From 78f7f5c88be76892bb075c0b54d4e54f99cc6d94 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:10:08 +0000
Subject: [PATCH 01/19] =?UTF-8?q?=EC=8B=9C=EC=9E=91=20=E2=80=94=20Ferrow?=
 =?UTF-8?q?=20=EA=B0=80=20=ED=8C=A8=EB=84=90=20=EC=9C=84=EC=97=90=EC=84=9C?=
 =?UTF-8?q?=20=EC=9B=80=EC=A7=81=EC=9D=B4=EA=B3=A0=20=EB=91=98=EB=A0=88?=
 =?UTF-8?q?=EC=97=90=20=EC=9D=B4=ED=8E=99=ED=8A=B8=EB=A5=BC=20=EB=82=B8?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr

From e46c8794d3129d81163bc3fc8a3f74fb88337518 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:29:32 +0000
Subject: [PATCH 02/19] =?UTF-8?q?Ferrow=20=EA=B0=80=20=EC=B9=BC=EC=9D=84?=
 =?UTF-8?q?=20=EA=BD=82=EA=B3=A0,=20=EC=A6=9D=EA=B8=B0=EB=A5=BC=20?=
 =?UTF-8?q?=EB=BF=9C=EA=B3=A0,=20=EB=88=88=EC=9D=84=20=EB=8F=8C=EB=A6=B0?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

노브 1 은 움직임, 노브 3 은 이펙트로 바꾸고 디테일 컷은 K3 탭으로 옮긴다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 490 +++++++++++++++++++---
 1 file changed, 440 insertions(+), 50 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 81e75154..410495b1 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -1,7 +1,7 @@
 // ===== Patternflow pattern =====
 // Title:   Ferrow
 // Family:  pixel
-// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, his visor shutters blink, the tabard swings, and now and then the case light runs along the steel.
+// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he takes the sword off his shoulder, raises it upright and drives its point into the stand in a spray of sparks, leans on it a while and shoulders it again.
 // Author:  patternflow-lab
 // Date:    2026-11-01
 // SPDX-License-Identifier: CC-BY-SA-4.0
@@ -9,19 +9,19 @@
 // Round:   86
 // ===============================
 // @matrix 64x128
-// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1
+// @knobs Motion=0..1, Stand=0..3, Effect=0..1, Edition=0..1
 //
-// Knob 1: Gel. The colour of the rim light down his left edges and of the bounce it throws into the shadows beside it: sky blue at 0, magenta from 0.25, green from 0.5, warm white from 0.75.
+// Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard, the sword planted and his eyes flared; from 0.75 he is on standby with dimmed eyes, breathing and blinking only.
 // Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.
-// Knob 3: Detail. Below 0.5 the whole figure; from 0.5 his head, chest and sword hand at exactly twice the size, the way a box shows a close-up.
+// Knob 3: Effect. What comes off him: steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that turns his gunmetal and rim live blue with arcs crawling off his outline; from 0.5 an overheat, the gunmetal glowing red and hotter on each in-breath, with heavy steam; from 0.75 none.
 // Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.
-// Buttons: K1 tap sends the case light along him; K2 tap makes the sword's point wink.
+// Buttons: K1 tap makes him plant the sword now; K2 tap sends the case light along him; K3 tap toggles the detail cut, his head, chest and sword hand at exactly twice the size; K4 tap makes the sword's point wink.
 
 const W = 64, H = 128;
 // Each part is a grid, one character per LED and "." where it is clear, drawn
 // in ORDER. Materials run light to dark: enamel a b c d, gunmetal g h i j,
 // tabard p q r s, blade steel m n o. C I R O are the shadow-side bounce next to
-// the rim light z, which the gels recolour. f u v are the hot amber of the
+// the rim light z. f u v are the hot amber of the
 // fuller and the eyes, x the dark of the visor, w the specular. U V X N are the stand.
 const PARTS = {
   base: { x: 6, y: 111, rows: [
@@ -438,23 +438,235 @@ const PARTS = {
     ".jihhgg.",
     "..ihhh..",
   ] },
-};
-const ORDER = ["base", "pack", "blade", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "neck", "paulfar", "armfar", "paulnear", "armnear", "head", "hilt", "fistfar"];
-// Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways.
-const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1};
-// The visor shutters half shut and shut, laid over the head.
-const LIDS = {
-  half: { x: 33, y: 23, rows: [
-    "xxxx.....",
-    "xxxx....xxx",
+  torso_u: { x: 38, y: 47, rows: [
+    ".bbb.....",
+    "bbbb...c.",
+    "..b....c.",
+    ".......dd",
+  ] },
+  paulfar_u: { x: 45, y: 45, rows: [
+    ".b.",
+    "bb.",
+    "bb.",
+    ".i.",
+    ".ii",
+    "..j",
+  ] },
+  chest_u: { x: 41, y: 43, rows: [
+    "bb.....",
+    "b......",
+    "...cb..",
+    ".......",
+    "..b....",
+    ".......",
+    ".......",
+    ".......",
+    ".....dd",
+  ] },
+  armfar_m: { x: 49, y: 40, rows: [
+    "......c......",
+    "....cccbb....",
+    "...dcccbba...",
+    "...dcccbba...",
+    "..ddcccbbaa..",
+    "...ddccbbaa..",
+    "...ddccbbaa..",
+    "...ddccbbaa..",
+    "..jdcccbbaa..",
+    ".jiddccbbaa..",
+    "jjjdddcbbaaa.",
+    "zIIdddcbbaaa.",
+    "zIIidccbbaaa.",
+    ".zIIcccbbaaa.",
+    "..zICccbbaaa.",
+    "...zCCcbbaaa.",
+    "....zCCbbaaaa",
+    "....zCCbbaaaa",
+    "....zCCbbaaaa",
+    ".....zCbbaaa.",
+    "......zbbaa..",
+    ".......zba...",
+  ] },
+  headrim: { x: 19, y: 11, rows: [
+    "....z",
+    "...z.",
+    "..z..",
+    ".z...",
+    ".z...",
+    ".zCC.",
+    ".zCC.",
+    "zCC..",
+    "zCC..",
+    "zCC..",
+  ] },
+  blade_m: { x: 52, y: 4, rows: [
+    "..z...",
+    "..z...",
+    ".zOO..",
+    ".zOO..",
+    ".zOOn.",
+    "zIOon.",
+    "zIOonn",
+    "zIOonn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIvvnn",
+    "zIOonn",
+    "zIOonn",
+    "zIOonn",
+    "zIOonn",
   ] },
-  shut: { x: 33, y: 23, rows: [
-    "xxxx.......",
-    "xxxx....xxx",
-    "vvvv....vvv",
-    "xxxx....xxx",
+  hilt_m: { x: 49, y: 34, rows: [
+    "zIIgggggggggg",
+    "zIIhhhhhhhhhh",
+    ".............",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....sir.....",
+    ".....igg.....",
+    "....hhggh....",
+    ".....hhh.....",
+    "......h......",
+  ] },
+  fist_m: { x: 51, y: 37, rows: [
+    "...jhg...",
+    "..jihgg..",
+    ".jiihhgw.",
+    "jjiihhggg",
+    "jjjjhhggg",
+    "jjiijjggg",
+    ".jiihhjg.",
+    "..jihgg..",
+    "...jhg...",
+  ] },
+  armfar_b: { x: 49, y: 48, rows: [
+    "..jhg........",
+    ".jihhg.......",
+    "jjihhgg......",
+    "zIIihhgg.....",
+    "zIIihhhgg....",
+    ".zIIihhbba...",
+    "..zjiibbbaa..",
+    "...jjcbbbaaa.",
+    "....ccbbbaaaa",
+    "...cccbbbaaaa",
+    "..dcccbbbaaaa",
+    "..dcccbbbaaa.",
+    ".ddcccbbbaa..",
+    "..dcccbbba...",
+    "..dcccbbb....",
+    "...cccbb.....",
+    ".....c.......",
+  ] },
+  blade_b: { x: 50, y: 67, rows: [
+    "zIOoooo",
+    "zIOoooo",
+    "zIOoonn",
+    "zIOoonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "zIOvonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "zIOvonn",
+    "zIOvonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiovonn",
+    "iiooonn",
+    "iiooonn",
+    "iiooonn",
+    "iiooonn",
+    ".iooon.",
+    ".iooon.",
+    ".iooon.",
+    "..ooo..",
+    "..ooo..",
+    "..ooo..",
+    "...o...",
+    "...o...",
+  ] },
+  hilt_b: { x: 47, y: 53, rows: [
+    "......h......",
+    ".....hgg.....",
+    "....zhggh....",
+    ".....hhh.....",
+    "......h......",
+    ".............",
+    ".............",
+    ".............",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    "zIIhhhhgggggg",
+    "zIIiiihhhhhhh",
+  ] },
+  fist_b: { x: 49, y: 56, rows: [
+    "...zhg...",
+    "..zIhgg..",
+    ".zIIhhgw.",
+    "zIIihhggg",
+    "zIIjhhggg",
+    "zIIijjggg",
+    ".zIIhhjg.",
+    "..zIhgg..",
+    "...zhg...",
   ] },
 };
+// The three poses: the sword on the shoulder, held upright, and planted.
+const ORDER = ["base", "pack", "blade", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "neck", "paulfar", "armfar", "paulnear", "armnear", "head", "hilt", "fistfar"];
+const ORDER_M = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_m", "paulnear", "armnear", "head", "headrim", "blade_m", "hilt_m", "fist_m"];
+const ORDER_B = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_b", "paulnear", "armnear", "head", "headrim", "blade_b", "hilt_b", "fist_b"];
+// Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.
+const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2};
 const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075 };
 // Knob 4: the editions, each a hand-picked repaint of some materials.
 const EDITIONS = [
@@ -470,30 +682,63 @@ const STANDS = [
   {  },
   { U: 0x00658c, V: 0x00bcd9, X: 0x0084a8, N: 0xc1f8f9 },
 ];
-// Knob 1: the gels on the rim light, with the shadow-side bounce they tint.
-const GELS = [
-  {  },
-  { z: 0xfb6acd, C: 0xa77096, I: 0x6a3f86, R: 0x8a3577, O: 0x8a5ba6 },
-  { z: 0x81ef7e, C: 0x88a184, I: 0x2f6b6a, R: 0x4f6a5a, O: 0x5b9a8a },
-  { z: 0xfff1d0, C: 0xbcaa98, I: 0x6a6a8a, R: 0x86506e, O: 0x8f95ae },
+// Knob 3: what the frame does to the steel. Steam and off leave it; the charge
+// turns the gunmetal and the rim to a live blue; the overheat runs the gunmetal
+// red hot, one shade hotter on each in-breath.
+// Z is the arcs, a shade apart from the charged rim.
+const CHARGE = { g: 0xa6dcf2, h: 0x5a8fc8, i: 0x3a5aa0, j: 0x2c3480, I: 0x4a70b0, z: 0xc8f0ff, O: 0x6aa0d0, Z: 0x6fd0ff };
+const HEAT = [
+  { g: 0xf0a070, h: 0xc05a48, i: 0x86344c, j: 0x56265a, I: 0x7a3a5a },
+  { g: 0xffc080, h: 0xe07448, i: 0xa0404a, j: 0x642a5c, I: 0x8a4058 },
 ];
-// The wink on the sword's point: x, y and what the LED turns into.
-const GLINT = [[10, 5, "w"], [9, 4, "w"], [11, 5, "w"]];
 // The case light: what a glossy character turns into while the band passes.
 const UP = {"n": "m", "o": "n", "O": "n", "h": "g", "i": "h", "I": "h", "j": "i"};
+// The eyes, x, y and colour, painted over the visor each frame so they can
+// look aside a pixel, half shut, shut to an ember line, flare or dim.
+const EYES = [[33, 23, "u"], [34, 23, "u"], [35, 23, "w"], [43, 23, "u"], [44, 23, "w"],
+  [33, 24, "u"], [34, 24, "f"], [35, 24, "f"], [36, 24, "f"], [37, 24, "u"], [41, 24, "u"], [42, 24, "f"], [43, 24, "f"], [44, 24, "u"],
+  [34, 25, "u"], [35, 25, "f"], [36, 25, "u"], [37, 25, "u"], [41, 25, "u"], [42, 25, "u"], [43, 25, "u"]];
+const FLARE = { u: "f", f: "w", w: "w" };
+const DIM = { u: "v", f: "u", w: "f" };
+// The wink on the sword's point: x, y and what the LED turns into.
+const GLINT = [[10, 5, "w"], [9, 4, "w"], [11, 5, "w"]];
+// Where the planted point bites the stand, and the glow it throws on the rim.
+const BITE_X = 53, BITE_Y = 116;
+const SPILL = [[51, 118, "u"], [52, 118, "f"], [53, 118, "f"], [54, 118, "f"], [55, 118, "u"], [52, 119, "u"], [53, 119, "u"], [54, 119, "u"]];
+// The flash at the moment of the bite, for its first two fifteenths of a second.
+const FLASH = [[53, 113, "w"], [52, 115, "w"], [54, 115, "w"], [51, 115, "f"], [55, 115, "f"], [53, 114, "f"], [50, 116, "u"], [56, 116, "u"]];
+// The two exhaust mouths, and the shape of a puff as it ages: x, y off its
+// centre and the colour, lightest while young.
+const STACKS = [[16, 27, 0], [10, 30, 0.5]];
+const PUFF = [
+  [[0, 0, "n"], [1, 0, "n"]],
+  [[0, 0, "n"], [1, 0, "n"], [0, -1, "n"], [1, -1, "o"]],
+  [[0, 0, "o"], [1, 0, "n"], [2, 0, "o"], [0, -1, "o"], [1, -1, "n"], [2, -1, "o"]],
+  [[0, 0, "h"], [1, 0, "o"], [2, 0, "h"], [0, -1, "h"], [1, -1, "h"], [2, -1, "h"]],
+  [[0, 0, "h"], [1, 0, "h"]],
+];
+const BIG = [[0, 0, "o"], [1, 0, "n"], [2, 0, "n"], [3, 0, "o"], [0, -1, "o"], [1, -1, "n"], [2, -1, "o"], [3, -1, "h"], [1, -2, "o"], [2, -2, "h"]];
 
-const { floor, min, max } = Math;
+const { floor, min, max, abs, sin, cos, PI } = Math;
 // The events run on a fixed loop of exactly eight breaths, so they always meet
 // the breath at the same phase. Blinks come 2 to 3.3 s apart and never while
 // the head is moving; the case light every 6.8 s, taking 2.4 s to cross, at a
-// phase where no breath step meets its edge; the glint on the point every 6 or
-// more. None falls between 1.5 and 2.5 s, where the still is taken.
+// phase where no breath step meets its edge; the glint on the point every 3 or
+// more, always while the sword is on the shoulder. The sword comes down twice
+// a loop and the eyes glance aside between. None falls between 1.5 and 2.5 s,
+// where the still is taken.
 const CYCLE = 27.2;
 const BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];
 const SWEEPS = [4.3, 11.1, 17.9, 24.7];
-const GLINTS = [3.0, 9.6, 15.8, 22.0];
+const GLINTS = [3.0, 12.6, 15.8, 25.0];
+const PLANTS = [7.0, 20.6];
+const PLANTS_KEEN = [0.2, 7.0, 13.8, 20.6];
+const SCANS = [[4.8, -1, 1.1], [10.95, 1, 0.9], [15.2, -1, 1.1], [18.4, 1, 1.0], [24.4, -1, 1.2]];
 const SWEEP_LEN = 2.4;
 const GLINT_LEN = 0.17;
+// The big move: the sword comes off the shoulder upright, bites the stand
+// point first at LIFT, is leant on until DOWN, and goes back up the same way.
+const LIFT = 0.23, DOWN = 3.23, PLANT_LEN = 3.46;
 // One breath is 3.4 s: the chest rises a pixel, the head follows a quarter
 // second later, and the tabard's hem swings a pixel sideways a beat after
 // that; both ends of each move are held longer than the moves between them.
@@ -510,7 +755,13 @@ function since(list, t, len) {
   return -1;
 }
 
-function lut(ed, stand, gel) {
+function hash(n) {
+  n = Math.imul(n ^ (n >>> 16), 0x45d9f3b);
+  n = Math.imul(n ^ (n >>> 16), 0x45d9f3b);
+  return (n ^ (n >>> 16)) >>> 0;
+}
+
+function lut(ed, stand, fx, tier) {
   const t = new Int32Array(128).fill(-1);
   const put = (p) => {
     for (const ch in p) t[ch.charCodeAt(0)] = p[ch];
@@ -518,7 +769,8 @@ function lut(ed, stand, gel) {
   put(PAL);
   put(EDITIONS[ed]);
   put(STANDS[stand]);
-  put(GELS[gel]);
+  if (fx === 1) put(CHARGE);
+  if (fx === 2) put(HEAT[tier]);
   return t;
 }
 
@@ -546,14 +798,99 @@ function blit(buf, part, dx, dy, sweep, band) {
   }
 }
 
+// Into clear LEDs only, so it passes behind the figure.
+function under(buf, x, y, ch) {
+  if (x < 0 || x >= W || y < 0 || y >= H) return;
+  const i = y * W + x;
+  if (!buf[i]) buf[i] = ch.charCodeAt(0);
+}
+
+function over(buf, x, y, ch) {
+  if (x < 0 || x >= W || y < 0 || y >= H) return;
+  buf[y * W + x] = ch.charCodeAt(0);
+}
+
+// Seconds since the sword started down, or -1.
+function plantSince(p, t) {
+  const list = p.motion === 0 ? PLANTS : p.motion === 1 ? PLANTS_KEEN : null;
+  let d = list ? since(list, t, PLANT_LEN) : -1;
+  const b = t - p.plantAt;
+  if (b >= 0 && b < PLANT_LEN) d = b;
+  return d;
+}
+
+function steam(buf, tt, heavy) {
+  const period = heavy ? 0.12 : 0.2, life = heavy ? 2.4 : 1.8;
+  for (let s = 0; s < STACKS.length; s++) {
+    const [x0, y0, off] = STACKS[s];
+    const k1 = floor(tt / period - off);
+    for (let k = max(0, k1 - floor(life / period) - 1); k <= k1; k++) {
+      const age = tt - (k + off) * period;
+      if (age < 0 || age >= life) continue;
+      const a = age / life;
+      const wob = floor(sin(age * 2.6 + k * 1.7) + 0.5);
+      const x = floor(x0 - age * 2.5 + wob + 0.5), y = floor(y0 - 1 - age * 9 + 0.5);
+      const shape = heavy && a >= 0.25 && a < 0.6 ? BIG : PUFF[min(4, floor(a * 5))];
+      for (let n = 0; n < shape.length; n++) under(buf, x + shape[n][0], y + shape[n][1], shape[n][2]);
+    }
+  }
+}
+
+function sparks(buf, sd, tt0, tt, seed) {
+  for (let n = 0; n < 14; n++) {
+    const h = hash(seed * 31 + n);
+    const ang = -PI * (0.4 + 0.45 * (h & 1023) / 1023);
+    const sp = 50 + ((h >>> 10) & 31), life = 0.4 + ((h >>> 15) & 15) / 30;
+    const age = tt - tt0;
+    if (age < 0 || age >= life) continue;
+    const at = (q) => [floor(BITE_X + cos(ang) * sp * q + 0.5), floor(BITE_Y + sin(ang) * sp * q + 55 * q * q + 0.5)];
+    const [x, y] = at(age);
+    if (y > BITE_Y + 2) continue;
+    const [px, py] = at(max(0, age - 1 / 15));
+    const steps = max(abs(x - px), abs(y - py));
+    for (let k = 1; k < steps; k++) over(buf, px + floor((x - px) * k / steps + 0.5), py + floor((y - py) * k / steps + 0.5), age < 0.35 ? "u" : "v");
+    over(buf, x, y, age < 0.14 ? "w" : age < 0.45 ? "f" : "u");
+  }
+}
+
+// The arcs for one tenth of a second, worked out once from where the outline
+// is when it starts and drawn over whatever moves under it, so a breath step
+// inside it cannot make an LED flick for one frame.
+function arcs(buf, slot) {
+  const out = [];
+  const h = hash(slot * 7 + 3);
+  if ((h & 3) === 0) return out;
+  const count = h & 16 ? 2 : 1;
+  for (let a = 0; a < count; a++) {
+    const g = hash(h + a * 101);
+    const y0 = 22 + (g % 88), left = (g >>> 8) & 1;
+    let x = -1;
+    if (left) { for (let i = 0; i < W; i++) if (buf[y0 * W + i]) { x = i; break; } }
+    else { for (let i = W - 1; i >= 0; i--) if (buf[y0 * W + i]) { x = i; break; } }
+    if (x < 0) continue;
+    let y = y0;
+    const len = 3 + ((g >>> 10) % 4);
+    for (let k = 1; k <= len; k++) {
+      x += left ? -1 : 1;
+      y += ((g >>> (12 + k * 2)) % 3) - 1;
+      if (y >= 0 && y < H && x >= 0 && x < W && !buf[y * W + x]) out.push([x, y, k === 1 ? "w" : "Z"]);
+    }
+  }
+  return out;
+}
+
 export function setup(params) {
   params.t = 0;
   params.buf = new Uint8Array(W * H);
   params.key = -1;
   params.sweepAt = -10;
   params.glintAt = -10;
-  params.gel = 0;
+  params.plantAt = -10;
+  params.arcSlot = -1;
+  params.arcPix = [];
+  params.motion = 0;
   params.stand = 2;
+  params.fx = 0;
   params.zoom = false;
   params.ed = 0;
 }
@@ -562,30 +899,39 @@ export function update(dt, input, params) {
   if (!params.buf) setup(params);
   const k = input.knobValues || [0, 2, 0, 0.06];
   params.t += min(dt || 0, 0.1);
-  params.gel = min(3, max(0, floor(k[0] * 4)));
+  params.motion = min(3, max(0, floor(k[0] * 4)));
   params.stand = min(3, max(0, floor(k[1])));
-  params.zoom = k[2] >= 0.5;
+  params.fx = min(3, max(0, floor(k[2] * 4)));
   params.ed = min(3, max(0, floor(k[3] * 4)));
   const b = input.btnPressed;
-  if (b && b[0]) params.sweepAt = params.t;
-  if (b && b[1]) params.glintAt = params.t;
+  if (b && b[0] && plantSince(params, params.t) < 0) params.plantAt = params.t;
+  if (b && b[1]) params.sweepAt = params.t;
+  if (b && b[2]) params.zoom = !params.zoom;
+  if (b && b[3]) params.glintAt = params.t;
 }
 
 export function draw(display, params) {
   const p = params;
   if (!p.buf) setup(p);
   const t = p.t;
-  const key = p.ed * 16 + p.stand * 4 + p.gel;
-  if (key !== p.key) {
-    p.key = key;
-    p.lut = lut(p.ed, p.stand, p.gel);
-  }
+  // Steam, sparks and arcs step at 15 a second, so no LED holds a state for
+  // a single frame.
+  const tt = floor(t * 15 + 0.25) / 15;
   const buf = p.buf;
   buf.fill(0);
 
   const u = (((t - 1.5) % BREATH) + BREATH) % BREATH;
-  const dy = [0, u >= 1.1 && u < 2.8 ? -1 : 0, u >= 1.35 && u < 3.05 ? -1 : 0, 0];
-  const dx = [0, 0, 0, u >= 1.45 && u < 3.15 ? -1 : 0];
+  const dy = [0, u >= 1.1 && u < 2.8 ? -1 : 0, u >= 1.35 && u < 3.05 ? -1 : 0, 0, 0];
+  const dx = [0, 0, 0, u >= 1.45 && u < 3.15 ? -1 : 0, 0];
+
+  // Shouldered, upright, or planted; guard mode keeps it planted.
+  const d = plantSince(p, t);
+  let pose = p.motion === 2 ? 2 : 0;
+  if (d >= 0) pose = d < LIFT ? 1 : d < DOWN || p.motion === 2 ? 2 : 1;
+  const sd = d >= LIFT ? d - LIFT : -1;
+  // The bite goes through him: the head drops a pixel, the chest after it.
+  if (sd >= 0 && sd < 0.27) dy[2] += 1;
+  if (sd >= 0.07 && sd < 0.23) dy[1] += 1;
 
   let sw = since(SWEEPS, t, SWEEP_LEN);
   if (t - p.sweepAt < SWEEP_LEN) sw = t - p.sweepAt;
@@ -593,23 +939,67 @@ export function draw(display, params) {
   const band = -8 + (sw / SWEEP_LEN) * (W + H * 0.5 + 16);
 
   // The case light passes over the steel above the stand; the legs and the stand keep still.
-  for (let n = 0; n < ORDER.length; n++) {
-    const name = ORDER[n], g = GROUP[name];
+  const order = pose === 0 ? ORDER : pose === 1 ? ORDER_M : ORDER_B;
+  for (let n = 0; n < order.length; n++) {
+    const name = order[n], g = GROUP[name];
     blit(buf, PARTS[name], dx[g], dy[g], sweep && g !== 0, band);
   }
 
+  // The eyes: clear the visor behind them, then paint them where they look.
+  const hy = dy[2];
+  for (let y = 23; y <= 25; y++) {
+    for (let x = 31; x <= 46; x++) {
+      const i = (y + hy) * W + x, c = buf[i];
+      if (c === 117 || c === 102 || c === 119) buf[i] = 120;
+    }
+  }
   const db = since(BLINKS, t, 0.3);
-  if (db >= 0) blit(buf, db < 0.08 || db >= 0.2 ? LIDS.half : LIDS.shut, 0, dy[2], false, 0);
+  const lid = db < 0 ? 0 : db < 0.08 || db >= 0.2 ? 1 : 2;
+  let look = 0;
+  if (d < 0 && p.motion !== 3) {
+    const u2 = t % CYCLE;
+    for (let s = 0; s < SCANS.length; s++) if (u2 >= SCANS[s][0] && u2 < SCANS[s][0] + SCANS[s][2]) look = SCANS[s][1];
+  }
+  const mood = (d >= 0 && d < 1.4) || p.motion === 2 ? FLARE : p.motion === 3 ? DIM : null;
+  for (let e = 0; e < EYES.length; e++) {
+    const [x, y, c] = EYES[e];
+    if (lid === 1 && y === 23) continue;
+    if (lid === 2 && y !== 24) continue;
+    over(buf, x + look, y + hy, lid === 2 ? "v" : mood ? mood[c] : c);
+  }
 
   let dg = since(GLINTS, t, GLINT_LEN);
   if (t - p.glintAt < GLINT_LEN) dg = t - p.glintAt;
-  if (dg >= 0) {
+  if (dg >= 0 && pose === 0) {
     for (let i = 0; i < GLINT.length; i++) {
       const g = GLINT[i], at = (g[1] + dy[1]) * W + g[0];
       if (buf[at]) buf[at] = g[2].charCodeAt(0);
     }
   }
 
+  const fx = p.fx;
+  if (fx === 0 || fx === 2) steam(buf, tt, fx === 2);
+  if (fx === 1) {
+    const slot = floor(t * 10 + 0.25);
+    if (slot !== p.arcSlot) {
+      p.arcSlot = slot;
+      p.arcPix = arcs(buf, slot);
+    }
+    for (let i = 0; i < p.arcPix.length; i++) over(buf, p.arcPix[i][0], p.arcPix[i][1], p.arcPix[i][2]);
+  }
+  if (fx !== 3 && sd >= 0 && sd < 0.9) {
+    const t0 = t - sd;
+    sparks(buf, sd, floor(t0 * 15 + 0.25) / 15, tt, floor(t0 * 10));
+    if (sd < 0.3) for (let i = 0; i < SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd < 0.15 ? SPILL[i][2] : "v");
+    if (sd < 0.14) for (let i = 0; i < FLASH.length; i++) over(buf, FLASH[i][0], FLASH[i][1], FLASH[i][2]);
+  }
+
+  const tier = fx === 2 && dy[1] < 0 ? 1 : 0;
+  const key = p.ed * 64 + p.stand * 16 + fx * 4 + tier;
+  if (key !== p.key) {
+    p.key = key;
+    p.lut = lut(p.ed, p.stand, fx, tier);
+  }
   const L = p.lut;
   for (let y = 0; y < H; y++) {
     for (let x = 0; x < W; x++) {

From c02e966e029a56c194f6a57bd5def162828f906e Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:32:25 +0000
Subject: [PATCH 03/19] =?UTF-8?q?Ferrow=20=EC=9D=98=20=EC=9B=80=EC=A7=81?=
 =?UTF-8?q?=EC=9E=84=EC=9D=84=20=EC=B4=88=EB=8B=B9=2015=EB=B2=88=20?=
 =?UTF-8?q?=EA=B1=B8=EC=9D=8C=EC=9C=BC=EB=A1=9C=20=EB=A7=9E=EC=B6=98?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

한 프레임만 바뀌는 LED 가 노브와 버튼 어디서도 나오지 않게 한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 80 ++++++++++++-----------
 1 file changed, 43 insertions(+), 37 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 410495b1..8ff7c242 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -667,7 +667,7 @@ const ORDER_M = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard",
 const ORDER_B = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_b", "paulnear", "armnear", "head", "headrim", "blade_b", "hilt_b", "fist_b"];
 // Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.
 const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2};
-const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075 };
+const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xa8bad4, T: 0x93a3c2, Y: 0x6a7aa6 };
 // Knob 4: the editions, each a hand-picked repaint of some materials.
 const EDITIONS = [
   {  },
@@ -708,16 +708,17 @@ const SPILL = [[51, 118, "u"], [52, 118, "f"], [53, 118, "f"], [54, 118, "f"], [
 // The flash at the moment of the bite, for its first two fifteenths of a second.
 const FLASH = [[53, 113, "w"], [52, 115, "w"], [54, 115, "w"], [51, 115, "f"], [55, 115, "f"], [53, 114, "f"], [50, 116, "u"], [56, 116, "u"]];
 // The two exhaust mouths, and the shape of a puff as it ages: x, y off its
-// centre and the colour, lightest while young.
+// centre and the colour, lightest while young. The steam has its own letters,
+// S T Y, so no repaint of the steel reaches it.
 const STACKS = [[16, 27, 0], [10, 30, 0.5]];
 const PUFF = [
-  [[0, 0, "n"], [1, 0, "n"]],
-  [[0, 0, "n"], [1, 0, "n"], [0, -1, "n"], [1, -1, "o"]],
-  [[0, 0, "o"], [1, 0, "n"], [2, 0, "o"], [0, -1, "o"], [1, -1, "n"], [2, -1, "o"]],
-  [[0, 0, "h"], [1, 0, "o"], [2, 0, "h"], [0, -1, "h"], [1, -1, "h"], [2, -1, "h"]],
-  [[0, 0, "h"], [1, 0, "h"]],
+  [[0, 0, "S"], [1, 0, "S"]],
+  [[0, 0, "S"], [1, 0, "S"], [0, -1, "S"], [1, -1, "T"]],
+  [[0, 0, "T"], [1, 0, "S"], [2, 0, "T"], [0, -1, "T"], [1, -1, "S"], [2, -1, "T"]],
+  [[0, 0, "Y"], [1, 0, "T"], [2, 0, "Y"], [0, -1, "Y"], [1, -1, "T"], [2, -1, "Y"]],
+  [[0, 0, "Y"], [1, 0, "Y"]],
 ];
-const BIG = [[0, 0, "o"], [1, 0, "n"], [2, 0, "n"], [3, 0, "o"], [0, -1, "o"], [1, -1, "n"], [2, -1, "o"], [3, -1, "h"], [1, -2, "o"], [2, -2, "h"]];
+const BIG = [[0, 0, "T"], [1, 0, "S"], [2, 0, "S"], [3, 0, "T"], [0, -1, "T"], [1, -1, "S"], [2, -1, "T"], [3, -1, "Y"], [1, -2, "T"], [2, -2, "Y"]];
 
 const { floor, min, max, abs, sin, cos, PI } = Math;
 // The events run on a fixed loop of exactly eight breaths, so they always meet
@@ -811,8 +812,8 @@ function over(buf, x, y, ch) {
 }
 
 // Seconds since the sword started down, or -1.
-function plantSince(p, t) {
-  const list = p.motion === 0 ? PLANTS : p.motion === 1 ? PLANTS_KEEN : null;
+function plantSince(p, t, motion) {
+  const list = motion === 0 ? PLANTS : motion === 1 ? PLANTS_KEEN : null;
   let d = list ? since(list, t, PLANT_LEN) : -1;
   const b = t - p.plantAt;
   if (b >= 0 && b < PLANT_LEN) d = b;
@@ -836,7 +837,7 @@ function steam(buf, tt, heavy) {
   }
 }
 
-function sparks(buf, sd, tt0, tt, seed) {
+function sparks(buf, tt0, tt, seed) {
   for (let n = 0; n < 14; n++) {
     const h = hash(seed * 31 + n);
     const ang = -PI * (0.4 + 0.45 * (h & 1023) / 1023);
@@ -853,14 +854,13 @@ function sparks(buf, sd, tt0, tt, seed) {
   }
 }
 
-// The arcs for one tenth of a second, worked out once from where the outline
-// is when it starts and drawn over whatever moves under it, so a breath step
-// inside it cannot make an LED flick for one frame.
+// The arcs for two fifteenths of a second, worked out once from where the
+// outline is when they start.
 function arcs(buf, slot) {
   const out = [];
   const h = hash(slot * 7 + 3);
-  if ((h & 3) === 0) return out;
-  const count = h & 16 ? 2 : 1;
+  if ((h & 7) === 0) return out;
+  const count = 1 + ((h >>> 4) & 1) + ((h >>> 5) & 1);
   for (let a = 0; a < count; a++) {
     const g = hash(h + a * 101);
     const y0 = 22 + (g % 88), left = (g >>> 8) & 1;
@@ -869,7 +869,7 @@ function arcs(buf, slot) {
     else { for (let i = W - 1; i >= 0; i--) if (buf[y0 * W + i]) { x = i; break; } }
     if (x < 0) continue;
     let y = y0;
-    const len = 3 + ((g >>> 10) % 4);
+    const len = 4 + ((g >>> 10) % 5);
     for (let k = 1; k <= len; k++) {
       x += left ? -1 : 1;
       y += ((g >>> (12 + k * 2)) % 3) - 1;
@@ -893,6 +893,8 @@ export function setup(params) {
   params.fx = 0;
   params.zoom = false;
   params.ed = 0;
+  params.tick = -1;
+  params.now = [0, 2, 0, 0, false];
 }
 
 export function update(dt, input, params) {
@@ -904,7 +906,7 @@ export function update(dt, input, params) {
   params.fx = min(3, max(0, floor(k[2] * 4)));
   params.ed = min(3, max(0, floor(k[3] * 4)));
   const b = input.btnPressed;
-  if (b && b[0] && plantSince(params, params.t) < 0) params.plantAt = params.t;
+  if (b && b[0] && plantSince(params, params.t, params.motion) < 0) params.plantAt = params.t;
   if (b && b[1]) params.sweepAt = params.t;
   if (b && b[2]) params.zoom = !params.zoom;
   if (b && b[3]) params.glintAt = params.t;
@@ -913,10 +915,15 @@ export function update(dt, input, params) {
 export function draw(display, params) {
   const p = params;
   if (!p.buf) setup(p);
-  const t = p.t;
-  // Steam, sparks and arcs step at 15 a second, so no LED holds a state for
-  // a single frame.
-  const tt = floor(t * 15 + 0.25) / 15;
+  // Everything steps at 15 a second, two of the Lab's frames, so no LED can
+  // hold a state for a single frame.
+  const tick = floor(p.t * 15 + 0.25), t = tick / 15;
+  // Knobs and the cut are taken at the step too.
+  if (tick !== p.tick) {
+    p.tick = tick;
+    p.now = [p.motion, p.stand, p.fx, p.ed, p.zoom];
+  }
+  const [motion, stand, fx, ed, zoom] = p.now;
   const buf = p.buf;
   buf.fill(0);
 
@@ -925,16 +932,16 @@ export function draw(display, params) {
   const dx = [0, 0, 0, u >= 1.45 && u < 3.15 ? -1 : 0, 0];
 
   // Shouldered, upright, or planted; guard mode keeps it planted.
-  const d = plantSince(p, t);
-  let pose = p.motion === 2 ? 2 : 0;
-  if (d >= 0) pose = d < LIFT ? 1 : d < DOWN || p.motion === 2 ? 2 : 1;
+  const d = plantSince(p, t, motion);
+  let pose = motion === 2 ? 2 : 0;
+  if (d >= 0) pose = d < LIFT ? 1 : d < DOWN || motion === 2 ? 2 : 1;
   const sd = d >= LIFT ? d - LIFT : -1;
   // The bite goes through him: the head drops a pixel, the chest after it.
   if (sd >= 0 && sd < 0.27) dy[2] += 1;
   if (sd >= 0.07 && sd < 0.23) dy[1] += 1;
 
   let sw = since(SWEEPS, t, SWEEP_LEN);
-  if (t - p.sweepAt < SWEEP_LEN) sw = t - p.sweepAt;
+  if (t >= p.sweepAt && t - p.sweepAt < SWEEP_LEN) sw = t - p.sweepAt;
   const sweep = sw >= 0;
   const band = -8 + (sw / SWEEP_LEN) * (W + H * 0.5 + 16);
 
@@ -956,11 +963,11 @@ export function draw(display, params) {
   const db = since(BLINKS, t, 0.3);
   const lid = db < 0 ? 0 : db < 0.08 || db >= 0.2 ? 1 : 2;
   let look = 0;
-  if (d < 0 && p.motion !== 3) {
+  if (d < 0 && motion !== 3) {
     const u2 = t % CYCLE;
     for (let s = 0; s < SCANS.length; s++) if (u2 >= SCANS[s][0] && u2 < SCANS[s][0] + SCANS[s][2]) look = SCANS[s][1];
   }
-  const mood = (d >= 0 && d < 1.4) || p.motion === 2 ? FLARE : p.motion === 3 ? DIM : null;
+  const mood = (d >= 0 && d < 1.4) || motion === 2 ? FLARE : motion === 3 ? DIM : null;
   for (let e = 0; e < EYES.length; e++) {
     const [x, y, c] = EYES[e];
     if (lid === 1 && y === 23) continue;
@@ -969,7 +976,7 @@ export function draw(display, params) {
   }
 
   let dg = since(GLINTS, t, GLINT_LEN);
-  if (t - p.glintAt < GLINT_LEN) dg = t - p.glintAt;
+  if (t >= p.glintAt && t - p.glintAt < GLINT_LEN) dg = t - p.glintAt;
   if (dg >= 0 && pose === 0) {
     for (let i = 0; i < GLINT.length; i++) {
       const g = GLINT[i], at = (g[1] + dy[1]) * W + g[0];
@@ -977,33 +984,32 @@ export function draw(display, params) {
     }
   }
 
-  const fx = p.fx;
-  if (fx === 0 || fx === 2) steam(buf, tt, fx === 2);
+  if (fx === 0 || fx === 2) steam(buf, t, fx === 2);
   if (fx === 1) {
-    const slot = floor(t * 10 + 0.25);
+    const slot = tick >> 1;
     if (slot !== p.arcSlot) {
       p.arcSlot = slot;
       p.arcPix = arcs(buf, slot);
     }
-    for (let i = 0; i < p.arcPix.length; i++) over(buf, p.arcPix[i][0], p.arcPix[i][1], p.arcPix[i][2]);
+    for (let i = 0; i < p.arcPix.length; i++) under(buf, p.arcPix[i][0], p.arcPix[i][1], p.arcPix[i][2]);
   }
   if (fx !== 3 && sd >= 0 && sd < 0.9) {
     const t0 = t - sd;
-    sparks(buf, sd, floor(t0 * 15 + 0.25) / 15, tt, floor(t0 * 10));
+    sparks(buf, t0, t, floor(t0 * 10 + 0.5));
     if (sd < 0.3) for (let i = 0; i < SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd < 0.15 ? SPILL[i][2] : "v");
     if (sd < 0.14) for (let i = 0; i < FLASH.length; i++) over(buf, FLASH[i][0], FLASH[i][1], FLASH[i][2]);
   }
 
   const tier = fx === 2 && dy[1] < 0 ? 1 : 0;
-  const key = p.ed * 64 + p.stand * 16 + fx * 4 + tier;
+  const key = ed * 64 + stand * 16 + fx * 4 + tier;
   if (key !== p.key) {
     p.key = key;
-    p.lut = lut(p.ed, p.stand, fx, tier);
+    p.lut = lut(ed, stand, fx, tier);
   }
   const L = p.lut;
   for (let y = 0; y < H; y++) {
     for (let x = 0; x < W; x++) {
-      const ch = p.zoom ? buf[(CUT_Y + (y >> 1)) * W + CUT_X + (x >> 1)] : buf[y * W + x];
+      const ch = zoom ? buf[(CUT_Y + (y >> 1)) * W + CUT_X + (x >> 1)] : buf[y * W + x];
       const c = ch ? L[ch] : -1;
       if (c < 0) display.setPixel(x, y, 0, 0, 0);
       else display.setPixel(x, y, (c >> 16) & 255, (c >> 8) & 255, c & 255);

From 7413b73a2d59e95faec342457dec30da47940cf7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:34:18 +0000
Subject: [PATCH 04/19] =?UTF-8?q?Ferrow=20=EC=B9=B4=EB=93=9C=EC=99=80=20?=
 =?UTF-8?q?=EA=B7=B8=EB=A6=BC=EC=97=90=20=EC=9B=80=EC=A7=81=EC=9E=84?=
 =?UTF-8?q?=EA=B3=BC=20=EC=9D=B4=ED=8E=99=ED=8A=B8=EB=A5=BC=20=EC=A0=81?=
 =?UTF-8?q?=EB=8A=94=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

창작자 요청(11-01 19:08)대로 노브와 버튼이 바뀐 것을 카드와 README 에 옮긴다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/README.md               |   2 +-
 .../pattern-study/craft/01-figure/brief.md     |  12 ++++++++----
 .../craft/01-figure/ferrow-86b-fx.gif          | Bin 0 -> 157703 bytes
 .../craft/01-figure/ferrow-86b.gif             | Bin 0 -> 137532 bytes
 .../pattern-study/craft/01-figure/look-86b.png | Bin 0 -> 65867 bytes
 5 files changed, 9 insertions(+), 5 deletions(-)
 create mode 100644 incoming/pattern-study/craft/01-figure/ferrow-86b-fx.gif
 create mode 100644 incoming/pattern-study/craft/01-figure/ferrow-86b.gif
 create mode 100644 incoming/pattern-study/craft/01-figure/look-86b.png

diff --git a/incoming/pattern-study/README.md b/incoming/pattern-study/README.md
index c955394a..0ee6c3ff 100644
--- a/incoming/pattern-study/README.md
+++ b/incoming/pattern-study/README.md
@@ -15,7 +15,7 @@
 | 패턴 | 작품 | 한 줄 |
 | --- | --- | --- |
 | [Tamsel](patterns/tamsel.js) | 작품 1 | 밤거리 가스등에 불을 붙이는 견습 점등꾼이 받침 위에 한 손은 허리에, 한 손은 갈고리 끝에 불씨를 매단 놋쇠 장대에 얹고 서서 숨 쉬고 깜빡여요. |
-| [Ferrow](patterns/ferrow.js) | 작품 1 | 무너진 성채의 문을 이백 년째 지키는 파수 로봇이 받침 위에 한 손은 허리에 얹고, 홈이 호박색으로 달아오른 대검을 어깨에 멘 채 숨 쉬고 눈 덮개를 깜빡여요. |
+| [Ferrow](patterns/ferrow.js) | 작품 1 | 무너진 성채의 문을 이백 년째 지키는 파수 로봇이 받침 위에 한 손은 허리에 얹고, 홈이 호박색으로 달아오른 대검을 어깨에 멘 채 숨 쉬며 증기를 뿜고, 가끔 그 대검을 받침에 꽂아 불꽃을 튀겨요. |
 
 ## 추려 보기
 
diff --git a/incoming/pattern-study/craft/01-figure/brief.md b/incoming/pattern-study/craft/01-figure/brief.md
index e2de3db8..2c67ece9 100644
--- a/incoming/pattern-study/craft/01-figure/brief.md
+++ b/incoming/pattern-study/craft/01-figure/brief.md
@@ -6,22 +6,26 @@ slug: ferrow
 
 11월 1일 16시 22분에 창작자가 「야 패턴 캐릭터 만든거 좀 별로야. 엄청 멋진 로봇캐릭터 해줘」라고 해서 Tamsel 카드를 이 카드로 바꿨어요. Tamsel 카드는 커밋 `7423fa4` 의 이 파일에 있어요.
 
+같은 날 19시 08분에 창작자가 「근데 움직임 구현같은건 안돼? 너무 정적인데. 아님 주변 이펙트라도... 어렵나..?」라고 해서 큰 동작 하나와 이펙트를 넣었어요. 림 젤 노브가 빠지고 그 자리에 움직임이, 디테일 컷 자리에 이펙트가 들어갔어요. 디테일 컷은 K3 탭으로 옮겼어요.
+
 - 성격: 늠름함, 과묵함
 - 시그니처: 제 키만 한 대검이에요. 날 가운데 홈이 막 단조한 쇠처럼 호박색으로 달아 있고, 오른 어깨에 걸친 날이 머리 뒤를 지나 왼쪽 위로 실루엣을 깨요.
 - 로봇인 표: 투구 틈 속 두 눈, 등 뒤로 솟은 배기통 둘, 귀 원반, 장갑 사이로 드러난 건메탈 배와 허리, 무릎 위 관절.
 - 재질: 반광 에나멜 장갑(뼈색), 광택 금속(건메탈 뼈대와 대검 날), 무광 천(허리에 늘어뜨린 자줏빛 휘장).
 - 광원: 키 라이트는 오른쪽 위에서 오는 따뜻한 빛이에요. 림은 왼쪽 가장자리의 차가운 하늘색 1px 이고, 그 옆 두 칸에 그늘 쪽 반사가 들어요.
 - 비례: 3.4등신. 키 111줄(볏 꼭대기에서 발바닥까지)에 머리 33줄이에요.
-- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임은 따로 돌아요.
+- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 1px 옆을 보는 것은 따로 돌아요. 등 배기통 둘에서 증기가 늘 올라요.
+- 큰 동작: 27.2초에 두 번, 대검을 어깨에서 들어 똑바로 세웠다가 칼끝을 받침에 꽂아요. 꽂히는 순간 눈이 하얗게 타고 머리와 가슴이 1px 내려앉고, 칼끝에서 불꽃이 튀고 받침 테에 빛이 번져요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요.
 - 강조색: 달군 쇠의 호박색. 대검의 홈과 두 눈에만 칠해요.
 - 이름판: 없어요. 받침 옆띠가 5줄이라 7줄이 안 돼요.
 
-노브 넷이에요.
+노브 넷과 버튼이에요.
 
-- K1 림 젤: 0 하늘색, 1/4 자홍, 1/2 초록, 3/4 따뜻한 흰빛. 림 1px 과 그늘 쪽 반사 두 칸을 같이 물들여요.
+- K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번), 1/2 경계(칼을 꽂은 채 눈을 밝히고 섬), 3/4 대기(눈을 낮추고 숨과 깜빡임만).
 - K2 받침: 0 나무, 1 흰 대리석, 2 검은 아크릴에 금 테(기본), 3 가장자리가 빛나는 아크릴.
-- K3 디테일 컷: 0.5 아래는 전신, 0.5 부터는 머리와 가슴, 칼 쥔 손을 정확히 2배로.
+- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈과 림이 푸르게 서고 윤곽에서 아크가 튐), 1/2 과열(건메탈이 붉게 달아 들숨마다 한 단 더 달고 증기가 짙음), 3/4 끔.
 - K4 에디션: 0 뼈색 기본 칠, 1/4 2P 검정과 청록, 1/2 금과 크롬 한정판, 3/4 무도색 원형.
+- 버튼: K1 탭 지금 칼 꽂기, K2 탭 진열장 빛 스윕, K3 탭 디테일 컷(머리와 가슴, 칼 쥔 손을 정확히 2배로) 켜고 끄기, K4 탭 칼끝 글린트.
 
 닮으면 안 되는 캐릭터 셋과, 각각과 다른 점 둘이에요.
 
diff --git a/incoming/pattern-study/craft/01-figure/ferrow-86b-fx.gif b/incoming/pattern-study/craft/01-figure/ferrow-86b-fx.gif
new file mode 100644
index 0000000000000000000000000000000000000000..9b417b9a131cd14eaaa0510cb9720a63c6f9e4ee
GIT binary patch
literal 157703
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%0D49RBm;8xoA<VzMV;WOn2-6?l
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
OjNb|`;(b8}&;J0xMs=+K

literal 0
HcmV?d00001

diff --git a/incoming/pattern-study/craft/01-figure/ferrow-86b.gif b/incoming/pattern-study/craft/01-figure/ferrow-86b.gif
new file mode 100644
index 0000000000000000000000000000000000000000..7ea22860ea42c255d9ed7ea399f6d1ba0a02e222
GIT binary patch
literal 137532
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

literal 0
HcmV?d00001

diff --git a/incoming/pattern-study/craft/01-figure/look-86b.png b/incoming/pattern-study/craft/01-figure/look-86b.png
new file mode 100644
index 0000000000000000000000000000000000000000..2cc39bba4ef214763426a09f04a14329908da57c
GIT binary patch
literal 65867
zcmZ_030zG3|3BWQq7+3WEtWz>Zlf`y_2QzHD@{#{&@xdmj7WP()^ep~Y7{P!rc$Rx
z(SDP*8KkKx?V6!Q+V}ds&P?I^dHnz8@fg(1Iq!4cujToAzMijh<B-MvrAyW<5fBhq
zYJ6btVF3Z*9RdR4z2ZXf6D6NrF#>{uGRAxVJmTHh+w6E<nfrk2>*y`6@I|%dt=q=6
zRkhwO|7Ncj%iX%^-Jtf(CrVQuRZc`k>}@t~RY{=Kz|GCX?X1;um)PQ%h++@UiDOzF
z>zpKCSLfEWc$;tItdCwd{yk`uCJA?UgJkaC+s<bsv17|edVG#B(`NOpMkaqO>(;n9
zH#wGk(7Il?)o|qVfYx>Rvst0JeZ{in%a;dZ*25nm(q8z}b{qXwkv#l(Ic@{`bMij;
zu?PeGu{aI=@&Dh)`9J4<eD8xIw&KOlXSok927IR^ydGlc_K!cfy1V^IiB9U+ZZT=4
z^S$0D%iSHdWLIvC-A-%1#C<R~9oWNYHQv0!LREwmrg#NI#_qvQedZci&!)_M?%%j#
z$upVDnDQ{OYskfb3lg+{s;P%I_i9ou+;uDNUcxx)-&vkkFwi*`I7lJy^I=@w{U{zj
zU9ROG<wwvY?`t#LyaN3?5`@4<hG<)s%4~6860%!ZFicTPilOc&_b9VHu1@8jV1Y-6
zaKXU>4*Q>Q=@BPuvL<@Z%nmYdjeOgrd>KPlqo}Q@q>bFe`*KM+H%HRunsv2zgsmFf
zd}j$QrI?fuFnBz-NFG-UAM3^olfsIL8aQ_*NqKH~f3gHE7+K!tF(l129PPG?3-oT$
zx7v(e>_J6Fz(lfRv~$#dq_Ui`8q(bZ#G%o4j&l5*VPHVA4Se+IS(DAQatdR1q|o=7
zeO|2FI(?EVtvQOh`^OSfYFT3h^K|nYL58G=<fq)}hU7Dm<WYD(*(0}vo4&^=2Cs4E
zfTRA*ogc5>oSCV3s*!;U<NkwpFCne$whcj=wxQPrOI{-`fG$~^)>lDF-jc4<Mqirn
z=X!k-dO!6^ZPf$S?H*Zo=wZxJx;5MktRQZxqdlTLew?#PI^i>BdeEBrAaFp}akd-3
z^Vp-88n~X<+}`A8h3VYM2vh6Ir$aY5A1HF|h<>fBryS0bwe~rEqO5e&T%W?+zc!9~
zei<@wAGotsfpZCElW?#k=fxor4eK5n%cXp`xllf^u`;&oOz-P{|09X-Tm1X~z016*
z<vsH;t6s}NLmB^?+a1S*9Sr&s9OQJ+4|$S~zRSeJid1Rnx_pX4N<74bim07WM`$S}
z>?y;EOSrWHi~}6A&G*sWQk0IyOH_D7GF#><m=fBziip#Hukp=J3dStl1OJhPx~+<T
z@3;|<h|^Y%)M$Ik1tV6YFPt*gYaU$+8{BKNRVmL-qL_U|o7Da#u{XA}!i8ZXWjAwB
zHKAFKQK|J@;fv;6{&>a)X+6r9U{Vn^!}X{Y!}~cy^#}_!2Ce|9f9?yn{X3`3XP`^@
zNE<yU1wM<IoLm<XX(I|-`~|1HOxo+Z#8QzUu;|cWWS4f6EW_eK!MX0?$W@NBf2I@K
zJt996sFJh_cr6YYWv%^AB~5;GI|oJ+T$bQR2u3cpPPrY#y&ka+pHA}{dK<rkFmbTW
zj7g2hJUYZA_EQloF>@W_-p;)j0>+)U!geD??g|o~Hq$woynl3jtWCLC9#`e>EnBfT
zq)n2BS6apBKJ2!L)@T3f=oZxJ%)@7-N?wph*@1$j%Gg}PQM08-z=Vwia1=cST=LbG
z1{wr#u?iuQs8B}B_M+jSL$6wlj85y5JSUmgdQBw^qZwO$-CMHTB~fPwcjstESF=B6
zxOL@^Dy+KD6IQj!I)8?vp>0E{q2&)DcB;Gc#|NcPOOV_>S~K5DS=>D^e>w6vVUomU
z#3b8;TQc%MqQ0sn<Hx$pWE<Br=49+aT+iJ)?RB}8>>}meWKqUit~AMIIYx+7v(rE;
zVc%;X0mgkDikABYo3837qPBPi^@}Ap47eUAXGpEDUivnTjK-ziH?6PN^I?>%cOBTV
zl)O(=sGzpp&q%FSI1+ipb-;a46w0fl)oi&X=gNp(TXn800Wa})Z}XUe&sctVc9>qF
z*O!ToB>64`v+F7{vQJipcfHlr_i(d>Np191INy;w%2#+sI80kSLJP*gLSsvaUCO2g
zrXh&F^@O`5qez}mb*oNk>f=9Yh9g<!1?Qg_zw*5>)!lXLH7O@u0vG4TWYZ>@CGm)w
zDXC$j4`WRU(M5Nt^5(yG=_c9|6ZDwf0<cprXifyYG8|=YG-1v%9X*~mdYqjJeuwDI
zNYl-r%2+2ChVzG;)kNytc#FH%c`r>_>}00vjT8L^V}Db}C9T<Ij^B}7QCf)2D1=Qp
zF;%I{7-2z<@LQVn_@t$y#z0TcLI15vNAvyCuOi9OTBj0rE)!sYU(UAmb|%cCh6y&=
zecxr#rw(VrbmJ-;Lh9w}o0*@VCHRRmoO!RS+9a^MU?lKA`p19t+v#TUDT8cANKcw$
z9zk;1Ro#E13%lDV;|iyT^ecK<H40^hmw(;BZ-%BlhEwR;3(kk%Dadh^#YtHI!5|V>
z;xw#pxRf<wNOIfY9w!QtBuH6HXsRKv$}?SCiBBQ4)tBW>D$hDac(7L>Ze9rva-O18
z<na!93rlP;vLwMOhAxnHZl#ujl-D(9mLF-;fhTn8-$Y8g6~lyx*>dC$)Xib#PfLhH
zS+N)m!U5Og`k6rpj{4WQq>Q}yJ2#bM?L&f*!9h<BrR4_;z$%J}B8<wg*%75<*`hS7
zcl7F<$i>;>5SghM^z|rTM`6UtVMcl`-QIk%I<X;;FvcE9Fwf`GRcTfQy`R2mth<>K
z;1W_@X)a!AvKg{dA{Sg8{Jflstj%ysqQ3aFX|`T*?4Q5jzVAzKnV8jKXD~3N_AA>(
zgAgliiFW$x2FVGy-57e5PVxiYT(60z7_P<X5yi_J(FMxm+{H;Q=E!1Nh%>=&K%HiF
zkJM&Hw2Z{Gs&jKA>;mULjGTb4)j2+Y<EA12+tyV?{PO4A(t7pMx?;9E6+)w=$ZGNJ
z%6CWnin^j1_r=jO%!I5NdWKte*N#b)njt0WA5HRgVWk*MGGT>T=e}+4$>wT)Yo9eg
z73)PN%+^;Hd~1)u6+x_+f3ZJjxOrw+I=C>-;iB*gGK|>!IvQGsXa6HtQ*<a7x`$Vi
zd3Pe7XBlu6b|;v`^aM_K#7s~8h;k~&rADTIJ(+Nq9T6I@6@OWRQN+egpXDSq*U!z=
zVGj1C{^^8}vc{82PocJmA+zu_t3yeHUo+1AmG>Tv$W71A-FJM0`nR1)qwnDRp)w)x
zvCbpk8G2b$fpdX{TUgX*7b3c2khF7e4?a+Tmf<R;Ps$xh$okgP{er6*`jqRTk4vs{
zvdU(>>AP-3!D$3cc3=HdkW}U?0Fm?B_e+5@t&UsUdq)BTbxsN$8yylHup}8285OO-
zko=uL<i%d6S#ms15;LR7*_)oHfYp6qsF4Y84m{~k@e|HD-6BBJo_~o7!7UIb&54ly
z(MtZbYs|wW*(0!E@^bsENHRHla)cjH^+~qH!|26ki{so6xcU-yM-U=v{@wisLY0Rz
zE>0vlOYi~KZhKj2u}$CfcZQvH8m+ZC_|QZV`-l%?@~dG_H}M3e8*gVj$G%Qx8FMrl
z05I<B?BC{Y@wk$mxVOP|XwVyH6FHRQe4&S9xT0tJdzkH)>dIIz%e%QQA11w*6jrlK
zFr=Ca%}C~HQ&-sg7;!M4+j`5k-<Sx(){IzdIcnbMhRCOQ?MjW<8?O<Q#iTP1`Hyb}
zx(W;OqQ()NJF(V21R4C(t<8+H@Z#+u)`Fw?1sSZDp?$;8drCZV#fvFjl`=;UpV1hh
zZO!FsMpm!)%T}WP)dpxmWjU_&lwyQ=AQ^jOSwM}qEz+-Pt1KI9sv8BU;t3rep-u|b
zDW0v2jSyeCjXOg_!?#+#zoqf+r4^bVFB1f_IB5cK1u@dAPY4}*860GM)pnMfzXuKf
zwIPVim2U6Niy5(I0(-~7Zx_rvU+3AtG-43%nVtEROP6Al?5OkclZ(P>=+u0wU))~(
zmg~b9p1+9R(TF&gv1*Lgn?~oynCZz+nzqfpn|J=<*D>(m$1A_p#XGn4N?p>tg>9}T
z#?Vidk{pVO??_&b0ym0?N6FaL$s;?vUy<Q5d3R5;-Ggb7w$Y&H37vfiz$)h749+nt
z#;lS|_K%E2b#5lllI&K{vc4cv7yyn&MfXL8MB}8t_76--D1)27Z#6Pf_Sf@b>iKd)
ztgGt25Z&7ApN%He<%e!kYGqUWJ4?QAHl1UC@@15mM|AiRb~ki~QIjNihz3P96*RAi
zzuY7663?{aoIi9Y>Oe|j<UL@~Jx<BDBTu$6H~1zjWK47)c|od4fwA6?u-^8AKH(lg
zhU&#2-4&<xDZV8sJbQQQN}s<78p*(nHB0k#db;CK)Luq$*@N?iJY6}Lmv_`)V6bY_
z(b;xPpzU<Obizb!p>Jns*{O*gI^;w;QQ>XE5^R||_t@)e8t&@u7Q=Xw!w4;exz+t6
zgk%~o$mBKKVd8fSlXe6L2aOL6Kf}ST5D5wv5EiU$UiZ*Eo1Uy`JFer!&RB;bb?J}v
z?Q~4iWvtU+eetiP>2MK9bb~r&>H#Y^kh4wB{WRTbK2qon+h_m=hX(g}OuHg)ua>vd
zFT1tfmfM+vmrGuXjo;#-bQ#HN*UT|MQUML5CG}twGPu2PqTIg9M+x+bsZSIZjakW^
zjfQ|hT}dYRSyOO!R{&XOaP$%`V;ip2T&>yTQllEJ({o|DoAx8TGl!l`w`wJ(=k=%P
zp3x@d{FSNi`=Lm_h7uZ-&Jh-Ek}+z~+p+BB7hX0ycMZw=GdQ&koR<%D4uSviqvv&I
z<uzm%u4m&V(Hp4c%67xfv3!}t=Gi#&cu%Y|lW0A2)PF3Z&i_pFrCLh1(&NY=h18}J
zqVc)xGeV?`w{dTBy{3n$B*&&*0X}y=Fe=Bgk7td?eSXvb^~U}S*nZtS(s)C3nBPoN
zn*Qk14a5+erL>V)y!*Yb?rxG!#pABKc=ti2yvl&AioCk~901;y^ce-|&~j~(;vn0z
zy|*kn@crPkJ?mX+vcvV^B$JblbB}H8$`5YRUy(AH@A-l@urv2k>xX*B$y+BpTP|kG
z7{Gbv`V8luoj}h>z50Sy8Oz(5^fr1Ma^foD{eE9=1t1W2qz8|~EPG#kO^_7tpCUrX
zFbkqG9~gD{HdTxL*ZKu6z+{c?z&i`oX%s{yeMLc3#Ct!m9yA9-FeUsz5s>bx)X=7c
zRyjta$0ezGwB*c?%g=F*n0=WVK!}({*7`7F--M=4zHJ;%hRcL2?9UyhWd$RbD=O=@
zQ&`tvYxqeK-3Emn6gj0(M_JbohcQRH?hK7vGjb|ubuRHGov9h_NyKzDd2K3kx+?as
zM!KK2=La)_-hN@U7E08ax`I^x=OU9__Dl!r1#m6cXe5eEfI4f!V<qEe=;zBAmzwq$
zG{q<#4W_#3i*s)iD2enW`biWeV8~IsUJyrx<az+Wq28Dif>d5yDM6DLUwz)-VQFws
zrR8h{N4P^5#SY81j|2zd!QnKfV_(i`W?A>bLZg$-nM4OB;Z<I@scGLP_m6goT)H(*
zL%>HLXWD@|un{eM;g$Wqn%K(DFwiD-$u7kzdu!`K;PNU5=#W>L>J_;%0^cLeP(L`K
zH9L?^W(9}=tmC_xK1revqC8yK(#52j2}zk?<k3mGAt5>7?ESae!3aQRNJpRbUpH^0
ziJVdOU(d%&RhL48tZ*6?^s5M`$sN53W<4=8R`_JcwJA=nhgtB2nYe=nn_1u4ecrem
zCN3X09cHZsNY`(G82B(?h3A+nM`?8_sXh$2w4N6UW=!@Gz+AOPMv1ZlGc{sI3UCI3
zcPosF>Z(?m+T{97oY14~4G;XdNqgB{D-L~IoX(fC)>LG>M8kegFUwK?F#X~-rRnMc
zfXY7Hsrt!x0a+77ZBk!5{cx>W2&Ojne_(=tF>yj?9c|^D(9bMm#^miW-4v(sOt8{Q
zZ|}cXk-M2o4B#@yW6@CAzEj=(GD0mS`lUU4GEi;SMmPK}e=Da$Yvn~j+MNapp<WF8
zB(EDUF~yzy3LHyEaen<+T4Zu~K|0pZ6uh6DeUsQ#JJ(aNoVLZCkxQ3vRn`Ai>`J|_
zGnKqL%qr=2;gQdaz@RXsJr?Js@F{pVPH(3>T#&DBR(Wy##nH(dX<I0)#k8_NP&!6c
zO616_yNiL!Nz))RQK8A6Eal{K!`Z`US4l!~4Lb$FN-f4}qJ`7CP<No!2R}>PUP!K*
zNIbGGAq4w{!VvAlPqi@mtbdF=$PegnM>(J!dvK;F5@%cX$t0T#G48cE2kxy~$1O7~
zaY!hfi`QCP*fTWNFMk=S2E2CgJj;b~VVk`c>&pIw)5sp92u<7M#g(zugyd@Ct@?k^
z!*MfQ4`-zp=KOP{i?)}D`DQ+9eXIB7?lp7b7yV~vQw(1np}#f=4CK)XV3lyr*uXS2
z!RTMuwrS+s*ckR6M_BETWp{_wrg}R1$=NEi%fC;Q4BUH*zMJsiIXGU$9=E3Lgz@}e
zIi@AHHbBnSfysuoZL^Nc*NGcW$nqJrF+XUN9FNGQ{mX?){a4iJ>Gf@b%pCSQmPPAG
zuV(v@M<<`UqvcuBIqY1^lQU2Tc>oe!tl?;XJPRxC^<#E__}aklZ8PB)q)2CNlCIAD
zW3SL+QliE8n7H>XvB|fyj@CD}PIn~~PPOa@Yp2Y*)R@>zbeKdU<^u!p)uV5Q1Jb2h
z=G;PEYP_jwGNabQo|Z{w>h|jH+dTO(1?5mQ-BljS5DH#tE5A?loO?IGHNokgo6eOI
z6Y5wx82PgBTQF9C)_Cijs8FM%h*>(9UNe^c%`n-{L7(e!)0D|xLnchO23bB!TS3`a
z7I9~4_9&l1<HZu};MtgU5%>taf+}T{!8~mhzmGsaXgKlmw2oiMyIVo?b?8r6V)}gd
zwI*6x>b11H!|P$oy!6!YtfsHa7~fmG$6NMrzt6S?mZ%?J#OOF4NM<QljFj7<aTEwR
zLtOI1l@L}p+}A08;Uq<1z47gAFF!a#Ooy+&k|9*a4!kVPa1GRXKdT;D8H@2|5L=h{
zR`G&5ud<jbYYoV;_i~Qf>kTN)C_0>@+~av3w~XBXh@yI@+4rlxDqT|KztUN7jyR>S
zY2~d(MM4+F#W6?CwRg2!PEp>`>J+0d*7oO*maGVOVG!!>B^%6s3$JW_i`5ePnS6NO
zl<kJosCDSe?al_UyWl$uAw!O_TTR1yLLnos(vgw32x{J=WVvUL%}Qq5=p~6)irEvP
z{eC^4xeP-;ZcF<@RUseqe3zdB;I(+<6Dcwz|Ae{Eqmr3zl&|<?yH?-65MwQU(z>X~
zxv{o)!b}gvO96dec5mEwdl!y3^`kMjrRN6q>P)1LhE;QMWo)6#L%YCP<}I(;cHLw+
zM@rn>A^Om3-79tLb^R17V~1i`l9;2%qcrrS5ErlVviNIY&7=Qy>b9SCa7|8@WYe@s
zl-O=hY0`cr@5E|a2qcQE;@2q~n991NTgk2}563K~;fh3s)Q6T`St|0z>pMkNbY}F`
znxpxL4}X9{Ns?98+TOGsB}3$KJ&+%*zTxf8c<uHo5A#p9`RR&0yo7X>u+^W2Bri=*
zN!1VBTj9*7?@*?4n6`B0bH+<UP5a{s#AYAB`1;lk2W_nLU7+rYs~!3=8H8-VXqBpe
z_EcZi<fJc;>d<ebR%E(vBVU*tYxU_X9(op7`1d%wzi)t>J^p8#$8IX3c5qZ#o5C79
zYt5$rK!#^@v`Owo?9CDoiY>+;xl#4Fn$a1YZ>@zRw}#4g1x}8gkqsF2^_|Y$8gMs5
zZ9e-05hUAWp%S4ebWUE}yRZ1(%>ZA&xF1MsQzz4N;L3d5oeU87JWY0;QsYw`RE)2?
zRNf}eU44>&TIys`3G?Gv{a5_!l)*=T{9eL08nEYpS5s#}p`#AIh%L+4@!g$c5wK&U
z5D8K2yIsnD8{D@?+Tk<qW%I<SxiOv972~|(UfxyY`%!t+r9>GSA;|JYH}30jCk|zL
z6DgfVqe+Id4{a30vUNX?>m^mPyM*69?kd|>72BMj@%v>-G+L+_EF*t?bW4?{==1f&
zM<b)d4edrowg~~}b%VEERC61s1g^6iZ`v$7L|t`sYcv`xWl{97fI_f$s)-S|tz+;K
z;Z=&lWBrDJyAJ-4c6|1|wI{<(n>3I{waliQb8hpfO?0bW>-eS31|ia(H%CJ0a?(?A
zESkUgLXNtxgKTrZFn(B(fbTpW$i&C_Kc`a<GKmpK(_eBm?We|+n<yc^j@QyG$NIfy
z;D8;D6msHaac32k=-?nJ#}}m&LEa6mQi6!|QjvF1c4f`QTDOj$O)v17RL~~v{U1>9
z6BPOI7qGWYllk(pBZRA(#XO&PAJjn`5$C?)Hvpc&(^qVZ)IneS;mDV2)QFi$B*r9;
z=U;I2TT0@qHRzes3V`m8@uT;?g?ptof8l(CM}uh;K)twnkB@=ak$A*_&_E*O4AYix
zRb({YwjnH2|HeAX-g#1nEGNx;@Hub#BbBl#M-G}wROCrT&ARaN%7!|{ofT0}T|ewD
zbY@(4wPJY;kuyvN{z%$PV4wAqfrR4y{R^u#@O-`va9=eB^Gsea1`t)Vlwf4`%##a)
z8_E+j+Iu0RK#E-^tyOqF(K)(G>jBk&KCz0T?FQbfx+PY&2QQJ(uk&S1a(&8aoo^V^
zK0}F_kCc5sZ{r3M12FgT?B3dg2AZs<GX)>(&Ne%rXr7{1ZLirviHcn(!6Y@;@2Ci}
z_=9pm?2bAaJ9MLJ3C5~q$(^#&nyIjOZ)eg_!N0!O&K~HNE|ilZnZ|30@?bayN>+S6
zDbni2oyeDm%WsFqjVb!iJT2VJ;`r~^IR55MgJb)-c9)tEL#j02Gm5CeLErSd3O_z`
zT&y80F!1BQ4Z5m#9(X%HlX<H!H03_wIBrx_GM4!+g$w9gvlrt#Rb#!&(Th3!!Z*Py
zp9sOnv~Mea!QT{VCz$ejLO;o;TUE3WHXZOcP*R&&x~+w*jklsEa}Q%Yom{HWe$1_r
zP0^`W%e~|?)XJeg&Rfj>;meK2YXqpatyrKm;}KmxHbct{<I@@U7t`*n9Nqs{WVj(~
z74#HQE>((5h-acEeD<E89M0|#5p&Xa&<sfJkeNDJ4dp<(7J)@O&m=a8vGz0Bun<D3
z8jz0(8d>{2=>~{l?s*rcRlOa{xo(77r*F4yx@CgL$U}H<95lQU9F$%%yK8`VAS@74
z)kFu@i+*tHikj36x8wV^S4Vj&UMjEw&y%>Q^;|c#O0UkPuyJiDJIf%$<v1tfyAF3p
zO72a!b|Jf;0iT!cVewGbFPJ;8<nYgawYa{BeZP%fqh<<4Xu_q@td!1Yyi#joj8-?|
zJJL*HeW3ymkr0x9{&)g=cBZ^?<@YIKPPb2XH`IUhms%;|2FOcp8k~2S&rCV8JP`c}
z)<A9j+~lgV#$5rnL`(F=p$~O#@2smk8wZ!usV1M1*J+TbZ5hsu#oyY{=<_Q3YUst)
z;;RdjP*|%q&;#$`p=c?46@gOLRi(&izEnl4goVH{PvZ|PPZ>_PFWa(+m%jMSn`RHB
z^_8PHy|NmIX*xu6pQ>(xG81F!Fw|ft3mZ%<Cd%x#YNN}1Z_3F{KYOCJphmy65^EA^
z9X3~wOAbbk7kF3fh-%Mtg@7C9Ty>5?%c^*sRdKV<<wfk;`Ug#FROCmGCE}8F^rFsI
z-Lh)-_UnY%Q3BeU>^<u{XhKBLLth&Ik#j5SOslIZ-NWeUrLOV7JJ$F}ozRJnkorF`
znozvW15_>q{H6dGK$fRHXq!)ZICbt-eKYnxSElg0{`u6w%7M8x3DQueR<F|X6H+Oi
z=k`xuC&bq+v|!Pkg_2LBu^t~uQ51-0vj}#^*-QVZIiWe%^CLwr!2eVN@kPCZK4}{>
z9zF8{lJbD7Nm_eRCz5!P7Q5B7dC{Y76f7az<DF*X5AtZ0<IH4q;pB*V)JUjX`@w`=
zk9o;1QG^72*TDwa)@kVE@=+yfXBmm`;=FUI(NZ#)IMX_=Ts8^6pC>M=+v)m`>;ANI
z=nQ-nyTLYnxjN7m$6$Mn23INjcEmyYgLhFO*IEiTvaW8Zx|;xN?w)<*rB8Aip)O?y
zqNiBk=slp$W@oGob791i7>&+Vv1X63)QyVTx3C*&ULkI0X{UrpeXD+X_+lRU3`an%
z=p>odE^Trm>uE9j*zu6J9qafg!$pErvpmIk-MQ5`1&I&$bx2mM-XCJBR`_TFYpo{z
z(;uCWGC14yNnZZ0cujp$jW45dn5uIrz%GLHa(;QiK_5hgc1{0jJS1qUAii3YZYJ>G
z9$`Ukl0U5SP0seF`>_Mv-Tv7XQFSh2mKSwnz&$F2wGJ;&xg=qTL(xC_!tkLSI4h5n
z<2x^k+-u^IBYWMCzF+H({tqbr>ea3?oEx_Xw%>T$_|mrPqSGh<8~V(tp_USZlut*~
zQ(H)J21s5(-Y5Uv(L6qr%G;pI+Fb3$Lz>xdOP}m=jZ-IeUED)N{Ih#UOzUrs05;Vo
zO#m@k32BW{(%B*S48p57l=p`bw+RxXq{DUK13}_JSz-M;+wmn`Uc*qLJq>rKCvAvD
zOGZUWkt6Z$3C1zpnB972u>x)w<wFzA^Y|3KsNbn`gbH37j6C)uj*)GDGfaA?0Rp7%
zmgsoI4<#!g%i$$JiUNW4(=3w2+fJ+)&i%@vm1~;xU;B>?mH}zvA3E@;WPH=j&UYp4
z^rZn-dN%{l%CO>C_wnup8b+t7$R`hCv+s9x3d{8zMct)l7dWC@S>aWiY$aM2d;HCW
zux=6Cqbk<(W_aW-4zMV#euICeUtpddTlH4CeC6EUf!!@7@arYfE5kb+X-Ae>^ZRnJ
z9oh8YAgt$9<l-RcO-AK#;e8ao<g5%|k{b_^7Rfw0k><T(uH(tyGV}d}qwSh&m)mT0
zOBExTzgJ&bRx-DyVCT=05IfisYx*7Uo{``R{p}=wSFiqDD4DTLy{bYen)&hqUQza(
ztEpp$tp{Gs2kZ>C4G75|bvvvX$75w~tY5wQ<E&7m&iX*}@X3*$QfuA8B21SMw20Rb
zp1W<w=@z~oV%2GIFJ5FF%fgcWUE0uP>;x^#+##(1Zk3~c4rz6H+LP@TP6Go?m8QG^
z!1JQYSl?(JjgkM*8b}qf+d22h299y>1<jMOFYcaOyjQhW;K=8|iT*jn20fg~YAt)U
zkbzyU)5Ttq(YBoVKJ^)#2H{nirK0!BO&BTCI=z+2i&N_!HK^YW2GE}+EEs7qT`Vfp
zlIQdEDw30W)Hqh!je>2Il>LGiB+r)h-`{Zo-j9@cR|Otkogi@i%*3HfNtYx=hMP&)
z`Z_B^`&NC(W7MwqlnXD#VDWt74ye1Y)ofa#4uwI}naE9IXFwdx>vVBt98Ra>X_1AP
zXBLiIn55j;BBHFl`{fhAJW;Kc4<W&jJx-J5xbf+2nkT&x;O-ut3VA!)*Yvpomwu*|
z6R&%ytQ1H8@5YPLm%Gnh`CzlCpwm#CkBPdsyX%9|cYM+bMeG7c-WjH}dY)-qTiDUM
zh#_aqx@|34uI{d;KT0oDCp~><m*n(&LUHLI^<J$tRObGV;<d;%UypfJo3MAyUXdH5
zAy|D9#fL#;=#$I?PDAvJh)43Ws(Arl4uEBUma@Bw%E{88S&p!J=W;OBJ9lJNX`UXm
zR|^Seo6=i_FP#q4aOiKr#cBfT!pZ~6nRgY1oEd|k*FCJkpX_joU^YQtdpx$bl9poq
z)jo}$t48zpOUVlu>%UV_z|kmPh|*MkvO<+jKRc#qwm`hvHM8E!m(26d<zhmF<$c&i
zl>*tPg-IXM1fiGWj&qkKEPGM-5_qsB5kEAPq_E*^HJS(z%W>r`v7QWLS>-st7K3<-
zTmdJOS2tL)s-M!?YV;M#QxdwG?rI^%AywYEhKTCMtCX$oESC>Ao8AJ^Ev@9g3uszp
zuX6JYO^197>vBsrh=oMYz5~#e-CMDTxypU$yHmTb1he7|h6L$%e<nF)Z1bH|IY?M{
zJB^IuUVhAObwrD_!!e%*m8Hd+gddvY>K88de^83K5`*P?T@+HxLSrr4bq;02S|}m<
zd%Tj30}orL)z-yUw#1tI^k3`6C--2Q-b~r#mW;{8M<k7*7K4??-8y4@f3FiJ2$3SD
z>}k1q#p3Yl9L>cH_130qZyTp$M|R$c>&tWnY8ERW4FwUl+^aUxe{HDYMfypWT12)N
zF*A?(apTl#*Q)NY=tC^cZI7+qZ?QPy3lavuD?_6aw3<i2i&pC<h2gJcxQ1FWq%<N2
zWR9a}Num=cTCiT#*h1GC{qoa`UCjB=MVN#KCe(IT!@Sj4RsgeF{3{vgb)`9Pia+|b
zlPV9PwV@_}t}aLTKN)^|Zw;-iD!R)Gp|nqS|NBRY=R0fV0}5gp$J;z&4yP?-_x0M4
z@@ZM$tWJFlWVzPqKT8Q;Ir}+1Uby~?ycZOlUI|bCRzCh7O0}r>s5kyZxJzU4J-(G`
z6+QKe($sZvJ{&q@44a@oo$Cee-5LsIA|Y<3{tEJ`P6WA`aBorz%yH|E-ZM%VrR+!P
zSYNxccFlups)Fkl3W6=}92*wRv7t4hy5o2p<VuJ3PL~?Jo*3#8JRdL@5gm}gS2K9n
zU{iVV82G4?z`)BI5hIuX)_og#D<(8Z6L{xrppp}h6eNV#eHrOt-OYEg?8he$<=2qr
zs)t%m`7pWzloLPlu4LgBJftE9+Mdu!=ngm?x1~(gnb8e4f6$WY*<8PKLh;qS<RWVt
zLrQM53Wx$}*7NE7=3Rq+uO3WvvpAPZ*mtElb^q7#P~;~kKsvi7Zm&3FUoawdQuE{m
zos(@l#0b2~AQ)NK-dndbV7gnuP?RLQ&HZgpOoTYp*;_!#RBq<eZTIotM(w0?Qfvxq
zf4HqRU?IbtnxTBy1;Ry(SnpV$(>(<R75zoLJU#7;!mTPF6%_-)?Kj>V6>SD=U?H%v
zFZym~#h+>bk*a7*Ct4bNcfJ2|V<M^Ci@R~;Rq{|&>>X&)_H@sHsBIw4{;$k}cKU?+
zOHKQqz+t{|DLLP!=7A*CB-!3%IRnB5uPnjW<dhRc#m6DxO^YB*Ujw|i|M`1kg{$5D
zvR((A&Ytr`eCs6JJi7HsdkS)}Q(joMyS7)|gNRRcb(c*0oZO*-ST`lcQ=<?mGcQZS
z4<+?vZ7~=fyRnPz^wzz=bJX9OMf1s~hc`<ldh0<iv*PS2(Ld(;;t0jb<1Vwq5z-2&
zb>;bTY4Sp~+sOnm=dvluIhU12#ZV3BE)_XHzFb{#z_W35YHBaslK-Bm-UHl7leS^-
zvm%<_7f3Ah%7`p7;TQpQ97^3R=hshgnOVgds3i4Vh*5UlZcPb^jIzLAMG*EJlgRLQ
z_3xG4Ri*>&&xpuI-)IW2%|b09%G`kt<1kd=P`WQ7NnAx{-RMhcRwck$g52R;z{O|!
z$y=RmDHc>{-%NlQ#D}@3gx&q`=Gap9sk6x9$14l-7Da_f=PtDtKe#TS%=-8til#=J
z_OuBZ>q^8Vh5g>iJVK=W?NT$_9phOU8~NjxHp3zgR4WVY9&%Px=$@K@g<ghb2^$)g
zz_g!Id04nO2n*@|M@q7_3C_2tI}$r2I4?FyA`@~-mOkvzkRm0!uY6Zh_vSt^=Vx&M
z(SV6p_)0wMKbGJ%5)W>=kbjWBhH2)icGwY3TPb!%0W`}UrlE(uIDCjn3%N7l)uimT
zh;(-Et$%IAt&%nTa=haHtUFGOSo#p`I8KSC+E>5hFP!@xrvd2(Wttc6&Ek2&OcEtC
zljzjU+KCl_4!dLE1CB(bv^>7Xmrp>kL>QAc<|fqk7o{0_%dakDG#+F7Tt}<hqIbfA
z1F54XxH7<xz>i2bfXX3MLG%j-dfx^}(pW;*dlKs+lMOsh2Dg$A{T6J4ig~?AGE>6{
z;{IUEbbkF&C@4He{&?w0h$qXHXVl4bpZe##{@#V_2OeOdT5}a7dAgb5B;&#sk!C(L
zY;2<!Izaawt%T^Qo`&{|uyw)K5%ss7h}W-pIf=D-T+MKe+m%R;dGXzbx1kZ6-AAp<
ztAF50reE=Pg8{LiTJZ1BT2-m@j0ZR}6vW*yf+}lWl}-RMo>db7Y70~gM%Q#jVp#T^
zOxII#TdScDa8QFn$oV#|*G69)RaZ=Wb;D8-s?3E8T*x#FxigW6e90_nT1uGE`9&lz
z8@YmWvbbBTb{4ap+dSH9V<AO8xmb7Y?Y%ZlrEN>0(7nW9+su%TgB~E3!1IA2E%$BH
zcoJr_yIOuS<h3Umu6jpU_8z>d*B)`%;|du1F<63^4fe~a%RWhDmPl1&DK+%H#YvFa
z>55bzQ&IWmkVO?ZutxlP=)6tBjpa*B(04RvlW+=&boN$SO28S#D3DOS`jw{cuqfCO
z17zJ4lha7z3l!!z1`8o%mtMMYA>NpK>gCCrO6l0K%tT&NV80@>>Wqx0AJ7Bd<}Ljf
zRB5-;L_imYHRw;Lv)gZ&Pu3Xkvc96vr4L@Y|FdxpDQOgdih{2i1mF0EC#|$66rBd(
z9hIF?%S7Z$iPzn_`cY(*tZ*l7y=g?+$&AU>;x>!^8)?)0FJqIm{@j;G+*{TfEsK8^
zsC;`OhBMI~_Rku1Uk^UHN?oVo!WY`s9^G0(OX+C8Axo_m8#$yxA<%KJ=<99$QpR50
z>F{kjQ(iDxS@ujKuu|PX&IV+Y*tN7Wq9^d?k3zSdUfa-up?`*q`%you(E7U;trb}J
zm^f&_p7faO_XMr?g%j}i_lf1|o8<VA8cbIK5KP)R__D!Bx$+A4&Y}yd^!vdb#}Dhg
z;2-2I*LYC}kah#RIJ2!ye%+3KuWhCR&me<vm<v(!MH!CvG-|qA>A>>G2jl9*Xdwyt
z6;9{&;3SyBxSq3+%9MFr{T-C6SEcVbR9^bT;QQ>++(NRbuE>AB(@oWKlGtU-5(LJh
z=X&=pCd~~dJb3PRwem*I1(k>40dzJ0-S{!;Nb|qhfph8SvcCNtS9!_i9M3Kn$gO{Y
z)Nsa4GA^6_L1A&cZ*reNAJ@7+#SZ5#<!RnV55My$?=te^0e$SiKXn*#59f~E&NILI
zgZxa6rh3~VVrWjoMncc_+XtUX$q`zt;w{sSujHR4+zOoDcp~+^jUG=`8jNhj+4a|T
z{3~3e{C0UkL|)yO{JP`zYeDW&kl}j4rAF$Or7<AF(s4?&sDwtpI+I(WsxPB;wCi@@
z^b=dk(=d7IXNOt6FVdbHpE=Yzv&XU*?~WvTTR>C3r#l~<0ccJz-B8bFAVw6g4Ja<>
zALha8d)SEUOtJqA13up0=OUz{WC282^6dlNSDWn-w<O&qne3Ivy1AQlD6I0SZwidO
zvJ8%s*i6bu8~wDxNZq2Jy+VHE`h^JCYkA;9nB-JUG;pcGUg!M1W}<{`gSlvIxKqjX
zvZLu0Wc-Xn=(E(p)DE)T+=FTnAQ@Cm{IPZRQ_RC-9Ue#m=M(ebDJD_5UkpslrKSnm
zr9QS+ADMSTsVlYtCv<y`<>lS2-miWX{%K*6L#OV#l#{6$TTRR%W)`&Wfwrqy)W{vT
zzI4r%j7s-6?P?aHLi>R0?7{c*R`GGLFcSn_3(J5!&|2|LimxGn3tFIqB2X`rq}|bz
zd#}V;VpseV?RtHtL`_z|csi2s4d0VJNADkl79e|fyT|sIpgZa4e^DyGhn$T~R-IX&
zm99CPZ(Mj4Ds(8NyFg)?nW)pFO>)qm@b4z>&=oQ3u^}Si8Lo<tBLf917ct&$ahD><
z^rg||1FaPe9+(m-ed?r-T89;?I$Gm~O~>uDLG`PA(<|U2N%U7iPzzV*5%aJRuIhF7
zkK9pFAy&Nffyuv4IT5FQBLWt;E|l@qVm{FESgmO%{o&ew8L*>^A1?&Zt?MZ)D-dq@
zs#)aELC2$3=J)dHdOV^^`e5c>$@l!cV8qN|cj(k!RZrtjYPS;_u*U<pWj-pBYNtPA
zg7}u|1g>yjXOknV`pbs%uS$JBy0&<hjNkB-9p&zhn>-0U|5*bqI6+wXWn@_-A^l%F
zO}qX-70$Z#bm|8I3E?g!;tV0ee-ggM{<?kP3{<_ZWI!p*xIIkvy(y+1*Q0`$UKcLn
z4yeK+{_64FADpUf=S6+-RI!SdB1TFs`sb#~Ofk_qoa!L`LC<6lD!W4|z6BEw#_Yhh
zeYZlSF~P`_mrFT3rkEp0@>=wI-SU*vhg1xfydRrNx`J@h{-q~{QAY~;;j>$y;PqVc
zpDdLB!2TADb@aa2L{BYuKWWN~Euuo4?Sk()vSmBfZERyI&?cj6=84_9BIhIV3L3Yf
zc9~OsK08llgga4@v%syEy-r`Ybtf))Pv$4<yYsZ9-Cn-p?)QT08)};#Aa0sYUp}+W
z)<9UWc?oPwZR`-0RUJ|1GZ|zFQn2JX%@MqFQgQ{QYSPAs@s_830v$%Yi#Z^*u6Bx(
z6@F?e2omqL>c=`2&m+fTW~RbJph7pdtd0VK9SyIr>cb$)nuFv~LHy;OqRma%+d3eF
z6yry*U&Ict!$;-P>ekzKKQxkUxOv9Ppjzl>@f`(Hl)Ez|bDs~8oU*y6K0ebaGr-J{
zE*YT60;wovPrG@Xq+=JaQIKE&@#mQDcXq6IH2%06nRU_iakzs>N$2)Ga<0f>P`aOu
zNNB1X0CDFwmi6~36YuF#(rl&;)4(tBduwSYPv$u}`i;~RHr3+)Cr49?<hd**)r^=!
zsEV#xg|qV^QUbiHpIYHJ{awB`nV$RGz(gcD;FniXR*T29iWGfB6*z+1S$uKUn%5xC
zQl+)d`;q=$yG2<)2IP_(J}F0ag+tqy|GM>#Hqu;MTRt1t4jPUUgO{J;5i(F-4k>A$
z$0GIX5$S|2*3E^XJx$LN^831dTMzS$nBPkQb(jdKuj9Yo2NS5;O37}yZj^r0v9Y86
zl@#M<)?~gpVdC}h;Em{8j`2TU*>v@r<-Tn!Py_>bjjuUXm<W>@pDR+Jk%_-}4wO^#
zEe}hUJ%Lzj!Ih8Ffu8E*RCwyDp3fCq=kxDri3bquV5GrE<rwrrDz+&oY;sk$IHA%u
zXi74{y@nPn(0h{X*4lF9JxYI8rSLG}JYqyDoEekv9*@AF+E74um}BAj6q|#31+q%g
zRNzFLHc?p0kAZa?@41>h?e7a?U})eO{Y9q6IrIF550hPOYcpNT=`i`^J>MHQzK&Xd
zMk1HCbpTHS;btU&$6*?Be3A*;GxU@!+3^0}T;OqfUL3TT_r2a_$3lbbfpmiq|6WS4
z)cFG{2uqB_-@38}0?)!;@lX1zIWsSF@zC0<fz=5=)B0&`)oz?bAVHaol?05u1FJ#U
z<0M}~JV?hz#-qYq^mfGYK`uK|Cz?=R{iG5i#Bm~0sLlmxzo+&o^jwxqTFPbHq5S|F
zgay?E5_c&dLpw_-Ew~Vb7J?WL%8D|4G%s2#VodJavCv3_CQa~B-v1I?e)6H98&jh|
z2bQqoP`~}F*|rbQN<E0DIP`E2q63Hiono#^!9LTpWsq4bAEy}X-LR4|xaG7uh@Sbc
zg_an<EyR;Iqjv;xeJE#e3|r7x%2pp;8Ys%2<N<B!KlnJ4Glv{_WZE|C22xZbuo4NN
z+axw~V@-H-OK>^A)js;JpYj^LjG+CXc@R1WZlF>;fDfNy7qg9~|2aPvD|qM5q6<@_
zp3sPE$T@>hUdFXj7s87ugJTcG?Du=!2AJngVOBEDIcJ7`w4Yh!4h=*p)5k-)5%Yxr
z2o<lpweLIFp7^a@{oxA@oJQl0Vs<8o#Ps`(6>Bju0;}C)P}5#a0@L2LRxPHLYTss5
z^vU;HNqkD`XwN4gZGI;JsEF>hRtH$NoM#?cZoMrYc?0a3dK6SBUFR{sU*LiPO}-gY
zZBE^no3mAru}hK^cmfo)@diR@apyrL%RO%B?#`y;<sNTwA3cmQQ6Ii-wKCQp>Q(aS
zrfgLCrF{G(Ow^5b!Aj=Pl?V%-QO!CKUUyJ`3gjK7?1TnX+BGGvO}gazp#;SLi<5P~
zZ=gU=C7?F;_@9`)=|b@(p^jJW;;$@JatIwH{phhE880*+7wlUFX9@)EI$K$sM$1aH
z(9V)4m7a3&ocYuqU~a0*^aOHnjLy|$&O*ysvv*yxoj;Uy9QJfPnBILI-OVytmzLdE
zCt1fOUVK$M@sUA^gVBP1B8T2|+cpLoZn#kBJ$tmu1c)UrA|)&A^q;H<{l|+BoL3~(
zi~;~8whNJDp=2Er_Zkv(mloNmKU^rY&CluDxEA@NQPHvfd7;lQmZ6$gENklGG<1bv
zz<73<`9da#>-%fUEX~GRBNXQ5{Lh(=D+<7!-$G`&HY|k>Gd{g>^O?gO%{ibUs7S`a
zX^<RivB#3Ya2%60rYm{tfyrN&BOoS;*=%LuQiHd`m;3x|wMvSd9}R+aLRR0Qyqy&{
zkK)(1(WUn;phn2ny(&vv0;2$)45ZPt>hJlZgx0S$nrq(5h8d$1eXW7?@8dA<Ro3X&
zR*~1a-7?aSL-$Mk%9BGy&Fyj9v)5gSlx&l|1jZZB3Xz6@GQyS;*CewGj29$BW<<mj
zqKxO0XhK)!K<@kyBFvX#mTd>h>&ZmW?At|A*kv!%&pzJx0@@CW*PuZfv-dfd-ZYCq
zvTwfNY4GEVr*%VTq#ctDr?%bp8=6||!cdF&OXFfpz>lxBkaj(Y(97Fy2Yqit+^uk-
z;iaS*{|moj6K6Hw(4xdhHZ_@v%lQAh7L3%@18({O`m+plW-*?k2BCZLNP@oi@Hc(y
z2m|CZ%wrnxSrT~|I5`$7@JLZeEdlD<n>u*LC0h!NL?somyE{qN*00zT>a@D!me<{q
zfrPLasInZB<*S`wd=?$EMY)TgSe*xyAV4l<#0pprOnL^a$5kmZb~$IIX9sjk-|Kj|
z!9(eBdTN`QHQNVh)fs1V0)vT;JE2x~Yco1Yy4JmRc((G^fXt(pm!5|u(eaa4T^$IT
z)p{XwN5>}7zz(od;TUMv)}U0p%1QfU^ogJ+Z>PN}`7bZI2^B4Hi~kecVP4Te&~lnP
zIw1S2wg3s?5Ze{jahypQ@Apbe1K~Qll-g^E9x<inlXKkmlO5+?E~8PQx!QyQfgj4~
zq(G(WoyyZX+u0K_Om$Km_fFR0h<Gck&2tdwFA!!Pe+mm;Vu)p4Ivg0c{o9tgD<Psn
z^CG_A3LhkggTjvh2JzG!5y<BDTs}w6$ICmYQ1xi;A+($+ID34j-nP?*Fi77HEZIFD
zKXC06`9m}AUHRR<Y58~eaOgGM7reo$HV<ub)Z%2-M@<F(aS(seh8@Q2aRj?|^*jfT
z?pxv!7Nkz<k>St3MR}8$BlU6qik6YJ^O#G9%qnM&ENe`H0zq5(?v8D!bw5c5>yF%>
zv>{+rR)8byx_#Nh9J&om{l4b<fU=2owBK*eHn(7`QKGBz5lDo&FYI{Of5C47XzilN
zxmHEp#mAkH^8{_yHubt0``-nN3rTuuK)Ad|+A|ZI;<P0zVGhG2W;k_HLb}y!{DyBl
z&ab{*zf@MiZjSSw3V)f;x~qPkxZ-53<nP0k4%1m&-gx$ROjhk4J#1pL#h%c81LbPB
ze{&dFrBu-KL&5IMik=@1p&IQs?xf81e1eh8hK8GS^(L=|#L8zAtY<T9bOXtnN?}>n
z`5B4vNHOX{h$;}R>GQdx^p3<vm@I%s(SvbMkg*>B__|xmuOohwNsAA>tG5^8&nJFK
z38Z{An=T}jXoMR$bks-gPY4UW(${fJ#fSsiMf$d>x-YN3>wt7PYr@_fbRXc&=mfvD
zpZ&w|gr?SmBJ(in7ag~NVZjGcS0v6o-|?kW@1~Upa|we3%)p%sfH<;kAc4w3H>O9y
zJ)`?51|l{#A-RHQXlzvArN6>_UdROPbSiNN97<BeIqv}vpZq%6|M(Q^>JxNk+zW>5
zLGS$rM$9X%+WyYDyMx92#nYorQTF9YCT~9{G8&ITpTai`mDK4Eykmf%ZcGwtz}c^|
z=-^u9Up*jO*l5Svh(auQcRh#6sU{BeSdSS&qx*aL-ON0H>7IO9GPaL5SO<N1#R9JP
ztN$}s1VbXdX{VEaIwB0&Wpaf@6~w>(&@V5Q4ey11ddEKxOwbZBP*!^W`eZ{8wZ73Z
zlfRy;*{MG*2%Y`O1tK|Wb)yMhbrjYUCfyiX4YP=vJ}LfElpQZxEYP-S*PZ3W@lY?&
zTFU4+1|xICqjcC4UJB)*f<!viG!hkzEjSmRJbJ5e=6k%x%BsoIy<{w85x}SDysyom
zQP61!(xa&M;+L4jBO98ZuZ7I?DcHYSp_D)S&vTphPUl-XEM38$<=?M!x`dxzz#~P(
zgXC;mqiVq$jfG+$aAZ4u;H`whc#aA#rcPSqgMhyPq=2p}Dz#??g(30wE>i)a6!d+j
zjB99h`C--UyHsS?3Ok3g(e@;b&!_$Jf00waBHK?eiW(&QCE6GQ)we4%3lj0)1Ye`x
zC9=0L(4!M18Pl`R9-Df<XVp$AkA7n(fI!>V+$tqbdsIs^qN<@~m<ad$%ghs)=E)C>
zM~=_8z<VE7=EC<rDF+^+-w|$#gpMT`gIBdT5fgyrShMWCBcVf(FG=hkfU$TRdQPjK
zstzbZJzrEo;T=_%pRgS`CHcN(%dCU#lR+SZt2%yX(e<)j7kceLP7ZD2Ku{1Ew86qm
zaZ`>H2-89!69%h1gh0i-%ur!SLEL8CkM{(E{{vxp9>|8qzWu=dlajfE#l=GJN*4V@
zf*y|`=jFR3^*}dfi#3pLrxFMbb419<d1JDpw5I|4eEEvGeMUL6qc=djQk}`s#*iFb
zVoJsgS)}`Tc%p&YD?-lOl2>ZU6VGh^0);o7N*L}v6YAw+j=s=4j+z^^n#vb7dSLGw
zyFvGbw^D#9$r^nrsT_eF)29Y!<FtONL=w3k@1e5tL3n5R#Ou)hQd7n`b3Evh5g;Vd
zCRGu^nnqs9uE13-W5|`wk9MQ*G}>zT2#aP<q@1*}__c^Aoo&Zdj-3-0G>wyfPl-Cn
zWZUEueHa}6Ip({-)M{cs@##8@nWsVj5d$Z{Je-H3?+!De!?FN&ezCnTZ4Jo;LAp0?
zHBG*ShX`vF7#$#^2BPIp^f>~^;n>@uS0Z)vN2@6eS2iWe?hGN0sT;|R;XA9SP_@|S
z0F{RyKY^wJNS5P4sO$p@t$2Lgl7_CKBp1e$O7sW+AND-oSb~l5&^({4awM>QW1Hp;
zgBcbSDf}P+3x(PK50w56C-`M$tg)9}p;zVnd>D+81ihR(8*I`P0KY`LflAXXd3dl4
z&qd*B1-u)=ix#(k$5ecOk`Kn@<V~bEZfxs?VIC#??C0Vs<&iiiTT8UmV^+)mgU%OU
zu8bAy4;=1zI(7@48k$+Zg>O>gKsLnm`4z!w!`23-UPVBRJ#>rL9l@Z_09ue;^Dkq=
z$6qaVi7J|T*N{aQrjoWCCwrmd)UVpn*n8}4>6p^4i}06u$&#;T%Nf~W2?j&G?jX3G
zssV`$>K=z#M>ei`T$u}Uq4v_&Z7hH!13$js2~{>6A(iF9RF1dJmgN@dbaXs*q;U4H
zbU4Q7&!ve9Wm=CJD5Id`zcc_H13zHw$7DJWv^?H6CsPwTjEZ2U6?Em*NZQ0--Dgyc
znCu_=B+H36mJ_#qcn`4QO&+P;!dB1^cXK20zh4}0fv}&Nn+Q#~m;NxI0K*Jpk`Znm
zH^~GTpqO_j5wP%b`v2{^n7wd<MH7>p)ZKj;)BySi!?bwJdNB0_Y25JpvU_i(^v|cu
zsF@3xomF|LEeIk|DUe8_FA=b=-z@C<|5S>%!Gq&OXl0i)w$O?*)d)TO@qk*;zSFmO
z9D({=J)%Tjk81{*ghDs_*b|+)vgbzm#gb0!YY8*hssY$4cv{o(a3Ero=ANKEn-~z+
z@+N0CP%)Rp`79Fe;(nV-t4b0>4>M{HH8HJ{`=EpLi2|0<(C_U^%Ta%Mcp_~e0cD!2
z*+s;sc=H!5MRd}v%m=2_T^QFvNjiQE@qU_dn3FtRKhCsb{Wb%jV%8#~($eX8@@^XX
zJDr7z1)k!6GwhG+nHnPcTn@418ca(!I-`PCMtk|z2(!+7+_-_PR=t|>HkRd4dJ3w5
zu1vmeT^_f=#k~EYOHFz_g_T&zhNkqn#>n~R;B83}@lcqRa1RZF*80p+ks}tbg9R1>
z3)~LA*Rk(wlVCb{RZsE12SdwIT^x%ee6Ro@%}uXq4Q^@YcHjFHwUZ|ktT`~;2oIV;
zaTm`zV7!FbQSaoqYjEUQ!6-~n_sV~dZ!Yke=m2HqX!}I-0}%A#3twAag~<qqfN$0C
z&=1+mh!k@luP;T15^7&%ti)FP|2qvGNd`jpjKRc18+b-d)79U^hm2ozVu~>k19}Pr
zhlrL;wx{n)CB4bvc=w^;O;zZk$Lx={S~2u(OsC%XFy0vjMa>2F>d&DA(kFXiKsrT+
z_mr7ypyAB^)w9S2>QRQVt?;}n2sjnv?|8#QS45!<?HL+47<hyZ(`>t~%h88<rMCnO
zMHYlp45atO%TnQ~Kz!roi`L<q7EsZAGkc#1Lr#daat+jZE?EGaLuL-6V`z+esAaSp
zDkt<LFIm7y3h2veb`ZqNp;vt_l5&!Yq{g3CRvLQ{vIISqrQRlOlCz3YOqG$53)Ff=
z_qg+H-fd?FJog5D@qC*1XfD2Ev6>6+ws*e{)Ud}Vgl>tK)dvT>>e;Soam4uev=|J5
z?$T2*est2DiY!O=dTQ@Oj{%<6`wAMZe}R@$dB+XVijg*KnK$U=P&6<55q|v5EyFFh
z=N=jZPvMQd2hU66pLn6E?+YWYJrC<mP%h#lMGfV<fS0HyhL@uwc5*$hTc@qf!=@Nf
z=6}R(MjcI@!4V)~oOJj>2TU4-*jKA!hmz0DbB6Nb%hrg;{4gq-<_JUOk;Cmpk71k)
zbI)5w+hJ^I!I+8V<)#dokn#nCu2<CRqrF2XP(7W0<|#?q@?az+-8PUMwb#j*9QEHR
zW3sC^3=g0vMjW&rVZ^T9G&=Q2xf#ebt?(dmSMufHNg+|69apBdX4HGue`MT<hY6pD
z<%MHFeemQhpzwhiT6p(Z{qm}!P^_6srA!%&9LI}MG4l`Qp(0diK5_6f^379b;<UxZ
z>?a^_XxiEJ{-E5p8LI&pA7);GxXOb!HOo;UfU@=;ma|a$FE*zj+|h4BtZdh8<d74z
zpDMtLP<Hj$BVoazsg!x_a1SqA$<r?IuJ7lWHS1xJA|OKzbs90d^1^cg!%tBX06qoM
z^B!_xBIxJe1ophGq&;<g7pC{aEPeEh-sdmgJ@1Cf8VlzdWWp%#R5(%Ql7Z#Ui~~f=
z7zdyjA26VEN}D;Oh?0>o`Wr0JE)FW6Xl+otEJnwvc_8iQgqVC^3boNLJFv4oGi$El
zF+nQ-V(v(LNTCztFZ5wVJbonyFNN5fC+b*YNMX^`KPAJ%6{iU4QfnKc@DLYi3N+Px
zE|x48=z`jh9Gn<UT9G=^o8ZSTHRBo@?hKFlIWcEckrOK{XxyJ$16qs7rBK-~dvDcm
z(V)!wf+s<TkG0;nzr?Gp=mI?Z0DYby4<2Z)0|A_U^xr+FRt0ZSsuE9C3WY%zC+aWr
z=3^IeT8&U)<5h@TX-5m-0a>s0X<3gVaLKA4Y^L?CVIZd>-CuV8&SWH(bSZ^YVcQ{C
zF38Yxwzy{}^^_&kjJ>MIeN*r2G||>7B!stsgr?i)LtbMb<)-PX=5FZpbVs4~r(%zE
z6`Fg4IR2ht>d}G*=);@u_wxg8NJwQiUPD;W(}GdL6^0oXuSf?|{iC+n)Z|WsH*WXf
z(FJhpc<{g#ZVg^^A>+XFGv4s)Y5C<iyKS_Q&<&ByIBta?>C!08t1db!FN#&ps_QPj
zr8WZ|g?bC)C7tcKE^YAAkRBeMX2YO8wdm8qf8QXSd9^c@5vW|wi(9yKDDZ6CG!k|)
zBb@lV@oVaB{#hTtM%>`37pDF#RuOgk`#;GLtht5ZPq}~$$wK6)O<_UMf5ba8)-wBT
zIJfWXgycr+3~7GZ0&NC(nq%ATcSc3KL6+$eypxw~(Q8`>&^`?M1Wf<JB;9i~B*g=J
z4XfJ=hU!(WOl><5$~_gZ36%rDVW17fIjnw>x?*sbp7oF}9!wWn&HK>j)?D^!!JG{4
z|6yO#|K&Dr*+XtMjOQ(kAYx0aiOTXi#P#L=a{;?W7Vsp(9_1f*UL(%$TZ7x6yxBKA
zY0t>xZ}g1G*_o>_X2~0h5*9?@=`Z0<><w(KUs+~;8S}${n@9x!&8z>wK`usvFap4@
z@j!WG!5?U>N4)@jDJtJDwq^XWR|TzXd5_eZheY@0;l+HU;H}jz60JUDBU{qC#Mdw5
z8!MG{z8CH_td{qZrQt6~qIne^2SJaBga2OVLpx_E`j$gPUcec(6i!2WH5ijHDMC0*
zuieA7Fruyc|B?13a4~n^|8|jNosm-1^Vpi|A#IW<>9HjA(4<X;L5rG1r3IBRM50tf
z3R&7F)4nfSv`k1FrES`^QAz9X+|OsGBEGNx>-B%V7-r^v?mhS1bKYmU=iZ3~PUiW+
z6@Wf6P3OZK&r|U}kgraLO41=#$<RL5)#+0cJpL^b;M{zNVgwUdt{G!tC0sEG1M|?0
zWQN`q$D^nb?^oqsq8{rW+QmbZOrNTv)G6=)v|+{k84DI-y|Hf>=<Ebs7WJD#ZxKXc
zhM59*U2v&sn!pHzB{$$=)2IJFJ%~-$>+02wa8De-JmTF-Q4X4~QEx=e+JEqU%*E|3
zT#H&`cF8gZQZkTgG5dV}Y!M^#!K23W;U}D_=mJ&w!8I@bo3Hiq6I?yhCN-=U375|t
znWI>#>gd#Tx^IoTju&+3xYK^f{S;LhE_InBv_`n%g{%3MIqPeICtox@E=_^!SGk8A
zV7&MYU$oZ9wxR1;VO!;EPR4Bg`dT=t2dC`J+xkzT>sN~}O5e+Sq1{0kxf*91HzC|O
zT>6)2(3~`1;n5f0lcXH1-E3_eE6U*F0|;eiO}l!PdoFb^HrKx$T_%pk5gVW=#{KSU
zT-L5#T`MME{NW5P!=j>G5d*-1`(!UT{nUZ(G`cy|b3xDm$&3qE&Y#)h0Cx<)KYFex
zmV*PcaBD;JLnF6;PD~MEErr`>p^H7IUOhWl1xL2EoQJkY%FZ{_&PbFKb{hH+u(S<=
zD}Hz)YfmS!4PwQ^8N1CbW<A~9v>W4W$!;xYO^ptB;RN!cY$!xKoN<Bwf%v6*h^tU&
z_}2{x4MSY-h4%?;idWP|(?{DuX1A^Xwgw(*U6j6QJn)<@jtfdQ`y!kb26wR$_P|pz
z$F6iyvXF;eu{YOdf;erOL6->oIPrjRFA-eik-{}lzy@9}xpp4w*y=Thfx4@+E;FC@
zwir6K?6rHA3a;o#26oV>4_-Z%vTF98pc?aW#TO5k7ry&CzTtze;w`j(_Gq^}A@RQq
z0s5PY05Yun4A#i5KC#YqLLsf%b10UpVYBd_%(bg&6_hBbO+uGKe%&_;?t7`B{NYrG
zzv=0|^x<nV3%0?7$5?;aBAte7fwj>tqzvZJp<97#%<lX<6*Ohx!ru8%q4+I4#fE%C
z3&I|drBw(ZlLku_%}fyfUc5Sn3#cc;tg%!bQWmIsB8<E<8B84<s#Uf(8(m&Y-XwdW
z6|t`7OTd%R_~)-0MU-MjM~5Ru)gwomBZqg@l5Gkq%4nQP99wzx!1Srrjw6<DbkXZU
z`O+C_U)D&>15S-snTm?$Egb_5xXn0C=hFh!vrADaAuf6vDr;or4u4y7>*~oXma<v9
zpSJ31*G`bI9Mv_lnd_e^+wIsP?Fueuf17US`YrJ6qEv`=HwbTz6kyHn_fp@18-d2x
zkTF<zAYeSHkC5e#UC1Kit41{>FKM(-vhdyI8nZ?B@^(KTklm{z?IryJ48g7)Q6zbP
zxRK}Y53yU}?v2%y_XuUVkb^vIQPJhxusFC0CPSD@F}D?8hc5X5X-<THtTJ7`E8DaC
ztwD!2HKE-xU;r;`<2t?7N|xfnpOd@0>Yt5-l0nb59JYmAiIjnTDj78{f^Z7S;wu;C
z-XkMk!iPloJK>b7>l5f%P<#tqhO)>7G)1!LEl$<X%I$gPEjM{0Dtd&69-STmm(GkT
z8Ol4AHFX+_!DfrKN&Rccf@FNU;+0mp?%<gQ9}(cxC1&vQP!He#{F30>n=`}dPmQa3
ze++tMI1bA4i;SF$giV|!J2Q4Ix%!MO6+ZM;+;kB<GJ{Wc>g^97oQsGaK1nw4y2cIm
zdv=eMm&>oZ;p(+4?0(%7wFVz3paEQjC|VFj(qf`Pr!p|75=YE;2jM1>y}OG2%pu%A
z#B;1{erG~k`h^a=ui=TpGmsdPG=`VztuM)b(nODj+o2QZ-n)o53JX(~DAhl&^c)s#
z25Zp=!w~9IP32P%Y)_w>5w4QC*wp=d<+o#VDDe7(3)`sBhD!rnMvagpYQH?q-Rf-H
znTTf<?v~7mE@uBy{&Zw4OkYBdzxy8p$a4DhRJhNLc61An(92dmt^tVa{V09bv^pc$
z9w|IAotOWne9uy+m<DCx<zS#tM5=<zir;E1UWXtI>07Az{T)<u6}peA{Qat3Ni#ts
zpA+Tt;l@5gz9^07Dt_4K_jaQZT0vq2c$&}HKhiiEv(nx2pF}VFp-Bid?PmnKsUYXG
zWd4<z83*p4g3Uv0Y5k0Kn1zd<-N{IwdphI5%bPB4d47no+qHyXKR&eYi6!Ik+1j;^
z18A2Jhg=T6E!0^2liETF_+Gdi8*p_k_?>gHe(o*=pJBn=F~X3;&N0jQ4b_-Y_r<jU
z*(n(}6*Rp(bUP#uHX>%@P%Z|+W#7;&B?`JI91~$acMJJ#@>)aaCUlw$b7Zb$=2E3Y
zZ(YAhz}-QM7D~)#4VWGhw$R(w8E=__ZU(~P&K0;1ddd&f&vCN{F7wcB3hmZzmtPTt
zda5A>N9JwNKm2b=nXA`JHPq83=Kbu`$2zDn+b9W^2la=zoY)Tm@{S#gQ2`U&wvBfs
zA?mu_I%6fW>(kRK=B-z}9ya$Xjc@pkn5f?>df}rrAMal-9n88i!d|!#_Nvh(hzNV1
zYswd=KgRuDgyJfJ_yQ$A`S-6Sh=v0@ErXMftlb3Y4<55h;C?P6H`}7Cz7Zo`RaW6f
z_+QU|*J5~oqh{}g==~>gpobgQ!PQ$R|LL3H*)AT=%;&hNV1}sgwy5WRq%AuH(tZ0*
z2SO16MxPtTEX$ZCx#pUMb9)hTZbfqgKB1fE@f+sxo9FQh>1V)XxS#*&=K24Ri|Qwh
zdSp4hYWw5Xz-_EqQdfydD-GCEmW{?@23?nJw<k@Zu#M~0q|sf|okL%|nK``hIT88d
z(qG+g5tC|WO4&x5$(t}}H;Fa|Ndwup@_R=#okrkqhr`#)r~&e^Zw%GeL(6nt0}?-L
z*%#<?v3f>B<^0a9Fn>9?#yy?448EQU&hC%QCVmn5dbc(h#jO0&lv#=8w(o>|;-$lh
zGlNPlEtk^6`V_Nl<QF-g=G&HGlg?{ds!ZQdo|R48ELG=WNoh488EtaMnprQdb5nL;
zuYL_=Ps7_t3iE8aA(oW;t+gNBl$<vJr=66C*{Wz>-@Z+w$It1`5ZP)FH>Vq@pF){;
zF0wnwRBB+`CIfbj+5<5+Vh9bo&iar%g<_$S)CEj{e}D~X0xtSyNo4JM(dANK<2R!l
zp_WUcPK&?(zS9T9)S;3HXSfAFBH^uEP`9z3)M4j=4=ZXhPE@+u)&e770@z!OXUYci
zI(ei9z6Es%mEOCPSyJg~%v^_tP`EIa1rLDJ;_JTvvDq^FC{a-A;|p<hTTd5aH?!<D
ztq+l{w$<RGwA?CqfeB8XHpZ0j<bQ2ki3+ywW|+Ho8<W)0N?{GBO#8Xv5-Gpf)`%t^
zsf1+7(r-a_2ksM-aw};4)#A{88<vTlJ_BEL{WKjf-Gwgh@#VG~!u<DJtNV#<lp09c
zd@y;Llg999RF`N#>VYhQMi7u0m_R{(15H6E;J60y({1N|blp8V7#MPSxzxa{hPM%$
z)&2OVb_I3n9%#;j<oG@D$|GBCG^#v%!)dFXU)XwPj-Hw`TsIS#hKGyNmf5_}>Bn@P
zlbTg-IW-P7B#)Cx%><s-%5@`8x78+uh|M@|5H-6&R(rP86?f^ftbZ&C=l>eolZ6-v
zPY%_B>=xJ{q7q-hb(JQT^PT%EU8xtDtFIm&x?oj6TNMF9r$Pi)6dpcOsJ_kHQoqZ1
znY^|B7&q{=rDZ9kkFKTLT+ObjJ)@GPols6qoa6R3>3VL`vPG<n)c^GD-m&)vKm5^^
zdZn`vWV$S?3tIuil-kuZ;3Z)Sr7B(L>dbi^t^9^nA~FVSyT$AOYtpXek;+b<<EE{C
zLF%yKs@@G5A%-F;A3bM3T&K+{QyY>xG?e-^=vG_M8~w-gee95+K$5B+sU?VaO{n6^
z=S<)9%uHWp2Zc&k6)7l;HMHCCgs2hjk??J(E??OeuH=86%u{qI(l1Wye4}=evXt$+
zSYilpe5|vTQ}E6-<$29dSZWh>7aPL<4Q<u-_+7OZiJ2}`FaNhMina3&*)9xUZLrDe
z*&E-0Hk)*sPzUkFqoiX}NNza<-9YH_^vQ!ynZ7jhWSYd;V@l_3H%QXsB?l7cM6cT*
z*BxZr&}dKzck+*%s!FngVwpyY;)uR=g5;I%pj4SP^1A$Yeb55Pt>Q=&mc1hV-A>QU
ziiuKoC|qH+IBzzO9x?Mm<mc)T;pG1QBR0bw)q;+Wh1!iRaC4$_@@R1e&1mFcH&R_l
z8DesT38yju(v@|lCuZl-hBC{BuCNnwr{49ydj@VWtd6%-GB7r<Vaw(U(m#E&T{!Ib
zbU1)uaF&-6lKP`?v}ntudG`9oo#?uKys!~5YtO8t-1yLn*PfQAR7Ac@EtR_RLs<gW
z$U+4;0+e70&NQ7eA0Zd_8JA`2vi|worT<5h+WgUHZp0r$H|x~4qW{$tWTE{F7%TNa
zIFf%ovwT1^<4XViRu8q6wGTXEXVH^*v>oz8`%GKW6XCRV_V`k+tZ{>d0Q7}<m+P4&
zoqU!M+*mh{Xd0a!K+L>*#?N-4g<15#Rj>XZBH6$o&E9{UAA@M#_l99LQ0@od0=-D4
z!RnoM?yq}PK#R0c3287f*jq*WP{Ix+DF5AS7~HH@1(>PF0mn<y&i&(3jzKQ%t5rWk
z9f2Fygb+u%5G2E6jq`C>wp*9l1sBn(Ka|prTc>4PKyygqS@EWjrZ{T}27--%`>=F!
ztG1;fI76l+o%U%sKjh3%Kb#XTz-$>X_~J!kk|hSTT;xpX6CJr1l2y1Rd0DonL(<yA
z)drgk19{Ql*#PH&oUpsoxOxW97}nYz=*)U4Ry$p<u}Mw-xo5)1{$=5ti3msMbs~gA
zvjAMe{>7|i%Mqm_H(s>ik{NyEU_l|R&hg6VtARmTWvPs^c|}G47<|zGUjrs|1<8jL
zCc{zcY_Op!>e*j|${%gsG8!U&cGZrdx>QyXt-t8yx97=NCseR(T&gD+Lz`r>`SUX!
zS?eXs6gJ)<W~FXAAK0%yH<dcaAk^TR8*i<cS;o?bkzHmvMBpg!7h@KPBUs5X^Ju(9
zs`YUHzqKVLm9&y*`;p8NA&<7w_eo^OerfcS0)WnxsbC;~wq|)hZYd8$i-XC2UF2Xp
zUt7E1qD}aeZj*{vPC4c|fRy6H6=;B8GG=0%S+uQ(7t7Dre!y#^*8Y|zD;Wy*2yvSI
z1>-bkn4vl7D`qyY^R{b0G<dB~cKdqhi$T#sOsH}zKs9(U1VfK<y@RCWtEoq<yjxk;
zaC$UxL4u)nZX@)RPKyT(fk}XrBKCoEawA<**5FCpTc_eD4oN5LR2~p(O)j+wA?uw^
zdjSR+O_^hkIl|`|LJY}j2v2%$y~?3swZUsEUu;^z9k_si>S5EsCDpSo<95h3<_kc}
zz+__8)>2oj@tF956-UZ}dnlq+G^1_tx>AQzV_9y8q%yKF8uI}(utop5t+rIc`VBeN
zZ(1p#7iL&3-Y=PQ2Un}w-_c=}SbGB%gGDFUl(Z_EeU;HTEb@0_Nws@#5|6$uT<@<b
zY@cEqUH1S})vPVQT{ChSt$*;w88~}gDp<2NC3bk0VMv6YLqgZH(2<xWlCH=%0ljAb
ze*K6q7U;;;EpU1-8^SM@QS_OeE*?m%wL?q%M^=X)y5(p4F6Z%;#IK?bYufl;gg(4v
zOtZ&$c0U|!%mP?)T#7+6F^zPzkNg~xMSEA6qnL62V60zK?B=pMgH3jh|4U%H^-db(
zcAN=oQme|=!(79eQo(J%orjYFdwQO^P|F2*7i_u%ec1AJW&9-G%Zl7mR-Ecoc}dKg
ze#u{%01g&Rl!~{-e6k74t}T@<At~2wY$JF9pP3gnv&$Txl%oMN_ZyUXX3#7#_~dHU
zFNl|Y&PYl9%2^{NDL?rPOnQ)0Ia!90u3#uEZym{j<1q|;pTtvC(5l%|>K2y~cs)*R
zI9VKPO!mX50=Ifh5Pt~heYbR%UmFMBeE=~eB4A)~Q!N0f>U;_=N67mD*and0=$qN*
zS?7CCYJppOF!{M^+Nu?Aa%d&e%vQB;Ww_4K!6OGG2Rp<;i;5-lgi~I;MR9?UP`+m+
z=-pqvOEGO1r2rhQ#2^{@*Id}QXj1#O-E~ChO);$x`<zCf`7;lg>y~Y?&<ccTM}fm8
zB=1w`Sj>Pgj9r?J#VjcWjY3*v(pAMfN9-{G;Wb!`3U;!2!P4P8EOuq4@EOREQk44s
zG4+LcCG-Z}6hn&*QauEd0etDt!~-rE#AI1g0^jK>@8>V_VMZ3o<RZ^Qh8eTUOPDx=
zexajA?X#uqjr3t1|J1^G2ux0PWZA1V882;0l@GBoc#TCFK*x;+FiVkR)B{HZGiypZ
z&0oR2|I~P={(^v!E?;H7TeRNuXNDNBvOjKgSP!I@UT|w{=Gaf9O$AvKCWb>}Xvk_0
zTv8D7gR_Z3C2V#Z4CUK0Yv2r18(i3x7yU3@!^y_m0m7`|kSs1;d&^+yjq4$J!x_Sf
zXcCHFN^w8HoSgBvaykz7FU7KA)^yLFCU^c4J{l5Y@Mt(4O=Sg7p{Onw8VTJxPdK~L
z4tyMPkx!lckjtUa|1fh6G^+yE!xv)&Ph|~kh<j5nj2d4ic2C=c!8G8<)M*nJH2)&=
zg<xfDA*>r`;=wp~F@3?L%saL)#3k;<tR}COE82`XAu%+@S;l3Tj*}%p?t;y+Sc_;m
z+g@!-zw|#Hz+i5#c%+HR3Ai;(z1q;5h3$Nj!YP|OC`C>Gv)7M87LrRWKCB4OxF0@G
zGDd<rNrySYSwqqWS6(uvS+ewHw7!5I`Onl=e5fHsS=-q7FJF=0_yTyup$y?GI9yz^
z<@49ATmDgJ*@F3RuY3wlnD`BbzT?aKUhA=qtlWk;TWy?^g~`o%GtuPjFfSE#$&Jo4
z{gzvdbiofU?JUI;3Efc4(gS}#d~WP7np?IA?*W3V&u*)gvA~@Sz=FdNCvMjXpGAxf
zfT(P^VoMb$Hblt}h?&){Xq<U1$ZJDTfZP3P^qUk*TYnw>TJ4xvg%RfAviJB1ZFcWU
zFx*jl_-p^Z{%`loPKQ`KL*sb}X5wi^pse`l5VgZF7n$8=21PZ8{Qb|&sKplW-92J`
z0(h;MkwSs`Wg_xYAz(90^4~8KuwnsxVxeLux)GBrjw{OXbeSz_I!O)jXZ!~Tzi1_4
zoF+~6v_k{I)R8mH4gNJmSceUtu^PKfaYA|=7w@(STmZ-@_4PZ~KH{$NRMr)lXbU&N
z;PB6`t@|8L_O-UJad^-bcrHZQN`dboTE2v@qGyeIhd#tJ1{Q1UBQfy2#l>Teb7SfK
zUE}$iT~Y?Ag_>tE;cL#M9l{iEZ$208IR;TazobTXP1T<zUm-(BdyUeF^<e+CZ^*aD
zMUDIl$D`k>%dbK?QS^X2Scrgk1FS}<_S;@AGUGFKM3l=^XCkKJY6~zrF75!=nH6!*
z5<8kCzx`1m!5{vk`kBGc$icmY4cB9Z`ns(L2d{C~acry!wpTXhpyu~~u2onjL)jku
z9@)DjsWAlNdH`I+x+D$g&E*vCJ95wokZ}g8l=EqW!&FcwX9r>b-4OY#s)x;yP8K6S
zJtiqT{<bDmQ(k<ZVU=p_VeRe(@gGXsFOWMQu${-JMhgeI9S21qDM31JSH3~yLGzQZ
zBve~3G(&sK3GMq}CB_GUhl@AJJ5j-ijUx+6_l<F0SC&3pcP2HlX?Ju?s$q1)I0hAb
z!psO};?X+Qko4;xmKwX=dLmv*?mSkBsXP8{PZMSdCt$TPC6X#1)?S^t<j?%P$w#p{
z7anfR`~JgH3!Q||M_A)@aZ-X@qDA@TL!^7*QuZ(L@B?_td8bGBl$JysvC19*Cx|OX
zS#iJ4J>Zbhr_-mSST#bW<kVx_QudHr6G*=S{^n1j6yuX#d;M1Z{P?dw?ycX;r|mp}
zo6C@zO_a$m=Vr-8CRyC<4S9P^W^_r&IS-o&Yq1J<L~yx7A=P`n@ICzD;f-so`b*fu
za)u@o)+I<8LY@hPU1V<MGhpS7jt!UbV>TALkICH6&41Rvs!Sbgrmvs<R;>yA-@x%U
z#`Llx!MOJJ#QA;xWqxM!G|HZAnb5^M_g_Xm(g%x1aUp^uwE$P+?I3Dc#)T*diiUkI
z24i69aTNLE>G5>lX(&BD6Ki5ws>hFhEcSrO#Gi%5vh62ZEQ7-|UDn`T?cX_l>b^+Y
zO;~d<EGO?+qTfqE33ied@E!XU+$Bj__!4tu<v;OazxCQ+Ke|TQ8U9k<cM%2mbG%9b
zw23->7k;c@eUKZ?NY%h>8y;Rlk603jt34N)NwuL2fp9*%$f?K2*f<f4wijPw$_Isg
z-@|Z~&9;z=8G)Y6!)YZAnxD3WV_JtY0OeRfPvs=2zix|4{gJO6fqwL%3vTW{8_8Ec
zO{(-;9lC)RuF`DVyyKhmkzgl%BuV686cAu36mD)lnrXLehxo;#HWE$7`Lo~IMz*T)
zP(rRYjz$%<Bp?-v+=N_qgvuJZxQ8$AKP|{{s8~csZ%<13mF=4hHeF&acsCT_{X-vf
z{k&0<6Q!2p=Wx>%>((fJ{#q#~w08yXM?*7|s&8fOv~AR?Ef_uJ+W~1;gD&Gapn)ip
z?dyM=lT7!XPibEm#(J2r<Yb(mzaxI~wxHLzZSGyWckMQwn+Y|eQEWSGYT!ZtGN#GO
zBbE18Z+q)h$j?)n$hLhaLWjIwak3<)^q3Pl3zD*2Pax1jEwDm^BruC7JL7V=WK5rr
zkkr@iX=}eBol#@q#0}NrUI{F1sdA8v=80*SQ?~mO+w2yexz@{Nb8&CbuFS1mu8C~L
zvtX8`GwDw~@?|$9#z&ik4UKl$&}Jqz*RN*76sG5akbq=?`~lm3WX|RpaqjDAEO{kf
z*qJoK&%bHm>N&m#Rn{zdvhD@%0gc-qwk<fei6>unTK@K<B)<RN&QEyXvij}H+ny^K
zi@X*GUi?=;^S=ht-gW+~H^1HH;<|gTjm@%`FV2zwD}7zJXl1eEn%Gled0yfsSw|xK
z@;_c^PgdqH+NSs50xQ1hf>Y5*wv#UTsL@VOW;DNPX_|-XV56X%<_f86o1<dGXKJy(
z^gS4i?X1*vKia=5d9BI2y4#nWqk3W%F8AXlWjBb*`LKgD56n+utfa7S&^@JHZox}D
zyfO30^y^K}PhUM_Po9nfb%$Mex}2kys~RnHSV5Bd?iT$`)}7IlZ{E#Oo})`4<qD+1
z<3`(AxxRY0rKz&*jK=*6dyL!zUZ2dF`ta3^9m6kZpYAd34`dq~D15u+{ZLLt#$S}=
z9dJNFEz|gib5!n31+f{>g@6M_26ZQ^F>d7}VaxtbdE0d#tuC6%HmS;uc8}hy{<M`H
z`e3a|t%!u~me)7b&cy#a+HyJT4(YwQ9D#jf!EI^Myshv!&r}65N`9VB=*i-#&x-!(
z={w(2Ur$NwsT6<KAz{{_8Rw+6$!D#IubR>Ws_4+;<N69TIW=;DKh4k1P0f_htIMZ&
zI9Fg5aH60_jKZGBi%7c7Twc&HDtNT1Ciz_Za9Mb=;Vhvu4Aru=D)WujPaX7P-re))
zV%8lhVY3fUP!fCRb2=}{`>yop{Z0+m`(17m=lBNRP|Pz9d+5!B-wvzZYO~;SoT=-h
zoeNLPj(%EnInY07lP$T2vGD6HZ((*QofelVZL)#r<L8`^o0TwnGW{}r;WQu#n=AV=
z-IG~6J1hHUlKm>4h=Woyh{_{<5ract>V`s{ybMRel-}qR)?@}n(@V~{Ui~UhkYJNe
zEUX?_wdOSW2`O7+eSGr|5efAZ+i|wZs=y*(1gahj5nE+z`K^1TvFXsQqAjmRRcFcQ
z9bVAj5_vx;cSrn8+B&cGIikV)r6}!dzqn-eI7fYGs>>w>Ypw^GK-@z@Mcv7hE1+O{
zP1eJ3UjNs7x;_z=>pPcgY*3y_j=JQ0eZdkD<~@c+?d7bmD%<W}$X6S#_1{G;y?EI<
z>c*1Gs;};EeF5U>dJ*f1g?DR~?Bf4|@LH+kNk+WAu3(^$&%pHAWKulhmyPuS<p*^|
zTkbKJ6C~Dt>0MymrYGd3Hk|bG$Lzmw83E1#MVQ1Du85aE;rd9e{OVVNoC?{jK|~^+
zujsDstosM3kzvkJN4K+F3qb_Px22_bOTttBivPB_FP&9!HqFY%$Nv83VR!SqOM)c(
zWey|n-rrilCbOgF(MlJsB(_rzXwC+?L6ev6hZiqQh-L}Z%rt9hi3+TrDe!)eb^ap8
zjRhp;hLgz)UoJdO8Zg>^*JoivAn8h;0D*cbD@EtFw8}QntD6geUh1Wp3jXz$Y4Qq!
zA7yT5gv=X$bJ+D!<C7Dl0Rb5Pl?@@DHidCtG>>Yu)0~FMTR{zTp(usDSF&I&Rn{Sv
z;-ILg!mud6x{*LWdTAyBrbS(ChW{6)TI$7IVvuzI%{QO$hno$`SLw3@HPebnWUUNY
zpSAAl#_y){x<t$-)OwP0v1fra#y>DOAQcI;=D?d?!SfN-af$aBFd4>uAGM)>N$hF7
zAPowc88w-g=|-!F<lD^nsXijU#uj{WDK6ewj&z1w(-$wd^d=FBe8#^b*WC1gH0TZo
zgn7L2X_x6?5|r*aS5z<L`G|G=mrtcGFtn|7F7JD7+~!iGd}M&KaOBK@?buM4=@mSl
z(kd&_Sf}n!|ESL2dFY&dt!Wbdbn|i7mCvTtI%X^HN_{=Zs~bSN`pP*f>cm3j)#oi2
z!&uYMGUfWFQ^a<#crNJySF(-g`yG;^5S!2+895JeTE>#+-6~0ux1X+XcC3#$(VuGS
z7WQCmM3!-4&=(O2jGZ|M4$;b+xiX+nQm)R5nw}>~_G#-Hm#gs_249p-sg&y=KQta*
zfBvF=#PRKt_3C|#W6lK$txu`k%=lON$65CuK8B8tts7}d*MLN9xxU=O7=u<d13Cr8
z*z-mwyuQ#mKA-A+Zv8Q<GS$M~BSyM=?q*W<-5q{Bla~~eEBc*3_p7p4<ZaH()Oi@d
zQPA)UA0_iDZ`L&4VZI8wcZjs}&bc8A>)5RP?P2jtKcCCoc{eg`8trl9+A~rN>{-x+
zOf(fhd1ib=s9M>!usOOG6tj7@*S&9QMOhh%<qcz!6{$uzJ{M#J7BS;Qmk|gWNMLTo
z0);(NSM{m!#mCv9^JIu$S{R?)Zm#_<mIoYDJ44D-x#))M$7-`#A|RgIS%7Tj>a4sX
z!lTBTk}VX0(?j?2+Ar!KWL>2y2i*V(H1kv|4BSLQ2q<kN-H#YeT}@<%?qgB&rM{@L
zPDhc}P`cZ{P#NEeve*-diy&8X{L|gxc_e3Ts;u`9f~=>qw%-hh-^t3m-^3?)phF#-
zyTq%jXLeq9)7y*LHim!$_5>)hw|e5SG6(%D)571qYN3|ay+0YW7kgqIDf^88;X<C;
zkG`1kac(1{`t41{#*0n&n0ouIi|D!+jqMc1*riWUZJ0+JZU`b#1mosN0NZ3$u%SR>
zJejK#cjkBgH7sZy%L<vJYs<ca_&jebiIEmWA@owOWQ|Y{FrRGxh1uo0r}R>&Z66w*
z{-aX1B{*33%W{p>WA$v(&cXLgZA1IM)3z~P`}#P1F?*nPlWr7Qrgyi&Y%P+LiEF)C
zL7cY7?pkqF&I8+JPUi<Qmb6H_r%F2A+hn#qzs_P6Wk<XS*mhkKRaN2d%UKJl8+tBJ
zA@zCE=-wJ*oWpo<Vu?cjbm0NDf(L%YkfOWrXm_=Nb-E>q(%r;3R*tQ!TEOVZUFy;V
z^?bGD%||1j>9M2C=5k5G<W~A|Zbk9>nTBE%2@6j-Vom>p8;bE8hi7EGf7za~^X?#E
zkG;tO0Bs=&q6B*$&7_elAS)@<?JNX^0rZ;}V!rPCFi^b6x;}1XMKIM{cgMNPHTy+m
zgDP*WHHlnGkSU%*t7jWaDrBl4;9o53!jDN;!3|N$o>Mx*^UKdEfuIpjJ*(10fU0id
znX;Lno~!m_adyTHKi02f#>CKjr`ui+D!g!c&4CV`yOGT|)e42ujGg1xo>64{^SIF%
zIZ#N*xUABhYi_FMAAVeQgS%iwNi{2c6v1jtu5tKuKeCxPu|abguk>ljF@Z)V<^=eH
zTiIq+4}xSa7B^`7cuHgQc_&D-<3DK}c~9?#Zjc~v{IZ;1$(v=lqH!g~s#C^nhX5^%
zasT_p)r7$X(?|u+?Z61(N{O`CS3r&Bt)?hR-E+D^ULhpiOil*YK9PDwjX!>^a|ZeT
z0SVlyfD&`t=judIuYkUhB94=L=(HB<6*s+k$G3z30zy2tq+VM)dculmF?#VcH|L#f
za^%lAA?7+$A=6kK+QX<^<^TX88tyQAH28<5k6bL0uvR>~@XEUTK3me6A_qDyWhJ=q
z(>{}3Q+X%gxjXcvA_<6Tnyb?hCiUWEy@hqzz%YACnR3xvMlUHZpGnq6It;KXznUv=
z=p9hlFnS~UXwyDfy|0%qE>{yAn5UXq`fP1PzOlrCY^+J$ePrV>8G#1?hGhF@B%EUm
z-etBNT8xVnGPk&4<6t6!xQBmH+SVUAL!1%%H^uQf*D4DEv5RGm5ZGd!^=(oUOvpbQ
zk+`#LuI`yJAVW6BRihlUFNn&LHx*0N_FTH>qo^M|I8WD<LmTu09(o2^01W=j;^=_Z
zOY9ti3=;&UKbQEnoh6=h6j^2VZHxe*?3a$?9y|?nxjpk=1qI%!Y38H%+cINrtc|4!
zpgyzY2{O8KIWUY7jp^CIZDwF@TLWqM`iGwA>XdV>{02YLXGaXJ9O--;P~Be>X<$01
zyv0ZtvopLT`=g$p=9#P_w!K<O$-tcwfHct8My*X3k)bdF4i18sio-o;9CB`!cSGo`
zb4oQ|%l__=tB$j4g?J%lv+f*SUVQ#!AGKyWay%w?tUAAIBY-KI!b4o^*n4qyBA+Hw
zU15)>d&7!6xmO|T;-D6=8s&1dt~Xv-jI_7hl@C5yNdXd^8c1rwBZ{*Y+ductx>(<I
zW~!|~L3>8b6O3qbK~|6h8Jvq|us57_1!)0oEj{=ldyX%oP#n>~k&o%*@fG!Cp1P=O
zVz80xqQUbMzwTX6u{PQ#^?JqJxPTQ;Ox+MYm;kS&OyL#8mm6H55iqxk$yGbUpH1JF
zx;fu@THBRBv@~cio7>oOF|)9zbokTY9BvmN4pRuSV|@?5(Yc{uKoT{umFbvrLNd)r
zVD6Z#{w!*t+6uG{?tg0+t6A2&X+N9pK`dU%?FR&QDv3L>?W`Cv$_7?cQ<Y2tp)m~O
zEN3QTf(tWwc<y?({Pc_c(>~f({P%}3Z_xQF*7;4RZ?&FpX{()aMQxPS`1fV5^38x?
z4uBlya+%&6+x6qI`}etyR!--voMcy+7n)`{x-yI+Z3z5Z2b<F=A{uLc`=GfNt5HSq
zKc0_9pDoH6%{Q~Y;$31WunOoFT!kxcjBw2|qmQ*4tmkb15&eGak#a^kffj!iUu!Jh
zLT)iqa};#PEr?3n%VLxd;2+5^2NVKdEn_DSPH&id{7`N1eyyn9J==H$34=#H1?~1M
zN=J{&&;O<E!prp!YOcAZ%X#o%D*6uOTjk<R0`6E4*rCd4gQ|&D3?r}%(KtauUf{6J
zfOG<&E<6KEvT{a?H2ZD#t-ofFg^arR{$3<(!u<{+>~Yc^b9L-_6Qk;9YMDgE-`YBh
z{&L&U_3m~}>j+!=;w_Qon`w9d?eNtSZ4nRN!4*)~DZC`EZ(MP1ijQ(nS3$Ai0pQSL
zn$SXA*05-gybN=@2y8Pcs%(QQ@elITx0Yh<*xXQN-hF*=O!kF*k-~8V_a}kFH1Q8#
zOjI#&EV(fJvuK-jg5PIT_1^-tHuws1Pz&Q-sW;O`xudd8Seh&1zv%9tI}V}tp)8L6
z)&@paTg-(liHX`eQ5&L7n{$#2JSyVORL46HvW6Yqf3MaPV!U67FyF<JG>o@tB^o*n
zLLS1Y{o~-X`6As(B0WbUJ~?x72zk|JV*|58pVHlKNuAe<i^|ksU+GKgG^$i=Q68IS
zmL3>r26Fm2=4NY}%(E|U!q)>&=v)cx46IUYSvB7HEI0`h#)(;x*1)el;e%O>v91&p
zW9Y+KYn;1Y3tx|^(r%aMt_;nQ2_}PU-vB0RqdRhzZ%+AJzd8Ezn*?q%Ued?NpWCgH
zSN+}<xzCwjcitbM&NN?VKINm)ocDn%q;xii-}-|vsfkd%UF=)pwI7xj873s`)*QW4
z*n5aKfJ_^so`9L32}D+hUX-Yk@ta<$8qxbV?{EfhL~2(?o5c7$Lh~=vCqnSU8S))p
z8{+nyQ#O1tMW*B2_`FKNb({#9n$z`Mwv?GVE<K$v67jE9_&DYo@A{eFvO<;?-;aLm
z6{-8G|81o0LfAOH?SL5LL*(l0Ny}*&$>dI8t21@t(m<fc{RSSpIA)1*D~70t`2{}&
z1~k1L@A_9(M9!?eGd`3z<>%R$emJ+PS71zwgVcUf9pBC8${Ag!js`N)RNxC(pd|$I
zTHG6Rn@O0<OIo6!m2t%l;$@VAqhtg_L!(P>qLkg`jQwPIZY5>+x~F#!zI2C=(0|x_
z(d%wcY4o~|8jN0_=K7*n=xRcf>vXIkr->R1YshKB>FfW!31>J?FZghGf2OE+9VKA&
zWlC?zZs&vFQtRw@h8;olr>T@IF&Cxe)nuv|q1j-0lesWk!gYH4Ue;F4>yTJQe1N5I
z-_QCy{39z-IduU)*sPK@ywVU`1?T#T&LFQv_5mI~MAH^iNOY?2fM2-nq1{p*RyoQu
zmGDwz)jyA+_v;{&tI|{!PQz^$pF+Nxq($wj8RX|SI`<F2;@iaOp5mF%B-B)aS1}~(
z)`Fvf152iHhGW3<OOU06Q1ff-`?b0s^^C;TE%b&wEI0HWMz$eFa>fZnF{~*vO53rd
zg(tI*8grQK^!4#~;Wo(XDB0WIT0n}JNj~~c8D>Hoj(nu?Ag>~J`CT*sV<p~2yB^E?
znjVktN7tiv5|Gj`pL0pTEsLP@b~WG{8jA<sBiZ=m$rKj-Uc<b#-hV+<DRj{6<pwPu
zk|(#k%alqT7|4%E*=JHJN$n0fqeLBy>t077_mI$_gGaaf0}754af5EI!wOcHB;KjK
zMz<<c@2Erh*&7RP2p%IJjnqfHE#J)haR<xw<^qVixD@GnG2=zGJ=8VIgTIfst{idY
zK)qk))P@J6@T3~y_oKC|v0BBnnI?9=jIgEgrS9)r-5xc%>VOC9z5tfV%yTA)40smc
z2ch>6;gyEaOZ3vVY@+r)JGR_GRVQlyRA{}KD<GV?Aip5DV!6AF`_6Eu*}X@SZ>gS=
zz}AbEaU;Vxk#uq~SX?AYu4y+iQ2HXJA++(_l-j2F+^nK5Y<q$byrN9^mYylWD9vqD
z@>cG;C5$x49u%yF*!HsQ*n-1*@RC1e7!?lO+~0A+B}2As)pXSJ@8sg)eA80;2Rco!
zf0q!`%E<rKZS&!o<-;Nym*t6;Ty9wpkLgm3b{auoA9W2A;c2`oM|Yz1M1^nzX={UY
z)pjLGGnoSd%ftFdvpa7tfS_O@M6=|cqDeHh>9SfiPkV^ptn6VtE&Au|!dpGv-AsM^
zj(b|)75amj_xAu_jWyAX>`zP*gm!I~N|~9fL1N#CY1wBfcZvC`&3^q2LHA~vRpWl-
zG@8V#M;c%lu>cv1-xOfXE7_r2&7@L>`d+A(*M-l~)fhS*6n&4A$;x_%ODUE+1LF&d
zY`&dUSAHYJkKy)jnR|O(PW6aQK!83ypd{zTkggIx1mCuEX|v^=t5kKCIP=m1Nh3pp
zsWz=$6{XCzqXYtkm;T^^{nL+O$^x|TI@MHJi=5uLst;mrD?cxB<8BNTAtI);zX+xe
z++>*@dDzvjF=u-bY2@5v;nCs-|M|)hb`Bk$WQc1)>Ri)MCfF0Xqe$oOG6NOE>lylx
ztb*NvhQ(WobCnt%jqMF&p{_L#g#UXvfVwQoHf}b}id0wV;9wc%&@AzN8Ob9XEsx64
zF0_;atH8<gWIDdl`7!D(M*JSP=W$c3BbSRYENmt5L?I4erc~J|l{D9|EZpUWr`K`w
zj~pJ>GEVRu9LVB(c6uMbZe_zv(`VmH`2}zfK9V03rtxH=80CUOsKDhVqDwX>e^4+u
zESsEuRN-j8tGTcKcTR+dsD!jI*JnK4N%el1q#$Xgnz&lF_Ry7)V~JcDKw$Q>419u2
z#J<lre3(mPj*qP~Ldfy{z_C}@<FX`!Fz{oKHtYmy`b!@AL@9r$!@x&G{E?>ONm-=J
zOB6osD-W-ZyD*%s?^1*!4G>z`hCt{g;D8jHqlPs4JrUoX;Wp*1imyo>Vf-oWuWV0r
zgH;9CeTYNpED?n02;q0KJl0dXkH1&FuzP>~J`-=6p2OhlVZIb$@)qVnFunqAYDG9w
zxPV<i?~y3z-e&6ERw)oxO46=q+3wXvx0>QTM_2MFmaU(im*8^7nM8Fqu?<k-ok~Ee
z8HFp?PjtSbyOn<cX~(v|8lTitd7i!gQm>gRZzIHrs=uG5SpMwHb4KoqZEz>CAex=@
z>4@Ku;>GNFUl&-PI1)50|9RDkZVldgkIV%*FDh3#^={zJG#&_UmM6821_{x=)<6nK
zI`76uISjsGw+O{hII?uJNoC!ag&QQ@CE7O~wJPiMd)T(0<*D;z(QT8+0wWm`<oy`U
zz8Dst=t9;4v$5>ZGYT}#r~(Pf2JP}ZPjPke`MW-LCl*R{c+zxeZWfHSOfvNy#F)Q-
z+H8<o8f1D-Bj*84r{nH>c{43zSxG9HO(vzDl*1U;Q^3&#FzkqtIQ&12?e%}}cqL4T
zdDh1^q4<Ixn{iSCpUjw~qs;>VdQ6J?o=7U|UfnMFuS}7ShmKHZ<*6q*0uB;nwt?FM
z;D9gIFUsbRi^YI9vr_ccAdjv_0o8~`Y{*r!_?#ZAP0(F}&z<~m5-)DhmD)eB;xoKy
zIzt6AM&g~JpNnfub1sj|4cesT^87<7n?z*(owzzdHS_RdW{Z*k_gS|t9FM$#H9x+y
z-DT1MW{T990*h9=Oz#m3$rGo_>pIN4%ssOV+;HLl$W=qG>48m6rtBJ9@9JFxa*c#3
zFDf)v2*;<U#}@2rj&CZk*)lTCt!D!g0p9~0H(;WGw)Gxf4qKp`Z8lpLM;t9QIh~MI
z>%Xb1K7)|+<tZg1rRPgYms#zD0>%EmJmc#N?#4$g=CFn~nQ~L=VdcA~_LU9AwdbEn
zMfh*E?r*Ep-j%ccs!pXTUy2xG+2$Dm0%S}c-$_rFPY9};_p@$(?GM@VRM%Bv<ddnz
zg=Ov%BSJ^`;o)4XU2;>3qj5HH4B1ap(PXu%k{8DicpVFt#y}Q6amSY78Ir6b_|v%D
zf&76tT^{_cKOh7I?DY@B9M+#4&MN6vd}C91AwTPtP>f$wj&Y??#8<-=n^UHwG``mT
zqm)CE^$gU~i<y_zXL#!p<l4`<be<$pJ7bcbTasoR|MSR@j&?tjtrp&UttjW%0kIkJ
zs;B-(YY<t&2GbSscA9oza|>7bx43lXl1@iGa#$;ogW;w0OA5yhOw^8;FQ*<BXA)#(
z)t5OWKX7`OQuOsj^Mys&VtTxpq<=eE16v)uc3M=LPZQdBp9Z@KJo$n0cOmorTcL%_
zn&}F-0#|qBZd0I<Y2;o$f(*_4S;YIgK0a)@BmbJT+?d^2c0trKnWGGz(rVcDHdlFa
zD}<;7=icIocS#!rV+Gc_GqNs_O}mT^2<LRGbt+(L3_vG2sb|RVdnfidHXl!u$SAEl
z=hy40`*ouYsg?i1>mv)|5WpYbY5ri6{K6!}t2a}9b4&E1s_R^f{WMqe=?;H8x}i+*
zjf4PXp-$Wti00bZao#c?vPrSh=fZM(2{C%?D_f@%tdj%!m*yz({||60F`QK?Ngbxw
zD4a3c(6Kb9YVWHpmm?9D1vLfXc6MCBdnG7sJHv~rK7bNEj(o23<Z05DJ%wSbvG!aa
zVI0-2RPPqMS^0LcvT25v^@1lh-~=+(rZ%<7br6>0CPw79CT5*yh=Tmaj%{z^7JJ2R
z?f1wIqKtP6d(i4UI6kxYu25xVt4Z=1IK)$zyPVt5rc5Q@FgZZD4AEKLhd*P@Ay)Q-
zuL7HAkY2AQ#@L=>2RgRLMm!jB(RS)e7gxSIs@T&cx79YZ?1;yCNIC{h0BRWBeI`Z>
zgs@au^PFf#w4j6f3D3Fd0nVeb$Wx5={sn?@Zvmpoimu!e_pqTYR;fR-3$<?X>T2AG
z-PrH(CP?!S)AMAm@>~o)P4znzKVkCA@soI_juCN~xW!19+O@)6ZFGF4P|*?!n81!B
zLi?g}-8}UTJRWa7VO3sNc6wpVaZz{JpZJ999XC35y@(qq2rroqU8ncWl<8-b$4;IO
zm~~Nzc=;5DnWKzo4<SN5*-U?e1?1Xn*isD6)$z}LN>t<L(^XasiCmUrtoaL-96v{k
z9V%(t%{M(?Ny+Tg4WH2&3~1{--WK+z$3z`CZ^#aIm#8eatV&%0o^Kz=9s_qK`e(kP
z6wT{;NtWtKJQkI!{<3zHAk8uEGN)xN9QWX0b83RG#U?2?t3KP{FK)K##H?z9j?mbc
zm^(S{7wlv`ToNOH<Wy0jzkOJ)(FTt!Ps}hrH{pgT<D|#0tdTpvKj+<CqpMOUJbV~3
zAkuXw*94ki9v%ufxeUV>qQuR-*`igCeL92i`CfXNATQR{hp|XzTv|NVP+C-kZV7)D
z@5%a60e@VIw%T`9s267*b_$ET^-q6HR^3UO`JV<-l7MOEyNBtsf!U%dC4XT(xAIKZ
zO7<7^&Md3licahv#yvyv_Q!lF4|RkzIBSlAQ|bPR%o&)kOUpGv*$J*!G+~O@=_P96
ztIbXoyl0e1<ryKbB8B5s;Jbxm3!=p~Gc_{pjy3sXPa3?sKR&QZjZDACn!q9~Bz!_{
zCwF6f%>RLY{RuHWcHmu!m~;W=;xj!td8X>HfqL%psT^8auu*>2N)Nr|%zitSaw_EP
zz06~CjU%}0hLUDKO$tcSn3C~L(@xDLf<nL~?D^y0c}dUQ%y&<jm!cH864U7wHz!#D
z*sS@{dW(144;$U2x{+Ci{3M*Y>L!yS5HSjbJiixbEi6nLmqQE`#?%dk(Z75*4j3{2
zl^;n87u;gu_CGmglR6Mzrqo#TNtBj6cg$y==-WaL?WceVk&E%310jR&F);Me95w4s
zXg9E;A>OHTd^=8{H%{dWO;)yJuTRA;;qUE=-y!Lf+L<0JK^P>Ag$NU8g@=HRi!Z~W
z6=XBjAgudY-3RY5^R+D=Y@Rm&b&JleT{Z#V_oSA#^(prcP^^T;^$Zoejo~j!j5yr0
zmTTUlSo!wM$)Z8w>}0Qz+0`RtGwt69JO+Xlw~N=P^55K1xJW>?S~c<f`^=h8i)mq;
zfDPgdRJDlB6DQMDB<3rzs^*g%?G@KUzxEp`x!IoD&*pzvt_s<<J_s`QyyA!ymQk1}
zo@}#xYD|arma`5Q(%zaTd)dscwj$rfwNCo9=43s9q~BS0OMb)dmQEuY6b}3cQv=O9
z?L4`uW4?~$kyANxPeVIxf0SD}($n45l*bnh#Eu__Fh~ODcr*3VB$dABEgpnOT)U;^
zQh<10?PAjn{fvJVm%=gvV0;w$ohL;Qz1tDYatm`e5bp{!w5{zW8rUX7f<m-x`%Ij)
z-vq2cT4lqY$39=2>Q+o6oKFPGJ|ZkZGx<$(m^7rE?8C^VXNL_vcbbNAvq%dkXOVPR
z)Wp-p;iD>2)iRx_DP`c<W9bhlM#CW;-|GRBRI!2mMZRj3lS?rc=Wr0)ZpBi)m{-Bs
z7y79ROH20-bD(BU`P-t!oc%NaGEC#~O{Be$&&>OK-=6uXVgwRm9+{I;IfK-gdyo3Q
zX`?a$^bkA_fg!$mhg`Pc7|4=f8wJf_kfhWCG(kynyqOkk88G%k&TO5FCgdj|zJ&)M
zZ-n*|KxBdLXK34CJL|t9Y(wD12n}ojzD)q%qs%`lP{DT!@T@&5yTrE>#u{Q<3Dn>t
zc@<5mFBiYe(0o7I`<kk&ENA;4O5|HEJ_70gba%8@0lgu29pB6FJwj%^U$2~9R#l^g
z?^vAnqV{zZNkJ~(&9(<JbciQ-a(-em3T#2gvB#O`hO?{Ss>Bwei1UD3S}6EBzi$rP
zxRO*W-lC113>0h(#GDtunWs3P*PlE858-Ummrz2g@SpNeX1Q~xe*5eyON^niv$HyR
zh$g>ZkQd3h6-PV=-`x6qAyh;u>3ef+vKUH9a#z=8J*E2e{t2ZrA6N}$zPWCUr{-O_
zz(p!g%D#;!@Gp#|QpFgP(rCeS#~&qShEBaU%bDjqX@-t%p4?4de6hL3fm#=Qm@S_9
zZhxH@rBwEMCdw<rpHJVp0?vhqaRHB6O|e!B7rN!g(C7@~PN%PMlCVlq4~xY6t;mPe
zAUIXOmDm>&`8tI&3sl9lop%Rw)N|(K8E*+yfRw%B^Rm`<;f>h3rWtb;ew;1{Vr?nC
zxG4$fh?}omq$cTf1uK_f{L>!y*`AHd#INbW4+fA|ca`|!!KyObU*5R+80670<-$!a
zzFZ)wZ7qxwk|$(5d6lo3$V!@N5nhF*PDzA%aU3e}#P5W~{C(2hT$7voZ09<c<0I&@
z-t&|U9bO*aVzei~s998ayrkcnBN0}cCh=$R9`kMOnpM>JmE5BJ`MN?^-pX|6tBLcK
zr_4r`roevPV;p}2rx)eJV(EN0bsWnL9DcNGK_INZIL5EPWQVCZm&7rTXN*Kh&t^pm
zXv-M!dWQ3V%DR<0+_n`7Ovo**AF=kr9N3)9iwRlv%)Xk&`r*Q&5a9s3V*&qTs9-u@
zmDLLOc1}TkK#lLtj&+Lk$6Z_gHp|K}v*PNA_GFISVSXKzP?zkm^4VEbGRUc}Ae(W+
z^KmpUWt*LJyEsRe#+5#WUsfIM%`AA*LlfLrLKlvS%jYfK*BK_ll|pXJJ1&KNRI>Dp
zbvxFcwSQrq6l!Mgl1@$Yp7UvAVh3J#H%a<FH;|O<to6#ToYOGF>fO(A7i^I0AdW3q
z%uI#+2T1}_6mheBZpI(>HMteY*v6HPGu3<6I#-Dvyu$sVtp3ZGB8C$4=<ii<9W~|w
zLqFB(`@qdaF5V4KhLc}Y;~W(0OaE2vzdWZB3|A{fJ)0rZvFQYCh{bAFR&&54NORIk
z{ge-HAIz}Mo=RSA7Jt$0yTIsQE7rFC4`Y~5B^Yao#L&Jm;g4T~RNgB3A|{qBuu6OH
zVM6FU%0C(#%QgBVlZ`$cS=mEt%k=ID4Tr7Mb60g7iZkNs|9Ne-{`^%#$AS#TRgw4(
zE)G^tGV~Cy#d{EY)}B`|JN0ZTEzzm$Y<R39$MB3LyvIZhG=LCr(pQ&d9L~5WrtNW9
z=uTAqd4JtXF(T7%rjj>ac}*Y-aU+PaCoB3;A^I0T4@Dxga@|v_^5EBIkhjKx@Rz-g
z58e%=<gn_y9nxkE_n#)dE`IR2UX%m%Xuk~e-!N@PIgE0~y#R^VD~V71nn*b$kMkXy
z-q&;G3JNap4U#eGD-EDG5In2Y%TF77^Xew8RhOiG8(SZ4ww-HtVXWWev~d$;tUpN(
z;QWr{i9P2u&bnU-TYaK9Q?`>&n5!^&L^{^-?{e8VudHTF>X#i_IOk!*`8y*w<7aL=
zeNM|=z2giQH@G=IuK(o8G&u9r>PKFf)-&FmV8e93oDXMduveD`*&QLK&%@*as4CB7
zx}D$H$&rd_9N%`lhcMWdqut*bURf_0Fh5n%(XOh;H`9=qx_k3{m4Z40NHk)GF!IbK
zN<k9>6D_TY%W@1G)>Vm`p{nsunet}cO>gbF*e^8cDX3F)<T1@CH4eNLpFv3Vvhun5
zEFcZfALwzhRg5{wJ$Q^2hrf8#OVrNk{Hsi+Q-YXJEkFHGgyWi?ei-m8+kcab#$k_E
zKM60yD8uc+4;RJTNonOEw=E5hOkum`9FoxX88_+NvO#cp3`0nLI7kQ=HM9#masTi-
zz4yFdQx8L_|I6dq0gh)~xjLONsZU6IC%&-u<TavwS~VRvT1O@k*LH|?BnLFe`$k0^
zqh!Z??vy7X#JIBHwKikK2gg8Fzqa!5@<Kso;Hr5(az3zItu*F!%5R(`7Y0xxJdJO7
zcQo%Oy;wdWV*KC#gERK`n3eO({}%I6>}EQgrnG(c;zcRr-@8yCaTb&>M?Bjk%;IzT
z9B1LP=4Ju8${T%LAtZHPoIZO%A>H~jINvx1U~d1IC-}*SX(LwFWYHSUwFF~13T{8t
z(zdWo?{oQ-x|yrDG(4sFv~1;?t4ZuL*I)(jkc|DLP}b7XJg}8h1)63&8A=DdAkDwW
zg=iQ~&wiv|FmOu<cUjP;9SWxLIpz9(d_}*h*dTqDhkR8-(k!sJI;_Ps)v^79ND@@1
z8vNKkR2`_C+MRBaTuMzU=F*ij$?pL(Dwt4zr2He_SkIGeDEO`efR1Z8_0~oq*SZgn
zaRsk@;UYE=86%?*a*fWA7~iCZ8ls6|3h1eVZAJ{6103A^IzCOnN+@$a#m*3oZfKBi
zH6gf5IE4|6bXQY<uMn;Of{Bl4{BJ*3Ab%B4kH07l#ma;Hx@~`Oys@O~ds+~nZNP()
z-;V;By_r%eMn~hHxl7#a{u(gl_iG|bu~xURFVDEiS2p~K3)#PJz=zN#Wo~gG9NV!Q
zhftGz9ie!}ka_c_6OiP6&5dt^oF{=F`-@yAL0!Dv?z~pSQib0Oz8dRF=Od5DOEVT2
z76?fh{SN?!oVA(id95Z<?Zq)&;as6BJ^rg1Jhw$*53$a+r^_Hv3fl)1cIbNtxmrKr
zn6Id~nuAVbyZ__9Asp$+AQ;Culz&v?g3d1~08eHD<LA^YM?%NS6~+`102Is1{uUM1
zQ4bU2{TNR-?8!Wwy4Iab(&%phvl`3E{-GCHI7zIfsOuh9RqeqocKyYP(D8@*AONVL
zWn6P(&drl@)K)-2@eciI?BczO21&Afx{|Z3*zfOW6)n#2zK~T<H=|)4Lkat@1|nBS
zzx?#H1rMF`#JTyHo=G_oa5E&#w5CCA3~pE_yB2J-Ty1B)DR~i}>Xv?&<M?M|oACH!
zKUo~iMW0Y_@{20}lyTu4<b$y%IaddPu?ZGkSMliuOqw1jX`558b;N~&|FJx1i)suc
zCLju&dw*j%fCaZ-TLL5uVynb0xB<~S{z>Mi{!K+(#K=a)H}xrwO(PH^e^>gWqdIPS
zCo@86<Y}ryL+K0nMW%LCP#taB8L-)*s%iLrL~p_{HyL0*IdG9u;5BTh<QsTDU#>^+
z<F^!dtIj8*oVjI{a%*eGX4-y$b$VaGJf%&GWcD1J=g8mwc^9hXL;^*d95;(mOg{bD
zPX{-5B(-z2|C-XK6Ya*%SVEID@+~vf&e$Y!3k^@Yl1W8%&ZEvF)oadSf+#ivz#cyo
z4=VcU6+J9bVE%B<Xsd`)DVA{+Aq+Ff+SgP@MMj%Od&weRSqZzBY))}I)ok(#J|F2@
z+`p!CYw0j@y|6?3n5H8kVYb6jg10Z-3%h#0GobWKO_}t5`c<X1@8GQ(p=Ii8;kzdX
zE|iPXdZri?cW?Tkgc(8DGr%Ma>>(U5+_TO8?fMRe(3iI!KDSns<v>}@fRU$GWK@~4
zm5@UI3-U+PNO=!>!+)gqXfUE`__23x2e}mvRBx|~&I8rSU9X)+-j^J*Pq<sKbg=7M
zG=$1MnWAfsjn+A*{CI6Z%R0NAPE+fDeT0!ar{Zaoft@iN0Zv%S$`W-jmLMN<`_h=B
z`6ZgXm-srKJk-7hojQj@@wnZF8EXl8Ga0^`{7)NPA7Q!P(cbUQ-wmBd&+7uf4j3)G
zE3Opk>%|nd*C&j2RF8J24t{s8ysWlAyoYgOAIrYkMkfg>#-)<F?7cGms@Ik+o^N`B
z9qMl2lO;Xc<~%U!kBaQzh&J~iez2?*#meVQHRIU#$1Ar_tFu@`A@`(-9t!vxw#oa8
z)7gJ`bSm4~q>jmN3GGfd(6_)OxOm_SmNZ3B7cH(3a==wD;^}-D{ZZ{F{-e=w+%lT{
z;rT9$mTsp_;lXXA*Z<2Zy~A9tpWl0Axpr}{v)W5z(>FRd!yD{nZiX~ZMelLekN0XL
zuaLiD-|j@G$B7PQNuvV>dsvKSbr#jV?|nG&QA1+maM|}GRBy#7pL5AmB=Ds49p;z7
z<R@)2PyPr$7(TEXilEVD5L~%hM?DwUVTkqOQ9PVqVU^&lpt#=)zncKb&M8cEuqy%3
zf4R?%{r@zDdRS`qUq_ppu4Qe769z3RvPAIt^>fjw&0t=XtA;BIuo6U+P=?w|4OZT9
zuhiz6Ok*)pv$it+mxzBk)^0EC^TdcQ9v%WW<K3-tBkZqdxs4XosN#&qDkXs;4+%;R
z2~yOM{>6x!6##xJWUnD31FjY)c?~}K|IS{2C~d%U(!)f^+@nf%NK!-28}iuKVKwn|
zHeP}L=WKTLU1pK<p*8=x1w0vTyVelnWYP5;<;H7QN5Kv}01;MrjujcMLj>QJj%LuG
z9&)-7kvNt_UfuAeD!?#l@EdP;vr(6$)4A>+0t9_HWey<53EDlSu|rgs=`UDpvjnf3
z^FP7e0-D3!&kP+PlRb^;P1hgoB0kGDuDW>}T^KNi0QjLIYA|pNGAt5X^5><{gNz~x
z*jZ3Gnqtj5oOnd59KW>yy8)pzn(p?Xq^`_`ZuAZ-f#eW@0)U$f0C%^uK6D@E$#n}8
zinr=k%*ZO2V2946iB%@4N}|Xc)z32!z3BD;By;{IKY|;?zI%xze<v&3+jhRoyr3@Z
zV7hKOx+nn~vM;tbY}Vgq!2AjxWM!c;pIfBP4wa$(_ihp|u$u{>$UxKc0_=O=OYTfB
za|uG%DU5A(pi|?he^k`4#<4ebsI?7h)HmPMNzBcPNa@Wj6sMR*@<e!G_bYHr@+}zu
z4Mvh0+UK8~>yDko69xmjdmz_$^GkZ+(s=5Y(;2eKP`%Q4a1$wyR9DoB-#JsX;+QAR
z3DLtTg7ZY`h;|x5n)^g4y`CWzkx6^YORwvhDr5%Dr2WS_c)*MH5be})%fJy<qU|+c
z6T|>A#DDm2>J6{+on>eW_r?g({8Z`Gcbc#Sc*Fp$-e8-!FhHsNSXvxPRqdg9o>8G+
z{xo(_EC@^1IozmXHVih&K;%%F`U#gMP7i5%L-Wq0Sbh6oWc1N0xi=T8UXH`#3G@a@
zo~zaiorGnj@j;Dg$ZO%;4#Vk0LZ~#<lUW(O_OpfrWFe8@ZFrzIWX`|B>CSHO0^^(4
zz=ENw+r_d#B^wnnA~3ZUDGgN^R(N)@c8yg*wwrmLN=z^DXy>V}r`NA!C6TB>-h-)}
zQL#<6pGQ^7({Z@AEy2ZJul#h-#!W}Ci*g>$G7LRgraY9@%kO+CYa{jW;Z5<)NL=8g
z1ROH}DFtZ3&L>b%x#^yJA&s#I)%=BHdIYXW)_HE->J+o5D4E&{RlDSOjQcFn6rM*U
z3a}!`9XN<P@IR9=oTt+)|A$2TLPSk`(T|evTb+B8iz1hu-zI&&Sy^L;hGa*w{g2Nf
zK9S^uyr^Ctxkm_2VKo<Gr$w-2NZ^sfQj}jx-_=+tgRSn*=2HoB1g#|!&yL6IC4GBP
zt!#6f83(=bpx#h0`b%#yD=G0B`AJ5+f-wUO{h|I(sU29BbU^-|GmTy~oUeX<^y`6S
z`U+pQ!sAnW-DR{C6bHM)nEcf*eWc^jIgP~}1|lN4hbLko_<pO<!D!57D8>D-b^iA4
zWe!Dn7i(u;#VVb>@p{35^f&lkF-#0_8oz021_(G<J3;$L((^wxh{wWVyhB^lrEgYh
zos(CuwcA~O{g#3s-LW%FGv#~fng-r!2SF5fi&ClQ>JuYA_jiQg9|gG~GI0MN#0t$A
zJNa^h-oA&`dPeB>PHwhe*g@txu<P51>Qg$POkK9Iz64%!Ja+pMC>&UoPz|VxcTXp}
zg6aXo;9d@>HNit^Yy|u;5ZmmQyNv4X_fi(}hpg?(>m;SfiU<oX+dd^_ycjNqTP+68
zvZ)LAwFgL2$n&bY{Nd;cR>z8Q0gktFs>}1yM#6%?w=GXu-LGD?@XgAfs=L}O|4V}5
zPS$0r+rBe5J>f=&W8``Fn2+=Vi*-%d<PSUo*x47n1{~cp1oyRY3dy~hJ?ug&Be*6f
za!$m?o;9CVIJCSOsR!qT5Wft(9^e+9rkDsyNHDzQ>a!lYng3s7R{{^^`nFq$Qs`9E
zDOu9#2=C~WER!v2+7wEQv80Hh>_l0!6qzE$s0>Qkj(x_OEi{M>%915y-?ML7zUO^s
zMx^t7-~Z=-ns?@1p7+`A`?>Gyx}N8GfiiUp&_xv*@w#6rR^wk1X`Bx5f$0J5ACG%6
zhmMKxf57b{N^v4r6lqEe+23b}s)nsPdp>n)oGHg5U+T_fCIE#UnygO!E*QkKqGCZ<
zZ)YmN4_?W&420c^)KZvT<3e92Ar2U`fk9r}_spK!!zSardZ@{oj@a2^U_Fe4@Es>2
zya9R?SYuGv>v@nN#ptcaY0jeudtS-yjk1h90Qg%uPObCpCR$Ky!@!^_tsOiHnWa4*
zfu8!ajb4yC+_vgXfJAMHih1+)5OL0T2d|Z~LRsZgLOn-tc0(QSMUCpVqP}4q08G$`
z3pzi%K{NHc_M0{JTrdV$j=uDzkH?R6auCRIdYyIpLdOi>AcEz%#p#dofOe){v|3rl
z2bbk8H{0CQ9?MH0C!-4lYsgb~O~8#Y4R&IBXaZO9L;+kc3{(fb>x;uIH2|lwB3{wd
z=1;Z3-#Xi_lz8-GYY?iC*K@azddAUN5JtL>oh`oAVR8zU#JLVNeAcYZr^EO#P%Hr*
zSG8%DO5Kt<e%xqUn`QGxs5Pjukhk=+4GM$q6WR{*t>|kwq|X5{3Is$@^pv7q#9{BB
zxhpmK^IfV=?#;usK=cfJcO)Pa!W-98_VJhODiMq{n(Gq0vg+SP1B`NJ2zFY{Pyv}#
z=ui-PjRT1ixJLlWPwN)6btw*@tF78gD!q>)3OxjecD+lKmqiEN_sbt}*@2Q!BKBT}
zE*jS+78~OfAYwW8(c|!$ZORwxB_JzJ+w1TsQKsipm(~41DUJ|dC&6ncW|*OVx-IeS
zgSzzMl&2Jwj`cqAK@zb#@mZLGGFd}(yM*V#HkvVR6G2$hmIc0DDLrny>~<iEyCS(F
z<&U-J`LY)W?ZF$MmAPI;u$>CLmSiSI^rMi8;ht)r-QS#mxe`emkyZJ!w+DJsy(5%+
zf3~|_7$tQ)qYl%8kK6CUh$?7RL<mDAny9|3gJkzM6AvH|lx)0#KqgWTKg;Z2MbM}1
z1595es=us&^8hvM)i0k9XaU+^TCo@_zaY?OQM}Ebq-rCa3au4OvhtSPPnfqpfMrMr
z394YQGCK)vpglC{d4i>P6bEoqb(yXWT4IL7;<X-eSrmI!(Caq*6G-YvhMYThVnq2H
z8$Tc4m%a6>7^c)1<}X-Xl26YN`mZJdz~&X?1<>gpQPnUpu+k7HU0l0f6ew?<4Myf~
z!X8jCBAu+WtTO@}gn_MkIZx`Coizw^q3q19YPbmY7-bi!NP}n+^=lAmyddlf?Nf7^
zF-`<;Ir%r<@PfjUg&i150L}$3r~7`el#j@qS}1H>BOs9(U9e|T2yd;!{f|G^EHCOs
z!HaKxKN{G}ZYjP~LuIhOzQK9({)s_fm^Jx?F<Bw@h(0J|YZ;<MJ^4vJmlHb=NPKN&
zDgQ0`K@a<*Nh_3eSjR~AA`wY8ajdzaQB{nKH7HGF&qyEsdRaAC>`;h^GD4wXT`d9K
zXoqUZdjSbm?)S|_`9Jbc%CwT!CnA~|MM><r4Q^P3NilAD3S|JxAN_08!B-?WYsP{4
zmO#+mTV2%gzdQ(CTvwr!p26|3En&ppY;)?Ac|yj(wOy%G)<$UjQLgC@vy+>d@<;Oi
z*jY?6k@CuO)=KJ)S2g~0+GC1vhL?h84d5rnNxV)pqQgfJm&gw`!=PP2QecL=2JqID
z_(2@lS*T5Hv#NqCJ>8qJPB%Nbx)>0JUIA&ZU4$7e?>C|E4npURWBe$njAzQUh%Ui7
z7UK15$H#%~e@5q(Fc!Tqw-UGw=V*m;TGJOQW(YBDc2D|VOcDtO7!!%|+&4&WEPU;_
zRGU}xsrZ{sTAK)#q3@npNe<SP1aek2KiuOilo2Ajy-j{KfZKs-KZBn8pc{NcIxh<F
zPMV%ohaRtwFS>_LgUsp&)-`8oUUI2Z%;W=^V}q*CW<`2e&@s9FFLlZT2qb}2Lq=f(
z5zN`L!unC>ZPisDG-d@xC+x+~?W!S#8O6a<4*g>(U`g2nga5G<Nyjg*Mh3TINt&%q
zBe{ZH<1MLEdcUOZAf#!8Lo}G2I$=Z8yrfSvJfMdpw8PQ_91BKk^8DSM7%c*I1OO4k
zSIKq#=au7cgAQ-c;7(2Ftub-Z5RWthfvJ&eWlcc8?;0Zuy3B3^if#&!dniWl02J4l
z2aRf|xD*po7&_XZ4PKDeXiBP7606A0@b!#*@3QORbP-}C8DS{k%D~Pj5RC#ZMwMhc
zG~XMk`}&T)<ROo5Bb`?4T3Mbcz;Qp_6Z0{~;Al9yk@GcVif$^<g!C?+)-||-<`FUd
zX8Wgsaf3P#7-WL-mig`=T{p&YXiT(P%*6Vuqy<PUW}T7iKFI|Yeho|gDuW9F8lHdJ
z6YAwUKrOXOudH9d5h(?tZwIY1wkVWF+NL@yWF%HAl&fL-T(N^nt|Q^A;+o5!K=!3r
z`&UP%&)@y;8wr6MJ=77k%D#u*p7E+&tw7Lj$PA6j{(w`d)J*Ia-#%Ad_XM`ZKzIcq
zVlVZ6Kwh+W|5~%{8O|z0q_q1bI4)==L*VKilv8JzC&!vZ=@HO9o+CsO#6&Pzb!ntH
zo(y@AgV~GkBX^G`c53px;<Ku3xK_4@BHhU#(t+*_D?B2TWbc=>Pbc?CjlC~_G2|Z@
z0+gI~fdyy~O)wyC<a|e|O*y35B}ha*kNLrjdq&uQS-%D_G<Ctih5=Hajh&4XKL}AJ
z7V}1Yyk$Q{&hZt%f427H`*{S0yaOH2u*`<cfv|XScphQ@WflDjF~hkNX8Q=Qyoo>(
z&)n~Zx(vEcw-UG-jt+ziLG{MC1#iRSrgq5aW~{g9Q&j{&g0!hjZv>!JJ&*|L9<#eS
zQ*W*-GY*8HS^y7)d%>=|+}v?UBOzti_pv;w!9QFp6pP&qJKCW`s5tA*9+1%`6`GPh
z=+VeZIiEiC8Qw3D2fRO+j!Lz4H}7^;v8s82brLHEJ`m`P2=wPT&BS9d=+H@|%>0g*
z(z`A03N6tn7}!VHoBW;Y8$qf*rt$^AP$ayMgC)T^8qf{&L|CgZB8nl;Nk<qdV?^0h
zzYsyA0R_67NhhrpX*1VA=^2ZDLs(W40LbCIs6Q#(kAqM}3~Y<?#R2P(q6vt?#VLlH
zMKv|5va%dM17A8NG3o;rIeMy%tXe=<0kI}9ikXWY2Y<?;+Y*s(J00V6MT^x3Uv}Am
z5D+~u1$V5x6QB|h5l#Sx8V#PWbNQlq0`z+=e@Zs_w-LAH3D7?Bvv?y!@RNx>Sd5Bo
z#b}8vqq2ZFyEh}qwb(5eFRdGHH#xn?X33U9wQV&$Ot9Fa4cQlC(>II3PEqy}zl|}3
zY%gF4d$#Xy+`Qk7$BzAj_B9S=w?7@D!>Al`R6;}%@0%N97!Ku=*ZevKuXGDvIV3kI
zaMAh$PD5z}yy$TLjrB?DfPAzy<|S=*QUESQ&u}PU8yX7aJ6ui9Xork;U_`qFmmY#)
z+0DcqAvF*8F1VBD?)XWJF~!pKwkbO_6}-49Tz{z@x|EdMB^R4P410c#Zc<@d54<u*
z2Dvv$&Xn!et~l=dQ+l1Z*K4^ajIS=!pt{LYrE<LjWrgr@Tt<Z=sCMC;Y3dk#?G4Y{
za9hGpX7+x}lALTY@L=!r)qG5f@}msJFFn#nOcy=(M>hu~IyLwIOx6a9HG0sag$&f&
zlAtNz1));8DIEns{-Pm39MN7))Of-$&r8CW6R#&*rNem@tn9y(Bm_)Uf}k4`CuL-9
z!3rGiob)8cIBzP-4+uBH^0L3_Z6H&A_RFVd;n!kx{R>)3neo(>T@9?AWK7WWwy@CP
zVr&@1T$sUDpsRLGG_=0%u*tyu1RBxW1y6(+N)Jn)&jSKt3^Gm1W6Ic_5-4AP$;%lI
zG2^~40ZjfX0KFxgEg%vUcV!$h93J&Z?6@*4Ez}T^78*>z#u`Nv|1)Bn0qDwihi28U
z_>sz}g0c(#my<U?LE_;s)(Fh*KZi8PluPbi1w1C8hc&tz&x|P}*4=Q=UyKOj&FO0X
z?RQ7|Qg2hiRIVL*X8M-z2cUpRkH8|T#*6XdUmmc0&VZ-f=f6}VGiHp02$*4S7_X0^
zAf<+NV&Xt!CiMNCtn7Rc(3=t#n;B-VSp6)g){mG_hp+maIkzqfPrf~2xERs~aN#AD
z3v^86rr?EnP;R=w&q(+3l7kQq61xQe53MY-%**|zLsU(m?FRmcr#~HptP&h{Eymz~
zsjr~#F}WXAMwnt+AZ#pfJ&Absa(G6QR@s28QZqd=SeYZGr1gPX=V>17G=*Be7)JCr
z>B$}ODKIX87A-x_0V^&bQwNjZpNr^SRKXEV!v5U3`jkmk-kiZv=bl>ouk#)K4(3i)
zz29?YzS-%{4S|@c!mWzeclH{`)egAqu>qmKkeT4`v-2{|({m09SL7Fe429QS4B!{y
z=h0`Ib`xDIR8C0-&saFGS+`U&kk)K#I<?@wKdSsKbU(*)r5Ru(8&;5c+(~gi)`OI@
zgTZ1e!Q}g&%|Qvzzce4l;|OHqr>%hsBqQDNOI2&_F>x9Gz%QHRSs1I+@5>zUm2SVz
z9u#zG-CNz^is6CPKqX71hWEdzC${a-*WHZ;mmNWRxRsIcZe<eue!@%uuuePq6K822
z=KzDkbGcj);+Icu>nJReKpA^>6nNTZHBO}$!d^T7@BLBM{!i8kvPq%2Hn##o_@*-S
z_~nyO?&kXlxs$>C@t;1kT8f?R_oP<m{^%8v)8X#=^xhdZW=zo?WDdvE%>u}4>{jXl
zB*-uJ-6?DMXYOsk;_~fYt=7gIG+9HL`>1}UyTE;<EE^D~6c!@~PCI=92N-p#PR=3w
z4}(HYyRTZN@h~CgOmnpe;Ha~0kNw*@<BBK|Nz_(qGO<3tfrV-TjfVL8<i6aBQoFJr
z3Evk1Z!0m^wi_`rDw7HfxWpG`5f|}FKb1!4&f8Djkt$+)to-dYl4GOqe~-6w@S|8g
z`22(kY*-1SY{(&*?u|lHr*JQ0nhPcr)|(VP0Mh7=J3(^PUKIHA2(bpH@W4hG5Nklx
zbt^F9B}_`qe<UxfDM)_w-v!vWNBBJOl8M3mVGw#4#2=8-r)z{Qo=DHEMiZ?jrW1NS
zZZxX4{(sm$3@tBMqpaP;8RIb7wf+12tdcAcnP(!L5Z?Y`HB%mvwmJ5VI+h9IYt0+w
z#*0Fohe4v0{i7yQeJ62QqXi1G<K^@1zRnXuF72c55q=ZwhXN)fY<gp}Nga~dMea{j
zty{WNDxA8_$KY9YKyv#C;JCtaTm!nae8pWs;e0R?6D%s!UbBPKu)xJ!ayJt>jHtPH
zp(zolc}aq%0qPt6DOX8?i>XSu<S=LhWGdw)u?o|b4!+|+i4!Ql*tO@Sp$H4Z{ImOg
z$5j``%AIE-UG7syAo&c-xul$_j$ndrQ=Z-(^i<kH=Y;-TE!RSC0{{Fr;89b8OM&ti
zXj6DAiOp+}Jcdjl#b7JC7+3Fcbq6Y%6#j?`;vg91Anx}{i4RdMyH5fM7}%p?ZZN<O
zDg#LJ)VPPifZCF#$(BCF%J~i%J5e4&jrT;T%M6$34{508lUw=VoO!?_B)E>CED*m8
zt}$KAkCB)JIQwcd`q@l<Ywk?VHd9q7HQvZUFX<LGD3Izh*Woe^&e$KlA^Ef0R5jSD
z16~gRGrKe?XX5jyV(jcWm4B^-=8JR^jOhCFKTvKxkk$DBnPG)Nkk$;lk6k?Bhv8<A
zt8Y>5lI<B!%i7{==`D*OHsD*s(nv7rN;@cwtWsTEH`X-M5=6k_B5$;t0J-cMvOOlK
z$wBV`mZKzSXy@){O-PDlaWMy1Cy+Ptqs*K=SLRx5&~Adp_IYBLe5`gY#=_s;M6--*
zs#y=++_76jnIo|qp=i<r4e-t!i`m=>uCH6GL-SQ>nv^Jod!eKh!vif_ovkFjvDv7q
zP)U`az!hfkg*_#@Wc<}#j#$Sv4eoZggnBznrsa2ng_~B+<omE#)^WDVni~*ZU4veq
zpk-Gv0M)+`piI46@wZ1G1x0dlJooL36V>E`=I6g>S@tGAo=$Ii8#ex~HPq#MXy{?+
zx_o?Eyb;)&AVna@pg?P(e<r%1wXV&+PxCIoC()C@NE`*oslllS4o``j`6$lM?PmF>
zXn-^I4}gl)0P*ltS;E-eorpvgqqP@NBXwWCR%JY^Hu26^)kE_L;nh*{3Axu!EO>5=
zpm>2859us!Dr^2e?}@9MZvxrvAo9?ixlJ+?C4wk74c5Z-dH&SYKJ!0Z=^|iAM}o}+
zqS?ieH<NpbQK8+ax)J3~U667%ci8DD41~BZy}oqxA~c^n>;M?J%ML{eV*>TkyQAtz
zTwiC4;7b_tUB9#>8gJ}z!x>1S*<fH=R+#EiT2>jrLy=&Gw8}_WA&u9Qy7Vj=PC}2;
zWBG!Ld-p#T6_rmkFVLD5BpAA5ptB)QqW3!{jSDku4>U>>bR2SlWc+bK8-OFa0Bs{X
znR}c^VTLzAC00adJ&CtO^`r~MK81opR}`kXLKoT<9It?s;Fg%m6q0wilI<Z>#-q77
zJF_PHE<+r9>n7Xoo!Da2dG+;Q0NepF5KA7e4l9%$hzX>?n7%4S_SSem0B4FhmlS8>
z(P^-`^wM)6onPIp`N*61DHZ~~!)2zW3Mj8JPtzxRNev||yslN@^$-}`xjX8d$BVLs
zON;n9<WV3Ij{qtV{+Ja?PzUTcv1At)arODQ5VmG*@O~&t6j(AvB<?G%YjzxOp6`rV
z0I6|}GuMC`Na$Qq=zPDzeDW3ceDuYmo~kME{x4`oU~a{Lu#|}};;q>wjOQ|wZ)%>+
z>K%T5VgfVOX;68LmiQ+%>;dW80dFkFZm;bVKHG)=T_WMOybl05WDte%>F8&Y(L6##
z>eV^lAL9v#H1Y8Et!q7Qw2SZ(HxAtpV}A#L8(;^I?JRE)Xv6t!#lapSHx#E|YGk?Y
z=TMwJpykiNZ6O=cz|sovVxoGknH)xy8@#mBdR%^;?j{0>ex$L{z)w9nz3A)dwLrkm
zN|Spsy+P_@^|HQtAD}{Dh)3Lqx{3{}!L9-8nn8#p7GM~`|LM~MVgtY=%z(?841TTJ
zeX{2WSL9RGKnftXkyK$~TNM5PNE3<ew~)`CED<EtE9fwf@&v!8-~ap}l0&hv1Dg^l
z_1jKN*M^fEef7EF!28n2ky3Ba9CZhQ_*DE4K8>Yc2%$Q7uK)5y(82f0x{*?fXytbY
zmG1s_paXgnV9Sw6n+A54ZD6FmkK)<^i?7z`((Qm(3UylumO$|C<{{Cnl8Vs&2UO|Z
zf7VL`O$><~b#eRcEm7@|-FfRQ5*njrI8;V;Bc<qXCW;8*ODVVW1!bEdU!aTuHxE5>
z$b>i6fXvb(CvLY2Ackw-dwczW4Q4>TqyIT;3_r@Lq%KwCP3yLHXzcrJQ;K?#?<s7Y
zDy9KNu+iuD5Exq+8u=b_*!heIn-dUPK==v2*r4`UE<~Ob;K4rNxU5ovECP{YngsM)
zU^mCH%hSc{x9@VL9nOt&XqMufJj+xYwE`)xAo#%C4~v77=-cAJ4oQ<Jod3O-$ax%!
zPHfw}c<2ls`uxr?qkfdv0CJ=C=#?C{zg0y_A>-^hSl{l$;&)AAggYHjPF!I{h@h>d
zc_1}QiMzSvnvtsCgLL(6#m1{q4ls27mlp#pr^Z70sCU2<5&?ScH*eE4o`Fnh<9#7G
z#U4EtD>GFB!T!*tx}Je61=fZ6$qz{#8Xl7w+fYfjS<#umI|8Zs$(<qMs0f30s7MgG
z?(Rf^VAB`2ZBu=oE*I;1(8s}*JUw6^9HG^SvR*hFJvIN!D}vN~MXWuB&Uuc(iA6)E
z>dAB^J?Oe|kq9?G%f^K?DGUd^IgTr~%<7bZaZs3nFrhKCEQ$R;etDDv$qVqzo0}_f
zOAd@HacfjTmFlQ_!XiTyh3VJoMSncDja@UW_-@E0=?fdY;9=GgJV64i@e6>J4~q(<
zjI|g(3S*sS*F-gINDSU~=QTGh;kAjoQpzAEDw|`^?Z@}zm4VH6AU9%JsbIHeHjx!I
zyr<T{ugP2QE@>~D)XlAEud5a0slU@Qur+-+79F0K2F)<BQH(G)!8We+m`^RH(oKM0
zk+qd4rV};cBQ@Q@>8+Nq#ueVzh^{8Nd{U*;9(hIVaO|H{?m>eyN1taj#gjVhcc6M)
zY0RU;jP$?EHgb9&mqDj}rqbiS+m)}Z0`Cb7Tv*c@ui!|$38f<Ws^#|wtJkUbvyCGs
zK!6ihSrW8x`)CNfX%9iM<HAeB)lmlPbRG4a&8A;xw8zF8scXFdE}8b{1s`nL8Z~9|
zzWpx_1(E``#l`9+T?psRZD`a}!=Phut8Sb^b=<S>{KJim@(0_j-IpDh`r3&SD2YB&
z7Isv_1WCF5GUMygG;PYhQPQnN9%r)bCQ^jq)KmQj93g~&9sI*XgBD>_Cyl)+gh#*a
zR5P@fX-u{b6nJkXi7hP@)|A<8R4L(E{z)q_B3Nc%PRgwNA4S$eFes2H<1gJ1h81k;
z_a9WJm1q+AQkA)$_<*g3piWJ_ELDu?O`H$a2Fp{V7r(dghyNm|07RB|5i*D=gX-)h
zB10ZLNB?5${Er8KBt9%-_~k;^`<PBlsU}MF<lu$Lwqo3LU4EqhmIT25ya|vG$QN#s
z9gLIc*aPIGh{I_~33q7Z4evKRk*S`Own|0#i;Ni&R@4W+Jwgv<A`RGE@3{k{!S|L@
z^x+&XIJ0k$itB*Vx~JsZV~>N~tx)@0{ne9E(5HLxle<|YL>_N(yZ!AY33W9I4fA}K
z-x>sBZH3=yTM^Y=r=EjN<Qy%m0SbW((!5qsE1s`JuX!aV;VJi<$k6h=ESPOxVACV^
z61FO^F~Q2=)_00#rI~uYHmZq<KLE^A>t)~6xMBY_P_}*4y9sQ#h7J<Lqcz@$BwnxW
zrm6u?$F&ETDnw}c7oXI&-Q;<}i_sF?OeO}c+yM<XE&n3+K2;MK#%pC@8lC$JP&rmG
zh9ULitK>WP1i%*?-Y9W{FMeXi!8k!S{R6-$C&eSv!Eapj&HTdX_ynM#EXKYs_vx7V
zt|E{lFm|z$tYuxzAigpn3##m$hu3G%s(i{lkaqH1*{kFsFv1Zv;^iaIK0BZg0QFRY
z#ms`u{=Uhl{uwRCev;LaM52leE!kM9lh;u$(a2Kqh=>>1bIEYn&iOn4LU8ksqHlHi
zGR8$=Srxbcg(Q5Vdr-g=a+6k}>7h9?*vnB(r({qa)VR-O*AZO9sqSe1hg*P;pRb<}
z$hB_2t<0MC*sP>8DK8t_%+fZ4{h6%#8T&I`z~y%e4W_i4TtWT%lRvhCoL&od{z~@`
z5F4;eYhVY2T+9T6ko&K%u^2$@j}($)HyitAQjbo3?NPoPS-xxj?bOBd2B)gOE!_O>
zqa!9tlU}v3e|Laz>Y1c{ET`BnDG3CxgNWGcDgSVvH`=51<rueAcK$l04ZC^%VlNfs
zNK)S3pRf7XB|%}xM6%^wQF_}$YZ?iIrv-O)pgkNNx*R9dx;{P)cEJ1OKZoim@BWr{
z7pMOTJZ2^3)$OoIwRtX_wqEH>C~?r0GG&)g_qSAtN9*J(DOze-nA7WeK52r><O@?P
zebP8hkQF!gMAz)7_cM9)*R}ZJ?^h^i%^Y>#e?Mx@9jj$na_dKDl-v>Sg+U1|N~fgV
zV`>I@#S?E!$9O7jVz=M5F=ZRARTP&NesYFW7P#F-&5kM6?g_dmE#AeSij#2d@*|-I
zIA8Zysrfj^y?v=$Pc^&BQHq^D%Cfofd2Tjkb(=a}V+!_)T1%F`jQYZYw^&F2V<F!a
zm(Dy!igQRADXQ+1y6cqyxW~0beeE51iG=-xa9sPJmkaAca8)fPUt`c;v-Z>u2eiNK
zthah7+7{b6KFN~z_OjO7Yscc-M1h)SN=LWaI>oZSQauusxSn=*6|H3>_+!7m8gF5{
zj%2FrI^+9xvhS93DevnL+g!G060Qn*z!yNh1jQ`WE9PGDq%<DrHJ+sDiEgNJsmj((
zSgSbLJ(z4@NnCNib@(=PcnY^^Lqc?E*gc~k*DHDOZP3kBZqrc6-u)^mJQ;;5Zq>$J
z-9lQunv}N#{Bakrp|zNpkj7sg0n?@WRbg8G@Y!)s=?{SaE+NfPBvsAdTJ?mQ3iX{$
zwk4veIO&||dG1Ielp4;sfIZ(&ah#3q!*AYi9sY;&)@)vUsGQ>h#q)dlT}mbSr0_)N
zK&E+9j?7w`&z#7SO*Fo*4#Sn%+wt$}lK2%8R_7J4P4dg9E3Bm%7Ox2cHHFj{?d}m2
z+(MGQ=QVwdR^u(TY8u4}Tj78Evtys{(R_z%BuY5!5AV?6KEj=5P&R7lde&kc3%ym3
z2yjTdQ_fk|1g+`QNEBkN`4)TMh-{RRYEP=>Hq}ARX{7oXIgm|wX*ax5#R$$@HHzHi
zgcCVgB%sGs=@s<_8t@EUnj@?5aA#S&=I79ewr+t!Ley<dlwHHs*tP!ge^t@8(<dJ{
z%lW4NnK<FK1xj7mpePm6@=i_UJ-)+KF8<p-67{q7;cCzmmR|83qQ5u2w}Agv#Y!vZ
zCHV`?9Z9UNiRkl6?Ygw{TI1GT%ImG};QDg|j{hmeT6ErRtf1~v!^ikN^&wiu9+sa0
z0Vuhai$%-S^sNu8gIV})LKFNtNZT(q{{^6#&_D5)=3qfjhi~X)PRK4=uP)vg0Le1t
z9!MIZFr@KP!L+MsLX}p!TlcwadpSAYZc($J&?s0L0u?(+XU`6gHq|~|>k84Hu}U)U
zO<L^=zr*o-oZ0Z;zOYB@+;&wGbCjG=J*{8Q9pk|ersjGAv2SnNZLK_Bfb%h$BcI&<
z&_^%NNT4|B2&$_LZhZP+VKn~h)>!8TFXv-CT}QhcYR-dgRCy|WjmR2rO^+#rJsQ1t
z_ci!@QBeW)aCEl~PWuL9RD&iGShWWCZU^bnBZ~e5$<Fij=cHwbMr1EbTd1;7yGC{c
zOA-0%$M8cq?ei<Ic^h#2baJ@v)~M$#rA7MRKkLg+l^oNW!LG)c1YqgE<XxJM8ga6p
zh0dd(ISczT7F~HhhfpH*BcrN6fHB4x@sgwzZgkoqVxP^2*c|*j97pB#Bs5Lai>L*F
zAa5OU&EhSw_gFK+le8n14aeoy(%^Z5F*D)eZmb^YMY(lM`4!4M`msv&+`fP0Icf~f
zsU~l|LH;61un!AYBc!FBtgG@hXxjpM_BeFXlKbbW*AJ-td_&N2ky`Pl+|u35&dbdm
zF|mtXDbgi1!hC+L^J4Rz`A0J4xtjqpMAgNm>w$dl)Wif^^V<Y=kN9%IIf}&GYn}w1
z@$t!~jQJ*+VHZ#5aefzvFyF&D*(Xrr$2bHCX^+ZWg~5s0gE`XRVm@3IML<BH>EA<A
zr{JfkAAa+2YG}WUGq~oUHfj$Z9<hwKrH@$g7Ly(&A=0?R5L&0(gW^Pv!ZH5QhRgok
zjcJtbio<VW`iNp5R_*?B_ONBHeOp}26{+>riQgeWJPE7DpK}gQPf&1b`?nShekc6L
zurtZ_qySx^L9OzyZ+mY|VmJMuJ;Od{9T(V_tJ0W|Ju-3;OtqUNt{>1^VIE|7z(fIN
zH`yuVAN*>3+x6A3;b3JJpFT6ltic;Z<<*67<s7VP>Hh+?n2;cNB8y=5Y<BuYa-s#=
zt0{dl)A72R9557A{qc8o^2Zv42&<xBK)pCr8^jmGMw{4OFOOq6Nrg(k#fBIhplJ>g
zX5tQu?IHYgr)X=j>&uWe2iRMa?C)OXM-|g&<Hg4y)<#%b**vQ;tn2N4N*r0^^a1I<
zK<at#JX|hBR9Ue28%&Xm>ZH$Ttaz>cb|I|z><6|csIGjRc^GdHHN&DN$f(HBQjB}d
z&=qX5xnht8`cUG$h-P6)Hh=8ITUvWS^_D2}u%xZP5SjTr#>&v@zZ0HYrf%c-^oWP(
zc9p~`fqVFL#iY^s4!7gR@H$F|S*XYPiGc;qheWKId!1EU8)Og)S@C=%X3piDtP>(M
zMnrU&u_>P3g!@QZd6xn(zUqZuB~JGy<^Fhv1C=a8yPmYIQgTWG-E8I|O0Y#Gy9>-F
zkYT502kFkx5}Rm7qNZs(rmH!s*)?7hY~FzX_C=5@2N*u!5n18hv&m6C0qR8!cq93n
z&y!D5ytuY|bM?~B&JGB$7ok2VA)Tf(j}7h-^xm9diE6g`<~3L$%nF>6m#esw@s&Q}
zxT@=ZZjfQ!C20=GonnRRxgM%A3huF$-ly}Pv+=`aqfe$S{XdRyt1cLuXU5*y$^n|*
zG*H6eTp{jEQgWJ3jjXp3ezl@(bY%7bnB$nHYxx}<cei8`jE2Yf|L(tCaBs>8FU_-?
zL%IR4C?28lPCaWH`@?B9ejJ?fh7UQTvAkfpDFR(-1I^y;Y7g1aOyu9yis>TKqWE*U
zzy`knZJla^6Sva^u2Cm+<4B^7FuKTXCwH-42<)r0e01l6Cv>_gAN>Z&rT4gmD(o9;
zGtaS~ExXKc6Vg<bI+9vLzU2k-HQIdtz5v-2x0W^7HD@`c@#5iMga}hD5k(7gFRPjj
zhr62yzJu9coONg4X`Cy6ignbeaFJiIdvz4W#oy>M)#5C}UZPJ$6Lzd{DR+?OxM^!j
zCyH<iVZqz+t_DBaV)-j+1j;+|oMnx#Q5UP?%Xjkv-9>AD*F#(SeO<h!18irX4m?%6
z6Pt`Lz<o?eZVNRj!Yw_@-Cv>~F2}>(Dy%RtCDfp(#wTiu)3#kPqqtL&ENk42EK)h~
za$siZvj7K2fCD0@AwaNPQS`dlpo+p{F?qPdb8nui&0UkQAnwuJL_1FmmyS_*zn*3V
zeydBJWCc+vwY6^kYlPW*xj5aBIg)9e5yx*Mjdqv9mn%bxE2xvjJ@lpAA^*wGLQd~T
znu}q55m$8`{thW1cS8jae$IJPyft?A;@u|cAT;41twfi#`w^v%ybsK~zzq<1Ox?J`
z!`Mh8wn0w8jel)j*a#RrxS7Kk5>;U>Ue2P%S@&JtC4rN=LTql|+c^<`ia8CzOO5Dg
zOQM-VkgemFJKmICL9NmIf}LAy*FRM=dw(Z~`|*;W^uod+g04^tB-JXb%YHH~^sJ10
zzbqB!bGGA$pmVT=Zu@ak7su)zVx(~qn@OZV@!9GF9OpN@PuOzgF^^@)eiqmhUhZ&M
zq_W^8u5L(ZJ}5}4Zi!uYCIjj{;X&C+s=g~6h@JDYxU|;o#i_%{N6D2|!kxmOkK=gO
zVxmP#xx1d0N~IrgC!hKB%WMmqGRi<yGUu5NONWQI??^XnSn)~V%Z(>uz76`vaHPE)
zCQQr6u;GiX`tCP_mHt*><*~w-V47Q&-<2oZqDEgksA4c<uL%cDOolL*=3$ywXMj&y
zkbHv%&1|sJUO%_6g#xVFXb&j*(f&MkDkNUz@WyoO*8VR&7^y*$^iyP-r5Bblp)ord
z-4HGo2(hJm|H_8VxR{I1%cAtT<Fb2b@vs3e)!p8Gz$|xjxfcbo-6OTE_75A(-;2Ao
zq+Gs|(>rpa$^jf7!#xcBjY+6GEHXfe+BuoY?>I8Z7OFkrZq6Gpfx7@UB8GaSlgq<y
zGy>&_agb$_Q$>w`9+l^~W9c$mneD6aR)|naTVe1Pi~PGf6k7PSFml;kcU-(YXZ|B4
zA=hFwIEGVwBz4Q^xi+7LmZxBKku{PjqdFEkKhtxOjn9<u=5-;j0wK_OG=Iz7#6Vj7
z;WHl^R6d?~BuY2{ufxG&1F1!1{PvSAQ1c>Pk~U{$Ojczkr)A&2b@|}D`~EDhj7>V9
zIeFfR4VWfe`x-#nOK7|wZ|u40YT!g_ZQ|f*+7qnVmdfOUh}X&v4L3FH_L9>dt{C&S
z52RzJ)1A7*J^sa<H|~)b%Y3pK5EuE=xU&7#Bu<E+v+p}!KB$EH-8aLW**5j@m_j^!
z*&n}ai53&nf;x6-(E@hb#CzP1;})qx>?KbRkPv5?F%s#%Qmg`Pe*BwxZdxEYmVZlE
z9!`u94)qnizhglx)e|nAIbg}h-3}ZYSLZ{1)TtGdPya{Y?H_y9hCXwY|JL3jpzpu;
zT=yZu>-g&=XhP`c$I$ynBXPTK?Ila=ub7@?xM-hTxcOX<4b)m3Ck0UcT#fIG|Mn1A
zz5{D$H97@5EHBaYSh!;|?~Au0OT(YNVjcblC#l0MF1f(3T3JTE)n2FEonmcZStlJ+
zE+}_8E26Efuy$M)Im&q((Y7ZZK3X<Xz*_zJi}m;np8jZlg@x?7r;*N1C(~YE7k%Mj
z7hB}63KmPPJ)zCAZyH?Fw{0o<(7L^RzW=e=i4T`Rh3r_-YfLVX?rH6t!}m6pNh<N*
zdr|?ksBH%7mF4&x$&azh{H*UQ$bYWh`^vzwkRD>7TL2_5!ovfkD{^;c<9)3iJb9o&
zXD)eMu@Z{>m}&x7d`6w@)b-sQ@K>M)KvR_s1opi)D}52afc~V_7sVC|AwTQghwt2I
z0zdH{{1sT9i?>0Oswu{`3-_9GZ^q~5_}UKvFADx$Y(G5VNd+;lhC>#dq_WR#3e1P$
zVMp|1S!bRQ@@#lj?k>(O+C6v~y7XD<_<Y>lqpo#YGtMRSC(vicpQTX`bfZ{h1W!0J
zi_p390Wu0Sn$>HcQLWPdxQ9gqZM5a-J-ef*)2P?mB=eq+fTJh(o-lk(Vcb4YPhc_>
z=91sb0S@5xOb2)a_yG3BM_bgv+k?}i<1FaAAGRRKrwxo94(Zz-<{@gw{%-Vb5?Sec
pC;q?Bm!@x|NI#!(@r|w-1^tVOo^3n@DXYN$PGMD!#VcKP`yXa-A!`5t

literal 0
HcmV?d00001


From a67be37f78002d8c0a9108fa18e841e20c5537c1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:43:44 +0000
Subject: [PATCH 05/19] =?UTF-8?q?Ferrow=20=EC=9D=98=20=EC=B9=BC=EC=9D=B4?=
 =?UTF-8?q?=20=EC=84=B8=20=EC=9E=90=EC=84=B8=EC=97=90=EC=84=9C=20=EA=B0=99?=
 =?UTF-8?q?=EC=9D=80=20=EC=B9=BC=EB=A1=9C=20=EC=9D=BD=ED=9E=88=EA=B2=8C=20?=
 =?UTF-8?q?=ED=95=9C=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

세운 칼이 짧아지던 것과, 포즈가 중간 없이 바뀌던 것을 심사 둘이 같이 짚어서다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 570 ++++++++++++++--------
 1 file changed, 369 insertions(+), 201 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 8ff7c242..4d4c4000 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -463,29 +463,23 @@ const PARTS = {
     ".......",
     ".....dd",
   ] },
-  armfar_m: { x: 49, y: 40, rows: [
-    "......c......",
-    "....cccbb....",
-    "...dcccbba...",
-    "...dcccbba...",
-    "..ddcccbbaa..",
-    "...ddccbbaa..",
-    "...ddccbbaa..",
-    "...ddccbbaa..",
-    "..jdcccbbaa..",
-    ".jiddccbbaa..",
-    "jjjdddcbbaaa.",
-    "zIIdddcbbaaa.",
-    "zIIidccbbaaa.",
-    ".zIIcccbbaaa.",
-    "..zICccbbaaa.",
-    "...zCCcbbaaa.",
-    "....zCCbbaaaa",
-    "....zCCbbaaaa",
-    "....zCCbbaaaa",
-    ".....zCbbaaa.",
-    "......zbbaa..",
-    ".......zba...",
+  armfar_m: { x: 49, y: 48, rows: [
+    "..jhg..........",
+    ".jjihgg........",
+    "jjjiihhhgg.....",
+    "zIIiihhhhbba...",
+    "zjjiiihhcbbaa..",
+    ".jjjiiiccbbaaa.",
+    "..zIIjcccccbbaa",
+    "....zIcccccbaaa",
+    ".....zcccbbaaaa",
+    ".....dcccbbaaa.",
+    ".....dcccbbaaa.",
+    "....ddcccbbaa..",
+    ".....dcccbbaa..",
+    ".....dcccbba...",
+    "......cccbb....",
+    "........c......",
   ] },
   headrim: { x: 19, y: 11, rows: [
     "....z",
@@ -500,41 +494,58 @@ const PARTS = {
     "zCC..",
   ] },
   blade_m: { x: 52, y: 4, rows: [
-    "..z...",
-    "..z...",
-    ".zOO..",
-    ".zOO..",
-    ".zOOn.",
-    "zIOon.",
-    "zIOonn",
-    "zIOonn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIvvnn",
-    "zIOonn",
-    "zIOonn",
-    "zIOonn",
-    "zIOonn",
-  ] },
-  hilt_m: { x: 49, y: 34, rows: [
-    "zIIgggggggggg",
+    "....z....",
+    "...zOO...",
+    "...zOO...",
+    "..zOOoo..",
+    "..zOOoo..",
+    ".zmnoooo.",
+    ".zmnoooo.",
+    "zmmnooooo",
+    "zmmnooooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "nmmnuoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnfoooo",
+    "nmmnooooo",
+    "nmmnooooo",
+    "nmmnooooo",
+  ] },
+  hilt_m: { x: 50, y: 52, rows: [
+    "iiigggggggggg",
     "zIIhhhhhhhhhh",
-    ".............",
     ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
@@ -544,113 +555,116 @@ const PARTS = {
     ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
-    ".....sir.....",
-    ".....igg.....",
-    "....hhggh....",
-    ".....hhh.....",
-    "......h......",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....zIR.....",
+    ".....zgg.....",
+    "....zhggh....",
+    ".....zhh.....",
+    "......z......",
   ] },
-  fist_m: { x: 51, y: 37, rows: [
-    "...jhg...",
-    "..jihgg..",
-    ".jiihhgw.",
-    "jjiihhggg",
-    "jjjjhhggg",
-    "jjiijjggg",
-    ".jiihhjg.",
-    "..jihgg..",
+  fist_m: { x: 52, y: 56, rows: [
     "...jhg...",
+    "..zIhgg..",
+    ".zIIhhgw.",
+    "zIIihhggg",
+    "zIIjhhggg",
+    "zIIijjggg",
+    ".zIIhhjg.",
+    "..zIhgg..",
+    "...zhg...",
   ] },
   armfar_b: { x: 49, y: 48, rows: [
-    "..jhg........",
-    ".jihhg.......",
-    "jjihhgg......",
-    "zIIihhgg.....",
-    "zIIihhhgg....",
-    ".zIIihhbba...",
-    "..zjiibbbaa..",
-    "...jjcbbbaaa.",
-    "....ccbbbaaaa",
-    "...cccbbbaaaa",
-    "..dcccbbbaaaa",
-    "..dcccbbbaaa.",
-    ".ddcccbbbaa..",
-    "..dcccbbba...",
-    "..dcccbbb....",
-    "...cccbb.....",
-    ".....c.......",
-  ] },
-  blade_b: { x: 50, y: 67, rows: [
-    "zIOoooo",
-    "zIOoooo",
-    "zIOoonn",
-    "zIOoonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "zIOvonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "zIOvonn",
-    "zIOvonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiovonn",
-    "iiooonn",
-    "iiooonn",
-    "iiooonn",
-    "iiooonn",
-    ".iooon.",
-    ".iooon.",
-    ".iooon.",
-    "..ooo..",
-    "..ooo..",
-    "..ooo..",
-    "...o...",
-    "...o...",
-  ] },
-  hilt_b: { x: 47, y: 53, rows: [
+    "..jhg..........",
+    ".jiihgg........",
+    "jjiiihhhgg.....",
+    "zIIiihhhhbba...",
+    "zIIiiihhcbbaa..",
+    ".zIIiiiccbbaaa.",
+    "..zIIjcccbbaaaa",
+    "....zIcccbbaaaa",
+    ".....zcccbbaaaa",
+    ".....dcccbbaaa.",
+    ".....dcccbbaaa.",
+    "....ddcccbbaa..",
+    ".....dcccbbaa..",
+    ".....dcccbba...",
+    "......cccbb....",
+    "........c......",
+  ] },
+  blade_b: { x: 52, y: 69, rows: [
+    "zOOoooooo",
+    "zOOoooooo",
+    "zmmnooooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnfoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnuoooo",
+    "zmmnooooo",
+    "zmmnooooo",
+    "nmmnooooo",
+    "nmmnooooo",
+    ".mmnoooo.",
+    ".mmnoooo.",
+    "..mnooo..",
+    "..mnooo..",
+    "...noo...",
+    "...noo...",
+    "....o....",
+    "....o....",
+  ] },
+  hilt_b: { x: 50, y: 51, rows: [
     "......h......",
     ".....hgg.....",
-    "....zhggh....",
+    "....hhggh....",
     ".....hhh.....",
-    "......h......",
-    ".............",
-    ".............",
-    ".............",
+    ".....shr.....",
+    ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
-    "zIIhhhhgggggg",
-    "zIIiiihhhhhhh",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....zRR.....",
+    ".....zRR.....",
+    "zIIgggggggggg",
+    "zIIhhhhhhhhhh",
   ] },
-  fist_b: { x: 49, y: 56, rows: [
-    "...zhg...",
+  fist_b: { x: 52, y: 56, rows: [
+    "...jhg...",
     "..zIhgg..",
     ".zIIhhgw.",
     "zIIihhggg",
@@ -660,14 +674,133 @@ const PARTS = {
     "..zIhgg..",
     "...zhg...",
   ] },
+  smear_up: { x: 9, y: 0, rows: [
+    ".........nnnnnnnoooooooooooonnnnnnnn............",
+    ".....nnnnoooooooo...........ooooooonnnnn........",
+    "..nnnooooo.........................oooonnnnn....",
+    "nnoooo.................................oooonnn..",
+    "oo.........................................ooonn",
+    "..............................................oo",
+  ] },
+  smear_flip: { x: 55, y: 6, rows: [
+    "on.......",
+    "on.......",
+    "oon......",
+    ".on......",
+    ".on......",
+    ".on......",
+    ".on......",
+    ".on......",
+    "..on.....",
+    "..on.....",
+    "..on.....",
+    "..on.....",
+    "..on.....",
+    "...on....",
+    "...on....",
+    "...on....",
+    "...on....",
+    "...on....",
+    "...oon...",
+    "....on...",
+    "....on...",
+    "....on...",
+    "....on...",
+    "....on...",
+    "....oon..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    ".......on",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    "......on.",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    ".....on..",
+    "....onn..",
+    "....on...",
+    "....on...",
+    "....on...",
+    "....on...",
+    "....on...",
+    "...onn...",
+    "...on....",
+    "...on....",
+    "...on....",
+    "...on....",
+    "...on....",
+    "..on.....",
+    "..on.....",
+    "..on.....",
+    "..on.....",
+    "..on.....",
+    ".on......",
+    ".on......",
+    ".on......",
+    ".on......",
+    ".on......",
+    "onn......",
+    "on.......",
+    "on.......",
+  ] },
 };
 // The three poses: the sword on the shoulder, held upright, and planted.
 const ORDER = ["base", "pack", "blade", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "neck", "paulfar", "armfar", "paulnear", "armnear", "head", "hilt", "fistfar"];
 const ORDER_M = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_m", "paulnear", "armnear", "head", "headrim", "blade_m", "hilt_m", "fist_m"];
 const ORDER_B = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_b", "paulnear", "armnear", "head", "headrim", "blade_b", "hilt_b", "fist_b"];
 // Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.
-const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2};
-const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xa8bad4, T: 0x93a3c2, Y: 0x6a7aa6 };
+const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2, "smear_up": 1, "smear_flip": 1};
+const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xd6dde6, T: 0xa8bad4, Y: 0x6a7aa6 };
 // Knob 4: the editions, each a hand-picked repaint of some materials.
 const EDITIONS = [
   {  },
@@ -686,41 +819,42 @@ const STANDS = [
 // turns the gunmetal and the rim to a live blue; the overheat runs the gunmetal
 // red hot, one shade hotter on each in-breath.
 // Z is the arcs, a shade apart from the charged rim.
-const CHARGE = { g: 0xa6dcf2, h: 0x5a8fc8, i: 0x3a5aa0, j: 0x2c3480, I: 0x4a70b0, z: 0xc8f0ff, O: 0x6aa0d0, Z: 0x6fd0ff };
+const CHARGE = { g: 0x58b0f0, h: 0x3a70d0, i: 0x2c44a0, j: 0x24286e, I: 0x3a5cc0, z: 0xd8f4ff, O: 0x5a90d8, Z: 0x6fd0ff };
 const HEAT = [
-  { g: 0xf0a070, h: 0xc05a48, i: 0x86344c, j: 0x56265a, I: 0x7a3a5a },
-  { g: 0xffc080, h: 0xe07448, i: 0xa0404a, j: 0x642a5c, I: 0x8a4058 },
+  { g: 0xf0a070, h: 0xc05a48, i: 0x86344c, j: 0x56265a, I: 0x7a3a5a, S: 0xf2d8c8, T: 0xc89a90, Y: 0x8a6070 },
+  { g: 0xffc080, h: 0xe07448, i: 0xa0404a, j: 0x642a5c, I: 0x8a4058, S: 0xf2d8c8, T: 0xc89a90, Y: 0x8a6070 },
 ];
 // The case light: what a glossy character turns into while the band passes.
 const UP = {"n": "m", "o": "n", "O": "n", "h": "g", "i": "h", "I": "h", "j": "i"};
 // The eyes, x, y and colour, painted over the visor each frame so they can
-// look aside a pixel, half shut, shut to an ember line, flare or dim.
+// look aside, half shut, shut to an ember line, or flare.
 const EYES = [[33, 23, "u"], [34, 23, "u"], [35, 23, "w"], [43, 23, "u"], [44, 23, "w"],
   [33, 24, "u"], [34, 24, "f"], [35, 24, "f"], [36, 24, "f"], [37, 24, "u"], [41, 24, "u"], [42, 24, "f"], [43, 24, "f"], [44, 24, "u"],
   [34, 25, "u"], [35, 25, "f"], [36, 25, "u"], [37, 25, "u"], [41, 25, "u"], [42, 25, "u"], [43, 25, "u"]];
 const FLARE = { u: "f", f: "w", w: "w" };
-const DIM = { u: "v", f: "u", w: "f" };
 // The wink on the sword's point: x, y and what the LED turns into.
 const GLINT = [[10, 5, "w"], [9, 4, "w"], [11, 5, "w"]];
 // Where the planted point bites the stand, and the glow it throws on the rim.
 const BITE_X = 53, BITE_Y = 116;
-const SPILL = [[51, 118, "u"], [52, 118, "f"], [53, 118, "f"], [54, 118, "f"], [55, 118, "u"], [52, 119, "u"], [53, 119, "u"], [54, 119, "u"]];
+const SPILL = [[51, 118, "f"], [52, 118, "w"], [53, 118, "w"], [54, 118, "w"], [55, 118, "f"], [52, 119, "f"], [53, 119, "f"], [54, 119, "f"]];
+// A ring running out along the stand from the bite, a step at a time.
+const SHOCK = [4, 9, 14, 19];
 // The flash at the moment of the bite, for its first two fifteenths of a second.
 const FLASH = [[53, 113, "w"], [52, 115, "w"], [54, 115, "w"], [51, 115, "f"], [55, 115, "f"], [53, 114, "f"], [50, 116, "u"], [56, 116, "u"]];
-// The two exhaust mouths, and the shape of a puff as it ages: x, y off its
-// centre and the colour, lightest while young. The steam has its own letters,
-// S T Y, so no repaint of the steel reaches it.
-const STACKS = [[16, 27, 0], [10, 30, 0.5]];
+// The two exhaust mouths and how late each puffs after the other. A
+// puff swells and thins as it rises up and away to the left: S T Y light to
+// dim, its own letters so a repaint of the steel never reaches it.
+const STACKS = [[16, 27, 0], [10, 30, 0.2]];
 const PUFF = [
-  [[0, 0, "S"], [1, 0, "S"]],
-  [[0, 0, "S"], [1, 0, "S"], [0, -1, "S"], [1, -1, "T"]],
-  [[0, 0, "T"], [1, 0, "S"], [2, 0, "T"], [0, -1, "T"], [1, -1, "S"], [2, -1, "T"]],
-  [[0, 0, "Y"], [1, 0, "T"], [2, 0, "Y"], [0, -1, "Y"], [1, -1, "T"], [2, -1, "Y"]],
-  [[0, 0, "Y"], [1, 0, "Y"]],
+  ["SS", "SS"],
+  [".SS.", "SSSS", ".TS."],
+  [".SST.", "SSSST", "TSSTT", ".TT.."],
+  ["..TT..", ".TTTTY", "TTTYY.", ".YY..."],
+  [".YY.", "YYYY", ".Y.."],
+  ["YY"],
 ];
-const BIG = [[0, 0, "T"], [1, 0, "S"], [2, 0, "S"], [3, 0, "T"], [0, -1, "T"], [1, -1, "S"], [2, -1, "T"], [3, -1, "Y"], [1, -2, "T"], [2, -2, "Y"]];
 
-const { floor, min, max, abs, sin, cos, PI } = Math;
+const { floor, min, max, abs, cos, sin, PI } = Math;
 // The events run on a fixed loop of exactly eight breaths, so they always meet
 // the breath at the same phase. Blinks come 2 to 3.3 s apart and never while
 // the head is moving; the case light every 6.8 s, taking 2.4 s to cross, at a
@@ -734,12 +868,19 @@ const SWEEPS = [4.3, 11.1, 17.9, 24.7];
 const GLINTS = [3.0, 12.6, 15.8, 25.0];
 const PLANTS = [7.0, 20.6];
 const PLANTS_KEEN = [0.2, 7.0, 13.8, 20.6];
-const SCANS = [[4.8, -1, 1.1], [10.95, 1, 0.9], [15.2, -1, 1.1], [18.4, 1, 1.0], [24.4, -1, 1.2]];
+const SCANS = [[4.8, -2, 1.1], [10.95, 2, 0.9], [15.2, -2, 1.1], [18.4, 2, 1.0], [24.4, -2, 1.2]];
 const SWEEP_LEN = 2.4;
 const GLINT_LEN = 0.17;
 // The big move: the sword comes off the shoulder upright, bites the stand
 // point first at LIFT, is leant on until DOWN, and goes back up the same way.
-const LIFT = 0.23, DOWN = 3.23, PLANT_LEN = 3.46;
+// Each knob 1 stop has a pose it rests in between: shouldered, shouldered,
+// held upright on guard, and planted on standby.
+const LIFT = 6 / 15, DOWN = 51 / 15, PLANT_LEN = 55 / 15;
+const REST = [0, 0, 1, 2];
+// The swing drawn behind the figure as the pose changes, by from * 3 + to: an
+// arc over the head between shoulder and upright, and a crescent down the right
+// side as the sword turns over in the hand.
+const SMEAR = [null, "smear_up", null, "smear_up", null, "smear_flip", null, "smear_flip", null];
 // One breath is 3.4 s: the chest rises a pixel, the head follows a quarter
 // second later, and the tabard's hem swings a pixel sideways a beat after
 // that; both ends of each move are held longer than the moves between them.
@@ -820,19 +961,22 @@ function plantSince(p, t, motion) {
   return d;
 }
 
-function steam(buf, tt, heavy) {
-  const period = heavy ? 0.12 : 0.2, life = heavy ? 2.4 : 1.8;
+// Puffs leave the stacks once the out-breath has settled, and on the overheat
+// once the in-breath has too.
+function steam(buf, t, heavy) {
+  const life = heavy ? 1.8 : 1.4, phases = heavy ? [1.3, 3.0] : [1.3];
   for (let s = 0; s < STACKS.length; s++) {
-    const [x0, y0, off] = STACKS[s];
-    const k1 = floor(tt / period - off);
-    for (let k = max(0, k1 - floor(life / period) - 1); k <= k1; k++) {
-      const age = tt - (k + off) * period;
+    const [x0, y0, lag] = STACKS[s];
+    for (let f = 0; f < phases.length; f++) {
+      const at = phases[f] + lag;
+      const age = t - (at + floor((t - at) / BREATH) * BREATH);
       if (age < 0 || age >= life) continue;
-      const a = age / life;
-      const wob = floor(sin(age * 2.6 + k * 1.7) + 0.5);
-      const x = floor(x0 - age * 2.5 + wob + 0.5), y = floor(y0 - 1 - age * 9 + 0.5);
-      const shape = heavy && a >= 0.25 && a < 0.6 ? BIG : PUFF[min(4, floor(a * 5))];
-      for (let n = 0; n < shape.length; n++) under(buf, x + shape[n][0], y + shape[n][1], shape[n][2]);
+      const shape = PUFF[min(5, floor(age / life * 6))];
+      const cx = floor(x0 - age * (heavy ? 7 : 6) + 0.5), cy = floor(y0 - 2 - age * 8 + 0.5);
+      const x1 = cx - (shape[0].length >> 1), y1 = cy - shape.length + 1;
+      for (let j = 0; j < shape.length; j++) {
+        for (let i = 0; i < shape[j].length; i++) if (shape[j][i] !== ".") under(buf, x1 + i, y1 + j, shape[j][i]);
+      }
     }
   }
 }
@@ -840,8 +984,8 @@ function steam(buf, tt, heavy) {
 function sparks(buf, tt0, tt, seed) {
   for (let n = 0; n < 14; n++) {
     const h = hash(seed * 31 + n);
-    const ang = -PI * (0.4 + 0.45 * (h & 1023) / 1023);
-    const sp = 50 + ((h >>> 10) & 31), life = 0.4 + ((h >>> 15) & 15) / 30;
+    const ang = -PI * (0.35 + 0.42 * (h & 1023) / 1023);
+    const sp = 55 + ((h >>> 10) & 31), life = 0.4 + ((h >>> 15) & 15) / 30;
     const age = tt - tt0;
     if (age < 0 || age >= life) continue;
     const at = (q) => [floor(BITE_X + cos(ang) * sp * q + 0.5), floor(BITE_Y + sin(ang) * sp * q + 55 * q * q + 0.5)];
@@ -849,8 +993,8 @@ function sparks(buf, tt0, tt, seed) {
     if (y > BITE_Y + 2) continue;
     const [px, py] = at(max(0, age - 1 / 15));
     const steps = max(abs(x - px), abs(y - py));
-    for (let k = 1; k < steps; k++) over(buf, px + floor((x - px) * k / steps + 0.5), py + floor((y - py) * k / steps + 0.5), age < 0.35 ? "u" : "v");
-    over(buf, x, y, age < 0.14 ? "w" : age < 0.45 ? "f" : "u");
+    for (let k = 1; k < steps; k++) over(buf, px + floor((x - px) * k / steps + 0.5), py + floor((y - py) * k / steps + 0.5), age < 0.35 ? "f" : "u");
+    over(buf, x, y, age < 0.3 ? "w" : "f");
   }
 }
 
@@ -868,13 +1012,22 @@ function arcs(buf, slot) {
     if (left) { for (let i = 0; i < W; i++) if (buf[y0 * W + i]) { x = i; break; } }
     else { for (let i = W - 1; i >= 0; i--) if (buf[y0 * W + i]) { x = i; break; } }
     if (x < 0) continue;
-    let y = y0;
-    const len = 4 + ((g >>> 10) % 5);
+    // A jagged run outward, never level for two steps, with a fork off its
+    // second step that kicks the other way.
+    let y = y0, fx = 0, fy = 0;
+    const len = 4 + ((g >>> 10) % 5), step = left ? -1 : 1;
+    const put = (px, py, ch) => {
+      if (py >= 0 && py < H && px >= 0 && px < W && !buf[py * W + px]) out.push([px, py, ch]);
+    };
     for (let k = 1; k <= len; k++) {
-      x += left ? -1 : 1;
-      y += ((g >>> (12 + k * 2)) % 3) - 1;
-      if (y >= 0 && y < H && x >= 0 && x < W && !buf[y * W + x]) out.push([x, y, k === 1 ? "w" : "Z"]);
+      x += step;
+      y += (g >>> (12 + k)) & 1 ? 1 : -1;
+      put(x, y, k < len ? "w" : "Z");
+      if (k === 2) { fx = x; fy = y; }
     }
+    const kick = (g >>> 13) & 1 ? -1 : 1;
+    put(fx + step, fy + kick * 2, "Z");
+    put(fx + step * 2, fy + kick * 3, "Z");
   }
   return out;
 }
@@ -931,11 +1084,16 @@ export function draw(display, params) {
   const dy = [0, u >= 1.1 && u < 2.8 ? -1 : 0, u >= 1.35 && u < 3.05 ? -1 : 0, 0, 0];
   const dx = [0, 0, 0, u >= 1.45 && u < 3.15 ? -1 : 0, 0];
 
-  // Shouldered, upright, or planted; guard mode keeps it planted.
+  // Shouldered, upright or planted, and the swing behind the figure for the
+  // two steps after it changes.
+  const poseAt = (q) => {
+    const e = plantSince(p, q, motion);
+    return e < 0 ? REST[motion] : e < LIFT || e >= DOWN ? 1 : 2;
+  };
   const d = plantSince(p, t, motion);
-  let pose = motion === 2 ? 2 : 0;
-  if (d >= 0) pose = d < LIFT ? 1 : d < DOWN || motion === 2 ? 2 : 1;
-  const sd = d >= LIFT ? d - LIFT : -1;
+  const pose = poseAt(t), was = poseAt((tick - 2) / 15);
+  const smear = was !== pose ? SMEAR[was * 3 + pose] : null;
+  const sd = d >= LIFT && d < DOWN ? d - LIFT : -1;
   // The bite goes through him: the head drops a pixel, the chest after it.
   if (sd >= 0 && sd < 0.27) dy[2] += 1;
   if (sd >= 0.07 && sd < 0.23) dy[1] += 1;
@@ -947,6 +1105,7 @@ export function draw(display, params) {
 
   // The case light passes over the steel above the stand; the legs and the stand keep still.
   const order = pose === 0 ? ORDER : pose === 1 ? ORDER_M : ORDER_B;
+  if (smear) blit(buf, PARTS[smear], 0, dy[1], false, 0);
   for (let n = 0; n < order.length; n++) {
     const name = order[n], g = GROUP[name];
     blit(buf, PARTS[name], dx[g], dy[g], sweep && g !== 0, band);
@@ -960,14 +1119,15 @@ export function draw(display, params) {
       if (c === 117 || c === 102 || c === 119) buf[i] = 120;
     }
   }
+  // On standby the eyes are down to the ember line between the shutters.
   const db = since(BLINKS, t, 0.3);
-  const lid = db < 0 ? 0 : db < 0.08 || db >= 0.2 ? 1 : 2;
+  const lid = motion === 3 && d < 0 ? 2 : db < 0 ? 0 : db < 0.08 || db >= 0.2 ? 1 : 2;
   let look = 0;
   if (d < 0 && motion !== 3) {
     const u2 = t % CYCLE;
     for (let s = 0; s < SCANS.length; s++) if (u2 >= SCANS[s][0] && u2 < SCANS[s][0] + SCANS[s][2]) look = SCANS[s][1];
   }
-  const mood = (d >= 0 && d < 1.4) || motion === 2 ? FLARE : motion === 3 ? DIM : null;
+  const mood = (d >= 0 && d < LIFT + 1) || motion === 2 ? FLARE : null;
   for (let e = 0; e < EYES.length; e++) {
     const [x, y, c] = EYES[e];
     if (lid === 1 && y === 23) continue;
@@ -984,7 +1144,7 @@ export function draw(display, params) {
     }
   }
 
-  if (fx === 0 || fx === 2) steam(buf, t, fx === 2);
+  if ((fx === 0 || fx === 2) && motion !== 3) steam(buf, t, fx === 2);
   if (fx === 1) {
     const slot = tick >> 1;
     if (slot !== p.arcSlot) {
@@ -996,7 +1156,15 @@ export function draw(display, params) {
   if (fx !== 3 && sd >= 0 && sd < 0.9) {
     const t0 = t - sd;
     sparks(buf, t0, t, floor(t0 * 10 + 0.5));
-    if (sd < 0.3) for (let i = 0; i < SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd < 0.15 ? SPILL[i][2] : "v");
+    if (sd < 0.3) for (let i = 0; i < SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd < 0.15 ? SPILL[i][2] : "u");
+    const r = SHOCK[floor(sd * 15 + 0.5)];
+    if (r) {
+      for (let s = -1; s <= 1; s += 2) {
+        const x = BITE_X + s * r;
+        if (x >= 0 && x < W && buf[117 * W + x]) over(buf, x, 117, "w");
+        if (x - s >= 0 && x - s < W && buf[117 * W + x - s]) over(buf, x - s, 117, "f");
+      }
+    }
     if (sd < 0.14) for (let i = 0; i < FLASH.length; i++) over(buf, FLASH[i][0], FLASH[i][1], FLASH[i][2]);
   }
 

From e8e5b9723c38a6abd3d0a445df07c2a3abb8e916 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:45:19 +0000
Subject: [PATCH 06/19] =?UTF-8?q?Ferrow=20=EC=B9=B4=EB=93=9C=EC=99=80=20?=
 =?UTF-8?q?=EB=A8=B8=EB=A6=AC=EA=B8=80=EC=97=90=20=EA=B2=BD=EA=B3=84?=
 =?UTF-8?q?=EC=99=80=20=EB=8C=80=EA=B8=B0=20=EC=9E=90=EC=84=B8=EB=A5=BC=20?=
 =?UTF-8?q?=EC=A0=81=EB=8A=94=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/craft/01-figure/brief.md | 6 +++---
 incoming/pattern-study/patterns/ferrow.js       | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/incoming/pattern-study/craft/01-figure/brief.md b/incoming/pattern-study/craft/01-figure/brief.md
index 2c67ece9..9e9ef5b8 100644
--- a/incoming/pattern-study/craft/01-figure/brief.md
+++ b/incoming/pattern-study/craft/01-figure/brief.md
@@ -14,14 +14,14 @@ slug: ferrow
 - 재질: 반광 에나멜 장갑(뼈색), 광택 금속(건메탈 뼈대와 대검 날), 무광 천(허리에 늘어뜨린 자줏빛 휘장).
 - 광원: 키 라이트는 오른쪽 위에서 오는 따뜻한 빛이에요. 림은 왼쪽 가장자리의 차가운 하늘색 1px 이고, 그 옆 두 칸에 그늘 쪽 반사가 들어요.
 - 비례: 3.4등신. 키 111줄(볏 꼭대기에서 발바닥까지)에 머리 33줄이에요.
-- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 1px 옆을 보는 것은 따로 돌아요. 등 배기통 둘에서 증기가 늘 올라요.
-- 큰 동작: 27.2초에 두 번, 대검을 어깨에서 들어 똑바로 세웠다가 칼끝을 받침에 꽂아요. 꽂히는 순간 눈이 하얗게 타고 머리와 가슴이 1px 내려앉고, 칼끝에서 불꽃이 튀고 받침 테에 빛이 번져요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요.
+- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 숨을 내쉬고 나면 등 배기통 둘에서 증기 덩이가 하나씩 올라요.
+- 큰 동작: 27.2초에 두 번, 대검을 머리 위로 휘둘러 허리춤에서 똑바로 세워 들었다가, 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 눈이 하얗게 타고 머리와 가슴이 1px 내려앉고, 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 빛이 퍼져요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길과 돌린 길에는 두 걸음 동안 자국이 남아요. 칼은 세 자세 다 같은 49줄짜리예요.
 - 강조색: 달군 쇠의 호박색. 대검의 홈과 두 눈에만 칠해요.
 - 이름판: 없어요. 받침 옆띠가 5줄이라 7줄이 안 돼요.
 
 노브 넷과 버튼이에요.
 
-- K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번), 1/2 경계(칼을 꽂은 채 눈을 밝히고 섬), 3/4 대기(눈을 낮추고 숨과 깜빡임만).
+- K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 눈을 숯불 줄로 낮추고 숨만 쉼).
 - K2 받침: 0 나무, 1 흰 대리석, 2 검은 아크릴에 금 테(기본), 3 가장자리가 빛나는 아크릴.
 - K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈과 림이 푸르게 서고 윤곽에서 아크가 튐), 1/2 과열(건메탈이 붉게 달아 들숨마다 한 단 더 달고 증기가 짙음), 3/4 끔.
 - K4 에디션: 0 뼈색 기본 칠, 1/4 2P 검정과 청록, 1/2 금과 크롬 한정판, 3/4 무도색 원형.
diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 4d4c4000..9182e6c8 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -1,7 +1,7 @@
 // ===== Patternflow pattern =====
 // Title:   Ferrow
 // Family:  pixel
-// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he takes the sword off his shoulder, raises it upright and drives its point into the stand in a spray of sparks, leans on it a while and shoulders it again.
+// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he swings the sword off his shoulder to stand it upright at his hip, turns it over in his hand and drives its point into the stand in a flash and a spray of sparks, leans on it a while and shoulders it again.
 // Author:  patternflow-lab
 // Date:    2026-11-01
 // SPDX-License-Identifier: CC-BY-SA-4.0
@@ -11,7 +11,7 @@
 // @matrix 64x128
 // @knobs Motion=0..1, Stand=0..3, Effect=0..1, Edition=0..1
 //
-// Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard, the sword planted and his eyes flared; from 0.75 he is on standby with dimmed eyes, breathing and blinking only.
+// Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his eyes down to an ember line, and only breathes.
 // Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.
 // Knob 3: Effect. What comes off him: steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that turns his gunmetal and rim live blue with arcs crawling off his outline; from 0.5 an overheat, the gunmetal glowing red and hotter on each in-breath, with heavy steam; from 0.75 none.
 // Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.

From c163e7016e6c8ee030a8f03e22bc3e26fef4e80d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:50:52 +0000
Subject: [PATCH 07/19] =?UTF-8?q?Ferrow=20=EA=B0=80=20=EC=B9=BC=EC=9D=84?=
 =?UTF-8?q?=20=EA=BD=82=EB=8A=94=20=EC=88=9C=EA=B0=84=EC=97=90=20=EB=AC=B4?=
 =?UTF-8?q?=EA=B2=8C=EB=A5=BC=20=EC=8B=A3=EB=8A=94=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

꽂히는 박자가 점 하나로 끝난다는 심사 둘의 지적에 몸이 내려앉고 받침 테가 번쩍이게 한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 332 ++++++++++++----------
 1 file changed, 182 insertions(+), 150 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 9182e6c8..a2791b73 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -21,8 +21,8 @@ const W = 64, H = 128;
 // Each part is a grid, one character per LED and "." where it is clear, drawn
 // in ORDER. Materials run light to dark: enamel a b c d, gunmetal g h i j,
 // tabard p q r s, blade steel m n o. C I R O are the shadow-side bounce next to
-// the rim light z. f u v are the hot amber of the
-// fuller and the eyes, x the dark of the visor, w the specular. U V X N are the stand.
+// the rim light z. f u v are the hot amber of the fuller and the eyes, x the
+// dark of the visor, w the specular. U V X N are the stand, S T Y the steam.
 const PARTS = {
   base: { x: 6, y: 111, rows: [
     ".............NNNNNNNNNNNNNNNNNNNNNNNNNN.............",
@@ -557,7 +557,10 @@ const PARTS = {
     ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
-    ".....zIR.....",
+    ".....zRR.....",
+    ".....zRR.....",
+    ".....zRR.....",
+    ".....zhr.....",
     ".....zgg.....",
     "....zhggh....",
     ".....zhh.....",
@@ -576,11 +579,11 @@ const PARTS = {
   ] },
   armfar_b: { x: 49, y: 48, rows: [
     "..jhg..........",
-    ".jiihgg........",
-    "jjiiihhhgg.....",
-    "zIIiihhhhbba...",
-    "zIIiiihhcbbaa..",
-    ".zIIiiiccbbaaa.",
+    ".jiiihg........",
+    "jjijjihhgg.....",
+    "zIIijihhhbba...",
+    "zIIijjhhcbbaa..",
+    ".zIIjjiccbbaaa.",
     "..zIIjcccbbaaaa",
     "....zIcccbbaaaa",
     ".....zcccbbaaaa",
@@ -643,7 +646,7 @@ const PARTS = {
     "....o....",
     "....o....",
   ] },
-  hilt_b: { x: 50, y: 51, rows: [
+  hilt_b: { x: 50, y: 46, rows: [
     "......h......",
     ".....hgg.....",
     "....hhggh....",
@@ -658,6 +661,11 @@ const PARTS = {
     ".....ssr.....",
     ".....ssr.....",
     ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
+    ".....ssr.....",
     ".....zRR.....",
     ".....zRR.....",
     "zIIgggggggggg",
@@ -675,123 +683,123 @@ const PARTS = {
     "...zhg...",
   ] },
   smear_up: { x: 9, y: 0, rows: [
-    ".........nnnnnnnoooooooooooonnnnnnnn............",
-    ".....nnnnoooooooo...........ooooooonnnnn........",
-    "..nnnooooo.........................oooonnnnn....",
-    "nnoooo.................................oooonnn..",
-    "oo.........................................ooonn",
+    "......ooommmmmmmmmmmmmmmmmmmmmmmmmmooooo........",
+    ".....mmmmmmmmmmmoooooooooooommmmmmmmmmmooo......",
+    "..mmmommmoooooooo...........ooooooommmmmmmmm....",
+    "mmoooooooo.........................oooommoommm..",
+    "oo.....................................ooo.ooomm",
     "..............................................oo",
   ] },
-  smear_flip: { x: 55, y: 6, rows: [
-    "on.......",
-    "on.......",
-    "oon......",
-    ".on......",
-    ".on......",
-    ".on......",
-    ".on......",
-    ".on......",
-    "..on.....",
-    "..on.....",
-    "..on.....",
-    "..on.....",
-    "..on.....",
-    "...on....",
-    "...on....",
-    "...on....",
-    "...on....",
-    "...on....",
-    "...oon...",
-    "....on...",
-    "....on...",
-    "....on...",
-    "....on...",
-    "....on...",
-    "....oon..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    ".......on",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    "......on.",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    ".....on..",
-    "....onn..",
-    "....on...",
-    "....on...",
-    "....on...",
-    "....on...",
-    "....on...",
-    "...onn...",
-    "...on....",
-    "...on....",
-    "...on....",
-    "...on....",
-    "...on....",
-    "..on.....",
-    "..on.....",
-    "..on.....",
-    "..on.....",
-    "..on.....",
-    ".on......",
-    ".on......",
-    ".on......",
-    ".on......",
-    ".on......",
-    "onn......",
-    "on.......",
-    "on.......",
+  smear_flip: { x: 54, y: 6, rows: [
+    "oo........",
+    "oo........",
+    "ooo.......",
+    ".oo.......",
+    ".oo.......",
+    ".oo.......",
+    ".oo.......",
+    ".oo.......",
+    "..oo......",
+    ".ommo.....",
+    ".ommo.....",
+    ".ommo.....",
+    ".ommo.....",
+    "..ommo....",
+    "..ommo....",
+    "..ommo....",
+    "..ommo....",
+    "..ommo....",
+    "..oommo...",
+    "...ommo...",
+    "...ommo...",
+    "...ommo...",
+    "...ommo...",
+    "...ommo...",
+    "...oommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    "......ommo",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    ".....ommo.",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "....ommo..",
+    "...ommoo..",
+    "...ommo...",
+    "...ommo...",
+    "...ommo...",
+    "...ommo...",
+    "...ommo...",
+    "..ommoo...",
+    "..ommo....",
+    "..ommo....",
+    "..ommo....",
+    "..ommo....",
+    "..ommo....",
+    ".ommo.....",
+    ".ommo.....",
+    ".ommo.....",
+    ".ommo.....",
+    "..oo......",
+    ".oo.......",
+    ".oo.......",
+    ".oo.......",
+    ".oo.......",
+    ".oo.......",
+    "ooo.......",
+    "oo........",
+    "oo........",
   ] },
 };
 // The three poses: the sword on the shoulder, held upright, and planted.
@@ -816,13 +824,17 @@ const STANDS = [
   { U: 0x00658c, V: 0x00bcd9, X: 0x0084a8, N: 0xc1f8f9 },
 ];
 // Knob 3: what the frame does to the steel. Steam and off leave it; the charge
-// turns the gunmetal and the rim to a live blue; the overheat runs the gunmetal
-// red hot, one shade hotter on each in-breath.
+// turns the gunmetal, the rim, the eyes and the fuller a live blue that surges
+// brighter now and then; the overheat runs the gunmetal orange hot, brighter
+// than the enamel, and hotter again on each in-breath.
 // Z is the arcs, a shade apart from the charged rim.
-const CHARGE = { g: 0x58b0f0, h: 0x3a70d0, i: 0x2c44a0, j: 0x24286e, I: 0x3a5cc0, z: 0xd8f4ff, O: 0x5a90d8, Z: 0x6fd0ff };
+const CHARGE = [
+  { g: 0x58b0f0, h: 0x3a70d0, i: 0x2c44a0, j: 0x24286e, I: 0x3a5cc0, z: 0xd8f4ff, O: 0x5a90d8, Z: 0x6fd0ff, u: 0x40c8ff, f: 0xa8ecff, v: 0x3a78e0 },
+  { g: 0xb8eaff, h: 0x70b8ff, i: 0x4070e0, j: 0x30349a, I: 0x5a88f0, z: 0xf0fcff, O: 0x80b8f8, Z: 0xa8e8ff, u: 0x80e0ff, f: 0xd8f8ff, v: 0x4a90f0 },
+];
 const HEAT = [
-  { g: 0xf0a070, h: 0xc05a48, i: 0x86344c, j: 0x56265a, I: 0x7a3a5a, S: 0xf2d8c8, T: 0xc89a90, Y: 0x8a6070 },
-  { g: 0xffc080, h: 0xe07448, i: 0xa0404a, j: 0x642a5c, I: 0x8a4058, S: 0xf2d8c8, T: 0xc89a90, Y: 0x8a6070 },
+  { g: 0xffe08a, h: 0xffa040, i: 0xd8602c, j: 0x8a3038, I: 0xc05a40 },
+  { g: 0xfff0b0, h: 0xffc060, i: 0xf07a34, j: 0xa83a3a, I: 0xd8703c },
 ];
 // The case light: what a glossy character turns into while the band passes.
 const UP = {"n": "m", "o": "n", "O": "n", "h": "g", "i": "h", "I": "h", "j": "i"};
@@ -835,23 +847,25 @@ const FLARE = { u: "f", f: "w", w: "w" };
 // The wink on the sword's point: x, y and what the LED turns into.
 const GLINT = [[10, 5, "w"], [9, 4, "w"], [11, 5, "w"]];
 // Where the planted point bites the stand, and the glow it throws on the rim.
-const BITE_X = 53, BITE_Y = 116;
-const SPILL = [[51, 118, "f"], [52, 118, "w"], [53, 118, "w"], [54, 118, "w"], [55, 118, "f"], [52, 119, "f"], [53, 119, "f"], [54, 119, "f"]];
+const BITE_X = 56, BITE_Y = 116;
+// What does not sink with him.
+const FIRM = { base: 1, legfar: 1, legnear: 1 };
+const SPILL = [[53, 118, "f"], [54, 118, "w"], [55, 118, "w"], [56, 118, "w"], [57, 118, "f"], [54, 119, "f"], [55, 119, "f"], [56, 119, "f"]];
 // A ring running out along the stand from the bite, a step at a time.
-const SHOCK = [4, 9, 14, 19];
+const SHOCK = [4, 9, 15, 22, 30, 38];
 // The flash at the moment of the bite, for its first two fifteenths of a second.
-const FLASH = [[53, 113, "w"], [52, 115, "w"], [54, 115, "w"], [51, 115, "f"], [55, 115, "f"], [53, 114, "f"], [50, 116, "u"], [56, 116, "u"]];
+const FLASH = [[56, 111, "f"], [56, 112, "w"], [56, 113, "w"], [56, 114, "w"], [53, 116, "w"], [54, 116, "w"], [55, 116, "w"], [57, 116, "w"], [58, 116, "w"], [51, 116, "f"], [52, 116, "f"], [59, 116, "f"], [60, 116, "f"], [54, 114, "f"], [58, 114, "f"], [53, 113, "u"], [59, 113, "u"], [56, 110, "u"]];
 // The two exhaust mouths and how late each puffs after the other. A
 // puff swells and thins as it rises up and away to the left: S T Y light to
 // dim, its own letters so a repaint of the steel never reaches it.
 const STACKS = [[16, 27, 0], [10, 30, 0.2]];
 const PUFF = [
-  ["SS", "SS"],
-  [".SS.", "SSSS", ".TS."],
-  [".SST.", "SSSST", "TSSTT", ".TT.."],
-  ["..TT..", ".TTTTY", "TTTYY.", ".YY..."],
-  [".YY.", "YYYY", ".Y.."],
-  ["YY"],
+  [".S.", "SSS", ".S."],
+  [".SSS.", "SSSSS", "SSSST", ".STT."],
+  [".SSSS.", "SSSSST", "SSSSTT", "TSSTTT", ".TTT.."],
+  ["..TTT..", ".TTTTTY", "TTTTTYY", "TTTYYY.", ".YYY..."],
+  ["..YYY.", ".YYYYY", "YYYYY.", ".YY..."],
+  [".YY.", "YYYY"],
 ];
 
 const { floor, min, max, abs, cos, sin, PI } = Math;
@@ -867,7 +881,7 @@ const BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];
 const SWEEPS = [4.3, 11.1, 17.9, 24.7];
 const GLINTS = [3.0, 12.6, 15.8, 25.0];
 const PLANTS = [7.0, 20.6];
-const PLANTS_KEEN = [0.2, 7.0, 13.8, 20.6];
+const PLANTS_KEEN = [1.6, 8.4, 15.2, 22.0];
 const SCANS = [[4.8, -2, 1.1], [10.95, 2, 0.9], [15.2, -2, 1.1], [18.4, 2, 1.0], [24.4, -2, 1.2]];
 const SWEEP_LEN = 2.4;
 const GLINT_LEN = 0.17;
@@ -911,7 +925,7 @@ function lut(ed, stand, fx, tier) {
   put(PAL);
   put(EDITIONS[ed]);
   put(STANDS[stand]);
-  if (fx === 1) put(CHARGE);
+  if (fx === 1) put(CHARGE[tier]);
   if (fx === 2) put(HEAT[tier]);
   return t;
 }
@@ -961,10 +975,10 @@ function plantSince(p, t, motion) {
   return d;
 }
 
-// Puffs leave the stacks once the out-breath has settled, and on the overheat
-// once the in-breath has too.
+// A puff leaves each stack once each half of the breath has settled, and twice
+// as often on the overheat.
 function steam(buf, t, heavy) {
-  const life = heavy ? 1.8 : 1.4, phases = heavy ? [1.3, 3.0] : [1.3];
+  const life = heavy ? 2.0 : 1.8, phases = heavy ? [1.3, 2.15, 3.0, 0.45] : [1.3, 3.0];
   for (let s = 0; s < STACKS.length; s++) {
     const [x0, y0, lag] = STACKS[s];
     for (let f = 0; f < phases.length; f++) {
@@ -972,7 +986,7 @@ function steam(buf, t, heavy) {
       const age = t - (at + floor((t - at) / BREATH) * BREATH);
       if (age < 0 || age >= life) continue;
       const shape = PUFF[min(5, floor(age / life * 6))];
-      const cx = floor(x0 - age * (heavy ? 7 : 6) + 0.5), cy = floor(y0 - 2 - age * 8 + 0.5);
+      const cx = floor(x0 - age * (heavy ? 5 : 4) + 0.5), cy = floor(y0 - 1 - age * 7 + 0.5);
       const x1 = cx - (shape[0].length >> 1), y1 = cy - shape.length + 1;
       for (let j = 0; j < shape.length; j++) {
         for (let i = 0; i < shape[j].length; i++) if (shape[j][i] !== ".") under(buf, x1 + i, y1 + j, shape[j][i]);
@@ -982,6 +996,15 @@ function steam(buf, t, heavy) {
 }
 
 function sparks(buf, tt0, tt, seed) {
+  // Embers skid out along the stand top, most of them to the left.
+  for (let n = 0; n < 6; n++) {
+    const h = hash(seed * 17 + n + 99);
+    const age = tt - tt0, life = 0.3 + (h & 7) / 30;
+    if (age < 0 || age >= life) continue;
+    const v = (40 + ((h >>> 3) & 31)) * (n < 4 ? -1 : 1);
+    const x = floor(BITE_X + v * age * (1 - age) + 0.5), y = BITE_Y + 1 - ((h >>> 9) & 1);
+    if (x >= 0 && x < W && buf[y * W + x]) over(buf, x, y, age < 0.15 ? "w" : "f");
+  }
   for (let n = 0; n < 14; n++) {
     const h = hash(seed * 31 + n);
     const ang = -PI * (0.35 + 0.42 * (h & 1023) / 1023);
@@ -1094,9 +1117,13 @@ export function draw(display, params) {
   const pose = poseAt(t), was = poseAt((tick - 2) / 15);
   const smear = was !== pose ? SMEAR[was * 3 + pose] : null;
   const sd = d >= LIFT && d < DOWN ? d - LIFT : -1;
-  // The bite goes through him: the head drops a pixel, the chest after it.
-  if (sd >= 0 && sd < 0.27) dy[2] += 1;
-  if (sd >= 0.07 && sd < 0.23) dy[1] += 1;
+  // He sinks into his knees a pixel as he swings, and two as the point bites;
+  // only the legs, the stand and the planted sword stay. On standby the head
+  // hangs a pixel.
+  const sink = d >= 0 && d < 2 / 15 ? 1 : sd >= 0 && sd < 2 / 15 ? 2 : sd >= 0 && sd < 4 / 15 ? 1 : 0;
+  dy[1] += sink;
+  dy[3] += sink;
+  dy[2] += sink + (motion === 3 && d < 0 ? 1 : 0);
 
   let sw = since(SWEEPS, t, SWEEP_LEN);
   if (t >= p.sweepAt && t - p.sweepAt < SWEEP_LEN) sw = t - p.sweepAt;
@@ -1108,7 +1135,7 @@ export function draw(display, params) {
   if (smear) blit(buf, PARTS[smear], 0, dy[1], false, 0);
   for (let n = 0; n < order.length; n++) {
     const name = order[n], g = GROUP[name];
-    blit(buf, PARTS[name], dx[g], dy[g], sweep && g !== 0, band);
+    blit(buf, PARTS[name], dx[g], dy[g] + (g === 0 && !FIRM[name] ? sink : 0), sweep && g !== 0, band);
   }
 
   // The eyes: clear the visor behind them, then paint them where they look.
@@ -1156,6 +1183,11 @@ export function draw(display, params) {
   if (fx !== 3 && sd >= 0 && sd < 0.9) {
     const t0 = t - sd;
     sparks(buf, t0, t, floor(t0 * 10 + 0.5));
+    // The stand's gold ring answers the bite: white, then amber.
+    if (sd < 4 / 15) {
+      const ring = sd < 2 / 15 ? 119 : 102;
+      for (let i = 104 * W; i < H * W; i++) if (buf[i] === 78) buf[i] = ring;
+    }
     if (sd < 0.3) for (let i = 0; i < SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd < 0.15 ? SPILL[i][2] : "u");
     const r = SHOCK[floor(sd * 15 + 0.5)];
     if (r) {
@@ -1168,7 +1200,7 @@ export function draw(display, params) {
     if (sd < 0.14) for (let i = 0; i < FLASH.length; i++) over(buf, FLASH[i][0], FLASH[i][1], FLASH[i][2]);
   }
 
-  const tier = fx === 2 && dy[1] < 0 ? 1 : 0;
+  const tier = fx === 2 ? (u >= 1.1 && u < 2.8 ? 1 : 0) : fx === 1 ? (hash((tick >> 1) * 13 + 5) % 7 === 0 ? 1 : 0) : 0;
   const key = ed * 64 + stand * 16 + fx * 4 + tier;
   if (key !== p.key) {
     p.key = key;

From c53635e05b4fe8ec090e8c6e06e7927a26af03bd Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:51:36 +0000
Subject: [PATCH 08/19] =?UTF-8?q?=ED=99=9C=EB=B0=9C=20=EC=9E=90=EB=A6=AC?=
 =?UTF-8?q?=EC=9D=98=20=EC=A0=95=EC=A7=80=20=EA=B7=B8=EB=A6=BC=EC=9D=B4=20?=
 =?UTF-8?q?=EC=B9=BC=EC=9D=B4=20=EA=BD=82=ED=9E=88=EB=8A=94=20=EC=88=9C?=
 =?UTF-8?q?=EA=B0=84=EC=97=90=20=EC=98=A4=EA=B2=8C=20=ED=95=9C=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index a2791b73..e57dbff7 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -881,7 +881,7 @@ const BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];
 const SWEEPS = [4.3, 11.1, 17.9, 24.7];
 const GLINTS = [3.0, 12.6, 15.8, 25.0];
 const PLANTS = [7.0, 20.6];
-const PLANTS_KEEN = [1.6, 8.4, 15.2, 22.0];
+const PLANTS_KEEN = [1.5, 8.3, 15.1, 21.9];
 const SCANS = [[4.8, -2, 1.1], [10.95, 2, 0.9], [15.2, -2, 1.1], [18.4, 2, 1.0], [24.4, -2, 1.2]];
 const SWEEP_LEN = 2.4;
 const GLINT_LEN = 0.17;

From 81f05e20fd928ff2ee348b8fed8b7eae1477b7fb Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:52:30 +0000
Subject: [PATCH 09/19] =?UTF-8?q?Ferrow=20=EC=B9=B4=EB=93=9C=EC=99=80=20?=
 =?UTF-8?q?=EB=A8=B8=EB=A6=AC=EA=B8=80=EC=9D=84=20=EC=A7=80=EA=B8=88=20?=
 =?UTF-8?q?=EC=9B=80=EC=A7=81=EC=9E=84=EC=97=90=20=EB=A7=9E=EC=B6=98?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/craft/01-figure/brief.md | 8 ++++----
 incoming/pattern-study/patterns/ferrow.js       | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/incoming/pattern-study/craft/01-figure/brief.md b/incoming/pattern-study/craft/01-figure/brief.md
index 9e9ef5b8..74e2927f 100644
--- a/incoming/pattern-study/craft/01-figure/brief.md
+++ b/incoming/pattern-study/craft/01-figure/brief.md
@@ -14,16 +14,16 @@ slug: ferrow
 - 재질: 반광 에나멜 장갑(뼈색), 광택 금속(건메탈 뼈대와 대검 날), 무광 천(허리에 늘어뜨린 자줏빛 휘장).
 - 광원: 키 라이트는 오른쪽 위에서 오는 따뜻한 빛이에요. 림은 왼쪽 가장자리의 차가운 하늘색 1px 이고, 그 옆 두 칸에 그늘 쪽 반사가 들어요.
 - 비례: 3.4등신. 키 111줄(볏 꼭대기에서 발바닥까지)에 머리 33줄이에요.
-- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 숨을 내쉬고 나면 등 배기통 둘에서 증기 덩이가 하나씩 올라요.
-- 큰 동작: 27.2초에 두 번, 대검을 머리 위로 휘둘러 허리춤에서 똑바로 세워 들었다가, 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 눈이 하얗게 타고 머리와 가슴이 1px 내려앉고, 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 빛이 퍼져요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길과 돌린 길에는 두 걸음 동안 자국이 남아요. 칼은 세 자세 다 같은 49줄짜리예요.
+- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 들숨과 날숨이 끝날 때마다 등 배기통 둘에서 증기 덩이가 하나씩 올라요.
+- 큰 동작: 27.2초에 두 번, 대검을 머리 위로 휘둘러 허리춤에서 똑바로 세워 들었다가, 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 무릎으로 2px 내려앉고 눈이 하얗게 타요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러지고, 받침의 금 테가 하얗게 번쩍였다가 호박색으로 식어요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길과 돌린 길에는 두 걸음 동안 자국이 남아요. 칼은 세 자세 다 같은 49줄짜리예요.
 - 강조색: 달군 쇠의 호박색. 대검의 홈과 두 눈에만 칠해요.
 - 이름판: 없어요. 받침 옆띠가 5줄이라 7줄이 안 돼요.
 
 노브 넷과 버튼이에요.
 
-- K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 눈을 숯불 줄로 낮추고 숨만 쉼).
+- K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번, 2초가 칼이 꽂히는 순간), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 고개를 1px 떨구고 눈을 숯불 줄로 낮춘 채 숨만 쉼).
 - K2 받침: 0 나무, 1 흰 대리석, 2 검은 아크릴에 금 테(기본), 3 가장자리가 빛나는 아크릴.
-- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈과 림이 푸르게 서고 윤곽에서 아크가 튐), 1/2 과열(건메탈이 붉게 달아 들숨마다 한 단 더 달고 증기가 짙음), 3/4 끔.
+- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈과 림, 눈과 칼 홈이 푸르게 서고 가끔 한 단 더 치솟음, 윤곽에서 갈래 진 아크가 튐), 1/2 과열(건메탈이 장갑보다 밝게 주황으로 달아 들숨마다 더 달고 증기가 두 배), 3/4 끔.
 - K4 에디션: 0 뼈색 기본 칠, 1/4 2P 검정과 청록, 1/2 금과 크롬 한정판, 3/4 무도색 원형.
 - 버튼: K1 탭 지금 칼 꽂기, K2 탭 진열장 빛 스윕, K3 탭 디테일 컷(머리와 가슴, 칼 쥔 손을 정확히 2배로) 켜고 끄기, K4 탭 칼끝 글린트.
 
diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index e57dbff7..032c6394 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -1,7 +1,7 @@
 // ===== Patternflow pattern =====
 // Title:   Ferrow
 // Family:  pixel
-// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he swings the sword off his shoulder to stand it upright at his hip, turns it over in his hand and drives its point into the stand in a flash and a spray of sparks, leans on it a while and shoulders it again.
+// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he swings the sword off his shoulder to stand it upright at his hip, turns it over in his hand and drives its point into the stand, sinking into his knees as the stand's gold ring flashes and sparks fly, leans on it a while and shoulders it again.
 // Author:  patternflow-lab
 // Date:    2026-11-01
 // SPDX-License-Identifier: CC-BY-SA-4.0
@@ -11,9 +11,9 @@
 // @matrix 64x128
 // @knobs Motion=0..1, Stand=0..3, Effect=0..1, Edition=0..1
 //
-// Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his eyes down to an ember line, and only breathes.
+// Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his head down a pixel and his eyes down to an ember line, and only breathes.
 // Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.
-// Knob 3: Effect. What comes off him: steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that turns his gunmetal and rim live blue with arcs crawling off his outline; from 0.5 an overheat, the gunmetal glowing red and hotter on each in-breath, with heavy steam; from 0.75 none.
+// Knob 3: Effect. What comes off him: puffs of steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that turns his gunmetal, rim, eyes and fuller a live blue that surges brighter now and then, with arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange, brighter than the enamel and hotter on each in-breath, with twice the steam; from 0.75 none.
 // Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.
 // Buttons: K1 tap makes him plant the sword now; K2 tap sends the case light along him; K3 tap toggles the detail cut, his head, chest and sword hand at exactly twice the size; K4 tap makes the sword's point wink.
 

From 1b6a1c4e15baaf5b5e3aa02d80789b141c25730e Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:57:15 +0000
Subject: [PATCH 10/19] =?UTF-8?q?Ferrow=20=EA=B0=80=20=EC=B9=BC=EC=9D=84?=
 =?UTF-8?q?=20=ED=9C=98=EB=91=90=EB=A5=B4=EA=B8=B0=20=EC=A0=84=EC=97=90=20?=
 =?UTF-8?q?=ED=95=9C=20=EB=B0=95=20=EB=93=A4=EC=96=B4=20=EC=98=AC=EB=A6=B0?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

한 프레임에 칼이 옮겨 간다는 심사 둘의 지적에 예비 동작과 굵은 자국을 넣는다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 264 +++++++++++-----------
 1 file changed, 134 insertions(+), 130 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 032c6394..f70ee28c 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -683,123 +683,122 @@ const PARTS = {
     "...zhg...",
   ] },
   smear_up: { x: 9, y: 0, rows: [
-    "......ooommmmmmmmmmmmmmmmmmmmmmmmmmooooo........",
-    ".....mmmmmmmmmmmoooooooooooommmmmmmmmmmooo......",
-    "..mmmommmoooooooo...........ooooooommmmmmmmm....",
-    "mmoooooooo.........................oooommoommm..",
-    "oo.....................................ooo.ooomm",
-    "..............................................oo",
+    ".....nnnnmmmmmmmnnnnnnnnnnnnmmmmmmmnnnno........",
+    "...nnmmmmnnnnnnnoooooooooooonnnnnnnmmmmnnnnn....",
+    "..mmmnnnnoooooooo...........ooooooonnnnmmmmnn...",
+    "mm.nnn.ooo.........................oooonnnnmmm..",
+    ".......................................o...nn.mm",
   ] },
   smear_flip: { x: 54, y: 6, rows: [
-    "oo........",
-    "oo........",
-    "ooo.......",
-    ".oo.......",
-    ".oo.......",
-    ".oo.......",
-    ".oo.......",
-    ".oo.......",
-    "..oo......",
-    ".ommo.....",
-    ".ommo.....",
-    ".ommo.....",
-    ".ommo.....",
-    "..ommo....",
-    "..ommo....",
-    "..ommo....",
-    "..ommo....",
-    "..ommo....",
-    "..oommo...",
-    "...ommo...",
-    "...ommo...",
-    "...ommo...",
-    "...ommo...",
-    "...ommo...",
-    "...oommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    "......ommo",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    ".....ommo.",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "....ommo..",
-    "...ommoo..",
-    "...ommo...",
-    "...ommo...",
-    "...ommo...",
-    "...ommo...",
-    "...ommo...",
-    "..ommoo...",
-    "..ommo....",
-    "..ommo....",
-    "..ommo....",
-    "..ommo....",
-    "..ommo....",
-    ".ommo.....",
-    ".ommo.....",
-    ".ommo.....",
-    ".ommo.....",
-    "..oo......",
-    ".oo.......",
-    ".oo.......",
-    ".oo.......",
-    ".oo.......",
-    ".oo.......",
-    "ooo.......",
-    "oo........",
-    "oo........",
+    "m.........",
+    "m.........",
+    "mm........",
+    ".m........",
+    ".m........",
+    ".m........",
+    "nmn.......",
+    "nmn.......",
+    ".nmn......",
+    ".nmn......",
+    ".nmn......",
+    ".nmn......",
+    ".nmn......",
+    ".onmno....",
+    ".onmno....",
+    ".onmno....",
+    ".onmno....",
+    ".onmno....",
+    ".oonmno...",
+    "..onmno...",
+    "..onmno...",
+    "..onmno...",
+    "..onmno...",
+    "..onmno...",
+    "..oonmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    ".....onmno",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "....onmno.",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "...onmno..",
+    "..onmnoo..",
+    "..onmno...",
+    "..onmno...",
+    "..onmno...",
+    "..onmno...",
+    "..onmno...",
+    ".onmnoo...",
+    ".onmno....",
+    ".onmno....",
+    ".onmno....",
+    ".onmno....",
+    ".onmno....",
+    ".nmn......",
+    ".nmn......",
+    ".nmn......",
+    ".nmn......",
+    ".nmn......",
+    "nmn.......",
+    "nmn.......",
+    ".m........",
+    ".m........",
+    ".m........",
+    "mm........",
+    "m.........",
+    "m.........",
   ] },
 };
 // The three poses: the sword on the shoulder, held upright, and planted.
@@ -808,7 +807,7 @@ const ORDER_M = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard",
 const ORDER_B = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_b", "paulnear", "armnear", "head", "headrim", "blade_b", "hilt_b", "fist_b"];
 // Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.
 const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2, "smear_up": 1, "smear_flip": 1};
-const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xd6dde6, T: 0xa8bad4, Y: 0x6a7aa6 };
+const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xe6e2de, T: 0xa7978f, Y: 0x6f6684, E: 0xff9b30, F: 0xffd884, W: 0xfffaf0 };
 // Knob 4: the editions, each a hand-picked repaint of some materials.
 const EDITIONS = [
   {  },
@@ -829,21 +828,22 @@ const STANDS = [
 // than the enamel, and hotter again on each in-breath.
 // Z is the arcs, a shade apart from the charged rim.
 const CHARGE = [
-  { g: 0x58b0f0, h: 0x3a70d0, i: 0x2c44a0, j: 0x24286e, I: 0x3a5cc0, z: 0xd8f4ff, O: 0x5a90d8, Z: 0x6fd0ff, u: 0x40c8ff, f: 0xa8ecff, v: 0x3a78e0 },
-  { g: 0xb8eaff, h: 0x70b8ff, i: 0x4070e0, j: 0x30349a, I: 0x5a88f0, z: 0xf0fcff, O: 0x80b8f8, Z: 0xa8e8ff, u: 0x80e0ff, f: 0xd8f8ff, v: 0x4a90f0 },
+  { g: 0x86d4ff, h: 0x4a90f0, i: 0x3058c0, j: 0x283090, I: 0x3a64d0, z: 0xd8f4ff, O: 0x5a90d8, Z: 0x6fd0ff, u: 0x40c8ff, f: 0xa8ecff, v: 0x3a78e0, E: 0x40c8ff, F: 0xa8ecff },
+  { g: 0xd0f4ff, h: 0x90d0ff, i: 0x5088f0, j: 0x3840b0, I: 0x6a98f8, z: 0xf0fcff, O: 0x80b8f8, Z: 0xa8e8ff, u: 0x80e0ff, f: 0xd8f8ff, v: 0x4a90f0, E: 0x80e0ff, F: 0xd8f8ff },
 ];
 const HEAT = [
-  { g: 0xffe08a, h: 0xffa040, i: 0xd8602c, j: 0x8a3038, I: 0xc05a40 },
-  { g: 0xfff0b0, h: 0xffc060, i: 0xf07a34, j: 0xa83a3a, I: 0xd8703c },
+  { g: 0xffe08a, h: 0xffa040, i: 0xd8602c, j: 0x8a3038, I: 0xc05a40, E: 0xfff0c0, F: 0xfffaf0 },
+  { g: 0xfff0b0, h: 0xffc060, i: 0xf07a34, j: 0xa83a3a, I: 0xd8703c, E: 0xfff0c0, F: 0xfffaf0 },
 ];
 // The case light: what a glossy character turns into while the band passes.
 const UP = {"n": "m", "o": "n", "O": "n", "h": "g", "i": "h", "I": "h", "j": "i"};
 // The eyes, x, y and colour, painted over the visor each frame so they can
-// look aside, half shut, shut to an ember line, or flare.
-const EYES = [[33, 23, "u"], [34, 23, "u"], [35, 23, "w"], [43, 23, "u"], [44, 23, "w"],
-  [33, 24, "u"], [34, 24, "f"], [35, 24, "f"], [36, 24, "f"], [37, 24, "u"], [41, 24, "u"], [42, 24, "f"], [43, 24, "f"], [44, 24, "u"],
-  [34, 25, "u"], [35, 25, "f"], [36, 25, "u"], [37, 25, "u"], [41, 25, "u"], [42, 25, "u"], [43, 25, "u"]];
-const FLARE = { u: "f", f: "w", w: "w" };
+// look aside, half shut, shut to an ember line, or flare. E F W are their own
+// letters, so each effect can repaint them apart from the fuller.
+const EYES = [[33, 23, "E"], [34, 23, "E"], [35, 23, "W"], [43, 23, "E"], [44, 23, "W"],
+  [33, 24, "E"], [34, 24, "F"], [35, 24, "F"], [36, 24, "F"], [37, 24, "E"], [41, 24, "E"], [42, 24, "F"], [43, 24, "F"], [44, 24, "E"],
+  [34, 25, "E"], [35, 25, "F"], [36, 25, "E"], [37, 25, "E"], [41, 25, "E"], [42, 25, "E"], [43, 25, "E"]];
+const FLARE = { E: "F", F: "W", W: "W" };
 // The wink on the sword's point: x, y and what the LED turns into.
 const GLINT = [[10, 5, "w"], [9, 4, "w"], [11, 5, "w"]];
 // Where the planted point bites the stand, and the glow it throws on the rim.
@@ -881,7 +881,7 @@ const BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];
 const SWEEPS = [4.3, 11.1, 17.9, 24.7];
 const GLINTS = [3.0, 12.6, 15.8, 25.0];
 const PLANTS = [7.0, 20.6];
-const PLANTS_KEEN = [1.5, 8.3, 15.1, 21.9];
+const PLANTS_KEEN = [1.25, 8.05, 14.85, 21.65];
 const SCANS = [[4.8, -2, 1.1], [10.95, 2, 0.9], [15.2, -2, 1.1], [18.4, 2, 1.0], [24.4, -2, 1.2]];
 const SWEEP_LEN = 2.4;
 const GLINT_LEN = 0.17;
@@ -889,7 +889,10 @@ const GLINT_LEN = 0.17;
 // point first at LIFT, is leant on until DOWN, and goes back up the same way.
 // Each knob 1 stop has a pose it rests in between: shouldered, shouldered,
 // held upright on guard, and planted on standby.
-const LIFT = 6 / 15, DOWN = 51 / 15, PLANT_LEN = 55 / 15;
+// Before each swing he winds up for two steps: the shouldered sword lifts off
+// the shoulder, and the upright one rises before it is turned and driven down.
+const LIFT = 10 / 15, DOWN = 55 / 15, PLANT_LEN = 61 / 15;
+const WIND = { blade: 1, hilt: 1, fistfar: 1, armfar: 1, blade_m: 1, hilt_m: 1, fist_m: 1, armfar_m: 1 };
 const REST = [0, 0, 1, 2];
 // The swing drawn behind the figure as the pose changes, by from * 3 + to: an
 // arc over the head between shoulder and upright, and a crescent down the right
@@ -1111,7 +1114,7 @@ export function draw(display, params) {
   // two steps after it changes.
   const poseAt = (q) => {
     const e = plantSince(p, q, motion);
-    return e < 0 ? REST[motion] : e < LIFT || e >= DOWN ? 1 : 2;
+    return e < 0 ? REST[motion] : e < 2 / 15 ? REST[motion] === 2 ? 2 : 0 : e < LIFT || e >= DOWN ? 1 : 2;
   };
   const d = plantSince(p, t, motion);
   const pose = poseAt(t), was = poseAt((tick - 2) / 15);
@@ -1120,7 +1123,8 @@ export function draw(display, params) {
   // He sinks into his knees a pixel as he swings, and two as the point bites;
   // only the legs, the stand and the planted sword stay. On standby the head
   // hangs a pixel.
-  const sink = d >= 0 && d < 2 / 15 ? 1 : sd >= 0 && sd < 2 / 15 ? 2 : sd >= 0 && sd < 4 / 15 ? 1 : 0;
+  const sink = d >= 0 && d < 4 / 15 ? 1 : sd >= 0 && sd < 2 / 15 ? 2 : sd >= 0 && sd < 4 / 15 ? 1 : 0;
+  const wind = (d >= 0 && d < 2 / 15) || (d >= LIFT - 2 / 15 && d < LIFT) ? -3 : 0;
   dy[1] += sink;
   dy[3] += sink;
   dy[2] += sink + (motion === 3 && d < 0 ? 1 : 0);
@@ -1135,7 +1139,7 @@ export function draw(display, params) {
   if (smear) blit(buf, PARTS[smear], 0, dy[1], false, 0);
   for (let n = 0; n < order.length; n++) {
     const name = order[n], g = GROUP[name];
-    blit(buf, PARTS[name], dx[g], dy[g] + (g === 0 && !FIRM[name] ? sink : 0), sweep && g !== 0, band);
+    blit(buf, PARTS[name], dx[g] + (WIND[name] && wind ? 1 : 0), dy[g] + (g === 0 && !FIRM[name] ? sink : 0) + (WIND[name] ? wind : 0), sweep && g !== 0, band);
   }
 
   // The eyes: clear the visor behind them, then paint them where they look.

From 899fb1b74aa768ba57d7debc33e8bd7a1688697a Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 10:58:16 +0000
Subject: [PATCH 11/19] =?UTF-8?q?Ferrow=20=EC=B9=B4=EB=93=9C=EC=99=80=20?=
 =?UTF-8?q?=EB=A8=B8=EB=A6=AC=EA=B8=80=EC=97=90=20=EC=98=88=EB=B9=84=20?=
 =?UTF-8?q?=EB=8F=99=EC=9E=91=EA=B3=BC=20=EC=9D=B4=ED=8E=99=ED=8A=B8=20?=
 =?UTF-8?q?=EB=88=88=EC=9D=84=20=EC=A0=81=EB=8A=94=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/craft/01-figure/brief.md | 6 +++---
 incoming/pattern-study/patterns/ferrow.js       | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/incoming/pattern-study/craft/01-figure/brief.md b/incoming/pattern-study/craft/01-figure/brief.md
index 74e2927f..be7a3da9 100644
--- a/incoming/pattern-study/craft/01-figure/brief.md
+++ b/incoming/pattern-study/craft/01-figure/brief.md
@@ -14,8 +14,8 @@ slug: ferrow
 - 재질: 반광 에나멜 장갑(뼈색), 광택 금속(건메탈 뼈대와 대검 날), 무광 천(허리에 늘어뜨린 자줏빛 휘장).
 - 광원: 키 라이트는 오른쪽 위에서 오는 따뜻한 빛이에요. 림은 왼쪽 가장자리의 차가운 하늘색 1px 이고, 그 옆 두 칸에 그늘 쪽 반사가 들어요.
 - 비례: 3.4등신. 키 111줄(볏 꼭대기에서 발바닥까지)에 머리 33줄이에요.
-- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 들숨과 날숨이 끝날 때마다 등 배기통 둘에서 증기 덩이가 하나씩 올라요.
-- 큰 동작: 27.2초에 두 번, 대검을 머리 위로 휘둘러 허리춤에서 똑바로 세워 들었다가, 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 무릎으로 2px 내려앉고 눈이 하얗게 타요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러지고, 받침의 금 테가 하얗게 번쩍였다가 호박색으로 식어요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길과 돌린 길에는 두 걸음 동안 자국이 남아요. 칼은 세 자세 다 같은 49줄짜리예요.
+- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 들숨과 날숨이 끝날 때마다 등 배기통 둘에서 회백색 증기 덩이가 하나씩 올라요.
+- 큰 동작: 27.2초에 두 번, 몸을 1px 낮추며 대검을 어깨에서 들어 올렸다가 머리 위로 휘둘러 허리춤에서 똑바로 세워 들어요. 한 번 더 치켜든 뒤 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 2px 내려앉고 눈이 하얗게 타요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러지고, 받침의 금 테가 하얗게 번쩍였다가 호박색으로 식어요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길과 돌린 길에는 두 걸음 동안 굵은 자국이 남아요. 칼은 세 자세 다 같은 49줄짜리예요. 모든 움직임은 초당 15걸음이에요.
 - 강조색: 달군 쇠의 호박색. 대검의 홈과 두 눈에만 칠해요.
 - 이름판: 없어요. 받침 옆띠가 5줄이라 7줄이 안 돼요.
 
@@ -23,7 +23,7 @@ slug: ferrow
 
 - K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번, 2초가 칼이 꽂히는 순간), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 고개를 1px 떨구고 눈을 숯불 줄로 낮춘 채 숨만 쉼).
 - K2 받침: 0 나무, 1 흰 대리석, 2 검은 아크릴에 금 테(기본), 3 가장자리가 빛나는 아크릴.
-- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈과 림, 눈과 칼 홈이 푸르게 서고 가끔 한 단 더 치솟음, 윤곽에서 갈래 진 아크가 튐), 1/2 과열(건메탈이 장갑보다 밝게 주황으로 달아 들숨마다 더 달고 증기가 두 배), 3/4 끔.
+- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈이 장갑보다 밝게 푸르게 서고 림과 눈, 칼 홈도 푸름, 가끔 한 단 더 치솟고 윤곽에서 갈래 진 아크가 튐), 1/2 과열(건메탈이 주황으로 달아 들숨마다 더 달고 눈은 하얗게 타고 증기가 두 배), 3/4 끔.
 - K4 에디션: 0 뼈색 기본 칠, 1/4 2P 검정과 청록, 1/2 금과 크롬 한정판, 3/4 무도색 원형.
 - 버튼: K1 탭 지금 칼 꽂기, K2 탭 진열장 빛 스윕, K3 탭 디테일 컷(머리와 가슴, 칼 쥔 손을 정확히 2배로) 켜고 끄기, K4 탭 칼끝 글린트.
 
diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index f70ee28c..0da6b9c5 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -1,7 +1,7 @@
 // ===== Patternflow pattern =====
 // Title:   Ferrow
 // Family:  pixel
-// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he swings the sword off his shoulder to stand it upright at his hip, turns it over in his hand and drives its point into the stand, sinking into his knees as the stand's gold ring flashes and sparks fly, leans on it a while and shoulders it again.
+// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he lifts the sword off his shoulder and swings it over his head to stand it upright at his hip, raises it once more, turns it over in his hand and drives its point into the stand, sinking into his knees as the stand's gold ring flashes and sparks fly, leans on it a while and shoulders it again.
 // Author:  patternflow-lab
 // Date:    2026-11-01
 // SPDX-License-Identifier: CC-BY-SA-4.0
@@ -13,7 +13,7 @@
 //
 // Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his head down a pixel and his eyes down to an ember line, and only breathes.
 // Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.
-// Knob 3: Effect. What comes off him: puffs of steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that turns his gunmetal, rim, eyes and fuller a live blue that surges brighter now and then, with arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange, brighter than the enamel and hotter on each in-breath, with twice the steam; from 0.75 none.
+// Knob 3: Effect. What comes off him: grey puffs of steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that lights his gunmetal brighter than the enamel in a live blue, with his rim, eyes and fuller, surging brighter now and then, and arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange, hotter on each in-breath, his eyes burning white and twice the steam; from 0.75 none.
 // Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.
 // Buttons: K1 tap makes him plant the sword now; K2 tap sends the case light along him; K3 tap toggles the detail cut, his head, chest and sword hand at exactly twice the size; K4 tap makes the sword's point wink.
 

From 121afdc78b59fa213acd5b0ef838b8d7d4aa9381 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:02:06 +0000
Subject: [PATCH 12/19] =?UTF-8?q?Ferrow=20=EA=B0=80=20=EC=B9=BC=EC=9D=84?=
 =?UTF-8?q?=20=EA=BD=82=EB=8A=94=20=EC=88=9C=EA=B0=84=EC=9D=B4=20=ED=8C=A8?=
 =?UTF-8?q?=EB=84=90=20=EC=A0=84=EC=B2=B4=EB=A1=9C=20=ED=8D=BC=EC=A7=80?=
 =?UTF-8?q?=EA=B2=8C=20=ED=95=9C=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

꽂히는 순간이 모서리의 반짝임으로 지나간다는 지적에 빛 고리와 윤곽 번쩍임을 넣고 6.8초마다 꽂는다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 32 ++++++++++++++++-------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 0da6b9c5..0a5ddc41 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -1,7 +1,7 @@
 // ===== Patternflow pattern =====
 // Title:   Ferrow
 // Family:  pixel
-// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and twice a loop he lifts the sword off his shoulder and swings it over his head to stand it upright at his hip, raises it once more, turns it over in his hand and drives its point into the stand, sinking into his knees as the stand's gold ring flashes and sparks fly, leans on it a while and shoulders it again.
+// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and every 6.8 s he lifts the sword off his shoulder and swings it over his head to stand it upright at his hip, raises it once more, turns it over in his hand and drives its point into the stand, sinking into his knees as his outline and the stand's gold ring flash, a ring of light runs out across the dark and sparks fly, leans on it a while and shoulders it again.
 // Author:  patternflow-lab
 // Date:    2026-11-01
 // SPDX-License-Identifier: CC-BY-SA-4.0
@@ -11,7 +11,7 @@
 // @matrix 64x128
 // @knobs Motion=0..1, Stand=0..3, Effect=0..1, Edition=0..1
 //
-// Knob 1: Motion. How he moves: below 0.25 he plants the sword twice a loop; from 0.25 he is restless and plants it four times; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his head down a pixel and his eyes down to an ember line, and only breathes.
+// Knob 1: Motion. How he moves: below 0.25 he plants the sword every 6.8 s; from 0.25 he is restless and plants it every 3.4 s; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his head down a pixel and his eyes down to an ember line, and only breathes.
 // Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.
 // Knob 3: Effect. What comes off him: grey puffs of steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that lights his gunmetal brighter than the enamel in a live blue, with his rim, eyes and fuller, surging brighter now and then, and arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange, hotter on each in-breath, his eyes burning white and twice the steam; from 0.75 none.
 // Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.
@@ -860,7 +860,7 @@ const FLASH = [[56, 111, "f"], [56, 112, "w"], [56, 113, "w"], [56, 114, "w"], [
 // dim, its own letters so a repaint of the steel never reaches it.
 const STACKS = [[16, 27, 0], [10, 30, 0.2]];
 const PUFF = [
-  [".S.", "SSS", ".S."],
+  ["SS", "SS"],
   [".SSS.", "SSSSS", "SSSST", ".STT."],
   [".SSSS.", "SSSSST", "SSSSTT", "TSSTTT", ".TTT.."],
   ["..TTT..", ".TTTTTY", "TTTTTYY", "TTTYYY.", ".YYY..."],
@@ -873,16 +873,16 @@ const { floor, min, max, abs, cos, sin, PI } = Math;
 // the breath at the same phase. Blinks come 2 to 3.3 s apart and never while
 // the head is moving; the case light every 6.8 s, taking 2.4 s to cross, at a
 // phase where no breath step meets its edge; the glint on the point every 3 or
-// more, always while the sword is on the shoulder. The sword comes down twice
-// a loop and the eyes glance aside between. None falls between 1.5 and 2.5 s,
+// more, always while the sword is on the shoulder. The sword comes down every
+// 6.8 s and the eyes glance aside between. None falls between 1.5 and 2.5 s,
 // where the still is taken.
 const CYCLE = 27.2;
 const BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];
 const SWEEPS = [4.3, 11.1, 17.9, 24.7];
-const GLINTS = [3.0, 12.6, 15.8, 25.0];
-const PLANTS = [7.0, 20.6];
-const PLANTS_KEEN = [1.25, 8.05, 14.85, 21.65];
-const SCANS = [[4.8, -2, 1.1], [10.95, 2, 0.9], [15.2, -2, 1.1], [18.4, 2, 1.0], [24.4, -2, 1.2]];
+const GLINTS = [3.0, 8.0, 15.8, 22.0];
+const PLANTS = [3.4, 10.2, 17.0, 23.8];
+const PLANTS_KEEN = [1.25, 4.65, 8.05, 11.45, 14.85, 18.25, 21.65, 25.05];
+const SCANS = [[7.2, -2, 1.1], [8.8, 2, 0.8], [14.0, 2, 1.0], [15.4, -2, 1.0], [21.0, -2, 1.1], [22.6, 2, 0.8]];
 const SWEEP_LEN = 2.4;
 const GLINT_LEN = 0.17;
 // The big move: the sword comes off the shoulder upright, bites the stand
@@ -891,7 +891,7 @@ const GLINT_LEN = 0.17;
 // held upright on guard, and planted on standby.
 // Before each swing he winds up for two steps: the shouldered sword lifts off
 // the shoulder, and the upright one rises before it is turned and driven down.
-const LIFT = 10 / 15, DOWN = 55 / 15, PLANT_LEN = 61 / 15;
+const LIFT = 10 / 15, DOWN = 40 / 15, PLANT_LEN = 46 / 15;
 const WIND = { blade: 1, hilt: 1, fistfar: 1, armfar: 1, blade_m: 1, hilt_m: 1, fist_m: 1, armfar_m: 1 };
 const REST = [0, 0, 1, 2];
 // The swing drawn behind the figure as the pose changes, by from * 3 + to: an
@@ -1187,6 +1187,18 @@ export function draw(display, params) {
   if (fx !== 3 && sd >= 0 && sd < 0.9) {
     const t0 = t - sd;
     sparks(buf, t0, t, floor(t0 * 10 + 0.5));
+    // A ring of light runs out across the dark from the point, and his whole
+    // rim flashes white with it.
+    const k = floor(sd * 15 + 0.5);
+    if (k < 6) {
+      const r = 6 + 11 * k, ch = k < 2 ? "w" : k < 4 ? "f" : "u";
+      for (let a = 0; a <= 180; a++) {
+        const q = PI + (a / 180) * PI;
+        under(buf, floor(BITE_X + cos(q) * r + 0.5), floor(BITE_Y + 1 + sin(q) * r + 0.5), ch);
+        if (k < 2) under(buf, floor(BITE_X + cos(q) * (r + 1) + 0.5), floor(BITE_Y + 1 + sin(q) * (r + 1) + 0.5), ch);
+      }
+    }
+    if (k < 2) for (let i = 0; i < W * 104; i++) if (buf[i] === 122) buf[i] = 119;
     // The stand's gold ring answers the bite: white, then amber.
     if (sd < 4 / 15) {
       const ring = sd < 2 / 15 ? 119 : 102;

From b1a4d66c591a850ad0adf24cbc928bde503b1b1f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:03:56 +0000
Subject: [PATCH 13/19] =?UTF-8?q?=EB=8F=8C=EB=A6=B0=20=EC=9E=90=EA=B5=AD?=
 =?UTF-8?q?=EC=9D=84=20=EC=B9=BC=EB=82=A0=EB=B3=B4=EB=8B=A4=20=EC=96=B4?=
 =?UTF-8?q?=EB=91=A1=EA=B2=8C,=20=EC=A6=9D=EA=B8=B0=EB=A5=BC=20=ED=9A=8C?=
 =?UTF-8?q?=EC=83=89=EC=9C=BC=EB=A1=9C=EB=A7=8C=20=EC=8B=9D=ED=9E=8C?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

초승달이 휜 칼로, 식은 증기가 보랏빛 얼룩으로 읽힌다는 지적이다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 240 +++++++++++-----------
 1 file changed, 120 insertions(+), 120 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 0a5ddc41..01f3712f 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -22,7 +22,7 @@ const W = 64, H = 128;
 // in ORDER. Materials run light to dark: enamel a b c d, gunmetal g h i j,
 // tabard p q r s, blade steel m n o. C I R O are the shadow-side bounce next to
 // the rim light z. f u v are the hot amber of the fuller and the eyes, x the
-// dark of the visor, w the specular. U V X N are the stand, S T Y the steam.
+// dark of the visor, w the specular. U V X N are the stand, S T the steam.
 const PARTS = {
   base: { x: 6, y: 111, rows: [
     ".............NNNNNNNNNNNNNNNNNNNNNNNNNN.............",
@@ -689,116 +689,116 @@ const PARTS = {
     "mm.nnn.ooo.........................oooonnnnmmm..",
     ".......................................o...nn.mm",
   ] },
-  smear_flip: { x: 54, y: 6, rows: [
-    "m.........",
-    "m.........",
-    "mm........",
-    ".m........",
-    ".m........",
-    ".m........",
-    "nmn.......",
-    "nmn.......",
-    ".nmn......",
-    ".nmn......",
-    ".nmn......",
-    ".nmn......",
-    ".nmn......",
-    ".onmno....",
-    ".onmno....",
-    ".onmno....",
-    ".onmno....",
-    ".onmno....",
-    ".oonmno...",
-    "..onmno...",
-    "..onmno...",
-    "..onmno...",
-    "..onmno...",
-    "..onmno...",
-    "..oonmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    ".....onmno",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "....onmno.",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "...onmno..",
-    "..onmnoo..",
-    "..onmno...",
-    "..onmno...",
-    "..onmno...",
-    "..onmno...",
-    "..onmno...",
-    ".onmnoo...",
-    ".onmno....",
-    ".onmno....",
-    ".onmno....",
-    ".onmno....",
-    ".onmno....",
-    ".nmn......",
-    ".nmn......",
-    ".nmn......",
-    ".nmn......",
-    ".nmn......",
-    "nmn.......",
-    "nmn.......",
-    ".m........",
-    ".m........",
-    ".m........",
-    "mm........",
-    "m.........",
-    "m.........",
+  smear_flip: { x: 53, y: 6, rows: [
+    "o..........",
+    "o..........",
+    "oo.........",
+    ".o.........",
+    ".o.........",
+    ".o.........",
+    "hhoh.......",
+    ".hoh.......",
+    ".hoh.......",
+    ".hoh.......",
+    ".hoh.......",
+    "..hoh......",
+    "..hoh......",
+    ".ihohi.....",
+    ".ihohi.....",
+    ".ihohi.....",
+    ".iihohi....",
+    "..ihohi....",
+    "..ihohi....",
+    "..ihohi....",
+    "..ihohi....",
+    "...ihohi...",
+    "...ihohi...",
+    "...ihohi...",
+    "...ihohi...",
+    "...ihohi...",
+    "...iihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....iihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    "......ihohi",
+    ".....ihohii",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    ".....ihohi.",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "....ihohi..",
+    "...ihohii..",
+    "...ihohi...",
+    "...ihohi...",
+    "...ihohi...",
+    "...ihohi...",
+    "...ihohi...",
+    "..ihohi....",
+    "..ihohi....",
+    "..ihohi....",
+    "..ihohi....",
+    ".ihohii....",
+    ".ihohi.....",
+    ".ihohi.....",
+    ".ihohi.....",
+    "..hoh......",
+    "..hoh......",
+    ".hoh.......",
+    ".hoh.......",
+    ".hoh.......",
+    ".hoh.......",
+    "hohh.......",
+    ".o.........",
+    ".o.........",
+    ".o.........",
+    "oo.........",
+    "o..........",
+    "o..........",
   ] },
 };
 // The three poses: the sword on the shoulder, held upright, and planted.
@@ -807,7 +807,7 @@ const ORDER_M = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard",
 const ORDER_B = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_b", "paulnear", "armnear", "head", "headrim", "blade_b", "hilt_b", "fist_b"];
 // Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.
 const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2, "smear_up": 1, "smear_flip": 1};
-const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xe6e2de, T: 0xa7978f, Y: 0x6f6684, E: 0xff9b30, F: 0xffd884, W: 0xfffaf0 };
+const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xe6e2de, T: 0xa7978f, E: 0xff9b30, F: 0xffd884, W: 0xfffaf0 };
 // Knob 4: the editions, each a hand-picked repaint of some materials.
 const EDITIONS = [
   {  },
@@ -856,16 +856,16 @@ const SHOCK = [4, 9, 15, 22, 30, 38];
 // The flash at the moment of the bite, for its first two fifteenths of a second.
 const FLASH = [[56, 111, "f"], [56, 112, "w"], [56, 113, "w"], [56, 114, "w"], [53, 116, "w"], [54, 116, "w"], [55, 116, "w"], [57, 116, "w"], [58, 116, "w"], [51, 116, "f"], [52, 116, "f"], [59, 116, "f"], [60, 116, "f"], [54, 114, "f"], [58, 114, "f"], [53, 113, "u"], [59, 113, "u"], [56, 110, "u"]];
 // The two exhaust mouths and how late each puffs after the other. A
-// puff swells and thins as it rises up and away to the left: S T Y light to
-// dim, its own letters so a repaint of the steel never reaches it.
+// puff swells and thins as it drifts up and away to the left, light grey
+// cooling to warm grey: S T, its own letters so a repaint never reaches it.
 const STACKS = [[16, 27, 0], [10, 30, 0.2]];
 const PUFF = [
   ["SS", "SS"],
-  [".SSS.", "SSSSS", "SSSST", ".STT."],
-  [".SSSS.", "SSSSST", "SSSSTT", "TSSTTT", ".TTT.."],
-  ["..TTT..", ".TTTTTY", "TTTTTYY", "TTTYYY.", ".YYY..."],
-  ["..YYY.", ".YYYYY", "YYYYY.", ".YY..."],
-  [".YY.", "YYYY"],
+  [".SSS.", "SSSSS", "SSSSS", ".SSS."],
+  [".SSSS.", "SSSSST", "SSSSTT", "TSSSTT", ".TTT.."],
+  ["..TTT..", ".TTTTTT", "TTTTTT.", ".TTT..."],
+  ["..TT.", ".TTTT", "TTT.."],
+  [".TT.", "TT.."],
 ];
 
 const { floor, min, max, abs, cos, sin, PI } = Math;
@@ -989,7 +989,7 @@ function steam(buf, t, heavy) {
       const age = t - (at + floor((t - at) / BREATH) * BREATH);
       if (age < 0 || age >= life) continue;
       const shape = PUFF[min(5, floor(age / life * 6))];
-      const cx = floor(x0 - age * (heavy ? 5 : 4) + 0.5), cy = floor(y0 - 1 - age * 7 + 0.5);
+      const cx = floor(x0 - age * (heavy ? 7 : 6) + 0.5), cy = floor(y0 - 1 - age * 5 + 0.5);
       const x1 = cx - (shape[0].length >> 1), y1 = cy - shape.length + 1;
       for (let j = 0; j < shape.length; j++) {
         for (let i = 0; i < shape[j].length; i++) if (shape[j][i] !== ".") under(buf, x1 + i, y1 + j, shape[j][i]);

From 914fba2ee17087ed3c75822112181b169b6385da Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:04:50 +0000
Subject: [PATCH 14/19] =?UTF-8?q?Ferrow=20=EC=B9=B4=EB=93=9C=EC=97=90=206.?=
 =?UTF-8?q?8=EC=B4=88=20=EB=B0=95=EC=9E=90=EC=99=80=20=EA=BD=82=EB=8A=94?=
 =?UTF-8?q?=20=EC=88=9C=EA=B0=84=EC=9D=98=20=EB=B9=9B=EC=9D=84=20=EC=A0=81?=
 =?UTF-8?q?=EB=8A=94=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/craft/01-figure/brief.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/incoming/pattern-study/craft/01-figure/brief.md b/incoming/pattern-study/craft/01-figure/brief.md
index be7a3da9..1ee007ca 100644
--- a/incoming/pattern-study/craft/01-figure/brief.md
+++ b/incoming/pattern-study/craft/01-figure/brief.md
@@ -14,16 +14,16 @@ slug: ferrow
 - 재질: 반광 에나멜 장갑(뼈색), 광택 금속(건메탈 뼈대와 대검 날), 무광 천(허리에 늘어뜨린 자줏빛 휘장).
 - 광원: 키 라이트는 오른쪽 위에서 오는 따뜻한 빛이에요. 림은 왼쪽 가장자리의 차가운 하늘색 1px 이고, 그 옆 두 칸에 그늘 쪽 반사가 들어요.
 - 비례: 3.4등신. 키 111줄(볏 꼭대기에서 발바닥까지)에 머리 33줄이에요.
-- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 들숨과 날숨이 끝날 때마다 등 배기통 둘에서 회백색 증기 덩이가 하나씩 올라요.
-- 큰 동작: 27.2초에 두 번, 몸을 1px 낮추며 대검을 어깨에서 들어 올렸다가 머리 위로 휘둘러 허리춤에서 똑바로 세워 들어요. 한 번 더 치켜든 뒤 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 2px 내려앉고 눈이 하얗게 타요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러지고, 받침의 금 테가 하얗게 번쩍였다가 호박색으로 식어요. 3초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길과 돌린 길에는 두 걸음 동안 굵은 자국이 남아요. 칼은 세 자세 다 같은 49줄짜리예요. 모든 움직임은 초당 15걸음이에요.
+- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 들숨과 날숨이 끝날 때마다 등 배기통 둘에서 증기 덩이가 하나씩 왼쪽 위로 흘러가며 연회색에서 따뜻한 회색으로 식어요.
+- 큰 동작: 6.8초에 한 번, 몸을 1px 낮추며 대검을 어깨에서 들어 올렸다가 머리 위로 휘둘러 허리춤에서 똑바로 세워 들어요. 한 번 더 치켜든 뒤 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 2px 내려앉고 눈이 하얗게 타고, 윤곽 전체와 받침의 금 테가 하얗게 번쩍여요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러지고, 빛 고리가 칼끝에서 어둠을 가로질러 퍼져요. 금 테는 호박색으로 식어요. 2초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길에는 굵은 호가, 돌린 길에는 어두운 초승달이 두 걸음 남아요. 칼은 세 자세 다 같은 49줄짜리예요. 모든 움직임은 초당 15걸음이에요.
 - 강조색: 달군 쇠의 호박색. 대검의 홈과 두 눈에만 칠해요.
 - 이름판: 없어요. 받침 옆띠가 5줄이라 7줄이 안 돼요.
 
 노브 넷과 버튼이에요.
 
-- K1 움직임: 0 기본(큰 동작 두 번), 1/4 활발(네 번, 2초가 칼이 꽂히는 순간), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 고개를 1px 떨구고 눈을 숯불 줄로 낮춘 채 숨만 쉼).
+- K1 움직임: 0 기본(6.8초마다 꽂기), 1/4 활발(3.4초마다, 2초가 칼이 꽂히는 순간), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 고개를 1px 떨구고 눈을 숯불 줄로 낮춘 채 숨만 쉼).
 - K2 받침: 0 나무, 1 흰 대리석, 2 검은 아크릴에 금 테(기본), 3 가장자리가 빛나는 아크릴.
-- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈이 장갑보다 밝게 푸르게 서고 림과 눈, 칼 홈도 푸름, 가끔 한 단 더 치솟고 윤곽에서 갈래 진 아크가 튐), 1/2 과열(건메탈이 주황으로 달아 들숨마다 더 달고 눈은 하얗게 타고 증기가 두 배), 3/4 끔.
+- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈이 밝은 파랑으로 서고 림과 눈, 칼 홈도 푸름, 가끔 한 단 더 치솟고 윤곽에서 갈래 진 아크가 튐), 1/2 과열(건메탈이 주황으로 달아 들숨마다 더 달고 눈은 하얗게 타고 증기가 두 배), 3/4 끔.
 - K4 에디션: 0 뼈색 기본 칠, 1/4 2P 검정과 청록, 1/2 금과 크롬 한정판, 3/4 무도색 원형.
 - 버튼: K1 탭 지금 칼 꽂기, K2 탭 진열장 빛 스윕, K3 탭 디테일 컷(머리와 가슴, 칼 쥔 손을 정확히 2배로) 켜고 끄기, K4 탭 칼끝 글린트.
 

From 78f48c1bfdd145b64a3351fd226ac2f28c03f95f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:10:34 +0000
Subject: [PATCH 15/19] =?UTF-8?q?Ferrow=20=EC=9D=98=20=EC=9E=A1=EC=9D=8C?=
 =?UTF-8?q?=EC=B2=98=EB=9F=BC=20=EC=9D=BD=ED=9E=88=EB=8D=98=20=EC=84=A0?=
 =?UTF-8?q?=EA=B3=BC=20=EC=A0=90=EC=9D=84=20=EA=B1=B7=EC=96=B4=20=EB=82=B8?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

휘두른 자국과 빛 고리, 늘 뜨던 작은 증기를 빼고, 꽂은 뒤 큰 증기 구름과 더 오래 실리는 무게를 남긴다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/patterns/ferrow.js | 213 +++++-----------------
 1 file changed, 43 insertions(+), 170 deletions(-)

diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index 01f3712f..a670bca1 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -682,124 +682,6 @@ const PARTS = {
     "..zIhgg..",
     "...zhg...",
   ] },
-  smear_up: { x: 9, y: 0, rows: [
-    ".....nnnnmmmmmmmnnnnnnnnnnnnmmmmmmmnnnno........",
-    "...nnmmmmnnnnnnnoooooooooooonnnnnnnmmmmnnnnn....",
-    "..mmmnnnnoooooooo...........ooooooonnnnmmmmnn...",
-    "mm.nnn.ooo.........................oooonnnnmmm..",
-    ".......................................o...nn.mm",
-  ] },
-  smear_flip: { x: 53, y: 6, rows: [
-    "o..........",
-    "o..........",
-    "oo.........",
-    ".o.........",
-    ".o.........",
-    ".o.........",
-    "hhoh.......",
-    ".hoh.......",
-    ".hoh.......",
-    ".hoh.......",
-    ".hoh.......",
-    "..hoh......",
-    "..hoh......",
-    ".ihohi.....",
-    ".ihohi.....",
-    ".ihohi.....",
-    ".iihohi....",
-    "..ihohi....",
-    "..ihohi....",
-    "..ihohi....",
-    "..ihohi....",
-    "...ihohi...",
-    "...ihohi...",
-    "...ihohi...",
-    "...ihohi...",
-    "...ihohi...",
-    "...iihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....iihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    "......ihohi",
-    ".....ihohii",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    ".....ihohi.",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "....ihohi..",
-    "...ihohii..",
-    "...ihohi...",
-    "...ihohi...",
-    "...ihohi...",
-    "...ihohi...",
-    "...ihohi...",
-    "..ihohi....",
-    "..ihohi....",
-    "..ihohi....",
-    "..ihohi....",
-    ".ihohii....",
-    ".ihohi.....",
-    ".ihohi.....",
-    ".ihohi.....",
-    "..hoh......",
-    "..hoh......",
-    ".hoh.......",
-    ".hoh.......",
-    ".hoh.......",
-    ".hoh.......",
-    "hohh.......",
-    ".o.........",
-    ".o.........",
-    ".o.........",
-    "oo.........",
-    "o..........",
-    "o..........",
-  ] },
 };
 // The three poses: the sword on the shoulder, held upright, and planted.
 const ORDER = ["base", "pack", "blade", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "neck", "paulfar", "armfar", "paulnear", "armnear", "head", "hilt", "fistfar"];
@@ -807,7 +689,7 @@ const ORDER_M = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard",
 const ORDER_B = ["base", "pack", "legfar", "legnear", "spine", "hips", "tabard", "tabtip", "torso", "torso_u", "neck", "paulfar", "paulfar_u", "chest_u", "armfar_b", "paulnear", "armnear", "head", "headrim", "blade_b", "hilt_b", "fist_b"];
 // Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.
 const GROUP = {"base": 0, "pack": 1, "blade": 1, "legfar": 0, "legnear": 0, "spine": 0, "hips": 0, "tabard": 0, "tabtip": 3, "torso": 1, "neck": 1, "paulfar": 1, "armfar": 1, "paulnear": 1, "armnear": 1, "head": 2, "hilt": 1, "fistfar": 1, "armfar_m": 1, "blade_m": 1, "hilt_m": 1, "fist_m": 1, "armfar_b": 1, "blade_b": 4, "hilt_b": 4, "fist_b": 1, "torso_u": 1, "paulfar_u": 1, "chest_u": 1, "headrim": 2, "smear_up": 1, "smear_flip": 1};
-const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xe6e2de, T: 0xa7978f, E: 0xff9b30, F: 0xffd884, W: 0xfffaf0 };
+const PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xe6e2de, E: 0xff9b30, F: 0xffd884, W: 0xfffaf0 };
 // Knob 4: the editions, each a hand-picked repaint of some materials.
 const EDITIONS = [
   {  },
@@ -832,8 +714,8 @@ const CHARGE = [
   { g: 0xd0f4ff, h: 0x90d0ff, i: 0x5088f0, j: 0x3840b0, I: 0x6a98f8, z: 0xf0fcff, O: 0x80b8f8, Z: 0xa8e8ff, u: 0x80e0ff, f: 0xd8f8ff, v: 0x4a90f0, E: 0x80e0ff, F: 0xd8f8ff },
 ];
 const HEAT = [
-  { g: 0xffe08a, h: 0xffa040, i: 0xd8602c, j: 0x8a3038, I: 0xc05a40, E: 0xfff0c0, F: 0xfffaf0 },
-  { g: 0xfff0b0, h: 0xffc060, i: 0xf07a34, j: 0xa83a3a, I: 0xd8703c, E: 0xfff0c0, F: 0xfffaf0 },
+  { g: 0xffe08a, h: 0xffa040, i: 0xd8602c, j: 0x8a3038, I: 0xc05a40, E: 0xffd060, F: 0xfffaf0 },
+  { g: 0xfff0b0, h: 0xffc060, i: 0xf07a34, j: 0xa83a3a, I: 0xd8703c, E: 0xffd060, F: 0xfffaf0 },
 ];
 // The case light: what a glossy character turns into while the band passes.
 const UP = {"n": "m", "o": "n", "O": "n", "h": "g", "i": "h", "I": "h", "j": "i"};
@@ -855,17 +737,17 @@ const SPILL = [[53, 118, "f"], [54, 118, "w"], [55, 118, "w"], [56, 118, "w"], [
 const SHOCK = [4, 9, 15, 22, 30, 38];
 // The flash at the moment of the bite, for its first two fifteenths of a second.
 const FLASH = [[56, 111, "f"], [56, 112, "w"], [56, 113, "w"], [56, 114, "w"], [53, 116, "w"], [54, 116, "w"], [55, 116, "w"], [57, 116, "w"], [58, 116, "w"], [51, 116, "f"], [52, 116, "f"], [59, 116, "f"], [60, 116, "f"], [54, 114, "f"], [58, 114, "f"], [53, 113, "u"], [59, 113, "u"], [56, 110, "u"]];
-// The two exhaust mouths and how late each puffs after the other. A
-// puff swells and thins as it drifts up and away to the left, light grey
-// cooling to warm grey: S T, its own letters so a repaint never reaches it.
+// The two exhaust mouths and how late each puffs after the other. A cloud
+// swells as it drifts up and away to the left, then shrinks away. S is its own
+// letter so no repaint reaches it.
 const STACKS = [[16, 27, 0], [10, 30, 0.2]];
 const PUFF = [
   ["SS", "SS"],
   [".SSS.", "SSSSS", "SSSSS", ".SSS."],
-  [".SSSS.", "SSSSST", "SSSSTT", "TSSSTT", ".TTT.."],
-  ["..TTT..", ".TTTTTT", "TTTTTT.", ".TTT..."],
-  ["..TT.", ".TTTT", "TTT.."],
-  [".TT.", "TT.."],
+  ["..SSS..", ".SSSSS.", "SSSSSSS", "SSSSSSS", ".SSSSS.", "..SSS.."],
+  ["..SSSS..", ".SSSSSS.", "SSSSSSSS", "SSSSSSSS", ".SSSSSS.", "..SSSS.."],
+  [".SSS.", "SSSSS", "SSSSS", ".SSS."],
+  [".SS.", "SSSS", ".SS."],
 ];
 
 const { floor, min, max, abs, cos, sin, PI } = Math;
@@ -894,10 +776,6 @@ const GLINT_LEN = 0.17;
 const LIFT = 10 / 15, DOWN = 40 / 15, PLANT_LEN = 46 / 15;
 const WIND = { blade: 1, hilt: 1, fistfar: 1, armfar: 1, blade_m: 1, hilt_m: 1, fist_m: 1, armfar_m: 1 };
 const REST = [0, 0, 1, 2];
-// The swing drawn behind the figure as the pose changes, by from * 3 + to: an
-// arc over the head between shoulder and upright, and a crescent down the right
-// side as the sword turns over in the hand.
-const SMEAR = [null, "smear_up", null, "smear_up", null, "smear_flip", null, "smear_flip", null];
 // One breath is 3.4 s: the chest rises a pixel, the head follows a quarter
 // second later, and the tabard's hem swings a pixel sideways a beat after
 // that; both ends of each move are held longer than the moves between them.
@@ -978,21 +856,27 @@ function plantSince(p, t, motion) {
   return d;
 }
 
-// A puff leaves each stack once each half of the breath has settled, and twice
-// as often on the overheat.
-function steam(buf, t, heavy) {
-  const life = heavy ? 2.0 : 1.8, phases = heavy ? [1.3, 2.15, 3.0, 0.45] : [1.3, 3.0];
+// After the bite the stacks vent four clouds each while he leans on the sword;
+// on the overheat they also puff through every breath.
+function steam(buf, t, heavy, bite) {
+  const life = 1.8;
+  const at = (x0, y0, age) => {
+    if (age < 0 || age >= life) return;
+    const shape = PUFF[min(5, floor(age / life * 6))];
+    const cx = floor(x0 - age * 6 + 0.5), cy = floor(y0 - 1 - age * 6 + 0.5);
+    const x1 = cx - (shape[0].length >> 1), y1 = cy - shape.length + 1;
+    for (let j = 0; j < shape.length; j++) {
+      for (let i = 0; i < shape[j].length; i++) if (shape[j][i] !== ".") under(buf, x1 + i, y1 + j, shape[j][i]);
+    }
+  };
   for (let s = 0; s < STACKS.length; s++) {
     const [x0, y0, lag] = STACKS[s];
-    for (let f = 0; f < phases.length; f++) {
-      const at = phases[f] + lag;
-      const age = t - (at + floor((t - at) / BREATH) * BREATH);
-      if (age < 0 || age >= life) continue;
-      const shape = PUFF[min(5, floor(age / life * 6))];
-      const cx = floor(x0 - age * (heavy ? 7 : 6) + 0.5), cy = floor(y0 - 1 - age * 5 + 0.5);
-      const x1 = cx - (shape[0].length >> 1), y1 = cy - shape.length + 1;
-      for (let j = 0; j < shape.length; j++) {
-        for (let i = 0; i < shape[j].length; i++) if (shape[j][i] !== ".") under(buf, x1 + i, y1 + j, shape[j][i]);
+    if (bite >= 0) for (let n = 0; n < 4; n++) at(x0, y0, t - (bite + 0.25 + n * 0.3 + lag * 0.6));
+    if (heavy) {
+      const phases = [1.3, 2.15, 3.0, 0.45];
+      for (let f = 0; f < phases.length; f++) {
+        const a = phases[f] + lag;
+        at(x0, y0, t - (a + floor((t - a) / BREATH) * BREATH));
       }
     }
   }
@@ -1029,8 +913,8 @@ function sparks(buf, tt0, tt, seed) {
 function arcs(buf, slot) {
   const out = [];
   const h = hash(slot * 7 + 3);
-  if ((h & 7) === 0) return out;
-  const count = 1 + ((h >>> 4) & 1) + ((h >>> 5) & 1);
+  if (h % 3 !== 0) return out;
+  const count = 1 + ((h >>> 4) & 1);
   for (let a = 0; a < count; a++) {
     const g = hash(h + a * 101);
     const y0 = 22 + (g % 88), left = (g >>> 8) & 1;
@@ -1041,7 +925,7 @@ function arcs(buf, slot) {
     // A jagged run outward, never level for two steps, with a fork off its
     // second step that kicks the other way.
     let y = y0, fx = 0, fy = 0;
-    const len = 4 + ((g >>> 10) % 5), step = left ? -1 : 1;
+    const len = 7 + ((g >>> 10) % 6), step = left ? -1 : 1;
     const put = (px, py, ch) => {
       if (py >= 0 && py < H && px >= 0 && px < W && !buf[py * W + px]) out.push([px, py, ch]);
     };
@@ -1049,11 +933,12 @@ function arcs(buf, slot) {
       x += step;
       y += (g >>> (12 + k)) & 1 ? 1 : -1;
       put(x, y, k < len ? "w" : "Z");
-      if (k === 2) { fx = x; fy = y; }
+      if (k === 3) { fx = x; fy = y; }
     }
     const kick = (g >>> 13) & 1 ? -1 : 1;
-    put(fx + step, fy + kick * 2, "Z");
+    put(fx + step, fy + kick * 2, "w");
     put(fx + step * 2, fy + kick * 3, "Z");
+    put(fx + step * 3, fy + kick * 4, "Z");
   }
   return out;
 }
@@ -1110,20 +995,18 @@ export function draw(display, params) {
   const dy = [0, u >= 1.1 && u < 2.8 ? -1 : 0, u >= 1.35 && u < 3.05 ? -1 : 0, 0, 0];
   const dx = [0, 0, 0, u >= 1.45 && u < 3.15 ? -1 : 0, 0];
 
-  // Shouldered, upright or planted, and the swing behind the figure for the
-  // two steps after it changes.
+  // Shouldered, upright or planted.
   const poseAt = (q) => {
     const e = plantSince(p, q, motion);
     return e < 0 ? REST[motion] : e < 2 / 15 ? REST[motion] === 2 ? 2 : 0 : e < LIFT || e >= DOWN ? 1 : 2;
   };
   const d = plantSince(p, t, motion);
-  const pose = poseAt(t), was = poseAt((tick - 2) / 15);
-  const smear = was !== pose ? SMEAR[was * 3 + pose] : null;
+  const pose = poseAt(t);
   const sd = d >= LIFT && d < DOWN ? d - LIFT : -1;
   // He sinks into his knees a pixel as he swings, and two as the point bites;
   // only the legs, the stand and the planted sword stay. On standby the head
   // hangs a pixel.
-  const sink = d >= 0 && d < 4 / 15 ? 1 : sd >= 0 && sd < 2 / 15 ? 2 : sd >= 0 && sd < 4 / 15 ? 1 : 0;
+  const sink = d >= 0 && d < 4 / 15 ? 1 : sd >= 0 && sd < 3 / 15 ? 2 : sd >= 0 && sd < 6 / 15 ? 1 : 0;
   const wind = (d >= 0 && d < 2 / 15) || (d >= LIFT - 2 / 15 && d < LIFT) ? -3 : 0;
   dy[1] += sink;
   dy[3] += sink;
@@ -1136,7 +1019,6 @@ export function draw(display, params) {
 
   // The case light passes over the steel above the stand; the legs and the stand keep still.
   const order = pose === 0 ? ORDER : pose === 1 ? ORDER_M : ORDER_B;
-  if (smear) blit(buf, PARTS[smear], 0, dy[1], false, 0);
   for (let n = 0; n < order.length; n++) {
     const name = order[n], g = GROUP[name];
     blit(buf, PARTS[name], dx[g] + (WIND[name] && wind ? 1 : 0), dy[g] + (g === 0 && !FIRM[name] ? sink : 0) + (WIND[name] ? wind : 0), sweep && g !== 0, band);
@@ -1175,7 +1057,7 @@ export function draw(display, params) {
     }
   }
 
-  if ((fx === 0 || fx === 2) && motion !== 3) steam(buf, t, fx === 2);
+  if (fx === 0 || fx === 2) steam(buf, t, fx === 2 && motion !== 3, sd >= 0 ? t - sd : -1);
   if (fx === 1) {
     const slot = tick >> 1;
     if (slot !== p.arcSlot) {
@@ -1187,21 +1069,12 @@ export function draw(display, params) {
   if (fx !== 3 && sd >= 0 && sd < 0.9) {
     const t0 = t - sd;
     sparks(buf, t0, t, floor(t0 * 10 + 0.5));
-    // A ring of light runs out across the dark from the point, and his whole
-    // rim flashes white with it.
+    // His whole rim flashes white as it bites.
     const k = floor(sd * 15 + 0.5);
-    if (k < 6) {
-      const r = 6 + 11 * k, ch = k < 2 ? "w" : k < 4 ? "f" : "u";
-      for (let a = 0; a <= 180; a++) {
-        const q = PI + (a / 180) * PI;
-        under(buf, floor(BITE_X + cos(q) * r + 0.5), floor(BITE_Y + 1 + sin(q) * r + 0.5), ch);
-        if (k < 2) under(buf, floor(BITE_X + cos(q) * (r + 1) + 0.5), floor(BITE_Y + 1 + sin(q) * (r + 1) + 0.5), ch);
-      }
-    }
-    if (k < 2) for (let i = 0; i < W * 104; i++) if (buf[i] === 122) buf[i] = 119;
+    if (k < 3) for (let i = 0; i < W * 104; i++) if (buf[i] === 122) buf[i] = 119;
     // The stand's gold ring answers the bite: white, then amber.
-    if (sd < 4 / 15) {
-      const ring = sd < 2 / 15 ? 119 : 102;
+    if (sd < 5 / 15) {
+      const ring = sd < 3 / 15 ? 119 : 102;
       for (let i = 104 * W; i < H * W; i++) if (buf[i] === 78) buf[i] = ring;
     }
     if (sd < 0.3) for (let i = 0; i < SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd < 0.15 ? SPILL[i][2] : "u");

From 64fa4310e731177d2520f2803f718db017211132 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:11:25 +0000
Subject: [PATCH 16/19] =?UTF-8?q?Ferrow=20=EC=B9=B4=EB=93=9C=EC=99=80=20?=
 =?UTF-8?q?=EB=A8=B8=EB=A6=AC=EA=B8=80=EC=9D=84=20=EC=97=AC=EC=84=AF?=
 =?UTF-8?q?=EC=A7=B8=20=EA=B3=A0=EC=B9=A8=EC=97=90=20=EB=A7=9E=EC=B6=98?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/craft/01-figure/brief.md | 6 +++---
 incoming/pattern-study/patterns/ferrow.js       | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/incoming/pattern-study/craft/01-figure/brief.md b/incoming/pattern-study/craft/01-figure/brief.md
index 1ee007ca..6d01a9ba 100644
--- a/incoming/pattern-study/craft/01-figure/brief.md
+++ b/incoming/pattern-study/craft/01-figure/brief.md
@@ -14,8 +14,8 @@ slug: ferrow
 - 재질: 반광 에나멜 장갑(뼈색), 광택 금속(건메탈 뼈대와 대검 날), 무광 천(허리에 늘어뜨린 자줏빛 휘장).
 - 광원: 키 라이트는 오른쪽 위에서 오는 따뜻한 빛이에요. 림은 왼쪽 가장자리의 차가운 하늘색 1px 이고, 그 옆 두 칸에 그늘 쪽 반사가 들어요.
 - 비례: 3.4등신. 키 111줄(볏 꼭대기에서 발바닥까지)에 머리 33줄이에요.
-- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요. 들숨과 날숨이 끝날 때마다 등 배기통 둘에서 증기 덩이가 하나씩 왼쪽 위로 흘러가며 연회색에서 따뜻한 회색으로 식어요.
-- 큰 동작: 6.8초에 한 번, 몸을 1px 낮추며 대검을 어깨에서 들어 올렸다가 머리 위로 휘둘러 허리춤에서 똑바로 세워 들어요. 한 번 더 치켜든 뒤 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 2px 내려앉고 눈이 하얗게 타고, 윤곽 전체와 받침의 금 테가 하얗게 번쩍여요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러지고, 빛 고리가 칼끝에서 어둠을 가로질러 퍼져요. 금 테는 호박색으로 식어요. 2초 기대어 섰다가 같은 길로 어깨에 다시 메요. 휘두른 길에는 굵은 호가, 돌린 길에는 어두운 초승달이 두 걸음 남아요. 칼은 세 자세 다 같은 49줄짜리예요. 모든 움직임은 초당 15걸음이에요.
+- 쉬는 동작: 숨(가슴과 어깨, 팔, 대검이 1px, 3.4초에 한 번, 머리는 한 박 늦게)과 휘장 끝이 한 박 더 늦게 옆으로 1px 흔들리는 것. 눈 덮개 깜빡임과, 눈이 투구 틈 안에서 2px 옆을 보는 것은 따로 돌아요.
+- 큰 동작: 6.8초에 한 번, 몸을 1px 낮추며 대검을 어깨에서 들어 올렸다가 허리춤에서 똑바로 세워 들어요. 한 번 더 치켜든 뒤 손은 그대로 두고 칼을 거꾸로 돌려 칼끝을 받침에 꽂아요. 꽂히는 순간 몸이 2px 내려앉아 0.2초 버티고 눈이 하얗게 타고, 윤곽 전체와 받침의 금 테가 하얗게 번쩍여요. 칼끝에서 번쩍임과 불꽃이 튀고 받침 위로 불티가 미끄러져요. 금 테는 호박색으로 식고, 기대어 선 2초 동안 등 배기통 둘에서 증기 구름이 넷씩 피어올라 왼쪽 위로 흘러가요. 그리고 같은 길로 어깨에 다시 메요. 칼은 세 자세 다 같은 49줄짜리예요. 모든 움직임은 초당 15걸음이에요.
 - 강조색: 달군 쇠의 호박색. 대검의 홈과 두 눈에만 칠해요.
 - 이름판: 없어요. 받침 옆띠가 5줄이라 7줄이 안 돼요.
 
@@ -23,7 +23,7 @@ slug: ferrow
 
 - K1 움직임: 0 기본(6.8초마다 꽂기), 1/4 활발(3.4초마다, 2초가 칼이 꽂히는 순간), 1/2 경계(칼을 허리춤에 세워 들고 눈을 하얗게 밝힘), 3/4 대기(꽂은 칼에 기대 고개를 1px 떨구고 눈을 숯불 줄로 낮춘 채 숨만 쉼).
 - K2 받침: 0 나무, 1 흰 대리석, 2 검은 아크릴에 금 테(기본), 3 가장자리가 빛나는 아크릴.
-- K3 이펙트: 0 증기와 불꽃, 1/4 충전(건메탈이 밝은 파랑으로 서고 림과 눈, 칼 홈도 푸름, 가끔 한 단 더 치솟고 윤곽에서 갈래 진 아크가 튐), 1/2 과열(건메탈이 주황으로 달아 들숨마다 더 달고 눈은 하얗게 타고 증기가 두 배), 3/4 끔.
+- K3 이펙트: 0 꽂은 뒤의 증기 구름과 불꽃, 1/4 충전(건메탈이 밝은 파랑으로 서고 림과 눈, 칼 홈도 푸름, 가끔 한 단 더 치솟고 윤곽에서 길게 갈래 진 아크가 튐), 1/2 과열(건메탈이 주황으로 달아 들숨마다 더 달고 눈은 노랗게 타고 숨마다 증기를 뿜음), 3/4 끔.
 - K4 에디션: 0 뼈색 기본 칠, 1/4 2P 검정과 청록, 1/2 금과 크롬 한정판, 3/4 무도색 원형.
 - 버튼: K1 탭 지금 칼 꽂기, K2 탭 진열장 빛 스윕, K3 탭 디테일 컷(머리와 가슴, 칼 쥔 손을 정확히 2배로) 켜고 끄기, K4 탭 칼끝 글린트.
 
diff --git a/incoming/pattern-study/patterns/ferrow.js b/incoming/pattern-study/patterns/ferrow.js
index a670bca1..457f3825 100644
--- a/incoming/pattern-study/patterns/ferrow.js
+++ b/incoming/pattern-study/patterns/ferrow.js
@@ -1,7 +1,7 @@
 // ===== Patternflow pattern =====
 // Title:   Ferrow
 // Family:  pixel
-// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, steam leaves his stacks, his eyes glance aside and blink, and every 6.8 s he lifts the sword off his shoulder and swings it over his head to stand it upright at his hip, raises it once more, turns it over in his hand and drives its point into the stand, sinking into his knees as his outline and the stand's gold ring flash, a ring of light runs out across the dark and sparks fly, leans on it a while and shoulders it again.
+// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, his eyes glance aside and blink, and every 6.8 s he lifts the sword off his shoulder to stand it upright at his hip, raises it once more, turns it over in his hand and drives its point into the stand, sinking into his knees as his outline and the stand's gold ring flash white and sparks fly; he leans on it while his stacks vent clouds of steam, then shoulders it again.
 // Author:  patternflow-lab
 // Date:    2026-11-01
 // SPDX-License-Identifier: CC-BY-SA-4.0
@@ -13,7 +13,7 @@
 //
 // Knob 1: Motion. How he moves: below 0.25 he plants the sword every 6.8 s; from 0.25 he is restless and plants it every 3.4 s; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his head down a pixel and his eyes down to an ember line, and only breathes.
 // Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.
-// Knob 3: Effect. What comes off him: grey puffs of steam from the stacks and sparks where the point bites below 0.25; from 0.25 a charge that lights his gunmetal brighter than the enamel in a live blue, with his rim, eyes and fuller, surging brighter now and then, and arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange, hotter on each in-breath, his eyes burning white and twice the steam; from 0.75 none.
+// Knob 3: Effect. What comes off him: steam clouds after each bite and sparks where the point goes in below 0.25; from 0.25 a charge that lights his gunmetal a live blue, with his rim, eyes and fuller, surging brighter now and then, and long arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange and hotter on each in-breath, his eyes burning yellow and steam on every breath; from 0.75 none.
 // Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.
 // Buttons: K1 tap makes him plant the sword now; K2 tap sends the case light along him; K3 tap toggles the detail cut, his head, chest and sword hand at exactly twice the size; K4 tap makes the sword's point wink.
 

From 7157485342bc7b7aa4c41a6e8ca02b772595efe1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:11:45 +0000
Subject: [PATCH 17/19] =?UTF-8?q?Ferrow=20=EC=9D=98=20=EC=9B=80=EC=A7=81?=
 =?UTF-8?q?=EC=9E=84=20GIF=20=EB=91=98=EA=B3=BC=20=EB=85=B8=EB=B8=8C=20?=
 =?UTF-8?q?=EA=B7=B8=EB=A6=BC=EC=9D=84=20=EB=A7=88=EC=A7=80=EB=A7=89=20?=
 =?UTF-8?q?=ED=8C=90=EC=9C=BC=EB=A1=9C=20=EB=B0=94=EA=BE=BC=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 .../craft/01-figure/ferrow-86b-fx.gif         | Bin 157703 -> 170538 bytes
 .../craft/01-figure/ferrow-86b.gif            | Bin 137532 -> 148396 bytes
 .../craft/01-figure/look-86b.png              | Bin 65867 -> 66939 bytes
 3 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/incoming/pattern-study/craft/01-figure/ferrow-86b-fx.gif b/incoming/pattern-study/craft/01-figure/ferrow-86b-fx.gif
index 9b417b9a131cd14eaaa0510cb9720a63c6f9e4ee..a872f46cfd54110562868d595b4a982321d9d434 100644
GIT binary patch
literal 170538
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

literal 157703
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%0D49RBm;8xoA<VzMV;WOn2-6?l
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
OjNb|`;(b8}&;J0xMs=+K

diff --git a/incoming/pattern-study/craft/01-figure/ferrow-86b.gif b/incoming/pattern-study/craft/01-figure/ferrow-86b.gif
index 7ea22860ea42c255d9ed7ea399f6d1ba0a02e222..a0b1d33264deb1168f1a48be49b04f99a957a180 100644
GIT binary patch
literal 148396
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

literal 137532
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

diff --git a/incoming/pattern-study/craft/01-figure/look-86b.png b/incoming/pattern-study/craft/01-figure/look-86b.png
index 2cc39bba4ef214763426a09f04a14329908da57c..1d8cb5a6da460b788e18cd6499fdb0b5799bdfcd 100644
GIT binary patch
literal 66939
zcmaI;2|SeT_Xm#KiYHlGs1Q+ULG{E;GiB+?)<TkXD3UUmu{?ybw;)QAQpTVt>r7%S
zt%yRHk!40hg(pi{QZZy1e&?Q{`uxBD->-SSrefy4uj{_fb<X>|&-+}_M-CfHERkCx
zARr)dV86jp0Rdqx0RgcgF(LSgV&LvO0)mV79WeOE@@)Ii2ghv1iI9;X$H$izpIb2!
zVZKqJ{`liUTz!l}Pj9aX?xSUVk$c*U`?iS|38c0C`)bFPKc*jCQl0Cx-b>D@eI>2s
zN=4b_Lvl;A#@@Sho=rYBrgB^P=YYZyeQfXEYdd<3p1eJv$!<x*v#$0{G?aHXJlCBO
z8%;>#Xpc7ZCnW`xh4lrrm2Xl}QAs~_=C=M`0|NsQ#%1^;MqUPg&TGPNRD|&GV}q`%
z$j>X*AV0^fM}F>Y^#Ad3{$=<d_Y=YgeDG`g5YWlZF$)>^`fQ|ZaMw;0Dy8mB#Hdco
z%Zs8O9S-f|b^Y}Qi=tJR;sZKECd#KBpHA~Xw35s&kziD?mv#?Xq)l0dQs-K|PPx19
zzO@BI^9VYD3F_Ze`f^P)If+E_m&NYcUv$E65k9}{`$e11pD(4t#w@&z+!-dOrcAhw
zPN<z`KaCi!DTL3=%<O6?8Q#z}6s0%iR(Er8^nH}6sVPe2UC9d!M(rC;;(>%CWpT8Y
z$Q=^t@LlD-%w;*)!Ta{Ur*)^Fl~3jogM&W_doN}fz_kq-fzjj_qX`}CpK)`OYnRD&
zh@ZP@B*?JtqQ!XyUzdW9wZiyvvBLP0mpC;Hp%Jgd{W;w$2-6btE}4zOr=8_cIeOZI
zsqXGe7{rd$-DK{}s`7?6>M@OldLzk=>*9<0QnCia&W?x8eHkWF=DKljwpg^B)9xSA
zo9z$yaW6Mo_NZ@S6?^TZx=8+xTS>7xlSAXw<SrBaioLh$&7MzLOXA@@vCtE~MUj>^
zV*HSAUS$@Fde0cK5A*pRv-#TaIRggi8}9tmI&c3PL6{gaHIzuWW=EI09AmtP=Chx;
z2t%mCU*AtpB57J!pzvJ{<NwL(=Kn|28NJoDlx!-%&<*<evni`=oLyBjK@Oe0f@hSC
zWu?viw`SJ~i<XC7lo1kbd+N+U>L;^p4sW9BHj#|!IEl33HE4onMN(1UUN?H9qV8<k
z$De8JpF`cBBEIyOpY1E3iwk2^!@rDF>s!w(R};~SPPg*7^7UQn$sS4ro^3Y8xzgrP
zepVx_XDBtpOZTFIoKU*F&^297F}WIfuN)gX6h^9Ivv1E@N<7YSE0hrIYCvPuv_!)-
zmt!?iGRVq!#4W{lCp7NdnRlKxW$ZSD%S4tf2Yzkk%d+9(m`9cwuApMUG!)VBk)1(S
zf8)^fj}qkbv>sb(=zyok5=Q27toWW?hHb>gEk22(?6uwMVgFdI$Ip(i>(Pq4OTWLx
zdaF{CtP^RWTN_VrrTztLeOQE1$)wZ1H$NCz*`<Dw8XLv9wMFApp+bE{Qe^nbY2ksa
zt*`j&P_p6@ZN;X1GUi<GgF~HfjMgyfZd$wS^j7sz^>J}`_n>#Dp3B@8>tgL|y$C;2
zHqo8x?LQq9#~pm^=W8aXHnYh)v(JQ{l#@fEeO!<CNO#pYYO5UCxMZUb>u++%nc>n;
zL2<+1M_%e((DY6W996xciCP3}>|f_y;yW9tOidca{jEJNFQ!(>-ZZy}e1MQS`%V*k
z1T0DmF%#M)+Rn7o8JT^QHv)J$p&Jf6_D+Q7d~uf$%wdv?bM)j3w`t5cY%Ogie^^#u
z0b3R}Z4CLra;&}GN{#ZiP|l1e(|@)nx3n|ZP=ruTAoPiG;HkV{#;~?6bBmB6uZt&X
zqG0E`Gb+|#?6;AJ$>n7*Fb8{C-Ag4`PqSDe_|Z!=Nu0*A8)^y?Gfqnw6-mQm-Rfp1
zSrxd^h{n;Zro>%fW-bG6bV(XHx@WJrv3?)pOnM^>fy=gO9QpX~b8es7<Pi=kjzrrL
zJ^3|A>4Ijn^tXHo!L{R}8=7^FVC39Cnr?c!Z?8=}4Qtp`S&K{XFn>6<9<LnpV)|ng
z^3?mP#gpZ?pE9G@rlm9~lc_9{Ks2(OU_T+-3A{nzc^Y^pL5zhje?dsd4=ZpM7_}K^
z2EM?%q`x+-8a9+uagptCbfZUbZ_;+1?@wY?TRybd+iZ7yr}HA>cm>;l!059KlVy=n
zYqnOYn)|Y(8B6MuRvGC$J-vPt?RsP3HW4tlE%jKJ#8J4)3^#203Q-%bGxg=`7pmij
zvwHH+vPw4yK0wvPkfYO2$J4ZDzf;>BhTQEp5XU^}3a>wgj8tiVTXXGsjGiOjcM(Rs
zVCa*)(kXeY<ONL$!71VDA*r8rnvQkf2h|#bb3y|-KOz(u4;{+x20Q2rU|>^CU!=u_
z&Tw_Q5pUGHtzIabnSdLoH9k^TT9b6z=?VBp0p6p5hhvB=t1!O&HRXN0PPe*L>a9s)
z{|u*XyF<O4Smmvz(X>F!>{qW@ce9<(LIz#N<GR3@c^2W$Xia;~ObZz-UbROlx5miP
zp7s|xVm+Z>{i+bTcYRGEacGUExF}q_C7c#PvlC>bXFfJAb?G#J0KVxq`|*_HEFr;_
zy)whqs`L0tkHzscb<`Sv3-o!KP@2pgb>aNrQ(p3DzsOUp;M1G-Z=fa}vGeW5G4|PM
zx^H#f4Eq>HekFp|m!Y6pZ?xaVNmuJ4EpTUEx90x)%Ioe$hDS_@t^}Wy={`Jf0q$Mu
z`JWw!1zprCaOWF-oV8axfqZ%c>||swd(e$Iwl;J1VRYk!-Lx&NG^>yR4&EXkOZW>P
zaXSTbZlgiL4>j>qiQD&G$M1W|dkPTcm}EZ%>>=eCS^1opkpIG%{z~RW9i^TwpHjRW
zS7;1s`^f5wISXLa5^!R8T$M{Lo@ZnCal;MY>Gj*wcKZg?Mz-u1LVkRn7U`YXua#VZ
z+wa1@QtxdomU>>(%@oHtLnGs_dCj&&wbB0V`{@#9@x>6l=~A+WD8pTGtke7Enukjm
zb*KD|F)h*%HpBKda|LfZ>fT!4+I!oKv&-s^-s{NlR(HnHY`rVg?=i>KXzpX?VdIR_
z{9gSCTqz1~E;ZqGqlI#THd8LkGL=eu#g9e&9n>dlNLZ0Fu+=BAvZR)M-J7+6iaVPy
zv!V*!=+iUw>W$ihO@K*|&ue;@ydu$vI`kh2+`Lqd(zQM}y21!N`}MResTbFE7OjGL
z{`>P&tLC%(IX2Uxap>V*XBxhEN<WIpv&AloFGlU|(e9?xli4}@_Wb*!Zf#m!eEC`5
zPZ2|AKJ7tMZ^hXH_-4|lQ(q73(5A!Y!piHabMXEdKkm>PeOOAnafjXLD`B#EdIXC$
zrWGBxM4!%f_qLX)*{Ys$u15BJpLb$N;FGF#7imN##Npo~d~}?n<zdM$X7M%|y9Hc2
zm5zjc9usvHy92>4ZnK@u+IZg>vW7+sYdK?Fq<AM8<uyzc!n2cGTVM3<@t$Ux^5Owv
zN14h3$TJxC^0po=-1pG8F}<krM}P0GrEQxwSK%f({6LPvAAHGwR$>^!ewQGZeHlgx
zuQT>N7shuHPhpZp@`?ph(1&&~%|xAxY0vg}9e?5DA0WE#fiT_zAW_CFB@Z7>&*>w&
zaq#Oaahu|4fw~sHs#L6xo$qoS1HGjZedTtWnP|PwEUCe>bLuvc{NY3Vm76SujWMhm
zi=T!JSw$@2uuDO(zwyqz3$z9U?@Z+rJ(1xD#zc#@JS-2K+;`X#oZe^e-L_#B_BQ!F
z-s3E$TJBHYRx0tv5RzKdt8laHw0=!o)d$?^8jSoVAK4$cS(*qQv4$Kh;%<pMIrtEY
zBMkQq3SV%_x(c5ckCPzZnq0d4ye5V9H+xJJpKzx#e@y^ke68VNhQ6;`hYG&y>U|Xc
zM(@y$P466GRu<9qz4uWs*I<(0|1ib=h1x(PEiV$vMumyO(D#N_NUs&Rh!Qb5ncEYF
z<!ugAafZ**-2d)v#t@nXk5s{U_~vZDpir@~Q#9RFkCLK$eUv4P${kGiVA)KJIF|ly
z;;-(8%KqPDSEp{aTdg5pI%>EyEzoDvdxnzHH|FRwea|cDrn`J(7w5Hq!`XPll$qk|
zmSGNwGZs4+&)ThBC5g8Mlman*9eEh{Mdmd=<vvP&$?^jPRagY|dUmINrEDteX74c<
zp3_bUrzHlnoO+g$-Nf!3)vq|g73AtTgmohhe~KV>=b*<CA{S?im%Wyi`kw6@%$fPR
zS)a>pB`_)t69y*LqaOW;Nh%PA@V@Xe-5z7jq;3I|WO<ajIGNYW>0Yt>@!VzDmybvg
zC(aA%!uX&nz=OS)6RqNU@5>mvq>QfFAcQ~URQ!^q%lAt#jjnc*)g&E>D??8TmB~ol
zoea~6JJfM|n}_4n*C%?7vlGwyXJ?c;e|n<rbWJ4ys%+a_kA0Wh-ArmGi3c-q$y2o4
zex6CNhTBOTWi4-`dUvt?_x0|UOA1H`$_Y`V->SyQ8ZmOyPwN9%4jSn2Dmz-7vd@z8
zCNzeO>Zj>+Q@)Xir}SRSfj?EitibYLEz$yr={-}6X{=boH@SwfZAf@$U-q`%3->t`
zMSE%M@o3znrO(2<WGC75g-dqstU3jom#ZmX*f%u1%kjyl{r6JgM!8r513&3I=Zon`
zXxNFVpUuURsTBag?R-;ljF*Z;m-gVT)F(YfE><h42cr6}$I~9BTZb6G&Ydk8cpMEl
zt7)8KD2y+<92x#{N_esT@`|EKOZ|!)@<K4iLu(kha*Li`pxFXqR>7;_Gm$r*?>7og
zTt&8eiQDuNA{Y-dB1@FPOhcV3VP8k#k28Zf$IYxcrB*ej;Lk263VUL{is7+uaAkjy
zKSVH>Xj$KRsONoZx*&xkdTj_B@}IA~<GH>=X2G88bGBFu<7rpPR)$SSFOyO1sE6r}
z9_gM|(<R^EJ|PY{25G&Q#SUI?gzIfTK6SX>EXtsnr1=K6@|}n;Q^Lj$VUzi^g4v4r
z%CY|eH3pf5<Yp3Y_yt|+pJ<c_&7ikNWwkCVFa+8F7Q)evwAt`|qI;d5a^D?3?A#GI
zyfPCR6jmk#@YTkhOr^Vghly4ppAH7dJH?nB?EcXoaEXRKlzLG!e*Q%us9J_4?xW)p
zLO$nuQcPdiG0TP>gU&R<29_Y7Hc5<&jHjW47e_Dn91}Xu$Gqs>Wt-4X+T#&44;8#s
ze3tjKyw7$-OUi*uCOwpnA{SY7eVR$KOv35LCIN7~|9G<^nFG%dCj)*MiN}c$HL&87
zl%;sKzUNCwmi{Xwa~iP;tedP>zR_LrU^Wm0Y5z{Mc$;HSC9XTaP>`V|qF$hPH#CB0
z*O?!sy}bpO3^tx5yuKFFP1J2~C0j9x5gB<;i{1qmsurJiX9Pyjmfp3wNZUMb7l>J?
z;1i<By=GdrVV}Qv?}63x2#~=JZhgwKvV`&LVbrvH^`>j!meUJ3o$t4JgXc)%>4<}+
zO+EtbHQ=Vc4AY_W!Vl0Q;91kmgf42fmk1yIZONBD5=kRB_+SWS&s8xAtYgO#Y1dhl
zMrYL<toJ%EIC=6Tc;|^RYwnrlNp;y?8>ryQBS<t(RO(0HODMcmMjnawaG?2V?j{Rg
zv<zIJRr=9mSa<!sA)<R#Bm^On)H?MJ^ony@4z&I>4p}cDsDjrqWE5tteh!YL-yyg-
zu9iJKqLUaKuuWm+72sC(+5V2Usmr0olj`xbac}Edx9Z9yPtyf^;CcA-w6ZSsFjFx+
zyF8rd&G?JYi$jCU89zM3gHK5{)po0Ipk8hC*;(%}3eb1gjJ}(xcZsX@757FH5ysS~
z)Pl2lv($m(0^kmJ=V13t{FgWRIiqhVMO<`3v9l~OPIsWXJvb3&*hRUDn{1iOo0UeK
z+phXGoD($IC*0FZYw9dn<yJ4mn@O-{S0S&{kRJ&qWclnl8-gEEnoL!}r&Qo{TzKFp
zGJI+_JbR<yayPNh`K(Zi+}u=YZooghFwmub8bi2%izxS)jp{P#S$KgdBH0R$13<iX
zE190(H)OvjK=I|^o}jtf2}|F_3^DS?m+lZpvQviQvUm49pUU@c%u;$jqFM8Ga_nNz
z;g?CZ?9_N#%4i$y`?q*}2YA~JF|6E+g(`*2tv;;(LJYtfAiuoTOEv(Ey=l7M(EpAy
zb#BQ-@YG9sXZfAjAYJYWCnSRgN0ux?M$OqHUR(Ep-nt>FI|llDTMv)hyzX@J`iE=t
z7;ft$_YB^bSj?}Lf#SZ7$b!o9MLf$!teeFm<LT@w<5aqFaxp5oHLW;s+}6<47OY8j
zB%^OBnU{O=ZTgT(jCJt`tJ1!erG^aai!{hkg1G+`?@Odjb{cV&VZ$CeRg4z%`}VSC
z*EO9m_-juTEzow0$@Kas=;tyKj>vx2^hVz+M%7;}wqv$;a_Npp6zejvvq&6W0ifwk
z%|$8Q(C+`FX#XN#HzBaHCYQ9#`rP%{dCNTdkeexgBAR@>;WaJXeskDMAxJlh7VF#?
z@J{-O<2uJX<83-`GpqG-dmQ!mCP#)}6t_UaUK7)ok%?&~Qw8wsISI_aKMt~tZ|JZe
zkNoj8RPcWp)*=wah)--qWW}HU1eu>@Y~;w1QPuw+kiD3pQh2?4XMb<gx3%dXMUc5!
zlRrKi|ICeIyq_-L<`m%uyFQEi5*N0iP05RAKNakmE=ssHJc$DY|1{R~fZ?W1W;3VJ
zUylbB?a;W78qDH8Kuy=5AHSV*lQl-BWw-A{tj#C~YcIhF9hd5CFqTO&T&Bp&GP+i@
zOiQJ_aT}V|$1iDtt<Ehfj|`uEDms<-y-oU2g^W<;Wt)V{hkv%tt_0`XG5KN4KK}*g
zwMRUy(9VZxtT!7vOCTciS}=3o4!9CY(|*rP&HMUO5}C2e{J!Rme`~k;slwo%^6Nip
z!^l>`Ja{Ed_E6k&Zs189Ixa<FHG`oWIAM?1^&4+`Hj(=E>vKO&9s5Jd`RLrL4+412
zY^*rpHK}!9#NhGFBfi$CGEV!I1VwkoKK1&!k(br_{pei|w&&h28zD)5Y@F=|D$mZs
zj^<(KJNoX;VAwQ`NL1W|wY3{<TY6?XfA%;U?iTRx(`UZZtnyQzhQ2aRJgJoo(6{pq
zji>FXlktpdD$E@wnpPpUI`AgN``Ok)rqw0lVPG-*I3-{<QH<Vrnlz(54t=)t$@j{p
z3`bEQakNB=Jj5`Z_XI3CCGczUOF5yByGL^rE{481PIh>4!=efB_)_cFo!y?UVi2~L
zk~vH8?9E_Y=-v08W*C>JO8hS<XZv(hOx(I%^@+U&{l+~ee2R_FgRtMC@J=DNn9AL>
z-0!UkdxEazk{&&DukW+;MQ8PQa|H2DLtB-C{%ftvn3)Zd<YB6-T|+%1FF5U0c(YlD
zj4zw!N@^NCzW>uj+!s$%H5*sj>BE}vw`rn$dp5?Ei>JwS5pN1I?xP-{`fsqbCxc4E
z{L%98)sJg4(`Gsp^-5oh9v}ew#dF(8{(7QLLNH&4Y|)foI<kY?(>eb0iH7cezJH{Q
zM7_;ij8F7hK9BuqC4F}ZCna&dtclOLlIk<tLduQk?6tQfW6%E)5?JGJW`QPhLNi|c
z%&i4SxU!8k^w)>oldk(k7_v+71kn;n9UrIR3hVy*U4{jAw>@qYUvJ$=_M2ev{YIiX
zId(IU5Kmqe^|ha;u5b+1lZP+uKK4_4YdyPHxZ1tt%JEFpvmiVK7v4;Sc`G?nvV89C
z`c*!dJ!7>I*^%MdZc!3~|N2c8*Z+0q$<BYS1hAy9Thehuq&pA<QA&ufGc7_q9}E(C
zv9(n2rYa6jJ?ifnHcQ`^&$&KctNT(fI4w6UKPEkz%q({~+*F8;*Hq!hg&b_M6`coP
zu8NUOuQI^{_z@VPz{>G|cpr5dn?WOUT4qyy(bG9aF1t~9Q}@@EB%1e7XV{s>We-Ev
zl$kNhZJ22}*t{_M%cLbL*CPeEf__{<_>#5Q9j>K*I1CIo-S&K{TB`8->jXy`?D~b}
zn1|x)QTW`tKcew^A$&r`c6cy-{Jao#j*bxFFyG7fQ7s3L9V8&HYs;~O(NxoPSBp3@
zr(ms7eQt>%<Fb~>RmUIs%6s+0BL#SmcH!A1)$-@`2jl~P<?)erfR`9et#(QQ0@>F{
zgt1$gl5HR4^x^)23LJOr7xCh&Yymq(miYwRGj6-=S?;iEQ{lVKcAsz8t^w}<<C~i7
z`?gN6zaKz6;~)G>-%u7G^J;n<$q60ZJ`lHcQzvFTSQ0N^lbQx`kURFHKFi1d$;^)&
zw%I)S#OGd-<P2x;dlH539(@t1;LLn#6|3s!QozCAbA)HHFcV@=Espp~?P_93@TZGJ
zgdRQaVdJN2J&d=y<Oc5Jofz({cAi7a2BF=rYuU%Oax2&k-INNG2)Faq16hMo3hYoK
zo_l_M(BVPl9K9Jk3|Zqz`D#9hKq&vQW>N&v*~zZfnPt|dg!wU5AC?jeNyExa&X?D-
z%WsRD5w^{|3Fe#rVgR!y`O0^XWI5iE-7PSX1t7jhs|4`8lbz$8PRBQMmGVNeWtoQV
zklYuabV^}E+SWXo9hhmu47Fyu08OD@QlhS%YL)MHbPwh=N%O48uT)%i6;?b02hhW_
z^J!9SKv@X&z)Fqrpw~w2)iH_OZ^nA`>a=6emwVb6){=-ehV{9-PgRwtIQFPdAE?;!
zJCP0G$2Y_t5{{kPvJ4|nXjhVvDVw$3zL<~Xf#=stMM_jd>x9+4OYRoAwEpOU`cn;Q
z{I;2TFt@-#or?WJqCJwN01XWT(NHoSXgpbNLyT>=^>cx8O<ih6ZVBa0cCKb#V9Bwc
zrK5RJ!GL1V-h!U6<r0F<rqg+^wj&p!D4$p!Ps`1=>I8q7l6)K(>&qurYjnInt1Le~
zp(J6mJ-hv3jJB0wc{?$xsaQAtv{O&vfKGoa6=ziB9j@`qd(Zok{}cIjlipt<bP*4F
zvs~gI(49A#=}ffu6(k_bMH?e9atB^aJ;V}zGyo=Vth9Ujh(Vm2&6pHx<5J|TQ1(`S
z&K^d#w^_z1INMPhPO5JpgZJFb2qn1G;6EbW7Ao)M!<zJ8{e8gwnQ0H@jemj|4k*s!
zNd+Cgv1I1@cK636m!bk(#a5SR&y_VQ)PEm@_q?=J2wVz`!#WeBNL~uWcRx#iu@ljJ
zW2`nVdS4TKDr)6CQ-qMqwEG0cNn=|z7Sq+jmvu@jM<Y)zM7vSlzroo9@vSb4@aAGx
z;k3##on@Tj;^B~K)&yBL(R}N3Uv3x`kMc%0T)A!H{Fgt$TIcWb14Zh+wYcQXcFEbc
zR`+w?_%jPUpkU;vB(HIW^EA(sy~T(T`A^YIoBe8t_OzPbH{xz|-leOe%Hw0<;^Hlp
zLOl@y59jhZ2(#$q@cf&$%Z1-=ev~M7d27dZEs>R(1VRTkmP++ll{ulbJK<9sV6l}S
zpUjrCCV)#^-S=92L}33Te!iP1m)>j4x%Qi}p?iDKbBk4zTaz9f^JQhuQcQJlR<Sk-
z=6=NFR&qps990t;aDT%C9Dx0bdHNYLfek+BTf+~Z?#wH3&Ny9=x6aa#0eeScjiJ0E
z1FC_JvryGkcgBTXmJOY1UB)A&&>Jz+Q0X&Hn`*~PDT(rS2oiviApHPke3%eA{_XqR
zSoK^(HT?cI)Of(QHcH}$mr<AG<}R75YEoz_j5zW#iNCn%j=^I&`Muu$@DB79uoIR>
zHjSEjas}Yp2BWN*<X9^_`V<#2Gk#vHf~Um-8Bu@qoh+6BOymj;LUTm>{e&~Mo7;h4
zmPu!RvIGi2@AouK??O~u*yUF)(j@gZ$1oEY<1d<uYgy|-$qX_6Q{5D7I_iLdq%huD
znN-wAX(p`=Jz|;Y>*hv(nHiz&!nL&Xy+fkq?xwAbB+>dHS`0Lhw9Bb)G~Y#1^myC3
z!WHUH@TIVdW;vn7$vlrICuG2wx<)Q$m+oj^DGz%=ufw1|H~nHk-dgodJ|%MLsO{aN
zzosUK5IwvcoX<t^DkkuBGneA&%c$q}`BIP~^jH_=t@E8)Ez?t!G@~Y4d26*9w2KtL
zZ9s$5vMjgPtQf!IG#Fp*z`)72zm6Z~h4p6A`Ye>VS^vRPB$vYCP`O(*#Dre;8T5Tr
zhjBepj+Hmld9vOo@o*0%&lN{RV1uG}AdnM?M?=S;<7#m_=@D^_wT&4_jVI)olgZj9
zEfH6-&v%vYemgd8km**krPT~b@b)p$m7(&#=d!>n@^)^?I!s;|MgwNa&(2_@{+q(K
zF#Fo0PsahIIL=IZ%_2u2HIRB^BA2brV;YkelZ*e!7K$BC{rEI+vJ&cHWmz242u^3V
zqOq(b-s4+dmpS)J#v_N)%v#*2mEh4U<ktWK#-HTD4rb6N4H<Qp6JO#kpU!)UOO9wv
z)_WvOrlYBB)k)i0=dY<Br<k!5w1S|(ymB}0r^f^3<{>Ix-EMSrbo~Wm&h~2uFCY4a
zGwrP*JuBqy6Rlv@ulmt33hz_NEWO&YS$XE|itW#p@0z{|dzmq{%DDK(Jj#~1J5;oF
zlNN9^s;)9uPIiY$Oi29lXR*&q`fd;yBuZA29UVsm;Gr7;CG5T={Ct?;SIyiR)>n}^
z^*#MyWtl%xi?eAegzV_JVSRHPIpQ))kx@4y{p_>FB&YkChxVCmN?_J9S&O#HEoCr%
zWiv9iRC<%Eu)kaLJET$%W%jAb?Wt^EyEsSlmO!~YuX2s&GJFGs4WmkZ5@1KWZl<74
zog^SdJjcR+{R1`uYVC6^IuM<iR5LTPs&Qsw?t3HqC;SUAKy-b!TZkfU_N8A$sU4r6
z?joKw$P>yRI>D;KiJ7roFA%IYTQA-Tsqo!GfCkZew)(%z1m;{pk84KBE*G@+2q0Pn
zY-~!%7c=pesT*@}VbQ(Z8&VOaBxC)(oqjI9YmYOlILCciRw=k8D7<Kp^dC;*$~7`Q
z$6ga0ctT@rY$7TeD6lJJKXLq|S0B`!CcifrgO|8KFg>#LR{&x65az+|QZikFG4KSh
zj=AFgaVU<tB-`$80XXzFR>{P$eW&lD+$lF5O6v-%s1~6&5=PF8em<OA$3vJHaGizv
zZ3+y}u#ti=`EuOHB5WvgP6lIt%#Nn(jIp-U94NqZPh-UoeB7t#3vuXIuppGSnGLoC
zb08DUict7`;#|YN_NTKKWq*)qXcQh|Ev^m_x9+YI2IT-9fv4ch*+hAv0m5*NyVzyB
z9e2xtI14hkCw#)g11Jm#a7dc{eGt;@fh^9V9~`ThwTHz&2w(IQSShDFpy#TrCUTkl
z;K{zd$<EEMYE(N*<2>o#fLz-hNsD_ZQ{y%JqG?dg;jdqi3(*ZAv-}l7au6J|lpHIF
z-_xHzLN0gcls;lqv}eO+;df7k$;`6F;92i?Q|LwEN4TbYF43~xR)#`hYOsc=nIZzu
zJ-Mcx<Z<o53Z>-WPTf>r*|IFCtwRl*iXAJu9z5jL?gVs_+^xryG|BM|G<3_8OjKUF
zE8D{v3e8b*+VY-J@o|8?%@ZGf%*q?iL3pVPm{UEJt#;#M_f{1agpM?McUC$VHq_!)
z7>L)n$2EU;4~J6t7PLrFl5E}hbh7_DX=zmK*2(-d$&$r;lfN9}aqYZW{jb}?VCoMe
zg@Io{`}GtJhVZOkj1ZY?lrVK48N%PU5Hjkc1kTsm3SR<u556=ltC;YBiNqhY9GSWO
zz)C}B&2UgXQ1w6Nil$_{y*O>|ZT+(Yt;OoYvmAGM7JeWdH)OOM93vStwG(aplE(|y
zhJLmEKr!9z0du$Nd~jgw@2iPc9@~|D5>pILzkMTV8H5ox<_h%>i(-=X?P#HYk7R52
zErkH)g5A?#$;uMT$mAp%K0t|wb*RR%;WnMVLy6b<p&7=Ncv64wy`J(TV{4g$J1$0s
zOHK>#rhL!e{xFWjvX^B_AA!-W74Qgk;Zg+(F7Y!doS4HTjs|Lu$)?raJ9~OXn_0r_
z9o}e@T$_1LhPW)ARsbQXbt@`IkD!^G+QO<4(+i;VSD?-r9k&93PJo-G@#@wjtJsaa
zdL~a>fz&N78ZoB6{viCAwd&9}s?Aiy=KXj<50KI;-Rfh_3Az*5Lpe57E=PWSP4&*L
zkb^@&;Ch$5bqnL(;k3Y0bn(aw#2iYfK6(Ph-;lyk@ZFM$>fbdya=-;Xa;^cLSJ{?@
zYH0wDx|fGfpf+mtdX_B(c@FI~N~FQ7y;DvAKDt&QLN+RU#J*Gdx(l$;Ttpee;RaJw
zM;uX+6piFSI_}npN7?kI)Cp^IUu19xd7*XzsUS1CT;wN%&6|3UJ|1)EGTCZvf@*5D
zVn=S<u1SgaWqz7K_D<VP#nX14?d|OSFrnKJRtjpAOZ7>&Z==mtFd~C@<nzmIh~4qb
z5>~840F#$haKPjxd$Tu7Io6Q#&<I7&tZ+w=4A|KQ@(akX9YQ{db`dMx=u_H#8#0?o
z8TV0p8k~)EI2r@y9?_?;Q52{K8&QEV&297;4bF#E_@B`|9~~x4?k`8M6YV~DnLPrk
ze>0_b9Ms<%wN}7<aHD~S&-MKPbyV>BU+t5vL`m9z>-j$$xbw<0!0-LZjDMkSa(p;!
ziMRD!-OhB51fFgjdAeKR|3Doc#Njg#F!sfa>Wj2*1#$%$67M21uAa8KEUW8@l>OIK
z;-Vby?cL-dom=kJsvOHqAS5&MTm%r6g}hH^JEe_%iu&fAxu3~NW1AX{l512`I?iTV
z3Y=9@W>Mcji)8se<@`3)$#<Q*26n{Z(ndXKU!N8AwPu_Sq4@83J*>PQZ(8EK{_>aY
zotBI9hiYcN$4bdv`|-(vHnH@)+iFanP$5yTDr}4JW~4M#3frW7-#wKwQ+8-rXLglj
z_>^ZfkTkG&66c8wSgZwplD900TIADrm<o)-sHZ60wj9Ow_7iLnJhlX1+H0+-oEY&J
zd#L=vFXBo5NuPS}ZkjIZuay5*7lKCXGWErwC%nZl=vI%ZW+`C`x$hWIV5?vYbyM`@
z2*UV?FF;t9K6Jo7d)AW5lx?PBvucw(>1Wbij}MPt_qGmQX$bm=O}moU*^Rf*AE^h|
zdSLdQUGhCI^weThP2tjQRW=uBf47j#&ow|s|9tj`Bi<RPfM(K_gM{(h02f*6CSj&7
zrC!`aXuuRjZ+s5^LPhdf%Ik84Pe27xfl;E=(Iou{p2jR-K_s~W4Z@8oHgJzcU!>m7
z7r!ECxy!Z*Sm_OPQ?%>$%3kZsX~_L89cd+>W3cx&#tc3Ky+Q~i;=jy9*4!6;%az@l
z;kw139*}i!z;{rfZG3-N&qr3a&qgDxRR)qvJDr$_BUXytAFVYOTSc5Ul?{h-G%?Uy
zw%DO%Wj944mKpYPwu@5L_lt6a6wddc8$J6LBkK-}m{3ERy8x8-p5P(&^ZAfq+C_<L
z+Hh;lwXN!T?*E9vRT8O@t_bOR^*u27Oouy%3jq89NLe)mq({{v;bu26Tb~qm>tN&2
zY|X)Eykari_r4=93!A6ufU08(Ew+=n3rIE8YnDaW&e-B(9lDg59Ir}dI^(brc86~~
zjC5T<%bCBD8Mb;COe9IND$^OLdM)%{m_aWqExyys+u9*z9BFFR#q7};EKq;-GPgw7
z8@<ntW~$h7<__hnts8yz$DM@z$hw+*!{QHRW9@$gl8!UUh$?IJZzK*cX51i%xwZ(N
z*lnWs%2q;<>nC86t_&6Ta1k4^x6~&Mo^+tRR%7$pQ>}X_?oHp%Rp3^rgCxXzS=LsA
z-}xHfEB%g~CVZBWqJ&W^6*{vBZ)Gc6=DPxuXXbf<_NIbe`3!{@z?%m#BdgQ9D4|ca
zKzG-N#XB?8BA{OAYzI14fM<HtC*S(X^mWuV#Wo&4?wEs{%PHzRnE~bhran0hd0>*E
z$gYOTt1MJDUeO9_FI8K>$l90u4@wA%J1U=8EFlQ@$P`|et9&;!m!DZ9(B{{&Ac>f7
zB+aRr^q~?r>6P~gO1a>_7S;i6M~8)NfZQ*ckisvrr|}#ZluB-U4ScIG;`*dtW1jdx
zijX1&Kw84%WFLF8tbpZ9y;<(eykKtHOk%4+Z8$TcG024AfA&O1DAv5j{ZT(zMt8s6
ziut4!WJYegL=0{fY-*N%+kHNEs@Gs`-b-t-&A~vg!Ya8e#Ve=xmd8SQu3kL$cKm}k
z1kzPqIib4n$8zKdTLcNE>W=Lj_hhGr|Eh}fJuc@b8CmCFn5GDVLH5xESL3>-!m{-q
zlR60f<DueVft6Ijv$I8S?@VXLF%?VWxgOKK@9Ia$A<w>9)cw5Ugu_&@y}hj)-G9;H
ztkjlDIwe%j&un-kWjdMRHJQ1&!Bhmw$;7!4%G}El&yl$lj!yZ$?urElUl_k0_);1f
zu5mbcl1rqleYe#_-0kj^n<YB8Jm9O>?(&GnjODL@dm9|RGaZKKCWXz#5{KYAl{T9d
z-r>-Ed^*srj_$SL?2VBQX}_x5r9Si3R53xm5_eXi0v9JC$l(e`DL%R0^6sATww0L?
zLIZI9wE<xx?>o;dRugG$`&s%$V>LzjZkceGRA>MIX}zBxhIuzQB`-9UUE_Xq(@mcg
zTqnvMC^@J<$`$7*L~U$CRtu4FAuqID4=4pPMmE>31m$i?)>)IMF=W4DFR&zESAq~e
zM13h!h8z)8*uLJd&bSMT)}>w_e(RpV4(DlrVt|TX1?Ci1cTw3MzejFP`OQNyvF<}u
zP`%|V88$4E%S+=wKHN$&b=;Ff6{agyFZ+6c>00Pzwc17sZ~D>EPV-5TOVpd3Y;}B8
z%T)hU3ADzL6{#`dO5g^EkVM+-pm8rr{9MD-7t3bw05Yf?iGgRKt}#GyRIiLXU;{b%
zusm!AIUzfg$QfJKTBg$5?xIk`OTde~IOw}EGW+$00T4cyhg#k?x+i=$boZ^u@P{fY
z1#A6%W7A(h-2B$XDm+Ii?OiQSX}V<>+3(6}dWYncJfz~xodY1NUl3O<OnQO)U@Oe$
zW8mL*Lo$B3&s^?HCEHdfz&y=f&s3xwNE}Z2Q%R}gPWcc<W_Kltk^QU=t(+$2K4GQ3
ze)yX0qC-b+Orq(Ii^BT2(f0st8)#?M+Rrjuap2fC4JvLfZ}8h&nekj*_-8WN(@wKw
z)YHveE1u?=;TkfcALh*xP2|M74i~7)GJg0z?^Zc1Cu9Va+#q&@H;Vf`VQyek3&Q}Q
z6qeB9!LP3UVG#=&w<j8Rb;zeneh2!&$9?MKNmhsQ^neNR;Nm)`L6OAX*G=5<Xi$nV
zFp*oOs1LfMJVWmFc3bPYQggk^U#dR5-3O8th=@{WbUB+zGD4Zf8dSEi9c@X|54F9z
z6>JP}S4Yz!j19tNvV0E^9+G>nPAL}`P-eX{LNAr8(mG0KH_GD!0$hHl1L#;#ACdk7
z=~#AWo@5#!U-?8Ys1B5l%GVFfp$CkAf|?KXj!+(5I#2Obod8V{dP5?0G2T?#^bh?1
z(4FzrPV?UZ4pOgAgyrQ|4uPmOY$a=8V>0b6K(+=?i6uea_(Nv*u}xdu52T}8ri43O
z+S9~6Hb2tG41Spg19y?<E#I3g)QZU^Yac#REWQ(v?8ZIsp*h?bfu3xUY$0(&9Kn?l
z;}+qSx85qquvfPq{zsnkmQ|yRWPEC9kqtj&miSG1WO9r%s(yVnMRYA%WNaeD0s^29
zH>n@W9lQWLuNI*#Q$dvXA^Dr%TAj+<dbGF*iqOn1%2I^_v1TQ*ALkC6DNWDNTJWH}
z+3>cnzO(Q{2h_BiinlDv<Khz}2+|-xT2*@PH^_5eneDacb5K}r7iDsKKcUW9^~Kle
zp)7E08JQl-U#);#A8P+)ZT}7Bs#0>R32yqlm?<aJ_g3(2pFDHB<)b1uP{)|Jps6w|
z?34jKux&xJ<XQJ_SoOp05aJbbtUNaF;K$eq*PNF)ne^9X7v}>TTZJzg`_u39BQi*>
z`{H6hOEm#(`HYnMzp%(=r7k22t7R4WAf0W?!51_tUs-FKYR{@U;*0j2rxiy{2!Rat
zW~nrJH4rDRQrPK(J_Y(V1C8<;C=6=7_gwBlI$310Qlqz){rGaC3j{WxdL8t`WrU1y
zB~Fyt@Y%9;3#8M6N+%u}pLRcGdDBVxMWhOA?$O?=rN65-Z<u5WTo~)VtOo?Bplhmr
zb`}&(i?GB#U&M7LYm@15)rr;a33m$$x`-2FEFkIp&Af)O5P+txnT!?0?0vk}sJ7D8
z8sRxTe>^$v;n-ewGj_Z7w+QcP5F={KH|hlD4s=!xhXsFn#{OCTra!l2+9Bkh9*QEP
zeVv^ZsnGpq%Wb+S#y${=_U9TNoW^d7uTfB=J_!mOwAuBsu^Kqa$}^$A$$nqZ1UrgW
zG*1buHVN*q)<@_=(7AwK)@gS+KdXjqWWBif+jrU1!~v=LW@D`dD>MWW`Qeu@&Rn|p
zrQ*|0Yi)^i9EKF^Y4b^3D%h#<`}>TnALg8qZe*NaF;fnumb|t3g;mazXk~kL8-k|=
zVwB2KxgI-YoXowN*QGAsTkf&*M`!bc;X~{=(5M>CCcmk%tuMU@dk&R_qqemwkyEf`
z=O%kCppN-FQa6+84-)LYXumA#OZt>NH`dJ|lCfnud>qB{NJqengy4Z)A{44e|4?B`
ziO%$w4RS);%7eE?(LlTo9A3qBj!uZSxG7S&0fjlN+kz@H88m93omK)}-n2zAcj`5P
zeHKwc1l1z6r*1rLR+@^10=60EM`y?2s(i%pJd*m&<8AoO<DJ+1KzfSW<5Da{W}5NU
zdFo4=;9d!cOl6~PKgE<MSW5#F-T_+UR-o$B=JgE91jf_c1PdNoj}%Z7u~lAoiziLv
zwk{E@GH62LRwg9(q6pLQ{}#l6D}&!wupKTZYPdU;2V3~6i+8KfP;|S9s{tgt60Iqb
z)ypr@Qf)o9BJ4L5&p`=C<>T)|gl!seN&6Em6g6KKxrE^uP;zQFXyx5l5vz95Zq(Qd
z@ou{XGTW8z3a@(!IoFgh%<lgZSkT5|5^#7CW6DTtq23SoId8}NU#0^x$@#CDg6?-i
zOrp#YAoONI?p1|U11NE>IIAAYK#=K1A9U7cyE>%Qa!V<FnK=H-hFwVQhyPj-K)Q*&
zMfwRAD(^VWBjQRs?Dg8KaBHR`^@J7}k}H?VrVr2{s2%EF-`KaFqIrc1tOSFS+lSoh
zK_Brj2Z8$whyW}_alQL->h5&_vJzFHCQvl)oftu`;ePERuA9C5G>9HvT`lzN7gal=
zFw_^YVPR0`Y1k~(pk{#ixwJJsf7cw0{@PI*`t#ea!UC_(z^E-vlWPymE6!eZs~Z$~
z-^=oD8uLDN1hCra)1)q9I|O>vh`CIQ=4XM`c}c%$R>|bQ;4Z7)N$=p0?mcqJ%j4{3
z^68od2Ee3e=wY|bDrxKr!{lv1*C$S>BXntX;lnQV5zocHvWnl?9WE`PEW3lbd7@-v
z1um+Et@IA^)vSD;T-jcg9I@G2@k1u6W}lWD-NDDmJUX?Ya39T#;Eze+o*&*$Wp~=x
zLOCJX4+|riFHhN<Z)|pkwuv%GPQMIE5yK#-3t1FT)5>rKmB`ggRvr_}uq{up<(~8%
z_tvD_E;j3~+FrS_5#)dT7p|G-mU)J<;9KTLjFu+9269%K`WN|h&>}{rDBh!;{m9Pd
zke=UThnD7RzVaA(moz5%0S@Vaia?#R%7`OrHfkq#g2#p)FHwm5QWrq8@7^>fX|vn0
z{a?=nmI5)&knuD&J7QV>!x9TnA4iXCbnn`sfl=H3ehl~-_v&H$U0zWBk3e@+;kft+
zVX`Rzcl!EPjwt25v^3}KT;-W=an07b@C>NPb>NYmh*<f8`OWL6d!W5X3?yJv`hV<=
zOxfWT#V3!)LO%$p^$pw?!DUCgD5f-dP(=HlEH?K)+M~|hY_}wy_Wbb7yH$*B?1`Kz
z+-1k!Wo3mrWM-K4xp3O0W|D{EijDO^X=kbT+wS2hAQ5Uve=lCjwhc7QCk}H3orgE@
zx9kG}e8@V|AE8>*?b{R$hQJg5CJya^kNtk~#FOSl^jP4z!{(ZDhoRT-lr#5UR$fWf
zek=EQ+DuY9D1)qEj8ShRFSA4#b+*=#w7x4C03wyRuq)l_u}t;OQwstgC}Dfp(aKNX
zzn$1y^zBK`JkeW+w0G<Tr~z#S#p3EzWyI<?<w9{mGV2hu7rX)uQYi-ysnCm0h}wA1
zwMW%z#Uz^V_A-(bFIVUD=+HZ8sv47+zk`do6htr6s)BbaGU*|PdRuocdAp0unfQS0
znt6=q!CxzTMY0p>11S^1Pe5%hCEx1Ig0_pcaN6kyAV|{bZ)o*pfWUhkt~#M$I?!-5
z4=X;{z-N@9xdT9k2~~Q>WG&7LdI9|FK9CMU`^6$gU0j+*oOi+KPO_Dg#bwvi>f)W7
zroUT;q(=(ygRaFd$tEJG|D)x>0;+fwH(!J$n~C6IxuYm(R<jxRpQAdT@1WDt3m$fv
zSh3xKso<P4HLByaDk2tlWk13HPOk!?X>7Ln3TMkc=q5O4;zn=Uqm`F_(y3?5%tY?Q
zDiEdt=5H5Rfk_6IAc`w!J}l(S5jBwMYg^Tpj7}R6m}k%aj|IC`;A|=^=bnTFtNa4l
zz$L2bc2IIt)hX;Hb1w$C^FE2#?wzQbSNw%U)QlZ?tUz4CI75gb53j)vKC{<E$FRU+
zw5@qNLt`5?$t96SAFXaT$w;+Azq15U;{q+gz91*mJS62hdVdz(lASdpg=T`s=e01w
zE?aOJNyVs5M?hic%Q!jM_%s(Q9(Riu+U5asEr{*$%L->gN1-#O+uwhB@@KWESNY_@
zp>f#SwC_lt*+j0_i}91N%g~*9?)FH+05lO!g(4f_IXzCzr+SQZl$P~t#T<4qbLMx>
z@OF9fQ9I3eb-ZQs{}kC;vY&q(8og6Up3hxC^{lJgrtg~7E)8t<Udv|{?d|@Dok5Nf
z;bv(#GqguwOtb+4nFkJC78n}P_<cM%pQ8P7a=bV=7-7odp|K!&#0teTxP|l|V$&IL
zsEHcNKIqq*+bz3@$1HQFj{SzOJha1$(GsC?YlzgW%A#<`MO)p0!*y$Q;Ox=~ZtTwb
z8Z_`tCu)N1neQ?C{hmb!A=z}6;PiBK+Bjc(c8D>e<gs%t;kCwsPXhu|lWNs0-m>q%
z!s}){vNmHpxBN?YkYstmq!C)O)A#X?4-OqOdS=HOtH;}2xM3P50ikoB=SJ%~PdWEb
z#Iek3?D8D!Ea>bLAni<HFL!5T+J+&E85!Q)z9@Z4c*(}Oh=Vg|2|@laLk7ySd_D%k
z`;rzt-7{PJsqmgVTP~YvqZo#+$ybZhv)5Zolo3Tl`$!)}Q@(14)kxC59twTJy->pk
z_VbI-?{>Na9gC)ZzMs`yHeVHY`;|ZcstV0NGHyom^|;YmqY`a3OtKU?me~#-m3^`s
z>?nkev-)70V9rV10w`|M!8DR*X)ZTd3WN7tkyau^W3Pg*znTuNBvW}^Q?Cf3U--4B
ze)07t{H(M@Wdrmqr^fx!#BCgD{9#|SZJPKm&J1x5v_(ul_t$*7_$9E)ArI63Y^Onz
zjtny(hY(5<Xx;=@Tmrmrwo9l@V$i`2vK#XU&Ohvp&##e2J^c{H92X&*?xA9B6MY{6
zaWj2P?|4{O?cnw~KQz$(NAEyu#n5&yHNKjj7fULNriB+1#6Ekc4gR6ABkkAU8@5(z
z-qKe91=>5#zHFGSdT8tGuliv@Li3=NLOpPc1JIL<%F!eo^<~|kg#vRDKJ|e$5Be_D
zpAbLJS&dDO894;)vO9oKSJ!|@$oI^=EtkMDK_cB2>U<thqJWuZ>jnEZF1vD?>!gB7
zhNu_D1>ryRxI9tbTMTZMfK(8E?;CUn=rybaq3D;KKH~h6{doV)*l+(9vR4z#epj7g
z^?0`v#=prxh$;RESS!f4R$Sh)&U`uq>G9N2)j<%cPXAT#Is{s3A2hsWen#S_oX~QQ
zRR}t*SORA0Y{(!DnE}8Z04ZT4bjsYbJ$I@;s^*&alkd#MzfzJviaP%j4XP?}GS@+G
z;n`RKGVIM6I_vx+qS?#9;fK>UTifq><o7vV90<+v`vquk^y*k9;FP92N@R^BCg^qZ
zps+Lhibb}10m?xqo{1;0hSt?T@jo&6>UL*iH3)|HDbh^sd>?7MgxJw$T^qIo@vWX!
z%XVK@_-+`QQm)4$<qx!vth`5VOgbt$(Q4RiHTDYknzdNAP2{oOA{QC*gB{gEuZRjd
zQykEEOEUU8rKOol-Y_sMnM;@%N`UGvz@tHdY%j5FJ-JbWnC;mxq#vC3VE-p0uV8QL
zQdi)_HLv!$fAQj)>wvfxA~t&;=m*{FPu75j^F|zSZtr$ebEjyaQMH<0!6Ls7HRi4L
zVusP)(pgqCn2$+m-_G@*V7XJtRT|tALw;R}TX8H;&e`c$Leq@>O>?B#pn9Xuw7t`D
zh&#U{54fYx{^!wGBsT2)6><_GkUto&%fJdq=#hrPMt`%4tz-#1(1>_gKb~_AG3FtX
zg(1VvJzxZqw;j=B`WBxOGKi~iaccjZr-^hE%_;LXh7^Wy2h7~)Zyulk8u1FoJpXY5
zH!LJ4qzWAiMY94Z{FheHswE>S%O9wRw`UZs<aSoJ_Dvt|-IEETHA(ky_3^X03qXgT
zAM$grJdQAaQAKW=<YGK&7cXlWjid#>+>S_b?yBRJskr^7EHlwVguo%7s_2D%>c#C8
zbZ5ZU&cBO!*U=LBEcMtI>iOB_p}TGM!xsrtq>)^y<XbJ<vSM3`mxhn3C9>V-n~f3Y
zzOcXN>&wev;hpc<3*MVbJ}ksY|J;)QP;DMlAcJfs-AE1Eq%@s;ScSUgRw*Yhfwht+
zs7E%I$uqB2n{N(J>`DPGvt`Xi#}qz_L{fWAnfZ@_RW17yr10_Vdhb5#U3%8g9JDt0
z+jnS-Q40R{Z@Iz;p38PKLe$=;v8!&fw10MeTD5I<hrFm#@O!BPd^lo+oSZ_O24+S2
z(Z55J3Jml$osp>fd^7^T<Z+S>?WFlz9pxY7fJ|Kc3fZ(5S(z9Zl;-daCg2W7`;L#L
zUN7E^eJnN}(L2)ze<hoU-_<n4bZGnkX!Xs9zL77th54z(2I`grS_X-Kf{ekeiHAB<
zJ<;V2)h`GTRmHbdf&gJxT*~v=QoZ_W(A$RYpLfdlmG_?W8{rBf^3PC^f3}&y4OMIM
zLAaBXCL1%D^-kIwI#i$u0Gc{N_j6Gq*;x6qKH^qn&CTh^K{{|21oBEZ-I=>`Is{bj
z3tZ%Uo$V@QJcpv0EJ@<pz@AEQC^}i@T4+Oz+S}C&TU-cM)!7BxCP_^B`D2=GyXTSB
z9i!gAp%ALx^Ecu{O>|hFJ8kG|;v>T!Oo%E3_Ut?C3^kM^cZ{GW2u07gg7e-KiLWB_
zVP#$|^#5->u*%F)>((=iKagyxn-;7qz9`czqsS#BbEo_6i~VGzynIdOKp^yL5w$rz
zhaZ1%@jIUr+_@#xI37;<IMMD5O@gsua1}MM`uQlnK3?-*F}};<1&KfVz;YH3=4=WW
zSMXr<lItc?{tK}5HR@_8>Ktzf{J6E^V0SqyY#Tfh6}+(Vt-jVAyJ9XJDB|+z{gr$$
zjspb7x0f!Qq`G~i{BMqfdN#iu(tiDLx3L=n9Mo)t&}3y8b?z9_+{UL<uJTUG;5Clt
zP0@1NP86T3wr66HPC@7|;5F;Q;XJ7Mj8ueSvLcdJ@D$bY$S%y=8Z)#IT=(0xoOxT+
zXWNJ+B=in#r{XX}e>4)9M0tv>CPajzAxA@rtdx8f3I1r_*5frTc#ng&#gO68aBQrG
zra6gHGxGBrvCxDW`lUIb@ZTYE$jEjC-t^hv=GJM`a}|z1;=3na(gj@*H(up$(k=ad
z3tu+&svkX02F2vO40F8YS2bc&a_TRl@UR$Tx3(O|0$GD4@Jylo<?XB96=@wmr{~63
zvCl$-am1genza8ZEC3>L(oD&ru^N~~C{g>L)f&iZhQ0gM_9BOu<_${eq{KNpVnBQ~
z`0(h%mv-$FR=&_sadT#_WPAqBHrbL@kgq-ZpmGcvN3mMRUIgExk5Th%d@w<S1Gj*E
ztm__vJ`3;`Z@Zha)7-`G`~z@(DtPSE2>uhan!RI=*X+`*twy>LCj9GaoNAp_d=}iu
zJUINHo=P4fxeR5SF3Mi#E@A<t<P!7)I1C`ynmjvAw^=N|MJY--E}8^qSv8Y<4-ud}
zx|wu{;j>M{hsA6et{N`OIMR*WDyGJu=PDdymDwzP<TK=Zk9ubLy(<_nZT?d7;m;qI
zJ?MG7)_d%Dxy-ejaaAk%cgghVrle-4XL6LZKp61N)xgvbvb@;U8{Jp@jkMgXcQb9d
z)<OccVYVAr)KrDa?ryqFniq6H=Zve^&*7r77(I8pxqlKs<cnNkz9HrE0@q1_ZeGeo
zJ2k}Epu;qWA4v=tf$wJl_G!v@&a{WQ7JdjQBE~cs#3RRebrB`K(V7dW@diul7K`i+
z1Ul|8AJRd4Zzjal_tHDck(k;-#ZLFN&FZ&)e#Rii_??B@^fXxVygB95@J8e4%Hf5k
z)Vz}0{w4;<Fn01<4|xgMVg@Wqr7cwtb0xiCGv><4Vo>iqpXXpiK(t=d;4^-kb+yjf
z=m9FDkZkT|8mBW#rkNain7^bZpFMcZ*{#NazQ#@L$fwSru)V;TnS=O=$A-YW>{8px
zC4#2Ar46G8*5maRMWLB$9xl<6cJYhRzuX^hFCo3QNf&4bUa~81dmX%&s;)4QH$Y%S
zYD@C^nGnQkyq{qAGq_d^mmvA-H>orI@z++ZX_rOT59uY<uh=Iq)Hjhg57ppstUrV7
z0?fhXLVFF+5!F-rW>RQil7>F(BOn$a7)WAR-GQb6=+Dg!R09Mvs)duUZpU&7acK6(
z`L>hemHtbXy=qO5?)Eb2ful7{6AlslA2&}nH<M^{%y~5KCbnbkJrIIh%LygE7rZ{-
zba!?Cd^u1Zx@VmU_2c<Ea=XTrj<@c=H@>ZS_w#SNGW&kJn<2>#r<-{PN?nLO4dXl4
zU+x}<zQ)Gt^TPH>R59saj5nWtznC%5xdzCfM~ff;BZu6$(W~Ics!+dWz{vvye(Jak
zA)p_DvawaS)J-fq3@;%Fhr^w*dbWZUg*wN;ouMZc)V4qKR=_;E1vJ$LAD69wilC)y
z8R%Ia#$@{y$5cSSut<G}(<KV94!;Mv;1gZWJ9=coflP3I(jyR#>yV4@B?MZ7olS*o
ztH32+be>e5w`n)i=z5*yw|Soq_4~vn4yAr{PXLioTVA6N#M!}#C)Zg-UvKqbT~HJ<
zvvUmx-MREFl2&JWm$4G9BvAPK$`xl`-<U(U<lWxhGxINW;zJJZvGu>fY2kF}tD1Q7
zR{CvUm-=(Pbs%`QX)1m<{J`+j)Ap}bS5(daMm8Rw@Pwe0<l(&#bx`<vULO*`vGcTE
zU<5Hof0nr^DtITlfOO8!t-#sMk9a&*_qpp)Ggu|0`)etbSvUSz(z%O%aXs`rL91Dt
zL&C7G%HBioz7G7HDA4c$FKn`jCH>a%ui)<K%yZrgl40KYVLYIM@OZE<7f=e(AB?l{
znfuPE>=e7o&v2E$TM;OhB0zo+y&iG|mnHF<9ittxJdf4dLUL36fi#=E<jq9+#61Z?
zx5NqpFN-H${I&l8+Evd)ku;C`y5#Z+Jh+Mq-T(rsUyV|9*Z!y)_fSzp6wuMdo7&Nx
z0nr<N?AEp(-GiBbP6(*H;Qn#Nmh&UuZ0RFiSKmqB?Q4Lr%|G`EWFA!@X;_9bSLq0u
z(^VE)*l%ni)Sr;y%^#A09A1ZnK)0=s8h^p!^_l58l$}$vA^Sv{=Zhra?1$2CYf3)H
zBOQe2=T$nuK*BfI&!g3gnw<dgp%4xyJtBsM+Xn)T`~MyMaEBjM_yk9ZRLlttygbr*
ziGUEqkMkORm+_zdeDl=&Stpc(2ze2GaJbD!WSJO$Va^cROJErR*79D+nRko9{&<xf
z<ci3DdB=|+CdF$!{38(2JYc85g=lXCjY-~UTIU7~%|o6Hz>ar{+vM83$+Zd+f+Zdo
z!6xN|WLv?{JEO`kYM#^&&xMKpda`h;R!0f)Bo=TCa^fHIC0mKGu`?9FR`b`*X*j;M
z=Ad1RFJe*gkpdQ|k-yfeK_3oUM0y#o-Lva@Ep8t;W)+eEIY%C0mx)*uoRWzw&MZ8e
zt8jki>;0KWc`0VX<;%-Kn=#9Oa_dy)-MOf75Aw0$NzuAmzTv`gnq9>6a2jMq{BVsw
zqQ>kms=9TzFM#3_=8c@BiJ9K@#!@mN*ZzN~8~?|VQ#03?LsHj@RFThIYW*o?(NhK;
zk&+6~9Jw;ngY?&u7I;o<C3sG7kA(sf9O!v8LetNA9@W8to{`L_J#i7cp0dm!v(Se0
zAi3u71!S6w$!{zV>-d&_Gk(QHe)lWuXeJpLXu&adpY%ASiHPkFkLc+vw2GsUn=P2N
zs*e#oo%Gqgh-o1UfE+P8@8)699r{NT_{L^na8sJRWuT2`!~)BH*;q6jNP3>8Gxt9i
z&=6$&nS(%z6gYQJ6aFHZO6mUmSzXYN{FT}w<kTR5QBZ>eOGOytiLIy1a-J3o+ixnH
z2}Q&AWitQFtrQ_u6kio~Cl-!haJVDu<Ey!!iM2-N*+n@TGZnPeM-Q5($vdD!``(Th
zb8nLrFkkh~xO{pyigh9?1eNX3uq<x8Tl=A)S$Z$r4sgvy1vQ?n2$8p}v@q_q&B4O)
zss9gSZvqeX{{4@)rxa<KNk~yr4RU3fgxeyORIZXOLK#J2lznL-ZWGc%GI3M1k!7Tm
zB_#VuAtLM8vSi<v-+8^?GidpI|NqD1<~Dl2U(0!&^E}UU&g=CWYdNv`KuXy~@P4Il
zleeMNAEa2XTSksS7p`8t$Ou0rP$*bE`j|JGQV(Z^$B}>FApR<gZC6BtvM=2!T_+ND
zsmAj3g<*8jT6K$5stcrP(P1L}5%~Gx9<yez81;lKM}e_w5I<j0_tYj>v>*kx;s2$d
zC)sU007Ia-pGd=%PS-E#af^;_YWn$kYSjMu+IqL(S=XIVs===Q`_YT;&>7RndKM_f
zei3zqAZO-k#9c&0_OF2C=0+a`J1{FSwcvICz#e<h_~Z=m0Z9xiA+dS{!T)-jbD_=9
zKi>55<dw++)Jz%-)>4=!=c+qEbWohxl!qD<&Hs*7yVQ0HE5*8dw&-k?bN)UTjIpMz
z8bX98@s05NiHR|l@mH3kMaxDWMwm88Q$nQzKxVTjp*OBxRF$3M(&L#ywsM7^nxA9Q
zm20OTti1@6<RBa$pXRfvR68>CuLq@fANvei1Tkxj-HGQp#g{aEN({Qaz0J5NTKPwE
zQ!dCJhg4l%9$Z$_4x3Hj-?!wo+*I4Wb(cc0iBIaAz84W_&tUx**fUssNT_Vi$ZYgF
zPJ{(@kl4O2o6HF#vFUELS`o3*WTk>SYcHfY_w0^eqYw<29&NefDgc*?X8YfUn}F7d
z=n?1|VINYr9DSt>$x#ute^AAo13UP7tXeR=VYqVOti$FrPCvdrgp;DS@W1+lQ}*MK
zi$X4MZ*d6)^>sG<eea@%TObFa>{utouz_byF<bMbspNl1n=gFG7I~z7yLacL>58nM
z(DZv29a`nye1K;kG%Ztl9@)vfvv5yI0aOEjM~E}ye{*u7-rnYGtxM;nqWfY7TpP=j
zLfx!ATT)zGA+Z5Pn&2v%Z42`6i}VrPMlryZErH`rPl{RSxt;+jv-*%jDl28b!PfH5
zTC0<$)hQP~-)mX7^u1O-k?1yx88m4poLkzxqOW=&$dqjL4Ss5VhAJdorL;6b!y@9A
zdDLB#$Evki(Hv#)K?=dgSF{z11MDOh40EHk_KAom=L+Pk&Ayf_&wjBzxhcf!$J-w*
z&K-^`G2Bw<3$)&NQs7~TZK+t)>8~Y67CJPvC=F~+N*rn`e+^F~&3~usF}(SxWO0jH
z)RK=8Yv08`f7<x(oyP;;2F~+P;AcEqMM!L8v=U6`vj-q4T!o4(p=f7qq??}Kxv{9e
zts@&N+bo9njXr~IobW>Fkt?uU?{VM0!g1|=p<_qF5~5o+EDP+@I;{c!N_ddAY8D*j
zYM*tMAfPjNgtp7*^PzyzFK|-;Zo*i62rfVj%gO@t!8Ebr^zxjSL3K&XBd(MSW$GiW
zf-6nY^+OGRR~$ICSL-g1nf(#)fZ+XxFEije-r?5O<}xMvH`32<dHe9p=x<Oo>t`tP
zDVHb83N7M3pk^GA7QtTN<)81J4N+JjD@1x=wrzicP0Ulw<<UMa7nt>R`*Wo;+jKU*
zX%W9Ld<Ei4eE3M;G4#d9k7_>vYN*^7^mHTKV;#1m_JH2!;v;CF;HDu~gkaIz8^st{
zRLJ(x=mO~yHsYYdG3Jbbex2EbbbSFjd#nZJUEJZZ7YKaK=xqG9T1=Pa1mD!o_#9M6
zgl_c&>7Ww)k}Vsrm~E?m9}e><s;h}i{igw{V#OiB%vW$_&kUSxJbjuCL-v^uUXwG3
z)_XmNFSnfcUWg53o6jBJmcMpwN;TW|)Zh^&lINdwJoAtD6P_H9zkg%}>;=O$=gcPX
z!@HLu4#ZX*J_Y^v%jXp=xPl1A;yDzV?6$oL``1X?eP=_}4vl!Zx#0t}`)^pt8?$qR
z0EnU15tr3)D?osFKtls_7ZvI^cSpe4Al#8h%gL629|U#>*KGq=28L6payZTO46a9T
z6ERwZSrq5JH?t=fp`nDc2>HduM>sTTlLKe=GO}<hF=~o;-_jt+FD&KL+-V(=^tJd1
zhzyPK-aW{!;dEiHA6#~fJkWfAu>Y@n&GGxrv3t#TBb5dZfUY~o?>on@L7#rF`TzO&
z|9w3=M8|K<k0>q8E~=T^b(#2{);pI;w|viSxJ1gESaY3jnPeVe??xTDA6jYG>yXB6
z_}U2kW#dUv`L%|fmx)RLoyrKhRp9AIJZgw8KI!ht5FYD=d(5BK=WrW#&cdlxwuUz`
zsb;Q}xg)%3TU)QXOf9{(jORxtzQrYnyJ@Zz%uvC08Fkq#N|Lo9bRlQC>mt^0flZKN
zy_5f1y%kTo(j8|q#Ydwq16e+|a}JYEOahV%hb?U55<9!Xa%oO#uVpSs1$?}h!EK!|
zheR8L2p$IddO_E$B`{jB7jn75phHpSzA7)#q`f_DgXjYFbYN)n;fBVG#3Y?nbdA<k
zbD1+{!eC}mF2b)+51|dgbW2H>B=5d3-re=83k{EuZ#rtOPO8aFs<qto<%yieg_?Yr
z<hh+mGv>fdfesv$BPtu7w@>H&*F0%&Q`=y3R<)IaLmF);O?UW<xb-})cl>K+P%h4(
zcY%-?%C-49jp<pmVbPu*qtWiB)WK8bo+*4j#Cj*q@!qG3>D<<(5@F#rJBPlk98sSQ
zvrn>KRyTJI2o*>SK7DSftM(qmF-Oe{i=KblT5I01H=%5~l!NpJ1@(4(O0(zGELt*S
z7AD?#Y*8RNq|t^SetA#pzd}sfyNvnl#O4BvBPCK>`X^RjLE^h8V>n}$^#^Y7zL*r6
zztVKn9Q-d6HO>iSI7kPGCf$8bblo8S`TR`!O#DHv88gwq)Mw*wnAdYj{nHudnC^**
zSa#$0L!W7z6yA;{XTe!wX(WxHU^wE;mfhGpT&LQFPWxsj?Jc0y&X;oV|0@7^dZXBT
zZWzkn@3_${aBZ^p-D)+fCi8}25~{bSp9(h3Di*5Eq$V{Jn4gmNT$1^F2Ge0CtSN{K
zR>qXAvCogMLJHk!vdOyigQrb0z8dMcuEKMt*`p{B%1O#jaD@3j;C}8{WEOO<v7rQC
zWcKpOz;Hk~aFYSH>RW9dUC&Os`-Z6Dd$P@+cf#Ve6==$l7?P*Oa+qVybx=h1G6bw<
zFT;C2!~7gtx8i%{FvjR`=Qot8;>E@mkS@FMSFx_Z#rlLO6+vC*1bJ@5H@)|rq|#0A
z_=t5J5gO|50*i{^qHHvHh^ZMU@x>WSkU28qaZTekJWxb~;y+8YM?_E~$-M61Ezv@-
z?maIPL16N0HwZ{M%tWgQEtGGad?$})Up>+ZXE`l9RP9<O+FxJj0R~jyXE$clB~nTo
zpC|Pxb=vz#H+^PNY%j@xF@OQe^wvGJ$m|Msx9T0fcC7m{aaq5}_GhtQo_tM37JX0-
zJ;XM;{G1Q4IAQKmklC*$yC*BVYT2=PvIPVy6dg22R)K89tosGt4Zj~ONR@YT&4j~7
z!8dOCfWgjz7G7x9SW4phF<0uJp0IyKYY%%cxxYNo{_<o=;^hfj2d}N>nHHdSKfg1~
z)~TVv9zeGm&k@yXP_(~mPS$${FOdR$8Q`{-^Ykpd4{(szE27A3_;F|MgroEZsdUX$
zL5&eMLe5hx2aN*>!q0c*#WlEfZ<2}=rTb93NK&7=L=3h@j1FELu2;EE%&5HU7`s)f
z(KQv;=^e})3<5-7DfLcwKYKi6p?9>W&U}jZ1WVeqOeVmNtW&*{Iig03JO_R=gHoS{
zOvft6@JRUVxXc5Xf~Sv(08GH|a~j21U_XYP>0`6#eY|XKJv9HM;Ym}tN7}`MJH(?R
zX>S(oqknPIYm2|TOb%jr57P&=#dH?npYeb_op68}|GK##71~o6EB_knxGuK&;HcCk
za#ZTOk?z5B5iOZpd>_@T$_@924VhCbaM+qX2NoQJI|GxF?pJ)OnMujwic95Kg@v>j
zu5EVlUDAR_B|$A-XvStCd;!g5PZu;x>x#^VVD9ST<R{yhLEM1h|J90nwQBW<R1|g^
z<)*$Ga^y>)IJjKx3j1yVomNU|EAqfZ6v{y}F-z<q)<jOQ(cQdG)$T~JGrF`Ct}4Ik
zd%Z!`E^VQoyQ7DsM_^l9DzlI_T==Z}NisL47`CM6DsT@PG&T)faQXWY%eyubpUVw|
zxePt0o?Iyv=YG0lXTSbJqr^E<xfGMeor8NXTYIRHwtwvd(6vr|k{;JM5=!P`&bV|7
z-9^KeN%>*+@(UXt@#*CAZz!syb&Cs6Sa0>Je+C+p%iF`6E7izStsbB?RzLaf#<!Rv
zeEjWL5$xIq2ZIEK&HA0L6V_1h8=`S@%J-T79(UCIv3Ja$*U#9|!&$%Yb@nFW8`s_I
zFa?JmX6u%KhG1AOzm|=)a%`xIy+?GtE=GK7eI)Vlokv{B=Jn}kd|`bsg*4jAk4vOh
zYz`MFAE4rgtJo4zlf>n(@g^?n++tY#_HasefYih1<aA6I!-jtEOb*9I|9ix~9|1z)
z&+04Tu;+2EZ_)b?puTkCkTai&Tp3P8*seX`yJ|_?x}MIkf4Pqudic$KLG{3_IP;9*
z5mzYIA@Du7lZ`Nz+i}k+A}f`fbNNNm6Y5%*CNaa}`oGwQJ`a3`RHa9y2QnkJy9s_s
zJSw?}d{053RdpHht8-DisRsIIQo9>+F$xGL*lt;U0S?pNeI|Fgjb0hvo=C{`j3d^<
zk~sLM5I-jal|rs*N>*@(ALc<o^Nwx2GOV=GJ?oj;ez}<qZFdlV3c&mqj2<H!lRP6O
z+=*{n99&qSoU87CdmsioBPr?9P@Qqc&_i;&YqKZ1Vm?_vVFPMpxZmX908M93q|xe4
z70W<R=$6nN7n>jT^@uM9ixQT)=d76;+85~8trN9Iex#zGJK=UUdBm>v@ojgBAZ~mP
zzC^7gqxegVPM&|zQCB1`@SDI**h;6!majnU65W!zC2pVP9`Z`1|EPN8uiPuLod-R3
zb-?8G01Zw@vtMN|O{6=U)Fi5DBsJF;`5$-W>&Q8yn$;kBLqZcARcDxrRDfgZlQ;Gr
z7%G6GReHc`A-vW7GHErDaBMKgv$5e#ZO9QHu@UVCy=0<BRVa?^!6T}#3mc47mqoX_
z&jz&x|CqP{NH7MZ_&PN0?0LW2-BecU8KH3#_~XmOT~4v_BdR@CLW-Di0Zl{*SPP4f
zaihH@v|>q@=j2cJw)1dnYIGJz@IU@F<^1W9e@eoRme&WtMaXERwUbaxE(e~yvd}X{
zs6|fq<9k|X7;=3kd!+(gQqAL<G-^oa5e1l3b^tBhp~NTe-JpB8LDf;$1dT1POXU8D
z>Mf<h(Zz71#GM6y>c+a3R$Uk;S{okaa;Y9hE^Q_CkHuW*rQxCGTuOQMWkhBWW1f@)
z0PY7nV_CJUhY0VTih!s<PaQ-!c^52r%d$v?qd|z`dyc@@^00LnnJFxAM6>FxvB+w#
zI7JvUnil@+cl=lGLu_GpGB@;-TAux#bdho=wc(1*c;lZv8J(J|FeE|5kZq0xUP=qy
z^632dDhHqwy-lhm84FAW_#!$~%l+2|%OES9(a^tyzk{+&d=BF7)6C>Ex%{f*k^7+7
zxuN>0ud^_BG?aZi*?e3X4fA664d)eZPTuB6f6PE)<8+H?opoIJl2sRK_3sgnDkubq
zK6TV=*xROvCNd*;mxx~559F367l#vM*lduxCoj_5wD+E2JP}ugwR{qlUSjSjyqN3&
z;}f?e?tgs3U41io<rhr6&~W=e=coQ~my0qR1lT%;p{cefqxfLL`p1iacN6=3-$yJ(
z)9#!l?#G=A0!CIa30I|=54R30l;>V8k+R>GuhR%o+Bc`751bybflkxHg1O8$O69pU
za<SCSuP(14pwgGpwtdv5zVd^V@Oo_FX5_j$^C|D2ja&nVOCVC|pdiqAvh~MS^@-c+
z?GVN^8b$`}&ffF7*Xj-o5?}Je9SfNz)r$ew*?nU1n2$}|or#1TF4|y<b4Ot+{K;sy
z9IY3qmbe}paPfXFjQQ-rZn40f?EdRT^c-s=EKg3%0(;}EFJc?|Y))+cg9`~8c*~<2
zRc~{R7!>nO_6U|^nRF{^+%>%mPF@Y^6x4{R++S}5A>sJ9??SbR%W(fk=Mkr5JsN5S
zD&>PhI#3S;D|k%u?P(h~yMqH?xB+N5#1Laj7<9hTZr<D9`C)keb~*b?m=Pd$g!CQ7
zY&cj%%%JQFv8<)^8Fy}xE35~ZmAK?2WN>TCnH)#`!7vsfGQb%Cv`~J&Ci449i%%)7
zC+jnpCOtVM&KB&!@}I_mIVyo%Gn{gx(IXljhYXrM6J2|`z`O;fiw|Zs#^RhCGl9Qw
z%;gxUf;ybhm5?H?*7oV&pg;6jW|VK`KzbI(gb)8@=Yac9({+QjUL>cLXY_s;>u7;E
z8)+tHB{*EMKf&HwB?ayR9wLp4Xt-F-?&kRmai{VQ1C3%oe|Mp{U+dhThg@D}Mp1uZ
z_R!_t1$er2+vLMQKR!WtGc^sEta|-P?sk&jxm^!U%eUVFo9DDV{W)0De-<A0vNN0K
zQIHSUTTiv{X#nLdPy~bz2n?mq%G%OAKDSY99>uxgB*IN#VlNCpo{jcCtLEJv>F4+k
zPW+#7Z<TU-2V7KLd>zPS6<mj-|1o}S<FN_dTAg$}wAn26_3cL%1NCyf0p^P<2j&%K
z(ZkQcH)ipVixr0!d{)9{d&E(C6bnuv(&f+|Tsz;DJIwQX71YgTR9@9MT)4?E9CQuF
zrri_v979jqR)}udewj^X<R3h+oCoo?XYk=;IEBgpiQw3Qqdx=_<w^I_P6Y?6FqxbY
zf4Be|eYX@sQY^Cq%gZ5ChVl=TQxp;PnX%)ZcRm6oaHjx_o#||LVY$s(+o-$pRl%6+
zz{U`4gaH?`(LfQ}Voa6o!XtPo4FgZ($Sywk@KdaI#!8-?H3ubQ7O|Z)N6^kn=`XgY
z&(+G4fADOVaEL=g#i2oEV~cY`%L27(P!cL^v(!#vZr0;m&+ZKY$hg2^46S<kb>hMS
zfK-%FfT6PKPq^!{Gt`fa0jr*WaeZ)g(6oaY&&d5e>(sB$p0N(T(t#-h(i0I4sff7<
zgD0IF*hC9|Wyy}{iArT<8@DNiQU`4TP-3e)kUG;C6u83B(C-lBb5su|yvT0SbYZw3
zPE7qH4&Z-o#ahl@p|##t>Bx=g?FLVEV=X5~_i=vxT-iQos>PqX!!U39xKLEf?hY;|
z@<g}I=c&2o7z>A1RBt%gH7N=}_Gw}O<SM(SRGBfyETaoH9j3tT@;%Cv4gE5E@VCH)
z*pdJZk}jJj&)}u#i`ITVv|#7`R_UXu>$%~dW^qt%>SImhA%#31qmo^<xuVYA25rrD
z!rB$LdJkdA2CS>1JHHHA*M6S-#`3&9k&86~PI-Ux8t-4{IVC#7cmRl>)-TvMt#AI9
zsgbhbp0l8gQyJyx;&f+U9gC5XrxHz*k}|3Kb-BA%4aAs<x~w}c_u=a;o9TlL{dJJn
z@0ahbjY+8XVjB~-Hou5WK!EwIjpS#!;8Pi&r0$!qI=CfsFdjK2j<7`*D?I<}Lj40<
zXJ0sYw}-#o{p9hn;yBULtZ5Vb(D%#KM;`rEk^7)%(-p0ireoQ0HoeVX{8o=S2~WvC
zX(jF_aqR}gsIio~lA&4ctH|2hwBb(BD&O%b>_xQZ7v;IX=$wgT$;#HpA5U(bAe>Un
zngV~6^!vqJy5=48oS*k_XosNN*7Au))5vM-*4s4QtAI6?K2FQyZwZ~0fx>vr^|YzM
z{Ny)(HNHq^1&ecXTBd%Kw*N~$`bSBE-IMEmnV8{>B85qz&!YQ0Xt{U0aat3@OQyL#
z=ygvXSWB&W=Ve&mS>WhEvcR?1z{G)lh=Pa3e$RqFz{Nv$6j>0Kz<1bzCGgjvM`kkb
zweq1aOFcuv$_mrJT~$JedAqOg0XxmFUGuao0Gh1x#P+vm0|P^?DLg!6QvTd(bd4~I
zjDW^Kc>rw}qt;^m&VkK;iJg2>4m)s+_6M(vMrpmr{zIIYH%ioELj_FXSC||$#tYOy
z7$^x2g=9#vqtU+84SX%Lf;2KD<u-)U;ZRR#LDz{j{@M;u90(3})I<smkAABjJ!%YJ
zg?a@Jj?7?Q?EVCe;i?T1c?ZcM4yM+$9Ypt~I$npnv*5c+%s(&Gdd!=v4uqFu6#(3m
zFB@KDC<cuc`K4A{Uu3NRzncy4qnRJYzUcDXc$KNGCu8dl$Dm0X2CdfQgEX;G&1445
zq#TVox?<L1HCqOp^L0dDmnNrj*sy!*5u|@0Ufe4%hSGJDkHUz@0DI>*BpPz~)l(>n
zu*oUA>3<el!Ck-4*M1$Xv3&F2_EgT?!9`&z4aE}nRCQND)PAx1FDbUHXt#kVV5`FB
zc{3;*)5<$dPg~3J9uCR+d1#Y<X(qE@Z_$O9(vo2ki<$q-YY0CMW25yZ4>k!*d<nS%
zF|%gFEY$UEc0~p9=GdN_09Ga)@dwD2_x-(uHaAJ9fF>r1^3<>m49_1y8VeE8ulf~c
z3%nb{X_yFmI!#{c^GOZQ19pKu+;|cRm(4RGg)M^rJ4(9dInf8-#@a1yr4YPK{E!gS
zp~#E){M$7L>2*sw!;*>5g=~=xfpVZknL<6P4fJ?2mW0IdjSRl+Zq2Z-aA-Dwt7eY;
z%}?(#d0DYS3er8ogwC)k+PT<BX!RDJgu+WBC`2fCkbe*;>DmO}iTYGt!Q-*z*0h(K
zxbyyoAd)M0LdAKYhg$C6G?YAk>uYh?VOh~jMA_bt&(3)GG~f9<zH)i#0j>Ck-HSw}
zicfIcC!Sp@adXwC9Xg&x5t^6xXIMUSe#WnN>VTg41JxbGJ?9=1?FLxhFAN>tUs<`h
zp3-xdc_ZXnezy1Z9#Q7Mwsn0CZ<qL;t8xw<NeQ(|3Uy{G?O?_<t1&+q7wK`wWXGC6
zI2F~<c7T-4PZpiSTEtD=!;D!&VOdtFHkUUUrgp5M*nG*>^?6b9WF=Ygh4=u8l1E%i
z`nvJ!5rWmXq0T5pVH4>Ku~uv6h&Gx0>+mu=(;RDxf;YvwO!sFbH;}HUI+5SLvG4if
z>S%MpQ8U`8!Cm$qUFg{Dk=u;nE-zI@f>vPIU$iav>sH^&Ov*T!=lQo}fcx4RXgFwO
z6xMaRzYKi1dWSLpa^GQ<LC2DInOEy5YJ3fRtVOi-^L+yu-Ww0xVKCyFcQD18>e5`s
z;~vL}k3Sz*O}v^N(VA(jdjmC)%};=~_-4Uh6P8|XGD_+jrM=1(_KCP_u}5e7!q6?^
zGOyNBvX(X|H$=LP8cX|S7H7IGpsirFJt75YmF-~OJi2By>3e^Wet%(@+ZEgCv&BX_
zlA{YZLMi=tl>Ty9kg9Dv*w`Fa$)Fn-`O)ueWa+$*cHBhKIiU1+f=A|=MDM_%=9;g|
zc#=<@vyC*!*V;OL9k^z~#Pt`zp=C8L=KH#4>ebAp1Ph_pIkDLi+tnrctvd|jP1h3D
zsj(et1^(FdxbW%a%!M~C=4^D0O<$wWqtMZ<&6_tONENe;YOowin?-V3a#@f@4=|2Z
z;!e~_ProjL%lC>O-FOF*ck4dptc2e4Uq5zTUDR^SHg9JF+-5%!p>~_`GQHGKd_am)
zKU(x@Vr}D7QbaC4Vf=1ZUFDP@u6i1r*ugB-X=}<UFMe@p`RY^O4>8wLWQ`TQ#D!0F
z`gE%0CF-(L=3Ip5q<OF<4odTyOU~FS399#*IASfmhg$lW?(;6JFipNuSVHH-rMZMA
zGi+!wgE8-Bag*=|9b|4<DfNB2kR_n_D0qAC0*CL<i-PG3D*CS!3QJH-_|E+cU0g!K
zVCC0jT&5eZCF+0{*qtQnZ?>!rP@@!O)ZC)k#&}yze^6!+q)3I=^aZSk0yZ|5UaWAP
zEB~Y{1q3)xm|zjRck1zUvrZ6M%nfc*c6k+*5PCx4WndDyF2rlYX3D@h!*6dLNo4K;
zM+40c_fDT4wLBYLkBQ)_)!d0N38aldX%x7AiHgR>ICXdS*TNswQEk1ad|qiSPWGWU
zxMg*2_mia5dv^~(&-!uRR<{&iPmUGuoP~+aR(gKHvp~l4JR1CW&u@L+rv%C3;U?i>
z7Z9cRfXd)#(dD@W9ge{H$qX)IkScV$?On@0N3Dj4@%WTMi4`9|Y)H(y|7?%O+%l~O
zsu9_On6P^Hkl+=od=<Tbo^&Mo<{(U>*Xg<**ji+lYf}SS2WKsTZ`0L1_dHA|yH2^(
zxS&0Qu*q#~S3Wh`#p&Y96kkOcLL8lopktX~QguCjrzG33m!K88#ZB#h<R@-RysWRz
z%)O?q9jjn@I;+rb=u{Wn9Gjd@5ZCd5*I#Tky_6|O%59xXpknGEN&&gRnkKHHSmf!_
zUR=^!mO#IJL&jJ?JzZErLhe}FELtfkcR8#OX8dHNKbPrXAi*M(7NW_k%8uKhFh%pL
z&E4Zk8$d)+y0<CIe{Vg@pV6H>_X*iSOSs_xvZVQ;Dtce}pm{senemJ7Inx0>gOwE{
zvLX*MsTEQ;7|E;yWs6eAZIQ4~*qlS?<1cfiP{ad$-oYHc!8kH^c&1=Tp*hv8bLin*
zZjx`Fh+r<KK{P#h4D{V1TbHLj;CPQ+`D$wtjZDrvT@Hs_<gP?dsOZJK3!@NN2XK+j
z3k7Q;AOKFdLq9wFwLDq9+PXfwoG*hguj>sm4RxJJXSl~Q=5B77Joy&QP3MvRw_7+m
zu0@Io!*AoFCipC2b;z`L-rGJ=7u8y|hv{*)Dw`%%6<bgv(BnrS#V9PKxdHgPQT+|u
z{zdp~*2y;unI^1FgwcM{QvYu4l@Bc73*IYcglwYp1?okeHrAK7O!Uz`!y_!{scPjO
z@4-{J&aEN#U7d>&*SosciBF88Es%{Oq~?qTL|M1k<&(TYLEiF#q>Qt*)sm@#7EXmN
z6`Riw-^<r3{Ft85QIj_&{jtvC`?&eOroRiUUahB9HkNMWBkjq~44__BRY}YqlYA=q
zg#peDt-#K|nSie{53_YwTc2xftyFtS&Rmc@y1UPgN^ttVx#xcL#2YJ@kq<sr)!8|R
z9kdqe)6$5B6P?wU(gQGKsH;{Q-<KQKc)Nm-xOc^3nuKoe4chSOtC>MmzKICgR@KEE
z=QW3QeaQ_OnQQctv#IwL;{$Io2*j&8+}5K90+LqAQVG4Mj)U)QsiAF*U+rQ#UUbv>
zP=M|u_ptaAnxYi2matHR_**h0C#LF<Db10Mv#3d!L%ujQA%tG=_SMtJeGP9K)fq<m
zPt&dZL&8E#4Aq%jX@+RIWl7Ze!?ypLr-hlVIuW~=wwf9nKsUCDG+?nT7yLHLv*D-u
zz81asa)&V}`>&Bt11LLXl?!F~VK}|oi6HH72Y$$ql#s7FwBmzFKL3j92`aAC)IH#S
z)~=zLEhks#Gkq`Uz*k5lzDauhCaLTgleDva9$3tGDM>A}*zLr=`CDVlu4V=#K1sBc
zC5RS2=^T-yur1o-BJQ67SIqS-()#tZdme0CyJe6$rlvkr_m^`HKS7igHoDN%cu!O&
z5DcU&$XCu`<%1`4&DNbTnwzcEB$E@Qnhm-hGE_{<BT-^IW@?apZ_*qEK7$+Rnbfg0
z6zDHVleMVkR3TaWU3dM$;57Rb6}?XsLwB2?hD4o#i(-VPyP7(8HCy9Ac@Ray=Lvdr
zmS$(jayoqJ-j@y9@x9gXsyx6>A2E;&0xsGmnH#-@V0MK2H~D~fw%E~Ow4lOfeyBmQ
zO5t#HHp#f?U|vi!nV8qGh&%Ca?r#(G8<G9AKI&!1`#Tl?J-ps;5qxYr=}gF#7=D)~
zGwHs%zgTU8B&QoPr2Hp#NJo~*amESj;XL>y`?%8@r7gvJPM?VJi`=Bh+(hNY8ce4A
z;PBAH@K*+;)Ytjj3AF?1Ve`TFWpc6AEMH_d$QHQ?FL$5raK%@e@s31$g<JFm`c_w>
zn^g4r3o>ug@{ohp=`CcBnY0u0*sQkakH>EbPc&~(8P_Z*m5(z1Lht=nNSyUGCn%;*
zW^j1)VR)!P{@d4!0OBsGPE2;mhQ`$aj3Y&7ZupTXwL$R!=@s^XkEiyDd>0l1FN7f;
z#tO~&Ft@aZ;&+STx}sgjh-=Lp(M2iB6Xq=vL@nN4(?1Vx-!-|T%Rel?>@b_(Sh2OH
zwcRg3nT^t7zoPVamgT=;;qP*TM=d|MZqh5rJmz^eswsv(QY=M@AAH#0jr=(&W~C3C
zYfL)VQ`Z7S{CKUxY4(m<?f0Ty23jV4+qouvb3$oWak_R7Juqok>8aQbVTrLO)WAEF
zt-p3%df4M*S3nt=%>8Xvd&;$haJmm6p?4^C_=EE;rv<dL<L0N;9tiP~Vvu=<zuPI9
zaFR`wU>N{N0n06wSbfxh6xB1^#)n%gq(*DniEc|K?3?|n9Y*}C?CY(K6|-t88vO!H
z8(<Knr~HE#>11c7;Oj9jRFw;11W@^?$L1`{<K$%tm93pE6eELy5n-3^@%f>aWSm_{
z=+O5uS#@|Y!FJ4e|7Cp_^Q;128#y;LUMQSx&{NuC#Po;~OnB}rAKme-lG^zags1~T
zq`lPfV1j{DW2M-@1fqob1R305^xe3{C<Qc1UYz1TVGf@6CGPma4i^NoU0$NXLwb02
zhN?zhpw$yKb*4wVIEL0BSu(9N_ZA`wKR+K$50~0K_+#aP=BIju*}m|dlQn0TYn1I-
z>7qYg6lW!gz1eN7L1KYrV6KA-3WqcunvzgG8*;;6##nI}+)oiT0<ld*N09qMoE9ne
zT(ZDErrzdzF+Su$<~_8?vuJ#rXF#^_i_7#rAF|Sz%cdGPo^uF)*bQBWf5F`9B-3(>
z`J8u_<wUOOjbe;#USm10ItZ95bR&)P$!WY!^n@Xgg27Ic>gwY_KxEL;!d&M3s$cyX
zf<_{;Rp-PzW|&F5tF3#^iu8&pFtsU7vwx3I=l4-m-Obput3~W}m))+snOVUtHyO9n
zHFfCDokE+5nCXiG2>@B~yAal*`EpZB=hv*Hd~J2x`X(?;XuYKpBl~Lmeaed}$3~Yc
zytqtUQ3P|<b5d%p^}C8zQf4f1za&>h@}{@vrPtiTpR~cHw@8_`1Q&3tfOYah){Msk
z^x1+TE691VT*(?`RMMgpN3TV>EtqL?B+2iBV^d_RPoYYx`>T(~0*UZnUQy|G?Ml(?
zavNQ`RcC=IpWIcWgC{{{!q1bOP5?az4u<j7dBWgm(5F2&881H`Tyfd%nq6f~Uq*Tj
zHz`3FZ`>636H_Fwf3~3L0mVu)iM8S?+Fu{$lxyl--!gbcCsK6|HY2vGvtt|RCs=Zh
z#Bv|H1jV?sT@jCX_L!m(5HNGZRHof4akMVtuvUB@QF%Q@9UyvK*D{C)$(#0@ghVOz
zu4`*vgGgNGBSv`%kJDk;lTbB2W8g{vz3+nwEA5zaL4vG*=k^RU4V_+q6wn(1q&LRK
zo&GW;7HAT%Nsl$jUV>i-1K{^QTLvQ{L@PgVNG)4Z?8Vu|{G?tME@X9g)kBHUX5zyF
zB@-7uuS!wh9?y&GNhTudCJ+k;&8yx{IK7QJK#vf0eSaIm1Y}B>y-mr{clPVXU3m?D
zdzro>x$}%PB&jVr^8ZWYHrK3A-_1;*#QKN}xQwAe|4IFaXD0=0xg-24Q#9ld)5%nm
zr=p}Gv!p>)kkPq}lt8iRz$|nngr~s8Zpd&nZuVWekc{Pyq}4YW^MkpS)=`S=cIoJ_
z;~~uXnswqvi=d!<4YmL8qz|_loz9-sUq#koLq<_4@?W$i7|%t7m*B^(AGtA>o;e{j
zes;8B2C1>-KUHrmK!S(a$r()hhG$pS*&O#sa3{2QZb={W2z^Y|=FxZYUdBzVc#ozE
z_IIER3ons#gfpDfgy>BTtL+bv6-8(|&r)tP=BqpngfGOKnH<Yim^z=(Rhwr+c<``L
z98)fgRAmQEb>4QJls+@}DK+5j?LFGen;8#B;vAaQ7x7ClxPmm%T9H8{2&?!+V1So0
z%c%WdH_J!Ab;&iRWt|=HhTOqfojLpV3(IHkFA$9|;(BtE(ZOr6TAC=zp$k7dbJr8+
zB=*S~E#Mg|z0X_yrl&Ts!BU;D<B^HdaQA<PA}3o8nGkB-8ih*Vhp9?3U$LXv>Bzf-
zIYW#x61(?hq|4tjr}&I^i}L78n$4^3#}S9)r&#$Mwe6oV3dx`sBarxV?@#<<lwvdT
zCPO{x#k%&s*JEC1r3gD1pRyKvN!j{2ccj@z{)CQufZ^gQYndD<Wv}@<K0}oi(f_8<
zxJm|`9WzbjiT?2GwR&p&E+cW?QWq*jh&sJ850SBAbPci-;874%WtTf$w18T^(u!RL
zdzNU0?s`l4bcKHZP9`62xpN6wr*J613>l21P2pnR-JEg-()Wz3xXU2`9Q*{PimPf;
zhg*b|6CQ`19ncooVA-X5$~O2f;Eqh}jm$(mJvN1@!G<H7G@A!+o_{dlBsP*;9<aYy
zfJQA#ph!~z4`7^3oT5Sk1am+T^3^Q*c4euAI}faN?~J-^QooSPPtIw|BRVfF?%kDr
zp8L~NAuHW&(GXnIuNm_hnZ+oZsq19pBVs2Ku>crBL7R=a){R51^`2S%uR@$o2O5rx
z>9<A^3}Xq#c?<XnHdZo&Y$HFw#tq!DKxV;uu4RkbL-ISNUPG(6kB3yo#vX@`yU}7i
zt0k2p9nTYL?Slr~ZG}uq?_v2Og3k31zfxJ7i}jN3LiTwbO%f~q`|wTD(k4(UJXYK2
zxZ$WP@rV16#mWwM2|~pp<^RP5H_UvoBcwICYN71$3H?W#5(4QZ&3Z4K%`_+UJ&uih
zzfW11Oyo{%-hjiIMeG_%IwBElM!{&gXzSJg>4iJrs~`88jH;bIqe4`ZXPm9>G3+^#
z=L^{sY)yQDm@E(gWWnXWgQ+)b_2Us<0US+r9L93^-=%YO1kh&z=U>2~%^=7j-+^IA
zYo4x><>ALEAzG6frPG#&+Ge)|&o>f0^sg?){TC^wEMzW(9P9?b*|uwDc@|U3@CHH2
z393ww$%ofa&a}lC*Ot87X?)33gpw|1sROWc80oB-<w9=Ka)ORHH3FXZoJ&}UoTG;Z
zJP1Ih%Df$8{2&J2+rhm3&;E_!M|j~^=r7qp=;v(_3i|mE>j3(>-(Lp(+(?a>_Q-Ow
z*0e{i(Xj{FkFeYN|NjWPJ9aDV?tUK8cP*y!__LIuqv0w~hm34oHQM!bPM|52EQjj?
zb89ko!i3mtX(5{MHTwMnOyz^ufIVTNU>&%BnCUi1doDa)w}1O0Wn4NK!F-HM;z$-%
zTh!2p)m9>3^|k|YeXKEFWxkaFb69g2gWQPAS2ls(uw3F?t@L2b;l#vCo(AI7#(!2p
zc2o<5zn;iC;In~JTO)QHsK{a2WwW^x592QQ5E8h-4VjY9;ahV95(4OVR-6ra;bYy!
zbA^}Y$iI%VUotxg(#ZM1C!jwu;x$P8kFzYLR7Z0B+<W)ByG?X74g6T;a^?VGtjQ!N
z(91gxWr=x2Db<#TQUA~nB#*L#wk6Wf!ezaD`zvZJG;wl9crd;qD%9Zm8VV%Z*oKKE
zx|d|nC2O%FkEy;LD0+M6Y-iMSbHalV;-l46zL3Jlp{`vJrR2XY=FtoQSVd(7#NNQ`
zE`gqlby=j<X^Do%it5x<-h>I+bcSCu<NJPA_p3b7G&e|P4Ok#Hcj{H}{c|9twVa&i
zSJQAUfVTf!t>0T^hvfTZZk1`o&G%Hzoy)(=5EFy8^zq7sk+2-|9_Aut<oZ!Ugmpm3
zh*|niJaz9G!h?phof1S@+Q)#reW8g8ujoSRw;^&+Cd6YIH1q}{m|zKZ1oHD^@%J1o
z8C>n*=B_*`bW1ppNuKkWB1xs%^)Y3R{n&16KvoPBA9>i|LNbT@QrH9D!-W*8?JiaB
zP|^25YieoX%>A^(yn1_>-f=2=A5QKF#)N^*Zs$eBY}5i6PO8sU{!2XOM;<(L@cS#S
zK2eHmW8DF&-FeM^HExhHPF3Jplo=PLjOFO+7S-8|A}6o-ZSUI@zZd38i&BQUjdeT{
zbUgyrnN%BG-}uvl!CR1O@t09$mL85Dj1hyOLkc;&+?;A>K%m-8iGZ{dU!v^tL>5V?
z)c8P_p4=g3fWct=_{DE1P1>GkGSvNf7pNT4p=p!(8xT{3V*BvU>W}md6j}A`;`JNG
zQ@d<MDL`#VDoU(6L8=|71Fa|aKMj0!u{A=`0i!2ZSCG*_4XDZ}rYS#q<@clgsa2Bo
zx2DxDc`x%tiVH=GQIFFU1Go;w<8MsyB{KTEeJZ4?UmxeuPulD8LN|bFv!A#c=n!O_
zAW)pHxYOjoQ^6=qcKc?`ckQhi-!t8SGXa9wE9(<i?qH72{1*~!u&!*AVhe?zJaUH5
zsg>yk^|u%|zJ(7b^4!)4_T?QIGV&q8JTsc=stSw-iVc=el$cW+dG|s9^ZSakEFaJ_
z)is;vt3<zXZ47t_$+Bh-YX8OVU1K#(M_(0I-lS`sDtggiBKW&z%7xICASDdNv!jH|
zTd9W>{^rjqUB-%Z5TM%K-gUZ3-$R?J8fn0He?v@O<yCq?UgpI3+ll`^_PyFb5oP=?
zcxhIo*~V)XYp?9eEx+pZiJ4X>n5Ym+kJ_ATww&$C{SdcAc{k9+wtdo|oVn#Tyx~Ik
zA>C?o9`d-L@z-$I2g?eK6bz`;kh$~5C;4+aUjx0OlDhieD5XD$j|<cFV1+3Y)%+Q7
z^BX5<2K`tI%|ni3Bh(>cJh?m%^7>>3uGKiSHyV;8uk{k5>2u-h(<-EPHZe0}S&{ka
z!Z&n!KU{|ImZvR2MzI5>$)IZ?UFN4-@=X#uwcd(tY3Z+!RUv!P8zh@o3IC-d0=*<E
zT%$*2qPN>J|M2z>CUt|=RrNbJ8Oja$H5LUsC5KVORTqi$0HyR$9tNMDogi8L%JOu=
zu>PUs^WVA}4t!P*?&nXCIFxU-meP_lKCfDicEg}ol#-_ljEbY|m~G*obv;%O+^W1>
zR8f<6zfD;9FAVR7X8$9}OhY3>=mlvP85|)fQ2&tloc)qV-}MVgAUP)}&HlD(^XtUB
z!`phLD1E<+5)*B|p+{ZD87=31hwGUV0xflXM#}zR^UV7+$LNe8R@>{aHot%=TZCK{
zhRqONvPi^7OBi@LOk%awSplbDRq<CRJev3?)(MG^<>?Lu%&XQTF#~CpKURiN3aO=+
zRYSuJ%xp>xuIF=xk09RzD<b>C&609`#@ufXGgbx?AFrRuowui1C;OA{g$>$44VT(9
zn7$6;QBA7N-ic6Ll@<C_{1~F|qATKGR3=^*2GXQ;Kf;wE9H>G5BfGqaMN(QW+jmya
zeamKFdv9Hro6eQ7XWkDV?O2lJB*C3w;>ZeM?1k;c58|yu)yTI?gXw*twBc&;Kw1vf
z?nh%ua&Sdnxg05hui+_a7#1}W(+EyC_`pBhVi;r*FN)hc^6gh#5%;>4_tc9%{|nq?
z3w!Y>(phJr{jKet1$?&tlG_svu8UE6bc$(IMZ#FVIH}a+ce8iR(;c<3>FAzs;Ta{E
zNR2mnx?j;PA(6I&6(5;7cTMR{h6HbT=C-no2l1}F)z@#)?o}Ow{Q{Id#!x;4zJjR{
z;2B%0QWS|djW;wZ6Yn-GU&m9iR3ey|=myK`^{HRUMP{cYa~-8Vrp*4&Z#&&#^ycO0
zpX+95l;!FLJliw;U?3^GK)|Kz-yt6UwhM!19tMJ{%oy`PKGLu;XD+D7wHD9j^uLy@
z*5}fZ+$%evTN<ZOMQ(4_Vha9c?mF1$l9;Wu5QVzZ4Q-W^z7f0){w`1x(yJ98$gIdc
zc~mOFs_wQ{JmHE|@}kIH^T5U_1(|#(3y&}bGX!KcSZ%!g2{qu^J3ZsP)4DE&vQ%y5
z*N)17&-WFfVs?Op;RiAs)ojR{V-$t{@;1XDKcVej^TEaXJ^>Pe48n#7O>#mTD2cwj
z|3qijMJ6hQ(T!u*5nGw!q=d<7vJ>wJQPh|Te3vg|1dLbE1H!3<fxA>Y80N<NX9*8P
z8|xw=XJ$b6n_L_OM;L#AuhHPzF%<MD)wJU>pRAW`h6I#!=mF%DHv}9v-oKYI|6zm4
z_kWJ1SnhWadzhnJNUB?&ok`Z==s9vaxalVw?ynyrS{=6^ZdAV$-Y6&gZ70{KcZIhY
z3P-AkhSkxZF1vdD+@M|aP63H%uwxmJbUo@Gu~?+Xr!0=|pG~`~I%c(jm^G=7(<Z0E
z%&q%pJVw6V(W@do^|%|kv^ONfim0-G)#Lw8*@PZt`ckvkjBbzNQc3M<7m!bJHO*5s
z_b_0+ktYk>Qr%RLXi!YQ=BuhQ9Ul>o<R>d$rfVp%j;(IUJ9NZ~FJaI=nyjH5z_9aL
zbUBQC^00088nHMZy3Y-o!JfJ=59X6IL_&C<E_t8m{W)+XV<{9xIg)_dG|s3ZRmjhI
zjWx>jEPG?M%jzh9{n%XBvU$n*GXiAW?Ekh8mMXc361!{<R;zSbZF?E3lP<Dh&I1dN
zH6^of{SAu2s4)lQ_!}&%lJAr}7(Zb!W^&lwCbP11UytD>`0|m)wO8nm&N&Y5k^Ju7
z`qU@$4XJU#4m#Tkerbh|W%=!HN$8%hFPd_6&k6KB4I~&S5B{V3ROMt$$A`lef`5tU
zl^c3l?a5OeV`%8IBpa97ra?OI)Y^Ap^2oR2@gm26`7;bvB0?UUw;HAxC!)flGB5va
z-tKemgJ$^##oK#U0c%@AzmiF2Sz^rK=ePSLC=w>6+o-J}Uv)((iMz}spkN^JeB$d4
z6|Y6qLOWPH7HZ`@O#)@(R&#&d&Ghg=nU6JCS__t~qJL{4kg#*x&MT7@bJt!O3<}j}
zI%%=)Q9@EyN$^O+27p8a#$uLW8#!}1xij5rVXep40?vJdZ4)m)#+6=6C|G-?GhZmB
zJW#d3V(DI?<6O|8`m_ndXT<sp8zL{{H>#c+xvO!9u}T##$rWn2v12q}UpU2|Hr%A^
z#*-(-b$u>DGzN$Zq}2FfuL9Tw+o3kbG_KN1D5w=ke4?Te44Jx2>hE0u*tn^OtLxF0
zy?LCHn77ulOR)bAqZCMOk<;h6QZFl($#)Ze;q(`dyeR3}GWOf_04giP=SLXIg{hV$
zkPEgyHm@++e}!JMy%2jl=TelzM!gV-#UW7%D2-<hmSDAb2#?5{jo#P>XP3CFNc8-#
zIO(sa^pfgBN;I7v{Yocq+<K7A!_Qh5*N5ideoiZNHiY=#-Y_-8vw1t1N2;j-iVm-i
zv4$7vKQq_*Vf>8VXPtebYW<m4?%EPO)!CUzl$9!8FHzdzA)?kl3#tzl|9#AfiOPpM
z4Ggs!BE5FalMQ@PX3=@)m6e`7aO7c%Lw$w(i?^Oggj~~%nVtM}%_~pwZ=Epx4&`}|
zhoQUXDS;zfgso8(_#zUs0Qr1lh=2}AV)aU(f34wLKV@sI@VwV~Tk7Z=4cN7$B=}cz
zE%(e8TOH<cNj+BB{Us-ghRLQy0@L)6<J!b1>LP(7WsX(zcBm)tZVRKgKQ~trEF~E!
zn4XD#%ax-#Ea0hDX~^7Ts#&#WucR+?Y5-GC#?p}WsV39w)u)y5G~J17a((}R3iC%g
zds~m}I$g^t;z7B06GiLCd|Cr3-9m&&K{)xdmFq@R<$l~QM1{b_7|(+fXEm}mtV$hA
z=dE(9o!{l|H9qL`O1Q=KmCBj56!qm2_IJC*!3E!x0j>Oxe_~IU@x7O5qXwQr1{KC4
zMXav2N}n0wX05?2J?;^)=_{AlqI8SypK5!FFjb$h5_5h+>%vP0^na)Hi$e_|dpDe2
z;uYnhVw2jRThJOpOt`mlU?Zg`MZ~%z4YoUQs(i4{-4<~gk}=}kmkb00e{V_c7UNzv
z5Odn$u}cT32?dZTS7ObgRZSZ=#?xU2S`Tw|$qs}E-~_>FH`A0G4gghVNbB})M0t9g
zL}5N`4a#arP)@Vb@v5Mou3*Aote(f&;BfQfgj1@b6laN@RM?*9lM&`l#`3Tj^;PwT
zgalB4Ge=<m%x&4nm-ReKlbendXP2koyjnB{xI7XfCQr<#T>`!gDV95jCfZaiqXNT9
zNhYcmuGwq0m-b)z;SFh#vFvhPT|rH3k0oX!(}!rGDyifxCu=z-_`dw6>W#biqIqCv
z(@HHSzWWb_-I!%h8`<XhQp#ybm3bKf9~?%Gosc3x?zOT;(F>4~&>E-Ug^llLT`Di5
zCak08We^T}R1er!2WC=LTWfEm4T0sv=rHSCAm1?wA)F-!VUPCvNcAo;+A7<z<mStC
zg5+9A(WthIdo5yaf|LO4Or+dl_)h_|rvbnZNJc=PStoDv+Tcv{Rx=AviK>`vk@($3
z{ikfs0gl202uE=rvX+RG%Ixy`bb{LE_6sTzRTdk+-%|Z}|Kk`VJGWf1&>*=de+Xiz
zcP9QzvSCN(Bu;XAgNl-u%6|u6HTb6H3tAal@PR$_K~l-!`VE?CEM!}Ja;D6bbs6LF
z{N(4{6~%r}ZT+7w(09;gSxOMp=NTp0D53%8LOOm3F#+7&aQYEA#Qfx=pp5E=#{4`L
zgCt)4q1d|BAQGuC%|el?ZkG_cgt3h>Y9fFEu`J?s>}8<tz|u3<=}H?dyXKYYUyb_q
z&v^rKE0mbv>3<;6jU{vNU~eZvGZ2wKLwG{mSL<t+1jMqVI;Z`_C~C&iXd@dzOBWJj
z(?J*cQp^H|dGu-F-Vn#^V1gCho=a8~o&vfX$cuqSJv8)?^EJ>Y`*b(l_<5@L6;<)a
z=CUL>Sr@?8p;lFMHM2hqzfUN^HgwR1L{<-FsP2`FF}GQ|jW9ONOHPiX+jw*6*Ya(a
z?QR32xw=-QJpoYZ5Xmw*Nmkta`+!)MPGz4)ay%tcd_d9fJM-N{HIY9p!anAwyaf?L
zR))b>qXe%gSSG41GR{+~Q`n&VI56~nu89OWI15r(Vnm3n;QuI($99d`z#FhcqTG5*
zS?*o0C)PtvF(OyjDU?j63Hzg&OF%&ti%i+BjLiYDWm6~2qkVisB^bFSxIA-n%3kBT
z8}$O4Z$RUh$pHmtZ~--eJ%<rc&9NGD<lZ%8qrbgwh-LYG^Rf>2@AaiBb=l~Z>oHyA
zKbQa{W0C;zZE~;#7rU5;n8&0{v4{kQi9@4D0mK`mouFD+2!aw*_-;TP&d_Htn>BbA
z(?TeL;MXb=ub=XlI*XJn3}|-3zsm2A*e;q=o}#|9!zRnXqx5L_OH@AuB`r0v5yO!Z
z_qdam#LiUxSrWP}8WVU;aF~ME1PwfV(@i{(^1udKEWts$0rl2Iw4D~9;}Ekkx$o7`
zjqM$;I$Q>!3|N@VB@~#6Apo}N6=()&ClrWa|16fDWpMGkNX$1n$ATQsPDxgs_a7S7
zXNI_Um0nO8scbD&9vIG(KWAj`@HYDG$~GwS@umPu44?uno+4Qg43V6Nrvd)yz9uuh
zLfZaPN_@uLF-~pIoo|~wZA+tX99ItKImij!fPK9;(L|62-2S{_*CC(X1rdUHH7`Tt
zyf#7202?Eofr5Y$66aV0D533Img~>p^2rdno)oiSIB=|HmS1gZo+vMOqJq8T8IKvX
zaUA-<8A9-f1Fa~<b|l(u*vqf|sk8-g#AaUgE~n)exCyl(!Z#Vt^1{{rVLtc{Yc{`t
zU^oaSh8Y4w6!_IcmGdr+?>;&!-Et*9C`IMIEOEUyPyev9g^-5I$;>9@?!1_(IfaH`
zPk5#pGEpi^I*fazp!R3r@oBcVX&l$%36=BKGB+7p2Gh@ejlBW8L@%kT;5LZx4Alq_
zN=1CQ!7zyb#8Z)Wu-yUZmJ(Csww5&M@-@%2R|UozSV64VVBt%{xiQT?zdNSnTwTc%
z(~E+u2Va^9Lrw6C)P|Ef?~@UQK(+tGm6zBrBP#(oL{%kV)k_}qntnGZb81eWB|O~n
zICY};bG4Q9V7gV{>Qcd5s!l=WuTw{t{@r&<mQ~lB_%1ABmt>5B$P{RCG9kkOjMsTa
zK2>oe|JrluRJPAEs%%g{O~0ZVsohd&OM;9zE3D7}Hj*@%PC+Rr5VT=Min%3LZ4SUn
zgX&B}+F_p;4R0ufzEo9*m$vieEhNK=d_4_%!SrGjwoU6D51PvT8%XwCqV2=-z5T~~
zMq8bu(~cE}8D32I;TS!%%ZSh6qZ-=zj*9dEfM&3V1DQO0(qdUYf{p2T0oP_Z7P(+M
zso2k=UGu0Q2vtE4mq!8n(`EWo(HvdZ&N-IfTmNMjoUt`!Z{-1{XNpi7mOhr?RIKZ9
zw*bW}tRM)+t(Za=TK{Bhv=l3vv$xkwZSKEDe_9VuC#{0QpwniE5^tw@d8VVXAG|9w
zxE#uYq~$Q1Tqs;YH4P<dHvXyJRl>jue9tDrASS^ogGl%A+8|yQ1OvrNhtMu63_|U1
z@<H@G3?zWs-*xPQ&$G^3z3xg02Bn2_SFeBqCCR`;+h68XCsvQdvP6rN@p@&1TmU0J
z_f?mjJPZ^bgre3X`dBCNn96A89f#g6lSddJV?ABm{AB%(lZ=f1?*c!LbN1G8<r_{(
z6(|II{}M8tQb;U|5MOm#PKoWiL*S<;Np&&s7^il)pPBAeQuifea_u$(mzgZ8U#Dx7
zuRZaN_OUTt+qW`l(5Lg1CA)}=rGuxsyFegUY^JIVb@{Dsfwb({==eAP>C1aRw_IM}
z_O$U`ppq-ZsB0}x3*ft=bnqk<I<&yvFaW!)V6$2Fw~^*=xyl3V0m2S7l$4k*m#o{2
zLn<S6p9@p=nwCmZyB-QFQU9zq-`l7O+o_2+SO;0x-zrn_@*xy(@TdPUfFhP<RQ8>E
z&1DG<uD$H7XPo@PG$GwrWqubu)|1vPXADC4AAN(zmZJ7OKDmnB9jdzgv|w=V<hh^0
z*!*JWz9Nq3*my7{XR4hGd9#}2__kh)=*pyy80q#TWhWN9j*fAbDFGJmr3TOpMx|fI
zoSo8vUz7?8b*mDWBq*5mq$ivdtr(U%5qg?q@#lXNHRU!#f!Z>^xF=nE*`23F*Cwn+
zE16r_3acQALC+Kn;5D<v24nRf#^1$Ox3t$gJAW6DG8jOoRWK>3p<?6DLa-y#L<6}$
zf#Xeeskb9r+N|99<-HU!YU>G64nFu|iE!hoIk7B{key*mPPC$jM900DlK0VKdYmp?
z<FI@K=UuR4QHqggJDf~QxzLm`9CI9khUk&*y6@d#$_E?V!C*1<E1Lc5WMrrbTPz38
zDSzd4GrTa8FR_@7R#^G$r#Vb3fGMZR_*5=aw)Rc$@rYSrCG(Z7#&90vS2Z@x*41Fu
zg$$H5zZ|Y)8#V3W@5uO;?s;*6KJWiB`vfn#=bCV<O6zBh-7%TRt77aNg<Ux-%JW;V
zO*g^GeQY^)zy9p0&)kawW+!NrB@8vM#$g@tEc^@&$~?hVgX38F%Jb}*FYm>+=N5+w
z+H;!5>a#!DrP>WfWlpehtFCbcmHiZ|lEax4&d!@X%;8&%t$Wv6K1l5=R{tVobtw4U
z(F#ggN`f)I3YbfpbTg>@W=D@nhP}<vDP19Kd*mc{r?raQi++SZFxg=qY1&9LN1C?3
zNmJk`vo3nyq4xDVd=!0j0X!O(70R>qx%n2x38w7nm%3B8Yprtq49jH+2Jg~)uDjpl
zxy{}@IhXJUhZaZoEGzbE|Bh*z*$9ow75KglHew`pD4aN*B~4Q~!8`Hl6$fM3@eD_a
z!F>v8Fh4~TzIaKD#k>LBEL&^VrOI9Jo3SM8Y2{kCK56a@k(7p%$(f=$Dx55u@~A+U
zsX|uGnjO@#PX}ic?8nqTCn|URZ*_!HkW1L9bBeT=0R0AJJ)6Csd_&Kkv-LB`KO@&$
z#*vEjs$cDdQIAeq4ViE2FvzDqzWu>ie<{P!e;QGkw)I&Hb{6!;xv9S?jJabP;I=Nr
ztyxLxe*ow;dck7-p{kvWs5_n|7E<%;9GVV_3Q^da6-)eW9H@x%ZyOn)ieXSzr$MIr
z>vObK`mbM~mVv^qmg1L%um!M7>5E6ysBvEqNBSebK?t0Hq)J!BS%fLdTFOf6uTHoi
z)#=TqI=|XA<iE};M;OXmwxkwhk{0V%CUcNu&u=aOiZb*XT{p3oA9pKeJZd!kZk^Y|
zdAk49uULsvm{_#(SRgCHD(zlH@p;;^?VsNja_b8+ez=T<qd(SGwLy{WO~R1UMrqJ#
zz}aR_)piq&@ZUU;6n)6c{jH1hH+F$#8_&-Cx+)8fd7t|YIl#Q13fDHKoDfXC6L_8$
zlbPyVaEiA+CNp|hD@TnL@Ca*~X@bEIFDdni%G@Ii`5reh$O49>%)&jf1!t;z@Pxv2
zueXOBY;V<|wWBrFKuG15!I$lDCMD1Kd7?X;jyy?pN5z8a&Ih(@zma~f;uC)y1aeNl
zGQNV-{s%nYGOc|;qLI5!`&gx8_qO4#3EPSAlLfWvGxgp_USI`eS)M6Nw-f9OrXo~C
zjtoHZCzL9!J{^*mVfW*q{SVjP4la&Wy5eyeN3XEN4b)SZs*)ZO=e!o-UfdijuTNhj
zNYPsefelss1zuWv8JRQXKg@z-@OVyu^9dN{ReGk?Snt{RbNLZhx40xH3Z@eZjiWj1
zl>OT}q3Y}6t$h+Dl9m?7<*W@^38VjqWR5ba!tc)UCszI&+MuPVuM%od_Wj5FKl=~>
zGOF;0junYj=>fFLVrOhmAs#~ff(*maGhfjRR5m!g(ElHtYLJ>>#Tp*H>ohqN^WSHZ
ze0$HT#HSnFN<AJY^|i@;Yhr`mtY0yJ0bB2HW;ZC?F)s|;oOku(FmVO>-=2iMYgq2y
z=-5HikCJ9%YCQjAvbxO1``!H8=8)ct5feVPq(-#}RHxW{vr6r}^2%s%$7uBf6}S3!
zHK*uyhd^F7T4P(Veqt1MbI8HNX)j}5a>()x*e3OpvX8SOm8pHko2w61MkiBy-ZXhe
ziG6_G#JJ$#jK&`fe;L`hf`j9K^32pukF$Af6+zM9&(?61`6=5|<4j(KO>q{9M}JgD
zB0WLl|6ro?q8pDK<{$x{3FCaCM!<22?v~Iouc!<EqlM*UeJN^7VA$iUQK7ugV{xVV
zh3_thRIQ;)+B>Qgul}m~cB7ep4pm@-nQvuxj3>81$H-gk^w%FOSeuyWQ19!otn&4)
zy`>BF%a*?X->%X$PggK8X6!7U!+y_+io@K0!%S9NZA@m-e&=s~PY13E;y{C9HMAWN
zA1vCS_F3gW--j#Gm$(O!tI|u^{lXD?ECn_xGuTL=d%P^d?ZAB+<Y&_vf3ayx8D2S=
zTG;Gz2Pl}n?;09=>zRTbxO@%!AqSM5>>bN;{Z<T2!c)i};Aw-W#Cyw;n3uHwIob=x
zwEEk2E_n^co6+eN4#r|zGJaBGz*xvQXa6r|2NJ&*6E3Zup`E(Xi>-BV>hJeSR~uV&
z{m*qvAXy>=@{0QQ!}rg*2l#sBnDBvH-1;s899%ZVYm$>|0LjH^$zuuP6$R?){JN0^
zc>1`)1dk9@enkZtsy5WNW_XMkb$fF#o}KZY*0d<)(87wFGgh)qlU?YVwp?(&r@J(i
zc(J=a!QuU+`%j?!>i(yc=2x_b67Ns#O*#BuqQ9S<R>ILTz3nf!x3j0W;n(Rg{8^UO
zuiPNpE65%@9O?W8R?wlYDXgBp{Hn~=6A|w1cY?nhR~}<z)+ac>7v*6q{qMR0Ayk2L
zt5wfh$4c18i0%;yab{DIBAH(YhEA4G)2eB6hoh~%8WX>t+Nf~-CO>BAS24jcYJ981
z^sE8|MxENs<NryuTklAHn%rS~ci_M<`vjMc;Qil11OA4{#@?KdTB4c^)epr@A3K63
zGdaHp#xhj7R~$oO*QTe|2xvh;d+Jc<{jC1tyDw>D3b2RTO=mQC#C@RbgNZZ2z3;P%
zi=}C-5^bVgW!&Ab9ZUD_;Q}4Q3ucgQf?Ps{JwMMFWg<hx@ew+r0kR%8j*VXGIj%BZ
zI5FZ6H>srTU%oBH<8-sMZrk(SMk%u<8hC|U*o{rL1TX`67?P5CNycAEqhvvwPU9k8
zTJH=K-u?0L(O=bRM(q6cdgFq=*&<38%RHA#xba}wKD>T}{Z*COz4XTF_-l%m^A%s#
zx0^QgDeS!X|JwWVcqrHK?-Ef;oHS0#+9}DPjx3XqN-9ZF7(_@TyAiS%Ntq&*QJE-Z
zEBjazLW4|3B#eC<`;zR$y!Z3Wkka|Rzt8*kdrp0tXXcq_?&n^v>$<P&`~5y(--g|T
zpEO36K=h92JU$%wnOL(cBY?Cm&H!^RA(kn%4~YcUAA0nUUxJ4qO%JI&qm#9PUe`zl
z;I3y)LpG<;Ckt|C>RWImtf~=C4SbMNwvMXPdaXSbT$$#Zjlg{i%(xh`B`thJC3DIw
z)rh;!Y?LMef%X6fn_+~ZBp*ATnDQw$pc;Gl^O2D))1T=-Tz%#u>BII}V8xCXi|*EQ
z*Ow8)D2?YM7f1y^h(4pz^aM8CbE7`f3Ibu`Gax?A_Km2_k57eful0Ox6pTuE5<(Po
zH$j-pnJgq1*aKq^=;%KS$p_vMNEh-wi}B6DzO3tR=RO0}@HMz|Ugcrc^=Wfeg~FE{
zvmS!<@yf&WxqU_8Q%IVDsq6yh8EfJJZjA?<7j~fL>b!l36dj_(d!)vleb`jnId5sC
zSw~022M+DT$iBr7<n2$28SufKBTYUa@?RiN*zxOCZT1Go@Xmi(W!*{vMHV=HGS|DR
zIo~?M$7^IKMjxO@bB=gispI_2NGwZ(QyMgKq0}<WLivcE{A^r3!IJK!C$8u9dpmhi
z+mhzOWRRdP@A%dSwJmlojCkWI$iD*N0@$K~FT}v3({+j|KLN$rORsgr9unPA!mD*m
zw2%OkN|5AB1C(DP?QkXnXj>SSL3hB^EMnXYwAqo;Scn1Z$uH%(2{6s@UwDcxD?P|Y
z5CqhA&CVpIzK;@0Er$Q@NF9g)o``WhxKaqd1z-c_2q=S_vP6RbG!$s|#(-G~vs56o
zUm=r+0dmK{D=;(D!16Lv)BU}0ra68A2W%-b^?VFwt*C)7Gsr6pA_-KrgOk*!mQIAJ
zE7%x=a%!o`SJ~G^TGjN4dMsLn@7g&i@$JB40O%%AZX6=VfL?%d<8aCuNc>grX)S4N
zUTVgD>}0Wt5tN7S0J=B1QzOa4^B%~zFuQeehXVnjL7W0I{FE-6oQD-$jc@GVxi*jZ
zeESH<-lBUwK2oRbT667?lNWBnY%4fR3}z*RgkSaq;7PC{IKyk1TRl-~#b(lwkPgI%
z?ja0K+G>JwA%orp^7!aFEJ8T}Q6LB*Qx<u`&}s#9V6hRSE*xbLP}Oa8TRXX4vJ0$3
z9;p^)Edz>I0n`#y4;h<_+WPz}b7k{gr7G^P0JV2&Y|d3((9=Vlf3XeNNeeHcDvUN*
z{DFr6fE&VTsu51exE!+Q=b12l1AzBI&=1uXCU|o^gz^ljAeF4N`#;Z88cw7G?2P9u
zmG8=@1~n<~@t5j$7f_ABT3v-%v(Ti694Me1LL5*iB=<0?$E!>6J!rZ^aI8}whO<W<
zO^{&8BGr_E)iH%d4nY5&r_=@-p#)`34O`TOJgpb+ZhR5gu++a)G_+%o6++r?&dd|7
zGk{>ci%JRbia;_LizuDWkJNW%Un3t}`Ie!(9|?+e&{l^TdPDej5XM4H4gV`=c2nF`
z|I1DJ?qF!w;R^ETbfYYz?K{D}I2ysR@HWWq0sJL&r-Rd2kXZWR+*@ay<JN3y-r(jn
zUIw}us9fPwZfDr!M46^~fx%lW)50s1S<wRI9KM`sb1P{7LgU?t15dPd>Id){XwE?q
z^e+fE8x@qs4!$Bpsf}?x-sX}aoo!HNWB$3SlsMCU6Yni%o?}i|rPM=2VP=i%msZ}z
zBGjekue%%9TSfgVYcNW`7uon^tx1AqYp&ObN7jgGi22za`Z^iNSW7IB^Z>#WjIbY~
z*+CUNc<J<ng1k9E;Q;Q4=E3U5(y7TBdE@Niv5ooq;HUK{T~S$};-*%~h<1U8fG}ck
zRgEHraqPmXy3dphh1oYr1xRuo>3up)iwa$9a}$t@42GQ-o;C6nIL(<|LJZ||@0I1#
z^ZDNVMr9_+2#As}u<lS59->dlz+|~&p+roi$NbwP^&Ls;3^jjPMX6CDX7Y0D1iFxR
z$bRdV?$eu|mHn72aBNnkbd(g`Edr_&P*RI|N8qyXjwOG6qoJ#^Ct#XPnC80oJTaMq
znbBT^a(W;kZ|39I@JOStWU8x5{@dYrWI6q{JYtN?UFrd`AZKFgf+R+-;Kw|Jhq6Uv
zFGSE_%zdZ;2Q?HF#@mYk4F2U3;iTdraf;rmuK43!_hgRYB#?;`r{{j8`uTUg@cuUT
zx)Eb{f&<{%VGF@vazTPGU8h2blcpXEB*V&rYi~S#G5k4Vo^9Lxd)Apsv|QegnyXNm
zrr9qPN|Q}Ej&Diyy#6mfF^v#vFY}bpJm2Cv;ysc}lV*JtsOxn7U**p;H;bP?X}r6O
z6;Mxpf>}WSe!2^ZJ`e#{Wf#`5a?Wbpz-zcr@1>=q`B~j`XQz-o22DUB24apv5%Vtt
z0)|-RVo_~z8|PtAbiNouW`hVT@Csv`Xli;4s%%oX(vU#3t@D<SY*@h13-U%@`GgD5
zDp!4{jcBh~paJEb??yLu=EBHZ5uklQ5{-!}0ujfJt^QD!>Oa!`-rG=|<y#Kq?LQWz
zcJIFFK3P81oWrqUC1t5`JpUp=r~U*`{+vjFG|~4le5^<=!`f^!q~ZoNys970_kd_a
z61z`}k^)ARk#~T(@k~^#0E5Gli17!xg)l{`ip}}cl*~&ZN>qBGF0Ctp9cnrlG^mqc
zG#}g(#KbP-Mr{tmUWTAs<Chr2uYk>xY^zVEA-5z8V_p=@d>R@E%97E_k}EZHlM>uv
zyr~O0o`_j!cP?#w5^ER^^nk!70rUZ69H7vE@jFCgxS|Rb6`*JbaLu5uTP(wa*~FZj
zgGj7yz6F0yt?8Q)Zeli&T>~YCz*}mHD2dj8&+msi37W$&90<@#-ox_&WR<_wy^5WD
z@Vw+%31qUq-|2ZsG*7)Po#g?czraLiWI`BAp0Nx-n1bijzD)&$NL?5AnS6&x$5ol@
z45co%yOpS%U@y-H;00q<GCqZ4iYkLUcgW-7=-;F6&n<c=YI~l~L%puB8Qvm6$Z2q4
z#+p$4UlkzaQP!nVNZUqWfRW0=jUW!C05*<3xnoV*e_#12A=*STX_Missk3I+;glnv
zI&g>*fdG*potz^-`ppry)I7;v5IsMYYb|0_&8{<ub_E3l1}BQml8sn-HXu82O(g>4
zFIWUhvKZK#D1nvD|6}<gi9kEhvg&n{1xh0~LT%>EWfi1BkLdDux)q>-VeXyb-Y9#*
zSPB2v`UXj?+rBvJSef>GVDz3Le$cjo0McYm98X&5-}=b&C+bqlu29S1%QLE&zg)f)
zFgY%aRb7R+FQ>)t6=(i)c}%qKG{xX*#fwkbP6oQgW_R$mA3+DyY%ljbUiUBKoqO*g
zd%JC!y<KFhy&*)0O&C^t0W2GFe8=eckrB6$@N&_-4TE@OW(YA2A02S!i{Gn8$dfge
zQ8%X}m2N)W{*S;7|E>N&6Aw<Kz_X0Oh6Bb{DTzFVFuTvGUEzf{N0chM^7ko#IiB@g
zQ$znz2C}xWsgA1zeKW$repC9Db+|M<>A>T;hSdmjz(i?SLUI4JeSfUC(BuSE0tjC%
z(WfaLngncMrW9_$DfKADDjg|-soHfKrMB%JNkL{kkm37N6Z>i?86Zszv1v>teDu9`
zp)?BCr{D>+bYy-HKT1NV>EIX9N8Vd5N&>+<aMpRO?!j!gUC<gfWK?Zncd%%lBS73h
zl+4}rR;L(Lg=nURQ!K$?T<?+2q25%b(XgO(FT2cMgZ5IffIvdx01dNULNq~fEW;8z
zcG-jn$JcE%oV9lX87qXVJ+^ie&K;#ew>?ePM&WYh0bo-tj}T3li?xU+keb86FwQUE
zQ-e_aC1@HzbB%01NUr>6UchPF^%~Dp0(O8gWH`XNS_j=FclR|aVXK{6zM5sCH0vpg
zkjA~Q`%}983?qV}LB+4^v4lE}E3h2jY55?{R$tky_&$W#wU`@`e4xU=$i``JDUw0E
zej^1=hWmUY51f|g*JAK?IyhI$BCWcRwQ08cH;tNr_e-AJx9y%-xwcdIQ@c_B>->oG
zSi}`79*Bquf*wv>LfHQ7nX0aYAIDDZ&>MC$iR7ZY%uK%RQwnI6@_ux6`_0Fsyf8v2
zY3KQLY^6ERf-OLwW#NQ&el3+mKcXcdrQ)MPJp^&z><v>m3NHNE9j|OxS#-A_nC+^k
zi_k78`iJZ`sD}bY3GbWXbH0v0bd9SeixBi-*)XNM#fSo~M4C;%NI?^uxY-1{TCxkd
z&>Wj~+a#bCD>rf9WZ0KCbr#u&04Qg^(Sgqf9G~Ly{(LWJAFQrW(bJTS`d;(I6jJ4-
z7QGK&^xEJU+$^zBPuf-%TWe+>m(hhRjaqmh+9#2+5qGY^sw+WF3NYnpIoCc(q=<0J
zybb_^Ww3Iv2JZq4XG?jkZ>>+x0q<QoNp5yI`uJj9C%R!d^__==kMr{dv+biYADt_l
z-k9zi*;21f>25Zhd9!A7QYnwUQ$$||7QDOnC1wB16n)$uyQuaadj86*ArQS{8#`i}
z?EnYfV!}kxvTh6%NAI~e4CyB@->{~Mirr2`KR&Aj3}!8(*7%D>>q;mHjt@I(*PI*=
z_WtwRYmK5T6VWz+>kYqb1dhiYL^uiLpAiltk^^~PJQ1<aS|EqEFPuL!ML>N%X8V|a
zI!wbcBFB^ilB0no+DXkY!NRK>*uTY8_j0EQ#PmF#_Iyu)&_H0X1=w3dbLX$~gWVHp
z5}P@qx7wWot%;x9ACN}42rpKkS33bfd|ij@J6!aM6Cg_yHAFJ&Dt?+r`;XuHt=^Us
zk2J8R9#m`8CU<{Cb0QKmY$Bp;<1Oa9AY0AABmEW||0MTAu`&z}UtA(J`vBc%AlCk+
zv$>q?&Gvx`8h7S3E)TF12(4B}>ycwl8fI@lhHfx87?7v`;q@cs^0x+Z=NpP>d&{d`
zV&I^@_-79<2K9d`*SUWV5!C;bd(<`;lct1g!S0**D+5yw^%AozyS#tFJ(Imw<yv%M
z#k}!aLpJlCSb+DAjK|il!8P%*m7B0x&U<EFsxp+SmR|p;V7<eCH{}7bDInEDEh#I7
zCMrK6Xr<r9)iOi^QleyW15Sijca#vS@n1f$=6<5mmjWh;Z?$0ken_;ga$Uqg?K#u{
zfQ6cH)JLdA=0MyW{ksQWrqn~J7#IK#EGokq0A|_Tv7|~+R(U}5LXW%YJ0+{d1sILH
z=sR749Tvk4K%%sa06@naD3IQ3s@be!U8K|E?h-!i^bLqspm66h%MC;AzbFwcpWy=J
zbfoRh=W7Ok0wWzIw9+fP>_-{?mD5y8$vLeOlr#d!cI$9WrsYPl0n!5=tSG|>-1uIL
zBq68iw0w4;@wpx+^GCn=TP@LU4=z3s4`hJsL#%WZB?nBZGAq?Q-Eil^`K{1XftQa7
z0Lttlv1Dn#1gOAnv7WcMR&%BTbo|v>d+XVfEPJD=6^ee=iY+uh`xZUc!|WoQPeUIP
zKkKJc)VR~0qfw|i?J7pt4nju|fP>k~Tt!q<08VGGE2_2orm6H9DAp0<D%pUO1Jj97
z8idrK7Ps~`wh)pHz?7#pPr)!XH`6zFM$fJ_$&305_9lr=XQeUFZfJ=}_H%;*z<f{3
z)-?j%+GAB^z|)iiiVYljG70=l-YMh(0Ckp8q0~djVl(-0`+=&i(0}e8?itm;%6uoF
z?)9l7g%tc%)TZ%hk}OWYswk$LHWUtm>0o~~O)16^w6GbNRz?WT+*T?A@xa12s4X>Z
z*7N$R5m<JmFrXL9%wU1V1XlgeoKT|cEQW3hj9#8TAoNhm84^6ul6z99&Qybf5Vm<`
z(I$Zr{F&a$2`v!W1_EI(Rl}E`_@<4-w*fiz9n{EL7Pj;TsO_<0By*}ZF~jAbC|;1V
zc~B;~$uK*mJ-@)i9@#D4fJL+)&ejJav<@OhP|)hWxWxfYf`%OIT>y#>w}a2ViO1e|
zn=8jh15-{z-@iTMqe$D7NZ~Q10<WwjQJjXyO+&gxTYAM?_A3nwpSS*qu0OmUY-B)*
zVvz^4XzI!Umk1<JY<#vIxJLz7+b1(!9*D@)*!0YbY5<6kcL||RJd8stpnyh(R;HRg
z!%+gU@ukabMR_RLIHp${Pnq}UiMsNlaOaUj&YP@<qb-3>gFXp-kkV}o)&)cP0K%_A
z$rpG_4hc4FitDuW-}}Mja!^)^?6iT<=ey^TWjdatxNBr5Z0+pz?jv%DAL4JP!R{Ga
zq!5@H9;BsRB8WCnHaZYcBWagSI~vq00Czay2}t~4emydW+?ScjN<#taS<%}ZJ-z96
zFOsFClcc1F0WKsjxaERi=67?FQc;_Ryd6WOX{jFp!5pe`!-h+1z2R-@q^UJuPA3pl
zhi9D4ii{pm{umAJP>2?2#X^PM&`C=O{trP^mNFGfsZM4smMPb_lzd@mok8G&eo?*6
znfotasqdGk?VZL3{$H-t3aS=M7;=!?UdqvmW0zHAy^q2w?m+Kph#5LAzsWBkKc*#R
zGitjb9|2@mw4SJCZ(P>kUse}w4SwL-Si^psoWDPWXqY2fwKxoic}h`Kxx62P27p$l
zk+J;JU_wBY8z|EZs{dSunyZTDrQMEVGZ8okx`tpCoNryE007<t)M>!Ngb>C2ZBMM)
zknc>h`8aR{;swB){NIwa)-ylLwI8Vl$){!<OD`?;#;=HaCSB;44C*4<{{Qten~{`^
zYesx8n!kslMKKtQ|M+Q}5oYmr?zQ%?qx$9lIPHIGMZ)Co934ovuS?MN($YY|tM6xL
zcjx~~(NUW2j<1$uKi}y+_VA6oN)A6z_RYzj4L8*DapHu`$j|K-P+^CKTfjhooH*p?
zAiD+D13-`l|8(SCgH`hLW6~{ehoQ74B+dtNr2|~{Q_ij99!hp}EMuGF-90s|Jm%r*
z(=$nOW>+%MdobzVw7~Zww{>pVxpi*7HG2xAJSW6j=bcqPzjWStCAoAc5(<{`{}8zw
zVG%9mIh^Cs0#d#58FgM<V-Y9le$sK3`N$aM0Akv2De}buwkhv>_#*aL)Meb=_{tZ}
zGJUF)NiVkl@f&YaLR)*+w&DRyPhi=^l!1F-G2QKPb7(oY2jsC}(_yg4wp$t;s4P4s
zDR?0N;Kkm&h>uHfQ6`gZ8A?Ghh!8ErG4%~$0xG)-OlS#{C9_y<hpIGy`Hj<UFjcGv
zQhh>-$)#I8Cy+&x?K+ArcAm!OAujdGo>nU9&C>}bz%q7hU)Gn*yc!gEvJC<$rEm2M
zwK~#6)#Nn=x`V|MwPxQmEk-Lab|ckfHb+U#!2lAJ%mamA?z-v^-cb0kJ!Ivc2XM(n
z4)>MT<fKe|_Fz*U|DxqX2gIFLvu^?+BxB#d`Ei1*`}RXof(FB1E%Oy2#C#fZ_`BZA
ztU>P%0TzU7?jk;JC8{iF2S#?3JYk%g&^OyEdarhoh5@vDVK=yl{{ZtAX#QY@zQ$aj
z-)do0PGuJX^9;V_a?IksE*rxCr`-H6DK}OvS{?tJS|?LS57H9svhhOAwM!=f!90o4
zUQ;G)WCi%`U##x8#Ne?EP{;sz;ktRCV*QR@D8@ppg8?Jj2>XRmp$k)$^dDM23q3yl
z6CdEJFC;CnD65c1py8vk{V@zoNsYB?ld&PFO*OO=h`vc+bNW0*m=!8>P^2;K!a)}C
z>`=i6DDl_qW`Wb+4Bb~|(tJn^LyNX-N!wo(mI|<MINO`g6WGRhS2M!{c(TE~VNi=q
z<y}$ZOr5Tz<LILy3sjRIw917J>D2lNl2+@riIDu+ug~6?G#8qANKQx6W3vSNK-I3!
z$Ag}n3JMU<j41ik=Zq5kU2cd-$kg9crBv@?ZA>{%L)rpSnvimI!%bm?uWh<8hiU_p
ztOZKtkjaKnAUc>Zq9E^3i~5M}WDdK@rohS8f*E5A^D2X?g^J1rM~h%k36`Ah9i|&l
z|L|>4JX_@Vghje&oc+<Ou9q&8s_-`I*&R~V7TXIT^`l3hY@P3KjoI`0G$$n3hk&*g
zP_hU{Ffg?|WP!Y%#@W-av0@9Q7m_WR^dE#T4T;qbRUB0r26fA*TWU)u^jzk-c`*mk
zh4|j|vD>lE8WOsP66)}icNpwEAQNbl7#)|O19l+qf|aLh&Cb@w^P>z~Kn69zn1Y{r
zqK~Zd{r;En4p#Cun8XT~exSq(Lxm4i6$*I2Zol1hj54X6?yX<*^W`~#+f7HIcWV!y
zNoJE}F913}dFiVd0V1P@0aqBI($GF27NdR6XT1u_x*}?U*Be{=lyp;P`Xkz0GET*o
z@Kc9iX-vS*BRX#3dbcqkHpz#AT%~R6%hb3q;?UeFWVyi^A8y;^60=iKBnvf`Q89sT
zAL1WLtBqQ)7(;690rx)jOjK=2WJl0@vy5|wQ$l9mDZh=Hc;68@Pf^KTJhm+s{pvgY
zU?Y7(#cSeiaW{2rw$}hc06~}vsPMPEL-2-y9mVn>!&;~Zs>KuFuWhBM(sM?KF;0c*
zqYThat+Gv@HZS6ZKFG~bAKa@Pkgj)(DGW2`0T~;VVcMwMJe%UNi_4EF<)R2*eYWm(
zg%2t+2c-Xkw60e+11|e2Jx6I#tZJ-Y2a@RW-ge+Q7veY?R`;c@&UqxH8>lG%>!Ad0
zT)5$&NF16HD@BJY#oHK6ke`i)s(P@JU=Bk`P&4wEYVczc76p-|VzeN#)V6>Xha$(p
zr$AgCd^$I5KmT%|<WCBGE-;B|b26wHdxKyojX=U3?FHzbc>O(>fS&R`9N`)p0u)V5
zQkieQOf9=pr?v34RAoj_D2#^mB3WIPj5UkDf3HL|tG?BJtUFQO9`7$~oN}aY_hGvk
zt(_NHe?pj`bq0wufRe4={Gd~^i7U5nwlx4D)mfbbdpvZ_;uFH=V(Ar)P@Q?0ALQFJ
z__qLgPr8^i<NTY?kMUUHeXw#cH-oWw8KR%i^-b0lE>@dib<2Wb_)$i)7BN4P%g~>q
zz$VsG4C6CJ^_kACTsV>kKvbtWycd#vCdYi{iS8oD(KXUDG#_T}>(@DVmmv8F;y@2E
z)egICV&DgIfroN&U(!F<tn8$LELoD?T3kUuGyNkK#GUS-v`l;WSx3#I=*HvS2etHX
z24-#5r1Ya}JVjRFc486M=wZ&)@lmE#hdIo)ls&r{VO6-9D{v<=!l75vDZC0;D8O9!
z^?tV<p;+-s4!ea_>%XZ~nr6O!ZzidR^Jt0QpQ5k9*%9G7b1Q=%Xt{%UgJ}&Q=L0UJ
z2vNiU=4`DA&|rqv5BST}vRE{Tj8a6#y7LD<7x#668tU-(wLN6OluC{u9R&4@cZD<G
zl_hWvR&?y*5j*ax<Hp#B(tN(z<Zvr#`#*LGs4u5{3OFrY%58rn!uWnB@)D>;$q6-2
zy%%k{budrZ7F`C4RWhl&O@w#+_QoTTme~V&99C$SOn?vpdiH;kAsz3kaKnOv^L_~?
z`%Kd!<RLNs!b^1f*_ef{Q%GP1YLcoFzU|iW!R|tg-Mna3ha7@FW5rc1>#0R<HBT4P
zRokgvFq~kE0>)dF(vZqw2vTB0=vQKo1BO!90eKBji(WK<us5MJkkN1J*+n?!6Jw3v
z4qxLOx~e#&OdGV`rmKRSeFVz8$4L@p=-$>@EqfzZ&+v0Kj5qn_gjrwEi9OzPZ#x@b
zVL!)mU);BA<=6x9$};c>&399P=L-h0Yfv9ak;IgmIogR_8w;lQR;VoO_+$6L8jL!U
zmXeqW0emD>q1HjC<B7A%qBsc9@MMpHHR{dCj<nsJsx$a_L^{HEmTM2U{2xu!SsF4w
zp`^xG)WtEDtYs%2C>?oC8HJO6vo9m;_JyWWi_|0nDeUXx28|C=!<}jRdK?`Zs8d5b
z|K)Lg&4QAA&rqcNb(w)@M&S(y{nkTS5R2F_kBw7XIlst(_pZV8xs#Roe#xIYFg~MU
zq0fwmWt%X_Q;lWlAhl}|>ZUw6z0YYNP>CNL$0oNco0~QqqhOKn_tsmgAUjCPaqnAO
z=mX`arT6g<%NW1P;_)T0!g7$If=J2-C}Y03N*Fpa0KK3}?57Pf33<7%($XcX(jax@
zx8@=min=$Zg)dGQ<b6bcPH;zYBCRqt_GkbFLk)CSgl&-8e|?f*F}j-i&BtT2Z%TR{
zr|Lxj2G&CJ;^W>!p<=Qk{(8FkmfM?HZqaeewDh2ETGEWn<Av&mfYi?`S*HFuZMx{S
zV=1T0yHAf4dkymN{-!*w*w(@@<G?6mO0{3OY#>6PRnjm_?Q;gultgwI4wFUmcuA}%
z4KBOd-3Hu+&n-Z~-6=ewj>z#=PL(VO9%h##jT`^YK5_WI;F&j7zQRJPY#p3$y5%N=
z!hT@c)#CJSycf;iiBN~|=5PeH+~A>;IyD2zFCcu=bwqHv3ui7T1xsLZT5hSiKPN68
z1<7CE;|g?6Px~W>XOBF|QBLCSI?!@8uE|2=xMJvapivn~<HvPE<=NjHBiMc^?^DT|
zuQI^u>ZX7HE+pLrp7JJ_we{R-HY>U74VS-xqI^%LiUITxxXhbsKWv=BRcZP)Hmfpr
z;=ae60Le&nRrwx-#`%U(VukJ6&@X9EH$Kn2bhaf910Jqnt?D)t%=bOL6BFKeeRnL2
zY&e%G1DLinIT(T!o+#@o*?`IpO8lW=364|(m>6z>wV-%EZh*v^sNSa8+`(7qq`P2i
zqpZ0sV#10w6{oh`)TiJrL7B)}j1{O}enY#jt4()`%~QFm8o;(^uNG%YFD$;cc+U*s
z9<W{Qv$z;`H4>{^n>L<u!TtW#h^Pwl)LKNRS2-F@#v<_&4F?g{w)<LQ385KKO<(Yz
zXR(%J`Ux3{&XI@D=-wzb`dbvWSN=bKAcR=zJkwI7{cLmc(>bIyIzc!`rx{QZzvubu
ziHjM-(wO{+&NB2&i?1B*!<%kpvH@b?;;=P4{2utC;h^;}F@Yu3x9haCkUE8d1p0L?
z0a9O6OlQx1BEKYgo$5QsGpDO+1w3;!ODn;19Sw9VqcRA;;{bpj>)Wac6ma@%*u&iR
z+aG;lK{9yVzh1hG`Y<0Z_@5I71%Hv<py2<I5RC-&)$O?Hh}bkB+7xZVrmsQ48X#Jo
z?h!&a*+rb-sQyw}_m?kW{f8-|9jvr9R{GoF^5}1U{|^Qw2}qph?3o3B1{z@bJJyAw
zU(+OWk4*saABH+7QhQ5%n)SHZYwnu3_gE1oI`KC{rvSvsOe>se$oVXkqy})VEg+gL
zemYQ&26zDjd^vg}F7LN@n({tU<pQc}xA=~?cApd8;+yRO9_sdU0YVUOD!sKuAlF8_
z$#E6^2=eCra$dYRSE%sX)W292@9A$BjY6zFygoTZ!bbFVjNV>uZH^pa)%!=d%)+GV
z*(Cpx2;oJ@@j0|vymKs}K6}zk#i*!w``@2xZtj_Xs~D+J2_6sZOUyCh*lluRcB@l3
z@7Gh-w<6yiBuu!AJont$hcOCMdsp>^)}Bzuxtb<%LdD#!IPU3{if<3Y*nN#n4ofe6
zE!scw5s8QRewTuu4C9aReKtZNH35JV7HY!vp4r(w<9aBoqVr{kF~{*6*<6@?Y=SxT
zKJ{Ur1KTByPPDSOZb09?CL+w%aezQVH%-+$O({(pDHvowa6~@>aD|WBV=}Tz9sbvO
zZx1*ih{z_scFXpYB^GB}nhpr;vi6RNQTJS@r1tRu_Xl1MmCZqjq@xJ+Pb}eW8z_uF
z*AF2a)?(C)(QYZH&}W97$+kCJZCitsl(5rRN7348H`~RA^BijBald_1jbtHrv~Xf9
zvLBrYn|w=?D;mkPFO3jHdA^-SiVJ<2Gm|ESvXlSaQEi;{;mCCJq~!ZAI|8)$B6sf8
zI2n-VunRYdOj*ZlMB4_AORF&sF02H}XP3(*eYwBHMyt0W7Y1d?T_t{Jez^X9kC=~6
zmp-S+f*Hjmqj$-dP<xTu_rGe*&=9X~_kF3};eha&d}@L1oD*G8yt}sW?Ufj#Ea{*F
zEUeJ^Pi3>R{g6SSY;uKL35-9hZy-SjbQhzQc&!fY1=s~+1zhr_W`JEVX&ZKJZJHkr
zH{O)*h#qhF`!ye>Ljs-ksw^KojP-kDG4=Mn7w+xI{0Gh&fv<dSND|AuDh{&y@`UqD
zu&8?O9Kfd@r?aFf=pyP_F`#eZKdfojWfXFc5)u^+W(N8vI1hc$dob|Sn!GRRF7at6
z+3X4eRTAo$X@QVcFmz1^PeJQCkpIA_&d4yx(Sq=GyN?EUf?`88+YYRN$%!QEBuVvv
ze>tpzq;YO(U~a8pSw6RT9BRW@CQO`#>INL}jmMOR95>}VT|O(b^Q|5tPhXebP?&8T
zKx~rhzY<J|;$!PC=vPjvyCIzA?Anl~a1v_tp;gNo?MIx6sW!M>J0<IkPUp4_M;`06
ziMUdMh_Zc1vgH0G6Ixrug5EB{Y2zy+4DJ!k^EE8!_ge`S_lP{ae^>artVfd2_4)DM
zo5j!x<fye6)47;gO@cvMFFCF1s5OSFP4FKI@0WM9`WPk6c8vJ^8H<K0cjkuItqR8x
zW0!7dI;>@7^x`35PU!NDlW%&56y|<VJR)1&Mm8vfOX41x$=i85bau02-c$3FS!&t_
zafX%NjssMgHk;Pu$hzxolp(F*riHEz3W`VmaEIvFYV1)?1zcl#H+Y~V{BQ4-itSY_
zln%K>l=~jZQr}g+*_zgZ@+)sMkXXg5U+OC<p2CHZJ^E0Mobk0Y;g;n<+TW#V&PN*`
zSPVGm9!Ymb-+lT10K(?P4QJsv(;FZ-ht?p+@-+x<5}G7nFdqUFv6UP2A(*PrJUu0_
z1~dANkoHoV4S!e!S$O7F(QWH`PRyu@uth0~2wv?A)pi-TplYZ418{`pHph(~?MT6h
zFE5gQ`v&v_OO^<{*1?d_>w}_Mw*tGR5uUW80k3i8=2%Rd{>l4fve{hp{vtOW2jtE&
z1;T{EWfy^}Orw)K2=W45crK65L!Yg$d~rtBW5qY3?^0Hn6k-Qb-ZX1x71rdmw9mZf
z_(Ye3t`8v^-L-2l^PdI+y30XM3fFYA8Gn?VxBCphtwCo%Z~aq+N0xb^@_tN=Rn<LQ
za|0Rlc*VNCT!gm!ZYLd8vDSBc6<+X#GVUsTNKpGRwKYubfLj({)#YMzkY#7uak0CT
zW`#DwWvPb{r4@f@W`Z~Mw&T(89*tfvYjH|{*uB5i_oI;)<jl5Lb-RgNOh)3R&hHIk
z8}nRu0TK3;(Ud2^cyKUGr&FhmNmK<YG?R}qx$`N~j4-5;j*69?Vkyi=K6cupi3oeN
z;yXmC=#al``*19>YdqaN25sFb>?ThvHB5N#t0g0~qa?k~K3{7{ODxaon;{-Yr;L;P
zm?s(_FwCAl1(|JlMG#-MC-__D#HSj?>Rg`iT1&{_)<k$Y)*eo8+HaBcrH?$TyoO?+
ze?Od`?0mpNw-xgqYW**kxBoB4%pgngnvR`Ys$aNoXY0lkzD4%m!5;<}BF2dstk1aS
zhI^#hsV}EeRcmp!(wCQg^uhYRGfF`$W5h$uRf=)g1+7n}gHte^3Ov+%{rcYYo<rOR
z=9`~-w}(j^P2_6jFAP6SE~RguCAJoLXpLledCd9QH%qX*7$6?^$%^rDng9AGf0ANY
z*WxCz(DOO@N2mSNxN&1va9LD@<?2hLX{o5a(FKNI28MBYnf5{<YD%0eEFIA&o&2uO
z=E^>+7P0sc;4?F(lvjsuPkW4l7A$khGwhPUYK(^1fp(iFKl{F;Vg%cVY8A|Xy7;-v
zSSY-U4q`RoBMYT1L7vioM|YF&cgGHI+Uz#HJUi~!rmbfMJtvO7sf_X@WG5?Koqt`|
zo^Z=c{ZrJbbaz5%@a8G9);rIypoRRC0{d|Pa`vm9Q9j+2oIl=iK6#DmM%hb_nJb;&
ze!^Gojg(BcZ}2~rEEHfPAh)=F(NnLYKu$7~ol<_rk0>eRX%SaQ%}2kd9z?H#jKrdA
z<7SNS<a_kV^pp@6H}Z3LJV^mpDa(RsgzPuVE333P4Eio{+GvME=EkbbkD`b6Tt;&N
z{ZE`@E!Lz)`m5ts^vy!Wm_uBw6TG)oxg)JvIWm`w)?#zuz#+_+I9@{5bWgHY7zib4
z2NqJZk$CM5loE^7tJ488kR$lnuB`-dg#o2zH(tWMT@Cr@?VOmGcQWk}rA1WBsG)FD
z>Y=?)+0q`1tr)Tk2Pp15k{6De_X+Q>?CRctPVYn-A2k=JbU$e#h~QiZ8LfPn60|hp
z6{kFst?=Mxt3O@k*&2*R9EtN2KG%!;BsFW^<YFcg3mpnz#OE%B7+%b58k$loS4MXs
zWF=h{Ikc_HIzFK<ZvJ@#V0N?(dMa3p7|aRtB21d6h?P%B+EE#urx1C!YuoARo(0@V
z$OiOhF5hnj<%gja>d;-t4mnfCN_FZ)=F>VV{5$Tw?c`eHCQb0S#T}dmuFziw-IaD*
z-aSxWGg$FC2snxm+G)p$x8?Z)<@+fce+&t8G$KA8h9ioVS1dv_ztCAfUW9(WiaQ-s
z6(obMxfJ4yyo{D6u;B~QDBRT)t$-O9Zr1h8rT@uq6Eunp1LiPkE_^$Ho<4WldYI%(
zE{hsTk3p6z;KcDRtye1YZoBYufADi}@QSUTG+T6Bl!Mc-34z15ZvX2-r=v*4K7Xfl
zvhj5!K5MtRg>174Usv(iY_-;C2j9>X8{w-~6v@vWJ_D<=3HEeLjtGRr;tJc=`9^<v
zn)4!VEo=MhwgiIOeEQ`e%QVYUYW0<hCa<%8L>bK4HNMe0S5Sx=(DEMGgZ|PG7i9n~
zk)IzSH~Qz#HOspe%yo|`j(B<Z<V~u^c_w97euKazZzraF5C<+ff^Y#u4WEOE-*Y;Y
zwGg8vny&OY@A!hs4rcH$IoBaZ*)rh<28MICGK?;DwXA~?N4yeXr8$u#aWZgt!VL15
z;mMph=ycm)qT^9TDGCcYvy`e3CBTQdVbR!Wv%M;a)A!JgAywc{{xn4ksX}z_F^QpR
zu}1b6-*c*!w^7WzqXp=f6e;CBC+BPwa5JGUKOTZ<I%9MtawF^L{YdCgcz2|PE!xOs
zMZoDt%yE?SwRFhj!tA)c7Bk=g4i2SovF^|pW<-w5hoF#(=6iAPj;<f^>huZr7qb;s
zZAkTWez3*VaMUfhvzb7<4L-{UV@cCLv&Q!ki#SKWJeTjUYaCi48z@27i9C@4l-l;e
zgXmAe#IZ~JR5&g<Qdcad4V3Q+5(Vq`@?$!c=Xe}-K@_l`LcyzT#nALtAL|^nK|fMG
zvoJej$z9g5;Sb-&cOsQe+i?f_tfd@l124HSqm}Qe9FRS5sO4nsbHoZys}3{#(lRIT
z<bW)tnuhrjB(JFDh&R_c$Qxa(<w@AfL8DxY;A2_-(W&%D7Nd?V6fEXoCD23vPP|eY
z{w!93oEq<G@}YFyl-ls!9ybx;3*Yw-UGp2_WzBhU;Iit;8`BD_S#x9}di+=YVgVVw
zgKtY%d#Zg}5_6NtPxyLWJWOqVYkR_4jO@j7i?cq*6yB^>tq^`jj#{|u;Ih(Bti`DK
z6A^n0(I$k9>+2}99SLlw9BTPkCH?lp4r|e~LyJ46EkP)>_C~yC3l9d`zOv}dyxT#!
z=B6;f7W3UroiO?x1abGJB3(ahwQzj2!X+{HF3^79m%tHTuZ*d)7_BZk%|AGz#aM&k
z%QB0ox5o@_x{!C88alX8(KZGD*l<#$6mdggBDNsdl~P<`{-3SG%xR0ewm5aznCziZ
zJWhiUE4s<8@($4}pa=T*Pg9WbtJfJmbLmFF4noI4_i(jDU2As#_W_n26vg4Y>K~{X
z0ZAs#GtM`7dIVfcc61EV#EkQQe$HC>Mmq1>S6Xshu);{TOu5;@imn2tC-G&q+{4$7
z1@jBB_677l3zg~Gvsc1Te9f-Jt0{$MJ~?-9?oD#ReE)!b<wLdkZ|^FO8aD~~Tpj2P
zw)@zTwjxKc=r~t1;*ej5b+E;!Pspdg;*IxoRh^*scm~G!+Q94L`%SJFTL#{ZsZ3wm
zr-hK7A8z)T)$*Aie7z=kR`g2p7$uT4R^Zkh;XT&9O;6xfSN@tY<DO6w0a{v%zr)yx
zqZK&mdwLL8H5HMoa?|IGi{DB-p%?NkaOJRF_`=2cUTP@6E@k*+&;vC))w=XzmK2TL
z5!r;?2QPsmJ-UA=rMI_w*kj`W$Toz9tcc#FcrdaiS)1}6osl)%Bbj&0QSaYkzvS+L
z$roXNy}qmw9bLC~_~hlXs6V_T(efgUt5FsRi9=r##m)So-x6&V!dGJ~{w}2A6(ou|
zD4DFPZhLR7m?R(yDWw)D{}>9M)W+X4?{IU#lg-4*CHqDXDv&KwA6axhz9z`sm8O64
zhU5Ma(vKDPXRu76G3@Az&Yh=@j5zO{Q=XpOdA4^yE-&d)1Ts_X=S!hmM`F=~&O6f-
z%vM-vMJ`G;UHIUdI}OS0w-qEX`__O53={)XNHJSWNX)&pqa%Sp+90g&x>5bZuVFiw
z;58@*d~QZHm!Yoo&^6qEvzH)2KmtcDL3<(kbUS1P?B(;5D*cGF$m*dt)(2WT+%H73
z|GJXlEnpFPc&$fUkJf@Ez2io#YoE)b@u(BixO>;WeeB3a9~`ge%)P3}?Xk}>0_i>9
zo9qIgaEG}qV@8{dPy+1vnhy8*#88@TWX6qmubXf4t5lh88`~l1nRZ`IV}$L)=d{PG
zcfPQ2`~a<>>#N|&wiZr~gm1$*hC#x>Jvn*B8xd34?2*VzBAn>54jZWFbEpTW;X^pA
zDlJ4;422Ek*^!?n(Ruq4GwS@b5NY@Qk(V5AL04|FfqoGjihwN%aYrX|D$?pp5}nU|
zE-7bWwq>AD3|#myA}#yf%Cnu?1`jIHm#zn!#b2%`qcGO?5WY4VGU%Twx)(2ZUB>wz
z@W_yBb}7+5TJR5mHb9o>)8ge;WBRonbfvPs;5R8VP9VW494DgNHxS=JZ3gED1ruL3
z#f^Dd{l_)dQ)(Q+4SuV;@Be^g<FDxu13Kpg_#f;K)?x%bPa;kt($0XF<$hY=swW{&
za0>bXZ~$*74o*Kp!l#2!6Mp0;FXQo^g|N!PBVWejKouAd0CiwI6|@ajTv-3VJ)e#7
kfKlf8j4z+GHKMcEdh1`%6Kg}R0{@**JAE|i@I~MM1C_q2jsO4v

literal 65867
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


From 396c7812a6b2321e5ab5331a8a63092364b14cd3 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:15:36 +0000
Subject: [PATCH 18/19] =?UTF-8?q?Ferrow=20=EA=B8=B0=EB=A1=9D=EC=97=90=20?=
 =?UTF-8?q?=EC=9B=80=EC=A7=81=EC=9E=84=20=EC=9A=94=EC=B2=AD=EA=B3=BC=20?=
 =?UTF-8?q?=EB=A9=8B=EC=A7=90=20=EC=8B=AC=EC=82=AC=20=EC=97=AC=EC=84=AF=20?=
 =?UTF-8?q?=ED=8C=90=EC=9D=84=20=EC=A0=81=EB=8A=94=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/README.md              |  2 +-
 incoming/pattern-study/craft/01-figure/log.md | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/incoming/pattern-study/README.md b/incoming/pattern-study/README.md
index 0ee6c3ff..0b42b490 100644
--- a/incoming/pattern-study/README.md
+++ b/incoming/pattern-study/README.md
@@ -15,7 +15,7 @@
 | 패턴 | 작품 | 한 줄 |
 | --- | --- | --- |
 | [Tamsel](patterns/tamsel.js) | 작품 1 | 밤거리 가스등에 불을 붙이는 견습 점등꾼이 받침 위에 한 손은 허리에, 한 손은 갈고리 끝에 불씨를 매단 놋쇠 장대에 얹고 서서 숨 쉬고 깜빡여요. |
-| [Ferrow](patterns/ferrow.js) | 작품 1 | 무너진 성채의 문을 이백 년째 지키는 파수 로봇이 받침 위에 한 손은 허리에 얹고, 홈이 호박색으로 달아오른 대검을 어깨에 멘 채 숨 쉬며 증기를 뿜고, 가끔 그 대검을 받침에 꽂아 불꽃을 튀겨요. |
+| [Ferrow](patterns/ferrow.js) | 작품 1 | 무너진 성채의 문을 이백 년째 지키는 파수 로봇이 받침 위에 한 손은 허리에 얹고, 홈이 호박색으로 달아오른 대검을 어깨에 멘 채 숨 쉬다가, 6.8초마다 그 대검을 받침에 꽂아 불꽃을 튀기고 등으로 증기를 뿜어요. |
 
 ## 추려 보기
 
diff --git a/incoming/pattern-study/craft/01-figure/log.md b/incoming/pattern-study/craft/01-figure/log.md
index 50891779..4986c863 100644
--- a/incoming/pattern-study/craft/01-figure/log.md
+++ b/incoming/pattern-study/craft/01-figure/log.md
@@ -129,3 +129,21 @@
 - 따로 띄운 멋짐 심사(총괄 완료 기준 8): 캐릭터 디자이너 5 · 패널 앞 관객 5. 비평 1 때 5·5, 비평 2 때 5·6
 - 걸린 멈춤: 되돌림 세 번 이어짐(패스 4·5·6), 막힘 둘(대검이 머리에 붙음, 두 다리가 무게를 똑같이 나눔)
 - 창작자에게: 로봇은 섰지만 멋짐 심사는 5점이에요. 판정단이 고르게 짚은 것은 대검이 머리 뒤로 가려 뿔처럼 읽히는 것, 뼈색 한 톤이라 금속으로 안 읽히는 것, 판금 갑옷 소년과 닮은 얼굴판이에요. 대검을 머리 옆으로 꺼낸 판(패스 1·2)은 캐릭터와 사진가가 두 순서 다 새 판을 골랐는데 블라인드 읽기 맞은 수가 그대로라 들어가지 못했어요
+
+## 86판 창작자 요청 2 · 움직임과 이펙트 · 시작 78f7f5c
+- 창작자 요청(11-01 19:08): 「근데 움직임 구현같은건 안돼? 너무 정적인데. 아님 주변 이펙트라도... 어렵나..?」 · 길 a 의 Ferrow 에 큰 동작과 이펙트를 넣음. 바퀴 규칙의 「진열장 안에서 일어날 만한 것만」과 「받침 밖이 꺼져 있고 무늬나 움직임이 없어요」보다 창작자 요청이 앞섬. 판정단 A/B 없이 들어가고, 총괄 완료 기준인 멋짐 심사(움직임·이펙트 항목 더함)로만 봄
+- 자세 둘을 새로 그림: 허리춤에서 칼을 세워 든 M(칼끝 y4), 같은 손에서 칼을 거꾸로 돌려 받침에 꽂은 B(칼끝 y117). 칼날은 세 자세 다 49줄에 같은 칠. 어깨에 멘 칼과 팔이 몸에 드리운 그림자 21 LED 는 M·B 에서 걷고, 칼이 가리던 머리 왼쪽 y11~20 에 림을 새로 침
+- 큰 동작: 6.8초마다(3.4, 10.2, 17.0, 23.8초). 몸 1px 낮추며 칼을 들어 올림 → M → 3px 치켜듦 → B(꽂힘: 몸 2px 내려앉아 0.2초, 윤곽과 받침 금 테가 하얗게, 칼끝 번쩍임과 불꽃, 받침 위 불티) → 2초 기대어 섬, 그동안 배기통 둘이 구름 넷씩 → M → 어깨
+- 작은 동작: 눈이 투구 틈 안에서 2px 옆을 봄(여섯 번, 꽂기 사이). 깜빡임은 눈을 새로 칠하는 길로 다시 맞춤(85판 바퀴 끝에 넘긴 `LIDS` 어긋남이 이걸로 풀림)
+- 노브: K1 림 젤 → 움직임(기본 6.8초, 활발 3.4초, 경계: 칼을 세워 들고 흰 눈, 대기: 꽂은 칼에 기대 고개 1px 떨굼과 숯불 줄 눈) · K3 디테일 컷 → 이펙트(증기와 불꽃, 충전, 과열, 끔). 디테일 컷은 K3 탭. 반응 K1 0.0826 · K2 0.0224 · K3 0.0542 · K4 0.0823
+- 한 프레임 깜빡임: 처음엔 눈 돌림이 머리 숨 걸음 옆에 붙어 5곳, 충전 아크가 림과 같은 색이라 1곳, 과열 증기가 칼날과 같은 색이라 8곳. 모든 움직임을 초당 15걸음(Lab 의 두 프레임)으로 맞추고 노브와 디테일 컷도 걸음에 받으니 0(노브 여덟 자리 40~82초, 버튼을 섞은 30초 넷)
+- 선 판: 23색(쉬는 프레임) · 근백색 8 · 10초에 바뀌는 LED 68.6%
+- 멋짐 심사(움직임·이펙트 항목 더함, 판마다 새 판정 둘): 캐릭터 디자이너 · 패널 앞 관객
+  - 고침 1(첫 움직임): 5 · 6. 세운 칼이 30줄로 짧았다가 꽂으면 50줄, 증기가 뼈대 색 1px 점선, 경계와 활발이 같은 그림
+  - 고침 2(세 자세 같은 칼, 휘두른 자국 둘, 숨 뒤 증기 덩이, 경계는 세운 칼, 대기는 꽂은 칼): 5 · 6. 꽂는 순간에 무게가 없음, 자국이 1px 실
+  - 고침 3(몸이 내려앉음, 받침 테 번쩍임, 충전 눈과 칼 홈, 과열을 장갑보다 밝게): 6 · 7
+  - 고침 4(예비 동작 둘, 굵은 자국): 7 · 6. 휘두르기가 한 프레임 순간이동, 증기가 칼끝 옆 먼지
+  - 고침 5(빛 고리, 윤곽 번쩍임, 6.8초 박자): 6 · 6. 초승달 자국이 활대로, 빛 고리가 머리카락으로 읽힘
+  - 고침 6(자국과 고리와 늘 뜨던 증기를 걷고, 꽂은 뒤 큰 구름, 무게 0.2초): 6 · 6. 뒤집어 꽂기가 그림 교체로 보이고, 흰 증기 구름이 스티커나 말풍선 같음
+- 판마다 짚은 자리가 옮겨 다녔고, 다섯 번째부터 6~7 에서 더 오르지 않음. 둘이 끝까지 같이 짚은 것: 쉬는 자세에서 대검이 머리 뒤 뿔로 읽힘(86판 바퀴 끝과 같은 지적), 세움에서 꽂음까지 한 프레임, 장갑이 한 톤 베이지
+- 창작자에게: 움직임과 이펙트는 들어갔지만 멋짐 심사는 6~7점이라 8점에 못 닿았어요. 판정 둘이 마지막까지 짚은 것은 시간의 절반을 차지하는 어깨에 멘 자세에서 대검이 뿔로 읽히는 것이에요. 쉬는 자세를 칼을 세워 든 자세로 바꿀지는 창작자가 정할 일이라 그대로 두었어요

From 9480e2a6db35b42db22ecfb121e1e18ed135610c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 1 Nov 2026 11:54:08 +0000
Subject: [PATCH 19/19] =?UTF-8?q?index.html=20=EC=9D=84=20=EC=9B=80?=
 =?UTF-8?q?=EC=A7=81=EC=9D=B4=EB=8A=94=20Ferrow=20=EB=A1=9C=20=EB=8B=A4?=
 =?UTF-8?q?=EC=8B=9C=20=EC=93=B4=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018svN6XxkaPoubnawT9DrJr
---
 incoming/pattern-study/index.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/incoming/pattern-study/index.html b/incoming/pattern-study/index.html
index abd7ff15..68949b6f 100644
--- a/incoming/pattern-study/index.html
+++ b/incoming/pattern-study/index.html
@@ -210,8 +210,8 @@ <h1>패턴 연구</h1>
   </details>
 </main>
 <dialog id="card"></dialog>
-<script id="study-data" type="application/json">{"patterns":[{"slug":"abracadabra","title":"Abracadabra","family":"type","round":73,"note":"ABRACADABRA 열한 줄이 한 글자씩 줄며 128줄을 내려가고, 열이 위에서 아래로 지나가며 줄마다 빠지는 한 글자를 태워 재로 부숴요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-abracadabra","type":"code","name":"abracadabra","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Form=0..2, Cooling=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Form","min":0,"max":2},{"name":"Cooling","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0476,"detail":0.1064,"edges":0.8578,"complexity":0.3125,"coverage":0.1968,"colour":0.1195,"drift":0.0544},"knobResponse":[0.0421,0.0455,0.0769,0.0452]},{"slug":"abrikosov-lattice","title":"Abrikosov Lattice","family":"physics","round":62,"note":"빠르게 도는 보스-아인슈타인 응축체가 세운 패널을 채우고, 위상이 색이고 밀도가 밝기라서 양자 소용돌이마다 모든 색이 한 번씩 감기는 검은 심이 돼요. 심들은 삼각 격자로 서서 유체와 함께 돌고, Rotation 을 올리면 간격이 좁아지며 어두운 가장자리에서 새 소용돌이가 들어와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-abrikosov-lattice","type":"code","name":"abrikosov-lattice","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rotation=0.3..0.95, Round=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rotation","min":0.3,"max":0.95},{"name":"Round","min":0,"max":1}],"start":[0,2,0.3,0.06],"measures":{"motion":0.1114,"detail":0.0307,"edges":0,"complexity":2.4522,"coverage":0.8728,"colour":0.5618,"drift":0.1244},"knobResponse":[0.3979,0.2644,0.2694,0.1322]},{"slug":"abyss","title":"Abyss","family":"ocean","round":16,"note":"물결 밑 햇빛층에서 심해 바닥까지 바다 한 기둥이 128줄에 서요. 빛내림과 정어리 떼 아래로 관해파리와 샛비늘치, 아귀의 미끼 불빛을 지나 잠수정이 등을 켜고 열수 분출공까지 내려갔다 올라와요. K1 을 누르면 죽은 고래가 기둥을 다 가라앉아 바닥에 뼈로 남아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-abyss","type":"code","name":"abyss","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Night=0..1, Speed=0.2..3, Current=-1..1, Bloom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Night","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Current","min":-1,"max":1},{"name":"Bloom","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1244,"detail":0.039,"edges":0.3461,"complexity":1.1983,"coverage":0.6808,"colour":0.2784,"drift":0.0583},"knobResponse":[0.1135,0.059,0.0565,0.0734]},{"slug":"agate","title":"Agate","family":"mineral","round":20,"note":"라이트박스에 올린 블루 레이스 마노 단면이 패널을 거의 다 채우고, 1 LED 남짓한 하늘색 띠와 젖빛 띠가 갈색 껍질을 따라 겹겹이 들어가 석영 결정이 반짝이는 빈 속에 닿아요. 톱이 천천히 더 깊이 썰어 들어가며 띠가 흐르고, K1 을 누르면 날이 라이트박스를 가로지르며 새 마노 덩어리의 단면이 깔려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-agate","type":"code","name":"agate","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stain=0..1, Speed=0.2..3, Width=1..4, Light=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stain","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Width","min":1,"max":4},{"name":"Light","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2044,"detail":0.342,"edges":0.8294,"complexity":2.5192,"coverage":1,"colour":0.128,"drift":0.0573},"knobResponse":[0.1001,0.2798,0.2989,0.0578]},{"slug":"aharonov-bohm","title":"Aharonov-Bohm","family":"wave","round":69,"note":"평면파가 패널을 위에서 아래로 내려오며 3분의 1 높이의 가는 자속관을 지나면, 자기장이 닿지 않는데도 관 뒤 그림자 선 양쪽의 마루가 자속만큼 어긋난 채 어두운 솔기에서 끊기고, 마루 빛깔이 관이 없을 때보다 얼마나 밀렸는지를 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-aharonov-bohm","type":"code","name":"aharonov-bohm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wavelength=7..16, Flux=0.5..1.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wavelength","min":7,"max":16},{"name":"Flux","min":0.5,"max":1.5}],"start":[0,2,7,0.5],"measures":{"motion":1.7809,"detail":0.1223,"edges":0.5237,"complexity":1.8374,"coverage":0.4378,"colour":0.2606,"drift":0.0554},"knobResponse":[0.1545,0.2573,0.2457,0.2735]},{"slug":"airy-beam","title":"Airy Beam","family":"wave","round":73,"note":"유한 에너지 에어리 빔이 위에서 들어와 주 로브와 곁 로브가 함께 포물선으로 휘며 내려가고, 위쪽에서 오가는 작은 구슬이 가린 로브는 아래에서 다시 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-airy-beam","type":"code","name":"airy-beam","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Truncation=0.04..0.4, Tilt=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Truncation","min":0.04,"max":0.4},{"name":"Tilt","min":-1,"max":1}],"start":[0,2,0.04,0.06],"measures":{"motion":0.0737,"detail":0.0427,"edges":0.1158,"complexity":2.1892,"coverage":0.6671,"colour":0.2485,"drift":0.0815},"knobResponse":[0.1936,0.056,0.0862,0.1557]},{"slug":"alphabet-lineage","title":"Alphabet Lineage","family":"type","round":82,"note":"사람 머리, 눈, 물, 소머리의 원시 시나이 그림 넷이 패널 아래로 쌓여 페니키아 글자로 휘고, 카드처럼 뒤집혀 오른쪽을 보는 그리스 글자가 된 뒤 굵고 가는 획과 세리프를 단 로마 대문자 ROMA 로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-alphabet-lineage","type":"code","name":"alphabet-lineage","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Lag=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":5},{"name":"Lag","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1574,"detail":0.0452,"edges":0.2195,"complexity":0.765,"coverage":0.2643,"colour":0.1547,"drift":0.0926},"knobResponse":[0.0431,0.1074,0.0835,0.0569]},{"slug":"ammann-beenker","title":"Ammann-Beenker","family":"geometry","round":64,"note":"정사각형과 45도 마름모로 된 팔각 비주기 타일링이 수직 공간에서 미끄러지면, 패널을 가로지르는 한 줄의 육각형들이 한꺼번에 뒤집혀요. 육각형마다 정사각형 하나와 마름모 둘이 미끄러져 자리를 바꾸며 하얗게 빛났다가 가라앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ammann-beenker","type":"code","name":"ammann-beenker","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Phason=0.2..3, Size=8..16, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Phason","min":0.2,"max":3},{"name":"Size","min":8,"max":16},{"name":"Glow","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.1944,"detail":0.2227,"edges":0.8433,"complexity":0.4519,"coverage":0.7641,"colour":0.4667,"drift":0.0622},"knobResponse":[0.3704,0.1224,0.3537,0.1676]},{"slug":"anagram","title":"Anagram","family":"type","round":76,"note":"세로로 선 LISTEN 의 글자들이 저마다 색을 지닌 채 S 자 길로 미끄러져 SILENT 가 되고, 길이 엇갈릴 때마다 튀는 불꽃이 켄들 거리를 세요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-anagram","type":"code","name":"anagram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Set=0..7, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Set","min":0,"max":7},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3574,"detail":0.0563,"edges":0.5169,"complexity":0.4781,"coverage":0.2256,"colour":0.181,"drift":0.1376},"knobResponse":[0.0738,0.0892,0.12,0.0504]},{"slug":"analemma","title":"Analemma","family":"celestial","round":15,"note":"일 년 동안 같은 시각에 찍은 해가 바다 위 하늘에 8자를 그려요. K1 이 시각을 아침에서 저녁까지 돌려 8자를 눕히고, K4 를 올리면 화성의 눈물방울 모양이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-analemma","type":"code","name":"analemma","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=-1..1, Speed=0.2..3, Latitude=-1..1, Orbit=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Latitude","min":-1,"max":1},{"name":"Orbit","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0266,"detail":0.0181,"edges":0.3039,"complexity":1.0442,"coverage":0.9984,"colour":0.1966,"drift":0.0308},"knobResponse":[0.0776,0.085,0.0971,0.0827]},{"slug":"anamorphosis","title":"Anamorphosis","family":"type","round":65,"note":"깊이가 제각각인 판과 상자 열세 개에 한 시점에서 비춘 것처럼 낱말을 칠해 두고, 카메라가 둘레를 8자로 날아요. 그 시점을 지나는 1초 남짓만 색 조각이 이어져 HERE 가 읽혀요","why":"","block":0,"ramped":false,"layer":{"id":"layer-anamorphosis","type":"code","name":"anamorphosis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Flatten=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":4},{"name":"Flatten","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.608,"detail":0.0669,"edges":0.6264,"complexity":0.5941,"coverage":0.7919,"colour":0.616,"drift":0.3963},"knobResponse":[0.3406,0.276,0.205,0.2121]},{"slug":"anderson-localization","title":"Anderson Localization","family":"wave","round":38,"note":"위치 에너지가 무작위로 놓인 사슬의 한 자리에 양자 입자를 놓고, 자리를 가로로, 시간을 세로로 그려요. 깨끗한 사슬이라면 점선을 따라 패널 끝까지 벌어졌을 원뿔이 27 LED 너비에서 멈추고, 얼룩진 기둥으로 끝까지 서 있어요. K3 은 무질서를 키워 기둥을 12 LED 까지 좁히고, K1 을 누르면 새 에너지와 새 자리에서 바로 다시 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-anderson-localization","type":"code","name":"anderson-localization","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Disorder=4..12, Samples=1..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Disorder","min":4,"max":12},{"name":"Samples","min":1,"max":16}],"start":[0,2,4,1],"measures":{"motion":0.0706,"detail":0.0573,"edges":0.2197,"complexity":1.2567,"coverage":0.5738,"colour":0.1923,"drift":0.1291},"knobResponse":[0.0885,0.0786,0.0464,0.0484]},{"slug":"andrews-curves","title":"Andrews Curves","family":"data","round":56,"note":"다섯 차원의 합성 점 40 개가 앤드루스 곡선이 되어 세 빛깔 다발로 꼬여요. 그랜드 투어가 데이터를 돌리는 동안 흰 곡선과 이웃 곡선 사이 틈은 부풀었다 오므라들지만, 바닥의 흰 막대는 길이가 그대로예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-andrews-curves","type":"code","name":"andrews-curves","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=0.12..0.6, Dims=5..9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":0.12,"max":0.6},{"name":"Dims","min":5,"max":9}],"start":[0,2,0.12,5],"measures":{"motion":0.2693,"detail":0.082,"edges":0.5228,"complexity":1.2778,"coverage":0.4709,"colour":0.3484,"drift":0.254},"knobResponse":[0.1694,0.208,0.2481,0.1765]},{"slug":"anscombes-quartet","title":"Anscombe's Quartet","family":"data","round":52,"note":"회귀선이 같은 앤스컴의 산점도 넷이 쌓였다가 한 그림으로 펴지고, 점 264개가 다섯 통계를 소수 둘째 자리까지 지킨 채 원과 별, 과녁과 빗금으로 모양을 바꾸는 동안 회귀선과 십자선은 꿈쩍하지 않아요. K3 은 담금질 온도, K4 는 점에서 선까지 내린 잔차 막대예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-anscombes-quartet","type":"code","name":"anscombes-quartet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Heat=0..1, Residuals=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Heat","min":0,"max":1},{"name":"Residuals","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.174,"detail":0.0764,"edges":0.907,"complexity":0.2046,"coverage":0.2024,"colour":0.1426,"drift":0.0225},"knobResponse":[0.054,0.1216,0.0387,0.0405]},{"slug":"ant-farm","title":"Ant Farm","family":"insect","round":17,"note":"유리 사이에 모래를 채운 개미집에서 수확개미들이 바닥의 여왕 방까지 굴을 파고, 판 모래를 입구 옆 더미에 올리거나 오래된 막다른 굴에 다시 다져 넣어요. K1 을 누르면 뚜껑으로 물을 줘서 젖은 모래 얼룩이 천천히 아래로 번져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-ant-farm","type":"code","name":"ant-farm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fill=0..1, Speed=0.2..3, Ants=40..120, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fill","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ants","min":40,"max":120},{"name":"Lamp","min":0,"max":1}],"start":[0,2,40,0.06],"measures":{"motion":0.0748,"detail":0.0791,"edges":0.3143,"complexity":0.7035,"coverage":0.9824,"colour":0.2295,"drift":0.0611},"knobResponse":[0.2509,0.0544,0.0511,0.2616]},{"slug":"antoine-necklace","title":"Antoine's Necklace","family":"space","round":37,"note":"경기장 트랙 모양 유리 목걸이 안에 고리 18개가 이웃끼리 한 번씩 걸린 사슬이 들어 있고, 고리마다 목걸이 전체를 0.184배로 줄인 꼴이라 그 안에 또 사슬이 있어요. 카메라가 고리 하나로 9초에 한 세대씩 날아 들어가면 겉은 유리 테두리로 얇아지고 속 사슬이 단단해져서, 9초 뒤에는 색만 한 세대 넘어간 처음 그림이 돼요. K3 은 사슬의 고리를 30개까지 늘리고, 누르면 옆의 고리로 옮겨 들어가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-antoine-necklace","type":"code","name":"antoine-necklace","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Links=18..30, Turn=45..90","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Links","min":18,"max":30},{"name":"Turn","min":45,"max":90}],"start":[0,2,18,45],"measures":{"motion":0.8976,"detail":0.0847,"edges":0.5082,"complexity":1.4555,"coverage":0.5229,"colour":0.1494,"drift":0.2617},"knobResponse":[0.1332,0.2651,0.185,0.2969]},{"slug":"apollonius-problem","title":"Problem of Apollonius","family":"geometry","round":71,"note":"세 흰 원이 패널 위를 떠다니는 동안 셋 모두에 접하는 원 여덟 개가 안팎 접촉에 따라 제 색으로 그려지고 접점마다 밝은 점이 찍히다가, 흰 원 둘이 겹치면 넷이 짝지어 합쳐지며 사라졌다 떨어지면 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-apollonius-problem","type":"code","name":"apollonius-problem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pair=0..4, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pair","min":0,"max":4},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8856,"detail":0.0945,"edges":0.7721,"complexity":0.7452,"coverage":0.1997,"colour":0.1905,"drift":0.1245},"knobResponse":[0.0633,0.1446,0.0701,0.1497]},{"slug":"aquarium","title":"Aquarium","family":"pixel","round":2,"note":"높은 수조에 흰동가리, 블루탱, 엔젤피시, 네온테트라 떼가 꼬리를 흔들며 헤엄쳐요. 모래 위 보물상자가 몇 초마다 뚜껑을 열어 공기 방울을 뱉고, K1 을 누르면 먹이가 떨어져 물고기가 몰려와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-aquarium","type":"code","name":"aquarium","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Water=0..1, Swim=0.2..4, Fish=6..18, Light=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Water","min":0,"max":1},{"name":"Swim","min":0.2,"max":4},{"name":"Fish","min":6,"max":18},{"name":"Light","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.1521,"detail":0.0707,"edges":0.4986,"complexity":0.73,"coverage":0.9459,"colour":0.2752,"drift":0.0492},"knobResponse":[0.1007,0.0662,0.0696,0.1627]},{"slug":"arcsine-law","title":"Arcsine Law","family":"data","round":54,"note":"공정한 동전 던지기 걸음 48개가 열마다 한 걸음에 한 줄씩 내려오며, 위로 간 걸음은 밝고 아래로 간 걸음은 어두워서 동전은 잡음처럼 흩어지는데, 0 위면 호박색이고 0 아래면 하늘색인 색은 대부분의 열에서 한 가지로 길게 이어져요. 126걸음이 끝나면 열마다 호박색 칸이 위로 떠올라 모이고 열이 그 수대로 줄을 서서 두 색의 경계가 아크사인 분위 곡선을 그리고, 옆의 히스토그램은 지금까지의 모든 걸음을 모아 레비의 U 자 법칙으로 다가가요. K3 은 줄 세우는 통계를 고르고, K4 는 걸음의 치우침이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-arcsine-law","type":"code","name":"arcsine-law","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Statistic=0..2, Drift=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Statistic","min":0,"max":2},{"name":"Drift","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0788,"detail":0.3087,"edges":0.905,"complexity":1.0822,"coverage":0.7327,"colour":0.379,"drift":0.2319},"knobResponse":[0.2567,0.2918,0.1212,0.3021]},{"slug":"arnold-tongues","title":"Arnold Tongues","family":"rhythm","round":32,"note":"아래 가장자리의 분수 p/q 마다 혀가 하나씩 위로 자라 벌어져요. 양옆은 0/1 과 1/1 혀, 가운데는 분홍 1/2 혀, 그 양쪽은 초록 1/3 과 2/3 혀예요. 혀마다 q박에 한 번 번쩍여서 판 전체가 13박까지의 폴리리듬으로 뛰고, 회색 탐침선이 오르내리며 그 높이의 악마의 계단을 그어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-arnold-tongues","type":"code","name":"arnold-tongues","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=0.2..3, Zoom=0..1, Depth=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":0.2,"max":3},{"name":"Zoom","min":0,"max":1},{"name":"Depth","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3954,"detail":0.0597,"edges":0.7533,"complexity":0.3067,"coverage":1,"colour":0.3016,"drift":0.0852},"knobResponse":[0.2048,0.0673,0.163,0.058]},{"slug":"art-gallery","title":"Art Gallery","family":"geometry","round":61,"note":"키 큰 다각형의 귀를 하나씩 잘라 삼각형으로 나누고 꼭짓점을 세 색으로 칠하면, 가장 적은 색의 꼭짓점에 선 경비원들의 빛이 갤러리를 빈틈없이 밝혀요. 세 번에 한 번은 이빨마다 경비원이 하나씩 있어야 하는 흐바탈의 빗이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-art-gallery","type":"code","name":"art-gallery","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Corners=12..30, Depth=0.6..0.95","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Corners","min":12,"max":30},{"name":"Depth","min":0.6,"max":0.95}],"start":[0,2,12,0.6],"measures":{"motion":0.1274,"detail":0.0489,"edges":0.5274,"complexity":1.0928,"coverage":0.6088,"colour":0.1804,"drift":0.3073},"knobResponse":[0.054,0.1398,0.1472,0.1053]},{"slug":"artin-braids","title":"Artin Braids","family":"topology","round":67,"note":"위 띠의 점 셋에서 일곱이 생성원마다 이웃과 반 바퀴 돌아 자리를 바꾸고, 그 자취가 아래로 흘러 앞으로 지난 가닥은 이어지고 뒤로 지난 가닥은 끊긴 브레이드가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-artin-braids","type":"code","name":"artin-braids","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Word=0..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":3,"max":7},{"name":"Word","min":0,"max":4}],"start":[0,2,3,0.06],"measures":{"motion":0.6036,"detail":0.0466,"edges":0.4184,"complexity":0.8835,"coverage":0.3211,"colour":0.2698,"drift":0.145},"knobResponse":[0.1127,0.1251,0.1771,0.111]},{"slug":"aurora","title":"Aurora","family":"light","round":1,"note":"떠도는 선에 빛 커튼이 걸리고, 빛줄기는 커튼이 흔들리는 것보다 느리게 일렁여요.","why":"예쁘지만 거의 제자리예요(움직임 0.04).","block":1,"ramped":true,"layer":{"id":"layer-aurora","type":"code","name":"aurora","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":0.18,"color":"#04122e","alpha":1},{"position":0.45,"color":"#0b6b5a","alpha":1},{"position":0.72,"color":"#3dff9a","alpha":1},{"position":0.9,"color":"#b8ffd9","alpha":1},{"position":1,"color":"#f0c8ff","alpha":1}],"mode":"oklab","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sway=0..1, Speed=0.1..5, Curtains=1..4, Rays=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sway","min":0,"max":1},{"name":"Speed","min":0.1,"max":5},{"name":"Curtains","min":1,"max":4},{"name":"Rays","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0423,"detail":0.0219,"edges":0.176,"complexity":1.1219,"coverage":0.4849,"colour":0.2574,"drift":0.0814},"knobResponse":[0.0412,0.0639,0.142,0.0829]},{"slug":"autogram","title":"Autogram","family":"type","round":72,"note":"제 글자 수를 늘어놓은 영어 문장을 글자마다 세어 주장과 맞춰 보고, 주장을 흔들면 틀린 문장을 센 수로 거듭 다시 쓰다 고리에 갇혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-autogram","type":"code","name":"autogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sentence=0..2, Doubt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sentence","min":0,"max":2},{"name":"Doubt","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0516,"detail":0.1474,"edges":0.9742,"complexity":0.1413,"coverage":0.1899,"colour":0.1454,"drift":0.0275},"knobResponse":[0.045,0.0894,0.0984,0.0516]},{"slug":"autostereogram","title":"Autostereogram","family":"type","round":74,"note":"무작위 색 점에 세 글자 낱말을 깊이로만 숨긴 단일 화면 입체 그림이고, 띠가 내려가며 LED 마다 한 주기 왼쪽 LED 와 견주면 낱말이 흰 점으로 드러나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-autostereogram","type":"code","name":"autostereogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Depth=-3..3, Period=11..15, Reveal=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Depth","min":-3,"max":3},{"name":"Period","min":11,"max":15},{"name":"Reveal","min":0,"max":1}],"start":[0,2,11,0.06],"measures":{"motion":0.1627,"detail":0.2351,"edges":0.7646,"complexity":1.782,"coverage":0.9412,"colour":0.3323,"drift":0.1174},"knobResponse":[0.1738,0.1554,0.1867,0.2562]},{"slug":"axon","title":"Axon","family":"body","round":23,"note":"어두운 조직 속에서 신경세포 하나가 초록 형광으로 빛나요. 세포체를 떠난 스파이크가 수초 사이의 랑비에 결절을 하나씩 건너뛰며 축삭을 내려가고, 말단 단추가 시냅스 틈 너머로 신호를 넘기면 아래의 자홍색 신경세포가 따라 켜져요. K4 를 올리면 수초가 벗겨져 신호가 기어가다 꺼져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-axon","type":"code","name":"axon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dye=0..1, Speed=0.2..3, Rate=1..8, Damage=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dye","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rate","min":1,"max":8},{"name":"Damage","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2284,"detail":0.0799,"edges":0.4159,"complexity":1.8734,"coverage":0.4953,"colour":0.2394,"drift":0.0867},"knobResponse":[0.1239,0.0564,0.0498,0.061]},{"slug":"aztec-diamond","title":"Aztec Diamond","family":"cells","round":28,"note":"아즈텍 다이아몬드 여덟 개가 패널을 덮고 저마다 도미노 셔플로 자라요. 도미노가 제 방향으로 한 LED 씩 미끄러지고 빈 2×2 칸에 새 쌍이 들어서면, 다 자란 다이아몬드의 네 모서리는 한 색 벽돌로 얼고 북극권 원 안만 뒤섞여요. K3 이 가로와 세로의 몫을 기울여 원을 타원으로 바꾸고, 누르면 처음부터 다시 자라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-aztec-diamond","type":"code","name":"aztec-diamond","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=-1..1, Checker=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":-1,"max":1},{"name":"Checker","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2173,"detail":0.3498,"edges":0.9816,"complexity":1.6331,"coverage":0.888,"colour":0.6403,"drift":0.1071},"knobResponse":[0.459,0.1665,0.2603,0.1486]},{"slug":"bait-ball","title":"Bait Ball","family":"ocean","round":23,"note":"옆에서 본 푸른 바다를 정어리 떼 공이 거의 다 채워요. 떼가 한꺼번에 몸을 틀면 은빛 물결이 공을 가로지르고, 등을 돌리면 짙은 남색으로 가라앉아요. 상어와 돌고래가 뚫고 지나간 구멍은 뒤에서 다시 닫히고, 가넷이 수면에서 거품 꼬리를 끌며 내리꽂혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bait-ball","type":"code","name":"bait-ball","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Water=0..1, Speed=0.2..3, Predators=1..5, Sun=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Water","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Predators","min":1,"max":5},{"name":"Sun","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.8889,"detail":0.2376,"edges":0.5511,"complexity":1.4993,"coverage":0.9518,"colour":0.2846,"drift":0.3724},"knobResponse":[0.0519,0.3412,0.1352,0.1016]},{"slug":"bak-sneppen","title":"Bak-Sneppen","family":"data","round":50,"note":"종 64개의 적합도 막대에서 가장 낮은 것과 양옆을 거듭 새로 뽑으면 막대의 바닥이 저절로 0.62 까지 오르고, 새 색의 사태가 가장 낮은 자리를 따라 번지다 멀리 뛰어요. K3 은 양옆을 고리 어디서나 고를 확률, K4 는 막대가 오래된 색이 되는 데 걸리는 걸음이고, K1 을 누르면 막대를 다시 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bak-sneppen","type":"code","name":"bak-sneppen","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Random=0..1, Memory=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Random","min":0,"max":1},{"name":"Memory","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5993,"detail":0.0856,"edges":0.259,"complexity":0.0878,"coverage":0.7857,"colour":0.385,"drift":0.0935},"knobResponse":[0.3999,0.1659,0.2098,0.1043]},{"slug":"balanced-rhythms","title":"Balanced Rhythms","family":"rhythm","round":62,"note":"재생 헤드가 위의 걸음 고리를 돌며 친 걸음마다 중심에서 그 단위 벡터를 긋고, 아래에서는 같은 벡터를 꼬리에 머리를 이어 붙인 걸음이 마디 끝마다 출발점으로 돌아와요. 첫 리듬은 오각형과 삼각형에서 둘을 잇는 이각형을 뺀 여섯 걸음이라, 어느 정다각형의 합집합도 아닌데 걸음이 닫혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-balanced-rhythms","type":"code","name":"balanced-rhythms","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rhythm=0..1, Rotate=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rhythm","min":0,"max":1},{"name":"Rotate","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1498,"detail":0.0431,"edges":0.519,"complexity":0.5682,"coverage":0.2534,"colour":0.1241,"drift":0.0663},"knobResponse":[0.0646,0.0388,0.096,0.0704]},{"slug":"ballistic-annihilation","title":"Ballistic Annihilation","family":"particle","round":44,"note":"총이 박자마다 느림, 가운데, 빠름 가운데 하나로 쏜 총알이 시공간 그림에서 제 기울기의 곧은 선이 되고, 빠른 것이 느린 것을 따라잡으면 둘 다 흰 불꽃으로 사라져요. 가운데 총알의 몫이 1/4 을 넘어야 끝까지 사는 총알이 생겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ballistic-annihilation","type":"code","name":"ballistic-annihilation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Middle=-1..1, Spread=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Middle","min":-1,"max":1},{"name":"Spread","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.3291,"detail":0.1292,"edges":0.9998,"complexity":0.0873,"coverage":0.1772,"colour":0.3485,"drift":0.1809},"knobResponse":[0.1075,0.179,0.1144,0.247]},{"slug":"ballistic-deposition","title":"Ballistic Deposition","family":"particle","round":30,"note":"입자가 64열 위로 곧게 떨어져 처음 닿는 자리에 붙어요. 처마 밑이 빈 퇴적물이 내려앉은 차례대로 띠를 이루고, 띠의 경계가 거칠어지는 앞면의 지난 모습이에요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-ballistic-deposition","type":"code","name":"ballistic-deposition","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slip=0..1, Layers=6..24","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slip","min":0,"max":1},{"name":"Layers","min":6,"max":24}],"start":[0,2,0,6],"measures":{"motion":0.6499,"detail":0.2394,"edges":0.9298,"complexity":0.4248,"coverage":0.4131,"colour":0.4145,"drift":0.0572},"knobResponse":[0.2133,0.2835,0.2999,0.1051]},{"slug":"balloon-box","title":"Balloon Box","family":"weather","round":11,"note":"새벽 골짜기에 바람이 둘이에요. 낮은 바람은 열기구를 왼쪽으로, 높은 바람은 오른쪽으로 데려가고, 조종사가 버너로 높이를 바꾸면 풍선이 멈췄다 되돌아가요. 옆으로 나간 자리에는 새 풍선이 바람을 타고 들어오거나 들판에서 떠올라요. K1 을 누르면 모든 버너가 한꺼번에 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-balloon-box","type":"code","name":"balloon-box","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Wind=0.2..3, Balloons=8..16, Sunrise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Wind","min":0.2,"max":3},{"name":"Balloons","min":8,"max":16},{"name":"Sunrise","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.167,"detail":0.0307,"edges":0.6336,"complexity":0.5511,"coverage":0.8946,"colour":0.5662,"drift":0.2806},"knobResponse":[0.306,0.2762,0.2316,0.2865]},{"slug":"banshee","title":"Banshee","family":"halloween","round":52,"note":"창 하나 밝힌 오두막 위 밤바람에 비치는 여인이 긴 머리와 해진 옷자락을 날리며 떠다니다 7초마다 고개를 젖혀 울면, 독한 초록 소리 고리가 밤을 휘며 퍼져서 하늘이 번쩍이고 유리창이 덜컹거리고 촛불이 눕고 까마귀가 흩어져요. K3 은 바람, K4 는 울음의 세기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-banshee","type":"code","name":"banshee","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Fury=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Fury","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5532,"detail":0.0402,"edges":0.2775,"complexity":0.7447,"coverage":0.7257,"colour":0.1068,"drift":0.0715},"knobResponse":[0.0665,0.0906,0.0657,0.1141]},{"slug":"barn-owl","title":"Barn Owl","family":"halloween","round":48,"note":"보라 밤하늘의 보름달 앞 마른 나무 높은 가지에서 원숭이올빼미가 하트 얼굴을 멀리 돌렸다 되돌리고 눈을 깜빡이다가, 날개를 크게 치며 패널 끝까지 내리꽂혀 풀밭의 쥐를 낚아채거나 놓치고 다시 가지로 올라가요. K3 은 사냥 사이의 기다림, K4 는 바람이고, K1 을 누르면 바로 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-barn-owl","type":"code","name":"barn-owl","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hunger=0..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hunger","min":0,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3665,"detail":0.044,"edges":0.5905,"complexity":0.2519,"coverage":0.8645,"colour":0.2004,"drift":0.0527},"knobResponse":[0.1297,0.0612,0.041,0.0703]},{"slug":"barrier-grid","title":"Barrier Grid","family":"type","round":66,"note":"낱말과 그 음화를 한 칸씩 엇갈려 짠 인쇄 위로 슬릿 난 막대 격자가 한 칸씩 미끄러져, 금빛 「빛」이 파란 바탕의 검은 「빛」으로 뒤집히고 네 걸음마다 다음 낱말이 와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-barrier-grid","type":"code","name":"barrier-grid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Frames=2..4, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Frames","min":2,"max":4},{"name":"Tilt","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.3479,"detail":0.3165,"edges":0.8138,"complexity":0.2788,"coverage":0.705,"colour":0.2937,"drift":0.3806},"knobResponse":[0.1993,0.3596,0.1969,0.184]},{"slug":"barycentric-subdivision","title":"Barycentric Subdivision","family":"fractal","round":53,"note":"정삼각형을 세 중선으로 여섯 조각 내고 조각마다 또 그렇게 자른 모자이크 속으로, 카메라가 무작위로 고른 자식 삼각형을 따라 늘이지 않고 돌리고 키우기만 하며 파고들어요. 조각은 가장 큰 각으로 칠해져 둥근 것은 청록, 납작할수록 자홍을 지나 호박색이 되고, 흰 선이 앞으로 들어갈 세 걸음을 미리 그어요. K3 은 모자이크를 현재 삼각형 몇 단 아래까지 자르는지이고, K4 는 가장 둥근 자식을 고를 확률이라 0.4 부터는 삼각형이 납작해지지 않아요. 단추를 누르면 정삼각형에서 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-barycentric-subdivision","type":"code","name":"barycentric-subdivision","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=2..3, Steer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":2,"max":3},{"name":"Steer","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":2.6277,"detail":0.1339,"edges":0.5315,"complexity":1.9596,"coverage":0.935,"colour":0.358,"drift":0.2554},"knobResponse":[0.272,0.2244,0.0682,0.0697]},{"slug":"bat-emergence","title":"Bat Emergence","family":"halloween","round":42,"note":"해 질 녘 능선의 동굴 어귀에서 박쥐 떼가 몇 초마다 몰려나와 128줄을 다 타고 오르고, 위로 갈수록 흩어져요. 날개를 퍼덕이는 세 LED 박쥐가 보라에서 주황으로 내려오는 하늘에 검게 비치고, 띠는 연기처럼 꼬여 흔들리다 돌풍이 불면 한쪽으로 휘어요. K3 은 하늘의 박쥐를 400 마리에서 1200 마리로 늘리고, K4 는 띠를 네 번까지 꼬아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bat-emergence","type":"code","name":"bat-emergence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bats=400..1200, Swirl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":400,"max":1200},{"name":"Swirl","min":0,"max":1}],"start":[0,2,400,0.06],"measures":{"motion":0.8455,"detail":0.0412,"edges":0.8734,"complexity":0.2736,"coverage":0.9228,"colour":0.2777,"drift":0.0354},"knobResponse":[0.236,0.0382,0.0363,0.0282]},{"slug":"bat-form","title":"Bat Form","family":"halloween","round":51,"note":"어두운 탑 방의 뾰족한 창턱에 선 흡혈귀가 진홍과 주황의 해 질 녘을 등지고 팔을 들어 망토를 펼치고, 망토 단이 박쥐 날개의 물결로 갈라지며 작아져 하늘로 고리를 그리고 날아갔다 돌아와 다시 사람이 되어 망토를 여며요. K3 은 망토가 펼쳐지는 너비와 날개 크기, K4 는 멀리 언덕 위를 도는 작은 박쥐 떼의 수예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bat-form","type":"code","name":"bat-form","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cape=-1..1, Flock=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cape","min":-1,"max":1},{"name":"Flock","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3823,"detail":0.0385,"edges":0.2665,"complexity":0.7369,"coverage":0.723,"colour":0.3727,"drift":0.1422},"knobResponse":[0.1088,0.0636,0.0426,0.037]},{"slug":"bath-fizz","title":"Bath Fizz","family":"cosmetic","round":35,"note":"패널 아래에서 녹는 배스 파우더가 깊은 물속으로 안료 구름을 올려 보내요. 분홍에서 색상환을 따라 벌려 놓은 안료 세 가지가 버섯 머리로 말리며 128줄을 채우고 맞닿은 가장자리에서 섞여요. 가는 거품 줄기가 그 사이를 뚫고 올라가며 물을 끌어올려요. K3 은 거품을 1초에 60개에서 360개로 늘려 첫 구름이 위 20줄에 닿는 때를 7.6초에서 2.4초로 당기고, K1 을 누르면 세 색이 바닥에서 한꺼번에 터져요.","why":"색은 굵고 진한데 패널을 꽉 채워요(채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-bath-fizz","type":"code","name":"bath-fizz","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fizz=0..1, Mix=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fizz","min":0,"max":1},{"name":"Mix","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7842,"detail":0.0381,"edges":0.0956,"complexity":2.4963,"coverage":1,"colour":0.5925,"drift":0.2882},"knobResponse":[0.3666,0.2615,0.3734,0.0989]},{"slug":"baudot-tape","title":"Baudot Tape","family":"type","round":81,"note":"다섯 구멍 천공 테이프가 패널 높이로 올라가고, 줄마다 뚫린 ITA2 부호를 읽은 글자가 그 옆에 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-baudot-tape","type":"code","name":"baudot-tape","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Message=0..2, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Message","min":0,"max":2},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8595,"detail":0.0644,"edges":0.7746,"complexity":0.1195,"coverage":0.6499,"colour":0.1569,"drift":0.0601},"knobResponse":[0.112,0.0788,0.0379,0.0343]},{"slug":"bauhaus","title":"Bauhaus","family":"geometry","round":1,"note":"바우하우스 포스터처럼 납작한 원반과 막대가 2×4 칸에 놓이고, 한 칸씩 천천히 다른 모양이나 색으로 바뀌어요.","why":"모양은 프리셋과 가장 닮았는데 거의 안 움직여요(움직임 0.04).","block":1,"ramped":false,"layer":{"id":"layer-bauhaus","type":"code","name":"bauhaus","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pace=0.25..6, Grid=4..12, Line=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pace","min":0.25,"max":6},{"name":"Grid","min":4,"max":12},{"name":"Line","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0436,"detail":0.04,"edges":0.8787,"complexity":0.0601,"coverage":0.5555,"colour":0.5847,"drift":0.0591},"knobResponse":[0.3486,0.141,0.3458,0.2172]},{"slug":"beading-letters","title":"Beading Letters","family":"type","round":81,"note":"부어 쓴 액체 낱말의 획이 반지름의 9.6배 물결로 잘록해지다 끊겨, 같은 간격 방울로 찍은 점 글자가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beading-letters","type":"code","name":"beading-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thickness=1.5..2.5, Viscosity=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thickness","min":1.5,"max":2.5},{"name":"Viscosity","min":0,"max":1}],"start":[0,2,1.5,0.06],"measures":{"motion":0.3003,"detail":0.0414,"edges":0.4095,"complexity":0.6624,"coverage":0.1881,"colour":0.1705,"drift":0.1317},"knobResponse":[0.0758,0.088,0.0766,0.0503]},{"slug":"beam-letters","title":"Beam Letters","family":"type","round":79,"note":"전자빔 하나가 한 획 글꼴의 획을 따라 LET THERE BE LIGHT 를 쓰며 모서리와 획 끝에서 느려져 밝게 타고, 형광체의 잔광이 쓰는 차례를 따라 줄마다 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beam-letters","type":"code","name":"beam-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Phosphor=0..1, Speed=0.2..3, Persistence=0..1, Focus=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Phosphor","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Persistence","min":0,"max":1},{"name":"Focus","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0651,"detail":0.0457,"edges":0.4222,"complexity":0.6663,"coverage":0.1867,"colour":0.1016,"drift":0.1237},"knobResponse":[0.0363,0.0881,0.0352,0.0713]},{"slug":"beatty-rhythm","title":"Beatty Rhythm","family":"rhythm","round":76,"note":"⌊nφ⌋ 와 ⌊nφ²⌋ 두 목소리가 내려오는 박을 자홍과 초록으로 나눠 치고, 옆의 기울어진 격자 띠가 둘이 왜 겹치지도 비지도 않는지 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beatty-rhythm","type":"code","name":"beatty-rhythm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Alpha=0..1, Ticks=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Alpha","min":0,"max":1},{"name":"Ticks","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.1369,"detail":0.1552,"edges":1,"complexity":0.1063,"coverage":0.2651,"colour":0.5931,"drift":0.077},"knobResponse":[0.2644,0.1828,0.1732,0.1676]},{"slug":"beckett-gray","title":"Beckett-Gray","family":"rhythm","round":58,"note":"여섯 줄 악보가 한 박에 두 줄씩 내려와 64박 한 바퀴가 판에 다 서고, 박마다 바뀐 줄이 지금 선에서 번쩍여요. 막 들어온 연기자는 어둡다가 앞사람이 나갈 때마다 한 단씩 밝아져 맨 앞에서 하얘진 뒤 나가고, 반사 그레이 코드로 돌리면 퇴장 32번 가운데 26번이 차례를 어겨 빨갛게 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beckett-gray","type":"code","name":"beckett-gray","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Code=0..3, Rows=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Code","min":0,"max":3},{"name":"Rows","min":2,"max":8}],"start":[0,2,0,2],"measures":{"motion":0.2581,"detail":0.0667,"edges":0.5613,"complexity":0.2026,"coverage":0.4106,"colour":0.3039,"drift":0.2116},"knobResponse":[0.114,0.2805,0.2976,0.2353]},{"slug":"belfry","title":"Belfry","family":"halloween","round":46,"note":"보라 폭풍 하늘 아래 종탑의 청동 종이 진자로 흔들리며 추가 테를 치고, 칠 때마다 박쥐가 쏟아져요. 시계는 30초에 한 시간을 가서 자정에 열두 번 울려요. K3 은 박쥐 수, K4 는 구름과 비와 번개이고, K1 을 누르면 바로 자정을 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-belfry","type":"code","name":"belfry","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bats=8..40, Storm=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":8,"max":40},{"name":"Storm","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.9809,"detail":0.0592,"edges":0.5694,"complexity":0.3567,"coverage":0.6981,"colour":0.3005,"drift":0.1162},"knobResponse":[0.1022,0.0353,0.0293,0.1095]},{"slug":"belt-trick","title":"Belt Trick","family":"topology","round":53,"note":"패널 가운데 정육면체가 위아래 가장자리 막대에 리본으로 묶인 채 한 축으로 쉬지 않고 돌아요. 한 바퀴를 돌면 리본이 정육면체를 한 번 감아 풀 수 없게 되고, 두 바퀴째에 리본이 정육면체를 돌아 넘어가며 곧게 풀려요. 뒤의 고리가 첫 바퀴엔 보라, 둘째 바퀴엔 초록으로 차올라 몇 번째 바퀴인지 보여요. K3 은 리본 수(2~8), K4 는 회전축의 기울기이고, 단추를 누르면 도는 방향이 거꾸로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-belt-trick","type":"code","name":"belt-trick","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ribbons=2..8, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ribbons","min":2,"max":8},{"name":"Tilt","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2433,"detail":0.043,"edges":0.6786,"complexity":0.2692,"coverage":0.2395,"colour":0.2437,"drift":0.0453},"knobResponse":[0.0922,0.0556,0.0846,0.0488]},{"slug":"benford-law","title":"Benford's Law","family":"data","round":76,"note":"1 에서 10 까지의 로그 자 위로 2 의 거듭제곱이 하나씩 떨어져, 첫 자리 띠마다 막대가 차오르다 벤퍼드의 몫을 뜻하는 한 직선에서 닫혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-benford-law","type":"code","name":"benford-law","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=0..8, Digit=1..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":0,"max":8},{"name":"Digit","min":1,"max":2}],"start":[0,2,0,1],"measures":{"motion":0.6321,"detail":0.0509,"edges":0.7369,"complexity":0.1028,"coverage":0.8981,"colour":0.4045,"drift":0.18},"knobResponse":[0.224,0.201,0.2081,0.217]},{"slug":"benton-pantograph","title":"Benton Pantograph","family":"type","round":71,"note":"위쪽 큰 본 글자의 윤곽을 스타일러스가 따라 돌면 팬터그래프 막대가 그 움직임을 줄여 아래 블랭크에 4분의 1 크기 글자를 새기고, 노브가 깎는 글자만 기울이거나 좁히고 넓혀서, 다 깎은 펀치가 BENTON, PUNCH, MATRIX, FAMILY 로 아래 두 줄에 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-benton-pantograph","type":"code","name":"benton-pantograph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slant=0..0.45, Width=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slant","min":0,"max":0.45},{"name":"Width","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7392,"detail":0.0576,"edges":0.5082,"complexity":0.4239,"coverage":0.3594,"colour":0.118,"drift":0.1152},"knobResponse":[0.0501,0.0737,0.0359,0.0474]},{"slug":"berggren-tree","title":"Berggren Tree","family":"number","round":62,"note":"피타고라스 세 수가 (3, 4, 5) 에서 한 세대씩 자라요. A 와 C 가지는 c − b = k² 과 c − a = 2n² 포물선을 따라 하늘색과 장밋빛으로 뻗고, 원시 세 수는 두 포물선이 만나는 마디에만 켜져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-berggren-tree","type":"code","name":"berggren-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Reach=-1..1, Root=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Reach","min":-1,"max":1},{"name":"Root","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6124,"detail":0.1119,"edges":0.994,"complexity":0.2155,"coverage":0.1899,"colour":0.1654,"drift":0.0779},"knobResponse":[0.05,0.1298,0.1469,0.1311]},{"slug":"bernoulli-convolutions","title":"Bernoulli Convolutions","family":"fractal","round":38,"note":"128줄 하나하나가 λ 하나에 대한 ±1 ±λ ±λ² … 의 분포예요. 위의 칸토어 먼지에서 아래의 매끈한 종까지 항이 하나 더해질 때마다 모든 점이 둘로 쪼개지고, λ 가 피소 수의 역수인 열네 줄에서는 합이 같은 점에 거듭 내려앉아 흰 금빛으로 타요. K3 은 동전을 한쪽으로 기울여 종을 오른쪽 벽으로 밀고, K1 을 누르면 항을 다 걷었다가 첫 항부터 다시 쌓아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-bernoulli-convolutions","type":"code","name":"bernoulli-convolutions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=0.5..0.95, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":0.5,"max":0.95},{"name":"Zoom","min":0,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.1052,"detail":0.0778,"edges":0.2761,"complexity":1.7226,"coverage":0.81,"colour":0.2382,"drift":0.0505},"knobResponse":[0.3122,0.0507,0.314,0.1288]},{"slug":"bertrand-paradox","title":"Bertrand Paradox","family":"data","round":33,"note":"지름 40 LED 의 원 셋이 세 칸에 하나씩 서서, 원마다 다른 뜻의 무작위로 현을 1초에 24개씩 긋고 현은 LED 하나씩 부서져 사라져요. 삼각형 변보다 긴 현은 자홍, 짧은 현은 초록이고, 옆 막대와 숫자가 긴 현의 몫을 세어 위 원은 1/3 로, 가운데는 1/2 로, 아래는 1/4 로 모여요. K3 을 올리면 선이 원마다 다른 밀도의 점묘가 되고, K1 을 누르면 원과 셈을 비우고 처음부터 다시 그어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-bertrand-paradox","type":"code","name":"bertrand-paradox","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Chords=0..1, Persist=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Chords","min":0,"max":1},{"name":"Persist","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3006,"detail":0.2269,"edges":0.8503,"complexity":0.2324,"coverage":0.2638,"colour":0.5757,"drift":0.0802},"knobResponse":[0.24,0.1255,0.1353,0.0538]},{"slug":"bi-phase","title":"Bi-Phase","family":"cosmetic","round":30,"note":"흔들어 섞은 이중층 클렌저가 패널 가득 기름 방울로 흩어졌다가, 방울끼리 합쳐 떠올라 위에 한 층으로 모이고 경계선이 맑게 서요. 그러고 나면 다시 흔들려요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-bi-phase","type":"code","name":"bi-phase","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Oil=0.3..0.6, Shake=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Oil","min":0.3,"max":0.6},{"name":"Shake","min":0,"max":1}],"start":[0,2,0.3,0.06],"measures":{"motion":0.0579,"detail":0.0044,"edges":0.0095,"complexity":0.6088,"coverage":1,"colour":0.3088,"drift":0.0284},"knobResponse":[0.1292,0.1228,0.1399,0.1113]},{"slug":"bicycle-tracks","title":"Bicycle Tracks","family":"line","round":57,"note":"앞바퀴 점이 세운 패널을 굽이치며 오르고 한 축거 뒤의 뒷바퀴 점은 늘 앞바퀴를 향해서만 굴러서, 뒷바퀴 자취가 굽이마다 안쪽을 질러가요. 두 자취 사이 초승달에는 뒷바퀴 자취의 접선이 꼭 한 축거 앞에서 앞바퀴 자취에 닿는 선분이 빗살처럼 서서, 자전거가 어느 쪽으로 갔는지 알려 줘요. 34초쯤마다 앞바퀴가 원을 두 바퀴 돌면 뒷바퀴는 반지름 √(r²−L²) 의 원으로 감겨 들고, 빠져나올 때는 곧게 나가는 앞바퀴 뒤로 트랙트릭스를 그려요. K3 은 축거(16~24 LED), K4 는 굽이마다 핸들을 꺾어 두는 각도(50~70도)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bicycle-tracks","type":"code","name":"bicycle-tracks","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wheelbase=16..24, Bar=50..70","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wheelbase","min":16,"max":24},{"name":"Bar","min":50,"max":70}],"start":[0,2,16,50],"measures":{"motion":0.5515,"detail":0.0432,"edges":0.3968,"complexity":0.8058,"coverage":0.2338,"colour":0.2462,"drift":0.1434},"knobResponse":[0.0617,0.1208,0.1256,0.1437]},{"slug":"big-type","title":"Big Type","family":"type","round":1,"note":"화면을 꽉 채운 낱말 하나가 자석을 댄 옛 텔레비전 화면처럼 휘어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-big-type","type":"code","name":"big-type","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..5, Word=0..6, Warp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":5},{"name":"Word","min":0,"max":6},{"name":"Warp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4681,"detail":0.0954,"edges":0.9989,"complexity":0.0628,"coverage":0.2402,"colour":0.253,"drift":0.0745},"knobResponse":[0.0865,0.0522,0.1361,0.0808]},{"slug":"biliteral-cipher","title":"Biliteral Cipher","family":"type","round":72,"note":"다섯 자씩 한 줄로 친 겉글을 읽는 빛이 글자마다 a 활자인지 b 활자인지 적고, 다섯이 차면 베이컨의 표대로 숨은 글자 하나가 아래 줄에 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-biliteral-cipher","type":"code","name":"biliteral-cipher","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Message=0..4, Tell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Message","min":0,"max":4},{"name":"Tell","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.057,"detail":0.1007,"edges":0.8951,"complexity":0.0811,"coverage":0.2301,"colour":0.1404,"drift":0.0426},"knobResponse":[0.0462,0.1227,0.1302,0.0424]},{"slug":"binary-lens","title":"Binary Lens","family":"space","round":61,"note":"서로 도는 두 질량이 만드는 확대 지도에서 밝은 커스틱이 뾰족점에서 만나며 별 모양 둘과 육각 고리, 가운데 작은 것과 세모 둘 사이를 오가요. 지도를 건너는 별의 밝기가 아래 띠에 흘러가며 커스틱을 넘을 때마다 솟아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-binary-lens","type":"code","name":"binary-lens","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mass ratio=0.2..1, Orbit=15..60","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mass ratio","min":0.2,"max":1},{"name":"Orbit","min":15,"max":60}],"start":[0,2,0.2,15],"measures":{"motion":0.5756,"detail":0.0511,"edges":0.1417,"complexity":1.4821,"coverage":0.8311,"colour":0.1924,"drift":0.0601},"knobResponse":[0.156,0.0531,0.0447,0.0554]},{"slug":"bismuth","title":"Bismuth","family":"mineral","round":18,"note":"녹은 비스무트 웅덩이에서 계단 진 네모 호퍼 결정이 가지를 치며 패널 꼭대기까지 자라요. 테라스마다 산화막이 은색에서 금색, 자홍, 파랑, 청록을 지나 두 번째 금색과 분홍으로 바뀌어서 색이 그 단이 생긴 때를 말해요. K1 을 누르면 웅덩이가 패널을 타고 올라 결정을 녹였다가 빠지고, 결정이 다시 자라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bismuth","type":"code","name":"bismuth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Steps=3..8, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Steps","min":3,"max":8},{"name":"Heat","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0634,"detail":0.155,"edges":0.6769,"complexity":1.8463,"coverage":0.7656,"colour":0.3505,"drift":0.1056},"knobResponse":[0.1563,0.1868,0.0876,0.1811]},{"slug":"black-cat","title":"Black Cat","family":"halloween","round":44,"note":"낮은 달 앞 담 위의 검은 고양이가 꼬리를 흔들고 박쥐를 눈으로 좇다가, 등을 활처럼 세우고 털을 곤두세워 하악거려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-black-cat","type":"code","name":"black-cat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mood=0..1, Startle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mood","min":0,"max":1},{"name":"Startle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3528,"detail":0.0576,"edges":0.4704,"complexity":0.4583,"coverage":0.6305,"colour":0.2863,"drift":0.1432},"knobResponse":[0.1545,0.0965,0.0557,0.1036]},{"slug":"blinking-vortex","title":"Blinking Vortex","family":"sim","round":67,"note":"아레프의 깜박이는 소용돌이 둘이 위아래로 60 LED 떨어져 반 주기씩 번갈아 돌고, 청록과 보라의 부드러운 띠가 늘고 접혀 LED 보다 가늘어지면 한 빛깔로 섞이다가 새 물감이 깔려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-blinking-vortex","type":"code","name":"blinking-vortex","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strength=2..16, Dye=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strength","min":2,"max":16},{"name":"Dye","min":0,"max":3}],"start":[0,2,2,0.06],"measures":{"motion":1.9524,"detail":0.0535,"edges":0.1285,"complexity":2.3556,"coverage":0.9995,"colour":0.3873,"drift":0.0906},"knobResponse":[0.326,0.2144,0.2142,0.2519]},{"slug":"bloch-oscillations","title":"Bloch Oscillations","family":"wave","round":56,"note":"한 자리에서 출발한 입자가 기운 사슬 위에서 렌즈 모양으로 50자리까지 퍼졌다가 한 점으로 돌아오기를 되풀이하며 위로 흘러가요. 색은 준운동량이라서 힘이 띠를 감는 동안 렌즈 가장자리 색이 돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bloch-oscillations","type":"code","name":"bloch-oscillations","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Force=0.16..0.64, Width=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Force","min":0.16,"max":0.64},{"name":"Width","min":0,"max":1}],"start":[0,2,0.16,0.06],"measures":{"motion":1.5543,"detail":0.1156,"edges":0.5608,"complexity":1.8221,"coverage":0.5888,"colour":0.3107,"drift":0.2251},"knobResponse":[0.1747,0.2739,0.2211,0.2305]},{"slug":"blooming-gel","title":"Blooming Gel","family":"cosmetic","round":36,"note":"젖은 블루밍 베이스에 코발트와 라일락, 흰 젤 방울이 하나씩 떨어져 가장자리가 해진 꽃처럼 번지고, 안료는 번지는 앞선으로 밀려 테두리가 짙어져요. 6.2초를 그리고 나면 경화 램프 띠가 위에서 아래로 지나며 무늬를 굳히고, 닦아 낸 새 베이스에서 다시 시작해요. K3 은 방울 크기와 번지는 거리를 정하고, K1 을 누르면 방울 하나가 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-blooming-gel","type":"code","name":"blooming-gel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bloom=0..1, Rim=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bloom","min":0,"max":1},{"name":"Rim","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0712,"detail":0.0141,"edges":0.1484,"complexity":1.601,"coverage":1,"colour":0.1697,"drift":0.0438},"knobResponse":[0.2098,0.0709,0.1051,0.0332]},{"slug":"blotting-paper","title":"Blotting Paper","family":"cosmetic","round":39,"note":"결이 비치는 얇은 기름종이가 살에 눌린 자리마다 피지를 빨아들여, 반투명한 점이 결을 따라 √t 로 번지고 합쳐져요. 젖은 자리는 뒤 벽의 빛이 비쳐 밝고 짙은 색이 되고, LED 마다 한 번만 밝아져요. 종이가 거의 다 비치면 새 종이가 내려와 덮어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-blotting-paper","type":"code","name":"blotting-paper","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pores=20..80, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pores","min":20,"max":80},{"name":"Grain","min":0,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.0572,"detail":0.0504,"edges":0.1413,"complexity":1.9288,"coverage":1,"colour":0.225,"drift":0.3434},"knobResponse":[0.1516,0.0572,0.0394,0.0465]},{"slug":"bokeh","title":"Bokeh","family":"light","round":1,"note":"초점이 나간 밤거리 불빛이에요. 여섯 모 진 빛 원반이 피었다 흘러가며 겹친 자리만 부드럽게 밝아져요.","why":"흐린 빛 원이 떠다녀요. 0609, 0524 처럼 번진 빛 덩어리예요.","block":0,"ramped":false,"layer":{"id":"layer-bokeh","type":"code","name":"bokeh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pace=0.2..4, Size=-1..1, Lights=40..90","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pace","min":0.2,"max":4},{"name":"Size","min":-1,"max":1},{"name":"Lights","min":40,"max":90}],"start":[0,2,0,40],"measures":{"motion":0.9868,"detail":0.0384,"edges":0.1836,"complexity":1.7001,"coverage":0.5358,"colour":0.318,"drift":0.3822},"knobResponse":[0.2498,0.2782,0.2491,0.2757]},{"slug":"bone-jig","title":"Bone Jig","family":"halloween","round":43,"note":"패널 키만 한 해골이 아래에서 올라오는 독한 초록 빛 위에서 턱을 딱딱거리며 춤춰요. 깡충 지그, 옆차기, 팔 휘돌리기, 엉덩이 흔들기, 한 바퀴 돌기, 오들오들 떨기를 96 bpm 으로 25초에 한 번씩 돌아요. K3 은 0.6 크기 해골을 뒤에 둘까지 세우고 K4 는 뼈마다 보라로 스러지는 잔상을 남기며, K1 을 누르면 머리가 패널 위로 튀어 나가 두 바퀴 돌고 1.4초 만에 목에 다시 앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bone-jig","type":"code","name":"bone-jig","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Dancers=1..3, Trails=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dancers","min":1,"max":3},{"name":"Trails","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.4633,"detail":0.0641,"edges":0.4215,"complexity":0.7536,"coverage":0.2639,"colour":0.1233,"drift":0.1064},"knobResponse":[0.0356,0.118,0.0359,0.0585]},{"slug":"bone-pile","title":"Bone Pile","family":"halloween","round":48,"note":"보랏빛 조명 아래 지하 묘실에서 춤추던 해골이 박자에 맞춰 와르르 무너져 바닥에 뼈 더미로 쌓이고, 해골 눈에 빛이 들면 뼈가 발부터 하나씩 포물선을 그리며 날아올라 제자리에 끼워지고 마지막에 머리가 내려앉아 끄덕인 뒤 다시 춤춰요. K3 은 무너지기 전에 추는 박자 수, K4 는 땅안개이고, K1 을 누르면 바로 무너져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bone-pile","type":"code","name":"bone-pile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dance=4..32, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dance","min":4,"max":32},{"name":"Fog","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.5905,"detail":0.0945,"edges":0.5574,"complexity":0.3887,"coverage":0.8965,"colour":0.1276,"drift":0.0606},"knobResponse":[0.0687,0.1358,0.0743,0.0616]},{"slug":"book-from-the-sky","title":"Book from the Sky","family":"type","round":71,"note":"부수와 부품을 실제 한자의 틀에 맞춰 지어낸 읽을 수 없는 글자가 괘선 친 세로줄 다섯을 채우고, 얇은 새 종이가 오른쪽부터 덮여 밑의 쪽이 비치는 채로 한 줄씩 위에서 아래로 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-book-from-the-sky","type":"code","name":"book-from-the-sky","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Ink=0..1, Speed=0.2..3, Strokes=-1..1, Notes=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Ink","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strokes","min":-1,"max":1},{"name":"Notes","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0481,"detail":0.254,"edges":0.6947,"complexity":1.0115,"coverage":0.7695,"colour":0.075,"drift":0.073},"knobResponse":[0.7099,0.0504,0.1819,0.1881]},{"slug":"borromean-rings","title":"Borromean Rings","family":"topology","round":33,"note":"테이트의 보로메오 고리를 황금 직사각형 세 장으로 만들고 세로로 2.3배 늘여 세웠어요. 하늘색 고리가 키 크게 서고 분홍 고리가 그것을 가로지르며 연두 고리가 허리를 둘러 20초에 한 바퀴 돌고, 앞 관이 뒤 관을 지나는 자리마다 LED 한 줄이 어두워져 위아래가 읽혀요. K3 은 직사각형의 긴 변 비를 1.618 에서 2.4 까지 바꾸고, K1 을 누르면 분홍 고리가 사라진 동안 연두 고리가 긴 고리 아래 끝으로 빠져나갔다 돌아와요.","why":"고리 셋이 작고 느려요.","block":1,"ramped":false,"layer":{"id":"layer-borromean-rings","type":"code","name":"borromean-rings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Aspect=1.618..2.4, Tube=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Aspect","min":1.618,"max":2.4},{"name":"Tube","min":0,"max":1}],"start":[0,2,1.618,0.06],"measures":{"motion":0.1873,"detail":0.0417,"edges":0.4546,"complexity":0.6755,"coverage":0.2581,"colour":0.1929,"drift":0.1053},"knobResponse":[0.1012,0.1249,0.077,0.0449]},{"slug":"borsuk-ulam","title":"Borsuk-Ulam","family":"topology","round":39,"note":"기온과 기압이 천천히 바뀌는 지구가 돌아요. 위 원판은 앞 반구, 아래 원판은 뒤 반구라서 −x 가 x 와 같은 자리에 그려지고, 대척점과 기온이 같은 흰 선과 기압이 같은 자홍 선이 두 원판의 같은 자리를 지나요. 두 선이 만나는 금색 점이 보르수크-울람 정리가 늘 있다고 하는 대척점 쌍이에요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-borsuk-ulam","type":"code","name":"borsuk-ulam","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Degree=3..6, Speed=0.2..3, Weather=0..1, Hue=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Degree","min":3,"max":6},{"name":"Speed","min":0.2,"max":3},{"name":"Weather","min":0,"max":1},{"name":"Hue","min":0,"max":1}],"start":[3,2,0,0.06],"measures":{"motion":0.3065,"detail":0.0677,"edges":0.3854,"complexity":1.6473,"coverage":0.7507,"colour":0.3391,"drift":0.0903},"knobResponse":[0.1438,0.1696,0.1763,0.2221]},{"slug":"boustrophedon","title":"Boustrophedon","family":"type","round":69,"note":"빛 한 점이 쟁기처럼 고랑 스무 줄을 갈며 헤시오도스의 두루미 대목을 한 줄은 왼쪽에서 오른쪽으로, 다음 줄은 글자를 거울에 비춘 채 오른쪽에서 왼쪽으로 새기고, 앞에서는 지난번에 써서 식은 글자를 갈아엎어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-boustrophedon","type":"code","name":"boustrophedon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Way=-1..1, Words=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Way","min":-1,"max":1},{"name":"Words","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.033,"detail":0.321,"edges":0.3873,"complexity":2.0984,"coverage":0.8968,"colour":0.1258,"drift":0.0301},"knobResponse":[0.1032,0.0855,0.0985,0.1862]},{"slug":"bowling-lane","title":"Bowling Lane","family":"sport","round":22,"note":"볼러 뒤에서 본 10핀 레인이에요. 공이 오일 위로 제 반사를 끌며 휘어 올라가 핀을 흩고, 스위프 바가 데드우드를 쓸어 낸 뒤 핀이 다시 서요. 처음에는 블랙라이트 아래 핀과 화살표, 오일이 빛나고, K4 를 올리면 나무 레인에 하우스 조명이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bowling-lane","type":"code","name":"bowling-lane","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Ball=0..1, Speed=0.2..3, Hook=0..1, Lights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Ball","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hook","min":0,"max":1},{"name":"Lights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1625,"detail":0.0689,"edges":0.5323,"complexity":1.7471,"coverage":0.9404,"colour":0.2104,"drift":0.042},"knobResponse":[0.0566,0.0281,0.0252,0.2377]},{"slug":"boys-surface","title":"Boy's Surface","family":"topology","round":31,"note":"사영 평면을 3차원에 담은 보이 곡면이 위 칸에서 세 겹 대칭축으로 돌고, 수평면이 오르내리며 자른 곡선이 아래 칸에 위에서 본 그림으로 떠요. 평면 아래는 단단하고 위는 옅은 유리라 안쪽에서 앞면과 뒷면이 만나는 이음매가 보여요. K1 을 누르면 평면이 삼중점에 멈춰 세 고리가 한 점을 지나요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-boys-surface","type":"code","name":"boys-surface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Bands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2388,"detail":0.0514,"edges":0.351,"complexity":1.1851,"coverage":0.4559,"colour":0.1933,"drift":0.0801},"knobResponse":[0.0711,0.1334,0.081,0.0395]},{"slug":"brachistochrone","title":"Brachistochrone","family":"physics","round":39,"note":"왼쪽 위 한 점에서 구슬 다섯이 직선, 갈릴레이의 원호, 포물선, 깊이 떨어지는 길, 사이클로이드를 타고 함께 미끄러져요. 직선보다 긴 길을 타는 사이클로이드의 구슬이 먼저 닿고, 구슬이 지금까지 닿을 수 있는 점들의 앞면이 고리를 남기며 패널 아래까지 퍼져요. 한 판 걸러 사이클로이드의 여러 높이에서 놓은 구슬이 바닥에 함께 닿아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-brachistochrone","type":"code","name":"brachistochrone","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Gravity=0.2..3, End=0..1, Tracks=5..13","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Gravity","min":0.2,"max":3},{"name":"End","min":0,"max":1},{"name":"Tracks","min":5,"max":13}],"start":[0,2,0,5],"measures":{"motion":0.2086,"detail":0.0362,"edges":0.3333,"complexity":0.8549,"coverage":0.2988,"colour":0.08,"drift":0.1306},"knobResponse":[0.0398,0.0764,0.0473,0.038]},{"slug":"braille-relief","title":"Braille Relief","family":"type","round":67,"note":"루이 브라유의 여섯 점 글자로 헬렌 켈러의 우물가 두 문장을 네 쪽에 새기고, 3~20도로 낮게 도는 램프가 점마다 밝은 쪽과 긴 그림자를 그리는 동안 손끝이 한 칸씩 읽으면 그 칸 밑에 활자가 작게 떠올랐다 사라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-braille-relief","type":"code","name":"braille-relief","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Relief=0.4..2.4, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Relief","min":0.4,"max":2.4},{"name":"Light","min":0,"max":1}],"start":[0,2,0.4,0.06],"measures":{"motion":0.0705,"detail":0.0559,"edges":0.3053,"complexity":1.5414,"coverage":0.8712,"colour":0.076,"drift":0.0705},"knobResponse":[0.0463,0.0637,0.0557,0.0539]},{"slug":"brazil-nut","title":"Brazil Nut","family":"particle","round":77,"note":"쌓인 원판을 통째로 들었다 가라앉히는 흔들기마다, 일곱 띠로 칠한 작은 원판 540개 사이를 큰 원판 하나가 바닥에서 꼭대기까지 52초에 올라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-brazil-nut","type":"code","name":"brazil-nut","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Amplitude=-1..1, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Amplitude","min":-1,"max":1},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.6152,"detail":0.2389,"edges":0.6546,"complexity":2.3526,"coverage":0.797,"colour":0.4151,"drift":0.0568},"knobResponse":[0.2996,0.2242,0.2383,0.2333]},{"slug":"bread-mould","title":"Bread Mould","family":"fungi","round":21,"note":"도마 위 식빵 두 쪽이 곰팡이로 덮여 가는 저속 촬영이에요. 내려앉은 포자에서 흰 테를 두른 푸른곰팡이와 검은 털곰팡이가 고리를 그리며 번지고, 다 덮이면 새 두 쪽이 옆에서 밀려 들어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bread-mould","type":"code","name":"bread-mould","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Mould=0..3, Speed=0.2..3, Spores=4..40, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Mould","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Spores","min":4,"max":40},{"name":"Damp","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.3259,"detail":0.0597,"edges":0.2499,"complexity":2.3664,"coverage":0.9889,"colour":0.1543,"drift":0.3583},"knobResponse":[0.188,0.3046,0.062,0.1018]},{"slug":"breath","title":"Breath","family":"body","round":24,"note":"후두에서 횡격막까지 해부도처럼 그린 폐가 숨을 쉬어요. 들이쉬면 횡격막이 내려가고 갈비뼈가 들리며, 푸르스름한 공기가 일곱 번 더 갈라지는 기관지를 타고 내려가 보랏빛 허파꽈리를 빨갛게 물들여요. K1 이 맑은 공기에서 입김이 하얗게 서리는 겨울과 매연 낀 도시까지 공기를 바꾸고, K1 을 누르면 기침을 해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-breath","type":"code","name":"breath","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Air=0..1, Rate=0.2..3, Depth=0..1, Altitude=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Air","min":0,"max":1},{"name":"Rate","min":0.2,"max":3},{"name":"Depth","min":0,"max":1},{"name":"Altitude","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3669,"detail":0.0863,"edges":0.4238,"complexity":2.0569,"coverage":0.8446,"colour":0.207,"drift":0.1347},"knobResponse":[0.0972,0.1294,0.1076,0.1068]},{"slug":"brick-factory","title":"Brick Factory","family":"geometry","round":74,"note":"완전 이분 그래프 K(m,n) 의 꼭짓점이 패널에 흩어져 떠도는 동안 변의 교차점마다 불꽃이 켜졌다 꺼지고, 그림이 자란키에비치의 가로세로 축 그림으로 풀리면 아래 세는 수가 Z(m,n) 까지 내려가 금빛으로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-brick-factory","type":"code","name":"brick-factory","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, m=4..6, n=6..9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"m","min":4,"max":6},{"name":"n","min":6,"max":9}],"start":[0,2,4,6],"measures":{"motion":0.3382,"detail":0.0689,"edges":0.6273,"complexity":0.6985,"coverage":0.2305,"colour":0.1466,"drift":0.1188},"knobResponse":[0.0613,0.1169,0.0549,0.115]},{"slug":"brillouin-zones","title":"Brillouin Zones","family":"cells","round":46,"note":"격자점 가운데 원점보다 가까운 것의 수로 LED 를 칠해, 가운데 1구역 둘레로 조각 난 구역 스무 개가 무지개 차례로 퍼져요. 때때로 한 구역의 조각들이 제 격자 벡터만큼 미끄러져 1구역에 꼭 맞게 들어가요. K3 은 칸 크기, K4 는 격자의 기울기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-brillouin-zones","type":"code","name":"brillouin-zones","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zones=16..48, Shear=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zones","min":16,"max":48},{"name":"Shear","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.5234,"detail":0.161,"edges":0.9828,"complexity":0.3382,"coverage":1,"colour":0.613,"drift":0.2583},"knobResponse":[0.3991,0.2962,0.3186,0.2228]},{"slug":"broad-nib","title":"Broad Nib","family":"type","round":64,"note":"넓적한 펜촉이 라틴어 경구를 한 줄에 한 낱말씩 획 차례대로 써 내려가고, 획마다 펜촉 각도와 만나는 방향에 따라 굵거나 가늘어져요. K1 로 펜촉을 돌리면 다 쓴 글자까지 그 자리에서 다시 칠해져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-broad-nib","type":"code","name":"broad-nib","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Angle=30..180, Speed=0.2..3, Weight=-1..1, Slant=0..20","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Angle","min":30,"max":180},{"name":"Speed","min":0.2,"max":3},{"name":"Weight","min":-1,"max":1},{"name":"Slant","min":0,"max":20}],"start":[30,2,0,0.06],"measures":{"motion":0.0389,"detail":0.1062,"edges":0.6307,"complexity":0.7952,"coverage":0.4305,"colour":0.1835,"drift":0.1337},"knobResponse":[0.1534,0.2462,0.119,0.1653]},{"slug":"brownian-frontier","title":"Brownian Frontier","family":"line","round":40,"note":"단순 무작위 걸음이 지나간 자리를 어두운 파랑으로, 바깥에 닿은 경계를 금빛 선으로 그려요. 걸음이 밖으로 나갔다 돌아와 경계를 먹을 때마다 주황 고리가 남고, 화면은 길을 따라 물러나 늘 패널을 채워요. K4 는 지난 경계를 겹겹의 주황 등고선으로 오래 남기고, K1 을 누르면 새 길이 시작돼요.","why":"검은 바탕의 덩어리는 좋은데 테두리 결이 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-brownian-frontier","type":"code","name":"brownian-frontier","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Trail=0..1, Speed=0.2..3, Fine=1..3, Rings=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Trail","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fine","min":1,"max":3},{"name":"Rings","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3651,"detail":0.0663,"edges":0.6024,"complexity":0.3231,"coverage":0.1928,"colour":0.1546,"drift":0.1284},"knobResponse":[0.0485,0.1252,0.1255,0.0359]},{"slug":"brushstrokes","title":"Brushstrokes","family":"noise","round":17,"note":"반 고흐의 「별이 빛나는 밤」을 짧고 두꺼운 붓질로 칠하고 또 칠해요. 흐름을 따라 놓인 군청과 코발트 붓질이 노란 별무리와 초승달을 감아 돌고, 불꽃처럼 솟은 사이프러스 옆 마을에 창이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-brushstrokes","type":"code","name":"brushstrokes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Flow=0.2..3, Length=4..12, Swirl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Flow","min":0.2,"max":3},{"name":"Length","min":4,"max":12},{"name":"Swirl","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0383,"detail":0.0951,"edges":0.2993,"complexity":2.3542,"coverage":0.998,"colour":0.5763,"drift":0.0278},"knobResponse":[0.4036,0.1538,0.1578,0.1518]},{"slug":"buffon-noodle","title":"Buffon's Noodle","family":"data","round":55,"note":"16 LED 간격의 바닥 선 위로 바늘이 1초에 10개씩 떨어져서, 선을 건넌 바늘은 금색, 못 건넌 바늘은 하늘색이 되고 건넌 자리마다 선 위에 흰 눈금이 서요. 아래에서는 떨어뜨린 길이와 건넌 횟수로 셈한 π 가 숫자와 자취로 흔들리며 다가가요. K3 은 바늘 길이(선 간격 × π 의 0.2~1배), K4 는 같은 길이 그대로 바늘을 휘는 정도예요. 길이 1 에서 다 휘면 지름 16 의 고리가 매번 꼭 두 번 건너서 숫자가 3.1416 에 멈추고, 단추를 누르면 셈을 처음부터 다시 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-buffon-noodle","type":"code","name":"buffon-noodle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=0.2..1, Bend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":0.2,"max":1},{"name":"Bend","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.3023,"detail":0.1243,"edges":0.8619,"complexity":0.4124,"coverage":0.1954,"colour":0.1973,"drift":0.1017},"knobResponse":[0.0469,0.06,0.1245,0.0711]},{"slug":"bulgarian-solitaire","title":"Bulgarian Solitaire","family":"number","round":44,"note":"바닥에 선 카드 더미마다 맨 위 한 장이 떠올라 새 더미로 쌓이고, 옛 더미가 비킨 자리에 새 더미가 떨어져요. 열 장은 아무리 늦어도 열두 수 만에 4, 3, 2, 1 계단에 닿아 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bulgarian-solitaire","type":"code","name":"bulgarian-solitaire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..6, Size=4..8, Extra=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":6},{"name":"Size","min":4,"max":8},{"name":"Extra","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.6686,"detail":0.0383,"edges":1,"complexity":0.0703,"coverage":0.2377,"colour":0.3144,"drift":0.259},"knobResponse":[0.1051,0.1873,0.177,0.1723]},{"slug":"burrows-wheeler","title":"Burrows-Wheeler","family":"algo","round":55,"note":"128자 글의 회전 128개가 한 줄씩 쌓여 사선 줄무늬로 섰다가 1초 동안 정렬된 자리로 미끄러지면 오른쪽 끝의 마지막 글자 열이 같은 글자끼리 덩어리로 모이고, 행들이 이웃과 갈리는 글자까지만 남았다가 첫 글자와 마지막 글자 열만 빼고 흐려진 뒤 LF 걸음을 따라 한 줄씩 다시 살아나요. K3 은 글의 짜임으로 무작위 글에서 스투름 단어까지 가고, K4 는 글자 수(2~6)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-burrows-wheeler","type":"code","name":"burrows-wheeler","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=0..3, Letters=2..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":0,"max":3},{"name":"Letters","min":2,"max":6}],"start":[0,2,0,2],"measures":{"motion":1.4193,"detail":0.3669,"edges":0.7602,"complexity":0.1296,"coverage":0.8191,"colour":0.3774,"drift":0.273},"knobResponse":[0.3007,0.3445,0.3069,0.2824]},{"slug":"busy-beaver","title":"Busy Beaver","family":"algo","round":62,"note":"튜링 기계가 테이프를 가로로, 시간을 아래로 써요. 다섯 상태 챔피언의 47,176,870 걸음이 1분 동안 뒤로 물러나는 그림 속에 고리 하나에 삼각형 하나씩 쌓이고, 머리가 꺾인 자리가 금색과 장밋빛 빗변을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-busy-beaver","type":"code","name":"busy-beaver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Machine=0..3, Clock=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Machine","min":0,"max":3},{"name":"Clock","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1764,"detail":0.0319,"edges":0.6847,"complexity":0.1743,"coverage":0.5524,"colour":0.2528,"drift":0.1335},"knobResponse":[0.1731,0.184,0.4088,0.1937]},{"slug":"calabi-yau","title":"Calabi-Yau Quintic","family":"space","round":51,"note":"5차 페르마 곡선 z1^5 + z2^5 = 1 을 핸슨의 25 조각으로 지어 공간에 세우면, 조각마다 색이 다른 주름진 공이 천천히 돌며 다섯 조각이 한 점에 모이는 이음매를 보여요. K3 은 허수부를 섞는 투영각 α, K4 는 25 조각을 떼어 놓는 펼친 그림이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-calabi-yau","type":"code","name":"calabi-yau","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Angle=-45..45, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Angle","min":-45,"max":45},{"name":"Spread","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2146,"detail":0.0444,"edges":0.3684,"complexity":1.1186,"coverage":0.3875,"colour":0.2484,"drift":0.108},"knobResponse":[0.1075,0.1074,0.0983,0.1881]},{"slug":"calculator-words","title":"Calculator Words","family":"type","round":69,"note":"패널을 채운 계산기가 1 − .2266 = 같은 작은 셈을 키를 밝히며 쳐 넣고 180도 돌아누우면, 7세그먼트의 0.7734 가 hELLO 로 읽히고 소수점은 낱말 위쪽에 걸려 있다가 다시 돌아와 다음 셈을 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-calculator-words","type":"code","name":"calculator-words","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Words=0..3, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Words","min":0,"max":3},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4914,"detail":0.0368,"edges":0.3074,"complexity":0.3771,"coverage":0.6093,"colour":0.1269,"drift":0.2016},"knobResponse":[0.065,0.1634,0.1666,0.0403]},{"slug":"cam-wave","title":"Cam Wave","family":"machine","round":15,"note":"발치의 캠축이 돌면 캠마다 막대를 밀어 올리고, 막대 끝에 걸린 구슬 띠가 물결이 되어 옆으로 흘러가요. K1 을 누르면 캠이 둥근 편심에서 달걀꼴, 달팽이꼴로 바뀌어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-cam-wave","type":"code","name":"cam-wave","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cams=6..12, Phase=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cams","min":6,"max":12},{"name":"Phase","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.4062,"detail":0.0758,"edges":0.6341,"complexity":0.5068,"coverage":0.4175,"colour":0.2693,"drift":0.1185},"knobResponse":[0.0838,0.0978,0.1488,0.0628]},{"slug":"canard-explosion","title":"Canard Explosion","family":"rhythm","round":61,"note":"반 데르 폴 진동자가 작은 호프 고리에서 반발 가지를 타는 머리 없는 오리와 머리 달린 오리를 지나 완화 진동까지 차례로 걸어가고, 지나온 고리가 색 띠로 겹겹이 남아요. 아래에서는 x(t) 가 흘러내리며 잔물결이 긴 톱니로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-canard-explosion","type":"code","name":"canard-explosion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Epsilon=0.04..0.2, Pace=0.6..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Epsilon","min":0.04,"max":0.2},{"name":"Pace","min":0.6,"max":3}],"start":[0,2,0.04,0.6],"measures":{"motion":0.4103,"detail":0.0497,"edges":0.527,"complexity":0.55,"coverage":0.6685,"colour":0.1538,"drift":0.0839},"knobResponse":[0.0566,0.0578,0.0741,0.0664]},{"slug":"candle-vigil","title":"Candle Vigil","family":"halloween","round":42,"note":"어두운 보랏빛 바닥에 선 초 세 자루의 불꽃이 흔들리고, 따뜻한 빛무리가 그 깜빡임을 따라 숨 쉬어요. 가끔 바람이 불꽃을 다 한쪽으로 눕히고, 한 불꽃이 꺼져 연기 한 줄을 올린 뒤 다시 붙어요. K3 은 초를 여섯 자루까지 세우고, K4 는 바람과 꺼짐을 잦게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-candle-vigil","type":"code","name":"candle-vigil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Candles=3..6, Draft=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Candles","min":3,"max":6},{"name":"Draft","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.3206,"detail":0.0241,"edges":0.2327,"complexity":0.8369,"coverage":0.7844,"colour":0.2233,"drift":0.1344},"knobResponse":[0.056,0.0467,0.1409,0.0796]},{"slug":"candy-corn","title":"Candy Corn","family":"halloween","round":45,"note":"캔디콘 알이 세 갈래로 쏟아져 128줄을 뒹굴며 내려오고, 바닥 더미에 튀었다가 비탈을 미끄러져 아무 각도로나 누워요. 더미가 차면 바닥이 뚜껑문처럼 양쪽으로 열려 더미가 쏟아져 나가고, 그동안에도 사탕은 계속 내려와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-candy-corn","type":"code","name":"candy-corn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pour=14..44, Bounce=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pour","min":14,"max":44},{"name":"Bounce","min":0,"max":1}],"start":[0,2,14,0.06],"measures":{"motion":1.9963,"detail":0.0647,"edges":0.8061,"complexity":0.2587,"coverage":0.2371,"colour":0.3719,"drift":0.2091},"knobResponse":[0.0427,0.1666,0.2292,0.1127]},{"slug":"cantor-scalogram","title":"Cantor Scalogram","family":"data","round":82,"note":"칸토어 계단의 웨이블릿 변환을 세로로 자리, 가로로 로그 크기에 펼치면 계수 크기가 칸토어 집합처럼 둘씩 갈라지는 나무가 되고, 위상을 색으로 칠해 가는 가지일수록 LED 마다 색이 바뀌며, 6초마다 3배 당겨 들어가 같은 그림으로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cantor-scalogram","type":"code","name":"cantor-scalogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=1..8, Omega=3..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":1,"max":8},{"name":"Omega","min":3,"max":8}],"start":[0,2,1,3],"measures":{"motion":1.5062,"detail":0.1033,"edges":0.5815,"complexity":2.2753,"coverage":0.2775,"colour":0.1894,"drift":0.2254},"knobResponse":[0.1022,0.2221,0.2523,0.167]},{"slug":"cardinal-vowels","title":"Cardinal Vowels","family":"type","round":77,"note":"존스의 모음 사각형 위를 혀의 점이 떠돌고, 가장 가까운 기본 모음이 괄호 사이에 크게 서서 이웃 모음이나 입술 짝으로 녹아 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cardinal-vowels","type":"code","name":"cardinal-vowels","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cardinal=0..8, Lips=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cardinal","min":0,"max":8},{"name":"Lips","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0756,"detail":0.0472,"edges":0.7432,"complexity":0.4452,"coverage":0.1745,"colour":0.229,"drift":0.0589},"knobResponse":[0.0758,0.0484,0.0525,0.0743]},{"slug":"cat-eye","title":"Cat Eye","family":"cosmetic","round":34,"note":"보랏빛 젤리 폴리시 밑으로 보이지 않는 막대 자석이 미끄러지면, 자성 반짝이가 자기장을 따라 돌아 자기장이 표면과 나란한 자리에 날카로운 빛줄기 하나가 서고 그 양옆은 곧추선 반짝이로 짙어져요. 자석이 지나간 자리의 반짝이는 1.8초에 걸쳐 흩어진 은하 같은 반짝임으로 돌아가요. K3 은 막대를 둘로 늘려 줄 두 개나 별 모양을 세우고, K1 을 누르면 자석이 멀어졌다 돌아와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cat-eye","type":"code","name":"cat-eye","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Magnet=-1..1, Depth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Magnet","min":-1,"max":1},{"name":"Depth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3686,"detail":0.0762,"edges":0.2839,"complexity":2.114,"coverage":0.9599,"colour":0.1236,"drift":0.1602},"knobResponse":[0.1875,0.1414,0.1895,0.1794]},{"slug":"cat-map","title":"Cat Map","family":"noise","round":31,"note":"패널을 토러스로 보고 아르놀트의 고양이 사상을 두 번의 밀기로 나눠 움직여요. 과녁 무늬가 사선 줄무늬로 늘어나다 잡음이 되고, 한 바퀴의 절반쯤에 줄이 엇갈린 유령이 지나간 뒤 30초에 처음 그림으로 정확히 돌아와요. K1 을 누르면 돌아오기 네 걸음 앞으로 건너뛰어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-cat-map","type":"code","name":"cat-map","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Twist=1..4, Picture=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Twist","min":1,"max":4},{"name":"Picture","min":0,"max":3}],"start":[0,2,1,0.06],"measures":{"motion":2.7145,"detail":0.107,"edges":0.6749,"complexity":0.5255,"coverage":1,"colour":0.5686,"drift":0.058},"knobResponse":[0.4614,0.2648,0.264,0.2979]},{"slug":"catastrophe-machine","title":"Catastrophe Machine","family":"physics","round":36,"note":"원판 테두리의 한 점에 고무줄 둘을 묶어 하나는 위의 고정점에, 하나는 아래를 좌우로 오가는 점 B 에 걸었어요. B 가 뾰족점 넷인 마름모, 곧 원판이 설 자리가 둘인 곳을 빠져나가는 순간 원판이 120도쯤 반대로 튀어서, B 의 자취가 가는 길과 오는 길에서 다른 색으로 남아요. K3 은 고무줄의 자연 길이를 줄여 마름모를 작게 하다가 1 에서 없애고, K1 을 누르면 B 가 축 건너편으로 건너뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-catastrophe-machine","type":"code","name":"catastrophe-machine","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tension=0..1, Depth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tension","min":0,"max":1},{"name":"Depth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.213,"detail":0.0332,"edges":0.4458,"complexity":0.4561,"coverage":0.1952,"colour":0.1001,"drift":0.0525},"knobResponse":[0.0365,0.0378,0.0477,0.0428]},{"slug":"catenoid-helicoid","title":"Catenoid-Helicoid","family":"space","round":53,"note":"체커판을 칠한 나선면이 축을 따라 패널을 세로로 채운 채 돌다가, 늘어나지 않고 현수면으로 풀렸다가 반대쪽으로 다시 감기는데, 칸은 내내 같은 크기의 정사각형이고 축의 금빛 선은 현수면의 허리 원이 돼요. K3 은 한 바퀴의 칸 수(12~36), K4 는 내려다보는 각이고, 단추를 누르면 휨이 그 자리에 멈춘 채 돌기만 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-catenoid-helicoid","type":"code","name":"catenoid-helicoid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Squares=12..36, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Squares","min":12,"max":36},{"name":"Tilt","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.3335,"detail":0.0318,"edges":0.4044,"complexity":0.9814,"coverage":0.3928,"colour":0.1926,"drift":0.2581},"knobResponse":[0.0638,0.2131,0.039,0.1585]},{"slug":"catoptric-anamorphosis","title":"Catoptric Anamorphosis","family":"type","round":71,"note":"원기둥 거울 둘레 바닥에 고리로 휘어 그린 낱말이 거울 속에서만 바로 서고, 카메라가 바닥 그림을 쫓은 눈에서 멀어지면 거울 속 글자가 미끄러지며 기울어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-catoptric-anamorphosis","type":"code","name":"catoptric-anamorphosis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Away=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Away","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0821,"detail":0.0685,"edges":0.3656,"complexity":1.0052,"coverage":0.8274,"colour":0.4221,"drift":0.1641},"knobResponse":[0.2151,0.0487,0.198,0.1603]},{"slug":"cauldron","title":"Cauldron","family":"halloween","round":41,"note":"작은 불 위의 검은 무쇠 솥에서 독한 초록 물약이 들썩이고, 거품이 부풀다 터지며 방울을 튀겨요. 초록과 보라 연기 두 줄기가 패널 꼭대기까지 휘감겨 올라가요. K3 은 끓는 세기를, K4 는 오르는 연기 양을 정하고, K1 을 누르면 눈알이 떨어져 물이 튀고 물약이 초록, 보라, 주황, 청록 차례로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cauldron","type":"code","name":"cauldron","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Boil=0..1, Fume=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Boil","min":0,"max":1},{"name":"Fume","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5114,"detail":0.0428,"edges":0.8955,"complexity":0.1495,"coverage":0.4358,"colour":0.2987,"drift":0.1811},"knobResponse":[0.1048,0.1326,0.0528,0.1034]},{"slug":"caustic-letters","title":"Caustic Letters","family":"type","round":69,"note":"물결이 거칠 때는 수영장 바닥에 늘 보던 빛 그물이 일렁이다가, 물이 잔잔해지면 같은 빛이 세로로 쌓은 LIGHT, 큰 한 글자 빛, WAVE 로 모이고, 바람이나 떨어진 돌이 다시 흔들면 흩어져 다음 낱말이 와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-caustic-letters","type":"code","name":"caustic-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ripple=1..3, Focus=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ripple","min":1,"max":3},{"name":"Focus","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.4129,"detail":0.0726,"edges":0.1364,"complexity":1.7879,"coverage":0.9266,"colour":0.1623,"drift":0.1604},"knobResponse":[0.2196,0.2371,0.1217,0.1311]},{"slug":"center-pivot","title":"Center Pivot","family":"farm","round":27,"note":"비행기 창으로 내려다본 들판이에요. 흙길로 나뉜 황토색 땅에 원형 밭이 두 줄로 넷씩 놓이고, 은빛 스프링클러 팔이 돌며 지나간 부채꼴을 짙게 적셨다가 말려요. 금빛 밀밭은 콤바인이 바깥부터 베어 들어가요. K1 이 봄에서 늦가을까지 철을 돌리고, 누르면 모든 팔이 한 바퀴 돌아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-center-pivot","type":"code","name":"center-pivot","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Season=0..1, Speed=0.2..3, Fields=2..4, Clouds=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Season","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fields","min":2,"max":4},{"name":"Clouds","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0527,"detail":0.0683,"edges":0.2287,"complexity":2.4956,"coverage":1,"colour":0.1929,"drift":0.0389},"knobResponse":[0.1272,0.0462,0.1999,0.1865]},{"slug":"chain-fountain","title":"Chain Fountain","family":"physics","round":78,"note":"떨어지는 끝에 끌려 나온 구슬 사슬이 단지 위로 뒤집힌 현수선 아치를 그리고 바닥으로 쏟아지다, 더미가 바닥나면 꼬리가 휘어 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-chain-fountain","type":"code","name":"chain-fountain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drop=67..75, Push=0.26..0.29","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drop","min":67,"max":75},{"name":"Push","min":0.26,"max":0.29}],"start":[0,2,67,0.26],"measures":{"motion":0.8058,"detail":0.038,"edges":0.553,"complexity":0.3325,"coverage":0.19,"colour":0.1643,"drift":0.0482},"knobResponse":[0.0565,0.0433,0.065,0.0468]},{"slug":"change-ringing","title":"Change Ringing","family":"rhythm","round":20,"note":"종탑 종실에서 종들이 바퀴째 한 바퀴씩 돌며 칠 때마다 번쩍이고, 그 아래로 종마다 제 색의 선이 체인지 한 줄에 한 칸씩 Plain Bob 을 따라 지그재그로 흘러내려요. 트레블의 선만 빨강이고, K1 을 누르면 「Bob!」을 불러 다음 리드 엔드에서 2번 자리 대신 4번 자리를 만들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-change-ringing","type":"code","name":"change-ringing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lines=0..1, Speed=0.25..3, Bells=4..8, Method=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lines","min":0,"max":1},{"name":"Speed","min":0.25,"max":3},{"name":"Bells","min":4,"max":8},{"name":"Method","min":-1,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.4844,"detail":0.08,"edges":0.458,"complexity":1.2457,"coverage":0.5293,"colour":0.2305,"drift":0.0504},"knobResponse":[0.0499,0.1129,0.1732,0.0613]},{"slug":"chebyshev-bias","title":"Chebyshev's Bias","family":"number","round":48,"note":"로그 눈금 수직선을 따라 흰 앞줄이 올라가며 소수 경주 64개를 파랗게 칠하고, 반대쪽이 앞선 드문 자리만 주황 점으로 남아 26,861 에서 첫 고리가 퍼져요. K3 은 경주 묶음을, K4 는 아슬아슬한 자리를 보라로 칠할 폭을 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-chebyshev-bias","type":"code","name":"chebyshev-bias","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Races=0..2, Margin=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Races","min":0,"max":2},{"name":"Margin","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2555,"detail":0.0581,"edges":0.156,"complexity":1.14,"coverage":1,"colour":0.2935,"drift":0.2812},"knobResponse":[0.2202,0.1171,0.1174,0.0849]},{"slug":"chemical-garden","title":"Chemical Garden","family":"chemistry","round":21,"note":"물유리 용액을 채운 키 큰 유리컵 모래 위에 금속염 결정을 떨어뜨리면 코발트의 청보라나 철의 녹슨 주황 같은 속 빈 광물 관이 흔들리며 수면까지 자라요. 컵이 차면 빈 컵이 밀려 들어와 다시 자라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-chemical-garden","type":"code","name":"chemical-garden","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Salts=0..4, Speed=0.2..3, Crystals=5..20, Strength=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Salts","min":0,"max":4},{"name":"Speed","min":0.2,"max":3},{"name":"Crystals","min":5,"max":20},{"name":"Strength","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.044,"detail":0.0682,"edges":0.4036,"complexity":2.0411,"coverage":0.7726,"colour":0.152,"drift":0.0448},"knobResponse":[0.0762,0.0506,0.0924,0.0773]},{"slug":"chimera-state","title":"Chimera State","family":"rhythm","round":35,"note":"똑같은 위상 진동자 256개가 고리에 앉아 서로 당기는데, 고리가 발맞춰 도는 30% 와 위상이 흩어진 나머지로 갈라져요. 위 20줄은 진동자마다 위상을 제자리에 점으로 찍어 매끈한 호 옆에 흩뿌린 점을 보이고, 그 아래로 한 줄이 한 순간이라 가운데로 하늘색 띠가 곧게 흐르고 양옆은 한 바퀴씩 뒤처지는 진동자의 어두운 획으로 채워져요. K3 은 위상 지연을 80도에서 88도로 돌려 발맞춘 띠를 19열에서 9열로 좁히고, K1 을 누르면 새 무작위 출발에서 키메라가 다시 자라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-chimera-state","type":"code","name":"chimera-state","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lag=80..88, Stride=0.8..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lag","min":80,"max":88},{"name":"Stride","min":0.8,"max":4}],"start":[0,2,80,0.8],"measures":{"motion":0.871,"detail":0.1412,"edges":0.5685,"complexity":1.5664,"coverage":0.8292,"colour":0.6214,"drift":0.032},"knobResponse":[0.5105,0.2386,0.2458,0.1784]},{"slug":"chladni","title":"Chladni","family":"wave","round":16,"note":"세운 놋쇠 판에 뿌린 모래가 떨리는 자리에서 튀어 나가 가만히 있는 마디선에 모여 클라드니 도형을 그려요. 5초마다 활을 다시 그으면 모래가 흩어졌다가 새 모드의 도형을 찾아가고, K4 를 올리면 석송 가루가 배 자리마다 둥근 노란 더미로 모여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-chladni","type":"code","name":"chladni","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Plate=0..1, Drive=0.8..3, Pitch=-1..1, Powder=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Plate","min":0,"max":1},{"name":"Drive","min":0.8,"max":3},{"name":"Pitch","min":-1,"max":1},{"name":"Powder","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4769,"detail":0.0916,"edges":0.6144,"complexity":1.6152,"coverage":0.9904,"colour":0.0973,"drift":0.0566},"knobResponse":[0.0837,0.1502,0.16,0.131]},{"slug":"chromatography","title":"Chromatography","family":"chemistry","round":20,"note":"실험대 위 유리 수조에 거름종이 띠가 매달려 발끝을 용매에 담그고, 젖은 앞선이 올라가는 동안 연필 출발선의 잉크 점이 색 띠로 갈라져 저마다 다른 빠르기로 올라가요. K1 을 누르면 띠를 들어 올리고 새 띠를 걸어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-chromatography","type":"code","name":"chromatography","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Inks=0..3, Speed=0.2..3, Strips=3..6, Solvent=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Inks","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Strips","min":3,"max":6},{"name":"Solvent","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0352,"detail":0.0646,"edges":0.3051,"complexity":1.2207,"coverage":0.7347,"colour":0.2232,"drift":0.0399},"knobResponse":[0.0454,0.0548,0.2236,0.048]},{"slug":"chrome-powder","title":"Chrome Powder","family":"cosmetic","round":32,"note":"판 전체가 크롬 파우더를 얹은 젤 한 면이에요. 보이지 않는 어플리케이터가 작은 원을 그리며 위에서 아래로 문지르면 무광 회색 가루가 로즈골드 거울로 바뀌고, 거울에는 소프트박스의 흰 띠와 검은 반사판 띠가 물결지며 비쳐요. 다 덮이면 빛이 비스듬히 한 번 쓸고, 새 가루가 위에서부터 다시 덮여요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-chrome-powder","type":"code","name":"chrome-powder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Holo=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Holo","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1725,"detail":0.0415,"edges":0.2939,"complexity":1.5841,"coverage":0.922,"colour":0.1297,"drift":0.2833},"knobResponse":[0.0785,0.1385,0.1031,0.0512]},{"slug":"circuit-board","title":"Circuit Board","family":"circuit","round":17,"note":"회로 기판이 패널을 다 채우고, Lee 의 미로 라우터가 프로세서와 메모리 둘, 플래시, 크리스털, 금도금 단자 사이에 구리 선 47개를 곧게, 또 45도로 깔아요. 버스에는 펄스 열이 나란히 달리고 바쁜 선은 신호 색으로 데워지며, K1 을 누르면 기판이 꺼졌다가 부팅해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-circuit-board","type":"code","name":"circuit-board","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Mask=0..1, Clock=0.5..4, Traffic=0..1, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Mask","min":0,"max":1},{"name":"Clock","min":0.5,"max":4},{"name":"Traffic","min":0,"max":1},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2002,"detail":0.119,"edges":0.678,"complexity":0.7577,"coverage":0.9814,"colour":0.2535,"drift":0.0471},"knobResponse":[0.2116,0.0618,0.0696,0.0621]},{"slug":"circulation","title":"Circulation","family":"body","round":22,"note":"해부도처럼 머리부터 발끝까지 선 사람이에요. 심장이 뛸 때마다 붉은 피의 맥이 동맥을 타고 머리와 손발 끝까지 번져 가고, 푸른 정맥혈은 심장 쪽으로 거슬러 올라오며 폐가 박동과 숨에 분홍빛으로 물들어요. 발치의 모니터에는 심전도와 맥박 수가 떠요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-circulation","type":"code","name":"circulation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Chart=0..1, Rate=1..5, Detail=1..4, Effort=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Chart","min":0,"max":1},{"name":"Rate","min":1,"max":5},{"name":"Detail","min":1,"max":4},{"name":"Effort","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3125,"detail":0.0474,"edges":0.3512,"complexity":1.0533,"coverage":0.3719,"colour":0.2033,"drift":0.0315},"knobResponse":[0.1504,0.046,0.0247,0.0525]},{"slug":"cistercian-numerals","title":"Cistercian Numerals","family":"type","round":76,"note":"패널 높이의 막대 하나에 시토회 수도사 숫자로 네 자리 수를 적고, 수가 바뀔 때마다 단위, 십, 백, 천의 귀가 문처럼 닫혔다 새 꼴로 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cistercian-numerals","type":"code","name":"cistercian-numerals","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Count=0..3, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Count","min":0,"max":3},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5687,"detail":0.0427,"edges":0.4323,"complexity":0.1964,"coverage":0.2135,"colour":0.1776,"drift":0.1687},"knobResponse":[0.0928,0.0599,0.1203,0.1454]},{"slug":"clay-mask","title":"Clay Mask","family":"cosmetic","round":32,"note":"판 전체에 스패출러로 바른 로즈 클레이가 얇은 곳부터 말라 들어가요. 짙은 라즈베리색 윤이 먼저 빠지고 옅은 블러시색 무광이 섬처럼 번지다가, 두꺼운 결만 마지막까지 짙은 줄로 남아요. 8초쯤 다 마르면 물 띠가 위에서 아래로 2초 동안 지나가며 다시 적셔요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-clay-mask","type":"code","name":"clay-mask","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thickness=-1..1, Gloss=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thickness","min":-1,"max":1},{"name":"Gloss","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0642,"detail":0.0418,"edges":0.1071,"complexity":2.3182,"coverage":1,"colour":0.1574,"drift":0.2242},"knobResponse":[0.2918,0.1358,0.0941,0.1324]},{"slug":"cleansing-balm","title":"Cleansing Balm","family":"cosmetic","round":33,"note":"서리 낀 셔벗 밤이 무광으로 판을 채우고, 아래에서 올라오는 온기와 보이지 않는 손끝이 닿은 곳마다 밤이 녹아 맑은 광택 오일이 돼요. 오일은 흘러내려 바닥에 고이고, 다 녹으면 위에서 새 밤이 다시 휘핑돼요. K3 은 녹는 빠르기와 높이를 정하고, K1 을 누르면 손끝 하나가 지름 20 LED 를 한 번에 녹여요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cleansing-balm","type":"code","name":"cleansing-balm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Warmth=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Warmth","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1343,"detail":0.0375,"edges":0.1005,"complexity":2.1868,"coverage":1,"colour":0.1701,"drift":0.1197},"knobResponse":[0.2675,0.0873,0.1368,0.0422]},{"slug":"clebsch-surface","title":"Clebsch Surface","family":"space","round":59,"note":"직선 27개가 다 실수인 클렙시 3차 곡면이 납작한 회전타원체 안에서 돌고, 이중 여섯이 청록과 분홍, 나머지 15개가 초록으로 곡면 위에 서요. 흰 초점이 2.5초마다 만나는 직선 10개 가운데 하나로 옮겨 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-clebsch-surface","type":"code","name":"clebsch-surface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Glass=0..1, Tilt=12..60","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Glass","min":0,"max":1},{"name":"Tilt","min":12,"max":60}],"start":[0,2,0,12],"measures":{"motion":0.2109,"detail":0.0462,"edges":0.3866,"complexity":1.4036,"coverage":0.61,"colour":0.1889,"drift":0.1456},"knobResponse":[0.0905,0.1477,0.1012,0.2034]},{"slug":"climber","title":"Climber","family":"pixel","round":2,"note":"빨간 목도리를 맨 꼬마가 혼자서 끝없는 탑의 턱을 뛰어올라요. K4 를 돌리면 한낮에서 노을을 지나 횃불 켜진 밤이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-climber","type":"code","name":"climber","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.3..3.5, Gap=16..34, Sky=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.3,"max":3.5},{"name":"Gap","min":16,"max":34},{"name":"Sky","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":1.5193,"detail":0.0867,"edges":0.9308,"complexity":0.2662,"coverage":0.7278,"colour":0.1488,"drift":0.118},"knobResponse":[0.0827,0.1542,0.146,0.1338]},{"slug":"climbing-wall","title":"Climbing Wall","family":"sport","round":27,"note":"체육관의 리드 벽을 정면에서 봐요. 합판에 색깔별 루트가 박혀 있고, 클라이머가 스폿 빛을 받으며 손발을 하나씩 옮겨 오르다 퀵드로마다 로프를 걸어요. 꼭대기 앵커를 걸면 빌레이어가 내려 주고 둘이 자리를 바꿔요. K3 은 셋까지 나란히 오르게 하고, 누르면 클라이머가 떨어져 로프에 걸려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-climbing-wall","type":"code","name":"climbing-wall","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Route=0..1, Speed=0.2..3, Climbers=1..3, Light=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Route","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Climbers","min":1,"max":3},{"name":"Light","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.067,"detail":0.0707,"edges":0.3416,"complexity":1.7869,"coverage":0.9212,"colour":0.1755,"drift":0.0209},"knobResponse":[0.0608,0.0368,0.048,0.1959]},{"slug":"cloth","title":"Cloth","family":"physics","round":2,"note":"12×22 매듭 천이 나무 봉의 집게에 걸려 있고, 뒤에서 부는 돌풍이 천을 앞으로 들어 올려요. LED 마다 그 자리 천이 빛에서 기운 만큼 밝아서 주름이 등고선처럼 읽혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-cloth","type":"code","name":"cloth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Wind=0..3, Stiffness=0..1, Pins=2..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Wind","min":0,"max":3},{"name":"Stiffness","min":0,"max":1},{"name":"Pins","min":2,"max":12}],"start":[0,2,0,2],"measures":{"motion":0.5789,"detail":0.0244,"edges":0.3966,"complexity":0.9079,"coverage":0.5904,"colour":0.3319,"drift":0.4132},"knobResponse":[0.2963,0.322,0.2371,0.2837]},{"slug":"clothesline","title":"Clothesline","family":"type","round":72,"note":"줄 넷에 집게로 꽂은 「바람이 분다 살아야겠다」 카드가 왼쪽에서 건너오는 돌풍에 차례로 흔들리고 비틀렸다가 곧은 자리를 지나 되흔들려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-clothesline","type":"code","name":"clothesline","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=2..7, Gust=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":2,"max":7},{"name":"Gust","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2752,"detail":0.0584,"edges":0.486,"complexity":1.0766,"coverage":0.4305,"colour":0.1971,"drift":0.057},"knobResponse":[0.0882,0.0798,0.2338,0.1206]},{"slug":"cloud-chamber","title":"Cloud Chamber","family":"particle","round":27,"note":"과학관의 확산 안개상자를 유리 뚜껑 위에서 내려다봐요. 등줄 빛을 받은 검은 펠트 위로 우주선 뮤온이 가는 직선을 패널 끝까지 긋고, 알파 입자는 짧고 굵은 막대를, 전자는 흐린 실을 남겨요. 자취는 한순간에 맺혔다가 대류를 따라 흘러가며 몇 초 만에 번져 사라져요. K3 은 토륨 막대를 세워 알파 부채를 뿜게 하고, K4 는 자기장으로 전자를 나선으로 감아요.","why":"흰 줄 몇 개뿐이라 색이 없어요(색 0.05).","block":1,"ramped":false,"layer":{"id":"layer-cloud-chamber","type":"code","name":"cloud-chamber","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Source=0..1, Field=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Source","min":0,"max":1},{"name":"Field","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.104,"detail":0.0456,"edges":0.3473,"complexity":1.374,"coverage":0.2504,"colour":0.0521,"drift":0.0923},"knobResponse":[0.046,0.1102,0.1287,0.0714]},{"slug":"coded-aperture","title":"Coded Aperture","family":"type","round":75,"note":"위에서 빛나는 낱말이 MURA 구멍 카드를 지나 검출기에 광자 하나씩 그림자를 겹쳐 쌓고, 읽히지 않는 그 그림자를 해독 배열과 상관시키면 맨 아래 띠에서 낱말이 잡음 위로 떠올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-coded-aperture","type":"code","name":"coded-aperture","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rate=0.2..3, Mask=0..2, Word=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rate","min":0.2,"max":3},{"name":"Mask","min":0,"max":2},{"name":"Word","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.6625,"detail":0.1101,"edges":0.5519,"complexity":0.7864,"coverage":0.4538,"colour":0.1161,"drift":0.0824},"knobResponse":[0.0559,0.1354,0.1486,0.0861]},{"slug":"composing-stick","title":"Composing Stick","family":"type","round":68,"note":"활자 상자에서 한 개씩 날아온 활자가 조판 막대에 거꾸로 서서 스페이스로 줄을 맞추고, 판에서는 거울 글자로 오른쪽에서 왼쪽으로 읽히다가 아래 종이에 찍혀서야 바로 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-composing-stick","type":"code","name":"composing-stick","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Spacing=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Spacing","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1192,"detail":0.0955,"edges":0.4504,"complexity":0.6662,"coverage":0.8248,"colour":0.2109,"drift":0.1879},"knobResponse":[0.0397,0.0995,0.0603,0.04]},{"slug":"constant-width","title":"Constant Width","family":"geometry","round":35,"note":"너비 62 LED 의 통로를 폭이 일정한 곡선이 위아래로 맞닿아 쌓인 채 내려가요. 뢸로 삼각형과 오각형, 칠각형, 홀수 배음으로 지은 매끈한 곡선과 원이 저마다 다른 빠르기로 도는데도 늘 두 벽과 위아래 경계선에 닿고, 닿은 자리마다 흰 점이 서요. K3 은 곡선마다 같은 너비의 원을 섞어 둘레 194.8 은 그대로 두고 삼각형의 넓이 2709 LED 를 원의 3019 까지 부풀리고, K1 을 누르면 꼭짓점이 지나간 길이 금색으로 남아 삼각형이 귀만 둥근 정사각형을 그려요.","why":"세 색의 뢸로 삼각형이 맞물려 굴러요. 0531 처럼 큰 색면 몇 개가 화면 전부예요.","block":0,"ramped":false,"layer":{"id":"layer-constant-width","type":"code","name":"constant-width","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Round=0..1, Spin=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Round","min":0,"max":1},{"name":"Spin","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4094,"detail":0.0438,"edges":1,"complexity":0.0838,"coverage":0.7349,"colour":0.4286,"drift":0.2768},"knobResponse":[0.306,0.2393,0.1029,0.1377]},{"slug":"continuum-random-tree","title":"Continuum Random Tree","family":"fractal","round":40,"note":"정규화한 브라운 엑스커션으로 짠 앨더스의 연속 랜덤 나무가 바닥의 뿌리에서 선 끊기로 잎 하나씩 자라고, 새 가지마다 흰 빛이 타고 올라가요. 다 자라면 시야가 가지 하나로 뛰어들고, 브라운 크기로 늘린 그 가지가 다시 온전한 나무가 되어 계속 자라요. K3 은 뛰어들 가지의 질량을 0.3 에서 0.06 으로 줄이고, 누르면 바로 뛰어들어요.","why":"빛나는 나뭇가지로 읽혀서 나무 그림이 돼요.","block":1,"ramped":false,"layer":{"id":"layer-continuum-random-tree","type":"code","name":"continuum-random-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dive=0..1, Cut=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dive","min":0,"max":1},{"name":"Cut","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3771,"detail":0.0535,"edges":0.3564,"complexity":1.3506,"coverage":0.3764,"colour":0.1995,"drift":0.2451},"knobResponse":[0.0977,0.2136,0.2254,0.0526]},{"slug":"contour","title":"Contour Map","family":"data","round":2,"note":"천천히 솟고 가라앉는 땅의 지형도예요. 다섯째 등고선마다 밝고, 바닷물이 차오르면 선은 땅에 그대로 남은 채 물 밑으로 들어가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-contour","type":"code","name":"contour","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Morph=0..6, Interval=50..200, Sea level=-300..600","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Morph","min":0,"max":6},{"name":"Interval","min":50,"max":200},{"name":"Sea level","min":-300,"max":600}],"start":[0,2,50,0.06],"measures":{"motion":0.059,"detail":0.1124,"edges":0.4216,"complexity":2.7352,"coverage":1,"colour":0.2347,"drift":0.0329},"knobResponse":[0.3087,0.1314,0.1058,0.2222]},{"slug":"conways-soldiers","title":"Conway's Soldiers","family":"algo","round":47,"note":"선 아래 금색 병사가 옆 병사를 뛰어넘어 하나를 1, 2, 3, 4줄 위로 보내는 데 2, 4, 8, 20명이 들어요. 병사마다 단 x^d 무게만 한 보라 원판이 뛰어넘을 때마다 합쳐져 마지막 병사에서 무게 1 의 고리를 꼭 채우고, 5줄에는 끝없는 군대도 닿지 못해 빨간 X 가 남아요. K3 은 출정, K4 는 무게 빛이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-conways-soldiers","type":"code","name":"conways-soldiers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Row=0..5, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Row","min":0,"max":5},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0992,"detail":0.0443,"edges":0.2789,"complexity":0.1147,"coverage":0.3897,"colour":0.2082,"drift":0.0665},"knobResponse":[0.0918,0.0603,0.227,0.0597]},{"slug":"corn-maze","title":"Corn Maze","family":"halloween","round":45,"note":"손전등을 든 사람이 밤의 옥수수 미로를 걸으면 빛줄기가 앞쪽 옥수수를 금빛으로 밝히고, 옥수수 너머의 길은 보라 그림자로 남아요. 막다른 길에서 초록 눈 두 개가 번뜩이면 빛이 떨리고 사람은 돌아서서 달아나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-corn-maze","type":"code","name":"corn-maze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beam=0..1, Moon=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beam","min":0,"max":1},{"name":"Moon","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1764,"detail":0.0771,"edges":0.2834,"complexity":0.3394,"coverage":0.2735,"colour":0.2662,"drift":0.3821},"knobResponse":[0.1026,0.1685,0.0891,0.0964]},{"slug":"cornsweet-letters","title":"Cornsweet Letters","family":"type","round":81,"note":"속이 바탕과 똑같은 색인 글자 셋이 테두리의 밝기 계단만으로 바탕보다 밝아 보였다가 어두워 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cornsweet-letters","type":"code","name":"cornsweet-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Cover=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":1},{"name":"Cover","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0402,"detail":0.0203,"edges":0.1283,"complexity":0.2615,"coverage":1,"colour":0.1286,"drift":0.024},"knobResponse":[0.2492,0.0594,0.045,0.1326]},{"slug":"cornu-spiral","title":"Cornu Spiral","family":"line","round":60,"note":"오일러 나선의 두 팔이 두 눈으로 감기고, 한 눈에서 나오거나 정해진 호만큼 떨어진 두 점을 잇는 현이 나선을 따라 미끄러져요. 그 현 길이의 제곱이 아래에 직선 모서리나 슬릿 뒤의 프레넬 무늬로 쌓여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cornu-spiral","type":"code","name":"cornu-spiral","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slit=0..1, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slit","min":0,"max":1},{"name":"Spread","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1715,"detail":0.0514,"edges":0.5539,"complexity":0.4702,"coverage":0.187,"colour":0.1843,"drift":0.0264},"knobResponse":[0.062,0.029,0.0654,0.0342]},{"slug":"costas-array","title":"Costas Array","family":"rhythm","round":53,"note":"위 절반에서 코스타스 배열이 주파수 도약 리듬으로 울리는 동안 장밋빛 사본이 시간과 높이로 한 칸씩 나선을 그리며 밀려 점에 닿을 때마다 번쩍이고, 아래 절반은 밀린 칸마다 맞은 점의 수를 채워 0 과 1 의 바닥 가운데 N 하나만 솟은 압정이 돼요. K3 은 배열을 짓는 유한체(원소 11~32개), K4 는 배열을 코스타스가 아닌 순열로 바꿔 지도에 2 이상의 능선을 키우는 것이고, 단추를 누르면 다음 배열로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-costas-array","type":"code","name":"costas-array","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Field=0..8, Rival=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Field","min":0,"max":8},{"name":"Rival","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.3252,"detail":0.0515,"edges":0.7559,"complexity":0.0988,"coverage":0.2034,"colour":0.1387,"drift":0.0603},"knobResponse":[0.0419,0.0476,0.0672,0.0563]},{"slug":"couette-shimmer","title":"Couette Shimmer","family":"cosmetic","round":38,"note":"두 원통 사이에 든 펄 세럼을 옆에서 봐요. 안쪽 원통이 빨라지면 옆으로 흐르던 결이 테일러 소용돌이의 밝고 어두운 띠로 128줄을 쌓고, 더 빨라지면 띠가 물결치며 원통을 돌아요. K3 은 띠를 다섯 쌍에서 열네 쌍으로 늘려 가는 골로 만들고, K4 는 바깥 원통을 거꾸로 돌려 띠를 나선으로 기울여요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-couette-shimmer","type":"code","name":"couette-shimmer","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Spin=0.5..4, Rolls=5..14, Counter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Spin","min":0.5,"max":4},{"name":"Rolls","min":5,"max":14},{"name":"Counter","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.2097,"detail":0.0404,"edges":0.1149,"complexity":2.5766,"coverage":0.9999,"colour":0.1504,"drift":0.059},"knobResponse":[0.3171,0.1536,0.1747,0.1924]},{"slug":"counterforms","title":"Counterforms","family":"type","round":64,"note":"굵은 글자 넷이 흐린 돌빛으로 어둠에 서 있고, 글자 안의 빈 자리인 카운터만 안에서 켠 창처럼 빛나요. 낱말이 바뀔 때마다 창이 비었다가 다음 낱말의 창이 아래부터 하나씩 차올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-counterforms","type":"code","name":"counterforms","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Words=0..2, Body=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Words","min":0,"max":2},{"name":"Body","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1606,"detail":0.0234,"edges":0.1514,"complexity":1.1058,"coverage":0.578,"colour":0.1785,"drift":0.3344},"knobResponse":[0.1819,0.1356,0.2615,0.2091]},{"slug":"coupling-from-the-past","title":"Coupling from the Past","family":"noise","round":80,"note":"모두 위로 놓은 이징 자석과 모두 아래로 놓은 이징 자석이 위아래 반에서 같은 난수로 −T 부터 0 까지 달리고, 둘이 어긋난 분홍 자리가 0 까지 다 녹으면 그 그림이 정확한 표본이고 하나라도 남으면 두 배 먼 과거에서 다시 출발해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-coupling-from-the-past","type":"code","name":"coupling-from-the-past","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beta=0.32..0.43, Field=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beta","min":0.32,"max":0.43},{"name":"Field","min":-1,"max":1}],"start":[0,2,0.32,0.06],"measures":{"motion":2.9321,"detail":0.1333,"edges":0.9379,"complexity":0.1472,"coverage":0.9836,"colour":0.2908,"drift":0.2061},"knobResponse":[0.3113,0.3054,0.2299,0.4225]},{"slug":"coxeter-frieze","title":"Conway-Coxeter Frieze","family":"number","round":72,"note":"칠각형의 삼각 분할이 정하는 정수 띠가 세로로 서서 모든 마름모가 ad − bc = 1 을 지키며 내려가고, 대각선 하나가 뒤집힐 때마다 바뀐 수가 하얗게 번쩍여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-coxeter-frieze","type":"code","name":"coxeter-frieze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=7..11, Chords=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":7,"max":11},{"name":"Chords","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.2849,"detail":0.0767,"edges":0.5929,"complexity":0.3454,"coverage":0.4879,"colour":0.1317,"drift":0.1196},"knobResponse":[0.0813,0.1338,0.1684,0.0742]},{"slug":"crackle-polish","title":"Crackle Polish","family":"cosmetic","round":39,"note":"형광 분홍 바탕 위의 검은 크래클 탑코트가 마르며 갈라져요. 긴 금이 먼저 패널을 가로지르고, 짧은 금이 옛 금에서 직각으로 나와 다른 금에 직각으로 닿고, 틈이 벌어지며 조각이 광택 테를 두른 구슬이 돼요. 다 갈라지면 새 코트를 위에서 칠해 내려와요.","why":"갈라진 선이 좋은데 거의 안 움직여요(움직임 0.06).","block":1,"ramped":false,"layer":{"id":"layer-crackle-polish","type":"code","name":"crackle-polish","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Craze=0..1, Coat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Craze","min":0,"max":1},{"name":"Coat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0606,"detail":0.0894,"edges":0.5269,"complexity":1.379,"coverage":0.5043,"colour":0.2853,"drift":0.1556},"knobResponse":[0.1036,0.1543,0.0671,0.6128]},{"slug":"crackling-noise","title":"Crackling Noise","family":"noise","round":61,"note":"영온 무작위장 이징 자석을 아래에서 위로 쓸어 올리면 눈사태 하나하나가 제 색으로 기어 나가서, 판이 크고 작은 덩어리의 조각보가 돼요. 다 뒤집히면 거꾸로 쓸어 내려 어둑한 조각보를 남기고 새 무질서로 다시 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-crackling-noise","type":"code","name":"crackling-noise","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Disorder=1.05..2.6, Grain=0..1.6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Disorder","min":1.05,"max":2.6},{"name":"Grain","min":0,"max":1.6}],"start":[0,2,1.05,0.06],"measures":{"motion":0.0576,"detail":0.0462,"edges":0.6729,"complexity":0.1681,"coverage":0.5893,"colour":0.4821,"drift":0.3457},"knobResponse":[0.2264,0.1134,0.2937,0.3249]},{"slug":"creaking-door","title":"Creaking Door","family":"halloween","round":52,"note":"보라 복도 끝의 문이 다섯 번 덜컹이며 삐걱 열리면 촛불 빛이 쐐기로 넓어지며 바닥과 왼쪽 벽을 타고, 그 빛 속으로 손가락이 긴 손 그림자가 기어 나오거나 뾰족 모자의 그림자가 지나가요. 문이 쾅 닫히면 판이 흔들리고 먼지가 떨어지고, 문 밑 빛줄기를 두 발이 지나가요. K3 은 빛이 닿는 거리, K4 는 공기 속 먼지이고, K1 을 누르면 문이 닫히거나 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-creaking-door","type":"code","name":"creaking-door","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Reach=0..1, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Reach","min":0,"max":1},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3271,"detail":0.0303,"edges":0.2098,"complexity":0.3788,"coverage":0.9562,"colour":0.2848,"drift":0.2119},"knobResponse":[0.1772,0.1071,0.1188,0.1277]},{"slug":"cream-swirl","title":"Cream Swirl","family":"cosmetic","round":29,"note":"보이지 않는 팔레트 나이프가 크림을 S자와 소용돌이로 펴 바르며 매끈한 띠와 윤기 나는 둔덕을 남기고, 떨어진 색 크림 덩이를 길쭉한 리본으로 끌고 가요. 부드러운 빛이 7초에 한 번 좌우로 오가며 결 위로 윤이 미끄러져요. K3 을 올리면 섞이는 색조가 셋까지 늘고, 누르면 가장 진한 색 덩이가 칼 앞에 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cream-swirl","type":"code","name":"cream-swirl","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tones=1..3, Gloss=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tones","min":1,"max":3},{"name":"Gloss","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0374,"detail":0.0161,"edges":0.0277,"complexity":1.8116,"coverage":1,"colour":0.1658,"drift":0.0429},"knobResponse":[0.2103,0.0689,0.1027,0.1086]},{"slug":"crofton-cell","title":"Crofton Cell","family":"cells","round":82,"note":"판을 가로지르는 푸아송 직선들이 움직이며 판을 볼록한 칸으로 자르고, 가운데 점을 품은 칸만 금빛 모서리 안의 옅은 내접원으로 빛나서 Big 을 올리면 그 칸이 커지며 변이 늘고 원에 가까워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-crofton-cell","type":"code","name":"crofton-cell","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=16..56, Big=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":16,"max":56},{"name":"Big","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.3316,"detail":0.0738,"edges":0.6777,"complexity":0.7314,"coverage":0.9037,"colour":0.3379,"drift":0.1617},"knobResponse":[0.2782,0.1733,0.2573,0.3703]},{"slug":"crossroads","title":"Crossroads","family":"city","round":17,"note":"드론으로 곧장 내려다본 밤 네거리예요. 차는 전조등과 미등으로만 보이고, 나트륨등 웅덩이 사이에서 신호가 줄을 세웠다 풀며, 모든 차가 서면 사람들이 건널목 넷을 한꺼번에 건너요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-crossroads","type":"code","name":"crossroads","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamps=0..1, Pace=0.2..3, Hour=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamps","min":0,"max":1},{"name":"Pace","min":0.2,"max":3},{"name":"Hour","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2133,"detail":0.0621,"edges":0.4808,"complexity":0.9935,"coverage":0.2564,"colour":0.385,"drift":0.0485},"knobResponse":[0.05,0.0417,0.0482,0.062]},{"slug":"crystal-ball","title":"Crystal Ball","family":"halloween","round":44,"note":"놋쇠 받침 위 수정 구슬 속에서 보라와 독초록 연기가 돌다가, 이따금 해골이나 눈, 초승달로 모였다 풀려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-crystal-ball","type":"code","name":"crystal-ball","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Smoke=0..1, Visions=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Smoke","min":0,"max":1},{"name":"Visions","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3664,"detail":0.0447,"edges":0.8468,"complexity":0.1092,"coverage":0.4161,"colour":0.198,"drift":0.0742},"knobResponse":[0.0514,0.1069,0.0438,0.0916]},{"slug":"curlicue","title":"Curlicue","family":"number","round":49,"note":"세타 합의 부분합이 가운데에서 양쪽으로 한 걸음씩 자라 서로 닿지 않는 LED 레이스가 되고, 화면이 끝없이 물러나도 단계마다 같은 갈고리가 다시 감겨 나와요. K3 은 √3 부터 √101 − 10 까지 무리수 다섯 가운데 x 를, K4 는 한 단계의 걸음 수를 골라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-curlicue","type":"code","name":"curlicue","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Number=0..1, Steps=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":1},{"name":"Steps","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4325,"detail":0.335,"edges":1,"complexity":0.1058,"coverage":0.1676,"colour":0.3546,"drift":0.1521},"knobResponse":[0.1317,0.1139,0.1229,0.113]},{"slug":"curve-shortening","title":"Curve Shortening","family":"line","round":36,"note":"굵은 나선이나 접힌 지렁이, 팔 여럿인 별 같은 닫힌 곡선 하나가 점마다 곡률만큼의 빠르기로 법선을 따라 움직여요. 곡선은 제 몸에 한 번도 닿지 않고 풀려 둥글어진 뒤 한 점으로 사라지고, 넓이는 모양과 상관없이 흐름 시간 1 에 2π 씩 줄며, 흰 점으로 찍힌 변곡점은 둘씩 만나 함께 없어져요. K3 은 나선을 2바퀴에서 3.5바퀴까지 감고, K1 을 누르면 남은 흐름이 0.6초 만에 끝나요.","why":"도형 하나가 줄어들다 사라져서 빈 화면이 길어요.","block":1,"ramped":false,"layer":{"id":"layer-curve-shortening","type":"code","name":"curve-shortening","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=2..3.5, Trace=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":2,"max":3.5},{"name":"Trace","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2037,"detail":0.0249,"edges":0.5796,"complexity":0.2104,"coverage":0.1942,"colour":0.2439,"drift":0.3752},"knobResponse":[0.229,0.2408,0.2872,0.1241]},{"slug":"cushion-mesh","title":"Cushion Mesh","family":"cosmetic","round":32,"note":"쿠션 팩트의 망사를 몇 밀리미터 앞에서 봐요. 1 LED 마다 검은 실과 장밋빛 구멍이 번갈아 서고, 보이지 않는 퍼프가 0.5초마다 지름 28 LED 쯤의 자국을 찍으면 그 안의 구멍 78% 에 흰 파운데이션 방울이 맺혀요. 방울은 연어색으로 물들었다가 자국 가장자리부터 빨려 들어가고, 판에는 늘 769개가 남아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cushion-mesh","type":"code","name":"cushion-mesh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Press=-1..1, Puff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Press","min":-1,"max":1},{"name":"Puff","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0612,"detail":0.3133,"edges":0.19,"complexity":0.3734,"coverage":0.5,"colour":0.1055,"drift":0.1322},"knobResponse":[0.0477,0.1254,0.1656,0.1397]},{"slug":"cyanotype","title":"Cyanotype","family":"print","round":19,"note":"철염을 바른 종이에 고사리와 깃털, 민들레 씨앗, 레이스를 놓고 햇빛에 구운 뒤 물로 씻어 내리면 프러시안 블루 인화가 드러나요. 마르며 짙어진 인화가 옆으로 밀려 나가면 다음 장이 깔려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-cyanotype","type":"code","name":"cyanotype","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tone=0..1, Speed=0.2..3, Specimen=0..4, Exposure=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tone","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Specimen","min":0,"max":4},{"name":"Exposure","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2407,"detail":0.0234,"edges":0.2171,"complexity":1.3748,"coverage":1,"colour":0.239,"drift":0.1842},"knobResponse":[0.1554,0.128,0.0957,0.1334]},{"slug":"damask","title":"Damask","family":"type","round":73,"note":"한 가지 실로 LED 하나에 한 교차씩 짠 천에 큰 낱말이 경수자로 들어 있어서, 낮게 도는 램프를 따라 글자가 바탕보다 밝았다가 어두워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-damask","type":"code","name":"damask","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0333,"detail":0.3241,"edges":0.9743,"complexity":0.8781,"coverage":0.2626,"colour":0.1359,"drift":0.0572},"knobResponse":[0.065,0.0923,0.1287,0.4594]},{"slug":"dandelin-spheres","title":"Dandelin Spheres","family":"geometry","round":33,"note":"유리 원뿔을 평면이 자른 원뿔곡선 위아래로 당들랭 구 둘이 원뿔에 끼어 평면에 닿아 있어요. 곡선을 도는 점에서 두 초점까지의 거리와 원뿔 모선 위 두 토막이 금색과 분홍으로 짝지어 같은 길이로 보여요. K3 은 평면 기울기로 30도의 타원에서 74도의 포물선을 지나 쌍곡선까지 가고, K1 을 누르면 평면이 11초 동안 똑바로 섰다가 돌아와요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-dandelin-spheres","type":"code","name":"dandelin-spheres","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=30..90, Cone=16..34","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":30,"max":90},{"name":"Cone","min":16,"max":34}],"start":[0,2,30,16],"measures":{"motion":0.1793,"detail":0.0495,"edges":0.3572,"complexity":1.3922,"coverage":0.6125,"colour":0.1958,"drift":0.0301},"knobResponse":[0.1111,0.0383,0.2036,0.1906]},{"slug":"dark-field","title":"Dark Field","family":"microbe","round":26,"note":"암시야 현미경 속 연못물 한 방울이에요. 볼복스와 짚신벌레, 돌말, 해캄 실 위의 종벌레가 검은 바탕에 흩은 빛으로만 빛나요. K1 이 라인베르크와 위상차로 조명을 바꾸고, 누르면 종벌레 자루가 용수철처럼 감겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-dark-field","type":"code","name":"dark-field","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Crowd=0..1, Focus=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Crowd","min":0,"max":1},{"name":"Focus","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.3814,"detail":0.2217,"edges":0.4142,"complexity":2.0815,"coverage":0.2631,"colour":0.1726,"drift":0.1456},"knobResponse":[0.5278,0.261,0.0556,0.1832]},{"slug":"datamosh","title":"Datamosh","family":"glitch","round":15,"note":"키프레임을 잃은 영상이에요. 노을과 격자 바닥이 제 움직임대로 블록째 밀려 녹아 흐르고, 장면이 바뀌면 새 그림이 옛 움직임을 따라 부서져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-datamosh","type":"code","name":"datamosh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Block=8..16, Mosh=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Block","min":8,"max":16},{"name":"Mosh","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.3661,"detail":0.0404,"edges":0.6611,"complexity":0.3641,"coverage":1,"colour":0.4625,"drift":0.1386},"knobResponse":[0.3092,0.1339,0.1128,0.1158]},{"slug":"day-cycle","title":"Day and Night","family":"weather","round":2,"note":"호수 위 작은 집이 하루를 지켜봐요. 해가 언덕 뒤로 지면 하늘이 노을을 지나 별과 달로 넘어가고 창에 하나씩 불이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-day-cycle","type":"code","name":"day-cycle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Season=0..1, Time=0.2..8, Clouds=0.15..1, Sun path=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Season","min":0,"max":1},{"name":"Time","min":0.2,"max":8},{"name":"Clouds","min":0.15,"max":1},{"name":"Sun path","min":-1,"max":1}],"start":[0,2,0.15,0.06],"measures":{"motion":0.0549,"detail":0.0184,"edges":0.5425,"complexity":0.6376,"coverage":1,"colour":0.3226,"drift":0.2553},"knobResponse":[0.2229,0.2763,0.1419,0.1052]},{"slug":"de-bruijn-sequence","title":"de Bruijn Sequence","family":"rhythm","round":52,"note":"0과 1의 고리를 1 은 치고 0 은 쉬는 리듬으로 치면서, 박마다 마지막 여섯 비트 창이 가리키는 단어의 타일을 켜서 단어 64개의 판이 한 주기에 꼭 한 번 차고, 그 아래 띠와 베틀 실이 같은 단어를 하나씩 밝혀요. K3 은 수열을 고르는 규칙, K4 는 차수를 6 에서 3 까지 내리고, K1 을 누르면 주기를 끝내고 새 수열로 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-de-bruijn-sequence","type":"code","name":"de-bruijn-sequence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rule=0..2, Zoom=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rule","min":0,"max":2},{"name":"Zoom","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1175,"detail":0.085,"edges":0.5433,"complexity":0.2615,"coverage":0.3366,"colour":0.1693,"drift":0.1252},"knobResponse":[0.0436,0.0602,0.076,0.1567]},{"slug":"dead-leaves","title":"Dead Leaves","family":"noise","round":56,"note":"반지름이 반 LED 부터 20 LED 까지인 원판이 이미 놓인 원판 밑으로 들어가 빈틈에만 보이다가, 마지막 구멍이 닫히면 그 자리에서 흰 고리가 퍼져요. 색은 원판 반지름의 옥타브를 알려 주고, 다음 표본이 차는 동안 구멍으로는 앞 표본이 잿빛으로 비쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-dead-leaves","type":"code","name":"dead-leaves","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grain=0.5..4, Law=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grain","min":0.5,"max":4},{"name":"Law","min":-1,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.1708,"detail":0.1549,"edges":1,"complexity":2.3375,"coverage":0.9888,"colour":0.4014,"drift":0.1961},"knobResponse":[0.417,0.1763,0.28,0.2968]},{"slug":"defect-turbulence","title":"Defect Turbulence","family":"wave","round":40,"note":"복소 긴즈부르크-란다우 방정식을 패널에서 풀어, 허수부와 실수부가 0 인 선을 두 색으로 긋고 둘이 만나는 위상 결함마다 + 와 − 를 찍어요. 처음의 결함 난류에서 쌍이 생기고 사라지며 나선을 끌고 다니다가 나선이 이겨 얼어붙은 칸이 되고, K3 을 Benjamin-Feir 선 아래로 돌리면 난류가 끝내 가라앉지 않아요. K4 는 그리는 시계를 나선의 진동수에 맞춰 팔을 멈춰 세우고, K1 을 누르면 한 자리를 휘저어 결함 쌍을 새로 터뜨려요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-defect-turbulence","type":"code","name":"defect-turbulence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stability=-0.8..0.6, Strobe=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stability","min":-0.8,"max":0.6},{"name":"Strobe","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.8012,"detail":0.3482,"edges":0.8162,"complexity":2.0341,"coverage":0.6518,"colour":0.3884,"drift":0.081},"knobResponse":[0.2629,0.3137,0.315,0.3041]},{"slug":"dehn-twist","title":"Dehn Twist","family":"topology","round":81,"note":"원환면의 닫힌 곡선이 고리띠를 따라 한 바퀴 끌려 돌고 펴질 때마다 류가 (p, q) 에서 (p, q + p) 로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-dehn-twist","type":"code","name":"dehn-twist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Curve=0..5, Twists=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Curve","min":0,"max":5},{"name":"Twists","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2569,"detail":0.058,"edges":0.3986,"complexity":0.8019,"coverage":0.6818,"colour":0.1997,"drift":0.059},"knobResponse":[0.1236,0.0658,0.1067,0.0496]},{"slug":"delaunay-flips","title":"Delaunay Flips","family":"cells","round":68,"note":"한 모서리에서 편 부채꼴 삼각분할을 로슨의 뒤집기가 외접원 안에 든 점을 하나씩 찾아 풀고, 삼각형마다 가장 작은 각에 따라 자홍 바늘에서 청록 정삼각형으로 바뀌다가 들로네가 되면 빈 외접원 71 개가 한꺼번에 떠요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-delaunay-flips","type":"code","name":"delaunay-flips","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Circles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Points","min":30,"max":90},{"name":"Circles","min":0,"max":1}],"start":[0,2,30,0.06],"measures":{"motion":0.3457,"detail":0.0664,"edges":0.3927,"complexity":1.6784,"coverage":0.8257,"colour":0.1971,"drift":0.1621},"knobResponse":[0.1868,0.0737,0.1711,0.1725]},{"slug":"diffusion-front","title":"Diffusion Front","family":"fractal","round":50,"note":"바닥에서 퍼져 오르는 염료의 농도만큼 칸이 차고, 바닥에 이어진 덩어리의 금빛 프랙탈 앞줄이 스미기 문턱 0.5927 의 자리를 따라 √t 로 올라갔다가 바닥이 닫히면 가라앉아요. K3 은 칸이 난수를 새로 뽑는 빠르기, K4 는 이어지지 않은 섬의 밝기이고, K1 을 누르면 새 격자를 깔아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-diffusion-front","type":"code","name":"diffusion-front","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hop=0..1, Islands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hop","min":0,"max":1},{"name":"Islands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2495,"detail":0.2169,"edges":0.89,"complexity":0.5712,"coverage":0.6223,"colour":0.3344,"drift":0.3892},"knobResponse":[0.3092,0.3138,0.2165,0.1015]},{"slug":"distance-field","title":"Distance Field","family":"type","round":67,"note":"W, S, K, 3, 빛, ? 가 성긴 거리장 격자에서 쌍선형으로 되살아나 테두리와 바깥 빛을 두르고, 텍셀이 커질수록 모서리가 둥글어지고 가는 획이 사라지며 다음 글자로 녹아들어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-distance-field","type":"code","name":"distance-field","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Magnify=-1.5..1.8, Weight=-4..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Magnify","min":-1.5,"max":1.8},{"name":"Weight","min":-4,"max":5}],"start":[0,2,0,0.06],"measures":{"motion":0.4695,"detail":0.0715,"edges":0.2744,"complexity":1.5956,"coverage":0.6893,"colour":0.3778,"drift":0.2994},"knobResponse":[0.225,0.3049,0.214,0.406]},{"slug":"domain-warp","title":"Domain Warp","family":"noise","round":1,"note":"노이즈가 제 자신을 비틀어서 어두운 쪽빛 돌에 금빛 결이 흘러요. 대리석을 붓는 것처럼 천천히 뒤섞여요.","why":"어두운 바탕에 빛나는 결이 흘러가요. A Big Hit, 0524-2 와 같은 쪽이에요.","block":0,"ramped":true,"layer":{"id":"layer-domain-warp","type":"code","name":"domain-warp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#05030f","alpha":1},{"position":0.16,"color":"#0e1450","alpha":1},{"position":0.22,"color":"#2a7ac0","alpha":1},{"position":0.27,"color":"#100c44","alpha":1},{"position":0.5,"color":"#2c1478","alpha":1},{"position":0.62,"color":"#c83888","alpha":1},{"position":0.68,"color":"#ffd890","alpha":1},{"position":0.74,"color":"#ff6a3a","alpha":1},{"position":0.84,"color":"#4a0a3a","alpha":1},{"position":1,"color":"#05030f","alpha":1}],"mode":"oklab","wrap":true},"recolor":false,"knobsAnnotationRaw":"// @knobs Cycle=0..1, Speed=0..5, Warp=1..6, Zoom=0.035..0.095","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Cycle","min":0,"max":1},{"name":"Speed","min":0,"max":5},{"name":"Warp","min":1,"max":6},{"name":"Zoom","min":0.035,"max":0.095}],"start":[0,2,1,0.06],"measures":{"motion":0.2428,"detail":0.0806,"edges":0.2816,"complexity":1.8069,"coverage":0.9604,"colour":0.3247,"drift":0.15},"knobResponse":[0.3352,0.1929,0.1917,0.2107]},{"slug":"domino-run","title":"Domino Run","family":"physics","round":16,"note":"여섯 선반과 나선 계단 다섯을 잇는 도미노 마흔 개를 손끝이 밀면, 물결이 제 물리 빠르기로 내려가고 낮은 램프 빛을 받던 상아색 면이 쓰러지는 대로 어두워져요. 다 쓰러지면 필름이 거꾸로 돌아 줄을 다시 세워요. 줄이 달리는 동안 K1 을 누르면 아직 서 있는 선반 머리에서 두 번째 물결이 떠나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-domino-run","type":"code","name":"domino-run","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.5..4, Spacing=-1..1, Angle=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.5,"max":4},{"name":"Spacing","min":-1,"max":1},{"name":"Angle","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1541,"detail":0.079,"edges":0.5891,"complexity":0.4474,"coverage":0.2699,"colour":0.0868,"drift":0.2609},"knobResponse":[0.2214,0.1713,0.2211,0.2694]},{"slug":"double-gyre","title":"Double Gyre","family":"noise","round":48,"note":"위아래로 쌓인 두 소용돌이 칸 사이의 경계가 출렁이는 동안, 유체가 갈라지는 능선을 앞으로 볼 때는 호박색, 뒤로 볼 때는 하늘색으로 그려서 가는 능선 다발이 두 칸을 감고 가운데로 혀처럼 접히며 반 주기마다 위아래가 뒤집혀요. K3 은 따라가는 시간을, K4 는 경계가 출렁이는 폭을 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-double-gyre","type":"code","name":"double-gyre","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Horizon=-1..1, Epsilon=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Horizon","min":-1,"max":1},{"name":"Epsilon","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.2924,"detail":0.2316,"edges":0.8131,"complexity":1.01,"coverage":0.6619,"colour":0.4307,"drift":0.2617},"knobResponse":[0.2983,0.422,0.5059,0.3811]},{"slug":"doyle-spiral","title":"Doyle Spiral","family":"cells","round":80,"note":"원판마다 여섯 원판과 맞닿은 도일 나선이 패널 가운데의 어두운 극에서 흘러나와 가장자리 밖으로 커지고, 원판이 앉은 나선 팔마다 색이 달라서 원판이 4.2초에 한 칸씩 밖으로 나갈 때마다 다섯 색 팔이 한 팔씩 돌아가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-doyle-spiral","type":"code","name":"doyle-spiral","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Arms=5..10, Poles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Arms","min":5,"max":10},{"name":"Poles","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.4507,"detail":0.1091,"edges":0.9944,"complexity":2.4096,"coverage":0.7853,"colour":0.5586,"drift":0.1604},"knobResponse":[0.4055,0.3257,0.3977,0.4088]},{"slug":"dragon","title":"Dragon Fold","family":"fractal","round":2,"note":"종이띠를 반으로 접기를 열 번 되풀이하면 헤이웨이 드래곤이 돼요. 세대마다 선 전체의 복사본이 끝점을 축으로 90도 돌아 나오고, 다 접히면 거꾸로 닫혀요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-dragon","type":"code","name":"dragon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Fold Speed=0.5..6, Generations=8..10, Dragons=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Fold Speed","min":0.5,"max":6},{"name":"Generations","min":8,"max":10},{"name":"Dragons","min":1,"max":4}],"start":[0,2,8,1],"measures":{"motion":0.7649,"detail":0.0834,"edges":0.9552,"complexity":0.1947,"coverage":0.1168,"colour":0.2214,"drift":0.0797},"knobResponse":[0.0573,0.0725,0.0977,0.1563]},{"slug":"dripstone","title":"Dripstone","family":"mineral","round":19,"note":"석회동굴 단면이 128줄을 다 써요. 종유석 끝에서 물방울이 부풀다 떨어져 석순을 한 방울씩 키우고 웅덩이에 동심원을 그리는 사이, 쇼케이브 조명이 청록과 보라, 흰빛으로 번갈아 바뀌고 동굴 탐험가의 헤드램프가 옆으로 훑고 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-dripstone","type":"code","name":"dripstone","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Age=0..1, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Age","min":0,"max":1},{"name":"Damp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.113,"detail":0.0548,"edges":0.2063,"complexity":2.555,"coverage":0.9702,"colour":0.163,"drift":0.1125},"knobResponse":[0.0618,0.1355,0.0996,0.0869]},{"slug":"drop-tower","title":"Drop Tower","family":"fair","round":18,"note":"밤 놀이공원의 드롭 타워가 128줄을 다 써요. 링에 탄 여덟 사람을 꼭대기까지 끌어올려 매달아 두었다가 탑 높이에 맞춘 중력으로 떨어뜨리고, 자석 브레이크에서 번쩍이며 세워요. K1 을 누르면 오르는 중에도 바로 떨어뜨려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-drop-tower","type":"code","name":"drop-tower","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lights=0..1, Speed=0.2..3, Height=50..110, Thrill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lights","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Height","min":50,"max":110},{"name":"Thrill","min":0,"max":1}],"start":[0,2,50,0.06],"measures":{"motion":0.437,"detail":0.0668,"edges":0.5494,"complexity":1.5352,"coverage":0.8276,"colour":0.1705,"drift":0.1633},"knobResponse":[0.0483,0.0875,0.0709,0.0567]},{"slug":"drying-mud","title":"Drying Mud","family":"cells","round":16,"note":"젖은 흙이 마르며 금이 직각으로 갈라져 T 자로 만나고, 오래된 금은 넓고 깊어지며 조각 테두리가 밝게 말려 올라가요. K1 을 누르면 소나기가 와서 금이 물에 잠겨 닫히고 흙이 다시 말라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-drying-mud","type":"code","name":"drying-mud","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Clay=0..1, Sun=0.3..3, Cracks=0..1, Curl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Clay","min":0,"max":1},{"name":"Sun","min":0.3,"max":3},{"name":"Cracks","min":0,"max":1},{"name":"Curl","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0652,"detail":0.0775,"edges":0.2652,"complexity":2.4007,"coverage":0.991,"colour":0.1598,"drift":0.1523},"knobResponse":[0.1914,0.2254,0.1497,0.0607]},{"slug":"dupin-cyclide","title":"Dupin Cyclide","family":"geometry","round":67,"note":"위에서 도는 원환면을 아래의 구면 반전으로 뒤집은 뒤팽 사이클라이드가 같이 돌고, 원환면의 원 28 개가 상에서도 모두 원으로 남아 청록과 장미색 곡률선 두 무리를 이뤄요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-dupin-cyclide","type":"code","name":"dupin-cyclide","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..2, Distance=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":2},{"name":"Distance","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5408,"detail":0.0518,"edges":0.2837,"complexity":1.1224,"coverage":0.3055,"colour":0.0954,"drift":0.0765},"knobResponse":[0.0389,0.0843,0.0716,0.0475]},{"slug":"durer-alphabet","title":"Dürer's Alphabet","family":"type","round":73,"note":"위아래 두 정사각형에서 번갈아 펜이 획 가장자리를 자로 긋고 둥근 획과 세리프 받침을 컴퍼스로 돌리면, 상아빛 잉크가 로마 대문자의 몸을 채우고 둘레의 종이가 밝아져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-durer-alphabet","type":"code","name":"durer-alphabet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Letter=0..12, Stem=0.1..0.2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Letter","min":0,"max":12},{"name":"Stem","min":0.1,"max":0.2}],"start":[0,2,0,0.1],"measures":{"motion":0.0484,"detail":0.0669,"edges":0.4795,"complexity":0.9934,"coverage":0.6454,"colour":0.1303,"drift":0.2473},"knobResponse":[0.0709,0.0457,0.1421,0.0759]},{"slug":"durer-unfolding","title":"Dürer's Unfolding","family":"space","round":49,"note":"판화처럼 빗금 친 입체가 펼친 그물로 패널에 섰다가 경첩마다 접혀 닫히고, 어둠 속에서 돌다 점으로 사라지면 다음 입체가 돌며 겹치지 않는 새 그물로 펼쳐져요. K3 은 정육면체부터 육팔면체까지 여섯 입체 가운데 처음 것을, K4 는 입체마다 골라 둔 그물 여덟 가운데 하나를 골라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-durer-unfolding","type":"code","name":"durer-unfolding","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Solid=0..5, Tree=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Solid","min":0,"max":5},{"name":"Tree","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0998,"detail":0.1127,"edges":0.9887,"complexity":0.0934,"coverage":0.3291,"colour":0.2802,"drift":0.3649},"knobResponse":[0.2193,0.1359,0.2556,0.2327]},{"slug":"dust-motes","title":"Dust Motes","family":"particle","round":19,"note":"어두운 방, 높은 창에서 내려온 햇살 한 줄기 안에서만 먼지가 반짝이며 떠돌고, 커튼이 흔들리면 빛줄기가 좁아졌다 넓어져요. K1 을 누르면 사람이 방을 가로질러 빛줄기에 그림자를 내고, 발치에서 먼지가 빛 속으로 피어올라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-dust-motes","type":"code","name":"dust-motes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sun=0..1, Speed=0.2..3, Dust=1..4, Draft=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sun","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dust","min":1,"max":4},{"name":"Draft","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0301,"detail":0.0213,"edges":0.2348,"complexity":0.703,"coverage":0.3211,"colour":0.0688,"drift":0.0337},"knobResponse":[0.0562,0.0401,0.0354,0.0362]},{"slug":"dyson-gas","title":"Dyson Gas","family":"particle","round":29,"note":"고유값 열 개가 맨 위 줄에 구슬로 떨며 서로 밀어내고, 그 지나온 길이 실이 되어 아래로 흘러요. 실은 가운데에 빽빽하고 가장자리로 갈수록 성기며 서로 건너지 않아요. K3 은 행렬 크기(10~28)이고, K1 을 누르면 밀어내는 힘이 3초쯤 꺼져 실이 엉키며 건너요.","why":"선이 LED 한 알 굵기예요.","block":1,"ramped":false,"layer":{"id":"layer-dyson-gas","type":"code","name":"dyson-gas","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Count=10..28, Beta=1..9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Count","min":10,"max":28},{"name":"Beta","min":1,"max":9}],"start":[0,2,10,1],"measures":{"motion":1.3286,"detail":0.1297,"edges":0.5413,"complexity":1.7541,"coverage":0.3748,"colour":0.2639,"drift":0.1193},"knobResponse":[0.1261,0.1507,0.2251,0.1306]},{"slug":"ehrenfest-urn","title":"Ehrenfest Urn","family":"particle","round":73,"note":"위아래로 쌓은 두 방의 공 N 개 가운데 하나가 걸음마다 좁은 목을 지나 건너가고, 아래 띠가 위 방의 공 수가 N 에서 N/2 로 내려와 이항분포의 폭 안에서 떠도는 것을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ehrenfest-urn","type":"code","name":"ehrenfest-urn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Balls=8..200, Watch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Balls","min":8,"max":200},{"name":"Watch","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.5689,"detail":0.0432,"edges":0.5521,"complexity":0.4509,"coverage":0.1971,"colour":0.1609,"drift":0.098},"knobResponse":[0.0418,0.0617,0.1227,0.0789]},{"slug":"eight-principles-of-yong","title":"Eight Principles of Yong","family":"type","round":70,"note":"붓이 패널 높이의 永 을 다섯 획 차례로 쓰는 동안 여덟 필법의 이름이 그 획 옆에 주홍으로 켜지고, 다 쓰면 여덟이 차례로 제 획과 함께 빛나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eight-principles-of-yong","type":"code","name":"eight-principles-of-yong","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Brush=-1..1, Ink=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Brush","min":-1,"max":1},{"name":"Ink","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0425,"detail":0.0837,"edges":0.5269,"complexity":1.1359,"coverage":0.9999,"colour":0.263,"drift":0.0973},"knobResponse":[0.1386,0.0726,0.0645,0.0579]},{"slug":"ekg-sequence","title":"EKG Sequence","family":"data","round":79,"note":"EKG 수열을 한 항에 한 줄씩 써 내려가며 값을 가로로 찍어요. 항은 대개 a = n 곁에 붙고, 홀수 소수 p 마다 2p, p, 3p 가 n/2 와 3n/2 의 흐린 안내선까지 뻗는 획이 되어 왼쪽에 금빛으로 그 소수가 적혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ekg-sequence","type":"code","name":"ekg-sequence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zoom=1..4, Links=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zoom","min":1,"max":4},{"name":"Links","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.1069,"detail":0.1017,"edges":0.9956,"complexity":0.1174,"coverage":0.1385,"colour":0.2607,"drift":0.0703},"knobResponse":[0.0886,0.0878,0.1179,0.0441]},{"slug":"elastica","title":"Euler's Elastica","family":"physics","round":53,"note":"양 끝이 핀에 걸린 120 LED 짜리 가는 막대가 천천히 눌렸다 풀리며 오일러의 탄성 곡선 가족을 다 지나가요. 살짝 휜 활에서 아치와 직각 엘라스티카를 지나, 두 끝이 만나는 물방울과 끝이 서로 지나치는 고리까지 가요. 위의 진자는 막대를 달리는 구슬 자리의 막대와 늘 나란히 흔들리고, 아래에서는 그 진자의 궤도가 상평면을 돌아요. K3 은 반파 수 1~4 이고, K4 는 풀 때 어디까지 돌아오는지예요. 단추를 누르면 하중이 멈춰 한 모양이 서 있어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-elastica","type":"code","name":"elastica","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=1..4, Preload=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":1,"max":4},{"name":"Preload","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3145,"detail":0.0384,"edges":0.3274,"complexity":0.4646,"coverage":0.1716,"colour":0.1706,"drift":0.1169},"knobResponse":[0.0447,0.0924,0.0801,0.0827]},{"slug":"elephant-toothpaste","title":"Elephant Toothpaste","family":"chemistry","round":23,"note":"보라색 장갑을 낀 손이 실험대 위 눈금실린더에 아이오딘화 칼륨을 부으면, 유리 안쪽에 그어 둔 식용 색소 줄무늬를 두른 거품 기둥이 입구에서 솟아 패널 꼭대기까지 올라요. 기둥은 한쪽으로 꺾여 실린더 옆을 타고 흘러내려 김 나는 더미로 쌓이고, 더미가 굳어 바래면 손이 닦아 내고 새 실린더를 내려놓아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-elephant-toothpaste","type":"code","name":"elephant-toothpaste","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dye=0..1, Speed=0.2..3, Stripes=1..4, Strength=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dye","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stripes","min":1,"max":4},{"name":"Strength","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1815,"detail":0.029,"edges":0.1765,"complexity":0.9251,"coverage":0.367,"colour":0.1801,"drift":0.102},"knobResponse":[0.0441,0.1137,0.0453,0.0773]},{"slug":"elliptic-chords","title":"Elliptic Chords","family":"number","round":36,"note":"위에는 실수 곡선 y² = x³ − 6x 가, 아래에는 같은 곡선을 61 로 나눈 나머지로 푼 61×61 판이 있어요. G 와 kG 를 지나는 직선이 곡선과 세 번째로 만나는 점을 x축에 뒤집으면 (k+1)G 이고, 아래에서는 그 직선이 판을 감아 도는 점 61개가 되어 곡선의 점 셋에서만 하얗게 빛나며 배수들이 방문 순서대로 무지개색으로 켜져요. K3 은 상수 b 를 바꿔 알 모양 고리를 키우다 긴 가지에 붙이고, K1 을 누르면 새 생성원 G 로 O 에서 다시 세요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-elliptic-chords","type":"code","name":"elliptic-chords","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Curve=-4..8, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Curve","min":-4,"max":8},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0496,"detail":0.0598,"edges":0.5832,"complexity":0.5264,"coverage":0.6226,"colour":0.1255,"drift":0.0238},"knobResponse":[0.0592,0.0309,0.1041,0.0281]},{"slug":"elliptic-law","title":"Elliptic Law","family":"particle","round":56,"note":"세로로 선 타원 안에서 무작위 실수 행렬의 고윳값이 짧은 꼬리를 끌며 떠다니고, 가운데 실수축에서 거울 짝이 만나면 두 실수 고윳값으로 갈라져 축을 따라 달아나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-elliptic-law","type":"code","name":"elliptic-law","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tau=0.333..1, Size=40..80","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tau","min":0.333,"max":1},{"name":"Size","min":40,"max":80}],"start":[0,2,0.333,40],"measures":{"motion":0.2405,"detail":0.0808,"edges":0.4129,"complexity":1.1148,"coverage":0.3169,"colour":0.1472,"drift":0.0656},"knobResponse":[0.0525,0.0819,0.0956,0.1404]},{"slug":"embossed-glow","title":"Embossed Glow","family":"cosmetic","round":37,"note":"엠보싱한 하이라이터의 눌린 면이 패널을 채우고, 떠도는 작은 램프를 향한 비탈이 부드러운 띠로 빛나요. 반짝이 알갱이는 면이 램프 쪽으로 7도 안에 설 때만 빛나서 반짝임이 능선을 타고 옮겨 가요. 6.5초마다 보이지 않는 손끝이 홈을 쓸어 엠보싱을 새틴 띠로 눌러 펴고, 네 번 쓸면 판이 다시 눌려요. K3 은 물결과 퀼팅 마름모, 갈매기, 비늘 무늬를 고르고, 누르면 판을 바로 다시 눌러요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-embossed-glow","type":"code","name":"embossed-glow","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Relief=0..3, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Relief","min":0,"max":3},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0374,"detail":0.0733,"edges":0.2266,"complexity":2.4899,"coverage":1,"colour":0.1712,"drift":0.1081},"knobResponse":[0.3063,0.0963,0.1554,0.2659]},{"slug":"emergence","title":"Emergence","family":"mammal","round":24,"note":"해 질 녘 메마른 언덕의 동굴 입구에서 박쥐 떼가 검은 리본처럼 쏟아져 나와, 노을 하늘을 비틀며 패널 꼭대기까지 기둥으로 올라가요. 기둥은 두 가닥으로 갈라졌다 다시 붙고, 매가 내리꽂히면 박쥐들이 고리처럼 물러났다가 구멍이 닫혀요. K1 을 끝까지 돌리면 밤이 되어 박쥐가 보름달 앞을 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-emergence","type":"code","name":"emergence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Bats=400..1400, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":400,"max":1400},{"name":"Wind","min":-1,"max":1}],"start":[0,2,400,0.06],"measures":{"motion":1.359,"detail":0.0665,"edges":0.4877,"complexity":1.5604,"coverage":0.9427,"colour":0.3555,"drift":0.0712},"knobResponse":[0.2525,0.0481,0.0669,0.0629]},{"slug":"erdos-discrepancy","title":"Erdős Discrepancy","family":"rhythm","round":56,"note":"64개 열이 같은 리듬을 d 박마다 하나씩 듣고 그 합을 한 줄씩 써 내려가요. 곱셈적 리듬은 청록과 자홍의 차분한 타탄을 짜고 기록이 깨지는 걸음마다 한 줄이 통째로 하얘지며, 동전 던지기 박이 섞이면 시끄러운 세로 줄로 찢어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-erdos-discrepancy","type":"code","name":"erdos-discrepancy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Prime=3..13","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":0,"max":1},{"name":"Prime","min":3,"max":13}],"start":[0,2,0,3],"measures":{"motion":1.4087,"detail":0.0873,"edges":0.5343,"complexity":0.2701,"coverage":0.9126,"colour":0.4077,"drift":0.1626},"knobResponse":[0.2476,0.1533,0.3359,0.3111]},{"slug":"eruption","title":"Eruption","family":"volcano","round":25,"note":"해 질 녘 성층화산을 세로로 잘라 봐요. 아래 마그마 방에서 떠난 가스 덩어리가 황토와 잿빛 지층 사이 화도를 타고 올라 분화구에서 터지면, 화산탄이 포물선을 그리며 떨어지고 재 기둥은 패널 꼭대기까지 올라 번개를 품어요. K1 이 스트롬볼리식에서 하와이식 용암 분수를 지나 플리니식 재 기둥까지 분출을 바꾸고, K1 을 누르면 큰 폭발이 나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-eruption","type":"code","name":"eruption","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Style=0..1, Speed=0.2..3, Pressure=0..1, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Style","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pressure","min":0,"max":1},{"name":"Wind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3557,"detail":0.0525,"edges":0.231,"complexity":2.1856,"coverage":1,"colour":0.2971,"drift":0.0844},"knobResponse":[0.082,0.0543,0.0923,0.0549]},{"slug":"essence-drop","title":"Essence Drop","family":"cosmetic","round":33,"note":"맑은 물빛 에센스에 짙은 색 방울이 느린 화면으로 떨어져 손가락 아홉 개의 왕관을 세우고, 파인 자리가 닫히며 솟은 기둥 끝에서 구슬이 떨어져 나가요. 방울의 짙은 색은 소용돌이 고리로 말려 가라앉으며 웅덩이에 풀려요. K3 을 올리면 왕관과 구슬이 사라지고 젤처럼 무겁게 잠기며, K1 은 색상환을 다 돌고 누르면 방울이 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-essence-drop","type":"code","name":"essence-drop","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Viscosity=0..1, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Viscosity","min":0,"max":1},{"name":"Size","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0508,"detail":0.0106,"edges":0.2549,"complexity":1.4637,"coverage":1,"colour":0.1457,"drift":0.0297},"knobResponse":[0.2403,0.0329,0.0375,0.0322]},{"slug":"etaoin-shrdlu","title":"Etaoin Shrdlu","family":"data","round":66,"note":"앨리스 첫 두 문장이 한 자씩 떨어져 잦은 차례로 줄 선 막대 열여섯 개에 쌓이고, 다 읽으면 이름표가 ETIONS AHRDWG 가 되어 라이노타이프 자판의 ETAOIN SHRDLU 와 여섯 자리가 맞아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-etaoin-shrdlu","type":"code","name":"etaoin-shrdlu","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Forget=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Forget","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5391,"detail":0.1494,"edges":0.9947,"complexity":0.1546,"coverage":0.3122,"colour":0.2867,"drift":0.0582},"knobResponse":[0.1006,0.088,0.1243,0.1]},{"slug":"euclid-pulse","title":"Euclid Pulse","family":"rhythm","round":1,"note":"유클리드 리듬 셋이 고리 셋에서 함께 돌아요. 바깥 두 고리의 박은 고리 밖 제 조각을 따라 빛으로 퍼져서 세운 패널의 위아래 끝까지 닿아요. 처음은 E(3,8) 이에요.","why":"리듬은 좋은데 그림이 작고 어두워요.","block":1,"ramped":false,"layer":{"id":"layer-euclid-pulse","type":"code","name":"euclid-pulse","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=80..180, Pulses=3..13, Steps=8..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":80,"max":180},{"name":"Pulses","min":3,"max":13},{"name":"Steps","min":8,"max":16}],"start":[0,80,3,8],"measures":{"motion":0.5845,"detail":0.0325,"edges":0.366,"complexity":0.4817,"coverage":0.4069,"colour":0.1498,"drift":0.1272},"knobResponse":[0.0702,0.0945,0.0699,0.0495]},{"slug":"euler-strokes","title":"Euler Strokes","family":"type","round":75,"note":"펜이 세로로 쌓은 낱말을 오일러가 센 가장 적은 획 수로 히어홀처의 길을 따라 쓰고, 홀수 꼭짓점이 펜보다 먼저 빛나며 글자마다 획 수가 숫자와 점으로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-euler-strokes","type":"code","name":"euler-strokes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Order=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Order","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0655,"detail":0.0437,"edges":0.4034,"complexity":0.6379,"coverage":0.2926,"colour":0.1378,"drift":0.0723},"knobResponse":[0.0459,0.0418,0.158,0.0479]},{"slug":"eulers-officers","title":"Euler's Officers","family":"cells","round":60,"note":"위에는 오일러의 36 장교를 세운 6 × 6 의 가장 나은 시도가, 아래에는 100쌍이 한 번씩 서는 10 × 10 그레코-라틴 방진이 있고, 칸마다 바깥 고리가 계급 색, 안쪽 심이 연대 색이에요. 연대가 1.5초마다 하나씩 밝아져 줄과 칸과 계급을 한 번씩 지나는 가로지르기를 보여 주고, 위 방진에서 두 쌍이 겹친 네 칸은 하얗게 맥박쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eulers-officers","type":"code","name":"eulers-officers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Core=-1..1, Shuffle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Core","min":-1,"max":1},{"name":"Shuffle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.036,"detail":0.1723,"edges":0.9888,"complexity":0.1476,"coverage":0.7056,"colour":0.6253,"drift":0.0407},"knobResponse":[0.4368,0.0498,0.2438,0.1746]},{"slug":"excavation","title":"Excavation","family":"construction","round":25,"note":"도심 빌딩 사이의 깊은 터파기를 세로로 잘라 봐요. 굴착기가 바닥에 쌓은 흙을 갠트리의 클램셸이 100줄 위 덤프트럭까지 끌어올리고, 바닥이 한 단 깊어지면 흙막이 벽 사이에 강철 버팀보가 한 단 더 용접돼 걸려요. K1 을 돌리면 데크 틈으로 떨어지던 햇빛 기둥이 기울다가 밤의 나트륨등으로 바뀌고, 누르면 경고등 뒤에 발파가 일어나 바닥에 먼지가 차요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-excavation","type":"code","name":"excavation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Depth=8..10, Water=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":8,"max":10},{"name":"Water","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.0546,"detail":0.0796,"edges":0.3258,"complexity":1.9604,"coverage":0.986,"colour":0.2478,"drift":0.0543},"knobResponse":[0.2505,0.0522,0.0454,0.0762]},{"slug":"exclusion-process","title":"Exclusion Process","family":"particle","round":82,"note":"64칸 줄에 왼쪽으로 들어온 입자가 앞 칸이 빌 때만 오른쪽으로 한 칸씩 뛰는 것을 가장 새 줄이 위에 오는 시공간 그림으로 쌓아서 입자마다 제 색 실이 남고, 처음 노브에서는 성긴 흐름과 막힌 줄 사이의 경계가 이리저리 떠돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-exclusion-process","type":"code","name":"exclusion-process","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Alpha=0.25..1, Beta=0.25..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Alpha","min":0.25,"max":1},{"name":"Beta","min":0.25,"max":1}],"start":[0,2,0.25,0.25],"measures":{"motion":2.8227,"detail":0.216,"edges":1,"complexity":1.6671,"coverage":0.6251,"colour":0.4383,"drift":0.1553},"knobResponse":[0.2918,0.2685,0.244,0.268]},{"slug":"excursion-sets","title":"Excursion Sets","family":"noise","round":63,"note":"오르내리는 수준으로 자른 가우스 장이 섬과 호수로 갈라지고, 섬은 분홍 테두리로, 호수는 파랑으로 칠해져요. 아래 띠에 섬 수 빼기 호수 수인 오일러 지표가 점으로 찍혀 애들러의 이론 곡선을 따라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-excursion-sets","type":"code","name":"excursion-sets","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=3..8, Level=-1.5..1.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":3,"max":8},{"name":"Level","min":-1.5,"max":1.5}],"start":[0,2,3,0.06],"measures":{"motion":0.2095,"detail":0.077,"edges":0.8873,"complexity":0.1914,"coverage":0.5179,"colour":0.205,"drift":0.1795},"knobResponse":[0.0473,0.0968,0.0829,0.2034]},{"slug":"explicit-formula","title":"Explicit Formula","family":"number","round":39,"note":"소수 거듭제곱마다 log p 씩 뛰는 계단 ψ(x) 를 제타 함수의 영점으로 다시 지어요. x 가 아래로, ψ 가 옆으로 가고, 영점이 한 쌍씩 더해질 때마다 매끈한 선 x 에 물결이 붙다가 계단으로 날카로워지고, 제자리를 찾은 계단 띠부터 켜져요. 오른쪽 끝 세 열이 임계선이라 더해진 영점이 제 높이에서 켜져요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-explicit-formula","type":"code","name":"explicit-formula","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Reach=24..144, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Reach","min":24,"max":144},{"name":"Tilt","min":0,"max":1}],"start":[0,2,24,0.06],"measures":{"motion":0.0929,"detail":0.028,"edges":0.4504,"complexity":0.7997,"coverage":0.9982,"colour":0.172,"drift":0.1028},"knobResponse":[0.141,0.0429,0.064,0.081]},{"slug":"eye-chart","title":"Eye Chart","family":"type","round":74,"note":"뒤에서 비춘 시력표의 슬론 글자 여덟 줄이 렌즈가 바뀔 때마다 흐려졌다 맑아지고, 지시봉이 글자를 하나씩 읽다가 더는 못 읽는 줄에서 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eye-chart","type":"code","name":"eye-chart","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Error=0.5..2.5, Speed=0.2..3, Glare=0..1, Duochrome=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Error","min":0.5,"max":2.5},{"name":"Speed","min":0.2,"max":3},{"name":"Glare","min":0,"max":1},{"name":"Duochrome","min":0,"max":1}],"start":[0.5,2,0,0.06],"measures":{"motion":0.0665,"detail":0.0498,"edges":0.2212,"complexity":1.6593,"coverage":0.9578,"colour":0.112,"drift":0.036},"knobResponse":[0.1018,0.2333,0.0999,0.3162]},{"slug":"eyes-in-the-dark","title":"Eyes in the Dark","family":"halloween","round":41,"note":"까만 패널에 고양이의 연두 눈, 부엉이의 둥근 주황 눈, 노려보는 빨간 눈, 거미의 여덟 눈이 떠서 떠도는 도깨비불을 눈동자로 따라가요. 눈은 깜빡이며 어슬렁거리다 0.7초 만에 다른 자리로 미끄러지고, 감았다가 다른 곳에서 다시 떠요. K3 은 눈 무리를 5 에서 9 까지 늘리고 K4 는 깜빡임과 튀는 몸짓을 잦게 하며, K1 을 누르면 모든 눈이 한꺼번에 떠서 2.5초 동안 가운데를 노려봐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eyes-in-the-dark","type":"code","name":"eyes-in-the-dark","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Shift=0..1, Speed=0.2..3, Pairs=5..9, Jumpy=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Shift","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pairs","min":5,"max":9},{"name":"Jumpy","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.3566,"detail":0.0262,"edges":0.2761,"complexity":0.5807,"coverage":0.1982,"colour":0.1282,"drift":0.1318},"knobResponse":[0.0445,0.0776,0.0581,0.0608]},{"slug":"ferris-wheel","title":"Ferris Wheel","family":"fair","round":25,"note":"밤 호숫가에서 지름 59 LED 의 관람차가 돌고, 곤돌라는 바퀴가 돌아도 늘 똑바로 매달려 있어요. 살과 테두리의 불빛이 쇼 여섯 가지를 6.5초씩 이어 가고, 호수가 바퀴와 불빛을 일렁이며 비춰요. K4 Wind 를 올리면 구름이 몰려오고 물그림자가 긴 빛줄기로 부서지며, 버튼은 다음 쇼로 넘겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-ferris-wheel","type":"code","name":"ferris-wheel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lights=0..1, Speed=0.2..3, Spokes=12..32, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lights","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spokes","min":12,"max":32},{"name":"Wind","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.2782,"detail":0.0637,"edges":0.3285,"complexity":1.8086,"coverage":0.9981,"colour":0.1705,"drift":0.1001},"knobResponse":[0.0444,0.0524,0.0479,0.0788]},{"slug":"ferrow","title":"Ferrow","family":"pixel","round":86,"note":"무너진 성채의 문을 이백 년째 지키는 파수 로봇이 받침 위에 한 손은 허리에 얹고, 홈이 호박색으로 달아오른 대검을 어깨에 멘 채 숨 쉬고 눈 덮개를 깜빡여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ferrow","type":"code","name":"ferrow","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gel","min":0,"max":1},{"name":"Stand","min":0,"max":3},{"name":"Detail","min":0,"max":1},{"name":"Edition","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0311,"detail":0.068,"edges":0.7411,"complexity":0.1739,"coverage":0.4925,"colour":0.1452,"drift":0.0113},"knobResponse":[0.0148,0.0224,0.3301,0.0823]},{"slug":"feynman-checkerboard","title":"Feynman Checkerboard","family":"wave","round":62,"note":"시간이 아래로, 공간이 가로로 놓인 빛 원뿔 격자에서 모퉁이마다 진폭에 iε 를 곱하는 지그재그 길 넷이 원천에서 떨어지며 모퉁이에 i^R 의 네 색 점을 찍어요. 그 밑에는 모든 길을 더한 장이 위상은 색, 크기는 밝기로 빛나고, 금빛 평균 위치가 지터베베궁으로 좌우로 떨려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-feynman-checkerboard","type":"code","name":"feynman-checkerboard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mass=0.08..0.4, Focus=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mass","min":0.08,"max":0.4},{"name":"Focus","min":0,"max":1}],"start":[0,2,0.08,0.06],"measures":{"motion":0.1065,"detail":0.0504,"edges":0.6165,"complexity":2.4819,"coverage":0.9591,"colour":0.2856,"drift":0.1064},"knobResponse":[0.2331,0.0766,0.181,0.1347]},{"slug":"fibonacci-word","title":"Fibonacci Word","family":"fractal","round":68,"note":"피보나치 단어 0100101001001… 을 한 자씩 읽는 펜이 0 마다 직각으로 꺾어, 희미한 띠에 놓인 굵은 곡선 위에 정사각형 속 정사각형 곡선을 그리고, 첫 토막으로 1+√2 배 들어가면 그 토막이 다시 전체가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fibonacci-word","type":"code","name":"fibonacci-word","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=12..15, Angle=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":12,"max":15},{"name":"Angle","min":-1,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.5413,"detail":0.0567,"edges":0.8662,"complexity":0.2611,"coverage":0.2103,"colour":0.167,"drift":0.0933},"knobResponse":[0.0611,0.0519,0.121,0.1242]},{"slug":"fiddlehead","title":"Fiddlehead","family":"growth","round":21,"note":"봄 숲 바닥의 타임랩스예요. 털 덮인 고사리 순이 지난해 낙엽을 뚫고 올라와 아래부터 풀리며 패널 꼭대기에서 휘는 잎이 되고, 그사이 늙은 잎은 누렇게 시들어 쓰러지고 숲 지붕 틈으로 든 빛살이 그 위를 미끄러져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-fiddlehead","type":"code","name":"fiddlehead","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fern=0..3, Speed=0.2..3, Fronds=6..18, Breeze=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fern","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Fronds","min":6,"max":18},{"name":"Breeze","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2772,"detail":0.0937,"edges":0.4428,"complexity":2.2973,"coverage":0.9858,"colour":0.1938,"drift":0.0784},"knobResponse":[0.0694,0.0969,0.0478,0.0882]},{"slug":"fifteen-puzzle","title":"Fifteen Puzzle","family":"type","round":77,"note":"위아래 두 15 퍼즐이 같은 밀기를 같은 순간에 받아, 위 판은 1~15 로 풀리고 14 와 15 를 바꿔 놓고 시작한 아래 판은 15, 14 에서 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fifteen-puzzle","type":"code","name":"fifteen-puzzle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scramble=0..1, Swap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scramble","min":0,"max":1},{"name":"Swap","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3613,"detail":0.1135,"edges":0.85,"complexity":0.0988,"coverage":0.7033,"colour":0.2261,"drift":0.1417},"knobResponse":[0.2027,0.1237,0.1712,0.0532]},{"slug":"figure-eight-orbit","title":"Figure-Eight Orbit","family":"physics","round":38,"note":"같은 질량 셋이 뉴턴 중력으로 패널 높이만 한 8자 하나를 3분의 1주기씩 떨어져 돌아요. 식으로 그린 곡선이 아니라 한 걸음씩 푼 궤도라서, K4 로 처음 속도를 밀면 8자가 흔들리다가 더 밀면 둘이 짝을 짓고 하나가 패널 밖으로 튕겨 나가요. K3 은 꼬리를 늘려 세 혜성을 겹친 8자 띠로 바꾸고, K1 을 누르면 도는 궤도를 살짝 밀어요.","why":"빛나는 공 셋이 8자 궤도를 돌아요. 0529, 0701 처럼 선 하나와 점 몇 개가 전부예요.","block":0,"ramped":false,"layer":{"id":"layer-figure-eight-orbit","type":"code","name":"figure-eight-orbit","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Trail=0.33..2, Kick=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Trail","min":0.33,"max":2},{"name":"Kick","min":0,"max":1}],"start":[0,2,0.33,0.06],"measures":{"motion":0.2677,"detail":0.0329,"edges":0.6811,"complexity":0.5694,"coverage":0.1522,"colour":0.2009,"drift":0.1349},"knobResponse":[0.0772,0.0891,0.0607,0.1032]},{"slug":"final-approach","title":"Final Approach","family":"flight","round":23,"note":"밤에 내려앉는 여객기 조종석에서 앞을 봐요. 활주로 등과 진입등이 도시 불빛이 깔린 지평선 아래로 모이고, 래빗 섬광등이 1초에 두 번 활주로 쪽으로 달려가요. 왼쪽 PAPI 가 흰 둘 빨강 둘을 보이다가, 플레어와 접지 뒤에는 중심선 등이 발밑으로 쏟아져 지나가요. K1 을 누르면 복행해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-final-approach","type":"code","name":"final-approach","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Weather=0..3, Crosswind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Weather","min":0,"max":3},{"name":"Crosswind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.2895,"detail":0.0365,"edges":0.3949,"complexity":1.2312,"coverage":0.4908,"colour":0.0984,"drift":0.1085},"knobResponse":[0.0373,0.0632,0.3041,0.0884]},{"slug":"fire","title":"Fire","family":"sim","round":1,"note":"데모신의 불이에요. 바닥의 열이 올라가며 식고, K1 을 돌리면 나무 불에서 가스 불, 붕소 불까지 색이 바뀌어요.","why":"패널에서 잘 읽히지만 불꽃은 데모의 단골이에요.","block":1,"ramped":false,"layer":{"id":"layer-fire","type":"code","name":"fire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Height=0.6..4, Wind=-1..1, Crackle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Height","min":0.6,"max":4},{"name":"Wind","min":-1,"max":1},{"name":"Crackle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9647,"detail":0.0218,"edges":0.1201,"complexity":0.8283,"coverage":0.5059,"colour":0.4964,"drift":0.2161},"knobResponse":[0.3207,0.2786,0.0846,0.0537]},{"slug":"fireflies","title":"Fireflies","family":"insect","round":16,"note":"풀밭 위 반딧불이 200마리가 따로 깜박이다가 서로의 깜박임을 보고 박자를 맞춰, 한꺼번에 깜박이는 무리와 어두운 쉼이 번갈아 와요. K4 가 결합의 세기이고, K1 을 누르면 손전등이 지나가며 박자를 흩어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-fireflies","type":"code","name":"fireflies","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Moon=0..1, Pace=0.5..4, Fireflies=200..480, Coupling=0..0.25","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Moon","min":0,"max":1},{"name":"Pace","min":0.5,"max":4},{"name":"Fireflies","min":200,"max":480},{"name":"Coupling","min":0,"max":0.25}],"start":[0,2,200,0.06],"measures":{"motion":0.3823,"detail":0.021,"edges":0.1814,"complexity":0.404,"coverage":0.3382,"colour":0.0994,"drift":0.0945},"knobResponse":[0.0808,0.0516,0.0623,0.0425]},{"slug":"flag-hoist","title":"Flag Hoist","family":"type","round":74,"note":"국제 신호서의 글자 깃발로 쓴 낱말이 왼쪽 가장자리의 깃줄에 한 장씩 아래로 매달려 밤하늘로 끌려 올라가고, 바람에 펄럭이는 동안 깃발 옆에 그 글자가 섰다가 내려가면 다음 낱말이 올라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-flag-hoist","type":"code","name":"flag-hoist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wind=3..8, Speed=0.2..3, Letters=3..6, Sky=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wind","min":3,"max":8},{"name":"Speed","min":0.2,"max":3},{"name":"Letters","min":3,"max":6},{"name":"Sky","min":0,"max":1}],"start":[3,2,3,0.06],"measures":{"motion":0.4925,"detail":0.0446,"edges":0.5633,"complexity":0.2165,"coverage":0.4929,"colour":0.5773,"drift":0.2045},"knobResponse":[0.0527,0.2307,0.2153,0.1566]},{"slug":"flame-test","title":"Flame Test","family":"chemistry","round":22,"note":"분젠 버너의 파란 불꽃에 손이 니크롬 고리를 넣으면 불꽃이 그 염의 색으로 터져요. 구리는 청록, 나트륨은 짙은 노랑으로 타고 알갱이가 튀다가 파랗게 돌아오면, 고리를 염산에 씻어 이름표 붙은 다음 시계접시로 가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flame-test","type":"code","name":"flame-test","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Salt=0..8, Speed=0.2..3, Room=0..1, Air=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Salt","min":0,"max":8},{"name":"Speed","min":0.2,"max":3},{"name":"Room","min":0,"max":1},{"name":"Air","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0593,"detail":0.0588,"edges":0.4458,"complexity":1.5027,"coverage":0.9519,"colour":0.1298,"drift":0.0434},"knobResponse":[0.0735,0.0457,0.2666,0.1163]},{"slug":"flashing-ratchet","title":"Flashing Ratchet","family":"sim","round":48,"note":"여덟 칸 톱니 퍼텐셜이 켜졌다 꺼질 때마다 브라운 입자 3000개가 빛나는 선으로 모였다 안개로 퍼지고, 금빛 표지 구름이 켜 두기만 해도 꺼 두기만 해도 지는 아래쪽 짐을 거슬러 올라가요. K3 은 꺼졌다 켜지는 주기, K4 는 짐이고, K1 을 누르면 깜빡이기와 켜 두기, 꺼 두기를 차례로 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-flashing-ratchet","type":"code","name":"flashing-ratchet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Period=0.8..3.2, Load=0.25..1.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Period","min":0.8,"max":3.2},{"name":"Load","min":0.25,"max":1.5}],"start":[0,2,0.8,0.25],"measures":{"motion":2.0192,"detail":0.0449,"edges":0.0319,"complexity":1.4118,"coverage":0.9216,"colour":0.1633,"drift":0.1337},"knobResponse":[0.1421,0.1086,0.1193,0.0659]},{"slug":"flip-clock","title":"Flip Clock","family":"time","round":2,"note":"세워 둔 넘김 시계예요. 위에 시, 아래에 분 카드가 있고, 바뀔 때마다 옛 카드의 윗장이 앞으로 넘어가 그 뒷면이 새 카드의 아랫장으로 내려앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flip-clock","type":"code","name":"flip-clock","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Rate=0..3, Seconds=0..1, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Rate","min":0,"max":3},{"name":"Seconds","min":0,"max":1},{"name":"Light","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0975,"detail":0.0443,"edges":0.7774,"complexity":0.213,"coverage":0.7633,"colour":0.1458,"drift":0.128},"knobResponse":[0.0983,0.1045,0.1894,0.032]},{"slug":"flipdot","title":"Flipdot","family":"type","round":22,"note":"버스 앞에 다는 형광 노랑 플립 디스크 행선판을 세워 놓았어요. 위 칸에 노선 번호, 아래 칸에 행선지가 7줄 점 글꼴로 서고, 쪽이 바뀔 때마다 디스크가 한 줄씩 넘어가며 판 전체를 노랗게 뒤집었다가 반전된 경유지 쪽을 써요. 넘어가는 동안의 디스크는 가는 모서리로 보여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flipdot","type":"code","name":"flipdot","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Disc=0..1, Speed=0.2..3, Route=0..3, Wipe=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Disc","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Route","min":0,"max":3},{"name":"Wipe","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1111,"detail":0.2452,"edges":0.47,"complexity":0.3774,"coverage":0.3252,"colour":0.3924,"drift":0.2652},"knobResponse":[0.0968,0.1699,0.0516,0.048]},{"slug":"floating-letters","title":"Floating Letters","family":"type","round":78,"note":"한 판에서 오린 글자가 물에 떨어져 출렁이다가 저마다 무게 중심과 부력 중심이 한 줄에 서는 각에 앉고, 위의 곡선에서 점이 에너지 골짜기로 굴러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-floating-letters","type":"code","name":"floating-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=0.2..0.8, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":0.2,"max":0.8},{"name":"Swell","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.0511,"detail":0.0365,"edges":0.7713,"complexity":0.25,"coverage":0.5905,"colour":0.1882,"drift":0.0253},"knobResponse":[0.1028,0.0652,0.0626,0.0425]},{"slug":"flock","title":"Flock","family":"particle","round":1,"note":"새 90마리가 가까운 이웃만 보고 날아요. 보이지 않는 매가 무리를 쫓아 자꾸 갈라놓아요.","why":"새 떼가 점 크기라 멀리서 안 보여요.","block":1,"ramped":false,"layer":{"id":"layer-flock","type":"code","name":"flock","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.5..4, Scatter=-1..1, Trail=0.3..2.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.5,"max":4},{"name":"Scatter","min":-1,"max":1},{"name":"Trail","min":0.3,"max":2.5}],"start":[0,2,0,0.3],"measures":{"motion":0.7954,"detail":0.0794,"edges":0.4039,"complexity":1.2562,"coverage":0.2957,"colour":0.1808,"drift":0.1151},"knobResponse":[0.0754,0.1076,0.0932,0.1053]},{"slug":"fluoroscope","title":"Fluoroscope","family":"body","round":27,"note":"형광 투시 화면의 어두운 판 위에서 해골이 러닝머신을 옆모습으로 걸어요. 정수리에서 발가락까지 128줄을 다 쓰고, 먼 쪽 다리와 팔은 흐리며 움직이는 뼈 뒤에 인광이 잠깐 남아요. K3 은 걸음을 두 발이 뜨는 달리기로 바꾸고, 누르면 돌아서서 앞모습으로 손을 흔들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-fluoroscope","type":"code","name":"fluoroscope","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Screen=0..1, Speed=0.2..3, Gait=0..1, Dose=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Screen","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gait","min":0,"max":1},{"name":"Dose","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.988,"detail":0.0374,"edges":0.3589,"complexity":1.506,"coverage":0.2562,"colour":0.1011,"drift":0.06},"knobResponse":[0.0534,0.0544,0.0908,0.0578]},{"slug":"flying-trapeze","title":"Flying Trapeze","family":"stage","round":24,"note":"밤의 서커스 천막 꼭대기를 올려다봐요. 빨강과 크림 줄무늬 천 아래에서 플라이어가 공중그네를 타고 나가 공중제비를 돌고, 무릎으로 매달린 캐처가 손을 잡아요. 팔로 스폿 셋이 연무 속에 빛줄기를 그으며 따라가고, 차례가 끝나면 그물로 떨어져 튀어 올라요. K1 을 누르면 북이 울리고 세 바퀴 공중제비가 나와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flying-trapeze","type":"code","name":"flying-trapeze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lights=0..1, Speed=0.2..3, Turns=1..3, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lights","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":1,"max":3},{"name":"Haze","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3174,"detail":0.0396,"edges":0.2107,"complexity":1.4663,"coverage":0.506,"colour":0.1821,"drift":0.1332},"knobResponse":[0.0514,0.1017,0.0609,0.161]},{"slug":"foam-coarsening","title":"Foam Coarsening","family":"cells","round":65,"note":"2차원 거품이 굵어지며 여섯 변보다 적은 칸은 줄어 사라지고 많은 칸은 자라요. 칸을 변의 수로 칠해서 폰 노이만의 n − 6 법칙이 색으로 보여요","why":"","block":0,"ramped":false,"layer":{"id":"layer-foam-coarsening","type":"code","name":"foam-coarsening","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3552,"detail":0.343,"edges":0.999,"complexity":0.3137,"coverage":0.6304,"colour":0.6276,"drift":0.0997},"knobResponse":[0.3696,0.3043,0.4038,0.35]},{"slug":"foam-lather","title":"Foam Lather","family":"cosmetic","round":31,"note":"거품 클렌저를 낸 거품 사백 개가 패널을 채우고, 작은 거품은 줄어 사라지고 벽이 터지며 둘이 합쳐져요. 위로 갈수록 마른 벌집이 되고 아래는 물기 머금은 둥근 거품이에요. K1 은 색상환을 다 돌고, 누르면 아래에서 고운 거품을 새로 쳐 올려요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-foam-lather","type":"code","name":"foam-lather","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Wetness=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Wetness","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1524,"detail":0.0833,"edges":0.3017,"complexity":2.5679,"coverage":1,"colour":0.1471,"drift":0.0328},"knobResponse":[0.1783,0.2037,0.1967,0.1202]},{"slug":"fogged-mirror","title":"Fogged Mirror","family":"halloween","round":45,"note":"촛불 하나가 밝힌 방의 긴 타원 거울에 입김이 테두리부터 번져 뿌옇게 덮이면, 보이지 않는 손가락이 거울 안쪽에서 BOO 나 이가 너무 많은 웃는 얼굴을 한 획씩 써요. 획마다 검은 유리가 드러나고 물방울이 줄을 그으며 흘러내리다가, 안개가 걷히면 내 뒤에 선 마른 형체가 1초 남짓 비치고 사라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fogged-mirror","type":"code","name":"fogged-mirror","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fog=0..1, Drips=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fog","min":0,"max":1},{"name":"Drips","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1202,"detail":0.0275,"edges":0.4164,"complexity":0.4171,"coverage":0.9271,"colour":0.208,"drift":0.2105},"knobResponse":[0.0521,0.0584,0.079,0.0692]},{"slug":"force-chains","title":"Force Chains","family":"particle","round":52,"note":"교차한 편광판 사이에 세운 원판 175개를 위의 피스톤과 양옆 벽이 번갈아 누르면, 하중을 지는 원판만 회색에서 흰색과 노랑을 지나 빨강과 파랑으로 물든 등색선을 띠고 갈라지는 사슬로 이어져서, 미는 쪽이 바뀔 때마다 위아래에서 옆으로 길을 바꿔요. K3 은 누르는 힘, K4 는 원판 크기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-force-chains","type":"code","name":"force-chains","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Analyser=0..1, Speed=0.2..3, Load=-1..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Analyser","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Load","min":-1,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5359,"detail":0.1998,"edges":0.5849,"complexity":2.4049,"coverage":0.6696,"colour":0.2157,"drift":0.0976},"knobResponse":[0.3352,0.272,0.2863,0.3662]},{"slug":"ford-circles","title":"Ford Circles","family":"number","round":28,"note":"세운 왼쪽 가장자리가 실수선이고, 분수 p/q 마다 반지름 1/(2q²) 인 원이 그 자리에 기대 서요. 화면은 황금비로 끝없이 들어가고, 맞닿은 두 원 사이의 중간수 자리에 더 작은 원이 자꾸 나와요. K3 이 과녁을 √2, √3, e, π 로 바꾸고, 누르면 스턴-브로코 나무를 따라 과녁까지 내려가는 길이 켜져요.","why":"원이 겹겹이라 패널이 꽉 차요(채움 0.80).","block":1,"ramped":false,"layer":{"id":"layer-ford-circles","type":"code","name":"ford-circles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Target=0..4, Fill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Target","min":0,"max":4},{"name":"Fill","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6649,"detail":0.0489,"edges":0.4057,"complexity":1.3917,"coverage":0.8005,"colour":0.1799,"drift":0.1998},"knobResponse":[0.1431,0.2105,0.195,0.7368]},{"slug":"fork-hologram","title":"Fork Hologram","family":"wave","round":82,"note":"위상이 감긴 소용돌이 열 개쯤이 떠다니는 빛과 비스듬한 평면파가 만든 가는 세로 줄무늬에서, 소용돌이마다 줄이 전하보다 하나 많은 갈래로 갈라지고, 반대 전하끼리 만나면 갈래가 합쳐지거나 사라졌다가 새 쌍으로 다시 생겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fork-hologram","type":"code","name":"fork-hologram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Charge=3..7, Carrier=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Charge","min":3,"max":7},{"name":"Carrier","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2929,"detail":0.3261,"edges":0.4139,"complexity":2.5971,"coverage":0.7608,"colour":0.2517,"drift":0.0262},"knobResponse":[0.1836,0.5134,0.3631,0.3477]},{"slug":"fortune-sweep","title":"Fortune's Sweep","family":"algo","round":37,"note":"금색 쓸기 선이 1초에 22줄씩 내려가고, 선 위로 포천의 해변선이 지나간 자리부터 보로노이 그림이 확정돼요. 해변선은 사이트 하나에 포물선 호 하나씩 이어진 목걸이라서, 선이 사이트를 지나면 호가 가시처럼 돋고 세 사이트를 지나는 빈 원이 선에 닿으면 가운데 호가 사라지며 꼭짓점이 금색 점으로 남아요. 지난 그림은 40% 밝기로 아래에서 기다려요. K4 는 가중치를 걸어 모서리를 쌍곡선으로 휘고, 누르면 새 사이트로 바로 다시 쓸어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-fortune-sweep","type":"code","name":"fortune-sweep","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sites=16..48, Weights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sites","min":16,"max":48},{"name":"Weights","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.3617,"detail":0.032,"edges":0.4248,"complexity":0.6651,"coverage":1,"colour":0.1845,"drift":0.1987},"knobResponse":[0.2392,0.1674,0.1095,0.0757]},{"slug":"four-vertex","title":"Four-Vertex Theorem","family":"line","round":53,"note":"세로로 선 매끈한 닫힌 곡선이 천천히 모양을 바꾸면, 곡률 중심이 그리는 축폐선이 그 안에서 금빛 별로 돌고, 별의 첨점은 곡률이 가장 크거나 작은 흰 꼭짓점과 점선으로 이어져 둘씩 태어나고 사라져도 넷 아래로는 줄지 않아요. K3 은 반지름을 휘는 물결의 수, K4 는 곡선이 오목하게 패이는 정도이고, 단추를 누르면 다음 물결이 잠깐 부풀어 제비꼬리가 한꺼번에 열렸다 닫혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-four-vertex","type":"code","name":"four-vertex","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Terms=2..6, Bend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Terms","min":2,"max":6},{"name":"Bend","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.3612,"detail":0.065,"edges":0.7134,"complexity":0.5747,"coverage":0.2289,"colour":0.1611,"drift":0.0493},"knobResponse":[0.0544,0.0726,0.079,0.1237]},{"slug":"fox-colorings","title":"Fox Colorings","family":"topology","round":78,"note":"패널 높이의 닫힌 땋기로 세운 매듭의 호마다 mod p 이름을 붙여, 교차마다 위 호의 두 배가 아래 두 호의 합이 되는 색칠을 하나씩 걸어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fox-colorings","type":"code","name":"fox-colorings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knot=0..1, Prime=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knot","min":0,"max":1},{"name":"Prime","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1168,"detail":0.0669,"edges":0.6766,"complexity":0.5269,"coverage":0.2169,"colour":0.2577,"drift":0.1236},"knobResponse":[0.1074,0.0695,0.2175,0.0529]},{"slug":"foxfire","title":"Foxfire","family":"fungi","round":19,"note":"밤 숲 바닥 단면에서 뽕나무버섯 균사가 그루터기와 통나무, 흙 속을 기어가며 갈라지고 실을 따라 연둣빛 펄스가 흘러요. 버섯 무리가 돋았다 시들며 숨 쉬듯 빛나고 포자가 위로 떠올라요. K1 을 누르면 피어 있는 갓이 한꺼번에 포자를 뿜어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-foxfire","type":"code","name":"foxfire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Spores=0..1, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spores","min":0,"max":1},{"name":"Damp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0552,"detail":0.062,"edges":0.4422,"complexity":2.0011,"coverage":0.1963,"colour":0.1249,"drift":0.0326},"knobResponse":[0.0328,0.0383,0.0467,0.0368]},{"slug":"fput-recurrence","title":"FPUT Recurrence","family":"physics","round":42,"note":"1955년의 질량 31개짜리 사슬이 위아래로 걸린 줄처럼 떨어요. 처음엔 에너지가 다 1번 모드에 있어 자홍 렌즈 하나로 보이다가, 높은 모드로 번지면서 마디가 늘어난 제 색 고리들이 차례로 부풀고, 31초 뒤 147번 흔들린 끝에 98% 가 1번 모드로 돌아와요. K4 를 0 으로 내리면 선형 사슬이 되어 렌즈가 끝내 그대로예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fput-recurrence","type":"code","name":"fput-recurrence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Amplitude=1..1.9, Alpha=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Amplitude","min":1,"max":1.9},{"name":"Alpha","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.0874,"detail":0.0555,"edges":0.8174,"complexity":0.1527,"coverage":0.4112,"colour":0.2328,"drift":0.1726},"knobResponse":[0.0868,0.1144,0.0646,0.2031]},{"slug":"fractal-percolation","title":"Fractal Percolation","family":"fractal","round":48,"note":"위아래로 쌓인 두 정사각형이 넷으로 쪼개질 때마다 조각이 확률 p 로 남고 나머지는 꺼지기를 낱 LED 까지 되풀이하고, 아래 줄에서 오른 빛이 위 줄에 닿으면 판을 건너는 덩어리가 민트로 켜진 뒤 남은 정사각형 한 쌍으로 두 배 확대해 들어가요. K3 이 p 이고, K1 을 누르면 구멍을 닫고 새로 깎아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fractal-percolation","type":"code","name":"fractal-percolation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Keep=0.88..0.99, Levels=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Keep","min":0.88,"max":0.99},{"name":"Levels","min":0,"max":1}],"start":[0,2,0.88,0.06],"measures":{"motion":1.1042,"detail":0.1052,"edges":0.9252,"complexity":0.1809,"coverage":0.7671,"colour":0.2486,"drift":0.2995},"knobResponse":[0.1604,0.1785,0.1179,0.1183]},{"slug":"fractran","title":"FRACTRAN","family":"number","round":75,"note":"콘웨이의 PRIMEGAME 이 2, 3, 5, 7 의 지수를 구슬 기둥으로 오르내리며 분수 열넷 가운데 맞는 첫 분수를 밝히고, n 이 2 의 거듭제곱이 될 때마다 2 기둥에 구슬 p 개만 남긴 채 소수 p 를 맨 위에 적어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fractran","type":"code","name":"fractran","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Start=0..3, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Start","min":0,"max":3},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.5136,"detail":0.0898,"edges":0.6742,"complexity":0.4175,"coverage":0.2767,"colour":0.1316,"drift":0.1231},"knobResponse":[0.0531,0.0903,0.1132,0.0542]},{"slug":"franklin-involution","title":"Franklin's Involution","family":"number","round":78,"note":"서로 다른 부분의 분할이 가장 작은 줄과 비탈을 맞바꿔 짝을 찾아 아래로 날아가고, 오각수에서만 계단 사다리꼴 하나가 홀로 남아 ±1 을 받아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-franklin-involution","type":"code","name":"franklin-involution","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, N=5..16, Gap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"N","min":5,"max":16},{"name":"Gap","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.4172,"detail":0.0431,"edges":0.6909,"complexity":0.0737,"coverage":0.3132,"colour":0.3305,"drift":0.1854},"knobResponse":[0.1363,0.1625,0.1208,0.0849]},{"slug":"frenkel-kontorova","title":"Frenkel-Kontorova","family":"sim","round":70,"note":"우물 12개가 두른 바닥 위 용수철 사슬에 공이 남거나 모자라 생긴 꼬임이 미는 힘에 고리를 돌고, 위 113줄 기록에서 꼬임은 비스듬한 자홍 띠로, 크림색 공의 세계선은 띠마다 한 우물씩 비켜 가는 계단으로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-frenkel-kontorova","type":"code","name":"frenkel-kontorova","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Drive=0..3, Misfit=0.86..1.2, Substrate=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Drive","min":0,"max":3},{"name":"Misfit","min":0.86,"max":1.2},{"name":"Substrate","min":1,"max":4}],"start":[0,2,0.86,1],"measures":{"motion":0.9856,"detail":0.1251,"edges":0.5212,"complexity":1.7026,"coverage":0.4943,"colour":0.1728,"drift":0.0379},"knobResponse":[0.0854,0.1755,0.1885,0.1467]},{"slug":"frieze-letters","title":"Frieze Letters","family":"type","round":76,"note":"글자 b 하나로 짠 띠 무늬 일곱 군이 콘웨이의 이름 차례로 세로로 서고, 띠마다 박자에 맞춰 제 대칭인 미끄럼, 접기, 반 바퀴를 해 보이고 제자리로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-frieze-letters","type":"code","name":"frieze-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Glyph=0..1, Marks=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Glyph","min":0,"max":1},{"name":"Marks","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.418,"detail":0.2076,"edges":0.9971,"complexity":0.0765,"coverage":0.2249,"colour":0.2875,"drift":0.1112},"knobResponse":[0.1119,0.1462,0.1961,0.0538]},{"slug":"frost","title":"Frost","family":"fractal","round":17,"note":"밤 유리창에 서리 고사리가 아래 틀과 창틀에서 자라 들어와요. 가지는 대각선으로 곧게 뻗어 깃털처럼 곁가지를 내며 반짝이고, 유리 너머로 가로등과 눈발이 흐리게 비치다가 방이 데워지면 가운데부터 녹아 다시 자라요. K1 을 누르면 입김이 가운데를 닦아요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-frost","type":"code","name":"frost","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Rime=0..1, Glitter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rime","min":0,"max":1},{"name":"Glitter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0377,"detail":0.1373,"edges":0.4636,"complexity":2.383,"coverage":0.4303,"colour":0.1004,"drift":0.0382},"knobResponse":[0.0509,0.1276,0.1564,0.0602]},{"slug":"funicular","title":"Funicular","family":"rail","round":27,"note":"해 질 녘 산비탈에서 계단꼴 객차 둘이 케이블 하나에 매달려 오르내려요. 호숫가 마을의 역을 떠난 빨간 객차가 오르는 동안 꼭대기 기관실의 큰 바퀴가 돌며 파란 객차가 내려오고, 둘은 중턱의 압트 교행 구간에서 갈라진 선로로 비켜 지나가요. K1 을 끝까지 돌리면 창이 켜진 밤이 되고, 누르면 객차가 바로 떠나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-funicular","type":"code","name":"funicular","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Grade=0..1, Snow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grade","min":0,"max":1},{"name":"Snow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0963,"detail":0.0901,"edges":0.4693,"complexity":1.617,"coverage":0.9811,"colour":0.2158,"drift":0.0259},"knobResponse":[0.2342,0.0427,0.0962,0.1569]},{"slug":"galilean-moons","title":"Galilean Moons","family":"celestial","round":22,"note":"목성의 네 위성을 관측 도표로 그려요. 위쪽 접안렌즈에서는 줄무늬 목성이 돌고 이오의 그림자가 원반을 지나가며, 아래 도표에서는 위성마다 제 사인 곡선을 그리며 날짜가 위로 올라와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-galilean-moons","type":"code","name":"galilean-moons","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sky=0..1, Speed=0.5..24, Power=0..1, Seeing=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sky","min":0,"max":1},{"name":"Speed","min":0.5,"max":24},{"name":"Power","min":0,"max":1},{"name":"Seeing","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0779,"detail":0.0747,"edges":0.5632,"complexity":0.743,"coverage":0.7778,"colour":0.1926,"drift":0.0306},"knobResponse":[0.5122,0.1178,0.1493,0.0539]},{"slug":"galileos-frets","title":"Galileo's Frets","family":"rhythm","round":78,"note":"세 홈에서 공이 함께 굴러 내려가고, 프렛이 제곱수 자리에 놓인 가운데 홈만 고른 박으로 덜컥여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-galileos-frets","type":"code","name":"galileos-frets","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Law=1..3, Frets=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Law","min":1,"max":3},{"name":"Frets","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2342,"detail":0.0637,"edges":0.8331,"complexity":0.0999,"coverage":0.4752,"colour":0.2688,"drift":0.1073},"knobResponse":[0.1471,0.0584,0.0419,0.0797]},{"slug":"galperin-billiard","title":"Galperin Billiard","family":"physics","round":57,"note":"무거운 블록이 레일을 내려와 바닥 벽 위의 가벼운 블록에 부딪히고, 블록끼리든 벽이든 부딪힐 때마다 셈판에 점이 하나씩 켜져서 질량비 100, 10,000, 1,000,000 에서 31, 314, 3141 로 읽혀요. 위의 에너지 원에서는 두 속도가 한 점이 되어 부딪힐 때마다 현을 하나씩 그으며 원의 왼쪽 끝에서 오른쪽 끝까지 지그재그로 원판을 쓸고, 각 arctan √(m/M) 의 쐐기에 들어가면 멈춰요. K3 은 자릿수 k(1~3), K4 는 몰린 부딪힘을 늘려 보여 주는 슬로 모션 초(0~8)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-galperin-billiard","type":"code","name":"galperin-billiard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Digits=1..3, Warp=0..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Digits","min":1,"max":3},{"name":"Warp","min":0,"max":8}],"start":[0,2,1,0.06],"measures":{"motion":0.151,"detail":0.0347,"edges":0.5009,"complexity":0.3385,"coverage":0.249,"colour":0.1861,"drift":0.2355},"knobResponse":[0.0674,0.1434,0.2269,0.1456]},{"slug":"galton","title":"Galton Board","family":"data","round":2,"note":"깔때기에서 떨어진 공이 못마다 동전 던지듯 왼쪽이나 오른쪽으로 튀어 칸에 쌓이고, 종 모양이 서요. 칸 색은 가운데에서 표준편차 몇 개만큼 떨어졌는지를 보여 줘요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-galton","type":"code","name":"galton","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rate=30..240, Bias=-0.3..0.3, Rows=8..15","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rate","min":30,"max":240},{"name":"Bias","min":-0.3,"max":0.3},{"name":"Rows","min":8,"max":15}],"start":[0,30,0,8],"measures":{"motion":0.2909,"detail":0.0577,"edges":0.7232,"complexity":0.5234,"coverage":0.2361,"colour":0.1843,"drift":0.0246},"knobResponse":[0.0536,0.0477,0.0979,0.0715]},{"slug":"gargoyle","title":"Gargoyle","family":"halloween","round":49,"note":"폭풍 속 성당 처마의 가고일이 입으로 물줄기를 패널 아래 웅덩이까지 쏟고, 번개가 칠 때마다 검게 드러났다가 눈에 독한 초록 불이 켜져요. K3 은 비, K4 는 번개가 치는 잦기이고, 단추를 누르면 바로 번개가 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gargoyle","type":"code","name":"gargoyle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Lightning=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rain","min":0,"max":1},{"name":"Lightning","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9825,"detail":0.0606,"edges":0.4454,"complexity":0.4401,"coverage":0.936,"colour":0.1221,"drift":0.2038},"knobResponse":[0.0799,0.0531,0.0669,0.0851]},{"slug":"gaussian-free-field","title":"Gaussian Free Field","family":"noise","round":52,"note":"패널의 격자점마다 가우스 무작위 높이를 둔 자유장이 0 위는 주황 땅, 0 아래는 보라 바다로 칠해지고, 흰 해안선이 섬 안의 호수와 호수 안의 섬으로 겹겹이 닫힌 고리가 되어 1~2초마다 지도를 새로 그려요. K3 을 올리면 테두리 왼쪽과 오른쪽의 높이가 갈려 바닥에서 꼭대기까지 오르는 해안선 하나, SLE(4) 곡선이 서고, K4 는 해안선 아래 흐림의 폭이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gaussian-free-field","type":"code","name":"gaussian-free-field","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Boundary=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Boundary","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4085,"detail":0.0882,"edges":0.349,"complexity":2.2565,"coverage":0.9674,"colour":0.466,"drift":0.3687},"knobResponse":[0.296,0.3457,0.2297,0.1853]},{"slug":"gaussian-moat","title":"Gaussian Moat","family":"number","round":31,"note":"LED 하나가 가우스 정수 하나라 가우스 소수가 옅은 점으로 깔리고, 1 + i 에서 걸음 √k 안의 소수로만 번지는 물길이 산호처럼 가지를 쳐요. 물길이 해자에 막히면 기슭이 깜박이고 k 가 커져 건너가요. K1 을 누르면 k 를 바로 한 칸 올려요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-gaussian-moat","type":"code","name":"gaussian-moat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Step=1.5..4.5, Reach=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Step","min":1.5,"max":4.5},{"name":"Reach","min":0,"max":1}],"start":[0,2,1.5,0.06],"measures":{"motion":0.0332,"detail":0.138,"edges":0.7904,"complexity":0.3035,"coverage":0.2952,"colour":0.1811,"drift":0.1107},"knobResponse":[0.0371,0.0267,0.0437,0.056]},{"slug":"gaussian-periods","title":"Gaussian Periods","family":"number","round":53,"note":"k 를 n 으로 나눈 나머지마다 LED 하나가 가우스 주기 η(k) 자리에 켜져서, 열한 개의 돌린 델토이드가 k mod 11 로 물든 점의 햇살로 서요. 점마다 η(uk) 로 미끄러지면 햇살이 흩어졌다가 같은 점 집합으로 다시 서고, 조각들의 색만 서로 바뀌어요. K3 은 (n, ω) 여덟 그림이고, K4 는 곱하는 단위 u 예요. 0 은 색 무리를 섞고, 1 은 무리를 제자리에 두어 조각마다 저 혼자 다시 서고, 2 는 조각을 통째로 돌려요. 단추를 누르면 다음 그림으로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gaussian-periods","type":"code","name":"gaussian-periods","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Figure=0..7, Unit=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Figure","min":0,"max":7},{"name":"Unit","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":4.9103,"detail":0.3241,"edges":1,"complexity":0.385,"coverage":0.3067,"colour":0.4274,"drift":0.1045},"knobResponse":[0.1965,0.2562,0.2353,0.2055]},{"slug":"gaussian-zeros","title":"Gaussian Zeros","family":"noise","round":77,"note":"가우스 해석 함수의 영점이 위 절반에 색상환을 두른 검은 점으로 고르게 떠다니고, 아래 절반의 같은 밀도 푸아송 점은 뭉쳐서 검은 구멍을 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gaussian-zeros","type":"code","name":"gaussian-zeros","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=0..1, Focus=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":0,"max":1},{"name":"Focus","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3263,"detail":0.1184,"edges":0.4357,"complexity":2.5673,"coverage":0.9761,"colour":0.3537,"drift":0.1284},"knobResponse":[0.2224,0.2717,0.2936,0.3132]},{"slug":"gear-train","title":"Gear Train","family":"machine","round":8,"note":"패널 발치의 크랭크가 색 톱니바퀴를 돌려요. 바퀴마다 아래 바퀴와 톱니를 맞물려 꼭대기까지 이어지고, 작은 바퀴일수록 빨리 돌아요. K4 를 올리면 모든 바퀴가 톱니 하나씩 딸깍 걸려 나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-gear-train","type":"code","name":"gear-train","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gears=4..9, Tick=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gears","min":4,"max":9},{"name":"Tick","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.8362,"detail":0.0922,"edges":0.4218,"complexity":1.1517,"coverage":0.8876,"colour":0.5762,"drift":0.1048},"knobResponse":[0.3786,0.1249,0.2931,0.0655]},{"slug":"geyser","title":"Geyser","family":"volcano","round":26,"note":"눈 덮인 지열 지대의 간헐천을 땅속까지 잘라 봐요. 화도에 기포가 차면 청록 웅덩이가 유리 돔으로 부풀다 흰 물기둥으로 터지고, 김 구름이 바람에 흘러가요. K1 은 정오에서 오로라 밤까지 빛을 바꾸고, 누르면 바로 분출해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-geyser","type":"code","name":"geyser","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Power=0..1, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Power","min":0,"max":1},{"name":"Wind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1931,"detail":0.0478,"edges":0.2475,"complexity":2.0465,"coverage":1,"colour":0.26,"drift":0.0438},"knobResponse":[0.2681,0.0644,0.048,0.0484]},{"slug":"ghost-ship","title":"Ghost Ship","family":"halloween","round":46,"note":"누더기 돛의 유령선이 너울에 앞뒤로 기울며 안개 속을 떠가고, 초록 등불이 흔들리며 이따금 선체 너머로 달이 비쳐요. K3 은 너울 높이, K4 는 안개이고, K1 을 누르면 안개 속으로 사라졌다 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ghost-ship","type":"code","name":"ghost-ship","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Swell=1..4, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Swell","min":1,"max":4},{"name":"Fog","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3375,"detail":0.0455,"edges":0.3255,"complexity":0.759,"coverage":0.9394,"colour":0.1111,"drift":0.0466},"knobResponse":[0.0323,0.0916,0.0798,0.0664]},{"slug":"giant-component","title":"Giant Component","family":"data","round":60,"note":"점 672개에 무작위 변이 하나씩 더해지며 성분마다 제 색을 입다가, 변이 점 수의 절반을 넘자 크림색 거대 성분이 패널을 덮어요. 아래 그래프는 가장 큰 성분의 몫을 이론 곡선 위에 그리고, Choice 를 올리면 그 곡선이 절벽처럼 솟아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-giant-component","type":"code","name":"giant-component","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Choice=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":-1,"max":1},{"name":"Choice","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2029,"detail":0.2656,"edges":0.9913,"complexity":0.1602,"coverage":0.3826,"colour":0.1542,"drift":0.1443},"knobResponse":[0.0885,0.1217,0.2249,0.0917]},{"slug":"gibbs-phenomenon","title":"Gibbs Phenomenon","family":"wave","round":36,"note":"사각파 한 주기가 가로로 놓이고, 아래로 내려갈수록 푸리에 부분합의 항이 늘어 맨 위 1항에서 맨 아래 32항까지 25줄마다 두 배가 돼요. 합이 파형을 넘어선 곳은 흰 금색으로 타서 점프마다 양옆에 뿔이 서고, 뿔은 아래로 갈수록 점프에 붙지만 높이는 언제나 점프의 8.95% 예요. K3 은 사각파를 톱니파를 거쳐 삼각파로 바꿔 점프와 함께 뿔을 지우고, K1 을 누르면 맨 아래 줄이 256항까지 달리며 그 합의 그래프가 금색 눈금에 닿아요.","why":"아치가 겹친 결이 패널을 채워요(채움 0.87).","block":1,"ramped":false,"layer":{"id":"layer-gibbs-phenomenon","type":"code","name":"gibbs-phenomenon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Fejer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Fejer","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5169,"detail":0.0632,"edges":0.2237,"complexity":1.7176,"coverage":0.871,"colour":0.3287,"drift":0.2332},"knobResponse":[0.1974,0.2792,0.2184,0.2064]},{"slug":"gilbreath-table","title":"Gilbreath Table","family":"number","round":32,"note":"맨 윗줄은 소수 2, 3, 5, 7, …이고, 그 아래 줄마다 윗줄 이웃끼리 뺀 차의 절댓값이 내려와요. 소수 간격이 분홍과 흰빛으로 남은 위 열 줄은 붙박혀 있고, 그 아래는 0 과 2 가 만드는 삼각형 무늬로 표를 따라 내려가요. 왼쪽 끝 금빛 1 의 열은 1만 줄 아래에서도 끊기지 않아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-gilbreath-table","type":"code","name":"gilbreath-table","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=0..1, Zoom=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":0,"max":1},{"name":"Zoom","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5182,"detail":0.0975,"edges":0.6797,"complexity":0.1987,"coverage":0.9794,"colour":0.3745,"drift":0.1585},"knobResponse":[0.3124,0.3276,0.151,0.2734]},{"slug":"gilded-cream","title":"Gilded Cream","family":"cosmetic","round":35,"note":"금박 조각 여섯 개가 든 아이보리 크림을 옆에서 본 단면이 제빵사의 반죽처럼 두 배로 늘어나 제 위로 접혀요. 접을 때마다 조각이 길게 늘어 금빛 결이 되고, 다섯 번 접으면 서른두 겹의 가는 금선이 반짝임만 남기고 크림에 녹아든 뒤 새 조각이 떨어져요. K3 은 한 번에 세 겹이나 네 겹으로 접게 하고, K1 은 크림을 색상환 한 바퀴로 물들이며 누르면 한 번을 네 배 빠르게 접어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-gilded-cream","type":"code","name":"gilded-cream","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fold=2..4, Gold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fold","min":2,"max":4},{"name":"Gold","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2739,"detail":0.0073,"edges":0.2093,"complexity":0.5765,"coverage":1,"colour":0.1255,"drift":0.0414},"knobResponse":[0.2092,0.0648,0.051,0.0463]},{"slug":"giraffe","title":"Giraffe","family":"mammal","round":23,"note":"우산 아카시아의 납작한 수관 밑에서 그물무늬기린이 보라색 혀로 잔가지를 감아 잎을 훑고, 소등쪼기새가 목을 타고 뛰어다녀요. 가끔 앞다리를 A 자로 벌리고 목을 내려 웅덩이 물을 마시면 물에 동그란 물결이 퍼져요. K3 을 돌리면 무늬가 마사이기린이나 로스차일드기린의 것으로 바뀌고, 끝에는 흰 기린이 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-giraffe","type":"code","name":"giraffe","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sun=0..1, Speed=0.2..3, Coat=0..3, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sun","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coat","min":0,"max":3},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.123,"detail":0.074,"edges":0.4044,"complexity":1.9181,"coverage":0.9853,"colour":0.3367,"drift":0.0426},"knobResponse":[0.2454,0.0494,0.078,0.0609]},{"slug":"glass-patterns","title":"Glass Patterns","family":"noise","round":46,"note":"흩어진 점마다 같은 일차 사상으로 세 번 옮긴 사본을 이어 그려서, 잡음 속에서 x' = Ax 의 흐름이 동심원과 나선, 별, 안장으로 차례로 떠올라요. 위 띠는 대각합–행렬식 평면에서 A 의 자리예요. K3 은 점 수, K4 는 옮기는 거리 ε 이고, K1 을 누르면 다음 꼴로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-glass-patterns","type":"code","name":"glass-patterns","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dots=320..800, Step=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dots","min":320,"max":800},{"name":"Step","min":0,"max":1}],"start":[0,2,320,0.06],"measures":{"motion":1.2073,"detail":0.1021,"edges":0.8095,"complexity":0.2342,"coverage":0.2548,"colour":0.1697,"drift":0.055},"knobResponse":[0.0375,0.0969,0.152,0.0523]},{"slug":"glassblower","title":"Glassblower","family":"glass","round":27,"note":"어두운 스윙 피트 위 발판에서 가퍼가 블로파이프 끝의 유리 덩어리를 진자처럼 흔들면, 덩어리가 아래로 늘어나 긴 화병이 되며 노랑에서 주황을 지나 진홍으로 식어요. 글로리 홀에서 다시 달궈 불고 또 흔든 뒤 잘라 내면 바닥의 컬릿 더미에 떨어져 부서져요. K1 이 코발트나 호박 같은 유리 색을 고르고, 버튼은 다시 달구기와 불기예요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-glassblower","type":"code","name":"glassblower","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glass=0..1, Speed=0.2..3, Length=-1..1, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glass","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":-1,"max":1},{"name":"Heat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2176,"detail":0.046,"edges":0.1956,"complexity":1.533,"coverage":0.4076,"colour":0.1924,"drift":0.0806},"knobResponse":[0.0366,0.0488,0.0315,0.0412]},{"slug":"glitter-fall","title":"Glitter Fall","family":"cosmetic","round":29,"note":"검은 화면 위로 분홍 글리터가 흔들리는 줄기로 쏟아지고, 육각 조각 하나하나가 제 박자로 돌다가 면이 빛을 향할 때 반짝여요. 바닥에 쌓인 더미는 바닥 틈으로 모래시계처럼 빠져요. K1 은 색상환을 다 돌고, 누르면 더미 윗층이 공중으로 튀어 올라요.","why":"반짝이가 점 하나 크기예요.","block":1,"ramped":false,"layer":{"id":"layer-glitter-fall","type":"code","name":"glitter-fall","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Amount=1..3, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Amount","min":1,"max":3},{"name":"Size","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.3817,"detail":0.0894,"edges":0.4622,"complexity":1.3664,"coverage":0.3835,"colour":0.1675,"drift":0.0908},"knobResponse":[0.0974,0.131,0.1719,0.0961]},{"slug":"glyph-rain","title":"Glyph Rain","family":"type","round":1,"note":"3×5 글자가 줄마다 떨어지며 바뀌어요. 비가 지나간 글자는 옛 단말기의 초록 형광처럼 몇 초 남아 흐려져서, 아무 말도 하지 않는 글이 화면을 채워요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-glyph-rain","type":"code","name":"glyph-rain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Fall=0.3..6, Density=0..1, Mutate=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Fall","min":0.3,"max":6},{"name":"Density","min":0,"max":1},{"name":"Mutate","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2257,"detail":0.0998,"edges":0.7469,"complexity":0.2343,"coverage":0.2152,"colour":0.1998,"drift":0.0956},"knobResponse":[0.0655,0.0718,0.1045,0.0664]},{"slug":"gold-leaf","title":"Gold Leaf","family":"cosmetic","round":33,"note":"맑은 세럼에 구겨진 금박 조각 마흔 개가 떠서 위아래 두 대류 칸을 따라 천천히 돌 뿐 가라앉지 않아요. 조각이 뒤집힐 때마다 빛을 향한 면이 흰 금빛으로 번쩍이고 돌아선 면은 짙은 금으로 내려가며, 먼 조각은 작고 흐려요. K1 은 색상환을 다 돌아 금박을 장밋빛 금이나 푸른 박으로 바꾸고, 누르면 세럼을 저어 조각이 느린 소용돌이로 돌며 다섯 배 빨리 뒤집혀요.","why":"금박이 좋은데 조각이 작고 느려요.","block":1,"ramped":false,"layer":{"id":"layer-gold-leaf","type":"code","name":"gold-leaf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flakes=40..120, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flakes","min":40,"max":120},{"name":"Size","min":0,"max":1}],"start":[0,2,40,0.06],"measures":{"motion":0.1468,"detail":0.0417,"edges":0.5435,"complexity":1.0218,"coverage":0.4003,"colour":0.1903,"drift":0.1193},"knobResponse":[0.0888,0.0967,0.0947,0.1201]},{"slug":"goldbach-comet","title":"Goldbach Comet","family":"number","round":33,"note":"짝수 n 을 두 소수의 합으로 쓰는 가짓수를 매끈한 예측값으로 나눠 가로로 찍고, n 은 아래로 커져요. n 이 3 이나 5 나 7 로 나뉘는지에 따라 여덟 줄기가 색으로 갈라지고, 아래로 갈수록 줄기가 가늘어지며 52만까지 가면 처음부터 다시 흘러요. K3 은 7 부터 소수 하나씩 줄기를 접어 한 줄로 모으고, K1 을 누르면 8초 동안 다 접었다 펴요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-goldbach-comet","type":"code","name":"goldbach-comet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Correction=0..1, Smear=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Correction","min":0,"max":1},{"name":"Smear","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.5227,"detail":0.1448,"edges":0.6539,"complexity":1.6402,"coverage":0.5247,"colour":0.2628,"drift":0.0876},"knobResponse":[0.139,0.1117,0.2621,0.1127]},{"slug":"golomb-ruler","title":"Golomb Ruler","family":"number","round":66,"note":"14 눈금 최적 Golomb 자의 눈금 쌍 91개가 저마다 다른 크기의 호로 겹쳐 서고, 캘리퍼가 길이 1부터 127까지 훑으며 길이마다 호 하나를 켜거나 오른쪽 길이 자에 빈칸을 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-golomb-ruler","type":"code","name":"golomb-ruler","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ruler=0..3, Shape=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ruler","min":0,"max":3},{"name":"Shape","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1027,"detail":0.1161,"edges":0.4688,"complexity":1.8229,"coverage":0.573,"colour":0.2653,"drift":0.2539},"knobResponse":[0.1063,0.1173,0.1575,0.1788]},{"slug":"golomb-trominoes","title":"Golomb Trominoes","family":"cells","round":56,"note":"64 × 64 판 둘이 한 칸씩 빠진 채 3 LED 짜리 L 트로미노로 덮여요. 깜박이는 빈칸이 한 LED 씩 걸을 때마다 그 사이 트로미노가 흰빛으로 다시 깔리고, 바탕 색은 빈칸을 둘러싼 증명의 L 자 껍질을 따라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-golomb-trominoes","type":"code","name":"golomb-trominoes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lift=0..4, Cell=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lift","min":0,"max":4},{"name":"Cell","min":1,"max":4}],"start":[0,2,0,1],"measures":{"motion":0.023,"detail":0.3554,"edges":0.9342,"complexity":0.3206,"coverage":1,"colour":0.518,"drift":0.0082},"knobResponse":[0.4161,0.0515,0.2793,0.3508]},{"slug":"gosset-polytope","title":"Gosset Polytope","family":"geometry","round":28,"note":"E8 의 근 240개와 그 사이 모서리 6720개, 고셋의 4₂₁ 다면체를 8차원에서 두 창에 비춰요. 위 창은 30개씩 고리 여덟이 서는 콕서터 평면에서 열려 E7, E6, D5, D4, D6 의 평면을 지나 돌아오고, 아래 창은 몇 평면 앞서가요. 누르면 둘 다 콕서터 평면으로 돌아가요.","why":"점 무늬가 작고 거의 안 움직여요(움직임 0.10).","block":1,"ramped":false,"layer":{"id":"layer-gosset-polytope","type":"code","name":"gosset-polytope","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Edges=-1..1, Plane=1..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Edges","min":-1,"max":1},{"name":"Plane","min":1,"max":5}],"start":[0,2,0,1],"measures":{"motion":0.1027,"detail":0.0626,"edges":0.2381,"complexity":1.7381,"coverage":0.5762,"colour":0.1523,"drift":0.0443},"knobResponse":[0.101,0.0579,0.4228,0.087]},{"slug":"granular-demon","title":"Granular Demon","family":"particle","round":59,"note":"바닥을 흔드는 키 큰 상자를 창 난 벽으로 나누면 240알이 저절로 한 칸에 모여요. 찬 칸은 바닥의 하늘색 더미, 뜨거운 칸은 뚜껑까지 날아다니는 분홍 줄이고, 벽이 들리면 다시 퍼져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-granular-demon","type":"code","name":"granular-demon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shaking=130..260, Boxes=2..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shaking","min":130,"max":260},{"name":"Boxes","min":2,"max":5}],"start":[0,2,130,2],"measures":{"motion":2.2353,"detail":0.0674,"edges":0.4722,"complexity":0.8616,"coverage":0.7457,"colour":0.1627,"drift":0.0506},"knobResponse":[0.099,0.0883,0.1616,0.0825]},{"slug":"granular-leidenfrost","title":"Granular Leidenfrost","family":"particle","round":70,"note":"바닥이 쳐 올리는 상자에서 320알이 차가운 결정 덩어리로 뭉쳐 뜨거운 알갱이 기체 위에 뜨고, 흔들기를 줄이면 바닥에 내려앉고 키우면 뚜껑에 눌리며, 알을 덜 비탄성으로 하면 결정이 녹아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-granular-leidenfrost","type":"code","name":"granular-leidenfrost","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Shaking=0.5..3, Restitution=0.88..0.98, Grains=320..440","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Shaking","min":0.5,"max":3},{"name":"Restitution","min":0.88,"max":0.98},{"name":"Grains","min":320,"max":440}],"start":[0,2,0.88,320],"measures":{"motion":3.0313,"detail":0.168,"edges":0.6544,"complexity":1.9555,"coverage":0.6406,"colour":0.3083,"drift":0.1129},"knobResponse":[0.1987,0.352,0.3535,0.2128]},{"slug":"grave-hand","title":"Grave Hand","family":"halloween","round":43,"note":"크고 낮은 주황 달 아래 묘비와 갓 덮은 흙무더기가 검게 서 있고, 흙이 들썩이며 초록 빛 금이 가더니 뼈만 남은 손이 흙덩이를 튀기며 솟아나와요. 손은 달 앞에서 팔꿈치를 굽혀 허공을 더듬고 손가락을 쥐었다 폈다 하다가 세 번에 걸쳐 끌려 들어가요. K3 은 손을 셋까지 늘리고 K4 는 땅안개를 달 아래쪽까지 올려요. K1 을 누르면 흙 속에 있는 손이 모두 한꺼번에 튀어나와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-grave-hand","type":"code","name":"grave-hand","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Hands=1..3, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hands","min":1,"max":3},{"name":"Fog","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2892,"detail":0.0299,"edges":0.4105,"complexity":1.0695,"coverage":0.5738,"colour":0.2984,"drift":0.0577},"knobResponse":[0.0879,0.0451,0.031,0.0445]},{"slug":"graveyard-fog","title":"Graveyard Fog","family":"halloween","round":42,"note":"가는 초승달 아래 검은 비석과 삐뚤어진 쇠울타리 사이로 땅안개 세 겹이 서로 다른 빠르기로 흘러가고, 독한 초록 도깨비불이 오르내리며 둘레의 안개를 물들여요. 안개에는 LED 한 알씩 엇갈린 고운 결이 있어요. K3 은 도깨비불을 4개에서 14개로 늘리고, K4 는 안개를 십자가 가로대 위까지 올려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-graveyard-fog","type":"code","name":"graveyard-fog","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wisps=4..14, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wisps","min":4,"max":14},{"name":"Fog","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0456,"detail":0.0983,"edges":0.0704,"complexity":2.0907,"coverage":0.921,"colour":0.117,"drift":0.0548},"knobResponse":[0.0865,0.0564,0.0424,0.1739]},{"slug":"greenhill-column","title":"Greenhill Column","family":"physics","round":61,"note":"바닥에 박힌 기둥 여덟 개가 자라다가 흰 눈금으로 찍은 제 임계 높이를 넘으면 제 무게에 꺾여 옆으로 눕고, 끝이 수평 아래로 내려가면 줄어들었다가 다시 일어서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-greenhill-column","type":"code","name":"greenhill-column","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=3..64, Top weight=0..40","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":3,"max":64},{"name":"Top weight","min":0,"max":40}],"start":[0,2,3,0.06],"measures":{"motion":0.5878,"detail":0.0407,"edges":0.2458,"complexity":0.6838,"coverage":0.4803,"colour":0.216,"drift":0.1815},"knobResponse":[0.1021,0.1248,0.0889,0.0764]},{"slug":"gridfonts","title":"Gridfonts","family":"type","round":66,"note":"호프스태터의 gridfont 처럼 글자 아홉이 희미한 점 격자를 잇는 짧은 선분으로만 서고, 노브가 스타일을 바꾸면 모든 글자가 같은 규칙으로 획을 거뒀다가 새로 그어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gridfonts","type":"code","name":"gridfonts","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Style=0..6, Grid=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Style","min":0,"max":6},{"name":"Grid","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0461,"detail":0.052,"edges":0.4604,"complexity":0.331,"coverage":0.2668,"colour":0.1721,"drift":0.0453},"knobResponse":[0.0804,0.0772,0.1425,0.0747]},{"slug":"grim-reaper","title":"Grim Reaper","family":"halloween","round":48,"note":"두 눈에 독한 초록 불을 켠 두건 사신이 해진 옷자락을 날리며 창백한 보름달 앞을 떠가고, 머리 위로 큰 낫을 휘두를 때마다 날이 번뜩이며, 지나가는 자리의 무덤 촛불은 꺼졌다가 등 뒤에서 다시 켜져요. K3 은 무덤 수, K4 는 안개이고, K1 을 누르면 바로 휘둘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-grim-reaper","type":"code","name":"grim-reaper","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Graves=6..30, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Graves","min":6,"max":30},{"name":"Fog","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.347,"detail":0.0359,"edges":0.3909,"complexity":0.2416,"coverage":0.989,"colour":0.1975,"drift":0.2578},"knobResponse":[0.0927,0.1212,0.0466,0.046]},{"slug":"grimoire","title":"Grimoire","family":"halloween","round":51,"note":"탑 방 독서대 위에 펼친 마법서의 책장을 보이지 않는 바람이 넘기면, 종이가 휘어 넘어가며 촛불을 받아 빛나요. 새로 펼친 면마다 독한 초록 인장이 한 획씩 그려지고, 그 글자들이 하나씩 떨어져 나와 초록 불티와 연기 꼬리를 끌며 패널 위로 올라가요. K3 은 바람, K4 는 인장이 타는 밝기이고, 단추를 누르면 돌풍이 책장을 몰아 넘겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-grimoire","type":"code","name":"grimoire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2495,"detail":0.0417,"edges":0.243,"complexity":1.5612,"coverage":0.9356,"colour":0.1766,"drift":0.0424},"knobResponse":[0.0422,0.0512,0.0434,0.0448]},{"slug":"guilloche","title":"Guilloché","family":"line","round":16,"note":"장미 기관으로 깎은 은판의 보리알 띠와 물결 띠가 패널 높이의 타원으로 서고, 등불이 돌면 그 쪽을 향한 홈만 금빛으로 번쩍여요. K1 을 누르면 칼끝이 귀퉁이에서 가운데로 들어오며 판을 새 무늬로 다시 깎아요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-guilloche","type":"code","name":"guilloche","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Metal=0..1, Light=0..4, Lobes=12..36, Phasing=0..0.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Metal","min":0,"max":1},{"name":"Light","min":0,"max":4},{"name":"Lobes","min":12,"max":36},{"name":"Phasing","min":0,"max":0.5}],"start":[0,2,12,0.06],"measures":{"motion":0.3271,"detail":0.2382,"edges":0.6848,"complexity":2.494,"coverage":1,"colour":0.0828,"drift":0.1447},"knobResponse":[0.1324,0.1841,0.2378,0.2082]},{"slug":"hadwiger-nelson","title":"Hadwiger-Nelson","family":"cells","round":45,"note":"일곱 색 정육각형 유리 타일이 천천히 흐르며 도는 위로 길이 1 인 막대와 모저 방추 같은 단위 도형이 굴러다니고, 빛으로 그은 변의 두 끝은 늘 다른 색 칸에 앉아요. K3 으로 육각형을 아이즈벨의 창 밖으로 줄이거나 키우면 두 끝이 같은 색에 닿은 변이 빨갛게 번쩍여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hadwiger-nelson","type":"code","name":"hadwiger-nelson","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Figures=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":-1,"max":1},{"name":"Figures","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9476,"detail":0.1022,"edges":0.6243,"complexity":0.5058,"coverage":0.8925,"colour":0.4528,"drift":0.1929},"knobResponse":[0.3239,0.3241,0.3031,0.0939]},{"slug":"hair-gloss","title":"Hair Gloss","family":"cosmetic","round":34,"note":"판 전체에 윤기 나는 긴 머리카락 230가닥이 위에서 끝까지 늘어져 산들바람에 흔들려요. 가닥이 빛과 눈의 반벡터에 직각인 줄에 흰 광택 띠가 서고 그 아래로 머리색의 둘째 띠가 따라와 머리가 흔들릴 때마다 오르내리며, 9초마다 보이지 않는 빗이 내려가 빗살 자리를 가르고 지나간 자리를 더 매끄럽고 반짝이게 해요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-hair-gloss","type":"code","name":"hair-gloss","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wave=0..1, Shine=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wave","min":0,"max":1},{"name":"Shine","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1831,"detail":0.0305,"edges":0.0431,"complexity":2.5214,"coverage":0.9825,"colour":0.1258,"drift":0.1122},"knobResponse":[0.2098,0.1537,0.1722,0.1466]},{"slug":"hair-oil","title":"Hair Oil","family":"cosmetic","round":37,"note":"청록 머리결이 위에서 아래까지 흘러내리며 두 번 갈라져 끝에서는 스무 묶음이 되고, 그 위를 카지야-케이 광택 띠가 오르내려요. 금색 오일 방울이 위쪽에 떨어져 가닥을 따라 미끄러지다 갈림길에서 둘로 나뉘고, 방울이 지나간 가닥은 한 톤 짙어지며 광택이 여섯 배 날카로워진 채 13초에 반쯤 흐려져요. K3 은 1초에 떨어지는 방울을 4개까지 늘리고, 누르면 방울 12개가 위에서 한꺼번에 흘러내려요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-hair-oil","type":"code","name":"hair-oil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=0.5..4, Wave=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":0.5,"max":4},{"name":"Wave","min":-1,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.3092,"detail":0.0865,"edges":0.3007,"complexity":2.6843,"coverage":0.7924,"colour":0.1708,"drift":0.1096},"knobResponse":[0.1623,0.2029,0.0681,0.2493]},{"slug":"hairy-ball","title":"Hairy Ball","family":"noise","round":28,"note":"위에는 털 난 공, 아래에는 털 난 도넛이 빛을 받으며 돌아요. 공은 어떻게 빗어도 털이 갈 데 없는 가마가 하나나 둘 금빛으로 남고, 도넛은 한 바퀴 매끈하게 빗겨요. 귀퉁이의 2 와 0 은 둘의 오일러 지표예요. 누르면 둘 다 다시 빗어서 가마가 다른 자리로 뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-hairy-ball","type":"code","name":"hairy-ball","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=8..13, Comb=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":8,"max":13},{"name":"Comb","min":-1,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":1.5705,"detail":0.1196,"edges":0.4915,"complexity":1.6126,"coverage":0.5237,"colour":0.1866,"drift":0.0881},"knobResponse":[0.0995,0.1196,0.1223,0.076]},{"slug":"halftone","title":"Halftone","family":"print","round":2,"note":"떠도는 등불 넷이 비추는 저녁 하늘을 잉크마다 각도가 다른 망점으로 찍어요. 점은 농도만큼 자라고 줄며, K1 이 CMY, 리소, 벤데이, 신문 잉크를 골라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-halftone","type":"code","name":"halftone","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Inks=0..3, Speed=0.1..5, Screen=8..13, Turn=0..30","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Inks","min":0,"max":3},{"name":"Speed","min":0.1,"max":5},{"name":"Screen","min":8,"max":13},{"name":"Turn","min":0,"max":30}],"start":[0,2,8,0.06],"measures":{"motion":0.0294,"detail":0.0277,"edges":0.6406,"complexity":0.1753,"coverage":0.9983,"colour":0.4355,"drift":0.0403},"knobResponse":[0.2427,0.1303,0.1431,0.1473]},{"slug":"ham-sandwich","title":"Ham Sandwich","family":"topology","round":44,"note":"청록 빵 구름과 자홍 햄 구름이 서로를 돌며 늘었다 갈라졌다 합쳐지고, 굵은 칼 하나가 프레임마다 두 구름을 똑같이 반씩 나눠요. 칼 한쪽은 밝고 다른 쪽은 어두워서, 칼이 돌면 밝은 쪽이 통째로 뒤집혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ham-sandwich","type":"code","name":"ham-sandwich","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..6, Thin=0..1, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":6},{"name":"Thin","min":0,"max":1},{"name":"Scatter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4325,"detail":0.322,"edges":1,"complexity":0.1735,"coverage":0.5292,"colour":0.3956,"drift":0.3705},"knobResponse":[0.0726,0.342,0.1452,0.2773]},{"slug":"hammersley-lines","title":"Hammersley Lines","family":"algo","round":32,"note":"왼쪽 아래를 원점으로 점이 빗방울처럼 하나씩 떨어져 쌓여요. 원점에서 그 칸까지의 상자 안에서 오른쪽 위로 이어지는 가장 긴 점 사슬의 길이로 띠를 칠해서, 점마다 꺾이는 계단 등고선이 쌍곡선 xy = 일정 꼴로 모여요. 오른쪽 위 모서리까지 가장 긴 사슬은 금빛 길이에요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-hammersley-lines","type":"code","name":"hammersley-lines","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Points=200..1000, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Points","min":200,"max":1000},{"name":"Bands","min":0,"max":1}],"start":[0,2,200,0.06],"measures":{"motion":0.4589,"detail":0.1005,"edges":0.9193,"complexity":0.242,"coverage":0.9226,"colour":0.2106,"drift":0.1453},"knobResponse":[0.1723,0.2043,0.2559,0.3087]},{"slug":"hanging-chain","title":"Hanging Chain","family":"physics","round":58,"note":"구슬 32개짜리 사슬이 윗줄 가운데에 매달려 J0 베셀 모양으로 흔들리고, 뒤에 남는 긴 노출이 흔들린 자리를 채워 봉투를 그려요. Mode 를 5 로 돌리면 자유단에서 3%, 14%, 34%, 62% 높이에 노란 눈금이 서고, 봉투가 그 네 자리에서 조여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hanging-chain","type":"code","name":"hanging-chain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=1..5, Mix=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":1,"max":5},{"name":"Mix","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3331,"detail":0.0297,"edges":0.3478,"complexity":0.7957,"coverage":0.3324,"colour":0.1445,"drift":0.0482},"knobResponse":[0.0569,0.0622,0.0762,0.0808]},{"slug":"hanging-line","title":"Hanging Line","family":"type","round":67,"note":"김소월 「진달래꽃」 94 음절이 안상수체를 본떠 직선과 원으로 그린 자모로 한 자모씩 쳐지며 윗줄에 매달려 아랫단이 들쭉날쭉하고, Frame 노브를 올리면 음절마다 같은 13×13 네모 칸에 늘려 담겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hanging-line","type":"code","name":"hanging-line","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=1..2, Frame=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":1,"max":2},{"name":"Frame","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.6878,"detail":0.0986,"edges":0.9511,"complexity":0.128,"coverage":0.1312,"colour":0.1358,"drift":0.0958},"knobResponse":[0.0394,0.1027,0.1151,0.1354]},{"slug":"hanging-scroll","title":"Hanging Scroll","family":"paper","round":23,"note":"어두운 도코노마 벽의 못에 족자가 걸리고, 아래 굴대가 내려가며 비단 표구 속 상아빛 종이에 그린 먹 산수를 한 줄씩 드러내요. 안개 낀 봉우리 아래 소나무와 폭포, 초가와 쪽배가 있고 붉은 낙관이 찍혀 있어요. 외풍에 조금 흔들리다 아래부터 말려 올라가면 바람 맞는 대나무가 내려오고, 달 아래 홍매와 파도 위 학이 뒤를 이어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-hanging-scroll","type":"code","name":"hanging-scroll","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Painting=0..3, Ink=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Painting","min":0,"max":3},{"name":"Ink","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.177,"detail":0.0295,"edges":0.2326,"complexity":1.3758,"coverage":0.4677,"colour":0.1211,"drift":0.2049},"knobResponse":[0.0845,0.2,0.0646,0.0324]},{"slug":"hard-squares","title":"Hard Squares","family":"particle","round":58,"note":"서로 닿을 수 없는 입자가 LED 위에 켜졌다 꺼지는데, 활동도가 아래로 갈수록 e^6 배까지 커져서 위는 드문 기체로 반짝이고, 활동도가 3.796 을 넘는 104번 줄 아래에서는 청록과 금색 두 부분격자의 바둑판 결정으로 얼어요. 결정의 영역은 몇 분에 걸쳐 굵어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hard-squares","type":"code","name":"hard-squares","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gravity=6..16, Activity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gravity","min":6,"max":16},{"name":"Activity","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.3409,"detail":0.3257,"edges":0.4003,"complexity":0.1595,"coverage":0.5876,"colour":0.313,"drift":0.0265},"knobResponse":[0.1202,0.0768,0.0943,0.1439]},{"slug":"harmonograph","title":"Harmonograph","family":"line","round":1,"note":"단순한 비에서 조금씩 어긋난 진자 셋이 닫히지 않는 그림을 그리고, 멎어 가며 가운데로 감겨 들어가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-harmonograph","type":"code","name":"harmonograph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..4, Ratio=0..7, Damping=0.02..0.4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":4},{"name":"Ratio","min":0,"max":7},{"name":"Damping","min":0.02,"max":0.4}],"start":[0,2,0,0.06],"measures":{"motion":0.0325,"detail":0.0469,"edges":0.3334,"complexity":0.8432,"coverage":0.2444,"colour":0.1802,"drift":0.053},"knobResponse":[0.0712,0.0419,0.0758,0.0561]},{"slug":"harp","title":"Harp","family":"music","round":16,"note":"무대에 선 페달 하프가 패널 높이를 다 채우고, 보이지 않는 하프 주자가 뜯은 줄이 렌즈 꼴로 번졌다가 잦아들어요. K3 은 펼친화음, 굴린 화음, 하모닉스, 글리산도 가운데 하나를 고르고, K1 을 누르면 29줄을 다 훑는 글리산도가 올라갔다 내려와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-harp","type":"code","name":"harp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Tempo=0.5..3.5, Figure=0..3, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Tempo","min":0.5,"max":3.5},{"name":"Figure","min":0,"max":3},{"name":"Damp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.151,"detail":0.0758,"edges":0.4257,"complexity":1.512,"coverage":0.8852,"colour":0.2261,"drift":0.0747},"knobResponse":[0.0708,0.0671,0.0617,0.0595]},{"slug":"hat-monotile","title":"Hat Monotile","family":"cells","round":51,"note":"13각형 타일 하나인 모자가 메타타일 치환이 감싸는 차례대로 덩이째 패널을 채우고, 거울에 비친 모자는 여덟에 하나꼴로 주황에 서요. 되풀이하지 않는 7,921장 조각 위로 창이 흘러가는 동안 색의 물결이 같은 모자들을 한 단계, 두 단계 큰 덩이로 다시 묶어요. K3 은 모자 크기, K4 는 같은 타일링의 변을 두 길이로 다시 재어 혜성에서 거북과 모자를 지나 갈매기표 모양까지 바꾸는 Tile(a, b) 예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hat-monotile","type":"code","name":"hat-monotile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=9..16, Shape=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":9,"max":16},{"name":"Shape","min":-1,"max":1}],"start":[0,2,9,0.06],"measures":{"motion":1.1786,"detail":0.3664,"edges":1,"complexity":0.3378,"coverage":0.6188,"colour":0.629,"drift":0.0817},"knobResponse":[0.4026,0.3923,0.4063,0.3702]},{"slug":"haunted-manor","title":"Haunted Manor","family":"halloween","round":42,"note":"보라 폭풍 아래 언덕 위에 첨탑이 굽은 낡은 저택과 죽은 나무가 서 있고, 비가 비스듬히 쏟아지다가 몇 초마다 갈래 친 번개가 내리쳐 하늘이 번쩍이고 집은 새까만 그림자가 돼요. 주황과 독한 초록 창이 깜빡이고, 창 하나에 사람 그림자가 지나가거나 덧문이 쾅 닫혀요. 젖은 땅이 아래층 창을 일렁이며 비춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-haunted-manor","type":"code","name":"haunted-manor","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Storm=0..1, Lights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Storm","min":0,"max":1},{"name":"Lights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6288,"detail":0.0353,"edges":0.6384,"complexity":0.7403,"coverage":0.7619,"colour":0.17,"drift":0.2715},"knobResponse":[0.0893,0.0581,0.0354,0.0321]},{"slug":"haunted-swing","title":"Haunted Swing","family":"halloween","round":44,"note":"보랏빛 밤에 옆에서 본 그네 틀에서 빈 판자 그네가 혼자 흔들려요. 가끔 초록 안개 손이 지나가는 그네를 뒤에서 밀고, 같은 가로대의 뒤 그네가 가만히 있다가 따라 흔들리기 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-haunted-swing","type":"code","name":"haunted-swing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Coupling=0.2..1, Haunt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coupling","min":0.2,"max":1},{"name":"Haunt","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.363,"detail":0.0399,"edges":0.626,"complexity":0.172,"coverage":0.5089,"colour":0.0969,"drift":0.046},"knobResponse":[0.0356,0.0447,0.0396,0.0256]},{"slug":"hawkes-process","title":"Hawkes Process","family":"rhythm","round":59,"note":"네 갈래 호크스 과정의 사건이 128줄을 따라 내려가고, 갈래마다 강도가 사건 때마다 부풀었다 잦아드는 띠로 채워져요. 자식 사건은 부모와 선으로 이어져서 무리 나무가 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hawkes-process","type":"code","name":"hawkes-process","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Branching=0.7..0.95, Decay=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Branching","min":0.7,"max":0.95},{"name":"Decay","min":2,"max":8}],"start":[0,2,0.7,2],"measures":{"motion":0.8669,"detail":0.0554,"edges":0.4465,"complexity":0.786,"coverage":0.4621,"colour":0.1293,"drift":0.1291},"knobResponse":[0.0527,0.1082,0.2793,0.0913]},{"slug":"head-wave","title":"Head Wave","family":"physics","round":81,"note":"느린 지각 밑 1.35배 빠른 맨틀의 경계를 타고 온 머리파가 곧은 원뿔 앞선으로 원형 앞선을 앞질러 올라와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-head-wave","type":"code","name":"head-wave","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=1.35..2.5, Height=2..50","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":1.35,"max":2.5},{"name":"Height","min":2,"max":50}],"start":[0,2,1.35,2],"measures":{"motion":1.7435,"detail":0.1971,"edges":0.1435,"complexity":1.9841,"coverage":0.8918,"colour":0.3956,"drift":0.0377},"knobResponse":[0.3029,0.2159,0.206,0.2492]},{"slug":"headless-rider","title":"Headless Rider","family":"halloween","round":48,"note":"큰 달 앞을 머리 없는 기수가 검은 그림자로 달리고, 말이 네 박자 습보로 다리를 모았다 뻗으며 흙먼지와 불티를 차올리는 사이 기수가 불붙은 호박을 높이 던져 앞길에서 터뜨려요. K3 은 나무 수, K4 는 달빛 안개이고, K1 을 누르면 바로 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-headless-rider","type":"code","name":"headless-rider","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Woods=0..1, Mist=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Woods","min":0,"max":1},{"name":"Mist","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.759,"detail":0.0482,"edges":0.4609,"complexity":0.2465,"coverage":0.8197,"colour":0.1505,"drift":0.0725},"knobResponse":[0.0773,0.0641,0.0497,0.0479]},{"slug":"heawood-torus","title":"Heawood Torus","family":"topology","round":36,"note":"세로로 긴 토러스가 천천히 돌며 헤우드의 지도를 보여 줘요. 일곱 나라가 저마다 나머지 여섯과 모두 맞닿아서, 구 위의 지도와 달리 이 지도는 일곱 색이 있어야 칠해져요. K3 은 구멍을 넓혀 굵은 관을 가는 고리로 만들고, K1 을 누르면 여섯 초 동안 일곱 수도와 그 사이 길 21개가 흰 선으로 그려져요.","why":"일곱 색으로 칠한 토러스가 돌아요. 색면이 커서 멀리서도 읽혀요.","block":0,"ramped":false,"layer":{"id":"layer-heawood-torus","type":"code","name":"heawood-torus","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hole=0..1, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hole","min":0,"max":1},{"name":"Tilt","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4823,"detail":0.0527,"edges":0.4488,"complexity":0.5038,"coverage":0.538,"colour":0.6204,"drift":0.3781},"knobResponse":[0.4775,0.281,0.1318,0.1492]},{"slug":"heesch-tiles","title":"Heesch Tiles","family":"cells","round":62,"note":"가장자리가 쉬지 않고 휘는 타일 하나가 틈도 겹침도 없이 패널을 덮어요. 짝지은 변은 헤슈가 붙인 이름 T, C, G, C3, C4 대로 서로 옮겨 붙고, 8초마다 다음 형이 위에서부터 한 장씩 덮어 오며, 돌거나 뒤집힌 복사본은 색이 달라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-heesch-tiles","type":"code","name":"heesch-tiles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Type=0..5, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Type","min":0,"max":5},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2034,"detail":0.0955,"edges":0.4513,"complexity":1.2,"coverage":0.8946,"colour":0.4574,"drift":0.1158},"knobResponse":[0.3386,0.2065,0.2554,0.2536]},{"slug":"hegselmann-krause","title":"Hegselmann-Krause","family":"sim","round":76,"note":"의견 400개가 ε 안의 이웃 평균으로 옮겨 가는 걸음을 위에서 아래로 적어, 흩어진 빛이 몇 갈래 강으로 모여 얼어붙어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hegselmann-krause","type":"code","name":"hegselmann-krause","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Epsilon=0.03..0.3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Epsilon","min":0.03,"max":0.3}],"start":[0,2,0,0.06],"measures":{"motion":0.0784,"detail":0.051,"edges":0.4377,"complexity":0.9178,"coverage":0.4662,"colour":0.186,"drift":0.1123},"knobResponse":[0.1128,0.0638,0.1258,0.1275]},{"slug":"hellschreiber","title":"Hellschreiber","family":"type","round":70,"note":"무선으로 온 글자가 한 열씩 아래에서 위로 종이 테이프에 두 벌 찍히고, 낱말 사이에서 잘린 띠가 양식지에 한 줄씩 붙으며, 수신기 시계가 어긋나면 글줄이 띠를 타고 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hellschreiber","type":"code","name":"hellschreiber","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Noise=0..1, Drift=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":0,"max":1},{"name":"Drift","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.478,"detail":0.1715,"edges":0.6347,"complexity":0.8955,"coverage":1,"colour":0.1406,"drift":0.096},"knobResponse":[0.1222,0.0523,0.1193,0.2024]},{"slug":"helter-skelter","title":"Helter Skelter","family":"fair","round":19,"note":"밤 장터의 헬터 스켈터가 128줄을 다 써요. 사람들이 탑 안 계단을 올라 작은 창에 비치고, 꼭대기에서 매트에 앉아 전구 체이스와 함께 탑을 돌아 미끄러져 내려온 뒤 매트를 들고 아래 문으로 돌아가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-helter-skelter","type":"code","name":"helter-skelter","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Bulbs=0..1, Speed=0.2..3, Turns=3..6, Stripes=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Bulbs","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":3,"max":6},{"name":"Stripes","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1978,"detail":0.0529,"edges":0.4142,"complexity":1.5797,"coverage":0.8591,"colour":0.2542,"drift":0.0688},"knobResponse":[0.0829,0.0365,0.0808,0.0347]},{"slug":"hex-theorem","title":"Hex Theorem","family":"cells","round":55,"note":"긴 대각선으로 세운 헥스 판에 칸이 하나씩 무작위로 차다가 한 색의 사슬이 제 두 변을 잇는 순간 그 사슬이 밝아지고, 판이 다 차면 진 색이 제 두 변에서 밀려 들어오다 사슬 앞에서 멈추는 사이 게일의 길이 두 색 사이 이음매를 따라 아래 꼭짓점에서 이긴 쪽 꼭짓점까지 하얗게 그어져요. K3 은 판의 한 변(7~15칸), K4 는 한 색이 칸을 가져갈 확률(0.25~0.75)이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hex-theorem","type":"code","name":"hex-theorem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=7..15, Bias=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":7,"max":15},{"name":"Bias","min":-1,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.1217,"detail":0.0977,"edges":0.72,"complexity":0.3967,"coverage":0.4082,"colour":0.3086,"drift":0.1603},"knobResponse":[0.1295,0.1334,0.1528,0.1015]},{"slug":"hexachordal-theorem","title":"Hexachordal Theorem","family":"rhythm","round":70,"note":"12박 고리의 여섯 온셋과 나머지 여섯이 위아래 고리에서 번갈아 울리고, 한 바퀴마다 온셋 하나가 옆으로 옮겨도 사이의 거리 막대는 늘 거울처럼 같아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hexachordal-theorem","type":"code","name":"hexachordal-theorem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pulses=12..20, Uneven=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pulses","min":12,"max":20},{"name":"Uneven","min":0,"max":3}],"start":[0,2,12,0.06],"measures":{"motion":0.2392,"detail":0.0729,"edges":0.8805,"complexity":0.3531,"coverage":0.2041,"colour":0.1574,"drift":0.0548},"knobResponse":[0.0535,0.0359,0.0907,0.0628]},{"slug":"hexagrammum-mysticum","title":"Hexagrammum Mysticum","family":"line","round":58,"note":"타원 위를 미끄러지는 여섯 점의 육각형 60개가 1초에 하나씩 그려져요. 변이 마주 보는 변과 만날 때까지 뻗어 세 점에 고리가 켜지면 그 셋을 지나는 파스칼 선이 하얗게 번쩍이고, 세 번째 육각형마다 같은 색 세 선이 만나는 슈타이너 점이 금빛으로 피어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hexagrammum-mysticum","type":"code","name":"hexagrammum-mysticum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=12..60, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":12,"max":60},{"name":"Spread","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.2964,"detail":0.0746,"edges":0.3901,"complexity":1.1529,"coverage":0.2916,"colour":0.1309,"drift":0.0816},"knobResponse":[0.0489,0.094,0.0872,0.1143]},{"slug":"hexatic-phase","title":"Hexatic Phase","family":"particle","round":37,"note":"단단한 원판 440개가 주기 경계 상자 안에서 사건 사슬 몬테카를로로 밀치고, 원판마다 둘레의 육각 격자가 가리키는 쪽에 따라 색을 입어요. 색상환 한 바퀴가 격자 회전 60도라서 결정 조각이 한 색 덩어리로 헤엄치고 합쳐지며 돌고, 이웃이 다섯인 원판은 흰 점, 일곱인 원판은 흰 고리로 결정 경계를 따라 줄지어요. K3 은 채움 몫을 0.68 의 액체에서 0.76 의 고체까지 올리고, 누르면 상자가 녹았다가 다시 굳어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-hexatic-phase","type":"code","name":"hexatic-phase","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=0.68..0.76, Cells=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":0.68,"max":0.76},{"name":"Cells","min":0,"max":1}],"start":[0,2,0.68,0.06],"measures":{"motion":2.3076,"detail":0.1862,"edges":0.5515,"complexity":2.0903,"coverage":0.6781,"colour":0.3428,"drift":0.1672},"knobResponse":[0.1472,0.2305,0.3425,0.068]},{"slug":"high-dive","title":"High Dive","family":"sport","round":23,"note":"밤의 실내 다이빙장을 옆에서 봐요. 다이버가 콘크리트 타워의 지그재그 계단을 올라 10 m 플랫폼 조명 아래 서고, 1.6초 동안 공중제비를 돌며 떨어져 물에 들어가면 물속에 기포 기둥이 오르고 전광판에 심판 일곱 명의 점수가 떠요. K3 이 앞으로 뛰기부터 세 바퀴 반과 비틀기까지 다이빙을 골라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-high-dive","type":"code","name":"high-dive","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Pool=0..1, Speed=0.2..3, Dive=0..4, Lights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Pool","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dive","min":0,"max":4},{"name":"Lights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3915,"detail":0.0721,"edges":0.2796,"complexity":1.8967,"coverage":0.7436,"colour":0.2296,"drift":0.0344},"knobResponse":[0.0986,0.0554,0.0399,0.1523]},{"slug":"high-striker","title":"High Striker","family":"fair","round":20,"note":"밤 장터의 하이 스트라이커가 128줄을 다 써요. 줄 선 사람들이 차례로 망치를 내리치면 퍽이 실제 중력으로 레일을 오르며 눈금을 켜다가 떨어지고, 세게 친 판이나 K1 을 누른 판에는 꼭대기 놋쇠 종이 울려 전구가 깜박이고 하늘이 밝아져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-high-striker","type":"code","name":"high-striker","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Bulbs=0..1, Speed=0.2..3, Strength=60..130, Gravity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Bulbs","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strength","min":60,"max":130},{"name":"Gravity","min":-1,"max":1}],"start":[0,2,60,0.06],"measures":{"motion":0.2551,"detail":0.0819,"edges":0.4794,"complexity":1.4989,"coverage":0.8211,"colour":0.2622,"drift":0.1521},"knobResponse":[0.0547,0.0439,0.0765,0.0768]},{"slug":"hill-regions","title":"Hill's Regions","family":"particle","round":64,"note":"두 질량을 위아래로 세운 회전 좌표계에서 입자 일곱이 야코비 상수의 영속도 곡선 안에 갇혀 돌아요. Jacobi 를 내리면 L1 부터 L3 까지 목이 차례로 열려서 입자가 작은 질량 쪽으로 건너가고 패널 위로 빠져나가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hill-regions","type":"code","name":"hill-regions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Jacobi=0..4, Mass=0.1..0.5, Trail=2..10","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Jacobi","min":0,"max":4},{"name":"Mass","min":0.1,"max":0.5},{"name":"Trail","min":2,"max":10}],"start":[0,2,0.1,2],"measures":{"motion":0.0735,"detail":0.0825,"edges":0.3959,"complexity":1.2103,"coverage":0.5044,"colour":0.1558,"drift":0.0355},"knobResponse":[0.0868,0.1786,0.1652,0.0627]},{"slug":"hinged-dissection","title":"Hinged Dissection","family":"geometry","round":41,"note":"한 변 62 LED 의 정삼각형이 Dudeney 의 네 조각으로 잘려 세 경첩에 매달려 있어요. 삼각형이 패널 높이만 한 사슬로 펼쳐졌다가 넓이가 같은 한 변 40.8 LED 의 정사각형으로 접히고, 다시 삼각형으로 돌아와요. K3 은 두 모양에서 3초까지 멈춰 서게 하고, K4 는 조각을 사슬 가운데에서 7 LED 까지 밀어내 떼어 놓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hinged-dissection","type":"code","name":"hinged-dissection","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hold=0..3, Gap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hold","min":0,"max":3},{"name":"Gap","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4714,"detail":0.0277,"edges":0.5373,"complexity":0.0578,"coverage":0.1906,"colour":0.2874,"drift":0.2526},"knobResponse":[0.1089,0.1832,0.1806,0.1188]},{"slug":"hitomezashi","title":"Hitomezashi","family":"line","round":43,"note":"가로줄과 세로줄마다 한 땀씩 걸러 뜬 실땀이 평직 천을 쪽빛과 물빛 두 색 영역으로 나눠요. 줄 하나의 비트가 뒤집히면 그 줄의 땀이 한 칸씩 옮겨 가고 줄 한쪽의 색이 물결처럼 바뀌어요. 금빛 불은 가장 새로 닫힌 고리를 따라 돌아요. K3 은 땀 길이를 6 LED 에서 10 LED 로 늘리고, K4 는 닫힌 고리를 모두 금빛으로 켜고 패널 밖으로 나가는 실을 3분의 1 밝기로 낮춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hitomezashi","type":"code","name":"hitomezashi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cell=6..10, Loops=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cell","min":6,"max":10},{"name":"Loops","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.5647,"detail":0.3122,"edges":0.9656,"complexity":0.0999,"coverage":0.7954,"colour":0.3504,"drift":0.2476},"knobResponse":[0.1793,0.3582,0.3708,0.0766]},{"slug":"hodograph","title":"Hodograph","family":"physics","round":66,"note":"해 하나를 이심률이 다른 천체 셋이 케플러의 박자로 돌며 같은 시간 부채를 쓸고, 아래에서는 한 원점에서 그은 속도 화살의 끝이 원점에서 반지름의 e 배만큼 비켜 선 원을 따라 돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hodograph","type":"code","name":"hodograph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Eccentricity=0.6..0.95, Bodies=3..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Eccentricity","min":0.6,"max":0.95},{"name":"Bodies","min":3,"max":6}],"start":[0,2,0.6,3],"measures":{"motion":0.5795,"detail":0.0478,"edges":0.4372,"complexity":0.9711,"coverage":0.3217,"colour":0.147,"drift":0.1019},"knobResponse":[0.0596,0.0807,0.0861,0.1174]},{"slug":"hofstadter-butterfly","title":"Hofstadter Butterfly","family":"fractal","round":30,"note":"자기장 속 격자 전자의 에너지 띠를 가로에, 자속을 세로에 놓았어요. 띠 사이 틈마다 홀 전도도의 정수로 칠해 날개가 서고, 같은 밀도의 줄이 날개를 따라 흘러요.","why":"나비 모양은 좋은데 결이 도해처럼 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-hofstadter-butterfly","type":"code","name":"hofstadter-butterfly","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=16..64, Coupling=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":16,"max":64},{"name":"Coupling","min":-1,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.216,"detail":0.0564,"edges":0.3637,"complexity":0.928,"coverage":0.7618,"colour":0.4337,"drift":0.1658},"knobResponse":[0.2654,0.1807,0.0682,0.2004]},{"slug":"holditch-ring","title":"Holditch Ring","family":"line","round":61,"note":"길이가 정해진 현이 키 큰 볼록 곡선을 따라 한 바퀴 미끄러지는 동안, 현을 a 와 b 로 나누는 점이 금빛 자취를 남기고 곡선과 자취 사이의 고리와 가운데의 반축 a, b 타원이 같은 넓이만큼 함께 차올라요. 바퀴마다 곡선이 달걀, 경기장, 방패 꼴로 바뀌어 고리 모양은 달라져도 타원은 그대로예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-holditch-ring","type":"code","name":"holditch-ring","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Split=0.25..0.5, Chord=36..44","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Split","min":0.25,"max":0.5},{"name":"Chord","min":36,"max":44}],"start":[0,2,0.25,36],"measures":{"motion":0.1008,"detail":0.0482,"edges":0.5264,"complexity":0.6187,"coverage":0.7142,"colour":0.1841,"drift":0.1047},"knobResponse":[0.0525,0.0455,0.0373,0.0468]},{"slug":"hopf-fibration","title":"Hopf Fibration","family":"topology","round":29,"note":"3차원 구면을 채운 원들을 입체 사영해 원근으로 그려요. 같은 위도의 밑점에서 온 원들이 겹겹의 토러스로 소용돌이치고, 가운데 세로선이 무한을 지나는 원이에요. K3 은 토러스 수(5~7)이고, K1 을 누르면 두 원만 남아 한 번 얽힌 것이 보여요.","why":"가는 선이 엉켜 덩어리로 보여요.","block":1,"ramped":false,"layer":{"id":"layer-hopf-fibration","type":"code","name":"hopf-fibration","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rings=5..7, Fibres=14..17","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rings","min":5,"max":7},{"name":"Fibres","min":14,"max":17}],"start":[0,2,5,14],"measures":{"motion":1.6067,"detail":0.0653,"edges":0.2066,"complexity":1.8736,"coverage":0.5881,"colour":0.1771,"drift":0.0635},"knobResponse":[0.0967,0.1134,0.1017,0.0832]},{"slug":"hopfield-letters","title":"Hopfield Letters","family":"type","round":77,"note":"글자 넷을 기억한 홉필드 망이 잡음에 묻힌 단서를 뉴런 하나씩 뒤집어 글자로 되돌리고, 글자를 더 넣으면 어느 글자도 아닌 섞인 상태로 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hopfield-letters","type":"code","name":"hopfield-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Load=0..1, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Load","min":0,"max":1},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2329,"detail":0.0739,"edges":0.9648,"complexity":0.0974,"coverage":0.8135,"colour":0.4478,"drift":0.2357},"knobResponse":[0.2909,0.215,0.19,0.1747]},{"slug":"horse-in-motion","title":"Horse in Motion","family":"film","round":27,"note":"양쪽에 퍼포레이션이 뚫린 필름이 영사기 게이트를 한 칸씩 끊어 내려가고, 램프가 비추는 가운데 칸에서 머이브리지의 경주마가 열두 장의 사진으로 달려요. 위아래 칸은 어둠 속에 흐리게 다음 차례를 기다려요. K3 이 그레이하운드와 앵무새, 달리는 사람의 필름으로 갈아 끼우고, 누르면 필름이 게이트에 걸려 타요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-horse-in-motion","type":"code","name":"horse-in-motion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Subject=0..3, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Subject","min":0,"max":3},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0766,"detail":0.056,"edges":0.3551,"complexity":1.5938,"coverage":0.6083,"colour":0.0988,"drift":0.0453},"knobResponse":[0.0878,0.0582,0.1145,0.1659]},{"slug":"hough-transform","title":"Hough Transform","family":"algo","round":60,"note":"위 정사각형에 점이 하나씩 내려앉을 때마다 그 점의 사인 곡선이 아래 누산기로 왼쪽부터 쓸려 들어가요. 한 직선 위 점들의 곡선이 모두 만나는 봉우리를 골라 그 직선을 위에 같은 색으로 다시 그어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hough-transform","type":"code","name":"hough-transform","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=2..6, Noise=0.3..0.9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":2,"max":6},{"name":"Noise","min":0.3,"max":0.9}],"start":[0,2,2,0.3],"measures":{"motion":0.3135,"detail":0.0699,"edges":0.3939,"complexity":1.1003,"coverage":0.4086,"colour":0.1456,"drift":0.0499},"knobResponse":[0.0603,0.0767,0.0904,0.0905]},{"slug":"hourglass","title":"Hourglass","family":"time","round":2,"note":"LED 하나가 모래 한 알이에요. 두 LED 목으로 흘러 위 더미는 가운데부터 꺼지고 아래에는 원뿔이 쌓이며, 위가 비면 유리가 반 바퀴 돌아 뒤집혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-hourglass","type":"code","name":"hourglass","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sand=0..1, Flow=0.5..4, Glass=0..1, Layers=1..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sand","min":0,"max":1},{"name":"Flow","min":0.5,"max":4},{"name":"Glass","min":0,"max":1},{"name":"Layers","min":1,"max":6}],"start":[0,2,0,1],"measures":{"motion":0.0687,"detail":0.0755,"edges":0.7242,"complexity":0.1856,"coverage":0.3468,"colour":0.2248,"drift":0.051},"knobResponse":[0.0656,0.0293,0.076,0.03]},{"slug":"howling-wolf","title":"Howling Wolf","family":"halloween","round":46,"note":"큰 보름달 앞 바위 언덕의 검은 늑대가 고개를 들어 울고, 초록 소리 고리가 퍼지면 먼 능선의 무리가 차례로 화답해요. K1 은 달 색, K3 은 화답하는 늑대 수, K4 는 구름과 바람이고, K1 을 누르면 바로 울어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-howling-wolf","type":"code","name":"howling-wolf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pack=2..6, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pack","min":2,"max":6},{"name":"Wind","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2286,"detail":0.0366,"edges":0.2127,"complexity":0.7049,"coverage":0.664,"colour":0.2509,"drift":0.0242},"knobResponse":[0.1154,0.0316,0.018,0.0331]},{"slug":"huffman-tree","title":"Huffman Tree","family":"type","round":68,"note":"글의 기호를 세어 가장 가벼운 둘씩 묶은 나무가 꼭대기 뿌리까지 자라고, 그 갈래를 따라 글이 0과 1로 흘러 고정 길이 부호보다 짧은 비트 줄이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-huffman-tree","type":"code","name":"huffman-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Tie=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Tie","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.0764,"detail":0.0889,"edges":0.8168,"complexity":0.2122,"coverage":0.271,"colour":0.16,"drift":0.0736},"knobResponse":[0.0355,0.0503,0.0814,0.0392]},{"slug":"hunminjeongeum","title":"Hunminjeongeum","family":"type","round":65,"note":"해례본 제자해대로 기본자 ㄱ ㄴ ㅁ ㅅ ㅇ 에서 한 단 내려갈 때마다 새로 더한 획만 빛나며 자음 나무 다섯 열이 자라고, 아래에서는 ㆍ ㅡ ㅣ 가 모여 모음 여덟이 돼요","why":"","block":0,"ramped":false,"layer":{"id":"layer-hunminjeongeum","type":"code","name":"hunminjeongeum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Style=0..1, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Style","min":0,"max":1},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0957,"detail":0.082,"edges":0.6543,"complexity":0.4537,"coverage":0.2214,"colour":0.1608,"drift":0.0866},"knobResponse":[0.0414,0.1016,0.0278,0.0796]},{"slug":"huygens-clocks","title":"Huygens' Clocks","family":"rhythm","round":79,"note":"한 들보에 매단 긴 진자 시계 둘이 째깍일 때마다 번쩍이며 제 줄에 막대를 떨어뜨리고, 거의 같이 치던 째깍이 일곱 번쯤 흔들리는 사이 꼭 반 박자씩 엇갈려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-huygens-clocks","type":"code","name":"huygens-clocks","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Detune=-1..1, Coupling=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Detune","min":-1,"max":1},{"name":"Coupling","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6533,"detail":0.0424,"edges":0.5498,"complexity":0.2121,"coverage":0.2696,"colour":0.2269,"drift":0.081},"knobResponse":[0.0679,0.0478,0.0465,0.0421]},{"slug":"hydra-game","title":"Hydra Game","family":"algo","round":72,"note":"머리를 자를 때마다 한 칸 아래 마디에서 가지가 n 벌 돋아 히드라가 부채처럼 커져도, 위에 적힌 순서수는 매번 줄고 끝내 뿌리만 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hydra-game","type":"code","name":"hydra-game","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hydra=1..5, Strategy=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hydra","min":1,"max":5},{"name":"Strategy","min":0,"max":3}],"start":[0,2,1,0.06],"measures":{"motion":0.4857,"detail":0.0446,"edges":0.3999,"complexity":0.8981,"coverage":0.3082,"colour":0.1783,"drift":0.1422},"knobResponse":[0.0408,0.0531,0.0596,0.0538]},{"slug":"hydrogen-orbital","title":"Hydrogen Orbital","family":"physics","round":40,"note":"수소 원자 고유 상태의 확률 밀도에서 뽑은 점 수천 개가 z 축을 세운 구름으로 16초에 한 바퀴 돌아요. 점은 서로 닿지 않는 LED 하나씩이고 파동 함수의 부호로 두 색을 칠해 마디 평면과 원뿔이 검게 남아요. K3 은 5g xz³ 에서 6f xz² 까지 열두 궤도를 고르고, K4 를 0 으로 내리면 9 LED 두께의 단면이 되어 지름 마디가 검은 고리로 보여요.","why":"궤도가 LED 한 알 크기의 점 구름이라 면으로 안 보여요.","block":1,"ramped":false,"layer":{"id":"layer-hydrogen-orbital","type":"code","name":"hydrogen-orbital","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Orbital=1..12, Slab=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Orbital","min":1,"max":12},{"name":"Slab","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.5238,"detail":0.3552,"edges":1,"complexity":0.4739,"coverage":0.1998,"colour":0.2586,"drift":0.1043},"knobResponse":[0.1235,0.0855,0.1373,0.0806]},{"slug":"hyperbolic-band","title":"Hyperbolic Band","family":"space","round":28,"note":"칠각형이 한 꼭짓점에 셋씩 모인 쌍곡 평면을 띠 모형으로 세웠어요. 패널 너비 64 LED 에 평면의 폭이 다 들어가고, 쪽매는 띠를 따라 끝없이 올라가며 양옆 가장자리에서 한없이 작아져요. K3 이 {8,3}, {5,4}, {4,5}, {3,7} 로 쪽매를 바꾸고, 누르면 반 바퀴 돌아 제 모습으로 내려앉아요.","why":"패널을 꽉 채우고 결이 복잡해요(복잡도 2.13).","block":1,"ramped":false,"layer":{"id":"layer-hyperbolic-band","type":"code","name":"hyperbolic-band","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tiling=0..4, Lines=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tiling","min":0,"max":4},{"name":"Lines","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4373,"detail":0.1076,"edges":0.286,"complexity":2.1332,"coverage":0.9802,"colour":0.6419,"drift":0.0932},"knobResponse":[0.5855,0.187,0.2223,0.3482]},{"slug":"iceberg","title":"Iceberg","family":"polar","round":26,"note":"물높이에서 자른 빙산이 9분의 1만 물 위에 내밀고 펭귄을 얹은 채 너울에 흔들리다, 판이 떨어져 물보라를 일으켜요. 물 아래 몸은 푸른 얼음 줄무늬와 탄산처럼 오르는 거품 줄기로 패널 바닥까지 내려가요. K1 은 백야의 해에서 오로라 뜬 극야로, 버튼은 판을 떼어 내요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-iceberg","type":"code","name":"iceberg","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Shape=0..1, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Swell","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1332,"detail":0.0357,"edges":0.189,"complexity":1.9213,"coverage":0.9971,"colour":0.3059,"drift":0.0544},"knobResponse":[0.1811,0.05,0.05,0.0489]},{"slug":"imaginary-geometry","title":"Imaginary Geometry","family":"noise","round":55,"note":"패널 아래 가운데 한 점에서 가우스 자유장의 흐름선 열세 개가 각도 부채꼴로 떠나 위 가운데 한 점까지 오르는데, 각도가 큰 선이 늘 왼쪽에 머물고 두 선이 한 LED 안으로 붙으면 하나로 같이 가다가 다시 갈라질 뿐 서로 건너지 않아요. 장이 천천히 흘러서 선들이 렌즈처럼 벌어졌다가 땋은 다발로 모여요. K3 은 선이 얼마나 굽이치는지 정하는 κ(0.5~3), K4 는 부채꼴의 각도 폭이고, 단추를 누르면 새 장에서 부채꼴이 다시 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-imaginary-geometry","type":"code","name":"imaginary-geometry","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Kappa=0.5..3, Spread=4..6.2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Kappa","min":0.5,"max":3},{"name":"Spread","min":4,"max":6.2}],"start":[0,2,0.5,4],"measures":{"motion":1.2251,"detail":0.1433,"edges":0.7882,"complexity":1.3379,"coverage":0.353,"colour":0.395,"drift":0.145},"knobResponse":[0.209,0.1565,0.1709,0.1838]},{"slug":"implosion","title":"Implosion","family":"construction","round":26,"note":"새벽 하늘 아래 스무 층 아파트에 장약 섬광이 층마다 타고 내려오면, 탑이 꺾이며 제자리로 주저앉고 회황색 먼지구름이 꼭대기까지 끓어올라요. 타임랩스로 비계 속에 새 탑이 서고, K1 을 누르면 바로 발파해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-implosion","type":"code","name":"implosion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Storeys=20..30, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Storeys","min":20,"max":30},{"name":"Wind","min":-1,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.3241,"detail":0.034,"edges":0.2245,"complexity":1.918,"coverage":0.9298,"colour":0.1876,"drift":0.0773},"knobResponse":[0.3233,0.0558,0.0577,0.0486]},{"slug":"in-the-flash","title":"In the Flash","family":"halloween","round":50,"note":"비 오는 밤 들판에 번개가 칠 때마다 키 크고 마른 형체가 한 걸음씩 가까이 서 있고, 움직이는 모습은 한 번도 보이지 않다가 끝내 얼굴이 눈앞을 채운 뒤 두 눈만 어둠에 남아요. K3 은 비, K4 는 다가오는 걸음 수이고, K1 을 누르면 바로 번개가 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-in-the-flash","type":"code","name":"in-the-flash","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Approach=3..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rain","min":0,"max":1},{"name":"Approach","min":3,"max":8}],"start":[0,2,0,3],"measures":{"motion":0.5508,"detail":0.0144,"edges":0.1675,"complexity":0.2946,"coverage":0.4921,"colour":0.0573,"drift":0.3391},"knobResponse":[0.0339,0.0922,0.0431,0.1198]},{"slug":"incense","title":"Incense","family":"noise","round":15,"note":"향 연기가 실처럼 곧게 오르다 몇 줄 위에서 흔들리고, 곧 소용돌이로 흩어져 위로 퍼져요. 돌탑 위 역류 향꽂이에서는 무거운 연기가 돌을 타고 흘러내려 접시에 고여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-incense","type":"code","name":"incense","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sticks=1..3, Breeze=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sticks","min":1,"max":3},{"name":"Breeze","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2464,"detail":0.0379,"edges":0.3304,"complexity":1.0761,"coverage":0.3311,"colour":0.0945,"drift":0.0442},"knobResponse":[0.0522,0.0616,0.0686,0.0518]},{"slug":"indian-rope-trick","title":"Indian Rope Trick","family":"physics","round":64,"note":"세 마디 막대 사슬이 거꾸로 서서 패널 키를 다 채우고, 눈에 보이지 않을 만큼 작고 빠르게 떨리는 받침점 덕에 쓰러지지 않아요. 몇 초마다 톡 치면 흔들리다 수직으로 돌아오고, Shake 를 문턱 아래로 내리면 넘어져 받침 아래로 휘돌았다가 다시 세워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-indian-rope-trick","type":"code","name":"indian-rope-trick","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Shake=0..3, Links=3..6, Nudge=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Shake","min":0,"max":3},{"name":"Links","min":3,"max":6},{"name":"Nudge","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2513,"detail":0.0187,"edges":0.3205,"complexity":0.452,"coverage":0.145,"colour":0.1218,"drift":0.1037},"knobResponse":[0.0357,0.0881,0.0328,0.1237]},{"slug":"indras-pearls","title":"Indra's Pearls","family":"geometry","round":31,"note":"마스킷 조각의 클라인 군이 그리는 극한 집합이 두 흰 벽 사이로 128줄을 내려가요. 접한 원의 목걸이 사이로 진주가 세대마다 작아지고, μ 가 첨점 사이를 오가며 목이 조였다 풀리고 겹 소용돌이가 감겼다 풀려요. K1 을 누르면 진주가 세대 차례로 켜져요.","why":"패널을 꽉 채우고 고리가 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-indras-pearls","type":"code","name":"indras-pearls","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Zoom","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5032,"detail":0.058,"edges":0.429,"complexity":0.897,"coverage":1,"colour":0.18,"drift":0.2157},"knobResponse":[0.3262,0.2178,0.2586,0.2575]},{"slug":"infinity-series","title":"Infinity Series","family":"rhythm","round":38,"note":"페르 뇌르고르의 무한 수열이 네 줄 피아노 롤에 한 박에 1, 2, 4, 8음으로 떨어져 타격선에 닿아요. 박마다 네 줄이 함께 닿는데, 4음 줄은 1음 줄과 같은 음에, 2음과 8음 줄은 그 거울상에 닿아요. K3 은 한 박의 줄 수를 8 에서 40 으로 늘려 음을 길게 펴고, K4 는 수열의 더 먼 자리에서 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-infinity-series","type":"code","name":"infinity-series","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beat=8..40, Start=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beat","min":8,"max":40},{"name":"Start","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":1.2502,"detail":0.083,"edges":0.4948,"complexity":0.2954,"coverage":0.3381,"colour":0.176,"drift":0.0581},"knobResponse":[0.067,0.12,0.1058,0.141]},{"slug":"ink-traps","title":"Ink Traps","family":"type","round":70,"note":"신문 용지에 같은 글자를 위아래로 찍으면, 이음매에 잉크 트랩을 판 위 글자는 번진 잉크가 홈을 메워 그린 모양으로 남고 트랩 없는 아래 글자는 뾰족한 이음매부터 막혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ink-traps","type":"code","name":"ink-traps","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Letters=0..2, Spread=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Letters","min":0,"max":2},{"name":"Spread","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3084,"detail":0.0349,"edges":0.4938,"complexity":0.7243,"coverage":0.4998,"colour":0.2397,"drift":0.3553},"knobResponse":[0.1557,0.0581,0.1966,0.0911]},{"slug":"invasion-percolation","title":"Invasion Percolation","family":"sim","round":32,"note":"바닥 가운데 한 칸으로 들어온 침입 유체가 경계에서 문턱이 가장 낮은 칸을 하나씩 차지하며 위로 자라요. 차지한 차례대로 청록에서 보라로 물들고, 맨 윗줄과 끊겨 갇힌 방어 유체는 장미색으로 굳어요. 맨 윗줄에 닿으면 입구에서 거기까지 가장 짧은 통로가 금색으로 켜지고 새 문턱으로 다시 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-invasion-percolation","type":"code","name":"invasion-percolation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gravity=-1..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gravity","min":-1,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1366,"detail":0.0909,"edges":0.2189,"complexity":1.5161,"coverage":0.4669,"colour":0.1889,"drift":0.1552},"knobResponse":[0.0576,0.0663,0.1297,0.1267]},{"slug":"inverse-cascade","title":"Inverse Cascade","family":"noise","round":50,"note":"잔 소용돌이 잡음이 2초 만에 둥근 소용돌이로 모이고, 같은 쪽으로 도는 것끼리 감기며 합쳐져 점점 적고 커져요. 붉은 쪽과 남색 쪽이 도는 방향이에요. K3 은 처음 소용돌이의 크기, K4 는 가는 실을 지우는 점성이고, K1 을 누르면 새 잡음에서 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-inverse-cascade","type":"code","name":"inverse-cascade","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=-1..1, Viscosity=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":-1,"max":1},{"name":"Viscosity","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6482,"detail":0.1256,"edges":0.3553,"complexity":2.3404,"coverage":0.9857,"colour":0.3044,"drift":0.0747},"knobResponse":[0.2481,0.168,0.1569,0.1223]},{"slug":"inversions","title":"Inversions","family":"type","round":65,"note":"위아래로 쌓은 두 음절이 판째 반 바퀴 돌면 곰국이 논문으로 읽혀요. 라틴 글자는 MOM 이 WOW 가 되고 SWIMS 는 제자리로 와요","why":"","block":0,"ramped":false,"layer":{"id":"layer-inversions","type":"code","name":"inversions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..8, Weight=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":8},{"name":"Weight","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6508,"detail":0.0532,"edges":0.6361,"complexity":0.386,"coverage":0.3297,"colour":0.3701,"drift":0.2737},"knobResponse":[0.1796,0.2252,0.2528,0.2508]},{"slug":"ishihara-plate","title":"Ishihara Plate","family":"type","round":77,"note":"점으로 채운 판 두 장에 숫자가 제1형과 제2형 혼동선의 색으로 숨어 3초마다 바뀌고, 노브를 돌리면 그 눈에 맞는 판의 숫자가 바탕에 묻혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ishihara-plate","type":"code","name":"ishihara-plate","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Dichromacy=-1..1, Dots=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dichromacy","min":-1,"max":1},{"name":"Dots","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1337,"detail":0.324,"edges":0.9997,"complexity":0.5224,"coverage":0.4414,"colour":0.5708,"drift":0.0417},"knobResponse":[0.0604,0.085,0.1011,0.2438]},{"slug":"ising-interface","title":"Ising Interface","family":"noise","round":45,"note":"왼쪽은 위, 오른쪽은 아래로 붙잡힌 이징 자석이 임계 온도에서 청록과 남색으로 끓고, 바닥에서 꼭대기까지 건너가는 경계 하나가 프레임마다 밝은 실로 그려져요. 그 실을 크게 키우면 SLE(3) 이 되는 프랙털 곡선이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ising-interface","type":"code","name":"ising-interface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Temp=-0.15..0.3, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Temp","min":-0.15,"max":0.3},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.1333,"detail":0.0453,"edges":0.3666,"complexity":0.2595,"coverage":1,"colour":0.2647,"drift":0.0682},"knobResponse":[0.1415,0.1161,0.1525,0.0778]},{"slug":"isospectral-drums","title":"Isospectral Drums","family":"wave","round":39,"note":"모양이 다른 북 두 개가 위아래에서 같은 높이의 소리로 울려요. 반정사각형 일곱 장으로 지은 고든, 웹, 월퍼트의 북이라 고유값이 하나도 다르지 않고, 가운데 띠의 눈금이 그 고유값이에요. 북마다 제 노드선을 그리며 같은 박자로 떨어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-isospectral-drums","type":"code","name":"isospectral-drums","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=0..24, Beat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":0,"max":24},{"name":"Beat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2952,"detail":0.0452,"edges":0.3635,"complexity":0.7651,"coverage":0.3333,"colour":0.1729,"drift":0.0914},"knobResponse":[0.0911,0.0611,0.0587,0.04]},{"slug":"ivy","title":"Ivy","family":"growth","round":15,"note":"돌담을 타고 담쟁이가 꼭대기까지 올라요. 바람이 잎을 뒤집어 옅은 뒷면이 물결치고, 가을이면 잎이 노랑에서 진홍으로 물들어 떨어져요. 겨울에는 맨 줄기에 검푸른 열매가 남아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-ivy","type":"code","name":"ivy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Vines=2..6, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Vines","min":2,"max":6},{"name":"Wind","min":-1,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0893,"detail":0.1136,"edges":0.3366,"complexity":2.0732,"coverage":0.8558,"colour":0.304,"drift":0.0713},"knobResponse":[0.1737,0.0489,0.1412,0.1012]},{"slug":"izhikevich-network","title":"Izhikevich Network","family":"rhythm","round":63,"note":"이지케비치의 신경 세포 천 개가 쏜 스파이크가 2 ms 한 줄씩 위에서 내려와요. 흥분 세포는 하늘색, 억제 세포는 자홍색이고, 망이 함께 터질 때마다 가로 띠가 서서 8 Hz 리듬이 줄무늬로 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-izhikevich-network","type":"code","name":"izhikevich-network","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drive=-1.5..3, Inhibition=0.8..1.6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drive","min":-1.5,"max":3},{"name":"Inhibition","min":0.8,"max":1.6}],"start":[0,2,0,0.8],"measures":{"motion":3.1405,"detail":0.2201,"edges":1,"complexity":0.2115,"coverage":0.1929,"colour":0.2665,"drift":0.2134},"knobResponse":[0.1022,0.1979,0.2345,0.1599]},{"slug":"j-invariant","title":"J-Invariant","family":"fractal","round":29,"note":"클라인의 j 함수를 위 반평면에 칠해요. j 가 위쪽 값으로 보내는 삼각형은 옅은 금색, 아래쪽 값으로 보내는 삼각형은 짙은 파랑이라 같은 타일이 패널 아래 실수축으로 갈수록 잘게 되풀이되고, j 의 크기를 나눈 등고선 띠가 영점마다 흘러나와요. K3 을 돌리면 실수축 쪽으로 여덟 배까지 다가가고, K1 을 누르면 빛이 맨 위 타일부터 세대마다 아래로 번져요.","why":"가장 복잡한 화면 가운데 하나예요(복잡도 2.69).","block":1,"ramped":false,"layer":{"id":"layer-j-invariant","type":"code","name":"j-invariant","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=0..1, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":0,"max":1},{"name":"Bands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3718,"detail":0.0494,"edges":0.1733,"complexity":2.6926,"coverage":1,"colour":0.3996,"drift":0.1786},"knobResponse":[0.3542,0.2406,0.2621,0.0689]},{"slug":"jack-in-the-box","title":"Jack-in-the-Box","family":"halloween","round":51,"note":"주황 마름모를 두른 보라 깡통 상자의 손잡이가 저절로 돌다 뚜껑이 터지면, 용수철 끝의 호박 등 머리가 패널 위까지 솟았다가 출렁이며 흔들리고 천천히 상자로 돌아가 뚜껑이 닫혀요. K3 은 용수철의 단단함, K4 는 옆으로 흔들리는 정도이고, 단추를 누르면 바로 튀어나와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jack-in-the-box","type":"code","name":"jack-in-the-box","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spring=0..1, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spring","min":0,"max":1},{"name":"Wobble","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3939,"detail":0.0355,"edges":0.7221,"complexity":0.2437,"coverage":0.3539,"colour":0.2859,"drift":0.0966},"knobResponse":[0.0607,0.072,0.0508,0.0507]},{"slug":"jack-o-lantern","title":"Jack-o'-Lantern","family":"halloween","round":41,"note":"패널 아래 호박 등 속에서 촛불이 흔들리면 파낸 얼굴이 짙은 주황과 흰빛 사이를 오가며 깜빡여요. 구멍마다 빛줄기가 패널 위까지 뻗는데, 맑은 곳에서는 옅은 보라로 보이고 떠가는 안개 띠를 지날 때는 주황으로 타올라요. K3 은 파낸 얼굴 넷 가운데 하나를 고르고 K4 는 안개를 걷거나 짙게 하며, K1 을 누르면 촛불이 꺼져 얼굴이 숯불 빨강으로 식었다가 2.5초 만에 다시 붙어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jack-o-lantern","type":"code","name":"jack-o-lantern","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fire=0..1, Speed=0.2..3, Face=0..3, Fog=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fire","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Face","min":0,"max":3},{"name":"Fog","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4879,"detail":0.0529,"edges":0.8777,"complexity":0.1426,"coverage":0.6351,"colour":0.3633,"drift":0.1316},"knobResponse":[0.0829,0.1046,0.0764,0.1278]},{"slug":"jacobi-geodesics","title":"Jacobi Geodesics","family":"space","round":65,"note":"세 축이 다른 타원면이 패널 키로 서서 돌고, 배꼽점 하나에서 사방으로 쏜 측지선 36개가 몸을 감싸며 내려가 맞은편 배꼽점 한 점에 다시 모여요","why":"","block":0,"ramped":false,"layer":{"id":"layer-jacobi-geodesics","type":"code","name":"jacobi-geodesics","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Launch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Axes","min":0,"max":1},{"name":"Launch","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5615,"detail":0.0305,"edges":0.2087,"complexity":0.9746,"coverage":0.4731,"colour":0.1408,"drift":0.1338},"knobResponse":[0.0491,0.0811,0.0824,0.0519]},{"slug":"jacobs-ladder","title":"Jacob's Ladder","family":"light","round":6,"note":"두 막대가 가장 가까운 목에서 보랏빛 아크가 튀어, 벌어지는 V 를 타고 막대 끝까지 올라가 끊어져요. 위의 아크가 끝에 닿기 전에 목에서 다음 아크가 튀고, K4 를 올리면 지나간 아크가 사다리 가로대로 쌓여요.","why":"아크는 좋은데 전극이 사물로 같이 그려져요.","block":1,"ramped":false,"layer":{"id":"layer-jacobs-ladder","type":"code","name":"jacobs-ladder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Power=0.3..3, Spread=0..1, Exposure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Power","min":0.3,"max":3},{"name":"Spread","min":0,"max":1},{"name":"Exposure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8103,"detail":0.0208,"edges":0.2771,"complexity":0.702,"coverage":0.2778,"colour":0.0843,"drift":0.105},"knobResponse":[0.0479,0.0767,0.0696,0.0781]},{"slug":"jacquard","title":"Jacquard Loom","family":"textile","round":4,"note":"구멍 뚫린 카드가 한 장씩 내려와 날실을 들어 올리면 북이 씨실을 끌고 지나가고, 바디가 그 씨실을 쳐 넣어요. 아래로 짜여 내려가는 천에 카드 구멍이 적어 둔 다이아몬드가 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-jacquard","type":"code","name":"jacquard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.5..5, Card=1..4, Stripes=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.5,"max":5},{"name":"Card","min":1,"max":4},{"name":"Stripes","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.0063,"detail":0.2005,"edges":0.8201,"complexity":0.1835,"coverage":0.8529,"colour":0.5431,"drift":0.0411},"knobResponse":[0.3764,0.209,0.2197,0.1447]},{"slug":"jamo-assembly","title":"Jamo Assembly","family":"type","round":63,"note":"패널 가장자리에서 날아온 자모가 칸 모양대로 줄거나 늘며 한 블록에 잠겨, 모아쓰기 같은 낱말을 한 글자씩 모아 써요. 조각이 잠길 때마다 블록 옆의 코드 값이 U+AC00 에서 그만큼 올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jamo-assembly","type":"code","name":"jamo-assembly","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Flight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phrase","min":0,"max":7},{"name":"Flight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2782,"detail":0.0466,"edges":0.6988,"complexity":0.2383,"coverage":0.1407,"colour":0.1388,"drift":0.1083},"knobResponse":[0.0383,0.0797,0.2271,0.0529]},{"slug":"jelly","title":"Jelly","family":"physics","round":2,"note":"젤리마다 질량 18개를 용수철과 안쪽 압력으로 묶은 고리예요. 키 큰 병에 떨어져 눌린 채 쌓여 출렁이다가, 하나씩 통 튀어 올라 다른 젤리 위로 굴러떨어져요.","why":"덩어리 넷이 바닥에 쌓여 있는 시간이 길어요.","block":1,"ramped":false,"layer":{"id":"layer-jelly","type":"code","name":"jelly","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Gravity=-1..3, Softness=0..1, Count=4..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Gravity","min":-1,"max":3},{"name":"Softness","min":0,"max":1},{"name":"Count","min":4,"max":12}],"start":[0,2,0,4],"measures":{"motion":0.4127,"detail":0.0345,"edges":0.4341,"complexity":0.5229,"coverage":0.4923,"colour":0.4252,"drift":0.1653},"knobResponse":[0.2349,0.3804,0.1184,0.2314]},{"slug":"jelly-layers","title":"Jelly Layers","family":"cosmetic","round":40,"note":"투명한 젤리 매니큐어를 흰 바탕에 붓으로 한 겹씩 겹쳐 발라, 겹친 곳은 투과율이 곱해져 짙어지고 붓결은 몇 초 만에 평평해져요. 두 번 바르면 한 번은 패드가 가장 짙은 띠를 닦아 내고, 광택 창과 빛 띠는 늘 맨 위에 떠요. K3 은 한 겹의 짙기를 옅은 분홍에서 깊은 라즈베리까지 올리고, K4 는 광택을 무광 베일로 바꾸고, K1 을 누르면 다음 붓질이나 닦기가 바로 와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-jelly-layers","type":"code","name":"jelly-layers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=0.35..1.2, Matte=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":0.35,"max":1.2},{"name":"Matte","min":0,"max":1}],"start":[0,2,0.35,0.06],"measures":{"motion":0.053,"detail":0.0079,"edges":0.0069,"complexity":1.5162,"coverage":1,"colour":0.1911,"drift":0.0385},"knobResponse":[0.1664,0.0692,0.1547,0.0566]},{"slug":"johnson-mehl","title":"Johnson-Mehl","family":"cells","round":37,"note":"결정이 아무 때나 아무 데서 태어나 같은 빠르기로 원처럼 자라고, LED 마다 먼저 닿은 결정의 것이 돼요. 늦게 난 결정은 작고 둥글게 남아서 먼저 난 결정과 곧은 선이 아니라 쌍곡선 호에서 만나고, 한 상이 판을 다 채우면 다음 상이 그 위로 자라요. 위 12줄은 바뀐 몫을 아브라미 곡선과 나란히 그려요. K4 를 1로 돌리면 결정이 한꺼번에 태어나 경계가 곧은 보로노이가 되고, 누르면 다음 상이 바로 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-johnson-mehl","type":"code","name":"johnson-mehl","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rate=4..80, Mode=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rate","min":4,"max":80},{"name":"Mode","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0659,"detail":0.0824,"edges":0.8775,"complexity":0.3635,"coverage":0.9103,"colour":0.4567,"drift":0.1875},"knobResponse":[0.3746,0.1973,0.3888,0.3417]},{"slug":"jordan-curve","title":"Jordan Curve","family":"topology","round":60,"note":"패널을 채운 구불구불한 닫힌 곡선 위로 탐침이 돌아다니며 패널 끝까지 반직선을 쏘고, 곡선을 건넌 곳에 금색 점을 찍어 세요. 그 수가 홀수면 안의 색, 짝수면 밖의 색이 탐침에서부터 번져 안과 밖이 맞물린 두 땅으로 드러나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jordan-curve","type":"code","name":"jordan-curve","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tension=-1..1, Probes=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tension","min":-1,"max":1},{"name":"Probes","min":1,"max":4}],"start":[0,2,0,1],"measures":{"motion":0.3606,"detail":0.064,"edges":0.5302,"complexity":1.0767,"coverage":1,"colour":0.3592,"drift":0.0786},"knobResponse":[0.2209,0.2847,0.2184,0.1119]},{"slug":"josephus","title":"Josephus Problem","family":"rhythm","round":68,"note":"램프 n 개의 원을 손이 돌며 k 번째 박마다 하나씩 끄고, 아래 64줄 표에서 살아남는 자리가 톱니로 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-josephus","type":"code","name":"josephus","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Step=2..7, Circle=8..64","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Step","min":2,"max":7},{"name":"Circle","min":8,"max":64}],"start":[0,2,2,8],"measures":{"motion":0.2599,"detail":0.0789,"edges":0.7436,"complexity":0.7416,"coverage":0.4479,"colour":0.1382,"drift":0.059},"knobResponse":[0.0716,0.0544,0.1126,0.0634]},{"slug":"joukowsky-airfoil","title":"Joukowsky Airfoil","family":"physics","round":35,"note":"주콥스키 사상으로 원을 지나는 이상 흐름을 날개를 지나는 흐름으로 옮겼어요. 44줄 길이의 날개 위로 1초마다 맨 윗줄에서 놓은 염료 줄이 내려와 앞전의 붉은 정체점에서 갈라지고, 오른쪽 흡입면으로 간 반쪽이 뒷전에 12.6줄 먼저 닿아요. K3 은 받음각을 0도에서 15도로 올려 그 앞섬을 46줄까지 늘리고, K1 을 누르면 순환을 10초 동안 빼서 두 반쪽이 거의 같이 닿아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-joukowsky-airfoil","type":"code","name":"joukowsky-airfoil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Attack=0..15, Camber=0..0.12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Attack","min":0,"max":15},{"name":"Camber","min":0,"max":0.12}],"start":[0,2,0,0.06],"measures":{"motion":1.8048,"detail":0.0682,"edges":0.3096,"complexity":0.7976,"coverage":0.3578,"colour":0.2135,"drift":0.0573},"knobResponse":[0.061,0.1268,0.1391,0.1409]},{"slug":"kac-ring","title":"Kac Ring","family":"rhythm","round":44,"note":"64칸 고리를 도는 공이 표시된 변을 지날 때마다 밝고 어두운 색을 바꿔요. 한 줄이 한 걸음이라 128줄이 꼭 한 주기이고, 가운데 줄에서 고리가 통째로 뒤집혀요. 흰 선은 밝은 공의 몫, 점선은 그 몫이 1/2 로 가라앉는다는 예측이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kac-ring","type":"code","name":"kac-ring","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Marks=3..15, Dark=0..0.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Marks","min":3,"max":15},{"name":"Dark","min":0,"max":0.5}],"start":[0,2,3,0.06],"measures":{"motion":1.8966,"detail":0.1266,"edges":0.9572,"complexity":0.1495,"coverage":0.9688,"colour":0.4319,"drift":0.3012},"knobResponse":[0.2767,0.4506,0.3765,0.3765]},{"slug":"kaleidocycle","title":"Kaleidocycle","family":"space","round":43,"note":"이등변 사면체 여섯 개를 경첩으로 이은 고리가 쉬지 않고 제 몸을 뒤집으며 돌아요. 위 절반은 고리를 앞에서, 아래 절반은 뒤에서 본 모습이라 육각형으로 모인 면이 4분의 1 바퀴마다 금빛, 초록, 하늘색, 자홍 차례로 바뀌고, 가운데 구멍은 세 갈래 별로 열렸다 닫혀요. K3 은 사면체를 정사면체 8 개에서 12 개까지 짝수로 늘려 고리를 넓히고, K4 는 두 그림을 고리 축에서 70도까지 기울여 옆에서 보게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kaleidocycle","type":"code","name":"kaleidocycle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tetrahedra=6..12, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tetrahedra","min":6,"max":12},{"name":"Tilt","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.3713,"detail":0.0425,"edges":0.8245,"complexity":0.146,"coverage":0.4664,"colour":0.3304,"drift":0.1584},"knobResponse":[0.2044,0.1656,0.2092,0.1555]},{"slug":"kaleidoscope","title":"Kaleidoscope","family":"geometry","round":1,"note":"움직이는 선 세 벌이 유리 한 조각을 자르고 거울이 그 조각을 꽃으로 접어요. 조각 사이에 1 LED 검은 납선이 있어요.","why":"색 조각이 잘아서 무늬가 자잘해요.","block":1,"ramped":false,"layer":{"id":"layer-kaleidoscope","type":"code","name":"kaleidoscope","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.1..4, Segments=6..16, Twist=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.1,"max":4},{"name":"Segments","min":6,"max":16},{"name":"Twist","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.9384,"detail":0.1125,"edges":0.4099,"complexity":1.6131,"coverage":0.5499,"colour":0.359,"drift":0.2217},"knobResponse":[0.1659,0.2298,0.1535,0.1426]},{"slug":"kanizsa-letters","title":"Kanizsa Letters","family":"type","round":76,"note":"비스듬한 격자 위의 금빛 원판 32개가 팩맨처럼 돌다 하나씩 제자리로 돌면, 어느 LED 도 그리지 않은 테두리로 글자가 떠올랐다 흩어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kanizsa-letters","type":"code","name":"kanizsa-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gap=0.3..0.8, Period=5..14","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gap","min":0.3,"max":0.8},{"name":"Period","min":5,"max":14}],"start":[0,2,0.3,5],"measures":{"motion":0.1928,"detail":0.2196,"edges":0.9288,"complexity":0.1571,"coverage":0.4377,"colour":0.3466,"drift":0.1178},"knobResponse":[0.1759,0.1493,0.1333,0.0903]},{"slug":"kaprekar-routine","title":"Kaprekar's Routine","family":"type","round":63,"note":"네 자리 수의 숫자가 하나씩 날아와 내림차순으로 앉고, 그 줄이 반 바퀴 돌아 오름차순이 되어 빼져요. 차가 다음 줄이 되어 계산 종이가 아래로 이어지다가 6174 에서 금빛으로 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kaprekar-routine","type":"code","name":"kaprekar-routine","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Digits=4..7, Start=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Digits","min":4,"max":7},{"name":"Start","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.4626,"detail":0.0551,"edges":0.7647,"complexity":0.2265,"coverage":0.1759,"colour":0.1936,"drift":0.1328},"knobResponse":[0.0406,0.0845,0.0634,0.0508]},{"slug":"kari-culik","title":"Kari-Culik Tiles","family":"algo","round":35,"note":"카리의 왕 타일 14장이 되풀이 없이 판을 덮어요. 한 줄이 x 를 2 나 2/3 로 곱하는 긴 곱셈이라 위아래 변에는 비티 숫자가 파랑 마름모로, 옆 변에는 올림수가 초록이나 보라에서 금색까지의 마름모로 이어져요. K3 은 맨 윗줄의 x 를 바꿔 다른 타일링을 깔고, K1 을 누르면 3초 동안 타일이 4분의 1 칸씩 떨어져 한 장씩 보여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-kari-culik","type":"code","name":"kari-culik","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Start=0..1, Size=8..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Start","min":0,"max":1},{"name":"Size","min":8,"max":16}],"start":[0,2,0,8],"measures":{"motion":1.0596,"detail":0.333,"edges":1,"complexity":0.1114,"coverage":0.75,"colour":0.4775,"drift":0.0797},"knobResponse":[0.3661,0.4609,0.2299,0.3929]},{"slug":"karman-street","title":"Kármán Street","family":"sim","round":37,"note":"반대로 도는 점 소용돌이 두 줄이 반 간격씩 어긋난 채 128줄을 위에서 아래로 흘러가요. 왼쪽 줄은 아쿠아, 오른쪽 줄은 장밋빛 염료를 감아 나선을 만들고, 두 줄 사이 거리와 간격의 비가 폰 카르만의 0.2806 이면 거리가 버티며 두 염료가 금색으로 바뀌어요. 처음 비 0.34 에서는 보이지 않던 흔들림이 12~24초 만에 자라 소용돌이가 짝을 지어 흩어지고, 그 뒤에 새 거리가 깔려요. K4 는 그 비를 0.13 에서 0.53 까지 옮기고, 누르면 새 거리를 바로 깔아요.","why":"소용돌이가 작고 어두워요.","block":1,"ramped":false,"layer":{"id":"layer-karman-street","type":"code","name":"karman-street","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Vortices=4..8, Offset=-0.15..0.25","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Vortices","min":4,"max":8},{"name":"Offset","min":-0.15,"max":0.25}],"start":[0,2,4,0.06],"measures":{"motion":0.4917,"detail":0.0363,"edges":0.1472,"complexity":1.3625,"coverage":0.3791,"colour":0.1414,"drift":0.0598},"knobResponse":[0.1029,0.0901,0.0896,0.103]},{"slug":"kdv-solitons","title":"KdV Solitons","family":"wave","round":31,"note":"맨 윗줄이 지금의 물결이고 지난 줄이 아래로 흘러내려요. 자부스키와 크루스칼의 코사인이 반 초 만에 가파라지며 솔리톤 여덟으로 갈리고, 키 큰 솔리톤이 작은 것을 지나칠 때마다 마루가 옆으로 비켜요. K1 을 누르면 큰 솔리톤 하나가 떨어져 무리를 뚫고 달려요.","why":"어두운 바탕에 빛줄기가 엇갈려 지나가요. 잰 값이 프리셋과 두 번째로 가까워요.","block":0,"ramped":false,"layer":{"id":"layer-kdv-solitons","type":"code","name":"kdv-solitons","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dispersion=0..1, Start=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dispersion","min":0,"max":1},{"name":"Start","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5261,"detail":0.0597,"edges":0.2382,"complexity":1.5547,"coverage":0.8045,"colour":0.3345,"drift":0.2583},"knobResponse":[0.2224,0.1099,0.0581,0.2182]},{"slug":"kelvin-wake","title":"Kelvin Wake","family":"wave","round":34,"note":"고요한 물 위로 흰 거품 한 점이 아래에서 위로 올라가고, 그 뒤로 켈빈의 배 물결이 펼쳐져요. 물길을 가로지르는 굽은 가로 물마루와 비스듬한 짧은 발산 물결이 반각 19.47° 쐐기의 두 팔에서 만나 가장 밝은 첨점 줄을 이루고, 쐐기는 원천이 얼마나 빠르든 원천 뒤 90 LED 에서 패널 양옆에 닿아요. K3 은 원천을 빠르게 해 물결을 길게 늘이지만 쐐기의 각은 그대로예요.","why":"패널을 한 색으로 채워요(채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-kelvin-wake","type":"code","name":"kelvin-wake","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Velocity=1..1.7, Patch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Velocity","min":1,"max":1.7},{"name":"Patch","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.1485,"detail":0.0308,"edges":0.1674,"complexity":1.0448,"coverage":0.995,"colour":0.1633,"drift":0.0493},"knobResponse":[0.3266,0.0627,0.0628,0.0605]},{"slug":"kempe-chains","title":"Kempe Chains","family":"cells","round":49,"note":"떠다니는 나라들의 국경이 바뀌어도 지도는 네 색을 지켜요. 새 국경이 같은 색 둘을 붙이면 남은 색을 칠하고, 네 색이 다 둘러싸면 두 색의 켐프 사슬이 빛나며 색을 맞바꿔요. K3 은 나라 수, K4 는 나라 크기가 갈리는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kempe-chains","type":"code","name":"kempe-chains","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Countries=15..40, Sizes=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Countries","min":15,"max":40},{"name":"Sizes","min":0,"max":1}],"start":[0,2,15,0.06],"measures":{"motion":0.4174,"detail":0.06,"edges":0.9672,"complexity":0.091,"coverage":0.9353,"colour":0.6239,"drift":0.0616},"knobResponse":[0.5052,0.3067,0.3719,0.3523]},{"slug":"kettle","title":"Kettle","family":"kitchen","round":20,"note":"밤 부엌 조리대의 유리 전기 주전자가 128줄을 다 써요. 받침의 파란 LED 고리가 물을 밑에서 밝히는 동안 열판의 잔 기포가 떠올랐다 꺼지는 철을 지나 큰 기포가 들끓고, 김이 주둥이에서 패널 꼭대기까지 오르다가 스위치가 딸깍 꺼져요. K1 을 누르면 바로 켜거나 꺼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-kettle","type":"code","name":"kettle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Fill=1..1.7, Cold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fill","min":1,"max":1.7},{"name":"Cold","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2843,"detail":0.0449,"edges":0.2669,"complexity":1.5413,"coverage":0.6281,"colour":0.1671,"drift":0.1681},"knobResponse":[0.1034,0.0699,0.0403,0.056]},{"slug":"kibble-zurek-ions","title":"Kibble-Zurek Ions","family":"particle","round":64,"note":"패널 높이로 선 이온 30개의 사슬이 가로 가둠이 임계값 아래로 내려갈 때마다 지그재그로 꺾여요. 빨리 내릴수록 두 방향의 지그재그가 만나는 꼬임이 더 많이 얼고, 사슬 양옆으로 밀려 나가는 역사에 두 방향이 자홍과 초록으로, 꼬임이 노란 솔기로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kibble-zurek-ions","type":"code","name":"kibble-zurek-ions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Quench=0.2..3, Ions=30..40, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Quench","min":0.2,"max":3},{"name":"Ions","min":30,"max":40},{"name":"Heat","min":0,"max":1}],"start":[0,2,30,0.06],"measures":{"motion":0.5165,"detail":0.2031,"edges":0.9676,"complexity":0.3137,"coverage":0.2809,"colour":0.562,"drift":0.1864},"knobResponse":[0.2692,0.2626,0.2686,0.1597]},{"slug":"kinematogram","title":"Kinematogram","family":"type","round":80,"note":"패널 가득한 무작위 점 가운데 글자 안의 점만 위로, 바깥 점은 아래로 흘러서 어느 한 프레임에도 없는 낱말이 움직일 때만 서고, 점이 1초 멈추면 낱말도 점 사이로 사라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kinematogram","type":"code","name":"kinematogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Coherence=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":7},{"name":"Coherence","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.7154,"detail":0.264,"edges":1,"complexity":0.2447,"coverage":0.2064,"colour":0.1847,"drift":0.0521},"knobResponse":[0.0717,0.214,0.0989,0.2045]},{"slug":"kingfisher","title":"Kingfisher","family":"bird","round":20,"note":"강둑 단면이 오리나무 가지부터 강바닥 자갈까지 128줄을 다 써요. 물총새가 가지에서 머리를 까딱이며 물을 보다가 곧장 내리꽂혀 물보라와 거품 줄을 남기고, 피라미를 물고 올라와 가지에 두드린 뒤 삼켜요. K1 을 누르면 바로 뛰어들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-kingfisher","type":"code","name":"kingfisher","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Fish=6..60, Current=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fish","min":6,"max":60},{"name":"Current","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.0867,"detail":0.0496,"edges":0.2577,"complexity":2.0204,"coverage":0.9952,"colour":0.1732,"drift":0.0377},"knobResponse":[0.186,0.0476,0.0402,0.0555]},{"slug":"kingman-coalescent","title":"Kingman Coalescent","family":"data","round":39,"note":"64개체 모런 집단이 앞으로 살고, 패널은 지금 살아 있는 64개체의 가계도예요. 맨 아랫줄이 지금, 위로 갈수록 과거이고, 같은 조상의 자손이 붙어 서도록 열을 줄 세워서 좁은 블록이 위로 갈수록 합쳐지는 불꽃 그림이 돼요. 마지막 두 갈래가 만나는 데 걸리는 시간이 전체의 절반쯤이라 긴 이음매 하나가 위쪽을 가르고, 한 집안이 사라지면 공통 조상이 앞으로 뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-kingman-coalescent","type":"code","name":"kingman-coalescent","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Span=3..9, Speed=0.2..3, Width=1..4, Mutation=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Span","min":3,"max":9},{"name":"Speed","min":0.2,"max":3},{"name":"Width","min":1,"max":4},{"name":"Mutation","min":0,"max":1}],"start":[3,2,1,0.06],"measures":{"motion":1.2518,"detail":0.0417,"edges":0.3173,"complexity":1.0432,"coverage":0.967,"colour":0.4104,"drift":0.1027},"knobResponse":[0.1845,0.106,0.0643,0.2761]},{"slug":"kintsugi","title":"Kintsugi","family":"pottery","round":25,"note":"어두운 쪽빛 천 위의 청자 찻사발에 금이 가고, 조각들이 조금 벌어져 돌아요. 깨진 날에 붉은 옻과 금이 돈 다음 다시 붙어요. 위에 매달린 종이 등이 흔들리며 금빛 이음매에 반짝임을 지나가게 하고, K3 Mends 를 올릴수록 지나온 깨짐의 금빛 그물이 촘촘해져요. K1 을 누르면 사발이 바로 깨져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-kintsugi","type":"code","name":"kintsugi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glaze=0..1, Speed=0.2..3, Mends=2..8, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glaze","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mends","min":2,"max":8},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.1906,"detail":0.0509,"edges":0.2812,"complexity":2.0844,"coverage":0.9972,"colour":0.1903,"drift":0.136},"knobResponse":[0.0565,0.1068,0.0529,0.1171]},{"slug":"klein-sails","title":"Klein's Sails","family":"number","round":65,"note":"정수 격자가 쌍곡선을 따라 흐르고, 연분수 수렴분수를 꼭짓점 삼은 볼록 껍질 네 줄이 제 몸을 따라 미끄러지다 처음 그림으로 돌아와요","why":"","block":0,"ramped":false,"layer":{"id":"layer-klein-sails","type":"code","name":"klein-sails","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Number=0..5, Zoom=10..22","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":5},{"name":"Zoom","min":10,"max":22}],"start":[0,2,0,10],"measures":{"motion":0.2849,"detail":0.0834,"edges":0.4941,"complexity":1.038,"coverage":0.2246,"colour":0.136,"drift":0.0352},"knobResponse":[0.0458,0.0743,0.1422,0.0944]},{"slug":"knights-tour","title":"Knight's Tour","family":"algo","round":42,"note":"기사가 8×16 판을 Warnsdorff 규칙으로 돌며 칸 가운데를 잇는 한 LED 선을 남기고, 127번 뛰면 별 같은 그물이 다 짜여요. 마지막 칸에서 첫 칸으로 한 번에 뛸 수 있으면 금빛 선으로 닫히고, 아니면 두 끝 칸에 금빛 상자가 서요. K4 를 0.1 위로 돌리면 기사가 규칙을 어기고 아무 칸으로나 뛰다가 막혀서, 막힌 칸이 빨갛게 깜빡여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-knights-tour","type":"code","name":"knights-tour","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..12, Board=0..1, Stray=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":12},{"name":"Board","min":0,"max":1},{"name":"Stray","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.029,"detail":0.3132,"edges":0.848,"complexity":0.6559,"coverage":0.3475,"colour":0.3541,"drift":0.0377},"knobResponse":[0.1789,0.0496,0.2163,0.1825]},{"slug":"koebe-packing","title":"Koebe Packing","family":"cells","round":47,"note":"원마다 삼각분할의 이웃 원과만 맞닿은 세로 직사각형 원 배치예요. 1.2초마다 변이 뒤집히거나 원이 생기고 사라지면, 모든 원이 새 그래프가 허락하는 하나뿐인 배치로 부풀고 줄어들고 새 변이 흰빛으로 번쩍여요. K3 은 원 수, K4 는 그래프를 어두운 살로 보일지 흰 선으로 보일지예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-koebe-packing","type":"code","name":"koebe-packing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Circles=22..56, Graph=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Circles","min":22,"max":56},{"name":"Graph","min":0,"max":1}],"start":[0,2,22,0.06],"measures":{"motion":0.2073,"detail":0.1313,"edges":0.7425,"complexity":0.2586,"coverage":0.4982,"colour":0.5525,"drift":0.0981},"knobResponse":[0.3319,0.0922,0.2901,0.201]},{"slug":"kohonen-map","title":"Kohonen Map","family":"data","round":59,"note":"무작위로 엉킨 12×24 격자가 점 하나가 올 때마다 그쪽으로 끌려가며 하늘색에서 자홍으로 물든 천처럼 고리, 초승달, S 위에 펴져요. Lattice 노브를 끝까지 돌리면 288마디 사슬이 고리를 이리저리 접어 메워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kohonen-map","type":"code","name":"kohonen-map","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lattice=0..1, Radius=0.5..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lattice","min":0,"max":1},{"name":"Radius","min":0.5,"max":3}],"start":[0,2,0,0.5],"measures":{"motion":3.6399,"detail":0.0917,"edges":0.9607,"complexity":0.9588,"coverage":0.4369,"colour":0.2844,"drift":0.1914},"knobResponse":[0.0676,0.2116,0.1362,0.0924]},{"slug":"kolakoski","title":"Kolakoski","family":"number","round":35,"note":"제 런 길이 부호와 같은 1 과 2 의 수열이 열 단의 고드름으로 매달려요. 맨 아래 단은 3,000번 항부터 64항이 LED 하나씩 금색 1 과 보라 2 로 서고, 그 위 단마다 아래 단의 런을 만든 항이 런 너비로 앉아 같은 수열이 단마다 3분의 2 로 줄며 왼쪽으로 한 항씩 흘러요. K3 은 단을 16 까지 늘리고, K1 을 누르면 창이 10만 항 뒤로 건너뛰어 맨 위 눈금이 1 이 4 개 앞선 자리에서 2 가 46 개 앞선 자리로 옮겨요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-kolakoski","type":"code","name":"kolakoski","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bands=10..16, Falloff=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bands","min":10,"max":16},{"name":"Falloff","min":-1,"max":1}],"start":[0,2,10,0.06],"measures":{"motion":0.3357,"detail":0.1184,"edges":0.9202,"complexity":0.2363,"coverage":0.9144,"colour":0.3543,"drift":0.0962},"knobResponse":[0.3404,0.1812,0.286,0.2965]},{"slug":"kp-web","title":"KP Web","family":"wave","round":58,"note":"가는 빛줄기로 그린 KP 방정식의 선 솔리톤이 9초에 한 번씩 시간을 지나며, T 웹의 상자가 한쪽에 키 큰 줄기를 단 채 오므라들어 X 하나가 됐다가 반대쪽으로 다시 열려요. 쓸기마다 Gr(2,5) 와 Gr(3,6) 의 구멍 난 웹, Y, 두 가지 X 로 넘어가고, 색은 선의 높이를 따라 보라에서 물빛으로 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kp-web","type":"code","name":"kp-web","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Type=0..6, Angle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Type","min":0,"max":6},{"name":"Angle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1152,"detail":0.025,"edges":0.1986,"complexity":0.2838,"coverage":0.1749,"colour":0.115,"drift":0.1113},"knobResponse":[0.0354,0.0783,0.0683,0.0659]},{"slug":"kruskal-count","title":"Kruskal Count","family":"line","round":75,"note":"섞은 카드 52장을 뱀 꼴로 깔고 첫 열 장에서 저마다 색을 띤 사슬이 카드 값만큼 뛰어 내려가다 만나면 하나로 합쳐 하얘지고, 끝에 닿은 카드를 크게 뒤집어 보인 뒤 다시 섞어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kruskal-count","type":"code","name":"kruskal-count","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Court=5..10, Decks=1..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Court","min":5,"max":10},{"name":"Decks","min":1,"max":2}],"start":[0,2,5,1],"measures":{"motion":0.2797,"detail":0.1131,"edges":0.6218,"complexity":0.2727,"coverage":0.5988,"colour":0.1947,"drift":0.1528},"knobResponse":[0.0605,0.094,0.0421,0.1573]},{"slug":"kuramoto-sivashinsky","title":"Kuramoto-Sivashinsky","family":"noise","round":37,"note":"쿠라모토-시바신스키 방정식을 패널 폭만 한 고리에서 한 열에 격자점 하나씩 풀고, 새 순간이 맨 위로 들어와 아래로 흘러서 128줄이 시공간 그림이 돼요. u 가 양인 청록 줄기와 음인 자홍 줄기가 흔들리고 갈라지고 합쳐지며 땋이고, u 가 0을 지나는 곳은 검게 비어요. K3 은 고리 길이를 22에서 66으로 늘려 두 줄기를 일곱 줄기로 만들고, K4 의 분산 항은 혼돈을 한쪽으로 기우는 펄스 열로 가라앉혀요. 누르면 앞면이 한 군데 패여요.","why":"청록과 자홍 줄이 쉬지 않고 꿈틀대요. 0718 의 굵은 줄무늬와 가까워요.","block":0,"ramped":false,"layer":{"id":"layer-kuramoto-sivashinsky","type":"code","name":"kuramoto-sivashinsky","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=22..66, Dispersion=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":22,"max":66},{"name":"Dispersion","min":-1,"max":1}],"start":[0,2,22,0.06],"measures":{"motion":2.1967,"detail":0.0813,"edges":0.1461,"complexity":1.9024,"coverage":0.8129,"colour":0.4992,"drift":0.2147},"knobResponse":[0.3397,0.3051,0.3397,0.3324]},{"slug":"lace-phantom","title":"Lace Phantom","family":"halloween","round":44,"note":"깨진 창의 레이스 커튼이 밤바람에 부풀고, 이따금 그 뒤에서 눈구멍과 벌린 입을 단 얼굴이 눌러 왔다가 가라앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lace-phantom","type":"code","name":"lace-phantom","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lace=-1..1, Haunt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lace","min":-1,"max":1},{"name":"Haunt","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3687,"detail":0.3103,"edges":0.1979,"complexity":0.4605,"coverage":0.5576,"colour":0.1002,"drift":0.0392},"knobResponse":[0.0592,0.1091,0.1119,0.0436]},{"slug":"laguerre-cells","title":"Laguerre Cells","family":"cells","round":70,"note":"점마다 무게를 단 파워 다이어그램을 뉴턴 걸음이 고쳐, 세 봉우리로 몰린 밀도를 칸마다 같은 질량으로 나눌 때까지 곧은 변이 미끄러지고, 넘친 칸은 보라로, 모자란 칸은 초록으로 기울어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-laguerre-cells","type":"code","name":"laguerre-cells","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cells=24..64, Contrast=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cells","min":24,"max":64},{"name":"Contrast","min":-1,"max":1}],"start":[0,2,24,0.06],"measures":{"motion":0.1532,"detail":0.0355,"edges":0.3566,"complexity":1.5636,"coverage":1,"colour":0.2106,"drift":0.1873},"knobResponse":[0.1902,0.1518,0.091,0.0662]},{"slug":"lakes-of-wada","title":"Lakes of Wada","family":"topology","round":34,"note":"섬 안의 두 호수와 바다가 차례로 1 LED 운하를 파요. 마른 땅이 파는 물에서 32, 16, 8, … LED 안에 들 때까지 차례마다 거리를 반으로 줄여 파고 서로 다른 물은 끝내 닿지 않아서, 다 판 섬은 하늘색 바다와 분홍, 연두 호수 사이에 가는 땅 벽만 남은 미로가 돼요. K3 은 호수를 다섯까지 늘리고, K1 을 누르면 섬이 잠기고 새 섬이 솟아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-lakes-of-wada","type":"code","name":"lakes-of-wada","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lakes=3..5, Wander=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lakes","min":3,"max":5},{"name":"Wander","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0225,"detail":0.2272,"edges":1,"complexity":0.1697,"coverage":0.5713,"colour":0.6325,"drift":0.1351},"knobResponse":[0.4015,0.1136,0.142,0.1216]},{"slug":"lambda-diagrams","title":"Lambda Diagrams","family":"line","round":74,"note":"처치 수 셈이 트롬프의 람다 그림으로 서서 정규 차례 베타 줄이기를 한 걸음씩 밟고, 끝에서 셈한 수만큼 이가 난 빗이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lambda-diagrams","type":"code","name":"lambda-diagrams","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Expression=0..6, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Expression","min":0,"max":6},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1651,"detail":0.0318,"edges":0.3577,"complexity":0.1912,"coverage":0.1656,"colour":0.1645,"drift":0.1598},"knobResponse":[0.0742,0.1781,0.2071,0.1108]},{"slug":"lamellar-cream","title":"Lamellar Cream","family":"cosmetic","round":40,"note":"크림을 직교 편광 현미경으로 본 그림이에요. 검은 바탕에서 라멜라 방울이 패널 위로 흐르며 맞붙고 가끔 합쳐지고, 방울마다 편광자 축을 따른 검은 몰타 십자와 간섭색을 띠며 큰 방울은 색 고리를 둘러요. K3 은 방울을 키워 2차의 파랑과 초록 고리를 꺼내고, K4 는 편광자 쌍을 돌려 십자를 방울이 아니라 편광자를 따라 돌게 해요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-lamellar-cream","type":"code","name":"lamellar-cream","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Turn=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Turn","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.582,"detail":0.1784,"edges":0.6166,"complexity":2.1131,"coverage":0.5915,"colour":0.1927,"drift":0.1439},"knobResponse":[0.0935,0.3456,0.3319,0.267]},{"slug":"langford-pairs","title":"Langford Pairs","family":"number","round":69,"note":"패널 높이의 블록 탑에 랭퍼드의 짝이 큰 것부터 놓였다 빠지며 짝마다 옆의 호로 이어지고, 찾은 배열은 왼쪽 선반으로 비켜나 5 LED 너비 탑으로 줄지어 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-langford-pairs","type":"code","name":"langford-pairs","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pairs=7..12, Rule=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pairs","min":7,"max":12},{"name":"Rule","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.9304,"detail":0.0961,"edges":0.7609,"complexity":0.3157,"coverage":0.3813,"colour":0.2873,"drift":0.2678},"knobResponse":[0.0993,0.126,0.1333,0.1042]},{"slug":"lantern-procession","title":"Lantern Procession","family":"halloween","round":46,"note":"등을 든 두건 행렬이 검은 밤의 언덕길을 올라 꼭대기 안개로 사라지고, 가끔 등이 꺼지면 초록 유령 등이 그 자리를 이어 걸어요. K3 은 걷는 사람 수, K4 는 안개이고, K1 을 누르면 등 하나가 유령 등이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lantern-procession","type":"code","name":"lantern-procession","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Walkers=8..24, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Walkers","min":8,"max":24},{"name":"Fog","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.1484,"detail":0.0104,"edges":0.0402,"complexity":0.4978,"coverage":0.2229,"colour":0.096,"drift":0.048},"knobResponse":[0.0444,0.04,0.0828,0.0659]},{"slug":"lap-pool","title":"Lap Pool","family":"sport","round":21,"note":"야외 25 m 수영장을 바로 위에서 내려다본 그림이 128줄을 다 써요. 색 수모를 쓴 사람들이 레인마다 제 속도로 오가다 벽에서 플립 턴을 하고, 뒤로 퍼지는 V자 물결이 빨강·하양·파랑 레인 로프를 흔들어요. 타일 바닥에는 햇빛이 만든 물결 그물이 흘러요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-lap-pool","type":"code","name":"lap-pool","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stroke=0..3, Speed=0.2..3, Swimmers=4..15, Sun=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stroke","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Swimmers","min":4,"max":15},{"name":"Sun","min":-1,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.3073,"detail":0.1425,"edges":0.4977,"complexity":2.1556,"coverage":0.9906,"colour":0.3817,"drift":0.0257},"knobResponse":[0.044,0.0596,0.0629,0.1105]},{"slug":"laser-speckle","title":"Laser Speckle","family":"noise","round":59,"note":"무작위 위상을 채운 동공의 푸리에 변환이 끓는 얼룩이 되고, 밝기는 위상자 합의 크기, 색은 그 위상이라 어두운 점마다 색이 한 바퀴 돌아요. 위쪽 창의 동공이 원판, 고리, 바늘구멍 둘로 바뀌면 알갱이 꼴도 바뀌고, 아래 막대가 e^-I 곡선을 따라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-laser-speckle","type":"code","name":"laser-speckle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pupil=5..14, Looks=1..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pupil","min":5,"max":14},{"name":"Looks","min":1,"max":8}],"start":[0,2,5,1],"measures":{"motion":0.2295,"detail":0.0749,"edges":0.1897,"complexity":2.4913,"coverage":0.7139,"colour":0.3145,"drift":0.1505},"knobResponse":[0.1903,0.1794,0.1574,0.2263]},{"slug":"lattice-reduction","title":"Lattice Reduction","family":"geometry","round":72,"note":"흰 격자점은 그대로 선 채 가늘고 긴 평행사변형 타일이 b1 을 따라 미끄러지고 두 화살이 자리를 바꾸며, 짧고 곧은 기저의 타일로 줄어들어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lattice-reduction","type":"code","name":"lattice-reduction","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Skew=3..7, Spacing=11..22","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Skew","min":3,"max":7},{"name":"Spacing","min":11,"max":22}],"start":[0,2,3,11],"measures":{"motion":0.4963,"detail":0.0878,"edges":0.4751,"complexity":1.1062,"coverage":1,"colour":0.3582,"drift":0.1988},"knobResponse":[0.3456,0.1564,0.1665,0.161]},{"slug":"lava-lake","title":"Lava Lake","family":"volcano","round":27,"note":"화구 가장자리에서 용암 호수를 곧장 내려다봐요. 검은 지각 판들이 노랗게 벌어진 확장 균열에서 떨어져 나와 변환 단층을 끼고 위아래로 흘러가다, 계단진 화구 벽 밑에서 밝은 이음매를 그으며 가라앉아요. K1 은 틈을 주황 용암 강으로 넓히고, 누르면 큰 가스 거품이 터져 용암을 튀겨요.","why":"갈라진 용암 결이 잘고 느려요.","block":1,"ramped":false,"layer":{"id":"layer-lava-lake","type":"code","name":"lava-lake","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Heat=0..1, Speed=0.2..3, Plates=0..1, Spatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Heat","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Plates","min":0,"max":1},{"name":"Spatter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2026,"detail":0.1176,"edges":0.3894,"complexity":2.2223,"coverage":0.271,"colour":0.2444,"drift":0.0498},"knobResponse":[0.229,0.0729,0.0899,0.0472]},{"slug":"lava-lamp","title":"Lava Lamp","family":"sim","round":3,"note":"전구 위 웅덩이에서 데워진 왁스가 목을 늘이며 떨어져 나와 방울로 떠오르고, 위에서 식으면 다시 가라앉아요. 파란 물속에서 식은 왁스는 주황, 뜨거운 왁스는 노랑이에요.","why":"느리고 패널을 꽉 채워요(움직임 0.11, 채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-lava-lamp","type":"code","name":"lava-lamp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Heat=0.3..3, Wax=4..10, Stretch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Heat","min":0.3,"max":3},{"name":"Wax","min":4,"max":10},{"name":"Stretch","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.1138,"detail":0.0147,"edges":0.1844,"complexity":1.5488,"coverage":1,"colour":0.5657,"drift":0.068},"knobResponse":[0.5599,0.1621,0.1504,0.0519]},{"slug":"leaf-devil","title":"Leaf Devil","family":"halloween","round":43,"note":"보랏빛 밤 패널 발치에 주황과 노랑 낙엽이 더미로 쌓여 있다가, 회오리가 일어 잎을 끌어모아 128줄 높이의 흔들리는 깔때기로 감아올려요. 잎은 돌며 뒤집힐 때마다 반짝이고, 회오리가 흩어지면 지그재그로 팔랑이며 내려와 새 더미가 돼요. K3 은 잎을 150장에서 300장으로 늘리고, K4 는 옆바람으로 깔때기 꼭대기를 오른쪽으로 20 LED 까지 눕혀요. K1 을 누르면 돌풍이 더미를 한꺼번에 날려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-leaf-devil","type":"code","name":"leaf-devil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Leaves=150..300, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Leaves","min":150,"max":300},{"name":"Wind","min":0,"max":1}],"start":[0,2,150,0.06],"measures":{"motion":1.0577,"detail":0.0392,"edges":0.7479,"complexity":0.8004,"coverage":0.8864,"colour":0.2098,"drift":0.0706},"knobResponse":[0.097,0.0601,0.0795,0.0373]},{"slug":"leapfrogging-vortices","title":"Leapfrogging Vortices","family":"sim","round":53,"note":"두 연기 고리를 축을 지나는 단면으로 봐서, 고리마다 반대로 도는 염료 나선 한 쌍이 보여요. 뒤 고리가 좁아지며 앞 고리 사이로 빠르게 빠져나가 앞서고, 앞 고리는 넓어지며 느려져 뒤로 처지기를 되풀이하며 위로 올라가요. K3 은 작은 고리가 지나는 순간의 두 고리 너비 비로, 러브의 문턱 5.83 을 넘으면 한 번 빠져나간 고리가 돌아오지 않아요. K4 는 고리에 실린 염료의 양이고, 단추를 누르면 두 고리에 새 염료를 입혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-leapfrogging-vortices","type":"code","name":"leapfrogging-vortices","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=3..8, Dye=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":3,"max":8},{"name":"Dye","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.942,"detail":0.0667,"edges":0.336,"complexity":2.2701,"coverage":0.2487,"colour":0.1385,"drift":0.0843},"knobResponse":[0.0413,0.1192,0.1292,0.0656]},{"slug":"lempel-ziv","title":"Lempel-Ziv","family":"type","round":79,"note":"LZ77 부호기가 「잭이 지은 집」을 읽어 가며 앞에서 가장 길게 겹치는 구절을 비추고 그 거리의 색으로 베껴 와서, 쪽이 흰 새 글자와 절마다 하나씩 긴 색 띠로 짜여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lempel-ziv","type":"code","name":"lempel-ziv","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Window=0..1, Text=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Window","min":0,"max":1},{"name":"Text","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.2545,"detail":0.2062,"edges":0.9724,"complexity":0.1841,"coverage":0.3019,"colour":0.2708,"drift":0.2873},"knobResponse":[0.0321,0.106,0.0394,0.0733]},{"slug":"lensed-page","title":"Lensed Page","family":"type","round":82,"note":"뉴턴 『광학』의 첫 물음이 3×5 대문자로 패널을 타고 올라가며 가운데의 보이지 않는 점 질량을 지나고, 줄은 그 둘레로 휘며, 가까운 글자는 아인슈타인 고리 밖과 안에 두 번 서고 바로 뒤의 글자는 고리로 번져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lensed-page","type":"code","name":"lensed-page","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mass=13..29, Drift=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mass","min":13,"max":29},{"name":"Drift","min":0,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":0.8247,"detail":0.1634,"edges":0.6599,"complexity":1.4694,"coverage":0.4817,"colour":0.1723,"drift":0.0975},"knobResponse":[0.1406,0.1995,0.195,0.1699]},{"slug":"letter-melt","title":"Letter Melt","family":"type","round":69,"note":"MELT, 물, FLOW, 녹다, DRIP 이 보이지 않는 거푸집에 담긴 물로 위에 서 있다가, 거푸집이 글자 발끝부터 놓아 주면 획이 늘어지고 방울져 패널 끝까지 흘러내려 바닥에 고이고, 웅덩이에서 실줄기가 빨려 올라가 다음 낱말을 글자 위부터 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-melt","type":"code","name":"letter-melt","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":5},{"name":"Heat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9629,"detail":0.0444,"edges":0.4857,"complexity":0.621,"coverage":0.2681,"colour":0.1863,"drift":0.1581},"knobResponse":[0.0856,0.1246,0.095,0.1458]},{"slug":"letter-mobile","title":"Letter Mobile","family":"type","round":75,"note":"네 글자 낱말을 잉크만큼 무게로 단 콜더식 모빌이 패널 높이로 걸려 돌고, 한 글자씩 바뀔 때마다 그 위 막대들이 기울었다가 고리를 새 균형점으로 옮겨 다시 수평이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-mobile","type":"code","name":"letter-mobile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..2, Sway=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":2},{"name":"Sway","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1522,"detail":0.0235,"edges":0.3907,"complexity":0.7374,"coverage":0.9749,"colour":0.164,"drift":0.0839},"knobResponse":[0.0654,0.0679,0.0606,0.0751]},{"slug":"letter-retracts","title":"Letter Retracts","family":"type","round":82,"note":"세로로 쌓은 굵은 대문자 셋이 구멍을 열지도 닫지도 않고 한 겹씩 뼈대로 가늘어진 뒤 끝을 한 LED 씩 잃어, 구멍 없는 글자는 한 점, 구멍 하나는 고리, 구멍 둘은 고리 둘로 줄고, 그 점과 고리에서 구멍 수가 같은 다음 낱말이 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-retracts","type":"code","name":"letter-retracts","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Set","min":0,"max":3},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0383,"detail":0.0453,"edges":0.9043,"complexity":0.0998,"coverage":0.3422,"colour":0.1312,"drift":0.0903},"knobResponse":[0.0576,0.1105,0.0857,0.0821]},{"slug":"letter-sand","title":"Letter Sand","family":"type","round":64,"note":"모래알로 지은 굵은 네 글자 낱말이 세로로 서 있다가 아래 글자부터 무너지고, 쌓인 더미는 글자 색 차례대로 층을 이뤄요. 더미에 팬 구덩이에서 가는 모래 기둥이 솟아 ROCK, SAND, DUNE, DUST, SILT, LOAM 가운데 다음 낱말을 다시 쌓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-sand","type":"code","name":"letter-sand","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grain=1..3, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grain","min":1,"max":3},{"name":"Wind","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.2963,"detail":0.0685,"edges":0.4843,"complexity":0.588,"coverage":0.1953,"colour":0.2881,"drift":0.2333},"knobResponse":[0.1063,0.097,0.1513,0.0369]},{"slug":"levy-dust","title":"Lévy Dust","family":"fractal","round":76,"note":"레비 비행이 1초에 3,000 번 떨어뜨린 먼지를 전체, 4배, 16배 세 층으로 나란히 세워, 무리 속의 무리가 어느 배율에서나 닮아 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-levy-dust","type":"code","name":"levy-dust","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tail=-1..1, Cut=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tail","min":-1,"max":1},{"name":"Cut","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9403,"detail":0.1026,"edges":0.7373,"complexity":0.7366,"coverage":0.217,"colour":0.2073,"drift":0.1125},"knobResponse":[0.0655,0.0998,0.1629,0.1741]},{"slug":"lichtenberg","title":"Lichtenberg","family":"fractal","round":26,"note":"소다물을 바른 단풍나무 판의 위아래 전극에서 깃털 잔가지를 단 프랙탈 나무가 파란 플라스마와 주황 불씨를 달고 서로를 향해 타 들어가고, 만나면 아크가 번쩍여요. K1 이 판의 나무를 바꾸고, 누르면 다음 판이에요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-lichtenberg","type":"code","name":"lichtenberg","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wood=0..1, Speed=0.2..3, Pull=1..4, Lead=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wood","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pull","min":1,"max":4},{"name":"Lead","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2052,"detail":0.13,"edges":0.3965,"complexity":2.6118,"coverage":0.9587,"colour":0.1893,"drift":0.2406},"knobResponse":[0.4635,0.1257,0.0391,0.0652]},{"slug":"life","title":"Life","family":"automata","round":1,"note":"같은 여덟 이웃에 법칙이 여섯이에요. 세포가 나이만큼 색을 입어서 법칙마다 무엇이 남는지 보여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-life","type":"code","name":"life","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..4, Rule=0..5, Ghosts=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":4},{"name":"Rule","min":0,"max":5},{"name":"Ghosts","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6935,"detail":0.1138,"edges":0.7121,"complexity":0.3343,"coverage":0.2193,"colour":0.2429,"drift":0.1393},"knobResponse":[0.1027,0.1531,0.303,0.0806]},{"slug":"liftoff","title":"Liftoff","family":"flight","round":22,"note":"새벽 물 건너 발사대에서 로켓이 하얀 산소 김을 흘리며 서 있다가 김구름 속에 불을 붙이고 솟아올라요. 카메라가 따라 고개를 들면 하늘이 파랑에서 별 뜬 검정으로 바뀌고, Max-Q 와 단 분리를 지나 밝은 점이 되면 새 로켓이 발사대에 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-liftoff","type":"code","name":"liftoff","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Rocket=0..3, Speed=0.2..3, Stages=1..3, Time=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Rocket","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Stages","min":1,"max":3},{"name":"Time","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3231,"detail":0.0267,"edges":0.3728,"complexity":1.8839,"coverage":0.9986,"colour":0.2838,"drift":0.1066},"knobResponse":[0.0489,0.062,0.0431,0.4667]},{"slug":"lights-out","title":"Lights Out","family":"algo","round":75,"note":"패널 크기의 라이츠 아웃 판을 빛 쫓기로 풀어서, 앞선 줄이 내려가며 호박색 불을 하늘색 누르기 기록으로 바꾸고, 맨 윗줄을 고친 두 번째 쫓기가 마지막 불을 끄면 판을 만든 누르기가 그대로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lights-out","type":"code","name":"lights-out","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cells=1..4, Record=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cells","min":1,"max":4},{"name":"Record","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.4263,"detail":0.3224,"edges":0.9529,"complexity":0.2538,"coverage":0.4703,"colour":0.3017,"drift":0.3986},"knobResponse":[0.2462,0.3606,0.2654,0.1462]},{"slug":"linotype","title":"Linotype","family":"type","round":80,"note":"놋쇠 매트릭스가 채널에서 하나씩 떨어져 벨트를 타고 어셈블러에 줄을 이루고, 스페이스밴드가 올라가 줄을 폭에 맞추면 쇳물을 부어 뜬 거울 글자 슬러그가 갤리에 쌓이고, 매트릭스는 꼭대기 분배 막대를 따라 제 채널로 돌아가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-linotype","type":"code","name":"linotype","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Measure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Measure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.1742,"detail":0.1204,"edges":0.8979,"complexity":0.1321,"coverage":0.456,"colour":0.1182,"drift":0.1084},"knobResponse":[0.0448,0.1397,0.1196,0.1254]},{"slug":"lip-gloss","title":"Lip Gloss","family":"cosmetic","round":31,"note":"맑은 글로스가 위에서 부어져 옅은 벽을 타고 흘러내리고, 앞머리가 길이 다른 방울 줄기로 갈라져 끝마다 빛 한 점을 문 구슬이 맺혀요. 바닥에 닿은 구슬은 떨어지고 글로스는 얇아지며 맑아져요. K1 은 색상환을 다 돌고, 누르면 위에 새로 부어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-lip-gloss","type":"code","name":"lip-gloss","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pour=0..1, Shimmer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pour","min":0,"max":1},{"name":"Shimmer","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0402,"detail":0.004,"edges":0.0558,"complexity":1.0787,"coverage":1,"colour":0.1859,"drift":0.0271},"knobResponse":[0.1707,0.0957,0.1771,0.0458]},{"slug":"littlewood-roots","title":"Littlewood Roots","family":"fractal","round":31,"note":"계수가 다 ±1 인 13차 다항식 8192개의 근 106,496개가 단위원 둘레에 옅은 레이스로 번지고, 1의 거듭제곱근 자리마다 구멍이 나요. 그레이 부호로 계수 하나씩 뒤집는 지금 다항식의 근이 불티로 옮겨 다니며 레이스를 다시 밝혀요. K1 을 누르면 단위원이 번쩍여요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-littlewood-roots","type":"code","name":"littlewood-roots","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Degree=13..16, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Degree","min":13,"max":16},{"name":"Glow","min":0,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":0.2172,"detail":0.0303,"edges":0.1403,"complexity":0.6238,"coverage":0.2539,"colour":0.1322,"drift":0.0228},"knobResponse":[0.0566,0.0256,0.0365,0.0521]},{"slug":"loewner-trace","title":"Loewner Trace","family":"line","round":28,"note":"브라운 운동이 모는 슈람-뢰브너 곡선이 패널만 한 골짜기를 기어오르고, 그 곡선을 푸는 등각 사상의 격자가 곡선 끝을 돌아 휘어요. 화면은 곡선을 따라 끝없이 위로 흘러가요. K3 이 κ 를 4 에서 8 까지 올리면 곡선이 제 몸과 벽에 닿아 가둔 땅을 삼키고, 8 에서는 다 메워요. 누르면 새 브라운 경로로 다시 자라요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-loewner-trace","type":"code","name":"loewner-trace","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Kappa=4..8, Trace=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Kappa","min":4,"max":8},{"name":"Trace","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":2.6307,"detail":0.0738,"edges":0.5207,"complexity":1.219,"coverage":0.8893,"colour":0.2244,"drift":0.1264},"knobResponse":[0.1533,0.1433,0.1845,0.1423]},{"slug":"lonely-runner","title":"Lonely Runner","family":"rhythm","round":47,"note":"위아래로 이은 128줄 트랙에서 주자마다 제 레인을 정수 빠르기로 달리고, 위아래 128/k 줄 안에 아무도 없으면 그 구역이 밝아지고 막대가 하얗게 달아올라요. 처음 셋은 1, 2, 3 으로 달려서 경주마다 1.8초와 3.6초에 한꺼번에 외로워져요. K3 은 주자 수, K4 는 빠르기를 흩는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lonely-runner","type":"code","name":"lonely-runner","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Runners=3..8, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Runners","min":3,"max":8},{"name":"Scatter","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":1.2637,"detail":0.0251,"edges":0.4032,"complexity":0.3563,"coverage":0.4516,"colour":0.303,"drift":0.2999},"knobResponse":[0.1637,0.2381,0.1916,0.1739]},{"slug":"long-division","title":"Long Division","family":"type","round":65,"note":"1 을 소수로 나누는 손 나눗셈이 세로셈 계단으로 내려가다, 나머지가 처음 수로 돌아오면 금빛이 되고 순환마디 위에 선이 그어져요","why":"","block":0,"ramped":false,"layer":{"id":"layer-long-division","type":"code","name":"long-division","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Divisor=7..97, Base=10..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Divisor","min":7,"max":97},{"name":"Base","min":10,"max":16}],"start":[0,2,7,10],"measures":{"motion":0.1327,"detail":0.0878,"edges":0.6993,"complexity":0.389,"coverage":0.1396,"colour":0.1965,"drift":0.0965},"knobResponse":[0.0464,0.0616,0.082,0.0645]},{"slug":"longcase-clock","title":"Longcase Clock","family":"time","round":18,"note":"촛불 켠 밤 방에 128줄을 다 쓰는 괘종시계가 서 있어요. 줄의 유리문 안에서 황동 추가 1초에 한 번씩 흔들리고 무게추가 내려가며, 다이얼 아치의 달 원판이 돌고, 정시마다 꼭대기 종이 번쩍이며 울려요. K3 을 돌리면 촛불이 시계 왼쪽에서 앞을 지나 오른쪽으로 옮겨 가고, 벽에 진 그림자가 반대쪽으로 넘어가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-longcase-clock","type":"code","name":"longcase-clock","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wood=0..1, Speed=0..3, Candle=0..1, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wood","min":0,"max":1},{"name":"Speed","min":0,"max":3},{"name":"Candle","min":0,"max":1},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.144,"detail":0.0765,"edges":0.4175,"complexity":2.1824,"coverage":0.9202,"colour":0.2877,"drift":0.0825},"knobResponse":[0.0907,0.1391,0.1097,0.2042]},{"slug":"look-and-say","title":"Look and Say","family":"data","round":28,"note":"콘웨이의 보고 말하기 수열이 한 줄씩 제 위 줄을 소리 내어 읽으며 쪽을 내려와요. 줄이 한 걸음에 1.3배씩 길어지면 글자가 3×5 숫자에서 막대로, LED 하나에 숫자 하나로 작아지고, 콘웨이의 원소 92개가 저마다 제 색이에요. K3 이 씨앗을 3, 312, 311311, 고정점 22 로 바꿔요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-look-and-say","type":"code","name":"look-and-say","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Seed=1..5, Digits=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Seed","min":1,"max":5},{"name":"Digits","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.7275,"detail":0.2216,"edges":0.866,"complexity":0.242,"coverage":0.6191,"colour":0.2962,"drift":0.1823},"knobResponse":[0.1154,0.1635,0.2082,0.064]},{"slug":"loop-soup","title":"Loop Soup","family":"noise","round":58,"note":"한 LED 걸러 놓인 격자 위에서 닫힌 무작위 걸음이 하얀 머리로 제 몸을 그리고 7초 만에 사라지며, 길이가 한 옥타브 길어질 때마다 수가 반으로 줄어요. 한 자리를 나눠 쓰는 고리끼리는 같은 색 무리가 되고, c 를 1 에서 4 로 올리면 쉰 개쯤이던 무리가 잉크의 90% 를 가진 하나로 합쳐져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-loop-soup","type":"code","name":"loop-soup","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Log2 c=-2..2, Smallest=-1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Log2 c","min":-2,"max":2},{"name":"Smallest","min":-1,"max":4}],"start":[0,2,0,0.06],"measures":{"motion":0.0666,"detail":0.1296,"edges":0.9301,"complexity":0.2392,"coverage":0.2075,"colour":0.2724,"drift":0.1292},"knobResponse":[0.0828,0.083,0.2604,0.1349]},{"slug":"loose-powder","title":"Loose Powder","family":"cosmetic","round":29,"note":"꽃 무늬가 눌린 분홍 압축 파우더 위로 보이지 않는 퍼프가 그림자로만 내려와 자국을 내고, 들릴 때 하얀 가루 구름이 운모 반짝임과 함께 피어 위로 흘러가요. K3 을 올리면 무늬 비탈에 새틴 광이 돌고, 누르면 퍼프가 바로 내려와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-loose-powder","type":"code","name":"loose-powder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shimmer=1..5, Air=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shimmer","min":1,"max":5},{"name":"Air","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0756,"detail":0.0494,"edges":0.1592,"complexity":2.3434,"coverage":1,"colour":0.2039,"drift":0.0525},"knobResponse":[0.2504,0.0583,0.0484,0.0614]},{"slug":"lorem-ipsum","title":"Lorem Ipsum","family":"type","round":71,"note":"키케로의 문장이 작은 활자로 짜여 있다가 정렬 셈이 고른 글자만 남고, 잘린 글자는 줄에서 떨어져 바닥에 쌓이고 남은 글자가 Lorem ipsum 의 새 줄로 미끄러지면, 모자란 글자가 더미에서 뛰어오르거나 위에서 떨어져 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lorem-ipsum","type":"code","name":"lorem-ipsum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Passage=0..3, Gravity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Passage","min":0,"max":3},{"name":"Gravity","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5815,"detail":0.1433,"edges":0.9901,"complexity":0.124,"coverage":0.1488,"colour":0.1175,"drift":0.1423},"knobResponse":[0.0459,0.1754,0.1497,0.0588]},{"slug":"lorentz-gas","title":"Lorentz Gas","family":"particle","round":46,"note":"삼각 격자로 놓인 원판 사이로 입자 800개가 한 점에서 튕기며 퍼지고, 금빛 고리가 √t 로 크는 제곱평균 거리를 그려요. K4 가 원판을 줄이면 0.148 에서 통로가 열려 입자가 줄무늬로 내달리고, K1 을 누르면 새로 터져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lorentz-gas","type":"code","name":"lorentz-gas","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Particles=800..3000, Radius=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Particles","min":800,"max":3000},{"name":"Radius","min":0,"max":1}],"start":[0,2,800,0.06],"measures":{"motion":0.4279,"detail":0.0846,"edges":0.3101,"complexity":0.6478,"coverage":0.3867,"colour":0.1734,"drift":0.0595},"knobResponse":[0.0701,0.0455,0.0404,0.167]},{"slug":"lost-head","title":"Lost Head","family":"halloween","round":52,"note":"달 뜬 묘지에서 목 없는 해골이 묘비 위 머리를 하나씩 써 보며 너무 크거나 작은 머리, 모자 쓴 머리, 무는 머리와 호박을 으쓱하며 내려놓다가, 제 머리가 맞으면 눈구멍이 독한 초록으로 켜지고 춤을 춰요. 그러다 머리가 떨어져 굴러가요. K3 은 틀린 머리 수, K4 는 크기가 틀린 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lost-head","type":"code","name":"lost-head","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tries=1..5, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tries","min":1,"max":5},{"name":"Size","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.9453,"detail":0.0638,"edges":0.5308,"complexity":0.2014,"coverage":0.8981,"colour":0.1323,"drift":0.0624},"knobResponse":[0.0646,0.0908,0.0776,0.0461]},{"slug":"lotion-ribbon","title":"Lotion Ribbon","family":"cosmetic","round":36,"note":"위에서 굵은 로션 줄기가 쏟아지며 가늘어지고, 닿는 자리에서 꿀처럼 똬리를 틀어 접힌 더미를 쌓아요. K3 은 로션의 무게라서 묽은 세럼은 작은 고리로 빨리 감기고 바디 버터는 25 LED 너비의 고리로 천천히 접혀요. K1 을 누르면 줄기가 끊기고, 더미가 가라앉은 뒤 새 줄기가 내려와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-lotion-ribbon","type":"code","name":"lotion-ribbon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thick=-1..1, Gloss=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thick","min":-1,"max":1},{"name":"Gloss","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0659,"detail":0.0182,"edges":0.2668,"complexity":1.0681,"coverage":0.9585,"colour":0.134,"drift":0.0362},"knobResponse":[0.16,0.0263,0.0576,0.0386]},{"slug":"lotion-stitch","title":"Lotion Stitch","family":"cosmetic","round":40,"note":"위에서 내려다본 벨트에 윤기 나는 로션 줄기가 떨어지고, 벨트가 놓인 땀을 아래로 실어 날라 128줄에 최근 바느질이 쌓여요. K3 으로 벨트를 빠르게 하면 옮겨지는 코일이 엇갈린 고리와 W 모양 꺾임과 사행을 거쳐 곧은 줄이 되고, K4 는 로션을 굵게 해서 코일을 넓고 느리게 감아요.","why":"굵은 코일 하나가 좋은데 모양이 늘 같아요.","block":1,"ramped":false,"layer":{"id":"layer-lotion-stitch","type":"code","name":"lotion-stitch","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Belt=0.2..1.2, Thick=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Belt","min":0.2,"max":1.2},{"name":"Thick","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.4822,"detail":0.0594,"edges":0.2775,"complexity":0.8362,"coverage":0.3316,"colour":0.1426,"drift":0.0308},"knobResponse":[0.0586,0.186,0.1911,0.2087]},{"slug":"lunation","title":"Lunation","family":"celestial","round":16,"note":"망원 렌즈로 본 한 달을 빠르게 돌려요. 패널 너비만 한 달이 지구조에 비친 초승달에서 보름달로 차오르며 달의 바다와 크레이터를 드러내고, 하늘도 같이 밝아져요. K1 을 누르면 다음 보름에 개기월식이 들어 달이 구릿빛이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-lunation","type":"code","name":"lunation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Latitude=-90..90, Days=0.5..4, Zoom=0..1, Exposure=-2..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Latitude","min":-90,"max":90},{"name":"Days","min":0.5,"max":4},{"name":"Zoom","min":0,"max":1},{"name":"Exposure","min":-2,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.058,"detail":0.023,"edges":0.2973,"complexity":1.178,"coverage":0.7526,"colour":0.083,"drift":0.3482},"knobResponse":[0.0549,0.1588,0.1276,0.2614]},{"slug":"malfatti-circles","title":"Malfatti Circles","family":"geometry","round":81,"note":"천천히 모양을 바꾸는 삼각형 하나가 위아래로 두 번 서서, 위의 말파티 세 원보다 아래의 탐욕 세 원이 늘 더 넓게 덮어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-malfatti-circles","type":"code","name":"malfatti-circles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thin=0..1, More=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thin","min":0,"max":1},{"name":"More","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1546,"detail":0.0716,"edges":0.7194,"complexity":0.6355,"coverage":0.4214,"colour":0.251,"drift":0.1206},"knobResponse":[0.0912,0.111,0.0673,0.0376]},{"slug":"mamikon-theorem","title":"Mamikon's Theorem","family":"line","round":80,"note":"위 칸에서 길이가 정해진 선분이 타원에 닿은 채 한 바퀴 돌며 고리를 열두 색으로 칠하고, 아래 칸에서는 같은 선분을 한 점에 모아 같은 순간 같은 색으로 원판을 채워서, 타원을 네모나 가는 경기장 꼴로 바꿔도 두 넓이가 색마다 같아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mamikon-theorem","type":"code","name":"mamikon-theorem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Oval=0..3, Length=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Oval","min":0,"max":3},{"name":"Length","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0741,"detail":0.0345,"edges":0.4693,"complexity":0.9742,"coverage":0.3335,"colour":0.2724,"drift":0.153},"knobResponse":[0.0943,0.0847,0.0778,0.1099]},{"slug":"mandelbrot","title":"Mandel Dive","family":"fractal","round":2,"note":"망델브로 집합 전체가 서 있다가 가장자리의 한 점으로 끝없이 떨어져 들어가요. 처음 자리는 안테나 위의 미니 망델브로라서, 다 들어가면 처음과 같은 그림으로 녹아들어 다시 떨어져요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-mandelbrot","type":"code","name":"mandelbrot","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..4, Spot=0..3, Bands=1..3.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":4},{"name":"Spot","min":0,"max":3},{"name":"Bands","min":1,"max":3.5}],"start":[0,2,0,1],"measures":{"motion":1.8353,"detail":0.0554,"edges":0.2209,"complexity":1.9032,"coverage":0.846,"colour":0.2924,"drift":0.4001},"knobResponse":[0.262,0.2907,0.2828,0.2216]},{"slug":"marble-run","title":"Marble Run","family":"toy","round":17,"note":"패널 높이의 구슬 굴리기 장난감이에요. 고양이눈 유리구슬이 깔때기를 돌고 지그재그 레일 셋과 나선, 실로폰을 지나 내려오면 옆의 나사 리프트가 다시 꼭대기로 올리고, 구슬이 지나는 플라스틱 조각에는 불이 들어와요. K1 을 누르면 구슬 여섯 개를 깔때기에 쏟아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-marble-run","type":"code","name":"marble-run","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paint=0..1, Speed=0.2..3, Marbles=6..28, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Marbles","min":6,"max":28},{"name":"Tilt","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.4936,"detail":0.087,"edges":0.6482,"complexity":0.8353,"coverage":0.464,"colour":0.2101,"drift":0.042},"knobResponse":[0.0707,0.0515,0.0698,0.0736]},{"slug":"marbling","title":"Marbling","family":"print","round":15,"note":"물 위에 떨어진 잉크 방울이 과녁처럼 번지고, 빗이 지나가면 깃털과 갈매기 무늬로 끌려가요. 종이를 들어 올리면 물이 비고 다음 판에 다시 방울이 떨어져요.","why":"검은 바탕에 원색 띠가 쉬지 않고 끌려가요. 복잡도 0.28, 움직임 1.65 로 프리셋이 서는 자리예요.","block":0,"ramped":false,"layer":{"id":"layer-marbling","type":"code","name":"marbling","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=3..8, Comb=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":3,"max":8},{"name":"Comb","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":1.6459,"detail":0.1305,"edges":0.9605,"complexity":0.2799,"coverage":0.6371,"colour":0.5767,"drift":0.3773},"knobResponse":[0.3451,0.3454,0.3519,0.2984]},{"slug":"marionette","title":"Marionette","family":"stage","round":25,"note":"작은 인형극 무대에서 어릿광대 꼭두각시가 팔로 스폿을 받으며 지그를 춰요. 머리와 두 손, 두 무릎, 등에 맨 실 일곱이 꼭대기 다리에서 인형사가 쥔 십자 조종대까지 올라가서, 조종대가 기울면 실이 따라 기울고 팔과 무릎이 끌려 올라가요. K4 가 스폿을 옆으로 옮기면 인형과 실의 그림자가 반대쪽 배경막에 서고, K1 을 누르면 인형이 무릎을 접고 높이 뛰었다가 인사해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-marionette","type":"code","name":"marionette","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Costume=0..1, Speed=0.2..3, Number=0..4, Spot=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Costume","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":4},{"name":"Spot","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7728,"detail":0.0499,"edges":0.328,"complexity":1.7055,"coverage":0.7031,"colour":0.18,"drift":0.1687},"knobResponse":[0.0905,0.1199,0.1924,0.0547]},{"slug":"mastermind","title":"Mastermind","family":"algo","round":71,"note":"1296 가지 암호가 6×6 블록 36개로 맨 위에 서고, 크누스의 미니맥스가 1296 개를 다 훑어 고른 수를 아래 판에 꽂을 때마다 아직 가능한 암호가 받을 답대로 물들었다가 온 답의 무리만 남아서, 다섯 수 안에 LED 하나로 줄어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mastermind","type":"code","name":"mastermind","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strategy=0..3, Codemaker=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strategy","min":0,"max":3},{"name":"Codemaker","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0379,"detail":0.0492,"edges":0.5257,"complexity":0.0949,"coverage":0.2524,"colour":0.1726,"drift":0.0785},"knobResponse":[0.0431,0.0919,0.0368,0.0455]},{"slug":"max-flow-min-cut","title":"Max-Flow Min-Cut","family":"algo","round":53,"note":"아래 원천 막대에서 위 싱크 막대까지 놓인 삼각 그물의 관을 펄스가 가장 짧은 증가 경로를 따라 하나씩 올라가며 청록 흐름으로 채우고, 가득 찬 관은 금색이 돼요. 길이 다 막히면 원천에서 아직 닿는 마디가 웅덩이처럼 차오르다 들쭉날쭉한 선에서 멈추고, 그 선을 건너는 관이 깜빡이며 싱크 막대가 그 관들의 용량으로 꼭 맞게 나뉘어요. K3 은 그물의 너비(7~13 마디), K4 는 관마다 제멋대로인 용량의 몫이고, 단추를 누르면 새 용량으로 다시 흘려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-max-flow-min-cut","type":"code","name":"max-flow-min-cut","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Columns=7..13, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Columns","min":7,"max":13},{"name":"Grain","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.2267,"detail":0.1285,"edges":0.5762,"complexity":1.2793,"coverage":0.4989,"colour":0.2167,"drift":0.1011},"knobResponse":[0.0661,0.0368,0.1344,0.0365]},{"slug":"maxwell-fish-eye","title":"Maxwell's Fish-Eye","family":"line","round":63,"note":"맥스웰의 물고기 눈 렌즈 안에서 한 점을 떠난 빛 24줄이 원을 그리며 휘고, 펄스의 고리가 부풀었다가 렌즈 반대편의 상 한 점으로 한꺼번에 오므라들어요. 원천이 떠돌면 상은 점선 원 r = R 너머에서 반대로 움직여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-maxwell-fish-eye","type":"code","name":"maxwell-fish-eye","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Source=-1..1, Profile=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Source","min":-1,"max":1},{"name":"Profile","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5726,"detail":0.0841,"edges":0.4726,"complexity":1.2809,"coverage":0.3074,"colour":0.1096,"drift":0.0657},"knobResponse":[0.0522,0.0987,0.1006,0.0935]},{"slug":"maya-numerals","title":"Maya Numerals","family":"type","round":73,"note":"다섯 자리 마야 숫자가 맨 아래 자리부터 하나씩 늘면서 점 다섯이 모여 막대 하나로 녹고, 다 찬 자리는 금빛 점 하나로 오그라들어 윗자리로 올라가며 조개 껍데기 0 을 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-maya-numerals","type":"code","name":"maya-numerals","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=0..1, Step=0..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":0,"max":1},{"name":"Step","min":0,"max":6}],"start":[0,2,0,0.06],"measures":{"motion":0.1292,"detail":0.0449,"edges":0.5033,"complexity":0.5225,"coverage":0.2779,"colour":0.1568,"drift":0.1203},"knobResponse":[0.1143,0.1005,0.0547,0.1227]},{"slug":"maze","title":"Maze","family":"algo","round":2,"note":"미로를 한 칸씩 파고 나면 입구에서 너비 우선 물결이 퍼져 복도마다 거리만큼 색을 입혀요. 가장 짧은 길이 밝게 그어지고, 미로가 부서진 자리에 다음 미로가 파여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-maze","type":"code","name":"maze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..4, Cell=2..4, Carver=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":4},{"name":"Cell","min":2,"max":4},{"name":"Carver","min":0,"max":3}],"start":[0,2,2,0.06],"measures":{"motion":0.0785,"detail":0.1747,"edges":0.9998,"complexity":0.1404,"coverage":0.6288,"colour":0.2889,"drift":0.1789},"knobResponse":[0.1257,0.2208,0.2744,0.1999]},{"slug":"mcmullen-carpet","title":"McMullen Carpet","family":"fractal","round":65,"note":"가로 m 칸, 세로 n 칸으로 나눈 칸 몇 개 안에 같은 나눔을 되풀이한 자기 아핀 카펫이 가로 m 배, 세로 n 배로 커지며 한 단마다 같은 그림으로 돌아와요","why":"","block":0,"ramped":false,"layer":{"id":"layer-mcmullen-carpet","type":"code","name":"mcmullen-carpet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pattern=0..5, Iso=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pattern","min":0,"max":5},{"name":"Iso","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6297,"detail":0.0468,"edges":0.3636,"complexity":0.1907,"coverage":0.7403,"colour":0.1516,"drift":0.2151},"knobResponse":[0.1243,0.2112,0.2369,0.096]},{"slug":"meander","title":"Meander","family":"line","round":30,"note":"패널 한가운데 세로로 난 길을 12번에서 32번 건너는 닫힌 곡선 하나예요. 한쪽 아치들이 길 위로 누웠다가 새 짝으로 펴져도 곡선은 늘 하나로 닫혀요.","why":"굵은 무지개 관이 좋은데 느려요(움직임 0.11).","block":1,"ramped":false,"layer":{"id":"layer-meander","type":"code","name":"meander","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Crossings=12..32, Hollow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Crossings","min":12,"max":32},{"name":"Hollow","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.1079,"detail":0.0446,"edges":0.5226,"complexity":0.7574,"coverage":0.4978,"colour":0.5487,"drift":0.1848},"knobResponse":[0.3105,0.2838,0.4218,0.1979]},{"slug":"medial-axis","title":"Medial Axis","family":"algo","round":57,"note":"닫힌 곡선을 따라 붙인 불이 안팎으로 같은 빠르기로 번져서, 거리의 톱니 띠가 반 띠씩 엇갈린 토막이 되어 곡선 안쪽과 바깥쪽으로 흘러가요. LED 마다 가장 가까운 곡선 위 점의 자리로 색을 칠해서, 그 점이 건너뛰는 중심축이 두 색 사이의 솔기로 서요. 처음에는 줄기에 갈래 하나가 붙은 키 큰 나무예요. K3 은 곡선에 물결을 하나씩 더하는데 5분의 1 LED 높이의 혹에서도 깊숙한 새 가지가 자라고, K4 는 앞선 사이 거리(6.7~14.2 LED)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-medial-axis","type":"code","name":"medial-axis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bumps=0..1, Width=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bumps","min":0,"max":1},{"name":"Width","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8876,"detail":0.2032,"edges":0.1485,"complexity":2.5448,"coverage":0.9038,"colour":0.4206,"drift":0.0907},"knobResponse":[0.2809,0.3154,0.2401,0.2394]},{"slug":"menger-slices","title":"Menger Slices","family":"fractal","round":80,"note":"긴 대각선에 수직인 평면이 멩거 스펀지를 한 모서리에서 맞은편 모서리까지 훑어서 단면이 삼각형에서 육각형으로 자라고 첫 단계 구멍이 한순간 육각별이 되며, 아래에는 그 가운데 단면의 육각별 레이스가 서 있어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-menger-slices","type":"code","name":"menger-slices","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=3..5, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":3,"max":5},{"name":"Zoom","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2733,"detail":0.083,"edges":0.9756,"complexity":0.1979,"coverage":0.5388,"colour":0.1899,"drift":0.1433},"knobResponse":[0.0975,0.1115,0.0338,0.1361]},{"slug":"mesostic","title":"Mesostic","family":"type","round":75,"note":"소로의 『월든』을 맨 아래 줄에서 읽어 가다 케이지의 메조스틱 규칙이 허락하는 글자가 가운데에 오면 금빛 대문자로 세우고 둘레 낱말을 날개로 남겨서, 등뼈 낱말이 패널 가운데를 위에서 아래로 거듭 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mesostic","type":"code","name":"mesostic","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Rule=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Rule","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6551,"detail":0.1248,"edges":0.9735,"complexity":0.1619,"coverage":0.1426,"colour":0.1451,"drift":0.0572},"knobResponse":[0.0484,0.1138,0.1154,0.072]},{"slug":"metro-map","title":"Metro Map","family":"city","round":15,"note":"해리 벡 식 지하철 노선도예요. 색 노선 넷이 45도로 꺾이며 위아래로 달리고, 갈아타는 역은 흰 고리예요. 흰 열차가 역마다 섰다 떠나고 끝에서 되돌아가요. K1 을 누르면 급행이 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-metro-map","type":"code","name":"metro-map","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=4..7, Rush=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":4,"max":7},{"name":"Rush","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0316,"detail":0.0683,"edges":0.914,"complexity":0.1388,"coverage":0.2043,"colour":0.2301,"drift":0.035},"knobResponse":[0.0664,0.0514,0.0687,0.0629]},{"slug":"milk-ring","title":"Milk Ring","family":"cosmetic","round":38,"note":"우윳빛 크림 방울이 색을 띤 세럼에 떨어져 테두리가 밝은 소용돌이 고리가 돼요. 고리는 가라앉으며 부풀다 작은 방울 몇 개로 갈라지고, 그 방울이 다시 작은 고리가 되어 가는 크림 실에 매달린 나무처럼 패널 아래로 늘어져요. K3 은 한 고리가 갈라지는 방울 수를 셋에서 여섯으로 늘리고, K1 을 누르면 방울이 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-milk-ring","type":"code","name":"milk-ring","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=3..6, Gel=1..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":3,"max":6},{"name":"Gel","min":1,"max":5}],"start":[0,2,3,1],"measures":{"motion":0.0728,"detail":0.0206,"edges":0.212,"complexity":1.5604,"coverage":1,"colour":0.1167,"drift":0.0533},"knobResponse":[0.2862,0.0564,0.077,0.0544]},{"slug":"millefiori","title":"Millefiori","family":"glass","round":20,"note":"무라노 밀레피오리 접시 위로 시야가 천천히 미끄러지며, 1 LED 고리와 꽃잎으로 된 유리 막대 조각 수백 개가 어두운 유리에 촘촘히 박혀 지나가요. K1 을 누르면 새로 뽑은 막대로 만든 접시가 오른쪽에서 밀려 들어와요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-millefiori","type":"code","name":"millefiori","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..4, Speed=0.2..3, Canes=6..12, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":4},{"name":"Speed","min":0.2,"max":3},{"name":"Canes","min":6,"max":12},{"name":"Light","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":1.2091,"detail":0.3373,"edges":0.8101,"complexity":1.6267,"coverage":1,"colour":0.5579,"drift":0.0871},"knobResponse":[0.1882,0.3627,0.3509,0.1412]},{"slug":"mirror-curves","title":"Mirror Curves","family":"topology","round":58,"note":"4 × 8 점 판 위를 빛줄기가 45도로 달리다 거울에 튕겨 여덟 가닥의 교대 고리를 짜고, 1초쯤마다 거울 하나가 돌거나 자리를 옮겨 가닥이 합쳐지거나 갈라지면 새 색이 그 거울에서부터 가닥을 따라 퍼져요. K3 을 누르면 4초 동안 테두리만 남은 판이 gcd(4, 8) = 4 가닥으로 엮여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mirror-curves","type":"code","name":"mirror-curves","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mirrors=0.5..1, Join=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mirrors","min":0.5,"max":1},{"name":"Join","min":0,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.1626,"detail":0.3176,"edges":0.1951,"complexity":0.1695,"coverage":0.5,"colour":0.3194,"drift":0.0208},"knobResponse":[0.0759,0.0813,0.0562,0.0517]},{"slug":"mitosis","title":"Mitosis","family":"microbe","round":27,"note":"검은 바탕에 찍은 면역형광 사진 속 세포 배양이에요. DNA 는 파랑, 미세소관은 초록, 액틴은 빨강으로 물든 세포가 둥글게 말려 염색체를 두 방추극 사이에 세우고, 양쪽 극으로 끌어 나눈 뒤 빨간 수축 고리에서 잘록해져 둘이 돼요. K1 이 염료를 바꾸고, 누르면 가운데 세포가 바로 분열을 시작해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-mitosis","type":"code","name":"mitosis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stain=0..1, Speed=0.2..3, Cells=9..17, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stain","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cells","min":9,"max":17},{"name":"Zoom","min":0,"max":1}],"start":[0,2,9,0.06],"measures":{"motion":0.3411,"detail":0.1419,"edges":0.8838,"complexity":0.8038,"coverage":0.2626,"colour":0.5399,"drift":0.2023},"knobResponse":[0.1544,0.1632,0.2075,0.2066]},{"slug":"miura-ori","title":"Miura-ori","family":"space","round":75,"note":"합동인 평행사변형으로 된 미우라 접기 판이 자유도 하나로 접혔다 펴지며, 면이 두 빛 사이에서 네 빛깔로 뒤집히고 판이 가로세로로 함께 줄어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-miura-ori","type":"code","name":"miura-ori","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sector=55..85, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sector","min":55,"max":85},{"name":"Light","min":0,"max":1}],"start":[0,2,55,0.06],"measures":{"motion":0.711,"detail":0.0923,"edges":0.6551,"complexity":0.2395,"coverage":0.9508,"colour":0.2499,"drift":0.3464},"knobResponse":[0.2388,0.4201,0.2929,0.4452]},{"slug":"mobius-energy","title":"Möbius Energy","family":"topology","round":48,"note":"공간을 비틀고 짜서 엉킨 매듭 관이 뫼비우스 에너지의 기울기를 따라 풀리며 매듭 꼴이 허락하는 만큼만 펴지고, 아래 띠에는 에너지가 떨어지는 자취가 그려져요. K3 은 세잎 매듭에서 8자 매듭, 오엽 매듭, 5₂ 매듭을 지나 풀린 고리까지 고르고, K4 는 구기는 세기이고, K1 을 누르면 바로 다시 구겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mobius-energy","type":"code","name":"mobius-energy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knot=0..4, Crumple=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knot","min":0,"max":4},{"name":"Crumple","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1874,"detail":0.0359,"edges":0.5566,"complexity":0.3706,"coverage":0.1735,"colour":0.187,"drift":0.1299},"knobResponse":[0.0473,0.0817,0.0842,0.0625]},{"slug":"mobius-loxodrome","title":"Möbius Loxodrome","family":"geometry","round":43,"note":"패널 위아래 바깥에 둔 두 고정점 사이로, 칸마다 밝은 톱니 물결이 비스듬히 그어진 체커판이 흘러요. 위의 고정점에서 나온 칸들이 두 점을 지나는 원을 따라 아래 고정점으로 빨려 들어가고, 축은 42초에 한 번 7도씩 기울었다 돌아와요. K3 을 올리면 쌍곡형 변환이 록소드롬형으로 바뀌어 칸의 줄이 이중 나선으로 감겨요. K4 는 고정점을 패널 끝까지 끌어와 칸들이 거기서 부채처럼 퍼져 나오게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mobius-loxodrome","type":"code","name":"mobius-loxodrome","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Twist=0..1, Poles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Twist","min":0,"max":1},{"name":"Poles","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7663,"detail":0.2144,"edges":0.1498,"complexity":2.2833,"coverage":0.9557,"colour":0.5271,"drift":0.0269},"knobResponse":[0.4067,0.3426,0.3284,0.3291]},{"slug":"mobius-type","title":"Möbius Type","family":"type","round":79,"note":"패널 높이로 선 종이 띠가 천천히 돌고, 가운데 찍힌 THE OTHER SIDE OF THIS LINE IS THIS LINE 은 띠를 두 바퀴 돌아야 제 첫 글자를 만나요. 반 꼬임을 짝수로 돌리면 THIS LINE HAS A BACK 이 한 바퀴에 닫히고 뒷면은 빈 종이예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mobius-type","type":"code","name":"mobius-type","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Twists=1..4, Paper=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Twists","min":1,"max":4},{"name":"Paper","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1383,"detail":0.0375,"edges":0.6297,"complexity":0.7232,"coverage":0.4278,"colour":0.1426,"drift":0.1944},"knobResponse":[0.0534,0.1191,0.1175,0.0461]},{"slug":"modular-hyperbola","title":"Modular Hyperbola","family":"number","round":81,"note":"소수 p 로 나눈 곱셈표를 톱니로 칠해서, 흰 날이 모듈러 쌍곡선 xy ≡ c 를 그리며 판을 옮겨 다녀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-modular-hyperbola","type":"code","name":"modular-hyperbola","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Prime=-3..4, Band=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Prime","min":-3,"max":4},{"name":"Band","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3421,"detail":0.3364,"edges":0.7689,"complexity":2.3909,"coverage":0.9008,"colour":0.2238,"drift":0.0402},"knobResponse":[0.1585,0.4526,0.3684,0.4372]},{"slug":"moffatt-eddies","title":"Moffatt Eddies","family":"sim","round":63,"note":"28도 쐐기가 패널을 채우고, 모서리로 갈수록 2.005배씩 작아지며 도는 방향이 번갈아 바뀌는 모팻 소용돌이가 흰 분리 유선 사이에 쌓여요. 추적 입자가 소용돌이마다 돌고, 화면은 3초에 소용돌이 하나씩 모서리로 파고들어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-moffatt-eddies","type":"code","name":"moffatt-eddies","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Angle=28..100, Truth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Angle","min":28,"max":100},{"name":"Truth","min":0,"max":1}],"start":[0,2,28,0.06],"measures":{"motion":1.178,"detail":0.084,"edges":0.6213,"complexity":0.9132,"coverage":0.54,"colour":0.1947,"drift":0.0724},"knobResponse":[0.0774,0.1394,0.2077,0.0548]},{"slug":"moire-rings","title":"Moire Rings","family":"wave","round":1,"note":"동심원 두 벌이 서로 지나가고, 어긋나는 자리에 아무도 그리지 않은 무늬가 생겨요.","why":"고리 무늬 둘이 겹쳐 간섭 무늬를 만들어요. 0707 의 과녁처럼 또렷하고(가장자리 1.00) 단순해요(복잡도 0.18).","block":0,"ramped":false,"layer":{"id":"layer-moire-rings","type":"code","name":"moire-rings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.1..6, Rings=5..16, Spread=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.1,"max":6},{"name":"Rings","min":5,"max":16},{"name":"Spread","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":1.5703,"detail":0.2108,"edges":1,"complexity":0.1822,"coverage":0.7502,"colour":0.4676,"drift":0.1626},"knobResponse":[0.2556,0.2849,0.3431,0.2821]},{"slug":"monge-transport","title":"Monge Transport","family":"algo","round":61,"note":"한쪽 반의 도형에 모인 입자 더미가 다른 반 도형의 자리와 아무렇게나 짝지어졌다가, 거리 합이 짧아지는 쌍마다 목적지를 맞바꿔 엇갈림이 풀린 뒤 한꺼번에 광선을 따라 미끄러져 새 도형으로 내려앉아요. 입자 색은 처음 도형에서의 각도라서 도착한 색 바퀴가 옮김대로 다시 놓여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-monge-transport","type":"code","name":"monge-transport","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Particles=150..400, Exponent=1..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Particles","min":150,"max":400},{"name":"Exponent","min":1,"max":2}],"start":[0,2,150,1],"measures":{"motion":0.3863,"detail":0.0385,"edges":0.6061,"complexity":0.6759,"coverage":0.2502,"colour":0.2956,"drift":0.3779},"knobResponse":[0.1121,0.2402,0.0602,0.0409]},{"slug":"mood-tint","title":"Mood Tint","family":"cosmetic","round":34,"note":"판 전체가 열에 색이 바뀌는 짙은 보라 코팅이에요. 보이지 않는 손끝이 누른 자리마다 지문 결이 든 옅은 난초색 타원이 피고, 열이 퍼지며 결부터 흐려지고 이웃 자국과 엉겨 붙었다가 다시 보라 속으로 줄어들어요. K1 을 누르면 손바닥 하나가 1.1초 동안 눌러요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-mood-tint","type":"code","name":"mood-tint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Warmth=-1..1, Blend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Warmth","min":-1,"max":1},{"name":"Blend","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0548,"detail":0.0134,"edges":0.483,"complexity":0.652,"coverage":1,"colour":0.1889,"drift":0.0997},"knobResponse":[0.4028,0.1176,0.1081,0.0933]},{"slug":"morley-triangle","title":"Morley Triangle","family":"geometry","round":42,"note":"큰 삼각형이 정삼각형에 가까운 꼴에서 가늘고 둔한 꼴까지 쉬지 않고 모양을 바꾸는데, 각을 삼등분한 선이 변 옆에서 만나는 세 점은 늘 정삼각형이라 금빛으로 칠한 그 삼각형은 돌며 크기만 바뀌어요. K4 를 올리면 바깥각 삼등분선이 만드는 큰 정삼각형이 뒤에 나타나고, 그 변이 안쪽 정삼각형과 늘 나란해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-morley-triangle","type":"code","name":"morley-triangle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wander=0..1, Exterior=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wander","min":0,"max":1},{"name":"Exterior","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3452,"detail":0.0243,"edges":1,"complexity":0.0704,"coverage":0.436,"colour":0.2815,"drift":0.2936},"knobResponse":[0.1485,0.1674,0.1396,0.0445]},{"slug":"moth-lamp","title":"Moth Lamp","family":"insect","round":20,"note":"벽돌집 처마 밑 사슬에 매달린 옛 등이 흔들리고, 나방이 어둠에서 나선을 그리며 날아와 등을 돌다가 유리와 불빛 든 벽돌에 날개를 펴고 앉아요. K1 을 누르면 박쥐가 빛 속으로 날아들어 나방 한 마리를 채 가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-moth-lamp","type":"code","name":"moth-lamp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Moths=12..120, Breeze=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Moths","min":12,"max":120},{"name":"Breeze","min":-1,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.1073,"detail":0.0382,"edges":0.2646,"complexity":2.2012,"coverage":0.2737,"colour":0.0944,"drift":0.0456},"knobResponse":[0.0525,0.0467,0.0451,0.0578]},{"slug":"motility-clusters","title":"Motility Clusters","family":"particle","round":50,"note":"스스로 헤엄치는 원판 1,434개가 밀어내기만 하는데도 서로 막혀 옅은 덩어리로 뭉치고, 안쪽을 보는 가장자리 원판이 헤엄치는 방향의 색으로 덩어리를 두르는 동안 흐린 기체가 그 사이를 달리고 덩어리끼리 합쳐져요. K3 은 페클레 수, K4 는 원판이 덮는 몫이고, K1 을 누르면 고른 기체로 흩어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-motility-clusters","type":"code","name":"motility-clusters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pe=-1..1, Packing=0.55..0.72","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pe","min":-1,"max":1},{"name":"Packing","min":0.55,"max":0.72}],"start":[0,2,0,0.55],"measures":{"motion":2.1227,"detail":0.1283,"edges":0.4244,"complexity":1.7585,"coverage":0.7263,"colour":0.3317,"drift":0.1865},"knobResponse":[0.2286,0.2646,0.3301,0.3674]},{"slug":"mouse-tale","title":"Mouse's Tale","family":"type","round":65,"note":"루이스 캐럴의 생쥐 이야기가 책에 찍힌 꼬리 모양 그대로 패널을 타고 내려가요. 아래로 갈수록 글자가 5×7 에서 점으로 작아지고, 꼬리는 천천히 흔들려요","why":"","block":0,"ramped":false,"layer":{"id":"layer-mouse-tale","type":"code","name":"mouse-tale","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sway=1..3, Taper=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sway","min":1,"max":3},{"name":"Taper","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.5174,"detail":0.1092,"edges":1,"complexity":0.1464,"coverage":0.1729,"colour":0.236,"drift":0.0469},"knobResponse":[0.0671,0.1021,0.0765,0.0779]},{"slug":"moving-sofa","title":"Moving Sofa","family":"geometry","round":34,"note":"폭 14 LED 의 ㄇ자 복도를 해머슬리 소파가 오른쪽 다리로 올라와 모퉁이를 돌고, 위를 건너 왼쪽 다리로 내려가요. 모퉁이마다 안쪽 모서리가 소파의 금빛 반원 홈 안을 지나가고, 소파 뒤에 옅게 붙어 온 띠가 벽에 깎여 나가 소파 모양만 남아요. K3 은 홈의 반지름을 0 의 반원판에서 넓이 2 인 소파까지 바꿔요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-moving-sofa","type":"code","name":"moving-sofa","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hole=-1..1, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hole","min":-1,"max":1},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3083,"detail":0.0578,"edges":0.2742,"complexity":0.3757,"coverage":0.3481,"colour":0.1671,"drift":0.1766},"knobResponse":[0.06,0.1158,0.0644,0.0648]},{"slug":"multiple-master","title":"Multiple Master","family":"type","round":73,"note":"굵기와 폭의 끝에 둔 마스터 넷의 점을 섞어 MASTER 를 짓고, 아래 설계 공간 정사각형에서 그 자리가 노브 둘레를 천천히 떠돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-multiple-master","type":"code","name":"multiple-master","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Weight=-1..1, Width=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Weight","min":-1,"max":1},{"name":"Width","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0232,"detail":0.0651,"edges":0.7348,"complexity":0.3207,"coverage":0.2362,"colour":0.1346,"drift":0.0364},"knobResponse":[0.054,0.0515,0.0824,0.1179]},{"slug":"multiplicative-cascade","title":"Multiplicative Cascade","family":"fractal","round":56,"note":"판을 가로세로 번갈아 열세 번 반씩 나눈 무게가 8 × 8 칸마다 민트와 보라 조각으로, LED 하나하나는 반짝이는 밝기로 보이고, 무게가 큰 반쪽부터 LED 까지 한 단씩 바뀌며 질량이 반쪽 사이를 오가요. Spread 를 올리면 판이 거의 꺼지고 몇 점의 불꽃만 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-multiplicative-cascade","type":"code","name":"multiplicative-cascade","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=0.4..1.6, Couple=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":0.4,"max":1.6},{"name":"Couple","min":-1,"max":1}],"start":[0,2,0.4,0.06],"measures":{"motion":0.0951,"detail":0.1173,"edges":0.32,"complexity":2.7161,"coverage":0.9744,"colour":0.3505,"drift":0.1655},"knobResponse":[0.3847,0.1422,0.2695,0.2036]},{"slug":"multiplicative-chaos","title":"Multiplicative Chaos","family":"noise","round":70,"note":"로그 상관 가우스장을 깊은 파랑 부조로 깔고 그 지수로 만든 카안의 측도를 금빛으로 띄우면, γ 가 오를수록 질량이 장의 가장 높은 몇 LED 로 모여 흰 점이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-multiplicative-chaos","type":"code","name":"multiplicative-chaos","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gamma=1..2.5, Cutoff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gamma","min":1,"max":2.5},{"name":"Cutoff","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2485,"detail":0.3458,"edges":0.7865,"complexity":2.3585,"coverage":0.7528,"colour":0.4307,"drift":0.0703},"knobResponse":[0.3086,0.2078,0.0886,0.2452]},{"slug":"mummy","title":"Mummy","family":"halloween","round":45,"note":"패널 높이만 한 미라가 팔을 내밀고 손을 늘어뜨린 채 보라 무덤에서 비틀거리고, 붕대 끝이 바람에 펄럭여요. 몇 초마다 가슴의 붕대 한 줄이 풀려 꼬이며 날아가고, 그 자리에 속이 빈 초록 빛이 드러났다가 붕대가 다시 감겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mummy","type":"code","name":"mummy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Wind=0..1, Torch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Torch","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3511,"detail":0.0606,"edges":0.3583,"complexity":0.5069,"coverage":0.3198,"colour":0.1397,"drift":0.0926},"knobResponse":[0.0355,0.0967,0.0488,0.0341]},{"slug":"murmuration","title":"Murmuration","family":"halloween","round":50,"note":"노을 진 하늘에서 까마귀 떼가 찌르레기처럼 접혔다 펼쳐지며 돌다가, 모두 날아들어 커다란 해골이 되고 턱을 떨구며 눈을 번뜩인 뒤 흩어져요. K3 은 까마귀 수, K4 는 떼가 짓는 모양이고, K1 을 누르면 바로 모여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-murmuration","type":"code","name":"murmuration","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flock=0..1, Shape=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flock","min":0,"max":1},{"name":"Shape","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.752,"detail":0.0663,"edges":0.6189,"complexity":0.2337,"coverage":0.7192,"colour":0.4564,"drift":0.2922},"knobResponse":[0.3073,0.1826,0.0494,0.0872]},{"slug":"mushroom-billiard","title":"Mushroom Billiard","family":"particle","round":79,"note":"반원 갓 아래로 곧은 줄기가 패널 밑까지 내려간 버섯 당구대에서 공 360개가 튀어요. 갓 중심에서 제 길까지 거리가 줄기 반폭보다 먼 공은 금빛으로 갓만 돌고, 나머지는 하늘색으로 줄기와 갓을 다 헤매요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mushroom-billiard","type":"code","name":"mushroom-billiard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stem=0.3..0.9, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stem","min":0.3,"max":0.9},{"name":"Trail","min":0,"max":1}],"start":[0,2,0.3,0.06],"measures":{"motion":2.2607,"detail":0.1169,"edges":0.6098,"complexity":0.8241,"coverage":0.2387,"colour":0.23,"drift":0.0455},"knobResponse":[0.0843,0.1136,0.1355,0.0898]},{"slug":"music-box","title":"Music Box","family":"halloween","round":49,"note":"원통의 핀이 빗살을 튕기면 해골 발레리나가 돌다가, 태엽이 풀려 음악이 늘어지면 우리를 보고 멈춰 눈구멍이 초록으로 빛나고, 보이지 않는 손이 열쇠를 감아 다시 시작해요. K3 은 곡 셋 가운데 하나를, K4 는 태엽을 감은 만큼이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-music-box","type":"code","name":"music-box","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Velvet=0..1, Speed=0.2..3, Tune=0..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Velvet","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tune","min":0,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1782,"detail":0.0682,"edges":0.7127,"complexity":0.1466,"coverage":0.725,"colour":0.2988,"drift":0.089},"knobResponse":[0.0697,0.0754,0.0603,0.0453]},{"slug":"napier-bones","title":"Napier's Bones","family":"type","round":80,"note":"네이피어 막대 다섯이 위에서 하나씩 떨어져 1617 을 세우고, 곱수 67 의 7 과 6 이 가리키는 줄이 차례로 켜져 대각선을 오른쪽부터 받아올림과 함께 더한 부분곱 둘과 그 합 108339 가 아래에 적히면, 막대가 떨어져 나가고 다음 문제가 내려와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-napier-bones","type":"code","name":"napier-bones","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Problem=0..5, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Problem","min":0,"max":5},{"name":"Bands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0854,"detail":0.0894,"edges":0.4963,"complexity":0.1419,"coverage":0.567,"colour":0.08,"drift":0.1053},"knobResponse":[0.053,0.1645,0.0564,0.0388]},{"slug":"needlepoint","title":"Needlepoint","family":"textile","round":19,"note":"슬레이트 틀의 인쇄 캔버스를 바늘이 오른쪽 위 구석부터 바스켓위브로 한 대각선씩 메워 가요. 앵무새 쿠션이나 검은 바탕의 베를린 장미, 알파벳 샘플러가 다 차면 틀이 굴러 새 캔버스를 감아 와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-needlepoint","type":"code","name":"needlepoint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wool=0..1, Speed=0.2..3, Design=0..2, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wool","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Design","min":0,"max":2},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1581,"detail":0.3325,"edges":0.8053,"complexity":1.8885,"coverage":0.6687,"colour":0.2513,"drift":0.043},"knobResponse":[0.1114,0.0649,0.1048,0.0607]},{"slug":"neon-alley","title":"Neon Alley","family":"city","round":16,"note":"밤 골목의 벽에 유리관을 구부린 네온 그림 간판이 지붕부터 젖은 길까지 걸려서, 관이 하나씩 켜지고 화살표가 달리고 지친 관 하나가 지직거려요. K1 을 누르면 정전이 됐다가 간판이 하나씩 다시 켜지고, K2 를 누르면 간판이 새로 걸려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-neon-alley","type":"code","name":"neon-alley","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pace=0..4, Wear=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pace","min":0,"max":4},{"name":"Wear","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7208,"detail":0.1177,"edges":0.5393,"complexity":0.4294,"coverage":0.2587,"colour":0.5724,"drift":0.1545},"knobResponse":[0.2671,0.0583,0.0882,0.0858]},{"slug":"neon-spreading","title":"Neon Spreading","family":"type","round":79,"note":"천천히 도는 흰 선 격자가 세로로 쌓인 큰 글자 셋을 지날 때만 선이 색을 띠고, 선 사이 LED 는 다 꺼져 있는데도 눈이 글자 안을 그 색의 옅은 막으로 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-neon-spreading","type":"code","name":"neon-spreading","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pitch=4..9, Fill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pitch","min":4,"max":9},{"name":"Fill","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.8708,"detail":0.2853,"edges":0.8034,"complexity":1.2133,"coverage":0.5927,"colour":0.197,"drift":0.0322},"knobResponse":[0.0813,0.2758,0.2679,0.0455]},{"slug":"night-flight","title":"Night Flight","family":"city","round":22,"note":"여객기 창으로 내려다본 밤 도시예요. 1 LED 가로등이 바둑판 길과 대로, 강 위 다리를 따라 레이스처럼 이어지고, 고속도로에는 흰 전조등과 빨간 미등이 흘러요. 도시는 초록 항법등과 흰 섬광등이 달린 날개 끝을 지나 왼쪽 아래로 천천히 미끄러져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-night-flight","type":"code","name":"night-flight","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamps=0..1, Speed=0.2..3, Grid=0..1, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamps","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grid","min":0,"max":1},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3475,"detail":0.3276,"edges":0.2578,"complexity":1.0097,"coverage":0.5044,"colour":0.2424,"drift":0.0667},"knobResponse":[0.0508,0.1119,0.0511,0.1477]},{"slug":"nine-fold-seal","title":"Nine-fold Seal","family":"type","round":69,"note":"주홍 인주로 찍은 세로 인영에 한글 여덟 음절이 오른쪽 줄부터 내리읽히고, 가로획마다 한 LED 선으로 겹겹이 접혀 칸을 메웠다가 몇 초마다 민 글자로 펴진 뒤 다음 글로 다시 접혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-nine-fold-seal","type":"code","name":"nine-fold-seal","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Ink=0..1, Speed=0.2..3, Plain=0..1, Press=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Ink","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Plain","min":0,"max":1},{"name":"Press","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0832,"detail":0.2165,"edges":1,"complexity":2.379,"coverage":1,"colour":0.3919,"drift":0.2293},"knobResponse":[0.2853,0.0641,0.0721,0.0605]},{"slug":"nixie","title":"Nixie","family":"circuit","round":21,"note":"회로판 소켓에 선 닉시관 속, 육각 그물 뒤에 겹겹이 선 숫자 철사 가운데 하나가 네온 주황으로 빛나요. 숫자가 돌다가 하나씩 멈추고, Mode 노브를 돌리면 주파수 계수기나 시계가 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-nixie","type":"code","name":"nixie","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gas=0..1, Speed=0.2..3, Rows=1..3, Mode=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gas","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rows","min":1,"max":3},{"name":"Mode","min":0,"max":3}],"start":[0,2,1,0.06],"measures":{"motion":0.4696,"detail":0.0533,"edges":0.238,"complexity":1.7971,"coverage":0.5829,"colour":0.1892,"drift":0.1676},"knobResponse":[0.0576,0.0717,0.1676,0.0732]},{"slug":"noborigama","title":"Noborigama","family":"pottery","round":26,"note":"밤 언덕의 오름가마를 세로로 잘라 봐요. 불이 그릇 쌓인 칸들을 타고 올라 아래 칸은 희고 위 칸은 붉으며, 장작을 넣을 때마다 감시 구멍에서 불길이, 굴뚝에서 검은 연기와 불티가 나와요. K1 은 소성 날짜를 바꾸고, 누르면 모든 구멍에 한꺼번에 불을 넣어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-noborigama","type":"code","name":"noborigama","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Firing=-1..1, Speed=0.2..3, Chambers=3..6, Draft=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Firing","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Chambers","min":3,"max":6},{"name":"Draft","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.141,"detail":0.0581,"edges":0.3934,"complexity":1.5788,"coverage":0.9717,"colour":0.2311,"drift":0.0397},"knobResponse":[0.0974,0.0413,0.0659,0.0443]},{"slug":"nodal-domains","title":"Nodal Domains","family":"noise","round":54,"note":"같은 파장의 평면파 40개를 무작위 방향으로 겹친 베리의 무작위 파동을 0 근처에서 잘라, 부호가 같은 이웃끼리 이어진 마디 영역마다 납작한 한 색을 칠해요. 0 위의 영역은 작을 때 장미색이다가 커지면 주황을 지나 금색이 되고 0 아래는 파랑 보라에서 청록으로 가며, 가장 큰 영역은 옅은 하늘색으로 패널을 가로지르고, 파동마다 위상이 제 빠르기로 돌아서 안장점에서 영역이 이어지고 끊길 때마다 흰 불꽃이 튀어요. K3 은 파장, K4 는 자르는 높이예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-nodal-domains","type":"code","name":"nodal-domains","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=0..1, Level=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wavenumber","min":0,"max":1},{"name":"Level","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3691,"detail":0.2893,"edges":0.861,"complexity":1.3149,"coverage":0.8785,"colour":0.6244,"drift":0.0352},"knobResponse":[0.4669,0.3447,0.4004,0.4803]},{"slug":"noordzij-cube","title":"Noordzij Cube","family":"type","round":82,"note":"펜이 nano, bone, ego 를 한 획씩 쓰고, 노브 둘이 넓은 펜촉의 병진과 뾰족한 펜의 팽창 사이와 대비의 양을 옮겨서 같은 뼈대의 모든 획 굵기를 다시 칠해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-noordzij-cube","type":"code","name":"noordzij-cube","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Model=0..1, Hairline=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Model","min":0,"max":1},{"name":"Hairline","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0602,"detail":0.0805,"edges":0.6975,"complexity":0.8378,"coverage":0.3372,"colour":0.3654,"drift":0.2511},"knobResponse":[0.1715,0.1763,0.0574,0.0468]},{"slug":"ogham","title":"Ogham","family":"type","round":68,"note":"선돌 모서리를 줄기 삼아 오검 글이 아래에서 위로 한 획씩 새겨지고, 옆의 라틴 글자가 획 수를 세어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ogham","type":"code","name":"ogham","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Turn=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Turn","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.164,"detail":0.0423,"edges":0.2795,"complexity":1.2395,"coverage":0.6764,"colour":0.0804,"drift":0.0437},"knobResponse":[0.0601,0.0613,0.0613,0.0962]},{"slug":"old-well","title":"Old Well","family":"halloween","round":50,"note":"달빛 아래 잘라 본 돌우물에 두레박이 내려가 검은 물에 닿으면, 물이 독한 초록으로 빛나며 두 눈이 뜨고 창백한 손이 올라와 두레박을 물속으로 끌고 가요. 감아올린 두레박에 그 손이 매달려 오기도 해요. K3 은 달의 자리, K4 는 물 위 안개이고, K1 을 누르면 손잡이를 놓아 두레박이 바로 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-old-well","type":"code","name":"old-well","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Moon=0..1, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Moon","min":0,"max":1},{"name":"Fog","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1312,"detail":0.0408,"edges":0.2457,"complexity":0.5075,"coverage":0.8029,"colour":0.1255,"drift":0.0802},"knobResponse":[0.06,0.0468,0.0499,0.0422]},{"slug":"oloid","title":"Oloid","family":"space","round":47,"note":"서로의 중심을 지나는 두 원의 볼록 껍질이 곧은 괘선 하나로 바닥을 짚으며 흔들흔들 굴러오고, 굴러간 겉이 전개도 그대로 바닥에 찍혀 두 색 뱀이 맞물린 띠로 패널 위로 멀어져요. K3 은 카메라 기울기, K4 는 자국이 바래는 빠르기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-oloid","type":"code","name":"oloid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Fade=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Fade","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2675,"detail":0.0235,"edges":0.4693,"complexity":0.2507,"coverage":0.3681,"colour":0.2837,"drift":0.0431},"knobResponse":[0.153,0.1039,0.1344,0.0769]},{"slug":"one-bit","title":"One Bit","family":"pixel","round":17,"note":"달밤 바닷가 벼랑에 선 등대를 두 색과 Bayer 순서 디더링만으로 그린 1비트 화면이에요. 빛줄기가 돌고 구름이 달 앞을 지나고 안개 둑이 바다 위에서 오르내려도 한 프레임에 뒤집히는 픽셀은 열 개 안팎이에요. K1 이 앰버 단말기, 게임보이, 매킨토시, 전자잉크, 플레이데이트의 두 색을 골라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-one-bit","type":"code","name":"one-bit","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Time=0.2..3, Fog=0..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Time","min":0.2,"max":3},{"name":"Fog","min":0,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0337,"detail":0.3203,"edges":1,"complexity":0.0918,"coverage":0.242,"colour":0.3801,"drift":0.0416},"knobResponse":[0.2143,0.057,0.0812,0.0548]},{"slug":"op-stripes","title":"Op Stripes","family":"wave","round":1,"note":"브리짓 라일리 식의 두 색 가로줄이에요. 밑으로 지나가는 넓은 부풂 둘이 줄 간격을 벌려서 평평한 패널이 부푸는 것처럼 보여요.","why":"굵은 줄무늬가 거의 안 움직여요(움직임 0.06).","block":1,"ramped":false,"layer":{"id":"layer-op-stripes","type":"code","name":"op-stripes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Drift=0.1..6, Stripes=14..26, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Drift","min":0.1,"max":6},{"name":"Stripes","min":14,"max":26},{"name":"Swell","min":0,"max":1}],"start":[0,2,14,0.06],"measures":{"motion":0.0622,"detail":0.0792,"edges":1,"complexity":0.0654,"coverage":1,"colour":0.6118,"drift":0.0499},"knobResponse":[0.4596,0.1655,0.1894,0.1993]},{"slug":"optical-kerning","title":"Optical Kerning","family":"type","round":72,"note":"낱말 다섯이 상자 사이를 같게 띄워 섰다가 글자 사이 흰 자리가 다 같은 넓이가 될 때까지 옆으로 미끄러지고, 틈마다 넓이를 말하던 빛이 한 색으로 모여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-optical-kerning","type":"code","name":"optical-kerning","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tracking=-1..1, Depth=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tracking","min":-1,"max":1},{"name":"Depth","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1278,"detail":0.0837,"edges":0.6066,"complexity":0.6528,"coverage":0.4051,"colour":0.2213,"drift":0.1788},"knobResponse":[0.0822,0.1737,0.1035,0.1471]},{"slug":"orb-weaver","title":"Orb Weaver","family":"halloween","round":43,"note":"보라 몸에 주황 십자가 박힌 왕거미가 128줄을 다 쓰는 둥근 그물을 짜요. 다리실을 띄워 걸고 틀을 친 뒤 방사실을 하나씩 내고, 임시 나선을 거쳐 끈끈한 나선을 바깥에서 안으로 감는데, 긴 아래쪽에서는 오가며 되돌아 채워요. 다 짠 그물에 주황 이슬이 맺혀 반짝이다 돌풍에 찢겨 날아가면 새 그물이 시작돼요. K3 은 방사실을 20개에서 44개로 늘리고, K4 는 바람으로 그물을 6 LED 까지 흔들며, K1 을 누르면 바로 찢어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-orb-weaver","type":"code","name":"orb-weaver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Radii=20..44, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Radii","min":20,"max":44},{"name":"Wind","min":0,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.2322,"detail":0.0987,"edges":0.5353,"complexity":1.1946,"coverage":0.3357,"colour":0.0806,"drift":0.0427},"knobResponse":[0.0472,0.0275,0.0912,0.1028]},{"slug":"order-k-voronoi","title":"Order-k Voronoi","family":"cells","round":76,"note":"떠도는 사이트 열 개에서 LED 마다 가장 가까운 k 개의 모임으로 칠한 차수 k 보로노이 그림이 서고, 아래 막대가 차수마다 영역 수를 세요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-order-k-voronoi","type":"code","name":"order-k-voronoi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Order=1..17, Sites=10..18, Drift=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Order","min":1,"max":17},{"name":"Sites","min":10,"max":18},{"name":"Drift","min":0,"max":1}],"start":[0,2,10,0.06],"measures":{"motion":0.0279,"detail":0.0429,"edges":0.1617,"complexity":1.1635,"coverage":0.9165,"colour":0.5501,"drift":0.0244},"knobResponse":[0.4215,0.2313,0.2691,0.0946]},{"slug":"origami","title":"Origami","family":"paper","round":26,"note":"어두운 호두나무 탁자의 램프 아래에서 청록 종이 한 장이 아홉 단계로 한 주름씩 접혀 종이학이 돼요. 학은 날개를 한 번 친 뒤 다시 펼쳐지고, 펼친 종이에는 산접기와 골접기의 주름 무늬가 남아요. K1 이 세이가이하 무늬 종이와 금박 같은 종이를 고르고, 누르면 학이 바로 펼쳐져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-origami","type":"code","name":"origami","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Sheets=1..3, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sheets","min":1,"max":3},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2431,"detail":0.0239,"edges":0.722,"complexity":0.6298,"coverage":0.2643,"colour":0.177,"drift":0.2549},"knobResponse":[0.2136,0.2519,0.2517,0.0599]},{"slug":"ostwald-ripening","title":"Ostwald Ripening","family":"sim","round":57,"note":"수백 개의 방울이 묽은 용액에 멈춰 선 채 물질을 주고받아서, 평균 반지름보다 작은 방울은 자홍으로 점점 빨리 줄다가 꺼지고 큰 방울은 초록으로 부풀어요. 용액은 작은 방울 둘레에서 옅은 자홍으로, 큰 방울 둘레에서 옅은 초록으로 빛나고, 그 사이를 용질 알갱이가 작은 방울에서 큰 방울로 흘러가요. 방울이 처음의 18% 아래로 줄면 빈자리에 새 무리가 맺혀요. K3 은 새 무리의 방울 수(200~500), K4 는 처음 반지름이 고르지 않은 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ostwald-ripening","type":"code","name":"ostwald-ripening","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=200..500, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":200,"max":500},{"name":"Spread","min":0,"max":1}],"start":[0,2,200,0.06],"measures":{"motion":0.3344,"detail":0.0919,"edges":0.4066,"complexity":1.7547,"coverage":0.46,"colour":0.2135,"drift":0.0942},"knobResponse":[0.1151,0.1039,0.2008,0.1811]},{"slug":"outer-billiards","title":"Outer Billiards","family":"geometry","round":30,"note":"정오각형 밖의 평면을 점마다 꼭짓점 대칭 뛰기 몇 번 만에 제자리로 오는지로 칠했어요. 십각형과 오각형 목걸이가 둘레를 감고, 흰 점 하나가 제 궤도를 뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-outer-billiards","type":"code","name":"outer-billiards","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=5..12, Zoom=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":5,"max":12},{"name":"Zoom","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.5156,"detail":0.1148,"edges":0.7368,"complexity":0.7773,"coverage":0.9999,"colour":0.6754,"drift":0.0832},"knobResponse":[0.5981,0.1953,0.4355,0.388]},{"slug":"palimpsest","title":"Palimpsest","family":"type","round":68,"note":"긁어낸 아르키메데스의 글 위에 직각으로 쓴 그리스어 기도문을 비추는 빛의 띠를 노브로 바꾸면, 평범한 빛에서 거의 사라진 옛 글이 자외선에서 어둡게 살아나고 의사색에서 붉게 갈라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-palimpsest","type":"code","name":"palimpsest","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Band=0..1, Speed=0.2..3, Page=0..3, Ink=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Band","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Page","min":0,"max":3},{"name":"Ink","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1376,"detail":0.0877,"edges":0.1782,"complexity":2.6742,"coverage":1,"colour":0.1535,"drift":0.0588},"knobResponse":[0.2125,0.0897,0.0919,0.0947]},{"slug":"pancakes","title":"Pancakes","family":"kitchen","round":21,"note":"길든 철판을 위에서 내려다봐요. 국자로 부은 반죽이 퍼지고 기포가 올라와 터지며 구멍을 남기는 동안, 뒤집개가 하나씩 뒤집어 노릇한 면을 보이고 다 익은 것을 숯색 접시에 쌓아요. K1 을 누르면 가장 많이 익은 것부터 바로 뒤집거나 접시로 옮겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pancakes","type":"code","name":"pancakes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Batter=0..1, Speed=0.2..3, Pancakes=6..12, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Batter","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pancakes","min":6,"max":12},{"name":"Heat","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2802,"detail":0.2275,"edges":0.2381,"complexity":2.2758,"coverage":0.9979,"colour":0.2408,"drift":0.1011},"knobResponse":[0.1406,0.1266,0.1876,0.1386]},{"slug":"paper-lantern-ghost","title":"Paper Lantern Ghost","family":"halloween","round":50,"note":"비 오는 보라 밤에 처마의 종이 등이 흔들리다 외눈을 뜨고, 이음매가 찢어져 붉은 혀를 늘어뜨리며 웃어요. 그 아래로 외눈 종이우산이 외다리로 웅덩이를 튀기며 뛰어다녀요. K3 은 비, K4 는 우산이 뛰는 높이예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-paper-lantern-ghost","type":"code","name":"paper-lantern-ghost","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Hop=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rain","min":0,"max":1},{"name":"Hop","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4718,"detail":0.0887,"edges":0.6739,"complexity":0.4158,"coverage":0.8692,"colour":0.2711,"drift":0.1026},"knobResponse":[0.0989,0.1248,0.0626,0.0651]},{"slug":"parallel-transport","title":"Parallel Transport","family":"space","round":68,"note":"도는 구 위에서 금빛 화살을 돌리지 않고 고리를 따라 옮기면, 한 바퀴 뒤 흰 처음 화살 옆에 고리가 두른 넓이만큼 돌아서 서고, 아래 다이얼이 그 넓이를 내내 더해 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-parallel-transport","type":"code","name":"parallel-transport","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Loop=0..3, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Loop","min":0,"max":3},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1882,"detail":0.0419,"edges":0.3666,"complexity":0.9362,"coverage":0.3621,"colour":0.1117,"drift":0.0547},"knobResponse":[0.0452,0.0586,0.1086,0.0534]},{"slug":"party-lights","title":"Party Lights","family":"halloween","round":49,"note":"주황과 보라, 독한 초록, 뼈처럼 흰 전구 줄이 어두운 현관 벽에 처지며 빛을 달리고 반짝이고 숨 쉬듯 켜고 박자에 번쩍이며, 바람이 줄을 그네처럼 흔들면 종이 박쥐들이 실에 매달려 빙글 돌아요. K3 은 전구 줄 수, K4 는 바람이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-party-lights","type":"code","name":"party-lights","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Warmth=-1..1, Speed=0.2..3, Strands=3..7, Gust=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Warmth","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":3,"max":7},{"name":"Gust","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2517,"detail":0.0425,"edges":0.2816,"complexity":0.5989,"coverage":0.5355,"colour":0.1816,"drift":0.0855},"knobResponse":[0.0669,0.0544,0.1598,0.0688]},{"slug":"paternoster","title":"Paternoster","family":"machine","round":19,"note":"옛 사무실 건물의 파테르노스터를 기계실에서 피트까지 잘라 보여요. 나무 칸들이 오른쪽으로 오르고 왼쪽으로 내려오며 꼭대기와 바닥의 사슬 바퀴를 넘어가고, 층마다 사람이 지나가는 칸에 올라타고 내려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-paternoster","type":"code","name":"paternoster","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Floors=3..6, Busy=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Floors","min":3,"max":6},{"name":"Busy","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1311,"detail":0.0811,"edges":0.4174,"complexity":0.5845,"coverage":0.8893,"colour":0.2319,"drift":0.047},"knobResponse":[0.1087,0.0733,0.147,0.0325]},{"slug":"paul-trap","title":"Paul Trap","family":"particle","round":61,"note":"세로축을 따라 늘어선 이온 열여섯 개가 RF q 0.3 에서 지그재그로 서고, q 를 올리면 둥근 점 한 줄로 펴졌다가 0.908 을 넘으면 옆으로 번지며 덫 밖으로 날아가요. 빛나지 않는 불순물 이온 둘이 결정에 어두운 틈을 내요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-paul-trap","type":"code","name":"paul-trap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ions=16..40, RF q=0.3..0.95","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ions","min":16,"max":40},{"name":"RF q","min":0.3,"max":0.95}],"start":[0,2,16,0.3],"measures":{"motion":0.0942,"detail":0.0126,"edges":0.1045,"complexity":0.637,"coverage":0.2057,"colour":0.0778,"drift":0.0178},"knobResponse":[0.0325,0.0318,0.0832,0.0398]},{"slug":"pearcey-cusp","title":"Pearcey Cusp","family":"wave","round":54,"note":"LED 마다 피어시 적분을 셈한 파동장이 패널 위쪽의 밝은 초점에서 아래로 첨점 모양으로 열리고, 그 안에 밝은 점 격자와 정확한 영점 76개가 서는데, 영점은 위상이 감기는 쪽에 따라 분홍과 호박색 점으로 찍히고 물마루는 빛이 가는 대로 아래로 흘러요. K3 은 파수를 올려 무늬를 광선의 첨점 곡선 쪽으로 촘촘하게 하고, K4 는 t³ 항으로 첨점을 옆으로 기울여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pearcey-cusp","type":"code","name":"pearcey-cusp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=-1..1, Tilt=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wavenumber","min":-1,"max":1},{"name":"Tilt","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.384,"detail":0.0526,"edges":0.1171,"complexity":2.2537,"coverage":0.9107,"colour":0.1877,"drift":0.1309},"knobResponse":[0.1581,0.1039,0.1218,0.1151]},{"slug":"pearl-sheen","title":"Pearl Sheen","family":"cosmetic","round":30,"note":"펄 안료를 부은 면이 새틴 결로 흘러내려요. 누운 결은 로즈이고 기운 결은 박막 간섭으로 금빛 쪽으로 넘어가며, 긴 반사띠가 면을 가로질러요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-pearl-sheen","type":"code","name":"pearl-sheen","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shift=0..1, Sheen=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shift","min":0,"max":1},{"name":"Sheen","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0507,"detail":0.0087,"edges":0,"complexity":1.7213,"coverage":1,"colour":0.1379,"drift":0.0591},"knobResponse":[0.2049,0.0688,0.0476,0.2033]},{"slug":"peaucellier-linkage","title":"Peaucellier Linkage","family":"line","round":42,"note":"굵은 막대 일곱 개로 짠 포슬리에 반전기가 두 고정 축에 매달려 흔들려요. 크랭크가 마름모의 한 꼭짓점을 주 축을 지나는 원 위로 밀면 맞은편 꼭짓점이 패널 높이의 빛나는 곧은 레일을 오르내려요. K3 은 레일을 주 축에서 51 LED 에서 34 LED 까지 끌어당기고, K4 를 0.08 위로 돌리면 크랭크 축이 비켜나 흰 자취가 레일을 벗어나 원호를 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-peaucellier-linkage","type":"code","name":"peaucellier-linkage","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Arms=0..1, Offset=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Arms","min":0,"max":1},{"name":"Offset","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7241,"detail":0.0522,"edges":0.7187,"complexity":0.3299,"coverage":0.146,"colour":0.1947,"drift":0.1464},"knobResponse":[0.0631,0.1027,0.1212,0.0548]},{"slug":"peel-off","title":"Peel-Off","family":"cosmetic","round":33,"note":"보랏빛 젤 막이 진줏빛 살결을 덮고, 위에서부터 벗겨지는 막이 옅은 안쪽을 드러낸 원통으로 말려 128줄을 내려가요. 막이 아래로 빠지면 젖은 새 막이 위에서 흘러내려 반무광으로 마르고, K3 은 그 막을 비치는 얇은 막에서 거의 불투명한 막까지 두껍게 해요. K1 은 색상환을 다 돌고, 누르면 바로 벗기기 시작해요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-peel-off","type":"code","name":"peel-off","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thickness=0..1, Curl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thickness","min":0,"max":1},{"name":"Curl","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2317,"detail":0.0136,"edges":0.1088,"complexity":2.1892,"coverage":1,"colour":0.193,"drift":0.226},"knobResponse":[0.1816,0.2118,0.0647,0.0647]},{"slug":"peg-light","title":"Peg Light","family":"toy","round":18,"note":"1967년 Lite-Brite 처럼 검은 판의 엇갈린 구멍에 색 페그를 하나씩 꽂아 로켓, 돛배, 화분, 물고기, 집, 광대 그림을 채워요. 다 차면 4초 머문 뒤 페그가 위에서부터 쓸려 빠지고 다음 종이가 올라가요. K1 을 누르면 판을 비우고 같은 그림을 처음부터 다시 꽂아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-peg-light","type":"code","name":"peg-light","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Bulb=0..1, Speed=0.2..3, Picture=0..5, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Bulb","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Picture","min":0,"max":5},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0352,"detail":0.2377,"edges":0.8627,"complexity":0.6614,"coverage":0.1604,"colour":0.2171,"drift":0.0512},"knobResponse":[0.0548,0.0566,0.1395,0.0943]},{"slug":"pendulum-wave","title":"Pendulum Wave","family":"physics","round":24,"note":"길이가 조금씩 다른 진자 줄을 위에서 내려다봐요. 한꺼번에 놓은 추들이 한 줄로 흔들리다가 뱀처럼 휘고, 세 줄, 두 줄로 엇갈렸다가 28초 만에 다시 한 줄로 모여요. K1 이 강철에서 놋쇠와 구리를 지나 무지개 유리구슬까지 추를 바꾸고, K4 를 올리면 추가 지나간 자리에 빛 꼬리가 남아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-pendulum-wave","type":"code","name":"pendulum-wave","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Finish=0..1, Speed=0.2..3, Pendulums=16..24, Trails=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Finish","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pendulums","min":16,"max":24},{"name":"Trails","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.7632,"detail":0.0304,"edges":0.1868,"complexity":1.4841,"coverage":0.886,"colour":0.0797,"drift":0.0334},"knobResponse":[0.1242,0.0438,0.0523,0.0491]},{"slug":"penney-game","title":"Penney's Game","family":"data","round":69,"note":"동전이 맨 위 줄에 오른쪽에서 한 칸씩 밀려 들어오다 A 나 B 의 세 수가 오른쪽 끝 세 칸을 채우면 그 판이 한 줄 내려가서, 이긴 세 수가 두 사람이 고른 줄 밑에 한 기둥으로 쌓이고 옆의 긴 막대가 콘웨이의 수가 매긴 눈금으로 다가가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-penney-game","type":"code","name":"penney-game","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, A=0..7, Rival=0..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"A","min":0,"max":7},{"name":"Rival","min":0,"max":6}],"start":[0,2,0,0.06],"measures":{"motion":0.4026,"detail":0.1084,"edges":0.9994,"complexity":0.0845,"coverage":0.2584,"colour":0.2286,"drift":0.0283},"knobResponse":[0.0915,0.0665,0.0752,0.0703]},{"slug":"penrose","title":"Penrose","family":"geometry","round":25,"note":"굵은 마름모와 가는 마름모의 펜로즈 타일링이 다섯 겹 대칭의 가운데로 끝없이 들어가요. 가운데서 꽃잎 다섯 장 꼴로 열리는 빛의 고리가 지나가면 타일이 황금비만큼 작은 타일로 나뉘고, 굵은 마름모 다섯이 모인 별은 금색이에요. Glow 를 올리면 유리가 어두워져 고리 뒤만 밝고, K1 을 누르면 연과 화살(P2)로 바뀌어요.","why":"타일 한 칸이 작아서 잘게 보여요(촘촘함 0.26).","block":1,"ramped":false,"layer":{"id":"layer-penrose","type":"code","name":"penrose","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=7..15, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":7,"max":15},{"name":"Glow","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":1.7979,"detail":0.2641,"edges":0.8556,"complexity":1.1732,"coverage":0.804,"colour":0.583,"drift":0.0983},"knobResponse":[0.4132,0.358,0.3898,0.2306]},{"slug":"penrose-diagram","title":"Penrose Diagram","family":"space","round":60,"note":"끝없는 평평한 시공간을 패널 꼴 그대로인 삼각형에 접어 넣었어요. 지금 면이 과거 무한대에서 미래 무한대로 오르는 동안, r = 0 에서 떠난 금빛 펄스가 가속하는 관찰자의 거울에 튕겨 돌아오거나 지평선 너머 미래 널 무한대로 빠져나가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-penrose-diagram","type":"code","name":"penrose-diagram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grid=0..2, Accel=-2..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grid","min":0,"max":2},{"name":"Accel","min":-2,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1551,"detail":0.1171,"edges":0.9251,"complexity":0.1697,"coverage":0.2999,"colour":0.1713,"drift":0.0412},"knobResponse":[0.056,0.0351,0.0761,0.0366]},{"slug":"penrose-room","title":"Penrose Room","family":"physics","round":33,"note":"거울로 된 펜로즈의 방에서 빛 한 점이 떠돌고, 수백 개의 광선이 반사하며 복도와 위아래 반타원을 밝히는 동안 양옆 방은 캄캄해요. 빛이 반타원을 지나 옆방으로 건너가면 밝은 곳과 어두운 곳이 뒤바뀌어요. K3 은 복도 벽을 초점에서 4 LED 까지 옮겨 어둠에 빛이 새게 하고, K1 을 누르면 빛이 바로 건너가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-penrose-room","type":"code","name":"penrose-room","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Offset=-4..4, Bounces=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Offset","min":-4,"max":4},{"name":"Bounces","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1329,"detail":0.0175,"edges":0.0753,"complexity":1.6655,"coverage":0.6752,"colour":0.1329,"drift":0.3645},"knobResponse":[0.1321,0.1111,0.1163,0.0615]},{"slug":"pentagon-tilings","title":"Pentagon Tilings","family":"cells","round":57,"note":"볼록 오각형 하나의 복사본이 얇은 검은 줄눈을 두고 평면을 덮고, 타일마다 돌아간 각도와 뒤집힘에 따라 색이 달라요. K3 은 라인하르트의 1형, 카이로 타일링(4형), 5형, 마저리 라이스의 13형, 2015년의 15형을 차례로 고르고, 바뀔 때 새 타일이 한 장씩 들어와요. 1형에서는 오각형 모양이 32/Speed 초에 한 바퀴 바뀌어도 타일링이 그대로 이어지고, K4 는 타일 한 장의 넓이를 12×12 에서 28×28 LED 까지 키워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pentagon-tilings","type":"code","name":"pentagon-tilings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Type=0..4, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Type","min":0,"max":4},{"name":"Size","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7935,"detail":0.1433,"edges":0.4476,"complexity":1.0511,"coverage":0.8837,"colour":0.4538,"drift":0.1235},"knobResponse":[0.3678,0.2701,0.3156,0.2919]},{"slug":"pentomino-cover","title":"Pentomino Cover","family":"algo","round":34,"note":"6×10 직사각형을 크누스의 춤추는 링크가 열두 펜토미노로 채워요. 고를 수가 가장 적은 칸부터 조각을 놓고 막히면 빼서 아래쪽 조각들이 쉴 새 없이 들고 나며 윤곽만 잠깐 남기고, 다 덮이면 2초 동안 빛이 비스듬히 쓸고 판 아래에 눈금이 하나 늘어요. K3 은 판을 5×12, 4×15, 해가 둘뿐인 3×20 으로 바꿔요.","why":"색 블록 열두 개가 판을 덮었다 풀었다 해요. 0514 처럼 굵은 블록이에요.","block":0,"ramped":false,"layer":{"id":"layer-pentomino-cover","type":"code","name":"pentomino-cover","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Board=0..3, Shuffle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Board","min":0,"max":3},{"name":"Shuffle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.8284,"detail":0.0833,"edges":0.9414,"complexity":0.2159,"coverage":0.603,"colour":0.4009,"drift":0.2078},"knobResponse":[0.2347,0.2072,0.3116,0.2483]},{"slug":"percolation","title":"Percolation","family":"cells","round":30,"note":"LED 마다 정해 둔 난수가 p 보다 작으면 열리고, 이어진 자리끼리 제 색의 클러스터가 돼요. p 가 오르다 한 클러스터가 위아래 128줄을 이으면 금빛으로 켜지고 가장 짧은 길이 그어져요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-percolation","type":"code","name":"percolation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Window=0.04..0.2, Small=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Window","min":0.04,"max":0.2},{"name":"Small","min":-1,"max":1}],"start":[0,2,0.04,0.06],"measures":{"motion":0.076,"detail":0.3535,"edges":0.6496,"complexity":2.5378,"coverage":0.6081,"colour":0.3525,"drift":0.1555},"knobResponse":[0.2138,0.2514,0.1582,0.0547]},{"slug":"peregrine-soliton","title":"Peregrine Soliton","family":"wave","round":44,"note":"고른 너울 위로 물마루 하나가 난데없이 너울의 세 배로 솟았다가 가라앉아요. 위쪽 띠는 그 물결의 시공간 기록이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-peregrine-soliton","type":"code","name":"peregrine-soliton","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Family=-1..1, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Family","min":-1,"max":1},{"name":"Swell","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3681,"detail":0.0209,"edges":0.5771,"complexity":0.0714,"coverage":0.5838,"colour":0.2288,"drift":0.0691},"knobResponse":[0.1304,0.0516,0.0557,0.0772]},{"slug":"perfume-tears","title":"Perfume Tears","family":"cosmetic","round":40,"note":"향수 잔 안쪽 벽을 가까이서 봐요. 알코올이 날아가며 생긴 마랑고니 응력이 바닥의 액체를 얇은 막으로 끌어올리고, 막이 모인 윤기 나는 테가 반지름의 9배 간격으로 부풀어 다리를 끄는 눈물로 미끄러져 내려요. K3 은 테를 굵게 해 눈물을 다섯 줄에서 세 줄의 큰 방울로 바꾸고, 누르면 잔을 휘저어 새 막을 입혀요.","why":"눈물 줄이 가늘고 바탕이 패널을 채워요(채움 0.79).","block":1,"ramped":false,"layer":{"id":"layer-perfume-tears","type":"code","name":"perfume-tears","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rim=0..1, Warmth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rim","min":0,"max":1},{"name":"Warmth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1468,"detail":0.0263,"edges":0.2563,"complexity":1.2316,"coverage":0.7892,"colour":0.1324,"drift":0.0443},"knobResponse":[0.1294,0.0465,0.0512,0.1098]},{"slug":"permutation-poem","title":"Permutation Poem","family":"type","round":81,"note":"구절 하나의 낱말 차례를 모두 내려 쓰고, 새 줄마다 이웃한 두 낱말이 흰빛으로 미끄러져 자리를 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-permutation-poem","type":"code","name":"permutation-poem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..3, Order=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phrase","min":0,"max":3},{"name":"Order","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.7557,"detail":0.1836,"edges":0.9999,"complexity":0.305,"coverage":0.237,"colour":0.1749,"drift":0.0366},"knobResponse":[0.0831,0.0964,0.2079,0.1166]},{"slug":"perron-tree","title":"Perron Tree","family":"geometry","round":29,"note":"키 120 LED 삼각형을 2^n 조각으로 잘라 페론처럼 한 단씩 겹쳐 밀면, 모든 방향을 품은 채 넓이가 30% 로 줄어든 나무가 돼요. 흰 바늘이 모든 방향을 돌며 싹에서 싹으로 건너뛰어요. K3 은 단 수(32~256 조각)이고 K1 을 누르면 삼각형부터 다시 지어요.","why":"검은 바탕에 무지개 빛살이 모였다 퍼져요. 패널의 72% 가 꺼져 있어서 빛살이 또렷해요.","block":0,"ramped":false,"layer":{"id":"layer-perron-tree","type":"code","name":"perron-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=5..8, Slide=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":5,"max":8},{"name":"Slide","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.2474,"detail":0.037,"edges":0.3794,"complexity":1.0174,"coverage":0.2747,"colour":0.1818,"drift":0.2212},"knobResponse":[0.075,0.1981,0.1861,0.1179]},{"slug":"persistence-barcode","title":"Persistence Barcode","family":"topology","round":51,"note":"고리를 따라 흩은 점마다 원판이 자라 고리를 삼키는 동안 아래에서는 그 성장의 바코드가 훑는 선 뒤로 켜지고, 고리 구멍의 긴 주황 막대와 그 구멍을 두른 고리가 같은 색으로 빛나다 구멍이 닫히면 함께 꺼져요. K3 은 점이 원에서 흩어지는 정도, K4 는 점을 뽑는 원의 수(하나, 둘, 셋)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-persistence-barcode","type":"code","name":"persistence-barcode","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Rings=1..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":0,"max":1},{"name":"Rings","min":1,"max":3}],"start":[0,2,0,1],"measures":{"motion":0.1144,"detail":0.0445,"edges":0.7451,"complexity":0.1576,"coverage":0.5181,"colour":0.1784,"drift":0.1563},"knobResponse":[0.0594,0.0757,0.092,0.1101]},{"slug":"phantom-jam","title":"Phantom Jam","family":"sim","round":51,"note":"패널 가장자리의 키 큰 고리 도로를 차들이 앞차와의 간격만 보고 달리면 사고도 공사도 없이 정체가 생겨, 차는 앞으로 가는데 정체는 뒤로 밀려나요. 트랙 안의 시공간 그림에서 차의 선은 한쪽으로, 빨간 정체 줄무늬는 반대쪽으로 기울어요. K3 은 차 수(22~44), K4 는 운전자가 간격에 맞춰 속도를 고치는 민감도 a 이고, 단추를 누르면 출발선 가까운 차가 급정거해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-phantom-jam","type":"code","name":"phantom-jam","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cars=22..44, Sensitivity=0.5..2.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cars","min":22,"max":44},{"name":"Sensitivity","min":0.5,"max":2.5}],"start":[0,2,22,0.5],"measures":{"motion":0.9389,"detail":0.1182,"edges":0.4636,"complexity":1.3296,"coverage":0.4722,"colour":0.2289,"drift":0.1114},"knobResponse":[0.0559,0.0933,0.1632,0.0768]},{"slug":"phase-spiral","title":"Phase Spiral","family":"sim","round":60,"note":"한 줄 위에서 서로 끌어당기는 면 3072개의 위치를 가로로, 속도를 세로로 찍어요. 차가운 띠가 무너지며 두 팔 나선으로 감기고, 감길수록 팔이 가늘어지는 동안 가운데 하얀 핵이 가라앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-phase-spiral","type":"code","name":"phase-spiral","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=0.1..1.2, Lumps=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":0.1,"max":1.2},{"name":"Lumps","min":0,"max":1}],"start":[0,2,0.1,0.06],"measures":{"motion":2.0334,"detail":0.1461,"edges":0.7081,"complexity":1.0491,"coverage":0.3042,"colour":0.3113,"drift":0.1311},"knobResponse":[0.1038,0.1468,0.2578,0.1439]},{"slug":"phasor-noise","title":"Phasor Noise","family":"noise","round":82,"note":"같은 가보르 커널을 더한 복소 장을 위 반에는 허수부로, 아래 반에는 위상만으로 그려서, 소용돌이와 안장을 따라 지문처럼 휘는 줄무늬가 위에서는 군데군데 흐려지고 아래에서는 같은 대비로 갈라지며 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-phasor-noise","type":"code","name":"phasor-noise","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Frequency=8..11, Profile=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Frequency","min":8,"max":11},{"name":"Profile","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.4899,"detail":0.1252,"edges":0.4366,"complexity":2.3092,"coverage":0.5932,"colour":0.1825,"drift":0.1341},"knobResponse":[0.1115,0.2995,0.1868,0.1064]},{"slug":"photochromic","title":"Photochromic","family":"cosmetic","round":38,"note":"LED 마다 맨 폴리시이거나 펄 조각인 옅은 매니큐어 위로 보이지 않는 UV 손전등이 구불구불 쓸고 지나가면, 지나간 자리가 순식간에 짙은 보석 색으로 바뀌었다가 몇 초에 걸쳐 다시 옅어져요. K3 은 펄 조각을 한 LED 에서 네 LED 너비로 키워 굵은 글리터로 바꾸고, K1 을 누르면 지난번과 반대쪽으로 한 번 더 쓸어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-photochromic","type":"code","name":"photochromic","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flakes=1..4, Fade=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flakes","min":1,"max":4},{"name":"Fade","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1311,"detail":0.2098,"edges":0.7508,"complexity":1.4701,"coverage":0.9752,"colour":0.1059,"drift":0.3646},"knobResponse":[0.1323,0.3042,0.2265,0.1945]},{"slug":"photon-disk","title":"Photon Disk","family":"type","round":70,"note":"어두운 유리 원판이 돌다가 줄에 필요한 글자가 12시 창을 지나는 순간 섬광이 그 글자를 하얗게 멈춰 세우고, 렌즈를 지난 빛이 위 필름 띠에 한 자씩 글줄을 쌓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-photon-disk","type":"code","name":"photon-disk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Lens=1..2.25","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Lens","min":1,"max":2.25}],"start":[0,2,0,1],"measures":{"motion":0.9592,"detail":0.0688,"edges":0.4781,"complexity":0.5937,"coverage":0.7453,"colour":0.1343,"drift":0.0584},"knobResponse":[0.0503,0.0615,0.065,0.0779]},{"slug":"pin-art","title":"Pin Art","family":"toy","round":22,"note":"핀 아트 장난감을 앞에서 봐요. 엇갈린 격자의 강철 핀 4096개가 패널을 채우고, 뒤에서 펼친 손이 눌러 들어오면 밀려 나온 핀만 비스듬한 등빛을 받아 빛나요. 장난감을 기울이면 핀이 물결치며 평평해지고 열쇠가 다음으로 눌러 들어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pin-art","type":"code","name":"pin-art","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Metal=0..1, Speed=0.2..3, Object=0..4, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Metal","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Object","min":0,"max":4},{"name":"Light","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0617,"detail":0.3463,"edges":0.9544,"complexity":1.3204,"coverage":0.7864,"colour":0.2041,"drift":0.3573},"knobResponse":[0.1597,0.2367,0.0944,0.0463]},{"slug":"pint","title":"Pint","family":"cells","round":18,"note":"탭이 패널 높이만 한 파인트 잔에 맥주를 따르면, 뿌연 맥주가 바닥부터 맑아지고 기포 줄이 오르는 동안 거품 머리가 밝은 테두리의 다각형 셀로 굵어져요. 누군가 다섯 모금에 나눠 마시며 잔에 레이싱 고리를 남기고, 바닥이 보이면 다시 따라요. K1 은 라거에서 앰버 에일, 레드 에일을 지나 스타우트까지 맥주를 바꾸고, 스타우트는 크림빛 서지가 바닥부터 검게 가라앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pint","type":"code","name":"pint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Beer=0..1, Speed=0.2..3, Fizz=4..20, Head=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Beer","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fizz","min":4,"max":20},{"name":"Head","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.1411,"detail":0.0425,"edges":0.5054,"complexity":1.0501,"coverage":0.678,"colour":0.3448,"drift":0.1113},"knobResponse":[0.1725,0.2433,0.0546,0.0641]},{"slug":"pinwheel-tiling","title":"Pinwheel Tiling","family":"geometry","round":32,"note":"다리가 1 과 2 인 직각삼각형 타일링 속으로 끝없이 들어가요. 3.6초마다 타일마다 이음매가 옅게 나타나 다섯 조각으로 갈라지고, 그 가운데 하나는 부모에서 26.6° 돌아가 있어요. 타일을 긴 다리의 방향으로 칠해서, 같은 색 무리가 서로 다른 각도로 기운 것이 보여요.","why":"삼각형이 잘고 패널을 다 채워요.","block":1,"ramped":false,"layer":{"id":"layer-pinwheel-tiling","type":"code","name":"pinwheel-tiling","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=13..40, Paint=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":13,"max":40},{"name":"Paint","min":0,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":2.1331,"detail":0.1861,"edges":0.7085,"complexity":1.6658,"coverage":0.856,"colour":0.5245,"drift":0.1667},"knobResponse":[0.362,0.3049,0.2869,0.2296]},{"slug":"pipe-organ","title":"Pipe Organ","family":"music","round":24,"note":"어두운 성당의 파이프오르간 정면이 패널을 채워요. 보이지 않는 오르가니스트가 여덟 화음 코랄을 되풀이하면, 소리 나는 파이프마다 입에서 빛이 켜지고 몸통을 따라 정상파 띠가 올라가요. 가운데 가장 긴 파이프가 가장 낮은 음이에요. K1 이 플루트의 파랑, 프린시펄의 은빛, 리드의 금빛과 빨강 사이에서 음전을 고르고, K1 을 누르면 파이프 열아홉이 다 울려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pipe-organ","type":"code","name":"pipe-organ","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stops=0..1, Tempo=0.2..3, Voices=1..6, Tremulant=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stops","min":0,"max":1},{"name":"Tempo","min":0.2,"max":3},{"name":"Voices","min":1,"max":6},{"name":"Tremulant","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1017,"detail":0.1071,"edges":0.5078,"complexity":2.0828,"coverage":0.7769,"colour":0.1713,"drift":0.0578},"knobResponse":[0.0627,0.0467,0.0469,0.0424]},{"slug":"pit-pendulum","title":"Pit and Pendulum","family":"halloween","round":49,"note":"횃불 켠 지하 감옥에서 커다란 초승달 칼날이 벽에 그림자를 휘두르며 한 번 지날 때마다 돌 침대 쪽으로 내려오고, 쥐들이 모여들다 손 한 뼘 위에서 횃불이 잦아들면 쇠사슬이 칼날을 어둠 속으로 끌어올려요. K3 은 한 번 지날 때 내려오는 깊이, K4 는 횃불이 닿는 거리예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pit-pendulum","type":"code","name":"pit-pendulum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Descent=3..12, Torch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Descent","min":3,"max":12},{"name":"Torch","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.467,"detail":0.0443,"edges":0.561,"complexity":0.2314,"coverage":0.7215,"colour":0.3226,"drift":0.122},"knobResponse":[0.2235,0.0975,0.0758,0.1337]},{"slug":"pivot-walk","title":"Pivot Walk","family":"sim","round":42,"note":"정사각 격자 위의 자기 회피 걸음 80걸음이 아쿠아에서 분홍으로 물든 빛 사슬로 떠 있고, 피벗 알고리즘이 고른 점에서 한쪽 팔을 90도나 180도 휘둘러 돌리거나 접어 넘겨요. K3 은 사슬을 160걸음까지 늘려 격자를 붐비게 하고, K4 는 꺾일 때마다 값을 매겨 사슬을 머리핀처럼 곧게 접어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pivot-walk","type":"code","name":"pivot-walk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=80..160, Stiff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":80,"max":160},{"name":"Stiff","min":0,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":0.8312,"detail":0.0373,"edges":0.5081,"complexity":0.3132,"coverage":0.1302,"colour":0.233,"drift":0.1532},"knobResponse":[0.0557,0.104,0.1579,0.1024]},{"slug":"plait","title":"Plait","family":"textile","round":15,"note":"세 가닥이 바깥 가닥부터 가운데 위로 넘어가며 땋여 내려가요. 밑으로 들어가는 가닥은 어둡고, 다 땋으면 리본을 묶고 다음 가닥이 내려와요. K3 이 일곱 가닥 납작 땋기까지 가요.","why":"굵은 세 가닥이 땋였다 풀려요. 잰 값 일곱이 프리셋과 가장 가까운 패턴이에요.","block":0,"ramped":false,"layer":{"id":"layer-plait","type":"code","name":"plait","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Tension=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":3,"max":7},{"name":"Tension","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":1.0033,"detail":0.0467,"edges":0.1711,"complexity":1.4043,"coverage":0.7414,"colour":0.4415,"drift":0.2976},"knobResponse":[0.2929,0.2273,0.2358,0.2751]},{"slug":"plancherel-growth","title":"Plancherel Growth","family":"data","round":45,"note":"영 도형이 무작위 수의 RSK 끼워 넣기로 마름모 칸을 하나씩 얻으며 왼쪽 가운데 모서리에서 오른쪽으로 자라요. 처음부터 그려 둔 로건-셰프와 베르시크-케로프의 극한 곡선 쪽으로 차오르고, 칸 색이 들어온 차례라서 색 띠가 같은 곡선을 작게 겹쳐 놓은 꼴이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-plancherel-growth","type":"code","name":"plancherel-growth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=3..6, Curve=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":3,"max":6},{"name":"Curve","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0444,"detail":0.0937,"edges":0.9992,"complexity":0.2243,"coverage":0.2569,"colour":0.3661,"drift":0.2665},"knobResponse":[0.0558,0.0775,0.1391,0.0494]},{"slug":"platycosms","title":"Platycosms","family":"space","round":71,"note":"닫혀 있지만 평평한 우주를 날면 큐브마다 같은 세 팔 잭의 사본이 보이고, 처음 여는 4분의 1 바퀴 공간에서는 z 로 한 칸 지날 때마다 사본이 4분의 1 바퀴씩 돌아 있어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-platycosms","type":"code","name":"platycosms","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Space=0..3, Heading=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Space","min":0,"max":3},{"name":"Heading","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6245,"detail":0.0429,"edges":0.1361,"complexity":1.2399,"coverage":0.2591,"colour":0.1174,"drift":0.1203},"knobResponse":[0.0365,0.1009,0.1004,0.1283]},{"slug":"player-piano","title":"Player Piano","family":"music","round":15,"note":"자동 피아노의 구멍 뚫린 종이 두루마리가 내려와요. 구멍이 트래커 바를 지날 때마다 발치의 건반이 눌려 빛나요. 곡은 패턴이 그 자리에서 지어서, 화음은 가로줄로, 펼친 화음은 사선으로 읽혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-player-piano","type":"code","name":"player-piano","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=0.5..3.5, Hands=2..5, Pedal=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":0.5,"max":3.5},{"name":"Hands","min":2,"max":5},{"name":"Pedal","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.3229,"detail":0.0822,"edges":0.6181,"complexity":0.1256,"coverage":0.9461,"colour":0.1765,"drift":0.0751},"knobResponse":[0.0626,0.0796,0.0519,0.0503]},{"slug":"plucked-letters","title":"Plucked Letters","family":"type","round":80,"note":"곧은 획만으로 된 HYMN 이 둘씩 두 줄로 서서 획마다 두 핀 사이의 줄이 되고, 글자마다 긴 줄부터 짧은 줄 차례로 뜯기면 번쩍인 줄의 세모가 두 꺾임으로 갈라져 핀까지 달려갔다가 뒤집혀 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-plucked-letters","type":"code","name":"plucked-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Pluck=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":7},{"name":"Pluck","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4282,"detail":0.0514,"edges":0.637,"complexity":0.5822,"coverage":0.2003,"colour":0.1617,"drift":0.0784},"knobResponse":[0.0586,0.0535,0.1017,0.0308]},{"slug":"pole-vault","title":"Pole Vault","family":"sport","round":26,"note":"밤 경기장에서 카메라가 장대를 든 선수를 따라 달리고, 활처럼 휜 장대를 타고 거꾸로 오른 선수가 패널 꼭대기 가까운 가로대를 넘어 매트에 떨어지면 심판이 흰 깃발이나 빨간 깃발을 들어요. K3 이 가로대를 5.00 m 에서 6.20 m 까지 올리고, 누르면 다음 선수가 바로 달려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pole-vault","type":"code","name":"pole-vault","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Bar=5..6.2, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bar","min":5,"max":6.2},{"name":"Wind","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.7696,"detail":0.0793,"edges":0.2827,"complexity":0.9294,"coverage":0.6904,"colour":0.1943,"drift":0.0642},"knobResponse":[0.0451,0.0895,0.0561,0.043]},{"slug":"pollards-rho","title":"Pollard's Rho","family":"algo","round":81,"note":"x² + c 를 숨은 소인수로 나눈 나머지가 세로로 선 ρ 를 그리고, 그 위를 쫓는 거북이와 토끼가 만나면 gcd 가 1 에서 그 소인수로 뛰어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pollards-rho","type":"code","name":"pollards-rho","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Number=0..7, Constant=1..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":7},{"name":"Constant","min":1,"max":6}],"start":[0,2,0,1],"measures":{"motion":0.1802,"detail":0.0868,"edges":0.7772,"complexity":0.3335,"coverage":0.193,"colour":0.1932,"drift":0.0856},"knobResponse":[0.0507,0.0718,0.0804,0.0606]},{"slug":"poltergeist","title":"Poltergeist","family":"halloween","round":45,"note":"기름등 하나가 흔들리는 응접실에서 책이 선반을 떠나 새처럼 퍼덕이며 날고, 접시와 의자도 초록 자국을 끌며 떠다녀요. 5초쯤 뒤 모두 한꺼번에 떨어지면 방이 흔들리고 등불이 잦아들었다가 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-poltergeist","type":"code","name":"poltergeist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fury=1..5, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fury","min":1,"max":5},{"name":"Lamp","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.6173,"detail":0.0348,"edges":0.4085,"complexity":0.3353,"coverage":0.9466,"colour":0.3788,"drift":0.2391},"knobResponse":[0.0347,0.079,0.0371,0.0901]},{"slug":"polya-orchard","title":"Pólya's Orchard","family":"space","round":45,"note":"가운데 등불 빛이 정수 격자 위 나무 48그루 사이로 새어 나가 패널 끝까지 닿는 가는 빛살이 돼요. 줄기가 문턱 1/R 까지 굵어지면 빛살이 여덟 개씩 꺼지고, 마지막 여덟은 과수원 바로 밖의 격자점 (4,1) 쪽을 가리켜요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-polya-orchard","type":"code","name":"polya-orchard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Trunk=0.45..0.95, Walk=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Trunk","min":0.45,"max":0.95},{"name":"Walk","min":0,"max":1}],"start":[0,2,0.45,0.06],"measures":{"motion":0.0713,"detail":0.0697,"edges":0.6282,"complexity":0.6251,"coverage":0.3033,"colour":0.2519,"drift":0.2064},"knobResponse":[0.0802,0.2383,0.0499,0.0695]},{"slug":"polya-urn","title":"Pólya Urn","family":"data","round":38,"note":"폴리아 항아리 64개가 한 열에 하나씩 나란히 공을 뽑아요. 로그 시계를 따라 위에서는 크게 흔들리다 아래로 가며 저마다 다른 섞임 비율로 굳고, 한 판이 끝나면 열들이 굳은 비율대로 줄을 서서 고르게 퍼진 극한을 곧은 그러데이션으로 보여 줘요. K3 은 처음 공을 늘려 열들을 가운데 섞임으로 모으고, K4 는 한 번에 더하는 공을 늘려 바코드를 두 색으로 갈라요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-polya-urn","type":"code","name":"polya-urn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Balls=1..8, Added=1..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Balls","min":1,"max":8},{"name":"Added","min":1,"max":8}],"start":[0,2,1,1],"measures":{"motion":0.0395,"detail":0.0065,"edges":0.0554,"complexity":1.2351,"coverage":1,"colour":0.4287,"drift":0.1821},"knobResponse":[0.3523,0.0975,0.0619,0.0708]},{"slug":"polynomial-amoeba","title":"Polynomial Amoeba","family":"topology","round":64,"note":"두 변수 다항식의 영점을 두 좌표의 절댓값 로그로 옮긴 아메바가 통통한 불가사리에서 가는 열대 사다리로 천천히 줄었다 부풀어요. 뉴턴 다각형의 안쪽 점 셋에 맞는 구멍 셋이 위아래로 쌓여 차례로 열리고 닫히고, 금빛 실이 아메바가 줄어드는 열대 곡선을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-polynomial-amoeba","type":"code","name":"polynomial-amoeba","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lift=-1..1, Phase=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lift","min":-1,"max":1},{"name":"Phase","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0535,"detail":0.0378,"edges":0.493,"complexity":0.3484,"coverage":0.2824,"colour":0.1971,"drift":0.2648},"knobResponse":[0.1498,0.1433,0.2533,0.0838]},{"slug":"polytope-slices","title":"Polytope Slices","family":"space","round":41,"note":"천천히 기우는 4차원 정다포체가 세로로 쌓인 초평면 세 장을 위에서부터 지나가요. 단면마다 4차원 칸의 색을 입은 입체가 돌면서 점에서 자라고, 꼭짓점 층을 지날 때마다 모양을 바꾸다 사라져요. K3 은 정24포체, 테서랙트, 정16포체, 정5포체를 고르고, K4 는 초평면을 칸 쪽에서 꼭짓점 쪽으로 기울여 정24포체의 가운데 단면을 육팔면체에서 마름모십이면체로 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-polytope-slices","type":"code","name":"polytope-slices","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Polytope=0..3, Tilt=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Polytope","min":0,"max":3},{"name":"Tilt","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0849,"detail":0.0942,"edges":0.9098,"complexity":0.1234,"coverage":0.3802,"colour":0.2925,"drift":0.379},"knobResponse":[0.2195,0.2306,0.2519,0.1928]},{"slug":"poncelet-porism","title":"Poncelet Porism","family":"line","round":41,"note":"꼭짓점은 세로로 긴 타원에, 변은 안쪽 작은 타원에 닿는 삼각형 셋이 같이 미끄러져 돌아요. 안쪽 타원이 가까운 끝에서는 꼭짓점이 1초에 7.5 LED 로 기고 먼 끝에서는 39 LED 로 달리는데, 어디서 출발한 삼각형이든 늘 닫혀요. K3 은 사각형과 {5/2}, {7/2}, {7/3}, {8/3} 별로 바꾸고, K4 를 1 로 돌리면 두 원의 중심이 겹쳐 정다각형을 늘인 꼴로 돌아요. K1 을 누르면 두 원이 반 바퀴 돌아 꼭짓점이 몰리는 끝이 반대편으로 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-poncelet-porism","type":"code","name":"poncelet-porism","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Centre=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":5},{"name":"Centre","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.203,"detail":0.0507,"edges":0.6256,"complexity":0.6557,"coverage":0.4223,"colour":0.4028,"drift":0.1814},"knobResponse":[0.2031,0.1803,0.2827,0.2014]},{"slug":"pop-up-book","title":"Pop-up Book","family":"paper","round":21,"note":"탁자에 펼친 팝업북에서 성과 숲, 등대, 도시가 종이 카드 여러 겹으로 일어서고, 그동안 달이 홈을 따라 가고 사슴이 고개를 숙여요. 페이지가 넘어가면 장면이 가운데 접힌 선으로 납작하게 눕고, 넘어오는 페이지에서 다음 장면이 일어나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pop-up-book","type":"code","name":"pop-up-book","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spread=0..3, Speed=0.2..3, Layers=4..6, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spread","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Layers","min":4,"max":6},{"name":"Lamp","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.2969,"detail":0.0558,"edges":0.4541,"complexity":0.5762,"coverage":0.9872,"colour":0.1893,"drift":0.1346},"knobResponse":[0.1392,0.0773,0.0475,0.1266]},{"slug":"popcorn","title":"Popcorn","family":"kitchen","round":19,"note":"영화관 팝콘 수레가 128줄을 다 써요. 케틀에서 낟알이 터져 뛰고 넘쳐 떨어지다가 케틀이 기울어 한 배치를 더미에 쏟고, K1 을 누르면 스쿱이 더미를 떠 가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-popcorn","type":"code","name":"popcorn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Heat=0.2..3, Batch=6..16, Heap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Heat","min":0.2,"max":3},{"name":"Batch","min":6,"max":16},{"name":"Heap","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2278,"detail":0.0649,"edges":0.5093,"complexity":0.7081,"coverage":0.9514,"colour":0.2616,"drift":0.0636},"knobResponse":[0.0358,0.0496,0.0725,0.0766]},{"slug":"population-pyramid","title":"Population Pyramid","family":"data","round":25,"note":"가상의 나라의 인구 피라미드가 한 살에 한 줄씩 움직여요. 왼쪽이 남자, 오른쪽이 여자이고, 10년마다 태어난 세대가 제 색 띠로 해마다 한 줄씩 올라가요. 1995년의 베이비붐 띠가 위로 올라가 2060년에 위가 무거운 항아리꼴이 되면, 1820년의 뾰족한 삼각형으로 돌아가 240년을 다시 지나요. K3 을 내리면 아래가 좁아져 거꾸로 선 피라미드가 되고, K1 을 누르면 그해가 전쟁이나 유행병이 되어 패인 홈이 위로 올라가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-population-pyramid","type":"code","name":"population-pyramid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Speed=0.25..6, Births=-1..1, Migration=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Speed","min":0.25,"max":6},{"name":"Births","min":-1,"max":1},{"name":"Migration","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1321,"detail":0.0783,"edges":0.6662,"complexity":0.212,"coverage":0.4183,"colour":0.3565,"drift":0.1142},"knobResponse":[0.1688,0.1844,0.07,0.0935]},{"slug":"potters-wheel","title":"Potter's Wheel","family":"pottery","round":24,"note":"밤의 도자기 공방에서 녹색 갓 램프 아래 물레가 돌아요. 두 손이 흙덩이를 가운데로 모아 벽을 끌어올리면 그릇이 76~92줄 높이로 자라고, 물레 자국이 램프 쪽에서 반짝이며 옆으로 흘러가요. 다 빚은 병과 항아리는 줄로 잘려 선반에 올라가 젖은 흙빛에서 하얗게 말라 가요. K1 이 흙을 테라코타에서 검은 흙까지 바꾸고, K1 을 누르면 그릇이 주저앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-potters-wheel","type":"code","name":"potters-wheel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Clay=0..1, Speed=0.2..3, Pots=6..20, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Clay","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pots","min":6,"max":20},{"name":"Lamp","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.6649,"detail":0.0524,"edges":0.2558,"complexity":1.7276,"coverage":0.8999,"colour":0.2006,"drift":0.0739},"knobResponse":[0.0662,0.0422,0.05,0.1325]},{"slug":"powder-burst","title":"Powder Burst","family":"cosmetic","round":37,"note":"어두운 스튜디오 바닥의 파우더 케이크가 6.3초마다 좌우를 번갈아 맞아 터지고, 마젠타 파우더가 둥근 머리를 이고 4초쯤 만에 패널 꼭대기 언저리까지 솟아요. 머리는 고리로 말리며 버섯 꼴이 되고, 가장자리에서 고운 먼지가 말려 나가고 무거운 알갱이는 포물선을 그리며 떨어지고, 운모가 가끔 반짝여요. K3 은 머리를 패널보다 넓게 키워 위로 빠져나가게 하고, K4 는 운모를 한 번에 1,460조각까지 늘려요. 누르면 바로 케이크를 쳐요.","why":"검은 바탕의 자홍 구름이 좋은데 모양이 흐릿해요(가장자리 0.05).","block":1,"ramped":false,"layer":{"id":"layer-powder-burst","type":"code","name":"powder-burst","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Force=0..1, Shimmer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Force","min":0,"max":1},{"name":"Shimmer","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.285,"detail":0.0166,"edges":0.0495,"complexity":1.3583,"coverage":0.4791,"colour":0.3931,"drift":0.3981},"knobResponse":[0.3053,0.2228,0.1341,0.0525]},{"slug":"prandtl-membrane","title":"Prandtl's Membrane","family":"type","round":75,"note":"비틀린 막대의 단면인 낱말마다 프란틀의 막을 씌워 부풀리면, 막이 4초마다 숨 쉬듯 부풀었다 가라앉고 응력에 따라 등성이는 파랗게, 테두리와 안쪽 모서리는 주황과 노랑으로 달아올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-prandtl-membrane","type":"code","name":"prandtl-membrane","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Twist=0.2..3, Word=0..3, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Twist","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0468,"detail":0.0421,"edges":0.2612,"complexity":1.2114,"coverage":0.5996,"colour":0.5715,"drift":0.1227},"knobResponse":[0.3827,0.3118,0.3423,0.0613]},{"slug":"prince-ruperts-cube","title":"Prince Rupert's Cube","family":"geometry","round":40,"note":"가운데가 정사각형으로 뚫린 정육면체가 천천히 돌고, 그보다 1.06066 배 큰 정육면체가 밑에서 올라와 그 굴을 벽에 딱 붙어 지나가요. K1 을 0 위로 돌리면 지나가던 정육면체가 굴 어귀에 걸려 붉게 빛나며 두드리고, K4 는 굴의 방향을 긴 대각선 쪽으로 돌려 굴을 √6 − √2 까지 좁혀요.","why":"큰 색면이 좋은데 입체 퍼즐이라 무엇을 보는지 설명이 있어야 해요.","block":1,"ramped":false,"layer":{"id":"layer-prince-ruperts-cube","type":"code","name":"prince-ruperts-cube","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fit=-1..1, Speed=0.2..3, Tilt=0..1, Bore=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fit","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Bore","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2252,"detail":0.0228,"edges":0.4539,"complexity":0.321,"coverage":0.2784,"colour":0.1731,"drift":0.1972},"knobResponse":[0.1587,0.1741,0.0803,0.1549]},{"slug":"print-gallery","title":"Print Gallery","family":"fractal","round":58,"note":"두 배씩 커지는 사각 고리 넷에 체커를 깐 드로스테 그림을 드 스밋과 렌스트라의 사상으로 비틀어, 네 빛깔 고리가 나선 팔 넷으로 이어지고 흰 액자는 나선 선 하나가 돼요. 5.6초마다 10.2배 확대와 59도 회전을 마치면 LED 하나 다르지 않은 같은 그림으로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-print-gallery","type":"code","name":"print-gallery","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=16..256, Unwind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":16,"max":256},{"name":"Unwind","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":2.1371,"detail":0.126,"edges":0.6593,"complexity":0.6183,"coverage":0.9229,"colour":0.4682,"drift":0.1907},"knobResponse":[0.3459,0.3261,0.3464,0.3498]},{"slug":"promotion","title":"Promotion","family":"algo","round":74,"note":"8×16 칸 표준 영 타블로에서 1 이 빠진 흰 구멍이 오른쪽과 아래 이웃 가운데 작은 수를 끌어당기며 오른쪽 아래 모서리로 미끄러지고 그 자리에 128 이 들어가기를 되풀이해서, 128번째에 모든 칸이 처음 수로 돌아와 번쩍여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-promotion","type":"code","name":"promotion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=-1..2, Levels=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":-1,"max":2},{"name":"Levels","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0482,"detail":0.1424,"edges":0.8812,"complexity":0.1807,"coverage":0.8191,"colour":0.5896,"drift":0.0361},"knobResponse":[0.4167,0.0649,0.3047,0.1092]},{"slug":"proscenium","title":"Proscenium","family":"stage","round":23,"note":"금박 프로시니엄 아래 붉은 벨벳 막이 플라이로 올라가면 달빛 바다나 숲, 밤 도시, 눈 내리는 마을을 그린 배경막이 드러나고, 브리지 조명의 빛줄기가 연무를 갈라요. 발레리나가 팔로 스폿을 받으며 도약해 무대를 건너고, 막이 내리면 막 앞에서 인사해요. 맨 아래에는 실크해트를 쓴 사람이 섞인 앞줄 관객의 뒤통수가 있어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-proscenium","type":"code","name":"proscenium","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gel=0..1, Speed=0.2..3, Scene=0..3, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gel","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scene","min":0,"max":3},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1444,"detail":0.0876,"edges":0.3879,"complexity":1.7658,"coverage":0.8713,"colour":0.2563,"drift":0.0949},"knobResponse":[0.0636,0.1625,0.077,0.1771]},{"slug":"pulse-bars","title":"Pulse Bars","family":"rhythm","round":1,"note":"음악 없는 하이파이 미터예요. 작은 드럼 머신이 혼자 치고 막대는 그 소리를 듣는 듯 춤춰요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-pulse-bars","type":"code","name":"pulse-bars","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=90..180, Bars=8..32, Decay=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":90,"max":180},{"name":"Bars","min":8,"max":32},{"name":"Decay","min":0,"max":1}],"start":[0,90,8,0.06],"measures":{"motion":0.7885,"detail":0.0861,"edges":0.9999,"complexity":0.1776,"coverage":0.2209,"colour":0.2463,"drift":0.1392},"knobResponse":[0.0897,0.0556,0.0615,0.0607]},{"slug":"pumpkin-carving","title":"Pumpkin Carving","family":"halloween","round":47,"note":"밤 탁자 위 큰 호박을 칼날이 한 조각씩 도려내 눈과 코와 이빨 난 입을 내고, 성냥불로 촛불이 붙으면 얼굴이 금빛으로 일렁이며 탁자에 빛이 번져요. 촛불이 꺼지면 호박이 돌아 새 얼굴을 깎아요. K3 은 얼굴이 사나운 정도, K4 는 빛이 번지는 거리예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pumpkin-carving","type":"code","name":"pumpkin-carving","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Warmth=-1..1, Speed=0.2..3, Fierce=0..1, Spill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Warmth","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fierce","min":0,"max":1},{"name":"Spill","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2082,"detail":0.0243,"edges":0.2464,"complexity":0.2244,"coverage":0.6689,"colour":0.4453,"drift":0.0568},"knobResponse":[0.0767,0.066,0.073,0.0698]},{"slug":"pumpkin-drop","title":"Pumpkin Drop","family":"halloween","round":52,"note":"구름 낀 보라 밤에 촛불 켠 호박 등이 도르래 틀 꼭대기까지 감겨 올라가 흔들리다 놓여 128줄을 떨어지고, 땅에서 터져 조각과 씨를 흩뿌려요. 초는 굴러 나가 연기를 피우며 꺼지고, 다음 호박이 들어와 불을 켜요. K3 은 바람, K4 는 호박 크기이고, K1 을 누르면 매달린 호박을 바로 놓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pumpkin-drop","type":"code","name":"pumpkin-drop","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Flame=0..1, Speed=0.2..3, Wind=0..1, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Flame","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Size","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1522,"detail":0.0251,"edges":0.3346,"complexity":0.5423,"coverage":0.9732,"colour":0.1929,"drift":0.1447},"knobResponse":[0.0342,0.0693,0.0419,0.088]},{"slug":"pumpkin-vine","title":"Pumpkin Vine","family":"halloween","round":47,"note":"보랏빛 밤 언덕에서 호박 덩굴이 128줄을 감아 오르며 잎을 펼치고 덩굴손을 감고, 마디의 작은 호박이 부풀어 아래부터 하나씩 호박 등으로 켜져요. 다 자라면 시들어 사라지고 새 덩굴이 자라요. K3 은 덩굴 수, K4 는 감기는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pumpkin-vine","type":"code","name":"pumpkin-vine","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spell=0..1, Speed=0.2..3, Vines=1..3, Curl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spell","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Vines","min":1,"max":3},{"name":"Curl","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0579,"detail":0.0293,"edges":0.4367,"complexity":0.7474,"coverage":0.974,"colour":0.4569,"drift":0.3473},"knobResponse":[0.1395,0.1093,0.0659,0.0529]},{"slug":"quadratic-reciprocity","title":"Quadratic Reciprocity","family":"number","round":59,"note":"홀수 소수 64개의 르장드르 기호가 LED 하나에 한 쌍씩 잔 결로 깔린 표 둘을 십자가가 대각선을 따라 훑으며 한 쌍과 거울쌍을 견주고, 두 소수가 다 4로 나눠 3 남는 쌍만 초록으로 남아요. 위 표는 자연순이라 초록이 격자무늬로 흩어지고, 아래 표는 4로 나눠 1 남는 소수를 앞에 둬서 초록이 34×34 구석 한 칸에 모여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quadratic-reciprocity","type":"code","name":"quadratic-reciprocity","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..5, Start=0..400, Law=0.25..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":5},{"name":"Start","min":0,"max":400},{"name":"Law","min":0.25,"max":1}],"start":[0,2,0,0.25],"measures":{"motion":0.032,"detail":0.3336,"edges":0.8903,"complexity":0.4799,"coverage":1,"colour":0.2813,"drift":0.0297},"knobResponse":[0.1738,0.0533,0.336,0.0431]},{"slug":"quantum-walk","title":"Quantum Walk","family":"sim","round":79,"note":"하다마르 동전을 단 양자 걸음이 한 걸음에 한 줄씩 시공간 도표를 써 내려가요. 동전이 L 인 쪽의 확률이 원뿔을 채우며 겹겹의 어두운 호로 갈라지고 두 앞머리 ±t/√2 가 하얗게 빛나다가, 가운데로 고전 걸음의 √t 금빛 점선이 내려와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quantum-walk","type":"code","name":"quantum-walk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Measure=0..1, Coin=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Measure","min":0,"max":1},{"name":"Coin","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0653,"detail":0.2127,"edges":0.8034,"complexity":1.0607,"coverage":0.4719,"colour":0.4591,"drift":0.378},"knobResponse":[0.2908,0.2271,0.2592,0.2987]},{"slug":"question-mark","title":"Question Mark Function","family":"number","round":55,"note":"민코프스키의 물음표 함수가 속을 채운 계단으로 서서 황금비 점 1/φ 를 향해 끝없이 확대되고 한 주기마다 그래프 전체의 사본 안으로 들어가 이음매 없이 돌아오는 동안, 계단에는 패리 분수에서 꺾이는 이분 높이선이 붙고 아래 두 줄에는 그 점의 연분수 자릿수와 ?(x) 의 이진 자릿수가 같은 길이의 덩어리로 맞물려 흘러가요. K3 은 확대해 들어가는 이차 무리수 여섯, K4 는 표시하는 패리 나무의 단 수(3~7)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-question-mark","type":"code","name":"question-mark","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Point=0..5, Depth=3..7","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Point","min":0,"max":5},{"name":"Depth","min":3,"max":7}],"start":[0,2,0,3],"measures":{"motion":0.4067,"detail":0.0603,"edges":0.5728,"complexity":0.6613,"coverage":0.516,"colour":0.2092,"drift":0.0557},"knobResponse":[0.1262,0.0936,0.0953,0.0863]},{"slug":"quipu","title":"Quipu","family":"type","round":78,"note":"주 끈에 늘어뜨린 끈마다 10진 자리 매듭으로 수를 적고, 끈이 셀 때마다 바뀐 값이 주 끈을 달려 끝의 합 끈에 더해져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quipu","type":"code","name":"quipu","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cords=5..8, Step=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cords","min":5,"max":8},{"name":"Step","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.1644,"detail":0.1015,"edges":0.9704,"complexity":0.1354,"coverage":0.2153,"colour":0.1832,"drift":0.0299},"knobResponse":[0.0649,0.0412,0.1565,0.0391]},{"slug":"quousque-tandem","title":"Quousque Tandem","family":"type","round":70,"note":"캐즐런 견본처럼 키케로의 글줄 하나를 크기만 줄여 왼쪽 정렬로 쌓아, 위는 읽히는 큰 글자이고 아래는 1 LED 보다 작은 글자의 회색 결이 되며, 줄마다 윗줄 크기로 자라는 확대가 끝없이 돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quousque-tandem","type":"code","name":"quousque-tandem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=0.7..0.9, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":0.7,"max":0.9},{"name":"Weight","min":0,"max":1}],"start":[0,2,0.7,0.06],"measures":{"motion":1.2978,"detail":0.2148,"edges":0.1725,"complexity":0.7449,"coverage":0.9348,"colour":0.1479,"drift":0.1172},"knobResponse":[0.1877,0.214,0.1904,0.1525]},{"slug":"rabbit-ears","title":"Rabbit Ears","family":"glitch","round":19,"note":"옛 TV 가 토끼 귀 안테나로 늦은 밤 일기예보를 잡아요. 신호가 흔들리면 진행자와 지도가 색을 잃고 눈 속으로 사라졌다가 블랭킹 띠와 함께 굴러 돌아오고, 오른쪽에는 고스트가 따라붙어요. K1 을 누르면 TV 를 쳐서 그림이 한 바퀴 굴러요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rabbit-ears","type":"code","name":"rabbit-ears","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Signal=0..1, Ghost=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Signal","min":0,"max":1},{"name":"Ghost","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.2448,"detail":0.1335,"edges":0.365,"complexity":2.3725,"coverage":0.9855,"colour":0.1077,"drift":0.2857},"knobResponse":[0.1208,0.2747,0.0525,0.0711]},{"slug":"rabi-chevron","title":"Rabi Chevron","family":"wave","round":77,"note":"가로는 이조, 세로는 펄스 길이로 두 준위 원자가 들뜰 확률을 칠해, 라비 셰브런의 겹겹 V 가 쉬지 않고 위로 흘러가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rabi-chevron","type":"code","name":"rabi-chevron","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Span=0..1, Damping=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Span","min":0,"max":1},{"name":"Damping","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.2224,"detail":0.0733,"edges":0.0896,"complexity":1.2279,"coverage":1,"colour":0.3557,"drift":0.032},"knobResponse":[0.2961,0.1552,0.1242,0.1121]},{"slug":"radon-transform","title":"Radon Transform","family":"algo","round":67,"note":"빛줄기가 1초에 반 바퀴를 돌며 센 광자로 아래 칸에 거친 사이노그램을 채우고, 램프 필터로 거른 투영이 위 칸에 제 각도로 번져 쌓이면 별 모양 줄무늬 속에서 타원이 떠올랐다가 두 칸이 함께 어두워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-radon-transform","type":"code","name":"radon-transform","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Angles=0..64, Filter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Angles","min":0,"max":64},{"name":"Filter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5081,"detail":0.0813,"edges":0.2348,"complexity":2.3335,"coverage":0.9242,"colour":0.2511,"drift":0.3748},"knobResponse":[0.24,0.2141,0.0853,0.1229]},{"slug":"rainstorm","title":"Rainstorm","family":"weather","round":2,"note":"빗줄기가 128줄을 다 떨어져 물웅덩이에 고리를 남기고, 가끔 갈라진 번개가 구름을 찢으며 쏟아지는 비를 한순간 밝혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rainstorm","type":"code","name":"rainstorm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rain=0.2..3, Wind=-1..1, Storm=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rain","min":0.2,"max":3},{"name":"Wind","min":-1,"max":1},{"name":"Storm","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.22,"detail":0.0685,"edges":0.8841,"complexity":0.6564,"coverage":0.3785,"colour":0.0656,"drift":0.2647},"knobResponse":[0.0545,0.1279,0.1012,0.1302]},{"slug":"ramsey-fringes","title":"Ramsey Fringes","family":"wave","round":79,"note":"가로가 두 펄스 사이의 빈 시간, 세로가 이조인 램지 무늬예요. 왼쪽 끝 라비 선에서 열린 쌍곡선이 오른쪽으로 갈수록 가운데 공명 줄로 좁아지고, 두 펄스의 위상이 돌며 무늬가 한 칸씩 흘러가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ramsey-fringes","type":"code","name":"ramsey-fringes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Free=-1..1, Pulse=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Free","min":-1,"max":1},{"name":"Pulse","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.409,"detail":0.0908,"edges":0.1478,"complexity":1.765,"coverage":0.964,"colour":0.2949,"drift":0.0644},"knobResponse":[0.2524,0.1847,0.131,0.1804]},{"slug":"random-organization","title":"Random Organization","family":"sim","round":56,"note":"원판 83개가 오른쪽은 아래로, 왼쪽은 위로 밀렸다 돌아오고, 그동안 서로 닿은 원판만 금색으로 빛났다가 주기 끝에 조금씩 튕겨 나가요. 1분쯤 지나면 아무도 닿지 않는 자리를 찾아 청록으로 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-random-organization","type":"code","name":"random-organization","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strain=1..4, Density=0.2..0.35","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strain","min":1,"max":4},{"name":"Density","min":0.2,"max":0.35}],"start":[0,2,1,0.2],"measures":{"motion":3.2667,"detail":0.0848,"edges":0.6378,"complexity":0.6754,"coverage":0.3738,"colour":0.1906,"drift":0.1203},"knobResponse":[0.0739,0.1962,0.2107,0.2637]},{"slug":"randu-planes","title":"RANDU Planes","family":"number","round":60,"note":"IBM 의 RANDU 가 낸 연속한 세 수가 정육면체 속 점 구름으로 구르다가, 시선이 평면 9x − 6y + z = n 을 따라 지나는 순간 열다섯 색의 가로줄 열다섯 개로 접혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-randu-planes","type":"code","name":"randu-planes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Generator=0..3, Points=1.8..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Generator","min":0,"max":3},{"name":"Points","min":1.8,"max":8}],"start":[0,2,0,1.8],"measures":{"motion":2.1593,"detail":0.1518,"edges":0.8612,"complexity":0.5041,"coverage":0.2062,"colour":0.2649,"drift":0.0681},"knobResponse":[0.0715,0.1191,0.1157,0.0454]},{"slug":"rational-tangles","title":"Rational Tangles","family":"topology","round":74,"note":"두 가닥 밧줄이 위는 덮개로 닫히고 아래는 풀린 4가닥 plat 으로 세로로 걸려, 콘웨이의 엉킴 춤에서 T 마다 가운데 두 끝이 실제로 한 번 꼬이고 R 마다 네 끝이 한 칸씩 돌며 분수 p/q 가 바뀌고, 끝을 닫아 2다리 매듭의 이름을 단 뒤 다시 풀어 0 으로 돌아가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rational-tangles","type":"code","name":"rational-tangles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=6..14, Rope=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":6,"max":14},{"name":"Rope","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.358,"detail":0.074,"edges":0.6397,"complexity":0.3735,"coverage":0.2026,"colour":0.2527,"drift":0.2063},"knobResponse":[0.0923,0.1293,0.0974,0.1191]},{"slug":"rauzy-fractal","title":"Rauzy Fractal","family":"fractal","round":28,"note":"트리보나치 치환의 라우지 프랙탈이 세 크기의 제 사본으로 판을 덮고, 그 고정점으로 끝없이 들어가요. 타일은 자라 한 크기 위가 되고, 가운데서 퍼지는 고리가 가장 큰 타일을 세 조각으로 나눠요. 누르면 조각 셋이 저마다의 벡터로 미끄러져 같은 테두리 안에 다시 맞물려요.","why":"색 조각이 패널을 빈틈없이 채워요(채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-rauzy-fractal","type":"code","name":"rauzy-fractal","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=1..4, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":1,"max":4},{"name":"Glow","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2887,"detail":0.0655,"edges":0.9038,"complexity":0.1892,"coverage":0.9988,"colour":0.5834,"drift":0.167},"knobResponse":[0.5259,0.2583,0.0944,0.2959]},{"slug":"rayleigh-taylor","title":"Rayleigh-Taylor","family":"sim","round":58,"note":"무거운 유체가 가벼운 유체 위에 얹혀 있고, 판 가운데 경계의 잔물결이 0.54초마다 e 배로 자라 3초쯤 버섯 갓으로 말려요. 무거운 손가락은 바닥으로, 가벼운 거품은 천장으로 6초 안팎에 닿고, 8.6초에 다 섞인 기둥이 1초 동안 새 층으로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rayleigh-taylor","type":"code","name":"rayleigh-taylor","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Modes=3..9, Viscosity=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Modes","min":3,"max":9},{"name":"Viscosity","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.629,"detail":0.0442,"edges":0.2874,"complexity":1.4144,"coverage":1,"colour":0.368,"drift":0.3399},"knobResponse":[0.3012,0.1067,0.0587,0.0337]},{"slug":"reaction-diffusion","title":"Reaction Diffusion","family":"sim","round":1,"note":"두 물질이 번지고 먹고 먹히며 산호와 미로와 점박이를 길러요. K3 가 종을 바꿔요.","why":"무늬는 굵은데 아주 느려요(움직임 0.06).","block":1,"ramped":false,"layer":{"id":"layer-reaction-diffusion","type":"code","name":"reaction-diffusion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.5..4, Species=0..5, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.5,"max":4},{"name":"Species","min":0,"max":5},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0572,"detail":0.0825,"edges":0.3087,"complexity":2.0894,"coverage":0.7212,"colour":0.4058,"drift":0.1337},"knobResponse":[0.314,0.2095,0.2824,0.2879]},{"slug":"reeb-graph","title":"Reeb Graph","family":"topology","round":46,"note":"구멍 g 개의 사슬 곡면이 수직축으로 돌고, 수평 평면이 훑어 올라가며 자른 고리마다 점 하나로 줄어든 자취가 레브 그래프가 돼요. K3 은 구멍을 둘에서 여섯까지, K4 는 곡면을 기울여 그래프 모양을 바꾸는데 임계점의 수는 늘 2 − 2g 예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-reeb-graph","type":"code","name":"reeb-graph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Holes=2..6, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Holes","min":2,"max":6},{"name":"Tilt","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.4553,"detail":0.0378,"edges":0.6727,"complexity":0.2652,"coverage":0.3868,"colour":0.1965,"drift":0.2996},"knobResponse":[0.0567,0.1232,0.0619,0.075]},{"slug":"reed-solomon","title":"Reed-Solomon","family":"data","round":74,"note":"낱말이 진짜 버전 1 QR 부호로 짜인 뒤 모듈이 긁히거나 얼룩지면, 디코더가 신드롬으로 틀린 코드워드를 찾아 고칠 수 있는 만큼이면 되돌리고 넘치면 빨갛게 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-reed-solomon","type":"code","name":"reed-solomon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Damage=8..60, Data=9..19","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Damage","min":8,"max":60},{"name":"Data","min":9,"max":19}],"start":[0,2,8,9],"measures":{"motion":0.0547,"detail":0.1334,"edges":0.9195,"complexity":0.0797,"coverage":0.3297,"colour":0.2632,"drift":0.2953},"knobResponse":[0.0874,0.0898,0.0503,0.1338]},{"slug":"renyi-parking","title":"Rényi Parking","family":"data","round":35,"note":"128줄이 저마다 60 LED 길이의 거리이고, 6 LED 짜리 차가 아무 데나 와서 들어갈 틈이 있을 때만 서요. 거리는 위에서 빈 채로 들어와 내려가며 차고, 바닥에 닿으면 차 길이만 한 틈이 하나도 없이 72% 쯤 막혀요. 먼저 온 차는 하늘색, 마지막 틈에 끼어든 차는 금색이며 옆 눈금이 바닥을 떠난 거리 128개의 평균을 예측값 0.722 의 금색 눈금에 대 보고, K3 은 차 길이를 6~15 LED 로 바꾸고 K1 을 누르면 차가 다 왼쪽으로 밀려 줄마다 채운 몫만 한 막대가 돼요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-renyi-parking","type":"code","name":"renyi-parking","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=6..15, Lattice=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":6,"max":15},{"name":"Lattice","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":1.1003,"detail":0.1839,"edges":0.8784,"complexity":0.1342,"coverage":0.3299,"colour":0.3078,"drift":0.0658},"knobResponse":[0.1481,0.1885,0.1964,0.2206]},{"slug":"rice-planting","title":"Rice Planting","family":"farm","round":26,"note":"물 댄 논을 위에서 내려다봐요. 밀짚모자를 쓴 일꾼들이 못줄을 따라 뒷걸음질하며 모를 한 포기씩 꽂고, 앞쪽 거울 물에는 구름과 모춤, 백로가 있어요. K1 은 아침 안개에서 노을까지 돌리고, 누르면 남은 모를 한꺼번에 꽂고 줄을 넘겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rice-planting","type":"code","name":"rice-planting","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Planters=4..8, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Planters","min":4,"max":8},{"name":"Wind","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0782,"detail":0.0601,"edges":0.318,"complexity":2.2267,"coverage":1,"colour":0.2886,"drift":0.0509},"knobResponse":[0.2048,0.0848,0.0585,0.1025]},{"slug":"rice-terraces","title":"Rice Terraces","family":"farm","round":25,"note":"세운 패널 아래 끝에서 숲이 선 능선까지 물 댄 다랑논이 등고선처럼 휘어 쌓이고, 논마다 해 뜨는 하늘을 비춰요. 위로 갈수록 층이 얇아지고 노을빛이 짙어지며, 구름 반사가 거울 논들을 가로질러 흘러가고 가까운 논에서는 농부가 물소를 몰아 논을 갈아요. K1 을 돌리면 모가 줄지어 서고 초록으로 덮였다가 누렇게 익고, K1 을 누르면 맨 위 물꼬가 열려 물이 둑을 하나씩 넘어 내려가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rice-terraces","type":"code","name":"rice-terraces","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Season=0..1, Speed=0.2..3, Terraces=12..24, Hour=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Season","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Terraces","min":12,"max":24},{"name":"Hour","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.0809,"detail":0.0942,"edges":0.423,"complexity":2.2579,"coverage":1,"colour":0.1716,"drift":0.0563},"knobResponse":[0.1151,0.0688,0.1253,0.4152]},{"slug":"richardson-dividers","title":"Richardson Dividers","family":"fractal","round":60,"note":"통계적으로 자기 닮은 무작위 곡선을 디바이더가 정한 벌림으로 걸으며 같은 길이의 현으로 다각형을 놓아요. 벌림이 23 LED 에서 0.93 LED 로 줄 때마다 (log s, log L) 점이 아래 로그-로그 그림의 기울기 1 − D 직선 위에 쌓여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-richardson-dividers","type":"code","name":"richardson-dividers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Roughness=-1..1, Cutoff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Roughness","min":-1,"max":1},{"name":"Cutoff","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0618,"detail":0.0439,"edges":0.7385,"complexity":0.4024,"coverage":0.1278,"colour":0.097,"drift":0.0211},"knobResponse":[0.025,0.0227,0.0833,0.0349]},{"slug":"riemann-function","title":"Riemann's Function","family":"fractal","round":62,"note":"리만의 미분 불가능 함수를 복소평면에 옮긴 곡선 φ(t) 가 펜 끝에서 나선 꽃이 달린 하트로 그려지고, 아래 확대경이 그 위의 유리수 한 점으로 파고들어요. p 와 q 가 다 홀수인 점에서는 곡선이 작은 장미꼴을 줄줄이 달고 가로로 곧게 지나가고, 다른 점에서는 직각으로 꺾여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-riemann-function","type":"code","name":"riemann-function","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Point=0..1, Depth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Point","min":0,"max":1},{"name":"Depth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.578,"detail":0.0618,"edges":0.646,"complexity":0.7695,"coverage":0.2342,"colour":0.1794,"drift":0.105},"knobResponse":[0.0776,0.0901,0.1113,0.0515]},{"slug":"ripple-tank","title":"Ripple Tank","family":"sim","round":1,"note":"빗방울이 떨어진 자리마다 고리가 퍼지고 벽에 부딪혀 되돌아와 서로 겹쳐요.","why":"고리가 LED 한 알 굵기라 멀리서는 가늘어요.","block":1,"ramped":false,"layer":{"id":"layer-ripple-tank","type":"code","name":"ripple-tank","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rain=0.5..6, Damping=0..1, Drop=2.5..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rain","min":0.5,"max":6},{"name":"Damping","min":0,"max":1},{"name":"Drop","min":2.5,"max":6}],"start":[0,2,0,2.5],"measures":{"motion":4.7512,"detail":0.0907,"edges":0.3794,"complexity":1.2184,"coverage":0.4445,"colour":0.2076,"drift":0.234},"knobResponse":[0.0799,0.2629,0.1082,0.1339]},{"slug":"risset-rhythm","title":"Risset Rhythm","family":"rhythm","round":50,"note":"다섯 옥타브의 템포를 가로로 깐 이진 자가 4초마다 두 배로 줌아웃하며 패널 아래 한 점으로 오그라들어서, 레인마다 눈금이 재생선을 치는 빠르기가 끝없이 빨라지는데 한 번 두 배가 되면 그림이 처음과 똑같아요. K3 은 밝기 종의 폭, K4 는 이웃 층의 템포 비이고, K1 을 누르면 끝없이 느려져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-risset-rhythm","type":"code","name":"risset-rhythm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=-1..1, Ratio=2..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":-1,"max":1},{"name":"Ratio","min":2,"max":4}],"start":[0,2,0,2],"measures":{"motion":1.5178,"detail":0.0602,"edges":0.37,"complexity":0.4663,"coverage":0.4439,"colour":0.2034,"drift":0.0406},"knobResponse":[0.1066,0.0932,0.0804,0.0638]},{"slug":"rivers-of-white","title":"Rivers of White","family":"type","round":64,"note":"『두 도시 이야기』 첫 문단이 3×5 픽셀 글자로 양쪽 맞춤되어 패널을 채우고, 늘어난 낱말 사이가 줄마다 겹쳐 생긴 흰 강이 하늘색으로 빛나며 아래로 흘러요. 글줄 폭이 64 LED 와 54 LED 사이를 오가면 줄이 다시 갈리면서 강이 끊기고 다시 이어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rivers-of-white","type":"code","name":"rivers-of-white","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fit=0..1, Space=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fit","min":0,"max":1},{"name":"Space","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.345,"detail":0.2252,"edges":0.8342,"complexity":0.8533,"coverage":0.4249,"colour":0.2108,"drift":0.1562},"knobResponse":[0.0331,0.2089,0.1588,0.1866]},{"slug":"rose-criterion","title":"Rose Criterion","family":"noise","round":68,"note":"광자를 하나씩 쌓아 원판 50개가 대비 × 지름 차례로 낟알 위로 떠오르고, 금빛 쌍곡선이 k = 5 경계를 그어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rose-criterion","type":"code","name":"rose-criterion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Exposure=0..1, Read noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Exposure","min":0,"max":1},{"name":"Read noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6536,"detail":0.2435,"edges":0.566,"complexity":2.2998,"coverage":0.4837,"colour":0.2531,"drift":0.2545},"knobResponse":[0.1212,0.1693,0.117,0.1706]},{"slug":"rotor-router","title":"Rotor-Router","family":"sim","round":45,"note":"두 샘에서 번갈아 나온 칩이 LED 마다 놓인 화살표를 따라 걷다가 빈 LED 에 멈춰서, 두 원이 만나 허리가 차오르는 땅콩 모양으로 자라요. 화살표는 방향마다 제 색으로 칠해지고, 땅콩이 양옆에 닿으면 가장자리부터 녹아 다시 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rotor-router","type":"code","name":"rotor-router","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Join=0..1, Random=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Join","min":0,"max":1},{"name":"Random","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9934,"detail":0.087,"edges":0.9599,"complexity":0.2854,"coverage":0.4224,"colour":0.3691,"drift":0.3095},"knobResponse":[0.2001,0.3518,0.2468,0.151]},{"slug":"rule-scroll","title":"Rule Scroll","family":"automata","round":1,"note":"64칸 한 줄이 이웃을 보고 다음 줄을 써 내려가요. 8비트 숫자 하나가 삼각형이 될지 잡음이 될지 정해요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-rule-scroll","type":"code","name":"rule-scroll","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..4, Rule=0..11, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":4},{"name":"Rule","min":0,"max":11},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.3184,"detail":0.3747,"edges":0.8011,"complexity":0.6155,"coverage":0.494,"colour":0.4373,"drift":0.0401},"knobResponse":[0.2576,0.1939,0.2319,0.0376]},{"slug":"ruled-hyperboloid","title":"Ruled Hyperboloid","family":"space","round":80,"note":"위아래 같은 원 둘을 곧은 막대로 이은 탑이 천천히 돌며 비틀려서, 막대가 원통에서 허리 잘록한 쌍곡면을 지나 한 점에서 만나는 이중 원뿔로 닫혔다 열리고, 반대로 비튼 막대와 겹쳐 슈호프 탑의 격자가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ruled-hyperboloid","type":"code","name":"ruled-hyperboloid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rods=16..48, Ruling=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rods","min":16,"max":48},{"name":"Ruling","min":-1,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":1.7728,"detail":0.1367,"edges":0.6464,"complexity":1.3956,"coverage":0.3874,"colour":0.194,"drift":0.2359},"knobResponse":[0.1021,0.2641,0.1844,0.0941]},{"slug":"runge-phenomenon","title":"Runge Phenomenon","family":"wave","round":43,"note":"종 모양 곡선 1/(1 + 25x²) 이 패널에 세로로 서고, 보간점이 그 위에 구슬로 앉아요. 같은 간격의 점이 3개에서 21개로 늘수록 그 점을 다 지나는 다항식이 위아래 끝에서 분홍과 금빛 혀를 패널 가장자리까지 내밀다가, 점이 체비쇼프 자리로 미끄러지면 곡선이 종 위에 내려앉아요. K3 은 가장 많은 점을 41개까지 늘리고, K4 를 올리면 점이 처음부터 체비쇼프 쪽에 앉아 혀가 나오지 않아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-runge-phenomenon","type":"code","name":"runge-phenomenon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Nodes=21..41, Chebyshev=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Nodes","min":21,"max":41},{"name":"Chebyshev","min":0,"max":1}],"start":[0,2,21,0.06],"measures":{"motion":0.3623,"detail":0.0453,"edges":0.6934,"complexity":0.1067,"coverage":0.6605,"colour":0.2225,"drift":0.2038},"knobResponse":[0.0721,0.1903,0.121,0.0829]},{"slug":"ruppert-refinement","title":"Ruppert Refinement","family":"cells","round":72,"note":"자홍 바늘로 가득한 다각형 삼각 분할에 외심과 선분의 가운데 점을 하나씩 꽂아, 가장 작은 각이 기준을 넘을 때까지 바늘이 초록과 파랑 삼각형으로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ruppert-refinement","type":"code","name":"ruppert-refinement","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bound=20..33, Domain=0..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bound","min":20,"max":33},{"name":"Domain","min":0,"max":5}],"start":[0,2,20,0.06],"measures":{"motion":0.0303,"detail":0.0845,"edges":0.6582,"complexity":0.653,"coverage":0.8325,"colour":0.5824,"drift":0.0523},"knobResponse":[0.4284,0.2842,0.0721,0.2915]},{"slug":"rutherford-shadow","title":"Rutherford Shadow","family":"physics","round":60,"note":"같은 에너지의 입자 빔이 아래에서 올라와 3분의 1 높이의 핵에 밀려 저마다 쿨롱 쌍곡선을 그리고, 어떤 궤도도 들어가지 못하는 포물선이 핵 위에 날카로운 그림자로 남아요. 그림자 가장자리에는 궤도가 몰려 빛나고, 정면으로 온 몇 개는 금색으로 되튀어 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rutherford-shadow","type":"code","name":"rutherford-shadow","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Charge=1..6, Attract=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Charge","min":1,"max":6},{"name":"Attract","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.6677,"detail":0.1113,"edges":0.5013,"complexity":1.46,"coverage":0.2954,"colour":0.2307,"drift":0.0765},"knobResponse":[0.0922,0.1217,0.1084,0.1184]},{"slug":"sandpile","title":"Sandpile","family":"automata","round":21,"note":"한 칸에 모래알이 넷 모이면 이웃 넷에 하나씩 넘기는 쟁반에 모래가 한 줌씩 떨어져요. 사태가 떨어진 자리에서 빛나는 고리로 번지며 네 색 레이스를 다시 쓰고, 쟁반이 다 차면 기울어 모래를 쏟아요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-sandpile","type":"code","name":"sandpile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..4, Speed=0.2..3, Sources=1..5, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":4},{"name":"Speed","min":0.2,"max":3},{"name":"Sources","min":1,"max":5},{"name":"Scatter","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.6394,"detail":0.335,"edges":0.8978,"complexity":0.6311,"coverage":0.8294,"colour":0.2844,"drift":0.1509},"knobResponse":[0.2234,0.3094,0.3442,0.2665]},{"slug":"satin-fold","title":"Satin Fold","family":"cosmetic","round":30,"note":"한 점에 잡힌 연한 새틴이 부채꼴 주름으로 흔들리고, 광택이 주름을 따라 긴 줄로 서요. 금색 실 하나가 천을 건너며 주름마다 휘어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-satin-fold","type":"code","name":"satin-fold","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Folds=1..5, Gold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Folds","min":1,"max":5},{"name":"Gold","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.094,"detail":0.0124,"edges":0.0787,"complexity":1.2735,"coverage":1,"colour":0.1403,"drift":0.1604},"knobResponse":[0.1121,0.2232,0.0933,0.0521]},{"slug":"sato-tate","title":"Sato-Tate","family":"number","round":51,"note":"타원곡선의 점을 mod p 로 세어 얻은 a_p/(2√p) 자리에 소수가 빗방울로 떨어지고, 바닥의 막대가 희미한 반원 (2/π)√(1−x²) 을 채워요. 한 겹이 차면 눈금이 반으로 줄고 다음 겹이 같은 반원을 다시 쌓아 다섯 겹의 돔이 돼요. K3 은 곡선 셋 가운데 하나를, K4 는 막대 수를 골라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sato-tate","type":"code","name":"sato-tate","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Curve=0..1, Bins=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Curve","min":0,"max":1},{"name":"Bins","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.4296,"detail":0.09,"edges":0.7697,"complexity":0.3712,"coverage":0.3366,"colour":0.3777,"drift":0.1242},"knobResponse":[0.1935,0.1887,0.1711,0.0589]},{"slug":"sator-square","title":"Sator Square","family":"type","round":71,"note":"돌판에 새긴 SATOR 다섯 줄을 가로, 세로, 거꾸로, 아래에서 위로 읽는 빛 넷이 늘 같은 글자 위를 지나 가운데 N 에서 만나고, 글자들이 가장 짧게 짝지은 길로 날아가 패널 높이의 PATERNOSTER 십자가와 네 끝의 A, O 가 되었다가 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sator-square","type":"code","name":"sator-square","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Assign=0..2, Weather=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Assign","min":0,"max":2},{"name":"Weather","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.171,"detail":0.0405,"edges":0.2522,"complexity":1.0846,"coverage":0.253,"colour":0.097,"drift":0.1512},"knobResponse":[0.0511,0.1526,0.0781,0.0516]},{"slug":"scarecrow-crows","title":"Scarecrow Crows","family":"halloween","round":43,"note":"보라에서 주황으로 내려오는 해 질 녘 하늘에 큰 달이 낮게 뜨고, 밀짚모자를 쓴 허수아비가 검은 그림자로 서서 바람에 흔들려요. 까마귀가 팔과 모자에 내려앉아 깡충 뛰거나 울다가, 허수아비 고개가 홱 돌아가면 한꺼번에 날아올라 위를 돌고 하나씩 돌아와요. K3 은 까마귀를 8마리에서 20마리로 늘려 자리를 못 찾은 까마귀가 지평선에서 땅을 쪼게 하고, K4 는 고개를 3초마다 돌려요. K1 을 누르면 바로 고개를 돌려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-scarecrow-crows","type":"code","name":"scarecrow-crows","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Crows=8..20, Nerves=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Crows","min":8,"max":20},{"name":"Nerves","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.3729,"detail":0.0581,"edges":0.5416,"complexity":0.2416,"coverage":0.785,"colour":0.4251,"drift":0.063},"knobResponse":[0.1462,0.0549,0.0539,0.0535]},{"slug":"scheidegger-rivers","title":"Scheidegger Rivers","family":"line","round":34,"note":"체크무늬로 놓인 LED 마다 물을 왼쪽 아래나 오른쪽 아래로 무작위로 보내는 샤이데거의 강 그물이에요. 모인 물의 로그로 밝혀서 위의 실개천이 아래로 갈수록 굵은 줄기로 합쳐지고, 바닥의 출구마다 다른 색으로 물든 강을 따라 빗방울이 흘러내리며, 가끔 한 자리가 방향을 바꾸면 큰 강이 옆 유역으로 넘어가 옛 물길이 마르고 새 물길이 줄마다 차올라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-scheidegger-rivers","type":"code","name":"scheidegger-rivers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=-1..1, Capture=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":-1,"max":1},{"name":"Capture","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.094,"detail":0.1271,"edges":0.515,"complexity":1.5978,"coverage":0.922,"colour":0.2023,"drift":0.0432},"knobResponse":[0.1672,0.0593,0.2285,0.1968]},{"slug":"schlieren-texture","title":"Schlieren Texture","family":"physics","round":72,"note":"교차한 편광판 사이 네마틱 막에서 ±1/2 전위마다 검은 붓자국 둘이 나와 편광판이 돌면 서로 반대로 돌고, 반대 부호 전위가 만나 사라지는 동안 둘째 차수 간섭색이 띠를 이뤄요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-schlieren-texture","type":"code","name":"schlieren-texture","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Order=-1..1, Speed=0.2..3, Defects=10..30, Uncross=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Order","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Defects","min":10,"max":30},{"name":"Uncross","min":0,"max":1}],"start":[0,2,10,0.06],"measures":{"motion":0.2495,"detail":0.0396,"edges":0.0602,"complexity":2.502,"coverage":0.9719,"colour":0.6294,"drift":0.2854},"knobResponse":[0.3735,0.2438,0.2772,0.6384]},{"slug":"schwarz-lantern","title":"Schwarz Lantern","family":"geometry","round":36,"note":"꼭짓점이 모두 원기둥 위에 있는 삼각형 랜턴이 패널 높이만큼 서서 돌고, 띠가 3개에서 40개로 늘었다 줄어요. 접힐수록 아코디언처럼 반짝이고, 왼쪽 막대가 넓이를 원기둥의 1.88배까지 올려요. K3 은 한 고리의 꼭짓점 수를 5에서 12로 바꿔 같은 띠 40개를 매끈한 기둥으로 남기고, K1 을 누르면 단번에 가장 구겨진 꼴로 접혔다가 천천히 풀려요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-schwarz-lantern","type":"code","name":"schwarz-lantern","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=5..12, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":5,"max":12},{"name":"Light","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":2.2095,"detail":0.1257,"edges":0.8296,"complexity":0.2813,"coverage":0.7377,"colour":0.3317,"drift":0.1973},"knobResponse":[0.2726,0.2005,0.2242,0.2083]},{"slug":"seam-carving","title":"Seam Carving","family":"algo","round":59,"note":"원과 고리로 된 그림 위로 누적 에너지 지도가 쓸려 내려간 뒤, 가장 싼 이음매가 패널 높이만큼 빛나고 빠져서 그림이 64열에서 44열로 좁아져도 원은 둥글게 남아요. 그다음 이음매를 하나씩 겹쳐 넣어 다시 64열로 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-seam-carving","type":"code","name":"seam-carving","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Carve=20..40, Forward=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Carve","min":20,"max":40},{"name":"Forward","min":0,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.1478,"detail":0.0468,"edges":0.4553,"complexity":0.8543,"coverage":0.8225,"colour":0.2557,"drift":0.2013},"knobResponse":[0.2022,0.1777,0.0432,0.0491]},{"slug":"searchlights","title":"Searchlights","family":"light","round":7,"note":"밤 도시의 지붕 뒤에서 탐조등 세 대가 가장자리가 또렷한 빛기둥을 천천히 휘둘러요. 기둥 둘이 겹친 자리는 하얗게 타고, K1 을 누르면 하늘을 가로지르는 비행기를 모든 기둥이 붙잡았다가 놓아줘요.","why":"빛기둥은 좋은데 도시 실루엣이 장면을 만들어요.","block":1,"ramped":false,"layer":{"id":"layer-searchlights","type":"code","name":"searchlights","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Sweep=0.2..4, Lights=3..7, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Sweep","min":0.2,"max":4},{"name":"Lights","min":3,"max":7},{"name":"Haze","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1662,"detail":0.0601,"edges":0.9751,"complexity":0.5201,"coverage":0.2833,"colour":0.1361,"drift":0.3569},"knobResponse":[0.0557,0.2929,0.2085,0.0855]},{"slug":"sedimenting-cloud","title":"Sedimenting Cloud","family":"particle","round":65,"note":"점성 유체 속 입자 구름이 한 덩이로 가라앉으며 안에서 뒤집히고 꼬리를 흘리다 고리가 되어 흩어져요. 위는 정면도, 아래는 위에서 본 평면도예요","why":"","block":0,"ramped":false,"layer":{"id":"layer-sedimenting-cloud","type":"code","name":"sedimenting-cloud","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Particles=300..600, View=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Particles","min":300,"max":600},{"name":"View","min":0,"max":1}],"start":[0,2,300,0.06],"measures":{"motion":0.1452,"detail":0.0345,"edges":0.5307,"complexity":0.5573,"coverage":0.1468,"colour":0.1561,"drift":0.0499},"knobResponse":[0.0478,0.0551,0.0625,0.0399]},{"slug":"seifert-surface","title":"Seifert Surface","family":"topology","round":59,"note":"세로로 그린 닫힌 땋임 매듭의 교차를 방향대로 풀면 자이페르트 원으로 갈라지고, 원마다 원판이 깊이를 두고 쌓인 뒤 교차마다 반 바퀴 꼬인 띠가 이어서 경계가 그 매듭인 곡면이 돼요. 원판의 한 면은 파랑, 다른 면은 금색이라 띠마다 꼬임을 지나며 색이 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-seifert-surface","type":"code","name":"seifert-surface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knot=0..7, Tilt=40..80","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knot","min":0,"max":7},{"name":"Tilt","min":40,"max":80}],"start":[0,2,0,40],"measures":{"motion":0.2142,"detail":0.0491,"edges":0.6412,"complexity":0.2227,"coverage":0.6556,"colour":0.2397,"drift":0.3277},"knobResponse":[0.0509,0.2063,0.217,0.0936]},{"slug":"semaphore","title":"Semaphore","family":"type","round":79,"note":"빨강 노랑 깃발 둘을 든 흰 점이 위에서 내려오며 글자마다 멈춰 두 팔을 시계의 여덟 방향 가운데 두 곳으로 뻗고, 지나간 자세가 대문자와 나란히 남아 낱말이 패널 높이로 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-semaphore","type":"code","name":"semaphore","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Guide=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":7},{"name":"Guide","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1316,"detail":0.0434,"edges":0.5796,"complexity":0.3348,"coverage":0.1427,"colour":0.1799,"drift":0.0884},"knobResponse":[0.0334,0.0835,0.1629,0.028]},{"slug":"senbazuru","title":"Senbazuru","family":"paper","round":22,"note":"붉은 옻칠 고리에 실로 꿴 종이학이 줄줄이 매달려 금박 학 아래로 주황에서 초록, 파랑을 지나 보라와 분홍까지 띠를 이루고, 실 끝에는 금 구슬과 비단 술이 달려요. 어두운 절 방에 외풍이 불면 줄이 흔들리고 학이 실을 축으로 돌면서 접힌 면이 하나씩 등불을 받아 번쩍여요. K1 을 누르면 돌풍이 불어 학 하나가 떨어져 나뭇잎처럼 바닥으로 내려앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-senbazuru","type":"code","name":"senbazuru","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Breeze=0.2..3, Strands=8..16, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Breeze","min":0.2,"max":3},{"name":"Strands","min":8,"max":16},{"name":"Light","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.5463,"detail":0.1059,"edges":0.4439,"complexity":2.0626,"coverage":0.7211,"colour":0.2483,"drift":0.1023},"knobResponse":[0.0684,0.1034,0.1073,0.1606]},{"slug":"sequins","title":"Sequins","family":"textile","round":23,"note":"뒤집히는 스팽글을 촘촘히 단 쿠션이 패널을 채워요. 은빛 비늘이 엇갈린 줄로 겹쳐 있고, 보이지 않는 손끝이 지나가면 스팽글이 차례로 모서리를 보이며 넘어가 하트, 별, 고양이 얼굴, 번개, 파도를 분홍 면으로 그려요. 손바닥이 위에서 아래로 쓸면 다시 은빛이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-sequins","type":"code","name":"sequins","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drawing=0..4, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drawing","min":0,"max":4},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1482,"detail":0.3266,"edges":0.6744,"complexity":1.7886,"coverage":0.647,"colour":0.0886,"drift":0.2495},"knobResponse":[0.0553,0.0492,0.2354,0.1678]},{"slug":"serum-drip","title":"Serum Drip","family":"cosmetic","round":39,"note":"위 끝에서 흘러드는 금빛 세럼 실이 목이 졸리고 부풀어 구슬을 꿴 줄이 되고, 가는 실이 끊기며 큰 방울과 작은 위성 방울이 바닥의 웅덩이로 떨어져요. 세로 홈이 진 벽이 구슬마다 크게 비쳐요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-serum-drip","type":"code","name":"serum-drip","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Viscosity=-1..1, Flow=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Viscosity","min":-1,"max":1},{"name":"Flow","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1144,"detail":0.0191,"edges":0.1005,"complexity":1.4238,"coverage":1,"colour":0.2611,"drift":0.048},"knobResponse":[0.2045,0.0526,0.0374,0.0514]},{"slug":"serum-fingers","title":"Serum Fingers","family":"cosmetic","round":38,"note":"유리판 두 장 사이 진한 크림에 묽은 세럼을 밑에서 밀어 넣으면, 둥근 손가락이 부풀고 갈라지며 위로 다투어 올라가요. LED 는 세럼이 닿을 때 한 번만 바뀌고, 한 손가락이 꼭대기에 닿으면 크림이 가는 손가락부터 다시 덮고 새로 밀어요. K3 은 표면 장력을 낮춰 굵은 손가락 셋을 가는 손가락 열둘로 바꾸고, K1 을 누르면 크림이 바로 다시 덮어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-serum-fingers","type":"code","name":"serum-fingers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fingers=-1..1, Inlet=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fingers","min":-1,"max":1},{"name":"Inlet","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0418,"detail":0.0193,"edges":0.1667,"complexity":0.987,"coverage":1,"colour":0.3588,"drift":0.2509},"knobResponse":[0.1449,0.1034,0.0454,0.0842]},{"slug":"serum-gel","title":"Serum Gel","family":"cosmetic","round":29,"note":"연보라 젤 속에 진주와 캡슐, 기포가 떠서 천천히 흔들리고, 뒤쪽 벽에는 젤 표면을 지난 빛이 부드러운 그물로 어른거려요. K3 은 구슬 수를 여덟에서 마흔까지 바꾸고, 누르면 젤이 크게 출렁이며 구슬이 늘어났다 줄어들며 흔들리다 가라앉아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-serum-gel","type":"code","name":"serum-gel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beads=8..40, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beads","min":8,"max":40},{"name":"Wobble","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.1786,"detail":0.0286,"edges":0.0792,"complexity":2.417,"coverage":1,"colour":0.2132,"drift":0.1307},"knobResponse":[0.3676,0.1568,0.0763,0.0849]},{"slug":"server-rack","title":"Server Rack","family":"circuit","round":18,"note":"앞에서 본 42U 서버 랙이 패널을 채워요. 맨 위 스위치로 들어온 트래픽이 서버를 타고 내려가며 드라이브 불을 켜고, 백업이 스토리지 선반의 드라이브를 차례로 채워요. K4 를 올리면 바닥 타일에서 올라온 푸른 냉기 빛이 아래쪽 앞판을 물들여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-server-rack","type":"code","name":"server-rack","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Load=0..1, Aisle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Load","min":0,"max":1},{"name":"Aisle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3413,"detail":0.1038,"edges":0.3523,"complexity":1.287,"coverage":0.6285,"colour":0.2245,"drift":0.0981},"knobResponse":[0.0421,0.0369,0.0435,0.0677]},{"slug":"setting-mist","title":"Setting Mist","family":"cosmetic","round":31,"note":"왼쪽 밖에서 세팅 미스트가 1초에 한 번쯤 뿜어져, 얇은 원뿔이 3분의 1초 만에 구름으로 부풀고 소용돌이를 말며 흘러가다 가라앉아요. 짙은 물빛 바탕에 굵은 방울이 부드럽게 반짝여요. K1 은 색상환을 다 돌고, 누르면 크게 두 번 뿜어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-setting-mist","type":"code","name":"setting-mist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spray=0..1, Droplets=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spray","min":0,"max":1},{"name":"Droplets","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1908,"detail":0.0088,"edges":0.0593,"complexity":1.291,"coverage":1,"colour":0.0895,"drift":0.1077},"knobResponse":[0.1473,0.1003,0.1667,0.0634]},{"slug":"seven-shuffles","title":"Seven Shuffles","family":"algo","round":29,"note":"카드 한 벌을 옆에서 본 무지개 막대 더미를 리플 셔플로 섞어요. 한 번 섞을 때마다 그러데이션이 2, 4, 8 갈래로 엇갈려 끼다가 일곱 번쯤에 색종이처럼 흩어지고, 그다음 기수 정렬로 되돌려 다시 시작해요. K4 를 끝까지 돌리면 완벽한 파로 셔플이 되어 32장은 다섯 번 만에 처음 순서로 돌아와요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-seven-shuffles","type":"code","name":"seven-shuffles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cards=32..128, Neatness=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cards","min":32,"max":128},{"name":"Neatness","min":0,"max":1}],"start":[0,2,32,0.06],"measures":{"motion":3.42,"detail":0.1826,"edges":0.5208,"complexity":0.0962,"coverage":0.5604,"colour":0.575,"drift":0.2123},"knobResponse":[0.3602,0.3179,0.3253,0.2206]},{"slug":"shadow-play","title":"Shadow Play","family":"stage","round":26,"note":"등잔 불빛을 받은 흰 막에 와양 쿨릿 가죽 인형의 레이스 그림자가 비쳐요. 기사가 거인과 싸워 던져 버리면 구눙안이 떨며 쓸고 들어와 다음 장을 열고, K1 을 돌리면 막 뒤로 돌아가 금빛과 빨강, 남색 칠이 보여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-shadow-play","type":"code","name":"shadow-play","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs View=0..1, Speed=0.2..3, Lamp=0..1, Flicker=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"View","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lamp","min":0,"max":1},{"name":"Flicker","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0562,"detail":0.0589,"edges":0.3798,"complexity":1.779,"coverage":0.627,"colour":0.1416,"drift":0.2084},"knobResponse":[0.2162,0.1484,0.1028,0.0596]},{"slug":"shannon-approximations","title":"Shannon's Approximations","family":"type","round":67,"note":"커서가 『오만과 편견』 첫머리로 센 섀넌의 근사 영어를 16자 21줄 쪽에 덮어 치고, 책에 있는 낱말은 청록으로, 책에서 나란히 선 낱말 쌍은 금빛으로 켜져서 Order 를 올릴수록 흐린 잡음이 낱말로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-shannon-approximations","type":"code","name":"shannon-approximations","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=0..5, Blackout=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":0,"max":5},{"name":"Blackout","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0341,"detail":0.1853,"edges":1,"complexity":0.2756,"coverage":0.3778,"colour":0.0993,"drift":0.0244},"knobResponse":[0.0594,0.0303,0.2475,0.0874]},{"slug":"shapley-folkman","title":"Shapley-Folkman","family":"geometry","round":66,"note":"모양 하나를 1, 2, 4, 8 개 더해 그 수로 나눈 민코프스키 평균이 띠 넷으로 쌓이고, 오목한 만이 띠마다 절반씩 메워지며 흐린 볼록 껍질에 다가가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-shapley-folkman","type":"code","name":"shapley-folkman","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..4, Hull=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":4},{"name":"Hull","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2143,"detail":0.0512,"edges":0.502,"complexity":0.3593,"coverage":0.4293,"colour":0.3465,"drift":0.1635},"knobResponse":[0.1799,0.1546,0.1977,0.0732]},{"slug":"sheet-ghosts","title":"Sheet Ghosts","family":"halloween","round":41,"note":"흰 머리에서 연보라 밑단으로 물든 침대보 유령들이 독한 초록빛을 두르고 세운 패널을 흔들흔들 올라가요. 밑단은 물결치고 몸은 흔들림 뒤로 끌리며, 겹치는 데서는 서로 비쳐 보여요. K3 은 유령을 3 에서 6 까지 늘리고 K4 는 바람이라 몸이 기울고 밑단이 날리며, K1 을 누르면 모두 3.2배로 부풀며 달려들었다가 사라지고 새 유령이 스며 나와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sheet-ghosts","type":"code","name":"sheet-ghosts","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Ghosts=3..6, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ghosts","min":3,"max":6},{"name":"Wind","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.481,"detail":0.0312,"edges":0.2298,"complexity":1.0453,"coverage":0.6411,"colour":0.1958,"drift":0.3699},"knobResponse":[0.0661,0.2767,0.3362,0.4311]},{"slug":"sheet-mask","title":"Sheet Mask","family":"cosmetic","round":35,"note":"세럼에 젖은 시트 마스크가 위에서 내려와 진줏빛 살결에 닿는 대로 맑은 청록으로 비치고, 공기가 갇힌 자리는 흰 공기 방울 여섯 개로 볼록 솟아요. 보이지 않는 손바닥이 4.2초 동안 위에서 아래로 쓸며 방울을 양옆 끝으로 밀어내면, 매끈해진 시트 위로 떠도는 빛 한 점이 섬유 결에 부서져 반짝여요. K3 은 방울을 20개까지 늘리고 크게 부풀리며, K1 은 색상환을 다 돌고 누르면 손바닥이 0.8초 만에 한 번에 눌러 펴요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-sheet-mask","type":"code","name":"sheet-mask","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bubbles=6..20, Weave=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bubbles","min":6,"max":20},{"name":"Weave","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.0942,"detail":0.0264,"edges":0.0175,"complexity":2.3054,"coverage":1,"colour":0.109,"drift":0.1087},"knobResponse":[0.2121,0.1814,0.0787,0.0461]},{"slug":"shimmer-oil","title":"Shimmer Oil","family":"cosmetic","round":36,"note":"보이지 않는 손끝이 마이카가 든 베리빛 바디 오일을 저으면, 납작한 조각들이 늘어난 자리에서는 일어서고 돌기만 하는 자리에서는 누운 채라 소용돌이 자체가 진주빛 실크 결로 보여요. K3 은 젓는 힘이라 1 에서는 소용돌이가 서로 말려 들며 결이 촘촘히 접혀요. K1 을 누르면 다른 손끝이 내려와 20 LED 쯤의 나선을 감아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-shimmer-oil","type":"code","name":"shimmer-oil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stir=0..1, Mica=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stir","min":0,"max":1},{"name":"Mica","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1227,"detail":0.0154,"edges":0,"complexity":1.6312,"coverage":1,"colour":0.1493,"drift":0.0939},"knobResponse":[0.4877,0.1036,0.0703,0.0773]},{"slug":"shoot-em-up","title":"Shoot 'em Up","family":"pixel","round":24,"note":"세로로 흐르는 아케이드 슈팅 게임이 혼자 돌아요. 섬과 해안, 들판과 빨간 지붕 마을이 아래로 흘러가고, 흰 전투기가 노란 탄을 쏘며 S 자로 들어오는 편대와 포탑을 돌리는 포함을 떨어뜨려요. 화면 위 3분의 1을 덮는 보스가 내려와 고리와 나선 탄막을 뿌리다 연쇄 폭발로 부서져요. K1 이 열대 바다에서 붉은 협곡, 밤 도시, 우주 정거장까지 판을 바꾸고, K1 을 누르면 폭탄이 터져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-shoot-em-up","type":"code","name":"shoot-em-up","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stage=0..1, Speed=0.2..3, Waves=1..5, Bullets=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stage","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Waves","min":1,"max":5},{"name":"Bullets","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.2251,"detail":0.0672,"edges":0.7429,"complexity":0.308,"coverage":0.995,"colour":0.3654,"drift":0.1128},"knobResponse":[0.2583,0.2156,0.0612,0.0985]},{"slug":"shoreline","title":"Shoreline","family":"ocean","round":17,"note":"드론으로 곧장 내려다본 해변이에요. 비스듬히 밀려온 너울이 모래톱 위에서 하얗게 부서지고 골에서 다시 일어나 기슭에서 한 번 더 부서진 뒤, 레이스 같은 거품 끝을 단 채 모래를 타고 올라갔다 물러나며 젖은 모래의 어두운 윤기를 남겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-shoreline","type":"code","name":"shoreline","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Water=0..1, Speed=0.2..3, Height=1..3, Tide=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Water","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Height","min":1,"max":3},{"name":"Tide","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1312,"detail":0.0226,"edges":0.2179,"complexity":0.5021,"coverage":1,"colour":0.3833,"drift":0.0432},"knobResponse":[0.2028,0.0707,0.0565,0.1108]},{"slug":"silencio","title":"Silencio","family":"type","round":67,"note":"곰링어의 silencio 열네 낱말이 책등처럼 돌아누워 다섯 단 세 줄로 서고, 가운데 빈 자리가 옆 칸으로 옮겨 가면 그 칸의 낱말은 끝 글자부터 잦아들고 떠난 칸의 낱말은 첫 글자부터 다시 켜져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-silencio","type":"code","name":"silencio","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Hush=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":4},{"name":"Hush","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0347,"detail":0.0734,"edges":0.5117,"complexity":0.3027,"coverage":0.284,"colour":0.0951,"drift":0.0342},"knobResponse":[0.0476,0.0328,0.1224,0.0474]},{"slug":"simpson-paradox","title":"Simpson's Paradox","family":"data","round":63,"note":"무리마다 오르는 점구름 셋이 시소처럼 기울면, 점 전체에 맞춘 흰 최소제곱 직선이 수평을 지나 거꾸로 내려가요. 맨 아래 막대가 무리 기울기와 합친 기울기의 부호를 견줘 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-simpson-paradox","type":"code","name":"simpson-paradox","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Groups=3..5, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Groups","min":3,"max":5},{"name":"Spread","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.7418,"detail":0.0506,"edges":0.4399,"complexity":0.4834,"coverage":0.1335,"colour":0.1541,"drift":0.092},"knobResponse":[0.0415,0.0784,0.0658,0.0336]},{"slug":"simulated-annealing","title":"Simulated Annealing","family":"sim","round":77,"note":"도시 80개를 잇는 엉킨 순회가 메트로폴리스 규칙으로 식으며 엇갈림을 풀고, 짝홀 규칙으로 채운 안쪽이 한 덩어리가 되면 도시가 날아가 다시 녹아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-simulated-annealing","type":"code","name":"simulated-annealing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cities=80..150, Floor=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cities","min":80,"max":150},{"name":"Floor","min":0,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":1.5585,"detail":0.0738,"edges":0.4663,"complexity":1.293,"coverage":0.5013,"colour":0.2017,"drift":0.0861},"knobResponse":[0.1144,0.103,0.1317,0.0922]},{"slug":"sinai-walk","title":"Sinai's Walk","family":"noise","round":57,"note":"무작위 퍼텐셜이 들쭉날쭉한 능선으로 패널을 내려가는 지형에서, 줄마다 제 동전을 가진 자리를 걷개 3,000개가 log t 로 가는 시계를 따라 걸어요. 골짜기마다 log t 깊이까지 웅덩이가 차오르고, 걷개는 저를 담은 웅덩이 바닥에서 빛나다가 웅덩이가 능선을 넘쳐 더 깊은 골짜기와 합쳐지면 다 같이 넘어가요. K3 은 치우침이라 0 이면 시나이의 되돌아오는 걸음이고 올리면 지형이 기울어 걷개가 t^κ 로 덫을 하나씩 거쳐 내려가며, K4 는 자리마다 log ρ 의 퍼짐 σ(1.2~2.4)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sinai-walk","type":"code","name":"sinai-walk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=0..1, Disorder=1.2..2.4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":0,"max":1},{"name":"Disorder","min":1.2,"max":2.4}],"start":[0,2,0,1.2],"measures":{"motion":0.3782,"detail":0.0475,"edges":0.4516,"complexity":0.3886,"coverage":0.3889,"colour":0.143,"drift":0.0579},"knobResponse":[0.059,0.0539,0.0963,0.0861]},{"slug":"siteswap","title":"Siteswap","family":"rhythm","round":41,"note":"공 세 개가 패널 아래 두 손 사이를 포물선으로 오가요. 첫 패턴 51 에서는 5 로 던진 공이 꼭대기까지 올랐다가 반대 손에 떨어지고, 1 은 손 사이를 낮게 건너가요. K3 을 돌리면 공이 7개까지 늘거나 하나씩 패널 밑으로 떨어지고, K4 를 1 로 올리면 공마다 제 아치를 꼬리로 다 그려요. K1 을 누르면 다음 패턴으로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-siteswap","type":"code","name":"siteswap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Balls=3..7, Tail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Balls","min":3,"max":7},{"name":"Tail","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.5928,"detail":0.0334,"edges":0.5727,"complexity":0.5374,"coverage":0.2049,"colour":0.2864,"drift":0.1571},"knobResponse":[0.1083,0.1105,0.258,0.0456]},{"slug":"sitnikov-problem","title":"Sitnikov Problem","family":"space","round":77,"note":"타원 궤도를 도는 두 별의 축 위로 셋째 몸 64개를 한꺼번에 던지면 매끈한 물결이 휘다가 몇 초 만에 찢겨 흩어지고, 궤도면에는 모저의 기호가 열마다 적혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sitnikov-problem","type":"code","name":"sitnikov-problem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ellipse=-1..1, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ellipse","min":-1,"max":1},{"name":"Spread","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7908,"detail":0.0297,"edges":0.4517,"complexity":0.3337,"coverage":0.1229,"colour":0.1073,"drift":0.1239},"knobResponse":[0.0393,0.0997,0.0976,0.0769]},{"slug":"skein","title":"Skein","family":"bird","round":23,"note":"해 진 뒤 하늘을 올려다보면 기러기 떼가 V 자로 패널 위쪽, 북쪽으로 날아가요. 지친 선두가 한쪽 줄로 물러나면 다른 기러기가 앞에 서고, 커다란 보름달 앞을 지날 때는 새카만 실루엣이 돼요. 뒤따라온 작은 떼가 꼬리에 붙기도 해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-skein","type":"code","name":"skein","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Geese=7..31, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Geese","min":7,"max":31},{"name":"Wind","min":-1,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.2572,"detail":0.0301,"edges":0.4436,"complexity":1.9214,"coverage":0.9745,"colour":0.3836,"drift":0.0616},"knobResponse":[0.2529,0.0352,0.0331,0.0516]},{"slug":"skull-swap","title":"Skull Swap","family":"halloween","round":50,"note":"달 뜬 묘지에서 춤추던 해골 둘이 제 머리를 들어 서로 던져 남의 목에 끼우고, 눈구멍을 돌려 마주 보며 어깨를 으쓱한 뒤 도로 던져요. K3 은 머리가 나는 높이와 도는 수, K4 는 바꾸기 사이에 추는 박자 수이고, K1 을 누르면 바로 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-skull-swap","type":"code","name":"skull-swap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Toss=0..1, Dance=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Toss","min":0,"max":1},{"name":"Dance","min":2,"max":8}],"start":[0,2,0,2],"measures":{"motion":0.9759,"detail":0.1109,"edges":0.6361,"complexity":0.3414,"coverage":0.8278,"colour":0.1986,"drift":0.0566},"knobResponse":[0.0913,0.1313,0.0947,0.1237]},{"slug":"skydiver","title":"Skydiver","family":"flight","round":25,"note":"강하장 위로 점프기가 지나가며 문에서 다이버들을 내보내요. 다이버들은 구름층을 뚫고 내려가 손을 잡아 고리를 만들었다가 흩어지고, 저마다 색 램에어 캐노피를 펴서 나선을 그리며 들판의 착지 원으로 내려와요. K1 을 끝까지 돌리면 해가 지평선에 걸린 노을 점프가 되고, K1 을 누르면 다음 비행기가 바로 들어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-skydiver","type":"code","name":"skydiver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Divers=5..12, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Divers","min":5,"max":12},{"name":"Wind","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.1475,"detail":0.0297,"edges":0.3609,"complexity":0.7202,"coverage":0.9986,"colour":0.3312,"drift":0.0468},"knobResponse":[0.1943,0.0707,0.0554,0.0919]},{"slug":"sled-dogs","title":"Sled Dogs","family":"polar","round":27,"note":"드론처럼 바로 위에서 본 개썰매 팀이 둘씩 갱라인에 매여 해빙 위를 달려 올라가요. 낮은 해가 개마다 긴 파란 그림자를 비스듬히 뒤로 던지고, 바람이 깎은 사스트루기 사이로 압력 능선과 다시 언 리드가 발밑을 흘러가요. K1 은 금빛 해에서 오로라 뜬 달밤으로 가고, 누르면 머셔가 외쳐 팀이 방향을 틀어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-sled-dogs","type":"code","name":"sled-dogs","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Dogs=8..14, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dogs","min":8,"max":14},{"name":"Wind","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.9731,"detail":0.0564,"edges":0.2725,"complexity":2.1928,"coverage":0.9989,"colour":0.1125,"drift":0.1372},"knobResponse":[0.4249,0.2371,0.2343,0.1374]},{"slug":"slime-drip","title":"Slime Drip","family":"halloween","round":44,"note":"보라 돌 턱 밑에서 초록 점액이 늘어져 목이 가늘어지다 끊기고, 방울이 패널 끝까지 떨어져 거품 이는 웅덩이에 철퍽 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-slime-drip","type":"code","name":"slime-drip","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drips=5..12, Viscosity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drips","min":5,"max":12},{"name":"Viscosity","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.4493,"detail":0.0402,"edges":0.389,"complexity":0.101,"coverage":0.3514,"colour":0.311,"drift":0.1365},"knobResponse":[0.137,0.0749,0.1396,0.0839]},{"slug":"slinky","title":"Slinky","family":"toy","round":21,"note":"슬링키가 패널 높이만큼 지그재그로 꺾인 계단을 한 칸씩 뒤집히며 내려가요. 코일이 활처럼 휘어 아래 칸으로 쏟아지고, 내려앉은 칸마다 계단등이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-slinky","type":"code","name":"slinky","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spring=0..1, Speed=0.2..3, Rise=6..12, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spring","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rise","min":6,"max":12},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.1152,"detail":0.057,"edges":0.2572,"complexity":1.8838,"coverage":0.9943,"colour":0.1312,"drift":0.056},"knobResponse":[0.1557,0.043,0.0908,0.2999]},{"slug":"smale-horseshoe","title":"Smale Horseshoe","family":"fractal","round":54,"note":"가운데 정사각형을 옆으로 누르고 위로 늘인 띠를 꺾어 다시 덮는 스메일 말굽이 한 번씩 접힐 때마다, 위로 오르는 금빛 가닥과 내려가는 하늘색 가닥 32개가 정사각형을 세로로 가로지르고 위에서는 겹친 아치로, 아래에서는 겹친 U 자로 돌아요. 가로 띠와 겹치는 곳이 하얗게 빛나는 불변 칸토어 집합이고, K3 은 세로 가닥과 가로 띠 가운데 무엇을 보일지, K4 는 한 번 접을 때 누르는 비율 λ 예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-smale-horseshoe","type":"code","name":"smale-horseshoe","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strands=-1..1, Squeeze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":-1,"max":1},{"name":"Squeeze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.9103,"detail":0.2159,"edges":0.8687,"complexity":0.1209,"coverage":0.4757,"colour":0.3518,"drift":0.3378},"knobResponse":[0.1237,0.2874,0.187,0.2058]},{"slug":"smalti","title":"Smalti","family":"glass","round":19,"note":"라벤나 갈라 플라키디아의 별 궁륭과 기도하는 사도를 어두운 줄눈의 유리와 금 테세라로 128줄에 짜요. 등불이 벽을 오르내리면 저마다 조금씩 기운 금 큐브가 빛의 각도를 만날 때마다 번쩍여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-smalti","type":"code","name":"smalti","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Tesserae=2..4, Gold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tesserae","min":2,"max":4},{"name":"Gold","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0438,"detail":0.2001,"edges":1,"complexity":2.3202,"coverage":0.4186,"colour":0.2372,"drift":0.1208},"knobResponse":[0.0652,0.0785,0.082,0.0729]},{"slug":"snow-monkeys","title":"Snow Monkeys","family":"mammal","round":25,"note":"눈 내리는 지고쿠다니의 해 질 녘, 일본원숭이들이 김 오르는 노천 온천에 어깨까지 잠겨 머리에 눈을 얹은 채 졸거나 서로 털을 골라 줘요. 바위 위의 어미가 물로 걸어 들어오고, 덩어리진 김은 눈 덮인 삼나무 비탈을 지나 패널 꼭대기까지 피어올라요. K1 을 끝까지 돌리면 밤이 되어 석등이 김을 주황으로 물들이고, K1 을 누르면 새끼가 물보라를 일으키며 뛰어들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-snow-monkeys","type":"code","name":"snow-monkeys","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Monkeys=3..14, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Monkeys","min":3,"max":14},{"name":"Wind","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2849,"detail":0.086,"edges":0.3721,"complexity":2.5086,"coverage":0.9682,"colour":0.1461,"drift":0.1151},"knobResponse":[0.1114,0.1216,0.0428,0.1209]},{"slug":"soap-film","title":"Soap Film","family":"cosmetic","round":39,"note":"고리에 건 세안 거품의 막이 세로로 서서 빠져요. 위로 갈수록 얇아서 뉴턴의 색 띠가 가로로 쌓여 가라앉고, 옆에서 얇은 막이 기둥으로 올라오고, 위에서 검은 막이 내려와요. 다 얇아지면 막이 터지고 새 막이 아래에서 올라와요.","why":"무지개 막이 화려한데 결이 복잡해요(복잡도 2.34).","block":1,"ramped":false,"layer":{"id":"layer-soap-film","type":"code","name":"soap-film","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Light=0..1, Swirl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Light","min":0,"max":1},{"name":"Swirl","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2419,"detail":0.0368,"edges":0.0854,"complexity":2.3422,"coverage":0.754,"colour":0.6118,"drift":0.3785},"knobResponse":[0.4809,0.5345,0.3525,0.1517]},{"slug":"solenoid","title":"Solenoid","family":"fractal","round":57,"note":"흐린 유리 같은 솔리드 토러스가 세로로 서서 12초에 한 바퀴 돌고, 그 안에서 닫힌 줄 한 가닥이 16번 감겨 두 다발, 네 다발, 여덟 쌍으로 갈라져요. 줄마다 검은 테가 있어서 앞을 지나는 줄이 뒤의 줄을 끊어요. K3 은 단계 k 를 1 에서 7 까지 바꿔 줄을 2가닥에서 128가닥까지 둘로 가르고, K4 는 축소 비율 λ 를 0.49 에서 0.22 까지 줄여 쌍을 한 줄로 붙여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-solenoid","type":"code","name":"solenoid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Level=-3..3, Lambda=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Level","min":-3,"max":3},{"name":"Lambda","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.2823,"detail":0.3196,"edges":1,"complexity":0.8784,"coverage":0.4957,"colour":0.3857,"drift":0.3565},"knobResponse":[0.1838,0.3355,0.2289,0.1985]},{"slug":"sorting","title":"Sorting","family":"algo","round":2,"note":"막대 64개를 알고리즘 하나가 한 번에 한 동작씩 줄 세워요. 비교하는 막대는 희게, 바꾸는 막대는 붉게 켜지고, 다 서면 위에서 아래로 훑어 확인한 뒤 다시 섞어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-sorting","type":"code","name":"sorting","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..5, Algorithm=0..7, Rows=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":5},{"name":"Algorithm","min":0,"max":7},{"name":"Rows","min":2,"max":8}],"start":[0,2,0,2],"measures":{"motion":1.5282,"detail":0.0322,"edges":0.8211,"complexity":0.0601,"coverage":0.5078,"colour":0.3589,"drift":0.1727},"knobResponse":[0.2105,0.2338,0.2297,0.1743]},{"slug":"sorting-network","title":"Sorting Network","family":"line","round":33,"note":"실 열여섯 가닥이 이웃끼리 한 쌍씩 자리를 바꿔 128줄 만에 순서가 거꾸로 되고, 다음 네트워크가 이어받아 실마다 패널을 사인 곡선으로 가로질러요. 균일한 무작위 정렬 네트워크라 바꾼 자리를 찍은 점이 가운데로 반원 꼴로 몰려요. K3 은 실을 32가닥까지 늘리고, K1 을 누르면 실 하나만 8초 동안 밝혀 그 곡선을 보여 줘요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-sorting-network","type":"code","name":"sorting-network","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wires=16..32, Bubble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wires","min":16,"max":32},{"name":"Bubble","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":1.187,"detail":0.1748,"edges":0.7005,"complexity":1.5147,"coverage":0.5118,"colour":0.2962,"drift":0.1325},"knobResponse":[0.1544,0.2402,0.3244,0.2291]},{"slug":"sparks","title":"Sparks","family":"particle","round":1,"note":"불꽃마다 흰빛에서 식어 가는 색이 제 나이를 보여 줘요. 꽃불 세 가지가 느슨한 박자로 터져요.","why":"불꽃이 작고 패널이 거의 비어요(채움 0.16).","block":1,"ramped":false,"layer":{"id":"layer-sparks","type":"code","name":"sparks","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spread=0..1, Rate=0.6..5, Gravity=-1..1, Trail=0.3..1.8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spread","min":0,"max":1},{"name":"Rate","min":0.6,"max":5},{"name":"Gravity","min":-1,"max":1},{"name":"Trail","min":0.3,"max":1.8}],"start":[0,2,0,0.3],"measures":{"motion":0.3313,"detail":0.0372,"edges":0.402,"complexity":0.7208,"coverage":0.1596,"colour":0.1435,"drift":0.1348},"knobResponse":[0.034,0.0885,0.063,0.0577]},{"slug":"specimen-jar","title":"Specimen Jar","family":"halloween","round":47,"note":"보랏빛 선반 위 표본 병의 독한 초록 액체 속에서 핏발 선 눈알이 오르내리며 두리번거리다, 몇 초마다 돌아서 유리 쪽으로 다가와 동공을 열고 나를 똑바로 봐요. K3 은 거품, K4 는 응시가 잦은 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-specimen-jar","type":"code","name":"specimen-jar","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Stare=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bubbles","min":0,"max":1},{"name":"Stare","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3174,"detail":0.0624,"edges":0.4802,"complexity":0.5507,"coverage":0.6646,"colour":0.2382,"drift":0.087},"knobResponse":[0.0956,0.0751,0.0813,0.0622]},{"slug":"specimen-shelf","title":"Specimen Shelf","family":"halloween","round":52,"note":"두 선반의 표본 병 셋에 뜬 눈알 가운데 하나가 돌아 나를 보면, 다른 눈들이 그 눈을 흘끗 보고 차례로 따라 돌았다가 다 함께 딴 데를 보고 위로 굴러 깜빡여요. 선반을 두드리면 액체가 출렁이며 빛나요. K3 은 거품, K4 는 두드리는 잦기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-specimen-shelf","type":"code","name":"specimen-shelf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Knock=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bubbles","min":0,"max":1},{"name":"Knock","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2883,"detail":0.0682,"edges":0.4417,"complexity":0.511,"coverage":0.8309,"colour":0.2555,"drift":0.0607},"knobResponse":[0.1525,0.0933,0.0649,0.0383]},{"slug":"spectrogram","title":"Spectrogram","family":"data","round":17,"note":"새벽 합창의 스펙트로그램이 폭포처럼 내려와요. 휘파람과 떨림, 짹 소리와 뻐꾸기의 두 음이 바람과 먼 찻길로 얼룩진 바닥 위에 밝게 그려지고, K3 을 누르면 손뼉 소리에 새들이 잠시 입을 다물어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-spectrogram","type":"code","name":"spectrogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Map=0..1, Scroll=0.5..4, Birds=0..1, Gain=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Map","min":0,"max":1},{"name":"Scroll","min":0.5,"max":4},{"name":"Birds","min":0,"max":1},{"name":"Gain","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.9689,"detail":0.133,"edges":0.3961,"complexity":2.4228,"coverage":0.9799,"colour":0.4061,"drift":0.0801},"knobResponse":[0.3109,0.1622,0.1596,0.4388]},{"slug":"sperner-lemma","title":"Sperner's Lemma","family":"topology","round":38,"note":"세운 삼각형을 작은 방으로 나누고, 꼭짓점마다 연속 사상이 가장 많이 줄이는 좌표의 번호를 붙여 파랑, 빨강, 초록 영토로 칠해요. 흰 걸음이 밑변의 1-2 문으로 들어와 방마다 다른 문으로 나가다가 세 번호를 다 가진 무지개 방에서 멈추고, 그 방은 사상의 고정점 위에 있어요. K3 은 사상을 고정점 둘레로 비틀어 영토 경계를 감고, K4 는 고정점을 늘려 무지개 방을 홀수 개로 늘려요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-sperner-lemma","type":"code","name":"sperner-lemma","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Mesh=12..28, Speed=0.2..3, Swirl=0..1, Ripple=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Mesh","min":12,"max":28},{"name":"Speed","min":0.2,"max":3},{"name":"Swirl","min":0,"max":1},{"name":"Ripple","min":0,"max":1}],"start":[12,2,0,0.06],"measures":{"motion":0.0411,"detail":0.0869,"edges":0.6362,"complexity":0.5552,"coverage":0.4564,"colour":0.2811,"drift":0.0451},"knobResponse":[0.0654,0.0563,0.0533,0.0518]},{"slug":"spider-drop","title":"Spider Drop","family":"halloween","round":41,"note":"주황 보름달 앞에 보라 거미줄이 걸려 있고, 가운데 앉은 초록 거미가 실을 타고 패널 아래 두 모서리 거미줄 사이까지 떨어져요. 실이 팽팽해지면 튀어 오르며 빙글 돌고 거미줄이 출렁인 뒤, 실을 감으며 다시 올라가요. K3 을 올리면 작은 거미가 둘 더 매달리고 K4 는 바람으로 거미를 20 LED 까지 흔들며, K1 을 누르면 거미가 바로 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-spider-drop","type":"code","name":"spider-drop","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Spiders=1..3, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spiders","min":1,"max":3},{"name":"Wind","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3564,"detail":0.1246,"edges":0.8602,"complexity":0.4765,"coverage":0.3192,"colour":0.2426,"drift":0.0556},"knobResponse":[0.0985,0.0606,0.0835,0.048]},{"slug":"sponge-blend","title":"Sponge Blend","family":"cosmetic","round":31,"note":"옅은 바탕에 산호색 줄 하나가 그어지고, 보이지 않는 촉촉한 스펀지가 줄을 따라 1초에 여섯 번쯤 두드려 고운 구멍 자국을 찍으며 색을 바깥으로 펴요. 15초쯤이면 선이 넓은 점묘 그러데이션이 되고, 닦아 내고 다시 그어요. K1 은 색상환을 다 돌고, 누르면 새 줄을 그어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-sponge-blend","type":"code","name":"sponge-blend","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Coverage=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coverage","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0318,"detail":0.1277,"edges":0.0012,"complexity":1.8672,"coverage":1,"colour":0.1441,"drift":0.0382},"knobResponse":[0.095,0.0521,0.043,0.0383]},{"slug":"spray-stencil","title":"Spray Stencil","family":"type","round":72,"note":"「취급주의」를 오린 철판 위로 분무기가 지그재그로 내려가며 물감을 뿌리고, 판이 걷히면 다리 자리를 틈으로 남긴 글자가 골판지 상자에 패널 높이로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-spray-stencil","type":"code","name":"spray-stencil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Plate=0..3, Overspray=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Plate","min":0,"max":3},{"name":"Overspray","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5288,"detail":0.0408,"edges":0.2215,"complexity":1.528,"coverage":1,"colour":0.3581,"drift":0.2321},"knobResponse":[0.225,0.2049,0.0745,0.0414]},{"slug":"sprout","title":"Sprout","family":"growth","round":1,"note":"한 LED 씩 자라는 픽셀 들꽃밭이에요. 키 큰 접시꽃 둘이 패널 위쪽까지 올라가 꽃대 아래부터 피어요. 시든 꽃잎은 한 점씩 떨어져 발치에 쌓이고, 시드는 포기 곁에서 새 싹이 올라와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-sprout","type":"code","name":"sprout","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Grow=0.25..6, Branches=3..14, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Grow","min":0.25,"max":6},{"name":"Branches","min":3,"max":14},{"name":"Wind","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0426,"detail":0.1141,"edges":0.9949,"complexity":0.1635,"coverage":0.1685,"colour":0.2652,"drift":0.0313},"knobResponse":[0.0448,0.119,0.1279,0.0982]},{"slug":"square-peg","title":"Square Peg","family":"topology","round":49,"note":"구불거리며 비틀리는 닫힌 곡선 위에 네 꼭짓점을 얹은 정사각형을 프레임마다 다 찾아 그리면, 정사각형이 둘씩 태어나고 사라져도 그 수는 늘 홀수예요. K3 은 찾는 직사각형의 가로세로 비, K4 는 곡선이 휘는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-square-peg","type":"code","name":"square-peg","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=1..3, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":1,"max":3},{"name":"Wobble","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2706,"detail":0.0627,"edges":0.8513,"complexity":0.1257,"coverage":0.5291,"colour":0.2477,"drift":0.1322},"knobResponse":[0.0846,0.1151,0.1378,0.1615]},{"slug":"square-wheels","title":"Square Wheels","family":"physics","round":41,"note":"세 줄의 길 위로 홈이 파인 정사각형 바퀴가 굴러가요. 길은 바퀴 한 변 길이로 자른 뒤집힌 현수선 둔덕이라, 바퀴를 길에 내려놓기만 하는데도 흰 축은 흐린 가로줄을 벗어나지 않아요. K3 은 변 수를 4 에서 8 까지 바꾸고 길도 그 바퀴에 맞춰요. K4 를 올리면 둔덕이 펴지면서 축이 출렁이기 시작해, 평평한 길에서 정사각형 축은 4.7 LED 까지 떠요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-square-wheels","type":"code","name":"square-wheels","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=4..8, Road=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":4,"max":8},{"name":"Road","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":1.4157,"detail":0.2236,"edges":0.9704,"complexity":0.1378,"coverage":0.427,"colour":0.3987,"drift":0.2852},"knobResponse":[0.2243,0.2227,0.2381,0.2086]},{"slug":"square-word","title":"Square Word","family":"type","round":78,"note":"한 줄로 쓴 영어 낱말 둘의 글자가 미끄러져 네모 칸에 들어가, 쉬빙의 방체 서법대로 한자 같은 네모 글자 둘이 위아래로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-square-word","type":"code","name":"square-word","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Weight=1.5..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phrase","min":0,"max":7},{"name":"Weight","min":1.5,"max":4}],"start":[0,2,0,1.5],"measures":{"motion":0.2543,"detail":0.0778,"edges":0.847,"complexity":0.1835,"coverage":0.2508,"colour":0.2887,"drift":0.1551},"knobResponse":[0.0491,0.1001,0.0631,0.0476]},{"slug":"squared-rectangle","title":"Squared Rectangle","family":"cells","round":53,"note":"저항 그물의 전선마다 전압 강하를 높이로, 전류를 너비로 삼은 타일이 세로 직사각형 하나를 빈틈없이 메운 채 전도도를 따라 늘고 줄며 미끄러지다가, 몇 초마다 전도도가 모두 1로 돌아와 정사각형들로 딱 맞아떨어지고 이음매가 하얗게 번쩍여요. K3 은 타일 수(13~20), K4 는 전도도가 1에서 벗어나는 폭이고, 단추를 누르면 바로 정사각형으로 맞아떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-squared-rectangle","type":"code","name":"squared-rectangle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tiles=13..20, Wander=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tiles","min":13,"max":20},{"name":"Wander","min":-1,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":0.7434,"detail":0.0564,"edges":0.5334,"complexity":0.0509,"coverage":0.8388,"colour":0.417,"drift":0.1753},"knobResponse":[0.4428,0.1319,0.1958,0.1798]},{"slug":"stable-marriage","title":"Stable Marriage","family":"algo","round":54,"note":"위 16명과 아래 16명 사이의 지연 수락에서 청혼마다 128줄을 가로지르는 선이 날아가 받아들여지면 남고 밀려나면 가운데서 끊기며, 위쪽 안정 매칭이 서면 아래쪽이 같은 목록으로 청혼해서 선 끝의 순위 색이 뒤집히고 두 안정 매칭이 다른 쌍만 번갈아 바뀌는데, K3 은 모두가 한 순위를 나누는 정도, K4 는 아예 받지 않는 상대의 몫이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stable-marriage","type":"code","name":"stable-marriage","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Agreement=0..1, Choosy=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Agreement","min":0,"max":1},{"name":"Choosy","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1867,"detail":0.154,"edges":0.6571,"complexity":1.4407,"coverage":0.4418,"colour":0.3151,"drift":0.1728},"knobResponse":[0.1476,0.1509,0.1814,0.175]},{"slug":"stadium-billiard","title":"Stadium Billiard","family":"physics","round":28,"note":"공 이백 개가 방향을 1000분의 3 라디안 안에서만 달리해 한 점에서 흰 구슬 하나로 떠나요. 패널만 한 부니모비치 경기장의 둥근 끝이 구슬을 무지개 선으로 늘이고 접어서, 몇 초 만에 공들이 기체처럼 판을 채워요. K3 을 돌리면 탁자가 원이 되어 공이 흩어지지 않고, 누르면 새 무리가 떠나요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-stadium-billiard","type":"code","name":"stadium-billiard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Round=0..1, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Round","min":0,"max":1},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.3616,"detail":0.0707,"edges":0.5768,"complexity":0.586,"coverage":0.1863,"colour":0.2492,"drift":0.1225},"knobResponse":[0.0382,0.064,0.0378,0.0449]},{"slug":"stained-glass","title":"Stained Glass","family":"glass","round":18,"note":"고딕 첨두 창이 세운 패널을 다 채워요. 뾰족한 머리의 장미창과 몸통의 생명나무가 검은 납선에 끼운 보석빛 유리 조각으로 짜여 있고, 창 뒤로 해가 지나가면 그 쪽 조각이 희게 타오르고 구름 그림자가 지나가면 어두워져요. K3 은 유리를 자른 크기라서, 돌리면 테두리 네모와 마름모가 잘아지고 장미 꽃잎이 여덟 장에서 열두 장이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-stained-glass","type":"code","name":"stained-glass","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glass=0..1, Speed=0.2..3, Pieces=1..4, Clouds=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glass","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pieces","min":1,"max":4},{"name":"Clouds","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0274,"detail":0.1501,"edges":0.9911,"complexity":1.9492,"coverage":0.4248,"colour":0.2313,"drift":0.0531},"knobResponse":[0.1334,0.0459,0.0844,0.0693]},{"slug":"star-trails","title":"Star Trails","family":"celestial","round":12,"note":"삼각대에 세운 카메라가 셔터를 열어 둔 사이 하늘이 돌아서, 별마다 북극 둘레에 제 색의 호를 그려요. 능선 아래에는 랜턴을 켠 텐트가 있고, 가끔 떨어지는 별똥별은 궤적만큼 사진에 남아요. K1 을 누르면 별똥별이 하나 더 떨어져요.","why":"거의 멈춘 사진이에요(움직임 0.02).","block":1,"ramped":false,"layer":{"id":"layer-star-trails","type":"code","name":"star-trails","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Facing=-1..1, Speed=0.2..3, Latitude=-1..1, Exposure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Facing","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Latitude","min":-1,"max":1},{"name":"Exposure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.019,"detail":0.0909,"edges":0.5036,"complexity":1.5537,"coverage":0.563,"colour":0.1007,"drift":0.036},"knobResponse":[0.2496,0.0367,0.1859,0.2144]},{"slug":"steiner-chain","title":"Steiner Chain","family":"geometry","round":39,"note":"위에서는 고리 안의 같은 원 여섯이 통째로 돌고, 아래는 그 사슬을 반전한 그림이라 원이 넓은 쪽을 지나며 부풀고 좁은 쪽에서 줄어요. 원마다 위아래가 같은 색이고, 어디서 시작해도 사슬이 닫히는 슈타이너의 포리즘이 접점의 흰 불꽃으로 보여요.","why":"원 안의 결이 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-steiner-chain","type":"code","name":"steiner-chain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Circles=6..12, Speed=0.2..3, Turns=1..4, Offset=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Circles","min":6,"max":12},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":1,"max":4},{"name":"Offset","min":0,"max":1}],"start":[6,2,1,0.06],"measures":{"motion":0.3441,"detail":0.0929,"edges":0.4245,"complexity":1.7706,"coverage":0.6096,"colour":0.2864,"drift":0.1304},"knobResponse":[0.1921,0.201,0.172,0.0934]},{"slug":"steiner-deltoid","title":"Steiner Deltoid","family":"line","round":73,"note":"외접원을 도는 점의 심슨 선이 패널 높이를 가로지르고, 그 자취가 쌓여 삼각형 세 변에 붙은 세 뿔 델토이드가 떠올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-steiner-deltoid","type":"code","name":"steiner-deltoid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Trail=0.5..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Trail","min":0.5,"max":4}],"start":[0,2,0,0.5],"measures":{"motion":0.3235,"detail":0.0808,"edges":0.2438,"complexity":1.8841,"coverage":0.4056,"colour":0.1102,"drift":0.0706},"knobResponse":[0.0649,0.0768,0.0891,0.0685]},{"slug":"steiner-symmetrization","title":"Steiner Symmetrization","family":"line","round":69,"note":"초승달, 구멍 난 달걀, 일곱 뿔 별, 떨어진 두 덩이, 빗이 한 LED 현의 빗금으로 그려지고, 현마다 제 박자로 미끄러져 가운데가 흐린 축에 오고 틈으로 갈렸던 현은 한 줄로 붙은 뒤, 빗금이 새 축으로 돌아 다시 미끄러지는 동안 아래 막대가 같은 넓이 원의 눈금까지 줄어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-steiner-symmetrization","type":"code","name":"steiner-symmetrization","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Axes=0..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":5},{"name":"Axes","min":0,"max":8}],"start":[0,2,0,0.06],"measures":{"motion":0.361,"detail":0.0844,"edges":0.9018,"complexity":0.2283,"coverage":0.3259,"colour":0.2893,"drift":0.1841},"knobResponse":[0.1362,0.1111,0.1448,0.0596]},{"slug":"steiner-tree","title":"Steiner Tree","family":"geometry","round":75,"note":"단자를 잇는 가장 짧은 망이 120도로 만나는 슈타이너 점을 두고 서서, 더 짧은 망이 나타나면 뒤집히며 옛 망을 호박색으로 지우고, 발치 막대가 최소 신장 트리와의 길이 비를 √3/2 바닥에 대어 읽어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-steiner-tree","type":"code","name":"steiner-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Terminals=4..7, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Terminals","min":4,"max":7},{"name":"Scatter","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0616,"detail":0.0546,"edges":0.2069,"complexity":0.9352,"coverage":0.2381,"colour":0.117,"drift":0.0648},"knobResponse":[0.0527,0.0761,0.0972,0.0813]},{"slug":"stit-tessellation","title":"STIT Tessellation","family":"cells","round":54,"note":"패널이 한 칸에서 시작해, 칸마다 둘레에 비례하는 빠르기로 기다리다 그 칸을 지나는 무작위 직선에 둘로 잘리고, 새 선분은 하얗게 번쩍이며 옛 선분에 T 자로 닿을 뿐 가로지르지 않아요. 칸이 제 밀도에 이르면 화면이 떠도는 한 점으로 다이빙하고, 잘림이 같은 법칙을 되찾을 만큼만 이어져서 칸은 끝없이 다가오며 갈라져요. K3 은 축을 따르는 선의 몫이라 1 이면 몬드리안 과정이고, K4 는 패널에 서는 칸의 수예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stit-tessellation","type":"code","name":"stit-tessellation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Cells=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Axes","min":0,"max":1},{"name":"Cells","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7782,"detail":0.0565,"edges":0.8121,"complexity":0.2984,"coverage":0.964,"colour":0.4942,"drift":0.134},"knobResponse":[0.4518,0.2186,0.2541,0.2601]},{"slug":"stochastic-resonance","title":"Stochastic Resonance","family":"rhythm","round":46,"note":"이중 우물 속 입자 60개가 약한 밀기와 잡음으로 우물을 건너고, 어느 우물에 있는지 적은 기록이 공명 잡음에서 박자 맞춘 보라와 호박색 띠가 돼요. K3 은 잡음(0 이 공명), K4 는 밀기 세기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stochastic-resonance","type":"code","name":"stochastic-resonance","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=-1..1, Drive=0.55..0.95","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":-1,"max":1},{"name":"Drive","min":0.55,"max":0.95}],"start":[0,2,0,0.55],"measures":{"motion":0.6379,"detail":0.0925,"edges":0.9858,"complexity":0.1411,"coverage":0.8834,"colour":0.5195,"drift":0.1272},"knobResponse":[0.4364,0.2917,0.1781,0.0586]},{"slug":"stokes-drift","title":"Stokes Drift","family":"wave","round":57,"note":"깊이 109 LED 의 물 단면에 파장 256 LED 의 깊은 물 파도가 오른쪽으로 지나가고, 선형 파도의 속도장을 따라 적분한 입자마다 작은 궤도가 꼭 닫히지 않아서 수면에서 곧게 내린 물감 선 네 개가 윗부분부터 앞으로 기울어요. 기운 모양은 e^(2kz) 곡선이라 14 LED 내려갈 때마다 반으로 줄고, 아래쪽 점들은 거의 제자리에 있어요. K3 은 가파름 ak(0.15~0.4)이고, K4 는 입자가 속도를 읽는 자리라 0 은 제 자리에서 읽는 에어리 파도, 1 은 궤도 중심에서 읽는 게르스트너의 트로코이드 파도여서 궤도가 닫히고 물감 선이 흔들리기만 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stokes-drift","type":"code","name":"stokes-drift","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Steepness=0.15..0.4, Gerstner=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Steepness","min":0.15,"max":0.4},{"name":"Gerstner","min":0,"max":1}],"start":[0,2,0.15,0.06],"measures":{"motion":0.9726,"detail":0.0852,"edges":0.4627,"complexity":0.9205,"coverage":0.188,"colour":0.1898,"drift":0.0896},"knobResponse":[0.0601,0.1102,0.1274,0.065]},{"slug":"stormer-trap","title":"Størmer Trap","family":"particle","round":54,"note":"패널을 가로질러 눕힌 자기 쌍극자의 장에서 대전 입자 48개가 위아래 끝까지 서는 희미한 자기력선 고리를 감아 돌며 가운데 가까운 거울점에서 되튀고, 양전하는 한쪽으로 음전하는 반대쪽으로 축을 돌며 천천히 떠돌다가 손실 원뿔에 든 몇 개만 가운데 작은 구에 닿아 번쩍이는데, K3 은 에너지를, K4 는 적도에서의 피치각을 정해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stormer-trap","type":"code","name":"stormer-trap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Energy=0..1, Pitch=0..90","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Energy","min":0,"max":1},{"name":"Pitch","min":0,"max":90}],"start":[0,2,0,0.06],"measures":{"motion":0.3519,"detail":0.0685,"edges":0.324,"complexity":1.4202,"coverage":0.2922,"colour":0.1285,"drift":0.0544},"knobResponse":[0.0516,0.0887,0.0898,0.0857]},{"slug":"strange-eigenmode","title":"Strange Eigenmode","family":"sim","round":54,"note":"한 변 1 인 토러스에 푼 물감을 반 주기는 행이 옆으로, 반 주기는 열이 위아래로 미끄러지는 피어험버트의 사인 흐름이 줄무늬로 늘이고 접는데, 매 프레임 밝기를 되돌려 놓아서 보라에서 옅은 청록으로 빛나는 줄무늬가 3초마다 똑같은 모양으로 돌아오는 동안 참 세기는 주기마다 39% 로 줄어요. K3 은 젓는 세기, K4 는 확산이고, K1 을 누르면 새 물감을 부어 다시 저어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-strange-eigenmode","type":"code","name":"strange-eigenmode","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stir=-1..1, Diffusion=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stir","min":-1,"max":1},{"name":"Diffusion","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6277,"detail":0.0452,"edges":0.2118,"complexity":2.219,"coverage":0.5118,"colour":0.2008,"drift":0.2314},"knobResponse":[0.1459,0.2614,0.2476,0.2971]},{"slug":"string-art","title":"String Art","family":"type","round":76,"note":"핀 187개를 두른 틀에 실 한 가닥이 탐욕 셈으로 고른 현을 하나씩 걸어, 12초에 걸쳐 청록 A 가 실의 겹침으로 짜이고 실, K, & 가 뒤를 이어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-string-art","type":"code","name":"string-art","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spacing=2..8, Round=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spacing","min":2,"max":8},{"name":"Round","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0569,"detail":0.0449,"edges":0.3137,"complexity":1.2839,"coverage":0.4198,"colour":0.1634,"drift":0.3416},"knobResponse":[0.032,0.1009,0.04,0.0366]},{"slug":"structure-ascii","title":"Structure ASCII","family":"type","round":68,"note":"큰 A, S, &, 글 이 안쪽 테두리만 어둡게 켠 채 흔들리다 다음 글자로 녹아들고, 외곽선이 지나는 5×8 칸마다 그 조각에 획이 가장 가까운 아스키 문자를 골라 빗금과 밑줄이 이어진 윤곽을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-structure-ascii","type":"code","name":"structure-ascii","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Cell=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Set","min":0,"max":3},{"name":"Cell","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1276,"detail":0.0664,"edges":1,"complexity":0.1004,"coverage":0.2024,"colour":0.1993,"drift":0.0877},"knobResponse":[0.0485,0.0526,0.0475,0.0505]},{"slug":"subpixel","title":"Subpixel","family":"type","round":66,"note":"a 와 g 의 TrueType 윤곽이 여섯 배로 키운 픽셀 격자 위를 픽셀 몇 분의 일씩 미끄러지고, 밑의 격자는 매 프레임 다시 래스터화돼 RGB 서브픽셀 줄무늬와 색 번짐으로 뛰어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-subpixel","type":"code","name":"subpixel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Letters=0..2, Speed=0.2..3, Mode=0..3, Hint=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Letters","min":0,"max":2},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":0,"max":3},{"name":"Hint","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.2208,"detail":0.0659,"edges":0.492,"complexity":0.7062,"coverage":0.4448,"colour":0.4077,"drift":0.2226},"knobResponse":[0.2289,0.1625,0.1909,0.033]},{"slug":"sugar-scrub","title":"Sugar Scrub","family":"cosmetic","round":32,"note":"장밋빛 오일 밤 위에 설탕 결정 칠백 알쯤이 떠 있고, 보이지 않는 손끝이 지름 26 LED 원을 그리며 지나간 자리에 분홍빛 광택 고리가 남아요. 손끝에 끌린 알갱이는 구르며 하얀 십자로 반짝이고 녹아 작아져요. 10초마다 새 한 숟갈이 더미로 얹혔다가 다음 원에 쓸려 퍼져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-sugar-scrub","type":"code","name":"sugar-scrub","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grain=-1..1, Oil=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grain","min":-1,"max":1},{"name":"Oil","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0841,"detail":0.0638,"edges":0.1575,"complexity":2.6755,"coverage":1,"colour":0.1376,"drift":0.0416},"knobResponse":[0.1741,0.077,0.0995,0.1983]},{"slug":"sunglint","title":"Sunglint","family":"ocean","round":20,"note":"절벽에서 해를 마주 보면 수평선 아래로 윤슬 길이 내려오며 넓어져 패널을 채우고, 밀려오는 잔물결 줄마다 반짝임이 실려요. K1 을 누르면 돛단배가 빛 속을 검은 그림자로 가로질러요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-sunglint","type":"code","name":"sunglint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sun=0..1, Speed=0.2..3, Chop=0..1, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sun","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Chop","min":0,"max":1},{"name":"Wind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5376,"detail":0.3357,"edges":0.4835,"complexity":2.2983,"coverage":0.8569,"colour":0.0799,"drift":0.0378},"knobResponse":[0.1189,0.329,0.2477,0.3023]},{"slug":"swarmalators","title":"Swarmalators","family":"particle","round":47,"note":"위상이 비슷한 점끼리 더 끌리고 모두에게서 밀리는 점 150개짜리 무리 둘이 위아래로 서서, 색이 고리를 한 바퀴 도는 무지개 고리가 돼요. 결합이 천천히 오르내리면 위 고리는 타원으로 눌렸다 쪼개지고, 아래 고리에서는 점들이 고리를 따라 돌아요. K3 은 결합 K, K4 는 그 흔들림의 폭이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-swarmalators","type":"code","name":"swarmalators","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Coupling=-1..0.5, Tour=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coupling","min":-1,"max":0.5},{"name":"Tour","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.551,"detail":0.0942,"edges":1,"complexity":0.2226,"coverage":0.2864,"colour":0.5645,"drift":0.1437},"knobResponse":[0.2718,0.1243,0.1551,0.083]},{"slug":"swatch-row","title":"Swatch Row","family":"cosmetic","round":30,"note":"보이지 않는 손가락이 아이보리 카드에 크림 안료를 한 줄씩 끌어 색조표를 채워요. 줄마다 한 단계씩 밝거나 짙고, K1 하나로 어떤 색 라인으로든 바뀌어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-swatch-row","type":"code","name":"swatch-row","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Range=-1..1, Finish=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Range","min":-1,"max":1},{"name":"Finish","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1965,"detail":0.0215,"edges":0.0463,"complexity":1.8772,"coverage":1,"colour":0.2018,"drift":0.0306},"knobResponse":[0.1202,0.0645,0.0452,0.0494]},{"slug":"syllable-odometer","title":"Syllable Odometer","family":"type","round":66,"note":"자모 바퀴 셋이 주행 기록계처럼 받침부터 돌며 한글 11,172 음절을 세고, 완성형 2,350 에 든 음절은 꽉 찬 호박색으로, 빠진 음절은 속 빈 보라 윤곽으로 지나가며 아래 지도를 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-syllable-odometer","type":"code","name":"syllable-odometer","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Initial=0..18, Skip=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Initial","min":0,"max":18},{"name":"Skip","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6463,"detail":0.0694,"edges":0.3599,"complexity":0.186,"coverage":0.2966,"colour":0.1732,"drift":0.0996},"knobResponse":[0.0578,0.0724,0.0603,0.0595]},{"slug":"taffy-cream","title":"Taffy Cream","family":"cosmetic","round":37,"note":"라일락 크림과 아이보리 크림이 높은 통을 채우고, 보이지 않는 핀 셋이 둘씩 서로를 한 바퀴씩 돌며 태피처럼 잡아당겨요. 두 크림의 경계가 윤기 있는 주름으로 늘어나 한 주기에 13배쯤 길어지며 겹이 늘고 가늘어지다 파스텔로 섞이면, 아이보리 테를 두른 새 덩이가 핀이 지날 길에 놓여요. K3 은 핀을 다섯까지 늘리고, 누르면 새 덩이를 바로 놓아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-taffy-cream","type":"code","name":"taffy-cream","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pins=3..5, Gloss=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pins","min":3,"max":5},{"name":"Gloss","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1992,"detail":0.0229,"edges":0.0398,"complexity":1.5866,"coverage":1,"colour":0.2145,"drift":0.034},"knobResponse":[0.174,0.088,0.0927,0.0503]},{"slug":"talbot-carpet","title":"Talbot Carpet","family":"wave","round":32,"note":"좁은 슬릿 격자를 지난 빛의 세기를, 격자에서 멀어지는 거리를 세로로 두고 그려요. 슬릿 상이 한 탤벗 길이마다 그대로, 반 길이마다 반 주기 옆으로 되살아나고, 그 사이 분수 거리에서는 둘과 넷으로 갈라진 상과 곧은 빛줄기가 엇갈려요. 남색 골과 청록 바닥, 흰 방울이 1 LED 망점 위에서 1초에 15줄씩 올라가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-talbot-carpet","type":"code","name":"talbot-carpet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slit=0..1, Periods=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slit","min":0,"max":1},{"name":"Periods","min":1,"max":4}],"start":[0,2,0,1],"measures":{"motion":0.9679,"detail":0.2277,"edges":0.1425,"complexity":1.3191,"coverage":0.9648,"colour":0.1367,"drift":0.088},"knobResponse":[0.1564,0.1417,0.1324,0.1293]},{"slug":"talking-board","title":"Talking Board","family":"halloween","round":47,"note":"두 촛불 사이 검보라 판 위를 하트 포인터가 스스로 미끄러져 글자에 멈추면, 유리창 아래 글자가 초록으로 켜지고 판 위에 HELLO 나 GOODBYE 같은 말이 한 자씩 적혀요. K3 은 촛불의 일렁임, K4 는 포인터 둘레 빛이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-talking-board","type":"code","name":"talking-board","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flicker=0..1, Aura=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flicker","min":0,"max":1},{"name":"Aura","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1577,"detail":0.0504,"edges":0.4811,"complexity":0.3955,"coverage":0.7725,"colour":0.1949,"drift":0.0733},"knobResponse":[0.0575,0.051,0.0657,0.0732]},{"slug":"tally-count","title":"Tally Count","family":"type","round":74,"note":"기호 1~4 아래 칠판 칸 넷에 표를 하나씩 읽을 때마다 분필 한 획이 正 의 획순대로 그어져, 다섯 표마다 正 하나가 닫히며 칸이 막대처럼 아래로 겨루고, 끝나면 1등 칸이 빛나고 맨 아래 선이 1등이 처음부터 끝까지 앞섰는지 말해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tally-count","type":"code","name":"tally-count","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Closeness=0..1, Size=7..15","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Closeness","min":0,"max":1},{"name":"Size","min":7,"max":15}],"start":[0,2,0,7],"measures":{"motion":0.0659,"detail":0.1174,"edges":0.771,"complexity":0.6007,"coverage":0.2554,"colour":0.1993,"drift":0.0864},"knobResponse":[0.0558,0.0397,0.0717,0.0732]},{"slug":"tamsel","title":"Tamsel","family":"pixel","round":85,"note":"밤거리 가스등에 불을 붙이는 견습 점등꾼이 받침 위에 한 손은 허리에, 한 손은 갈고리 끝에 불씨를 매단 놋쇠 장대에 얹고 서서 숨 쉬고 깜빡여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tamsel","type":"code","name":"tamsel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gel","min":0,"max":1},{"name":"Stand","min":0,"max":3},{"name":"Detail","min":0,"max":1},{"name":"Edition","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0282,"detail":0.0739,"edges":0.7504,"complexity":0.1761,"coverage":0.5022,"colour":0.2325,"drift":0.0077},"knobResponse":[0.0167,0.0248,0.3056,0.0888]},{"slug":"taylor-unmixing","title":"Taylor Unmixing","family":"sim","round":61,"note":"끈적한 유체에 떨어뜨린 염료 일곱 방울이 쿠에트 흐름에 비스듬한 가는 줄로 늘어나 패널을 몇 바퀴 감았다가, 벽이 되돌아가면 처음 자리의 고리 안으로 둥글게 돌아와요. 확산을 올리면 위아래로 번진 흐린 얼룩으로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-taylor-unmixing","type":"code","name":"taylor-unmixing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Turns=2..8, Diffusion=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":2,"max":8},{"name":"Diffusion","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.6612,"detail":0.0451,"edges":0.1585,"complexity":1.9428,"coverage":0.691,"colour":0.2693,"drift":0.2092},"knobResponse":[0.1311,0.1754,0.1626,0.0959]},{"slug":"teletext","title":"Teletext","family":"type","round":78,"note":"디코더가 쪽 번호를 돌려 100 쪽을 찾고, 색이 바뀌는 자리마다 빈칸이 생기는 모자이크 하위 쪽 셋이 2.5초마다 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-teletext","type":"code","name":"teletext","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Page=1..5, Speed=0.2..3, Size=0..1, Reception=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Page","min":1,"max":5},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Reception","min":0,"max":1}],"start":[1,2,0,0.06],"measures":{"motion":0.1635,"detail":0.0962,"edges":1,"complexity":0.062,"coverage":0.3473,"colour":0.6199,"drift":0.3756},"knobResponse":[0.4155,0.2111,0.3795,0.2189]},{"slug":"tennis-racket","title":"Tennis Racket","family":"sim","round":49,"note":"가운데 축으로 돌던 T자 손잡이가 몇 초마다 반 바퀴씩 뒤집히고, 아래 구에서는 각운동량이 분리선을 따라 한쪽 끝에서 반대쪽 끝으로 건너가요. K3 은 어느 주축 가까이에서 던질지, K4 는 그 축에서 얼마나 비껴 던질지이고, 단추를 누르면 다시 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tennis-racket","type":"code","name":"tennis-racket","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Axis=-1..1, Nudge=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Axis","min":-1,"max":1},{"name":"Nudge","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4329,"detail":0.0508,"edges":0.9029,"complexity":0.141,"coverage":0.3983,"colour":0.2014,"drift":0.0914},"knobResponse":[0.0954,0.0589,0.0798,0.0708]},{"slug":"tensegrity","title":"Tensegrity","family":"physics","round":71,"note":"서로 닿지 않는 막대 15개가 팽팽한 케이블 그물에 걸려 패널 높이의 탑으로 서서 16초에 한 바퀴 천천히 돌고, Load 를 올리면 꼭대기의 추가 탑을 17% 짧게 누르며 위쪽을 74도 더 비틀어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tensegrity","type":"code","name":"tensegrity","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Struts=3..6, Load=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Struts","min":3,"max":6},{"name":"Load","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.3934,"detail":0.0806,"edges":0.5939,"complexity":1.0678,"coverage":0.3024,"colour":0.1564,"drift":0.0513},"knobResponse":[0.0608,0.1126,0.1149,0.1101]},{"slug":"terrell-rotation","title":"Terrell Rotation","family":"space","round":57,"note":"정육면체와 위경선 그물을 두른 구가 바둑판으로 놓인 판이 바늘구멍 카메라 앞을 빛의 절반 넘는 빠르기로 위로 미끄러지고, LED 마다 판을 먼저 떠나 지금 카메라에 닿는 빛이 그리는 모습을 보여 줘요. 정육면체는 납작해지지 않고 아랫면을 보이며 돌아 보이고, 구는 테두리가 둥근 채로 그물의 극만 위로 돌아가요. 빛이 다가오는 쪽에서 떠난 아래는 보라 쪽으로, 멀어지는 쪽에서 떠난 위는 초록 쪽으로 옮겨 가요. K3 은 빛에 대한 속도 β(0.5~0.95)라 카메라 바로 앞의 정육면체가 0.5 에서 30도, 0.9 에서 64도 돌아 보이고, K4 는 카메라와 판 사이 거리(2~8칸)라 가까우면 시야가 위아래 54도라 가까운 줄의 테가 휘고 멀면 19도라 모든 정육면체가 거의 같은 각도 arcsin β 로 돌아 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-terrell-rotation","type":"code","name":"terrell-rotation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beta=0.5..0.95, Distance=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beta","min":0.5,"max":0.95},{"name":"Distance","min":2,"max":8}],"start":[0,2,0.5,2],"measures":{"motion":2.7089,"detail":0.1244,"edges":0.7026,"complexity":1.1776,"coverage":0.5154,"colour":0.1984,"drift":0.1346},"knobResponse":[0.1189,0.221,0.2271,0.2255]},{"slug":"test-card","title":"Test Card","family":"glitch","round":1,"note":"텔레비전 컬러 바를, 수직 동기를 잃어 가는 수상기가 보여 주는 대로 그려요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-test-card","type":"code","name":"test-card","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Bursts=0.2..6, Damage=0.15..1, Roll=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Bursts","min":0.2,"max":6},{"name":"Damage","min":0.15,"max":1},{"name":"Roll","min":0,"max":1}],"start":[0,2,0.15,0.06],"measures":{"motion":0.2635,"detail":0.0837,"edges":0.7844,"complexity":0.0808,"coverage":0.8476,"colour":0.6265,"drift":0.0606},"knobResponse":[0.3578,0.0535,0.0933,0.3676]},{"slug":"tetromino-well","title":"Tetromino Well","family":"algo","round":10,"note":"세운 패널이 너비 10칸, 높이 21칸의 테트리스 우물이에요. 지치지 않는 플레이어가 꼭대기에 기다리는 다음 조각을 보며 패널의 3분의 2 높이까지 쌓고, 오른쪽 한 줄을 비워 두었다가 긴 막대가 오면 네 줄을 한꺼번에 지워요. K1 을 누르면 긴 막대가 다음 조각으로 와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-tetromino-well","type":"code","name":"tetromino-well","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Headroom=6..18, Garbage=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Headroom","min":6,"max":18},{"name":"Garbage","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2184,"detail":0.0909,"edges":0.7088,"complexity":0.1224,"coverage":0.6512,"colour":0.4389,"drift":0.0999},"knobResponse":[0.2488,0.0464,0.2189,0.2009]},{"slug":"thermal","title":"Thermal","family":"flight","round":24,"note":"여름 오후의 밭 위에서 흰 글라이더가 열기류를 타고 타원을 그리며 맴돌아 올라가요. 말똥가리 둘이 더 좁게 같이 돌고, 꼭대기의 적운은 자라며 바닥이 어두워져요. 구름 바닥에 닿은 글라이더는 다음 열기류로 미끄러져 가고 아래에서 새 글라이더가 들어와요. K1 을 누르면 윈치가 글라이더 하나를 끌어올려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-thermal","type":"code","name":"thermal","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Gliders=1..4, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gliders","min":1,"max":4},{"name":"Wind","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0272,"detail":0.0308,"edges":0.2402,"complexity":1.2348,"coverage":0.9999,"colour":0.3714,"drift":0.0371},"knobResponse":[0.1132,0.0554,0.0527,0.073]},{"slug":"thomson-kink","title":"Thomson Kink","family":"wave","round":61,"note":"가운데 줄을 오르내리던 전하가 거꾸로 돌거나 멈출 때마다 빛의 속도로 퍼지는 껍질이 생기고, 껍질 사이마다 그때의 속도로 지금 있을 자리에서 뻗은 곧은 역선이 분홍 꺾임으로 이어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-thomson-kink","type":"code","name":"thomson-kink","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=12..32, Velocity=0.3..0.9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":12,"max":32},{"name":"Velocity","min":0.3,"max":0.9}],"start":[0,2,12,0.3],"measures":{"motion":1.4922,"detail":0.0536,"edges":0.539,"complexity":0.846,"coverage":0.8963,"colour":0.1807,"drift":0.1066},"knobResponse":[0.1162,0.1317,0.1166,0.1513]},{"slug":"thomson-problem","title":"Thomson Problem","family":"physics","round":34,"note":"천천히 도는 구 위에서 같은 전하 100개가 서로 밀어 거의 삼각형인 격자로 앉아요. 이웃이 여섯인 전하는 가운데가 옅은 하늘색으로, 오일러 공식이 늘 열둘을 남기는 다섯 이웃 전하는 금색으로 빛나고, 일곱 이웃 전하가 생기면 자홍색이에요. K3 을 480 까지 올리면 열둘이 5-7-5 흉터로 자라고, K1 을 누르면 전하가 흩어졌다가 다시 격자로 앉아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-thomson-problem","type":"code","name":"thomson-problem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Charges=100..480, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Charges","min":100,"max":480},{"name":"Heat","min":0,"max":1}],"start":[0,2,100,0.06],"measures":{"motion":0.1033,"detail":0.027,"edges":0.1646,"complexity":0.9152,"coverage":0.2589,"colour":0.1371,"drift":0.0297},"knobResponse":[0.0593,0.055,0.0527,0.0511]},{"slug":"three-disk-scattering","title":"Three-Disk Scattering","family":"fractal","round":78,"note":"원판 셋 사이를 튀다 나가는 점들 아래로, 출발마다 나가는 틈의 색을 칠한 지도가 끝없이 튀는 궤도 쪽으로 확대되며 띠 속의 띠를 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-three-disk-scattering","type":"code","name":"three-disk-scattering","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gap=0.4..4, Bounces=3..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gap","min":0.4,"max":4},{"name":"Bounces","min":3,"max":12}],"start":[0,2,0.4,3],"measures":{"motion":0.2688,"detail":0.0373,"edges":0.7407,"complexity":0.5293,"coverage":0.7748,"colour":0.5349,"drift":0.1648},"knobResponse":[0.2861,0.1933,0.1665,0.052]},{"slug":"three-gaps","title":"Three Gaps","family":"number","round":30,"note":"원 위에 α 씩 돌아가며 점을 찍으면 이웃 간격은 많아야 세 가지예요. 줄마다 점을 하나씩 더해 간격을 길이 등급으로 칠하고, α 가 분수에 닿으면 아래쪽이 줄무늬로 무너져요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-three-gaps","type":"code","name":"three-gaps","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Alpha=0..1, Points=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Alpha","min":0,"max":1},{"name":"Points","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1477,"detail":0.1059,"edges":0.725,"complexity":0.2583,"coverage":0.9968,"colour":0.6429,"drift":0.149},"knobResponse":[0.4559,0.1669,0.3074,0.2544]},{"slug":"tissot-indicatrix","title":"Tissot's Indicatrix","family":"space","round":55,"note":"도는 구 위에 같은 크기로 깐 작은 원들을 메르카토르 지도에 옮기면 원은 원 그대로지만 위아래 끝으로 갈수록 부풀어서, 위도 80도의 원은 적도의 원보다 거의 여섯 배 넓어요. 투영의 축이 25도 기운 채 열려서 구의 극이 위 가장자리 안에 앉고, 원들은 휜 길을 따라 돌며 위아래 끝에 다가갈 때 부풀었다 가운데로 오며 줄어요. K3 은 축의 기울기(25~90도), K4 는 메르카토르에서 등적 투영으로 섞는 정도이고, 다 섞으면 원이 넓이가 같은 납작한 타원이 되며 한 색이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tissot-indicatrix","type":"code","name":"tissot-indicatrix","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=25..90, Blend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":25,"max":90},{"name":"Blend","min":0,"max":1}],"start":[0,2,25,0.06],"measures":{"motion":0.7992,"detail":0.1355,"edges":0.5856,"complexity":1.5719,"coverage":0.5442,"colour":0.1192,"drift":0.0625},"knobResponse":[0.0588,0.1671,0.1912,0.2193]},{"slug":"toner-pad","title":"Toner Pad","family":"cosmetic","round":35,"note":"섬유 400가닥이 아무렇게나 엇갈린 흰 솜 패드에 장밋빛 토너가 3.2초마다 한 방울씩 떨어져요. 젖는 앞은 잘 빨아올리는 섬유를 따라 손가락처럼 먼저 뻗고, 젖은 곳은 반투명해져 뒤의 빛을 토너 색으로 받으며 그 안의 섬유가 어둡게 드러나요. 패치는 가장자리부터 말라 흰 솜으로 돌아가요. K3 은 한 방울이 적시는 넓이를 1800 LED 에서 5400 LED 로 늘리고, K1 을 누르면 아직 젖은 곳을 피해 한 방울이 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-toner-pad","type":"code","name":"toner-pad","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Toner=0..1, Fibre=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Toner","min":0,"max":1},{"name":"Fibre","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0391,"detail":0.0359,"edges":0.0818,"complexity":1.8818,"coverage":1,"colour":0.1257,"drift":0.1404},"knobResponse":[0.0571,0.1234,0.1866,0.1574]},{"slug":"topologists-sine-curve","title":"Topologist's Sine Curve","family":"topology","round":73,"note":"sin(1/x) 의 흔들림이 아래 극한 선분으로 갈수록 촘촘해져 가장자리가 밝은 띠로 합쳐지고, 곡선을 따라 내려가는 구슬은 점점 빨리 흔들릴 뿐 선분에 닿지 못해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-topologists-sine-curve","type":"code","name":"topologists-sine-curve","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zoom=0..1, Measure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zoom","min":0,"max":1},{"name":"Measure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9526,"detail":0.0885,"edges":0.3974,"complexity":1.1709,"coverage":0.3977,"colour":0.2422,"drift":0.0717},"knobResponse":[0.0922,0.1188,0.238,0.0806]},{"slug":"toussaint-wilczek","title":"Toussaint-Wilczek","family":"particle","round":55,"note":"초록과 자홍 두 종의 입자가 판 가득 뿌려져 걷다가 서로 만나면 짝지어 사라지고, 처음 우연히 더 많았던 쪽이 남은 자리마다 같은 색 영역이 걸음 수의 제곱근으로 넓어지며, 그 사이 이음매는 어둡게 남아 입자가 사라지는 자리에서 잿빛으로 반짝여요. K3 은 처음 뿌리는 밀도(LED 마다 80~320), K4 는 A 가 B 보다 많은 몫이라 올리면 자홍이 사라지고 초록이 판을 채워요. 단추를 누르면 새로 뿌려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-toussaint-wilczek","type":"code","name":"toussaint-wilczek","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=80..320, Excess=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":80,"max":320},{"name":"Excess","min":0,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":3.4684,"detail":0.3444,"edges":0.6629,"complexity":1.2513,"coverage":0.6627,"colour":0.521,"drift":0.22},"knobResponse":[0.3754,0.3816,0.244,0.3428]},{"slug":"tower-crane","title":"Tower Crane","family":"construction","round":24,"note":"해 질 녘 올라가는 콘크리트 건물 옆에 노란 타워크레인이 서서, 마당의 벽판과 철근 다발, 거푸집, 콘크리트 버킷을 차례로 꼭대기 층에 올려요. 붐이 원근 속에서 돌며 짧아졌다 길어지고, 버킷이 바닥을 부으면 건물이 한 층 자라 새 층 창에 불이 들어와요. K1 을 끝까지 돌리면 밤이 되어 투광등이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-tower-crane","type":"code","name":"tower-crane","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Floors=9..13, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Floors","min":9,"max":13},{"name":"Wind","min":-1,"max":1}],"start":[0,2,9,0.06],"measures":{"motion":0.1573,"detail":0.0705,"edges":0.403,"complexity":1.4462,"coverage":0.9851,"colour":0.2925,"drift":0.0434},"knobResponse":[0.3747,0.0499,0.0453,0.0999]},{"slug":"tower-stair","title":"Tower Stair","family":"halloween","round":51,"note":"둥근 돌탑을 잘라 보인 나선 계단을 두건 쓴 사람이 촛불을 들고 오르면, 불빛이 굽은 벽을 비추며 그의 커다란 그림자를 벽에 드리워요. 꼭대기에서 바람이 촛불을 끄면 어둠 속 창에 초록 눈 둘이 뜨고, 촛불은 계단 아래에서 다시 켜져요. K3 은 계단이 감기는 바퀴 수(3~8), K4 는 불빛이 닿는 거리이고, 단추를 누르면 그 자리에서 촛불이 꺼져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tower-stair","type":"code","name":"tower-stair","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Turns=3..8, Reach=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":3,"max":8},{"name":"Reach","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2621,"detail":0.0492,"edges":0.2821,"complexity":1.2358,"coverage":0.985,"colour":0.1804,"drift":0.1729},"knobResponse":[0.0937,0.0804,0.108,0.0818]},{"slug":"train-window","title":"Train Window","family":"space","round":17,"note":"달리는 기차 창밖이 층층이 흘러요. 먼 구름과 산은 느리게, 들판과 농가는 빠르게 지나가고 전차선 기둥은 휙 스쳐요. 깎은 비탈이 다가오면 터널이 창을 검게 덮고 나트륨등이 줄을 그으며 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-train-window","type":"code","name":"train-window","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Time=0..1, Speed=0.2..3, Hills=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Time","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hills","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6601,"detail":0.0493,"edges":0.717,"complexity":0.2041,"coverage":0.8669,"colour":0.2389,"drift":0.3599},"knobResponse":[0.2716,0.0947,0.2843,0.1097]},{"slug":"trajan-helix","title":"Trajan Helix","family":"type","round":74,"note":"대리석 기둥이 천천히 돌고 발치에서 꼭대기까지 감긴 나선 띠에 트라야누스 기둥 받침의 비문이 빨간 로마 대문자로 새겨져 있어서, 앞에서 제 너비로 읽히던 글자가 가장자리에서 좁아지다 뒤로 넘어가며 글줄이 띠를 따라 끝없이 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-trajan-helix","type":"code","name":"trajan-helix","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paint=0..1, Turn=0.2..3, Turns=5..9, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paint","min":0,"max":1},{"name":"Turn","min":0.2,"max":3},{"name":"Turns","min":5,"max":9},{"name":"Light","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.3116,"detail":0.0348,"edges":0.1539,"complexity":1.4771,"coverage":0.7596,"colour":0.1718,"drift":0.0112},"knobResponse":[0.0496,0.0641,0.0878,0.3546]},{"slug":"tree-peano-curve","title":"Tree Peano Curve","family":"line","round":56,"note":"한 줄로 이어진 곡선이 LED 8192개를 한 번씩 다 지나며 왼쪽 아래 모서리에서 왼쪽 위 모서리까지 판을 메우고, 메운 순서대로 초록에서 파랑을 거쳐 자홍으로 물든 위를 옅은 앞선과 짧은 꼬리가 곡선을 따라 흘러요. 8초마다 고리 지운 걸음이 하얀 줄로 새 나무를 그리고, 새 곡선이 모서리에서부터 다시 차올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tree-peano-curve","type":"code","name":"tree-peano-curve","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bands=1..8, Stretch=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bands","min":1,"max":8},{"name":"Stretch","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3401,"detail":0.022,"edges":0.3283,"complexity":0.9535,"coverage":0.993,"colour":0.336,"drift":0.3792},"knobResponse":[0.3794,0.5046,0.1343,0.2557]},{"slug":"trick-or-treat","title":"Trick or Treat","family":"halloween","round":48,"note":"보라 하늘 아래 좁은 골목이 소실점으로 올라가고, 홑이불 유령과 빗자루 든 마녀, 고양이 셋이 손전등을 휘두르며 걸어가다 노란 빛이 쏟아지는 문 앞에서 사탕을 받고 점점 작아져요. K3 은 불 켠 집의 몫, K4 는 바람이고, K1 을 누르면 불 켠 집의 문이 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-trick-or-treat","type":"code","name":"trick-or-treat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lights=0.5..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lights","min":0.5,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.3583,"detail":0.0448,"edges":0.294,"complexity":0.575,"coverage":0.8706,"colour":0.1771,"drift":0.0693},"knobResponse":[0.0692,0.1054,0.0595,0.0592]},{"slug":"trip-let","title":"Trip-let","family":"type","round":63,"note":"글자 셋을 밀어 낸 기둥의 교집합으로 깎은 블록이 비스듬한 빛줄기 속에서 제 대각선을 축으로 3분의 1 바퀴씩 돌아요. 축 하나가 빛과 나란해질 때마다 바닥의 긴 그림자가 덩어리에서 G, E, B 로 차례로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-trip-let","type":"code","name":"trip-let","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Letters=0..5, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Letters","min":0,"max":5},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.246,"detail":0.0368,"edges":0.745,"complexity":0.5108,"coverage":0.8704,"colour":0.1399,"drift":0.1035},"knobResponse":[0.0995,0.0996,0.0657,0.1578]},{"slug":"truchet","title":"Truchet","family":"geometry","round":1,"note":"타일마다 같은 사분원 둘이 있어요. 한 장을 90도 돌리면 길 둘이 하나로 이어지거나 하나가 둘로 끊겨요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-truchet","type":"code","name":"truchet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Flip Rate=0..5, Tile=8..20, Thickness=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Flip Rate","min":0,"max":5},{"name":"Tile","min":8,"max":20},{"name":"Thickness","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.3464,"detail":0.1313,"edges":0.5615,"complexity":1.2014,"coverage":0.7147,"colour":0.3084,"drift":0.0597},"knobResponse":[0.1766,0.0939,0.1747,0.1431]},{"slug":"tukey-depth","title":"Tukey Depth","family":"data","round":58,"note":"점 30 개가 천천히 떠다니고, LED 마다 그 자리를 품는 반평면이 가장 적게 담는 점의 수로 칠해져 한 점씩 깊어지는 볼록 다각형이 겹겹이 서요. 8초마다 점 둘이 160 LED 밖으로 날아가면 바깥 다각형이 쐐기처럼 끌려가고 주황 평균은 11 LED 밀려나지만, 흰 고리의 터키 중앙값은 2.6 LED 만 움직여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tukey-depth","type":"code","name":"tukey-depth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Outliers=0..0.4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Points","min":30,"max":90},{"name":"Outliers","min":0,"max":0.4}],"start":[0,2,30,0.06],"measures":{"motion":0.2276,"detail":0.0365,"edges":0.8553,"complexity":0.1282,"coverage":0.3174,"colour":0.1699,"drift":0.0821},"knobResponse":[0.0816,0.0799,0.0558,0.0644]},{"slug":"tunnel","title":"Tunnel","family":"space","round":1,"note":"가운데서 떨어진 거리로 나누면 평평한 체크무늬가 날아 들어가는 관이 돼요.","why":"굵고 빨라요. 다만 체크무늬 터널은 데모의 단골이에요.","block":1,"ramped":false,"layer":{"id":"layer-tunnel","type":"code","name":"tunnel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=-3..8, Twist=-1..1, Tiles=8..24","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":-3,"max":8},{"name":"Twist","min":-1,"max":1},{"name":"Tiles","min":8,"max":24}],"start":[0,2,0,8],"measures":{"motion":2.5151,"detail":0.0531,"edges":0.4689,"complexity":0.9004,"coverage":0.8993,"colour":0.486,"drift":0.3919},"knobResponse":[0.376,0.2448,0.256,0.2505]},{"slug":"turntables","title":"Turntables","family":"music","round":18,"note":"DJ 의 턴테이블 두 대가 믹서 띠를 사이에 두고 위아래로 서요. 판은 가만히 있는 방 불빛 아래에서 돌며 홈을 드러내고, DJ 는 기다리는 판을 손으로 잡았다가 킥에 맞춰 놓고 크로스페이더를 넘겨요. K2 Pitch 를 0 에 두면 플래터 테두리의 안쪽 스트로브 점이 멈춰 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-turntables","type":"code","name":"turntables","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pitch=-8..8, Scratch=0..1, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pitch","min":-8,"max":8},{"name":"Scratch","min":0,"max":1},{"name":"Light","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2259,"detail":0.0842,"edges":0.4014,"complexity":1.294,"coverage":0.7108,"colour":0.1698,"drift":0.051},"knobResponse":[0.0432,0.0432,0.0448,0.0571]},{"slug":"tutte-embedding","title":"Tutte Embedding","family":"algo","round":43,"note":"세로로 긴 볼록 다각형에 바깥 면을 박은 그물에서 안쪽 매듭이 엉킴으로 던져지고, 서로 엇갈린 실이 주황으로 켜져요. 매듭마다 이웃의 평균 자리로 옮겨 가면 3.5초쯤에 엇갈림이 다 꺼지고 면이 모두 볼록해지며, 테두리 매듭이 다각형을 따라 돌아 그물이 쉬지 않고 흘러요. K3 은 매듭을 90개에서 210개까지 늘리고, K4 는 끊었던 실을 이어 면을 다 삼각형으로 만들며, K1 을 누르면 다시 엉켜요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tutte-embedding","type":"code","name":"tutte-embedding","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knots=90..210, Triangles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knots","min":90,"max":210},{"name":"Triangles","min":0,"max":1}],"start":[0,2,90,0.06],"measures":{"motion":0.5625,"detail":0.1039,"edges":0.6844,"complexity":0.856,"coverage":0.2732,"colour":0.1519,"drift":0.1175},"knobResponse":[0.0933,0.2212,0.1823,0.1191]},{"slug":"twindragon","title":"Twindragon","family":"fractal","round":71,"note":"체크무늬로 켜진 LED 하나하나가 −1+i 진법으로 적힌 가우스 정수이고, 512 개씩 묶인 쌍둥이 용 타일이 저마다 흐린 빛깔로 패널을 덮은 채, 모든 타일에서 같은 수를 세는 밝은 창이 지나가며 자리올림마다 135도씩 돈 작은 쌍둥이 용들로 모양을 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-twindragon","type":"code","name":"twindragon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Digits=9..12, Split=1..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Digits","min":9,"max":12},{"name":"Split","min":1,"max":8}],"start":[0,2,9,1],"measures":{"motion":0.1054,"detail":0.3099,"edges":0.1858,"complexity":0.4006,"coverage":0.5,"colour":0.1924,"drift":0.1219},"knobResponse":[0.0816,0.1242,0.1346,0.1023]},{"slug":"twist-writhe","title":"Twist and Writhe","family":"topology","round":56,"note":"세 번 꼬인 고리 리본이 납작한 원에서 8자를 지나 키 큰 초나선으로 감기는 동안, 아래 막대에서 꼬임수 Tw 가 줄어든 만큼 뒤틀림수 Wr 가 늘어 둘의 합은 늘 같은 정수 눈금에 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-twist-writhe","type":"code","name":"twist-writhe","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lk=3..6, Coil=3..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lk","min":3,"max":6},{"name":"Coil","min":3,"max":6}],"start":[0,2,3,3],"measures":{"motion":0.2285,"detail":0.0397,"edges":0.775,"complexity":0.2545,"coverage":0.1469,"colour":0.1783,"drift":0.1548},"knobResponse":[0.0582,0.122,0.0593,0.0995]},{"slug":"type-mosaic","title":"Type Mosaic","family":"type","round":63,"note":"도는 네 면 프리즘에 붙은 큰 돋을새김 글자가 TYPE 을 한 자씩 넘기는데, 그림 전체가 3×5 작은 글자로 짜여 있어요. 칸마다 밝기에 맞는 잉크의 글자를 골라서 빛이 돌면 획 위의 글자가 8 과 M 에서 ? 와 : 로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-type-mosaic","type":"code","name":"type-mosaic","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Cell=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":4},{"name":"Cell","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.8581,"detail":0.2558,"edges":1,"complexity":0.2121,"coverage":0.2295,"colour":0.243,"drift":0.2554},"knobResponse":[0.0811,0.1865,0.2432,0.2151]},{"slug":"typewriter","title":"Typewriter","family":"type","round":18,"note":"수동 타자기가 시 두 편을 3×5 픽셀 글자로 한 자씩 쳐요. 칠 때마다 활자대가 리본을 지나 튀어 올라 글자를 찍고 종이가 한 칸 왼쪽으로 밀리며, 줄 끝에서 벨이 번쩍이면 캐리지가 오른쪽으로 돌아오며 종이를 한 줄 올려요. K4 를 돌리면 리본이 닳아 글자가 옅어지고, 빨간 반쪽으로 치는 낱말이 늘어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-typewriter","type":"code","name":"typewriter","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Spacing=1..2, Ribbon=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spacing","min":1,"max":2},{"name":"Ribbon","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.4854,"detail":0.1156,"edges":0.8353,"complexity":0.7724,"coverage":0.9016,"colour":0.0948,"drift":0.1684},"knobResponse":[0.084,0.1398,0.167,0.0481]},{"slug":"ulam-sequence","title":"Ulam Sequence","family":"number","round":54,"note":"울람 수열을 1초에 80 항씩 세면서 코드가 스스로 찾은 숨은 진동수 α 로 각 항을 원에 감아 가로로 펼치면, 항들은 cos(αa) \u003c 0 인 절반에만 두 봉우리로 쌓이고 다른 절반은 분홍으로 표시한 2, 3, 47, 69 넷만 남긴 채 비어요. 새 항은 아래 더미로 떨어지고, K3 은 씨앗을 바꾸고 K4 는 α 를 비틀어 띠를 감아 버려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ulam-sequence","type":"code","name":"ulam-sequence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Seed=0..5, Detune=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Seed","min":0,"max":5},{"name":"Detune","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2015,"detail":0.0673,"edges":0.8089,"complexity":0.3845,"coverage":0.1525,"colour":0.1636,"drift":0.0156},"knobResponse":[0.0546,0.0534,0.101,0.1704]},{"slug":"universal-cover","title":"Universal Cover","family":"topology","round":55,"note":"아래 8자 고리를 점이 한 걸음에 한 바퀴씩 도는 동안 위의 네 갈래 나무에서는 그 올림이 같은 글자의 변을 걷고, 나무는 걸음마다 올림을 새 뿌리로 삼아 미끄러지며 다시 자라요. 뿌리까지 줄인 낱말은 빛나는 길과 블록 띠로 남아 걸음마다 반 글자씩 길어져요. K3 은 마지막 글자를 되돌리는 확률(0.25~0.85), K4 는 그리는 나무의 단 수(1.5~6.5)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-universal-cover","type":"code","name":"universal-cover","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Return=0.25..0.85, Depth=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Return","min":0.25,"max":0.85},{"name":"Depth","min":-1,"max":1}],"start":[0,2,0.25,0.06],"measures":{"motion":1.0419,"detail":0.0684,"edges":0.6889,"complexity":0.5487,"coverage":0.1908,"colour":0.182,"drift":0.0463},"knobResponse":[0.0471,0.0708,0.0595,0.0593]},{"slug":"v-cut-letters","title":"V-Cut Letters","family":"type","round":77,"note":"V 끌로 돌에 판 LVX 세 글자가 세로로 서고, 낮은 빛이 12초에 한 바퀴 돌며 홈의 평평한 벽을 하나씩 밝혔다 그늘에 넣어 글자가 빛으로만 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-v-cut-letters","type":"code","name":"v-cut-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wall=30..70, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wall","min":30,"max":70},{"name":"Light","min":0,"max":1}],"start":[0,2,30,0.06],"measures":{"motion":0.0335,"detail":0.0336,"edges":0.3082,"complexity":1.2827,"coverage":1,"colour":0.072,"drift":0.0719},"knobResponse":[0.0507,0.0692,0.0377,0.1383]},{"slug":"vampire-coffin","title":"Vampire Coffin","family":"halloween","round":46,"note":"납골당에 선 관 뚜껑이 삐걱 열려 초록 안개와 빨간 눈을 내보이다 활짝 열리며 박쥐 떼를 쏟아내고 쾅 닫혀요. K3 은 박쥐 수, K4 는 안개 양이고, K1 을 누르면 바로 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-vampire-coffin","type":"code","name":"vampire-coffin","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bats=24..72, Mist=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":24,"max":72},{"name":"Mist","min":0,"max":1}],"start":[0,2,24,0.06],"measures":{"motion":0.3318,"detail":0.0475,"edges":0.2821,"complexity":0.5932,"coverage":0.8711,"colour":0.1969,"drift":0.1254},"knobResponse":[0.0516,0.0994,0.0347,0.0448]},{"slug":"veech-octagon","title":"Veech Octagon","family":"topology","round":62,"note":"위의 정팔각형과 아래의 이중 정오각형 위를 직선 넷씩이 같은 방향으로 달리다가, 한 변으로 나가면 그 변에 붙은 변으로 다시 들어와요. 대부분의 방향에서는 선이 면을 고르게 채우고, K3 이 주기 방향에 닿으면 선이 닫히며 면이 하늘색과 보라 원기둥 둘로 갈라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-veech-octagon","type":"code","name":"veech-octagon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Direction=45..135, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Direction","min":45,"max":135},{"name":"Trail","min":0,"max":1}],"start":[0,2,45,0.06],"measures":{"motion":0.054,"detail":0.0773,"edges":0.6109,"complexity":0.8473,"coverage":0.5614,"colour":0.1756,"drift":0.0143},"knobResponse":[0.1008,0.0657,0.1241,0.0965]},{"slug":"veiled-lady","title":"Veiled Lady","family":"fungi","round":20,"note":"동트기 전 열대 숲 바닥을 손전등으로 비춘 망태버섯 타임랩스예요. 낙엽 속 흰 알이 터져 대가 패널 높이만큼 솟고, 올리브색 갓 밑에서 흰 레이스 망사가 낙엽 가까이까지 내려와요. 파리가 꼬였던 버섯이 시들어 쓰러지면 옆에서 다음 알이 부풀고, K1 을 돌리면 손전등이 UV 로 바뀌어 망사가 청록으로 빛나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-veiled-lady","type":"code","name":"veiled-lady","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Torch=0..1, Speed=0.2..3, Veil=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Torch","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Veil","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1497,"detail":0.0791,"edges":0.3662,"complexity":1.7099,"coverage":0.5698,"colour":0.1244,"drift":0.0576},"knobResponse":[0.0782,0.0485,0.0482,0.0673]},{"slug":"velvet-nap","title":"Velvet Nap","family":"cosmetic","round":34,"note":"판 전체가 에메랄드 무광 벨벳이고, 보이지 않는 손끝 둘이 천천히 글씨를 쓰듯 결을 쓸어요. 빛 쪽으로 밀린 결은 짙고 깊은 색으로, 빛을 따라 누운 결은 옅은 은빛으로 남아 서로 겹쳐 덮이고, 7초마다 손바닥이 22 LED 너비 띠를 위에서 아래로 쓸어 결을 한 방향으로 눕혀요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-velvet-nap","type":"code","name":"velvet-nap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Width=0..1, Pile=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Width","min":0,"max":1},{"name":"Pile","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0497,"detail":0.0465,"edges":0.1077,"complexity":1.9034,"coverage":1,"colour":0.202,"drift":0.1599},"knobResponse":[0.6367,0.0934,0.1478,0.2049]},{"slug":"voderberg-tiling","title":"Voderberg Tiling","family":"cells","round":59,"note":"꼭지각 12도의 가는 삼각형에서 나온 보데르베르크의 9각 타일 두 장이 가운데서 한 장을 감싸고, 다시 두 장을 감싼 뒤, 같은 타일이 두 팔 나선으로 한 장씩 자라 패널을 덮어요. 화면이 물러나면 나선 전체가 돌고 빛의 물결이 팔을 따라 밖으로 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-voderberg-tiling","type":"code","name":"voderberg-tiling","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=16..44, Arms=2..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":16,"max":44},{"name":"Arms","min":2,"max":6}],"start":[0,2,16,2],"measures":{"motion":1.9356,"detail":0.1452,"edges":0.7012,"complexity":1.7048,"coverage":0.8497,"colour":0.434,"drift":0.3913},"knobResponse":[0.222,0.3186,0.2625,0.2904]},{"slug":"void-and-cluster","title":"Void and Cluster","family":"noise","round":62,"note":"백색 잡음으로 뿌린 점 1,516개가 가장 빽빽한 뭉치에서 가장 큰 빈자리로 하나씩 옮겨 가며 고르게 퍼져요. 다 퍼진 점에는 순위가 매겨지고, 문턱이 내려갔다 오르면 점이 순위대로 떠났다 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-void-and-cluster","type":"code","name":"void-and-cluster","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=-1..1, Sigma=1.5..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":-1,"max":1},{"name":"Sigma","min":1.5,"max":4}],"start":[0,2,0,1.5],"measures":{"motion":0.1264,"detail":0.3309,"edges":0.9985,"complexity":0.4769,"coverage":0.1767,"colour":0.2092,"drift":0.1884},"knobResponse":[0.1082,0.1136,0.1954,0.1104]},{"slug":"voronoi","title":"Voronoi","family":"cells","round":2,"note":"흐름을 타고 도는 씨앗마다 가장 가까운 LED 를 제 유리 색으로 칠하고, 조각 사이에 1 LED 납선이 서요. K4 로 거리를 재는 법을 바꾸면 조각 가운데 둥근 유리가 원에서 마름모를 지나 정사각형이 돼요.","why":"색 칸이 쉬지 않고 갈라지고 합쳐져요. 움직임 2.10, 가장자리 1.00, 복잡도 0.21 로 프리셋의 잰 값과 거의 같아요.","block":0,"ramped":false,"layer":{"id":"layer-voronoi","type":"code","name":"voronoi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..6, Cells=20..60, Metric=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":6},{"name":"Cells","min":20,"max":60},{"name":"Metric","min":0,"max":2}],"start":[0,2,20,0.06],"measures":{"motion":2.0975,"detail":0.1621,"edges":1,"complexity":0.2058,"coverage":0.8378,"colour":0.5986,"drift":0.1196},"knobResponse":[0.4827,0.3489,0.3517,0.1477]},{"slug":"vortex-sheet","title":"Vortex Sheet","family":"sim","round":55,"note":"패널을 세로로 가르는 와류 시트를 사이에 두고 왼쪽 물은 아래로, 오른쪽 물은 위로 흐르면, 시트의 작은 물결이 자라 두 갈래 나선으로 말려 들며 청록과 보라 두 물을 점점 얇은 겹으로 감아 넣어요. K3 은 크라스니의 덩이 δ(0.15~0.5)라 작을수록 나선이 촘촘히 감기고, K4 는 패널에 쌓는 파장 수(1~4)예요. 단추를 누르면 새 물결로 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-vortex-sheet","type":"code","name":"vortex-sheet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Blob=0.15..0.5, Waves=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Blob","min":0.15,"max":0.5},{"name":"Waves","min":1,"max":4}],"start":[0,2,0.15,1],"measures":{"motion":0.6705,"detail":0.0853,"edges":0.755,"complexity":0.7161,"coverage":1,"colour":0.2081,"drift":0.0897},"knobResponse":[0.1768,0.1002,0.07,0.0943]},{"slug":"voss-dice","title":"Voss Dice","family":"noise","round":73,"note":"이진 카운터의 비트가 바뀐 주사위만 다시 굴려 1/f 잡음을 만들고, 그 합을 백색 잡음과 갈색 잡음 사이에 나란히 흘려 내려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-voss-dice","type":"code","name":"voss-dice","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dice=4..8, Hold=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dice","min":4,"max":8},{"name":"Hold","min":-1,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.9587,"detail":0.0834,"edges":0.759,"complexity":0.184,"coverage":0.2937,"colour":0.125,"drift":0.0744},"knobResponse":[0.0484,0.1033,0.1412,0.0956]},{"slug":"vuza-canon","title":"Vuza Canon","family":"rhythm","round":55,"note":"72박 주기에서 열두 성부가 같은 여섯 음 리듬 {0, 8, 16, 18, 26, 34} 를 저마다 다른 박에서 시작해 한 줄에 한 박씩 위로 흘러가고, 어느 줄에도 음이 꼭 하나만 켜져서 박을 하나도 겹치거나 빼지 않고 시간을 덮어요. 지금 줄에 닿는 음은 하얗게 번쩍이고 주기가 바뀌는 줄에는 점선이 그어져요. K3 은 캐넌을 바꿔서 역할을 바꾼 여섯 성부, 24박마다 되풀이하는 타일링, 계단 하나로 가는 가장 단순한 타일링을 보여 주고, K4 는 한 성부를 골라 그 음마다 패널을 가로지르는 선을 그어 리듬을 자처럼 읽게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-vuza-canon","type":"code","name":"vuza-canon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Canon=0..3, Focus=0..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Canon","min":0,"max":3},{"name":"Focus","min":0,"max":12}],"start":[0,2,0,0.06],"measures":{"motion":1.0428,"detail":0.0999,"edges":0.3597,"complexity":0.1,"coverage":0.2434,"colour":0.188,"drift":0.0816},"knobResponse":[0.0402,0.0726,0.1195,0.0412]},{"slug":"waggle-dance","title":"Waggle Dance","family":"insect","round":24,"note":"관찰 벌통의 벌집 한 장이 패널 높이로 서요. 위에 봉한 꿀, 그 아래 여덟 색 꽃가루 띠와 애벌레 방이 있고, 벌 여든 마리가 기어 다녀요. 아래쪽 빈 벌집에서는 꽃가루를 단 벌이 몸을 흔들며 8 자 춤을 추고 따르는 벌들이 둘러서요. 춤의 각도가 해에서 본 꽃밭의 방향이라 K4 를 돌리면 모든 춤이 같이 돌아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-waggle-dance","type":"code","name":"waggle-dance","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Bees=80..240, Sun=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bees","min":80,"max":240},{"name":"Sun","min":-1,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":0.2561,"detail":0.1412,"edges":0.4465,"complexity":2.5302,"coverage":0.7323,"colour":0.2225,"drift":0.0504},"knobResponse":[0.1684,0.0666,0.1239,0.0576]},{"slug":"walsh-functions","title":"Walsh Functions","family":"wave","round":67,"note":"위에는 ±1 로만 된 2차원 Walsh 함수 64장의 표가 서고, 아래 추상 그림은 그 계수를 지그재그로 하나씩 더하며 8×8 블록에서 또렷해지는 동안 더해지는 타일이 위에서 빛나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-walsh-functions","type":"code","name":"walsh-functions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=0..2, Drop=0..63","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":0,"max":2},{"name":"Drop","min":0,"max":63}],"start":[0,2,0,0.06],"measures":{"motion":0.0796,"detail":0.1162,"edges":0.8289,"complexity":0.6061,"coverage":0.7721,"colour":0.2904,"drift":0.1251},"knobResponse":[0.1921,0.0706,0.0866,0.0779]},{"slug":"warp","title":"Warp","family":"space","round":15,"note":"별 사이를 워프로 날아요. 별은 앞쪽에서 얼음빛 파랑이고, 옆으로 지나가며 자홍 줄로 늘어나요. K1 을 누르면 워프에서 빠져 멈췄다가 흰 빛과 함께 다시 들어가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-warp","type":"code","name":"warp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Warp=0.2..4, Stars=420..1400, Steer=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Warp","min":0.2,"max":4},{"name":"Stars","min":420,"max":1400},{"name":"Steer","min":-1,"max":1}],"start":[0,2,420,0.06],"measures":{"motion":2.077,"detail":0.0623,"edges":0.3496,"complexity":0.991,"coverage":0.2025,"colour":0.1354,"drift":0.0642},"knobResponse":[0.0455,0.0994,0.1476,0.0712]},{"slug":"waterfall","title":"Waterfall","family":"weather","round":14,"note":"강이 벼랑 끝을 넘어 패널 높이를 다 떨어져 소에 닿아요. 벼랑 끝에서 청록 유리 같던 물은 떨어지며 하얘지고, 소에서 오르는 안개에 무지개 한 토막이 서요. K3 바람을 끝까지 돌리면 돌풍이 물줄기를 찢어 물보라로 날려 올리고, K1 을 누르면 통나무 하나가 벼랑 끝을 넘어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-waterfall","type":"code","name":"waterfall","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=-1..1, Spate=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":-1,"max":1},{"name":"Spate","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6549,"detail":0.0595,"edges":0.3161,"complexity":1.514,"coverage":0.9639,"colour":0.146,"drift":0.0724},"knobResponse":[0.0442,0.112,0.1828,0.287]},{"slug":"weaire-phelan","title":"Weaire-Phelan","family":"space","round":54,"note":"A15 격자의 보로노이 칸 48개로 쌓은 키 큰 거품 기둥이 천천히 돌며, 청록 오각형만 두른 십이면체와 금색 육각형 둘을 낀 십사면체가 흰 모서리 아래 맞물린 위어-펠런 구조를 보여 주는데, K3 을 올리면 기둥 위쪽부터 같은 부피의 켈빈 깎은 팔면체가 보라 정사각형을 달고 들어서고 K4 는 칸을 제 자리 쪽으로 줄여 틈을 벌려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-weaire-phelan","type":"code","name":"weaire-phelan","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Kelvin=0..1, Gap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Kelvin","min":0,"max":1},{"name":"Gap","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5969,"detail":0.0787,"edges":0.8466,"complexity":0.5443,"coverage":0.5818,"colour":0.2374,"drift":0.0597},"knobResponse":[0.118,0.1957,0.207,0.2228]},{"slug":"weaver","title":"Weaver","family":"bird","round":22,"note":"강 위로 뻗은 아카시아 가지 끝에서 수컷 마을베짜기새가 둥지를 지어요. 갈대 잎을 찢어 문 초록 띠를 벽에 꿰어 당기면 둥지가 고리에서 둥근 방으로, 다시 아래로 열린 입구로 한 가닥씩 자라고, 묵은 띠는 짚 색으로 바래요. K1 을 누르면 암컷이 날아와 둥지를 살피고, 다 지은 둥지가 퇴짜를 맞으면 수컷이 끊어 강에 떨어뜨리고 새 고리부터 다시 지어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-weaver","type":"code","name":"weaver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Plumage=0..2, Speed=0.2..3, Nests=3..9, Sky=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Plumage","min":0,"max":2},{"name":"Speed","min":0.2,"max":3},{"name":"Nests","min":3,"max":9},{"name":"Sky","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1278,"detail":0.0716,"edges":0.3689,"complexity":2.2916,"coverage":0.9985,"colour":0.2367,"drift":0.0436},"knobResponse":[0.0466,0.0543,0.0568,0.2018]},{"slug":"web-tremor","title":"Web Tremor","family":"halloween","round":47,"note":"달 아래 키 큰 거미줄에 나방이 걸려 버둥댈 때마다 빛이 실을 타고 세로줄로는 빠르게, 나선으로는 느리게 퍼지고, 허브의 거미가 달려가 나방을 흰 고치로 감고 돌아와요. K3 은 나방의 몸부림, K4 는 그물이 처지는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-web-tremor","type":"code","name":"web-tremor","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Struggle=0..1, Sag=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Struggle","min":0,"max":1},{"name":"Sag","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5269,"detail":0.0644,"edges":0.5533,"complexity":0.4866,"coverage":0.6885,"colour":0.1269,"drift":0.0951},"knobResponse":[0.072,0.0714,0.0623,0.0732]},{"slug":"werewolf","title":"Werewolf","family":"halloween","round":49,"note":"구름이 걷힌 보름달 앞 바위 위에서 남자가 등을 굽히고 팔이 앞다리로 늘어나 늑대가 되어 울부짖고, 구름이 다시 달을 덮으면 남자로 돌아와요. K3 은 구름, K4 는 달의 크기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-werewolf","type":"code","name":"werewolf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Moon=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Clouds","min":0,"max":1},{"name":"Moon","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1085,"detail":0.038,"edges":0.3264,"complexity":0.2377,"coverage":0.6294,"colour":0.2043,"drift":0.065},"knobResponse":[0.0663,0.0874,0.0692,0.1205]},{"slug":"wheel-cypher","title":"Wheel Cypher","family":"type","round":80,"note":"윤이 나는 원판 25 장을 쌓은 원통에서 원판이 위에서부터 하나씩 돌아 25 글자 평문이 호박색 한 줄로 서고, 몇 칸 옆 줄이 보라색 암호문으로 켜지며 양옆 쪽지에 두 글이 적혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wheel-cypher","type":"code","name":"wheel-cypher","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Message=0..5, Line=1..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Message","min":0,"max":5},{"name":"Line","min":1,"max":5}],"start":[0,2,0,1],"measures":{"motion":0.3465,"detail":0.2066,"edges":0.4818,"complexity":2.4715,"coverage":0.9503,"colour":0.1051,"drift":0.0748},"knobResponse":[0.0909,0.1093,0.0749,0.1867]},{"slug":"whipped-soap","title":"Whipped Soap","family":"cosmetic","round":36,"note":"보이지 않는 별 깍지가 휘핑 바디 솝을 한 송이씩 짜는데, 한 바퀴가 앞 바퀴에 반쯤 얹히며 뾰족하게 솟아요. 쟁반이 두 칸 네 줄로 차면 긁개가 거품을 말아 아래로 밀어 내요. K3 은 깍지의 별 꼭짓점 수라서 굵은 골 두세 줄이 가는 골 네다섯 줄로 바뀌고, K1 을 누르면 쟁반을 바로 밀어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-whipped-soap","type":"code","name":"whipped-soap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ridges=5..10, Swirl=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ridges","min":5,"max":10},{"name":"Swirl","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.0309,"detail":0.0537,"edges":0.3642,"complexity":1.1069,"coverage":0.9764,"colour":0.1274,"drift":0.0699},"knobResponse":[0.1534,0.0635,0.0442,0.1089]},{"slug":"whitney-graustein","title":"Whitney-Graustein","family":"topology","round":69,"note":"접선 방향을 무지개빛으로 두른 닫힌 곡선이 멈추지 않고 모양을 바꾸며 감은 수대로 칸을 칠하고, Turns 를 돌리면 작은 고리가 뾰족점으로 조여 사라지거나 뾰족점에서 고리가 태어나며 위 다이얼의 회전수가 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-whitney-graustein","type":"code","name":"whitney-graustein","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Turns=-2..3, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":-2,"max":3},{"name":"Wobble","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2309,"detail":0.0449,"edges":1,"complexity":0.1622,"coverage":0.4121,"colour":0.1865,"drift":0.0946},"knobResponse":[0.084,0.0914,0.1103,0.0535]},{"slug":"wigner-cat","title":"Wigner Cat","family":"wave","round":59,"note":"켜 매질을 지나는 결맞은 빛의 위그너 함수가 위상 평면에서 돌며 2, 3, 4덩이 고양이 상태로 갈라졌다 반대쪽 한 덩이로 모여요. 양수는 장밋빛, 음수는 하늘색이라 덩이 사이 간섭 무늬가 두 색으로 번갈아 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wigner-cat","type":"code","name":"wigner-cat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Decoherence=0..1, Amplitude=2..3.2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Decoherence","min":0,"max":1},{"name":"Amplitude","min":2,"max":3.2}],"start":[0,2,0,2],"measures":{"motion":0.2173,"detail":0.0208,"edges":0.1215,"complexity":0.9875,"coverage":0.2578,"colour":0.1028,"drift":0.0519},"knobResponse":[0.0455,0.0544,0.1018,0.0382]},{"slug":"wilkinson-polynomial","title":"Wilkinson's Polynomial","family":"algo","round":66,"note":"(x − 1)…(x − 20) 의 근 스무 개가 세로 실수축에 구슬로 서고, x¹⁹ 계수를 2⁻²³ 너머까지 건드리면 위쪽 열 개가 둘씩 만나 옆으로 날아가며 분홍 활을 남겨요. 계수를 살짝 흔든 다항식들의 근이 둘레에 반짝이는 성운을 이뤄요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wilkinson-polynomial","type":"code","name":"wilkinson-polynomial","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phase=0..1, Cloud=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phase","min":0,"max":1},{"name":"Cloud","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4256,"detail":0.1031,"edges":0.3715,"complexity":2.203,"coverage":0.2825,"colour":0.1357,"drift":0.0676},"knobResponse":[0.0449,0.0948,0.0734,0.0897]},{"slug":"wireworld","title":"Wireworld","family":"automata","round":16,"note":"구리선 회로를 전자가 파란 머리와 주황 꼬리로 달려요. 둘레 12, 18, 24, 30칸 클록 넷의 신호가 다이오드와 지연선을 지나 XOR 과 OR 게이트에서 만나고, 아래 램프 셋이 그 답을 깜박여요. K1 을 누르면 네 줄에 전자 여섯 개씩이 박자를 맞춰 들어가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-wireworld","type":"code","name":"wireworld","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..3, Speed=0..4, Pulses=1..3, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":3},{"name":"Speed","min":0,"max":4},{"name":"Pulses","min":1,"max":3},{"name":"Glow","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2605,"detail":0.0895,"edges":0.7694,"complexity":0.461,"coverage":0.3111,"colour":0.2355,"drift":0.0855},"knobResponse":[0.0911,0.0637,0.0514,0.0736]},{"slug":"witch-moon","title":"Witch Moon","family":"halloween","round":42,"note":"보랏빛 밤하늘 위쪽에 주황 보름달이 크게 떠 있고, 가장자리가 달빛에 은빛으로 빛나는 구름이 그 앞을 흘러가요. 아래에서는 앙상한 나뭇가지가 흔들리고, 빗자루를 탄 마녀가 초록 불티를 흘리며 3.7초에 달 한가운데를 지나가요. K4 를 올리면 마녀가 넷까지 V 자로 날아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-witch-moon","type":"code","name":"witch-moon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Flights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Clouds","min":0,"max":1},{"name":"Flights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1513,"detail":0.0426,"edges":0.2622,"complexity":0.7664,"coverage":0.7549,"colour":0.2827,"drift":0.0541},"knobResponse":[0.0817,0.0492,0.0566,0.0225]},{"slug":"wongoji","title":"Wongoji","family":"type","round":64,"note":"윤동주의 「서시」를 펜이 세로 원고지에 한 획씩 써요. 한글은 패턴이 자모에서 조합한 9×11 글꼴이고, 칸은 위에서 아래로, 줄은 오른쪽에서 왼쪽으로 차서 한 장이 차면 쪽이 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wongoji","type":"code","name":"wongoji","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Brush=0..1, Hand=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Brush","min":0,"max":1},{"name":"Hand","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3254,"detail":0.1342,"edges":0.9882,"complexity":0.1178,"coverage":0.2372,"colour":0.1805,"drift":0.0963},"knobResponse":[0.7702,0.03,0.0493,0.0454]},{"slug":"woodpecker","title":"Woodpecker","family":"bird","round":21,"note":"새벽 숲의 자작나무 줄기가 128줄을 다 쓰고, 오색딱따구리가 뻣뻣한 꽁지로 버티며 껑충껑충 오르다 멈춰 머리가 흐려지도록 두드려 부스러기를 튀기고 구멍을 내요. 꼭대기에 닿으면 물결치듯 날아 밑동으로 내려가 다시 오르고, K1 을 누르면 다음 걸음 뒤에 바로 두드려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-woodpecker","type":"code","name":"woodpecker","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tree=0..2, Speed=0.2..3, Birds=1..4, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tree","min":0,"max":2},{"name":"Speed","min":0.2,"max":3},{"name":"Birds","min":1,"max":4},{"name":"Light","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.092,"detail":0.0823,"edges":0.3471,"complexity":2.5826,"coverage":0.9376,"colour":0.1398,"drift":0.0454},"knobResponse":[0.1005,0.0437,0.0473,0.1346]},{"slug":"word-bokeh","title":"Word Bokeh","family":"type","round":78,"note":"낱말 꼴로 뚫은 조리개 너머의 빛 스물하나가 초점에서 벗어난 만큼 그 낱말로 부풀고, 초점면 뒤의 빛은 바로, 앞의 빛은 뒤집혀 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-word-bokeh","type":"code","name":"word-bokeh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Stop=1.4..2.8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":1},{"name":"Stop","min":1.4,"max":2.8}],"start":[0,2,0,1.4],"measures":{"motion":0.4117,"detail":0.1019,"edges":0.8295,"complexity":0.4245,"coverage":0.2344,"colour":0.3641,"drift":0.3684},"knobResponse":[0.2826,0.2726,0.225,0.2398]},{"slug":"word-ladder","title":"Word Ladder","family":"type","round":63,"note":"루이스 캐럴의 Doublets 사다리가 HEAD 에서 TAIL 까지 128줄을 내려가요. 가로대마다 한 글자만 획을 따라 흘러 바뀌고, 바뀐 자리가 흰빛으로 켜져 사다리를 따라 지그재그로 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-word-ladder","type":"code","name":"word-ladder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ladder=0..11, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ladder","min":0,"max":11},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1293,"detail":0.0767,"edges":0.7991,"complexity":0.4368,"coverage":0.2688,"colour":0.1738,"drift":0.1227},"knobResponse":[0.0327,0.0584,0.0765,0.1131]},{"slug":"word-search","title":"Word Search","family":"type","round":82,"note":"10×16 칸 대문자 격자에 숨은 타이포 낱말 열둘을 흰 커서가 칸마다 여덟 방향으로 더듬어 찾고, 찾은 낱말마다 제 색 캡슐이 둘러져 남다가 다 찾으면 격자가 흩어지고 새 판이 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-word-search","type":"code","name":"word-search","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Puzzle=0..5, Fill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Puzzle","min":0,"max":5},{"name":"Fill","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0396,"detail":0.2078,"edges":0.9832,"complexity":0.159,"coverage":0.3271,"colour":0.1389,"drift":0.0359},"knobResponse":[0.0508,0.1244,0.1387,0.0828]},{"slug":"wythoff-nim","title":"Wythoff Nim","family":"algo","round":28,"note":"위토프 게임의 스프라그-그런디 값 표를 모서리로 세웠어요. 지는 자리(값 0)는 황금비 두 줄을 따라 금빛이고, 값 0, 1, 2 가 차례로 쓸고 지나가며 저마다의 두 줄에서 번쩍였다 표로 가라앉아요. 누르면 흰 말이 떨어져 이기는 수로 모서리까지 게임을 해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-wythoff-nim","type":"code","name":"wythoff-nim","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zoom=1..4, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zoom","min":1,"max":4},{"name":"Glow","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0944,"detail":0.0878,"edges":0.5187,"complexity":1.051,"coverage":0.875,"colour":0.3599,"drift":0.0676},"knobResponse":[0.2558,0.0431,0.2303,0.1714]},{"slug":"yard-sale","title":"Yard-Sale Model","family":"data","round":62,"note":"공정한 동전으로 거래하는 64명의 재산이 위의 로렌츠 곡선을 대각선에서 처지게 하고, 정렬한 막대를 한 사람에게 몰아요. 맨 아래의 지니 계수는 1 을 향해 오르다가 K4 로 세금을 올리면 그 아래에서 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-yard-sale","type":"code","name":"yard-sale","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fraction=0.2..0.6, Tax=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fraction","min":0.2,"max":0.6},{"name":"Tax","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.0729,"detail":0.0329,"edges":0.637,"complexity":0.1293,"coverage":0.3962,"colour":0.2042,"drift":0.071},"knobResponse":[0.0929,0.0456,0.0669,0.0505]},{"slug":"ybc-7289","title":"YBC 7289","family":"type","round":81,"note":"등불 아래 점토판 YBC 7289 의 정사각형과 쐐기 숫자가 서고, 아래 점토에 1;30 에서 시작한 평균 셈이 한 줄씩 눌려 써지며 √2 와 맞는 자리가 청록으로 켜져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ybc-7289","type":"code","name":"ybc-7289","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Start=0..5, Places=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Start","min":0,"max":5},{"name":"Places","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0273,"detail":0.0548,"edges":0.5828,"complexity":0.6551,"coverage":0.9775,"colour":0.1714,"drift":0.0231},"knobResponse":[0.1016,0.0468,0.044,0.0315]},{"slug":"zagier-windmill","title":"Zagier's Windmills","family":"number","round":57,"note":"소수 p 가 p 칸짜리 풍차로 서요. 가운데 정사각형 둘레에 직사각형 날개 넷이 돌아가며 붙고, 자기에의 사상은 바깥선을 그대로 둔 채 가운데 정사각형을 새로 잘라 내고, 날개 바꾸기는 날개마다 4분의 1 바퀴 돌려 눕혀요. 두 사상을 번갈아 밟은 걸음은 날개가 정사각형인 풍차에서 멈추고, 그 풍차가 넓이를 더하면 p 인 두 정사각형으로 미끄러져 모이며, 아래 로그 눈금의 (y, z) 평면에는 p 의 풍차가 모두 제 쌍곡선 위의 점으로 찍히고 걸어온 지그재그 길이 남아요. K3 은 13부터 113까지 순환을 여는 소수이고, K4 는 풍차를 1~2.5배로 키워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zagier-windmill","type":"code","name":"zagier-windmill","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Prime=1..13, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Prime","min":1,"max":13},{"name":"Zoom","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1077,"detail":0.0489,"edges":0.6146,"complexity":0.37,"coverage":0.3927,"colour":0.1564,"drift":0.1221},"knobResponse":[0.0825,0.0913,0.109,0.1131]},{"slug":"zeldovich-pancakes","title":"Zeldovich Pancakes","family":"space","round":40,"note":"입자 3만 2768개가 젤도비치 근사로 움직여, 고른 안개에서 얇은 팬케이크가 켜지고 벽과 실과 매듭으로 된 우주 거대 구조가 돼요. 벽에 삼켜진 물질은 장밋빛이라 첫 팬케이크가 D = 1/max λ1 에서 켜지는 것이 보이고, K4 를 올리면 만난 흐름이 붙지 않고 지나가 매듭이 마름모로 부풀어요. K1 을 누르면 새 무작위 퍼텐셜이 바로 스며 들어요.","why":"빛나는 그물이 좋은데 아주 느리고 점점 흐려져요(움직임 0.05).","block":1,"ramped":false,"layer":{"id":"layer-zeldovich-pancakes","type":"code","name":"zeldovich-pancakes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=1.8..3.4, Cross=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":1.8,"max":3.4},{"name":"Cross","min":0,"max":1}],"start":[0,2,1.8,0.06],"measures":{"motion":0.054,"detail":0.0516,"edges":0.1927,"complexity":1.591,"coverage":0.7338,"colour":0.1524,"drift":0.1057},"knobResponse":[0.115,0.0501,0.0952,0.0369]},{"slug":"zen-garden","title":"Zen Garden","family":"line","round":18,"note":"곧장 내려다본 마른 돌 정원이에요. 갈퀴 자국이 이끼 두른 돌 둘레에서 고리로 휘고, 갈퀴가 15줄 띠씩 줄을 다시 그으며 떨어진 단풍잎을 거둬 가요. K1 을 돌리면 아침 해가 저녁 해로 옮겨 가며 돌 그림자와 고리의 밝은 쪽이 따라 돌아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-zen-garden","type":"code","name":"zen-garden","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Stones=3..5, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stones","min":3,"max":5},{"name":"Wind","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0392,"detail":0.2481,"edges":0.4637,"complexity":1.6255,"coverage":0.96,"colour":0.1203,"drift":0.0759},"knobResponse":[0.1756,0.245,0.2327,0.2481]},{"slug":"zermelo-navigation","title":"Zermelo Navigation","family":"line","round":66,"note":"바닥 항구에서 0.5초마다 배가 지금까지 닿을 수 있는 곳의 앞선이 떠나, 소용돌이나 제트 물살에 휘고 접히며 패널 끝까지 올라가요. 가장 빠른 길 여섯 줄에 흰 점이 실려 가고, 물이 배보다 빨리 들어오는 가장자리에는 끝내 닿지 못하는 그림자가 빗금으로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zermelo-navigation","type":"code","name":"zermelo-navigation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Current=0..2.5, Shape=0..1, Harbour=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Current","min":0,"max":2.5},{"name":"Shape","min":0,"max":1},{"name":"Harbour","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.4524,"detail":0.1348,"edges":0.6115,"complexity":1.5311,"coverage":0.5705,"colour":0.2766,"drift":0.059},"knobResponse":[0.1395,0.1397,0.1485,0.1091]},{"slug":"zeta-loops","title":"Zeta Loops","family":"line","round":29,"note":"리만 제타 함수를 임계선 위에서 t 를 올리며 그려요. 실수축이 패널 위로 서 있고, 밝은 머리가 고리를 돌다가 영점마다 원점을 정확히 지나며 원점에서 고리가 퍼져요. K3 으로 임계선에서 벗어나면 고리가 원점을 비껴가고, K1 을 누르면 머리가 다음 영점까지 달려가요.","why":"선 하나가 어두운 판에 작아요(채움 0.17).","block":1,"ramped":false,"layer":{"id":"layer-zeta-loops","type":"code","name":"zeta-loops","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sigma=-0.25..0.25, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sigma","min":-0.25,"max":0.25},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1356,"detail":0.0457,"edges":0.4182,"complexity":0.8175,"coverage":0.1691,"colour":0.1955,"drift":0.0901},"knobResponse":[0.0373,0.0539,0.0648,0.0438]},{"slug":"zombie-shamble","title":"Zombie Shamble","family":"halloween","round":51,"note":"지평선 너머 독한 초록 빛을 등진 좀비 떼가 안개 낀 시골길을 비틀대며 다가오고, 가장 가까운 것은 패널을 채운 뒤 안개 속으로 부서져요. K3 은 좀비 수, K4 는 안개의 높이와 짙기이고, 단추를 누르면 모든 고개가 들려 초록 눈으로 우리를 봐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zombie-shamble","type":"code","name":"zombie-shamble","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Horde=5..18, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Horde","min":5,"max":18},{"name":"Fog","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.2236,"detail":0.1201,"edges":0.0317,"complexity":2.0049,"coverage":0.9416,"colour":0.1449,"drift":0.077},"knobResponse":[0.15,0.0416,0.0584,0.0897]},{"slug":"zonal-jets","title":"Zonal Jets","family":"wave","round":52,"note":"북쪽으로 갈수록 코리올리 힘이 커지는 판에서 잔 소용돌이를 흔들면 에너지가 큰 규모로 올라가다 막혀, 동쪽으로 흐르는 붉은 띠와 서쪽으로 흐르는 푸른 띠가 패널 위아래로 줄지어 서요. 흐름선의 굽이와 띠 사이 소용돌이는 물이 흐르는 쪽을 거슬러 서쪽으로 미끄러져요. K3 은 띠의 수를 정하는 β, K4 는 휘젓는 세기이고, K1 을 누르면 새로 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zonal-jets","type":"code","name":"zonal-jets","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beta=-1..1, Stir=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beta","min":-1,"max":1},{"name":"Stir","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6984,"detail":0.1034,"edges":0.3215,"complexity":2.5641,"coverage":1,"colour":0.5239,"drift":0.091},"knobResponse":[0.4219,0.2215,0.3123,0.148]}],"families":{"algo":{"label":"알고리즘","color":"#e0c060"},"automata":{"label":"셀룰러 오토마타","color":"#9be15d"},"bird":{"label":"새","color":"#778800"},"body":{"label":"몸","color":"#bb5566"},"celestial":{"label":"천체","color":"#ffffaa"},"cells":{"label":"보로노이·셀","color":"#5fd0d0"},"chemistry":{"label":"화학·실험","color":"#00bb00"},"circuit":{"label":"전자 회로","color":"#2e7d32"},"city":{"label":"도시","color":"#22ff00"},"construction":{"label":"공사·건설","color":"#ffee00"},"cosmetic":{"label":"화장품 팝업","color":"#f2c6c2"},"data":{"label":"데이터 그림","color":"#7fe08a"},"fair":{"label":"놀이공원","color":"#ffffff"},"farm":{"label":"농사·밭","color":"#449911"},"film":{"label":"필름·영화","color":"#ff0000"},"flight":{"label":"비행","color":"#9944ee"},"fractal":{"label":"프랙탈","color":"#a3a0ff"},"fungi":{"label":"버섯·균사","color":"#00ff88"},"geometry":{"label":"기하·대칭","color":"#c77dff"},"glass":{"label":"유리","color":"#b0002a"},"glitch":{"label":"글리치","color":"#b0b8c8"},"growth":{"label":"자라남","color":"#d4c094"},"halloween":{"label":"할로윈","color":"#7f00ff"},"insect":{"label":"곤충","color":"#b4e61e"},"kitchen":{"label":"부엌","color":"#ff5500"},"light":{"label":"빛","color":"#7ef0d0"},"line":{"label":"선·궤적","color":"#ff7a45"},"machine":{"label":"기계·톱니","color":"#4a2cff"},"mammal":{"label":"짐승","color":"#998844"},"microbe":{"label":"미생물","color":"#aa00aa"},"mineral":{"label":"광물·결정","color":"#886688"},"music":{"label":"음악·악기","color":"#a0705a"},"noise":{"label":"노이즈·흐름","color":"#5ec8ff"},"number":{"label":"수론","color":"#00aaff"},"ocean":{"label":"바다","color":"#1f7fb8"},"paper":{"label":"종이","color":"#996600"},"particle":{"label":"입자","color":"#ffb02e"},"physics":{"label":"물리·스프링","color":"#ff9db0"},"pixel":{"label":"픽셀 아트","color":"#ffd166"},"polar":{"label":"얼음·극지","color":"#00ffff"},"pottery":{"label":"도자기","color":"#b05030"},"print":{"label":"망점·인쇄","color":"#f0a0e0"},"rail":{"label":"철도","color":"#00bb66"},"rhythm":{"label":"리듬·펄스","color":"#ff4d4d"},"sim":{"label":"시뮬레이션","color":"#3fe0a8"},"space":{"label":"공간·원근","color":"#e8e05a"},"sport":{"label":"운동·경기","color":"#337777"},"stage":{"label":"무대·공연","color":"#ff0066"},"textile":{"label":"직물·짜임","color":"#e04ad8"},"time":{"label":"시계·시간","color":"#ff8f5a"},"topology":{"label":"위상·매듭","color":"#80ff40"},"toy":{"label":"장난감","color":"#dd11ff"},"type":{"label":"글자","color":"#ff5fa2"},"volcano":{"label":"화산","color":"#bb2200"},"wave":{"label":"물결·간섭","color":"#4f7dff"},"weather":{"label":"날씨·자연","color":"#8fc0ff"}},"shelf":{"date":"2026-10-25","about":"1–39판 298개를 창작자의 기본 프리셋과 같은 잣대로 재서 여섯 묶음으로 나눴어요. 프리셋은 화면이 단순하고(복잡도 가운데값 0.22) 쉬지 않고 움직이는데(움직임 0.66), 15판부터 나온 250개는 복잡도 1.3–1.6, 움직임 0.21 이에요. 나눈 뒤에 들어온 40판 열 개도 같은 잣대로 보고 넣었어요.","groups":[{"key":"new","label":"아직 안 추린 것","why":"추린 뒤에 들어온 패턴이에요. 아직 어느 묶음에도 넣지 않았어요.","open":true,"patterns":["ferrow","tamsel","alphabet-lineage","cantor-scalogram","crofton-cell","exclusion-process","fork-hologram","lensed-page","letter-retracts","noordzij-cube","phasor-noise","word-search","baudot-tape","beading-letters","cornsweet-letters","dehn-twist","head-wave","malfatti-circles","modular-hyperbola","permutation-poem","pollards-rho","ybc-7289","coupling-from-the-past","doyle-spiral","kinematogram","linotype","mamikon-theorem","menger-slices","napier-bones","plucked-letters","ruled-hyperboloid","wheel-cypher","beam-letters","ekg-sequence","huygens-clocks","lempel-ziv","mobius-type","mushroom-billiard","neon-spreading","quantum-walk","ramsey-fringes","semaphore","chain-fountain","floating-letters","fox-colorings","franklin-involution","galileos-frets","quipu","square-word","teletext","three-disk-scattering","word-bokeh","brazil-nut","cardinal-vowels","fifteen-puzzle","gaussian-zeros","hopfield-letters","ishihara-plate","rabi-chevron","simulated-annealing","sitnikov-problem","v-cut-letters","anagram","beatty-rhythm","benford-law","cistercian-numerals","frieze-letters","hegselmann-krause","kanizsa-letters","levy-dust","order-k-voronoi","string-art","coded-aperture","euler-strokes","fractran","kruskal-count","letter-mobile","lights-out","mesostic","miura-ori","prandtl-membrane","steiner-tree","autostereogram","brick-factory","eye-chart","flag-hoist","lambda-diagrams","promotion","rational-tangles","reed-solomon","tally-count","trajan-helix","abracadabra","airy-beam","damask","durer-alphabet","ehrenfest-urn","maya-numerals","multiple-master","steiner-deltoid","topologists-sine-curve","voss-dice","autogram","biliteral-cipher","clothesline","coxeter-frieze","hydra-game","lattice-reduction","optical-kerning","ruppert-refinement","schlieren-texture","spray-stencil","benton-pantograph","book-from-the-sky","catoptric-anamorphosis","lorem-ipsum","mastermind","platycosms","apollonius-problem","sator-square","tensegrity","twindragon","eight-principles-of-yong","frenkel-kontorova","granular-leidenfrost","hellschreiber","hexachordal-theorem","ink-traps","laguerre-cells","multiplicative-chaos","photon-disk","quousque-tandem","aharonov-bohm","boustrophedon","calculator-words","caustic-letters","langford-pairs","letter-melt","nine-fold-seal","penney-game","steiner-symmetrization","whitney-graustein","composing-stick","delaunay-flips","fibonacci-word","huffman-tree","josephus","ogham","palimpsest","parallel-transport","rose-criterion","structure-ascii","artin-braids","blinking-vortex","braille-relief","distance-field","dupin-cyclide","hanging-line","radon-transform","shannon-approximations","silencio","walsh-functions","barrier-grid","etaoin-shrdlu","golomb-ruler","gridfonts","hodograph","shapley-folkman","subpixel","syllable-odometer","wilkinson-polynomial","zermelo-navigation","anamorphosis","foam-coarsening","hunminjeongeum","inversions","jacobi-geodesics","klein-sails","long-division","mcmullen-carpet","mouse-tale","sedimenting-cloud","ammann-beenker","broad-nib","counterforms","hill-regions","indian-rope-trick","kibble-zurek-ions","letter-sand","polynomial-amoeba","rivers-of-white","wongoji","excursion-sets","izhikevich-network","jamo-assembly","kaprekar-routine","maxwell-fish-eye","moffatt-eddies","simpson-paradox","trip-let","type-mosaic","word-ladder","abrikosov-lattice","balanced-rhythms","berggren-tree","busy-beaver","feynman-checkerboard","heesch-tiles","riemann-function","veech-octagon","void-and-cluster","yard-sale","art-gallery","binary-lens","canard-explosion","crackling-noise","greenhill-column","holditch-ring","monge-transport","paul-trap","taylor-unmixing","thomson-kink","cornu-spiral","eulers-officers","giant-component","hough-transform","jordan-curve","penrose-diagram","phase-spiral","randu-planes","richardson-dividers","rutherford-shadow","clebsch-surface","granular-demon","hawkes-process","kohonen-map","laser-speckle","quadratic-reciprocity","seam-carving","seifert-surface","voderberg-tiling","wigner-cat","beckett-gray","hanging-chain","hard-squares","hexagrammum-mysticum","kp-web","loop-soup","mirror-curves","print-gallery","rayleigh-taylor","tukey-depth","bicycle-tracks","galperin-billiard","medial-axis","ostwald-ripening","pentagon-tilings","sinai-walk","solenoid","stokes-drift","terrell-rotation","zagier-windmill","andrews-curves","bloch-oscillations","dead-leaves","elliptic-law","erdos-discrepancy","golomb-trominoes","multiplicative-cascade","random-organization","tree-peano-curve","twist-writhe","buffon-noodle","burrows-wheeler","hex-theorem","imaginary-geometry","question-mark","tissot-indicatrix","toussaint-wilczek","universal-cover","vortex-sheet","vuza-canon","arcsine-law","nodal-domains","pearcey-cusp","smale-horseshoe","stable-marriage","stit-tessellation","stormer-trap","strange-eigenmode","ulam-sequence","weaire-phelan","barycentric-subdivision","belt-trick","catenoid-helicoid","costas-array","elastica","four-vertex","gaussian-periods","leapfrogging-vortices","max-flow-min-cut","squared-rectangle","anscombes-quartet","banshee","creaking-door","de-bruijn-sequence","force-chains","gaussian-free-field","lost-head","pumpkin-drop","specimen-shelf","zonal-jets","bat-form","calabi-yau","grimoire","hat-monotile","jack-in-the-box","persistence-barcode","phantom-jam","sato-tate","tower-stair","zombie-shamble","bak-sneppen","diffusion-front","in-the-flash","inverse-cascade","motility-clusters","murmuration","old-well","paper-lantern-ghost","risset-rhythm","skull-swap","curlicue","durer-unfolding","gargoyle","kempe-chains","music-box","party-lights","pit-pendulum","square-peg","tennis-racket","werewolf","barn-owl","bone-pile","chebyshev-bias","double-gyre","flashing-ratchet","fractal-percolation","grim-reaper","headless-rider","mobius-energy","trick-or-treat","conways-soldiers","koebe-packing","lonely-runner","oloid","pumpkin-carving","pumpkin-vine","specimen-jar","swarmalators","talking-board","web-tremor","belfry","brillouin-zones","ghost-ship","glass-patterns","howling-wolf","lantern-procession","lorentz-gas","reeb-graph","stochastic-resonance","vampire-coffin","candy-corn","corn-maze","fogged-mirror","hadwiger-nelson","ising-interface","mummy","plancherel-growth","poltergeist","polya-orchard","rotor-router","ballistic-annihilation","black-cat","bulgarian-solitaire","crystal-ball","ham-sandwich","haunted-swing","kac-ring","lace-phantom","peregrine-soliton","slime-drip","bone-jig","grave-hand","hitomezashi","kaleidocycle","leaf-devil","mobius-loxodrome","orb-weaver","runge-phenomenon","scarecrow-crows","tutte-embedding","bat-emergence","candle-vigil","fput-recurrence","graveyard-fog","haunted-manor","knights-tour","morley-triangle","peaucellier-linkage","pivot-walk","witch-moon","cauldron","eyes-in-the-dark","hinged-dissection","jack-o-lantern","polytope-slices","poncelet-porism","sheet-ghosts","siteswap","spider-drop","square-wheels"]},{"key":"pick","label":"먼저 볼 후보","why":"프리셋이 서는 자리에 서는 것이에요. 큰 모양 몇 개가 쉬지 않고 움직이고, 글자나 사물이 없어서 한두 걸음 떨어져도 무엇이 움직이는지 보여요. 패널에 먼저 올려 볼 것들이에요.","open":true,"patterns":["marbling","constant-width","voronoi","pentomino-cover","moire-rings","kuramoto-sivashinsky","plait","domain-warp","heawood-torus","perron-tree","figure-eight-orbit","kdv-solitons","bokeh"]},{"key":"near","label":"하나가 모자란 추상","why":"추상이고 패널에서 읽히지만 하나가 모자라요. 거의 안 움직이거나, 패널을 꽉 채우거나, 데모에서 자주 본 것이에요. 칸마다 모자란 것을 적었어요.","open":false,"patterns":["bauhaus","fire","tunnel","aurora","reaction-diffusion","op-stripes","meander","jelly","ripple-tank","kaleidoscope","penrose","rauzy-fractal","hyperbolic-band","pinwheel-tiling","gibbs-phenomenon","zeta-loops","karman-street","dyson-gas","steiner-chain","lava-lamp","indras-pearls","j-invariant","bath-fizz","soap-film","crackle-polish","powder-burst","gold-leaf","glitter-fall","borromean-rings","flock","euclid-pulse","sparks","jacobs-ladder","searchlights","star-trails","curve-shortening","hofstadter-butterfly","ford-circles","gosset-polytope","cloud-chamber","kelvin-wake","hopf-fibration","lava-lake","prince-ruperts-cube","brownian-frontier","zeldovich-pancakes","continuum-random-tree","hydrogen-orbital","lotion-stitch","perfume-tears"]},{"key":"scene","label":"사물·장면 그림","why":"사물이나 장소를 그린 픽셀 그림이에요. 무엇인지는 바로 보이지만 한 번 보고 나면 더 볼 것이 없어요. 64칸 폭에 물건을 그리느라 결이 잘고, 바탕까지 칠해서 패널을 꽉 채워요. 15–27판이 거의 다 여기 있고, 프리셋 48개에는 이런 그림이 없어요.","open":false,"patterns":["center-pivot","climbing-wall","fluoroscope","funicular","glassblower","horse-in-motion","mitosis","sled-dogs","dark-field","geyser","iceberg","implosion","lichtenberg","noborigama","origami","pole-vault","rice-planting","shadow-play","eruption","excavation","ferris-wheel","kintsugi","marionette","rice-terraces","skydiver","snow-monkeys","breath","emergence","flying-trapeze","pipe-organ","potters-wheel","shoot-em-up","thermal","tower-crane","waggle-dance","axon","bait-ball","elephant-toothpaste","final-approach","giraffe","hanging-scroll","high-dive","proscenium","sequins","skein","bowling-lane","circulation","flame-test","flipdot","galilean-moons","liftoff","night-flight","pin-art","senbazuru","weaver","bread-mould","chemical-garden","fiddlehead","lap-pool","nixie","pancakes","pop-up-book","slinky","woodpecker","agate","change-ringing","chromatography","high-striker","kettle","kingfisher","moth-lamp","veiled-lady","cyanotype","dripstone","dust-motes","foxfire","helter-skelter","needlepoint","paternoster","popcorn","rabbit-ears","smalti","bismuth","drop-tower","longcase-clock","peg-light","pint","server-rack","stained-glass","turntables","typewriter","zen-garden","ant-farm","brushstrokes","circuit-board","crossroads","marble-run","one-bit","shoreline","train-window","abyss","domino-run","drying-mud","fireflies","harp","lunation","neon-alley","analemma","cam-wave","datamosh","incense","ivy","metro-map","player-piano","waterfall","balloon-box","tetromino-well","gear-train","jacquard","aquarium","climber","cloth","day-cycle","flip-clock","hourglass","rainstorm","sprout"]},{"key":"diagram","label":"수학·데이터 도해","why":"수학이나 데이터를 설명하는 그림이에요. 숫자와 눈금, 한 LED 굵기의 선이 많아서 패널에서는 뭉개지고, 무엇을 보는지 알려면 설명을 읽어야 해요.","open":false,"patterns":["borsuk-ulam","brachistochrone","explicit-formula","isospectral-drums","kingman-coalescent","anderson-localization","bernoulli-convolutions","infinity-series","polya-urn","sperner-lemma","antoine-necklace","fortune-sweep","johnson-mehl","catastrophe-machine","elliptic-chords","schwarz-lantern","joukowsky-airfoil","kolakoski","renyi-parking","lakes-of-wada","moving-sofa","thomson-problem","bertrand-paradox","dandelin-spheres","goldbach-comet","penrose-room","sorting-network","arnold-tongues","gilbreath-table","hammersley-lines","invasion-percolation","boys-surface","gaussian-moat","littlewood-roots","outer-billiards","three-gaps","seven-shuffles","hairy-ball","loewner-trace","look-and-say","stadium-billiard","wythoff-nim","population-pyramid","pendulum-wave","contour","galton","sorting"]},{"key":"cosmetic","label":"옅은 화장품 질감","why":"화장품 팝업용 질감이에요. 연분홍과 흰 바탕이 패널을 다 채워서(채움 가운데값 1.00) LED 에서는 밝은 판 하나로 보여요. 광택이나 눌린 자국 같은 표면 결은 64×128 에서 남지 않아요. 진한 색이 굵은 여섯은 위 묶음에 있어요.","open":false,"patterns":["jelly-layers","blotting-paper","serum-drip","couette-shimmer","milk-ring","photochromic","serum-fingers","embossed-glow","hair-oil","taffy-cream","blooming-gel","lotion-ribbon","shimmer-oil","whipped-soap","gilded-cream","sheet-mask","toner-pad","cat-eye","hair-gloss","mood-tint","velvet-nap","cleansing-balm","essence-drop","peel-off","chrome-powder","clay-mask","cushion-mesh","sugar-scrub","foam-lather","lip-gloss","setting-mist","sponge-blend","bi-phase","pearl-sheen","satin-fold","swatch-row","cream-swirl","loose-powder","serum-gel"]},{"key":"grain","label":"잔 결과 흔한 데모","why":"LED 한두 알 크기의 결이 화면을 덮거나, 생성 미술에서 너무 자주 본 것이에요. 가까이서는 촘촘하지만 한 걸음만 물러나도 잡음처럼 보여요.","open":false,"patterns":["defect-turbulence","lamellar-cream","hexatic-phase","chimera-state","kari-culik","scheidegger-rivers","talbot-carpet","cat-map","ballistic-deposition","percolation","aztec-diamond","sandpile","millefiori","sunglint","frost","spectrogram","chladni","guilloche","wireworld","warp","dragon","halftone","mandelbrot","maze","big-type","glyph-rain","harmonograph","life","pulse-bars","rule-scroll","test-card","truchet"]}]}}</script>
-<script type="application/json" id="code-0">{"ferrow":"// ===== Patternflow pattern =====\n// Title:   Ferrow\n// Family:  pixel\n// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, his visor shutters blink, the tabard swings, and now and then the case light runs along the steel.\n// Author:  patternflow-lab\n// Date:    2026-11-01\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 86\n// Round:   86\n// ===============================\n// @matrix 64x128\n// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1\n//\n// Knob 1: Gel. The colour of the rim light down his left edges and of the bounce it throws into the shadows beside it: sky blue at 0, magenta from 0.25, green from 0.5, warm white from 0.75.\n// Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.\n// Knob 3: Detail. Below 0.5 the whole figure; from 0.5 his head, chest and sword hand at exactly twice the size, the way a box shows a close-up.\n// Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.\n// Buttons: K1 tap sends the case light along him; K2 tap makes the sword's point wink.\n\nconst W = 64, H = 128;\n// Each part is a grid, one character per LED and \".\" where it is clear, drawn\n// in ORDER. Materials run light to dark: enamel a b c d, gunmetal g h i j,\n// tabard p q r s, blade steel m n o. C I R O are the shadow-side bounce next to\n// the rim light z, which the gels recolour. f u v are the hot amber of the\n// fuller and the eyes, x the dark of the visor, w the specular. U V X N are the stand.\nconst PARTS = {\n  base: { x: 6, y: 111, rows: [\n    \".............NNNNNNNNNNNNNNNNNNNNNNNNNN.............\",\n    \"......NNNNNNNUUUUUUUUUUUUUUUUUUUUUUUUUUNNNNNNN......\",\n    \"...NNNUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUNNN...\",\n    \".NNUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUNN.\",\n    \"NUUUXXXXUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUN\",\n    \"XNNUXXXXXXXXXXXXXXXXXXXXXXXXXXUUUUUUUUUUUUUUUUUUUNNV\",\n    \"XXXNNNUUUUUUUUUUUUUUUUUUUUXXXXXXXXXXXXXXXXXXXXXXXVVV\",\n    \"XXXXXXNNNNNNNUUUUUUUUUUUUUUUUUUUUUUUUUUNNNNNNNVVVVVV\",\n    \"XXXXXXXVVVVVVNNNNNNNNNNNNNNNNNNNNNNNNNNVVVVVVVVVVVVV\",\n    \"XXXXXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\",\n    \"XXXXXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\",\n    \"..XXXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV..\",\n    \".......VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV.......\",\n    \".................VVVVVVVVVVVVVVVVVV.................\",\n  ] },\n  pack: { x: 8, y: 27, rows: [\n    \"..........z....\",\n    \"......zxxxh....\",\n    \"......zIIhhh...\",\n    \"....z.zIIhhh...\",\n    \"zxxxg.zIIhhh...\",\n    \"zIIhggjjihihh..\",\n    \"zIIhggjjihihh..\",\n    \"zIIhgg.zIIhihh.\",\n    \"zIIhgg.zIIhihh.\",\n    \".zIIgggjjihhgg.\",\n    \".zIIhggjjiihhgg\",\n    \".ziihggjjiihhgg\",\n    \".jjihhgg.......\",\n    \".jjihhgg.......\",\n    \".j.............\",\n  ] },\n  blade: { x: 7, y: 2, rows: [\n    \"z..........................................\",\n    \"zOOn.......................................\",\n    \".zOOoo.....................................\",\n    \".zOOnoooo..................................\",\n    \".zOOnnoooooo...............................\",\n    \"..zOOnnoooooo..............................\",\n    \"..zOOnnnoooooo.............................\",\n    \"...zOOnnnoooooo............................\",\n    \"...zmnnnnnoooooo...........................\",\n    \"...zmmnnnnnoooooo..........................\",\n    \"....zmmnnnnnoooooo.........................\",\n    \"....zmmmnnnnnoooooo........................\",\n    \".....zmmmnnnnnoooooo.......................\",\n    \"......zmmmnnonnoooooo......................\",\n    \".......zmmmoonnnoooooo.....................\",\n    \"........zmmnonnnnoooooo....................\",\n    \".........zmnmnnnuuoooooo...................\",\n    \"..........zOmmnnuuuoooooo..................\",\n    \"...........zmmmnnuuuoooooo.................\",\n    \"............mmmmnnuufoooooo................\",\n    \".............mmmmnnfffooooooo..............\",\n    \"..............mmmmnnfffooooooo.............\",\n    \"...............mmmmnnfffooooooo............\",\n    \"................mmmmnnfffooooooo...........\",\n    \".................mmmmnnfffooooooo..........\",\n    \"..................mmmmnnfffooooooo.........\",\n    \"...................mmmmnnfffooooooo........\",\n    \"...................mmmmmnnfffooooooo.......\",\n    \"....................mmmmmnnfffooooooo......\",\n    \".....................mmmmmnnfffooooooo.....\",\n    \"......................mmmmmnnfffooooooo....\",\n    \".......................mmmmmnnfffooooooo...\",\n    \"........................mmmmmnnfffooooooo..\",\n    \".........................mmmmmnnfffooooooo.\",\n    \"..........................mmmmmnnfnnooooooo\",\n    \"...........................mmmmmnnnnnooooo.\",\n    \"............................mmnnnnnnnnooo..\",\n    \".............................mmmmnnnnnno...\",\n    \"..............................mmmmmnnnn....\",\n    \"...............................mmmmmnn.....\",\n    \"................................mmmmm......\",\n    \".................................mmm.......\",\n    \"..................................m........\",\n  ] },\n  legfar: { x: 35, y: 75, rows: [\n    \"..jhg.................\",\n    \".jihhg................\",\n    \"jjihhgg...............\",\n    \"jjihhgg...............\",\n    \"jjiihhgg..............\",\n    \".jjihhgh..............\",\n    \".jjiihhhg.............\",\n    \".jjiihhgg.............\",\n    \"..jjiihhgg............\",\n    \"..jjiihhgg............\",\n    \"...jjihhgg...z........\",\n    \"...jcccaaaaaaa........\",\n    \"....cccaaaaaaaa.......\",\n    \"....cccbbbbbbbb.......\",\n    \"....cccbbbbbbbbb......\",\n    \".....ccbbbbbbbbb......\",\n    \".....ccbbbbbbbb.......\",\n    \".....ccbbbbbbb........\",\n    \".....zcbbbbbbb........\",\n    \"....zCCcccabbbb.......\",\n    \"....zCCcccabbbb.......\",\n    \"....zCCcccabbbb.......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbb.......\",\n    \"......zCCcabbbb.......\",\n    \"......zCCcabbbb.......\",\n    \"......zCCdccccc.......\",\n    \".......zCCccccg.......\",\n    \".......zCCccccg.......\",\n    \".......zIIihhgg.......\",\n    \"..zbbbbbbbbaaaaaaaa...\",\n    \"..zCCccccccbbbbbbbbb..\",\n    \"..zCCccccccbbbbbbbbb..\",\n    \"..cccccccccbbbbbbbbbb.\",\n    \"..cccccccccbbbbbbbbbbb\",\n    \".ccccccccccbbbbbbbbbbb\",\n    \".ccccccccccbbbbbbbbbbb\",\n    \".iiiiiiiiiihhhhhhhhhhh\",\n    \".jjjjjjjjjjjjjjjjjjjjj\",\n  ] },\n  legnear: { x: 14, y: 75, rows: [\n    \"............jhg.....\",\n    \"...........jihhg....\",\n    \"..........jjihhgg...\",\n    \"..........jjihhgg...\",\n    \"..........jjihhgg...\",\n    \"..........jjihhgg...\",\n    \"..........jjjiiih...\",\n    \"..........zIIiihh...\",\n    \"..........zIhhhhh...\",\n    \".........zIIhhgh....\",\n    \".........zIIhhghh...\",\n    \".......zCCaaaaawb...\",\n    \".......zCCaaaaabb...\",\n    \".......zCCbbbbbccb..\",\n    \".......zCCbbbbbccb..\",\n    \"........zCbbbbbcbb..\",\n    \"........zCbbbbbcb...\",\n    \"........zCbbbbcc....\",\n    \"........zCbbbbcc....\",\n    \"......zCCcccabccbb..\",\n    \"......zCCcccabccbb..\",\n    \"......zCCcccabcbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbb...\",\n    \".......zCCccabbbb...\",\n    \".......zCCccabbbb...\",\n    \".......zCCddccccc...\",\n    \"........zCCdcccc....\",\n    \"........zCCdcccc....\",\n    \"........zIIihhgg....\",\n    \".zbbbbbbbaaaaaaaaa..\",\n    \".zCCcccccbbbbbbbbb..\",\n    \".zCCcccccbbbbbbbbbb.\",\n    \".zCCcccccbbbbbbbbbb.\",\n    \"cccccccccbbbbbbbbbbb\",\n    \"cccccccccbbbbbbbbbbb\",\n    \"iiiiiiiiihhhhhhhhhhh\",\n    \"jjjjjjjjjjjjjjjjjjjj\",\n  ] },\n  spine: { x: 28, y: 59, rows: [\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"zIIjiiihh\",\n    \"zIIjjjjjj\",\n    \"zIIihhhgg\",\n    \"zIIihhhgg\",\n    \"zIIjjjjjj\",\n    \"zIIihhhgg\",\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n  ] },\n  hips: { x: 18, y: 67, rows: [\n    \"..zIIgggggggggggggggggggggg....\",\n    \"..zIIiiiiihhhhhhhhhhggggggg....\",\n    \".jjjiiiiihhhhhhhhhhhhggggggg...\",\n    \"dddbbbbbbbbbbbhcccaaaaaaaaaa...\",\n    \"dddbbbbbbbbbbb.cccaaaaaaaaaa...\",\n    \"dddcccccccccdd.cccbbbbbbbbbbb..\",\n    \"dddcccccccccdd.cccbbbbbbbbbbb..\",\n    \"dddcccccccccdd.cccbbbbbbbbbbb..\",\n    \"dddcccccccccd...ccbbbbbbbbbbbb.\",\n    \"zCCcccccccccd...ccbbbbbbbbbbbb.\",\n    \"zCCcccccccccd...ccbbbbbbbbbbbbb\",\n    \".zCCccccccccd...ccbbbbbbbbbbbbb\",\n    \"...zCCddddddd...ccccccccccc....\",\n    \"....zCCdddddd...cccccccc.......\",\n    \".....z.........................\",\n  ] },\n  tabard: { x: 31, y: 70, rows: [\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".zRqrqqppp.\",\n    \".zRqrqqppp.\",\n    \".zRqrqqppp.\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"zRRqrqqpppp\",\n  ] },\n  tabtip: { x: 30, y: 85, rows: [\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \"rrrrqrrqqpppp\",\n    \"rrrrqrrqqpppp\",\n    \"rrrrqrrqqpppp\",\n    \"rr..zRRqq..pp\",\n    \"r....zRq....p\",\n    \"......z......\",\n  ] },\n  torso: { x: 17, y: 39, rows: [\n    \"........jjjiihhhhhgghhh.........\",\n    \".bbbbbbbjjjiihhhhhgggggbbaaaaa..\",\n    \".bbbbbbbbjjjjiiiiiggggabbbawaa..\",\n    \".bbbbbbbbjjjjiiiiiggggabbbaaaaa.\",\n    \".dddccccccccccciabbbbbbbccbbbbb.\",\n    \"ddddccccccccccciabbbbbbbcbbbbbb.\",\n    \"ddddccjjjjjjccciabbbbbbbbbbbbbbb\",\n    \"ddddccccccccccciabbbbbbbbbbcbbbb\",\n    \"ddddccccccccccciabbbbbcccbccbbb.\",\n    \".dddccjjjjjjccciabbbbccccbccdbb.\",\n    \".dddccccccccccciabbbbbbcbbccdb..\",\n    \".ddddddddddddddicccccccccccddd..\",\n    \"..dddddddddddddicccccccccccdd...\",\n    \"..zCCddddddddddiccccccccccccd...\",\n    \".....zIIiiiiihhhhhhhgggggg......\",\n    \".....zIIjjjjjjjjjjjjjjjjjj......\",\n    \".....zIIiiiiihhhhhhhgggggg......\",\n    \"......zIIiiiiihhhhhhggggg.......\",\n    \"......zIIjjjjjjjjjjjjjjjj.......\",\n    \"......zIIiiiiihhhhhhggggg.......\",\n    \".......zIIiiiihhhhhggggg........\",\n    \".......zIIiiiihhhhhggggg........\",\n  ] },\n  neck: { x: 28, y: 35, rows: [\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"zIijiiihh\",\n    \"jjjjiiihh\",\n    \"jjiihhhgg\",\n  ] },\n  paulfar: { x: 42, y: 36, rows: [\n    \".....a..........\",\n    \"...aaaaaaaaa....\",\n    \"..caaaaaaawaa...\",\n    \"cccaaaaaaaaaaa..\",\n    \"cccbbbbbbbbbbb..\",\n    \".ccbbbbbbbbbbbb.\",\n    \".ccbbbbbbbbbbbbb\",\n    \"..cbbbbbbbbbbbbb\",\n    \"..cbbbbbbbbbbbbb\",\n    \"...ccbbbbbbbbbbb\",\n    \"...ccbbbbbbbbbb.\",\n    \"...ccbbbbbbbbbb.\",\n    \"....jiiiiiiiiii.\",\n    \"....jjiiiiiiiii.\",\n    \".....jjjjj......\",\n    \".....z..........\",\n  ] },\n  armfar: { x: 48, y: 47, rows: [\n    \"..cccbb....\",\n    \".dcccbbb...\",\n    \"ddcccbbba..\",\n    \"ddcccbbba..\",\n    \"dddddcbba..\",\n    \"zCCddccbaa.\",\n    \"zCCcdccbaa.\",\n    \"zCCccccbaa.\",\n    \".zCCccccaa.\",\n    \".zCCccccaa.\",\n    \".zCCcbccaa.\",\n    \"..zCCbbbaa.\",\n    \"..zCCbbbaaa\",\n    \"..zCCbbbaaa\",\n    \"..zCCbbbaaa\",\n    \"...zCbbbaa.\",\n    \"....zbbba..\",\n    \".....zbb...\",\n  ] },\n  paulnear: { x: 4, y: 36, rows: [\n    \".........aaaaaaabb.....\",\n    \"........baaaaaaawbb....\",\n    \"......bbbaaaaaaaabbb...\",\n    \".....zbbbaaaaaaaaaaaa..\",\n    \"...zCbbbbaaaaaaaaaaaaa.\",\n    \"...zCbbbbbbbbbbbbbbbbbb\",\n    \"..zCCccccccccccbbbbbbbb\",\n    \"..zCCccccccccccbbbbbbbb\",\n    \".zCCdccccccccccbbbbbbbb\",\n    \".zCCdccccccccccbbbbbbb.\",\n    \"zCCddddddddddddddddddd.\",\n    \"zCCddccccccccccbbbbbbb.\",\n    \"zCCddccccccccccbbbbbbb.\",\n    \".zIIiiiiiiiiihhhhhhhhh.\",\n    \".zIIiiiiiiiiiiiiiii....\",\n    \".zIIjjjjjjjjjjjjj......\",\n    \"......jjjjjjjj.........\",\n    \"...........j...........\",\n  ] },\n  armnear: { x: 4, y: 49, rows: [\n    \".......hhh.........\",\n    \"......jihhg........\",\n    \".....jjihhgg.......\",\n    \".....zIIhhgg.......\",\n    \".....zIIhhgg.......\",\n    \"....zIIhhgg........\",\n    \"....zIIhhgg........\",\n    \"...zIIhhgg.........\",\n    \"...zIIhhgg.........\",\n    \"...zIIhhgg.........\",\n    \"..zIIhhgg..........\",\n    \"..zIIhhgg..........\",\n    \".zIaaagg...........\",\n    \".zaaaaaa...........\",\n    \".zbaaaaaa..........\",\n    \"zCbbaaaaaa.........\",\n    \"zCCbbbaaaaa........\",\n    \"zCCcbbbaaaaa.......\",\n    \".zCCccbbaaaaa......\",\n    \".zCCcccbbaaaaa.....\",\n    \"..zCCcccbbbaajjhhg.\",\n    \"....zCCccbbbjijhhgg\",\n    \".....zCCcccbjijhhgg\",\n    \"......zCCcccjijhhgg\",\n    \".......zCCccjijhhgg\",\n    \".........zCCjijhhgg\",\n    \"..........zCIjjhhg.\",\n    \"............z......\",\n  ] },\n  head: { x: 19, y: 6, rows: [\n    \".......z.....................\",\n    \"........zCCca................\",\n    \".........zCCaaaa.............\",\n    \"..........zCbbbbbbb..........\",\n    \"............zbbbbbbb.........\",\n    \"....bbbbaaaaaabbbbbbbw.......\",\n    \"...bbbbbaaaaaaaaaaaaaaaaa....\",\n    \"..bbbbbbaaaaaaaaaaaaaaaaaa...\",\n    \".bbbbbbbaaaaaaaaaaaaaaaaaa...\",\n    \".bbbbbbbbbbbbbbbbbbbbbbbbbb..\",\n    \".ddccccccccccbbbbbbbbbbbbbbb.\",\n    \".ddccccccccccbbbbbbbbbbbbbbb.\",\n    \"dddccccccccaaabbbbbbbbbbbaaa.\",\n    \"dddccccccccbbbaaabbbbbaaabbdd\",\n    \"dddccccccccdddbbbaaaaabbbddxx\",\n    \"zCCcchcccccxxxdddbbbbbdddxxxx\",\n    \"zCCiihhhcccxxxxxxdddddxxxxxxx\",\n    \"zCCiihghcccxxxuuwxxxxxxxuwxxx\",\n    \"zCCiihghcccxxxufffuxxxuffuxxx\",\n    \"zCIiihhhhccxxxxufuuxxxuuuxxxx\",\n    \".zCIiiiicccxxxxxxxxxxxxxxxxxx\",\n    \".zCIiiiicccxxxxxxxxxxxxxxxxxx\",\n    \".zCIiiiicccccbbbbbbbbbbbbbbbb\",\n    \".ddccicccccccbbbbbbbbbbbbbbb.\",\n    \".ddccccccccccbbbbbbdbbdbbdbb.\",\n    \".ddccccccccccbbbbbbdbbdbbdbb.\",\n    \"..dccccccccccbbbbbbdbbdbbdb..\",\n    \"..dccccccccccbbbbbbdbbdbbdb..\",\n    \"...ccccccccccbbbbbbbbbbbbb...\",\n    \"...ddddddddddcccccccccccc....\",\n    \"....zCCddddddccccccccccc.....\",\n    \"........zCCddcccccccccc......\",\n    \"...........d.................\",\n  ] },\n  hilt: { x: 40, y: 35, rows: [\n    \"...........z.......\",\n    \"..........gg.......\",\n    \".........gghh......\",\n    \"........gghh.......\",\n    \".......gghh........\",\n    \"......gghh.........\",\n    \".....gghh..........\",\n    \"....gghh...........\",\n    \"...gghh............\",\n    \"..gghh..sr.........\",\n    \".gghh...ssr........\",\n    \"gghh.....ssr.......\",\n    \"..h.......ssr......\",\n    \"...........ssr.....\",\n    \"............sss....\",\n    \".............sss...\",\n    \"..............sshh.\",\n    \"...............hhgw\",\n    \"...............hhgg\",\n    \"...............hhhh\",\n    \"................hh.\",\n  ] },\n  fistfar: { x: 47, y: 42, rows: [\n    \"..ihhg..\",\n    \".jihhgg.\",\n    \"jjihhhwg\",\n    \"jjihhhgg\",\n    \"jjihhhgg\",\n    \"jjjjhhgg\",\n    \"jjihhhgg\",\n    \".jihhgg.\",\n    \"..ihhh..\",\n  ] },\n};\nconst ORDER = [\"base\", \"pack\", \"blade\", \"legfar\", \"legnear\", \"spine\", \"hips\", \"tabard\", \"tabtip\", \"torso\", \"neck\", \"paulfar\", \"armfar\", \"paulnear\", \"armnear\", \"head\", \"hilt\", \"fistfar\"];\n// Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways.\nconst GROUP = {\"base\": 0, \"pack\": 1, \"blade\": 1, \"legfar\": 0, \"legnear\": 0, \"spine\": 0, \"hips\": 0, \"tabard\": 0, \"tabtip\": 3, \"torso\": 1, \"neck\": 1, \"paulfar\": 1, \"armfar\": 1, \"paulnear\": 1, \"armnear\": 1, \"head\": 2, \"hilt\": 1, \"fistfar\": 1};\n// The visor shutters half shut and shut, laid over the head.\nconst LIDS = {\n  half: { x: 33, y: 23, rows: [\n    \"xxxx.....\",\n    \"xxxx....xxx\",\n  ] },\n  shut: { x: 33, y: 23, rows: [\n    \"xxxx.......\",\n    \"xxxx....xxx\",\n    \"vvvv....vvv\",\n    \"xxxx....xxx\",\n  ] },\n};\nconst PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075 };\n// Knob 4: the editions, each a hand-picked repaint of some materials.\nconst EDITIONS = [\n  {  },\n  { a: 0xb4b9cf, b: 0x7f86a6, c: 0x575c82, d: 0x3b3d66, C: 0x575c82, p: 0x6fc7b5, q: 0x3b9590, r: 0x226670, s: 0x1b4560, R: 0x226670 },\n  { a: 0xffe7a3, b: 0xe1b45e, c: 0xb07a6a, d: 0x6e4a6e, C: 0xb07a6a, g: 0xe8eef6, h: 0xa7b3c8, i: 0x6c7896, j: 0x3d4568, I: 0x6c7896 },\n  { a: 0xe6e2df, b: 0xc4c0be, c: 0x999593, d: 0x706c6a, C: 0x999593, g: 0xbbb7b4, h: 0x8a8684, i: 0x625f5d, j: 0x464341, I: 0x625f5d, p: 0xb0acaa, q: 0x8a8684, r: 0x625f5d, s: 0x464341, R: 0x625f5d, m: 0xede7e3, n: 0xbbb5b1, o: 0x86807d, O: 0x86807d, f: 0xede7e3, u: 0xbbb5b1, v: 0x86807d, x: 0x403d3b },\n];\n// Knob 2: the stands.\nconst STANDS = [\n  { U: 0xb2815f, V: 0x8d5541, X: 0x67332f, N: 0xe0c29b },\n  { U: 0xd5d7dd, V: 0xa9abb2, X: 0x797c84, N: 0xe1e2e8 },\n  {  },\n  { U: 0x00658c, V: 0x00bcd9, X: 0x0084a8, N: 0xc1f8f9 },\n];\n// Knob 1: the gels on the rim light, with the shadow-side bounce they tint.\nconst GELS = [\n  {  },\n  { z: 0xfb6acd, C: 0xa77096, I: 0x6a3f86, R: 0x8a3577, O: 0x8a5ba6 },\n  { z: 0x81ef7e, C: 0x88a184, I: 0x2f6b6a, R: 0x4f6a5a, O: 0x5b9a8a },\n  { z: 0xfff1d0, C: 0xbcaa98, I: 0x6a6a8a, R: 0x86506e, O: 0x8f95ae },\n];\n// The wink on the sword's point: x, y and what the LED turns into.\nconst GLINT = [[10, 5, \"w\"], [9, 4, \"w\"], [11, 5, \"w\"]];\n// The case light: what a glossy character turns into while the band passes.\nconst UP = {\"n\": \"m\", \"o\": \"n\", \"O\": \"n\", \"h\": \"g\", \"i\": \"h\", \"I\": \"h\", \"j\": \"i\"};\n\nconst { floor, min, max } = Math;\n// The events run on a fixed loop of exactly eight breaths, so they always meet\n// the breath at the same phase. Blinks come 2 to 3.3 s apart and never while\n// the head is moving; the case light every 6.8 s, taking 2.4 s to cross, at a\n// phase where no breath step meets its edge; the glint on the point every 6 or\n// more. None falls between 1.5 and 2.5 s, where the still is taken.\nconst CYCLE = 27.2;\nconst BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];\nconst SWEEPS = [4.3, 11.1, 17.9, 24.7];\nconst GLINTS = [3.0, 9.6, 15.8, 22.0];\nconst SWEEP_LEN = 2.4;\nconst GLINT_LEN = 0.17;\n// One breath is 3.4 s: the chest rises a pixel, the head follows a quarter\n// second later, and the tabard's hem swings a pixel sideways a beat after\n// that; both ends of each move are held longer than the moves between them.\nconst BREATH = 3.4;\n// The detail cut's top left corner, in figure LEDs.\nconst CUT_X = 16, CUT_Y = 6;\n\nfunction since(list, t, len) {\n  const u = t % CYCLE;\n  for (let i = 0; i \u003c list.length; i++) {\n    const d = u - list[i];\n    if (d >= 0 && d \u003c len) return d;\n  }\n  return -1;\n}\n\nfunction lut(ed, stand, gel) {\n  const t = new Int32Array(128).fill(-1);\n  const put = (p) => {\n    for (const ch in p) t[ch.charCodeAt(0)] = p[ch];\n  };\n  put(PAL);\n  put(EDITIONS[ed]);\n  put(STANDS[stand]);\n  put(GELS[gel]);\n  return t;\n}\n\nfunction blit(buf, part, dx, dy, sweep, band) {\n  const rows = part.rows;\n  for (let j = 0; j \u003c rows.length; j++) {\n    const y = part.y + j + dy;\n    if (y \u003c 0 || y >= H) continue;\n    const r = rows[j];\n    for (let i = 0; i \u003c r.length; i++) {\n      const ch = r.charCodeAt(i);\n      if (ch === 46) continue;\n      const x = part.x + i + dx;\n      if (x \u003c 0 || x >= W) continue;\n      let c = ch;\n      if (sweep) {\n        const s = x + y * 0.5 - band;\n        if (s >= 0 && s \u003c 5) {\n          const up = UP[r[i]];\n          if (up) c = up.charCodeAt(0);\n        }\n      }\n      buf[y * W + x] = c;\n    }\n  }\n}\n\nexport function setup(params) {\n  params.t = 0;\n  params.buf = new Uint8Array(W * H);\n  params.key = -1;\n  params.sweepAt = -10;\n  params.glintAt = -10;\n  params.gel = 0;\n  params.stand = 2;\n  params.zoom = false;\n  params.ed = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.buf) setup(params);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  params.t += min(dt || 0, 0.1);\n  params.gel = min(3, max(0, floor(k[0] * 4)));\n  params.stand = min(3, max(0, floor(k[1])));\n  params.zoom = k[2] >= 0.5;\n  params.ed = min(3, max(0, floor(k[3] * 4)));\n  const b = input.btnPressed;\n  if (b && b[0]) params.sweepAt = params.t;\n  if (b && b[1]) params.glintAt = params.t;\n}\n\nexport function draw(display, params) {\n  const p = params;\n  if (!p.buf) setup(p);\n  const t = p.t;\n  const key = p.ed * 16 + p.stand * 4 + p.gel;\n  if (key !== p.key) {\n    p.key = key;\n    p.lut = lut(p.ed, p.stand, p.gel);\n  }\n  const buf = p.buf;\n  buf.fill(0);\n\n  const u = (((t - 1.5) % BREATH) + BREATH) % BREATH;\n  const dy = [0, u >= 1.1 && u \u003c 2.8 ? -1 : 0, u >= 1.35 && u \u003c 3.05 ? -1 : 0, 0];\n  const dx = [0, 0, 0, u >= 1.45 && u \u003c 3.15 ? -1 : 0];\n\n  let sw = since(SWEEPS, t, SWEEP_LEN);\n  if (t - p.sweepAt \u003c SWEEP_LEN) sw = t - p.sweepAt;\n  const sweep = sw >= 0;\n  const band = -8 + (sw / SWEEP_LEN) * (W + H * 0.5 + 16);\n\n  // The case light passes over the steel above the stand; the legs and the stand keep still.\n  for (let n = 0; n \u003c ORDER.length; n++) {\n    const name = ORDER[n], g = GROUP[name];\n    blit(buf, PARTS[name], dx[g], dy[g], sweep && g !== 0, band);\n  }\n\n  const db = since(BLINKS, t, 0.3);\n  if (db >= 0) blit(buf, db \u003c 0.08 || db >= 0.2 ? LIDS.half : LIDS.shut, 0, dy[2], false, 0);\n\n  let dg = since(GLINTS, t, GLINT_LEN);\n  if (t - p.glintAt \u003c GLINT_LEN) dg = t - p.glintAt;\n  if (dg >= 0) {\n    for (let i = 0; i \u003c GLINT.length; i++) {\n      const g = GLINT[i], at = (g[1] + dy[1]) * W + g[0];\n      if (buf[at]) buf[at] = g[2].charCodeAt(0);\n    }\n  }\n\n  const L = p.lut;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const ch = p.zoom ? buf[(CUT_Y + (y >> 1)) * W + CUT_X + (x >> 1)] : buf[y * W + x];\n      const c = ch ? L[ch] : -1;\n      if (c \u003c 0) display.setPixel(x, y, 0, 0, 0);\n      else display.setPixel(x, y, (c >> 16) & 255, (c >> 8) & 255, c & 255);\n    }\n  }\n}\n","tamsel":"// ===== Patternflow pattern =====\n// Title:   Tamsel\n// Family:  pixel\n// Idea:    A hand-pixelled figure of Tamsel, a fourteen-year-old apprentice lamplighter, standing on a display stand that fills the panel: plum ponytail under a teal cap, long teal work coat, tall plum boots, one hand on her hip and the other on a brass lighting pole taller than she is, its hook hanging a little cage of flame over her head. She breathes, blinks, and now and then the case light runs across the gloss.\n// Author:  patternflow-lab\n// Date:    2026-11-01\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 85\n// Round:   85\n// ===============================\n// @matrix 64x128\n// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1\n//\n// Knob 1: Gel. The colour of the rim light down her left edges and of the bounce it throws into the shadows next to it: sky blue at 0, magenta from 0.25, green from 0.5, amber from 0.75.\n// Knob 2: Stand. What she stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.\n// Knob 3: Detail. Below 0.5 the whole figure; from 0.5 her head and chest at exactly twice the size, the way a box shows a close-up.\n// Knob 4: Edition. The paint: the standard colours below 0.25, the second-player colours from 0.25, a gold and silver limited plating from 0.5, and from 0.75 the unpainted grey prototype.\n// Buttons: K1 tap sends the case light across her; K2 tap makes the brass on her hook wink.\n\nconst W = 64, H = 128;\n// Each part is a grid, one character per LED and \".\" where it is clear, drawn\n// in ORDER. Materials run light to dark: skin a b c d, hair and boots h i j k,\n// coat and cap p q r s, brass m n o. U V X N M are the stand, z the rim light,\n// w the specular, f g the flame, e the whites of the eyes, x the pupils.\nconst PARTS = {\n  base: { x: 6, y: 110, rows: [\n    \"....................NNNNNNNNNNN....................\",\n    \".........NNNNNNNNNNNUUUUUUUUUUNNNNNNNNNNNN.........\",\n    \".....NNNNUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUNNwN.....\",\n    \"..NNNUUUUUUUUUUXXXXXXXXXXUUUUUUUUUUUUUUUUUUUUUNNN..\",\n    \".NUUUUUUUUUUUXXXXXXXXXXXXXXUUUUUUUUUUUUUUUUUUUUUUN.\",\n    \"VNUUUUUUUUUUUUXXXXXXXXXXXXUUUUUUUUUXXXXXXXXXXUUXXNV\",\n    \"VVMMMUUUUUUUUUUUUUUUUUUUUUUUUUUUUUXXXXXXXXXXXXMMMVV\",\n    \"VVVVVMMMMUUUUUUUUUUUUUUUUUUUUUUUUUUXXXXXXXMMMMVVVVV\",\n    \"VVVVVVVVVMMMMMMMMMMMUUUUUUUUUUUMMMMMMMMMMMVVVVVVwVV\",\n    \"VVVVVVVVVVVVVVVVVVVVMMMMMMMMMMMVVVVVVVVVVVVVVVVVVVV\",\n    \"XXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXX\",\n    \"..XXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXXX..\",\n    \".....XXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXXXX.....\",\n    \".........XXXXXXXXXXXVVVVVVVVVVVXXXXXXXXXXX.........\",\n    \"....................XXXXXXXXXXX....................\",\n  ] },\n  staff: { x: 54, y: 3, rows: [\n    \"...nnnw...\",\n    \"..nn..mmm.\",\n    \"onm.....mm\",\n    \"onm.....nm\",\n    \"onm.....nm\",\n    \"onm.....om\",\n    \"onm.....o.\",\n    \"onm.....o.\",\n    \"onm.....o.\",\n    \"onm...onno\",\n    \"onm...offo\",\n    \"onm...offo\",\n    \"onm...ogfo\",\n    \"onm...oggo\",\n    \"onm...onno\",\n    \"onm....oo.\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"oom.......\",\n    \"ooo.......\",\n  ] },\n  hairback: { x: 3, y: 8, rows: [\n    \".............zJ................\",\n    \"...........zJJjjj..............\",\n    \"..........zJJjjjjj.............\",\n    \".........zJJjjjjjjjjj..........\",\n    \"........zJJjjjjiiijjjjjj.......\",\n    \"........zJJjjjjiiijjjjjjjj.....\",\n    \".......zJJjjjjiiiijjjjjjjjj....\",\n    \".......zJJjjjjiiijjjjjjjjjjj...\",\n    \"......zJJjjjjiiiijjjjjjjjjjjj..\",\n    \"......zJJjjjiiiijjjjjjjjjjjjj..\",\n    \".....zJJjjjhhiijjjjjjjjjjjjjjj.\",\n    \"....zKKjjjjhhiijjjjjjjjjjjjjjj.\",\n    \"....zKKkjjhhiijjjjjjjjjjjjjjjj.\",\n    \"...zKKkkjhhiiijjjjjjjjjjjjjjjj.\",\n    \"...zKKkjjhiiijjjjjjjjjjjjjjjjjj\",\n    \"..zKKkkjjiiijjjjjjjjjjjjjjjjjjj\",\n    \"..zKKkkjjiiijjjjjjjjjjjjjjjjjjj\",\n    \".zKKkkjjiiikjjjjjjjjjjjjjjjjjjj\",\n    \".zKKkkjhiiikkjjjjjjjjjjjjjjjjj.\",\n    \".zKKkjjhiikkkkjjjjjjjjjjjjjjjj.\",\n    \".zKKkjhhiikkkkkjjjjjjjjjjjjjjj.\",\n    \".zKKkjhii.zKKkkkjjjjjjjjjjjjjj.\",\n    \".zKKjjhii..zKKkkjjjjjjjjjjjjj..\",\n    \"zKKkjjii...zKKkkkjjjjjjjjjjjj..\",\n    \"zKKkjjii....zKKkkkjjjjjjjjjj...\",\n    \"zKKjjji......zKKkkkjjjjjjjj....\",\n    \"zKKjjii.......zKKkkkjjjjjj.....\",\n    \"zKKjji..........zKKkkjjj.......\",\n    \"zKJjji.............zk..........\",\n    \"zKJjj..........................\",\n    \"zJJjj..........................\",\n    \".jjj...........................\",\n  ] },\n  tailtip: { x: 3, y: 34, rows: [\n    \".jjj..\",\n    \"zKjjj.\",\n    \"zKKji.\",\n    \"zKKji.\",\n    \"zKKji.\",\n    \"zKKji.\",\n    \".zKJi.\",\n    \".zKJi.\",\n    \"..zJi.\",\n    \"..zJi.\",\n    \"..zJJ.\",\n    \"...zJ.\",\n    \"....zk\",\n    \".....z\",\n  ] },\n  armfar: { x: 38, y: 44, rows: [\n    \".qqqp...............\",\n    \"qqqqpp..............\",\n    \"qqqqqpp.............\",\n    \"qqqqqqpp............\",\n    \"qqqqqqqp............\",\n    \".qrrqqqqq......bbbb.\",\n    \".qrrrqqqqp..ssbbaaaa\",\n    \"..rrrqqqqpssssbbaaaa\",\n    \"...rrrqqqqsssbcccaab\",\n    \"....rrrqqqsssbbcbbbb\",\n    \"....rrrqqqssssccbbbb\",\n    \".....rrrqqqsssccccc.\",\n    \"......rrrrrrrr......\",\n    \".......rrrrr........\",\n    \"........rrr.........\",\n  ] },\n  legs: { x: 23, y: 80, rows: [\n    \"..jjjjj.....jjjjj................\",\n    \".jjjjjjj...jjjjjjj...............\",\n    \"jjjjjjjjj..jjjjjjj...............\",\n    \"jjjjjjjjj.jjjjjjjjj..............\",\n    \"jjjjjjjjj.jjjjjjjjj..............\",\n    \"kkkjjjjjj..kkjjjjjj..............\",\n    \"kkkjjjjjj..kkjjjjjjj.............\",\n    \"zKKjjjjii..kkjjjjjij.............\",\n    \"zKKjjjjii...zKJjjjii.............\",\n    \"zKKjjjjii...zKJjjjiij............\",\n    \"ziiiiiiii....ziiiiiij............\",\n    \"zKKkkkkkk....zKKkkkkij...........\",\n    \"zKKjjjhiw....zKKjjjiij...........\",\n    \"zKKjjjhii.....zKJjjjii...........\",\n    \"zKKjjjhii.....zKJjjjiii..........\",\n    \"zKKjjjhii.....zKJjjjjii..........\",\n    \"zKKjjjhii......zKJjjjii..........\",\n    \"zKKjjjhii......zKJjjjjii.........\",\n    \"zKKjjjhii.......zKJjjjii.........\",\n    \".zKJjjhi........zKJjjhii.........\",\n    \".zKJjjhi........zKJjjhhwi........\",\n    \".zKJjjhi.........zKJjjhii........\",\n    \".zKJjjhi.........zKJjjhii........\",\n    \".zKJjjji..........zJJjhhii.......\",\n    \".zKJjjji..........zKJjjhii.......\",\n    \".zKJjjji..........zKJjjhii.......\",\n    \".zKJjjji...........zJJjjji.......\",\n    \".zKJjjji...........zKJjjjii......\",\n    \".zKJjjji...........zKJjjjji......\",\n    \".zKJjjjj............zJJjjji......\",\n    \".zJJjjjjjii.........zJJjjjjj.....\",\n    \"..jjjjjjiiiii........jjjjjj......\",\n    \".jjjjjjjjiiijj.......jjjjjjjiii..\",\n    \".jjjjjjjjjjjjj.......jjjjjjiiiiij\",\n    \"..kkkkjjjkkkk........jjjjjjjjiijj\",\n    \"......kkk............kkjjjjjjjjkk\",\n    \".......................kkkkkkkk..\",\n  ] },\n  skirt: { x: 13, y: 63, rows: [\n    \".........rrrrrqqqqqqqqqqqqqqqq......\",\n    \".........rrrrrqqqqqqqqqqqqqqqq......\",\n    \".........rrrrrqqqqqqqqqqqqqqqq......\",\n    \"........rrrrrrqqqqqqqqqqqqqppp......\",\n    \"........rrrrrrqqqqqqqqqqqqqpppq.....\",\n    \".......rrrrrrrqqqqqqqqqqqqqpppq.....\",\n    \".......rrrrrrrqqqqqqqqqqqqqpppq.....\",\n    \".......zRRrrrrqqqqrqqqqqqqqpppp.....\",\n    \"......zRRrrrrrqqqqrqqqqqqqqppppq....\",\n    \"......zRRrrrrrqqqqrqqqqqqqqqpppq....\",\n    \".....zRRrrrrrrqqqqrqqqqqqqqqpppp....\",\n    \".....zRRrrrrrrqqqqrqqqqqqqqqpppp....\",\n    \".....zRRrrrrrrqqqqrrqqqqqqqqppppq...\",\n    \"....zRRrrrrrrrqqqqrrqqqqqqqqppppq...\",\n    \"....zRRrrrrrrrqqqqrrqqqqqqqqqpppp...\",\n    \"....zRRrrrrrrrqqqqrrqqqqqqqqqpppp...\",\n    \"...zRRrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"...zRRrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"..zRRrrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"..zRRrrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"..zRRrrrrrrrrqqqqqrrqqqqqqqqqqppppp.\",\n    \".zRRrrrrrrrrrqqqqqrrqqqqqqqqqqppppp.\",\n    \".zRRrrrrrrrrrqqqqqrrqqqqqqqqqqppppp.\",\n    \"zTTssssssssssssqqqrrqqqqqqqqqqppppp.\",\n    \"...............ssssssssssssssqpppppp\",\n    \".............................ssqqqqq\",\n  ] },\n  torso: { x: 19, y: 39, rows: [\n    \"..........zQQqq...........\",\n    \"......zQQqqqqqppppp.......\",\n    \".....zRRrqqqpppppppp......\",\n    \"....zRRrrqqqppppppppp.....\",\n    \"....zRRrrqqqqppppppppppp..\",\n    \".....zRRrqqqqqpppppqpppp..\",\n    \".rrrrrrrrqqqqqqqqqqqppppp.\",\n    \".rrrrrrrrqqqqqqqqqqqppppp.\",\n    \".rrrrrqssssssssssssqpppppp\",\n    \"rrrrrrqqqqqqqqqqqrpqpppppp\",\n    \"rrrrrrqqqqqqqqqqqrpqqppppp\",\n    \"rrrrrrrqqqqqqqqqqrpqqppppp\",\n    \"rrrrrrrqqqqqqqqqqrpqqppppp\",\n    \".rrrrrrqqqqqqqqqqrpqqpppp.\",\n    \".rrrrrrqqqqqqqqqqrpqqpppp.\",\n    \".zRRrrrqqqqqqqqqqrpqqpppp.\",\n    \".zRRrrrqqqqqqqqqqrpqqpppp.\",\n    \".zRRrrrqqqqqqqqqqqrpqpppp.\",\n    \"..zRRrrrqqqqqqqqqqrpqpppp.\",\n    \"..zRRrrrqqqqqqqqqqrpqpppp.\",\n    \"..zRRrrrqqqqqqqqqqrpqppp..\",\n    \"..zRRrrrqqqqqqqqqqrpqppp..\",\n    \"..zRRrrrqqqqqqqqqqrpqppp..\",\n    \"...zRRrrqqqqqqqqqqrpqppp..\",\n    \"...rrrrrqqqqqqqqqqqqqppp..\",\n    \"...rrrrrqqqqqqqqqqqqqppp..\",\n    \"...rrrrrqqqqqqqqqqqqqppp..\",\n  ] },\n  belt: { x: 22, y: 63, rows: [\n    \"kkkkkkkkkjjjjnnnjjjjjj\",\n    \"kkkkkkkkkiiiinwoiiiiii\",\n    \".kkkkkkkkkkkknookkkkk.\",\n  ] },\n  armnear: { x: 5, y: 44, rows: [\n    \"...............zQQ..\",\n    \"..............zppqq.\",\n    \"............zppppqqq\",\n    \"...........zppppqqqq\",\n    \"..........zpppqqqqqq\",\n    \"........zppppqqqqqqq\",\n    \".......zpppqqrrqqqq.\",\n    \"......zpppqqrrrqqq..\",\n    \"....zppppqqrrrqqq...\",\n    \"...zpppqqqrrrqq.....\",\n    \"..zpppqqqrrrqq......\",\n    \".zQQqqqqrrrr........\",\n    \"zQQqqqrrrrr.........\",\n    \"zQQqqrrrq...........\",\n    \"zQQqqrrqqq..........\",\n    \".zQQqrqqqqq.........\",\n    \"..zRRqqqqsss........\",\n    \"...zRRqqssqqq.......\",\n    \"....zRRqssqqqs......\",\n    \"......zTTssqssbbb...\",\n    \".......zTTsssbbaaaa.\",\n    \"........zTTsbbbaaaaa\",\n    \".........zTTbbbaaab.\",\n    \"...........zccbbbbb.\",\n    \"............zccccc..\",\n    \"..............ccc...\",\n  ] },\n  neck: { x: 29, y: 35, rows: [\n    \"cccccc\",\n    \"cccccc\",\n    \"dddddd\",\n    \"dddddc\",\n    \"cccccc\",\n    \"cccccc\",\n    \"cccccc\",\n    \"cccccc\",\n  ] },\n  head: { x: 26, y: 16, rows: [\n    \".......bbbbbbb.......\",\n    \".....bbbbbbbbbbb.....\",\n    \"....bbbbbbbbbbbbb....\",\n    \"...bbbbbbbbbbbbbbb...\",\n    \"..cccbbbbccbbbccbcc..\",\n    \".cccccbccbbbbbbbbbbb.\",\n    \".cccccbbbbbbbbbbbbba.\",\n    \"ccccccbbbbbbbbbxxxbaa\",\n    \"ccccccbxxxxbbbxbbbxaa\",\n    \"ccccccxbbbbbbbbbbbbaa\",\n    \"ccccccbxxxxbbbbxxxbaa\",\n    \"ccccccbaxxabbbbxxabaa\",\n    \"cccccccaxxgbbbbxxgaaa\",\n    \"cccccccagggbbbbgggaaa\",\n    \".cccccccggbbbbbbgbaa.\",\n    \".cccccccbbbbbbbbbbaaa\",\n    \"..ccccccbbbbbbbbbbbc.\",\n    \"...ccccccbbbbbbbbbb..\",\n    \"....ccccccbbbbbdbb...\",\n    \".....ccccccbcddbb....\",\n    \".......cccccccccc....\",\n    \".........ccccccc.....\",\n  ] },\n  hairfront: { x: 16, y: 4, rows: [\n    \".........zQQqqqqqqppp..............\",\n    \".....zQQqqqqqqqqppppppppp..........\",\n    \"...zRRqqqqqqqqqpppppppppppp........\",\n    \"..zRRrqqqqqqqqqppppppppppppp.......\",\n    \".rrrrrqqqqqqqqqpppppppppppppp......\",\n    \"rrrrrrqqqqqqqqqqppppppppppppqq.....\",\n    \"rrrrrrrrrqqqqqqqqqqppppppqqqqq.....\",\n    \"rrrrrrrrrrrrrrqqqqqqqqqqqqqqqq.....\",\n    \"rrrrrrrrrrrrrrqqqqqqqqpppppppppppp.\",\n    \"rrrrrrrrrrrrrrqqqqqqqqppppppppppqqq\",\n    \".ssssssssssssskkkkkkkkkkkkkkkkkqqqq\",\n    \"..............kkkkkkkkkkkkkkkkkssss\",\n    \"...............jjjjjjjjjjjjjjjj....\",\n    \"........k......jjjjjjjjjjiiiiii....\",\n    \"........kkjjjii.jjjjjjjjjihhhii....\",\n    \"........kkjjjii.jjjjjjjjjiiiiii....\",\n    \"........kkjjjii..jj..jjj..i..ii....\",\n    \"........kkjjjii.......j...i........\",\n    \"........kkjjjii....................\",\n    \"........kkjjjii....................\",\n    \"........kkjjjii....................\",\n    \".........kjjji.....................\",\n    \".........kjjji.....................\",\n    \".........kjjji.....................\",\n    \".........kkjji.....................\",\n    \".........kkjji.....................\",\n    \".........kkjji.....................\",\n    \".........kkjji.....................\",\n    \"..........kjj......................\",\n    \"..........kjj......................\",\n    \"..........jjj......................\",\n    \"...........jj......................\",\n  ] },\n};\nconst ORDER = [\"base\", \"staff\", \"hairback\", \"tailtip\", \"armfar\", \"legs\", \"skirt\", \"torso\", \"belt\", \"armnear\", \"neck\", \"head\", \"hairfront\"];\n// Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the ponytail's end.\nconst GROUP = {\"base\": 0, \"staff\": 0, \"hairback\": 2, \"tailtip\": 3, \"armfar\": 1, \"legs\": 0, \"skirt\": 0, \"torso\": 1, \"belt\": 0, \"armnear\": 1, \"neck\": 1, \"head\": 2, \"hairfront\": 2};\n// The eyes half shut and shut, laid over the head.\nconst LIDS = {\n  half: { x: 33, y: 26, rows: [\n    \"bbbb....bbb\",\n    \"xxxx....xxx\",\n  ] },\n  shut: { x: 33, y: 26, rows: [\n    \"bbbb....bbb\",\n    \"bbbb....bbb\",\n    \"bbbb....bbb\",\n    \"xxxx....xxx\",\n    \"bbbb....bbb\",\n  ] },\n};\nconst PAL = { a: 0xf9e1d1, b: 0xe9b9a8, c: 0xcb8b86, d: 0xa0606b, h: 0xe3a3c6, i: 0xb267a9, j: 0x764492, k: 0x423276, p: 0x9edfc6, q: 0x50ada2, r: 0x267b80, s: 0x005362, m: 0xf7e8b3, n: 0xd6b075, o: 0x9e7a60, U: 0x5f74a3, V: 0x464c7f, X: 0x3b2f61, f: 0xffefaf, g: 0xfdae3a, w: 0xfffaf0, z: 0x8cccff, e: 0xe2dcec, N: 0xd6b075, M: 0xf7e8b3, x: 0x3b2f61, K: 0x423276, R: 0x267b80, T: 0x005362, J: 0x764492, Q: 0x50ada2 };\n// Knob 4: the editions, each a hand-picked repaint of some materials.\nconst EDITIONS = [\n  {  },\n  { p: 0xfcb6a4, q: 0xdf6f71, r: 0xab4660, s: 0x752d4f, h: 0x90c3d9, i: 0x2e89b8, j: 0x005d97, k: 0x1c3c73, K: 0x1c3c73, R: 0xab4660, T: 0x752d4f, J: 0x005d97, Q: 0xdf6f71 },\n  { p: 0xeae8e0, q: 0xadb7c0, r: 0x77828e, s: 0x4c5564, h: 0xf2e2a9, i: 0xd7b06d, j: 0xaf7c4d, k: 0x7e4d38, a: 0xf8dec6, b: 0xe1b198, c: 0xbc8374, d: 0x8f5a58, K: 0x7e4d38, R: 0x77828e, T: 0x4c5564, J: 0xaf7c4d, Q: 0xadb7c0 },\n  { a: 0xe6e2df, b: 0xc4c0be, c: 0x999593, d: 0x706c6a, h: 0xb9b5b3, i: 0x84807e, j: 0x5c5957, k: 0x403d3b, p: 0xd5d1ce, q: 0xa19d9b, r: 0x726f6d, s: 0x4e4b49, m: 0xede7e3, n: 0xbbb5b1, o: 0x86807d, f: 0xede7e3, g: 0xbbb5b1, e: 0xdbd6d4, x: 0x494644, K: 0x403d3b, R: 0x726f6d, T: 0x4e4b49, J: 0x5c5957, Q: 0xa19d9b },\n];\n// Knob 2: the stands.\nconst STANDS = [\n  { U: 0xb2815f, V: 0x8d5541, X: 0x67332f, N: 0xcea378, M: 0xe0c29b },\n  { U: 0xd5d7dd, V: 0xa9abb2, X: 0x797c84, N: 0xb5b5c0, M: 0xe1e2e8 },\n  {  },\n  { U: 0x00658c, V: 0x00bcd9, X: 0x0084a8, N: 0x7de1ed, M: 0xc1f8f9 },\n];\n// Knob 1: the gels on the rim light, with the shadow-side bounce they tint.\nconst GELS = [\n  {  },\n  { z: 0xfb6acd, K: 0x74266e, R: 0x7b4c89, T: 0x5f376b, J: 0x9f3d88, Q: 0x9f87b9 },\n  { z: 0x81ef7e, K: 0x004d41, R: 0x297554, T: 0x005742, J: 0x006c6f, Q: 0x5ab788 },\n  { z: 0xffbf5d, K: 0x7c343b, R: 0x866139, T: 0x6e3f2a, J: 0xa04657, Q: 0x98a76d },\n];\n// The wink on the hook: x, y and what the LED turns into.\nconst GLINT = [[60, 3, \"w\"], [59, 3, \"w\"], [61, 4, \"w\"]];\n// The case light: what a glossy character turns into while the band passes.\nconst UP = {\"j\": \"i\", \"J\": \"i\", \"i\": \"h\", \"k\": \"j\", \"K\": \"j\", \"n\": \"m\", \"o\": \"n\", \"N\": \"M\"};\n\nconst { floor, min, max } = Math;\n// The events run on a fixed 25 s loop. Blinks come 2.2 to 4.2 s apart, the\n// case light every 7.8 to 9.4 s, taking 2.4 s to cross, the glint on the hook every 6 or more; none\n// falls between 1.5 and 2.5 s, where the still is taken.\nconst CYCLE = 25;\nconst BLINKS = [0.9, 3.4, 6.1, 8.3, 11.9, 14.6, 16.9, 20.4, 23.1];\nconst SWEEPS = [4.6, 12.4, 20.2];\nconst GLINTS = [3.0, 9.6, 15.8, 22.0];\nconst SWEEP_LEN = 2.4;\nconst GLINT_LEN = 0.17;\n// One breath is 3.2 s: the chest rises a pixel, the head follows a quarter\n// second later and the ponytail's end a tenth after that, and both ends of the\n// breath are held longer than the moves between them.\nconst BREATH = 3.2;\n// The detail cut's top left corner, in figure LEDs.\nconst CUT_X = 20, CUT_Y = 3;\n\nfunction since(list, t, len) {\n  const u = t % CYCLE;\n  for (let i = 0; i \u003c list.length; i++) {\n    const d = u - list[i];\n    if (d >= 0 && d \u003c len) return d;\n  }\n  return -1;\n}\n\nfunction lut(ed, stand, gel) {\n  const t = new Int32Array(128).fill(-1);\n  const put = (p) => {\n    for (const ch in p) t[ch.charCodeAt(0)] = p[ch];\n  };\n  put(PAL);\n  put(EDITIONS[ed]);\n  put(STANDS[stand]);\n  put(GELS[gel]);\n  return t;\n}\n\nfunction blit(buf, part, dx, dy, sweep, band) {\n  const rows = part.rows;\n  for (let j = 0; j \u003c rows.length; j++) {\n    const y = part.y + j + dy;\n    if (y \u003c 0 || y >= H) continue;\n    const r = rows[j];\n    for (let i = 0; i \u003c r.length; i++) {\n      const ch = r.charCodeAt(i);\n      if (ch === 46) continue;\n      const x = part.x + i + dx;\n      if (x \u003c 0 || x >= W) continue;\n      let c = ch;\n      if (sweep) {\n        const s = x + y * 0.5 - band;\n        if (s >= 0 && s \u003c 6) {\n          const up = UP[r[i]];\n          if (up) c = up.charCodeAt(0);\n        }\n      }\n      buf[y * W + x] = c;\n    }\n  }\n}\n\nexport function setup(params) {\n  params.t = 0;\n  params.buf = new Uint8Array(W * H);\n  params.key = -1;\n  params.sweepAt = -10;\n  params.glintAt = -10;\n  params.gel = 0;\n  params.stand = 2;\n  params.zoom = false;\n  params.ed = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.buf) setup(params);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  params.t += min(dt || 0, 0.1);\n  params.gel = min(3, max(0, floor(k[0] * 4)));\n  params.stand = min(3, max(0, floor(k[1])));\n  params.zoom = k[2] >= 0.5;\n  params.ed = min(3, max(0, floor(k[3] * 4)));\n  const b = input.btnPressed;\n  if (b && b[0]) params.sweepAt = params.t;\n  if (b && b[1]) params.glintAt = params.t;\n}\n\nexport function draw(display, params) {\n  const p = params;\n  if (!p.buf) setup(p);\n  const t = p.t;\n  const key = p.ed * 16 + p.stand * 4 + p.gel;\n  if (key !== p.key) {\n    p.key = key;\n    p.lut = lut(p.ed, p.stand, p.gel);\n  }\n  const buf = p.buf;\n  buf.fill(0);\n\n  const u = (((t - 1.5) % BREATH) + BREATH) % BREATH;\n  const off = [0, u >= 1.1 && u \u003c 2.7 ? -1 : 0, u >= 1.35 && u \u003c 2.95 ? -1 : 0, u >= 1.45 && u \u003c 3.05 ? -1 : 0];\n\n  let sw = since(SWEEPS, t, SWEEP_LEN);\n  if (t - p.sweepAt \u003c SWEEP_LEN) sw = t - p.sweepAt;\n  const sweep = sw >= 0;\n  const band = -8 + (sw / SWEEP_LEN) * (W + H * 0.5 + 16);\n\n  // The case light passes over the gloss above the stand; the boots and the stand keep still.\n  for (let n = 0; n \u003c ORDER.length; n++) {\n    const name = ORDER[n];\n    blit(buf, PARTS[name], 0, off[GROUP[name]], sweep && name !== \"legs\" && name !== \"base\", band);\n  }\n\n  const db = since(BLINKS, t, 0.3);\n  if (db >= 0) blit(buf, db \u003c 0.08 || db >= 0.2 ? LIDS.half : LIDS.shut, 0, off[2], false, 0);\n\n  let dg = since(GLINTS, t, GLINT_LEN);\n  if (t - p.glintAt \u003c GLINT_LEN) dg = t - p.glintAt;\n  if (dg >= 0) {\n    for (let i = 0; i \u003c GLINT.length; i++) {\n      const g = GLINT[i], at = g[1] * W + g[0];\n      if (buf[at]) buf[at] = g[2].charCodeAt(0);\n    }\n  }\n\n  const L = p.lut;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const ch = p.zoom ? buf[(CUT_Y + (y >> 1)) * W + CUT_X + (x >> 1)] : buf[y * W + x];\n      const c = ch ? L[ch] : -1;\n      if (c \u003c 0) display.setPixel(x, y, 0, 0, 0);\n      else display.setPixel(x, y, (c >> 16) & 255, (c >> 8) & 255, c & 255);\n    }\n  }\n}\n","alphabet-lineage":"// ===== Patternflow pattern =====\n// Title:   Alphabet Lineage\n// Family:  type\n// Idea:    A four letter Latin word stacked down the tall panel starts as Proto-Sinaitic pictures, an ox head, a house, water, a human head, and every letter's strokes bend through Phoenician, written right to left, turn over like a card to face the other way as Greek, and settle as Roman capitals with thick and thin strokes and serifs, the letters one after another so the column can hold four eras at once.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the alphabet's descent from Proto-Sinaitic (Wadi el-Hol and Serabit el-Khadim, c. 1850 BCE; read by Alan Gardiner, The Egyptian origin of the Semitic alphabet, 1916) through Phoenician (c. 1050 BCE) and archaic Greek (c. 750 BCE) to Roman inscriptional capitals (1st century); letter shapes drawn for this pattern, pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Lag=0..1\n//\n// Knob 1: Hue. Turns the four era colours round the wheel together. At 0 the pictographs are gold, Phoenician purple, Greek azure and the Roman capitals warm white.\n// Knob 2: Speed. At 2 a letter holds each era 1.2 to 2.6 s and takes 1.8 s to bend into the next, and a whole history with its 1.4 s rewind takes 13.4 s; every time goes as 2 / Speed.\n// Knob 3: Word. 0 ROMA, 1 AMOR, 2 ARMA, 3 DONA, 4 BONA, 5 MORA, Latin words that between them use all seven letters drawn here: A, B, D, M, N, O and R.\n// Knob 4: Lag. How far each letter runs behind the one above, in eras: 0.06 at the opening, so the word changes almost as one; at 1 the column shows four eras at once, the top letter a Roman capital while the bottom one is still a picture.\n\n// Each letter is a few strokes, and each stroke is a polyline in every era,\n// on a 10 by 10 grid with y down. A stroke is resampled to the same number\n// of points by arc length in every era, so one era's stroke bends into the\n// next point by point. A stroke that is not there in an era has alpha 0 and\n// borrows its shape from the next era that has it.\n//\n// Between two eras a letter may also turn. The ox head lies down on its\n// side as Phoenician aleph and stands up again, upside down, as alpha; the\n// Greek delta lies on its side to round into D. When Greek settled on\n// writing left to right, letters that face a way turned to face the other:\n// Phoenician beth, mem, nun and resh look left, Greek beta, mu, nu and rho\n// look right. So between Phoenician and Greek every letter except the ox\n// head turns over about its upright axis, like a card. The morph bends the\n// stroke toward the next era's shape seen from before the turn, and turns\n// it on the way; at the end of the morph the turn is complete and the\n// stroke is the next era's.\n//\n// The pen is round and a little thinner each era back. The Roman capitals\n// get the shading of a broad edged brush held at 30 degrees, thick where a\n// stroke runs across the edge and thin along it (Edward Catich, The Origin\n// of the Serif, 1968), and short serifs fade in at their feet.\n//\n// Phoenician and archaic Greek shapes and stroke directions were checked\n// against the Unicode reference glyphs in Noto Sans Phoenician and Noto\n// Sans Old Italic; the coordinates are drawn here, not copied.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, abs, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst K = 36;\n\n// Era colours at Hue 0 (h, s), widths of the round pen in grid units.\nconst ERA = [[0.12, 0.7], [0.82, 0.62], [0.56, 0.7], [0.09, 0.16]];\nconst PEN = [0.3, 0.34, 0.37, 0.4];\n// Seconds at Speed 2: hold in each era, the bend between, the rewind.\nconst HOLD = [1.6, 1.2, 1.2, 2.6], BEND = 1.8, BACK = 1.4;\nconst CYCLE = HOLD[0] + HOLD[1] + HOLD[2] + HOLD[3] + 3 * BEND + BACK;\n\nconst WORDS = [\"ROMA\", \"AMOR\", \"ARMA\", \"DONA\", \"BONA\", \"MORA\"];\n\n// Per letter: the turn between eras 0-1, 1-2, 2-3 as [degrees clockwise,\n// mirrored], and the strokes as [alpha per era, shape per era]. A shape is\n// \"x,y x,y ...\"; a closed stroke ends where it starts; \"\" borrows.\nconst LETTERS = {\n  // ʾalp, the ox head, muzzle down -> aleph on its side -> alpha -> A.\n  A: {\n    turn: [[90, 0], [90, 0], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"3,3.2 3.4,6 4.1,8.2 5,9.1 5.9,8.2 6.6,6 7,3.2\",\n        \"7.9,1.3 4.5,3.7 1,6.3 5.4,6.2 9.7,6.1\",\n        \"8.4,9.5 6.7,5 5,0.6 3.3,5 1.6,9.5\",\n        \"9,9.4 7,4.9 5,0.4 3,4.9 1,9.4\",\n      ]],\n      [[1, 1, 1, 1], [\n        \"0.6,0.8 1.4,2.4 2.6,3.3 5,3.7 7.4,3.3 8.6,2.4 9.4,0.8\",\n        \"3.6,0.6 4.8,5 6.1,9.4\",\n        \"7.1,5.6 2.9,6.4\",\n        \"7.2,6.5 2.8,6.5\",\n      ]],\n      [[1, 0, 0, 0], [\"4.1,5 4.3,5.2\", \"\", \"\", \"\"]],\n      [[1, 0, 0, 0], [\"5.9,5 5.7,5.2\", \"\", \"\", \"\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"-0.2,9.4 2.4,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"7.6,9.4 10.2,9.4\"]],\n    ],\n  },\n  // bayt, the plan of a house with its door in the front wall -> beth ->\n  // beta -> B.\n  B: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"6,8.6 8.6,8.6 8.6,1.4 1.4,1.4 1.4,8.6 4,8.6\",\n        \"6.9,5 1.2,4.6 5.8,0.6 6.6,2.6 6.9,5 6.4,7.6 4.4,9 1.8,9.4\",\n        \"2.4,4.8 6.4,4.2 7.4,2.4 6.2,0.8 2.4,0.6 2.4,9.4 7,9.2 8.2,7.2 7,5.2 2.4,4.8\",\n        \"2.2,4.7 5.6,4.6 6.8,3.8 7,2.5 6.6,1.3 5.4,0.6 2.2,0.6 2.2,9.4 6,9.4 7.6,8.6 8,7 7.4,5.5 5.8,4.8 2.2,4.7\",\n      ]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,0.6 2.4,0.6\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,9.4 2.4,9.4\"]],\n    ],\n  },\n  // dalt, a door with its leaf -> daleth -> delta -> D, the delta laid on\n  // its side as western Greek and Latin wrote it.\n  D: {\n    turn: [[0, 0], [0, 1], [90, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"2.4,0.8 7.6,0.8 7.6,9.2 2.4,9.2 2.4,0.8\",\n        \"4.6,0.8 1.6,6 6.4,6 4.6,0.8\",\n        \"5,0.8 0.8,9.2 9.2,9.2 5,0.8\",\n        \"2.2,0.6 5,0.6 7.4,1.8 8.6,3.8 8.8,5 8.6,6.2 7.4,8.2 5,9.4 2.2,9.4 2.2,0.6\",\n      ]],\n      [[1, 1, 0, 0], [\"5.6,2.2 6.4,5 5.6,7.8\", \"6.4,6 8.2,9.2\", \"9.2,9.2 9.2,9.2\", \"\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,0.6 2.4,0.6\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,9.4 2.4,9.4\"]],\n    ],\n  },\n  // mem, water -> mem with its tail -> mu, long left leg -> M.\n  M: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"0.4,4 1.6,6 2.8,4 4,6 5.2,4 6.4,6 7.6,4 8.8,6 9.6,4.6\",\n        \"1.1,0.6 3,3 4.7,1.3 6.4,3 9,0.8 8.4,4.8 6.6,8 4,9.6\",\n        \"0.9,9.4 3,0.6 5.4,5.9 7.7,0.6 9.6,5.2\",\n        \"1,9.4 2.1,0.6 5,9.4 7.9,0.6 9,9.4\",\n      ]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"-0.2,9.4 2,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"8,9.4 10.2,9.4\"]],\n    ],\n  },\n  // nun, a snake -> nun -> nu, long left leg -> N.\n  N: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"1.4,1.4 2.4,0.6 3.4,1.2 3.6,2.8 5.4,3.4 7.4,2.6 8,4.2 6.6,6 4.6,7 4.4,8.6 6,9.6\",\n        \"1.8,0.6 3.8,3.6 7.4,1.2 6.4,5.6 3.2,9.6\",\n        \"1.2,9.4 3.2,0.6 6.4,6.4 8.8,0.6\",\n        \"1.6,9.4 1.6,0.6 8.4,9.4 8.4,0.6\",\n      ]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.6,9.4 2.6,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"7.4,0.6 9.4,0.6\"]],\n    ],\n  },\n  // ʿayin, an eye -> ayin -> omicron -> O.\n  O: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"0.4,5 1.8,3.4 3.4,2.5 5,2.2 6.6,2.5 8.2,3.4 9.6,5 8.2,6.6 6.6,7.5 5,7.8 3.4,7.5 1.8,6.6 0.4,5\",\n        \"circle 5,5 3.4\",\n        \"circle 5,5 3.9\",\n        \"circle 5,5 4.5\",\n      ]],\n      [[1, 0, 0, 0], [\"circle 5,5 1.3\", \"circle 5,5 0.2\", \"\", \"\"]],\n    ],\n  },\n  // rōš, a head in profile looking left -> resh -> rho -> R, whose leg\n  // Latin kept to tell it from its own P.\n  R: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"5.8,9.6 5.8,6.8 7.2,5 7.6,3 6.6,1.2 4.4,0.6 2.4,1.6 1.2,3.4 2.2,3.9 2,4.8 2.8,5.8 4.2,6.2 5.8,6.8\",\n        \"7.8,9.6 6.4,4.4 5.2,0.6 1.4,3.6 6.4,4.4\",\n        \"2.4,9.4 2.4,0.6 6,0.6 7.6,1.6 7.8,3 6.8,4.6 2.4,5\",\n        \"2.2,9.4 2.2,0.6 5.4,0.6 7,1.2 7.6,2.6 7,4 5.4,4.8 2.2,4.8\",\n      ]],\n      [[0, 0, 1, 1], [\"5.8,6.8 5.8,6.8\", \"6.4,4.4 6.4,4.4\", \"4.2,4.9 4.2,4.9\", \"4.4,4.8 6.4,7 8.6,9.4\"]],\n      [[1, 0, 0, 0], [\"3.4,2.6 3.6,2.8\", \"\", \"\", \"\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,0.6 2.4,0.6\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,9.4 3.6,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"7.8,9.4 10,9.4\"]],\n    ],\n  },\n};\n\nfunction parse(text) {\n  if (text.startsWith(\"circle\")) {\n    const [, c, r] = text.split(\" \"), [x, y] = c.split(\",\").map(Number), rr = Number(r), pts = [];\n    // Starts at the left, as the eye does, and runs clockwise.\n    for (let i = 0; i \u003c= 24; i++) pts.push([x - rr * cos((i / 24) * 2 * PI), y - rr * sin((i / 24) * 2 * PI)]);\n    return pts;\n  }\n  return text.split(\" \").map((t) => t.split(\",\").map(Number));\n}\n\n// K points evenly along the polyline.\nfunction resample(pts) {\n  const L = [0];\n  for (let i = 1; i \u003c pts.length; i++) L.push(L[i - 1] + Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]));\n  const total = L[L.length - 1], out = [];\n  let j = 1;\n  for (let k = 0; k \u003c K; k++) {\n    const s = (total * k) / (K - 1);\n    while (j \u003c pts.length - 1 && L[j] \u003c s) j++;\n    const seg = L[j] - L[j - 1] || 1, t = total ? cl((s - L[j - 1]) / seg, 0, 1) : 0;\n    out.push([pts[j - 1][0] + (pts[j][0] - pts[j - 1][0]) * t, pts[j - 1][1] + (pts[j][1] - pts[j - 1][1]) * t]);\n  }\n  return out;\n}\n\n// The turn between two eras, about the middle of the grid, and back.\nfunction turn(pts, deg, mir, back) {\n  const a = ((back ? -deg : deg) * PI) / 180, c = cos(a), s = sin(a);\n  return pts.map(([x, y]) => {\n    let dx = x - 5, dy = y - 5;\n    if (mir && !back) dx = -dx;\n    let rx = dx * c - dy * s, ry = dx * s + dy * c;\n    if (mir && back) rx = -rx;\n    return [5 + rx, 5 + ry];\n  });\n}\n\nconst closed = (p) => Math.hypot(p[0][0] - p[K - 1][0], p[0][1] - p[K - 1][1]) \u003c 1e-6;\nconst gap = (a, b) => a.reduce((s, p, i) => s + (p[0] - b[i][0]) ** 2 + (p[1] - b[i][1]) ** 2, 0);\n\n// The target turned to face the source the nearest way: reversed if open,\n// and for a closed stroke also started at the best point.\nfunction align(src, tgt) {\n  let best = tgt, bg = gap(src, tgt);\n  const rev = tgt.slice().reverse();\n  if (gap(src, rev) \u003c bg) {\n    best = rev;\n    bg = gap(src, rev);\n  }\n  if (closed(tgt)) {\n    const ring = tgt.slice(0, K - 1);\n    for (const dir of [ring, ring.slice().reverse()])\n      for (let sft = 0; sft \u003c K - 1; sft++) {\n        const c = [];\n        for (let i = 0; i \u003c K - 1; i++) c.push(dir[(i + sft) % (K - 1)]);\n        c.push(c[0]);\n        const g = gap(src, c);\n        if (g \u003c bg) {\n          bg = g;\n          best = c;\n        }\n      }\n  }\n  return best;\n}\n\n// Every letter's strokes for every era and every bend.\nfunction build() {\n  const out = {};\n  for (const ch in LETTERS) {\n    const L = LETTERS[ch], strokes = [];\n    for (const [alpha, shapes] of L.strokes) {\n      const g = shapes.map((t) => (t ? resample(parse(t)) : null));\n      for (let e = 1; e \u003c 4; e++) if (!g[e] && g[e - 1]) g[e] = turn(g[e - 1], L.turn[e - 1][0], L.turn[e - 1][1], false);\n      for (let e = 2; e >= 0; e--) if (!g[e] && g[e + 1]) g[e] = turn(g[e + 1], L.turn[e][0], L.turn[e][1], true);\n      // For each bend, the next era's shape seen from before the turn.\n      const to = [0, 1, 2].map((e) => align(g[e], turn(g[e + 1], L.turn[e][0], L.turn[e][1], true)));\n      strokes.push({ alpha, g, to });\n    }\n    out[ch] = { turn: L.turn, strokes };\n  }\n  return out;\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n}\n\nconst ease = (u) => u * u * (3 - 2 * u);\n\n// The era position 0..3 of a letter whose own clock reads t seconds.\nfunction eraAt(t) {\n  if (t \u003c= 0) return 0;\n  t %= CYCLE;\n  let x = 0;\n  for (let e = 0; e \u003c 3; e++) {\n    if (t \u003c HOLD[e]) return e;\n    t -= HOLD[e];\n    if (t \u003c BEND) return e + t / BEND;\n    t -= BEND;\n  }\n  if (t \u003c HOLD[3]) return 3;\n  t -= HOLD[3];\n  x = 3 * (1 - ease(t / BACK));\n  return x;\n}\n\nexport function setup(params) {\n  params.s = { glyphs: build(), clock: 0, hue: 0, word: 0, lag: 0.06, ink: new Float32Array(N), owner: new Int8Array(N) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.clock += cl(dt || 0, 0, 0.1) * (speed / 2);\n  S.hue = k[0] || 0;\n  S.word = round(cl(k[2] || 0, 0, WORDS.length - 1));\n  S.lag = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n}\n\n// Distance from (px, py) to the segment a-b.\nfunction seg(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n  const t = L2 > 1e-9 ? cl(((px - ax) * dx + (py - ay) * dy) / L2, 0, 1) : 0;\n  const ex = px - ax - t * dx, ey = py - ay - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// Ink a segment with a round pen of radius w and a soft halo.\nfunction stamp(S, band, ax, ay, bx, by, w, a) {\n  const x0 = max(0, floor(min(ax, bx) - w - 3)), x1 = min(W - 1, floor(max(ax, bx) + w + 3));\n  const y0 = max(0, floor(min(ay, by) - w - 3)), y1 = min(H - 1, floor(max(ay, by) + w + 3));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const d = seg(x + 0.5, y + 0.5, ax, ay, bx, by);\n      const v = a * max(cl(w + 0.5 - d, 0, 1), 0.34 * exp(-((d - w) * (d - w)) / 4.5));\n      const i = y * W + x;\n      if (v > S.ink[i]) {\n        S.ink[i] = v;\n        S.owner[i] = band;\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  S.ink.fill(0);\n  const word = WORDS[S.word], step = HOLD[1] + BEND;\n  // Grid unit in LEDs and the 32 row band of each letter.\n  const U = 3, colours = [];\n  for (let n = 0; n \u003c 4; n++) {\n    const G = S.glyphs[word[n]], yc = n * 32 + 16, xc = 33;\n    const x = eraAt(S.clock - n * S.lag * step);\n    const e = min(2, floor(x)), u = ease(x - e);\n    const [deg, mir] = G.turn[e];\n    const a = ((deg * u) * PI) / 180, ca = cos(a), sa = sin(a);\n    const flip = mir ? cos(PI * u) : 1;\n    const shade = mir ? 0.5 + 0.5 * abs(flip) : 1;\n    // Roman shading comes in over the last bend.\n    const roman = e === 2 ? u : 0;\n    const pen = PEN[e] + (PEN[e + 1] - PEN[e]) * u;\n    const c0 = hsv(S.hue + ERA[e][0], ERA[e][1], 1), c1 = hsv(S.hue + ERA[e + 1][0], ERA[e + 1][1], 1);\n    colours.push(c0.map((v, i) => (v + (c1[i] - v) * u) * 255 * shade));\n    for (const st of G.strokes) {\n      const al = st.alpha[e] + (st.alpha[e + 1] - st.alpha[e]) * u;\n      if (al \u003c 0.01) continue;\n      const src = st.g[e], tgt = st.to[e];\n      let px = 0, py = 0;\n      for (let i = 0; i \u003c K; i++) {\n        let gx = src[i][0] + (tgt[i][0] - src[i][0]) * u - 5, gy = src[i][1] + (tgt[i][1] - src[i][1]) * u - 5;\n        gx *= flip;\n        const rx = gx * ca - gy * sa, ry = gx * sa + gy * ca;\n        const qx = xc + rx * U, qy = yc + ry * U;\n        if (i > 0) {\n          // A broad edge at 30 degrees: thick across it, thin along it.\n          const dx = qx - px, dy = qy - py, L = Math.hypot(dx, dy) || 1;\n          const nib = abs((dx / L) * 0.5 + (dy / L) * 0.866);\n          const w = (pen + roman * (0.22 + 0.5 * nib - pen)) * U;\n          stamp(S, n, px, py, qx, qy, w, al);\n        }\n        px = qx;\n        py = qy;\n      }\n    }\n    // The era rail at the left: four ticks and where the letter is.\n    for (let t = 0; t \u003c 4; t++) stamp(S, n, 6, yc - 10.5 + 7 * t, 6, yc - 10.5 + 7 * t, 0.2, 0.35);\n    stamp(S, n, 6, yc - 10.5 + 7 * x, 6, yc - 10.5 + 7 * x, 0.9, 1);\n    // The writing direction at the right: left for Phoenician, then turned.\n    const dirA = e === 0 ? u : 1, f = mir ? flip : e === 0 ? 1 : -1;\n    const ax = 57 + 2.5 * f, bx = 57 - 2.5 * f;\n    stamp(S, n, ax, yc - 3.5, bx, yc, 0.35, 0.8 * dirA);\n    stamp(S, n, bx, yc, ax, yc + 3.5, 0.35, 0.8 * dirA);\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const v = S.ink[i], c = colours[S.owner[i]];\n    display.setPixel(i % W, (i / W) | 0, round(c[0] * v), round(c[1] * v), round(c[2] * v));\n  }\n}\n","cantor-scalogram":"// ===== Patternflow pattern =====\n// Title:   Cantor Scalogram\n// Family:  data\n// Idea:    The wavelet transform of the Cantor staircase fills the tall panel, position down the 128 rows and log scale across the 64 columns, brightness its modulus and hue the phase of a complex Morlet wavelet, so the modulus branches into a tree of cones exactly as the middle-thirds Cantor set does while the view zooms in by three and slides one level along the scale axis back to the same picture.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: continuous wavelet transform (Alex Grossmann and Jean Morlet, 1984); wavelet transform of fractal signals, the Cantor staircase and the tree of its modulus maxima (Alain Arneodo, Guy Grasseau and Matthias Holschneider, 1988); the middle-thirds Cantor set (Georg Cantor, 1883); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=1..8, Omega=3..8\n//\n// Knob 1: Hue. Turns the phase wheel: at 0 a phase of 0 is cyan, at 0.5 it is red, and the hue goes once round the wheel for every turn of the phase.\n// Knob 2: Speed. At 2 the view zooms in by three every 6 s while the tree slides 21 columns towards the coarse side; 60 s at 0.2, 4 s at 3.\n// Knob 3: Noise. Complex noise on every coefficient, 0.1 times Noise^0.85 of the lit threshold at the coarsest column and 1.54 times that at the finest: at 1 it is a dim static under the cones and 28% of the LEDs are lit, at 8 the fine branches sink into it and 55% are lit.\n// Knob 4: Omega. The Morlet wavelet's centre frequency, 3 to 8 radians per unit of its width. At 3 the cones are smooth and the hue turns 2.8 radians a row at the finest column; from 5 the two halves of each branch cancel between them, so each cone opens into a striped oval.\n\n// Rows are the position b, columns the scale a, 21 columns to a factor of\n// 3, from a = 0.243 on the left to 0.009 on the right. The Morlet wavelet\n// psi(t) = exp(-t^2 / 2) (exp(i w t) - exp(-w^2 / 2)) is taken against the\n// Cantor measure mu, the derivative of the staircase F:\n//\n//   T(a, b) = (1/a) * integral psi((x - b) / a) dmu(x),\n//\n// which is -1/a times the transform of F itself with psi' as wavelet. The\n// staircase rises as |x - x0|^alpha at each point of the set, alpha =\n// log 2 / log 3, so T grows as a^(alpha - 1) on its maxima, and every\n// column is multiplied by a^(1 - alpha). Then the measure's own symmetry,\n// mu on [0, 1/3] being half of mu shrunk by 3, makes the scaled T at\n// (a/3, b/3) equal to the scaled T at (a, b): zooming in by 3 about b = 0 and moving 21 columns gives\n// the picture back, and the loop has no seam. The mass of [2/3, 1] is 3.95\n// wavelet widths from the bottom row at the end of the loop.\n//\n// At scale a the measure is cut at the stage k where the intervals are\n// 1/5.5 to 1/16.5 of a, each interval a point mass at its centre. The\n// spread of the measure inside an interval, variance (3^-k)^2 / 8, is put\n// back with the second derivative of psi, so the sum changes by under 0.1%\n// when k steps. Only the masses within 4a of the panel count, 8 to 64 of\n// them and 410 to 1860 terms a column, and down the rows each mass runs by\n// recurrence: the Gaussian by two products and the phase by one rotation.\n//\n// The 72% of LEDs with the smallest modulus stay at 24 or under, drawn as\n// the log of the modulus over a range of e^4; the rest climb from 25 to\n// 255. The hue is the phase. Noise on the coefficients is what lights the\n// gaps of the set, where the staircase is flat and its transform is all\n// but zero.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, round, sqrt, sin, cos, exp, log, pow, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst LN3 = log(3);\nconst ALPHA = log(2) / LN3;\n\n// Rows: position b from -0.04 to 1.04 at the start of the loop.\nconst B0 = -0.04, DB = 1.08 / H;\n// Columns: scale a from AMAX at column 0 down by 3 every PER columns.\nconst AMAX = 0.243, PER = 21;\n// The level of point masses keeps a / 3^-k in [RMIN, 3 RMIN).\nconst RMIN = 5.5, KMAX = 9;\n// Histogram of the modulus for the exposure.\nconst HB = 512;\n// Share of LEDs left under the lit threshold.\nconst DARK = 0.72;\n// Under the threshold the brightness is the log of the modulus, over e^LOGR.\nconst LOGR = 4;\n// Noise on the coefficients at Noise 1, as a share of the threshold.\nconst NOISE = 0.1;\n\n// Centres of the 2^k intervals of the k-th stage of the Cantor set, sorted.\nconst CENTRES = [];\nfor (let k = 0; k \u003c= KMAX; k++) {\n  const n = 1 \u003c\u003c k, w = pow(3, -k), arr = new Float64Array(n);\n  for (let j = 0; j \u003c n; j++) {\n    let x = 0, s = 1 / 3;\n    for (let i = k - 1; i >= 0; i--) {\n      if ((j >> i) & 1) x += 2 * s;\n      s /= 3;\n    }\n    arr[j] = x + w / 2;\n  }\n  CENTRES.push(arr);\n}\nconst firstAtLeast = (arr, x) => {\n  let lo = 0, hi = arr.length;\n  while (lo \u003c hi) {\n    const m = (lo + hi) >> 1;\n    if (arr[m] \u003c x) lo = m + 1;\n    else hi = m;\n  }\n  return lo;\n};\n\n// A small generator of its own, seeded once from Math.random, for the\n// 16384 noise draws a frame; two uniforms make a triangle of variance 1.\nlet seed = 1;\nconst uni = () => {\n  seed ^= seed \u003c\u003c 13;\n  seed ^= seed >>> 17;\n  seed ^= seed \u003c\u003c 5;\n  return (seed >>> 0) / 4294967296;\n};\nconst tri = () => (uni() + uni() - 1) * 2.449;\n\nexport function setup(params) {\n  seed = (Math.random() * 4294967295) | 1;\n  params.s = {\n    u: 0,\n    hue: 0,\n    noise: 1,\n    omega: 3,\n    re: new Float64Array(W * H),\n    im: new Float64Array(W * H),\n    mod: new Float64Array(W * H),\n    hist: new Uint32Array(HB),\n    // Complex noise on every coefficient, refreshed a little every frame.\n    noiseRI: new Float32Array(W * H * 2).map(tri),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.noise = cl(k[2] == null ? 1 : k[2], 1, 8);\n  S.omega = cl(k[3] == null ? 3 : k[3], 3, 8);\n  S.u = (S.u + (d * speed) / 12) % 1;\n  // The noise drifts: each value keeps exp(-dt / 0.15 s) of itself.\n  const keep = exp(-d / 0.15), fresh = sqrt(1 - keep * keep), nz = S.noiseRI;\n  for (let i = 0; i \u003c nz.length; i++) nz[i] = nz[i] * keep + fresh * tri();\n}\n\n// Adds the transform of the Cantor measure at one column into re, im.\nfunction column(S, c) {\n  const z = pow(3, -S.u), om = S.omega, kap = exp(-om * om / 2);\n  const a = AMAX * pow(3, -c / PER) * z;\n  const db = DB * z, b0 = (B0 + 0.5 * DB) * z;\n  const k = cl(ceil(log(RMIN / a) / LN3), 0, KMAX);\n  const r = a * pow(3, k), v2 = 1 / (16 * r * r), norm = pow(r, -ALPHA);\n  const reach = 4 * a, xs = CENTRES[k];\n  const delta = db / a, D = exp(-delta * delta), cw = cos(om * delta), sw = sin(om * delta);\n  const re = S.re, im = S.im, off = c;\n  for (let n = 0; n \u003c H; n++) re[n * W + off] = im[n * W + off] = 0;\n  const end = b0 + (H - 1) * db + reach;\n  for (let j = firstAtLeast(xs, b0 - reach); j \u003c xs.length && xs[j] \u003c= end; j++) {\n    const x = xs[j];\n    const n0 = max(0, ceil((x - reach - b0) / db)), n1 = min(H - 1, floor((x + reach - b0) / db));\n    let t = (x - (b0 + n0 * db)) / a;\n    let G = exp(-t * t / 2), Q = exp(t * delta - delta * delta / 2);\n    let zr = cos(om * t), zi = sin(om * t);\n    for (let n = n0; n \u003c= n1; n++) {\n      const tt = t * t;\n      const p = 1 + v2 * (tt - 1 - om * om), q = -2 * v2 * om * t;\n      const kk = kap * (1 + v2 * (tt - 1));\n      re[n * W + off] += G * (zr * p - zi * q - kk);\n      im[n * W + off] += G * (zr * q + zi * p);\n      G *= Q;\n      Q *= D;\n      t -= delta;\n      const tr = zr * cw + zi * sw;\n      zi = zi * cw - zr * sw;\n      zr = tr;\n    }\n  }\n  for (let n = 0; n \u003c H; n++) {\n    re[n * W + off] *= norm;\n    im[n * W + off] *= norm;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  for (let c = 0; c \u003c W; c++) column(S, c);\n  const re = S.re, im = S.im, mod = S.mod, hist = S.hist, N = W * H;\n  // Exposure from the staircase alone: the lit threshold is the modulus that\n  // DARK of the LEDs stay under, full brightness the top 0.5%.\n  let top = 0;\n  for (let p = 0; p \u003c N; p++) {\n    const m = sqrt(re[p] * re[p] + im[p] * im[p]);\n    mod[p] = m;\n    if (m > top) top = m;\n  }\n  hist.fill(0);\n  const hs = (HB - 1) / (top || 1);\n  for (let p = 0; p \u003c N; p++) hist[floor(mod[p] * hs)]++;\n  let mf = 0, mt = top;\n  for (let i = 0, acc = 0; i \u003c HB; i++) {\n    acc += hist[i];\n    if (!mf && acc >= DARK * N) mf = (i + 1) / hs;\n    if (acc >= 0.995 * N) {\n      mt = (i + 1) / hs;\n      break;\n    }\n  }\n  mt = max(mt, mf * 1.05);\n  const nz = S.noiseRI, hue = S.hue + 0.5;\n  for (let c = 0; c \u003c W; c++) {\n    // The noise grows as a^-(alpha - 1/2) towards fine scales, as white\n    // noise in the staircase would against the Cantor part.\n    const sig = NOISE * mf * pow(S.noise, 0.85) * pow(3, (c / PER) * (ALPHA - 0.5));\n    const cmax = 3 * sig;\n    for (let n = 0; n \u003c H; n++) {\n      const p = n * W + c;\n      let nr = nz[2 * p] * sig, ni = nz[2 * p + 1] * sig;\n      const nm = sqrt(nr * nr + ni * ni);\n      if (nm > cmax) {\n        nr *= cmax / nm;\n        ni *= cmax / nm;\n      }\n      const zr = re[p] + nr, zi = im[p] + ni;\n      const m = sqrt(zr * zr + zi * zi);\n      // Under the threshold the LED stays under 24; over it, it climbs.\n      let v, sat;\n      if (m \u003c mf) {\n        v = m > 0 ? 24.4 * cl(1 + log(m / mf) / LOGR, 0, 1) : 0;\n        // The more of the coefficient is noise, the deeper its colour.\n        sat = 0.3 + (0.65 * nm) / (nm + mod[p] + 1e-9);\n      } else {\n        const x = min(1, (m - mf) / (mt - mf));\n        v = 25 + 230 * pow(x, 0.8);\n        sat = 0.85 - 0.4 * x * x;\n      }\n      // Hue: the phase, once round the wheel per turn.\n      let h = atan2(zi, zr) / TAU + hue;\n      h = (h - floor(h)) * 6;\n      const i = floor(h), fr = h - i;\n      const P = v * (1 - sat), Q = v * (1 - sat * fr), T = v * (1 - sat * (1 - fr));\n      let R, G, B;\n      if (i === 0) (R = v), (G = T), (B = P);\n      else if (i === 1) (R = Q), (G = v), (B = P);\n      else if (i === 2) (R = P), (G = v), (B = T);\n      else if (i === 3) (R = P), (G = Q), (B = v);\n      else if (i === 4) (R = T), (G = P), (B = v);\n      else (R = v), (G = P), (B = Q);\n      if (m >= mf) {\n        // A lit LED sits on a grey of 25, so none of its channels is as dim\n        // as the floor.\n        const k = (v - 25) / v;\n        R = 25 + R * k;\n        G = 25 + G * k;\n        B = 25 + B * k;\n      }\n      display.setPixel(c, n, round(R), round(G), round(B));\n    }\n  }\n}\n","crofton-cell":"// ===== Patternflow pattern =====\n// Title:   Crofton Cell\n// Family:  cells\n// Idea:    Isotropic Poisson lines drift, are born and die across the tall panel and cut it into convex cells tinted by their number of sides, while the one cell that holds the fixed point in the middle, the Crofton cell, is lit as a pale incircle in gold corners under a dashed outer circle, so when the Big knob keeps every line at least r away from that point the cell swells, gains sides and its gold corners thin round the disc, as Kendall conjectured.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Poisson line tessellation and its zero cell (Roger E. Miles, Random polygons determined by random lines in a plane, 1964); D. G. Kendall's conjecture that large zero cells are nearly round (1940s), proved for the plane by Igor Kovalenko (1997) and in general by Daniel Hug, Matthias Reitzner and Rolf Schneider (2004); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=16..56, Big=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 triangles are teal, quadrilaterals azure, pentagons violet, hexagons pink and cells of seven sides or more green, and the Crofton cell is a pale disc in gold corners.\n// Knob 2: Speed. At 2 a line slides along its normal at up to 3 LEDs a second, turns at up to 0.05 radians a second and lives 10 s on average, so at the opening about 1.6 lines a second are born where the panel shows them and as many die. Everything goes as Speed / 2.\n// Knob 3: Lines. The mean number of lines that cross the panel, 16 to 56: the panel shows about 52 cells at 16, 190 at 36 and 390 at 56.\n// Knob 4: Big. No line may come nearer the fixed point than r = 20 Big^0.6 LEDs, which is the Poisson process conditioned on the zero cell holding that disc: 3.7 LEDs at the opening 0.06, 8.7 at 0.25, 13.2 at 0.5 and 20 at 1. With 56 lines the zero cell has 4.95 sides on average at 0, 5.9 at the opening and 8.5 at 1, and its incircle grows from 0.36 to 0.65 of the radius of its outer circle.\n\n// A line is (theta, p): the points x with x . (cos theta, sin theta) = p,\n// p >= 0, measured from the fixed point O in the middle of the panel. The\n// isotropic Poisson line process is a Poisson point process in (theta, p)\n// with uniform density, and by Crofton's formula the lines that hit a convex\n// set K number perimeter(K) times that density on average. So the panel\n// keeps every line with p \u003c R, R past the panel's corners, uniformly in\n// theta and p: the panel's perimeter of 384 LEDs against the circle's 2 pi R\n// says how many of those cross it.\n//\n// Each line slides in p and turns in theta at its own constant rate, which\n// moves the points of (theta, p) without squeezing them, so the law stays\n// the Poisson one. A line whose p passes 0 is the same line seen from the\n// other side, (theta + pi, -p). At p = R it turns back. Lines are also born\n// uniformly at a constant rate and each dies at a constant rate, a spatial\n// birth and death process whose resting law is the same Poisson process.\n//\n// The zero cell is the cell that contains O. Conditioning the process on\n// the zero cell holding the disc of radius r round O is the same as\n// keeping only the lines with p >= r, since a Poisson process on a set and\n// on its complement are independent. So Big only hides lines: a line that\n// slides in to p = r dies at the point where it touches the disc, and one\n// that slides out is born there. Miles found the zero cell has pi^2 / 2 =\n// 4.93 sides on average where a typical cell has 4. Kendall's question\n// was what a large zero cell looks like, and the answer is a disc: with r\n// large against the mean spacing of the lines, many lines lie just past r\n// and the cell is a many sided polygon hugging the circle. It comes slowly:\n// with l lines per LED of p per radian, the cell's corners stand out past\n// the disc by about (l r)^(-2/3) of r, so on 64 LEDs the cell gets to 8 or\n// 9 sides, rounder than its neighbours but still a polygon.\n//\n// Two LEDs are in the same cell when no line separates them, so each LED's\n// cell is the set of lines it lies beyond, hashed. A cell's polygon is the\n// square of side 2R clipped by the half plane of every line on that cell's\n// side; its edges give the number of sides. The zero cell's largest\n// inscribed disc comes from the three edges that pin it.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, sin, cos, abs, atan2, exp, pow, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst OX = 32, OY = 64;\n// Lines are kept while they pass within R of O; the corners are 71.6 away.\nconst R = 76;\n// Lines crossing the panel per line kept: perimeter over 2 pi R.\nconst CROSS = 384 / (TAU * R);\n// Mean life, the speed limits, all at Speed 2.\nconst LIFE = 10, VP = 3, VT = 0.05;\nconst MAXL = 160;\nconst SLOTS = 2048;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n}\n\nfunction poisson(mu) {\n  const L = exp(-mu);\n  let k = 0, prod = Math.random();\n  while (prod > L && k \u003c MAXL) {\n    k++;\n    prod *= Math.random();\n  }\n  return k;\n}\n\nfunction newLine(S, p) {\n  if (S.n >= MAXL) return;\n  const i = S.n++;\n  S.th[i] = Math.random() * TAU;\n  S.p[i] = p == null ? Math.random() * R : p;\n  S.v[i] = (Math.random() * 2 - 1) * VP;\n  S.w[i] = (Math.random() * 2 - 1) * VT;\n  S.life[i] = -log(1 - Math.random()) * LIFE;\n  S.key[i] = (Math.random() * 4294967296) >>> 0 | 1;\n  S.glow[i] = 0;\n  S.vis[i] = 0;\n}\n\nfunction kill(S, i) {\n  // A dying line that the panel shows leaves a fading ghost.\n  if (S.vis[i] && S.p[i] \u003c 73 && S.ghosts.length \u003c 8) S.ghosts.push([cos(S.th[i]), sin(S.th[i]), S.p[i], 1]);\n  const j = --S.n;\n  for (const a of [S.th, S.p, S.v, S.w, S.life, S.key, S.glow, S.vis]) a[i] = a[j];\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, th: new Float64Array(MAXL), p: new Float64Array(MAXL), v: new Float64Array(MAXL), w: new Float64Array(MAXL),\n    life: new Float64Array(MAXL), key: new Uint32Array(MAXL), glow: new Float32Array(MAXL), vis: new Uint8Array(MAXL),\n    ghosts: [], sparks: [], started: false, hue: 0, r: 4, mu: 20,\n    hash: new Uint32Array(N), dmin: new Float32Array(N), near: new Int16Array(N), cell: new Int16Array(N),\n    skey: new Uint32Array(SLOTS), sused: new Uint8Array(SLOTS), sid: new Int16Array(SLOTS),\n    rep: new Int32Array(SLOTS), sides: new Uint8Array(SLOTS), area: new Float32Array(SLOTS),\n    px: new Float64Array(96), py: new Float64Array(96), pl: new Int16Array(96), qx: new Float64Array(96), qy: new Float64Array(96), ql: new Int16Array(96),\n    zero: null,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 16, 0.06];\n  const d = cl(dt || 0, 0, 0.1) * cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.hue = k[0] || 0;\n  S.mu = cl(k[2] == null ? 16 : k[2], 16, 56) / CROSS;\n  S.r = 20 * pow(cl(k[3] == null ? 0.06 : k[3], 0, 1), 0.6);\n  if (!S.started) {\n    S.started = true;\n    for (let m = poisson(S.mu); m > 0; m--) newLine(S);\n    for (let i = 0; i \u003c S.n; i++) S.vis[i] = S.p[i] >= S.r ? 1 : 0;\n  }\n  // Births at the resting rate, plus a quick catch up when the knob moves.\n  const births = (S.mu / LIFE + max(0, S.mu - S.n) / 0.6) * d;\n  let extra = (max(0, S.n - S.mu) / 0.6) * d;\n  for (let b = births; b > 0; b--) if (Math.random() \u003c b) {\n    newLine(S);\n    S.glow[S.n - 1] = 1;\n  }\n  for (; extra > 0; extra--) if (Math.random() \u003c extra && S.n > 0) kill(S, floor(Math.random() * S.n));\n  for (let i = S.n - 1; i >= 0; i--) {\n    let p = S.p[i] + S.v[i] * d;\n    S.th[i] += S.w[i] * d;\n    if (p \u003c 0) {\n      p = -p;\n      S.th[i] += PI;\n      S.v[i] = -S.v[i];\n    }\n    if (p > R) {\n      p = 2 * R - p;\n      S.v[i] = -S.v[i];\n    }\n    S.p[i] = p;\n    S.glow[i] = max(0, S.glow[i] - d * 1.6);\n    S.life[i] -= d;\n    if (S.life[i] \u003c= 0) {\n      kill(S, i);\n      continue;\n    }\n    // Big hides the lines nearer than r: they die and are born touching the disc.\n    const vis = p >= S.r ? 1 : 0;\n    if (vis !== S.vis[i]) {\n      if (S.sparks.length \u003c 24) S.sparks.push([OX + S.r * cos(S.th[i]), OY + S.r * sin(S.th[i]), 1]);\n      if (vis) S.glow[i] = 0.8;\n      S.vis[i] = vis;\n    }\n  }\n  for (const g of S.ghosts) g[3] -= d * 2;\n  S.ghosts = S.ghosts.filter((g) => g[3] > 0);\n  for (const s of S.sparks) s[2] -= d * 2.2;\n  S.sparks = S.sparks.filter((s) => s[2] > 0);\n}\n\n// Clip the square of side 2R by the lines on one side, sign per line from\n// the LED at rep, or every line on O's side when rep \u003c 0. Leaves the polygon\n// in S.px, S.py with edge labels in S.pl (-1 for the square) and returns its\n// vertex count.\nfunction polygon(S, act, rep) {\n  let px = S.px, py = S.py, pl = S.pl, qx = S.qx, qy = S.qy, ql = S.ql;\n  px[0] = -R; py[0] = -R; px[1] = R; py[1] = -R; px[2] = R; py[2] = R; px[3] = -R; py[3] = R;\n  pl[0] = pl[1] = pl[2] = pl[3] = -1;\n  let n = 4;\n  const rx = rep \u003c 0 ? 0 : (rep % W) + 0.5 - OX, ry = rep \u003c 0 ? 0 : floor(rep / W) + 0.5 - OY;\n  for (let j = 0; j \u003c act.n; j++) {\n    const a = act.a[j], b = act.b[j], p = act.p[j];\n    // Keep s (a x + b y - p) >= 0.\n    const s = a * rx + b * ry - p > 0 ? 1 : -1;\n    let m = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const i2 = i + 1 === n ? 0 : i + 1;\n      const f1 = s * (a * px[i] + b * py[i] - p), f2 = s * (a * px[i2] + b * py[i2] - p);\n      if (f1 >= 0) {\n        qx[m] = px[i]; qy[m] = py[i]; ql[m] = pl[i]; m++;\n        if (f2 \u003c 0) {\n          const t = f1 / (f1 - f2);\n          qx[m] = px[i] + t * (px[i2] - px[i]); qy[m] = py[i] + t * (py[i2] - py[i]); ql[m] = j; m++;\n        }\n      } else if (f2 >= 0) {\n        const t = f1 / (f1 - f2);\n        qx[m] = px[i] + t * (px[i2] - px[i]); qy[m] = py[i] + t * (py[i2] - py[i]); ql[m] = pl[i]; m++;\n      }\n      if (m > 90) break;\n    }\n    [px, qx] = [qx, px];\n    [py, qy] = [qy, py];\n    [pl, ql] = [ql, pl];\n    n = m;\n    if (n \u003c 3) break;\n  }\n  S.px = px; S.py = py; S.pl = pl; S.qx = qx; S.qy = qy; S.ql = ql;\n  return n;\n}\n\n// The largest disc in the convex polygon S.px, S.py: centre and radius from\n// the three edges it touches, tried over every three.\nfunction incircle(S, n) {\n  const ex = [], ey = [], ec = [];\n  for (let i = 0; i \u003c n; i++) {\n    const i2 = i + 1 === n ? 0 : i + 1;\n    const dx = S.px[i2] - S.px[i], dy = S.py[i2] - S.py[i], L = sqrt(dx * dx + dy * dy);\n    if (L \u003c 1e-6) continue;\n    // The square runs clockwise on the panel (y down), so the inward\n    // normal is the edge turned a quarter to the right.\n    const nx = -dy / L, ny = dx / L;\n    ex.push(nx); ey.push(ny); ec.push(nx * S.px[i] + ny * S.py[i]);\n  }\n  const m = ex.length;\n  let best = [0, 0, 0];\n  for (let i = 0; i \u003c m; i++)\n    for (let j = i + 1; j \u003c m; j++)\n      for (let k = j + 1; k \u003c m; k++) {\n        // n . x - rho = c for the three: inside means n . x >= c + rho.\n        const a1 = ex[i], b1 = ey[i], c1 = ec[i], a2 = ex[j], b2 = ey[j], c2 = ec[j], a3 = ex[k], b3 = ey[k], c3 = ec[k];\n        const det = a1 * (b2 * -1 - -1 * b3) - b1 * (a2 * -1 - -1 * a3) + -1 * (a2 * b3 - b2 * a3);\n        if (abs(det) \u003c 1e-9) continue;\n        const dx = c1 * (b2 * -1 - -1 * b3) - b1 * (c2 * -1 - -1 * c3) + -1 * (c2 * b3 - b2 * c3);\n        const dy = a1 * (c2 * -1 - -1 * c3) - c1 * (a2 * -1 - -1 * a3) + -1 * (a2 * c3 - c2 * a3);\n        const dr = a1 * (b2 * c3 - c2 * b3) - b1 * (a2 * c3 - c2 * a3) + c1 * (a2 * b3 - b2 * a3);\n        const x = dx / det, y = dy / det, rho = dr / det;\n        if (!(rho > best[2])) continue;\n        let ok = true;\n        for (let q = 0; q \u003c m && ok; q++) if (ex[q] * x + ey[q] * y \u003c ec[q] + rho - 1e-7) ok = false;\n        if (ok) best = [x, y, rho];\n      }\n  return best;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { hash, dmin, near, cell, skey, sused, sid, rep, sides } = S;\n  // The lines the panel shows.\n  const act = { n: 0, a: [], b: [], p: [], key: [], glow: [] };\n  for (let i = 0; i \u003c S.n; i++)\n    if (S.vis[i] && S.p[i] \u003c 73) {\n      act.a.push(cos(S.th[i])); act.b.push(sin(S.th[i])); act.p.push(S.p[i]); act.key.push(S.key[i]); act.glow.push(S.glow[i]);\n      act.n++;\n    }\n  hash.fill(0);\n  dmin.fill(99);\n  near.fill(-1);\n  for (let j = 0; j \u003c act.n; j++) {\n    const a = act.a[j], b = act.b[j], key = act.key[j];\n    for (let y = 0; y \u003c H; y++) {\n      let dd = a * (0.5 - OX) + b * (y + 0.5 - OY) - act.p[j];\n      for (let x = 0, i = y * W; x \u003c W; x++, i++, dd += a) {\n        if (dd > 0) hash[i] ^= key;\n        const ad = dd \u003c 0 ? -dd : dd;\n        if (ad \u003c dmin[i]) {\n          dmin[i] = ad;\n          near[i] = j;\n        }\n      }\n    }\n  }\n  // Cells: hash every LED's line set into a table.\n  sused.fill(0);\n  let cells = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const h = hash[i];\n    let s = Math.imul(h, 2654435761) >>> 21;\n    while (sused[s] && skey[s] !== h) s = (s + 1) & (SLOTS - 1);\n    if (!sused[s]) {\n      sused[s] = 1;\n      skey[s] = h;\n      sid[s] = cells;\n      rep[cells] = i;\n      cells++;\n    }\n    cell[i] = sid[s];\n  }\n  for (let c = 0; c \u003c cells; c++) {\n    const n = polygon(S, act, rep[c]);\n    let e = 0, ar = 0;\n    for (let i = 0; i \u003c n; i++) {\n      if (S.pl[i] >= 0) e++;\n      const i2 = i + 1 === n ? 0 : i + 1;\n      ar += S.px[i] * S.py[i2] - S.px[i2] * S.py[i];\n    }\n    sides[c] = e;\n    S.area[c] = abs(ar) / 2;\n  }\n  // The zero cell, every line on O's side.\n  const zn = polygon(S, act, -1);\n  const [cx, cy, rin] = incircle(S, zn);\n  let rout = 0, zs = 0;\n  for (let i = 0; i \u003c zn; i++) {\n    rout = max(rout, sqrt((S.px[i] - cx) ** 2 + (S.py[i] - cy) ** 2));\n    if (S.pl[i] >= 0) zs++;\n  }\n  S.zero = { sides: zs, rin, rout };\n  const icx = cx + OX, icy = cy + OY;\n\n  const hue = S.hue;\n  // Hue by number of sides, a little brighter the larger the cell.\n  const tone = new Float32Array(cells * 3);\n  for (let c = 0; c \u003c cells; c++) {\n    const n = sides[c], h = n \u003c= 3 ? 0.47 : n === 4 ? 0.6 : n === 5 ? 0.74 : n === 6 ? 0.88 : 0.24;\n    const col = hsv(hue + h, 0.7, 0.32 + 0.26 * cl(log(1 + S.area[c]) / log(3000), 0, 1));\n    tone[c * 3] = col[0] * 255; tone[c * 3 + 1] = col[1] * 255; tone[c * 3 + 2] = col[2] * 255;\n  }\n  const gold = hsv(hue + 0.12, 0.8, 1).map((v) => v * 255);\n  const pale = hsv(hue + 0.55, 0.2, 0.95).map((v) => v * 255);\n  for (let i = 0; i \u003c N; i++) {\n    const x = i % W, y = (i / W) | 0, px = x + 0.5, py = y + 0.5;\n    const c = cell[i];\n    let r, g, b;\n    if (hash[i] === 0) {\n      const q = sqrt((px - icx) ** 2 + (py - icy) ** 2);\n      const t = cl(q - rin + 0.5, 0, 1);\n      r = pale[0] + (gold[0] - pale[0]) * t;\n      g = pale[1] + (gold[1] - pale[1]) * t;\n      b = pale[2] + (gold[2] - pale[2]) * t;\n    } else {\n      r = tone[c * 3]; g = tone[c * 3 + 1]; b = tone[c * 3 + 2];\n    }\n    // The lines themselves are dark seams; a new line flashes white.\n    const dm = dmin[i];\n    const seam = cl((dm - 0.3) / 0.45, 0, 1);\n    r *= seam; g *= seam; b *= seam;\n    if (near[i] >= 0) {\n      const gl = act.glow[near[i]];\n      if (gl > 0) {\n        const f = gl * exp(-dm * dm * 1.5) * 255;\n        r += f; g += f; b += f;\n      }\n    }\n    // Dying lines fade out where they stood.\n    for (const gh of S.ghosts) {\n      const dd = abs(gh[0] * (px - OX) + gh[1] * (py - OY) - gh[2]);\n      if (dd \u003c 1.2) {\n        const f = gh[3] * (1 - dd / 1.2) * 150;\n        r += f; g += f; b += f;\n      }\n    }\n    // Where a line touches the forbidden disc it dies or is born.\n    for (const sp of S.sparks) {\n      const dd = (px - sp[0]) ** 2 + (py - sp[1]) ** 2;\n      if (dd \u003c 9) {\n        const f = sp[2] * (1 - dd / 9) * 255;\n        r += f; g += f * 0.9; b += f * 0.7;\n      }\n    }\n    // The disc no line may enter, a faint ring round O.\n    if (S.r > 1.5) {\n      const fr = 1 - abs(sqrt((px - OX) ** 2 + (py - OY) ** 2) - S.r) / 0.6;\n      if (fr > 0) {\n        r *= 1 - 0.35 * fr; g *= 1 - 0.3 * fr; b *= 1 - 0.15 * fr;\n      }\n    }\n    // The incircle of the zero cell, solid, and its outer circle round the\n    // same centre, dashed, over everything.\n    const q = sqrt((px - icx) ** 2 + (py - icy) ** 2);\n    const ri = 1 - abs(q - rin) / 0.75;\n    if (ri > 0 && rin > 1) {\n      r += (255 - r) * ri; g += (255 - g) * ri; b += (255 - b) * ri;\n    }\n    const ro = 1 - abs(q - rout) / 0.7;\n    if (ro > 0 && floor(((atan2(py - icy, px - icx) + PI) / TAU) * 40) % 2 === 0) {\n      r += (255 - r) * ro * 0.55; g += (255 - g) * ro * 0.55; b += (255 - b) * ro * 0.55;\n    }\n    // O itself, a dark point.\n    if (abs(px - OX) \u003c 1 && abs(py - OY) \u003c 1) r = g = b = 0;\n    display.setPixel(x, y, min(255, r) | 0, min(255, g) | 0, min(255, b) | 0);\n  }\n}\n","exclusion-process":"// ===== Patternflow pattern =====\n// Title:   Exclusion Process\n// Family:  particle\n// Idea:    Particles enter a line of 64 sites across the panel at rate alpha, each hops one site right at rate 1 only when that site is empty and leaves the last site at rate beta, and the tall panel is the space-time diagram with the newest row at the top, so every particle draws its own coloured thread up and to the right, a jam stands as a block of steep threads whose holes run back to the left, and at the opening rates, equal and below one half, the front between a sparse stream and a jam wanders to and fro.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: totally asymmetric simple exclusion process (Frank Spitzer, Interaction of Markov processes, 1970; first written down for ribosomes on messenger RNA by Carolyn MacDonald, Julian Gibbs and Allen Pipkin, 1968), its exact phase diagram with open ends (Bernard Derrida, Eytan Domany and David Mukamel, 1992; Gunter Schütz and Eytan Domany, 1993); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Alpha=0.25..1, Beta=0.25..1\n//\n// Knob 1: Hue. Turns the band of thread colours round the wheel. At 0 the particles take hues from cyan through azure and violet to pink, each 0.618 of the band on from the one that entered before it, so neighbouring threads never share a colour; at 0.5 the band runs from red through yellow to green.\n// Knob 2: Speed. At 2 the diagram takes 16 new rows a second at the top, each row one unit of the process's time, in which a particle with an empty site ahead hops once on average, so the 128 rows hold the last 8 s; 80 s at 0.2, 5.3 s at 3.\n// Knob 3: Alpha. The rate at which a particle enters an empty first site. At the opening 0.25, equal to beta, a stream at density 0.25 meets a jam at density 0.75 and the front between them wanders about 10 sites over the 128 rows; any alpha above beta (with beta below 1/2) is the high-density phase, where the jam fills the line at density 1 - beta and its front backs out of the left end, a quarter of a site a row at alpha 0.5.\n// Knob 4: Beta. The rate at which the particle on the last site leaves. Above alpha (and alpha below 1/2) it is the low-density phase, a free stream at density alpha with no jam; with alpha and beta both above 1/2 it is the maximal-current phase, density 1/2 in the middle of the line and a quarter of a particle through every bond per row, however much higher the two rates go.\n\n// Each site holds at most one particle. In every unit of time each of\n// the 65 bonds (the entry, the 63 between sites and the exit) is tried\n// once on average, in random order: a particle crosses a bond inside the\n// line when the site beyond it is empty, comes in through the entry with\n// probability alpha when site 0 is empty and goes out through the exit\n// with probability beta. That is random sequential update, the process in\n// continuous time sampled once a row.\n//\n// Derrida, Domany and Mukamel solved the stationary state exactly. The\n// current through the line is alpha (1 - alpha) when alpha \u003c beta and\n// alpha \u003c 1/2, beta (1 - beta) in the mirror case, and 1/4 when both pass\n// 1/2. On alpha = beta \u003c 1/2 the two densities alpha and 1 - beta carry\n// the same current J = alpha (1 - alpha), so the front between them, a\n// shock, has no drift and walks at random. Its variance grows by\n// 2 J / (1 - 2 alpha) a unit of time: 0.75 at the opening, and here it\n// wanders 9.8 sites (root mean square) in the 128 rows the panel holds.\n//\n// Every particle gets a number when it comes in and keeps it, and its\n// colour comes from that number. Particles never pass one another, so\n// neighbours on the line always hold consecutive numbers, and consecutive\n// numbers sit 0.618 of the hue band apart, wrapped. A row stores which particle sits on each\n// site at the end of the row, and dimly every site a particle passed\n// through during the row, so a particle that hopped three sites leaves a\n// short step instead of a gap and its thread stays joined.\n//\n// Before the first frame the line starts as a step between the two\n// densities the ends ask for, runs 120 units to settle and then fills all\n// 128 rows, so the panel opens full.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Time units of the process per row, rows per second at Speed 1.\nconst DT = 1, RATE = 8;\n// Time run before the first row is kept, and the hue band the ids fill.\nconst SETTLE = 120, BAND = 0.42, PHI = 0.6180339887;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h), f = h - i, p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6];\n}\n\nexport function setup(params) {\n  params.s = {\n    occ: new Int32Array(W),\n    hist: new Int32Array(N),\n    trail: new Int32Array(N),\n    head: 0,\n    next: 1,\n    acc: 0,\n    alpha: 0.25,\n    beta: 0.25,\n    hue: 0,\n    ready: false,\n    pal: new Uint8Array(256 * 3),\n    palHue: -1,\n  };\n}\n\n// One row: DT units of random sequential update over the W + 1 bonds.\nfunction row(S, keep) {\n  const occ = S.occ, a = S.alpha, b = S.beta;\n  let hi = 0, ti = 0;\n  if (keep) {\n    S.head = (S.head + 1) % H;\n    hi = S.head * W;\n    for (let x = 0; x \u003c W; x++) S.trail[hi + x] = occ[x];\n    ti = hi;\n  }\n  const tries = (W + 1) * DT;\n  for (let n = 0; n \u003c tries; n++) {\n    const k = floor(Math.random() * (W + 1));\n    if (k === 0) {\n      if (occ[0] === 0 && Math.random() \u003c a) {\n        occ[0] = S.next++;\n        if (keep) S.trail[ti] = occ[0];\n      }\n    } else if (k === W) {\n      if (occ[W - 1] !== 0 && Math.random() \u003c b) occ[W - 1] = 0;\n    } else if (occ[k - 1] !== 0 && occ[k] === 0) {\n      occ[k] = occ[k - 1];\n      occ[k - 1] = 0;\n      if (keep) S.trail[ti + k] = occ[k];\n    }\n  }\n  if (keep) for (let x = 0; x \u003c W; x++) S.hist[hi + x] = occ[x];\n}\n\nfunction start(S) {\n  // A step between the two densities the boundaries ask for, then let it settle.\n  const left = S.alpha \u003c 0.5 ? S.alpha : 0.5, right = S.beta \u003c 0.5 ? 1 - S.beta : 0.5;\n  for (let x = W - 1; x >= 0; x--) S.occ[x] = Math.random() \u003c (x \u003c W / 2 ? left : right) ? S.next++ : 0;\n  for (let t = 0; t \u003c SETTLE; t++) row(S, false);\n  for (let r = 0; r \u003c H; r++) row(S, true);\n  S.ready = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.25, 0.25], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.alpha = cl(k[2] == null ? 0.25 : k[2], 0, 1);\n  S.beta = cl(k[3] == null ? 0.25 : k[3], 0, 1);\n  if (!S.ready) start(S);\n  S.acc += d * speed * RATE;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    row(S, true);\n  }\n}\n\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  for (let i = 0; i \u003c 256; i++) {\n    const f = (i * PHI) % 1;\n    const c = hsv(S.hue + 0.47 + f * BAND, 0.75, 1);\n    S.pal[i * 3] = round(c[0] * 255);\n    S.pal[i * 3 + 1] = round(c[1] * 255);\n    S.pal[i * 3 + 2] = round(c[2] * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  palette(S);\n  const pal = S.pal;\n  for (let y = 0; y \u003c H; y++) {\n    const r = ((S.head - y) % H + H) % H, o = r * W;\n    const fade = 1 - 0.35 * (y / (H - 1));\n    for (let x = 0; x \u003c W; x++) {\n      const id = S.hist[o + x], tr = S.trail[o + x];\n      let v = 0, c = 0;\n      if (id) { c = id & 255; v = fade; }\n      else if (tr) { c = tr & 255; v = fade * 0.45; }\n      if (v > 0) display.setPixel(x, y, round(pal[c * 3] * v), round(pal[c * 3 + 1] * v), round(pal[c * 3 + 2] * v));\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n  }\n}\n","fork-hologram":"// ===== Patternflow pattern =====\n// Title:   Fork Hologram\n// Family:  wave\n// Idea:    The tall panel is the fork grating you record when a beam with phase singularities meets a tilted plane wave, fine near-vertical fringes that split into l + 1 tines wherever a vortex of charge l sits, and some ten vortices of charge 1 to 7 and both signs drift over it, pull their opposites in, annihilate or leave the difference, and are born again in pairs, so forks open, merge and vanish, the crowded side of each fork tinted blue and the thinned side green.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: fork grating, the interferogram of a beam with a screw dislocation of charge l and a tilted plane wave (V. Yu. Bazhenov, M. V. Vasnetsov and M. S. Soskin, Laser beams with screw dislocations in their wavefronts, 1990), made as a binary computer-generated hologram (N. R. Heckenberg, R. McDuff, C. P. Smith and A. G. White, 1992); wave dislocations (John Nye and Michael Berry, 1974); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Charge=3..7, Carrier=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the plain grating is pale aqua, the side of a fork where the extra fringes crowd in is blue and the side where they thin out is green; at 0.3 the grating is lilac with red and blue.\n// Knob 2: Speed. At 2 the vortices drift 0.5 to 4 LEDs a second, faster as an opposite closes in, new pairs are born one every 0.6 to 1.8 s while fewer than ten vortices are left, and the fringes slide sideways 0.12 of a period a second; every time goes as 2 / Speed.\n// Knob 3: Charge. The highest charge a new pair carries: half the pairs carry it and the rest 1 up to it, so at the opening 3 the forks have 2, 3 or 4 tines and at 7 up to 8. A vortex of charge 2 or more sheds a unit vortex of its own sign, a charge 2 about every 12 s and a charge 3 every 6 s.\n// Knob 4: Carrier. The fringe period, 3.3 LEDs at the opening 0.06, 19 fringes across the panel, doubling by 0.68 and 9.4 LEDs at 1, where every tine of a fork stands apart. The fringes always lean 14 degrees.\n\n// A beam whose phase winds by 2 pi l round a point, l times atan2 about it,\n// meets a plane wave tilted by a carrier k. Where they add, the intensity\n// follows the phase difference\n//\n//   phi = 2 pi (k . r) + sum over vortices of l_j atan2(y - y_j, x - x_j),\n//\n// and the fringes are its level lines. Round a vortex phi gains 2 pi l, so\n// l more fringes cross a circle on one side of it than on the other: the\n// fork. The phases are multiplied as unit complex numbers and one atan2\n// per LED gives phi, so 10 vortices cost no more than one. The phase\n// gradient comes alongside in closed form: where it is longer than the\n// carrier the fringes crowd (blue at the opening), where shorter they thin\n// (green). At each core the beam is dark, so the fringes fade to the mean\n// within about sqrt(0.7 l) LEDs.\n//\n// Each fringe is drawn the way Heckenberg's binary holograms were cut, a\n// hard step from dark to bright, with the grey interferogram left in at\n// 35%: a triangle wave of phi runs 0 to 0.17 across a dark fringe and 0.83\n// to 1 across a bright one. The step keeps the fringes sharp; the ramp\n// keeps every LED a little different from the LED above it.\n//\n// The vortices move overdamped: opposite charges pull together and like\n// charges push apart, as 1 / r, with a slow random heading each. Opposite\n// charges that meet add up, equal ones annihilate and unequal ones leave\n// the difference. Total charge stays 0, since pairs are born as +l and -l.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, exp, pow, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Pairs kept on the panel, the margin past every edge the vortices may\n// wander into, the carrier's tilt as ky / k, the grey share of a fringe,\n// the period in LEDs at Carrier 0, the dark core's size per unit of charge.\nconst PAIRS = 5, MARGIN = 6, SLANT = 0.25, RAMP = 0.35, P0 = 3.09, CORE = 0.7;\n\nfunction vortex(x, y, l, vx, vy) {\n  return { x, y, l, vx, vy, wx: 0, wy: 0, kick: 1, age: 0 };\n}\n\nfunction charge(top) {\n  // Half the pairs carry the top charge, the rest anything from 1 up.\n  return Math.random() \u003c 0.5 ? top : 1 + floor(Math.random() * top);\n}\n\nfunction birth(S, x, y, top) {\n  const l = charge(top), a = Math.random() * TAU, v = 7;\n  S.v.push(vortex(x + cos(a) * 0.4, y + sin(a) * 0.4, l, cos(a) * v, sin(a) * v));\n  S.v.push(vortex(x - cos(a) * 0.4, y - sin(a) * 0.4, -l, -cos(a) * v, -sin(a) * v));\n}\n\nfunction seed(S, top) {\n  S.v = [];\n  for (let i = 0; i \u003c PAIRS; i++) {\n    const l = charge(top);\n    S.v.push(vortex(6 + Math.random() * 52, 6 + Math.random() * 116, l, 0, 0));\n    S.v.push(vortex(6 + Math.random() * 52, 6 + Math.random() * 116, -l, 0, 0));\n  }\n  for (const p of S.v) p.kick = 0;\n}\n\nexport function setup(params) {\n  params.s = { v: null, t: 0, hue: 0, top: 3, f: 0.31, wait: 0, slide: 0 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.top = round(cl(k[2] == null ? 3 : k[2], 3, 7));\n  S.f = 1 / (P0 * pow(2, 1.6 * cl(k[3] == null ? 0.06 : k[3], 0, 1)));\n  if (!S.v) seed(S, S.top);\n  const h = (d * speed) / 2;\n  S.t += h;\n  S.slide += h * 0.12;\n  const V = S.v;\n  // Overdamped motion: opposite charges pull together, like charges push\n  // apart, both as 1/r, and every vortex wanders on a slow random heading.\n  for (const p of V) {\n    let fx = 0, fy = 0;\n    for (const q of V) {\n      if (q === p) continue;\n      const dx = p.x - q.x, dy = p.y - q.y, r2 = dx * dx + dy * dy + 4;\n      const s = Math.sign(p.l * q.l) * sqrt(abs(p.l * q.l));\n      fx += (s * dx) / r2;\n      fy += (s * dy) / r2;\n    }\n    p.wx += (Math.random() - 0.5) * 6 * h - p.wx * 0.4 * h;\n    p.wy += (Math.random() - 0.5) * 6 * h - p.wy * 0.4 * h;\n    p.kick *= exp(-h * 1.6);\n    const ux = 9 * fx + p.wx + p.vx * p.kick, uy = 9 * fy + p.wy + p.vy * p.kick;\n    const sp = sqrt(ux * ux + uy * uy), cap = 9 / max(9, sp);\n    p.x += ux * cap * h;\n    p.y += uy * cap * h;\n    if (p.x \u003c -MARGIN) { p.x = -MARGIN; p.wx = abs(p.wx); }\n    if (p.x > W + MARGIN) { p.x = W + MARGIN; p.wx = -abs(p.wx); }\n    if (p.y \u003c -MARGIN) { p.y = -MARGIN; p.wy = abs(p.wy); }\n    if (p.y > H + MARGIN) { p.y = H + MARGIN; p.wy = -abs(p.wy); }\n    p.age += h;\n  }\n  // Opposite charges that meet add up: equal ones annihilate, unequal ones\n  // leave one vortex with the difference.\n  for (let i = 0; i \u003c V.length; i++)\n    for (let j = i + 1; j \u003c V.length; j++) {\n      const a = V[i], b = V[j];\n      if (a.l * b.l >= 0) continue;\n      const dx = a.x - b.x, dy = a.y - b.y;\n      if (dx * dx + dy * dy > 1.2) continue;\n      const l = a.l + b.l;\n      if (l === 0) {\n        V.splice(j, 1);\n        V.splice(i, 1);\n      } else {\n        const keep = abs(a.l) > abs(b.l) ? a : b;\n        keep.l = l;\n        V.splice(keep === a ? j : i, 1);\n      }\n      i = -1;\n      break;\n    }\n  // A vortex of charge 2 or more is unstable and now and then sheds a unit one.\n  for (let i = V.length - 1; i >= 0; i--) {\n    const p = V[i];\n    if (abs(p.l) > 1 && p.age > 2 && Math.random() \u003c h * 0.08 * (abs(p.l) - 1)) {\n      const s = Math.sign(p.l), a = Math.random() * TAU;\n      p.l -= s;\n      p.age = 0;\n      const q = vortex(p.x, p.y, s, cos(a) * 6, sin(a) * 6);\n      p.vx = -cos(a) * 6 / abs(p.l);\n      p.vy = -sin(a) * 6 / abs(p.l);\n      p.kick = 1;\n      V.push(q);\n    }\n  }\n  // New pairs are born out of nothing, a pair at a time.\n  S.wait -= h;\n  if (V.length \u003c 2 * PAIRS && S.wait \u003c= 0) {\n    birth(S, 8 + Math.random() * 48, 10 + Math.random() * 108, S.top);\n    S.wait = 0.6 + Math.random() * 1.2;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.v) return;\n  const V = S.v, n = V.length, f = S.f;\n  const ky = SLANT * f, kx = sqrt(f * f - ky * ky);\n  const px = new Float64Array(n), py = new Float64Array(n), pl = new Int8Array(n);\n  for (let j = 0; j \u003c n; j++) {\n    px[j] = V[j].x;\n    py[j] = V[j].y;\n    pl[j] = V[j].l;\n  }\n  const base = S.hue + 0.5, shift = S.slide;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      // The vortex phases multiplied as unit complex numbers, one atan2 at the end;\n      // the phase gradient in cycles per LED alongside, for the colour.\n      let re = 1, im = 0, gx = kx, gy = ky, c = 1;\n      for (let j = 0; j \u003c n; j++) {\n        const l = pl[j], dx = x - px[j], dy = y - py[j], r2 = dx * dx + dy * dy + 1e-6, ir = 1 / sqrt(r2);\n        const ux = dx * ir, uy = (l > 0 ? dy : -dy) * ir;\n        for (let m = l > 0 ? l : -l; m > 0; m--) {\n          const t = re * ux - im * uy;\n          im = re * uy + im * ux;\n          re = t;\n        }\n        const w = l / (TAU * r2);\n        gx -= dy * w;\n        gy += dx * w;\n        c *= r2 / (r2 + CORE * (l > 0 ? l : -l));\n      }\n      let u = kx * x + ky * y + shift + atan2(im, re) / TAU;\n      u -= floor(u);\n      const tri = 1 - abs(2 * u - 1);\n      const v = 0.5 + (RAMP * tri + (tri > 0.5 ? 1 - RAMP : 0) - 0.5) * c;\n      // Hue and saturation from how crowded the fringes are against the carrier.\n      const g = sqrt(gx * gx + gy * gy) / f - 1, ag = min(1, 4 * abs(g));\n      let h = base + (g > 0 ? 0.17 : -0.13) * ag;\n      const s = (0.3 + 0.5 * ag) * c;\n      h = (h - floor(h)) * 6;\n      const i = floor(h), q = h - i, lo = v * (1 - s), dn = v * (1 - s * q), up = v * (1 - s * (1 - q));\n      let r, gg, b;\n      if (i === 0) { r = v; gg = up; b = lo; }\n      else if (i === 1) { r = dn; gg = v; b = lo; }\n      else if (i === 2) { r = lo; gg = v; b = up; }\n      else if (i === 3) { r = lo; gg = dn; b = v; }\n      else if (i === 4) { r = up; gg = lo; b = v; }\n      else { r = v; gg = lo; b = dn; }\n      display.setPixel(x, y, round(r * 255), round(gg * 255), round(b * 255));\n    }\n  }\n}\n","lensed-page":"// ===== Patternflow pattern =====\n// Title:   Lensed Page\n// Family:  type\n// Idea:    A tall column of Newton's first Query from Opticks, set in 3 by 5 capitals, climbs past an invisible point mass in the middle of the panel, and every LED reads the page through the point-lens equation, so the lines bow into arcs round the mass, letters near it show twice, once outside the Einstein ring and once turned over inside it, and the letters right behind it spread into the ring itself.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the point-mass gravitational lens and its ring (Orest Chwolson, 1924; Albert Einstein, 1936); text from Isaac Newton, Opticks (1704), Query 1, public domain; 3 by 5 capitals drawn for this pattern; pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mass=13..29, Drift=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the ink is pale sky blue on dark blue paper, the turned-over images inside the ring are lilac, and the ink pales to white across the ring; at 0.5 the ink is peach and the inner images green.\n// Knob 2: Speed. At 2 the page climbs 5 rows a second, a line every 1.4 s and the whole 98-row page, the query and the signature, in 19.6 s, and a Drift swing takes 10 s; every time goes as 2 / Speed.\n// Knob 3: Mass. The Einstein radius in LEDs, 13 at the opening and 29 at the top, where the ring is 58 LEDs across. A letter t LEDs off the line of sight shows twice, outside the ring at (t + sqrt(t^2 + 4 E^2)) / 2 and turned over inside it at (sqrt(t^2 + 4 E^2) - t) / 2 on the far side; a line 40 LEDs from the mass is pushed 4.2 LEDs outward at 13 and 21 at 29.\n// Knob 4: Drift. Swings the mass sideways across the column, 24 LEDs times Drift each way: 1.4 at the opening 0.06, so the ring stays in the middle, and 24 at 1, where the ring runs off the side of the panel and the dark beyond the page's edge shows inside it, turned over, as a black disc.\n\n// Put the mass at the origin of the sky and the page far behind it. Light\n// that reaches the LED at angle theta from the mass passed the page at\n//\n//   beta = theta - thetaE^2 theta / |theta|^2,\n//\n// the point-lens equation (Chwolson 1924, Einstein 1936). So each LED\n// looks up the page at beta, and nothing is scattered or added up. A page\n// point at distance b from the line of sight has two images, both on the\n// line through the mass, at (b + sqrt(b^2 + 4 thetaE^2)) / 2 outside the\n// Einstein ring and (b - sqrt(b^2 + 4 thetaE^2)) / 2 inside it, on the\n// other side and turned over; the point right behind the mass is the whole\n// ring. Lensing keeps surface brightness, so the LED takes the page's\n// level as it is, bilinear between page LEDs, and a magnified letter is\n// bigger, never brighter. Inside the ring the page is shrunk: an LED at r\n// from the mass covers 1 + thetaE^2 / r^2 page LEDs radially, so it reads\n// a box-blurred copy of the page that wide instead of aliasing.\n//\n// The page is one LED to the page LED far from the mass: 16 characters of\n// 4 LEDs to a line, lines 7 rows apart, centred, the query wrapped by words\n// and the signature after it, then the same page again below. Past the\n// column's two sides there is no page, and that dark is what shows in the\n// middle of the ring, where the inner image reaches far out sideways.\n\nconst W = 64, H = 128;\nconst { floor, abs, sin, log2, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Isaac Newton, Opticks (1704), the first of the Queries.\nconst TEXT = \"QU. 1. DO NOT BODIES ACT UPON LIGHT AT A DISTANCE, AND BY THEIR ACTION BEND ITS RAYS; AND IS NOT THIS ACTION (CAETERIS PARIBUS) STRONGEST AT THE LEAST DISTANCE?\";\nconst SIGN = \"NEWTON 1704\";\n\n// Capitals, figures and stops, 3 wide and 5 tall, rows top to bottom.\nconst GLYPHS = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101110011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101111\", V: \"101101101101010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\",\n  0: \"111101101101111\", 1: \"010110010010111\", 4: \"101101111001001\", 7: \"111001010010010\",\n  \".\": \"000000000000010\", \",\": \"000000000010100\", \";\": \"000010000010100\", \"?\": \"110001010000010\",\n  \"(\": \"001010010010001\", \")\": \"100010010010100\", \" \": \"000000000000000\",\n};\n\n// Characters per line, LEDs per character and per line, page ground level.\nconst COLS = 16, ADV = 4, PITCH = 7, GROUND = 0.09, LEVELS = 5;\n\nfunction wrap(text) {\n  const lines = [];\n  let line = \"\";\n  for (const word of text.split(\" \")) {\n    if (line && line.length + 1 + word.length > COLS) {\n      lines.push(line);\n      line = word;\n    } else line = line ? line + \" \" + word : word;\n  }\n  if (line) lines.push(line);\n  return lines;\n}\n\n// The page: one copy of the query and the signature, PITCH rows a line,\n// 64 wide, repeating down. Level 1 is ink, GROUND the paper.\nfunction page() {\n  const lines = [...wrap(TEXT), \"\", SIGN, \"\"];\n  const ph = lines.length * PITCH, p = new Float32Array(W * ph).fill(GROUND);\n  lines.forEach((text, li) => {\n    const x0 = floor((W - (ADV * text.length - 1)) / 2);\n    for (let c = 0; c \u003c text.length; c++) {\n      const g = GLYPHS[text[c]] || GLYPHS[\" \"];\n      for (let r = 0; r \u003c 5; r++)\n        for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") p[(li * PITCH + 1 + r) * W + x0 + c * ADV + q] = 1;\n    }\n  });\n  return { p, ph };\n}\n\n// Box-blurred copies of the page, 2^L LEDs wide, for LEDs that see a wide\n// patch of it (the demagnified image inside the ring).\nfunction mips(p, ph) {\n  const out = [p];\n  for (let L = 1; L \u003c LEVELS; L++) {\n    const s = 1 \u003c\u003c L, a = new Float32Array(W * ph), b = new Float32Array(W * ph);\n    for (let y = 0; y \u003c ph; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let t = 0;\n        for (let i = 0; i \u003c s; i++) {\n          const xx = x + i - (s >> 1);\n          t += xx >= 0 && xx \u003c W ? p[y * W + xx] : 0;\n        }\n        a[y * W + x] = t / s;\n      }\n    for (let y = 0; y \u003c ph; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let t = 0;\n        for (let i = 0; i \u003c s; i++) t += a[(((y + i - (s >> 1)) % ph) + ph) % ph * W + x];\n        b[y * W + x] = t / s;\n      }\n    out.push(b);\n  }\n  return out;\n}\n\n// Bilinear sample: x off the page is dark, y wraps.\nfunction sample(p, ph, x, y) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  const ya = ((y0 % ph) + ph) % ph, yb = ya + 1 === ph ? 0 : ya + 1;\n  const a0 = x0 >= 0 && x0 \u003c W ? p[ya * W + x0] : 0, a1 = x0 + 1 >= 0 && x0 + 1 \u003c W ? p[ya * W + x0 + 1] : 0;\n  const b0 = x0 >= 0 && x0 \u003c W ? p[yb * W + x0] : 0, b1 = x0 + 1 >= 0 && x0 + 1 \u003c W ? p[yb * W + x0 + 1] : 0;\n  return (a0 + (a1 - a0) * fx) * (1 - fy) + (b0 + (b1 - b0) * fx) * fy;\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nexport function setup(params) {\n  const { p, ph } = page();\n  params.s = { mip: mips(p, ph), ph, scroll: 20, swing: 0, hue: 0, mass: 13, drift: 0.06 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 13, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.mass = cl(k[2] == null ? 13 : k[2], 13, 29);\n  S.drift = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.scroll = (S.scroll + d * speed * 2.5) % S.ph;\n  S.swing = (S.swing + (d * speed * TAU) / 20) % TAU;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { mip, ph } = S, e2 = S.mass * S.mass;\n  const lx = W / 2 + S.drift * 24 * sin(S.swing), ly = H / 2;\n  // Ink is the page colour outside the ring and turned inside it, paling to\n  // white at the ring; the paper keeps the page colour everywhere.\n  const out = hsv(S.hue + 0.56, 0.5, 1), inn = hsv(S.hue + 0.86, 0.5, 1), paper = hsv(S.hue + 0.56, 0.65, 1);\n  const rim = [], inner = [];\n  for (let i = 0; i \u003c= 10; i++) {\n    rim.push(hsv(S.hue + 0.56, 0.05 * i, 1));\n    inner.push(hsv(S.hue + 0.86, 0.05 * i, 1));\n  }\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      // Point lens: the LED at theta from the mass sees the page at\n      // beta = theta (1 - thetaE^2 / |theta|^2).\n      const tx = x - lx, ty = y - ly, r2 = tx * tx + ty * ty + 1e-6, k = 1 - e2 / r2;\n      const sx = lx + tx * k, sy = ly + ty * k + S.scroll;\n      // How many LEDs of page the LED spans radially: 1 + thetaE^2 / r^2.\n      const span = 1 + e2 / r2, lev = cl(log2(span) - 1, 0, LEVELS - 1.001), L0 = floor(lev), fl = lev - L0;\n      let v = sample(mip[L0], ph, sx, sy);\n      if (fl > 0) v += (sample(mip[L0 + 1], ph, sx, sy) - v) * fl;\n      // Outer images keep the page colour, the inverted inner images turn,\n      // and the ring between them goes white.\n      const t = (r2 - e2) / (r2 + e2), ink = cl((v - GROUND) / (1 - GROUND), 0, 1);\n      const c = t > 0 ? (abs(t) \u003c 0.2 ? rim[round(abs(t) * 50)] : out) : abs(t) \u003c 0.2 ? inner[round(abs(t) * 50)] : inn;\n      const s = 255 * v;\n      display.setPixel(x, y, round((paper[0] + (c[0] - paper[0]) * ink) * s), round((paper[1] + (c[1] - paper[1]) * ink) * s), round((paper[2] + (c[2] - paper[2]) * ink) * s));\n    }\n  }\n}\n","letter-retracts":"// ===== Patternflow pattern =====\n// Title:   Letter Retracts\n// Family:  type\n// Idea:    Three bold capitals stacked down the tall panel thin layer by layer to their skeletons without ever opening or closing a hole, then lose their free ends one LED at a time, so each letter shrinks onto its homotopy type, a point for X, T or Y, one loop round the counter for O, A or D and two loops for B, coloured by that hole count, and from those few LEDs the next word of the same classes grows.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: deformation retract and homotopy type (Karol Borsuk, 1931); parallel thinning in two subiterations (T. Y. Zhang and C. Y. Suen, 1984), in the version of Zicheng Guo and Richard W. Hall (1989); simple points (Shigeru Yokoi, Jun-ichiro Toriwaki and Teruo Fukumura, 1975); capitals drawn for this pattern; pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Weight=0..1\n//\n// Knob 1: Hue. Turns the three class colours round the wheel together. At 0 a letter with no hole is green, with one hole sky blue and with two holes magenta; at 0.5 they are violet, red-orange and green.\n// Knob 2: Speed. At 2 a letter loses one layer of thinning every 0.16 s and one LED off each free end every 0.1 s, so BOX retracts in 3.3 s and BAG in 6.6 s; every time goes as 2 / Speed.\n// Knob 3: Set. Four lists of words whose letters keep the same hole counts, so each word grows out of the last one's points and loops: 0 BOX, BAT, BAG, BOY (two, one, none); 1 DOG, ROT, PAL, DOT (one, one, none); 2 KEY, LEG, YET, ZEN (none); 3 ROD, POD, PRO, ODD (one each).\n// Knob 4: Weight. Stroke width, 7 LEDs at 0 to 11.5 at 1 (7.5 at the opening 0.06): the bolder the letter, the more layers it loses before its skeleton shows, 11 for B at the opening and 17 at 1.\n\n// Each letter is drawn as round-ended strokes in a 48 by 40 box and lit\n// where an LED centre is within half the weight of a stroke. Then it is\n// taken apart and every LED remembers the step at which it went:\n//\n// 1. Thinning, Guo and Hall's two subiterations, each one step, shown\n//    1.6 times as long as a pruning step. A pixel goes when it has one\n//    run of neighbours, two or three neighbouring pairs and does not face\n//    the side the subiteration keeps; that peels the strokes from both\n//    sides down to one LED wide, keeps every hole and keeps every free\n//    end.\n// 2. Pruning. At each step every pixel that is simple for 8-connected\n//    letters on 4-connected ground, Yokoi's connectivity number 1, is\n//    taken, rechecked as it goes. On a one-LED skeleton only the free\n//    ends are simple, so every branch loses one LED a step. A pixel on\n//    a loop is never simple, since taking it would join the hole to the\n//    ground; a single pixel is not either.\n//\n// What is left cannot shrink further without changing the topology: one\n// pixel, one loop, or two loops sharing an arc. The number of holes, the\n// 4-connected pieces of ground the letter closes off, is counted once for\n// the colour and is the same at every step.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Glyph strokes in a unit box, v downwards: [x0, y0, x1, y1] segments and\n// [cx, cy, rx, ry, from, to] elliptic arcs in degrees (0 right, 90 down).\n// The first number of each entry is the glyph's width in the box.\nconst GLYPHS = {\n  A: [1, [0, 1, 0.5, 0], [0.5, 0, 1, 1], [0.15, 0.7, 0.85, 0.7]],\n  B: [0.9, [0, 0, 0, 1], [0, 0, 0.58, 0], [0.58, 0.235, 0.34, 0.235, -90, 90], [0.58, 0.47, 0, 0.47], [0, 0.47, 0.62, 0.47], [0.62, 0.735, 0.38, 0.265, -90, 90], [0.62, 1, 0, 1]],\n  D: [0.9, [0, 0, 0, 1], [0, 0, 0.42, 0], [0.42, 0.5, 0.58, 0.5, -90, 90], [0.42, 1, 0, 1]],\n  E: [0.78, [0, 0, 0, 1], [0, 0, 1, 0], [0, 0.5, 0.85, 0.5], [0, 1, 1, 1]],\n  G: [0.95, [0.5, 0.5, 0.5, 0.5, 25, 310], [0.52, 0.56, 1, 0.56], [1, 0.56, 0.953, 0.711]],\n  K: [0.88, [0, 0, 0, 1], [1, 0, 0, 0.64], [0.32, 0.435, 1, 1]],\n  L: [0.72, [0, 0, 0, 1], [0, 1, 1, 1]],\n  N: [0.9, [0, 1, 0, 0], [0, 0, 1, 1], [1, 1, 1, 0]],\n  O: [0.95, [0.5, 0.5, 0.5, 0.5, 0, 360]],\n  P: [0.85, [0, 0, 0, 1], [0, 0, 0.52, 0], [0.52, 0.28, 0.48, 0.28, -90, 90], [0.52, 0.56, 0, 0.56]],\n  R: [0.9, [0, 0, 0, 1], [0, 0, 0.5, 0], [0.5, 0.27, 0.46, 0.27, -90, 90], [0.5, 0.54, 0, 0.54], [0.42, 0.54, 1, 1]],\n  T: [0.95, [0, 0, 1, 0], [0.5, 0, 0.5, 1]],\n  X: [0.95, [0, 0, 1, 1], [1, 0, 0, 1]],\n  Y: [0.95, [0, 0, 0.5, 0.52], [1, 0, 0.5, 0.52], [0.5, 0.52, 0.5, 1]],\n  Z: [0.85, [0, 0, 1, 0], [1, 0, 0, 1], [0, 1, 1, 1]],\n};\n\nconst SETS = [\n  [\"BOX\", \"BAT\", \"BAG\", \"BOY\"],\n  [\"DOG\", \"ROT\", \"PAL\", \"DOT\"],\n  [\"KEY\", \"LEG\", \"YET\", \"ZEN\"],\n  [\"ROD\", \"POD\", \"PRO\", \"ODD\"],\n];\n\n// Letter boxes: 48 wide by 40 tall, three down the panel.\nconst BW = 48, BH = 40, BX = 3, BY = [2, 44, 86];\n// The sign of each letter's homotopy type stands at this column.\nconst SX = 57.5;\nconst KEEP = 32767;\n\n// Segments of a glyph in LED coordinates for a stroke radius r.\nfunction segmentsOf(ch, r) {\n  const g = GLYPHS[ch], gw = g[0];\n  const w = (BW - 2 * r) * gw, h = BH - 2 * r, ox = (BW - w) / 2, oy = r;\n  const P = (u, v) => [ox + u * w, oy + v * h];\n  const out = [];\n  for (let i = 1; i \u003c g.length; i++) {\n    const s = g[i];\n    if (s.length === 4) out.push([...P(s[0], s[1]), ...P(s[2], s[3])]);\n    else {\n      const n = max(8, round(abs(s[5] - s[4]) / 7.5));\n      let prev = null;\n      for (let j = 0; j \u003c= n; j++) {\n        const t = ((s[4] + ((s[5] - s[4]) * j) / n) * PI) / 180;\n        const q = P(s[0] + s[2] * cos(t), s[1] + s[3] * sin(t));\n        if (prev) out.push([...prev, ...q]);\n        prev = q;\n      }\n    }\n  }\n  return out;\n}\n\nfunction rasterize(ch, r) {\n  const segs = segmentsOf(ch, r), img = new Uint8Array(BW * BH), r2 = r * r;\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c BW; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      for (const [x0, y0, x1, y1] of segs) {\n        const dx = x1 - x0, dy = y1 - y0, L = dx * dx + dy * dy;\n        const t = L > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / L, 0, 1) : 0;\n        const ex = px - x0 - t * dx, ey = py - y0 - t * dy;\n        if (ex * ex + ey * ey \u003c= r2) {\n          img[y * BW + x] = 1;\n          break;\n        }\n      }\n    }\n  return img;\n}\n\n// Neighbours of (x, y) in the box, outside counts as ground.\nconst at = (img, x, y) => (x \u003c 0 || y \u003c 0 || x >= BW || y >= BH ? 0 : img[y * BW + x]);\n\n// Yokoi's 8-connectivity number: 1 for a simple pixel or a free end.\nfunction simple(img, x, y) {\n  const n = [at(img, x + 1, y), at(img, x + 1, y - 1), at(img, x, y - 1), at(img, x - 1, y - 1), at(img, x - 1, y), at(img, x - 1, y + 1), at(img, x, y + 1), at(img, x + 1, y + 1)];\n  let c = 0;\n  for (let k = 0; k \u003c 8; k += 2) {\n    const a = 1 - n[k], b = 1 - n[k + 1], d = 1 - n[(k + 2) & 7];\n    c += a - a * b * d;\n  }\n  return c === 1;\n}\n\n// Pieces of 4-connected ground that do not reach the box edge.\nfunction holes(img) {\n  const seen = new Uint8Array(BW * BH), stack = [];\n  let count = 0;\n  for (let s = 0; s \u003c BW * BH; s++) {\n    if (img[s] || seen[s]) continue;\n    let edge = false;\n    stack.push(s);\n    seen[s] = 1;\n    while (stack.length) {\n      const p = stack.pop(), x = p % BW, y = (p / BW) | 0;\n      if (x === 0 || y === 0 || x === BW - 1 || y === BH - 1) edge = true;\n      for (const [nx, ny] of [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]) {\n        if (nx \u003c 0 || ny \u003c 0 || nx >= BW || ny >= BH) continue;\n        const q = ny * BW + nx;\n        if (!img[q] && !seen[q]) {\n          seen[q] = 1;\n          stack.push(q);\n        }\n      }\n    }\n    if (!edge) count++;\n  }\n  return count;\n}\n\n// Takes a letter apart: the step each pixel goes at, KEEP for what stays.\nfunction retract(ch, r) {\n  const img = rasterize(ch, r), N = BW * BH;\n  const gone = new Int16Array(N).fill(-1);\n  for (let p = 0; p \u003c N; p++) if (img[p]) gone[p] = KEEP;\n  const kind = holes(img);\n  let step = 0;\n  const mark = [];\n  // Thinning, Guo and Hall.\n  for (let pass = 0, any = 0; pass \u003c 200; pass++) {\n    const iter = pass & 1;\n    if (!iter) any = 0;\n    mark.length = 0;\n    for (let y = 0; y \u003c BH; y++)\n      for (let x = 0; x \u003c BW; x++) {\n        if (!img[y * BW + x]) continue;\n        const p2 = at(img, x, y - 1), p3 = at(img, x + 1, y - 1), p4 = at(img, x + 1, y), p5 = at(img, x + 1, y + 1);\n        const p6 = at(img, x, y + 1), p7 = at(img, x - 1, y + 1), p8 = at(img, x - 1, y), p9 = at(img, x - 1, y - 1);\n        const C = (!p2 & (p3 | p4)) + (!p4 & (p5 | p6)) + (!p6 & (p7 | p8)) + (!p8 & (p9 | p2));\n        const N1 = (p9 | p2) + (p3 | p4) + (p5 | p6) + (p7 | p8), N2 = (p2 | p3) + (p4 | p5) + (p6 | p7) + (p8 | p9);\n        const n = min(N1, N2);\n        const m = iter === 0 ? (p6 | p7 | !p9) & p8 : (p2 | p3 | !p5) & p4;\n        if (C === 1 && n >= 2 && n \u003c= 3 && m === 0) mark.push(y * BW + x);\n      }\n    if (!mark.length) {\n      if (iter === 1 && !any) break;\n      continue;\n    }\n    any = 1;\n    step++;\n    for (const p of mark) {\n      img[p] = 0;\n      gone[p] = step;\n    }\n  }\n  const thin = step;\n  // Pruning: every simple pixel of the step before goes, if still simple.\n  for (;;) {\n    mark.length = 0;\n    for (let p = 0; p \u003c N; p++) if (img[p] && simple(img, p % BW, (p / BW) | 0)) mark.push(p);\n    if (!mark.length) break;\n    step++;\n    let took = 0;\n    for (const p of mark)\n      if (simple(img, p % BW, (p / BW) | 0)) {\n        img[p] = 0;\n        gone[p] = step;\n        took++;\n      }\n    if (!took) {\n      step--;\n      break;\n    }\n  }\n  let point = -1;\n  if (!kind) for (let p = 0; p \u003c N; p++) if (gone[p] === KEEP) point = p;\n  return { gone, kind, thin, last: step, point, end: SLOW * thin + step - thin };\n}\n\n// A thinning layer takes SLOW times as long as a pruning step.\nconst SLOW = 1.6;\nconst stepAt = (L, tau) => (tau \u003c SLOW * L.thin ? tau / SLOW : L.thin + tau - SLOW * L.thin);\n\nfunction wordOf(text, r) {\n  const letters = [...text].map((ch) => retract(ch, r));\n  return { text, letters, last: max(...letters.map((l) => l.end)) };\n}\n\nconst hsv = (h, s, v) => {\n  h = ((h % 1) + 1) % 1;\n  const i = floor(h * 6), f = h * 6 - i;\n  const p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6];\n};\n// Class hues: no hole green, one hole sky blue, two holes magenta.\nconst HUES = [0.3, 0.56, 0.86];\n\n// Phases of one word, in steps: grow from the points and loops, stand,\n// retract, rest, then cross to the next word's points and loops.\nconst STAND = 10, REST = 12, CROSS = 6;\n\nexport function setup(params) {\n  params.s = { set: -1, weight: -1, index: 0, word: null, next: null, phase: \"stand\", t: 0, clock: 0, hue: 0 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const set = round(cl(k[2] || 0, 0, 3));\n  const r = round((3.5 + 2.25 * cl(k[3] == null ? 0.06 : k[3], 0, 1)) * 4) / 4;\n  const list = SETS[set];\n  if (set !== S.set) {\n    S.set = set;\n    S.index = 0;\n    S.weight = r;\n    S.word = wordOf(list[0], r);\n    S.next = wordOf(list[1], r);\n    S.phase = \"stand\";\n    S.t = 0;\n  } else if (r !== S.weight) {\n    S.weight = r;\n    S.word = wordOf(list[S.index], r);\n    S.next = wordOf(list[(S.index + 1) % list.length], r);\n  }\n  S.clock += d * speed;\n  let left = d * speed * 5;\n  // Walk the phases with the steps this frame has.\n  while (left > 0) {\n    const w = S.word;\n    if (S.phase === \"grow\") {\n      const go = min(left * 1.5, S.t);\n      S.t -= go;\n      left -= go / 1.5;\n      if (S.t \u003c= 0) (S.phase = \"stand\"), (S.t = 0);\n    } else if (S.phase === \"stand\") {\n      const go = min(left, STAND - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= STAND) (S.phase = \"retract\"), (S.t = 0);\n    } else if (S.phase === \"retract\") {\n      const go = min(left, w.last - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= w.last) (S.phase = \"rest\"), (S.t = 0);\n    } else if (S.phase === \"rest\") {\n      const go = min(left, REST - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= REST) (S.phase = \"cross\"), (S.t = 0);\n    } else {\n      const go = min(left, CROSS - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= CROSS) {\n        S.index = (S.index + 1) % list.length;\n        S.word = S.next;\n        S.next = wordOf(list[(S.index + 1) % list.length], S.weight);\n        S.phase = \"grow\";\n        S.t = S.word.last;\n      }\n    }\n  }\n}\n\n// One word at retraction step tau, faded by f, into the frame.\nfunction paint(frame, word, tau, f, S, glow) {\n  const pulse = 0.75 + 0.25 * sin(S.clock * 4);\n  for (let li = 0; li \u003c 3; li++) {\n    const L = word.letters[li], hue = HUES[L.kind] + S.hue, oy = BY[li];\n    const body = hsv(hue, 0.85, 1), ghost = hsv(hue, 0.45, 0.2), tip = hsv(hue, 0.25, 1);\n    const st = stepAt(L, tau), pruning = st > L.thin;\n    for (let y = 0; y \u003c BH; y++)\n      for (let x = 0; x \u003c BW; x++) {\n        const g = L.gone[y * BW + x];\n        if (g \u003c 0) continue;\n        let c, a;\n        if (g === KEEP) {\n          // What stays: brighter once nothing else is left.\n          const done = st >= L.last;\n          c = done ? hsv(hue, 0.6, glow ? pulse : 1) : body;\n          a = 1;\n        } else if (g > st + 1) {\n          c = body;\n          // A soft depth: pixels that go late are brighter.\n          a = 0.62 + (0.38 * min(g, L.thin + 1)) / (L.thin + 1);\n        } else if (g > st) {\n          // The layer or end that goes next, fading out.\n          c = pruning ? tip : body;\n          a = 0.2 + 0.8 * (g - st);\n        } else {\n          c = ghost;\n          a = 1;\n        }\n        const p = ((oy + y) * W + BX + x) * 3;\n        frame[p] += c[0] * a * f;\n        frame[p + 1] += c[1] * a * f;\n        frame[p + 2] += c[2] * a * f;\n      }\n    // Beside the letter, the sign of what it retracts to: a dot, a ring, or\n    // two rings that touch. Dim until the letter gets there.\n    {\n      const there = st >= L.last, c = hsv(hue, 0.55, 1), sy = oy + BH / 2;\n      const a0 = (there ? (glow ? pulse : 1) : 0.3) * f;\n      for (let y = -6; y \u003c= 6; y++)\n        for (let x = -4; x \u003c= 4; x++) {\n          const px = floor(SX) + x + 0.5 - SX, py = y;\n          let a = 0;\n          if (L.kind === 0) a = max(0, 1 - sqrt(px * px + py * py) / 1.6);\n          else if (L.kind === 1) a = max(0, 1 - abs(sqrt(px * px + py * py) - 3.2) / 0.7);\n          else {\n            const d1 = abs(sqrt(px * px + (py + 2.6) ** 2) - 2.6), d2 = abs(sqrt(px * px + (py - 2.6) ** 2) - 2.6);\n            a = max(0, 1 - min(d1, d2) / 0.7);\n          }\n          if (!a) continue;\n          const p = ((sy + y) * W + floor(SX) + x) * 3;\n          frame[p] += c[0] * a * a0;\n          frame[p + 1] += c[1] * a * a0;\n          frame[p + 2] += c[2] * a * a0;\n        }\n    }\n    // A point is one LED, so it gets a halo once it is all that is left.\n    if (L.point >= 0 && st >= L.last) {\n      const px = L.point % BW, py = (L.point / BW) | 0, c = hsv(hue, 0.5, 1);\n      for (let dy = -3; dy \u003c= 3; dy++)\n        for (let dx = -3; dx \u003c= 3; dx++) {\n          const d = sqrt(dx * dx + dy * dy);\n          if (!d || d > 3.2) continue;\n          const a = 0.5 * (1 - d / 3.4) * (glow ? pulse : 1) * f, p = ((oy + py + dy) * W + BX + px + dx) * 3;\n          frame[p] += c[0] * a;\n          frame[p + 1] += c[1] * a;\n          frame[p + 2] += c[2] * a;\n        }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.word) return;\n  const frame = (S.frame = S.frame || new Float32Array(W * H * 3));\n  frame.fill(0);\n  if (S.phase === \"grow\") paint(frame, S.word, S.t, 1, S, false);\n  else if (S.phase === \"stand\") paint(frame, S.word, 0, 1, S, false);\n  else if (S.phase === \"retract\") paint(frame, S.word, S.t, 1, S, false);\n  else if (S.phase === \"rest\") paint(frame, S.word, S.word.last, 1, S, true);\n  else {\n    const f = S.t / CROSS;\n    paint(frame, S.word, S.word.last, 1 - f, S, true);\n    paint(frame, S.next, S.next.last, f, S, true);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3;\n      display.setPixel(x, y, round(min(1, frame[p]) * 255), round(min(1, frame[p + 1]) * 255), round(min(1, frame[p + 2]) * 255));\n    }\n}\n","noordzij-cube":"// ===== Patternflow pattern =====\n// Title:   Noordzij Cube\n// Family:  type\n// Idea:    A pen writes three lowercase words down the panel stroke by stroke, and the width at every point of every stroke comes from Gerrit Noordzij's two kinds of contrast, the broad nib's translation, thick or thin by the stroke's direction against the nib, and the pointed pen's expansion, swelling on the downstrokes, so turning the knobs moves the whole page across his cube on one unchanged skeleton.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the theory of the stroke and its cube of contrast, translation, expansion and the amount of contrast (Gerrit Noordzij, De streek, 1985; The stroke: theory of writing, 2005); lowercase skeletons drawn for this pattern, pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Model=0..1, Hairline=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel. At 0 every stroke runs from cyan where the pen comes down to violet where it lifts, deep where the ink is thick and pale in a hairline.\n// Knob 2: Speed. At 2 the pen moves 44 LEDs a second, a page of three words takes 17 to 19 s and holds for 2.5 s before it fades; at 0.2 the pen is ten times slower.\n// Knob 3: Model. Where the page stands between translation at 0, a broad nib held at 30 degrees, thickest across the nib and thinnest along it, and expansion at 1, a pointed pen that swells on every downstroke and runs thin up and across. The skeleton and the order of the strokes never change.\n// Knob 4: Hairline. The thinnest stroke as a share of the thickest, which is 4.8 LEDs, the amount of contrast read the other way: at the opening 0.06 a hairline is the floor of 0.8 LED; at 1 every stroke is 4.8 LEDs and translation and expansion give the same letters, the edge of the cube where there is no contrast to tell them apart.\n\n// Noordzij reads every contrast in written letters as the trace of a pen.\n// A broad nib moved without turning, translation, leaves its full width\n// where it travels across its edge and a hairline where it travels along\n// it, so the thick and thin of a letter follow the direction of each stroke\n// and the angle of the nib. A pointed flexible nib, expansion, is thin until\n// it is pressed, and the hand presses on the way down, so the thick falls on\n// the downstrokes and swells in and out. His cube sets these two models on\n// one edge, the amount of contrast on another, and interrupted against\n// running construction on the third. Here the third stays interrupted: the\n// pen lifts between the strokes of a letter and the letters do not join.\n//\n// Every letter is one centreline, written in order and in one direction.\n// Each point of it carries both widths, worked out once: the broad nib's\n// |sin(direction - 30 degrees)| and the pointed pen's pressure, the share of\n// the stroke's motion that runs down, smoothed forwards and backwards over\n// 3.2 LEDs so it comes and goes. Model blends the two, Hairline sets how\n// thin the thinnest is, and a round soft-edged pen of that width inks the\n// line. Nothing about the letters changes but those two numbers.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Skeleton lowercase in a box 7 wide, y down from the x-line at 0 to the\n// base line at 10, ascender to -6.5 and descender to 16.5: the strokes in\n// the order and direction a hand writes them. M moves, L draws a line, and\n// E cx cy rx ry a0 a1 an arc of an ellipse from angle a0 to a1 in degrees\n// (0 right, 90 down), so a falling angle runs anticlockwise on the panel.\nconst GLYPHS = {\n  a: \"E3.5 5 3.5 5 330 30|M7 0L7 10\",\n  b: \"M0 -6.5L0 10|E3.5 5 3.5 5 205 515\",\n  e: \"M0.2 5L7 5E3.5 5 3.5 5 0 -318\",\n  g: \"E3.5 5 3.5 5 330 30|M7 0L7 12.5E3.5 12.5 3.5 4 0 165\",\n  n: \"M0 0L0 10|E3.5 3.6 3.5 3.6 180 360L7 10\",\n  o: \"E3.5 5 3.5 5 290 -66\",\n};\nconst PAGES = [\n  [\"nano\", \"bone\", \"ego\"],\n  [\"oboe\", \"nag\", \"eon\"],\n];\n// LEDs per unit across and down, the space between letters in LEDs, the\n// thickest stroke, the nib angle and the length over which a pointed pen's\n// pressure comes and goes, in LEDs.\nconst KX = 1.38, KY = 2.1, GAP = 6.5, THICK = 4.8, NIB = (30 * PI) / 180, SWELL = 3.2;\n\nfunction parse(src) {\n  return src.split(\"|\").map((s) => {\n    const tk = s.match(/[MLE]|-?[\\d.]+/g), pts = [];\n    for (let i = 0; i \u003c tk.length; ) {\n      const c = tk[i++];\n      if (c === \"M\" || c === \"L\") pts.push([+tk[i++], +tk[i++]]);\n      else {\n        const [cx, cy, rx, ry, a0, a1] = tk.slice(i, i + 6).map(Number);\n        i += 6;\n        const n = ceil(abs(a1 - a0) / 6);\n        for (let j = 0; j \u003c= n; j++) {\n          const a = ((a0 + ((a1 - a0) * j) / n) * PI) / 180;\n          pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n        }\n      }\n    }\n    return pts;\n  });\n}\nconst FONT = {};\nfor (const c in GLYPHS) FONT[c] = parse(GLYPHS[c]);\n\n// A stroke in LEDs, cut into steps of at most an LED. For each point:\n// tr, the width a broad nib at NIB leaves, |sin(direction - nib)|, and ex,\n// the pressure on a pointed pen: how much the stroke runs down, smoothed\n// along it forwards and backwards so it swells in and out.\nfunction stroke(pts) {\n  const P = [];\n  for (let i = 0; i \u003c pts.length; i++) {\n    if (!i) {\n      P.push(pts[0]);\n      continue;\n    }\n    const [qx, qy] = P[P.length - 1], [px, py] = pts[i], n = ceil(sqrt((px - qx) ** 2 + (py - qy) ** 2));\n    for (let j = 1; j \u003c= n; j++) P.push([qx + ((px - qx) * j) / n, qy + ((py - qy) * j) / n]);\n  }\n  const n = P.length, xy = new Float32Array(2 * n), cum = new Float32Array(n), tr = new Float32Array(n), ex = new Float32Array(n);\n  const raw = new Float32Array(n), fw = new Float32Array(n);\n  for (let i = 0; i \u003c n; i++) {\n    xy[2 * i] = P[i][0];\n    xy[2 * i + 1] = P[i][1];\n    if (i) cum[i] = cum[i - 1] + sqrt((P[i][0] - P[i - 1][0]) ** 2 + (P[i][1] - P[i - 1][1]) ** 2);\n    const a = P[max(0, i - 1)], b = P[min(n - 1, i + 1)], dx = b[0] - a[0], dy = b[1] - a[1], L = sqrt(dx * dx + dy * dy) || 1;\n    // The direction with y up, as the nib angle is measured.\n    tr[i] = abs(sin(atan2(-dy, dx) - NIB));\n    raw[i] = max(0, dy / L);\n  }\n  for (let i = 0, f = 0; i \u003c n; i++) {\n    const k = 1 - exp(-(i ? cum[i] - cum[i - 1] : 1) / SWELL);\n    f += (raw[i] - f) * k;\n    fw[i] = f;\n  }\n  for (let i = n - 1, f = 0; i >= 0; i--) {\n    const k = 1 - exp(-(i \u003c n - 1 ? cum[i + 1] - cum[i] : 1) / SWELL);\n    f += (raw[i] - f) * k;\n    ex[i] = min(fw[i], f) ** 0.8;\n  }\n  return { xy, cum, tr, ex, len: cum[n - 1] };\n}\n\n// One page: each word on a line of its own, centred, the lines spread\n// evenly down the panel by their ascenders and descenders.\nfunction layout(words) {\n  const lines = words.map((w) => ({\n    w,\n    up: /b/.test(w) ? 6.5 : 0,\n    down: /g/.test(w) ? 6.5 : 0,\n    width: w.length * 7 * KX + (w.length - 1) * GAP,\n  }));\n  const tall = lines.reduce((s, l) => s + (10 + l.up + l.down) * KY, 0), gap = (H - tall) / (lines.length + 1);\n  const strokes = [], guides = [];\n  let y = gap;\n  for (const l of lines) {\n    const top = y + l.up * KY;\n    let x = (W - 1 - l.width) / 2;\n    for (const c of l.w) {\n      for (const pts of FONT[c]) strokes.push(stroke(pts.map(([u, v]) => [x + u * KX, top + v * KY])));\n      x += 7 * KX + GAP;\n    }\n    guides.push(Math.round(top), Math.round(top + 10 * KY));\n    y += (10 + l.up + l.down) * KY + gap;\n  }\n  return { strokes, guides };\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nexport function setup(params) {\n  params.nc = {\n    page: -1, strokes: [], guides: [], si: 0, d: 0, mode: \"lift\", lift: 0, liftT: 0.1, from: [32, -6], to: [32, -6], pen: [32, -6], timer: 0, fade: 1, started: false,\n    hue: 0, speed: 2, model: 0, hair: 0.06,\n    cov: new Float32Array(N), fat: new Float32Array(N), pos: new Float32Array(N), out: new Float32Array(N * 3),\n  };\n}\n\nfunction nextPage(B) {\n  B.page = (B.page + 1) % PAGES.length;\n  const L = layout(PAGES[B.page]);\n  B.strokes = L.strokes;\n  B.guides = L.guides;\n  B.si = 0;\n  B.d = 0;\n  B.fade = 1;\n  startLift(B);\n}\n\nfunction startLift(B) {\n  const s = B.strokes[B.si];\n  B.mode = \"lift\";\n  B.from = [B.pen[0], B.pen[1]];\n  B.to = [s.xy[0], s.xy[1]];\n  B.lift = 0;\n  B.liftT = max(0.08, sqrt((B.to[0] - B.from[0]) ** 2 + (B.to[1] - B.from[1]) ** 2) / (3 * rate(B)));\n}\n\nconst rate = (B) => 22 * B.speed;\n\n// The point at distance d along a stroke.\nfunction at(s, d) {\n  const n = s.cum.length;\n  if (d >= s.len) return [s.xy[2 * n - 2], s.xy[2 * n - 1]];\n  let i = 0;\n  while (i \u003c n - 2 && s.cum[i + 1] \u003c d) i++;\n  const f = (d - s.cum[i]) / max(1e-6, s.cum[i + 1] - s.cum[i]);\n  return [s.xy[2 * i] + (s.xy[2 * i + 2] - s.xy[2 * i]) * f, s.xy[2 * i + 1] + (s.xy[2 * i + 3] - s.xy[2 * i + 1]) * f];\n}\n\nfunction step(B, dt) {\n  if (B.mode === \"write\") {\n    const s = B.strokes[B.si];\n    B.d += rate(B) * dt;\n    B.pen = at(s, B.d);\n    if (B.d >= s.len) {\n      B.si++;\n      if (B.si \u003c B.strokes.length) startLift(B);\n      else (B.mode = \"hold\"), (B.timer = 2.5);\n    }\n  } else if (B.mode === \"lift\") {\n    B.lift = min(1, B.lift + dt / B.liftT);\n    const e = B.lift * B.lift * (3 - 2 * B.lift);\n    B.pen = [B.from[0] + (B.to[0] - B.from[0]) * e, B.from[1] + (B.to[1] - B.from[1]) * e];\n    if (B.lift >= 1) (B.mode = \"write\"), (B.d = 0);\n  } else if (B.mode === \"hold\") {\n    B.timer -= (dt * B.speed) / 2;\n    if (B.timer \u003c= 0) (B.mode = \"fade\"), (B.timer = 0.8);\n  } else {\n    B.timer -= dt;\n    B.fade = max(0, B.timer / 0.8);\n    if (B.timer \u003c= 0) nextPage(B);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.nc) setup(params);\n  const B = params.nc, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  B.hue = k[0] || 0;\n  B.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  B.model = cl(k[2] || 0, 0, 1);\n  B.hair = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (!B.started) {\n    // The panel opens 13.5 s into the page: at Speed 2 the pen has written\n    // all but the last word.\n    B.started = true;\n    nextPage(B);\n    for (let i = 0; i \u003c 405; i++) step(B, 1 / 30);\n  }\n  step(B, dt);\n}\n\n// The width of a stroke at a point: the two models blended by Model, the\n// result laid between the hairline and the thickest stroke.\nfunction width(B, s, i) {\n  const f = (1 - B.model) * s.tr[i] + B.model * s.ex[i], w = max(0.8, THICK * (B.hair + (1 - B.hair) * f));\n  return [w, w / THICK];\n}\n\n// Ink one piece of a stroke with a round pen whose radius runs from ra to\n// rb along it, its edge softened over one LED. fat keeps how thick the\n// stroke is there and pos how far along it, from 0 to 1, for the colour.\nfunction piece(B, ax, ay, bx, by, ra, rb, fa, fb, ua, ub) {\n  const r = max(ra, rb) + 1;\n  const x0 = max(0, floor(min(ax, bx) - r)), x1 = min(W - 1, ceil(max(ax, bx) + r));\n  const y0 = max(0, floor(min(ay, by) - r)), y1 = min(H - 1, ceil(max(ay, by) + r));\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1e-9, { cov, fat, pos } = B;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const t = cl(((x - ax) * dx + (y - ay) * dy) / L2, 0, 1), ex = x - ax - t * dx, ey = y - ay - t * dy;\n      const c = cl(ra + (rb - ra) * t - sqrt(ex * ex + ey * ey) + 0.5, 0, 1);\n      const p = y * W + x;\n      if (c > cov[p]) {\n        cov[p] = c;\n        fat[p] = fa + (fb - fa) * t;\n        pos[p] = ua + (ub - ua) * t;\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const B = params.nc;\n  if (!B || !B.started) return;\n  const { cov, fat } = B;\n  cov.fill(0);\n  const done = B.mode === \"write\" ? B.si + 1 : B.si;\n  for (let k = 0; k \u003c done && k \u003c B.strokes.length; k++) {\n    const s = B.strokes[k], lim = k === B.si && B.mode === \"write\" ? B.d : 1e9;\n    let [wa, fa] = width(B, s, 0);\n    for (let i = 0; i + 1 \u003c s.cum.length && s.cum[i] \u003c lim; i++) {\n      let [wb, fb] = width(B, s, i + 1), bx = s.xy[2 * i + 2], by = s.xy[2 * i + 3];\n      if (s.cum[i + 1] > lim) {\n        const f = (lim - s.cum[i]) / (s.cum[i + 1] - s.cum[i]);\n        bx = s.xy[2 * i] + (bx - s.xy[2 * i]) * f;\n        by = s.xy[2 * i + 1] + (by - s.xy[2 * i + 1]) * f;\n      }\n      piece(B, s.xy[2 * i], s.xy[2 * i + 1], bx, by, wa / 2, wb / 2, fa, fb, s.cum[i] / s.len, min(lim, s.cum[i + 1]) / s.len);\n      wa = wb;\n      fa = fb;\n    }\n  }\n  // Each stroke runs from cyan where the pen comes down to violet where it\n  // lifts, so the colour shows the way it was written; thick ink is deep,\n  // a hairline pale.\n  const { out, pos } = B, F = B.fade, rule = new Uint8Array(H);\n  for (const g of B.guides) if (g >= 0 && g \u003c H) rule[g] = 1;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const c = cov[p] * F, bg = rule[y] && x % 3 === 0 ? (34 / 255) * F : 0;\n      let r = bg * 0.7, g = bg * 0.8, b = bg;\n      if (c > 0) {\n        const [ir, ig, ib] = hsv(B.hue + 0.48 + 0.24 * pos[p], 0.2 + 0.7 * fat[p], 1);\n        r += (ir - r) * c;\n        g += (ig - g) * c;\n        b += (ib - b) * c;\n      }\n      out[p * 3] = r;\n      out[p * 3 + 1] = g;\n      out[p * 3 + 2] = b;\n    }\n  // The pen: a white point as wide as the stroke it is writing, dim and\n  // small while it is lifted between strokes.\n  if (B.mode === \"write\" || B.mode === \"lift\") {\n    const s = B.strokes[min(B.si, B.strokes.length - 1)];\n    let i = 0;\n    while (i \u003c s.cum.length - 1 && s.cum[i + 1] \u003c= B.d) i++;\n    const rr = B.mode === \"write\" ? width(B, s, i)[0] / 2 + 0.4 : 1;\n    const v = B.mode === \"write\" ? 1 : 0.6, [px, py] = B.pen;\n    for (let y = max(0, floor(py - rr - 1)); y \u003c= min(H - 1, ceil(py + rr + 1)); y++)\n      for (let x = max(0, floor(px - rr - 1)); x \u003c= min(W - 1, ceil(px + rr + 1)); x++) {\n        const c = cl(rr - sqrt((x - px) ** 2 + (y - py) ** 2) + 0.5, 0, 1), p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) out[p + j] += (v - out[p + j]) * c;\n      }\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), out[p * 3] * 255, out[p * 3 + 1] * 255, out[p * 3 + 2] * 255);\n}\n","phasor-noise":"// ===== Patternflow pattern =====\n// Title:   Phasor Noise\n// Family:  noise\n// Idea:    One set of Gabor kernels, little wave packets turned by a field with a whirl and a saddle drifting through it, is summed into a complex field and shown twice: on top as Gabor noise, its imaginary part, whose stripes fade to flat wherever the kernels cancel, and below as phasor noise, a profile of its phase alone, the same curving bands at full contrast everywhere and broken only at the points where the sum is zero.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: phasor noise (Thibault Tricard, Semyon Efremov, Cédric Zanni, Fabrice Neyret, Jonàs Martínez and Sylvain Lefebvre, Procedural phasor noise, 2019), built on sparse convolution Gabor noise (Ares Lagae, Sylvain Lefebvre, George Drettakis and Philip Dutré, Procedural noise using sparse Gabor convolution, 2009); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Frequency=8..11, Profile=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. Each band takes its colour from the way it runs: at 0 level bands are sea green, slanting ones azure and upright ones violet.\n// Knob 2: Speed. At 2 the bands travel one period every 3.3 s, each kernel circles its place every 9 s and the direction field turns once in 50 s; all of it goes as Speed / 2.\n// Knob 3: Frequency. Stripes across the 64 LEDs of the panel: 8 is a period of 8 LEDs, 11 a period of 5.8. The kernels keep their size, 6.5 LEDs to one standard deviation, so at 11 each holds 1.4 times as many stripes.\n// Knob 4: Profile. The wave the phase is drawn with in the lower half, blended between a sine at 0, a triangle at 0.33, a square at 0.67 and a sawtooth at 1, whose sharp side shows which way each band's phase runs. The upper half is Gabor noise at every setting.\n\n// A Gabor kernel is a Gaussian times a complex plane wave,\n//\n//   g_i(x) = exp(-|x - x_i|^2 / (2 s^2)) exp(i (k_i . (x - x_i) + phi_i)),\n//\n// and the sum G(x) of a few hundred of them, scattered on a jittered grid,\n// is complex noise with the frequency and orientation of its kernels. Lagae\n// and his co-authors showed Im G, Gabor noise: wherever the kernels around a\n// point happen to cancel, |G| is small and the stripes fade out. Tricard and\n// his co-authors kept the phase and threw the amplitude away, profile(arg G):\n// stripes of one contrast everywhere, with the same orientation and period,\n// broken only where G = 0, the points the phase winds round. Both halves of\n// the panel here are the same 64 x 63 window of the same G, so every place\n// the upper stripes fade to flat is a fork or an end in the lower ones.\n//\n// The kernel direction comes from a field with a whirl and a saddle in it,\n// theta = theta0 + the angle round the whirl - the angle round the saddle.\n// Round the whirl the wave vectors point outwards (rings), across (spokes)\n// or in between (spirals) as theta0 turns; spokes and spirals spread apart\n// as they go out, and phasor noise can only keep its period by forking.\n//\n// Each kernel is separable, the Gaussian and the wave both, so it is two\n// short complex rows, one along x and one along y, multiplied pixel by pixel.\n\nconst W = 64, H = 128, FH = 63, LOW = 65;\nconst { floor, min, max, round, sqrt, sin, cos, exp, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Kernel size and reach in LEDs, and the grid the kernels sit on.\nconst SIG = 6.5, R = 18, STEP = 8;\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const ks = [];\n  for (let y = -R; y \u003c FH + R; y += STEP)\n    for (let x = -R; x \u003c W + R; x += STEP)\n      ks.push({\n        hx: x + (Math.random() - 0.5) * STEP * 0.8,\n        hy: y + (Math.random() - 0.5) * STEP * 0.8,\n        ph: Math.random() * TAU,\n        wa: Math.random() * TAU,\n        wr: 0.8 + 1.2 * Math.random(),\n        ws: Math.random() \u003c 0.5 ? -1 : 1,\n        cx: 0, cy: 0, kx: 0, ky: 0,\n      });\n  params.s = {\n    ks, t: 0, hue: 0, freq: 8, prof: 0.06,\n    gr: new Float32Array(W * FH), gi: new Float32Array(W * FH), u: [0, 0], th: new Float32Array(W * FH),\n    xr: new Float32Array(2 * R + 2), xi: new Float32Array(2 * R + 2), out: new Float32Array(W * H * 3),\n  };\n}\n\n// A whirl and a saddle, each on a slow loop of its own.\nfunction poles(t) {\n  return [24 + 8 * sin(0.071 * t), 20 + 6 * cos(0.053 * t + 1), 40 + 8 * sin(0.062 * t + 2), 46 + 6 * cos(0.047 * t + 0.5)];\n}\n\n// The kernel direction at (x, y) as a unit complex number,\n// e^(i theta0) (z - whirl) / |z - whirl| times the conjugate for the saddle.\nfunction dir(P, c0, s0, x, y, o) {\n  const ar = x - P[0], ai = y - P[1], br = x - P[2], bi = -(y - P[3]);\n  const pr = ar * br - ai * bi, pi = ar * bi + ai * br;\n  const qr = pr * c0 - pi * s0, qi = pr * s0 + pi * c0, m = sqrt(qr * qr + qi * qi) || 1;\n  o[0] = qr / m;\n  o[1] = qi / m;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.freq = cl(k[2] == null ? 8 : k[2], 8, 11);\n  S.prof = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.t += (d * speed) / 2;\n}\n\nfunction field(S) {\n  const t = S.t, P = poles(t), th0 = (TAU * t) / 50 + 0.4, c0 = cos(th0), s0 = sin(th0), kk = (TAU * S.freq) / W;\n  const { gr, gi, xr, xi, u } = S;\n  gr.fill(0);\n  gi.fill(0);\n  const a = 1 / (2 * SIG * SIG), drift = (TAU * t) / 3.3;\n  for (const K of S.ks) {\n    const w = ((TAU * t) / 9) * K.ws + K.wa;\n    const cx = K.hx + K.wr * cos(w), cy = K.hy + K.wr * sin(w);\n    dir(P, c0, s0, cx, cy, u);\n    const kx = kk * u[0], ky = kk * u[1];\n    const x0 = max(0, Math.ceil(cx - R)), x1 = min(W - 1, floor(cx + R));\n    const y0 = max(0, Math.ceil(cy - R)), y1 = min(FH - 1, floor(cy + R));\n    if (x0 > x1 || y0 > y1) continue;\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x - cx, e = exp(-a * dx * dx), p = kx * dx;\n      xr[x - x0] = e * cos(p);\n      xi[x - x0] = e * sin(p);\n    }\n    for (let y = y0; y \u003c= y1; y++) {\n      const dy = y - cy, e = exp(-a * dy * dy), p = ky * dy + K.ph - drift;\n      const yr = e * cos(p), yi = e * sin(p);\n      let o = y * W + x0;\n      for (let x = x0; x \u003c= x1; x++, o++) {\n        const ar = xr[x - x0], ai = xi[x - x0];\n        gr[o] += ar * yr - ai * yi;\n        gi[o] += ar * yi + ai * yr;\n      }\n    }\n  }\n  // cos 2 theta at every LED, which way its stripes run, for the colour.\n  const T = S.th;\n  for (let y = 0, o = 0; y \u003c FH; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      dir(P, c0, s0, x, y, u);\n      T[o] = u[0] * u[0] - u[1] * u[1];\n    }\n}\n\n// Brightness of a band at height v of its wave; the lowest seventh is black.\nconst lum = (v) => (v \u003c 0.14 ? 0 : ((v - 0.14) / 0.86) ** 2);\n\n// The wave drawn from the phase: 1 on the crest of sin, 0 in the trough.\nfunction profile(ph, m) {\n  const s = 0.5 + 0.5 * sin(ph);\n  if (m \u003c= 0) return s;\n  let u = ph / TAU - 0.25;\n  u -= floor(u);\n  const tri = Math.abs(2 * u - 1), sq = cl(0.5 + 2.6 * sin(ph), 0, 1), saw = 1 - u;\n  const z = m * 3, i = min(2, floor(z)), f = z - i;\n  const A = [s, tri, sq, saw];\n  return A[i] + (A[i + 1] - A[i]) * f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  field(S);\n  const { gr, gi, out } = S, n = W * FH;\n  let e = 0;\n  for (let i = 0; i \u003c n; i++) e += gr[i] * gr[i] + gi[i] * gi[i];\n  const rms = sqrt(e / n) || 1, hb = S.hue + 0.55;\n  out.fill(0);\n  for (let i = 0; i \u003c n; i++) {\n    const h = hb + 0.16 * S.th[i];\n    const g = cl(gi[i] / (1.5 * rms), -1, 1) * 0.5 + 0.5;\n    const p = profile(atan2(gi[i], gr[i]), S.prof);\n    hsv(h, 0.75 - 0.35 * g, lum(g), out, i * 3);\n    hsv(h, 0.75 - 0.35 * p, lum(p), out, (i + LOW * W) * 3);\n  }\n  for (let i = 0; i \u003c W * H; i++) display.setPixel(i % W, floor(i / W), round(out[i * 3] * 255), round(out[i * 3 + 1] * 255), round(out[i * 3 + 2] * 255));\n}\n","word-search":"// ===== Patternflow pattern =====\n// Title:   Word Search\n// Family:  type\n// Idea:    A word search of 160 capitals, 10 across and 16 down the tall panel, hides twelve words of type vocabulary in all eight directions among random letters, and a white cursor reads it cell by cell the plain way, sending a probe out in each of the eight directions from every letter that starts a word still unfound, until a probe runs a whole word and a rounded capsule in that word's colour closes round it and stays; when all twelve are ringed the grid dissolves and the next puzzle types itself in.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: word search puzzle (Norman E. Gibat, Selenby Digest, Norman, Oklahoma, 1968), solved by the plain search that tries all eight directions from every cell; capitals 5 by 7 drawn for this pattern; pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Puzzle=0..5, Fill=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the grid is pale blue-grey, the probe reads in pale gold, a failed letter flashes rose, and the capsules come in cyan, violet, rose, azure, magenta and on, each 0.382 of a 0.62 band on from the one before.\n// Knob 2: Speed. At 2 each comparison takes 0.03 s and each find holds the search 0.4 s, so the opening puzzle types in for 1 s, has all twelve words ringed by 20 s, holds 1.6 s and dissolves in 1.2 s; at 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Puzzle. Which of six lists of twelve words is hidden: 0 SERIF, KERN, GLYPH, BOWL, STEM, SPUR, EAR, TAIL, LEADING, BASELINE, COUNTER and ASCENDER; 1 more parts of a letter, APEX to XHEIGHT; 2 words of the page, TRACKING to HYPHEN; 3 classes of type, ROMAN to MONO; 4 metal type, SORT to FURNITURE; 5 accents and marks, ACUTE to MACRON. Each new puzzle on a list is laid again from its own seed.\n// Knob 4: Fill. How a found word is marked. At 0 and the opening 0.06 a capsule outline one LED wide, which for words across and down runs in the gaps between the letters; at 0.5 the capsule is filled at 40% of its colour, and at 1 it is solid at 80% with the word's letters cut out of it dark while every letter outside the found words dims to half.\n\n// Placing: the words go in longest first, each at the first of 400 random\n// starts where every cell is empty or already holds the same letter. Each\n// word tries a direction of its own for the first 200 starts, three\n// eighths of a turn on from the word before, so a grid has words running\n// backwards, upwards and along both diagonals. The cells left over get\n// random letters, and a word that the filler happens to spell again is\n// found wherever the search reaches it first.\n//\n// Searching: the cursor visits the cells in reading order. A cell whose\n// letter starts no word still unfound costs one step. From any other cell\n// the probe tries east, then each direction clockwise; it reads one letter\n// a step, keeps the words whose next letter matches and stops at the first\n// letter that matches none, which flashes. When a word runs out on a match\n// it is found. Directions that leave the grid at once cost nothing.\n//\n// The capsule round a word is the set of LEDs at distance 3 from the\n// segment joining its first and last letter centres, measured with the\n// vertical squeezed by 3/4. So the outline sits on the gap row 4 LEDs\n// above and below a word that runs across, on the gap column 3 LEDs either\n// side of a word that runs down, and the ends round off between the two.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// 10 columns by 16 rows of 5 by 7 capitals, 6 LEDs apart across and 8 down.\nconst COLS = 10, ROWS = 16, CELLS = COLS * ROWS, CW = 6, CH = 8, X0 = 2, Y0 = 1;\n// Clockwise from east, the order the search tries them in.\nconst DIRS = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]];\n// Seconds at Speed 2: one comparison, the pause on a find, the hold when\n// every word is found, the dissolve and the typing in of the next grid.\nconst STEP = 0.03, FIND = 0.4, HOLD = 1.6, MELT = 1.2, TYPE = 1.0;\n// Capsule radius across the word, in LEDs; down the panel it is 4/3 of it.\nconst R = 3, SY = 0.75;\n\nconst LISTS = [\n  [\"SERIF\", \"KERN\", \"GLYPH\", \"BOWL\", \"STEM\", \"SPUR\", \"EAR\", \"TAIL\", \"LEADING\", \"BASELINE\", \"COUNTER\", \"ASCENDER\"],\n  [\"APEX\", \"VERTEX\", \"SPINE\", \"ARM\", \"LEG\", \"LOOP\", \"LINK\", \"CROSSBAR\", \"SHOULDER\", \"TERMINAL\", \"DESCENDER\", \"XHEIGHT\"],\n  [\"TRACKING\", \"MEASURE\", \"GUTTER\", \"INDENT\", \"WIDOW\", \"ORPHAN\", \"RAG\", \"RIVER\", \"JUSTIFY\", \"MARGIN\", \"COLUMN\", \"HYPHEN\"],\n  [\"ROMAN\", \"ITALIC\", \"GOTHIC\", \"SLAB\", \"SCRIPT\", \"GROTESK\", \"DIDONE\", \"UNCIAL\", \"TEXTURA\", \"FRAKTUR\", \"ANTIQUA\", \"MONO\"],\n  [\"SORT\", \"QUOIN\", \"CHASE\", \"GALLEY\", \"FORME\", \"PLATEN\", \"PUNCH\", \"MATRIX\", \"SLUG\", \"LIGATURE\", \"COMPOSE\", \"FURNITURE\"],\n  [\"ACUTE\", \"GRAVE\", \"TILDE\", \"CEDILLA\", \"OGONEK\", \"UMLAUT\", \"CARET\", \"DAGGER\", \"PILCROW\", \"ASTERISK\", \"OBELUS\", \"MACRON\"],\n];\n\n// Capitals 5 wide and 7 tall, top row first.\nconst FONT = (\n  \".###. #...# #...# ##### #...# #...# #...#|####. #...# #...# ####. #...# #...# ####.|.###. #...# #.... #.... #.... #...# .###.|\" +\n  \"####. #...# #...# #...# #...# #...# ####.|##### #.... #.... ####. #.... #.... #####|##### #.... #.... ####. #.... #.... #....|\" +\n  \".###. #...# #.... #.### #...# #...# .####|#...# #...# #...# ##### #...# #...# #...#|.###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.|\" +\n  \"..### ...#. ...#. ...#. ...#. #..#. .##..|#...# #..#. #.#.. ##... #.#.. #..#. #...#|#.... #.... #.... #.... #.... #.... #####|\" +\n  \"#...# ##.## #.#.# #.#.# #...# #...# #...#|#...# #...# ##..# #.#.# #..## #...# #...#|.###. #...# #...# #...# #...# #...# .###.|\" +\n  \"####. #...# #...# ####. #.... #.... #....|.###. #...# #...# #...# #.#.# #..#. .##.#|####. #...# #...# ####. #.#.. #..#. #...#|\" +\n  \".#### #.... #.... .###. ....# ....# ####.|##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..|#...# #...# #...# #...# #...# #...# .###.|\" +\n  \"#...# #...# #...# #...# #...# .#.#. ..#..|#...# #...# #...# #.#.# #.#.# #.#.# .#.#.|#...# #...# .#.#. ..#.. .#.#. #...# #...#|\" +\n  \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..|##### ....# ...#. ..#.. .#... #.... #####\"\n)\n  .split(\"|\")\n  .map((g) => g.split(\" \").map((row) => [...row].map((c) => c === \"#\")));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h), f = h - i, p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6];\n}\n\nfunction rng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nconst code = (ch) => ch.charCodeAt(0) - 65;\nconst inGrid = (c, r) => c >= 0 && c \u003c COLS && r >= 0 && r \u003c ROWS;\n\nfunction puzzle(list, gen) {\n  const rand = rng(list * 7919 + gen * 104729 + 17);\n  const grid = new Int8Array(CELLS).fill(-1);\n  const words = LISTS[list].slice().sort((a, b) => b.length - a.length);\n  const turn = floor(rand() * 8), laid = [];\n  for (const [n, w] of words.entries()) {\n    for (let tries = 0; tries \u003c 400; tries++) {\n      // Each word tries its own direction first, so all eight turn up.\n      const d = DIRS[tries \u003c 200 ? (turn + n * 3) % 8 : floor(rand() * 8)], c0 = floor(rand() * COLS), r0 = floor(rand() * ROWS);\n      const c1 = c0 + d[0] * (w.length - 1), r1 = r0 + d[1] * (w.length - 1);\n      if (!inGrid(c1, r1)) continue;\n      let ok = true;\n      for (let i = 0; i \u003c w.length && ok; i++) {\n        const g = grid[(r0 + d[1] * i) * COLS + c0 + d[0] * i];\n        if (g >= 0 && g !== code(w[i])) ok = false;\n      }\n      if (!ok) continue;\n      for (let i = 0; i \u003c w.length; i++) grid[(r0 + d[1] * i) * COLS + c0 + d[0] * i] = code(w[i]);\n      laid.push(w);\n      break;\n    }\n  }\n  for (let i = 0; i \u003c CELLS; i++) if (grid[i] \u003c 0) grid[i] = floor(rand() * 26);\n  return { grid, words: laid.map((w) => w.split(\"\").map(code)) };\n}\n\nexport function setup(params) {\n  params.s = {\n    list: -1, gen: 0, grid: null, words: [], left: [], found: [],\n    phase: 0, t: 0, acc: 0, wait: 0,\n    cell: 0, dir: -1, k: 0, live: [], miss: -1, next: false,\n    seen: new Uint8Array(CELLS),\n    capIn: new Int8Array(N), capOut: new Int8Array(N),\n    hue: 0, fill: 0.06,\n    rgb: new Uint8Array(N * 3),\n    melt: null,\n  };\n  const S = params.s;\n  const rand = rng(99);\n  S.melt = new Float32Array(N);\n  for (let i = 0; i \u003c N; i++) S.melt[i] = rand();\n}\n\nfunction begin(S, list, gen) {\n  const p = puzzle(list, gen);\n  S.list = list;\n  S.gen = gen;\n  S.grid = p.grid;\n  S.words = p.words;\n  S.left = p.words.map((_, i) => i);\n  S.found = [];\n  S.phase = 0;\n  S.t = 0;\n  S.acc = 0;\n  S.wait = 0;\n  S.cell = 0;\n  S.dir = -1;\n  S.k = 0;\n  S.live = [];\n  S.miss = -1;\n  S.next = false;\n  S.seen.fill(0);\n  S.capIn.fill(0);\n  S.capOut.fill(0);\n}\n\nconst centre = (c, r) => [X0 + c * CW + 2, Y0 + r * CH + 3];\n\n// Mark the capsule round a found word in the two LED maps.\nfunction capsule(S, f) {\n  const [ax, ay] = centre(f.c, f.r), [bx, by] = centre(f.c + f.d[0] * (f.n - 1), f.r + f.d[1] * (f.n - 1));\n  const ux = bx - ax, uy = (by - ay) * SY, uu = ux * ux + uy * uy || 1;\n  const x0 = max(0, min(ax, bx) - 5), x1 = min(W - 1, max(ax, bx) + 5), y0 = max(0, min(ay, by) - 6), y1 = min(H - 1, max(ay, by) + 6);\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x - ax, py = (y - ay) * SY;\n      const t = cl((px * ux + py * uy) / uu, 0, 1);\n      const ex = px - t * ux, ey = py - t * uy, d = sqrt(ex * ex + ey * ey);\n      const p = y * W + x;\n      if (abs(d - R) \u003c 0.5) S.capOut[p] = f.i + 1;\n      else if (d \u003c R) S.capIn[p] = f.i + 1;\n    }\n}\n\n// The cells a probe from the cursor has read so far.\nfunction cellAt(S, i) {\n  const c = (S.cell % COLS) + DIRS[S.dir][0] * i, r = floor(S.cell / COLS) + DIRS[S.dir][1] * i;\n  return inGrid(c, r) ? r * COLS + c : -1;\n}\n\nfunction nextDir(S) {\n  S.k = 0;\n  S.miss = -1;\n  for (S.dir++; S.dir \u003c 8; S.dir++) {\n    S.live = S.left.filter((w) => S.words[w][0] === S.grid[S.cell]);\n    if (S.live.length && cellAt(S, 1) >= 0) return;\n  }\n  S.seen[S.cell] = 1;\n  S.cell++;\n  S.dir = -1;\n}\n\n// One comparison of the plain search.\nfunction tick(S) {\n  if (S.next) {\n    S.next = false;\n    nextDir(S);\n    if (S.dir \u003c 0) return;\n  }\n  if (S.cell >= CELLS || S.left.length === 0) {\n    S.phase = 2;\n    S.t = 0;\n    return;\n  }\n  if (S.dir \u003c 0) {\n    // On a new cell: does any word left start with its letter?\n    if (S.left.some((w) => S.words[w][0] === S.grid[S.cell])) nextDir(S);\n    else {\n      S.seen[S.cell] = 1;\n      S.cell++;\n    }\n    return;\n  }\n  const at = cellAt(S, S.k + 1);\n  const live = at \u003c 0 ? [] : S.live.filter((w) => S.words[w].length > S.k + 1 && S.words[w][S.k + 1] === S.grid[at]);\n  if (!live.length) {\n    S.miss = at;\n    S.next = true;\n    return;\n  }\n  S.k++;\n  S.live = live;\n  const done = live.find((w) => S.words[w].length === S.k + 1);\n  if (done != null) {\n    const f = { i: S.found.length, w: done, c: S.cell % COLS, r: floor(S.cell / COLS), d: DIRS[S.dir], n: S.k + 1 };\n    S.found.push(f);\n    S.left = S.left.filter((w) => w !== done);\n    capsule(S, f);\n    S.wait = FIND;\n    S.live = live.filter((w) => w !== done);\n    if (!S.live.length) S.next = true;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const list = round(cl(k[2] || 0, 0, LISTS.length - 1));\n  S.fill = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (list !== S.list) begin(S, list, 0);\n  const step = (d * speed) / 2;\n  S.t += step;\n  if (S.wait > 0) S.wait = max(0, S.wait - step);\n  if (S.phase === 0) {\n    if (S.t >= TYPE) {\n      S.phase = 1;\n      S.t = 0;\n    }\n  } else if (S.phase === 1) {\n    if (S.wait > 0) return;\n    S.acc += step;\n    while (S.acc >= STEP && S.phase === 1 && S.wait \u003c= 0) {\n      S.acc -= STEP;\n      tick(S);\n    }\n  } else if (S.phase === 2) {\n    if (S.t >= HOLD) {\n      S.phase = 3;\n      S.t = 0;\n    }\n  } else if (S.t >= MELT) begin(S, S.list, S.gen + 1);\n}\n\nfunction put(rgb, p, c, v) {\n  rgb[p * 3] = round(c[0] * v * 255);\n  rgb[p * 3 + 1] = round(c[1] * v * 255);\n  rgb[p * 3 + 2] = round(c[2] * v * 255);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.grid) return;\n  const rgb = S.rgb, h = S.hue, f = S.fill;\n  rgb.fill(0);\n  const wordCol = S.found.map((w) => hsv(h + 0.5 + ((w.i * 0.381966) % 1) * 0.62, 0.7, 1));\n  const fresh = S.wait > 0 ? S.found.length - 1 : -1;\n  // Capsules: a fill under the letters as Fill rises, and the outline.\n  for (let p = 0; p \u003c N; p++) {\n    const o = S.capOut[p], i = S.capIn[p];\n    if (o) put(rgb, p, wordCol[o - 1], o - 1 === fresh ? 1 : 0.85);\n    else if (i && f > 0.02) put(rgb, p, wordCol[i - 1], 0.8 * f);\n  }\n  const inWord = new Int8Array(CELLS).fill(-1);\n  for (const w of S.found) for (let j = 0; j \u003c w.n; j++) inWord[(w.r + w.d[1] * j) * COLS + w.c + w.d[0] * j] = w.i;\n  const probe = new Int8Array(CELLS);\n  if (S.phase === 1 && S.dir >= 0) {\n    for (let j = 1; j \u003c= S.k; j++) probe[cellAt(S, j)] = 1;\n    if (S.miss >= 0) probe[S.miss] = 2;\n  }\n  const base = hsv(h + 0.58, 0.28, 1), dim = hsv(h + 0.6, 0.4, 1);\n  const hit = hsv(h + 0.14, 0.45, 1), miss = hsv(h + 0.93, 0.6, 1), white = [1, 1, 1];\n  const knock = cl((f - 0.45) / 0.45, 0, 1), rest = 1 - 0.5 * f;\n  const typed = S.phase === 0 ? (S.t / TYPE) * (CELLS + 20) : 1e9;\n  const melt = S.phase === 3 ? S.t / MELT : -1;\n  for (let ci = 0; ci \u003c CELLS; ci++) {\n    if (ci > typed) continue;\n    const c = ci % COLS, r = floor(ci / COLS), g = FONT[S.grid[ci]];\n    let col = base, v = 0.55 * rest;\n    if (inWord[ci] >= 0) {\n      col = wordCol[inWord[ci]];\n      v = inWord[ci] === fresh ? 1 : 1 - 0.85 * knock;\n      if (inWord[ci] !== fresh && knock \u003c 0.5) col = col.map((x) => x + (1 - x) * 0.35);\n    } else if (S.phase === 1 && ci === S.cell) {\n      col = white;\n      v = 1;\n    } else if (probe[ci] === 1) {\n      col = hit;\n      v = 1;\n    } else if (probe[ci] === 2) {\n      col = miss;\n      v = 0.9;\n    } else if (S.seen[ci]) {\n      col = dim;\n      v = 0.32 * rest;\n    }\n    const x0 = X0 + c * CW, y0 = Y0 + r * CH;\n    for (let y = 0; y \u003c 7; y++)\n      for (let x = 0; x \u003c 5; x++) if (g[y][x]) put(rgb, (y0 + y) * W + x0 + x, col, v);\n  }\n  // The cursor's box in the gaps round its cell.\n  if (S.phase === 1 && S.cell \u003c CELLS) {\n    const x0 = X0 + (S.cell % COLS) * CW - 1, y0 = Y0 + floor(S.cell / COLS) * CH - 1;\n    for (let x = x0; x \u003c= x0 + 6; x++)\n      for (const y of [y0, y0 + 8]) if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(rgb, y * W + x, white, 0.6);\n    for (let y = y0; y \u003c= y0 + 8; y++)\n      for (const x of [x0, x0 + 6]) if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(rgb, y * W + x, white, 0.6);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    if (melt >= 0 && S.melt[p] \u003c melt) display.setPixel(p % W, floor(p / W), 0, 0, 0);\n    else display.setPixel(p % W, floor(p / W), rgb[p * 3], rgb[p * 3 + 1], rgb[p * 3 + 2]);\n  }\n}\n","baudot-tape":"// ===== Patternflow pattern =====\n// Title:   Baudot Tape\n// Family:  type\n// Idea:    Five-hole teleprinter tape runs up the whole height of the panel, each character arriving down the line as five pulses that set the punch at the bottom, punched as one row of holes with the small feed hole between the third and the fourth, and typed beside its row as it is punched, so the message reads down the panel next to its own code and passes under the reader at the top; line noise flips a pulse now and then, and when the pulse it flips belongs to a shift code the rest of the line comes out in the wrong shift, 1234567890 as QWERTYUIOP.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the five-unit code of Emile Baudot (1870s), rearranged by Donald Murray for a keyboard and punched tape (1901), in the letters and figures of International Telegraph Alphabet No. 2; 5 by 7 capitals and 3 by 5 tags drawn for this pattern, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Message=0..2, Noise=0..1\n//\n// Knob 1: Hue. Turns the paper, the ink and the marks round the wheel together. At 0 the tape is cream, the typed characters pale azure, the line hits pink and the punch's selectors gold; at 0.25 the tape is pale green and the ink violet, at 0.5 pale blue tape with peach ink, at 0.75 lilac tape with green ink.\n// Knob 2: Speed. Characters a second, 1.5 times the knob: 3 at 2, so a row takes 0.33 s and the tape climbs 24 LEDs a second; 0.3 at 0.2 and 4.5 at 3. Each character spends half its time arriving, a pulse at a time, and the rest punched and moving up one row of 8 LEDs.\n// Knob 3: Message. 0 the teleprinter test line THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 1234567890, 1 the RYRY test, R 01010 and Y 10101 in turn so the tape is a checkerboard, 2 a telegram, ARRIVE FRIDAY 10.45 STOP MEET TRAIN; after each the next one follows. Every message opens with a letters shift. Turning it starts the new message on the next row.\n// Knob 4: Noise. The chance a character takes a line hit that flips one of its five pulses, 0.6 times the knob: 3.6% at the opening 0.06, 15% at 0.25, 60% at 1. A hit row gets a pink tick in the margin and a pink ring round the flipped hole, and whatever the receiver types wrong is pink. A hit on the figures shift before 1234567890 leaves the receiver in letters, and the digits come out QWERTYUIOP; a hit on the letters shift that opens the RYRY test leaves it in figures, and it comes out 464646.\n\n// ITA2 sends a character as five pulses, each mark or space; a punched\n// tape keeps them as five holes across one row, bit 1 on the left, with\n// a smaller feed hole between bit 3 and bit 4 that the sprocket pulls the\n// tape by. Thirty-two codes are not enough for letters and figures, so\n// two of them are shifts: 11011 puts the receiver in figures and 11111\n// back in letters, and every other code means a letter or a figure by\n// which shift came last. Space 00100, carriage return 00010 and line feed\n// 01000 mean the same in both. The figures drawn here are the digits, on\n// the top row of letters Q W E R T Y U I O P, and the marks on A B C K L\n// M N S V X Z; J in figures rings the bell, drawn as a bell, and D F G H\n// in figures get no figure here and are drawn as an empty box.\n//\n// The receiver keeps only the shift, so a single flipped pulse in a shift\n// code changes how everything after it reads, up to the next shift code.\n// Each row is decoded as it is punched, by the receiver's own shift, and\n// compared with what was sent: what does not match is typed in pink.\n//\n// The tape climbs: rows are punched at the bottom, under the punch at row\n// 106, and a row that has climbed twelve rows stops under the reader at\n// row 10, whose pins drop through the holes they find.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, round, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Letters shift, bit 1 first.\nconst LT = {\n  A: \"11000\", B: \"10011\", C: \"01110\", D: \"10010\", E: \"10000\", F: \"10110\", G: \"01011\", H: \"00101\", I: \"01100\",\n  J: \"11010\", K: \"11110\", L: \"01001\", M: \"00111\", N: \"00110\", O: \"00011\", P: \"01101\", Q: \"11101\", R: \"01010\",\n  S: \"10100\", T: \"00001\", U: \"11100\", V: \"01111\", W: \"11001\", X: \"10111\", Y: \"10101\", Z: \"10001\",\n};\n// Figures shift on the same codes; \"*\" is the bell, \"#\" an empty box.\nconst FG = {\n  Q: \"1\", W: \"2\", E: \"3\", R: \"4\", T: \"5\", Y: \"6\", U: \"7\", I: \"8\", O: \"9\", P: \"0\",\n  A: \"-\", B: \"?\", C: \":\", K: \"(\", L: \")\", M: \".\", N: \",\", S: \"'\", V: \"=\", X: \"/\", Z: \"+\", J: \"*\",\n  D: \"#\", F: \"#\", G: \"#\", H: \"#\",\n};\nconst SP = 4, CR = 2, LF = 8, FIGS = 27, LTRS = 31, NUL = 0;\nconst C2L = [], C2F = [], F2C = {};\nfor (const ch in LT) {\n  const c = parseInt(LT[ch], 2);\n  C2L[c] = ch;\n  C2F[c] = FG[ch];\n  if (FG[ch] !== \"#\" && FG[ch] !== \"*\") F2C[FG[ch]] = c;\n}\n\nconst MSG = [\n  \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 1234567890\",\n  \"RYRYRYRYRYRYRYRYRYRYRYRY\",\n  \"ARRIVE FRIDAY 10.45 STOP MEET TRAIN\",\n];\n\n// 5 by 7 capitals, figures and marks: seven rows, each a base-32 digit\n// whose five bits are the row's LEDs, left first.\nconst BIG = {\n  A: \"ehhvhhh\", B: \"uhhuhhu\", C: \"ehggghe\", D: \"uhhhhhu\", E: \"vgguggv\", F: \"vgguggg\", G: \"ehgjhhe\", H: \"hhhvhhh\",\n  I: \"e44444e\", J: \"72222ic\", K: \"hikokih\", L: \"ggggggv\", M: \"hrllhhh\", N: \"hhpljhh\", O: \"ehhhhhe\", P: \"uhhuggg\",\n  Q: \"ehhhlid\", R: \"uhhukih\", S: \"fgge11u\", T: \"v444444\", U: \"hhhhhhe\", V: \"hhhhha4\", W: \"hhhllla\", X: \"hha4ahh\",\n  Y: \"hha4444\", Z: \"v1248gv\", 0: \"ehjlphe\", 1: \"4c4444e\", 2: \"eh1248v\", 3: \"v2421he\", 4: \"26aiv22\", 5: \"vgu11he\",\n  6: \"68guhhe\", 7: \"v124888\", 8: \"ehhehhe\", 9: \"ehhf12c\", \".\": \"00000cc\", \",\": \"0000c48\", \"-\": \"000v000\",\n  \"?\": \"eh12404\", \"'\": \"4480000\", \":\": \"0cc0cc0\", \"(\": \"2488842\", \")\": \"8422248\", \"/\": \"01248g0\", \"=\": \"00v0v00\",\n  \"+\": \"044v440\", \"#\": \"0eaaae0\", \"*\": \"4eeev04\",\n};\n// 3 by 5 letters for the tags of the codes that type nothing: five rows,\n// each an octal digit.\nconst SMALL = { C: \"74447\", F: \"74644\", G: \"74557\", I: \"72227\", L: \"44447\", R: \"65655\", T: \"72222\" };\n\n// Geometry: row pitch, the punch and reader rows, the five hole columns\n// and the feed hole's, the tape's edges, the typed column.\nconst RP = 8, YP = 106, YR = 10, HX = [8, 14, 20, 32, 38], FX = 26, TX0 = 3, TX1 = 43, GX = 51;\nconst KEEP = 20;\n\n// A message as rows: what is punched and what the row should type.\nfunction encode(text) {\n  const rows = [{ code: LTRS, want: \"LTR\" }];\n  let fig = false;\n  for (const ch of text) {\n    if (ch === \" \") rows.push({ code: SP, want: \" \" });\n    else if (LT[ch]) {\n      if (fig) rows.push({ code: LTRS, want: \"LTR\" }), (fig = false);\n      rows.push({ code: parseInt(LT[ch], 2), want: ch });\n    } else if (F2C[ch] != null) {\n      if (!fig) rows.push({ code: FIGS, want: \"FIG\" }), (fig = true);\n      rows.push({ code: F2C[ch], want: ch });\n    }\n  }\n  rows.push({ code: CR, want: \"CR\" }, { code: LF, want: \"LF\" }, { code: NUL, want: \"\" }, { code: NUL, want: \"\" });\n  return rows;\n}\nconst ENC = MSG.map(encode);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// The receiver: the row as it came down the line, decoded in the shift it\n// is in.\nfunction receive(S, sent, n) {\n  let flip = 0;\n  if (Math.random() \u003c S.noise) flip = 1 \u003c\u003c floor(Math.random() * 5);\n  const code = sent.code ^ flip;\n  let key;\n  if (code === LTRS) (S.fig = false), (key = \"LTR\");\n  else if (code === FIGS) (S.fig = true), (key = \"FIG\");\n  else if (code === SP) key = \" \";\n  else if (code === CR) key = \"CR\";\n  else if (code === LF) key = \"LF\";\n  else if (code === NUL) key = \"\";\n  else key = S.fig ? C2F[code] : C2L[code];\n  return { code, flip, key, bad: key !== sent.want, n, age: 0 };\n}\n\nfunction queue(S, m) {\n  S.m = ((m % MSG.length) + MSG.length) % MSG.length;\n  S.q = ENC[S.m].slice();\n}\n\nfunction next(S) {\n  if (!S.q.length) queue(S, S.m + 1);\n  S.cur = S.q.shift();\n  S.curRx = null;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, noise: 0.1, knob: -1, m: 0, q: [], rows: [], cur: null, curRx: null, fig: false,\n    ph: 0, T: 0, base: 0, buf: new Float32Array(N * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.noise = 0.6 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const km = round(cl(k[2] || 0, 0, 2));\n  if (km !== S.knob) {\n    if (S.knob \u003c 0) {\n      // A fresh tape opens on the end of the message before, already\n      // punched and typed, with the receiver in letters.\n      const before = ENC[(km + MSG.length - 1) % MSG.length];\n      const tail = before.slice(before.length - 15);\n      tail.forEach((r, i) => S.rows.push(receive(S, r, i - tail.length)));\n      for (const r of S.rows) r.age = 9;\n      queue(S, km);\n      next(S);\n    } else queue(S, km);\n    S.knob = km;\n  }\n  const rate = 1.5 * speed, was = S.ph;\n  S.ph += d * rate;\n  for (const r of S.rows) r.age += d;\n  // Half way through its time the row is punched and typed.\n  if (!S.curRx) S.curRx = receive(S, S.cur, S.base);\n  if (was \u003c 0.5 && S.ph >= 0.5) {\n    S.curRx.age = 0;\n    S.rows.push(S.curRx);\n    if (S.rows.length > KEEP) S.rows.shift();\n  }\n  // Then the tape moves up one row, from 0.55 to 0.95 of the time.\n  if (S.ph >= 1) {\n    S.ph -= 1;\n    S.base++;\n    next(S);\n  }\n  S.T = S.base + smooth((S.ph - 0.55) / 0.4);\n}\n\nfunction px(buf, x, y, c, a) {\n  if (a \u003c= 0 || x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  if (a > 1) a = 1;\n  buf[p] += (c[0] - buf[p]) * a;\n  buf[p + 1] += (c[1] - buf[p + 1]) * a;\n  buf[p + 2] += (c[2] - buf[p + 2]) * a;\n}\n\n// A disc (or a ring of width w) centred on (x, y).\nfunction disc(buf, x, y, r, c, a, w) {\n  for (let Y = floor(y - r - 1); Y \u003c= y + r + 1; Y++)\n    for (let X = floor(x - r - 1); X \u003c= x + r + 1; X++) {\n      const e = sqrt((X + 0.5 - x) ** 2 + (Y + 0.5 - y) ** 2);\n      const cov = w ? cl(w / 2 + 0.5 - abs(e - r), 0, 1) : cl(r + 0.5 - e, 0, 1);\n      px(buf, X, Y, c, a * cov);\n    }\n}\n\n// A glyph of rows (base-32 for the capitals, octal for the tags) with its\n// top at a fractional row, the fraction shared between two LED rows.\n// Bold doubles each lit LED to the right, as a typewheel's heavy face.\nfunction glyph(buf, rows, base, wide, x0, top, c, a, bold) {\n  const y0 = floor(top), f = top - y0;\n  for (let r = 0; r \u003c rows.length; r++) {\n    const bits = parseInt(rows[r], base);\n    for (let j = 0; j \u003c wide; j++)\n      if ((bits >> (wide - 1 - j)) & 1)\n        for (let b = 0; b \u003c= bold; b++) {\n          px(buf, x0 + j + b, y0 + r, c, a * (1 - f));\n          px(buf, x0 + j + b, y0 + r + 1, c, a * f);\n        }\n  }\n}\n\nfunction typed(buf, key, top, c, a) {\n  if (!key || key === \" \") return;\n  if (BIG[key]) return glyph(buf, BIG[key], 32, 5, GX, top, c, a, 1);\n  // A tag: two or three small letters, centred on the capitals' column.\n  const w = key.length * 4 - 1;\n  let x = GX + 3 - floor(w / 2);\n  for (const ch of key) glyph(buf, SMALL[ch], 8, 3, x, top + 1, c, a, 0), (x += 4);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, h = S.hue;\n  buf.fill(0);\n  const paper = hsv(h + 0.13, 0.3, 0.72), ink = hsv(h + 0.55, 0.42, 1), dim = hsv(h + 0.55, 0.3, 0.55);\n  const hit = hsv(h + 0.95, 0.65, 1), gold = hsv(h + 0.12, 0.7, 1), steel = [0.42, 0.44, 0.48], white = [1, 1, 1];\n\n  // The paper, a little darker at its edges.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = TX0; x \u003c= TX1; x++) {\n      const e = min(x - TX0, TX1 - x), v = e === 0 ? 0.62 : e === 1 ? 0.85 : 1, p = (y * W + x) * 3;\n      buf[p] = paper[0] * v;\n      buf[p + 1] = paper[1] * v;\n      buf[p + 2] = paper[2] * v;\n    }\n\n  // The punched rows climbing, their holes, their line hits, and beside\n  // each the character it typed.\n  const black = [0, 0, 0];\n  let under = null;\n  for (const r of S.rows) {\n    const y = YP - (S.T - r.n) * RP;\n    if (y \u003c -RP || y > H + RP) continue;\n    if (abs(y - YR) \u003c 0.5) under = r;\n    disc(buf, FX + 0.5, y + 0.5, 1.05, black, 1);\n    for (let b = 0; b \u003c 5; b++) {\n      const on = (r.code >> (4 - b)) & 1;\n      if (on) disc(buf, HX[b] + 0.5, y + 0.5, 2.1, black, 1);\n      if ((r.flip >> (4 - b)) & 1) disc(buf, HX[b] + 0.5, y + 0.5, 2.8, hit, 1, 1.1);\n    }\n    // A line hit also gets a pink tick in the margin beside its row.\n    if (r.flip) for (let dy = -2; dy \u003c= 3; dy++) for (let x = TX1 + 2; x \u003c= TX1 + 3; x++) px(buf, x, round(y) + dy, hit, 0.85);\n    const fresh = smooth(1 - r.age * 4), tag = r.key.length > 1;\n    const base = r.bad ? hit : tag ? dim : ink;\n    const c = [base[0] + (1 - base[0]) * fresh, base[1] + (1 - base[1]) * fresh, base[2] + (1 - base[2]) * fresh];\n    typed(buf, r.key, y - 3, c, 1);\n  }\n\n  // The punch: two steel bars across the tape, and between them the row\n  // being received, each mark pulse lighting its selector as it arrives.\n  for (let x = TX0 - 2; x \u003c= TX1 + 2; x++) {\n    px(buf, x, YP - 3, steel, 1);\n    px(buf, x, YP + 4, steel, 1);\n    px(buf, x, YR - 3, steel, 1);\n    px(buf, x, YR + 4, steel, 1);\n  }\n  for (const yy of [YP - 3, YP + 4, YR - 3, YR + 4]) {\n    px(buf, TX0 - 3, yy, steel, 0.6);\n    px(buf, TX1 + 3, yy, steel, 0.6);\n  }\n  if (S.curRx && S.ph \u003c 0.5) {\n    for (let b = 0; b \u003c 5; b++) {\n      const at = 0.07 + 0.07 * b;\n      if (S.ph >= at && (S.curRx.code >> (4 - b)) & 1) disc(buf, HX[b] + 0.5, YP + 0.5, 0.9, gold, smooth((S.ph - at) / 0.05));\n    }\n  }\n  // The punch fires: a flash round the new holes.\n  const last = S.rows[S.rows.length - 1];\n  if (last && last.age \u003c 0.25) {\n    const y = YP - (S.T - last.n) * RP, a = 1 - last.age / 0.25;\n    for (let b = 0; b \u003c 5; b++) if ((last.code >> (4 - b)) & 1) disc(buf, HX[b] + 0.5, y + 0.5, 2.4, white, a, 0.8);\n  }\n\n  // The reader: a pin over each hole column, dropped through where it\n  // finds a hole, resting on the paper where it does not.\n  for (let b = 0; b \u003c 5; b++) {\n    const through = under && (under.code >> (4 - b)) & 1;\n    disc(buf, HX[b] + 0.5, YR + 0.5, through ? 1.1 : 0.7, through ? gold : steel, 1);\n  }\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","beading-letters":"// ===== Patternflow pattern =====\n// Title:   Beading Letters\n// Family:  type\n// Idea:    A three-letter word stacked down the panel in capitals 37 rows tall is poured stroke by stroke as round glossy threads of liquid, and every thread then does what Plateau and Rayleigh showed a cylinder of liquid must do: a ripple about nine and a half radii long grows on it from almost nothing, the strokes neck and pinch off roughly in the order they were poured, and each breaks into evenly spaced drops with a small satellite between them that ring and round off, so the word stands as a dotted, dot-matrix version of itself until the drops run off the bottom and the next word is poured.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Plateau-Rayleigh instability (Joseph Plateau, 1873; Lord Rayleigh, 1878), with the viscous term of Weber's long-wave equation (Constantin Weber, 1931) and the ringing of a drop in Rayleigh's lowest shape mode (Lord Rayleigh, 1879) damped at the rate Horace Lamb gave for a viscous drop; capitals drawn for this pattern as lines and elliptical arcs, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Thickness=1.5..2.5, Viscosity=0..1\n//\n// Knob 1: Hue. The liquid's colour, turned round the wheel from cyan at 0: violet at 0.25, red at 0.5, yellow green at 0.75. The highlight on every thread and drop stays white, and the caustic beside it is the liquid's colour paled.\n// Knob 2: Speed. At 2 DEW is poured in 1.7 s, its first stroke breaks at 2.3 s and its last at 3.6 s, the dotted word holds 2 s, and at 5.6 s the drops let go and run off the bottom while INK is poured from 5.8 s. Every time goes as 2 / Speed, ten times slower at 0.2 and one and a half times faster at 3.\n// Knob 3: Thickness. The thread's radius in LEDs, from 1.5 at the opening (a thread 3 LEDs across) to 2.5. The fastest ripple is 14.4 LEDs long at 1.5 and 24 at 2.5, so the stem of the D breaks into four drops at 1.5 and keeps only its two corner drops at 2.5, and a drop from the middle of a stroke grows from 5.5 LEDs across to about 9.5. A thicker thread is also slower, as the radius to the power 1.5: at 2.5 everything takes 2.15 times as long.\n// Knob 4: Viscosity. The Ohnesorge number, the liquid's viscosity against its surface tension at this size, from 0 to 1. The fastest ripple is 9.02 radii long at 0, 9.6 at the opening 0.06 and 16.1 at 1, so a thicker liquid breaks into fewer, bigger drops, 2.7 times more slowly, and its threads draw out into thin filaments between bulbs before they snap. At the opening a drop rings about once every 0.83 s and the ringing falls by e in 1.7 s; from about 0.8 the drops creep round without ringing.\n\n// Plateau measured it and Rayleigh explained it: a long cylinder of liquid\n// held only by surface tension is unstable. Any ripple r = r0 (1 + a cos kz)\n// longer than the thread's circumference (k r0 \u003c 1) lowers the surface area\n// at fixed volume, so it grows, as a = a0 exp(sigma t). Rayleigh's growth\n// rate for an inviscid thread, in units of tau = sqrt(rho r0^3 / gamma), is\n//   sigma^2 = x (1 - x^2) I1(x) / I0(x),   x = k r0,\n// largest at x = 0.697, a wavelength of 9.02 radii, with sigma = 0.343.\n// Viscosity enters through Weber's long-wave equation, which adds a damping\n// term 3 Oh x^2 sigma to the left; here that term is added to Rayleigh's\n// exact right-hand side, so Oh = 0 gives Rayleigh's numbers back.\n//\n// Each stroke of a letter is a thread of length L with free ends. Its modes\n// are cos(2 pi n s / L), with a crest at both ends (a free end gathers\n// liquid), and of the whole numbers n the stroke takes the one whose sigma\n// is largest: the fastest ripple that fits. Its crests are where the drops\n// form, so a stroke always ends in a drop and every corner of a letter, where\n// strokes meet, gets one drop that all of them feed; it forms as soon as the\n// first of them breaks, as a bulb on the ends of the others. The ripple grows\n// from a small random a0, 0.012 to 0.03, from the moment the liquid is laid,\n// so the word pinches roughly in the order it was poured. The volume per\n// wavelength is kept: r0 shrinks as a grows, and each drop gets the volume of\n// the thread it came from, a free end the volume of a whole wavelength. With\n// viscosity the profile is sharpened into bulbs on thin filaments.\n//\n// After a pinch each drop starts stretched along its stroke and relaxes as a\n// spheroid of fixed volume, ringing in Rayleigh's lowest shape mode, omega^2\n// = 8 gamma / (rho R^3), damped at Lamb's rate 5 nu / R^2. A small satellite\n// is left where each neck broke.\n//\n// Every thread and drop is drawn as a body of revolution: for each LED the\n// nearest point of the stroke, its arc length s and the side the LED is on\n// give a surface normal, which a light from the upper left shades with a\n// white highlight and a glow on the far side, as light passes through.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sqrt, sin, cos, exp, log, pow, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst WORDS = [\"DEW\", \"INK\", \"OIL\", \"SEA\", \"WET\", \"SAP\", \"TAR\", \"GEL\"];\n// Letters 37 rows tall, 8 units of 4.625 LEDs, at rows 3, 45.5 and 88.\nconst LH = 37, U = LH / 8, TOP = 3, PITCH = 42.5;\n// Model seconds (real seconds at Speed 2).\nconst POUR = 1.2, JUMP = 0.05, HOLD = 2.0, NEXT = 0.25, FALL = 520, TAU0 = 0.15, R0REF = 1.5;\nconst HUE0 = 0.5;\n\n// Strokes: a start point, then \"L\" x y for a line or \"A\" cx cy rx ry a0 a1\n// for an elliptical arc in degrees (y down); \"Z\" closes the stroke.\n// All joins between strokes are at stroke ends.\nconst GLYPHS = {\n  D: [10, [[0, 0, \"L\", 0, 8], [0, 0, \"L\", 5, 0, \"A\", 5, 4, 5, 4, -90, 90, \"L\", 0, 8]]],\n  E: [9, [[0, 0, \"L\", 0, 4], [0, 4, \"L\", 0, 8], [0, 0, \"L\", 9, 0], [0, 4, \"L\", 7, 4], [0, 8, \"L\", 9, 8]]],\n  W: [11, [[0, 0, \"L\", 2.75, 8], [2.75, 8, \"L\", 5.5, 1.5], [5.5, 1.5, \"L\", 8.25, 8], [8.25, 8, \"L\", 11, 0]]],\n  I: [6, [[0, 0, \"L\", 3, 0], [3, 0, \"L\", 6, 0], [3, 0, \"L\", 3, 8], [0, 8, \"L\", 3, 8], [3, 8, \"L\", 6, 8]]],\n  N: [9, [[0, 8, \"L\", 0, 0], [0, 0, \"L\", 9, 8], [9, 8, \"L\", 9, 0]]],\n  K: [9, [[0, 0, \"L\", 0, 4.5], [0, 4.5, \"L\", 0, 8], [0, 4.5, \"L\", 9, 0], [0, 4.5, \"L\", 9, 8]]],\n  O: [10, [[10, 4, \"A\", 5, 4, 5, 4, 0, 360, \"Z\"]]],\n  L: [8, [[0, 0, \"L\", 0, 8], [0, 8, \"L\", 8, 8]]],\n  S: [9, [[8.397, 1, \"A\", 4.5, 2, 4.5, 2, -30, -270, \"A\", 4.5, 6, 4.5, 2, -90, 150]]],\n  A: [10, [[0, 8, \"L\", 1.5625, 5.5], [1.5625, 5.5, \"L\", 5, 0], [5, 0, \"L\", 8.4375, 5.5], [8.4375, 5.5, \"L\", 10, 8], [1.5625, 5.5, \"L\", 8.4375, 5.5]]],\n  T: [10, [[0, 0, \"L\", 5, 0], [5, 0, \"L\", 10, 0], [5, 0, \"L\", 5, 8]]],\n  P: [9, [[0, 0, \"L\", 0, 4.6], [0, 4.6, \"L\", 0, 8], [0, 0, \"L\", 5, 0, \"A\", 5, 2.3, 4, 2.3, -90, 90, \"L\", 0, 4.6]]],\n  R: [9, [[0, 0, \"L\", 0, 4.6], [0, 4.6, \"L\", 0, 8], [0, 0, \"L\", 5, 0, \"A\", 5, 2.3, 4, 2.3, -90, 90], [5, 4.6, \"L\", 0, 4.6], [5, 4.6, \"L\", 9, 8]]],\n  G: [10, [[8.83, 1.429, \"A\", 5, 4, 5, 4, -40, -360], [10, 4, \"L\", 6, 4]]],\n};\n\n// ---- Rayleigh's growth rate with Weber's viscous term.\nfunction besselRatio(x) {\n  let t0 = 1, t1 = x / 2, i0 = 0, i1 = 0;\n  const h = (x * x) / 4;\n  for (let k = 0; k \u003c 10; k++) {\n    i0 += t0;\n    i1 += t1;\n    t0 *= h / ((k + 1) * (k + 1));\n    t1 *= h / ((k + 1) * (k + 2));\n  }\n  return i1 / i0;\n}\n\nfunction growth(x, oh) {\n  if (x >= 1) return 0;\n  const f = x * (1 - x * x) * besselRatio(x), b = 3 * oh * x * x;\n  return (-b + sqrt(b * b + 4 * f)) / 2;\n}\n\n// ---- Stroke geometry, in LEDs.\nfunction strokeOf(cmd, ox, oy) {\n  const xs = [ox + cmd[0] * U], ys = [oy + cmd[1] * U];\n  let closed = false;\n  for (let i = 2; i \u003c cmd.length; ) {\n    const c = cmd[i];\n    if (c === \"L\") {\n      xs.push(ox + cmd[i + 1] * U);\n      ys.push(oy + cmd[i + 2] * U);\n      i += 3;\n    } else if (c === \"A\") {\n      const cx = cmd[i + 1], cy = cmd[i + 2], rx = cmd[i + 3], ry = cmd[i + 4], a0 = (cmd[i + 5] * PI) / 180, a1 = (cmd[i + 6] * PI) / 180;\n      const steps = max(4, ceil((abs(a1 - a0) * sqrt((rx * rx + ry * ry) / 2) * U) / 0.8));\n      for (let k = 0; k \u003c= steps; k++) {\n        const a = a0 + ((a1 - a0) * k) / steps;\n        xs.push(ox + (cx + rx * cos(a)) * U);\n        ys.push(oy + (cy + ry * sin(a)) * U);\n      }\n      i += 7;\n    } else {\n      closed = true;\n      i++;\n    }\n  }\n  // Drop repeated points, measure arc length.\n  const px = [xs[0]], py = [ys[0]], ps = [0];\n  for (let k = 1; k \u003c xs.length; k++) {\n    const d = sqrt((xs[k] - px[px.length - 1]) ** 2 + (ys[k] - py[py.length - 1]) ** 2);\n    if (d \u003c 1e-4) continue;\n    px.push(xs[k]);\n    py.push(ys[k]);\n    ps.push(ps[ps.length - 1] + d);\n  }\n  return { px, py, ps, L: ps[ps.length - 1], closed };\n}\n\n// Point and unit tangent at arc length s.\nfunction at(st, s, o) {\n  const { px, py, ps } = st;\n  let i = 0;\n  while (i \u003c ps.length - 2 && ps[i + 1] \u003c s) i++;\n  const len = ps[i + 1] - ps[i], u = cl((s - ps[i]) / len, 0, 1);\n  o[0] = px[i] + (px[i + 1] - px[i]) * u;\n  o[1] = py[i] + (py[i + 1] - py[i]) * u;\n  o[2] = (px[i + 1] - px[i]) / len;\n  o[3] = (py[i + 1] - py[i]) / len;\n  return o;\n}\n\nfunction wordOf(index) {\n  const text = WORDS[index], strokes = [];\n  for (let l = 0; l \u003c text.length; l++) {\n    const [w, cmds] = GLYPHS[text[l]];\n    const ox = 32 - (w * U) / 2, oy = TOP + l * PITCH;\n    for (const c of cmds) {\n      const st = strokeOf(c, ox, oy);\n      st.letter = l;\n      st.eps = 0.012 + 0.018 * Math.random();\n      st.envP = TAU * Math.random();\n      strokes.push(st);\n    }\n  }\n  return { index, strokes, beads: [], sats: [], S0: 0, Td: 1e9 };\n}\n\n// ---- Timing and drops for the current knobs: the mode each stroke takes,\n// when it pinches, and the drops it leaves.\nfunction plan(S, wd) {\n  const r0 = S.r0, oh = S.oh, tau = TAU0 * pow(r0 / R0REF, 1.5);\n  let total = 0;\n  for (const st of wd.strokes) total += st.L;\n  const v = total / POUR, tmp = [0, 0, 0, 0];\n  // The fastest growth an endless thread could have, for the floor below.\n  let smax = 0;\n  for (let x = 0.02; x \u003c 1; x += 0.01) smax = max(smax, growth(x, oh));\n  let t = wd.S0;\n  wd.beads = [];\n  wd.sats = [];\n  const nodes = [];\n  for (const st of wd.strokes) {\n    let best = -1, bn = st.closed ? 2 : 1;\n    for (let n = st.closed ? 2 : 1; n \u003c 40; n++) {\n      const g = growth((TAU * n * r0) / st.L, oh);\n      if (g > best) {\n        best = g;\n        bn = n;\n      }\n      if ((TAU * n * r0) / st.L >= 1) break;\n    }\n    st.n = bn;\n    st.k = (TAU * bn) / st.L;\n    // A stroke too short for a fast ripple (at 2.5 LEDs the serif of the I\n    // has k r0 >= 1 for every n) still balls up into its end drops, here at\n    // no less than 0.6 of the fastest rate.\n    st.sig = max(best, 0.6 * smax);\n    st.tau = tau;\n    st.v = v;\n    st.r0 = r0;\n    st.t0 = t;\n    st.t1 = t + st.L / v;\n    // A slow swell 2.7 wavelengths long lets some crests grow ahead of others.\n    st.envK = TAU / (2.7 * 9.6 * r0);\n    st.tp = max(st.t1 + 0.2, t + st.L / (2 * v) + (tau * log(1 / st.eps)) / st.sig);\n    t = st.t1 + JUMP;\n    const vol = PI * r0 * r0 * (st.L / bn);\n    const first = st.closed ? 0 : 1;\n    for (let k = first; k \u003c bn; k++) {\n      at(st, (k * st.L) / bn, tmp);\n      wd.beads.push({ x: tmp[0], y: tmp[1], tx: tmp[2], ty: tmp[3], V: vol, act: st.tp, e0: 0.5 });\n    }\n    for (let k = 0; k \u003c bn; k++) {\n      at(st, ((k + 0.5) * st.L) / bn, tmp);\n      wd.sats.push({ x: tmp[0], y: tmp[1], act: st.tp + 0.04, fall: 0 });\n    }\n    if (!st.closed)\n      for (const e of [0, 1]) {\n        at(st, e * st.L, tmp);\n        let node = null;\n        for (const nd of nodes) if (nd.letter === st.letter && abs(nd.x - tmp[0]) \u003c 0.6 && abs(nd.y - tmp[1]) \u003c 0.6) node = nd;\n        if (!node) {\n          node = { letter: st.letter, x: tmp[0], y: tmp[1], tx: tmp[2], ty: tmp[3], V: 0, act: 1e9, m: 0, e0: 0.2 };\n          nodes.push(node);\n        }\n        node.V += vol / 2;\n        node.m++;\n        node.act = min(node.act, st.tp);\n      }\n  }\n  // A free end gathers the liquid of the end it retracts from.\n  for (const nd of nodes) {\n    if (nd.m === 1) nd.V *= 2;\n    wd.beads.push(nd);\n  }\n  let last = 0;\n  for (const st of wd.strokes) last = max(last, st.tp);\n  for (const b of wd.beads) {\n    b.R = Math.cbrt((3 * b.V) / (4 * PI));\n    const q = r0 / b.R;\n    b.w = sqrt(8 * q * q * q) / tau;\n    b.g = (5 * oh * q * q) / tau;\n    b.fall = b.fall || 0;\n    last = max(last, b.act);\n  }\n  wd.Td = last + HOLD;\n  wd.v = v;\n  wd.Q = 1 + 2 * oh;\n  // Means of the sharpened profile c' over a period, for the volume.\n  let m1 = 0, m2 = 0;\n  for (let i = 0; i \u003c 64; i++) {\n    const c = 2 * pow((1 + cos((TAU * (i + 0.5)) / 64)) / 2, wd.Q) - 1;\n    m1 += c / 64;\n    m2 += (c * c) / 64;\n  }\n  wd.m1 = m1;\n  wd.m2 = m2;\n}\n\n// ---- For every LED near a stroke, the nearest point of up to two strokes.\nfunction buildMap(S, wd) {\n  const reach = (S.reach = 2.2 * S.r0 + 1.2);\n  const { sj, sd, ss, sdx, sdy, stx, sty, scap } = S;\n  sj.fill(-1);\n  wd.strokes.forEach((st, j) => {\n    const { px, py, ps } = st, last = px.length - 2;\n    for (let i = 0; i \u003c= last; i++) {\n      const ax = px[i], ay = py[i], len = ps[i + 1] - ps[i];\n      const tx = (px[i + 1] - ax) / len, ty = (py[i + 1] - ay) / len;\n      const x0 = max(0, floor(min(ax, px[i + 1]) - reach)), x1 = min(W - 1, ceil(max(ax, px[i + 1]) + reach));\n      const y0 = max(0, floor(min(ay, py[i + 1]) - reach)), y1 = min(H - 1, ceil(max(ay, py[i + 1]) + reach));\n      for (let y = y0; y \u003c= y1; y++)\n        for (let x = x0; x \u003c= x1; x++) {\n          const qx = x + 0.5 - ax, qy = y + 0.5 - ay;\n          let t = qx * tx + qy * ty, cap = 0;\n          if (t \u003c 0) {\n            if (!st.closed && i === 0) cap = 1;\n            t = 0;\n          } else if (t > len) {\n            if (!st.closed && i === last) cap = 1;\n            t = len;\n          }\n          let dx = qx - tx * t, dy = qy - ty * t;\n          const d = sqrt(dx * dx + dy * dy);\n          if (d > reach) continue;\n          if (d > 1e-6) {\n            dx /= d;\n            dy /= d;\n          } else {\n            dx = -ty;\n            dy = tx;\n          }\n          const p = (y * W + x) * 2;\n          let k = -1;\n          if (sj[p] === j) k = d \u003c sd[p] ? p : -2;\n          else if (sj[p + 1] === j) k = d \u003c sd[p + 1] ? p + 1 : -2;\n          else if (sj[p] \u003c 0) k = p;\n          else if (sj[p + 1] \u003c 0) k = p + 1;\n          else k = sd[p] > sd[p + 1] ? (d \u003c sd[p] ? p : -2) : d \u003c sd[p + 1] ? p + 1 : -2;\n          if (k \u003c 0) continue;\n          sj[k] = j;\n          sd[k] = d;\n          ss[k] = ps[i] + t;\n          sdx[k] = dx;\n          sdy[k] = dy;\n          stx[k] = tx;\n          sty[k] = ty;\n          scap[k] = cap;\n        }\n    }\n  });\n  let n = 0;\n  for (let p = 0; p \u003c N; p++) if (sj[p * 2] >= 0) S.active[n++] = p;\n  S.nActive = n;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, r0: 1.5, oh: 0.06, m: 0, idx: 0, cur: null, old: null, reach: 4.5,\n    sj: new Int16Array(N * 2), sd: new Float32Array(N * 2), ss: new Float32Array(N * 2),\n    sdx: new Float32Array(N * 2), sdy: new Float32Array(N * 2), stx: new Float32Array(N * 2),\n    sty: new Float32Array(N * 2), scap: new Int8Array(N * 2), active: new Int32Array(N), nActive: 0,\n    K: new Float32Array(N), C: new Float32Array(N), NX: new Float32Array(N), NY: new Float32Array(N), NZ: new Float32Array(N),\n    CA: new Float32Array(N), CB: new Float32Array(N),\n    base: [0, 0, 0], tmp: [0, 0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1.5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const r0 = cl(k[2] == null ? 1.5 : k[2], 1.5, 2.5), oh = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const newR = abs(r0 - S.r0) > 0.004, newOh = abs(oh - S.oh) > 0.002;\n  if (newR) S.r0 = r0;\n  if (newOh) S.oh = oh;\n  if (!S.cur) {\n    S.cur = wordOf(S.idx);\n    S.cur.S0 = 0;\n    plan(S, S.cur);\n    buildMap(S, S.cur);\n  } else if (newR || newOh) {\n    plan(S, S.cur);\n    if (newR) buildMap(S, S.cur);\n  }\n  S.m += (d * S.speed) / 2;\n  const cur = S.cur;\n  if (S.m >= cur.Td) {\n    // The drops let go and run off the bottom; the next word is poured.\n    for (const b of cur.beads) b.fall = cur.Td + 0.35 * Math.random();\n    for (const b of cur.sats) b.fall = cur.Td + 0.35 * Math.random();\n    S.old = cur;\n    S.idx = (S.idx + 1) % WORDS.length;\n    const nw = wordOf(S.idx);\n    nw.S0 = cur.Td + NEXT;\n    plan(S, nw);\n    buildMap(S, nw);\n    S.cur = nw;\n  }\n  if (S.old && S.m > S.old.Td + 1.2) S.old = null;\n}\n\n// The radius of stroke st at arc length s, and its slope, at model time t.\nfunction profile(wd, st, s, t, o) {\n  let a = st.eps * exp((st.sig * (t - st.t0 - s / st.v)) / st.tau);\n  a *= 1 + 0.15 * sin(st.envK * s + st.envP);\n  if (a > 1) a = 1;\n  const ph = st.k * s, base = (1 + cos(ph)) / 2, bq = pow(base, wd.Q - 1);\n  const c = 2 * base * bq - 1, den = st.r0 / sqrt(1 + 2 * a * wd.m1 + a * a * wd.m2);\n  o[0] = den * (1 + a * c);\n  o[1] = den * a * -wd.Q * bq * sin(ph) * st.k;\n}\n\nfunction wobble(b, t) {\n  const e0 = b.e0, w = b.w, g = b.g;\n  if (g \u003c w * 0.999) {\n    const wd = sqrt(w * w - g * g);\n    return e0 * exp(-g * t) * (cos(wd * t) + (g / wd) * sin(wd * t));\n  }\n  const r = sqrt(max(1e-9, g * g - w * w)), r1 = -g + r, r2 = -g - r;\n  return (e0 * (r1 * exp(r2 * t) - r2 * exp(r1 * t))) / (r1 - r2);\n}\n\n// A spheroid of semi-axes a along (tx, ty) and b across and up, into the\n// buffers: the topmost surface wins each LED.\nfunction spheroid(S, cx, cy, tx, ty, a, b) {\n  const { K, C, NX, NY, NZ } = S, ext = max(a, b) + 1;\n  const x0 = max(0, floor(cx - ext)), x1 = min(W - 1, ceil(cx + ext)), y0 = max(0, floor(cy - ext)), y1 = min(H - 1, ceil(cy + ext));\n  const ia = 1 / (a * a), ib = 1 / (b * b);\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const qx = x + 0.5 - cx, qy = y + 0.5 - cy, u = qx * tx + qy * ty, w = -qx * ty + qy * tx;\n      const q = u * u * ia + w * w * ib, sq = sqrt(q), gx = u * ia, gy = w * ib, g = sqrt(gx * gx + gy * gy);\n      const c = g \u003c 1e-9 ? 1 : cl(0.5 - ((sq - 1) * sq) / g, 0, 1);\n      if (c \u003c= 0) continue;\n      const h = q \u003c 1 ? b * sqrt(1 - q) : 0, key = h + c, p = y * W + x;\n      if (c > C[p]) C[p] = c;\n      if (key \u003c= K[p]) continue;\n      K[p] = key;\n      let nx = gx * tx - gy * ty, ny = gx * ty + gy * tx, nz = h * ib;\n      const l = sqrt(nx * nx + ny * ny + nz * nz) || 1;\n      NX[p] = nx / l;\n      NY[p] = ny / l;\n      NZ[p] = nz / l;\n    }\n}\n\nfunction drops(S, wd, t) {\n  for (const b of wd.beads) {\n    if (t \u003c b.act) continue;\n    let e = cl(wobble(b, t - b.act), -0.45, 1), tx = b.tx, ty = b.ty, y = b.y;\n    if (b.fall && t > b.fall) {\n      const f = t - b.fall;\n      y += 0.5 * FALL * f * f;\n      e = min(0.6, FALL * f * 0.004);\n      tx = 0;\n      ty = 1;\n    }\n    if (y - b.R * 2 > H) continue;\n    spheroid(S, b.x, y, tx, ty, b.R * (1 + e), b.R / sqrt(1 + e));\n  }\n  const rs = 0.4 * S.r0;\n  for (const sa of wd.sats) {\n    if (t \u003c sa.act) continue;\n    let y = sa.y;\n    if (sa.fall && t > sa.fall) y += 0.5 * FALL * (t - sa.fall) ** 2;\n    if (y - 2 > H) continue;\n    const grow = cl((t - sa.act) / 0.15, 0, 1);\n    spheroid(S, sa.x, y, 1, 0, rs * grow + 0.01, rs * grow + 0.01);\n  }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The light: from the upper left and in front.\nconst LX = -0.45, LY = -0.6, LZ = 0.66, LN = sqrt(LX * LX + LY * LY + LZ * LZ);\nconst lx = LX / LN, ly = LY / LN, lz = LZ / LN, HN = sqrt(lx * lx + ly * ly + (lz + 1) ** 2);\nconst hx = lx / HN, hy = ly / HN, hz = (lz + 1) / HN, LP = sqrt(lx * lx + ly * ly);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cur) return;\n  const { K, C, NX, NY, NZ, sj, sd, ss, sdx, sdy, stx, sty, scap, active } = S;\n  const t = S.m, wd = S.cur, reach = S.reach, pr = [0, 0], head = S.tmp;\n  K.fill(-1);\n  C.fill(0);\n\n  // Where each stroke of the current word stands: 0 not poured yet, 1 being\n  // poured (head = arc length reached), 2 a thread, 3 broken into drops.\n  for (const st of wd.strokes) {\n    st.state = t \u003c st.t0 ? 0 : t \u003c st.t1 ? 1 : t \u003c st.tp ? 2 : 3;\n    if (st.state === 1) {\n      st.head = (t - st.t0) * st.v;\n      at(st, st.head, head);\n      st.hx = head[0];\n      st.hy = head[1];\n    }\n  }\n\n  for (let a = 0; a \u003c S.nActive; a++) {\n    const p = active[a], X = (p % W) + 0.5, Y = floor(p / W) + 0.5;\n    for (let q = p * 2; q \u003c p * 2 + 2; q++) {\n      const j = sj[q];\n      if (j \u003c 0) break;\n      const st = wd.strokes[j];\n      if (st.state === 0 || st.state === 3) continue;\n      let s = ss[q], dist = sd[q], dx = sdx[q], dy = sdy[q], cap = scap[q];\n      if (st.state === 1 && s > st.head) {\n        if (s - st.head > reach) continue;\n        dx = X - st.hx;\n        dy = Y - st.hy;\n        dist = sqrt(dx * dx + dy * dy);\n        if (dist > reach) continue;\n        if (dist > 1e-6) {\n          dx /= dist;\n          dy /= dist;\n        }\n        s = st.head;\n        cap = 1;\n      }\n      profile(wd, st, s, t, pr);\n      const r = pr[0], dr = cap ? 0 : pr[1];\n      if (r \u003c 0.03) continue;\n      const c = min(1, r - dist + 0.5);\n      if (c \u003c= 0) continue;\n      const h = dist \u003c r ? sqrt(r * r - dist * dist) : 0, key = h + c;\n      if (c > C[p]) C[p] = c;\n      if (key \u003c= K[p]) continue;\n      K[p] = key;\n      const ct = min(1, dist / r);\n      let nx = -dr * stx[q] + ct * dx, ny = -dr * sty[q] + ct * dy, nz = h / r;\n      const l = sqrt(nx * nx + ny * ny + nz * nz) || 1;\n      NX[p] = nx / l;\n      NY[p] = ny / l;\n      NZ[p] = nz / l;\n    }\n  }\n  drops(S, wd, t);\n  if (S.old) drops(S, S.old, t);\n\n  // The caustic: light through each thread or drop comes to a focus on the\n  // dark ground beyond it, down and to the right, brightest behind the\n  // thickest liquid. Shifted 1.5 and 2 LEDs, then softened once.\n  const { CA, CB } = S;\n  CA.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    const c = C[p];\n    if (c \u003c= 0) continue;\n    const x = p % W, y = floor(p / W) + 2;\n    if (y >= H || x + 2 >= W) continue;\n    const w = c * (0.09 + 0.28 * NZ[p]) * 0.5;\n    CA[y * W + x + 1] += w;\n    CA[y * W + x + 2] += w;\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W;\n    let v = CA[p] * 0.6;\n    if (x > 0) v += CA[p - 1] * 0.1;\n    if (x \u003c W - 1) v += CA[p + 1] * 0.1;\n    if (p >= W) v += CA[p - W] * 0.1;\n    if (p \u003c N - W) v += CA[p + W] * 0.1;\n    CB[p] = min(0.4, v);\n  }\n\n  const base = hsv(S.hue + HUE0, 0.8, 1, S.base);\n  const kr = base[0] * 0.8 + 0.2, kg = base[1] * 0.8 + 0.2, kb = base[2] * 0.8 + 0.2;\n  for (let p = 0; p \u003c N; p++) {\n    const c = C[p], ca = CB[p] * (1 - c);\n    let r = ca * kr, g = ca * kg, b = ca * kb;\n    if (c > 0) {\n      const nx = NX[p], ny = NY[p], nz = NZ[p];\n      const diff = max(0, nx * lx + ny * ly + nz * lz);\n      const sh = max(0, nx * hx + ny * hy + nz * hz), spec = pow(sh, 28);\n      const back = max(0, -(nx * lx + ny * ly) / LP) * (1 - nz);\n      const v = 0.22 + 0.62 * diff + 0.5 * back;\n      r += c * (base[0] * v + spec);\n      g += c * (base[1] * v + spec);\n      b += c * (base[2] * v + spec);\n    }\n    display.setPixel(p % W, floor(p / W), floor(cl(r, 0, 1) * 255), floor(cl(g, 0, 1) * 255), floor(cl(b, 0, 1) * 255));\n  }\n}\n","cornsweet-letters":"// ===== Patternflow pattern =====\n// Title:   Cornsweet Letters\n// Family:  type\n// Idea:    Three bold letters stacked down the tall panel are filled with exactly the ground's own colour and differ from it only along their outlines, where a sharp step falls back to the ground level within 4.5 LEDs inside and 6 outside, so a letter whose step is lighter on the inside looks lighter than the ground and one whose step is darker looks darker, and as each letter's step turns over, a third of a turn after the one above, the same untouched interiors seem to brighten, vanish into the ground and darken.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Craik-O'Brien-Cornsweet illusion (Vernon O'Brien, 1958; Kenneth Craik, 1966; Tom Cornsweet, 1970), with letters drawn for this pattern as round-ended strokes, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Cover=0..1\n//\n// Knob 1: Hue. The ground's hue, letters and all, since the letters are the ground. At 0 a slate azure, at 0.25 violet, at 0.5 a terracotta brown, at 0.75 green.\n// Knob 2: Speed. How fast each letter's step turns from lighter inside to darker inside and back: one turn in 12 s at 1, 6 s at the opening 2, 60 s at 0.2 and 4 s at 3. The letters are a third of a turn apart, so at any moment one of them is near its lightest and another near its darkest.\n// Knob 3: Word. LIT, DIM, LUX (the unit of illuminance) and NIT (the unit of luminance), a quarter of the knob each.\n// Knob 4: Cover. Lays a dark band over the outlines, the way a pencil laid along the edge of Cornsweet's figure takes the illusion away. Nothing up to 0.1, then the band grows until at 1 it covers the whole profile, 4.5 LEDs in and 6 out, and leaves the inner strips of each stroke next to the open ground, the same colour on both sides of the band.\n\n// The illusion carries the names of O'Brien, Craik and Cornsweet. Take a\n// uniform field, and along a border put a sharp step that falls back on\n// both sides to the field's own level: lighter just inside, darker just\n// outside. The inside then looks lighter all the way across, though away\n// from the border it sends out exactly the light the outside does. Cover\n// the border and both sides look the same.\n//\n// Here the border is a letter's outline. Each LED's distance to it comes\n// from a distance transform of the letter drawn five times finer than the\n// panel. The profile is a parabola in that distance, a (1 - d/w)^2 with\n// w = 4.5 LEDs inside and 6 outside, so it reaches the ground level exactly\n// and the LEDs past it are the ground's own colour, bit for bit, inside the\n// letter or not. The height a of the step turns as a cosine: positive, the\n// letter looks lighter; zero, it is gone; negative, it looks darker. Where\n// two letters' outer profiles meet in the gap between them they add.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Ground level, the step's half height at its largest, and how far the\n// profile reaches inside and outside (LEDs).\nconst G = 118, C = 88, WIN = 4.5, WOUT = 6;\nconst SS = 5; // the distance grid has SS x SS cells per LED\nconst HUE0 = 0.55, SAT = 0.62, COVER = 26;\n\n// Letters as strokes on a unit box, x right and y down. \"a\" is an arc:\n// [cx, cy, rx, ry, from, to] in degrees, 0 to the right, 90 down.\nconst GLYPHS = {\n  L: [[0, 0, 0, 1], [0, 1, 1, 1]],\n  I: [[0.5, 0, 0.5, 1]],\n  T: [[0, 0, 1, 0], [0.5, 0, 0.5, 1]],\n  D: [[0, 0, 0, 1], [0, 0, 0.42, 0], [0, 1, 0.42, 1], [\"a\", 0.42, 0.5, 0.58, 0.5, -90, 90]],\n  M: [[0, 1, 0, 0], [0, 0, 0.5, 0.62], [0.5, 0.62, 1, 0], [1, 0, 1, 1]],\n  U: [[0, 0, 0, 0.5], [\"a\", 0.5, 0.5, 0.5, 0.5, 180, 0], [1, 0.5, 1, 0]],\n  X: [[0, 0, 1, 1], [1, 0, 0, 1]],\n  N: [[0, 1, 0, 0], [0, 0, 1, 1], [1, 1, 1, 0]],\n};\nconst WORDS = [\"LIT\", \"DIM\", \"LUX\", \"NIT\"];\n// Strokes 14 LEDs thick with round ends, letters 36 rows tall and 52 wide\n// with 6 rows between them and 4 above the first and below the last.\nconst RAD = 7, X0 = 13, X1 = 51, LH = 36, GAP = 6, TOP0 = 4;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, word: 0, cover: 0.06, t: 0, built: -1, n: 3,\n    dist: [0, 1, 2].map(() => new Float32Array(N)), inside: [0, 1, 2].map(() => new Uint8Array(N)),\n    lut: new Uint8Array(256 * 3), lh: -1, c: [0, 0, 0],\n  };\n}\n\n// Letter k's strokes as panel segments [x0, y0, x1, y1].\nfunction strokes(ch, k) {\n  const segs = [];\n  const top = TOP0 + k * (LH + GAP) + RAD, bot = TOP0 + k * (LH + GAP) + LH - RAD;\n  const px = (u) => X0 + (X1 - X0) * u, py = (v) => top + (bot - top) * v;\n  for (const s of GLYPHS[ch]) {\n    if (s[0] === \"a\") {\n      const [, cx, cy, rx, ry, a0, a1] = s, n = 12;\n      for (let j = 0; j \u003c n; j++) {\n        const t0 = ((a0 + ((a1 - a0) * j) / n) * PI) / 180, t1 = ((a0 + ((a1 - a0) * (j + 1)) / n) * PI) / 180;\n        segs.push([px(cx + rx * cos(t0)), py(cy + ry * sin(t0)), px(cx + rx * cos(t1)), py(cy + ry * sin(t1))]);\n      }\n    } else segs.push([px(s[0]), py(s[1]), px(s[2]), py(s[3])]);\n  }\n  return segs;\n}\n\nfunction segDist(x, y, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l2 = dx * dx + dy * dy;\n  const t = l2 > 0 ? cl(((x - s[0]) * dx + (y - s[1]) * dy) / l2, 0, 1) : 0;\n  const ex = x - s[0] - t * dx, ey = y - s[1] - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// One pass of the squared Euclidean distance transform along a line: the\n// lower envelope of parabolas (Felzenszwalb and Huttenlocher, 2004).\nfunction edt1(f, n, d, v, z) {\n  let k = 0;\n  v[0] = 0;\n  z[0] = -1e20;\n  z[1] = 1e20;\n  for (let q = 1; q \u003c n; q++) {\n    let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);\n    while (s \u003c= z[k]) {\n      k--;\n      s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);\n    }\n    k++;\n    v[k] = q;\n    z[k] = s;\n    z[k + 1] = 1e20;\n  }\n  k = 0;\n  for (let q = 0; q \u003c n; q++) {\n    while (z[k + 1] \u003c q) k++;\n    d[q] = (q - v[k]) * (q - v[k]) + f[v[k]];\n  }\n}\n\nfunction edt(grid, gw, gh) {\n  const n = max(gw, gh), f = new Float64Array(n), d = new Float64Array(n), v = new Int32Array(n), z = new Float64Array(n + 1);\n  for (let x = 0; x \u003c gw; x++) {\n    for (let y = 0; y \u003c gh; y++) f[y] = grid[y * gw + x];\n    edt1(f, gh, d, v, z);\n    for (let y = 0; y \u003c gh; y++) grid[y * gw + x] = d[y];\n  }\n  for (let y = 0; y \u003c gh; y++) {\n    for (let x = 0; x \u003c gw; x++) f[x] = grid[y * gw + x];\n    edt1(f, gw, d, v, z);\n    for (let x = 0; x \u003c gw; x++) grid[y * gw + x] = d[x];\n  }\n}\n\n// For each letter, every LED's distance to its outline and which side the\n// LED is on. Each letter gets its own field over its rows and 8 more above\n// and below, so where two outer profiles overlap they can add.\nfunction build(S) {\n  const word = WORDS[S.word], INF = 1e12, gw = W * SS, h = SS >> 1;\n  S.n = word.length;\n  for (let k = 0; k \u003c word.length; k++) {\n    const segs = strokes(word[k], k), D = S.dist[k], IN = S.inside[k];\n    D.fill(1e9);\n    IN.fill(0);\n    const y0 = max(0, TOP0 + k * (LH + GAP) - 8), y1 = min(H, TOP0 + k * (LH + GAP) + LH + 8), gh = (y1 - y0) * SS;\n    const toIn = new Float64Array(gw * gh), toOut = new Float64Array(gw * gh), ins = new Uint8Array(gw * gh);\n    for (let gy = 0; gy \u003c gh; gy++)\n      for (let gx = 0; gx \u003c gw; gx++) {\n        const x = (gx + 0.5) / SS, y = y0 + (gy + 0.5) / SS;\n        let dmin = 1e9;\n        for (const s of segs) {\n          const dd = segDist(x, y, s);\n          if (dd \u003c dmin) dmin = dd;\n        }\n        const i = gy * gw + gx, inn = dmin \u003c= RAD ? 1 : 0;\n        ins[i] = inn;\n        toIn[i] = inn ? 0 : INF;\n        toOut[i] = inn ? INF : 0;\n      }\n    edt(toIn, gw, gh);\n    edt(toOut, gw, gh);\n    for (let y = y0; y \u003c y1; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const g = ((y - y0) * SS + h) * gw + x * SS + h, i = y * W + x;\n        IN[i] = ins[g];\n        // From the cell's centre to the nearest cell on the other side,\n        // less half a cell: the distance to the outline between them.\n        D[i] = (sqrt(ins[g] ? toOut[g] : toIn[g]) - 0.5) / SS;\n      }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.word = min(WORDS.length - 1, floor(cl(k[2] || 0, 0, 1) * WORDS.length));\n  S.cover = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.t += d * S.speed;\n  if (S.t > 1200) S.t -= 1200;\n  if (S.built !== S.word) {\n    S.built = S.word;\n    build(S);\n  }\n}\n\n// One colour for everything: the ground's hue and saturation at each level.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let v = 0; v \u003c 256; v++) {\n    hsv(S.hue + HUE0, SAT, v / 255, S.c);\n    S.lut[v * 3] = round(S.c[0] * 255);\n    S.lut[v * 3 + 1] = round(S.c[1] * 255);\n    S.lut[v * 3 + 2] = round(S.c[2] * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const L = S.lut, n = S.n;\n  // Each letter's step height, a third of a turn behind the letter above.\n  const amp = [0, 0, 0];\n  for (let k = 0; k \u003c n; k++) amp[k] = C * cos(2 * PI * (S.t / 12 - k / 3));\n  const cv = max(0, S.cover - 0.1) / 0.9, cin = cv * WIN, cout = cv * WOUT;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let v = G, covered = false;\n      for (let k = 0; k \u003c n; k++) {\n        const dd = S.dist[k][i];\n        if (dd >= WOUT) continue;\n        if (S.inside[k][i]) {\n          if (dd \u003c cin) covered = true;\n          else if (dd \u003c WIN) v += amp[k] * (1 - dd / WIN) * (1 - dd / WIN);\n        } else if (dd \u003c cout) covered = true;\n        else v -= amp[k] * (1 - dd / WOUT) * (1 - dd / WOUT);\n      }\n      const o = (covered ? COVER : round(cl(v, 0, 255))) * 3;\n      display.setPixel(x, y, L[o], L[o + 1], L[o + 2]);\n    }\n}\n","dehn-twist":"// ===== Patternflow pattern =====\n// Title:   Dehn Twist\n// Family:  topology\n// Idea:    A shaded torus turns slowly in the upper half carrying a gold closed curve, and below it the flat square with opposite sides glued shows the same curve as straight segments; a thin green annulus round the tube lights up, its inside is dragged one full turn round the tube while its cut edge lets the curve's ends slide apart and meet again, and the curve relaxes to a straight one of class (p, q + p), so on the square it gains p more slanted segments and on the torus it winds p more times round the tube, until after a few twists it twists back as many times and the next curve takes its place.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dehn twist (Max Dehn, 1938), and Lickorish's theorem that Dehn twists generate the mapping class group of a closed orientable surface (W. B. R. Lickorish, 1962), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Curve=0..5, Twists=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the torus and the square are blue, the curve gold and the annulus green; at 0.25 the torus is magenta, the curve green and the annulus blue, at 0.5 the torus is amber and the curve blue, at 0.75 the torus is green and the curve pink.\n// Knob 2: Speed. At 2 a twist takes 2.5 s: 0.3 s for the annulus to light, 1.1 s of drag, 0.15 s to glue, 0.55 s to relax and 0.4 s held; every time goes as 2 / Speed, so 25 s a twist at 0.2 and 1.7 s at 3. The torus turns once in 30 s at 2.\n// Knob 3: Curve. The class (p, q) the curve starts from, p times round the long way and q times round the tube: 0 (1, 0), 1 (2, 1), 2 (1, -2), 3 (3, 1), 4 (2, -3), 5 (3, -1). After it has climbed and come back the next one on the list takes its place. Turning the knob starts the new curve at once.\n// Knob 4: Twists. How many twists the curve climbs before it twists back, and which way. From 0 to 1 each twist drags the annulus up the square and takes (p, q) to (p, q + p): 2 twists up to a third, 3 up to two thirds and 4 beyond. Below 0 it drags the other way, (p, q) to (p, q - p), with the same counts by the knob's size. A climb also stops early when the next curve would cut the square into more than 10 segments.\n\n// The torus is the square [0,1) x [0,1) with its left edge glued to its\n// right and its top to its bottom. U runs across the square and once round\n// the long way of the torus; V runs up the square and once round the tube.\n// A straight line through the square with slope q/p closes up after going\n// p times across and q times up: a simple closed curve of class (p, q)\n// whenever p and q have no common factor. On the square it crosses the\n// side edges p times and the top edge |q| times, so it is cut into p + |q|\n// segments.\n//\n// A meridian is a circle U = a, once round the tube. The Dehn twist about\n// it cuts the torus along that circle, turns one side a full turn and\n// glues it back: on the annulus a \u003c= U \u003c a + w it is\n//\n//   (U, V) -> (U, V + g((U - a) / w)),  g rising smoothly from 0 to 1,\n//\n// and the identity everywhere else. Each time the curve crosses the\n// annulus it is carried once round the tube, so (p, q) becomes (p, q + p);\n// the inverse twist gives (p, q - p). The meridian (0, 1) itself is left\n// alone, so every curve here has p >= 1. In the matrix picture the twist\n// is [[1, 0], [1, 1]] acting on (p, q).\n//\n// While the twist is under way the drag goes as s from 0 to 1: inside the\n// annulus V moves by s g, outside it does not, so the curve stays whole at\n// the annulus' left edge and comes apart at its right edge, where the cut\n// is, by s of a turn. At s = 1 the ends meet again. The green stripes on\n// the annulus are lines of the surface itself, V - s g constant, so they\n// shear into helices while it turns.\n//\n// The twisted curve is then pulled straight. Written as V(tau) over\n// tau in [0, 1) with U = p tau + c1, the twisted curve has\n// V(tau + k/p) - V(tau) = k q / p + k for k = 1, ..., p - 1, and so has\n// the straight line of class (p, q + p). Every mix of the two keeps that,\n// and none of those differences is a whole number, so the straight-line\n// homotopy between them passes only through simple curves of the class.\n//\n// The torus is ray marched once, at load: the view is orthographic and\n// fixed, so each LED keeps its hit point, normal and (U, V) for good, and\n// the turning only shifts U. The curve is drawn as a chain of 1600 dots,\n// each tested against the torus' depth; the parts on the far side show\n// faintly through.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, atan2, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst fr = (x) => x - floor(x);\n\n// The torus: radii, centre on the panel, the view's elevation above its\n// equator, and the camera's up and toward-viewer axes in torus space.\nconst RB = 21, RS = 9, CX = 32, CY = 28.5, EL = (56 * PI) / 180, TOP = 58;\nconst EY = [0, sin(EL), cos(EL)], EZ = [0, -cos(EL), sin(EL)];\n// The square: side, left and top edge.\nconst SQ = 56, SX = 4, SY = 67;\n// The annulus' width in U, the samples along the curve, and the most\n// segments a climb may cut the square into.\nconst AW = 0.1, NS = 1600, MAXSEG = 10;\nconst CURVES = [[1, 0], [2, 1], [1, -2], [3, 1], [2, -3], [3, -1]];\n// Seconds at Speed 2.\nconst PRE = 0.3, DRAG = 1.1, GLUE = 0.15, RELAX = 0.55, POST = 0.4, FADE = 0.35, SPIN = 1 / 30;\n\n// Light from the upper left, toward the viewer, in torus space.\nconst LIGHT = (() => {\n  const c = [-0.45, 0.62, 0.64], n = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);\n  return [c[0] / n, (c[1] * EY[1] + c[2] * EZ[1]) / n, (c[1] * EY[2] + c[2] * EZ[2]) / n];\n})();\nconst HALF = (() => {\n  const h = [LIGHT[0] + EZ[0], LIGHT[1] + EZ[1], LIGHT[2] + EZ[2]], n = sqrt(h[0] * h[0] + h[1] * h[1] + h[2] * h[2]);\n  return [h[0] / n, h[1] / n, h[2] / n];\n})();\n\n// Ray march the torus once: for each LED of the upper part, whether it\n// sees the torus, and where.\nconst TH = new Uint8Array(W * TOP), TU = new Float32Array(W * TOP), TV = new Float32Array(W * TOP);\nconst TZ = new Float32Array(W * TOP), TL = new Float32Array(W * TOP);\nfor (let py = 0; py \u003c TOP; py++)\n  for (let px = 0; px \u003c W; px++) {\n    const X = px + 0.5 - CX, Y = CY - (py + 0.5), i = py * W + px;\n    let t = 45;\n    for (let k = 0; k \u003c 200 && t > -45; k++) {\n      const x = X, y = Y * EY[1] + t * EZ[1], z = Y * EY[2] + t * EZ[2];\n      const rho = sqrt(x * x + y * y), q = rho - RB, d = sqrt(q * q + z * z) - RS;\n      if (d \u003c 0.002) {\n        const nx = (x - (RB * x) / rho) / RS, ny = (y - (RB * y) / rho) / RS, nz = z / RS;\n        const lam = max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]);\n        const sp = max(0, nx * HALF[0] + ny * HALF[1] + nz * HALF[2]);\n        TH[i] = 1;\n        TU[i] = atan2(y, x) / TAU;\n        TV[i] = fr((atan2(z, q) + PI / 2) / TAU);\n        TZ[i] = y * EZ[1] + z * EZ[2];\n        TL[i] = 0.2 + 0.68 * lam + 0.32 * sp ** 24;\n        break;\n      }\n      t -= d;\n    }\n  }\n\n// Small figures for the class label, rows of three bits, top first.\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n  \"-\": \"000000111000000\", \"(\": \"010100100100010\", \")\": \"010001001001010\", \",\": \"000000000010100\",\n};\n\nfunction hsv(h, s, v) {\n  h = fr(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// A soft dot of radius r into a coverage buffer, kept to rows y0..y1 and\n// columns x0..x1.\nfunction dot(A, x, y, r, a, x0, x1, y0, y1) {\n  const ax = max(x0, floor(x - r - 0.5)), bx = min(x1, floor(x + r + 0.5));\n  const ay = max(y0, floor(y - r - 0.5)), by = min(y1, floor(y + r + 0.5));\n  for (let yy = ay; yy \u003c= by; yy++)\n    for (let xx = ax; xx \u003c= bx; xx++) {\n      const dx = xx + 0.5 - x, dy = yy + 0.5 - y, c = cl(r + 0.5 - sqrt(dx * dx + dy * dy), 0, 1) * a, j = yy * W + xx;\n      if (c > A[j]) A[j] = c;\n    }\n}\n\nfunction begin(S, ci) {\n  S.ci = ((ci % CURVES.length) + CURVES.length) % CURVES.length;\n  S.p = CURVES[S.ci][0];\n  S.q = CURVES[S.ci][1];\n  S.c1 = 0.1;\n  S.c2 = 0.5 / S.p;\n  S.m = 0;\n  S.up = true;\n}\n\n// What comes after a twist: another the same way, the way back, or the\n// next curve.\nfunction plan(S) {\n  if (S.up) {\n    const d = S.n >= 0 ? 1 : -1, q2 = S.q + d * S.p;\n    if ((S.m === 0 || Math.sign(S.m) === d) && abs(S.m) \u003c abs(S.n) && S.p + abs(q2) \u003c= MAXSEG) return go(S, d);\n    S.up = false;\n  }\n  if (S.m !== 0) return go(S, -Math.sign(S.m));\n  S.mode = \"out\";\n  S.tm = 0;\n}\n\nfunction go(S, d) {\n  S.dir = d;\n  S.mode = \"pre\";\n  S.tm = 0;\n  // The annulus goes where the torus' left side will be halfway through\n  // the drag. Seen from the front a meridian is a vertical line and a turn\n  // round it hides; seen from the side it is an ellipse 18 LEDs wide.\n  S.a = fr(0.5 - (S.spin + SPIN * (PRE + DRAG / 2)) - AW / 2);\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, spin: 0.08, ci: -1, knob: -1, n: 2, mode: \"pre\", tm: 0, s: 0, lam: 0, hl: 0, fade: 1, glow: 0,\n    p: 1, q: 0, c1: 0, c2: 0, a: 0, dir: 1, m: 0, up: true, c2n: 0, c2a: 0, c2b: 0,\n    buf: new Float32Array(N * 3), A: new Float32Array(N), B: new Float32Array(N),\n    cu: new Float32Array(NS), cv: new Float32Array(NS), P: [0, 0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3), t4 = cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  S.n = (t4 \u003c 0 ? -1 : 1) * min(4, 2 + floor(abs(t4) * 3));\n  const kc = round(cl(k[2] || 0, 0, 5));\n  if (kc !== S.knob) {\n    S.knob = kc;\n    S.fade = 1;\n    S.glow = 0;\n    begin(S, kc);\n    plan(S);\n  }\n  const h = (d * speed) / 2;\n  S.spin = fr(S.spin + SPIN * h);\n  S.tm += h;\n  S.glow = max(0, S.glow - h * 3);\n  if (S.mode === \"pre\") {\n    S.hl = smooth(S.tm / PRE);\n    if (S.tm >= PRE) (S.mode = \"drag\"), (S.tm -= PRE);\n  }\n  if (S.mode === \"drag\") {\n    S.s = smooth(S.tm / DRAG);\n    if (S.tm >= DRAG) (S.mode = \"glue\"), (S.tm -= DRAG), (S.s = 1), (S.glow = 1);\n  }\n  if (S.mode === \"glue\" && S.tm >= GLUE) {\n    S.mode = \"relax\";\n    S.tm -= GLUE;\n    // The straight line the twisted curve relaxes to: same class plus the\n    // twist, at the offset that matches the twisted curve on average.\n    let mean = 0;\n    for (let i = 0; i \u003c NS; i++) {\n      const x = S.p * (i / NS) + S.c1 - S.a, kk = floor(x), f = x - kk;\n      mean += kk + (f \u003c AW ? smooth(f / AW) : 1);\n    }\n    S.c2n = S.c2 + S.dir * (mean / NS - S.p / 2);\n  }\n  if (S.mode === \"relax\") {\n    S.lam = smooth(S.tm / RELAX);\n    if (S.tm >= RELAX) {\n      S.q += S.dir * S.p;\n      S.c2 = S.c2a = fr(S.c2n);\n      // The held line then slides round the tube back to its home offset,\n      // 0.5 / p up to a multiple of 1 / p, which leaves the curve's set of\n      // strands the same: a pure translation, so the class does not move.\n      let e = (0.5 - S.c2a * S.p) % 1;\n      if (e > 0.5) e -= 1;\n      if (e \u003c -0.5) e += 1;\n      S.c2b = S.c2a + e / S.p;\n      S.m += S.dir;\n      S.mode = \"post\";\n      S.tm -= RELAX;\n      S.s = 0;\n      S.lam = 0;\n    }\n  }\n  if (S.mode === \"post\") {\n    S.hl = 1 - smooth(S.tm / POST);\n    S.c2 = S.c2a + (S.c2b - S.c2a) * smooth(S.tm / POST);\n    if (S.tm >= POST) {\n      S.hl = 0;\n      plan(S);\n    }\n  }\n  if (S.mode === \"out\") {\n    S.fade = 1 - smooth(S.tm / FADE);\n    if (S.tm >= FADE) {\n      begin(S, S.ci + 1);\n      S.mode = \"in\";\n      S.tm = 0;\n    }\n  }\n  if (S.mode === \"in\") {\n    S.fade = smooth(S.tm / FADE);\n    if (S.tm >= FADE) {\n      S.fade = 1;\n      plan(S);\n    }\n  }\n}\n\n// The curve as NS points (U, V), U unwrapped.\nfunction trace(S) {\n  const { p, q, c1, c2, a, dir } = S, cu = S.cu, cv = S.cv;\n  const drag = S.mode === \"drag\" || S.mode === \"glue\", relax = S.mode === \"relax\";\n  for (let i = 0; i \u003c NS; i++) {\n    const tau = i / NS, U = p * tau + c1;\n    let V = q * tau + c2;\n    const x = U - a, kk = floor(x), f = x - kk, g = f \u003c AW ? smooth(f / AW) : 1;\n    if (drag) V += dir * S.s * (f \u003c AW ? g : 0);\n    else if (relax) {\n      const vt = V + dir * (kk + g), vn = (q + dir * p) * tau + S.c2n;\n      V = vt + (vn - vt) * S.lam;\n    }\n    cu[i] = U;\n    cv[i] = V;\n  }\n}\n\nfunction label(buf, text, cy, c) {\n  let w = 0;\n  for (const ch of text) w += (ch === \"(\" || ch === \")\" || ch === \",\" ? 3 : 4);\n  let x = round(32 - (w - 1) / 2);\n  for (const ch of text) {\n    const g = GLYPH[ch], gw = ch === \"(\" || ch === \")\" || ch === \",\" ? 2 : 3;\n    // Narrow glyphs keep the middle and one side of their three columns.\n    const cols = ch === \"(\" || ch === \",\" ? [0, 1] : ch === \")\" ? [1, 2] : [0, 1, 2];\n    for (let r = 0; r \u003c 5; r++)\n      for (let j = 0; j \u003c gw; j++)\n        if (g[r * 3 + cols[j]] === \"1\") {\n          const p = ((cy + r) * W + x + j) * 3;\n          buf[p] = c[0];\n          buf[p + 1] = c[1];\n          buf[p + 2] = c[2];\n        }\n    x += gw + 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, A = S.A, B = S.B, P = S.P, h = S.hue;\n  buf.fill(0);\n  A.fill(0);\n  B.fill(0);\n  trace(S);\n  const torus = hsv(h + 0.6, 0.6, 0.78), curve = hsv(h + 0.13, 0.55, 1), ann = hsv(h + 0.36, 0.7, 1);\n  const lng = hsv(h + 0.83, 0.35, 0.62), mer = hsv(h + 0.36, 0.55, 0.62);\n  const spin = S.spin;\n\n  // The curve on the torus, front and back, and on the square. A dot\n  // within 0.4 LED of the last one drawn adds nothing and is skipped.\n  let lx = -9, ly = -9, lf = -1, mx0 = -9, my0 = -9;\n  for (let i = 0; i \u003c NS; i++) {\n    const U = S.cu[i], V = S.cv[i];\n    const t = TAU * (U + spin), ph = TAU * V - PI / 2, rr = RB + RS * cos(ph);\n    const x = rr * cos(t), y = rr * sin(t), z = RS * sin(ph);\n    P[0] = CX + x;\n    P[1] = CY - (y * EY[1] + z * EY[2]);\n    P[2] = y * EZ[1] + z * EZ[2];\n    const facing = cos(ph) * sin(t) * EZ[1] + sin(ph) * EZ[2];\n    const ix = floor(P[0]), iy = floor(P[1]), j = iy * W + ix;\n    const front = ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c TOP && TH[j] ? P[2] >= TZ[j] - 1.6 : facing > 0;\n    const fb = front ? 1 : 0;\n    if (fb !== lf || (P[0] - lx) ** 2 + (P[1] - ly) ** 2 > 0.16) {\n      dot(front ? A : B, P[0], P[1], front ? 1.25 : 0.9, 1, 0, W - 1, 0, TOP - 1);\n      lx = P[0];\n      ly = P[1];\n      lf = fb;\n    }\n    const qx = SX + fr(U) * SQ, qy = SY + SQ - fr(V) * SQ;\n    if ((qx - mx0) ** 2 + (qy - my0) ** 2 > 0.16) {\n      dot(A, qx, qy, 1.15, 1, SX, SX + SQ - 1, SY, SY + SQ - 1);\n      mx0 = qx;\n      my0 = qy;\n    }\n  }\n\n  // The torus.\n  const drag = S.mode === \"drag\" || S.mode === \"glue\" ? S.s : S.mode === \"relax\" || S.mode === \"post\" ? 1 : 0;\n  for (let i = 0; i \u003c W * TOP; i++) {\n    if (!TH[i]) continue;\n    const l = TL[i], o = i * 3;\n    let r = torus[0] * l, g = torus[1] * l, b = torus[2] * l;\n    if (S.hl > 0) {\n      const f = fr(TU[i] - spin - S.a);\n      if (f \u003c AW) {\n        const vm = TV[i] - S.dir * drag * smooth(f / AW), e = fr(vm * 6), st = cl(1.3 - min(e, 1 - e) * 9.4, 0, 1);\n        const edge = cl(1.4 - min(f, AW - f) * 2 * PI * RB * 1.2, 0, 1);\n        const m = S.hl * (0.3 + 0.7 * max(st, edge)), lv = 0.35 + 0.65 * l;\n        r += (ann[0] * lv - r) * m;\n        g += (ann[1] * lv - g) * m;\n        b += (ann[2] * lv - b) * m;\n      }\n    }\n    const back = B[i] * (1 - A[i]) * 0.3 * S.fade, a = A[i] * S.fade, lc = 0.55 + 0.45 * min(1, l);\n    r += (curve[0] - r) * back;\n    g += (curve[1] - g) * back;\n    b += (curve[2] - b) * back;\n    r += (curve[0] * lc - r) * a;\n    g += (curve[1] * lc - g) * a;\n    b += (curve[2] * lc - b) * a;\n    buf[o] = r;\n    buf[o + 1] = g;\n    buf[o + 2] = b;\n  }\n\n  // The square: its ground, the annulus as a strip, the curve, and the\n  // glued edges, side edges in the meridian's colour with one arrow each,\n  // top and bottom in the longitude's colour with two.\n  for (let y = SY; y \u003c SY + SQ; y++)\n    for (let x = SX; x \u003c SX + SQ; x++) {\n      const i = y * W + x, o = i * 3, U = (x + 0.5 - SX) / SQ, V = (SY + SQ - y - 0.5) / SQ;\n      let r = torus[0] * 0.2, g = torus[1] * 0.2, b = torus[2] * 0.2;\n      if (S.hl > 0) {\n        const f = fr(U - S.a);\n        if (f \u003c AW) {\n          const vm = V - S.dir * drag * smooth(f / AW), e = fr(vm * 6), st = cl(1.2 - min(e, 1 - e) * 9.3, 0, 1);\n          const edge = cl(1.3 - min(f, AW - f) * SQ, 0, 1);\n          const m = S.hl * (0.3 + 0.7 * max(st, edge));\n          r += (ann[0] * 0.55 - r) * m;\n          g += (ann[1] * 0.55 - g) * m;\n          b += (ann[2] * 0.55 - b) * m;\n        }\n      }\n      const a = A[i] * S.fade;\n      r += (curve[0] - r) * a;\n      g += (curve[1] - g) * a;\n      b += (curve[2] - b) * a;\n      buf[o] = r;\n      buf[o + 1] = g;\n      buf[o + 2] = b;\n    }\n  const put = (x, y, c) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    buf[o] = c[0];\n    buf[o + 1] = c[1];\n    buf[o + 2] = c[2];\n  };\n  for (let y = SY - 1; y \u003c= SY + SQ; y++) put(SX - 1, y, mer), put(SX + SQ, y, mer);\n  for (let x = SX; x \u003c SX + SQ; x++) put(x, SY - 1, lng), put(x, SY + SQ, lng);\n  const my = SY + SQ / 2 - 2, mx = SX + SQ / 2 - 2;\n  for (const ex of [SX - 1, SX + SQ])\n    for (let k = 1; k \u003c= 2; k++) put(ex - k, my + k, mer), put(ex + k, my + k, mer);\n  for (const ey of [SY - 1, SY + SQ])\n    for (const dx of [0, 3])\n      for (let k = 1; k \u003c= 2; k++) put(mx + dx - k, ey - k, lng), put(mx + dx - k, ey + k, lng);\n\n  // Where the cut closes, a flash on each meeting point.\n  if (S.glow > 0 && S.mode !== \"out\") {\n    for (let k = 0; k \u003c S.p; k++) {\n      const U = S.a + AW + k, tau = (U - S.c1 - floor((U - S.c1) / S.p) * S.p) / S.p, ii = floor(tau * NS) % NS;\n      const V = S.cv[ii];\n      const t = TAU * (U + spin), ph = TAU * V - PI / 2, rr = RB + RS * cos(ph);\n      const x = rr * cos(t), y = rr * sin(t), z = RS * sin(ph);\n      const facing = cos(ph) * sin(t) * EZ[1] + sin(ph) * EZ[2];\n      const pts = [[SX + fr(U) * SQ, SY + SQ - fr(V) * SQ]];\n      if (facing > 0) pts.push([CX + x, CY - (y * EY[1] + z * EY[2])]);\n      for (const [px, py] of pts)\n        for (let dy = -2; dy \u003c= 2; dy++)\n          for (let dx = -2; dx \u003c= 2; dx++) {\n            const X = floor(px) + dx, Y = floor(py) + dy;\n            if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n            const o = (Y * W + X) * 3, m = S.glow * cl(2.4 - sqrt(dx * dx + dy * dy), 0, 1);\n            buf[o] += (1 - buf[o]) * m;\n            buf[o + 1] += (1 - buf[o + 1]) * m;\n            buf[o + 2] += (1 - buf[o + 2]) * m;\n          }\n    }\n  }\n\n  // The class: the new one from the moment the ends meet.\n  const shown = S.mode === \"glue\" || S.mode === \"relax\" ? S.q + S.dir * S.p : S.q;\n  const lc = hsv(h + 0.13, 0.25, 0.75 + 0.25 * S.glow);\n  label(buf, \"(\" + S.p + \",\" + shown + \")\", 58, [lc[0] * S.fade, lc[1] * S.fade, lc[2] * S.fade]);\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","head-wave":"// ===== Patternflow pattern =====\n// Title:   Head Wave\n// Family:  physics\n// Idea:    A cross-section of two-layer ground stands the height of the panel, a slow crust over a mantle 1.35 times faster with a flat boundary across row 64, and a source just above the boundary at the left edge sends out pulses whose first arrivals, worked out exactly by Fermat's principle, run as banded fronts: circles in the crust, wider circles bent through the boundary in the mantle, and beside them a straight conical front in the mantle's colour that the boundary leaks back up into the crust at the critical angle of 47.8 degrees, arriving first over a wedge that reaches 33 rows up at the right edge.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: head waves and the crust-mantle boundary found from them (Andrija Mohorovicic, 1909); first arrivals by Fermat's principle (Pierre de Fermat, 1662), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=1.35..2.5, Height=2..50\n//\n// Knob 1: Hue. Turns both layers round the wheel together. At 0 the crust and every front that stayed in it are sea green and the mantle with the head wave it sends up is rose; at 0.5 the crust is red and the mantle green.\n// Knob 2: Speed. How many bands leave the source a second: half the knob, so one a second at the opening 2, a front crossing the crust at 4.4 LEDs a second and the mantle at 1.35 times that; 0.1 a second at 0.2 and 1.5 at 3.\n// Knob 3: Ratio. The mantle's speed over the crust's, from 1.35, about the ratio between crust and upper mantle, to 2.5. The critical angle asin(1/ratio) falls from 47.8 to 23.6 degrees, so the conical front tips from a diagonal towards flat, the wedge where it leads grows from 11% of the panel to 25% and reaches the top row at the right edge, and the mantle's bands widen from 5.9 to 11 LEDs.\n// Knob 4: Height. How far above the boundary the source sits, 2 to 50 LEDs. At the opening 2 the head wave leads from 2.2 LEDs out along the boundary and its wedge reaches 33 rows up at the right edge; at 20 it leads only from 22 LEDs out and reaches 6 rows up; at 50 it meets the boundary 55 LEDs out and hardly shows.\n// Buttons: Any tap moves the source 16 LEDs to the right, from the left edge through 16, 32 and 48 to the right edge and back.\n\n// Everything is measured in LEDs, and time in LEDs of travel through the\n// slow layer, so the crust's speed is 1 and the mantle's is r. A pulse\n// reaches each point first along the path of least time (Fermat), and there\n// are three candidates.\n//\n// Direct: the straight line from the source, T = distance. Its fronts are\n// circles.\n//\n// Refracted, for points below the boundary: down to some point m on the\n// boundary, then on to the point at speed r. T(m) = |s - m| + |m - p| / r is\n// convex in m, so a few Newton steps find the minimum, and setting its\n// derivative to zero is Snell's law, sin(i) = sin(t) / r.\n//\n// Head wave, for points above the boundary: down to the boundary at the\n// critical angle ic = asin(1/r), along the boundary at speed r, and back up\n// at ic. With hs the source's height and hr the point's height above the\n// boundary and dx the distance across,\n//\n//   T = dx / r + (hs + hr) cos(ic),\n//\n// which is a plane: the conical front. It exists once dx is at least\n// (hs + hr) tan(ic), and it arrives first wherever it beats the circle.\n// Mohorovicic read exactly this from the Kupa valley earthquake of\n// 8 October 1909: beyond some distance a faster phase overtook the direct\n// one, and the distance gave him the depth of a faster layer underneath.\n//\n// The travel time is worked out once whenever the source, the ratio or the\n// height change. Each frame only reads it: an LED's light is a sawtooth of\n// (t - T) over one period, bright as a front arrives and fading until the\n// next, and the source never stops, so every LED is always somewhere in a\n// band.\n//\n// A band climbs to its crest over its width. When its front runs along a\n// row or a column the whole climb falls between neighbours in one\n// direction; when it runs diagonally the climb splits between the row and\n// the column. So each LED's band is drawn as tall as it can be with no step\n// between neighbours above 39.5 levels: diagonal fronts, the head wave among\n// them, stand at full height and fronts square to the panel at about two\n// thirds of it. The drop at the back of each band is the only hard step.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The boundary's row, the band width in the crust (LEDs), the largest step\n// between two neighbouring LEDs a band may climb, and its full height.\nconst YB = 64, P = 4.4, CAP = 39.5, TOP = 255;\nconst SRC_X = [0.5, 16, 32, 48, 63.5];\n// Crust, then mantle (and the head wave, which spent its fast stretch there).\nconst HUES = [0.47, 0.91];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, ratio: 1.35, height: 2, src: 0, tau: 0, key: \"\",\n    ph: new Float32Array(N), amp: new Float32Array(N), fast: new Uint8Array(N),\n    lut: new Uint8Array(2 * 256 * 3), lh: -1, c: [0, 0, 0],\n  };\n}\n\n// First arrivals (in band periods) and each LED's band height.\nfunction solve(S) {\n  const r = S.ratio, xs = SRC_X[S.src], hs = S.height, ys = YB - hs;\n  const ci = sqrt(1 - 1 / (r * r)), ti = 1 / sqrt(r * r - 1);\n  const PH = S.ph, A = S.amp, F = S.fast;\n  for (let y = 0; y \u003c H; y++) {\n    const py = y + 0.5;\n    let m = xs;\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5, i = y * W + x, dx = abs(px - xs);\n      // t is the travel time, (gx, gy) the size of its slope along the row\n      // and down the column.\n      let t, gx, gy;\n      if (py \u003c YB) {\n        const dy = py - ys, rr = sqrt(dx * dx + dy * dy) + 1e-6, hr = YB - py;\n        t = rr;\n        gx = dx / rr;\n        gy = abs(dy) / rr;\n        F[i] = 0;\n        if (dx >= (hs + hr) * ti) {\n          const th = dx / r + (hs + hr) * ci;\n          if (th \u003c t) {\n            t = th;\n            gx = 1 / r;\n            gy = ci;\n            F[i] = 1;\n          }\n        }\n      } else {\n        // Newton on the crossing point, started from the last LED's.\n        const dz = py - YB, a = min(xs, px), b = max(xs, px);\n        m = cl(m, a, b);\n        for (let k = 0; k \u003c 6; k++) {\n          const d1 = sqrt((m - xs) * (m - xs) + hs * hs), d2 = sqrt((px - m) * (px - m) + dz * dz);\n          const g = (m - xs) / d1 - (px - m) / (r * d2);\n          const gp = (hs * hs) / (d1 * d1 * d1) + (dz * dz) / (r * d2 * d2 * d2);\n          m = cl(m - g / gp, a, b);\n        }\n        const d1 = sqrt((m - xs) * (m - xs) + hs * hs), d2 = sqrt((px - m) * (px - m) + dz * dz) + 1e-6;\n        t = d1 + d2 / r;\n        gx = abs(px - m) / (r * d2);\n        gy = dz / (r * d2);\n        F[i] = 1;\n      }\n      PH[i] = t / P;\n      A[i] = min(TOP, (CAP * P) / max(gx, gy, 1e-6));\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1.35, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.ratio = cl(k[2] == null ? 1.35 : k[2], 1.35, 2.5);\n  S.height = cl(k[3] == null ? 2 : k[3], 2, 50);\n  const b = input.btnPressed;\n  if (b && (b[0] || b[1] || b[2] || b[3])) S.src = (S.src + 1) % SRC_X.length;\n  S.tau += d * S.speed * 0.5;\n  if (S.tau > 1000) S.tau -= 1000;\n  const key = S.ratio.toFixed(3) + \"/\" + S.height.toFixed(2) + \"/\" + S.src;\n  if (key !== S.key) {\n    S.key = key;\n    solve(S);\n  }\n}\n\n// One ramp per layer, indexed by the LED's level: saturated in the fading\n// tail of a band, paler at the crest.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let z = 0; z \u003c 2; z++)\n    for (let v = 0; v \u003c 256; v++) {\n      const a = v / 255;\n      hsv(S.hue + HUES[z], 0.9 - 0.5 * a * a * a, a, S.c);\n      const o = (z * 256 + v) * 3;\n      S.lut[o] = round(S.c[0] * 255);\n      S.lut[o + 1] = round(S.c[1] * 255);\n      S.lut[o + 2] = round(S.c[2] * 255);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const PH = S.ph, A = S.amp, F = S.fast, Lut = S.lut, tau = S.tau;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let u = tau - PH[i];\n      u -= floor(u);\n      const o = (F[i] * 256 + round(A[i] * (1 - u))) * 3;\n      display.setPixel(x, y, Lut[o], Lut[o + 1], Lut[o + 2]);\n    }\n}\n","malfatti-circles":"// ===== Patternflow pattern =====\n// Title:   Malfatti Circles\n// Family:  geometry\n// Idea:    One slowly morphing triangle is drawn twice down the tall panel, the upper copy holding Malfatti's three circles, each touching two sides and the other two circles, and the lower copy the greedy three, the incircle and then each time the largest circle that still fits, with two bars and percentages between them for the share of the triangle each three cover, so the greedy bar stays ahead, by 14 points of the triangle when it is a 23 degree wedge and by a single point when it passes through equilateral.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Malfatti's problem (Gian Francesco Malfatti, 1803); the greedy arrangement beating his circles (H. Lob and H. W. Richmond, 1930) and proved best in every triangle (V. A. Zalgaller and G. A. Los', 1994), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Thin=0..1, More=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together. At 0 Malfatti's circles and their bar are azure and the greedy ones rose pink; at 0.25 violet and yellow; at 0.5 red orange and green.\n// Knob 2: Speed. At 2 the triangle goes from its thinnest to equilateral in 6 s and back in 6 more, and its thin end comes in turn as a wedge leaning over the right end of the base, a flat isosceles triangle, a wedge leaning left and the flat one again, 48 s for the round. Every time goes as 2 / Speed, so 60 s from thin to equilateral at 0.2 and 4 s at 3.\n// Knob 3: Thin. How low the apex comes at the thin end of the morph: 26 rows above the 61 LED base at 0, a wedge whose sharpest corner is 23 degrees, where the greedy three cover 69.8% against Malfatti's 55.9%, or a flat triangle of 99 degrees at the top, 73.7% against 64.7%; at 1 it comes to 7 rows, a 6.6 degree wedge with 39.1% against 23.1%, or 154 degrees at the top with 39.9% against 30.0%.\n// Knob 4: More. Goes on placing circles greedily after the first three, in both copies and in a paler shade: none up to 0.1 (the opening is 0.06), 3 at 0.25, 16 at 0.5, 36 at 0.75 and 60 at 1, so the gaps each first three leave fill with ever smaller circles. The bars and numbers keep counting the first three only.\n\n// In 1803 Malfatti asked how to cut three cylindrical columns out of a\n// triangular prism of marble with the least waste, and took for granted that\n// the answer was three circles in the triangle, each tangent to the other two\n// and to two of the sides. Those circles have a closed form. With a, b, c the\n// sides opposite A, B, C, s the semiperimeter, r the inradius and d, e, f the\n// distances from the incentre to A, B and C, the circle in the corner at A\n// has radius\n//\n//   r_A = r / (2 (s - a)) * (s - r - (e + f - d))\n//\n// and the others go round the same way. Its centre is the vertex pulled\n// towards the incentre by r_A / r, which makes it tangent to both sides at A.\n// Checked numerically on the triangles this pattern passes through and on\n// ten random ones, with corners from 3.6 to 154 degrees: the distances\n// between centres equal the sums of the radii, and each circle stands its\n// own radius off both sides at its corner, to within 1e-13 LEDs.\n//\n// Lob and Richmond showed in 1930 that the circles were not the answer: in\n// an equilateral triangle the incircle with two small circles in two corners\n// covers 73.9% against Malfatti's 72.9%, and in a thin triangle the gap is\n// wide. Zalgaller and Los' proved in 1994 that the greedy choice is the best\n// one in every triangle: the incircle, then the largest circle left, then the\n// largest left again.\n//\n// After the incircle the free space is three corners, each bounded by two\n// sides and the incircle. The largest circle in the corner at A is the image\n// of the incircle under the homothety at A with ratio\n//\n//   q_A = (1 - sin(A/2)) / (1 + sin(A/2)),\n//\n// and placing it leaves a smaller corner (the next circle shrinks by q_A\n// again) and two cusps, each between two tangent circles and a side. A cusp,\n// like every gap after that, is bounded by three mutually tangent things, and\n// its largest circle touches all three, with Descartes' curvature\n//\n//   k = k1 + k2 + k3 + 2 sqrt(k1 k2 + k2 k3 + k3 k1),   a side counting 0.\n//\n// So the greedy keeps a list of gaps, each with the radius of its best\n// circle, and takes the largest each time; the circle placed splits its gap\n// into three. The same list, started from Malfatti's circles (their middle\n// gap, three corners and three cusps), continues the upper copy when K4 asks\n// for more.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Each copy's base runs from x = 1.5 to 62.5 on its bottom row.\nconst BX0 = 1.5, BX1 = 62.5, BASE = BX1 - BX0, HEQ = (BASE * sqrt(3)) / 2;\nconst TOPS = [{ base: 56, bar: 60, num: 58 }, { base: 126, bar: 67, num: 65 }];\nconst BAR0 = 1, BARLEN = 42;\n// The two colours' places on the wheel, before the hue knob.\nconst HUES = [0.56, 0.9];\n\n// 3 by 5 digits, rows top to bottom, bit 2 the left column.\nconst DIG = [\n  [7, 5, 5, 5, 7], [2, 6, 2, 2, 7], [7, 1, 7, 4, 7], [7, 1, 7, 1, 7], [5, 5, 7, 1, 1],\n  [7, 4, 7, 1, 7], [7, 4, 7, 5, 7], [7, 1, 1, 2, 2], [7, 5, 7, 5, 7], [7, 5, 7, 1, 7],\n];\nconst PCT = [5, 1, 2, 4, 5];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, thin: 0, more: 0,\n    buf: new Float32Array(W * H * 3),\n    col: [[0, 0, 0], [0, 0, 0]], pale: [[0, 0, 0], [0, 0, 0]],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.thin = cl(k[2] || 0, 0, 1);\n  const m = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.more = m \u003c 0.1 ? 0 : round(60 * ((m - 0.1) / 0.9) ** 1.6);\n  S.t += (d * speed) / 2;\n}\n\n// The triangle at model time t: base fixed, the apex walking. m is 1 at the\n// thin end and 0 at equilateral; the apex's side goes round once in 48 s.\nfunction triangle(t, thin) {\n  const m = 0.5 + 0.5 * cos((TAU * t) / 12);\n  const side = cos((TAU * t) / 48);\n  const hmin = 26 - 19 * thin;\n  const h = HEQ - m * (HEQ - hmin);\n  const ax = (BX0 + BX1) / 2 + m * 30 * side;\n  return [[ax, -h], [BX0, 0], [BX1, 0]];\n}\n\n// A side as a line with its inward unit normal: inside is n . p - c >= 0.\nfunction sideLine(P, Q, R) {\n  let nx = -(Q[1] - P[1]), ny = Q[0] - P[0];\n  const l = hypot(nx, ny);\n  nx /= l;\n  ny /= l;\n  let c = nx * P[0] + ny * P[1];\n  if (nx * R[0] + ny * R[1] - c \u003c 0) {\n    nx = -nx;\n    ny = -ny;\n    c = -c;\n  }\n  return { line: true, nx, ny, c };\n}\n\n// Everything about one triangle: sides, inradius, Malfatti's three, and the\n// corner ratios the greedy uses.\nfunction solve(V) {\n  const [A, B, C] = V;\n  const a = hypot(B[0] - C[0], B[1] - C[1]), b = hypot(C[0] - A[0], C[1] - A[1]), c = hypot(A[0] - B[0], A[1] - B[1]);\n  const s = (a + b + c) / 2, area = sqrt(max(1e-9, s * (s - a) * (s - b) * (s - c))), r = area / s;\n  const I = [(a * A[0] + b * B[0] + c * C[0]) / (2 * s), (a * A[1] + b * B[1] + c * C[1]) / (2 * s)];\n  const dist = (P) => hypot(P[0] - I[0], P[1] - I[1]);\n  const d = dist(A), e = dist(B), f = dist(C);\n  const rad = [\n    (r / (2 * (s - a))) * (s - r - (e + f - d)),\n    (r / (2 * (s - b))) * (s - r - (f + d - e)),\n    (r / (2 * (s - c))) * (s - r - (d + e - f)),\n  ];\n  const mal = rad.map((rr, i) => ({ x: V[i][0] + (I[0] - V[i][0]) * (rr / r), y: V[i][1] + (I[1] - V[i][1]) * (rr / r), r: rr }));\n  // Each side by the vertex it faces: lines[0] is BC.\n  const lines = [sideLine(B, C, A), sideLine(C, A, B), sideLine(A, B, C)];\n  const q = V.map((P) => {\n    const sh = r / dist(P);\n    return (1 - sh) / (1 + sh);\n  });\n  return { V, area, r, I, mal, lines, q };\n}\n\n// The largest circle tangent to three mutually tangent things (at most one\n// of them a side): its radius from Descartes, its centre from two of the\n// three, choosing of the two crossings the one that also touches the third.\nfunction soddy(o) {\n  const k = o.map((x) => (x.line ? 0 : 1 / x.r));\n  const kk = k[0] + k[1] + k[2] + 2 * sqrt(max(0, k[0] * k[1] + k[1] * k[2] + k[2] * k[0]));\n  const rho = 1 / kk;\n  const circ = o.filter((x) => !x.line), ln = o.find((x) => x.line);\n  const third = ln || o[2];\n  let pts;\n  if (ln) {\n    // Points rho inside the side, at r1 + rho from the circle.\n    const C1 = circ[0], R = C1.r + rho, off = ln.nx * C1.x + ln.ny * C1.y - (ln.c + rho);\n    const h2 = R * R - off * off;\n    if (h2 \u003c 0) return null;\n    const fx = C1.x - ln.nx * off, fy = C1.y - ln.ny * off, hh = sqrt(h2);\n    pts = [[fx - ln.ny * hh, fy + ln.nx * hh], [fx + ln.ny * hh, fy - ln.nx * hh]];\n    // Of the two, the one that touches the other circle.\n    const C2 = circ[1], want = C2.r + rho;\n    const e0 = abs(hypot(pts[0][0] - C2.x, pts[0][1] - C2.y) - want), e1 = abs(hypot(pts[1][0] - C2.x, pts[1][1] - C2.y) - want);\n    const p = e0 \u003c e1 ? pts[0] : pts[1];\n    return { x: p[0], y: p[1], r: rho };\n  }\n  const C1 = o[0], C2 = o[1], R1 = C1.r + rho, R2 = C2.r + rho;\n  const dx = C2.x - C1.x, dy = C2.y - C1.y, D = hypot(dx, dy);\n  const ax = (D * D + R1 * R1 - R2 * R2) / (2 * D), h2 = R1 * R1 - ax * ax;\n  if (h2 \u003c 0 || D \u003c= 0) return null;\n  const ux = dx / D, uy = dy / D, hh = sqrt(h2), mx = C1.x + ux * ax, my = C1.y + uy * ax;\n  pts = [[mx - uy * hh, my + ux * hh], [mx + uy * hh, my - ux * hh]];\n  const want = third.r + rho;\n  const e0 = abs(hypot(pts[0][0] - third.x, pts[0][1] - third.y) - want), e1 = abs(hypot(pts[1][0] - third.x, pts[1][1] - third.y) - want);\n  const p = e0 \u003c e1 ? pts[0] : pts[1];\n  return { x: p[0], y: p[1], r: rho };\n}\n\n// A gap's best circle: in a corner the next image of its circle under the\n// homothety at the vertex, otherwise the Soddy circle.\nfunction best(T, g) {\n  if (g.corner >= 0) {\n    const P = T.V[g.corner], q = T.q[g.corner], c = g.o[0];\n    return { x: P[0] + (c.x - P[0]) * q, y: P[1] + (c.y - P[1]) * q, r: c.r * q };\n  }\n  return soddy(g.o);\n}\n\nfunction addGap(list, T, corner, o) {\n  const g = { corner, o, c: null };\n  g.c = best(T, g);\n  if (g.c && g.c.r > 0.05) list.push(g);\n}\n\n// Takes the largest gap n times, splitting it each time. Returns the circles.\nfunction grow(T, gaps, n) {\n  const out = [];\n  for (let k = 0; k \u003c n && gaps.length; k++) {\n    let bi = 0;\n    for (let i = 1; i \u003c gaps.length; i++) if (gaps[i].c.r > gaps[bi].c.r) bi = i;\n    const g = gaps[bi], c = g.c;\n    gaps[bi] = gaps[gaps.length - 1];\n    gaps.pop();\n    out.push(c);\n    if (g.corner >= 0) {\n      // A corner leaves a smaller corner and the two cusps on its sides.\n      const v = g.corner, old = g.o[0];\n      addGap(gaps, T, v, [c]);\n      addGap(gaps, T, -1, [old, c, T.lines[(v + 1) % 3]]);\n      addGap(gaps, T, -1, [old, c, T.lines[(v + 2) % 3]]);\n    } else {\n      const [p, q, r] = g.o;\n      addGap(gaps, T, -1, [p, q, c]);\n      addGap(gaps, T, -1, [q, r, c]);\n      addGap(gaps, T, -1, [p, r, c]);\n    }\n  }\n  return out;\n}\n\n// The greedy from an empty triangle: the incircle and then grow().\nfunction greedy(T, n) {\n  const inc = { x: T.I[0], y: T.I[1], r: T.r }, gaps = [];\n  for (let v = 0; v \u003c 3; v++) addGap(gaps, T, v, [inc]);\n  return [inc].concat(grow(T, gaps, n - 1));\n}\n\n// After Malfatti's three: the middle, three corners and three cusps.\nfunction afterMalfatti(T, n) {\n  const [mA, mB, mC] = T.mal, gaps = [];\n  addGap(gaps, T, -1, [mA, mB, mC]);\n  for (let v = 0; v \u003c 3; v++) addGap(gaps, T, v, [T.mal[v]]);\n  addGap(gaps, T, -1, [mA, mB, T.lines[2]]);\n  addGap(gaps, T, -1, [mB, mC, T.lines[0]]);\n  addGap(gaps, T, -1, [mC, mA, T.lines[1]]);\n  return grow(T, gaps, n);\n}\n\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\n// A disc lit at `fill` inside, rising towards a rim line at `rim`.\nfunction disc(buf, oy, c, col, fill, rim) {\n  const cx = c.x, cy = c.y + oy, r = c.r;\n  if (r \u003c 0.7) {\n    add(buf, round(cx), round(cy), col, (fill + rim) * r * 0.9);\n    return;\n  }\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const e = hypot(x - cx, y - cy), u = e / r;\n      const inside = cl(r + 0.5 - e, 0, 1);\n      if (inside \u003c= 0) continue;\n      const ring = cl(1.2 - abs(e - r + 0.7), 0, 1);\n      add(buf, x, y, col, inside * (fill * (0.7 + 0.3 * u * u) * (1 - ring) + rim * ring));\n    }\n}\n\n// The triangle: its inside a faint grey, its sides a pale line.\nfunction shape(buf, T, oy, ink) {\n  const V = T.V.map((P) => [P[0], P[1] + oy]);\n  const y0 = max(0, floor(min(V[0][1], V[1][1], V[2][1])) - 1), y1 = min(H - 1, Math.ceil(max(V[0][1], V[1][1], V[2][1])) + 1);\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let dmin = 1e9, dseg = 1e9;\n      for (let i = 0; i \u003c 3; i++) {\n        const L = T.lines[i];\n        dmin = min(dmin, L.nx * x + L.ny * (y - oy) - L.c);\n        const P = V[(i + 1) % 3], Q = V[(i + 2) % 3], dx = Q[0] - P[0], dy = Q[1] - P[1];\n        const tt = cl(((x - P[0]) * dx + (y - P[1]) * dy) / (dx * dx + dy * dy), 0, 1);\n        dseg = min(dseg, hypot(P[0] + tt * dx - x, P[1] + tt * dy - y));\n      }\n      const inside = cl(dmin + 0.5, 0, 1), edge = cl(1.1 - dseg, 0, 1);\n      add(buf, x, y, ink, 0.13 * inside * (1 - edge) + 0.62 * edge);\n    }\n}\n\nfunction digit(buf, ch, x0, y0, col) {\n  const g = ch === \"%\" ? PCT : DIG[ch];\n  for (let j = 0; j \u003c 5; j++) for (let i = 0; i \u003c 3; i++) if (g[j] & (4 >> i)) add(buf, x0 + i, y0 + j, col, 1);\n}\n\n// A bar of the covered share, over a faint track for the whole triangle,\n// and the share in tenths of a percent at the right.\nfunction bar(buf, row, numRow, share, col, pale) {\n  const len = share * BARLEN;\n  for (let x = BAR0; x \u003c BAR0 + BARLEN; x++) {\n    const f = cl(BAR0 + len - x, 0, 1);\n    for (let y = row - 1; y \u003c= row + 1; y++) add(buf, x, y, col, 0.12 + 0.83 * f);\n  }\n  const tenths = round(share * 1000), s = String(floor(tenths / 10)).padStart(2, \" \");\n  let x = 46;\n  for (const ch of s) {\n    if (ch !== \" \") digit(buf, +ch, x, numRow, pale);\n    x += 4;\n  }\n  add(buf, x, numRow + 4, pale, 1);\n  digit(buf, tenths % 10, x + 2, numRow, pale);\n  digit(buf, \"%\", x + 6, numRow, pale);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, col = S.col, pale = S.pale;\n  buf.fill(0);\n  for (let i = 0; i \u003c 2; i++) {\n    hsv(S.hue + HUES[i], 0.85, 1, col[i]);\n    hsv(S.hue + HUES[i], 0.35, 1, pale[i]);\n  }\n  const T = solve(triangle(S.t, S.thin));\n  const ink = [0.85, 0.85, 0.9];\n  const greedyAll = greedy(T, 3 + S.more), malMore = afterMalfatti(T, S.more);\n  const sets = [T.mal, greedyAll.slice(0, 3)];\n  const extra = [malMore, greedyAll.slice(3)];\n  for (let i = 0; i \u003c 2; i++) {\n    const L = TOPS[i], oy = L.base;\n    shape(buf, T, oy, ink);\n    for (const c of sets[i]) disc(buf, oy, c, col[i], 0.42, 1);\n    for (const c of extra[i]) disc(buf, oy, c, pale[i], 0.45, 0.85);\n    let a = 0;\n    for (const c of sets[i]) a += PI * c.r * c.r;\n    bar(buf, L.bar, L.num, a / T.area, col[i], pale[i]);\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n}\n","modular-hyperbola":"// ===== Patternflow pattern =====\n// Title:   Modular Hyperbola\n// Family:  number\n// Idea:    The multiplication table of the integers mod a prime p fills the panel, column x + 1 times row y, and every LED stands on one sawtooth of the residues, white where the product is a running residue c and falling through a cubehelix ramp to black just before it comes round to c again, so the hard white edges trace the modular hyperbola xy = c (mod p): at p = 127, 32 true hyperbolas nested round the top left corner and their mirror round the bottom left, with checks along the middle row and the last column where x and y are near p/2, and, with the tooth narrowed to two residues, a scatter of points that lands a fair share in every patch of the table.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the modular hyperbola xy = c (mod p), whose points in a box are counted with Kloosterman sums (Hendrik Kloosterman, 1926) and Weil's bound on them (Andre Weil, 1948); cubehelix colour ramp (Dave Green, 2011), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Prime=-3..4, Band=0..1\n//\n// Knob 1: Hue. Where the cubehelix ramp starts its turn round the colour wheel. At 0 a tooth climbs from black through violet, blue, teal and green to pale pink and white; at 0.25 through brown, mauve and sky blue; at 0.5 through moss, rose and lilac; at 0.75 through navy, green and salmon. The top of every tooth is white whatever the hue.\n// Knob 2: Speed. c climbs through all p residues in 12 / Speed seconds whatever the prime: 6 s at the opening 2, 60 s at 0.2 and 4 s at 3. At p = 127 and Speed 2 that is 21 residues a second.\n// Knob 3: Prime. -3 is 13, -2 is 31, -1 is 61, the opening 0 is 127, 1 is 251, 2 is 509, 3 is 1021 and 4 is 2039, each the largest prime under a power of two. At 127 the 128 rows hold every residue once with the zero row at the top and again at the bottom, and the lower half is the upper half upside down. At 13 the table repeats as a 13 by 13 tile, and at 2039 the product stays under p over 59% of the panel, so the top left is plain hyperbolas.\n// Knob 4: Band. How much of each tooth is lit: p - Band^2 (p - 2) residues of the p. The whole tooth at 0 and at the opening 0.06, three quarters at 0.5, and at 1 only the residues c and c + 1, so what is left is the hyperbola itself; at p = 127 that is one LED in every column for each of the two.\n\n// The integers mod a prime p, multiplied. LED (x, y) holds the residue\n// (x + 1) y mod p: columns count 1 to 64 and rows 0 to 127, so the top row\n// is the row of zeros. A running residue c, a real number, lights every LED\n// by how far its residue r has to go back to reach c:\n//\n//   t = 1 - ((r - c) mod p) / p\n//\n// t is 1 on the residue just above c and falls to 0 on the one just below,\n// so wherever the residue steps from c - 1 to c the picture steps from black\n// to white. Those steps are the modular hyperbola xy = c (mod p).\n//\n// Each tooth is the band between two hyperbolas xy = c + kp and\n// xy = c + (k + 1)p. Row y is a sawtooth in x of y/p cycles an LED, and\n// column x one of (x + 1)/p cycles down, so at p = 127 the whole upper\n// half stays under half a cycle an LED both ways and its 32 teeth are true\n// hyperbolas, nested round the top left corner. Near y = p/2 a row is\n// almost two LEDs a cycle and reads as a check; near p/3 every third LED\n// lines up; and the rows round each fraction a/b with a small b repeat\n// every b LEDs, the Farey fractions in order down the panel. The table is the same read\n// across, so at p = 127 the last column, x + 1 = 64 = (p + 1) / 2, is a\n// check too: 64 is the inverse of 2 mod 127, and the column holds y/2.\n//\n// Row p - y holds -xy. At p = 127 row 127 - y is row y with the residue\n// negated, so the lower half is the upper half upside down, with the ramp\n// run backwards and c read as -c.\n//\n// c climbs through the residues, a full turn in 12 / Speed seconds. Near\n// the corner the hyperbolas spread out smoothly; elsewhere every whole step\n// of c moves the white set to a new scatter of points. Counting the points\n// of xy = c in a box of X columns and Y rows comes down to Kloosterman sums\n// (Hendrik Kloosterman, 1926), and Weil's bound on them (Andre Weil, 1948),\n// no bigger than 2 sqrt(p), keeps every box within a few sqrt(p) log^2 p of\n// its fair share XY / p. Band narrows the lit part of the tooth until only\n// that scatter is left.\n//\n// The ramp is Dave Green's cubehelix (2011): brightness rises from black to\n// white while the colour turns round a helix about the grey line, so all\n// three channels change along the tooth. A hue wheel scaled by brightness\n// was measured too: every LED then has one channel at 0, deflate packs the\n// frame in 1.91 bytes a pixel instead of 2.39, and the colour runs to 0.56.\n\nconst W = 64, H = 128;\nconst { floor, round, cos, sin, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The largest prime under 2^k, for k = 4 to 11.\nconst PRIMES = [13, 31, 61, 127, 251, 509, 1021, 2039];\n// Cubehelix: turns of the helix over the ramp, its width, and a gamma that\n// keeps the dark third of the tooth short.\nconst ROT = 1.2, AMP = 1.0, GAMMA = 1.25;\n\nfunction helix(l, s, o) {\n  l = pow(l, GAMMA);\n  const phi = 2 * PI * (s / 3 - ROT * l), a = (AMP * l * (1 - l)) / 2, c = cos(phi), sn = sin(phi);\n  o[0] = l + a * (-0.14861 * c + 1.78277 * sn);\n  o[1] = l + a * (-0.29227 * c - 0.90649 * sn);\n  o[2] = l + a * (1.97294 * c);\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    c: 0, p: 127, hue: 0, speed: 2, band: 0.06,\n    lut: new Uint8Array(256 * 3), lh: -1, o: [0, 0, 0],\n    m: new Int32Array(W * H), mp: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.p = PRIMES[cl(round(k[2] || 0), -3, 4) + 3];\n  S.band = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.c += (d * S.speed * S.p) / 12;\n  S.c -= floor(S.c / S.p) * S.p;\n}\n\n// The 256 steps of the tooth's ramp, rebuilt when Hue turns. The 0.37\n// keeps the opening hue off a red start.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let i = 0; i \u003c 256; i++) {\n    helix(i / 255, 3 * (S.hue + 0.37), S.o);\n    for (let j = 0; j \u003c 3; j++) S.lut[i * 3 + j] = round(cl(S.o[j], 0, 1) * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const p = S.p, M = S.m, L = S.lut;\n  // The table itself changes only with the prime.\n  if (S.mp !== p) {\n    S.mp = p;\n    for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) M[y * W + x] = ((x + 1) * y) % p;\n  }\n  // The lit part of the tooth, in residues: p at Band 0, 2 at Band 1.\n  const fp = (1 - S.band * S.band * (1 - 2 / p)) * p, c = S.c;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = M[y * W + x] - c;\n      if (r \u003c 0) r += p;\n      const t = r \u003c fp ? 1 - r / fp : 0;\n      const i = round(t * 255) * 3;\n      display.setPixel(x, y, L[i], L[i + 1], L[i + 2]);\n    }\n}\n","permutation-poem":"// ===== Patternflow pattern =====\n// Title:   Permutation Poem\n// Family:  type\n// Idea:    A short phrase is written out in every order of its words, one line under the next in 3 by 5 capitals with each word in its own colour, so the 21 lines on the panel weave into a block of the same few words; each new line starts as a copy of the one above, the words that move slide into their new places in white, and the page steps up a line, and in the Steinhaus-Johnson-Trotter order that move is always two neighbouring words passing each other, while in I AM THAT I AM a quarter of those passes trade an I for an I or an AM for an AM and leave the line exactly as it was.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Brion Gysin's permutation poems (I AM THAT I AM, 1960); Steinhaus-Johnson-Trotter order (Hale Trotter, 1962; Selmer Johnson, 1963); Heap's algorithm (B. R. Heap, 1963); next permutation in lexicographic order (Narayana Pandita, 14th century); 3 by 5 capitals drawn for this pattern, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..3, Order=0..2\n//\n// Knob 1: Hue. Turns the words' colours round the wheel together. At 0 the opening phrase has I in azure, AM in pink and THAT in yellow green, and a phrase of four different words runs blue violet, rose, yellow and sea green; the words that are moving are always near white.\n// Knob 2: Speed. 0.75 x Speed new lines a second: 1.5 at the opening 2, so a line takes 0.67 s, half of it the words sliding, a fifth held while the white fades, and the last 0.3 the page stepping up 6 rows. One line every 6.7 s at 0.2 and 2.25 a second at 3.\n// Knob 3: Phrase. 0 I AM THAT I AM (5 words, 120 orders, 30 different lines), 1 RUB OUT THE WORD (24 orders, all different), 2 TO BE OR NOT TO BE (720 orders, 180 different lines), 3 VENI VIDI VICI (6 orders, so the page repeats every 6 lines). Turning it rewrites the whole page at once.\n// Knob 4: Order. 0, the opening, is Steinhaus-Johnson-Trotter: every line is the one above with two neighbouring words swapped, and the last word of the phrase zigzags across the page. 1 is Heap's order: one swap a line, but the two words can stand far apart and slide over the ones between. 2 is lexicographic order, the phrase's own word order taken as the alphabet: the tail of the line turns round, so up to all the words move at once.\n\n// Gysin wrote out every arrangement of the words of a phrase, one under the\n// next, so that the page reads as a block of the same words in shifting\n// places. This pattern does the same with the phrase's words as tokens\n// 0..n-1 in the order the phrase gives them, and lists the n! orders of the\n// tokens, not the orders of the words: where a word comes twice, two lines\n// can read the same.\n//\n// Steinhaus-Johnson-Trotter (the plain changes of English bell ringing)\n// lists them so that each order is the one before with two neighbours\n// swapped. Even's way of running it gives every token a direction, left to\n// start with; the largest token that points at a smaller neighbour swaps\n// with it, and every token larger than it turns round. The largest token\n// of all moves on every line but one in n, so it crosses the line from end\n// to end and back: the zigzag thread down the page. After n! - 1 swaps the\n// order is the phrase with its first two words swapped, one swap from the\n// start, so the list closes into a loop.\n//\n// Heap's algorithm also makes each order from the last with one swap, but\n// of any two positions. The next permutation in lexicographic order finds\n// the last place i where token[i] \u003c token[i+1], swaps token[i] with the\n// smallest larger token after it and reverses everything after i.\n//\n// In I AM THAT I AM the tokens are I0 AM1 THAT2 I3 AM4. A swap of I0 with\n// I3 or AM1 with AM4 changes the tokens but not the words, and the new line\n// reads like the one above. Over a full turn that is 30 of the 120 lines in\n// Steinhaus-Johnson-Trotter order, 26 in Heap's and 12 in lexicographic\n// order; in TO BE OR NOT TO BE it is 144, 91 and 48 of the 720.\n//\n// The capitals are drawn on a grid five rows tall: I one column wide, N\n// four, M and W five, the rest three, one column between letters and three\n// between words. Lines stand 6 rows apart, so 21 whole lines and the foot of\n// a 22nd fill the 128 rows. Every order of a phrase is the same width, and\n// the block is centred on the panel.\n//\n// The page dims towards the top. Drawn at one brightness, every line is\n// the same bytes as some line above it, and the frame deflates to 0.055\n// bytes a pixel, a hair above the lowest pattern on the study's map.\n\nconst W = 64, H = 128, PITCH = 6, GH = 5, GAP = 3, LINES = 23;\nconst BOTTOM = H - GH; // top row of the newest line\nconst { floor, round, min } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nconst GLYPHS = {\n  A: \".#./#.#/###/#.#/#.#\", B: \"##./#.#/##./#.#/##.\", C: \".##/#../#../#../.##\",\n  D: \"##./#.#/#.#/#.#/##.\", E: \"###/#../##./#../###\", F: \"###/#../##./#../#..\",\n  G: \".##/#../#.#/#.#/.##\", H: \"#.#/#.#/###/#.#/#.#\", I: \"#/#/#/#/#\",\n  J: \"..#/..#/..#/#.#/.#.\", K: \"#.#/#.#/##./#.#/#.#\", L: \"#../#../#../#../###\",\n  M: \"#...#/##.##/#.#.#/#...#/#...#\", N: \"#..#/##.#/#.##/#..#/#..#\",\n  O: \".#./#.#/#.#/#.#/.#.\", P: \"##./#.#/##./#../#..\", Q: \".#./#.#/#.#/##./.##\",\n  R: \"##./#.#/##./#.#/#.#\", S: \".##/#../.#./..#/##.\", T: \"###/.#./.#./.#./.#.\",\n  U: \"#.#/#.#/#.#/#.#/###\", V: \"#.#/#.#/#.#/#.#/.#.\", W: \"#...#/#...#/#.#.#/##.##/#...#\",\n  X: \"#.#/#.#/.#./#.#/#.#\", Y: \"#.#/#.#/.#./.#./.#.\", Z: \"###/..#/.#./#../###\",\n};\n// Each glyph as its width and the list of lit cells (dx, dy).\nconst FONT = {};\nfor (const ch in GLYPHS) {\n  const rows = GLYPHS[ch].split(\"/\"), cells = [];\n  rows.forEach((r, dy) => [...r].forEach((c, dx) => c === \"#\" && cells.push(dx, dy)));\n  FONT[ch] = { w: rows[0].length, cells };\n}\n\n// I AM THAT I AM is Exodus 3:14 in the King James Bible and Gysin's\n// phrase; TO BE OR NOT TO BE is Hamlet's and VENI VIDI VICI Caesar's.\n// Each word gets a colour of its own, shared where a word comes twice.\nconst PHRASES = [\"I AM THAT I AM\", \"RUB OUT THE WORD\", \"TO BE OR NOT TO BE\", \"VENI VIDI VICI\"].map((text) => {\n  const words = text.split(\" \");\n  const kinds = [...new Set(words)];\n  const widths = words.map((w) => [...w].reduce((s, c) => s + FONT[c].w + 1, -1));\n  return { words, kind: words.map((w) => kinds.indexOf(w)), kinds: kinds.length, widths };\n});\n\n// The three orders, each as the full list of token orders from the phrase.\nfunction sjt(n) {\n  const p = [...Array(n).keys()], d = Array(n).fill(-1), out = [p.slice()];\n  for (;;) {\n    let m = -1;\n    for (let i = 0; i \u003c n; i++) {\n      const j = i + d[i];\n      if (j >= 0 && j \u003c n && p[j] \u003c p[i] && (m \u003c 0 || p[i] > p[m])) m = i;\n    }\n    if (m \u003c 0) return out;\n    const v = p[m], j = m + d[m];\n    [p[m], p[j]] = [p[j], p[m]];\n    [d[m], d[j]] = [d[j], d[m]];\n    for (let i = 0; i \u003c n; i++) if (p[i] > v) d[i] = -d[i];\n    out.push(p.slice());\n  }\n}\nfunction heap(n) {\n  const a = [...Array(n).keys()], c = Array(n).fill(0), out = [a.slice()];\n  let i = 1;\n  while (i \u003c n) {\n    if (c[i] \u003c i) {\n      const j = i % 2 === 0 ? 0 : c[i];\n      [a[j], a[i]] = [a[i], a[j]];\n      out.push(a.slice());\n      c[i]++;\n      i = 1;\n    } else c[i++] = 0;\n  }\n  return out;\n}\nfunction lex(n) {\n  const a = [...Array(n).keys()], out = [a.slice()];\n  for (;;) {\n    let i = n - 2;\n    while (i >= 0 && a[i] > a[i + 1]) i--;\n    if (i \u003c 0) return out;\n    let j = n - 1;\n    while (a[j] \u003c a[i]) j--;\n    [a[i], a[j]] = [a[j], a[i]];\n    for (let l = i + 1, r = n - 1; l \u003c r; l++, r--) [a[l], a[r]] = [a[r], a[l]];\n    out.push(a.slice());\n  }\n}\nconst ORDERS = [sjt, heap, lex];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const q = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  for (let k = 0; k \u003c 3; k++) o[k] = v * (1 - s + s * q[k]);\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, phrase: -1, order: -1, list: null,\n    k: LINES - 3, u: 0, buf: new Float32Array(W * H * 3), o: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ph = cl(round(k[2] || 0), 0, 3), od = cl(round(k[3] == null ? 0.06 : k[3]), 0, 2);\n  if (ph !== S.phrase || od !== S.order) {\n    S.phrase = ph;\n    S.order = od;\n    S.list = ORDERS[od](PHRASES[ph].words.length);\n  }\n  S.u += d * 0.75 * S.speed;\n  while (S.u >= 1) {\n    S.u -= 1;\n    S.k++;\n  }\n}\n\n// Where each token's word starts, for the order on line m of the list.\nfunction places(S, m, left, out) {\n  const P = PHRASES[S.phrase], perm = S.list[((m % S.list.length) + S.list.length) % S.list.length];\n  let x = left;\n  for (const t of perm) {\n    out[t] = x;\n    x += P.widths[t] + GAP;\n  }\n  return out;\n}\n\n// The page dims row by row towards the top, to 45% on row 0, so the\n// oldest lines recede.\nconst FADE = new Float32Array(H);\nfor (let y = 0; y \u003c H; y++) FADE[y] = 0.45 + (0.55 * y) / (H - 1);\n\nfunction word(S, t, x0, y0, r, g, b) {\n  const B = S.buf, w = PHRASES[S.phrase].words[t];\n  let x = x0;\n  for (const ch of w) {\n    const f = FONT[ch], c = f.cells;\n    for (let i = 0; i \u003c c.length; i += 2) {\n      const px = round(x) + c[i], py = y0 + c[i + 1];\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const q = (py * W + px) * 3, v = FADE[py];\n      B[q] += r * v;\n      B[q + 1] += g * v;\n      B[q + 2] += b * v;\n    }\n    x += f.w + 1;\n  }\n}\n\n// A step is one new line: the words slide for the first half, the white\n// fades until 0.7, and the page steps up 6 rows in the rest.\nconst SLIDE = 0.5, HOLD = 0.7;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.list) return;\n  const P = PHRASES[S.phrase], n = P.words.length, B = S.buf, o = S.o;\n  B.fill(0);\n  const width = P.widths.reduce((s, v) => s + v, 0) + GAP * (n - 1);\n  const left = floor((W - width) / 2);\n  const u = S.u, slide = smooth(u / SLIDE);\n  const glow = u \u003c SLIDE ? 1 : u \u003c HOLD ? 1 - (u - SLIDE) / (HOLD - SLIDE) : 0;\n  const lift = u \u003c HOLD ? 0 : round(PITCH * smooth((u - HOLD) / (1 - HOLD)));\n  // One colour a word, spread round the wheel from a start picked so that\n  // at Hue 0 no word is red or orange; orange dimmed at the top of the page\n  // reads as brown.\n  const cols = [], base = P.kinds === 4 ? 0.68 : 0.58;\n  for (let i = 0; i \u003c P.kinds; i++) {\n    hsv(S.hue + base + i / P.kinds, 0.55, 230, o);\n    cols.push([o[0], o[1], o[2]]);\n  }\n  const a = new Array(n), b = new Array(n);\n  // Line S.k is the newest; while the page steps up, line S.k + 1 comes in\n  // under it as a copy, its words still in S.k's places.\n  const newest = lift > 0 ? S.k + 1 : S.k;\n  for (let m = newest; m > newest - LINES; m--) {\n    const y0 = BOTTOM - PITCH * (S.k - m) - lift;\n    if (y0 \u003c= -GH || y0 >= H) continue;\n    if (m === S.k) {\n      places(S, m - 1, left, a);\n      places(S, m, left, b);\n    } else places(S, m > S.k ? S.k : m, left, b);\n    for (let t = 0; t \u003c n; t++) {\n      const c = cols[P.kind[t]];\n      if (m === S.k && a[t] !== b[t]) {\n        const x = a[t] + (b[t] - a[t]) * slide, wv = 0.8 * glow;\n        word(S, t, x, y0, c[0] + (255 - c[0]) * wv, c[1] + (255 - c[1]) * wv, c[2] + (255 - c[2]) * wv);\n      } else word(S, t, b[t], y0, c[0], c[1], c[2]);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, B[q]), min(255, B[q + 1]), min(255, B[q + 2]));\n    }\n}\n","pollards-rho":"// ===== Patternflow pattern =====\n// Title:   Pollard's Rho\n// Family:  algo\n// Idea:    The sequence x -> x^2 + c taken modulo a hidden prime factor p of n stands up the panel as the Greek letter rho, a tail of numbered beads climbing from x0 = 2 at the bottom into a loop of beads at the top, and a tortoise and a hare chase each other along it, one bead and two beads a beat after Floyd or one bead a beat with the tortoise jumping to the hare at powers of two after Brent, while the readout beside the tail shows what the algorithm itself sees, the two values modulo n and their difference, and the gcd in the middle of the loop stays 1 until the two land on the same bead, when it jumps to p, the loop flashes and n is written as its two factors before the next number.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pollard's rho method of factorisation (John M. Pollard, 1975), with Floyd's cycle finding (credited to Robert W. Floyd) and Brent's (Richard P. Brent, 1980); numerals and letters drawn for this pattern on a 3 by 5 grid, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Number=0..7, Constant=1..6\n//\n// Knob 1: Hue. Turns the three colours round the wheel together. At 0 the beads are azure, the tortoise green and the hare orange; at 0.5 the beads are orange-red, the tortoise magenta and the hare blue.\n// Knob 2: Speed. One evaluation of f takes 0.44 / Speed seconds: 0.22 s at the opening 2, so a Floyd beat (three evaluations) takes 0.66 s and a Brent beat 0.22 s. At 0.2 a Floyd beat takes 6.6 s, at 3 it takes 0.44 s. A found factor is held 3.2 s at Speed 2.\n// Knob 3: Number. Which n the pattern starts from: 0 is 5893 = 71 x 83, then 6319, 8051 = 83 x 97, 4307, 4331, 6497, 2911 and 7031. Each number is factored by Floyd and then by Brent, and then the next one comes. With c = 1, 4307 = 59 x 73 fails: both primes close their loops on the same beat, the gcd is n itself, and the pattern tries again with c = 2.\n// Knob 4: Constant. The c in x^2 + c, 1 to 6. A new c is a new sequence and a new rho: for 5893 the rho modulo 83 has a tail of 4 and a loop of 5 at c = 1, 2 and 4 at c = 2, 5 and 5 at c = 4, and at c = 5 the factor that turns up first is 71, with a tail of 2 and a loop of 6.\n\n// Pollard's idea: take a map that looks random, f(x) = x^2 + c, and walk\n// x0, x1 = f(x0), x2 = f(x1), ... modulo n. Modulo an unknown prime factor p\n// of n the same walk is a walk on only p values, so after about sqrt(p)\n// steps it must come back to a value it has seen, and from there it goes\n// round the same loop for ever. Drawn out, the walk modulo p is a tail and a\n// loop: the letter rho. Modulo n nothing has repeated yet, but two terms\n// that sit on the same bead of the rho differ by a multiple of p, so\n// gcd(|x_i - x_j|, n) is p.\n//\n// The algorithm cannot see the rho, only the values modulo n. It finds the\n// loop without storing the walk by running two pointers. Floyd's tortoise\n// takes one step and his hare two each beat; once both are on the loop the\n// hare gains one bead a beat and lands on the tortoise's bead at the first\n// beat i that is at least the tail's length and a multiple of the loop's.\n// Brent's hare takes one step a beat and his tortoise waits, jumping to the\n// hare after 1, 2, 4, 8, ... steps; it costs one evaluation of f a beat\n// against Floyd's three, which is what Brent's 1980 paper gains. Here time\n// runs by evaluations, so the two methods race fairly on the same number.\n//\n// The beads are x_i mod p, which the panel knows and the algorithm does\n// not; the readout T and H are x_t and x_h mod n, and D is their difference.\n// The hare lights each bead as it first reaches it. Every product here is\n// below 8051^2, about 6.5e7, so ordinary doubles are exact.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst TAU = 2 * PI;\n\nconst NUMS = [5893, 6319, 8051, 4307, 4331, 6497, 2911, 7031];\nconst X0 = 2;\n// The rho: loop centre and radius, the stem down its left side to YB.\nconst CX = 32, CY = 31, R = 24, SX = CX - R, YB = 122;\n// Model seconds: one evaluation of f, the start, and the hold after a find.\nconst EVAL = 0.22, INTRO = 0.5, HOLD = 3.2, MOVE = 0.6;\nconst HUE_BEAD = 0.55, HUE_T = 0.33, HUE_H = 0.09;\n\n// ---- Glyphs on a 3 by 5 grid, rows top to bottom.\nconst GL = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\",\n  4: \"101101111001001\", 5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001001010010\",\n  8: \"111101111101111\", 9: \"111101111001111\",\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", L: \"100100100100111\", N: \"101111111101101\", O: \"010101101101010\",\n  R: \"110101110101101\", T: \"111010010010010\", X: \"101101010101101\", Y: \"101101010010010\",\n  \"+\": \"000010111010000\", \"=\": \"000111000111000\", \"*\": \"000101010101000\", \"|\": \"010010010010010\",\n  \"-\": \"000000111000000\", \" \": \"000000000000000\",\n};\n\nfunction gcd(a, b) {\n  while (b) {\n    const t = a % b;\n    a = b;\n    b = t;\n  }\n  return a;\n}\n\nfunction smallestFactor(n) {\n  for (let d = 2; d * d \u003c= n; d++) if (n % d === 0) return d;\n  return n;\n}\n\n// One run of the method on (n, c): the states beat by beat, and the rho of\n// the prime it finds (or, when it fails, of the smaller prime).\nfunction plan(n, c, brent) {\n  const xs = [X0 % n];\n  const x = (i) => {\n    while (xs.length \u003c= i) {\n      const v = xs[xs.length - 1];\n      xs.push((v * v + c) % n);\n    }\n    return xs[i];\n  };\n  const beats = [{ t: 0, h: 0, d: 0 }];\n  let d = 1;\n  if (!brent) {\n    for (let i = 1; d === 1 && i \u003c 400; i++) {\n      d = gcd(abs(x(i) - x(2 * i)), n);\n      beats.push({ t: i, h: 2 * i, d });\n    }\n  } else {\n    let pw = 1, lam = 1, t = 0, h = 1;\n    for (let k = 0; k \u003c 800; k++) {\n      d = gcd(abs(x(t) - x(h)), n);\n      beats.push({ t, h, d });\n      if (d > 1) break;\n      if (pw === lam) {\n        t = h;\n        pw *= 2;\n        lam = 0;\n      }\n      h++;\n      lam++;\n    }\n  }\n  const p = d > 1 && d \u003c n ? d : smallestFactor(n);\n  const seen = new Map(), lab = [];\n  let v = X0 % p, i = 0;\n  while (!seen.has(v)) {\n    seen.set(v, i);\n    lab.push(v);\n    v = (v * v + c) % p;\n    i++;\n  }\n  const mu = seen.get(v), lam = i - mu;\n  const tailSp = mu > 0 ? (YB - CY) / mu : 99, loopSp = lam > 1 ? 2 * R * sin(PI / lam) : 99;\n  return {\n    n, c, brent, xs, beats, d, p, q: n / p, mu, lam, lab, fail: d === n,\n    rt: cl(tailSp / 2 - 0.4, 1.5, 5), rl: cl(loopSp / 2 - 0.4, 1.5, 5),\n    beat: brent ? EVAL : 3 * EVAL,\n  };\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, num: -1, c: -1, idx: 0, cc: 1, brent: false,\n    run: null, m: 0, buf: new Float32Array(N * 3),\n    cb: [0, 0, 0], ct: [0, 0, 0], ch: [0, 0, 0], pos: [0, 0],\n  };\n}\n\nfunction start(S) {\n  S.run = plan(NUMS[S.idx], S.cc, S.brent);\n  S.m = 0;\n}\n\n// After a run: a failure tries the next c with the same method; a Floyd find\n// hands the number to Brent; a Brent find moves on to the next number.\nfunction next(S) {\n  const P = S.run;\n  if (P.fail) S.cc++;\n  else if (!P.brent) S.brent = true;\n  else {\n    S.brent = false;\n    S.idx = (S.idx + 1) % NUMS.length;\n    S.cc = S.c;\n  }\n  start(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const num = round(cl(k[2] || 0, 0, 7)), c = round(cl(k[3] == null ? 1 : k[3], 1, 6));\n  if (num !== S.num || c !== S.c) {\n    S.num = num;\n    S.c = c;\n    S.idx = num;\n    S.cc = c;\n    S.brent = false;\n    start(S);\n  }\n  const P = S.run, end = INTRO + (P.beats.length - 1) * P.beat;\n  // The hold after a find runs at no less than Speed 1, so a slow knob\n  // still moves on to the next number within 6.4 s.\n  S.m += d * (S.m > end ? max(1, S.speed) : S.speed) * 0.5;\n  if (S.m > end + HOLD) next(S);\n}\n\n// ---- Drawing into a float RGB buffer.\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] = c[0] * a;\n  buf[p + 1] = c[1] * a;\n  buf[p + 2] = c[2] * a;\n}\n\nfunction disc(buf, cx, cy, r, c, a) {\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const e = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      add(buf, x, y, c, a * cl(r + 0.5 - e, 0, 1));\n    }\n}\n\nfunction ring(buf, cx, cy, r, c, a, w) {\n  for (let y = floor(cy - r - 2); y \u003c= cy + r + 2; y++)\n    for (let x = floor(cx - r - 2); x \u003c= cx + r + 2; x++) {\n      const e = abs(sqrt((x - cx) ** 2 + (y - cy) ** 2) - r);\n      add(buf, x, y, c, a * cl(w + 0.5 - e, 0, 1));\n    }\n}\n\nconst textWidth = (s, sc) => s.length * 4 * sc - sc;\n\n// mode 0 adds light, mode 1 punches the glyph dark out of what is there.\nfunction text(buf, s, x0, y0, sc, c, a, mode) {\n  for (let k = 0; k \u003c s.length; k++) {\n    const g = GL[s[k]];\n    if (!g) continue;\n    for (let gy = 0; gy \u003c 5; gy++)\n      for (let gx = 0; gx \u003c 3; gx++) {\n        if (g[gy * 3 + gx] !== \"1\") continue;\n        for (let yy = 0; yy \u003c sc; yy++)\n          for (let xx = 0; xx \u003c sc; xx++) {\n            const x = x0 + k * 4 * sc + gx * sc + xx, y = y0 + gy * sc + yy;\n            if (mode) put(buf, x, y, c, a);\n            else add(buf, x, y, c, a);\n          }\n      }\n  }\n}\n\n// A point on the rho at fractional node u: the tail up the stem, then the\n// loop, entered at its leftmost point going up and round clockwise.\nfunction along(P, u, o) {\n  if (u \u003c P.mu) {\n    o[0] = SX;\n    o[1] = YB - ((YB - CY) * u) / P.mu;\n  } else {\n    const a = PI + (TAU * (u - P.mu)) / P.lam;\n    o[0] = CX + R * cos(a);\n    o[1] = CY + R * sin(a);\n  }\n  return o;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.run) return;\n  const P = S.run, buf = S.buf, pos = S.pos;\n  buf.fill(0);\n  const CB = hsv(S.hue + HUE_BEAD, 0.75, 1, S.cb), CT = hsv(S.hue + HUE_T, 0.8, 1, S.ct), CH = hsv(S.hue + HUE_H, 0.85, 1, S.ch);\n  const white = [1, 1, 1], pale = [0.82, 0.86, 0.95];\n\n  // Where the run is: beat k, the share f of it gone, the movement eased.\n  const nb = P.beats.length, tm = S.m - INTRO;\n  let k = 0, f = 1;\n  if (tm >= 0) {\n    k = min(nb - 1, 1 + floor(tm / P.beat));\n    f = k === nb - 1 && tm >= (nb - 1) * P.beat ? 1 : (tm - (k - 1) * P.beat) / P.beat;\n  }\n  const e = smooth(f / MOVE), b0 = P.beats[max(0, k - 1)], b1 = P.beats[k];\n  const tu = k === 0 ? 0 : b0.t + (b1.t - b0.t) * e, hu = k === 0 ? 0 : b0.h + (b1.h - b0.h) * e;\n  const shown = k === 0 ? P.beats[0] : f >= MOVE ? b1 : b0;\n  const found = k === nb - 1 && f >= MOVE;\n  const since = found ? S.m - INTRO - (nb - 2) * P.beat - MOVE * P.beat : -1;\n  const flash = found ? cl(1 - since / 0.7, 0, 1) : 0;\n\n  // The string: the loop, and the stem when there is a tail.\n  const loopA = 0.2 + (found ? 0.25 + 0.55 * flash : 0);\n  ring(buf, CX, CY, R, found ? white : CB, loopA, 0.45);\n  if (P.mu > 0) for (let y = CY; y \u003c= YB; y++) add(buf, SX, y, CB, 0.22);\n\n  // The beads, lit once the hare has reached them, each with x_i mod p.\n  const nodes = P.mu + P.lam;\n  for (let i = 0; i \u003c nodes; i++) {\n    along(P, i, pos);\n    const x = pos[0], y = pos[1], r = i \u003c P.mu ? P.rt : P.rl;\n    if (hu + 1e-6 >= i) {\n      disc(buf, x, y, r, CB, 0.82);\n      const s = String(P.lab[i]);\n      if (r >= 4.4) text(buf, s, round(x - textWidth(s, 1) / 2), round(y - 2.5), 1, CB, 0.05, 1);\n    } else ring(buf, x, y, r - 0.5, CB, 0.3, 0.45);\n  }\n\n  // The meeting bead flashes white with a ring running out from it.\n  if (found) {\n    along(P, P.beats[nb - 1].t, pos);\n    const r = P.beats[nb - 1].t \u003c P.mu ? P.rt : P.rl;\n    disc(buf, pos[0], pos[1], r + 1, white, 0.9 * flash);\n    if (since \u003c 1.2) ring(buf, pos[0], pos[1], r + 3 + since * 26, white, 0.7 * (1 - since / 1.2), 0.6);\n  }\n\n  // Tortoise and hare: rings round their beads.\n  along(P, tu, pos);\n  ring(buf, pos[0], pos[1], P.rl + 2.2, CT, 1, 0.55);\n  along(P, hu, pos);\n  ring(buf, pos[0], pos[1], P.rl + 3.8, CH, 1, 0.55);\n\n  // The gcd in the middle of the loop.\n  const g = shown.d || 1;\n  text(buf, \"GCD\", CX - 5, CY - 13, 1, pale, 0.55, 0);\n  if (P.fail && found) {\n    // n itself is four digits wide and reaches the rings on the loop, so it\n    // gets a dark field one LED round it to stay whole.\n    const s = String(g), x0 = CX - textWidth(s, 2) / 2;\n    for (let y = CY - 5; y \u003c= CY + 6; y++) for (let x = x0 - 1; x \u003c= x0 + textWidth(s, 2); x++) put(buf, x, y, white, 0);\n    text(buf, s, x0, CY - 4, 2, white, 0.5 + 0.5 * flash, 0);\n  } else {\n    const s = String(g), sc = 3;\n    text(buf, s, round(CX - textWidth(s, sc) / 2), CY - 5, sc, found ? CB : pale, found ? 0.6 + 0.4 * flash : 0.5, 0);\n    if (found) text(buf, s, round(CX - textWidth(s, sc) / 2), CY - 5, sc, white, 0.6 * flash, 0);\n  }\n\n  // The readout beside the stem: what the algorithm sees modulo n.\n  const RX = 20;\n  const ns = String(P.n);\n  text(buf, ns, RX + 23 - textWidth(ns, 2) / 2, 66, 2, pale, 0.85, 0);\n  // f(x) = x^2 + c, the 2 a small raised one.\n  text(buf, \"X\", RX + 6, 81, 1, pale, 0.7, 0);\n  add(buf, RX + 10, 79, pale, 0.7);\n  add(buf, RX + 11, 79, pale, 0.7);\n  add(buf, RX + 11, 80, pale, 0.7);\n  add(buf, RX + 10, 81, pale, 0.7);\n  add(buf, RX + 10, 82, pale, 0.7);\n  add(buf, RX + 11, 82, pale, 0.7);\n  text(buf, \"+\" + P.c, RX + 13, 81, 1, pale, 0.7, 0);\n  const evals = (k === 0 ? 0 : f >= MOVE ? k : k - 1) * (P.brent ? 1 : 3);\n  text(buf, P.brent ? \"BRENT\" : \"FLOYD\", RX + 2, 90, 1, pale, 0.75, 0);\n  const es = String(evals);\n  text(buf, es, RX + 44 - textWidth(es, 1), 90, 1, pale, 0.6, 0);\n  const xt = P.xs[shown.t], xh = P.xs[shown.h];\n  text(buf, \"T\", RX + 2, 100, 1, CT, 1, 0);\n  text(buf, String(xt), RX + 44 - textWidth(String(xt), 1), 100, 1, CT, 0.95, 0);\n  text(buf, \"H\", RX + 2, 107, 1, CH, 1, 0);\n  text(buf, String(xh), RX + 44 - textWidth(String(xh), 1), 107, 1, CH, 0.95, 0);\n  text(buf, \"D\", RX + 2, 114, 1, pale, 0.75, 0);\n  const ds = String(abs(xt - xh));\n  text(buf, ds, RX + 44 - textWidth(ds, 1), 114, 1, pale, 0.75, 0);\n  if (found) {\n    const s = P.fail ? \"FAIL C+1\" : \"=\" + P.p + \"*\" + P.q;\n    text(buf, s, RX + 44 - textWidth(s, 1), 122, 1, P.fail ? CH : CB, 0.7 + 0.3 * flash, 0);\n  }\n\n  for (let p = 0; p \u003c N; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n}\n","ybc-7289":"// ===== Patternflow pattern =====\n// Title:   YBC 7289\n// Family:  type\n// Idea:    The upper half of the tall panel is the face of the tablet YBC 7289 under a swaying lamp, a square with both diagonals pressed into clay and its numbers in cuneiform wedges, 30 by a side, 1;24,51,10 along the diagonal and 42;25,35 below it, and on the clay below, the averaging x -> (x + 2/x)/2 is written out wedge by wedge from 1;30, one step to a line in sexagesimal places, each place lighting turquoise once it is the square root of 2's own place, so 1;30 and 1;25 light only their 1, 1;24,51,10,35 lights four places and the tablet's number with them, and 1;24,51,10,7 lights all five.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: YBC 7289, Yale Babylonian Collection, Old Babylonian (about 1800 to 1600 BCE); the averaging method for square roots as later written down by Heron of Alexandria (1st century); wedges drawn for this pattern as pyramids pressed into a height field, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Lamp=0..1, Speed=0.2..3, Start=0..5, Places=0..1\n//\n// Knob 1: Lamp. Where the lamp stands around the tablet, a full turn over the range; it is always 15 degrees above the clay and sways 29 degrees either way. At 0 it is on the left and a little above, so a wedge's left wall falls into shadow and its right wall catches the light; at 0.25 it is below, at 0.5 on the right, where the bright and dark walls of every wedge change sides, and at 0.75 above.\n// Knob 2: Speed. At 2 a wedge is pressed every 0.06 s and each agreeing place lights 0.12 s after the one before, so the four lines from 1;30 are written and checked in 7.9 s and stand 3.5 s before the clay is smoothed over 1.2 s, a round of 13.1 s; the lamp sways once in 7 s. Every time goes as 2 / Speed.\n// Knob 3: Start. The first guess: 0 is 1;30 (3/2), 1 is 1;20 (4/3), 2 is 2, 3 is 1, 4 is 1;24 (7/5), 5 is 1;40 (5/3). 1;30 and 1;20 both give 1;25 next, and 2 and 1 both give 1;30, since x and 2/x always lead to the same average; 1;24 agrees in two places at once and needs only three lines. A new start opens on its lines already written, then smooths them and writes them again.\n// Knob 4: Places. How many places after the point each step keeps before the next is worked out: all of them below 0.125 (the opening 0.06), so the lines run on until one holds five places that all agree; 4 from 0.125, 3 from 0.375, 2 from 0.625 and 1 from 0.875. Cut to 3, every start lands on 1;24,51,10, the tablet's own number, the next step gives it back unchanged, and the tablet's number lights; cut to 2 or 1 the lines settle on 1;24,51 or 1;24 and the tablet stays dark.\n\n// YBC 7289 carries a square with its two diagonals. One side is marked 30;\n// along a diagonal stands 1;24,51,10 and under it 42;25,35. In base 60,\n// 1;24,51,10 is 1 + 24/60 + 51/60^2 + 10/60^3 = 1.4142130, the square root\n// of 2 to about six decimal places, and 42;25,35 is 30 times it: the\n// diagonal of the square of side 30. Halving 1;24,51,10 gives 0;42,25,35,\n// so multiplying by 30 is halving and moving one place up.\n//\n// The method drawn below takes a guess x for the root of 2 and averages it\n// with 2/x. When x is too big 2/x is too small by about as much, so the\n// average lands far closer, and each step about doubles the places that\n// are right. From 3/2: 17/12 = 1;25, then 577/408 = 1;24,51,10,35,... and\n// 665857/470832 = 1;24,51,10,7,46,6,9,... where the root is\n// 1;24,51,10,7,46,6,4,44. The iterates are kept as exact fractions (BigInt)\n// and their places read off one by one, so a place lights only when it is\n// the root's own place, not a rounding of it. 1;25 is nearer the root than\n// 1;24 but its 25 is not the root's 24, so line two lights only its 1.\n//\n// Places cuts each step to so many places before the next, as anyone\n// working by hand must. Cut to three, the steps from every start reach\n// 1;24,51,10 and stop there: the average of 1;24,51,10 and 2 over it is\n// the root plus about 1e-13, whose first three places are 1;24,51,10 again.\n//\n// Numerals: a place from 1 to 59 is its tens as corner wedges\n// (Winkelhaken) on the left, stacked in a column (four as two and two,\n// five as three and two), and its units as upright wedges in rows of three\n// on the right. Places stand a gap apart and a zero place is a wider gap.\n// Nothing marks where the whole part ends: the semicolon in 1;24,51,10 is\n// the modern reader's, and the wedges are only 1, 24, 51 and 10.\n//\n// Each wedge is a triangular pyramid pressed into a height field: a\n// triangle outline and its deepest point, the stylus's corner. The upright\n// wedge is a broad head with a tail; the corner wedge a short triangle\n// pointing left. The LEDs average 16 samples each of the surface normal,\n// and the light is a lamp at azimuth and elevation, scaled so flat clay\n// keeps one brightness: walls facing the lamp glow, walls facing away go\n// dark, and the deeper the floor the darker. The lamp sways, so the light\n// moves in every wedge on the panel while the stylus works on one.\n//\n// An agreeing place lights in two ways at once: its wedges turn turquoise\n// with the light spilling 4 LEDs round each, and a soft tile fills the box\n// of the place, so the agreeing run of a line reads as one highlighted span.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, PI, hypot, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Clay, its shadow floor, and the colour an agreeing place lights.\nconst CLAY = [168, 132, 92];\nconst AMB = 0.16, OCC = 0.85;\nconst GLOW = [45, 230, 220];\n\n// Wedge sizes in LEDs. A size is the cell an upright wedge or a corner\n// wedge sits in, c wide and r tall, and the width w of the wedge inside it.\n// The tablet writes small, so its 42;25,35 fits under the diagonal; the\n// worked lines write a size up.\nconst SMALL = { c: 3, r: 4, w: 2.6, x0: 0.2, tu: 1 }, LARGE = { c: 4, r: 4, w: 3, x0: 0, tu: 0 };\nconst DEPTH = 1.1, SS = 4, HALO = 4, PLACE_GAP = 3, ZERO_GAP = 6;\n\n// Timing in model seconds; Speed 2 runs one model second a second.\nconst T_WEDGE = 0.06, T_PLACE = 0.08, T_PAUSE = 0.25, T_CHECK = 0.12, T_AFTER = 0.3, T_HOLD = 3.5, T_SMOOTH = 1.2, T_REST = 0.5;\n\nconst STARTS = [[3n, 2n], [4n, 3n], [2n, 1n], [1n, 1n], [7n, 5n], [5n, 3n]];\n// How many places after the point a step keeps, by Places.\nconst KEEP = [Infinity, 4, 3, 2, 1];\nconst PLACES = 8;\n// The lamp sways SWAY radians either side of where Lamp sets it, once in SWAY_T model seconds.\nconst SWAY = 0.5, SWAY_T = 7, EL = (15 * PI) / 180;\n\n// ---- Exact arithmetic.\nfunction isqrt(n) {\n  if (n \u003c 2n) return n;\n  let x = n, y = (x + 1n) / 2n;\n  while (y \u003c x) {\n    x = y;\n    y = (x + n / x) / 2n;\n  }\n  return x;\n}\nfunction sexagesimal(p, q, n) {\n  const out = [Number(p / q)];\n  let r = p % q;\n  for (let k = 0; k \u003c n; k++) {\n    r *= 60n;\n    out.push(Number(r / q));\n    r %= q;\n  }\n  return out;\n}\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\nconst ROOT = (() => {\n  let v = isqrt(2n * 60n ** BigInt(2 * PLACES));\n  const d = [];\n  for (let k = 0; k \u003c= PLACES; k++) {\n    d.unshift(Number(v % 60n));\n    v /= 60n;\n  }\n  return d;\n})();\n\n// ---- Wedges as pyramids. Each returns its footprint on the LEDs: for every\n// LED it touches, the change it makes to the averaged normal, the share of\n// the LED inside it, the mean depth and how much of its glow reaches it.\nfunction pyramid(tri, P0) {\n  const edges = [];\n  for (let i = 0; i \u003c 3; i++) {\n    const A = tri[(i + 1) % 3], B = tri[(i + 2) % 3], C = tri[i];\n    let nx = -(B[1] - A[1]), ny = B[0] - A[0];\n    const l = hypot(nx, ny);\n    nx /= l;\n    ny /= l;\n    if (nx * (C[0] - A[0]) + ny * (C[1] - A[1]) \u003c 0) {\n      nx = -nx;\n      ny = -ny;\n    }\n    const d0 = nx * (P0[0] - A[0]) + ny * (P0[1] - A[1]);\n    const s = DEPTH / d0, nz = 1 / sqrt(1 + s * s);\n    edges.push({ ax: A[0], ay: A[1], nx, ny, d0, Nx: s * nx * nz, Ny: s * ny * nz, Nz: nz });\n  }\n  const x0 = floor(min(tri[0][0], tri[1][0], tri[2][0])), x1 = ceil(max(tri[0][0], tri[1][0], tri[2][0]));\n  const y0 = floor(min(tri[0][1], tri[1][1], tri[2][1])), y1 = ceil(max(tri[0][1], tri[1][1], tri[2][1]));\n  const out = [];\n  const w = 1 / (SS * SS);\n  for (let y = max(0, y0 - HALO); y \u003c min(H, y1 + HALO); y++)\n    for (let x = max(0, x0 - HALO); x \u003c min(W, x1 + HALO); x++) {\n      let dx = 0, dy = 0, dz = 0, cov = 0, dep = 0;\n      for (let sy = 0; sy \u003c SS; sy++)\n        for (let sx = 0; sx \u003c SS; sx++) {\n          const px = x + (sx + 0.5) / SS, py = y + (sy + 0.5) / SS;\n          let best = 2, k = -1;\n          for (let i = 0; i \u003c 3; i++) {\n            const e = edges[i], u = (e.nx * (px - e.ax) + e.ny * (py - e.ay)) / e.d0;\n            if (u \u003c 0) {\n              k = -1;\n              break;\n            }\n            if (u \u003c best) {\n              best = u;\n              k = i;\n            }\n          }\n          if (k \u003c 0) continue;\n          const e = edges[k];\n          dx += e.Nx * w;\n          dy += e.Ny * w;\n          dz += (e.Nz - 1) * w;\n          cov += w;\n          dep += best * DEPTH * w;\n        }\n      // The glow of an agreeing place spills a little onto the clay round\n      // each wedge, falling off over HALO LEDs from its outline.\n      let far = 0;\n      for (const e of edges) far = max(far, -(e.nx * (x + 0.5 - e.ax) + e.ny * (y + 0.5 - e.ay)));\n      const halo = max(cov, 0.75 * cl(1 - far / HALO, 0, 1));\n      if (cov > 0 || halo > 0) out.push(y * W + x, dx, dy, dz, cov, dep, halo);\n    }\n  return Float32Array.from(out);\n}\n// An upright wedge: broad head at the top, tail down to a point.\nconst upright = (x, y, z) =>\n  pyramid([[x + z.x0, y + 0.1], [x + z.x0 + z.w, y + 0.1], [x + z.x0 + z.w / 2, y + z.r - 0.1]], [x + z.x0 + z.w / 2, y + 1.2]);\n// A corner wedge: a short triangle pointing left, deepest near its point.\nconst corner = (x, y, z) =>\n  pyramid([[x + z.x0, y + 1.5], [x + z.x0 + z.w, y + 0.05], [x + z.x0 + z.w, y + 2.95]], [x + z.x0 + 1.1, y + 1.5]);\n\n// ---- Numerals. A place's wedges in writing order, tens first, from the\n// place's left edge x and the line's middle row ym.\nfunction placeWidth(v, z) {\n  if (v === 0) return ZERO_GAP - PLACE_GAP;\n  const t = floor(v / 10), u = v % 10;\n  const tw = t === 0 ? 0 : (t \u003c= 3 ? 1 : 2) * z.c;\n  const uw = min(u, 3) * z.c;\n  return tw + uw + (t && u ? z.tu : 0) - (z.c - z.w - z.x0 > 0.5 ? 1 : 0);\n}\nfunction placeWedges(v, x, ym, z) {\n  const out = [];\n  const t = floor(v / 10), u = v % 10;\n  const cols = t === 0 ? [] : t \u003c= 3 ? [t] : t === 4 ? [2, 2] : [3, 2];\n  cols.forEach((n, c) => {\n    const top = round(ym - (n * z.r - 1) / 2);\n    for (let i = 0; i \u003c n; i++) out.push({ kind: 1, x: x + c * z.c, y: top + i * z.r });\n  });\n  const ux = x + cols.length * z.c + (t && u ? z.tu : 0);\n  const rows = ceil(u / 3), top = round(ym - (rows * z.r - 1) / 2);\n  for (let r = 0; r \u003c rows; r++) for (let i = 0; i \u003c min(3, u - 3 * r); i++) out.push({ kind: 0, x: ux + i * z.c, y: top + r * z.r });\n  return out;\n}\n// A number from its places, left edge x: the wedges, each tagged with its\n// place and its size.\nfunction numberWedges(digits, x, ym, z) {\n  const wedges = [];\n  digits.forEach((v, k) => {\n    for (const w of placeWedges(v, round(x), ym, z)) wedges.push(Object.assign(w, { place: k, z }));\n    x += placeWidth(v, z) + PLACE_GAP;\n  });\n  return wedges;\n}\nconst numberWidth = (digits, z) => digits.reduce((s, v) => s + placeWidth(v, z) + PLACE_GAP, -PLACE_GAP);\n\n// The soft tile of light under an agreeing place: its wedges' box, full\n// strength POOL inside and fading out over 1.5 LEDs.\nconst POOL = 0.6;\nfunction pool(wedges) {\n  let x0 = 99, y0 = 999, x1 = -99, y1 = -999;\n  for (const w of wedges) {\n    x0 = min(x0, w.x + w.z.x0);\n    x1 = max(x1, w.x + w.z.x0 + w.z.w);\n    y0 = min(y0, w.y);\n    y1 = max(y1, w.y + (w.kind ? 3 : w.z.r - 0.1));\n  }\n  const out = [];\n  for (let y = max(0, floor(y0) - 2); y \u003c min(H, ceil(y1) + 2); y++)\n    for (let x = max(0, floor(x0) - 2); x \u003c min(W, ceil(x1) + 2); x++) {\n      const dx = max(x0 - x - 0.5, x + 0.5 - x1, 0), dy = max(y0 - y - 0.5, y + 0.5 - y1, 0);\n      const v = POOL * smooth((1.5 - hypot(dx, dy)) / 1.5);\n      if (v > 0) out.push(y * W + x, v);\n    }\n  return Float32Array.from(out);\n}\nfunction places(wedges) {\n  const by = new Map();\n  for (const w of wedges) {\n    if (!by.has(w.place)) by.set(w.place, []);\n    by.get(w.place).push(w);\n  }\n  return by;\n}\n\nfunction makeItem(w) {\n  return { fp: w.kind ? corner(w.x, w.y, w.z) : upright(w.x, w.y, w.z), place: w.place, at: 0, glowAt: Infinity };\n}\n\n// ---- The tablet face, upper half: grooves of the square and its diagonals\n// in a static normal field, a ruled line under it, and its three numbers as\n// items that never fade.\nconst SQ = { cx: 32, cy: 33, r: 30.5 };\nfunction grooves(st, stD) {\n  const { cx, cy, r } = SQ;\n  const V = [[cx - r, cy], [cx, cy - r], [cx + r, cy], [cx, cy + r]];\n  const segs = [[V[0], V[1]], [V[1], V[2]], [V[2], V[3]], [V[3], V[0]], [V[0], V[2]], [V[1], V[3]], [[1, 67.5], [63, 67.5]]];\n  const hw = 0.95, dg = 0.55, s = dg / hw, nz = 1 / sqrt(1 + s * s), w = 1 / (SS * SS);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      for (let sy = 0; sy \u003c SS; sy++)\n        for (let sx = 0; sx \u003c SS; sx++) {\n          const px = x + (sx + 0.5) / SS, py = y + (sy + 0.5) / SS;\n          let bd = 9, ux = 0, uy = 0;\n          for (const [A, B] of segs) {\n            const dx = B[0] - A[0], dy = B[1] - A[1];\n            const t = cl(((px - A[0]) * dx + (py - A[1]) * dy) / (dx * dx + dy * dy), 0, 1);\n            const qx = px - (A[0] + t * dx), qy = py - (A[1] + t * dy), d = hypot(qx, qy);\n            if (d \u003c bd) {\n              bd = d;\n              ux = d > 1e-6 ? qx / d : 0;\n              uy = d > 1e-6 ? qy / d : 0;\n            }\n          }\n          if (bd >= hw) continue;\n          // The groove's wall tilts towards its middle line.\n          st[p * 3] += -s * ux * nz * w;\n          st[p * 3 + 1] += -s * uy * nz * w;\n          st[p * 3 + 2] += (nz - 1) * w;\n          stD[p] += dg * (1 - bd / hw) * w;\n        }\n      // The clay is a low pillow, 1.5 degrees at the edges.\n      st[p * 3] += 0.026 * ((x + 0.5 - 32) / 32);\n      st[p * 3 + 1] += 0.026 * ((y + 0.5 - 64) / 64);\n    }\n}\n\n// The tablet's wedges, and the tiles of light under its 1;24,51,10.\nfunction tabletItems() {\n  const items = [], pools = [];\n  const { cx, cy } = SQ;\n  // 30 by the upper left side, 1;24,51,10 above the level diagonal, 42;25,35 below it.\n  const groups = [\n    { digits: [30], x: 26, ym: 16, tag: 0 },\n    { digits: [1, 24, 51, 10], x: cx - numberWidth([1, 24, 51, 10], SMALL) / 2, ym: cy - 6, tag: 1 },\n    { digits: [42, 25, 35], x: cx - numberWidth([42, 25, 35], SMALL) / 2, ym: cy + 7, tag: 2 },\n  ];\n  for (const g of groups) {\n    const wedges = numberWedges(g.digits, g.x, g.ym, SMALL);\n    for (const w of wedges) {\n      const it = makeItem(w);\n      it.tag = g.tag;\n      items.push(it);\n    }\n    if (g.tag === 1) for (const ws of places(wedges).values()) pools.push(pool(ws));\n  }\n  return { items, pools };\n}\n\n// ---- The worked lines, lower half.\nconst LINE_X = 2, LINE_W = 61, LOW_TOP = 69, LOW_BOT = 127;\n\n// The steps from a start, each cut to `keep` places after the point. A\n// line holds as many places as fit across the panel. The lines stop when\n// one holds five places and all agree with the root, or when a cut step\n// gives back the line before it.\nfunction plan(start, keep) {\n  let [p, q] = STARTS[start];\n  const lines = [];\n  let before = null;\n  for (let i = 0; i \u003c 6; i++) {\n    const d = sexagesimal(p, q, PLACES);\n    let n = 1;\n    while (n \u003c d.length && numberWidth(d.slice(0, n + 1), LARGE) \u003c= LINE_W) n++;\n    while (n > 1 && d[n - 1] === 0) n--;\n    const shown = d.slice(0, n);\n    let agree = 0;\n    while (agree \u003c n && shown[agree] === ROOT[agree]) agree++;\n    lines.push({ shown, agree });\n    const same = before && before[0] === p && before[1] === q;\n    if ((agree === n && n >= 5) || same) break;\n    before = [p, q];\n    [p, q] = [p * p + 2n * q * q, 2n * p * q];\n    if (keep \u003c Infinity) {\n      const unit = 60n ** BigInt(keep);\n      [p, q] = [(p * unit) / q, unit];\n    }\n    const g = gcd(p, q);\n    p /= g;\n    q /= g;\n  }\n  const pitch = min(14, floor((LOW_BOT - LOW_TOP) / lines.length));\n  const top = LOW_TOP + (LOW_BOT - LOW_TOP - pitch * lines.length) / 2;\n  const items = [], pools = [];\n  let t = 0.3, sync = Infinity;\n  lines.forEach((L, i) => {\n    const ym = top + pitch * (i + 0.5);\n    const wedges = numberWedges(L.shown, LINE_X, ym, LARGE), byPlace = places(wedges);\n    let last = -1;\n    for (const w of wedges) {\n      if (w.place !== last && last >= 0) t += T_PLACE;\n      last = w.place;\n      const it = makeItem(w);\n      it.at = t;\n      it.line = i;\n      it.agree = w.place \u003c L.agree;\n      items.push(it);\n      t += T_WEDGE;\n    }\n    t += T_PAUSE;\n    for (let k = 0; k \u003c L.agree; k++) {\n      for (const it of items) if (it.line === i && it.place === k) it.glowAt = t;\n      pools.push({ fp: pool(byPlace.get(k)), glowAt: t });\n      if (k === 3 && sync === Infinity) sync = t;\n      t += T_CHECK;\n    }\n    t += T_AFTER;\n  });\n  return { items, pools, end: t + T_HOLD, sync };\n}\n\nexport function setup(params) {\n  const st = new Float32Array(N * 3), stD = new Float32Array(N);\n  grooves(st, stD);\n  params.s = {\n    t: 0, clock: 0, start: -1, keep: -1, lampA: 0,\n    st, stD,\n    dn: new Float32Array(N * 3), dD: new Float32Array(N), glow: new Float32Array(N),\n    plan: null,\n  };\n  const T = tabletItems();\n  params.s.tablet = T.items;\n  params.s.tabletPools = T.pools;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.lampA = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const start = cl(round(k[2] || 0), 0, STARTS.length - 1);\n  const keep = KEEP[cl(round(4 * (k[3] == null ? 0.06 : k[3])), 0, 4)];\n  // A new start, or a new cut, opens on its lines already written, 3.2\n  // model seconds before the clay is smoothed and they are written again.\n  if (start !== S.start || keep !== S.keep) {\n    S.start = start;\n    S.keep = keep;\n    S.plan = plan(start, keep);\n    S.t = S.plan.end - 3.2;\n  }\n  S.t += (d * speed) / 2;\n  S.clock += (d * speed) / 2;\n  if (S.t > S.plan.end + T_SMOOTH + T_REST) S.t = 0;\n}\n\nfunction light(S, fp, g) {\n  const gl = S.glow;\n  for (let i = 0; i \u003c fp.length; i += 2) gl[fp[i]] = max(gl[fp[i]], fp[i + 1] * g);\n}\n\nfunction stamp(S, it, scale, glow) {\n  const fp = it.fp, dn = S.dn, dD = S.dD, gl = S.glow;\n  for (let i = 0; i \u003c fp.length; i += 7) {\n    const p = fp[i];\n    dn[p * 3] += fp[i + 1] * scale;\n    dn[p * 3 + 1] += fp[i + 2] * scale;\n    dn[p * 3 + 2] += fp[i + 3] * scale;\n    dD[p] += fp[i + 5] * scale;\n    if (glow > 0) gl[p] = max(gl[p], fp[i + 6] * glow);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.plan) return;\n  const P = S.plan, t = S.t;\n  S.dn.fill(0);\n  S.dD.fill(0);\n  S.glow.fill(0);\n  const fade = 1 - smooth((t - P.end) / T_SMOOTH);\n  const sync = smooth((t - P.sync) / 0.4) * fade;\n  for (const it of S.tablet) stamp(S, it, 1, it.tag === 1 ? sync : 0);\n  if (sync > 0) for (const fp of S.tabletPools) light(S, fp, sync);\n  for (const pl of P.pools) if (t >= pl.glowAt) light(S, pl.fp, smooth((t - pl.glowAt) / 0.25) * fade);\n  for (const it of P.items) {\n    if (t \u003c it.at) continue;\n    const press = smooth((t - it.at) / 0.06) * fade;\n    stamp(S, it, press, it.agree ? smooth((t - it.glowAt) / 0.25) * fade : 0);\n  }\n  // The lamp, its azimuth counted anticlockwise from the right with up as\n  // up: at Lamp 0 it stands on the left and a little above.\n  const az = PI - 0.35 + 2 * PI * S.lampA + SWAY * sin((2 * PI * S.clock) / SWAY_T);\n  const Lx = cos(EL) * cos(az), Ly = -cos(EL) * sin(az), Lz = sin(EL);\n  const st = S.st, stD = S.stD, dn = S.dn, dD = S.dD, gl = S.glow;\n  for (let p = 0; p \u003c N; p++) {\n    const nx = st[p * 3] + dn[p * 3], ny = st[p * 3 + 1] + dn[p * 3 + 1], nz = 1 + st[p * 3 + 2] + dn[p * 3 + 2];\n    const b = cl((nx * Lx + ny * Ly + nz * Lz) / Lz, 0, 2.2);\n    const sh = (AMB + (1 - AMB) * b) * (1 - OCC * cl(stD[p] + dD[p], 0, 1));\n    let r = CLAY[0] * sh, g = CLAY[1] * sh, bl = CLAY[2] * sh;\n    const gw = cl(gl[p], 0, 1) * 0.9;\n    if (gw > 0) {\n      const lit = 0.45 + 0.4 * min(1, sh);\n      r += (GLOW[0] * lit - r) * gw;\n      g += (GLOW[1] * lit - g) * gw;\n      bl += (GLOW[2] * lit - bl) * gw;\n    }\n    display.setPixel(p % W, floor(p / W), cl(round(r), 0, 255), cl(round(g), 0, 255), cl(round(bl), 0, 255));\n  }\n}\n","coupling-from-the-past":"// ===== Patternflow pattern =====\n// Title:   Coupling from the Past\n// Family:  noise\n// Idea:    Two Ising magnets, one started all up on the top half and one all down on the bottom, run forward from time -T to 0 on the same random numbers while the sites where they still disagree glow pink and dissolve; a run that ends with any left starts again from twice as far back, reusing the numbers for its last stretch, and once the two meet the picture at time 0 is an exact sample, which a check run from twice as far back again lands on LED for LED.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: coupling from the past (James Propp and David Wilson, 1996) on the Ising model (Wilhelm Lenz, 1920) with heat-bath updates, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beta=0.32..0.43, Field=-1..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. At 0 an up spin is pale ice blue, a down spin deep indigo and a site where the two chains disagree pink, bright on the top half and deeper on the bottom; at 0.25 they are lilac, purple and yellow, at 0.5 peach, indigo and green, at 0.75 pale green, teal and blue. The down spins keep to the deep arc from teal to purple, since a deep orange reads brown.\n// Knob 2: Speed. How fast a run goes from -T to 0. At 2 the first run, 8 sweeps, takes 0.45 s and each doubling 1.37 times longer, so 64 sweeps take 1.15 s and 1024 take 4 s; a sample holds 2 s and a failed run pauses 0.4 s. Every time goes as 2 / Speed.\n// Knob 3: Beta. The inverse temperature, in units of the coupling. At the opening 0.32 the chains meet after 35 to 60 sweeps, so the run from -64 is the first that works and a sample comes 4.4 s in, fine grain with small islands; at 0.36 they need 80 to 130 sweeps and at 0.4 about 200 to 370; at 0.43, just short of the critical 0.4407, they need 1000 to 2100, a sample takes 17 to 43 s and is a few big domains. Turning it starts a fresh run.\n// Knob 4: Field. An outside field, up to the right, of 0.6 k|k| in units of the coupling: 0.002 at the opening 0.06, too weak to see at Beta 0.32, though at 0.43 it acts on all 3968 spins at once and most samples come out more up than down. At 1 or -1 nine spins in ten or more point its way and the chains meet in 13 to 22 sweeps at any Beta. Turning it starts a fresh run.\n\n// The Ising model on a 64 by 62 torus: each site a spin +1 or -1, and each\n// pair of neighbours adds -1 to the energy if they agree and +1 if they do\n// not, with -h for every spin up and +h for every spin down. The heat-bath\n// update visits a site, sums its four neighbours s, and sets it up with\n// probability 1 / (1 + exp(-2 beta (s + h))) whatever it was before. One\n// sweep visits every site once in a fixed order.\n//\n// Coupling from the past (Propp and Wilson, 1996): feed the same uniform\n// random number u(t, x) to every chain, so a sweep is one fixed map from\n// configurations to configurations. The update is monotone: a chain that\n// is up wherever another is up stays so after the sweep. So the chain\n// started all up at time -T stays above every other start, and the chain\n// started all down below it. If those two agree everywhere at time 0, every\n// start agrees with them, and the state at 0 is the end of a chain that has\n// run since minus infinity: an exact sample of the Gibbs distribution, not\n// an approximation. If they do not, start again from -2T. The random\n// numbers for -T..0 must be the same as last time, or the sample is biased,\n// so u is a hash of (run seed, t, x) and is never stored.\n//\n// The top half is the chain from all up, the bottom the chain from all\n// down, each 64 by 62. Where they disagree the top one is always up and the\n// bottom one down, by monotonicity, and those sites take the disagreement\n// colour. Between the halves, framed by a dark row on each side, two rows\n// are the timeline from -T at the left to 0 at the right: lit in the\n// disagreement colour while the chains differ and in the up colour once\n// they have met, with a dark notch where each earlier run started, at -T/2,\n// -T/4 and on. After a sample the same seed runs once more from twice as\n// far back. That check run lands on the same sample: its chains are held\n// between the first run's two from -T on, so they have met by the time the\n// first run's did, the gold notch, and from there they replay its last\n// stretch sweep for sweep. When it lands on the stored sample LED for LED,\n// the whole timeline turns gold while it holds. A run that fails with 48\n// sites or fewer still apart rings each of them while it pauses.\n\nconst W = 64, LH = 62, N = W * LH, BOT = 66, LINE = 63;\nconst { floor, round, exp, pow, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Seconds at Speed 2: the first run, the growth of a run's length with each\n// doubling, the hold on a sample and the pause on a run that failed.\nconst T0 = 8, D0 = 0.45, GROW = 0.45, HOLD = 2, FAIL = 0.4, TMAX = 1 \u003c\u003c 16;\n\n// Neighbours on the torus. A sweep visits the sites in index order.\nconst NB = new Int32Array(N * 4);\nfor (let y = 0; y \u003c LH; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const i = y * W + x;\n    NB[i * 4] = y * W + ((x + 1) % W);\n    NB[i * 4 + 1] = y * W + ((x + W - 1) % W);\n    NB[i * 4 + 2] = ((y + 1) % LH) * W + x;\n    NB[i * 4 + 3] = ((y + LH - 1) % LH) * W + x;\n  }\n\n// Murmur3's finaliser, a bijection on 32 bits.\nfunction mix(h) {\n  h ^= h >>> 16;\n  h = Math.imul(h, 0x85ebca6b);\n  h ^= h >>> 13;\n  h = Math.imul(h, 0xc2b2ae35);\n  return (h ^ (h >>> 16)) >>> 0;\n}\n// u(seed, t, x): a key for the sweep at time t, mixed with the site. The\n// same three numbers give the same u in every run that passes through t.\nconst keyOf = (seed, t) => mix(seed ^ Math.imul(t, 0x9e3779b1));\nconst uOf = (key, i) => mix(key ^ Math.imul(i + 1, 0x27d4eb2f));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i].map((c) => round(c * 255));\n}\n\n// A run of length T at Speed 2 lasts D0 (T / T0)^GROW seconds.\nconst span = (T) => D0 * pow(T / T0, GROW);\n\nfunction fresh(S) {\n  S.run++;\n  S.seed = mix(S.base + Math.imul(S.run, 0x632be5ab)) | 0;\n  S.T = T0;\n  S.check = false;\n  S.metFirst = null;\n  begin(S);\n}\n\n// Both chains to their extremes at time -T.\nfunction begin(S) {\n  S.up.fill(1);\n  S.dn.fill(-1);\n  S.t = -S.T;\n  S.dis = N;\n  S.met = null;\n  S.acc = 0;\n  S.phase = \"run\";\n  S.wait = 0;\n  S.same = false;\n}\n\n// One sweep from time t to t + 1 on both chains with the same u.\nfunction sweep(S) {\n  const a = S.up, b = S.dn, thr = S.thr, key = keyOf(S.seed, S.t), one = S.dis === 0;\n  for (let i = 0; i \u003c N; i++) {\n    const u = uOf(key, i), j = i * 4;\n    a[i] = u \u003c thr[a[NB[j]] + a[NB[j + 1]] + a[NB[j + 2]] + a[NB[j + 3]] + 4] ? 1 : -1;\n    if (!one) b[i] = u \u003c thr[b[NB[j]] + b[NB[j + 1]] + b[NB[j + 2]] + b[NB[j + 3]] + 4] ? 1 : -1;\n  }\n  S.t++;\n  if (one) b.set(a);\n  else {\n    let d = 0;\n    for (let i = 0; i \u003c N; i++) if (a[i] !== b[i]) d++;\n    S.dis = d;\n    if (!d) S.met = S.t;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    up: new Int8Array(N), dn: new Int8Array(N), thr: new Float64Array(9), sample: new Int8Array(N),\n    base: floor(Math.random() * 2147483647), run: 0, seed: 0, T: T0, t: -T0, dis: N, met: null, metFirst: null,\n    check: false, same: false, acc: 0, phase: \"run\", wait: 0, beta: -1, field: -9, hue: 0, speed: 2, flash: 0,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const beta = cl(k[2] || 0, 0.32, 0.43), k4 = cl(k[3] == null ? 0.06 : k[3], -1, 1), field = 0.6 * k4 * abs(k4);\n  if (abs(beta - S.beta) > 1e-4 || abs(field - S.field) > 1e-4) {\n    S.beta = beta;\n    S.field = field;\n    // Probability of up, as a 32-bit threshold, for each neighbour sum s.\n    for (let s = -4; s \u003c= 4; s++) S.thr[s + 4] = floor(4294967296 / (1 + exp(-2 * beta * (s + field))));\n    fresh(S);\n  }\n  const rate = S.speed / 2;\n  S.flash = max(0, S.flash - d * 2.5 * rate);\n  if (S.phase !== \"run\") {\n    S.wait -= d * rate;\n    if (S.wait > 0) return;\n    if (S.phase === \"fail\") {\n      S.T = min(TMAX, S.T * 2);\n      begin(S);\n    } else if (!S.check) {\n      // The same seed from twice as far back: the check run.\n      const met = S.met;\n      S.T *= 2;\n      begin(S);\n      S.check = true;\n      S.metFirst = met;\n    } else fresh(S);\n    return;\n  }\n  // Sweeps owed this frame; a long run gets more of them each second.\n  S.acc += (d * rate * S.T) / span(S.T);\n  let n = floor(S.acc);\n  S.acc -= n;\n  // Past 24 sweeps a frame the run would cost more than 2 ms a frame.\n  n = min(n, 24, -S.t);\n  for (let i = 0; i \u003c n; i++) sweep(S);\n  if (S.t >= 0) {\n    if (S.dis === 0) {\n      S.phase = \"hold\";\n      S.wait = HOLD;\n      S.flash = 1;\n      if (S.check) {\n        let same = true;\n        for (let i = 0; i \u003c N; i++) if (S.sample[i] !== S.up[i]) same = false;\n        S.same = same;\n      } else S.sample.set(S.up);\n    } else {\n      S.phase = \"fail\";\n      S.wait = FAIL;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // Up is a pale tint of the hue. Down stays in the deep cool arc from teal\n  // to violet as the hue goes round, since a deep orange or yellow reads\n  // brown on the panel; the disagreement takes the hue's far side.\n  const h = S.hue + 0.55;\n  const UP = hsv(h, 0.3, 0.88), DN = hsv(0.675 + 0.175 * Math.sin(2 * Math.PI * S.hue), 0.85, 0.45);\n  const XT = hsv(h + 0.37, 0.65, 1), XB = hsv(h + 0.37, 0.95, 0.8);\n  const a = S.up, b = S.dn, f = S.flash * 0.3;\n  const lift = (c) => [round(c[0] + (255 - c[0]) * f), round(c[1] + (255 - c[1]) * f), round(c[2] + (255 - c[2]) * f)];\n  const U = lift(UP), D = lift(DN);\n  for (let y = 0; y \u003c LH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, sa = a[i];\n      if (sa !== b[i]) {\n        display.setPixel(x, y, XT[0], XT[1], XT[2]);\n        display.setPixel(x, y + BOT, XB[0], XB[1], XB[2]);\n      } else {\n        const c = sa > 0 ? U : D;\n        display.setPixel(x, y, c[0], c[1], c[2]);\n        display.setPixel(x, y + BOT, c[0], c[1], c[2]);\n      }\n    }\n\n  // The rings round the sites a failed run left apart, pulsing twice.\n  if (S.phase === \"fail\" && S.dis \u003c= 48) {\n    const v = 0.5 + 0.5 * Math.cos((1 - S.wait / FAIL) * 4 * Math.PI);\n    for (let i = 0; i \u003c N; i++) {\n      if (a[i] === b[i]) continue;\n      const x0 = i % W, y0 = floor(i / W);\n      for (let k = -2; k \u003c= 2; k++)\n        for (const [dx, dy] of [[k, -2], [k, 2], [-2, k], [2, k]]) {\n          const x = (x0 + dx + W) % W, y = (y0 + dy + LH) % LH, j = y * W + x;\n          const ct = a[j] !== b[j] ? XT : a[j] > 0 ? U : D, cb = a[j] !== b[j] ? XB : a[j] > 0 ? U : D;\n          display.setPixel(x, y, round(ct[0] + (255 - ct[0]) * v), round(ct[1] + (255 - ct[1]) * v), round(ct[2] + (255 - ct[2]) * v));\n          display.setPixel(x, y + BOT, round(cb[0] + (255 - cb[0]) * v), round(cb[1] + (255 - cb[1]) * v), round(cb[2] + (255 - cb[2]) * v));\n        }\n    }\n  }\n\n  // The timeline, -T at the left edge and 0 at the right, between two dark\n  // rows. The x of time t is W (1 + t / T).\n  const T = S.T, X = (t) => min(W - 1, floor(W * (1 + t / T)));\n  const ahead = hsv(h, 0.45, 0.17), gold = hsv(h + 0.6, 0.75, 1), notch = [0, 0, 0];\n  const now = S.phase === \"run\" ? X(S.t) : W;\n  const met = S.met === null ? W : X(S.met);\n  for (let x = 0; x \u003c W; x++) {\n    let c = x >= now ? ahead : x \u003c met ? XB : UP;\n    if (S.same && S.phase === \"hold\") c = gold;\n    // Earlier runs started at -T/2, -T/4, ... down to -T0.\n    for (let q = T / 2; q >= T0; q /= 2) if (x === X(-q)) c = notch;\n    if (S.metFirst !== null && x === X(S.metFirst)) c = gold;\n    if (x === now) c = [255, 255, 255];\n    display.setPixel(x, LINE - 1, 0, 0, 0);\n    display.setPixel(x, LINE, c[0], c[1], c[2]);\n    display.setPixel(x, LINE + 1, c[0], c[1], c[2]);\n    display.setPixel(x, LINE + 2, 0, 0, 0);\n  }\n}\n","doyle-spiral":"// ===== Patternflow pattern =====\n// Title:   Doyle Spiral\n// Family:  cells\n// Idea:    A Doyle spiral, a packing of discs in which every disc touches six others and each is its neighbour turned and scaled by one of two fixed complex numbers, streams out of a dark pole in the middle of the tall panel and past its edges, every disc coloured by which of its 5 to 10 spiral arms it sits on, so the arms turn round the pole while the discs grow.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Doyle spirals, named for Peter Doyle (Alan F. Beardon, Tomasz Dubejko and Kenneth Stephenson, Spiral hexagonal circle packings in the plane, 1994); H. S. M. Coxeter's loxodromic sequences of tangent spheres (1968), whose plane case is the (2, 3) spiral; pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Arms=5..10, Poles=0..1\n//\n// Knob 1: Hue. Turns the arm colours round the wheel together. At 0 the five arms of the opening spiral are azure, violet, rose, gold and green, a fifth of the wheel apart; each disc is pale in the middle, fully coloured at its rim and lit from the side that faces the pole.\n// Knob 2: Speed. At 2 every disc takes 4.2 s to move out into the place of its neighbour along one family of arms, 1.41 times as far from the pole and 25 degrees further clockwise in the opening spiral, so the packing is the same again and only the colours have stepped on by one arm. 42 s at 0.2, 2.8 s at 3.\n// Knob 3: Arms. How many coloured arms, q - p of the pair (p, q): 5 is (8, 13), 6 (11, 17), 7 (12, 19), 8 (13, 21), 9 (14, 23), 10 (17, 27). The more arms, the smaller the discs: a disc 60 LEDs from the pole has a radius of 16.4 LEDs at 5 and 7.9 at 10, and between 4 and 6 LEDs from the pole 32% of the LEDs are lit at 5 and 4% at 10. Neighbouring arms are 1/5 of the wheel apart at 5, then 2/6, 2/7, 2/8, 2/9 and 3/10, so they stay apart.\n// Knob 4: Poles. A Moebius map brings the spiral's second pole, at infinity at 0, in from below. At the opening 0.06 it is 1006 rows under the first, which sits at row 62 and bends the packing only slightly; from 0.59 the second pole is on the panel, and at 1 the two stand at rows 34 and 94, the discs coming out of the upper one and spiralling into the lower.\n\n// Put the pole at 0 in the complex plane. A Doyle spiral has a disc\n// centred on A^m B^n for every pair of integers m, n, with radius r times\n// the distance of its centre from 0. Multiplying by A or by B maps the\n// packing onto itself, so if the disc at 1 touches the discs at A and B\n// and those two touch each other,\n//\n//   |1 - A| = r (1 + |A|),  |1 - B| = r (1 + |B|),  |A - B| = r (|A| + |B|),\n//\n// then every disc touches six: those at z A, z B, z B/A and back. The\n// packing closes on itself in the plane when A^p = B^q, and then the discs\n// lie on q arms one way, p arms the other and q - p arms the third. Write\n// A = a e^(it) and B = a^(p/q) e^(i(pt + 2 pi)/q), which makes A^p = B^q,\n// take r from the first equation and solve the other two for a and t with\n// Newton, the way Robin Houston's doyle-spiral code does. Newton starts\n// from the hexagonal lattice that log A and log B would make if the discs\n// were all one size.\n//\n// In log z every disc is the same shape, the log of the disc of radius r\n// round 1, moved to m log A + n log B. So one table over a single cell of\n// that lattice tells every LED which disc it is in and where in it. Disc\n// (m, n) and disc (m + p, n - q) are the same disc, and the arm a disc sits\n// on among the q - p is (m + n) mod (q - p). Moving every disc out by one\n// step of B is the packing again, so the motion runs on without a seam.\n//\n// The edges stay hard: every LED within 0.55 LED of a rim is off, so two\n// discs never light neighbouring LEDs, and inside a disc the brightest\n// channel changes by under 6 of 255 an LED, 7 only where rounding meets.\n// Hue and saturation change from LED to LED as much as they like, which is\n// what keeps the frame from packing small.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, atan2, log, exp, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// (p, q) for 5 to 10 coloured arms.\nconst PAIRS = [[8, 13], [11, 17], [12, 19], [13, 21], [14, 23], [17, 27]];\n// The table over one lattice cell is L by L.\nconst L = 192;\n// LEDs kept dark inside every rim.\nconst RIM = 0.55;\n\n// The two tangencies besides the first, as differences of r, and r.\nfunction tangency(a, t, p, q) {\n  const b = pow(a, p / q), s = (p * t + TAU) / q;\n  const ax = a * cos(t), ay = a * sin(t), bx = b * cos(s), by = b * sin(s);\n  const r = sqrt((1 - ax) ** 2 + ay * ay) / (1 + a);\n  return [sqrt((1 - bx) ** 2 + by * by) / (1 + b) - r, sqrt((ax - bx) ** 2 + (ay - by) ** 2) / (a + b) - r, r];\n}\n\nfunction solve(p, q) {\n  // log A has length 2 pi / |q e^(i pi/3) - p| in the lattice of equal discs.\n  const len = TAU / sqrt(p * p - p * q + q * q);\n  const th = PI / 2 - atan2(q * sin(PI / 3), q * cos(PI / 3) - p);\n  let a = exp(len * cos(th)), t = len * sin(th);\n  for (let it = 0; it \u003c 40; it++) {\n    const f = tangency(a, t, p, q), h = 1e-7, fa = tangency(a + h, t, p, q), ft = tangency(a, t + h, p, q);\n    const j00 = (fa[0] - f[0]) / h, j01 = (ft[0] - f[0]) / h, j10 = (fa[1] - f[1]) / h, j11 = (ft[1] - f[1]) / h;\n    const det = j00 * j11 - j01 * j10, da = (j11 * f[0] - j01 * f[1]) / det, dt = (j00 * f[1] - j10 * f[0]) / det;\n    a -= da;\n    t -= dt;\n    if (da * da + dt * dt \u003c 1e-26) break;\n  }\n  // log A = ur + i ui, log B = vr + i vi.\n  return { p, q, ur: log(a), ui: t, vr: (log(a) * p) / q, vi: (p * t + TAU) / q, r: tangency(a, t, p, q)[2], code: null };\n}\n\n// For each point (al, be) of the cell, al log A + be log B in log z: which\n// corner's disc it is in (0..15 for m, n offsets -1..2), how far out in\n// that disc as a share of its radius, the disc's distance from the pole\n// over the point's, and the direction from the disc's centre, measured\n// from the line out of the pole.\nfunction build(P) {\n  const n = L * L;\n  P.code = new Uint8Array(n);\n  P.s = new Float32Array(n);\n  P.e = new Float32Array(n);\n  P.cs = new Float32Array(n);\n  P.sn = new Float32Array(n);\n  for (let j = 0; j \u003c L; j++)\n    for (let i = 0; i \u003c L; i++) {\n      const al = (i + 0.5) / L, be = (j + 0.5) / L, k = j * L + i;\n      let best = 1e9;\n      for (let dn = -1; dn \u003c= 2; dn++)\n        for (let dm = -1; dm \u003c= 2; dm++) {\n          const dr = (al - dm) * P.ur + (be - dn) * P.vr, di = (al - dm) * P.ui + (be - dn) * P.vi;\n          if (dr \u003c -2 || dr > 2) continue;\n          // z over the disc's centre is e^(dr + i di); the disc is |that - 1| \u003c r.\n          const ex = exp(dr), x = ex * cos(di) - 1, y = ex * sin(di), h = sqrt(x * x + y * y) || 1e-9, s = h / P.r;\n          if (s >= best) continue;\n          best = s;\n          P.code[k] = (dn + 1) * 4 + dm + 1;\n          P.e[k] = 1 / ex;\n          P.cs[k] = x / h;\n          P.sn[k] = y / h;\n        }\n      P.s[k] = best;\n    }\n}\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    pairs: PAIRS.map(([p, q]) => solve(p, q)), pi: -1, kappa: -1,\n    fa: new Int32Array(N), col: new Int32Array(N), B0: new Float32Array(N), G: new Float32Array(N),\n    tb: 0, on: 0, hue: 0, out: new Float32Array(N * 3),\n  };\n}\n\n// Per LED: where it falls in the lattice, and how many LEDs one unit of\n// relative distance is there. With poles P1 and P2 the map is\n// z = (w - P1)(P2 - P1) / (P2 - w), which is w - P1 when P2 is at infinity.\nfunction tables(S, P, kappa) {\n  const px = 32, p1 = 64 - 30 * kappa, p2 = kappa \u003c 1e-4 ? 0 : 64 + 30 * kappa + (64 * (1 - kappa)) / kappa;\n  const det = P.ur * P.vi - P.ui * P.vr;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, wx = x + 0.5 - px, wy = y + 0.5 - p1, d1 = sqrt(wx * wx + wy * wy) + 1e-6;\n      let lr = log(d1), th = atan2(wy, wx), g = d1;\n      if (kappa >= 1e-4) {\n        const ex = px - x - 0.5, ey = p2 - y - 0.5, d2 = sqrt(ex * ex + ey * ey) + 1e-6, D = p2 - p1;\n        lr += log(D / d2);\n        th += PI / 2 - atan2(ey, ex);\n        g = (d1 * d2) / D;\n      }\n      const a = (lr * P.vi - th * P.vr) / det, fa = floor(a);\n      S.fa[i] = fa;\n      S.col[i] = min(L - 1, floor((a - fa) * L));\n      S.B0[i] = (P.ur * th - P.ui * lr) / det;\n      S.G[i] = g;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const pi = round(cl(k[2] == null ? 5 : k[2], 5, 10)) - 5, kappa = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const P = S.pairs[pi];\n  if (!P.code) build(P);\n  if (pi !== S.pi || kappa !== S.kappa) {\n    S.pi = pi;\n    S.kappa = kappa;\n    tables(S, P, kappa);\n  }\n  // One step of B every 4.2 s at Speed 2. A whole step is the same\n  // packing with every disc one further along, so the count moves instead.\n  S.tb += d * speed * 0.12;\n  while (S.tb >= 1) {\n    S.tb -= 1;\n    S.on -= 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.pi \u003c 0) return;\n  const P = S.pairs[S.pi], out = S.out, arms = P.q - P.p, r = P.r;\n  // Neighbouring arms are this many steps of 1/arms apart on the wheel.\n  const stride = max(1, round(arms / 4)) / arms;\n  out.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const b = S.B0[i] - S.tb, fb = floor(b), li = min(L - 1, floor((b - fb) * L)) * L + S.col[i], s = P.s[li];\n    if (s >= 1) continue;\n    // The disc's radius in LEDs, and how far this LED is inside its rim.\n    const R = S.G[i] * P.e[li] * r, dd = R * (1 - s);\n    if (dd \u003c RIM) continue;\n    const c = P.code[li], m = S.fa[i] + (c & 3) - 1, n = fb + (c >> 2) - 1 + S.on;\n    const arm = (((m + n) % arms) + arms) % arms;\n    const lean = cl(R * s * P.cs[li], -12, 12);\n    const v = 0.9 - 0.017 * (7 - min(dd, 7)) - 0.006 * lean;\n    hsv(S.hue + 0.55 + arm * stride + 0.04 * s * P.sn[li], 0.35 + 0.6 * s, v, out, i * 3);\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(out[i * 3] * 255), round(out[i * 3 + 1] * 255), round(out[i * 3 + 2] * 255));\n}\n","kinematogram":"// ===== Patternflow pattern =====\n// Title:   Kinematogram\n// Family:  type\n// Idea:    The whole tall panel is random dots at one even density, and a word of large capitals stacked down it exists only as motion: the dots inside the letters drift up while the dots around them drift down, so any single frame is plain noise, and every few seconds the dots stop for a moment and the word is gone until they move again.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random-dot kinematogram, a region of random dots displaced against its surround (Oliver Braddick, A short-range process in apparent motion, Vision Research, 1974), with motion coherence, the share of dots that carry the signal (William Newsome and Edmond Paré, 1988); capitals drawn for this pattern, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Coherence=0..1\n//\n// Knob 1: Hue. Turns the three dot colours round the wheel together. At 0 they are pale teal, azure and pale gold; at 0.5 rose, amber and pale blue.\n// Knob 2: Speed. At 2 the dots drift 10 LEDs a second, live 1.2 s on average, and the motion runs 3.6 s and stops for 1 s; every time goes as 2 / Speed.\n// Knob 3: Word. 0 SEE, 1 MOVE, 2 NOW, 3 GO, 4 HIDE, 5 STOP, 6 LOOK, 7 FLY, stacked one letter above the next down the 128 rows: 56 rows a letter for GO, 37 for three letters and 28 for four.\n// Knob 4: Coherence. The share of dots that drift with their sheet; the rest each go their own way at the same speed. The share is the knob to the power 0.25: half at the opening 0.06, where the word still reads, 84% at 0.5, all at 1, and none at 0, where nothing tells the letters from the ground and the word is gone even while the dots move.\n\n// Braddick showed his observers two frames of random dots in which one\n// region of the second frame was the first frame's dots moved a little.\n// Each frame alone is noise; shown one after the other, the moved region\n// stands out as a shape. Here that runs on: two sheets of dots, each\n// covering the whole panel at the same density and wrapping round its\n// edges, one drifting up and one drifting down. The panel shows the up sheet\n// inside the letters and the down sheet everywhere else. A dot that drifts\n// out of a letter is no longer shown, and the up sheet's dots that were\n// hidden below the letter come in at its lower edge, so the density inside\n// and outside stays the same in every frame.\n//\n// Every dot lives a while and is born again at a random place, so no dot's\n// path runs long enough to trace a letter's outline in a still. Coherence\n// is the share of dots that drift with their sheet; each of the others\n// drifts at the same speed in a direction of its own. Which dots are which\n// is drawn once at birth, so the knob changes where the dots go but never\n// how many there are.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, cos, sin, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Dots in each sheet, drift in LEDs per second at Speed 2, mean life,\n// and the run and the stop of the motion, in seconds at Speed 2.\nconst DOTS = 1900, V = 10, LIFE = 1.2, RUN = 3.6, STOP = 1;\n\nconst WORDS = [\"SEE\", \"MOVE\", \"NOW\", \"GO\", \"HIDE\", \"STOP\", \"LOOK\", \"FLY\"];\n\n// Capitals as polylines on a grid 4 wide and 6 tall, y down.\nconst STROKES = {\n  S: \"4,1 3,0 1,0 0,1 0,2 1,3 3,3 4,4 4,5 3,6 1,6 0,5\",\n  E: \"4,0 0,0 0,6 4,6|0,3 3,3\",\n  M: \"0,6 0,0 2,3 4,0 4,6\",\n  O: \"1,0 3,0 4,1 4,5 3,6 1,6 0,5 0,1 1,0\",\n  V: \"0,0 2,6 4,0\",\n  N: \"0,6 0,0 4,6 4,0\",\n  W: \"0,0 1,6 2,2 3,6 4,0\",\n  G: \"4,1 3,0 1,0 0,1 0,5 1,6 3,6 4,5 4,3 2,3\",\n  H: \"0,0 0,6|4,0 4,6|0,3 4,3\",\n  I: \"2,0 2,6|1,0 3,0|1,6 3,6\",\n  D: \"0,0 0,6 2.4,6 4,4.4 4,1.6 2.4,0 0,0\",\n  T: \"0,0 4,0|2,0 2,6\",\n  P: \"0,6 0,0 3,0 4,1 4,2 3,3 0,3\",\n  L: \"0,0 0,6 4,6\",\n  K: \"0,0 0,6|4,0 0,4|1.5,3 4,6\",\n  F: \"4,0 0,0 0,6|0,3 3,3\",\n  Y: \"0,0 2,3 4,0|2,3 2,6\",\n};\n\n// The letters of a word as a mask over the panel, 1 inside a stroke.\nfunction maskOf(word, out) {\n  out.fill(0);\n  const n = word.length, ch = H / n;\n  const gap = n \u003c= 2 ? 8 : n === 3 ? 6 : 4, lh = ch - gap, lw = n \u003c= 2 ? 50 : 54, T = n \u003c= 2 ? 11 : n === 3 ? 9 : 7;\n  for (let k = 0; k \u003c n; k++) {\n    const x0 = (W - lw) / 2 + T / 2, y0 = k * ch + gap / 2 + T / 2, ux = (lw - T) / 4, uy = (lh - T) / 6;\n    const segs = [];\n    for (const line of STROKES[word[k]].split(\"|\")) {\n      const p = line.split(\" \").map((t) => t.split(\",\").map(Number)).map(([gx, gy]) => [x0 + gx * ux, y0 + gy * uy]);\n      for (let i = 1; i \u003c p.length; i++) segs.push([p[i - 1][0], p[i - 1][1], p[i][0], p[i][1]]);\n    }\n    const r2 = (T / 2) * (T / 2);\n    for (let y = max(0, floor(k * ch)); y \u003c min(H, floor((k + 1) * ch) + 1); y++)\n      for (let x = 0; x \u003c W; x++) {\n        const px = x + 0.5, py = y + 0.5;\n        for (const s of segs) {\n          const dx = s[2] - s[0], dy = s[3] - s[1], L2 = dx * dx + dy * dy || 1e-9;\n          const t = cl(((px - s[0]) * dx + (py - s[1]) * dy) / L2, 0, 1), ex = px - s[0] - t * dx, ey = py - s[1] - t * dy;\n          if (ex * ex + ey * ey \u003c= r2) {\n            out[y * W + x] = 1;\n            break;\n          }\n        }\n      }\n  }\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nfunction sheet() {\n  const s = {\n    x: new Float32Array(DOTS), y: new Float32Array(DOTS), age: new Float32Array(DOTS), life: new Float32Array(DOTS),\n    u: new Float32Array(DOTS), dx: new Float32Array(DOTS), dy: new Float32Array(DOTS), c: new Uint8Array(DOTS),\n  };\n  for (let i = 0; i \u003c DOTS; i++) {\n    born(s, i);\n    s.age[i] = Math.random() * s.life[i];\n  }\n  return s;\n}\n\nfunction born(s, i) {\n  s.x[i] = Math.random() * W;\n  s.y[i] = Math.random() * H;\n  s.age[i] = 0;\n  s.life[i] = LIFE * (0.4 + 1.2 * Math.random());\n  s.u[i] = Math.random();\n  const a = Math.random() * TAU;\n  s.dx[i] = cos(a);\n  s.dy[i] = sin(a);\n  s.c[i] = floor(Math.random() * 3);\n}\n\n// Move a sheet on by d seconds at Speed 2, its signal going (vx, vy).\nfunction drift(s, d, vx, vy, share) {\n  for (let i = 0; i \u003c DOTS; i++) {\n    if (s.age[i] >= s.life[i]) born(s, i);\n    let x = s.x[i], y = s.y[i];\n    if (s.u[i] \u003c share) {\n      x += vx * d;\n      y += vy * d;\n    } else {\n      x += s.dx[i] * V * d;\n      y += s.dy[i] * V * d;\n    }\n    s.x[i] = x - floor(x / W) * W;\n    s.y[i] = y - floor(y / H) * H;\n    s.age[i] += d;\n  }\n}\n\nexport function setup(params) {\n  params.s = { up: sheet(), down: sheet(), mask: new Uint8Array(N), ink: new Uint8Array(N), word: -1, clock: 0, share: 0.5, hue: 0 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const w = round(cl(k[2] || 0, 0, 7));\n  if (w !== S.word) {\n    S.word = w;\n    maskOf(WORDS[w], S.mask);\n  }\n  S.share = pow(cl(k[3] == null ? 0.06 : k[3], 0, 1), 0.25);\n  const step = (d * speed) / 2;\n  // The motion runs, then stops dead: nothing moves and nothing ages.\n  const was = S.clock % (RUN + STOP);\n  S.clock = (S.clock + step) % ((RUN + STOP) * 1000);\n  const run = min(step, max(0, RUN - was));\n  if (run > 0) {\n    drift(S.up, run, 0, -V, S.share);\n    drift(S.down, run, 0, V, S.share);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const ink = S.ink, mask = S.mask;\n  ink.fill(0);\n  // The down sheet shows outside the letters, the up sheet inside them.\n  for (const [s, inside] of [[S.down, 0], [S.up, 1]]) {\n    for (let i = 0; i \u003c DOTS; i++) {\n      const p = (floor(s.y[i]) % H) * W + (floor(s.x[i]) % W);\n      if (mask[p] === inside) ink[p] = s.c[i] + 1;\n    }\n  }\n  const pal = [[0, 0, 0], hsv(S.hue + 0.47, 0.5, 0.8), hsv(S.hue + 0.6, 0.6, 0.82), hsv(S.hue + 0.13, 0.4, 0.82)].map((c) => c.map((v) => round(v * 255)));\n  for (let i = 0; i \u003c N; i++) {\n    const c = pal[ink[i]];\n    display.setPixel(i % W, floor(i / W), c[0], c[1], c[2]);\n  }\n}\n","linotype":"// ===== Patternflow pattern =====\n// Title:   Linotype\n// Family:  type\n// Idea:    Brass matrices drop one at a time from a magazine of channels and ride a belt into the assembler, where the line builds up with a steel spaceband in every word space; the spacebands are driven up until the line fills the measure, metal is pumped against it, and the slug, its face the line in mirror image, drops onto a galley of earlier slugs while the matrices are lifted to the distributor bar and slide along it until each falls back into its own channel.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Linotype line-casting machine (Ottmar Mergenthaler, 1886), its magazine, assembler, spacebands, mould and distributor bar; the first verse of the Gospel of John in the King James Version (1611) and the Gettysburg Address (Abraham Lincoln, 1863); capitals drawn for this pattern, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Measure=0..1\n//\n// Knob 1: Hue. Turns the brass of the matrices and the magazine and the steel of the frame, the spacebands and the slugs round the wheel together. At 0 the matrices are gold and the steel blue-grey, at 0.25 green and mauve, at 0.5 blue and a warm grey, at 0.75 pink and green-grey. The molten metal stays a warm white.\n// Knob 2: Speed. At 2 a matrix reaches the assembler every 0.13 s, the next line's matrices already falling while the last one is justified, and a line of 13 goes from its first matrix to the mould in 2.6 s; the lift, 1 s, and the distributor run alongside the next line. Every time goes as 2 / Speed, ten times slower at 0.2 and one and a half times faster at 3.\n// Knob 3: Text. 0 the first verse of John, which at the opening measure justifies every line with word spaces of 5 to 10 LEDs; 1 the pangram pack my box with five dozen liquor jugs, whose first line comes in at 59 LEDs and barely needs its spacebands; 2 ETAOIN SHRDLU CMFWYP VBGKQJ, the first four columns of the keyboard's lowercase keys, which operators ran a finger down to fill out a line they meant to throw away, and which draws only on the 24 channels at the left; 3 the Gettysburg Address to all men are created equal. Turning it starts the machine over on the new text, the galley already holding slugs of its opening lines.\n// Knob 4: Measure. The width of the line and of the slug: 60 LEDs, 15 matrices of 4, up to 0.16, then 56, 52 to 0.83 and 48. At 48 the Gettysburg Address sets BROUGHT on a line of its own, which has no word space for a spaceband and is quadded left, and ETAOIN SHRDLU comes apart into four lines of one word.\n\n// The machine is drawn standing, top to bottom: the distributor bar with\n// its box at the right, the magazine of 29 channels, the belt, the\n// assembler with the spaceband box at its right end, the mould, and the\n// galley. Pressing a key lets one matrix out of the foot of its channel. It\n// falls onto the belt, rides it down to its end above the assembler and\n// drops in at the right, so the line grows to the left. A spaceband\n// is a long double wedge, thin at the top; when the line is full the\n// spacebands are driven up, their thick feet come into the line, and every\n// word space opens by the same amount until the line fills the measure.\n// The line drops to the mould, metal fills the mould behind it from left to\n// right, and the slug that comes out carries the whole line in relief. Its\n// face reads in mirror image, as type does: that is what the galley shows,\n// newest at the top, each slug pushing the earlier ones down. The\n// spacebands go back to their box; the matrices are lifted to the top,\n// passing behind the machine, fed one at a time from the right end of the\n// line onto the distributor bar, and slide left along it until they come\n// over their own channel and fall in. On the real bar a matrix falls where\n// the teeth in its V notch stop finding ribs to hang on; here it simply\n// falls at its channel.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Capitals 5 rows tall, drawn for this pattern; M and W are 5 wide, N 4.\nconst FONT = {\n  A: \".#.|#.#|###|#.#|#.#\", B: \"##.|#.#|##.|#.#|##.\", C: \".##|#..|#..|#..|.##\", D: \"##.|#.#|#.#|#.#|##.\",\n  E: \"###|#..|##.|#..|###\", F: \"###|#..|##.|#..|#..\", G: \".##|#..|#.#|#.#|.##\", H: \"#.#|#.#|###|#.#|#.#\",\n  I: \"###|.#.|.#.|.#.|###\", J: \"..#|..#|..#|#.#|.#.\", K: \"#.#|#.#|##.|#.#|#.#\", L: \"#..|#..|#..|#..|###\",\n  M: \"#...#|##.##|#.#.#|#...#|#...#\", N: \"#..#|##.#|#.##|#..#|#..#\", O: \".#.|#.#|#.#|#.#|.#.\",\n  P: \"##.|#.#|##.|#..|#..\", Q: \".#.|#.#|#.#|##.|.##\", R: \"##.|#.#|##.|#.#|#.#\", S: \".##|#..|.#.|..#|##.\",\n  T: \"###|.#.|.#.|.#.|.#.\", U: \"#.#|#.#|#.#|#.#|###\", V: \"#.#|#.#|#.#|#.#|.#.\", W: \"#...#|#...#|#.#.#|##.##|#...#\",\n  X: \"#.#|#.#|.#.|#.#|#.#\", Y: \"#.#|#.#|.#.|.#.|.#.\", Z: \"###|..#|.#.|#..|###\",\n  \".\": \".|.|.|.|#\", \",\": \"..|..|..|.#|#.\", \"-\": \"...|...|###|...|...\",\n};\nconst GL = {};\nfor (const c in FONT) {\n  const rows = FONT[c].split(\"|\");\n  GL[c] = { w: rows[0].length, px: rows.map((r) => [...r].map((q) => q === \"#\")) };\n}\n\n// The magazine's channels, left to right, in the order of the Linotype\n// keyboard's lowercase keys, etaoin shrdlu cmfwyp vbgkqj, then x and z, the\n// full point, the comma and the hyphen. Each starts with more matrices the\n// more often its letter comes in English, 18 for E down to 3 for Q, J, X and\n// Z, one LED of the channel for each.\nconst ORDER = \"ETAOINSHRDLUCMFWYPVBGKQJXZ.,-\";\nconst BASE = [18, 14, 13, 12, 11, 11, 10, 10, 10, 8, 8, 6, 6, 6, 6, 6, 5, 5, 4, 5, 5, 4, 3, 3, 3, 3, 6, 6, 5];\nconst CI = {};\nfor (let i = 0; i \u003c ORDER.length; i++) CI[ORDER[i]] = i;\nconst chX = (i) => 2 * i + 1;\n\n// Texts, with | where a word may be broken by a hyphen.\nconst TEXTS = [\n  \"IN THE BE|GIN|NING WAS THE WORD, AND THE WORD WAS WITH GOD, AND THE WORD WAS GOD.\",\n  \"PACK MY BOX WITH FIVE DOZ|EN LIQ|UOR JUGS.\",\n  \"ETAOIN SHRDLU CMFWYP VBGKQJ\",\n  \"FOUR SCORE AND SEV|EN YEARS AGO OUR FA|THERS BROUGHT FORTH ON THIS CON|TI|NENT, A NEW NA|TION, CON|CEIVED IN LIB|ER|TY, AND DED|I|CAT|ED TO THE PROP|O|SI|TION THAT ALL MEN ARE CRE|AT|ED E|QUAL.\",\n];\n\n// Geometry, rows from the top.\nconst BOXX = 59, BAR = 9, HANG = 10, MAG0 = 18, MAG1 = 35, ESC = 36;\nconst ENT = 61, LINE = 63, RAIL = 70, MOULD = 76, CAV = 83, GAL = 93, SLUG = 7;\nconst SLOPE = 0.22, GMIN = 1, RISE = 3, LIP = 8;\n// Machine seconds at Speed 2.\nconst DT = 0.13, G = 400, VB = 90, TSB = 0.2, TJ = 0.6, TD = 0.35, TP = 0.3, TH = 0.35, TL = 1.0;\nconst VF = 45, VBAR = 80, TCH = 0.12, TE = 0.3, COOL = 1.5, TAU = 0.05;\nconst MOLTEN = [1, 0.92, 0.62], HOT_B = [0.78, 0.72, 0.6], HOT_S = [0.5, 0.45, 0.38], HOT_F = [1, 0.97, 0.86];\n\nconst wOf = (s) => {\n  let w = 0;\n  for (const c of s) if (GL[c]) w += GL[c].w + 1;\n  return w;\n};\n\n// Line breaking over the whole text at once: a line may end at a word space\n// or at a | with a hyphen, and the breaks are the ones whose word spaces\n// come out nearest 5 LEDs, a hyphen costing as much as a space 4.5 LEDs off.\n// The last line costs nothing, and is quadded when the text ends a sentence.\nfunction breakLines(text, M) {\n  const fr = [];\n  for (const word of text.split(\" \")) {\n    const parts = word.split(\"|\");\n    parts.forEach((p, j) => fr.push({ s: p, end: j === parts.length - 1 }));\n  }\n  const n = fr.length, best = new Array(n + 1).fill(Infinity), from = new Array(n + 1).fill(-1);\n  best[0] = 0;\n  for (let a = 0; a \u003c n; a++) {\n    if (best[a] === Infinity) continue;\n    let w = 0, gaps = 0;\n    for (let b = a + 1; b \u003c= n; b++) {\n      const f = fr[b - 1];\n      w += wOf(f.s);\n      if (b - 1 > a && fr[b - 2].end) gaps++;\n      const hy = !f.end, width = w + gaps * GMIN + (hy ? wOf(\"-\") : 0);\n      if (width > M && b > a + 1) break;\n      let cost;\n      if (b === n) cost = 0;\n      else if (gaps === 0) cost = 4 * (M - width) * (M - width) + 400;\n      else {\n        const g = (M - width + gaps * GMIN) / gaps - 5;\n        cost = gaps * g * g + (hy ? 20 : 0);\n      }\n      if (best[a] + cost \u003c best[b]) {\n        best[b] = best[a] + cost;\n        from[b] = a;\n      }\n    }\n  }\n  const cuts = [];\n  for (let b = n; b > 0; b = from[b]) cuts.unshift([from[b], b]);\n  return cuts.map(([a, b], k) => {\n    const words = [];\n    let cur = \"\";\n    for (let i = a; i \u003c b; i++) {\n      cur += fr[i].s;\n      if (fr[i].end) {\n        words.push(cur);\n        cur = \"\";\n      }\n    }\n    if (cur) words.push(cur + \"-\");\n    return setLine(words, M, k === cuts.length - 1 && /\\.$/.test(text));\n  });\n}\n\n// A line's matrices and spacebands, and where each stands once the line is\n// justified to the measure: the spare width shared out between the word\n// spaces as evenly as whole LEDs allow. A line left unjustified, the last\n// of a sentence or a line of one word, is quadded left.\nfunction setLine(words, M, last) {\n  const items = [];\n  words.forEach((wd, k) => {\n    if (k) items.push({ sp: true, w: GMIN });\n    for (const c of wd) if (GL[c]) items.push({ ch: c, ci: CI[c], w: GL[c].w + 1 });\n  });\n  const gaps = words.length - 1, letters = items.reduce((s, it) => s + (it.sp ? 0 : it.w), 0);\n  const just = !last && gaps > 0, spare = M - letters;\n  let x = ENT - M, g = 0;\n  for (const it of items) {\n    it.fx = x;\n    if (it.sp) {\n      it.fw = just ? floor(((g + 1) * spare) / gaps) - floor((g * spare) / gaps) : GMIN;\n      g++;\n    } else it.fw = it.w;\n    x += it.fw;\n  }\n  return { items, just };\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The schedule of one line through the machine, all in absolute machine\n// time from its first matrix reaching the assembler at `start`.\nfunction schedule(S, n, start) {\n  const src = S.lines[n % S.lines.length];\n  const items = src.items.map((it, k) => {\n    const m = { ...it, a: start + k * DT };\n    if (it.sp) m.r = m.a - TSB;\n    else {\n      m.x0 = cl(chX(it.ci) - floor(it.w / 2), 0, ENT - it.w);\n      const yb = LINE - LIP - SLOPE * (ENT - it.w - m.x0);\n      m.tf = sqrt((2 * max(0, yb - ESC)) / G);\n      m.r = m.a - TAU - m.tf - (ENT - it.w - m.x0) / VB;\n    }\n    return m;\n  });\n  const L = { n, items, just: src.just, aEnd: items[items.length - 1].a };\n  L.j0 = L.aEnd + 0.08;\n  L.j1 = L.j0 + TJ;\n  L.d1 = L.j1 + TD;\n  L.p1 = L.d1 + TP;\n  L.l0 = L.p1 + TH;\n  L.l1 = L.l0 + TL;\n  L.end = L.l1;\n  for (const m of items) {\n    if (m.sp) continue;\n    m.tin = L.l1 + (BOXX - (m.fx + m.w)) / VF;\n    m.tout = m.tin + 0.08;\n    m.xc = max(0, chX(m.ci) - floor(m.w / 2));\n    m.tdrop = m.tout + max(0, BOXX - m.w - m.xc) / VBAR;\n    m.back = m.tdrop + TCH;\n    L.end = max(L.end, m.back);\n  }\n  return L;\n}\n\nfunction start(S) {\n  S.lines = breakLines(TEXTS[S.text], S.M);\n  S.active = [];\n  S.slugs = [];\n  // The machine opens as if it had been running: cold slugs of the text's\n  // opening lines in the galley, one line on the distributor bar, one at\n  // the mould and the next coming down into the assembler.\n  const nl = S.lines.length;\n  for (let n = 0; n \u003c 5; n++) S.slugs.push({ L: schedule(S, n % nl, -100 + n), tE: -100 + n, hot: -100 });\n  S.t = 0;\n  let t0 = -5.2;\n  for (let n = 5; n \u003c 8; n++) {\n    const L = schedule(S, n, t0);\n    S.active.push(L);\n    t0 = L.d1;\n  }\n  S.next = 8;\n  for (const L of S.active) if (L.l0 \u003c= 0) S.slugs.push({ L, tE: L.l0, hot: L.d1 });\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, text: 0, M: 60, key: \"\", buf: new Float32Array(N * 3), c: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const text = round(cl(k[2] || 0, 0, 3)), M = 60 - 4 * round(3 * cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  const key = text + \":\" + M;\n  if (key !== S.key) {\n    S.key = key;\n    S.text = text;\n    S.M = M;\n    start(S);\n  }\n  const t0 = S.t;\n  S.t += (d * speed) / 2;\n  // Keep the next line scheduled ahead; a slug joins the galley when ejected.\n  while (S.active[S.active.length - 1].d1 \u003c S.t + 3) {\n    const last = S.active[S.active.length - 1];\n    S.active.push(schedule(S, S.next++, last.d1));\n  }\n  for (const L of S.active) if (L.l0 > t0 && L.l0 \u003c= S.t) S.slugs.push({ L, tE: L.l0, hot: L.d1 });\n  S.active = S.active.filter((L) => L.end > S.t - 0.5);\n  while (S.slugs.length > 7) S.slugs.shift();\n}\n\n// Drawing into a float buffer, 0..1.\nfunction paint(S, x, y, c, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, b = S.buf;\n  if (a == null || a >= 1) {\n    b[p] = c[0];\n    b[p + 1] = c[1];\n    b[p + 2] = c[2];\n  } else {\n    b[p] += (c[0] - b[p]) * a;\n    b[p + 1] += (c[1] - b[p + 1]) * a;\n    b[p + 2] += (c[2] - b[p + 2]) * a;\n  }\n}\n\n// A matrix: a thin brass plate, its ears top and bottom, the letter between.\nfunction matrix(S, ch, x, y, a) {\n  const g = GL[ch], C = S.col;\n  x = round(x);\n  y = round(y);\n  for (let i = 0; i \u003c g.w; i++) {\n    paint(S, x + i, y, C.ear, a);\n    paint(S, x + i, y + 6, C.ear, a);\n    for (let r = 0; r \u003c 5; r++) paint(S, x + i, y + 1 + r, g.px[r][i] ? C.brass : C.plate, a);\n  }\n}\n\n// A spaceband: a long steel double wedge, a thin stem above the line and\n// its thick foot below it. `w` is its width across the line, `rise` how far\n// it has been driven up: the foot comes up into the line and pushes the\n// words apart.\nfunction band(S, x, y, w, rise) {\n  const C = S.col, top = round(y - 5 - rise), x0 = round(x);\n  for (let r = 0; r \u003c 15; r++) {\n    const ww = r \u003c 5 ? 1 : min(w, round(1 + ((r - 4) * (w - 1)) / 7)), Y = top + r, inLine = Y >= y && Y \u003c y + 7;\n    for (let i = 0; i \u003c ww; i++) paint(S, x0 + floor((w - ww) / 2) + i, Y, C.band, inLine ? 0.5 : 0.9);\n  }\n}\n\n// Where each matrix of a line stands across the assembler at time t:\n// packed against the entrance as they come, then spread to the measure.\nfunction across(L, t, out) {\n  const it = L.items, n = it.length;\n  let x = ENT;\n  for (let k = n - 1; k >= 0; k--) {\n    const u = cl((t - (it[k].a - 2 * TAU)) / TAU, 0, 1);\n    x -= it[k].w * u;\n    out[k] = x;\n  }\n  if (t > L.j0) {\n    const p = ease((t - L.j0) / (L.j1 - L.j0));\n    for (let k = 0; k \u003c n; k++) out[k] += (it[k].fx - out[k]) * p;\n  }\n  return out;\n}\n\n// A slug: one bar of type metal the width of the measure, its face the\n// line in relief and in mirror image. Fresh from the mould it is pale and\n// warm, and it cools to the grey of the galley.\nfunction slug(S, L, y, heat) {\n  const C = S.col, c = S.c, x0 = ENT - S.M, x1 = ENT - 1;\n  for (let r = 0; r \u003c SLUG; r++) {\n    const base = r === 0 || r === SLUG - 1 ? C.shoulder : C.body, hot = r === 0 || r === SLUG - 1 ? HOT_S : HOT_B;\n    for (let q = 0; q \u003c 3; q++) c[q] = base[q] + (hot[q] - base[q]) * heat;\n    for (let x = x0; x \u003c= x1; x++) paint(S, x, y + r, c);\n  }\n  for (let q = 0; q \u003c 3; q++) c[q] = C.face[q] + (HOT_F[q] - C.face[q]) * heat;\n  for (const m of L.items) {\n    if (m.sp) continue;\n    const g = GL[m.ch];\n    for (let i = 0; i \u003c g.w; i++) for (let r = 0; r \u003c 5; r++) if (g.px[r][i]) paint(S, x0 + x1 - (m.fx + i), y + 1 + r, c);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.active) return;\n  const t = S.t, b = S.buf, hue = S.hue;\n  b.fill(0);\n  S.col = {\n    brass: hsv(hue + 0.13, 0.55, 1, [0, 0, 0]),\n    ear: hsv(hue + 0.12, 0.6, 0.62, [0, 0, 0]),\n    plate: hsv(hue + 0.12, 0.6, 0.12, [0, 0, 0]),\n    fill: hsv(hue + 0.12, 0.6, 0.7, [0, 0, 0]),\n    steel: hsv(hue + 0.58, 0.25, 0.3, [0, 0, 0]),\n    band: hsv(hue + 0.58, 0.15, 0.85, [0, 0, 0]),\n    body: hsv(hue + 0.58, 0.1, 0.36, [0, 0, 0]),\n    shoulder: hsv(hue + 0.58, 0.12, 0.22, [0, 0, 0]),\n    face: hsv(hue + 0.58, 0.06, 0.9, [0, 0, 0]),\n  };\n  const C = S.col, pos = [];\n\n  // Lines lifted back to the top, behind everything, dim while they rise.\n  for (const L of S.active) {\n    if (t \u003c L.l0 || t > L.end) continue;\n    const y = t \u003c L.l1 ? MOULD + (1 - MOULD) * ease((t - L.l0) / TL) : 1, a = t \u003c L.l1 ? 0.5 : 1;\n    const shift = t > L.l1 ? VF * (t - L.l1) : 0;\n    for (const m of L.items) if (!m.sp && t \u003c m.tin) matrix(S, m.ch, m.fx + shift, y, a);\n  }\n\n  // The frame: distributor bar and box, magazine walls, belt, rail.\n  for (let x = 0; x \u003c BOXX; x++) paint(S, x, BAR, C.steel);\n  for (let y = 0; y \u003c= BAR; y++) for (let x = BOXX; x \u003c W; x++) paint(S, x, y, y === 0 || y === BAR || x === BOXX ? C.steel : [0, 0, 0]);\n  for (let i = 0; i \u003c= ORDER.length; i++) for (let y = MAG0; y \u003c= MAG1; y++) paint(S, 2 * i, y, C.steel);\n  for (let x = 0; x \u003c= ENT - 4; x++) paint(S, x, LINE - LIP + 7 - SLOPE * (ENT - 4 - x), C.steel, 0.8);\n  for (let x = ENT - S.M - 1; x \u003c= ENT; x++) paint(S, x, RAIL, C.steel);\n  for (let y = 44; y \u003c= 54; y++) for (let x = 61; x \u003c W; x++) paint(S, x, y, y === 44 || x === 61 ? C.steel : [0, 0, 0]);\n  // The mould's jaws, warm while the metal is in.\n  let glow = 0;\n  for (const L of S.active) if (t >= L.d1) glow = max(glow, t \u003c L.l0 ? 1 : exp(-(t - L.l0) / 0.4));\n  for (let y = CAV - 1; y \u003c= CAV + SLUG; y++)\n    for (const x of [ENT - S.M - 1, ENT]) {\n      paint(S, x, y, C.steel);\n      paint(S, x, y, MOLTEN, glow * 0.8);\n    }\n\n  // Magazine fills: each channel's matrices stacked from its escapement.\n  const count = BASE.slice();\n  for (const L of S.active)\n    for (const m of L.items) if (!m.sp && t >= m.r && t \u003c (m.back ?? 1e9)) count[m.ci]--;\n  for (let i = 0; i \u003c ORDER.length; i++)\n    for (let r = 0; r \u003c min(MAG1 - MAG0 + 1, max(0, count[i])); r++) paint(S, chX(i), MAG1 - r, r === count[i] - 1 ? C.brass : C.fill);\n\n  for (const L of S.active) {\n    across(L, t, pos);\n    const yLine = t \u003c L.j1 ? LINE : t \u003c L.d1 ? LINE + (MOULD - LINE) * ease((t - L.j1) / TD) : MOULD;\n    const rise = L.just ? RISE * ease((t - L.j0) / TJ) : 0;\n    for (let k = 0; k \u003c L.items.length; k++) {\n      const m = L.items[k];\n      if (t \u003c m.r) continue;\n      if (m.sp) {\n        if (t \u003c m.a) band(S, ENT - GMIN, 49 + (LINE - 49) * ((t - m.r) / TSB), GMIN, 0);\n        else if (t \u003c L.l0) {\n          const w = t \u003c L.j0 ? GMIN : GMIN + (m.fw - GMIN) * ease((t - L.j0) / TJ);\n          band(S, pos[k], yLine, round(w), rise);\n        } else if (t \u003c L.l0 + 0.4) band(S, pos[k] + 120 * (t - L.l0), yLine, m.fw, rise);\n        continue;\n      }\n      if (t \u003c m.a) {\n        // Falling from the escapement, riding the belt to its end above the\n        // entrance, then dropping into the line once the line has moved up.\n        const tf = t - m.r;\n        if (tf \u003c m.tf) matrix(S, m.ch, m.x0, ESC + 0.5 * G * tf * tf, 1);\n        else if (t \u003c m.a - TAU) {\n          const x = m.x0 + VB * (tf - m.tf);\n          matrix(S, m.ch, x, LINE - LIP - SLOPE * (ENT - m.w - x), 1);\n        } else {\n          const u = (t - (m.a - TAU)) / TAU;\n          matrix(S, m.ch, ENT - m.w, LINE - LIP * (1 - u * u), 1);\n        }\n      } else if (t \u003c L.l0) matrix(S, m.ch, pos[k], yLine, 1);\n      else if (t >= m.tout && t \u003c m.back) {\n        // Along the distributor bar to its channel, then down into it.\n        const x = max(m.xc, BOXX - m.w - VBAR * (t - m.tout));\n        const y = t \u003c m.tdrop ? HANG : HANG + (MAG0 - HANG) * ((t - m.tdrop) / TCH);\n        matrix(S, m.ch, x, y, 1);\n      }\n    }\n    // The cast: metal pumped into the mould behind the line, left to right.\n    if (t >= L.d1 && t \u003c L.l0) {\n      const x0 = ENT - S.M, f = (t - L.d1) / TP;\n      if (f \u003c 1) {\n        const xe = x0 + S.M * f;\n        for (let y = CAV; y \u003c CAV + SLUG; y++) for (let x = x0; x \u003c xe; x++) paint(S, x, y, MOLTEN);\n      } else slug(S, L, CAV, 1);\n    }\n  }\n\n  // The galley: the newest slug at the top, each pushing the earlier down.\n  const sl = S.slugs.filter((s) => s.tE \u003c= t);\n  for (let i = sl.length - 1; i >= 0; i--) {\n    let y = CAV + (GAL - CAV) * ease((t - sl[i].tE) / TE);\n    for (let j = i + 1; j \u003c sl.length; j++) y += SLUG * ease((t - sl[j].tE) / TE);\n    if (y \u003c H) slug(S, sl[i].L, y, exp(-max(0, t - sl[i].hot - TP) / COOL));\n  }\n\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), round(cl(b[p * 3], 0, 1) * 255), round(cl(b[p * 3 + 1], 0, 1) * 255), round(cl(b[p * 3 + 2], 0, 1) * 255));\n}\n","mamikon-theorem":"// ===== Patternflow pattern =====\n// Title:   Mamikon's Theorem\n// Family:  line\n// Idea:    In the top square a segment of fixed length runs round an oval, always tangent to it at one end, and the ring it sweeps fills in twelve colours by the segment's angle, while in the bottom square the same segment, carried to one fixed point, sweeps a disk in the same colours at the same moments, so that every wedge of the ring, fan-shaped where the oval turns sharply and a long thin sliver where it is flat, has the area of its slice of the disk, and the whole ring has the disk's area whatever the oval.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Mamikon's theorem on tangent sweeps and tangent clusters (Mamikon Mnatsakanian, 1959), pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Oval=0..3, Length=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 the twelve wedges run from teal, where the segment starts at the top of the oval, through azure and violet to pink; at 0.5 from red through gold to green. The oval's outline and the segment stay near white.\n// Knob 2: Speed. One turn of the segment takes 9 / Speed seconds: 4.5 s at the opening 2, 45 s at 0.2 and 3 s at 3. The ring fills in one turn, holds full for a fifth of a turn, drains in the next turn and stays empty for an eighth of one.\n// Knob 3: Oval. The curve, with the disk below left as it is: 0 an ellipse twice as wide as it is tall, 1 a triangle with rounded corners, 2 a square with rounded corners, 3 a thin stadium, and the shapes between are their Minkowski blends, so every setting is a convex oval. Round the triangle the ring is three fans, round the square a pinwheel of four quarter disks, round the stadium two half disks, and each has the area of the disk.\n// Knob 4: Length. The segment, 20 LEDs long at 0 and 16 to 25 across the range (20.3 at the opening 0.06); the disk's radius is the same length. The oval is scaled so that it and its ring fill the top square, so a longer segment means a smaller oval in a wider ring.\n\n// Let a segment of length L touch a curve at one end and point along the\n// curve's tangent. Run that end round a closed convex curve once: the\n// segment sweeps the ring between the curve and the path of its far end,\n// the tangent sweep. Now carry every one of those segments, unturned, so\n// that its touching end sits at one point: they fill a disk of radius L,\n// the tangent cluster. Mamikon's theorem says the two have the same area,\n// so the ring has area pi L^2 whatever the curve. A wedge of the ring made\n// while the tangent turns through d theta has area L^2 d theta / 2, the\n// same as the slice of the disk for that d theta: a point at distance t\n// along the tangent at angle theta covers t dt d theta in both. That is\n// why the colours here go by the tangent's angle, twelve wedges of 30\n// degrees, and the brightness by t / L. Where the curve is flat the\n// segment slides along itself and sweeps nothing, and the disk below\n// waits.\n//\n// The ovals are kept as support functions: h(theta) is how far the\n// tangent line with outward normal (cos theta, sin theta) is from the\n// centre, the touching point is h n + h' n', and the tangent direction is\n// n' = (-sin theta, cos theta). A point Q lies on that tangent line when\n// g(theta) = Q . n - h(theta) is 0, and g' = Q . n' - h' is exactly how far\n// Q is along the tangent from the touching point. So for each LED outside\n// the oval the forward tangent is the root where g goes from negative to\n// positive, found on 128 angles and polished by Newton's method, and g' at\n// that root is t. Blending two support functions linearly is a Minkowski\n// blend of the two shapes, and stays convex.\n//\n// The segment's clock runs partly by the tangent's angle and partly by arc\n// length, so it turns at the corners and slides along the sides instead\n// of jumping across them; the fill below keeps step because both halves\n// fill by the same angle.\n\nconst W = 64, H = 128, TOP = 64;\nconst { floor, min, max, round, sqrt, sin, cos, atan2, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst F = 256; // angles in the fine tables: the segment's run and the outline\nconst C = 2; // every C-th of them is searched for an LED's tangent\nconst M = F / C;\nconst TH0 = -PI / 2; // the run starts at the top, the segment pointing right\nconst WEDGES = 12;\nconst GHOST = 0.26;\nconst SLIDE = 0.45; // share of the segment's clock that goes by arc length\nconst BOX = 60;\nconst DX = 32, DY = 96; // the disk's centre\n// One cycle, in turns: fill, hold full, drain, hold empty.\nconst FILL = 1, FULL = 0.2, DRAIN = 1, EMPTY = 0.125, CYCLE = FILL + FULL + DRAIN + EMPTY;\n\nconst TRI = [[0, -1], [0.866, 0.5], [-0.866, 0.5]];\nconst SQR = [[-0.72, -0.72], [0.72, -0.72], [0.72, 0.72], [-0.72, 0.72]];\nconst SHAPES = [{ a: 1, b: 0.5 }, { v: TRI, r: 0.16 }, { v: SQR, r: 0.12 }, { v: [[-1, 0], [1, 0]], r: 0.14 }];\n\n// h and h' of one shape at the normal (c, s).\nfunction sup1(sh, c, s, o) {\n  if (sh.v) {\n    let best = -1e9, bi = 0;\n    for (let i = 0; i \u003c sh.v.length; i++) {\n      const d = sh.v[i][0] * c + sh.v[i][1] * s;\n      if (d > best) {\n        best = d;\n        bi = i;\n      }\n    }\n    o[0] = best + sh.r;\n    o[1] = sh.v[bi][1] * c - sh.v[bi][0] * s;\n  } else {\n    const h = sqrt(sh.a * sh.a * c * c + sh.b * sh.b * s * s);\n    o[0] = h;\n    o[1] = ((sh.b * sh.b - sh.a * sh.a) * s * c) / h;\n  }\n}\n\nconst ta = [0, 0], tb = [0, 0];\nfunction sup(S, c, s, o) {\n  sup1(SHAPES[S.si], c, s, ta);\n  sup1(SHAPES[S.si + 1], c, s, tb);\n  o[0] = (1 - S.sw) * ta[0] + S.sw * tb[0];\n  o[1] = (1 - S.sw) * ta[1] + S.sw * tb[1];\n}\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// An antialiased line of width w into a coverage buffer of the given width, max-blended.\nfunction line(buf, bw, bh, x0, y0, x1, y1, w, a) {\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-9, e = w / 2 + 0.5;\n  const ya = max(0, floor(min(y0, y1) - e)), yb = min(bh - 1, floor(max(y0, y1) + e));\n  const xa = max(0, floor(min(x0, x1) - e)), xb = min(bw - 1, floor(max(x0, x1) + e));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / L2, 0, 1);\n      const ex = px - t * dx, ey = py - t * dy, c = a * cl(e - sqrt(ex * ex + ey * ey), 0, 1);\n      const i = y * bw + x;\n      if (c > buf[i]) buf[i] = c;\n    }\n}\n\nfunction dot(buf, bw, bh, x0, y0, r, a) {\n  for (let y = max(0, floor(y0 - r - 1)); y \u003c= min(bh - 1, floor(y0 + r + 1)); y++)\n    for (let x = max(0, floor(x0 - r - 1)); x \u003c= min(bw - 1, floor(x0 + r + 1)); x++) {\n      const ex = x + 0.5 - x0, ey = y + 0.5 - y0, c = a * cl(r + 0.5 - sqrt(ex * ex + ey * ey), 0, 1), i = y * bw + x;\n      if (c > buf[i]) buf[i] = c;\n    }\n}\n\nexport function setup(params) {\n  const S = {\n    ph: 0, hue: 0, L: 20, oval: 0, key: \"\", hkey: \"\", si: 0, sw: 0, sig: 1, ox: 32, oy: 32,\n    cs: new Float32Array(F + 1), sn: new Float32Array(F + 1), hh: new Float32Array(F + 1),\n    px: new Float32Array(F + 1), py: new Float32Array(F + 1), m: new Float32Array(F + 1),\n    u: new Float32Array(W * H), t: new Float32Array(W * H), rim: new Float32Array(W * TOP),\n    col: new Float32Array(W * H * 3), out: new Float32Array(W * H * 3), seg: new Float32Array(W * H),\n    o: [0, 0],\n  };\n  for (let j = 0; j \u003c= F; j++) {\n    const th = TH0 + (TAU * j) / F;\n    S.cs[j] = cos(th);\n    S.sn[j] = sin(th);\n  }\n  params.s = S;\n}\n\nfunction extent(S, sig, L) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let j = 0; j \u003c F; j++) {\n    const ax = sig * S.px[j], ay = sig * S.py[j], bx = ax - L * S.sn[j], by = ay + L * S.cs[j];\n    x0 = min(x0, ax, bx);\n    x1 = max(x1, ax, bx);\n    y0 = min(y0, ay, by);\n    y1 = max(y1, ay, by);\n  }\n  S.bx = (x0 + x1) / 2;\n  S.by = (y0 + y1) / 2;\n  return max(x1 - x0, y1 - y0);\n}\n\n// Everything that depends on the oval and the length: the scale, the\n// segment's run, and for every LED its tangent angle and distance.\nfunction build(S) {\n  const L = S.L, o = S.o;\n  const v = cl(S.oval, 0, 3);\n  S.si = min(2, floor(v));\n  S.sw = v - S.si;\n  for (let j = 0; j \u003c= F; j++) {\n    const c = S.cs[j], s = S.sn[j];\n    sup(S, c, s, o);\n    S.hh[j] = o[0];\n    S.px[j] = o[0] * c - o[1] * s;\n    S.py[j] = o[0] * s + o[1] * c;\n  }\n  let lo = 0, hi = BOX;\n  for (let it = 0; it \u003c 24; it++) {\n    const mid = (lo + hi) / 2;\n    if (extent(S, mid, L) \u003c= BOX) lo = mid;\n    else hi = mid;\n  }\n  const sig = (S.sig = lo);\n  extent(S, sig, L);\n  S.ox = 32 - S.bx;\n  S.oy = 32 - S.by;\n  // The touching points in LEDs, and the segment's clock along them.\n  let per = 0;\n  for (let j = 0; j \u003c= F; j++) {\n    S.px[j] = sig * S.px[j] + S.ox;\n    S.py[j] = sig * S.py[j] + S.oy;\n    if (j) per += sqrt((S.px[j] - S.px[j - 1]) ** 2 + (S.py[j] - S.py[j - 1]) ** 2);\n  }\n  S.m[0] = 0;\n  for (let j = 1; j \u003c= F; j++) {\n    const ds = sqrt((S.px[j] - S.px[j - 1]) ** 2 + (S.py[j] - S.py[j - 1]) ** 2);\n    S.m[j] = S.m[j - 1] + (1 - SLIDE) / F + (SLIDE * ds) / (per || 1);\n  }\n  for (let j = 0; j \u003c= F; j++) S.m[j] /= S.m[F];\n\n  // The top square: each LED outside the oval, its forward tangent.\n  S.rim.fill(0);\n  for (let j = 0; j \u003c F; j++) line(S.rim, W, TOP, S.px[j], S.py[j], S.px[j + 1], S.py[j + 1], 1.1, 1);\n  for (let y = 0; y \u003c TOP; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, qx = x + 0.5 - S.ox, qy = y + 0.5 - S.oy;\n      S.u[p] = -1;\n      let jp = F - C, gp = qx * S.cs[jp] + qy * S.sn[jp] - sig * S.hh[jp], k = -1, g = 0;\n      for (let i = 0; i \u003c M; i++) {\n        const j = i * C;\n        g = qx * S.cs[j] + qy * S.sn[j] - sig * S.hh[j];\n        if (gp \u003c 0 && g >= 0) {\n          k = i;\n          break;\n        }\n        gp = g;\n      }\n      if (k \u003c 0) continue;\n      const a0 = TH0 + (TAU * (k - 1)) / M, a1 = a0 + TAU / M;\n      let th = a0 + ((TAU / M) * -gp) / (g - gp), t = 0;\n      for (let it = 0; it \u003c 3; it++) {\n        const c = cos(th), s = sin(th);\n        sup(S, c, s, o);\n        const gg = qx * c + qy * s - sig * o[0];\n        t = qy * c - qx * s - sig * o[1];\n        if (it === 2 || t \u003c 1e-4) break;\n        const tn = th - gg / t;\n        if (tn \u003c a0 || tn > a1) break;\n        th = tn;\n      }\n      if (t \u003c 0 || t > L + 1) continue;\n      let u = (th - TH0) / TAU;\n      u -= floor(u);\n      S.u[p] = u;\n      S.t[p] = t;\n    }\n  // The bottom square: the tangent cluster, a disk of radius L.\n  for (let y = TOP; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, dx = x + 0.5 - DX, dy = y + 0.5 - DY, d = sqrt(dx * dx + dy * dy);\n      S.u[p] = -1;\n      if (d > L + 1) continue;\n      let u = atan2(dy, dx) / TAU;\n      u -= floor(u);\n      S.u[p] = u;\n      S.t[p] = d;\n    }\n}\n\nfunction paint(S) {\n  const L = S.L;\n  for (let p = 0; p \u003c W * H; p++) {\n    const u = S.u[p];\n    if (u \u003c 0) {\n      S.col[p * 3] = S.col[p * 3 + 1] = S.col[p * 3 + 2] = 0;\n      continue;\n    }\n    const t = S.t[p], aa = cl(L - t + 0.5, 0, 1), tau = cl(t / L, 0, 1), wedge = floor(u * WEDGES);\n    hsv(S.hue + 0.48 + 0.42 * u, 0.8, (wedge & 1 ? 0.68 : 1) * (0.42 + 0.58 * tau) * aa, S.col, p * 3);\n  }\n}\n\n// Where the segment is at a fraction q of its clock: its angle as a\n// fraction of the turn, and its touching point.\nfunction at(S, q) {\n  let a = 0, b = F;\n  while (b - a > 1) {\n    const c = (a + b) >> 1;\n    if (S.m[c] \u003c= q) a = c;\n    else b = c;\n  }\n  const f = cl((q - S.m[a]) / (S.m[a + 1] - S.m[a] || 1), 0, 1);\n  S.phi = (a + f) / F;\n  S.qx = S.px[a] + (S.px[a + 1] - S.px[a]) * f;\n  S.qy = S.py[a] + (S.py[a + 1] - S.py[a]) * f;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.oval = cl(k[2] || 0, 0, 3);\n  S.L = 20 * pow(1.25, cl(k[3] == null ? 0.06 : k[3], -1, 1));\n  S.ph = (S.ph + (d * speed) / 9) % CYCLE;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.oval + \"|\" + S.L;\n  if (key !== S.key) {\n    S.key = key;\n    build(S);\n    S.hkey = \"\";\n  }\n  if (S.hkey !== key + \"|\" + S.hue) {\n    S.hkey = key + \"|\" + S.hue;\n    paint(S);\n  }\n  const ph = S.ph, L = S.L;\n  let mode;\n  if (ph \u003c FILL) {\n    mode = 0;\n    at(S, ph);\n  } else if (ph \u003c FILL + FULL) {\n    mode = 1;\n    at(S, 0);\n  } else if (ph \u003c FILL + FULL + DRAIN) {\n    mode = 2;\n    at(S, ph - FILL - FULL);\n  } else {\n    mode = 3;\n    at(S, 0);\n  }\n  const phi = S.phi, out = S.out, col = S.col;\n  for (let p = 0; p \u003c W * H; p++) {\n    const u = S.u[p];\n    let f = 0;\n    if (u >= 0) {\n      if (mode === 1) f = 1;\n      else if (mode === 3) f = GHOST;\n      else if (mode === 0) {\n        const lag = phi - u;\n        f = lag >= 0 ? 1 + (lag \u003c 0.04 ? 0.6 * (1 - lag / 0.04) : 0) : GHOST;\n      } else f = u \u003c phi ? GHOST : 1;\n    }\n    out[p * 3] = col[p * 3] * f;\n    out[p * 3 + 1] = col[p * 3 + 1] * f;\n    out[p * 3 + 2] = col[p * 3 + 2] * f;\n  }\n  // The oval's outline, pale over the ring.\n  for (let p = 0; p \u003c W * TOP; p++) {\n    const r = S.rim[p] * 0.9;\n    if (r \u003c= 0) continue;\n    out[p * 3] = max(out[p * 3], r * 0.86);\n    out[p * 3 + 1] = max(out[p * 3 + 1], r * 0.92);\n    out[p * 3 + 2] = max(out[p * 3 + 2], r);\n  }\n  // The segment, above at the oval and below at the disk's centre.\n  const th = TH0 + TAU * phi, tx = -sin(th), ty = cos(th), seg = S.seg;\n  seg.fill(0);\n  line(seg, W, H, S.qx, S.qy, S.qx + L * tx, S.qy + L * ty, 1.3, 1);\n  dot(seg, W, H, S.qx, S.qy, 1.4, 1);\n  line(seg, W, H, DX, DY, DX + L * tx, DY + L * ty, 1.3, 1);\n  dot(seg, W, H, DX, DY, 1.4, 1);\n  for (let p = 0; p \u003c W * H; p++) {\n    const a = seg[p];\n    if (a > 0) {\n      out[p * 3] += (1 - out[p * 3]) * a;\n      out[p * 3 + 1] += (1 - out[p * 3 + 1]) * a;\n      out[p * 3 + 2] += (1 - out[p * 3 + 2]) * a;\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(out[p * 3], 0, 1) * 255), round(cl(out[p * 3 + 1], 0, 1) * 255), round(cl(out[p * 3 + 2], 0, 1) * 255));\n}\n","menger-slices":"// ===== Patternflow pattern =====\n// Title:   Menger Slices\n// Family:  fractal\n// Idea:    A plane square to the long diagonal of a Menger sponge sweeps from corner to corner and back, every LED kept or cut by the base-3 digit test, so the section grows from a point into a triangle and a hexagon whose biggest hole turns from a triangle into a six-pointed star and on into a triangle the other way up, while below it the centre section holds the lace of stars still and every hole is coloured by the level that cut it.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Menger sponge (Karl Menger, 1926), cut across its long diagonal by the planes x + y + z = c, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=3..5, Zoom=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the kept sponge is pale cream, pinker near the corner the plane starts from and paler lime near the far one, and the holes run from dark teal for the first cut through blue, indigo and purple to magenta for the fifth. The holes skip orange and yellow, which read brown and olive when dark.\n// Knob 2: Speed. At 2 the plane takes 12 s from corner to corner and 24 s there and back, and first crosses the centre 5 s in; 120 s a way at 0.2 and 8 s at 3.\n// Knob 3: Depth. How many levels are cut, 3 to 5, the next level fading in as the knob turns between whole numbers. The upper view puts 43 LEDs on the cube's edge, so a third-level hole, a cube a 27th of the edge, is 1.6 LEDs; a fourth-level one is 0.53 LEDs and comes through as single LEDs in a moire, whole only in the lower view with Zoom turned up.\n// Knob 4: Zoom. The lower view. Up to 0.1 it is the whole centre section; past it the view magnifies about the section's right corner, the edge midpoint (1, 0, 1/2), up to 9 times at 1. At 0.55 it is 3 times and the lace comes back one level down, each hole in the next level's colour: the small cube at (2, 0, 1)/3 is cut through its own centre just as the whole cube is.\n\n// Karl Menger's sponge keeps a point of the unit cube when, at no place of\n// the base-3 expansions of its coordinates, two of the three digits are 1.\n// Each level cuts the cube into 27 and takes out the 7 whose position has\n// two or three 1s: the centre and the middle of each face. Every LED here\n// is that test, run on the point of the plane under it, level by level\n// until a level cuts it or the depth runs out.\n//\n// The planes x + y + z = c stand square to the diagonal from (0, 0, 0) to\n// (1, 1, 1). The section is a point at c = 0, a triangle up to c = 1, a\n// hexagon from 1 to 2, a triangle the other way up to 3. At c = 3/2 the\n// hole the first level cuts is a six-pointed star: the centre cube gives a\n// hexagon, and the three face cubes below the plane and the three above it\n// each add a triangle, all six the same size only there. Below 3/2 the\n// three from above shrink away and the hole becomes a triangle; further\n// down it opens into three lobes, the face cubes' own hexagons, and towards\n// the corner it is three small triangles. Above 3/2 the same happens the\n// other way up. The same holds inside every kept small cube the plane cuts\n// through its centre, which is why the centre section is a lace of stars.\n//\n// In the plane, u runs across the panel along (1, -1, 0) / sqrt 2 and w up\n// it along (-1, -1, 2) / sqrt 6, from where the diagonal pierces it.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, sqrt, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst R2 = sqrt(2), R6 = sqrt(6);\n\n// Upper view: rows 0..70, the moving section; row 71 the gauge; lower\n// view: rows 72..127, the centre section.\nconst TOP = 71, GAUGE = 71, SCALE_T = 43, SCALE_B = 44;\nconst CXT = 31.5, CYT = 35.5, CXB = 31.5, CYB = 99.5;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The level at which (x, y, z) is cut away, 0 if it is kept to depth K,\n// -1 outside the cube.\nfunction cut(x, y, z, K) {\n  if (x \u003c 0 || y \u003c 0 || z \u003c 0 || x >= 1 || y >= 1 || z >= 1) return -1;\n  for (let k = 1; k \u003c= K; k++) {\n    x *= 3; y *= 3; z *= 3;\n    const a = floor(x), b = floor(y), c = floor(z);\n    if ((a === 1 ? 1 : 0) + (b === 1 ? 1 : 0) + (c === 1 ? 1 : 0) >= 2) return k;\n    x -= a; y -= b; z -= c;\n  }\n  return 0;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, depth: 3, zoom: 0, hole: [], kept: [0, 0, 0], tmp: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.depth = cl(k[2] == null ? 3 : k[2], 3, 5);\n  S.zoom = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.t += (d * speed) / 2;\n}\n\n// Hole colours by level, dark for the first cut and a little lighter for\n// each finer one. Their hues go round a wheel with orange and yellow (0.03\n// to 0.2) cut out, since dark they read brown and olive on the panel.\nconst wheel = (h) => 0.2 + (h - floor(h)) * 0.83;\nfunction palette(S) {\n  for (let k = 1; k \u003c= 5; k++) S.hole[k] = hsv(wheel(S.hue + 0.36 + 0.13 * (k - 1)), 0.88, 0.3 + 0.05 * (k - 1), [0, 0, 0]);\n}\n\nfunction keptColour(S, c, w) {\n  return hsv(S.hue + 0.1 + 0.08 * (c - 1.5), 0.22 + 0.12 * w, 0.95, S.kept);\n}\n\nfunction put(display, x, y, c) {\n  display.setPixel(x, y, round(c[0]), round(c[1]), round(c[2]));\n}\n\n// One view: the plane x + y + z = cc, a point u across and w up from where\n// the diagonal pierces it, magnified m times about (vu, 0).\nfunction view(display, S, y0, y1, cx, cy, sc, cc, m, vu) {\n  const D = S.depth, K = ceil(D - 1e-6), f = D - (K - 1), b = cc / 3, mix = S.tmp;\n  for (let j = y0; j \u003c y1; j++) {\n    const w = (cy - j) / sc / m;\n    const kc = keptColour(S, cc, w);\n    for (let i = 0; i \u003c W; i++) {\n      const u = vu + ((i - cx) / sc - vu) / m;\n      const lev = cut(b + u / R2 - w / R6, b - u / R2 - w / R6, b + (2 * w) / R6, K);\n      if (lev \u003c 0) display.setPixel(i, j, 0, 0, 0);\n      else if (lev === 0) put(display, i, j, kc);\n      else if (lev \u003c K || f >= 1) put(display, i, j, S.hole[lev]);\n      else {\n        // The deepest level fades in as Depth turns past a whole number.\n        const h = S.hole[lev];\n        mix[0] = kc[0] + (h[0] - kc[0]) * f;\n        mix[1] = kc[1] + (h[1] - kc[1]) * f;\n        mix[2] = kc[2] + (h[2] - kc[2]) * f;\n        put(display, i, j, mix);\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  // The plane sweeps from corner to corner and back, 12 s a way at Speed 2,\n  // starting at c = 1/4.\n  const ph = (S.t / 12 + 1 / 12) % 2, c = 3 * (ph \u003c 1 ? ph : 2 - ph);\n  view(display, S, 0, TOP, CXT, CYT, SCALE_T, c, 1, 0);\n  // The gauge: the long diagonal from (0, 0, 0) at the left to (1, 1, 1)\n  // at the right, the plane a bright tick on it, the centre a dim one.\n  const tick = round((c / 3) * 62), g = hsv(S.hue + 0.1, 0.2, 0.22, [0, 0, 0]), hi = keptColour(S, c, 0);\n  for (let i = 0; i \u003c W; i++) put(display, i, GAUGE, i === tick || i === tick + 1 ? hi : i === 31 || i === 32 ? S.hole[3] : g);\n  const z = cl((S.zoom - 0.1) / 0.9, 0, 1);\n  view(display, S, GAUGE + 1, H, CXB, CYB, SCALE_B, 1.5, pow(9, z), 1 / R2);\n}\n","napier-bones":"// ===== Patternflow pattern =====\n// Title:   Napier's Bones\n// Family:  type\n// Idea:    Napier's multiplying rods fall down the tall panel one after another, the index rod and four rods headed by the digits of a number such as 1617, every square split by its diagonal into the tens and units of a product, and for each digit of the multiplier the row it names lights across the rods while the rest dim, the diagonals are added from right to left with each carry stepping over to the next, and the partial products and then their sum are written underneath before the rods fall away for the next problem.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Napier's bones (John Napier, Rabdologiæ, 1617), digits drawn for this pattern on a 3 by 5 grid, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Problem=0..5, Bands=0..1\n//\n// Knob 1: Hue. The colour of the rods. At 0 they are slate blue with pale digits, and the heads, the digits being added and the answer are gold; at 0.5 the rods are brown like boxwood and the gold turns blue, at 0.75 they are green and it turns pink.\n// Knob 2: Speed. At 2 each rod takes 0.45 s to fall, 0.12 s after the one before; each digit of the multiplier takes 2.1 s, 0.3 s to light its row, 0.32 s for each of the five diagonals and 0.2 s to rest; the rule takes 0.3 s and each column of the sum 0.26 s, and the answer stands 1.8 s before the rods fall out in 0.6 s. 1617 x 67 takes 9.5 s, 1089 x 9 takes 5.5 s and 1550 x 128 takes 11.6 s. Every time goes as 2 / Speed.\n// Knob 3: Problem. 0 is 1617 x 67, the year of Rabdologiæ by the 67 years since Napier's birth in 1550; 1 is 1550 x 128, that year by the panel's height; 2 is 1089 x 9 = 9801 and 3 is 2178 x 4 = 8712, the only four-digit numbers that a multiple turns back to front; 4 is 3367 x 33 = 111111 and 5 is 2439 x 41 = 99999. Each problem is followed by the next, and turning the knob starts the one it points at from the top.\n// Knob 4: Bands. Gives each diagonal of the lattice a hue of its own, on the wood and on the digits: the units half of a rod and the tens half of the rod to its right, the two that are added together, share one. Nothing at 0, too faint to see at the opening 0.06, and at 1 five hues a tenth of the wheel apart, so the diagonals read as stripes down all nine rows.\n\n// Each rod is headed by a digit d, and its k-th square holds k times d, the\n// tens above the diagonal and the units below it. Lay the index rod and the\n// rods for 1617 side by side and row 7 reads 0/7 4/2 0/7 4/9: 7 x 1, 7 x 6,\n// 7 x 1, 7 x 7. The units of one rod and the tens of the rod to its right\n// lie between the same two diagonals and count the same power of ten, so\n// adding along the diagonals from the right, carrying as you go, gives\n// 9, 7 + 4 = 11, 2 + 0 + 1 = 3, 7 + 4 = 11 and 0 + 1 = 1: 1617 x 7 = 11319,\n// with no multiplying done. A multiplier of more digits reads one row for\n// each digit, from its last, and the partial products are added each one\n// place to the left of the one before.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// 3 by 5 digits, five rows of three bits, the left LED the high bit.\nconst DIGIT = [\"75557\", \"26227\", \"71747\", \"71717\", \"55711\", \"74717\", \"74757\", \"71122\", \"75757\", \"75717\"].map((s) => s.split(\"\").map(Number));\nconst TIMES = [5, 2, 5];\n\n// Multiplicand and multiplier.\nconst PROBLEMS = [\n  [\"1617\", \"67\"],\n  [\"1550\", \"128\"],\n  [\"1089\", \"9\"],\n  [\"2178\", \"4\"],\n  [\"3367\", \"33\"],\n  [\"2439\", \"41\"],\n];\n\n// Rods: the index rod 8 LEDs wide, then four rods 13 wide, one dark LED\n// between. Each is 101 rows: a head, nine squares of 10 rows, edges.\nconst X0 = [0, 9, 23, 37, 51], RW = [8, 13, 13, 13, 13];\n// The diagonal of a square, from its lower left corner to its upper right:\n// the row it crosses in each column 1..11.\nconst DIAG = [0, 9, 8, 7, 7, 6, 5, 4, 3, 3, 2, 1];\nconst ROWS = 101, WORK = 102;\n\n// Seconds at Speed 2.\nconst DROP = 0.45, STAG = 0.12, T1 = 1.0, LIGHT = 0.3, BAND = 0.32, REST = 0.2, ROW = LIGHT + 5 * BAND + REST;\nconst RULE = 0.3, COL = 0.26, HOLD = 1.8, FALL = 0.6;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\nconst mix = (a, b, u) => [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, a[2] + (b[2] - a[2]) * u];\n\n// The reading of one problem: for each multiplier digit, right to left,\n// the five diagonals of its row with the carry each takes in and the digit\n// it leaves; then the columns of the partial products added the same way.\nfunction plan(a, b) {\n  const A = a.split(\"\").map(Number), M = b.split(\"\").map(Number).reverse();\n  const parts = M.map((k) => {\n    const bands = [];\n    let carry = 0;\n    for (let j = 0; j \u003c 5; j++) {\n      // Diagonal j: the units of the rod for 10^j and the tens of the rod for 10^(j-1).\n      const u = j \u003c= 3 ? (k * A[3 - j]) % 10 : 0, t = j >= 1 ? floor((k * A[4 - j]) / 10) : 0, s = u + t + carry;\n      bands.push({ cin: carry, d: s % 10 });\n      carry = floor(s / 10);\n    }\n    let len = 5;\n    while (len > 1 && bands[len - 1].d === 0) len--;\n    return { k, bands, len };\n  });\n  const total = String(Number(a) * Number(b)), cols = [];\n  let carry = 0;\n  for (let e = 0; e \u003c total.length; e++) {\n    let s = carry;\n    parts.forEach((p, i) => {\n      const j = e - i;\n      if (j >= 0 && j \u003c p.len) s += p.bands[j].d;\n    });\n    cols.push({ cin: carry, d: s % 10 });\n    carry = floor(s / 10);\n  }\n  const n = parts.length, sum = n > 1 ? T1 + n * ROW : 0, end = n > 1 ? sum + RULE + cols.length * COL : T1 + ROW;\n  return { A, parts, cols, n, sum, end, length: end + HOLD + FALL };\n}\n\nexport function setup(params) {\n  params.s = { buf: new Float32Array(N * 3), tau: 0, pi: 0, P: plan(...PROBLEMS[0]), knob: -1, hue: 0, bands: 0.06 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.bands = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3), kp = round(cl(k[2] || 0, 0, PROBLEMS.length - 1));\n  if (kp !== S.knob) {\n    S.knob = kp;\n    S.pi = kp;\n    S.P = plan(...PROBLEMS[kp]);\n    S.tau = 0;\n  }\n  S.tau += (d * speed) / 2;\n  if (S.tau >= S.P.length) {\n    S.tau -= S.P.length;\n    S.pi = (S.pi + 1) % PROBLEMS.length;\n    S.P = plan(...PROBLEMS[S.pi]);\n  }\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  if (a >= 1) {\n    buf[p] = c[0];\n    buf[p + 1] = c[1];\n    buf[p + 2] = c[2];\n  } else {\n    buf[p] += (c[0] - buf[p]) * a;\n    buf[p + 1] += (c[1] - buf[p + 1]) * a;\n    buf[p + 2] += (c[2] - buf[p + 2]) * a;\n  }\n}\n\nfunction glyph(buf, g, x, y, c, a) {\n  for (let r = 0; r \u003c g.length; r++) for (let i = 0; i \u003c 3; i++) if ((g[r] >> (2 - i)) & 1) put(buf, x + i, y + r, c, a);\n}\n\nconst scale = (c, f) => [c[0] * f, c[1] * f, c[2] * f];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, P = S.P, tau = S.tau, h = S.hue + 0.58, acc = h + 0.55;\n  buf.fill(0);\n  const C = {\n    body: hsv(h, 0.5, 0.17), edge: hsv(h, 0.4, 0.38), line: hsv(h, 0.35, 0.3), dig: hsv(h, 0.12, 0.78),\n    head: hsv(acc, 0.55, 1), lit: hsv(h, 0.45, 0.45), white: [1, 1, 1], fill: hsv(acc, 0.65, 0.3), gold: hsv(acc, 0.5, 1),\n    done: hsv(acc, 0.25, 0.9), pale: hsv(h, 0.15, 0.92), rule: hsv(h, 0.3, 0.55), sum: hsv(acc, 0.6, 1),\n  };\n  // Bands: each diagonal of the lattice in a hue of its own, on the wood\n  // and on its digits.\n  const tint = [0, 1, 2, 3, 4].map((b) => mix(C.body, hsv(acc + 0.1 * b, 0.75, 0.5), S.bands));\n  const ink = [0, 1, 2, 3, 4].map((b) => mix(C.dig, hsv(acc + 0.1 * b, 0.6, 0.95), S.bands));\n\n  // Which row is lit and which diagonal is being added. While\n  // a row is read the others dim, and so do all of them while the partial\n  // products are added.\n  let row = -1, light = 0, part = -1, band = -1;\n  for (let i = 0; i \u003c P.n; i++) {\n    const r0 = T1 + i * ROW;\n    if (tau >= r0 && tau \u003c r0 + ROW + 0.15) {\n      row = P.parts[i].k;\n      part = i;\n      light = smooth((tau - r0) / LIGHT) * (1 - smooth((tau - r0 - ROW + REST) / (REST + 0.15)));\n      band = tau - r0 \u003c LIGHT ? -1 : floor((tau - r0 - LIGHT) / BAND);\n    }\n  }\n  const out = P.length - FALL;\n  const adding = P.n > 1 ? smooth((tau - P.sum) / RULE) * (1 - smooth((tau - P.end) / 0.4)) : 0;\n  const dim = 1 - 0.45 * max(light, adding);\n\n  for (let r = 0; r \u003c 5; r++) {\n    // Each rod falls in from above, one after another, and falls out below.\n    const uin = cl((tau - STAG * r) / DROP, 0, 1), uout = cl((tau - out - STAG * r * 0.25) / (FALL * 0.8), 0, 1);\n    if (uin \u003c= 0 || uout >= 1) continue;\n    const oy = round(-(ROWS + 2) * (1 - uin * uin) + (H + 2) * uout * uout);\n    const x0 = X0[r], w = RW[r], dgt = r ? P.A[r - 1] : 0, place = 4 - r;\n    for (let sq = 0; sq \u003c= 10; sq++) {\n      const lit = sq === row ? light : 0, f = sq === row ? 1 : dim;\n      // The two halves of a square: units at this rod's place, tens one up.\n      let cu = r && sq ? tint[place] : C.body, ct = r && sq ? tint[min(4, place + 1)] : C.body;\n      cu = mix(scale(cu, f), C.lit, lit);\n      ct = mix(scale(ct, f), C.lit, lit);\n      if (lit && band === place) cu = mix(cu, C.fill, lit);\n      if (lit && band === place + 1) ct = mix(ct, C.fill, lit);\n      const ln = mix(scale(C.line, f), C.edge, lit), ed = scale(C.edge, sq ? f : 1);\n      for (let ly = 0; ly \u003c 10; ly++) {\n        const ry = sq * 10 + ly, y = ry + oy;\n        if (ry >= ROWS) break;\n        if (y \u003c 0 || y >= H) continue;\n        for (let lx = 0, p = (y * W + x0) * 3; lx \u003c w; lx++, p += 3) {\n          let c;\n          if (lx === 0 || lx === w - 1 || ry === 0 || ry === 100) c = ed;\n          else if (ly === 0 || (r && sq && ly === DIAG[lx])) c = ln;\n          else c = r && sq && ly \u003c DIAG[lx] ? ct : cu;\n          buf[p] = c[0];\n          buf[p + 1] = c[1];\n          buf[p + 2] = c[2];\n        }\n      }\n    }\n    // The digits: the head's at row 3, the squares' from their row 1. A\n    // tens digit of 0 is drawn half as bright.\n    if (r) glyph(buf, DIGIT[dgt], x0 + 5, oy + 3, C.head, 1);\n    else glyph(buf, TIMES, x0 + 2, oy + 4, C.head, 1);\n    for (let sq = 1; sq \u003c= 9; sq++) {\n      const y = sq * 10 + oy + 1, lit = sq === row ? light : 0, f = sq === row ? 1 : dim;\n      if (!r) {\n        glyph(buf, DIGIT[sq], x0 + 2, y + 2, mix(scale(C.dig, f), C.gold, lit), 1);\n        continue;\n      }\n      const v = sq * dgt, t = floor(v / 10), u = v % 10;\n      const tc = band === place + 1 ? C.gold : band > place + 1 ? C.done : C.white;\n      const uc = band === place ? C.gold : band > place ? C.done : C.white;\n      glyph(buf, DIGIT[t], x0 + 2, y, mix(scale(ink[min(4, place + 1)], t ? f : f * 0.5), tc, lit), 1);\n      glyph(buf, DIGIT[u], x0 + 8, y + 4, mix(scale(ink[place], f), uc, lit), 1);\n    }\n    // A carry steps from the units of this rod to its tens, the next diagonal.\n    if (row > 0 && r && band === place + 1 && band \u003c= 4 && P.parts[part].bands[band].cin) {\n      const f = smooth((tau - T1 - part * ROW - LIGHT - band * BAND) / (BAND * 0.45));\n      const cx = round(x0 + 9 - 6 * f), cy = row * 10 + 10 + oy;\n      put(buf, cx, cy, C.gold, light);\n      put(buf, cx + 1, cy, C.gold, light);\n    }\n  }\n\n  // Underneath: the multiplier at the left, the digit being read in gold,\n  // then the partial products as they are read, then their sum.\n  const fade = 1 - smooth((tau - out) / (FALL * 0.7));\n  const xOf = (e) => 60 - 4 * e, mul = PROBLEMS[S.pi][1];\n  const shown = fade * smooth((tau - 0.6) / 0.3);\n  glyph(buf, TIMES, 1, WORK + 1, C.rule, shown);\n  for (let j = 0; j \u003c mul.length; j++) glyph(buf, DIGIT[+mul[j]], 5 + 4 * j, WORK, mix(C.pale, C.gold, part === mul.length - 1 - j ? light : 0), shown);\n  for (let i = 0; i \u003c P.n; i++) {\n    const p = P.parts[i], r0 = T1 + i * ROW, y = WORK + 6 * i, single = P.n === 1;\n    for (let j = 0; j \u003c p.len; j++) {\n      const at = r0 + LIGHT + (j + 0.5) * BAND;\n      if (tau \u003c at) break;\n      const flash = 1 - smooth((tau - at) / 0.35);\n      let c = mix(single ? C.sum : C.pale, C.white, flash);\n      if (P.n > 1 && tau >= P.sum + RULE) {\n        const e = i + j, ce = floor((tau - P.sum - RULE) / COL);\n        if (ce === e) c = C.gold;\n      }\n      glyph(buf, DIGIT[p.bands[j].d], xOf(i + j), y, c, fade);\n    }\n  }\n  if (P.n > 1 && tau >= P.sum) {\n    const yr = WORK + 6 * P.n, len = round(26 * smooth((tau - P.sum) / RULE));\n    for (let x = 0; x \u003c len; x++) put(buf, 62 - x, yr, C.rule, fade);\n    for (let e = 0; e \u003c P.cols.length; e++) {\n      const at = P.sum + RULE + (e + 0.5) * COL;\n      if (tau \u003c at) break;\n      const flash = 1 - smooth((tau - at) / 0.35);\n      glyph(buf, DIGIT[P.cols[e].d], xOf(e), yr + 2, mix(C.sum, C.white, flash), fade);\n      // The carry into the next column, on the rule.\n      const nx = P.cols[e + 1];\n      if (nx && nx.cin && tau \u003c at + COL) {\n        const f = smooth((tau - at) / (COL * 0.5)), cx = round(xOf(e) + 1 - 4 * f);\n        put(buf, cx, yr, C.gold, fade);\n        put(buf, cx + 1, yr, C.gold, fade);\n      }\n    }\n  }\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","plucked-letters":"// ===== Patternflow pattern =====\n// Title:   Plucked Letters\n// Family:  type\n// Idea:    A four-letter word of straight strokes stands two over two down the tall panel, every stroke a string pinned between bright points where strokes meet or end, and the strings are plucked letter by letter, each letter rolled as a chord from its longest stroke to its shortest, so that each string flashes, splits its triangle into two kinks that run to the pins, come back upside down and ring away, the long strokes swinging slowly and the short ones buzzing.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: d'Alembert's travelling-wave solution of the vibrating string (Jean le Rond d'Alembert, 1747), capitals drawn for this pattern as straight strokes, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Pluck=0..1\n//\n// Knob 1: Hue. Turns the strings' colours round the wheel. At 0 the longest strings are violet and the shortest cyan, with azure between; at 0.5 the longest are a yellow green and the shortest a warm red. The pins, the kinks and the flash of a fresh pluck stay near white.\n// Knob 2: Speed. The clock of everything. At 2 a wave runs 75 LEDs a second, so a 52-LED stroke swings once in 1.4 s and the 8-LED half of a serif in 0.2 s, a string's swing falls to 37% in 1.5 s, a letter's notes are 0.12 s apart and the next letter comes 0.5 s after the last note: HYMN's 15 strings come round every 3.9 s, the last 1.1 s of it a rest. Every time goes as 2 / Speed.\n// Knob 3: Word. 0 HYMN, 1 WAVE, 2 KITE, 3 LYNX, 4 ZEAL, 5 FLAX, 6 TWIN, 7 AXLE, all letters of straight strokes only. Turning it sets the new word at rest and starts it from its first letter.\n// Knob 4: Pluck. Where along each string it is pulled: at 0 the middle, at the opening 0.06 at 0.47 of its length, and at 1 at 0.06 of it, close to a pin. From the middle the two kinks part and the string's flat top widens as it sinks, until the string lies straight and the triangle comes back upside down; from near a pin the kinks come in close pairs, each pair a steep step, and the two steps run opposite ways along the string, pass through each other and turn over at the pins.\n\n// A string pinned at x = 0 and x = l, pulled aside into a triangle with\n// its peak at p l and let go, moves by d'Alembert's solution of the wave\n// equation: y(x, t) = (F(x - c t) + F(x + c t)) / 2, where F is the\n// triangle extended to the whole line as an odd function of period 2 l.\n// Half the triangle runs left and half runs right; each half reaches a\n// pin, where the odd extension sends back the same shape upside down. So\n// the string is never a sine. It is straight lines between at most four\n// kinks, at x = +-c t +- p l reduced into the string, and that is how it is\n// drawn: the kinks are worked out exactly each frame, the string is the\n// polyline through them, and each kink is a bright bead. The wave speed\n// c is the same on every string, so the period 2 l / c goes as the length\n// and the frequency as 1 / l. The swing dies away by one exponential for\n// every string, which scales the shape and leaves its corners sharp.\n//\n// The capitals are drawn on a grid four units wide and eight tall, with\n// straight strokes only. A stroke is cut wherever another stroke's end\n// lands on it or crosses it, so the crossbar of H makes four strings of\n// its two stems, and every cut and every end is a pin.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, exp, log, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst LETTERS = {\n  A: \"0 8 2 0|2 0 4 8|0.75 5 3.25 5\",\n  E: \"4 0 0 0|0 0 0 8|0 8 4 8|0 4 3.4 4\",\n  F: \"4 0 0 0|0 0 0 8|0 4 3.4 4\",\n  H: \"0 0 0 8|4 0 4 8|0 4 4 4\",\n  I: \"2 0 2 8|0.6 0 3.4 0|0.6 8 3.4 8\",\n  K: \"0 0 0 8|4 0 0 5|1.6 3 4 8\",\n  L: \"0 0 0 8|0 8 4 8\",\n  M: \"0 8 0 0|0 0 2 5|2 5 4 0|4 0 4 8\",\n  N: \"0 8 0 0|0 0 4 8|4 8 4 0\",\n  T: \"0 0 4 0|2 0 2 8\",\n  V: \"0 0 2 8|2 8 4 0\",\n  W: \"0 0 1 8|1 8 2 3|2 3 3 8|3 8 4 0\",\n  X: \"0 0 4 8|4 0 0 8\",\n  Y: \"0 0 2 4|4 0 2 4|2 4 2 8\",\n  Z: \"0 0 4 0|4 0 0 8|0 8 4 8\",\n};\nconst WORDS = [\"HYMN\", \"WAVE\", \"KITE\", \"LYNX\", \"ZEAL\", \"FLAX\", \"TWIN\", \"AXLE\"];\n\n// A letter's box: 22 by 52 LEDs, two over two.\nconst UX = 5.5, UY = 6.5;\nconst CELLS = [[5, 6], [37, 6], [5, 70], [37, 70]];\n\n// At Speed 2, in seconds: the wave speed in LEDs a second, the ring-down,\n// the flash, the notes of a letter, the gap to the next letter, the rest.\nconst WAVE = 75, RING = 1.5, FLASH = 0.16, NOTE = 0.12, NEXT = 0.5, REST = 1.1;\nconst PIN = [1, 0.97, 0.9];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Strings and pins of a word.\nfunction build(S, word) {\n  const strings = [], pins = [], seen = {};\n  const pin = (x, y) => {\n    const k = round(x * 8) + \",\" + round(y * 8);\n    if (!seen[k]) {\n      seen[k] = 1;\n      pins.push([x, y]);\n    }\n  };\n  for (let li = 0; li \u003c word.length && li \u003c 4; li++) {\n    const strokes = LETTERS[word[li]].split(\"|\").map((s) => s.split(\" \").map(Number));\n    const [cx, cy] = CELLS[li], mine = [];\n    for (const a of strokes) {\n      // Where the other strokes meet this one, as fractions along it.\n      const cuts = [0, 1];\n      const dx = a[2] - a[0], dy = a[3] - a[1];\n      for (const b of strokes) {\n        if (b === a) continue;\n        const ex = b[2] - b[0], ey = b[3] - b[1], den = dx * ey - dy * ex;\n        if (abs(den) \u003c 1e-9) continue;\n        const fx = b[0] - a[0], fy = b[1] - a[1];\n        const ta = (fx * ey - fy * ex) / den, tb = (fx * dy - fy * dx) / den;\n        if (ta > 1e-6 && ta \u003c 1 - 1e-6 && tb > -1e-6 && tb \u003c 1 + 1e-6) cuts.push(ta);\n      }\n      cuts.sort((p, q) => p - q);\n      for (let i = 1; i \u003c cuts.length; i++) {\n        if (cuts[i] - cuts[i - 1] \u003c 1e-6) continue;\n        const ax = cx + (a[0] + dx * cuts[i - 1]) * UX, ay = cy + (a[1] + dy * cuts[i - 1]) * UY;\n        const bx = cx + (a[0] + dx * cuts[i]) * UX, by = cy + (a[1] + dy * cuts[i]) * UY;\n        const l = sqrt((bx - ax) ** 2 + (by - ay) ** 2);\n        mine.push({ ax, ay, bx, by, l, ex: (bx - ax) / l, ey: (by - ay) / l, t: 1e9, sign: mine.length & 1 ? 1 : -1, rank: 0, li });\n        pin(ax, ay);\n        pin(bx, by);\n      }\n    }\n    // A letter is a chord rolled from its lowest note, the longest string.\n    mine.sort((p, q) => q.l - p.l);\n    for (const s of mine) strings.push(s);\n  }\n  let lmin = 1e9, lmax = 0;\n  for (const s of strings) {\n    lmin = min(lmin, s.l);\n    lmax = max(lmax, s.l);\n  }\n  for (const s of strings) s.rank = (log(s.l) - log(lmin)) / (log(lmax / lmin) || 1);\n  // The score: when each string is plucked, in seconds at Speed 2.\n  const score = [];\n  let at = 0, li = -1;\n  for (let i = 0; i \u003c strings.length; i++) {\n    if (i) at += strings[i].li !== li ? NEXT : NOTE;\n    li = strings[i].li;\n    score.push(at);\n  }\n  S.strings = strings;\n  S.pins = pins;\n  S.score = score;\n  S.cycle = at + REST;\n  S.clk = 0;\n  S.next = 0;\n}\n\nexport function setup(params) {\n  params.s = { buf: new Float32Array(W * H * 3), hue: 0, word: -1, p: 0.47, clk: 0, next: 0, strings: [], pins: [], score: [], cycle: 1, c: [0, 0, 0], g: [0, 0, 0], w: [0, 0, 0], xs: new Float32Array(8), ys: new Float32Array(8) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const wi = round(cl(k[2] || 0, 0, WORDS.length - 1));\n  S.p = 0.5 - 0.44 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (wi !== S.word) {\n    S.word = wi;\n    build(S, WORDS[wi]);\n  }\n  const step = (d * speed) / 2;\n  for (const s of S.strings) s.t += step;\n  // Pluck every string whose time came in this step.\n  let left = step;\n  while (left > 0) {\n    const due = S.score[S.next] - S.clk;\n    if (due > left) {\n      S.clk += left;\n      break;\n    }\n    S.clk += due;\n    left -= due;\n    const s = S.strings[S.next];\n    s.t = left;\n    s.sign = -s.sign;\n    S.next++;\n    if (S.next >= S.score.length) {\n      // The rest after the word, then from the top.\n      S.next = 0;\n      S.clk -= S.cycle;\n    }\n  }\n}\n\nfunction seg(S, x0, y0, x1, y1, w, c) {\n  const buf = S.buf, len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, Math.ceil(len / 6));\n  for (let i = 0; i \u003c n; i++) {\n    const ax = x0 + ((x1 - x0) * i) / n, ay = y0 + ((y1 - y0) * i) / n, bx = x0 + ((x1 - x0) * (i + 1)) / n, by = y0 + ((y1 - y0) * (i + 1)) / n;\n    const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1e-9, e = w / 2 + 0.5;\n    for (let y = max(0, floor(min(ay, by) - e)); y \u003c= min(H - 1, floor(max(ay, by) + e)); y++)\n      for (let x = max(0, floor(min(ax, bx) - e)); x \u003c= min(W - 1, floor(max(ax, bx) + e)); x++) {\n        const px = x + 0.5 - ax, py = y + 0.5 - ay, t = cl((px * dx + py * dy) / L2, 0, 1);\n        const ex = px - t * dx, ey = py - t * dy, a = cl(e - sqrt(ex * ex + ey * ey), 0, 1);\n        if (a \u003c= 0) continue;\n        const p = (y * W + x) * 3;\n        if (c[0] * a > buf[p]) buf[p] = c[0] * a;\n        if (c[1] * a > buf[p + 1]) buf[p + 1] = c[1] * a;\n        if (c[2] * a > buf[p + 2]) buf[p + 2] = c[2] * a;\n      }\n  }\n}\n\nfunction bead(S, x0, y0, r, c) {\n  const buf = S.buf;\n  for (let y = max(0, floor(y0 - r - 1)); y \u003c= min(H - 1, floor(y0 + r + 1)); y++)\n    for (let x = max(0, floor(x0 - r - 1)); x \u003c= min(W - 1, floor(x0 + r + 1)); x++) {\n      const ex = x + 0.5 - x0, ey = y + 0.5 - y0, a = cl(r + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (a \u003c= 0) continue;\n      const p = (y * W + x) * 3;\n      buf[p] += (c[0] - buf[p]) * a;\n      buf[p + 1] += (c[1] - buf[p + 1]) * a;\n      buf[p + 2] += (c[2] - buf[p + 2]) * a;\n    }\n}\n\n// The odd, 2l-periodic extension of the plucked triangle, peak 1 at x = q.\nfunction tri(x, l, q) {\n  x -= floor(x / (2 * l)) * 2 * l;\n  if (x > l) return -tri(2 * l - x, l, q);\n  return x \u003c q ? x / q : (l - x) / (l - q);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  S.buf.fill(0);\n  const c = S.c, xs = S.xs, ys = S.ys, ghost = S.g, white = S.w;\n  for (const s of S.strings) {\n    const env = exp(-s.t / RING), fl = exp(-s.t / FLASH);\n    hsv(S.hue + 0.5 + 0.24 * s.rank, 0.78 - 0.6 * fl, min(1, 0.56 + 0.3 * env + 0.4 * fl), c);\n    const l = s.l, q = S.p * l, amp = s.sign * min(0.13 * l, 6) * env;\n    const nx = -s.ey, ny = s.ex;\n    if (abs(amp) \u003c 0.04) {\n      seg(S, s.ax, s.ay, s.bx, s.by, 2.2, c);\n      continue;\n    }\n    // The rest line, faint under the moving string.\n    hsv(S.hue + 0.5 + 0.24 * s.rank, 0.7, 0.16, ghost);\n    seg(S, s.ax, s.ay, s.bx, s.by, 1.6, ghost);\n    // The kinks inside the string: +-ct +- pl, reduced mod 2l.\n    const ct = (s.t * WAVE) % (2 * l);\n    let n = 0;\n    xs[n++] = 0;\n    for (const k of [ct + q, ct - q, -ct + q, -ct - q]) {\n      const x = k - floor(k / (2 * l)) * 2 * l;\n      if (x > 1e-3 && x \u003c l - 1e-3) xs[n++] = x;\n    }\n    xs[n++] = l;\n    // Sort the few vertices in place.\n    for (let i = 1; i \u003c n; i++)\n      for (let j = i; j > 0 && xs[j] \u003c xs[j - 1]; j--) {\n        const t = xs[j];\n        xs[j] = xs[j - 1];\n        xs[j - 1] = t;\n      }\n    for (let i = 0; i \u003c n; i++) ys[i] = (amp * (tri(xs[i] - ct, l, q) + tri(xs[i] + ct, l, q))) / 2;\n    for (let i = 1; i \u003c n; i++)\n      seg(S, s.ax + s.ex * xs[i - 1] + nx * ys[i - 1], s.ay + s.ey * xs[i - 1] + ny * ys[i - 1], s.ax + s.ex * xs[i] + nx * ys[i], s.ay + s.ey * xs[i] + ny * ys[i], 2.2, c);\n    // The kinks as beads, while the swing is still worth watching.\n    white[0] = white[1] = min(1, 1.6 * env);\n    white[2] = white[0] * 0.92 + 0.08;\n    if (env > 0.2) for (let i = 1; i \u003c n - 1; i++) bead(S, s.ax + s.ex * xs[i] + nx * ys[i], s.ay + s.ey * xs[i] + ny * ys[i], 1 + 1.3 * fl, white);\n  }\n  for (const p of S.pins) bead(S, p[0], p[1], 0.9, PIN);\n  const buf = S.buf;\n  for (let i = 0; i \u003c W * H; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","ruled-hyperboloid":"// ===== Patternflow pattern =====\n// Title:   Ruled Hyperboloid\n// Family:  space\n// Idea:    Two equal circles, one above the other, are joined by straight rods; the top circle twists against the bottom, so the rods stand as a cylinder, pull in to a hyperboloid with a waist, close to a double cone through one point and open again, while the rods twisted the other way, the surface's second ruling, cross them into the lattice of a Shukhov tower that fills the panel's height and slowly turns.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hyperboloid of one sheet swept by a straight line turned about an axis it does not meet (Christopher Wren, 1669), built in straight bars by Vladimir Shukhov from 1896, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rods=16..48, Ruling=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the first ruling is azure, the second violet and the waist ring pale gold; at 0.5 the rulings are orange and green and the waist ring pale blue.\n// Knob 2: Speed. At 2 the twist breathes from cylinder to cone and back in 12 s and the tower turns once in 20 s; every time goes as 2 / Speed.\n// Knob 3: Rods. Rods in each ruling, 16 at the opening and up to 48: 32 to 96 straight lines in all.\n// Knob 4: Ruling. How the two rulings share the light. At 0 both are full; the opening 0.06 dims the second to 94%. At 1 only the first ruling is left, the rods twisted one way, and at -1 only the second, the same surface twisted the other way.\n\n// Join a circle of radius R at the bottom to an equal one at the top by a\n// straight rod from angle phi below to angle phi + theta above. At\n// theta = 0 the rods stand upright and sweep a cylinder. For 0 \u003c theta \u003c pi\n// every rod passes the axis at the distance R cos(theta / 2), at mid\n// height, and together they sweep a hyperboloid of one sheet whose waist\n// is that circle. At theta = pi each rod goes straight through the axis and\n// the rods meet at one point: a double cone. Rods from phi to phi - theta\n// sweep the very same surface, so the hyperboloid holds two families of\n// straight lines, its two rulings, and through each of its points passes\n// one line of each. Shukhov's towers are this: two sets of straight bars,\n// leaning opposite ways, joined where they cross.\n//\n// At theta = 0 and at theta = pi the two rulings fall on the same lines,\n// so the lattice closes to a single set of rods at both ends of the breath.\n//\n// The tower is seen in perspective from four fifths of the way up its\n// height, so the top circle shows its underside and the bottom one its top.\n// The near rods are bright and the far ones dim, each rod shaded along its\n// length by how near each part of it comes.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, sin, cos, sqrt, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\nconst ONE = [1, 1, 1];\n\n// Radius 1, half height HH, eye at distance D from the axis, the view\n// tilted down by TILT radians.\nconst HH = 1.85, D = 7, TILT = 0.16;\nconst CT = cos(TILT), ST = sin(TILT);\n\n// Fit both circles into the panel, rows 1.5 to 126.5 and columns 2 to 62.\nlet K = 1, CX = 32, CY = 64;\n{\n  let y0 = 1e9, y1 = -1e9, x1 = 0;\n  for (let i = 0; i \u003c 360; i++) {\n    const a = (i * TAU) / 360, x = cos(a), z = sin(a);\n    for (const y of [-HH, HH]) {\n      const yc = y * CT - z * ST, s = 1 / (D - (y * ST + z * CT));\n      y0 = min(y0, yc * s);\n      y1 = max(y1, yc * s);\n      x1 = max(x1, x * s);\n    }\n  }\n  K = min(125 / (y1 - y0), 30 / x1);\n  CY = 1.5 + K * y1 + (125 - K * (y1 - y0)) / 2;\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// Add colour c times a to the four LEDs around (x, y), bilinear.\nfunction splat(buf, x, y, c, a) {\n  x -= 0.5;\n  y -= 0.5;\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++) {\n    const yy = iy + j;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = j ? fy : 1 - fy;\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = a * wy * (i ? fx : 1 - fx), p = (yy * W + xx) * 3;\n      buf[p] += c[0] * w;\n      buf[p + 1] += c[1] * w;\n      buf[p + 2] += c[2] * w;\n    }\n  }\n}\n\n// How near a point is: 0 at the far side of the circle, 1 at the near side,\n// and the light it gets from that.\nconst shade = (z) => {\n  const d = cl((z + 1) / 2, 0, 1);\n  return 0.16 + 0.84 * d * sqrt(d);\n};\n\n// A straight piece of the world from (ax, ay, az) to (bx, by, bz), drawn as\n// a line one LED thick, each step lit by its own nearness.\nconst P = [0, 0];\nfunction project(x, y, z) {\n  const s = 1 / (D - (y * ST + z * CT));\n  P[0] = CX + K * x * s;\n  P[1] = CY - K * (y * CT - z * ST) * s;\n}\nfunction piece(buf, ax, ay, az, bx, by, bz, c, a) {\n  project(ax, ay, az);\n  const sx = P[0], sy = P[1];\n  project(bx, by, bz);\n  const len = sqrt((P[0] - sx) ** 2 + (P[1] - sy) ** 2), n = max(1, ceil(len * 1.6)), step = len / n;\n  for (let k = 0; k \u003c= n; k++) {\n    const t = k / n, z = az + (bz - az) * t;\n    project(ax + (bx - ax) * t, ay + (by - ay) * t, z);\n    splat(buf, P[0], P[1], c, a * shade(z) * step * (k === 0 || k === n ? 0.5 : 1));\n  }\n}\n\n// A horizontal circle of radius r at height y.\nfunction ring(buf, r, y, c, a) {\n  if (r \u003c 0.02) {\n    project(0, y, 0);\n    splat(buf, P[0], P[1], c, a * 2);\n    return;\n  }\n  const n = max(8, ceil(r * 40));\n  for (let i = 0; i \u003c n; i++) {\n    const a0 = (i * TAU) / n, a1 = ((i + 1) * TAU) / n;\n    piece(buf, r * cos(a0), y, r * sin(a0), r * cos(a1), y, r * sin(a1), c, a);\n  }\n}\n\nexport function setup(params) {\n  // The breath opens on a waist, a third of the way from cylinder to cone.\n  params.s = { buf: new Float32Array(W * H * 3), mask: new Float32Array(W * H * 3), breath: 1.16, spin: 0.3, hue: 0, rods: 16, w1: 1, w2: 0.94 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.rods = round(cl(k[2] || 16, 16, 48));\n  const r = cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  S.w1 = min(1, 1 + r);\n  S.w2 = min(1, 1 - r);\n  S.breath = (S.breath + (d * speed * TAU) / 24) % TAU;\n  S.spin = (S.spin + (d * speed * TAU) / 40) % TAU;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf;\n  buf.fill(0);\n  const theta = PI * (0.5 - 0.5 * cos(S.breath));\n  const c1 = hsv(S.hue + 0.57, 0.7, 1), c2 = hsv(S.hue + 0.78, 0.6, 1), cw = hsv(S.hue + 0.13, 0.4, 1);\n  const n = S.rods, lit = 1.35;\n\n  for (let i = 0; i \u003c n; i++) {\n    const p = S.spin + (i * TAU) / n, bx = cos(p), bz = sin(p);\n    if (S.w1 > 0.004) piece(buf, bx, -HH, bz, cos(p + theta), HH, sin(p + theta), c1, lit * S.w1);\n    if (S.w2 > 0.004) piece(buf, bx, -HH, bz, cos(p - theta), HH, sin(p - theta), c2, lit * S.w2);\n  }\n\n  // The two circles the rods hang between, and the waist they pull in to.\n  const pale = [(c1[0] + c2[0]) * 0.5, (c1[1] + c2[1]) * 0.5, (c1[2] + c2[2]) * 0.5];\n  ring(buf, 1, HH, pale, 0.7);\n  ring(buf, 1, -HH, pale, 0.7);\n\n  // The waist ring is laid over the rods rather than added to them, so it\n  // keeps its own colour where the lattice is thickest.\n  const m = S.mask;\n  m.fill(0);\n  ring(m, cos(theta / 2), 0, ONE, 2.2);\n  for (let i = 0; i \u003c W * H; i++) {\n    const a = cl(m[i * 3], 0, 1), p = i * 3;\n    display.setPixel(\n      i % W,\n      floor(i / W),\n      round(cl(buf[p] + (cw[0] * a * 1.6 - buf[p]) * a, 0, 1) * 255),\n      round(cl(buf[p + 1] + (cw[1] * a * 1.6 - buf[p + 1]) * a, 0, 1) * 255),\n      round(cl(buf[p + 2] + (cw[2] * a * 1.6 - buf[p + 2]) * a, 0, 1) * 255),\n    );\n  }\n}\n","wheel-cypher":"// ===== Patternflow pattern =====\n// Title:   Wheel Cypher\n// Family:  type\n// Idea:    A cylinder of 25 polished discs stands up the panel, each with its own scrambled alphabet painted round the rim; one disc at a time from the top turns until a 25-letter message reads down one line in amber, the line a set number of letters round then lights in violet as the ciphertext, a clerk's slip down each side carries the plaintext and the ciphertext, and the discs spin away for the next message.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: wheel cypher (Thomas Jefferson, about 1795), reinvented as Étienne Bazeries's cylinder (1891) and issued as the US Army M-94 of 25 aluminium discs (1922); the 25 alphabets are scrambled for this pattern from a fixed seed, not the M-94's, and the 3 by 4 capitals are drawn for it, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Message=0..5, Line=1..5\n//\n// Knob 1: Hue. Tints the metal and turns the two lit lines with it. At 0 the metal is steel blue, the plaintext amber and the ciphertext violet; at 0.25 the metal is mauve, the lines green and red orange; at 0.5 the metal is bronze, the lines azure and green; at 0.75 the metal is sage, the lines magenta and cyan. The paint on the letters stays white and the slips stay cream.\n// Knob 2: Speed. At 2 a disc turns in 0.3 s, so the 25 are set in 7.5 s; after a 0.5 s pause the ciphertext is read off at 0.06 s a letter, the finished message holds 3 s and the discs spin away in 1.3 s, a message every 13.9 s. Every time goes as 2 / Speed.\n// Knob 3: Message. 0 ANYOTHERLINEISACIPHERTEXT, 1 TURNEACHWHEELUNTILITREADS, 2 ATTACKATDAWNHOLDTHEBRIDGE, 3 MEETMEATTHEMILLATMIDNIGHT, 4 SENDMOREMENTOTHEEASTRIDGE, 5 NOWISTHETIMEFORALLGOODMEN, and after each the next. A fresh start opens for 3.3 s on the message before, set and enciphered. Turning it sets the new message at once from the top disc, from wherever the discs stand.\n// Knob 4: Line. How many letters round from the plaintext the ciphertext lies, to the right, 1 to 5. The whole cylinder stands turned by half that, so the two lines face the front from either side: at the opening 1 they are the two lines next to the front, both one LED to a glyph column; at 5 they stand 2.5 letters either side, 35 degrees round, where the letters are foreshortened to 0.82. Turning it turns the whole cylinder there in about 0.3 s.\n\n// Each disc carries the 26 capitals round its rim in its own order. Turn\n// the discs, one by one, until the message reads along one line of the\n// cylinder; every other line of 25 letters is then a ciphertext of it, and\n// the sender copies one. The receiver, with the same discs in the same\n// order on the spindle, sets that ciphertext along a line and looks round\n// the cylinder for the one line that reads. Here the order of the discs is\n// fixed and the line is the knob.\n//\n// The cylinder is drawn as it would look: a letter cell 6.04 LEDs wide at\n// the front, and each LED column covering the stretch of rim between the\n// angles its two edges see, so letters thin as the cosine towards the\n// sides and blur into the rim's grain at its edges. Ink is averaged over\n// that stretch exactly, from a running sum round each disc.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, asin, sin, cos, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// The cylinder: 25 discs of 5 rows, 4 of letters and a chamfer, from row 1;\n// the axis through the middle of LED column 31, radius 25 LEDs, so a letter\n// cell at the front is 6.04 LEDs wide and a glyph column 1.007.\nconst DISCS = 25, PITCH = 5, TOP = 1, R = 25, XC = 31.5, CELL = (2 * PI) / 26, SLOTS = 26 * 12;\n\n// Capitals 3 wide and 4 tall, rows from the top.\nconst GLYPHS = {\n  A: [\".#.\", \"#.#\", \"###\", \"#.#\"], B: [\"##.\", \"###\", \"#.#\", \"###\"], C: [\".##\", \"#..\", \"#..\", \".##\"],\n  D: [\"##.\", \"#.#\", \"#.#\", \"##.\"], E: [\"###\", \"##.\", \"#..\", \"###\"], F: [\"###\", \"#..\", \"##.\", \"#..\"],\n  G: [\".##\", \"#..\", \"#.#\", \".##\"], H: [\"#.#\", \"###\", \"#.#\", \"#.#\"], I: [\"###\", \".#.\", \".#.\", \"###\"],\n  J: [\"..#\", \"..#\", \"#.#\", \".#.\"], K: [\"#.#\", \"##.\", \"#.#\", \"#.#\"], L: [\"#..\", \"#..\", \"#..\", \"###\"],\n  M: [\"###\", \"###\", \"#.#\", \"#.#\"], N: [\"##.\", \"#.#\", \"#.#\", \"#.#\"], O: [\".#.\", \"#.#\", \"#.#\", \".#.\"],\n  P: [\"###\", \"#.#\", \"###\", \"#..\"], Q: [\".#.\", \"#.#\", \"#.#\", \".##\"], R: [\"###\", \"#.#\", \"##.\", \"#.#\"],\n  S: [\".##\", \"#..\", \"..#\", \"##.\"], T: [\"###\", \".#.\", \".#.\", \".#.\"], U: [\"#.#\", \"#.#\", \"#.#\", \"###\"],\n  V: [\"#.#\", \"#.#\", \"#.#\", \".#.\"], W: [\"#.#\", \"#.#\", \"###\", \"###\"], X: [\"#.#\", \".#.\", \".#.\", \"#.#\"],\n  Y: [\"#.#\", \"#.#\", \".#.\", \".#.\"], Z: [\"###\", \"..#\", \".#.\", \"###\"],\n};\nconst ABC = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\n// Six messages of exactly 25 letters, one per disc.\nconst MESSAGES = [\n  \"ANYOTHERLINEISACIPHERTEXT\", \"TURNEACHWHEELUNTILITREADS\", \"ATTACKATDAWNHOLDTHEBRIDGE\",\n  \"MEETMEATTHEMILLATMIDNIGHT\", \"SENDMOREMENTOTHEEASTRIDGE\", \"NOWISTHETIMEFORALLGOODMEN\",\n];\n\n// The 25 alphabets, shuffled by a fixed generator so every run has the same\n// cylinder. ALPHA[d][j] is the letter at place j round disc d, POS[d][c] the\n// place of letter c.\nconst ALPHA = [], POS = [];\n{\n  let a = 1922;\n  const rnd = () => {\n    a = (a + 0x6d2b79f5) | 0;\n    let t = Math.imul(a ^ (a >>> 15), 1 | a);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n  for (let d = 0; d \u003c DISCS; d++) {\n    const p = ABC.split(\"\");\n    for (let i = 25; i > 0; i--) {\n      const j = floor(rnd() * (i + 1));\n      const t = p[i];\n      p[i] = p[j];\n      p[j] = t;\n    }\n    ALPHA.push(p);\n    const q = {};\n    p.forEach((c, j) => (q[c] = j));\n    POS.push(q);\n  }\n}\n\n// Round each disc the ink of glyph row r in twelfths of a cell, summed so\n// any stretch of the rim can be averaged in two lookups. A cell runs from\n// twelfth 0 to 12 with the letter centred, its three columns at 3..9.\nconst INK = [];\nfor (let d = 0; d \u003c DISCS; d++)\n  for (let r = 0; r \u003c 4; r++) {\n    const P = new Float32Array(SLOTS + 1);\n    for (let s = 0; s \u003c SLOTS; s++) {\n      const j = floor(s / 12), k = s % 12, g = GLYPHS[ALPHA[d][j]][r];\n      P[s + 1] = P[s] + (k >= 3 && k \u003c 9 && g[floor((k - 3) / 2)] === \"#\" ? 1 : 0);\n    }\n    INK.push(P);\n  }\nconst inkAt = (P, s) => {\n  const turns = floor(s / SLOTS), u = s - turns * SLOTS, i = floor(u);\n  return turns * P[SLOTS] + P[i] + (P[i + 1] - P[i]) * (u - i);\n};\n\n// Small integer hash for the grain of metal, paint and paper.\nfunction hash(a, b) {\n  let h = Math.imul(a ^ 0x9e3779b9, 0x85ebca6b) ^ Math.imul(b + 0x632be5ab, 0xc2b2ae35);\n  h ^= h >>> 15;\n  h = Math.imul(h, 0x2c1b3c6d);\n  h ^= h >>> 12;\n  return (h >>> 0) / 4294967296;\n}\n// Grain in three steps, -0.5, 0 or 0.5: as rough to the eye as smooth\n// noise, and far fewer distinct values on the panel.\nconst grain = (a, b) => floor(hash(a, b) * 3) / 2 - 0.5;\n\n// The rim is polished, so at angle th from the front it shows the room at\n// 2 th: a lamp-lit wall drawn as two waves in that angle, 3.1 and 9.7 to a\n// radian, under a little diffuse light from the lamp up on the left. Each\n// disc sits a hair off true and its reflection jogs by up to 0.15 radian\n// against its neighbours. The rim's four rows of letters fall from a bright\n// top bevel to a dark bottom one, LATHE varies each row's turning a little,\n// and the fifth row is the chamfer between two discs.\nconst ENV = [0.38, 0.22, 3.1, 0.4, 0.16, 9.7, 1.3], DIFF = 0.12, JOG = 0.15, LATHE = 0.1;\nconst BEVEL = [1.15, 1, 0.86, 0.72, 0.4], CHAMFER = 0.5, CAP = [0.6, 0.55, 0.35];\n// The letters are stamped and filled with white paint, which is matte: it\n// takes the lamp, not the reflections. PGRAIN is its unevenness.\nconst MATTE = 0.85, PGRAIN = 0.17;\n// The slips: paper level, its fibre, the rules, the shadow of the cylinder\n// on the column beside it, and pencil lead.\nconst PAPER = 0.7, FIBRE = 0.22, RULE = 0.2, SHADOW = 0.35, LEAD = 0.09;\n\n// Each LED column's stretch of the rim in cells from the front, its centre,\n// how much of it the cylinder covers, the paint's light there, and per disc\n// the light on the metal.\nconst COL = [], LIGHT = new Float32Array(DISCS * W);\nfor (let x = 0; x \u003c W; x++) {\n  const s0 = (x - XC) / R, s1 = (x + 1 - XC) / R, sc = (x + 0.5 - XC) / R;\n  const cover = cl(min(x + 1, XC + R) - max(x, XC - R), 0, 1);\n  if (cover \u003c= 0) {\n    COL.push(null);\n    continue;\n  }\n  const th = asin(cl(sc, -1, 1));\n  COL.push({ a0: asin(cl(s0, -1, 1)) / CELL, a1: asin(cl(s1, -1, 1)) / CELL, ac: th / CELL, cover, matte: MATTE + (1 - MATTE) * cos(th - 0.35) });\n  for (let d = 0; d \u003c DISCS; d++) {\n    const f = 2 * th + JOG * (hash(d, 77) - 0.5) * 2;\n    const env = ENV[0] + ENV[1] * sin(ENV[2] * f + ENV[3]) + ENV[4] * sin(ENV[5] * f + ENV[6]);\n    LIGHT[d * W + x] = (1 - DIFF) * env + DIFF * cos(th - 0.35);\n  }\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// Seconds at Speed 2: a disc's turn, the pause before the ciphertext, one\n// cipher letter, the hold on a finished message, the spin away.\nconst TURN = 0.3, PAUSE = 0.5, CIPH = 0.06, HOLD = 3, SPIN = 1.3, OPEN = 3.3;\n\nconst wrap = (v) => ((v % 26) + 26) % 26;\nconst shortest = (from, to) => {\n  let d = wrap(to - from);\n  if (d > 13) d -= 26;\n  return d;\n};\n\nfunction setMessage(S, m) {\n  S.m = ((m % MESSAGES.length) + MESSAGES.length) % MESSAGES.length;\n  S.msg = MESSAGES[S.m];\n  S.target = [];\n  for (let d = 0; d \u003c DISCS; d++) S.target.push(POS[d][S.msg[d]]);\n}\n\nfunction beginSet(S) {\n  S.phase = \"set\";\n  S.i = 0;\n  S.tau = 0;\n  S.set = 0;\n  S.ciph = 0;\n  S.from = S.phi[0];\n}\n\nexport function setup(params) {\n  const S = { phi: new Float32Array(DISCS), blur: new Float32Array(DISCS), spin0: new Float32Array(DISCS), spinD: new Float32Array(DISCS) };\n  S.knob = -1;\n  S.line = 1;\n  S.turn = -1;\n  S.dturn = 0;\n  S.hue = 0;\n  S.speed = 2;\n  S.buf = new Float32Array(W * H * 3);\n  params.s = S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.line = round(cl(k[3] == null ? 1 : k[3], 1, 5));\n  // The whole cylinder sits turned by half the line, so the plaintext and\n  // the ciphertext stand either side of the front; a new line turns it there.\n  const turn0 = S.turn;\n  S.turn = S.turn \u003c 0 ? S.line / 2 : S.turn + (S.line / 2 - S.turn) * min(1, (d * S.speed) / 2 / 0.12);\n  S.dturn = abs(S.turn - turn0) * (turn0 \u003c 0 ? 0 : 1);\n  const km = round(cl(k[2] || 0, 0, 5));\n  if (km !== S.knob) {\n    if (S.knob \u003c 0) {\n      // A fresh start opens on the message before, set and enciphered.\n      setMessage(S, km - 1);\n      for (let i = 0; i \u003c DISCS; i++) S.phi[i] = S.target[i];\n      S.phase = \"hold\";\n      S.tau = HOLD - OPEN;\n      S.set = DISCS;\n      S.ciph = DISCS;\n      S.next = km;\n    } else {\n      setMessage(S, km);\n      S.next = null;\n      beginSet(S);\n    }\n    S.knob = km;\n  }\n  const old = Float32Array.from(S.phi);\n  S.tau += (d * S.speed) / 2;\n  if (S.phase === \"set\") {\n    const delta = shortest(S.from, S.target[S.i]);\n    S.phi[S.i] = S.from + delta * smooth(S.tau / TURN);\n    if (S.tau >= TURN) {\n      S.phi[S.i] = S.target[S.i];\n      S.set = ++S.i;\n      S.tau = 0;\n      if (S.i >= DISCS) S.phase = \"pause\";\n      else S.from = S.phi[S.i];\n    }\n  } else if (S.phase === \"pause\") {\n    if (S.tau >= PAUSE) {\n      S.phase = \"cipher\";\n      S.tau = 0;\n    }\n  } else if (S.phase === \"cipher\") {\n    S.ciph = min(DISCS, floor(S.tau / CIPH) + 1);\n    if (S.tau >= CIPH * DISCS) {\n      S.phase = \"hold\";\n      S.tau = 0;\n    }\n  } else if (S.phase === \"hold\") {\n    if (S.tau >= HOLD) {\n      S.phase = \"spin\";\n      S.tau = 0;\n      // The slip keeps this ciphertext in lead until the next is inked over it.\n      S.old = \"\";\n      for (let i = 0; i \u003c DISCS; i++) S.old += ALPHA[i][wrap(S.target[i] + S.line)];\n      S.set = 0;\n      S.ciph = 0;\n      for (let i = 0; i \u003c DISCS; i++) {\n        S.spin0[i] = S.phi[i];\n        // Each disc flicked by hand: 4 to 11 letters either way.\n        S.spinD[i] = (Math.random() \u003c 0.5 ? -1 : 1) * (4 + Math.random() * 7);\n      }\n    }\n  } else if (S.phase === \"spin\") {\n    for (let i = 0; i \u003c DISCS; i++) {\n      const u = cl((S.tau / SPIN) * 1.25 - (i / DISCS) * 0.25, 0, 1);\n      S.phi[i] = S.spin0[i] + S.spinD[i] * (1 - pow(1 - u, 3));\n    }\n    if (S.tau >= SPIN) {\n      setMessage(S, S.next == null ? S.m + 1 : S.next);\n      S.next = null;\n      beginSet(S);\n    }\n  }\n  for (let i = 0; i \u003c DISCS; i++) S.blur[i] = abs(S.phi[i] - old[i]) + S.dturn;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf;\n  buf.fill(0);\n  const h = S.hue + 0.58;\n  const metal = hsv(h, 0.16, 1), paint = hsv(h + 0.5, 0.06, 1), amber = hsv(h + 0.5, 0.75, 1), violet = hsv(h + 0.22, 0.6, 1);\n  const line = S.line;\n\n  for (let d = 0; d \u003c DISCS; d++) {\n    const y0 = TOP + d * PITCH, phi = S.phi[d] + S.turn, blur = S.blur[d] * 12;\n    const plain = d \u003c S.set, ciph = d \u003c S.ciph;\n    const jp = S.target[d], jc = wrap(jp + line), lathe = [];\n    for (let r = 0; r \u003c PITCH; r++) lathe.push(1 + LATHE * (hash(d * 8 + r, 999) - 0.5));\n    for (let x = 0; x \u003c W; x++) {\n      const C = COL[x];\n      if (!C) continue;\n      const sL = (C.a0 + phi + 0.5) * 12, sR = (C.a1 + phi + 0.5) * 12 + blur, span = max(1e-6, sR - sL);\n      const uc = C.ac + phi, j = wrap(round(uc)), slot = floor(wrap(uc + 0.5) * 12);\n      const litP = plain && j === jp, litC = ciph && j === jc;\n      for (let r = 0; r \u003c PITCH; r++) {\n        const p = ((y0 + r) * W + x) * 3;\n        let b = LIGHT[d * W + x] * BEVEL[r] * lathe[r];\n        if (r === 4) b *= 1 + CHAMFER * grain(d * 8 + 4, slot);\n        let cr = metal[0] * b, cg = metal[1] * b, cb = metal[2] * b;\n        if (r \u003c 4) {\n          const P = INK[d * 4 + r], ink = (inkAt(P, sR) - inkAt(P, sL)) / span;\n          if (litP || litC) {\n            // A lit line: its cells washed in the colour, its letters in it.\n            const g = litP ? amber : violet, wash = 0.35;\n            cr += (g[0] * wash * b - cr * wash) + (g[0] - cr) * ink;\n            cg += (g[1] * wash * b - cg * wash) + (g[1] - cg) * ink;\n            cb += (g[2] * wash * b - cb * wash) + (g[2] - cb) * ink;\n          } else if (ink > 0) {\n            const v = C.matte * (1 + PGRAIN * grain(d * 8 + r + 9000, slot));\n            cr += (paint[0] * v - cr) * ink;\n            cg += (paint[1] * v - cg) * ink;\n            cb += (paint[2] * v - cb) * ink;\n          }\n        }\n        buf[p] = cr * C.cover;\n        buf[p + 1] = cg * C.cover;\n        buf[p + 2] = cb * C.cover;\n      }\n    }\n  }\n\n  // The end plates: one row on top, the bottom plate and its foot below.\n  for (const [y, k] of [[0, CAP[0]], [H - 2, CAP[1]], [H - 1, CAP[2]]])\n    for (let x = 0; x \u003c W; x++) {\n      const C = COL[x];\n      if (!C) continue;\n      const b = LIGHT[x] * k * (1 + CHAMFER * grain(y + 31, x)) * C.cover, p = (y * W + x) * 3;\n      buf[p] = metal[0] * b;\n      buf[p + 1] = metal[1] * b;\n      buf[p + 2] = metal[2] * b;\n    }\n\n  // The clerk's slips: the plaintext written down the left one from the\n  // start, each letter inked amber once its disc is set, and the ciphertext\n  // written down the right one in violet as it is read off.\n  const paper = hsv(0.11, 0.14, PAPER), lead = [LEAD, LEAD, LEAD * 1.1];\n  for (const [x0, x1] of [[0, 5], [57, 63]])\n    for (let y = 0; y \u003c H; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const p = (y * W + x) * 3, rule = (y - TOP) % PITCH === 4 ? 1 - RULE : 1;\n        // The column against the cylinder lies in its shadow.\n        const f = (x === 5 || x === 57 ? SHADOW : 1) * rule * (1 + FIBRE * grain(x * 131 + 7, y));\n        buf[p] = paper[0] * f;\n        buf[p + 1] = paper[1] * f;\n        buf[p + 2] = paper[2] * f;\n      }\n  // Ink takes the grain of the paper it lies on.\n  const glyph = (ch, x0, y0, c) => {\n    const g = GLYPHS[ch];\n    for (let r = 0; r \u003c 4; r++)\n      for (let i = 0; i \u003c 3; i++)\n        if (g[r][i] === \"#\") {\n          const x = x0 + i, y = y0 + r, p = (y * W + x) * 3, f = 1 + FIBRE * grain(x * 131 + 7, y);\n          buf[p] = c[0] * f;\n          buf[p + 1] = c[1] * f;\n          buf[p + 2] = c[2] * f;\n        }\n  };\n  for (let d = 0; d \u003c DISCS; d++) {\n    const y0 = TOP + d * PITCH;\n    glyph(S.msg[d], 1, y0, d \u003c S.set ? amber : lead);\n    if (d \u003c S.ciph) glyph(ALPHA[d][wrap(S.target[d] + line)], 59, y0, violet);\n    else if (S.old) glyph(S.old[d], 59, y0, lead);\n  }\n\n  for (let i = 0; i \u003c W * H; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","beam-letters":"// ===== Patternflow pattern =====\n// Title:   Beam Letters\n// Family:  type\n// Idea:    One electron beam writes a few short words stacked down the tall screen the way an oscilloscope in XY mode writes text, along the strokes of a single-stroke font at a limited slew rate and blanked as it jumps from one stroke to the next, so the phosphor glows hottest where the beam slows into corners, turns and stroke ends and stays dimmer along long fast strokes, the glow fades behind the spot, and the writing order shows as a bright sweep running line by line through the words until, with the beam fast enough, the text stands steady with a faint refresh shimmer.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: single-stroke fonts for vector displays and plotters after the Hershey fonts (Allen V. Hershey, U.S. Naval Weapons Laboratory, 1967), with letters drawn for this pattern as lines and arcs; phosphor persistence on a cathode-ray tube driven in XY mode; pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Phosphor=0..1, Speed=0.2..3, Persistence=0..1, Focus=0..1\n//\n// Knob 1: Phosphor. P31, the green of oscilloscopes, below 0.25; then P7, the radar phosphor whose blue-white flash leaves a long yellow-green afterglow; P11 blue from 0.5; P4, the white of black-and-white television, from 0.75.\n// Knob 2: Speed. How many steps of the beam's path go by a second. At 2 the beam's top speed is 3360 LEDs a second and LET THERE BE LIGHT is written 2.25 times a second, so a bright sweep runs line by line through words that stay readable behind it; at 3 the top speed is 66500 LEDs a second, the text is rewritten 44 times a second and stands steady; at 0.2 the beam crawls at 105 LEDs a second and takes 14 s over the four lines. Between those three the rate goes evenly in its logarithm. A message holds for 8 s, or one pass if that is longer.\n// Knob 3: Persistence. The phosphor's time constant: 0.1 s at 0, 0.32 s at a quarter, 1 s at a half, 3.2 s at three quarters and 10 s at 1. At the opening the line the beam left 0.3 s ago gives 5% of the light it gave as it was written; at a half the oldest line keeps 64% and the text stands nearly evenly; from three quarters on the light takes seconds to build and the old message stays under the new one, at 1 for longer than a message holds, so two or three lie over each other.\n// Knob 4: Focus. The spot's size, a Gaussian 0.55 LEDs wide (one sigma) up to the opening 0.06, growing to 2.4 LEDs at 1, where the lines bloom into soft bars and the letters only just read.\n\n// A vector display draws nothing but lines: the deflection plates steer one\n// spot, and the spot lights the phosphor wherever it goes while the beam is\n// on. Text on such a screen is a display list, letter after letter of short\n// polylines, and the beam is switched off (blanked) while it jumps from the\n// end of one stroke to the start of the next. Here each letter is a few\n// strokes of lines and arcs on a grid 24 units high, in the spirit of\n// Hershey's single-stroke Roman, and each line of a message is scaled to its\n// own width, as a stroke font can be.\n//\n// The deflection cannot move the spot at any speed. The beam has a top speed\n// and a top acceleration, so it slows down into every corner, the more the\n// sharper the turn, and comes to rest at both ends of a stroke, where it\n// waits a moment for the beam to switch. The beam current is constant, so\n// the energy a stretch of phosphor takes is the time the spot spends on it:\n// long fast strokes are faint, turns and stroke ends glow, and a dot is a\n// spot that only waits. The path is sampled once at equal steps of beam\n// time, and the Speed knob only says how many of those steps a second take.\n//\n// The phosphor stores the energy and gives it back as light, its store\n// decaying as exp(-t / tau), so the light it gives is the store over tau. A\n// short second component flashes for 0.035 s where the beam has just been:\n// on most phosphors a hotter, whiter tint, on P7 its blue. When the beam\n// writes the whole list many times within tau the screen shows the steady\n// average, the same brightness at every speed; when it writes slower than\n// tau only the last stretch glows and the writing order is there to read.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, exp, cos, sin, acos, hypot, ceil, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- The font. [advance width, strokes] on a grid 24 high, y down. M starts\n// a stroke, L draws to a point, A cx,cy,rx,ry,from,to draws an arc in\n// degrees (0 at the right, 90 at the bottom) on from the pen.\nconst GLYPHS = {\n  A: [16, \"M0,24 L8,0 L16,24 M3,16 L13,16\"],\n  B: [14, \"M0,24 L0,0 L8,0 A8,5.5,5.5,5.5,-90,90 L0,11 M8,11 A8,17.5,6,6.5,-90,90 L0,24\"],\n  C: [15, \"A8,12,8,12,-40,-320\"],\n  D: [15, \"M0,0 L0,24 L4,24 A4,12,11,12,90,-90 L0,0\"],\n  E: [13, \"M13,0 L0,0 L0,24 L13,24 M0,12 L10,12\"],\n  F: [13, \"M13,0 L0,0 L0,24 M0,12 L10,12\"],\n  G: [16, \"A8,12,8,12,-40,-360 L9,12\"],\n  H: [14, \"M0,0 L0,24 M14,0 L14,24 M0,12 L14,12\"],\n  I: [0, \"M0,0 L0,24\"],\n  J: [11, \"M11,0 L11,18 A5.5,18,5.5,6,0,180\"],\n  K: [14, \"M0,0 L0,24 M14,0 L0,16 M4.5,11 L14,24\"],\n  L: [12, \"M0,0 L0,24 L12,24\"],\n  M: [18, \"M0,24 L0,0 L9,24 L18,0 L18,24\"],\n  N: [15, \"M0,24 L0,0 L15,24 L15,0\"],\n  O: [16, \"A8,12,8,12,-90,270\"],\n  P: [14, \"M0,24 L0,0 L8,0 A8,6,6,6,-90,90 L0,12\"],\n  Q: [16, \"A8,12,8,12,-90,270 M10,18 L16,25\"],\n  R: [14, \"M0,24 L0,0 L8,0 A8,6,6,6,-90,90 L0,12 M7,12 L14,24\"],\n  S: [14, \"A7,6,6.5,6,-25,-270 A7,18,7,6,-90,155\"],\n  T: [14, \"M0,0 L14,0 M7,0 L7,24\"],\n  U: [14, \"M0,0 L0,17 A7,17,7,7,180,0 L14,0\"],\n  V: [16, \"M0,0 L8,24 L16,0\"],\n  W: [20, \"M0,0 L5,24 L10,6 L15,24 L20,0\"],\n  X: [14, \"M0,0 L14,24 M14,0 L0,24\"],\n  Y: [14, \"M0,0 L7,12 L14,0 M7,12 L7,24\"],\n  Z: [14, \"M0,0 L14,0 L0,24 L14,24\"],\n};\nconst GAP = 6;\n\n// The first words of four new ways to send words: Genesis 1:3, the first\n// telegraph line from Washington to Baltimore (Samuel Morse, 24 May 1844),\n// Alexander Graham Bell's first call to his assistant (10 March 1876), and\n// the first two letters of LOGIN that reached SRI from UCLA over the ARPANET\n// (29 October 1969) before the host there crashed.\nconst MESSAGES = [\n  [\"LET\", \"THERE\", \"BE\", \"LIGHT\"],\n  [\"WHAT\", \"HATH\", \"GOD\", \"WROUGHT\"],\n  [\"MR\", \"WATSON\", \"COME\", \"HERE\"],\n  [\"LO\"],\n];\nconst HOLD = 8;\n\n// Glyph strokes in its own units: an array of flat [x0, y0, x1, y1, ...].\nfunction glyphStrokes(src) {\n  const out = [];\n  let cur = null;\n  for (const tok of src.split(\" \")) {\n    const op = tok[0], a = tok.slice(1).split(\",\").map(Number);\n    if (op === \"M\") {\n      cur = [a[0], a[1]];\n      out.push(cur);\n    } else if (op === \"L\") cur.push(a[0], a[1]);\n    else {\n      const [cx, cy, rx, ry, a0, a1] = a, n = max(4, ceil(Math.abs(a1 - a0) / 15));\n      for (let i = 0; i \u003c= n; i++) {\n        const t = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, x = cx + rx * cos(t), y = cy + ry * sin(t);\n        if (i === 0 && cur && hypot(cur[cur.length - 2] - x, cur[cur.length - 1] - y) \u003c 0.01) continue;\n        if (i === 0 && !cur) {\n          cur = [];\n          out.push(cur);\n        }\n        cur.push(x, y);\n      }\n    }\n  }\n  return out;\n}\n\n// A message laid out on the panel: four lines 22 LEDs tall with 9 between,\n// or one line twice that, each line squeezed sideways to fit 60 LEDs.\nfunction layout(lines) {\n  const n = lines.length, capH = n === 1 ? 44 : floor((118 - (n - 1) * 9) / n), sy = capH / 24;\n  const strokes = [];\n  let y0 = (H - (n * capH + (n - 1) * 9)) / 2;\n  for (const line of lines) {\n    let uw = 0;\n    for (const ch of line) uw += GLYPHS[ch][0];\n    uw += GAP * (line.length - 1);\n    // A line too long for the width is squeezed, but to no less than 0.65\n    // of the font's own width; past that it is set smaller instead.\n    const sx = min(sy, 58 / uw), ly = min(sy, sx / 0.65), yl = y0 + ((sy - ly) * 24) / 2;\n    let ux = 0;\n    const x0 = (W - uw * sx) / 2;\n    for (const ch of line) {\n      for (const st of glyphStrokes(GLYPHS[ch][1])) {\n        const p = [];\n        for (let i = 0; i \u003c st.length; i += 2) p.push(x0 + (ux + st[i]) * sx, yl + st[i + 1] * ly);\n        strokes.push(p);\n      }\n      ux += GLYPHS[ch][0] + GAP;\n    }\n    y0 += capH + 9;\n  }\n  return strokes;\n}\n\n// ---- The beam. Units are LEDs and steps of beam time. The top speed is\n// VMAX LEDs a step and the deflection can stop from it within 3.5 LEDs;\n// a turn through angle a caps the speed at VMAX (1 - a / pi)^1.5, so a right\n// angle at 35% and the apex of the A at 10%. The beam rests DWELL steps on\n// at each end of a stroke, and a blanked jump runs at 1.7 VMAX and settles\n// for SETTLE steps.\nconst VMAX = 0.35, ACC = (VMAX * VMAX) / 7, VMIN = 0.02, DWELL = 8, VJUMP = 0.6, SETTLE = 3;\n\nfunction trace(strokes) {\n  const xs = [], ys = [];\n  let px = null, py = null;\n  const jump = (x1, y1) => {\n    const n = ceil(hypot(x1 - px, y1 - py) / VJUMP) + SETTLE;\n    for (let i = 0; i \u003c n; i++) {\n      xs.push(-1);\n      ys.push(-1);\n    }\n  };\n  for (const st of strokes) {\n    const n = st.length / 2;\n    if (px !== null) jump(st[0], st[1]);\n    const v = new Float64Array(n), len = new Float64Array(n);\n    for (let i = 0; i \u003c n - 1; i++) len[i] = hypot(st[2 * i + 2] - st[2 * i], st[2 * i + 3] - st[2 * i + 1]);\n    for (let i = 1; i \u003c n - 1; i++) {\n      const ax = st[2 * i] - st[2 * i - 2], ay = st[2 * i + 1] - st[2 * i - 1], bx = st[2 * i + 2] - st[2 * i], by = st[2 * i + 3] - st[2 * i + 1];\n      const c = (ax * bx + ay * by) / max(1e-9, hypot(ax, ay) * hypot(bx, by));\n      v[i] = VMAX * (1 - acos(cl(c, -1, 1)) / PI) ** 1.5;\n    }\n    for (let i = 1; i \u003c n; i++) v[i] = min(v[i], sqrt(v[i - 1] ** 2 + 2 * ACC * len[i - 1]));\n    for (let i = n - 2; i >= 0; i--) v[i] = min(v[i], sqrt(v[i + 1] ** 2 + 2 * ACC * len[i]));\n    for (let k = 0; k \u003c DWELL; k++) {\n      xs.push(st[0]);\n      ys.push(st[1]);\n    }\n    let s = 0;\n    for (let i = 0; i \u003c n - 1; i++) {\n      const l = len[i], v0 = v[i], v1 = v[i + 1];\n      if (l \u003c 1e-6) continue;\n      const vat = (q) => min(VMAX, sqrt(v0 * v0 + 2 * ACC * max(0, q)), sqrt(v1 * v1 + 2 * ACC * max(0, l - q)));\n      while (s \u003c l) {\n        const u = s / l;\n        xs.push(st[2 * i] + (st[2 * i + 2] - st[2 * i]) * u);\n        ys.push(st[2 * i + 1] + (st[2 * i + 3] - st[2 * i + 1]) * u);\n        s += max(VMIN, vat(s + 0.5 * vat(s)));\n      }\n      s -= l;\n    }\n    for (let k = 0; k \u003c DWELL; k++) {\n      xs.push(st[2 * n - 2]);\n      ys.push(st[2 * n - 1]);\n    }\n    px = st[2 * n - 2];\n    py = st[2 * n - 1];\n  }\n  // The retrace to the first stroke, blanked.\n  jump(strokes[0][0], strokes[0][1]);\n  return { xs: Float32Array.from(xs), ys: Float32Array.from(ys) };\n}\n\n// ---- Phosphors: the main glow's colour, the flash's colour and the flash's\n// share of the energy. Light is turned into a colour channel by channel as\n// 1 - exp(-light * weight), so a hot spot runs to white.\nconst PHOSPHORS = [\n  { m: [0.3, 1, 0.36], f: [0.75, 1, 0.8], ff: 0.35 }, // P31\n  { m: [0.55, 1, 0.12], f: [0.5, 0.72, 1], ff: 1.2 }, // P7\n  { m: [0.22, 0.6, 1.8], f: [0.9, 1.1, 1.8], ff: 0.35 }, // P11\n  { m: [0.82, 0.88, 1], f: [1, 1, 1], ff: 0.35 }, // P4\n];\nconst TAUF = 0.035, GAIN = 1700, CAP = 30000;\n// Steps a second: R0 at Speed 0.2, R2 at 2 and R3 at 3, evenly in the\n// logarithm between them.\nconst R0 = 300, R2 = 9600, R3 = 190000;\n\nexport function setup(params) {\n  params.s = {\n    paths: MESSAGES.map((m) => trace(layout(m))),\n    msg: 0, pos: 0, acc: 0, held: 0, sigma: 0.45,\n    E: new Float32Array(N), F: new Float32Array(N),\n    tm: new Float32Array(N), tf: new Float32Array(N), tmp: new Float32Array(N),\n    tau: 0.12, ph: PHOSPHORS[0],\n  };\n}\n\n// Separable Gaussian blur of a buffer in place: the spot.\nfunction blur(b, tmp, sigma) {\n  const r = max(1, ceil(sigma * 2.5)), k = [];\n  let sum = 0;\n  for (let i = -r; i \u003c= r; i++) {\n    const w = exp(-(i * i) / (2 * sigma * sigma));\n    k.push(w);\n    sum += w;\n  }\n  for (let i = 0; i \u003c k.length; i++) k[i] /= sum;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let a = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const xx = x + i;\n        if (xx >= 0 && xx \u003c W) a += b[y * W + xx] * k[i + r];\n      }\n      tmp[y * W + x] = a;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let a = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const yy = y + i;\n        if (yy >= 0 && yy \u003c H) a += tmp[yy * W + x] * k[i + r];\n      }\n      b[y * W + x] = a;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.ph = PHOSPHORS[min(3, floor(cl(k[0] || 0, 0, 1) * 4))];\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.tau = 0.1 * 100 ** cl(k[2] || 0, 0, 1);\n  // The spot is 0.55 LEDs up to the opening 0.06 and 2.4 LEDs at 1.\n  S.sigma = 0.55 + 1.85 * max(0, (cl(k[3] == null ? 0.06 : k[3], 0, 1) - 0.06) / 0.94) ** 1.3;\n  const R = speed \u003c= 2 ? R2 * (R0 / R2) ** ((2 - speed) / 1.8) : R2 * (R3 / R2) ** (speed - 2), tau = S.tau;\n  S.acc += d * R;\n  let n = floor(S.acc);\n  S.acc -= n;\n  S.held += d;\n  const tm = S.tm, tf = S.tf;\n  tm.fill(0);\n  tf.fill(0);\n  // Steps older than CAP are too faded to show: skip them unseen.\n  let skip = max(0, n - CAP);\n  n -= skip;\n  const q = 1 / R, rm = exp(1 / (R * tau)), rf = exp(1 / (R * TAUF)), ff = S.ph.ff;\n  let wm = q * exp(-(n - 1) / (R * tau)), wf = q * ff * exp(-(n - 1) / (R * TAUF));\n  let path = S.paths[S.msg];\n  const step = () => {\n    S.pos++;\n    if (S.pos >= path.xs.length) {\n      S.pos = 0;\n      if (S.held >= HOLD) {\n        S.held = 0;\n        S.msg = (S.msg + 1) % MESSAGES.length;\n        path = S.paths[S.msg];\n      }\n    }\n  };\n  while (skip-- > 0) step();\n  for (let i = 0; i \u003c n; i++) {\n    const x = path.xs[S.pos], y = path.ys[S.pos];\n    if (x >= 0) {\n      const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n      for (let j = 0; j \u003c 4; j++) {\n        const xx = x0 + (j & 1), yy = y0 + (j >> 1);\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const w = (j & 1 ? fx : 1 - fx) * (j >> 1 ? fy : 1 - fy), p = yy * W + xx;\n        tm[p] += wm * w;\n        tf[p] += wf * w;\n      }\n    }\n    wm *= rm;\n    wf *= rf;\n    step();\n  }\n  blur(tm, S.tmp, S.sigma);\n  blur(tf, S.tmp, S.sigma);\n  const dm = exp(-d / tau), df = exp(-d / TAUF), E = S.E, F = S.F;\n  for (let p = 0; p \u003c N; p++) {\n    E[p] = E[p] * dm + tm[p];\n    F[p] = F[p] * df + tf[p];\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const E = S.E, F = S.F, m = S.ph.m, f = S.ph.f, gm = GAIN / S.tau, gf = GAIN / TAUF;\n  for (let p = 0; p \u003c N; p++) {\n    const a = E[p] * gm, b = F[p] * gf;\n    display.setPixel(p % W, floor(p / W),\n      round(255 * (1 - exp(-(a * m[0] + b * f[0])))),\n      round(255 * (1 - exp(-(a * m[1] + b * f[1])))),\n      round(255 * (1 - exp(-(a * m[2] + b * f[2])))));\n  }\n}\n","ekg-sequence":"// ===== Patternflow pattern =====\n// Title:   EKG Sequence\n// Family:  data\n// Idea:    The EKG sequence is computed term by term and runs down the panel one term to a row with each value plotted across, scaled so the newest n sits two thirds of the way over: most terms hug the line a = n, and each odd prime p arrives as the run 2p, p, 3p, a stroke out to the faint guide a = n/2, where the prime is written in gold, and across to a = 3n/2, so that as the count goes on the opening fan of three rays from the top corner straightens into three upright lines with the primes listed down the left in order.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the EKG sequence (Jeffrey Lagarias, Eric Rains and Neil Sloane, 2002; OEIS A064413), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Zoom=1..4, Links=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the trace is azure, the primes gold and the guides a dim azure; at 0.5 the trace is orange and the primes blue.\n// Knob 2: Speed. New terms a second, 4 for each unit: 8 at the opening 2, so near n = 1,000 a prime arrives about every 1.5 s; 0.8 at 0.2 and 12 at 3. After 50,000 terms (the last prime to arrive is 25,771) the count starts again.\n// Knob 3: Zoom. Terms to a row: 1 at the opening, so the panel holds 128, up to 4 at the end (512). The panel opens full with the first 128 x Zoom terms, and at 1 the run 1, 2, 4, 6, 3, 9, 12, 8, 10, 5, 15 fans out from the top left corner.\n// Knob 4: Links. Colours each step of the trace by the smallest prime its two terms share, fully at 1 and hardly at the opening 0.06: 2 azure, 3 magenta, a larger prime below the square root of the term lime, and one above it white. For p of 5 or more the strokes 2p to p to 3p of each spike are white; the lime steps are the short runs through 5, 7, 29 and the like that weave the line near a = n.\n\n// a(1) = 1, a(2) = 2, and a(n) is the smallest number not used yet that\n// shares a factor greater than 1 with a(n - 1). Lagarias, Rains and Sloane\n// named it for its graph, which looks like an electrocardiogram, and\n// proved that every positive integer turns up in it. Most terms sit a\n// little above n; they conjectured n (1 + 1/(3 log n)), and near\n// n = 10,000 the middle of the terms here runs at 1.037 n. Each odd prime p\n// comes as the run 2p, p, 3p: 2p is an even number near n, p is then the\n// smallest unused number sharing a factor with it, and 3p the smallest\n// unused multiple of p after that, so the graph drops to about n/2 and\n// jumps to about 3n/2. They saw this for every prime they computed, and it\n// was proved later. In the 50,000 terms here it holds for all 2,837 odd\n// primes, and the primes arrive in increasing order.\n//\n// The code keeps a used flag for every number and, for each prime p, the\n// least m with p m unused; m only moves up, since numbers are only ever\n// added to the used set. The next term is the least p m over the primes of\n// the last term, read off a table of smallest prime factors.\n//\n// Each row of the panel holds a term (or Zoom terms), the newest at the\n// bottom, and the value runs across with 0 on column 2 and the newest n on\n// column 42. So the guides a = n/2, n and 3n/2 are rays from the point\n// n = 0 above the panel, and they lean less as n grows.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, max, abs, round, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Terms before the count starts again, and the numbers the code keeps\n// track of: in the first 50,000 terms the largest is 77,313 and the largest\n// candidate looked at 103,084.\nconst NMAX = 50000, LIM = 120000;\n// Columns: the value 0 sits on column X0 and the newest n on X0 + XS.\nconst X0 = 2, XS = 40;\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001011001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001010010\", \"111101111101111\", \"111101111001111\"];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\n// Smallest prime factor of every number up to LIM.\nfunction sieve() {\n  const s = new Int32Array(LIM + 1);\n  for (let i = 2; i \u003c= LIM; i++) if (!s[i]) for (let j = i; j \u003c= LIM; j += i) if (!s[j]) s[j] = i;\n  return s;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 8, zoom: 1, links: 0.06, acc: 0, ready: false,\n    spf: sieve(), a: new Int32Array(NMAX + 2), link: new Int32Array(NMAX + 2),\n    used: new Uint8Array(LIM + 1), ptr: new Int32Array(LIM + 1), n: 0,\n    buf: new Float32Array(N * 3), cols: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], c: [0, 0, 0],\n  };\n}\n\nfunction restart(S) {\n  S.used.fill(0);\n  S.ptr.fill(0);\n  S.a[1] = 1;\n  S.a[2] = 2;\n  S.used[1] = S.used[2] = 1;\n  S.link[2] = 2;\n  S.n = 2;\n}\n\n// a(n + 1): for each prime p of a(n), the smallest multiple of p not yet\n// used (ptr[p] only ever moves up, since used only fills), and the least\n// of these. link is the smallest prime the two terms share.\nfunction next(S) {\n  const spf = S.spf, used = S.used, ptr = S.ptr, prev = S.a[S.n];\n  let x = prev, best = Infinity;\n  while (x > 1) {\n    const p = spf[x];\n    while (x % p === 0) x /= p;\n    let m = ptr[p] || 1;\n    while (p * m \u003c= LIM && used[p * m]) m++;\n    ptr[p] = m;\n    if (p * m \u003c best) best = p * m;\n  }\n  if (best > LIM || S.n >= NMAX) {\n    S.ready = false;\n    return;\n  }\n  x = prev;\n  let lk = 0;\n  while (x > 1 && !lk) {\n    const p = spf[x];\n    while (x % p === 0) x /= p;\n    if (best % p === 0) lk = p;\n  }\n  S.n++;\n  S.a[S.n] = best;\n  S.link[S.n] = lk;\n  used[best] = 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = 4 * cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.zoom = cl(k[2] == null ? 1 : k[2], 1, 4);\n  S.links = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (!S.ready) fill(S);\n  S.acc += d * S.rate;\n  while (S.acc >= 1) {\n    next(S);\n    if (!S.ready) fill(S);\n    S.acc -= 1;\n  }\n}\n\n// Open, and start again, with the panel full: the first 128 x Zoom terms.\nfunction fill(S) {\n  restart(S);\n  while (S.n \u003c round(H * S.zoom)) next(S);\n  S.ready = true;\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] = max(buf[o], c[0] * a);\n  buf[o + 1] = max(buf[o + 1], c[1] * a);\n  buf[o + 2] = max(buf[o + 2], c[2] * a);\n}\n\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0), 1);\n  for (let s = 0; s \u003c= n; s++) put(buf, round(x0 + ((x1 - x0) * s) / n), round(y0 + ((y1 - y0) * s) / n), c, a);\n}\n\nfunction digits(buf, v, x, y, c, a) {\n  const t = String(v);\n  for (let i = 0; i \u003c t.length; i++) {\n    const g = DIG[t.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") put(buf, x + i * 4 + q, y + r, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const buf = S.buf, n = S.n, z = S.zoom, A = S.a, spf = S.spf;\n  const [base, three, lime, gold, white] = S.cols;\n  hsv(0.58 + S.hue, base);\n  hsv(0.86 + S.hue, three);\n  hsv(0.3 + S.hue, lime);\n  hsv(0.13 + S.hue, gold);\n  white[0] = white[1] = white[2] = 1;\n  buf.fill(0);\n  const X = (v) => X0 + (XS * v) / n, Y = (i) => H - 1 - (n - i) / z;\n  // The guides a = n/2, n, 3n/2, dotted on every other term.\n  for (let y = 0; y \u003c H; y++) {\n    const m = n - (H - 1 - y) * z;\n    if (m \u003c 1 || floor(m / z) % 2) continue;\n    for (const f of [0.5, 1, 1.5]) put(buf, round(X(f * m)), y, base, 0.3);\n  }\n  const first = max(1, ceil(n - (H - 1) * z) - 1), c = S.c;\n  for (let i = first + 1; i \u003c= n; i++) {\n    const lk = S.link[i], u = S.links, tint = lk === 2 ? base : lk === 3 ? three : lk * lk > A[i] ? white : lime;\n    for (let q = 0; q \u003c 3; q++) c[q] = base[q] * (1 - u) + tint[q] * u;\n    line(buf, round(X(A[i - 1])), round(Y(i - 1)), round(X(A[i])), round(Y(i)), c, 0.8 + 0.2 * u);\n  }\n  // Each prime: a gold tip and its value beside it.\n  let lastRow = -99;\n  for (let i = max(1, first); i \u003c= n; i++) {\n    const v = A[i];\n    if (v \u003c 2 || spf[v] !== v) continue;\n    const x = round(X(v)), y = round(Y(i));\n    put(buf, x, y, white, 1);\n    put(buf, x - 1, y, gold, 1);\n    put(buf, x + 1, y, gold, 1);\n    // A label that would touch the one above moves down, by 3 rows at most.\n    const w = String(v).length * 4 - 1, ly = max(y - 2, lastRow + 6);\n    if (x - 3 - w \u003c 0 || ly > y + 1) continue;\n    digits(buf, v, x - 3 - w, ly, gold, 0.9);\n    lastRow = ly;\n  }\n  put(buf, round(X(A[n])), H - 1, white, 1);\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","huygens-clocks":"// ===== Patternflow pattern =====\n// Title:   Huygens' Clocks\n// Family:  rhythm\n// Idea:    Two long pendulum clocks hang from one beam that can sway a little, each flashing as its escapement kicks it through the bottom of the swing and dropping that tick as a bar into its own lane of a falling record, so the two lanes start out ticking almost together, the beam rocks, and over six or seven swings the right clock's ticks slide until they fall exactly halfway between the left one's and the beam goes still: Huygens's anti-phase sympathy, or, with the clocks detuned past the lock, a slow slip of beats.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Huygens's odd sympathy of pendulum clocks (Christiaan Huygens, 1665), modelled as pendulums with an escapement kick on a moving support after Bennett, Schatz, Rockwood and Wiesenfeld (Huygens's clocks, Proc. R. Soc. A, 2002), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Detune=-1..1, Coupling=0..1\n//\n// Knob 1: Hue. Turns both clocks round the wheel together. At 0 the left clock and its lane are amber and the right one azure; at 0.5 the left is blue and the right orange-red.\n// Knob 2: Speed. How fast the model runs: half the knob in model seconds a second, so a swing takes 1 s at the opening 2, 10 s at 0.2 and 0.67 s at 3. The record falls 9 rows a model second and holds the last 6.4 swings.\n// Knob 3: Detune. The two clocks' own rates, 1 - 0.15 x knob and 1 + 0.15 x knob of the common rate, so at 1 the right clock runs 35% faster. At 0 they lock half a swing apart. At the opening coupling they still lock at 0.3 (rates 9% apart), the right clock's ticks a third of a swing after the left's (before them at -0.3), and the faster clock swings half as wide as the other; from about 0.33 the lock breaks and the two lanes' ticks slip round each other in beats, once in 13 s just past the edge and faster from there.\n// Knob 4: Coupling. How much each bob weighs against the beam, 0.4 x the square root of the knob: 0.098 at the opening 0.06, where the clocks come from a tenth of a swing apart to half a swing in 7 s. At 0 the beam is too heavy to move and the clocks keep their first offset for good; at 1 (0.4) they are half a swing apart within 3 s.\n// Buttons: Any tap holds the right pendulum at the end of its next swing to the right for 0.3 to 0.8 model seconds and lets it go, as the pattern does by itself every 24 model seconds, and the clocks find their way back.\n\n// Huygens noticed in 1665 that two of his pendulum clocks hung from the\n// same beam ended up swinging in opposite directions, and came back to it\n// after he disturbed one. Bennett, Schatz, Rockwood and Wiesenfeld rebuilt\n// the experiment in 2002 and explained it with a model of pendulums kept\n// going by escapement kicks, mounted on a support that can move. This\n// pattern runs a model of that kind; its numbers are mine, picked so the\n// lock comes within a few swings.\n//\n// In units of the rod length, with x the beam's sideways place and mu the\n// mass of one bob over the beam's:\n//\n//   theta_i'' = -w_i^2 sin(theta_i) - b theta_i' - x'' cos(theta_i)\n//   (1 + 2 mu) x'' + mu sum_i (theta_i'' cos(theta_i) - theta_i'^2 sin(theta_i))\n//       = -k x - c x'\n//\n// with b = 0.6 the pendulums' own damping, k = 4 and c = 5 the beam's\n// spring and damping, and w = 2 pi so a swing takes one model second. Each\n// time a pendulum passes the bottom going right its escapement kicks it,\n// theta' += 0.32, and the beam takes the recoil. That is the tick, and it\n// keeps the swing at about 0.17 radians, 9 or 10 LEDs either side.\n//\n// Swinging together, the two bobs push the beam back and forth and its\n// damping takes energy out of that motion. Swinging against each other\n// they push it equally both ways and it stays put, so that is the motion\n// that costs the clocks nothing, and the escapements keep it going while\n// the rest dies away. The beam's sway is drawn in the middle strip of the\n// record: a wobble while the clocks tick near together, a straight line\n// once they alternate.\n//\n// The clocks start from the same side, the right one let go 0.08 s after\n// the left. Each tick flashes the bob and drops a bar into that clock's\n// lane of the record below, where row y is the time (y - 70) / 9 model\n// seconds ago. Ticking together, the bars of the two lanes lie side by\n// side like the rungs of a ladder; at half a swing apart each bar of one\n// lane falls exactly between two of the other's.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, sin, cos, PI, tanh } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// The model's constants: the common rate, the pendulums' damping, the\n// escapement's kick, the beam's spring and damping, and the time step.\nconst W0 = TAU, B = 0.6, EPS = 0.32, KB = 4, CB = 5, H_STEP = 1 / 600;\n// Drawing: pivots, rod length in LEDs, the record's top row and its pace.\nconst PX = [16, 48], PY = 3, LEN = 56, R0 = 70, VS = 9, BOB = 3.6;\nconst HUES = [0.11, 0.55];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, det: 0, mu: 0.1,\n    th: [0.19, 0.19], om: [0, 0], X: 0, V: 0, t: 0,\n    hold: 0.08, pending: 0, next: 24,\n    ticks: [[], []], flash: [0, 0],\n    hist: new Float32Array(256), hn: 0, ht: 0,\n    buf: new Float32Array(W * H * 3), c: [[0, 0, 0], [0, 0, 0]],\n  };\n}\n\nfunction step(S, h) {\n  const w0 = W0 * (1 - S.det / 2), w1 = W0 * (1 + S.det / 2), w = [w0, w1], mu = S.mu, th = S.th, om = S.om;\n  const held = S.hold > 0;\n  // The pendulums' forces apart from the beam, then the beam's acceleration\n  // with the pendulums' reaction solved in, then the pendulums'.\n  const f0 = -w[0] * w[0] * sin(th[0]) - B * om[0], f1 = -w[1] * w[1] * sin(th[1]) - B * om[1];\n  let num = -KB * S.X - CB * S.V, den = 1 + 2 * mu;\n  num -= mu * (f0 * cos(th[0]) - om[0] * om[0] * sin(th[0]));\n  den -= mu * cos(th[0]) * cos(th[0]);\n  if (!held) {\n    num -= mu * (f1 * cos(th[1]) - om[1] * om[1] * sin(th[1]));\n    den -= mu * cos(th[1]) * cos(th[1]);\n  }\n  const a = num / den;\n  S.V += a * h;\n  S.X += S.V * h;\n  const p0 = th[0], p1 = th[1], q1 = om[1];\n  om[0] += (f0 - a * cos(th[0])) * h;\n  th[0] += om[0] * h;\n  if (held) {\n    om[1] = 0;\n    S.hold -= h;\n  } else {\n    om[1] += (f1 - a * cos(th[1])) * h;\n    th[1] += om[1] * h;\n    // A hold waits for the end of a swing to the right.\n    if (S.pending > 0 && q1 > 0 && om[1] \u003c= 0) {\n      S.hold = S.pending;\n      S.pending = 0;\n    }\n  }\n  S.t += h;\n  const pr = [p0, p1];\n  for (let i = 0; i \u003c 2; i++) {\n    if (pr[i] \u003c 0 && th[i] >= 0 && om[i] > 0) {\n      om[i] += EPS;\n      S.V -= (mu / (1 + 2 * mu)) * EPS;\n      S.ticks[i].push(S.t);\n      if (S.ticks[i].length > 24) S.ticks[i].shift();\n      S.flash[i] = 1;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.det = 0.3 * cl(k[2] || 0, -1, 1);\n  S.mu = 0.4 * sqrt(cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  const b = input.btnPressed;\n  if (b && (b[0] || b[1] || b[2] || b[3])) S.pending = 0.3 + 0.5 * Math.random();\n  if (S.t >= S.next) {\n    S.next = S.t + 24;\n    S.pending = 0.45 + 0.3 * Math.random();\n  }\n  const sim = d * S.speed * 0.5;\n  let n = Math.ceil(sim / H_STEP);\n  const h = n > 0 ? sim / n : 0;\n  while (n-- > 0) {\n    step(S, h);\n    // The beam's place, one sample per half row of the record.\n    if (S.t >= S.ht) {\n      S.ht = S.t + 0.5 / VS;\n      S.hist[S.hn] = S.X;\n      S.hn = (S.hn + 1) % S.hist.length;\n    }\n  }\n  for (let i = 0; i \u003c 2; i++) S.flash[i] = max(0, S.flash[i] - sim * 5);\n}\n\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\n// A line one LED wide, each LED lit by its distance to the segment.\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  for (let y = max(0, floor(min(y0, y1)) - 1); y \u003c= min(H - 1, Math.ceil(max(y0, y1)) + 1); y++)\n    for (let x = max(0, floor(min(x0, x1)) - 1); x \u003c= min(W - 1, Math.ceil(max(x0, x1)) + 1); x++) {\n      const t = cl(((x - x0) * dx + (y - y0) * dy) / l2, 0, 1), ex = x0 + t * dx - x, ey = y0 + t * dy - y;\n      add(buf, x, y, c, a * cl(1.1 - sqrt(ex * ex + ey * ey), 0, 1));\n    }\n}\n\nfunction disc(buf, cx, cy, r, c, a) {\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const e = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      add(buf, x, y, c, a * cl(r + 0.5 - e, 0, 1));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, C = S.c, white = [1, 1, 1], warm = [1, 0.85, 0.65];\n  buf.fill(0);\n  hsv(S.hue + HUES[0], C[0]);\n  hsv(S.hue + HUES[1], C[1]);\n  const off = S.X * LEN;\n  // The beam, with a stud every 4 LEDs so its sway shows.\n  for (let x = 1; x \u003c W - 1; x++) {\n    const u = x - off, stud = u - 4 * floor(u / 4) \u003c 1 ? 0.3 : 0;\n    add(buf, x, 0, warm, 0.3);\n    add(buf, x, 1, warm, 0.5 + stud);\n    add(buf, x, 2, warm, 0.3);\n  }\n  // The record: two lanes, the ticks falling down them from the clocks, and\n  // between them the beam's swing over the same time.\n  for (let i = 0; i \u003c 2; i++) {\n    const x0 = PX[i] - 11, x1 = PX[i] + 11, c = C[i];\n    for (let y = R0; y \u003c H; y++) for (let x = x0; x \u003c= x1; x++) add(buf, x, y, c, 0.08);\n    // Each tick a bar two rows deep with a short glow above it, on the\n    // side of the present, falling at VS rows a second of model time.\n    for (const tk of S.ticks[i]) {\n      const yy = R0 + (S.t - tk) * VS;\n      if (yy > H + 1) continue;\n      const fade = 1 - (0.4 * (yy - R0)) / (H - R0);\n      for (let y = floor(yy) - 5; y \u003c= floor(yy) + 2; y++) {\n        if (y \u003c R0 || y >= H) continue;\n        const core = cl(min(y + 1, yy + 2) - max(y, yy), 0, 1), glow = y \u003c yy ? 0.45 * Math.exp((y + 1 - yy) / 1.6) : 0;\n        const a = (0.88 * core + glow * (1 - core)) * fade;\n        for (let x = x0; x \u003c= x1; x++) add(buf, x, y, c, a);\n      }\n    }\n  }\n  // The beam's sway down the middle strip, squashed so the largest sway at\n  // the start just fills it.\n  const nh = S.hist.length;\n  for (let y = R0; y \u003c H; y++) {\n    const back = round((y - R0) * 2);\n    if (back >= nh) break;\n    const xv = S.hist[(S.hn - 1 - back + nh * 4) % nh];\n    const px = 31.5 + 2.6 * tanh(xv * 90);\n    const ix = floor(px), fr = px - ix;\n    add(buf, ix, y, warm, 0.6 * (1 - fr));\n    add(buf, ix + 1, y, warm, 0.6 * fr);\n  }\n  // The two clocks.\n  for (let i = 0; i \u003c 2; i++) {\n    const px = PX[i] + off, th = S.th[i], bx = px + LEN * sin(th), by = PY + LEN * cos(th), f = S.flash[i];\n    line(buf, px, PY, bx, by, C[i], 0.6 + 0.4 * f);\n    disc(buf, bx, by, BOB, C[i], 1);\n    disc(buf, bx, by, BOB + 1.5 * f, white, 0.8 * f);\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n}\n","lempel-ziv":"// ===== Patternflow pattern =====\n// Title:   Lempel-Ziv\n// Family:  type\n// Idea:    An LZ77 encoder walks a text set in tiny capitals sixteen to a row, and at each step it lights the longest earlier stretch that the coming letters repeat, copies it forward letter by letter in a colour set by how far back it was (the hue climbs with the logarithm of the distance) and writes the one new letter after it in white, so the cumulative rhyme of the House That Jack Built turns into a white phrase and one long band per verse whose colour moves from azure to magenta as the verses grow, letters beyond the sliding window dim, and a counter at the foot keeps the bytes of text against the bytes of code.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: LZ77, the sliding-window universal compressor (Jacob Ziv and Abraham Lempel, A Universal Algorithm for Sequential Data Compression, 1977); texts: This Is the House That Jack Built and The Twelve Days of Christmas (traditional), Charles Dickens's A Tale of Two Cities (1859), Gertrude Stein's Sacred Emily (1913); 3 by 5 capitals drawn for this pattern; pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Window=0..1, Text=0..1\n//\n// Knob 1: Hue. Turns the distance colours round the wheel. At 0 a copy from 1 letter back is yellow-green, from 3 back green, 10 back cyan, 35 back (the second verse of the House copying the first) azure, 300 back violet and 2000 back rose; literals stay white.\n// Knob 2: Speed. At 2 a literal takes 0.03 s and a copy lights its source for 0.09 s and then copies 143 letters a second, so the first verse of the House is written in 1.7 s and all 1970 letters in 25 s, after which the page holds for 3 s and starts again; everything goes as the knob, ten times slower at 0.2.\n// Knob 3: Window. How far back the encoder may look, shrinking as the knob turns: 4096 letters at 0, 1024 at a quarter, 256 at a half, 32 at three quarters and 8 at 1. Letters further back than the window dim. The House codes to 371 bytes at 4096 (19% of its 1970), 345 at 1024, where every verse is still in reach and the distance field is 2 bits shorter, 846 at 256, 1967 at 32, and 3114 at 8, more than the text.\n// Knob 4: Text. This Is the House That Jack Built below 0.25, Stein's rose line (35 letters, ten tokens, one of them a copy of 23 letters from 10 back) to 0.5, The Twelve Days of Christmas (2357 letters, 154 tokens) to 0.75, then the opening of A Tale of Two Cities (416 letters, 96 tokens, 81%).\n\n// LZ77 reads the text once from the front. At each position it looks back\n// through the window, the last letters it has already passed, for the\n// longest run that matches the letters coming next, and sends one token: how\n// far back that run starts, how long it is, and the one letter after it. The\n// decoder rebuilds the text by copying length letters from distance back,\n// a letter at a time, so a run may overlap itself: in Stein's line, from the\n// O of the second ROSE the encoder copies 23 letters from 10 back, OSE IS A\n// ROSE IS A ROSE, reading letters it is itself writing. A text that repeats\n// itself turns into a few long copies; a text that does not turns into short\n// ones and literals.\n//\n// Here the page is 16 letters a row, each letter 3 by 5 LEDs on a pitch of\n// 4 by 6, 20 rows on the panel and the page scrolling up as it fills. Every\n// letter keeps the token that wrote it: white for the literal, and for a copy\n// a hue from the logarithm of the distance, so all the letters one verse of\n// the House copies from the verse before take the same colour, and a verse\n// reads as a white phrase and a long band. The counter at the foot is the\n// plain text in bytes, an arrow, the tokens in bytes (each token log2 W bits\n// of distance, 8 of length and 8 for the letter) and the ratio. With a small\n// window the code comes out longer than the text.\n\nconst W = 64, H = 128, N = W * H, COLS = 16, ROWS = 20, MAXLEN = 255, LOOK = 0.18, STEP = 0.014, LIT = 0.06;\nconst { floor, min, max, round, log2, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- 3 by 5 capitals, five rows of three bits each, the left LED the\n// high bit.\nconst FONT = {\n  A: \"25755\", B: \"65656\", C: \"34443\", D: \"65556\", E: \"74647\", F: \"74644\", G: \"34553\",\n  H: \"55755\", I: \"72227\", J: \"11152\", K: \"55655\", L: \"44447\", M: \"57755\", N: \"65555\",\n  O: \"25552\", P: \"65644\", Q: \"25573\", R: \"65655\", S: \"34216\", T: \"72222\", U: \"55557\",\n  V: \"55552\", W: \"55775\", X: \"55255\", Y: \"55222\", Z: \"71247\",\n  0: \"75557\", 1: \"26227\", 2: \"61247\", 3: \"61216\", 4: \"55711\", 5: \"74616\", 6: \"34757\",\n  7: \"71122\", 8: \"75757\", 9: \"75716\",\n  \".\": \"00002\", \",\": \"00024\", \"'\": \"22000\", \"-\": \"00700\", \";\": \"02024\", \"%\": \"51245\", \">\": \"42124\",\n};\n\n// ---- The texts.\nfunction house() {\n  const noun = [\"THE HOUSE THAT JACK BUILT.\", \"THE MALT\", \"THE RAT\", \"THE CAT\", \"THE DOG\", \"THE COW WITH THE CRUMPLED HORN\", \"THE MAIDEN ALL FORLORN\", \"THE MAN ALL TATTERED AND TORN\", \"THE PRIEST ALL SHAVEN AND SHORN\", \"THE COCK THAT CROWED IN THE MORN\", \"THE FARMER SOWING HIS CORN\"];\n  const verb = [\"\", \"THAT LAY IN\", \"THAT ATE\", \"THAT KILLED\", \"THAT WORRIED\", \"THAT TOSSED\", \"THAT MILKED\", \"THAT KISSED\", \"THAT MARRIED\", \"THAT WAKED\", \"THAT KEPT\"];\n  const out = [];\n  for (let k = 0; k \u003c noun.length; k++) {\n    let v = \"THIS IS \" + noun[k];\n    for (let j = k; j >= 1; j--) v += \", \" + verb[j] + \" \" + noun[j - 1];\n    out.push(v);\n  }\n  return out.join(\" \");\n}\nfunction twelveDays() {\n  const ord = [\"FIRST\", \"SECOND\", \"THIRD\", \"FOURTH\", \"FIFTH\", \"SIXTH\", \"SEVENTH\", \"EIGHTH\", \"NINTH\", \"TENTH\", \"ELEVENTH\", \"TWELFTH\"];\n  const gift = [\"A PARTRIDGE IN A PEAR TREE.\", \"TWO TURTLE DOVES,\", \"THREE FRENCH HENS,\", \"FOUR CALLING BIRDS,\", \"FIVE GOLD RINGS,\", \"SIX GEESE A-LAYING,\", \"SEVEN SWANS A-SWIMMING,\", \"EIGHT MAIDS A-MILKING,\", \"NINE LADIES DANCING,\", \"TEN LORDS A-LEAPING,\", \"ELEVEN PIPERS PIPING,\", \"TWELVE DRUMMERS DRUMMING,\"];\n  const out = [];\n  for (let k = 0; k \u003c 12; k++) {\n    let v = \"ON THE \" + ord[k] + \" DAY OF CHRISTMAS MY TRUE LOVE GAVE TO ME \";\n    for (let j = k; j >= 1; j--) v += gift[j] + \" \";\n    out.push(v + (k ? \"AND \" : \"\") + gift[0]);\n  }\n  return out.join(\" \");\n}\nconst TEXTS = [\n  house(),\n  \"ROSE IS A ROSE IS A ROSE IS A ROSE.\",\n  twelveDays(),\n  \"IT WAS THE BEST OF TIMES, IT WAS THE WORST OF TIMES, IT WAS THE AGE OF WISDOM, IT WAS THE AGE OF FOOLISHNESS, IT WAS THE EPOCH OF BELIEF, IT WAS THE EPOCH OF INCREDULITY, IT WAS THE SEASON OF LIGHT, IT WAS THE SEASON OF DARKNESS, IT WAS THE SPRING OF HOPE, IT WAS THE WINTER OF DESPAIR, WE HAD EVERYTHING BEFORE US, WE HAD NOTHING BEFORE US, WE WERE ALL GOING DIRECT TO HEAVEN, WE WERE ALL GOING DIRECT THE OTHER WAY\",\n];\n\n// The longest match for text[p...] that starts within win letters back,\n// the nearest one among equals. It may run on past p into the letters it\n// is copying, and it leaves at least one letter for the literal.\nfunction longest(t, p, win) {\n  let bestL = 0, bestD = 0;\n  const lim = min(MAXLEN, t.length - 1 - p);\n  for (let d = 1; d \u003c= min(win, p); d++) {\n    const s = p - d;\n    let l = 0;\n    while (l \u003c lim && t.charCodeAt(s + l) === t.charCodeAt(p + l)) l++;\n    if (l > bestL) {\n      bestL = l;\n      bestD = d;\n      if (l === lim) break;\n    }\n  }\n  return [bestD, bestL];\n}\n\nexport function setup(params) {\n  params.s = { ti: -1, buf: new Float32Array(N * 3) };\n}\n\nfunction restart(S, ti) {\n  const n = TEXTS[ti].length;\n  S.ti = ti;\n  S.text = TEXTS[ti];\n  S.kind = new Uint8Array(n);\n  S.dist = new Uint16Array(n);\n  S.born = new Float32Array(n);\n  S.lit = new Float32Array(n);\n  S.litD = new Uint16Array(n);\n  S.p = 0;\n  S.tok = null;\n  S.tokens = 0;\n  S.bits = 0;\n  S.top = 0;\n  S.scroll = 0;\n  S.t = 0;\n  S.done = -1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.wbits = round(12 - 9 * cl(k[2] || 0, 0, 1));\n  const ti = min(3, floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 4));\n  if (ti !== S.ti) restart(S, ti);\n  S.t += d;\n  const f = S.speed, t = S.text, n = t.length;\n  // A lit source letter fades over about 0.4 s once it has been read.\n  const fade = exp(-d / 0.4);\n  for (let i = 0; i \u003c n; i++) if (S.lit[i] > 0) S.lit[i] *= fade;\n  let budget = d * f;\n  while (budget > 0) {\n    if (S.p >= n) {\n      // The page holds for 3 s, then starts over.\n      if (S.done \u003c 0) S.done = S.t;\n      if (S.t - S.done > 3) restart(S, ti);\n      break;\n    }\n    if (!S.tok) {\n      const [dist, len] = longest(t, S.p, 1 \u003c\u003c S.wbits);\n      // Time in units of the knob: LOOK to show the source, STEP a copied\n      // letter, LIT for the literal.\n      S.tok = { dist, len, j: 0, look: len ? LOOK : 0, lit: LIT, carry: 0 };\n      S.tokens++;\n      S.bits += S.wbits + 16;\n      for (let i = S.p - dist; len && i \u003c min(S.p, S.p - dist + len); i++) {\n        S.lit[i] = 1;\n        S.litD[i] = dist;\n      }\n    }\n    const T = S.tok;\n    if (T.look > 0) {\n      const use = min(budget, T.look);\n      T.look -= use;\n      budget -= use;\n      continue;\n    }\n    if (T.j \u003c T.len) {\n      T.carry += budget;\n      budget = 0;\n      while (T.carry >= STEP && T.j \u003c T.len) {\n        T.carry -= STEP;\n        const src = S.p - T.dist;\n        S.kind[S.p] = 2;\n        S.dist[S.p] = T.dist;\n        S.born[S.p] = S.t;\n        S.lit[src] = 1.6;\n        S.litD[src] = T.dist;\n        S.p++;\n        T.j++;\n      }\n      if (T.j >= T.len) budget = T.carry;\n      continue;\n    }\n    const use = min(budget, T.lit);\n    T.lit -= use;\n    budget -= use;\n    if (T.lit \u003c= 0) {\n      S.kind[S.p] = 1;\n      S.born[S.p] = S.t;\n      S.p++;\n      S.tok = null;\n    }\n  }\n  // Scroll so the row being written is on the page.\n  const row = floor(min(S.p, n - 1) / COLS);\n  if (row >= S.top + ROWS) S.top = row - ROWS + 1;\n  S.scroll += (S.top * 6 - S.scroll) * min(1, d * 10);\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] = max(buf[o], c[0] * a);\n  buf[o + 1] = max(buf[o + 1], c[1] * a);\n  buf[o + 2] = max(buf[o + 2], c[2] * a);\n}\n\nfunction glyph(buf, ch, x, y, c, a, y1) {\n  const g = FONT[ch];\n  if (!g) return;\n  for (let r = 0; r \u003c 5; r++) {\n    if (y + r >= y1) break;\n    const bits = g.charCodeAt(r) - 48;\n    for (let b = 0; b \u003c 3; b++) if (bits & (4 >> b)) put(buf, x + b, y + r, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.text) return;\n  const buf = S.buf, t = S.text, win = 1 \u003c\u003c S.wbits, white = [1, 1, 1];\n  buf.fill(0);\n  const hueOf = (dist) => S.hue + 0.25 + 0.065 * log2(dist);\n  const r0 = max(0, floor(S.scroll / 6)), end = S.done >= 0 ? cl(1 - (S.t - S.done - 2.5) / 0.5, 0, 1) : 1;\n  let above = 0, aboveD = 0;\n  for (let i = 0; i \u003c S.p; i++) if (S.lit[i] > 0.05 && floor(i / COLS) \u003c r0 && S.lit[i] > above) {\n    above = S.lit[i];\n    aboveD = S.litD[i];\n  }\n  for (let i = r0 * COLS; i \u003c min(t.length, (r0 + ROWS + 1) * COLS); i++) {\n    const x = (i % COLS) * 4, y = floor(i / COLS) * 6 - round(S.scroll);\n    if (y >= 120 || y + 5 \u003c 0) continue;\n    const lit = S.lit[i];\n    // A source letter's cell fills with the copy's colour while it is read.\n    if (lit > 0.05 && i \u003c S.p) {\n      const c = hsv(hueOf(S.litD[i]), 0.9, 1);\n      for (let yy = y; yy \u003c min(120, y + 6); yy++) for (let xx = x; xx \u003c x + 4; xx++) put(buf, xx, yy, c, min(0.45, 0.3 * lit) * end);\n    }\n    if (i >= S.p) continue;\n    const ch = t[i], age = S.t - S.born[i], flash = max(0, 1 - age / 0.35);\n    const inWin = S.p - i \u003c= win ? 1 : 0.32;\n    let c;\n    if (S.kind[i] === 2) {\n      const h = hsv(hueOf(S.dist[i]), 0.72, 1);\n      c = [h[0] + (1 - h[0]) * 0.4 * flash, h[1] + (1 - h[1]) * 0.4 * flash, h[2] + (1 - h[2]) * 0.4 * flash];\n    } else c = [0.85, 0.85, 0.85];\n    const a = (lit > 0.05 ? 1 : inWin) * end;\n    glyph(buf, ch, x, y, c, a, 120);\n  }\n  // A source above the top edge lights the edge in its colour.\n  if (above > 0.05) {\n    const c = hsv(hueOf(aboveD), 0.9, 1);\n    for (let x = 0; x \u003c W; x++) put(buf, x, 0, c, min(1, above) * 0.8 * end);\n  }\n  // The cursor: a bar under the next letter.\n  if (S.p \u003c t.length) {\n    const x = (S.p % COLS) * 4, y = floor(S.p / COLS) * 6 - round(S.scroll) + 5;\n    if (y \u003c 120) for (let b = 0; b \u003c 3; b++) put(buf, x + b, y, white, 0.7);\n  }\n  // The counter: plain bytes > coded bytes, and the ratio.\n  const plain = S.p, coded = Math.ceil(S.bits / 8), pct = plain ? round((100 * coded) / plain) : 0;\n  const left = plain + \">\" + coded, right = pct + \"%\";\n  for (let j = 0; j \u003c left.length; j++) glyph(buf, left[j], j * 4, 122, left[j] === \">\" ? [0.5, 0.5, 0.5] : white, 0.8, 128);\n  const pc = hsv(S.hue + 0.25 + 0.065 * 8, 0.6, 1);\n  for (let j = 0; j \u003c right.length; j++) glyph(buf, right[j], W - (right.length - j) * 4 + 1, 122, pc, 0.9, 128);\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","mobius-type":"// ===== Patternflow pattern =====\n// Title:   Möbius Type\n// Family:  type\n// Idea:    A paper band stands up the height of the panel and turns slowly in 3D with a line of capitals printed along its middle; with one or three half-twists the band has one side, so the sentence THE OTHER SIDE OF THIS LINE IS THIS LINE runs round twice before it meets its own start and every piece of the band carries ink on its back as well, while with two or four the band has two sides, THIS LINE HAS A BACK closes after one lap and the back is bare paper, and a bright reading mark runs along the line so the eye can follow it round.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the one-sided band (August Ferdinand Möbius and Johann Benedict Listing, 1858), capitals on a 5 by 7 grid drawn for this pattern, pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Twists=1..4, Paper=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel. At 0 it is azure, 0.25 purple, 0.5 orange, 0.75 green; the paper stays grey and the reading mark white.\n// Knob 2: Speed. At 2 the band turns once round the upright in 24 s, 15 degrees a second, and the reading mark moves on 2.5 letters a second, so it takes 16.4 s to read the 41 letters of the one-sided line twice round and 8.4 s for the 21 of the two-sided one. At 0.2 both go ten times slower, at 3 half as fast again.\n// Knob 3: Twists. Half-twists in the band, to the nearest whole number: 1 at the opening, Möbius's band, one side and one edge; 2, a full twist, two sides and two edges linked once; 3, one side again, its one edge tied in a trefoil; 4, two sides.\n// Knob 4: Paper. How thin the paper is. At 0 it is card and only the face toward you shows. At 1 the paper itself is 45% darker and the far face's letters show through it mirrored, at about two thirds the light of the ink facing you: on a two-sided band the bare back shows the line from behind, on a one-sided band the other lap's letters lie mirrored between the letters facing you.\n\n// The band's middle line is a stadium standing in the plane of the panel:\n// two uprights 60 LEDs long at x = +-19 joined by half circles of radius 19,\n// 239.4 LEDs round. A point on the band is c(s) + v d(s), s the arc length\n// along the middle and v from -12 to 12 across. The direction across, d,\n// turns about the middle line: d = cos(a) N + sin(a) Z, N the outward\n// normal in the plane, Z out of it, and a = pi/2 + k pi s / P for k\n// half-twists in the length P, so at the start of the line, halfway up the\n// right upright, the band stands straight out of the plane. After one lap d has turned by k pi, so with\n// k odd it comes back as -d: the face you set out on has become the other\n// one, and only a second lap brings you back to your start. That is the one\n// side of Möbius's band, and the line printed along it is 2P long, ink on\n// both faces of every piece of paper. With k even d comes back as itself,\n// the line closes after one lap and the back is a second face of its own.\n//\n// Seen from the face whose normal is n = ds x dv, the letters stand up\n// along +v. Seen from the other face of the same piece of paper the line\n// is the next lap, s + P along with v turned over, so its letters stand up\n// the right way to a reader on that side. Through thin paper the far face's\n// ink shows from behind, as a mirror image.\n//\n// The picture is drawn by splatting: 640 by 56 points of the band are\n// turned, put in perspective from a camera 260 LEDs away, and kept only\n// where they are nearest the camera; an LED is the mean of the near points\n// that land in it, so the letters are box-filtered where the paper is seen\n// at a slant. Which face is toward the camera decides which lap's letters\n// that point shows, and the light falls on that face.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, max, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst R = 19, D = 30, HW = 12, P = 4 * D + 2 * PI * R;\nconst NS = 640, NV = 56, DC = 260, TILT = 0.24, EPS = 1.6;\nconst CAP = 0.7 * 2 * HW, HUE0 = 0.57;\nconst LINES = [\"THIS LINE HAS A BACK \", \"THE OTHER SIDE OF THIS LINE IS THIS LINE \"];\n// The light, from the upper left and in front, in camera space.\nconst LX = -0.45, LY = 0.55, LZ = 0.7, LN = sqrt(LX * LX + LY * LY + LZ * LZ);\n\n// Capitals on a 5 by 7 grid, rows from the top.\nconst GLYPHS = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\",\n  B: \"####. #...# #...# ####. #...# #...# ####.\",\n  C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\",\n  E: \"##### #.... #.... ####. #.... #.... #####\",\n  F: \"##### #.... #.... ####. #.... #.... #....\",\n  H: \"#...# #...# #...# ##### #...# #...# #...#\",\n  I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\",\n  L: \"#.... #.... #.... #.... #.... #.... #####\",\n  N: \"#...# ##..# ##..# #.#.# #..## #..## #...#\",\n  O: \".###. #...# #...# #...# #...# #...# .###.\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\",\n  T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\",\n};\n// Each line as 35 dots a letter, 0 for a space.\nconst BITS = LINES.map((line) => {\n  const b = new Uint8Array(line.length * 35);\n  for (let i = 0; i \u003c line.length; i++) {\n    const g = GLYPHS[line[i]];\n    if (!g) continue;\n    const rows = g.split(\" \");\n    for (let r = 0; r \u003c 7; r++) for (let c = 0; c \u003c 5; c++) b[i * 35 + r * 5 + c] = rows[r][c] === \"#\" ? 1 : 0;\n  }\n  return b;\n});\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The middle line at arc length s: position, unit tangent, curvature.\nfunction stadium(s, o) {\n  let x, y, tx, ty, k = 0;\n  if (s \u003c D) [x, y, tx, ty] = [R, s, 0, 1];\n  else if (s \u003c D + PI * R) {\n    const a = (s - D) / R;\n    [x, y, tx, ty, k] = [R * cos(a), D + R * sin(a), -sin(a), cos(a), 1 / R];\n  } else if (s \u003c 3 * D + PI * R) [x, y, tx, ty] = [-R, D - (s - D - PI * R), 0, -1];\n  else if (s \u003c 3 * D + 2 * PI * R) {\n    const a = PI + (s - 3 * D - PI * R) / R;\n    [x, y, tx, ty, k] = [R * cos(a), -D + R * sin(a), -sin(a), cos(a), 1 / R];\n  } else [x, y, tx, ty] = [R, -D + (s - 3 * D - 2 * PI * R), 0, 1];\n  o[0] = x; o[1] = y; o[2] = tx; o[3] = ty; o[4] = k;\n}\n\n// The row of the 5 by 7 grid at each of the NV steps across, read with the\n// letters standing up along +v (ROWS[0]) or along -v (ROWS[1]); -1 off the\n// letters.\nconst ROWS = [0, 1].map((flip) => {\n  const r = new Int32Array(NV);\n  for (let j = 0; j \u003c NV; j++) {\n    const v = (-HW + ((j + 0.5) * 2 * HW) / NV) * (flip ? -1 : 1), row = floor((CAP / 2 - v) / (CAP / 7));\n    r[j] = row >= 0 && row \u003c 7 ? row * 5 : -1;\n  }\n  return r;\n});\n\n// For each of the NS stations along the band: the middle point c, the\n// direction across d and the normal n0 + v n1 (12 numbers), for k\n// half-twists; and where the line's letters fall on each face there.\nfunction build(k) {\n  const g = new Float32Array(NS * 12), st = [0, 0, 0, 0, 0], da = (k * PI) / P;\n  const odd = k % 2, len = LINES[odd].length, adv = (odd ? 2 * P : P) / len;\n  const cell = [new Int32Array(NS), new Int32Array(NS)], letter = [new Int32Array(NS), new Int32Array(NS)];\n  for (let i = 0; i \u003c NS; i++) {\n    const s = ((i + 0.5) * P) / NS;\n    stadium(s, st);\n    const [x, y, tx, ty, kap] = st, nx = ty, ny = -tx, a = PI / 2 + da * s, ca = cos(a), sa = sin(a);\n    const dx = ca * nx, dy = ca * ny, dz = sa;\n    // ds at v is T + v (kap cos a T + a' (-sin a N + cos a Z)), dv is d.\n    const ax = kap * ca * tx - da * sa * nx, ay = kap * ca * ty - da * sa * ny, az = da * ca;\n    const o = i * 12;\n    g[o] = x; g[o + 1] = y; g[o + 2] = 0;\n    g[o + 3] = dx; g[o + 4] = dy; g[o + 5] = dz;\n    g[o + 6] = ty * dz; g[o + 7] = -tx * dz; g[o + 8] = tx * dy - ty * dx;\n    g[o + 9] = ay * dz - az * dy; g[o + 10] = az * dx - ax * dz; g[o + 11] = ax * dy - ay * dx;\n    // Lap 0 is the line at s on the face n points to; lap 1 is s + P,\n    // on the other face, and only a one-sided band has it.\n    for (let lap = 0; lap \u003c 2; lap++) {\n      const u = (s + lap * P) / adv, li = floor(u) % len, col = floor((u - floor(u)) * 6 - 0.5);\n      letter[lap][i] = li;\n      cell[lap][i] = col >= 0 && col \u003c 5 && (odd || !lap) ? li * 35 + col : -1;\n    }\n  }\n  return { g, cell, letter, odd, len };\n}\n\nexport function setup(params) {\n  params.s = {\n    k: 1, geo: build(1), view: new Float32Array(NS * 12), lam: new Float32Array(NS * 2), turn: -0.65, read: 0, hue: 0, paper: 0.06,\n    z: new Float32Array(N), pix: new Int32Array(NS * NV), zs: new Float32Array(NS * NV), acc: new Float32Array(N * 4), ink: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1] == null ? 2 : kv[1], 0.2, 3);\n  const k = round(cl(kv[2] == null ? 1 : kv[2], 1, 4));\n  S.paper = cl(kv[3] == null ? 0.06 : kv[3], 0, 1);\n  if (k !== S.k) {\n    S.k = k;\n    S.geo = build(k);\n  }\n  S.turn += (d * speed * 2 * PI) / 48;\n  S.read += d * speed * 1.25;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { g, cell, letter, odd, len } = S.geo, bits = BITS[odd];\n  const zb = S.z, acc = S.acc, vw = S.view, lam = S.lam, pix = S.pix, zs = S.zs, ink = hsv(S.hue + HUE0, 0.8, 1, S.ink);\n  // Camera: turn about the upright, then tip the top toward the camera by\n  // TILT, so the band is seen a little from above.\n  const cp = cos(S.turn), sp = sin(S.turn), ct = cos(TILT), stl = sin(TILT);\n  const m00 = cp, m02 = sp, m10 = sp * stl, m11 = ct, m12 = -cp * stl, m20 = -sp * ct, m21 = stl, m22 = cp * ct;\n  for (let i = 0; i \u003c NS * 12; i += 3) {\n    const x = g[i], y = g[i + 1], z = g[i + 2];\n    vw[i] = m00 * x + m02 * z;\n    vw[i + 1] = m10 * x + m11 * y + m12 * z;\n    vw[i + 2] = m20 * x + m21 * y + m22 * z;\n  }\n  // The light on each face at each station.\n  for (let i = 0; i \u003c NS; i++) {\n    const o = i * 12, nx = vw[o + 6], ny = vw[o + 7], nz = vw[o + 8];\n    const l = (nx * LX + ny * LY + nz * LZ) / (LN * sqrt(nx * nx + ny * ny + nz * nz) + 1e-9);\n    lam[i * 2] = max(0, l);\n    lam[i * 2 + 1] = max(0, -l);\n  }\n  zb.fill(-1e9);\n  acc.fill(0);\n  const dv = (2 * HW) / NV;\n  for (let i = 0, q = 0; i \u003c NS; i++) {\n    const o = i * 12, cx = vw[o], cy = vw[o + 1], cz = vw[o + 2], dx = vw[o + 3], dy = vw[o + 4], dz = vw[o + 5];\n    for (let j = 0; j \u003c NV; j++, q++) {\n      const v = -HW + (j + 0.5) * dv, Z = cz + v * dz, f = DC / (DC - Z);\n      const px = floor(32 + (cx + v * dx) * f), py = floor(64 - (cy + v * dy) * f);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) {\n        pix[q] = -1;\n        continue;\n      }\n      const p = py * W + px;\n      pix[q] = p;\n      zs[q] = Z;\n      if (Z > zb[p]) zb[p] = Z;\n    }\n  }\n  const show = S.paper, thin = 1 - 0.45 * show, pr = 0.9 * thin, pg = 0.9 * thin, pb = 0.95 * thin;\n  const rowP = ROWS[0], rowN = ROWS[1];\n  for (let i = 0, q = 0; i \u003c NS; i++) {\n    const o = i * 12, cx = vw[o], cy = vw[o + 1], dx = vw[o + 3], dy = vw[o + 4];\n    const c0 = cell[0][i], c1 = cell[1][i];\n    for (let j = 0; j \u003c NV; j++, q++) {\n      const p = pix[q];\n      if (p \u003c 0) continue;\n      const Z = zs[q];\n      if (Z \u003c zb[p] - EPS) continue;\n      // Which face looks at the camera: the line's lap 0 is on the face\n      // n points to, lap 1 (turned over) on the other.\n      const v = -HW + (j + 0.5) * dv;\n      const nx = vw[o + 6] + v * vw[o + 9], ny = vw[o + 7] + v * vw[o + 10], nz = vw[o + 8] + v * vw[o + 11];\n      const front = nx * -(cx + v * dx) + ny * -(cy + v * dy) + nz * (DC - Z) >= 0;\n      const l = lam[i * 2 + (front ? 0 : 1)];\n      const nc = front ? c0 : c1, nr = front ? rowP[j] : rowN[j], fc = front ? c1 : c0, fr = front ? rowN[j] : rowP[j];\n      const near = nc >= 0 && nr >= 0 ? bits[nc + nr] : 0;\n      // The far face's ink seen through the paper, mirrored.\n      const far = !near && fc >= 0 && fr >= 0 ? bits[fc + fr] : 0;\n      const q4 = p * 4;\n      acc[q4] += 1;\n      if (near) {\n        const il = 0.42 + 0.58 * l, h = glow(S.read, letter[front ? 0 : 1][i], len), a = il * (1 - h), w = il * h;\n        acc[q4 + 1] += ink[0] * a + w;\n        acc[q4 + 2] += ink[1] * a + w;\n        acc[q4 + 3] += ink[2] * a + w;\n      } else {\n        const pl = 0.09 + 0.3 * l, sh = far * show, il = (0.26 + 0.4 * l) * sh, a = pl * (1 - sh);\n        acc[q4 + 1] += pr * a + ink[0] * il;\n        acc[q4 + 2] += pg * a + ink[1] * il;\n        acc[q4 + 3] += pb * a + ink[2] * il;\n      }\n    }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const n = acc[p * 4], q4 = p * 4;\n    if (n > 0) display.setPixel(p % W, floor(p / W), round(cl(acc[q4 + 1] / n, 0, 1) * 255), round(cl(acc[q4 + 2] / n, 0, 1) * 255), round(cl(acc[q4 + 3] / n, 0, 1) * 255));\n    else display.setPixel(p % W, floor(p / W), 0, 0, 0);\n  }\n}\n\n// The reading mark: white on the letter it has reached, fading over the\n// three behind it.\nfunction glow(read, li, len) {\n  let u = (read - li) % len;\n  if (u \u003c 0) u += len;\n  return u \u003c 4 ? (1 - u / 4) ** 1.5 : 0;\n}\n","mushroom-billiard":"// ===== Patternflow pattern =====\n// Title:   Mushroom Billiard\n// Family:  particle\n// Idea:    A mushroom-shaped billiard stands up the panel, a half disc of radius 30 on top of a straight stem that runs down to the floor, and 360 balls bounce in it with short trails, gold where a ball's chord passes the cap's centre further off than half the stem's width, so that it circles the cap for ever tangent to its caustic and never finds the way down, and blue for every other ball, which wanders the stem and the cap alike, the two kinds parted exactly by that one distance.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: mushroom billiards (Leonid Bunimovich, Mushrooms and other billiards with divided phase space, Chaos 11, 2001), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Stem=0.3..0.9, Trail=0..1\n//\n// Knob 1: Hue. Turns both kinds round the wheel together. At 0 the regular balls run from amber on the caustics just outside the border to lemon on the ones nearest the rim, and the chaotic ones are azure; at 0.5 the regular balls are blue and the chaotic ones orange.\n// Knob 2: Speed. At 2 a ball flies 40 LEDs a second, so one going straight down would run the stem's 95 rows in 2.4 s; at 0.2 it flies 4 and at 3, 60. In a two-minute run at 2 every chaotic ball went down the stem and no regular one did, its |L| drifting by less than a trillionth of an LED.\n// Knob 3: Stem. The stem's half width as a share of the cap's radius: 9 LEDs (an 18 LED stem) at the opening 0.3, 18 at 0.6, 27 at 0.9, where the cap is left only a 3 LED brim each side. The border moves with it, and a regular ball whose caustic is now inside it turns blue at once and will find the stem; one that the narrower stem shuts out turns gold.\n// Knob 4: Trail. How long a path stays lit. At the opening 0.06 a ball draws a streak about 5 LEDs long; at 1 a path fades over 1.55 s, too faint to see alone, and the paths add up to a haze in which the regular balls' chords make a gold band round the rim that never comes inside the dotted border.\n// Buttons: K1 tap throws every ball again, two in five regular, each kind spread evenly over its own part of the table's phase space.\n\n// A ball in a disc keeps the distance L from the centre to the line it\n// flies along: a bounce off the circle turns its heading but not that line's\n// distance, so every chord is tangent to one circle of radius |L|, its\n// caustic. A bounce off a mirror through the centre turns L into -L. The cap\n// here is a half disc whose flat side is such a mirror, so in the cap |L| is\n// kept too. The stem hangs from the middle of the flat side, |x| \u003c a.\n//\n// Leonid Bunimovich saw what that does. A ball's line meets the flat side\n// at a distance |L| / |sin phi| from the centre, never closer than |L|. If\n// |L| > a it never meets the opening, never goes down the stem, and circles\n// the cap for ever: a regular, integrable orbit. If |L| \u003c a the lines turn\n// round from bounce to bounce and sooner or later one crosses the opening;\n// down in the stem the walls and the floor scatter it, and it comes back up\n// with a new L that is again smaller than a, since it came up through the\n// opening. Those balls are chaotic and wander everywhere. The phase space is\n// split in two by the one number |L| = a: a sharp border, with no chains of\n// smaller islands round the regular part as most billiards with both kinds\n// of motion have.\n//\n// The kind of a ball is decided by exactly that: in the cap and |L| > a is\n// regular, anything else is chaotic. The balls start two in five regular,\n// spread evenly over the cap's positions and headings with |L| > a, and the\n// rest spread evenly over the positions and headings of the whole table\n// with |L| \u003c a in the cap, so each kind starts in its own invariant measure\n// and the picture has nothing left to settle into. Every bounce is worked out exactly: the\n// arc, the flat underside of the cap on both sides of the stem, the stem's\n// walls and its floor, each a mirror.\n\nconst W = 64, H = 128, N = W * H;\nconst CX = 32, CY = 31.5, R = 30, HS = 95, EPS = 1e-9;\nconst { min, max, floor, ceil, sqrt, exp, cos, sin, abs, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// 360 balls, two in five regular at a throw. VEL LEDs a second per unit of\n// Speed. The table's outline and the dotted border circle |L| = a in the\n// cap sit just above the 24/255 an LED needs to count as lit.\nconst NB = 360, REG = 0.4, VEL = 20;\nconst RIM = 0.11, BORDER = 0.12;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// Inside the table, at least m from its walls (m \u003c 0: within -m outside).\nfunction inside(a, x, y, m) {\n  if (y >= 0) return x * x + y * y \u003c= (R - m) * (R - m) && (y >= m || abs(x) \u003c= a - m);\n  return y >= -HS + m && abs(x) \u003c= a - m;\n}\n\n// Where along (dx, dy) a ball at (x, y) meets the next wall, and the\n// wall's normal there. The ball's own y >= 0 means it is in the cap.\nconst HIT = [0, 0, 0];\nfunction hit(a, x, y, dx, dy) {\n  let t = Infinity, nx = 0, ny = 0;\n  // The arc: the far root of |p + t d| = R, landing on the upper half.\n  const b = x * dx + y * dy, c = x * x + y * y - R * R, d = b * b - c;\n  if (d >= 0) {\n    const u = -b + sqrt(d);\n    if (u > EPS && y + u * dy >= 0) (t = u), (nx = x + u * dx), (ny = y + u * dy);\n  }\n  if (dy \u003c 0) {\n    // The cap's flat underside, a \u003c= |x| \u003c= R on the line y = 0.\n    if (y >= 0) {\n      const u = -y / dy, hx = abs(x + u * dx);\n      if (u > EPS && u \u003c t && hx >= a) (t = u), (nx = 0), (ny = 1);\n    }\n    // The floor of the stem.\n    const u = (-HS - y) / dy;\n    if (u > EPS && u \u003c t && abs(x + u * dx) \u003c= a) (t = u), (nx = 0), (ny = 1);\n  }\n  // The stem's walls, x = +-a below the flat side.\n  if (dx !== 0) {\n    const u = ((dx > 0 ? a : -a) - x) / dx, hy = y + u * dy;\n    if (u > EPS && u \u003c t && hy \u003c= 0 && hy >= -HS) (t = u), (nx = 1), (ny = 0);\n  }\n  const n = sqrt(nx * nx + ny * ny) || 1;\n  HIT[0] = t;\n  HIT[1] = nx / n;\n  HIT[2] = ny / n;\n}\n\n// A new ball of the given kind, spread evenly over that kind's part of the\n// phase space: position even over the area, heading even over the circle.\nfunction throwBall(P, i, regular) {\n  const a = P.a, capA = (PI * R * R) / 2, stemA = 2 * a * HS;\n  for (let k = 0; k \u003c 20000; k++) {\n    let x, y;\n    if (regular || Math.random() * (capA + stemA) \u003c capA) {\n      x = (Math.random() * 2 - 1) * R;\n      y = Math.random() * R;\n      if (x * x + y * y > (R - 0.3) * (R - 0.3)) continue;\n    } else {\n      x = (Math.random() * 2 - 1) * (a - 0.3);\n      y = -Math.random() * (HS - 0.3);\n    }\n    const th = Math.random() * 2 * PI, dx = cos(th), dy = sin(th), L = abs(x * dy - y * dx);\n    if (y >= 0 && L > a !== regular) continue;\n    P.x[i] = x;\n    P.y[i] = y;\n    P.dx[i] = dx;\n    P.dy[i] = dy;\n    return;\n  }\n  P.x[i] = 0;\n  P.y[i] = -HS / 2;\n  P.dx[i] = 0.6;\n  P.dy[i] = 0.8;\n}\n\nfunction throwAll(P) {\n  for (let i = 0; i \u003c NB; i++) throwBall(P, i, i \u003c NB * REG);\n}\n\n// The kind and colour of ball i: regular balls by where their caustic lies\n// between the border and the rim, chaotic ones all one colour.\nfunction paint(P, i) {\n  const x = P.x[i], y = P.y[i], L = abs(x * P.dy[i] - y * P.dx[i]), a = P.a;\n  if (y >= 0 && L > a) hsv(P.hue + 0.1 + 0.07 * ((L - a) / (R - a)), 0.9, 1, P.col, i * 3);\n  else hsv(P.hue + 0.57, 0.8, 1, P.col, i * 3);\n}\n\n// Lights the LEDs a ball passes between (x0, y0) and (x1, y1), each once,\n// w0 at the start fading up to w1 at the end.\nfunction trail(P, i, x0, y0, x1, y1, w0, w1) {\n  const n = max(1, ceil(sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) / 0.6)), buf = P.buf, c = i * 3;\n  const cr = P.col[c], cg = P.col[c + 1], cb = P.col[c + 2];\n  for (let j = 1; j \u003c= n; j++) {\n    const t = j / n, X = floor(CX + x0 + (x1 - x0) * t), Y = floor(CY - (y0 + (y1 - y0) * t));\n    const p = cl(Y, 0, H - 1) * W + cl(X, 0, W - 1);\n    if (p === P.lastp) continue;\n    P.lastp = p;\n    const w = w0 + (w1 - w0) * t, q = p * 3;\n    buf[q] += cr * w;\n    buf[q + 1] += cg * w;\n    buf[q + 2] += cb * w;\n  }\n}\n\n// Ball i flies s LEDs, bouncing off the walls as a mirror.\nfunction fly(P, i, s, w0, w1) {\n  const a = P.a;\n  let x = P.x[i], y = P.y[i], dx = P.dx[i], dy = P.dy[i], done = 0;\n  for (let k = 0; k \u003c 32 && done \u003c s; k++) {\n    hit(a, x, y, dx, dy);\n    const bounce = HIT[0] \u003c s - done, t = bounce ? HIT[0] : s - done;\n    const x1 = x + t * dx, y1 = y + t * dy;\n    trail(P, i, x, y, x1, y1, w0 + ((w1 - w0) * done) / s, w0 + ((w1 - w0) * (done + t)) / s);\n    x = x1;\n    y = y1;\n    done += t;\n    if (bounce) {\n      const nx = HIT[1], ny = HIT[2], d = dx * nx + dy * ny;\n      dx -= 2 * d * nx;\n      dy -= 2 * d * ny;\n      const n = sqrt(dx * dx + dy * dy);\n      dx /= n;\n      dy /= n;\n    }\n  }\n  P.x[i] = x;\n  P.y[i] = y;\n  P.dx[i] = dx;\n  P.dy[i] = dy;\n  // Rounding can, very rarely, slip a ball out past a corner of the stem;\n  // it is thrown again, into the stem's kind.\n  if (!inside(a, x, y, -0.05)) throwBall(P, i, false);\n}\n\n// The outline of the table and the border circle |L| = a in the cap.\nfunction table(P) {\n  const a = P.a, m = P.rim;\n  m.fill(0);\n  const put = (x, y, v) => {\n    const p = cl(floor(CY - y), 0, H - 1) * W + cl(floor(CX + x), 0, W - 1);\n    if (v > m[p]) m[p] = v;\n  };\n  const o = 0.7;\n  for (let k = 0; k \u003c= 600; k++) {\n    const t = (k / 600) * PI;\n    put((R + o) * cos(t), (R + o) * sin(t), RIM);\n  }\n  for (let x = a + o; x \u003c= R + o; x += 0.5) put(x, -o, RIM), put(-x, -o, RIM);\n  for (let y = -o; y >= -HS - o; y -= 0.5) put(a + o, y, RIM), put(-a - o, y, RIM);\n  for (let x = -a - o; x \u003c= a + o; x += 0.5) put(x, -HS - o, RIM);\n  // The border, dotted: no regular ball's chord comes inside it.\n  for (let k = 0; k \u003c= 40; k++) {\n    const t = (k / 40) * PI;\n    put(a * cos(t), a * sin(t), BORDER);\n  }\n}\n\nexport function setup(params) {\n  const F64 = (n) => new Float64Array(n);\n  params.s = {\n    x: F64(NB), y: F64(NB), dx: F64(NB), dy: F64(NB),\n    col: new Float32Array(NB * 3), buf: new Float32Array(N * 3), img: new Float32Array(N * 3),\n    rim: new Float32Array(N), a: 0.3 * R, hue: 0, lastp: -1, tint: [0, 0, 0],\n  };\n  table(params.s);\n  throwAll(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0.3, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0] || 0;\n  const v = VEL * cl(k[1] == null ? 2 : k[1], 0.2, 3), tr = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const tau = 0.05 + 1.5 * tr * tr * tr, f = exp(-d / tau), B = min(1, 0.09 / tau);\n  hsv(P.hue + 0.57, 0.5, 1, P.tint, 0);\n\n  // A new stem width squeezes or spreads the balls in the stem with it.\n  const a = R * cl(k[2] == null ? 0.3 : k[2], 0.3, 0.9);\n  if (abs(a - P.a) > 1e-6) {\n    const s = a / P.a;\n    for (let i = 0; i \u003c NB; i++) if (P.y[i] \u003c 0) P.x[i] *= s;\n    P.a = a;\n    table(P);\n  }\n  if (input.btnPressed && input.btnPressed[0]) throwAll(P);\n\n  const buf = P.buf;\n  for (let q = 0; q \u003c N * 3; q++) buf[q] *= f;\n  if (d > 0)\n    for (let i = 0; i \u003c NB; i++) {\n      paint(P, i);\n      P.lastp = -1;\n      fly(P, i, v * d, B * f, B);\n    }\n  for (let q = 0; q \u003c N * 3; q++) if (buf[q] > 1.2) buf[q] = 1.2;\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const img = P.img, buf = P.buf, m = P.rim, t = P.tint;\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    img[q] = max(buf[q], t[0] * m[p]);\n    img[q + 1] = max(buf[q + 1], t[1] * m[p]);\n    img[q + 2] = max(buf[q + 2], t[2] * m[p]);\n  }\n  for (let i = 0; i \u003c NB; i++) {\n    paint(P, i);\n    const q = (cl(floor(CY - P.y[i]), 0, H - 1) * W + cl(floor(CX + P.x[i]), 0, W - 1)) * 3, c = i * 3;\n    img[q] = max(img[q], P.col[c]);\n    img[q + 1] = max(img[q + 1], P.col[c + 1]);\n    img[q + 2] = max(img[q + 2], P.col[c + 2]);\n  }\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3)\n    display.setPixel(p % W, (p / W) | 0, round(cl(img[q], 0, 1) * 255), round(cl(img[q + 1], 0, 1) * 255), round(cl(img[q + 2], 0, 1) * 255));\n}\n","neon-spreading":"// ===== Patternflow pattern =====\n// Title:   Neon Spreading\n// Family:  type\n// Idea:    A lattice of thin white lines turns slowly over the black panel, and wherever its lines pass through the three big round letters of a word stacked down the panel those stretches of line are drawn in a dimmer colour, nothing else, so the eye spreads the colour into a glowing veil filling each letter between the lines, though every LED between them is dark; the letters shrink to their spines and swell into the next word in the next colour.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: neon colour spreading (Harrie van Tuijl, A new visual illusion: neonlike color spreading and complementary color induction between subjective contours, Acta Psychologica, 1975), after the chromatic spreading Dario Varin described in 1971; round-stroke capitals drawn for this pattern, pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pitch=4..9, Fill=0..1\n//\n// Knob 1: Hue. Turns the colours of the words round the wheel, which skips red-orange. At 0 the words go cyan HUE, violet FOG, rose AIR and green SEE; at 0.5 rose, green, cyan and blue. The lines stay white.\n// Knob 2: Speed. At 2 the lattice turns 4 degrees a second, so it comes back to itself every 22.5 s, and a word holds 4 s, shrinks to its spines in 0.9 s and the next one swells in 0.9 s. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Pitch. LEDs between the lattice's lines: 4 at the opening, where a stroke 9 LEDs wide holds two or three lines each way and the veil fills it, up to 9, where a stroke holds one line or none and the colour stays on its segments.\n// Knob 4: Fill. A real fill of the letters for comparison, painted between the lines in the word's colour: none up to 0.1, so at the opening 0.06 no LED inside a letter is lit but the line segments; 5% of full at 0.25, 13% at 0.5 and 30% at 1.\n// Buttons: K1 tap shrinks the word now and brings the next.\n\n// Every LED of the panel is on a line of the lattice or dark, until Fill\n// paints the letters. The lattice is two families of parallel lines, at\n// angles th and th + 90 degrees through the panel's centre, Pitch apart. An\n// LED's light goes by its distance d from the nearest line, 1.3 - 1.6 d:\n// full within 0.19 LEDs of the line, half at 0.5, dark from 0.81, a little\n// sharper than plain coverage so that a turning line keeps its weight.\n// The word is a distance field: the distance from each LED to the spines\n// of its letters, round strokes drawn as polylines and elliptic arcs, and a\n// letter covers the LEDs nearer its spine than half the stroke.\n// Where a line crosses a letter it changes from white at 74% to the word's\n// colour at 58% of its brightest channel; a coloured stretch is dimmer than\n// the white line and brighter than the black between, which is what the\n// spreading needs. The edge of the letter falls across a line within one\n// LED, so the colour starts and stops on the letter's outline, and the eye\n// carries it across the dark gaps to that outline.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n// Three letters down the panel, each in a box 56 by 36, 4 apart; strokes 9\n// LEDs wide.\nconst BX = 4, BW = 56, BH = 36, BY = [6, 46, 86], WT = 9;\nconst HOLD = 4, OUT = 0.9, IN = 0.9, HUE0 = 0.427;\nconst WHITE = 0.74, SEG = 0.58;\nconst WORDS = [\"HUE\", \"FOG\", \"AIR\", \"SEE\"], HUES = [0, 0.317, 0.524, 0.732];\n\n// Points of an elliptic arc in the unit box, y down, angles in degrees\n// (0 right, 90 down).\nfunction arc(cx, cy, rx, ry, a0, a1, n = 10) {\n  const out = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    out.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return out;\n}\n// The spines, as polylines in the unit box.\nconst GLYPHS = {\n  H: [[[0, 0], [0, 1]], [[1, 0], [1, 1]], [[0, 0.5], [1, 0.5]]],\n  U: [[[0, 0], [0, 0.45], ...arc(0.5, 0.45, 0.5, 0.55, 180, 0, 12), [1, 0]]],\n  E: [[[1, 0], [0, 0], [0, 1], [1, 1]], [[0, 0.5], [0.82, 0.5]]],\n  F: [[[1, 0], [0, 0], [0, 1]], [[0, 0.5], [0.8, 0.5]]],\n  O: [arc(0.5, 0.5, 0.5, 0.5, 0, 360, 24)],\n  G: [[...arc(0.5, 0.5, 0.5, 0.5, -40, -360, 20), [1, 0.5], [1, 0.62]], [[1, 0.55], [0.58, 0.55]]],\n  A: [[[0, 1], [0.5, 0], [1, 1]], [[0.24, 0.62], [0.76, 0.62]]],\n  I: [[[0.5, 0], [0.5, 1]], [[0.22, 0], [0.78, 0]], [[0.22, 1], [0.78, 1]]],\n  R: [[[0, 1], [0, 0], [0.68, 0], ...arc(0.68, 0.25, 0.32, 0.25, -90, 90, 10), [0, 0.5]], [[0.5, 0.5], [1, 1]]],\n  S: [[...arc(0.5, 0.25, 0.5, 0.25, -20, -270, 12), ...arc(0.5, 0.75, 0.5, 0.25, -90, 160, 12)]],\n};\n\n// The word's distance field: each LED's distance to the nearest spine.\nfunction field(word, out) {\n  const segs = [];\n  const r = WT / 2, sx = BW - 2 * r, sy = BH - 2 * r;\n  for (let c = 0; c \u003c word.length; c++)\n    for (const line of GLYPHS[word[c]]) {\n      const pts = line.map(([x, y]) => [BX + r + x * sx, BY[c] + r + y * sy]);\n      for (let i = 0; i + 1 \u003c pts.length; i++) segs.push([...pts[i], ...pts[i + 1]]);\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let best = 1e9;\n      for (const [x0, y0, x1, y1] of segs) {\n        const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n        const t = l2 > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / l2, 0, 1) : 0;\n        const ex = px - x0 - t * dx, ey = py - y0 - t * dy, d2 = ex * ex + ey * ey;\n        if (d2 \u003c best) best = d2;\n      }\n      out[y * W + x] = sqrt(best);\n    }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n// The wheel without red-orange, which reads brown when dim: 0 to 1 runs from\n// yellow through green, cyan, blue and violet to rose.\nconst wheel = (h) => 0.15 + 0.82 * (h - floor(h));\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, pitch: 4, fill: 0.06, th: 0.21, t: 0, ph: 1, wi: 0, btn: false,\n    dist: new Float32Array(N), col: [0, 0, 0],\n  });\n  field(WORDS[0], S.dist);\n  return S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.pitch = cl(k[2] == null ? 4 : k[2], 4, 9);\n  S.fill = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && S.ph !== 2) (S.ph = 2), (S.t = 0);\n  S.btn = btn;\n  const d = (d0 * S.speed) / 2;\n  S.th += (d * 4 * PI) / 180;\n  S.t += d;\n  // Phases: 1 the word holds, 2 it shrinks to its spines, 0 the next swells.\n  if (S.ph === 1 && S.t >= HOLD) (S.ph = 2), (S.t = 0);\n  if (S.ph === 2 && S.t >= OUT) {\n    S.wi = (S.wi + 1) % WORDS.length;\n    field(WORDS[S.wi], S.dist);\n    S.ph = 0;\n    S.t = 0;\n  }\n  if (S.ph === 0 && S.t >= IN) (S.ph = 1), (S.t = 0);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const dist = S.dist, col = hsv(wheel(S.hue + HUE0 + HUES[S.wi]), 1, 1, S.col);\n  // Half the stroke: whole while the word holds, down to nothing at its\n  // spines between words.\n  const r = (WT / 2) * (S.ph === 1 ? 1 : S.ph === 2 ? 1 - ease(S.t / OUT) : ease(S.t / IN));\n  const c = cos(S.th), s = sin(S.th), pt = S.pitch, fill = (0.3 * max(0, S.fill - 0.1)) / 0.9;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x - 32, py = y - 64;\n      const u = (px * c + py * s) / pt, v = (py * c - px * s) / pt;\n      const du = abs(u - round(u)) * pt, dv = abs(v - round(v)) * pt;\n      const line = cl(1.3 - 1.6 * min(du, dv), 0, 1);\n      // How much of this LED the letter covers, with a one-LED edge.\n      const m = r > 0 ? cl(r - dist[y * W + x] + 0.5, 0, 1) : 0;\n      const wl = line * WHITE * (1 - m), cs = line * SEG * m, f = fill * m * (1 - line);\n      display.setPixel(x, y, round(cl(wl + col[0] * (cs + f), 0, 1) * 255), round(cl(wl + col[1] * (cs + f), 0, 1) * 255), round(cl(wl + col[2] * (cs + f), 0, 1) * 255));\n    }\n}\n","quantum-walk":"// ===== Patternflow pattern =====\n// Title:   Quantum Walk\n// Family:  sim\n// Idea:    Space runs across the panel, two lattice sites to an LED, and time down it, one step a row, as a Hadamard walk started with its coin on L writes its space-time diagram: the chance of finding the walker at each site with its coin on L fills a cone whose edges, the two ballistic fronts near plus and minus t over root 2, glow white where the walker is most likely found, cut through by nested dark arcs where that half of the wave cancels itself, and once the diagram is written a gold dotted line traces down the middle at the classical walk's square root of t, before the panel fades and the walk starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: discrete-time quantum walk (Yakir Aharonov, Luiz Davidovich and Nicim Zagury, 1993), the Hadamard walk on the line (Andris Ambainis, Eric Bach, Ashwin Nayak, Ashvin Vishwanath and John Watrous, 2001), its limit law (Norio Konno, 2002), the walk with a measured coin (Todd Brun, Hilary Carteret and Andris Ambainis, 2003), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Measure=0..1, Coin=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the probability is azure and the classical line gold, at 0.25 violet with green, at 0.5 red-orange with blue.\n// Knob 2: Speed. Steps a second, 33 for each unit: 66 at the opening 2, so a diagram of 127 steps is written in 1.9 s, then held 5.5 s, the gold line tracing down in the first 2.5 s of it, faded in 0.3 s and left dark for 0.4 s. At 0.2 a diagram takes 19 s, at 3 it takes 1.3 s.\n// Knob 3: Measure. The chance p that the coin is measured after each flip, 10^(3 (knob - 1)): none at 0, 0.0056 at 0.25, 0.032 at 0.5, 0.18 at 0.75 and every step at 1. The arcs fade from about row 1/p on (row 31 at 0.5, row 6 at 0.75) and the cone gives way to a bell; at 1 it is the classical walk, whose standard deviation on the last row is sqrt(127) = 11.3 sites, 5.6 LEDs.\n// Knob 4: Coin. The coin is [[cos q, sin q], [sin q, -cos q]] and its fronts run at cos q sites a step. Within 0.12 of the middle (it opens at 0.06) it is Hadamard's, cos q = 0.707, and the fronts leave the panel on row 90; at -1 cos q = 0.96 and they leave on row 67; at -0.5 it is 0.82 (row 78), at 0.5 it is 0.53 (row 120), and at 1 it is 0.3, and the fronts end 19 LEDs either side of the middle.\n// Buttons: K1 tap starts the walk again with the next starting coin: L (the opening), (L + iR)/sqrt 2, then R. K2 tap changes what the colour shows: the chance of the walker at a site with its coin on L (the opening), with its coin on R, or at the site at all.\n\n// The walker sits on a site x of the line and carries a coin, a qubit with\n// the states L and R. A step flips the coin with the Hadamard matrix\n// (1/sqrt 2) [[1, 1], [1, -1]] and then moves the L part one site left and\n// the R part one site right. After t steps the walker is only ever on sites\n// of the parity of t, so each row here keeps one site of each LED's pair.\n//\n// A classical walker with a fair coin spreads as sqrt(t). This one spreads\n// as t: Ambainis and his coauthors found the chance pile up in two peaks\n// near x = -t / sqrt 2 and x = t / sqrt 2, and Konno found the limit law of\n// x / t, which lives between -cos q and cos q for the coin of K4. Started\n// with its coin on L the walk drifts left; started in (L + iR)/sqrt 2 it is\n// symmetric.\n//\n// Each row is scaled to its own largest value, so the late rows show as\n// well as the first. Scaled plainly, the narrow peaks would leave the rest\n// of a row dark, so the colour climbs as the square to full at 4% of that\n// value, and white shows where the position probability passes 12% of its\n// largest. The L part of the wave alone falls nearly to zero along nested\n// arcs, where the two travelling waves it is made of cancel. The R part has\n// its own arcs between them, and in the sum they fill each other in (K2 tap\n// shows all three).\n//\n// K3 measures the coin after each flip with chance p. The walker is then in\n// a mixed state, held here as its density matrix over sites and coin, up\n// to 256 by 256. A measurement multiplies every entry between L and R by\n// 1 - p, and the rest of a step is the flip and the shift as before. At\n// p = 1 nothing quantum is left and the walk is classical: a fair coin for\n// Hadamard's, and for other coins a walk that keeps its direction with\n// chance cos^2 q, whose standard deviation comes close to sqrt(t) cot q, the\n// gold line.\n\nconst W = 64, H = 128, N = W * H, K = H + 2, D = 2 * K;\nconst { floor, max, sqrt, log, round, pow, abs, SQRT1_2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Rows a second per unit of Speed, and the hold, fade and dark gap after a\n// diagram is written, in seconds.\nconst RATE = 33, HOLD = 5.5, FADE = 0.3, GAP = 0.4, TRACE = 2.5;\n// The brightness ramp: full at KNEE of the row's largest value, as the\n// square below it; white from WKNEE of the row's largest probability.\nconst KNEE = 0.04, GAM = 2, WKNEE = 0.12;\n// Weights of the walks started in |L> and in |R> for the three starts.\nconst STARTS = [[1, 0], [0.5, 0.5], [0, 1]];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 66, p: 0, c: SQRT1_2, s: SQRT1_2, view: 0, start: 0,\n    t: 0, acc: 0, phase: 0, clock: 0,\n    a1: new Float64Array(K), b1: new Float64Array(K), a2: new Float64Array(K), b2: new Float64Array(K),\n    mixed: false, r: null, r2: null,\n    PL: new Float32Array(N), PR: new Float32Array(N), mL: new Float32Array(H), mR: new Float32Array(H),\n    mS: new Float32Array(H), cot: new Float32Array(H),\n    buf: new Float32Array(N * 3), col: [0, 0, 0], gold: [0, 0, 0],\n  };\n  begin(params.s);\n}\n\nfunction begin(S) {\n  S.t = 0;\n  S.acc = 0;\n  S.phase = 0;\n  S.clock = 0;\n  for (const a of [S.a1, S.b1, S.a2, S.b2]) a.fill(0);\n  S.a1[0] = 1;\n  S.b2[0] = 1;\n  S.mixed = false;\n  S.PL.fill(0);\n  S.PR.fill(0);\n  record(S);\n}\n\n// Row t of the panel holds the walk after t steps. Its active sites are\n// x = 2k - t for k = 0..t; LED j holds the sites 2(j - 32) and 2(j - 32) + 1,\n// exactly one of which is active, so k = j - 32 + ceil(t / 2).\nfunction record(S) {\n  const t = S.t, o = t * W, sh = (t + 1) >> 1, [w1, w2] = STARTS[S.start];\n  let mL = 0, mR = 0, mS = 0;\n  for (let k = 0; k \u003c= t; k++) {\n    let l, r;\n    if (S.mixed) {\n      l = S.r[2 * k * D + 2 * k];\n      r = S.r[(2 * k + 1) * D + 2 * k + 1];\n    } else {\n      l = w1 * S.a1[k] * S.a1[k] + w2 * S.a2[k] * S.a2[k];\n      r = w1 * S.b1[k] * S.b1[k] + w2 * S.b2[k] * S.b2[k];\n    }\n    if (l > mL) mL = l;\n    if (r > mR) mR = r;\n    if (l + r > mS) mS = l + r;\n    const j = k - sh + 32;\n    if (j >= 0 && j \u003c W) {\n      S.PL[o + j] = l;\n      S.PR[o + j] = r;\n    }\n  }\n  S.mL[t] = mL;\n  S.mR[t] = mR;\n  S.mS[t] = mS;\n  S.cot[t] = S.c / S.s;\n}\n\n// One step of a real walk: the coin [[c, s], [s, -c]] on (L, R), then L\n// moves one site left and R one site right.\nfunction walk(a, b, t, c, s) {\n  for (let k = t; k >= 0; k--) {\n    const A = a[k], B = b[k];\n    a[k] = c * A + s * B;\n    b[k + 1] = s * A - c * B;\n  }\n  b[0] = 0;\n}\n\nfunction step(S) {\n  const t = S.t, c = S.c, s = S.s, [w1, w2] = STARTS[S.start];\n  if (S.p > 0 && !S.mixed) {\n    if (!S.r) {\n      S.r = new Float64Array(D * D);\n      S.r2 = new Float64Array(D * D);\n    }\n    // The real part of the density matrix; the imaginary part never\n    // reaches the diagonal, so it is left out.\n    const n = 2 * (t + 1), r = S.r, a1 = S.a1, b1 = S.b1, a2 = S.a2, b2 = S.b2;\n    for (let i = 0; i \u003c n; i++) {\n      const h = i >> 1, p1 = i & 1 ? b1[h] : a1[h], p2 = i & 1 ? b2[h] : a2[h];\n      for (let j = 0; j \u003c n; j++) {\n        const g = j >> 1;\n        r[i * D + j] = w1 * p1 * (j & 1 ? b1[g] : a1[g]) + w2 * p2 * (j & 1 ? b2[g] : a2[g]);\n      }\n    }\n    S.mixed = true;\n  }\n  if (!S.mixed) {\n    if (w1) walk(S.a1, S.b1, t, c, s);\n    if (w2) walk(S.a2, S.b2, t, c, s);\n  } else {\n    // rho -> (1 - p) C rho C + p (the same with the coin measured), which\n    // scales every entry between L and R by 1 - p, then the shift.\n    const r = S.r, q = S.r2, e = 1 - S.p, n2 = 2 * (t + 2), z = 2 * (t + 1);\n    for (let i = 0; i \u003c n2; i++) {\n      q[D + i] = q[i * D + 1] = 0;\n      q[z * D + i] = q[i * D + z] = 0;\n    }\n    for (let k1 = 0; k1 \u003c= t; k1++) {\n      const i0 = 2 * k1 * D, i1 = i0 + D, L1 = 2 * k1, R1 = L1 + 3;\n      for (let k2 = k1; k2 \u003c= t; k2++) {\n        const j0 = 2 * k2, w = r[i0 + j0], x = r[i0 + j0 + 1], y = r[i1 + j0], zz = r[i1 + j0 + 1];\n        const u0 = c * w + s * y, u1 = c * x + s * zz, v0 = s * w - c * y, v1 = s * x - c * zz;\n        const L2 = j0, R2 = j0 + 3;\n        q[L1 * D + L2] = q[L2 * D + L1] = u0 * c + u1 * s;\n        q[L1 * D + R2] = q[R2 * D + L1] = (u0 * s - u1 * c) * e;\n        q[R1 * D + L2] = q[L2 * D + R1] = (v0 * c + v1 * s) * e;\n        q[R1 * D + R2] = q[R2 * D + R1] = v0 * s - v1 * c;\n      }\n    }\n    S.r = q;\n    S.r2 = r;\n  }\n  S.t = t + 1;\n}\n\nfunction knobs(S, k) {\n  S.hue = k[0] || 0;\n  S.rate = RATE * cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const m = cl(k[2] || 0, 0, 1);\n  S.p = m \u003c= 0 ? 0 : pow(10, 3 * (m - 1));\n  // The peak speed |c| = cos(theta): 1/sqrt(2), Hadamard's, within 0.12 of\n  // the middle, out to 0.96 at -1 and in to 0.3 at +1.\n  const g = cl(k[3] == null ? 0.06 : k[3], -1, 1), u = max(0, abs(g) - 0.12) / 0.88;\n  S.c = g \u003c 0 ? SQRT1_2 + u * (0.96 - SQRT1_2) : SQRT1_2 - u * (SQRT1_2 - 0.3);\n  S.s = sqrt(1 - S.c * S.c);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, d = cl(dt || 0, 0, 0.1), bp = input.btnPressed || [];\n  knobs(S, input.knobValues || [0, 2, 0, 0.06]);\n  if (bp[1]) S.view = (S.view + 1) % 3;\n  if (bp[0]) {\n    S.start = (S.start + 1) % 3;\n    begin(S);\n  }\n  S.clock += d;\n  if (S.phase === 0) {\n    S.acc += d * S.rate;\n    while (S.acc >= 1 && S.t \u003c H - 1) {\n      step(S);\n      record(S);\n      S.acc -= 1;\n    }\n    if (S.t >= H - 1) {\n      S.phase = 1;\n      S.clock = 0;\n    }\n  } else if (S.phase === 1 && S.clock >= HOLD) {\n    S.phase = 2;\n    S.clock = 0;\n  } else if (S.phase === 2 && S.clock >= FADE) {\n    S.phase = 3;\n    S.clock = 0;\n  } else if (S.phase === 3 && S.clock >= GAP) begin(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, col = hsv(0.55 + S.hue, S.col), gold = hsv(0.12 + S.hue, S.gold), lw = log(1 / WKNEE);\n  buf.fill(0);\n  const fade = S.phase === 2 ? 1 - S.clock / FADE : S.phase === 3 ? 0 : 1;\n  const traced = S.phase === 0 ? -1 : S.phase === 1 ? (H * S.clock) / TRACE : H;\n  if (fade > 0)\n    for (let y = 0; y \u003c= S.t; y++) {\n      const m = S.view === 0 ? S.mL[y] : S.view === 1 ? S.mR[y] : S.mS[y], ms = S.mS[y];\n      if (!(m > 0)) continue;\n      const pen = S.phase === 0 && y === S.t ? 0.6 : 0;\n      for (let x = 0; x \u003c W; x++) {\n        const i = y * W + x, P = S.view === 0 ? S.PL[i] : S.view === 1 ? S.PR[i] : S.PL[i] + S.PR[i], v = P / m;\n        const lev = v >= KNEE ? 1 : pow(v / KNEE, GAM);\n        // White where the walker is most likely found, from the position\n        // probability whatever the view.\n        const vs = (S.PL[i] + S.PR[i]) / ms;\n        const wh = max(vs > WKNEE ? (0.9 * log(vs / WKNEE)) / lw : 0, pen * lev), o = i * 3;\n        buf[o] = (col[0] * lev * (1 - wh) + wh) * fade;\n        buf[o + 1] = (col[1] * lev * (1 - wh) + wh) * fade;\n        buf[o + 2] = (col[2] * lev * (1 - wh) + wh) * fade;\n      }\n      // The classical walk's standard deviation, sqrt(t) cot(theta) sites,\n      // traced down the diagram once it is written.\n      if (y % 2 || y > traced) continue;\n      const sd = sqrt(y) * S.cot[y];\n      for (const sg of [-1, 1]) {\n        const x = 32 + floor((sg * sd) / 2);\n        if (x \u003c 0 || x >= W) continue;\n        const o = (y * W + x) * 3;\n        buf[o] = gold[0] * fade;\n        buf[o + 1] = gold[1] * fade;\n        buf[o + 2] = gold[2] * fade;\n      }\n    }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","ramsey-fringes":"// ===== Patternflow pattern =====\n// Title:   Ramsey Fringes\n// Family:  wave\n// Idea:    Every row is a two-level atom at its own detuning and every column a longer dark gap between two short pulses, so Ramsey's formula fans out into hyperbolic fringes that open from the single-pulse line on the left and close in on resonance to the right, a central fringe 2.9 rows from crest to dark at the right edge inside a pedestal that fills the panel, while the relative phase of the two pulses slides every fringe on by one place each turn.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ramsey's method of separated oscillatory fields (Norman F. Ramsey, 1950), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Free=-1..1, Pulse=0..1\n//\n// Knob 1: Hue. Turns the colour ramp round the wheel. At 0 an atom left in its ground state is deep violet and the ramp climbs through rose to a pale peach at full excitation; at 0.5 it runs from a dark green to a pale azure.\n// Knob 2: Speed. How fast the phase of the second pulse turns against the first: 0.17 turns a second for each unit, so one turn in 2.9 s at the opening 2, 29 s at 0.2 and 2 s at 3. Each turn moves every fringe on by one place.\n// Knob 3: Free. The longest free time, at the right edge: 22 over the Rabi frequency at the opening 0, the length of 14 pi/2 pulses, and 1.5 times shorter or longer at the ends (9.3 and 21). At the opening the central fringe at the right edge falls from its crest to dark in 2.9 rows, while the pedestal falls off to a crest of P = 0.04 at the top and bottom rows; at 1 the central fringe takes 1.9 rows and the fringes crowd towards the right.\n// Knob 4: Pulse. The area of each pulse, from the optimal pi/2 at 0 to pi at 1; the opening 0.06 is 0.53 pi. At 0.5 the fringes lose half their depth on resonance, and at pi the two pulses flip the atom and flip it back whatever the gap, so the middle row stays dark and the fringes live only in two lobes above and below.\n\n// In Rabi's method the atom crossed one oscillating field, and the width of\n// the line was set by the time it spent in it. Ramsey split the field in\n// two: a short pulse of length tau, a free time T with no field at all, and\n// a second short pulse. During the free time the atom's superposition keeps\n// the phase of its own transition while the field keeps the phase of the\n// oscillator, and the second pulse turns their difference Delta T into\n// population. With Rabi frequency Omega, detuning Delta and\n// W = sqrt(Omega^2 + Delta^2), the chance of finding the atom excited is\n//\n//   P = 4 (Omega/W)^2 sin^2(W tau/2)\n//       [cos(W tau/2) cos(chi/2) - (Delta/W) sin(W tau/2) sin(chi/2)]^2,\n//   chi = Delta T - phi,\n//\n// where phi is the phase of the second pulse against the first. The bracket\n// is one sinusoid in chi/2, R cos(chi/2 + beta), so P swings between 0 and\n// a crest set by the pulses alone: the pedestal, whose width is set by the\n// short pulses, about 1/tau. The fringes on top of it are spaced 2 pi / T\n// in detuning, so the longer the free time, the narrower the central\n// fringe. With pulses of area Omega tau = pi/2 the crest on resonance\n// reaches 1.\n//\n// Here the rows are the detuning, from +3.2 Omega at the top to -3.2 Omega\n// at the bottom, 0.05 Omega a row, and the columns the free time, from 0 at\n// the left to Tmax at the right. At T = 0 and phi = 0 the two pulses are\n// one pulse of area pi, and the left column is Rabi's line for it. The\n// fringes are the curves Delta T = phi + 2 pi n, hyperbolas that run out of\n// the left edge and crowd towards the middle row. On resonance chi does not\n// depend on T, so the middle rows are one even colour that brightens and\n// darkens as phi turns, while every other row runs through its fringes\n// along the free time.\n//\n// Brightness is a triangle wave of the fringe phase chi/2 + beta: dark where\n// P is 0, and at the crest the polar angle of the atom's Bloch vector there,\n// 2 asin(sqrt(Pmax)), as a share of pi. With pi/2 pulses on resonance that\n// is the Bloch angle exactly at every LED, since P = cos^2 makes\n// asin(sqrt(P)) a straight ramp; elsewhere the triangle keeps the crest and\n// the zeros and draws a straight ramp between them. So every fringe rises\n// and falls at one even slope instead of the sharp-bottomed sin^2.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, sin, cos, asin, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Detuning at the top and bottom rows, and the longest free time at the\n// opening, both in units of the Rabi frequency.\nconst DMAX = 3.2, T0 = 22;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    phi: 0, hue: 0, speed: 2, tmax: T0, area: PI / 2,\n    crest: new Float32Array(H), beta: new Float32Array(H),\n    lut: new Uint8Array(257 * 3), lh: -1, c: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.tmax = T0 * Math.pow(1.5, cl(k[2] || 0, -1, 1));\n  S.area = (PI / 2) * (1 + cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  S.phi += d * S.speed * 0.17 * TAU;\n  if (S.phi > TAU * 1000) S.phi -= TAU * 1000;\n}\n\n// Violet ground, rose in the middle, pale peach at full excitation.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let i = 0; i \u003c= 256; i++) {\n    const p = i / 256;\n    hsv(S.hue + 0.72 + 0.38 * p, 0.9 - 0.55 * p * p * p, 0.08 + 0.92 * p, S.c);\n    S.lut[i * 3] = round(S.c[0] * 255);\n    S.lut[i * 3 + 1] = round(S.c[1] * 255);\n    S.lut[i * 3 + 2] = round(S.c[2] * 255);\n  }\n}\n\nconst dlOf = (y) => (DMAX * (63.5 - y)) / 64;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const L = S.lut, tau = S.area;\n  // Per row the pulses fix the crest (as a Bloch angle over pi) and the\n  // phase beta they add to the fringes.\n  for (let y = 0; y \u003c H; y++) {\n    const dl = dlOf(y), w = sqrt(1 + dl * dl), a = (w * tau) / 2, sa = sin(a), ca = cos(a), b = (dl / w) * sa;\n    const r = (2 / w) * sa * sqrt(ca * ca + b * b);\n    S.crest[y] = (2 / PI) * asin(cl(r \u003c 0 ? -r : r, 0, 1));\n    S.beta[y] = atan2(b, ca);\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const A = S.crest[y], dl = dlOf(y), be = S.beta[y];\n    for (let x = 0; x \u003c W; x++) {\n      const T = (S.tmax * x) / (W - 1);\n      // The fringe phase in half turns, folded to the nearest crest.\n      let u = ((dl * T - S.phi) / 2 + be) / PI;\n      u -= floor(u + 0.5);\n      const i = round(A * (1 - 2 * (u \u003c 0 ? -u : u)) * 256) * 3;\n      display.setPixel(x, y, L[i], L[i + 1], L[i + 2]);\n    }\n  }\n}\n","semaphore":"// ===== Patternflow pattern =====\n// Title:   Semaphore\n// Family:  type\n// Idea:    A signaller, a white point with two arms each holding a square red and yellow flag, comes down the tall panel from the top edge, stops once for each letter of a word and swings its arms to that letter's pair of the eight clock directions, and every pose it leaves behind stays as a glyph with the decoded capital beside it, drawn in strokes of the same eight directions, so the word reads down the panel's height before the signaller drops off the bottom and the next word comes down over the last one.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: flag semaphore, each letter a pair of arm directions in 45 degree steps as the observer sees them; N over D as Gerald Holtom drew them into the nuclear disarmament symbol (1958); capitals drawn for this pattern in strokes of the same eight directions, pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Guide=0..1\n//\n// Knob 1: Hue. The panel's own colour, for the arms and the capitals; the flags stay red and yellow. At 0 the arms are azure and the capitals pale azure, at 0.25 violet, at 0.5 a red orange, at 0.75 green; the signaller itself is always near white.\n// Knob 2: Speed. At 2 a letter takes 1 s, 0.45 s of swing and 0.55 s held while its capital comes up beside it, and the finished word stands 1.6 s: HELLO takes 6.6 s and SOS 4.6 s. Every time goes as 2 / Speed, 10 s a letter at 0.2 and 0.67 s at 3.\n// Knob 3: Word. 0 HELLO, 1 FLAG, 2 SOS, 3 WAVE, 4 SEND, 5 QUIZ, 6 YACHT, 7 KNOT, and after each word the next; in SEND the N and the D stand one over the other. A word fills the 128 rows whatever its length: 42.7 rows a letter for three letters, 32 for four, 25.6 for five, with arms 18.3, 13.8 and 11 LEDs long, flags 7.7, 5.8 and 4.6 LEDs square, and capitals 32, 26 and 21 rows tall. Turning it starts the new word at once from the top, over what was laid of the last.\n// Knob 4: Guide. The clock face behind every pose: the eight spokes the arms can take, and at the end of each the outline of the square its flag would fill. Nothing at 0, too faint to see at the opening 0.06, and at 1 half as bright as an arm, so every pose reads as two of eight.\n\n// In flag semaphore a letter is the pair of directions the two arms point\n// in, each one of eight, 45 degrees apart. As the observer sees them on a\n// clock face, A to G hold one arm at 6 and send the other round from 7:30\n// to 4:30; H to N (with no J) hold one at 7:30; O to S at 9; T, U and Y at\n// 10:30; and J, V, W, X and Z are what is left. That is 26 of the 28 pairs\n// of eight directions. CODE below is that table, written as clock times.\n//\n// Which arm makes which direction is left out: the observer sees only\n// directions, and so does the code. Between letters the two arms swing to\n// the new pair along whichever matching of old to new needs the least\n// turning, each the short way round, so an arm that holds its direction\n// holds still: A to B moves one arm 45 degrees. Before a word and after it\n// the arms rest, both pointing down at 6.\n//\n// The capitals are drawn on a grid four units wide and six tall with\n// strokes at 0, 45 and 90 degrees only, the arms' own eight directions:\n// round letters are octagons, and N, V, X and Y bend to stay on the grid.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nconst CLOCK = { \"6\": 0, \"7:30\": 1, \"9\": 2, \"10:30\": 3, \"12\": 4, \"1:30\": 5, \"3\": 6, \"4:30\": 7 };\nconst CODE = {\n  A: \"6 7:30\", B: \"6 9\", C: \"6 10:30\", D: \"6 12\", E: \"6 1:30\", F: \"6 3\", G: \"6 4:30\",\n  H: \"7:30 9\", I: \"7:30 10:30\", K: \"7:30 12\", L: \"7:30 1:30\", M: \"7:30 3\", N: \"7:30 4:30\",\n  O: \"9 10:30\", P: \"9 12\", Q: \"9 1:30\", R: \"9 3\", S: \"9 4:30\",\n  T: \"10:30 12\", U: \"10:30 1:30\", Y: \"10:30 3\",\n  J: \"12 3\", V: \"12 4:30\", W: \"1:30 3\", X: \"1:30 4:30\", Z: \"3 4:30\",\n};\nconst POSE = {};\nfor (const c in CODE) POSE[c] = CODE[c].split(\" \").map((t) => CLOCK[t]);\nconst REST = [0, 0];\n\n// Direction k of the eight, k = 0 at 6 o'clock and on clockwise as the\n// observer sees it, as a unit vector on the panel (y down). A fractional k\n// is an arm on its way between two.\nconst dirOf = (k) => {\n  const a = PI + (k * PI) / 4;\n  return [sin(a), -cos(a)];\n};\n\n// Capitals: polylines through points xy of the 4 by 6 grid, y down.\nconst STROKES = {\n  A: \"06 02 20 42 46|04 44\", B: \"06 00 30 41 42 33 03|33 44 45 36 06\", C: \"41 30 10 01 05 16 36 45\",\n  D: \"00 20 42 44 26 06 00\", E: \"40 00 06 46|03 33\", F: \"40 00 06|03 33\", G: \"41 30 10 01 05 16 36 45 43 23\",\n  H: \"00 06|40 46|03 43\", I: \"10 30|20 26|16 36\", J: \"40 45 36 16 05\", K: \"00 06|40 13 46|03 13\",\n  L: \"00 06 46\", M: \"06 00 22 40 46\", N: \"06 00|01 45|40 46\", O: \"10 30 41 45 36 16 05 01 10\",\n  P: \"06 00 30 41 42 33 03\", Q: \"10 30 41 45 36 16 05 01 10|24 46\", R: \"06 00 30 41 42 33 03|23 45 46\",\n  S: \"41 30 10 01 02 13 33 44 45 36 16 05\", T: \"00 40|20 26\", U: \"00 05 16 36 45 40\", V: \"00 04 26 44 40\",\n  W: \"00 06 24 46 40\", X: \"00 01 45 46|40 41 05 06\", Y: \"00 01 23 41 40|23 26\", Z: \"00 40 41 05 06 46\",\n};\nconst SEGS = {};\nfor (const c in STROKES) {\n  const s = [];\n  for (const line of STROKES[c].split(\"|\")) {\n    const p = line.split(\" \").map((t) => [+t[0], +t[1]]);\n    for (let i = 1; i \u003c p.length; i++) s.push([p[i - 1][0], p[i - 1][1], p[i][0], p[i][1]]);\n  }\n  SEGS[c] = s;\n}\n\nconst WORDS = [\"HELLO\", \"FLAG\", \"SOS\", \"WAVE\", \"SEND\", \"QUIZ\", \"YACHT\", \"KNOT\"];\n\n// Seconds at Speed 2: the swing, a letter, the finished word's stand.\nconst SWING = 0.45, LETTER = 1, STAND = 1.6, DIM = 0.3, OLD = 0.3;\nconst RED = [1, 0.07, 0.04], YEL = [1, 0.8, 0], WHITE = [1, 1, 1];\n\n// Where a word of n letters puts things: slot height, arm, flag, the\n// hub's x, the capital's grid unit, its left edge and stroke.\nfunction layout(n) {\n  const h = H / n, r = 0.43 * h, u = n \u003c= 3 ? 5.4 : n === 4 ? 4.3 : 3.5;\n  const hx = r + 2.5, cx = (hx + r + 65) / 2 - 2 * u;\n  return { n, h, r, s: 0.42 * r, hx, u, cx, sw: 0.68 * u + 0.2, aw: 0.08 * r + 0.9 };\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nfunction paint(buf, x, y, c, a) {\n  if (a \u003c= 0 || x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  if (a > 1) a = 1;\n  buf[p] += (c[0] - buf[p]) * a;\n  buf[p + 1] += (c[1] - buf[p + 1]) * a;\n  buf[p + 2] += (c[2] - buf[p + 2]) * a;\n}\n\n// A line of width w from (x0, y0) to (x1, y1), its edge a pixel soft.\nfunction line(buf, x0, y0, x1, y1, w, c, a) {\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-9, e = w / 2 + 0.5;\n  for (let y = max(0, floor(min(y0, y1) - e)); y \u003c= min(H - 1, floor(max(y0, y1) + e)); y++)\n    for (let x = max(0, floor(min(x0, x1) - e)); x \u003c= min(W - 1, floor(max(x0, x1) + e)); x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / L2, 0, 1);\n      const ex = px - t * dx, ey = py - t * dy;\n      paint(buf, x, y, c, a * cl(e - sqrt(ex * ex + ey * ey), 0, 1));\n    }\n}\n\n// The flag on an arm from the hub (x, y) in direction d: a square of side\n// s on the staff's clockwise side, its outer edge at the arm's tip, split\n// on the diagonal from the staff's inner corner, red on the staff's side.\nfunction flag(buf, x, y, d, r, s, a) {\n  const px = -d[1], py = d[0], x0 = x + d[0] * (r - s), y0 = y + d[1] * (r - s);\n  const xs = [x0, x0 + d[0] * s, x0 + d[0] * s + px * s, x0 + px * s], ys = [y0, y0 + d[1] * s, y0 + d[1] * s + py * s, y0 + py * s];\n  for (let Y = max(0, floor(min(...ys))); Y \u003c= min(H - 1, floor(max(...ys))); Y++)\n    for (let X = max(0, floor(min(...xs))); X \u003c= min(W - 1, floor(max(...xs))); X++) {\n      let nr = 0, ny = 0;\n      for (let j = 0; j \u003c 3; j++)\n        for (let i = 0; i \u003c 3; i++) {\n          const qx = X + (i + 0.5) / 3 - x0, qy = Y + (j + 0.5) / 3 - y0, u = qx * d[0] + qy * d[1], v = qx * px + qy * py;\n          if (u \u003c 0 || u > s || v \u003c 0 || v > s) continue;\n          if (u >= v) nr++;\n          else ny++;\n        }\n      if (nr) paint(buf, X, Y, RED, (a * nr) / 9);\n      if (ny) paint(buf, X, Y, YEL, (a * ny) / 9);\n    }\n}\n\n// The outline of a flag's square, for the clock face.\nfunction ghost(buf, x, y, d, r, s, c, a) {\n  const px = -d[1], py = d[0], x0 = x + d[0] * (r - s), y0 = y + d[1] * (r - s);\n  const xs = [x0, x0 + d[0] * s, x0 + d[0] * s + px * s, x0 + px * s], ys = [y0, y0 + d[1] * s, y0 + d[1] * s + py * s, y0 + py * s];\n  for (let Y = max(0, floor(min(...ys))); Y \u003c= min(H - 1, floor(max(...ys))); Y++)\n    for (let X = max(0, floor(min(...xs))); X \u003c= min(W - 1, floor(max(...xs))); X++) {\n      const qx = X + 0.5 - x0, qy = Y + 0.5 - y0, u = qx * d[0] + qy * d[1], v = qx * px + qy * py;\n      const e = min(u, s - u, v, s - v);\n      paint(buf, X, Y, c, a * cl(1 - abs(e) * 1.4, 0, 1));\n    }\n}\n\n// The clock face behind a pose: the eight spokes, and at the end of each\n// the outline of the square a flag would fill there.\nfunction guide(buf, L, x, y, c, a) {\n  if (a \u003c= 0.004) return;\n  for (let k = 0; k \u003c 8; k++) {\n    const d = dirOf(k);\n    line(buf, x + d[0] * 2.5, y + d[1] * 2.5, x + d[0] * L.r, y + d[1] * L.r, 1, c, a);\n    ghost(buf, x, y, d, L.r, L.s, c, a);\n  }\n}\n\n// A pose: arms at directions (fractional k) a0 and a1 from the hub.\nfunction pose(buf, L, x, y, a0, a1, arm, alpha, live) {\n  for (const k of [a0, a1]) {\n    const d = dirOf(k);\n    line(buf, x, y, x + d[0] * L.r, y + d[1] * L.r, L.aw, arm, alpha);\n    flag(buf, x, y, d, L.r, L.s, alpha * (live ? 1 : 0.85));\n  }\n  // The signaller's body is a white point; a laid glyph keeps a dot.\n  if (live) for (let dy = -2; dy \u003c= 2; dy++) for (let dx = -2; dx \u003c= 2; dx++) paint(buf, floor(x) + dx, floor(y) + dy, WHITE, alpha * cl(2.3 - sqrt(dx * dx + dy * dy), 0, 1));\n  else paint(buf, floor(x), floor(y), arm, alpha);\n}\n\nfunction capital(buf, L, ch, top, c, a) {\n  const segs = SEGS[ch];\n  if (!segs || a \u003c= 0) return;\n  const u = L.u, x0 = L.cx, e = L.sw / 2 + 0.5;\n  for (let y = max(0, floor(top - e)); y \u003c= min(H - 1, floor(top + 6 * u + e)); y++)\n    for (let x = max(0, floor(x0 - e)); x \u003c= min(W - 1, floor(x0 + 4 * u + e)); x++) {\n      const gx = (x + 0.5 - x0) / u, gy = (y + 0.5 - top) / u;\n      let dmin = 1e9;\n      for (const s of segs) {\n        const dx = s[2] - s[0], dy = s[3] - s[1], L2 = dx * dx + dy * dy, px = gx - s[0], py = gy - s[1];\n        const t = cl((px * dx + py * dy) / L2, 0, 1), ex = px - t * dx, ey = py - t * dy, dd = ex * ex + ey * ey;\n        if (dd \u003c dmin) dmin = dd;\n      }\n      paint(buf, x, y, c, a * cl(e - sqrt(dmin) * u, 0, 1));\n    }\n}\n\n// A word's laid glyphs: the first `count`, each pose with its capital at\n// alpha a, those whose slot starts above row `cut` left out.\nfunction glyphs(buf, S, word, count, a, cut, col) {\n  const L = layout(word.length);\n  for (let k = 0; k \u003c count; k++) {\n    const top = k * L.h, f = a * cl((top - cut) / 4 + 1, 0, 1);\n    if (f \u003c= 0) continue;\n    const ch = word[k], p = POSE[ch], y = top + L.h / 2;\n    guide(buf, L, L.hx, y, col.guide, f * S.guide);\n    pose(buf, L, L.hx, y, p[0], p[1], col.arm, f, false);\n    capital(buf, L, ch, y - 3 * L.u, col.cap, f);\n  }\n}\n\n// The arms' matching from one pair to the next that turns them least,\n// each the short way round: [from, turn, from, turn] in eighths of a turn.\nfunction swing(p, q) {\n  const turn = (a, b) => {\n    let d = (((b - a) % 8) + 8) % 8;\n    if (d > 4) d -= 8;\n    return d;\n  };\n  const s1 = abs(turn(p[0], q[0])) + abs(turn(p[1], q[1])), s2 = abs(turn(p[0], q[1])) + abs(turn(p[1], q[0]));\n  return s1 \u003c= s2 ? [p[0], turn(p[0], q[0]), p[1], turn(p[1], q[1])] : [p[0], turn(p[0], q[1]), p[1], turn(p[1], q[0])];\n}\n\nfunction start(S, wi, oldWord, oldCount, dimmed) {\n  S.wi = ((wi % WORDS.length) + WORDS.length) % WORDS.length;\n  S.word = WORDS[S.wi];\n  S.old = oldWord;\n  S.oldCount = oldCount;\n  S.dimmed = !!dimmed;\n  S.tau = 0;\n}\n\nexport function setup(params) {\n  params.s = { buf: new Float32Array(N * 3), tau: 0, wi: 0, word: WORDS[0], old: \"\", oldCount: 0, dimmed: true, knob: -1, guide: 0, hue: 0 };\n  start(params.s, 0, WORDS[WORDS.length - 1], WORDS[WORDS.length - 1].length, true);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.guide = cl(k[3] == null ? 0.06 : k[3], 0, 1) * 0.5;\n  const kw = round(cl(k[2] || 0, 0, 7));\n  if (kw !== S.knob) {\n    // A fresh start opens on the word before, already sent; a turn of the\n    // knob keeps what is laid of the word in hand.\n    const before = WORDS[(kw + WORDS.length - 1) % WORDS.length];\n    if (S.knob \u003c 0) start(S, kw, before, before.length, true);\n    else start(S, kw, S.word, min(S.word.length, floor(S.tau / LETTER)), false);\n    S.knob = kw;\n  }\n  S.tau += (d * speed) / 2;\n  const n = S.word.length;\n  if (S.tau >= n * LETTER + STAND) start(S, S.wi + 1, S.word, n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, tau = S.tau, word = S.word, n = word.length, L = layout(n);\n  buf.fill(0);\n  const col = { arm: hsv(S.hue + 0.55, 0.8, 0.95), cap: hsv(S.hue + 0.55, 0.6, 1), guide: hsv(S.hue + 0.55, 0.25, 1) };\n  const pale = hsv(S.hue + 0.55, 0.3, 1);\n\n  // Where the signaller is: k is the letter in hand, n while it leaves.\n  const k = min(n, floor(tau / LETTER)), u = tau - k * LETTER, e = smooth(u / SWING);\n  const sy = ((k - 1) * (1 - e) + k * e + 0.5) * L.h;\n  const from = k === 0 ? REST : POSE[word[k - 1]], to = k \u003c n ? POSE[word[k]] : REST, m = swing(from, to);\n\n  // The last word, dimmed as this one starts, wiped where this one has come.\n  const fade = S.dimmed ? OLD : OLD + (1 - OLD) * (1 - smooth(tau / DIM));\n  if (S.old) glyphs(buf, S, S.old, S.oldCount, fade, k \u003c n ? sy + L.h / 2 : H + 99, col);\n  glyphs(buf, S, word, k, 1, -99, col);\n\n  // The letter in hand: its capital comes up while the pose is held.\n  if (k \u003c n) {\n    const ch = word[k], c = smooth((u - SWING) / (LETTER - SWING));\n    capital(buf, L, ch, sy - 3 * L.u, col.cap, c);\n  }\n  guide(buf, L, L.hx, sy, col.guide, S.guide * 1.3);\n  pose(buf, L, L.hx, sy, m[0] + m[1] * e, m[2] + m[3] * e, pale, 1, true);\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","chain-fountain":"// ===== Patternflow pattern =====\n// Title:   Chain Fountain\n// Family:  physics\n// Idea:    A bead chain drawn out of a pile in a pot by the weight of its own falling end rises in an arch above the pot before it falls to a growing heap on the floor, an inverted catenary half as high as the drop below it, its beads running round the path and the links between them coloured by their tension, until the pile runs out, the tail whips up and over, the pot fills again, and the end tips over the rim and the speed builds and the arch climbs off the rim to its height.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the chain fountain (Steve Mould, 2013), explained by John Biggins and Mark Warner (Understanding the chain fountain, Proceedings of the Royal Society A, 2014), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drop=67..75, Push=0.26..0.29\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the beads are cyan, the links between them pink where the chain is most taut at the top of the arch, the glow round it blue and the pot and floor pale lavender lines; at 0.5 the beads are coral red with green links at the top and an amber glow.\n// Knob 2: Speed. How fast the film runs. At 2 it is nine times slower than life at a centimetre to the LED: the chain runs at 3.8 m/s, 42 LEDs a second on the panel, and one run from the end tipping over to the tail landing takes 17 s, 19 s with the refill. Ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Drop. The bottom of the pot above the floor, 67 to 75 LEDs, which moves the rim from row 43 up to row 35. The fall from the pile to the floor goes from 70 to 78 LEDs, the speed from 3.8 to 4.0 m/s and the arch from 35 to 39 LEDs high, its top from row 16 to row 4.\n// Knob 4: Push. Biggins and Warner's alpha, the share of lambda v^2 with which the pile pushes up on the chain, 0.26 to 0.29, the floor's beta kept equal to it. The arch stands at 0.50 of the drop at 0.26, 0.57 at 0.275 and 0.65 at 0.29, where its top reaches row 6; with Drop also at 75 it runs 7 rows off the top of the panel.\n// Buttons: K1 tap pulls the end over the rim again and starts the chain from rest.\n\n// A chain running along its own length at speed v on a fixed path carries\n// a momentum flux lambda v^2 (lambda its mass per LED) besides its tension\n// T, and T - lambda v^2 obeys the equations of a chain hanging still. So in\n// steady flow the path is a catenary, and since T - lambda v^2 is negative\n// here it stands up as an arch: x = XT + a asinh(s / a) and\n// y = top + sqrt(a^2 + s^2) - a in arc length s from the top, with\n// T - lambda v^2 = -lambda g (a + depth below the top).\n//\n// Biggins and Warner closed it at the two ends. A link lifted from the pile\n// pivots, the pile pushes up on it, and the tension just above the pile is\n// (1 - alpha) lambda v^2 rather than lambda v^2. At the floor the tension\n// is beta lambda v^2. Down the fall h2 from the pickup to the floor that\n// gives g h2 = (1 - alpha - beta) v^2, and up the rise h1 to the top\n// h1 = alpha v^2 / g - a; as a goes to 0 this is their\n// h1 / h2 = alpha / (1 - alpha - beta). This pattern takes a = 3 LEDs and\n// beta = alpha, a landing link pivoting as a lifted one does, and keeps\n// alpha between 0.26 and 0.29 because there the arch stands half to two\n// thirds of the drop high and reaches the top third of the panel; with\n// alpha at 0.15 it would stand 12 LEDs over a 70 LED drop.\n//\n// Out of steady flow one equation runs the speed, for the length l in\n// flight: l dv/dt = g (drop from its upper end to its lower end), less\n// (1 - alpha) v^2 while the pile feeds it, plus beta v^2 once the end is\n// down. The arch stands at alpha v^2 / g - a for the speed of the moment,\n// or lies on the rim while that is lower. When the pile runs out nothing is\n// picked up and the free tail speeds up as it runs up, over and down. The\n// heap on the floor rises as it grows and shortens the fall, so the arch\n// sinks a few LEDs through a run.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sqrt, asinh, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// One LED is a centimetre and g is 981 LEDs per second squared; the film\n// runs TIME simulated seconds to the second at Speed 1.\nconst GRAV = 981, TIME = 1 / 18;\n// The floor row, the pot (inner columns PL..PR, DEPTH rows deep, the pile\n// at most PILE rows), the column where the chain turns over, the catenary\n// parameter a at the top, the chain's length and the beads' spacing.\nconst FLOOR = 124, PL = 9, PR = 27, DEPTH = 14, PILE = 10, XT = 28, A = 3;\nconst LC = 500, BEAD = 7, SUB = 4;\n// Seconds at Speed 2 the chain lies on the floor, and the pot refills.\nconst REST = 0.6, REFILL = 1;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, drop: 67, alpha: 0.26, ph: 0, pt: 0, M: 0, D: 0, v: 0, ytop: 0, fill: 1, btn: false,\n    buf: new Float32Array(N * 3), line: new Float32Array(N), ten: new Float32Array(N), glow: new Float32Array(N),\n    cc: [0, 0, 0], hc: [0, 0, 0], pc: [0, 0, 0], rc: [0, 0, 0], P: [0, 0], started: false,\n  });\n  return S;\n}\n\n// The pot and the pile for the current drop and what is left in the pile.\nfunction pot(S) {\n  S.ybot = FLOOR - S.drop;\n  S.yrim = S.ybot - DEPTH;\n  const left = S.ph === 3 ? LC * S.fill : S.ph >= 1 ? 0 : cl(LC - S.M, 0, LC);\n  S.ypile = S.ybot - PILE * (left / LC);\n}\n// The heap on the floor: a mound of height sqrt(3 x area / 8) and twice\n// that half width, its area 0.45 LED^2 for each LED of chain.\nconst heapH = (d) => sqrt((3 * 0.45 * d) / 8);\n\n// The path from the pickup in the pile, up over the top and down to the\n// floor: one inverted catenary, x = XT + a asinh(sig / a) and\n// y = ytop + sqrt(a^2 + sig^2) - a, sig the arc length from the top.\nfunction path(S) {\n  pot(S);\n  S.yland = FLOOR - heapH(S.D);\n  S.s1 = sqrt((S.ypile - S.ytop + A) ** 2 - A * A);\n  S.s2 = sqrt((S.yland - S.ytop + A) ** 2 - A * A);\n  S.len = S.s1 + S.s2;\n}\nfunction at(S, s, o) {\n  const sg = s - S.s1;\n  o[0] = XT + A * asinh(sg / A);\n  o[1] = S.ytop + sqrt(A * A + sg * sg) - A;\n  return o;\n}\n// Where the arch stands: alpha v^2 / g - a above the pickup, or on the rim.\nconst top = (S) => min(S.yrim - 1, S.ypile - max(0, (S.alpha * S.v * S.v) / GRAV - A));\n\n// Steady flow with a share u of the chain already on the floor.\nfunction steady(S, u) {\n  S.ph = 0;\n  S.landed = true;\n  S.D = u * LC;\n  S.M = S.D + 100;\n  for (let i = 0; i \u003c 6; i++) {\n    path(S);\n    S.v = sqrt((GRAV * (S.yland - S.ypile)) / (1 - 2 * S.alpha));\n    S.ytop = top(S);\n    path(S);\n    S.M = S.D + S.len;\n  }\n}\n\n// From rest: the end pulled over the rim, hanging 30 LEDs below it.\nfunction start(S) {\n  S.ph = 0;\n  S.pt = 0;\n  S.v = 0;\n  S.D = 0;\n  S.landed = false;\n  S.M = 0;\n  pot(S);\n  S.ytop = S.yrim - 1;\n  path(S);\n  S.M = S.s1 + sqrt((S.yrim + 30 - S.ytop + A) ** 2 - A * A);\n}\n\n// One step of the speed for the chain in flight, its upper end the pickup\n// or, once the pile is empty, the tail; beta is alpha.\nfunction step(S, h) {\n  const al = S.alpha, P = S.P;\n  path(S);\n  const tail = S.ph === 1 ? S.M - LC : 0;\n  // Once the end is down, the chain in flight spans the whole path, taking\n  // from the heap or adding to it as the path changes length.\n  if (!S.landed && S.M - S.D >= S.len) S.landed = true;\n  if (S.landed) S.D = max(0, S.M - S.len);\n  const landed = S.landed, lo = S.M - S.D;\n  const yEnd = at(S, lo, P)[1], yUp = tail > 0 ? at(S, tail, P)[1] : S.ypile;\n  const acc = (GRAV * (yEnd - yUp) - (S.ph === 0 ? (1 - al) : 0) * S.v * S.v + (landed ? al * S.v * S.v : 0)) / max(4, lo - tail);\n  S.v = max(0, S.v + acc * h);\n  if (S.ph === 1) S.v = min(S.v, 2.5 * S.vss);\n  S.M += S.v * h;\n  if (S.ph === 0) {\n    S.ytop = top(S);\n    if (S.M >= LC) S.ph = 1;\n  } else if (S.M - LC >= S.len - 0.5) {\n    S.ph = 2;\n    S.pt = 0;\n    S.D = LC;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.drop = cl(k[2] || 67, 67, 75);\n  S.alpha = cl(k[3] == null ? 0.26 : k[3], 0.26, 0.29);\n  S.vss = sqrt((GRAV * (S.drop + PILE)) / (1 - 2 * S.alpha));\n  // The film opens on a fountain already running, 10% of its chain on the\n  // floor; every one after starts from rest.\n  if (!S.started) {\n    S.started = true;\n    steady(S, 0.1);\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn) start(S);\n  S.btn = btn;\n  S.dts = d * S.speed * TIME;\n  if (S.ph \u003c= 1) {\n    for (let i = 0; i \u003c SUB; i++) step(S, S.dts / SUB);\n  } else {\n    S.pt += d * S.speed * 0.5;\n    if (S.ph === 2 && S.pt > REST) (S.ph = 3), (S.pt = 0);\n    if (S.ph === 3) {\n      S.fill = min(1, S.pt / REFILL);\n      S.D = LC * (1 - S.fill);\n      if (S.pt > REFILL) start(S);\n    }\n  }\n  path(S);\n}\n\n// Adds v to an LED buffer at a point between LEDs, shared by the four round it.\nfunction splat(L, x, y, v) {\n  const i = floor(x - 0.5), j = floor(y - 0.5), fx = x - 0.5 - i, fy = y - 0.5 - j;\n  for (let q = 0; q \u003c 4; q++) {\n    const a = i + (q & 1), b = j + (q >> 1);\n    if (a \u003c 0 || a >= W || b \u003c 0 || b >= H) continue;\n    const w = (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy), p = b * W + a;\n    if (v * w > L[p]) L[p] = v * w;\n  }\n}\n// A bead: a disc 4.4 LEDs across with a soft edge out to 6.4.\nfunction bead(L, x, y, v) {\n  const x0 = floor(x - 3.5), y0 = floor(y - 3.5);\n  for (let j = y0; j \u003c= y0 + 7; j++)\n    for (let i = x0; i \u003c= x0 + 7; i++) {\n      if (i \u003c 0 || i >= W || j \u003c 0 || j >= H) continue;\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, r = sqrt(dx * dx + dy * dy), w = v * cl(3.2 - r, 0, 1), p = j * W + i;\n      if (w > L[p]) L[p] = w;\n    }\n}\n// A halo of radius 4 round a point of the chain.\nfunction halo(G, x, y) {\n  const cx = round(x - 0.5), cy = round(y - 0.5);\n  for (let dy = -4; dy \u003c= 4; dy++)\n    for (let dx = -4; dx \u003c= 4; dx++) {\n      const a = cx + dx, b = cy + dy, r2 = dx * dx + dy * dy;\n      if (a \u003c 0 || a >= W || b \u003c 0 || b >= H || r2 > 16) continue;\n      const g = 0.24 * (1 - r2 / 25), p = b * W + a;\n      if (g > G[p]) G[p] = g;\n    }\n}\n\nfunction put(buf, x, y, c, k) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] = max(buf[p], c[0] * k);\n  buf[p + 1] = max(buf[p + 1], c[1] * k);\n  buf[p + 2] = max(buf[p + 2], c[2] * k);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { buf, line: L, ten: T, glow: G, cc, hc, pc, rc, P } = S;\n  buf.fill(0);\n  L.fill(0);\n  T.fill(0);\n  G.fill(0);\n  hsv(S.hue + 0.5, 0.7, 1, cc);\n  hsv(S.hue + 0.62, 0.8, 1, hc);\n  hsv(S.hue + 0.75, 0.25, 1, pc);\n  hsv(S.hue + 0.85, 0.55, 1, rc);\n  // The floor, and the pot as two walls and a bottom.\n  for (let x = 0; x \u003c W; x++) put(buf, x, FLOOR + 1, pc, 0.3);\n  const yb = round(S.ybot), yr = round(S.yrim);\n  for (let y = yr; y \u003c= yb; y++) put(buf, PL - 1, y, pc, 0.45), put(buf, PR + 1, y, pc, 0.45);\n  for (let x = PL - 1; x \u003c= PR + 1; x++) put(buf, x, yb + 1, pc, 0.45);\n  // The pile and the heap on the floor: beads lying in rows.\n  const lie = (x, y) => bead(L, x, y, 0.42 + 0.12 * (((x * 7 + y * 3) | 0) % 3));\n  for (let y = S.ybot - 1.5, r = 0; y > S.ypile - 1; y -= 3, r++) for (let x = PL + 1.5 + 2 * (r & 1); x \u003c PR; x += 4) lie(x, y);\n  const hh = heapH(S.D);\n  if (hh > 0.8) {\n    const xl = XT + A * asinh(S.s2 / A);\n    for (let y = FLOOR - 1.5, r = 0; y > FLOOR - hh; y -= 3, r++) {\n      const half = 2 * hh * sqrt(max(0, 1 - (FLOOR - y) / hh));\n      for (let x = xl - half + 2 * (r & 1); x \u003c= xl + half; x += 4) lie(x, y);\n    }\n  }\n  // The chain in flight: its line in a colour that runs with its tension,\n  // T = v^2 - g (a + depth below the top), highest at the top and down to\n  // beta v^2 at the floor, and a halo round it.\n  const t0 = S.ph === 1 ? S.M - LC : 0, t1 = S.ph \u003c= 1 ? min(S.M - S.D, S.len) : 0;\n  const tmax = max(1, S.v * S.v - GRAV * A);\n  for (let s = max(0, t0), i = 0; s \u003c t1; s += 0.5, i++) {\n    at(S, s, P);\n    const t = cl((S.v * S.v - GRAV * (A + P[1] - S.ytop)) / tmax, 0, 1);\n    splat(L, P[0], P[1], 0.35);\n    splat(T, P[0], P[1], t);\n    if (!(i & 1)) halo(G, P[0], P[1]);\n  }\n  // Beads every BEAD LEDs of chain, each smeared back over the way it moved\n  // this frame.\n  const smear = min(BEAD, S.v * S.dts);\n  for (let m = BEAD * ceil(S.D / BEAD); m \u003c= min(S.M, LC); m += BEAD) {\n    const s = S.M - m;\n    if (s \u003c 0 || s > S.len) continue;\n    for (let q = 2; q >= 0; q--) {\n      const sq = s - (smear * q) / 3;\n      if (sq \u003c 0) continue;\n      at(S, sq, P);\n      bead(L, P[0], P[1], 1 - 0.3 * q);\n    }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const v = L[p], g = G[p];\n    if (v \u003c= 0 && g \u003c= 0) continue;\n    const t = T[p], o = p * 3, wh = 0.6 * max(0, v - 0.75);\n    // Slack in the chain's colour, taut toward the second colour.\n    for (let q = 0; q \u003c 3; q++) buf[o + q] = max(buf[o + q], (cc[q] * (1 - t) + rc[q] * t) * v + wh, hc[q] * g);\n  }\n  // At the left edge, h1 above the pickup and h2 below it while the chain\n  // runs, and a tick at the steady height alpha v^2 / g - a.\n  if (S.ph \u003c= 1) {\n    const yp = round(S.ypile), ya = round(S.ytop), yl = round(S.yland);\n    for (let y = ya; y \u003c yp; y++) put(buf, 1, y, rc, 0.8), put(buf, 2, y, rc, 0.45);\n    for (let y = yp; y \u003c= yl; y++) put(buf, 1, y, cc, 0.55), put(buf, 2, y, cc, 0.3);\n    const ys = round(S.ypile - max(0, (S.alpha * (S.yland - S.ypile)) / (1 - 2 * S.alpha) - A));\n    put(buf, 3, ys, rc, 1);\n    put(buf, 4, ys, rc, 0.6);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = (p - x) / W;\n    display.setPixel(x, y, round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n  }\n}\n","floating-letters":"// ===== Patternflow pattern =====\n// Title:   Floating Letters\n// Family:  type\n// Idea:    The letters of a word, cut from one board lighter than water, drop one by one into a pool across the middle of the panel, splash, bob and turn until each rests where its centre of buoyancy stands straight under its centre of gravity, the O level, the T on its side, the E on its back beside an A that stays upright, while a curve over each letter draws its potential energy against its angle with a dot that rolls into a valley; then the board soaks up water, the letters ride lower, some roll to new angles, and they sink before the next word drops.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Archimedes, On Floating Bodies (c. 250 BC); the metacentre (Pierre Bouguer, Traité du navire, 1746), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Density=0.2..0.8, Swell=0..1\n//\n// Knob 1: Hue. Turns the letters and the water round the wheel together. At 0 the letters run from amber to lime over blue water; at 0.25 from green to sea green over violet; at 0.5 from blue to violet over amber.\n// Knob 2: Speed. Simulated seconds to the second, 0.7 for each unit: 1.4 at the opening 2, where a word takes 14 s from the first drop to the last letter sinking. Ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Density. The board's density against water, 0.2 to 0.8, which is also the share of each letter under the waterline, and which moves the valleys of every energy curve. At 0.2 the O floats level, the T lies on its side about 20 degrees off flat, the E on its back, the L tips about 15 or about 70 degrees and the A floats upright. At 0.5 the O turns to 45 degrees like a square log, the T lies flat and the L stands on its corner. At 0.8 every curve is the one at 0.2 turned through 180 degrees and a fifth of each letter shows above the water.\n// Knob 4: Swell. A swell running left to right on a 48 LED wavelength, 12 LEDs from crest to trough at 1 and 0.7 at the opening 0.06; past 0.57 its crests break white. A big swell rocks the letters and can knock one out of a shallow valley into another.\n// Buttons: K1 tap soaks the board at once, and the next word follows.\n\n// Each letter is a 15 by 15 bitmap cut from a board of density rho, water\n// being 1, and floats as a rigid body in the plane of the panel. Its weight,\n// rho g for each cell, acts at its centre of gravity G. Each cell under the\n// surface is pushed up by g times the part of it that is under; together\n// that is the weight of the water displaced, acting at the centroid of the\n// wet cells, the centre of buoyancy B. While B is off the vertical through\n// G the two forces turn the letter. It rests where B stands straight under\n// G and a small turn carries B past G's vertical to the side that turns it\n// back, Bouguer's metacentre above G. Those rests are the valleys of the\n// potential energy, the weight times the height of G less the work the\n// water does holding the letter up, and a letter keeps the valley it lands\n// in. Water drag on each wet cell, in proportion to its speed, damps the\n// bobbing. G is the white dot on each letter and B the pale one below it.\n//\n// The valleys depend on where the ink is, not how much. The E has 147\n// cells and the A 138; both drop upright, the E rolls onto its back and the\n// A stays upright in a valley shallower than the one upside down that it\n// never reaches. They depend on rho only through rho and 1 - rho, so the\n// curve at 0.8 is the one at 0.2 turned through 180 degrees. The square\n// glyph matters: one row taller and the O lies on its side at every\n// density, as a long log does.\n//\n// The tank is the panel's 64 columns, so the water rises by what the\n// letters displace, 1.1 LEDs for TEA at 0.2. Letters keep an LED apart, each\n// cell beside another letter's pushing both along the line between their\n// centres. After 8 simulated seconds the board soaks: rho climbs at 0.12 a\n// second, the letters ride lower and some roll after their valleys (a T\n// from about 70 degrees to about 110, an L onto its corner), then fast past\n// 0.95, and they sink.\n\nconst W = 64, H = 128, N = W * H, G = 15;\nconst { floor, round, min, max, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The still waterline, gravity in LEDs per simulated second squared, water\n// drag per wet cell, the push between letters and from the panel's sides.\nconst WL = 62, GRAV = 40, DRAG = 2.4, PUSH = 30, WALL = 60, SUB = 6;\n// Swell: 48 LED wavelength, deep water, so omega = sqrt(g k).\nconst KW = (2 * PI) / 48, OMW = sqrt(GRAV * KW);\n// Simulated seconds: release of the first letter, gap between letters, when\n// the board starts to soak, how fast rho rises, and when to give up waiting.\nconst T0 = 0.5, GAP = 0.55, SOAK = 8, SOAKR = 0.12, TMAX = 26;\nconst HANG = 34, HUE0 = 0.13;\n// The energy curves: 48 angles, drawn in rows CY0 to CY1.\nconst NA = 48, CY0 = 11, CY1 = 25;\n\nconst WORDS = [\"TEA\", \"LOT\", \"BUOY\", \"FLY\", \"OIL\", \"SINK\", \"KEY\"];\n\n// 15 by 15, stroke 3, drawn for this pattern.\nconst GL = {\n  T: `\n###############\n###############\n###############\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......`,\n  E: `\n###############\n###############\n###############\n###............\n###............\n###............\n#############..\n#############..\n#############..\n###............\n###............\n###............\n###############\n###############\n###############`,\n  A: `\n..###########..\n.#############.\n###############\n###.........###\n###.........###\n###.........###\n###.........###\n###############\n###############\n###############\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###`,\n  L: `\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###############\n###############\n###############`,\n  O: `\n..###########..\n.#############.\n###############\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###############\n.#############.\n..###########..`,\n  B: `\n#############..\n##############.\n##############.\n###........###.\n###........###.\n###........###.\n###############\n###############\n###############\n###.........###\n###.........###\n###.........###\n###############\n##############.\n#############..`,\n  U: `\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###############\n.#############.\n..###########..`,\n  Y: `\n###.........###\n####.......####\n#####.....#####\n.#####...#####.\n..#####.#####..\n...#########...\n....#######....\n.....#####.....\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......`,\n  S: `\n..###########..\n.#############.\n###############\n###............\n###............\n###............\n###############\n###############\n###############\n............###\n............###\n............###\n###############\n.#############.\n..###########..`,\n  I: `\n..###########..\n..###########..\n..###########..\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n..###########..\n..###########..\n..###########..`,\n  N: `\n###.........###\n####........###\n#####.......###\n######......###\n#######.....###\n########....###\n###.#####...###\n###..#####..###\n###...#####.###\n###....########\n###.....#######\n###......######\n###.......#####\n###........####\n###.........###`,\n  K: `\n###.........###\n###.......#####\n###......######\n###....######..\n###..#######...\n###.######.....\n########.......\n#######........\n#########......\n###..#####.....\n###...######...\n###.....#####..\n###......######\n###........####\n###.........###`,\n  F: `\n###############\n###############\n###############\n###............\n###............\n###............\n############...\n############...\n############...\n###............\n###............\n###............\n###............\n###............\n###............`,\n};\n\n// Each glyph once: its cells about the centre of gravity, the moment of\n// inertia per unit density, and a bitmap with a clear border to sample.\nconst GLYPH = {};\nfor (const ch in GL) {\n  const rows = GL[ch].trim().split(\"\\n\");\n  const xs = [], ys = [];\n  for (let j = 0; j \u003c G; j++) for (let i = 0; i \u003c G; i++) if (rows[j][i] === \"#\") xs.push(i + 0.5), ys.push(j + 0.5);\n  const n = xs.length;\n  let cx = 0, cy = 0;\n  for (let k = 0; k \u003c n; k++) (cx += xs[k]), (cy += ys[k]);\n  cx /= n;\n  cy /= n;\n  const dx = new Float32Array(n), dy = new Float32Array(n), bm = new Uint8Array((G + 2) * (G + 2));\n  let I = n / 6, R = 0;\n  for (let k = 0; k \u003c n; k++) {\n    dx[k] = xs[k] - cx;\n    dy[k] = ys[k] - cy;\n    I += dx[k] * dx[k] + dy[k] * dy[k];\n    R = max(R, sqrt(dx[k] * dx[k] + dy[k] * dy[k]) + 0.8);\n    bm[(ys[k] + 0.5) * (G + 2) + xs[k] + 0.5] = 1;\n  }\n  GLYPH[ch] = { n, cx, cy, dx, dy, I, R, bm };\n}\n\n// The potential energy of a letter at each of NA angles in still water,\n// scaled to 0..1: the height of its centre of gravity times its weight,\n// less the work the water does holding it up. The draft at each angle is\n// found by halving until the letter displaces its own weight.\nfunction curve(g, rho) {\n  const out = new Float32Array(NA), n = g.n, want = rho * n;\n  let lo = 1e9, hi = -1e9;\n  for (let k = 0; k \u003c NA; k++) {\n    const a = -PI + (2 * PI * k) / NA, c = cos(a), s = sin(a);\n    let y0 = -12, y1 = 12;\n    for (let it = 0; it \u003c 22; it++) {\n      const yc = (y0 + y1) / 2;\n      let f = 0;\n      for (let q = 0; q \u003c n; q++) f += cl(yc + g.dx[q] * s + g.dy[q] * c + 0.5, 0, 1);\n      if (f > want) y1 = yc;\n      else y0 = yc;\n    }\n    const yc = (y0 + y1) / 2;\n    let U = -want * yc;\n    for (let q = 0; q \u003c n; q++) {\n      const y = yc + g.dx[q] * s + g.dy[q] * c, t = y + 0.5;\n      if (t > 0) U += (t * t - (y > 0.5 ? (y - 0.5) * (y - 0.5) : 0)) / 2;\n    }\n    out[k] = U;\n    lo = min(lo, U);\n    hi = max(hi, U);\n  }\n  for (let k = 0; k \u003c NA; k++) out[k] = hi > lo ? (out[k] - lo) / (hi - lo) : 0;\n  return out;\n}\n\n// 3 by 5 capitals for the word written plainly at the top.\nconst SMALL = {\n  A: \"### #.# ### #.# #.#\", B: \"##. #.# ##. #.# ##.\", E: \"### #.. ##. #.. ###\", F: \"### #.. ##. #.. #..\",\n  I: \"### .#. .#. .#. ###\", K: \"#.# ##. #.. ##. #.#\", L: \"#.. #.. #.. #.. ###\", N: \"##. #.# #.# #.# #.#\",\n  O: \"### #.# #.# #.# ###\", S: \"### #.. ### ..# ###\", T: \"### .#. .#. .#. .#.\", U: \"#.# #.# #.# #.# ###\",\n  Y: \"#.# #.# .#. .#. .#.\",\n};\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, rho: 0.2, swell: 0.06, t: 0, tw: 0, wi: -1, B: [], drops: [], rise: 0,\n    rip: new Float32Array(W), ripv: new Float32Array(W), surf: new Float32Array(W), sf: new Float32Array(W + 1), foam: new Float32Array(W), curves: new Map(),\n    grid: new Uint8Array(W * (H + 64)), buf: new Float32Array(N * 3), btn: false,\n    lc: [0, 0, 0], wc: [0, 0, 0],\n  });\n  word(S);\n  return S;\n}\n\nfunction word(S) {\n  S.wi = (S.wi + 1) % WORDS.length;\n  S.tw = 0;\n  S.soaked = false;\n  const w = WORDS[S.wi], n = w.length;\n  S.B = [...w].map((ch, i) => ({\n    ch, g: GLYPH[ch], x: ((i + 0.5) * W) / n, y: HANG, a: 0, vx: 0, vy: 0, w: 0, fx: 0, fy: 0, tq: 0,\n    rho: S.rho, on: T0 + GAP * i, free: false, wet: false, gone: false, bx: 0, by: 0, sub: 0, hue: i * 0.035,\n  }));\n}\n\n// The surface: the still level, raised by the water the letters displace\n// across the 64 LED tank, the swell, and the ripples splashes leave. Set\n// once a step at every whole x and read between.\nfunction level(S) {\n  const sf = S.sf, a = S.swell * 6, ph = OMW * S.t;\n  for (let x = 0; x \u003c= W; x++) sf[x] = WL - S.rise + a * sin(KW * x - ph) + S.rip[min(x, W - 1)];\n}\nfunction surface(S, x) {\n  if (x \u003c= 0) return S.sf[0];\n  if (x >= W) return S.sf[W];\n  const i = floor(x), f = x - i;\n  return S.sf[i] * (1 - f) + S.sf[i + 1] * f;\n}\n\nfunction splash(S, x, v, n) {\n  for (let k = 0; k \u003c n; k++) {\n    const sp = v * (0.25 + 0.35 * Math.random()), an = -PI / 2 + (Math.random() - 0.5) * 1.6;\n    S.drops.push({ x: x + (Math.random() - 0.5) * 12, y: WL - S.rise - 1, vx: cos(an) * sp, vy: sin(an) * sp });\n  }\n  const i = cl(round(x), 1, W - 2);\n  for (let d = -6; d \u003c= 6; d++) if (i + d >= 0 && i + d \u003c W) S.ripv[i + d] += v * 0.05 * (1 - abs(d) / 7);\n}\n\n// Another letter's cell on this LED or the four beside it: its index + 1.\nfunction touch(S, grid, gx, gy, me) {\n  for (const [ox, oy] of NB) {\n    const x = gx + ox, y = gy + oy;\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H + 64) continue;\n    const o = grid[y * W + x];\n    if (o && o !== me) return o;\n  }\n  return 0;\n}\nconst NB = [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]];\n\nfunction step(S, h) {\n  S.t += h;\n  S.tw += h;\n  const grid = S.grid;\n  grid.fill(0);\n  // Ripples: a damped wave along the surface.\n  const rip = S.rip, rv = S.ripv;\n  for (let i = 0; i \u003c W; i++) {\n    const l = rip[i > 0 ? i - 1 : 0], r = rip[i \u003c W - 1 ? i + 1 : W - 1];\n    rv[i] += h * (400 * (l + r - 2 * rip[i]) - 20 * rip[i] - 3 * rv[i]);\n  }\n  for (let i = 0; i \u003c W; i++) rip[i] = cl(rip[i] + h * rv[i], -4, 4);\n  level(S);\n  const B = S.B;\n  let disp = 0;\n  for (let bi = 0; bi \u003c B.length; bi++) {\n    const b = B[bi];\n    if (b.gone) continue;\n    if (!b.free) {\n      if (S.tw \u003c b.on) continue;\n      b.free = true;\n      b.a = (Math.random() - 0.5) * 0.5;\n      b.w = (Math.random() - 0.5) * 2;\n      b.vx = (Math.random() - 0.5) * 4;\n    }\n    // Soaking, rho climbs slowly to just under 1 and then fast.\n    b.rho = S.soaked ? min(2.4, b.rho + SOAKR * h * (b.rho \u003c 0.95 ? 1 : 6)) : S.rho;\n    const g = b.g, n = g.n, m = b.rho * n, c = cos(b.a), s = sin(b.a);\n    let fx = 0, fy = m * GRAV, tq = 0, sub = 0, sx = 0, sy = 0;\n    for (let k = 0; k \u003c n; k++) {\n      const rx = g.dx[k] * c - g.dy[k] * s, ry = g.dx[k] * s + g.dy[k] * c;\n      const px = b.x + rx, py = b.y + ry;\n      const vx = b.vx - b.w * ry, vy = b.vy + b.w * rx;\n      let Fx = 0, Fy = 0;\n      const f = cl(py - surface(S, px) + 0.5, 0, 1);\n      if (f > 0) {\n        Fx -= DRAG * f * vx;\n        Fy -= GRAV * f + DRAG * f * vy;\n        sub += f;\n        sx += f * px;\n        sy += f * py;\n      } else {\n        Fx -= 0.02 * vx;\n        Fy -= 0.02 * vy;\n      }\n      if (px \u003c 0.5) Fx += WALL * (0.5 - px);\n      else if (px > W - 0.5) Fx -= WALL * (px - W + 0.5);\n      // Letters keep one LED apart: a cell next to another letter's pushes\n      // both along the line between their centres.\n      const gx = round(px - 0.5), gy = round(py - 0.5) + 32;\n      const o = touch(S, grid, gx, gy, bi + 1);\n      if (o) {\n        const q = B[o - 1];\n        let nx = b.x - q.x, ny = b.y - q.y;\n        const d = sqrt(nx * nx + ny * ny) || 1;\n        nx /= d;\n        ny /= d;\n        const P = PUSH - 2 * min(0, (b.vx - q.vx) * nx + (b.vy - q.vy) * ny);\n        Fx += P * nx;\n        Fy += P * ny;\n        q.fx -= P * nx;\n        q.fy -= P * ny;\n        q.tq += (py - q.y) * P * nx - (px - q.x) * P * ny;\n      }\n      if (gx >= 0 && gx \u003c W && gy >= 0 && gy \u003c H + 64) grid[gy * W + gx] = bi + 1;\n      fx += Fx;\n      fy += Fy;\n      tq += rx * Fy - ry * Fx;\n    }\n    b.sub = sub;\n    disp += sub;\n    if (sub > 0) (b.bx = sx / sub), (b.by = sy / sub);\n    // First touch of the water throws a splash as big as the letter is fast.\n    if (sub > 0 && !b.wet) {\n      b.wet = true;\n      splash(S, b.x, abs(b.vy), round(cl(abs(b.vy) / 4, 4, 16)));\n    }\n    b.fx += fx;\n    b.fy += fy;\n    b.tq += tq;\n  }\n  S.rise = disp / W;\n  for (const b of B) {\n    if (!b.free || b.gone) continue;\n    const m = b.rho * b.g.n, I = b.rho * b.g.I;\n    b.vx += (h * b.fx) / m;\n    b.vy += (h * b.fy) / m;\n    b.w += (h * b.tq) / I;\n    b.x += h * b.vx;\n    b.y += h * b.vy;\n    b.a += h * b.w;\n    b.a -= 2 * PI * floor((b.a + PI) / (2 * PI));\n    b.fx = b.fy = b.tq = 0;\n    if (b.y > H + b.g.R) b.gone = true;\n  }\n  for (const d of S.drops) {\n    d.vy += GRAV * h;\n    d.x += d.vx * h;\n    d.y += d.vy * h;\n    if (d.vy > 0 && d.y > surface(S, d.x)) d.gone = true;\n  }\n  S.drops = S.drops.filter((d) => !d.gone && d.x > -2 && d.x \u003c W + 2);\n  if (!S.soaked && S.tw > SOAK) S.soaked = true;\n  if (B.every((b) => b.gone) || S.tw > TMAX) word(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.rho = cl(k[2] == null ? 0.2 : k[2], 0.2, 0.8);\n  S.swell = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && !S.soaked) {\n    S.soaked = true;\n    for (const b of S.B) if (!b.free) b.gone = true;\n  }\n  S.btn = btn;\n  const h = (d * S.speed * 0.7) / SUB;\n  for (let i = 0; i \u003c SUB; i++) step(S, h);\n}\n\n// A letter's energy curve at its density, from the cache; flat once it is\n// heavier than water, when every angle is the same to it.\nfunction curveOf(S, b) {\n  const q = round(min(b.rho, 1) * 50), key = b.ch + q;\n  let c = S.curves.get(key);\n  if (!c) S.curves.set(key, (c = q >= 50 ? new Float32Array(NA) : curve(b.g, q / 50)));\n  return c;\n}\n\nfunction put(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] = r;\n  buf[p + 1] = g;\n  buf[p + 2] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, lc = S.lc, wc = S.wc;\n  hsv(S.hue + 0.6, 0.85, 1, wc);\n  const surf = S.surf, foam = S.foam;\n  level(S);\n  // The swell's height over its length is Swell / 4; past 1 in 7, at\n  // Swell 0.57, its crests break white.\n  const br = cl((S.swell - 0.57) / 0.3, 0, 1);\n  for (let x = 0; x \u003c W; x++) {\n    surf[x] = surface(S, x + 0.5);\n    foam[x] = br * max(0, -sin(KW * (x + 0.5) - OMW * S.t));\n  }\n  // Sky dark, water a tint that fades with depth, the surface a line.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3, dpt = y + 0.5 - surf[x];\n      let v = 0, wh = 0;\n      if (dpt > -0.5) v = dpt \u003c 0.5 ? 0.7 * (dpt + 0.5) : dpt \u003c 1.5 ? 0.7 : 0.11 + 0.3 * max(0, 1 - dpt / 50) ** 2;\n      if (dpt > -0.5 && dpt \u003c 2.5) wh = foam[x] * (dpt \u003c 0.5 ? dpt + 0.5 : 1) * (1 - max(0, dpt - 0.5) / 2);\n      buf[p] = wc[0] * v * (1 - wh) + wh;\n      buf[p + 1] = wc[1] * v * (1 - wh) + wh;\n      buf[p + 2] = wc[2] * v * (1 - wh) + wh;\n    }\n  // The letters, each LED sampled from the glyph turned back; under the\n  // surface seen dimmer through the water.\n  for (const b of S.B) {\n    if (b.gone) continue;\n    const g = b.g, c = cos(b.a), s = sin(b.a), R = g.R;\n    hsv(S.hue + HUE0 + b.hue, 0.8, 1, lc);\n    const x0 = max(0, floor(b.x - R)), x1 = min(W - 1, floor(b.x + R)), y0 = max(0, floor(b.y - R)), y1 = min(H - 1, floor(b.y + R));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const X = x + 0.5 - b.x, Y = y + 0.5 - b.y;\n        const u = X * c + Y * s + g.cx + 0.5, v = -X * s + Y * c + g.cy + 0.5;\n        if (u \u003c 0 || v \u003c 0 || u >= G + 1 || v >= G + 1) continue;\n        const i = floor(u), j = floor(v), fu = u - i, fv = v - j, o = j * (G + 2) + i;\n        let a = (g.bm[o] * (1 - fu) + g.bm[o + 1] * fu) * (1 - fv) + (g.bm[o + G + 2] * (1 - fu) + g.bm[o + G + 3] * fu) * fv;\n        if (a \u003c= 0.05) continue;\n        a = a >= 0.9 ? 1 : a * a * (3 - 2 * a);\n        const p = (y * W + x) * 3, dpt = y + 0.5 - surf[x];\n        const k = dpt > 0 ? 0.5 - 0.3 * min(1, dpt / 50) : 1;\n        for (let q = 0; q \u003c 3; q++) buf[p + q] = buf[p + q] * (1 - a * (dpt > 0 ? 0.6 : 1)) + lc[q] * k * a;\n      }\n  }\n  // G and B: the centre of gravity white, the centre of buoyancy in the\n  // water's colour, which settles straight under it.\n  for (const b of S.B) {\n    if (!b.free || b.gone) continue;\n    put(buf, floor(b.x), floor(b.y), 1, 1, 1);\n    if (b.sub > 0.5) put(buf, floor(b.bx), floor(b.by), 0.4 + 0.6 * wc[0], 0.4 + 0.6 * wc[1], 0.4 + 0.6 * wc[2]);\n  }\n  for (const d of S.drops) put(buf, floor(d.x), floor(d.y), 0.5 + 0.5 * wc[0], 0.5 + 0.5 * wc[1], 0.5 + 0.5 * wc[2]);\n  // At the top, the word written plainly, and over each letter's place its\n  // potential energy against its angle, -180 to 180 degrees, with a dot\n  // where the letter is now: it rolls into a valley as the letter settles.\n  const B = S.B, n = B.length, cw = floor(W / n);\n  for (let i = 0; i \u003c n; i++) {\n    const b = B[i], cu = curveOf(S, b), x0 = floor((i * W) / n) + floor((W / n - cw) / 2) + 1, wd = cw - 2;\n    hsv(S.hue + HUE0 + b.hue, 0.45, 0.7, lc);\n    let py = -1;\n    for (let x = 0; x \u003c wd; x++) {\n      const t = (x / (wd - 1)) * NA, k0 = floor(t) % NA, f = t - floor(t);\n      const u = cu[k0] * (1 - f) + cu[(k0 + 1) % NA] * f, y = round(CY1 - u * (CY1 - CY0));\n      const ya = py \u003c 0 ? y : y > py ? py + 1 : y, yb = py \u003c 0 ? y : y \u003c py ? py - 1 : y;\n      for (let yy = min(ya, yb, y); yy \u003c= max(ya, yb, y); yy++) put(buf, x0 + x, yy, lc[0], lc[1], lc[2]);\n      py = y;\n    }\n    put(buf, x0 + floor((wd - 1) / 2), CY1 + 2, lc[0] * 0.6, lc[1] * 0.6, lc[2] * 0.6);\n    const t = ((b.a + PI) / (2 * PI)) * NA, k0 = floor(t) % NA, f = t - floor(t);\n    const u = cu[k0] * (1 - f) + cu[(k0 + 1) % NA] * f;\n    const bx = x0 + round(((b.a + PI) / (2 * PI)) * (wd - 1)), by = round(CY1 - u * (CY1 - CY0)) - 1;\n    put(buf, bx, by, 1, 1, 1);\n    put(buf, bx, by - 1, 1, 1, 1);\n  }\n  const w = WORDS[S.wi], lx = floor((W - (w.length * 4 - 1)) / 2);\n  hsv(S.hue + HUE0, 0.6, 0.75, lc);\n  for (let i = 0; i \u003c w.length; i++) {\n    const rows = SMALL[w[i]].split(\" \");\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (rows[r][q] === \"#\") put(buf, lx + i * 4 + q, 2 + r, lc[0], lc[1], lc[2]);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = (p - x) / W;\n    display.setPixel(x, y, round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n  }\n}\n","fox-colorings":"// ===== Patternflow pattern =====\n// Title:   Fox Colorings\n// Family:  topology\n// Idea:    A knot stands the full height of the panel as a closed braid, its crossings stacked down the middle and its strands coming back up round the right side, each under-strand broken where it passes beneath, and every arc between two undercrossings is coloured by a label mod p so that at each crossing twice the over arc equals the sum of the two under arcs; the colourings are found by Gaussian elimination mod p and walked one basis step at a time, the arcs that change dipping dark and coming back in their new colour, and the count p^d and the knot's determinant stand at the top, so a knot whose determinant p does not divide sits in a single colour.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fox colourings of knot diagrams (Ralph Fox; Richard H. Crowell and Ralph H. Fox, Introduction to Knot Theory, 1963), Alexander's theorem that every knot is a closed braid (James Waddell Alexander, A lemma on systems of knotted curves, 1923), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knot=0..1, Prime=0..1\n//\n// Knob 1: Hue. Turns the p label colours round the wheel; label a sits a/p of a turn on from label 0, which is azure at 0.\n// Knob 2: Speed. At 2 a colouring lasts 1.9 seconds, the change taking the first 0.55 of them; 0.2 is ten times slower, 3 half as fast again. Three faint bright bands run round the knot the way it is drawn, each going round in 9 seconds at 2.\n// Knob 3: Knot. Thirteen stations: the trefoil s1^3 (determinant 3), the figure-eight s1 s2^-1 s1 s2^-1 (5), 5_1 = s1^5 (5), 5_2 (7), 6_1 on four strands (9), 6_2 (11), 6_3 (13), 7_1 = s1^7 (7), the square knot s1^3 s2^-3 (9, and 27 colourings mod 3, one more dimension than any prime knot here), a four-strand knot of determinant 15 = 3 x 5, the torus knot T(3,4) = 8_19 (3), 9_1 = s1^9 (9) and T(3,5) = 10_124 (1, colourable by no prime at all).\n// Knob 4: Prime. The modulus p, five stations: 3, 5, 7, 11, 13. The knot has colourings other than the p constant ones exactly when p divides its determinant; then they number p^2 for every knot here but the square knot, which has 3^3 = 27.\n\n// Cut a knot diagram at its undercrossings and it falls into arcs, as many\n// as it has crossings. Fox's colouring gives each arc a label in Z/p so that\n// at every crossing 2 x (over arc) = (under arc in) + (under arc out) mod p.\n// The constant labellings always pass; the knot is p-colourable when some\n// other one does, and that happens exactly when p divides the determinant,\n// the absolute value of any (n-1) by (n-1) minor of the n by n matrix of\n// these equations. The solutions are a vector space over Z/p of dimension\n// d >= 1, so there are p^d colourings. Here the equations are solved by\n// Gaussian elimination mod p with arc 0 held at 0, which leaves the d - 1\n// non-constant directions; the constant vector is the last. The walk runs\n// through all p^d colourings in a modular Gray code, adding one basis vector\n// at each step, so only the arcs where that vector is not 0 change, and\n// every crossing is valid in every colouring it rests on.\n//\n// Alexander showed in 1923 that every knot is the closure of a braid. The\n// braid runs down the panel, one crossing to a band; s_i crosses the\n// strands at places i and i + 1, the one moving right in front for s_i and\n// behind for its inverse. Each place j then returns up the right side, the\n// leftmost on the outside, so the closing arcs never cross.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\nconst KNOTS = [\n  [2, [1, 1, 1]],\n  [3, [1, -2, 1, -2]],\n  [2, [1, 1, 1, 1, 1]],\n  [3, [1, 1, 1, 2, -1, 2]],\n  [4, [1, 1, 2, -1, -3, 2, -3]],\n  [3, [1, 1, 1, -2, 1, -2]],\n  [3, [1, 1, -2, 1, -2, -2]],\n  [2, [1, 1, 1, 1, 1, 1, 1]],\n  [3, [1, 1, 1, -2, -2, -2]],\n  [4, [1, 1, 2, -1, 2, 2, 3, -2, 3]],\n  [3, [1, 2, 1, 2, 1, 2, 1, 2]],\n  [2, [1, 1, 1, 1, 1, 1, 1, 1, 1]],\n  [3, [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]],\n];\nconst PRIMES = [3, 5, 7, 11, 13];\n// Strand radius and the dark margin an over-strand cuts round itself.\nconst RAD = 1.45, GAP = 1.6;\n// Seconds a colouring lasts at Speed 1, and the share of it the change takes.\nconst STEP = 3.8, DIP = 0.29;\nconst HUE0 = 0.55;\n\nconst GLYPH = {\n  0: \"### #.# #.# #.# ###\", 1: \".#. ##. .#. .#. ###\", 2: \"### ..# ### #.. ###\", 3: \"### ..# .## ..# ###\", 4: \"#.# #.# ### ..# ..#\",\n  5: \"### #.. ### ..# ###\", 6: \"### #.. ### #.# ###\", 7: \"### ..# ..# .#. .#.\", 8: \"### #.# ### #.# ###\", 9: \"### #.# ### ..# ###\",\n  \"=\": \"... ### ... ### ...\", d: \"..# ..# ### #.# ###\", e: \"### #.# ### #.. ###\", t: \".#. ### .#. .#. .##\",\n};\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  o[1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  o[2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n  return o;\n}\n\n// Arcs of the closed braid: piece (l, j) is the strand at place j between\n// crossing l - 1 and crossing l, and level n is level 0 again. Pieces are\n// joined where a strand passes a crossing untouched or in front.\nfunction arcsOf(k, w) {\n  const n = w.length, par = new Int32Array(n * k).map((_, i) => i);\n  const find = (a) => (par[a] === a ? a : (par[a] = find(par[a])));\n  const id = (l, j) => (l % n) * k + j;\n  const eqs = [];\n  for (let t = 0; t \u003c n; t++) {\n    const g = w[t], i = abs(g) - 1;\n    for (let j = 0; j \u003c k; j++) if (j !== i && j !== i + 1) par[find(id(t, j))] = find(id(t + 1, j));\n    const oi = g > 0 ? id(t, i) : id(t, i + 1), oo = g > 0 ? id(t + 1, i + 1) : id(t + 1, i);\n    par[find(oi)] = find(oo);\n    eqs.push([oi, g > 0 ? id(t, i + 1) : id(t, i), g > 0 ? id(t + 1, i) : id(t + 1, i + 1)]);\n  }\n  const roots = [], arc = new Int32Array(n * k);\n  for (let a = 0; a \u003c n * k; a++) {\n    const r = find(a);\n    if (!roots.includes(r)) roots.push(r);\n    arc[a] = roots.indexOf(r);\n  }\n  // Each crossing as a row: 2 over - under in - under out.\n  const M = eqs.map(([o, a, b]) => {\n    const row = new Array(roots.length).fill(0);\n    row[arc[o]] += 2;\n    row[arc[a]] -= 1;\n    row[arc[b]] -= 1;\n    return row;\n  });\n  return { arc, M, na: roots.length, id };\n}\n\n// The determinant: a minor of the crossing matrix, by Bareiss's fraction-free\n// elimination, which keeps every entry a whole number.\nfunction determinant(M) {\n  const A = M.slice(1).map((r) => r.slice(1)), n = A.length;\n  let prev = 1, sign = 1;\n  for (let c = 0; c \u003c n; c++) {\n    let p = c;\n    while (p \u003c n && A[p][c] === 0) p++;\n    if (p === n) return 0;\n    if (p !== c) {\n      [A[p], A[c]] = [A[c], A[p]];\n      sign = -sign;\n    }\n    for (let r = c + 1; r \u003c n; r++) {\n      for (let q = c + 1; q \u003c n; q++) A[r][q] = (A[r][q] * A[c][c] - A[r][c] * A[c][q]) / prev;\n      A[r][c] = 0;\n    }\n    prev = A[c][c];\n  }\n  return abs(sign * (n ? A[n - 1][n - 1] : 1));\n}\n\nconst mod = (a, p) => ((a % p) + p) % p;\nfunction inverse(a, p) {\n  let r = 1;\n  for (let e = p - 2, b = a; e > 0; e >>= 1, b = (b * b) % p) if (e & 1) r = (r * b) % p;\n  return r;\n}\n\n// The colourings mod p as a basis: the non-constant directions found with\n// arc 0 held at 0, then the constant vector.\nfunction colourings(M, na, p) {\n  const A = M.map((r) => r.map((v) => mod(v, p)));\n  A.push(new Array(na).fill(0).map((_, i) => (i === 0 ? 1 : 0)));\n  const pivots = [];\n  let row = 0;\n  for (let c = 0; c \u003c na && row \u003c A.length; c++) {\n    let r = row;\n    while (r \u003c A.length && A[r][c] === 0) r++;\n    if (r === A.length) continue;\n    [A[r], A[row]] = [A[row], A[r]];\n    const iv = inverse(A[row][c], p);\n    for (let q = 0; q \u003c na; q++) A[row][q] = (A[row][q] * iv) % p;\n    for (let r2 = 0; r2 \u003c A.length; r2++) {\n      if (r2 === row || !A[r2][c]) continue;\n      const f = A[r2][c];\n      for (let q = 0; q \u003c na; q++) A[r2][q] = mod(A[r2][q] - f * A[row][q], p);\n    }\n    pivots.push(c);\n    row++;\n  }\n  const basis = [];\n  for (let f = 0; f \u003c na; f++) {\n    if (pivots.includes(f)) continue;\n    const v = new Array(na).fill(0);\n    v[f] = 1;\n    pivots.forEach((c, r) => (v[c] = mod(-A[r][f], p)));\n    basis.push(v);\n  }\n  basis.push(new Array(na).fill(1));\n  return basis;\n}\n\n// The path of the knot, sampled every quarter LED or so, in the order it is\n// drawn: down the braid, round the closing arc on the right, down again\n// from the next place, until it comes back to place 0.\nfunction layout(k, w) {\n  const n = w.length;\n  const yt = [], yb = [];\n  for (let j = 0; j \u003c k; j++) {\n    yt.push(10 + 4 * j);\n    yb.push(124 - 4 * j);\n  }\n  const y0 = yt[k - 1] + 5, y1 = yb[k - 1] - 5, band = (y1 - y0) / n;\n  // Wide crossings where there is height for them, narrower where many share it.\n  const sp = min([0, 0, 22, 13, 9][k], max(9, round(band * 1.25))), rs = [0, 0, 11, 8, 6][k], gap = [0, 0, 12, 11, 9][k];\n  const width = (k - 1) * sp + gap + (k - 1) * rs, x0 = round(2 + (59 - width) / 2);\n  const xb = [], xr = [];\n  for (let j = 0; j \u003c k; j++) {\n    xb.push(x0 + j * sp);\n    xr.push(x0 + (k - 1) * sp + gap + (k - 1 - j) * rs);\n  }\n  return { xb, xr, yt, yb, y0, y1, band };\n}\n\nfunction build(S, ki) {\n  const [k, w] = KNOTS[ki], n = w.length;\n  const { arc, M, na, id } = arcsOf(k, w);\n  S.ki = ki;\n  S.M = M;\n  S.na = na;\n  S.det = determinant(M);\n  const L = layout(k, w), xs = [], ys = [], as = [], fl = [];\n  const add = (x, y, a, f) => {\n    xs.push(x);\n    ys.push(y);\n    as.push(a);\n    fl.push(f);\n  };\n  const line = (xa, ya, xb, yb, a) => {\n    const m = max(1, Math.ceil(Math.hypot(xb - xa, yb - ya) * 3));\n    for (let i = 0; i \u003c m; i++) add(xa + ((xb - xa) * i) / m, ya + ((yb - ya) * i) / m, a, 0);\n  };\n  const turn = (cx, cy, r, a0, a1, a) => {\n    for (let i = 0; i \u003c 12; i++) {\n      const t = a0 + ((a1 - a0) * i) / 12;\n      add(cx + r * cos(t), cy + r * sin(t), a, 0);\n    }\n  };\n  const R = 3;\n  let j = 0;\n  do {\n    for (let t = 0; t \u003c n; t++) {\n      const g = w[t], i = abs(g) - 1, ya = L.y0 + t * L.band;\n      if (j !== i && j !== i + 1) {\n        line(L.xb[j], ya, L.xb[j], ya + L.band, arc[id(t, j)]);\n        continue;\n      }\n      const jj = j === i ? i + 1 : i, over = g > 0 ? j === i : j === i + 1;\n      const m = Math.ceil(L.band * 5);\n      for (let s = 0; s \u003c m; s++) {\n        const u = s / m;\n        // 1: in front through this crossing; 2: in front near its middle, where it cuts the gap.\n        const f = over ? (abs(u - 0.5) \u003c 0.3 ? 2 : 1) : 0;\n        add(L.xb[j] + (L.xb[jj] - L.xb[j]) * ease(u), ya + u * L.band, over || u \u003c 0.5 ? arc[id(t, j)] : arc[id(t + 1, jj)], f);\n      }\n      j = jj;\n    }\n    // Round the right side and back to the top of the braid at place j.\n    const a = arc[id(0, j)], xl = L.xb[j], xr = L.xr[j], yt = L.yt[j], yb = L.yb[j];\n    line(xl, L.y1, xl, yb - R, a);\n    turn(xl + R, yb - R, R, PI, PI / 2, a);\n    line(xl + R, yb, xr - R, yb, a);\n    turn(xr - R, yb - R, R, PI / 2, 0, a);\n    line(xr, yb - R, xr, yt + R, a);\n    turn(xr - R, yt + R, R, 0, -PI / 2, a);\n    line(xr - R, yt, xl + R, yt, a);\n    turn(xl + R, yt + R, R, -PI / 2, -PI, a);\n    line(xl, yt + R, xl, L.y0, a);\n  } while (j !== 0);\n  // Distance along the knot, for the brightening that runs round it.\n  const ss = [0];\n  for (let i = 1; i \u003c xs.length; i++) ss.push(ss[i - 1] + Math.hypot(xs[i] - xs[i - 1], ys[i] - ys[i - 1]));\n  S.len = ss[ss.length - 1];\n  // Rasterise: every sample, then a dark margin round each over-strand near\n  // its crossing, then the over-strands again on top.\n  const { pa, pd, ps } = S;\n  pa.fill(-1);\n  pd.fill(9);\n  const stamp = (i, r, dark) => {\n    const fx = xs[i], fy = ys[i];\n    for (let y = Math.ceil(fy - r); y \u003c= floor(fy + r); y++)\n      for (let x = Math.ceil(fx - r); x \u003c= floor(fx + r); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const dd = (x - fx) * (x - fx) + (y - fy) * (y - fy);\n        if (dd > r * r) continue;\n        const p = y * W + x;\n        if (dark) {\n          pa[p] = -1;\n          pd[p] = 9;\n        } else if (pa[p] !== as[i] || dd \u003c pd[p]) {\n          pa[p] = as[i];\n          pd[p] = dd;\n          ps[p] = ss[i];\n        }\n      }\n  };\n  for (let i = 0; i \u003c xs.length; i++) stamp(i, RAD, false);\n  for (let i = 0; i \u003c xs.length; i++) if (fl[i] === 2) stamp(i, RAD + GAP, true);\n  for (let i = 0; i \u003c xs.length; i++) if (fl[i]) stamp(i, RAD, false);\n}\n\n// Label of each arc in colouring m of the walk: the digits of m in base p\n// turned into a modular Gray code, digit i the coefficient of basis vector i.\nfunction labels(S, m, out) {\n  const { basis, p } = S, d = basis.length;\n  out.fill(0);\n  let rest = mod(m, S.count);\n  const dig = [];\n  for (let i = 0; i \u003c d; i++) {\n    dig.push(rest % p);\n    rest = floor(rest / p);\n  }\n  for (let i = 0; i \u003c d; i++) {\n    const g = mod(dig[i] - (i + 1 \u003c d ? dig[i + 1] : 0), p);\n    if (g) for (let a = 0; a \u003c S.na; a++) out[a] = (out[a] + g * basis[i][a]) % p;\n  }\n  return out;\n}\n\nfunction text(S) {\n  const tx = S.tx;\n  tx.fill(0);\n  const put = (s, x, y, v) => {\n    for (const ch of s) {\n      const g = GLYPH[ch].split(\" \");\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\" && x + q \u003c W) tx[(y + r) * W + x + q] = v;\n      x += 4;\n    }\n    return x;\n  };\n  // p, raised d, \"=\", the count; the determinant at the right.\n  let x = put(String(S.p), 1, 2, 2);\n  x = put(String(S.basis.length), x, 0, 1);\n  x = put(\"=\", x, 2, 1);\n  put(String(S.count), x, 2, 2);\n  const ds = \"det\" + S.det;\n  put(ds, W - 4 * ds.length, 2, 1);\n}\n\nexport function setup(params) {\n  params.s = {\n    ki: -1, pi: -1, p: 3, hue: 0, speed: 2, w: 0, wave: 0, basis: [], count: 1, det: 1, M: [], na: 0, len: 1,\n    pa: new Int16Array(N), pd: new Float32Array(N), ps: new Float32Array(N), tx: new Uint8Array(N),\n    la: new Int32Array(16), lb: new Int32Array(16), col: new Float32Array(48), tmp: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ki = min(KNOTS.length - 1, floor(cl(k[2] || 0, 0, 1) * KNOTS.length));\n  const pi = min(PRIMES.length - 1, floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * PRIMES.length));\n  if (ki !== S.ki || pi !== S.pi) {\n    if (ki !== S.ki) build(S, ki);\n    S.pi = pi;\n    S.p = PRIMES[pi];\n    S.basis = colourings(S.M, S.na, S.p);\n    S.count = S.p ** S.basis.length;\n    // Open on a colouring that is not constant when there is one, settled.\n    S.w = (S.basis.length > 1 ? 1 : 0) + DIP;\n    text(S);\n  }\n  S.w += (d * S.speed) / STEP;\n  S.wave += (d * S.speed) / 18;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.ki \u003c 0) return;\n  const { pa, pd, ps, tx, col, la, lb, p } = S;\n  const m = floor(S.w), fr = S.w - m, u = fr / DIP;\n  labels(S, m, la);\n  labels(S, m - 1, lb);\n  // Colour of each arc: its label's hue, and while the colouring changes,\n  // the arcs that change dip dark and turn at the bottom of the dip.\n  for (let a = 0; a \u003c S.na; a++) {\n    let lab = la[a], v = 1;\n    if (u \u003c 1 && la[a] !== lb[a]) {\n      v = 1 - 0.85 * sin(PI * u);\n      if (u \u003c 0.5) lab = lb[a];\n    }\n    const c = hsv(S.hue + HUE0 + lab / p, 0.85, v, S.tmp);\n    col[a * 3] = c[0];\n    col[a * 3 + 1] = c[1];\n    col[a * 3 + 2] = c[2];\n  }\n  const ph = S.wave - floor(S.wave), L = S.len;\n  for (let i = 0; i \u003c N; i++) {\n    const a = pa[i], x = i % W, y = (i - x) / W;\n    if (a >= 0) {\n      // Brighter down the middle of a strand, and a little brighter where the\n      // slow wave round the knot is passing.\n      const wv = 0.82 + 0.18 * cos(2 * PI * (ps[i] / L - ph) * 3);\n      const b = (1 - 0.45 * (pd[i] / (RAD * RAD))) * wv;\n      display.setPixel(x, y, round(col[a * 3] * b), round(col[a * 3 + 1] * b), round(col[a * 3 + 2] * b));\n    } else if (tx[i]) {\n      const v = tx[i] === 2 ? 235 : 150;\n      display.setPixel(x, y, v, v, v);\n    } else display.setPixel(x, y, 0, 0, 0);\n  }\n}\n","franklin-involution":"// ===== Patternflow pattern =====\n// Title:   Franklin's Involution\n// Family:  number\n// Idea:    Every partition of n into distinct parts stands in turn as a Ferrers diagram of square dots in the top third, coloured by whether it has an even or an odd number of parts, over a faint lattice of every dot place a partition of n can reach, and Franklin's move flies its smallest row onto the slope of its largest rows, or the slope down into a new smallest row, leaving fading trails, to build its partner of the other colour in the bottom third, while the middle third counts the two colours level and writes Euler's series one coefficient at a time, until at a pentagonal n one staircase-trapezoid has no move to make and stands framed above the sign it gives the series.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler's pentagonal number theorem (Leonhard Euler, 1750) and Fabian Franklin's involution on partitions into distinct parts (Sur le développement du produit infini (1 - x)(1 - x^2)(1 - x^3)..., Comptes Rendus, 1881), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, N=5..16, Gap=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel, always opposite. At 0 partitions with an even number of parts are azure and odd ones amber; at 0.5 the two swap.\n// Knob 2: Speed. A partition takes 2.4 / Speed seconds: 1.2 s at the opening 2, 12 s at 0.2, 0.8 s at 3. The moved dots leave one after another, the last 0.3 of that time after the first, and each takes 0.42 of it to land; their trails keep a third of their light after a step.\n// Knob 3: N. The n the walk starts from, 5 to 16; it goes on to n + 1 after the last partition of n and back to N after 16. At the opening 5, (5) and (4, 1) turn into each other and then (3, 2) has no move, which gives x^5 its +1; n = 6 then comes out even, two pairs, and n = 7 ends on (4, 3). At 16 a pass is 32 partitions, 38 s.\n// Knob 4: Gap. The gap between dots as a share of their spacing: one LED at the opening 0.06, so the rows read as rows of square dots; at 0.5 the dots are five eighths of the spacing, at 1 a quarter.\n\n// Euler: (1 - x)(1 - x^2)(1 - x^3)... = 1 - x - x^2 + x^5 + x^7 - x^12 -\n// x^15 + ..., the exponents the pentagonal numbers k(3k - 1)/2 and\n// k(3k + 1)/2 with sign (-1)^k. Multiplied out, the product counts each\n// partition of n into distinct parts with +1 if it has an even number of\n// parts and -1 if odd, so the theorem says those two counts are equal\n// except at a pentagonal n.\n//\n// Franklin pairs them off. In the Ferrers diagram (largest part on top)\n// let s be the smallest part and sigma the slope, the number of top rows\n// that each fall short of the one above by exactly one dot. If s \u003c= sigma,\n// take the smallest row away and put one of its dots at the end of each of\n// the s largest rows; if s > sigma, take the last dot from each of the sigma\n// largest rows and lay them down as a new smallest row. The number of parts\n// changes by one and doing it twice gives back the partition. It fails only\n// when the slope runs down to the smallest row and shares its last dot,\n// with s = sigma = k or s = sigma + 1 = k + 1, the partitions (2k - 1, ...,\n// k) and (2k, ..., k + 1) of k(3k - 1)/2 and k(3k + 1)/2: (3, 2) for 5,\n// (4, 3) for 7, (5, 4, 3) for 12, (6, 5, 4) for 15.\n//\n// Each partition comes on top once, its partner straight after it, so a\n// pair is seen both ways round, and the lone one, if n has one, comes last.\n// The pair shares one dot spacing, the largest that fits both in a third\n// of the panel, up to 14 LEDs: 12 for (5) and (4, 1), 4 for (13) and (12, 1).\n// Behind each diagram every dot place that some partition of n uses is lit\n// faintly, brighter the more partitions use it (the first place is in all\n// of them, the end of the row (n) in one) and tinted by the share of those\n// with an even number of parts.\n\nconst W = 64, H = 128, TOP = 1, BOT = 85, REG = 42, NMAX = 16, UR = 6, UC = NMAX + 1;\nconst { floor, min, max, round, PI, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Digits and signs, 3 by 5, drawn for this pattern.\nconst GL = {\n  0: \"### #.# #.# #.# ###\", 1: \".#. ##. .#. .#. ###\", 2: \"### ..# ### #.. ###\", 3: \"### ..# .## ..# ###\",\n  4: \"#.# #.# ### ..# ..#\", 5: \"### #.. ### ..# ###\", 6: \"### #.. ### #.# ###\", 7: \"### ..# .#. .#. .#.\",\n  8: \"### #.# ### #.# ###\", 9: \"### #.# ### ..# ###\", \"+\": \"... .#. ### .#. ...\", \"-\": \"... ... ### ... ...\",\n};\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0] * 255;\n  o[1] = v[1] * 255;\n  o[2] = v[2] * 255;\n  return o;\n}\n\n// ---- Partitions -----------------------------------------------------------\n\n// Partitions of n into distinct parts, largest first, (n) first of all.\nfunction partitions(n) {\n  const out = [];\n  const rec = (rem, top, cur) => {\n    if (!rem) return void out.push(cur.slice());\n    for (let a = min(rem, top); a >= 1; a--) {\n      cur.push(a);\n      rec(rem - a, a - 1, cur);\n      cur.pop();\n    }\n  };\n  rec(n, n, []);\n  return out;\n}\n\n// Franklin's move on l: the partner and which dots go where, [row, column]\n// in l to [row, column] in the partner; null for the lone partition, with\n// the dots that block it.\nfunction franklin(l) {\n  const k = l.length, s = l[k - 1];\n  let sg = 1;\n  while (sg \u003c k && l[sg] === l[sg - 1] - 1) sg++;\n  const slope = [], low = [];\n  for (let i = 0; i \u003c sg; i++) slope.push([i, l[i] - 1]);\n  for (let j = 0; j \u003c s; j++) low.push([k - 1, j]);\n  if (s \u003c= sg) {\n    if (sg === k && s === k) return { m: null, slope, low };\n    const m = l.slice(0, k - 1);\n    for (let i = 0; i \u003c s; i++) m[i]++;\n    return { m, moves: low.map(([r, c]) => [[r, c], [c, l[c]]]) };\n  }\n  if (sg === k && s === sg + 1) return { m: null, slope, low };\n  const m = l.slice();\n  for (let i = 0; i \u003c sg; i++) m[i]--;\n  m.push(sg);\n  return { m, moves: slope.map(([r, c]) => [[r, c], [k, r]]) };\n}\n\n// The walk through n: each pair both ways round, then the lone one.\nfunction walk(n) {\n  const seen = new Set(), out = [];\n  let lone = null;\n  for (const l of partitions(n)) {\n    if (seen.has(l.join())) continue;\n    const f = franklin(l);\n    if (!f.m) {\n      lone = { l, f };\n      continue;\n    }\n    seen.add(l.join());\n    seen.add(f.m.join());\n    out.push({ l, f }, { l: f.m, f: franklin(f.m) });\n  }\n  if (lone) out.push(lone);\n  return out;\n}\n\n// Euler's coefficients: (-1)^k at the pentagonal numbers k(3k -+ 1)/2.\nconst COEF = new Int8Array(NMAX + 1);\nfor (let k = 1; k \u003c 5; k++) for (const e of [(k * (3 * k - 1)) / 2, (k * (3 * k + 1)) / 2]) if (e \u003c= NMAX) COEF[e] = k % 2 ? -1 : 1;\n\n// ---- State ----------------------------------------------------------------\n\nexport function setup(params) {\n  params.s = {\n    N: -1, n: 0, steps: [], i: 0, u: 0, e: 0, o: 0, lone: -1, hue: 0, speed: 2, gap: 0.06, t: 0,\n    buf: new Float32Array(W * H * 3), ca: [0, 0, 0], cb: [0, 0, 0],\n    use: new Float32Array(UR * UC), even: new Float32Array(UR * UC), q: 1, trail: new Float32Array(W * H * 3),\n  };\n}\n\n// How many partitions of n use each dot place, row r and column c, and\n// how many of those have an even number of parts.\nfunction usage(S, n) {\n  S.use.fill(0);\n  S.even.fill(0);\n  const P = partitions(n);\n  for (const l of P)\n    for (let r = 0; r \u003c l.length; r++)\n      for (let c = 0; c \u003c l[r]; c++) {\n        S.use[r * UC + c]++;\n        if (l.length % 2 === 0) S.even[r * UC + c]++;\n      }\n  S.q = P.length;\n}\n\nfunction begin(S, n) {\n  S.n = n;\n  S.steps = walk(n);\n  usage(S, n);\n  S.i = 0;\n  S.u = 0;\n  S.e = S.o = 0;\n  S.lone = -1;\n  count(S);\n}\n\n// The partition on top is counted as it comes up.\nfunction count(S) {\n  const st = S.steps[S.i];\n  if (st.l.length % 2) S.o++;\n  else S.e++;\n  if (!st.f.m) S.lone = st.l.length % 2;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.gap = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const N = cl(round(k[2] == null ? 5 : k[2]), 5, NMAX);\n  if (N !== S.N) {\n    S.N = N;\n    begin(S, N);\n  }\n  S.t += d;\n  S.u += (d * S.speed) / 2.4;\n  // The trail keeps a third of its light after a step.\n  const keep = Math.exp((-d * S.speed) / 2.2), tr = S.trail;\n  for (let i = 0; i \u003c tr.length; i++) tr[i] *= keep;\n  while (S.u >= 1) {\n    S.u -= 1;\n    if (++S.i >= S.steps.length) begin(S, S.n >= max(NMAX, S.N) ? S.N : S.n + 1);\n    else count(S);\n  }\n}\n\n// ---- Drawing --------------------------------------------------------------\n\nfunction rect(S, x, y, w, h, c, a) {\n  const b = S.buf;\n  for (let yy = max(0, round(y)); yy \u003c min(H, round(y) + h); yy++)\n    for (let xx = max(0, round(x)); xx \u003c min(W, round(x) + w); xx++) {\n      const i = (yy * W + xx) * 3;\n      b[i] = c[0] * a;\n      b[i + 1] = c[1] * a;\n      b[i + 2] = c[2] * a;\n    }\n}\n\nfunction text(S, s, x, y, sc, c, a) {\n  for (const ch of s) {\n    const g = GL[ch].split(\" \");\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\") rect(S, x + q * sc, y + r * sc, sc, sc, c, a);\n    x += 4 * sc;\n  }\n}\n\n// Lay a dot into the trail, keeping the brighter of old and new.\nfunction glow(S, x, y, w, c, a) {\n  const t = S.trail;\n  for (let yy = max(0, round(y)); yy \u003c min(H, round(y) + w); yy++)\n    for (let xx = max(0, round(x)); xx \u003c min(W, round(x) + w); xx++)\n      for (let q = 0, i = (yy * W + xx) * 3; q \u003c 3; q++) t[i + q] = max(t[i + q], c[q] * a);\n}\n\nconst mix = (c, w, o) => ((o[0] = c[0] + (255 - c[0]) * w), (o[1] = c[1] + (255 - c[1]) * w), (o[2] = c[2] + (255 - c[2]) * w), o);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.steps.length) return;\n  S.buf.set(S.trail);\n  const st = S.steps[S.i], l = st.l, f = st.f, m = f.m, u = S.u;\n  const ca = hsv(S.hue + 0.58, S.ca), cb = hsv(S.hue + 0.08, S.cb);\n  const col = (p) => (p.length % 2 ? cb : ca);\n  const fade = ease(u / 0.1) * (1 - ease((u - 0.94) / 0.06));\n\n  // One spacing for the pair, so the moved dots keep their size.\n  const wide = max(l[0], m ? m[0] : 0), tall = max(l.length, m ? m.length : 0);\n  const p = max(2, min(14, floor(62 / wide), floor((REG - 2) / tall)));\n  const ds = p \u003c= 2 ? 1 : cl(round(p * (1 - 0.75 * S.gap)), 1, p - 1);\n  const left = round((W - (wide * p - (p - ds))) / 2);\n  const ytop = (rows, y0) => y0 + round((REG - (rows * p - (p - ds))) / 2);\n  const yl = ytop(l.length, TOP), ym = m ? ytop(m.length, BOT) : 0;\n  const at = (y0, r, c) => [left + c * p, y0 + r * p];\n\n  // The middle third. Along the top, Euler's series so far: a cell for\n  // each m up to n, in the even colour for +x^m, the odd one for -x^m, grey\n  // for none, the cell for n blinking until its walk is done. Below, n on\n  // the left and even minus odd so far on the right, then a pip for each\n  // partition counted, even above, odd below.\n  const white = [210, 210, 210], grey = [55, 55, 55];\n  for (let j = 1; j \u003c= S.n; j++) {\n    const c = j \u003c S.n || S.i === S.steps.length - 1 ? COEF[j] : 2;\n    if (c === 2 && sin(S.t * 6) \u003c 0) continue;\n    rect(S, (j - 1) * 4, 46, 3, 3, c > 0 && c \u003c 2 ? ca : c \u003c 0 ? cb : c === 2 ? white : grey, 1);\n  }\n  text(S, String(S.n), 1, 53, 3, white, 1);\n  const dif = S.e - S.o, ds2 = dif > 0 ? \"+\" + dif : String(dif);\n  text(S, ds2, W - (4 * ds2.length - 1) * 3, 53, 3, dif > 0 ? ca : dif \u003c 0 ? cb : white, 1);\n  const pip = min(6, floor(W / Math.ceil(S.steps.length / 2)));\n  for (let j = 0; j \u003c S.e; j++) rect(S, j * pip, 71, pip - 1, pip - 1, ca, 1);\n  for (let j = 0; j \u003c S.o; j++) rect(S, j * pip, 78, pip - 1, pip - 1, cb, 1);\n  if (S.lone >= 0) {\n    // The pip with no partner flashes white.\n    const j = (S.lone ? S.o : S.e) - 1, w = 0.5 + 0.5 * sin(S.t * 6);\n    rect(S, j * pip, S.lone ? 78 : 71, pip - 1, pip - 1, mix(S.lone ? cb : ca, w, [0, 0, 0]), 1);\n  }\n\n  // Under each diagram, faintly, every dot place some partition of n\n  // reaches: the brighter the more partitions use it, tinted from the odd\n  // colour to the even one by the share of them with an even number of parts.\n  const faint = [0, 0, 0];\n  const lattice = (y0) => {\n    for (let r = 0; r \u003c UR; r++)\n      for (let c = 0; c \u003c UC; c++) {\n        const k = S.use[r * UC + c];\n        if (!k) continue;\n        const [x, y] = at(y0, r, c);\n        if (x >= W || y \u003c y0 - 1 || y + ds > (y0 \u003c BOT ? TOP + REG : H)) continue;\n        const w = S.even[r * UC + c] / k, a = (0.05 + 0.13 * (k / S.q)) * fade;\n        for (let q = 0; q \u003c 3; q++) faint[q] = ca[q] * w + cb[q] * (1 - w);\n        rect(S, x, y, ds, ds, faint, a);\n      }\n  };\n  lattice(yl);\n  if (m) lattice(ym);\n\n  const hl = [0, 0, 0];\n  if (!m) {\n    // The lone partition: its smallest row and its slope lit, the dot they\n    // share flashing, a frame round it, and the sign it gives below.\n    const mark = new Set([...f.slope, ...f.low].map(([r, c]) => r * 64 + c));\n    const shared = (l.length - 1) * 64 + l[l.length - 1] - 1;\n    for (let r = 0; r \u003c l.length; r++)\n      for (let c = 0; c \u003c l[r]; c++) {\n        const [x, y] = at(yl, r, c), key = r * 64 + c;\n        const w = key === shared ? 0.5 + 0.5 * sin(S.t * 6) : mark.has(key) ? 0.45 : 0;\n        rect(S, x, y, ds, ds, mix(col(l), w, hl), fade);\n      }\n    const fx0 = left - 3, fy0 = yl - 3, fw = l[0] * p - (p - ds) + 6, fh = l.length * p - (p - ds) + 6;\n    for (const [x, y, w, h] of [[fx0, fy0, fw, 1], [fx0, fy0 + fh - 1, fw, 1], [fx0, fy0, 1, fh], [fx0 + fw - 1, fy0, 1, fh]]) rect(S, x, y, w, h, white, fade);\n    const sg = l.length % 2 ? \"-1\" : \"+1\", a = ease((u - 0.25) / 0.2) * fade;\n    text(S, sg, round((W - 7 * 6) / 2), BOT + 10, 6, col(l), a);\n  } else {\n    // Dots that stay, top and bottom.\n    const from = new Set(f.moves.map(([a]) => a[0] * 64 + a[1])), to = new Set(f.moves.map(([, b]) => b[0] * 64 + b[1]));\n    const n = f.moves.length;\n    const v = f.moves.map((_, j) => ease((u - 0.14 - (n > 1 ? (0.3 * j) / (n - 1) : 0)) / 0.42));\n    for (let r = 0; r \u003c l.length; r++)\n      for (let c = 0; c \u003c l[r]; c++) {\n        const [x, y] = at(yl, r, c);\n        if (!from.has(r * 64 + c)) rect(S, x, y, ds, ds, col(l), fade);\n        // A dot about to move is lit; once gone it leaves a dim ghost.\n        else rect(S, x, y, ds, ds, mix(col(l), 0.45, hl), fade * (v[f.moves.findIndex(([a]) => a[0] === r && a[1] === c)] > 0 ? 0.22 : 1));\n      }\n    for (let r = 0; r \u003c m.length; r++)\n      for (let c = 0; c \u003c m[r]; c++) if (!to.has(r * 64 + c)) rect(S, ...at(ym, r, c), ds, ds, col(m), fade);\n    // The moved dots in flight, bowing out to the right on the way down.\n    // Each leaves its path in the trail, which fades over about a step.\n    f.moves.forEach(([a, b], j) => {\n      const [x0, y0] = at(yl, a[0], a[1]), [x1, y1] = at(ym, b[0], b[1]), w = v[j];\n      if (w \u003c= 0) return;\n      const x = x0 + (x1 - x0) * w + sin(PI * w) * (6 + 2 * j), y = y0 + (y1 - y0) * w;\n      const k = mix(col(m), 0.45, hl);\n      if (w \u003c 1) glow(S, x, y, ds, k, 0.4);\n      rect(S, x, y, ds, ds, k, fade);\n    });\n  }\n\n  const b = S.buf;\n  for (let i = 0; i \u003c W * H; i++) display.setPixel(i % W, floor(i / W), round(b[i * 3]), round(b[i * 3 + 1]), round(b[i * 3 + 2]));\n}\n","galileos-frets":"// ===== Patternflow pattern =====\n// Title:   Galileo's Frets\n// Family:  rhythm\n// Idea:    Three grooves run down an inclined plane, each with its own frets and its own ball, all released together from the top: the middle groove's frets sit at the squares 1, 4, 9, 16 so its ball bumps over them on an even beat, the outer two sit at other powers so their beats speed up or slow down, and beside each groove its strikes stand as stripes on a strip of time against the dotted lines of an even metronome.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Galileo's law of fall and the law of odd numbers (Galileo Galilei, Two New Sciences, 1638), the frets on the inclined plane as Stillman Drake read them (The Role of Music in Galileo's Experiments, Scientific American, June 1975), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Law=1..3, Frets=0..1\n//\n// Knob 1: Hue. Turns the three grooves round the wheel together. At 0 the left one is azure, Galileo's in the middle green and the right one magenta.\n// Knob 2: Speed. How steep the plane is. The acceleration goes as the knob, so a fall takes 4 s at 2 (with 8 frets Galileo's groove strikes every 0.5 s), 12.6 s at 0.2 and 3.3 s at 3.\n// Knob 3: Law. The exponent p of the left groove's frets, which sit at (n/N)^p of the plane; the right groove takes 4 - p. At the opening 1, even spacing, whose first strike comes 1.41 s into a 4 s fall and whose last two are 0.26 s apart, against the cubes on the right, which strike first 0.18 s in and last 0.73 s after the one before. At 2 all three grooves are Galileo's and strike together on the beat; at 3 the outer two have swapped.\n// Knob 4: Frets. How many frets each groove has: 8 at the opening, 10, 12 and 14 at the quarters, 16 at the end.\n\n// A ball rolling from rest down a plane covers x = a t^2 / 2, so in equal\n// times it covers distances in the ratio of the odd numbers 1, 3, 5, 7, and\n// after n beats it has gone n^2. Drake read Galileo's working notes as an\n// experiment done by ear: gut frets tied round the plane, the ball bumping\n// over each, the frets moved until the bumps came on an even beat, and their\n// distances then measured from the start, which came out as the squares.\n//\n// Here the three grooves share one plane, so their balls fall together, and\n// they differ only in where their frets are: fret n of N at (n/N)^p of the\n// plane's 128 rows. The ball crosses it at (n/N)^(p/2) of the time of the\n// fall, and only p = 2 makes that n/N, the beat. Beside each groove is a\n// strip of time, 128 rows for the length of the fall, with the metronome's\n// N even marks down its left edge and carried across it as dotted lines.\n// Stretch n of the groove, fret n - 1 to fret n, and stretch n of the strip,\n// strike n - 1 to strike n, are one piece of the fall, once as a distance\n// and once as a time. In Galileo's groove the stretches grow 1, 3, 5, 7\n// and their times are all equal, so its stripes lie on the dotted lines;\n// with even frets the times shrink, with the cubes they grow. A white mark\n// runs down the metronome at an even pace while the ball runs down the\n// groove ever faster, and both get to the bottom together.\n\n// Each lane is 21 LEDs: the groove between walls 8 apart, then the\n// metronome's column and the strip of time.\nconst W = 64, H = 128, N = W * H, LANES = 3, LW = 21, GR = 8, REST = 0.35;\nconst { floor, min, max, round, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst HUES = [0.57, 0.31, 0.87];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, law: 1, nf: 8, t: 0, T: 4,\n    flash: [new Float32Array(17), new Float32Array(17), new Float32Array(17)],\n    buf: new Float32Array(N * 3), col: [0, 0, 0],\n  };\n}\n\n// Exponents of the three grooves' frets: Law, Galileo's 2, and 4 - Law.\nconst laws = (S) => [S.law, 2, 4 - S.law];\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.law = cl(k[2] == null ? 1 : k[2], 1, 3);\n  S.nf = 8 + round(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 8);\n  // The acceleration goes as Speed, so the time of a fall as 1/sqrt(Speed).\n  S.T = 4 * sqrt(2 / S.speed);\n  const u0 = S.t / S.T;\n  S.t += d;\n  const u1 = S.t / S.T, P = laws(S);\n  for (const f of S.flash) for (let n = 0; n \u003c f.length; n++) f[n] = max(0, f[n] - d * 4);\n  // A fret struck between the last frame and this one flashes.\n  for (let L = 0; L \u003c LANES; L++)\n    for (let n = 1; n \u003c= S.nf; n++) {\n      const tn = (n / S.nf) ** (P[L] / 2);\n      if (tn > u0 && tn \u003c= u1) S.flash[L][n] = 1;\n    }\n  if (S.t >= S.T + REST) S.t = 0;\n}\n\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\nfunction band(buf, x0, x1, y0, y1, c, a) {\n  for (let y = max(0, y0); y \u003c= min(H - 1, y1); y++) for (let x = x0; x \u003c= x1; x++) add(buf, x, y, c, a);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, col = S.col, nf = S.nf, u = min(1, S.t / S.T), by = (H - 1) * u * u, P = laws(S);\n  buf.fill(0);\n  const white = [1, 1, 1];\n  for (let L = 0; L \u003c LANES; L++) {\n    const ox = L * LW, p = P[L], fl = S.flash[L], gr = ox + GR, mx = gr + 2, sx = gr + 4, ex = ox + LW - 1, bx = ox + GR / 2;\n    hsv(S.hue + HUES[L], col);\n    // The stretches of the groove and of the strip: the strip's shaded\n    // alternately, and both lit while the ball is in that stretch.\n    let g0 = 0, s0 = 0;\n    for (let n = 1; n \u003c= nf; n++) {\n      const g1 = round((H - 1) * (n / nf) ** p), s1 = round((H - 1) * (n / nf) ** (p / 2)), f = fl[n];\n      const now = u \u003c 1 && by \u003c g1 && by >= g0;\n      band(buf, ox + 1, gr - 1, g0 + 1, g1 - 1, col, now ? 0.5 : 0.03);\n      band(buf, sx, ex, s0 + 1, s1 - 1, col, (n % 2 ? 0.26 : 0.08) + (now ? 0.4 : 0));\n      // The fret, and the strike in the strip, flash white as the ball\n      // bumps over it.\n      band(buf, ox, gr, g1, g1, col, 0.6 + 0.4 * f);\n      band(buf, ox, gr, g1, g1, white, 0.7 * f);\n      band(buf, sx, ex, s1, s1, col, 0.6 + 0.4 * f);\n      band(buf, sx, ex, s1, s1, white, 0.7 * f);\n      g0 = g1;\n      s0 = s1;\n    }\n    band(buf, ox, ox, 0, H - 1, col, 0.25);\n    band(buf, gr, gr, 0, H - 1, col, 0.25);\n    // The metronome down the strip's left edge: N even marks, and time\n    // running down past them at an even pace.\n    const ty = round((H - 1) * u);\n    band(buf, mx, mx + 1, 0, ty, white, 0.1);\n    for (let n = 1; n \u003c= nf; n++) {\n      const y = round(((H - 1) * n) / nf);\n      band(buf, mx, mx + 1, y, y, white, 0.45);\n      // Carried across the strip as a dotted line, so a strike on the beat\n      // lies on it.\n      for (let x = sx + 1; x \u003c= ex; x += 2) add(buf, x, y, white, 0.3);\n    }\n    band(buf, mx, mx + 1, ty, ty, white, 1);\n    // The ball, and a streak over the ground it covered in the last 6% of\n    // the fall's time.\n    const v = 2 * (H - 1) * u, tail = min(by, v * 0.06);\n    for (let y = floor(by - tail); y \u003c= by; y++) add(buf, bx, y, white, 0.2 + 0.4 * (1 - (by - y) / max(1, tail)));\n    const yb = round(by);\n    band(buf, bx - 1, bx + 1, yb - 1, yb, white, 0.7);\n    band(buf, bx, bx, yb - 1, yb, white, 0.3);\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","quipu":"// ===== Patternflow pattern =====\n// Title:   Quipu\n// Family:  type\n// Idea:    Pendant cords hang the full height from a primary cord across the top, each holding a number tied in decimal place clusters, thousands at the top and units nearest the free end, single knots counted out for the upper places, a long knot of two to nine turns or a figure-eight for the units and bare cord for zero, with the digit written in small figures beside each cluster; the cords count up at their own rates, knots flash as they are tied and fade as a carry unties them, and each change runs along the primary cord to the pale cord at the end of the group, which always comes back to their sum.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: khipu of the Inka as Leland Locke read their decimal knots and sum cords (L. Leland Locke, The Ancient Quipu or Peruvian Knot Record, 1923), with the knot types of Marcia and Robert Ascher (Code of the Quipu, 1981), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cords=5..8, Step=0..1\n//\n// Knob 1: Hue. Turns the three cord colours round the wheel together. At 0 they are azure, amber and rose; the sum cord stays a pale cream whatever the knob says.\n// Knob 2: Speed. How often the cords count. At 2 the four data cords of the opening tick 0.7 to 2.2 times a second, 5.6 ticks a second in all reaching the sum; 0.2 is ten times slower, 3 half as fast again. A cord jumps from 40% to full strength when it ticks, and the extra light falls to 37% in 0.8 s.\n// Knob 3: Cords. Pendants on the primary cord, 5 to 8, the last always the sum of the others. With 4 data cords each counts up to 2499 and wraps to the remainder, with 7 up to 1428, so the sum never needs a fifth place. Up to 7 the cords are 2 LEDs thick; 8 only fit at 1.\n// Knob 4: Step. What one tick adds to a data cord, five stations: 1, 10, 100, 111, 1111. At 1 the long knot grows a turn a tick and every tenth tick unties it and ties a ten; at 10 the units hold still and the tens count; at 100 the hundreds count and a thousand is tied every tenth tick; at 111 the units, tens and hundreds each take a knot every tick; at 1111 all four places do, and with 4 data cords a cord passes 2499 every two or three ticks and wraps.\n\n// A khipu records a number on a pendant cord in clusters of knots, one\n// cluster for each decimal place, the places at the same height on every\n// cord so that they read across as rows. Locke showed this in 1912 and set\n// it out in the 1923 monograph, along with cords whose values are the sums\n// of a group of pendants. The Aschers' notation names three knots: s, the\n// single overhand knot, one for each unit of a place above the units; L,\n// the long knot, a coil of 2 to 9 turns that holds the units digit, so the\n// units place can be told from the others even where the places of\n// neighbouring cords do not line up; and\n// E, the figure-eight, for a units digit of 1, since a long knot of one\n// turn is just a single knot. A place holding zero is a stretch of bare\n// cord.\n//\n// Here a single knot is a bead one LED wider than the cord on each side\n// and 2 rows tall, with a row of bare cord between beads; a long knot is a\n// coil of turns 2 rows apart, each slanting across the cord, bright in\n// front and dim behind; a figure-eight is two loops stacked on the cord,\n// washed toward white. The four places start at rows 8, 37,\n// 66 and 96, so nine single knots (26 rows) fit in each. Each data cord\n// ticks on its own clock. Its change runs along the primary cord at 80\n// LEDs a second (at Speed 2) and the sum cord adds it on arrival, so the\n// sum is exact whenever nothing is on its way.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Top row of each place's cluster: units, tens, hundreds, thousands.\nconst TIER = [96, 66, 37, 8];\nconst P10 = [1, 10, 100, 1000];\nconst STEPS = [1, 10, 100, 111, 1111];\n// Ticks a second at Speed 1 for each data cord.\nconst RATE = [0.5, 0.85, 0.35, 1.1, 0.65, 0.95, 0.42];\n// LEDs a second a change runs along the primary cord at Speed 1.\nconst RUN = 40;\n// Category hues of the data cords, before the Hue knob.\nconst CAT = [0.56, 0.11, 0.9];\n// Seconds a knot takes to be tied or untied, and for a cord's glow to fall\n// to a third.\nconst TT = 0.3, GLOW = 0.8;\nconst BLACK = [0, 0, 0];\n\nconst FONT = [\n  \"### #.# #.# #.# ###\", \".#. ##. .#. .#. ###\", \"### ..# ### #.. ###\", \"### ..# .## ..# ###\", \"#.# #.# ### ..# ..#\",\n  \"### #.. ### ..# ###\", \"### #.. ### #.# ###\", \"### ..# ..# .#. .#.\", \"### #.# ### #.# ###\", \"### #.# ### ..# ###\",\n].map((s) => s.split(\" \"));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [\n    255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p),\n    255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p),\n    255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p),\n  ];\n}\n\nconst newCord = (v, rate, x) => ({ v, pv: v, tc: 9, glow: 0, acc: Math.random(), rate, x, end: 116 + floor(Math.random() * 7), ph: floor(Math.random() * 3) });\n\nfunction build(S, n) {\n  S.n = n;\n  S.cw = n \u003c= 7 ? 2 : 1;\n  S.cap = floor(9999 / (n - 1));\n  S.cords = [];\n  S.sparks = [];\n  // Each cord needs its beads (x - 1 to x + cw) and its figures (x + cw + 2\n  // to x + cw + 4) and a dark LED either side of them.\n  const span = 63 - (S.cw + 5);\n  let total = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const x = 1 + round((i * span) / (n - 1));\n    if (i \u003c n - 1) {\n      const v = floor(Math.random() * (S.cap + 1));\n      total += v;\n      S.cords.push(newCord(v, RATE[i], x));\n    } else S.cords.push(newCord(total, 0, x));\n  }\n}\n\nexport function setup(params) {\n  params.s = { n: 0, cw: 2, cap: 0, hue: 0, speed: 2, step: 1, cords: [], sparks: [], buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const n = cl(floor((k[2] == null ? 5 : k[2]) + 0.25), 5, 8);\n  if (n !== S.n) build(S, n);\n  S.step = STEPS[min(4, floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 5))];\n  const C = S.cords, sum = C[n - 1], fade = exp(-d / GLOW);\n  for (let i = 0; i \u003c n; i++) {\n    const c = C[i];\n    c.tc += d;\n    c.glow *= fade;\n    if (i === n - 1) break;\n    c.acc += d * S.speed * c.rate;\n    while (c.acc >= 1) {\n      c.acc -= 1;\n      c.pv = c.v;\n      c.v = (c.v + S.step) % (S.cap + 1);\n      c.tc = 0;\n      c.glow = 1;\n      // A wrap carries a negative amount.\n      S.sparks.push({ i, x: c.x, delta: c.v - c.pv });\n    }\n  }\n  const run = RUN * S.speed * d;\n  S.sparks = S.sparks.filter((sp) => {\n    sp.x += run;\n    if (sp.x \u003c sum.x) return true;\n    sum.pv = sum.v;\n    sum.v += sp.delta;\n    sum.tc = 0;\n    sum.glow = 1;\n    return false;\n  });\n}\n\n// Strength of the cord being drawn, set before each part of it.\nlet GAIN = 1;\n\nfunction put(buf, x, y, c, b, w) {\n  b *= GAIN;\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || b \u003c 0) return;\n  const o = (y * W + x) * 3;\n  buf[o] = (c[0] + (255 - c[0]) * w) * b;\n  buf[o + 1] = (c[1] + (255 - c[1]) * w) * b;\n  buf[o + 2] = (c[2] + (255 - c[2]) * w) * b;\n}\n\nfunction bar(buf, x0, x1, y, c, b, w) {\n  for (let x = x0; x \u003c= x1; x++) put(buf, x, y, c, b, w);\n}\n\n// How a knot that is there, being tied or being untied, is drawn: its\n// strength and how far it is washed toward white. A new knot flashes\n// nearly white for the first third of its tying.\nfunction look(k, d, pd, u) {\n  if (k \u003c d && k \u003c pd) return [1, 0.15];\n  if (k \u003c d) return u \u003c 0.35 ? [1.15, 0.85] : [1, 0.15 + 0.7 * (1 - u)];\n  if (k \u003c pd) return [0.9 * (1 - u), 0.1];\n  return null;\n}\n\n// The units: a figure-eight for 1, a long knot of d turns for 2 to 9.\nfunction units(buf, x, cw, d, pd, u, c) {\n  const y0 = TIER[0], xr = x + cw;\n  if (d === 1 || pd === 1) {\n    // Steady, being tied, or fading under the long knot that replaces it.\n    const [b, w] = d !== 1 ? [0.9 * (1 - u), 0.1] : pd === 1 ? [1, 0.2] : u \u003c 0.35 ? [1.15, 0.85] : [1, 0.2 + 0.65 * (1 - u)];\n    for (let r = 0; r \u003c 5; r++) {\n      if (r % 2) {\n        put(buf, x - 1, y0 + r, c, b, w);\n        put(buf, xr, y0 + r, c, b, w);\n        bar(buf, x, xr - 1, y0 + r, BLACK, 1, 0);\n      } else bar(buf, x, xr - 1, y0 + r, c, b, r === 2 ? 0.7 : max(w, 0.35));\n    }\n  }\n  // Each turn of a long knot slants across the cord: its front a bright\n  // row from the left, its back a dim row to the right.\n  const ld = d >= 2 ? d : 0, lp = pd >= 2 ? pd : 0, m = max(ld, lp);\n  for (let t = 0; t \u003c m; t++) {\n    const lk = look(t, ld, lp, u);\n    if (!lk) continue;\n    const y = y0 + 2 * t;\n    bar(buf, x - 1, xr - 1, y, c, lk[0], lk[1]);\n    put(buf, xr, y, BLACK, 1, 0);\n    put(buf, x - 1, y + 1, BLACK, 1, 0);\n    bar(buf, x, xr, y + 1, c, lk[0] * 0.5, lk[1]);\n  }\n}\n\nfunction digit(buf, x, y, dg, c, b) {\n  const g = FONT[dg];\n  for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\") put(buf, x + q, y + r, c, b, 0.25);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const { buf, cords, n, cw } = S;\n  buf.fill(0);\n  GAIN = 1;\n  // The primary cord, three rows of plied cotton.\n  const pc = hsv(0.09, 0.3, 1);\n  for (let y = 2; y \u003c= 4; y++) for (let x = 0; x \u003c W; x++) put(buf, x, y, pc, (x + 2 * y) % 3 === 0 ? 0.32 : 0.55, 0);\n  for (let i = 0; i \u003c n; i++) {\n    const cd = cords[i], x = cd.x, xr = x + cw;\n    const col = i === n - 1 ? hsv(0.12, 0.18, 1) : hsv(S.hue + CAT[i % 3], 0.8, 1);\n    // The pendant, hitched over the primary cord, plied in a slant, and\n    // fraying at its free end. It dims at rest and brightens as it changes.\n    GAIN = 0.4 + 0.6 * cd.glow;\n    put(buf, x - 1, 1, col, 0.6, 0);\n    put(buf, xr, 1, col, 0.6, 0);\n    for (let y = 1; y \u003c= cd.end; y++) for (let c = 0; c \u003c cw; c++) put(buf, x + c, y, col, (y + c + cd.ph) % 3 === 0 ? 0.5 : 0.8, 0);\n    for (let y = cd.end + 1; y \u003c= cd.end + 3; y++) {\n      put(buf, x - 1, y, col, 0.5 - 0.1 * (y - cd.end), 0);\n      put(buf, xr, y, col, 0.5 - 0.1 * (y - cd.end), 0);\n    }\n    // Knots and figures stay near full strength.\n    GAIN = 0.85 + 0.15 * cd.glow;\n    const u = min(1, cd.tc / TT), v = cd.v, pv = cd.pv;\n    for (let q = 3; q >= 0; q--) {\n      const dd = floor(v / P10[q]) % 10, pd = floor(pv / P10[q]) % 10;\n      if (q > 0) {\n        for (let kk = 0; kk \u003c max(dd, pd); kk++) {\n          const lk = look(kk, dd, pd, u);\n          if (!lk) continue;\n          const y = TIER[q] + 3 * kk;\n          bar(buf, x - 1, xr, y, col, lk[0], lk[1]);\n          bar(buf, x - 1, xr, y + 1, col, lk[0], lk[1]);\n        }\n      } else units(buf, x, cw, dd, pd, u, col);\n      // The written digit beside the cluster, from the leading place down.\n      if (v >= P10[q] || q === 0) digit(buf, xr + 2, TIER[q], dd, col, dd === pd || u >= 1 ? 0.8 : 1);\n    }\n  }\n  GAIN = 1;\n  // Changes on their way to the sum cord, a bright head with a short tail.\n  for (const sp of S.sparks) {\n    const col = hsv(S.hue + CAT[sp.i % 3], 0.8, 1), hx = round(sp.x);\n    for (let t = 0; t \u003c 5; t++) for (let y = 2; y \u003c= 4; y++) put(buf, hx - t, y, col, t ? 0.8 - 0.15 * t : 1, t ? 0 : 0.6);\n  }\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, round(buf[p])), min(255, round(buf[p + 1])), min(255, round(buf[p + 2])));\n}\n","square-word":"// ===== Patternflow pattern =====\n// Title:   Square Word\n// Family:  type\n// Idea:    Two English words stand as an ordinary line of letters, one in each half of the panel, and then their letters glide and squeeze into the boxes of a square character the way Xu Bing writes English, left to right, top to bottom, outside to inside, so the panel holds two square characters one above the other, a phrase read top to bottom like vertical writing, before it fades and the next phrase is written.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Square Word Calligraphy (Xu Bing, An Introduction to Square Word Calligraphy, 1994-96); the single-stroke letters and the box templates drawn here, pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Weight=1.5..4\n//\n// Knob 1: Hue. Turns every letter round the wheel together. At 0 the top word runs from gold through yellow to green, 0.07 of the wheel a letter, and the bottom word from azure through blue and violet to magenta, so letters that touch in the square stay apart by colour; at 0.5 the two words swap.\n// Knob 2: Speed. At 2 a phrase takes 8.4 s: the letters are written in a line in 1.3 s, stand 0.7 s, glide into the square over 2.4 s, the two characters hold 3.2 s and fade out over 0.8 s. At 0.2 it all runs ten times slower, at 3 one and a half times faster.\n// Knob 3: Phrase. Which of the eight phrases is written first, to the nearest whole number: 0 LOOK UP, 1 HELLO WORLD, 2 GOOD LUCK, 3 ON AIR, 4 LONG LIFE, 5 ART NOW, 6 OPEN BOOK, 7 READ ME. The others follow in that order.\n// Knob 4: Weight. The pen, 1.5 LEDs wide at the opening up to 4. As a letter goes into the square its strokes thicken by 30% and the upright ones by up to 70%, the way a brush lays a down stroke heavier than a cross stroke; at 4 the O of a line letter fills in, while the O squeezed into HELLO's 19 LED box keeps a hole a few LEDs wide.\n// Buttons: K1 tap fades the phrase and writes the next one.\n\n// A letter is a few polylines on an 8 by 8 grid. Laid into a box of any\n// shape it stretches with it, but its stroke stays the pen's width in\n// LEDs, so the E of HELLO, squeezed into a quarter of the square, keeps\n// three bars and two gaps. A template divides the 58 LED square into\n// boxes in reading order, left to right, top to bottom, outside to\n// inside, which is Xu Bing's rule: a two by two grid, a tall box at the\n// left with one over two at the right, a roof over two, one over two\n// over two, two over three, two tall boxes and a stack, two over one,\n// one over one, and the enclosure, where an O or a U takes the whole\n// square and the next letter sits inside it. Each word was given the\n// template that suits its letters by hand: A as a roof, W wide on top or\n// at the bottom, the long upright of an L, B or R as the left side, O\n// round N and U round P. The narrowest box is the I of LIFE, 12 LEDs\n// across; the L, L and O of HELLO get 19 by 29. Letters keep 1 + 0.7\n// times the pen's width from the edge of their box.\n\nconst W = 64, H = 128, N = W * H, SQ = 58, X0 = 3, Y0 = [3, 67];\nconst { floor, round, min, max, abs, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n// Seconds at Speed 2.\nconst WRITE = 1.3, LINE = 0.7, GLIDE = 2.4, HOLD = 3.2, FADE = 0.8, CYCLE = WRITE + LINE + GLIDE + HOLD + FADE;\nconst HUE0 = 0.12;\n\n// x right, y down, 0..8.\nconst FONT = {\n  A: [[0, 8, 4, 0, 8, 8], [1.5, 5, 6.5, 5]],\n  B: [[0, 0, 0, 8], [0, 0, 5, 0, 7, 1, 7, 3, 5, 4, 0, 4], [5, 4, 7.5, 5, 8, 6.5, 7.5, 7.5, 5.5, 8, 0, 8]],\n  C: [[8, 1.5, 6, 0, 2, 0, 0, 2, 0, 6, 2, 8, 6, 8, 8, 6.5]],\n  D: [[0, 0, 0, 8, 4.5, 8, 8, 5, 8, 3, 4.5, 0, 0, 0]],\n  E: [[8, 0, 0, 0, 0, 8, 8, 8], [0, 4, 6, 4]],\n  F: [[8, 0, 0, 0, 0, 8], [0, 4, 6, 4]],\n  G: [[8, 1.5, 6, 0, 2, 0, 0, 2, 0, 6, 2, 8, 6, 8, 8, 6, 8, 4.5, 4.5, 4.5]],\n  H: [[0, 0, 0, 8], [8, 0, 8, 8], [0, 4, 8, 4]],\n  I: [[4, 0, 4, 8], [1.5, 0, 6.5, 0], [1.5, 8, 6.5, 8]],\n  J: [[3, 0, 8, 0, 8, 6, 6, 8, 2, 8, 0, 6]],\n  K: [[0, 0, 0, 8], [8, 0, 0, 5], [2.6, 3.4, 8, 8]],\n  L: [[0, 0, 0, 8, 8, 8]],\n  M: [[0, 8, 0, 0, 4, 5, 8, 0, 8, 8]],\n  N: [[0, 8, 0, 0, 8, 8, 8, 0]],\n  O: [[2, 0, 6, 0, 8, 2, 8, 6, 6, 8, 2, 8, 0, 6, 0, 2, 2, 0]],\n  P: [[0, 8, 0, 0, 6, 0, 8, 1.5, 8, 3, 6, 4.5, 0, 4.5]],\n  Q: [[2, 0, 6, 0, 8, 2, 8, 6, 6, 8, 2, 8, 0, 6, 0, 2, 2, 0], [4.5, 5, 8, 8.5]],\n  R: [[0, 8, 0, 0, 6, 0, 8, 1.5, 8, 3, 6, 4.5, 0, 4.5], [4, 4.5, 8, 8]],\n  S: [[8, 1.5, 6.5, 0, 1.5, 0, 0, 1.5, 0, 2.5, 1.5, 4, 6.5, 4, 8, 5.5, 8, 6.5, 6.5, 8, 1.5, 8, 0, 6.5]],\n  T: [[0, 0, 8, 0], [4, 0, 4, 8]],\n  U: [[0, 0, 0, 6, 2, 8, 6, 8, 8, 6, 8, 0]],\n  V: [[0, 0, 4, 8, 8, 0]],\n  W: [[0, 0, 2, 8, 4, 3, 6, 8, 8, 0]],\n  X: [[0, 0, 8, 8], [8, 0, 0, 8]],\n  Y: [[0, 0, 4, 4], [8, 0, 4, 4, 4, 8]],\n  Z: [[0, 0, 8, 0, 0, 8, 8, 8]],\n};\n\n// Boxes [x0, y0, x1, y1] in the unit square, in reading order.\nconst T3 = 1 / 3, T6 = 2 / 3;\nconst TPL = {\n  tb: [[0, 0, 1, 0.45], [0, 0.45, 1, 1]],\n  \"o@\": [[0, 0, 1, 1], [0.24, 0.24, 0.76, 0.76]],\n  \"u@\": [[0, 0, 1, 1], [0.24, 0.02, 0.76, 0.74]],\n  \"roof\": [[0, 0, 1, 0.42], [0, 0.42, 0.5, 1], [0.5, 0.42, 1, 1]],\n  \"lr/b\": [[0, 0, 0.5, 0.56], [0.5, 0, 1, 0.56], [0, 0.56, 1, 1]],\n  g4: [[0, 0, 0.5, 0.5], [0.5, 0, 1, 0.5], [0, 0.5, 0.5, 1], [0.5, 0.5, 1, 1]],\n  \"l|t/lr\": [[0, 0, 0.38, 1], [0.38, 0, 1, 0.48], [0.38, 0.48, 0.69, 1], [0.69, 0.48, 1, 1]],\n  \"ll|tb\": [[0, 0, 0.32, 1], [0.32, 0, 0.52, 1], [0.52, 0, 1, 0.5], [0.52, 0.5, 1, 1]],\n  \"lr/lmr\": [[0, 0, 0.5, 0.5], [0.5, 0, 1, 0.5], [0, 0.5, T3, 1], [T3, 0.5, T6, 1], [T6, 0.5, 1, 1]],\n  \"t/lr/lr\": [[0, 0, 1, 0.34], [0, 0.34, 0.5, 0.67], [0.5, 0.34, 1, 0.67], [0, 0.67, 0.5, 1], [0.5, 0.67, 1, 1]],\n};\n\nconst PHRASES = [\n  [[\"LOOK\", \"g4\"], [\"UP\", \"u@\"]],\n  [[\"HELLO\", \"lr/lmr\"], [\"WORLD\", \"t/lr/lr\"]],\n  [[\"GOOD\", \"g4\"], [\"LUCK\", \"l|t/lr\"]],\n  [[\"ON\", \"o@\"], [\"AIR\", \"roof\"]],\n  [[\"LONG\", \"l|t/lr\"], [\"LIFE\", \"ll|tb\"]],\n  [[\"ART\", \"roof\"], [\"NOW\", \"lr/b\"]],\n  [[\"OPEN\", \"g4\"], [\"BOOK\", \"l|t/lr\"]],\n  [[\"READ\", \"l|t/lr\"], [\"ME\", \"tb\"]],\n];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The practice grid behind each character: the square's outline and a\n// dashed cross through its middle, as in a copybook.\nconst GRID = new Uint8Array(N);\nfor (const y0 of Y0) {\n  for (let i = -1; i \u003c= SQ; i++) {\n    for (const [x, y] of [[X0 + i, y0 - 1], [X0 + i, y0 + SQ], [X0 - 1, y0 + i], [X0 + SQ, y0 + i]])\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) GRID[y * W + x] = 2;\n    if (i >= 0 && i \u003c SQ && (i & 3) \u003c 2) {\n      GRID[(y0 + SQ / 2) * W + X0 + i] = 1;\n      GRID[(y0 + i) * W + X0 + SQ / 2] = 1;\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 1, wt: 1.5, st: -1, n: 0, t: 0, btn: false,\n    cov: new Float32Array(N), id: new Uint8Array(N), pal: [], words: [],\n  };\n  for (let i = 0; i \u003c 13; i++) params.s.pal.push([0, 0, 0]);\n  return params.s;\n}\n\n// The letters of a phrase with their two boxes, the line and the square.\nfunction build(S) {\n  const ph = PHRASES[(S.st + S.n) % PHRASES.length];\n  S.words = ph.map(([word, tpl], k) => {\n    const n = word.length, boxes = TPL[tpl], lw = 8.5, lh = 20, adv = 12.4;\n    const lx = 32 - (adv * (n - 1) + lw) / 2, ly = Y0[k] + SQ / 2 - lh / 2;\n    return [...word].map((ch, j) => {\n      const b = boxes[j];\n      return {\n        g: FONT[ch], j, k,\n        line: [lx + adv * j, ly, lx + adv * j + lw, ly + lh],\n        sq: [X0 + b[0] * SQ, Y0[k] + b[1] * SQ, X0 + b[2] * SQ, Y0[k] + b[3] * SQ],\n      };\n    });\n  });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.wt = cl(k[3] == null ? 1.5 : k[3], 1.5, 4);\n  const st = round(cl(k[2] || 0, 0, PHRASES.length - 1));\n  if (st !== S.st) {\n    S.st = st;\n    S.n = 0;\n    S.t = 0;\n    build(S);\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && S.t \u003c CYCLE - FADE) S.t = CYCLE - FADE;\n  S.btn = btn;\n  S.t += d * S.rate;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    S.n++;\n    build(S);\n  }\n}\n\n// One stroke segment, lit by the pixel centre's distance to it.\nfunction seg(S, ax, ay, bx, by, w, c) {\n  const { cov, id } = S, r = w / 2 + 0.5;\n  const x0 = max(0, floor(min(ax, bx) - r)), x1 = min(W - 1, floor(max(ax, bx) + r));\n  const y0 = max(0, floor(min(ay, by) - r)), y1 = min(H - 1, floor(max(ay, by) + r));\n  const dx = bx - ax, dy = by - ay, ll = dx * dx + dy * dy || 1e-9;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay, u = cl((px * dx + py * dy) / ll, 0, 1);\n      const ex = px - u * dx, ey = py - u * dy, v = r - sqrt(ex * ex + ey * ey);\n      if (v \u003c= 0) continue;\n      const p = y * W + x, cv = v > 1 ? 1 : v;\n      if (cv > cov[p]) {\n        cov[p] = cv;\n        id[p] = c;\n      }\n    }\n}\n\n// A letter in box b; m is how far it has gone into the square (heavier\n// down strokes), u how much of it has been written, by length.\nfunction letter(S, L, b, m, u, c) {\n  const w = S.wt, sx = (b[2] - b[0]) / 8, sy = (b[3] - b[1]) / 8;\n  let total = 0;\n  if (u \u003c 1) for (const s of L.g) for (let i = 2; i \u003c s.length; i += 2) total += Math.hypot((s[i] - s[i - 2]) * sx, (s[i + 1] - s[i - 1]) * sy);\n  let left = u * total;\n  for (const s of L.g)\n    for (let i = 2; i \u003c s.length; i += 2) {\n      const ax = b[0] + s[i - 2] * sx, ay = b[1] + s[i - 1] * sy;\n      let bx = b[0] + s[i] * sx, by = b[1] + s[i + 1] * sy;\n      const len = Math.hypot(bx - ax, by - ay);\n      if (u \u003c 1) {\n        if (left \u003c= 0) return;\n        if (left \u003c len) {\n          const f = left / len;\n          bx = ax + (bx - ax) * f;\n          by = ay + (by - ay) * f;\n        }\n        left -= len;\n      }\n      const vert = len > 0 ? abs(by - ay) / len : 0;\n      seg(S, ax, ay, bx, by, w * (1 + m * (0.3 + 0.4 * vert * vert)), c);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.words.length) return;\n  const { cov, id, pal } = S, t = S.t, w = S.wt;\n  cov.fill(0);\n  const pad = w * 0.7 + 1;\n  let grid = 0;\n  for (const word of S.words)\n    for (const L of word) {\n      const { j, k } = L;\n      // Written stroke by stroke in the line, letter after letter.\n      const wu = cl((t - j * 0.18 - k * 0.1) / 0.4, 0, 1);\n      // Then each letter glides into its box, one after another.\n      const gu = ease((t - WRITE - LINE - k * 0.3 - j * 0.2) / 1.3);\n      grid = max(grid, gu);\n      const q = L.sq, a = L.line;\n      const sb = [q[0] + pad, q[1] + pad, q[2] - pad, q[3] - pad];\n      const b = [0, 1, 2, 3].map((i) => a[i] + (sb[i] - a[i]) * gu);\n      letter(S, L, b, gu, wu, 1 + k * 6 + j);\n    }\n  const fade = 1 - cl((t - (CYCLE - FADE)) / FADE, 0, 1);\n  for (let k = 0; k \u003c 2; k++)\n    for (let j = 0; j \u003c 6; j++) hsv(HUE0 + S.hue + k * 0.5 + j * 0.07, 0.9, fade, pal[1 + k * 6 + j]);\n  const gc = hsv(HUE0 + S.hue + 0.75, 0.6, 1, [0, 0, 0]);\n  const gl = grid * fade;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = (p - x) / W, c = cov[p];\n    let r = 0, g = 0, bl = 0;\n    if (c > 0) {\n      const col = pal[id[p]];\n      r = col[0] * c;\n      g = col[1] * c;\n      bl = col[2] * c;\n    }\n    const gv = GRID[p] ? (GRID[p] === 2 ? 0.22 : 0.16) * gl * (1 - c) : 0;\n    display.setPixel(x, y, round(r + gc[0] * gv), round(g + gc[1] * gv), round(bl + gc[2] * gv));\n  }\n}\n","teletext":"// ===== Patternflow pattern =====\n// Title:   Teletext\n// Family:  type\n// Idea:    A sixteen-column teletext page decoded byte by byte the way the Mullard SAA5050 drew one, letters and 2 by 3 mosaics in seven colours where every colour change spends a cell as a space, rolls its header through the magazine until page 100 comes round, then flips through a carousel of three subpages, diagonal mosaic stripes over an index, double-height block numerals and a ringed disc, each written in from the top as it arrives.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: teletext as the BBC's Ceefax (from 1974) and ITV's ORACLE broadcast it, the Level 1 page of World System Teletext with its spacing attributes and 2 by 3 mosaic characters as the Mullard SAA5050 character generator drew them, and the four coloured prompts of Fastext; a 3 by 5 font drawn for this pattern; pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Page=1..5, Speed=0.2..3, Size=0..1, Reception=0..1\n//\n// Knob 1: Page. The page asked for: 100 at 1, then 200, 300, 400 and 500. Turning it sends the decoder looking again: the old page stays up while the header rolls through the magazine to the new number.\n// Knob 2: Speed. Pages going past a second, 20 for each unit: 40 at the opening 2, so the magazine of 100 pages comes round every 2.5 s and brings the next subpage; 4 a second at 0.2, where page 100 takes 12 s to come, and 60 at 3.\n// Knob 3: Size. The decoder's size key: below 1/3 the whole page, then the top half at double height, and from 2/3 the bottom half.\n// Knob 4: Reception. The share of bytes hit by noise, 0.45 times the square of the knob: 0.16% at the opening 0.06, 2.8% at 0.25, 11% at 0.5, 45% at 1. A hit flips one to three of a byte's eight bits. An odd number fails the parity check and the byte is dropped, leaving a space; two get through as a wrong character, and when that is a spacing attribute the rest of its row changes colour, size or mode.\n// Buttons: K1 tap is the reveal key: concealed text on the page shows, or hides again.\n\n// A page here is 16 columns by 21 rows of 4 by 6 LED cells, one byte a\n// cell; the SAA5050 drew 40 by 24 cells of 6 by 10 dots. Bytes 0x20 to\n// 0x7f are characters. Bytes below 0x20 are spacing attributes: each\n// changes the colour, the mode or the size for the rest of its row and is\n// itself shown as a space in the background colour. That is where teletext\n// art gets its gaps: two mosaics of different colours side by side always\n// have a cell between them. A row starts as white letters on black. 0x01\n// to 0x07 switch to letters and 0x11 to 0x17 to mosaics in red, green,\n// yellow, blue, magenta, cyan and white. In mosaic mode a byte with 0x20 set\n// is a 2 by 3 block of sixels, one bit each (0x01 top left, 0x02 top right,\n// 0x04 and 0x08 the middle, 0x10 and 0x40 the bottom), drawn here as 2 by 2\n// LEDs, or one LED with a gap left and below once 0x1a (separated) has\n// been sent. 0x1d makes the foreground colour the background and 0x1c goes\n// back to black. 0x0d makes the rest of the row double height, and the row\n// under it then shows the lower halves. 0x1e (hold) shows the last mosaic\n// again in place of the space an attribute leaves. Background, hold,\n// separated, contiguous, conceal, steady and normal size act in their own\n// cell; the colours, flash, double height and release from the next cell.\n//\n// Every byte goes out with an odd parity bit. Noise that flips an odd\n// number of the eight bits is caught and the byte dropped; an even number\n// gets through as another character, which is how a weak signal used to\n// turn the rest of a row green or into graphics. The magazine goes round\n// for ever, and the decoder's header shows each page number as it passes\n// until the one asked for comes; each time it comes again it brings the\n// next subpage.\n\nconst W = 64, H = 128, COLS = 16, ROWS = 21, CW = 4, CH = 6, Y0 = 1, N = ROWS * COLS;\nconst { floor, min, round, sin, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Attribute bytes: A(c) letters and G(c) mosaics in colour c.\nconst A = (c) => c, G = (c) => 0x10 + c;\nconst FLASH = 0x08, STEADY = 0x09, NORMAL = 0x0c, DOUBLE = 0x0d, CONCEAL = 0x18;\nconst CONTIG = 0x19, SEP = 0x1a, BLACKBG = 0x1c, NEWBG = 0x1d, HOLD = 0x1e, RELEASE = 0x1f;\nconst RED = 1, GREEN = 2, YELLOW = 3, BLUE = 4, MAGENTA = 5, CYAN = 6, WHITE = 7;\n\n// 3 by 5 letters for 0x20 to 0x7f in the English set (0x23 is a pound sign,\n// 0x5b to 0x5e arrows and a half, 0x5f #, 0x7b to 0x7e quarters, a double\n// bar and a division sign, 0x7f a block). Each digit is a row, top first,\n// 4 the left LED and 1 the right; lower case has a sixth row for descenders.\nconst FONT = (\n  \"0 22202 55 34647 36236 51245 25253 22 12221 42224 0525 0272 00024 007 00002 11244 \" +\n  \"75557 26227 71747 71317 55711 74717 74757 71222 75757 75717 0202 02024 12421 0707 42124 71202 \" +\n  \"25743 25755 65656 34443 65556 74647 74644 34553 55755 72227 11152 55655 44447 57755 65555 25552 \" +\n  \"65644 25563 65655 34216 72222 55557 55552 55775 55255 55222 71247 24742 45123 21712 27222 57575 \" +\n  \"007 00357 44656 00343 11353 02563 12722 035316 44655 20222 101152 44565 62227 00775 00655 00252 \" +\n  \"065644 035311 00344 00326 22723 00553 00552 00577 00525 055316 00623 44131 55555 66131 20702 77777\"\n)\n  .split(\" \")\n  .map((s) => [0, 1, 2, 3, 4, 5].map((i) => +(s[i] || 0)));\n\n// ---- Building pages -------------------------------------------------------\n\nconst blank = () => new Uint8Array(N).fill(0x20);\n\n// Bytes and strings into row r from column c.\nfunction put(p, r, c, ...items) {\n  for (const it of items) {\n    if (typeof it === \"number\") p[r * COLS + c++] = it;\n    else for (const ch of it) p[r * COLS + c++] = ch.charCodeAt(0);\n  }\n}\n\n// The mosaic byte for six sixels in reading order.\nconst MOS = [0x01, 0x02, 0x04, 0x08, 0x10, 0x40];\nfunction mosaic(bits) {\n  let b = 0x20;\n  for (let i = 0; i \u003c 6; i++) if (bits & (1 \u003c\u003c i)) b |= MOS[i];\n  return b;\n}\n\n// Paint a picture f(sx, sy) -> colour (0 for none), in sixels, into rows\n// r0..r1 and columns c0..c1 the way a teletext artist had to: one colour to\n// a cell and a cell for every change of colour. An empty cell before a new\n// colour takes the attribute for nothing; a lit one is lost to it, and\n// that is the gap. `pre` gives bytes to start each row with.\nfunction paint(p, r0, r1, c0, c1, f, pre) {\n  for (let r = r0; r \u003c= r1; r++) {\n    let c = c0, fg = -1;\n    for (const b of pre ? pre(r) : []) {\n      p[r * COLS + c++] = b;\n      if (b > 0x10 && b \u003c 0x18) fg = b - 0x10;\n    }\n    const want = [], bits = [];\n    for (let k = c; k \u003c= c1; k++) {\n      const n = [0, 0, 0, 0, 0, 0, 0, 0], sc = [];\n      for (let i = 0; i \u003c 6; i++) sc.push(f(2 * k + (i & 1), 3 * r + (i >> 1)));\n      for (const v of sc) n[v]++;\n      let best = 0;\n      for (let v = 1; v \u003c 8; v++) if (n[v] && (!best || n[v] > n[best])) best = v;\n      let b = 0;\n      sc.forEach((v, i) => (b |= best && v === best ? 1 \u003c\u003c i : 0));\n      want.push(best);\n      bits.push(b);\n    }\n    for (let k = c; k \u003c= c1; k++) {\n      const i = k - c, w = want[i], nx = want[i + 1] || 0;\n      if (w && w !== fg) (p[r * COLS + k] = G(w)), (fg = w);\n      else if (!w && nx && nx !== fg) (p[r * COLS + k] = G(nx)), (fg = nx);\n      else p[r * COLS + k] = mosaic(w ? bits[i] : 0);\n    }\n  }\n}\n\n// Big numerals: the 3 by 5 font with every dot sw by sh sixels, from\n// sixel (x0, y0), a digit every `pitch` sixels, each in its own colour.\nfunction bigDigits(s, x0, y0, sw, sh, pitch, colours) {\n  return (sx, sy) => {\n    const d = floor((sx - x0) / pitch), cx = floor((sx - x0 - d * pitch) / sw), cy = floor((sy - y0) / sh);\n    if (sx \u003c x0 || cy \u003c 0 || cy > 4 || d >= s.length || cx > 2) return 0;\n    return (FONT[s.charCodeAt(d) - 32][cy] >> (2 - cx)) & 1 ? colours[d % colours.length] : 0;\n  };\n}\n\n// The title band: a background across the row and a double-height word.\nfunction title(p, bg, fg, word, sub) {\n  put(p, 1, 0, A(bg), NEWBG, A(fg), DOUBLE, word);\n  put(p, 1, 11, NORMAL, A(WHITE), sub);\n}\n\n// Fastext prompts along the bottom: the four other pages in red, green,\n// yellow and cyan.\nfunction prompts(p, page) {\n  let c = 0, k = 0;\n  for (let q = 1; q \u003c= 5; q++) if (q !== page) put(p, 20, (c += 4) - 4, A([RED, GREEN, YELLOW, CYAN][k++]), q + \"00\");\n}\n\n// ---- The pages ------------------------------------------------------------\n// Each page is its subpages in the order the magazine sends them.\n\nconst PAGES = [\n  [\n    // 100, 1/3: stripes over an index of the other pages.\n    (p) => {\n      title(p, BLUE, YELLOW, \"LIGHT\", \"1/3\");\n      paint(p, 3, 10, 0, 15, (x, y) => ((x + y) % 8 \u003c 6 ? [MAGENTA, GREEN, WHITE, YELLOW][floor((x + y) / 8) % 4] : 0));\n      [\"WAVE\", \"COLOUR\", \"NUMBER\", \"SHAPE\"].forEach((w, i) => put(p, 12 + 2 * i, 0, A(YELLOW), w, A(CYAN)));\n      for (let i = 0; i \u003c 4; i++) put(p, 12 + 2 * i, 13, i + 2 + \"01\");\n      prompts(p, 1);\n    },\n    // 2/3: the round in double-height block numerals.\n    (p) => {\n      title(p, MAGENTA, WHITE, \"P100\", \"2/3\");\n      put(p, 4, 0, A(WHITE), \"PATTERN ROUND\");\n      for (let r = 10; r \u003c= 18; r += 2) paint(p, r, r, 0, 15, bigDigits(\"78\", 6, 30, 4, 6, 14, [MAGENTA, GREEN]), () => [DOUBLE]);\n      prompts(p, 1);\n    },\n    // 3/3: a ringed disc and a question with its answer concealed.\n    (p) => {\n      title(p, GREEN, BLUE, \"SHAPE\", \"3/3\");\n      put(p, 4, 0, A(WHITE), \"WHAT COLOUR?\");\n      paint(p, 6, 16, 0, 15, (x, y) => {\n        const d = (x - 16) * (x - 16) + (y - 34) * (y - 34);\n        return d \u003c 144 ? (d \u003c 49 ? YELLOW : RED) : 0;\n      });\n      put(p, 18, 0, A(CYAN), \"ANSWER\", A(RED), CONCEAL, \"RED\");\n      prompts(p, 1);\n    },\n  ],\n  [\n    // 200: three waves, then a field of separated dots.\n    (p) => {\n      title(p, CYAN, RED, \"WAVE\", \"1/2\");\n      paint(p, 4, 19, 0, 15, (x, y) => {\n        for (let i = 0; i \u003c 3; i++) if (Math.abs(y - 20 - 14 * i - 6 * sin(x / 4 + i)) \u003c 2.6) return [YELLOW, MAGENTA, GREEN][i];\n        return 0;\n      });\n      prompts(p, 2);\n    },\n    (p) => {\n      title(p, RED, CYAN, \"WAVE\", \"2/2\");\n      paint(p, 3, 19, 0, 15, (x, y) => ((x + floor(y / 6) * 3) % 8 \u003c 3 ? (y \u003c 34 ? CYAN : YELLOW) : 0), () => [SEP]);\n      prompts(p, 2);\n    },\n  ],\n  [\n    // 300: colour bars, then each colour behind its opposite, the bands\n    // that hold graphics run on without a gap where the hatch turns white.\n    (p) => {\n      title(p, BLUE, WHITE, \"COLOUR\", \"1/2\");\n      for (let r = 3; r \u003c 19; r++) {\n        [WHITE, YELLOW, CYAN, GREEN, MAGENTA, RED, BLUE].forEach((k, i) => put(p, r, 2 * i, A(k), NEWBG));\n        put(p, r, 14, BLACKBG);\n      }\n      prompts(p, 3);\n    },\n    (p) => {\n      title(p, YELLOW, BLUE, \"COLOUR\", \"2/2\");\n      [RED, GREEN, YELLOW, CYAN, BLUE, MAGENTA].forEach((k, i) => {\n        for (let r = 3 + 2 * i; r \u003c 5 + 2 * i; r++) {\n          const pre = i & 1 ? [G(k), NEWBG, HOLD] : [G(k), NEWBG];\n          paint(p, r, r, 0, 15, (x, y) => ((x + y) % 4 \u003c 2 ? (x \u003c 18 ? 7 - k : WHITE) : 0), () => pre);\n        }\n      });\n      prompts(p, 3);\n    },\n  ],\n  [\n    // 400: numerals, one a subpage, the second in separated mosaics.\n    (p) => {\n      title(p, RED, YELLOW, \"NUMBER\", \"1/3\");\n      paint(p, 4, 18, 0, 15, bigDigits(\"1\", 10, 12, 4, 9, 14, [YELLOW]));\n      prompts(p, 4);\n    },\n    (p) => {\n      title(p, RED, YELLOW, \"NUMBER\", \"2/3\");\n      paint(p, 4, 18, 0, 15, bigDigits(\"2\", 10, 12, 4, 9, 14, [CYAN]), () => [SEP]);\n      prompts(p, 4);\n    },\n    (p) => {\n      title(p, RED, YELLOW, \"NUMBER\", \"3/3\");\n      paint(p, 4, 18, 0, 15, bigDigits(\"3\", 10, 12, 4, 9, 14, [MAGENTA]));\n      prompts(p, 4);\n    },\n  ],\n  [\n    // 500: a triangle on a block, then rings.\n    (p) => {\n      title(p, MAGENTA, GREEN, \"SHAPE\", \"1/2\");\n      paint(p, 3, 19, 0, 15, (x, y) => (y - 9 > Math.abs(x - 16) * 1.6 && y \u003c 60 ? (y \u003c 34 ? CYAN : RED) : 0));\n      prompts(p, 5);\n    },\n    (p) => {\n      title(p, BLUE, CYAN, \"SHAPE\", \"2/2\");\n      paint(p, 3, 19, 0, 15, (x, y) => {\n        const d = hypot(x - 16, y - 34);\n        return floor(d / 3) % 2 === 0 && d \u003c 16 ? [YELLOW, MAGENTA, YELLOW, GREEN, WHITE, BLUE][floor(d / 3)] : 0;\n      });\n      prompts(p, 5);\n    },\n  ],\n].map((subs) =>\n  subs.map((make) => {\n    const p = blank();\n    make(p);\n    return p;\n  }),\n);\n\nconst NAME = \"PATTERN\";\n// The magazine was at its page 52 when the set was switched on.\nconst START = 52;\n\n// ---- Reception ------------------------------------------------------------\n\n// A byte with its odd parity bit as bit 7.\nfunction parity(b) {\n  let n = 0;\n  for (let i = 0; i \u003c 7; i++) n += (b >> i) & 1;\n  return n & 1 ? b : b | 0x80;\n}\n\n// One byte through the noise; -1 when the parity check catches it.\nfunction receive(b, q) {\n  if (q \u003c= 0 || Math.random() >= q) return b;\n  const u = Math.random(), n = u \u003c 0.5 ? 1 : u \u003c 0.85 ? 2 : 3;\n  let v = parity(b), used = 0;\n  for (let k = 0; k \u003c n; ) {\n    const bit = 1 \u003c\u003c floor(Math.random() * 8);\n    if (!(used & bit)) (used |= bit), (v ^= bit), k++;\n  }\n  return n & 1 ? -1 : v & 0x7f;\n}\n\n// ---- State ----------------------------------------------------------------\n\nexport function setup(params) {\n  params.s = {\n    want: -1, pos: 0, found: false, cycles: 0, wr: ROWS, mem: blank(), head: new Uint8Array(COLS).fill(0x20),\n    size: 0, q: 0, speed: 2, reveal: false, flash: 0, dblRow: false, code: new Uint8Array(W * H),\n  };\n}\n\n// A header going past: the page asked for, the page passing, the service.\nfunction header(S, n) {\n  const h = S.head;\n  put(h, 0, 0, \"P\" + (S.want + 1) + \"00\", A(GREEN), S.want + 1 + String(n).padStart(2, \"0\"), A(YELLOW));\n  for (let i = 0; i \u003c NAME.length; i++) {\n    const b = receive(NAME.charCodeAt(i), S.q);\n    if (b >= 0) h[9 + i] = b;\n  }\n}\n\n// The page asked for comes round: the decoder clears its page and writes\n// the subpage in, each byte through the noise.\nfunction arrive(S) {\n  const subs = PAGES[S.want], src = subs[S.cycles % subs.length], m = S.mem;\n  for (let i = COLS; i \u003c N; i++) {\n    const b = receive(src[i], S.q);\n    m[i] = b \u003c 0 ? 0x20 : b;\n  }\n  S.wr = 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [1, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const page = cl(round(k[0] == null ? 1 : k[0]), 1, 5) - 1;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const z = cl(k[2] || 0, 0, 1);\n  S.size = z \u003c 1 / 3 ? 0 : z \u003c 2 / 3 ? 1 : 2;\n  const rx = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.q = 0.45 * rx * rx;\n  if (input.btnPressed && input.btnPressed[0]) S.reveal = !S.reveal;\n  if (page !== S.want) {\n    S.want = page;\n    S.found = false;\n    header(S, START);\n  }\n  S.flash += d;\n  const before = floor(S.pos);\n  S.pos += d * S.speed * 20;\n  for (let i = before + 1; i \u003c= floor(S.pos); i++) {\n    const n = (START + i) % 100;\n    if (n === 0) {\n      // The page address is Hamming coded, so only a heavier hit loses it.\n      if (Math.random() >= S.q * S.q) {\n        S.found = true;\n        header(S, n);\n        arrive(S);\n      }\n      S.cycles++;\n    } else if (!S.found) header(S, n);\n  }\n  // The rows come in over 8 page slots, top first.\n  if (S.wr \u003c ROWS) S.wr = min(ROWS, S.wr + d * S.speed * 20 * (ROWS / 8));\n}\n\n// ---- Drawing --------------------------------------------------------------\n\n// One cell: mode 0 a space, 1 a mosaic, 2 a letter; half 1 is the lower\n// half of a double-height cell.\nfunction cell(code, x0, y0, fg, bg, b, mode, sep, dbl, half) {\n  for (let yy = 0; yy \u003c CH; yy++) {\n    const y = y0 + yy, gy = dbl ? (yy + half * CH) >> 1 : yy;\n    for (let xx = 0; xx \u003c CW; xx++) {\n      let on = false;\n      if (mode === 1) {\n        on = (b & MOS[(gy >> 1) * 2 + (xx >> 1)]) !== 0;\n        if (on && sep) on = (xx & 1) === 1 && (dbl ? (yy + half * CH) % 4 !== 3 : (gy & 1) === 0);\n      } else if (mode === 2 && xx \u003c 3) on = ((FONT[b - 32][gy] >> (2 - xx)) & 1) === 1;\n      code[y * W + x0 + xx] = on ? fg : bg;\n    }\n  }\n}\n\n// Decode one row of bytes and draw it; true when it went double height.\nfunction row(S, bytes, r, code) {\n  let fg = WHITE, bg = 0, gfx = false, sep = false, hold = false, held = 0x20, heldSep = false;\n  let dbl = false, conceal = false, flash = false, any = false;\n  const y0 = Y0 + r * CH, lit = S.flash % 1 \u003c 0.75, last = r === 0 || r === ROWS - 1;\n  const show = (c, mode, b, s) => {\n    const m = (conceal && !S.reveal) || (flash && !lit) || b === 0x20 ? 0 : mode;\n    cell(code, c * CW, y0, fg, bg, b, m, s, dbl, 0);\n    if (dbl) cell(code, c * CW, y0 + CH, fg, bg, b, m, s, true, 1);\n    else if (S.dblRow) cell(code, c * CW, y0 + CH, fg, bg, b, 0, false, false, 0);\n  };\n  for (let c = 0; c \u003c COLS; c++) {\n    const b = bytes[c] & 0x7f;\n    if (b >= 0x20) {\n      if (gfx && b & 0x20) {\n        held = b;\n        heldSep = sep;\n        show(c, 1, b, sep);\n      } else show(c, 2, b, false);\n      continue;\n    }\n    // Set-at: these act in this cell.\n    if (b === STEADY) flash = false;\n    else if (b === NORMAL) {\n      if (dbl) held = 0x20;\n      dbl = false;\n    } else if (b === CONCEAL) conceal = true;\n    else if (b === CONTIG) sep = false;\n    else if (b === SEP) sep = true;\n    else if (b === BLACKBG) bg = 0;\n    else if (b === NEWBG) bg = fg;\n    else if (b === HOLD) hold = true;\n    if (hold && gfx) show(c, 1, held, heldSep);\n    else show(c, 0, 0x20, false);\n    // Set-after: these act from the next cell.\n    if (b >= 1 && b \u003c= 7) {\n      if (gfx) held = 0x20;\n      (gfx = false), (fg = b), (conceal = false);\n    } else if (b >= 0x11 && b \u003c= 0x17) {\n      if (!gfx) held = 0x20;\n      (gfx = true), (fg = b - 0x10), (conceal = false);\n    } else if (b === FLASH) flash = true;\n    else if (b === DOUBLE && !last) {\n      if (!dbl) held = 0x20;\n      dbl = any = true;\n    } else if (b === RELEASE) hold = false;\n  }\n  return any;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const code = S.code;\n  code.fill(0);\n  S.dblRow = false;\n  row(S, S.head, 0, code);\n  for (let r = 1; r \u003c S.wr && r \u003c ROWS; r++) {\n    const bytes = S.mem.subarray(r * COLS, r * COLS + COLS);\n    // A row with double height in it covers the row under it as well.\n    S.dblRow = r \u003c ROWS - 1 && bytes.some((b) => (b & 0x7f) === DOUBLE);\n    if (row(S, bytes, r, code)) r++;\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const sy = S.size === 0 ? y : S.size === 1 ? y >> 1 : 64 + (y >> 1);\n    for (let x = 0; x \u003c W; x++) {\n      const v = code[sy * W + x];\n      display.setPixel(x, y, v & 1 ? 255 : 0, v & 2 ? 255 : 0, v & 4 ? 255 : 0);\n    }\n  }\n}\n","three-disk-scattering":"// ===== Patternflow pattern =====\n// Title:   Three-Disk Scattering\n// Family:  fractal\n// Idea:    Three hard discs stand in the top half with a few points bouncing between them and leaving through the three gaps, and the bottom half maps every start from the top disc, one LED each, coloured by the gap it leaves through and lit by its bounces, zooming slowly towards a start on an orbit that bounces for ever, so the bands between colours split into thinner bands again and again while the points launched from that LED run round the orbit longer the deeper the zoom goes.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: chaotic scattering off three discs (Bruno Eckhardt, Fractal properties of scattering singularities, 1987; Pierre Gaspard and Stuart Rice, Scattering from a classically chaotic repellor, 1989), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gap=0.4..4, Bounces=3..12\n//\n// Knob 1: Hue. Turns the three exit colours round the wheel together, a third apart. At 0 the gap at the bottom is gold, the one to the upper right teal and the one to the upper left violet; at 1/3 each colour moves on one gap. Starts still bouncing after 40 bounces are white.\n// Knob 2: Speed. At 2 the zoom takes 20.4 s to go 4 decades deep and holds there, then fades back to the whole map and the next trapped start, 24 s in all, and the points fly 40 LEDs a second. At 0.2 it all runs ten times slower, at 3 one and a half times faster.\n// Knob 3: Gap. The gap between neighbouring discs in disc radii, 0.4 to 4 in steps of 0.05, so the centres stand R = 2.4a to 6a apart. At 0.4 the discs nearly touch, most starts bounce several times and the map is mostly thin bands; at 4 most starts leave at once or after one bounce and the bands narrow to a few strips across broad fields.\n// Knob 4: Bounces. How many bounces beyond the fewest on the map a start needs to reach full brightness, 3 at the opening up to 12. At 3 a start that bounced three times more than the quickest is at full brightness and one that bounced once more at two thirds; at 12 only the bands next to the trapped curves are bright, and the fields that leave at once stay at 42%.\n\n// A point moves in straight lines and bounces off three hard discs of\n// radius a whose centres stand R apart at the corners of a triangle. For\n// R > 2a almost every start leaves through one of the three gaps, but a\n// Cantor set of starts bounces for ever: the repeller of this open\n// billiard. Eckhardt coded it by the order in which the discs are hit\n// and found its dimension (1987); Gaspard and Rice took it as a model of\n// a molecule breaking apart and computed its escape rate, dimension,\n// entropy and Lyapunov exponent (1989).\n//\n// The bottom half maps the starts on disc 0, the top disc, in Birkhoff's\n// coordinates, in which the billiard keeps area: s across, the angle\n// round the disc from the point nearest the middle, -108 to 108 degrees,\n// and p down, the sine of the angle between the ray and the disc's\n// normal, -1 to 1. Each LED traces its ray up to 40 bounces and takes\n// the colour of the gap its last direction faces and a brightness from\n// its bounces. The starts that never leave lie on curves; beside each\n// curve lie bands that leave after more and more bounces, and inside\n// each band the same again. The zoom heads 4 decades deep towards a\n// start on a periodic orbit: the triangle orbit through the three points\n// nearest the middle (s = 0, p = 1/2 or -1/2), or the to and fro between\n// disc 0 and one of the others (s = 30 or -30 degrees, p = 0). Near the\n// to and fro the bands repeat each time the zoom gains the orbit's\n// stretch per bounce, (g + 1) + sqrt((g + 1)^2 - 1) for a gap of g\n// radii: 2.38 at the opening gap of 0.4, 9.9 at R = 6a, the ratio most\n// papers on the three discs use.\n//\n// The map is rebuilt at the current zoom a few rows a frame, as many as\n// 6000 bounces of work allow, and shown resampled from the last finished\n// one meanwhile. The points in the top half start from the LED the zoom\n// heads to, at a random spot inside it, so the deeper the zoom the longer\n// they run round the orbit before they leave.\n\nconst W = 64, H = 128, MY = 64, MS = 64, MAXB = 40, BUDGET = 6000, DEPTH = 4, ZOOM = 20.4, REST = 3.6, SM = 0.6 * Math.PI;\n// Trapped starts on disc 0: the orbit round the triangle both ways, and\n// the orbit to and fro between disc 0 and each of the others.\nconst TG = [[0, 0.5], [Math.PI / 6, 0], [0, -0.5], [-Math.PI / 6, 0]];\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst HUE0 = 0.14;\n\nfunction hsv(h, s, v, o, i0) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[i0] = round((i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255);\n  o[i0 + 1] = round((i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255);\n  o[i0 + 2] = round((i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255);\n}\n\n// Disc k sits at angle 90 + 120 k degrees, d = R / sqrt 3 from the middle;\n// exit k is the gap opposite disc k, which faces the direction U_k.\nfunction geometry(S, gap) {\n  const R = gap + 2, d = R / sqrt(3);\n  S.gap = gap;\n  S.d = d;\n  S.C = [];\n  S.U = [];\n  for (let k = 0; k \u003c 3; k++) {\n    const a = PI / 2 + (k * TAU) / 3;\n    S.C.push(d * cos(a), d * sin(a));\n    S.U.push(-cos(a), -sin(a));\n  }\n  // The billiard half frames the three discs: 62 LEDs across them.\n  S.scale = 62 / (sqrt(3) * d + 2);\n  S.oy = 32 + (d / 4) * S.scale;\n}\n\n// Where a ray leaving disc 0 goes: exit * 64 + bounces, or 3 * 64 + MAXB\n// if it is still bouncing after MAXB. A ray that hits no disc has left,\n// through the gap whose direction is nearest its own.\nfunction trace(S, px, py, vx, vy) {\n  const C = S.C, U = S.U;\n  let last = 0;\n  for (let n = 0; n \u003c MAXB; n++) {\n    let tb = 1e9, kb = -1;\n    for (let k = 0; k \u003c 3; k++) {\n      if (k === last) continue;\n      const ox = px - C[2 * k], oy = py - C[2 * k + 1], b = ox * vx + oy * vy;\n      if (b >= 0) continue;\n      const disc = b * b - (ox * ox + oy * oy - 1);\n      if (disc \u003c= 0) continue;\n      const t = -b - sqrt(disc);\n      if (t \u003c tb) {\n        tb = t;\n        kb = k;\n      }\n    }\n    if (kb \u003c 0) {\n      const e0 = U[0] * vx + U[1] * vy, e1 = U[2] * vx + U[3] * vy, e2 = U[4] * vx + U[5] * vy;\n      return (e0 >= e1 && e0 >= e2 ? 0 : e1 >= e2 ? 1 : 2) * 64 + n;\n    }\n    px += vx * tb;\n    py += vy * tb;\n    const nx = px - C[2 * kb], ny = py - C[2 * kb + 1], dn = 2 * (vx * nx + vy * ny);\n    vx -= dn * nx;\n    vy -= dn * ny;\n    last = kb;\n  }\n  return 3 * 64 + MAXB;\n}\n\n// A start (s, p) on disc 0: s the angle round the disc from the point\n// nearest the middle, counterclockwise, p the sine of the angle between\n// the ray and the disc's outward normal there.\nfunction ray(S, s, p, o) {\n  const a = -PI / 2 + s, nx = cos(a), ny = sin(a), c = sqrt(max(0, 1 - p * p));\n  o[0] = S.C[0] + nx;\n  o[1] = S.C[1] + ny;\n  o[2] = nx * c - ny * p;\n  o[3] = nx * p + ny * c;\n  return o;\n}\nconst RAY = [0, 0, 0, 0];\nconst start = (S, s, p) => {\n  const r = ray(S, s, p, RAY);\n  return trace(S, r[0], r[1], r[2], r[3]);\n};\n\nfunction newMap() {\n  return { v: new Uint8Array(MS * MS), view: [0, 0, 1, 1], row: 0, nmin: 0 };\n}\n\nfunction computeRow(S, M, j) {\n  const [cb, cp, hb, hp] = M.view, ph = cp + hp * ((j + 0.5) / (MS / 2) - 1);\n  let cost = 0;\n  for (let i = 0; i \u003c MS; i++) {\n    const r = start(S, cb + hb * ((i + 0.5) / (MS / 2) - 1), ph);\n    M.v[j * MS + i] = r;\n    cost += (r & 63) + 1;\n  }\n  return cost;\n}\n\nfunction finish(M) {\n  let n = MAXB;\n  for (let i = 0; i \u003c M.v.length; i++) n = min(n, M.v[i] & 63);\n  M.nmin = n;\n}\n\nfunction view(S) {\n  const z = Math.pow(10, -S.z), [tb, tp] = TG[S.ti % TG.length];\n  return [tb * (1 - z), tp * (1 - z), SM * z, z];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 1, gap: -1, bref: 3, z: 0, zt: 0, ti: 0, fade: 0,\n    full: newMap(), shown: newMap(), build: newMap(), parts: [],\n    trail: new Float32Array(W * MY * 3), bg: new Float32Array(W * MY), gm: new Uint8Array(W * MY),\n    pal: new Uint8Array(4 * 64 * 3), gc: new Uint8Array(9),\n  };\n  for (let i = 0; i \u003c 4; i++) params.s.parts.push({ on: false, wait: 0.3 + i * 0.6 });\n  return params.s;\n}\n\n// The discs, with the arc of disc 0 the map starts from drawn brighter, a\n// dashed line across each gap and a mark where each exit leaves the frame,\n// drawn once per geometry. gm holds which exit a LED marks.\nfunction backdrop(S) {\n  const { bg, gm, C, scale, oy } = S;\n  bg.fill(0);\n  gm.fill(0);\n  for (let y = 0; y \u003c MY; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const wx = (x + 0.5 - 32) / scale, wy = (oy - y - 0.5) / scale, p = y * W + x;\n      for (let k = 0; k \u003c 3; k++) {\n        const dx = wx - C[2 * k], dy = wy - C[2 * k + 1], r = Math.hypot(dx, dy) * scale, e = 1 - abs(r - scale);\n        if (r \u003c scale) bg[p] = max(bg[p], 0.16);\n        // The arc |s| \u003c SM of disc 0, s measured from straight down.\n        const lit = k === 0 && abs(Math.atan2(dx, -dy)) \u003c SM ? 1 : 0.55;\n        if (e > 0) bg[p] = max(bg[p], lit * e);\n      }\n    }\n  for (let k = 0; k \u003c 3; k++) {\n    const i = (k + 1) % 3, j = (k + 2) % 3, ax = C[2 * i], ay = C[2 * i + 1], bx = C[2 * j], by = C[2 * j + 1];\n    const L = Math.hypot(bx - ax, by - ay), steps = floor(L * scale * 2);\n    for (let s = 0; s \u003c= steps; s++) {\n      const u = s / steps, along = u * L;\n      if (along \u003c 1.25 || along > L - 1.25) continue;\n      const x = floor(32 + (ax + (bx - ax) * u) * scale), y = floor(oy - (ay + (by - ay) * u) * scale);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c MY && floor((along * scale) / 2) % 2 === 0) gm[y * W + x] = k + 1;\n    }\n    // Out from the middle of the gap in its direction to the frame.\n    let x = 32 + ((ax + bx) / 2) * scale, y = oy - ((ay + by) / 2) * scale;\n    while (x >= 0 && x \u003c W && y >= 0 && y \u003c MY) {\n      x += S.U[2 * k] * 0.5;\n      y -= S.U[2 * k + 1] * 0.5;\n    }\n    // A bar 2 LEDs deep and 7 long along the edge it reaches.\n    const side = x \u003c 0 || x >= W;\n    x = cl(floor(x), 0, W - 1);\n    y = cl(floor(y), 0, MY - 1);\n    for (let a = -3; a \u003c= 3; a++)\n      for (let b = 0; b \u003c 2; b++) {\n        const tx = side ? (x === 0 ? b : W - 1 - b) : x + a, ty = side ? y + a : MY - 1 - b;\n        if (tx >= 0 && tx \u003c W && ty >= 0 && ty \u003c MY) gm[ty * W + tx] = 4 + k;\n      }\n  }\n}\n\nfunction launch(S, P) {\n  // From the LED of the map the zoom is heading to: a random start\n  // inside it.\n  const [cb, cp, hb, hp] = view(S), [tb, tp] = TG[S.ti % TG.length];\n  const fx = floor(((tb - cb) / hb + 1) * (MS / 2)), fy = floor(((tp - cp) / hp + 1) * (MS / 2));\n  const s = cb + hb * ((fx + Math.random()) / (MS / 2) - 1), p = cp + hp * ((fy + Math.random()) / (MS / 2) - 1);\n  const r = ray(S, s, p, RAY);\n  P.x = r[0];\n  P.y = r[1];\n  P.vx = r[2];\n  P.vy = r[3];\n  P.last = 0;\n  P.g = (start(S, s, p) >> 6) % 3;\n  P.on = true;\n}\n\n// Moves a point dist along its path, splatting each piece into the trail.\nfunction fly(S, P, dist) {\n  const C = S.C;\n  while (dist > 1e-9) {\n    let tb = dist, kb = -1;\n    for (let k = 0; k \u003c 3; k++) {\n      if (k === P.last) continue;\n      const ox = P.x - C[2 * k], oy = P.y - C[2 * k + 1], b = ox * P.vx + oy * P.vy;\n      if (b >= 0) continue;\n      const disc = b * b - (ox * ox + oy * oy - 1);\n      if (disc \u003c= 0) continue;\n      const t = -b - sqrt(disc);\n      if (t \u003c tb) {\n        tb = t;\n        kb = k;\n      }\n    }\n    const nx0 = P.x + P.vx * tb, ny0 = P.y + P.vy * tb;\n    line(S, P.x, P.y, nx0, ny0, P.g);\n    P.x = nx0;\n    P.y = ny0;\n    dist -= tb;\n    if (kb >= 0) {\n      const nx = P.x - C[2 * kb], ny = P.y - C[2 * kb + 1], dn = 2 * (P.vx * nx + P.vy * ny);\n      P.vx -= dn * nx;\n      P.vy -= dn * ny;\n      P.last = kb;\n    }\n  }\n}\n\nfunction line(S, ax, ay, bx, by, g) {\n  const sc = S.scale, oy = S.oy, x0 = 32 + ax * sc, y0 = oy - ay * sc, x1 = 32 + bx * sc, y1 = oy - by * sc;\n  const n = max(1, Math.ceil(Math.hypot(x1 - x0, y1 - y0) * 2));\n  for (let s = 1; s \u003c= n; s++) {\n    const x = x0 + ((x1 - x0) * s) / n - 0.5, y = y0 + ((y1 - y0) * s) / n - 0.5, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    for (const [dx, dy, w] of [[0, 0, (1 - fx) * (1 - fy)], [1, 0, fx * (1 - fy)], [0, 1, (1 - fx) * fy], [1, 1, fx * fy]]) {\n      const px = ix + dx, py = iy + dy;\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= MY) continue;\n      const p = (py * W + px) * 3 + g;\n      if (w > S.trail[p]) S.trail[p] = w;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.bref = cl(k[3] == null ? 3 : k[3], 3, 12);\n  const gap = round(cl(k[2] == null ? 0.4 : k[2], 0.4, 4) * 20) / 20;\n  if (gap !== S.gap) {\n    geometry(S, gap);\n    backdrop(S);\n    const F = S.full;\n    F.view = [0, 0, SM, 1];\n    for (let j = 0; j \u003c MS; j++) computeRow(S, F, j);\n    finish(F);\n    S.shown.v.set(F.v);\n    S.shown.view = F.view.slice();\n    S.shown.nmin = F.nmin;\n    S.build.row = 0;\n    S.build.view = view(S);\n    for (const P of S.parts) P.on = false;\n  }\n  // The zoom: DEPTH decades in towards a trapped start over ZOOM seconds,\n  // a hold, then a fade back to the whole map and the next trapped start.\n  S.zt += d * S.rate;\n  if (S.zt >= ZOOM + REST) {\n    S.zt -= ZOOM + REST;\n    S.ti++;\n  }\n  const u = cl(S.zt / ZOOM, 0, 1);\n  S.z = DEPTH * u * u * (3 - 2 * u);\n  S.fade = min(1, S.zt / 0.4, (ZOOM + REST - S.zt) / 0.6);\n  // Build the map at the current view a few rows a frame.\n  const B = S.build;\n  if (B.row === 0) B.view = view(S);\n  let cost = 0;\n  while (B.row \u003c MS && cost \u003c BUDGET) cost += computeRow(S, B, B.row++);\n  if (B.row >= MS) {\n    finish(B);\n    const t = S.shown;\n    S.shown = B;\n    S.build = t;\n    S.build.row = 0;\n  }\n  // The points.\n  const tr = S.trail, decay = exp(-d * S.rate * 1.6);\n  for (let i = 0; i \u003c tr.length; i++) tr[i] *= decay;\n  for (const P of S.parts) {\n    if (!P.on) {\n      P.wait -= d * S.rate;\n      if (P.wait \u003c= 0) launch(S, P);\n      continue;\n    }\n    fly(S, P, (d * S.rate * 40) / S.scale);\n    const qx = 32 + P.x * S.scale, qy = S.oy - P.y * S.scale;\n    if (qx \u003c -2 || qx > W + 2 || qy \u003c -2 || qy > MY + 2) {\n      P.on = false;\n      P.wait = 0.3 + Math.random() * 0.5;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.gap \u003c 0) return;\n  const { pal, gc, trail, bg, gm } = S;\n  for (let g = 0; g \u003c 3; g++) {\n    hsv(HUE0 + S.hue + g / 3, 1, 1, gc, g * 3);\n    for (let n = 0; n \u003c= MAXB; n++) {\n      const u = min(1, n / S.bref);\n      hsv(HUE0 + S.hue + g / 3, 0.92 - 0.3 * (n / MAXB), 0.42 + 0.58 * Math.pow(u, 0.8), pal, (g * 64 + n) * 3);\n    }\n  }\n  for (let n = 0; n \u003c= MAXB; n++) {\n    const q = (3 * 64 + n) * 3;\n    pal[q] = pal[q + 1] = pal[q + 2] = 255;\n  }\n  // The billiard.\n  for (let y = 0; y \u003c MY; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, b = bg[p] * 200;\n      let r = b, g = b, bl = b;\n      if (gm[p]) {\n        const c = ((gm[p] - 1) % 3) * 3, f = gm[p] > 3 ? 0.9 : 0.45;\n        r = max(r, gc[c] * f);\n        g = max(g, gc[c + 1] * f);\n        bl = max(bl, gc[c + 2] * f);\n      }\n      for (let k = 0; k \u003c 3; k++) {\n        const t = trail[p * 3 + k];\n        if (t > 0.02) {\n          r = max(r, gc[k * 3] * t);\n          g = max(g, gc[k * 3 + 1] * t);\n          bl = max(bl, gc[k * 3 + 2] * t);\n        }\n      }\n      display.setPixel(x, y, round(r), round(g), round(bl));\n    }\n  // The heads, white.\n  for (const P of S.parts) {\n    if (!P.on) continue;\n    const x = floor(32 + P.x * S.scale), y = floor(S.oy - P.y * S.scale);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c MY) display.setPixel(x, y, 255, 255, 255);\n  }\n  // The map, sampled from the last finished build at the current view.\n  const V = view(S), M = S.shown, F = S.full, [cb, cp, hb, hp] = M.view;\n  for (let j = 0; j \u003c MS; j++) {\n    const ph = V[1] + V[3] * ((j + 0.5) / (MS / 2) - 1);\n    for (let i = 0; i \u003c MS; i++) {\n      const b = V[0] + V[2] * ((i + 0.5) / (MS / 2) - 1);\n      const si = floor(((b - cb) / hb + 1) * (MS / 2)), sj = floor(((ph - cp) / hp + 1) * (MS / 2));\n      let v;\n      if (si >= 0 && si \u003c MS && sj >= 0 && sj \u003c MS) v = M.v[sj * MS + si];\n      else {\n        const fi = cl(floor((b / SM + 1) * (MS / 2)), 0, MS - 1), fj = cl(floor((ph + 1) * (MS / 2)), 0, MS - 1);\n        v = F.v[fj * MS + fi];\n      }\n      const g = v >> 6, n = g === 3 ? MAXB : max(0, (v & 63) - M.nmin), q = (g * 64 + n) * 3, f = S.fade;\n      display.setPixel(i, MY + j, round(pal[q] * f), round(pal[q + 1] * f), round(pal[q + 2] * f));\n    }\n  }\n  // Ticks round the LED the zoom is heading to.\n  const [tb, tp] = TG[S.ti % TG.length], tx = floor(((tb - V[0]) / V[2] + 1) * (MS / 2)), ty = MY + floor(((tp - V[1]) / V[3] + 1) * (MS / 2));\n  for (const [dx, dy] of [[-3, 0], [-4, 0], [3, 0], [4, 0], [0, -3], [0, -4], [0, 3], [0, 4]]) {\n    const x = tx + dx, y = ty + dy;\n    if (x >= 0 && x \u003c W && y >= MY && y \u003c H) display.setPixel(x, y, 255, 255, 255);\n  }\n}\n","word-bokeh":"// ===== Patternflow pattern =====\n// Title:   Word Bokeh\n// Family:  type\n// Idea:    Points of light at different depths seen through a lens whose aperture is cut in the shape of a word, so every light out of focus is drawn as the word, upright behind the plane of focus and turned 180 degrees in front of it, while the focus pulls slowly through the scene and each light shrinks to a point and swells into the word again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: bokeh (Japanese boke, blur; spelled with an h and brought into English by Mike Johnston's Photo Techniques, 1997), the thin-lens circle of confusion, the shaped aperture, pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Stop=1.4..2.8\n//\n// Knob 1: Hue. Turns the three colours of the lights round the wheel together. At 0 they are sky blue, magenta and golden yellow, and where words cross their light adds, to near white where all three do.\n// Knob 2: Speed. The focus pull. One cycle, near to far and back, takes 12 s at 2: the words stand upright, shrink to points, open out turned over 6 s later, and come back. 120 s at 0.2, 8 s at 3.\n// Knob 3: Word. The word cut in the aperture, a fifth of the knob each: BOKE, LUX, BLUR, GLOW, LENS.\n// Knob 4: Stop. The f-number. The blur goes as the aperture diameter, F/N, so it halves from f/1.4 to f/2.8: at the ends of the pull the largest word stands 14 LEDs tall at f/1.4 (BOKE is then 46 wide), 10 at f/2 and 7 at f/2.8.\n\n// Thin lens, focal length F, aperture diameter A = F/N, focused at depth f.\n// A point at depth d comes to focus in front of the sensor or behind it, and\n// the cone of light through the aperture cuts the sensor in a copy of the\n// aperture, the circle of confusion, of diameter about A F |1/d - 1/f|. The\n// sign matters. For a point behind the plane of focus (d > f) the rays meet\n// before the sensor and cross, so the copy on the sensor is turned 180\n// degrees, and the lens has already turned the whole picture 180 degrees: the\n// light is drawn upright, the word as it reads from behind the lens. For a\n// point in front of it (d \u003c f) the rays have not met yet and the light is\n// drawn turned 180 degrees. Every light here gets the signed scale\n// s = K (1/f - 1/d) / N, LEDs per cell of the word, and is drawn as the word\n// scaled by s about its own centre; a negative s turns it over by itself.\n// Each LED is lit by how much of its square the scaled word's ink covers,\n// read exactly from a summed-area table of the 5 by 7 letters, so a word 1.6\n// LEDs to the cell keeps clean strokes and a light in focus folds into one\n// LED.\n//\n// The 21 lights lie within 1/3 either side of the middle of the scene in\n// inverse depth (1/d), and the focus swings to 1 either side, so the ends of\n// the pull are beyond every light: at the near end every light is behind the\n// plane of focus and upright, at the far end every one is in front and\n// turned, and at f/1.4 each is a word 7 to 14 LEDs tall. The focus offset\n// goes as sin^2.3 of the phase, so it lingers in the middle, where it passes\n// the lights one by one while they are small and turns each over as it goes\n// by. Below 0.7 LEDs to the cell a light keeps all its power as its word\n// shrinks, so near focus the words burn out into short bright bars.\n\nconst W = 64, H = 128, N = W * H, CH = 7, NL = 21;\nconst { floor, min, max, abs, sin, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// 5 by 7 capitals, drawn for this pattern.\nconst FONT = {\n  B: \"####. #...# #...# ####. #...# #...# ####.\",\n  O: \".###. #...# #...# #...# #...# #...# .###.\",\n  K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\",\n  E: \"##### #.... #.... ####. #.... #.... #####\",\n  L: \"#.... #.... #.... #.... #.... #.... #####\",\n  U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  G: \".###. #...# #.... #.### #...# #...# .###.\",\n  W: \"#...# #...# #...# #.#.# #.#.# ##.## #...#\",\n  N: \"#...# ##..# #.#.# #..## #...# #...# #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\",\n};\nconst WORDS = [\"BOKE\", \"LUX\", \"BLUR\", \"GLOW\", \"LENS\"];\n\n// A word as an aperture: its width in cells, its ink area, and the table\n// F(i, j) = ink in cells [0, i) x [0, j), from which the ink in any\n// rectangle comes by bilinear reads, exactly.\nfunction aperture(word) {\n  const w = word.length * 6 - 1, F = new Float32Array((w + 1) * (CH + 1));\n  const ink = (i, j) => {\n    const c = floor(i / 6), q = i % 6;\n    return q \u003c 5 && FONT[word[c]].split(\" \")[j][q] === \"#\" ? 1 : 0;\n  };\n  for (let j = 1; j \u003c= CH; j++)\n    for (let i = 1; i \u003c= w; i++) F[j * (w + 1) + i] = ink(i - 1, j - 1) + F[(j - 1) * (w + 1) + i] + F[j * (w + 1) + i - 1] - F[(j - 1) * (w + 1) + i - 1];\n  return { w, F, area: F[CH * (w + 1) + w] };\n}\nconst APS = WORDS.map(aperture);\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\n// Inverse depths about the middle of the scene: the lights lie between\n// -SPREAD and +SPREAD, the focus swings between -PULL and +PULL.\nconst SPREAD = 1 / 3, PULL = 1, K = 1.5, SHAPE = 2.3, HUES = [0.53, 0.86, 0.13];\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, word: 0, stop: 1.4, ph: PI / 6,\n    x: new Float32Array(NL), y: new Float32Array(NL), z: new Float32Array(NL), g: new Float32Array(NL), c: new Uint8Array(NL),\n    buf: new Float32Array(N * 3), cu: new Float32Array(W + 1), cv: new Float32Array(H + 1), rgb: [0, 0, 0],\n  });\n  // Columns, rows and depths each spread evenly, then paired at random, so\n  // the words do not pile up in one place or one plane.\n  const shuffle = () => {\n    const a = [];\n    for (let i = 0; i \u003c NL; i++) a.splice(floor(Math.random() * (i + 1)), 0, i);\n    return a;\n  };\n  const cols = shuffle(), rows = shuffle();\n  for (let i = 0; i \u003c NL; i++) {\n    S.x[i] = 8 + ((W - 16) * (cols[i] + Math.random())) / NL;\n    S.y[i] = 5 + ((H - 10) * (rows[i] + Math.random())) / NL;\n    S.z[i] = -SPREAD + (2 * SPREAD * (i + Math.random())) / NL;\n    S.g[i] = 0.75 + 0.25 * Math.random();\n    S.c[i] = i % 3;\n  }\n  return S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.word = min(WORDS.length - 1, floor(cl(k[2] || 0, 0, 1) * WORDS.length));\n  S.stop = cl(k[3] == null ? 1.4 : k[3], 1.4, 2.8);\n  // 12 s a cycle at Speed 2.\n  S.ph += (d * S.speed * PI) / 12;\n}\n\n// Ink of the aperture in [0, u) x [0, v), u and v in cells.\nfunction inkTo(F, w, u, v) {\n  u = cl(u, 0, w);\n  v = cl(v, 0, CH);\n  const i = min(w - 1, floor(u)), j = min(CH - 1, floor(v)), a = u - i, b = v - j, r = w + 1;\n  const f00 = F[j * r + i], f10 = F[j * r + i + 1], f01 = F[(j + 1) * r + i], f11 = F[(j + 1) * r + i + 1];\n  return f00 + a * (f10 - f00) + b * (f01 - f00) + a * b * (f11 - f10 - f01 + f00);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, ap = APS[S.word], F = ap.F, w = ap.w, cu = S.cu, cv = S.cv, col = S.rgb;\n  buf.fill(0);\n  const sn = sin(S.ph), focus = PULL * (sn \u003c 0 ? -1 : 1) * abs(sn) ** SHAPE, gain = (K * 1.4) / S.stop;\n  for (let n = 0; n \u003c NL; n++) {\n    let s = gain * (focus - S.z[n]);\n    if (abs(s) \u003c 0.04) s = s \u003c 0 ? -0.04 : 0.04;\n    const as = abs(s), lx = S.x[n], ly = S.y[n];\n    // Surface brightness: even over a word of 0.7 LEDs to the cell and\n    // more, overdriven 1.8 times so the strokes stay whole after clamping.\n    // Below that the light keeps its whole power and spreads it less, so a\n    // small word burns out and a light in focus is one bright LED.\n    const lum = S.g[n] * 1.8 * max(1, 0.45 / (s * s));\n    hsv(S.hue + HUES[S.c[n]], col);\n    const x0 = max(0, floor(lx - (w * as) / 2)), x1 = min(W - 1, floor(lx + (w * as) / 2));\n    const y0 = max(0, floor(ly - (CH * as) / 2)), y1 = min(H - 1, floor(ly + (CH * as) / 2));\n    // Cell coordinates of each LED edge; a negative s runs them backwards,\n    // which is the 180 degree turn.\n    for (let x = x0; x \u003c= x1 + 1; x++) cu[x - x0] = (x - lx) / s + w / 2;\n    for (let y = y0; y \u003c= y1 + 1; y++) cv[y - y0] = (y - ly) / s + CH / 2;\n    const s2 = s * s * lum;\n    for (let y = y0; y \u003c= y1; y++) {\n      let va = cv[y - y0], vb = cv[y - y0 + 1];\n      if (va > vb) (vb = va), (va = cv[y - y0 + 1]);\n      for (let x = x0; x \u003c= x1; x++) {\n        let ua = cu[x - x0], ub = cu[x - x0 + 1];\n        if (ua > ub) (ub = ua), (ua = cu[x - x0 + 1]);\n        const c = (inkTo(F, w, ub, vb) - inkTo(F, w, ua, vb) - inkTo(F, w, ub, va) + inkTo(F, w, ua, va)) * s2;\n        if (c \u003c= 0.001) continue;\n        const p = (y * W + x) * 3;\n        buf[p] += c * col[0];\n        buf[p + 1] += c * col[1];\n        buf[p + 2] += c * col[2];\n      }\n    }\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","brazil-nut":"// ===== Patternflow pattern =====\n// Title:   Brazil Nut\n// Family:  particle\n// Idea:    A bed of 540 small discs in seven coloured strata fills the panel nearly to the top with one large pale disc on its floor, and a Monte Carlo shakes it six times a second, lifting the whole packing and letting every disc settle by random steps that may never go up, so the small discs that slip into the gap opening under the large one ratchet it up through the strata, stirring them in its wake, until it reaches the top after about 52 seconds and the column tips over end to end and starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Brazil nut effect, size segregation by shaking in the Monte Carlo of Anthony Rosato, Katherine Strandburg, Friedrich Prinz and Robert Swendsen (1987), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Amplitude=-1..1, Size=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the strata run from sea green on the floor through cyan and azure to violet at the top, every other one pale, and the large disc is pale gold; at 0.5 they run from rose through orange and yellow to lime and the large disc is pale blue.\n// Knob 2: Speed. Shakes a second, 3 for each unit: 6 at the opening 2, 0.6 at 0.2 and 9 at 3. Each shake is the same Monte Carlo whatever the speed, so the climb takes about 315 shakes: 52 seconds at 2, 35 seconds at 3, nearly 9 minutes at 0.2.\n// Knob 3: Amplitude. How far each shake lifts the packing, 6 x 1.6^Amplitude LEDs: 3.75 at -1, 6 at the opening 0 (1.7 small diameters), 9.6 at 1. A bigger lift opens a deeper gap under the large disc and it climbs faster: about 100 seconds at -1, 52 at 0, 31 at 1.\n// Knob 4: Size. The large disc's radius, 7 x 1.45^Size rounded to half an LED: 5 at -1, 7 at the opening, 10 at 1, against small radii of 1.6 to 1.95. The climb takes about 58, 52 and 49 seconds. A new size fills a new column once the knob has rested 0.3 seconds.\n// Buttons: K1 tap tips the column over now. A large disc on the floor then lands on top and the column tips back after 2.5 seconds.\n\n// Anthony Rosato, Katherine Strandburg, Friedrich Prinz and Robert Swendsen,\n// \"Why the Brazil nuts are on top: size segregation of particulate matter\n// by shaking\", Physical Review Letters 58 (1987), found the effect in a\n// Monte Carlo of hard discs under gravity, with no other force. A shake\n// lifts the whole packing by the amplitude, and then the discs settle by\n// random trial moves that are kept only if they overlap nothing and do not\n// go up. As the packing falls back, a gap opens under a large disc, and\n// small discs slip into its edges before the large disc can fall the whole\n// way. It cannot go back down past them, so each shake leaves it a little\n// higher: a ratchet, with no convection and no air.\n//\n// The moves here are this pattern's own. A shake lifts every disc by A and\n// then runs ceil(20 + 5 A) sweeps, 50 at the opening, enough for the packing\n// to settle. In a sweep each disc is tried once, in order of height from\n// the floor up, so a whole column can drop a step in one sweep: a step\n// sideways by up to 0.6 LEDs and down by 0.3 to 0.6, else straight down by\n// 0.6, else down by 0.15, each kept only if the disc then overlaps nothing.\n// No disc ever moves up except in the lift. The sides wrap round, so the\n// large disc never stalls against a wall, and overlaps are found through a\n// grid of 12 by 32 cells. The 540 small discs have radii 1.6 to 1.95 LEDs,\n// spread so the packing does not freeze into a crystal.\n//\n// The picture glides from one settled packing to the next while the Monte\n// Carlo works out the one after, and rises 0.15 A and falls back in each\n// shake, so the shaking shows without the packing jumping 6 LEDs six times\n// a second. The small discs are coloured by the seventh of the packing's\n// height they started in. Once no small disc lies above the large one it\n// holds 2.5 seconds, the column turns end over end about the middle row in\n// 1.4 seconds, the strata are recoloured from the new floor while it is\n// edge-on, and the packing falls 90 sweeps onto the floor in 1.2 seconds.\n// After 900 shakes without the large disc reaching the top it tips anyway.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, round, cos, sin, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The sides wrap round: x is taken modulo the width, and a difference in x\n// is the shorter way round.\nconst wrap = (x) => x - W * floor(x / W);\nconst near = (d) => d - W * round(d / W);\n\nconst P = {\n  RMIN: 1.6, RMAX: 1.95, TOP: 137, DELTA: 0.6, CS: 5, GX: 12, GY: 32,\n  BANDS: 7, HOLD: 2.5, TIP: 1.4, FALL: 1.2, LIMIT: 900,\n};\nconst CX = W / P.GX;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nfunction build(S) {\n  const R = S.R, nb = S.nb;\n  const xs = [], ys = [], rs = [];\n  // Big discs side by side on the floor.\n  for (let b = 0; b \u003c nb; b++) {\n    xs.push(((b + 0.5) * W) / nb);\n    ys.push(R + 0.2);\n    rs.push(R);\n  }\n  const per = floor(W / (2 * P.RMAX + 0.15)), dx = W / per, dy = dx * 0.87;\n  for (let row = 0; ; row++) {\n    const y = P.RMAX + 0.1 + row * dy;\n    if (y > P.TOP) break;\n    for (let q = 0; q \u003c per; q++) {\n      const x = (q + (row & 1 ? 0.5 : 0)) * dx;\n      let ok = true;\n      for (let b = 0; b \u003c nb; b++) {\n        const ex = near(x - xs[b]), ey = y - ys[b];\n        if (ex * ex + ey * ey \u003c (R + P.RMAX + 0.2) ** 2) ok = false;\n      }\n      if (!ok) continue;\n      xs.push(wrap(x + (random() - 0.5) * 0.1));\n      ys.push(y);\n      rs.push(P.RMIN + random() * (P.RMAX - P.RMIN));\n    }\n  }\n  const n = xs.length;\n  S.n = n;\n  S.x = Float64Array.from(xs);\n  S.y = Float64Array.from(ys);\n  S.r = Float64Array.from(rs);\n  S.band = new Float32Array(n);\n  S.cell = new Int32Array(P.GX * P.GY + 1);\n  S.item = new Int32Array(n);\n  S.ci = new Int32Array(n);\n  for (let k = 0; k \u003c 120; k++) sweep(S);\n  S.ay = null;\n  colour(S, false);\n}\n\n// Strata by starting height: seven bands of the packing's height, bottom\n// to top. After a tip the bands are the mirror of the old ones.\nfunction colour(S, flip) {\n  let top = 0;\n  for (let i = S.nb; i \u003c S.n; i++) top = max(top, S.ay ? S.ay[i] : S.y[i]);\n  for (let i = S.nb; i \u003c S.n; i++) {\n    const b = min(P.BANDS - 1, floor(((S.ay ? S.ay[i] : S.y[i]) / (top + 0.01)) * P.BANDS));\n    S.band[i] = flip ? P.BANDS - 1 - b : b;\n  }\n}\n\nfunction grid(S) {\n  const { cell, item, ci, n, nb } = S;\n  cell.fill(0);\n  for (let i = nb; i \u003c n; i++) {\n    const cx = cl(floor(S.x[i] / CX), 0, P.GX - 1), cy = cl(floor(S.y[i] / P.CS), 0, P.GY - 1);\n    ci[i] = cy * P.GX + cx;\n    cell[ci[i] + 1]++;\n  }\n  for (let c = 0; c \u003c P.GX * P.GY; c++) cell[c + 1] += cell[c];\n  const fill = S.fill || (S.fill = new Int32Array(P.GX * P.GY));\n  fill.fill(0);\n  for (let i = nb; i \u003c n; i++) item[cell[ci[i]] + fill[ci[i]]++] = i;\n}\n\n// Would disc i overlap anything at (px, py)?\nfunction hits(S, i, px, py) {\n  const ri = S.r[i];\n  if (py \u003c ri) return true;\n  const { x, y, r, nb, cell, item } = S;\n  for (let b = 0; b \u003c nb; b++) {\n    if (b === i) continue;\n    const ex = near(px - x[b]), ey = py - y[b], s = ri + r[b];\n    if (ex * ex + ey * ey \u003c s * s) return true;\n  }\n  const reach = ceil((ri + P.RMAX + 1.5 * P.DELTA) / P.CS);\n  const cx = floor(wrap(px) / CX), cy = floor(py / P.CS);\n  for (let gy = max(0, cy - reach); gy \u003c= min(P.GY - 1, cy + reach); gy++)\n    for (let g = cx - reach; g \u003c= cx + reach; g++) {\n      const c = gy * P.GX + (g + P.GX) % P.GX;\n      for (let k = cell[c]; k \u003c cell[c + 1]; k++) {\n        const j = item[k];\n        if (j === i) continue;\n        const ex = near(px - x[j]), ey = py - y[j], s = ri + r[j];\n        if (ex * ex + ey * ey \u003c s * s) return true;\n      }\n    }\n  return false;\n}\n\nfunction sweep(S) {\n  grid(S);\n  const { x, y, n } = S, d = P.DELTA;\n  // Each disc once a sweep, from the lowest up, so a whole column can drop\n  // a step in one sweep. Insertion sort: the order barely changes.\n  const ord = S.ord && S.ord.length === n ? S.ord : (S.ord = new Int32Array(n).map((_, i) => i));\n  for (let k = 1; k \u003c n; k++) {\n    const t = ord[k], ty = y[t];\n    let j = k - 1;\n    while (j >= 0 && y[ord[j]] > ty) {\n      ord[j + 1] = ord[j];\n      j--;\n    }\n    ord[j + 1] = t;\n  }\n  for (let k = 0; k \u003c n; k++) {\n    const i = ord[k];\n    // A step down and to the side; if that is blocked, straight down.\n    const dx = d * (2 * random() - 1), dy = -d * (0.5 + 0.5 * random());\n    if (!hits(S, i, x[i] + dx, y[i] + dy)) {\n      x[i] = wrap(x[i] + dx);\n      y[i] += dy;\n    } else if (!hits(S, i, x[i], y[i] - d)) y[i] -= d;\n    else if (!hits(S, i, x[i], y[i] - d * 0.25)) y[i] -= d * 0.25;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, A: 6, R: 7, want: 7, rest: 0, fresh: true, nb: 1, mode: 0, shakes: 0, hold: -1, done: 0, owed: 0, K: 50, tip: 0, btn: false,\n    img: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n  build(params.s);\n  settled(params.s, true);\n}\n\n// Keep the last two settled packings: the picture glides from one to the\n// next while the Monte Carlo works out the one after.\nfunction settled(S, both) {\n  if (!S.ax || S.ax.length !== S.n) {\n    S.ax = new Float64Array(S.n);\n    S.ay = new Float64Array(S.n);\n    S.bx = new Float64Array(S.n);\n    S.by = new Float64Array(S.n);\n    both = true;\n  }\n  if (both) {\n    S.bx.set(S.x);\n    S.by.set(S.y);\n  } else {\n    S.bx.set(S.ax);\n    S.by.set(S.ay);\n  }\n  S.ax.set(S.x);\n  S.ay.set(S.y);\n}\n\n// A big disc is on top once no small disc sits above it within its width.\nfunction surfaced(S) {\n  for (let b = 0; b \u003c S.nb; b++)\n    for (let i = S.nb; i \u003c S.n; i++) if (S.y[i] > S.y[b] && abs(near(S.x[i] - S.x[b])) \u003c S.r[b]) return false;\n  return true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.A = 6 * 1.6 ** cl(k[2] || 0, -1, 1);\n  const R = round(7 * 1.45 ** cl(k[3] == null ? 0.06 : k[3], -1, 1) * 2) / 2;\n  if (R !== S.want) {\n    S.want = R;\n    S.rest = 0;\n  } else S.rest += d;\n  // A new size fills a new column, once the knob has rested 0.3 seconds.\n  if (R !== S.R && (S.rest > 0.3 || S.fresh)) {\n    S.R = R;\n    build(S);\n    settled(S, true);\n    S.mode = 0;\n    S.shakes = 0;\n    S.hold = -1;\n    S.done = 0;\n  }\n  S.fresh = false;\n  const b = !!(input.btnPressed && input.btnPressed[0]);\n  if (b && !S.btn && S.mode === 0) {\n    S.mode = 1;\n    S.tip = 0;\n  }\n  S.btn = b;\n  if (S.mode === 0) {\n    // Shaking: each shake lifts the whole packing by A and lets it settle\n    // through K sweeps, K growing with A.\n    S.K = ceil(20 + 5 * S.A);\n    S.owed += d * 3 * S.speed * S.K;\n    while (S.owed >= 1) {\n      if (S.done === 0) for (let i = 0; i \u003c S.n; i++) S.y[i] += S.A;\n      sweep(S);\n      S.owed -= 1;\n      if (++S.done >= S.K) {\n        S.done = 0;\n        settled(S, false);\n        if (S.hold \u003c 0 && (surfaced(S) || ++S.shakes > P.LIMIT)) S.hold = 0;\n      }\n    }\n    if (S.hold >= 0 && (S.hold += d) > P.HOLD) {\n      S.mode = 1;\n      S.tip = 0;\n    }\n  } else if (S.mode === 1) {\n    // Tipping: the column turns over end to end about its middle row.\n    // Edge-on at the halfway point, the column changes its colours unseen.\n    if (S.tip \u003c 0.5 && S.tip + d / P.TIP >= 0.5) colour(S, true);\n    S.tip += d / P.TIP;\n    if (S.tip >= 1) {\n      for (let i = 0; i \u003c S.n; i++) S.y[i] = H - S.ay[i];\n      S.x.set(S.ax);\n      S.mode = 2;\n      S.owed = 0;\n      S.done = 0;\n    }\n  } else {\n    // Falling back onto the floor, no lift, then shaking again.\n    S.owed += (d * 90) / P.FALL;\n    while (S.owed >= 1 && S.mode === 2) {\n      sweep(S);\n      S.owed -= 1;\n      if (++S.done >= 90) {\n        settled(S, true);\n        S.mode = 0;\n        S.done = 0;\n        S.owed = 0;\n        S.shakes = 0;\n        S.hold = -1;\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const img = S.img, c = S.c;\n  img.fill(0);\n  const disc = (cx, cy, rad, sq, R, G, B) => {\n    if (cx - rad \u003c 0) one(cx + W, cy, rad, sq, R, G, B);\n    if (cx + rad > W) one(cx - W, cy, rad, sq, R, G, B);\n    one(cx, cy, rad, sq, R, G, B);\n  };\n  const one = (cx, cy, rad, sq, R, G, B) => {\n    const x0 = max(0, floor(cx - rad - 1)), x1 = min(W - 1, ceil(cx + rad));\n    const ry = max(0.3, rad * sq), r2 = (rad + 0.2) * (rad + 0.2), s2 = (ry + 0.2) * (ry + 0.2);\n    for (let px = x0; px \u003c= x1; px++) {\n      const ex = px + 0.5 - cx;\n      for (let row = max(0, floor(H - cy - ry - 1)); row \u003c= min(H - 1, ceil(H - cy + ry)); row++) {\n        const ey = H - (row + 0.5) - cy, q = (ex * ex) / r2 + (ey * ey) / s2;\n        if (q >= 1) continue;\n        const w = 1 - 0.6 * q, p = (row * W + px) * 3;\n        img[p] = max(img[p], R * w);\n        img[p + 1] = max(img[p + 1], G * w);\n        img[p + 2] = max(img[p + 2], B * w);\n      }\n    }\n  };\n  // Where each disc is drawn: gliding between settled packings with the\n  // shake's bump while shaking, squashed about row 64 while tipping, as\n  // it is while falling.\n  let u = 0, bump = 0, sq = 1;\n  if (S.mode === 0) {\n    const ph = cl((S.done + S.owed) / S.K, 0, 1);\n    u = ph * ph * (3 - 2 * ph);\n    bump = 0.15 * S.A * sin(PI * ph);\n  } else if (S.mode === 1) {\n    u = 1;\n    sq = cos(PI * S.tip);\n  }\n  const X = (i) => (S.mode === 2 ? S.x[i] : wrap(S.bx[i] + near(S.ax[i] - S.bx[i]) * u));\n  const Y = (i) => {\n    if (S.mode === 2) return S.y[i];\n    if (S.mode === 1) return H / 2 + (S.ay[i] - H / 2) * sq;\n    return S.by[i] + (S.ay[i] - S.by[i]) * u + bump;\n  };\n  for (let i = S.nb; i \u003c S.n; i++) {\n    // Even bands full, odd bands pale, so a stratum that has been stirred\n    // shows as speckle in the next one's tint.\n    const b = S.band[i];\n    hsv(S.hue + 0.45 + 0.055 * b, b & 1 ? 0.4 : 0.82, 1, c);\n    disc(X(i), Y(i), S.r[i], abs(sq), c[0], c[1], c[2]);\n  }\n  hsv(S.hue + 0.12, 0.5, 1, c);\n  for (let b = 0; b \u003c S.nb; b++) disc(X(b), Y(b), S.r[b], abs(sq), c[0], c[1], c[2]);\n  for (let row = 0; row \u003c H; row++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (row * W + x) * 3;\n      display.setPixel(x, row, round(img[p] * 255), round(img[p + 1] * 255), round(img[p + 2] * 255));\n    }\n}\n","cardinal-vowels":"// ===== Patternflow pattern =====\n// Title:   Cardinal Vowels\n// Family:  type\n// Idea:    Daniel Jones's vowel chart stands up on the tall panel with its sixteen cardinal vowels in pairs at their eight places, a point that stands for the tongue glides from place to place across it, and above it, between phonetic brackets, the vowel nearest the tongue is drawn with an x-height of 28 LEDs and melts into the next one as the tongue crosses over, while a lip knob turns every letter into its rounded partner, i into y, a into ɶ, ɯ into u.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the cardinal vowels (Daniel Jones, An Outline of English Phonetics, 1918) and the vowel quadrilateral of the International Phonetic Alphabet, pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cardinal=0..8, Lips=0..1\n//\n// Knob 1: Hue. Turns every colour together. At 0 the spread-lip letters are cyan, the rounded ones pink, the chart's lines slate blue and the tongue warm white; the big letter turns from cyan through blue and violet to pink as the lips round. At 0.5 the spread-lip letters are red and the rounded ones green.\n// Knob 2: Speed. How fast the tongue wanders. At 2 it glides to a new place in about 0.8 s and rests 0.7 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Cardinal. 0 lets the tongue wander by itself. 1 to 8 holds it on the place of Jones's primary vowel of that number, in his order round the edge of the chart: 1 close front, down the front to 4 open front, across the floor to 5 open back, and up the back to 8 close back. Between two numbers it stands between the two places, and the big letter is half one and half the other; between 0 and 1 it is pulled from where it wanders toward vowel 1.\n// Knob 4: Lips. Rounds the lips: below 0.1 every letter is the spread-lip one (i e ɛ a ɑ ʌ ɤ ɯ), above 0.9 the rounded one (y ø œ ɶ ɒ ɔ o u), and in between the big letter morphs from one to the other and the small pairs on the chart trade brightness. The number in the top left corner is Jones's: 1 to 8 for his primary vowels, 9 to 16 for the secondary ones.\n\n// Daniel Jones fixed eight reference vowels round the edge of the space the\n// tongue can reach: 1 [i] with the tongue as high and as far forward as it\n// goes without friction, 5 [ɑ] as low and as far back, and between them, on\n// the front and back edges, vowels at equal steps of sound. Those are his\n// primary cardinal vowels, i e ɛ a ɑ ɔ o u. The secondary ones, 9 to 16,\n// take the same tongue and the other lips: y ø œ ɶ ɒ ʌ ɤ ɯ. He recorded\n// them himself for the gramophone, in 1917 and again in 1956. The chart the\n// International Phonetic Alphabet prints is his quadrilateral, close at the\n// top and open at the bottom, front at the left and back at the right, with\n// each place holding a pair, the unrounded letter left of its dot and the\n// rounded one right of it.\n//\n// On the panel the chart stands 62 LEDs high and 42 wide at the top, its\n// front edge slanting in to half that at the floor as on the IPA chart. The\n// big letter is the vowel whose dot is nearest the tongue. When the tongue\n// is about as near two dots, the letter is drawn from the blend of the two\n// letters' distance fields, so one letter melts into the other instead of\n// switching, and Lips blends each letter's field with its rounded\n// partner's in the same way. Inside the chart each dot has a faint pool of\n// light that fades out where another dot becomes nearer, so the pools are\n// the regions that name the same vowel.\n//\n// Every glyph is drawn here: the big letters as strokes (straight runs,\n// ellipse arcs and Catmull-Rom curves) whose distance fields are worked out\n// once, the small ones as 5-row pixel letters, and the figures as 3 by 5\n// pixel figures.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, exp, abs, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The chart: close at TY, open at BY; the front edge runs from FX0 to FX1,\n// the back edge stands at BX.\nconst TY = 60, BY = 121, FX0 = 12, FX1 = 33, BX = 54;\n// The big letter: x-height XH from row TOP, in rows 0..BH-1.\nconst XH = 28, TOP = 13, BH = 52, HW = 2.3;\n\n// --- Big letters, as strokes in x-height units (y down, 0 top, 1 baseline).\nfunction arc(cx, cy, rx, ry, a0, a1) {\n  const n = max(4, round(abs(a1 - a0) * 6)), p = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n;\n    p.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return p;\n}\nfunction curve(...c) {\n  const p = [];\n  for (let i = 0; i + 1 \u003c c.length; i++) {\n    const a = c[max(0, i - 1)], b = c[i], d = c[i + 1], e = c[min(c.length - 1, i + 2)];\n    for (let s = 0; s \u003c 6; s++) {\n      const t = s / 6, t2 = t * t, t3 = t2 * t;\n      const f = (k) => 0.5 * (2 * b[k] + (d[k] - a[k]) * t + (2 * a[k] - 5 * b[k] + 4 * d[k] - e[k]) * t2 + (3 * b[k] - a[k] - 3 * d[k] + e[k]) * t3);\n      p.push([f(0), f(1)]);\n    }\n  }\n  p.push(c[c.length - 1]);\n  return p;\n}\nconst line = (...p) => p;\nconst mirror = (strokes, w) => strokes.map((s) => s.map(([x, y]) => [w - x, y]));\nconst O = arc(0.42, 0.5, 0.42, 0.5, 0, 2 * PI);\nconst SCRIPT_A = [curve([0.78, 0.22], [0.5, 0.0], [0.16, 0.12], [0.04, 0.5], [0.16, 0.88], [0.5, 1.0], [0.78, 0.78]), line([0.8, 0], [0.8, 1])];\n\n// [name, width in x-height units, strokes]\nconst BIG = {\n  i: [0.4, [line([0.2, 0], [0.2, 1]), line([0.2, -0.33], [0.2, -0.3])]],\n  e: [0.86, [line([0.06, 0.5], [0.84, 0.5]), curve([0.84, 0.5], [0.76, 0.18], [0.44, 0.0], [0.12, 0.16], [0.03, 0.52], [0.16, 0.87], [0.48, 1.0], [0.8, 0.86])]],\n  \"ɛ\": [0.86, [curve([0.82, 0.14], [0.5, 0.0], [0.2, 0.08], [0.16, 0.32], [0.46, 0.5], [0.12, 0.62], [0.06, 0.86], [0.42, 1.0], [0.84, 0.86]), line([0.46, 0.5], [0.58, 0.5])]],\n  a: [0.86, [curve([0.12, 0.12], [0.42, 0.0], [0.72, 0.1], [0.78, 0.4], [0.78, 1.0]), curve([0.78, 0.5], [0.36, 0.48], [0.05, 0.68], [0.14, 0.95], [0.44, 1.0], [0.78, 0.84])]],\n  \"ɑ\": [0.9, SCRIPT_A],\n  \"ʌ\": [0.9, [line([0.02, 1], [0.45, 0], [0.88, 1])]],\n  \"ɤ\": [0.9, [curve([0.02, 0.0], [0.26, 0.38], [0.5, 0.72], [0.57, 0.92], [0.45, 1.01], [0.33, 0.92], [0.4, 0.72], [0.64, 0.38], [0.88, 0.0])]],\n  \"ɯ\": [0.92, [line([0.04, 0], [0.04, 0.62]), arc(0.25, 0.62, 0.21, 0.38, PI, 0), line([0.46, 0], [0.46, 0.62]), arc(0.67, 0.62, 0.21, 0.38, PI, 0), line([0.88, 0], [0.88, 1])]],\n  y: [0.9, [line([0.02, 0], [0.47, 0.98]), curve([0.88, 0], [0.47, 0.98], [0.34, 1.24], [0.12, 1.34])]],\n  \"ø\": [0.9, [O, line([-0.04, 1.1], [0.88, -0.1])]],\n  \"œ\": [1.42, [arc(0.36, 0.5, 0.34, 0.5, 0, 2 * PI), line([0.7, 0.5], [1.4, 0.5]), curve([1.4, 0.5], [1.32, 0.18], [1.05, 0.0], [0.76, 0.14], [0.7, 0.5], [0.76, 0.86], [1.06, 1.0], [1.38, 0.86])]],\n  \"ɶ\": [1.34, [curve([0.72, 0.0], [0.3, 0.04], [0.04, 0.5], [0.3, 0.96], [0.72, 1.0]), line([1.32, 0], [0.72, 0], [0.72, 1], [1.32, 1]), line([0.72, 0.5], [1.2, 0.5])]],\n  \"ɒ\": [0.9, mirror(SCRIPT_A, 0.84)],\n  \"ɔ\": [0.84, [curve([0.08, 0.14], [0.42, 0.0], [0.78, 0.28], [0.8, 0.5], [0.78, 0.72], [0.42, 1.0], [0.06, 0.86])]],\n  o: [0.84, [O]],\n  u: [0.84, [line([0.04, 0], [0.04, 0.62]), arc(0.42, 0.62, 0.38, 0.38, PI, 0), line([0.8, 0], [0.8, 1])]],\n};\n\n// --- Small letters, 5 rows of x-height (rows 2..6 of 9: two above for the\n// dot of i and the slash of ø, two below for the tail of y).\nconst SMALL = {\n  i: [\".#.\", \"...\", \"##.\", \".#.\", \".#.\", \".#.\", \"###\"],\n  e: [\".###.\", \"#...#\", \"#####\", \"#....\", \".###.\"],\n  \"ɛ\": [\".####\", \"#....\", \".###.\", \"#....\", \".####\"],\n  a: [\".###.\", \"....#\", \".####\", \"#...#\", \".####\"],\n  \"ɑ\": [\".##.#\", \"#..##\", \"#...#\", \"#..##\", \".##.#\"],\n  \"ʌ\": [\"..#..\", \".#.#.\", \".#.#.\", \"#...#\", \"#...#\"],\n  \"ɤ\": [\"#...#\", \".#.#.\", \"..#..\", \".#.#.\", \"..#..\"],\n  \"ɯ\": [\"#.#.#\", \"#.#.#\", \"#.#.#\", \"#.#.#\", \".#.##\"],\n  y: [\"#...#\", \"#...#\", \".#.#.\", \".#.#.\", \"..#..\", \".#...\", \"#....\"],\n  \"ø\": [\"....#\", \".###.\", \"#..##\", \"#.#.#\", \"##..#\", \".###.\", \"#....\"],\n  \"œ\": [\".##.##.\", \"#..#..#\", \"#..####\", \"#..#...\", \".##.###\"],\n  \"ɶ\": [\".######\", \"#..#...\", \"#..####\", \"#..#...\", \".######\"],\n  \"ɒ\": [\"#.##.\", \"##..#\", \"#...#\", \"##..#\", \"#.##.\"],\n  \"ɔ\": [\".###.\", \"....#\", \"....#\", \"....#\", \".###.\"],\n  o: [\".###.\", \"#...#\", \"#...#\", \"#...#\", \".###.\"],\n  u: [\"#...#\", \"#...#\", \"#...#\", \"#..##\", \".##.#\"],\n};\n// Rows above the x-height for each small letter that reaches up.\nconst RISE = { i: 2, \"ø\": 1 };\n\n// 3 by 5 figures, drawn for this pattern.\nconst FIG = [\"####.##.##.####\", \".#.##..#..#.###\", \"###..#####..###\", \"###..#.##..####\", \"#.##.####..#..#\", \"####..###..####\", \"####..####.####\", \"###..#..#.#..#.\", \"####.#####.####\", \"####.####..####\"];\n\n// The eight places in Jones's order, as (backness, openness), with the\n// spread-lip and rounded letters and their cardinal numbers.\nconst PLACES = [\n  [0, 0, \"i\", \"y\", 1, 9],\n  [0, 1 / 3, \"e\", \"ø\", 2, 10],\n  [0, 2 / 3, \"ɛ\", \"œ\", 3, 11],\n  [0, 1, \"a\", \"ɶ\", 4, 12],\n  [1, 1, \"ɑ\", \"ɒ\", 5, 13],\n  [1, 2 / 3, \"ʌ\", \"ɔ\", 14, 6],\n  [1, 1 / 3, \"ɤ\", \"o\", 15, 7],\n  [1, 0, \"ɯ\", \"u\", 16, 8],\n];\nconst px = (b, v) => FX0 + v * (FX1 - FX0) + b * (BX - FX0 - v * (FX1 - FX0));\nconst py = (v) => TY + v * (BY - TY);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i, p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  const c = i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n  o[0] = c[0];\n  o[1] = c[1];\n  o[2] = c[2];\n  return o;\n}\n\nfunction segDist(x, y, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((x - ax) * dx + (y - ay) * dy) / l, 0, 1) : 0;\n  const ex = ax + dx * t - x, ey = ay + dy * t - y;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// The distance from every LED of the big box to a letter's strokes, in LEDs.\nfunction field(name) {\n  const [w, strokes] = BIG[name], x0 = W / 2 - (w * XH) / 2, f = new Float32Array(W * BH);\n  const segs = [];\n  for (const s of strokes) for (let i = 0; i + 1 \u003c s.length; i++) segs.push([x0 + s[i][0] * XH, TOP + s[i][1] * XH, x0 + s[i + 1][0] * XH, TOP + s[i + 1][1] * XH]);\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let d = 1e9;\n      for (const g of segs) d = min(d, segDist(x + 0.5, y + 0.5, g[0], g[1], g[2], g[3]));\n      f[y * W + x] = d;\n    }\n  return f;\n}\n\nexport function setup(params) {\n  const F = {};\n  for (const name of Object.keys(BIG)) F[name] = field(name);\n  // Each LED inside the chart: its nearest place and how near the next.\n  const cell = new Int8Array(W * H).fill(-1), pool = new Float32Array(W * H);\n  for (let y = TY; y \u003c= BY; y++) {\n    const v = (y - TY) / (BY - TY), xf = FX0 + v * (FX1 - FX0);\n    for (let x = Math.ceil(xf); x \u003c= BX; x++) {\n      let d1 = 1e9, d2 = 1e9, k1 = 0;\n      PLACES.forEach((p, k) => {\n        const d = Math.hypot(px(p[0], p[1]) - x, py(p[1]) - y);\n        if (d \u003c d1) (d2 = d1), (d1 = d), (k1 = k);\n        else if (d \u003c d2) d2 = d;\n      });\n      cell[y * W + x] = k1;\n      pool[y * W + x] = 1 - (2 * d1) / (d1 + d2);\n    }\n  }\n  params.s = {\n    F, cell, pool, b: 0, v: 0, fb: 0, fv: 0, gb: 0, gv: 0, at: 0, go: 1, rest: 0, trail: [], hue: 0, speed: 1, hand: 0, lips: 0,\n    rgb: new Float32Array(W * H * 3),\n  };\n  pick(params.s);\n}\n\n// The next place to glide to: another cardinal vowel, or now and then a\n// point between them.\nfunction pick(S) {\n  S.fb = S.b;\n  S.fv = S.v;\n  if (Math.random() \u003c 0.25) {\n    S.gb = 0.15 + 0.7 * Math.random();\n    S.gv = 0.1 + 0.8 * Math.random();\n  } else {\n    let k;\n    do k = floor(Math.random() * 8);\n    while (PLACES[k][0] === S.gb && PLACES[k][1] === S.gv);\n    S.gb = PLACES[k][0];\n    S.gv = PLACES[k][1];\n  }\n  const d = Math.hypot((S.gb - S.fb) * 0.7, S.gv - S.fv);\n  S.go = 0.45 + 0.5 * d;\n  S.at = 0;\n}\n\n// Where knob 3 puts the tongue: along the edge through the places 1..8.\nfunction edge(c) {\n  const k = min(6, floor(c - 1)), f = c - 1 - k, a = PLACES[k], b = PLACES[k + 1];\n  return [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.hand = cl(k[2] || 0, 0, 8);\n  S.lips = sm(0.1, 0.9, cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  // The wander.\n  if (S.rest > 0) {\n    S.rest -= d * S.speed;\n    if (S.rest \u003c= 0) pick(S);\n  } else {\n    S.at += (d * S.speed) / S.go;\n    if (S.at >= 1) (S.at = 1), (S.rest = 0.7);\n  }\n  const e = sm(0, 1, S.at);\n  let b = S.fb + (S.gb - S.fb) * e, v = S.fv + (S.gv - S.fv) * e;\n  if (S.hand > 0) {\n    // The hand: pulled from the wander toward vowel 1 below 1, along the\n    // edge above it, and eased so a turned knob glides rather than jumps.\n    const [hb, hv] = edge(max(1, S.hand)), f = min(1, S.hand), a = 1 - exp(-d * 12);\n    b += (hb - b) * f;\n    v += (hv - v) * f;\n    S.b += (b - S.b) * a;\n    S.v += (v - S.v) * a;\n  } else (S.b = b), (S.v = v);\n  S.trail.push([px(S.b, S.v), py(S.v)]);\n  if (S.trail.length > 36) S.trail.shift();\n}\n\nfunction add(rgb, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  rgb[o] = max(rgb[o], c[0] * a);\n  rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n  rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n}\n\nfunction small(rgb, name, x, y, c, a) {\n  const rows = SMALL[name], rise = RISE[name] || 0;\n  for (let r = 0; r \u003c rows.length; r++)\n    for (let i = 0; i \u003c rows[r].length; i++) if (rows[r][i] === \"#\") add(rgb, x + i, y - rise + r, c, a);\n}\n\nfunction figure(rgb, n, x, y, c, a) {\n  const s = String(n);\n  for (let j = 0; j \u003c s.length; j++) {\n    const g = FIG[+s[j]];\n    for (let r = 0; r \u003c 5; r++) for (let i = 0; i \u003c 3; i++) if (g[r * 3 + i] === \"#\") add(rgb, x + j * 4 + i, y + r, c, a);\n  }\n}\n\nfunction seg(rgb, x0, y0, x1, y1, c, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0), 1);\n  for (let i = 0; i \u003c= n; i++) add(rgb, round(x0 + ((x1 - x0) * i) / n), round(y0 + ((y1 - y0) * i) / n), c, a);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, hue = S.hue, lips = S.lips;\n  rgb.fill(0);\n  const cu = hsv(0.5 + hue, 0.85, 1, [0, 0, 0]), cr = hsv(0.9 + hue, 0.7, 1, [0, 0, 0]), lineC = hsv(0.62 + hue, 0.45, 1, [0, 0, 0]);\n  // The letter's colour turns the short way round the wheel, through blue.\n  const cl2 = hsv(0.5 + 0.4 * lips + hue, 0.85 - 0.15 * lips, 1, [0, 0, 0]);\n  const tx = px(S.b, S.v), ty = py(S.v);\n  // The two places nearest the tongue.\n  let d1 = 1e9, d2 = 1e9, k1 = 0, k2 = 1;\n  PLACES.forEach((p, k) => {\n    const d = Math.hypot(px(p[0], p[1]) - tx, py(p[1]) - ty);\n    if (d \u003c d1) (d2 = d1), (k2 = k1), (d1 = d), (k1 = k);\n    else if (d \u003c d2) (d2 = d), (k2 = k);\n  });\n  const m = 0.5 * sm(0.3, 0.5, d1 / (d1 + d2));\n  // The pools.\n  for (let p = 0; p \u003c W * H; p++) {\n    const k = S.cell[p];\n    if (k \u003c 0) continue;\n    const a = (k === k1 ? 0.3 : 0.13) * S.pool[p];\n    rgb[p * 3] = cl2[0] * a;\n    rgb[p * 3 + 1] = cl2[1] * a;\n    rgb[p * 3 + 2] = cl2[2] * a;\n  }\n  // The chart's lines: the edge, the close-mid and open-mid lines, the\n  // central line.\n  const L = 0.42, L2 = 0.22;\n  seg(rgb, FX0, TY, BX, TY, lineC, L);\n  seg(rgb, BX, TY, BX, BY, lineC, L);\n  seg(rgb, FX1, BY, BX, BY, lineC, L);\n  seg(rgb, FX0, TY, FX1, BY, lineC, L);\n  for (const v of [1 / 3, 2 / 3]) seg(rgb, round(px(0, v)), round(py(v)), BX, round(py(v)), lineC, L2);\n  seg(rgb, round(px(0.5, 0)), TY, round(px(0.5, 1)), BY, lineC, L2);\n  // The pairs.\n  PLACES.forEach((p, k) => {\n    const x = round(px(p[0], p[1])), y = round(py(p[1]));\n    const near = k === k1 ? 1 : k === k2 ? 2 * m : 0;\n    add(rgb, x, y, [1, 1, 1], 0.6 + 0.4 * near);\n    const wl = SMALL[p[2]][SMALL[p[2]].length - 1].length;\n    const au = 0.16 + (0.56 + 0.28 * near) * (1 - lips), ar = 0.16 + (0.56 + 0.28 * near) * lips;\n    const wu = [0, 0, 0], wr = [0, 0, 0];\n    for (let c = 0; c \u003c 3; c++) (wu[c] = cu[c] + (1 - cu[c]) * 0.5 * near * (1 - lips)), (wr[c] = cr[c] + (1 - cr[c]) * 0.5 * near * lips);\n    small(rgb, p[2], x - 2 - wl, y - 2, wu, au);\n    small(rgb, p[3], x + 2, y - 2, wr, ar);\n  });\n  // The tongue and where it has been.\n  for (let i = 0; i \u003c S.trail.length; i++) {\n    const [x, y] = S.trail[i];\n    add(rgb, floor(x), floor(y), [1, 0.85, 0.65], 0.12 + (0.35 * i) / S.trail.length);\n  }\n  const tc = hsv(0.1 + hue, 0.3, 1, [0, 0, 0]);\n  for (let j = -2; j \u003c= 2; j++)\n    for (let i = -2; i \u003c= 2; i++) {\n      const r = Math.hypot(i + floor(tx) + 0.5 - tx, j + floor(ty) + 0.5 - ty);\n      add(rgb, floor(tx) + i, floor(ty) + j, tc, cl(1.6 - r, 0, 1) + 0.25 * exp(-r));\n    }\n  // The big letter: the nearest place's letter, blended toward the next\n  // nearest by m and toward its rounded partner by lips.\n  const P1 = PLACES[k1], P2 = PLACES[k2], F = S.F;\n  const a1 = F[P1[2]], b1 = F[P1[3]], a2 = F[P2[2]], b2 = F[P2[3]];\n  // A blend of two fields thins out where the letters part, so the stroke\n  // swells by up to 1.25 LEDs halfway.\n  const thick = 5 * max(m * (1 - m), lips * (1 - lips));\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let d = a1[p];\n      if (lips > 0) d += (b1[p] - d) * lips;\n      if (m > 0) d += (a2[p] + (b2[p] - a2[p]) * lips - d) * m;\n      d -= thick;\n      const core = cl(HW + 0.5 - d, 0, 1), glow = 0.2 * exp(-max(0, d - HW) / 2.2);\n      add(rgb, x, y, cl2, core + (1 - core) * glow);\n    }\n  // Phonetic brackets round it, and Jones's number for it.\n  const bc = lineC, BT = 5, BB = 48;\n  seg(rgb, 3, BT, 3, BB, bc, 0.55);\n  seg(rgb, 3, BT, 6, BT, bc, 0.55);\n  seg(rgb, 3, BB, 6, BB, bc, 0.55);\n  seg(rgb, 60, BT, 60, BB, bc, 0.55);\n  seg(rgb, 57, BT, 60, BT, bc, 0.55);\n  seg(rgb, 57, BB, 60, BB, bc, 0.55);\n  const n = lips \u003c 0.5 ? P1[4] : P1[5];\n  figure(rgb, n, 8, 7, [1, 1, 1], 0.6);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, round(rgb[o] * 255)), min(255, round(rgb[o + 1] * 255)), min(255, round(rgb[o + 2] * 255)));\n    }\n}\n","fifteen-puzzle":"// ===== Patternflow pattern =====\n// Title:   Fifteen Puzzle\n// Family:  type\n// Idea:    Two fifteen puzzles stand one above the other and take the same slides at the same moment, the top one scrambled from the solved order and the bottom one by the same scramble from Sam Loyd's order with 14 and 15 exchanged, and as a solver brings the top board home row by row the bottom board follows it exactly and ends at 1 to 13, 15, 14, while a number on the empty square of each board, the count of pairs out of order plus how many rows the empty square stands above the bottom, steps down by twos and stays even on top and odd below.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the fifteen puzzle (Noyes Palmer Chapman, 1874; the craze of 1880), the parity proof that half the arrangements cannot be reached (William Woolsey Johnson and William E. Story, American Journal of Mathematics, 1879), Sam Loyd's 14-15 puzzle, pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scramble=0..1, Swap=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the tiles are azure, the exchanged pair pink, the count under the top board's empty square green and the one under the bottom board's pink; at 0.33 the tiles are pink and the pair yellow-green, at 0.5 the tiles orange (brown away from home) and the pair teal.\n// Knob 2: Speed. Slides a second, twice the knob: 4 at the opening 2, each tile crossing its 16 LEDs in a quarter of a second; 0.4 at 0.2, where every slide can be followed, and 6 at 3. The shuffle between puzzles runs three times as fast, between 6 and 14 slides a second.\n// Knob 3: Scramble. How many random slides mix the boards before each solve: 40 at the opening 0, which the solver takes 38 to 94 slides to undo (68 as a rule, 17 s at the opening speed); 120 at 1, where a solve takes 66 to 110 (90). The solver's way home is longer than the scramble because it places the tiles in its own order. A turn takes effect at the next shuffle.\n// Knob 4: Swap. Which two numbers the bottom board has exchanged, in five steps: 14 and 15 (Loyd's) at the opening, then 1 and 2, 8 and 12, 4 and 13, and 1 and 15. The pair is pink on both boards; whatever the solver does, the bottom board ends with the pair crossed and its number at 1, 1, 7, 17 or 27, never 0.\n\n// The fifteen puzzle has 16! / 2 arrangements anyone can reach and as many\n// that nobody can. Johnson and Story proved it in 1879 in the second volume\n// of the American Journal of Mathematics. Read the tiles row by row, skip\n// the empty square, and count the pairs that stand in the wrong order: the\n// inversions. A slide along a row changes nothing in that reading. A slide\n// up or down lifts one tile past the three others between its two cells,\n// which changes the count by 1 or 3, and moves the empty square one row.\n// So the inversions plus the empty square's height above the bottom row\n// change by an even number at every slide, and their parity never changes.\n// The solved board has 0 and 0. Loyd's board, solved with 14 and 15\n// exchanged, has one inversion and the empty square at the bottom: odd. It\n// can be brought to 1 to 13, 15, 14 and no closer. Story showed the other\n// half: every arrangement with the even parity can be reached.\n//\n// The panel is two boards of 16 tiles 16 LEDs square, the top one 0 to 63\n// and the bottom one 64 to 127. A move is the cell the empty square goes\n// to; both boards take every move. The bottom board is drawn as the top\n// board with the pair's labels exchanged, and that is the same thing as\n// playing the same moves from the exchanged start: moves act on cells, not\n// on labels. The number on each empty square is its board's inversions plus\n// its height. On top it walks down through even numbers to 0, below through\n// odd ones to the pair's own count, 1 for Loyd's.\n//\n// The solve is a real search, not the scramble undone. The top board is\n// solved in nine steps, the usual order a person learns: tile 1, tile 2,\n// tiles 3 and 4 together, 5, 6, 7 and 8, then the left column (9 and 13),\n// the next one (10 and 14), and the last 2 by 2 corner. Each step is a\n// breadth-first search over the cells of the tiles it places and of the\n// empty square, the placed tiles fixed and the others anonymous, so each\n// step is as short as it can be (the whole is not). At most 16^4 states.\n// Tiles in their own cells are lit; tiles away from home are dim. When the\n// top board arrives it flashes, and the bottom board's pair blinks. Then\n// the next scramble plays in view, three times as fast: a random walk of\n// the empty square that never steps straight back.\n\nconst W = 64, H = 128, C = 16;\nconst { floor, min, max, round, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Tile figures, 5 by 9 and drawn for this pattern; the 1 is 3 wide, so the\n// six two-figure numbers are 9 LEDs wide on a 14 LED face.\nconst BIG = [\n  \".###. #...# #...# #...# #...# #...# #...# #...# .###.\",\n  \".#. ##. .#. .#. .#. .#. .#. .#. ###\",\n  \".###. #...# ....# ....# ...#. ..#.. .#... #.... #####\",\n  \".###. #...# ....# ....# ..##. ....# ....# #...# .###.\",\n  \"...#. ..##. .#.#. #..#. #..#. ##### ...#. ...#. ...#.\",\n  \"##### #.... #.... ####. ....# ....# ....# #...# .###.\",\n  \"..##. .#... #.... ####. #...# #...# #...# #...# .###.\",\n  \"##### ....# ...#. ...#. ..#.. ..#.. .#... .#... .#...\",\n  \".###. #...# #...# #...# .###. #...# #...# #...# .###.\",\n  \".###. #...# #...# #...# .#### ....# ....# ...#. .##..\",\n].map((g) => g.split(\" \"));\n// The count under the empty square, 3 by 5.\nconst SMALL = [\n  \"### #.# #.# #.# ###\", \".#. ##. .#. .#. ###\", \"### ..# ### #.. ###\", \"### ..# .## ..# ###\", \"#.# #.# ### ..# ..#\",\n  \"### #.. ### ..# ###\", \"### #.. ### #.# ###\", \"### ..# ..# .#. .#.\", \"### #.# ### #.# ###\", \"### #.# ### ..# ###\",\n].map((g) => g.split(\" \"));\n\nconst SWAPS = [[14, 15], [1, 2], [8, 12], [4, 13], [1, 15]];\nconst GROUPS = [[1], [2], [3, 4], [5], [6], [7, 8], [9, 13], [10, 14], [11, 12, 15]];\nconst NB = [];\nfor (let c = 0; c \u003c 16; c++) {\n  const r = c >> 2, k = c & 3, a = [];\n  if (r > 0) a.push(c - 4);\n  if (r \u003c 3) a.push(c + 4);\n  if (k > 0) a.push(c - 1);\n  if (k \u003c 3) a.push(c + 1);\n  NB.push(a);\n}\n\nconst SEEN = new Uint8Array(65536), PAR = new Int32Array(65536), Q = new Int32Array(65536);\n\n// The nine searches. A state is the empty square's cell and the cells of\n// the step's tiles, four bits each.\nfunction solve(board) {\n  const b = Int8Array.from(board), moves = [], locked = new Uint8Array(16);\n  for (const g of GROUPS) {\n    const m = g.length;\n    let start = b.indexOf(0), want = 0;\n    for (let i = 0; i \u003c m; i++) {\n      start |= b.indexOf(g[i]) \u003c\u003c (4 + 4 * i);\n      want |= (g[i] - 1) \u003c\u003c (4 + 4 * i);\n    }\n    const mask = ((1 \u003c\u003c (4 * m)) - 1) \u003c\u003c 4;\n    SEEN.fill(0);\n    let head = 0, tail = 0, goal = -1;\n    Q[tail++] = start;\n    SEEN[start] = 1;\n    PAR[start] = -1;\n    while (head \u003c tail) {\n      const k = Q[head++];\n      if ((k & mask) === want) {\n        goal = k;\n        break;\n      }\n      const e = k & 15;\n      for (const n of NB[e]) {\n        if (locked[n]) continue;\n        let k2 = n;\n        for (let i = 0; i \u003c m; i++) {\n          const p = (k >> (4 + 4 * i)) & 15;\n          k2 |= (p === n ? e : p) \u003c\u003c (4 + 4 * i);\n        }\n        if (!SEEN[k2]) {\n          SEEN[k2] = 1;\n          PAR[k2] = k;\n          Q[tail++] = k2;\n        }\n      }\n    }\n    if (goal \u003c 0) break;\n    const path = [];\n    for (let k = goal; PAR[k] !== -1; k = PAR[k]) path.push(k & 15);\n    for (let j = path.length - 1; j >= 0; j--) {\n      const n = path[j], e = b.indexOf(0);\n      b[e] = b[n];\n      b[n] = 0;\n      moves.push(n);\n    }\n    for (const t of g) locked[t - 1] = 1;\n  }\n  return moves;\n}\n\n// A random walk of the empty square that never steps straight back.\nfunction scramble(b, k) {\n  let e = b.indexOf(0), prev = -1;\n  const mv = [];\n  for (let i = 0; i \u003c k; i++) {\n    const opts = NB[e].filter((n) => n !== prev);\n    const n = opts[floor(Math.random() * opts.length) % opts.length];\n    mv.push(n);\n    prev = e;\n    e = n;\n  }\n  return mv;\n}\n\nfunction apply(b, n) {\n  const e = b.indexOf(0);\n  b[e] = b[n];\n  b[n] = 0;\n}\n\n// Inversions of the 15 tiles read row by row, plus the empty square's\n// height above the bottom row; lab exchanges a pair's labels first.\nfunction parityCount(b, pa, pb) {\n  let inv = 0, e = 0;\n  const lab = (v) => (v === pa ? pb : v === pb ? pa : v);\n  for (let i = 0; i \u003c 16; i++) {\n    const vi = lab(b[i]);\n    if (!vi) {\n      e = i;\n      continue;\n    }\n    for (let j = i + 1; j \u003c 16; j++) {\n      const vj = lab(b[j]);\n      if (vj && vj \u003c vi) inv++;\n    }\n  }\n  return inv + 3 - (e >> 2);\n}\n\nexport function setup(params) {\n  params.s = {\n    b: Int8Array.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0]),\n    phase: \"init\", list: [], i: 0, u: 0, timer: 0, t: 0, hue: 0, rate: 4, k: 40, sw: 0,\n    buf: new Float32Array(W * H * 3), c0: [0, 0, 0], c1: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.rate = 2 * cl(kv[1] == null ? 2 : kv[1], 0.2, 3);\n  S.k = round(40 + 80 * cl(kv[2] || 0, 0, 1));\n  S.sw = min(SWAPS.length - 1, floor(cl(kv[3] == null ? 0.06 : kv[3], 0, 1) * SWAPS.length));\n  S.t += d;\n  if (S.phase === \"init\") {\n    for (const n of scramble(S.b, S.k)) apply(S.b, n);\n    S.list = solve(S.b);\n    S.phase = \"wait\";\n    S.timer = 0.5;\n  }\n  if (S.phase === \"wait\") {\n    S.timer -= d;\n    if (S.timer \u003c= 0) {\n      S.phase = \"solve\";\n      S.i = 0;\n      S.u = 0;\n    }\n  } else if (S.phase === \"solve\" || S.phase === \"mix\") {\n    S.u += d * (S.phase === \"mix\" ? cl(3 * S.rate, 6, 14) : S.rate);\n    while (S.u >= 1 && S.i \u003c S.list.length) {\n      apply(S.b, S.list[S.i++]);\n      S.u -= 1;\n    }\n    if (S.i >= S.list.length) {\n      S.u = 0;\n      if (S.phase === \"solve\") {\n        S.phase = \"cheer\";\n        S.timer = 2.4;\n      } else {\n        S.list = solve(S.b);\n        S.phase = \"wait\";\n        S.timer = 0.7;\n      }\n    }\n  } else if (S.phase === \"cheer\") {\n    S.timer -= d;\n    if (S.timer \u003c= 0) {\n      S.phase = \"mix\";\n      S.list = scramble(S.b, S.k);\n      S.i = 0;\n      S.u = 0;\n    }\n  }\n}\n\nfunction put(buf, x, y, c, f) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] = c[0] * f;\n  buf[o + 1] = c[1] * f;\n  buf[o + 2] = c[2] * f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { buf, b, c0, c1 } = S, hT = 0.58 + S.hue, hP = hT + 0.33, [pa, pb] = SWAPS[S.sw];\n  const sliding = (S.phase === \"solve\" || S.phase === \"mix\") && S.i \u003c S.list.length;\n  const from = sliding ? S.list[S.i] : -1, to = sliding ? b.indexOf(0) : -1, u = sliding ? ease(S.u) : 0;\n  // The empty square after this slide, and the boards' two counts there.\n  const after = Int8Array.from(b);\n  if (sliding) apply(after, from);\n  const hole = after.indexOf(0);\n  const cheer = S.phase === \"cheer\" ? 2.4 - S.timer : -1;\n\n  // The trays: dark, with a frame round each board.\n  const tray = hsv(hT, 0.5, 0.05, [0, 0, 0]), rim = hsv(hT, 0.35, 0.22, [0, 0, 0]);\n  for (let y = 0; y \u003c H; y++) {\n    const yb = y & 63;\n    for (let x = 0; x \u003c W; x++) put(buf, x, y, x === 0 || x === W - 1 || yb === 0 || yb === 63 ? rim : tray, 255);\n  }\n\n  for (let board = 0; board \u003c 2; board++) {\n    const oy = board * 64;\n    // The count, under the empty square.\n    const n = board ? parityCount(after, pa, pb) : parityCount(after, 0, 0);\n    hsv(board ? hP : hT - 0.25, 0.65, sliding ? 0.75 * u : 0.75, c0);\n    const s = String(n), hx = (hole & 3) * C, hy = oy + (hole >> 2) * C, tw = s.length * 4 - 1;\n    for (let j = 0; j \u003c s.length; j++) {\n      const g = SMALL[+s[j]];\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\") put(buf, hx + 8 - (tw >> 1) + 4 * j + q, hy + 6 + r, c0, 255);\n    }\n\n    for (let cell = 0; cell \u003c 16; cell++) {\n      const top = b[cell];\n      if (!top) continue;\n      const lab = board && top === pa ? pb : board && top === pb ? pa : top;\n      const moving = cell === from;\n      const cx = cell & 3, cy = cell >> 2;\n      let px = cx * C, py = cy * C, home = lab === cell + 1 ? 1 : 0;\n      if (moving) {\n        px = round(px + ((to & 3) - cx) * C * u);\n        py = round(py + ((to >> 2) - cy) * C * u);\n        home = home * (1 - u) + (lab === to + 1 ? u : 0);\n      }\n      py += oy;\n      const pair = lab === pa || lab === pb;\n      let v = 0.4 + 0.5 * home, sat = 0.62 - 0.12 * home, white = 0;\n      if (cheer >= 0) {\n        if (!board) {\n          const w = cheer - 0.08 * (cx + cy);\n          white = w > 0 && w \u003c 0.7 ? 0.6 * Math.sin((PI * w) / 0.7) : 0;\n        } else if (pair) {\n          const blink = 0.5 + 0.5 * cos(2 * PI * 2.5 * cheer);\n          v = 0.25 + 0.75 * blink;\n          sat = 0.75 - 0.5 * blink;\n        }\n      }\n      hsv(pair ? hP : hT, sat, v, c0);\n      for (let i = 0; i \u003c 3; i++) c0[i] = c0[i] + (1 - c0[i]) * white;\n      // Face 14 by 14 with a one-LED bevel, figures cut dark into it.\n      for (let y = 1; y \u003c 15; y++)\n        for (let x = 1; x \u003c 15; x++) {\n          const f = y === 1 || x === 1 ? 1.35 : y === 14 || x === 14 ? 0.55 : 1;\n          c1[0] = min(1, c0[0] * f);\n          c1[1] = min(1, c0[1] * f);\n          c1[2] = min(1, c0[2] * f);\n          put(buf, px + x, py + y, c1, 255);\n        }\n      const s2 = String(lab), wd = s2.length === 1 ? BIG[lab][0].length : 3 + 1 + BIG[lab - 10][0].length;\n      let x0 = px + 1 + ((14 - wd + 1) >> 1);\n      for (let j = 0; j \u003c s2.length; j++) {\n        const g = BIG[+s2[j]];\n        for (let r = 0; r \u003c 9; r++) for (let q = 0; q \u003c g[r].length; q++) if (g[r][q] === \"#\") put(buf, x0 + q, py + 3 + r, c0, 255 * 0.1);\n        x0 += g[0].length + 1;\n      }\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, round(buf[o]), round(buf[o + 1]), round(buf[o + 2]));\n}\n","gaussian-zeros":"// ===== Patternflow pattern =====\n// Title:   Gaussian Zeros\n// Family:  noise\n// Idea:    The zeros of the planar Gaussian analytic function fill the upper half, each a black point ringed by the colour wheel of the function's phase, and drift as its random coefficients turn, while the lower half draws Poisson points of the same density with the same marks and the same speed, so the upper half stays an even foam of cells while the lower one piles its points into clumps and leaves dark holes between them.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the zeros of the planar Gaussian analytic function (Mikhail Sodin and Boris Tsirelson, Random complex zeroes, 2004; J. Ben Hough, Manjunath Krishnapur, Yuval Peres and Bálint Virág, Zeros of Gaussian Analytic Functions and Determinantal Point Processes, 2009), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=0..1, Focus=0..1\n//\n// Knob 1: Hue. Adds a turn to every phase before it is painted, so each wheel turns round its black point. At 0 phase 0 is red, a third of a turn green and two thirds blue; at 0.5 phase 0 is cyan. The ground stays deep indigo.\n// Knob 2: Speed. How fast the coefficients turn: at 2 each of the three Gaussians in a coefficient turns at 0.3 to 0.9 radians a second, and a zero moves 0.48 units, 2.4 LEDs, a second on average. The Poisson points wander at the same mean speed. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Scale. LEDs to one unit of the plane, 5 at 0 and 3.5 at 1. Each half is 64 by 63 LEDs: 12.8 by 12.6 units and 51 zeros on average at 0, 18.3 by 18 units and 105 zeros at 1, where the upper half turns into a fine, even weave and the holes in the lower one stand out the most.\n// Knob 4: Focus. How far a mark spreads, rho = 4.4 - 2.6 Focus LEDs: 4.24 at the opening 0.06, where a lone mark's brightest ring sits 3 LEDs from its point and neighbouring zeros, 6.2 LEDs apart on average, run together into a foam; 3.1 at 0.5; 1.8 at 1, where every point is a small separate wheel and the two halves are the two point patterns bare.\n\n// The planar Gaussian analytic function is\n//\n//   f(z) = sum_n xi_n z^n / sqrt(n!),\n//\n// the xi_n independent standard complex Gaussians. E f(z) conj f(w) =\n// exp(z conj w), so |f(z)|^2 exp(-|z|^2) has the same law at every z, and\n// the zeros of f form a point process that no translation or rotation of\n// the plane changes, with 1/pi zeros to each unit of area. They are not\n// independent. A zero makes the function small around it, which leaves\n// little room for another, so the zeros keep apart and spread far more\n// evenly than Poisson points of the same density. Counted in Node over 40\n// runs of 30 s, a sample every 3 s, a half of this panel holds 51.3 zeros\n// with a spread of 1.7 against 51.7 and 6.1 Poisson points, a zero's\n// nearest neighbour is 1.23 units away on average against 0.88 (0.886 in\n// theory), and 3.0% of zeros have a neighbour within 0.6 units against\n// 30.8% of Poisson points (1 - exp(-0.36) = 30.2%).\n//\n// The upper half is the window of the plane round z = 0, 64 by 63 LEDs at\n// 5 LEDs a unit. f is summed by Horner to |z|^2 + 4.5|z| + 8 terms, past\n// which the terms are negligible, on every other LED. A cell of that grid\n// holds a zero when arg f winds once round it; far from 0, arg f turns by\n// Im(h conj z) over a step h even where there is no zero, so each step is\n// read against that turn. Newton, on f(z) exp(-z conj z0) so that the\n// growth of f does not throw it, puts the zero in place. Each coefficient\n// is the sum of three standard complex Gaussians turning at their own\n// rates, over sqrt 3: again a standard complex Gaussian at every moment,\n// so at every frame f is exactly a GAF, and the zeros drift and dodge.\n//\n// The colour is the phase seen from the zero itself. Translating a GAF,\n// g(w) = exp(-w conj a - |a|^2/2) f(a + w), gives a GAF again, and its\n// phase arg f(a + w) - Im(w conj a) loses the fast background turn that\n// arg f has far from 0, the turn that would otherwise stripe the corners.\n// Round each zero a the pattern takes g's Taylor series to w^5 and paints\n// its phase as the wheel; every wheel runs the same way round, as the zeros\n// of an analytic function must. A mark multiplies the brightness field by\n// 1 - exp(-d^2 / rho^2), black at the point and brightest where the field\n// is 0.4. Where marks overlap their wheels vote, and wheels that disagree\n// cancel towards white, drawing pale seams between the cells.\n//\n// The lower half holds 215 points on a 26 by 26 unit torus, uniform and\n// each moving on its own with a velocity that turns slowly, which keeps\n// them a Poisson process of density 1/pi in the window. They get the same\n// marks with a plain wheel each.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, sin, cos, atan2, log, round, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// The GAF fills rows 0 .. HG - 1 and the Poisson points rows HP .. H - 1.\n// f is evaluated on every other LED, MG LEDs past the GAF's edges so that\n// zeros just outside still mark the LEDs near them.\nconst HG = 63, HP = 65, MG = 6;\nconst GW = (W + 2 * MG) / 2 + 1, GH = floor((HG + 2 * MG) / 2) + 2;\n// Terms kept of the series, turning Gaussians per coefficient, Taylor\n// terms kept round a zero.\nconst NMAX = 270, NJ = 3, NT = 6;\n// The Poisson torus in units, centred on the lower half: wider than the\n// half at the smallest Scale by more than any mark reaches.\nconst TW = 26, TH = 26;\n// Poisson speed per unit of time, matched to the zeros' mean speed.\nconst VP = 0.39;\n\nfunction gauss() {\n  return sqrt(-2 * log(max(1e-12, Math.random()))) * cos(TAU * Math.random());\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const g = new Float64Array(NMAX * NJ * 2), om = new Float64Array(NMAX * NJ);\n  for (let i = 0; i \u003c NMAX * NJ; i++) {\n    // A standard complex Gaussian: E|g|^2 = 1, each part variance 1/2.\n    g[2 * i] = gauss() * Math.SQRT1_2;\n    g[2 * i + 1] = gauss() * Math.SQRT1_2;\n    om[i] = (Math.random() \u003c 0.5 ? -1 : 1) * (0.3 + 0.6 * Math.random());\n  }\n  // 1 / sqrt(n!)\n  const isf = new Float64Array(NMAX);\n  let lf = 0;\n  for (let n = 0; n \u003c NMAX; n++) {\n    if (n > 0) lf += log(n);\n    isf[n] = exp(-lf / 2);\n  }\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, ppu: 5, rho: 4.2,\n    g, om, isf, c: new Float64Array(NMAX * 2),\n    ar: new Float32Array(GW * GH), zx: [], zy: [],\n    e: new Float32Array(W * H),\n    wr: new Float32Array(W * H), wi: new Float32Array(W * H), ws: new Float32Array(W * H),\n    G: new Float64Array(NT * 2), px: [], py: [], pvx: [], pvy: [], pth: [],\n    bg: [0, 0, 0], col: [0, 0, 0],\n  });\n  // Uniform points of density 1/pi on the torus, round(TW TH / pi) = 215\n  // of them, each placed and moved on its own: in a window a quarter of the\n  // torus or less that is a Poisson process to within the count.\n  const n = round((TW * TH) / PI);\n  for (let i = 0; i \u003c n; i++) {\n    S.px.push(Math.random() * TW);\n    S.py.push(Math.random() * TH);\n    S.pvx.push(gauss());\n    S.pvy.push(gauss());\n    S.pth.push(TAU * Math.random());\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.ppu = 5 - 1.5 * cl(k[2] || 0, 0, 1);\n  S.rho = 4.4 - 2.6 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const ds = d * S.speed * 0.5;\n  S.t += ds;\n  // Each Poisson point wanders with a velocity that turns slowly, and on\n  // its own, so the points stay a Poisson process.\n  const a = exp(-0.4 * ds), b = sqrt(1 - a * a);\n  for (let i = 0; i \u003c S.px.length; i++) {\n    S.pvx[i] = S.pvx[i] * a + gauss() * b;\n    S.pvy[i] = S.pvy[i] * a + gauss() * b;\n    S.px[i] = (S.px[i] + S.pvx[i] * VP * ds + TW) % TW;\n    S.py[i] = (S.py[i] + S.pvy[i] * VP * ds + TH) % TH;\n    S.pth[i] += 0.5 * ds * S.pvx[i];\n  }\n}\n\nconst terms = (r2) => min(NMAX, floor(r2 + 4.5 * sqrt(r2) + 8));\n\n// f(z) and f'(z) by Horner.\nconst F = [0, 0, 0, 0];\nfunction evalF(c, x, y) {\n  let fr = 0, fi = 0, dr = 0, di = 0;\n  for (let n = terms(x * x + y * y) - 1; n >= 0; n--) {\n    const t1 = dr * x - di * y + fr, t2 = dr * y + di * x + fi;\n    dr = t1;\n    di = t2;\n    const a = fr * x - fi * y + c[2 * n], b = fr * y + fi * x + c[2 * n + 1];\n    fr = a;\n    fi = b;\n  }\n  F[0] = fr;\n  F[1] = fi;\n  F[2] = dr;\n  F[3] = di;\n}\n\n// Round a zero a: the Taylor coefficients T_m = f^(m)(a) / m! by repeated\n// synthetic division, then those of the GAF seen from a,\n// g(w) = exp(-w conj a) f(a + w), G_m = sum_l T_(m-l) (-conj a)^l / l!,\n// whose phase is arg f(a + w) - Im(w conj a).\nconst BUF = new Float64Array(NMAX * 2), T = new Float64Array(NT * 2);\nfunction local(c, ax, ay, G) {\n  const N = terms(ax * ax + ay * ay);\n  for (let n = 0; n \u003c 2 * N; n++) BUF[n] = c[n];\n  for (let m = 0; m \u003c NT; m++) {\n    // Divide by (z - a) in place: the quotient lands in BUF[0 .. N - 2 - m]\n    // and the remainder is T_m.\n    let rr = 0, ri = 0;\n    for (let n = N - 1 - m; n >= 0; n--) {\n      const a = rr * ax - ri * ay + BUF[2 * n], b = rr * ay + ri * ax + BUF[2 * n + 1];\n      BUF[2 * n] = rr;\n      BUF[2 * n + 1] = ri;\n      rr = a;\n      ri = b;\n    }\n    T[2 * m] = rr;\n    T[2 * m + 1] = ri;\n  }\n  let sc = 0;\n  for (let m = 1; m \u003c NT; m++) {\n    let gr = 0, gi = 0, pr = 1, pi = 0;\n    for (let l = 0; l \u003c= m; l++) {\n      if (l > 0) {\n        const qr = (-pr * ax - pi * ay) / l, qi = (pr * ay - pi * ax) / l;\n        pr = qr;\n        pi = qi;\n      }\n      gr += T[2 * (m - l)] * pr - T[2 * (m - l) + 1] * pi;\n      gi += T[2 * (m - l)] * pi + T[2 * (m - l) + 1] * pr;\n    }\n    G[2 * m] = gr;\n    G[2 * m + 1] = gi;\n    sc = max(sc, sqrt(gr * gr + gi * gi));\n  }\n  // Only the phase is used, so scale freely.\n  G[0] = G[1] = 0;\n  for (let m = 2; m \u003c 2 * NT; m++) G[m] /= sc || 1;\n  return G.slice();\n}\n\n// One mark at (qx, qy), rho LEDs across: the factor 1 - exp(-d^2 / rho^2)\n// on e, and a vote for the hue, a unit vector weighted exp(-d^2 / 2 rho^2):\n// the phase of the zero's own series G, or for a Poisson point a plain\n// wheel turned by th.\nfunction stamp(S, qx, qy, y0, y1, G, th) {\n  const { e, wr, wi, ws, ppu, rho } = S, ct = cos(th), st = sin(th);\n  const R = 2.3 * rho, ir = 1 / (rho * rho);\n  for (let py = max(y0, floor(qy - R)); py \u003c= min(y1, floor(qy + R) + 1); py++)\n    for (let px = max(0, floor(qx - R)); px \u003c= min(W - 1, floor(qx + R) + 1); px++) {\n      const dx = px - qx, dy = py - qy, d2 = dx * dx + dy * dy, p = py * W + px;\n      if (d2 * ir > 5) continue;\n      const E = exp(-d2 * ir);\n      e[p] *= 1 - E;\n      let a, b;\n      if (G) {\n        const ux = dx / ppu, uy = dy / ppu;\n        let sr = 0, si = 0;\n        for (let m = NT - 1; m >= 1; m--) {\n          const qa = sr * ux - si * uy + G[2 * m], qb = sr * uy + si * ux + G[2 * m + 1];\n          sr = qa;\n          si = qb;\n        }\n        a = sr * ux - si * uy;\n        b = sr * uy + si * ux;\n      } else {\n        a = dx * ct - dy * st;\n        b = dx * st + dy * ct;\n      }\n      const n = sqrt(a * a + b * b), w = sqrt(E);\n      if (n > 0) {\n        wr[p] += (w * a) / n;\n        wi[p] += (w * b) / n;\n      }\n      ws[p] += w;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { g, om, isf, c, ar, ppu, e, wr, wi, ws, bg, col } = S, t = S.t;\n  // The coefficients at time t, each a sum of NJ complex Gaussians turning\n  // at their own rates, which is again a standard complex Gaussian.\n  const sn = 1 / sqrt(NJ);\n  for (let n = 0; n \u003c NMAX; n++) {\n    let re = 0, im = 0;\n    for (let j = 0; j \u003c NJ; j++) {\n      const q = n * NJ + j, a = om[q] * t, ca = cos(a), sa = sin(a);\n      re += g[2 * q] * ca - g[2 * q + 1] * sa;\n      im += g[2 * q] * sa + g[2 * q + 1] * ca;\n    }\n    c[2 * n] = re * sn * isf[n];\n    c[2 * n + 1] = im * sn * isf[n];\n  }\n  // f on the grid, z = 0 in the middle of the upper half.\n  const cx = (W - 1) / 2, cy = (HG - 1) / 2, st = 2 / ppu, x0 = (-MG - cx) / ppu, y0 = (-MG - cy) / ppu;\n  for (let j = 0; j \u003c GH; j++) {\n    const y = y0 + j * st;\n    for (let i = 0; i \u003c GW; i++) {\n      const x = x0 + i * st, r2 = x * x + y * y;\n      let fr = 0, fi = 0;\n      for (let n = terms(r2) - 1; n >= 0; n--) {\n        const a = fr * x - fi * y + c[2 * n], b = fr * y + fi * x + c[2 * n + 1];\n        fr = a;\n        fi = b;\n      }\n      ar[j * GW + i] = atan2(fi, fr);\n    }\n  }\n  // The zeros: grid cells round which arg f winds once. Each step is read\n  // against the step the background makes, Im(h conj z), which far from 0\n  // is too big to read a winding off plain differences. Newton finishes.\n  const step = (p, q, xa, ya, xb, yb) => {\n    const bk = ((yb - ya) * (xa + xb) - (xb - xa) * (ya + yb)) / 2;\n    let dd = ar[q] - ar[p] - bk;\n    dd -= TAU * round(dd / TAU);\n    return dd + bk;\n  };\n  const zx = [], zy = [], zg = [];\n  for (let j = 0; j \u003c GH - 1; j++)\n    for (let i = 0; i \u003c GW - 1; i++) {\n      const p = j * GW + i, xa = x0 + i * st, ya = y0 + j * st, xb = xa + st, yb = ya + st;\n      const w = step(p, p + 1, xa, ya, xb, ya) + step(p + 1, p + 1 + GW, xb, ya, xb, yb) + step(p + 1 + GW, p + GW, xb, yb, xa, yb) + step(p + GW, p, xa, yb, xa, ya);\n      if (w \u003c PI) continue;\n      let x = xa + st / 2, y = ya + st / 2;\n      for (let it = 0; it \u003c 4; it++) {\n        // Newton on f(z) exp(-z conj z0), which has f's zeros without its\n        // growth: the step is -1 / (f'/f - conj z0).\n        evalF(c, x, y);\n        const m2 = F[0] * F[0] + F[1] * F[1];\n        if (!(m2 > 0)) break;\n        const lr = (F[2] * F[0] + F[3] * F[1]) / m2 - x, li = (F[3] * F[0] - F[2] * F[1]) / m2 + y, l2 = lr * lr + li * li;\n        if (!(l2 > 0)) break;\n        x -= lr / l2;\n        y += li / l2;\n      }\n      if (!(abs(x - xa - st / 2) \u003c 2 * st && abs(y - ya - st / 2) \u003c 2 * st)) continue;\n      let dup = false;\n      for (let k = 0; k \u003c zx.length; k++) if ((zx[k] - x) ** 2 + (zy[k] - y) ** 2 \u003c 0.01) dup = true;\n      if (dup) continue;\n      zx.push(x);\n      zy.push(y);\n      zg.push(local(c, x, y, S.G));\n    }\n  S.zx = zx;\n  S.zy = zy;\n  e.fill(1);\n  wr.fill(0);\n  wi.fill(0);\n  ws.fill(0);\n  for (let k = 0; k \u003c zx.length; k++) stamp(S, cx + zx[k] * ppu, cy + zy[k] * ppu, 0, HG - 1, zg[k], 0);\n  const sx = cx - (TW / 2) * ppu, sy = (HP + H - 1) / 2 - (TH / 2) * ppu;\n  for (let k = 0; k \u003c S.px.length; k++) stamp(S, sx + S.px[k] * ppu, sy + S.py[k] * ppu, HP, H - 1, null, S.pth[k]);\n  const hue0 = S.hue;\n  hsv(0.7, 0.65, 0.15, bg);\n  for (let py = 0; py \u003c H; py++) {\n    if (py >= HG && py \u003c HP) {\n      for (let px = 0; px \u003c W; px++) display.setPixel(px, py, 0, 0, 0);\n      continue;\n    }\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, ee = e[p];\n      // Black at the point, the wheel brightest where e = 0.4, the ground\n      // beyond 0.85. Where wheels overlap their votes cancel towards white.\n      const u = ee \u003c 0.4 ? 0 : max(0, 1 - (ee - 0.4) / 0.45);\n      const ring = ee \u003c 0.4 ? sqrt(ee / 0.4) : u * sqrt(u);\n      const k = ring * min(1, ws[p] * 1.2), core = min(1, ee / 0.3) * (1 - k);\n      const coh = ws[p] > 1e-4 ? sqrt(wr[p] * wr[p] + wi[p] * wi[p]) / ws[p] : 0;\n      hsv(atan2(wi[p], wr[p]) / TAU + hue0, 0.95 * coh, 1, col);\n      display.setPixel(px, py, round((bg[0] * core + col[0] * k) * 255), round((bg[1] * core + col[1] * k) * 255), round((bg[2] * core + col[2] * k) * 255));\n    }\n  }\n}\n","hopfield-letters":"// ===== Patternflow pattern =====\n// Title:   Hopfield Letters\n// Family:  type\n// Idea:    A Hopfield network of 1,536 neurons, each a 2 by 2 block of LEDs, holds the letters A, T, O and M in its Hebbian weights, and every few seconds it is handed one of them buried under noise and turns its neurons over one at a time, each flip lighting up as it happens, until the energy, traced underneath, can fall no further and the letter stands clean; store more letters and the same descent ends in a blurred blend that is none of them.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hopfield network (John Hopfield, 1982), its storage capacity 0.138 N (Daniel Amit, Hanoch Gutfreund and Haim Sompolinsky, 1985), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Load=0..1, Noise=0..1\n//\n// Knob 1: Hue. Turns both states round the wheel. At 0 a neuron at +1 is gold and one at -1 a dim navy, at 0.25 green on plum, at 0.5 blue on a dim olive, at 0.75 magenta on a dim green.\n// Knob 2: Speed. Neuron updates a second, 512 for each unit: 1,024 at the opening 2, so one sweep through all 1,536 neurons takes 1.5 s; 0.2 takes 15 s a sweep and 3 takes 1 s. Once no neuron's field points against it the state stands for 1.6 s / Speed, 0.8 s at the opening, before the next cue.\n// Knob 3: Load. How many letters the weights hold, 4 at 0 and 10 at 1, added in the order A T O M H E K R S X. Four come back every time from a cue with 26.5% of its neurons wrong. The fifth, H, agrees with M on 90% of the neurons, and with five stored neither M nor H is a valley any more: M's cue ends a dozen neurons or so short of M, and H's cue mostly in a blend that overlaps M by 0.89 and H by 0.90. With six T still comes back 87% of the time and A 43%, from seven no cue finds its letter, and from eight every cue ends in a blend lower in energy than any stored letter. The labels under the bars show which letters are stored.\n// Knob 4: Noise. The share of a cue's neurons set wrong, 25% at 0 rising to 50% at 1; at the opening 0.06 it is 26.5%. At 50% the cue is pure noise and says nothing of the letter asked for, so the network falls into whichever valley is nearest: a stored letter, its negative (the ground lit and the letter dark), or a blend.\n// Buttons: K1 tap hands the network its next cue at once.\n\n// John Hopfield's network (PNAS, 1982) is N neurons that are each +1 or\n// -1 and a symmetric weight between every pair. To store letters xi^1 ...\n// xi^P it takes the Hebb rule, W_ij = (1/N) sum over mu of xi_i^mu xi_j^mu,\n// with W_ii = 0. A neuron updates by taking the sign of its field\n// h_i = sum_j W_ij s_j, and since the weights are symmetric every flip\n// lowers (or keeps) the energy E = -1/2 sum_ij W_ij s_i s_j, so updating\n// one neuron at a time must end in a state no single flip can improve:\n// a valley of E. The stored letters are valleys when they are few and\n// unlike each other, and a corrupted letter rolls down into its own.\n//\n// With the Hebb rule the field never needs the N by N weights: with\n// M_mu = sum_j xi_j^mu s_j, the state's overlap with letter mu,\n// N h_i = sum_mu xi_i^mu M_mu - P s_i, the last term taking the diagonal\n// out. A flip of neuron i changes every M_mu by 2 s_i xi_i^mu, so an\n// update costs P steps and the energy is E/N = -1/2 sum_mu m_mu^2 + P/2N\n// with m_mu = M_mu / N. The bars under the picture are the m_mu, and the\n// trace above them is E/N, which falls in steps between cues and never\n// rises while the network is left alone.\n//\n// Daniel Amit, Hanoch Gutfreund and Haim Sompolinsky (Physical Review\n// Letters, 1985) found that random patterns stay retrievable up to\n// P = 0.138 N, 212 patterns for these 1,536 neurons. Letters are not\n// random: they share a ground and many strokes. Here M and H agree on 90%\n// of their neurons (overlap 0.79), and R on 81% with each of E and K.\n// Sitting on letter mu, a neuron where every other stored letter\n// disagrees with mu feels a field of 1 minus the sum of mu's overlaps\n// with them, so once that sum passes 1 such a neuron turns against the\n// letter and the letter stops being a valley. Four letters, 0.26% of N,\n// are recalled every time; at seven no stored letter is a valley any\n// more, and blends of several letters, spurious valleys nobody stored,\n// take their place.\n\nconst W = 64, H = 128, GW = 32, GH = 48, N = GW * GH, CS = 2;\nconst { floor, round, min, max, abs, sqrt, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst LIST = \"ATOMHEKRSX\";\n// Rows of the panel under the network: the energy trace, the bars, the labels.\nconst TR0 = 98, TR1 = 109, BAR0 = 112, BAR1 = 121, LAB = 122, TN = 60;\n\n// The letters as strokes in a 10 by 16 box, drawn for this pattern, then\n// set at neuron resolution as every neuron within 3 neurons of a stroke.\nconst arc = (cx, cy, rx, ry, a0, a1, n) => {\n  const o = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    o.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return o;\n};\nconst STROKES = {\n  A: [[[0, 16], [5, 0], [10, 16]], [[2.2, 10.5], [7.8, 10.5]]],\n  T: [[[0, 0], [10, 0]], [[5, 0], [5, 16]]],\n  O: [arc(5, 8, 5, 8, 0, 360, 24)],\n  M: [[[0, 16], [0, 0], [5, 9], [10, 0], [10, 16]]],\n  H: [[[0, 0], [0, 16]], [[10, 0], [10, 16]], [[0, 8], [10, 8]]],\n  E: [[[10, 0], [0, 0], [0, 16], [10, 16]], [[0, 8], [8, 8]]],\n  K: [[[0, 0], [0, 16]], [[10, 0], [0, 9]], [[3.5, 6.5], [10, 16]]],\n  R: [[[0, 16], [0, 0], [5, 0], ...arc(5, 4, 5, 4, -90, 90, 8), [0, 8]], [[4, 8], [10, 16]]],\n  S: [[...arc(5, 4, 5, 4, -20, -270, 12), ...arc(5, 12, 5, 4, -90, 160, 12)]],\n  X: [[[0, 0], [10, 16]], [[10, 0], [0, 16]]],\n};\n// The same ten as 3 by 5 labels under the bars.\nconst SMALL = {\n  A: \".#. #.# ### #.# #.#\", T: \"### .#. .#. .#. .#.\", O: \"### #.# #.# #.# ###\", M: \"#.# ### ### #.# #.#\",\n  H: \"#.# #.# ### #.# #.#\", E: \"### #.. ### #.. ###\", K: \"#.# #.# ##. #.# #.#\", R: \"##. #.# ##. #.# #.#\",\n  S: \".## #.. .#. ..# ##.\", X: \"#.# #.# .#. #.# #.#\",\n};\n\nfunction segDist(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const t = l ? cl(((px - ax) * dx + (py - ay) * dy) / l, 0, 1) : 0;\n  const x = ax + t * dx - px, y = ay + t * dy - py;\n  return sqrt(x * x + y * y);\n}\n\nfunction letter(ch) {\n  const out = new Int8Array(N), HW = 3, M = 3, sx = (GW - 2 * M - 2 * HW) / 10, sy = (GH - 2 * M - 2 * HW) / 16;\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      let d = 1e9;\n      for (const pl of STROKES[ch])\n        for (let i = 0; i + 1 \u003c pl.length; i++) {\n          const a = pl[i], b = pl[i + 1];\n          d = min(d, segDist(x + 0.5, y + 0.5, M + HW + a[0] * sx, M + HW + a[1] * sy, M + HW + b[0] * sx, M + HW + b[1] * sy));\n        }\n      out[y * GW + x] = d \u003c= HW ? 1 : -1;\n    }\n  return out;\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const L = [...LIST].map(letter), K = L.length;\n  // Overlaps between the letters, for the energy each letter sits at.\n  const C = new Float32Array(K * K);\n  for (let a = 0; a \u003c K; a++)\n    for (let b = 0; b \u003c K; b++) {\n      let c = 0;\n      for (let p = 0; p \u003c N; p++) c += L[a][p] * L[b][p];\n      C[a * K + b] = c / N;\n    }\n  params.s = {\n    L, K, C, P: 4, s: new Int8Array(N), M: new Int32Array(K), flash: new Float32Array(N),\n    order: new Uint16Array(N), at: N, total: 0, hold: -1, cue: -1, budget: 0,\n    speed: 2, hue: 0, noise: 0.265, trace: new Float32Array(TN), tclock: 0, tn: 0, prev: false,\n    ink: [0, 0, 0], gnd: [0, 0, 0],\n  };\n  for (let i = 0; i \u003c N; i++) params.s.order[i] = i;\n}\n\nfunction overlaps(S) {\n  for (let m = 0; m \u003c S.K; m++) {\n    let v = 0;\n    const x = S.L[m];\n    for (let p = 0; p \u003c N; p++) v += x[p] * S.s[p];\n    S.M[m] = v;\n  }\n}\n\n// The next stored letter, with a share of its neurons set wrong.\nfunction kick(S) {\n  S.cue = (S.cue + 1) % S.P;\n  const x = S.L[S.cue];\n  for (let p = 0; p \u003c N; p++) {\n    const v = Math.random() \u003c S.noise ? -x[p] : x[p];\n    if (v !== S.s[p]) S.flash[p] = 0.5;\n    S.s[p] = v;\n  }\n  overlaps(S);\n  S.at = N;\n  S.hold = -1;\n}\n\nfunction energy(S) {\n  let e = 0;\n  for (let m = 0; m \u003c S.P; m++) e += (S.M[m] / N) * (S.M[m] / N);\n  return -0.5 * e + S.P / (2 * N);\n}\n\nfunction stable(S) {\n  const s = S.s, P = S.P;\n  for (let i = 0; i \u003c N; i++) {\n    let h = -P * s[i];\n    for (let m = 0; m \u003c P; m++) h += S.L[m][i] * S.M[m];\n    if (h * s[i] \u003c 0) return false;\n  }\n  return true;\n}\n\nfunction step(S) {\n  if (S.at >= N) {\n    // A new sweep in a fresh random order.\n    S.at = 0;\n    const o = S.order;\n    for (let i = N - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1)), t = o[i];\n      o[i] = o[j];\n      o[j] = t;\n    }\n  }\n  const i = S.order[S.at++], s = S.s, P = S.P;\n  let h = -P * s[i];\n  for (let m = 0; m \u003c P; m++) h += S.L[m][i] * S.M[m];\n  const v = h > 0 ? 1 : h \u003c 0 ? -1 : s[i];\n  if (v !== s[i]) {\n    for (let m = 0; m \u003c S.K; m++) S.M[m] += 2 * v * S.L[m][i];\n    s[i] = v;\n    S.flash[i] = 1;\n    S.total++;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.noise = 0.25 + 0.25 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const P = 4 + round(cl(k[2] || 0, 0, 1) * 6);\n  if (P !== S.P) {\n    S.P = P;\n    S.cue = S.cue % P;\n    S.hold = -1;\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (S.cue \u003c 0 || (btn && !S.prev)) kick(S);\n  S.prev = btn;\n  for (let p = 0; p \u003c N; p++) S.flash[p] = max(0, S.flash[p] - d * 3.5);\n  if (S.hold >= 0) {\n    S.hold -= d;\n    if (S.hold \u003c 0) kick(S);\n  } else {\n    S.budget += d * S.speed * 512;\n    const before = S.total;\n    while (S.budget >= 1) {\n      S.budget -= 1;\n      step(S);\n    }\n    // No flip this frame: if no neuron's field opposes it, the state is a\n    // valley, and it stands for 1.6 s / Speed before the next cue.\n    if (S.total === before && stable(S)) S.hold = 1.6 / S.speed;\n  }\n  // The energy, ten samples a second, the newest at the right.\n  S.tclock += d;\n  while (S.tclock >= 0.1) {\n    S.tclock -= 0.1;\n    S.trace.copyWithin(0, 1);\n    S.trace[TN - 1] = energy(S);\n    S.tn = min(TN, S.tn + 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const ink = hsv(S.hue + 0.13, 0.85, 1, S.ink), gnd = hsv(S.hue + 0.64, 0.75, 0.3, S.gnd);\n  const ir = ink[0] * 255, ig = ink[1] * 255, ib = ink[2] * 255, gr = gnd[0] * 255, gg = gnd[1] * 255, gb = gnd[2] * 255;\n  // The network: +1 in the letter colour, -1 in the dim ground, a neuron\n  // that has just flipped flaring towards white.\n  for (let y = 0; y \u003c 96; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = floor(y / CS) * GW + floor(x / CS), f = S.flash[p] * S.flash[p];\n      let r, g, b;\n      if (S.s[p] > 0) (r = ir), (g = ig), (b = ib);\n      else (r = gr), (g = gg), (b = gb);\n      display.setPixel(x, y, round(r + (255 - r) * f), round(g + (255 - g) * f), round(b + (255 - b) * f));\n    }\n  for (let y = 96; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n  // The energy trace: 0 at the top row, and the deepest stored letter's\n  // own energy three quarters of the way down, marked by a dotted line.\n  let el = 0;\n  for (let a = 0; a \u003c S.P; a++) {\n    let e = 0;\n    for (let b = 0; b \u003c S.P; b++) e += S.C[a * S.K + b] * S.C[a * S.K + b];\n    el = min(el, -0.5 * e + S.P / (2 * N));\n  }\n  const span = TR1 - TR0, ey = (e) => TR0 + cl((-e / -el) * 0.75, 0, 1) * span;\n  const yl = round(ey(el));\n  for (let x = 2; x \u003c W - 2; x += 3) display.setPixel(x, yl, round(gr * 1.6), round(gg * 1.6), round(gb * 1.6));\n  let last = -1;\n  for (let i = TN - S.tn; i \u003c TN; i++) {\n    const x = 2 + i, y = round(ey(S.trace[i]));\n    const a = last \u003c 0 ? y : last, lo = min(a, y), hi = max(a, y);\n    for (let yy = lo; yy \u003c= hi; yy++) display.setPixel(x, yy, round(ir), round(ig), round(ib));\n    for (let yy = hi + 1; yy \u003c= TR1; yy++) display.setPixel(x, yy, round(gr * 0.8), round(gg * 0.8), round(gb * 0.8));\n    last = y;\n  }\n  // One bar per letter in LIST: its overlap with the state, |m| tall, in\n  // the letter colour when m > 0 and in the ground colour lifted when the\n  // state leans to the letter's negative. Letters not stored are grey.\n  for (let m = 0; m \u003c S.K; m++) {\n    const x0 = 2 + m * 6, stored = m \u003c S.P, v = S.M[m] / N, hgt = round(abs(v) * (BAR1 - BAR0 + 1));\n    for (let y = BAR1 - hgt + 1; y \u003c= BAR1; y++)\n      for (let x = x0; x \u003c x0 + 4; x++) {\n        if (!stored) display.setPixel(x, y, 46, 46, 46);\n        else if (v > 0) display.setPixel(x, y, round(ir), round(ig), round(ib));\n        else display.setPixel(x, y, round(min(255, gr * 2.6)), round(min(255, gg * 2.6)), round(min(255, gb * 2.6)));\n      }\n    const g = SMALL[LIST[m]].split(\" \"), cue = stored && m === S.cue;\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++)\n        if (g[r][q] === \"#\") {\n          if (cue) display.setPixel(x0 + q, LAB + r, 255, 255, 255);\n          else if (stored) display.setPixel(x0 + q, LAB + r, round(ir * 0.8), round(ig * 0.8), round(ib * 0.8));\n          else display.setPixel(x0 + q, LAB + r, 60, 60, 60);\n        }\n  }\n}\n","ishihara-plate":"// ===== Patternflow pattern =====\n// Title:   Ishihara Plate\n// Family:  type\n// Idea:    Two colour-vision plates stand one above the other, each a disc of about 370 dots on black, from single LEDs to 21-LED blots, where the dots inside a numeral differ from the dots around it only along a line of colours one kind of dichromat cannot tell apart, the protan line in the top plate and the deutan line in the bottom one; every 3 s a plate is repainted dot by dot and a new numeral comes up through the same dots, and turned towards a simulated protan or deutan eye the plate built on that eye's line loses its numeral into a field of yellow and blue.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: pseudo-isochromatic plates (Shinobu Ishihara, Tests for Colour-Blindness, 1917), dichromat simulation (Françoise Viénot, Hans Brettel and John Mollon, 1999), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Tint=0..1, Speed=0.2..3, Dichromacy=-1..1, Dots=0..1\n//\n// Knob 1: Tint. Adds the same blue to every dot, 0.55 of full in linear light at 1. At 0 the grounds are green and azure and the numerals yellow, amber, red and magenta; at 1 the greens turn teal, the yellows cream and the reds pink. Blue is kept by both simulations and added to figure and ground alike, so a numeral that vanishes still vanishes.\n// Knob 2: Speed. A plate holds its numeral 6 / Speed seconds, 3 s at the opening 2, with the bottom plate half a period behind the top; 30 s at 0.2 and 2 s at 3. When a new numeral comes, every dot of the plate draws a new colour and brightness and takes them at its own moment within the first quarter of the period (0.75 s at the opening), dimming to 15% for 0.1 s either side.\n// Knob 3: Dichromacy. 0 is normal vision; towards -1 the colours slide to what a protanope would see, towards +1 a deuteranope, mixed in linear light. At -1 the top numeral has exactly its ground's colours and is gone, while the bottom one is still there as darker olive dots; at +1 the bottom numeral is gone and the top one keeps a slightly brighter yellow that its blue dots mostly hide. At -0.5 the top numeral is half faded and the bottom one still reads.\n// Knob 4: Dots. Every dot's radius times 1 at 0 up to 1.9 at 1, in 13 steps, each a new deal of both plates. At 0 a plate holds about 220 single LEDs, 55 five-LED crosses, 36 three-by-three squares and 60 larger dots of 13 and 21 LEDs; at 1 about 270 dots, 200 of them still single LEDs and the rest 9 to 61 LEDs, and the numeral's strokes widen from 7.2 to 9.5 LEDs, about one big dot across, so the numeral starts to break up.\n\n// Shinobu Ishihara's plates hide a numeral in a disc of dots. The dots\n// inside it and the dots around it are drawn from colours a colour-normal\n// eye sees as different hues, red and orange against green, but that a\n// dichromat sees as the same, and their brightness is varied from dot to\n// dot so lightness gives nothing away. A protanope lacks the L cones and a\n// deuteranope the M cones, so two colours whose cone signals differ only in\n// L, or only in M, look alike to them: those differences are the protan and\n// deutan confusion lines.\n//\n// Here every dot draws a ground colour from a palette of five and a\n// brightness from 0.8 to 1 (in linear light). A dot inside the numeral\n// moves its colour along the plate's confusion line, the change of L alone\n// in the top plate and of M alone in the bottom one, until its red reaches\n// 0.95 or its green 0.02, so the greens turn yellow, amber or red and the\n// azures magenta. Figure and ground then differ in L alone, or in M alone,\n// and nowhere else.\n//\n// The simulation is the single-plane method of Viénot, Brettel and Mollon\n// (1999): convert to cone signals, rebuild the missing cone's signal from\n// the other two so that black, white and the blue primary keep their\n// colour, and convert back. A difference in L alone vanishes under the\n// protan rebuild, a difference in M alone under the deutan one, so at the\n// knob's end each numeral dot takes exactly the colour of a ground dot with\n// the same palette entry and brightness, and the two sets are drawn alike.\n// The cone matrix is the RGB-to-LMS matrix the common simulators use, and\n// the two rebuilds come out as L = 2.0234 M - 2.5258 S and\n// M = 0.4942 L + 1.2483 S.\n//\n// The dots are thrown at the disc on whole LEDs, largest first, and one\n// stays only if none of its LEDs touches another dot's side by side, so a\n// dark seam runs between every two and the plate is busy with small edges.\n\nconst W = 64, H = 128, R = 32;\nconst { floor, round, min, max, abs, sqrt, pow, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Linear RGB to cone signals L, M, S, and back.\nconst A = [17.8824, 43.5161, 4.11935, 3.45565, 27.1554, 3.86714, 0.0299566, 0.184309, 1.46709];\nfunction inv3(m) {\n  const [a, b, c, d, e, f, g, h, i] = m, x = e * i - f * h, y = f * g - d * i, z = d * h - e * g, det = a * x + b * y + c * z;\n  return [x / det, (c * h - b * i) / det, (b * f - c * e) / det, y / det, (a * i - c * g) / det, (c * d - a * f) / det, z / det, (b * g - a * h) / det, (a * e - b * d) / det];\n}\nconst AI = inv3(A);\nconst mul = (m, v) => [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];\n// The missing cone's signal rebuilt from the other two so that white and\n// the blue primary keep their colour.\nfunction plane(miss) {\n  const w = mul(A, [1, 1, 1]), b = mul(A, [0, 0, 1]), o = miss === 0 ? 1 : 0;\n  // u w[o] + v w[2] = w[miss], u b[o] + v b[2] = b[miss]\n  const det = w[o] * b[2] - w[2] * b[o];\n  return [(w[miss] * b[2] - w[2] * b[miss]) / det, (w[o] * b[miss] - w[miss] * b[o]) / det];\n}\nconst PROT = plane(0), DEUT = plane(1);\n// Confusion directions: a change of L alone (protan) or M alone (deutan).\nconst DL = mul(AI, [1, 0, 0]), DM = mul(AI, [0, -1, 0]);\n\nfunction simulate(c, kind, amt, o) {\n  if (amt \u003c= 0) {\n    o[0] = c[0], o[1] = c[1], o[2] = c[2];\n    return o;\n  }\n  const lms = mul(A, c);\n  if (kind \u003c 0) lms[0] = PROT[0] * lms[1] + PROT[1] * lms[2];\n  else lms[1] = DEUT[0] * lms[0] + DEUT[1] * lms[2];\n  const s = mul(AI, lms);\n  for (let k = 0; k \u003c 3; k++) o[k] = c[k] + (s[k] - c[k]) * amt;\n  return o;\n}\n\n// The ground colours of each plate in linear RGB, greens and azures. The\n// protan line raises red and barely lowers green, so the top plate's\n// greens turn yellow and amber; the deutan line takes 0.41 of green away\n// for each unit of red, so the bottom plate's turn red and orange.\nconst GROUND = [\n  [[0, 1, 0.005], [0, 0.5, 0.005], [0, 0.13, 1], [0, 0.75, 0.005], [0, 0.2, 1]],\n  [[0, 0.42, 0.005], [0, 0.6, 0.005], [0, 0.42, 1], [0, 0.45, 0.8], [0, 0.55, 0.005]],\n];\nconst FR = 0.95, DIP = 0.1;\n\n// Numerals as strokes in a 6 by 10 box, drawn for this pattern.\nconst arc = (cx, cy, rx, ry, a0, a1, n) => {\n  const o = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    o.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return o;\n};\nconst DIGITS = [\n  [arc(3, 5, 3, 5, 0, 360, 24)],\n  [[[1, 2.2], [3.2, 0], [3.2, 10]]],\n  [[...arc(3, 3, 3, 3, 195, 375, 10), [0, 10], [6, 10]]],\n  [[...arc(3, 2.6, 2.8, 2.6, 200, 450, 10), ...arc(3, 7.3, 3, 2.7, -90, 160, 10)]],\n  [[[4.4, 10], [4.4, 0], [0, 7], [6, 7]]],\n  [[[5.6, 0], [1, 0], [0.5, 4.3], ...arc(3, 6.8, 3, 3.2, -125, 150, 12)]],\n  [[...arc(3.5, 5.5, 2.8, 5.5, -55, -175, 7), ...arc(3, 7, 3, 3, 180, 540, 16)]],\n  [[[0, 0], [6, 0], [2.2, 10]]],\n  [arc(3, 2.5, 2.6, 2.5, 90, 450, 16), arc(3, 7.3, 3, 2.7, -90, 270, 18)],\n  [[...arc(3, 3, 3, 3, 0, 360, 16), ...arc(2.5, 4.5, 3.5, 5.5, 0, 100, 6)]],\n];\n\nfunction segDist(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const t = l ? cl(((px - ax) * dx + (py - ay) * dy) / l, 0, 1) : 0;\n  const x = ax + t * dx - px, y = ay + t * dy - py;\n  return sqrt(x * x + y * y);\n}\n\n// Is the point (x, y), relative to the plate's centre, inside digit d?\nfunction inDigit(d, x, y, hw) {\n  const sx = 5, sy = 4.5, ox = -3 * sx, oy = -5 * sy;\n  let best = 1e9;\n  for (const pl of DIGITS[d])\n    for (let i = 0; i + 1 \u003c pl.length; i++) {\n      const a = pl[i], b = pl[i + 1];\n      best = min(best, segDist(x, y, ox + a[0] * sx, oy + a[1] * sy, ox + b[0] * sx, oy + b[1] * sy));\n    }\n  return best \u003c= hw;\n}\n\nconst RADII = [2.3, 2.0, 1.5, 1.0, 1.0, 0.5];\nconst TRIES = [60, 200, 1500, 9000, 9000, 9000];\nfunction newPlate(cy, kind, sc) {\n  const own = new Int16Array(W * 64).fill(-1), dots = [];\n  for (let c = 0; c \u003c RADII.length; c++) {\n    const r = RADII[c] * sc, rr = r * r, ri = floor(r), cells = [];\n    for (let dy = -ri; dy \u003c= ri; dy++) for (let dx = -ri; dx \u003c= ri; dx++) if (dx * dx + dy * dy \u003c= rr) cells.push(dx, dy);\n    for (let k = 0; k \u003c TRIES[c]; k++) {\n      const cx = floor(Math.random() * 64), cyy = floor(Math.random() * 64);\n      let ok = true;\n      for (let i = 0; i \u003c cells.length && ok; i += 2) {\n        const x = cx + cells[i], y = cyy + cells[i + 1], ex = x + 0.5 - 32, ey = y + 0.5 - 32;\n        if (ex * ex + ey * ey > R * R) ok = false;\n        else\n          for (const [ax, ay] of NB) {\n            const u = x + ax, v = y + ay;\n            if (u >= 0 && u \u003c 64 && v >= 0 && v \u003c 64 && own[v * W + u] >= 0) {\n              ok = false;\n              break;\n            }\n          }\n      }\n      if (!ok) continue;\n      const n = dots.length;\n      for (let i = 0; i \u003c cells.length; i += 2) own[(cyy + cells[i + 1]) * W + cx + cells[i]] = n;\n      dots.push({ x: cx + 0.5 - 32, y: cyy + 0.5 - 32, now: [0, 0, 1], old: [0, 0, 1], at: 0 });\n    }\n  }\n  return { dots, own, cy, kind, digit: -1, clock: 0, hw: 3.6 + 1.3 * (sc - 1) };\n}\nconst NB = [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]];\n\n// A new numeral: every dot draws a new colour from the palette and a new\n// brightness, inside the numeral or not, and takes them at its own moment\n// in the first quarter of the period.\nfunction setNumeral(P, digit, spread) {\n  P.digit = digit;\n  for (const d of P.dots) {\n    const t = d.old;\n    d.old = d.now;\n    d.now = t;\n    t[0] = inDigit(digit, d.x, d.y, P.hw) ? 1 : 0;\n    t[1] = floor(Math.random() * 5);\n    t[2] = 0.8 + 0.2 * Math.random();\n    d.at = Math.random() * spread;\n  }\n  P.clock = 0;\n}\n\nexport function setup(params) {\n  params.s = { plates: null, size: -1, period: 3, tint: 0, dich: 0, c: [0, 0, 0], o: [0, 0, 0] };\n}\n\nfunction build(S, size) {\n  S.size = size;\n  const sc = 1 + 0.9 * size;\n  S.plates = [newPlate(0, -1, sc), newPlate(64, 1, sc)];\n  for (const P of S.plates) {\n    setNumeral(P, floor(Math.random() * 10), 0);\n    setNumeral(P, P.digit, 0);\n  }\n  S.plates[1].clock = -S.period / 2;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.tint = cl(k[0] || 0, 0, 1);\n  S.period = 6 / cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.dich = cl(k[2] || 0, -1, 1);\n  const size = floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 12.99) / 12;\n  if (size !== S.size) build(S, size);\n  for (const P of S.plates) {\n    P.clock += d;\n    if (P.clock >= S.period) {\n      let n = floor(Math.random() * 9);\n      if (n >= P.digit) n++;\n      setNumeral(P, n, min(0.8, S.period * 0.25));\n    }\n  }\n}\n\nconst toByte = (v) => round(255 * pow(cl(v, 0, 1), 1 / 2.2));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.plates) return;\n  const c = S.c, o = S.o, amt = abs(S.dich), kind = S.dich \u003c 0 ? -1 : 1;\n  for (const P of S.plates) {\n    const dir = P.kind \u003c 0 ? DL : DM, cols = [];\n    for (const d of P.dots) {\n      // A dot being repainted dims to 15% and comes back in its new colour.\n      const u = abs(P.clock - d.at) / DIP, [fig, gi, l0] = P.clock >= d.at ? d.now : d.old, g = GROUND[P.kind \u003c 0 ? 0 : 1][gi];\n      const lum = u \u003c 1 ? l0 * (0.15 + 0.85 * u * u) : l0;\n      // As far along the line as the red target, or as the green allows.\n      const t = fig ? min((FR - g[0]) / dir[0], (g[1] - 0.02) / -dir[1]) : 0;\n      c[0] = (g[0] + t * dir[0]) * lum;\n      c[1] = (g[1] + t * dir[1]) * lum;\n      c[2] = (g[2] + t * dir[2] + 0.55 * S.tint) * lum;\n      simulate(c, kind, amt, o);\n      cols.push(toByte(o[0]), toByte(o[1]), toByte(o[2]));\n    }\n    for (let y = 0; y \u003c 64; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const n = P.own[y * W + x];\n        if (n \u003c 0) display.setPixel(x, P.cy + y, 0, 0, 0);\n        else display.setPixel(x, P.cy + y, cols[n * 3], cols[n * 3 + 1], cols[n * 3 + 2]);\n      }\n  }\n}\n","rabi-chevron":"// ===== Patternflow pattern =====\n// Title:   Rabi Chevron\n// Family:  wave\n// Idea:    Every column is a two-level atom driven at its own detuning, every row a pulse length, and the brightness the chance of finding the atom excited, so Rabi's formula draws its chevron: on resonance in the middle the population swings all the way up and back four times down each sweep, while off resonance it swings faster and less deep, bending the fringes into nested V's that stream up the panel as the sweep of pulse lengths repeats.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rabi oscillations (Isidor Isaac Rabi, 1937), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Span=0..1, Damping=0..1\n//\n// Knob 1: Hue. Turns the colour ramp round the wheel. At 0 the ground state is deep indigo and the ramp climbs through teal and green to a pale yellow at full excitation, the way a physics plot would draw it; at 0.15 the ground turns violet and the top green, and at 0.5 the ramp runs from a dark brown through red and magenta to periwinkle.\n// Knob 2: Speed. How fast the sweep runs: 16 rows a second for each unit, so 32 at the opening 2. A row is a twentieth of the Rabi period on resonance, so the middle columns swing 1.6 times a second and the 80 rows of one sweep pass in 2.5 s; 3.2 rows a second at 0.2, 48 at 3.\n// Knob 3: Span. The detuning at the panel's left and right edges, from 2.5 times the Rabi frequency at 0 to 5 times at 1. At the opening 2.5 the edge columns swing 2.69 times as fast as the middle and only 14% of the way up; at 5, 5.1 times as fast and 4% of the way, and the chevron narrows to a spike.\n// Knob 4: Damping. Dephasing at the rate 0.6 Damping^2 times the Rabi frequency, which pulls each swing towards its mean. At the opening 0.06 a sweep keeps 95% of its depth to the end; at 0.3 the last fringes keep 26%, at 0.5 2%, and at 1 every column settles within one period to half its peak, so the panel shows the power-broadened Lorentzian line, a soft column 2 Rabi frequencies wide.\n\n// A two-level atom starts in its ground state and is driven by a field of\n// Rabi frequency Omega, detuned by Delta from the transition. Rabi worked\n// out in 1937, for a spin in a steady magnetic field with a weak second\n// field turning round it, that after a time t the chance of finding it\n// flipped is\n//\n//   P(Delta, t) = Omega^2 / (Omega^2 + Delta^2) sin^2(W t / 2),\n//   W = sqrt(Omega^2 + Delta^2).\n//\n// On resonance it swings all the way to 1 and back at Omega. Detuned, it\n// swings faster, at the generalised Rabi frequency W, and never higher than\n// Omega^2 / W^2, a Lorentzian in Delta. Plotted against detuning and pulse\n// length the fringes are the curves W t = 2 pi n, hyperbolas that sit flat\n// for short pulses and bend into ever deeper V's for long ones: the chevron\n// that experiments on qubits and trapped ions measure to find the resonance\n// and the length of a pi pulse.\n//\n// Here x is Delta, from -D to +D in units of Omega (D = 2.5 to 5 by Span),\n// and y is the pulse length, a sweep of 80 rows from Omega t = 0 to 8 pi\n// (four full swings on resonance). The sweeps follow one another down the\n// panel like the repeated scans of a real experiment, and the whole record\n// scrolls up, so every LED sees the fringes run past it: a new sweep comes\n// in at the bottom, dark for the shortest pulses, and the seam where the\n// last one ends and the next begins rises with it. The swing is damped by\n// exp(-gamma t) about its mean, P = A (1 - exp(-gamma t) cos W t) / 2, a\n// plain dephasing envelope rather than the full Bloch equations. Brightness\n// follows P^0.7 so the faint, fast fringes far off resonance still show.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Rows to one Rabi period on resonance, and periods in one sweep.\nconst P0 = 20, NP = 4, LS = P0 * NP;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = { g: 0, hue: 0, speed: 2, D: 2.5, gam: 0, lut: new Uint8Array(257 * 3), lh: -1, c: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.D = 2.5 + 2.5 * cl(k[2] || 0, 0, 1);\n  const dm = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.gam = 0.6 * dm * dm;\n  S.g += d * S.speed * 16;\n  if (S.g > LS * 1000) S.g -= LS * 1000;\n}\n\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let i = 0; i \u003c= 256; i++) {\n    const p = Math.pow(i / 256, 0.7);\n    hsv(S.hue + 0.66 - 0.5 * p, 0.95 - 0.35 * p * p, 0.13 + 0.87 * p, S.c);\n    S.lut[i * 3] = round(S.c[0] * 255);\n    S.lut[i * 3 + 1] = round(S.c[1] * 255);\n    S.lut[i * 3 + 2] = round(S.c[2] * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const L = S.lut, D = S.D, gam = S.gam;\n  for (let y = 0; y \u003c H; y++) {\n    const g = y + S.g, ph = g - floor(g / LS) * LS, t = (ph / P0) * TAU, e = exp(-gam * t);\n    for (let x = 0; x \u003c W; x++) {\n      const dl = ((x - 31.5) / 32) * D, r2 = 1 + dl * dl, wr = sqrt(r2);\n      const P = (0.5 / r2) * (1 - e * cos(wr * t));\n      const i = round(P * 256) * 3;\n      display.setPixel(x, y, L[i], L[i + 1], L[i + 2]);\n    }\n  }\n}\n","simulated-annealing":"// ===== Patternflow pattern =====\n// Title:   Simulated Annealing\n// Family:  sim\n// Idea:    A closed tour through 80 random cities starts as a hot tangle of crossing lines that jumps every frame, and as the temperature falls under the Metropolis rule the crossings undo themselves, the inside of the loop (filled by the even-odd rule) closes into one region, and the tour settles into a ring that no longer crosses itself with its colours flowing round it, until the cities fly to new places and melt it again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: simulated annealing (Scott Kirkpatrick, C. Daniel Gelatt and Mario Vecchi, 1983) with the Metropolis rule (Nicholas Metropolis, Arianna Rosenbluth, Marshall Rosenbluth, Augusta Teller and Edward Teller, 1953), on the travelling salesman problem, pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cities=80..150, Floor=0..1\n//\n// Knob 1: Hue. Turns the loop's colours round the wheel. At 0 the tour runs from cyan through blue and violet to pink and back again, so the ring has no seam; at 0.5 it runs from red through orange and yellow to green.\n// Knob 2: Speed. Stretches the clock of the whole cycle. At 2 one cycle is 18 s: 0.8 s hot while the cities fly to their new places, 12 s of cooling and 5.2 s held at the floor, with 60,000 tries a second (2,000 a frame). At 0.2 everything is ten times slower, at 3 one and a half times faster, and a cycle always gets the same 1.08 million tries.\n// Knob 3: Cities. 80 to 150 cities. A new count scatters new cities and starts from a random tour at once. The city spacing, the square root of the area per city, is 9.4 LEDs for 80 and 6.9 for 150, and the temperatures are counted in it.\n// Knob 4: Floor. The temperature the cooling ends at and holds, 0.01 city spacings times 50 to the power of the knob: 0.013 at the opening 0.06, 0.07 at 0.5 and 0.5 at 1. Cooling always starts at 4 spacings. Up to about 0.5 the ring freezes with no crossings; at 1 it stays a warm liquid that keeps about 20 crossings of 80 cities and flickers as they come and go.\n\n// The travelling salesman wants the shortest closed tour through all the\n// cities. Kirkpatrick, Gelatt and Vecchi (Science, 1983) treated the tour's\n// length L as the energy of a physical system and cooled it: propose a\n// small change, and keep it by the rule of Metropolis and his coauthors\n// (1953), always if it makes the tour shorter and with probability\n// exp(-dL / T) if it makes it longer by dL. At a high temperature T almost\n// every change is kept and the tour is a random tangle. Cooled slowly, the\n// tour has time to find its way down, and cold it stops at a short tour\n// that no single change can shorten. Cooled at once (a quench), it freezes\n// in the first dent it meets: on the same 80 cities a 2-opt descent from a\n// random order ends 2.6% to 9.5% longer than this anneal, 6.6% on average.\n//\n// The change here is the 2-opt move (Shen Lin, 1965): cut two edges of the\n// tour, a-b and c-d, and join a-c and b-d, which reverses the path between\n// them.\n// If two edges cross, the move that uncrosses them always shortens the\n// tour (the two diagonals of a quadrilateral are longer than either pair of\n// its opposite sides), so a tour that no 2-opt move can shorten never\n// crosses itself, and the cold ring on the panel is a simple polygon.\n//\n// The picture shows that through the inside of the loop: each row is\n// filled between alternate crossings of the tour (the even-odd rule). A\n// tangled tour fills as a patchwork that flickers; once the tour stops\n// crossing itself the fill becomes one region with the loop as its edge,\n// a meander that interlocks with the outside. The loop is coloured by place\n// along the tour, so while it is tangled neighbouring colours are scattered\n// over the whole panel, and as it orders they sort into one gradient.\n// The line on row 125 is the temperature on a log scale from 0.01 to 4\n// city spacings, warm white when hot and pale blue when cold.\n\nconst W = 64, H = 128, NP = W * H;\nconst X0 = 2.5, X1 = 61.5, Y0 = 2.5, Y1 = 121.5, GY = 125;\nconst { floor, round, min, max, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Seconds at Speed 2.\nconst HOT = 0.8, CYCLE = 18, COOL = 12, TRIES = 60000;\nconst T0 = 4, T1 = 0.01, SPAN = 0.45;\n\nfunction hsv(h, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const v = i === 0 ? [1, f, 0] : i === 1 ? [1 - f, 1, 0] : i === 2 ? [0, 1, f] : i === 3 ? [0, 1 - f, 1] : i === 4 ? [f, 0, 1] : [1, 0, 1 - f];\n  o[k] = v[0];\n  o[k + 1] = v[1];\n  o[k + 2] = v[2];\n}\n\nfunction scatter(S, glide) {\n  const n = S.n;\n  for (let i = 0; i \u003c n; i++) {\n    S.ox[i] = glide ? S.x[i] : 0;\n    S.oy[i] = glide ? S.y[i] : 0;\n    S.tx[i] = X0 + Math.random() * (X1 - X0);\n    S.ty[i] = Y0 + Math.random() * (Y1 - Y0);\n    if (!glide) (S.x[i] = S.tx[i]), (S.y[i] = S.ty[i]);\n  }\n  S.glide = glide ? 0 : 1;\n}\n\nfunction start(S, n) {\n  S.n = n;\n  S.x = new Float32Array(n);\n  S.y = new Float32Array(n);\n  S.ox = new Float32Array(n);\n  S.oy = new Float32Array(n);\n  S.tx = new Float32Array(n);\n  S.ty = new Float32Array(n);\n  S.tour = new Int32Array(n);\n  for (let i = 0; i \u003c n; i++) S.tour[i] = i;\n  // A random order: the first tour is a tangle.\n  for (let i = n - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = S.tour[i];\n    S.tour[i] = S.tour[j];\n    S.tour[j] = t;\n  }\n  S.col = new Float32Array(n * 3);\n  S.unit = sqrt(((X1 - X0) * (Y1 - Y0)) / n);\n  scatter(S, false);\n  S.tc = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, hue: 0, rate: 1, floor: T1, tc: 0, phi: 0, T: T0, acc: new Float32Array(NP * 3), cur: new Float32Array(NP * 3),\n    bl: new Float32Array(NP * 3), tmp: new Float32Array(NP * 3), xs: new Float32Array(400), ca: [0, 0, 0], cb: [0, 0, 0],\n  };\n}\n\nfunction dist(S, a, b) {\n  const dx = S.x[a] - S.x[b], dy = S.y[a] - S.y[b];\n  return sqrt(dx * dx + dy * dy);\n}\n\n// Tries 2-opt reversals at temperature T (in pixels) by the Metropolis rule.\nfunction anneal(S, tries, T) {\n  const n = S.n, tour = S.tour, half = n >> 1;\n  for (let k = 0; k \u003c tries; k++) {\n    let i = floor(Math.random() * n), j = floor(Math.random() * n);\n    if (i > j) {\n      const t = i;\n      i = j;\n      j = t;\n    }\n    if (j - i \u003c 2 || (i === 0 && j === n - 1)) continue;\n    const a = tour[i], b = tour[i + 1], c = tour[j], d = tour[(j + 1) % n];\n    const dL = dist(S, a, c) + dist(S, b, d) - dist(S, a, b) - dist(S, c, d);\n    if (dL > 0 && Math.random() >= exp(-dL / T)) continue;\n    // Reverse positions i+1..j, or the rest of the ring if that is shorter:\n    // both give the same closed tour.\n    let lo = i + 1, hi = j, len = j - i;\n    if (len > half) (lo = j + 1), (hi = i + n), (len = n - len);\n    for (let s = 0; s \u003c len >> 1; s++) {\n      const p = (lo + s) % n, q = (hi - s) % n, t = tour[p];\n      tour[p] = tour[q];\n      tour[q] = t;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  const n = round(cl(k[2] == null ? 80 : k[2], 80, 150));\n  S.floor = T1 * Math.pow(50, cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  if (n !== S.n) start(S, n);\n  const dc = d * S.rate;\n  S.tc += dc;\n  S.phi += dc / 12;\n  if (S.tc >= CYCLE) {\n    S.tc -= CYCLE;\n    scatter(S, true);\n  }\n  // The cities fly to their new places while the tour is hot.\n  if (S.glide \u003c 1) {\n    S.glide = min(1, S.glide + dc / HOT);\n    const e = S.glide * S.glide * (3 - 2 * S.glide);\n    for (let i = 0; i \u003c S.n; i++) {\n      S.x[i] = S.ox[i] + (S.tx[i] - S.ox[i]) * e;\n      S.y[i] = S.oy[i] + (S.ty[i] - S.oy[i]) * e;\n    }\n  }\n  const u = cl((S.tc - HOT) / COOL, 0, 1);\n  S.T = T0 * Math.pow(S.floor / T0, u) * S.unit;\n  anneal(S, round(TRIES * dc), S.T);\n}\n\n// Plots a line with two-pixel anti-aliasing, keeping the brighter colour.\nfunction line(S, x0, y0, x1, y1, ca, cb, lv) {\n  const cur = S.cur, dx = x1 - x0, dy = y1 - y0;\n  const steep = Math.abs(dy) > Math.abs(dx);\n  const len = steep ? Math.abs(dy) : Math.abs(dx);\n  const steps = max(1, Math.ceil(len));\n  for (let s = 0; s \u003c= steps; s++) {\n    const t = s / steps, x = x0 + dx * t - 0.5, y = y0 + dy * t - 0.5;\n    const r = (ca[0] + (cb[0] - ca[0]) * t) * lv, g = (ca[1] + (cb[1] - ca[1]) * t) * lv, b = (ca[2] + (cb[2] - ca[2]) * t) * lv;\n    let px, py, f, ox, oy;\n    if (steep) (py = round(y)), (px = floor(x)), (f = x - px), (ox = 1), (oy = 0);\n    else (px = round(x)), (py = floor(y)), (f = y - py), (ox = 0), (oy = 1);\n    for (let h = 0; h \u003c 2; h++) {\n      const qx = px + ox * h, qy = py + oy * h, w = h ? f : 1 - f;\n      if (qx \u003c 0 || qx >= W || qy \u003c 0 || qy >= H) continue;\n      const o = (qy * W + qx) * 3;\n      if (r * w > cur[o]) cur[o] = r * w;\n      if (g * w > cur[o + 1]) cur[o + 1] = g * w;\n      if (b * w > cur[o + 2]) cur[o + 2] = b * w;\n    }\n  }\n}\n\n// A box blur of radius R across and then down.\nfunction blur(src, dst, tmp) {\n  const R = 5, k = 1 / (2 * R + 1);\n  for (let y = 0; y \u003c H; y++)\n    for (let c = 0; c \u003c 3; c++) {\n      let sum = 0;\n      for (let x = -R; x \u003c= R; x++) if (x >= 0 && x \u003c W) sum += src[(y * W + x) * 3 + c];\n      for (let x = 0; x \u003c W; x++) {\n        tmp[(y * W + x) * 3 + c] = sum * k;\n        const xa = x - R, xb = x + R + 1;\n        if (xa >= 0) sum -= src[(y * W + xa) * 3 + c];\n        if (xb \u003c W) sum += src[(y * W + xb) * 3 + c];\n      }\n    }\n  for (let x = 0; x \u003c W; x++)\n    for (let c = 0; c \u003c 3; c++) {\n      let sum = 0;\n      for (let y = -R; y \u003c= R; y++) if (y >= 0 && y \u003c H) sum += tmp[(y * W + x) * 3 + c];\n      for (let y = 0; y \u003c H; y++) {\n        dst[(y * W + x) * 3 + c] = sum * k;\n        const ya = y - R, yb = y + R + 1;\n        if (ya >= 0) sum -= tmp[(ya * W + x) * 3 + c];\n        if (yb \u003c H) sum += tmp[(yb * W + x) * 3 + c];\n      }\n    }\n}\n\nconst FILL = 0.2;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const n = S.n, tour = S.tour, col = S.col, cur = S.cur, acc = S.acc, xs = S.xs;\n  const h0 = 0.47 + S.hue;\n  // Colour by place along the tour, there and back so the ring has no seam.\n  for (let p = 0; p \u003c n; p++) hsv(h0 + SPAN * (0.5 - 0.5 * cos(2 * PI * (p / n + S.phi))), col, p * 3);\n  cur.fill(0);\n  // The tour.\n  const ca = S.ca, cb = S.cb;\n  for (let p = 0; p \u003c n; p++) {\n    const q = p + 1 === n ? 0 : p + 1, a = tour[p], b = tour[q];\n    for (let c = 0; c \u003c 3; c++) (ca[c] = col[p * 3 + c]), (cb[c] = col[q * 3 + c]);\n    line(S, S.x[a], S.y[a], S.x[b], S.y[b], ca, cb, 0.85);\n  }\n  // The colour of the nearby loop, blurred, to fill the inside with.\n  blur(cur, S.bl, S.tmp);\n  const bl = S.bl;\n  // The inside of the loop, by the even-odd rule, row by row.\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5;\n    let m = 0;\n    for (let p = 0; p \u003c n; p++) {\n      const a = tour[p], b = tour[p + 1 === n ? 0 : p + 1];\n      const ya = S.y[a], yb = S.y[b];\n      if ((ya \u003c= yc && yc \u003c yb) || (yb \u003c= yc && yc \u003c ya)) {\n        const x = S.x[a] + ((yc - ya) * (S.x[b] - S.x[a])) / (yb - ya);\n        let q = m++;\n        while (q > 0 && xs[q - 1] > x) (xs[q] = xs[q - 1]), q--;\n        xs[q] = x;\n      }\n    }\n    for (let q = 0; q + 1 \u003c m; q += 2) {\n      const x0 = max(0, Math.ceil(xs[q] - 0.5)), x1 = min(W - 1, floor(xs[q + 1] - 0.5));\n      for (let x = x0; x \u003c= x1; x++) {\n        const o = (y * W + x) * 3, r = bl[o], g = bl[o + 1], b = bl[o + 2], top = max(r, g, b);\n        const f = top > 1e-4 ? FILL / top : 0;\n        cur[o] = max(cur[o], top > 1e-4 ? r * f : FILL * col[0]);\n        cur[o + 1] = max(cur[o + 1], top > 1e-4 ? g * f : FILL * col[1]);\n        cur[o + 2] = max(cur[o + 2], top > 1e-4 ? b * f : FILL * col[2]);\n      }\n    }\n  }\n  // The cities, pale versions of their colour.\n  for (let p = 0; p \u003c n; p++) {\n    const a = tour[p], x = floor(S.x[a]), y = floor(S.y[a]), o = (y * W + x) * 3;\n    for (let c = 0; c \u003c 3; c++) cur[o + c] = 0.55 + 0.45 * col[p * 3 + c];\n  }\n  // The temperature, on a log scale from T1 to T0 city spacings.\n  const hot = cl(log(S.T / S.unit / T1) / log(T0 / T1), 0, 1), g = hot * W;\n  for (let x = 0; x \u003c W; x++) {\n    const o = (GY * W + x) * 3, w = 0.8 * (x \u003c g ? 1 : x \u003c g + 1 ? g - x : 0);\n    cur[o] = max(cur[o], w * (0.45 + 0.55 * hot));\n    cur[o + 1] = max(cur[o + 1], w * (0.7 + 0.1 * hot));\n    cur[o + 2] = max(cur[o + 2], w * (1 - 0.45 * hot));\n  }\n  // A short afterglow while it is hot, so the tangle reads as a web.\n  const keep = 0.55 * hot;\n  for (let i = 0; i \u003c NP * 3; i++) acc[i] = acc[i] * keep + cur[i] * (1 - keep);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, round(acc[o] * 255)), min(255, round(acc[o + 1] * 255)), min(255, round(acc[o + 2] * 255)));\n    }\n}\n","sitnikov-problem":"// ===== Patternflow pattern =====\n// Title:   Sitnikov Problem\n// Family:  space\n// Idea:    Two equal stars swing round each other on ellipses in a plane seen edge-on across the middle of the panel, and 64 massless bodies on the axis through their centre, each drawn in a column of its own, are thrown up together at speeds a hair apart, so they rise and fall through the plane as one smooth wave that bends and then tears into scattered points, each colouring the plane under it with the number of whole turns the stars made between its last two crossings, Moser's symbol, until the next wave goes up; on circles the wave only winds into more crests and never tears.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sitnikov problem (Kirill Sitnikov, 1960), its symbolic dynamics (Jürgen Moser, Stable and Random Motions in Dynamical Systems, 1973), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ellipse=-1..1, Spread=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 a body that has not yet come back to the plane is cyan, and one whose last half swing took s whole turns of the stars is azure for 0, violet for 1, pink for 2, rose for 3, orange for 4 and lime for 5; at 0.5 the wave goes up red and the symbols run orange, lime and green.\n// Knob 2: Speed. Time runs at 2 units a second for each unit of the knob, so at 2 the stars go round once in 1.57 seconds (their period is 2 pi), at 0.2 once in 15.7 seconds and at 3 once in 1.05 seconds.\n// Knob 3: Ellipse. The eccentricity e of the stars' orbit, 0.3 (1 + Ellipse): 0 at -1, 0.3 at the opening 0, 0.6 at 1. At 0.3 each star swings between 0.35 and 0.65 from the centre, and a quarter of the opening wave has torn 4.7 seconds after it goes up, half of it by 8.4. At e = 0.15 a quarter has torn by 11.7 seconds and half by 15.7; at 0.6 by 6.4 and 7.8. At e = 0 the wave only winds into more and more crests and never tears in its 20 seconds, and each body's energy holds to 8 decimals.\n// Knob 4: Spread. How far apart the 64 launch speeds are, 0.005 to 0.305 of the escape speed 2, centred on 0.86 of it. At the opening 0.06 the speeds run from 1.697 to 1.743, so the wave goes up nearly flat. At 1 they run from 1.415 to 2.025 and the wave is steep from the start: its slow left end keeps a smooth arc, and its right end, at the escape speed and past it, runs off the top and is sent up again and again.\n// Buttons: K1 tap sends up a new wave the next time the stars are at r = 1/2, within one turn. A new wave also goes up by itself every 80 units of time (about 13 turns, 20 seconds at the opening Speed) and when Ellipse or Spread has rested 0.3 seconds at a new value.\n\n// Two stars of mass 1/2 each move on Kepler ellipses of eccentricity e about\n// their centre of mass, with G = 1, the semi-major axis of their relative\n// orbit 1 and so a period of 2 pi. Each is r(t) = (1 - e cos E) / 2 from the\n// centre, where E - e sin E = t (Kepler's equation, solved by Newton's\n// method each step). A third body of no mass on the line through the centre\n// at right angles to the plane feels both stars at the distance\n// sqrt(z^2 + r^2), and their pulls along the line add up to\n//\n//   z'' = -z / (z^2 + r(t)^2)^(3/2).\n//\n// Kirill Sitnikov used this set-up in 1960 to show that the three-body\n// problem has oscillatory motions, swings that go out further and further\n// and still come back. For e = 0, r = 1/2 is fixed, the energy\n// v^2 / 2 - 1 / sqrt(z^2 + 1/4) is conserved and every bounded body swings\n// periodically, the period growing with the amplitude. For e > 0 the pull\n// beats with the stars and energy changes at every pass through the plane.\n// Jürgen Moser (1973) counted s_k, the whole turns of the stars between the\n// k-th and (k+1)-th time a body crosses the plane, and showed that for\n// small e > 0 there is a whole number m such that every sequence of\n// s_k >= m, chosen like coin tosses, is the record of some orbit: the motion\n// is as random as any sequence of symbols.\n//\n// The picture: 64 bodies, one in each column, leave the plane together at\n// the moment the stars are r = 1/2 apart, so a launch speed of 2 is the\n// escape speed whatever e is. Their speeds rise from left to right by equal\n// steps, so they start as one curve. Height on the panel is\n// 62 tanh(z / 2.2) rows from the middle, so a body far out still shows near\n// the edge. A body is a small cross with a glow; neighbours within 4 rows of\n// each other are joined, and the joined curve leaves a fading trail, so a\n// body that has fallen out of step with both neighbours is a lone point. Its\n// colour is its last symbol s, and the plane edge-on, rows 63 and 64, shows\n// under each column the last symbol written there, flashing as it is\n// written. The two stars are drawn at their positions seen from the side,\n// 34 LEDs to a unit, the nearer one larger. A body moving out past z = 5\n// with positive energy has escaped and is sent up again from the plane.\n// RK4 takes steps of at most 0.03 r^(3/2), 0.01 at e = 0, so a body still\n// gets several steps across the plane at the stars' closest approach.\n\nconst W = 64, H = 128, N = W * H, MID = 63.5, NB = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, round, PI, atan2, tanh } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst P = { F0: 0.86, RATE: 2, CYCLE: 80, DECAY: 0.76, ZS: 2.2, ZOUT: 5, LINK: 4, BR: 1.8 };\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Eccentric anomaly of the primaries at time t: E - e sin E = t.\nfunction anomaly(t, e) {\n  const M = t - TAU * floor(t / TAU);\n  let E = M + (sin(M) >= 0 ? 0.85 : -0.85) * e;\n  for (let k = 0; k \u003c 8; k++) E -= (E - e * sin(E) - M) / (1 - e * cos(E));\n  return E;\n}\nconst radius = (t, e) => (1 - e * cos(anomaly(t, e))) / 2;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, since: 0, e: 0.3, sp: 0.023, hue: 0, speed: 2, pending: false,\n    z: new Float64Array(NB), v: new Float64Array(NB), f: new Float64Array(NB),\n    tc: new Float64Array(NB), sym: new Int8Array(NB),\n    yy: new Float64Array(NB),\n    acc: new Float32Array(N * 3), c: [0, 0, 0], want: [0.3, 0.023], rest: 0,\n    flash: new Float32Array(NB), btn: false,\n  };\n  const S = params.s;\n  S.t = PI / 2 - S.e;\n  launch(S);\n}\n\n// The wave leaves the plane when the primaries are half their mean\n// distance apart, r = 1/2, so the launch speed 2f is f of the escape speed\n// whatever e is.\nfunction launch(S) {\n  for (let i = 0; i \u003c NB; i++) {\n    S.f[i] = P.F0 + S.sp * (i / (NB - 1) - 0.5);\n    S.z[i] = 0;\n    S.v[i] = 2 * S.f[i];\n    S.tc[i] = S.t;\n    S.sym[i] = -1;\n  }\n  S.since = 0;\n  S.pending = false;\n}\n\nfunction relaunchOne(S, i) {\n  S.z[i] = 0;\n  S.v[i] = 2 * S.f[i];\n  S.tc[i] = S.t;\n  S.sym[i] = -1;\n}\n\nconst acc = (z, r) => -z / ((z * z + r * r) * sqrt(z * z + r * r));\n\nfunction step(S, h) {\n  const e = S.e, t = S.t, r0 = radius(t, e), r1 = radius(t + h / 2, e), r2 = radius(t + h, e);\n  const z = S.z, v = S.v;\n  for (let i = 0; i \u003c NB; i++) {\n    const Z = z[i], V = v[i];\n    const a1 = acc(Z, r0);\n    const z2 = Z + (h / 2) * V, v2 = V + (h / 2) * a1, a2 = acc(z2, r1);\n    const z3 = Z + (h / 2) * v2, v3 = V + (h / 2) * a2, a3 = acc(z3, r1);\n    const z4 = Z + h * v3, v4 = V + h * a3, a4 = acc(z4, r2);\n    const zn = Z + (h / 6) * (V + 2 * v2 + 2 * v3 + v4);\n    const vn = V + (h / 6) * (a1 + 2 * a2 + 2 * a3 + a4);\n    if ((Z \u003c 0 && zn >= 0) || (Z > 0 && zn \u003c= 0)) {\n      const tx = t + (h * abs(Z)) / max(1e-12, abs(Z) + abs(zn));\n      S.sym[i] = min(9, floor((tx - S.tc[i]) / TAU));\n      S.tc[i] = tx;\n      S.flash[i] = 1;\n    }\n    z[i] = zn;\n    v[i] = vn;\n  }\n  S.t += h;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const e = 0.3 * (1 + cl(k[2] || 0, -1, 1)), sp = 0.005 + 0.3 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (abs(e - S.want[0]) > 1e-6 || abs(sp - S.want[1]) > 1e-6) {\n    S.want = [e, sp];\n    S.rest = 0;\n  } else S.rest += d;\n  if ((abs(e - S.e) > 1e-6 || abs(sp - S.sp) > 1e-6) && (S.rest > 0.3 || S.since === 0)) {\n    S.e = e;\n    S.sp = sp;\n    S.t = PI / 2 - e;\n    launch(S);\n  }\n  const b = !!(input.btnPressed && input.btnPressed[0]);\n  if (b && !S.btn) S.pending = true;\n  S.btn = b;\n  for (let i = 0; i \u003c NB; i++) S.flash[i] *= 0.88;\n  let T = d * S.speed * P.RATE;\n  while (T > 1e-9) {\n    const r = radius(S.t, S.e);\n    let h = min(0.01, 0.03 * r * sqrt(r), T);\n    if (S.pending) {\n      // The next wave goes as the primaries come round to r = 1/2.\n      const ph = PI / 2 - S.e, nxt = ph + TAU * ceil((S.t - ph) / TAU + 1e-9);\n      if (S.t + h >= nxt) {\n        h = nxt - S.t;\n        if (h > 1e-9) step(S, h);\n        S.t = nxt;\n        T -= h;\n        launch(S);\n        continue;\n      }\n    }\n    step(S, h);\n    T -= h;\n  }\n  S.since += d * S.speed * P.RATE;\n  if (S.since > P.CYCLE) S.pending = true;\n  const r = radius(S.t, S.e);\n  for (let i = 0; i \u003c NB; i++) {\n    const z = S.z[i], vz = S.v[i];\n    // Past the edge of the panel, moving out with positive energy: gone.\n    if (abs(z) > P.ZOUT && z * vz > 0 && (vz * vz) / 2 - 1 / sqrt(z * z + r * r) > 0) relaunchOne(S, i);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const A = S.acc, c = S.c, y = S.yy;\n  for (let p = 0; p \u003c N * 3; p++) A[p] *= P.DECAY;\n  const put = (x, yy, r, g, b) => {\n    if (yy \u003c 0 || yy >= H || x \u003c 0 || x >= W) return;\n    const p = (yy * W + x) * 3;\n    if (A[p] \u003c r) A[p] = r;\n    if (A[p + 1] \u003c g) A[p + 1] = g;\n    if (A[p + 2] \u003c b) A[p + 2] = b;\n  };\n  for (let i = 0; i \u003c NB; i++) y[i] = MID - 62 * tanh(S.z[i] / P.ZS);\n  for (let i = 0; i \u003c NB; i++) {\n    const s = S.sym[i];\n    hsv(S.hue + 0.5 + (s \u003c 0 ? 0 : 0.12 * (s + 1)), 0.8, 1, c);\n    const R = P.BR, y0 = y[i];\n    if (y0 \u003c -R || y0 > H + R) continue;\n    // A body still in step with a neighbour leaves its glow behind; one on\n    // its own leaves only a short tail.\n    const linked = (i > 0 && abs(y0 - y[i - 1]) \u003c= P.LINK) || (i \u003c NB - 1 && abs(y0 - y[i + 1]) \u003c= P.LINK);\n    const g = linked ? 1 : 0.4;\n    for (let yy = floor(y0 - R); yy \u003c= ceil(y0 + R); yy++)\n      for (let x = i - 2; x \u003c= i + 2; x++) {\n        const q = ((x - i) * (x - i) + (yy - y0) * (yy - y0)) / (R * R);\n        if (q \u003c 1) {\n          const w = (0.6 - q * 0.45) * g;\n          put(x, yy, c[0] * w, c[1] * w, c[2] * w);\n        }\n      }\n    if (i \u003c NB - 1 && abs(y0 - y[i + 1]) \u003c= P.LINK) {\n      const m = (y0 + y[i + 1]) / 2;\n      for (let yy = round(min(y0, m)); yy \u003c= round(max(y0, m)); yy++) put(i, yy, c[0], c[1], c[2]);\n      for (let yy = round(min(y[i + 1], m)); yy \u003c= round(max(y[i + 1], m)); yy++) put(i + 1, yy, c[0], c[1], c[2]);\n    }\n  }\n  const E = anomaly(S.t, S.e), e = S.e;\n  const r = (1 - e * cos(E)) / 2;\n  const nu = 2 * atan2(sqrt(1 + e) * sin(E / 2), sqrt(1 - e) * cos(E / 2));\n  const px = [32 + 34 * r * cos(nu), 32 - 34 * r * cos(nu)], depth = [sin(nu), -sin(nu)];\n  for (let yy = 0; yy \u003c H; yy++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (yy * W + x) * 3;\n      let R = A[p], G = A[p + 1], B = A[p + 2];\n      if (yy === 63 || yy === 64) {\n        // The plane edge-on: under each body the last symbol it wrote.\n        const s = S.sym[x];\n        if (s \u003c 0) {\n          R = max(R, 0.12);\n          G = max(G, 0.12);\n          B = max(B, 0.16);\n        } else {\n          hsv(S.hue + 0.5 + 0.12 * (s + 1), 0.8, 0.3 + 0.7 * S.flash[x], c);\n          R = max(R, c[0]);\n          G = max(G, c[1]);\n          B = max(B, c[2]);\n        }\n      }\n      for (let j = 0; j \u003c 2; j++) {\n        const rad = 1.6 + 0.7 * depth[j], dx = x + 0.5 - px[j], dy = yy - MID;\n        const q = dx * dx + dy * dy;\n        if (q \u003c rad * rad) {\n          const w = 1 - (q / (rad * rad)) * 0.5;\n          R = max(R, w);\n          G = max(G, w * 0.92);\n          B = max(B, w * 0.75);\n        }\n      }\n      display.setPixel(x, yy, min(255, round(R * 255)), min(255, round(G * 255)), min(255, round(B * 255)));\n    }\n  for (let i = 0; i \u003c NB; i++) {\n    const yy = round(y[i]);\n    if (yy \u003c 0 || yy >= H) continue;\n    hsv(S.hue + 0.5 + (S.sym[i] \u003c 0 ? 0 : 0.12 * (S.sym[i] + 1)), 0.45, 1, c);\n    for (const [dx, dy] of [[0, -1], [0, 1], [-1, 0], [1, 0]]) {\n      const X = i + dx, Y = yy + dy;\n      if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) display.setPixel(X, Y, round(c[0] * 255), round(c[1] * 255), round(c[2] * 255));\n    }\n    display.setPixel(i, yy, 255, 255, 255);\n  }\n}\n","v-cut-letters":"// ===== Patternflow pattern =====\n// Title:   V-Cut Letters\n// Family:  type\n// Idea:    LVX stands up the panel in three Roman capitals cut into stone with a V chisel, each stroke a groove whose flat walls meet in a sharp line down its middle, and a low light walks round the stone so the walls flip between lit and shadowed one facet at a time while the uncut surface keeps one dim tone, and the letters are read only from how the light falls on the planes.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: V-cut letter carving of Roman inscriptions, with the roof of a polygon as its straight skeleton (Oswin Aichholzer, Franz Aurenhammer, David Alberts and Bernd Gärtner, 1995), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wall=30..70, Light=0..1\n//\n// Knob 1: Hue. The colour of the light, with the sky's fill in the shaded walls opposite it on the wheel: at 0 a pale gold sun and navy shade on blue-grey stone; 0.25 green light and purple shade, 0.5 blue moonlight and amber shade on warm grey, 0.75 pink light and green shade.\n// Knob 2: Speed. How fast the light walks round the stone: at 2 one turn in 12 s, so a wall swings from its brightest to its darkest in 6 s; at 0.2 a turn takes 2 minutes, at 3 eight seconds.\n// Knob 3: Wall. How steep the chisel's walls stand, in degrees from the surface: 30 at the opening, a shallow cut, 2.9 LEDs deep under the 10 LED stems, where a light square across a stroke leaves the lower 28% of the lit wall in the lip's shadow; at 50 a V of 80 degrees between its walls, twice as deep; at 70 the groove is 13.7 LEDs deep, the lip shades 79% of the lit wall and the letters are mostly dark cuts with a bright edge.\n// Knob 4: Light. How high the light stands above the stone, from 15 degrees at 0 to 75 at 1: 18 at the opening 0.06, raking, lower than the 30 degree walls, so the wall turned away goes into shade; at 45 (0.5) that wall keeps a quarter of the light; at 75, steeper than any wall the knob allows, the lip throws no shadow, and with the opening's 30 degree walls both sides of a groove stay lit and the letters go pale.\n\n// A letter cut with a V chisel is a groove whose two walls are planes that\n// slope down from the outline at the same angle and meet along a line. For\n// a stroke whose outline is a convex polygon, the depth under a point is\n// the slope times its distance to the nearest edge of the outline: every\n// edge carries one plane, and two planes meet where a point is equally far\n// from two edges. Those meeting lines are the straight skeleton of the\n// polygon, which Aichholzer, Aurenhammer, Alberts and Gärtner defined in\n// 1995 by moving every edge inward at the same speed; lifted, it is a roof\n// whose planes all slope at one angle. For a convex outline it is the same\n// as the medial axis. A long stroke has a sharp line down its middle and a\n// hip at each end, and in a triangular serif three facets meet at one\n// deepest point. Where two strokes cross, the chisel takes away both, so\n// the deeper cut wins.\n//\n// Each LED is four samples. A sample inside a stroke takes the normal of\n// the plane of its nearest edge; the light, at a fixed height and walking\n// round, lights it by Lambert's cosine, and the sky gives the shaded walls a\n// little of the opposite colour. The light is then followed from the LED's\n// centre across the depth field toward the lamp: where the stone in between\n// stands higher than the ray, the lip of the groove casts its shadow. The\n// uncut stone is not lit by the moving light at all, so the letters are\n// only what the facets do.\n//\n// The capitals are polygons drawn for this pattern, after the Roman\n// inscriptional capital: thick strokes down and down to the right, thin\n// ones across and down to the left, a pointed V that dips a row below the\n// line, and wedge serifs cut shallower than the stems. In Roman\n// inscriptions U is V, so the word is LVX, light.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, tan, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst RAD = PI / 180;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Where line ab meets line cd.\nfunction meet(a, b, c, d) {\n  const r = [b[0] - a[0], b[1] - a[1]], s = [d[0] - c[0], d[1] - c[1]];\n  const t = ((c[0] - a[0]) * s[1] - (c[1] - a[1]) * s[0]) / (r[0] * s[1] - r[1] * s[0]);\n  return [a[0] + t * r[0], a[1] + t * r[1]];\n}\n// A slanted stroke as a parallelogram from top centre to bottom centre,\n// cut level at both ends, w LEDs wide across.\nfunction bar(xa, ya, xb, yb, w) {\n  const hw = ((w / 2) * Math.hypot(xb - xa, yb - ya)) / Math.abs(yb - ya);\n  return [[xa - hw, ya], [xa + hw, ya], [xb + hw, yb], [xb - hw, yb]];\n}\n\n// The letters in a box 39 LEDs tall, y down from the cap line.\nconst L = [\n  [[10, 0], [20, 0], [20, 38], [10, 38]],\n  [[4, 0], [26, 0], [21, 4], [9, 4]],\n  [[10, 32], [48, 32], [48, 38], [10, 38]],\n  [[41, 32], [50, 24], [50, 38], [41, 38]],\n  [[3, 38], [10, 33], [10, 38]],\n];\nconst vOL = [4, 0], vIL = [15, 0], vOR = [50, 0], vIR = [43, 0], vA = [27, 39];\nconst vIL2 = [vIL[0] + vA[0] - vOL[0], vIL[1] + vA[1]], vIR2 = [vIR[0] + vA[0] - vOR[0], vIR[1] + vA[1]];\nconst V = [\n  [vOL, vIL, meet(vIL, vIL2, vOR, vA), vA],\n  [vIR, vOR, vA, meet(vIR, vIR2, vOL, vA)],\n  [[-1, 0], [21, 0], [18, 4], [6, 4]],\n  [[38, 0], [55, 0], [48, 4], [40, 4]],\n];\nconst X = [\n  bar(10, 0, 44, 38, 10),\n  bar(40, 0, 12, 38, 6),\n  [[0, 0], [21, 0], [19, 4], [8, 4]],\n  [[31, 0], [47, 0], [41, 4], [33.5, 4]],\n  [[11.5, 34], [18.5, 34], [23, 38], [4, 38]],\n  [[35, 34], [46, 34], [55, 38], [31, 38]],\n];\nconst WORD = [[L, 3], [V, 45], [X, 87]];\n\n// Every polygon as its edges: a point and the inward unit normal.\nfunction build() {\n  const polys = [];\n  for (const [letter, top] of WORD) {\n    let x0 = 1e9, x1 = -1e9;\n    for (const p of letter) for (const q of p) (x0 = min(x0, q[0])), (x1 = max(x1, q[0]));\n    const dx = 31.5 - (x0 + x1) / 2;\n    for (const p of letter) {\n      const pts = p.map((q) => [q[0] + dx, q[1] + top]);\n      let cx = 0, cy = 0;\n      for (const q of pts) (cx += q[0] / pts.length), (cy += q[1] / pts.length);\n      const edges = [];\n      let bx0 = 1e9, bx1 = -1e9, by0 = 1e9, by1 = -1e9;\n      for (let i = 0; i \u003c pts.length; i++) {\n        const a = pts[i], b = pts[(i + 1) % pts.length];\n        let nx = a[1] - b[1], ny = b[0] - a[0];\n        const l = Math.hypot(nx, ny);\n        (nx /= l), (ny /= l);\n        if (nx * (cx - a[0]) + ny * (cy - a[1]) \u003c 0) (nx = -nx), (ny = -ny);\n        edges.push([a[0], a[1], nx, ny]);\n        (bx0 = min(bx0, a[0])), (bx1 = max(bx1, a[0])), (by0 = min(by0, a[1])), (by1 = max(by1, a[1]));\n      }\n      polys.push({ edges, bx0, bx1, by0, by1 });\n    }\n  }\n  return polys;\n}\n\n// Distance in from the outline at (x, y) and the inward normal of the\n// nearest edge, the deepest stroke winning; 0 outside every stroke.\nfunction sample(polys, x, y, out) {\n  let best = 0, nx = 0, ny = 0;\n  for (const P of polys) {\n    if (x \u003c P.bx0 || x > P.bx1 || y \u003c P.by0 || y > P.by1) continue;\n    let d = 1e9, ex = 0, ey = 0;\n    for (const e of P.edges) {\n      const v = (x - e[0]) * e[2] + (y - e[1]) * e[3];\n      if (v \u003c d) (d = v), (ex = e[2]), (ey = e[3]);\n    }\n    if (d > best) (best = d), (nx = ex), (ny = ey);\n  }\n  out[0] = best;\n  out[1] = nx;\n  out[2] = ny;\n}\n\nconst SUB = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]];\n\nexport function setup(params) {\n  const polys = build(), n = W * H, o = [0, 0, 0];\n  const sd = new Float32Array(n * 4), sx = new Float32Array(n * 4), sy = new Float32Array(n * 4), dc = new Float32Array(n);\n  const grain = new Float32Array(n);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      for (let k = 0; k \u003c 4; k++) {\n        sample(polys, x + SUB[k][0], y + SUB[k][1], o);\n        sd[p * 4 + k] = o[0];\n        sx[p * 4 + k] = o[1];\n        sy[p * 4 + k] = o[2];\n      }\n      sample(polys, x + 0.5, y + 0.5, o);\n      dc[p] = o[0];\n      // A fixed grain in the stone, a few percent either way.\n      let h = (x * 374761393 + y * 668265263) | 0;\n      h = Math.imul(h ^ (h >>> 13), 1274126177);\n      grain[p] = 0.94 + 0.12 * (((h ^ (h >>> 16)) >>> 0) / 4294967296);\n    }\n  params.s = { sd, sx, sy, dc, grain, phi: 2.2, hue: 0, wall: 30, elev: 18, lc: [0, 0, 0], kc: [0, 0, 0], fc: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 30, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.wall = cl(k[2] == null ? 30 : k[2], 30, 70);\n  S.elev = 15 + 60 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.phi += (d * 2 * PI * speed) / 24;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { sd, sx, sy, dc, grain, lc, kc, fc } = S;\n  const sl = tan(S.wall * RAD), th = S.elev * RAD, ct = cos(th), st = sin(th), tt = st / ct, nrm = 1 / sqrt(1 + sl * sl);\n  const lx = cos(S.phi), ly = sin(S.phi);\n  // The light's colour, the sky's fill and the uncut stone's tone.\n  hsv(0.12 + S.hue, 0.46, 1.1, lc);\n  hsv(0.62 + S.hue, 0.65, 0.13, kc);\n  hsv(0.62 + S.hue, 0.16, 0.26, fc);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, g = grain[p];\n      // The lip's shadow, followed from the centre toward the light.\n      let shade = 1;\n      const D = sl * dc[p];\n      if (D > 0) {\n        let m = 1e9;\n        for (let j = 1; j \u003c 40; j++) {\n          const rise = j * 0.75 * tt;\n          if (rise > D + 0.6) break;\n          const qx = x + 0.5 + lx * j * 0.75, qy = y + 0.5 + ly * j * 0.75;\n          const ix = floor(qx), iy = floor(qy);\n          const dq = ix \u003c 0 || ix >= W || iy \u003c 0 || iy >= H ? 0 : sl * dc[iy * W + ix];\n          m = min(m, rise - (D - dq));\n        }\n        shade = cl(0.5 + m / 1.2, 0, 1);\n      }\n      let r = 0, gg = 0, b = 0;\n      for (let k = 0; k \u003c 4; k++) {\n        const i = p * 4 + k;\n        if (sd[i] \u003c= 0) {\n          r += fc[0];\n          gg += fc[1];\n          b += fc[2];\n          continue;\n        }\n        const nl = max(0, (sl * ct * (sx[i] * lx + sy[i] * ly) + st) * nrm) * shade;\n        r += lc[0] * nl + kc[0];\n        gg += lc[1] * nl + kc[1];\n        b += lc[2] * nl + kc[2];\n      }\n      const f = (255 / 4) * g;\n      display.setPixel(x, y, min(255, floor(r * f)), min(255, floor(gg * f)), min(255, floor(b * f)));\n    }\n}\n","anagram":"// ===== Patternflow pattern =====\n// Title:   Anagram\n// Family:  type\n// Idea:    A word stands down one side of the tall panel a letter to a band, LISTEN from top to bottom, and its letters, each in a colour of its own, glide across to the other side along S-shaped paths to their places in the next word of the set, SILENT, leaving their paths drawn behind them and a faint copy of the old word where they set out, so that every pair of letters whose order the new word reverses crosses once, a white spark marks each crossing as it happens and a counter at the top counts them to the number of inversions between the two words, 5 from LISTEN to SILENT and 9 on to ENLIST.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: anagrams; the number of inversions between two orderings as a distance (Maurice Kendall, A New Measure of Rank Correlation, Biometrika, 1938); the 5 by 7 capitals and figures of Photon Disk (pattern round 70), copied from autogram.js and redrawn as strokes through their dots so they scale; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Set=0..7, Weight=0..1\n//\n// Knob 1: Hue. Turns every letter's colour round the wheel together. The letters of a set's first word are spread evenly round the wheel at 75% saturation, starting from orange at 0: in LISTEN the L is orange, the I yellow-green, the S green, the T sky blue, the E violet and the N pink.\n// Knob 2: Speed. At 2 a word holds for 1.8 s and the letters take 2.4 s to cross, 4.2 s a word; at 0.2 a word takes 42 s and at 3 2.8 s.\n// Knob 3: Set. Which anagrams: 0 LISTEN SILENT ENLIST TINSEL INLETS, 1 STARE TEARS RATES ASTER, 2 EVIL VILE LIVE VEIL, 3 SPOT STOP POTS TOPS POST OPTS, 4 LEAST SLATE STEAL TALES STALE, 5 HEART EARTH HATER, 6 PETAL PLATE PLEAT LEAPT, 7 RETAINS RETINAS NASTIER STEARIN. The letters grow to fill their bands: 4 LEDs between dots for four letters, 2.7 for six, 2.3 for seven. The crossings per step run from 1 (VEIL to EVIL) to 17 (RETINAS to NASTIER, of the 21 possible).\n// Knob 4: Weight. The stroke through the dots: 0.68 of the dot pitch wide at 0 (1.9 LEDs in LISTEN), 1.52 at 1 (4.2 LEDs), where the dots of a letter run together into a heavy face and the bars of an E nearly close up.\n\n// Two letters cross between word A and word B exactly when B puts them in\n// the other order, because every letter moves on the same clock: its height\n// is y0 + (y1 - y0) e(s), with one e for all, so the gap between two letters\n// is a straight line in e and changes sign once or not at all. The crossings\n// of one step are the inversions of the permutation from A to B, Kendall's\n// distance between the two orderings; the most there can be is n(n-1)/2,\n// when B is A backwards. Where k paths pass through one point, as the L, I\n// and S of LISTEN do on the way to SILENT, that point is k(k-1)/2 crossings\n// and the counter jumps by that many at once.\n\nconst W = 64, H = 128, TOP = 1, BOT = 127;\nconst { floor, round, min, max, sqrt, exp, sin, asin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => u * u * (3 - 2 * u);\n// The inverse of smooth on 0..1.\nconst unsmooth = (e) => 0.5 - sin(asin(1 - 2 * e) / 3);\nconst T_MOVE = 2.4, T_HOLD = 1.8, HUE0 = 0.07;\n\n// Every set is spelt with letters that differ, so each letter is one thing\n// with one path.\nconst SETS = [\n  [\"LISTEN\", \"SILENT\", \"ENLIST\", \"TINSEL\", \"INLETS\"],\n  [\"STARE\", \"TEARS\", \"RATES\", \"ASTER\"],\n  [\"EVIL\", \"VILE\", \"LIVE\", \"VEIL\"],\n  [\"SPOT\", \"STOP\", \"POTS\", \"TOPS\", \"POST\", \"OPTS\"],\n  [\"LEAST\", \"SLATE\", \"STEAL\", \"TALES\", \"STALE\"],\n  [\"HEART\", \"EARTH\", \"HATER\"],\n  [\"PETAL\", \"PLATE\", \"PLEAT\", \"LEAPT\"],\n  [\"RETAINS\", \"RETINAS\", \"NASTIER\", \"STEARIN\"],\n];\n\n// Photon Disk's 5 x 7 face, the letters these words need and the figures,\n// rows from the top (copied from autogram.js).\nconst G57 = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", E: \"##### #.... #.... ####. #.... #.... #####\",\n  H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  L: \"#.... #.... #.... #.... #.... #.... #####\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\",\n  O: \".###. #...# #...# #...# #...# #...# .###.\", P: \"####. #...# #...# ####. #.... #.... #....\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\", S: \".#### #.... #.... .###. ....# ....# ####.\",\n  T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", V: \"#...# #...# #...# #...# #...# .#.#. ..#..\",\n  0: \".###. #...# #..## #.#.# ##..# #...# .###.\", 1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  2: \".###. #...# ....# ...#. ..#.. .#... #####\", 3: \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\",\n  6: \"..##. .#... #.... ####. #...# #...# .###.\", 7: \"##### ....# ...#. ..#.. .#... .#... .#...\",\n  8: \".###. #...# #...# .###. #...# #...# .###.\", 9: \".###. #...# #...# .#### ....# ...#. .##..\",\n};\nfor (const k in G57) G57[k] = G57[k].replace(/ /g, \"\");\n\n// A letter as strokes through its dots: runs along a row or a column, and a\n// diagonal step where two dots touch only at a corner. A dot with no\n// neighbour is a stroke of no length.\nconst STROKES = {};\nfor (const k of \"AEHILNOPRSTV\") {\n  const g = G57[k], on = (x, y) => x >= 0 && x \u003c 5 && y >= 0 && y \u003c 7 && g[y * 5 + x] === \"#\", s = [], used = new Set();\n  for (let y = 0; y \u003c 7; y++)\n    for (let x = 0; x \u003c 5; x++) {\n      if (!on(x, y)) continue;\n      if (on(x + 1, y) && !on(x - 1, y)) {\n        let e = x;\n        while (on(e + 1, y)) e++;\n        s.push([x, y, e, y]);\n        for (let q = x; q \u003c= e; q++) used.add(q + \",\" + y);\n      }\n      if (on(x, y + 1) && !on(x, y - 1)) {\n        let e = y;\n        while (on(x, e + 1)) e++;\n        s.push([x, y, x, e]);\n        for (let q = y; q \u003c= e; q++) used.add(x + \",\" + q);\n      }\n      for (const dx of [-1, 1])\n        if (on(x + dx, y + 1) && !on(x + dx, y) && !on(x, y + 1)) s.push([x, y, x + dx, y + 1]), used.add(x + \",\" + y), used.add(x + dx + \",\" + (y + 1));\n    }\n  for (let y = 0; y \u003c 7; y++) for (let x = 0; x \u003c 5; x++) if (on(x, y) && !used.has(x + \",\" + y)) s.push([x, y, x, y]);\n  STROKES[k] = s;\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The layout of a set: n bands, the dot pitch, the two columns.\nfunction begin(S, set) {\n  const words = SETS[set], n = words[0].length, bh = (BOT - TOP) / n;\n  const c = min(4.1, (bh - 3.5) / 6.4), xl = 2.5 + 2.6 * c;\n  Object.assign(S, { set, words, n, bh, c, xl, xr: W - xl, wi: 0, side: 0, phase: 0, pt: 0, s: 0, move: null, last: null, fade: 0, count: 0 });\n  S.letters = [...words[0]];\n  S.col = S.letters.map(() => [0, 0, 0]);\n  S.at = S.letters.map((_, i) => i);\n}\nconst bandY = (S, b) => TOP + (b + 0.5) * S.bh;\nconst sideX = (S, side) => (side ? S.xr : S.xl);\n\n// The step from the word on show to the next: where each letter goes and\n// where on its way it crosses another.\nfunction plan(S) {\n  const B = S.words[(S.wi + 1) % S.words.length], to = S.letters.map((ch) => B.indexOf(ch));\n  const from = S.at.slice(), xa = sideX(S, S.side), xb = sideX(S, 1 - S.side), cross = [];\n  for (let i = 0; i \u003c S.n; i++)\n    for (let j = i + 1; j \u003c S.n; j++) {\n      const d0 = from[i] - from[j], d1 = to[i] - to[j];\n      if (d0 * d1 >= 0) continue;\n      const e = d0 / (d0 - d1), s = unsmooth(e);\n      cross.push({ s, i, j, x: xa + (xb - xa) * s, y: bandY(S, from[i]) + (to[i] - from[i]) * S.bh * e, at: -1 });\n    }\n  cross.sort((a, b) => a.s - b.s);\n  return { from, to, xa, xb, cross };\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, hw: 1, set: -1, buf: new Float32Array(W * H * 3), t: 0 };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const set = cl(round(k[2] || 0), 0, SETS.length - 1);\n  if (set !== S.set) {\n    const first = S.set \u003c 0;\n    begin(S, set);\n    // The Lab opens with the letters already a third of the way across.\n    if (first) (S.phase = 1), (S.move = plan(S)), (S.pt = 0.36 * T_MOVE * (2 / S.speed));\n  }\n  S.hw = S.c * (0.34 + 0.42 * cl(k[3] || 0, 0, 1));\n  for (let i = 0; i \u003c S.n; i++) hsv(S.hue + HUE0 + i / S.n, 0.75, 1, S.col[i]);\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  if (S.phase === 0 && S.pt >= T_HOLD * sc) {\n    S.phase = 1;\n    S.pt = 0;\n    S.last = S.move;\n    S.move = plan(S);\n  }\n  if (S.phase === 1) {\n    S.s = smooth(cl(S.pt / (T_MOVE * sc), 0, 1));\n    S.fade = cl(1 - S.pt / (0.45 * T_MOVE * sc), 0, 1);\n    let n = 0;\n    for (const x of S.move.cross) if (S.s >= x.s) (n++), x.at \u003c 0 && (x.at = S.t);\n    S.count = n;\n    if (S.pt >= T_MOVE * sc) {\n      S.phase = 0;\n      S.pt = 0;\n      S.s = 1;\n      S.at = S.move.to.slice();\n      S.side = 1 - S.side;\n      S.wi = (S.wi + 1) % S.words.length;\n    }\n  }\n}\n\n// A stroke of half-width hw lit at a, with a glow round it; the brighter\n// of what is there and what it brings wins, channel by channel.\nfunction seg(S, x0, y0, x1, y1, hw, c, a, glow) {\n  const R = hw + (glow ? 4 : 1.5), b = S.buf, dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  const ax = max(0, floor(min(x0, x1) - R)), bx = min(W - 1, floor(max(x0, x1) + R));\n  const ay = max(0, floor(min(y0, y1) - R)), by = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = l2 > 0 ? cl((px * dx + py * dy) / l2, 0, 1) : 0;\n      const dd = sqrt((px - u * dx) ** 2 + (py - u * dy) ** 2) - hw;\n      let v = dd \u003c -0.5 ? 1 : dd \u003c 0.5 ? 0.5 - dd : 0;\n      if (glow) v += glow * exp(-max(0, dd) / 1.3);\n      v *= a;\n      if (v \u003c= 0.004) continue;\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) b[kk + q] = max(b[kk + q], c[q] * min(1, v));\n    }\n}\n\nfunction letter(S, ch, cx, cy, c, a) {\n  const p = S.c;\n  for (const s of STROKES[ch]) seg(S, cx + (s[0] - 2) * p, cy + (s[1] - 3) * p, cx + (s[2] - 2) * p, cy + (s[3] - 3) * p, S.hw, c, a, 0.18);\n}\n\n// Letter i's place on the step m at progress s.\nfunction where(S, m, i, s) {\n  return [m.xa + (m.xb - m.xa) * s, bandY(S, m.from[i]) + (m.to[i] - m.from[i]) * S.bh * smooth(s)];\n}\n\n// The paths of a step up to progress s, lit at a.\nfunction paths(S, m, s, a) {\n  const steps = 48;\n  for (let i = 0; i \u003c S.n; i++) {\n    let [px, py] = where(S, m, i, 0);\n    for (let k = 1; k \u003c= steps; k++) {\n      const u = (k / steps) * s;\n      if (u \u003c= 0) break;\n      const [x, y] = where(S, m, i, u);\n      seg(S, px, py, x, y, 0.45, S.col[i], a, 0);\n      (px = x), (py = y);\n    }\n  }\n}\n\n// The word a step set out from, faint where it stood.\nfunction ghost(S, m, a) {\n  for (let i = 0; i \u003c S.n; i++) letter(S, S.letters[i], m.xa, bandY(S, m.from[i]), S.col[i], a);\n}\n\nfunction sparks(S, m, a, now) {\n  const white = [1, 1, 1];\n  for (const x of m.cross) {\n    if (x.at \u003c 0) continue;\n    const age = now - x.at, f = exp(-age / 0.35);\n    seg(S, x.x, x.y, x.x, x.y, 0.7 + 1.6 * f, white, a * (0.75 + 0.25 * f), 0.5 * f);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.letters) return;\n  const b = S.buf;\n  for (let i = 0; i \u003c W * H; i++) (b[i * 3] = 0.01), (b[i * 3 + 1] = 0.008), (b[i * 3 + 2] = 0.02);\n  // The step before, fading as the letters set out again: its paths, its\n  // sparks and the faint copy of the word it left.\n  if (S.last && S.phase === 1 && S.fade > 0) {\n    paths(S, S.last, 1, 0.55 * S.fade);\n    sparks(S, S.last, 0.8 * S.fade, S.t + 9);\n    ghost(S, S.last, 0.22 * S.fade);\n  }\n  if (S.move) {\n    paths(S, S.move, S.phase === 1 ? S.s : 1, 0.55);\n    ghost(S, S.move, 0.22);\n  }\n  if (S.move) sparks(S, S.move, 1, S.t);\n  // The letters themselves.\n  for (let i = 0; i \u003c S.n; i++) {\n    let x, y;\n    if (S.phase === 1) [x, y] = where(S, S.move, i, S.s);\n    else (x = sideX(S, S.side)), (y = bandY(S, S.at[i]));\n    letter(S, S.letters[i], x, y, S.col[i], 1);\n  }\n  // The count of crossings so far, at the top between the columns, on a\n  // dark patch so the letters passing under it do not hide it.\n  const num = String(S.phase === 1 ? S.count : S.move ? S.move.cross.length : 0);\n  const x0 = round(W / 2 - (num.length * 6 - 1) / 2), y0 = 2;\n  for (let y = y0 - 1; y \u003c= y0 + 7; y++)\n    for (let x = x0 - 1; x \u003c= x0 + num.length * 6 - 1; x++) {\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) b[kk + q] *= 0.25;\n    }\n  for (let n = 0; n \u003c num.length; n++) {\n    const g = G57[num[n]];\n    for (let r = 0; r \u003c 7; r++)\n      for (let q = 0; q \u003c 5; q++) if (g[r * 5 + q] === \"#\") {\n        const kk = ((y0 + r) * W + x0 + n * 6 + q) * 3;\n        b[kk] = b[kk + 1] = b[kk + 2] = 0.95;\n      }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(b[kk], 0, 1) * 255), round(cl(b[kk + 1], 0, 1) * 255), round(cl(b[kk + 2], 0, 1) * 255));\n    }\n}\n","beatty-rhythm":"// ===== Patternflow pattern =====\n// Title:   Beatty Rhythm\n// Family:  rhythm\n// Idea:    Two voices play a score of ticks that falls down the panel, voice A on every tick floor(k alpha) and voice B on every tick floor(k beta) with 1/alpha + 1/beta = 1, in two lanes side by side where each tick fills as it reaches the playhead, and beside them the reason stands as a picture, the square lattice cut along the line of slope alpha - 1 with its lines x = i in A's colour and y = j in B's, which the line crosses exactly once in every tick, filling each cell it enters in the colour of the line it crossed, until a fraction for alpha sends the line through a lattice point, where both voices strike at once and the tick before goes unstruck.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Beatty's theorem (Samuel Beatty, 1926; Lord Rayleigh, 1894), pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Alpha=0..1, Ticks=0..1\n//\n// Knob 1: Hue. Turns the two voices round the wheel together, always opposite and at full strength. At 0 voice A is magenta and voice B green; at 1/6 red and cyan, at 0.25 orange and azure, at 0.5 the opening pair swapped.\n// Knob 2: Speed. Ticks a second, 1.5 for each unit: 3 at the opening 2, so the score falls 15 LEDs a second at 5 rows a tick; 0.3 ticks a second at 0.2 and 4.5 at 3.\n// Knob 3: Alpha. Eight stations, an eighth of the knob each: the golden ratio 1.618 (beta = 2.618, A strikes 61.8% of the ticks), then 8/5, the square root of 2 (beta = 3.414), 7/5, e - 1 = 1.718 (beta = 2.392), 12/7, pi - 2 = 1.142 (beta = 8.062) and 8/7. Each fraction p/q sits after the number it is near, and there the line meets a lattice point every p ticks: both voices strike ticks p, 2p, 3p and nobody strikes p - 1, 2p - 1, ... At pi - 2 voice B strikes every 8th tick fifteen times running and then 9 ticks after; at 8/7 it strikes every 8th tick for ever, and every 8th tick is a double. Alpha stands at the top left in A's colour and beta at the top right in B's.\n// Knob 4: Ticks. Rows to a tick, 5 at the opening (24 ticks on the 120 rows under the labels) up to 12 (10 ticks). A lattice cell spans two ticks, 10 to 24 rows, and is always 20 LEDs wide.\n\n// Beatty's theorem: if alpha > 1 is irrational and 1/alpha + 1/beta = 1,\n// the numbers floor(k alpha) and floor(k beta), k = 1, 2, 3, ..., take every\n// whole number once between them. Rayleigh stated it in The Theory of Sound\n// (1894) and Beatty set it as a problem in the American Mathematical Monthly\n// (1926).\n//\n// The picture is the lattice proof. Take the line from the origin in the\n// direction (1/alpha, 1/beta) and call t = x + y its time: it crosses the\n// line x = i at t = i alpha and the line y = j at t = j beta. Up to time\n// N + 1 it has crossed floor((N + 1)/alpha) + floor((N + 1)/beta) lines,\n// and the two fractional parts add to exactly 1 because the two quotients\n// add to N + 1 and neither is whole, so that is N lines: one more for every\n// tick, never two, never none. Each tick of the score is the stretch of\n// the line from t = n to n + 1, and the lane that lights is the kind of\n// line crossed in it. On the panel t runs up and w = x - t/alpha, how far\n// a point is ahead of the line in x at the same t, runs across, so the line\n// stands upright in the middle of the ribbon and the square lattice leans:\n// its x lines rise to the left, its y lines to the right.\n\nconst W = 64, H = 128, PY = 76, TOP = 8, CX = 42, LW = 9;\nconst { floor, ceil, min, max, round, sqrt, PI, E } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst PHI = (1 + sqrt(5)) / 2;\n\n// The stations of the Alpha knob: each irrational number, then a fraction\n// close to it, where the theorem breaks.\nconst ST = [\n  { a: PHI, la: \"φ\", lb: \"φ+1\" },\n  { p: 8, q: 5, la: \"8/5\", lb: \"8/3\" },\n  { a: sqrt(2), la: \"√2\", lb: \"2+√2\" },\n  { p: 7, q: 5, la: \"7/5\", lb: \"7/2\" },\n  { a: E - 1, la: \"e-1\", lb: \"2.39\" },\n  { p: 12, q: 7, la: \"12/7\", lb: \"12/5\" },\n  { a: PI - 2, la: \"π-2\", lb: \"8.06\" },\n  { p: 8, q: 7, la: \"8/7\", lb: \"8\" },\n];\n\n// 3 by 5 figures and signs, drawn for this pattern; φ, π and √ are wider.\nconst GL = {\n  0: \"### #.# #.# #.# ###\", 1: \".#. ##. .#. .#. ###\", 2: \"### ..# ### #.. ###\", 3: \"### ..# .## ..# ###\",\n  4: \"#.# #.# ### ..# ..#\", 5: \"### #.. ### ..# ###\", 6: \"### #.. ### #.# ###\", 7: \"### ..# ..# .#. .#.\",\n  8: \"### #.# ### #.# ###\", 9: \"### #.# ### ..# ###\", \".\": \"... ... ... ... .#.\", \"/\": \"..# ..# .#. #.. #..\",\n  \"+\": \"... .#. ### .#. ...\", \"-\": \"... ... ### ... ...\", e: \".#. #.# ### #.. .##\",\n  \"φ\": \"..#.. .###. #.#.# .###. ..#..\", \"π\": \"..... ##### .#.#. .#.#. .#..#\", \"√\": \"..### ..#.. #.#.. ##... .#...\",\n};\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = round(v[0] * 255);\n  o[1] = round(v[1] * 255);\n  o[2] = round(v[2] * 255);\n  return o;\n}\n\nconst cdiv = (a, b) => floor((a + b - 1) / b);\n\n// How many multiples of alpha (voice A) and of beta (voice B) have floor n.\nfunction hits(S, n) {\n  const s = S.st;\n  if (n \u003c 1) return [0, 0];\n  if (s.p) {\n    const p = s.p, q = s.q, r = p - q;\n    return [cdiv((n + 1) * q, p) - cdiv(n * q, p), cdiv((n + 1) * r, p) - cdiv(n * r, p)];\n  }\n  return [ceil((n + 1) * S.ia) - ceil(n * S.ia), ceil((n + 1) * S.ib) - ceil(n * S.ib)];\n}\n\nexport function setup(params) {\n  params.s = {\n    T: 40, hue: 0, speed: 2, k: -1, st: ST[0], ia: 1 / PHI, ib: 1 - 1 / PHI, R: 6, S: 20,\n    id: new Int32Array(W * H), code: new Uint8Array(W * H), ca: [0, 0, 0], cb: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ki = min(ST.length - 1, floor(cl(k[2] || 0, 0, 1) * ST.length));\n  if (ki !== S.k) {\n    S.k = ki;\n    S.st = ST[ki];\n    const a = S.st.p ? S.st.p / S.st.q : S.st.a;\n    S.ia = 1 / a;\n    S.ib = 1 - 1 / a;\n  }\n  S.R = 5 + round(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 7);\n  S.T += d * S.speed * 1.5;\n}\n\n// Cell (i, j) of the square lattice, x in [i, i+1) and y in [j, j+1), is on\n// the walk when the times the line spends in its column and in its row meet.\n// Returns 0 when it is not, else when and how it was entered: 1 across a\n// line x = i (voice A), 2 across y = j (voice B), 3 through a corner.\nfunction cell(S, i, j) {\n  if (i \u003c 0 || j \u003c 0) return [0, 0];\n  const s = S.st;\n  if (s.p) {\n    const r = s.p - s.q;\n    // i alpha \u003c (j + 1) beta and j beta \u003c (i + 1) alpha, times q r / p.\n    if (!(i * r \u003c (j + 1) * s.q && j * s.q \u003c (i + 1) * r)) return [0, 0];\n    const ta = i * r, tb = j * s.q;\n    return [ta > tb ? 1 : ta \u003c tb ? 2 : 3, (max(ta, tb) * s.p) / (s.q * r)];\n  }\n  const ta = i / S.ia, tb = j / S.ib;\n  if (!(ta \u003c (j + 1) / S.ib && tb \u003c (i + 1) / S.ia)) return [0, 0];\n  return [ta > tb ? 1 : 2, max(ta, tb)];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { id, code, R } = S, T = S.T, sw = S.S;\n  code.fill(0);\n  id.fill(0);\n  const cells = new Map();\n  const tlo = T - (H - PY) / R - 2, ib0 = floor(tlo * S.ia) - 4, jb0 = floor(tlo * S.ib) - 4;\n  // Every LED's cell of the lattice, visited or not, as 1 + a key; the\n  // line is w = 0, between columns CX - 1 and CX.\n  for (let py = TOP; py \u003c H; py++) {\n    const t = T + (PY - py - 0.5) / R;\n    if (t \u003c= 0) continue;\n    for (let px = 0; px \u003c W; px++) {\n      const w = (px - CX + 0.5) / sw, x = w + t * S.ia, y = t * S.ib - w;\n      const i = floor(x), j = floor(y), key = (i - ib0) * 1024 + (j - jb0);\n      if (!cells.has(key)) cells.set(key, cell(S, i, j));\n      id[py * W + px] = key + 1;\n    }\n  }\n  // 0 off the walk, 1 a cell the walk has entered, 2 one it has yet to enter.\n  const state = (v) => {\n    if (!v) return 0;\n    const c = cells.get(v - 1);\n    return !c[0] ? 0 : c[1] \u003c= T ? 1 : 2;\n  };\n  for (let py = TOP; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, v = id[p];\n      if (!v) continue;\n      const c = cells.get(v - 1), st = state(v), r = px \u003c W - 1 ? id[p + 1] : 0, dn = py \u003c H - 1 ? id[p + W] : 0;\n      if (st === 1) {\n        // Entered: filled in the colour of the voice that crossed into it,\n        // with a dark seam where it meets the next cell.\n        if (!((r !== v && state(r) === 1) || (dn !== v && state(dn) === 1))) code[p] = c[0] === 3 ? (px \u003c CX ? 1 : 2) : c[0];\n        continue;\n      }\n      // Not yet entered: only the lattice lines round it, a line x = i in\n      // voice A's colour and a line y = j in B's, and the line of the walk.\n      for (const q of [r, dn]) {\n        if (!q || q === v || state(q) === 1 || (st !== 2 && state(q) !== 2)) continue;\n        code[p] = floor((q - 1) / 1024) !== floor((v - 1) / 1024) ? 1 : 2;\n      }\n      if (st === 2 && px === CX) code[p] = c[0] === 3 ? 2 : c[0];\n    }\n  // The two voices side by side at the left: one block per tick, voice A\n  // in the outer lane, B in the inner one. A struck block throws a line to\n  // the point where the walk crosses into its next cell.\n  const n0 = floor(T - (H - PY) / R) - 1, n1 = ceil(T + (PY - TOP) / R) + 1;\n  for (let n = max(1, n0); n \u003c= n1; n++) {\n    const [a, b] = hits(S, n);\n    const yb = round(PY - (n - T) * R), ya = yb - R + 1;\n    // Not yet struck: an outline; struck: filled. A tick neither voice\n    // strikes, which only a rational alpha leaves, is a box round both lanes.\n    const done = n \u003c= T;\n    for (let py = max(TOP, ya); py \u003c min(H, yb); py++) {\n      const edge = py === ya || py === yb - 1;\n      for (let px = 0; px \u003c 2 * LW; px++) {\n        const c = px \u003c LW ? 1 : 2, on = c === 1 ? a : b, side = px === 0 || px === 2 * LW - 1;\n        if ((on && (done || edge || side || px === LW - 1 || px === LW)) || (!a && !b && (edge || side))) code[py * W + px] = c;\n      }\n    }\n    const age = T - n;\n    if (age >= 0 && age \u003c 0.7) {\n      const x1 = round(2 * LW + (CX - 2 * LW) * (1 - age / 0.7));\n      for (const [v, inv, c] of [[a, S.ia, 1], [b, S.ib, 2]]) {\n        if (!v) continue;\n        const te = ceil(n * inv - 1e-9) / inv, py = round(PY - (te - T) * R - 0.5);\n        if (py >= TOP && py \u003c H) for (let px = 2 * LW; px \u003c x1; px++) code[py * W + px] = c;\n      }\n    }\n  }\n  // alpha and beta, top left and top right.\n  const label = (s, x0, cc, right) => {\n    const gl = [...s].map((ch) => GL[ch].split(\" \"));\n    let wd = -1;\n    for (const g of gl) wd += g[0].length + 1;\n    let x = right ? W - 1 - wd : x0;\n    for (const g of gl) {\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c g[r].length; q++) if (g[r][q] === \"#\") code[(1 + r) * W + x + q] = cc;\n      x += g[0].length + 1;\n    }\n  };\n  label(S.st.la, 1, 1, false);\n  label(S.st.lb, 0, 2, true);\n  const ca = hsv(S.hue + 5 / 6, S.ca), cb = hsv(S.hue + 1 / 3, S.cb);\n  for (let p = 0; p \u003c W * H; p++) {\n    const c = code[p], x = p % W, y = (p - x) / W;\n    if (c === 1) display.setPixel(x, y, ca[0], ca[1], ca[2]);\n    else if (c === 2) display.setPixel(x, y, cb[0], cb[1], cb[2]);\n    else display.setPixel(x, y, 0, 0, 0);\n  }\n}\n","benford-law":"// ===== Patternflow pattern =====\n// Title:   Benford's Law\n// Family:  data\n// Idea:    The panel is a logarithmic ruler from 1 at the bottom to 10 at the top, cut into nine bands as tall as Benford's shares, 30.1% of the height for the leading digit 1 down to 4.6% for 9, and the powers 2, 4, 8, 16, ... land on it one after another, each a step of log10 2 further up that wraps at the top, so the landings spread evenly up the ruler and each band's bar, its count over its share, swings wildly for the first powers and closes onto one dotted line by the thousandth, while a ratio such as the square root of 10 lands on two bands only and never gets there.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Benford's law (Simon Newcomb, 1881; Frank Benford, 1938), equidistribution of n x mod 1 (Hermann Weyl, 1916); 5 by 7 figures from Photon Disk (pattern round 70), copied from autogram.js; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=0..8, Digit=1..2\n//\n// Knob 1: Hue. Turns the band colours round the wheel together. At 0 the band of 1 is cyan and the bands go azure, blue, violet, magenta, rose, orange and yellow to lime for 9; at 0.5 the band of 1 is red, 2 orange, 3 yellow and 9 blue violet. With Digit at 2 the ten second digits run from cyan for 0 to yellow for 9.\n// Knob 2: Speed. The count speeds up as it goes: at 2 the first power lands at 0.6 s, the tenth at 2.8 s, the hundredth at 6.4 s, the thousandth at 10.4 s and the 3000th at 12.3 s; the bars hold 2.5 s, drain in 0.8 s and the count starts again from the first power. At 0.2 all ten times slower, at 3 in two thirds of the time. The readout changes at most eight times a second.\n// Knob 3: Ratio. The common ratio a, in nine steps: 2, 3, 7, 1.1, pi, 1.01, then 10^(1/5) = 1.585, 10^(1/3) = 2.154 and 10^(1/2) = 3.162. For the first six log10 a is irrational and the bars close on the line. The first 1000 powers of 2 count 301, 176, 125, 97, 79, 69, 56, 52 and 45 against Benford's 301, 176, 125, 97, 79, 67, 58, 51 and 46, and after 3000 every bar is within 1.1% of the line, under a third of an LED. pi^2 = 9.87 sits just under 10, so the powers of pi run 3, 9, 3, 9 for eight steps and then walk down in two slow lines, each crossing the decade in about 350 powers: the band of 4 is still empty after 100. 1.01 climbs about a row every two powers and takes 231 for a decade, so after 300 the band of 1 is still half again too long. The last three come back to the same leading digits every 5, 3 and 2 powers: 10^(1/5) lands only on 1, 1, 2, 3 and 6, 10^(1/3) on 1, 2 and 4, the square root of 10 on 1 and 3, and their bars never reach the line. A new ratio starts the count again.\n// Knob 4: Digit. 1 counts the first digit, 2 the second. For the second digit each band of the ruler splits into ten slivers, 90 in all, from 5.3 rows for 10 to 0.6 rows for 99, coloured by the second digit, whose shares run from 12.0% for 0 to 8.5% for 9; Newcomb gave both tables in 1881. The second-digit bars of the first 100 powers of 2 are within 25% of the line and within 2% after 3000. Both counts run all the time, so the knob switches without starting over.\n// Buttons: K1 tap starts the count again from the first power.\n\n// Each power multiplies by a, which adds log10 a to the number's logarithm.\n// Its mantissa, the logarithm mod 1, is the height on the ruler, so a power\n// lands log10 a mod 1 of the ruler above the one before and wraps at the\n// top. When log10 a is irrational Weyl's theorem says the landings fill the\n// ruler evenly, and a band then gets its share of them, its height,\n// log10(1 + 1/d) for the first digit d. A band's bar is its count over the\n// number of powers over that share, 26 LEDs to 1, so a digit that keeps the\n// law ends its bar on the dotted line 26 LEDs in, and one past 2.2 times\n// its share runs off the right edge, which then shows white. Across\n// the right half the newest 28 landings stand from right to left, one\n// column each: a staircase for 1.1, a ramp for 1.01, two falling lines for\n// pi, and level rows for the last three ratios.\n\nconst W = 64, H = 128, X0 = 6, UNIT = 26, NEND = 3000, TRAIL = 28;\nconst { floor, min, max, abs, exp, log10, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The ratios a, by the knob. A fraction p/q is a = 10^(p/q), whose powers\n// come back to the same mantissas every q steps.\nconst RATIOS = [\n  { name: \"2\", l: log10(2) },\n  { name: \"3\", l: log10(3) },\n  { name: \"7\", l: log10(7) },\n  { name: \"1.1\", l: log10(1.1) },\n  { name: \"pi\", l: log10(PI) },\n  { name: \"1.01\", l: log10(1.01) },\n  { name: \"10^(1/5)\", p: 1, q: 5 },\n  { name: \"10^(1/3)\", p: 1, q: 3 },\n  { name: \"10^(1/2)\", p: 1, q: 2 },\n];\n\n// 3 by 5 figures drawn for this pattern, rows from the top.\nconst F35 = [\"### #.# #.# #.# ###\", \".#. ##. .#. .#. ###\", \"##. ..# .#. #.. ###\", \"##. ..# .#. ..# ##.\", \"#.# #.# ### ..# ..#\",\n  \"### #.. ##. ..# ##.\", \".## #.. ### #.# ###\", \"### ..# .#. .#. .#.\", \"### #.# ### #.# ###\", \"### #.# ### ..# ##.\"].map((f) => f.replace(/ /g, \"\"));\n// The figures 0 to 9 of Photon Disk's 5 by 7 face (copied from autogram.js).\nconst F57 = [\n  \".###. #...# #..## #.#.# ##..# #...# .###.\", \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", \".###. #...# ....# ...#. ..#.. .#... #####\",\n  \"##### ...#. ..#.. ...#. ....# #...# .###.\", \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", \"##### #.... ####. ....# ....# #...# .###.\",\n  \"..##. .#... #.... ####. #...# #...# .###.\", \"##### ....# ...#. ..#.. .#... .#... .#...\", \".###. #...# #...# .###. #...# #...# .###.\",\n  \".###. #...# #...# .#### ....# ...#. .##..\",\n].map((f) => f.replace(/ /g, \"\"));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Row y (0 at the top) holds the mantissas from 1 at the bottom to 10 at the\n// top: its centre is the number 10^((127.5 - y) / 128). Each row belongs to\n// the first digit and the second digit of that number.\nconst ROW1 = new Int8Array(H), ROW2 = new Int8Array(H);\nfor (let y = 0; y \u003c H; y++) {\n  const v = pow(10, (127.5 - y) / 128);\n  ROW1[y] = floor(v);\n  ROW2[y] = floor(v * 10) % 10;\n}\n// The law: the first digit d has share log10(1 + 1/d); the second digit e\n// the sum over d of log10(1 + 1/(10d + e)), 12.0% for 0 down to 8.5% for 9.\nconst SHARE1 = [0], SHARE2 = [];\nfor (let d = 1; d \u003c= 9; d++) SHARE1.push(log10(1 + 1 / d));\nfor (let e = 0; e \u003c= 9; e++) {\n  let s = 0;\n  for (let d = 1; d \u003c= 9; d++) s += log10(1 + 1 / (10 * d + e));\n  SHARE2.push(s);\n}\n// Band d runs from row TOP1[d] to row TOP1[d - 1] - 1 (TOP1[0] = 128).\nconst BOT1 = [], TOP1 = [];\nfor (let d = 1; d \u003c= 9; d++) {\n  let a = H, b = -1;\n  for (let y = 0; y \u003c H; y++) if (ROW1[y] === d) (a = min(a, y)), (b = max(b, y));\n  TOP1[d] = a;\n  BOT1[d] = b;\n}\n\nfunction mantissa(R, n) {\n  if (R.q) return ((n * R.p) % R.q) / R.q;\n  const t = n * R.l;\n  return t - floor(t);\n}\n\nfunction restart(S) {\n  S.c1.fill(0);\n  S.c2.fill(0);\n  S.n = 0;\n  S.t = 0;\n  S.phase = 0;\n  S.pt = 0;\n  S.flash.length = 0;\n  S.shown = -1;\n  S.last = null;\n  S.label = null;\n  S.drain = 1;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, ratio: -1, digit: 1, btn: false, time: 0,\n    c1: new Float64Array(10), c2: new Float64Array(10), n: 0, t: 0, phase: 0, pt: 0, drain: 1,\n    flash: [], shown: -1, label: 0, labelT: -1, rgb: [0, 0, 0], col: [0, 0, 0],\n    out: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\n// One power: count its first and second digits, and flash its row.\nfunction land(S, n) {\n  const R = RATIOS[S.ratio], m = mantissa(R, n), v = pow(10, m);\n  const d1 = min(9, floor(v + 1e-9)), d2 = floor(v * 10 + 1e-9) % 10;\n  S.c1[d1]++;\n  S.c2[d2]++;\n  const y = cl(127 - floor(m * 128), 0, H - 1);\n  S.flash.push({ y, t: S.time, d1, d2 });\n  if (S.flash.length > TRAIL) S.flash.shift();\n  S.last = { n, y, v };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ratio = cl(round(k[2] || 0), 0, RATIOS.length - 1);\n  S.digit = cl(round(k[3] == null ? 1 : k[3]), 1, 2);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (ratio !== S.ratio || (btn && !S.btn)) {\n    S.ratio = ratio;\n    restart(S);\n  }\n  S.btn = btn;\n  S.time += d;\n  const sp = S.speed / 2;\n  if (S.phase === 0) {\n    // The count speeds up: n = 2.5 (2^(t / 1.2) - 1) at Speed 2, so the\n    // first powers come about a second apart and the 3000th at 12.3 s.\n    S.t += d * sp;\n    S.drain = min(1, S.drain + d * 3);\n    const want = min(NEND, floor(2.5 * (pow(2, S.t / 1.2) - 1)));\n    while (S.n \u003c want) land(S, ++S.n);\n    if (S.n >= NEND) (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    S.pt += d * sp;\n    if (S.pt > 2.5) (S.phase = 2), (S.pt = 0);\n  } else {\n    S.pt += d * sp;\n    S.drain = max(0, 1 - S.pt / 0.6);\n    if (S.pt > 0.8) restart(S), (S.drain = 0);\n  }\n  // The readout follows the newest power, at most eight times a second.\n  if (S.last && S.last.n !== S.shown && S.time - S.labelT >= 0.125) {\n    S.shown = S.last.n;\n    S.labelT = S.time;\n    S.label = S.last;\n  }\n}\n\nfunction put(o, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const k = (y * W + x) * 3;\n  o[k] = c[0] * a;\n  o[k + 1] = c[1] * a;\n  o[k + 2] = c[2] * a;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.out, col = S.col, n = max(1, S.n), two = S.digit === 2;\n  const share = two ? SHARE2 : SHARE1, cnt = two ? S.c2 : S.c1;\n  const glow = S.phase === 1 ? 0.5 + 0.5 * Math.sin(S.pt * 6) : 0;\n  // Flash strength per row.\n  // Flash strength per row: the newest four powers, each fading in 0.15 s.\n  const fl = new Float32Array(H), F = S.flash;\n  for (let i = F.length - 1, r = 0; i >= 0 && r \u003c 4; i--, r++) fl[F[i].y] = max(fl[F[i].y], exp(-r / 2 - (S.time - F[i].t) / 0.15));\n  for (let y = 0; y \u003c H; y++) {\n    const cls = two ? ROW2[y] : ROW1[y];\n    const hue = two ? S.hue + 0.5 + cls * 0.074 : S.hue + 0.5 + (cls - 1) * 0.094;\n    const ratio = S.n > 0 ? cnt[cls] / n / share[cls] : 0;\n    const fx = X0 + UNIT * ratio * S.drain;\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      let r = 0, g = 0, b = 0;\n      if (x >= X0) {\n        if (x + 1 \u003c= fx) {\n          // The bar, its last column brightest.\n          const edge = x + 2 > fx ? 1 : 0;\n          hsv(hue, edge ? 0.45 : 0.72, edge ? 1 : 0.86, col);\n        } else if (x \u003c fx) {\n          const f = fx - x;\n          hsv(hue, 0.45, 0.18 + 0.82 * f, col);\n        } else hsv(hue, 0.35, 0.13, col);\n        (r = col[0]), (g = col[1]), (b = col[2]);\n        if (fl[y] > 0) {\n          const a = 0.7 * fl[y];\n          r += (1 - r) * a;\n          g += (1 - g) * a;\n          b += (1 - b) * a;\n        }\n      }\n      o[k] = r;\n      o[k + 1] = g;\n      o[k + 2] = b;\n    }\n    // A bar past the edge of the panel ends in a white column.\n    if (X0 + UNIT * ratio * S.drain > W) put(o, W - 1, y, [1, 1, 1], 0.9);\n    // Benford's line: where every bar ends when the digits keep the law.\n    if (y % 2 === 0) {\n      const k = (y * W + X0 + UNIT) * 3, a = 0.55 + 0.45 * glow;\n      o[k] = max(o[k], a);\n      o[k + 1] = max(o[k + 1], a);\n      o[k + 2] = max(o[k + 2], a);\n    }\n  }\n  // The ruler: a tick at each digit 1 to 9 and the digit beside its band.\n  for (let d = 1; d \u003c= 9; d++) {\n    const yb = BOT1[d], yt = TOP1[d], mid = floor((yb + yt) / 2) - 2;\n    hsv(S.hue + 0.5 + (d - 1) * 0.094, two ? 0 : 0.5, 1, col);\n    for (let x = 0; x \u003c X0 - 1; x++) put(o, x, yb, col, 0.35);\n    const f = F35[d];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (f[r * 3 + q] === \"#\") put(o, 1 + q, mid + r, col, 0.95);\n  }\n  // The orbit: the newest 28 powers from right to left, one column each, at\n  // the rows they landed on.\n  const F2 = S.flash, fade = S.phase === 2 ? S.drain : 1;\n  for (let i = F2.length - 1, j = 0; i >= 0; i--, j++) {\n    const f = F2[i], x = W - 2 - j;\n    if (x \u003c= X0 + UNIT + 1) break;\n    const c = two ? f.d2 : f.d1;\n    hsv(two ? S.hue + 0.5 + c * 0.074 : S.hue + 0.5 + (c - 1) * 0.094, 0.3, 1, col);\n    put(o, x, f.y, col, fade * (1 - (0.6 * j) / TRAIL));\n  }\n  // The newest power's first four digits, beside the row it landed on.\n  if (S.label && S.phase !== 2) {\n    const v = floor(S.label.v * 1000 + 1e-6), s = [floor(v / 1000), -1, floor(v / 100) % 10, floor(v / 10) % 10, v % 10];\n    const top = cl(S.label.y - 3, 1, H - 8), x1 = W - 4;\n    const wid = 4 * 6 + 2;\n    for (let y = top - 1; y \u003c= top + 7; y++) for (let x = x1 - wid; x \u003c= x1 + 1; x++) put(o, x, y, [0, 0, 0], 0);\n    const lv = S.label.v;\n    hsv(two ? S.hue + 0.5 + (floor(lv * 10 + 1e-9) % 10) * 0.074 : S.hue + 0.5 + (min(9, floor(lv + 1e-9)) - 1) * 0.094, 0.25, 1, col);\n    let x = x1 - wid + 1;\n    for (const c of s) {\n      if (c \u003c 0) {\n        put(o, x, top + 6, col, 1);\n        x += 2;\n        continue;\n      }\n      const f = F57[c];\n      for (let r = 0; r \u003c 7; r++) for (let q = 0; q \u003c 5; q++) if (f[r * 5 + q] === \"#\") put(o, x + q, top + r, col, 1);\n      x += 6;\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(o[k], 0, 1) * 255), round(cl(o[k + 1], 0, 1) * 255), round(cl(o[k + 2], 0, 1) * 255));\n    }\n}\n","cistercian-numerals":"// ===== Patternflow pattern =====\n// Title:   Cistercian Numerals\n// Family:  type\n// Idea:    One Cistercian cipher stands the full height of the panel, a single stave 122 rows long carrying the units in its top right corner, the tens top left, the hundreds bottom right and the thousands bottom left, and it counts, each corner swinging shut against the stave like a door and opening again on its next figure, so when it counts by one the units corner flaps four times a second, the tens every 2.5 s and the hundreds hardly ever, while a small readout in Arabic figures beside the middle of the stave says the same number.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the ciphers of the Cistercian monks, from the 13th century, in the forms David A. King tabulates in The Ciphers of the Monks (2001); the Fibonacci numbers mod 10000 (Pisano period 15000); 5 by 7 figures from Photon Disk (pattern round 70), copied from autogram.js; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Count=0..3, Weight=0..1\n//\n// Knob 1: Hue. Turns the four corner colours round the wheel together. At 0 the units are gold, the tens lime, the hundreds aquamarine and the thousands blue, 0.17 of a turn apart; the stave is the units colour washed nearly white.\n// Knob 2: Speed. How often the number changes. Counting by one it steps 4 times a second at 2, 0.4 at 0.2 and 6 at 3; the other counts step 1.2 times a second at 2 (0.12 at 0.2, 1.8 at 3) because all four corners turn at once. A corner takes 0.3 s to swing shut and open, never more than 85% of a step.\n// Knob 3: Count. What is counted: 0 counts by one from a random number whose four figures are all 1 to 9, 1 the Fibonacci numbers mod 10000, 2 the 1229 primes below 10000 and 3 the squares 1 to 9801. Each wraps round at its end; a new count starts at a random place in it.\n// Knob 4: Weight. The stroke: 3.3 LEDs wide at 0, 6 at 0.5 and 8.6 at 1, each with a glow about 2 LEDs deep, so at 1 the narrow angle of a 3, 4 or 5 fills in where it meets the stave.\n\n// Each corner is a box QW LEDs wide and QH tall against one end of the stave.\n// In the box of the units, u runs from the stave out to the right (0..1) and\n// v from the top end of the stave down (0..1). The nine figures in the\n// convention the modern tables take from King (2001):\n//   1 a bar along the top            (0,0)-(1,0)\n//   2 a bar along the bottom         (0,1)-(1,1)\n//   3 a diagonal down, away          (0,0)-(1,1)\n//   4 a diagonal up, away            (0,1)-(1,0)\n//   5 = 1 + 4, a closed triangle\n//   6 the outer upright              (1,0)-(1,1)\n//   7 = 1 + 6, 8 = 2 + 6, 9 = 1 + 2 + 6, a closed square against the stave.\n// The manuscripts do not all draw them alike; this pattern keeps the\n// convention above throughout. The tens are the units mirrored left to\n// right, the hundreds the units mirrored top to bottom (their 1 runs along\n// the foot of the stave), the thousands both. A blank corner is a 0; the\n// bare stave is 0.\n\nconst W = 64, H = 128, SX = 32, Y0 = 3, Y1 = 125, QW = 26, QH = 40;\nconst { floor, round, min, max, abs, sqrt, cos, sin, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst HUE0 = 0.12, HSTEP = 0.17, FLIP = 0.3;\n\nconst B1 = [0, 0, 1, 0], B2 = [0, 1, 1, 1], D3 = [0, 0, 1, 1], D4 = [0, 1, 1, 0], U6 = [1, 0, 1, 1];\nconst FIGURE = [[], [B1], [B2], [D3], [D4], [B1, D4], [U6], [B1, U6], [B2, U6], [B1, B2, U6]];\n// Which way u and v run for units, tens, hundreds and thousands.\nconst SIDE = [1, -1, 1, -1], END = [0, 0, 1, 1];\n\n// The figures 0 to 9 of Photon Disk's 5 x 7 face, rows from the top\n// (copied from autogram.js).\nconst FIG = [\n  \".###. #...# #..## #.#.# ##..# #...# .###.\", \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  \".###. #...# ....# ...#. ..#.. .#... #####\", \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", \"##### #.... ####. ....# ....# #...# .###.\",\n  \"..##. .#... #.... ####. #...# #...# .###.\", \"##### ....# ...#. ..#.. .#... .#... .#...\",\n  \".###. #...# #...# .###. #...# #...# .###.\", \".###. #...# #...# .#### ....# ...#. .##..\",\n].map((f) => f.replace(/ /g, \"\"));\n// The readout's left edge for thousands, hundreds, tens and units, and its top row.\nconst RX = [15, 21, 38, 44], RY = 61;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The primes below 10000 by the sieve of Eratosthenes.\nconst PRIMES = [];\n{\n  const comp = new Uint8Array(10000);\n  for (let n = 2; n \u003c 10000; n++) {\n    if (comp[n]) continue;\n    PRIMES.push(n);\n    for (let m = n * n; m \u003c 10000; m += n) comp[m] = 1;\n  }\n}\n\n// A new count of kind k at a random place in it.\nfunction start(S, k) {\n  S.kind = k;\n  if (k === 0) {\n    S.val = 0;\n    for (let p = 0; p \u003c 4; p++) S.val = S.val * 10 + 1 + floor(Math.random() * 9);\n  } else if (k === 1) {\n    (S.fa = 0), (S.fb = 1);\n    for (let i = floor(Math.random() * 400) + 12; i > 0; i--) [S.fa, S.fb] = [S.fb, (S.fa + S.fb) % 10000];\n    S.val = S.fb;\n  } else if (k === 2) {\n    S.pi = 30 + floor(Math.random() * (PRIMES.length - 60));\n    S.val = PRIMES[S.pi];\n  } else {\n    S.sq = 10 + floor(Math.random() * 80);\n    S.val = S.sq * S.sq;\n  }\n}\nfunction step(S) {\n  if (S.kind === 0) S.val = (S.val % 9999) + 1;\n  else if (S.kind === 1) ([S.fa, S.fb] = [S.fb, (S.fa + S.fb) % 10000]), (S.val = S.fb);\n  else if (S.kind === 2) (S.pi = (S.pi + 1) % PRIMES.length), (S.val = PRIMES[S.pi]);\n  else (S.sq = (S.sq % 99) + 1), (S.val = S.sq * S.sq);\n}\n// Hand the number to the four corners; a corner whose figure changed swings.\nfunction show(S, quiet) {\n  for (let p = 0, v = S.val; p \u003c 4; p++, v = floor(v / 10)) {\n    const d = v % 10;\n    if (d === S.dig[p]) continue;\n    S.old[p] = quiet ? d : S.dig[p];\n    S.dig[p] = d;\n    S.t[p] = quiet ? 9 : 0;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, kind: -1, hw: 1.67, acc: 0, val: 0, fa: 0, fb: 1, pi: 0, sq: 1,\n    dig: [0, 0, 0, 0], old: [0, 0, 0, 0], t: [9, 9, 9, 9],\n    buf: new Float32Array(W * H * 3), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], pale: [0, 0, 0],\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.hw = 1.67 + 2.6 * cl(k[3] || 0, 0, 1);\n  const kind = cl(round(k[2] || 0), 0, 3);\n  if (kind !== S.kind) {\n    const first = S.kind \u003c 0;\n    start(S, kind);\n    show(S, first);\n    S.acc = 0;\n  }\n  const rate = (S.kind === 0 ? 2 : 0.6) * S.speed;\n  S.flip = min(FLIP, 0.85 / rate);\n  S.acc += d * rate;\n  for (let p = 0; p \u003c 4; p++) S.t[p] += d;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    step(S);\n    show(S, false);\n  }\n}\n\n// Paint a segment of half-width hw with a glow round it, keeping the\n// brighter of what is there and what it brings, channel by channel.\nfunction seg(S, x0, y0, x1, y1, c, a) {\n  const hw = S.hw, R = hw + 6, b = S.buf;\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  const ax = max(0, floor(min(x0, x1) - R)), bx = min(W - 1, floor(max(x0, x1) + R));\n  const ay = max(0, floor(min(y0, y1) - R)), by = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = l2 > 0 ? cl((px * dx + py * dy) / l2, 0, 1) : 0;\n      const dd = sqrt((px - u * dx) ** 2 + (py - u * dy) ** 2) - hw;\n      const v = a * (dd \u003c -0.5 ? 1 : dd \u003c 0.5 ? 0.5 - dd : 0) + a * 0.26 * exp(-max(0, dd) / 1.6);\n      if (v \u003c= 0.004) continue;\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) b[kk + q] = max(b[kk + q], c[q] * min(1, v));\n    }\n}\n\n// One corner: figure f of place p, its far side at fraction w of full width\n// (1 open, 0 shut against the stave), lit at a.\nfunction corner(S, p, f, w, c, a) {\n  const sx = SIDE[p] * QW * w, top = END[p] === 0;\n  for (const s of FIGURE[f]) {\n    const x0 = SX + s[0] * sx, x1 = SX + s[2] * sx;\n    const y0 = top ? Y0 + s[1] * QH : Y1 - s[1] * QH, y1 = top ? Y0 + s[3] * QH : Y1 - s[3] * QH;\n    seg(S, x0, y0, x1, y1, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const b = S.buf;\n  for (let i = 0; i \u003c W * H; i++) (b[i * 3] = 0.008), (b[i * 3 + 1] = 0.01), (b[i * 3 + 2] = 0.022);\n  for (let p = 0; p \u003c 4; p++) hsv(S.hue + HUE0 + p * HSTEP, 0.72, 1, S.col[p]);\n  hsv(S.hue + HUE0, 0.16, 0.92, S.pale);\n  // The stave first, so the corners' colours win where they meet it.\n  seg(S, SX, Y0, SX, Y1, S.pale, 1);\n  const hot = [0, 0, 0];\n  for (let p = 0; p \u003c 4; p++) {\n    const ph = S.t[p] / S.flip, c = S.col[p];\n    if (ph \u003c 0.5) {\n      // The old figure swings shut: its width goes as the cosine of the turn.\n      const w = cos(PI * ph);\n      corner(S, p, S.old[p], w, c, 0.35 + 0.65 * w);\n    } else {\n      // The new one swings open, white hot at first and cooling in about 0.25 s.\n      const w = ph >= 1 ? 1 : sin(PI * (ph - 0.5)), heat = exp(-max(0, S.t[p] - 0.5 * S.flip) / 0.12);\n      for (let q = 0; q \u003c 3; q++) hot[q] = c[q] + (1 - c[q]) * 0.6 * heat;\n      corner(S, p, S.dig[p], w, hot, 0.35 + 0.65 * w);\n    }\n  }\n  // The readout: thousands, hundreds | tens, units, each in its corner's\n  // colour, flashing as the corner turns.\n  for (let i = 0; i \u003c 4; i++) {\n    const p = 3 - i, f = FIG[S.dig[p]], c = S.col[p], fl = exp(-S.t[p] / 0.25);\n    for (let r = 0; r \u003c 7; r++)\n      for (let q = 0; q \u003c 5; q++) {\n        if (f[r * 5 + q] !== \"#\") continue;\n        const kk = ((RY + r) * W + RX[i] + q) * 3;\n        for (let z = 0; z \u003c 3; z++) b[kk + z] = 0.25 + 0.75 * (c[z] + (1 - c[z]) * (0.35 + 0.65 * fl));\n      }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(b[kk], 0, 1) * 255), round(cl(b[kk + 1], 0, 1) * 255), round(cl(b[kk + 2], 0, 1) * 255));\n    }\n}\n","frieze-letters":"// ===== Patternflow pattern =====\n// Title:   Frieze Letters\n// Family:  type\n// Idea:    Seven strips run down the panel, each one glyph repeated in one of the seven frieze groups the textbook way, b, d, p and q, every glyph coloured by how it sits, and on each beat every strip makes one of its own symmetries, sliding down by its period, gliding, folding pairs of cells over the mirror between them, mirroring across its axis or turning pairs half round, so that it lands exactly where it began, while a caption names one strip at a time by the group its pixels really have, in Conway's words and orbifold signature, so that with a symmetric glyph such as A or H strips built in different ways end as the same frieze under the same name.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the seven frieze groups with John Conway's names and orbifold signatures (John H. Conway, Heidi Burgiel and Chaim Goodman-Strauss, The Symmetries of Things, 2008), shown the textbook way with b, d, p and q; 5 by 7 glyphs, Hangul included, and 3 by 5 caption letters drawn for this pattern, pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Glyph=0..1, Marks=-1..1\n//\n// Knob 1: Hue. Turns the four colours round the wheel together. A glyph's colour says how it sits: at 0 the glyph as drawn (b) is azure, mirrored left to right (d) pink, upside down (p) yellow and turned half round (q) green. Ways of sitting that look alike take the first one's colour, so A and its mirror are both azure and the upside-down A is yellow.\n// Knob 2: Speed. A beat lasts 3 / Speed seconds, 1.5 s at the opening 2: every strip makes its motion in the first 0.9 s and holds for 0.6 s. 15 s at 0.2, 1 s at 3. The caption moves to the next strip every two beats.\n// Knob 3: Glyph. Ten glyphs, a tenth of the knob each: b, F, R, J, ㄱ and 가 have no symmetry of their own and give seven different friezes. N has a half-turn: hop and spinning hop draw the same strip, and so do step and sidle, five pictures in four groups. E has a mirror across: hop is sidle, step is spinning hop and jump is spinning jump, four pictures in three groups. A has a mirror down its middle: hop and step are one picture, sidle, spinning hop and spinning sidle another, and only two groups are left, jump and spinning jump. H has both, and all seven strips are spinning jump.\n// Knob 4: Marks. The symmetry of each strip as the pixels have it, in grey under the glyphs: a line across the strip at each mirror across it, a small diamond at each half-turn centre, a line down the axis for a mirror along it and a dotted line for a glide. Off at -1, 35% grey at the opening 0.06, 90% at 1. At any setting the mirror, centre or axis a strip is moving about flashes white while it moves.\n// Buttons: K1 tap starts the next beat at once.\n\nconst W = 64, H = 128, GW = 5, GH = 7, CH = 12, TOPY = -3, FBOT = 112;\nconst { floor, min, max, round, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\n// The glyphs, 5 by 7, drawn for this pattern.\nconst GLYPHS = [\n  \"#.... #.... #.##. ##..# #...# #...# ####.\", // b\n  \"##### #.... #.... ####. #.... #.... #....\", // F\n  \"####. #...# #...# ####. #.#.. #..#. #...#\", // R\n  \"..### ...#. ...#. ...#. ...#. #..#. .##..\", // J\n  \"##### ....# ....# ....# ....# ...#. ..#..\", // ㄱ\n  \"...#. ##.#. .#.#. .#.## .#.#. #..#. ...#.\", // 가\n  \"#...# #...# ##..# #.#.# #..## #...# #...#\", // N, a half-turn\n  \"##### #.... #.... ####. #.... #.... #####\", // E, a mirror across\n  \".###. #...# #...# ##### #...# #...# #...#\", // A, a mirror along\n  \"#...# #...# #...# ##### #...# #...# #...#\", // H, both\n].map((s) => s.replace(/ /g, \"\").split(\"\").map((c) => c === \"#\"));\n\n// The four ways a glyph can sit: as drawn, mirrored left to right (b to d),\n// upside down (b to p), turned half round (b to q).\nconst I = 0, V = 1, M = 2, R = 3;\n// Doing one after another is t ^ u: the four form the Klein group, V M = R.\nfunction variant(g, t) {\n  const o = new Array(GW * GH);\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      const sx = t & 1 ? GW - 1 - x : x, sy = t & 2 ? GH - 1 - y : y;\n      o[y * GW + x] = g[sy * GW + sx];\n    }\n  return o;\n}\n\n// The seven friezes, each strip running down the panel. A cell holds one\n// glyph, or two in the jumps, the second the first mirrored across the\n// strip's axis. The textbook runs its friezes across the page; here they run\n// down, so b to d is the mirror along the axis and b to p the mirror across\n// it, and the textbook's sidle, b d b d, is b p b p. seq gives how the glyph\n// sits in a cell by its place in the period, and ops the motions the strip\n// makes, one a beat, in turn. Each is a symmetry of the strip, so it ends\n// where it began: T slides the strip down n cells, G mirrors it across its\n// axis as it slides, A mirrors it across its axis, Mp folds each pair of\n// cells over the mirror between them and Rp turns each pair half round about\n// the centre between them.\nconst FRIEZES = [\n  { name: \"HOP\", sig: \"∞∞\", seq: [I], ops: [[\"T\", 1]] },\n  { name: \"STEP\", sig: \"∞×\", seq: [I, V], ops: [[\"G\", 1]] },\n  { name: \"SIDLE\", sig: \"*∞∞\", seq: [I, M], ops: [[\"Mp\"], [\"T\", 2]] },\n  { name: \"SPINNING HOP\", sig: \"22∞\", seq: [I, R], ops: [[\"Rp\"], [\"T\", 2]] },\n  { name: \"SPINNING SIDLE\", sig: \"2*∞\", seq: [I, M, V, R], ops: [[\"Mp\"], [\"Rp\"], [\"G\", 2], [\"T\", 4]] },\n  { name: \"JUMP\", sig: \"∞*\", seq: [I], twin: true, ops: [[\"A\"], [\"T\", 1]] },\n  { name: \"SPINNING JUMP\", sig: \"*22∞\", seq: [I, M], twin: true, ops: [[\"A\"], [\"Mp\"], [\"Rp\"], [\"T\", 2]] },\n];\nconst COLX = [0, 8, 16, 24, 32, 40, 53];\nconst colW = (f) => (FRIEZES[f].twin ? 2 * GW + 1 : GW);\n// Slot j, counted down from the top, holds the cell with place -j.\nconst seqAt = (f, k) => {\n  const s = FRIEZES[f].seq;\n  return s[((k % s.length) + s.length) % s.length];\n};\nconst tauAt = (f, j) => seqAt(f, -j);\n\n// 3 by 5 capitals for the caption, N and M wider, and the orbifold signs.\nconst CAP = {\n  H: \"#.# #.# ### #.# #.#\", O: \".#. #.# #.# #.# .#.\", P: \"##. #.# ##. #.. #..\", S: \".## #.. .#. ..# ##.\",\n  T: \"### .#. .#. .#. .#.\", E: \"### #.. ##. #.. ###\", I: \"### .#. .#. .#. ###\", D: \"##. #.# #.# #.# ##.\",\n  L: \"#.. #.. #.. #.. ###\", N: \"#..# ##.# #.## #..# #..#\", G: \".## #.. #.# #.# .##\", J: \"..# ..# ..# #.# .#.\",\n  U: \"#.# #.# #.# #.# ###\", M: \"#...# ##.## #.#.# #...# #...#\", 2: \"##. ..# .#. #.. ###\",\n  \"∞\": \"..... .#.#. #.#.# .#.#. .....\", \"*\": \"..#.. #.#.# .###. #.#.# ..#..\", \"×\": \"... #.# .#. #.# ...\", \" \": \". . . . .\",\n};\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const c = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  for (let q = 0; q \u003c 3; q++) o[q] = v * (1 - s + s * c[q]);\n  return o;\n}\n\n// Four cells of a frieze, a whole period of every one, as a bitmap laid out\n// like slots 0 to 3, so the marks found in it fall where the cells are drawn.\nfunction periodMap(f, vars) {\n  const cw = colW(f), L = 4 * CH, b = new Uint8Array(L * cw);\n  for (let m = 0; m \u003c 4; m++) {\n    const t = tauAt(f, m);\n    const put = (v, x0) => {\n      for (let y = 0; y \u003c GH; y++) for (let x = 0; x \u003c GW; x++) if (v[y * GW + x]) b[(m * CH + y) * cw + x0 + x] = 1;\n    };\n    put(vars[t], 0);\n    if (FRIEZES[f].twin) put(vars[t ^ V], GW + 1);\n  }\n  return b;\n}\n\n// Which of the seven groups a frieze of this glyph really has, found from\n// the pixels: a symmetric glyph adds symmetry, and two constructions can\n// end in the same frieze. Also where its mirrors and half-turn centres are.\nfunction analyse(f, vars) {\n  const cw = colW(f), L = 4 * CH, b = periodMap(f, vars);\n  const at = (y, x) => b[(((y % L) + L) % L) * cw + x];\n  const test = (fn) => {\n    for (let y = 0; y \u003c L; y++) for (let x = 0; x \u003c cw; x++) if (at(y, x) !== fn(y, x)) return false;\n    return true;\n  };\n  const axis = test((y, x) => at(y, cw - 1 - x));\n  const mir = [], rot = [];\n  for (let h = 0; h \u003c 2 * L; h++) {\n    if (test((y, x) => at(h - y, x))) mir.push(h);\n    if (test((y, x) => at(h - y, cw - 1 - x))) rot.push(h);\n  }\n  let glide = false;\n  for (let s = 1; s \u003c L && !axis && !glide; s++) glide = test((y, x) => at(y + s, cw - 1 - x));\n  const g = axis && mir.length ? 6 : axis ? 5 : mir.length && rot.length ? 4 : mir.length ? 2 : rot.length ? 3 : glide ? 1 : 0;\n  return { g, axis, glide, mir, rot };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, gi: -1, marks: 0.5, ph: 0, vars: null, cls: [0, 1, 2, 3], an: [],\n    buf: new Float32Array(W * H * 3), pal: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const gi = min(GLYPHS.length - 1, floor(cl(k[2] || 0, 0, 1) * GLYPHS.length));\n  if (gi !== S.gi) {\n    S.gi = gi;\n    S.vars = [I, V, M, R].map((t) => variant(GLYPHS[gi], t));\n    // Ways of sitting that look the same share a colour: b, d, p and q are\n    // four, A and its mirror are one.\n    S.cls = [I, V, M, R].map((t) => {\n      for (let u = 0; u \u003c t; u++) if (S.vars[u].every((v, i) => v === S.vars[t][i])) return u;\n      return t;\n    });\n    S.an = FRIEZES.map((_, f) => analyse(f, S.vars));\n  }\n  S.marks = (cl(k[3] == null ? 0.06 : k[3], -1, 1) + 1) / 2;\n  if (input.btnPressed && input.btnPressed[0]) S.ph = floor(S.ph) + 1;\n  S.ph += (d * S.speed) / 3;\n}\n\n// One glyph through an affine motion: the LED at p shows the glyph's pixel\n// at A^-1 (p - c), counted from the glyph's centre, c being where that\n// centre has got to.\nfunction glyph(S, src, a, b, c, d, cx, cy, col) {\n  const det = a * d - b * c || 1e-3, buf = S.buf;\n  for (let y = max(0, floor(cy - 5)); y \u003c= min(FBOT - 1, floor(cy + 5)); y++)\n    for (let x = max(0, floor(cx - 5)); x \u003c= min(W - 1, floor(cx + 5)); x++) {\n      const px = x + 0.5 - cx, py = y + 0.5 - cy;\n      const gx = floor((d * px - b * py) / det + GW / 2), gy = floor((-c * px + a * py) / det + GH / 2);\n      if (gx \u003c 0 || gx >= GW || gy \u003c 0 || gy >= GH || !src[gy * GW + gx]) continue;\n      const q = (y * W + x) * 3;\n      buf[q] = col[0];\n      buf[q + 1] = col[1];\n      buf[q + 2] = col[2];\n    }\n}\n\nfunction mark(S, x, y, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= FBOT) return;\n  const q = (y * W + x) * 3;\n  S.buf[q] = S.buf[q + 1] = S.buf[q + 2] = max(S.buf[q], a);\n}\n\n// The gaps (j, j + 1) where the cell below is the cell above under op t:\n// M for a mirror across the strip, R for a half-turn. Taken top down so no\n// cell is in two pairs.\nfunction pairs(f, t, j0, j1) {\n  const out = [];\n  for (let j = j0; j \u003c j1; j++) if ((tauAt(f, j) ^ tauAt(f, j + 1)) === t) out.push(j++);\n  return out;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.vars) return;\n  const b = S.buf;\n  b.fill(0);\n  // A beat: every strip makes its next motion in the first 60%, then holds.\n  const beat = floor(S.ph), u = S.ph - beat, e = ease(min(1, u / 0.6)), fl = sin(PI * min(1, u / 0.6));\n  const hl = floor(beat / 2) % FRIEZES.length;\n  for (let c = 0; c \u003c 4; c++) hsv(S.hue + [0.58, 0.9, 0.14, 0.36][c], 0.75, 1, S.pal[c]);\n  const ma = 0.9 * S.marks ** 1.5;\n  for (let f = 0; f \u003c FRIEZES.length; f++) {\n    const fr = FRIEZES[f], an = S.an[f], x0 = COLX[f], cw = colW(f), ax = x0 + cw / 2;\n    const op = fr.ops[beat % fr.ops.length], kind = op[0], n = op[1] || 0;\n    const yc = (j) => TOPY + j * CH + GH / 2;\n    const gx = fr.twin ? [x0 + GW / 2, x0 + GW + 1 + GW / 2] : [x0 + GW / 2];\n    const mp = kind === \"Mp\" ? pairs(f, M, -5, 16) : [];\n    const rp = kind === \"Rp\" ? pairs(f, fr.twin ? M : R, -5, 16) : [];\n    // Marks of the strip's real symmetry, under the glyphs: mirrors across\n    // it as lines, half-turn centres as small diamonds, a mirror along the\n    // axis as a line down it and a glide as a dotted one. The ones the\n    // motion uses light up while it moves.\n    const axf = kind === \"A\" || kind === \"G\" ? fl : 0;\n    for (let y = 0; y \u003c FBOT; y++) {\n      if (an.axis || (an.glide && y % 3 === 0)) mark(S, floor(ax), y, ma);\n      if (axf && (kind === \"A\" || y % 3 === 0)) mark(S, floor(ax), y, axf);\n    }\n    for (let j = -1; j \u003c= 12; j++) {\n      const yk = TOPY + j * CH, m = ((j % 4) + 4) % 4;\n      for (const h of an.mir) {\n        const r = floor(h / 2) - m * CH;\n        if (r >= 0 && r \u003c CH) for (let x = x0 - 1; x \u003c= x0 + cw; x++) mark(S, x, yk + r, ma);\n      }\n      for (const h of an.rot) {\n        const r = floor(h / 2) - m * CH;\n        if (r >= 0 && r \u003c CH) for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) mark(S, floor(ax) + dx, yk + r + dy, ma);\n      }\n    }\n    const gapY = TOPY + GH + (CH - GH - 1) / 2;\n    for (const j of mp) for (let x = x0 - 1; x \u003c= x0 + cw; x++) mark(S, x, gapY + j * CH, fl);\n    for (const j of rp) for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) mark(S, floor(ax) + dx, gapY + j * CH + dy, fl);\n    // The glyphs. Each one's colour is the look it lands in, from halfway.\n    const draw1 = (t, t2, c0x, c0y, A, c1x, c1y) => glyph(S, S.vars[t], A[0], A[1], A[2], A[3], c1x, c1y, S.pal[S.cls[e \u003c 0.5 ? t : t2]]);\n    const sc = cos(PI * e), sn = sin(PI * e);\n    for (let j = -n - 1; j \u003c= 12; j++) {\n      const t0 = tauAt(f, j);\n      for (let g = 0; g \u003c gx.length; g++) {\n        const t = g ? t0 ^ V : t0, cx = gx[g], cy = yc(j);\n        if (kind === \"T\") draw1(t, t, cx, cy, [1, 0, 0, 1], cx, cy + n * CH * e);\n        else if (kind === \"G\") draw1(t, t ^ V, cx, cy, [sc, 0, 0, 1], ax + (cx - ax) * sc, cy + n * CH * e);\n        else if (kind === \"A\") draw1(t, t ^ V, cx, cy, [sc, 0, 0, 1], ax + (cx - ax) * sc, cy);\n        else if (kind === \"Mp\") {\n          const p = mp.indexOf(j) >= 0 ? j : mp.indexOf(j - 1) >= 0 ? j - 1 : null;\n          if (p === null) draw1(t, t, cx, cy, [1, 0, 0, 1], cx, cy);\n          else {\n            const ym = gapY + p * CH + 0.5;\n            draw1(t, t ^ M, cx, cy, [1, 0, 0, sc], cx, ym + (cy - ym) * sc);\n          }\n        } else {\n          const p = rp.indexOf(j) >= 0 ? j + 1 : rp.indexOf(j - 1) >= 0 ? j - 1 : null;\n          if (p === null) draw1(t, t, cx, cy, [1, 0, 0, 1], cx, cy);\n          else {\n            // Turned about its own centre while the centre runs straight to\n            // its partner's place: the same end as the half-turn about the\n            // point between them, kept inside the strip.\n            const tx = fr.twin ? gx[1 - g] : cx, ty = yc(p);\n            draw1(t, t ^ R, cx, cy, [sc, -sn, sn, sc], cx + (tx - cx) * e, cy + (ty - cy) * e);\n          }\n        }\n      }\n    }\n  }\n  // The caption: the group of one strip at a time, read from what its\n  // pixels do, under a bar over the strip it names.\n  const an = S.an[hl], fr = FRIEZES[an.g], ink = 0.85;\n  for (let x = COLX[hl]; x \u003c COLX[hl] + colW(hl); x++) for (let y = FBOT + 1; y \u003c FBOT + 3; y++) b.fill(ink, (y * W + x) * 3, (y * W + x) * 3 + 3);\n  const text = (s, y0) => {\n    const gl = [...s].map((ch) => CAP[ch].split(\" \"));\n    let wd = -1;\n    for (const g of gl) wd += g[0].length + 1;\n    let x = floor((W - wd) / 2);\n    for (const g of gl) {\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c g[r].length; q++) if (g[r][q] === \"#\") b.fill(ink, ((y0 + r) * W + x + q) * 3, ((y0 + r) * W + x + q) * 3 + 3);\n      x += g[0].length + 1;\n    }\n  };\n  text(fr.name, FBOT + 5);\n  text(fr.sig, FBOT + 11);\n  for (let p = 0; p \u003c W * H; p++) {\n    const x = p % W, y = (p - x) / W;\n    display.setPixel(x, y, round(cl(b[p * 3], 0, 1) * 255), round(cl(b[p * 3 + 1], 0, 1) * 255), round(cl(b[p * 3 + 2], 0, 1) * 255));\n  }\n}\n","hegselmann-krause":"// ===== Patternflow pattern =====\n// Title:   Hegselmann-Krause\n// Family:  sim\n// Idea:    Four hundred opinions spread over the panel's 64 columns each move, step after step, to the mean of all the opinions within epsilon of their own, and a pen writes the steps down the 128 rows on a clock that slows, so the even wash at the top, every opinion coloured by where it started, gathers into funnels that freeze in about nine steps into six or seven bright rivers some 2.6 epsilon apart, the odd straggler between them, before a fresh set of opinions is written over them from the top.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: bounded confidence model (Rainer Hegselmann and Ulrich Krause, 2002), pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Epsilon=0.03..0.3\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 an opinion that starts at 0 is cyan, one that starts at 0.5 blue violet and one at 1 rose, and a river wears the colour of the mean start of the opinions in it; at 0.5 the same run goes red, orange, lime and teal. Twenty faint stripes, every twentieth of the starting range, run down the wash and pinch together where it gathers.\n// Knob 2: Speed. The pen writes 12 rows a second times the knob: at 2 a run fills the panel in 5.3 s and holds 1.2 s, at 0.2 it takes 53 s and holds 12 s, at 3 it takes 3.6 s.\n// Knob 3: Tilt. Asymmetric confidence: an agent listens epsilon x (1 + Tilt) to its right and epsilon x (1 - Tilt) to its left, the window still 2 epsilon wide. At 0 the symmetric model, whose mean opinion stays at 0.50. At 0.5, with epsilon 0.06, the funnels lean right, a run moves for 16 steps instead of 9 and ends in 4.8 rivers instead of 6.6, and the mean opinion drifts to 0.65. At 1 an agent hears only the opinions at or right of its own, up to 2 epsilon away, and in 277 runs of 300 everyone streams into one river at the right edge.\n// Knob 4: Epsilon. The confidence bound, 0.03 to 0.3, opening at 0.06. Over 300 runs of 400 agents a run ends in 13.0 clusters at 0.03 (1/(2 epsilon) is 16.7), 6.6 at 0.06 (8.3), 3.9 at 0.1 (5), 2.6 at 0.15 (3.3) and 1.9 at 0.2, where 9% of runs reach consensus; at 0.25 96% do, at 0.3 all. A change starts a new run.\n// Buttons: K1 tap starts a new run from the top.\n\n// Each step every agent moves to the mean of the opinions within epsilon of\n// its own, its own included, all at once. Opinions freeze in finite time:\n// once neighbouring clusters are more than epsilon apart nothing moves\n// again. The rule of thumb says about 1/(2 epsilon) clusters. Random starts\n// give fewer: over 300 runs of 400 agents they sat 2.56 epsilon apart at\n// epsilon 0.06 and 2.65 at 0.03, where evenly spaced starts sit about 2.2\n// apart, near the 2 epsilon that Vincent Blondel, Julien Hendrickx and John\n// Tsitsiklis conjectured for them (2009).\n//\n// Step s is drawn on row A ln(1 + s / 6), interpolated between steps, so the\n// first steps, where most of the gathering happens, get the most rows. A\n// grey tick in both margin columns marks each step, and a white one the end\n// of the last step that moves an opinion by more than a tenth of an LED.\n\nconst W = 64, H = 128, N = 400, MAXSTEP = 400;\nconst { floor, min, max, abs, exp, sqrt, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// One run: N opinions drawn uniformly from [0, 1], then the model's steps\n// until no opinion moves. The order of the opinions never changes, so a\n// sorted start stays sorted and each step is one sweep of a sliding window.\nfunction simulate(epsL, epsR) {\n  const x0 = new Float64Array(N);\n  for (let i = 0; i \u003c N; i++) x0[i] = Math.random();\n  x0.sort();\n  const traj = [Float32Array.from(x0)];\n  let x = x0, last = 0;\n  for (let s = 0; s \u003c MAXSTEP; s++) {\n    const y = new Float64Array(N);\n    let lo = 0, hi = 0, sum = 0, move = 0;\n    for (let i = 0; i \u003c N; i++) {\n      while (hi \u003c N && x[hi] \u003c= x[i] + epsR + 1e-12) sum += x[hi++];\n      while (x[lo] \u003c x[i] - epsL - 1e-12) sum -= x[lo++];\n      y[i] = sum / (hi - lo);\n      move = max(move, abs(y[i] - x[i]));\n    }\n    x = y;\n    traj.push(Float32Array.from(y));\n    if (move > 0.0015) last = s + 1;\n    if (move \u003c 1e-9) break;\n  }\n  return { x0: Float32Array.from(x0), traj, steps: last };\n}\n\nfunction newRun(S) {\n  const r = simulate(S.eps * (1 - S.tilt), S.eps * (1 + S.tilt));\n  S.run = r;\n  // The clock slows down the panel: step s sits on row A ln(1 + s / 6), A\n  // chosen so the last step that moves lands on row 96 at the latest and the\n  // first step takes at most 16 rows.\n  S.A = min(16 / Math.log(1 + 1 / 6), 96 / Math.log(1 + max(1, r.steps) / 6));\n  S.pen = 0;\n  S.hold = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, tilt: -1, eps: -1, btn: false,\n    img: new Float32Array(W * H * 2), old: new Float32Array(W * H * 2), rgb: new Float32Array(3),\n    w: new Float32Array(W), wx: new Float32Array(W), wb: new Float32Array(W), drawn: 0, run: null,\n  };\n  return params.s;\n}\n\n// Draw row y of the run into img.\nfunction drawRow(S, y) {\n  const { traj, x0 } = S.run, t = 6 * (exp(y / S.A) - 1), s = floor(t), f0 = t - s, f = f0 * f0 * (3 - 2 * f0);\n  const a = traj[min(s, traj.length - 1)], b = traj[min(s + 1, traj.length - 1)];\n  const { w, wx, wb } = S;\n  w.fill(0);\n  wx.fill(0);\n  wb.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const p = a[i] + (b[i] - a[i]) * f, u = 1 + p * 61, c = floor(u), g = u - c;\n    const br = 0.4 + 0.6 * (0.5 + 0.5 * cos(x0[i] * PI * 40));\n    w[c] += 1 - g;\n    wx[c] += (1 - g) * x0[i];\n    wb[c] += (1 - g) * br;\n    w[c + 1] += g;\n    wx[c + 1] += g * x0[i];\n    wb[c + 1] += g * br;\n  }\n  const o = S.img, rho = W / N;\n  for (let c = 0; c \u003c W; c++) {\n    let best = 0, bh = 0, bb = 0;\n    for (let d = -4; d \u003c= 4; d++) {\n      const cc = c + d;\n      if (cc \u003c 0 || cc >= W || w[cc] \u003c 0.03) continue;\n      const r = w[cc] * rho, hw = max(0, 0.45 * sqrt(r) - 0.35);\n      const cov = cl(hw + 0.5 - abs(d), 0, 1) * cl(w[cc] / 0.25, 0, 1);\n      const v = cov * (0.3 + 0.7 * (1 - exp(-r / 1.5)));\n      if (v > best) (best = v), (bh = wx[cc] / w[cc]), (bb = wb[cc] / w[cc]);\n    }\n    const k = (y * W + c) * 2;\n    o[k] = best * bb;\n    o[k + 1] = bh;\n  }\n  // A tick in both margins on each row where a step falls, a bright one on\n  // the row where the run freezes.\n  const t1 = 6 * (exp((y + 1) / S.A) - 1);\n  if (floor(t1) > s) {\n    const v = s \u003c S.run.steps && floor(t1) >= S.run.steps ? 0.9 : s \u003c S.run.steps ? 0.3 : 0;\n    for (const c of [0, W - 1]) if (v > 0) (o[(y * W + c) * 2] = v), (o[(y * W + c) * 2 + 1] = -1);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const tilt = cl(k[2] || 0, 0, 1), eps = cl(k[3] == null ? 0.06 : k[3], 0.03, 0.3);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.run) {\n    S.tilt = tilt;\n    S.eps = eps;\n    newRun(S);\n    for (let y = 0; y \u003c H; y++) drawRow(S, y);\n    S.old.set(S.img);\n    newRun(S);\n    S.pen = 48;\n    for (let y = 0; y \u003c 48; y++) drawRow(S, y);\n    S.drawn = 48;\n  }\n  if (abs(tilt - S.tilt) > 0.02 || abs(eps - S.eps) > 0.004 || (btn && !S.btn)) {\n    S.tilt = tilt;\n    S.eps = eps;\n    S.old.set(S.img);\n    newRun(S);\n    S.drawn = 0;\n  }\n  S.btn = btn;\n  const rate = 12 * S.speed;\n  if (S.pen \u003c H) S.pen = min(H, S.pen + d * rate);\n  else {\n    S.hold += d;\n    if (S.hold > 2.4 / S.speed) {\n      S.old.set(S.img);\n      newRun(S);\n      S.drawn = 0;\n    }\n  }\n  while (S.drawn \u003c floor(S.pen)) drawRow(S, S.drawn++);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.run) return;\n  const o = S.img, ol = S.old, pen = floor(S.pen), c = S.rgb;\n  for (let y = 0; y \u003c H; y++) {\n    // The newest rows come in brighter and settle in about 10 rows; below\n    // the pen the last run stays, dimmed.\n    const now = y \u003c pen, buf = now ? o : ol, lift = now ? 1 + 0.6 * exp(-(pen - 1 - y) / 4) : 0.38;\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 2, v = buf[k] * lift;\n      if (v \u003c= 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      hsv(S.hue + 0.5 + 0.48 * buf[k + 1], buf[k + 1] \u003c 0 ? 0 : 0.78, cl(v, 0, 1), c, 0);\n      display.setPixel(x, y, floor(c[0] * 255), floor(c[1] * 255), floor(c[2] * 255));\n    }\n  }\n}\n","kanizsa-letters":"// ===== Patternflow pattern =====\n// Title:   Kanizsa Letters\n// Family:  type\n// Idea:    Thirty-two pac-man discs on a 4 by 8 lattice turn at random over a fine diagonal grating, and only when every one swings its cut into line does a letter of EDGE LIGHT stand out in front of them, a surface the colour of the background whose edges the eye draws between the cuts while the grating inside it slips half a period so its lines end on those edges, though no LED ever draws an edge; then the discs let go, spin, turn about and line up into the next letter.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: illusory contours from notched discs (Gaetano Kanizsa, Margini quasi-percettivi in campi con stimolazione omogenea, 1955) and from line ends (Walter Ehrenstein, 1941); abutting gratings (Rüdiger von der Heydt, Esther Peterhans and Günter Baumgartner, 1984); the support ratio (Thomas Shipley and Philip Kellman, 1992); letters on a 3 by 7 grid of cells drawn here, pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gap=0.3..0.8, Period=5..14\n//\n// Knob 1: Hue. Turns both colours round the wheel. At 0 the discs are golden yellow and the grating slate blue; at 0.5 the discs are sky blue and the grating a muted gold.\n// Knob 2: Speed. At 2 a letter takes 7.2 s: the discs swing into line one by one over 2.6 s, each swing 0.45 s, the letter holds 2.4 s, they let go over 1.2 s and spin free for 1 s. A free disc turns at 0.2 to 0.55 turns a second and turns about every 1.7 s on average. At 0.2 it all runs ten times slower.\n// Knob 3: Gap. The share of each letter edge left between the discs for the eye to fill in, one minus Shipley and Kellman's support ratio. A disc's radius is 8 (1 - Gap) LEDs on the 16 LED lattice: 5.6 at 0.3, where 70% of every edge is cut and the letter is plain; 3.2 at 0.6; 1.6 at 0.8, where the cuts are too small to see and the letter stands on the grating's line ends alone.\n// Knob 4: Period. LEDs along a row between grating lines, 5 to 14; the lines run at 45 degrees, 3.5 to 9.9 LEDs apart. Inside the letter they shift by half a period rounded to a whole LED, 3 LEDs at 5 and 7 at 14, and each LED is lit by its distance to the nearest line so that the shift leaves the grating's mean light as it was.\n// Buttons: K1 tap lets the letter go at once and moves on to the next.\n\n// A letter fills cells of the lattice, so every disc sits on a corner of\n// four cells and the letter covers 0 to 4 of its quarters. The quarters it\n// covers are the disc's cut: one quarter at an outer corner, two side by\n// side along an edge, three at an inner corner, two opposite where the\n// letter steps diagonally. A disc the letter does not touch is whole. While\n// the discs spin free each wears one open quarter, a pac-man, so the lattice\n// reads the same whatever letter is coming; as a disc swings into line its\n// mouth turns into the cut the letter asks of it. The letter's own surface\n// is the grating shifted by half a period. It shows through every cut.\n\nconst W = 64, H = 128, N = W * H, TAU = 2 * Math.PI, Q = Math.PI / 2;\nconst { floor, round, min, max, abs, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\n// The lattice: discs on the corners of 16 LED cells, 4 across and 8 down,\n// the first at (8, 8). A letter fills 3 by 7 of the cells.\nconst CELL = 16, OX = 8, OY = 8, NX = 4, NY = 8;\n// Seconds at Speed 2: the discs swing into line one by one, the letter\n// holds, they let go, they spin free.\nconst SETTLE = 2.6, HOLD = 2.4, LETGO = 1.2, FREE = 1, SWING = 0.45, HUE0 = 0.12;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// E D G E L I G H T, rows of 3 cells from the top.\nconst FONT = {\n  E: \"### #.. #.. ### #.. #.. ###\",\n  D: \"##. #.# #.# #.# #.# #.# ##.\",\n  G: \"### #.. #.. #.# #.# #.# ###\",\n  L: \"#.. #.. #.. #.. #.. #.. ###\",\n  I: \"### .#. .#. .#. .#. .#. ###\",\n  H: \"#.# #.# #.# ### #.# #.# #.#\",\n  T: \"### .#. .#. .#. .#. .#. .#.\",\n};\nconst WORD = \"EDGELIGHT\";\nconst cellOf = (g, r, c) => r >= 0 && r \u003c 7 && c >= 0 && c \u003c 3 && g[r * 3 + c] === \"#\";\n\n// Which quarters of each disc the letter covers: quarter k spans the\n// directions k x 90 to (k + 1) x 90 degrees, y down, so 0 is the cell to the\n// lower right, 1 lower left, 2 upper left, 3 upper right.\nfunction notches(ch) {\n  const g = FONT[ch].replace(/ /g, \"\"), out = [];\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c NX; i++) out.push([cellOf(g, j, i), cellOf(g, j, i - 1), cellOf(g, j - 1, i - 1), cellOf(g, j - 1, i)]);\n  return { g, out };\n}\n\nfunction newDisc(i) {\n  return {\n    x: OX + (i % NX) * CELL, y: OY + floor(i / NX) * CELL, th: Math.random() * TAU,\n    om: 1.2 + 2.2 * Math.random(), dir: Math.random() \u003c 0.5 ? -1 : 1, spin: 0,\n    o: [0, 0, 0, 0], from: [0, 0, 0, 0], to: [0, 0, 0, 0], on: 0, off: 0, ft: 0, th0: 0, mode: 0,\n  };\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, gap: 0.3, per: 5, started: false, btn: false, D: [], li: 0, ph: 0, t: 0, sh: 0,\n    g: \"\", cov: new Uint8Array(N), out: new Float32Array(N * 3), lc: [0, 0, 0], dc: [0, 0, 0],\n  });\n  for (let i = 0; i \u003c NX * NY; i++) S.D.push(newDisc(i));\n  return S;\n}\n\n// The mouth a disc wears while it spins free before a letter: one quarter\n// open, one of the quarters the letter will cover if it covers any.\nfunction freeMouth(want) {\n  const ks = [0, 1, 2, 3].filter((k) => want[k]);\n  const k = ks.length ? ks[floor(Math.random() * ks.length)] : floor(Math.random() * 4);\n  return [0, 1, 2, 3].map((q) => (q === k ? 1 : 0));\n}\n\nfunction letter(S, k) {\n  S.li = ((k % WORD.length) + WORD.length) % WORD.length;\n  const { g, out } = notches(WORD[S.li]);\n  S.g = g;\n  S.want = out;\n}\n// Where the letter's own grating lies; set as the discs start to swing in,\n// when the grating is whole again.\nfunction surface(S) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) S.cov[y * W + x] = cellOf(S.g, floor((y - OY) / CELL), floor((x - OX) / CELL)) ? 1 : 0;\n}\n\n// Phases: 0 the discs swing into line one by one, 1 the letter holds, 2 they\n// let go, their mouths turning to the next letter's, 3 they spin free.\nfunction phase(S, p) {\n  S.ph = p;\n  S.t = 0;\n  if (p === 0) surface(S);\n  S.D.forEach((d, i) => {\n    if (p === 0) {\n      d.on = 0.2 + Math.random() * (SETTLE - SWING - 0.4);\n      d.mode = 0;\n      d.from = d.o.slice();\n      d.to = S.want[i].map((b) => (b ? 1 : 0));\n    }\n    if (p === 2) {\n      d.off = Math.random() * 0.6;\n      d.ft = 0;\n      d.from = d.o.slice();\n    }\n  });\n  if (p === 2) {\n    // The next letter is chosen as the discs let go.\n    letter(S, S.li + 1);\n    S.D.forEach((d, i) => (d.to = freeMouth(S.want[i])));\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.3, 5], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.gap = cl(k[2] == null ? 0.3 : k[2], 0.3, 0.8);\n  S.per = cl(k[3] == null ? 5 : k[3], 5, 14);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started) {\n    letter(S, 0);\n    S.D.forEach((d, i) => (d.o = freeMouth(S.want[i])));\n    phase(S, 0);\n    S.started = true;\n  } else if (btn && !S.btn && S.ph \u003c 2) phase(S, 2);\n  S.btn = btn;\n  const d = (d0 * S.speed) / 2;\n  S.t += d;\n  // A free disc turns at its own pace and now and then turns about.\n  for (const c of S.D) {\n    if (Math.random() \u003c d * 0.6) c.dir = -c.dir;\n    c.spin += cl(c.dir - c.spin, -d * 5, d * 5);\n  }\n  let lined = 0;\n  if (S.ph === 0) {\n    for (const c of S.D) {\n      if (c.mode === 0) {\n        c.th += c.om * c.spin * d;\n        if (S.t >= c.on) (c.mode = 1), (c.th0 = wrap(c.th));\n      }\n      if (c.mode === 1) {\n        const u = ease((S.t - c.on) / SWING);\n        c.th = c.th0 * (1 - u);\n        for (let q = 0; q \u003c 4; q++) c.o[q] = c.from[q] + (c.to[q] - c.from[q]) * u;\n        if (S.t - c.on >= SWING) (c.mode = 2), (c.th = 0);\n      }\n      if (c.mode === 2) lined++;\n    }\n    if (S.t >= SETTLE) phase(S, 1);\n  } else if (S.ph === 1) {\n    lined = S.D.length;\n    if (S.t >= HOLD) phase(S, 2);\n  } else {\n    for (const c of S.D) {\n      if (S.ph === 2 && S.t \u003c c.off) {\n        lined++;\n        continue;\n      }\n      // Let go: the spin picks up over 0.3 s and the mouth turns into the\n      // free one over 0.4 s.\n      c.ft += d;\n      c.th += c.om * c.spin * d * min(1, c.ft / 0.3);\n      const e = ease(c.ft / 0.4);\n      for (let q = 0; q \u003c 4; q++) c.o[q] = c.from[q] + (c.to[q] - c.from[q]) * e;\n    }\n    if (S.ph === 2 && S.t >= LETGO) phase(S, 3);\n    else if (S.ph === 3 && S.t >= FREE) phase(S, 0);\n  }\n  // The grating inside the letter slides half a period once more than half\n  // the discs are in line, and back as they let go.\n  const goal = ease((lined / S.D.length - 0.5) / 0.5);\n  S.sh += cl(goal - S.sh, -d / 0.5, d / 0.5);\n}\n\n// A grating of lines x - y = 0 mod P, one LED wide, each LED lit by its\n// distance along x - y from the nearest line, so that a shift by any amount\n// leaves the mean light of the grating the same.\nfunction line(x, y, P, s) {\n  const g = x - y + s, m = ((g % P) + P) % P;\n  return cl(1 - min(m, P - m), 0, 1);\n}\n\n// Is the direction b (radians, y down) in a disc's open mouth?\nfunction inMouth(o, b) {\n  b = ((b % TAU) + TAU) % TAU;\n  const k = floor(b / Q), f = b / Q - k;\n  // Quarter k is open over the middle o of its width.\n  return o[k] > 0 && abs(f - 0.5) \u003c= o[k] / 2;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const o = S.out, P = S.per, sh = round((S.sh * P) / 2), cov = S.cov, lc = S.lc, dc = S.dc;\n  hsv(S.hue + HUE0 + 0.5, 0.45, 0.55, lc);\n  hsv(S.hue + HUE0, 0.75, 1, dc);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, v = line(x, y, P, cov[i] ? sh : 0);\n      o[i * 3] = v * lc[0];\n      o[i * 3 + 1] = v * lc[1];\n      o[i * 3 + 2] = v * lc[2];\n    }\n  const R = (CELL / 2) * (1 - S.gap), R2 = R * R;\n  for (const c of S.D) {\n    const x0 = max(0, floor(c.x - R - 1)), x1 = min(W - 1, floor(c.x + R)), y0 = max(0, floor(c.y - R - 1)), y1 = min(H - 1, floor(c.y + R));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        // 3 x 3 samples: on the disc and outside its mouth is disc colour,\n        // in the mouth the letter's own grating shows through.\n        let body = 0, mouth = 0;\n        for (let sy = 0; sy \u003c 3; sy++)\n          for (let sx = 0; sx \u003c 3; sx++) {\n            const px = x + (sx + 0.5) / 3 - c.x, py = y + (sy + 0.5) / 3 - c.y;\n            if (px * px + py * py > R2) continue;\n            body++;\n            if (inMouth(c.o, atan2(py, px) - c.th)) mouth++;\n          }\n        if (!body) continue;\n        const i = (y * W + x) * 3, g = line(x, y, P, sh), a = body / 9, m = mouth / body;\n        for (let q = 0; q \u003c 3; q++) o[i + q] = a * (m * g * lc[q] + (1 - m) * dc[q]) + (1 - a) * o[i + q];\n      }\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(o[i * 3], 0, 1) * 255), round(cl(o[i * 3 + 1], 0, 1) * 255), round(cl(o[i * 3 + 2], 0, 1) * 255));\n}\n","levy-dust":"// ===== Patternflow pattern =====\n// Title:   Lévy Dust\n// Family:  fractal\n// Idea:    A Lévy flight jumps from landing to landing, each jump in a uniform random direction with a length whose chance of passing l falls as l to the power -alpha, three thousand landings a second that fade over half a minute, and the panel shows the dust they leave three times over, the whole flight in the top third, a window a quarter as wide round a typical landing in the middle third and a quarter as wide again in the bottom third, each window framed in the tier above, so the clusters within clusters and the long empty jumps between them look alike at 1x, 4x and 16x while each long jump flashes as a white streak.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lévy flights and the stable laws (Paul Lévy, 1937); Lévy dust, the landing points of a Rayleigh-Lévy flight, of dimension alpha (Benoit Mandelbrot, 1977; The Fractal Geometry of Nature, 1982); the truncated Lévy flight (Rosario Mantegna and H. Eugene Stanley, 1994); pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tail=-1..1, Cut=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a landing is cyan, blue or violet by when it landed, the hue swinging from cyan to violet and back every 66,000 landings (22 s at Speed 2), and the newest few hundred are near white; the frame in the top tier and the dotted line under it are pale gold, the frame in the middle tier and its line pale green. At 0.5 the dust runs from red through orange and yellow to green inside blue and violet frames.\n// Knob 2: Speed. Landings a second, 1500 times the knob: 3000 at 2, 300 at 0.2, 4500 at 3. A landing dims by a factor e every 30,000 landings after it, 10 s at 2, and goes dark after 105,000, 35 s at 2 and 350 s at 0.2. At every speed the middle tier picks a new window every 3.2 s and the bottom tier every 1.6 s.\n// Knob 3: Tail. Sets alpha = 1.5 - 0.5 x Tail, the exponent of the jump law and the dimension of the dust. At the opening 0 alpha is 1.5: the top tier spans about 75 shortest jumps an LED (38 to 181 over 20 s) and the bottom tier about 4.7, and about 2 jumps a second leave a streak. At 1 alpha is 1 and the long jumps rule: the top tier spans about 360 an LED, the clusters sit far apart and 7 streaks flash a second. At -1 alpha is 2, where the flight falls back towards Brownian motion: the top tier spans 18 an LED, the dust closes into a smudge, and the bottom tier at about 1.1 an LED shows single jumps, where the self-similarity stops.\n// Knob 4: Cut. The longest jump, cut off sharply as in Mantegna and Stanley's truncated flight: 3000 x 60^-Cut shortest jumps, 2350 at the opening 0.06, 390 at 0.5 and 50 at 1. Above the cut the flight adds up like a Brownian walk, so a tier much wider than the cut stops looking like the tiers below it: at 1 the top tier spans about 2,000 (32 an LED) and shows a cloud of small clusters, the middle tier about 500 and the bottom tier 130, near the cut, where the grain of single jumps shows. A new Tail or Cut acts on new landings, so the old dust takes about 35 s to turn over at Speed 2.\n\nconst W = 64, TH = 42, RING = 131072, ZOOM = 4, DWELL = 1.6, LIFE = 30000;\nconst WW = 16, WH = 10.5; // a deeper tier's window in the tier above, in LEDs: 64 / 4 by 42 / 4\nconst TOP = [0, 43, 86]; // tiers on rows 0..41, 43..84, 86..127; dotted lines on 42 and 85\nconst HUES = 32, AGES = 16;\nconst { floor, round, min, max, abs, exp, log, cos, sin, hypot, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const c = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[o] = c[0];\n  out[o + 1] = c[1];\n  out[o + 2] = c[2];\n}\n\nexport function setup(params) {\n  params.s = {\n    px: new Float64Array(RING), py: new Float64Array(RING), n: 0, hx: 0, hy: 0,\n    alpha: 1.5, speed: 2, hue: 0, cut: 3000, acc: 0, t: 0, dt: 0, lutHue: NaN,\n    // view[T] = [cx, cy, world units per LED]; tiers 1 and 2 glide to aim[T].\n    view: [[0, 0, 1], [0, 0, 1], [0, 0, 1]], aim: [[0, 0], [0, 0], [0, 0]], clock: 0,\n    fit: [0, 0, 1], fitTimer: 0, fresh: true, gain: [0, 0, 0],\n    acc4: new Float32Array(W * 128 * 4), lut: new Float32Array(HUES * AGES * 3), streaks: [],\n  };\n  return params.s;\n}\n\n// One landing: a Pareto length, P(L > l) = l^-alpha for 1 \u003c= l, cut off at\n// S.cut and drawn by inverting that law, in a uniform direction. This is\n// Mandelbrot's Rayleigh-Lévy flight, and for alpha below 2 its landings make\n// a dust of dimension alpha. Measured on 40,000 landings at the opening cut,\n// the share of pairs closer than r grows as r^1.22 to r^1.25 at alpha 1.25,\n// r^1.39 to r^1.44 at 1.5 and r^1.55 to r^1.62 at 1.75 for r from 8 to 64:\n// the correlation dimension sits at alpha or a little under it.\nfunction jump(S) {\n  const L = (1 - random() * (1 - S.cut ** -S.alpha)) ** (-1 / S.alpha);\n  const a = random() * 2 * PI;\n  S.hx += L * cos(a);\n  S.hy += L * sin(a);\n  const i = S.n % RING;\n  S.px[i] = S.hx;\n  S.py[i] = S.hy;\n  S.n++;\n  return L;\n}\n\n// A landing's weight by how many landings came after it. It is dropped below\n// 0.03, 105,000 landings on, well inside the ring of 131,072.\nconst weight = (S, age) => exp(-age / LIFE);\n\n// Tier 0 holds the whole dust: centred on the weighted median, and wide\n// enough that 85% of the weight lies inside. Every fourth landing is enough.\nfunction fitTop(S) {\n  const n = min(S.n, RING), xs = [], ys = [], rs = [];\n  let tot = 0;\n  for (let a = 0; a \u003c n; a += 4) {\n    const w = weight(S, a);\n    if (w \u003c 0.03) break;\n    const i = (S.n - 1 - a) % RING;\n    xs.push([S.px[i], w, S.py[i]]);\n    ys.push([S.py[i], w]);\n    tot += w;\n  }\n  const quant = (arr, q) => {\n    arr.sort((p, r) => p[0] - r[0]);\n    let c = 0;\n    for (const e of arr) if ((c += e[1]) >= tot * q) return e[0];\n    return arr[arr.length - 1][0];\n  };\n  const cy = quant(ys, 0.5), cx = quant(xs, 0.5);\n  for (const [x, w, y] of xs) rs.push([max(abs(x - cx) / 31, abs(y - cy) / 20), w]);\n  S.fit = [cx, cy, max(0.05, quant(rs, 0.85) * 1.05)];\n}\n\n// A landing picked at random by weight from those that put a window of a\n// deeper tier wholly inside tier T: a typical point of the dust there, so\n// the window shows what a typical cluster holds rather than the densest.\nfunction pick(S, T) {\n  const v = S.view[T], mx = (W / 2 - WW / 2) * v[2], my = (TH / 2 - WH / 2) * v[2];\n  const n = min(S.n, RING);\n  let tot = 0, got = -1;\n  for (let a = 0; a \u003c n; a++) {\n    const w = weight(S, a);\n    if (w \u003c 0.03) break;\n    const i = (S.n - 1 - a) % RING;\n    if (abs(S.px[i] - v[0]) > mx || abs(S.py[i] - v[1]) > my) continue;\n    tot += w;\n    if (random() * tot \u003c w) got = i;\n  }\n  return got \u003c 0 ? [v[0], v[1]] : [S.px[got], S.py[got]];\n}\n\n// Where a deeper tier's window sits in the tier above, in that tier's LEDs.\nconst inParent = (S, T) => [(S.view[T][0] - S.view[T - 1][0]) / S.view[T - 1][2] + W / 2, (S.view[T][1] - S.view[T - 1][1]) / S.view[T - 1][2] + TH / 2];\n// Whether the window a deeper tier is gliding to has left the window the\n// tier above is gliding to, which tier 0's own drift can do.\nconst outside = (S, T) => {\n  const p = T === 1 ? S.view[0] : S.aim[1], s = S.view[T - 1][2];\n  const x = (S.aim[T][0] - p[0]) / s, y = (S.aim[T][1] - p[1]) / s;\n  return abs(x) > W / 2 - WW / 2 + 1.5 || abs(y) > TH / 2 - WH / 2 + 1.5;\n};\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.dt = d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.alpha = 1.5 - 0.5 * cl(k[2], -1, 1);\n  S.cut = 3000 * 60 ** -cl(k[3], 0, 1);\n  S.t += d;\n  // The first frame opens on a dust already 3.5 lifetimes deep.\n  if (S.n === 0) {\n    for (let i = 0; i \u003c min(RING - 1, 3.5 * LIFE); i++) jump(S);\n    fitTop(S);\n    S.view[0] = S.fit.slice();\n  }\n  S.acc += d * 1500 * S.speed;\n  while (S.acc >= 1) {\n    S.acc--;\n    const x0 = S.hx, y0 = S.hy, L = jump(S);\n    if (L > 1.5 * S.view[0][2]) S.streaks.push([x0, y0, S.hx, S.hy, S.t]);\n  }\n  while (S.streaks.length && (S.streaks.length > 32 || S.t - S.streaks[0][4] > 0.6)) S.streaks.shift();\n  // The flight never ends, so now and then everything shifts back near 0.\n  if (abs(S.hx) + abs(S.hy) > 1e9) {\n    const ox = S.hx, oy = S.hy;\n    for (let i = 0; i \u003c RING; i++) (S.px[i] -= ox), (S.py[i] -= oy);\n    for (const v of S.view) (v[0] -= ox), (v[1] -= oy);\n    for (const a of S.aim) (a[0] -= ox), (a[1] -= oy);\n    for (const s of S.streaks) (s[0] -= ox), (s[1] -= oy), (s[2] -= ox), (s[3] -= oy);\n    S.fit[0] -= ox;\n    S.fit[1] -= oy;\n    S.hx = S.hy = 0;\n  }\n  S.fitTimer -= d;\n  if (S.fitTimer \u003c= 0) (S.fitTimer = 0.25), fitTop(S);\n  const v0 = S.view[0];\n  if (S.fresh) (v0[0] = S.fit[0]), (v0[1] = S.fit[1]), (v0[2] = S.fit[2]);\n  else {\n    const a = 1 - exp(-d / 0.7), b = 1 - exp(-d / 1.2);\n    v0[0] += (S.fit[0] - v0[0]) * a;\n    v0[1] += (S.fit[1] - v0[1]) * a;\n    v0[2] = exp(log(v0[2]) + (log(S.fit[2]) - log(v0[2])) * b);\n  }\n  // Tier 1 picks a new window every 2 x DWELL seconds and tier 2 picks one\n  // inside it at once; halfway between, tier 2 alone picks again. Either\n  // picks at once when tier 0's drift has pushed its window out.\n  S.clock += d;\n  const both = S.fresh || S.clock >= 2 * DWELL || outside(S, 1);\n  const deep = both || (S.clock >= DWELL && S.clock - d \u003c DWELL) || outside(S, 2);\n  if (both) {\n    S.clock = 0;\n    S.aim[1] = pick(S, 0);\n  }\n  if (deep) {\n    // Picked inside the window tier 1 is gliding to.\n    const v1 = S.view[1], keep = [v1[0], v1[1], v1[2]];\n    v1[0] = S.aim[1][0];\n    v1[1] = S.aim[1][1];\n    v1[2] = v0[2] / ZOOM;\n    S.aim[2] = pick(S, 1);\n    if (!S.fresh) (v1[0] = keep[0]), (v1[1] = keep[1]), (v1[2] = keep[2]);\n  }\n  const g = S.fresh ? 1 : 1 - exp(-d / 0.25);\n  for (let T = 1; T \u003c 3; T++) {\n    const v = S.view[T], a = S.aim[T];\n    v[0] += (a[0] - v[0]) * g;\n    v[1] += (a[1] - v[1]) * g;\n    v[2] = S.view[T - 1][2] / ZOOM;\n  }\n  S.fresh = false;\n}\n\n// Every landing still lit, added into each tier it falls in: colour times\n// weight in the first three slots of an LED, weight in the fourth.\nfunction bin(S, A) {\n  const lut = S.lut;\n  A.fill(0);\n  const n = min(S.n, RING), P = 2.2 * LIFE;\n  for (let a = 0; a \u003c n; a++) {\n    const w = weight(S, a);\n    if (w \u003c 0.03) break;\n    const nb = S.n - 1 - a, i = nb % RING;\n    const hq = floor((0.5 - 0.5 * cos((2 * PI * nb) / P)) * (HUES - 1) + 0.5);\n    const q = (hq * AGES + min(AGES - 1, floor(Math.sqrt(a / (4 * LIFE)) * AGES))) * 3;\n    for (let T = 0; T \u003c 3; T++) {\n      const v = S.view[T];\n      const x = floor((S.px[i] - v[0]) / v[2] + W / 2), y = floor((S.py[i] - v[1]) / v[2] + TH / 2);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= TH) continue;\n      const o = ((TOP[T] + y) * W + x) * 4;\n      A[o] += lut[q] * w;\n      A[o + 1] += lut[q + 1] * w;\n      A[o + 2] += lut[q + 2] * w;\n      A[o + 3] += w;\n    }\n  }\n}\n\nfunction line(A, T, x0, y0, x1, y1, f) {\n  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n  for (let i = 0; i \u003c= n; i++) {\n    const x = round(x0 + ((x1 - x0) * i) / n), y = round(y0 + ((y1 - y0) * i) / n);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= TH) continue;\n    const o = ((TOP[T] + y) * W + x) * 4;\n    A[o] += f;\n    A[o + 1] += f;\n    A[o + 2] += f;\n    A[o + 3] += f;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const A = S.acc4;\n  if (S.lutHue !== S.hue) {\n    // A landing's hue follows when it landed, swinging 0.3 round the wheel\n    // and back, cyan through blue to violet at Hue 0; fresh landings are\n    // whitened.\n    for (let h = 0; h \u003c HUES; h++)\n      for (let a = 0; a \u003c AGES; a++) {\n        const fresh = 1 - a / (AGES - 1);\n        hsv(S.hue + 0.5 + (0.3 * h) / (HUES - 1), 0.8 - 0.6 * fresh ** 8, 1, S.lut, (h * AGES + a) * 3);\n      }\n    S.lutHue = S.hue;\n  }\n  bin(S, A);\n  // A long jump leaves a white streak for 0.6 s.\n  for (const [x0, y0, x1, y1, t] of S.streaks) {\n    const f = 0.6 * (1 - (S.t - t) / 0.6);\n    if (f \u003c= 0) continue;\n    for (let T = 0; T \u003c 3; T++) {\n      const v = S.view[T];\n      if (hypot(x1 - x0, y1 - y0) / v[2] \u003c 6) continue;\n      line(A, T, (x0 - v[0]) / v[2] + W / 2, (y0 - v[1]) / v[2] + TH / 2, (x1 - v[0]) / v[2] + W / 2, (y1 - v[1]) / v[2] + TH / 2, f);\n    }\n  }\n  // Each tier's gain follows the mean weight of its lit LEDs, so an LED of\n  // average weight shows at 70% in every tier: a window a quarter as wide\n  // holds about 4^-alpha of the weight, 1/8 at alpha 1.5.\n  for (let T = 0; T \u003c 3; T++) {\n    let sum = 0, cnt = 0;\n    for (let p = TOP[T] * W; p \u003c (TOP[T] + TH) * W; p++) if (A[p * 4 + 3] > 0) (sum += A[p * 4 + 3]), cnt++;\n    const g = 1.2 / max(0.05, sum / max(1, cnt));\n    S.gain[T] = S.gain[T] > 0 ? exp(log(S.gain[T]) + (log(g) - log(S.gain[T])) * (1 - exp(-S.dt / 0.4))) : g;\n  }\n  for (let T = 0; T \u003c 3; T++)\n    for (let y = 0; y \u003c TH; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const o = ((TOP[T] + y) * W + x) * 4, wt = A[o + 3];\n        if (wt \u003c= 0) {\n          display.setPixel(x, TOP[T] + y, 0, 0, 0);\n          continue;\n        }\n        const f = (255 * (1 - exp(-S.gain[T] * wt))) / wt;\n        display.setPixel(x, TOP[T] + y, A[o] * f, A[o + 1] * f, A[o + 2] * f);\n      }\n  // The newest landing, white, in every tier it falls in.\n  for (let T = 0; T \u003c 3; T++) {\n    const v = S.view[T], x = floor((S.hx - v[0]) / v[2] + W / 2), y = floor((S.hy - v[1]) / v[2] + TH / 2);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c TH) display.setPixel(x, TOP[T] + y, 255, 255, 255);\n  }\n  // The frames: in tier 0 where tier 1 looks, in tier 1 where tier 2 looks,\n  // each in the colour of the dotted line above the tier it shows.\n  const fc = [[], []];\n  hsv(S.hue + 0.13, 0.55, 0.85, fc[0], 0);\n  hsv(S.hue + 0.33, 0.55, 0.85, fc[1], 0);\n  for (let T = 0; T \u003c 2; T++) {\n    const col = fc[T], [ux, uy] = inParent(S, T + 1);\n    const x0 = round(ux - WW / 2) - 1, x1 = round(ux + WW / 2), y0 = round(uy - WH / 2) - 1, y1 = round(uy + WH / 2);\n    const put = (x, y) => {\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c TH) display.setPixel(x, TOP[T] + y, col[0] * 255, col[1] * 255, col[2] * 255);\n    };\n    for (let x = x0; x \u003c= x1; x++) put(x, y0), put(x, y1);\n    for (let y = y0 + 1; y \u003c y1; y++) put(x0, y), put(x1, y);\n    for (let x = 0; x \u003c W; x++) {\n      const on = (x & 1) === 0;\n      display.setPixel(x, TOP[T + 1] - 1, on ? col[0] * 150 : 0, on ? col[1] * 150 : 0, on ? col[2] * 150 : 0);\n    }\n  }\n}\n","order-k-voronoi":"// ===== Patternflow pattern =====\n// Title:   Order-k Voronoi\n// Family:  cells\n// Idea:    Ten sites drift slowly and every LED takes the colour of the set of its k nearest sites, the mean of their hues, so the panel splits into the regions of the order-k Voronoi diagram with pale lines where the k-th and the (k+1)-th nearest swap, neighbouring regions sharing all but one site and shading into each other, from the ordinary Voronoi diagram at k = 1 to the farthest-point diagram at k = n - 1, whose few unbounded regions meet in a tree that the centre of the smallest circle round the sites lies on, while a bar chart along the bottom counts the regions of every order in the whole plane and on the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: higher-order Voronoi diagrams and the farthest-point diagram (Michael Shamos and Dan Hoey, 1975); the count of their regions (D. T. Lee, 1982); 3 x 5 figures drawn for this pattern; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Order=1..17, Sites=10..18, Drift=0..1\n//\n// Knob 1: Hue. Turns the site colours round the wheel together: n hues evenly spaced from Hue + 0.05, so at 0 the ten sites are red-orange, gold, chartreuse, green, sea green, sky blue, blue, violet, magenta and rose at full brightness. A region's colour is the mean of its sites' hues at 30 to 75% saturation, paler where its sites pull in opposite directions; at k = 1 each region is its site's own colour.\n// Knob 2: Order. k, the size of the nearest set, held at n - 1 above it. At 1 the ordinary Voronoi diagram, ten regions. At the opening 2 a region is a pair of sites whose cells touch, 3n - 3 - h of them: 21 to 23 over a minute for the opening ten sites as their hull has 6 to 4 corners. At 4 there are 26 to 34, the tallest bar nine tenths of the time (3 has it the rest), and since each site lies in just one region at least 16 of them hold no site at all. At n - 1, 9 at the opening, the farthest-point diagram: one unbounded region for each corner of the hull, 4 to 6 as the sites drift, meeting in a tree; the smallest circle round all the sites is dotted white and its centre, which lies on the tree, is a white star.\n// Knob 3: Sites. n, 10 to 18; each whole step adds a site on its own path. At the first moment the chart's bars, orders 1 to n - 1, read 10 21 28 31 27 24 16 11 6 with 10 sites, of which the panel holds 10 19 23 25 22 14 9 5 3, and 18 44 63 79 89 96 95 95 88 75 64 56 43 34 24 16 7 with 18, of which it holds 18 38 49 57 61 67 67 61 55 46 37 26 22 18 16 11 5. The tallest bar is seven LEDs high.\n// Knob 4: Drift. How fast the sites run their Lissajous paths: 0.56 LEDs a second on average at 0, 0.68 at the opening 0.06 and 2.6 at 1. The counts in the chart step by one or two as regions are born and die, and the white bar moves with the order.\n\nconst W = 64, H = 128, NMAX = 18, STRIP = 114; // the chart takes rows 114..127\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, hypot, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (e0, e1, x) => {\n  const t = cl((x - e0) / (e1 - e0), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// 3 x 5 figures, drawn for this pattern, rows from the top.\nconst FIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001010010010\", \"111101111101111\", \"111101111001111\"];\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nexport function setup(params) {\n  // Each site runs a slow Lissajous path that keeps it 3 LEDs inside the\n  // panel and clear of the chart. The first ten centres take one band each\n  // of the height, shuffled, so the opening ten spread down the panel.\n  const band = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n  for (let i = 9; i > 0; i--) {\n    const j = floor(random() * (i + 1));\n    [band[i], band[j]] = [band[j], band[i]];\n  }\n  const path = [];\n  for (let i = 0; i \u003c NMAX; i++) {\n    const ax = 4 + random() * 9, ay = 4 + random() * 8, room = STRIP - 6 - 2 * ay;\n    path.push({\n      cx: 3 + ax + random() * (58 - 2 * ax), cy: 3 + ay + room * (i \u003c 10 ? (band[i] + random()) / 10 : random()), ax, ay,\n      wx: 0.06 + random() * 0.08, wy: 0.05 + random() * 0.07, px: random() * 2 * PI, py: random() * 2 * PI,\n    });\n  }\n  params.s = {\n    path, t: 0, n: 10, k: 2, hue: 0, sx: new Float64Array(NMAX), sy: new Float64Array(NMAX),\n    plane: new Int32Array(NMAX), panel: new Int32Array(NMAX),\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 10, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.n = cl(round(kv[2]), 3, NMAX);\n  S.k = cl(round(kv[1]), 1, S.n - 1);\n  S.t += d * (0.8 + 3 * cl(kv[3], 0, 1));\n  for (let i = 0; i \u003c NMAX; i++) {\n    const p = S.path[i];\n    S.sx[i] = p.cx + p.ax * sin(p.wx * S.t + p.px);\n    S.sy[i] = p.cy + p.ay * sin(p.wy * S.t + p.py);\n  }\n}\n\n// The number of i-sets for every i: sets of i sites that a line cuts off\n// from the rest, which are the unbounded regions of the order-i diagram.\n// Sweeping a direction u round the circle, the i sites furthest along u\n// change only when u is square to a line through two sites.\nfunction isets(S, e) {\n  const n = S.n, ang = [];\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) if (i !== j) ang.push((atan2(S.sy[j] - S.sy[i], S.sx[j] - S.sx[i]) + 2.5 * PI) % (2 * PI));\n  ang.sort((a, b) => a - b);\n  const seen = [];\n  for (let i = 0; i \u003c n; i++) seen.push(new Set());\n  const ord = [];\n  for (let s = 0; s \u003c ang.length; s++) {\n    const a = (ang[s] + (s + 1 \u003c ang.length ? ang[s + 1] : ang[0] + 2 * PI)) / 2, ux = cos(a), uy = sin(a);\n    ord.length = 0;\n    for (let i = 0; i \u003c n; i++) ord.push(i);\n    ord.sort((p, q) => S.sx[q] * ux + S.sy[q] * uy - (S.sx[p] * ux + S.sy[p] * uy));\n    let m = 0;\n    for (let i = 1; i \u003c n; i++) seen[i].add((m |= 1 \u003c\u003c ord[i - 1]));\n  }\n  for (let i = 1; i \u003c n; i++) e[i] = seen[i].size;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { n, k, sx, sy } = S;\n  // The regions of the order-j diagram in the whole plane, for every j:\n  // 2jn - j^2 - n + 1 less the i-sets for every i below j (D. T. Lee, 1982).\n  // Against a brute-force count, the distinct j-nearest sets round every\n  // crossing of two bisectors, it agreed for 319 random sets of 5 to 14\n  // sites and for 60 moments of this drift at 10, 14 and 18 sites; the one\n  // random set it missed had three sites on a line. Points in convex\n  // position give j(n - j) + 1, and j = 2 gives 3n - 3 - h for h corners\n  // of the hull, the number of Delaunay edges: an order-2 region is a pair\n  // of sites whose Voronoi cells touch.\n  const e = new Int32Array(NMAX);\n  isets(S, e);\n  let sum = 0;\n  for (let j = 1; j \u003c n; j++) {\n    S.plane[j] = 2 * j * n - j * j - n + 1 - sum;\n    sum += e[j];\n  }\n  // Site colours: n hues evenly round the wheel, so their unit vectors sum\n  // to nothing. A region takes the direction of the sum over its k sites,\n  // so two regions that share k - 1 sites differ by one vector in k, and in\n  // the farthest-point diagram the region that leaves out site p takes the\n  // hue opposite p's. Saturation follows the length of the sum against\n  // sqrt(k (n - k) / (n - 1)), its root mean square over random k-sets.\n  const hx = [], hy = [];\n  for (let i = 0; i \u003c n; i++) (hx[i] = cos(2 * PI * (i / n + S.hue + 0.05))), (hy[i] = sin(2 * PI * (i / n + S.hue + 0.05)));\n  const ref = sqrt((k * (n - k)) / (n - 1));\n  const cache = new Map();\n  const colour = (m) => {\n    let c = cache.get(m);\n    if (c) return c;\n    let x = 0, y = 0;\n    for (let i = 0; i \u003c n; i++) if (m & (1 \u003c\u003c i)) (x += hx[i]), (y += hy[i]);\n    const z = hypot(x, y) / ref;\n    c = hsv(atan2(y, x) / (2 * PI), 0.3 + 0.45 * smooth(0, 1.4, z), 1);\n    cache.set(m, c);\n    return c;\n  };\n  const d2 = new Float64Array(NMAX), id = new Int32Array(NMAX);\n  // Every prefix of the sorted list is the region of one order, so one pass\n  // counts the regions with an LED centre on the panel for every order.\n  const sets = [];\n  for (let j = 0; j \u003c n; j++) sets.push(new Set());\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      // All n distances, sorted by insertion: n is at most 18.\n      for (let i = 0; i \u003c n; i++) {\n        const v = (x + 0.5 - sx[i]) ** 2 + (y + 0.5 - sy[i]) ** 2;\n        let j = i;\n        while (j > 0 && d2[j - 1] > v) (d2[j] = d2[j - 1]), (id[j] = id[j - 1]), j--;\n        d2[j] = v;\n        id[j] = i;\n      }\n      let m = 0;\n      for (let j = 0; j \u003c k; j++) m |= 1 \u003c\u003c id[j];\n      let q = 0;\n      for (let j = 1; j \u003c n; j++) sets[j].add((q |= 1 \u003c\u003c id[j - 1]));\n      // The region ends where the k-th and the (k+1)-th nearest swap: the\n      // distance to the bisector of those two sites.\n      const a = id[k - 1], b = id[k];\n      const edge = (d2[k] - d2[k - 1]) / (2 * hypot(sx[a] - sx[b], sy[a] - sy[b]));\n      const c = colour(m);\n      const v = 0.76 + 0.24 * smooth(0, 7, edge), line = 1 - smooth(0.3, 1.1, edge);\n      let r = c[0] * v, g = c[1] * v, bl = c[2] * v;\n      r += (0.95 - r) * line;\n      g += (0.95 - g) * line;\n      bl += (0.95 - bl) * line;\n      // Under the chart the diagram goes on at a twelfth.\n      const f = y \u003c STRIP ? 255 : 21;\n      display.setPixel(x, y, r * f, g * f, bl * f);\n    }\n  for (let j = 1; j \u003c n; j++) S.panel[j] = sets[j].size;\n  // The farthest-point diagram: the smallest circle round all the sites,\n  // dotted, and its centre, which lies on the tree.\n  if (k === n - 1) {\n    const [cx, cy, R] = enclosing(S);\n    const steps = round(2 * PI * R);\n    for (let i = 0; i \u003c steps; i += 2) {\n      const x = round(cx + R * cos((2 * PI * i) / steps) - 0.5), y = round(cy + R * sin((2 * PI * i) / steps) - 0.5);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c STRIP) display.setPixel(x, y, 235, 235, 235);\n    }\n    const x = round(cx - 0.5), y = round(cy - 0.5);\n    for (let dy = -2; dy \u003c= 2; dy++)\n      for (let dx = -2; dx \u003c= 2; dx++) {\n        const r = max(abs(dx), abs(dy));\n        if (r === 1 || x + dx \u003c 0 || x + dx >= W || y + dy \u003c 0 || y + dy >= STRIP) continue;\n        if (r === 0) display.setPixel(x, y, 255, 255, 255);\n        else if (dx === 0 || dy === 0 || abs(dx) === abs(dy)) display.setPixel(x + dx, y + dy, 255, 255, 255);\n      }\n  }\n  // The sites, white with a dark rim.\n  for (let i = 0; i \u003c n; i++) {\n    const x = floor(sx[i]), y = floor(sy[i]);\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) display.setPixel(x + dx, y + dy, 20, 20, 30);\n    display.setPixel(x, y, 255, 255, 255);\n  }\n  // The chart: one bar for each order 1 to n - 1, as tall as its count of\n  // regions in the whole plane, the part that has an LED on the panel\n  // brighter, the bar of this order white with its count above it.\n  let fmax = 1;\n  for (let j = 1; j \u003c n; j++) fmax = max(fmax, S.plane[j]);\n  const bw = floor(60 / (n - 1)), x0 = floor((W - bw * (n - 1)) / 2);\n  for (let j = 1; j \u003c n; j++) {\n    const hp = max(1, round((7 * S.plane[j]) / fmax)), hv = min(hp, round((7 * S.panel[j]) / fmax)), on = j === k;\n    for (let r = 0; r \u003c hp; r++)\n      for (let c = 0; c \u003c bw - 1; c++) {\n        const lit = r \u003c hv;\n        const col = on ? (lit ? [255, 255, 255] : [120, 120, 130]) : lit ? [110, 125, 150] : [45, 50, 64];\n        display.setPixel(x0 + (j - 1) * bw + c, 127 - r, col[0], col[1], col[2]);\n      }\n  }\n  const txt = String(S.plane[k]), tw = txt.length * 4 - 1;\n  const tx = cl(round(x0 + (k - 1) * bw + (bw - 1) / 2 - tw / 2), 1, W - 1 - tw);\n  for (let c = 0; c \u003c txt.length; c++) {\n    const f = FIG[txt.charCodeAt(c) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (f[r * 3 + q] === \"1\") display.setPixel(tx + c * 4 + q, 115 + r, 255, 255, 255);\n  }\n}\n\n// The smallest circle holding every site: it passes through two sites on a\n// diameter or through three, so try every pair and triple. 18 sites make\n// 816 triples.\nfunction enclosing(S) {\n  const { n, sx, sy } = S;\n  let best = [0, 0, 1e9];\n  const holds = (cx, cy, r) => {\n    for (let i = 0; i \u003c n; i++) if ((sx[i] - cx) ** 2 + (sy[i] - cy) ** 2 > r * r + 1e-6) return false;\n    return true;\n  };\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      const cx = (sx[i] + sx[j]) / 2, cy = (sy[i] + sy[j]) / 2, r = hypot(sx[i] - sx[j], sy[i] - sy[j]) / 2;\n      if (r \u003c best[2] && holds(cx, cy, r)) best = [cx, cy, r];\n      for (let l = j + 1; l \u003c n; l++) {\n        const ax = sx[j] - sx[i], ay = sy[j] - sy[i], bx = sx[l] - sx[i], by = sy[l] - sy[i], dd = 2 * (ax * by - ay * bx);\n        if (abs(dd) \u003c 1e-9) continue;\n        const ux = (by * (ax * ax + ay * ay) - ay * (bx * bx + by * by)) / dd, uy = (ax * (bx * bx + by * by) - bx * (ax * ax + ay * ay)) / dd;\n        const R = hypot(ux, uy);\n        if (R \u003c best[2] && holds(sx[i] + ux, sy[i] + uy, R)) best = [sx[i] + ux, sy[i] + uy, R];\n      }\n    }\n  return best;\n}\n","string-art":"// ===== Patternflow pattern =====\n// Title:   String Art\n// Family:  type\n// Idea:    One thread is strung from pin to pin round the edge of the panel, each next pin picked greedily as the one whose straight chord best fills what the glyph still lacks and least lights what lies outside it, so a bold A, the Hangul syllable 실 (thread), a K and an ampersand come up one after another out of about four hundred lines of light on black, each strung in 12 s, held, faded and strung again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: computational string art, one continuous thread whose next pin is the greedy choice of the chord that most lowers the error against the picture (Petros Vrellis, A New Way to Knit, 2016); antialiased lines (Xiaolin Wu, 1991); the frame a superellipse (Gabriel Lamé, 1818); glyphs drawn here, the 실 included, pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spacing=2..8, Round=0..1\n//\n// Knob 1: Hue. Turns the thread colour round the wheel. At 0 the A is strung in cyan and its last threads have turned 0.14 of the wheel toward blue; each glyph after it starts 0.13 further round, so at 0 the 실 runs blue to violet, the K violet to pink and the ampersand pink to coral.\n// Knob 2: Speed. At 2 a glyph is strung in 12.3 s, slowly at first and last and about 54 threads a second in the middle, holds 3 s and fades in 1.2 s, 16.5 s a glyph. At 0.2 it is ten times slower and each thread can be seen running from its pin to the next.\n// Knob 3: Spacing. LEDs of frame between neighbouring pins, 2 to 8 in whole steps: 187 pins at 2, 94 at 4, 47 at 8. A glyph takes 2.25 threads a pin, 421 at 2 and 106 at 8, and fewer pins mean heavier threads, each twice as bright at 8 as at 2, so the A turns from a dense weave into a coarse lattice of separate lines.\n// Knob 4: Round. The shape of the frame the pins stand on, the superellipse |x/a|^n + |y/b|^n = 1 through the edges of the panel with n = 2 + 40 (1 - Round)^3: at 0.06 n is 35, a rectangle with its corners rounded by about an LED; at 0.5 n is 7; at 1 it is the ellipse inside the panel, Vrellis's round loom stretched to 64 by 128, 153 pins and the corners left dark. Turning Spacing or Round strings the glyph again from its first thread.\n// Buttons: K1 tap fades the glyph and starts the next.\n\n// The greedy step. Each LED has a target, 3.5 units of thread light times\n// how much of it the glyph covers, and the light the threads have left so\n// far. Adding a thread of light a along a chord changes the squared error by\n// a w (2 r - a w) at each LED it crosses with weight w, r the shortfall\n// there. Outside the glyph the target is 0, so a thread there only adds\n// error, counted 0.6 times. The chord from the current pin with the largest\n// gain per LED of length wins; a chord is used once. The target is set\n// above what 421 threads can give, so the glyph keeps drawing threads to\n// itself to the end instead of filling up and spilling. What shows is\n// (1 - exp(-light))^1.3 per colour channel, so one stray thread stays dim\n// and fifteen crossing on a stroke come near full brightness.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5, AX = 31.5, BY = 63.5;\nconst { floor, round, max, abs, sqrt, exp, pow, cos, sin, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Threads per pin; light a thread leaves per LED step with 188 pins; the\n// light the glyph asks for; the weight of light outside it; the display curve.\nconst PER_PIN = 2.25, ALPHA = 0.2, PIN0 = 188, TGT = 3.5, LAM = 0.6, GAM = 1.3;\n// Seconds at Speed 2: the first thread running out from its pin, the whole\n// build, the hold, the fade. HUE0 is the A's hue at Hue 0, cyan.\nconst T0 = 0.6, TB = 12.3, HOLD = 3, CUT = 1.2, HUE0 = 0.52;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Glyph primitives: [\"p\", x, y, x, y, ...] a filled polygon, [\"s\", x0, y0,\n// x1, y1, r] a stroke with round ends, [\"a\", cx, cy, R, r, from, to] an arc\n// of a ring, angles in degrees with y down (90 is the bottom).\nconst GLYPHS = [\n  // A\n  [\n    [\"p\", 25, 6, 39, 6, 18, 122, 4, 122],\n    [\"p\", 25, 6, 39, 6, 60, 122, 46, 122],\n    [\"p\", 12, 80, 52, 80, 52, 92, 12, 92],\n  ],\n  // 실\n  [\n    [\"s\", 24, 9, 6, 58, 6],\n    [\"s\", 18, 27, 40, 58, 6],\n    [\"p\", 46, 5, 58, 5, 58, 66, 46, 66],\n    [\"p\", 6, 72, 58, 72, 58, 81, 6, 81],\n    [\"p\", 48, 72, 58, 72, 58, 101, 48, 101],\n    [\"p\", 6, 92, 58, 92, 58, 101, 6, 101],\n    [\"p\", 6, 92, 16, 92, 16, 122, 6, 122],\n    [\"p\", 6, 113, 59, 113, 59, 122, 6, 122],\n  ],\n  // K\n  [\n    [\"p\", 5, 6, 19, 6, 19, 122, 5, 122],\n    [\"p\", 15, 62, 44, 6, 60, 6, 15, 90],\n    [\"p\", 27, 62, 37, 50, 61, 122, 45, 122],\n  ],\n  // &\n  [\n    [\"a\", 30, 25, 13, 5.5, 0, 360],\n    [\"s\", 21, 35, 59, 121, 6],\n    [\"s\", 39, 35, 9.5, 87, 5.5],\n    [\"a\", 28, 94, 20, 6, -30, 200],\n    [\"s\", 45.3, 84, 57, 68, 5.5],\n  ],\n];\n\nfunction inPoly(pr, x, y) {\n  let c = false;\n  for (let i = 1, j = pr.length - 2; i \u003c pr.length; j = i, i += 2) {\n    const xi = pr[i], yi = pr[i + 1], xj = pr[j], yj = pr[j + 1];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) c = !c;\n  }\n  return c;\n}\nfunction inside(g, x, y) {\n  for (const pr of g) {\n    if (pr[0] === \"p\" && inPoly(pr, x, y)) return true;\n    if (pr[0] === \"s\") {\n      const [, x0, y0, x1, y1, r] = pr, dx = x1 - x0, dy = y1 - y0;\n      const t = cl(((x - x0) * dx + (y - y0) * dy) / (dx * dx + dy * dy), 0, 1);\n      if ((x - x0 - t * dx) ** 2 + (y - y0 - t * dy) ** 2 \u003c r * r) return true;\n    }\n    if (pr[0] === \"a\") {\n      const [, cx, cy, R, r, a0, a1] = pr, d = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      if (abs(d - R) \u003c r) {\n        let a = (atan2(y - cy, x - cx) * 180) / PI;\n        while (a \u003c a0) a += 360;\n        if (a \u003c= a1) return true;\n      }\n    }\n  }\n  return false;\n}\n// Coverage of each LED by the glyph, 4 x 4 samples.\nfunction mask(g) {\n  const m = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let c = 0;\n      for (let j = 0; j \u003c 4; j++) for (let i = 0; i \u003c 4; i++) if (inside(g, x + (i + 0.5) / 4, y + (j + 0.5) / 4)) c++;\n      m[y * W + x] = c / 16;\n    }\n  return m;\n}\n\n// The frame is the superellipse |x/a|^n + |y/b|^n = 1 through the panel's\n// edges. norm() is its left side to the power 1/n, 1 on the frame.\nfunction norm(u, v, n) {\n  u = abs(u);\n  v = abs(v);\n  const m = max(u, v);\n  return m > 0 ? m * pow(pow(u / m, n) + pow(v / m, n), 1 / n) : 0;\n}\n// Pins every `sp` LEDs of arc round the frame, on LED centres.\nfunction pins(sp, n) {\n  const M = 1440, xs = [], ys = [], arc = [0];\n  for (let k = 0; k \u003c= M; k++) {\n    const f = (2 * PI * k) / M, c = cos(f), s = sin(f), r = 1 / norm(c / AX, s / BY, n);\n    xs.push(CX + r * c);\n    ys.push(CY + r * s);\n    if (k) arc.push(arc[k - 1] + sqrt((xs[k] - xs[k - 1]) ** 2 + (ys[k] - ys[k - 1]) ** 2));\n  }\n  const P = [];\n  for (let s = sp / 2, k = 0; s \u003c arc[M]; s += sp) {\n    while (arc[k + 1] \u003c s) k++;\n    const u = (s - arc[k]) / (arc[k + 1] - arc[k] || 1);\n    const x = cl(round(xs[k] + u * (xs[k + 1] - xs[k])), 0, W - 1), y = cl(round(ys[k] + u * (ys[k + 1] - ys[k])), 0, H - 1);\n    const q = P[P.length - 1];\n    if (!q || q.x !== x || q.y !== y) P.push({ x, y });\n  }\n  if (P.length > 1 && P[0].x === P[P.length - 1].x && P[0].y === P[P.length - 1].y) P.pop();\n  return P;\n}\n\n// Walk a chord LED by LED along its long axis, splitting each step between\n// the two LEDs either side of it (Xiaolin Wu, 1991). u is how much of the\n// chord, from a.\nfunction walk(a, b, u, fn) {\n  const dx = b.x - a.x, dy = b.y - a.y, n = max(abs(dx), abs(dy)), m = floor(n * u);\n  const sx = dx \u003c 0 ? -1 : 1, sy = dy \u003c 0 ? -1 : 1;\n  if (abs(dx) >= abs(dy))\n    for (let k = 0; k \u003c= m; k++) {\n      const x = a.x + sx * k, y = a.y + (dy * k) / n, yi = floor(y), f = y - yi;\n      fn(x + yi * W, 1 - f);\n      if (f > 1e-6 && yi + 1 \u003c H) fn(x + (yi + 1) * W, f);\n    }\n  else\n    for (let k = 0; k \u003c= m; k++) {\n      const y = a.y + sy * k, x = a.x + (dx * k) / n, xi = floor(x), f = x - xi;\n      fn(xi + y * W, 1 - f);\n      if (f > 1e-6 && xi + 1 \u003c W) fn(xi + 1 + y * W, f);\n    }\n}\n\nfunction newGlyph(S, gi) {\n  S.gi = ((gi % GLYPHS.length) + GLYPHS.length) % GLYPHS.length;\n  S.mask = mask(GLYPHS[S.gi]);\n  S.P = pins(S.sp, S.n);\n  // Fewer pins, fewer and heavier threads.\n  S.nt = round(PER_PIN * S.P.length);\n  S.al = ALPHA * sqrt(PIN0 / S.P.length);\n  S.acc.fill(0);\n  S.rgb.fill(0);\n  Object.assign(S, { laid: 0, used: new Set(), t: 0, phase: 0, fade: 1, at: 0, u: 0 });\n  // The thread is tied on at the pin nearest the bottom left corner.\n  let best = 1e9;\n  S.P.forEach((p, i) => {\n    const d = (p.x - 8) ** 2 + (p.y - H) ** 2;\n    if (d \u003c best) (best = d), (S.at = i);\n  });\n  S.next = choose(S);\n}\n\n// The greedy step: from the pin the thread is on, the chord whose light most\n// lowers the squared error against the glyph, per LED of its length. Light\n// outside the glyph counts LAM times. A chord whose middle lies within 2.5\n// LEDs of the frame would only hug the frame, and none is used twice.\nfunction choose(S) {\n  const P = S.P, a = P[S.at], acc = S.acc, m = S.mask, al = S.al;\n  let best = -1e18, bi = -1;\n  for (let j = 0; j \u003c P.length; j++) {\n    const b = P[j], key = S.at \u003c j ? S.at * 4096 + j : j * 4096 + S.at;\n    if (j === S.at || S.used.has(key)) continue;\n    const mx = (a.x + b.x) / 2 - CX, my = (a.y + b.y) / 2 - CY;\n    if ((1 - norm(mx / AX, my / BY, S.n)) * AX \u003c 2.5) continue;\n    let sc = 0;\n    walk(a, b, 1, (i, w) => {\n      const c = m[i], r = TGT * c - acc[i];\n      sc += (c + LAM * (1 - c)) * w * (2 * r - al * w);\n    });\n    sc /= sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);\n    if (sc > best) (best = sc), (bi = j);\n  }\n  return bi;\n}\n\n// Thread k's colour: the glyph's hue, turning 0.14 round the wheel from the\n// first thread to the last.\nconst tint = (S, k, o) => hsv(S.hue + HUE0 + S.gi * 0.13 + (0.14 * k) / S.nt, 0.6, 1, o);\n\nfunction lay(S) {\n  const a = S.P[S.at], b = S.P[S.next], col = S.tc;\n  tint(S, S.laid, col);\n  walk(a, b, 1, (i, w) => {\n    const l = S.al * w, k = i * 3;\n    S.acc[i] += l;\n    S.rgb[k] += l * col[0];\n    S.rgb[k + 1] += l * col[1];\n    S.rgb[k + 2] += l * col[2];\n  });\n  S.used.add(S.at \u003c S.next ? S.at * 4096 + S.next : S.next * 4096 + S.at);\n  S.at = S.next;\n  S.laid++;\n  S.next = choose(S);\n}\n\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst tone = (a) => pow(1 - exp(-a), GAM);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, sp: 2, n: 40, rk: 0, started: false, btn: false, gi: 0,\n    acc: new Float32Array(N), rgb: new Float32Array(N * 3), part: new Float32Array(N), tc: [1, 1, 1], pc: [1, 1, 1],\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const sp = round(cl(k[2] == null ? 2 : k[2], 2, 8)), rk = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started || sp !== S.sp || abs(rk - S.rk) > 0.02) {\n    S.sp = sp;\n    S.rk = rk;\n    S.n = 2 + 40 * (1 - rk) ** 3;\n    newGlyph(S, S.gi);\n    S.started = true;\n  } else if (btn && !S.btn && S.phase \u003c 2) (S.phase = 2), (S.t = 0);\n  S.btn = btn;\n  S.t += (d * S.speed) / 2;\n  if (S.phase === 0) {\n    // The first thread runs out over T0, then the rest follow on an S-curve.\n    const want = max(S.nt * ease((S.t - T0) / (TB - T0)), cl(S.t / T0, 0, 1));\n    while (S.laid + 1 \u003c= want && S.laid \u003c S.nt && S.next >= 0) lay(S);\n    S.u = cl(want - S.laid, 0, 1);\n    if (S.laid >= S.nt || S.next \u003c 0) (S.phase = 1), (S.t = 0);\n  } else if (S.phase === 1) {\n    if (S.t >= HOLD) (S.phase = 2), (S.t = 0);\n  } else {\n    S.fade = cl(1 - S.t / CUT, 0, 1);\n    if (S.t >= CUT) newGlyph(S, S.gi + 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, f = S.fade, part = S.part, tc = S.tc;\n  part.fill(0);\n  // The thread being laid, as far as it has got.\n  if (S.phase === 0 && S.next >= 0 && S.u > 0) {\n    tint(S, S.laid, tc);\n    walk(S.P[S.at], S.P[S.next], S.u, (i, w) => (part[i] += S.al * w));\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const kk = i * 3, p = part[i];\n    display.setPixel(i % W, floor(i / W), round(tone(rgb[kk] + p * tc[0]) * f * 255), round(tone(rgb[kk + 1] + p * tc[1]) * f * 255), round(tone(rgb[kk + 2] + p * tc[2]) * f * 255));\n  }\n  // The pins.\n  hsv(S.hue + HUE0 + S.gi * 0.13, 0.15, 0.3, S.pc);\n  const pc = S.pc;\n  for (const p of S.P) display.setPixel(p.x, p.y, round(pc[0] * 255), round(pc[1] * 255), round(pc[2] * 255));\n  // Below Speed 1 a thread takes long enough to follow, and the point it has\n  // reached shows as a bright needle.\n  const nd = cl((1 - S.speed) / 0.5, 0, 1);\n  if (nd > 0 && S.phase === 0 && S.next >= 0 && S.u > 0) {\n    const a = S.P[S.at], b = S.P[S.next], x = round(a.x + (b.x - a.x) * S.u), y = round(a.y + (b.y - a.y) * S.u);\n    const v = 255 * nd * f;\n    display.setPixel(x, y, round(v * (0.6 + 0.4 * tc[0])), round(v * (0.6 + 0.4 * tc[1])), round(v * (0.6 + 0.4 * tc[2])));\n  }\n}\n","coded-aperture":"// ===== Patternflow pattern =====\n// Title:   Coded Aperture\n// Family:  type\n// Idea:    A glowing word shines through a card punched with a modified uniformly redundant array onto a detector where photons land one by one as an unreadable jumble of overlapping shadows, and correlating that jumble with the array's decoding pattern brings the word up out of the noise as the counts pile up, until the 6 s exposure ends and the detector is cleared.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: coded aperture imaging with random arrays of pinholes (Robert H. Dicke, 1968; J. G. Ables, 1968), uniformly redundant arrays (E. E. Fenimore and T. M. Cannon, 1978), modified uniformly redundant arrays from quadratic residues (S. R. Gottesman and E. E. Fenimore, 1989), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Rate=0.2..3, Mask=0..2, Word=0..3\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the word, the light in the holes and the decoded word are pale gold and the photons on the detector cyan.\n// Knob 2: Rate. Photons a second through the coded card, 1500 per unit: 3000 at 2, 300 at 0.2, 4500 at 3, on top of a detector background of 1 count per element a second. Every exposure lasts 6 s and holds its result 1.2 s, so the rate sets how clear the word comes up: at the end it stands 3.8 noise widths above the empty sky at 2, 0.9 at 0.2 and 4.7 at 3.\n// Knob 3: Mask. 0 is the MURA for p = 17, 144 holes of 289. 1 is a random card about half open, the kind Dicke and Ables proposed, decoded by balanced correlation; even without noise its shadows do not cancel, so 15 of STAR's 34 elements come out under half bright and a ghost in the sky reaches 38%. 2 is one pinhole in the middle. Every hole passes the same light, so in the same 6 s the pinhole gathers 123 photons among 1740 background counts, and the word ends 1.5 noise widths clear against 2.6 for the random card and 3.8 for the MURA.\n// Knob 4: Word. What shines above the card: STAR, CRAB, VELA or LUX, in 3 by 5 letters on the 17 by 17 sky. The fewer the lit elements, the clearer the decoded word: LUX, 27 elements, ends at 4.7 where STAR, 34, ends at 3.8.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Geometry. The sky, the card and the detector are all 17 by 17\n// elements, one element 3 LEDs wide and 2 tall, so each band is 51 by 34.\n// From the top: the word (sky rows 5 to 11 only), the card, the detector,\n// and the decoded sky.\nconst P = 17, C = 8, NE = P * P;\nconst CW = 3, CH = 2, X0 = 6, BW = P * CW, BH = P * CH;\nconst Y_OBJ = 0, OBJ_R0 = 5, OBJ_R1 = 11, Y_MASK = 18, Y_DET = 56, Y_DEC = 94;\nconst EXPO = 6, HOLD = 1.2, CYCLE = EXPO + HOLD;\n// Detector background, counts per element per second, the same for every\n// mask: the cosmic-ray and radioactive counts an X-ray detector sees.\nconst BKG = 1;\n// The pattern opens 0.6 s into an exposure, so that 2 s in the word\n// already stands about 2.5 noise widths clear.\nconst T0 = 0.6;\n\n// ---- Letters, 3 by 5, on sky rows 6 to 10.\nconst FONT = {\n  S: [\".##\", \"#..\", \".#.\", \"..#\", \"##.\"], T: [\"###\", \".#.\", \".#.\", \".#.\", \".#.\"],\n  A: [\".#.\", \"#.#\", \"###\", \"#.#\", \"#.#\"], R: [\"##.\", \"#.#\", \"##.\", \"#.#\", \"#.#\"],\n  C: [\".##\", \"#..\", \"#..\", \"#..\", \".##\"], B: [\"##.\", \"#.#\", \"##.\", \"#.#\", \"##.\"],\n  V: [\"#.#\", \"#.#\", \"#.#\", \"#.#\", \".#.\"], E: [\"###\", \"#..\", \"##.\", \"#..\", \"###\"],\n  L: [\"#..\", \"#..\", \"#..\", \"#..\", \"###\"], U: [\"#.#\", \"#.#\", \"#.#\", \"#.#\", \"###\"],\n  X: [\"#.#\", \"#.#\", \".#.\", \"#.#\", \"#.#\"],\n};\nconst WORDS = [\"STAR\", \"CRAB\", \"VELA\", \"LUX\"];\n\nfunction sky(word) {\n  const O = new Uint8Array(NE), n = word.length, c0 = floor((P - (4 * n - 1)) / 2);\n  for (let k = 0; k \u003c n; k++)\n    for (let r = 0; r \u003c 5; r++) for (let c = 0; c \u003c 3; c++) if (FONT[word[k]][r][c] === \"#\") O[(6 + r) * P + c0 + 4 * k + c] = 1;\n  const lit = [];\n  for (let e = 0; e \u003c NE; e++) if (O[e]) lit.push(e);\n  return { O, lit };\n}\n\n// ---- The cards, in display coordinates with the centre at (C, C). A photon\n// from sky element s through hole h lands on detector element d = h - s + C\n// (mod 17, each axis): the shadow of the whole card, shifted, as when the\n// card is the 2 by 2 mosaic of one period. Decoding is the periodic\n// correlation dec(o) = sum over d of D(d) Q(d + o - C), and for the MURA\n// sum over x of M(x) Q(x + t) is 144 at t = 0 and exactly 0 everywhere else,\n// so a noiseless detector decodes to 144 times the sky. Q sums to 1, so a\n// flat background adds a flat offset.\nfunction cards() {\n  const q = new Int8Array(P).fill(-1);\n  for (let x = 1; x \u003c P; x++) q[(x * x) % P] = 1;\n  const mura = { M: new Uint8Array(NE), Q: new Int8Array(NE) };\n  for (let i = 0; i \u003c P; i++)\n    for (let j = 0; j \u003c P; j++) {\n      // Gottesman and Fenimore: row 0 closed, column 0 open, else open where\n      // both indices are residues or both are not.\n      const a = i === 0 ? 0 : j === 0 ? 1 : q[i] * q[j] === 1 ? 1 : 0;\n      const e = ((i + C) % P) * P + ((j + C) % P);\n      mura.M[e] = a;\n      mura.Q[e] = i === 0 && j === 0 ? 1 : a ? 1 : -1;\n    }\n  // Dicke's and Ables's random card: each element open with chance 1/2, from\n  // a fixed hash so the card is the same every time. Decoded with 2M - 1.\n  const rand = { M: new Uint8Array(NE), Q: new Int8Array(NE) };\n  for (let e = 0; e \u003c NE; e++) {\n    let h = (e * 2654435761 + 12345) >>> 0;\n    h ^= h >>> 15; h = Math.imul(h, 0x2c1b3c6d) >>> 0; h ^= h >>> 12; h = Math.imul(h, 0x297a2d39) >>> 0; h ^= h >>> 15;\n    rand.M[e] = (h >>> 0) % 1000 \u003c 498 ? 1 : 0;\n    rand.Q[e] = rand.M[e] ? 1 : -1;\n  }\n  const pin = { M: new Uint8Array(NE), Q: new Int8Array(NE) };\n  pin.M[C * P + C] = 1;\n  pin.Q[C * P + C] = 1;\n  return [mura, rand, pin].map((m) => {\n    const holes = [];\n    let sq = 0;\n    for (let e = 0; e \u003c NE; e++) {\n      if (m.M[e]) holes.push(e);\n      sq += m.Q[e];\n    }\n    return { ...m, holes, sq };\n  });\n}\nconst KMURA = 144;\n\nfunction gauss() {\n  const u = Math.random() || 1e-9, v = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * v);\n}\nfunction poisson(l) {\n  if (l \u003c= 0) return 0;\n  if (l > 30) return max(0, round(l + sqrt(l) * gauss()));\n  const L = exp(-l);\n  let k = 0, p = Math.random();\n  while (p > L) {\n    k++;\n    p *= Math.random();\n  }\n  return k;\n}\n\nfunction clear(S) {\n  // What the last exposure decoded fades out in about a quarter second.\n  if (S.view) {\n    S.oldDec.set(S.view);\n    S.oldA = 1;\n  }\n  S.D.fill(0);\n  S.dD.fill(0);\n  S.dec.fill(0);\n  S.cnt.fill(0);\n  S.nWord = 0;\n  S.nBkg = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    cards: cards(), mode: -1, word: -1, hue: 0, rate: 3000, t: 0, sky: null,\n    D: new Float32Array(NE), dD: new Float32Array(NE), dec: new Float32Array(NE),\n    cnt: new Float32Array(BW * BH), flash: new Float32Array(BW * BH), hole: new Float32Array(NE), spark: new Float32Array(NP),\n    nWord: 0, nBkg: 0, rgb: new Float32Array(NP * 3), wrap: new Int32Array(3 * P),\n    view: new Float32Array(NE), oldDec: new Float32Array(NE), oldA: 0,\n  });\n  for (let x = 0; x \u003c 3 * P; x++) S.wrap[x] = x % P;\n}\n\nfunction land(S, d, flash) {\n  S.D[d]++;\n  S.dD[d]++;\n  const di = floor(d / P), dj = d - di * P;\n  const led = (di * CH + floor(Math.random() * CH)) * BW + dj * CW + floor(Math.random() * CW);\n  S.cnt[led]++;\n  S.flash[led] = min(1.6, S.flash[led] + flash);\n}\n\nfunction spark(S, x, y) {\n  const i = y * W + x;\n  S.spark[i] = min(1.2, S.spark[i] + 0.7);\n}\n\nfunction expose(S, dt) {\n  const card = S.cards[S.mode], lit = S.sky.lit, holes = card.holes;\n  // Equal exposure: every hole passes the same flux, so the photon count\n  // scales with the number of holes.\n  const n = poisson((S.rate * dt * holes.length) / KMURA);\n  for (let k = 0; k \u003c n; k++) {\n    const s = lit[floor(Math.random() * lit.length)], h = holes[floor(Math.random() * holes.length)];\n    const si = floor(s / P), sj = s - si * P, hi = floor(h / P), hj = h - hi * P;\n    land(S, ((hi - si + C + P) % P) * P + ((hj - sj + C + P) % P), 1);\n    S.hole[h] = min(1, S.hole[h] + 0.5);\n    // One photon in three is drawn in flight, in the gaps above and below\n    // the card, over the element it left and the hole it went through.\n    if (Math.random() \u003c 0.33) {\n      spark(S, X0 + sj * CW + floor(Math.random() * CW), Y_MASK - 4 + floor(Math.random() * 4));\n      spark(S, X0 + hj * CW + floor(Math.random() * CW), Y_DET - 4 + floor(Math.random() * 4));\n    }\n  }\n  S.nWord += n;\n  const b = poisson(BKG * NE * dt);\n  for (let k = 0; k \u003c b; k++) land(S, floor(Math.random() * NE), 0.8);\n  S.nBkg += b;\n  // Fold this frame's counts into the decoded sky.\n  const Q = card.Q, wrap = S.wrap, dec = S.dec;\n  for (let d = 0; d \u003c NE; d++) {\n    const c = S.dD[d];\n    if (!c) continue;\n    S.dD[d] = 0;\n    const di = floor(d / P), dj = d - di * P;\n    for (let oi = 0; oi \u003c P; oi++) {\n      const row = wrap[di + oi - C + P] * P, base = oi * P;\n      for (let oj = 0; oj \u003c P; oj++) dec[base + oj] += c * Q[row + wrap[dj + oj - C + P]];\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.rate = 1500 * cl(k[1], 0.2, 3);\n  const mode = cl(round(k[2]), 0, 2), word = cl(round(k[3]), 0, 3);\n  if (mode !== S.mode || word !== S.word) {\n    if (S.mode \u003c 0) S.t = T0;\n    S.mode = mode;\n    S.word = word;\n    S.sky = sky(WORDS[word]);\n    clear(S);\n    if (S.t > 0) {\n      // Open on an exposure already under way: replay the time since it began.\n      const was = S.t;\n      S.t = 0;\n      while (S.t \u003c was) {\n        expose(S, min(0.1, was - S.t));\n        S.t += 0.1;\n      }\n      S.t = was;\n      S.flash.fill(0);\n    }\n  }\n  const fade = exp(-d / 0.12), hf = exp(-d / 0.08);\n  for (let i = 0; i \u003c S.flash.length; i++) S.flash[i] *= fade;\n  for (let i = 0; i \u003c NE; i++) S.hole[i] *= hf;\n  for (let i = 0; i \u003c NP; i++) S.spark[i] *= hf;\n  S.t += d;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    clear(S);\n  }\n  S.oldA *= exp(-d / 0.12);\n  if (S.t \u003c EXPO) expose(S, d);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.sky) return;\n  const rgb = S.rgb, card = S.cards[S.mode], O = S.sky.O;\n  const gold = hsv(0.12 + S.hue, 0.38, 1), cyan = hsv(0.52 + S.hue, 0.55, 1), night = hsv(0.62 + S.hue, 0.5, 0.035);\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += c[0] * a;\n    rgb[o + 1] += c[1] * a;\n    rgb[o + 2] += c[2] * a;\n  };\n  // The word, with a soft glow round it.\n  for (let r = OBJ_R0; r \u003c= OBJ_R1; r++)\n    for (let j = 0; j \u003c P; j++)\n      for (let y = 0; y \u003c CH; y++)\n        for (let x = 0; x \u003c CW; x++) {\n          const px = X0 + j * CW + x, py = Y_OBJ + (r - OBJ_R0) * CH + y;\n          let g = 0;\n          for (let dr = -1; dr \u003c= 1; dr++)\n            for (let dj = -1; dj \u003c= 1; dj++) {\n              const rr = r + dr, jj = j + dj;\n              if (rr >= 0 && rr \u003c P && jj >= 0 && jj \u003c P && O[rr * P + jj]) g += dr || dj ? 0.05 : 0;\n            }\n          put(px, py, O[r * P + j] ? gold : night, O[r * P + j] ? 0.95 : 1);\n          put(px, py, gold, g);\n        }\n  // The card: dark, the holes lit from above, flickering as photons pass.\n  const plate = hsv(0.6 + S.hue, 0.25, 0.05), lightC = hsv(0.12 + S.hue, 0.3, 1);\n  for (let e = 0; e \u003c NE; e++) {\n    const i = floor(e / P), j = e - i * P;\n    for (let y = 0; y \u003c CH; y++)\n      for (let x = 0; x \u003c CW; x++) {\n        const px = X0 + j * CW + x, py = Y_MASK + i * CH + y;\n        if (card.M[e]) put(px, py, lightC, (y === 0 ? 0.42 : 0.3) + 0.35 * S.hole[e]);\n        else put(px, py, plate, 1);\n      }\n  }\n  // The detector: counts per LED, and each new photon a flash.\n  // Linear in counts, so the overlapping shadows show through the grain:\n  // the mean LED reaches 0.4 at the end of an exposure through the MURA.\n  const ref = (S.rate * EXPO + BKG * NE * EXPO) / (BW * BH);\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c BW; x++) {\n      const i = y * BW + x, v = (S.cnt[i] / ref) * 0.4, f = S.flash[i];\n      put(X0 + x, Y_DET + y, cyan, v);\n      put(X0 + x, Y_DET + y, [1, 1, 1], 0.5 * f);\n    }\n  // The decoded sky: counts per sky element, the background's flat offset\n  // taken off, stretched so the word reaches 1 at the end of an exposure.\n  const full = (S.rate * EXPO * card.holes.length) / KMURA / S.sky.lit.length;\n  const off = (S.nBkg / NE) * card.sq;\n  for (let e = 0; e \u003c NE; e++) {\n    const i = floor(e / P), j = e - i * P;\n    const v = (S.view[e] = cl((S.dec[e] - off) / full, 0, 1.3));\n    const u = max(v, S.oldDec[e] * S.oldA);\n    for (let y = 0; y \u003c CH; y++)\n      for (let x = 0; x \u003c CW; x++) {\n        put(X0 + j * CW + x, Y_DEC + i * CH + y, night, 1);\n        put(X0 + j * CW + x, Y_DEC + i * CH + y, gold, 0.85 * u);\n      }\n  }\n  // The exposure clock: a thread under the detector that runs out over the\n  // 6 s and stays full while the decoded word holds.\n  const run = min(1, S.t / EXPO) * BW;\n  for (let x = 0; x \u003c run; x++) put(X0 + x, Y_DET + BH + 1, cyan, 0.3);\n  for (let p = 0; p \u003c NP; p++) if (S.spark[p] > 0.01) put(p % W, floor(p / W), p \u003c Y_MASK * W ? gold : lightC, 0.6 * S.spark[p]);\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3;\n    display.setPixel(p % W, floor(p / W), min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n  }\n}\n","euler-strokes":"// ===== Patternflow pattern =====\n// Title:   Euler Strokes\n// Family:  type\n// Idea:    A pen writes a word stacked down the panel letter by letter, each letter a graph of stroke ends, corners and junctions, in exactly as many strokes as Euler's count of its odd vertices allows, following a Hierholzer route: the unwritten skeleton is faintly tinted with the stroke each piece will belong to, the odd vertices glow before the pen reaches them, each pen lift leaves a faint dashed trail, and beside each letter a digit and a row of pips keep its stroke count.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the seven bridges of Königsberg and the odd-vertex count (Leonhard Euler, Solutio problematis ad geometriam situs pertinentis, 1736), the construction of an Euler path (Carl Hierholzer, 1873), one-stroke drawing (한붓그리기), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Order=0..1\n//\n// Knob 1: Hue. Turns every colour together. At 0 the first stroke of a letter is cyan, the second magenta, the third gold, the fourth green; the marks where strokes start and end are warm white on odd vertices and rose on even ones, and fresh ink is white hot for about 0.7 s.\n// Knob 2: Speed. At 2 the pen writes 34 LEDs a second, travels with the pen up at 90 and rests 0.12 s on each touch and lift. PATH takes 10.5 to 10.8 s in the Euler order and 12.6 s in school order, then holds for 1.8 s and fades for 0.9 s before it is written again. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. PATH (1, 2, 2 and 3 strokes), 다리 (bridge: 3 and 2), EULER (2, 1, 1, 2, 1) or 한붓 (one brush: 6 and 6), the counts in the Euler order. Each letter is a vertex and edge list in the code; the word stacks one letter per cell down the 128 rows.\n// Knob 4: Order. Below 0.5 the pen takes the fewest strokes, max(1, odd/2) for each connected piece, on a Hierholzer route that pairs the spare odd vertices with short pen-up hops, and each pass picks a new route of the same count (H has 11, 붓 32 seen in 3000 passes). Above 0.5 it follows school stroke order instead (ball and stick print for the Latin letters, 필순 for Hangul), and the counts grow: PATH 10 against 8, 다리 8 against 5, EULER 12 against 7, 한붓 14 against 12. A ring stays where each stroke touched down or lifted. Rose rings sit on even vertices: in the Euler order only a closed piece (the ring of ㅎ) touches one, in school order P, A, E, ㄷ, ㄹ and ㅂ do too.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, sin, cos, exp, abs, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters as graphs. v is the vertex list (x, y pairs, y down) in a box\n// 10 by 14 for a Latin capital and 14 by 14 for a Hangul syllable. An edge is\n// [a, b] or [a, b, points between]; c is the school stroke order, each stroke\n// a list of edges, ~i for edge i run from b to a.\nconst arc = (cx, cy, rx, ry, a0, a1, n) => {\n  const o = [];\n  for (let i = 1; i \u003c n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n;\n    o.push(cx + rx * cos(a), cy + ry * sin(a));\n  }\n  return o;\n};\nconst bowl = () => [5.5, 0, ...arc(5.5, 3.75, 4, 3.75, -PI / 2, PI / 2, 10), 5.5, 7.5];\nconst GLYPHS = {\n  // P: the stem's top has degree 2, the joint 3, the foot 1. One stroke.\n  P: { v: [1.5, 0, 1.5, 7.5, 1.5, 14], e: [[0, 1], [1, 2], [0, 1, bowl()]], c: [[0, 1], [2]] },\n  // A: apex 2, feet 1, the crossbar's ends 3. Two strokes.\n  A: { v: [5, 0, 0.5, 14, 9.5, 14, 2.11, 9, 7.89, 9], e: [[0, 3], [3, 1], [0, 4], [4, 2], [3, 4]], c: [[0, 1], [2, 3], [4]] },\n  // T: three ends and a junction of 3. Two strokes.\n  T: { v: [0.5, 0, 5, 0, 9.5, 0, 5, 14], e: [[0, 1], [1, 2], [1, 3]], c: [[2], [0, 1]] },\n  // H: four ends and two junctions, six odd vertices. Three strokes.\n  H: { v: [1, 0, 1, 7, 1, 14, 9, 0, 9, 7, 9, 14], e: [[0, 1], [1, 2], [3, 4], [4, 5], [1, 4]], c: [[0, 1], [2, 3], [4]] },\n  // E: three bar ends and the middle junction are odd, the corners even. Two strokes.\n  E: { v: [9, 0, 1, 0, 1, 7, 8, 7, 1, 14, 9, 14], e: [[1, 0], [1, 2], [2, 4], [2, 3], [4, 5]], c: [[1, 2], [0], [3], [4]] },\n  U: { v: [1, 0, 9, 0], e: [[0, 1, [1, 9.5, ...arc(5, 9.5, 4, 4.5, PI, 0, 12), 9, 9.5]]], c: [[0]] },\n  L: { v: [1.5, 0, 1.5, 14, 9, 14], e: [[0, 1], [1, 2]], c: [[0, 1]] },\n  // R: the leg leaves from the joint, which takes degree 4. One stroke.\n  R: { v: [1.5, 0, 1.5, 7.5, 1.5, 14, 9.5, 14], e: [[0, 1], [1, 2], [0, 1, bowl()], [1, 3]], c: [[0, 1], [2, 3]] },\n  // 다: ㄷ is an open path (1), ㅏ a stem with a branch (2).\n  다: {\n    v: [7.2, 2.2, 1, 2.2, 1, 11.8, 7.6, 11.8, 10.4, 0, 10.4, 7, 10.4, 14, 13.4, 7],\n    e: [[0, 1], [1, 2], [2, 3], [4, 5], [5, 6], [5, 7]],\n    c: [[~0], [1, 2], [3, 4], [5]],\n  },\n  // 리: ㄹ is one zigzag (1, written as 3), ㅣ a line (1).\n  리: {\n    v: [1, 1.2, 7.4, 1.2, 7.4, 7, 1, 7, 1, 12.8, 7.8, 12.8, 11, 0, 11, 14],\n    e: [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [6, 7]],\n    c: [[0, 1], [~2], [3, 4], [5]],\n  },\n  // 한: ㅎ is three pieces (tick, bar, ring), ㅏ two strokes, ㄴ one.\n  한: {\n    v: [4.3, 0.2, 4.3, 1.5, 1, 2.4, 7.6, 2.4, 4.3, 3.5, 4.3, 8.1, 10.6, 0, 10.6, 4.6, 10.6, 9.2, 13.4, 4.6, 1.6, 10.2, 1.6, 13.6, 13, 13.6],\n    e: [[0, 1], [2, 3], [4, 5, arc(4.3, 5.8, 2.6, 2.3, -PI / 2, -1.5 * PI, 10)], [5, 4, arc(4.3, 5.8, 2.6, 2.3, PI / 2, -PI / 2, 10)], [6, 7], [7, 8], [7, 9], [10, 11], [11, 12]],\n    c: [[0], [1], [2, 3], [4, 5], [6], [7, 8]],\n  },\n  // 붓: ㅂ has four odd vertices (2, written as 4), ㅜ 2, ㅅ 2.\n  붓: {\n    v: [2.5, 0.3, 2.5, 2.7, 2.5, 5.2, 11.5, 0.3, 11.5, 2.7, 11.5, 5.2, 0.5, 7.2, 7, 7.2, 13.5, 7.2, 7, 9.6, 7, 10.3, 2.6, 13.8, 5.4, 11.57, 11.4, 13.8],\n    e: [[0, 1], [1, 2], [3, 4], [4, 5], [1, 4], [2, 5], [6, 7], [7, 8], [7, 9], [10, 12], [12, 11], [12, 13]],\n    c: [[0, 1], [2, 3], [4], [5], [6, 7], [8], [9, 10], [11]],\n  },\n};\nconst WORDS = [[\"P\", \"A\", \"T\", \"H\"], [\"다\", \"리\"], [\"E\", \"U\", \"L\", \"E\", \"R\"], [\"한\", \"붓\"]];\nconst STROKE_HUE = [0, 0.36, 0.62, 0.8, 0.2, 0.5, 0.27, 0.9];\n\n// 3 by 5 digits for the counts.\nconst DIGITS = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7292, 0x7bef, 0x7bcf];\n\n// Pen speeds in LEDs per second and rests in seconds, at Speed 2.\nconst V_DOWN = 34, V_UP = 90, REST = 0.12, HOLD = 1.8, FADE = 0.9;\n\n// ---- Euler's count and Hierholzer's route. Each connected piece with 2k odd\n// vertices is drawn in k strokes: k - 1 pen-up hops pair off all but two odd\n// vertices, the walk starts at one of those two, and Hierholzer's splice\n// finds a walk that uses every edge once. The hops are where it lifts.\nfunction* matchings(a) {\n  if (!a.length) {\n    yield [];\n    return;\n  }\n  const [x, ...rest] = a;\n  for (let i = 0; i \u003c rest.length; i++) {\n    const y = rest[i], others = rest.filter((_, j) => j !== i);\n    for (const m of matchings(others)) yield [[x, y], ...m];\n  }\n}\n\nfunction eulerOrder(g) {\n  const nv = g.v.length / 2, deg = new Array(nv).fill(0), par = [...Array(nv).keys()];\n  const find = (x) => (par[x] === x ? x : (par[x] = find(par[x])));\n  for (const [a, b] of g.e) {\n    deg[a]++;\n    deg[b]++;\n    par[find(a)] = find(b);\n  }\n  const key = (i) => g.v[2 * i + 1] + 0.6 * g.v[2 * i];\n  const dist = (a, b) => hypot(g.v[2 * a] - g.v[2 * b], g.v[2 * a + 1] - g.v[2 * b + 1]);\n  const comps = new Map();\n  for (let i = 0; i \u003c nv; i++) if (deg[i]) (comps.get(find(i)) || comps.set(find(i), []).get(find(i))).push(i);\n  const list = [...comps.values()].sort((A, B) => min(...A.map(key)) - min(...B.map(key)));\n  const strokes = [];\n  for (const C of list) {\n    const odd = C.filter((i) => deg[i] & 1);\n    let s = C.reduce((a, b) => (key(a) \u003c= key(b) ? a : b)), hops = [];\n    if (odd.length) {\n      let best = Infinity;\n      for (const si of odd)\n        for (const ti of odd) {\n          if (si === ti) continue;\n          for (const m of matchings(odd.filter((x) => x !== si && x !== ti))) {\n            let c = 0.15 * key(si) + 0.8 * Math.random();\n            for (const [a, b] of m) c += dist(a, b);\n            if (c \u003c best) (best = c), (s = si), (hops = m);\n          }\n        }\n    }\n    // The piece's edges and the hops, with each vertex's list shuffled so\n    // each pass can take another route of the same count.\n    const ids = [], ends = [];\n    g.e.forEach((e, i) => {\n      if (find(e[0]) === find(C[0])) ids.push(i), ends.push([e[0], e[1]]);\n    });\n    for (const [a, b] of hops) ids.push(-1), ends.push([a, b]);\n    const adj = new Map();\n    ends.forEach(([a, b], j) => {\n      for (const x of [a, b]) (adj.get(x) || adj.set(x, []).get(x)).push(j);\n    });\n    for (const l of adj.values())\n      for (let i = l.length - 1; i > 0; i--) {\n        const j = floor(Math.random() * (i + 1));\n        [l[i], l[j]] = [l[j], l[i]];\n      }\n    const used = new Uint8Array(ends.length), ptr = new Map(), stack = [[s, -1]], walk = [];\n    while (stack.length) {\n      const [v, j] = stack[stack.length - 1], l = adj.get(v) || [];\n      let p = ptr.get(v) || 0, moved = false;\n      while (p \u003c l.length) {\n        const jj = l[p++];\n        if (used[jj]) continue;\n        used[jj] = 1;\n        stack.push([ends[jj][0] === v ? ends[jj][1] : ends[jj][0], jj]);\n        moved = true;\n        break;\n      }\n      ptr.set(v, p);\n      if (!moved) {\n        stack.pop();\n        if (j >= 0) walk.push([j, v]);\n      }\n    }\n    walk.reverse();\n    let at = s, cur = [];\n    for (const [j, to] of walk) {\n      if (ids[j] \u003c 0) {\n        if (cur.length) strokes.push(cur);\n        cur = [];\n      } else cur.push(ends[j][0] === at && ends[j][1] === to ? ids[j] : ~ids[j]);\n      at = to;\n    }\n    if (cur.length) strokes.push(cur);\n  }\n  return strokes;\n}\n\n// ---- Layout: one letter per cell down the panel, its count beside it.\nfunction layout(S) {\n  const word = WORDS[S.word], n = word.length, ch = H / n, hangul = word[0].charCodeAt(0) > 255;\n  const bw = hangul ? 14 : 10, bh = 14, CWID = 15, GAP = 5;\n  // Latin capitals may stretch up to 1.4 times wider than tall.\n  const sy = min((W - 4 - CWID - GAP) / bw, (ch - (n > 3 ? 7 : 10)) / bh), sx = min((W - 4 - CWID - GAP) / bw, sy * (hangul ? 1 : 1.4));\n  const gw = bw * sx, x0 = (W - gw - GAP - CWID) / 2;\n  S.r = 0.85 + 0.28 * sy;\n  S.glyphs = word.map((name, gi) => {\n    const g = GLYPHS[name], y0 = gi * ch + (ch - bh * sy) / 2;\n    const P = (x, y) => [x0 + x * sx, y0 + y * sy];\n    const vx = [], deg = new Array(g.v.length / 2).fill(0);\n    for (let i = 0; i \u003c g.v.length; i += 2) vx.push(P(g.v[i], g.v[i + 1]));\n    const edges = g.e.map(([a, b, mid]) => {\n      const pts = [...vx[a]];\n      for (let i = 0; mid && i \u003c mid.length; i += 2) pts.push(...P(mid[i], mid[i + 1]));\n      pts.push(...vx[b]);\n      deg[a]++;\n      deg[b]++;\n      return pts;\n    });\n    return { g, vx, edges, deg, cx: x0 + gw + GAP, cy: gi * ch + ch / 2 };\n  });\n}\n\nfunction strokePts(G, refs) {\n  const out = [];\n  for (const ref of refs) {\n    const id = ref >= 0 ? ref : ~ref, e = G.edges[id], n = e.length / 2;\n    for (let i = 0; i \u003c n; i++) {\n      const k = ref >= 0 ? i : n - 1 - i;\n      if (out.length && i === 0) continue;\n      out.push(e[2 * k], e[2 * k + 1]);\n    }\n  }\n  return out;\n}\n\n// Which vertex a stroke starts or ends on.\nfunction vertexAt(G, x, y) {\n  let best = -1, bd = 0.5;\n  G.vx.forEach(([vx, vy], i) => {\n    const d = hypot(vx - x, vy - y);\n    if (d \u003c bd) (bd = d), (best = i);\n  });\n  return best;\n}\n\nfunction track(pts) {\n  const cum = [0];\n  for (let i = 2; i \u003c pts.length; i += 2) cum.push(cum[cum.length - 1] + hypot(pts[i] - pts[i - 2], pts[i + 1] - pts[i - 1]));\n  return { pts, cum, len: cum[cum.length - 1] };\n}\n\nfunction newPass(S) {\n  S.moves = [];\n  S.counts = [];\n  S.marks = [];\n  S.ghost.fill(0);\n  let px = null, py = null;\n  S.glyphs.forEach((G, gi) => {\n    const strokes = S.mode ? G.g.c : eulerOrder(G.g);\n    S.counts[gi] = strokes.length;\n    S.marks[gi] = new Set();\n    strokes.forEach((refs, k) => {\n      const pts = strokePts(G, refs), n = pts.length;\n      if (px !== null) S.moves.push({ up: true, gi, ...track([px, py, pts[0], pts[1]]) });\n      const sv = vertexAt(G, pts[0], pts[1]), ev = vertexAt(G, pts[n - 2], pts[n - 1]);\n      S.moves.push({ up: false, gi, k, sv, ev, ...track(pts) });\n      // The unwritten skeleton, faintly tinted with the stroke each piece\n      // will belong to, so the route shows before the pen takes it.\n      for (let i = 2; i \u003c n; i += 2) capsule(S.ghost, null, pts[i - 2], pts[i - 1], pts[i], pts[i + 1], S.r, 1, 0, S.gk, k);\n      S.marks[gi].add(sv).add(ev);\n      px = pts[n - 2];\n      py = pts[n - 1];\n    });\n  });\n  S.mi = 0;\n  S.u = 0;\n  S.done = 0;\n  S.hold = -1;\n  S.ink.fill(0);\n  S.hot.fill(0);\n  S.touched = S.glyphs.map((G) => new Float32Array(G.vx.length).fill(-1));\n  S.lit = S.glyphs.map(() => []);\n  S.pen = [S.moves[0].pts[0], S.moves[0].pts[1], false];\n  S.started = -1;\n}\n\nconst dur = (m) => (m.up ? m.len / V_UP : REST + m.len / V_DOWN + REST);\n\nfunction posAt(m, s) {\n  const { pts, cum } = m;\n  let i = 1;\n  while (i \u003c cum.length - 1 && cum[i] \u003c s) i++;\n  const u = cum[i] > cum[i - 1] ? cl((s - cum[i - 1]) / (cum[i] - cum[i - 1]), 0, 1) : 1;\n  return [pts[2 * i - 2] + (pts[2 * i] - pts[2 * i - 2]) * u, pts[2 * i - 1] + (pts[2 * i + 1] - pts[2 * i - 1]) * u];\n}\n\n// Ink the move from arc length a to b: a capsule per piece for strokes, faint\n// dashes for pen-up hops.\nfunction inkSpan(S, m, a, b) {\n  if (b \u003c= a) return;\n  if (m.up) {\n    // Dashes two LEDs long with two LEDs between them.\n    for (let s = floor(a) + 1; s \u003c= b; s++) {\n      const [x, y] = posAt(m, s);\n      if (s > 2 && s \u003c m.len - 2 && s % 4 \u003c 2) capsule(S.ink, [0.3, 0.31, 0.36], x, y, x, y, 0.5, 1, 0);\n    }\n    return;\n  }\n  const col = S.strokeCol[m.k % 8];\n  const { pts, cum } = m;\n  for (let i = 1; i \u003c cum.length; i++) {\n    const s0 = max(a, cum[i - 1]), s1 = min(b, cum[i]);\n    if (s1 \u003c s0 || cum[i] \u003c= cum[i - 1]) continue;\n    const [x0, y0] = posAt(m, s0), [x1, y1] = posAt(m, s1);\n    capsule(S.ink, col, x0, y0, x1, y1, S.r, 1, 0.42);\n    capsule(S.hot, null, x0, y0, x1, y1, S.r, 1, 0.6);\n  }\n}\n\n// A round-ended segment: a solid core of radius r and a soft glow around it.\n// With col null it writes one channel (the ghost, with the stroke index in\n// kb, or the hot ink).\nfunction capsule(buf, col, ax, ay, bx, by, r, a, glow, kb, kv) {\n  const R = r + (glow ? 5 : 1), dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n  for (let y = max(0, floor(min(ay, by) - R)); y \u003c= min(H - 1, floor(max(ay, by) + R)); y++)\n    for (let x = max(0, floor(min(ax, bx) - R)); x \u003c= min(W - 1, floor(max(ax, bx) + R)); x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay, t = L2 > 0 ? cl((px * dx + py * dy) / L2, 0, 1) : 0;\n      const d = hypot(px - t * dx, py - t * dy), core = cl(r + 0.5 - d, 0, 1), e = max(0, d - r);\n      const v = a * max(core, glow * exp(-e * e * 0.16));\n      if (v \u003c= 0.004) continue;\n      const p = y * W + x;\n      if (!col) {\n        if (v > buf[p]) (buf[p] = v), kb && (kb[p] = kv);\n      } else for (let c = 0; c \u003c 3; c++) buf[3 * p + c] = max(buf[3 * p + c], col[c] * v * (core > 0.5 ? 1 : 0.85));\n    }\n}\n\nexport function setup(params) {\n  params.s = { word: -1, mode: 0, hue: -1, t: 0, ink: new Float32Array(NP * 3), ghost: new Float32Array(NP), gk: new Uint8Array(NP), hot: new Float32Array(NP), rgb: new Float32Array(NP * 3), strokeCol: [] };\n}\n\nfunction touch(S, gi, v) {\n  if (v >= 0 && S.touched[gi][v] \u003c 0) S.touched[gi][v] = S.t;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  if (k[0] !== S.hue) {\n    S.hue = k[0];\n    S.strokeCol = STROKE_HUE.map((h) => hsv(0.5 + S.hue + h, 0.58, 1));\n  }\n  const word = cl(round(k[2]), 0, 3), mode = k[3] >= 0.5 ? 1 : 0;\n  if (word !== S.word || mode !== S.mode) {\n    const relayout = word !== S.word;\n    S.word = word;\n    S.mode = mode;\n    if (relayout) layout(S);\n    newPass(S);\n  }\n  const step = (d * cl(k[1], 0.2, 3)) / 2, cool = exp(-d * 1.4);\n  S.t += step;\n  // Fresh ink is white hot and cools to its colour in about 0.7 s of real\n  // time, so a faster pen drags a longer hot tail.\n  for (let p = 0; p \u003c NP; p++) S.hot[p] *= cool;\n  if (S.hold >= 0) {\n    S.hold += step;\n    if (S.hold > HOLD + FADE) newPass(S);\n    return;\n  }\n  S.u += step;\n  for (let guard = 0; guard \u003c 64 && S.mi \u003c S.moves.length; guard++) {\n    const m = S.moves[S.mi];\n    if (!m.up && S.started !== S.mi) {\n      S.started = S.mi;\n      touch(S, m.gi, m.sv);\n      S.lit[m.gi][m.k] = 1;\n    }\n    const T = dur(m), s = m.up ? S.u * V_UP : cl((S.u - REST) * V_DOWN, 0, m.len);\n    inkSpan(S, m, S.done, min(s, m.len));\n    S.done = max(S.done, min(s, m.len));\n    const [x, y] = posAt(m, S.done);\n    S.pen = [x, y, !m.up];\n    if (S.u \u003c T) break;\n    if (!m.up) touch(S, m.gi, m.ev);\n    S.u -= T;\n    S.done = 0;\n    S.mi++;\n  }\n  if (S.mi >= S.moves.length) S.hold = 0;\n}\n\n// Soft disc or ring added on top of the frame.\nfunction spot(rgb, x, y, r, col, a, ring) {\n  const R = r + 2;\n  for (let j = max(0, floor(y - R)); j \u003c= min(H - 1, floor(y + R)); j++)\n    for (let i = max(0, floor(x - R)); i \u003c= min(W - 1, floor(x + R)); i++) {\n      const dd = hypot(i + 0.5 - x, j + 0.5 - y);\n      const v = a * (ring ? cl(1 - abs(dd - r) / 0.8, 0, 1) : cl(r + 0.5 - dd, 0, 1) + 0.35 * exp(-max(0, dd - r) * 0.9) * (dd > r ? 1 : 0));\n      if (v \u003c= 0) continue;\n      const o = 3 * (j * W + i);\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = max(rgb[o + c], col[c] * v);\n    }\n}\n\nfunction digit(rgb, n, x, y, col, z) {\n  const bits = DIGITS[n % 10];\n  for (let r = 0; r \u003c 5; r++)\n    for (let c = 0; c \u003c 3; c++)\n      if ((bits >> (14 - r * 3 - c)) & 1)\n        for (let j = 0; j \u003c z; j++)\n          for (let i = 0; i \u003c z; i++) {\n            const X = round(x) + c * z + i, Y = round(y) + r * z + j;\n            if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) for (let q = 0; q \u003c 3; q++) rgb[3 * (Y * W + X) + q] = col[q];\n          }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.glyphs) return;\n  const { rgb, ink, ghost, gk, hot, strokeCol } = S;\n  const fade = S.hold > HOLD ? cl((S.hold - HOLD) / FADE, 0, 1) : 0, keep = 1 - fade;\n  const bg = hsv(0.62 + S.hue, 0.6, 0.035), gc = hsv(0.6 + S.hue, 0.25, 0.2);\n  for (let p = 0; p \u003c NP; p++) {\n    const g = ghost[p], o = 3 * p, sc = strokeCol[gk[p] % 8];\n    for (let c = 0; c \u003c 3; c++) rgb[o + c] = max(bg[c] + g * (0.4 * gc[c] + 0.28 * sc[c]), ink[o + c] * keep) + 0.6 * hot[p];\n  }\n  const warm = hsv(0.12 + S.hue, 0.25, 1), rose = hsv(0.97 + S.hue, 0.5, 1), pale = hsv(0.6 + S.hue, 0.12, 0.85), pulse = 0.5 + 0.5 * sin(TAU * 1.3 * S.t);\n  const next = S.moves[S.mi];\n  S.glyphs.forEach((G, gi) => {\n    // The vertices where the plan's strokes start or end glow until the pen\n    // touches them, then keep a ring: warm on an odd vertex, rose on an even\n    // one. In the Euler order every mark but one per closed piece is odd.\n    for (const v of S.marks[gi]) {\n      const [x, y] = G.vx[v], col = G.deg[v] & 1 ? warm : rose;\n      if (S.touched[gi][v] >= 0) {\n        spot(rgb, x, y, 2.4, col, 0.6 * keep * min(1, (S.t - S.touched[gi][v]) * 4 + 0.2), true);\n        continue;\n      }\n      const after = next && next.up ? S.moves[S.mi + 1] : next, soon = after && !after.up && after.gi === gi && after.sv === v ? 1 : 0;\n      spot(rgb, x, y, 2.2, col, (0.4 + 0.35 * pulse + 0.35 * soon) * keep + 0.2 * fade);\n    }\n    // The count: a digit and a pip for each stroke, lit as the stroke starts.\n    const z = H / S.glyphs.length >= 30 ? 3 : 2, n = S.counts[gi], cols = min(4, n), rows = Math.ceil(n / 4), top = G.cy - (5 * z + 3 + rows * 4 - 1) / 2;\n    digit(rgb, n, G.cx + 7.5 - 1.5 * z, top, S.mode ? rose : pale, z);\n    for (let q = 0; q \u003c n; q++) {\n      const px = G.cx + (q % 4) * 4 + (4 - cols) * 2, py = top + 5 * z + 3 + floor(q / 4) * 4, on = S.lit[gi][q] && keep > 0;\n      const col = on ? S.strokeCol[q % 8] : gc;\n      for (let j = 0; j \u003c 3; j++)\n        for (let i = 0; i \u003c 3; i++) {\n          const X = round(px) + i, Y = round(py) + j;\n          if (X \u003c W && Y \u003c H) for (let c = 0; c \u003c 3; c++) rgb[3 * (Y * W + X) + c] = col[c] * (on ? keep : 0.9);\n        }\n    }\n  });\n  if (S.hold \u003c 0) {\n    const [x, y, down] = S.pen, m = S.moves[S.mi], lc = down && m ? S.strokeCol[m.k % 8] : pale;\n    // The pen tip lights the paper round it in the colour it writes.\n    for (let j = max(0, floor(y - 22)); j \u003c= min(H - 1, floor(y + 22)); j++)\n      for (let i = 0; i \u003c W; i++) {\n        const dx = i + 0.5 - x, dy = j + 0.5 - y, v = 0.2 * exp(-(dx * dx + dy * dy) / 130);\n        if (v \u003c 0.01) continue;\n        const o = 3 * (j * W + i);\n        for (let c = 0; c \u003c 3; c++) rgb[o + c] += lc[c] * v;\n      }\n    spot(rgb, x, y, down ? 1.2 : 1.7, [1, 1, 1], down ? 1 : 0.8, !down);\n  }\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, floor(p / W), min(255, rgb[3 * p] * 255) | 0, min(255, rgb[3 * p + 1] * 255) | 0, min(255, rgb[3 * p + 2] * 255) | 0);\n}\n","fractran":"// ===== Patternflow pattern =====\n// Title:   FRACTRAN\n// Family:  number\n// Idea:    Conway's PRIMEGAME runs as a bead machine: the exponents of 2, 3, 5 and 7 stand as columns of beads that pump up and down in sawtooth loops while beads rise out of them and fall back in, the first of the fourteen fractions that keeps n whole lights at each step, and whenever n is a bare power of two the machine stops with p beads in the 2 column alone and writes the prime p into the record at the top.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: FRACTRAN and PRIMEGAME (John Horton Conway, 1987, \"FRACTRAN: A Simple Universal Programming Language for Arithmetic\"), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Start=0..3, Trail=0..1\n//\n// Knob 1: Hue. Turns every colour together: at 0 the 2 column is gold, 3 cyan, 5 violet and 7 green, the fractions and the state lamps 11 to 29 blue and the record warm white.\n// Knob 2: Speed. Steps a second, 2 times 60 to the power (Speed - 0.2) / 1.8: 120 at 2, where 2, 3, 5 and 7 enter the record at 0.2, 1.2, 3.5 and 7.7 s; 2 at 0.2, slow enough to follow every fraction and every bead; 1170 at 3, where 29 arrives at 37 s. On a prime the machine waits for its beads to land and 30 steps more, 0.55 s at 2.\n// Knob 3: Start. Where a run begins: n = 2 at 0, then 2^11, 2^19 or 2^29, the states PRIMEGAME is in when it finds those primes, with the primes up to them already in the record. The higher the start, the taller the sawtooth: from 2^29 the 2 and 5 columns climb to 31 beads before 31 arrives at 73 s, and the beads thin from 5 rows to 2. A run ends 3 s after 2^41 and starts again.\n// Knob 4: Trail. How long the light stays, 0.05 times 30 to the power Trail seconds. At 0.06 a flying bead leaves almost nothing behind and the tubes show single beads; from 0.4 up each bead draws a full tail, and at 1 the tails last 1.5 s and pile up into lit tubes as bright as their traffic, the fractions glow by how often they fire, and each column keeps a ghost of its last peak that sinks a bead a second.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, exp, pow, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The machine. n is held as its exponents over the ten primes the\n// program uses, never as a number. 2, 3, 5 and 7 are the registers; 11 to 29\n// never go above 1 and act as the program's state.\nconst PR = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29];\nconst FR = [[17, 91], [78, 85], [19, 51], [23, 38], [29, 33], [77, 29], [95, 23], [77, 19], [1, 17], [11, 13], [13, 11], [15, 2], [1, 7], [55, 1]];\nfunction vec(n) {\n  const e = new Int8Array(10);\n  for (let i = 0; i \u003c 10; i++) while (n % PR[i] === 0) (n /= PR[i]), e[i]++;\n  return e;\n}\nconst NUM = FR.map((f) => vec(f[0])), DEN = FR.map((f) => vec(f[1]));\n// Run in Node from n = 2, 2^p first appears at step 19, 69, 281, 710, 2375,\n// 3893, 8102, 11361, 19268, 36981, 45680, 75417 and 101354 for p = 2 to 41.\nconst PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41];\nconst STARTS = [1, 11, 19, 29];\n\n// ---- Digits, 3 by 5.\nconst DIG = [\"###.#.#.#.#.###\", \".#.##..#..#.###\", \"###..#####..###\", \"###..#.##..####\", \"#.##.####..#..#\", \"####..###..####\", \"####..####.####\", \"###..#..#.#..#.\", \"####.#####.####\", \"####.####..####\"];\nconst textW = (s) => 4 * s.length - 1;\n\n// ---- Layout. The record of primes in two lines at the top, the fourteen\n// fractions in two rows of seven, numerator over denominator, the state\n// lamps 11 to 29, then the four register columns standing on row 120.\nconst REC_Y = [1, 7];\nconst FR_Y = [15, 31];\nconst ST_Y = 47;\nconst COL_X = [8, 24, 40, 56], FLOOR = 120, CEIL = 56;\nconst frX = (k) => 4.5 + 9 * (k % 7);\nconst frY = (k) => FR_Y[k \u003c 7 ? 0 : 1];\nconst stX = (j) => 6.5 + 10 * j;\nconst recPlace = (() => {\n  const out = [];\n  for (const [line, from, to] of [[0, 0, 7], [1, 7, 13]]) {\n    const items = PRIMES.slice(from, to).map(String);\n    let x = floor((W - (items.reduce((s, t) => s + textW(t), 0) + 3 * (items.length - 1))) / 2);\n    for (const t of items) {\n      out.push([x, REC_Y[line]]);\n      x += textW(t) + 3;\n    }\n  }\n  return out;\n})();\n\nfunction reset(S) {\n  const p = STARTS[S.start];\n  S.e = new Int32Array(10);\n  S.e[0] = p;\n  S.found = PRIMES.filter((q) => q \u003c= p && p > 1).length;\n  S.flights = [];\n  S.inc = new Int32Array(10);\n  S.heat.fill(0);\n  S.scan.fill(0);\n  S.ghost = new Float32Array(4);\n  S.acc = 0;\n  S.pause = 0;\n  S.flash = 0;\n  S.end = 0;\n  S.peak = max(12, p + 1);\n  S.pitch = min(5, (FLOOR - CEIL) / S.peak);\n  S.glow.fill(0);\n  S.last = -1;\n}\n\nexport function setup(params) {\n  params.s = { start: -1, hue: 0, rate: 100, trail: 0.06, heat: new Float32Array(14), scan: new Float32Array(14), glow: new Float32Array(NP * 3), rgb: new Float32Array(NP * 3), sheat: new Float32Array(6), gain: 1, hgain: 1, last: -1, dur: 0.3 };\n}\n\n// A bead in flight runs up or down its own column: up from the top of the\n// stack and out of the column's head when a denominator takes it, down from\n// the head onto the stack when a numerator gives it.\nfunction flight(S, j, y0, y1) {\n  if (S.flights.length > 240) {\n    if (y1 > y0) S.inc[j]--;\n    return;\n  }\n  S.flights.push({ j, y0, y1, u: 0 });\n}\n\nfunction step(S) {\n  const e = S.e;\n  let k = 0;\n  for (; k \u003c 14; k++) {\n    let ok = true;\n    for (let j = 0; j \u003c 10 && ok; j++) if (e[j] \u003c DEN[k][j]) ok = false;\n    if (ok) break;\n    // Tried and passed over: its bar flickers.\n    S.scan[k] = min(1, S.scan[k] + 0.35);\n  }\n  S.heat[k] = min(1.6, S.heat[k] + S.hgain);\n  S.last = k;\n  for (let j = 0; j \u003c 10; j++) {\n    e[j] -= DEN[k][j];\n    if (j \u003c 4) for (let d = 0; d \u003c DEN[k][j]; d++) flight(S, j, FLOOR - S.pitch * (e[j] + d + 0.5), CEIL - 2);\n  }\n  for (let j = 0; j \u003c 10; j++) {\n    for (let n = 0; n \u003c NUM[k][j]; n++) {\n      e[j]++;\n      if (j \u003c 4) {\n        S.inc[j]++;\n        flight(S, j, CEIL - 2, FLOOR - S.pitch * (e[j] - 0.5));\n      }\n    }\n  }\n  let bare = e[0] >= 2;\n  for (let j = 1; j \u003c 10 && bare; j++) if (e[j]) bare = false;\n  if (bare) {\n    S.found = PRIMES.indexOf(e[0]) + 1;\n    S.flash = 1;\n    // Hold until every bead has landed, then a beat more, so the 2 column\n    // stands alone with its p beads.\n    S.pause = S.dur + cl(30 / S.rate, 0.25, 1.5);\n    if (e[0] >= PRIMES[PRIMES.length - 1]) S.end = 3;\n  }\n  for (let j = 0; j \u003c 4; j++) if (e[j] + 1 > S.peak) S.peak = e[j] + 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const h = S.hue;\n  S.cols = [hsv(0.11 + h, 0.6, 1), hsv(0.5 + h, 0.6, 1), hsv(0.8 + h, 0.5, 1), hsv(0.32 + h, 0.6, 1), hsv(0.61 + h, 0.5, 1)];\n  S.rate = 2 * pow(60, (cl(k[1], 0.2, 3) - 0.2) / 1.8);\n  S.trail = cl(k[3], 0, 1);\n  const start = cl(round(k[2]), 0, 3);\n  if (start !== S.start) {\n    S.start = start;\n    reset(S);\n  }\n  const tau = 0.05 * pow(30, S.trail);\n  // A longer trail lays each pass down fainter, so a path's brightness is\n  // its traffic, not how long the light stays. At the shortest trail a bead\n  // leaves almost nothing behind it and the tubes show single beads.\n  S.gain = min(1, 0.35 / tau) * (0.12 + 0.88 * min(1, S.trail / 0.4));\n  const htau = max(0.1, tau, 0.6 / S.rate), fade = exp(-d / tau), hfade = exp(-d / htau);\n  S.hgain = min(1, 0.12 / htau);\n  for (let i = 0; i \u003c NP * 3; i++) S.glow[i] *= fade;\n  for (let i = 0; i \u003c 14; i++) S.heat[i] *= hfade;\n  const sfade = exp(-d / 0.06);\n  for (let i = 0; i \u003c 14; i++) S.scan[i] *= sfade;\n  for (let j = 0; j \u003c 6; j++) S.sheat[j] = S.e[4 + j] > 0 ? 1 : S.sheat[j] * exp(-d / 0.08);\n  S.flash *= exp(-d / 0.6);\n  // A flight takes 0.3 s at speed, up to 0.6 s when the steps come slower.\n  const dur = (S.dur = cl(2.2 / S.rate, 0.3, 0.6));\n  const live = [];\n  S.busy = [0, 0, 0, 0];\n  for (const f of S.flights) S.busy[f.j]++;\n  for (const f of S.flights) {\n    const u0 = f.u;\n    f.u = min(1, f.u + d / dur);\n    trace(S, f, u0, f.u);\n    if (f.u >= 1) {\n      if (f.y1 > f.y0) S.inc[f.j]--;\n    } else live.push(f);\n  }\n  S.flights = live;\n  if (S.end > 0) {\n    S.end -= d;\n    if (S.end \u003c= 0) reset(S);\n  } else if (S.pause > 0) S.pause -= d;\n  else {\n    S.acc += S.rate * d;\n    for (let guard = 0; S.acc >= 1 && guard \u003c 200; guard++) {\n      S.acc--;\n      step(S);\n      if (S.pause > 0 || S.end > 0) {\n        S.acc = 0;\n        break;\n      }\n    }\n  }\n  S.pitch += (min(5, (FLOOR - CEIL) / S.peak) - S.pitch) * (1 - exp(-d / 0.4));\n  for (let j = 0; j \u003c 4; j++) {\n    const c = shown(S, j);\n    S.ghost[j] = max(c, S.ghost[j] - d * (1 + 40 * (1 - S.trail) * (1 - S.trail)));\n  }\n}\n\n// The beads a column shows. Below 10 steps a second a given bead joins the\n// stack when its flight lands; faster than that a flight outlasts many\n// steps, so the stack shows the register as it is and the flights are the\n// traffic through it.\nconst shown = (S, j) => S.e[j] - (S.rate \u003c 10 ? S.inc[j] : 0);\n\n// Falling beads speed up, rising ones slow down, like a ball thrown up.\nconst fly = (f, u) => f.y0 + (f.y1 - f.y0) * (f.y1 > f.y0 ? u * u : u * (2 - u));\n\nfunction trace(S, f, u0, u1) {\n  const a = fly(f, u0), b = fly(f, u1), col = S.cols[f.j];\n  const lo = round(min(a, b)), hi = round(max(a, b)), x = COL_X[f.j];\n  for (let y = lo; y \u003c= hi; y++) {\n    if (y \u003c 0 || y >= H) continue;\n    const w = S.gain * min(1, 14 / S.busy[f.j]) * (0.12 + 0.33 * (f.y1 > f.y0 ? (y - lo + 1) / (hi - lo + 1) : (hi - y + 1) / (hi - lo + 1)));\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const o = (y * W + x + dx) * 3, ww = dx ? 0.5 * w : w;\n      S.glow[o] += col[0] * ww;\n      S.glow[o + 1] += col[1] * ww;\n      S.glow[o + 2] += col[2] * ww;\n    }\n  }\n}\n\nfunction put(S, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  S.rgb[o] += c[0] * a;\n  S.rgb[o + 1] += c[1] * a;\n  S.rgb[o + 2] += c[2] * a;\n}\n\nfunction text(S, s, x, y, c, a) {\n  for (let i = 0; i \u003c s.length; i++) {\n    const g = DIG[s.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"#\") put(S, x + 4 * i + q, y + r, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.e) return;\n  const h = S.hue, rgb = S.rgb;\n  const cols = S.cols, ink = hsv(0.58 + h, 0.45, 1), warm = hsv(0.1 + h, 0.5, 1);\n  rgb.fill(0);\n  // The record.\n  for (let i = 0; i \u003c S.found; i++) {\n    const [x, y] = recPlace[i], t = String(PRIMES[i]), lastOne = i === S.found - 1;\n    if (lastOne && S.flash > 0.02) for (let yy = y - 1; yy \u003c= y + 5; yy++) for (let xx = x - 1; xx \u003c= x + textW(t); xx++) put(S, xx, yy, cols[0], 0.35 * S.flash);\n    text(S, t, x, y, lastOne ? [1, 1, 1] : warm, lastOne ? 0.75 + 0.25 * S.flash : 0.6);\n  }\n  // The fractions.\n  for (let k = 0; k \u003c 14; k++) {\n    const x = frX(k), y = frY(k), hk = min(1, max(S.heat[k], k === S.last ? 0.55 : 0)), [a, b] = FR[k].map(String);\n    if (hk > 0.02) for (let yy = y - 1; yy \u003c= y + 13; yy++) for (let xx = floor(x - 4); xx \u003c= floor(x + 4); xx++) put(S, xx, yy, ink, 0.16 * hk);\n    const lv = 0.2 + 0.8 * hk;\n    text(S, a, round(x - textW(a) / 2), y, ink, lv);\n    for (let xx = round(x - 3.5); xx \u003c round(x + 3.5); xx++) put(S, xx, y + 6, ink, min(1, lv * 0.8 + 0.6 * S.scan[k]));\n    text(S, b, round(x - textW(b) / 2), y + 8, ink, lv);\n  }\n  // The state lamps.\n  for (let j = 0; j \u003c 6; j++) {\n    const on = S.e[4 + j] > 0;\n    text(S, String(PR[4 + j]), round(stX(j) - 3.5), ST_Y, on ? [1, 1, 1] : cols[4], on ? 0.95 : 0.22 + 0.5 * S.sheat[j]);\n  }\n  // The columns: a rod, the ghost of the last peak, and the beads.\n  const pitch = S.pitch, bh = max(0.8, pitch - 1.4);\n  for (let j = 0; j \u003c 4; j++) {\n    const c = cols[j], cx = COL_X[j], n = shown(S, j);\n    for (let y = CEIL; y \u003c= FLOOR; y++) put(S, cx, y, c, 0.12);\n    text(S, String(PR[j]), cx - 1, FLOOR + 2, c, 0.7);\n    const top = S.ghost[j];\n    for (let i = 0; i \u003c Math.ceil(top); i++) {\n      const lit = i \u003c n, yc = FLOOR - pitch * (i + 0.5), a = lit ? 1 : 0.45 * min(1, top - i);\n      const glow = j === 0 && S.flash > 0.02 && lit ? S.flash : 0;\n      for (let y = floor(yc - bh / 2 - 1); y \u003c= floor(yc + bh / 2 + 1); y++) {\n        const cov = cl(min(y + 1, yc + bh / 2) - max(y, yc - bh / 2), 0, 1);\n        if (cov \u003c= 0) continue;\n        for (let dx = -5; dx \u003c= 5; dx++) {\n          const u = dx / 5.6, shade = 0.3 + 0.7 * sqrt(1 - u * u) - 0.25 * (y + 0.5 - yc) / (bh / 2 + 0.5);\n          put(S, cx + dx, y, c, a * cov * cl(shade, 0, 1) * 0.85);\n          if (glow) put(S, cx + dx, y, [1, 1, 1], 0.5 * glow * cov);\n        }\n      }\n    }\n  }\n  // Beads in flight: a small bright bead at the head of each trail.\n  // A crowded column dims its heads, so fast traffic reads as a lit tube in\n  // the column's colour rather than as white.\n  const busy = [0, 0, 0, 0];\n  for (const f of S.flights) busy[f.j]++;\n  for (const f of S.flights) {\n    const y = fly(f, f.u), c = S.cols[f.j], a = min(1, 14 / busy[f.j]);\n    const core = [0.5 + 0.5 * c[0], 0.5 + 0.5 * c[1], 0.5 + 0.5 * c[2]];\n    for (let dy = 0; dy \u003c 2; dy++) for (let dx = -2; dx \u003c= 2; dx++) put(S, COL_X[f.j] + dx, round(y) + dy - 1, abs(dx) \u003c 2 ? core : c, a * (abs(dx) \u003c 2 ? 0.85 : 0.5));\n  }\n  // The trails keep their colour: a pixel's glow is held under 0.7 of full,\n  // hue kept, so heavy traffic makes a coloured tube and not a white one.\n  for (let p = 0; p \u003c NP * 3; p += 3) {\n    const g = S.glow, m = max(g[p], g[p + 1], g[p + 2]), q = m > 0.7 ? 0.7 / m : 1;\n    rgb[p] += g[p] * q;\n    rgb[p + 1] += g[p + 1] * q;\n    rgb[p + 2] += g[p + 2] * q;\n  }\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3;\n    display.setPixel(p % W, floor(p / W), min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n  }\n}\n","kruskal-count":"// ===== Patternflow pattern =====\n// Title:   Kruskal Count\n// Family:  line\n// Idea:    A shuffled deck is laid down the panel in a snake of rows, a chain of its own colour starts on each of the first ten cards and a reading head sweeps the deck from top to bottom, so every chain it passes hops forward by the value of its card, chains that land on the same card merge and pale together, and at the bottom the card where they end is turned up large before the deck is shuffled again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Kruskal count (Martin Kruskal, 1970s), as Martin Gardner gave it in Mathematical Games (Scientific American, 1978), analysed by Jeffrey Lagarias, Eric Rains and Robert Vanderbei (The Kruskal Count, 2001), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Court=5..10, Decks=1..2\n//\n// Knob 1: Hue. Turns the ten chain colours round the wheel together; at 0 the first card's chain is cyan and the rest follow in steps of a tenth of the wheel.\n// Knob 2: Speed. At 2 the head reads 10.4 cards a second (20.8 with two decks), so a deal takes 5 s, the turned-up card stays 2.2 s and the shuffle 0.8 s: a new deal every 8 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Court. What a jack, queen or king counts, from 5 as in Gardner's telling to 10 as in blackjack; with one deck a court card shows its count where the suit would be. The mean jump grows from 5.4 to 6.5 cards and fewer chains meet: with one deck all ten merge in 58% of deals at 5 and 28% at 10.\n// Knob 4: Decks. One deck of 52 cards in 13 rows of 4 with suits, or from 1.5 two decks of 104 in 13 rows of 8 with the suit shown only by the colour of the rank. All ten chains merge in 94% of two-deck deals at Court 5. Turning it deals again.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, PI, sin, cos } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Card faces. Ranks in a 3 by 5 font, one number a row with the high\n// bit on the left: A, 2 to 9, J, Q, K. Ten is a one-column 1 and a 0 (the\n// table below), so \"10\" fits in 5 columns.\nconst RANK = [\n  [2, 5, 7, 5, 5], [6, 1, 2, 4, 7], [6, 1, 2, 1, 6], [5, 5, 7, 1, 1], [7, 4, 6, 1, 6], [3, 4, 6, 5, 2], [7, 1, 2, 2, 2], [2, 5, 2, 5, 2], [2, 5, 3, 1, 6],\n  null, [1, 1, 1, 5, 2], [2, 5, 5, 6, 3], [5, 6, 4, 6, 5],\n];\nconst ZERO = [2, 5, 5, 5, 2];\n// Suits on 5 by 5: spades, hearts, diamonds, clubs.\nconst SUIT = [\n  [4, 14, 31, 31, 4],\n  [10, 31, 31, 14, 4],\n  [4, 14, 31, 14, 4],\n  [14, 14, 31, 21, 4],\n];\nconst RED = [false, true, true, false];\n\n// A rank's glyphs as [bits, width, dx]: 10 is a narrow 1 and a 0.\nconst GLYPHS = [null];\nfor (let r = 1; r \u003c= 13; r++) GLYPHS.push(r === 10 ? [[[1, 1, 1, 1, 1], 1, 0], [ZERO, 3, 2]] : [[RANK[r - 1], 3, 0]]);\n\nconst valueOf = (r, court) => (r > 10 ? court : r);\n\n// ---- The deal and the sweep. A chain is a token on a card. The head reads\n// the cards in order; when it reaches a token the token jumps forward by\n// that card's value, and if a token already waits where it lands the two\n// become one. Every token is always ahead of the head, so a chain can only\n// meet another on a card the other has not left yet. A token whose jump\n// would leave the deck stays: its card is that chain's last card. Counted\n// in Node with this code over 100000 deals, every chain's last card the\n// same as walking it alone: with one deck and Court 5 all ten chains end\n// on one card in 58.5% of deals, and the trick itself, the magician's\n// chain from the first card against yours from a card you pick among the\n// first ten, works in 85.4%. At Court 10 it is 28.4% and 72.2%; with two\n// decks at Court 5, 93.8% and 97.9%.\nconst CHAINS = 10;\nconst DEAL = 5.0, SHOW = 2.2, SHUFFLE = 0.8;\n\nfunction deal(S) {\n  const n = 52 * S.decks, cards = [];\n  for (let k = 0; k \u003c S.decks; k++) for (let s = 0; s \u003c 4; s++) for (let r = 1; r \u003c= 13; r++) cards.push({ r, s });\n  for (let i = n - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = cards[i];\n    cards[i] = cards[j];\n    cards[j] = t;\n  }\n  S.n = n;\n  S.cards = cards;\n  S.cols = S.decks === 1 ? 4 : 8;\n  // The token on each card, and the chains that have stood on it (null for\n  // a card no chain has reached).\n  S.tok = new Array(n).fill(null);\n  S.trail = new Array(n).fill(null);\n  for (let i = 0; i \u003c CHAINS; i++) {\n    S.tok[i] = { members: [i], id: i };\n    S.trail[i] = S.tok[i].members.slice();\n  }\n  S.arcs = [];\n  S.flights = [];\n  S.bursts = [];\n  S.head = -1;\n  S.phase = 0;\n  S.t = 0;\n  S.final = null;\n}\n\n// Where a card sits: a snake of 13 rows, left to right then right to left.\nfunction place(C, i) {\n  const row = floor(i / C), q = i % C, col = row % 2 ? C - 1 - q : q;\n  const cw = W / C, ch = H / 13, fw = cw - 2;\n  const x = col * cw + 1, y = round(row * ch + (ch - 7) / 2);\n  return { x, y, w: fw, cx: x + fw / 2 - 0.5, cy: y + 3 };\n}\nconst PLACES = { 4: [], 8: [] };\nfor (let i = 0; i \u003c 52; i++) PLACES[4].push(place(4, i));\nfor (let i = 0; i \u003c 104; i++) PLACES[8].push(place(8, i));\nconst cell = (S, i) => PLACES[S.cols][i];\n\n// A hop's path: a quadratic curve from card centre to card centre, bowed\n// up (or to the right for a straight drop) by 0.3 of its length.\nfunction bez(a, b, u) {\n  const dx = b.cx - a.cx, dy = b.cy - a.cy, L = sqrt(dx * dx + dy * dy) || 1;\n  let px = dy / L, py = -dx / L;\n  if (py > 0) ((px = -px), (py = -py));\n  const k = 0.3 * L, mx = (a.cx + b.cx) / 2 + px * k, my = (a.cy + b.cy) / 2 + py * k, v = 1 - u;\n  return [v * v * a.cx + 2 * v * u * mx + u * u * b.cx, v * v * a.cy + 2 * v * u * my + u * u * b.cy, L];\n}\n// Its LEDs in order, each once.\nfunction arcPixels(a, b) {\n  const L = bez(a, b, 0)[2], steps = Math.ceil(L * 1.6) + 2, out = [];\n  let last = -1;\n  for (let s = 0; s \u003c= steps; s++) {\n    const [x, y] = bez(a, b, s / steps), xi = round(x), yi = round(y);\n    if (xi \u003c 0 || yi \u003c 0 || xi >= W || yi >= H) continue;\n    const q = yi * W + xi;\n    if (q !== last) (out.push(q), (last = q));\n  }\n  return out;\n}\n\nfunction step(S) {\n  const h = ++S.head;\n  if (h >= S.n) return;\n  const tk = S.tok[h];\n  if (!tk) return;\n  const t = h + valueOf(S.cards[h].r, S.court);\n  if (t >= S.n) return;\n  S.tok[h] = null;\n  const dur = min(0.4, valueOf(S.cards[h].r, S.court) * S.dt0 * 0.9);\n  const flight = { from: h, to: t, members: tk.members.slice(), age: 0, dur };\n  S.flights.push(flight);\n  S.arcs.push({ members: flight.members, pts: arcPixels(cell(S, h), cell(S, t)), flight });\n  const there = S.tok[t];\n  if (there) {\n    there.members = there.members.concat(tk.members).sort((a, b) => a - b);\n    S.bursts.push({ at: t, age: -dur, members: there.members.slice() });\n  } else S.tok[t] = { members: tk.members.slice(), id: tk.id };\n  S.trail[t] = S.tok[t].members.slice();\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, court: 5, decks: 1, dt0: DEAL / 52, rgb: new Float32Array(NP * 3) };\n  deal(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.court = cl(round(k[2]), 5, 10);\n  const decks = cl(k[3], 1, 2) >= 1.5 ? 2 : 1;\n  if (decks !== S.decks) ((S.decks = decks), deal(S));\n  S.dt0 = DEAL / S.n;\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  for (const f of S.flights) f.age += g;\n  for (const b of S.bursts) b.age += g;\n  S.flights = S.flights.filter((f) => f.age \u003c f.dur);\n  S.bursts = S.bursts.filter((b) => b.age \u003c 0.6);\n  if (S.phase === 0) {\n    while (S.t >= S.dt0 && S.head \u003c S.n - 1) {\n      S.t -= S.dt0;\n      step(S);\n    }\n    if (S.head >= S.n - 1 && !S.flights.length) {\n      // Where the chains ended, the card holding most of them first.\n      const ends = [];\n      for (let i = 0; i \u003c S.n; i++) if (S.tok[i]) ends.push({ at: i, members: S.tok[i].members });\n      ends.sort((a, b) => b.members.length - a.members.length || a.at - b.at);\n      S.final = ends;\n      S.phase = 1;\n      S.t = 0;\n    }\n  } else if (S.phase === 1 && S.t >= SHOW) ((S.phase = 2), (S.t = 0));\n  else if (S.phase === 2 && S.t >= SHUFFLE) deal(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0.004) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a);\n    rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n    rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n  const set = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = c[0] * a;\n    rgb[o + 1] = c[1] * a;\n    rgb[o + 2] = c[2] * a;\n  };\n  const bits = (rows, w, x, y, c, a, sc, plot) => {\n    for (let r = 0; r \u003c rows.length; r++)\n      for (let i = 0; i \u003c w; i++)\n        if ((rows[r] >> (w - 1 - i)) & 1) for (let v = 0; v \u003c sc; v++) for (let u = 0; u \u003c sc; u++) plot(x + i * sc + u, y + r * sc + v, c, a);\n  };\n\n  const chainCol = [];\n  for (let i = 0; i \u003c CHAINS; i++) chainCol.push(hsv(S.hue + 0.5 + i / CHAINS, 0.85, 1));\n  // A group's colour: its members' mean, paled towards white as it grows.\n  const memo = new Map();\n  const groupCol = (m) => {\n    const key = m.key || (m.key = m.join(\",\"));\n    if (memo.has(key)) return memo.get(key);\n    const c = [0, 0, 0];\n    for (const i of m) for (let q = 0; q \u003c 3; q++) c[q] += chainCol[i][q] / m.length;\n    const top = max(c[0], c[1], c[2], 1e-3), w = (m.length - 1) / (CHAINS - 1);\n    const out = c.map((v) => (v / top) * (1 - w * 0.75) + w * 0.75);\n    memo.set(key, out);\n    return out;\n  };\n  const ivory = [1, 0.93, 0.8], dim = S.phase === 1 ? 1 - 0.55 * ease(S.t / 0.4) : 1;\n  const fade = S.phase === 2 ? 1 - ease(S.t / SHUFFLE) : 1;\n  const redC = hsv(0.98, 0.6, 0.95), blackC = hsv(0.6, 0.18, 0.8);\n\n  // ---- Cards.\n  for (let i = 0; i \u003c S.n; i++) {\n    const p = cell(S, i), card = S.cards[i];\n    const tk = S.tok[i], tr = S.trail[i];\n    let face = ivory, fa = 0.13, ink = 0.8, dark = false;\n    if (tr && fade > 0) {\n      face = groupCol(tr);\n      fa = 0.13 + (0.55 - 0.13) * fade;\n      if (tk) ((fa = 0.13 + (0.85 - 0.13) * fade), (dark = fade > 0.5));\n    }\n    const f0 = face[0] * fa * dim, f1 = face[1] * fa * dim, f2 = face[2] * fa * dim;\n    for (let y = 0; y \u003c 7; y++)\n      for (let x = y === 0 || y === 6 ? 1 : 0, x1 = y === 0 || y === 6 ? p.w - 1 : p.w; x \u003c x1; x++) {\n        const o = ((p.y + y) * W + p.x + x) * 3;\n        (rgb[o] = f0), (rgb[o + 1] = f1), (rgb[o + 2] = f2);\n      }\n    // While shuffling the faces flicker through other ranks.\n    const r = S.phase === 2 && Math.random() \u003c 0.5 ? 1 + floor(Math.random() * 13) : card.r;\n    const inkC = dark ? [0, 0, 0] : S.cols === 8 && RED[card.s] ? redC : ivory;\n    const gl = GLYPHS[r], wide = r === 10 ? 5 : 3;\n    const rx = S.cols === 4 ? p.x + 2 : p.x + floor((p.w - wide) / 2);\n    for (const [rows, w, dx] of gl) bits(rows, w, rx + dx, p.y + 1, inkC, dark ? 1 : ink * dim, 1, dark ? set : put);\n    if (S.cols === 4) {\n      // Beside the rank the suit, or on a court card what it counts, in the\n      // suit's colour.\n      const sc = dark ? [0, 0, 0] : RED[card.s] ? redC : blackC, sa = dark ? 1 : 0.85 * dim, plot = dark ? set : put;\n      if (card.r \u003c= 10) bits(SUIT[card.s], 5, p.x + 8, p.y + 1, sc, sa, 1, plot);\n      else if (S.court === 10) for (const [rows, w, dx] of GLYPHS[10]) bits(rows, w, p.x + 7 + dx, p.y + 1, sc, sa, 1, plot);\n      else bits(RANK[S.court - 1], 3, p.x + 9, p.y + 1, sc, sa, 1, plot);\n    }\n  }\n\n  // ---- The hops so far, thin arcs that bow up, and the head.\n  const arcA = 0.7 * fade * dim;\n  for (const arc of S.arcs) {\n    const c = groupCol(arc.members), f = arc.flight, pts = arc.pts;\n    const upto = f.age \u003c f.dur ? round(ease(f.age / f.dur) * pts.length) : pts.length;\n    for (let s = 0; s \u003c upto; s++) {\n      const o = pts[s] * 3;\n      rgb[o] = max(rgb[o], c[0] * arcA);\n      rgb[o + 1] = max(rgb[o + 1], c[1] * arcA);\n      rgb[o + 2] = max(rgb[o + 2], c[2] * arcA);\n    }\n  }\n  for (const f of S.flights) {\n    const a = cell(S, f.from), b = cell(S, f.to), c = groupCol(f.members), u = ease(f.age / f.dur);\n    for (let tail = 0; tail \u003c 5; tail++) {\n      const [x, y] = bez(a, b, max(0, u - tail * 0.05));\n      const xi = round(x - 0.5), yi = round(y - 0.5), al = tail ? 0.6 - tail * 0.1 : 1;\n      put(xi, yi, c, al), put(xi + 1, yi, c, al), put(xi, yi + 1, c, al), put(xi + 1, yi + 1, c, al);\n    }\n  }\n  if (S.phase === 0 && S.head >= 0 && S.head \u003c S.n) {\n    const p = cell(S, S.head);\n    for (let x = -1; x \u003c= p.w; x++) (put(p.x + x, p.y - 1, ivory, 0.6), put(p.x + x, p.y + 7, ivory, 0.6));\n    for (let y = 0; y \u003c 7; y++) (put(p.x - 1, p.y + y, ivory, 0.6), put(p.x + p.w, p.y + y, ivory, 0.6));\n  }\n  // Two chains meeting: a ring opens round the card.\n  for (const b of S.bursts) {\n    if (b.age \u003c 0) continue;\n    const p = cell(S, b.at), c = groupCol(b.members), R = 2 + b.age * 22, a = 1 - b.age / 0.6;\n    for (let s = 0; s \u003c 48; s++) put(round(p.cx + R * cos((s / 48) * 2 * PI)), round(p.cy + R * 0.8 * sin((s / 48) * 2 * PI)), c, a);\n  }\n\n  // ---- The card the chains came to, turned up large: rank and suit, and a\n  // dot for each of the ten chains, lit in its colour if it ended here.\n  if (S.phase >= 1 && S.final && S.final.length) {\n    const top = S.final[0], card = S.cards[top.at], c = groupCol(top.members);\n    const grow = S.phase === 1 ? ease(S.t / 0.35) : 1 - ease(S.t / 0.4);\n    const cw = round(36 * grow), chh = round(52 * grow), x0 = 32 - (cw >> 1), y0 = 64 - (chh >> 1);\n    // The ends themselves pulse on the deck.\n    for (const e of S.final) {\n      const p = cell(S, e.at), ec = groupCol(e.members), a = 0.5 + 0.5 * sin(S.t * 9);\n      for (let x = -1; x \u003c= p.w; x++) (put(p.x + x, p.y - 1, ec, a), put(p.x + x, p.y + 7, ec, a));\n      for (let y = 0; y \u003c 7; y++) (put(p.x - 1, p.y + y, ec, a), put(p.x + p.w, p.y + y, ec, a));\n    }\n    if (cw > 4 && chh > 4) {\n      for (let y = 0; y \u003c chh; y++)\n        for (let x = 0; x \u003c cw; x++) {\n          const edge = x === 0 || y === 0 || x === cw - 1 || y === chh - 1;\n          if ((x === 0 || x === cw - 1) && (y === 0 || y === chh - 1)) continue;\n          set(x0 + x, y0 + y, edge ? c : ivory, edge ? 1 : 0.16);\n        }\n      if (grow > 0.95) {\n        const r = card.r, wide = r === 10 ? 5 : 3, ink = RED[card.s] ? redC : ivory;\n        for (const [rows, w, dx] of GLYPHS[r]) bits(rows, w, x0 + ((cw - wide * 4) >> 1) + dx * 4, y0 + 4, ink, 1, 4, set);\n        bits(SUIT[card.s], 5, x0 + ((cw - 15) >> 1), y0 + 27, RED[card.s] ? redC : blackC, 1, 3, set);\n        for (let i = 0; i \u003c CHAINS; i++) {\n          const on = top.members.includes(i), dx = x0 + 4 + (i % 5) * 6, dy = y0 + chh - 8 + floor(i / 5) * 3;\n          for (let v = 0; v \u003c 2; v++) for (let u = 0; u \u003c 4; u++) set(dx + u, dy + v, on ? chainCol[i] : ivory, on ? 1 : 0.12);\n        }\n      }\n    }\n  }\n\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","letter-mobile":"// ===== Patternflow pattern =====\n// Title:   Letter Mobile\n// Family:  type\n// Idea:    A hanging mobile in the manner of Calder whose weights are the four letters of a word, each weighing its ink, hangs the full height of the panel with every bar balanced by moments and turning slowly on its thread before a lit wall that takes its shadow, and when one letter changes, as in a word ladder, every bar above it tips and its hanging point slides to the new balance.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Alexander Calder's first mobiles (1931-32, named by Marcel Duchamp), the law of the lever (Archimedes, On the Equilibrium of Planes, 3rd century BC), word ladders (Lewis Carroll's Doublets, 1879), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..2, Sway=0..1\n//\n// Knob 1: Hue. Turns the painted plates round the wheel together: at 0 they are Calder's yellow, blue, red and white, top to bottom. The wires stay steel; the wall is a grey that turns with the plates, blue-grey at 0.\n// Knob 2: Speed. One clock for the turning, the swing and the word: at 2 one letter changes every 3.6 s, the bars turn round on their threads once in 30 to 44 s while a draft rocks each to and fro every 7 to 11 s, and the mobile swings once in 3.3 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. Which word ladder the mobile climbs, one letter at a time and back down: 0 is Carroll's own first, HEAD HEAL TEAL TELL TALL TAIL, from 752 LEDs of ink to 501; 1 is FILL FILM FIRM FORM WORM WARM, light letters turning heavy, 467 to 860; 2 is WOMB TOMB TOME TIME TILE TILL, heavy turning light, 905 to 448.\n// Knob 4: Sway. How far the whole mobile swings from its hook: at 0.06 the bottom letters move 2.5 LEDs either way, at 1 they move 23.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, round, min, max, sqrt, sin, cos, abs, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters. Skeletons in a box one cap height tall (y down), width w,\n// drawn with a round pen 4 LEDs wide into plates 22 LEDs tall. Straight\n// strokes snap to LED edges so stems come out exactly 4 wide; curves don't.\n// A letter weighs its ink, the LEDs its plate lights facing you:\n// I 84, L 119, T 126, F 145, A 172, E 180, H 196, O 198, D 204, R 206,\n// B 225, W 240, M 242.\nfunction arc(cx, cy, rx, ry, a0, a1, n) {\n  const s = [];\n  for (let i = 0; i \u003c n; i++) {\n    const t0 = a0 + ((a1 - a0) * i) / n, t1 = a0 + ((a1 - a0) * (i + 1)) / n;\n    s.push([cx + rx * cos(t0), cy + ry * sin(t0), cx + rx * cos(t1), cy + ry * sin(t1), 1]);\n  }\n  return s;\n}\nconst HP = PI / 2;\nconst SK = {\n  A: [0.72, [[0, 1, 0.36, 0], [0.36, 0, 0.72, 1], [0.13, 0.64, 0.59, 0.64]]],\n  B: [0.56, [[0, 0, 0, 1], [0, 0, 0.3, 0], ...arc(0.3, 0.235, 0.22, 0.235, -HP, HP, 6), [0.3, 0.47, 0, 0.47], [0, 0.47, 0.32, 0.47], ...arc(0.32, 0.735, 0.24, 0.265, -HP, HP, 6), [0.32, 1, 0, 1]]],\n  D: [0.62, [[0, 0, 0, 1], [0, 0, 0.22, 0], ...arc(0.22, 0.5, 0.4, 0.5, -HP, HP, 10), [0.22, 1, 0, 1]]],\n  E: [0.52, [[0, 0, 0, 1], [0, 0, 0.52, 0], [0, 0.5, 0.44, 0.5], [0, 1, 0.52, 1]]],\n  F: [0.52, [[0, 0, 0, 1], [0, 0, 0.52, 0], [0, 0.5, 0.44, 0.5]]],\n  H: [0.62, [[0, 0, 0, 1], [0.62, 0, 0.62, 1], [0, 0.5, 0.62, 0.5]]],\n  I: [0, [[0, 0, 0, 1]]],\n  L: [0.5, [[0, 0, 0, 1], [0, 1, 0.5, 1]]],\n  M: [0.82, [[0, 1, 0, 0], [0, 0, 0.41, 0.66], [0.41, 0.66, 0.82, 0], [0.82, 0, 0.82, 1]]],\n  O: [0.72, arc(0.36, 0.5, 0.36, 0.5, 0, 2 * PI, 16)],\n  R: [0.58, [[0, 0, 0, 1], [0, 0, 0.3, 0], ...arc(0.3, 0.25, 0.24, 0.25, -HP, HP, 6), [0.3, 0.5, 0, 0.5], [0.26, 0.5, 0.58, 1]]],\n  T: [0.66, [[0, 0, 0.66, 0], [0.33, 0, 0.33, 1]]],\n  W: [0.94, [[0, 0, 0.21, 1], [0.21, 1, 0.47, 0.32], [0.47, 0.32, 0.73, 1], [0.73, 1, 0.94, 0]]],\n};\nconst GH = 22, PEN = 2, SC = GH - 2 * PEN;\n\nfunction glyph(ch) {\n  const [w, segs] = SK[ch], bw = ceil(w * SC + 2 * PEN) + 1, bits = new Uint8Array(bw * GH);\n  let x0 = bw, x1 = -1;\n  for (let j = 0; j \u003c GH; j++)\n    for (let i = 0; i \u003c bw; i++) {\n      const px = i + 0.5, py = j + 0.5;\n      let on = 0;\n      for (const [sx, sy, ex, ey, curved] of segs) {\n        const sn = (v) => (curved ? PEN + v * SC : floor(PEN + v * SC));\n        const ax = sn(sx), ay = sn(sy), dx = sn(ex) - ax, dy = sn(ey) - ay, l2 = dx * dx + dy * dy;\n        const t = l2 ? cl(((px - ax) * dx + (py - ay) * dy) / l2, 0, 1) : 0;\n        const qx = ax + t * dx - px, qy = ay + t * dy - py;\n        if (qx * qx + qy * qy \u003c= (PEN + 0.01) * (PEN + 0.01)) {\n          on = 1;\n          break;\n        }\n      }\n      if (on) (bits[j * bw + i] = 1), (x0 = min(x0, i)), (x1 = max(x1, i));\n    }\n  // Trimmed to the ink, with a running sum per row for area sampling.\n  const gw = x1 - x0 + 1, g = new Uint8Array(gw * GH), cum = new Float32Array((gw + 1) * GH);\n  let ink = 0;\n  for (let j = 0; j \u003c GH; j++)\n    for (let i = 0; i \u003c gw; i++) {\n      const b = bits[j * bw + i + x0];\n      g[j * gw + i] = b;\n      ink += b;\n      cum[j * (gw + 1) + i + 1] = cum[j * (gw + 1) + i] + b;\n    }\n  return { ch, gw, g, cum, ink };\n}\nconst GLYPHS = {};\nconst glyphOf = (ch) => GLYPHS[ch] || (GLYPHS[ch] = glyph(ch));\n\n// ---- Word ladders: one letter changes at a time, each step a word.\nconst LADDERS = [\n  [\"HEAD\", \"HEAL\", \"TEAL\", \"TELL\", \"TALL\", \"TAIL\"],\n  [\"FILL\", \"FILM\", \"FIRM\", \"FORM\", \"WORM\", \"WARM\"],\n  [\"WOMB\", \"TOMB\", \"TOME\", \"TIME\", \"TILE\", \"TILL\"],\n];\n\n// ---- The mobile. Three bars in a chain, as Calder hung most of his: bar 0\n// carries letter 0 on its left end and everything below on its right, bar 1\n// carries that rest on its left and letter 1 on its right, bar 2 carries\n// letters 2 and 3. Facing you the chain zigzags so the word reads down the\n// panel. Each bar hangs from a loop D LEDs above it.\n// Bar k: length and the thread below each end. The top bar's hook hangs on\n// a thread 10 rows long from the top edge at x 31.\nconst BAR = [\n  { len: 28, drop: [3, 28] },\n  { len: 26, drop: [28, 3] },\n  { len: 32, drop: [10, 10] },\n];\nconst HOOK = [31, 10], D = 7;\n\n// Weights on each end of bar k, given the four letters' ink. A sub-mobile\n// weighs the sum of what hangs below it; wire and thread weigh nothing.\nfunction loads(ink) {\n  const w2 = ink[2] + ink[3], w1 = ink[1] + w2;\n  return [[ink[0], w1], [w1, ink[1]], [ink[2], ink[3]]];\n}\n\n// The law of the lever: the hook divides the bar so that left weight times\n// left arm equals right weight times right arm, so it sits at the fraction\n// WR / (WL + WR) of the bar from the left end.\n// Checked in Node over all three ladders, 21 words at rest just before the\n// next change: every bar's net moment is under 1e-12 (LEDs of ink times\n// LEDs of arm) and its tilt under 1.8 degrees. HEAD weighs H 196, E 180,\n// A 172, D 204; its top bar hangs 20.70 LEDs from the H and 7.30 from the\n// 556 below (196 x 20.70 = 556 x 7.30), its bottom bar 17.36 from the A and\n// 14.64 from the D.\nconst balance = ([wl, wr]) => wr / (wl + wr);\n\n// Turning: each bar turns round on its thread at its own rate, the bottom\n// one fastest, and a draft rocks it back and forth on top of that. Per bar:\n// angle at the start, seconds a turn at Speed 2 (signed), the draft's swing\n// and its period.\nconst TURN = [[-0.3, 44, 0.35, 9], [0.35, -36, 0.35, 7], [-0.6, 30, 0.35, 11]];\n\n// Lamp up and to the left in front of the mobile, the wall 26 LEDs behind\n// the threads.\nconst LX = -80, LY = -120, LZ = 300, WZ = -26;\n// A word holds 3.6 s at Speed 2; a changing letter spins round in 0.7 s and\n// swaps when it has turned a quarter (ss(0.3264) = 0.25); the hooks start to\n// slide 0.3 s after the swap and take 1.4 s.\nconst STEP = 3.6, FLIP = 0.7, SWAP = 0.3264, SLIDE_AT = 0.3, SLIDE = 1.4;\n\nfunction startWord(S, ladder) {\n  S.ladder = ladder;\n  S.step = 0;\n  S.dir = 1;\n  const word = LADDERS[ladder][0];\n  S.letters = [0, 1, 2, 3].map((i) => ({ g: glyphOf(word[i]), next: null, flip: -1 }));\n  const L = loads(S.letters.map((l) => l.g.ink));\n  S.bars = BAR.map((b, k) => ({ f: balance(L[k]), f0: 0, slide: -1, a: 0, av: 0 }));\n  S.clock = STEP - 2.1;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, sway: 0.06, ladder: -1, fb: new Float32Array(NP * 3), sh: new Float32Array(NP), tmp: new Float32Array(NP), wall: null };\n}\n\nfunction ink(S) {\n  return S.letters.map((l) => l.g.ink);\n}\n\nfunction nextWord(S) {\n  const lad = LADDERS[S.ladder];\n  if (S.step + S.dir \u003c 0 || S.step + S.dir >= lad.length) S.dir = -S.dir;\n  const from = lad[S.step], to = lad[S.step + S.dir];\n  S.step += S.dir;\n  for (let i = 0; i \u003c 4; i++)\n    if (from[i] !== to[i]) {\n      S.letters[i].next = glyphOf(to[i]);\n      S.letters[i].flip = 0;\n    }\n}\n\n// The bar's tilt a about its hook. With the hook D above the bar, the weights\n// hanging from the ends at arms aL, aR turn it by\n//   (WR aR - WL aL) cos a - (WL + WR) D sin a,\n// so a bar out of balance by a moment M settles at tan a = M / (W D), and a\n// balanced bar hangs level.\nfunction torque(b, len, [wl, wr]) {\n  const al = b.f * len, ar = (1 - b.f) * len;\n  return { tq: (wr * ar - wl * al) * cos(b.a) - (wl + wr) * D * sin(b.a), I: wl * (al * al + D * D) + wr * (ar * ar + D * D) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.sway = cl(k[3], 0, 1);\n  const ladder = cl(round(k[2]), 0, 2);\n  if (ladder !== S.ladder) startWord(S, ladder);\n  const step = (d * cl(k[1], 0.2, 3)) / 2;\n  S.t += step;\n  S.clock += step;\n  if (S.clock >= STEP) {\n    S.clock -= STEP;\n    nextWord(S);\n  }\n  // A letter that changes spins once round on its thread and comes back as\n  // the new letter; its weight changes a quarter turn in.\n  let changed = false;\n  for (const l of S.letters) {\n    if (l.flip \u003c 0) continue;\n    const was = l.flip;\n    l.flip += step / FLIP;\n    if (was \u003c SWAP && l.flip >= SWAP && l.next) {\n      l.g = l.next;\n      l.next = null;\n      changed = true;\n    }\n    if (l.flip >= 1) l.flip = -1;\n  }\n  const L = loads(ink(S));\n  // Only the bars whose balance moved: the changed letter's and those above.\n  if (changed) S.bars.forEach((b, i) => abs(balance(L[i]) - b.f) > 1e-9 && (b.slide = 0));\n  // The hooks slide to the new balance once the bars have tipped.\n  S.bars.forEach((b, i) => {\n    if (b.slide \u003c 0) return;\n    if (b.slide \u003c SLIDE_AT && b.slide + step >= SLIDE_AT) b.f0 = b.f;\n    b.slide += step;\n    if (b.slide >= SLIDE_AT) {\n      const u = ss((b.slide - SLIDE_AT) / SLIDE);\n      b.f = b.f0 + (balance(L[i]) - b.f0) * u;\n      if (u >= 1) b.slide = -1;\n    }\n  });\n  // Tilts, in four substeps. G and DAMP set the swing: when HEAD turns to\n  // HEAL the bottom bar tips to 35 degrees in 0.9 s, swings back past level\n  // to 6 degrees 1.3 s later and is within 1.5 degrees a second after that.\n  const G = 400, DAMP = 2.6, n = 4, h = step / n;\n  for (let s = 0; s \u003c n; s++)\n    S.bars.forEach((b, i) => {\n      const { tq, I } = torque(b, BAR[i].len, L[i]);\n      b.av += (G * tq / I - DAMP * b.av) * h;\n      b.a += b.av * h;\n      if (abs(b.a) > 0.75) (b.a = 0.75 * Math.sign(b.a)), (b.av = 0);\n    });\n}\n\n// ---- Geometry: points in LEDs, x right, y down, z towards you.\nfunction layout(S) {\n  const t = S.t, phi = (0.012 + 0.2 * S.sway) * sin((2 * PI * t) / 3.3);\n  // The whole mobile swings about the top of its thread.\n  const sw = (p) => [HOOK[0] + (p[0] - HOOK[0]) * cos(phi) - p[1] * sin(phi), (p[0] - HOOK[0]) * sin(phi) + p[1] * cos(phi), p[2]];\n  const lines = [], plates = [];\n  let piv = [HOOK[0], HOOK[1], 0];\n  lines.push({ p: [HOOK[0], -1, 0], q: piv, c: 0, glint: 0 });\n  for (let k = 0; k \u003c 3; k++) {\n    const B = BAR[k], b = S.bars[k], [th0, per, amp, dp] = TURN[k];\n    const th = th0 + (2 * PI * t) / per + amp * sin((2 * PI * t) / dp), ex = cos(th), ez = sin(th), ca = cos(b.a), sa = sin(b.a);\n    const bx = ca * ex, by = sa, bz = ca * ez;\n    // Hook, then the bar's own point under it, then the ends.\n    const hp = [piv[0] - sa * ex * D, piv[1] + ca * D, piv[2] - sa * ez * D];\n    const al = b.f * B.len, ar = (1 - b.f) * B.len;\n    const le = [hp[0] - bx * al, hp[1] - by * al, hp[2] - bz * al], re = [hp[0] + bx * ar, hp[1] + by * ar, hp[2] + bz * ar];\n    // The hook glints while it slides along the bar.\n    const sl = b.slide >= SLIDE_AT ? sin(PI * cl((b.slide - SLIDE_AT) / SLIDE, 0, 1)) : 0;\n    lines.push({ p: piv, q: hp, c: 1, glint: sl }, { p: le, q: re, c: 1, glint: 0 });\n    const ends = [le, re];\n    for (let side = 0; side \u003c 2; side++) {\n      const e = ends[side], drop = B.drop[side], lo = [e[0], e[1] + drop, e[2]];\n      lines.push({ p: e, q: lo, c: 0, glint: 0 });\n      const li = k === 0 ? (side === 0 ? 0 : -1) : k === 1 ? (side === 1 ? 1 : -1) : 2 + side;\n      if (li \u003c 0) piv = lo;\n      else {\n        const l = S.letters[li], fl = l.flip >= 0 ? 2 * PI * ss(l.flip) : 0;\n        plates.push({ top: lo, th: th + fl, l, pos: li });\n      }\n    }\n  }\n  for (const L of lines) (L.p = sw(L.p)), (L.q = sw(L.q));\n  for (const P of plates) P.top = sw(P.top);\n  return { lines, plates };\n}\n\n// Where a point lands on the wall, seen from the lamp.\nfunction onWall(p) {\n  const s = (WZ - LZ) / (p[2] - LZ);\n  return [LX + s * (p[0] - LX), LY + s * (p[1] - LY)];\n}\n\n// A line laid down as samples a third of an LED apart, each shared among the\n// four LEDs round it.\nfunction put(buf, X, Y, v) {\n  if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) buf[Y * W + X] += v;\n}\nfunction splatLine(buf, x0, y0, x1, y1, a) {\n  const n = max(2, ceil(sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) * 3)), w = a / 3;\n  for (let i = 0; i \u003c= n; i++) {\n    const x = x0 + ((x1 - x0) * i) / n - 0.5, y = y0 + ((y1 - y0) * i) / n - 0.5, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    put(buf, ix, iy, w * (1 - fx) * (1 - fy));\n    put(buf, ix + 1, iy, w * fx * (1 - fy));\n    put(buf, ix, iy + 1, w * (1 - fx) * fy);\n    put(buf, ix + 1, iy + 1, w * fx * fy);\n  }\n}\n\n// Ink in glyph row j left of column u.\nfunction inkTo(g, j, u) {\n  if (u \u003c= 0) return 0;\n  const gw = g.gw;\n  if (u >= gw) return g.cum[j * (gw + 1) + gw];\n  const i = floor(u);\n  return g.cum[j * (gw + 1) + i] + (u - i) * g.g[j * gw + i];\n}\n\n// Shadows: every plate, wire and thread, cast by the lamp on the wall.\nfunction castShadows(sh, lines, plates) {\n  sh.fill(0);\n  for (const L of lines) {\n    const a = onWall(L.p), b = onWall(L.q);\n    splatLine(sh, a[0], a[1], b[0], b[1], 0.9);\n  }\n  for (const P of plates) {\n    const g = P.l.g, gw = g.gw, ex = cos(P.th), ez = sin(P.th), nx = -ez, nz = ex, T = P.top;\n    let x0 = W, x1 = 0, y0 = H, y1 = 0;\n    for (let k = 0; k \u003c 4; k++) {\n      const u = (k & 1 ? 0.5 : -0.5) * gw, c = onWall([T[0] + u * ex, T[1] + (k & 2 ? GH : 0), T[2] + u * ez]);\n      x0 = min(x0, c[0]);\n      x1 = max(x1, c[0]);\n      y0 = min(y0, c[1]);\n      y1 = max(y1, c[1]);\n    }\n    const nT = nx * (T[0] - LX) + nz * (T[2] - LZ), Dz = WZ - LZ;\n    for (let y = max(0, floor(y0)); y \u003c= min(H - 1, ceil(y1)); y++)\n      for (let x = max(0, floor(x0)); x \u003c= min(W - 1, ceil(x1)); x++) {\n        // The ray from the lamp to this LED of the wall, met with the plate.\n        const Dx = x + 0.5 - LX, Dy = y + 0.5 - LY, den = nx * Dx + nz * Dz;\n        if (abs(den) \u003c 1e-6) continue;\n        const s = nT / den, qx = LX + s * Dx - T[0], qy = LY + s * Dy - T[1], qz = LZ + s * Dz - T[2];\n        const u = floor(qx * ex + qz * ez + gw / 2), v = floor(qy);\n        if (u >= 0 && u \u003c gw && v >= 0 && v \u003c GH && g.g[v * gw + u]) sh[y * W + x] = 1;\n      }\n  }\n}\n\n// Soften the shadow edge by one LED (the lamp is not a point) and lay the\n// wall, under a spot aimed a little above the middle.\nfunction paintWall(S) {\n  const { fb, sh, tmp } = S;\n  if (!S.wall) {\n    S.wall = new Float32Array(NP);\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const r2 = (x - 30) * (x - 30) + (y - 52) * (y - 52) * 0.55;\n        S.wall[y * W + x] = 0.105 + 0.13 * exp(-r2 / 2600);\n      }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (sh[p] * 2 + (x > 0 ? sh[p - 1] : sh[p]) + (x \u003c W - 1 ? sh[p + 1] : sh[p])) / 4;\n    }\n  const wallC = hsv(0.58 + S.hue, 0.16, 1), wall = S.wall;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, s = min(1, (tmp[p] * 2 + (y > 0 ? tmp[p - W] : tmp[p]) + (y \u003c H - 1 ? tmp[p + W] : tmp[p])) / 4);\n      const v = wall[p] * (1 - 0.62 * s);\n      fb[p * 3] = wallC[0] * v;\n      fb[p * 3 + 1] = wallC[1] * v;\n      fb[p * 3 + 2] = wallC[2] * v;\n    }\n}\n\nfunction paintLine(fb, cov, p, q, wgt, col) {\n  splatLine(cov, p[0], p[1], q[0], q[1], wgt);\n  const xa = max(0, floor(min(p[0], q[0])) - 2), xb = min(W - 1, ceil(max(p[0], q[0])) + 2);\n  const ya = max(0, floor(min(p[1], q[1])) - 2), yb = min(H - 1, ceil(max(p[1], q[1])) + 2);\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const pi = y * W + x, a = min(1, cov[pi]);\n      if (a \u003c= 0) continue;\n      cov[pi] = 0;\n      for (let ch = 0; ch \u003c 3; ch++) fb[pi * 3 + ch] += (col[ch] - fb[pi * 3 + ch]) * a;\n    }\n}\n\n// A plate, foreshortened by its turn: each LED takes the share of the glyph\n// it covers, so a plate turned edge-on thins to its edge and turned past it\n// shows its back, the letter mirrored.\nfunction paintPlate(fb, g, T, th, base) {\n  const gw = g.gw, ex = cos(th), ez = sin(th), c = abs(ex) \u003c 0.07 ? (ex \u003c 0 ? -0.07 : 0.07) : ex, ac = abs(c);\n  // Lit by the lamp on whichever face it turns to it.\n  const cx = T[0], lx = LX - cx, ly = LY - T[1] - GH / 2, lz = LZ - T[2], ll = sqrt(lx * lx + ly * ly + lz * lz);\n  const shade = 0.5 + 0.5 * abs((-ez * lx + ex * lz) / ll), c0 = base[0] * shade, c1 = base[1] * shade, c2 = base[2] * shade;\n  const half = (gw / 2) * ac, xa = max(0, floor(cx - half)), xb = min(W - 1, ceil(cx + half));\n  const ya = max(0, floor(T[1])), yb = min(H - 1, ceil(T[1] + GH));\n  for (let x = xa; x \u003c= xb; x++) {\n    let u0 = (x - cx) / c + gw / 2, u1 = (x + 1 - cx) / c + gw / 2;\n    if (u0 > u1) {\n      const t = u0;\n      u0 = u1;\n      u1 = t;\n    }\n    for (let y = ya; y \u003c= yb; y++) {\n      // Rows blend where the plate sits between LEDs.\n      const v = y - T[1], j0 = floor(v), fv = v - j0;\n      let a = 0;\n      if (j0 >= 0 && j0 \u003c GH) a += (1 - fv) * (inkTo(g, j0, u1) - inkTo(g, j0, u0));\n      if (j0 + 1 >= 0 && j0 + 1 \u003c GH) a += fv * (inkTo(g, j0 + 1, u1) - inkTo(g, j0 + 1, u0));\n      a = min(1, a * ac);\n      if (a \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      fb[o] += (c0 - fb[o]) * a;\n      fb[o + 1] += (c1 - fb[o + 1]) * a;\n      fb[o + 2] += (c2 - fb[o + 2]) * a;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.letters) return;\n  const { fb, sh, tmp } = S;\n  const { lines, plates } = layout(S);\n  castShadows(sh, lines, plates);\n  paintWall(S);\n  // The mobile, far things first.\n  const items = [];\n  for (const L of lines) items.push({ z: (L.p[2] + L.q[2]) / 2, L, P: null });\n  for (const P of plates) items.push({ z: P.top[2], L: null, P });\n  items.sort((a, b) => a.z - b.z);\n  const steel = [0.62, 0.64, 0.68], thread = [0.36, 0.36, 0.38];\n  const pal = [hsv(0.14 + S.hue, 0.85, 1), hsv(0.6 + S.hue, 0.8, 1), hsv(0.995 + S.hue, 0.85, 1), hsv(0.6 + S.hue, 0.07, 1)];\n  tmp.fill(0);\n  for (const it of items) {\n    if (it.L) {\n      const { p, q, c, glint } = it.L;\n      paintLine(fb, tmp, p, q, c ? 1.15 : 0.8, glint ? steel.map((v) => v + (1 - v) * glint) : c ? steel : thread);\n    } else paintPlate(fb, it.P.l.g, it.P.top, it.P.th, pal[it.P.pos]);\n  }\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, fb[p * 3] * 255) | 0, min(255, fb[p * 3 + 1] * 255) | 0, min(255, fb[p * 3 + 2] * 255) | 0);\n}\n","lights-out":"// ===== Patternflow pattern =====\n// Title:   Lights Out\n// Family:  algo\n// Idea:    A random board of Lights Out the size of the panel is solved by light chasing: a front runs down pressing the cell below every lit cell, the lights turn into a record of presses behind it, the leftover on the bottom row is looked up as a set of presses on the top row, and a second chase runs the last lights off the bottom, leaving the record of what was pressed.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lights Out (Tiger Electronics, 1995), the sigma-plus game as linear algebra over GF(2) (Klaus Sutner, 1989), light chasing and the kernel (Marlow Anderson and Todd Feil, Turning Lights Out with Linear Algebra, 1998), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cells=1..4, Record=0..1\n//\n// Knob 1: Hue. Turns the board round the wheel: at 0 the lights are amber, the record of presses is sky blue and a press flashes white.\n// Knob 2: Speed. At 2 a board is built in 0.6 s, the first chase runs down 127 rows in 2.4 s, the bottom row is looked up in 0.7 s and the second chase takes 2.0 s, 7.7 s a board in all. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Cells. Cell size in LEDs: 1 is a board of 64 by 128 cells, 2 is 32 by 64, 3 is 21 by 42, 4 is 16 by 32. Every one of these boards has a kernel of 0, so any pattern of lights has exactly one solution.\n// Knob 4: Record. How long a press stays on the board. At 0.06 and below the record stays until the board is done, and when the second chase ends it is the one solution, cell for cell the random presses that built the board. Turned up, the record fades, at 1 within 0.2 s, and only the lights and the flashes of the chase are left, as on the toy.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst WHITE = [1, 1, 1];\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The game. Pressing a cell toggles it and its four neighbours. The\n// board is a vector over GF(2) and a set of presses x lights A x, where A is\n// the w h by w h matrix of the pluses; solving the board is solving A x = b.\nfunction press(B, w, h, x, y) {\n  const i = y * w + x;\n  B[i] ^= 1;\n  if (x > 0) B[i - 1] ^= 1;\n  if (x \u003c w - 1) B[i + 1] ^= 1;\n  if (y > 0) B[i - w] ^= 1;\n  if (y \u003c h - 1) B[i + w] ^= 1;\n}\n\n// ---- Light chasing. Pressing the cell below every lit cell of a row clears\n// that row and touches nothing above it, so chasing row 0 to row h - 2 leaves\n// lights only on the bottom row. Chasing is linear: the leftover is the sum\n// of what each top-row press alone would leave. Column j of the chase matrix\n// is the bottom row that pressing top cell j and chasing leaves; to clear a\n// leftover r, press the top-row set t with C t = r and chase again.\n// Worked in Node for the four boards here (64x128, 32x64, 21x42, 16x32):\n// C has full rank, so the kernel of A is 0 and every board is solvable. Three\n// rows less is another story: 64x125 has a kernel of dimension 36, and 5x5,\n// the toy, has 2.\nfunction chaseMatrix(w, h) {\n  const C = [], B = new Uint8Array(w * h);\n  for (let j = 0; j \u003c w; j++) {\n    B.fill(0);\n    press(B, w, h, j, 0);\n    for (let y = 0; y \u003c h - 1; y++) for (let x = 0; x \u003c w; x++) if (B[y * w + x]) press(B, w, h, x, y + 1);\n    C.push(B.slice((h - 1) * w));\n  }\n  return C;\n}\n\n// Gaussian elimination over GF(2) for C t = r; free columns, if a board ever\n// has any, are left unpressed.\nfunction solveTop(C, r, w) {\n  const M = [];\n  for (let i = 0; i \u003c w; i++) {\n    const row = new Uint8Array(w + 1);\n    for (let j = 0; j \u003c w; j++) row[j] = C[j][i];\n    row[w] = r[i];\n    M.push(row);\n  }\n  const piv = [];\n  let k = 0;\n  for (let c = 0; c \u003c w && k \u003c w; c++) {\n    let p = -1;\n    for (let i = k; i \u003c w; i++) if (M[i][c]) { p = i; break; }\n    if (p \u003c 0) continue;\n    const tmp = M[k]; M[k] = M[p]; M[p] = tmp;\n    for (let i = 0; i \u003c w; i++) if (i !== k && M[i][c]) for (let q = c; q \u003c= w; q++) M[i][q] ^= M[k][q];\n    piv.push(c);\n    k++;\n  }\n  const t = new Uint8Array(w);\n  for (let i = 0; i \u003c piv.length; i++) t[piv[i]] = M[i][w];\n  return t;\n}\n\n// ---- One board's life, in seconds at Speed 2.\nconst PH = [\"build\", \"hold\", \"chase1\", \"resid\", \"correct\", \"chase2\", \"solved\", \"fade\", \"dark\"];\nconst DUR = { build: 0.6, hold: 0.3, chase1: 2.4, resid: 0.7, correct: 0.35, chase2: 2.0, solved: 0.6, fade: 0.5, dark: 0.25 };\n\nfunction sizeOf(S, c) {\n  if (!S.cache[c]) {\n    const w = floor(W / c), h = floor(H / c);\n    S.cache[c] = { c, w, h, ox: floor((W - w * c) / 2), oy: floor((H - h * c) / 2), C: chaseMatrix(w, h) };\n  }\n  return S.cache[c];\n}\n\nfunction newBoard(S, c) {\n  const z = sizeOf(S, c), n = z.w * z.h;\n  S.z = z;\n  S.L = new Uint8Array(n);\n  S.R = new Uint8Array(n);\n  S.age = new Float32Array(n).fill(99);\n  S.fl = new Float32Array(n);\n  S.fk = new Uint8Array(n);\n  // The board is made the way the toy makes one: by pressing. Each cell is\n  // pressed with probability one half, so the lights are a uniform draw from\n  // the boards that can be solved (here all 2^(w h) of them).\n  const g = [];\n  for (let i = 0; i \u003c n; i++) if (Math.random() \u003c 0.5) g.push(i);\n  for (let i = g.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = g[i];\n    g[i] = g[j];\n    g[j] = t;\n  }\n  S.g = g;\n  S.gi = 0;\n  S.ph = 0;\n  S.u = 0;\n  S.row = 0;\n  S.t = null;\n}\n\n// Chase rows up to (not including) row `to`: press below each lit cell.\nfunction chaseTo(S, to) {\n  const { w, h } = S.z, L = S.L;\n  for (; S.row \u003c min(to, h - 1); S.row++) {\n    const y = S.row;\n    for (let x = 0; x \u003c w; x++)\n      if (L[y * w + x]) {\n        const i = (y + 1) * w + x;\n        press(L, w, h, x, y + 1);\n        mark(S, i);\n      }\n  }\n}\n\n// A press goes into the record (presses are counted mod 2, so a second press\n// on a cell takes the first back) and flashes: white when it adds to the\n// record, rose when it cancels an earlier press.\nfunction mark(S, i) {\n  S.R[i] ^= 1;\n  S.age[i] = 0;\n  S.fl[i] = 1;\n  S.fk[i] = S.R[i] ? 1 : 2;\n}\n\nfunction enter(S, ph) {\n  S.ph = ph;\n  S.u = 0;\n  const { w, h } = S.z;\n  if (PH[ph] === \"chase1\" || PH[ph] === \"chase2\") S.row = 0;\n  if (PH[ph] === \"resid\") S.t = solveTop(S.z.C, S.L.subarray((h - 1) * w), w);\n  if (PH[ph] === \"correct\")\n    for (let x = 0; x \u003c w; x++)\n      if (S.t[x]) {\n        press(S.L, w, h, x, 0);\n        mark(S, x);\n      }\n}\n\nexport function setup(params) {\n  params.s = { cache: {}, hue: 0, rec: 0.06, cells: 1, rgb: new Float32Array(NP * 3) };\n  newBoard(params.s, 1);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.rec = cl(k[3], 0, 1);\n  const c = cl(round(k[2]), 1, 4);\n  if (c !== S.cells) {\n    S.cells = c;\n    newBoard(S, c);\n  }\n  // step is board time: seconds at Speed 2.\n  const step = (d * cl(k[1], 0.2, 3)) / 2, n = S.L.length, ff = exp(-step * 14);\n  for (let i = 0; i \u003c n; i++) {\n    S.age[i] += step;\n    S.fl[i] *= ff;\n  }\n  S.u += step;\n  for (let guard = 0; guard \u003c 16; guard++) {\n    const name = PH[S.ph], T = DUR[name], u = cl(S.u / T, 0, 1);\n    const { w, h } = S.z;\n    if (name === \"build\") {\n      const to = floor(S.g.length * u);\n      for (; S.gi \u003c to; S.gi++) {\n        const i = S.g[S.gi];\n        press(S.L, w, h, i % w, floor(i / w));\n        S.fl[i] = max(S.fl[i], 0.55);\n        S.fk[i] = 0;\n      }\n    } else if (name === \"chase1\" || name === \"chase2\") chaseTo(S, floor(u * (h - 1) + 1e-9));\n    if (S.u \u003c T) break;\n    S.u -= T;\n    if (name === \"dark\") newBoard(S, S.cells);\n    else enter(S, S.ph + 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { c, w, h, ox, oy } = S.z, rgb = S.rgb;\n  const lit = hsv(0.11 + S.hue, 0.78, 0.86), rec = hsv(0.56 + S.hue, 0.72, 0.72), undo = hsv(0.94 + S.hue, 0.6, 1);\n  const name = PH[S.ph], u = cl(S.u / DUR[name], 0, 1);\n  // The fade at the end of a board, and a blink on the leftover bottom row.\n  const all = name === \"fade\" ? 1 - u : name === \"dark\" ? 0 : 1;\n  const blink = name === \"resid\" ? 0.35 + 0.65 * (0.5 + 0.5 * cos(u * 4 * PI)) : 1;\n  // Record fade per second of press age: 0 up to Record 0.06, 30 at 1.\n  const rate = (30 * max(0, S.rec - 0.06)) / 0.94;\n  rgb.fill(0);\n  const g = c >= 3 ? 1 : 0;\n  for (let j = 0; j \u003c h; j++)\n    for (let i = 0; i \u003c w; i++) {\n      const q = j * w + i;\n      let r = 0, gg = 0, b = 0;\n      if (S.L[q]) {\n        const a = j === h - 1 && name === \"resid\" ? blink : 1;\n        r = lit[0] * a;\n        gg = lit[1] * a;\n        b = lit[2] * a;\n      } else if (S.R[q]) {\n        const a = exp(-rate * S.age[q]);\n        r = rec[0] * a;\n        gg = rec[1] * a;\n        b = rec[2] * a;\n      }\n      const f = cl(S.fl[q], 0, 1), fc = S.fk[q] === 2 ? undo : WHITE;\n      r = (r + (fc[0] - r) * f) * all;\n      gg = (gg + (fc[1] - gg) * f) * all;\n      b = (b + (fc[2] - b) * f) * all;\n      if (r + gg + b \u003c= 0) continue;\n      for (let yy = 0; yy \u003c c - g; yy++)\n        for (let xx = 0; xx \u003c c - g; xx++) {\n          const o = ((oy + j * c + yy) * W + ox + i * c + xx) * 3;\n          rgb[o] = r;\n          rgb[o + 1] = gg;\n          rgb[o + 2] = b;\n        }\n    }\n  // The lookup: a thin line rises from the leftover row to the top row,\n  // where the presses it found land.\n  if (name === \"resid\" && u > 0.45) {\n    const y = floor(oy + (h * c - 1) * (1 - (u - 0.45) / 0.55));\n    for (let x = ox; x \u003c ox + w * c; x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] = max(rgb[o], 0.5);\n      rgb[o + 1] = max(rgb[o + 1], 0.5);\n      rgb[o + 2] = max(rgb[o + 2], 0.5);\n    }\n  }\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n","mesostic":"// ===== Patternflow pattern =====\n// Title:   Mesostic\n// Family:  type\n// Idea:    A reader slides through a stretch of Thoreau's Walden in the bottom line until the next letter of a spine word that Cage's mesostic rule allows comes to the centre, the letter locks as a gold capital, the words the rule lets stand stay as its wings and the rest fade, and the page climbs a line, so the spine word reads down the middle of the panel again and again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: John Cage's mesostics (from the late 1960s; Writing through Finnegans Wake, 1978) and his 50% and 100% rules, written through Henry David Thoreau's Walden (1854); letters from the MatrixLight6 pixel font of trip5's Matrix-Fonts (CC-BY), as the device's firmware carries it; pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Rule=0..1\n//\n// Knob 1: Hue. Turns the capitals and the wings round the wheel together: at 0 the capitals are gold and the wing text pale sky blue.\n// Knob 2: Speed. At 2 the reader slides for 0.45 to 0.95 s depending on how much text it passes over, the capital locks in 0.4 s and the page climbs a line in 0.35 s: a new line every 1.28 s on average with THOREAU. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. The spine: THOREAU, WALDEN, MUREAU (Cage's 1970 piece made from Thoreau's Journal, MUsic and thoREAU) or SILENCE (Cage's 1961 book). The page opens on the first 17 lines of the mesostic; turning it leaves a blank line and the reader starts a new mesostic from where it is.\n// Knob 4: Rule. Below 0.5 a 50% mesostic: between two capitals the second capital's letter does not appear. From 0.5 a 100% mesostic: the first capital's letter does not appear there either, so the wings are shorter and more letters are passed over. Turning it leaves a blank line like Word.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The source. Three passages of Walden (1854), from the chapter \"Where\n// I Lived, and What I Lived For\", in the order the chapter has them, quoted\n// as printed. The reader drops the punctuation, turns hyphens into spaces\n// and reads in lower case: 304 words.\nconst WALDEN = [\n  \"I went to the woods because I wished to live deliberately, to front only the essential facts of life, and see if I could not learn what it had to teach, and not, when I came to die, discover that I had not lived. I did not wish to live what was not life, living is so dear; nor did I wish to practise resignation, unless it was quite necessary. I wanted to live deep and suck out all the marrow of life, to live so sturdily and Spartan-like as to put to rout all that was not life, to cut a broad swath and shave close, to drive life into a corner, and reduce it to its lowest terms, and, if it proved to be mean, why then to get the whole and genuine meanness of it, and publish its meanness to the world; or if it were sublime, to know it by experience, and be able to give a true account of it in my next excursion.\",\n  \"Our life is frittered away by detail. An honest man has hardly need to count more than his ten fingers, or in extreme cases he may add his ten toes, and lump the rest. Simplicity, simplicity, simplicity! I say, let your affairs be as two or three, and not a hundred or a thousand; instead of a million count half a dozen, and keep your accounts on your thumb-nail.\",\n  \"Time is but the stream I go a-fishing in. I drink at it; but while I drink I see the sandy bottom and detect how shallow it is. Its thin current slides away, but eternity remains. I would drink deeper; fish in the sky, whose bottom is pebbly with stars. I cannot count one. I know not the first letter of the alphabet.\",\n];\nconst WORDS = WALDEN.join(\" \").toLowerCase().replace(/-/g, \" \").replace(/[^a-z ]/g, \"\").split(/ +/).filter((w) => w.length > 0);\nconst N = WORDS.length;\nconst mod = (g) => ((g % N) + N) % N;\nconst word = (g) => WORDS[mod(g)];\n\nconst SPINES = [\"THOREAU\", \"WALDEN\", \"MUREAU\", \"SILENCE\"];\n\n// ---- Letters: MatrixLight6, the 6-row pixel font in the device's\n// firmware/patternflow/src/fonts/. Each glyph is its width, its first row\n// (0 for capitals and ascenders, 1 for the x-height, 2 for a's short bowl)\n// and one base-32 digit per row, the high bit on the left. Capitals are 5\n// rows tall; lower case runs 4 rows from row 1 with descenders on row 5.\nconst B32 = \"0123456789abcdefghijklmnopqrstuv\";\nconst UP = \"3025755 3065656 3025452 3065556 3074747 3074744 4068b97 4099f99 1011111 3011152 3055655 3044447 50allhh 409db99 4069996 3065644 40699a5 3065655 3034216 3072222 3055552 3055522 50lllla 3055255 3055222 3071247\";\nconst LO = \"32353 3044656 313443 3011353 313563 3012722 3135312 3044655 1010111 30101152 3044565 1011111 51qlll 316555 312552 3165564 3135531 316544 313436 3027221 315553 315552 51llla 315225 3155312 317127\";\nconst glyph = (code) => ({ w: +code[0], top: +code[1], rows: [...code.slice(2)].map((c) => B32.indexOf(c)) });\nconst CAPS = UP.split(\" \").map(glyph), SMALL = LO.split(\" \").map(glyph);\nconst gOf = (ch, cap) => (cap ? CAPS : SMALL)[ch.charCodeAt(0) - 97];\n// Width of a run of text with its trailing 1 LED gap; a space adds 2 more,\n// so words stand 3 LEDs apart.\nfunction runW(s) {\n  let x = 0;\n  for (const ch of s) x += ch === \" \" ? 2 : gOf(ch, false).w + 1;\n  return x;\n}\n// A capital stands on the middle of the panel, x 31.5.\nconst capX = (w) => round(31.5 - w / 2);\n\n// ---- The reading strip: the whole source in one line of lower case, words\n// 3 LEDs apart. wordX0 is where each word starts; the strip repeats every\n// TOTAL LEDs, so the reading can run round the source.\nconst wordW = WORDS.map((w) => runW(w) - 1);\nconst wordX0 = [];\nlet TOTAL = 0;\nfor (let i = 0; i \u003c N; i++) (wordX0.push(TOTAL), (TOTAL += wordW[i] + 3));\nconst wordX = (g) => floor(g / N) * TOTAL + wordX0[mod(g)];\nfunction readPoint(g, c) {\n  const w = word(g);\n  let x = wordX(g);\n  for (let j = 0; j \u003c c; j++) x += gOf(w[j], false).w + 1;\n  return x + gOf(w[c], false).w / 2;\n}\n\n// ---- The mesostic. Lines go through the source in order, one capital\n// each, the capital in its own word, and every word shown whole: a line is\n// [left wing words] prefix CAPITAL suffix [right wing words]. Cage's rules\n// are about the text between two capitals, the right wing of one line and\n// the left wing of the next:\n//   50%: the second capital's letter does not appear there;\n//   100%: nor does the first capital's letter.\n// Text between the two wings may be passed over, as Cage passed it over.\n// A word can carry the capital only where its own prefix and suffix keep\n// the rule (the suffix lies before the next capital, so it may not hold the\n// next spine letter) and where both fit their half of the panel. Wings take\n// whole words outward until a word holds a forbidden letter or the half is\n// full; when both wings want the same words in a short gap they split it.\n// Checked in Node over 3000 lines for each spine and rule: no line breaks\n// its rule, and THOREAU at 50% sets 49 capitals a pass through the 304\n// words on average, 35 at 100%.\nfunction newGen(spine, full, from) {\n  return { spine, full, k: 0, from, cur: null };\n}\nfunction pick(G, k, from) {\n  const S = G.spine, L = S.length;\n  const s = S[k % L].toLowerCase(), sp = S[(k + L - 1) % L].toLowerCase(), sn = S[(k + 1) % L].toLowerCase();\n  for (let g = from; g \u003c from + 4 * N; g++) {\n    const w = word(g), c = w.indexOf(s);\n    if (c \u003c 0) continue;\n    const pre = w.slice(0, c), suf = w.slice(c + 1);\n    if (suf.includes(sn)) continue;\n    if (G.full && ((k > 0 && pre.includes(sp)) || suf.includes(s))) continue;\n    const cw = gOf(s, true).w, cx = capX(cw);\n    if (runW(pre) > cx || runW(suf) - 1 > W - (cx + cw + 1)) continue;\n    return { g, c, k, s, cx, cw, pre, suf, left: [], right: [] };\n  }\n  return null;\n}\nconst holds = (w, F) => F.some((f) => w.includes(f));\nfunction extendLeft(line, lo, F) {\n  const out = [];\n  let txt = line.pre.length ? \" \" + line.pre : \" \";\n  for (let g = line.g - 1; g >= lo; g--) {\n    const w = word(g);\n    if (holds(w, F) || runW(w + txt) > line.cx) break;\n    out.unshift(g);\n    txt = \" \" + w + txt;\n  }\n  return out;\n}\nfunction extendRight(line, hi, F) {\n  const out = [];\n  let txt = line.suf;\n  for (let g = line.g + 1; g \u003c= hi; g++) {\n    const w = word(g), t = txt + \" \" + w;\n    if (holds(w, F) || runW(t) - 1 > W - (line.cx + line.cw + 1)) break;\n    out.push(g);\n    txt = t;\n  }\n  return out;\n}\n// The next finished line: it needs the capital after it to know where its\n// right wing must stop.\nfunction nextLine(G) {\n  if (!G.cur) {\n    G.cur = pick(G, 0, G.from);\n    G.cur.left = extendLeft(G.cur, G.from, [G.cur.s]);\n  }\n  const cur = G.cur, nx = pick(G, cur.k + 1, cur.g + 1);\n  const F = G.full ? [nx.s, cur.s] : [nx.s];\n  let right = extendRight(cur, nx.g - 1, F), left = extendLeft(nx, cur.g + 1, F);\n  if (right.length && left.length && left[0] \u003c= right[right.length - 1]) {\n    const mid = floor((left[0] + right[right.length - 1]) / 2);\n    right = right.filter((g) => g \u003c= mid);\n    left = left.filter((g) => g > mid);\n  }\n  cur.right = right;\n  nx.left = left;\n  G.cur = nx;\n  return layout(cur);\n}\n\n// Glyphs of a finished line, placed outward from the capital.\nfunction layout(line) {\n  const out = [{ gl: gOf(line.s, true), x: line.cx, cap: true }];\n  const lt = line.left.map(word).join(\" \") + (line.left.length ? \" \" : \"\") + line.pre;\n  const rt = line.suf + (line.right.length ? \" \" : \"\") + line.right.map(word).join(\" \");\n  let x = line.cx;\n  for (let i = lt.length - 1; i >= 0; i--) {\n    if (lt[i] === \" \") x -= 2;\n    else {\n      const gl = gOf(lt[i], false);\n      x -= gl.w + 1;\n      out.push({ gl, x, cap: false });\n    }\n  }\n  x = line.cx + line.cw + 1;\n  for (const ch of rt) {\n    if (ch === \" \") x += 2;\n    else {\n      const gl = gOf(ch, false);\n      out.push({ gl, x, cap: false });\n      x += gl.w + 1;\n    }\n  }\n  const lastG = line.right.length ? line.right[line.right.length - 1] : line.g;\n  return { glyphs: out, s: line.s, rp: readPoint(line.g, line.c), end: lastG + 1, blank: false };\n}\n\n// ---- Page. Eighteen slots of 7 rows (6 for the font, 1 between), rows 1\n// to 126; the bottom slot is the reading strip, the 17 above hold the\n// finished lines, the newest lowest.\nconst PITCH = 7, SLOTS = 18;\nconst slotY = (j) => 1 + PITCH * j;\n\nfunction start(S) {\n  S.gen = newGen(SPINES[S.word], S.full, 0);\n  S.page = [];\n  for (let i = 0; i \u003c SLOTS - 1; i++) S.page.push(nextLine(S.gen));\n  S.next = nextLine(S.gen);\n  S.from = S.page[S.page.length - 1].rp;\n  S.phase = 0;\n  S.t = 0;\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, word: 0, full: false, seen: false, page: null, rgb: new Float32Array(NP * 3) };\n  start(params.s);\n}\n\n// Phase 0 slides the strip from the last capital to the next, 1 locks the\n// capital and fades the passed-over text, 2 climbs the page a line.\nfunction phaseDur(S) {\n  if (S.phase === 0) return 0.45 + 0.5 * min(1, (S.next.rp - S.from) / 600);\n  return S.phase === 1 ? 0.4 : 0.35;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const wd = cl(round(k[2]), 0, 3), full = cl(k[3], 0, 1) >= 0.5;\n  if (!S.seen) {\n    // The first frame opens on the mesostic the knobs ask for.\n    S.seen = true;\n    if (wd !== S.word || full !== S.full) ((S.word = wd), (S.full = full), start(S));\n  }\n  if (wd !== S.word || full !== S.full) {\n    S.word = wd;\n    S.full = full;\n    // A new mesostic from where the reading stands, after a blank line. The\n    // line on its way is dropped unless it is already locking.\n    if (S.phase === 1) S.page.push(S.next);\n    const last = S.page[S.page.length - 1];\n    S.gen = newGen(SPINES[wd], full, last.end);\n    S.page.push({ blank: true, glyphs: [], rp: last.rp, end: last.end });\n    while (S.page.length > SLOTS + 1) S.page.shift();\n    S.next = nextLine(S.gen);\n    S.from = last.rp;\n    S.phase = 2;\n    S.t = 0;\n  }\n  S.t += (d * S.speed) / 2;\n  for (let guard = 0; guard \u003c 8; guard++) {\n    const T = phaseDur(S);\n    if (S.t \u003c T) break;\n    S.t -= T;\n    if (S.phase === 0) S.phase = 1;\n    else if (S.phase === 1) {\n      S.page.push(S.next);\n      while (S.page.length > SLOTS + 1) S.page.shift();\n      S.from = S.next.rp;\n      S.next = nextLine(S.gen);\n      S.phase = 2;\n    } else S.phase = 0;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0.004) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a);\n    rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n    rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n  // A glyph at x (fractional while the strip slides, split over two\n  // columns) with its top on row y.\n  const stamp = (gl, x, y, c, a) => {\n    const xi = floor(x), f = x - xi;\n    for (let r = 0; r \u003c gl.rows.length; r++) {\n      const bits = gl.rows[r], yy = y + gl.top + r;\n      for (let i = 0; i \u003c gl.w; i++)\n        if ((bits >> (gl.w - 1 - i)) & 1) {\n          if (f \u003c 0.01) put(xi + i, yy, c, a);\n          else (put(xi + i, yy, c, a * (1 - f)), put(xi + i + 1, yy, c, a * f));\n        }\n    }\n  };\n  const gold = hsv(0.12 + S.hue, 0.85, 1), sky = hsv(0.56 + S.hue, 0.5, 0.88), white = [1, 0.97, 0.9];\n  const T = phaseDur(S), u = cl(S.t / T, 0, 1);\n  const climb = S.phase === 2 ? ease(u) : 1, shift = round(PITCH * (1 - climb));\n\n  // ---- Finished lines. The newest is lowest; each line dims a little with\n  // every slot it has climbed, to 55% at the top.\n  const n = S.page.length;\n  for (let j = 0; j \u003c n; j++) {\n    const line = S.page[j];\n    if (line.blank) continue;\n    const slot = SLOTS - 2 - (n - 1 - j), y = slotY(slot) + shift;\n    if (y \u003c -6 || y >= H) continue;\n    const age = 0.55 + 0.45 * cl(y / slotY(SLOTS - 2), 0, 1);\n    for (const g of line.glyphs) stamp(g.gl, g.x, y, g.cap ? gold : sky, age);\n  }\n\n  // ---- The reading strip in the bottom slot. Its text is dim, brighter\n  // under the reading point in the middle, and the letters the spine wants\n  // next glint gold as they pass.\n  const yS = slotY(SLOTS - 1) + shift;\n  let rp, sa;\n  if (S.phase === 0) (rp = S.from + (S.next.rp - S.from) * ease(u)), (sa = 1);\n  else if (S.phase === 1) (rp = S.next.rp), (sa = 1 - ease(u));\n  else (rp = S.from), (sa = climb);\n  if (sa > 0) {\n    const off = 31.5 - rp, view = rp - 31.5;\n    let g = floor(view / TOTAL) * N;\n    while (wordX(g + 1) \u003c= view) g++;\n    const want = S.next.s;\n    for (; wordX(g) + off \u003c W; g++) {\n      const w = word(g);\n      let x = wordX(g) + off;\n      for (const ch of w) {\n        const gl = gOf(ch, false), dx = x + gl.w / 2 - 31.5;\n        const a = sa * (0.3 + 0.4 * exp(-(dx * dx) / 120));\n        stamp(gl, x, yS, ch === want ? gold : sky, ch === want ? a * 1.2 : a);\n        x += gl.w + 1;\n      }\n    }\n  }\n  // The line that is locking fades in over the strip, its capital flashing\n  // white and cooling to gold.\n  if (S.phase === 1) {\n    const e = ease(u), cap = [0, 1, 2].map((q) => white[q] + (gold[q] - white[q]) * ease(u * 1.4));\n    for (const g of S.next.glyphs) stamp(g.gl, g.x, yS, g.cap ? cap : sky, g.cap ? 0.5 + 0.5 * min(1, u * 4) : e);\n  }\n\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","miura-ori":"// ===== Patternflow pattern =====\n// Title:   Miura-ori\n// Family:  space\n// Idea:    A Miura-ori sheet of congruent parallelograms, bigger than the panel, folds and opens again on its one degree of freedom, seen in 3D from a little below, so its facets split into four kinds that flip between a warm key light, a cool fill, both and neither as the fold deepens, its mountain and valley creases show as light and dark lines, and at the deepest fold the sheet has shrunk across and down at once until its edges come into view on all four sides.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Miura-ori (Koryo Miura, 1970; \"Method of packaging and deployment of large membranes in space\", 1985), its closed-form rigid folding and in-plane Poisson ratio (Mark Schenk and Simon Guest, 2013), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sector=55..85, Light=0..1\n//\n// Knob 1: Hue. The colour of the two lights, which keep opposite hues. At 0 the key is amber and the fill blue, so a facet that faces both is cream, one that faces only the key amber, only the fill blue, and neither almost black; at 0.5 the key is sky blue and the fill salmon.\n// Knob 2: Speed. At 2 the sheet folds from almost flat to its deepest fold in 4 s and opens again in 4 s; 40 s each way at 0.2 and 2.7 s at 3.\n// Knob 3: Sector. The sector angle alpha, the acute angle between each parallelogram's 12 and 10 LED sides, from 55 to 85 degrees. At 55 the deepest fold shrinks the sheet to 57% across and 67% down, and halfway there it shrinks 0.66% across for every 1% down. At 70 it goes to 78% and 52%. At 85 the facets are nearly rectangles, the sheet only shortens, to 51%, and the creases run as straight bands.\n// Knob 4: Light. Walks both lights once round the sheet. The key stands 45 degrees up and the fill 15 degrees up a quarter turn round from it; at 0.06 the key comes from the top of the panel and the fill from its right.\n\nconst W = 64, H = 128, SW = 128, SH = 256, NS = SW * SH;\nconst { floor, ceil, round, sqrt, cos, sin, acos, min, max, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst DEG = PI / 180;\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- The fold. A Miura-ori is a translational surface, P(i, j) = A(i) + B(j),\n// with A a zigzag in the (v, z) plane whose steps are\n//   eb(i) = (0, b cos psi, +-b sin psi)\n// and B a zigzag in the (u, v) plane whose steps are\n//   ea(j) = (a sin g, +-a cos g, 0).\n// Every facet is then a parallelogram with sides eb(i) and ea(j), so its\n// sides stay b and a whatever psi is, and its angle stays alpha (or pi -\n// alpha, the same parallelogram turned over) while eb.ea = +-ab cos alpha,\n// that is cos psi cos g = cos alpha. psi = 0 is the flat sheet (g = alpha)\n// and psi = alpha the sheet folded flat into a packet (g = 0); psi is the\n// fold's one degree of freedom. It is Schenk and Guest's closed form with\n// sin psi = sin theta sin alpha, theta the angle between each facet and the\n// sheet's plane. u runs across the panel, v down it, z out of the sheet\n// towards the eye. Checked in Node for alpha from 55 to 85 degrees by 1 and\n// psi from 0 to alpha in 400 steps, 12,431 shapes of 187 facets: every side\n// stays 12 or 10 to within 6e-14, every corner's cosine stays cos alpha to\n// within 2e-15, every facet stays flat to within 3e-14, and the four angles\n// round each inside vertex add to 2 pi to within 6e-15.\n// 17 facets down and 11 across: flat, the sheet is 191 rows by 90 LEDs on\n// the panel; at the deepest fold at 55 degrees it is 125 by 52.\nconst M = 17, N = 11, NV = (M + 1) * (N + 1);\nconst B_LEN = 12, A_LEN = 10;\nfunction sheet(alpha, psi, out) {\n  const g = acos(cl(cos(alpha) / cos(psi), -1, 1));\n  const bv = B_LEN * cos(psi), bz = B_LEN * sin(psi), au = A_LEN * sin(g), av = A_LEN * cos(g);\n  const u0 = (N * au) / 2, v0 = (M * bv + av) / 2;\n  let k = 0;\n  for (let i = 0; i \u003c= M; i++)\n    for (let j = 0; j \u003c= N; j++) {\n      out[k++] = j * au - u0;\n      out[k++] = i * bv + (j & 1) * av - v0;\n      out[k++] = (i & 1) * bz - bz / 2;\n    }\n  return g;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, alpha: 55 * DEG, light: 0.06,\n    P: new Float64Array(NV * 3), sx: new Float32Array(NV), sy: new Float32Array(NV),\n    key: new Float32Array(3), fill: new Float32Array(3),\n    id: new Int16Array(NS), mark: new Uint8Array(NS),\n    col: new Float32Array(M * N * 3), mv: new Int8Array(M * N * 2),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 55, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.alpha = cl(k[2], 55, 85) * DEG;\n  S.light = cl(k[3], 0, 1);\n  S.t += (d * S.speed) / 2;\n}\n\nconst TILT = 24 * DEG; // how far the eye leans from straight above\nconst FOLD = 8; // seconds a fold and an opening at Speed 2\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { P, sx, sy, id, mark, col, mv, key, fill } = S;\n  const f = 0.5 - 0.5 * cos((2 * PI * S.t) / FOLD);\n  // psi runs from 3% to 100% of its deepest, 0.9 alpha or 60 degrees,\n  // whichever is less: at 55 degrees the facets fold up to 68 degrees from\n  // the sheet's plane.\n  const psi = min(S.alpha * 0.9, PI / 3) * (0.03 + 0.97 * f);\n  sheet(S.alpha, psi, P);\n  const ct = cos(TILT), st = sin(TILT);\n  // Vertices on the sample grid, two samples per LED each way. The eye looks\n  // down at the sheet leaning TILT towards the bottom of the panel, so z\n  // lifts a point up the screen.\n  for (let k = 0, q = 0; k \u003c NV; k++, q += 3) {\n    sx[k] = (W / 2 + P[q]) * 2;\n    sy[k] = (H / 2 + P[q + 1] * ct - P[q + 2] * st) * 2;\n  }\n  // Lights, in sheet coordinates: the key from the Light knob's side, 45\n  // degrees up; the fill a quarter turn round from it, 15 degrees up. A\n  // facet's four kinds (its row tilting up or down the sheet, its column\n  // left or right) take these two lights four ways.\n  const az = 2 * PI * (S.light + 0.69), e1 = 45 * DEG, e2 = 15 * DEG;\n  const az2 = az + PI / 2, k1x = cos(e1) * cos(az), k1y = cos(e1) * sin(az), k1z = sin(e1), k2x = cos(e2) * cos(az2), k2y = cos(e2) * sin(az2), k2z = sin(e2);\n  hsv(0.1 + S.hue, 0.7, 1, key, 0);\n  hsv(0.58 + S.hue, 0.9, 0.75, fill, 0);\n  id.fill(-1);\n  for (let i = 0; i \u003c M; i++)\n    for (let j = 0; j \u003c N; j++) {\n      const v0 = i * (N + 1) + j, v1 = v0 + 1, v3 = v0 + N + 1, v2 = v3 + 1, fi = i * N + j;\n      // Normal from the sides at P(i, j), turned to the front of the sheet (+z).\n      const q0 = v0 * 3, q1 = v1 * 3, q3 = v3 * 3;\n      const ax = P[q3] - P[q0], ay = P[q3 + 1] - P[q0 + 1], az3 = P[q3 + 2] - P[q0 + 2], bx = P[q1] - P[q0], by = P[q1 + 1] - P[q0 + 1], bz = P[q1 + 2] - P[q0 + 2];\n      let nx = ay * bz - az3 * by, ny = az3 * bx - ax * bz, nz = ax * by - ay * bx;\n      const nl = sqrt(nx * nx + ny * ny + nz * nz) || 1;\n      (nx /= nl), (ny /= nl), (nz /= nl);\n      if (nz \u003c 0) (nx = -nx), (ny = -ny), (nz = -nz);\n      // The back of the sheet shows where the turned normal points away from the eye.\n      const sgn = ny * st + nz * ct >= 0 ? 1 : -1;\n      const d1 = max(0, sgn * (nx * k1x + ny * k1y + nz * k1z)), d2 = max(0, sgn * (nx * k2x + ny * k2y + nz * k2z)), back = sgn \u003c 0 ? 0.5 : 1;\n      for (let c = 0; c \u003c 3; c++) col[fi * 3 + c] = back * (0.1 + key[c] * d1 + fill[c] * d2);\n      // Mountain or valley for the crease to the next facet down (side 0)\n      // and across (side 1): a mountain when that facet's far corner lies\n      // below this facet's plane.\n      if (i + 1 \u003c M) {\n        const q = (v3 + N + 1) * 3;\n        mv[fi * 2] = (P[q] - P[q3]) * nx + (P[q + 1] - P[q3 + 1]) * ny + (P[q + 2] - P[q3 + 2]) * nz \u003c 0 ? 1 : 2;\n      }\n      if (j + 1 \u003c N) {\n        const q = (v1 + 1) * 3;\n        mv[fi * 2 + 1] = (P[q] - P[q1]) * nx + (P[q + 1] - P[q1 + 1]) * ny + (P[q + 2] - P[q1 + 2]) * nz \u003c 0 ? 1 : 2;\n      }\n      // Rasterize. Seen from straight above, the folded sheet is a height\n      // field over (u, v), and a ray from the eye leaning towards +v meets\n      // larger v first, so drawing the rows in order down the sheet leaves\n      // the nearest facet on top (checked against a depth buffer: the same\n      // frames).\n      const X0 = sx[v0], Y0 = sy[v0];\n      const ux = sx[v1] - X0, uy = sy[v1] - Y0, wx = sx[v3] - X0, wy = sy[v3] - Y0;\n      const det = ux * wy - uy * wx;\n      if (abs(det) \u003c 1e-6) continue;\n      const xmin = max(0, floor(min(X0, sx[v1], sx[v2], sx[v3]))), xmax = min(SW - 1, ceil(max(X0, sx[v1], sx[v2], sx[v3])));\n      const ymin = max(0, floor(min(Y0, sy[v1], sy[v2], sy[v3]))), ymax = min(SH - 1, ceil(max(Y0, sy[v1], sy[v2], sy[v3])));\n      const inv = 1 / det, da = wy * inv, db = -uy * inv;\n      for (let y = ymin; y \u003c= ymax; y++) {\n        const ry = y + 0.5 - Y0, rx = xmin + 0.5 - X0;\n        // The sample as a + b along the two sides is inside when both lie in\n        // 0..1; along a row each is linear in x, so the row's run is solved\n        // for, not searched.\n        const a0 = (rx * wy - ry * wx) * inv, b0 = (ux * ry - uy * rx) * inv;\n        let lo = 0, hi = xmax - xmin;\n        for (let e = 0; e \u003c 2; e++) {\n          const v0 = e ? b0 : a0, dv = e ? db : da;\n          if (abs(dv) \u003c 1e-12) {\n            if (v0 \u003c 0 || v0 > 1) hi = -1;\n          } else {\n            const t0 = -v0 / dv, t1 = (1 - v0) / dv;\n            lo = max(lo, ceil(t0 \u003c t1 ? t0 : t1));\n            hi = min(hi, floor(t0 \u003c t1 ? t1 : t0));\n          }\n        }\n        for (let k = y * SW + xmin + lo, e = y * SW + xmin + hi; k \u003c= e; k++) id[k] = fi;\n      }\n    }\n  // Lines: a sample whose right or lower neighbour belongs to another facet\n  // is on a crease (1 mountain, 2 valley) or on an edge where one part of\n  // the sheet passes in front of another (3).\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      const p = y * SW + x, a = id[p];\n      mark[p] = 0;\n      if (a \u003c 0) continue;\n      let t = 0;\n      for (let side = 0; side \u003c 2; side++) {\n        if (side === 0 ? x + 1 >= SW : y + 1 >= SH) continue;\n        const b = id[side === 0 ? p + 1 : p + SW];\n        if (b === a || b \u003c 0) continue;\n        const lo = min(a, b), d = abs(a - b);\n        let m = 3;\n        if (d === N) m = mv[lo * 2];\n        else if (d === 1 && ((a / N) | 0) === ((b / N) | 0)) m = mv[lo * 2 + 1];\n        if (m > t) t = m;\n      }\n      mark[p] = t;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      for (let s = 0; s \u003c 4; s++) {\n        const p = (2 * y + (s >> 1)) * SW + 2 * x + (s & 1), a = id[p];\n        if (a \u003c 0) continue;\n        let cr = col[a * 3], cg = col[a * 3 + 1], cb = col[a * 3 + 2];\n        const m = mark[p];\n        if (m === 1) (cr = 0.45 + 0.55 * cr), (cg = 0.45 + 0.55 * cg), (cb = 0.45 + 0.55 * cb);\n        else if (m >= 2) (cr *= 0.2), (cg *= 0.2), (cb *= 0.2);\n        (r += cr), (g += cg), (b += cb);\n      }\n      display.setPixel(x, y, round(min(255, 63.75 * r)), round(min(255, 63.75 * g)), round(min(255, 63.75 * b)));\n    }\n}\n","prandtl-membrane":"// ===== Patternflow pattern =====\n// Title:   Prandtl's Membrane\n// Family:  type\n// Idea:    A bar whose cross-section is a word is twisted, and each letter is Prandtl's film stretched over a hole of its shape and blown up from below, so the letters breathe as lit pillows and hollow letters rise as plateaus round a flat plate, coloured by the shear stress, which is zero along each crest, runs hot along the rims and hottest in the inside corners.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: torsion of prismatic bars (Adhémar Barré de Saint-Venant, 1855), the membrane analogy (Ludwig Prandtl, 1903), thin-walled tubes (Rudolf Bredt, 1896), the Shortley-Weller boundary stencil (George Shortley and Royal Weller, 1938), successive over-relaxation (David Young, 1950), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Twist=0.2..3, Word=0..3, Lamp=0..1\n//\n// Knob 1: Hue. Turns the stress colours round the wheel: at 0 the crests, where the stress is zero, are blue, the rims run from magenta through red to orange, and the hottest places, inside corners and the outer walls of the hollow letters, burn yellow-orange. The plates in the holes take the blue, dim.\n// Knob 2: Twist. How hard the bar is twisted, which is how hard the film is blown up. Each breath, one every 4 s, swings the twist from 40% to 100% of the knob. At 2 the film stands at 56 degrees at the rim of the 14 LED bar of ㅜ at the top of a breath and 31 at the bottom, and the colour reaches its hot end at a stress of 12.7. At 0.2 the film over that bar tilts 9 degrees at most and the colours stay blue and violet; at 3 the same rim stands at 66 degrees and runs yellow.\n// Knob 3: Word. The cross-section: the syllable 숨 (breath) the height of the panel, then LIT, AIR and HOT, three capitals 56 by 38 LEDs stacked. A letter with a hole is a hollow section, and the hole is a flat plate the film lifts: at the same twist HOT carries four times the torque of LIT.\n// Knob 4: Lamp. How high the lamp stands as it walks round the word once in 12 s: 19 degrees at 0.06, low enough that each stroke is lit on one side and shaded on the other, with a pale glint halfway down the flank that faces the lamp; 75 degrees at 1, where the film is lit almost evenly, the glint rides the crests and mostly the colours move.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, cos, sin, min, max, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Letters, as unions of convex polygons in LEDs. The capitals sit in a\n// box 56 wide and 38 tall, stems 13 thick and bars 7 to 11, at rows 3, 46\n// and 89; the syllable 숨 fills the panel, ㅅ in rows 2 to 46, ㅜ in 51 to\n// 81 and ㅁ, a hollow box with walls 14 to 15 thick, in 85 to 126. Corners\n// are left sharp: the film is flat at an outside corner and infinitely steep\n// at an inside one, and both should show.\nconst R = (a, b, c, d) => [[a, b], [c, b], [c, d], [a, d]];\nconst TOP = [[0, 9], [9, 0], [47, 0], [56, 9], [56, 11], [0, 11]];\nconst LAT = {\n  L: [R(0, 0, 13, 38), R(13, 27, 56, 38)],\n  I: [R(6, 0, 50, 11), R(21, 11, 35, 27), R(6, 27, 50, 38)],\n  T: [R(0, 0, 56, 11), R(21, 11, 35, 38)],\n  A: [TOP, R(0, 11, 13, 38), R(43, 11, 56, 38), R(13, 20, 43, 29)],\n  R: [R(0, 0, 13, 38), [[13, 0], [47, 0], [56, 9], [56, 11], [13, 11]], R(43, 11, 56, 18), [[13, 18], [56, 18], [56, 21], [49, 28], [13, 28]], [[30, 28], [43, 28], [56, 36], [56, 38], [43, 38]]],\n  H: [R(0, 0, 13, 38), R(43, 0, 56, 38), R(13, 14, 43, 24)],\n  O: [TOP, [[0, 27], [56, 27], [56, 29], [47, 38], [9, 38], [0, 29]], R(0, 11, 13, 27), R(43, 11, 56, 27)],\n};\nconst SUM = [\n  [[23, 2], [41, 2], [18, 46], [0.5, 46]], // ㅅ, left stroke\n  [[19, 30], [27, 17], [63.5, 38], [63.5, 46], [46, 46]], // ㅅ, right stroke\n  R(0.5, 51, 63.5, 65), R(24, 65, 40, 81), // ㅜ\n  R(3, 85, 61, 99), R(3, 112, 61, 126), R(3, 99, 18, 112), R(46, 99, 61, 112), // ㅁ\n];\nconst WORDS = [\"숨\", \"LIT\", \"AIR\", \"HOT\"];\n\nfunction wordPolys(word) {\n  if (word === \"숨\") return SUM;\n  const out = [];\n  [...word].forEach((ch, i) => {\n    for (const poly of LAT[ch]) out.push(poly.map(([x, y]) => [x + 4, y + 3 + 43 * i]));\n  });\n  return out;\n}\n\n// Each convex polygon as its edge lines, outward normal (nx, ny) and offset,\n// so the largest n.p - c over the edges is negative inside and positive out.\nfunction edgesOf(poly) {\n  let cx = 0, cy = 0;\n  for (const [x, y] of poly) (cx += x / poly.length), (cy += y / poly.length);\n  return poly.map(([x0, y0], i) => {\n    const [x1, y1] = poly[(i + 1) % poly.length];\n    let nx = y1 - y0, ny = x0 - x1;\n    const l = sqrt(nx * nx + ny * ny);\n    (nx /= l), (ny /= l);\n    if (nx * (cx - x0) + ny * (cy - y0) > 0) (nx = -nx), (ny = -ny);\n    return [nx, ny, nx * x0 + ny * y0];\n  });\n}\n\n// ---- The film. Saint-Venant's stress function phi solves lap(phi) = -2\n// (twist and shear modulus taken as 1) inside the section with phi = 0 on\n// its outline, the shear stress is |grad phi| and the torque is twice the\n// volume under phi. Prandtl saw the same equation in a film stretched over a\n// hole of that shape and blown up from below. It is solved on a grid of half\n// LEDs, 128 by 256 nodes at ((i + 1/2)/2, (j + 1/2)/2), by successive\n// over-relaxation, ten sweeps a frame until no node moves by more than 0.01,\n// so a new word inflates as the solver relaxes: 116 to 144 sweeps, half a\n// second. Next to the outline a node uses the Shortley-Weller stencil with\n// its true distance to the edge along each grid line, so a slanted outline is\n// not a staircase. A hole makes a hollow section: phi is constant round the\n// hole, a weightless flat plate the film lifts, and the plate settles where\n// the pressure on its area balances the film's pull round its rim. That is\n// the condition that the stress circulates round the hole twice the hole's\n// area, the one Bredt's formula for thin tubes rests on.\n//\n// Checked in Node with this solver: on a circle of radius 20 the film peaks\n// at 199.79 against a^2/2 = 200, phi is within 0.18 of (a^2 - r^2)/2\n// everywhere, and the largest stress is 19.98 against a = 20, at the rim. On\n// a 40 by 8 strip the largest stress is at the middle of a long side, 7.50\n// at the node a quarter LED in from the edge, where the strip's 2y gives 7.5.\n// In a square tube 40 across with walls 6 the plate stands at 108.7 against\n// 102 from Bredt's thin-wall formula, and the stress in the middle of a wall\n// is 17.6 against Bredt's 17.0. The walls of 숨's ㅁ are too thick for Bredt:\n// its plate stands at 268, and across the bottom wall the stress climbs from\n// 6 at the plate to 31 at the outline.\nconst FW = 128, FH = 256, NN = FW * FH, HS = 0.5;\nfunction buildFilm(word) {\n  // Each polygon is measured only over its own box and 2 LEDs round it;\n  // everywhere else is plainly outside.\n  const d = new Float32Array(NN).fill(2);\n  for (const poly of wordPolys(word)) {\n    const e = edgesOf(poly).flat(), ne = e.length, xs = poly.map((q) => q[0]), ys = poly.map((q) => q[1]);\n    const i0 = max(0, floor((min(...xs) - 2) / HS)), i1 = min(FW - 1, floor((max(...xs) + 2) / HS));\n    const j0 = max(0, floor((min(...ys) - 2) / HS)), j1 = min(FH - 1, floor((max(...ys) + 2) / HS));\n    for (let j = j0; j \u003c= j1; j++)\n      for (let i = i0; i \u003c= i1; i++) {\n        const x = (i + 0.5) * HS, y = (j + 0.5) * HS;\n        let m = -1e9;\n        for (let k = 0; k \u003c ne; k += 3) {\n          const v = e[k] * x + e[k + 1] * y - e[k + 2];\n          if (v > m) m = v;\n        }\n        if (m \u003c d[j * FW + i]) d[j * FW + i] = m;\n      }\n  }\n  // 0 outside, 1 film, 2 + k hole k: a gap no path from the panel's edge reaches.\n  const type = new Int16Array(NN), seen = new Uint8Array(NN), stack = new Int32Array(4 * NN + 8);\n  for (let p = 0; p \u003c NN; p++) if (d[p] \u003c 0) type[p] = 1;\n  const fill = (starts, mark) => {\n    let top = 0, n = 0;\n    for (const p of starts) stack[top++] = p;\n    while (top) {\n      const p = stack[--top];\n      if (seen[p] || type[p] === 1) continue;\n      seen[p] = 1;\n      type[p] = mark;\n      n++;\n      const x = p % FW;\n      if (x > 0) stack[top++] = p - 1;\n      if (x \u003c FW - 1) stack[top++] = p + 1;\n      if (p >= FW) stack[top++] = p - FW;\n      if (p \u003c NN - FW) stack[top++] = p + FW;\n    }\n    return n;\n  };\n  const rim = [];\n  for (let i = 0; i \u003c FW; i++) rim.push(i, NN - FW + i);\n  for (let j = 0; j \u003c FH; j++) rim.push(j * FW, j * FW + FW - 1);\n  fill(rim, 0);\n  const area = [];\n  for (let p = 0; p \u003c NN; p++) if (!seen[p] && type[p] !== 1) area.push(fill([p], 2 + area.length) * HS * HS);\n  const holes = area.length;\n  // Film nodes and their stencils. A neighbour slot points into V: a film\n  // node's own index, NN for the outline (0), or NN + 1 + k for hole k's rim.\n  const cells = [];\n  for (let p = 0; p \u003c NN; p++) if (type[p] === 1) cells.push(p);\n  const n = cells.length, idx = new Int32Array(n * 4), cof = new Float32Array(n * 5), th = new Float32Array(n * 4);\n  const links = Array.from({ length: holes }, () => []);\n  const OFF = [-1, 1, -FW, FW];\n  for (let c = 0; c \u003c cells.length; c++) {\n    const p = cells[c];\n    for (let k = 0; k \u003c 4; k++) {\n      const q = p + OFF[k];\n      if (type[q] === 1) (idx[c * 4 + k] = q), (th[c * 4 + k] = 1);\n      else {\n        const t = cl(d[p] / (d[p] - d[q]), 0.08, 1);\n        th[c * 4 + k] = t;\n        if (type[q] >= 2) (idx[c * 4 + k] = NN + 1 + type[q] - 2), links[type[q] - 2].push(c, t);\n        else idx[c * 4 + k] = NN;\n      }\n    }\n    // Shortley-Weller: d2/dx2 ~ 2/(a b (a+b)) (b uL + a uR - (a+b) u), a, b the arms.\n    for (let ax = 0; ax \u003c 2; ax++) {\n      const a = th[c * 4 + ax * 2], b = th[c * 4 + ax * 2 + 1];\n      cof[c * 5 + ax * 2] = 2 / (a * (a + b));\n      cof[c * 5 + ax * 2 + 1] = 2 / (b * (a + b));\n      cof[c * 5 + 4] += 2 / (a * b);\n    }\n  }\n  for (let k = 0; k \u003c holes; k++) {\n    let corr = 0;\n    for (let i = 1; i \u003c links[k].length; i += 2) corr += 0.5 - links[k][i];\n    area[k] += corr * HS * HS;\n  }\n  return { cells: Int32Array.from(cells), idx, cof, th, links, area, holes, type, V: new Float32Array(NN + 1 + holes), n, settled: false, sweeps: 0, gx: new Float32Array(NN), gy: new Float32Array(NN), lgx: new Float32Array(W * H), lgy: new Float32Array(W * H), lin: new Uint8Array(W * H), lplate: new Uint8Array(W * H) };\n}\n\n// One sweep. The node update is the stencil solved for its centre, with the\n// -2 on the right scaled by h^2. Each hole's plate then moves to the height\n// where the film's pull round its rim, sum (K - phi)/theta over the links,\n// balances twice its area.\nfunction sweep(F, w) {\n  const { cells, idx, cof, V, n } = F, src = 2 * HS * HS;\n  let change = 0;\n  for (let c = 0; c \u003c n; c++) {\n    const p = cells[c], i4 = c * 4, i5 = c * 5;\n    const g = (cof[i5] * V[idx[i4]] + cof[i5 + 1] * V[idx[i4 + 1]] + cof[i5 + 2] * V[idx[i4 + 2]] + cof[i5 + 3] * V[idx[i4 + 3]] + src) / cof[i5 + 4];\n    const dv = w * (g - V[p]);\n    V[p] += dv;\n    if (abs(dv) > change) change = abs(dv);\n  }\n  for (let k = 0; k \u003c F.holes; k++) {\n    const L = F.links[k];\n    let s = 0, inv = 0;\n    for (let i = 0; i \u003c L.length; i += 2) (s += V[cells[L[i]]] / L[i + 1]), (inv += 1 / L[i + 1]);\n    const K = (2 * F.area[k] + s) / inv, dv = w * (K - V[NN + 1 + k]);\n    V[NN + 1 + k] += dv;\n    if (abs(dv) > change) change = abs(dv);\n  }\n  return change;\n}\n\n// Slope of the film at each node, from the parabola through the node and its\n// two neighbours on each axis at their true distances (the outline or the\n// plate counting as a neighbour at its crossing).\nfunction slopes(F) {\n  const { cells, idx, th, V, n, gx, gy } = F;\n  for (let c = 0; c \u003c n; c++) {\n    const p = cells[c], u = V[p];\n    for (let ax = 0; ax \u003c 2; ax++) {\n      const a = th[c * 4 + ax * 2] * HS, b = th[c * 4 + ax * 2 + 1] * HS, uL = V[idx[c * 4 + ax * 2]], uR = V[idx[c * 4 + ax * 2 + 1]];\n      const g = (a * a * uR - b * b * uL + (b * b - a * a) * u) / (a * b * (a + b));\n      if (ax) gy[p] = g;\n      else gx[p] = g;\n    }\n  }\n  // Each LED takes the mean slope of the film nodes among its four.\n  const { type, lgx, lgy, lin, lplate } = F;\n  for (let q = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      let sx = 0, sy = 0, m = 0, pl = 0;\n      for (let s = 0; s \u003c 4; s++) {\n        const p = (2 * y + (s >> 1)) * FW + 2 * x + (s & 1);\n        if (type[p] === 1) (sx += gx[p]), (sy += gy[p]), m++;\n        else if (type[p] >= 2) pl++;\n      }\n      (lgx[q] = m ? sx / m : 0), (lgy[q] = m ? sy / m : 0), (lin[q] = m), (lplate[q] = pl);\n    }\n}\n\nconst BREATH = 4; // seconds a breath, fifteen a minute at rest\nconst LAMP_TURN = 12;\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, twist: 2, word: -1, lamp: 0.06, film: null, films: [], rgb: new Float32Array(3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.twist = cl(k[1], 0.2, 3);\n  S.lamp = cl(k[3], 0, 1);\n  const word = cl(round(k[2]), 0, 3);\n  if (word !== S.word) {\n    S.word = word;\n    if (!S.films[word]) S.films[word] = buildFilm(WORDS[word]);\n    S.film = S.films[word];\n  }\n  const F = S.film;\n  if (!F.settled) {\n    let ch = 0;\n    for (let i = 0; i \u003c 10; i++) ch = sweep(F, 1.92);\n    F.sweeps += 10;\n    slopes(F);\n    if (ch \u003c 1e-2 || F.sweeps > 1500) F.settled = true;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.film) return;\n  const F = S.film, { lgx, lgy, lin, lplate } = F, rgb = S.rgb;\n  // The twist swings between 40% and 100% of the knob's on every breath.\n  const breath = 0.5 - 0.5 * cos((2 * PI * S.t) / BREATH);\n  const P = (S.twist / 2) * (0.4 + 0.6 * breath);\n  const Z = 0.12 * P; // film height per unit of phi\n  const az = (2 * PI * S.t) / LAMP_TURN + 0.6, el = ((15 + 60 * S.lamp) * PI) / 180;\n  const lx = cos(el) * cos(az), ly = cos(el) * sin(az), lz = sin(el);\n  let hx = lx, hy = ly, hz = lz + 1;\n  const hl = sqrt(hx * hx + hy * hy + hz * hz);\n  (hx /= hl), (hy /= hl), (hz /= hl);\n  const kt = P / 11; // the stress at which the colour reaches the hot end is 11 / P\n  const plate = 0.6 * (0.5 + 0.5 * lz);\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const n = lin[p];\n      if (n) {\n        const gx = lgx[p], gy = lgy[p], ax = -Z * gx, ay = -Z * gy, inv = 1 / sqrt(ax * ax + ay * ay + 1);\n        const dif = (ax * lx + ay * ly + lz) * inv, nh = (ax * hx + ay * hy + hz) * inv;\n        let spec = nh > 0.6 ? nh * nh : 0;\n        spec *= spec * spec * spec;\n        spec *= spec * spec; // nh^24\n        const tau = min(1.2, sqrt(gx * gx + gy * gy) * kt);\n        const v = (0.4 + 0.3 * (1 + dif)) * (0.6 + 0.6 * tau) + 0.7 * spec * n * 0.25;\n        hsv(0.62 + S.hue + 0.45 * min(1.15, tau), 1 - 0.3 * spec, v > 1 ? 1 : v, rgb, 0);\n        display.setPixel(x, y, round(255 * rgb[0]), round(255 * rgb[1]), round(255 * rgb[2]));\n      } else if (lplate[p]) {\n        hsv(0.62 + S.hue, 1, plate * lplate[p] * 0.25, rgb, 0);\n        display.setPixel(x, y, round(255 * rgb[0]), round(255 * rgb[1]), round(255 * rgb[2]));\n      } else display.setPixel(x, y, 0, 0, 0);\n    }\n}\n","steiner-tree":"// ===== Patternflow pattern =====\n// Title:   Steiner Tree\n// Family:  geometry\n// Idea:    Four to seven terminals stand on a zigzag of equilateral triangles or wander the panel; the minimum spanning tree joins them in faint dashes and the shortest network in bright lines that meet three at a time at 120 degrees in pink Steiner points, and when another network becomes shorter the tree flips to it while the old one fades out amber; a bar at the foot reads the length ratio of the two trees against the conjectured floor of root 3 over 2.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Euclidean Steiner tree problem (Jakob Steiner's name; Vojtěch Jarník and Miloš Kössler, 1934), Steiner minimal trees and the root 3 over 2 ratio conjecture (E. N. Gilbert and H. O. Pollak, 1968), full Steiner topologies (Z. A. Melzak, 1961), the iteration for a fixed topology (Warren D. Smith, 1992), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Terminals=4..7, Scatter=0..1\n//\n// Knob 1: Hue. Turns every colour together: at 0 the Steiner tree is cyan with faint rings spreading from it every 6 LEDs, its Steiner points pink, the terminals warm white, the spanning tree dashed blue grey and a tree just left behind amber.\n// Knob 2: Speed. How fast the terminals move. At 2 each wobbles round its place on the strip by 3.5% of the triangle side (2.1 LEDs for four terminals), once in 9 to 20 s, the strip sways 2.5 LEDs across, and free terminals wander at up to about 6 LEDs a second. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Terminals. 4 to 7. Each frame tries 40 of the full Steiner topologies (3, 15, 105 or 945 in all) from a cold start with 15 of Smith's steps, keeps the near misses for 3 s with 10 more steps a frame, and tries both swaps across every inner edge of the tree on show. A shorter candidate takes over, and if the picture changes the old tree fades out amber over 1.2 s.\n// Knob 4: Scatter, applied as its square. At 0 the terminals sit on a zigzag strip of equilateral triangles down the panel, side 60 LEDs for four terminals and 32 for seven. Four make a 60 degree rhombus whose two Steiner trees are mirror images of one length, root 7 over 3 (0.882) of the spanning tree, so the wobble flips the tree back and forth about 8 times a minute. Five and seven split into equilateral stars that share terminals: at rest the ratio is exactly root 3 over 2, and with the wobble it reads 0.867 to 0.904. At 1 they wander the whole panel, the ratio stays above 0.95 nine tenths of the time and seven terminals flip 27 times a minute.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, sin, cos, exp, abs, hypot, PI } = Math;\nconst TAU = 2 * PI, FLOOR = sqrt(3) / 2;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Full Steiner topologies. Terminals are nodes 0..n-1 and Steiner\n// points n..2n-3, each of degree 3. Terminal k joins the topology of the\n// first k by splitting one of its 2k - 3 edges, so there are 3, 15, 105 and\n// 945 for n = 4 to 7. A degenerate tree, a Steiner point sitting on a\n// terminal or two on one spot, is a full topology with a zero-length edge,\n// so the shortest over all full topologies is the Steiner minimal tree.\nconst TOPS = {};\nfunction topologies(n) {\n  if (TOPS[n]) return TOPS[n];\n  const out = [];\n  const rec = (edges, ins, k) => {\n    if (k === n) return void out.push(prep(n, edges, ins));\n    const s = n + k - 2;\n    for (let i = 0; i \u003c edges.length; i++) {\n      const [u, v] = edges[i], ne = edges.slice();\n      ne[i] = [u, s];\n      ne.push([s, v], [s, k]);\n      rec(ne, [...ins, [s, u, v, k]], k + 1);\n    }\n  };\n  rec([[0, n], [1, n], [2, n]], [], 3);\n  return (TOPS[n] = out);\n}\n\n// Adjacency and an order from the first Steiner point outwards, for the\n// elimination in smith().\nfunction prep(n, edges, ins) {\n  const N = 2 * n - 2, adj = Array.from({ length: N }, () => []);\n  edges.forEach(([a, b], e) => {\n    adj[a].push([b, e]);\n    adj[b].push([a, e]);\n  });\n  const order = [n], par = new Int8Array(N).fill(-1), seen = new Uint8Array(N);\n  seen[n] = 1;\n  for (let i = 0; i \u003c order.length; i++)\n    for (const [b] of adj[order[i]])\n      if (b >= n && !seen[b]) {\n        seen[b] = 1;\n        par[b] = order[i];\n        order.push(b);\n      }\n  return { n, edges, ins, adj, order, par };\n}\n\n// A cold start: each Steiner point at the centroid of the three it was\n// inserted between.\nfunction initPos(T, X) {\n  const n = T.n;\n  X[2 * n] = (X[0] + X[2] + X[4]) / 3;\n  X[2 * n + 1] = (X[1] + X[3] + X[5]) / 3;\n  for (const [s, u, v, k] of T.ins)\n    for (let c = 0; c \u003c 2; c++) X[2 * s + c] = (X[2 * u + c] + X[2 * v + c] + X[2 * k + c]) / 3;\n}\n\n// Smith's iteration for a fixed topology: weight every edge by 1/length and\n// solve the tree's linear system exactly, from the leaves of the Steiner\n// points up and back down. The total length is convex in the Steiner points\n// and each step can only shorten it. Returns the length after iters steps.\nconst WB = new Float64Array(16), AA = new Float64Array(16), BX = new Float64Array(16), BY = new Float64Array(16);\nfunction smith(T, X, iters) {\n  const { n, edges, adj, order, par } = T;\n  let L = 0;\n  for (let it = 0; ; it++) {\n    L = 0;\n    for (let e = 0; e \u003c edges.length; e++) {\n      const a = edges[e][0], b = edges[e][1], d = hypot(X[2 * a] - X[2 * b], X[2 * a + 1] - X[2 * b + 1]);\n      L += d;\n      WB[e] = 1 / max(d, 1e-4);\n    }\n    if (it === iters) return L;\n    for (let i = order.length - 1; i >= 0; i--) {\n      const c = order[i];\n      let D = 0, bx = 0, by = 0, ap = 0;\n      for (const [b, e] of adj[c]) {\n        const w = WB[e];\n        if (b \u003c n) (D += w), (bx += w * X[2 * b]), (by += w * X[2 * b + 1]);\n        else if (b === par[c]) (D += w), (ap = w);\n        else (D += w * (1 - AA[b])), (bx += w * BX[b]), (by += w * BY[b]);\n      }\n      AA[c] = ap / D;\n      BX[c] = bx / D;\n      BY[c] = by / D;\n    }\n    for (const c of order) {\n      const p = par[c];\n      X[2 * c] = (p >= 0 ? AA[c] * X[2 * p] : 0) + BX[c];\n      X[2 * c + 1] = (p >= 0 ? AA[c] * X[2 * p + 1] : 0) + BY[c];\n    }\n  }\n}\n\n// The two other topologies across inner edge e: swap one neighbour of each\n// end. Both ends start at the edge's middle, nudged towards their new pairs.\nfunction swaps(T, X) {\n  const { n, edges } = T, out = [];\n  edges.forEach(([s1, s2], e) => {\n    if (s1 \u003c n || s2 \u003c n) return;\n    const nb = (s, o) => T.adj[s].filter(([q]) => q !== o);\n    const [[a], [b, eb]] = nb(s1, s2), [[c, ec], [d, ed]] = nb(s2, s1);\n    for (const [x, ex, y] of [[c, ec, d], [d, ed, c]]) {\n      // s1 keeps a and takes x from s2; s2 keeps y and takes b.\n      const ne = edges.map((p) => p.slice());\n      ne[eb] = [s2, b];\n      ne[ex] = [s1, x];\n      const T2 = prep(n, ne, T.ins), X2 = X.slice();\n      const mx = (X[2 * s1] + X[2 * s2]) / 2, my = (X[2 * s1 + 1] + X[2 * s2 + 1]) / 2;\n      for (const [s, p, q] of [[s1, a, x], [s2, b, y]]) {\n        const ux = (X[2 * p] + X[2 * q]) / 2 - mx, uy = (X[2 * p + 1] + X[2 * q + 1]) / 2 - my, l = hypot(ux, uy) || 1;\n        X2[2 * s] = mx + (0.4 * ux) / l;\n        X2[2 * s + 1] = my + (0.4 * uy) / l;\n      }\n      out.push([T2, X2]);\n    }\n  });\n  return out;\n}\n\n// The tree as drawn: edges shorter than 0.8 LED are contracted, and the key\n// lists for every edge left the terminals on its far side from terminal 0.\n// A change of topology that leaves the key alone does not show.\nfunction drawnKey(T, X) {\n  const { n, edges } = T, N = 2 * n - 2, par = [...Array(N).keys()];\n  const find = (x) => (par[x] === x ? x : (par[x] = find(par[x])));\n  const len = (e) => hypot(X[2 * e[0]] - X[2 * e[1]], X[2 * e[0] + 1] - X[2 * e[1] + 1]);\n  for (const e of edges) if (len(e) \u003c 0.8) par[find(e[0])] = find(e[1]);\n  const keep = edges.filter((e) => len(e) >= 0.8), ks = [];\n  for (const [a, b] of keep) {\n    let m = 0;\n    const seen = new Set([find(a), find(b)]), st = [find(b)];\n    while (st.length) {\n      const c = st.pop();\n      for (let t = 0; t \u003c n; t++) if (find(t) === c) m |= 1 \u003c\u003c t;\n      for (const [p, q] of keep) {\n        const fp = find(p), fq = find(q), o = fp === c ? fq : fq === c ? fp : -1;\n        if (o >= 0 && !seen.has(o)) seen.add(o), st.push(o);\n      }\n    }\n    if (m & 1) m = ((1 \u003c\u003c n) - 1) & ~m;\n    ks.push(m);\n  }\n  return ks.sort((x, y) => x - y).join(\",\");\n}\n\nfunction mst(n, X) {\n  const inT = new Uint8Array(n), d = new Float64Array(n).fill(1e9), from = new Int8Array(n).fill(-1), E = [];\n  d[0] = 0;\n  let L = 0;\n  for (let it = 0; it \u003c n; it++) {\n    let u = -1;\n    for (let i = 0; i \u003c n; i++) if (!inT[i] && (u \u003c 0 || d[i] \u003c d[u])) u = i;\n    inT[u] = 1;\n    L += d[u];\n    if (from[u] >= 0) E.push([from[u], u]);\n    for (let v = 0; v \u003c n; v++)\n      if (!inT[v]) {\n        const dd = hypot(X[2 * u] - X[2 * v], X[2 * u + 1] - X[2 * v + 1]);\n        if (dd \u003c d[v]) (d[v] = dd), (from[v] = u);\n      }\n  }\n  return { L, E };\n}\n\n// ---- Where the terminals are. On the strip, terminal i sits on a zigzag of\n// equilateral triangles of side a down the middle of the panel; free, it\n// follows two sines in x and two in y over the whole panel.\nfunction place(S, scatter) {\n  const n = S.n, a = min(60, 192 / (n - 1)), sep = (a * sqrt(3)) / 2, t = S.tau;\n  const sx = 32 + 2.5 * sin(0.043 * t), sy = 58 + 3 * sin(0.031 * t + 1);\n  for (let i = 0; i \u003c n; i++) {\n    const f = S.freq[i];\n    const wx = 0.035 * a * sin(f[0] * t + f[4]), wy = 0.035 * a * sin(f[1] * t + f[5]);\n    const lx = sx + (i % 2 ? 0.5 : -0.5) * sep + wx, ly = sy + (i - (n - 1) / 2) * (a / 2) + wy;\n    const fx = 32 + 26 * (0.62 * sin(f[2] * t + f[6]) + 0.38 * sin(f[3] * t * 1.7 + f[7])), fy = 58 + 50 * (0.62 * sin(f[3] * t + f[7]) + 0.38 * sin(f[2] * t * 1.3 + f[4]));\n    S.X[2 * i] = cl(lx + (fx - lx) * scatter, 3, 61);\n    S.X[2 * i + 1] = cl(ly + (fy - ly) * scatter, 4, 110);\n  }\n}\n\nfunction resolve(S) {\n  // Every topology from a cold start, the shortest kept and polished.\n  let best = null;\n  for (const T of topologies(S.n)) {\n    const X = S.X.slice();\n    initPos(T, X);\n    const L = smith(T, X, 15);\n    if (!best || L \u003c best[2]) best = [T, X, L];\n  }\n  S.T = best[0];\n  S.X = best[1];\n  S.L = smith(S.T, S.X, 60);\n  S.key = drawnKey(S.T, S.X);\n  S.sweep = 0;\n}\n\nexport function setup(params) {\n  const freq = [];\n  for (let i = 0; i \u003c 7; i++) {\n    const r = () => Math.random();\n    freq.push([TAU / (9 + 11 * r()), TAU / (9 + 11 * r()), 0.05 + 0.05 * r(), 0.05 + 0.05 * r(), TAU * r(), TAU * r(), TAU * r(), TAU * r()]);\n  }\n  params.s = { n: 0, tau: 0, t: 0, freq, X: null, T: null, L: 0, M: 1, pool: [], old: null, oldT: -9, boost: 0, sg: new Float64Array(80), F: new Float32Array(NP), rgb: new Float32Array(NP * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.t += d;\n  S.tau += (d * cl(k[1], 0.2, 3)) / 2;\n  const n = cl(round(k[2]), 4, 7), scatter = cl(k[3], 0, 1) ** 2;\n  if (n !== S.n) {\n    S.n = n;\n    S.X = new Float64Array(2 * (2 * n - 2));\n    place(S, scatter);\n    resolve(S);\n    S.old = null;\n    S.pool = [];\n  }\n  place(S, scatter);\n  S.L = smith(S.T, S.X, 4);\n  // Candidates: the swaps across each inner edge, warm; a share of all\n  // topologies, cold; and the near misses of earlier sweeps, warm. Smith's\n  // steps only shorten, so a candidate shorter than the polished tree on\n  // show is truly shorter.\n  let cand = null;\n  const better = (T, X, L) => {\n    if (L \u003c S.L * (1 - 2e-4) && (!cand || L \u003c cand[2])) cand = [T, X, L];\n  };\n  for (const [T2, X2] of swaps(S.T, S.X)) better(T2, X2, smith(T2, X2, 12));\n  for (const q of S.pool) {\n    q.X.set(S.X.subarray(0, 2 * n));\n    q.L = smith(q.T, q.X, 10);\n    q.age += d;\n    better(q.T, q.X, q.L);\n  }\n  S.pool = S.pool.filter((q) => q.age \u003c 3 && q.L \u003c S.L * 1.03 && q.T !== S.T);\n  const all = topologies(n), per = min(all.length, 40);\n  for (let i = 0; i \u003c per; i++) {\n    const T = all[(S.sweep + i) % all.length], X = S.X.slice();\n    initPos(T, X);\n    const L = smith(T, X, 15);\n    better(T, X, L);\n    // A cold start a little longer than the tree on show may still be the\n    // shorter one once it settles, so it stays in the pool for 3 s.\n    if (L \u003c S.L * 1.03 && T !== S.T && S.pool.length \u003c 8 && !S.pool.some((q) => q.T === T)) S.pool.push({ T, X, L, age: 0 });\n  }\n  S.sweep = (S.sweep + per) % all.length;\n  if (cand) {\n    const key = drawnKey(cand[0], cand[1]);\n    if (key !== S.key) {\n      // A visible flip: keep the old tree to fade out.\n      S.old = segs(S.T, S.X);\n      S.oldT = S.t;\n      S.boost = 1;\n    }\n    S.T = cand[0];\n    S.X = cand[1];\n    S.L = smith(S.T, S.X, 6);\n    S.key = key;\n  }\n  S.mst = mst(n, S.X);\n  S.M = S.mst.L;\n  S.boost *= exp(-d * 2.5);\n}\n\nfunction segs(T, X) {\n  const out = [];\n  for (const [a, b] of T.edges) {\n    const ax = X[2 * a], ay = X[2 * a + 1], bx = X[2 * b], by = X[2 * b + 1];\n    if (hypot(bx - ax, by - ay) > 0.05) out.push([ax, ay, bx, by]);\n  }\n  return out;\n}\n\n// Soft line, added.\nfunction line(rgb, ax, ay, bx, by, col, a, w, dash) {\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy, L = sqrt(L2), R = w + 1.5;\n  for (let y = max(0, floor(min(ay, by) - R)); y \u003c= min(H - 1, floor(max(ay, by) + R)); y++) {\n    // Only the stretch of the row the segment can reach.\n    let x0 = min(ax, bx), x1 = max(ax, bx);\n    if (abs(dy) > 1e-6) {\n      const t0 = cl((y + 0.5 - R - ay) / dy, 0, 1), t1 = cl((y + 0.5 + R - ay) / dy, 0, 1);\n      x0 = ax + min(t0, t1) * dx;\n      x1 = ax + max(t0, t1) * dx;\n      if (x0 > x1) [x0, x1] = [x1, x0];\n    }\n    for (let x = max(0, floor(x0 - R)); x \u003c= min(W - 1, floor(x1 + R)); x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay, t = L2 > 0 ? cl((px * dx + py * dy) / L2, 0, 1) : 0;\n      if (dash && (t * L) % 4 > 2) continue;\n      const dd = hypot(px - t * dx, py - t * dy), v = a * cl(w + 0.5 - dd, 0, 1);\n      if (v \u003c= 0) continue;\n      const o = 3 * (y * W + x);\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = max(rgb[o + c], col[c] * v);\n    }\n  }\n}\n\n// A disc laid over what is there.\nfunction spot(rgb, x, y, r, col, a) {\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - r - 1)); i \u003c= min(W - 1, floor(x + r + 1)); i++) {\n      const v = a * cl(r + 0.5 - hypot(i + 0.5 - x, j + 0.5 - y), 0, 1);\n      if (v \u003c= 0) continue;\n      const o = 3 * (j * W + i);\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = rgb[o + c] * (1 - v) + col[c] * v;\n    }\n}\n\n// Field brightness by distance from the tree, in steps of 0.05 LED.\nconst RING = new Float32Array(3000).map((_, i) => {\n  const dd = i / 20, ring = Math.pow(0.5 + 0.5 * cos((TAU * dd) / 6), 6) * 0.17 * exp(-dd / 26);\n  return max(dd > 2 ? ring : 0, 0.3 * exp((-dd * dd) / 5));\n});\n\n// 3 by 5 digits for the ratio.\nconst DIGITS = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7292, 0x7bef, 0x7bcf];\nfunction digit(rgb, n, x, y, col) {\n  for (let r = 0; r \u003c 5; r++)\n    for (let c = 0; c \u003c 3; c++)\n      if ((DIGITS[n] >> (14 - r * 3 - c)) & 1) {\n        const o = 3 * ((y + r) * W + x + c);\n        for (let q = 0; q \u003c 3; q++) rgb[o + q] = col[q];\n      }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const { rgb } = S, h0 = 0.5 + S.hue;\n  const tree = hsv(h0, 0.5, 1), glowC = hsv(h0 + 0.03, 0.75, 1), pink = hsv(h0 + 0.42, 0.5, 1), warm = hsv(h0 + 0.6, 0.15, 1), amber = hsv(h0 + 0.6, 0.75, 1), mstC = hsv(h0 + 0.1, 0.3, 0.62), bg = hsv(h0 + 0.12, 0.7, 0.03);\n  const sg = segs(S.T, S.X), ns = sg.length, SG = S.sg, core = [];\n  sg.forEach(([ax, ay, bx, by], i) => {\n    const dx = bx - ax, dy = by - ay;\n    SG.set([ax, ay, dx, dy, 1 / (dx * dx + dy * dy)], 5 * i);\n  });\n  // Distance from each LED to the tree: a glow along it and faint rings\n  // every 6 LEDs that spread out from it, looked up by distance. It is\n  // worked exactly on every second LED each way and within 3.5 LEDs of the\n  // tree, and read off its four exact neighbours everywhere else.\n  const F = S.F, dist = (px, py) => {\n    let m = 1e9;\n    for (let i = 0; i \u003c 5 * ns; i += 5) {\n      const ex0 = px - SG[i], ey0 = py - SG[i + 1], dx = SG[i + 2], dy = SG[i + 3];\n      let t = (ex0 * dx + ey0 * dy) * SG[i + 4];\n      t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n      const ex = ex0 - t * dx, ey = ey0 - t * dy, q = ex * ex + ey * ey;\n      if (q \u003c m) m = q;\n    }\n    return sqrt(m);\n  };\n  for (let y = 0; y \u003c H; y += 2) for (let x = 0; x \u003c W; x += 2) F[y * W + x] = dist(x + 0.5, y + 0.5);\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    const y0 = y & ~1, y1 = y0 + 2 \u003c H ? y0 + 2 : y0, fy = y & 1 ? 0.5 : 0;\n    for (let x = 0; x \u003c W; x++, p++) {\n      let dd = F[p];\n      if ((x | y) & 1) {\n        const x0 = x & ~1, x1 = x0 + 2 \u003c W ? x0 + 2 : x0, fx = x & 1 ? 0.5 : 0;\n        const a = F[y0 * W + x0], b = F[y0 * W + x1], c = F[y1 * W + x0], e = F[y1 * W + x1];\n        dd = min(a, b, c, e) \u003c 3.5 ? dist(x + 0.5, y + 0.5) : (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + e * fx) * fy;\n      }\n      const v = RING[min(RING.length - 1, (dd * 20) | 0)], o = 3 * p;\n      rgb[o] = bg[0] + glowC[0] * v;\n      rgb[o + 1] = bg[1] + glowC[1] * v;\n      rgb[o + 2] = bg[2] + glowC[2] * v;\n      // The tree's own line, 1.7 LEDs wide, laid on after the dashes.\n      if (dd \u003c 1.35) core.push(p, 1.35 - dd);\n    }\n  }\n  // The minimum spanning tree, dashed and faint.\n  for (const [a, b] of S.mst.E) line(rgb, S.X[2 * a], S.X[2 * a + 1], S.X[2 * b], S.X[2 * b + 1], mstC, 1, 0.45, true);\n  // A tree just left behind fades out amber.\n  const age = S.t - S.oldT;\n  if (S.old && age \u003c 1.2) for (const [ax, ay, bx, by] of S.old) line(rgb, ax, ay, bx, by, amber, 0.9 * (1 - age / 1.2), 0.7);\n  const bright = [0, 1, 2].map((c) => tree[c] + (1 - tree[c]) * 0.7 * S.boost);\n  for (let i = 0; i \u003c core.length; i += 2) {\n    const o = 3 * core[i], v = min(1, core[i + 1]);\n    for (let c = 0; c \u003c 3; c++) rgb[o + c] = rgb[o + c] * (1 - v) + bright[c] * v;\n  }\n  // Steiner points that stand apart from every terminal are pink dots.\n  for (let s = S.n; s \u003c 2 * S.n - 2; s++) {\n    const x = S.X[2 * s], y = S.X[2 * s + 1];\n    let near = 1e9;\n    for (let i = 0; i \u003c S.n; i++) near = min(near, hypot(x - S.X[2 * i], y - S.X[2 * i + 1]));\n    if (near > 1.2) spot(rgb, x, y, 1.5, pink, cl(near - 1.2, 0, 1));\n  }\n  for (let i = 0; i \u003c S.n; i++) spot(rgb, S.X[2 * i], S.X[2 * i + 1], 1.9, warm, 1);\n  // The ratio: a bar from root 3 over 2 at the left to 1 at the right, and\n  // the number above it.\n  // Smith's steps reach a degenerate tree slowly, so where the spanning tree\n  // is already the shortest the length can stand 0.04% above it: read 1.\n  const r = S.M > 0 ? min(1, S.L / S.M) : 1, fill = cl((r - FLOOR) / (1 - FLOOR), 0, 1);\n  for (let x = 3; x \u003c= 60; x++) {\n    const u = (x - 3) / 57, on = u \u003c= fill;\n    for (let y = 121; y \u003c= 124; y++) {\n      const o = 3 * (y * W + x), v = on ? 0.85 : 0.12;\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = (on ? tree : mstC)[c] * v;\n    }\n  }\n  for (let y = 119; y \u003c= 126; y++) for (let c = 0; c \u003c 3; c++) rgb[3 * (y * W + 2) + c] = pink[c];\n  const txt = r.toFixed(3);\n  let cx = 3;\n  for (const ch of txt) {\n    if (ch === \".\") {\n      for (let c = 0; c \u003c 3; c++) rgb[3 * (117 * W + cx) + c] = warm[c] * 0.85;\n      cx += 2;\n      continue;\n    }\n    digit(rgb, +ch, cx, 113, warm);\n    cx += 4;\n  }\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, floor(p / W), min(255, rgb[3 * p] * 255) | 0, min(255, rgb[3 * p + 1] * 255) | 0, min(255, rgb[3 * p + 2] * 255) | 0);\n}\n","autostereogram":"// ===== Patternflow pattern =====\n// Title:   Autostereogram\n// Family:  type\n// Idea:    A three-letter word stacked down the panel in capitals 42 LEDs wide and 38 tall is hidden in coloured random dots as a wall-eyed single-image stereogram, every LED copying the dot one period to its left except where a letter pulls that copy 2 LEDs nearer, so the dots look like nothing but noise until a band sweeps down and shows each LED against the LED one whole period to its left, dark where they agree and white where they differ, and the word appears letter by letter in that comparison, glows, fades, and a wipe of fresh dots brings the next word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random-dot stereogram (Béla Julesz, Bell System Technical Journal, 1960), single-image random-dot stereogram (Christopher Tyler and Maureen Clarke, made 1979, published at SPIE Stereoscopic Displays and Applications, 1990), after the wallpaper effect (David Brewster, 1844), pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Depth=-3..3, Period=11..15, Reveal=0..1\n//\n// Knob 1: Hue. Turns the four dot colours round the wheel together over a ground that stays deep indigo. At 0 they are teal, azure, violet and pale gold; at 0.5 rose, amber, lime and blue. The comparison stays warm white.\n// Knob 2: Depth. How many LEDs nearer than the period a letter's dots copy, rounded: at 2 (the opening) the word floats in front of the dots for a wall-eyed viewer, at -3 it sinks 3 LEDs behind them, and at 0 the dots are a plain wallpaper with nothing hidden, so the sweep finds no word.\n// Knob 3: Period. The wallpaper's repeat, 11 to 15 LEDs: 5.8 repeats across the 64 LEDs at 11, 4.3 at 15. A wider period needs the eyes to diverge further and widens the random strip down the left edge.\n// Knob 4: Reveal. Up to 0.1 (the opening 0.06) the comparison shows only in the band, 24 rows tall, that sweeps down at 40 rows a second, 3.8 s a sweep, once for each word; between sweeps the dots carry no trace of the word. Above 0.1 the comparison also shows over the whole panel at that strength: at 0.55 the dots are half dimmed and the word stands half white all the time, at 1 the dots are gone and only the comparison is left.\n\n// A random-dot stereogram hides a shape in dots that carry no outline at\n// all: the shape exists only as a shift between what the left eye and the\n// right eye see. Julesz made them as pairs; Tyler and Clarke put both views\n// in one picture. Each row starts with a strip of random dots one period\n// wide, and every later LED copies the LED one separation to its left. Where\n// the depth map is flat the separation is the period P and the row repeats\n// exactly. Inside a letter it is P - D, so for eyes diverged by P the dots\n// of the letter pair up at a different disparity and the letter stands out\n// D LEDs nearer (D > 0) or further (D \u003c 0).\n//\n// The comparison is the reveal: an LED that copied from P to its left\n// always equals the LED P to its left, and inside a letter it copied from\n// P - D, so it differs from the LED at P whenever the two dots were drawn\n// differently, 70% of the time here. Matching LEDs go dark, differing ones\n// light, and the letter appears without any free-viewing.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\n\n// Letter boxes: 42 x 38 LEDs from x = 19, three of them at rows 2, 45 and\n// 88. The box starts right of the widest separation (15 + 3), so a letter\n// never needs a dot left of the panel.\nconst BX = 19, BW = 42, BH = 38, TOPS = [2, 45, 88];\n// Timing in seconds: the wipe of new dots, the quiet before the sweep, the\n// sweep's speed in rows a second, the quiet after, and the glow's decay.\nconst WIPE = 0.5, PRE = 1.5, V = 40, POST = 2.0, TAU = 0.9, BAND = 24;\nconst LIT = 0.52; // share of dots that take one of the four colours\nconst SHADE = 0.025, SH2 = (2 * SHADE) / 255;\n\n// A bold 7 x 7 capital for each letter, drawn for this pattern. Each cell\n// is 6 x 5.43 LEDs; sampling the cells bilinearly and cutting at one half\n// rounds the corners and turns the stairs of A, S and Y into slopes.\nconst FONT = {\n  A: [\"..###..\", \".##.##.\", \"##...##\", \"##...##\", \"#######\", \"##...##\", \"##...##\"],\n  D: [\"#####..\", \"##..##.\", \"##...##\", \"##...##\", \"##...##\", \"##..##.\", \"#####..\"],\n  E: [\"#######\", \"##.....\", \"##.....\", \"######.\", \"##.....\", \"##.....\", \"#######\"],\n  F: [\"#######\", \"##.....\", \"##.....\", \"######.\", \"##.....\", \"##.....\", \"##.....\"],\n  H: [\"##...##\", \"##...##\", \"##...##\", \"#######\", \"##...##\", \"##...##\", \"##...##\"],\n  I: [\".#####.\", \"..###..\", \"..###..\", \"..###..\", \"..###..\", \"..###..\", \".#####.\"],\n  O: [\".#####.\", \"##...##\", \"##...##\", \"##...##\", \"##...##\", \"##...##\", \".#####.\"],\n  R: [\"######.\", \"##...##\", \"##...##\", \"######.\", \"##.##..\", \"##..##.\", \"##...##\"],\n  S: [\".#####.\", \"##...##\", \"##.....\", \".#####.\", \".....##\", \"##...##\", \".#####.\"],\n  T: [\"#######\", \"#######\", \"..###..\", \"..###..\", \"..###..\", \"..###..\", \"..###..\"],\n  Y: [\"##...##\", \"##...##\", \".##.##.\", \"..###..\", \"..###..\", \"..###..\", \"..###..\"],\n};\nconst WORDS = [\"SEE\", \"EYE\", \"AHA\", \"DOT\", \"HID\", \"FAR\", \"ODD\", \"TOE\"];\n\nfunction cell(g, i, j) {\n  return i \u003c 0 || j \u003c 0 || i > 6 || j > 6 ? 0 : g[j][i] === \"#\" ? 1 : 0;\n}\n\n// The depth map of one word: 1 inside a letter, 0 elsewhere.\nfunction wordMask(word) {\n  const m = new Uint8Array(W * H), cw = BW / 7, ch = BH / 7;\n  for (let n = 0; n \u003c 3; n++) {\n    const g = FONT[word[n]], top = TOPS[n];\n    for (let y = top; y \u003c top + BH; y++)\n      for (let x = BX; x \u003c BX + BW; x++) {\n        const u = (x - BX + 0.5) / cw - 0.5, v = (y - top + 0.5) / ch - 0.5;\n        const i = floor(u), j = floor(v), fu = u - i, fv = v - j;\n        const a = cell(g, i, j) * (1 - fu) + cell(g, i + 1, j) * fu;\n        const b = cell(g, i, j + 1) * (1 - fu) + cell(g, i + 1, j + 1) * fu;\n        if (a * (1 - fv) + b * fv > 0.5) m[y * W + x] = 1;\n      }\n  }\n  return m;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// New random dots for a row: the dot each LED would take if it had nothing\n// to copy, and a shade for each LED's three channels. The shade is the\n// LED's own and is never copied. At 2.5% either way the eye cannot tell\n// it and the dots still fuse, but no copy is then the same three bytes as\n// its source. Without it a compressor finds every repeat and the study's\n// complexity reads 0.46 bytes an LED for a field that looks like noise;\n// with it, 1.78.\nfunction roll(S, y) {\n  const o = y * W;\n  for (let x = 0; x \u003c W; x++) {\n    S.R[o + x] = Math.random() \u003c LIT ? 1 + floor(Math.random() * 4) : 0;\n    for (let c = 0; c \u003c 3; c++) S.sh[(o + x) * 3 + c] = floor(Math.random() * 256);\n  }\n}\n\n// One row of the stereogram, left to right.\nfunction build(S, y) {\n  const o = y * W, P = S.P, D = S.D, m = S.masks[S.rowWord[y]], R = S.R, I = S.idx;\n  for (let x = 0; x \u003c W; x++) {\n    const sep = P - D * m[o + x];\n    I[o + x] = x \u003c sep ? R[o + x] : I[o + x - sep];\n  }\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    P: 11, D: 2, hue: 0, floor: 0, word: 0, ct: 0, wiped: H,\n    R: new Uint8Array(W * H), sh: new Uint8Array(W * H * 3), idx: new Uint8Array(W * H),\n    glow: new Float32Array(W * H), cover: new Float32Array(H), rowWord: new Uint8Array(H),\n    masks: WORDS.map(wordMask), pal: new Float32Array(15),\n  });\n  for (let y = 0; y \u003c H; y++) roll(S, y), build(S, y);\n  return S;\n}\n\nconst CYCLE = PRE + (H + BAND) / V + POST;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 11, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const D = round(cl(k[1] == null ? 2 : k[1], -3, 3)), P = round(cl(k[2] || 11, 11, 15));\n  S.floor = cl(((k[3] == null ? 0.06 : k[3]) - 0.1) / 0.9, 0, 1);\n  if (D !== S.D || P !== S.P) {\n    S.D = D;\n    S.P = P;\n    for (let y = 0; y \u003c H; y++) build(S, y);\n  }\n  S.ct += d;\n  if (S.ct >= CYCLE) {\n    S.ct = 0;\n    S.word = (S.word + 1) % WORDS.length;\n    S.wiped = 0;\n  }\n  // The wipe: rows take new dots and the new word as its front passes.\n  const front = min(H, floor((S.ct / WIPE) * H));\n  while (S.wiped \u003c front) {\n    const y = S.wiped++;\n    S.rowWord[y] = S.word;\n    roll(S, y);\n    build(S, y);\n  }\n  // The band: each row's share of comparison, with a 3-row soft edge, and\n  // never less than the Reveal floor.\n  const yb = -BAND / 2 + (S.ct - PRE) * V, half = BAND / 2, on = S.ct > PRE;\n  const fall = exp(-d / TAU), I = S.idx, G = S.glow;\n  for (let y = 0; y \u003c H; y++) {\n    const c = max(S.floor, on ? cl((half - abs(y + 0.5 - yb)) / 3, 0, 1) : 0);\n    S.cover[y] = c;\n    const o = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      let g = G[o + x] * fall;\n      if (c > 0 && x >= S.P && I[o + x] !== I[o + x - S.P] && c > g) g = c;\n      G[o + x] = g;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // The ground and the four dot colours, levels 0..255.\n  const pal = S.pal, h = S.hue;\n  hsv(0.7, 0.85, 0.2, pal, 0);\n  hsv(0.47 + h, 0.9, 0.62, pal, 3);\n  hsv(0.58 + h, 0.8, 0.66, pal, 6);\n  hsv(0.77 + h, 0.65, 0.62, pal, 9);\n  hsv(0.13 + h, 0.5, 0.66, pal, 12);\n  const I = S.idx, G = S.glow, sh = S.sh;\n  for (let y = 0; y \u003c H; y++) {\n    const dim = 1 - 0.9 * S.cover[y], o = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      const i = o + x, p = I[i] * 3, g = G[i], j = i * 3;\n      // Each channel within 2.5% either side of the dot's colour.\n      let r = pal[p] * (1 - SHADE + sh[j] * SH2) * 255 * dim;\n      let gg = pal[p + 1] * (1 - SHADE + sh[j + 1] * SH2) * 255 * dim;\n      let b = pal[p + 2] * (1 - SHADE + sh[j + 2] * SH2) * 255 * dim;\n      r += g * 255;\n      gg += g * 236;\n      b += g * 200;\n      display.setPixel(x, y, round(cl(r, 0, 255)), round(cl(gg, 0, 255)), round(cl(b, 0, 255)));\n    }\n  }\n}\n","brick-factory":"// ===== Patternflow pattern =====\n// Title:   Brick Factory\n// Family:  geometry\n// Idea:    The complete bipartite graph K(m,n) is drawn with straight edges, every crossing of two edges lit as a spark: its vertices are thrown about the panel and wander so crossings flare up and go out all over it, then the drawing relaxes into Zarankiewicz's, m vertices split about the middle of a horizontal line and n of a vertical one, where the live count at the foot of the panel falls to the number Z(m,n) beside it and holds there before the vertices are thrown again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Turán's brick factory problem (Pál Turán, met in a labour camp's brick yard in 1944, published in his A note of welcome, Journal of Graph Theory, 1977), the drawing and the number Z(m,n) of Kazimierz Zarankiewicz (1954), shown to be the crossing number when min(m,n) \u003c= 6 by Daniel Kleitman (1970); 5 by 7 figures from Photon Disk (pattern round 70); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, m=4..6, n=6..9\n//\n// Knob 1: Hue. Turns the edge colours round the wheel. Each of the m vertices on the horizontal line gives its edges one colour, the m colours spread over two thirds of the wheel, blues lifted towards white so they read beside gold: at the opening 0 and m = 4 teal, blue, rose and gold, at 0.5 red, lime, sea green and azure. The sparks stay white-gold.\n// Knob 2: Speed. At 2 the vertices fly to new places in 1.2 s, wander for 2.6 s, relax into Zarankiewicz's drawing in 3 s and hold it 2.6 s, 9.4 s a round. Every time scales as 2 / Speed: 94 s a round at 0.2, 6.3 s at 3.\n// Knob 3: m. The vertices on the horizontal line, the smaller side: 4 at the opening, split 2 and 2 about the middle, 5 split 3 and 2, 6 split 3 and 3.\n// Knob 4: n. The vertices on the vertical line: 6 at the opening, split 3 above the middle and 3 below, up to 9, split 5 and 4. Z(m,n) runs from 12 for the opening K(4,6), which wanders through 22 to 84 crossings, to 96 for K(6,9), which wanders through 180 to 380.\n// Buttons: K1 tap throws the vertices again at once.\n\n// K(m,n) has m vertices on one side and n on the other and an edge from\n// every vertex of one side to every vertex of the other. In 1944 Turán\n// asked how few crossings the rail tracks between m kilns and n storage\n// yards could have. Zarankiewicz's drawing puts one side on the x axis and\n// the other on the y axis, each split as evenly as it goes about the origin.\n// Two edges cross only when they lie in the same quadrant and their ends\n// are in opposite orders, so the count is the sum over the quadrants of\n// C(p,2) C(q,2), which comes to\n//   Z(m,n) = floor(m/2) floor((m-1)/2) floor(n/2) floor((n-1)/2).\n// Kleitman proved no drawing does better when the smaller side is 6 or\n// less. That none does for any m and n is Zarankiewicz's conjecture, still\n// open.\n//\n// Every frame tests each pair of edges that share no vertex, up to 1080\n// pairs for K(6,9), and remembers which pairs crossed, so a crossing that\n// appears or goes out can flare where it happened.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst TAU = 2 * PI;\n// The middle of the drawing, and the box the vertices are thrown into.\nconst OX = 31.5, OY = 58, BX0 = 4, BX1 = 59.5, BY0 = 4, BY1 = 112;\n// Fly, wander, relax, hold, in seconds at Speed 2.\nconst DUR = [1.2, 2.6, 3, 2.6];\nconst MAXE = 54, FLARE = 0.55;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// 5 x 7 figures and Z from Photon Disk (pattern round 70), rows from the\n// top. A 3 x 5 Z is a 2 whose middle bar has shrunk to one LED, and the\n// two could not be told apart on the panel.\nconst GLYPH = {\n  0: \".###. #...# #..## #.#.# ##..# #...# .###.\", 1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", 2: \".###. #...# ....# ...#. ..#.. .#... #####\",\n  3: \"##### ...#. ..#.. ...#. ....# #...# .###.\", 4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\",\n  6: \"..##. .#... #.... ####. #...# #...# .###.\", 7: \"##### ....# ...#. ..#.. .#... .#... .#...\", 8: \".###. #...# #...# .###. #...# #...# .###.\",\n  9: \".###. #...# #...# .#### ....# ...#. .##..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\",\n};\nfor (const k in GLYPH) GLYPH[k] = GLYPH[k].replace(/ /g, \"\");\n\nconst zar = (m, n) => floor(m / 2) * floor((m - 1) / 2) * floor(n / 2) * floor((n - 1) / 2);\n\n// Zarankiewicz's places: the m vertices on the horizontal line, more of them\n// on the left, and the n on the vertical line, more of them above.\nfunction targets(S) {\n  const { m, n } = S, pl = Math.ceil(m / 2), pr = m - pl, qu = Math.ceil(n / 2), qd = n - qu;\n  const hs = 27.5 / pl, vs = (OY - 6) / qu;\n  S.tA = [];\n  for (let i = pl; i >= 1; i--) S.tA.push([OX - hs * i, OY]);\n  for (let i = 1; i \u003c= pr; i++) S.tA.push([OX + hs * i, OY]);\n  S.tB = [];\n  for (let j = qu; j >= 1; j--) S.tB.push([OX, OY - vs * j]);\n  for (let j = 1; j \u003c= qd; j++) S.tB.push([OX, OY + vs * j]);\n}\n\n// New places at random: the box is cut into 3 by 5 cells, at most one\n// vertex to a cell (m + n is 15 at most), so the throw spreads over the\n// whole panel; each vertex gets its own slow wander. The vertical side\n// draws its cells first, so a change of n moves the whole throw.\nfunction throwVertices(S) {\n  const all = [...S.B, ...S.A], cells = [...Array(15).keys()];\n  for (let i = cells.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1));\n    [cells[i], cells[j]] = [cells[j], cells[i]];\n  }\n  const cw = (BX1 - BX0) / 3, ch = (BY1 - BY0) / 5;\n  all.forEach((v, i) => {\n    const c = cells[i], x = BX0 + ((c % 3) + 0.15 + 0.7 * Math.random()) * cw, y = BY0 + (floor(c / 3) + 0.15 + 0.7 * Math.random()) * ch;\n    v.fx = v.x;\n    v.fy = v.y;\n    v.rx = x;\n    v.ry = y;\n    v.p1 = Math.random() * TAU;\n    v.p2 = Math.random() * TAU;\n    v.f1 = 0.25 + Math.random() * 0.3;\n    v.f2 = 0.2 + Math.random() * 0.3;\n    v.delay = Math.random() * 0.35;\n  });\n  S.phase = 0;\n  S.pt = 0;\n}\n\n// Each side goes to its places in the order it already has: the vertices of\n// the horizontal side sorted left to right, the vertical side top to bottom,\n// so the paths into the drawing cross as little as they can.\nfunction assign(S) {\n  const a = S.A.map((v, i) => i).sort((i, j) => S.A[i].x - S.A[j].x);\n  a.forEach((i, k) => ((S.A[i].tx = S.tA[k][0]), (S.A[i].ty = S.tA[k][1])));\n  const b = S.B.map((v, i) => i).sort((i, j) => S.B[i].y - S.B[j].y);\n  b.forEach((i, k) => ((S.B[i].tx = S.tB[k][0]), (S.B[i].ty = S.tB[k][1])));\n}\n\nfunction build(S, m, n) {\n  S.m = m;\n  S.n = n;\n  targets(S);\n  const mk = () => ({ x: OX, y: OY, fx: OX, fy: OY, rx: OX, ry: OY, tx: OX, ty: OY, p1: 0, p2: 0, f1: 0, f2: 0, delay: 0, sx: OX, sy: OY });\n  S.A = Array.from({ length: m }, mk);\n  S.B = Array.from({ length: n }, mk);\n  throwVertices(S);\n  // The first frame lands them straight on their thrown places.\n  for (const v of [...S.A, ...S.B]) (v.x = v.fx = v.rx), (v.y = v.fy = v.ry);\n  S.phase = 1;\n  S.pt = 0;\n  S.was.fill(0);\n  S.quiet = true;\n  S.flares.length = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, m: 0, n: 0, hue: 0, speed: 2, phase: 1, pt: 0, btn: false, A: [], B: [], tA: [], tB: [],\n    was: new Uint8Array(MAXE * MAXE), lastX: new Float32Array(MAXE * MAXE), lastY: new Float32Array(MAXE * MAXE),\n    cx: new Float32Array(1200), cy: new Float32Array(1200), count: 0, bump: 0, flares: [], quiet: true,\n    acc: new Float32Array(W * H * 3), spark: new Float32Array(W * H), col: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// Where each vertex is in the current phase: flying out along a smooth path,\n// wandering about its thrown place, or easing into Zarankiewicz's place.\nfunction place(S, sc) {\n  const ph = S.phase, u = S.pt / (DUR[ph] * sc), t = S.t;\n  for (const v of [...S.A, ...S.B]) {\n    const wx = 5 * sin(t * v.f1 * TAU * 0.5 + v.p1) + 2 * sin(t * v.f2 * TAU + v.p2);\n    const wy = 7 * sin(t * v.f2 * TAU * 0.5 + v.p2) + 2.5 * sin(t * v.f1 * TAU + v.p1);\n    if (ph === 0) {\n      // Each vertex sets off up to 0.17 of the flight late; its wander\n      // grows in as it lands.\n      const e = smooth(cl((u - v.delay * 0.5) / (1 - 0.175), 0, 1)), k = smooth(e);\n      v.x = v.fx + (v.rx + wx * k - v.fx) * e;\n      v.y = v.fy + (v.ry + wy * k - v.fy) * e;\n    } else if (ph === 1) {\n      v.x = v.rx + wx;\n      v.y = v.ry + wy;\n      v.sx = v.x;\n      v.sy = v.y;\n    } else if (ph === 2) {\n      const e = smooth(cl((u - v.delay) / (1 - 0.35), 0, 1));\n      v.x = v.sx + (v.tx - v.sx) * e;\n      v.y = v.sy + (v.ty - v.sy) * e;\n    } else {\n      v.x = v.tx;\n      v.y = v.ty;\n    }\n    v.x = cl(v.x, BX0, BX1);\n    v.y = cl(v.y, BY0, BY1);\n  }\n}\n\n// Every pair of edges a_i b_j and a_k b_l with i != k and j != l; a pair\n// that shares a vertex never crosses in a straight drawing. Each end of one\n// edge is tested for the side of the other it lies on; the edges cross when\n// both pairs of ends lie on opposite sides. Where a pair last crossed is\n// kept, so a crossing that goes out flares where it was.\nfunction crossings(S) {\n  const { A, B, m, n, was, lastX, lastY, cx, cy } = S;\n  let c = 0;\n  for (let i = 0; i \u003c m; i++)\n    for (let j = 0; j \u003c n; j++) {\n      const ax = A[i].x, ay = A[i].y, ex = B[j].x - ax, ey = B[j].y - ay, e1 = i * n + j;\n      for (let k = i + 1; k \u003c m; k++)\n        for (let l = 0; l \u003c n; l++) {\n          if (l === j) continue;\n          const kx = A[k].x, ky = A[k].y, fx = B[l].x - kx, fy = B[l].y - ky;\n          const d1 = ex * (ky - ay) - ey * (kx - ax), d2 = ex * (B[l].y - ay) - ey * (B[l].x - ax);\n          const d3 = fx * (ay - ky) - fy * (ax - kx), d4 = fx * (B[j].y - ky) - fy * (B[j].x - kx);\n          const e2 = k * n + l, key = e1 * MAXE + e2;\n          const hit = d1 * d2 \u003c 0 && d3 * d4 \u003c 0;\n          if (hit) {\n            const s = d3 / (d3 - d4), x = ax + s * ex, y = ay + s * ey;\n            cx[c] = x;\n            cy[c] = y;\n            c++;\n            lastX[key] = x;\n            lastY[key] = y;\n          }\n          if (hit !== !!was[key] && !S.quiet && S.flares.length \u003c 400) S.flares.push({ x: lastX[key], y: lastY[key], age: 0, on: hit });\n          was[key] = hit ? 1 : 0;\n        }\n    }\n  S.quiet = false;\n  return c;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 6], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const m = round(cl(k[2], 4, 6)), n = round(cl(k[3], 6, 9)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (m !== S.m || n !== S.n) build(S, m, n);\n  if (btn && !S.btn) throwVertices(S);\n  S.btn = btn;\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  if (S.pt >= DUR[S.phase] * sc) {\n    S.pt = 0;\n    if (S.phase === 3) throwVertices(S);\n    else {\n      S.phase++;\n      if (S.phase === 2) assign(S);\n    }\n  }\n  place(S, sc);\n  const c = crossings(S);\n  if (c !== S.count) S.bump = 1;\n  S.count = c;\n  S.bump = max(0, S.bump - d / 0.35);\n  for (const f of S.flares) f.age += d / sc;\n  S.flares = S.flares.filter((f) => f.age \u003c FLARE);\n}\n\n// An antialiased line, added in: along the long axis each step lights the\n// LEDs across it by a tent 1.3 LEDs either side of the true line, measured\n// square to the line, so steep and shallow lines weigh the same.\nfunction line(acc, x0, y0, x1, y1, c, w) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0, lim = st ? H - 1 : W - 1, k = 1 / sqrt(1 + s * s);\n  for (let x = max(0, round(x0)); x \u003c= min(lim, round(x1)); x++) {\n    const y = y0 + (x - x0) * s;\n    for (let iy = floor(y - 1.8); iy \u003c= floor(y + 1.8); iy++) {\n      const e = 1 - (abs(iy + 0.5 - y) * k) / 1.3;\n      if (e > 0) add(acc, st ? iy : x, st ? x : iy, c, w * e * k * 1.3);\n    }\n  }\n}\nfunction add(acc, x, y, c, w) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  acc[k] += c[0] * w;\n  acc[k + 1] += c[1] * w;\n  acc[k + 2] += c[2] * w;\n}\n// A soft round light of radius r about x, y.\nfunction glow(acc, x, y, r, c, w) {\n  for (let py = floor(y - r); py \u003c= floor(y + r); py++)\n    for (let px = floor(x - r); px \u003c= floor(x + r); px++) {\n      const dd = sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2) / r;\n      if (dd \u003c 1) add(acc, px, py, c, w * (1 - dd) * (1 - dd));\n    }\n}\nfunction ring(acc, x, y, r, c, w) {\n  for (let py = floor(y - r - 1); py \u003c= floor(y + r + 1); py++)\n    for (let px = floor(x - r - 1); px \u003c= floor(x + r + 1); px++) {\n      const e = abs(sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2) - r);\n      if (e \u003c 1) add(acc, px, py, c, w * (1 - e));\n    }\n}\nfunction text(acc, str, x, y, c, w) {\n  for (const ch of str) {\n    const g = GLYPH[ch];\n    if (g) for (let i = 0; i \u003c 35; i++) if (g[i] === \"#\") add(acc, x + (i % 5), y + floor(i / 5), c, w);\n    x += 6;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.A.length) return;\n  const acc = S.acc, col = S.col, { A, B, m, n } = S;\n  acc.fill(0);\n  // The edges, coloured by their end on the horizontal side.\n  const pal = [];\n  for (let i = 0; i \u003c m; i++) {\n    const c = [0, 0, 0];\n    hsv(S.hue + 0.47 + (0.66 * i) / max(1, m - 1), 0.78, 1, c);\n    // Blue and violet are dim on the panel next to gold and teal: lift\n    // them towards white until their luminance is at least 0.45.\n    const lum = 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2], up = max(0, 0.45 - lum) * 0.7;\n    for (let q = 0; q \u003c 3; q++) c[q] += (1 - c[q]) * up;\n    pal.push(c);\n  }\n  for (let i = 0; i \u003c m; i++) for (let j = 0; j \u003c n; j++) line(acc, A[i].x, A[i].y, B[j].x, B[j].y, pal[i], 0.5);\n  // Sparks at the crossings, kept on a layer of their own where the\n  // brightest wins, so a knot of crossings reads as many points and not as\n  // one white blot. Then the flares of those that just came or went.\n  const hot = [1, 0.86, 0.55], white = [1, 1, 1], sp = S.spark;\n  sp.fill(0);\n  for (let c = 0; c \u003c S.count; c++) {\n    const x = S.cx[c], y = S.cy[c];\n    for (let py = floor(y - 1.5); py \u003c= floor(y + 1.5); py++)\n      for (let px = floor(x - 1.5); px \u003c= floor(x + 1.5); px++) {\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const dd = sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2), v = dd \u003c 0.75 ? 1 : 0.45 * max(0, 1 - (dd - 0.75) / 1.3);\n        if (v > sp[py * W + px]) sp[py * W + px] = v;\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const v = sp[p];\n    if (!v) continue;\n    const k = p * 3, wv = v > 0.9 ? 1 : 0;\n    acc[k] += hot[0] * v + 0.2 * wv;\n    acc[k + 1] += hot[1] * v + 0.3 * wv;\n    acc[k + 2] += hot[2] * v + 0.45 * wv;\n  }\n  for (const f of S.flares) {\n    const u = f.age / FLARE, fade = (1 - u) * (1 - u);\n    if (f.on) ring(acc, f.x, f.y, 1 + 5 * u, hot, 1.1 * fade);\n    else glow(acc, f.x, f.y, 2 + 3 * u, hot, 1.1 * fade);\n  }\n  // The vertices: the horizontal side large in its colour, the vertical\n  // side small and white.\n  for (let i = 0; i \u003c m; i++) {\n    glow(acc, A[i].x, A[i].y, 3.2, pal[i], 1.6);\n    glow(acc, A[i].x, A[i].y, 1.6, white, 0.9);\n  }\n  for (const v of B) glow(acc, v.x, v.y, 2.4, white, 1.3);\n  // The count at the foot, left, against Z(m,n), right. The count flashes\n  // when it changes and turns gold when it is down to Z.\n  const z = zar(m, n), at = S.count === z;\n  hsv(S.hue + 0.47, 0.25, 1, col);\n  const cc = at ? hot : col;\n  text(acc, String(S.count), 1, 119, cc, 0.75 + 0.25 * S.bump);\n  const zs = String(z);\n  text(acc, zs, 64 - 6 * zs.length, 119, at ? hot : col, at ? 0.95 : 0.6);\n  text(acc, \"Z\", 64 - 6 * zs.length - 9, 119, col, 0.3);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[k])) | 0, (255 * min(1, acc[k + 1])) | 0, (255 * min(1, acc[k + 2])) | 0);\n    }\n}\n","eye-chart":"// ===== Patternflow pattern =====\n// Title:   Eye Chart\n// Family:  type\n// Idea:    A back-lit letter chart stands the full height of the panel, eight rows of Sloan letters from one letter 25 LEDs tall down to five letters 5 LEDs tall with one LED to a stroke, each row 1.26 times the one below as on a logMAR chart, and lens after lens wipes across it as in a phoropter, blurring the chart by a disc as wide as the defocus that lens leaves, while a pointer reads down the rows letter by letter, marking blue the letters a noisy reader still tells apart from the ten letters blurred the same way and red the ones it takes for another, and stops at the row it fails, until the last lens of the series leaves the chart sharp, the black occluder sweeps across and a new chart goes up.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Snellen chart (Herman Snellen, Optotypi ad visum determinandum, 1862), the ten Sloan letters (Louise Sloan, 1959) and the logMAR chart's rows a tenth of a log unit apart (Ian Bailey and Jan Lovie, 1976), the letters drawn for this pattern on Sloan's 5 by 5 grid, pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Error=0.5..2.5, Speed=0.2..3, Glare=0..1, Duochrome=0..1\n//\n// Knob 1: Error. The eye's myopia, 0.5 to 2.5 diopters. One LED is one minute of arc and the pupil 3 mm, so each diopter left uncorrected blurs the chart by a disc 5.2 LEDs in radius. A series of lenses closes in on the error: at 0.5 they are 0, 0.25, 0.5, 0.75 and 0.5 diopters, blur radii 2.6, 1.3, 0, 1.3 and 0, and the bare eye reads down to the 10 or 7.9 LED row; at 2.5 the bare eye sees a disc 12.9 LEDs in radius and fails even the top letter, and the series takes 7 lenses.\n// Knob 2: Speed. At 2 a lens wipes in over 0.45 s, the reader looks for 0.35 s, spends 0.18 s on a letter and holds its result 0.8 s (2.2 s after the last lens), so a lens takes 3 to 4 s and a series of five about 22 s. At 0.2 all of it is ten times slower, at 3 two thirds as long.\n// Knob 3: Glare. A veil of light over the chart: at 0 the letters are black, at 1 they keep 35 percent of their contrast, and the reader sees that too. Through the right lens it still gets nine letters in ten on the 5 LED row, but a quarter diopter off it stops at the 7.9 LED row where it read to the bottom, and half a diopter off at the 12.6 or 15.8 row instead of the 10.\n// Knob 4: Duochrome. Up from 0.1 the light box turns red on the left half and green on the right, fully at 1. The eye focuses red behind green, half a diopter apart, so the red half is blurred as by a quarter diopter less myopia and the green as by a quarter more: red sharper while the lens is too weak, green sharper when it is too strong, both equally soft at the right one.\n// Buttons: K1 tap starts a new series on a new chart.\n\n// A letter is legible when what the eye sees of it is closer to that letter\n// than to any of the other nine. The reader here does that literally: it\n// blurs the patch of chart around the letter with the same disc, blurs each\n// of the ten Sloan letters alone at the same size and place, and takes the\n// one with the smallest difference, summed over the LEDs with exponent 4\n// (Minkowski pooling, as models of threshold vision add up small\n// differences), after adding noise to each distance. A sharp C and O differ\n// by one LED at the bottom row; blurred by a disc of radius 1.3 that LED is\n// spread over eight, and the reader starts to confuse them.\n//\n// The eye is myopic and does not accommodate, so a lens a quarter diopter\n// too strong blurs it as much as one a quarter too weak.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, pow, log, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Defocus blur: a disc of angular diameter pupil x diopters radians. With a\n// 3 mm pupil and one LED to a minute of arc, 5.16 LEDs of radius a diopter.\nconst KAPPA = 0.003 * (180 / PI) * 60 * 0.5;\nconst NOISE = 0.2;\n// Timings at Speed 2.\nconst T_FLIP = 0.45, T_LOOK = 0.35, T_LETTER = 0.18, T_HOLD = 0.8, T_LAST = 2.2;\n\n// ---- The ten Sloan letters. At the bottom row, 5 LEDs tall, each is a 5x5\n// bitmap, one LED to a stroke (16 is the left column, rows from the top).\n// The C is the Landolt ring with its gap to the right, one stroke wide, so C\n// and O differ by one LED there.\nconst SLOAN = \"CDHKNORSVZ\";\nconst BITS = [\n  14, 17, 16, 17, 14,\n  30, 17, 17, 17, 30,\n  17, 17, 31, 17, 17,\n  17, 18, 28, 18, 17,\n  17, 25, 21, 19, 17,\n  14, 17, 17, 17, 14,\n  30, 17, 30, 18, 17,\n  15, 16, 14, 1, 30,\n  17, 17, 17, 10, 4,\n  31, 2, 4, 8, 31,\n];\n// Bigger rows draw the same letters from shapes on the 5 by 5 grid, one unit\n// to a stroke: boxes, elliptical rings and straight bars.\nconst box = (u, v, x0, y0, x1, y1) => u >= x0 && u \u003c= x1 && v >= y0 && v \u003c= y1;\nfunction ring(u, v, cx, cy, ao, bo, ai, bi) {\n  const x = u - cx, y = v - cy;\n  return (x * x) / (ao * ao) + (y * y) / (bo * bo) \u003c= 1 && (x * x) / (ai * ai) + (y * y) / (bi * bi) >= 1;\n}\nfunction bar(u, v, ax, ay, bx, by, hw) {\n  const dx = bx - ax, dy = by - ay, t = cl(((u - ax) * dx + (v - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  const ex = u - ax - t * dx, ey = v - ay - t * dy;\n  return ex * ex + ey * ey \u003c= hw * hw;\n}\nconst O_ = (u, v) => ring(u, v, 2.5, 2.5, 2.5, 2.5, 1.5, 1.5);\nfunction inside(c, u, v) {\n  switch (c) {\n    case 0: return O_(u, v) && !(u > 2.5 && abs(v - 2.5) \u003c 0.5);\n    case 1: return box(u, v, 0, 0, 1, 5) || (u \u003c= 2.5 ? box(u, v, 0, 0, 2.5, 1) || box(u, v, 0, 4, 2.5, 5) : O_(u, v));\n    case 2: return box(u, v, 0, 0, 1, 5) || box(u, v, 4, 0, 5, 5) || box(u, v, 0, 2, 5, 3);\n    case 3: return box(u, v, 0, 0, 1, 5) || bar(u, v, 1, 3.2, 5, -0.4, 0.56) || bar(u, v, 2.4, 2.2, 5, 5.4, 0.56);\n    case 4: return box(u, v, 0, 0, 1, 5) || box(u, v, 4, 0, 5, 5) || bar(u, v, 0.6, 0, 4.4, 5, 0.6);\n    case 5: return O_(u, v);\n    case 6: return box(u, v, 0, 0, 1, 5) || (u \u003c= 2.5 ? box(u, v, 0, 0, 2.5, 1) || box(u, v, 0, 2, 2.5, 3) : ring(u, v, 2.5, 1.5, 2.5, 1.5, 1.5, 0.5)) || bar(u, v, 2.6, 2.8, 4.6, 5.3, 0.56);\n    case 7: return (ring(u, v, 2.5, 1.5, 2.5, 1.5, 1.5, 0.5) && !(u > 2.5 && v > 1.5)) || (ring(u, v, 2.5, 3.5, 2.5, 1.5, 1.5, 0.5) && !(u \u003c 2.5 && v \u003c 3.5));\n    case 8: return bar(u, v, 0.5, -1, 2.5, 5, 0.6) || bar(u, v, 4.5, -1, 2.5, 5, 0.6);\n    default: return box(u, v, 0, 0, 5, 1) || box(u, v, 0, 4, 5, 5) || bar(u, v, 4.3, 1, 0.7, 4, 0.6);\n  }\n}\n// Ink coverage of letter c, h LEDs tall, its corner at (x0, y0), into buf.\nfunction stamp(buf, bw, bh, c, x0, y0, h) {\n  if (h === 5) {\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 5; q++) {\n        const x = x0 + q, y = y0 + r;\n        if ((BITS[c * 5 + r] >> (4 - q)) & 1 && x >= 0 && x \u003c bw && y >= 0 && y \u003c bh) buf[y * bw + x] = 1;\n      }\n    return;\n  }\n  const k = 5 / h;\n  for (let y = max(0, floor(y0)); y \u003c min(bh, ceil(y0 + h)); y++)\n    for (let x = max(0, floor(x0)); x \u003c min(bw, ceil(x0 + h)); x++) {\n      let n = 0;\n      for (let j = 0; j \u003c 4; j++) {\n        const v = (y + (j + 0.5) / 4 - y0) * k;\n        if (v \u003c 0 || v > 5) continue;\n        for (let i = 0; i \u003c 4; i++) {\n          const u = (x + (i + 0.5) / 4 - x0) * k;\n          if (u >= 0 && u \u003c= 5 && inside(c, u, v)) n++;\n        }\n      }\n      if (n) buf[y * bw + x] = max(buf[y * bw + x], n / 16);\n    }\n}\n\n// ---- The chart: eight rows, logMAR 0.7 at the top to 0.0 at the bottom,\n// each 10^0.1 = 1.259 times the one below: 25.1, 19.9, 15.8, 12.6, 10, 7.9,\n// 6.3 and 5 LEDs. Letters stand one letter width apart as Bailey and Lovie\n// spaced them, so a row holds as many as fit, 1 at the top and 5 below 7\n// LEDs. Rows sit about 3 LEDs apart with the pointer's line in the gap.\nconst ROWS = (() => {\n  const hs = [];\n  for (let k = 7; k >= 0; k--) {\n    const h = 5 * pow(10, k / 10);\n    hs.push(abs(h - round(h)) \u003c 0.06 ? round(h) : h);\n  }\n  const gap = (125 - hs.reduce((a, b) => a + b, 0)) / 7, rows = [];\n  let y = 0;\n  for (let i = 0; i \u003c 8; i++) {\n    const h = hs[i], top = round(y), n = min(5, floor((62 / h + 1) / 2)), left = (W - (2 * n - 1) * h) / 2, xs = [];\n    for (let j = 0; j \u003c n; j++) xs.push(round(left + 2 * j * h));\n    rows.push({ h, top, n, xs, w: max(1, round(h)), mark: round(top + h + gap / 2 - 0.5) });\n    y += h + gap;\n  }\n  return rows;\n})();\n\n// ---- Disc blur. Each row of the disc is a span of the image row, summed\n// from prefix sums at fractional ends, so the disc grows smoothly with its\n// radius; rows near the rim come in with partial weight. Off the panel is\n// no ink.\nfunction kernel(r) {\n  const R = ceil(r + 0.5), dy = [], hw = [], wt = [];\n  let norm = 0;\n  for (let d = -R; d \u003c= R; d++) {\n    const w = d === 0 ? 1 : cl(r - abs(d) + 0.5, 0, 1);\n    if (w \u003c= 0) continue;\n    const h = sqrt(max(0, r * r - d * d));\n    dy.push(d), hw.push(h), wt.push(w);\n    norm += w * (2 * h + 1);\n  }\n  return { dy, hw, wt, inv: 1 / norm, R };\n}\nfunction prefix(src, w, h, pre) {\n  for (let y = 0; y \u003c h; y++) {\n    const o = y * (w + 1);\n    let a = 0;\n    pre[o] = 0;\n    for (let x = 0; x \u003c w; x++) pre[o + x + 1] = a += src[y * w + x];\n  }\n}\n// Ink of row y from 0 to t.\nfunction upto(src, pre, w, y, t) {\n  if (t \u003c= 0) return 0;\n  if (t >= w) return pre[y * (w + 1) + w];\n  const i = t | 0;\n  return pre[y * (w + 1) + i] + (t - i) * src[y * w + i];\n}\nfunction blurAt(src, pre, w, h, x, y, K) {\n  let s = 0;\n  for (let k = 0; k \u003c K.dy.length; k++) {\n    const yy = y + K.dy[k];\n    if (yy \u003c 0 || yy >= h) continue;\n    s += K.wt[k] * (upto(src, pre, w, yy, x + 1 + K.hw[k]) - upto(src, pre, w, yy, x - K.hw[k]));\n  }\n  return s * K.inv;\n}\n\nfunction gauss() {\n  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n}\n\n// A new chart: each row draws its letters without repeating one.\nfunction newChart(s) {\n  s.chart = ROWS.map((row) => {\n    const pool = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n    for (let i = 9; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [pool[i], pool[j]] = [pool[j], pool[i]];\n    }\n    return pool.slice(0, row.n);\n  });\n  s.ink.fill(0);\n  ROWS.forEach((row, i) => row.xs.forEach((x, j) => stamp(s.ink, W, H, s.chart[i][j], x, row.top, row.h)));\n  prefix(s.ink, W, H, s.pre);\n  s.tkey = -1;\n}\n\n// The lenses a series tries for an error E, in quarter diopters: none, half\n// of E, three quarters, then up a quarter at a time to E, one too strong,\n// and back to E.\nfunction plan(E) {\n  const q = (v) => round(v * 4) / 4, out = [0];\n  const push = (v) => out[out.length - 1] !== v && out.push(v);\n  push(q(E / 2));\n  push(q((3 * E) / 4));\n  for (let v = out[out.length - 1] + 0.25; v \u003c q(E) - 1e-6; v += 0.25) push(v);\n  push(q(E));\n  push(q(E) + 0.25);\n  push(q(E));\n  return out;\n}\n\n// A new series starts behind the occluder, the phoropter's black disc: a\n// new chart goes up and the first lens, none, wipes in from the dark.\nfunction newSeries(s) {\n  newChart(s);\n  s.Eplan = s.E;\n  s.lenses = plan(s.E);\n  s.li = 0;\n  s.L = 0;\n  s.best = -1;\n  clearMarks(s);\n  s.dark = true;\n  s.phase = \"flip\";\n  s.pt = 0;\n}\nfunction clearMarks(s) {\n  s.marks = ROWS.map((row) => new Array(row.n).fill(0));\n  s.ri = -1;\n  s.lj = -1;\n}\n\n// The blur radius a lens of power P leaves, on the red (-1), plain (0) or\n// green (+1) side.\nconst radius = (s, P, side) => KAPPA * abs(s.E - P + side * 0.25 * s.u);\n\n// The reader's answer for letter j of row ri. It looks at the letter's own\n// cell: its box, a LED above and below (the rows are 3 LEDs apart) and half\n// a letter to each side, where its neighbours' blur can reach in and crowd it.\nfunction read(s, ri, j) {\n  const row = ROWS[ri], h = row.h, x0 = row.xs[j], y0 = row.top;\n  const f = cl((32 - x0) / h, 0, 1);\n  const r = f * radius(s, s.L, -1) + (1 - f) * radius(s, s.L, 1);\n  const K = kernel(r), M = K.R + 1, n = ceil(h) + 2 * M, T = s.tpl;\n  const ex = min(M, ceil(h / 2)), wx = M - ex, wy = M - 1, ww = ceil(h) + 2 * ex, wh = ceil(h) + 2;\n  const key = ri * 100000 + round(r * 200);\n  if (s.tkey !== key) {\n    s.tkey = key;\n    for (let c = 0; c \u003c 10; c++) {\n      s.ink2.fill(0, 0, n * n);\n      stamp(s.ink2, n, n, c, M, M, h);\n      prefix(s.ink2, n, n, s.pre2);\n      for (let y = 0; y \u003c wh; y++) for (let x = 0; x \u003c ww; x++) T[c][y * ww + x] = blurAt(s.ink2, s.pre2, n, n, wx + x, wy + y, K);\n    }\n  }\n  const P = s.patch;\n  for (let y = 0; y \u003c wh; y++) for (let x = 0; x \u003c ww; x++) P[y * ww + x] = blurAt(s.ink, s.pre, W, H, x0 - M + wx + x, y0 - M + wy + y, K);\n  let best = 0, bs = 1e9;\n  for (let c = 0; c \u003c 10; c++) {\n    let d4 = 0;\n    for (let i = 0; i \u003c ww * wh; i++) {\n      const e = s.c * (P[i] - T[c][i]), e2 = e * e;\n      d4 += e2 * e2;\n    }\n    const score = sqrt(sqrt(d4)) + NOISE * gauss();\n    if (score \u003c bs) (bs = score), (best = c);\n  }\n  return best;\n}\n\nexport function setup(params) {\n  const s = (params.s = {\n    E: 0.5, c: 1, u: 0, L: 0, Lold: 0, pt: 0, phase: \"flip\", dark: true, btn: false,\n    ink: new Float32Array(W * H), pre: new Float32Array(H * (W + 1)),\n    ink2: new Float32Array(64 * 64), pre2: new Float32Array(64 * 65), patch: new Float32Array(64 * 64),\n    tpl: Array.from({ length: 10 }, () => new Float32Array(64 * 64)),\n    rgb: new Float32Array(W * H * 3), colK: new Array(W), colDark: new Uint8Array(W), started: false,\n  });\n  return s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0.5, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.E = cl(k[0] == null ? 0.5 : k[0], 0.5, 2.5);\n  const sc = 2 / cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  s.c = 1 - 0.65 * cl(k[2] || 0, 0, 1);\n  s.u = smooth((cl(k[3] == null ? 0.06 : k[3], 0, 1) - 0.1) / 0.9);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  // A new error or a tap closes the occluder for a new series.\n  if (!s.started) (s.started = true), newSeries(s);\n  else if (((btn && !s.btn) || abs(s.E - s.Eplan) > 0.1) && s.phase !== \"close\") (s.phase = \"close\"), (s.pt = 0);\n  s.btn = btn;\n  s.pt += d;\n  if (s.phase === \"close\") {\n    if (s.pt >= T_FLIP * sc) newSeries(s);\n  } else if (s.phase === \"flip\") {\n    if (s.pt >= T_FLIP * sc) (s.phase = \"look\"), (s.pt = 0), (s.Lold = s.L), (s.dark = false);\n  } else if (s.phase === \"look\") {\n    if (s.pt >= T_LOOK * sc) {\n      s.phase = \"read\";\n      s.pt = 0;\n      s.ri = s.li === 0 ? 0 : max(0, min(s.best, 6) - 1);\n      s.lj = 0;\n      s.marks[s.ri][0] = read(s, s.ri, 0) === s.chart[s.ri][0] ? 1 : 2;\n      s.best = -1;\n    }\n  } else if (s.phase === \"read\") {\n    if (s.pt >= T_LETTER * sc) {\n      s.pt = 0;\n      const row = ROWS[s.ri];\n      if (++s.lj >= row.n) {\n        // More than half right passes the row.\n        const right = s.marks[s.ri].filter((m) => m === 1).length;\n        if (right * 2 > row.n) s.best = s.ri;\n        if (right * 2 > row.n && s.ri \u003c 7) (s.ri++), (s.lj = 0);\n        else return void ((s.phase = \"hold\"), (s.lj = -1));\n      }\n      s.marks[s.ri][s.lj] = read(s, s.ri, s.lj) === s.chart[s.ri][s.lj] ? 1 : 2;\n    }\n  } else if (s.pt >= (s.li === s.lenses.length - 1 ? T_LAST : T_HOLD) * sc) {\n    if (s.li === s.lenses.length - 1) return void ((s.phase = \"close\"), (s.pt = 0));\n    s.li++;\n    s.Lold = s.L;\n    s.L = s.lenses[s.li];\n    const keep = s.best;\n    clearMarks(s);\n    s.best = keep;\n    s.phase = \"flip\";\n    s.pt = 0;\n  }\n  s.sc = sc;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.started) return;\n  const sc = s.sc || 1;\n  // A lens wipes in from the left: columns it has passed see the new one,\n  // the rest the old lens, or the dark of the occluder.\n  const moving = s.phase === \"flip\" || s.phase === \"close\";\n  const wipe = moving ? -6 + 76 * smooth(s.pt / (T_FLIP * sc)) : 999;\n  const Ks = [[kernel(radius(s, s.Lold, -1)), kernel(radius(s, s.Lold, 1))], [kernel(radius(s, s.L, -1)), kernel(radius(s, s.L, 1))]];\n  const red = [255, 36, 18], green = [40, 255, 70], white = [255, 246, 232], u = s.u, c = s.c, rgb = s.rgb;\n  for (let x = 0; x \u003c W; x++) {\n    const passed = x \u003c wipe;\n    s.colDark[x] = s.phase === \"close\" ? +passed : s.phase === \"flip\" && s.dark ? +!passed : 0;\n    s.colK[x] = Ks[passed || s.phase === \"close\" ? 1 : 0][x \u003c 32 ? 0 : 1];\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const vy = (y - 63.5) / 64;\n    for (let x = 0; x \u003c W; x++) {\n      if (s.colDark[x]) {\n        rgb.fill(0, (y * W + x) * 3, (y * W + x) * 3 + 3);\n        continue;\n      }\n      const b = blurAt(s.ink, s.pre, W, H, x, y, s.colK[x]);\n      const vx = (x - 31.5) / 32, lit = 0.8 * (1 - 0.13 * vx * vx - 0.1 * vy * vy) * (1 - c * b);\n      const tint = x \u003c 32 ? red : green, j = (y * W + x) * 3;\n      let dark = 1;\n      if (moving) dark = 1 - 0.6 * exp(-(((x - wipe) / 2.2) ** 2));\n      for (let q = 0; q \u003c 3; q++) rgb[j + q] = (white[q] + (tint[q] - white[q]) * u) * lit * dark;\n    }\n  }\n  // The pointer's line: blue under a letter read right, red under a\n  // mistake, amber under the letter being read.\n  ROWS.forEach((row, i) => {\n    row.xs.forEach((x0, j) => {\n      const m = s.marks[i][j], now = s.phase === \"read\" && i === s.ri && j === s.lj;\n      if (!m && !now) return;\n      const col = now && s.pt \u003c (T_LETTER * sc) / 2 ? [255, 150, 0] : m === 1 ? [20, 70, 255] : [235, 20, 40];\n      for (let x = x0; x \u003c min(W, x0 + row.w); x++) {\n        if (s.colDark[x]) continue;\n        const o = (row.mark * W + x) * 3;\n        rgb[o] = col[0], rgb[o + 1] = col[1], rgb[o + 2] = col[2];\n      }\n    });\n  });\n  // The row the eye reads to through this lens, pointed at from both sides.\n  if (s.best >= 0) {\n    const row = ROWS[s.best], m = round(row.top + row.h / 2 - 0.5);\n    for (const [dx, dy] of [[0, 0], [1, 0], [2, 0], [0, -1], [1, -1], [0, 1], [1, 1], [0, -2], [0, 2]])\n      for (const x of [dx, W - 1 - dx]) {\n        if (s.colDark[x]) continue;\n        const o = ((m + dy) * W + x) * 3;\n        rgb[o] = 20, rgb[o + 1] = 70, rgb[o + 2] = 255;\n      }\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const j = i * 3;\n    display.setPixel(i % W, (i / W) | 0, round(cl(rgb[j], 0, 255)), round(cl(rgb[j + 1], 0, 255)), round(cl(rgb[j + 2], 0, 255)));\n  }\n}\n","flag-hoist":"// ===== Patternflow pattern =====\n// Title:   Flag Hoist\n// Family:  type\n// Idea:    Words are spelled in the letter flags of the International Code of Signals, bent on one under another to a halyard that runs down the tall panel by its left edge, and each hoist is hauled up hand over hand into a night sky, flies there with every flag fluttering in a wave that grows towards its fly and turns its folds light and dark, shows the plain letter beside each flag while it is close up, and is hauled down for the next word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the letter flags of the International Code of Signals, which began as the British Board of Trade's Commercial Code of Signals (1857), its 26 letter flags as revised in 1931 and 1965; before it Frederick Marryat's Code of Signals for the Merchant Service (1817); 5 by 7 capitals from Photon Disk (pattern round 70); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Wind=3..8, Speed=0.2..3, Letters=3..6, Sky=0..1\n//\n// Knob 1: Wind. The wind in Beaufort force. At the opening 3, the gentle breeze in which light flags stand out, a fold runs down each flag about once a second, its steepest side turned 29 degrees, and the fly lifts and falls about 2 LEDs; at 8, a gale, the folds come 2.7 times a second at half the length, turned up to 45 degrees, the fly whips about 6 LEDs and the cloth bunches 7 percent shorter.\n// Knob 2: Speed. At 2 a hoist takes 2.6 s to go up in six hauls, flies close up for 4.5 s, takes 2.2 s to come down, and the next follows 0.4 s later, 9.7 s a word. Every time scales as 2 / Speed: 97 s a word at 0.2, 6.5 s at 3.\n// Knob 3: Letters. How many flags a hoist carries, one word of that length. At 3 (KEG, RIG, DRY, BAY, OAR, SKY) the flags are 31 LEDs deep and 40 long and the hoist reaches row 100; at 4 (QUAY, GOLD, DECK, BUOY and four more) 25 by 34; at 5 (OCEAN, YACHT, RIDGE and three more) 20 by 28; at 6 (ANCHOR, BRIDGE, VOYAGE and three more) 16 by 23, the hoist reaching row 110 to 113.\n// Knob 4: Sky. 0 is a moonless night, near black with a few faint stars; 1 is the blue hour, a deep blue sky going violet and then amber towards the foot of the panel. The opening 0.06 is night.\n// Buttons: K1 tap hauls the hoist down at once and sends up the next word.\n\n// A ship carries one flag for each letter, so a word that needs one letter\n// twice would take a substitute pennant in the second place. The words here\n// never repeat a letter. A hoist is read from the top down once it is\n// close up, hauled right up to the block, and that is when the plain\n// letters show.\n//\n// A flag in the wind is a sheet on which waves run from the hoist, where it\n// is held, to the fly, where it is free, growing as they go. The sheet's\n// folds stand out of the panel: each column of the flag tilts by the slope\n// of the fold there, which shortens it on the panel and turns it towards or\n// away from a light on the left. The folds also lift the fly a\n// little, so the top and bottom edges ripple.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst TAU = 2 * PI;\n\n// The halyard's column and where the flags' hoist edges start.\nconst HX = 3, X0 = 4, TOP = 2, GAP = 3;\n// Cloth colours, chosen to read on LEDs: white, red, blue, yellow, black.\n// Black cloth stays just above dark so the flag keeps its shape at night.\nconst CLOTH = [\n  [228, 226, 214],\n  [255, 8, 22],\n  [0, 40, 255],\n  [255, 196, 0],\n  [36, 34, 42],\n];\nconst Wt = 0, R = 1, B = 2, Y = 3, K = 4;\n// Swallowtailed flags, A and B: the notch reaches this far into the fly.\nconst NOTCH = 0.24;\n\n// Each flag as a function of u along the fly (0 at the hoist), v down the\n// hoist (0 at the top), and the flag's length and depth in LEDs for the\n// shapes that are square or round on the cloth.\nfunction distLine(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay;\n  return abs((px - ax) * dy - (py - ay) * dx) / sqrt(dx * dx + dy * dy);\n}\nconst FLAGS = {\n  A: (u) => (u \u003c 0.5 ? Wt : B),\n  B: () => R,\n  C: (u, v) => [B, Wt, R, Wt, B][min(4, floor(v * 5))],\n  D: (u, v) => (v \u003c 0.25 || v >= 0.75 ? Y : B),\n  E: (u, v) => (v \u003c 0.5 ? B : R),\n  F: (u, v) => (abs(u - 0.5) + abs(v - 0.5) \u003c 0.5 ? R : Wt),\n  G: (u) => (floor(u * 6) % 2 ? B : Y),\n  H: (u) => (u \u003c 0.5 ? Wt : R),\n  I: (u, v, l, d) => (((u - 0.5) * l) ** 2 + ((v - 0.5) * d) ** 2 \u003c (0.26 * d) ** 2 ? K : Y),\n  J: (u, v) => (v \u003c 1 / 3 || v >= 2 / 3 ? B : Wt),\n  K: (u) => (u \u003c 0.5 ? Y : B),\n  L: (u, v) => ((u \u003c 0.5) === (v \u003c 0.5) ? Y : K),\n  M: (u, v, l, d) => (min(distLine(u * l, v * d, 0, 0, l, d), distLine(u * l, v * d, 0, d, l, 0)) \u003c 0.1 * d ? Wt : B),\n  N: (u, v) => ((floor(u * 4) + floor(v * 4)) % 2 ? Wt : B),\n  O: (u, v) => (v \u003c u ? R : Y),\n  P: (u, v, l, d) => (abs(u - 0.5) * l \u003c d / 6 && abs(v - 0.5) * d \u003c d / 6 ? Wt : B),\n  Q: () => Y,\n  R: (u, v, l, d) => (abs(u - 0.5) * l \u003c 0.1 * d || abs(v - 0.5) \u003c 0.1 ? Y : R),\n  S: (u, v, l, d) => (abs(u - 0.5) * l \u003c d / 6 && abs(v - 0.5) * d \u003c d / 6 ? B : Wt),\n  T: (u) => [R, Wt, B][min(2, floor(u * 3))],\n  U: (u, v) => ((u \u003c 0.5) === (v \u003c 0.5) ? R : Wt),\n  V: (u, v, l, d) => (min(distLine(u * l, v * d, 0, 0, l, d), distLine(u * l, v * d, 0, d, l, 0)) \u003c 0.1 * d ? R : Wt),\n  W: (u, v, l, d) => {\n    const e = min(u * l, (1 - u) * l, v * d, (1 - v) * d);\n    return e \u003c d / 6 ? B : e \u003c d / 3 ? Wt : R;\n  },\n  X: (u, v, l, d) => (abs(u - 0.5) * l \u003c 0.1 * d || abs(v - 0.5) \u003c 0.1 ? B : Wt),\n  Y: (u, v, l, d) => (floor(((u * l + v * d) / (l + d)) * 10) % 2 ? R : Y),\n  Z: (u, v) => (u \u003c v && u \u003c 1 - v ? K : v \u003c u && v \u003c 1 - u ? Y : u > v && u > 1 - v ? B : R),\n};\n\n// Words of three to six letters with no letter twice.\nconst WORDS = {\n  3: [\"KEG\", \"RIG\", \"DRY\", \"BAY\", \"OAR\", \"SKY\"],\n  4: [\"QUAY\", \"GOLD\", \"DECK\", \"BUOY\", \"YARD\", \"BRIG\", \"TIDE\", \"WIND\"],\n  5: [\"OCEAN\", \"YACHT\", \"RIDGE\", \"BADGE\", \"BOARD\", \"DRIFT\"],\n  6: [\"ANCHOR\", \"BRIDGE\", \"VOYAGE\", \"YONDER\", \"GOLDEN\", \"BYGONE\"],\n};\n// Flag depth and length for each word length: the hoist runs from row 2 to\n// row 100 (three flags) or 110 to 113 (more), with 3 LEDs of halyard\n// between flags.\nconst SIZE = { 3: [31, 40], 4: [25, 34], 5: [20, 28], 6: [16, 23] };\n\n// 5 x 7 capitals from Photon Disk (pattern round 70), rows from the top.\nconst GLYPHS = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", B: \"####. #...# #...# ####. #...# #...# ####.\", C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\", E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\",\n  G: \".###. #...# #.... #.### #...# #...# .####\", H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  J: \"..### ...#. ...#. ...#. ...#. #..#. .##..\", K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  M: \"#...# ##.## #.#.# #.#.# #...# #...# #...#\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\",\n  P: \"####. #...# #...# ####. #.... #.... #....\", Q: \".###. #...# #...# #...# #.#.# #..#. .##.#\", R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\", X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\",\n};\nconst FONT = {};\nfor (const k in GLYPHS) FONT[k] = GLYPHS[k].replace(/ /g, \"\");\n\n// Steps along the cloth when a flag's folds are worked out.\nconst STEPS = 96;\n// The light comes from the left and the front.\nconst LX = -0.6, LZ = 0.8;\n\n// A few faint stars, fixed for the run.\nconst STARS = [];\nfor (let i = 0; i \u003c 26; i++) STARS.push([floor(Math.random() * W), floor(Math.random() * H), Math.random() * TAU, 0.5 + Math.random() * 0.5]);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, phase: -1, pt: 0, word: \"\", n: 3, next: { 3: 0, 4: 0, 5: 0, 6: 0 }, wind: 3, speed: 2, sky: 0.06, btn: false,\n    y: H, show: 0, flut: 0, acc: new Float32Array(W * H * 3),\n    cu: new Float32Array(W), cdy: new Float32Array(W), csh: new Float32Array(W), cdu: new Float32Array(W),\n    xs: new Float32Array(STEPS + 1), ys: new Float32Array(STEPS + 1), ss: new Float32Array(STEPS + 1),\n  };\n  return params.s;\n}\n\n// Phase 0 up, 1 close up, 2 down, 3 the pause before the next word.\nconst DUR = [2.6, 4.5, 2.2, 0.4];\nconst HAULS = 6;\n\nfunction hoistLength(S) {\n  const [d] = SIZE[S.n];\n  return S.n * d + (S.n - 1) * GAP;\n}\nfunction nextWord(S, n) {\n  S.n = n;\n  const list = WORDS[n];\n  S.word = list[S.next[n] % list.length];\n  S.next[n]++;\n  S.phase = 0;\n  S.pt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [3, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.wind = cl(k[0], 3, 8);\n  S.speed = cl(k[1], 0.2, 3);\n  const n = round(cl(k[2], 3, 6));\n  S.sky = cl(k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (S.phase \u003c 0) nextWord(S, n);\n  if (btn && !S.btn && S.phase \u003c 2) (S.phase = 2), (S.pt = 0), (S.from = S.y);\n  S.btn = btn;\n  S.t += d;\n  // The flutter runs on its own clock so a change of wind never jumps it.\n  S.flut += d * (0.95 + 0.35 * (S.wind - 3));\n  const sc = 2 / S.speed;\n  S.pt += d;\n  const len = hoistLength(S);\n  if (S.phase === 0) {\n    // Hand over hand: the haul surges and slackens six times on the way.\n    const p = cl(S.pt / (DUR[0] * sc), 0, 1), q = p - (0.55 * sin(TAU * HAULS * p)) / (TAU * HAULS);\n    S.y = H + 2 + (TOP - H - 2) * smooth(q);\n    if (p >= 1) (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    S.y = TOP;\n    if (S.pt >= DUR[1] * sc) (S.phase = 2), (S.pt = 0), (S.from = TOP);\n  } else if (S.phase === 2) {\n    const p = cl(S.pt / (DUR[2] * sc), 0, 1), from = S.from ?? TOP;\n    S.y = from + (H + 2 - from) * (p * p * (1.6 - 0.6 * p));\n    if (p >= 1) (S.phase = 3), (S.pt = 0);\n  } else {\n    S.y = H + len + 2;\n    if (S.pt >= DUR[3] * sc) nextWord(S, n);\n  }\n  // The letters fade in once the hoist is close up and out as it starts down.\n  const want = S.phase === 1 ? 1 : 0;\n  S.show += (want - S.show) * min(1, d * (want ? 3 : 6));\n}\n\n// One flag: its columns first (where each u lands, how far its fold lifts\n// it, how it is lit), then every LED in its box, four samples each.\nfunction flag(S, acc, ch, top, d, l, ph) {\n  const wind = S.wind - 3, t = S.flut * TAU;\n  // The steepest fold, as dz/dx: 0.55 (29 degrees) in a gentle breeze, 1\n  // (45 degrees) in a gale, the folds getting shorter as the wind rises.\n  const lam = 0.95 - 0.09 * wind, amp = ((0.55 + 0.09 * wind) * lam) / TAU, lift = 1.5 + 0.6 * wind;\n  const cu = S.cu, cdy = S.cdy, csh = S.csh, cdu = S.cdu, xs = S.xs, ys = S.ys, ss = S.ss, N = STEPS;\n  // March along the cloth in small steps, adding up how far along the panel\n  // each step goes (its length times the cosine of its tilt).\n  let x = 0;\n  for (let i = 0; i \u003c= N; i++) {\n    const u = i / N, g = u ** 0.9, th = (TAU * u) / lam - t + ph;\n    // The slope of the fold, dz/dx, which tilts the column.\n    const slope = amp * g * (TAU / lam) * cos(th) + amp * 0.9 * max(u, 0.01) ** -0.1 * sin(th);\n    const tilt = atan(slope);\n    if (i > 0) x += (l / N) * cos(tilt);\n    xs[i] = x;\n    ys[i] = lift * g * sin(th - 0.9) + 0.4 * lift * u * u * sin(2 * th + 0.5);\n    // Lambert light on the tilted column, never black.\n    ss[i] = 0.3 + 0.78 * max(0, -sin(tilt) * LX + cos(tilt) * LZ);\n  }\n  const end = xs[N];\n  // Each LED column the flag reaches: the u at its centre by walking the\n  // table, and how much u one LED spans there.\n  let j = 0;\n  const cols = min(W - X0, floor(end) + 1);\n  for (let col = 0; col \u003c cols; col++) {\n    const xc = col + 0.5;\n    while (j \u003c N - 1 && xs[j + 1] \u003c xc) j++;\n    const f = cl((xc - xs[j]) / max(1e-6, xs[j + 1] - xs[j]), 0, 1);\n    cu[col] = (j + f) / N;\n    cdy[col] = ys[j] + (ys[j + 1] - ys[j]) * f;\n    csh[col] = ss[j] + (ss[j + 1] - ss[j]) * f;\n    cdu[col] = 1 / (N * max(1e-6, xs[j + 1] - xs[j]));\n  }\n  const fn = FLAGS[ch], notch = ch === \"A\" || ch === \"B\";\n  const y0 = max(0, floor(top - 8)), y1 = min(H - 1, floor(top + d + 8));\n  for (let c = 0; c \u003c cols; c++) {\n    const px = X0 + c, u = cu[c], du = cdu[c], dy = cdy[c], sh = csh[c];\n    // The fly edge, soft.\n    const aFly = cl(end - c, 0, 1);\n    for (let py = y0; py \u003c= y1; py++) {\n      const yy = py + 0.5 - top - dy;\n      const aEdge = cl(min(yy, d - yy) + 0.5, 0, 1);\n      if (aEdge \u003c= 0) continue;\n      // Four samples a quarter LED from the centre. A sample in the\n      // swallowtail's notch is sky, so it only thins the LED.\n      let r = 0, g = 0, b = 0, hits = 0;\n      for (let s = 0; s \u003c 4; s++) {\n        const su = cl(u + ((s & 1) - 0.5) * 0.5 * du, 0, 0.9999), sv = cl((yy + ((s >> 1) - 0.5) * 0.5) / d, 0, 0.9999);\n        if (notch && su > 1 - NOTCH * (1 - abs(2 * sv - 1))) continue;\n        const cc = CLOTH[fn(su, sv, l, d)];\n        r += cc[0];\n        g += cc[1];\n        b += cc[2];\n        hits++;\n      }\n      if (!hits) continue;\n      const a = (aEdge * aFly * hits) / 4, kk = (py * W + px) * 3, m = sh / 255 / hits;\n      acc[kk] += (r * m - acc[kk]) * a;\n      acc[kk + 1] += (g * m - acc[kk + 1]) * a;\n      acc[kk + 2] += (b * m - acc[kk + 2]) * a;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const acc = S.acc, sky = S.sky, sk = sky ** 1.5, t = S.t;\n  // The sky: night is near black with a blue breath at the top; the blue\n  // hour runs deep blue to violet to amber at the foot.\n  for (let y = 0; y \u003c H; y++) {\n    const v = y / (H - 1);\n    const nr = 0, ng = 2 + 4 * (1 - v), nb = 5 + 12 * (1 - v);\n    const hr = v \u003c 0.6 ? 20 + 60 * (v / 0.6) : 80 + 120 * ((v - 0.6) / 0.4);\n    const hg = v \u003c 0.6 ? 34 + 6 * (v / 0.6) : 40 + 50 * ((v - 0.6) / 0.4);\n    const hb = v \u003c 0.6 ? 120 - 20 * (v / 0.6) : 100 - 70 * ((v - 0.6) / 0.4);\n    const r = (nr + (hr - nr) * sk) / 255, g = (ng + (hg - ng) * sk) / 255, b = (nb + (hb - nb) * sk) / 255;\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      acc[k] = r;\n      acc[k + 1] = g;\n      acc[k + 2] = b;\n    }\n  }\n  const starA = 1 - smooth(sky * 1.6);\n  for (const [x, y, p, m] of STARS) {\n    const k = (y * W + x) * 3, v = starA * m * (0.13 + 0.07 * sin(t * 1.7 + p));\n    acc[k] = max(acc[k], v);\n    acc[k + 1] = max(acc[k + 1], v);\n    acc[k + 2] = max(acc[k + 2], v * 1.1);\n  }\n  // The halyard: a laid rope whose lay marks travel with the hoist.\n  const off = S.y;\n  for (let y = 0; y \u003c H; y++) {\n    const lay = (((floor(y - off) % 3) + 3) % 3) === 0 ? 0.62 : 0.42;\n    const k = (y * W + HX) * 3;\n    acc[k] = 0.92 * lay;\n    acc[k + 1] = 0.84 * lay;\n    acc[k + 2] = 0.68 * lay;\n  }\n  const [d, l] = SIZE[S.n];\n  const word = S.word;\n  for (let i = 0; i \u003c word.length; i++) {\n    const top = S.y + i * (d + GAP);\n    if (top > H + 8 || top + d \u003c -8) continue;\n    flag(S, acc, word[i], top, d, l, i * 1.7);\n    // The toggle and the snap that join each flag to the halyard.\n    for (const yy of [top, top + d - 1]) {\n      const iy = round(yy);\n      if (iy >= 0 && iy \u003c H) for (let x = HX; x \u003c= X0; x++) {\n        const k = (iy * W + x) * 3;\n        acc[k] = 0.75;\n        acc[k + 1] = 0.72;\n        acc[k + 2] = 0.66;\n      }\n    }\n  }\n  // The plain letters, two LEDs a dot, 9 LEDs clear of the fly.\n  if (S.show > 0.01) {\n    const a = smooth(S.show), lx = X0 + l + 9;\n    for (let i = 0; i \u003c word.length; i++) {\n      const g = FONT[word[i]], top = round(S.y + i * (d + GAP) + d / 2 - 7);\n      for (let gy = 0; gy \u003c 7; gy++)\n        for (let gx = 0; gx \u003c 5; gx++) {\n          if (g[gy * 5 + gx] !== \"#\") continue;\n          for (let q = 0; q \u003c 4; q++) {\n            const x = lx + gx * 2 + (q & 1), y = top + gy * 2 + (q >> 1);\n            if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n            const k = (y * W + x) * 3;\n            acc[k] += (0.94 - acc[k]) * a;\n            acc[k + 1] += (0.92 - acc[k + 1]) * a;\n            acc[k + 2] += (0.86 - acc[k + 2]) * a;\n          }\n        }\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[k])) | 0, (255 * min(1, acc[k + 1])) | 0, (255 * min(1, acc[k + 2])) | 0);\n    }\n}\n","lambda-diagrams":"// ===== Patternflow pattern =====\n// Title:   Lambda Diagrams\n// Family:  line\n// Idea:    Church-numeral arithmetic, SUCC 2, PLUS 2 3, TIMES 2 3, EXP 2 3, TIMES 4 4 and EXP 2 4, are drawn as Tromp's lambda diagrams, every abstraction a horizontal bar, every variable a vertical line hanging from the bar that binds it and every application a link joining the leftmost lines of function and argument, and they are reduced one normal-order beta step at a time, the redex's bar with its variables lighting warm white and its argument gold before the picture cross-fades to the next term laid out afresh to fit the panel, until the normal form, a staircase comb with one tooth for each count, holds while a pulse runs down it and the next expression begins.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: lambda calculus and Church numerals (Alonzo Church, An Unsolvable Problem of Elementary Number Theory, 1936), de Bruijn indices (Nicolaas Govert de Bruijn, 1972), lambda diagrams (John Tromp), pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Expression=0..6, Glow=0..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. At 0 the outermost bar and its variables are cyan and each deeper binder steps 0.09 round the wheel through blue and violet to magenta, links are pale, and a redex lights warm white and gold; at 0.5 the binders run red, orange, yellow and green and the redex lights pale blue and blue.\n// Knob 2: Speed. At 2 a step takes 1.25 s: 0.25 s showing the term, 0.55 s lighting the redex and 0.45 s cross-fading to the result. The step times scale as 2 / Speed, so at 0.2 a step takes 12.5 s and at 3 it takes 0.83 s; the 2.6 s hold on the normal form stays as it is.\n// Knob 3: Expression. 0 (the opening) runs the six expressions in turn; 1 to 6 repeats one: SUCC 2 (3 steps to 3), PLUS 2 3 (6 steps to 5), TIMES 2 3 (7 steps to 6), EXP 2 3 (16 steps to 8), TIMES 4 4 (11 steps to 16) and EXP 2 4 (32 steps to 16), whose widest term is 27 variables across, drawn at 2 LEDs a column.\n// Knob 4: Glow. A halo of the lines blurred over 5 x 5 LEDs is added on top, 0.35 times at 0, 0.48 at the opening 0.06 and 2.5 times at 1, where the lines swim in their own colour and the 1-LED lines of the big terms, a pitch of 2 apart, run together into bands.\n\n// A lambda term is variables, abstractions (lambda x. body) and\n// applications (f a). Church (1936) wrote the number n as the term that\n// applies f n times, lambda f. lambda x. f (f ... (f x)), and arithmetic as terms\n// that take numerals apart and put them together: PLUS m n f x = m f (n f x).\n// A beta step replaces (lambda x. body) a by the body with a in place of x;\n// normal order always takes the leftmost, outermost such redex, and reaches\n// the normal form whenever there is one.\n//\n// Terms are kept with de Bruijn indices: a variable is the number of\n// binders between it and its own, so no name ever needs renaming.\n//\n// Tromp's diagram lays a term out on a grid. Each variable takes a column\n// and is a vertical line from its binder's bar down to where it is used. An\n// abstraction is a bar on its own row across its body's columns. An\n// application puts function and argument side by side and joins their\n// leftmost lines one row below the deeper of the two, the function's line\n// carrying on down. The numeral n becomes two bars over a staircase of n\n// links: a comb.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Terms: { t: 0, i } a variable with its de Bruijn index (0 = the\n// nearest binder), { t: 1, b } an abstraction, { t: 2, f, a } an application.\nconst Var = (i) => ({ t: 0, i }), Lam = (b) => ({ t: 1, b }), App = (f, a) => ({ t: 2, f, a });\nconst ap = (...xs) => xs.reduce((f, a) => App(f, a));\nfunction num(n) {\n  let b = Var(0);\n  for (let k = 0; k \u003c n; k++) b = App(Var(1), b);\n  return Lam(Lam(b));\n}\nconst SUCC = Lam(Lam(Lam(App(Var(1), ap(Var(2), Var(1), Var(0)))))); // n f x. f (n f x)\nconst PLUS = Lam(Lam(Lam(Lam(ap(Var(3), Var(1), ap(Var(2), Var(1), Var(0))))))); // m n f x. m f (n f x)\nconst TIMES = Lam(Lam(Lam(App(Var(2), App(Var(1), Var(0)))))); // m n f. m (n f)\nconst EXP = Lam(Lam(App(Var(0), Var(1)))); // m n. n m, which is m to the n\nconst EXPRS = [\n  ap(SUCC, num(2)), ap(PLUS, num(2), num(3)), ap(TIMES, num(2), num(3)),\n  ap(EXP, num(2), num(3)), ap(TIMES, num(4), num(4)), ap(EXP, num(2), num(4)),\n];\n\nfunction shift(t, d, c) {\n  return t.t === 0 ? (t.i >= c ? Var(t.i + d) : t) : t.t === 1 ? Lam(shift(t.b, d, c + 1)) : App(shift(t.f, d, c), shift(t.a, d, c));\n}\nfunction subst(t, j, s) {\n  return t.t === 0 ? (t.i === j ? s : t) : t.t === 1 ? Lam(subst(t.b, j + 1, shift(s, 1, 0))) : App(subst(t.f, j, s), subst(t.a, j, s));\n}\n// One normal-order step, or null at the normal form.\nfunction step(t) {\n  if (t.t === 2) {\n    if (t.f.t === 1) return shift(subst(t.f.b, 0, shift(t.a, 1, 0)), -1, 0);\n    const f = step(t.f);\n    if (f) return App(f, t.a);\n    const a = step(t.a);\n    return a ? App(t.f, a) : null;\n  }\n  if (t.t === 1) {\n    const b = step(t.b);\n    return b ? Lam(b) : null;\n  }\n  return null;\n}\nconst nodes = (t) => (t.t === 0 ? 1 : t.t === 1 ? 1 + nodes(t.b) : 1 + nodes(t.f) + nodes(t.a));\n\n// ---- Layout in grid units. Segments: k 0 a bar (row r, columns c0..c1),\n// 1 a variable (column c, rows r0..r1), 2 a link (row r, columns c0..c1).\n// d is the depth of the binder a bar or variable belongs to. role marks the\n// first redex met in the walk, which is the normal-order one: 1 its bar and\n// the variables it binds, 2 its argument, 3 its link.\nfunction lay(t, c0, r0, env, ctx, redexLam) {\n  if (t.t === 0) {\n    const b = env[env.length - 1 - t.i] || { row: 0, d: 0, role: 0 };\n    const seg = { k: 1, c: c0, r0: b.row, r1: r0, d: b.d, role: ctx.role || b.role };\n    ctx.segs.push(seg);\n    return { w: 1, h: 0, left: seg };\n  }\n  if (t.t === 1) {\n    const bar = { k: 0, c0, c1: c0, r: r0, d: env.length, role: ctx.role || (redexLam ? 1 : 0) };\n    ctx.segs.push(bar);\n    env.push({ row: r0, d: env.length, role: redexLam ? 1 : 0 });\n    const B = lay(t.b, c0, r0 + 1, env, ctx, false);\n    env.pop();\n    bar.c1 = c0 + B.w - 1;\n    return { w: B.w, h: B.h + 1, left: B.left };\n  }\n  const redex = t.f.t === 1 && !ctx.found;\n  if (redex) ctx.found = true;\n  const F = lay(t.f, c0, r0, env, ctx, redex);\n  const outer = ctx.role;\n  if (redex) ctx.role = 2;\n  const A = lay(t.a, c0 + F.w, r0, env, ctx, false);\n  ctx.role = outer;\n  const h = max(F.h, A.h) + 1, row = r0 + h - 1;\n  F.left.r1 = row;\n  A.left.r1 = row;\n  ctx.segs.push({ k: 2, c0: F.left.c, c1: A.left.c, r: row, d: 0, role: redex ? 3 : outer });\n  return { w: F.w + A.w, h, left: F.left };\n}\n\n// The term in LED rectangles: the widest column pitch from 8 down to 2 that\n// fits 62 LEDs, a row pitch up to twice that (the panel is tall) and at most\n// 16 that fits 124, lines 2 LEDs thick from a pitch of 5. A bar reaches past\n// its outer columns by e, which leaves at least one dark LED between two\n// bars side by side on a row: none at pitch 2 and 3, 2 at pitch 7 and 8.\n// null if the term cannot fit at 2 x 2.\nfunction diagram(t) {\n  const ctx = { segs: [], role: 0, found: false };\n  const R = lay(t, 0, 0, [], ctx, false);\n  R.left.r1 = R.h; // the root's line runs on one row: the term's output\n  const w = R.w, h = R.h;\n  let gx = 8;\n  const ext = (g) => floor((g - (g >= 5 ? 2 : 1) - 1) / 2);\n  const span = (g) => (w - 1) * g + 2 * ext(g) + (g >= 5 ? 2 : 1);\n  while (gx > 2 && span(gx) > 62) gx--;\n  if (span(gx) > 62) return null;\n  const th = gx >= 5 ? 2 : 1, e = ext(gx);\n  let gy = min(16, 2 * gx);\n  while (gy > 2 && h * gy + th > 124) gy--;\n  if (h * gy + th > 124) return null;\n  const ox = round((W - span(gx)) / 2) + e, oy = round((H - h * gy - th) / 2);\n  const X = (c) => ox + c * gx, Y = (r) => oy + r * gy;\n  const rects = ctx.segs.map((s) =>\n    s.k === 0 ? [X(s.c0) - e, Y(s.r), X(s.c1) + e + th - 1, Y(s.r) + th - 1, s]\n    : s.k === 1 ? [X(s.c), Y(s.r0), X(s.c) + th - 1, Y(s.r1) + th - 1, s]\n    : [X(s.c0), Y(s.r), X(s.c1) + th - 1, Y(s.r) + th - 1, s]);\n  return { rects, redex: ctx.found, top: oy, bottom: Y(h) + th };\n}\n\n// Every term of one reduction, laid out, with a cap on steps and size so a\n// term that blows up is cut off rather than drawn.\nconst MAX_STEPS = 60, MAX_NODES = 600;\nfunction reduce(t0) {\n  const out = [];\n  for (let t = t0, n = 0; t && n \u003c= MAX_STEPS; t = step(t), n++) {\n    const dg = nodes(t) \u003c= MAX_NODES ? diagram(t) : null;\n    if (!dg) return null;\n    out.push(dg);\n    if (!dg.redex) return out;\n  }\n  return null;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, glow: 0.06, pick: -1, ex: -1, terms: null, k: 0, u: 0, phase: 0, pt: 0, fade: 1,\n    a: new Float32Array(W * H * 3), b: new Float32Array(W * H * 3), out: new Float32Array(W * H * 3), tmp: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\nfunction start(S, ex) {\n  for (let n = 0; n \u003c EXPRS.length; n++, ex = (ex + 1) % EXPRS.length) {\n    const terms = reduce(EXPRS[ex]);\n    if (terms) return void Object.assign(S, { ex, terms, k: 0, phase: 0, pt: 0 });\n  }\n}\n\n// Phases at Speed 2: 0 show the term 0.25 s, 1 light the redex 0.55 s, 2\n// cross-fade 0.45 s; at the normal form 3 hold 2.6 s and 4 fade out 0.5 s.\nconst T_SHOW = 0.25, T_HI = 0.55, T_MORPH = 0.45, T_HOLD = 2.6, T_OUT = 0.5;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  if (!S.terms) start(S, 0);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.glow = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const pick = round(cl(k[2] || 0, 0, 6));\n  if (pick !== S.pick) (S.pick = pick), start(S, pick ? pick - 1 : 0), (S.fade = 0);\n  const sc = 2 / S.speed;\n  S.pt += d;\n  S.fade = min(1, S.fade + d / 0.4);\n  const last = S.k >= S.terms.length - 1;\n  if (S.phase === 0 && S.pt >= T_SHOW * sc) (S.phase = last ? 3 : 1), (S.pt = 0);\n  else if (S.phase === 1 && S.pt >= T_HI * sc) (S.phase = 2), (S.pt = 0);\n  else if (S.phase === 2 && S.pt >= T_MORPH * sc) (S.k++, (S.phase = 0), (S.pt = 0));\n  else if (S.phase === 3 && S.pt >= T_HOLD) (S.phase = 4), (S.pt = 0);\n  else if (S.phase === 4 && S.pt >= T_OUT * min(sc, 1)) {\n    start(S, S.pick ? S.pick - 1 : (S.ex + 1) % EXPRS.length);\n    S.fade = 0;\n  }\n}\n\n// Paint one diagram into buf at weight w; hl lights its redex, pulse (a row)\n// runs a bright band down a held normal form.\nfunction paint(S, buf, dg, w, hl, pulse) {\n  const base = 0.52 + S.hue;\n  const roleCol = [null, hsv(base + 0.6, 0.3, 1), hsv(base + 0.62, 0.9, 1), [1, 1, 1]];\n  const link = hsv(base + 0.25, 0.15, 0.7);\n  for (const [x0, y0, x1, y1, s] of dg.rects) {\n    let c = s.k === 2 ? link : hsv(base + 0.09 * (s.d % 5), 0.78, 1);\n    if (hl > 0) {\n      const r = roleCol[s.role];\n      c = r ? [c[0] + (r[0] - c[0]) * hl, c[1] + (r[1] - c[1]) * hl, c[2] + (r[2] - c[2]) * hl] : [c[0] * (1 - 0.7 * hl), c[1] * (1 - 0.7 * hl), c[2] * (1 - 0.7 * hl)];\n    }\n    for (let y = max(0, y0); y \u003c= min(H - 1, y1); y++) {\n      const p = pulse == null ? w : w * (0.55 + 0.75 * exp(-(((y - pulse) / 7) ** 2)));\n      for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) {\n        const j = (y * W + x) * 3;\n        for (let q = 0; q \u003c 3; q++) if (c[q] * p > buf[j + q]) buf[j + q] = c[q] * p;\n      }\n    }\n  }\n}\n\n// A 5-wide box blur across and then down.\nfunction blur(src, dst, tmp) {\n  for (let y = 0; y \u003c H; y++)\n    for (let c = 0; c \u003c 3; c++) {\n      let s = 0;\n      for (let x = -2; x \u003c W + 2; x++) {\n        if (x + 2 \u003c W) s += src[(y * W + x + 2) * 3 + c];\n        if (x - 3 >= 0) s -= src[(y * W + x - 3) * 3 + c];\n        if (x >= 0 && x \u003c W) tmp[(y * W + x) * 3 + c] = s / 5;\n      }\n    }\n  for (let x = 0; x \u003c W; x++)\n    for (let c = 0; c \u003c 3; c++) {\n      let s = 0;\n      for (let y = -2; y \u003c H + 2; y++) {\n        if (y + 2 \u003c H) s += tmp[((y + 2) * W + x) * 3 + c];\n        if (y - 3 >= 0) s -= tmp[((y - 3) * W + x) * 3 + c];\n        if (y >= 0 && y \u003c H) dst[(y * W + x) * 3 + c] = s / 5;\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.terms) return;\n  const sc = 2 / S.speed, A = S.a, B = S.b, O = S.out;\n  A.fill(0);\n  B.fill(0);\n  const cur = S.terms[S.k], fade = smooth(S.fade);\n  if (S.phase === 0) paint(S, A, cur, fade, 0, null);\n  else if (S.phase === 1) paint(S, A, cur, fade, smooth(S.pt / (0.35 * T_HI * sc)), null);\n  else if (S.phase === 2) {\n    const u = smooth(S.pt / (T_MORPH * sc));\n    paint(S, A, cur, 1 - u, 1, null);\n    paint(S, B, S.terms[S.k + 1], u, 0, null);\n  } else {\n    // The pulse runs from the top bar to the end of the output line in 1.3 s, twice.\n    const pulse = cur.top - 10 + ((S.pt % 1.3) / 1.3) * (cur.bottom - cur.top + 20);\n    const out = S.phase === 4 ? 1 - smooth(S.pt / (T_OUT * min(sc, 1))) : 1;\n    paint(S, A, cur, out, 0, S.phase === 3 && S.pt \u003c 2.6 ? pulse : null);\n  }\n  for (let i = 0; i \u003c A.length; i++) A[i] += B[i];\n  blur(A, O, S.tmp);\n  const g = 0.35 + 2.15 * S.glow;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const j = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl((A[j] + g * O[j]) * 255, 0, 255)), round(cl((A[j + 1] + g * O[j + 1]) * 255, 0, 255)), round(cl((A[j + 2] + g * O[j + 2]) * 255, 0, 255)));\n    }\n}\n","promotion":"// ===== Patternflow pattern =====\n// Title:   Promotion\n// Family:  algo\n// Idea:    A random standard Young tableau of 8 by 16 cells fills the panel, its 128 entries rising along every row and down every column, each cell coloured by its entry and the gutters lit where the entries pass a quarter, a half and three quarters of 128 so three nested staircases show, and Schützenberger's promotion runs on it again and again: the 1 in the top-left corner lifts out as a white hole, the hole slides by jeu de taquin to the bottom-right corner, each step pulling in the smaller of its right and lower neighbours behind a short bright tail, every entry drops by one so the bands creep outward while the hole's path pushes them back, 128 goes into the corner, and a bar along the foot counts the promotions until, after exactly 128 of them, every cell is back where it started and the tableau flashes home.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: promotion of standard Young tableaux (Marcel-Paul Schützenberger, 1972) by jeu de taquin (Schützenberger, 1977), whose order on an a by b rectangle is exactly ab (Mark Haiman, 1992), the start of Brendon Rhoades's cyclic sieving for promotion (2010); the tableau drawn uniformly by the hook walk of Curtis Greene, Albert Nijenhuis and Herbert Wilf (1979); 3 by 5 digits copied from hydra-game.js (round 72); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=-1..2, Levels=0..1\n//\n// Knob 1: Hue. Turns the ramp round the wheel: at 0 the small entries in the top-left corner are azure, the middle ones violet and magenta, the large ones at the bottom-right orange and yellow; at 0.5 the ramp runs from red-orange through yellow and green to blue.\n// Knob 2: Speed. At 2 the 1 lifts out in 0.25 s, each slide of the hole takes 0.08 s on 8 LED cells (the glide is 100 LEDs a second at every size), 128 goes in over 0.25 s: a promotion of the 8 by 16 tableau takes 2.26 s and the way home 4.8 minutes. Every time scales as 2 / Speed: at 3 the way home takes 3.3 minutes, at 0.2 a promotion takes 23 s.\n// Knob 3: Size. The cell size, 8 LEDs at the opening 0: 8 by 16 cells, N = 128, 22 slides a promotion. At -1 cells of 4 LEDs, 16 by 32, N = 512, 46 slides and 20 minutes home; at 1 cells of 16 LEDs, 4 by 8, N = 32, 10 slides, 67 s home, each entry written in the cell; at 2 cells of 32 LEDs, 2 by 4, N = 8, 4 slides, 14 s home, the digits twice the size, and some of its 14 tableaux come home after 2 or 4 promotions, as cyclic sieving counts. A new size draws a new tableau.\n// Knob 4: Levels. How many bands the ramp is cut into: 4 at the opening 0.06, so three staircases, the edges of the Young diagrams of entries up to N/4, N/2 and 3N/4, stand in the lit gutters and the cells brighten and dim once a band; 8 at 0.5 (every 16 entries on 8 by 16); 16 at 1, where the 15 staircases nest close as contour lines of the tableau.\n// Buttons: K1 tap draws a new random tableau and starts the count again.\n\n// A standard Young tableau of a rectangular shape holds 1 to N once each,\n// increasing along rows and down columns. Promotion: take out the 1 at\n// the corner, and while the hole has a neighbour to its right or below,\n// move the smaller of the two into it; the hole ends at the far corner.\n// Take 1 from every entry and write N there. Haiman (1992) proved that on\n// an a by b rectangle doing this N = ab times gives back the tableau you\n// started from, for every tableau, though a single promotion moves only\n// one staircase of cells. The bar along the foot counts to N; a white dot\n// marks each cell that holds what it held at the start, and at N they all\n// light at once. A tableau can come home sooner, after a divisor of N, and\n// Rhoades (2010) counted how many do; on 8 by 16 a random one almost never.\n//\n// The cells holding 1 to m always form a Young diagram, a staircase from\n// the top-right edge to the bottom-left; the gutters on its edge are lit\n// for every m that is a multiple of N / Levels. A promotion turns the\n// diagram of 1 to m + 1 into that of 1 to m by taking off the corner\n// where the hole left it, so each staircase moves by at most a cell a\n// promotion: the falling entries push it out and the path pulls it in.\n//\n// The start is uniform among all tableaux of the shape: the hook walk\n// places N, N-1, ... 1 in turn, each by starting on a random free cell\n// and jumping to a random cell of its hook, to the right or below, until\n// it stands on a corner.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v, o, k) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// 3 by 5 digits, copied from hydra-game.js (round 72), rows top to bottom.\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001011001111\", \"101101111001001\",\n  \"111100111001111\", \"111100111101111\", \"111001010010010\", \"111101111101111\", \"111101111001111\"];\n\n// The hook walk (Greene, Nijenhuis and Wilf, 1979) on a rows of a cells.\nfunction randomTableau(a, b) {\n  const N = a * b, T = new Int16Array(N), len = new Int16Array(b).fill(a);\n  for (let n = N; n >= 1; n--) {\n    // A uniformly random cell of the shape still free.\n    let pick = floor(Math.random() * n), r = 0;\n    while (pick >= len[r]) pick -= len[r++];\n    let c = pick;\n    for (;;) {\n      const arm = len[r] - c - 1;\n      let leg = 0;\n      while (r + leg + 1 \u003c b && len[r + leg + 1] > c) leg++;\n      if (arm + leg === 0) break;\n      const m = floor(Math.random() * (arm + leg));\n      if (m \u003c arm) c += 1 + m;\n      else r += 1 + m - arm;\n    }\n    T[r * a + c] = n;\n    len[r]--;\n  }\n  return T;\n}\n\n// One promotion of T in place; returns the hole's path as cell indices.\nfunction promote(T, a, b) {\n  const N = a * b, path = [0];\n  let r = 0, c = 0;\n  for (;;) {\n    const right = c + 1 \u003c a ? T[r * a + c + 1] : 1e9, down = r + 1 \u003c b ? T[(r + 1) * a + c] : 1e9;\n    if (right === 1e9 && down === 1e9) break;\n    if (right \u003c down) T[r * a + c] = right, c++;\n    else T[r * a + c] = down, r++;\n    path.push(r * a + c);\n  }\n  for (let i = 0; i \u003c N; i++) T[i]--;\n  T[r * a + c] = N;\n  return path;\n}\n\nfunction newTableau(s) {\n  const cell = 8 * 2 ** s.size, a = W / cell, b = H / cell;\n  Object.assign(s, { cell, a, b, N: a * b, k: 0, phase: 0, pt: 0, j: 0, u: 0 });\n  s.T = randomTableau(a, b);\n  s.T0 = s.T.slice();\n  s.home = new Uint8Array(s.N).fill(1);\n  s.eh = new Float32Array((a - 1) * b);\n  s.ev = new Float32Array(a * (b - 1));\n  s.col = new Float32Array(s.N * 3);\n  startPromotion(s);\n}\n\n// Work out the promotion ahead, then let the animation walk through it.\nfunction startPromotion(s) {\n  s.next = s.T.slice();\n  s.path = promote(s.next, s.a, s.b);\n  s.Wk = s.T.slice();\n  s.phase = 0;\n  s.pt = 0;\n  s.j = 0;\n}\n\nexport function setup(params) {\n  const s = (params.s = { size: 0, hue: 0, speed: 2, levels: 4, flash: 0, btn: false });\n  newTableau(s);\n  return s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  s.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const size = round(cl(k[2] || 0, -1, 2)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (size !== s.size || (btn && !s.btn)) (s.size = size), newTableau(s);\n  s.btn = btn;\n  // Levels: 4 bands of N / 4 entries at the opening, 16 at 1.\n  s.levels = round(4 * 2 ** (2 * cl(k[3] == null ? 0.06 : k[3], 0, 1)));\n  const sc = 2 / s.speed, tRem = 0.25 * sc, tStep = 0.01 * s.cell * sc, tIns = 0.25 * sc;\n  const L = s.path.length - 1, total = tRem + L * tStep + tIns;\n  // The hole's staircase fades in 0.3 s at Speed 2, a comet's tail.\n  const fade = exp(-dt / (0.3 * sc));\n  for (let i = 0; i \u003c s.eh.length; i++) s.eh[i] *= fade;\n  for (let i = 0; i \u003c s.ev.length; i++) s.ev[i] *= fade;\n  s.flash = max(0, s.flash - dt / 1.4);\n  s.pt += dt;\n  // Phases: 0 the 1 lifts out, 1 the hole slides, 2 N goes in.\n  for (let guard = 0; guard \u003c 64; guard++) {\n    if (s.phase === 0 && s.pt >= tRem) (s.phase = 1), (s.pt -= tRem), (s.Wk[0] = -1);\n    else if (s.phase === 1 && s.pt >= tStep && s.j \u003c L) {\n      const from = s.path[s.j + 1], to = s.path[s.j];\n      s.Wk[to] = s.Wk[from];\n      s.Wk[from] = -1;\n      // Light the edge the hole crossed.\n      const a = s.a, lo = min(from, to);\n      if (abs(from - to) === 1) s.eh[floor(lo / a) * (a - 1) + (lo % a)] = 1;\n      else s.ev[lo] = 1;\n      s.j++;\n      s.pt -= tStep;\n    } else if (s.phase === 1 && s.j >= L) s.phase = 2;\n    else if (s.phase === 2 && s.pt >= tIns) {\n      s.pt -= tIns;\n      s.T = s.next;\n      s.k = (s.k + 1) % s.N;\n      let all = 1;\n      for (let i = 0; i \u003c s.N; i++) (s.home[i] = s.T[i] === s.T0[i] ? 1 : 0), (all &= s.home[i]);\n      if (all) s.flash = 1;\n      startPromotion(s);\n    } else break;\n  }\n  const done = s.phase === 0 ? s.pt : s.phase === 1 ? tRem + s.j * tStep + min(s.pt, tStep) : tRem + L * tStep + s.pt;\n  s.u = cl(done / total, 0, 1);\n  s.f = s.phase === 0 ? s.pt / tRem : s.phase === 1 ? s.pt / tStep : s.pt / tIns;\n}\n\n// The ramp: the hue runs 0.62 of the wheel from entry 1 to N, and the\n// brightness waves once over each band of N / Levels entries, at its\n// middle where the bands meet.\nfunction colourOf(s, x, out, k) {\n  const N = s.N, t = (x - 1) / (N - 1);\n  hsv(0.55 + s.hue + 0.62 * t, 0.8, 0.84 + 0.14 * sin((PI * (x - 1) * s.levels) / N), out, k);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { a, cell, N, Wk, col, path } = s, c1 = cell - 1, u = s.u;\n  const hole = [1, 0.97, 0.9];\n  // Every cell's colour; the entries fall by u on the way to the next\n  // tableau, so the bands flow outward while a promotion runs.\n  const band = s.band && s.band.length === N ? s.band : (s.band = new Int16Array(N)), bw = N / s.levels;\n  for (let i = 0; i \u003c N; i++) {\n    if (Wk[i] \u003c 0) (col[i * 3] = hole[0]), (col[i * 3 + 1] = hole[1]), (col[i * 3 + 2] = hole[2]), (band[i] = -1);\n    else colourOf(s, Wk[i] - u, col, i * 3), (band[i] = floor((Wk[i] - u - 1 + 1e-6) / bw));\n  }\n  const f = ease(s.f);\n  // The 1 lifting out turns white; N coming in comes out of white.\n  if (s.phase === 0) for (let q = 0; q \u003c 3; q++) col[q] += (hole[q] - col[q]) * f;\n  const corner = N - 1, ins = [0, 0, 0];\n  if (s.phase === 2) {\n    colourOf(s, N + 1 - u, ins, 0);\n    for (let q = 0; q \u003c 3; q++) col[corner * 3 + q] = hole[q] + (ins[q] - hole[q]) * f;\n  }\n  // The gliding cell: during a slide it leaves path[j+1] (now drawn as the\n  // hole) and moves over the hole at path[j].\n  let gx = -99, gy = -99, gc = null, gv = 0;\n  if (s.phase === 1 && s.j \u003c path.length - 1) {\n    const from = path[s.j + 1], to = path[s.j];\n    gc = [0, 0, 0];\n    colourOf(s, Wk[from] - u, gc, 0);\n    gv = Wk[from];\n    for (let q = 0; q \u003c 3; q++) col[from * 3 + q] = hole[q];\n    gx = ((from % a) + ((to % a) - (from % a)) * f) * cell;\n    gy = (floor(from / a) + (floor(to / a) - floor(from / a)) * f) * cell;\n  }\n  const fl = s.flash * 0.55, px = s.px || (s.px = new Float32Array(W * H * 3));\n  for (let y = 0; y \u003c H; y++) {\n    const row = floor(y / cell), iy = y - row * cell;\n    for (let x = 0; x \u003c W; x++) {\n      const cc = floor(x / cell), ix = x - cc * cell, i = row * a + cc;\n      let r = 0.025, g = 0.025, b = 0.05;\n      if (ix \u003c c1 && iy \u003c c1) (r = col[i * 3]), (g = col[i * 3 + 1]), (b = col[i * 3 + 2]);\n      else {\n        // A gutter on a band's edge is lit: the cells with entries up to a\n        // multiple of N / a form a Young diagram, and these are its edges.\n        const me = band[i], rt = ix === c1 && cc + 1 \u003c a ? band[i + 1] : me, dn = iy === c1 && row + 1 \u003c s.b ? band[i + a] : me;\n        const dg = ix === c1 && iy === c1 && cc + 1 \u003c a && row + 1 \u003c s.b ? band[i + a + 1] : me;\n        if (me >= 0 && ((rt >= 0 && rt !== me) || (dn >= 0 && dn !== me) || (dg >= 0 && dg !== me))) (r = 0.62), (g = 0.6), (b = 0.66);\n      }\n      // The gliding block, with soft edges where it sits between LEDs.\n      if (gc) {\n        const ox = cl(min(x + 1 - gx, gx + c1 - x), 0, 1), oy = cl(min(y + 1 - gy, gy + c1 - y), 0, 1), w = ox * oy;\n        if (w > 0) (r += (gc[0] - r) * w), (g += (gc[1] - g) * w), (b += (gc[2] - b) * w);\n      }\n      if (fl > 0) (r += (1 - r) * fl), (g += (1 - g) * fl), (b += (1 - b) * fl);\n      const k = (y * W + x) * 3;\n      px[k] = r;\n      px[k + 1] = g;\n      px[k + 2] = b;\n    }\n  }\n  const put = (x, y, r, g, b, w) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const k = (y * W + x) * 3;\n    px[k] += (r - px[k]) * w;\n    px[k + 1] += (g - px[k + 1]) * w;\n    px[k + 2] += (b - px[k + 2]) * w;\n  };\n  // The staircases the hole has left, through the cells' middles.\n  const lw = cell \u003c= 4 ? 1 : cell \u003c= 8 ? 2 : 3, off = round((c1 - lw) / 2), tc = [1, 0.93, 0.78], ta = 0.9;\n  for (let rr = 0; rr \u003c s.b; rr++)\n    for (let cc = 0; cc \u003c a; cc++) {\n      const x0 = cc * cell + off, y0 = rr * cell + off;\n      const eh = cc \u003c a - 1 ? s.eh[rr * (a - 1) + cc] : 0, ev = rr \u003c s.b - 1 ? s.ev[rr * a + cc] : 0;\n      if (eh > 0.01) for (let x = x0; x \u003c x0 + cell + lw; x++) for (let d = 0; d \u003c lw; d++) put(x, y0 + d, tc[0], tc[1], tc[2], ta * eh);\n      if (ev > 0.01) for (let y = y0; y \u003c y0 + cell + lw; y++) for (let d = 0; d \u003c lw; d++) put(x0 + d, y, tc[0], tc[1], tc[2], ta * ev);\n    }\n  // Entries written in the cells when they are 16 LEDs or more.\n  if (cell >= 16) {\n    const sz = cell >= 32 ? 2 : 1;\n    const write = (v, x0, y0) => {\n      const str = String(v), wdt = str.length * 4 * sz - sz;\n      let x = round(x0 + (c1 - wdt) / 2);\n      const y = round(y0 + (c1 - 5 * sz) / 2);\n      for (const ch of str) {\n        const bits = DIG[ch.charCodeAt(0) - 48];\n        for (let p = 0; p \u003c 15; p++)\n          if (bits[p] === \"1\")\n            for (let dy = 0; dy \u003c sz; dy++) for (let dx = 0; dx \u003c sz; dx++) put(x + (p % 3) * sz + dx, y + floor(p / 3) * sz + dy, 0.03, 0.02, 0.06, 0.88);\n        x += 4 * sz;\n      }\n    };\n    for (let i = 0; i \u003c N; i++) if (Wk[i] > 0 && !(gc && i === path[s.j + 1])) write(Wk[i], (i % a) * cell, floor(i / a) * cell);\n    if (gc) write(gv, gx, gy);\n  }\n  // A white dot in each cell that holds what it held at the start.\n  const dsz = cell \u003c= 4 ? 1 : 2;\n  for (let i = 0; i \u003c N; i++)\n    if (s.home[i] && Wk[i] > 0) {\n      const x0 = (i % a) * cell + c1 - dsz - (cell > 4 ? 1 : 0), y0 = floor(i / a) * cell + (cell > 4 ? 1 : 0);\n      for (let dy = 0; dy \u003c dsz; dy++) for (let dx = 0; dx \u003c dsz; dx++) put(x0 + dx, y0 + dy, 1, 1, 1, 0.95);\n    }\n  // The count: a bar along the bottom gutter, k + u of N, with a tick at\n  // each band.\n  const bar = ((s.k + u) / N) * W;\n  for (let x = 0; x \u003c W; x++) {\n    const w = cl(bar - x, 0, 1), tick = ((x + 1) % (W / a) === 0) ? 0.25 : 0;\n    put(x, H - 1, 1, 0.85, 0.55, max(w * 0.9, tick));\n  }\n  for (let i = 0; i \u003c W * H; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(px[i * 3], 0, 1) * 255), round(cl(px[i * 3 + 1], 0, 1) * 255), round(cl(px[i * 3 + 2], 0, 1) * 255));\n}\n","rational-tangles":"// ===== Patternflow pattern =====\n// Title:   Rational Tangles\n// Family:  topology\n// Idea:    Two coloured ropes hang down the tall panel as a four-strand plat, capped at the top and loose at the bottom, and Conway's tangle dance plays on them: a twist T swaps the two middle ends at the foot so that the ropes really wind one more crossing in (x to x + 1), a rotate R carries all four ends one place round (x to -1/x), the fraction p/q in small figures changes with each call, and after a random string of calls the bottom ends close up into the two-bridge knot or link N(p/q), named by Schubert's classification, open again, and Conway's rule, rotate when positive and twist when negative, untangles the ropes back to 0.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rational tangles and their fractions (John H. Conway, \"An enumeration of knots and links, and some of their algebraic properties\", 1970) and the square dance of twists and rotations he used to show them; classification of two-bridge knots and links (Horst Schubert, \"Knoten mit zwei Brücken\", 1956); 3 by 5 capitals from Typewriter (pattern round 18) and 3 by 5 figures from Josephus (pattern round 68); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=6..14, Rope=-1..1\n//\n// Knob 1: Hue. Turns both ropes round the wheel together. At 0 rope A, the one capped on the left at [0], is cyan and rope B amber; at 0.5 A is red and B azure. Each rope keeps its colour through every call. A closed knot is one loop, so one rope takes the other's colour while the ends join; a closed link keeps both. The fraction is white, the calls grey, the undoing calls tinted like rope A, the name amber.\n// Knob 2: Speed. At 2 a call takes 0.75 s and a pause of 0.25 s, the ropes settle into the simplest picture in 0.45 s after one call in five, the ends close in 0.8 s, the knot holds for 2.6 s and opens in 0.8 s, and the dance waits 1.2 s at 0, so a dance lasts 21 s on average at Depth 6 and 36 s at 14. Everything scales as 2 / Speed: at 0.2 a call takes 7.5 s, at 3 half a second.\n// Knob 3: Depth. How many calls build the tangle, 6 to 14, drawn at random, T 65 times in 100, never R twice running and never R at 0, which would give 1/0, where a twist changes nothing. A dance is kept when it ends at p/q with |p| at least 3, holds at least 1 + floor((Depth - 6) / 4) calls of R (1 up to 9, 3 at 14) and never needs more than 12 crossings. At 6 the closure is a trefoil about two times in three and a figure-eight otherwise; at 10 it ranges over 4/1, 7/4, 10/7, 8/3, 13/8 and some thirty more. A crossing is 88 rows over the most crossings the dance will need, 16 at most: 16 at Depth 6, a median 14.7 at 8 and 10 and 12.6 at 12 and 14, 8.8 at the least. Conway's rule then undoes the tangle in 8 calls on average at Depth 6 and 14 at 14.\n// Knob 4: Rope. The rope's width, 3 x 2^Rope LEDs: 1.5 at -1, 3.1 at the opening 0.06 and 6 at 1, where the ropes nearly fill the 14 LEDs between neighbouring strands. The gap left where a rope passes under grows with it.\n// Buttons: K1 tap starts a new dance from 0.\n\n// A rational tangle is two strings in a ball with their four ends on the\n// boundary, NW, NE, SE and SW. Conway gave each one a fraction: [0] is two\n// arcs joining NW to NE and SW to SE, twisting the two right ends adds 1,\n// and turning the ball a quarter turn sends x to -1/x. Every rational tangle\n// is reached from [0] by twists and turns, and two are the same tangle\n// exactly when their fractions agree (Conway 1970; full proofs by Jay\n// Goldman and Louis Kauffman, 1997, and Kauffman and Sofia Lambropoulou,\n// 2004). Conway showed it with four people holding two ropes: on \"twist\"\n// the two on the right swap places, one passing under the other's rope; on\n// \"rotate\" all four step one place round; and to untangle any tangle, rotate\n// when its fraction is positive and twist when it is negative.\n// Closing NW to NE and SW to SE, the numerator closure, gives the\n// two-bridge link b(p, q); Schubert showed in 1956 that b(p, q) and b(p', q')\n// are the same unoriented link exactly when p = p' and q' = q or q q' = 1\n// mod p, and allowing mirror images, q' = -q or q q' = -1 as well.\n//\n// The panel draws the tangle as a plat: four lanes across the panel, ends 1\n// to 4 at the foot standing for NW, NE, SE and SW. The top is closed by caps,\n// 1-2 and 3-4 for [0], 2-3 inside 1-4 for [1/0]. Below come crossings, each\n// between lanes 2 and 3 (a horizontal twist, H) or lanes 1 and 2 (a vertical\n// twist, V, the twist of NW and NE). A T adds an H crossing at the foot, or\n// takes one away if the last crossing there was the opposite hand. An R\n// moves every end one place round the boundary: a crossing of lanes 2 and 3\n// becomes one of lanes 3 and 4, which on a rational tangle is the same as\n// one of lanes 1 and 2 (a flype), one of lanes 1 and 2 becomes one of 2 and\n// 3, every crossing keeps its hand and the caps swap. Worked through the\n// fractions that is x to -1/x. The picture is then the alternating one of\n// the regular continued fraction, all crossings of one sign alternating over\n// and under. A call that leaves a picture of another form, mostly a T just\n// after an R, is followed by the ropes settling into this one, their four\n// ends held still. Which hand counts as +1 is a convention;\n// the other choice would show every fraction as its negative, the mirror.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, sign, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst gcd = (a, b) => {\n  (a = abs(a)), (b = abs(b));\n  while (b) [a, b] = [b, a % b];\n  return a;\n};\n// The lanes' centres, the top of the crossings, the foot, the most crossings.\nconst X = [10.5, 24.5, 38.5, 52.5], YS = 28, YE = 116, MAXC = 12;\n// Seconds at Speed 2.\nconst T_MOVE = 0.75, T_SETTLE = 0.45, T_PAUSE = 0.25, T_CLOSE = 0.8, T_HOLD = 2.6, T_REST = 1.2;\n\n// ---- Fractions: p / q with q >= 0, 1/0 for infinity.\nfunction norm(p, q) {\n  if (q \u003c 0 || (q === 0 && p \u003c 0)) (p = -p), (q = -q);\n  const g = gcd(p, q) || 1;\n  return [p / g, q / g];\n}\nconst twist = ([p, q]) => (q === 0 ? [1, 0] : norm(p + q, q));\nconst turn = ([p, q]) => norm(-q, p);\n\n// ---- Diagrams: caps 0 or 1, and crossings from the top, each { p, o }:\n// p 1 between lanes 2 and 3, p 0 between lanes 1 and 2; o +1 when the\n// strand going down to the right passes over, -1 when it passes under.\n// The regular continued fraction, peeled from the foot: an H run of the\n// whole part while |x| >= 1, else a V run of the whole part of 1/x.\nfunction canon(p, q) {\n  const runs = [];\n  let caps;\n  for (;;) {\n    if (q === 0) {\n      caps = 1;\n      break;\n    }\n    if (p === 0) {\n      caps = 0;\n      break;\n    }\n    if (abs(p) >= q) {\n      const a = sign(p) * floor(abs(p) / q);\n      p -= a * q;\n      runs.push([1, a]);\n    } else {\n      const b = sign(p) * floor(q / abs(p));\n      q -= b * p;\n      runs.push([0, b]);\n    }\n  }\n  const steps = [];\n  for (let i = runs.length - 1; i >= 0; i--) {\n    const [t, a] = runs[i];\n    for (let k = 0; k \u003c abs(a); k++) steps.push({ p: t, o: t ? sign(a) : -sign(a) });\n  }\n  return { caps, steps };\n}\n// The literal moves on a picture.\nfunction litT(D) {\n  const st = D.steps.slice(), l = st[st.length - 1];\n  if (l && l.p === 1 && l.o === -1) st.pop();\n  else st.push({ p: 1, o: 1 });\n  return { caps: D.caps, steps: st };\n}\nconst litR = (D) => ({ caps: D.caps ^ 1, steps: D.steps.map((s) => ({ p: s.p ^ 1, o: s.o })) });\nconst same = (A, B) => A.caps === B.caps && A.steps.length === B.steps.length && A.steps.every((s, i) => s.p === B.steps[i].p && s.o === B.steps[i].o);\n// Which rope (0 or 1) runs in each lane below the last crossing.\nfunction ropesAtFoot(D) {\n  const r = D.caps ? [1, 0, 0, 1] : [0, 0, 1, 1];\n  for (const s of D.steps) [r[s.p], r[s.p + 1]] = [r[s.p + 1], r[s.p]];\n  return r;\n}\n\n// ---- Names of N(p/q), keyed by p and the least of q, -q, 1/q and -1/q\n// mod p, with Rolfsen's table numbers; \"^2_1\" is superscript 2, subscript 1.\nconst NAMES = {\n  \"2/1\": \"HOPF LINK\", \"3/1\": \"TREFOIL 3_1\", \"4/1\": \"SOLOMON 4^2_1\", \"5/1\": \"CINQUEFOIL 5_1\", \"5/2\": \"FIGURE-8 4_1\",\n  \"6/1\": \"LINK 6^2_1\", \"7/1\": \"KNOT 7_1\", \"7/2\": \"KNOT 5_2\", \"8/3\": \"WHITEHEAD 5^2_1\",\n  \"9/1\": \"KNOT 9_1\", \"9/2\": \"STEVEDORE 6_1\", \"10/3\": \"LINK 6^2_2\", \"11/2\": \"KNOT 7_2\", \"11/3\": \"KNOT 6_2\",\n  \"12/5\": \"LINK 6^2_3\", \"13/3\": \"KNOT 7_3\", \"13/5\": \"KNOT 6_3\", \"15/4\": \"KNOT 7_4\", \"17/5\": \"KNOT 7_5\",\n  \"19/7\": \"KNOT 7_6\", \"21/8\": \"KNOT 7_7\",\n};\nfunction inverse(q, p) {\n  for (let k = 1; k \u003c p; k++) if ((q * k) % p === 1) return k;\n  return 0;\n}\nfunction nameOf([p, q]) {\n  p = abs(p);\n  if (p === 0) return \"UNLINK\";\n  if (p === 1) return \"UNKNOT 0_1\";\n  const r = ((q % p) + p) % p, iv = inverse(r, p), c = min(r, p - r, iv, p - iv);\n  const key = p + \"/\" + c;\n  if (NAMES[key]) return NAMES[key];\n  // Unnamed here: the crossing number, the sum of the continued fraction.\n  let a = p, b = c, n = 0;\n  while (b) (n += floor(a / b)), ([a, b] = [b, a % b]);\n  return n + \"-CROSSING \" + (p % 2 ? \"KNOT\" : \"LINK\");\n}\n\n// ---- 3 x 5 capitals from Typewriter (copied from autogram.js), 3 x 5\n// figures from Josephus (copied from josephus.js), and a slash and a\n// lemniscate drawn here.\nconst G35 = {\n  A: \"010101111101101\", C: \"011100100100011\", D: \"110101101101110\", E: \"111100110100111\", F: \"111100110100100\",\n  G: \"011100101101011\", H: \"101101111101101\", I: \"111010010010111\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\", Q: \"010101101111011\",\n  R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\", U: \"101101101101011\", V: \"101101101010010\",\n  W: \"101101111111101\", \"-\": \"000000111000000\", \"/\": \"001001010100100\",\n};\nconst FIG = [0b111101101101111, 0b010110010010111, 0b111001111100111, 0b111001111001111, 0b101101111001001, 0b111100111001111, 0b111100111101111, 0b111001001001001, 0b111101111101111, 0b111101111001111];\nconst LEMNI = \".#.#.\" + \"#.#.#\" + \".#.#.\";\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The dance: the calls that build it and Conway's calls that undo it,\n// each with the picture before it (from), the literal picture after it (L)\n// and the alternating one (C). Ropes are labelled from the caps down, so a\n// new picture can swap the labels; f says which label rope A has, chosen so\n// that each rope keeps its colour: an R carries the end in lane i to lane\n// i + 1, and while the ropes settle no end moves.\nfunction step(m, x, D, f) {\n  const nx = m === \"T\" ? twist(x) : turn(x), L = m === \"T\" ? litT(D) : litR(D), C = canon(nx[0], nx[1]);\n  const a = ropesAtFoot(D), b = ropesAtFoot(L), c = ropesAtFoot(C);\n  const fL = m === \"R\" ? b[1] ^ a[0] ^ f : f, fC = c[0] ^ b[0] ^ fL;\n  return { m, x: nx, L, C, from: D, f0: f, fL, fC };\n}\nfunction plan(depth) {\n  let best = null;\n  for (let tries = 0; tries \u003c 60; tries++) {\n    let x = [0, 1], D = canon(0, 1), last = \"\", peak = 0, f = 0;\n    const build = [];\n    for (let i = 0; i \u003c depth; i++) {\n      // A turn of [0] would give 1/0, where a twist changes nothing and only\n      // a second turn, undoing the first, could follow.\n      let m = Math.random() \u003c 0.65 ? \"T\" : \"R\";\n      if (x[0] === 0 || last === \"R\") m = \"T\";\n      const c = step(m, x, D, f);\n      build.push(c);\n      peak = max(peak, c.L.steps.length, c.C.steps.length);\n      (x = c.x), (D = c.C), (f = c.fC), (last = m);\n    }\n    const undo = [];\n    for (let k = 0; k \u003c 60 && !(x[0] === 0 && x[1] === 1); k++) {\n      const c = step(x[1] === 0 || x[0] > 0 ? \"R\" : \"T\", x, D, f);\n      undo.push(c);\n      peak = max(peak, c.L.steps.length, c.C.steps.length);\n      (x = c.x), (D = c.C), (f = c.fC);\n    }\n    const end = build[build.length - 1].x, turns = build.filter((c) => c.m === \"R\").length;\n    const good = abs(end[0]) >= 3 && turns >= 1 + floor((depth - 6) / 4) && peak \u003c= MAXC;\n    best = { build, undo, peak, end };\n    if (good) break;\n  }\n  return best;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, depth: 6, width: 3.1, btn: false, started: false,\n    acc: new Float32Array(W * H * 3), buf: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\nfunction newDance(S) {\n  const P = (S.plan = plan(S.depth));\n  S.h = cl(88 / max(3, P.peak), 6, 16);\n  S.calls = [...P.build.map((c) => ({ ...c, undo: false })), { close: true }, ...P.undo.map((c) => ({ ...c, undo: true }))];\n  S.k = -1;\n  S.pt = 0;\n  S.x = [0, 1];\n  S.D = canon(0, 1);\n  S.f = 0;\n  S.said = \"\";\n  S.undoSaid = \"\";\n  S.stage = \"rest0\";\n}\n\n// Stages: a call (move, then settle), the closing, the hold, the opening,\n// the rest at 0. The stage clock is in seconds at Speed 2.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const depth = round(cl(k[2] == null ? 6 : k[2], 6, 14)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  S.width = 3 * 2 ** cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  if (!S.started || depth !== S.depth || (btn && !S.btn)) {\n    S.depth = depth;\n    S.started = true;\n    newDance(S);\n  }\n  S.btn = btn;\n  S.pt += (d * S.speed) / 2;\n  for (let guard = 0; guard \u003c 4; guard++) {\n    const c = S.calls[S.k];\n    if (S.stage === \"rest0\") {\n      if (S.pt \u003c (S.k \u003c 0 ? 0.6 : T_REST)) break;\n      if (S.k >= 0) return void newDance(S);\n      next(S);\n    } else if (S.stage === \"move\") {\n      if (S.pt \u003c T_MOVE) break;\n      S.pt -= T_MOVE;\n      S.x = c.x;\n      S.D = c.L;\n      S.f = c.fL;\n      S.stage = same(c.L, c.C) ? \"pause\" : \"settle\";\n    } else if (S.stage === \"settle\") {\n      if (S.pt \u003c T_SETTLE) break;\n      S.pt -= T_SETTLE;\n      S.D = c.C;\n      S.f = c.fC;\n      S.stage = \"pause\";\n    } else if (S.stage === \"pause\") {\n      if (S.pt \u003c T_PAUSE) break;\n      S.pt -= T_PAUSE;\n      next(S);\n    } else if (S.stage === \"close\") {\n      if (S.pt \u003c T_CLOSE) break;\n      (S.pt -= T_CLOSE), (S.stage = \"hold\");\n    } else if (S.stage === \"hold\") {\n      if (S.pt \u003c T_HOLD) break;\n      (S.pt -= T_HOLD), (S.stage = \"open\");\n    } else if (S.stage === \"open\") {\n      if (S.pt \u003c T_CLOSE) break;\n      S.pt -= T_CLOSE;\n      next(S);\n    } else break;\n  }\n}\n\nfunction next(S) {\n  S.k++;\n  const c = S.calls[S.k];\n  if (!c) return void ((S.stage = \"rest0\"), (S.pt = 0));\n  if (c.close) return void (S.stage = \"close\");\n  S.stage = \"move\";\n  if (c.undo) S.undoSaid += c.m;\n  else S.said += c.m;\n}\n\n// ---- Drawing. Ropes are drawn row by row: in a crossing the two strands\n// follow x = mid -+ d cos(theta t) down its height, so a whole crossing is\n// a half turn of the pair, and a twist that is still under way is the same\n// picture with theta short of pi, its foot still turning.\n\nfunction putRope(acc, x, y, xc, hw, col, lv, cut) {\n  const off = x + 0.5 - xc, cov = cl(hw + 0.5 - abs(off), 0, 1) * lv * cut;\n  if (cov \u003c= 0) return;\n  // Round: darker towards the edges; laid: a slanting strand every 3 rows.\n  const u = off / max(hw, 0.6), lay = 0.82 + 0.18 * cos(2 * PI * ((y + 0.5) / 3.2 + 0.35 * u));\n  const v = (1 - 0.45 * u * u) * lay, k = (y * W + x) * 3;\n  for (let q = 0; q \u003c 3; q++) acc[k + q] = acc[k + q] * (1 - cov) + col[q] * v * cov;\n}\nfunction strandRow(acc, y, xc, slope, w, col, lv, mask) {\n  const hw = (w / 2) * sqrt(1 + slope * slope);\n  for (let x = max(0, floor(xc - hw - 1)); x \u003c= min(W - 1, floor(xc + hw + 1)); x++) {\n    let cut = 1;\n    if (mask) cut = cl(abs(x + 0.5 - mask[0]) - mask[1] - mask[2] + 0.5, 0, 1);\n    putRope(acc, x, y, xc, hw, col, lv, cut);\n  }\n}\n// A capsule chain for the caps and cups: a half ellipse about (cx, cy)\n// bulging up (dir -1) or down (dir +1), drawn from angle a0 to a1.\nfunction arc(acc, cx, cy, rx, ry, dir, a0, a1, w, colA, colB) {\n  if (a1 \u003c= a0) return;\n  const n = 20, px = [], py = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const th = a0 + ((a1 - a0) * i) / n;\n    px.push(cx - rx * cos(th));\n    py.push(cy + dir * ry * sin(th));\n  }\n  const hw = w / 2, x0 = max(0, floor(min(...px) - hw - 1)), x1 = min(W - 1, floor(max(...px) + hw + 1));\n  const y0 = max(0, floor(min(...py) - hw - 1)), y1 = min(H - 1, floor(max(...py) + hw + 1));\n  const col = [0, 0, 0];\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      let dm = 1e9, tm = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const ax = px[i], ay = py[i], bx = px[i + 1] - ax, by = py[i + 1] - ay, l2 = bx * bx + by * by || 1;\n        const t = cl(((x + 0.5 - ax) * bx + (y + 0.5 - ay) * by) / l2, 0, 1), dd = (x + 0.5 - ax - t * bx) ** 2 + (y + 0.5 - ay - t * by) ** 2;\n        if (dd \u003c dm) (dm = dd), (tm = (i + t) / n);\n      }\n      const dist = sqrt(dm), cov = cl(hw + 0.5 - dist, 0, 1);\n      if (cov \u003c= 0) continue;\n      const g = (a0 + (a1 - a0) * tm) / PI;\n      for (let q = 0; q \u003c 3; q++) col[q] = colA[q] + (colB[q] - colA[q]) * g;\n      const u = dist / max(hw, 0.6), v = (1 - 0.45 * u * u) * (0.82 + 0.18 * cos(2 * PI * (tm * 9 + 0.35 * u))), k = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) acc[k + q] = acc[k + q] * (1 - cov) + col[q] * v * cov;\n    }\n}\n\n// One picture into acc: D the diagram, dx its sideways shift,\n// tw the share of a half turn the last crossing has made (1 when done),\n// cup how far the foot has closed, cols the two ropes' colours by lane.\nfunction picture(S, acc, D, dx, tw, cup, cols) {\n  const w = S.width, h = S.h, n = D.steps.length, gap = 0.9 + 0.25 * w;\n  const lane = X.map((v) => v + dx);\n  const caps = D.caps;\n  // Caps.\n  if (caps === 0) {\n    arc(acc, (lane[0] + lane[1]) / 2, YS, 7, 9, -1, 0, PI, w, cols[0], cols[0]);\n    arc(acc, (lane[2] + lane[3]) / 2, YS, 7, 9, -1, 0, PI, w, cols[1], cols[1]);\n  } else {\n    arc(acc, (lane[0] + lane[3]) / 2, YS, 21, 11, -1, 0, PI, w, cols[1], cols[1]);\n    arc(acc, (lane[1] + lane[2]) / 2, YS, 7, 5.5, -1, 0, PI, w, cols[0], cols[0]);\n  }\n  // Rope per lane, going down.\n  const rope = caps ? [1, 0, 0, 1] : [0, 0, 1, 1];\n  let y0 = YS;\n  const xs = lane.slice();\n  for (let i = 0; i \u003c n; i++) {\n    const s = D.steps[i], last = i === n - 1, th = last ? PI * tw : PI, hh = last ? h * max(tw, 0.001) : h;\n    const p = s.p, mid = (xs[p] + xs[p + 1]) / 2, half = (xs[p + 1] - xs[p]) / 2;\n    const ya = floor(y0), yb = floor(y0 + hh);\n    for (let y = max(0, ya); y \u003c min(H, yb); y++) {\n      const t = cl((y + 0.5 - y0) / hh, 0, 1), c = cos(th * t), sn = sin(th * t), sl = (half * th * sn) / hh;\n      for (let L = 0; L \u003c 4; L++) if (L !== p && L !== p + 1) strandRow(acc, y, xs[L], 0, w, cols[rope[L]], 1, null);\n      const xl = mid - half * c, xr = mid + half * c, hwo = (w / 2) * sqrt(1 + sl * sl);\n      // The strand from the left lane is in front when o is +1.\n      const lf = s.o > 0;\n      const [xu, su, cu, xo, so, co] = lf ? [xr, -sl, cols[rope[p + 1]], xl, sl, cols[rope[p]]] : [xl, sl, cols[rope[p]], xr, -sl, cols[rope[p + 1]]];\n      const near = abs(xl - xr) \u003c 2 * hwo + 2 * gap + 2;\n      strandRow(acc, y, xu, su, w, cu, near ? 0.85 : 1, near ? [xo, hwo, gap] : null);\n      strandRow(acc, y, xo, so, w, co, 1, null);\n    }\n    // After the crossing the lanes carry each other's ropes, and an\n    // unfinished twist leaves its two ends partway round.\n    const ce = cos(th);\n    xs[p] = mid - half * ce;\n    xs[p + 1] = mid + half * ce;\n    if (th > PI / 2) [rope[p], rope[p + 1]] = [rope[p + 1], rope[p]];\n    if (th > PI / 2) [xs[p], xs[p + 1]] = [xs[p + 1], xs[p]];\n    y0 += hh;\n  }\n  // Below the crossings straight down to the foot, then the cups.\n  const yf = cup > 0 ? YE : H;\n  for (let y = max(0, floor(y0)); y \u003c min(H, yf); y++) for (let L = 0; L \u003c 4; L++) strandRow(acc, y, xs[L], 0, w, cols[rope[L]], 1, null);\n  if (cup > 0) {\n    const e = smooth(cup), ytail = YE + (H - YE) * (1 - e);\n    for (let y = YE; y \u003c min(H, ytail); y++) for (let L = 0; L \u003c 4; L++) strandRow(acc, y, xs[L], 0, w, cols[rope[L]], 1, null);\n    for (const [l0, l1] of [[0, 1], [2, 3]]) {\n      const cx = (xs[l0] + xs[l1]) / 2, rx = (xs[l1] - xs[l0]) / 2, ca = cols[rope[l0]], cb = cols[rope[l1]];\n      arc(acc, cx, YE, rx, 8, 1, 0, (PI / 2) * e, w, ca, cb);\n      arc(acc, cx, YE, rx, 8, 1, PI - (PI / 2) * e, PI, w, ca, cb);\n    }\n  }\n}\n\n// ---- Text.\nfunction glyph(acc, ch, x, y, col) {\n  let bits = null;\n  if (ch >= \"0\" && ch \u003c= \"9\") {\n    const f = FIG[ch.charCodeAt(0) - 48];\n    bits = [];\n    for (let i = 14; i >= 0; i--) bits.push((f >> i) & 1);\n  } else if (G35[ch]) bits = [...G35[ch]].map(Number);\n  if (ch === \"~\") {\n    for (let i = 0; i \u003c 15; i++) if (LEMNI[i] === \"#\") dotPx(acc, x + (i % 5), y + 1 + floor(i / 5), col);\n    return 5;\n  }\n  if (bits) for (let i = 0; i \u003c 15; i++) if (bits[i]) dotPx(acc, x + (i % 3), y + floor(i / 3), col);\n  return 3;\n}\nfunction dotPx(acc, x, y, col) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const k = (y * W + x) * 3;\n  for (let q = 0; q \u003c 3; q++) acc[k + q] = col[q];\n}\n// \"_\" before a figure lowers it three rows, \"^\" raises it two; a lowered\n// figure right after a raised one stands under it.\nfunction text(acc, str, cx, y, col) {\n  let wd = 0;\n  for (let i = 0; i \u003c str.length; i++) {\n    const ch = str[i];\n    if (ch === \"_\" || ch === \"^\") continue;\n    if (str[i - 1] === \"_\" && str[i - 3] === \"^\") continue;\n    wd += (ch === \"~\" ? 5 : 3) + 1;\n  }\n  let x = round(cx - (wd - 1) / 2);\n  for (let i = 0; i \u003c str.length; i++) {\n    const ch = str[i];\n    if (ch === \"_\" || ch === \"^\") continue;\n    const dy = str[i - 1] === \"_\" ? 3 : str[i - 1] === \"^\" ? -2 : 0;\n    if (str[i - 1] === \"_\" && str[i - 3] === \"^\") x -= 4;\n    x += (ch === \" \" ? 3 : glyph(acc, ch, x, y + dy, col)) + 1;\n  }\n}\nconst fracText = ([p, q]) => (q === 0 ? \"~\" : (p \u003c 0 ? \"-\" : \"\") + abs(p) + \"/\" + q);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.plan) return;\n  const acc = S.acc, buf = S.buf;\n  acc.fill(0);\n  const A = hsv(S.hue + 0.5, 0.85, 1), B = hsv(S.hue + 0.11, 0.85, 1);\n  const c = S.calls[S.k], AB = [A, B], BA = [B, A];\n  let cols = S.f ? BA : AB;\n  const stage = S.stage;\n  if (stage === \"close\" || stage === \"hold\" || stage === \"open\") {\n    // A knot is one loop: one rope takes the other's colour as the ends join.\n    const D = S.D, r = ropesAtFoot(D), knot = r[0] !== r[1];\n    const e = stage === \"close\" ? smooth(S.pt / T_CLOSE) : stage === \"hold\" ? 1 : 1 - smooth(S.pt / T_CLOSE);\n    if (knot) cols = [cols[0], cols[1].map((v, i) => v + (cols[0][i] - v) * e)];\n    picture(S, acc, D, 0, 1, e, cols);\n  } else if (stage === \"move\" && c && c.m === \"T\") {\n    // A twist: the literal picture after it, its last crossing turning in,\n    // or the picture before it with its last crossing turning out.\n    const u = smooth(S.pt / T_MOVE);\n    cols = c.fL ? BA : AB;\n    if (c.L.steps.length > c.from.steps.length) picture(S, acc, c.L, 0, u, 0, cols);\n    else picture(S, acc, c.from, 0, 1 - u, 0, cols);\n  } else if (stage === \"move\" && c && c.m === \"R\") {\n    // A rotation: every end steps one lane round; the old picture slides\n    // off to the right as the new one comes in from the left.\n    const u = smooth(S.pt / T_MOVE);\n    picture(S, acc, c.from, 14 * u, 1, 0, c.f0 ? BA : AB);\n    buf.fill(0);\n    picture(S, buf, c.L, -14 * (1 - u), 1, 0, c.fL ? BA : AB);\n    for (let i = 0; i \u003c acc.length; i++) acc[i] += (buf[i] - acc[i]) * u;\n  } else if (stage === \"settle\") {\n    const u = smooth(S.pt / T_SETTLE);\n    picture(S, acc, c.L, 0, 1, 0, c.fL ? BA : AB);\n    buf.fill(0);\n    picture(S, buf, c.C, 0, 1, 0, c.fC ? BA : AB);\n    for (let i = 0; i \u003c acc.length; i++) acc[i] += (buf[i] - acc[i]) * u;\n  } else picture(S, acc, S.D, 0, 1, 0, cols);\n  // The fraction on the first line; the calls, or the name, on the second.\n  const white = [0.92, 0.92, 0.88];\n  const fx = stage === \"move\" ? (S.pt / T_MOVE > 0.5 ? c.x : S.x) : S.x;\n  text(acc, fracText(fx), 32, 1, white);\n  if (stage === \"close\" || stage === \"hold\" || stage === \"open\") {\n    const e = stage === \"close\" ? S.pt / T_CLOSE : stage === \"open\" ? 1 - S.pt / T_CLOSE : 1;\n    if (e > 0.5) text(acc, nameOf(S.x), 32, 8, [1, 0.85, 0.55]);\n  } else {\n    const said = S.undoSaid ? S.undoSaid.slice(-15) : S.said;\n    text(acc, said, 32, 8, S.undoSaid ? A.map((v) => 0.35 + 0.6 * v) : [0.75, 0.75, 0.75]);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(acc[k], 0, 1) * 255), round(cl(acc[k + 1], 0, 1) * 255), round(cl(acc[k + 2], 0, 1) * 255));\n    }\n}\n","reed-solomon":"// ===== Patternflow pattern =====\n// Title:   Reed-Solomon\n// Family:  data\n// Idea:    A word becomes a real version 1 QR code, 21 modules of 3 LEDs, its codewords standing above as columns of bits, data and error correction in two colours, the bits snaking into the symbol from the bottom right and the mask swept over them; then a scratch, a blot or a bite spoils part of it, the decoder lights the syndromes and finds the bad codewords by Berlekamp-Massey, Chien search and Forney's formula, and if they are at most half the error correction codewords the spoiled modules flash back, otherwise the count turns red.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Reed-Solomon codes (Irving S. Reed and Gustave Solomon, 1960) in a version 1 QR code (Masahiro Hara, Denso Wave, 1994), decoded with the Berlekamp-Massey algorithm (Elwyn Berlekamp, 1968; James Massey, 1969), Chien search (Robert Chien, 1964) and Forney's formula (G. David Forney, 1965), pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Damage=8..60, Data=9..19\n//\n// Knob 1: Hue. Turns data, error correction and damage round the wheel together, a quarter turn or more apart: cyan, violet and red at 0; red, yellow-green and cyan-blue at 0.5. Finders stay warm white, format bits pale gold.\n// Knob 2: Speed. At 2 a word takes 10.9 s: set and computed 1.2 s, placed 1.8 s, masked 0.6 s, held 0.6 s, spoiled 0.5 s, read 0.7 s, errors found 0.8 s, repaired 1 s, held 3.2 s, cleared 0.5 s. The first word opens with its bits placed, just before the mask. At 0.2 each step takes ten times as long, at 3 two thirds.\n// Knob 3: Damage. The spoiled area, 8 to 60 square modules, times a random 0.7 to 1.5 a word. A blot makes modules dark, a bite out of an edge and a scratch 1.2 modules wide make them light. At 8 a hurt mostly spoils 0 to 4 codewords and H, Q and M mend 996 in 1000. At 60 a blot 4.4 modules in radius spoils 2 to 11: H mends 74 percent, M 47, L 19. A scratch spoils only 2 to 7, crossing codewords 2 modules wide.\n// Knob 4: Data. How many of the 26 codewords carry the word, and so the level: 9 is H (17 error correction codewords, mends 8), 13 is Q (13, mends 6), 16 is M (10, mends 5), 19 is L (7, mends 3). A syndrome cell for each error correction codeword, a budget slot for each one it mends. A new level rebuilds the symbol at once.\n// Buttons: K1 tap spoils the finished symbol again with the next hurt.\n\n// A version 1 QR code holds 26 codewords of 8 bits. The first k carry the\n// word in alphanumeric mode, padded with 236 and 17; the other n = 26 - k are\n// the remainder of that polynomial times x^n divided by\n// g(x) = (x - a^0)...(x - a^(n-1)) over GF(256), a = 2, built on 0x11D. So\n// what is read, taken at a^0 ... a^(n-1), gives n syndromes that are all zero\n// unless something changed. From them Berlekamp-Massey finds the shortest\n// error locator, Chien search tries every position for its roots and\n// Forney's formula gives the value to XOR back: up to n / 2 codewords. The\n// QR standard trusts fewer at version 1 (2, 4, 6, 8 for L, M, Q, H) and\n// keeps the rest against misreading; their budget slots are dimmer.\n//\n// The decoder reads the symbol as a scanner does once it has found it: the\n// two copies of the 15 format bits, the nearest valid one (within 3 bits),\n// the mask it names, then the 208 data modules in zig-zag order.\n\nconst W = 64, H = 128, N = 21, SX = 1, SY = 38, CY = 11, TY = 1;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- GF(256) on 0x11D, a = 2.\nconst EXP = new Uint8Array(512), LOG = new Uint8Array(256);\nfor (let i = 0, x = 1; i \u003c 255; i++) {\n  EXP[i] = EXP[i + 255] = x;\n  LOG[x] = i;\n  x \u003c\u003c= 1;\n  if (x & 256) x ^= 0x11d;\n}\nconst mul = (a, b) => (a && b ? EXP[LOG[a] + LOG[b]] : 0);\nconst div = (a, b) => (a ? EXP[LOG[a] + 255 - LOG[b]] : 0);\n\n// Remainder of data(x) x^n mod g(x), highest power first.\nfunction rsRemainder(data, n) {\n  let g = [1];\n  for (let i = 0; i \u003c n; i++) {\n    const h = new Array(g.length + 1).fill(0);\n    for (let j = 0; j \u003c g.length; j++) (h[j] ^= g[j]), (h[j + 1] ^= mul(g[j], EXP[i]));\n    g = h;\n  }\n  const rem = new Array(n).fill(0);\n  for (const d of data) {\n    const f = d ^ rem.shift();\n    rem.push(0);\n    for (let i = 0; i \u003c n; i++) rem[i] ^= mul(g[i + 1], f);\n  }\n  return rem;\n}\n// The received polynomial at a^0 ... a^(n-1).\nconst syndromes = (cw, n) => Array.from({ length: n }, (_, j) => cw.reduce((v, c) => mul(v, EXP[j]) ^ c, 0));\n// Berlekamp-Massey: the shortest LFSR (error locator, lowest power first)\n// that generates the syndromes.\nfunction berlekamp(S) {\n  let C = [1], B = [1], L = 0, m = 1, b = 1;\n  for (let k = 0; k \u003c S.length; k++) {\n    let d = S[k];\n    for (let i = 1; i \u003c= L; i++) d ^= mul(C[i] || 0, S[k - i]);\n    if (!d) { m++; continue; }\n    const T = C.slice(), coef = div(d, b);\n    for (let i = 0; i \u003c B.length; i++) C[i + m] = (C[i + m] || 0) ^ mul(coef, B[i]);\n    if (2 * L \u003c= k) (L = k + 1 - L), (B = T), (b = d), (m = 1);\n    else m++;\n  }\n  return { C, L };\n}\n// Codeword i is the coefficient of x^(25 - i). Returns the syndromes, the\n// codewords found wrong, the mended codewords and whether it worked.\nfunction rsDecode(cw, n) {\n  const S = syndromes(cw, n), out = { S, errs: [], fixed: cw.slice(), ok: true };\n  if (S.every((v) => !v)) return out;\n  const { C, L } = berlekamp(S);\n  out.ok = false;\n  if (L > n >> 1) return out;\n  // Chien search: position p is wrong where the locator vanishes at a^-p.\n  const ps = [];\n  for (let p = 0; p \u003c 26; p++) {\n    let v = 0;\n    for (let i = 0; i \u003c C.length; i++) v ^= mul(C[i], EXP[(255 - ((p * i) % 255)) % 255]);\n    if (!v) ps.push(p);\n  }\n  out.errs = ps.map((p) => 25 - p);\n  if (ps.length !== L) return out;\n  // Forney: e = X Omega(1/X) / Lambda'(1/X), Omega = S Lambda mod x^n.\n  const Om = new Array(n).fill(0);\n  for (let i = 0; i \u003c n; i++) for (let j = 0; j \u003c= i && j \u003c C.length; j++) Om[i] ^= mul(C[j], S[i - j]);\n  for (const p of ps) {\n    const xi = EXP[(255 - p) % 255];\n    let om = 0, dl = 0;\n    for (let i = n - 1; i >= 0; i--) om = mul(om, xi) ^ Om[i];\n    for (let i = 1; i \u003c C.length; i += 2) dl ^= mul(C[i], EXP[(LOG[xi] * (i - 1)) % 255]);\n    if (!dl) return out;\n    out.fixed[25 - p] ^= mul(EXP[p], div(om, dl));\n  }\n  out.ok = syndromes(out.fixed, n).every((v) => !v);\n  return out;\n}\n\n// ---- The message, in alphanumeric mode.\nconst ALNUM = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:\";\nconst WORDS = [\"REED\", \"SOLOMON\", \"GALOIS\", \"SYNDROME\", \"LIGHT\", \"KNOB\", \"PATTERN\", \"ERASURE\"];\nfunction encode(word, k) {\n  const bits = [], put = (v, n) => { for (let i = n - 1; i >= 0; i--) bits.push((v >> i) & 1); };\n  put(2, 4);\n  put(word.length, 9);\n  for (let i = 0; i + 1 \u003c word.length; i += 2) put(45 * ALNUM.indexOf(word[i]) + ALNUM.indexOf(word[i + 1]), 11);\n  if (word.length % 2) put(ALNUM.indexOf(word[word.length - 1]), 6);\n  for (let i = 0; i \u003c 4 && bits.length \u003c 8 * k; i++) bits.push(0);\n  while (bits.length % 8) bits.push(0);\n  const out = [];\n  for (let i = 0; i \u003c bits.length; i += 8) out.push(bits.slice(i, i + 8).reduce((a, b) => (a \u003c\u003c 1) | b, 0));\n  for (let pad = 0xec; out.length \u003c k; pad ^= 0xec ^ 0x11) out.push(pad);\n  return out;\n}\n// What the data codewords say, read leniently: a wrong mode or length\n// gives question marks, a pair past 44 x 45 + 44 two of them.\nfunction parse(cw, k, len) {\n  let pos = 0;\n  const take = (n) => {\n    let v = 0;\n    for (let i = 0; i \u003c n; i++, pos++) v = (v \u003c\u003c 1) | (pos \u003c 8 * k ? (cw[pos >> 3] >> (7 - (pos & 7))) & 1 : 0);\n    return v;\n  };\n  const mode = take(4), count = take(9);\n  if (mode !== 2 || count > 25) return \"?\".repeat(len);\n  let s = \"\";\n  for (let i = 0; i \u003c count && pos \u003c 8 * k; i += 2) {\n    if (i + 1 === count) s += ALNUM[take(6)] || \"?\";\n    else {\n      const v = take(11);\n      s += v \u003c 2025 ? ALNUM[floor(v / 45)] + ALNUM[v % 45] : \"??\";\n    }\n  }\n  return s;\n}\n\n// ---- The symbol. Levels in the order of the Data knob, with the two bits\n// the format info gives each.\nconst LEVELS = [{ k: 9, bits: 2 }, { k: 13, bits: 3 }, { k: 16, bits: 0 }, { k: 19, bits: 1 }];\nconst STD = [8, 6, 4, 2];\nconst FN = new Uint8Array(N * N), BASE = new Uint8Array(N * N);\nconst setF = (x, y, v) => ((FN[y * N + x] = 1), (BASE[y * N + x] = v));\nfor (let i = 0; i \u003c N; i++) setF(6, i, +(i % 2 === 0)), setF(i, 6, +(i % 2 === 0));\nfor (const [cx, cy] of [[3, 3], [N - 4, 3], [3, N - 4]])\n  for (let dy = -4; dy \u003c= 4; dy++)\n    for (let dx = -4; dx \u003c= 4; dx++) {\n      const x = cx + dx, y = cy + dy, d = max(abs(dx), abs(dy));\n      if (x >= 0 && x \u003c N && y >= 0 && y \u003c N) setF(x, y, +(d !== 2 && d !== 4));\n    }\n// The 15 format bits, bit i at FMT[0][i] beside the top left finder and\n// again at FMT[1][i] split under the top right and beside the bottom left.\nconst FMT = [[], []];\nfor (let i = 0; i \u003c= 5; i++) FMT[0].push([8, i]);\nFMT[0].push([8, 7], [8, 8], [7, 8]);\nfor (let i = 9; i \u003c 15; i++) FMT[0].push([14 - i, 8]);\nfor (let i = 0; i \u003c 8; i++) FMT[1].push([N - 1 - i, 8]);\nfor (let i = 8; i \u003c 15; i++) FMT[1].push([8, N - 15 + i]);\nconst ISFMT = new Uint8Array(N * N);\nfor (const [x, y] of [...FMT[0], ...FMT[1]]) setF(x, y, 0), (ISFMT[y * N + x] = 1);\nsetF(8, N - 8, 1);\nfunction formatBits(level, mask) {\n  const data = (LEVELS[level].bits \u003c\u003c 3) | mask;\n  let rem = data;\n  for (let i = 0; i \u003c 10; i++) rem = (rem \u003c\u003c 1) ^ ((rem >> 9) * 0x537);\n  return ((data \u003c\u003c 10) | rem) ^ 0x5412;\n}\n// The data modules in placement order: two-module columns from the right,\n// up then down, skipping the timing column.\nconst ORDER = [];\nfor (let right = N - 1; right >= 1; right -= 2) {\n  if (right === 6) right = 5;\n  for (let vert = 0; vert \u003c N; vert++)\n    for (let j = 0; j \u003c 2; j++) {\n      const x = right - j, y = ((right + 1) & 2) === 0 ? N - 1 - vert : vert;\n      if (!FN[y * N + x]) ORDER.push(y * N + x);\n    }\n}\n// Which bit of the 208 each module carries (-1 for function modules).\nconst BITOF = new Int16Array(N * N).fill(-1);\nORDER.forEach((p, i) => (BITOF[p] = i));\n// The eight masks: a module flips where its expression is 0.\nfunction maskAt(m, p) {\n  const x = p % N, y = floor(p / N), a = (x * y) % 2, b = (x * y) % 3;\n  return +([(x + y) % 2, y % 2, x % 3, (x + y) % 3, (floor(x / 3) + floor(y / 2)) % 2, a + b, (a + b) % 2, (((x + y) % 2) + b) % 2][m] === 0);\n}\n\nfunction compose(cw, level, m) {\n  const mat = BASE.slice(), f = formatBits(level, m);\n  ORDER.forEach((p, i) => (mat[p] = ((cw[i >> 3] >> (7 - (i & 7))) & 1) ^ maskAt(m, p)));\n  for (let i = 0; i \u003c 15; i++) for (const c of FMT) mat[c[i][1] * N + c[i][0]] = (f >> i) & 1;\n  return mat;\n}\n// The standard's four penalties: runs of five or more, 2x2 blocks, finder\n// look-alikes with four light modules on a side, and imbalance of dark.\nfunction penalty(mat) {\n  let p = 0, dark = 0;\n  for (let pass = 0; pass \u003c 2; pass++)\n    for (let a = 0; a \u003c N; a++) {\n      const at = (b) => (b \u003c 0 || b >= N ? 0 : pass ? mat[b * N + a] : mat[a * N + b]);\n      let run = 1;\n      for (let b = 1; b \u003c= N; b++) {\n        if (b \u003c N && at(b) === at(b - 1)) run++;\n        else (p += run >= 5 ? run - 2 : 0), (run = 1);\n      }\n      // Runs of exactly 1, 1, 3, 1, 1; off the symbol counts as light.\n      for (let b = 0; b + 6 \u003c N; b++)\n        if (!at(b - 1) && at(b) && !at(b + 1) && at(b + 2) && at(b + 3) && at(b + 4) && !at(b + 5) && at(b + 6) && !at(b + 7)) {\n          if (!at(b - 2) && !at(b - 3) && !at(b - 4)) p += 40;\n          if (!at(b + 8) && !at(b + 9) && !at(b + 10)) p += 40;\n        }\n    }\n  for (let y = 0; y \u003c N; y++)\n    for (let x = 0; x \u003c N; x++) {\n      const v = mat[y * N + x];\n      dark += v;\n      if (x \u003c N - 1 && y \u003c N - 1 && v === mat[y * N + x + 1] && v === mat[(y + 1) * N + x] && v === mat[(y + 1) * N + x + 1]) p += 3;\n    }\n  return p + 10 * (Math.ceil(abs(dark * 20 - N * N * 10) / (N * N)) - 1);\n}\nfunction build(word, level) {\n  const k = LEVELS[level].k, data = encode(word, k), cw = data.concat(rsRemainder(data, 26 - k));\n  let best = 0, bp = 1e9;\n  for (let m = 0; m \u003c 8; m++) {\n    const p = penalty(compose(cw, level, m));\n    if (p \u003c bp) (bp = p), (best = m);\n  }\n  return { word, level, k, n: 26 - k, cw, mask: best, mat: compose(cw, level, best) };\n}\n// Read a symbol as a scanner does once it has found it.\nfunction readSymbol(mat) {\n  let f = null, fd = 99;\n  for (const c of FMT) {\n    let v = 0;\n    for (let i = 0; i \u003c 15; i++) v |= mat[c[i][1] * N + c[i][0]] \u003c\u003c i;\n    for (let g = 0; g \u003c 32; g++) {\n      let d = 0;\n      for (let x = v ^ formatBits(g >> 3, g & 7); x; x &= x - 1) d++;\n      if (d \u003c fd) (fd = d), (f = { l: g >> 3, m: g & 7 });\n    }\n  }\n  if (fd > 3) return null;\n  const cw = new Array(26).fill(0);\n  ORDER.forEach((p, i) => (cw[i >> 3] |= (mat[p] ^ maskAt(f.m, p)) \u003c\u003c (7 - (i & 7))));\n  return { level: f.l, mask: f.m, cw };\n}\n\n// ---- 5x7 capitals, digits and the alphanumeric mode's signs, drawn for\n// this pattern: seven base-32 digits a glyph, rows from the top, 16 the left\n// column.\nconst FONT_CH = ALNUM + \"?\";\nconst FONT =\n  \"ehjlphe4c4444eeh1248vv2421he26aiv22vgu11he68guhhev124888ehhehheehhf12cehhvhhhuhhuhhu\" +\n  \"ehggghesihhhisvgguggvvggugggehgnhhfhhhvhhhe44444e72222ichikokihggggggvhrllhhhhhpljhh\" +\n  \"ehhhhheuhhugggehhhliduhhukihfgge11uv444444hhhhhhehhhhha4hhhlllahha4ahhhhha444v1248gv\" +\n  \"00000004fke5u4op248j304lel40044v440000v00000000cc01248g00cc0cc0eh12404\";\n\n// ---- Layout, top to bottom: the word, marks over the codewords found\n// wrong, the codeword columns, the symbol, the syndromes, the budget of\n// codewords the level mends, the count.\nconst MARK_Y = 9, SYN_Y = 105, SLOT_Y = 112, CNT_Y = 118;\nconst colX = (i, k) => 5 + 2 * i + (i >= k ? 3 : 0);\nconst PHASES = [\"write\", \"place\", \"mask\", \"hold0\", \"damage\", \"synd\", \"locate\", \"repair\", \"hold\", \"clear\"];\nconst DUR = [1.2, 1.8, 0.6, 0.6, 0.5, 0.7, 0.8, 1.0, 3.2, 0.5];\nconst FUNC = [235, 212, 175], FMTC = [255, 238, 150];\n\n// ---- Hurts, in modules: a scratch 1.2 wide and at most 30 long through\n// the middle, a blot with a wobbling rim, a bite centred just off an edge.\nfunction newHurt(s) {\n  const kind = s.kinds++ % 3, A = s.area * (0.7 + 0.8 * Math.random()), R = Math.random;\n  if (kind === 0) {\n    const len = min(A / 1.2, 30), th = R() * PI, cx = 6 + 9 * R(), cy = 6 + 9 * R(), dx = (cos(th) * len) / 2, dy = (sin(th) * len) / 2;\n    return { kind, ax: cx - dx, ay: cy - dy, bx: cx + dx, by: cy + dy, dark: 0 };\n  }\n  if (kind === 1) return { kind, cx: 3 + 15 * R(), cy: 3 + 15 * R(), r: sqrt(A / PI), ph: R() * 7, dark: 1 };\n  const u = 4 + 13 * R(), side = floor(R() * 4);\n  const [cx, cy] = [[u, -0.3], [N + 0.3, u], [u, N + 0.3], [-0.3, u]][side];\n  return { kind, cx, cy, r: sqrt((2 * A) / PI), ph: R() * 7, dark: 0 };\n}\nfunction inHurt(h, u, v, g) {\n  if (!h || g \u003c= 0) return false;\n  if (h.kind === 0) {\n    const bx = (h.bx - h.ax) * g, by = (h.by - h.ay) * g;\n    const t = cl(((u - h.ax) * bx + (v - h.ay) * by) / (bx * bx + by * by + 1e-9), 0, 1);\n    return hypot(u - h.ax - t * bx, v - h.ay - t * by) \u003c= 0.6;\n  }\n  const dx = u - h.cx, dy = v - h.cy, a = atan2(dy, dx);\n  const rim = h.kind === 1 ? 1 + 0.06 * sin(2 * a + 3 * h.ph) + 0.07 * sin(5 * a + h.ph) + 0.05 * sin(8 * a + 2 * h.ph) : 0.9 + 0.14 * abs(sin(5 * a + h.ph));\n  return hypot(dx, dy) \u003c= h.r * rim * g;\n}\n// The symbol with the hurt grown to g, and the codewords read from it with\n// the true mask, for the columns, the word and the count.\nfunction spoil(s, g) {\n  const sym = s.sym;\n  for (let p = 0; p \u003c N * N; p++) s.dmg[p] = inHurt(s.hurt, (p % N) + 0.5, floor(p / N) + 0.5, g) ? s.hurt.dark : sym.mat[p];\n  s.seen.fill(0);\n  ORDER.forEach((p, i) => (s.seen[i >> 3] |= (s.dmg[p] ^ maskAt(sym.mask, p)) \u003c\u003c (7 - (i & 7))));\n  s.hit = s.seen.reduce((a, v, i) => a + (v !== sym.cw[i]), 0);\n}\n\nfunction newWord(s, level, phase) {\n  const sym = build(WORDS[s.wi % WORDS.length], level);\n  Object.assign(s, { sym, dmg: sym.mat.slice(), seen: sym.cw.slice(), hurt: null, dec: null, hit: 0, ph: PHASES.indexOf(phase), pt: 0 });\n}\n\nexport function setup(params) {\n  params.s = { wi: 0, kinds: 1, area: 8, hue: 0, sc: 1, level: -1, btn: false, rgb: new Float32Array(W * H * 3) };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 8, 9], d = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  s.sc = 2 / cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  s.area = cl(k[2] == null ? 8 : k[2], 8, 60);\n  // Data 9, 13, 16, 19: the nearest level.\n  const data = cl(k[3] == null ? 9 : k[3], 9, 19);\n  let level = 0;\n  LEVELS.forEach((L, i) => abs(L.k - data) \u003c abs(LEVELS[level].k - data) && (level = i));\n  // The first word, and a new level, start with the bits in place and the\n  // mask about to be swept over them.\n  if (level !== s.level) (s.level = level), newWord(s, level, \"mask\");\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !s.btn && s.ph >= 3) Object.assign(s, { dmg: s.sym.mat.slice(), seen: s.sym.cw.slice(), dec: null, ph: 4, pt: 0, hurt: newHurt(s) });\n  s.btn = btn;\n  s.pt += d;\n  while (s.pt >= DUR[s.ph] * s.sc) {\n    s.pt -= DUR[s.ph] * s.sc;\n    if (++s.ph === PHASES.length) {\n      s.wi++;\n      newWord(s, s.level, \"write\");\n    }\n    const ph = PHASES[s.ph];\n    if (ph === \"damage\") s.hurt = newHurt(s);\n    if (ph === \"synd\") {\n      spoil(s, 1);\n      // The decoder reads the spoiled symbol on its own.\n      const r = readSymbol(s.dmg);\n      if (!r) s.dec = { fmt: false, ok: false, good: false, S: [], errs: [] };\n      else {\n        const dec = rsDecode(r.cw, 26 - LEVELS[r.level].k);\n        dec.fmt = true;\n        dec.good = dec.ok && r.level === s.sym.level && dec.fixed.every((v, i) => v === s.sym.cw[i]);\n        s.dec = dec;\n      }\n    }\n  }\n  if (PHASES[s.ph] === \"damage\") spoil(s, ease(s.pt / (DUR[s.ph] * s.sc)));\n}\n\nfunction put(rgb, x, y, c) {\n  const o = (y * W + x) * 3;\n  if (x >= 0 && x \u003c W) (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n}\nfunction glyph(rgb, ch, x0, y0, col) {\n  const g = FONT_CH.indexOf(ch);\n  for (let r = 0; r \u003c 7 && g >= 0; r++) for (let c = 0; c \u003c 5; c++) if ((parseInt(FONT[g * 7 + r], 32) >> (4 - c)) & 1) put(rgb, x0 + c, y0 + r, col);\n}\nfunction fill(rgb, x0, y0, w, h, col) {\n  for (let y = y0; y \u003c y0 + h; y++) for (let x = x0; x \u003c x0 + w; x++) put(rgb, x, y, col);\n}\nconst sc3 = (c, f) => [c[0] * f, c[1] * f, c[2] * f];\nconst mix = (a, b, f) => [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f, a[2] + (b[2] - a[2]) * f];\n\nexport function draw(display, params, time) {\n  const s = params.s;\n  if (!s || !s.sym) return;\n  const rgb = s.rgb, sym = s.sym, K = sym.k, n = sym.n, t = n >> 1;\n  const u = s.pt / (DUR[s.ph] * s.sc), at = s.ph, T = time || 0;\n  // Data, error correction and damage stay a quarter of the wheel or more\n  // apart whatever the hue: cyan, violet and red at 0.\n  const DATA = hsv(0.5 + s.hue, 0.75, 255), ECC = hsv(0.75 + s.hue, 0.6, 255), RED = hsv(0.02 + s.hue, 0.88, 255), WHITE = [255, 255, 255];\n  const good = s.dec && s.dec.good, fail = s.dec && !s.dec.good && at >= 6;\n  rgb.fill(0);\n\n  // The word: typed in while it is encoded, then read from what the\n  // codewords say, red where that is wrong.\n  const word = sym.word;\n  let shown = word;\n  if (at >= 4 && !(at >= 7 && good && (at > 7 || u > 0.5))) shown = parse(s.seen, K, word.length).slice(0, 10);\n  const tx = round((W - (6 * shown.length - 1)) / 2);\n  for (let i = 0; i \u003c shown.length; i++) {\n    if (at === 0 && u \u003c ((i + 1) / word.length) * 0.33) break;\n    // Once the decoder gives up, none of it can be trusted.\n    glyph(rgb, shown[i], tx + 6 * i, TY, shown[i] === word[i] && !fail ? [235, 235, 225] : RED);\n  }\n\n  // The codeword columns, 8 bits each, data then error correction.\n  const flashFix = at === 7 && good ? exp(-(((u - 0.45) / 0.15) ** 2)) : 0;\n  for (let i = 0; i \u003c 26; i++) {\n    if (at === 0 && u \u003c (i \u003c K ? 0.33 + (0.34 * i) / K : 0.67 + (0.33 * (i - K)) / n)) continue;\n    const x = colX(i, K), base = i \u003c K ? DATA : ECC;\n    const v = at >= 4 && !(at >= 7 && good && u > 0.45) && !(at > 7 && good) ? s.seen[i] : sym.cw[i];\n    for (let b = 0; b \u003c 8; b++) {\n      const bit = (v >> (7 - b)) & 1, wrong = bit !== ((sym.cw[i] >> (7 - b)) & 1);\n      let col = wrong ? sc3(RED, bit ? 1 : 0.3) : sc3(base, bit ? 1 : 0.16);\n      if (at === 1) {\n        const head = (u * 208) | 0, idx = i * 8 + b;\n        if (idx \u003c head && idx > head - 6) col = mix(col, WHITE, 1 - (head - idx) / 6);\n      }\n      if (flashFix && ((s.seen[i] ^ sym.cw[i]) >> (7 - b)) & 1) col = mix(col, WHITE, flashFix);\n      fill(rgb, x, CY + 3 * b, 1, 2, col);\n    }\n  }\n  // Marks over the codewords the decoder finds.\n  if (s.dec && at >= 6 && at \u003c= 8) {\n    const errs = s.dec.errs;\n    errs.forEach((i, j) => {\n      if (at === 6 && u \u003c (j + 1) / (errs.length + 1)) return;\n      fill(rgb, colX(i, K), MARK_Y, 1, 1, fail ? RED : [255, 210, 60]);\n    });\n  }\n\n  // The symbol, 3 LEDs to a module.\n  const fade = at === 9 ? 1 - u : 1, fnIn = at === 0 ? 0 : at === 1 ? cl(u * 5, 0, 1) : 1;\n  const hurtG = at === 4 ? ease(u) : at >= 5 ? 1 : 0;\n  const heal = good ? (at === 7 ? ease((u - 0.2) / 0.5) : at > 7 ? 1 : 0) : 0;\n  const pulse = fail ? 0.75 + 0.25 * sin(T * 6) : 1;\n  for (let my = 0; my \u003c N; my++)\n    for (let mx = 0; mx \u003c N; mx++) {\n      const p = my * N + mx, bi = BITOF[p], isF = FN[p];\n      let v = sym.mat[p], col;\n      if (isF) {\n        if (fnIn \u003c= 0) continue;\n        const fmt = ISFMT[p];\n        // The format bits arrive with the mask they name.\n        if (fmt && at \u003c 2) continue;\n        if (fmt && at === 2 && mx + my > u * 42) continue;\n        col = sc3(fmt ? FMTC : FUNC, fnIn);\n      } else {\n        const ci = bi >> 3;\n        col = ci \u003c K ? DATA : ECC;\n        if (at === 0) continue;\n        if (at === 1) {\n          const head = (u * 208) | 0;\n          if (bi >= head) continue;\n          v = (sym.cw[ci] >> (7 - (bi & 7))) & 1;\n          if (bi > head - 6) col = mix(col, WHITE, 1 - (head - bi) / 6), (v = 1);\n        } else if (at === 2) {\n          const front = u * 42 - (mx + my);\n          if (front \u003c 0) v = (sym.cw[ci] >> (7 - (bi & 7))) & 1;\n          else if (maskAt(sym.mask, p) && front \u003c 3) col = mix(col, WHITE, 1 - front / 3), (v = 1);\n        }\n      }\n      if (!v) col = [0, 0, 0];\n      const wrongMod = !isF && s.dmg[p] !== sym.mat[p];\n      for (let dy = 0; dy \u003c 3; dy++)\n        for (let dx = 0; dx \u003c 3; dx++) {\n          const x = SX + 3 * mx + dx, y = SY + 3 * my + dy;\n          let c = col;\n          if (hurtG > 0 && inHurt(s.hurt, (x - SX + 0.5) / 3, (y - SY + 0.5) / 3, hurtG)) {\n            const hc = sc3(RED, (s.hurt.dark ? 1 : 0.38) * pulse);\n            c = mix(hc, col, heal);\n          }\n          put(rgb, x, y, wrongMod && flashFix ? mix(c, WHITE, flashFix) : c);\n        }\n    }\n\n  // Syndromes: one cell each, dark when zero.\n  const cw = min(7, floor(62 / n)), sx = round((W - cw * n + 1) / 2);\n  for (let j = 0; j \u003c n; j++) {\n    let col = [26, 26, 32];\n    const S = s.dec && s.dec.fmt ? s.dec.S[j] || 0 : 0;\n    const on = s.dec && at >= 5 && at \u003c= 8 && !(at === 5 && u \u003c j / n) && !(good && (at > 7 || (at === 7 && u > 0.35 + (0.5 * j) / n)));\n    if (on && s.dec.fmt && S) col = hsv(S / 255, 0.55, 255);\n    else if (on && !s.dec.fmt) col = sc3(RED, 0.4 + 0.3 * sin(T * 6));\n    fill(rgb, sx + cw * j, SYN_Y, cw - 1, 4, col);\n  }\n  // The budget: one slot for each codeword the code can mend; the slots\n  // the standard holds back against misreading are dimmer.\n  const sw = t > 6 ? 5 : 7, bx = round((W - (sw + 2) * t + 2) / 2), found = s.dec ? s.dec.errs.length : 0;\n  for (let j = 0; j \u003c t; j++) {\n    let col = j \u003c STD[sym.level] ? [44, 44, 52] : [34, 16, 40];\n    if (s.dec && at >= 6 && at \u003c= 8) {\n      if (fail) col = sc3(RED, pulse);\n      else if (j \u003c found && !(at === 6 && u \u003c (j + 1) / (found + 1))) col = [255, 210, 60];\n    }\n    fill(rgb, bx + (sw + 2) * j, SLOT_Y, sw, 3, col);\n  }\n  // The count: codewords spoiled over codewords the code can mend.\n  const cnt = `${at >= 4 && at \u003c= 8 ? s.hit : 0}/${t}`, cx = round((W - (6 * cnt.length - 1)) / 2);\n  const ccol = at \u003c 4 || at > 8 || !s.hit ? [120, 120, 120] : s.hit > t || fail ? RED : good && at >= 7 ? [120, 255, 140] : [235, 235, 225];\n  for (let i = 0; i \u003c cnt.length; i++) glyph(rgb, cnt[i], cx + 6 * i, CNT_Y, ccol);\n\n  for (let i = 0; i \u003c W * H; i++) {\n    const j = i * 3;\n    display.setPixel(i % W, (i / W) | 0, round(cl(rgb[j] * fade, 0, 255)), round(cl(rgb[j + 1] * fade, 0, 255)), round(cl(rgb[j + 2] * fade, 0, 255)));\n  }\n}\n","tally-count":"// ===== Patternflow pattern =====\n// Title:   Tally Count\n// Family:  type\n// Idea:    Four candidates numbered 1 to 4 head four columns of a chalkboard, ballots drawn from a sealed box are read out one at a time and each adds one chalk stroke to its candidate's column, written in the order of the character 正 so that every five votes close one 正 and the stacks of them race down the tall panel like bars, a column flashes when its candidate takes the lead, a thin trace along the bottom follows the lead of the final winner over the runner-up through the count as in Bertrand's ballot problem, and at the end the winner's column glows, the trace says whether the winner led all the way, and the board is wiped for the next count.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tally marks in the character 正, five strokes to a mark, as vote counters in Korea, China and Japan keep them; the ballot problem (William Allen Whitworth, 1878; Joseph Bertrand, 1887); 5 by 7 figures from Photon Disk (pattern round 70); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Closeness=0..1, Size=7..15\n//\n// Knob 1: Hue. Turns the four chalk colours round the wheel together. At 0 candidate 1 writes in light cyan, 2 in lilac, 3 in salmon and 4 in light green, a quarter turn apart at 60% saturation; at 0.5 they are salmon, light green, light cyan and lilac.\n// Knob 2: Speed. A full count takes 10 s at 2, 100 s at 0.2 and 6.7 s at 3, whatever the number of ballots, and a stroke is written in 0.18 s at 2. The winner then glows for 3 s and the eraser takes 1.2 s, both scaled by 2 / Speed within 1.5 to 6 s and 0.6 to 2.4 s.\n// Knob 3: Closeness. How close the hidden shares are. Each count draws four shares from a Dirichlet(2, 2, 2, 2) and mixes them toward 25% each by this much. At 0 the winner takes 34 to 58% of the ballots (median 44%), the lead changes hands about 3 times and the winner leads all the way in 23% of counts; at 0.5 it takes 33% and leads all the way in 12%; at 1 all four shares are 25%, the columns finish within a few marks of each other, the lead changes about 12 times at Size 7 and the winner leads all the way in 2% of counts. A change of more than 0.08 starts a new count.\n// Knob 4: Size. The height of a 正 in LEDs, 7 to 15 in odd steps. At 7 two marks share a row of the 16 LED column, 12 rows deep, so a column holds 120 votes and a count reads 265 ballots at Closeness 0 and 455 at 1; at 9 one mark a row, 9 rows, 45 votes and about 100 ballots; at 15 five rows of marks 13 wide with 2 LED strokes, 25 votes and about 55 ballots. The winner's column always ends within a few votes of full. A new size starts a new count.\n// Buttons: K1 tap wipes the board and starts a new count.\n\n// The ballot problem: if A gets p votes and B gets q \u003c p, and every order of\n// reading them is equally likely, the chance that A is strictly ahead of B\n// after every ballot is (p - q) / (p + q). Whitworth stated it in 1878 and\n// Bertrand published it in 1887 (Comptes Rendus 105). Here the four\n// candidates' votes are all drawn before the count starts, a sealed box, and\n// then read in a uniformly shuffled order, so for the two who finish first\n// and second the theorem holds as stated: ballots for the other two only\n// stretch the trace sideways. The trace is the lead of the final winner over\n// the final runner-up after each ballot; the winner led all the way when it\n// stays above the zero line from that pair's first ballot on.\n//\n// The five strokes of 正 in their written order: the top bar, the centre\n// stem, the short bar right of the stem at half height, the short stem at\n// the lower left, the long bottom bar. One vote is one stroke.\n\nconst W = 64, H = 128, NC = 4, CW = 16;\n// The tally runs from row TOP to BOT; the trace of the lead sits on row\n// ZERO and swings AMP rows either way.\nconst TOP = 16, BOT = 113, ZERO = 121, AMP = 5;\nconst { floor, round, min, max, abs, sqrt, exp, log, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst T_COUNT = 10, T_STROKE = 0.18, T_END = 3, T_WIPE = 1.2, HUE0 = 0.55;\n\nconst ZHENG = [\n  [0.15, 0, 0.85, 0],\n  [0.5, 0, 0.5, 1],\n  [0.5, 0.5, 0.85, 0.5],\n  [0.15, 0.5, 0.15, 1],\n  [0, 1, 1, 1],\n];\n\n// The figures 1 to 4 of Photon Disk's 5 x 7 face (copied from autogram.js),\n// rows from the top.\nconst FIG = [\n  \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  \".###. #...# ....# ...#. ..#.. .#... #####\",\n  \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\",\n].map((f) => f.replace(/ /g, \"\"));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// A shares vector from a Dirichlet(2, 2, 2, 2): each a sum of two\n// exponentials, normalised.\nconst expo = () => -log(1 - Math.random() * 0.999999);\nfunction shares(close) {\n  const d = [];\n  let s = 0;\n  for (let c = 0; c \u003c NC; c++) s += d[c] = expo() + expo();\n  for (let c = 0; c \u003c NC; c++) d[c] = (1 - close) * (d[c] / s) + close / NC;\n  return d;\n}\n\n// The layout of one size: marks per row, rows, and the cell pitch.\nfunction layout(size) {\n  const g = size \u003c= 7 ? 1 : 2, per = size \u003c= 7 ? 2 : 1, pitch = size + g;\n  const rows = floor((BOT - TOP + g) / pitch);\n  // A mark is as wide as it is tall up to 13 LEDs, which leaves at least\n  // 3 LEDs between neighbouring columns.\n  const mw = min(size, 13), wid = per * mw + (per - 1) * g;\n  return { size, mw, g, per, pitch, rows, cap: rows * per * 5, ox: floor((CW - wid) / 2), sw: size \u003c= 9 ? 1 : size \u003c= 13 ? 1.5 : 2 };\n}\n\n// A new count: draw the shares, the votes, a uniformly shuffled order, and\n// the lead path of the final first over the final second.\nfunction newCount(S, prefill) {\n  const L = (S.L = layout(S.size));\n  let tally;\n  for (let tries = 0; tries \u003c 30; tries++) {\n    S.share = shares(S.close);\n    const top = max(...S.share), n = round((L.cap * 0.96) / top);\n    tally = [0, 0, 0, 0];\n    for (let i = 0; i \u003c n; i++) {\n      let u = Math.random(), c = 0;\n      while (c \u003c NC - 1 && u >= S.share[c]) u -= S.share[c++];\n      tally[c]++;\n    }\n    for (let c = 0; c \u003c NC; c++) tally[c] = min(tally[c], L.cap);\n    const sorted = tally.slice().sort((a, b) => b - a);\n    if (sorted[0] > sorted[1]) break;\n  }\n  const seq = [];\n  for (let c = 0; c \u003c NC; c++) for (let i = 0; i \u003c tally[c]; i++) seq.push(c);\n  for (let i = seq.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1));\n    [seq[i], seq[j]] = [seq[j], seq[i]];\n  }\n  let win = 0;\n  for (let c = 1; c \u003c NC; c++) if (tally[c] > tally[win]) win = c;\n  let run = -1;\n  for (let c = 0; c \u003c NC; c++) if (c !== win && (run \u003c 0 || tally[c] > tally[run])) run = c;\n  const lead = new Int16Array(seq.length);\n  let d = 0, ok = true, seen = false, peak = 1;\n  for (let i = 0; i \u003c seq.length; i++) {\n    if (seq[i] === win) (d++), (seen = true);\n    else if (seq[i] === run) (d--), (seen = true);\n    lead[i] = d;\n    if (seen && d \u003c= 0) ok = false;\n    peak = max(peak, abs(d));\n  }\n  Object.assign(S, { seq, final: tally, win, run, lead, ok, peak, n: seq.length, read: 0, next: 0, phase: 0, pt: 0, leader: -1 });\n  S.p = tally[win];\n  S.q = tally[run];\n  S.tally = [0, 0, 0, 0];\n  S.active = [];\n  S.flash.fill(0);\n  S.lit.fill(0);\n  S.chalk.fill(0);\n  if (prefill) {\n    const k = floor(S.n * prefill);\n    for (let i = 0; i \u003c k; i++) commit(S, true);\n    S.read = k;\n  }\n}\n\n// Where stroke j of candidate c goes, in LED coordinates of pixel centres.\nfunction strokeAt(S, c, j, out) {\n  const L = S.L, m = floor(j / 5), k = j % 5, r = floor(m / L.per), col = m % L.per;\n  const x0 = c * CW + L.ox + col * (L.mw + L.g) + 0.5, y0 = TOP + r * L.pitch + 0.5, ex = L.mw - 1, ey = L.size - 1, z = ZHENG[k];\n  out[0] = x0 + round(z[0] * ex);\n  out[1] = y0 + round(z[1] * ey);\n  out[2] = x0 + round(z[2] * ex);\n  out[3] = y0 + round(z[3] * ey);\n  return out;\n}\n\n// Read the next ballot: one stroke for its candidate, and a flash when the\n// lead changes hands.\nfunction commit(S, silent) {\n  const c = S.seq[S.next], j = S.tally[c]++;\n  const st = strokeAt(S, c, j, [0, 0, 0, 0]);\n  if (silent) bake(S, st, c, 1);\n  else S.active.push({ st, c, t: 0 });\n  let best = 0, ties = 0;\n  for (let k = 1; k \u003c NC; k++) if (S.tally[k] > S.tally[best]) best = k;\n  for (let k = 0; k \u003c NC; k++) if (S.tally[k] === S.tally[best]) ties++;\n  // A change of leader flashes the new leader's column once it has a\n  // whole 正; the swaps among the first few ballots would only flicker.\n  if (ties === 1 && best !== S.leader) {\n    if (S.leader >= 0 && !silent && S.tally[best] >= 5) S.flash[best] = 1;\n    S.leader = best;\n  }\n  if (!silent) S.lit[c] = min(1, S.lit[c] + 0.35);\n  S.next++;\n}\n\n// Chalk: a line of width sw through pixel centres, its grain fixed per LED.\nfunction chalkLine(buf, st, u, sw, col, grain, k0) {\n  const x0 = st[0], y0 = st[1], x1 = x0 + (st[2] - x0) * u, y1 = y0 + (st[3] - y0) * u;\n  const hw = sw / 2, dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  const ax = max(0, floor(min(x0, x1) - hw - 1)), bx = min(W - 1, floor(max(x0, x1) + hw + 1));\n  const ay = max(0, floor(min(y0, y1) - hw - 1)), by = min(H - 1, floor(max(y0, y1) + hw + 1));\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = l2 > 0 ? cl((px * dx + py * dy) / l2, 0, 1) : 0;\n      const d = sqrt((px - t * dx) ** 2 + (py - t * dy) ** 2), cov = cl(hw + 0.5 - d, 0, 1);\n      if (cov \u003c= 0) continue;\n      const i = y * W + x, a = cov * grain[i] * k0, kk = i * 3;\n      for (let q = 0; q \u003c 3; q++) buf[kk + q] = max(buf[kk + q], col[q] * a);\n    }\n}\nfunction bake(S, st, c, u) {\n  chalkLine(S.chalk, st, u, S.L.sw, S.col[c], S.grain, 1);\n}\n// A finished stroke throws a little dust round itself, which settles in\n// about a second: the front where a column is being written hazes over.\nfunction puff(S, st, c) {\n  const ax = max(0, floor(min(st[0], st[2]) - 4)), bx = min(W - 1, floor(max(st[0], st[2]) + 4));\n  const ay = max(0, floor(min(st[1], st[3]) - 4)), by = min(H - 1, floor(max(st[1], st[3]) + 4));\n  const dx = st[2] - st[0], dy = st[3] - st[1], l2 = dx * dx + dy * dy || 1;\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - st[0], py = y + 0.5 - st[1], t = cl((px * dx + py * dy) / l2, 0, 1);\n      const d2 = (px - t * dx) ** 2 + (py - t * dy) ** 2, i = y * W + x;\n      S.dust[i] = min(0.5, S.dust[i] + 0.09 * exp(-d2 / 5) * S.grain[i]);\n      S.dustC[i] = c;\n    }\n}\n\nexport function setup(params) {\n  const grain = new Float32Array(W * H);\n  for (let i = 0; i \u003c grain.length; i++) grain[i] = 0.74 + 0.26 * Math.random();\n  params.s = {\n    hue: 0, speed: 2, close: 0, size: 7, started: false, btn: false, grain,\n    chalk: new Float32Array(W * H * 3), out: new Float32Array(W * H * 3), dust: new Float32Array(W * H), dustC: new Uint8Array(W * H),\n    flash: new Float32Array(NC), lit: new Float32Array(NC), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\n    wipeY: -1, t: 0,\n  };\n  return params.s;\n}\n\nfunction paint(S) {\n  for (let c = 0; c \u003c NC; c++) hsv(S.hue + HUE0 + c * 0.25, 0.6, 1, S.col[c]);\n}\n\n// Phases: 0 counting, 1 the winner glows, 2 the eraser comes down.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 7], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const close = cl(k[2] || 0, 0, 1), size = 7 + 2 * round((cl(k[3] == null ? 7 : k[3], 7, 15) - 7) / 2);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  paint(S);\n  if (!S.started || size !== S.size || abs(close - S.close) > 0.08) {\n    // The Lab opens on a count 40% of the way through.\n    S.close = close;\n    S.size = size;\n    newCount(S, S.started ? 0.12 : 0.4);\n    S.started = true;\n  } else if (btn && !S.btn) (S.phase = 2), (S.pt = 0), (S.wipeY = 0);\n  S.btn = btn;\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  for (let c = 0; c \u003c NC; c++) (S.flash[c] *= exp(-d / 0.45)), (S.lit[c] *= exp(-d / 0.25));\n  const settle = exp(-d / 0.9);\n  for (let i = 0; i \u003c W * H; i++) S.dust[i] *= settle;\n  if (S.phase === 0) {\n    const rate = S.n / (T_COUNT * sc);\n    S.read = min(S.n, S.read + d * rate);\n    while (S.next \u003c S.n && S.next \u003c S.read) commit(S, false);\n    const ds = T_STROKE * sc;\n    for (const a of S.active) a.t += d / ds;\n    S.active = S.active.filter((a) => (a.t >= 1 ? (bake(S, a.st, a.c, 1), puff(S, a.st, a.c), false) : true));\n    if (S.next >= S.n && !S.active.length) (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    if (S.pt >= cl(T_END * sc, 1.5, 6)) (S.phase = 2), (S.pt = 0), (S.wipeY = 0);\n  } else {\n    // The eraser: what it passes keeps a smear of dust that fades.\n    const dur = cl(T_WIPE * sc, 0.6, 2.4), y1 = min(H, (S.pt / dur) * (H + 12));\n    const ch = S.chalk;\n    for (let y = 0; y \u003c min(H, floor(y1)); y++) {\n      const f = y >= S.wipeY ? 0.16 : exp(-d / 0.5);\n      for (let x = 0; x \u003c W; x++) {\n        const kk = (y * W + x) * 3;\n        ch[kk] *= f;\n        ch[kk + 1] *= f;\n        ch[kk + 2] *= f;\n      }\n    }\n    S.wipeY = max(S.wipeY, floor(y1));\n    if (S.pt >= dur + 0.5) newCount(S, 0);\n  }\n}\n\nfunction fill(o, x0, y0, x1, y1, c, a) {\n  for (let y = max(0, y0); y \u003c= min(H - 1, y1); y++)\n    for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) {\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) o[kk + q] = max(o[kk + q], c[q] * a);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.out, ch = S.chalk, col = S.col;\n  const wipe = S.phase === 2, glow = S.phase === 1 ? 0.5 + 0.5 * sin(S.pt * 5) : 0;\n  // The board, with a faint tint behind a column that just took the lead or won.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3, c = floor(x / CW);\n      const inside = y >= TOP - 2 && y \u003c= BOT;\n      let tint = inside ? 0.2 * S.flash[c] : 0;\n      if (S.phase === 1 && c === S.win && inside) tint = max(tint, 0.1 + 0.1 * glow);\n      const du = S.dust[y * W + x], dc = col[S.dustC[y * W + x]];\n      o[kk] = 0.02 + col[c][0] * tint + dc[0] * du;\n      o[kk + 1] = 0.055 + col[c][1] * tint + dc[1] * du;\n      o[kk + 2] = 0.045 + col[c][2] * tint + dc[2] * du;\n    }\n  // Chalk on the board; the winner's marks brighten while it glows.\n  const boost = S.phase === 1 ? 1 + 0.25 * glow : 1;\n  for (let i = 0; i \u003c W * H; i++) {\n    const kk = i * 3, b = S.phase === 1 && floor((i % W) / CW) === S.win ? boost : 1;\n    o[kk] = max(o[kk], ch[kk] * b);\n    o[kk + 1] = max(o[kk + 1], ch[kk + 1] * b);\n    o[kk + 2] = max(o[kk + 2], ch[kk + 2] * b);\n  }\n  // Strokes being written: the line so far, its tip a little brighter.\n  const tip = [0, 0, 0];\n  for (const a of S.active) {\n    const u = cl(a.t, 0, 1);\n    chalkLine(o, a.st, u, S.L.sw, col[a.c], S.grain, 1);\n    for (let q = 0; q \u003c 3; q++) tip[q] = 0.5 + 0.5 * col[a.c][q];\n    const st = a.st, tx = st[0] + (st[2] - st[0]) * u, ty = st[1] + (st[3] - st[1]) * u;\n    chalkLine(o, [tx, ty, tx, ty], 1, S.L.sw + 0.4, tip, S.grain, 1);\n  }\n  // The candidates' numbers, 기호 1 to 4, in boxes that light as a ballot is read.\n  for (let c = 0; c \u003c NC; c++) {\n    const x0 = c * CW + 2, x1 = c * CW + 13, cc = col[c];\n    const lit = S.lit[c], won = S.phase >= 1 && c === S.win ? 1 : 0;\n    fill(o, x0, 1, x1, 13, cc, 0.14 + 0.5 * lit + 0.25 * won * (S.phase === 1 ? glow : 1));\n    for (let x = x0; x \u003c= x1; x++) fill(o, x, 1, x, 1, cc, 0.7), fill(o, x, 13, x, 13, cc, 0.7);\n    fill(o, x0, 1, x0, 13, cc, 0.7);\n    fill(o, x1, 1, x1, 13, cc, 0.7);\n    const f = FIG[c];\n    for (let r = 0; r \u003c 7; r++)\n      for (let q = 0; q \u003c 5; q++) if (f[r * 5 + q] === \"#\") fill(o, c * CW + 5 + q, 4 + r, c * CW + 5 + q, 4 + r, [1, 1, 1], 0.9 + 0.1 * lit);\n    // Led all the way: a second frame round the winner's box.\n    if (S.phase === 1 && c === S.win && S.ok && glow > 0.3) {\n      for (let x = x0 - 1; x \u003c= x1 + 1; x++) fill(o, x, 0, x, 0, [1, 1, 1], 0.9), fill(o, x, 14, x, 14, [1, 1, 1], 0.9);\n      fill(o, x0 - 1, 0, x0 - 1, 14, [1, 1, 1], 0.9);\n      fill(o, x1 + 1, 0, x1 + 1, 14, [1, 1, 1], 0.9);\n    }\n  }\n  // The ballot path: zero line dotted, the winner's lead above, the\n  // runner-up's below, one column per ballot read.\n  if (!wipe || S.pt \u003c 0.3) {\n    for (let x = 0; x \u003c W; x += 2) fill(o, x, ZERO, x, ZERO, [0.5, 0.5, 0.5], 0.42);\n    const n = min(S.next, S.n), cw = col[S.win], cr = col[S.run], sy = AMP / S.peak;\n    let py = ZERO;\n    for (let i = 0; i \u003c n; i++) {\n      const x = floor((i * W) / S.n), y = round(ZERO - S.lead[i] * sy);\n      const c = S.lead[i] > 0 ? cw : S.lead[i] \u003c 0 ? cr : [1, 1, 1];\n      const a = S.phase === 1 ? (S.ok ? 0.75 + 0.25 * glow : 0.75) : 0.75;\n      for (let yy = min(py, y); yy \u003c= max(py, y); yy++) fill(o, x, yy, x, yy, c, a);\n      py = y;\n    }\n    // Not led all the way: where the runner-up drew level or went ahead.\n    if (S.phase === 1 && !S.ok) {\n      let seen = false, was = false;\n      for (let i = 0; i \u003c n; i++) {\n        if (S.seq[i] === S.win || S.seq[i] === S.run) seen = true;\n        const down = seen && S.lead[i] \u003c= 0;\n        if (down && was === false) {\n          const x = floor((i * W) / S.n);\n          fill(o, x, ZERO - 2, x, ZERO + 2, [1, 1, 1], 0.4 + 0.6 * glow);\n        }\n        if (seen) was = down;\n      }\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(o[kk], 0, 1) * 255), round(cl(o[kk + 1], 0, 1) * 255), round(cl(o[kk + 2], 0, 1) * 255));\n    }\n}\n","trajan-helix":"// ===== Patternflow pattern =====\n// Title:   Trajan Helix\n// Family:  type\n// Idea:    A marble column fills the height of the panel and turns slowly under a raking lamp while a helical band winds round it from foot to top, the way the frieze winds round Trajan's Column, but the band carries the column's own base inscription in Roman capitals cut and painted red, full width where the band faces you, squeezed thin toward the column's edges and gone behind it, so as the column turns and the view climbs the line slides along the helix and reads on without end, SENATVS POPVLVSQVE ROMANVS and on to SIT EGESTVS, while the band itself creeps slowly up like a barber's pole and the letters lost from the stone pass as a broken patch with their restoration ghosted in.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the base inscription of Trajan's Column (CIL VI 960, the column dedicated in AD 113 and attributed to Apollodorus of Damascus), the model of the Roman capital, with stroke weights after Edward Catich's flat-brush account in The Origin of the Serif (1968) and the red letters after Pliny's minium for inscriptions (Natural History 33.122); capitals drawn for this pattern as strokes, pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Paint=0..1, Turn=0.2..3, Turns=5..9, Light=0..1\n//\n// Knob 1: Paint. The colour in the cut letters: at 0 minium, a vermilion red; 0.1 gold, 0.3 green, 0.6 blue, 0.8 purple, and back to red at 1. The marble stays marble and the lost letters stay bare.\n// Knob 2: Turn. How fast the column turns: at 2 the front of the column moves 12 LEDs a second, a letter and two thirds, a full turn takes 13.1 s, the band creeps up half a pitch a turn (12.8 rows at the opening 5 turns) and the whole inscription, 172 letters and 34 stops, passes in 1 minute 53 s; at 0.2 a letter goes by every 6 s and the inscription takes 19 minutes, at 3 two and a half letters go by a second.\n// Knob 3: Turns. How many turns of the band stand on the panel: 5 at the start, a pitch of 25.6 rows with 13.6 rows of plain marble between the turns; at 9 the pitch is 14.2 rows and the turns almost touch, 2.2 rows apart, so the panel is a screw of text as the real frieze is a screw of figures.\n// Knob 4: Light. Where the lamp stands round the column, 30 degrees above it: at the opening 0.06 it rakes in from 57 degrees to the left, so the left of the shaft is lit, the right falls into shadow and every cut letter shows a lit wall and a dark one; at 0.5 the lamp is in front and the column goes flat; at 1 it rakes from 65 degrees to the right and the shading turns over.\n\n// The column is a cylinder of radius 25 LEDs seen from far off, so the LED\n// x across the shaft is R sin(beta) for the angle beta round from the front,\n// and a stroke on the stone shrinks by cos(beta) as it turns toward the edge.\n// The band is a helix: its top edge stands at Y0 - P beta / 2 pi, P the\n// pitch, and the text coordinate along it is the arc R (beta - 2 pi m) for\n// the m-th turn counted up from the panel's foot. Turning the column by phi\n// slides the text along the band by R phi. Turning alone would make the\n// band climb a whole pitch a turn, the barber's pole, and the panel would\n// show the same stretch of stone for ever; so the view climbs too, half a\n// pitch a turn, new stone and the next words come in at the top, and the\n// band still creeps up by the other half. Every letter is fixed to the\n// stone.\n//\n// The capitals are strokes (straight or elliptic arcs) in a box 8 LEDs tall.\n// Their weights follow a flat brush held with its edge 20 degrees above the\n// horizontal, Catich's account of how the letters were laid out before the\n// cutting: uprights and down-right strokes come out thick (1.8 LEDs), the\n// horizontals and down-left strokes thin (0.85), and the N's uprights are\n// set thin by hand as on the stone. Each LED's coverage comes from its\n// distance to the strokes, measured on the stone and turned into LEDs\n// through the squeeze cos(beta), so letters thin out smoothly at the edges.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, asin, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nfunction hsv(h, s, v) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nconst CX = 32, R = 25;\n// The band: 12 rows, a shadowed seam on top, the letters 8 rows tall from\n// row 2, a lit lip at the bottom.\nconst BAND = 12, CAP = 8, TOP = 2, Y0 = 118;\nconst HAIR = 0.85, THICK = 1.8, GAP = 1.7;\nconst ELEV = (30 * PI) / 180, FOLLOW = 0.5;\n\n// ---- The capitals, in units of the cap height, y down. [\"l\", x0, y0, x1,\n// y1, wt] a straight stroke, [\"a\", cx, cy, rx, ry, from, to, wt] an\n// elliptic arc between two angles in degrees (0 right, 90 down), [\"d\", x,\n// y] the stop between words. wt left out takes the brush's weight for the\n// stroke's direction; 0 is a hairline. Serifs are short hairlines at the\n// ends of the stems. Only the 19 letters the inscription uses are drawn.\nconst s0 = (x, y, a = 0.11) => [\"l\", x - a, y, x + a, y, 0];\nconst GLYPHS = {\n  A: [0.86, [[\"l\", 0.43, 0, 0.05, 1], [\"l\", 0.43, 0, 0.82, 1], [\"l\", 0.21, 0.64, 0.66, 0.64, 0], s0(0.05, 1), s0(0.82, 1)]],\n  B: [0.58, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.32, 0, 0], [\"a\", 0.32, 0.24, 0.2, 0.24, -90, 90], [\"l\", 0.1, 0.48, 0.34, 0.48, 0],\n    [\"a\", 0.34, 0.74, 0.22, 0.26, -90, 90], [\"l\", 0.1, 1, 0.34, 1, 0], s0(0.04, 0, 0.06), s0(0.04, 1, 0.06)]],\n  C: [0.82, [[\"a\", 0.46, 0.5, 0.44, 0.5, -48, -312], [\"l\", 0.76, 0.06, 0.76, 0.2, 0]]],\n  D: [0.88, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.42, 0, 0], [\"l\", 0.1, 1, 0.42, 1, 0], [\"a\", 0.42, 0.5, 0.42, 0.5, -90, 90], s0(0.04, 0, 0.06), s0(0.04, 1, 0.06)]],\n  E: [0.5, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.47, 0, 0], [\"l\", 0.1, 0.5, 0.42, 0.5, 0], [\"l\", 0.1, 1, 0.5, 1, 0],\n    [\"l\", 0.47, 0, 0.47, 0.12, 0], [\"l\", 0.5, 1, 0.5, 0.86, 0], s0(0.04, 0, 0.06), s0(0.04, 1, 0.06)]],\n  F: [0.5, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.48, 0, 0], [\"l\", 0.1, 0.5, 0.42, 0.5, 0], [\"l\", 0.48, 0, 0.48, 0.12, 0], s0(0.04, 0, 0.06), s0(0.12, 1, 0.14)]],\n  G: [0.86, [[\"a\", 0.46, 0.5, 0.44, 0.5, -48, -340], [\"l\", 0.84, 0.56, 0.84, 0.96], [\"l\", 0.76, 0.06, 0.76, 0.2, 0]]],\n  I: [0.24, [[\"l\", 0.12, 0, 0.12, 1], s0(0.12, 0), s0(0.12, 1)]],\n  L: [0.5, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 1, 0.5, 1, 0], [\"l\", 0.5, 1, 0.5, 0.86, 0], s0(0.12, 0, 0.14), s0(0.04, 1, 0.06)]],\n  M: [1.0, [[\"l\", 0.15, 0, 0.05, 1], [\"l\", 0.15, 0, 0.5, 1], [\"l\", 0.85, 0, 0.5, 1], [\"l\", 0.85, 0, 0.95, 1], s0(0.05, 1), s0(0.95, 1)]],\n  N: [0.82, [[\"l\", 0.08, 0, 0.08, 1, 0], [\"l\", 0.74, 0, 0.74, 1, 0], [\"l\", 0.08, 0, 0.74, 1], s0(0.08, 1), s0(0.74, 0)]],\n  O: [0.94, [[\"a\", 0.47, 0.5, 0.46, 0.5, 0, 360]]],\n  P: [0.56, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.32, 0, 0], [\"a\", 0.32, 0.26, 0.22, 0.26, -90, 90], [\"l\", 0.1, 0.52, 0.32, 0.52, 0], s0(0.04, 0, 0.06), s0(0.12, 1, 0.14)]],\n  Q: [0.94, [[\"a\", 0.47, 0.5, 0.46, 0.5, 0, 360], [\"l\", 0.52, 0.94, 1.1, 1.1]]],\n  R: [0.66, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.32, 0, 0], [\"a\", 0.32, 0.25, 0.22, 0.25, -90, 90], [\"l\", 0.1, 0.5, 0.32, 0.5, 0],\n    [\"l\", 0.3, 0.5, 0.62, 1], s0(0.04, 0, 0.06), s0(0.12, 1, 0.14), s0(0.66, 1, 0.06)]],\n  S: [0.5, [[\"l\", 0.44, 0.06, 0.44, 0.18, 0], [\"a\", 0.26, 0.25, 0.2, 0.25, -30, -270], [\"a\", 0.24, 0.75, 0.22, 0.25, -90, 90], [\"l\", 0.06, 0.82, 0.06, 0.94, 0]]],\n  T: [0.72, [[\"l\", 0, 0, 0.72, 0, 0], [\"l\", 0.36, 0, 0.36, 1], [\"l\", 0, 0, 0, 0.12, 0], [\"l\", 0.72, 0, 0.72, 0.12, 0], s0(0.36, 1, 0.14)]],\n  V: [0.84, [[\"l\", 0.04, 0, 0.42, 1], [\"l\", 0.8, 0, 0.42, 1], s0(0.04, 0), s0(0.8, 0)]],\n  X: [0.74, [[\"l\", 0.06, 0, 0.68, 1], [\"l\", 0.66, 0, 0.08, 1], s0(0.06, 0), s0(0.66, 0), s0(0.08, 1), s0(0.68, 1)]],\n  \"·\": [0.2, [[\"d\", 0.1, 0.55]]],\n};\n\n// The inscription, its six lines run together, stops between the words as\n// on the stone. Square brackets mark the letters lost with a piece of the\n// last line, read here TANT[IS OPER]IBVS; editions differ by a letter at\n// either end of the gap (TAN[TIS OPE]RIBVS in one).\nconst TEXT =\n  \"SENATVS·POPVLVSQVE·ROMANVS·IMP·CAESARI·DIVI·NERVAE·F·NERVAE·TRAIANO·AVG·GERM·DACICO·PONTIF·MAXIMO·TRIB·POT·XVII·IMP·VI·COS·VI·P·P·\" +\n  \"AD·DECLARANDVM·QVANTAE·ALTITVDINIS·MONS·ET·LOCVS·TANT[IS·OPER]IBVS·SIT·EGESTVS\";\n\n// The brush: weight 1 for an upright, about 0.95 down-right, 0.13\n// down-left, 0 across.\nconst NIB = (-20 * PI) / 180;\nconst brush = (dx, dy) => cl((abs(sin(atan2(dy, dx) - NIB)) - 0.34) / 0.6, 0, 1);\n\n// Each glyph as segments in LEDs: x0, y0, x1, y1, half width.\nfunction build(parts) {\n  const seg = [];\n  const push = (x0, y0, x1, y1, wt) => {\n    const w = wt == null ? brush(x1 - x0, y1 - y0) : wt;\n    seg.push(x0 * CAP, y0 * CAP, x1 * CAP, y1 * CAP, (HAIR + (THICK - HAIR) * w) / 2);\n  };\n  for (const p of parts) {\n    if (p[0] === \"l\") push(p[1], p[2], p[3], p[4], p[5]);\n    else if (p[0] === \"d\") seg.push(p[1] * CAP, p[2] * CAP, p[1] * CAP, p[2] * CAP, 0.7);\n    else {\n      const [, cx, cy, rx, ry, a0, a1, wt] = p, n = max(3, round(abs(a1 - a0) / 20));\n      for (let i = 0; i \u003c n; i++) {\n        const t0 = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, t1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * PI) / 180;\n        push(cx + rx * cos(t0), cy + ry * sin(t0), cx + rx * cos(t1), cy + ry * sin(t1), wt);\n      }\n    }\n  }\n  return new Float32Array(seg);\n}\n\n// Lay the text out along the band: each letter's start, width, segments and\n// whether it is lost. A wider gap closes the round before it starts again.\nfunction layout() {\n  const shapes = {};\n  for (const ch in GLYPHS) shapes[ch] = build(GLYPHS[ch][1]);\n  const letters = [];\n  let x = 0, lost = false;\n  for (const ch of TEXT) {\n    if (ch === \"[\" || ch === \"]\") {\n      lost = ch === \"[\";\n      continue;\n    }\n    const w = GLYPHS[ch][0] * CAP;\n    letters.push({ x, w, seg: shapes[ch], lost });\n    x += w + GAP;\n  }\n  const len = x + 14;\n  // at[i]: the first letter whose right edge passes arc i, for a quick find.\n  const at = new Int16Array(floor(len) + 1);\n  for (let i = 0, k = 0; i \u003c= floor(len); i++) {\n    while (k \u003c letters.length && letters[k].x + letters[k].w \u003c i) k++;\n    at[i] = min(k, letters.length - 1);\n  }\n  // The lost stretch, a little wider than its letters.\n  let lost0 = Infinity, lost1 = -Infinity;\n  for (const g of letters) if (g.lost) (lost0 = min(lost0, g.x - 1.2)), (lost1 = max(lost1, g.x + g.w + 1.2));\n  return { letters, len, at, lost0, lost1 };\n}\n\n// Marble: a vein field on the stone, 160 columns round by 256 rows,\n// periodic both ways, from wrapped value noise and a sine through it.\nconst TW = 160, TH = 256;\nfunction marble() {\n  const tex = new Float32Array(TW * TH);\n  const oct = [[10, 16, 1], [20, 32, 0.5], [40, 64, 0.25]].map(([nx, ny, a]) => {\n    const g = new Float32Array(nx * ny);\n    for (let i = 0; i \u003c g.length; i++) g[i] = Math.random();\n    return { nx, ny, a, g };\n  });\n  const sm = (u) => u * u * (3 - 2 * u);\n  for (let y = 0; y \u003c TH; y++)\n    for (let x = 0; x \u003c TW; x++) {\n      let n = 0;\n      for (const o of oct) {\n        const fx = (x / TW) * o.nx, fy = (y / TH) * o.ny, ix = floor(fx), iy = floor(fy), ux = sm(fx - ix), uy = sm(fy - iy);\n        const a = o.g[(iy % o.ny) * o.nx + (ix % o.nx)], b = o.g[(iy % o.ny) * o.nx + ((ix + 1) % o.nx)];\n        const c = o.g[((iy + 1) % o.ny) * o.nx + (ix % o.nx)], d = o.g[((iy + 1) % o.ny) * o.nx + ((ix + 1) % o.nx)];\n        n += o.a * (a + (b - a) * ux + (c - a + (d - c - b + a) * ux) * uy);\n      }\n      const m = abs(sin(TAU * (2 * x / TW + y / TH) + 5 * n));\n      tex[y * TW + x] = (1 - m) ** 6 * 0.55 + n * 0.12;\n    }\n  return tex;\n}\n\nexport function setup(params) {\n  const L = layout();\n  params.s = { L, tex: marble(), phi: 0, shift: 0, band: 0, climb: 0, paint: 0, turn: 2, turns: 5, light: 0.06, rough: new Float32Array(64) };\n  for (let i = 0; i \u003c 64; i++) params.s.rough[i] = Math.random();\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 5, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.paint = cl(k[0] || 0, 0, 1);\n  s.turn = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  s.turns = cl(k[2] == null ? 5 : k[2], 5, 9);\n  s.light = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  // 6 LEDs a second of arc at the front for each unit of Turn. The turn\n  // slides the text along the band; the view climbs FOLLOW of the band's\n  // rise, so the band itself creeps up the rest, a barber pole slowed down.\n  const dphi = (6 * s.turn * dt) / R, P = H / s.turns;\n  s.phi = (s.phi + dphi) % TAU;\n  s.shift = (s.shift + R * dphi) % s.L.len;\n  s.band += ((1 - FOLLOW) * P * dphi) / TAU;\n  s.climb = (s.climb + (FOLLOW * P * dphi) / TAU) % TH;\n}\n\n// Coverage of the letters at one LED: (u, v) its place on the band in LEDs,\n// sq the squeeze cos(beta). Returns coverage and the outward direction of\n// the nearest stroke edge (for the walls of the cut) in out.\nfunction ink(L, u, v, sq, out) {\n  const { letters, at } = L;\n  const pad = 2 / sq + 1;\n  let best = 0, nx = 0, ny = 0;\n  const i0 = at[cl(floor(u - pad), 0, at.length - 1)], i1 = at[cl(floor(u + pad), 0, at.length - 1)];\n  for (let i = i0; i \u003c= i1; i++) {\n    const g = letters[i], seg = g.seg, lu = u - g.x, lv = v;\n    for (let j = 0; j \u003c seg.length; j += 5) {\n      const ax = seg[j], ay = seg[j + 1], bx = seg[j + 2] - ax, by = seg[j + 3] - ay, hw = seg[j + 4];\n      const bb = bx * bx + by * by, t = bb > 0 ? cl(((lu - ax) * bx + (lv - ay) * by) / bb, 0, 1) : 0;\n      let dx = lu - ax - t * bx, dy = lv - ay - t * by;\n      const d = sqrt(dx * dx + dy * dy);\n      if (d - hw > pad) continue;\n      if (d > 1e-4) (dx /= d), (dy /= d);\n      else (dx = 0), (dy = 0);\n      // The gradient of the distance in LEDs on the panel: across the\n      // squeeze an arc step is sq LEDs wide.\n      const gx = dx / sq, gl = sqrt(gx * gx + dy * dy) || 1;\n      const c = min(0.5 - (d - hw) / gl, (2 * hw) / gl, 1);\n      if (c > best) (best = c), (nx = dx), (ny = dy), (out[2] = g.lost ? 1 : 0), (out[3] = d / hw);\n    }\n  }\n  out[0] = nx;\n  out[1] = ny;\n  return best;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const L = s.L, tex = s.tex, P = H / s.turns, phi = s.phi;\n  const al = ((-65 + 130 * s.light) * PI) / 180, ce = cos(ELEV), se = sin(ELEV);\n  // The light and the half vector for a little sheen.\n  const lx = sin(al) * ce, lz = cos(al) * ce, hx = lx, hy = -se, hz = lz + 1, hl = sqrt(hx * hx + hy * hy + hz * hz);\n  const paint = hsv(0.02 + s.paint, 0.86, 1);\n  const out = [0, 0, 0, 0];\n  const climb = s.climb, band = s.band, shift = s.shift;\n  for (let x = 0; x \u003c W; x++) {\n    const sx = (x + 0.5 - CX) / R, edge = cl(R - abs(x + 0.5 - CX) + 0.5, 0, 1);\n    const beta = asin(cl(sx, -1, 1)), sq = max(0.05, cos(beta));\n    const nX = sin(beta), nZ = cos(beta);\n    const lam = max(0, nX * lx + nZ * lz), spec = max(0, (nX * hx + nZ * hz) / hl) ** 30;\n    const shade = 0.13 + 0.92 * lam;\n    // The lamp's pull along the surface, for the walls of the cuts.\n    const tu = sin(al - beta) * ce, tv = -se;\n    const us = frac((beta + phi) / TAU) * TW;\n    const qb = (P * beta) / TAU + band;\n    for (let y = 0; y \u003c H; y++) {\n      const sb = 14 + (y / H) * 8;\n      if (edge \u003c= 0) {\n        display.setPixel(x, y, 5, 7, round(sb));\n        continue;\n      }\n      // The stone under this LED.\n      const ys = y - climb, vy = ((floor(ys) % TH) + TH) % TH;\n      const vein = tex[vy * TW + (floor(us) % TW)];\n      let r = 236 - 70 * vein, gr = 230 - 66 * vein, b = 218 - 50 * vein;\n      // Which turn of the band, and where in it.\n      const q = y + 0.5 - Y0 + qb, m = floor(q / P), v = q - m * P;\n      let k = shade, lr = 0, lg = 0, lb = 0, c = 0;\n      if (v \u003c BAND) {\n        // The band is a shallow sunk ribbon: shadow under its top edge, a\n        // lit lip at its foot.\n        k *= v \u003c 1 ? 0.5 + 0.2 * (1 - se) : v >= BAND - 1 ? 1.18 : 0.86;\n        let u = R * (beta - TAU * m) + shift;\n        u = ((u % L.len) + L.len) % L.len;\n        // The broken patch where the piece is lost: rough, darker stone.\n        if (u > L.lost0 && u \u003c L.lost1) k *= 0.5 + 0.22 * s.rough[(floor(u * 0.7) + 7 * floor(v * 0.6)) & 63];\n        c = ink(L, u, v - TOP, sq, out);\n        if (c > 0) {\n          // A wall of the cut facing the lamp is lit, the one facing away\n          // dark; the stroke's middle is the floor of the V. A lost letter\n          // is only the restorer's pale outline on the broken patch.\n          const kk = shade * (1 - 0.55 * (out[0] * tu + out[1] * tv) * cl(out[3], 0, 1));\n          if (out[2]) (lr = r * 1.05 * shade), (lg = gr * 1.05 * shade), (lb = b * 1.08 * shade), (c *= 0.75);\n          else (lr = 255 * paint[0] * kk), (lg = 255 * paint[1] * kk), (lb = 255 * paint[2] * kk);\n        }\n      }\n      r = r * k + 120 * spec;\n      gr = gr * k + 118 * spec;\n      b = b * k + 112 * spec;\n      if (c > 0) (r += (lr - r) * c), (gr += (lg - gr) * c), (b += (lb - b) * c);\n      const sky = 1 - edge;\n      display.setPixel(x, y, round(cl(r * edge + 5 * sky, 0, 255)), round(cl(gr * edge + 7 * sky, 0, 255)), round(cl(b * edge + sb * sky, 0, 255)));\n    }\n  }\n}\n","abracadabra":"// ===== Patternflow pattern =====\n// Title:   Abracadabra\n// Family:  type\n// Idea:    The fever charm from Serenus Sammonicus stands down all 128 rows as eleven lines of ABRACADABRA, one letter shorter each line, and a fever runs down through it again and again, writing each line hot as it passes, while the one letter each line leaves out flares, burns, cools to ash and crumbles to a faint scorch, until only the last A carries the heat off the foot of the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the ABRACADABRA cone in Quintus Serenus Sammonicus, Liber Medicinalis (usually dated to the early 3rd century AD), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Form=0..2, Cooling=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together: at 0 the fever is hot pink going white where it is hottest, the written lines a pale teal, the letter each line leaves out burns amber, and its ash is a grey blue.\n// Knob 2: Speed. The fever crosses one line a beat: 0.6 s at 2, so it goes down the 128 rows in 6.6 s and comes round again every 8.4 s; ten times slower at 0.2 and half again as fast at 3.\n// Knob 3: Form. Which end of the line loses its letter, rounded to 0, 1 or 2. 0 drops the last letter, the staircase whose left column reads eleven A's; 1 drops the first, the mirrored staircase; 2 drops the last and the first in turn, the centred cone that ends on the A in the middle of the word. Every letter stays in its own column, so the three forms end on an A.\n// Knob 4: Cooling. How long the heat stays behind the fever: at 0.06 a line is back to ink a beat or so after it was written and the ash of a left-out letter has crumbled to its scorch 3 to 5 beats after it caught; at 1 the cone stays pink about 4 beats behind the front and the ash crumbles over 6 to 17 beats, so about a third of it is still there when the next fever comes round.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters. The word needs five: A B R C D. Eleven letters must fit 64\n// columns, so each is 4 wide on a 5 LED pitch (54 columns, 5 spare on each\n// side) and 9 tall, one stroke wide. A line has 11.64 rows, so the eleven\n// lines fill the 128 rows with 2 or 3 dark rows between them.\nconst GLYPH = {\n  A: [\".##.\", \"#..#\", \"#..#\", \"#..#\", \"####\", \"#..#\", \"#..#\", \"#..#\", \"#..#\"],\n  B: [\"###.\", \"#..#\", \"#..#\", \"#..#\", \"###.\", \"#..#\", \"#..#\", \"#..#\", \"###.\"],\n  R: [\"###.\", \"#..#\", \"#..#\", \"#..#\", \"###.\", \"#.#.\", \"#..#\", \"#..#\", \"#..#\"],\n  C: [\".##.\", \"#..#\", \"#...\", \"#...\", \"#...\", \"#...\", \"#...\", \"#..#\", \".##.\"],\n  D: [\"###.\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"###.\"],\n};\nconst WORD = \"ABRACADABRA\", N = 11, GW = 4, GH = 9, X0 = 5, PX = 5, LH = H / N;\nconst TOP = [];\nfor (let i = 0; i \u003c N; i++) TOP.push(round(i * LH + (LH - GH) / 2));\n// Rows 1, 13, 25, 36, 48, 60, 71, 83, 94, 106, 118: the last line ends on row 126.\n\n// Every place in the 11 by 11 grid: line i, column j holds WORD[j], always in\n// the same column, so a line that loses its first letter does not shift.\n// pix lists the lit LEDs of each place; rnd is a fixed number per LED that\n// sets when that LED of an ash letter crumbles.\nconst CELL = [];\nfor (let i = 0; i \u003c N; i++)\n  for (let j = 0; j \u003c N; j++) {\n    const g = GLYPH[WORD[j]], pix = [];\n    for (let r = 0; r \u003c GH; r++)\n      for (let c = 0; c \u003c GW; c++) if (g[r][c] === \"#\") pix.push((TOP[i] + r) * W + X0 + PX * j + c);\n    CELL.push({ i, j, pix });\n  }\nfunction hash(n) {\n  let h = Math.imul(n ^ 0x9e3779b9, 0x85ebca6b) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nconst RND = new Float32Array(NP);\nfor (let p = 0; p \u003c NP; p++) RND[p] = hash(p + 17);\n\n// ---- The forms. Line i keeps the columns a..b of the word. L[j] is the line\n// on which column j is left out, the line its letter burns on; the column\n// that is never left out gets 11, below the last line. Staircase: line i\n// keeps 0..10-i, so L = 11, 10, 9, ..., 1 and the letters burn in the order\n// A R B A D A C A R B, the word backwards, with the first A left to carry the\n// last of the heat. Mirrored: line i keeps i..10. Cone: the last and the\n// first in turn, line i keeps floor(i/2)..10-ceil(i/2), and the middle A,\n// column 5, is left.\nconst FORMS = [0, 1, 2].map((f) => {\n  const L = new Int8Array(N).fill(N);\n  for (let i = N - 1; i >= 0; i--) {\n    const a = f === 0 ? 0 : f === 1 ? i : floor(i / 2), b = f === 0 ? N - 1 - i : f === 1 ? N - 1 : N - 1 - Math.ceil(i / 2);\n    for (let j = 0; j \u003c N; j++) if (j \u003c a || j > b) L[j] = i;\n  }\n  let last = 0;\n  for (let j = 0; j \u003c N; j++) if (L[j] === N) last = j;\n  return { L, last };\n});\n// Checked: every form keeps 11 - i letters on line i (66 in all), burns one\n// letter on each of lines 1..10, and leaves an A: column 0, 10 or 5.\nfor (const F of FORMS) {\n  for (let i = 0; i \u003c N; i++) {\n    let k = 0, burn = 0;\n    for (let j = 0; j \u003c N; j++) (k += i \u003c F.L[j] ? 1 : 0), (burn += i === F.L[j] ? 1 : 0);\n    if (k !== N - i || burn !== (i ? 1 : 0)) throw new Error(\"Abracadabra form is off at line \" + i);\n  }\n  if (WORD[F.last] !== \"A\") throw new Error(\"Abracadabra does not end on an A\");\n}\n\n// ---- Time, in beats. The fever's front is at row (beat - 0.5) * 11.64, so\n// it crosses one line a beat, enters the top half a beat into the cycle and\n// leaves the foot at 11.5. The cycle is 14 beats; the last 2.5 are the heat\n// leaving under the last A and the ash crumbling. A fresh start comes in at\n// beat 2.6, with the first two lines already written and burning.\nconst CYCLE = 14, ENTER = 0.5, START = 2.6;\nconst INLINE = new Uint8Array(H);\nfor (const t of TOP) for (let r = 0; r \u003c GH; r++) INLINE[t + r] = 1;\nconst lineOf = (y) => {\n  // The line the front is going to at row y: the gap above a line counts as that line's.\n  for (let i = 0; i \u003c N; i++) if (y \u003c= TOP[i] + GH - 1) return i;\n  return N;\n};\n\nexport function setup(params) {\n  params.s = {\n    beat: START, hue: 0, form: 0, cool: 0.06, t: 0,\n    rgb: new Float32Array(NP * 3), glow: new Float32Array(NP), tmp: new Float32Array(NP),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3);\n  S.form = cl(round(k[2]), 0, 2);\n  S.cool = cl(k[3], 0, 1);\n  // One beat is 1.2 / Speed seconds: 0.6 s at 2.\n  S.beat += (d * speed) / 1.2;\n  S.t += d;\n}\n\nfunction blur(src, tmp) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (2 * src[p] + (x > 0 ? src[p - 1] : 0) + (x \u003c W - 1 ? src[p + 1] : 0)) / 4;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      src[p] = (2 * tmp[p] + (y > 0 ? tmp[p - W] : 0) + (y \u003c H - 1 ? tmp[p + W] : 0)) / 4;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, glow } = S, F = FORMS[S.form];\n  const tau = ((S.beat % CYCLE) + CYCLE) % CYCLE, Y = (tau - ENTER) * LH;\n  const hF = 0.9 + S.hue;\n  const inkF = hsv(hF + 0.58, 0.45, 0.74), ember = hsv(hF, 0.85, 1), white = hsv(hF, 0.1, 1);\n  const flare = hsv(hF + 0.2, 0.15, 1), flame = hsv(hF + 0.2, 0.75, 1);\n  const ash = hsv(hF + 0.72, 0.3, 0.34), speck = hsv(hF + 0.04, 0.7, 0.9), scorch = hsv(hF + 0.72, 0.3, 0.125);\n  // The heat in a written letter falls by a factor e every tk beats; an LED of\n  // ash lasts 2.4 + ta * (0.3 + its own number 0..1) beats after it caught.\n  const tk = 0.8 + 3.2 * S.cool, ta = 1.5 + 10 * S.cool;\n  // Embers flicker 12 times a second, each LED on its own.\n  const fl = floor(S.t * 12);\n  rgb.fill(0);\n  glow.fill(0);\n  const put = (p, c, v) => {\n    rgb[p * 3] = c[0] * v, rgb[p * 3 + 1] = c[1] * v, rgb[p * 3 + 2] = c[2] * v;\n  };\n  // Beats since the front last passed row y: this cycle's pass, or the last one's.\n  const since = (y) => {\n    const s = (Y - y) / LH;\n    return s \u003c 0 ? s + CYCLE : s;\n  };\n\n  for (const C of CELL) {\n    const Lj = F.L[C.j];\n    if (C.i > Lj) continue;\n    if (C.i \u003c Lj) {\n      // A kept letter: written hot as the front goes through it row by row,\n      // then cooling back to ink, which fades from 100% to 64% over the\n      // cycle (e every 5 beats), so the lines the fever has just written\n      // stand out from the ones it is coming to.\n      for (const p of C.pix) {\n        const s = since(floor(p / W));\n        const h = s \u003c 0.12 ? s / 0.12 : exp(-(s - 0.12) / tk), m = 0.62 + 0.38 * exp(-s / 5);\n        const ink = [inkF[0] * m, inkF[1] * m, inkF[2] * m];\n        let c;\n        if (h > 0.55) {\n          const u = (h - 0.55) / 0.45;\n          c = [ember[0] + (white[0] - ember[0]) * u, ember[1] + (white[1] - ember[1]) * u, ember[2] + (white[2] - ember[2]) * u];\n        } else {\n          const u = h / 0.55;\n          c = [ink[0] + (ember[0] - ink[0]) * u, ink[1] + (ember[1] - ink[1]) * u, ink[2] + (ember[2] - ink[2]) * u];\n        }\n        put(p, c, 255);\n        glow[p] += h;\n      }\n      continue;\n    }\n    // The letter this line leaves out burns in a colour of its own, a fifth\n    // of the wheel past the fever (amber at Hue 0): white for 0.4 beat as the\n    // front reaches it, a flickering flame for a beat, then by beat 2.4 it\n    // cools to ash, turning back round the wheel through the fever's pink so\n    // it never passes through a dim orange. Each LED then crumbles at its own\n    // time, lighting once more as it goes and leaving a scorch at 32 of 255\n    // that the next fever burns again.\n    for (const p of C.pix) {\n      const s = since(floor(p / W)), r = RND[p], life = 2.4 + ta * (0.3 + r);\n      if (s > life) put(p, scorch, 255);\n      else if (s \u003c 0.4) {\n        put(p, flare, 255);\n        glow[p] += 2;\n      } else if (s \u003c 1.4) {\n        const f = 0.45 + 0.55 * hash(p * 31 + fl);\n        put(p, flame, 255 * f);\n        glow[p] += 1.4 * f;\n      } else if (s \u003c 2.4) {\n        const u = s - 1.4;\n        put(p, hsv(hF + 0.2 - 0.48 * u, 0.75 - 0.45 * u, 1 - 0.66 * u), 255);\n        glow[p] += 0.6 * (1 - u);\n      } else if (s > life - 0.3) {\n        put(p, speck, 255 * (0.5 + 0.5 * hash(p * 7 + fl)));\n        glow[p] += 0.4;\n      } else put(p, ash, 255);\n    }\n  }\n\n  // ---- The front: a drop of heat in every column still carrying it, which\n  // is every column whose letter has not yet been left out above this row.\n  // It shows only in the dark rows between lines (inside a line the letter\n  // itself lights row by row), and the survivor's runs on off the foot.\n  const lf = lineOf(Y);\n  if (Y > -2 && Y \u003c H + 2)\n    for (let j = 0; j \u003c N; j++) {\n      if (F.L[j] \u003c lf) continue;\n      const cx = X0 + PX * j + 1.5;\n      for (let dy = -4; dy \u003c= 1; dy++) {\n        const y = floor(Y) + dy;\n        if (y \u003c 0 || y >= H || INLINE[y]) continue;\n        const v = dy > 0 ? 0.5 : exp(dy / 1.6);\n        for (const x of [floor(cx), floor(cx) + 1]) {\n          const p = y * W + x;\n          glow[p] += 1.2 * v;\n          rgb[p * 3] = max(rgb[p * 3], white[0] * 255 * v);\n          rgb[p * 3 + 1] = max(rgb[p * 3 + 1], white[1] * 255 * v);\n          rgb[p * 3 + 2] = max(rgb[p * 3 + 2], white[2] * 255 * v);\n        }\n      }\n    }\n\n  // ---- The heat off the foot: once the front has left row 127 the last of\n  // the fever spreads along the foot under the last A and fades in 2 beats.\n  const sb = (Y - H) / LH;\n  if (sb > 0 && sb \u003c 3) {\n    const xs = X0 + PX * F.last + 1.5, wdt = 4 + 12 * sb, a = exp(-sb / 1.1) * 3;\n    for (let y = H - 14; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const v = a * exp(-(((x + 0.5 - xs) / wdt) ** 2)) * exp(-(H - 0.5 - y) / (1.5 + 2.5 * sb));\n        if (v > 0.02) glow[y * W + x] += v;\n      }\n  }\n\n  // Heat glows round itself in the fever's colour.\n  blur(glow, S.tmp);\n  blur(glow, S.tmp);\n  for (let p = 0; p \u003c NP; p++) {\n    const g = min(1.6, glow[p]) * 140, o = p * 3;\n    if (g \u003c 1) continue;\n    rgb[o] += ember[0] * g, rgb[o + 1] += ember[1] * g, rgb[o + 2] += ember[2] * g;\n  }\n\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3, r = rgb[o], g = rgb[o + 1], b = rgb[o + 2];\n    if (r \u003c 1 && g \u003c 1 && b \u003c 1) continue;\n    display.setPixel(p % W, (p - (p % W)) / W, min(255, r) | 0, min(255, g) | 0, min(255, b) | 0);\n  }\n}\n","airy-beam":"// ===== Patternflow pattern =====\n// Title:   Airy Beam\n// Family:  wave\n// Idea:    A finite-energy Airy beam enters at the top and runs down the panel, its main lobe and the side lobes beside it bending together along parabolas while the field's phase runs along them as a green and blue tint, and a small bead drifting back and forth near the top blocks a lobe that grows back further down.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the nonspreading Airy wave packet (Michael Berry and Nandor Balazs, 1979), finite-energy accelerating Airy beams (Georgios Siviloglou, John Broky, Aristide Dogariu and Demetrios Christodoulides, 2007), self-healing Airy beams (John Broky, Georgios Siviloglou, Aristide Dogariu and Demetrios Christodoulides, 2008), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Truncation=0.04..0.4, Tilt=-1..1\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the beam is cyan with near-white peaks, and the field's phase tints each lobe a little towards green or towards azure, the two sides of a lobe boundary always opposite. The bead is a pale stone in any hue.\n// Knob 2: Speed. The tint follows the phase turning once a second at 2 (a tenth of that at 0.2, 1.5 at 3), so green and azure run down the lobes. The bead's drift to and fro across the beam takes 9 s at 2, 90 s at 0.2 and 6 s at 3.\n// Knob 3: Truncation. The a of the launch field Ai(s) exp(a s). At 0.04 the main lobe keeps a third of its peak to the bottom row and side lobes fill everything to its left down the whole panel. At 0.15 the far lobes fade first and the bottom row's brightest point is a tenth of the top's. At 0.4 the main lobe has lost 99.7% of its light by the bottom row and what is left there is a wide glow. The brightness is set row by row against the free beam, so the spreading shows as lobes dissolving rather than as the panel going dark.\n// Knob 4: Tilt. The launch angle v = -1.25 + 1.25 Tilt, a factor exp(i v s) at launch, which shears the whole beam by v xi. At the opening 0.06 the main lobe enters at x 28, swings left to x 22 at row 38 and bends right to x 54 at the bottom. At -1 it falls to x 26 at row 80 and turns back to x 34, like a ball thrown upward. At 1 it is launched straight and bends 63 LEDs, leaving the panel at row 121.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Units. The paraxial equation i dphi/dxi + (1/2) d2phi/ds2 = 0 in\n// s = x / x0 across and xi = z / (k x0^2) down. One LED is 1/4 of s, and the\n// 128 rows run xi from 0 at row 0 (the launch plane) to 8.\nconst X0 = 4, XI = 8, DXI = XI / H;\n// The beam is worked on N points one LED apart, s from S0 = -96 to 32. At\n// any tilt the panel sees the untilted beam only between s = -13.6 and 22.2.\n// At a = 0.04 the launch field at -96 is down to 0.8% of the main lobe, and\n// the spectrum at the grid's highest wavenumber, 4 pi, to 0.2%.\nconst N = 512, S0 = -96, MASK = N - 1;\n\n// ---- FFT, radix 2, in place, the sum with exp(+2 pi i m j / N) and no 1/N.\nconst REV = new Uint16Array(N);\nfor (let i = 0, b = Math.log2(N); i \u003c N; i++) {\n  let r = 0;\n  for (let k = 0; k \u003c b; k++) r |= ((i >> k) & 1) \u003c\u003c (b - 1 - k);\n  REV[i] = r;\n}\nconst TC = new Float64Array(N / 2), TS = new Float64Array(N / 2);\nfor (let i = 0; i \u003c N / 2; i++) (TC[i] = cos((2 * PI * i) / N)), (TS[i] = sin((2 * PI * i) / N));\nfunction ifft(re, im) {\n  for (let i = 0; i \u003c N; i++) {\n    const j = REV[i];\n    if (j > i) {\n      let t = re[i];\n      (re[i] = re[j]), (re[j] = t);\n      t = im[i];\n      (im[i] = im[j]), (im[j] = t);\n    }\n  }\n  for (let len = 2; len \u003c= N; len \u003c\u003c= 1) {\n    const half = len >> 1, step = N / len;\n    for (let i = 0; i \u003c N; i += len)\n      for (let k = 0; k \u003c half; k++) {\n        const c = TC[k * step], s = TS[k * step], a = i + k, b = a + half;\n        const xr = re[b] * c - im[b] * s, xi = re[b] * s + im[b] * c;\n        (re[b] = re[a] - xr), (im[b] = im[a] - xi), (re[a] += xr), (im[a] += xi);\n      }\n  }\n}\n// Wavenumber of FFT bin m.\nconst KM = new Float64Array(N);\nfor (let m = 0; m \u003c N; m++) KM[m] = (2 * PI * (m \u003c N / 2 ? m : m - N) * X0) / N;\n\n// ---- The free-space propagator over d rows on this grid: the inverse FFT of\n// exp(-i k^2 d DXI / 2), divided by N. Convolving a field with KR/KI[d] is\n// the same as one FFT step of split-step propagation, exactly.\nconst KR = new Float32Array(H * N), KI = new Float32Array(H * N);\n{\n  const re = new Float64Array(N), im = new Float64Array(N);\n  for (let d = 1; d \u003c H; d++) {\n    for (let m = 0; m \u003c N; m++) {\n      const ph = (-KM[m] * KM[m] * d * DXI) / 2;\n      (re[m] = cos(ph) / N), (im[m] = sin(ph) / N);\n    }\n    ifft(re, im);\n    KR.set(re, d * N);\n    KI.set(im, d * N);\n  }\n}\n\n// ---- The free beam for truncation a, every row. The launch field\n// Ai(s) exp(a s) has the spectrum exp(a^3/3) exp(-a k^2) exp(i (k^3/3 - a^2 k))\n// (shift the contour of Ai's integral by i a), and each plane wave picks up\n// exp(-i k^2 xi / 2) on the way down. Checked against a power series of Ai\n// at a = 0.04: row 0 gives 0.355028 at s = 0, 0.514561 at -1, -0.335979 at\n// -3 and 0.026987 at -10, all within 1e-5; row 64 agrees with a direct\n// O(N^2) transform of row 0 to five places.\nfunction freeBeam(S, a) {\n  const re = new Float64Array(N), im = new Float64Array(N), c = (X0 / N) * exp((a * a * a) / 3);\n  for (let r = 0; r \u003c H; r++) {\n    const xi = r * DXI;\n    for (let m = 0; m \u003c N; m++) {\n      const k = KM[m], amp = c * exp(-a * k * k), ph = (k * k * k) / 3 - a * a * k + k * S0 - (k * k * xi) / 2;\n      (re[m] = amp * cos(ph)), (im[m] = amp * sin(ph));\n    }\n    ifft(re, im);\n    let peak = 0;\n    for (let j = 0; j \u003c N; j++) peak = max(peak, re[j] * re[j] + im[j] * im[j]);\n    S.FR.set(re, r * N);\n    S.FI.set(im, r * N);\n    S.RM[r] = peak;\n  }\n  S.a = a;\n}\n\n// Main lobe of Ai at s = -1.0188, the first maximum.\nconst A1 = -1.0188;\n// The bead: its row, its half width in LEDs, and its drift about the main\n// lobe, from 6 LEDs right of it to 11 left. Set squarely on the main lobe at\n// a = 0.04 it leaves the lobe 20% of the free beam's intensity 8 rows below,\n// 47% by row 60 and 62% by row 80: the side lobes feed it back. It never\n// heals all the way, since the bead keeps what it took.\nconst OBS_ROW = 22, OBS_W = 2.6, OBS_MID = -2.5, OBS_AMP = 8.5, OBS_T = 9;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, a: -1, v: 0,\n    FR: new Float32Array(H * N), FI: new Float32Array(H * N), RM: new Float32Array(H),\n    I: new Float32Array(W * H), C: new Float32Array(W * H), rgb: new Float32Array(W * H * 3),\n    ub: new Int32Array(16), ur: new Float32Array(16), ui: new Float32Array(16), GR: new Float32Array(W + 1), GI: new Float32Array(W + 1),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.04, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.t += (d * cl(k[1], 0.2, 3)) / 2;\n  // Steps of 0.0025 in a, so a knob held still never rebuilds the beam. A\n  // rebuild is 128 FFTs, about 13 ms in Node; the propagator table above is\n  // as many again, once at load. A frame after that is about 1.4 ms.\n  const a = Math.round(cl(k[2], 0.04, 0.4) * 400) / 400;\n  if (a !== S.a) freeBeam(S, a);\n  S.v = -1.25 + 1.25 * cl(k[3], -1, 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.a \u003c 0) return;\n  const { FR, FI, RM, I, C, rgb, ub, ur, ui, GR, GI, v } = S;\n  // The main lobe runs along s = A1 + v xi + xi^2 / 4 in the panel's frame.\n  // The middle of its range across the panel sits at x = 38.\n  let lo = A1, hi = A1;\n  for (let r = 0; r \u003c H; r++) {\n    const xi = r * DXI, s = A1 + v * xi + (xi * xi) / 4;\n    (lo = min(lo, s)), (hi = max(hi, s));\n  }\n  const sL = (lo + hi) / 2 - 38 / X0;\n  // The beam's own grid point under LED x of row r is x + off(r): the tilt\n  // is the shear s -> s + v xi of the untilted beam.\n  const off = (r) => (sL - S0) * X0 - v * r * DXI * X0;\n\n  // ---- The bead and the light it takes out, on the beam's grid.\n  const xio = OBS_ROW * DXI, xm = (A1 + v * xio + (xio * xio) / 4 - sL) * X0;\n  const co = xm + OBS_MID + OBS_AMP * sin((2 * PI * S.t) / OBS_T);\n  const jc = co + off(OBS_ROW);\n  let nb = 0;\n  for (let j = Math.ceil(jc - OBS_W - 0.5); j \u003c= floor(jc + OBS_W + 0.5); j++) {\n    const b = cl(OBS_W + 0.5 - Math.abs(j - jc), 0, 1);\n    if (b \u003c= 0) continue;\n    const q = OBS_ROW * N + (j & MASK);\n    (ub[nb] = j), (ur[nb] = b * FR[q]), (ui[nb] = b * FI[q]), nb++;\n  }\n\n  // ---- The field at every LED: the free beam minus what the bead took out,\n  // carried down by the propagator, on the 65 grid points under the row,\n  // then linear between the two either side of each LED.\n  const wc = cos(2 * PI * S.t), ws = sin(2 * PI * S.t);\n  for (let r = 0; r \u003c H; r++) {\n    const o = off(r), jb = floor(o), f = o - jb, d = r - OBS_ROW, kb = d * N;\n    for (let e = 0; e \u003c= W; e++) {\n      const j = jb + e, q = r * N + (j & MASK);\n      let pr = FR[q], pi = FI[q];\n      if (d > 0)\n        for (let n = 0; n \u003c nb; n++) {\n          const kk = kb + ((j - ub[n]) & MASK), kr = KR[kk], ki = KI[kk];\n          pr -= kr * ur[n] - ki * ui[n];\n          pi -= kr * ui[n] + ki * ur[n];\n        }\n      else if (d === 0) {\n        const b = 1 - cl(OBS_W + 0.5 - Math.abs(j - jc), 0, 1);\n        (pr *= b), (pi *= b);\n      }\n      (GR[e] = pr), (GI[e] = pi);\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const fr = GR[x] + f * (GR[x + 1] - GR[x]), fi = GI[x] + f * (GI[x + 1] - GI[x]);\n      const ii = fr * fr + fi * fi, p = r * W + x;\n      I[p] = ii;\n      C[p] = ii > 1e-12 ? (fr * wc + fi * ws) / sqrt(ii) : 0;\n    }\n  }\n\n  // ---- Light. Brightness is intensity over the geometric mean of 0.25 and\n  // the free beam's brightest point in that row, to the power 0.55: a row\n  // whose free beam peaks 100 times below 0.25 is drawn as if 10 times\n  // below. The tint is cos(phase - 2 pi t), 0.05 of the wheel either way.\n  for (let r = 0; r \u003c H; r++) {\n    const ref = sqrt(0.25 * RM[r]);\n    for (let x = 0; x \u003c W; x++) {\n      const p = r * W + x, val = min(1, Math.pow(I[p] / ref, 0.55));\n      hsv(0.5 + S.hue + 0.05 * C[p], 1 - 0.55 * val * val, val, rgb, p * 3);\n    }\n  }\n  // The bead: a pale stone, lit on top by the light that falls on it from\n  // three rows up.\n  for (let y = OBS_ROW - 2; y \u003c= OBS_ROW + 1; y++)\n    for (let x = floor(co - OBS_W - 1); x \u003c= co + OBS_W + 1; x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const dx = (x + 0.5 - co) / (OBS_W + 0.6), dy = (y + 0.5 - (OBS_ROW - 0.2)) / 1.9, rr = dx * dx + dy * dy;\n      if (rr > 1) continue;\n      const lit = min(1, sqrt(I[max(0, OBS_ROW - 3) * W + x] / 0.15)), sh = 0.3 + 0.25 * (1 - rr) + 0.45 * lit * (dy \u003c 0 ? 1 : 0.4);\n      hsv(0.08 + S.hue, 0.15, sh, rgb, (y * W + x) * 3);\n    }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p % W, floor(p / W), (rgb[p * 3] * 255) | 0, (rgb[p * 3 + 1] * 255) | 0, (rgb[p * 3 + 2] * 255) | 0);\n}\n","damask":"// ===== Patternflow pattern =====\n// Title:   Damask\n// Family:  type\n// Idea:    A cloth of one ivory thread woven at one LED per crossing carries a big word in warp-faced satin on a weft-faced satin ground, so only the light tells letter from ground, and as a low lamp walks round the table the word flips from brighter than the cloth to darker than it and back.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: damask weave (figure in warp-faced satin on a weft-faced satin ground of the same thread), five-end satin, anisotropic thread sheen (James Kajiya and Timothy Kay, 1989), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Lamp=0..1\n//\n// Knob 1: Hue. The colour of the one thread, always pale: linen ivory at 0, mint at 0.25, a cold blue at 0.5 and rose at 0.75.\n// Knob 2: Speed. How fast the lamp walks round the table: once in 64 s at 2, so the word turns from light to dark every 16 s; 43 s at 3 and over ten minutes at 0.2. The low swells under the cloth keep the same clock.\n// Knob 3: Word. What the cloth says: LUX, the Hangul syllable 빛 (light), NOX, or 밤 (night). Each word is woven with the stem width that makes it 10 to 11% of the cloth: 4.0 LEDs for LUX, 3.3 to 3.5 for the others.\n// Knob 4: Lamp. How high the lamp stands: at 0.06 it rakes the cloth from 8 degrees up, the word is sharp and every swell in the cloth shows; towards 1 it climbs to 68 degrees, both threads catch the light alike, the swells flatten out and the word sinks into the cloth.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, sqrt, cos, sin, tan, min, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The weave. The warp runs down the panel (one end per column), the weft\n// across (one pick per row), and each LED is one crossing: lit by whichever\n// thread lies on top there. The ground is a five-end weft-faced satin with\n// move number 2: the warp comes up where (y + 2x) mod 5 = 0, once in every\n// five crossings of each row and each column, and never next to another\n// binding point across or down (the four neighbours give 1, 2, 3, 4 mod 5).\n// The figure is the back of the same cloth: at every crossing the other\n// thread is on top, so the word is warp-faced satin whose weft binding points\n// sit exactly where the ground's warp binding points would be.\nconst groundWarp = (x, y) => (y + 2 * x) % 5 === 0;\n\n// ---- Letters, as strokes in a box one cap height tall: [x0, y0, x1, y1, w],\n// w the weight (1 a stem, 0.72 a hairline, 0.62 a serif). The capitals are\n// a plain roman with thick and thin strokes and bar serifs; the Hangul is one\n// weight.\nfunction arc(cx, cy, rx, ry, a0, a1, n, w0, w1) {\n  const out = [];\n  for (let i = 0; i \u003c n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n, b = a0 + ((a1 - a0) * (i + 1)) / n, m = (a + b) / 2;\n    out.push([cx + rx * cos(a), cy + ry * sin(a), cx + rx * cos(b), cy + ry * sin(b), w0 + (w1 - w0) * abs(cos(m))]);\n  }\n  return out;\n}\nconst SERIF = 0.62, HAIR = 0.72;\nconst GLYPH = {\n  L: { w: 0.78, s: [[0.17, 0, 0.17, 1, 1], [0.17, 0.985, 0.9, 0.985, HAIR], [0, 0.015, 0.36, 0.015, SERIF], [0, 0.985, 0.2, 0.985, SERIF], [0.9, 1, 0.92, 0.8, SERIF]] },\n  U: {\n    w: 0.96,\n    s: [[0.17, 0, 0.17, 0.64, 1], [0.83, 0, 0.83, 0.64, HAIR], [0, 0.015, 0.36, 0.015, SERIF], [0.68, 0.015, 1, 0.015, SERIF], ...arc(0.5, 0.64, 0.33, 0.345, 0, PI, 8, HAIR, 1)],\n  },\n  X: { w: 0.98, s: [[0.1, 0, 0.9, 1, 1], [0.88, 0, 0.12, 1, HAIR], [-0.04, 0.015, 0.3, 0.015, SERIF], [0.72, 0.015, 1.04, 0.015, SERIF], [-0.04, 0.985, 0.28, 0.985, SERIF], [0.7, 0.985, 1.04, 0.985, SERIF]] },\n  N: { w: 0.96, s: [[0.13, 0, 0.13, 1, HAIR], [0.13, 0, 0.87, 1, 1], [0.87, 0, 0.87, 1, HAIR], [-0.02, 0.015, 0.16, 0.015, SERIF], [0.7, 0.015, 1.02, 0.015, SERIF], [-0.02, 0.985, 0.3, 0.985, SERIF]] },\n  O: { w: 1, s: arc(0.5, 0.5, 0.4, 0.49, 0, 2 * PI, 20, HAIR, 1) },\n};\n// Hangul syllables in a box 1 wide and 1.75 tall: the initial ㅂ top left,\n// the vowel on the right, the final consonant under both.\nconst B = [[0.1, 0.04, 0.1, 0.86, 1], [0.58, 0.04, 0.58, 0.86, 1], [0.1, 0.45, 0.58, 0.45, 1], [0.08, 0.86, 0.6, 0.86, 1]];\nconst HANGUL = {\n  빛: [...B, [0.86, 0, 0.86, 1.02, 1], [0.5, 1.04, 0.5, 1.2, 1], [0.14, 1.24, 0.86, 1.24, 1], [0.5, 1.28, 0.12, 1.71, 1], [0.38, 1.45, 0.88, 1.71, 1]],\n  밤: [...B, [0.8, 0, 0.8, 1.02, 1], [0.8, 0.46, 0.98, 0.46, 1], [0.16, 1.16, 0.84, 1.16, 1], [0.84, 1.16, 0.84, 1.7, 1], [0.84, 1.7, 0.16, 1.7, 1], [0.16, 1.7, 0.16, 1.16, 1]],\n};\n\n// Each word as strokes in panel LEDs. LUX and NOX stand one letter above\n// another, caps 28 tall from rows 8, 50 and 92; a Hangul syllable is 48 wide\n// and 84 tall, centred.\nfunction wordStrokes(word) {\n  const out = [];\n  if (HANGUL[word]) {\n    const s = 48, x0 = 32 - s / 2, y0 = 64 - (1.75 * s) / 2;\n    for (const [a, b, c, d, w] of HANGUL[word]) out.push([x0 + a * s, y0 + b * s, x0 + c * s, y0 + d * s, w]);\n    return out;\n  }\n  const cap = 28;\n  [...word].forEach((ch, i) => {\n    const g = GLYPH[ch], x0 = 32 - (g.w * cap) / 2, y0 = 8 + 42 * i;\n    for (const [a, b, c, d, w] of g.s) out.push([x0 + a * cap, y0 + b * cap, x0 + c * cap, y0 + d * cap, w]);\n  });\n  return out;\n}\n\nfunction segDist(px, py, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l2 = dx * dx + dy * dy;\n  const t = l2 > 0 ? cl(((px - s[0]) * dx + (py - s[1]) * dy) / l2, 0, 1) : 0;\n  const ex = px - s[0] - t * dx, ey = py - s[1] - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// A crossing is figure when its centre lies within half a stroke's width of\n// the stroke. The stem width is found by halving until the word covers its\n// share of the 8192 crossings (SHARE), so each word keeps about the same\n// balance of figure and ground whatever its stroke length. Done once per word,\n// the first time the Word knob lands on it: 2 to 15 ms in Node.\nconst WORDS = [\"LUX\", \"빛\", \"NOX\", \"밤\"];\nconst SHARE = [0.104, 0.115, 0.104, 0.115];\nfunction figureMask(word, share) {\n  const st = wordStrokes(word), near = new Float32Array(NP).fill(1e9);\n  // For each crossing, the stem width at which it would just fall inside.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 1e9;\n      for (const s of st) r = min(r, segDist(x + 0.5, y + 0.5, s) / s[4]);\n      near[y * W + x] = r;\n    }\n  let lo = 0.5, hi = 12;\n  for (let k = 0; k \u003c 30; k++) {\n    const mid = (lo + hi) / 2;\n    let n = 0;\n    for (let p = 0; p \u003c NP; p++) if (near[p] \u003c mid / 2) n++;\n    if (n / NP > share) hi = mid;\n    else lo = mid;\n  }\n  const m = new Uint8Array(NP);\n  for (let p = 0; p \u003c NP; p++) m[p] = near[p] \u003c lo / 2 ? 1 : 0;\n  return m;\n}\nconst MASKS = [];\n\n// Which thread is on top at each crossing: 1 warp, 0 weft.\nfunction topThreads(mask) {\n  const t = new Uint8Array(NP);\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) t[y * W + x] = groundWarp(x, y) ? 1 - mask[y * W + x] : mask[y * W + x];\n  return t;\n}\n\n// Linen is not even: each warp end and each weft pick has its own lustre,\n// between 0.95 and 1, so the floats show faint streaks along their threads.\nfunction hash(n) {\n  let h = Math.imul(n ^ 0x9e3779b9, 0x85ebca6b) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nconst WARP = Float32Array.from({ length: W }, (_, x) => 0.95 + 0.05 * hash(x + 11));\nconst WEFT = Float32Array.from({ length: H }, (_, y) => 0.95 + 0.05 * hash(y + 977));\n\n// ---- The lamp. It stands 300 LEDs from the middle of the cloth and walks\n// round it; its elevation at the middle is set by the Lamp knob. A float\n// lying along T, seen from straight above and lit from the unit direction L,\n// shines as (1 - (T.L)^2)^(P/2) (Kajiya and Kay's fibre highlight with the\n// eye overhead, where T.V = 0), times a peak level of 232. P is 4 here, so\n// the sheen is the square of 1 - (T.L)^2. A warp float (T down the\n// panel) is brightest with the lamp to its side, a weft float with the lamp\n// above or below the panel, so the two systems trade places every quarter\n// turn of the lamp.\nconst R = 300, PEAK = 232;\n// The lamp starts 28.1 degrees short of due right of the cloth and walks\n// 5.625 degrees a second at Speed 2, so at 5 s it stands square to the\n// warp. Checked over every crossing and frame from 2 s to 8 s: the lamp is\n// never more than 30.5 degrees off square, and with the swell below a weft\n// float never rises above 17.6 of 255 (under the 24 that counts as lit), a\n// warp float never falls below 92, and the word stays bright on a dark\n// ground. The two sheens are equal where dx^2 = dy^2: a straight line at 45\n// degrees through the foot of the lamp, which crosses the cloth from the\n// bottom right corner at 10.7 s to the top left at 15.3 s and passes the\n// middle at 13 s. The word vanishes along that line and comes back dark.\nconst A0 = (-28.125 * PI) / 180, RATE = (5.625 * PI) / 180;\n\n// ---- The swell. The cloth is not quite flat: two low swells run under it,\n// like a tablecloth lifting in a draught. Each is [direction in radians from\n// the x axis, wavelength in LEDs, speed in LEDs a second at Speed 2, the\n// steepest slope it gives]. A tilt changes how much light the cloth takes\n// from the lamp: with the surface normal (-gx, -gy, 1) and D the way to the\n// lamp, the light goes as N.D / D.z = 1 - (gx dx + gy dy) / hz. With the\n// lamp 8 degrees up, D runs about 7.3 LEDs across for each one up, so a\n// slope of 0.03 toward it dims or brightens the threads by 22%; with the\n// lamp 68 degrees up, by 1%, so the swell shows only in raking light, as\n// folds do. At Speed 2 the swells pass each crossing every 6 and 5.6 s,\n// and from 2 s to 8 s they scale the light by 0.62 to 1.39.\nconst SWELL = [[0.15, 36, 6, 0.03], [0.9, 28, 5, 0.02]].map(([a, l, v, g]) => ({ ux: cos(a), uy: sin(a), k: (2 * PI) / l, w: (2 * PI * v) / l, g }));\n\nexport function setup(params) {\n  params.s = { a: A0, t: 0, hue: 0, word: 0, lamp: 0.06, top: null, wordShown: -1 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const clock = (d * cl(k[1], 0.2, 3)) / 2;\n  S.a += RATE * clock;\n  S.t += clock;\n  S.word = cl(round(k[2]), 0, 3);\n  S.lamp = cl(k[3], 0, 1);\n  if (S.wordShown !== S.word) {\n    if (!MASKS[S.word]) MASKS[S.word] = figureMask(WORDS[S.word], SHARE[S.word]);\n    S.top = topThreads(MASKS[S.word]);\n    S.wordShown = S.word;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.top) return;\n  const top = S.top;\n  // Elevation 8 degrees at Lamp 0.06, 68 at 1.\n  const elev = ((4 + 64 * S.lamp) * PI) / 180, hz = R * tan(elev);\n  const lx = 32 + R * cos(S.a), ly = 64 - R * sin(S.a);\n  const c = hsv(0.115 + S.hue, 0.36, 1);\n  for (let y = 0; y \u003c H; y++) {\n    const dy = ly - (y + 0.5);\n    for (let x = 0; x \u003c W; x++) {\n      const dx = lx - (x + 0.5), inv = 1 / (dx * dx + dy * dy + hz * hz);\n      let gx = 0, gy = 0;\n      for (const w of SWELL) {\n        const q = w.g * cos(w.k * (w.ux * x + w.uy * y) - w.w * S.t);\n        gx += q * w.ux;\n        gy += q * w.uy;\n      }\n      const lit = 1 - (gx * dx + gy * dy) / hz;\n      const p = y * W + x;\n      // T.L squared: dy^2 / |D|^2 for a warp float, dx^2 / |D|^2 for a weft.\n      let s, f;\n      if (top[p]) (s = 1 - dy * dy * inv), (f = WARP[x]);\n      else (s = 1 - dx * dx * inv), (f = WEFT[y]);\n      const v = PEAK * f * s * s * (lit > 0 ? lit : 0);\n      display.setPixel(x, y, round(v * c[0]), round(v * c[1]), round(v * c[2]));\n    }\n  }\n}\n","durer-alphabet":"// ===== Patternflow pattern =====\n// Title:   Dürer's Alphabet\n// Family:  type\n// Idea:    Two ruled squares stand one above the other, and in each in turn a Roman capital is constructed by Dürer's method, its stems a tenth of the square, a travelling pen ruling the stem edges and sweeping compass arcs for the bowls and serif brackets, then ivory ink runs through the body, the paper lights up around it, and the plate holds while the next letter is drawn in the other square.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Roman capitals constructed with ruler and compass in a square, Underweysung der Messung (Albrecht Dürer, 1525), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Letter=0..12, Stem=0.1..0.2\n//\n// Knob 1: Hue. Turns the plate round the wheel: at 0 the ink is ivory, the construction lines pale teal and the paper deep blue; at 0.5 the ink is pale blue, the lines salmon and the paper dark amber.\n// Knob 2: Speed. At 2 a letter takes 8 s: 4 s of ruler and compass, 1.6 s for the ink to run through the body, 1 s for the paper, so each finished plate stands about 9 s. At 0.2 it is ten times slower.\n// Knob 3: Letter. Which of the thirteen capitals A C D E H I L M N O T V X comes first; the rest follow in that order and wrap round. At 0 the panel opens on a finished A with the C being ruled below it.\n// Knob 4: Stem. The thick stroke as a share of the square's side. At 0.1 it is Dürer's tenth, 5.9 LEDs; at 0.2 the letters are twice as heavy, and the thin strokes, the serif brackets and the bowls' counters follow.\n\nconst W = 64, H = 128, SH = 64, NL = 4096;\nconst { floor, round, min, max, sqrt, sin, cos, tan, acos, atan2, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The square. Each sheet is 64 rows; its square runs from LED centre\n// 2.5 to 61.5, so the outline sits on whole LEDs and the side is 59. Letters\n// are written in units of a tenth of the side (u right, v down, 0..10): one\n// unit is 5.9 LEDs, and at Stem 0.1 one unit is the thick stroke, the\n// proportion Dürer gives. The thin stroke is a third of the thick one, which\n// is how Alan Hoenig's METAFONT reading of the rules has it (TUGboat 11:3).\n// The centres of the bowls and the serif brackets are this pattern's own.\nconst S0 = 2.5, UN = 5.9;\nconst toX = (u) => S0 + u * UN;\n\n// Clip the infinite line through a and b to the square: a ruler line.\nfunction ruled(a, b) {\n  const d = [b[0] - a[0], b[1] - a[1]];\n  let t0 = -1e9, t1 = 1e9;\n  for (let k = 0; k \u003c 2; k++) {\n    if (abs(d[k]) \u003c 1e-9) continue;\n    const p = (0 - a[k]) / d[k], q = (10 - a[k]) / d[k];\n    t0 = max(t0, min(p, q));\n    t1 = min(t1, max(p, q));\n  }\n  return { k: 0, a: [a[0] + d[0] * t0, a[1] + d[1] * t0], b: [a[0] + d[0] * t1, a[1] + d[1] * t1] };\n}\n\n// ---- The capitals. Each is a union of convex polygons (k 0), rings (k 1:\n// inside one disk, outside its hole disks, on the right side of its clip\n// lines) and serif brackets (k 2: the kite between the corner, the two\n// tangent points and the compass centre, less the compass disk). Building a\n// letter also lists its construction: ruler lines (k 0) and compass arcs\n// (k 1), in the order they are drawn.\nfunction build(ch, w) {\n  const t = w / 3, r = 0.6 + 0.25 * w, P = [], G = [], ends = new Set();\n  const poly = (pts) => P.push({ k: 0, pts });\n  const edgeAt = (e, v) => e[0][0] + ((e[1][0] - e[0][0]) * (v - e[0][1])) / (e[1][1] - e[0][1]);\n  const hwOf = (dx, th) => (th / 2) * sqrt(dx * dx + 100) / 10;\n  // A straight stroke over the full height: centre ut on the cap line, ub on\n  // the base line, th thick across. Thick ones are ruled along both edges,\n  // thin ones along the middle.\n  const stroke = (ut, ub, th, v0 = 0, v1 = 10) => {\n    const hw = (th / 2) * sqrt((ub - ut) ** 2 + (v1 - v0) ** 2) / (v1 - v0);\n    const s = { L: [[ut - hw, v0], [ub - hw, v1]], R: [[ut + hw, v0], [ub + hw, v1]], c: [[ut, v0], [ub, v1]] };\n    poly([s.L[0], s.R[0], s.R[1], s.L[1]]);\n    if (th > 0.6 * w) G.push(ruled(s.L[0], s.L[1]), ruled(s.R[0], s.R[1]));\n    else G.push(ruled(s.c[0], s.c[1]));\n    return s;\n  };\n  // A horizontal thin bar, ruled along its middle.\n  const bar = (u0, u1, v0, v1) => {\n    poly([[u0, v0], [u1, v0], [u1, v1], [u0, v1]]);\n    G.push(ruled([0, (v0 + v1) / 2], [10, (v0 + v1) / 2]));\n  };\n  // A serif on stroke s: end 1 its foot on the base line, 0 its head on the\n  // cap line; sides 1 left, 2 right, 3 both. A thin bar runs along the line\n  // and a quarter-round bracket joins it to each edge. On a slanted stroke\n  // the acute side's bracket comes out longer, tangent length r / tan(half\n  // the angle).\n  const serif = (s, end, sides) => {\n    const vb = end ? s.L[1][1] : s.L[0][1], vq = end ? vb - t : vb + t;\n    let bl = max(edgeAt(s.L, vb), edgeAt(s.L, vq)), br = min(edgeAt(s.R, vb), edgeAt(s.R, vq));\n    for (let side = 0; side \u003c 2; side++) {\n      if (!(sides & (side + 1))) continue;\n      const e = side ? s.R : s.L, p = [edgeAt(e, vq), vq], d1 = [side ? 1 : -1, 0];\n      let d2 = end ? [e[0][0] - e[1][0], e[0][1] - e[1][1]] : [e[1][0] - e[0][0], e[1][1] - e[0][1]];\n      const n = Math.hypot(d2[0], d2[1]);\n      d2 = [d2[0] / n, d2[1] / n];\n      // A very acute corner would throw the bracket far out, so its\n      // tangent length stops at 1.9 units and the radius shrinks to match.\n      const h = acos(cl(d1[0] * d2[0] + d1[1] * d2[1], -1, 1)) / 2, tl = min(r / tan(h), 1.9), rr = tl * tan(h), pc = tl / cos(h);\n      const bx = d1[0] + d2[0], by = d1[1] + d2[1], bn = Math.hypot(bx, by);\n      const c = [p[0] + (bx / bn) * pc, p[1] + (by / bn) * pc], T1 = [p[0] + d1[0] * tl, p[1]], T2 = [p[0] + d2[0] * tl, p[1] + d2[1] * tl];\n      P.push({ k: 2, kite: [p, T1, c, T2], c, r: rr });\n      const a1 = atan2(T1[1] - c[1], T1[0] - c[0]);\n      let da = atan2(T2[1] - c[1], T2[0] - c[0]) - a1;\n      da -= 2 * PI * round(da / (2 * PI));\n      G.push({ k: 1, c, r: rr, a0: a1, a1: a1 + da });\n      if (side) br = T1[0];\n      else bl = T1[0];\n    }\n    poly([[bl, min(vb, vq)], [br, min(vb, vq)], [br, max(vb, vq)], [bl, max(vb, vq)]]);\n    ends.add(end);\n  };\n  const circ = (c, R) => G.push({ k: 1, c, r: R, a0: -PI / 2, a1: 1.5 * PI });\n  // The O and the C: a disk of radius 5 less two disks of radius 5 - w whose\n  // centres sit w - t either side of the middle along an axis leaning 20\n  // degrees to the left, so the ring is t thick at 11 and 5 o'clock and w\n  // thick at 2 and 8.\n  const ring = (clip) => {\n    const e = w - t, ax = [-sin(0.35), -cos(0.35)], h1 = [5 + ax[0] * e, 5 + ax[1] * e, 5 - w], h2 = [5 - ax[0] * e, 5 - ax[1] * e, 5 - w];\n    P.push({ k: 1, o: [5, 5, 5], h: [h1, h2], clip });\n    G.push(ruled([5 - ax[0] * 5, 5 - ax[1] * 5], [5 + ax[0] * 5, 5 + ax[1] * 5]));\n    circ([5, 5], 5), circ([h1[0], h1[1]], h1[2]), circ([h2[0], h2[1]], h2[2]);\n  };\n  let s, s2;\n  switch (ch) {\n    case \"A\": {\n      const kt = 5.2, kh = hwOf(3.2, w), ut = kt - kh + hwOf(-3.4, t);\n      s2 = stroke(ut, 1.6, t), s = stroke(kt, 8.4, w);\n      const v0 = 6.3, v1 = 6.3 + t, at = (e, v) => edgeAt(e, v);\n      poly([[at(s2.c, v0), v0], [at(s.c, v0), v0], [at(s.c, v1), v1], [at(s2.c, v1), v1]]);\n      G.push(ruled([0, v0 + t / 2], [10, v0 + t / 2]));\n      serif(s2, 1, 3), serif(s, 1, 3);\n      break;\n    }\n    case \"C\":\n      ring([[-1, 0, 8.6]]);\n      break;\n    case \"D\": {\n      s = stroke(1.4 + w / 2, 1.4 + w / 2, w);\n      const c = 4.4, hc = 9.4 - w - (5 - t);\n      bar(1.4 + w, c, 0, t), bar(1.4 + w, c, 10 - t, 10);\n      P.push({ k: 1, o: [c, 5, 5], h: [[hc, 5, 5 - t]], clip: [[1, 0, -c]] });\n      circ([c, 5], 5), circ([hc, 5], 5 - t);\n      serif(s, 0, 1), serif(s, 1, 1);\n      break;\n    }\n    case \"E\": {\n      const x = 1.6 + w;\n      s = stroke(1.6 + w / 2, 1.6 + w / 2, w);\n      bar(x, 8.2, 0, t), bar(x, 7.4, 4.85 - t / 2, 4.85 + t / 2), bar(x, 8.6, 10 - t, 10);\n      poly([[8.2 - t, 0], [8.2, 0], [8.2, 1.8], [8.2 - t, 1.8]]);\n      poly([[7.4 - t, 4.15], [7.4, 4.15], [7.4, 5.55], [7.4 - t, 5.55]]);\n      poly([[8.6 - t, 8.2], [8.6, 8.2], [8.6, 10], [8.6 - t, 10]]);\n      serif(s, 0, 1), serif(s, 1, 1);\n      break;\n    }\n    case \"H\":\n      s = stroke(1.5 + w / 2, 1.5 + w / 2, w), s2 = stroke(8.5 - w / 2, 8.5 - w / 2, w);\n      bar(1.5 + w, 8.5 - w, 4.7, 4.7 + t);\n      serif(s, 0, 3), serif(s, 1, 3), serif(s2, 0, 3), serif(s2, 1, 3);\n      break;\n    case \"I\":\n      s = stroke(5, 5, w);\n      serif(s, 0, 3), serif(s, 1, 3);\n      break;\n    case \"L\":\n      s = stroke(1.8 + w / 2, 1.8 + w / 2, w);\n      bar(1.8 + w, 8.6, 10 - t, 10);\n      poly([[8.6 - t, 8.0], [8.6, 8.0], [8.6, 10], [8.6 - t, 10]]);\n      serif(s, 0, 3), serif(s, 1, 1);\n      break;\n    case \"M\": {\n      s = stroke(1.6, 1.2, t);\n      stroke(2.0, 5.0, w), stroke(8.0, 5.0, t);\n      s2 = stroke(8.4, 8.8, w);\n      serif(s, 1, 3), serif(s2, 1, 3), serif(s, 0, 1), serif(s2, 0, 2);\n      break;\n    }\n    case \"N\": {\n      s = stroke(1.6, 1.6, t), s2 = stroke(8.4, 8.4, t);\n      const hk = hwOf(6, w);\n      stroke(1.6 - t / 2 + hk, 8.4 + t / 2 - hk, w);\n      serif(s, 1, 3), serif(s, 0, 1), serif(s2, 0, 3);\n      break;\n    }\n    case \"O\":\n      ring([]);\n      break;\n    case \"T\":\n      bar(0.9, 9.1, 0, t);\n      poly([[0.9, 0], [0.9 + t, 0], [0.9 + t, 1.8], [0.9, 1.8]]);\n      poly([[9.1 - t, 0], [9.1, 0], [9.1, 1.8], [9.1 - t, 1.8]]);\n      s = stroke(5, 5, w, t, 10);\n      serif(s, 1, 3);\n      break;\n    case \"V\": {\n      const kb = 4.8, hk = hwOf(2.9, w);\n      s = stroke(1.9, kb, w), s2 = stroke(8.1, kb + hk - hwOf(-3.3, t), t);\n      serif(s, 0, 3), serif(s2, 0, 3);\n      break;\n    }\n    case \"X\":\n      s = stroke(2.0, 8.0, w), s2 = stroke(7.6, 2.4, t);\n      serif(s, 0, 3), serif(s, 1, 3), serif(s2, 0, 3), serif(s2, 1, 3);\n      break;\n  }\n  // The serif heights are ruled first, right across the square.\n  const pre = [];\n  if (ends.has(0)) pre.push(ruled([0, t], [10, t]));\n  if (ends.has(1)) pre.push(ruled([0, 10 - t], [10, 10 - t]));\n  return { P, G: pre.concat(G) };\n}\n\n// Each piece becomes a box, a list of half-planes a u + b v + c >= 0, a disk\n// it must be in, and disks it must stay out of.\nfunction compile(P) {\n  const half = (pts) => {\n    let area = 0;\n    for (let i = 0; i \u003c pts.length; i++) {\n      const a = pts[i], b = pts[(i + 1) % pts.length];\n      area += a[0] * b[1] - b[0] * a[1];\n    }\n    const sg = area > 0 ? 1 : -1, hp = [];\n    for (let i = 0; i \u003c pts.length; i++) {\n      const a = pts[i], b = pts[(i + 1) % pts.length], du = b[0] - a[0], dv = b[1] - a[1];\n      hp.push(-dv * sg, du * sg, (dv * a[0] - du * a[1]) * sg);\n    }\n    return hp;\n  };\n  return P.map((q) => {\n    let pts = q.pts || q.kite, o = null, out = [];\n    if (q.k === 1) {\n      pts = [[q.o[0] - q.o[2], q.o[1] - q.o[2]], [q.o[0] + q.o[2], q.o[1] + q.o[2]]];\n      o = [q.o[0], q.o[1], q.o[2] ** 2];\n      out = q.h.map((h) => [h[0], h[1], h[2] ** 2]);\n    } else if (q.k === 2) out = [[q.c[0], q.c[1], q.r * q.r]];\n    const us = pts.map((p) => p[0]), vs = pts.map((p) => p[1]);\n    let hp = q.k === 1 ? [] : half(pts);\n    if (q.k === 1) for (const c of q.clip) hp.push(c[0], c[1], c[2]);\n    return { u0: min(...us), u1: max(...us), v0: min(...vs), v1: max(...vs), hp, o, out };\n  });\n}\n\nfunction inside(Q, u, v) {\n  next: for (const q of Q) {\n    if (u \u003c q.u0 || u > q.u1 || v \u003c q.v0 || v > q.v1) continue;\n    const hp = q.hp;\n    for (let i = 0; i \u003c hp.length; i += 3) if (hp[i] * u + hp[i + 1] * v + hp[i + 2] \u003c -1e-12) continue next;\n    if (q.o && (u - q.o[0]) ** 2 + (v - q.o[1]) ** 2 > q.o[2]) continue;\n    for (const h of q.out) if ((u - h[0]) ** 2 + (v - h[1]) ** 2 \u003c h[2]) continue next;\n    return true;\n  }\n  return false;\n}\n\n// Distance in 1 and 1.414 steps over the 64 x 64 sheet, from every LED\n// already at 0. With a mask it only walks inside the mask, a geodesic:\n// Dijkstra with a binary heap.\nconst STEPS = [[1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1], [1, 1, 1.414], [-1, 1, 1.414], [1, -1, 1.414], [-1, -1, 1.414]];\nfunction distance(d, mask) {\n  const heap = [], key = (i) => d[heap[i]];\n  const push = (p) => {\n    heap.push(p);\n    for (let i = heap.length - 1; i > 0; ) {\n      const j = (i - 1) >> 1;\n      if (key(j) \u003c= key(i)) break;\n      const tmp = heap[i];\n      heap[i] = heap[j], heap[j] = tmp, i = j;\n    }\n  };\n  const pop = () => {\n    const top = heap[0], last = heap.pop();\n    if (heap.length) {\n      heap[0] = last;\n      for (let i = 0; ; ) {\n        const a = 2 * i + 1, b = a + 1;\n        let m = i;\n        if (a \u003c heap.length && key(a) \u003c key(m)) m = a;\n        if (b \u003c heap.length && key(b) \u003c key(m)) m = b;\n        if (m === i) break;\n        const tmp = heap[i];\n        heap[i] = heap[m], heap[m] = tmp, i = m;\n      }\n    }\n    return top;\n  };\n  const done = new Uint8Array(NL);\n  for (let p = 0; p \u003c NL; p++) if (d[p] === 0) push(p);\n  while (heap.length) {\n    const p = pop();\n    if (done[p]) continue;\n    done[p] = 1;\n    const x = p & 63, y = p >> 6;\n    for (let k = 0; k \u003c 8; k++) {\n      const xx = x + STEPS[k][0], yy = y + STEPS[k][1], c = STEPS[k][2];\n      if (xx \u003c 0 || yy \u003c 0 || xx > 63 || yy > 63) continue;\n      const q = yy * 64 + xx;\n      if ((mask && !mask[q]) || d[p] + c >= d[q]) continue;\n      d[q] = d[p] + c;\n      push(q);\n    }\n  }\n}\n\n// ---- One letter on a 64 x 64 sheet: ink coverage from 4 x 4 samples an\n// LED, when the ink reaches each LED (geodesic from the top left of the\n// body, 0..1), when the paper lights (by distance from the letter, 0..1),\n// and the construction lines with the moment the pen passes each LED.\n// A letter is worked out the first time it is needed, 5 to 10 ms in Node\n// once warm, and kept until Stem moves; the first frame works out two.\nconst SEQ = \"ACDEHILMNOTVX\";\nfunction letter(ch, w) {\n  const { P, G } = build(ch, w), Q = compile(P);\n  const cov = new Float32Array(NL), mask = new Uint8Array(NL);\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c 64; x++) {\n      let n = 0;\n      for (let j = 0; j \u003c 4; j++)\n        for (let i = 0; i \u003c 4; i++) if (inside(Q, (x + (i + 0.5) / 4 - S0) / UN, (y + (j + 0.5) / 4 - S0) / UN)) n++;\n      cov[y * 64 + x] = n / 16;\n      mask[y * 64 + x] = n >= 6 ? 1 : 0;\n    }\n  // Ink: from the masked LED nearest the top left.\n  const fill = new Float32Array(NL).fill(1e9);\n  let seed = -1, best = 1e9;\n  for (let p = 0; p \u003c NL; p++) if (mask[p] && (p >> 6) + 0.5 * (p & 63) \u003c best) (best = (p >> 6) + 0.5 * (p & 63)), (seed = p);\n  fill[seed] = 0;\n  distance(fill, mask);\n  let fm = 0;\n  for (let p = 0; p \u003c NL; p++) if (mask[p] && fill[p] > fm) fm = fill[p];\n  for (let p = 0; p \u003c NL; p++) {\n    if (!cov[p] || mask[p]) continue;\n    const x = p & 63, y = p >> 6;\n    let b = 1e9;\n    for (let j = -1; j \u003c= 1; j++) for (let i = -1; i \u003c= 1; i++) if (x + i >= 0 && x + i \u003c 64 && y + j >= 0 && y + j \u003c 64 && mask[(y + j) * 64 + x + i]) b = min(b, fill[(y + j) * 64 + x + i] + 1);\n    fill[p] = b;\n  }\n  for (let p = 0; p \u003c NL; p++) fill[p] = cov[p] ? min(1, fill[p] / (fm + 1)) : 1;\n  // Paper: distance from the body.\n  const gd = new Float32Array(NL);\n  for (let p = 0; p \u003c NL; p++) gd[p] = mask[p] ? 0 : 1e9;\n  distance(gd, null);\n  let gm = 0;\n  for (let p = 0; p \u003c NL; p++) if (inPaper(p) && gd[p] > gm) gm = gd[p];\n  for (let p = 0; p \u003c NL; p++) gd[p] = min(1, gd[p] / gm);\n  // Construction: each element gets a share of the 4 s of 0.6 plus its\n  // length over 2.5 units, so the O's outer circle takes 1.35 s at Speed 2.\n  let tot = 0;\n  const len = G.map((g) => (g.k ? g.r * abs(g.a1 - g.a0) : Math.hypot(g.b[0] - g.a[0], g.b[1] - g.a[1])));\n  len.forEach((l) => (tot += 0.6 + l / 2.5));\n  const gw = new Float32Array(NL), gt = new Float32Array(NL).fill(2);\n  let acc = 0;\n  G.forEach((g, i) => {\n    g.t0 = acc / tot;\n    acc += 0.6 + len[i] / 2.5;\n    g.t1 = acc / tot;\n    const n = max(2, round((len[i] * UN) / 0.3));\n    for (let k = 0; k \u003c= n; k++) {\n      const tt = g.t0 + ((g.t1 - g.t0) * k) / n;\n      splat(at(g, k / n), (q, wt) => {\n        if (wt \u003c 0.05) return;\n        if (wt > gw[q]) gw[q] = wt;\n        if (tt \u003c gt[q]) gt[q] = tt;\n      });\n    }\n  });\n  return { cov, fill, gd, gw, gt, G };\n}\n\n// Where element g is at s (0..1), in sheet LEDs.\nfunction at(g, s) {\n  if (g.k === 0) return [toX(g.a[0] + (g.b[0] - g.a[0]) * s), toX(g.a[1] + (g.b[1] - g.a[1]) * s)];\n  const a = g.a0 + (g.a1 - g.a0) * s;\n  return [toX(g.c[0] + g.r * cos(a)), toX(g.c[1] + g.r * sin(a))];\n}\n\n// A point split over its four nearest LEDs of the sheet, by area.\nfunction splat([px, py], f) {\n  const fx = px - 0.5, fy = py - 0.5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i, yy = iy + j;\n      if (xx >= 0 && yy >= 0 && xx \u003c 64 && yy \u003c 64) f(yy * 64 + xx, (i ? ax : 1 - ax) * (j ? ay : 1 - ay));\n    }\n}\n\n// The paper: LEDs 2..61 of the sheet, the square and its outline.\nconst inPaper = (p) => (p & 63) >= 2 && (p & 63) \u003c= 61 && p >> 6 >= 2 && p >> 6 \u003c= 61;\n\n// Paper grain: value noise on a 5 LED lattice, 0.75..1.25, the same under\n// every letter.\nconst GRAIN = new Float32Array(NL);\n{\n  const hs = (x, y) => {\n    let h = (x * 374761393 + y * 668265263) >>> 0;\n    h = Math.imul(h ^ (h >>> 13), 1274126177) >>> 0;\n    return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n  };\n  for (let p = 0; p \u003c NL; p++) {\n    const fx = (p & 63) / 5, fy = (p >> 6) / 5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n    const a = hs(ix, iy), b = hs(ix + 1, iy), c = hs(ix, iy + 1), d = hs(ix + 1, iy + 1);\n    GRAIN[p] = 0.75 + 0.5 * ((a + (b - a) * ax) * (1 - ay) + (c + (d - c) * ax) * ay);\n  }\n}\n\n// The frame every sheet keeps: the square and its two diagonals.\nconst FRAME = new Float32Array(NL);\nfor (const g of [ruled([0, 0], [10, 0]), ruled([0, 0], [0, 10]), ruled([10, 0], [10, 10]), ruled([0, 10], [10, 10]), ruled([0, 0], [10, 10]), ruled([10, 0], [0, 10])]) {\n  const n = round((Math.hypot(g.b[0] - g.a[0], g.b[1] - g.a[1]) * UN) / 0.3);\n  for (let k = 0; k \u003c= n; k++) splat(at(g, k / n), (q, wt) => (FRAME[q] = max(FRAME[q], wt)));\n}\n\n// ---- Time, in seconds at Speed 2. A letter's turn is 8 s in one sheet:\n// the old plate there goes dark in 0.8 s, from the paper's edge in to the\n// letter; 4 s of construction; the ink runs 1.6 s; the paper lights in 1 s.\n// Turns alternate between the sheets, so a finished plate stands through\n// the other sheet's whole turn. A fresh start is 2.2 s into turn 1, the\n// lower sheet, with turn 0's letter standing finished in the upper one, so\n// at Speed 2 the ink and paper of the lower plate (2.6..5.2 s) and the\n// darkening of the upper (5.8..6.6 s) both fall in the study's 2..8 s, and\n// almost every LED that changes there changes once: the study measures\n// drift 0.247 at motion 0.048, and motion over those 6 s adds up to only\n// 1.17 times the drift.\nconst TURN = 8, ER = 0.8, CN = 4, F0 = 4.8, FN = 1.6, G0 = 6.4, GN = 1, START = TURN + 2.2;\nconst L_FRAME = 0.2, L_GUIDE = 0.42, L_PAPER = 0.17;\n\nexport function setup(params) {\n  params.s = { tau: START, hue: 0, first: 0, w: 1, cache: {}, rgb: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.tau += (d * cl(k[1], 0.2, 3)) / 2;\n  S.first = cl(round(k[2]), 0, 12);\n  const w = round(cl(k[3], 0.1, 0.2) * 400) / 40;\n  if (w !== S.w) (S.w = w), (S.cache = {});\n}\n\nfunction get(S, n) {\n  if (n \u003c 0) return null;\n  const ch = SEQ[(S.first + n) % SEQ.length];\n  return S.cache[ch] || (S.cache[ch] = letter(ch, S.w));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, h = S.hue;\n  const ink = hsv(0.11 + h, 0.3, 1), line = hsv(0.5 + h, 0.55, 1), paper = hsv(0.62 + h, 0.75, 1), frame = hsv(0.56 + h, 0.35, 1), pen = hsv(0.13 + h, 0.15, 1);\n  rgb.fill(0);\n  const n = floor(S.tau / TURN);\n  for (let sh = 0; sh \u003c 2; sh++) {\n    const oy = sh * SH * W;\n    // Which letter this sheet shows and how far along it is.\n    let L, ph, erase = 0;\n    if (n % 2 === sh) {\n      ph = S.tau - n * TURN;\n      if (ph \u003c ER) (L = get(S, n - 2)), (erase = ph / ER), (ph = TURN);\n      else L = get(S, n);\n    } else (L = get(S, n - 1)), (ph = TURN);\n    const cp = (ph - ER) / CN, fp = (ph - F0) / FN, gp = (ph - G0) / GN;\n    for (let p = 0; p \u003c NL; p++) {\n      const o = (oy + p) * 3;\n      let r = FRAME[p] * L_FRAME * frame[0], g = FRAME[p] * L_FRAME * frame[1], b = FRAME[p] * L_FRAME * frame[2];\n      if (L) {\n        // Erasing goes from the paper's edge in: far paper first, the letter last.\n        const keep = erase ? 1 - cl((erase - (1 - L.gd[p]) * 0.6) / 0.4, 0, 1) : 1;\n        if (keep > 0) {\n          const gl = L.gw[p] ? L.gw[p] * cl((cp - L.gt[p]) * CN * 20, 0, 1) * L_GUIDE : 0;\n          const pa = inPaper(p) ? cl((gp - L.gd[p] * 0.75) / 0.25, 0, 1) * L_PAPER * GRAIN[p] : 0;\n          const a = L.cov[p] ? L.cov[p] * cl((fp - L.fill[p] * 0.85) / 0.15, 0, 1) : 0;\n          r = ((1 - a) * (r + gl * line[0] + pa * paper[0]) + a * ink[0]) * keep + r * (1 - keep);\n          g = ((1 - a) * (g + gl * line[1] + pa * paper[1]) + a * ink[1]) * keep + g * (1 - keep);\n          b = ((1 - a) * (b + gl * line[2] + pa * paper[2]) + a * ink[2]) * keep + b * (1 - keep);\n        }\n      }\n      rgb[o] = r, rgb[o + 1] = g, rgb[o + 2] = b;\n    }\n    // The pen, while the construction is being drawn: a bright point at the\n    // tip and, for an arc, the compass needle in its centre.\n    if (L && !erase && cp > 0 && cp \u003c 1) {\n      const e = L.G.find((q) => cp >= q.t0 && cp \u003c q.t1);\n      if (e) {\n        const s = (cp - e.t0) / (e.t1 - e.t0), [px, py] = at(e, s);\n        dot(rgb, px, py + sh * SH, 1, pen);\n        if (e.k === 1 && e.r > 1.5) dot(rgb, toX(e.c[0]), toX(e.c[1]) + sh * SH, 0.55, pen);\n      }\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p & 63, p >> 6, min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n\n// A point of light split over the four nearest LEDs, with a faint ring.\nfunction dot(rgb, x, y, a, c) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  for (let j = -1; j \u003c= 2; j++)\n    for (let i = -1; i \u003c= 2; i++) {\n      const xx = ix + i, yy = iy + j;\n      if (xx \u003c 0 || yy \u003c 0 || xx >= W || yy >= H) continue;\n      const wx = i === 0 ? 1 - ax : i === 1 ? ax : 0, wy = j === 0 ? 1 - ay : j === 1 ? ay : 0;\n      const v = a * (wx * wy + 0.12);\n      const o = (yy * W + xx) * 3;\n      rgb[o] += c[0] * v, rgb[o + 1] += c[1] * v, rgb[o + 2] += c[2] * v;\n    }\n}\n","ehrenfest-urn":"// ===== Patternflow pattern =====\n// Title:   Ehrenfest Urn\n// Family:  particle\n// Idea:    N balls start in the upper of two chambers stacked down the panel and joined by a narrow neck, and every step one ball chosen at random darts through the neck to the other side, while a strip at the foot traces the count in the upper chamber falling from N to N/2 along its expected curve and then hovering inside the binomial spread, with the time spent at each count piling up beside it into the binomial bell, and the chambers flash each time the count comes back to the state the fourth knob watches.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ehrenfest urn model (Paul and Tatjana Ehrenfest, 1907), its mean recurrence times (Mark Kac, 1947), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Balls=8..200, Watch=0..1\n//\n// Knob 1: Hue. Turns the two chambers' colours round the wheel together, nearly half a wheel apart: at 0 the balls in the upper chamber are gold and those in the lower one azure, and a ball changes colour as it goes through the neck.\n// Knob 2: Speed. Steps a second, 5 times Speed times the square root of N / 8: 10 at 2 with 8 balls, so the all-up state, 256 steps apart on average, comes back about every 26 s; 50 at 2 with 200 balls. A step's flight takes 1.8 steps' time, between 0.12 and 0.5 s.\n// Knob 3: Balls. N, 8 to 200. Turning it starts again with every ball in the upper chamber. At 8 the count drops to 4 within a second and swings by 1.4 either side; at 200 the distance to 100 halves every 69 steps, 1.4 s at Speed 2, and the count swings by 7, and the all-up state would take 2^200 steps to come back.\n// Knob 4: Watch. Which count the flash watches, from N (every ball up, the start) below 0.08 down to N/2 at 1. Kac's mean return time to count k is 2^N / C(N, k) steps: 256 for k = 8 of 8, 9.1 for k = 6 and 3.7 for k = 4, so the flash goes from rare to nearly every step. A dotted line on the trace marks the count, and a tick above the trace each visit.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, exp, abs, pow, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The vessel. Two rounded chambers 62 by 44 LEDs, the upper from row 1\n// to 44 and the lower from 51 to 94, joined by a neck 6 LEDs wide (x 29 to\n// 34) and 6 rows long. The trace takes rows 96 to 126.\nconst CH = [\n  { x0: 1, y0: 51, x1: 62, y1: 94 }, // side 0: lower\n  { x0: 1, y0: 1, x1: 62, y1: 44 }, // side 1: upper\n];\nconst NX0 = 29, NX1 = 34, NECK = 31.5;\nconst MOUTH = [52.5, 43.5]; // the row a ball passes as it leaves each chamber\n\n// Wall brightness 0..1 per LED: the outline of each rounded rectangle (corner\n// radius 5), open where the neck meets it, and the neck's two sides.\nconst WALL = new Float32Array(NP);\nfunction rrect(px, py, c) {\n  const r = 5, cx = (c.x0 + c.x1) / 2, cy = (c.y0 + c.y1) / 2, hx = (c.x1 - c.x0) / 2 - r, hy = (c.y1 - c.y0) / 2 - r;\n  const qx = abs(px - cx) - hx, qy = abs(py - cy) - hy;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n}\nfor (let y = 0; y \u003c 96; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const px = x, py = y;\n    let v = 0;\n    for (const c of CH) v = max(v, 1 - abs(rrect(px, py, c)));\n    if (x >= NX0 && x \u003c= NX1 && y >= 43 && y \u003c= 52) v = 0;\n    if ((x === NX0 - 1 || x === NX1 + 1) && y >= 44 && y \u003c= 51) v = 1;\n    WALL[y * W + x] = cl(v, 0, 1);\n  }\n// The LEDs inside either chamber or the neck.\nconst INSIDE = new Uint8Array(NP);\nfor (let y = 0; y \u003c 96; y++)\n  for (let x = 0; x \u003c W; x++)\n    INSIDE[y * W + x] = WALL[y * W + x] \u003c= 0 && (rrect(x, y, CH[0]) \u003c 0 || rrect(x, y, CH[1]) \u003c 0 || (x >= NX0 && x \u003c= NX1 && y > 44 && y \u003c 51)) ? 1 : 0;\n\n// ---- The trace. Count n of N maps to row TY1 - n / N * (TY1 - TY0): all up\n// on row 99, none up on row 126. 52 columns of history (x 0 to 51), then a\n// gap, then the time spent at each count as bars from x 54 to 63.\nconst TY0 = 99, TY1 = 126, TCOLS = 52, HX = 54, HW = 10, RUG = 97;\nconst rowOf = (n, N) => TY1 - (n / N) * (TY1 - TY0);\n\n// log C(N, k), for the binomial law the count settles to: C(N, k) / 2^N.\nfunction logC(N, k) {\n  let s = 0;\n  for (let i = 1; i \u003c= k; i++) s += log(N - k + i) - log(i);\n  return s;\n}\n\nfunction gauss() {\n  // Box-Muller from the seeded Math.random.\n  const u = 1 - Math.random(), v = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * v);\n}\n\nfunction reset(S, N) {\n  S.N = N;\n  S.n = N;\n  S.x = new Float32Array(N), S.y = new Float32Array(N), S.vx = new Float32Array(N), S.vy = new Float32Array(N);\n  S.side = new Uint8Array(N).fill(1);\n  // A flight: start time, length, and the four points start, mouth, other mouth, end.\n  S.ft = new Float32Array(N).fill(-1), S.fd = new Float32Array(N), S.fp = new Float32Array(N * 8);\n  const c = CH[1];\n  for (let i = 0; i \u003c N; i++) {\n    S.x[i] = c.x0 + 4 + Math.random() * (c.x1 - c.x0 - 8);\n    S.y[i] = c.y0 + 4 + Math.random() * (c.y1 - c.y0 - 8);\n  }\n  // Radius 3.3 at N = 8, 1.25 at 200.\n  S.r = 3.3 * pow(8 / N, 0.3);\n  // Steps per trace column: 2 at N = 8, 10 at N = 200, so the 52 columns\n  // hold 104 and 520 steps, a little over 5 relaxation times at 200.\n  S.per = max(1, round(2 * sqrt(N / 8)));\n  S.cols = [];\n  S.cur = { mn: N, mx: N, last: N, hit: 1, g: 0 };\n  S.steps = 0;\n  S.g = 0;\n  S.time = new Float64Array(N + 1);\n  S.time[N] = 1;\n  // The law the count settles to, C(N, k) / 2^N, summed into trace rows.\n  S.law = new Float64Array(H);\n  const l2 = N * log(2);\n  for (let k = 0; k \u003c= N; k++) S.law[round(rowOf(k, N))] += exp(logC(N, k) - l2);\n  S.lawMax = 0;\n  for (let y = TY0; y \u003c= TY1; y++) S.lawMax = max(S.lawMax, S.law[y]);\n  S.flash = 1;\n}\n\nfunction step(S) {\n  const N = S.N, i = floor(Math.random() * N);\n  const from = S.side[i], to = 1 - from;\n  S.side[i] = to;\n  S.n += to ? 1 : -1;\n  // Fly from wherever the ball is now through the neck to a random place in\n  // the other chamber. A ball still flying that has not yet passed the\n  // middle of the neck turns round inside the chamber it is in.\n  const p = ballAt(S, i, S.clock), c = CH[to], ox = NECK + (Math.random() - 0.5) * (NX1 - NX0 - 1.5);\n  const f = S.fp, o = i * 8, here = p[1] \u003c 48 ? 1 : 0;\n  f[o] = p[0], f[o + 1] = p[1];\n  if (here === to) (f[o + 2] = f[o + 4] = p[0]), (f[o + 3] = f[o + 5] = p[1]);\n  else (f[o + 2] = f[o + 4] = ox), (f[o + 3] = MOUTH[here]), (f[o + 5] = MOUTH[to]);\n  f[o + 6] = c.x0 + 4 + Math.random() * (c.x1 - c.x0 - 8);\n  f[o + 7] = c.y0 + 4 + Math.random() * (c.y1 - c.y0 - 8);\n  S.ft[i] = S.clock;\n  S.fd[i] = S.fly;\n  // The trace and the clock of counts.\n  const cur = S.cur, n = S.n;\n  cur.mn = min(cur.mn, n), cur.mx = max(cur.mx, n), cur.last = n;\n  S.time[n]++;\n  if (n === S.kw) (cur.hit = 1), (S.flash = 1);\n  S.steps++;\n  if (S.steps % S.per === 0) {\n    S.cols.push(cur);\n    if (S.cols.length > TCOLS - 1) S.cols.shift();\n    S.g++;\n    S.cur = { mn: n, mx: n, last: n, hit: 0, g: S.g };\n  }\n}\n\n// Where ball i is drawn at time `at`: on its flight path, or resting in its chamber.\nfunction ballAt(S, i, at) {\n  const t0 = S.ft[i];\n  if (t0 \u003c 0) return [S.x[i], S.y[i], -1];\n  const u = cl((at - t0) / S.fd[i], 0, 1), e = u * u * (3 - 2 * u), f = S.fp, o = i * 8;\n  const l1 = sqrt((f[o + 2] - f[o]) ** 2 + (f[o + 3] - f[o + 1]) ** 2), l2 = abs(f[o + 5] - f[o + 3]);\n  const l3 = sqrt((f[o + 6] - f[o + 4]) ** 2 + (f[o + 7] - f[o + 5]) ** 2), L = l1 + l2 + l3;\n  let d = e * L, k = 0;\n  if (d > l1) (d -= l1), (k = 2);\n  if (k === 2 && d > l2) (d -= l2), (k = 4);\n  const seg = k === 0 ? l1 : k === 2 ? l2 : l3, a = seg > 0 ? d / seg : 1;\n  // The third value says how far through the neck it is, 0 before, 1 after\n  // (and 1 all along for a ball turning round on its own side).\n  const thr = l1 + l2 === 0 || k === 4 ? 1 : k === 2 ? a : 0;\n  return [f[o + k] + (f[o + k + 2] - f[o + k]) * a, f[o + k + 1] + (f[o + k + 3] - f[o + k + 1]) * a, thr, u];\n}\n\nexport function setup(params) {\n  params.s = { clock: 0, acc: 0.6, hue: 0, rate: 10, fly: 0.18, kw: 8, rgb: new Float32Array(NP * 3) };\n  reset(params.s, 8);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), N = cl(round(k[2]), 8, 200), w = cl(k[3], 0, 1);\n  if (N !== S.N) reset(S, N);\n  S.kw = N - round((max(0, w - 0.08) / 0.92) * (N / 2));\n  S.rate = 5 * speed * sqrt(N / 8);\n  S.fly = cl(1.8 / S.rate, 0.12, 0.5);\n  S.clock += d;\n  S.flash *= exp(-d / 0.3);\n  // A gentle jiggle for every ball at rest: velocities relax in 0.6 s and\n  // run at about 5 LEDs a second, and the walls turn them back.\n  const sig = 9.1 * sqrt(d), r = S.r;\n  for (let i = 0; i \u003c N; i++) {\n    if (S.ft[i] >= 0) {\n      if (S.clock - S.ft[i] \u003c S.fd[i]) continue;\n      // Landed: rest where the flight ended.\n      S.x[i] = S.fp[i * 8 + 6], S.y[i] = S.fp[i * 8 + 7], S.ft[i] = -1;\n    }\n    S.vx[i] += -S.vx[i] * (d / 0.6) + sig * gauss();\n    S.vy[i] += -S.vy[i] * (d / 0.6) + sig * gauss();\n    S.x[i] += S.vx[i] * d, S.y[i] += S.vy[i] * d;\n    const c = CH[S.side[i]], a0 = c.x0 + 1.5 + r, a1 = c.x1 - 1.5 - r, b0 = c.y0 + 1.5 + r, b1 = c.y1 - 1.5 - r;\n    if (S.x[i] \u003c a0) (S.x[i] = a0), (S.vx[i] = abs(S.vx[i]));\n    if (S.x[i] > a1) (S.x[i] = a1), (S.vx[i] = -abs(S.vx[i]));\n    if (S.y[i] \u003c b0) (S.y[i] = b0), (S.vy[i] = abs(S.vy[i]));\n    if (S.y[i] > b1) (S.y[i] = b1), (S.vy[i] = -abs(S.vy[i]));\n  }\n  S.acc += d * S.rate;\n  for (let s = 0; s \u003c 40 && S.acc >= 1; s++) (S.acc -= 1), step(S);\n}\n\n// A ball: a disc of radius r with a brighter middle and a halo that falls\n// from a fifth of its brightness at the rim to nothing a radius and a half out.\nfunction disc(rgb, x, y, r, c, a) {\n  const R = 2.5 * r + 1;\n  for (let j = max(0, floor(y - R)); j \u003c= min(H - 1, floor(y + R)); j++)\n    for (let i = max(0, floor(x - R)); i \u003c= min(W - 1, floor(x + R)); i++) {\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, dd = sqrt(dx * dx + dy * dy);\n      const core = cl(r + 0.5 - dd, 0, 1) * (1 + 0.5 * exp(-(dd * dd) / (0.3 * r * r)));\n      const v = a * max(core, 0.2 * cl(1 - (dd - r) / (1.5 * r), 0, 1) ** 2);\n      if (v \u003c= 0.5) continue;\n      const o = (j * W + i) * 3;\n      rgb[o] += c[0] * v, rgb[o + 1] += c[1] * v, rgb[o + 2] += c[2] * v;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, N } = S;\n  const hT = 0.12 + S.hue, hB = hT + 0.45;\n  // Walls, band and mean line are only tinted (saturation 0.2 to 0.3): at Hue 0.5\n  // the lower colour is orange, and a dim orange would read brown.\n  const up = hsv(hT, 0.78, 1), lo = hsv(hB, 0.78, 1), pale = hsv(hT, 0.12, 1), band = hsv(hB, 0.3, 1);\n  rgb.fill(0);\n\n  // ---- Walls, flashing white on a visit to the watched count, and the\n  // inside of both chambers lit to 40 with them.\n  const fl = S.flash, wc = hsv(hB, 0.2 * (1 - fl), 1), wv = 62 + 170 * fl, fv = 40 * fl;\n  for (let p = 0; p \u003c 96 * W; p++) {\n    const v = WALL[p];\n    if (v > 0) rgb[p * 3] = wc[0] * wv * v, rgb[p * 3 + 1] = wc[1] * wv * v, rgb[p * 3 + 2] = wc[2] * wv * v;\n    else if (fv > 1 && INSIDE[p]) rgb[p * 3] = pale[0] * fv, rgb[p * 3 + 1] = pale[1] * fv, rgb[p * 3 + 2] = pale[2] * fv;\n  }\n  // ---- Balls.\n  const r = S.r;\n  for (let i = 0; i \u003c N; i++) {\n    const b = ballAt(S, i, S.clock);\n    if (b[2] \u003c 0) {\n      disc(rgb, b[0], b[1], r, S.side[i] ? up : lo, 235);\n      continue;\n    }\n    // In flight: brighter, with the colour turning in the neck and two\n    // fading copies behind it.\n    const to = S.side[i], t = b[2], c0 = to ? lo : up, c1 = to ? up : lo;\n    const c = [c0[0] + (c1[0] - c0[0]) * t, c0[1] + (c1[1] - c0[1]) * t, c0[2] + (c1[2] - c0[2]) * t];\n    // The copies are paled towards white so a dim one does not read brown.\n    for (let k = 2; k >= 0; k--) {\n      const q = ballAt(S, i, S.clock - k * 0.025), a = 0.3 * k;\n      const ck = [c[0] + (1 - c[0]) * a, c[1] + (1 - c[1]) * a, c[2] + (1 - c[2]) * a];\n      disc(rgb, q[0], q[1], r * (1 - 0.2 * k), ck, 255 * pow(0.5, k));\n    }\n  }\n\n  // ---- The trace. The binomial spread first: rows within one standard\n  // deviation sqrt(N)/2 of N/2 at 30, within two at 18.\n  const sd = sqrt(N) / 2, m = N / 2;\n  for (let y = TY0 - 1; y \u003c= TY1 + 1; y++) {\n    const n = ((TY1 - y) / (TY1 - TY0)) * N, z = abs(n - m) / sd;\n    const v = z \u003c= 1 ? 30 : z \u003c= 2 ? 18 : 0;\n    if (!v) continue;\n    for (let x = 0; x \u003c TCOLS; x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] += band[0] * v, rgb[o + 1] += band[1] * v, rgb[o + 2] += band[2] * v;\n    }\n  }\n  const put = (x, y, c, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * v), rgb[o + 1] = max(rgb[o + 1], c[1] * v), rgb[o + 2] = max(rgb[o + 2], c[2] * v);\n  };\n  // The mean N/2, dashed, and the watched count, dotted.\n  const ym = round(rowOf(m, N)), yk = round(rowOf(S.kw, N));\n  for (let x = 0; x \u003c TCOLS; x++) {\n    if (x % 4 \u003c 2) put(x, ym, band, 120);\n    if (x % 3 === 0) put(x, yk, pale, 110);\n  }\n  const cols = S.cols.concat([S.cur]);\n  // The expected count from the start, N/2 + (N/2)(1 - 2/N)^t, dim, for the\n  // columns still on the trace since the start.\n  for (let x = 0; x \u003c cols.length; x++) {\n    const t = (cols[x].g + 1) * S.per, e = m + m * pow(1 - 2 / N, t);\n    if (e - m \u003c 0.5) continue;\n    put(x, round(rowOf(e, N)), pale, 70);\n  }\n  let prev = cols.length ? cols[0].mx : N;\n  for (let x = 0; x \u003c cols.length; x++) {\n    const c = cols[x], a = round(rowOf(max(c.mx, prev), N)), b = round(rowOf(min(c.mn, prev), N));\n    for (let y = a; y \u003c= b; y++) put(x, y, up, 255);\n    if (c.hit) (put(x, RUG, pale, 255), put(x, RUG - 1, pale, 140));\n    prev = c.last;\n  }\n  // The time spent at each count, against the binomial law (bright dots).\n  let tot = 0;\n  for (let k = 0; k \u003c= N; k++) tot += S.time[k];\n  const rows = new Float64Array(H);\n  for (let k = 0; k \u003c= N; k++) rows[round(rowOf(k, N))] += S.time[k] / tot;\n  for (let y = TY0; y \u003c= TY1; y++) {\n    const len = min(HW, (rows[y] / S.lawMax) * (HW - 2)), want = (S.law[y] / S.lawMax) * (HW - 2);\n    for (let x = 0; x \u003c len - 0.3; x++) put(HX + x, y, up, 70 + 110 * min(1, len - x));\n    if (want >= 0.5) put(HX + round(want), y, pale, 230);\n  }\n\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3, R = rgb[o], G = rgb[o + 1], B = rgb[o + 2];\n    if (R \u003c 1 && G \u003c 1 && B \u003c 1) continue;\n    display.setPixel(p % W, (p - (p % W)) / W, min(255, R) | 0, min(255, G) | 0, min(255, B) | 0);\n  }\n}\n","maya-numerals":"// ===== Patternflow pattern =====\n// Title:   Maya Numerals\n// Family:  type\n// Idea:    A number five places tall is counted up in Maya numerals, the lowest place at the bottom: each new dot slides in from the right, five dots slide together and melt into a bar, and a place that fills (twenty, or eighteen in the Long Count's second place) collapses into a gold dot that climbs to the place above and leaves a shell for zero behind, so carries ripple up the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Maya place-value numerals in base 20, a dot for one, a bar for five and a shell for zero, the places written one above the other (Dresden Codex); the Long Count, whose second place counts to 18 (worked out from the Dresden Codex by Ernst Förstemann, 1880s); pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mode=0..1, Step=0..6\n//\n// Knob 1: Hue. Turns the signs round the wheel: at 0 the dots and bars are jade, the shells ivory and a dot on its way up a place gold. The faint rules between the places take the jade.\n// Knob 2: Speed. At 2 a dot slides in in 0.30 s, five dots melt into a bar in 0.40 s, a full place collapses in 0.36 s and its dot climbs in 0.42 s. Counting by one runs 1.7 numbers a second, so the second place moves about every 12 s. The opening carry is through three places at 4.8 s, or reaches 13.0.0.0.0 at 6.0 s in the Long Count. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Mode. 0 is plain base 20: every place carries at 20, four bars. It opens on 12.7.19.19.17 (top to bottom) and three counts later the carry runs up to 12.8.0.0.0. 1 is the Long Count of days: kin 20, winal 18 (18 winals of 20 days make a tun of 360 days), then 20 for the tun, katun and baktun. The winal carries when a third dot joins its three bars. It opens on 12.19.19.17.16, four days before 13.0.0.0.0, the day the Long Count reached on 21 December 2012 in the GMT correlation, and the carry runs up four places. Turning it starts the count again from that mode's opening.\n// Knob 4: Step. How much each addition adds, from 0 to 6: 1, 13, 20, 260, 360, 365 or 584. The step is written in the mode's places and its bars and dots slide in one at a time, lowest place first, each fusing and carrying as it lands. 260 is 13.0 in both modes; 360 is 18.0 in base 20 but 1.0.0 in the Long Count, one dot in the third place; 365 is 18.5 against 1.0.5; 584, the Venus period of the Dresden Codex's Venus table, is 1.9.4 against 1.11.4. At Speed 2 a step of 13 adds 0.38 times a second and 584 adds 0.22 times, moving the third place every 4.5 s.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst ss = (a, b, v) => ease((v - a) / (b - a));\nconst lerp = (a, b, u) => a + (b - a) * u;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Layout. Five places, the lowest at the bottom, each a cell 25.6 rows\n// tall. A numeral is bars stacked from the bottom of the glyph, one slot\n// each, and a row of up to four dots in the slot above them; the glyph is\n// centred in its cell. Zero is a shell.\nconst P = 5, CELL = H / P, CX = 32;\nconst BL = 38, BT = 4.4, SP = 6, DR = 2.8, DS = 9.5;\nconst cyOf = (p) => H - CELL * (p + 0.5);\nconst slotY = (p, n, k) => cyOf(p) + ((n - 1) / 2 - k) * SP;\nconst dotX = (i, d) => CX + (i - (d - 1) / 2) * DS;\n\n// Sprites: kind 0 dot, 1 bar, 2 shell.\nconst DOT = 0, BAR = 1, SHELL = 2;\n\n// Sprites carry a position, a size s (a bar's length as a share of BL), an\n// alpha a and g, how far the sign is tinted gold and glows.\nfunction staticPlace(out, p, b, d, a) {\n  const n = b + (d > 0 ? 1 : 0);\n  if (n === 0) out.push({ k: SHELL, x: CX, y: cyOf(p), s: 1, a, g: 0 });\n  for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: slotY(p, n, k), s: 1, a, g: 0 });\n  for (let i = 0; i \u003c d; i++) out.push({ k: DOT, x: dotX(i, d), y: slotY(p, n, b), s: 1, a, g: 0 });\n}\n\n// ---- Counting. Radix of each place: 20, or in the Long Count 20 for the\n// kin, 18 for the winal (18 winals of 20 days make a tun of 360), then 20.\nconst RADIX = [[20, 20, 20, 20, 20], [20, 18, 20, 20, 20]];\nconst STEPS = [1, 13, 20, 260, 360, 365, 584];\n// Openings, lowest place first. Base 20: 12.7.19.19.17, three counts before\n// a carry runs up three places to 12.8.0.0.0. Long Count: 12.19.19.17.16,\n// four days before 13.0.0.0.0. Counted through at Speed 2 (op times below),\n// the first lands at 4.76 s and the second at 6.00 s.\n// The steps are written in each mode's places when an addition starts:\n// 584 = 1.9.4 in base 20 (400 + 180 + 4) and 1.11.4 in the Long Count\n// (360 + 220 + 4); 365 = 18.5 against 1.0.5. Counted over 120 s at Speed 2,\n// base 20 makes 202 additions of 1 and 26 of 584; 360 makes 37 in base 20,\n// six signs each, and 202 in the Long Count, one dot each.\nconst OPEN = [[17, 19, 19, 7, 12], [16, 17, 19, 19, 12]];\n\n// Op durations in seconds at Speed 2.\nconst DUR = { side: 0.3, bar: 0.36, climb: 0.42, fuse: 0.4, carry: 0.36, pause: 0.16 };\nconst opDur = (op) => (op.k === \"in\" ? (op.from === \"below\" ? DUR.climb : op.sign === BAR ? DUR.bar : DUR.side) : DUR[op.k]);\n\nfunction reset(S) {\n  const o = OPEN[S.mode];\n  S.b = o.map((v) => floor(v / 5));\n  S.d = o.map((v) => v % 5);\n  S.q = [];\n  S.cur = null;\n  S.u = 0;\n}\n\nfunction addition(S) {\n  const R = RADIX[S.mode];\n  let n = STEPS[S.step];\n  for (let p = 0; p \u003c P && n > 0; p++) {\n    const dg = n % R[p];\n    n = floor(n / R[p]);\n    for (let i = 0; i \u003c floor(dg / 5); i++) S.q.push({ k: \"in\", p, sign: BAR, from: \"side\" });\n    for (let i = 0; i \u003c dg % 5; i++) S.q.push({ k: \"in\", p, sign: DOT, from: \"side\" });\n  }\n  S.q.push({ k: \"pause\" });\n}\n\n// What happens when an op ends: the place takes the sign, and anything it\n// sets off goes to the front of the queue.\nfunction finish(S, op) {\n  const p = op.p, R = RADIX[S.mode];\n  if (op.k === \"pause\") return;\n  if (p >= P) return;\n  const val = () => S.b[p] * 5 + S.d[p];\n  if (op.k === \"in\") {\n    if (op.sign === BAR) S.b[p]++;\n    else S.d[p]++;\n    if (S.d[p] === 5) S.q.unshift({ k: \"fuse\", p });\n    else if (val() >= R[p]) S.q.unshift({ k: \"carry\", p });\n  } else if (op.k === \"fuse\") {\n    S.d[p] -= 5;\n    S.b[p]++;\n    if (val() >= R[p]) S.q.unshift({ k: \"carry\", p });\n  } else if (op.k === \"carry\") {\n    const v = val() - R[p];\n    S.b[p] = floor(v / 5);\n    S.d[p] = v % 5;\n    S.q.unshift({ k: \"in\", p: p + 1, sign: DOT, from: \"below\" });\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, mode: 0, step: 0, b: null, d: null, q: [], cur: null, u: 0,\n    rgb: new Float32Array(NP * 3), sig: new Float32Array(NP * 3), hot: new Float32Array(NP * 3), tmp: new Float32Array(NP * 3), blr: new Float32Array(NP * 3), blh: new Float32Array(NP * 3),\n  };\n  reset(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const mode = round(cl(k[2], 0, 1)), step = cl(round(k[3]), 0, 6);\n  S.step = step;\n  if (mode !== S.mode) {\n    S.mode = mode;\n    reset(S);\n  }\n  S.u += (d * cl(k[1], 0.2, 3)) / 2;\n  for (let guard = 0; guard \u003c 64; guard++) {\n    if (!S.cur) {\n      if (!S.q.length) addition(S);\n      S.cur = S.q.shift();\n    }\n    const T = opDur(S.cur);\n    if (S.u \u003c T) break;\n    S.u -= T;\n    finish(S, S.cur);\n    S.cur = null;\n  }\n}\n\n// ---- Sprites for the frame.\nfunction sprites(S) {\n  const out = [], op = S.cur, u = op ? S.u / opDur(op) : 0;\n  for (let p = 0; p \u003c P; p++) {\n    const b = S.b[p], d = S.d[p];\n    if (!op || op.p !== p || op.k === \"pause\") {\n      staticPlace(out, p, b, d, 1);\n      continue;\n    }\n    const e = ease(u);\n    if (op.k === \"in\") {\n      const nb = op.sign === BAR ? b + 1 : b, nd = op.sign === BAR ? d : d + 1;\n      const n0 = b + (d > 0 ? 1 : 0), n1 = nb + (nd > 0 ? 1 : 0);\n      if (b + d === 0) out.push({ k: SHELL, x: CX, y: cyOf(p), s: 1 - 0.3 * e, a: 1 - e, g: 0 });\n      for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: lerp(slotY(p, n0, k), slotY(p, n1, k), e), s: 1, a: 1, g: 0 });\n      for (let i = 0; i \u003c d; i++)\n        out.push({ k: DOT, x: lerp(dotX(i, d), dotX(i, nd), e), y: lerp(slotY(p, n0, b), slotY(p, n1, nb), e), s: 1, a: 1, g: 0 });\n      // The newcomer.\n      const tx = op.sign === BAR ? CX : dotX(d, nd), ty = slotY(p, n1, b);\n      if (op.from === \"below\") {\n        // Climbing from the middle of the place below, with a fading tail.\n        const sy = cyOf(p - 1);\n        for (let tr = 4; tr >= 0; tr--) {\n          const mm = ease(u - tr * 0.06);\n          out.push({ k: DOT, x: lerp(CX, tx, mm), y: lerp(sy, ty, mm), s: 1 - tr * 0.12, a: tr ? 0.35 - tr * 0.06 : 1, g: 1 - 0.6 * ss(0.7, 1, u) });\n        }\n      } else {\n        const sx = W + (op.sign === BAR ? BL / 2 + 2 : DR + 2), mm = 1 - (1 - u) * (1 - u) * (1 - u);\n        out.push({ k: op.sign, x: lerp(sx, tx, mm), y: ty, s: 1, a: 1, g: 0.35 * (1 - u) });\n      }\n    } else if (op.k === \"fuse\") {\n      const n = b + 1;\n      for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: slotY(p, n, k), s: 1, a: 1, g: 0 });\n      // The five slide together until they touch (a chain 26 LEDs long),\n      // melt into one rod as thick as a dot, and the rod draws out to a bar.\n      const y = slotY(p, n, b), m = ss(0, 0.45, u), gap = lerp(DS, 2 * DR * 0.92, m), fade = 1 - ss(0.38, 0.6, u);\n      for (let i = 0; i \u003c 5; i++) out.push({ k: DOT, x: CX + (i - 2) * gap, y, s: 1, a: fade, g: 0.7 * m });\n      const melt = ss(0.35, 0.6, u), draw = ss(0.55, 1, u), chain = (8 * DR * 0.92 + 2 * DR) / BL;\n      if (melt > 0) out.push({ k: BAR, x: CX, y, s: lerp(chain, 1, draw), th: lerp(2 * DR, BT, draw), a: melt, g: 0.7 * (1 - draw) });\n    } else if (op.k === \"carry\") {\n      // b, d still hold the place before the carry is taken out.\n      const R = RADIX[S.mode][p], v = b * 5 + d - R, rb = floor(v / 5), rd = v % 5;\n      const n = b + (d > 0 ? 1 : 0), ga = ease(u / 0.55), cy = cyOf(p);\n      const gone = 1 - ss(0.4, 0.6, u);\n      for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: lerp(slotY(p, n, k), cy, ga), s: 1 - 0.85 * ga, a: gone, g: ga });\n      for (let i = 0; i \u003c d; i++) out.push({ k: DOT, x: lerp(dotX(i, d), CX, ga), y: lerp(slotY(p, n, b), cy, ga), s: 1 - 0.4 * ga, a: gone, g: ga });\n      const pop = ss(0.4, 0.65, u);\n      if (pop > 0) out.push({ k: DOT, x: CX, y: cy, s: pop, a: 1, g: 1 });\n      const back = ss(0.55, 1, u);\n      if (back > 0) {\n        staticPlace(out, p, rb, rd, back);\n      }\n    }\n  }\n  // A carry off the top place climbs off the panel.\n  if (op && op.k === \"in\" && op.p >= P) {\n    for (let tr = 4; tr >= 0; tr--) {\n      const mm = ease(u - tr * 0.06);\n      out.push({ k: DOT, x: CX, y: lerp(cyOf(P - 1), -8, mm), s: 1 - tr * 0.12, a: tr ? 0.35 - tr * 0.06 : 1, g: 1 });\n    }\n  }\n  return out;\n}\n\n// ---- Drawing the signs, lit from the upper left.\nconst LX = -0.45, LY = -0.6, LZ = 0.66;\n\nfunction bead(buf, x, y, r, col, a) {\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - r - 1)); i \u003c= min(W - 1, floor(x + r + 1)); i++) {\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, dd = sqrt(dx * dx + dy * dy), cov = cl(r + 0.5 - dd, 0, 1) * a;\n      if (cov \u003c= 0) continue;\n      const nx = dx / (r + 0.3), ny = dy / (r + 0.3), nz = sqrt(max(0, 1 - nx * nx - ny * ny));\n      const lam = max(0, nx * LX + ny * LY + nz * LZ), spec = Math.pow(lam, 12);\n      const v = 0.28 + 0.72 * lam;\n      const o = (j * W + i) * 3;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = max(buf[o + c], cov * (col[c] * v + 0.6 * spec));\n    }\n}\n\nfunction rod(buf, x, y, len, th, col, a) {\n  const r = th / 2, hx = max(0, len / 2 - r);\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - hx - r - 1)); i \u003c= min(W - 1, floor(x + hx + r + 1)); i++) {\n      const dx0 = i + 0.5 - x, dy = j + 0.5 - y, dx = dx0 - cl(dx0, -hx, hx), dd = sqrt(dx * dx + dy * dy), cov = cl(r + 0.5 - dd, 0, 1) * a;\n      if (cov \u003c= 0) continue;\n      const nx = dx / (r + 0.3), ny = dy / (r + 0.3), nz = sqrt(max(0, 1 - nx * nx - ny * ny));\n      const lam = max(0, nx * LX + ny * LY + nz * LZ), spec = Math.pow(lam, 12);\n      const v = 0.28 + 0.72 * lam;\n      const o = (j * W + i) * 3;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = max(buf[o + c], cov * (col[c] * v + 0.5 * spec));\n    }\n}\n\n// The shell: an oval 21 by 12, pointed a little at the ends, with a rim,\n// a long curved slit through the middle and short teeth along both lips,\n// like a cowrie turned over. Ivory, lit from the upper left.\nfunction shell(buf, x, y, sc, col, a) {\n  const rx = 10.5 * sc, ry = 5.9 * sc;\n  for (let j = max(0, floor(y - ry - 1)); j \u003c= min(H - 1, floor(y + ry + 1)); j++)\n    for (let i = max(0, floor(x - rx - 1)); i \u003c= min(W - 1, floor(x + rx + 1)); i++) {\n      const u = (i + 0.5 - x) / rx, v = (j + 0.5 - y) / ry, au = abs(u), q = Math.pow(Math.pow(au, 1.7) + Math.pow(abs(v), 2), 1 / 2);\n      if (q > 1.1) continue;\n      const rimD = abs(q - 1) * ry * 1.1;\n      let val = cl(1.15 - rimD, 0, 1);\n      if (q \u003c 1) {\n        // Body, brighter up and left.\n        val = max(val, 0.2 + 0.28 * cl(0.5 - 0.5 * u - 0.9 * v, 0, 1));\n        // The slit: a gentle arc through the middle, dark.\n        const sv = 0.06 - 0.12 * u * u, ds = abs(v - sv) * ry;\n        if (au \u003c 0.82) {\n          if (ds \u003c 0.55) val *= 0.15;\n          // Teeth: one-LED ticks across each lip, every third column.\n          else if (ds \u003c 2 && (((i - round(x)) % 3) + 3) % 3 === 1) val = max(val, 0.85 * a);\n        }\n      }\n      val *= a * cl((1.1 - q) * 8, 0, 1);\n      const o = (j * W + i) * 3;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = max(buf[o + c], val * col[c]);\n    }\n}\n\n// A 5-tap binomial blur, across and then down, over rows y0..y1 only.\nfunction blur(src, tmp, out, y0, y1) {\n  const R = W * 3;\n  y0 = max(0, y0);\n  y1 = min(H - 1, y1);\n  for (let y = max(0, y0 - 2); y \u003c= min(H - 1, y1 + 2); y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const p = (y * W + x) * 3 + c;\n        tmp[p] = (6 * src[p] + 4 * ((x > 0 ? src[p - 3] : 0) + (x \u003c W - 1 ? src[p + 3] : 0)) + (x > 1 ? src[p - 6] : 0) + (x \u003c W - 2 ? src[p + 6] : 0)) / 16;\n      }\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const p = (y * W + x) * 3 + c;\n        out[p] = (6 * tmp[p] + 4 * ((y > 0 ? tmp[p - R] : 0) + (y \u003c H - 1 ? tmp[p + R] : 0)) + (y > 1 ? tmp[p - 2 * R] : 0) + (y \u003c H - 2 ? tmp[p + 2 * R] : 0)) / 16;\n      }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, sig, hot, tmp, blr, blh } = S;\n  const jade = hsv(0.4 + S.hue, 0.6, 1), gold = hsv(0.13 + S.hue, 0.5, 1), ivory = hsv(0.11 + S.hue, 0.18, 0.95);\n  sig.fill(0);\n  hot.fill(0);\n  // Rows the moving signs cover, so the wide glow is worked only there.\n  let h0 = H, h1 = -1;\n  for (const sp of sprites(S)) {\n    if (sp.a \u003c= 0.01) continue;\n    const g = cl(sp.g, 0, 1);\n    const col = [lerp(jade[0], gold[0], g), lerp(jade[1], gold[1], g), lerp(jade[2], gold[2], g)];\n    // Signs on the move also go into the hot buffer, which glows wider.\n    for (const [buf, a] of g > 0.02 ? [[sig, sp.a], [hot, sp.a * g]] : [[sig, sp.a]]) {\n      if (sp.k === DOT) bead(buf, sp.x, sp.y, DR * sp.s, col, a);\n      else if (sp.k === BAR) rod(buf, sp.x, sp.y, max(BT, BL * sp.s), sp.th || BT, col, a);\n      else shell(buf, sp.x, sp.y, sp.s, ivory, a);\n    }\n    if (g > 0.02) (h0 = min(h0, floor(sp.y) - 4)), (h1 = max(h1, floor(sp.y) + 4));\n  }\n  blur(sig, tmp, blr, 0, H - 1);\n  blh.fill(0);\n  if (h1 >= 0) {\n    blur(hot, tmp, blh, h0 - 4, h1 + 4);\n    hot.fill(0);\n    blur(blh, tmp, hot, h0 - 6, h1 + 6);\n  }\n  const bg = hsv(0.4 + S.hue, 0.5, 0.05);\n  for (let y = 0; y \u003c H; y++) {\n    const line = abs(((y + 0.5) % CELL) - 0.5) \u003c 0.6 && y > 2 ? 0.07 : 0;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3;\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = bg[c] + line * jade[c] + 0.85 * sig[o + c] + 0.45 * blr[o + c] + 1.4 * hot[o + c];\n    }\n  }\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n","multiple-master":"// ===== Patternflow pattern =====\n// Title:   Multiple Master\n// Family:  type\n// Idea:    The word MASTER is stored as four master outlines, light and black at condensed and extended width, all with the same points in the same order, and the big word on top is the instance made by blending the four point lists bilinearly at the weight and width of the knobs, while it wanders slowly round the knob point on the design-space square below, whose corners hold the four masters of one letter at a time.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Multiple Master fonts (Adobe, 1991; the first faces Myriad MM and Minion MM, 1992), the axis tags wght and wdth of OpenType Font Variations (2016), letters and masters drawn for this pattern, pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Weight=-1..1, Width=-1..1\n//\n// Knob 1: Hue. Turns the picture round the wheel: at 0 the word is pale azure, the design space blue and the instance dot gold.\n// Knob 2: Speed. How fast the instance wanders round the knob point and the corners change letter: at 2 the slowest part of the wander comes round in 14 s and each letter holds the corners 3 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Weight. Where the knob point sits on the weight axis, light at -1 and black at 1; the instance wanders up to 0.24 of the axis either side of it and folds back at the ends. The stems go from 1.6 LEDs to 4.1 at black condensed and 5.6 at black extended, the counters of A, R and S close up and the vertex of M lifts off the base line.\n// Knob 4: Width. The same on the width axis, condensed at -1 and extended at 1: the letters and the space between them stretch together, the top line from 29 LEDs of ink at light condensed to 55 at light extended and 58 at black extended.\n// Buttons: K3 tap leans the word 8 degrees, or stands it up again: a slant axis, whose ends differ by a shear alone.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The masters. Master m is weight (m >> 1) and width (m & 1): 0 light\n// condensed, 1 light extended, 2 black condensed, 3 black extended. Units are\n// the cap height, y up from the base line. Each letter is drawn by one\n// function from the master's numbers below, so all four come out with the\n// same contours of the same point counts; the code checks that and stops if\n// they do not. Pieces overlap (an E is a stem and three arms) and fill by\n// the nonzero rule, as OpenType variable outlines may; Type 1 MM outlines\n// could not overlap.\nconst SV = [0.072, 0.076, 0.185, 0.255]; // vertical stem\nconst SB = [0.05, 0.085, 0.042, 0.072]; // side bearing\n// Body width of each letter at the four masters, and how much of the side\n// bearing it keeps on the left and right (open sides take less).\nconst BW = {\n  M: [0.48, 0.88, 0.64, 0.94],\n  A: [0.4, 0.78, 0.52, 0.84],\n  S: [0.34, 0.62, 0.5, 0.7],\n  T: [0.36, 0.68, 0.44, 0.74],\n  E: [0.3, 0.56, 0.42, 0.62],\n  R: [0.38, 0.66, 0.5, 0.74],\n};\nconst SIDE = { M: [1, 1], A: [0.25, 0.25], S: [0.8, 0.8], T: [0.3, 0.3], E: [1, 0.6], R: [1, 0.45] };\n\nconst rect = (x0, y0, x1, y1) => [x0, y0, x1, y0, x1, y1, x0, y1];\n// A ring between two superellipses from angle a0 to a1 (degrees), n points\n// along each edge: the bowls of S and R.\nfunction ring(cx, cy, rxo, ryo, rxi, ryi, a0, a1, n, ex) {\n  const o = [], e = 2 / ex;\n  const pt = (rx, ry, a) => {\n    const c = cos((a * PI) / 180), s = sin((a * PI) / 180);\n    o.push(cx + rx * Math.sign(c) * abs(c) ** e, cy + ry * Math.sign(s) * abs(s) ** e);\n  };\n  for (let i = 0; i \u003c n; i++) pt(rxo, ryo, a0 + ((a1 - a0) * i) / (n - 1));\n  for (let i = n - 1; i >= 0; i--) pt(rxi, ryi, a0 + ((a1 - a0) * i) / (n - 1));\n  return o;\n}\n// The horizontal width of a stroke of perpendicular thickness t that rises\n// dy over dx: t * length / dy, solved with the stroke's own width in dx.\nfunction slantW(t, dx0, k, dy) {\n  let hx = t;\n  for (let i = 0; i \u003c 4; i++) {\n    const dx = dx0 - k * hx;\n    hx = (t * sqrt(dx * dx + dy * dy)) / dy;\n  }\n  return hx;\n}\n\nfunction design(ch, m) {\n  const w = m >> 1, bw = BW[ch][m], sv = SV[m], sh = sv * (w ? 0.84 : 0.92), td = sv * 0.96;\n  const c = [];\n  if (ch === \"M\") {\n    // Vertex on the base line when light; lifted 0.15 at black condensed so\n    // the two notches keep some light.\n    const vx = bw / 2, vy = [0, 0, 0.15, 0.05][m], hx = slantW(td, vx, 0, 1 - vy);\n    c.push(rect(0, 0, sv, 1), rect(bw - sv, 0, bw, 1));\n    c.push([0, 1, hx, 1, vx + hx / 2, vy, vx - hx / 2, vy]);\n    c.push([bw, 1, bw - hx, 1, vx - hx / 2, vy, vx + hx / 2, vy]);\n  } else if (ch === \"A\") {\n    // Flat apex ft wide; the bar drops as the weight rises so the counter\n    // above it is the last thing to close.\n    const ft = [0.05, 0.06, 0.12, 0.16][m], yb = [0.27, 0.27, 0.12, 0.2][m];\n    const dx = bw / 2 - ft / 2, hx = slantW(td, dx, 0, 1);\n    c.push([0, 0, hx, 0, dx + hx, 1, dx, 1]);\n    c.push([bw, 0, bw - hx, 0, bw - dx - hx, 1, bw - dx, 1]);\n    const yt = yb + sh * 0.9;\n    c.push(rect(dx * yt, yb, bw - dx * yt, yt));\n  } else if (ch === \"S\") {\n    // Two rings of superellipses, the upper a little narrower, meeting in the\n    // spine at y = 0.53, with the terminals cut at a0 degrees.\n    const mid = 0.53, a0 = [34, 30, 44, 38][m], ex = [2.2, 2.3, 2.7, 2.8][m];\n    const ryU = (1 - mid + sh / 2) / 2, ryL = (mid + sh / 2) / 2, rxU = bw * 0.47, rxL = bw * 0.5;\n    c.push(ring(bw / 2, 1 - ryU, rxU, ryU, rxU - sv, ryU - sh, a0, 270, 16, ex));\n    c.push(ring(bw / 2, ryL, rxL, ryL, rxL - sv, ryL - sh, 90, a0 - 180, 16, ex));\n  } else if (ch === \"T\") {\n    c.push(rect(0, 1 - sh, bw, 1), rect(bw / 2 - sv / 2, 0, bw / 2 + sv / 2, 1));\n  } else if (ch === \"E\") {\n    const mE = 0.52;\n    c.push(rect(0, 0, sv, 1), rect(0, 1 - sh, bw, 1), rect(0, 0, bw, sh), rect(0, mE - sh / 2, bw * 0.88, mE + sh / 2));\n  } else if (ch === \"R\") {\n    const yl = [0.44, 0.44, 0.4, 0.41][m], bowlR = bw * [0.93, 0.9, 0.94, 0.92][m];\n    const bx = sv + 0.4 * (bowlR - 2 * sv), rxo = bowlR - bx, ryo = (1 - yl) / 2, ex = [2.2, 2.3, 2.7, 2.8][m];\n    c.push(rect(0, 0, sv, 1), rect(0, 1 - sh, bx, 1), rect(0, yl, bx, yl + sh));\n    c.push(ring(bx, yl + ryo, rxo, ryo, rxo - sv, ryo - sh, 90, -90, 14, ex));\n    const top = yl + sh, lx = bx - 0.3 * td, hx = slantW(td, bw - lx, 1, top);\n    c.push([lx, top, lx + hx, top, bw, 0, bw - hx, 0]);\n  }\n  // Every contour counter-clockwise (y up), so overlapping pieces add.\n  for (const p of c) {\n    let a = 0;\n    for (let i = 0; i \u003c p.length; i += 2) {\n      const j = (i + 2) % p.length;\n      a += p[i] * p[j + 1] - p[j] * p[i + 1];\n    }\n    if (a \u003c 0) for (let i = 0, j = p.length - 2; i \u003c j; i += 2, j -= 2) [p[i], p[i + 1], p[j], p[j + 1]] = [p[j], p[j + 1], p[i], p[i + 1]];\n  }\n  const sb = SB[m];\n  return { pts: c.map((p) => Float32Array.from(p)), bw, l: sb * SIDE[ch][0], r: sb * SIDE[ch][1] };\n}\n\nconst GLYPH = {};\nfor (const ch of \"MASTER\") {\n  const ms = [0, 1, 2, 3].map((m) => design(ch, m));\n  // Same contours, same point counts, in all four masters.\n  for (const g of ms) {\n    if (g.pts.length !== ms[0].pts.length) throw new Error(\"Multiple Master: contour count differs in \" + ch);\n    g.pts.forEach((p, i) => {\n      if (p.length !== ms[0].pts[i].length) throw new Error(\"Multiple Master: point count differs in \" + ch);\n    });\n  }\n  GLYPH[ch] = ms;\n}\nconst LINES = [\"MAS\", \"TER\"];\n\n// ---- Size. The widest line at any master, with the full slant added, sets\n// the cap height: MAS at black extended is 2.65 caps of ink, plus 0.14 of\n// lean, so 62 LEDs hold a cap height of 22.\nconst SLANT = 0.14;\nfunction inkWidth(line, m) {\n  let a = 0;\n  for (const ch of line) a += GLYPH[ch][m].l + GLYPH[ch][m].bw + GLYPH[ch][m].r;\n  return a - GLYPH[line[0]][m].l - GLYPH[line[line.length - 1]][m].r;\n}\nlet widest = 0;\nfor (const line of LINES) for (let m = 0; m \u003c 4; m++) widest = max(widest, inkWidth(line, m));\nconst CAP = floor(62 / (widest + SLANT));\nconst BASE = [5 + CAP, 14 + 2 * CAP];\n\n// ---- The design-space square: width across, weight down, corners at\n// (SQ_X0, SQ_Y0) and (SQ_X0 + SQ, SQ_Y0 + SQ); the master glyphs sit\n// outside each corner, 11 LEDs high.\nconst SQ = 32, SQ_X0 = 16, SQ_Y0 = BASE[1] + 21, MCAP = 11;\n// A 3 by 5 pixel font for the four letters of the axis names.\nconst TINY = {\n  W: [\"#.#\", \"#.#\", \"###\", \"###\", \"#.#\"],\n  D: [\"##.\", \"#.#\", \"#.#\", \"#.#\", \"##.\"],\n  T: [\"###\", \".#.\", \".#.\", \".#.\", \".#.\"],\n  H: [\"#.#\", \"#.#\", \"###\", \"#.#\", \"#.#\"],\n  G: [\".##\", \"#..\", \"#.#\", \"#.#\", \".##\"],\n};\nfor (const k in TINY) TINY[k] = TINY[k].join(\"\");\n\n// ---- Fill with anti-aliased coverage. Five sub-rows a row; on each, the\n// crossings with every edge are sorted and walked with the nonzero rule,\n// and each span adds its exact horizontal overlap with every LED.\nconst SUB = 5, EDGE = new Float32Array(5 * 1200), XS = new Float32Array(256), DS = new Int8Array(256), ROW = new Float32Array(W);\nfunction fill(cov, polys, wgt) {\n  let ne = 0, ylo = 1e9, yhi = -1e9;\n  for (const p of polys)\n    for (let i = 0; i \u003c p.length; i += 2) {\n      const j = (i + 2) % p.length, y0 = p[i + 1], y1 = p[j + 1];\n      if (y0 === y1) continue;\n      const o = ne * 5;\n      EDGE[o] = p[i], EDGE[o + 1] = y0, EDGE[o + 2] = p[j], EDGE[o + 3] = y1, EDGE[o + 4] = y1 > y0 ? 1 : -1;\n      ne++;\n      ylo = min(ylo, y0, y1), yhi = max(yhi, y0, y1);\n    }\n  const r0 = max(0, floor(ylo)), r1 = min(H - 1, ceil(yhi));\n  for (let r = r0; r \u003c= r1; r++) {\n    ROW.fill(0);\n    for (let s = 0; s \u003c SUB; s++) {\n      const ys = r + (s + 0.5) / SUB;\n      let n = 0;\n      for (let e = 0; e \u003c ne; e++) {\n        const o = e * 5, y0 = EDGE[o + 1], y1 = EDGE[o + 3];\n        if (y0 \u003c y1 ? ys \u003c y0 || ys >= y1 : ys \u003c y1 || ys >= y0) continue;\n        const x = EDGE[o] + ((ys - y0) * (EDGE[o + 2] - EDGE[o])) / (y1 - y0);\n        let k = n++;\n        while (k > 0 && XS[k - 1] > x) (XS[k] = XS[k - 1]), (DS[k] = DS[k - 1]), k--;\n        XS[k] = x, DS[k] = EDGE[o + 4];\n      }\n      let wind = 0, xa = 0;\n      for (let k = 0; k \u003c n; k++) {\n        const was = wind;\n        wind += DS[k];\n        if (was === 0 && wind !== 0) xa = XS[k];\n        else if (was !== 0 && wind === 0) span(xa, XS[k]);\n      }\n    }\n    const o = r * W;\n    for (let x = 0; x \u003c W; x++) if (ROW[x] > 0) cov[o + x] = min(1, cov[o + x] + (ROW[x] / SUB) * wgt);\n  }\n}\nfunction span(a, b) {\n  a = max(0, a), b = min(W, b);\n  if (b \u003c= a) return;\n  const ia = floor(a), ib = floor(b);\n  if (ia === ib) return void (ROW[ia] += b - a);\n  ROW[ia] += ia + 1 - a;\n  for (let i = ia + 1; i \u003c ib; i++) ROW[i] += 1;\n  if (ib \u003c W) ROW[ib] += b - ib;\n}\n\n// One glyph at the blend c (four master weights) into panel polygons: x0 is\n// the left of its body, base the base line, cap the cap height in LEDs.\nfunction place(ch, c, x0, base, cap, lean, out) {\n  const g = GLYPH[ch];\n  for (let k = 0; k \u003c g[0].pts.length; k++) {\n    const a = g[0].pts[k], b = g[1].pts[k], d = g[2].pts[k], e = g[3].pts[k];\n    const p = new Float32Array(a.length);\n    for (let i = 0; i \u003c a.length; i += 2) {\n      const x = c[0] * a[i] + c[1] * b[i] + c[2] * d[i] + c[3] * e[i];\n      const y = c[0] * a[i + 1] + c[1] * b[i + 1] + c[2] * d[i + 1] + c[3] * e[i + 1];\n      p[i] = x0 + (x + lean * (y - 0.5)) * cap;\n      p[i + 1] = base - y * cap;\n    }\n    out.push(p);\n  }\n}\nconst mix = (c, ch, key) => c[0] * GLYPH[ch][0][key] + c[1] * GLYPH[ch][1][key] + c[2] * GLYPH[ch][2][key] + c[3] * GLYPH[ch][3][key];\n\nexport function setup(params) {\n  params.s = {\n    ph: 2.1, lc: 0, u: 0.5, v: 0.5, u0: 0.5, v0: 0.5, hue: 0, lean: 0, leanT: 0,\n    trail: [], word: new Float32Array(N), map: new Float32Array(N), rgb: new Float32Array(N * 3),\n  };\n}\n\n// Reflect into the square, so the wander folds back at an edge.\nconst fold = (x) => cl(x \u003c 0 ? -x : x > 1 ? 2 - x : x, 0, 1);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3);\n  S.u0 = (cl(k[2], -1, 1) + 1) / 2;\n  S.v0 = (cl(k[3], -1, 1) + 1) / 2;\n  if (input.btnPressed && input.btnPressed[2]) S.leanT = 1 - S.leanT;\n  S.lean += cl(S.leanT - S.lean, -d * 2, d * 2);\n  // The wander: two sines an axis at unrelated rates, 0.24 of the square at\n  // most each way, so it never closes into a figure. 0.42 rad/s a unit of\n  // Speed: the slowest term comes round in 14 s at 2.\n  S.ph += d * speed * 0.42;\n  const A = 0.24, p = S.ph;\n  S.u = fold(S.u0 + A * (0.62 * sin(0.71 * p + 0.3) + 0.38 * sin(1.37 * p + 2.1)));\n  S.v = fold(S.v0 + A * (0.62 * sin(0.53 * p + 1.7) + 0.38 * sin(1.19 * p + 0.6)));\n  S.trail.push(S.u, S.v);\n  if (S.trail.length > 72) S.trail.splice(0, 2);\n  S.lc += (d * speed) / 6;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { word, map, rgb } = S, u = S.u, v = S.v;\n  const c = [(1 - u) * (1 - v), (1 - u) * v, u * (1 - v), u * v];\n  const lean = SLANT * ss(0, 1, S.lean);\n  const hue = 0.54 + S.hue;\n  const ink = hsv(hue, 0.4, 1), guide = hsv(hue, 0.7, 0.17), blue = hsv(hue + 0.06, 0.62, 1), gold = hsv(hue + 0.58, 0.68, 1);\n  const li = floor(S.lc) % 6, lf = S.lc - floor(S.lc), fresh = ss(0, 0.08, lf);\n  const letter = \"MASTER\"[li], before = \"MASTER\"[(li + 5) % 6];\n\n  // ---- The instance: two lines, centred on their ink.\n  word.fill(0);\n  const ticks = [];\n  for (let L = 0; L \u003c 2; L++) {\n    const line = LINES[L], polys = [];\n    let ink0 = 0;\n    for (const ch of line) ink0 += mix(c, ch, \"l\") + mix(c, ch, \"bw\") + mix(c, ch, \"r\");\n    ink0 -= mix(c, line[0], \"l\") + mix(c, line[2], \"r\");\n    let x = (W - ink0 * CAP) / 2 - mix(c, line[0], \"l\") * CAP;\n    ticks.push([L, x]);\n    for (let i = 0; i \u003c 3; i++) {\n      const ch = line[i], l = mix(c, ch, \"l\"), bw = mix(c, ch, \"bw\"), r = mix(c, ch, \"r\");\n      place(ch, c, x + l * CAP, BASE[L], CAP, lean, polys);\n      if (L * 3 + i === li) ticks.push([L, x + (l + bw / 2) * CAP, 1]);\n      x += (l + bw + r) * CAP;\n      ticks.push([L, x]);\n    }\n    fill(word, polys, 1);\n  }\n\n  // ---- The masters of one letter at the four corners, the incoming letter\n  // fading over the first 0.24 s at Speed 2.\n  map.fill(0);\n  const corner = (ch, wgt) => {\n    for (let m = 0; m \u003c 4; m++) {\n      const g = GLYPH[ch][m], cm = [0, 0, 0, 0];\n      cm[m] = 1;\n      const right = m & 1, low = m >> 1, polys = [];\n      const x0 = right ? SQ_X0 + SQ + 3 : SQ_X0 - 3 - g.bw * MCAP;\n      const base = low ? SQ_Y0 + SQ + 3 + MCAP : SQ_Y0 - 3;\n      place(ch, cm, x0, base, MCAP, lean, polys);\n      fill(map, polys, wgt * (0.5 + 0.5 * c[m]));\n    }\n  };\n  corner(letter, fresh);\n  if (fresh \u003c 1) corner(before, 1 - fresh);\n\n  rgb.fill(0);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], col[0] * a), rgb[o + 1] = max(rgb[o + 1], col[1] * a), rgb[o + 2] = max(rgb[o + 2], col[2] * a);\n  };\n  // Cap line and base line of each line of type.\n  for (let L = 0; L \u003c 2; L++)\n    for (let x = 0; x \u003c W; x++) {\n      add(x, BASE[L], guide, 1);\n      add(x, BASE[L] - CAP - 1, guide, 1);\n    }\n  // Side-bearing ticks under the base line, and a gold dot under the letter\n  // the corners show.\n  for (const [L, x, mark] of ticks) {\n    const xi = round(x - 0.5), y = BASE[L] + 2;\n    if (mark) {\n      add(xi, y + 1, gold, 1), add(xi + 1, y + 1, gold, 1), add(xi, y + 2, gold, 0.5), add(xi + 1, y + 2, gold, 0.5);\n    } else for (let j = 0; j \u003c 3; j++) add(xi, y + j, blue, 0.32);\n  }\n  // The square, its quarter lines, and pale lines from the instance to each\n  // master, as bright as that master's share of the blend.\n  for (let i = 0; i \u003c= SQ; i++)\n    for (const q of [0, 1, 2, 3, 4]) {\n      const a = q === 0 || q === 4 ? 0.42 : 0.13;\n      add(SQ_X0 + i, SQ_Y0 + (q * SQ) / 4, blue, a);\n      add(SQ_X0 + (q * SQ) / 4, SQ_Y0 + i, blue, a);\n    }\n  // Axis names as the OpenType variation tags spell them: wdth across the\n  // top, wght down the left side.\n  const label = (s, x, y, dx, dy) => {\n    for (let i = 0; i \u003c s.length; i++)\n      for (let b = 0; b \u003c 15; b++) if (TINY[s[i]][b] === \"#\") add(x + i * dx + (b % 3), y + i * dy + floor(b / 3), blue, 0.5);\n  };\n  label(\"WDTH\", SQ_X0 + SQ / 2 - 7, SQ_Y0 - 7, 4, 0);\n  label(\"WGHT\", SQ_X0 - 9, SQ_Y0 + SQ / 2 - 11, 0, 6);\n  const px = SQ_X0 + v * SQ, py = SQ_Y0 + u * SQ;\n  for (let m = 0; m \u003c 4; m++) {\n    const cx = SQ_X0 + (m & 1) * SQ, cy = SQ_Y0 + (m >> 1) * SQ, n = ceil(max(abs(cx - px), abs(cy - py)));\n    for (let i = 1; i \u003c n; i++) add(round(px + ((cx - px) * i) / n), round(py + ((cy - py) * i) / n), gold, 0.08 + 0.25 * c[m]);\n  }\n  // The knob point: a small cross.\n  const kx = round(SQ_X0 + S.v0 * SQ), ky = round(SQ_Y0 + S.u0 * SQ);\n  for (let j = -2; j \u003c= 2; j++) if (j) add(kx + j, ky, gold, 0.4), add(kx, ky + j, gold, 0.4);\n  // Trail, oldest dimmest, then the instance itself.\n  const T = S.trail, nt = T.length / 2;\n  for (let i = 0; i \u003c nt; i++) add(round(SQ_X0 + T[i * 2 + 1] * SQ), round(SQ_Y0 + T[i * 2] * SQ), gold, 0.1 + 0.5 * (i / nt));\n  for (let j = -1; j \u003c= 1; j++)\n    for (let i = -1; i \u003c= 1; i++) {\n      const dx = round(px) + i + 0.5 - px, dy = round(py) + j + 0.5 - py;\n      add(round(px) + i, round(py) + j, gold, cl(1.25 - 0.55 * sqrt(dx * dx + dy * dy), 0, 1));\n    }\n\n  // ---- Ink over everything.\n  for (let p = 0; p \u003c N; p++) {\n    const o = p * 3, a = word[p], b = map[p];\n    if (a > 0) for (let q = 0; q \u003c 3; q++) rgb[o + q] = rgb[o + q] * (1 - a) + ink[q] * a;\n    if (b > 0) for (let q = 0; q \u003c 3; q++) rgb[o + q] = max(rgb[o + q], ink[q] * b);\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","steiner-deltoid":"// ===== Patternflow pattern =====\n// Title:   Steiner Deltoid\n// Family:  line\n// Idea:    A point runs round the circumcircle of a slowly changing triangle, the feet of its perpendiculars to the three side lines stand on one straight line drawn the full height of the panel, and the fading trace of those Simson lines piles up into a bright three-cusped deltoid that turns and slides as the triangle changes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Simson line (William Wallace, 1799), Steiner's deltoid as the envelope of the Simson lines (Jakob Steiner, 1856), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Trail=0.5..4\n//\n// Knob 1: Hue. Turns every colour together: at 0 the traces run teal to blue round the deltoid, the triangle and its circle are pale gold, its feet gold, and the point and the current Simson line near white.\n// Knob 2: Speed. How fast the point runs round the circle: one turn in 5 s at 2, 3.3 s at 3 and 50 s at 0.2. The triangle changes shape on the same clock.\n// Knob 3: Shape. How far the triangle strays from equilateral. At 0 its corners swing up to 14 degrees each way round the circle and the deltoid barely leaves the middle; at 1 they swing up to 46, the triangle goes obtuse, the orthocentre leaves it, and the deltoid rides up to 13.5 LEDs up and down the panel.\n// Knob 4: Trail. How long the earlier Simson lines stay, in turns of the point: at 0.5 a line fades to 37% in half a turn and the deltoid is one bright edge among separate rays; at 4 the lines stay for 20 s at Speed 2, each laid fainter, and the inside of the deltoid, crossed by three lines a turn, glows over the outside, crossed by one.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, round, cos, sin, exp, min, max, abs, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The geometry, checked in Node for 200 random triangles with the point\n// at 2000 places round the circle each: the three feet are collinear (the\n// area they span stays under 1e-15 of R^2); the Simson line turns 180 degrees\n// the other way while the point goes once round; the line for the point\n// diametrically opposite a vertex is the opposite side; and the envelope's\n// nearest and farthest points lie R/2 and 3R/2 from the nine-point centre N\n// (to 1e-6), so the nine-point circle is the deltoid's incircle and its\n// cusps sit 1.5 R out. For one triangle, counting sign changes over 20,000\n// places of the point, each of 36 test points within R/2 of N lay on three\n// Simson lines a turn and each of 36 beyond 1.5 R on one. With the\n// circumcentre at 0 and R = 1, in complex numbers, N = (a + b + c) / 2 and\n// the line for p touches the deltoid at (a + b + c + 2p + abc / p^2) / 2,\n// which the code uses for the spark; that formula matched the intersection\n// of neighbouring lines to 1e-6.\n//\n// R is 18 LEDs, so the cusps lie 27 from N and the deltoid fits the 64\n// columns when N stands on the middle one. The view slides sideways to keep\n// it there: the circumcentre sits on row 64 at x = 32 - Hx / 2, where H is\n// the orthocentre's offset from it, and N rides up and down the panel with\n// Hy / 2. Over 5000 s at Shape 1 the circle reaches column 63.5 at most and\n// N stays within 13.5 rows of row 64.\nconst R = 18;\n// One turn of the point takes TURN seconds at Speed 2.\nconst TURN = 5;\n\n// The triangle at clock u (seconds at Speed 2). Three corners spaced a third\n// of a turn, each swinging round the circle on its own slow beat (47, 59 and\n// 71 s), and the whole triangle turning once in 200 s against the point, so\n// over the 2.5 s a trace lasts at the start the deltoid hardly moves and its\n// edge stays sharp. amp is the swing in radians: 0.25 at Shape 0, 0.8 at\n// Shape 1. A corner can never pass the next one: two neighbours close by at\n// most 2 * 0.8 rad, short of 2.09, and over 5000 s they never come closer\n// than 28 degrees.\nconst BEAT = [47, 59, 71], PH = [0.9, 2.6, 4.4];\nfunction triangle(u, amp, out) {\n  const rho = (-TAU * u) / 200;\n  let hx = 0, hy = 0;\n  for (let i = 0; i \u003c 3; i++) {\n    const a = rho + PI / 2 + (TAU * i) / 3 + amp * sin((TAU * u) / BEAT[i] + PH[i]);\n    out.ca[i] = cos(a);\n    out.sa[i] = sin(a);\n    hx += out.ca[i];\n    hy += out.sa[i];\n  }\n  // Orthocentre H = O + R (a + b + c); the circumcentre O keeps the\n  // nine-point centre N = O + R (a + b + c) / 2 on column 32.\n  out.ox = 32 - (R * hx) / 2;\n  out.oy = 64;\n  out.hx = hx;\n  out.hy = hy;\n  for (let i = 0; i \u003c 3; i++) (out.x[i] = out.ox + R * out.ca[i]), (out.y[i] = out.oy + R * out.sa[i]);\n  return out;\n}\nconst newTri = () => ({ ca: [0, 0, 0], sa: [0, 0, 0], x: [0, 0, 0], y: [0, 0, 0], ox: 0, oy: 0, hx: 0, hy: 0 });\n\n// Foot of the perpendicular from (px, py) to the line through corners i, j.\nfunction foot(T, i, j, px, py, o, k) {\n  const ux = T.x[i], uy = T.y[i], dx = T.x[j] - ux, dy = T.y[j] - uy;\n  const t = ((px - ux) * dx + (py - uy) * dy) / (dx * dx + dy * dy);\n  o[k] = ux + t * dx;\n  o[k + 1] = uy + t * dy;\n}\n\n// The Simson line of the point at angle th: the three feet into F (on BC,\n// CA, AB), and the line through the two farthest apart as n . q = c with n\n// a unit normal, into L.\nfunction simson(T, th, F, L) {\n  const px = T.ox + R * cos(th), py = T.oy + R * sin(th);\n  foot(T, 1, 2, px, py, F, 0);\n  foot(T, 2, 0, px, py, F, 2);\n  foot(T, 0, 1, px, py, F, 4);\n  let bi = 0, bj = 2, bd = -1;\n  for (const [i, j] of [[0, 2], [2, 4], [0, 4]]) {\n    const d = hypot(F[j] - F[i], F[j + 1] - F[i + 1]);\n    if (d > bd) (bd = d), (bi = i), (bj = j);\n  }\n  const dx = (F[bj] - F[bi]) / bd, dy = (F[bj + 1] - F[bi + 1]) / bd;\n  L[0] = -dy;\n  L[1] = dx;\n  L[2] = -dy * F[bi] + dx * F[bi + 1];\n  L[3] = px;\n  L[4] = py;\n}\n\n// Add a soft line n . q = c, w LEDs to each side, into a float RGB buffer.\n// It walks rows for a steep line and columns for a flat one, so a line\n// costs about 400 pixel visits, not 8192.\nfunction addLine(buf, nx, ny, c, w, amt, col) {\n  if (abs(nx) >= abs(ny)) {\n    const sp = w / abs(nx);\n    for (let y = 0; y \u003c H; y++) {\n      const xc = (c - ny * (y + 0.5)) / nx - 0.5;\n      for (let x = max(0, ceil(xc - sp)); x \u003c= min(W - 1, floor(xc + sp)); x++) {\n        const f = 1 - abs(nx * (x + 0.5) + ny * (y + 0.5) - c) / w;\n        if (f > 0) {\n          const o = (y * W + x) * 3;\n          buf[o] += amt * f * col[0], buf[o + 1] += amt * f * col[1], buf[o + 2] += amt * f * col[2];\n        }\n      }\n    }\n  } else {\n    const sp = w / abs(ny);\n    for (let x = 0; x \u003c W; x++) {\n      const yc = (c - nx * (x + 0.5)) / ny - 0.5;\n      for (let y = max(0, ceil(yc - sp)); y \u003c= min(H - 1, floor(yc + sp)); y++) {\n        const f = 1 - abs(nx * (x + 0.5) + ny * (y + 0.5) - c) / w;\n        if (f > 0) {\n          const o = (y * W + x) * 3;\n          buf[o] += amt * f * col[0], buf[o + 1] += amt * f * col[1], buf[o + 2] += amt * f * col[2];\n        }\n      }\n    }\n  }\n}\n\n// Soft segment and dot, brightest-wins, into the 0..255 frame.\nfunction seg(rgb, x0, y0, x1, y1, w, col) {\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy || 1e-9;\n  const xa = max(0, floor(min(x0, x1) - w)), xb = min(W - 1, ceil(max(x0, x1) + w));\n  const ya = max(0, floor(min(y0, y1) - w)), yb = min(H - 1, ceil(max(y0, y1) + w));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const qx = x + 0.5 - x0, qy = y + 0.5 - y0, t = cl((qx * dx + qy * dy) / l2, 0, 1);\n      const f = 1 - hypot(qx - t * dx, qy - t * dy) / w;\n      if (f > 0) put(rgb, y * W + x, f, col);\n    }\n}\nfunction dot(rgb, cx, cy, r, col) {\n  for (let y = max(0, floor(cy - r)); y \u003c= min(H - 1, ceil(cy + r)); y++)\n    for (let x = max(0, floor(cx - r)); x \u003c= min(W - 1, ceil(cx + r)); x++) {\n      const f = 1 - hypot(x + 0.5 - cx, y + 0.5 - cy) / r;\n      if (f > 0) put(rgb, y * W + x, min(1, 1.6 * f), col);\n    }\n}\nfunction ring(rgb, cx, cy, rad, w, col) {\n  for (let y = max(0, floor(cy - rad - w)); y \u003c= min(H - 1, ceil(cy + rad + w)); y++)\n    for (let x = max(0, floor(cx - rad - w)); x \u003c= min(W - 1, ceil(cx + rad + w)); x++) {\n      const f = 1 - abs(hypot(x + 0.5 - cx, y + 0.5 - cy) - rad) / w;\n      if (f > 0) put(rgb, y * W + x, f, col);\n    }\n}\nfunction put(rgb, p, f, col) {\n  const o = p * 3;\n  rgb[o] = max(rgb[o], f * col[0]);\n  rgb[o + 1] = max(rgb[o + 1], f * col[1]);\n  rgb[o + 2] = max(rgb[o + 2], f * col[2]);\n}\n\n// ---- The trace. Every time the point passes a multiple of STEP (6 degrees,\n// 60 lines a turn) that place's Simson line is laid into ACC, LINE strong,\n// and the buffer fades by exp(-u / tau), tau the Trail knob in turns. The\n// lines are kept apart like threads in string art: near the deltoid\n// neighbours overlap and add up to a bright edge, farther out they part, 3\n// degrees apart, and run as separate rays to the panel's ends. Being tied\n// to the point's angle, not to frames, the trace is the same at any frame\n// rate and speed.\nconst STEP = (6 * PI) / 180, LINE = 0.5, LW = 0.75;\nfunction deposit(S, T, th0, th1) {\n  const F = S.F, L = S.L;\n  for (let k = floor(th0 / STEP) + 1; k * STEP \u003c= th1; k++) {\n    const th = k * STEP;\n    simson(T, th, F, L);\n    // The trace's colour runs from its hue to 0.16 past it and back once a\n    // turn, so each arc of the deltoid keeps its own tint.\n    const col = hsv(0.47 + S.hue + 0.08 * (1 - cos(th)), 0.75, 1);\n    addLine(S.acc, L[0], L[1], L[2], LW, LINE * (0.5 / S.trail) ** 0.7, col);\n  }\n}\n\nfunction advance(S, du) {\n  const T = triangle(S.u, S.amp, S.T);\n  const th1 = S.th + (TAU * du) / TURN;\n  const fade = exp(-du / (S.trail * TURN)), acc = S.acc;\n  for (let i = 0; i \u003c NP * 3; i++) acc[i] *= fade;\n  deposit(S, T, S.th, th1);\n  S.th = th1;\n  S.u += du;\n}\n\nexport function setup(params) {\n  params.s = {\n    u: 0, th: 0, hue: 0, amp: 0.25, trail: 0.5, warm: false,\n    acc: new Float32Array(NP * 3), rgb: new Float32Array(NP * 3), tmp: new Float32Array(NP * 3),\n    T: newTri(), F: new Float64Array(6), L: new Float64Array(5),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.5], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.amp = 0.25 + 0.55 * cl(k[2], 0, 1);\n  S.trail = cl(k[3], 0.5, 4);\n  if (!S.warm) {\n    // First frame: run the last three trail lengths (at most 60 s) at 30\n    // steps a second, so the deltoid is already built when the panel opens.\n    // 90 lines and 10 to 20 ms in Node at Trail 0.5; 720 lines and about\n    // 60 ms at 4, most of it fading the buffer 1800 times.\n    const back = min(60, 3 * S.trail * TURN);\n    S.u = -back;\n    S.th = (-TAU * back) / TURN;\n    for (let i = 0, n = round(back * 30); i \u003c n; i++) advance(S, 1 / 30);\n    S.u = 0;\n    S.th = 0;\n    S.warm = true;\n  }\n  advance(S, (d * cl(k[1], 0.2, 3)) / 2);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.warm) return;\n  const T = triangle(S.u, S.amp, S.T), F = S.F, L = S.L, rgb = S.rgb, acc = S.acc;\n  // The trace, through 1 - exp(-acc) per channel, so where lines pile up the\n  // colour runs to white.\n  for (let i = 0; i \u003c NP * 3; i++) rgb[i] = 255 * (1 - exp(-acc[i]));\n\n  const gold = hsv(0.12 + S.hue, 0.38, 1), grey = hsv(0.12 + S.hue, 0.2, 1), pale = hsv(0.47 + S.hue, 0.18, 1);\n  const sc = (c, v) => [c[0] * v, c[1] * v, c[2] * v];\n  // The three side lines, run off the panel both ways: the feet often land\n  // on them outside the triangle.\n  const side = [], dim = sc(grey, 50);\n  for (const [i, j] of [[1, 2], [2, 0], [0, 1]]) {\n    const dx = T.x[j] - T.x[i], dy = T.y[j] - T.y[i], l = hypot(dx, dy);\n    side.push([-dy / l, dx / l, (-dy * T.x[i] + dx * T.y[i]) / l]);\n  }\n  const lines = S.tmp.fill(0);\n  for (const [nx, ny, c] of side) addLine(lines, nx, ny, c, 0.9, 1, dim);\n  for (let i = 0; i \u003c NP * 3; i++) rgb[i] = max(rgb[i], min(dim[i % 3], lines[i]));\n  ring(rgb, T.ox, T.oy, R, 0.9, sc(gold, 95));\n  for (const [i, j] of [[0, 1], [1, 2], [2, 0]]) seg(rgb, T.x[i], T.y[i], T.x[j], T.y[j], 1, sc(gold, 210));\n\n  // The point, its perpendiculars, the feet and its Simson line.\n  simson(T, S.th, F, L);\n  const px = L[3], py = L[4];\n  for (let k = 0; k \u003c 3; k++) seg(rgb, px, py, F[2 * k], F[2 * k + 1], 0.8, sc(gold, 95));\n  const line = S.tmp.fill(0);\n  addLine(line, L[0], L[1], L[2], 1.1, 1, sc(pale, 235));\n  for (let i = 0; i \u003c NP * 3; i++) if (line[i] > rgb[i]) rgb[i] = line[i];\n  for (let k = 0; k \u003c 3; k++) dot(rgb, F[2 * k], F[2 * k + 1], 1.8, sc(gold, 255));\n  dot(rgb, px, py, 2.4, [255, 255, 255]);\n  // Where the line touches the deltoid: (a + b + c + 2p + abc / p^2) / 2.\n  const ar = T.ca[0] * T.ca[1] - T.sa[0] * T.sa[1], ai = T.ca[0] * T.sa[1] + T.sa[0] * T.ca[1];\n  const br = ar * T.ca[2] - ai * T.sa[2], bi = ar * T.sa[2] + ai * T.ca[2];\n  const tr = br * cos(-2 * S.th) - bi * sin(-2 * S.th), ti = br * sin(-2 * S.th) + bi * cos(-2 * S.th);\n  const tx = T.ox + (R * (T.hx + 2 * cos(S.th) + tr)) / 2, ty = T.oy + (R * (T.hy + 2 * sin(S.th) + ti)) / 2;\n  dot(rgb, tx, ty, 1.6, [255, 255, 255]);\n\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, (p / W) | 0, min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","topologists-sine-curve":"// ===== Patternflow pattern =====\n// Title:   Topologist's Sine Curve\n// Family:  topology\n// Idea:    The graph of sin(1/x) stands on the panel with x running down to the limit segment drawn across near the bottom, its swings packing tighter until they merge into a band that is bright at both edges and dim in the middle by the arcsine law, while a slow zoom toward x = 0 draws new swings out of the band and a bead walks down the curve, swinging faster and faster, and never reaches the segment.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: topologist's sine curve (Lynn Arthur Steen and J. Arthur Seebach Jr., Counterexamples in Topology, 1970), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Zoom=0..1, Measure=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel: at 0 the curve is aqua where it swings right on its way down and violet where it swings left, the band where the two can no longer be told apart is their periwinkle mix, the segment is pale gold and the bead leaves a gold trail.\n// Knob 2: Speed. At 2 a walk takes about 9 s and the zoom breathes in and out once every 30 s; at 0.2 both are ten times slower, at 3 half as fast again.\n// Knob 3: Zoom. How near x = 0 the top of the panel is: at 0 the panel shows x from 0.16 down to 0, at 1 from 0.005, where the band takes nearly the whole height. The slow zoom then goes four times nearer and back.\n// Knob 4: Measure. What a LED's brightness counts. At 0 it is how much of its row's stretch of x the curve spends in that LED, which in the band is the arcsine law, bright edges and a dim middle. At 1 it is how much curve length passes through the LED, and the band fills flat.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sqrt, sin, cos, asin, exp, log, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The panel. The curve's x runs down the panel, x = X at the top edge\n// and x = 0 on row 121 (Y = 121.5), where the limit segment {0} x [-1, 1]\n// lies across. Its value sin(1/x) runs across: -1 at column 4.5, +1 at 59.5.\nconst YS = 121.5, CX = 32, AMP = 27.5;\nconst colOf = (s) => CX + AMP * s;\n\n// In the band a row holds so many swings that the share of it the curve\n// spends in each column is the arcsine law: (asin s1 - asin s0) / pi for the\n// column's stretch s0..s1. Column 4, which only half meets the curve, gets\n// 0.061 of the row, 5.25 times the 0.0116 of a middle column, and column 5\n// gets 3.9 times. Across, every swing crosses each column twice.\nconst ARC = new Float32Array(W), OVL = new Float32Array(W);\nfor (let c = 0; c \u003c W; c++) {\n  const s0 = cl((c - CX) / AMP, -1, 1), s1 = cl((c + 1 - CX) / AMP, -1, 1);\n  ARC[c] = (asin(s1) - asin(s0)) / PI;\n  OVL[c] = (s1 - s0) * AMP;\n}\n\n// ---- One row, exactly. Between turning points, u = 1/x walks one way and\n// sin u is monotone, with inverse u = k pi + asin((-1)^k s) on the k-th\n// piece. Every crossing of a column boundary is then an exact x, so the\n// share of the row's x in each column, and the chord length through it, are\n// sums of differences: a box filter with no samples to alias. Odd pieces,\n// where the curve swings left on its way down, are also kept apart in L.\nfunction rowExact(j, ulo, uhi, span, yScale, M, L, A) {\n  const k0 = floor(ulo / PI + 0.5), k1 = floor(uhi / PI + 0.5), o = j * W;\n  for (let k = k0; k \u003c= k1; k++) {\n    const ua = max(ulo, (k - 0.5) * PI), ub = min(uhi, (k + 0.5) * PI);\n    if (ub \u003c= ua) continue;\n    const sg = k & 1 ? -1 : 1, cb = colOf(sin(ub)), dir = cb >= colOf(sin(ua)) ? 1 : -1;\n    let p = colOf(sin(ua)), xp = 1 / ua;\n    for (let guard = 0; guard \u003c 70; guard++) {\n      let q = dir > 0 ? floor(p) + 1 : ceil(p) - 1, last = false;\n      if (dir > 0 ? q >= cb : q \u003c= cb) (q = cb), (last = true);\n      const xq = last ? 1 / ub : 1 / (k * PI + asin(cl((sg * (q - CX)) / AMP, -1, 1)));\n      const c = floor((p + q) / 2), dx = abs(xp - xq);\n      if (c >= 0 && c \u003c W) {\n        M[o + c] += dx / span;\n        if (sg \u003c 0) L[o + c] += dx / span;\n        A[o + c] += sqrt((q - p) ** 2 + (dx * yScale) ** 2);\n      }\n      if (last) break;\n      (p = q), (xp = xq);\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, tz: 0, walk: 0, hue: 0, zoom: 0, meas: 0.06, X: 0.16, dt: 0, prevU: 0,\n    M: new Float32Array(N), L: new Float32Array(N), A: new Float32Array(N), T: new Float32Array(N), tmp: new Float32Array(N), F: new Float32Array(N * 3),\n    C: [0, 1, 2].map(() => new Float32Array(N)), O: [0, 1, 2].map(() => new Float32Array(N)),\n  };\n}\n\n// ---- Time, in seconds at Speed 2. The bead's share of the way from the\n// segment, q = x / X, is (1 - t / 8)^1.25: it comes down the panel at a\n// walker's pace, 19 rows a second at first and slower near the end, and\n// would touch the segment at 8 s. It cannot: there sin(1/x) has no limit,\n// so its swings come without bound, past the frame rate for the last second\n// or so, and the walk stops 0.4 LED short, in the band. A new one starts 0.8 s\n// later. The zoom divides X by up to 4 and back over 30 s.\nconst TW = 8, PW = 1.25, Q_END = 0.4 / YS, PAUSE = 0.8, TZ = 30;\nconst WALK = TW * (1 - Q_END ** (1 / PW));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const e = (d * cl(k[1], 0.2, 3)) / 2;\n  S.hue = k[0];\n  S.zoom = cl(k[2], 0, 1);\n  S.meas = cl(k[3], 0, 1);\n  S.tz += e;\n  S.walk += e;\n  S.dt = e;\n  if (S.walk > WALK + PAUSE) (S.walk -= WALK + PAUSE), (S.prevU = 0);\n  S.X = 0.16 * 10 ** (-1.5 * S.zoom) * exp(-log(4) * 0.5 * (1 - cos((2 * PI * S.tz) / TZ)));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { M, L, A, T, tmp, F, C, O } = S, [CR, CG, CB] = C, X = S.X, span = X / YS, yScale = YS / X;\n  M.fill(0), L.fill(0), A.fill(0);\n  // ---- The curve, row by row down to the segment's row.\n  for (let j = 0; j \u003c= 121; j++) {\n    const xb = X * (1 - j / YS), xa = max(0, X * (1 - (j + 1) / YS));\n    const ulo = 1 / xb, uhi = xa > 0 ? 1 / xa : Infinity;\n    if (uhi - ulo \u003c 10 * PI) rowExact(j, ulo, uhi, span, yScale, M, L, A);\n    else {\n      // More than five whole swings: the arcsine law, half of it swinging\n      // each way, and the chord length of two crossings a swing.\n      const f = (xb - xa) / span, sw = min(40, (uhi - ulo) / (2 * PI)), o = j * W;\n      for (let c = 4; c \u003c 60; c++) (M[o + c] += f * ARC[c]), (L[o + c] += 0.5 * f * ARC[c]), (A[o + c] += 2 * sw * OVL[c]);\n    }\n  }\n  // ---- Colour. Brightness from the measure: a share of 1/22 of the row\n  // reads 0.63. The curve swings right on its way down in aqua and left in\n  // violet, so a visible swing shows both, and in the band, where each row\n  // holds as much of one as of the other, they mix to periwinkle. Both hues\n  // drift by depth, ln(0.16 / x), so the colour travels with the zoom.\n  // The bright edges belong to the measure of x, not to the curve's length:\n  // counted by length (Measure 1), every swing crosses each column twice,\n  // nearly level, and a band row is the same all across. Checked on row 116\n  // of the opening view: 255 at the edges and 97 in the middle at Measure 0,\n  // 255 all across at Measure 1.\n  const m = S.meas, h0 = S.hue;\n  for (let y = 0; y \u003c H; y++) {\n    const dh = 0.03 * cl(log(0.16 / (X * max(1e-6, 1 - (y + 0.5) / YS))), -2, 6);\n    const ca = hsv(0.47 + h0 + dh, 0.85, 1), cv = hsv(0.71 + h0 + dh, 0.7, 1);\n    for (let x = 0, p = y * W; x \u003c W; x++, p++) {\n      if (!(M[p] > 0)) {\n        CR[p] = CG[p] = CB[p] = 0;\n        continue;\n      }\n      const v = (1 - m) * (1 - exp(-22 * M[p])) + m * (1 - exp(-1.3 * A[p])), l = L[p] / M[p];\n      CR[p] = v * (ca[0] + (cv[0] - ca[0]) * l);\n      CG[p] = v * (ca[1] + (cv[1] - ca[1]) * l);\n      CB[p] = v * (ca[2] + (cv[2] - ca[2]) * l);\n    }\n  }\n  // Glow: a 5-tap blur across and down of each channel, added at 0.7.\n  for (let i = 0; i \u003c 3; i++) blur(C[i], tmp, O[i]);\n\n  // ---- The bead. Its path since the last frame is sampled in u, every 0.1\n  // rad at most, into a trail that fades in 0.3 s; once it swings faster\n  // than the frame, the samples spread across the row, a smear as wide as\n  // the band.\n  const w = S.walk, fade = exp(-S.dt / 0.3);\n  for (let p = 0; p \u003c N; p++) T[p] *= fade;\n  let head = null;\n  if (w \u003c WALK) {\n    const q = (1 - w / TW) ** PW, u = 1 / (q * X), u0 = S.prevU > 0 && S.prevU \u003c u ? S.prevU : u - 1e-3;\n    const n = min(400, max(2, ceil((u - u0) / 0.1)));\n    for (let i = 1; i \u003c= n; i++) {\n      const ui = u0 + ((u - u0) * i) / n;\n      dep(T, colOf(sin(ui)), YS * (1 - 1 / (ui * X)), 1.6 / n + 0.02);\n    }\n    S.prevU = u;\n    head = [colOf(sin(u)), YS * (1 - q)];\n  }\n  // The trail is added on top in gold.\n  const seg = hsv(0.13 + h0, 0.35, 1), gold = hsv(0.12 + h0, 0.6, 1), [OR, OG, OB] = O;\n  for (let p = 0; p \u003c N; p++) {\n    const tr = min(1, T[p]);\n    F[p * 3] = min(1, CR[p] + 0.7 * OR[p] + gold[0] * tr);\n    F[p * 3 + 1] = min(1, CG[p] + 0.7 * OG[p] + gold[1] * tr);\n    F[p * 3 + 2] = min(1, CB[p] + 0.7 * OB[p] + gold[2] * tr);\n  }\n  // ---- The limit segment on row 121, closed at both ends, and a faint\n  // glow on the rows either side.\n  for (let x = 4; x \u003c 60; x++) {\n    const end = x === 4 || x === 59;\n    for (const [dy, a] of [[-1, 0.18], [0, end ? 1 : 0.85], [1, 0.25], [2, 0.08]]) add(F, x, 121 + dy, seg, a);\n  }\n  // The bead itself: white, with a soft halo 1.5 LEDs across.\n  if (head)\n    for (let j = -3; j \u003c= 3; j++)\n      for (let i = -3; i \u003c= 3; i++) {\n        const x = floor(head[0]) + i, y = floor(head[1]) + j, dx = x + 0.5 - head[0], dy = y + 0.5 - head[1];\n        add(F, x, y, [1, 0.97, 0.9], 1.3 * exp(-(dx * dx + dy * dy) / 1.1));\n      }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), (F[p * 3] * 255) | 0, (F[p * 3 + 1] * 255) | 0, (F[p * 3 + 2] * 255) | 0);\n}\n\n// Light added on top of the frame buffer, held to 1.\nfunction add(F, x, y, c, a) {\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  (F[o] = min(1, F[o] + c[0] * a)), (F[o + 1] = min(1, F[o + 1] + c[1] * a)), (F[o + 2] = min(1, F[o + 2] + c[2] * a));\n}\n\n// A point of the bead's path, split over its four nearest LEDs.\nfunction dep(T, x, y, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i, yy = iy + j;\n      if (xx >= 0 && yy >= 0 && xx \u003c W && yy \u003c H) T[yy * W + xx] += a * (i ? ax : 1 - ax) * (j ? ay : 1 - ay);\n    }\n}\n\nfunction blur(src, tmp, out) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (6 * src[p] + 4 * ((x > 0 ? src[p - 1] : 0) + (x \u003c W - 1 ? src[p + 1] : 0)) + (x > 1 ? src[p - 2] : 0) + (x \u003c W - 2 ? src[p + 2] : 0)) / 16;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      out[p] = (6 * tmp[p] + 4 * ((y > 0 ? tmp[p - W] : 0) + (y \u003c H - 1 ? tmp[p + W] : 0)) + (y > 1 ? tmp[p - 2 * W] : 0) + (y \u003c H - 2 ? tmp[p + 2 * W] : 0)) / 16;\n    }\n}\n","voss-dice":"// ===== Patternflow pattern =====\n// Title:   Voss Dice\n// Family:  noise\n// Idea:    A row of dice stands for the bits of a binary counter and at every step the dice whose bits changed are rerolled, so die k rerolls every 2^k steps and their sum is pink 1/f noise, drawn flowing down the panel between white noise (all the dice rerolled every step) on the left and brown noise (a walk stepped by one die) on the right.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Richard F. Voss's dice for 1/f noise, as Martin Gardner gave it with white and brown music in Mathematical Games (Scientific American, April 1978), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dice=4..8, Hold=-1..1\n//\n// Knob 1: Hue. Turns the dice and the middle and right traces round the wheel together: at 0 the middle trace and the dice's flashes are pink and the right trace brown. The left trace stays near white.\n// Knob 2: Speed. Steps a second: 6 at 2, 0.6 at 0.2, 9 at 3. Each step moves the traces down 2 rows.\n// Knob 3: Dice. How many dice, 4 to 8, the same for all three traces. The slowest die of the middle trace rerolls every 8 steps with 4 dice and every 128 with 8, so each die more adds an octave at the low end. From 5 dice up the faces shrink from 14 to 7 LEDs.\n// Knob 4: Hold. How much longer each die holds its face than the one to its right. At the opening 0.06 it is exactly 2, Voss's counter; at -0.94 and below it is 1, every die rerolls every step and the middle trace turns white like the left; at 1 it is 3.8, die 1 rerolls every 3 or 4 steps and die 3 every 56, so the middle trace jitters by one die round levels that seldom move.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nconst roll = () => 1 + floor(Math.random() * 6);\n\n// ---- Faces on a 7 by 7 grid: pips one cell at columns and rows 1, 3, 5,\n// the four corner cells left dark to round the die. Drawn at 2 LEDs a cell\n// for 4 dice (14 LED faces) and 1 for 5 to 8.\nconst PIPS = [\n  [],\n  [[3, 3]],\n  [[1, 1], [5, 5]],\n  [[1, 1], [3, 3], [5, 5]],\n  [[1, 1], [5, 1], [1, 5], [5, 5]],\n  [[1, 1], [5, 1], [3, 3], [1, 5], [5, 5]],\n  [[1, 1], [5, 1], [1, 3], [5, 3], [1, 5], [5, 5]],\n];\n\n// ---- The three games. Every step:\n// white: all n dice rerolled, the sum taken;\n// pink: Voss's dice, die k rerolled when floor(step / r^k) changes, which for\n//   r = 2 is when bit k of the step count changes, so die 0 every step,\n//   die 1 every 2nd, die k every 2^k-th;\n// brown: a walk that moves by a die's roll less 3.5 (-2.5 to +2.5) and folds\n//   back at the ends of the window the other two are drawn in.\n// The window is the mean of n dice, 3.5n, plus and minus 2.6 standard\n// deviations (each die's variance is 35/12): of 4 to 24 for 4 dice that is\n// 5.1 to 22.9, of 8 to 48 for 8 dice 15.4 to 40.6. Values are kept as -1..1\n// across the window, so the history survives a change of Dice.\n// Checked over 400,000 steps: 1.875 dice reroll a step on average with 4\n// dice and 1.992 with 8, so the pink sum moves 2.56 and 2.61 a step against\n// 3.87 and 5.46 for the white; the brown always moves 1.5.\nconst HIST = 140;\n\nfunction windowOf(n) {\n  return [3.5 * n, 2.6 * sqrt((n * 35) / 12)];\n}\n\nfunction step(S) {\n  const n = S.n, r = S.r, t = ++S.count;\n  for (let k = 0; k \u003c n; k++) {\n    const p = pow(r, k);\n    if (floor(t / p) !== floor((t - 1) / p)) {\n      S.dice[k] = roll();\n      S.flash[k] = 1;\n    }\n  }\n  let pink = 0, white = 0;\n  for (let k = 0; k \u003c n; k++) (pink += S.dice[k]), (white += roll());\n  const [mean, half] = windowOf(n);\n  let b = S.brown + roll() - 3.5;\n  if (b > mean + half) b = 2 * (mean + half) - b;\n  if (b \u003c mean - half) b = 2 * (mean - half) - b;\n  S.brown = b;\n  const at = S.head = (S.head + 1) % HIST;\n  S.hw[at] = (white - mean) / half;\n  S.hp[at] = (pink - mean) / half;\n  S.hb[at] = (b - mean) / half;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 4, r: 2, count: 0, ph: 0, hue: 0, ready: false,\n    dice: new Int8Array(8).fill(1), flash: new Float32Array(8), brown: 14,\n    head: 0, hw: new Float32Array(HIST), hp: new Float32Array(HIST), hb: new Float32Array(HIST),\n    rgb: new Float32Array(N * 3),\n  };\n  for (let k = 0; k \u003c 8; k++) params.s.dice[k] = roll();\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), n = cl(round(k[2]), 4, 8);\n  // Hold ratio: 2^(k + 0.94), so the Lab's opening 0.06 gives exactly 2.\n  S.r = max(1, pow(2, cl(k[3], -1, 1) + 0.94));\n  if (n !== S.n) {\n    // Dice added come in rolled; the walk keeps its place in the window.\n    const [m0, h0] = windowOf(S.n), [m1, h1] = windowOf(n);\n    S.brown = m1 + ((S.brown - m0) / h0) * h1;\n    S.n = n;\n  }\n  if (!S.ready) {\n    // A full panel of history before the first frame: 140 steps.\n    S.brown = 3.5 * n;\n    for (let i = 0; i \u003c HIST; i++) step(S);\n    S.flash.fill(0);\n    S.ready = true;\n  }\n  S.ph += d * speed * 3;\n  while (S.ph >= 1) {\n    S.ph -= 1;\n    step(S);\n  }\n  // A reroll flash fades in a quarter of a second.\n  const f = exp(-d / 0.09);\n  for (let i = 0; i \u003c 8; i++) S.flash[i] *= f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, n } = S, hue = S.hue;\n  const pinkC = hsv(0.93 + hue, 0.5, 1), brownC = hsv(0.07 + hue, 0.82, 0.68), whiteC = hsv(0.6 + hue, 0.06, 0.92);\n  const ivory = hsv(0.93 + hue, 0.1, 0.78), hot = hsv(0.93 + hue, 0.65, 1);\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a), rgb[o + 1] = max(rgb[o + 1], c[1] * a), rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n\n  // ---- Dice row, the counter's bit lamps under it.\n  const cell = n \u003c= 4 ? 2 : 1, face = 7 * cell, pitch = floor(W / n), x0 = floor((W - pitch * n + pitch - face) / 2);\n  const bitsY = 2 + face + cell, top = bitsY + 2 * cell + 3;\n  for (let k = 0; k \u003c n; k++) {\n    // Die 0, the fastest, on the right, so the lamps read as the step count\n    // in binary.\n    const dx = x0 + (n - 1 - k) * pitch, fl = S.flash[k];\n    const col = [0, 1, 2].map((q) => ivory[q] + (hot[q] - ivory[q]) * fl);\n    const pips = PIPS[S.dice[k]];\n    for (let j = 0; j \u003c 7; j++)\n      for (let i = 0; i \u003c 7; i++) {\n        if ((i === 0 || i === 6) && (j === 0 || j === 6)) continue;\n        let pip = false;\n        for (const [pi, pj] of pips) if (pi === i && pj === j) pip = true;\n        const a = pip ? 0.05 * (1 - fl) : 0.9 + 0.1 * fl;\n        for (let v = 0; v \u003c cell; v++) for (let u = 0; u \u003c cell; u++) put(dx + i * cell + u, 2 + j * cell + v, col, a);\n      }\n    const bit = floor(S.count / pow(S.r, k)) & 1;\n    for (let u = cell; u \u003c face - cell; u++) for (let v = 0; v \u003c cell; v++) put(dx + u, bitsY + v, pinkC, bit ? 0.9 : 0.12);\n  }\n\n  // ---- Three traces, newest at the top, 2 rows a step, sliding down\n  // smoothly between steps. Each is a step plot: a bright line at the value\n  // with a dim fill back to the column's middle.\n  const R = 2, cols = [[0, S.hw, whiteC], [22, S.hp, pinkC], [44, S.hb, brownC]];\n  for (const [cx, hist, c] of cols) {\n    const mid = cx + 9.5;\n    let prev = null;\n    for (let y = top; y \u003c H; y++) {\n      const age = floor((y - top) / R - S.ph + 1);\n      if (age >= HIST) break;\n      const v = hist[(S.head - max(0, age) + HIST * 2) % HIST];\n      const x = mid + cl(v, -1, 1) * 9;\n      // Fill from the middle.\n      const a = min(x, mid), b = max(x, mid);\n      for (let i = floor(a); i \u003c= floor(b); i++) put(i, y, c, 0.2);\n      // The line, split over two LEDs by where it falls between them, and a\n      // horizontal run where the value changed since the row above.\n      const xi = floor(x - 0.5), fr = x - 0.5 - xi;\n      put(xi, y, c, 1 - fr), put(xi + 1, y, c, fr);\n      if (prev !== null && abs(prev - x) > 1) for (let i = round(min(prev, x)); i \u003c= round(max(prev, x)) - 1; i++) put(i, y, c, 0.85);\n      prev = x;\n    }\n  }\n\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","autogram":"// ===== Patternflow pattern =====\n// Title:   Autogram\n// Family:  type\n// Idea:    A sentence that counts its own letters fills the panel in 3 by 5 capitals, and a checker goes through it letter by letter, lighting every occurrence of that letter in reading order while a tally climbs towards the number the sentence claims, so the claim word and the bar under the text turn true when the tally reaches it; with Doubt turned up some claims are changed first, the check finds them false, and the sentence is rewritten again and again with the numbers it actually has, faster and faster, until it either comes true or is caught going round a loop of hundreds of sentences.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: autograms, named by Lee Sallows, the first of his printed in Douglas Hofstadter's Metamagical Themas column in Scientific American, January 1982; the three sentences here were found for this pattern; 3 by 5 capitals from Typewriter (pattern round 18) and 5 by 7 figures from Photon Disk (pattern round 70); pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sentence=0..2, Doubt=0..1\n//\n// Knob 1: Hue. Moves the two colours together along the part of the wheel away from red, which is kept for a false claim: at 0 the counted letters are cyan and the claims amber, at 0.5 blue-violet and green, at 1 magenta and sea green; the sentence and the dark ground take a tint of the same two.\n// Knob 2: Speed. At 2 the sentence is written in 1.8 s, 125 characters a second, and the checker takes 0.035 s an occurrence and 0.4 s a letter, so THIS SENTENCE HAS, 152 letters of 19 kinds, is checked in 13 s and held 3 s when true; the first rewrite takes 1.5 s and each after it 0.8 times as long, down to 240 a second. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Sentence. Which autogram comes first; the others follow in turn: 0 THIS SENTENCE HAS, 1 THIS PANEL SHOWS, 2 THESE LIGHTS SPELL. Turning it starts the new one at once.\n// Knob 4: Doubt. How many claims are changed, by 1 to 3, before a sentence is checked: none below 0.125, so the opening 0.06 shows the sentence as found, one at 0.25, two at 0.5, three at 0.75 and four at 1. A changed claim changes the letters of its own number word, so more claims than that come out false.\n\n// Each sentence lists, for every letter it uses, how many times that letter\n// appears in it, counting letters only, the S of each 'S included. The\n// three were found by a search for this pattern that starts from random\n// claims, writes the sentence, counts it and copies some of the counts back\n// into the claims, with restarts, until a sentence comes out true of itself;\n// setup counts each one again and stops if a claim is wrong.\n//\n// Copying every count back at once, which is what the rewrite here does,\n// almost never finds one. In 1200 tries from the first sentence with one\n// to four claims moved by 1 to 3, the rewriting was caught in a loop of\n// 453 sentences 1042 times, of 397 sentences 109 times and of 127\n// sentences 46 times, half of them within 760 rewrites and all within 1320,\n// and came true 3 times: twice as the sentence it started from, once as an\n// autogram nobody had written. From the second sentence the loops were 257,\n// 75, 306, 172, 21 and 12 sentences long (all within 2220 rewrites), from\n// the third 415, 94, 28 and 35. The chase gives up at 3000.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, abs, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nconst SENTENCES = [\n  \"THIS SENTENCE HAS THREE A'S, TWO C'S, TWO D'S, TWENTY-NINE E'S, TWO F'S, THREE G'S, NINE H'S, EIGHT I'S, ONE L, SIXTEEN N'S, SEVEN O'S, SIX R'S, TWENTY-SEVEN S'S, EIGHTEEN T'S, TWO U'S, FOUR V'S, SEVEN W'S, THREE X'S AND THREE Y'S.\",\n  \"THIS PANEL SHOWS THREE A'S, TWO D'S, TWENTY-THREE E'S, TWO F'S, TWO G'S, NINE H'S, SIX I'S, THREE L'S, ELEVEN N'S, EIGHT O'S, TWO P'S, SEVEN R'S, TWENTY-SIX S'S, TWENTY T'S, TWO U'S, THREE V'S, TEN W'S, THREE X'S AND FOUR Y'S.\",\n  \"THESE LIGHTS SPELL TWO A'S, TWO D'S, TWENTY-FIVE E'S, THREE F'S, TWO G'S, SEVEN H'S, SIX I'S, FOUR L'S, TEN N'S, SEVEN O'S, TWO P'S, SIX R'S, THIRTY S'S, SEVENTEEN T'S, TWO U'S, SEVEN V'S, SEVEN W'S, THREE X'S AND THREE Y'S.\",\n];\nconst ONES = [\"ZERO\", \"ONE\", \"TWO\", \"THREE\", \"FOUR\", \"FIVE\", \"SIX\", \"SEVEN\", \"EIGHT\", \"NINE\", \"TEN\", \"ELEVEN\", \"TWELVE\", \"THIRTEEN\", \"FOURTEEN\", \"FIFTEEN\", \"SIXTEEN\", \"SEVENTEEN\", \"EIGHTEEN\", \"NINETEEN\"];\nconst TENS = [\"\", \"\", \"TWENTY\", \"THIRTY\", \"FORTY\", \"FIFTY\", \"SIXTY\", \"SEVENTY\", \"EIGHTY\", \"NINETY\"];\nconst word = (n) => (n \u003c 20 ? ONES[n] : TENS[floor(n / 10)] + (n % 10 ? \"-\" + ONES[n % 10] : \"\"));\nconst NUMBER = {};\nfor (let n = 0; n \u003c 100; n++) NUMBER[word(n)] = n;\nconst AZ = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\n// ---- The sentence from its opening words and its claims, with where each\n// claim sits: the number word, the letter and its 'S.\nfunction build(pre, L, c) {\n  let text = pre + \" \";\n  const item = [];\n  L.forEach((l, i) => {\n    if (i === L.length - 1) text += \"AND \";\n    const a = text.length;\n    text += word(c[i]) + \" \" + l + (c[i] !== 1 ? \"'S\" : \"\");\n    item.push([a, text.length]);\n    text += i === L.length - 1 ? \".\" : i === L.length - 2 ? \" \" : \", \";\n  });\n  return { text, item };\n}\nfunction tally(text, L) {\n  const n = new Array(26).fill(0);\n  for (let i = 0; i \u003c text.length; i++) {\n    const k = text.charCodeAt(i) - 65;\n    if (k >= 0 && k \u003c 26) n[k]++;\n  }\n  return L.map((l) => n[l.charCodeAt(0) - 65]);\n}\n// Parse a sentence back into opening words and claims, then check it.\nconst BOOK = SENTENCES.map((s, si) => {\n  const re = /([A-Z]+(?:-[A-Z]+)?) ([A-Z])(?:'S)?(?=[,.]| AND)/g;\n  const L = [], c = [];\n  let m, first = -1;\n  while ((m = re.exec(s))) {\n    if (!(m[1] in NUMBER)) continue;\n    if (first \u003c 0) first = m.index;\n    L.push(m[2]), c.push(NUMBER[m[1]]);\n  }\n  const pre = s.slice(0, first - 1), b = build(pre, L, c), n = tally(s, L);\n  if (b.text !== s) throw new Error(`sentence ${si} does not rebuild`);\n  for (let i = 0; i \u003c L.length; i++) if (n[i] !== c[i]) throw new Error(`sentence ${si} has ${n[i]} ${L[i]}, not ${c[i]}`);\n  for (const ch of AZ) if (s.includes(ch) && !L.includes(ch)) throw new Error(`sentence ${si} does not list ${ch}`);\n  return { pre, L, c };\n});\n\n// ---- Faces. 3 x 5 capitals from Typewriter, one bit per LED, rows from\n// the top; 5 x 7 capitals and figures from Photon Disk, and three signs.\nconst G35 = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\", \".\": \"000000000000010\", \",\": \"000000000010100\",\n  \"-\": \"000000111000000\", \"'\": \"010010000000000\",\n};\nconst G57 = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", C: \".###. #...# #.... #.... #.... #...# .###.\", D: \"####. #...# #...# #...# #...# #...# ####.\",\n  E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\", G: \".###. #...# #.... #.### #...# #...# .####\",\n  H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\", P: \"####. #...# #...# ####. #.... #.... #....\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\", S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\",\n  U: \"#...# #...# #...# #...# #...# #...# .###.\", V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\",\n  X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\", Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", 0: \".###. #...# #..## #.#.# ##..# #...# .###.\",\n  1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", 2: \".###. #...# ....# ...#. ..#.. .#... #####\", 3: \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\", 6: \"..##. .#... #.... ####. #...# #...# .###.\",\n  7: \"##### ....# ...#. ..#.. .#... .#... .#...\", 8: \".###. #...# #...# .###. #...# #...# .###.\", 9: \".###. #...# #...# .#### ....# ...#. .##..\",\n  \"\u003c\": \"...#. ..#.. .#... #.... .#... ..#.. ...#.\", \">\": \".#... ..#.. ...#. ....# ...#. ..#.. .#...\", \"=\": \"..... ..... ##### ..... ##### ..... .....\",\n};\nfor (const k in G57) G57[k] = G57[k].replace(/ /g, \"\");\n\nconst blend = (c1, c2, u) => [c1[0] + (c2[0] - c1[0]) * u, c1[1] + (c2[1] - c1[1]) * u, c1[2] + (c2[2] - c1[2]) * u];\nconst T_TYPE = 0.008, T_IN = 0.1, T_OCC = 0.035, T_V = 0.3, T_TRUE = 3, T_LOOP = 4, T_R0 = 1.5, T_RMIN = 1 / 240, MAXR = 3000;\n\nfunction wrap(s, text) {\n  // Break at spaces, or after a hyphen; 16 letters of 4 LEDs a line.\n  const pos = new Int16Array(text.length * 2).fill(-1);\n  let col = 0, line = 0, i = 0;\n  while (i \u003c text.length) {\n    let j = i;\n    while (j \u003c text.length && text[j] !== \" \" && !(j > i && text[j - 1] === \"-\")) j++;\n    if (col > 0 && col + (j - i) > 16) (line++), (col = 0);\n    for (let k = i; k \u003c j; k++) (pos[k * 2] = col++), (pos[k * 2 + 1] = line);\n    if (text[j] === \" \") (col++), j++;\n    i = j;\n  }\n  s.pos = pos;\n  s.lines = line + 1;\n}\n\nfunction setText(s, c) {\n  const b = BOOK[s.si], { text, item } = build(b.pre, b.L, c);\n  s.claim = c.slice();\n  s.text = text;\n  s.item = item;\n  s.count = tally(text, b.L);\n  s.itemOf = new Int8Array(text.length).fill(-1);\n  s.litAt = new Float32Array(text.length).fill(-9);\n  item.forEach(([a, e], i) => {\n    for (let k = a; k \u003c e; k++) s.itemOf[k] = i;\n  });\n  wrap(s, text);\n}\n\nfunction start(s, si, m) {\n  s.si = si;\n  s.m = m;\n  const b = BOOK[si], c = b.c.slice();\n  const vol = [];\n  b.L.forEach((l, i) => \"EFGHILNORSTUVWXY\".includes(l) && vol.push(i));\n  for (let k = 0; k \u003c m && vol.length; k++) {\n    const i = vol.splice(floor(Math.random() * vol.length), 1)[0];\n    let d = 0;\n    while (!d || c[i] + d \u003c 1) d = (Math.random() \u003c 0.5 ? -1 : 1) * (1 + floor(Math.random() * 3));\n    c[i] += d;\n  }\n  setText(s, c);\n  s.changedAt = new Float32Array(s.text.length).fill(-9);\n  s.phase = 0; // 0 check, 1 true, 2 chase, 3 loop\n  s.t = 0;\n  s.li = 0;\n  s.sub = -1; // -1 writing, 0 intro, 1 count, 2 verdict\n  s.typed = 0;\n  s.k = 0;\n  s.done = new Int16Array(b.L.length).fill(-1);\n  s.occ = occ(s, 0);\n  s.round = 0;\n  s.seen = null;\n  s.born = s.clock;\n}\nfunction occ(s, li) {\n  const l = BOOK[s.si].L[li], o = [];\n  for (let i = 0; i \u003c s.text.length; i++) if (s.text[i] === l) o.push(i);\n  return o;\n}\nconst keyOf = (c) => c.join(\",\");\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.clock = 0;\n  s.kS = -1;\n  s.kM = -1;\n  s.fb = new Uint8ClampedArray(W * H * 3);\n  start(s, 0, 0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kn = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = kn[0] || 0;\n  const rate = cl(kn[1] == null ? 2 : kn[1], 0.2, 3) / 2;\n  const si = round(cl(kn[2] || 0, 0, 2)), m = round(cl(kn[3] == null ? 0.06 : kn[3], 0, 1) * 4);\n  if (si !== s.kS || m !== s.kM) {\n    s.kS = si;\n    s.kM = m;\n    start(s, si, m);\n  }\n  s.clock += dt;\n  s.t += dt * rate;\n  const L = BOOK[s.si].L;\n  for (let guard = 0; guard \u003c 24; guard++) {\n    if (s.phase === 0) {\n      if (s.sub === -1) {\n        const n = min(s.text.length - s.typed, floor(s.t / T_TYPE));\n        s.typed += n;\n        s.t -= n * T_TYPE;\n        if (s.typed \u003c s.text.length) break;\n        s.sub = 0;\n      } else if (s.sub === 0) {\n        if (s.t \u003c T_IN) break;\n        s.t -= T_IN;\n        s.sub = 1;\n      } else if (s.sub === 1) {\n        if (s.k >= s.occ.length) {\n          s.sub = 2;\n          s.done[s.li] = s.k;\n          continue;\n        }\n        if (s.t \u003c T_OCC) break;\n        s.t -= T_OCC;\n        s.litAt[s.occ[s.k++]] = s.clock;\n      } else {\n        if (s.t \u003c T_V) break;\n        s.t -= T_V;\n        s.li++;\n        if (s.li >= L.length) {\n          s.t = 0;\n          if (s.done.every((n, i) => n === s.claim[i])) s.phase = 1;\n          else (s.phase = 2), (s.seen = new Map([[keyOf(s.claim), 0]])), (s.round = 0);\n        } else (s.sub = 0), (s.k = 0), (s.occ = occ(s, s.li));\n      }\n    } else if (s.phase === 1 || s.phase === 3) {\n      // Caught in a loop, the rewriting goes on round it, 8 a second.\n      if (s.phase === 3 && s.period && s.t >= s.next) {\n        const prev = s.claim, c = s.count.slice();\n        setText(s, c);\n        s.changedAt = new Float32Array(s.text.length).fill(-9);\n        s.item.forEach(([a, e], i) => {\n          if (c[i] !== prev[i]) for (let k = a; k \u003c e; k++) s.changedAt[k] = s.clock;\n        });\n        s.next += 0.125;\n        continue;\n      }\n      if (s.t \u003c (s.phase === 1 ? T_TRUE : T_LOOP)) break;\n      start(s, (s.si + 1) % 3, s.m);\n    } else {\n      const d = max(T_RMIN, T_R0 * Math.pow(0.8, s.round));\n      if (s.t \u003c d) break;\n      s.t -= d;\n      // Rewrite every claim with the count it has.\n      const prev = s.claim, c = s.count.slice();\n      setText(s, c);\n      s.round++;\n      s.changedAt = new Float32Array(s.text.length).fill(-9);\n      s.item.forEach(([a, e], i) => {\n        if (c[i] !== prev[i]) for (let k = a; k \u003c e; k++) s.changedAt[k] = s.clock;\n      });\n      const key = keyOf(c);\n      if (s.count.every((n, i) => n === c[i])) (s.phase = 1), (s.t = 0), (s.verdict = \"TRUE\");\n      else if (s.seen.has(key)) (s.phase = 3), (s.t = 0), (s.next = 0.125), (s.period = s.round - s.seen.get(key));\n      else if (s.round >= MAXR) (s.phase = 3), (s.t = 0), (s.period = 0);\n      else s.seen.set(key, s.round);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const fb = s.fb, b = BOOK[s.si], L = b.L, nL = L.length;\n  // Both colours stay clear of red, which marks a false claim.\n  const hk = 0.11 + 0.34 * cl(s.hue, 0, 1), hc = hk + 0.41;\n  const CNT = hsv(hc, 0.8, 255), CLM = hsv(hk, 0.85, 255), TXT = hsv(hk, 0.3, 155), TONE = blend(TXT, CNT, 0.42), RED = [255, 34, 30], WHT = [255, 255, 255];\n  const BG = hsv(hc, 0.7, 10);\n  for (let i = 0; i \u003c W * H; i++) (fb[i * 3] = BG[0]), (fb[i * 3 + 1] = BG[1]), (fb[i * 3 + 2] = BG[2]);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    fb[i] = c[0] * a;\n    fb[i + 1] = c[1] * a;\n    fb[i + 2] = c[2] * a;\n  };\n  const fadeIn = cl((s.clock - s.born) / 0.4, 0, 1);\n  const pitch = s.lines * 6 \u003c= 102 ? 6 : floor(102 / s.lines);\n  const checking = s.phase === 0, writing = checking && s.sub === -1, cur = checking && !writing ? s.li : -1;\n  // Which claims are known false.\n  const bad = new Uint8Array(nL);\n  for (let i = 0; i \u003c nL; i++) {\n    if (checking) bad[i] = s.done[i] >= 0 && (i \u003c s.li || s.sub === 2) && s.done[i] !== s.claim[i] ? 1 : 0;\n    else bad[i] = s.count[i] !== s.claim[i] ? 1 : 0;\n  }\n  const sweep = s.phase === 1 ? s.t * 60 : -99;\n  // ---- The sentence.\n  const shown = writing ? s.typed : s.text.length;\n  for (let ci = 0; ci \u003c shown; ci++) {\n    const ch = s.text[ci], g = G35[ch];\n    if (!g) continue;\n    const X = s.pos[ci * 2] * 4, Y = s.pos[ci * 2 + 1] * pitch;\n    const it = s.itemOf[ci], lit = s.litAt[ci];\n    let col = lit > -9 ? TONE : TXT;\n    if (it >= 0 && bad[it]) col = RED;\n    if (it === cur && cur >= 0) col = CLM;\n    if (checking && ch === L[cur] && lit > -9) {\n      const age = s.clock - lit;\n      col = blend(CNT, WHT, cl(1 - age / 0.15, 0, 1) * 0.8);\n      if (s.sub === 2) col = blend(col, TONE, cl(s.t / T_V, 0, 1));\n    }\n    if (writing && shown - ci \u003c 6) col = blend(col, WHT, 1 - (shown - ci) / 6);\n    const ch2 = s.clock - s.changedAt[ci];\n    if (ch2 \u003c 0.35) col = blend(col, WHT, 1 - ch2 / 0.35);\n    if (sweep > -99) {\n      const d = abs(Y - sweep + 20);\n      if (d \u003c 20) col = blend(col, CNT, (1 - d / 20) * 0.85);\n    }\n    for (let y = 0; y \u003c 5; y++)\n      for (let x = 0; x \u003c 3; x++) if (g.charCodeAt(y * 3 + x) === 49) put(X + x, Y + y, col, fadeIn);\n  }\n  // ---- The tally line: letter, count, sign, claim; or the round; or the\n  // verdict.\n  let line = [];\n  if (writing) line = [];\n  else if (checking) {\n    const n = s.sub === 2 ? s.done[cur] : s.k, c = s.claim[cur];\n    const sign = n \u003c c ? \"\u003c\" : n > c ? \">\" : \"=\";\n    const sc = s.sub === 2 ? (n === c ? CNT : RED) : n > c ? RED : WHT;\n    line = [[L[cur], TXT], [\" \", TXT], ...[...String(n).padStart(2, \" \")].map((d) => [d, CNT]), [sign, sc], ...[...String(c)].map((d) => [d, CLM])];\n  } else if (s.phase === 2) line = s.round ? [...\"ROUND \"].map((d) => [d, TXT]).concat([...String(s.round)].map((d) => [d, CLM])) : [...\"FALSE\"].map((d) => [d, RED]);\n  else if (s.phase === 1) line = [...\"TRUE\"].map((d) => [d, CNT]);\n  else if (s.period) line = [...\"LOOP \"].map((d) => [d, RED]).concat([...String(s.period)].map((d) => [d, CLM]));\n  else line = [...\"ROUND \"].map((d) => [d, TXT]).concat([...String(s.round)].map((d) => [d, RED]));\n  const x0 = floor((W - (line.length * 6 - 1)) / 2);\n  line.forEach(([d, col], k) => {\n    const g = G57[d];\n    if (!g) return;\n    for (let y = 0; y \u003c 7; y++) for (let x = 0; x \u003c 5; x++) if (g[y * 5 + x] === \"#\") put(x0 + k * 6 + x, 104 + y, col, fadeIn);\n  });\n  // ---- The bars: a dim column as tall as each claim, a bright one as tall\n  // as the count so far, half an LED a letter.\n  const bx = floor((W - (nL * 3 - 1)) / 2);\n  for (let i = 0; i \u003c nL; i++) {\n    const c = s.claim[i];\n    let n = s.count[i];\n    if (checking) n = i \u003c cur ? s.done[i] : i === cur ? (s.sub === 2 ? s.done[i] : s.k) : 0;\n    const hi = i === cur ? 1 : 0.75;\n    const fill = bad[i] || (checking && i === cur && n > c) ? RED : CNT;\n    if (writing && s.item[i][1] > s.typed) continue;\n    const top = Math.ceil(c / 2) - 1;\n    for (let r = 0; r \u003c 16; r++) {\n      const nn = cl(n / 2 - r, 0, 1);\n      let col = null, a = 0;\n      if (r === top) (col = n === c ? blend(CNT, WHT, 0.5) : n > c ? RED : CLM), (a = i === cur ? 1 : 0.8);\n      else if (nn > 0) (col = fill), (a = (0.35 + 0.65 * nn) * hi);\n      else if (r \u003c top) (col = CLM), (a = i === cur ? 0.16 : 0.09);\n      if (col) for (let x = 0; x \u003c 2; x++) put(bx + i * 3 + x, 127 - r, col, a * fadeIn);\n    }\n    if (c > 32 || n > 32) for (let x = 0; x \u003c 2; x++) put(bx + i * 3 + x, 111, RED, fadeIn);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, fb[i] | 0, fb[i + 1] | 0, fb[i + 2] | 0);\n    }\n}\n","biliteral-cipher":"// ===== Patternflow pattern =====\n// Title:   Biliteral Cipher\n// Family:  type\n// Idea:    A cover sentence is set in capitals ten LEDs wide, five to a line, each one in fount a or fount b, two founts that differ by a slant and a little weight the eye passes over; a reading light then goes along the letters one by one, writes a small a or b under each, and every five of those spell one letter of Bacon's 24-letter alphabet, set below in light until the hidden word is complete, holds, and the next sentence is typed.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Francis Bacon's biliteral cipher in De Augmentis Scientiarum (1623), with his own example, FUGE hidden in MANERE TE VOLO DONEC VENERO; the 5 by 7 capitals of Photon Disk (pattern round 70) doubled; pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Message=0..4, Tell=0..1\n//\n// Knob 1: Hue. The colour of the reading light, the a and b marks and the hidden word, cyan at 0, violet at 0.25, red at 0.5, yellow-green at 0.75; the cover letters take a pale tint from the opposite side of the wheel, ivory at 0.\n// Knob 2: Speed. At 2 a letter is typed every 0.07 s and read every 0.3 s, a hidden letter is set in 0.45 s and the finished word holds 3 s, so Bacon's sentence takes 13 s from first letter to the next sentence. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Message. Which sentence is set first; the rest follow in turn. 0 Bacon's MANERE TE VOLO DONEC VENERO hiding FUGE, 1 THE SEA IS CALM AND STILL TODAY hiding STORM, 2 SAY NOTHING TO ANYONE YET hiding TELL, 3 WE ARE ALL QUITE WELL HERE hiding HELP, 4 BURN THIS LETTER AT ONCE hiding KEEP. Turning it sets the new sentence at once.\n// Knob 4: Tell. How far fount b strays from fount a. At 0 they are the same LEDs and only the reading light knows; at the opening 0.06 a b letter leans 0.22 LED over its 14 rows and is 0.12 LED heavier, a change of a few levels on its edge LEDs; at 0.5 it leans 1.8 LEDs, is 1 LED heavier and the b letters read as a faint italic; at 1 it leans 3.6 LEDs and is 2 LEDs heavier, a bold italic, and the hidden word can be read off the page without the light.\n\n// Bacon's cipher writes each letter of the hidden word as five symbols,\n// a or b, A = aaaaa through Z = babbb, with I and J sharing abaaa and U and\n// V sharing baabb, and prints a cover text of at least five times as many\n// letters in two founts: each cover letter in fount a stands for a, each in\n// fount b for b. Letters past the last full group are nulls, set in either\n// fount and not read; here they are drawn a little dimmer. Bacon's own\n// example hides FUGE (flee) in MANERE TE VOLO DONEC VENERO (stay until I\n// come): 23 letters, 20 read, ERO left over.\n//\n// The cover letters here are the 5 by 7 capitals of Photon Disk drawn at\n// two LEDs a cell, 10 wide and 14 tall with 3 LEDs between them, so five\n// fill 62 of the 64 columns: one group of five to a line. Fount b is the\n// same bitmap sheared and thickened, sampled 4 x 4 times a LED, so at a\n// small Tell it differs from fount a only in how bright its edge LEDs are.\n// A dot halfway up the gap marks the end of a word, as Roman inscriptions\n// did, since a line of five has no room for word spaces.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, abs, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- 5 x 7 capitals from Photon Disk, rows from the top.\nconst G57 = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", B: \"####. #...# #...# ####. #...# #...# ####.\", C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\", E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\",\n  G: \".###. #...# #.... #.### #...# #...# .####\", H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  J: \"..### ...#. ...#. ...#. ...#. #..#. .##..\", K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  M: \"#...# ##.## #.#.# #.#.# #...# #...# #...#\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\",\n  P: \"####. #...# #...# ####. #.... #.... #....\", Q: \".###. #...# #...# #...# #.#.# #..#. .##.#\", R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\", X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\",\n};\nconst BITS = {};\nfor (const k in G57) {\n  const s = G57[k].replace(/ /g, \"\"), b = new Uint8Array(35);\n  for (let i = 0; i \u003c 35; i++) b[i] = s[i] === \"#\" ? 1 : 0;\n  BITS[k] = b;\n}\n// The marks, a 3 by 5 a and b drawn for this pattern.\nconst MARK = [\"....###.##.#.##\".replace(/\\./g, \"0\").replace(/#/g, \"1\"), \"#..#..##.#.###.\".replace(/\\./g, \"0\").replace(/#/g, \"1\")];\n// Bacon's alphabet of 24: J reads as I, V as U.\nconst ABC = \"ABCDEFGHIKLMNOPQRSTUWXYZ\";\nconst code = (ch) => ABC.indexOf(ch === \"J\" ? \"I\" : ch === \"V\" ? \"U\" : ch);\n\nconst MESSAGES = [\n  [\"MANERE TE VOLO DONEC VENERO\", \"FUGE\"],\n  [\"THE SEA IS CALM AND STILL TODAY\", \"STORM\"],\n  [\"SAY NOTHING TO ANYONE YET\", \"TELL\"],\n  [\"WE ARE ALL QUITE WELL HERE\", \"HELP\"],\n  [\"BURN THIS LETTER AT ONCE\", \"KEEP\"],\n];\n\n// ---- Layout: a letter is 10 x 14 LEDs in a cell 13 wide; a line is 22\n// rows, the letter, a blank row, the 5-row mark and two blank rows.\nconst CX = (c) => 1 + 13 * c, CY = (r) => 1 + 22 * r, HY = 112, RULE = 110;\nconst GW = 16, GOX = 3; // glyph raster: columns -3..12 of the cell\n\n// Coverage of one glyph in fount b at a given tell, 16 x 14 LEDs. Shear s\n// leans the top s/2 right and the foot s/2 left; weight w widens every\n// stroke by w, half to each side.\nfunction raster(ch, t) {\n  const bm = BITS[ch], out = new Float32Array(GW * 14);\n  const s = 3.6 * t, w = 2 * t;\n  const on = (x, y) => {\n    const c = floor(x / 2), r = floor(y / 2);\n    return c >= 0 && c \u003c 5 && r >= 0 && r \u003c 7 && bm[r * 5 + c] === 1;\n  };\n  for (let y = 0; y \u003c 14; y++)\n    for (let gx = 0; gx \u003c GW; gx++) {\n      let n = 0;\n      for (let j = 0; j \u003c 4; j++) {\n        const Y = y + (j + 0.5) / 4, sh = s * (0.5 - Y / 14);\n        for (let i = 0; i \u003c 4; i++) {\n          const x = gx - GOX + (i + 0.5) / 4 - sh;\n          if (on(x, Y) || (w > 0 && (on(x - w / 2, Y) || on(x + w / 2, Y)))) n++;\n        }\n      }\n      out[y * GW + gx] = n / 16;\n    }\n  return out;\n}\n\nfunction prepare(s, mi) {\n  const [cover, hidden] = MESSAGES[mi];\n  const letters = [], dots = [];\n  for (const ch of cover) {\n    if (ch === \" \") {\n      if (letters.length % 5) dots.push(letters.length - 1);\n    } else letters.push(ch);\n  }\n  const n = min(hidden.length, floor(letters.length / 5), 5);\n  const fount = letters.map(() => (Math.random() \u003c 0.5 ? 1 : 0));\n  for (let i = 0; i \u003c n; i++) {\n    const v = code(hidden[i]);\n    for (let k = 0; k \u003c 5; k++) fount[i * 5 + k] = (v >> (4 - k)) & 1;\n  }\n  // Read it back the way a decipherer would, so a wrong table cannot pass.\n  for (let i = 0; i \u003c n; i++) {\n    let v = 0;\n    for (let k = 0; k \u003c 5; k++) v = v * 2 + fount[i * 5 + k];\n    if (ABC[v] !== hidden[i]) throw new Error(`message ${mi} letter ${i} reads ${ABC[v]}`);\n  }\n  s.mi = mi;\n  s.letters = letters.slice(0, 25);\n  s.fount = fount;\n  s.dots = dots;\n  s.hidden = hidden.slice(0, n);\n  s.n = n;\n  s.phase = 0; // 0 type, 1 read, 2 set, 3 hold, 4 clear\n  s.t = 0;\n  s.typed = 0;\n  s.read = 0;\n  s.set = 0;\n  s.born = letters.map(() => -1);\n  s.markAt = letters.map(() => -1);\n  s.setAt = [-1, -1, -1, -1, -1];\n}\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.clock = 0;\n  s.knobMsg = -1;\n  s.cache = {};\n  s.tellKey = -1;\n  s.fb = new Uint8ClampedArray(W * H * 3);\n  prepare(s, 0);\n}\n\nconst T_TYPE = 0.07, T_READ = 0.3, T_SET = 0.45, T_HOLD = 3, T_CLEAR = 0.6;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  s.tell = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  const mi = round(cl(k[2] || 0, 0, 4));\n  if (mi !== s.knobMsg) {\n    s.knobMsg = mi;\n    prepare(s, mi);\n  }\n  s.clock += dt;\n  s.t += dt * rate;\n  const L = s.letters.length, R = s.n * 5;\n  for (let guard = 0; guard \u003c 40; guard++) {\n    if (s.phase === 0) {\n      if (s.t \u003c T_TYPE) break;\n      s.t -= T_TYPE;\n      s.born[s.typed++] = s.clock;\n      if (s.typed >= L) (s.phase = 1), (s.t = -0.25);\n    } else if (s.phase === 1) {\n      if (s.t \u003c T_READ) break;\n      s.t -= T_READ;\n      if (s.markAt[s.read] \u003c 0) s.markAt[s.read] = s.clock;\n      s.read++;\n      if (s.read % 5 === 0) (s.phase = 2), (s.setAt[s.read / 5 - 1] = s.clock);\n    } else if (s.phase === 2) {\n      if (s.t \u003c T_SET) break;\n      s.t -= T_SET;\n      s.set++;\n      s.phase = s.read >= R ? 3 : 1;\n    } else if (s.phase === 3) {\n      if (s.t \u003c T_HOLD) break;\n      s.t -= T_HOLD;\n      s.phase = 4;\n    } else {\n      if (s.t \u003c T_CLEAR) break;\n      prepare(s, (s.mi + 1) % MESSAGES.length);\n    }\n  }\n  // The mark under a letter is written 60% of the way through its reading.\n  if (s.phase === 1 && s.read \u003c R && s.t > 0.6 * T_READ && s.markAt[s.read] \u003c 0) s.markAt[s.read] = s.clock;\n}\n\nfunction glyphOf(s, ch, b) {\n  const key = b ? round(s.tell * 400) : 0;\n  if (b && key !== s.tellKey) (s.cache = {}), (s.tellKey = key);\n  const id = ch + (b ? \"b\" : \"a\");\n  if (!s.cache[id]) s.cache[id] = raster(ch, b ? key / 400 : 0);\n  return s.cache[id];\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const fb = s.fb;\n  const ha = 0.5 + s.hue;\n  const acc = hsv(ha, 0.85, 255), ink = hsv(ha + 0.6, 0.24, 225), bg = hsv(ha, 0.6, 7);\n  for (let i = 0; i \u003c W * H; i++) (fb[i * 3] = bg[0]), (fb[i * 3 + 1] = bg[1]), (fb[i * 3 + 2] = bg[2]);\n  const add = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n    const i = (y * W + x) * 3;\n    fb[i] = max(fb[i], c[0] * a);\n    fb[i + 1] = max(fb[i + 1], c[1] * a);\n    fb[i + 2] = max(fb[i + 2], c[2] * a);\n  };\n  const mix = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n    const i = (y * W + x) * 3;\n    fb[i] += (c[0] - fb[i]) * a;\n    fb[i + 1] += (c[1] - fb[i + 1]) * a;\n    fb[i + 2] += (c[2] - fb[i + 2]) * a;\n  };\n  const fade = s.phase === 4 ? 1 - cl(s.t / T_CLEAR, 0, 1) : 1;\n  const R = s.n * 5;\n  const reading = s.phase === 1 && s.t >= 0 && s.read \u003c R ? s.read : -1;\n  const p = reading >= 0 ? cl(s.t / T_READ, 0, 1) : 0;\n\n  // The reading light: a dim box behind the letter and a bright line\n  // crossing it left to right.\n  if (reading >= 0) {\n    const x0 = CX(reading % 5), y0 = CY(floor(reading / 5));\n    const env = sin(PI * cl(p * 1.15, 0, 1)) * 0.22 + 0.06;\n    for (let y = y0 - 1; y \u003c= y0 + 14; y++) for (let x = x0 - 2; x \u003c= x0 + 11; x++) add(x, y, acc, env);\n  }\n  // Cover letters.\n  for (let j = 0; j \u003c s.typed; j++) {\n    const c = j % 5, r = floor(j / 5), x0 = CX(c), y0 = CY(r);\n    const g = glyphOf(s, s.letters[j], s.fount[j]);\n    const age = s.clock - s.born[j], flash = cl(1 - age / 0.25, 0, 1);\n    let col = ink, lv = fade;\n    if (j >= R) lv *= 0.62;\n    // A group glows as its letter is set below; in the hold the b letters\n    // keep a tint.\n    const sa = j \u003c R ? s.setAt[floor(j / 5)] : -1;\n    let u = sa >= 0 ? 0.4 * cl(1 - (s.clock - sa) / 0.6, 0, 1) : 0;\n    if (s.phase === 3 && s.fount[j] && j \u003c R) u = max(u, 0.3);\n    if (u > 0) col = [ink[0] + (acc[0] - ink[0]) * u, ink[1] + (acc[1] - ink[1]) * u, ink[2] + (acc[2] - ink[2]) * u];\n    const scan = j === reading ? x0 - 1 + p * 12 : -99;\n    for (let y = 0; y \u003c 14; y++)\n      for (let gx = 0; gx \u003c GW; gx++) {\n        const v = g[y * GW + gx];\n        if (v \u003c= 0) continue;\n        const X = x0 + gx - GOX, Y = y0 + y;\n        mix(X, Y, col, v * lv);\n        if (flash > 0) mix(X, Y, [255, 255, 255], v * flash * 0.8);\n        const d = abs(X - scan);\n        if (d \u003c 1.5) mix(X, Y, [acc[0] * 0.5 + 127, acc[1] * 0.5 + 127, acc[2] * 0.5 + 127], v * (1 - d / 1.5));\n      }\n  }\n  if (reading >= 0) {\n    const x = round(CX(reading % 5) - 1 + p * 12), y0 = CY(floor(reading / 5));\n    for (let y = y0 - 1; y \u003c= y0 + 14; y++) add(x, y, acc, 0.55);\n  }\n  // Word dots in the gaps.\n  for (const j of s.dots)\n    if (j + 1 \u003c s.typed && j % 5 \u003c 4) {\n      const x = CX(j % 5) + 11, y = CY(floor(j / 5)) + 6;\n      add(x, y, ink, 0.5 * fade), add(x, y + 1, ink, 0.5 * fade);\n    }\n  // The a and b marks.\n  for (let j = 0; j \u003c R; j++) {\n    if (s.markAt[j] \u003c 0) continue;\n    const age = s.clock - s.markAt[j], m = MARK[s.fount[j]], x0 = CX(j % 5) + 3, y0 = CY(floor(j / 5)) + 15;\n    const grp = floor(j / 5), sa = s.setAt[grp];\n    let lv = cl(age / 0.12, 0, 1) * 0.78;\n    if (sa >= 0) lv = 0.78 + 0.22 * cl(1 - abs(s.clock - sa - 0.2) / 0.3, 0, 1);\n    for (let y = 0; y \u003c 5; y++) for (let x = 0; x \u003c 3; x++) if (m[y * 3 + x] === \"1\") add(x0 + x, y0 + y, acc, lv * fade);\n  }\n  // The rule over the hidden word, and the word.\n  for (let x = 2; x \u003c W - 2; x++) add(x, RULE, acc, 0.13 * fade);\n  for (let i = 0; i \u003c s.n; i++) {\n    if (s.setAt[i] \u003c 0) continue;\n    const age = s.clock - s.setAt[i], g = glyphOf(s, s.hidden[i], 0), x0 = CX(i);\n    const grow = cl(age / 0.3, 0, 1), flash = cl(1 - age / 0.5, 0, 1);\n    for (let y = 0; y \u003c 14; y++) {\n      if (y > grow * 14 + 0.5) continue;\n      for (let gx = 0; gx \u003c GW; gx++) {\n        const v = g[y * GW + gx];\n        if (v \u003c= 0) continue;\n        mix(x0 + gx - GOX, HY + y, acc, v * fade);\n        if (flash > 0) mix(x0 + gx - GOX, HY + y, [255, 255, 255], v * flash * 0.7 * fade);\n      }\n    }\n    // A soft glow under a freshly set letter.\n    if (flash > 0) for (let y = HY - 1; y \u003c= HY + 14; y++) for (let x = x0 - 1; x \u003c= x0 + 10; x++) add(x, y, acc, 0.12 * flash * fade);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, fb[i] | 0, fb[i + 1] | 0, fb[i + 2] | 0);\n    }\n}\n","clothesline":"// ===== Patternflow pattern =====\n// Title:   Clothesline\n// Family:  type\n// Idea:    Four ropes sag from wall to wall down the tall panel with ten letter cards pegged on them, 바람이 / 분다 / 살아야 / 겠다, and gusts cross the panel from the left so the cards swing on their pegs one after another like pendulums and twist on the line, the ropes lift and bob under them, and every card falls back to hanging straight once the gust has gone.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 72; the text is «Le vent se lève, il faut tenter de vivre» from Paul Valéry's Le Cimetière marin (1920) in the Korean it is usually given; the mean wind from the Beaufort scale (Francis Beaufort, 1805) by v = 0.836 B^(3/2) m/s; the Hangul syllables drawn as strokes for this pattern\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wind=2..7, Gust=0..1\n//\n// Knob 1: Hue. The card colour, the ink always cream: sea green at 0, azure at 0.25, blue violet at 0.5, magenta at 0.75 and rose red at 1, each card a little off its neighbours. The wheel skips orange, which on a dim card reads brown.\n// Knob 2: Speed. The time scale. At 2 a card left to itself swings once a second and a gust crosses the 64 columns in 1.6 s in a light breeze; at 1 everything is half as fast, at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Wind. The mean wind in Beaufort force. At the opening 2, a light breeze of 2.4 m/s, the cards lean 7 degrees and the gusts swing them to 20 or 35 and back past straight; at 4, 6.7 m/s, they lean 45 degrees; at 7, a near gale of 15.5 m/s, they fly 79 degrees out, almost flat, and the ropes pull from a 5-LED sag to 1.\n// Knob 4: Gust. Turbulence on top of the gust fronts. At 0 only the fronts, one every 1.5 to 3 s; at the opening 0.06 a little flutter; at 1 the fronts come twice as often and half as strong again, eddies throw neighbouring cards opposite ways and the cards twist round their pegs until some turn their backs, where the ink shows through mirrored.\n// Buttons: K1 tap sends a strong gust across the whole line.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sin, cos, exp, sqrt, tanh, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The cards' syllables, drawn as strokes in an 11 by 13 box, one unit\n// an LED: polylines, and ellipses [cx, cy, rx, ry] for the ㅇ. Each vowel\n// stands at column 8, each initial in columns 0 to 5 beside it.\nconst A_ = [[[8, 0], [8, 12]], [[8, 6], [10, 6]]];\nconst O_ = { e: [2.5, 6, 2.5, 3.6] };\nconst GLYPHS = {\n  바: [[[0, 1], [0, 11]], [[5, 1], [5, 11]], [[0, 6], [5, 6]], [[0, 11], [5, 11]], ...A_],\n  람: [[[0, 0], [5, 0], [5, 2], [0, 2], [0, 4], [5, 4]], [[8, 0], [8, 6]], [[8, 3], [10, 3]], [[1, 8], [9, 8], [9, 12], [1, 12], [1, 8]]],\n  이: [O_, [[8, 0], [8, 12]]],\n  분: [[[1, 0], [1, 4]], [[9, 0], [9, 4]], [[1, 2], [9, 2]], [[1, 4], [9, 4]], [[0, 6.5], [10, 6.5]], [[5, 6.5], [5, 8.5]], [[1, 10], [1, 12], [9, 12]]],\n  다: [[[5, 1], [0, 1], [0, 11], [5, 11]], ...A_],\n  살: [[[2.6, 0], [0, 5]], [[2.6, 0.5], [5.2, 5]], [[8, 0], [8, 6]], [[8, 3], [10, 3]], [[1, 8], [9, 8], [9, 10], [1, 10], [1, 12], [9, 12]]],\n  아: [O_, ...A_],\n  야: [O_, [[8, 0], [8, 12]], [[8, 4], [10, 4]], [[8, 8], [10, 8]]],\n  겠: [[[0, 0], [3.5, 0], [3.5, 5]], [[5, 3], [7, 3]], [[7, 0], [7, 6.5]], [[10, 0], [10, 7]], [[2.5, 8.5], [0.5, 12]], [[2.5, 8.5], [4.5, 12]], [[7.5, 8.5], [5.5, 12]], [[7.5, 8.5], [9.5, 12]]],\n};\n\n// Each glyph's distance field, 4 samples an LED over x -2..12 and y -2..14,\n// so a card turned to any angle samples its strokes smoothly.\nconst FS = 4, FX0 = -2, FY0 = -2, FW = 14 * FS + 1, FH = 16 * FS + 1;\nfunction segDist(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy, t = l ? cl(((px - ax) * dx + (py - ay) * dy) / l, 0, 1) : 0;\n  const ex = px - ax - t * dx, ey = py - ay - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\nconst FIELD = {};\nfor (const key in GLYPHS) {\n  const F = new Float32Array(FW * FH);\n  for (let j = 0; j \u003c FH; j++)\n    for (let i = 0; i \u003c FW; i++) {\n      const x = FX0 + i / FS, y = FY0 + j / FS;\n      let d = 99;\n      for (const s of GLYPHS[key]) {\n        if (s.e) {\n          const [cx, cy, rx, ry] = s.e, ux = (x - cx) / rx, uy = (y - cy) / ry, r = sqrt(ux * ux + uy * uy);\n          // |r - 1| over the gradient of r: the distance to the ellipse near it.\n          const gx = ux / rx, gy = uy / ry, gl = sqrt(gx * gx + gy * gy);\n          d = min(d, gl > 1e-6 ? (abs(r - 1) * r) / gl : min(rx, ry));\n        } else for (let k = 1; k \u003c s.length; k++) d = min(d, segDist(x, y, s[k - 1][0], s[k - 1][1], s[k][0], s[k][1]));\n      }\n      F[j * FW + i] = d;\n    }\n  FIELD[key] = F;\n}\nfunction fieldAt(F, gx, gy) {\n  const fx = (gx - FX0) * FS, fy = (gy - FY0) * FS;\n  if (fx \u003c 0 || fy \u003c 0 || fx >= FW - 1 || fy >= FH - 1) return 99;\n  const i = floor(fx), j = floor(fy), u = fx - i, v = fy - j, o = j * FW + i;\n  return (F[o] * (1 - u) + F[o + 1] * u) * (1 - v) + (F[o + FW] * (1 - u) + F[o + FW + 1] * u) * v;\n}\n\n// ---- The line. Four ropes 32 rows apart, anchored at both walls with a\n// 5-LED sag; the cards 16 by 18, hung from a peg at the middle of the top.\nconst ROPES = [\n  { y: 5, cards: \"바람이\" },\n  { y: 37, cards: \"분다\" },\n  { y: 69, cards: \"살아야\" },\n  { y: 101, cards: \"겠다\" },\n];\nconst SAG = 5, CW = 8, CT = 1, CB = 19, GX = 5, GY = 4.5;\n// A card about its peg: centre of mass 10 LEDs down, J = I / m in LED^2.\nconst L = (CT + CB) / 2, J = (2 * CW) ** 2 / 12 + (CB - CT) ** 2 / 12 + L * L;\n// A swing of 1 s at small angles: g l / J = (2 pi)^2.\nconst G = (4 * PI * PI * J) / L;\n// Drag: tan(lean) = 0.022 v^2 for v in m/s, and 10 LED/s to a m/s.\nconst Q = 10, KD = (0.022 * G) / (Q * Q);\n\n// The rope hangs in a catenary, y = c cosh(x / c) about its lowest point:\n// a 5-LED sag over the 63 columns between the hooks makes c = 99, a pull\n// along the rope equal to the weight of 99 LEDs of it. A gust lifting it\n// shrinks the sag in the same shape, and tips it in a sine of the span.\nconst CC = 99, CH = Math.cosh(31.5 / CC) - 1;\nconst cat = (x) => (Math.cosh(31.5 / CC) - Math.cosh((x - 31.5) / CC)) / CH;\nconst tip = (x) => sin((2 * PI * x) / 63);\nfunction ropeY(r, x) {\n  return r.y + (SAG - r.b1) * cat(x) - r.b2 * tip(x);\n}\n\nexport function setup(params) {\n  const ropes = ROPES.map((R) => {\n    const n = [...R.cards].length, cards = [];\n    [...R.cards].forEach((ch, i) => {\n      const x = 32 + (i - (n - 1) / 2) * 20 + (Math.random() - 0.5) * 2;\n      cards.push({ ch, x, th: (Math.random() - 0.5) * 0.1, w: 0, ph: 0, pw: 0, dh: (Math.random() - 0.5) * 0.08 });\n    });\n    return { y: R.y, cards, b1: 0, v1: 0, a1: 0, b2: 0, v2: 0, a2: 0 };\n  });\n  params.s = { t: 0, ropes, gusts: [], next: 0.3, ph: [0, 1, 2, 3, 4, 5].map(() => Math.random() * 2 * PI), warm: false, hue: 0, speed: 2, B: 2, V: 24, gust: 0.06, F: new Float32Array(W * H * 3) };\n}\n\n// The wind across the panel, LED/s rightward, at sim time t.\nfunction windAt(S, x, y) {\n  const V = S.V, t = S.t;\n  let g = 0;\n  for (const q of S.gusts) {\n    const u = (x - q.x + 0.18 * (y - 64)) / q.s, v = (y - q.yc) / 90;\n    g += q.a * exp(-u * u - v * v);\n  }\n  const P = S.ph, k = S.gust;\n  // Turbulence: four drifting waves of different sizes.\n  const tu =\n    0.45 * sin(0.21 * (x - 0.8 * V * t) + 0.05 * y + P[0]) +\n    0.3 * sin(0.37 * (x - 0.8 * V * t) - 0.11 * y + 2.3 * t + P[1]) +\n    0.25 * sin(0.6 * x - 0.17 * y - 3.7 * t + P[2]) +\n    0.2 * sin(0.09 * y + 1.3 * t + P[3]);\n  return V * (1 + g + 1.6 * k * tu);\n}\n\nfunction step(S, h) {\n  S.t += h;\n  const V = S.V, k = S.gust;\n  // Gust fronts: born left of the panel every 1.5 to 3 s (twice as often at\n  // Gust 1), crossing at 0.9 V + 20 LED/s.\n  S.next -= h;\n  if (S.next \u003c= 0) {\n    S.next = (1.5 + Math.random() * 1.5) / (1 + k);\n    S.gusts.push({ x: -25, s: 8 + Math.random() * 5, a: (0.7 + Math.random() * 0.6) * (1 + 0.5 * k), yc: Math.random() * 128, c: 0.9 * V + 20 });\n  }\n  for (const q of S.gusts) q.x += q.c * h;\n  S.gusts = S.gusts.filter((q) => q.x \u003c 110);\n  for (const r of S.ropes) {\n    // The wind on its cards lifts the rope (the first mode) and tips it\n    // toward the side the gust has reached (the second); 0.9 and 1.6 Hz.\n    let l1 = 0, l2 = 0;\n    for (const c of r.cards) {\n      const py = ropeY(r, c.x), w = windAt(S, c.x, py + L);\n      c.wv = w;\n      c.wd = windAt(S, c.x + 6, py + L) - windAt(S, c.x - 6, py + L);\n      const f = (w * w) / (Q * Q) / 100;\n      l1 += f * cat(c.x);\n      l2 += f * tip(c.x);\n    }\n    const w1 = 2 * PI * 0.9, w2 = 2 * PI * 1.6;\n    r.a1 = -w1 * w1 * r.b1 - 0.5 * w1 * r.v1 + w1 * w1 * 4 * tanh(l1);\n    r.a2 = -w2 * w2 * r.b2 - 0.5 * w2 * r.v2 + w2 * w2 * 1.5 * tanh(l2 - 0.3 * l1);\n    r.v1 += r.a1 * h;\n    r.v2 += r.a2 * h;\n    r.b1 = min(SAG * 0.85, r.b1 + r.v1 * h);\n    r.b2 += r.v2 * h;\n    for (const c of r.cards) {\n      // The peg's own acceleration, down, changes the gravity the card feels.\n      const ay = -r.a1 * cat(c.x) - r.a2 * tip(c.x);\n      const ct = cos(c.th), st = sin(c.th), rel = c.wv - 0.5 * L * ct * c.w, F = KD * rel * abs(rel);\n      const acc = ((-(G - ay) * st + F * ct) * L) / J - 0.3 * c.w;\n      c.w += acc * h;\n      c.th += c.w * h;\n      // Twist about the peg: a gust front reaching one edge of the card\n      // before the other turns it, and a spring brings it back.\n      const target = cl(((0.5 * c.wd) / max(V, 1)) * (0.3 + 1.6 * k) * (0.7 + 0.08 * S.B) + c.dh, -1.5, 1.5);\n      c.pw += (16 * (target - c.ph) - 1.4 * c.pw) * h;\n      c.ph += c.pw * h;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kn[0] || 0;\n  S.speed = cl(kn[1], 0.2, 3);\n  S.B = cl(kn[2], 2, 7);\n  S.gust = cl(kn[3], 0, 1);\n  // Beaufort: v = 0.836 B^1.5 m/s.\n  S.V = 0.836 * S.B ** 1.5 * Q;\n  let T = d * (S.speed / 2);\n  if (input.btnPressed && input.btnPressed[0]) S.gusts.push({ x: -25, s: 12, a: 2.4, yc: 64, c: 0.9 * S.V + 20 });\n  // Start with the line already in the wind, 2.5 s in.\n  if (!S.warm) (S.warm = true), (T += 2.5);\n  const n = max(1, Math.ceil(T / (1 / 240)));\n  for (let i = 0; i \u003c n; i++) step(S, T / n);\n}\n\n// ---- Drawing.\nconst BG0 = [5, 7, 16], BG1 = [2, 3, 8];\nfunction blend(F, x, y, a, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  F[o] += (r - F[o]) * a;\n  F[o + 1] += (g - F[o + 1]) * a;\n  F[o + 2] += (b - F[o + 2]) * a;\n}\n\nfunction drawCard(S, F, r, c, ci) {\n  const px = c.x, py = ropeY(r, c.x), th = c.th, ct = cos(th), st = sin(th);\n  const cp = cos(c.ph), sx = max(0.06, abs(cp)), back = cp \u003c 0;\n  // The knob runs the cards from sea green through azure and violet to rose,\n  // past the oranges, which a dim card turns brown.\n  const hue = 0.42 + 0.56 * S.hue + ((ci * 0.37) % 1 - 0.5) * 0.07;\n  const card = hsv(hue, 0.78, back ? 0.3 : 0.5), ink = [1, 0.96, 0.86];\n  // Light from the upper left: a card turned away from it dims.\n  const lit = 0.55 + 0.45 * sx + 0.12 * st;\n  const Fg = FIELD[c.ch];\n  // Bounding box of the turned card and its peg.\n  let x0 = 99, x1 = -99, y0 = 99, y1 = -99;\n  for (const [u, v] of [[-CW, -3], [CW, -3], [-CW, CB], [CW, CB]]) {\n    const X = px + u * sx * ct + v * st, Y = py - u * sx * st + v * ct;\n    x0 = min(x0, X);\n    x1 = max(x1, X);\n    y0 = min(y0, Y);\n    y1 = max(y1, Y);\n  }\n  for (let Y = max(0, floor(y0) - 1); Y \u003c= min(H - 1, Math.ceil(y1) + 1); Y++)\n    for (let X = max(0, floor(x0) - 1); X \u003c= min(W - 1, Math.ceil(x1) + 1); X++) {\n      const dx = X - px, dy = Y - py, us = dx * ct - dy * st, v = dx * st + dy * ct;\n      // Coverage of the card, its edges antialiased in LEDs on the panel.\n      const cov = cl(CW * sx - abs(us) + 0.5, 0, 1) * cl(min(v - CT, CB - v) + 0.5, 0, 1);\n      if (cov > 0) {\n        const u = (back ? -us : us) / sx;\n        const dd = fieldAt(Fg, u + GX, v - GY);\n        // Ink: strokes 1.3 LEDs wide, faint and mirrored through the paper\n        // from behind.\n        const ik = cl(0.65 + 0.5 - dd * (0.6 + 0.4 * sx), 0, 1) * (back ? 0.18 : 1);\n        const shade = lit * (1 - 0.18 * max(0, (v - 12) / 7));\n        blend(F, X, Y, cov, (card[0] + (ink[0] - card[0]) * ik) * shade, (card[1] + (ink[1] - card[1]) * ik) * shade, (card[2] + (ink[2] - card[2]) * ik) * shade);\n      }\n      // The peg: a pale wooden clip 2.4 LEDs wide over the rope.\n      const pc = cl(1.2 - abs(us) + 0.5, 0, 1) * cl(min(v + 2.6, 3 - v) + 0.5, 0, 1);\n      if (pc > 0) blend(F, X, Y, pc, 0.82, 0.72, 0.55);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const F = S.F;\n  for (let y = 0, o = 0; y \u003c H; y++) {\n    const f = y / (H - 1);\n    for (let x = 0; x \u003c W; x++, o += 3) {\n      F[o] = (BG0[0] + (BG1[0] - BG0[0]) * f) / 255;\n      F[o + 1] = (BG0[1] + (BG1[1] - BG0[1]) * f) / 255;\n      F[o + 2] = (BG0[2] + (BG1[2] - BG0[2]) * f) / 255;\n    }\n  }\n  let ci = 0;\n  for (const r of S.ropes) {\n    // The rope, one LED thick, shared between the two rows it falls across.\n    for (let x = 0; x \u003c W; x++) {\n      const y = ropeY(r, x), iy = floor(y), f = y - iy;\n      blend(F, x, iy, 1 - f, 0.55, 0.5, 0.42);\n      blend(F, x, iy + 1, f, 0.55, 0.5, 0.42);\n    }\n    // Hooks in the walls.\n    blend(F, 0, r.y - 1, 1, 0.7, 0.7, 0.72);\n    blend(F, 63, r.y - 1, 1, 0.7, 0.7, 0.72);\n    for (const c of r.cards) drawCard(S, F, r, c, ci++);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(cl(F[o], 0, 1) * 255), round(cl(F[o + 1], 0, 1) * 255), round(cl(F[o + 2], 0, 1) * 255));\n}\n","coxeter-frieze":"// ===== Patternflow pattern =====\n// Title:   Conway-Coxeter Frieze\n// Family:  number\n// Idea:    A Conway-Coxeter frieze stands up the tall panel, its rows of whole numbers turned into columns between two columns of 1s and offset half a step into a lattice of diamonds, every diamond keeping ad - bc = 1 as the frieze drifts down past its glide; every 6 s the frieze dims, the triangulated polygon it comes from lights up with each vertex's count of triangles, one diagonal flips, and the frieze comes back recomputed with the numbers that changed flashing white.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: frieze patterns (H. S. M. Coxeter, \"Frieze patterns\", 1971), triangulated polygons and frieze patterns (John Conway and H. S. M. Coxeter, 1973), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sides=7..11, Chords=0..1\n//\n// Knob 1: Hue. Turns the numbers' colours round the wheel. At 0 the 2s are green, 3s teal, 4s cyan, 5s azure, 7s and 8s blue, 13s magenta, 21s red and 34s gold, each number on a diamond of its own colour at a fifth of the brightness; the 1s are white, the two border columns grey, and the flip is drawn in amber. At 0.5 the 2s are purple and the 8s yellow-green.\n// Knob 2: Speed. The frieze drifts down 1.5 Speed LEDs a second, 3 at the opening 2, so the heptagon's frieze, which repeats every 84 LEDs and mirrors itself left to right every 42, comes round in 28 s. A diagonal flips every 12 / Speed seconds: every 6 s at Speed 2, first at 4.2 s, every 60 s at 0.2 and 4 s at 3.\n// Knob 3: Sides. The polygon's n, 7 to 11, and the frieze's n - 1 columns. At the opening 7 there are 6 columns and the 42 triangulations of the heptagon give numbers up to 8; the largest number over all triangulations is a Fibonacci number, 13 for the octagon's 132, then 21, 34 and 55 for 11 sides and 4862 triangulations. Columns that can hold two digits are 7 LEDs wide, the rest 3. A new n starts from a fan and 4n random flips.\n// Knob 4: Chords. Every number in the frieze is m(i, j) for the chord from vertex i to vertex j. At 0 the numbers are coloured by value; at 1 by the direction of their chord, so parallel chords share a colour, and the numbers standing at one height are one family of parallel chords. Between the two the colours blend; at the opening 0.06 they are nearly all by value.\n\n// Coxeter (1971): a frieze is rows of numbers between a row of 0s and 1s\n// above and of 1s and 0s below, each row offset half a step, where every\n// diamond b over a, d over c holds ad - bc = 1. Conway and Coxeter (1973):\n// the friezes of positive whole numbers with n - 1 rows between the 0s are\n// the triangulations of an n-gon, the row after the 1s counting the\n// triangles at each vertex, its quiddity. The entries are m(i, j) for\n// vertices i and j, with m(i, i) = 0, m(i, i + 1) = 1 and\n// m(i, j + 1) = a_j m(i, j) - m(i, j - 1); m(i, j) = 1 exactly where i j is\n// a side or a diagonal of the triangulation, and m(i, j) = m(j, i + n), the\n// glide. Both were checked against every triangulation from 5 to 11 sides.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, cos, sin, log2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst STEP = 12; // LEDs between one entry and the next down a column\nconst CX = 31.5, CY = 63.5, RX = 24.5, RY = 50; // the polygon, an ellipse's n-gon\n\n// 3 x 5 digits, one octal digit a row from the top, 4 = left column.\nconst FONT = [0o75557, 0o26227, 0o71747, 0o71717, 0o55711, 0o74717, 0o74757, 0o71122, 0o75757, 0o75717];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- The triangulation: an n by n table of sides and diagonals. ----\nconst linked = (S, i, j) => S.adj[i * S.n + j] === 1;\nfunction link(S, i, j, v) {\n  S.adj[i * S.n + j] = v;\n  S.adj[j * S.n + i] = v;\n}\nfunction diagonals(S) {\n  const n = S.n, out = [];\n  for (let i = 0; i \u003c n; i++) for (let j = i + 2; j \u003c n; j++) if (!(i === 0 && j === n - 1) && linked(S, i, j)) out.push(i, j);\n  return out;\n}\n// The two triangles on diagonal i j: the vertices joined to both, one on\n// each side. In a triangulated convex polygon every three mutually joined\n// vertices bound a triangle.\nfunction apexes(S, i, j) {\n  const out = [];\n  for (let k = 0; k \u003c S.n; k++) if (k !== i && k !== j && linked(S, i, k) && linked(S, j, k)) out.push(k);\n  return out;\n}\nfunction flip(S, i, j) {\n  const [k, l] = apexes(S, i, j);\n  link(S, i, j, 0);\n  link(S, k, l, 1);\n  return [k, l];\n}\n\n// ---- The frieze from the triangulation, checked. ----\nfunction build(S) {\n  const n = S.n, a = new Int32Array(n), M = [];\n  for (let i = 0; i \u003c n; i++) for (let j = 0; j \u003c n; j++) a[i] += S.adj[i * n + j];\n  for (let i = 0; i \u003c n; i++) a[i] -= 1; // triangles at i: its sides and diagonals less one\n  for (let i = 0; i \u003c n; i++) {\n    const r = new Int32Array(n + 1);\n    r[1] = 1;\n    for (let k = 1; k \u003c n; k++) r[k + 1] = a[(i + k) % n] * r[k] - r[k - 1];\n    M.push(r);\n  }\n  // Every diamond: a = m(i, i + k) over d = m(i + 1, i + 1 + k), with\n  // b = m(i + 1, i + k) and c = m(i, i + k + 1) beside them; the 1s and 0s\n  // closing every column; every entry between them positive.\n  let ok = true, checked = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const R = M[i], Q = M[(i + 1) % n];\n    if (R[n - 1] !== 1 || R[n] !== 0) ok = false;\n    for (let k = 1; k \u003c= n - 2; k++, checked++) if (R[k] * Q[k] - Q[k - 1] * R[k + 1] !== 1) ok = false;\n    for (let k = 1; k \u003c n; k++) if (R[k] \u003c 1) ok = false;\n  }\n  return { a, M, ok, checked };\n}\n\n// A random triangulation: a fan from vertex 0, then 4n random flips.\nfunction fresh(S, n) {\n  S.n = n;\n  S.adj = new Uint8Array(n * n);\n  for (let i = 0; i \u003c n; i++) link(S, i, (i + 1) % n, 1);\n  for (let j = 2; j \u003c n - 1; j++) link(S, 0, j, 1);\n  for (let t = 0; t \u003c 4 * n; t++) {\n    const d = diagonals(S), q = 2 * floor((Math.random() * d.length) / 2);\n    flip(S, d[q], d[q + 1]);\n  }\n  const f = build(S);\n  S.a = f.a;\n  S.M = f.M;\n  S.checked = f.checked;\n  S.flash = new Float32Array(n * (n + 1)).fill(-99);\n  S.old = null;\n  S.neu = null;\n  S.pick = null;\n  // Fixed column widths: 3 LEDs, or 7 where two digits can come, columns\n  // 3 to n - 3 from the octagon on; the spare LEDs shared out as gaps.\n  const wd = [];\n  let used = 0;\n  for (let k = 1; k \u003c n; k++) {\n    const w = n >= 8 && k >= 3 && k \u003c= n - 3 ? 7 : 3;\n    wd.push(w);\n    used += w;\n  }\n  const gap = (W - used) / (n - 1);\n  S.colX = [];\n  let x = gap / 2;\n  for (let k = 0; k \u003c n - 1; k++) {\n    S.colX.push(x + wd[k] / 2);\n    x += wd[k] + gap;\n  }\n  // For each LED column, the frieze columns either side of it (1 to n - 1).\n  S.near = new Int8Array(2 * W);\n  for (let X = 0; X \u003c W; X++) {\n    let k = 1;\n    while (k \u003c n - 1 && S.colX[k] \u003c= X) k++;\n    S.near[2 * X] = X \u003c S.colX[0] ? 1 : k;\n    S.near[2 * X + 1] = X \u003c S.colX[0] ? 1 : min(k + 1, n - 1);\n  }\n  // Colour and flash of the 14 entries in view down each column.\n  S.EC = [];\n  for (let k = 0; k \u003c n; k++) S.EC.push(new Float32Array(14 * 5));\n  S.I0 = new Int32Array(n);\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, n: 0, chords: 0.06, t: 0, scroll: 0, cyc: 0.5, pick: null, flips: 0, bad: 0, buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.chords = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 7, 11));\n  if (n !== S.n) fresh(S, n);\n  S.t += d;\n  S.scroll += d * 1.5 * S.speed;\n  // The flip cycle, 12 / Speed seconds: the polygon fades in over the first\n  // 8 per cent, the diagonal flips at 20, the polygon fades out from 32 to 40\n  // and the changed numbers flash as the frieze comes back.\n  S.cyc += (d * S.speed) / 12;\n  if (S.cyc >= 1) {\n    // A new cycle picks the diagonal to flip, not the one the last flip\n    // made, which would only flip back.\n    S.cyc -= 1;\n    const dg = diagonals(S);\n    let q = 2 * floor((Math.random() * dg.length) / 2);\n    if (S.neu && dg.length > 2 && dg[q] === S.neu[0] && dg[q + 1] === S.neu[1]) q = (q + 2) % dg.length;\n    S.pick = [dg[q], dg[q + 1]];\n  }\n  if (S.pick && S.cyc >= 0.2) {\n    const [i, j] = S.pick, kl = flip(S, i, j), f = build(S);\n    S.pick = null;\n    if (f.ok) {\n      // The changed entries flash from the moment the frieze comes back.\n      const at = S.t + ((0.32 - S.cyc) * 12) / S.speed;\n      for (let r = 0; r \u003c n; r++) for (let c = 1; c \u003c n; c++) if (f.M[r][c] !== S.M[r][c]) S.flash[r * (n + 1) + c] = at;\n      S.a = f.a;\n      S.M = f.M;\n      S.old = [i, j];\n      S.neu = [min(kl[0], kl[1]), max(kl[0], kl[1])];\n      S.flips++;\n    } else {\n      // Never seen: a frieze that fails a diamond keeps the old triangulation.\n      link(S, kl[0], kl[1], 0);\n      link(S, i, j, 1);\n      S.bad++;\n    }\n    S.checked = f.checked;\n  }\n}\n\n// Additive soft line into the buffer, a splat every quarter LED.\nfunction line(buf, x0, y0, x1, y1, r, g, b) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), steps = max(1, round(len * 4));\n  for (let s = 0; s \u003c= steps; s++) {\n    const t = s / steps, x = x0 + (x1 - x0) * t, y = y0 + (y1 - y0) * t, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const X = ix + dx, Y = iy + dy;\n        if (X \u003c 0 || Y \u003c 0 || X >= W || Y >= H) continue;\n        const w = (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy) * 0.25, o = (Y * W + X) * 3;\n        buf[o] = max(buf[o], min(1, buf[o] + r * w));\n        buf[o + 1] = max(buf[o + 1], min(1, buf[o + 1] + g * w));\n        buf[o + 2] = max(buf[o + 2], min(1, buf[o + 2] + b * w));\n      }\n  }\n}\n\n// One 3 x 5 digit with its top left at (x, y).\nfunction digit(buf, d, x, y, r, g, b) {\n  const f = FONT[d];\n  for (let row = 0; row \u003c 5; row++) {\n    const Y = y + row;\n    if (Y \u003c 0 || Y >= H) continue;\n    const bits = (f >> (3 * (4 - row))) & 7;\n    for (let c = 0; c \u003c 3; c++)\n      if (bits & (4 >> c)) {\n        const X = x + c;\n        if (X \u003c 0 || X >= W) continue;\n        const o = (Y * W + X) * 3;\n        buf[o] = r;\n        buf[o + 1] = g;\n        buf[o + 2] = b;\n      }\n  }\n}\n// A number 1 to 99 centred on (cx, cy).\nfunction number(buf, v, cx, cy, r, g, b) {\n  const y = round(cy) - 2;\n  if (v \u003c 10) digit(buf, v, round(cx - 1.5), y, r, g, b);\n  else {\n    const x = round(cx - 3.5);\n    digit(buf, floor(v / 10) % 10, x, y, r, g, b);\n    digit(buf, v % 10, x + 4, y, r, g, b);\n  }\n}\n\nconst vx = (S, v) => CX + RX * cos((2 * PI * v) / S.n - PI / 2);\nconst vy = (S, v) => CY + RY * sin((2 * PI * v) / S.n - PI / 2);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) {\n    for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n    return;\n  }\n  const { buf, n, M, colX, EC, I0 } = S, c = S.cyc, tmp = [0, 0, 0], acc = [0, 0, 0];\n  // How far the polygon has come in: 0 on the frieze alone, 1 at full.\n  const sm = (e) => e * e * (3 - 2 * e);\n  const ov = c \u003c 0.08 ? sm(c / 0.08) : c \u003c 0.32 ? 1 : c \u003c 0.4 ? sm(1 - (c - 0.32) / 0.08) : 0, fr = 1 - 0.85 * ov;\n  const hue0 = S.hue + 0.12;\n  hsv(hue0, 0.75, 1, acc);\n\n  // ---- Each entry's colour. Column k holds m(i, i + k) at height\n  // i + k / 2 steps. By value: 1s white, the border's dimmer, the rest round\n  // the wheel by log2 of the value. By chord: hue from (i + j) mod n. ----\n  for (let k = 1; k \u003c n; k++) {\n    const i0 = (I0[k] = Math.ceil((-STEP - S.scroll) / STEP - k / 2)), e = EC[k];\n    for (let q = 0; q \u003c 14; q++) {\n      const i = i0 + q, r = ((i % n) + n) % n, v = M[r][k];\n      const edge = k === 1 || k === n - 1;\n      if (v === 1) tmp[0] = tmp[1] = tmp[2] = edge ? 0.6 : 1;\n      else hsv(hue0 + 0.2 * log2(v), 0.8, 1, tmp);\n      if (S.chords > 0) {\n        const t = tmp.slice();\n        hsv(hue0 + ((2 * r + k) % n) / n, 0.75, 1, tmp);\n        for (let z = 0; z \u003c 3; z++) tmp[z] = t[z] + (tmp[z] - t[z]) * S.chords;\n      }\n      // A changed number flashes white for 0.4 s and fades back over 1.2 s.\n      const age = S.t - S.flash[r * (n + 1) + k];\n      const wf = age >= 0 && age \u003c 1.6 ? (age \u003c 0.4 ? 1 : 1 - (age - 0.4) / 1.2) : 0;\n      for (let z = 0; z \u003c 3; z++) e[q * 4 + z] = tmp[z] + (1 - tmp[z]) * wf;\n      e[q * 4 + 3] = wf;\n      // How bright its diamond is: 0.2 of the colour, 0.1 for a 1 inside\n      // and 0.05 on the border.\n      e[56 + q] = v > 1 ? 0.2 : edge ? 0.083 : 0.1;\n    }\n  }\n\n  // ---- Tiles: every LED belongs to the nearest entry in a diamond metric,\n  // so each number sits on a diamond of its colour at 0.2, and LEDs on a\n  // boundary between two diamonds stay dark. ----\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) {\n      const a = S.near[2 * x], b = S.near[2 * x + 1], h = b > a ? (colX[b - 1] - colX[a - 1]) / 2 : 6;\n      let d1 = 9, d2 = 9, kb = 0, qb = 0;\n      for (const k of a === b ? [a] : [a, b]) {\n        const u = (y - S.scroll) / STEP - k / 2, i = round(u), dd = abs(x - colX[k - 1]) / h + (abs(u - i) * STEP) / (STEP / 2);\n        if (dd \u003c d1) (d2 = d1), (d1 = dd), (kb = k), (qb = i - I0[k]);\n        else if (dd \u003c d2) d2 = dd;\n      }\n      if (d2 - d1 \u003c 0.16 || qb \u003c 0 || qb > 13) {\n        buf[o] = buf[o + 1] = buf[o + 2] = 0;\n        continue;\n      }\n      const e = EC[kb], g = (e[56 + qb] + 0.3 * e[qb * 4 + 3]) * fr;\n      buf[o] = e[qb * 4] * g;\n      buf[o + 1] = e[qb * 4 + 1] * g;\n      buf[o + 2] = e[qb * 4 + 2] * g;\n    }\n\n  // ---- The numbers. ----\n  for (let k = 1; k \u003c n; k++) {\n    const e = EC[k];\n    for (let q = 0; q \u003c 14; q++) {\n      const i = I0[k] + q, r = ((i % n) + n) % n, y = (i + k / 2) * STEP + S.scroll, lv = fr + (1 - fr) * e[q * 4 + 3];\n      number(buf, M[r][k], colX[k - 1], y, e[q * 4] * lv, e[q * 4 + 1] * lv, e[q * 4 + 2] * lv);\n    }\n  }\n\n  // ---- In the flip, the polygon over the dimmed frieze: sides grey,\n  // diagonals white. The chosen diagonal pulses in the accent colour from\n  // 0.08 of the cycle, fades from 0.2 to 0.26, and the new one grows from\n  // one end to the other from 0.2 to 0.28. Each vertex carries its count of\n  // triangles, the quiddity, the four the flip changes in the accent. ----\n  if (ov > 0) {\n    for (let v = 0; v \u003c n; v++) line(buf, vx(S, v), vy(S, v), vx(S, (v + 1) % n), vy(S, (v + 1) % n), 0.6 * ov, 0.6 * ov, 0.6 * ov);\n    const hot = c \u003c 0.2 ? S.pick : null, grow = c >= 0.2 && c \u003c 0.28 ? S.neu : null;\n    for (let i = 0; i \u003c n; i++)\n      for (let j = i + 2; j \u003c n; j++) {\n        if ((i === 0 && j === n - 1) || !linked(S, i, j)) continue;\n        if (hot && hot[0] === i && hot[1] === j) {\n          const e = (c \u003c 0.08 ? 1 : 0.6 + 0.4 * cos((c - 0.08) * 160)) * ov;\n          line(buf, vx(S, i), vy(S, i), vx(S, j), vy(S, j), acc[0] * e, acc[1] * e, acc[2] * e);\n        } else if (grow && grow[0] === i && grow[1] === j) {\n          const g = (c - 0.2) / 0.08, x0 = vx(S, i), y0 = vy(S, i);\n          line(buf, x0, y0, x0 + (vx(S, j) - x0) * g, y0 + (vy(S, j) - y0) * g, acc[0] * ov, acc[1] * ov, acc[2] * ov);\n        } else line(buf, vx(S, i), vy(S, i), vx(S, j), vy(S, j), ov, ov, ov);\n      }\n    if (S.old && c >= 0.2 && c \u003c 0.26) {\n      const e = (1 - (c - 0.2) / 0.06) * ov, [i, j] = S.old;\n      line(buf, vx(S, i), vy(S, i), vx(S, j), vy(S, j), acc[0] * e, acc[1] * e, acc[2] * e);\n    }\n    for (let v = 0; v \u003c n; v++) {\n      const ang = (2 * PI * v) / n - PI / 2, lx = CX + (RX + 6) * cos(ang), ly = CY + (RY + 7) * sin(ang);\n      const touched = S.old && c >= 0.2 && c \u003c 0.4 && (v === S.old[0] || v === S.old[1] || v === S.neu[0] || v === S.neu[1]);\n      if (touched) number(buf, S.a[v], lx, ly, acc[0] * ov, acc[1] * ov, acc[2] * ov);\n      else number(buf, S.a[v], lx, ly, ov, ov, ov);\n    }\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(buf[o] * 255), round(buf[o + 1] * 255), round(buf[o + 2] * 255));\n}\n","hydra-game":"// ===== Patternflow pattern =====\n// Title:   Hydra Game\n// Family:  algo\n// Idea:    Hercules fights Kirby and Paris's hydra, a tree rooted at the bottom of the panel with glowing heads on writhing necks: at step n he cuts one head, and unless its neck grows from the root, the node one level further down grows n copies of the branch the head was cut from, which sprout from it in gold, so the hydra swells into a dense fan of hundreds or thousands of heads while its ordinal at the top, the sum of omega to the power of each branch's ordinal, falls at every cut, and the cuts come faster and faster until the last head drops and the root stands alone.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hydra game (Laurie Kirby and Jeff Paris, Accessible independence results for Peano arithmetic, Bulletin of the London Mathematical Society, 1982), a tree's ordinal in Cantor normal form (Georg Cantor), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hydra=1..5, Strategy=0..3\n//\n// Knob 1: Hue. Turns the hydra round the wheel. At 0 the necks are green, the heads pale mint and new growth gold; at 0.25 the necks are azure and new growth green, at 0.5 magenta with sky-blue growth, at 0.75 amber with pink growth.\n// Knob 2: Speed. Cuts a second, 0.9 Speed (1 + n / 8) at step n, so the cuts come faster as the hydra grows. At the opening 2 the hydra grows out of its root in the first second, the first cut falls at 1.6 s, step 40 at 9.3 s, and hydra 1 dies at step 1149 at 23.5 s; at 3 that death comes at 16 s, at 0.2 at 225 s. The dead root waits 3.5 s and the hydra grows again.\n// Knob 3: Hydra. Five starting hydras, by whole steps, with their deaths under the rightmost cut. 1: ω²+ω+1, a two-headed neck, a one-headed neck and a head on the root, 7 nodes; dead at step 1149, 576 nodes at its biggest. 2: ω^ω, one neck of three, dead at step 37 with 20 nodes at most. 3: ω²+ω·2, dead at step 445, 224 nodes. 4: ω²+ω+2, dead at step 5629, 2816 nodes. 5: ω²+ω·2+2, 10 nodes, dead at step 2302, 1153 nodes. Levels stand 50 LEDs apart for the hydras two necks high and 33 for the neck of three.\n// Knob 4: Strategy. Which head Hercules cuts, by whole steps: 0 the rightmost head, 1 the leftmost, 2 a random branch at every fork, 3 the deepest head, the rightmost of them. The order changes the length of the fight up to 234 times: hydra 4 dies at step 5629 cut from the right and at 24 from the deepest end; hydra 1 at 1149 from the right, 30 from the left and 23 from the deepest end, and 2000 random hunts on it took 17 to 441 steps. Hydras 2, 3 and 5 are symmetric enough that the leftmost cut takes as long as the rightmost. A hunt whose regrowth would pass 8000 nodes is called off and shown as MAX; in 2000 random hunts on hydra 5 that happened twice.\n// Buttons: K1 tap grows the hydra again from its root.\n\n// Kirby and Paris (1982): a hydra is a finite rooted tree and its heads are\n// the leaves. At step n Hercules cuts a head. If its neck grows from the\n// root, the head is simply gone; otherwise the node below that neck's own\n// node grows n copies of the branch the head was cut from. Every way of\n// choosing heads kills every hydra in finitely many steps, and Peano\n// arithmetic cannot prove it. The proof gives each node the ordinal o(v),\n// the sum of omega^o(c) over its children c in Cantor normal form, biggest\n// terms first. A cut lowers one term and adds n smaller ones, so the root's\n// ordinal falls at every step, and ordinals below epsilon_0 cannot fall\n// forever; the hydra needs all of them, more than Peano arithmetic reaches.\n//\n// The panel can draw a few thousand heads, which leaves the hydras below\n// omega^3 and the single neck of three. The rightmost cut on omega^2 with\n// nothing beside it, first met at step m, ends at step (m + 3) 2^(m + 1) - 3:\n// 13 for m = 1, 1149 for m = 6. Two such necks, omega^2 2, die at step\n// 557053 with 278528 nodes at their biggest.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sin, cos, exp, sqrt, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The root's children as brackets, each pair a node, an empty pair a head.\nconst HYDRAS = [\"(()())(())()\", \"((()))\", \"(())(()())(())\", \"(()())(())()()\", \"()(())(()())(())()\"];\nconst CAP = 8000;\nconst ROOT_X = 31.5, ROOT_Y = 124, TOP_Y = 24;\nconst HUE0 = 0.36;\n\nfunction mk(p, x, y, t) {\n  return { p, c: [], x, y, tx: x, ty: y, dx: 0, b: t, ph: Math.random() * 2 * PI, k: 1, h: 0 };\n}\nfunction clone(v, p, x, y, t) {\n  const u = mk(p, x, y, t);\n  for (const c of v.c) u.c.push(clone(c, u, x, y, t));\n  return u;\n}\nfunction size(v) {\n  let s = 1;\n  for (const c of v.c) s += size(c);\n  return s;\n}\nfunction height(v) {\n  let h = 0;\n  for (const c of v.c) h = max(h, height(c) + 1);\n  return (v.h = h);\n}\n\n// ---- Ordinals below epsilon_0: a list of [exponent, coefficient] terms,\n// exponents falling, each exponent an ordinal of the same kind; [] is 0.\nfunction cmpO(a, b) {\n  for (let i = 0; i \u003c a.length && i \u003c b.length; i++) {\n    const c = cmpO(a[i][0], b[i][0]);\n    if (c) return c;\n    if (a[i][1] !== b[i][1]) return a[i][1] - b[i][1];\n  }\n  return a.length - b.length;\n}\nfunction ord(v) {\n  if (!v.c.length) return [];\n  const ex = v.c.map(ord).sort((a, b) => cmpO(b, a)), out = [];\n  for (const e of ex) {\n    const l = out[out.length - 1];\n    if (l && !cmpO(l[0], e)) l[1]++;\n    else out.push([e, 1]);\n  }\n  return out;\n}\n\n// ---- The game.\nfunction restart(S, hy) {\n  S.hy = hy;\n  const root = mk(null, ROOT_X, ROOT_Y, S.t), st = [root];\n  for (const ch of HYDRAS[hy]) {\n    if (ch === \"(\") {\n      const v = mk(st[st.length - 1], ROOT_X, ROOT_Y, S.t);\n      st[st.length - 1].c.push(v);\n      st.push(v);\n    } else st.pop();\n  }\n  S.root = root;\n  S.nodes = size(root);\n  // Levels share the 100 rows above the root: 50 apart for a hydra two\n  // necks high, 33 for three.\n  S.sp = min(50, floor((ROOT_Y - TOP_Y) / height(root)));\n  S.n = 0;\n  S.acc = 0;\n  S.state = 0;\n  S.st = 0;\n  S.grow = 1;\n  S.dirty = true;\n  S.fx = [];\n  aim(S);\n}\n\n// The head Hercules cuts next, as the branch index taken at each fork.\nfunction aim(S) {\n  const path = [];\n  let v = S.root;\n  if (S.strat === 3) height(S.root);\n  while (v.c.length) {\n    const n = v.c.length;\n    let i = n - 1;\n    if (S.strat === 1) i = 0;\n    else if (S.strat === 2) i = floor(Math.random() * n);\n    else if (S.strat === 3) for (const want = v.h - 1; i > 0 && v.c[i].h !== want; i--);\n    path.push(i);\n    v = v.c[i];\n  }\n  S.path = path;\n  S.aim = path.length ? v : null;\n}\n\nfunction chop(S) {\n  const path = S.path;\n  let g = null, p = null, v = S.root;\n  for (let d = 0; d \u003c path.length; d++) (g = p), (p = v), (v = v.c[path[d]]);\n  const n = ++S.n;\n  p.c.splice(path[path.length - 1], 1);\n  S.nodes--;\n  S.dirty = true;\n  if (S.fx.length \u003c 28) S.fx.push({ cx: v.x + v.dx, cy: v.y, x: v.x + v.dx, y: v.y, vx: (Math.random() - 0.5) * 14, vy: -14, a: 0 });\n  if (g) {\n    const s = size(p);\n    if (S.nodes + n * s > CAP) {\n      S.state = 2;\n      S.st = 0;\n      return;\n    }\n    const at = path[path.length - 2] + 1, copies = [];\n    for (let j = 0; j \u003c n; j++) copies.push(clone(p, g, g.x + g.dx, g.y, S.t));\n    g.c = g.c.slice(0, at).concat(copies, g.c.slice(at));\n    S.nodes += n * s;\n  }\n  if (!S.root.c.length) {\n    S.state = 1;\n    S.st = 0;\n    S.aim = null;\n    return;\n  }\n  aim(S);\n}\n\n// Heads under each node, then a span of the 60 columns for each node in\n// proportion to its heads, levels S.sp apart up from the root. A node that\n// still carries necks keeps at least 4 heads' width, so a few branches stay\n// apart beside a fan of hundreds.\nfunction count(v) {\n  if (!v.c.length) return (v.k = v.w = 1);\n  let s = 0, w = 0;\n  for (const c of v.c) (s += count(c)), (w += c.w);\n  v.w = max(4, w);\n  return (v.k = s);\n}\nfunction place(S, v, a, b, d) {\n  v.tx = (a + b) / 2;\n  v.ty = ROOT_Y - d * S.sp;\n  let x = a, sw = 0;\n  for (const c of v.c) sw += c.w;\n  for (const c of v.c) {\n    const w = ((b - a) * c.w) / sw;\n    place(S, c, x, x + w, d + 1);\n    x += w;\n  }\n}\nfunction ease(S, v, e, d) {\n  v.x += (v.tx - v.x) * e;\n  v.y += (v.ty - v.y) * e;\n  // The necks writhe: a head sways up to 0.7 LED a level.\n  v.dx = d ? sin(S.t * 1.7 + v.ph) * 0.7 * d : 0;\n  for (const c of v.c) ease(S, c, e, d + 1);\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, speed: 2, strat: 0, hy: -1, A: new Float32Array(N * 3), O: new Uint8ClampedArray(N * 3), ordv: [], fx: [] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const hy = cl(round(k[2]), 1, 5) - 1, strat = cl(round(k[3]), 0, 3);\n  S.t += d;\n  if (hy !== S.hy || (input.btnPressed && input.btnPressed[0])) restart(S, hy);\n  if (strat !== S.strat) {\n    S.strat = strat;\n    if (S.state === 0) aim(S);\n  }\n  if (S.state === 0) {\n    if (S.grow > 0) S.grow -= d;\n    else {\n      S.acc += d * S.speed * 0.9 * (1 + S.n / 8);\n      for (let m = 0; S.acc >= 1 && S.state === 0; m++) {\n        if (m === 600) {\n          S.acc = 0;\n          break;\n        }\n        chop(S);\n        S.acc -= 1;\n      }\n    }\n  } else {\n    S.st += d;\n    if (S.st > (S.state === 1 ? 3.5 : 2)) restart(S, S.hy);\n  }\n  count(S.root);\n  place(S, S.root, 1.5, 61.5, 0);\n  ease(S, S.root, 1 - exp(-d * 7), 0);\n  if (S.dirty) {\n    S.ordv = ord(S.root);\n    S.heads = S.root.c.length ? S.root.k : 0;\n    S.dirty = false;\n  }\n  for (const f of S.fx) {\n    f.a += d;\n    f.vy += 70 * d;\n    f.x += f.vx * d;\n    f.y += f.vy * d;\n  }\n  S.fx = S.fx.filter((f) => f.a \u003c 1.6 && f.y \u003c H + 2);\n}\n\n// ---- Drawing into a light buffer, then 1 - exp(-light) per channel.\nfunction splat(A, x, y, r, g, b) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++) {\n    const yy = iy + j;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = j ? fy : 1 - fy;\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = wy * (i ? fx : 1 - fx), o = (yy * W + xx) * 3;\n      A[o] += r * w;\n      A[o + 1] += g * w;\n      A[o + 2] += b * w;\n    }\n  }\n}\n// A neck: it leaves its node straight up and bends over to the child,\n// 2.8 LEDs thick at the node and 1.4 at the head, in a faint glow, and a\n// wave of up to 1.1 LEDs runs up it at phase ph.\nfunction neck(A, x0, y0, x1, y1, col, w, thick, ph) {\n  const ky = y0 + (y1 - y0) * 0.6, n = 2 + floor(max(abs(x1 - x0), abs(y1 - y0)) * 1.25);\n  const r = col[0] * w, g = col[1] * w, b = col[2] * w;\n  for (let i = 1; i \u003c n; i++) {\n    const t = i / n, u = 1 - t, y = u * u * y0 + 2 * u * t * ky + t * t * y1;\n    let x = u * u * x0 + 2 * u * t * x0 + t * t * x1;\n    if (!thick) {\n      splat(A, x, y, r, g, b);\n      continue;\n    }\n    x += 1.1 * sin(PI * t) * sin(ph - 5 * t);\n    // Across the neck: the normal to the curve's tangent.\n    let tx = 2 * t * (x1 - x0), ty = 2 * u * (ky - y0) + 2 * t * (y1 - ky);\n    const l = sqrt(tx * tx + ty * ty) || 1, half = (2.8 - 1.4 * t) / 2;\n    tx /= l;\n    ty /= l;\n    for (let j = -1; j \u003c= 1; j++) {\n      const q = j ? 0.45 : 0.8;\n      splat(A, x - ty * half * j, y + tx * half * j, r * q, g * q, b * q);\n    }\n    // and its glow, 1.5 LEDs further out each side.\n    for (let j = -1; j \u003c= 1; j += 2) splat(A, x - ty * (half + 1.5) * j, y + tx * (half + 1.5) * j, r * 0.22, g * 0.22, b * 0.22);\n  }\n}\nfunction headDot(A, x, y, col, w) {\n  splat(A, x, y - 0.5, col[0] * w * 1.6, col[1] * w * 1.6, col[2] * w * 1.6);\n  const q = w * 0.45;\n  for (const [i, j] of [[-1.2, 0], [1.2, 0], [0, -1.6], [-0.9, -1.2], [0.9, -1.2]]) splat(A, x + i, y + j, col[0] * q, col[1] * q, col[2] * q);\n}\n// The neck colour, gold for a branch just grown and back to the hydra's in\n// a second.\nconst MIX = [0, 0, 0];\nfunction tint(C, age) {\n  const f = age \u003c 1 ? (1 - age) * (1 - age) : 0;\n  for (let i = 0; i \u003c 3; i++) MIX[i] = C.neck[i] + (C.gold[i] - C.neck[i]) * f;\n  return MIX;\n}\nconst BN = new Float32Array(64), BX = new Float32Array(64), BY = new Float32Array(64), BA = new Float32Array(64), BL = new Float32Array(64);\nfunction drawNode(S, A, C, v) {\n  const n = v.c.length;\n  if (!n) return;\n  const px = v.x + v.dx, py = v.y;\n  if (n \u003c= 48) {\n    for (const c of v.c) {\n      const cx = c.x + c.dx;\n      neck(A, px, py, cx, c.y, tint(C, S.t - c.b), 0.85, true, S.t * 2.3 + c.ph);\n      if (c.c.length) {\n        // A joint where the neck meets the next ones.\n        splat(A, cx, c.y, C.neck[0] * 0.7, C.neck[1] * 0.7, C.neck[2] * 0.7);\n        drawNode(S, A, C, c);\n      } else headDot(A, cx, c.y, C.head, 1);\n    }\n    return;\n  }\n  // Hundreds of necks from one node: one neck a column, as bright as the\n  // square root of the necks it stands for.\n  BN.fill(0);\n  BX.fill(0);\n  BY.fill(0);\n  BA.fill(0);\n  BL.fill(0);\n  for (const c of v.c) {\n    const cx = c.x + c.dx, j = cl(round(cx), 0, 63);\n    BN[j]++;\n    BX[j] += cx;\n    BY[j] += c.y;\n    BA[j] += S.t - c.b;\n    if (c.c.length) drawNode(S, A, C, c);\n    else BL[j]++;\n  }\n  for (let j = 0; j \u003c 64; j++) {\n    if (!BN[j]) continue;\n    const cx = BX[j] / BN[j], cy = BY[j] / BN[j], w = sqrt(BN[j]);\n    neck(A, px, py, cx, cy, tint(C, BA[j] / BN[j]), 0.55 * w, false, 0);\n    if (BL[j]) headDot(A, cx, cy, C.head, sqrt(BL[j]));\n  }\n}\n\n// ---- The 3 by 5 face for the counters, and a 5-wide omega.\nconst G = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n  n: \"000110101101101\", \"=\": \"000111000111000\", \"+\": \"000010111010000\", D: \"110101101101110\", E: \"111100110100111\",\n  A: \"010101111101101\", M: \"101111111101101\", X: \"101101010101101\",\n};\n// rows 00000 10001 10101 10101 01010\nconst OMEGA = \"0000010001101011010101010\";\nfunction put(O, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  O[o] = r;\n  O[o + 1] = g;\n  O[o + 2] = b;\n}\nfunction glyph(O, ch, x, y, col) {\n  const g = G[ch];\n  for (let i = 0; i \u003c 15; i++) if (g[i] === \"1\") put(O, x + (i % 3), y + floor(i / 3), col[0], col[1], col[2]);\n  return x + 4;\n}\nfunction text(O, s, x, y, col) {\n  for (const ch of s) x = glyph(O, ch, x, y, col);\n  return x;\n}\nfunction omega(O, x, y, col) {\n  for (let i = 0; i \u003c 25; i++) if (OMEGA[i] === \"1\") put(O, x + (i % 5), y + floor(i / 5), col[0], col[1], col[2]);\n  return x + 6;\n}\n// An ordinal in Cantor normal form, exponents raised 4 rows; returns the\n// end column, or 99 when the next term would pass the edge.\nfunction ordText(O, o, x, y, C) {\n  if (!o.length) return text(O, \"0\", x, y, C.txt);\n  for (let i = 0; i \u003c o.length; i++) {\n    const [e, c] = o[i];\n    if (i) {\n      if (x > 54) return 99;\n      x = glyph(O, \"+\", x, y, C.dim);\n    }\n    if (!e.length) {\n      x = text(O, String(c), x, y, C.txt);\n      continue;\n    }\n    x = omega(O, x, y, C.om);\n    if (!(e.length === 1 && !e[0][0].length && e[0][1] === 1)) x = ordText(O, e, x, y - 4, C);\n    if (c > 1) {\n      put(O, x, y + 2, C.dim[0], C.dim[1], C.dim[2]);\n      x = text(O, String(c), x + 2, y, C.txt);\n    }\n  }\n  return x;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.root) return;\n  const A = S.A, O = S.O, h = S.hue + HUE0;\n  const C = {\n    neck: hsv(h, 0.85, 0.9),\n    head: hsv(h + 0.04, 0.42, 1),\n    gold: hsv(h - 0.22, 0.55, 1.1),\n    txt: hsv(h + 0.04, 0.18, 0.85).map((c) => round(c * 255)),\n    dim: hsv(h, 0.3, 0.55).map((c) => round(c * 255)),\n    om: hsv(h, 0.6, 1).map((c) => round(c * 255)),\n  };\n  A.fill(0);\n  // The ground the root stands on.\n  for (let x = 0; x \u003c W; x++) {\n    const o = (127 * W + x) * 3, f = 0.1 * exp(-(((x - ROOT_X) / 22) ** 2));\n    A[o] += C.neck[0] * f;\n    A[o + 1] += C.neck[1] * f;\n    A[o + 2] += C.neck[2] * f;\n  }\n  // Called off for size: the hydra fades out.\n  const fade = S.state === 2 ? max(0, 1 - S.st / 1.5) : 1;\n  drawNode(S, A, C, S.root);\n  // The root, pulsing while it stands alone.\n  const rw = S.state === 1 ? 1.4 + 0.8 * sin(S.st * 5) : 1;\n  // Dead: a ring goes out from the root, 30 LEDs in 1.5 s.\n  if (S.state === 1 && S.st \u003c 1.5) {\n    const r = 3 + S.st * 20, q = 1.6 * (1 - S.st / 1.5);\n    for (let i = 0; i \u003c 80; i++) {\n      const a = (i / 80) * PI;\n      splat(A, S.root.x + r * cos(a), ROOT_Y - r * sin(a), C.head[0] * q, C.head[1] * q, C.head[2] * q);\n    }\n  }\n  for (let j = -1; j \u003c= 1; j++) for (let i = -1; i \u003c= 1; i++) splat(A, S.root.x + i, ROOT_Y + j, C.neck[0] * rw * (i || j ? 0.5 : 1.2), C.neck[1] * rw * (i || j ? 0.5 : 1.2), C.neck[2] * rw * (i || j ? 0.5 : 1.2));\n  // The next head, ringed while the cuts are slow enough to follow.\n  if (S.aim && S.state === 0 && S.grow \u003c= 0 && S.speed * 0.9 * (1 + S.n / 8) \u003c 6) {\n    const a = S.aim, ax = a.x + a.dx, w = 0.35 + 0.25 * sin(S.t * 14);\n    for (let i = 0; i \u003c 12; i++) splat(A, ax + 2.7 * cos((i * PI) / 6), a.y + 2.7 * sin((i * PI) / 6), w, w, w * 0.9);\n  }\n  // Each cut: a white flash where the neck was, and the head falling.\n  for (const f of S.fx) {\n    if (f.a \u003c 0.3) {\n      const q = (1 - f.a / 0.3) * 1.4, r = 1 + f.a * 9;\n      for (let i = 0; i \u003c 10; i++) splat(A, f.cx + r * cos(i * 0.63), f.cy + r * sin(i * 0.63), q * 0.5, q * 0.5, q * 0.42);\n    }\n    const q = max(0, 1 - f.a / 1.6) * 1.3;\n    splat(A, f.x, f.y, C.head[0] * q, C.head[1] * q, C.head[2] * q);\n  }\n  for (let p = 0; p \u003c N * 3; p++) O[p] = 255 * fade * (1 - exp(-1.25 * A[p]));\n  // Step and heads, the ordinal under them.\n  let x = text(O, \"n=\", 1, 1, C.dim);\n  text(O, String(S.n), x, 1, C.txt);\n  const right = S.state === 1 ? \"DEAD\" : S.state === 2 ? \"MAX\" : String(S.heads);\n  x = 64 - right.length * 4;\n  if (S.state === 0) {\n    const hc = C.head.map((c) => round(c * 230));\n    for (const [i, j] of [[0, 0], [1, 0], [0, 1], [1, 1]]) put(O, x - 4 + i, 2 + j, hc[0], hc[1], hc[2]);\n  }\n  text(O, right, x, 1, C.txt);\n  if (ordText(O, S.ordv, 1, 11, C) === 99) for (let i = 0; i \u003c 3; i++) put(O, 58 + i * 2, 15, C.dim[0], C.dim[1], C.dim[2]);\n  for (let p = 0, y = 0; y \u003c H; y++) for (let xx = 0; xx \u003c W; xx++, p += 3) display.setPixel(xx, y, O[p], O[p + 1], O[p + 2]);\n}\n","lattice-reduction":"// ===== Patternflow pattern =====\n// Title:   Lattice Reduction\n// Family:  geometry\n// Idea:    The points of a plane lattice stand still as white dots over the whole panel while the plane is tiled by the parallelogram of its current basis, which starts as long thin slivers, and Lagrange-Gauss reduction takes the basis apart one step at a time: b2 shears along b1 by the whole number of b1 nearest its projection, the tiles sliding until their corners land back on dots, the arrows trade colours when b2 has become the shorter and the two swap names, and when the projection is half of b1 or less the tiles are compact, flash, hold, and a new lattice starts skewed.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: reduction of binary quadratic forms, the two-dimensional lattice basis reduction (Joseph-Louis Lagrange, 1773; Carl Friedrich Gauss, Disquisitiones Arithmeticae, 1801), whose heir in any dimension is the LLL algorithm (Arjen Lenstra, Hendrik Lenstra and László Lovász, 1982), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Skew=3..7, Spacing=11..22\n//\n// Knob 1: Hue. Turns the tiles and the arrows round the wheel together. At 0 the tiles are teal, blue and violet, the cell at the centre green, b1 amber and b2 pink; at 0.5 the tiles go red, ochre and lime, the centre cell magenta, b1 blue and b2 spring green.\n// Knob 2: Speed. At 2 a shear takes 0.55 s, a swap 0.4 s and a pause of 0.2 s follows each, so a basis from 3 shears is reduced in 2.2 to 4.2 s and a new lattice comes every 6 to 8 s. Every time but the 2.6 s hold and the 0.5 s cross-fade scales as 2 / Speed: at 0.2 a shear takes 5.5 s, at 3 0.37 s.\n// Knob 3: Skew. How many shears, b2 += b1 and b1 += b2 by turns, each with the sign that lengthens, turn the reduced basis into the starting one. At the opening spacing: at 3 the longer vector is 3.5 to 4.9 spacings and the tiles 2.3 to 3.2 LEDs wide; at 5 about 10 spacings and one LED wide; at 7 up to 25 spacings, where a cap stops the word, and the tiles under a LED, a moire until the first shear. Gauss takes 2 or 3 shears at 3 and 4 at 7, each by 1 to 3 times b1, with a swap between most of them.\n// Knob 4: Spacing. The square root of one cell's area, 11 to 22 LEDs: 68 dots at 11, 17 at 22. The lattices come square, hexagonal, rectangular (sides 1.6 to 1) and random (60 to 90 degrees, sides up to 1.7 to 1) in turn, all of that area and turned at random.\n// Buttons: K1 tap starts a new lattice.\n\n// A lattice is every whole combination of two vectors. Many bases give the\n// same lattice: b1, b2 and b1, b2 - q b1 for any whole q, or the two swapped.\n// Lagrange (1773) and Gauss (1801) reduced a basis by alternating the two:\n// keep b1 the shorter, subtract from b2 the multiple of b1 nearest its\n// projection, and stop when that multiple is 0. Then |b1| \u003c= |b2| and\n// |b1 . b2| \u003c= |b1|^2 / 2, so the angle between them is 60 to 120 degrees\n// and b1 is a shortest vector of the lattice.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst smooth = (u) => u * u * (3 - 2 * u);\n// The lattice point everything turns about, at the panel's middle.\nconst OX = 31.5, OY = 63.5;\nconst HOLD = 2.6, FADE = 0.5, LOOK = 0.8, CAP = 26;\n\nfunction hsv(h, s, v, out) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The basis is R U: R the reduced basis the lattice was made from, U whole\n// numbers with determinant +-1, kept exactly so the basis never drifts off\n// the lattice.\nfunction basis(S) {\n  const R = S.R, U = S.U, b = S.b;\n  b[0] = R[0] * U[0] + R[2] * U[2];\n  b[1] = R[1] * U[0] + R[3] * U[2];\n  b[2] = R[0] * U[1] + R[2] * U[3];\n  b[3] = R[1] * U[1] + R[3] * U[3];\n}\nconst len2 = (x, y) => x * x + y * y;\n\nfunction newLattice(S) {\n  // The last frame stays to cross-fade from, black at the very start.\n  S.old.set(S.acc);\n  S.xf = 1;\n  const kind = S.kind++ % 4, a = S.spacing, th = Math.random() * PI;\n  let u, v, ang;\n  if (kind === 0) (u = a), (v = a), (ang = PI / 2);\n  else if (kind === 1) (u = v = a * sqrt(2 / sqrt(3))), (ang = PI / 3);\n  else if (kind === 2) (u = a / sqrt(1.6)), (v = a * sqrt(1.6)), (ang = PI / 2);\n  else {\n    ang = PI / 3 + Math.random() * (PI / 6);\n    const r = 1 + Math.random() * 0.7;\n    u = a / sqrt(r * sin(ang));\n    v = u * r;\n  }\n  const R = S.R;\n  R[0] = u * cos(th);\n  R[1] = u * sin(th);\n  R[2] = v * cos(th + ang);\n  R[3] = v * sin(th + ang);\n  // The word: shears of b2 along b1 and of b1 along b2 by turns, from a\n  // random first one, each with the sign that lengthens the vector it\n  // moves, stopping early if the longer vector would pass CAP spacings.\n  const U = S.U;\n  U.splice(0, 4, 1, 0, 0, 1);\n  basis(S);\n  for (let k = 0, w = Math.random() \u003c 0.5 ? 1 : 0; k \u003c S.skew; k++, w ^= 1) {\n    const b = S.b, d = b[0] * b[2] + b[1] * b[3], sg = d > 1e-9 ? 1 : d \u003c -1e-9 ? -1 : Math.random() \u003c 0.5 ? 1 : -1;\n    const V = U.slice();\n    if (w) (V[1] += sg * V[0]), (V[3] += sg * V[2]);\n    else (V[0] += sg * V[1]), (V[2] += sg * V[3]);\n    const nx = w ? R[0] * V[1] + R[2] * V[3] : R[0] * V[0] + R[2] * V[2], ny = w ? R[1] * V[1] + R[3] * V[3] : R[1] * V[0] + R[3] * V[2];\n    if (len2(nx, ny) > (CAP * a) ** 2) break;\n    U.splice(0, 4, ...V);\n    basis(S);\n  }\n  Object.assign(S, { phase: 0, pt: 0, op: null, steps: 0, ca: 1, cb: 2 });\n}\n\n// The next operation: a swap when b2 is the shorter, else the shear by q,\n// else none (reduced).\nfunction nextOp(S) {\n  const b = S.b, l1 = len2(b[0], b[1]), l2 = len2(b[2], b[3]);\n  if (l2 \u003c l1 * (1 - 1e-9)) return { swap: true };\n  // A projection of half of b1 or less is already reduced; testing that\n  // and not q = 0 keeps a tie, as in the hexagonal lattice, from flipping\n  // between q = 1 and q = -1 for ever.\n  const mu = (b[0] * b[2] + b[1] * b[3]) / l1;\n  return abs(mu) > 0.5 + 1e-7 ? { q: round(mu) } : null;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, skew: 3, spacing: 11, kind: 0, phase: 0, pt: 0, op: null, steps: 0, flash: 0, btn: false,\n    R: [9, 0, 0, 9], U: [1, 0, 0, 1], b: [9, 0, 0, 9], ca: 1, cb: 2, c: [0, 0, 0],\n    tile: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], acc: new Float32Array(W * H * 3), old: new Float32Array(W * H * 3), xf: 1,\n  };\n  return params.s;\n}\n\n// Phases: 0 cross-fading in and showing the skewed basis, 1 reducing, 2\n// the reduced basis held, then the next lattice.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 11], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const skew = round(cl(k[2], 3, 7)), spacing = cl(k[3], 11, 22), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (skew !== S.skew || abs(spacing - S.spacing) > 0.05 || !S.started || (btn && !S.btn))\n    (S.skew = skew), (S.spacing = spacing), (S.started = true), newLattice(S);\n  S.btn = btn;\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  S.flash = max(0, S.flash - d / 0.7);\n  S.xf = max(0, S.xf - d / FADE);\n  if (S.phase === 0) {\n    if (S.pt >= FADE + LOOK * sc) (S.phase = 1), (S.pt = 0), (S.op = nextOp(S));\n  } else if (S.phase === 1) {\n    if (!S.op) return void ((S.phase = 2), (S.pt = 0), (S.flash = 1));\n    const dur = (S.op.swap ? 0.4 : 0.55) * sc;\n    if (S.pt >= dur + 0.2 * sc) {\n      const U = S.U;\n      if (S.op.swap) {\n        [U[0], U[1]] = [U[1], U[0]];\n        [U[2], U[3]] = [U[3], U[2]];\n        [S.ca, S.cb] = [S.cb, S.ca];\n      } else (U[1] -= S.op.q * U[0]), (U[3] -= S.op.q * U[2]);\n      basis(S);\n      S.steps++;\n      S.pt = 0;\n      S.op = nextOp(S);\n    }\n  } else if (S.pt >= HOLD) newLattice(S);\n}\n\nfunction put(acc, x, y, c, w) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  w = min(1, w);\n  for (let i = 0; i \u003c 3; i++) acc[k + i] += (c[i] - acc[k + i]) * w;\n}\nfunction line(acc, x0, y0, x1, y1, c, w) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0;\n  for (let x = max(0, round(x0)); x \u003c= min(st ? H - 1 : W - 1, round(x1)); x++) {\n    const y = y0 + (x - x0) * s, iy = floor(y), f = y - iy;\n    if (st) put(acc, iy, x, c, w * (1 - f)), put(acc, iy + 1, x, c, w * f);\n    else put(acc, x, iy, c, w * (1 - f)), put(acc, x, iy + 1, c, w * f);\n  }\n}\n// An arrow from the origin along x, y: a shaft 1.5 LEDs wide and a head 6\n// long, in colour c over a dark rim 1 LED wide that keeps it off the tiles.\nfunction arrow(acc, x, y, c) {\n  const l = sqrt(x * x + y * y);\n  if (l \u003c 1) return;\n  const ux = x / l, uy = y / l, hl = min(6, l * 0.5), hw = hl * 0.45, sl = l - hl, k = hl / sqrt(hl * hl + hw * hw);\n  const x0 = max(0, floor(min(OX, OX + x) - 4)), x1 = min(W - 1, floor(max(OX, OX + x) + 5));\n  const y0 = max(0, floor(min(OY, OY + y) - 4)), y1 = min(H - 1, floor(max(OY, OY + y) + 5));\n  for (let py = y0; py \u003c= y1; py++)\n    for (let px = x0; px \u003c= x1; px++) {\n      const dx = px - OX, dy = py - OY, al = dx * ux + dy * uy, ac = abs(-dx * uy + dy * ux);\n      const ds = (al \u003c 0 ? sqrt(al * al + ac * ac) : al > sl ? sqrt((al - sl) ** 2 + ac * ac) : ac) - 0.75;\n      const dh = max(sl - al, al - l, (ac - (hw * (l - al)) / hl) * k);\n      const dd = min(ds, dh);\n      if (dd > 1.6) continue;\n      const kk = (py * W + px) * 3, w = cl(0.5 - dd, 0, 1), m = 1 - 0.6 * cl(1.6 - dd, 0, 1);\n      for (let i = 0; i \u003c 3; i++) acc[kk + i] = acc[kk + i] * m * (1 - w) + c[i] * w;\n    }\n}\nfunction dot(acc, x, y, c, w) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  put(acc, ix, iy, c, w * min(1, 1.7 * (1 - fx) * (1 - fy)));\n  put(acc, ix + 1, iy, c, w * min(1, 1.7 * fx * (1 - fy)));\n  put(acc, ix, iy + 1, c, w * min(1, 1.7 * (1 - fx) * fy));\n  put(acc, ix + 1, iy + 1, c, w * min(1, 1.7 * fx * fy));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const acc = S.acc, b = S.b, c = S.c, tile = S.tile;\n  // The basis on screen: during a shear b2 slides along b1 by q b1.\n  let b1x = b[0], b1y = b[1], b2x = b[2], b2y = b[3], mix = 0;\n  if (S.phase === 1 && S.op) {\n    const sc = 2 / S.speed, u = smooth(cl(S.pt / ((S.op.swap ? 0.4 : 0.55) * sc), 0, 1));\n    if (S.op.swap) mix = u;\n    else (b2x -= u * S.op.q * b1x), (b2y -= u * S.op.q * b1y);\n  }\n  const det = b1x * b2y - b1y * b2x, l1 = sqrt(len2(b1x, b1y)), l2 = sqrt(len2(b2x, b2y));\n  // Tile heights across each family of edges, and how much edge they carry.\n  const h1 = abs(det) / l2, h2 = abs(det) / l1, e1 = cl((h1 - 1.2) / 2, 0, 1), e2 = cl((h2 - 1.2) / 2, 0, 1);\n  const fl = S.flash * S.flash;\n  for (let k = 0; k \u003c 3; k++) hsv(S.hue + [0.5, 0.6, 0.73][k], 0.72 - 0.2 * fl, [0.56, 0.66, 0.76][k] + 0.12 * fl, tile[k]);\n  hsv(S.hue + 0.38, 0.8 - 0.3 * fl, 0.85 + 0.15 * fl, tile[3]);\n  // Each LED's place in the tiling: s along b1, t along b2. Tiles are\n  // coloured by (ca i + cb j) mod 3, which keeps every tile's colour when\n  // the arrows swap and never gives two tiles that share an edge one colour.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - OX, dy = y - OY, s = (dx * b2y - dy * b2x) / det, t = (b1x * dy - b1y * dx) / det;\n      const i = floor(s), j = floor(t), fs = s - i, ft = t - j;\n      const col = i === 0 && j === 0 ? tile[3] : tile[(((S.ca * i + S.cb * j) % 3) + 3) % 3];\n      const ed = max(e1 * cl(1 - (min(fs, 1 - fs) * h1) / 0.7, 0, 1), e2 * cl(1 - (min(ft, 1 - ft) * h2) / 0.7, 0, 1));\n      const m = 1 - 0.7 * ed, k = (y * W + x) * 3;\n      acc[k] = col[0] * m;\n      acc[k + 1] = col[1] * m;\n      acc[k + 2] = col[2] * m;\n    }\n  // The lattice points, from the reduced basis R: they never move.\n  const R = S.R, rd = R[0] * R[3] - R[1] * R[2], white = [1, 1, 1];\n  let span = 0;\n  for (const [x, y] of [[-OX, -OY], [W - OX, -OY], [-OX, H - OY], [W - OX, H - OY]]) {\n    span = max(span, abs((x * R[3] - y * R[2]) / rd) + 1, abs((R[0] * y - R[1] * x) / rd) + 1);\n  }\n  span = min(60, ceilInt(span));\n  for (let m = -span; m \u003c= span; m++)\n    for (let n = -span; n \u003c= span; n++) {\n      const x = OX + m * R[0] + n * R[2], y = OY + m * R[1] + n * R[3];\n      if (x > -1 && x \u003c W && y > -1 && y \u003c H) dot(acc, x, y, white, 0.95);\n    }\n  // The arrows; during a swap their colours cross over.\n  const a1 = [0, 0, 0], a2 = [0, 0, 0];\n  hsv(S.hue + 0.1, 0.85, 1, a1);\n  hsv(S.hue + 0.92, 0.6, 1, a2);\n  const ma = [0, 1, 2].map((k) => a1[k] + (a2[k] - a1[k]) * mix), mb = [0, 1, 2].map((k) => a2[k] + (a1[k] - a2[k]) * mix);\n  // During a shear, the path of b2's tip along b1, through the dots.\n  if (S.phase === 1 && S.op && !S.op.swap) {\n    const c2 = mb.map((v) => v * 0.8);\n    line(acc, OX + b[2], OY + b[3], OX + b2x, OY + b2y, c2, 0.8);\n  }\n  arrow(acc, b2x, b2y, mb);\n  arrow(acc, b1x, b1y, ma);\n  dot(acc, OX, OY, white, 1);\n  const xf = smooth(S.xf), old = S.old;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      for (let i = 0; i \u003c 3; i++) acc[k + i] = min(1, acc[k + i]);\n      const r = acc[k] + (old[k] - acc[k]) * xf, gr = acc[k + 1] + (old[k + 1] - acc[k + 1]) * xf, bl = acc[k + 2] + (old[k + 2] - acc[k + 2]) * xf;\n      display.setPixel(x, y, (255 * r) | 0, (255 * gr) | 0, (255 * bl) | 0);\n    }\n}\nconst ceilInt = (v) => -floor(-v);\n","optical-kerning":"// ===== Patternflow pattern =====\n// Title:   Optical Kerning\n// Family:  type\n// Idea:    Five words whose letters have open and slanted sides, AVOW, LYNX, TOY, WAVE and FLY among them, stand in capitals 19 LEDs tall down the panel, the white between each pair of neighbours glows in a colour that says how much of it there is, and after each word is set with the same 2 LED space between every pair of letter boxes, so that A and V gape while H and I sit tight, its letters slide sideways until every gap holds the same area and the glows of the word turn one colour, a wave of new words running down the panel every 6.35 s.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 72, after letter spacing worked out by formula in David Kindersley's Optical Letter Spacing for New Printing Systems (1976 edition) and by method in Walter Tracy's Letters of Credit (1986)\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tracking=-1..1, Depth=-1..1\n//\n// Knob 1: Hue. Turns the glow palette round the wheel. At 0 a gap 1.5 LEDs or less across on average glows violet-blue, 3.6 cyan, 6 yellow-green and 7.5 or more amber; the letters stay warm white.\n// Knob 2: Speed. At 2 a word is set, shown for 1.15 s at box spacing, slides into its spacing in 1.5 s, holds 3 s and goes, 6.35 s in all, and each line starts 0.45 s after the one above; at 0.2 a word takes 64 s, at 3 it takes 4.2 s.\n// Knob 3: Tracking. The area every gap is spaced to, given as its width averaged over the 19 rows: 3.6 LEDs at 0, where every gap of all ten words meets it, H and I stand 3.6 apart and A tucks 0.3 under V; 2.4 at -1, where seven pairs, Y N, F L and T O among them, reach the 1 LED that letters may come to and stay a little wider than the rest; 5.4 at 1, AVOW then 57 LEDs wide. The settled glows are blue at -1, cyan at 0 and green at 1.\n// Knob 4: Depth. How far into an open side the white is counted, measured in from the letter's outermost point: 3.2 LEDs at the opening 0.06. At -1 only 1 LED counts, every pair is spaced almost by its boxes and A V stands 1.9 apart instead of tucking under. At 1 the 8 LEDs counted reach right into the throats of A, V, L and T: A goes 0.6 under V and the L's foot 3.4 under the Y's arm, and still L Y, L T and F L cannot shed enough white without touching, so their glows stay yellow-green while the rest settle cyan.\n\n// The white between two letters is counted row by row through the cap\n// height: the horizontal distance between their facing contours, except\n// that on each side the distance is counted only Depth LEDs in from that\n// letter's outermost point. Without that limit the open sides of A, L, T, V\n// and Y would count all their white and pull their neighbours in until they\n// touched. Every pair is then moved until its area meets the Tracking\n// target, never closer than 1 LED in any row.\n//\n// Pairs whose slants run parallel, V Y or A X, cannot meet any target this\n// way: the tips touch before the throats close. The words leave them out.\n\nconst W = 64, H = 128, CAP = 19, HW = 1.25, LINES = 5, PITCH = 25, TOP0 = 4, BOX = 2, CLEAR = 1;\nconst { floor, round, min, max, abs, exp, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The capitals, drawn for this pattern in a box 19 LEDs tall: \"r\" is a\n// filled rectangle x0, y0, x1, y1; \"s\" a stroke 2.5 LEDs wide along a\n// segment, cut flat at the top and bottom of the box; \"o\" an elliptical\n// ring 2.5 LEDs wide with its centre and the radii of its middle line.\nconst GLYPHS = {\n  A: [[\"s\", 6, -1, 1.2, 19.6], [\"s\", 6, -1, 10.8, 19.6], [\"r\", 2.4, 12, 9.6, 14.5]],\n  V: [[\"s\", 1.2, -0.6, 6, 20], [\"s\", 10.8, -0.6, 6, 20]],\n  O: [[\"o\", 6, 9.5, 4.75, 8.25]],\n  W: [[\"s\", 1.1, -0.5, 4.3, 19.6], [\"s\", 4.3, 19.6, 7.5, 3], [\"s\", 7.5, 3, 10.7, 19.6], [\"s\", 10.7, 19.6, 13.9, -0.5]],\n  L: [[\"r\", 0, 0, 2.5, 19], [\"r\", 0, 16.5, 10, 19]],\n  Y: [[\"s\", 1.2, -0.6, 6, 10], [\"s\", 10.8, -0.6, 6, 10], [\"r\", 4.75, 9, 7.25, 19]],\n  N: [[\"r\", 0, 0, 2.5, 19], [\"r\", 9.5, 0, 12, 19], [\"s\", 1.4, 0.4, 10.6, 18.6]],\n  X: [[\"s\", 1.2, -0.6, 10.8, 19.6], [\"s\", 10.8, -0.6, 1.2, 19.6]],\n  T: [[\"r\", 0, 0, 12, 2.5], [\"r\", 4.75, 0, 7.25, 19]],\n  E: [[\"r\", 0, 0, 2.5, 19], [\"r\", 0, 0, 10, 2.5], [\"r\", 0, 8.25, 9, 10.75], [\"r\", 0, 16.5, 10, 19]],\n  F: [[\"r\", 0, 0, 2.5, 19], [\"r\", 0, 0, 10, 2.5], [\"r\", 0, 8.25, 9, 10.75]],\n  I: [[\"r\", 0, 0, 2.5, 19]],\n  H: [[\"r\", 0, 0, 2.5, 19], [\"r\", 8.5, 0, 11, 19], [\"r\", 0, 8.25, 11, 10.75]],\n};\n// Line k takes words k and k + 5 in turn.\nconst WORDS = [\"AVOW\", \"LYNX\", \"TOY\", \"WAVE\", \"FLY\", \"YAWL\", \"HILT\", \"VOLT\", \"AWAY\", \"OVAL\"];\n\n// Signed distance from a point in the box to the letter's ink (negative inside).\nfunction dist(parts, x, y) {\n  let d = 1e9;\n  for (const p of parts) {\n    let e;\n    if (p[0] === \"r\") {\n      const dx = max(p[1] - x, x - p[3]), dy = max(p[2] - y, y - p[4]);\n      e = dx > 0 && dy > 0 ? hypot(dx, dy) : max(dx, dy);\n    } else if (p[0] === \"s\") {\n      const ax = p[1], ay = p[2], bx = p[3] - ax, by = p[4] - ay;\n      const t = cl(((x - ax) * bx + (y - ay) * by) / (bx * bx + by * by), 0, 1);\n      e = max(hypot(x - ax - t * bx, y - ay - t * by) - HW, -y, y - CAP);\n    } else {\n      const qx = (x - p[1]) / p[3], qy = (y - p[2]) / p[4], k0 = hypot(qx, qy), k1 = hypot(qx / p[3], qy / p[4]);\n      e = abs((k0 * (k0 - 1)) / max(k1, 1e-6)) - HW;\n    }\n    if (e \u003c d) d = e;\n  }\n  return d;\n}\n\n// Each letter's contour, row by row, measured once: where the ink starts\n// and ends in the row's middle, and from those its outermost points.\nfunction measure(ch) {\n  const parts = GLYPHS[ch], lf = new Float32Array(CAP), rt = new Float32Array(CAP);\n  for (let r = 0; r \u003c CAP; r++) {\n    let a = 99, b = -99;\n    for (let x = -3; x \u003c= 17; x += 0.02) if (dist(parts, x, r + 0.5) \u003c= 0) { if (a === 99) a = x; b = x; }\n    lf[r] = a;\n    rt[r] = b;\n  }\n  let L = 99, R = -99;\n  for (let r = 0; r \u003c CAP; r++) (L = min(L, lf[r])), (R = max(R, rt[r]));\n  const ld = new Float32Array(CAP), rd = new Float32Array(CAP);\n  for (let r = 0; r \u003c CAP; r++) (ld[r] = lf[r] - L), (rd[r] = R - rt[r]);\n  return { parts, L, w: R - L, ld, rd };\n}\n\n// The white counted between a left letter and a right letter whose\n// outermost points stand g apart, and the g that gives a wanted area.\nfunction area(A, B, g, D) {\n  let s = 0;\n  for (let r = 0; r \u003c CAP; r++) s += max(0, g + min(A.rd[r], D) + min(B.ld[r], D));\n  return s;\n}\nfunction solve(A, B, want, D) {\n  let lo = -12;\n  for (let r = 0; r \u003c CAP; r++) lo = max(lo, CLEAR - A.rd[r] - B.ld[r]);\n  if (area(A, B, lo, D) >= want) return lo;\n  let hi = 30;\n  for (let i = 0; i \u003c 28; i++) {\n    const m = (lo + hi) / 2;\n    if (area(A, B, m, D) \u003c want) lo = m;\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\nfunction setWord(s, k, word) {\n  const ln = s.lines[k];\n  ln.word = word;\n  ln.g = [];\n  ln.letters = [...word].map((ch) => s.m[ch]);\n  for (let i = 0; i + 1 \u003c ln.letters.length; i++) ln.g.push(BOX);\n}\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.m = {};\n  for (const ch in GLYPHS) s.m[ch] = measure(ch);\n  s.lines = [];\n  for (let k = 0; k \u003c LINES; k++) {\n    s.lines.push({ tau: 0.35 - 0.45 * k, n: 0 });\n    setWord(s, k, WORDS[k]);\n  }\n  s.glow = new Float32Array(W * H * 3);\n  s.tmp = new Float32Array(W * H * 3);\n  s.ink = new Float32Array(W * H);\n  s.D = 3.18;\n  s.want = 3.6 * CAP;\n  s.hue = 0;\n}\n\n// Phases of a line, in seconds at Speed 2.\nconst T_IN = 0.35, T_SLIDE = 1.5, T_HOLD = 3.0, T_OUT = 6.0, T_END = 6.35;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  const tr = cl(k[2] || 0, -1, 1), dp = cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  s.want = (3.6 + (tr \u003c 0 ? 1.2 : 1.8) * tr) * CAP;\n  s.D = 3 * exp(dp * (dp \u003c 0 ? 1.0986 : 0.9808));\n  const follow = 1 - exp(-8 * dt);\n  for (let li = 0; li \u003c LINES; li++) {\n    const ln = s.lines[li];\n    ln.tau += dt * rate;\n    if (ln.tau >= T_END) {\n      ln.tau -= T_END;\n      ln.n++;\n      setWord(s, li, WORDS[(li + LINES * ln.n) % WORDS.length]);\n    }\n    const e = ease((ln.tau - T_SLIDE) / (T_HOLD - T_SLIDE));\n    for (let i = 0; i \u003c ln.g.length; i++) {\n      const target = BOX + (solve(ln.letters[i], ln.letters[i + 1], s.want, s.D) - BOX) * e;\n      ln.g[i] += (target - ln.g[i]) * (ln.tau \u003c T_HOLD ? 1 : follow);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const glow = s.glow, ink = s.ink, D = s.D;\n  glow.fill(0);\n  ink.fill(0);\n  const marks = [];\n  for (let li = 0; li \u003c LINES; li++) {\n    const ln = s.lines[li], top = TOP0 + li * PITCH, L = ln.letters;\n    // The first words are on the panel from the start; later ones fade in.\n    const fade = ln.n === 0 && ln.tau \u003c T_IN ? 1 : ln.tau \u003c T_IN ? ln.tau / T_IN : ln.tau > T_OUT ? 1 - (ln.tau - T_OUT) / (T_END - T_OUT) : 1;\n    let total = 0;\n    for (let i = 0; i \u003c L.length; i++) total += L[i].w + (i \u003c ln.g.length ? ln.g[i] : 0);\n    let x = 32 - total / 2;\n    const xs = [];\n    for (let i = 0; i \u003c L.length; i++) {\n      xs.push(x);\n      x += L[i].w + (i \u003c ln.g.length ? ln.g[i] : 0);\n    }\n    // Letters.\n    for (let i = 0; i \u003c L.length; i++) {\n      const g = L[i], ox = xs[i] - g.L;\n      const x0 = max(0, floor(xs[i] - 1)), x1 = min(W - 1, floor(xs[i] + g.w + 1));\n      for (let y = 0; y \u003c CAP; y++)\n        for (let px = x0; px \u003c= x1; px++) {\n          const c = cl(0.5 - dist(g.parts, px + 0.5 - ox, y + 0.5), 0, 1) * fade;\n          const j = (top + y) * W + px;\n          if (c > ink[j]) ink[j] = c;\n        }\n    }\n    // The counted white between each pair, and its colour.\n    for (let i = 0; i \u003c ln.g.length; i++) {\n      const A = L[i], B = L[i + 1], a = xs[i] + A.w, b = xs[i + 1];\n      const ar = area(A, B, b - a, D), mean = ar / CAP;\n      const sv = cl((mean - 1.5) / 6, 0, 1);\n      const col = hsv(0.7 + s.hue - 0.58 * sv, 0.9, 0.62 + 0.3 * sv);\n      const lv = fade;\n      for (let r = 0; r \u003c CAP; r++) {\n        const u0 = a - min(A.rd[r], D), u1 = b + min(B.ld[r], D);\n        if (u1 \u003c= u0) continue;\n        for (let px = max(0, floor(u0)); px \u003c= min(W - 1, floor(u1)); px++) {\n          const c = (min(px + 1, u1) - max(px, u0)) * lv;\n          if (c \u003c= 0) continue;\n          const j = ((top + r) * W + px) * 3;\n          glow[j] += col[0] * c;\n          glow[j + 1] += col[1] * c;\n          glow[j + 2] += col[2] * c;\n        }\n      }\n      // Under each gap a bar as long as the gap's mean width: its area\n      // laid out along one row.\n      let cx = 0, n = 0;\n      for (let r = 0; r \u003c CAP; r++) {\n        const u0 = a - min(A.rd[r], D), u1 = b + min(B.ld[r], D);\n        if (u1 > u0) (cx += (u0 + u1) / 2), n++;\n      }\n      marks.push([n ? cx / n : (a + b) / 2, top + CAP + 1, mean, col, fade]);\n    }\n  }\n  // Soften the glow: a 1-2-1 blur across and down.\n  const t = s.tmp;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const j = (y * W + x) * 3 + c;\n        t[j] = (2 * glow[j] + (x > 0 ? glow[j - 3] : 0) + (x \u003c W - 1 ? glow[j + 3] : 0)) / 4;\n      }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const j = (y * W + x) * 3 + c;\n        glow[j] = (2 * t[j] + (y > 0 ? t[j - W * 3] : 0) + (y \u003c H - 1 ? t[j + W * 3] : 0)) / 4;\n      }\n  for (const [cx, y, len, col, f] of marks) {\n    const u0 = cx - len / 2, u1 = cx + len / 2;\n    for (let px = max(0, floor(u0)); px \u003c= min(W - 1, floor(u1)); px++) {\n      const c = cl(min(px + 1, u1) - max(px, u0), 0, 1) * 0.9 * f;\n      const j = (y * W + px) * 3;\n      for (let q = 0; q \u003c 3; q++) glow[j + q] = max(glow[j + q], col[q] * c);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, j = i * 3, a = ink[i];\n      const r = glow[j] * 255 * (1 - a) + 242 * a, g = glow[j + 1] * 255 * (1 - a) + 234 * a, b = glow[j + 2] * 255 * (1 - a) + 218 * a;\n      display.setPixel(x, y, round(cl(r + 3, 0, 255)), round(cl(g + 3, 0, 255)), round(cl(b + 6, 0, 255)));\n    }\n}\n","ruppert-refinement":"// ===== Patternflow pattern =====\n// Title:   Ruppert Refinement\n// Family:  cells\n// Idea:    A polygon with notches and holes starts as the constrained Delaunay triangulation of its corners, a panel of magenta needles, and Ruppert's refinement mends it one point at a time: an encroached boundary segment is split at its midpoint, else the worst triangle shows its circumcircle and a point goes in at the centre, or the segment that centre would encroach is split instead, Lawson flips restore the Delaunay mesh, and each triangle wears the colour of its smallest angle until the domain is green, teal and blue.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Delaunay refinement (Jim Ruppert, \"A Delaunay refinement algorithm for quality 2-dimensional mesh generation\", J. Algorithms, 1995), Lawson flips (Charles L. Lawson, 1977), size limit as in Triangle (Jonathan Shewchuk, 1996), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bound=20..33, Domain=0..5\n//\n// Knob 1: Hue. Turns the angle colours round the wheel. At 0 needles are magenta, triangles halfway to the bound red, those just under it amber, and triangles past it green, then teal, then blue at 60 degrees; at 0.5 needles go green and the finished mesh magenta, red and orange.\n// Knob 2: Speed. Steps a second: 0.8 times Speed at first, and 1 + n / 24 times that after n new points, since later steps are smaller. At 2 the first steps come 1.6 a second and the opening domain is finished after 15 s; at 0.2 one step every 6 s, each circle in plain view.\n// Knob 3: Bound. The smallest angle a triangle may keep, 20 to 33 degrees. Triangles below it are coloured magenta to amber and get refined. Ruppert proved that the refinement stops for bounds up to 20.7 degrees when no two segments meet at less than 90, as in all six domains here; past 20.7 nothing is proved and above about 30 some inputs never finish, but these six do: 35 to 54 new points at 20, 58 to 166 at 33. Turning it up on a finished mesh starts the refinement again; turning it down only recolours it.\n// Knob 4: Domain. Which of six domains comes first: a slab with crenels top and bottom, a slab with slots and a diamond hole, an octagon with three small diamond holes at each end, a slab with notches 40 LEDs deep, a slab with a slot 63 LEDs tall, and a staircase. Each finished mesh holds 4 s and hands on to the next domain.\n// Buttons: K1 tap starts the next domain.\n\n// Ruppert (1995): start from a constrained Delaunay triangulation of the\n// input segments. While some segment has a vertex inside its diametral\n// circle (the circle it is a diameter of), split it at its midpoint.\n// Otherwise take a triangle whose smallest angle is below the bound and add\n// its circumcentre, unless that centre would encroach a segment: then split\n// the segment and leave the centre out. Each new point is joined to the\n// triangle (or the two triangles) it falls in and Lawson flips restore the\n// Delaunay property. The boundary sides are the segments and never flip.\n// The worst triangle goes first. Once none is below the bound, a triangle\n// whose circumcircle is wider than 22 LEDs is split the same way, a size\n// limit like Triangle's, so the open middle ends as a mesh too.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst DEG = PI / 180;\n\nconst NMAX = 700, TMAX = 2 * NMAX + 16;\n// Triangles with a circumradius under 1.1 LEDs are left alone; no domain\n// gets there even at 33 degrees.\nconst RMIN = 1.1, RMAX = 11, INTRO = 0.7, HOLD = 4, FADE = 0.6;\nconst FV = 0.84, FS = 0.88;\n\n// The domains in LEDs, outer ring first, then the holes. Every corner is 90\n// degrees or more. Most corners sit near the ends, so the first\n// triangulation is needles from end to end.\nconst rect = (x0, y0, x1, y1) => [x0, y0, x1, y0, x1, y1, x0, y1];\nconst diamond = (x, y, r) => [x, y - r, x + r, y, x, y + r, x - r, y];\n// A rectangle 3..60 by 3..124 with notches d deep cut into its top edge at\n// the x spans in top and into its bottom edge at those in bot.\nfunction notched(top, bot, d) {\n  const out = [3, 3];\n  for (let k = 0; k \u003c top.length; k += 2) out.push(top[k], 3, top[k], 3 + d, top[k + 1], 3 + d, top[k + 1], 3);\n  out.push(60, 3, 60, 124);\n  for (let k = bot.length - 2; k >= 0; k -= 2) out.push(bot[k + 1], 124, bot[k + 1], 124 - d, bot[k], 124 - d, bot[k], 124);\n  out.push(3, 124);\n  return out;\n}\n// Stairs: five steps 11 or 12 LEDs wide and 4 high down along the top and\n// five up along the bottom.\nconst STEPS = [3, 14, 26, 37, 49, 60];\nfunction stairs() {\n  const out = [3, 3];\n  for (let k = 0; k \u003c 5; k++) out.push(STEPS[k + 1], 3 + 4 * k, STEPS[k + 1], 7 + 4 * k);\n  out.length -= 2;\n  out.push(60, 124);\n  for (let k = 0; k \u003c 5; k++) out.push(STEPS[4 - k], 124 - 4 * k, STEPS[4 - k], 120 - 4 * k);\n  out.length -= 2;\n  return out;\n}\nconst DOMAINS = [\n  [notched([9, 16, 23, 30, 37, 44, 51, 56], [7, 13, 20, 27, 34, 41, 48, 55], 6)],\n  [notched([14, 19, 29, 34, 44, 49], [21, 26, 37, 42], 16), diamond(31.5, 32, 5)],\n  [[17, 3, 46, 3, 60, 17, 60, 110, 46, 124, 17, 124, 3, 110, 3, 17], diamond(19, 17, 3.5), diamond(31.5, 17, 3.5), diamond(44, 17, 3.5), diamond(19, 110, 3.5), diamond(31.5, 110, 3.5), diamond(44, 110, 3.5)],\n  [notched([10, 18, 45, 53], [22, 41], 40), rect(29, 16, 34, 28)],\n  [notched([20, 43], [8, 16, 47, 55], 8), rect(28, 32, 35, 95)],\n  [stairs()],\n];\n\nfunction hsv(h, s, v, out) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The colour of a smallest angle m: below the bound from magenta through red\n// to amber, from the bound to 60 degrees green through teal to blue.\nfunction angleHue(S, m) {\n  if (m \u003c S.bound) return S.hue + 0.84 + 0.27 * (m / S.bound);\n  return S.hue + 0.31 + 0.31 * cl((m - S.bound) / (PI / 3 - S.bound), 0, 1);\n}\n\n// ---- Predicates. Every stored triangle has orient > 0. ----\nconst orient = (P, a, b, c) =>\n  (P[2 * b] - P[2 * a]) * (P[2 * c + 1] - P[2 * a + 1]) - (P[2 * b + 1] - P[2 * a + 1]) * (P[2 * c] - P[2 * a]);\nfunction incircle(P, a, b, c, d) {\n  const dx = P[2 * d], dy = P[2 * d + 1];\n  const ax = P[2 * a] - dx, ay = P[2 * a + 1] - dy, bx = P[2 * b] - dx, by = P[2 * b + 1] - dy;\n  const cx = P[2 * c] - dx, cy = P[2 * c + 1] - dy;\n  const a2 = ax * ax + ay * ay, b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  return ax * (by * c2 - b2 * cy) - ay * (bx * c2 - b2 * cx) + a2 * (bx * cy - by * cx);\n}\nfunction angle(P, a, b, c) {\n  const ux = P[2 * b] - P[2 * a], uy = P[2 * b + 1] - P[2 * a + 1], vx = P[2 * c] - P[2 * a], vy = P[2 * c + 1] - P[2 * a + 1];\n  return atan2(abs(ux * vy - uy * vx), ux * vx + uy * vy);\n}\nfunction minAngle(S, t) {\n  const P = S.P, V = S.V, a = V[3 * t], b = V[3 * t + 1], c = V[3 * t + 2];\n  return min(angle(P, a, b, c), angle(P, b, c, a), angle(P, c, a, b));\n}\nfunction circum(P, a, b, c, out) {\n  const ax = P[2 * a], ay = P[2 * a + 1];\n  const bx = P[2 * b] - ax, by = P[2 * b + 1] - ay, cx = P[2 * c] - ax, cy = P[2 * c + 1] - ay;\n  const d = 2 * (bx * cy - by * cx), b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  const ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d;\n  out[0] = ax + ux;\n  out[1] = ay + uy;\n  out[2] = sqrt(ux * ux + uy * uy);\n}\n\n// ---- The starting triangulation: the holes bridged into the outer ring,\n// ears clipped, then Lawson flips to the constrained Delaunay one. ----\nfunction addPoint(S, x, y) {\n  const i = S.np++;\n  S.P[2 * i] = x;\n  S.P[2 * i + 1] = y;\n  S.pb[i] = S.t;\n  return i;\n}\nfunction build(S, d) {\n  const P = S.P, rings = [], edges = [];\n  S.np = 0;\n  for (const R of DOMAINS[d]) {\n    let ids = [], area = 0;\n    for (let k = 0; k \u003c R.length; k += 2) ids.push(addPoint(S, R[k], R[k + 1]));\n    for (let k = 0, n = R.length; k \u003c n; k += 2) area += R[k] * R[(k + 3) % n] - R[(k + 2) % n] * R[k + 1];\n    if ((area > 0) !== !rings.length) ids = ids.reverse();\n    rings.push(ids);\n    for (let k = 0; k \u003c ids.length; k++) edges.push(ids[k], ids[(k + 1) % ids.length]);\n  }\n  S.n0 = S.np;\n  let L = rings[0];\n  const holes = rings.slice(1).map((h) => {\n    let m = 0;\n    for (let k = 1; k \u003c h.length; k++) if (P[2 * h[k]] > P[2 * h[m]]) m = k;\n    return { h, m };\n  });\n  holes.sort((p, q) => P[2 * q.h[q.m]] - P[2 * p.h[p.m]]);\n  for (const { h, m } of holes) {\n    const v = h[m];\n    let best = -1, bd = 1e9;\n    for (let k = 0; k \u003c L.length; k++) {\n      const o = L[k], dd = (P[2 * o] - P[2 * v]) ** 2 + (P[2 * o + 1] - P[2 * v + 1]) ** 2;\n      if (dd >= bd) continue;\n      let ok = true;\n      for (let j = 0; j \u003c edges.length && ok; j += 2) {\n        const p = edges[j], q = edges[j + 1];\n        if (p === o || q === o || p === v || q === v) continue;\n        ok = !(orient(P, o, v, p) * orient(P, o, v, q) \u003c 0 && orient(P, p, q, o) * orient(P, p, q, v) \u003c 0);\n      }\n      if (ok) (best = k), (bd = dd);\n    }\n    const ring = h.slice(m).concat(h.slice(0, m + 1));\n    L = L.slice(0, best + 1).concat(ring, L.slice(best));\n  }\n  const tris = [];\n  while (L.length > 3) {\n    const n = L.length;\n    let found = -1;\n    for (let pass = 0; pass \u003c 2 && found \u003c 0; pass++)\n      for (let i = 0; i \u003c n && found \u003c 0; i++) {\n        const a = L[(i + n - 1) % n], v = L[i], b = L[(i + 1) % n];\n        if (orient(P, a, v, b) \u003c= 1e-9) continue;\n        const e = pass ? 1e-9 : -1e-9;\n        let ok = true;\n        for (let j = 0; j \u003c n && ok; j++) {\n          const p = L[j];\n          if (p === a || p === v || p === b) continue;\n          ok = !(orient(P, a, v, p) > e && orient(P, v, b, p) > e && orient(P, b, a, p) > e);\n        }\n        if (ok) found = i;\n      }\n    if (found \u003c 0) break;\n    tris.push(L[(found + n - 1) % n], L[found], L[(found + 1) % n]);\n    L.splice(found, 1);\n  }\n  if (L.length === 3) tris.push(...L);\n  link(S, tris);\n  for (let pass = 0, any = true; any && pass \u003c 100; pass++) {\n    any = false;\n    for (let e = 0; e \u003c 3 * S.T; e++) if (S.Nb[e] > ((e / 3) | 0) && illegal(S, e)) flip(S, e), (any = true);\n  }\n}\n// Nb[3t + i] is the triangle across t's side opposite its vertex i, -1 on\n// the boundary: the boundary sides are exactly the segments.\nfunction link(S, tris) {\n  const V = S.V, Nb = S.Nb, T = (S.T = tris.length / 3), seen = new Map();\n  for (let i = 0; i \u003c tris.length; i++) V[i] = tris[i];\n  Nb.fill(-1);\n  S.tb.fill(-9);\n  for (let e = 0; e \u003c 3 * T; e++) {\n    const t = (e / 3) | 0, b = V[3 * t + ((e + 1) % 3)], c = V[3 * t + ((e + 2) % 3)];\n    const key = min(b, c) * 4096 + max(b, c), o = seen.get(key);\n    if (o === undefined) seen.set(key, e);\n    else (Nb[e] = (o / 3) | 0), (Nb[o] = t);\n  }\n}\n\n// ---- Edges and flips. Edge e = 3t + i is t's side opposite vertex i. ----\nfunction quad(S, e, q) {\n  const V = S.V, t = (e / 3) | 0, i = e % 3, u = S.Nb[e];\n  if (u \u003c 0) return false;\n  let j = 0;\n  while (S.Nb[3 * u + j] !== t) j++;\n  q.splice(0, 6, V[e], V[3 * t + ((i + 1) % 3)], V[3 * t + ((i + 2) % 3)], V[3 * u + j], u, j);\n  return true;\n}\nfunction illegal(S, e) {\n  const q = S.q, P = S.P;\n  if (!quad(S, e, q)) return false;\n  const [a, b, c, d] = q;\n  return incircle(P, a, b, c, d) > 1e-6 && orient(P, a, b, d) > 0 && orient(P, d, c, a) > 0;\n}\n// t = a b c and u = d c b become t = a b d and u = d c a.\nfunction flip(S, e) {\n  const V = S.V, Nb = S.Nb, q = S.q;\n  quad(S, e, q);\n  const [a, b, c, d, u, j] = q, t = (e / 3) | 0, i = e % 3;\n  const nca = Nb[3 * t + ((i + 1) % 3)], nab = Nb[3 * t + ((i + 2) % 3)];\n  const nbd = Nb[3 * u + ((j + 1) % 3)], ndc = Nb[3 * u + ((j + 2) % 3)];\n  V.set([a, b, d], 3 * t);\n  Nb.set([nbd, u, nab], 3 * t);\n  V.set([d, c, a], 3 * u);\n  Nb.set([nca, t, ndc], 3 * u);\n  for (let k = 0; k \u003c 3; k++) {\n    if (nbd >= 0 && Nb[3 * nbd + k] === u) Nb[3 * nbd + k] = t;\n    if (nca >= 0 && Nb[3 * nca + k] === t) Nb[3 * nca + k] = u;\n  }\n  S.tb[t] = S.tb[u] = S.t;\n}\nconst repoint = (S, n, from, to) => {\n  for (let k = 0; n >= 0 && k \u003c 3; k++) if (S.Nb[3 * n + k] === from) S.Nb[3 * n + k] = to;\n};\nfunction setTri(S, t, a, b, c, na, nb, nc) {\n  S.V.set([a, b, c], 3 * t);\n  S.Nb.set([na, nb, nc], 3 * t);\n  S.tb[t] = S.t;\n}\n// Lawson: flip the side facing p while it is illegal, then the two sides\n// facing p of the triangles the flip made.\nfunction legalize(S, p, stack) {\n  for (let guard = 0; stack.length && guard \u003c 4000; guard++) {\n    const t = stack.pop();\n    let i = 0;\n    while (i \u003c 3 && S.V[3 * t + i] !== p) i++;\n    if (i === 3) continue;\n    const u = S.Nb[3 * t + i];\n    if (u >= 0 && illegal(S, 3 * t + i)) flip(S, 3 * t + i), stack.push(t, u);\n  }\n}\n// p inside t = a b c: three triangles round p.\nfunction insertIn(S, t, p) {\n  const V = S.V, Nb = S.Nb, a = V[3 * t], b = V[3 * t + 1], c = V[3 * t + 2];\n  const n0 = Nb[3 * t], n1 = Nb[3 * t + 1], n2 = Nb[3 * t + 2], t2 = S.T, t3 = S.T + 1;\n  S.T += 2;\n  setTri(S, t, a, b, p, t2, t3, n2);\n  setTri(S, t2, b, c, p, t3, t, n0);\n  setTri(S, t3, c, a, p, t, t2, n1);\n  repoint(S, n0, t, t2);\n  repoint(S, n1, t, t3);\n  legalize(S, p, [t, t2, t3]);\n}\n// p on side e of t (opposite a, from b to c). On a segment t splits in two;\n// inside, the triangle across splits too.\nfunction insertOn(S, e, p) {\n  const V = S.V, Nb = S.Nb, t = (e / 3) | 0, i = e % 3;\n  const a = V[e], b = V[3 * t + ((i + 1) % 3)], c = V[3 * t + ((i + 2) % 3)];\n  const nca = Nb[3 * t + ((i + 1) % 3)], nab = Nb[3 * t + ((i + 2) % 3)], u = Nb[e], t2 = S.T++;\n  if (u \u003c 0) {\n    setTri(S, t, a, b, p, -1, t2, nab);\n    setTri(S, t2, a, p, c, -1, nca, t);\n    repoint(S, nca, t, t2);\n    return legalize(S, p, [t, t2]);\n  }\n  let j = 0;\n  while (Nb[3 * u + j] !== t) j++;\n  const d = V[3 * u + j], nbd = Nb[3 * u + ((j + 1) % 3)], ndc = Nb[3 * u + ((j + 2) % 3)], u2 = S.T++;\n  setTri(S, t, a, b, p, u2, t2, nab);\n  setTri(S, t2, a, p, c, u, nca, t);\n  setTri(S, u, d, c, p, t2, u2, ndc);\n  setTri(S, u2, d, p, b, t, nbd, u);\n  repoint(S, nca, t, t2);\n  repoint(S, nbd, u, u2);\n  legalize(S, p, [t, t2, u, u2]);\n}\n\n// ---- Ruppert's tests. ----\nconst segEnds = (S, e) => [S.V[3 * ((e / 3) | 0) + ((e + 1) % 3)], S.V[3 * ((e / 3) | 0) + ((e + 2) % 3)]];\n// The longest segment with a point from p0 up to p1 inside its diametral\n// circle, or -1. Segments under 2.2 LEDs are not split again.\nfunction encroached(S, p0, p1) {\n  const P = S.P;\n  let best = -1, bl = 0;\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    if (S.Nb[e] >= 0) continue;\n    const [a, b] = segEnds(S, e), l = (P[2 * a] - P[2 * b]) ** 2 + (P[2 * a + 1] - P[2 * b + 1]) ** 2;\n    if (l \u003c 4 * RMIN * RMIN || l \u003c= bl) continue;\n    for (let p = p0; p \u003c p1; p++) {\n      const v = (P[2 * p] - P[2 * a]) * (P[2 * p] - P[2 * b]) + (P[2 * p + 1] - P[2 * a + 1]) * (P[2 * p + 1] - P[2 * b + 1]);\n      if (v \u003c -1e-7 && p !== a && p !== b) (bl = l), (best = e);\n    }\n  }\n  return best;\n}\n// The triangle with the smallest angle below the bound, or when there is\n// none the one with the widest circle past RMAX, or -1.\nfunction worst(S) {\n  let best = -1, bm = S.bound, br = RMAX;\n  for (let t = 0; t \u003c S.T; t++) {\n    const m = minAngle(S, t);\n    if (m >= bm) continue;\n    circum(S.P, S.V[3 * t], S.V[3 * t + 1], S.V[3 * t + 2], S.cc);\n    if (S.cc[2] >= RMIN) (best = t), (bm = m);\n  }\n  for (let t = 0; t \u003c S.T && best \u003c 0; t++) {\n    circum(S.P, S.V[3 * t], S.V[3 * t + 1], S.V[3 * t + 2], S.cc);\n    if (S.cc[2] > br) (best = t), (br = S.cc[2]);\n  }\n  return best;\n}\n// Walk from t toward point p: the triangle that holds it as { t }, the side\n// it lies on as { e }, or the segment in the way as { seg }.\nfunction locate(S, t, p) {\n  const P = S.P, V = S.V;\n  for (let g = 0; g \u003c 4 * S.T + 8; g++) {\n    let next = -1, on = -1;\n    for (let i = 0; i \u003c 3 && next \u003c 0; i++) {\n      const b = V[3 * t + ((i + 1) % 3)], c = V[3 * t + ((i + 2) % 3)];\n      const o = orient(P, b, c, p) / sqrt((P[2 * b] - P[2 * c]) ** 2 + (P[2 * b + 1] - P[2 * c + 1]) ** 2);\n      if (o \u003c -1e-7) next = i;\n      else if (o \u003c 1e-7) on = i;\n    }\n    const e = 3 * t + (next \u003c 0 ? on : next);\n    if (next \u003c 0 && on \u003c 0) return { t };\n    if (S.Nb[e] \u003c 0) return { seg: e };\n    if (next \u003c 0) return { e };\n    t = S.Nb[e];\n  }\n  return null;\n}\n\n// The next step, worked out before it is shown: { split } with the segment,\n// and the rejected centre when there is one, or { t } and its centre.\nfunction plan(S) {\n  const P = S.P, V = S.V, cc = S.cc;\n  if (S.np >= NMAX - 2) return null;\n  const seg = encroached(S, 0, S.np);\n  if (seg >= 0) return splitPlan(S, seg, null);\n  const t = worst(S);\n  if (t \u003c 0) return null;\n  circum(P, V[3 * t], V[3 * t + 1], V[3 * t + 2], cc);\n  const tri = [V[3 * t], V[3 * t + 1], V[3 * t + 2]], at = { t, tri, cx: cc[0], cy: cc[1], r: cc[2] };\n  // The centre waits in the next free slot while it is tested.\n  P[2 * S.np] = cc[0];\n  P[2 * S.np + 1] = cc[1];\n  const by = encroached(S, S.np, S.np + 1);\n  if (by >= 0) return splitPlan(S, by, at);\n  const where = locate(S, t, S.np);\n  if (!where) return null;\n  if (where.seg !== undefined) return splitPlan(S, where.seg, at);\n  return Object.assign(at, { where });\n}\nfunction splitPlan(S, e, from) {\n  const P = S.P, [a, b] = segEnds(S, e);\n  const mx = (P[2 * a] + P[2 * b]) / 2, my = (P[2 * a + 1] + P[2 * b + 1]) / 2;\n  return { split: e, a, b, mx, my, sr: sqrt((P[2 * a] - P[2 * b]) ** 2 + (P[2 * a + 1] - P[2 * b + 1]) ** 2) / 2, from };\n}\nfunction execute(S, pl) {\n  if (pl.split !== undefined) return insertOn(S, pl.split, addPoint(S, pl.mx, pl.my));\n  const p = addPoint(S, pl.cx, pl.cy);\n  if (pl.where.t !== undefined) insertIn(S, pl.where.t, p);\n  else insertOn(S, pl.where.e, p);\n}\n\nfunction restart(S, d) {\n  S.dom = d;\n  build(S, d);\n  Object.assign(S, { phase: 0, pt: 0, u: 0, pl: null });\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, bound: 20 * DEG, dom: -1, k4: -1, btn: false, n0: 0, np: 0, T: 0,\n    P: new Float64Array(2 * NMAX), pb: new Float32Array(NMAX),\n    V: new Int32Array(3 * TMAX), Nb: new Int32Array(3 * TMAX), tb: new Float32Array(TMAX),\n    phase: 0, pt: 0, u: 0, pl: null, q: [0, 0, 0, 0, 0, 0], cc: [0, 0, 0],\n    acc: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// Phases: 0 the corners' triangulation fades in, 1 refining, 2 holding the\n// finished mesh, 3 fading out to the next domain.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 20, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const bound = cl(k[2], 20, 33) * DEG, k4 = floor(cl(k[3], 0, 5.999));\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (k4 !== S.k4) (S.k4 = k4), restart(S, k4);\n  else if (btn && !S.btn) restart(S, (S.dom + 1) % DOMAINS.length);\n  S.btn = btn;\n  if (abs(bound - S.bound) > 1e-6) {\n    S.bound = bound;\n    if (S.phase === 1 && S.u \u003c 0.5) S.pl = plan(S);\n    if (S.phase === 2) (S.phase = 1), (S.u = 0), (S.pl = plan(S));\n  }\n  S.t += d;\n  S.pt += d;\n  if (S.phase === 0) {\n    if (S.pt >= INTRO) (S.phase = 1), (S.pt = 0), (S.u = 0), (S.pl = plan(S));\n    return;\n  }\n  if (S.phase === 2) {\n    if (S.pt >= HOLD) (S.phase = 3), (S.pt = 0);\n    return;\n  }\n  if (S.phase === 3) {\n    if (S.pt >= FADE) restart(S, (S.dom + 1) % DOMAINS.length);\n    return;\n  }\n  const rate = 0.8 * S.speed * (1 + (S.np - S.n0) / 24);\n  let left = d * rate;\n  while (left > 0 && S.phase === 1) {\n    if (!S.pl) {\n      (S.phase = 2), (S.pt = 0);\n      break;\n    }\n    const step = min(left, 1 - S.u);\n    if (S.u \u003c 0.5 && S.u + step >= 0.5) execute(S, S.pl);\n    S.u += step;\n    left -= step;\n    if (S.u >= 1 - 1e-9) (S.u = 0), (S.pl = plan(S));\n  }\n}\n\n// ---- Drawing into acc, a float RGB buffer. ----\nfunction fill(S, t, c) {\n  const P = S.P, V = S.V, acc = S.acc, xs = [0, 0, 0], ys = [0, 0, 0];\n  for (let k = 0; k \u003c 3; k++) (xs[k] = P[2 * V[3 * t + k]]), (ys[k] = P[2 * V[3 * t + k] + 1]);\n  for (let y = max(0, ceil(min(ys[0], ys[1], ys[2]))); y \u003c= min(H - 1, floor(max(ys[0], ys[1], ys[2]))); y++) {\n    let lo = W, hi = -1;\n    for (let e = 0; e \u003c 3; e++) {\n      const ya = ys[e], yb = ys[(e + 1) % 3];\n      if ((ya - y) * (yb - y) > 0 || ya === yb) continue;\n      const x = xs[e] + ((y - ya) * (xs[(e + 1) % 3] - xs[e])) / (yb - ya);\n      (lo = min(lo, x)), (hi = max(hi, x));\n    }\n    for (let x = max(0, ceil(lo - 0.5)); x \u003c= min(W - 1, floor(hi + 0.5)); x++) acc.set(c, (y * W + x) * 3);\n  }\n}\n// Mode 0 darkens what is there by w, mode 1 moves it toward c by w.\nfunction put(acc, x, y, c, w, mode) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  w = min(1, w);\n  for (let i = 0; i \u003c 3; i++) acc[k + i] = mode ? acc[k + i] + (c[i] - acc[k + i]) * w : acc[k + i] * (1 - c[i] * w);\n}\nfunction line(acc, x0, y0, x1, y1, c, w, mode) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0;\n  for (let x = max(0, ceil(x0)); x \u003c= min(st ? H - 1 : W - 1, floor(x1)); x++) {\n    const y = y0 + (x - x0) * s, iy = floor(y), f = y - iy;\n    if (st) put(acc, iy, x, c, w * (1 - f), mode), put(acc, iy + 1, x, c, w * f, mode);\n    else put(acc, x, iy, c, w * (1 - f), mode), put(acc, x, iy + 1, c, w * f, mode);\n  }\n}\n// A circle: by rows where it runs steep, by columns where it runs flat.\nfunction ring(acc, cx, cy, r, c, w) {\n  if (!(r > 0.5 && r \u003c 1e4)) return;\n  const h = r * 0.7072;\n  for (let ax = 0; ax \u003c 2; ax++) {\n    const a0 = ax ? cx : cy, b0 = ax ? cy : cx, n = ax ? W : H;\n    for (let u = max(0, ceil(a0 - h)); u \u003c= min(n - 1, floor(a0 + h)); u++) {\n      const dv = sqrt(max(0, r * r - (u - a0) ** 2));\n      for (const v of [b0 - dv, b0 + dv]) {\n        const iv = floor(v), f = v - iv;\n        if (ax) put(acc, u, iv, c, w * (1 - f), 1), put(acc, u, iv + 1, c, w * f, 1);\n        else put(acc, iv, u, c, w * (1 - f), 1), put(acc, iv + 1, u, c, w * f, 1);\n      }\n    }\n  }\n}\nfunction dot(acc, x, y, c, w) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let k = 0; k \u003c 4; k++)\n    put(acc, ix + (k & 1), iy + (k >> 1), c, w * min(1, 1.6 * (k & 1 ? fx : 1 - fx) * (k >> 1 ? fy : 1 - fy)), 1);\n}\n// The line from point a to point b.\nconst edge = (S, a, b, c, w, mode) => line(S.acc, S.P[2 * a], S.P[2 * a + 1], S.P[2 * b], S.P[2 * b + 1], c, w, mode);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const P = S.P, V = S.V, Nb = S.Nb, acc = S.acc, c = S.c, pl = S.pl;\n  const white = [1, 1, 1], dark = [0.62, 0.62, 0.62];\n  acc.fill(0);\n  // Fills by smallest angle, all at one brightness; a triangle just made\n  // starts pale and takes its colour over 0.4 s.\n  for (let t = 0; t \u003c S.T; t++) {\n    const age = S.t - S.tb[t];\n    hsv(angleHue(S, minAngle(S, t)), FS * (1 - 0.5 * exp(-age / 0.3)), FV, c);\n    fill(S, t, c);\n  }\n  // Inner edges darken what they cross; the segments are pale lines.\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    const t = (e / 3) | 0, u = Nb[e];\n    if (u >= 0 && u \u003c t) continue;\n    const a = V[3 * t + ((e + 1) % 3)], b = V[3 * t + ((e + 2) % 3)];\n    edge(S, a, b, u >= 0 ? dark : white, u >= 0 ? 1 : 0.85, u \u003c 0);\n  }\n  // The step under way: before its midpoint the circle grows bright, after\n  // it the new point is in and the circle fades.\n  if (S.phase === 1 && pl) {\n    const g = S.u \u003c 0.5 ? 0.25 + 1.5 * S.u : 1 - 1.6 * (S.u - 0.5);\n    const from = pl.split !== undefined ? pl.from : pl;\n    if (from) {\n      for (let k = 0; k \u003c 3 && S.u \u003c 0.5; k++) edge(S, from.tri[k], from.tri[(k + 1) % 3], white, g, 1);\n      ring(acc, from.cx, from.cy, from.r, white, 0.8 * g);\n      if (S.u \u003c 0.5) dot(acc, from.cx, from.cy, pl.split !== undefined ? dark : white, g);\n    }\n    if (pl.split !== undefined) {\n      hsv(S.hue + 0.11, 0.5, 1, c);\n      ring(acc, pl.mx, pl.my, pl.sr, c, g);\n      if (S.u \u003c 0.5) dot(acc, pl.mx, pl.my, white, g);\n    }\n  }\n  // New points shine white for a moment.\n  for (let i = S.n0; i \u003c S.np; i++) {\n    const w = exp(-(S.t - S.pb[i]) / 0.5);\n    if (w > 0.02) dot(acc, P[2 * i], P[2 * i + 1], white, w);\n  }\n  const g = S.phase === 0 ? min(1, S.pt / 0.5) : S.phase === 3 ? max(0, 1 - S.pt / FADE) : 1;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * g * min(1, acc[k])) | 0, (255 * g * min(1, acc[k + 1])) | 0, (255 * g * min(1, acc[k + 2])) | 0);\n    }\n}\n","schlieren-texture":"// ===== Patternflow pattern =====\n// Title:   Schlieren Texture\n// Family:  physics\n// Idea:    A nematic liquid crystal film between crossed polarizers, its director a line field relaxing by Ginzburg-Landau dynamics, so that disclinations of strength +1/2 and -1/2 drift together and annihilate while new pairs are let in, each half-strength core sitting on two dark brushes and each whole-strength core on four, the brushes swinging round the cores as the polarizers turn, over Michel-Levy interference colours that band in the second order down the wedge of the film and step down through the first order into every melted core.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: disinclination lines and the elastic theory of nematic liquid crystals (F. C. Frank, \"On the theory of liquid crystals\", 1958), Ginzburg-Landau relaxation of a complex order parameter (Vitaly Ginzburg and Lev Landau, 1950), interference colour chart (Auguste Michel-Levy, 1888), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Order=-1..1, Speed=0.2..3, Defects=10..30, Uncross=0..1\n//\n// Knob 1: Order. The film's retardation at its mean thickness, 850 + 650 Order nm. At the opening 0 it is 850 nm, and the wedge spreads it from about 620 nm at the top of the panel to 1080 nm at the bottom, the whole second order in bands: blue, cyan, green, yellow, orange, red and magenta. At -1 it is 200 nm, first-order grey and white; at -0.5, 525 nm, first-order orange and the violet of the sensitive tint; at 1, 1500 nm, the greens and pinks of the third order.\n// Knob 2: Speed. The polarizers turn at 0.03 Speed radians a second, 0.06 at the opening 2, and the brushes of a half-strength core turn twice as fast, a +1/2 core's with the polarizers and a -1/2 core's against them; crossed polarizers look the same after a quarter turn, 26 s at Speed 2, 17 s at 3. The film relaxes 10 Speed time units a second: at Speed 2 a lone pair of opposite cores 20 LEDs apart meets in about 3 s, 30 LEDs apart in about 11 s, 40 apart in 23 s.\n// Knob 3: Defects. The film opens with this many cores and keeps at least this many: when annihilation leaves fewer, new pairs are let in, 26 to 34 LEDs apart at the best of 14 spots away from the cores already there, up to three pairs at once and at most every 1.5 s, and the panel dissolves to them over 0.5 s. One pair in five is a +1 and a -1 with four brushes each, which come apart into half-strength cores within a few seconds. 10 at the opening, 30 at the top.\n// Knob 4: Uncross. Turns the analyzer away from crossed by 90 Uncross degrees: at 0 the polarizers are crossed and the brushes black, at the opening 0.06 they are 5.4 degrees off, at 0.5 the colours have paled and the brushes gone, and at 1 the polarizers are parallel, the brushes white and the colours turned to their pale complements.\n\n// The director n is a line field: n and -n are the same, so its angle theta\n// counts only modulo pi, and a loop round a core may turn it by half a turn,\n// a disclination of strength 1/2. The film is held as the complex order\n// parameter psi = S e^(2 i theta), whose phase counts modulo 2 pi: a\n// half-strength core is a single winding of psi, a whole-strength core a\n// double one, which splits because it costs twice the energy of two singles.\n// psi relaxes by d psi / dt = lap psi + a psi (1 - |psi|^2) with a = 0.15:\n// the order S is below 0.5 over 4 LEDs across a core and below 0.9 over 9.\n// Opposite cores attract and annihilate as the texture coarsens.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\nconst FADE = 0.5, GAIN = 1.4, AGL = 0.15, XI = 1 / sqrt(AGL);\n\n// ---- Michel-Levy colours: white light through a plate of retardation G\n// between crossed polarizers transmits sin^2(pi G / lambda) of each\n// wavelength. Summed against the CIE 1931 matching functions (the\n// multi-lobe fit of Chris Wyman, Peter-Pike Sloan and Peter Shirley, 2013)\n// from 400 to 700 nm and taken to sRGB, each channel divided by white's,\n// then saturated SAT times over for the panel and kept in linear light. One\n// entry each 2 nm up to 2400 nm. ----\nconst SAT = 3, GMAX = 2400, GSTEP = 2, GN = GMAX / GSTEP + 1, ML = new Float32Array(GN * 3);\n{\n  const g = (l, m, a, b) => exp(-0.5 * ((l - m) / (l \u003c m ? a : b)) ** 2);\n  const L = [], C = [];\n  for (let l = 400; l \u003c= 700; l += 10) {\n    L.push(l);\n    const x = 1.056 * g(l, 599.8, 37.9, 31) + 0.362 * g(l, 442, 16, 26.7) - 0.065 * g(l, 501.1, 20.4, 26.2);\n    const y = 0.821 * g(l, 568.8, 46.9, 40.5) + 0.286 * g(l, 530.9, 16.3, 31.1);\n    const z = 1.217 * g(l, 437, 11.8, 36) + 0.681 * g(l, 459, 26, 13.8);\n    C.push([3.2406 * x - 1.5372 * y - 0.4986 * z, -0.9689 * x + 1.8758 * y + 0.0415 * z, 0.0557 * x - 0.204 * y + 1.057 * z]);\n  }\n  const wh = [0, 0, 0];\n  for (const c of C) for (let k = 0; k \u003c 3; k++) wh[k] += c[k];\n  const enc = (v) => (v \u003c= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055);\n  const dec = (v) => (v \u003c= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4);\n  for (let i = 0; i \u003c GN; i++) {\n    const G = i * GSTEP, c = [0, 0, 0];\n    for (let j = 0; j \u003c L.length; j++) {\n      const s = sin((PI * G) / L[j]) ** 2;\n      for (let k = 0; k \u003c 3; k++) c[k] += C[j][k] * s;\n    }\n    for (let k = 0; k \u003c 3; k++) c[k] = enc(cl(c[k] / wh[k], 0, 1));\n    // Saturation (max - min) / max times SAT, hue and the brightest channel kept.\n    const mx = max(c[0], c[1], c[2]), mn = min(c[0], c[1], c[2]), sa = mx > 0 ? (mx - mn) / mx : 0, k2 = sa > 0 ? min(1, sa * SAT) / sa : 1;\n    for (let k = 0; k \u003c 3; k++) ML[i * 3 + k] = dec(mx - (mx - c[k]) * k2);\n  }\n}\n// Back to sRGB for the panel, 1024 steps of linear light.\nconst ENC = new Uint8Array(1025);\nfor (let i = 0; i \u003c= 1024; i++) {\n  const v = i / 1024;\n  ENC[i] = round(255 * (v \u003c= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055));\n}\n\n// The film's thickness, 1 at its mean: a wedge from 0.725 at the top to\n// 1.275 at the bottom and two shallow waves of 0.05 and 0.04 across it, so\n// the colours lie in wavy bands.\nconst D = new Float32Array(N);\nfor (let y = 0, p = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++, p++)\n    D[p] = 1 + 0.55 * ((y - 63.5) / 127) + 0.05 * sin(0.11 * x + 0.035 * y + 1) + 0.04 * sin(0.05 * y - 0.07 * x + 2);\n\n// A core of winding w (+-1 or +-2) at (cx, cy), multiplied into psi: its\n// phase, and its order melted to the profile of a relaxed core.\nfunction core(S, cx, cy, w) {\n  const { U, V } = S, n = abs(w);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const dx = x - cx, dy = y - cy, r2 = dx * dx + dy * dy;\n      const r = sqrt(r2) || 1e-6;\n      let c = dx / r, s = (w \u003c 0 ? -dy : dy) / r;\n      if (n === 2) (s = 2 * c * s), (c = 2 * c * c - 1);\n      // GL core profile, about r / sqrt(r^2 + 2 xi^2), n times over.\n      const f = (r / sqrt(r2 + 2 * XI * XI)) ** n;\n      const u = U[p], v = V[p];\n      U[p] = (u * c - v * s) * f;\n      V[p] = (u * s + v * c) * f;\n    }\n}\n\n// Where the cores are: winding of psi round each 2 by 2 square.\nfunction census(S) {\n  const { U, V, A } = S;\n  for (let p = 0; p \u003c N; p++) A[p] = atan2(V[p], U[p]);\n  const wrap = (d) => (d > PI ? d - TAU : d \u003c -PI ? d + TAU : d);\n  const list = [];\n  let count = 0;\n  for (let y = 0; y \u003c H - 1; y++)\n    for (let x = 0; x \u003c W - 1; x++) {\n      const p = y * W + x, a = A[p], b = A[p + 1], c = A[p + W + 1], d = A[p + W];\n      const w = round((wrap(b - a) + wrap(c - b) + wrap(d - c) + wrap(a - d)) / TAU);\n      if (w) {\n        list.push(x + 0.5, y + 0.5);\n        count += abs(w);\n      }\n    }\n  S.cores = list;\n  S.count = count;\n}\n\n// A spot for a pair: of 14 tries, the one furthest from the cores there.\nfunction spot(S, sep) {\n  let best = null, bd = -1;\n  for (let t = 0; t \u003c 14; t++) {\n    const an = Math.random() * PI, hx = 0.5 * sep * cos(an), hy = 0.5 * sep * sin(an);\n    const cx = 8 + abs(hx) + Math.random() * (48 - 2 * abs(hx)), cy = 8 + abs(hy) + Math.random() * (112 - 2 * abs(hy));\n    let d = 1e9;\n    for (let i = 0; i \u003c S.cores.length; i += 2)\n      for (const e of [-1, 1]) d = min(d, (S.cores[i] - cx - e * hx) ** 2 + (S.cores[i + 1] - cy - e * hy) ** 2);\n    if (d > bd) (bd = d), (best = [cx - hx, cy - hy, cx + hx, cy + hy]);\n  }\n  return best;\n}\n\nfunction pair(S) {\n  const w = Math.random() \u003c 0.2 ? 2 : 1, q = spot(S, 26 + Math.random() * 8);\n  core(S, q[0], q[1], w);\n  core(S, q[2], q[3], -w);\n}\n\n// Relax psi by time t in Euler steps of at most 0.2 (stable below 0.25),\n// walls with no flux through them.\nfunction relax(S, t) {\n  const n = Math.ceil(t / 0.2 - 1e-9);\n  if (n \u003c= 0) return;\n  const h = t / n;\n  let { U, V, U2, V2 } = S;\n  for (let k = 0; k \u003c n; k++) {\n    for (let y = 0, p = 0; y \u003c H; y++) {\n      const up = y > 0 ? -W : 0, dn = y \u003c H - 1 ? W : 0;\n      for (let x = 0; x \u003c W; x++, p++) {\n        const lf = x > 0 ? -1 : 0, rt = x \u003c W - 1 ? 1 : 0, u = U[p], v = V[p];\n        const lu = U[p + lf] + U[p + rt] + U[p + up] + U[p + dn] - 4 * u;\n        const lv = V[p + lf] + V[p + rt] + V[p + up] + V[p + dn] - 4 * v;\n        const g = AGL * (1 - u * u - v * v);\n        U2[p] = u + h * (lu + g * u);\n        V2[p] = v + h * (lv + g * v);\n      }\n    }\n    const tu = U, tv = V;\n    (U = U2), (V = V2), (U2 = tu), (V2 = tv);\n  }\n  S.U = U;\n  S.V = V;\n  S.U2 = U2;\n  S.V2 = V2;\n}\n\n// The opening film: n cores of alternating sign, no two closer than the\n// spacing allows, on a gently twisted background, relaxed 8 time units.\nfunction seed(S, n) {\n  const { U, V } = S;\n  const k1 = Math.random() * TAU, k2 = Math.random() * TAU;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const ph = 0.15 * sin(0.045 * x + 0.03 * y + k1) + 0.1 * sin(0.02 * x - 0.04 * y + k2);\n      U[p] = cos(ph);\n      V[p] = sin(ph);\n    }\n  const pts = [];\n  let dmin = 0.75 * sqrt(N / n), tries = 0;\n  while (pts.length \u003c 2 * n) {\n    const x = 6 + Math.random() * 52, y = 6 + Math.random() * 116;\n    if (++tries > 400) (dmin *= 0.9), (tries = 0);\n    let ok = true;\n    for (let i = 0; i \u003c pts.length && ok; i += 2) ok = (pts[i] - x) ** 2 + (pts[i + 1] - y) ** 2 >= dmin * dmin;\n    if (ok) pts.push(x, y);\n  }\n  for (let i = 0; i \u003c n; i++) core(S, pts[2 * i], pts[2 * i + 1], i & 1 ? -1 : 1);\n  relax(S, 8);\n  census(S);\n}\n\nexport function setup(params) {\n  params.s = {\n    U: new Float32Array(N), V: new Float32Array(N), U2: new Float32Array(N), V2: new Float32Array(N), A: new Float32Array(N),\n    LAST: new Uint8Array(N * 3), OLD: new Uint8Array(N * 3), fade: 9,\n    order: 0, speed: 2, want: 10, uncross: 0.06, phi: 0.3, t: 0, frame: 0, lastPair: -9, cores: [], count: 0, seeded: false,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 10, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.order = cl(k[0], -1, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.want = round(cl(k[2], 10, 30));\n  S.uncross = cl(k[3], 0, 1);\n  if (!S.seeded) {\n    seed(S, S.want + (S.want & 1));\n    S.seeded = true;\n  }\n  S.t += d;\n  S.fade += d;\n  S.phi += d * 0.03 * S.speed;\n  relax(S, d * 10 * S.speed);\n  if (++S.frame % 6 === 0) census(S);\n  if (S.count \u003c S.want && S.t - S.lastPair > 1.5) {\n    // Enough pairs at once to make up the count, three at most, and the\n    // panel dissolves from the last frame to the film with them over FADE\n    // seconds.\n    for (let m = min(3, Math.ceil((S.want - S.count) / 2)); m > 0; m--) {\n      pair(S);\n      census(S);\n    }\n    S.lastPair = S.t;\n    S.OLD.set(S.LAST);\n    S.fade = 0;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.seeded) {\n    for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, 0, 0, 0);\n    return;\n  }\n  const { U, V, OLD, LAST } = S, G0 = 850 + 650 * S.order, w0 = min(1, S.fade / FADE), w = w0 * w0 * (3 - 2 * w0);\n  // Polarizer at phi, analyzer at phi + 90 (1 - Uncross) degrees. A plate\n  // with its axis at theta passes cos^2(A - P) - sin 2(theta - P)\n  // sin 2(theta - A) times sin^2(pi G / lambda) of the light: with the\n  // polarizers crossed, sin^2 2(theta - P) of the colour, black where the\n  // director lies along either polarizer. Mixed in linear light, then\n  // encoded for the panel.\n  const P = S.phi, A = P + (PI / 2) * (1 - S.uncross);\n  const c2p = cos(2 * P), s2p = sin(2 * P), c2a = cos(2 * A), s2a = sin(2 * A), base = cos(A - P) ** 2;\n  for (let p = 0; p \u003c N; p++) {\n    const u = U[p], v = V[p], r = sqrt(u * u + v * v), Sq = min(1, r), iv = r > 1e-9 ? 1 / r : 0;\n    const c = u * iv, s = v * iv; // cos and sin of 2 theta\n    const kP = s * c2p - c * s2p, kA = s * c2a - c * s2a;\n    // Retardation d S: toward a core the colours step down through the\n    // orders to first-order grey, and the light fades as S^3 into it.\n    const G = G0 * D[p] * Sq;\n    const gi = min(GN - 2, G / GSTEP), i0 = floor(gi), f = gi - i0, o = i0 * 3;\n    const m = Sq * Sq * Sq * 1024 * GAIN, t = -kP * kA;\n    const R = (base + t * (ML[o] + f * (ML[o + 3] - ML[o]))) * m;\n    const Gc = (base + t * (ML[o + 1] + f * (ML[o + 4] - ML[o + 1]))) * m;\n    const B = (base + t * (ML[o + 2] + f * (ML[o + 5] - ML[o + 2]))) * m;\n    // Exposed GAIN times over: a channel past full scales the three down\n    // together, so the hue holds.\n    const q = max(1024, R, Gc, B) / 1024, o3 = p * 3;\n    let r8 = ENC[cl((R / q) | 0, 0, 1024)], g8 = ENC[cl((Gc / q) | 0, 0, 1024)], b8 = ENC[cl((B / q) | 0, 0, 1024)];\n    if (w \u003c 1) {\n      r8 = round(OLD[o3] + (r8 - OLD[o3]) * w);\n      g8 = round(OLD[o3 + 1] + (g8 - OLD[o3 + 1]) * w);\n      b8 = round(OLD[o3 + 2] + (b8 - OLD[o3 + 2]) * w);\n    }\n    LAST[o3] = r8;\n    LAST[o3 + 1] = g8;\n    LAST[o3 + 2] = b8;\n    display.setPixel(p & 63, p >> 6, r8, g8, b8);\n  }\n}\n","spray-stencil":"// ===== Patternflow pattern =====\n// Title:   Spray Stencil\n// Family:  type\n// Idea:    A grey metal stencil plate cut with the four syllables of 취급주의 (handle with care) one above the other lies on the side of a kraft cardboard crate, a spray nozzle sweeps down it in a zigzag and builds the paint out of soft particles, and when the plate slides off the letters stand on the crate with their bridges left as gaps, the counters of ㅇ, ㅁ and ㅂ held on by them; then the crate moves on and a fresh one comes under the next plate, 화기엄금 or 파손주의.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 72, after the stencilled handling marks on shipping crates, the syllables drawn for this pattern as a stencil face\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Plate=0..3, Overspray=0..1\n//\n// Knob 1: Hue. The paint: azure at 0, then violet, magenta, red at 0.4, orange, yellow and green round the wheel.\n// Knob 2: Speed. At 2 a crate takes 8.4 s: the plate slides on in 0.6 s, the nozzle sweeps it in 4 s, the plate slides off in 0.8 s, the letters hold 2.2 s and the crate moves on in 0.8 s. At 0.2 a crate takes 84 s, at 3 it takes 5.6 s.\n// Knob 3: Plate. 0 the three plates take turns, 취급주의, 화기엄금 (no open flame), 파손주의 (fragile); 1, 2 and 3 keep one of them. A new choice brings a fresh crate and plate at once.\n// Knob 4: Overspray. The nozzle's distance from the plate. At the opening 0.06 the droplets land with a standard deviation of 4 LEDs across the sweep and 3.2 down it, one in ten of them a finer mist spread 1.7 times wider, and the letters print crisp. At 1 the spread is 9.6 LEDs, nearly two in five are mist spread 3.2 times wider and dusting cuts the nozzle has not reached, and paint creeps under the plate's edges: of what lands on the plate 1 LED from a cut, 27 percent reaches the crate beneath, 3 LEDs out 13 percent, so the letters come up soft and haloed.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The stencil face. Each syllable is drawn in a box 52 LEDs wide and\n// 28 tall from cut-outs: [0, x0, y0, x1, y1] a rectangle, [1, xa, ya, xb, yb,\n// w] a slanted stroke w LEDs thick with flat ends, [2, cx, cy, rx, ry, t] an\n// elliptical ring t thick; and [3, x0, y0, x1, y1] a bridge, plate left\n// standing across a cut. Horizontal strokes are 3 to 4 LEDs, upright ones 5.\n// Every ring is bridged top and bottom, and the corners of ㄱ, ㄴ, ㅁ, ㅂ and\n// ㅍ, the peaks of ㅅ, ㅈ and ㅊ and the arms of ㅏ and ㅓ are cut apart by\n// 2 LEDs of plate, so no part of the plate is ringed by a cut and the inside\n// of ㅇ, ㅎ, ㅁ, ㅂ and ㅍ stays held to the rest: filled from its corner, LED\n// to LED across edges, each plate reaches all of its 5855 to 6056 LEDs. The\n// joins of ㅜ and ㅗ ring nothing and stay whole.\nconst SYL = {\n  취: [[0, 17, 0, 25, 3], [0, 5, 3, 37, 6.5], [1, 21, 8.5, 7, 16.5, 4.2], [1, 21, 8.5, 35, 16.5, 4.2], [3, 20, 8, 22, 17],\n    [0, 1, 18.5, 40, 22], [0, 18, 22, 23, 28], [0, 44, 0, 49, 28]],\n  급: [[0, 6, 0, 37, 3.5], [0, 39, 0, 44, 8.5], [0, 0, 10.5, 52, 13.5],\n    [0, 9, 15.5, 14, 28], [0, 38, 15.5, 43, 28], [0, 16, 20, 36, 23], [0, 16, 25, 36, 28]],\n  주: [[0, 7, 0, 45, 4], [1, 26, 6, 10, 15.5, 4.5], [1, 26, 6, 42, 15.5, 4.5], [3, 25, 5, 27, 16],\n    [0, 0, 17.5, 52, 21], [0, 23.5, 21, 28.5, 28]],\n  의: [[2, 20, 9, 14, 8.5, 4.5], [3, 19, 0, 21, 5.5], [3, 19, 12.5, 21, 18], [0, 1, 21, 40, 25], [0, 44, 0, 49, 28]],\n  화: [[0, 14, 0, 22, 2.5], [0, 5, 2.5, 31, 5.5], [2, 18, 11.5, 10, 4.8, 3.3], [3, 17, 6, 19, 10.5], [3, 17, 12.5, 19, 17],\n    [0, 15.5, 18, 20.5, 22.5], [0, 0, 22.5, 37, 26], [0, 41, 0, 46, 28], [0, 48, 11.5, 52, 15.5]],\n  기: [[0, 4, 3, 25, 7], [0, 27, 3, 32, 24], [0, 41, 0, 46, 28]],\n  엄: [[2, 15, 7.5, 12, 7.5, 4.5], [3, 14, 0, 16, 5], [3, 14, 10, 16, 15], [0, 29, 5.5, 35, 9.5], [0, 37, 0, 42, 15.5],\n    [0, 8, 17.5, 13, 28], [0, 37, 17.5, 42, 28], [0, 15, 17.5, 35, 21], [0, 15, 24.5, 35, 28]],\n  금: [[0, 6, 0, 37, 3.5], [0, 39, 0, 44, 8.5], [0, 0, 10.5, 52, 13.5],\n    [0, 9, 15.5, 14, 28], [0, 38, 15.5, 43, 28], [0, 16, 15.5, 36, 19], [0, 16, 24.5, 36, 28]],\n  파: [[0, 2, 1, 33, 5], [0, 2, 23, 33, 27], [1, 11, 7, 9, 21, 4.2], [1, 22, 7, 24, 21, 4.2], [0, 38, 0, 43, 28], [0, 45, 11.5, 51, 15.5]],\n  손: [[1, 26, 0, 11, 9.5, 4.2], [1, 26, 0, 41, 9.5, 4.2], [3, 25, 0, 27, 10], [0, 23.5, 9.5, 28.5, 14], [0, 0, 13.5, 52, 17],\n    [0, 8, 19, 13, 28], [0, 15, 24.5, 46, 28]],\n};\nconst PLATES = [[\"취\", \"급\", \"주\", \"의\"], [\"화\", \"기\", \"엄\", \"금\"], [\"파\", \"손\", \"주\", \"의\"]];\nconst SX = 6, SY = [3, 34, 65, 96];\n\nfunction inPrim(p, x, y) {\n  if (p[0] === 0 || p[0] === 3) return x >= p[1] && x \u003c p[3] && y >= p[2] && y \u003c p[4];\n  if (p[0] === 1) {\n    if (y \u003c p[2] || y >= p[4]) return false;\n    const dx = p[3] - p[1], dy = p[4] - p[2], c = p[1] + (dx * (y - p[2])) / dy;\n    return abs(x - c) \u003c (p[5] / 2) * (sqrt(dx * dx + dy * dy) / dy);\n  }\n  const qx = (x - p[1]) / p[3], qy = (y - p[2]) / p[4], qi = (x - p[1]) / (p[3] - p[5]), qj = (y - p[2]) / (p[4] - p[5]);\n  return qx * qx + qy * qy \u003c 1 && qi * qi + qj * qj >= 1;\n}\n\n// The plate: how much of each LED is cut away (0 to 1, from 4 by 4 samples),\n// and for the plate around the cuts, how far it is to the nearest cut.\nfunction makePlate(k) {\n  const hole = new Float32Array(N), far = new Float32Array(N).fill(99);\n  PLATES[k].forEach((ch, r) => {\n    const prims = SYL[ch], cuts = prims.filter((p) => p[0] !== 3), bridges = prims.filter((p) => p[0] === 3);\n    for (let y = 0; y \u003c 28; y++)\n      for (let x = -1; x \u003c 53; x++) {\n        let c = 0;\n        for (let j = 0; j \u003c 4; j++)\n          for (let i = 0; i \u003c 4; i++) {\n            const u = x + (i + 0.5) / 4, v = y + (j + 0.5) / 4;\n            if (cuts.some((p) => inPrim(p, u, v)) && !bridges.some((p) => inPrim(p, u, v))) c++;\n          }\n        const px = x + SX, py = y + SY[r];\n        if (c && px >= 0 && px \u003c W) hole[py * W + px] = c / 16;\n      }\n  });\n  for (let i = 0; i \u003c N; i++) if (hole[i] >= 0.5) far[i] = 0;\n  // Two chamfer passes give the distance to the nearest cut.\n  const step = (i, j, d) => { if (far[j] + d \u003c far[i]) far[i] = far[j] + d; };\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (x > 0) step(i, i - 1, 1);\n      if (y > 0) step(i, i - W, 1), x > 0 && step(i, i - W - 1, 1.41), x \u003c W - 1 && step(i, i - W + 1, 1.41);\n    }\n  for (let y = H - 1; y >= 0; y--)\n    for (let x = W - 1; x >= 0; x--) {\n      const i = y * W + x;\n      if (x \u003c W - 1) step(i, i + 1, 1);\n      if (y \u003c H - 1) step(i, i + W, 1), x > 0 && step(i, i + W - 1, 1.41), x \u003c W - 1 && step(i, i + W + 1, 1.41);\n    }\n  return { hole, far, paint: new Float32Array(N) };\n}\n\n// ---- Surfaces: value noise from a hash.\nconst hash = (a, b, c) => {\n  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  h = Math.imul(h ^ (h >>> 16), 2246822519);\n  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n};\nfunction vn(x, y, k) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);\n  const a = hash(x0, y0, k), b = hash(x0 + 1, y0, k), c = hash(x0, y0 + 1, k), d = hash(x0 + 1, y0 + 1, k);\n  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n}\n// Kraft board: the flutes of the corrugation run up the side 4 LEDs apart,\n// with fibre speckle and a tint that differs a little from crate to crate.\nfunction makeCrate(seed) {\n  const t = 0.93 + 0.14 * hash(seed, 7, 1), warm = 0.04 * (hash(seed, 9, 2) - 0.5);\n  const lum = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++)\n      lum[y * W + x] = t * (0.92 + 0.07 * vn(x / 9, y / 13, seed) + 0.05 * (hash(x, y, seed) - 0.5) + 0.035 * cos((2 * PI * x) / 4));\n  return { lum, warm, paint: new Float32Array(N) };\n}\n\nfunction gauss() {\n  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n}\n\n// Phases of a crate, in seconds at Speed 2.\nconst T_ON = 0.6, T_SPRAY = 4.0, T_OFF = 0.8, T_HOLD = 2.2, T_MOVE = 0.8;\nconst P_SPRAY = T_ON, P_OFF = P_SPRAY + T_SPRAY, P_HOLD = P_OFF + T_OFF, P_MOVE = P_HOLD + T_HOLD, P_END = P_MOVE + T_MOVE;\nconst DROPS = 26000; // droplets in one pass of the nozzle\nconst PRE = 0.35;\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.plates = [0, 1, 2].map(makePlate);\n  s.seed = 1;\n  s.crate = makeCrate(s.seed);\n  s.next = makeCrate(s.seed + 1);\n  s.mode = -1;\n  s.which = 0;\n  // The panel opens on a plate the nozzle is already a third of the way down.\n  s.t = P_SPRAY + PRE * T_SPRAY;\n  s.nx = -9;\n  s.ny = -9;\n  s.fresh = [];\n  s.hue = 0;\n  s.ov = 0.06;\n  s.buf = new Float32Array(N * 3);\n}\n\nfunction freshCrate(s) {\n  s.seed++;\n  s.crate = s.next;\n  s.next = makeCrate(s.seed + 1);\n}\n\nfunction spray(s, a, b) {\n  // The nozzle runs 13 sweeps across while it moves steadily down, from\n  // 6 LEDs above the panel to 6 below, so its path is a zigzag.\n  const ov = s.ov, sig = 3.6 + 6 * ov, plate = s.plates[s.which], hole = plate.hole, far = plate.far;\n  const pos = (p) => {\n    const q = p * 13, k = floor(q), f = q - k;\n    return [k % 2 ? 72 - 80 * f : -8 + 80 * f, -6 + 140 * p];\n  };\n  const n = round(DROPS * (b - a));\n  const ss = 0.5 + 0.6 * ov, reach = ss > 0.8 ? 2 : 1, bleed = 0.4 * ov * ov, bl = 0.4 + 2.2 * ov;\n  s.fresh.length = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const [px, py] = pos(a + ((b - a) * (i + Math.random())) / n);\n    const mist = Math.random() \u003c 0.08 + 0.3 * ov, r = mist ? sig * (1.6 + 1.6 * ov) : sig, m = mist ? 0.5 : 1;\n    const x = px + gauss() * r, y = py + gauss() * r * 0.8;\n    if (x \u003c -2 || x > W + 1 || y \u003c -2 || y > H + 1) continue;\n    if (i % 2 === 0 && s.fresh.length \u003c 240) s.fresh.push(x, y);\n    const x0 = floor(x), y0 = floor(y);\n    for (let yy = y0 - reach; yy \u003c= y0 + reach; yy++) {\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let xx = x0 - reach; xx \u003c= x0 + reach; xx++) {\n        if (xx \u003c 0 || xx >= W) continue;\n        const dx = xx + 0.5 - x, dy = yy + 0.5 - y, w = (m * exp(-(dx * dx + dy * dy) / (2 * ss * ss))) / (2 * PI * ss * ss);\n        const j = yy * W + xx, c = hole[j];\n        s.crate.paint[j] += w * (c + (1 - c) * bleed * exp(-far[j] / bl));\n        plate.paint[j] += w * (1 - c);\n      }\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  s.ov = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const mode = round(cl(k[2] || 0, 0, 3));\n  if (mode !== s.mode) {\n    // A new choice: fresh crate, and the plate slides on.\n    const first = s.mode \u003c 0;\n    s.mode = mode;\n    s.which = mode ? mode - 1 : 0;\n    if (first) spray(s, 0, PRE);\n    else {\n      freshCrate(s);\n      s.t = 0;\n    }\n  }\n  const t0 = s.t;\n  s.t += dt * rate;\n  s.fresh.length = 0;\n  if (s.t > P_SPRAY && t0 \u003c P_OFF) {\n    const a = cl((t0 - P_SPRAY) / T_SPRAY, 0, 1), b = cl((s.t - P_SPRAY) / T_SPRAY, 0, 1);\n    if (b > a) spray(s, a, b);\n    const q = b * 13, kk = floor(q), f = q - kk;\n    s.nx = kk % 2 ? 72 - 80 * f : -8 + 80 * f;\n    s.ny = -6 + 140 * b;\n  }\n  if (s.t >= P_END) {\n    s.t -= P_END;\n    freshCrate(s);\n    if (!s.mode) s.which = (s.which + 1) % 3;\n    // The plate is wiped between crates, but not clean.\n    const pp = s.plates[s.which].paint;\n    for (let i = 0; i \u003c N; i++) pp[i] *= 0.35;\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const t = s.t, plate = s.plates[s.which], hole = plate.hole, pp = plate.paint, buf = s.buf;\n  const paint = hsv(0.6 + s.hue, 0.88, 1);\n  // Plate offset: slides on from the right, off to the right.\n  const off = t \u003c P_SPRAY ? round(68 * (1 - ease(t / T_ON))) : t \u003c P_OFF ? 0 : round(68 * ease((t - P_OFF) / T_OFF));\n  const lift = t >= P_OFF && t \u003c P_HOLD ? 1 : 0;\n  // Crate move: the painted crate slides down and out, the fresh one follows.\n  const drop = t >= P_MOVE ? round(H * ease((t - P_MOVE) / T_MOVE)) : 0;\n  const kraft = [176, 121, 66];\n  for (let y = 0; y \u003c H; y++) {\n    const sy = y - drop, old = sy >= 0, cr = old ? s.crate : s.next, row = old ? sy : sy + H;\n    const seam = drop && (sy === 0 || sy === -1) ? 0.45 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const i = row * W + x, l = cr.lum[i] * seam;\n      let r = kraft[0] * l * (1 + cr.warm), g = kraft[1] * l, b = kraft[2] * l * (1 - cr.warm);\n      const a = 1 - exp(-1.4 * cr.paint[i]);\n      r += (paint[0] * 250 - r) * a;\n      g += (paint[1] * 250 - g) * a;\n      b += (paint[2] * 250 - b) * a;\n      // The plate over the crate, shifted right by off.\n      const px = x - off;\n      if (px >= 0 && px \u003c W && !drop) {\n        const j = y * W + px, c = hole[j];\n        // The cut's upper left edge throws a one-LED shadow into the hole.\n        const sh = c > 0 && ((px > 0 && hole[j - 1] \u003c 0.5) || (y > 0 && hole[j - W] \u003c 0.5)) ? 0.55 : 1;\n        const brush = 0.94 + 0.08 * hash(0, y, 5) + 0.03 * (hash(px, y, 3) - 0.5);\n        let mr = 100 * brush, mg = 100 * brush, mb = 98 * brush;\n        const pa = (1 - exp(-0.6 * pp[j])) * 0.45;\n        mr += (paint[0] * 150 - mr) * pa;\n        mg += (paint[1] * 150 - mg) * pa;\n        mb += (paint[2] * 150 - mb) * pa;\n        r = r * sh * c + mr * (1 - c);\n        g = g * sh * c + mg * (1 - c);\n        b = b * sh * c + mb * (1 - c);\n      } else if (lift && px >= -3 && px \u003c 0) {\n        // The lifted plate's shadow just left of its edge.\n        const d = 0.55 + 0.15 * (3 + px);\n        r *= d;\n        g *= d;\n        b *= d;\n      }\n      const o = (y * W + x) * 3;\n      buf[o] = r;\n      buf[o + 1] = g;\n      buf[o + 2] = b;\n    }\n  }\n  // The nozzle: a cloud of paint in the air over the sweep, and the droplets\n  // landing this frame.\n  if (t > P_SPRAY && t \u003c P_OFF) {\n    const rad = (3.6 + 6 * s.ov) * 1.3, amp = 0.26 + 0.34 * s.ov;\n    for (let y = max(0, floor(s.ny - 2 * rad)); y \u003c min(H, s.ny + 2 * rad); y++)\n      for (let x = max(0, floor(s.nx - 2 * rad)); x \u003c min(W, s.nx + 2 * rad); x++) {\n        const dx = x + 0.5 - s.nx, dy = y + 0.5 - s.ny, d2 = dx * dx + dy * dy;\n        const e = min(0.85, amp * exp(-d2 / (rad * rad)) + 0.8 * exp(-d2 / 1.6));\n        const o = (y * W + x) * 3;\n        for (let q = 0; q \u003c 3; q++) buf[o + q] += (min(255, paint[q] * 255 + 140 * e) - buf[o + q]) * e;\n      }\n    const f = s.fresh;\n    for (let i = 0; i \u003c f.length; i += 2) {\n      const x = floor(f[i]), y = floor(f[i + 1]);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) buf[o + q] += (min(255, paint[q] * 255 + 110) - buf[o + q]) * 0.8;\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(buf[o], 0, 255)), round(cl(buf[o + 1], 0, 255)), round(cl(buf[o + 2], 0, 255)));\n    }\n}\n","benton-pantograph":"// ===== Patternflow pattern =====\n// Title:   Benton Pantograph\n// Family:  type\n// Idea:    A stylus runs round the outline of a large pattern letter while a pantograph's bars carry its motion down to a cutter that engraves the same letter at a quarter of the size on a steel blank, slanted and condensed or extended by the knobs past what the plain pantograph would give, and the finished punches of BENTON, PUNCH, MATRIX and FAMILY stand in rows below.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Benton pantograph punch-cutter (Linn Boyd Benton, 1885), the pantograph (Christoph Scheiner, 1603), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Slant=0..0.45, Width=-1..1\n//\n// Knob 1: Hue. Turns the brass of the pattern and the punches round the wheel together with the steel blue of the bars; at 0 the pattern is brass and the cut metal pale gold.\n// Knob 2: Speed. At 2 the stylus runs 30 units a second round the outline (the cap height is 14 units), about 94 LEDs of the pattern, so tracing a B takes 3.0 s, BENTON 25.8 s and all four words 94 s; 0.2 is a tenth as fast, 3 half as fast again.\n// Knob 3: Slant. Leans the cut letter by this much of its height: 0 is upright, 0.45 leans the top 24 degrees to the right. The pattern stays upright; only the letter being cut and the punches cut after the turn take it.\n// Knob 4: Width. Condenses or extends the cut letter: -1 is 55% of the pattern's width, 0 as drawn, 1 is 145%. The punches in the rows keep the width they were cut at.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, min, max, sqrt, abs, sin, cos } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The pattern letters, a heavy gothic drawn as outlines: cap height 14\n// units, stems 3, y down from the cap line, x from the left side bearing.\n// Each glyph is [width, contour, hole, ...]; filled even-odd.\nconst GLYPH = {\n  B: [10.5, [0, 0, 7.8, 0, 10, 2, 10, 5.2, 8.7, 6.6, 10.5, 8.2, 10.5, 12, 8.5, 14, 0, 14], [3, 2.8, 6.8, 2.8, 7.2, 3.3, 7.2, 5, 6.8, 5.5, 3, 5.5], [3, 8.3, 7.2, 8.3, 7.6, 8.8, 7.6, 10.7, 7.2, 11.2, 3, 11.2]],\n  E: [9.5, [0, 0, 9.5, 0, 9.5, 2.8, 3, 2.8, 3, 5.6, 8.2, 5.6, 8.2, 8.4, 3, 8.4, 3, 11.2, 9.5, 11.2, 9.5, 14, 0, 14]],\n  N: [11, [0, 0, 3.2, 0, 8, 8.6, 8, 0, 11, 0, 11, 14, 7.8, 14, 3, 5.4, 3, 14, 0, 14]],\n  T: [11, [0, 0, 11, 0, 11, 2.8, 7, 2.8, 7, 14, 4, 14, 4, 2.8, 0, 2.8]],\n  O: [11.5, [3.2, 0, 8.3, 0, 11.5, 3.2, 11.5, 10.8, 8.3, 14, 3.2, 14, 0, 10.8, 0, 3.2], [4.3, 2.8, 7.2, 2.8, 8.5, 4.1, 8.5, 9.9, 7.2, 11.2, 4.3, 11.2, 3, 9.9, 3, 4.1]],\n  P: [10.3, [0, 0, 7.8, 0, 10.3, 2.4, 10.3, 6.4, 7.8, 8.8, 3, 8.8, 3, 14, 0, 14], [3, 2.8, 6.9, 2.8, 7.4, 3.3, 7.4, 5.5, 6.9, 6, 3, 6]],\n  U: [11, [0, 0, 3, 0, 3, 10.3, 3.9, 11.2, 7.1, 11.2, 8, 10.3, 8, 0, 11, 0, 11, 11, 8, 14, 3, 14, 0, 11]],\n  C: [11, [3.2, 0, 8, 0, 11, 3, 11, 4.6, 8, 4.6, 8, 4.1, 6.7, 2.8, 4.3, 2.8, 3, 4.1, 3, 9.9, 4.3, 11.2, 6.7, 11.2, 8, 9.9, 8, 9.4, 11, 9.4, 11, 11, 8, 14, 3.2, 14, 0, 10.8, 0, 3.2]],\n  H: [11, [0, 0, 3, 0, 3, 5.6, 8, 5.6, 8, 0, 11, 0, 11, 14, 8, 14, 8, 8.4, 3, 8.4, 3, 14, 0, 14]],\n  M: [13, [0, 0, 3.6, 0, 6.5, 7.5, 9.4, 0, 13, 0, 13, 14, 10, 14, 10, 5.5, 7.8, 11.5, 5.2, 11.5, 3, 5.5, 3, 14, 0, 14]],\n  A: [12, [4, 0, 8, 0, 12, 14, 8.9, 14, 8.1, 11, 3.9, 11, 3.1, 14, 0, 14], [4.6, 8.4, 7.4, 8.4, 6.2, 3.8, 5.8, 3.8]],\n  R: [10.8, [0, 0, 7.8, 0, 10.3, 2.4, 10.3, 6.2, 8.4, 8.2, 10.8, 14, 7.6, 14, 5.6, 8.8, 3, 8.8, 3, 14, 0, 14], [3, 2.8, 6.9, 2.8, 7.4, 3.3, 7.4, 5.5, 6.9, 6, 3, 6]],\n  I: [3, [0, 0, 3, 0, 3, 14, 0, 14]],\n  X: [12, [0, 0, 3.4, 0, 6, 4.6, 8.6, 0, 12, 0, 7.8, 7, 12, 14, 8.6, 14, 6, 9.4, 3.4, 14, 0, 14, 4.2, 7]],\n  F: [9.5, [0, 0, 9.5, 0, 9.5, 2.8, 3, 2.8, 3, 5.8, 8.2, 5.8, 8.2, 8.6, 3, 8.6, 3, 14, 0, 14]],\n  L: [9, [0, 0, 3, 0, 3, 11.2, 9, 11.2, 9, 14, 0, 14]],\n  Y: [12, [0, 0, 3.4, 0, 6, 5.2, 8.6, 0, 12, 0, 7.5, 8.6, 7.5, 14, 4.5, 14, 4.5, 8.6]],\n};\n// Arc length along each glyph's contours, for the stylus.\nconst PATH = {};\nfor (const ch in GLYPH) {\n  const cs = GLYPH[ch].slice(1), out = [];\n  let total = 0;\n  for (const c of cs) {\n    const n = c.length / 2, cum = [0];\n    for (let i = 0; i \u003c n; i++) {\n      const j = (i + 1) % n;\n      cum.push(cum[i] + sqrt((c[2 * j] - c[2 * i]) ** 2 + (c[2 * j + 1] - c[2 * i + 1]) ** 2));\n    }\n    out.push({ c, n, cum, len: cum[n] });\n    total += cum[n];\n  }\n  PATH[ch] = { cs: out, total };\n}\nfunction along(ch, d) {\n  // The point at distance d along contour after contour.\n  for (const k of PATH[ch].cs) {\n    if (d \u003c= k.len) {\n      let i = 0;\n      while (i \u003c k.n - 1 && k.cum[i + 1] \u003c d) i++;\n      const j = (i + 1) % k.n, f = (d - k.cum[i]) / max(1e-6, k.cum[i + 1] - k.cum[i]);\n      return [k.c[2 * i] + (k.c[2 * j] - k.c[2 * i]) * f, k.c[2 * i + 1] + (k.c[2 * j + 1] - k.c[2 * i + 1]) * f];\n    }\n    d -= k.len;\n  }\n  const k = PATH[ch].cs[PATH[ch].cs.length - 1];\n  return [k.c[0], k.c[1]];\n}\n\n// ---- The machine. The pattern's cap line at y = 5 and baseline at 49, so\n// a unit is 44/14 = 3.14 LEDs, centred on x = 36. The fixed pivot O at\n// (4, 90). Bars O-J of 52 and J-T of 50 LEDs, elbow to the right: over the\n// whole pattern J stays inside x 31..56, y 46..101. Collars at A on O-J and\n// D on J-T, a share s from O and from J, carry the links that meet at\n// P = O + s (T - O), the plain pantograph's point: a copy s times the size,\n// scaled about O, upright and as wide as drawn. Benton's machine added the\n// motions that condense, extend and slant; here they are a stage between P\n// and the cutter C, about the copy's baseline origin.\nconst PS = 44 / 14, PY = 5, PCX = 36, OX = 4, OY = 90, L1 = 52, L2 = 50;\nconst WORDS = [\"BENTON\", \"PUNCH\", \"MATRIX\", \"FAMILY\"];\n// Each word cut at its own ratio, so the collars slide between words: cap\n// heights 11.4, 9.7, 13.2 and 10.6 LEDs.\nconst RATIO = [0.26, 0.22, 0.3, 0.24];\nconst V = 30, SLIDE = 0.5, LIFT = 0.25, ROUT = 0.45, XFER = 0.6, HOLD = 1, SHIFT = 0.8;\n// The rows of finished punches: the last word above, baselines 112 and 126.\nconst ROWY = [112, 126];\n\n// ---- The timeline, in seconds at Speed 2: per letter the pattern slides\n// in, the stylus traces, the cutter clears round the letter, and the punch\n// goes to its row; per word a hold and the rows moving up.\nconst SEG = [];\nlet TOTAL = 0;\nWORDS.forEach((w, wi) => {\n  for (let li = 0; li \u003c w.length; li++) {\n    const ch = w[li], tr = PATH[ch].total / V + LIFT * (PATH[ch].cs.length - 1);\n    for (const [st, d] of [[\"slide\", SLIDE], [\"trace\", tr], [\"rout\", ROUT], [\"xfer\", XFER]]) {\n      SEG.push({ wi, li, st, t0: TOTAL, d });\n      TOTAL += d;\n    }\n  }\n  SEG.push({ wi, li: w.length, st: \"hold\", t0: TOTAL, d: HOLD });\n  TOTAL += HOLD;\n  SEG.push({ wi, li: w.length, st: \"shift\", t0: TOTAL, d: SHIFT });\n  TOTAL += SHIFT;\n});\n// A fresh start comes in as the O of BENTON slides in, with B, E, N and T\n// in the lower row and FAMILY above, all cut at the knobs as they are.\nconst START = (() => {\n  const g = SEG.find((s) => s.wi === 0 && s.li === 4 && s.st === \"slide\");\n  return g.t0 + 0.2 * g.d;\n})();\n\nfunction elbow(tx, ty) {\n  const dx = tx - OX, dy = ty - OY, d = sqrt(dx * dx + dy * dy);\n  const a = (L1 * L1 - L2 * L2 + d * d) / (2 * d), h = sqrt(max(0, L1 * L1 - a * a));\n  const ux = dx / d, uy = dy / d;\n  return [OX + a * ux - uy * h, OY + a * uy + ux * h];\n}\n\nexport function setup(params) {\n  params.s = {\n    tau: START, hue: 0, speed: 2, slant: 0, width: 1, dt: 0,\n    rec: {}, cov: new Float32Array(NP), rgb: new Float32Array(NP * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.slant = cl(k[2], 0, 0.45);\n  S.width = 1 + 0.45 * cl(k[3], -1, 1);\n  S.tau += (d * S.speed) / 2;\n  S.dt = d;\n  // A punch keeps the slant and width it was cut at, from the moment the\n  // cutter has cleared round it.\n  const g = seg(S.tau);\n  if (g.st === \"xfer\") S.rec[g.wi + \",\" + g.li] = [S.slant, S.width];\n}\n\nfunction seg(tau) {\n  const t = ((tau % TOTAL) + TOTAL) % TOTAL;\n  let lo = 0, hi = SEG.length - 1;\n  while (lo \u003c hi) {\n    const m = (lo + hi + 1) >> 1;\n    if (SEG[m].t0 \u003c= t) lo = m;\n    else hi = m - 1;\n  }\n  const g = SEG[lo];\n  return { ...g, e: cl((t - g.t0) / g.d, 0, 1), loc: t - g.t0 };\n}\n\n// ---- Drawing helpers.\nfunction add(rgb, p, c, v) {\n  rgb[p * 3] += c[0] * v, rgb[p * 3 + 1] += c[1] * v, rgb[p * 3 + 2] += c[2] * v;\n}\n// A line, sampled every half LED and spread over the four nearest LEDs.\nfunction line(rgb, x0, y0, x1, y1, c, v) {\n  const n = max(1, ceil(sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) * 2));\n  for (let i = 0; i \u003c= n; i++) {\n    const x = x0 + ((x1 - x0) * i) / n - 0.5, y = y0 + ((y1 - y0) * i) / n - 0.5;\n    const ix = floor(x), iy = floor(y), ax = x - ix, ay = y - iy, a = v / 2;\n    if (iy >= 0 && iy \u003c H) {\n      if (ix >= 0 && ix \u003c W) add(rgb, iy * W + ix, c, a * (1 - ax) * (1 - ay));\n      if (ix + 1 >= 0 && ix + 1 \u003c W) add(rgb, iy * W + ix + 1, c, a * ax * (1 - ay));\n    }\n    if (iy + 1 >= 0 && iy + 1 \u003c H) {\n      if (ix >= 0 && ix \u003c W) add(rgb, (iy + 1) * W + ix, c, a * (1 - ax) * ay);\n      if (ix + 1 >= 0 && ix + 1 \u003c W) add(rgb, (iy + 1) * W + ix + 1, c, a * ax * ay);\n    }\n  }\n}\nfunction dot(rgb, x, y, r, c, v) {\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - r - 1)); i \u003c= min(W - 1, floor(x + r + 1)); i++) {\n      const d = sqrt((i + 0.5 - x) ** 2 + (j + 0.5 - y) ** 2), a = cl(r + 0.5 - d, 0, 1);\n      if (a > 0) add(rgb, j * W + i, c, v * a);\n    }\n}\n// A glyph placed by its baseline origin (ox, oy), unit size u, width w and\n// slant k: unit point (x, y) goes to (ox + u (w x + k (14 - y)), oy - u (14 - y)).\nconst place = (x, y, ox, oy, u, w, k) => [ox + u * (w * x + k * (14 - y)), oy - u * (14 - y)];\nfunction contours(ch, ox, oy, u, w, k) {\n  return GLYPH[ch].slice(1).map((c) => {\n    const o = [];\n    for (let i = 0; i \u003c c.length; i += 2) o.push(...place(c[i], c[i + 1], ox, oy, u, w, k));\n    return o;\n  });\n}\n// Even-odd coverage of a set of contours, four sub-rows a row and exact\n// along each sub-row. Returns the box it wrote, cleared first.\nfunction fill(cov, cs) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (const c of cs)\n    for (let i = 0; i \u003c c.length; i += 2) (x0 = min(x0, c[i])), (x1 = max(x1, c[i])), (y0 = min(y0, c[i + 1])), (y1 = max(y1, c[i + 1]));\n  const bx0 = max(0, floor(x0)), bx1 = min(W - 1, floor(x1)), by0 = max(0, floor(y0)), by1 = min(H - 1, floor(y1));\n  for (let y = by0; y \u003c= by1; y++) for (let x = bx0; x \u003c= bx1; x++) cov[y * W + x] = 0;\n  const xs = [];\n  for (let y = by0; y \u003c= by1; y++)\n    for (let sub = 0; sub \u003c 4; sub++) {\n      const ys = y + (sub + 0.5) / 4;\n      xs.length = 0;\n      for (const c of cs) {\n        const n = c.length / 2;\n        for (let i = 0; i \u003c n; i++) {\n          const j = (i + 1) % n, ya = c[2 * i + 1], yb = c[2 * j + 1];\n          if ((ya \u003c= ys && yb > ys) || (yb \u003c= ys && ya > ys)) xs.push(c[2 * i] + ((ys - ya) * (c[2 * j] - c[2 * i])) / (yb - ya));\n        }\n      }\n      xs.sort((a, b) => a - b);\n      for (let i = 0; i + 1 \u003c xs.length; i += 2) {\n        const a = max(xs[i], bx0), b = min(xs[i + 1], bx1 + 1);\n        for (let x = floor(a); x \u003c b && x \u003c= bx1; x++) cov[y * W + x] += (min(x + 1, b) - max(x, a)) / 4;\n      }\n    }\n  return [bx0, bx1, by0, by1];\n}\n// Fills that stay put from frame to frame (the pattern at rest, punches in\n// their rows, the face being cleared) are kept by key and copied back.\nconst CACHE = new Map();\nfunction fillK(cov, key, cs) {\n  const hit = CACHE.get(key);\n  if (hit) {\n    const [x0, x1, y0, y1] = hit.r;\n    let i = 0;\n    for (let y = y0; y \u003c= y1; y++) for (let x = x0; x \u003c= x1; x++) cov[y * W + x] = hit.v[i++];\n    return hit.r;\n  }\n  const r = fill(cov, cs), v = new Float32Array(max(0, (r[1] - r[0] + 1) * (r[3] - r[2] + 1)));\n  let i = 0;\n  for (let y = r[2]; y \u003c= r[3]; y++) for (let x = r[0]; x \u003c= r[1]; x++) v[i++] = cov[y * W + x];\n  if (CACHE.size > 96) CACHE.clear();\n  CACHE.set(key, { r, v });\n  return r;\n}\nfunction outline(rgb, cs, c, v) {\n  for (const k of cs) {\n    const n = k.length / 2;\n    for (let i = 0; i \u003c n; i++) {\n      const j = (i + 1) % n;\n      line(rgb, k[2 * i], k[2 * i + 1], k[2 * j], k[2 * j + 1], c, v);\n    }\n  }\n}\n// The box a placed glyph needs, with a margin of m LEDs.\nfunction box(ch, ox, oy, u, w, k, m) {\n  const gw = GLYPH[ch][0];\n  return [ox - m, ox + u * (w * gw + k * 14) + m, oy - u * 14 - m, oy + m];\n}\n// A punch: a steel blank with the letter's face standing bright on it.\nfunction punch(S, ch, ox, oy, u, w, k, a, steel, face, still) {\n  const rgb = S.rgb, b = box(ch, ox, oy, u, w, k, 1.2);\n  for (let y = max(0, floor(b[2])); y \u003c= min(H - 1, floor(b[3])); y++)\n    for (let x = max(0, floor(b[0])); x \u003c= min(W - 1, floor(b[1])); x++) {\n      const edge = x === floor(b[0]) || y === floor(b[2]) ? 1.35 : x === floor(b[1]) || y === floor(b[3]) ? 0.6 : 1;\n      add(rgb, y * W + x, steel, 30 * edge * a);\n    }\n  const key = still ? [ch, ox, oy, u, w, k].map((v) => (typeof v === \"number\" ? v.toFixed(3) : v)).join() : null;\n  const cs = contours(ch, ox, oy, u, w, k), r = key ? fillK(S.cov, key, cs) : fill(S.cov, cs);\n  for (let y = r[2]; y \u003c= r[3]; y++)\n    for (let x = r[0]; x \u003c= r[1]; x++) {\n      const v = min(1, S.cov[y * W + x]);\n      if (v > 0) add(rgb, y * W + x, face, 200 * v * a);\n    }\n}\n\n// Where a word's punches stand in a row: unit size and each origin, the\n// blanks 1 LED apart and the row at most 62 LEDs.\nfunction rowLayout(S, wi) {\n  const w = WORDS[wi], u0 = RATIO[wi] * PS;\n  const kw = [];\n  let sum = 0;\n  for (let i = 0; i \u003c w.length; i++) {\n    const r = S.rec[wi + \",\" + i] || [S.slant, S.width];\n    kw.push(r);\n    sum += r[1] * GLYPH[w[i]][0] + r[0] * 14;\n  }\n  const u = min(u0, (62 - 3.4 * w.length + 1) / sum);\n  let x = (W - (u * sum + 3.4 * w.length - 1)) / 2 + 1.2;\n  const o = [];\n  for (let i = 0; i \u003c w.length; i++) {\n    o.push([x, kw[i][0], kw[i][1]]);\n    x += u * (kw[i][1] * GLYPH[w[i]][0] + kw[i][0] * 14) + 3.4;\n  }\n  return { u, o };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  const g = seg(S.tau), wi = g.wi, word = WORDS[wi];\n  const brass = hsv(0.115 + S.hue, 0.62, 1), hot = hsv(0.13 + S.hue, 0.22, 1), steel = hsv(0.6 + S.hue, 0.28, 1), dim = hsv(0.62 + S.hue, 0.5, 1);\n  const prevW = (wi + WORDS.length - 1) % WORDS.length;\n\n  // The ratio of the word being cut; the collars slide to the next one\n  // while the rows move up.\n  const nextR = RATIO[(wi + 1) % WORDS.length];\n  const s = g.st === \"shift\" ? RATIO[wi] + (nextR - RATIO[wi]) * ss(0, 1, g.e) : RATIO[wi];\n\n  // ---- The pattern: cap line and baseline, the letter filled dim with its\n  // outline, the part the stylus has passed bright.\n  for (const y of [PY - 1, PY + 44])\n    for (let x = 0; x \u003c W; x++) add(rgb, y * W + x, dim, x % 4 \u003c 2 ? 22 : 10);\n  const li = min(g.li, word.length - 1), ch = word[li], gw = GLYPH[ch][0];\n  let off = 0;\n  if (g.st === \"slide\") off = 46 * (1 - ss(0, 1, g.e));\n  else if (g.st === \"xfer\") off = -50 * ss(0, 1, g.e);\n  const showPattern = g.st !== \"hold\" && g.st !== \"shift\";\n  const pox = PCX - (gw * PS) / 2 + off, poy = PY + 44;\n  const P = (x, y) => place(x, y, pox, poy, PS, 1, 0);\n  let done = 0;\n  if (g.st === \"trace\") done = g.loc * V - 0;\n  else if (g.st === \"rout\" || g.st === \"xfer\") done = 1e9;\n  if (showPattern) {\n    const cs = contours(ch, pox, poy, PS, 1, 0);\n    const r = off === 0 ? fillK(S.cov, \"P\" + ch, cs) : fill(S.cov, cs);\n    for (let y = r[2]; y \u003c= r[3]; y++)\n      for (let x = r[0]; x \u003c= r[1]; x++) {\n        const v = min(1, S.cov[y * W + x]);\n        if (v > 0) add(rgb, y * W + x, brass, 62 * v);\n      }\n    outline(rgb, cs, brass, 120);\n    // Traced so far: the distance along the outline, less the lifts.\n    if (done > 0) {\n      let left = g.st === \"trace\" ? 0 : 1e9;\n      if (g.st === \"trace\") {\n        let t = g.loc;\n        for (const k of PATH[ch].cs) {\n          const need = k.len / V;\n          if (t \u003c= need) {\n            left += t * V;\n            break;\n          }\n          left += k.len;\n          t -= need + LIFT;\n          if (t \u003c 0) break;\n        }\n      }\n      let acc = 0;\n      for (const k of PATH[ch].cs) {\n        for (let i = 0; i \u003c k.n; i++) {\n          const a = k.cum[i], b = k.cum[i + 1];\n          if (acc + a >= left) break;\n          const j = (i + 1) % k.n, f = min(1, (left - acc - a) / max(1e-6, b - a));\n          const p0 = P(k.c[2 * i], k.c[2 * i + 1]), p1 = P(k.c[2 * j], k.c[2 * j + 1]);\n          line(rgb, p0[0], p0[1], p0[0] + (p1[0] - p0[0]) * f, p0[1] + (p1[1] - p0[1]) * f, hot, 150);\n        }\n        acc += k.len;\n      }\n      S.left = left;\n    }\n  }\n\n  // ---- The stylus T over the time of this letter.\n  const REST = [60, 30];\n  let T = REST, cutting = false;\n  const startPt = P(...along(ch, 0));\n  if (g.st === \"slide\") {\n    const m = ss(0, 1, g.e);\n    T = [REST[0] + (startPt[0] - REST[0]) * m, REST[1] + (startPt[1] - REST[1]) * m];\n  } else if (g.st === \"trace\") {\n    let t = g.loc, d = 0, lifted = null;\n    for (let c = 0; c \u003c PATH[ch].cs.length; c++) {\n      const k = PATH[ch].cs[c], need = k.len / V;\n      if (t \u003c= need) {\n        d += t * V;\n        break;\n      }\n      d += k.len;\n      t -= need;\n      if (c + 1 \u003c PATH[ch].cs.length && t \u003c= LIFT) {\n        lifted = [P(...along(ch, d - 1e-3)), P(...along(ch, d + 1e-3)), ss(0, 1, t / LIFT)];\n        break;\n      }\n      t -= LIFT;\n    }\n    if (lifted) T = [lifted[0][0] + (lifted[1][0] - lifted[0][0]) * lifted[2], lifted[0][1] + (lifted[1][1] - lifted[0][1]) * lifted[2]];\n    else (T = P(...along(ch, d))), (cutting = true);\n  } else if (g.st === \"rout\") {\n    // The cutter clears round the letter in six passes, top to bottom.\n    const pass = g.e * 6, i = floor(min(5.999, pass)), f = pass - i;\n    const xa = pox - 3, xb = pox + gw * PS + 3, y = PY - 2 + ((i + f) / 6) * 48;\n    T = [i % 2 ? xb + (xa - xb) * f : xa + (xb - xa) * f, y];\n    cutting = true;\n  } else if (g.st === \"xfer\") {\n    // From where the clearing ended, lifted, back to rest.\n    const end = [pox - off - 3, PY + 46], m = ss(0, 1, g.e);\n    T = [end[0] + (REST[0] - end[0]) * m, end[1] + (REST[1] - end[1]) * m];\n  }\n\n  // ---- Linkage geometry.\n  const J = elbow(T[0], T[1]);\n  const A = [OX + s * (J[0] - OX), OY + s * (J[1] - OY)], D = [J[0] + s * (T[0] - J[0]), J[1] + s * (T[1] - J[1])];\n  const Pp = [OX + s * (T[0] - OX), OY + s * (T[1] - OY)];\n  // The copy's baseline origin under the plain pantograph, and the stage.\n  const bo = [OX + s * (pox - off - OX), OY + s * (poy - OY)], u = s * PS;\n  const k = S.slant, w = S.width;\n  const stage = (x, y) => [bo[0] + w * (x - bo[0]) + k * (bo[1] - y), y];\n  const C = stage(Pp[0], Pp[1]);\n\n  // ---- The copy on its blank: the plain pantograph's copy as a faint\n  // ghost, the cut outline so far, then the face as the cutter clears.\n  if (g.st === \"slide\" || g.st === \"trace\" || g.st === \"rout\") {\n    const fadeIn = g.st === \"slide\" ? ss(0.3, 1, g.e) : 1;\n    const b = box(ch, bo[0], bo[1], u, w, k, 1.5);\n    const clearY = g.st === \"rout\" ? C[1] : g.st === \"trace\" ? -1 : -1;\n    for (let y = max(0, floor(b[2])); y \u003c= min(H - 1, floor(b[3])); y++)\n      for (let x = max(0, floor(b[0])); x \u003c= min(W - 1, floor(b[1])); x++) add(rgb, y * W + x, steel, (y + 0.5 \u003c clearY ? 16 : 34) * fadeIn);\n    outline(rgb, contours(ch, bo[0], bo[1], u, 1, 0), dim, 42 * fadeIn);\n    const cs = contours(ch, bo[0], bo[1], u, w, k);\n    if (g.st === \"rout\") {\n      const r = fillK(S.cov, [\"F\", ch, bo[0], bo[1], u, w, k].map((v) => (typeof v === \"number\" ? v.toFixed(3) : v)).join(), cs);\n      for (let y = r[2]; y \u003c= r[3]; y++)\n        for (let x = r[0]; x \u003c= r[1]; x++) {\n          const v = min(1, S.cov[y * W + x]) * (y + 0.5 \u003c clearY ? 1 : 0.25);\n          if (v > 0) add(rgb, y * W + x, hot, 170 * v);\n        }\n    }\n    if (g.st === \"trace\" || g.st === \"rout\") {\n      const left = g.st === \"rout\" ? 1e9 : S.left || 0;\n      let acc = 0;\n      for (let c = 0; c \u003c PATH[ch].cs.length; c++) {\n        const kk = PATH[ch].cs[c], pc = cs[c];\n        for (let i = 0; i \u003c kk.n; i++) {\n          const a = kk.cum[i], bb = kk.cum[i + 1];\n          if (acc + a >= left) break;\n          const j = (i + 1) % kk.n, f = min(1, (left - acc - a) / max(1e-6, bb - a));\n          line(rgb, pc[2 * i], pc[2 * i + 1], pc[2 * i] + (pc[2 * j] - pc[2 * i]) * f, pc[2 * i + 1] + (pc[2 * j + 1] - pc[2 * i + 1]) * f, hot, 190);\n        }\n        acc += kk.len;\n      }\n    }\n  }\n\n  // ---- Rows of finished punches. During the shift the upper row rises\n  // and fades and the lower row moves up into its place.\n  const shift = g.st === \"shift\" ? ss(0, 1, g.e) : 0;\n  {\n    const L = rowLayout(S, prevW);\n    for (let i = 0; i \u003c WORDS[prevW].length; i++) punch(S, WORDS[prevW][i], L.o[i][0], ROWY[0] - 16 * shift, L.u, L.o[i][2], L.o[i][1], 1 - shift, steel, brass, shift === 0);\n  }\n  {\n    const L = rowLayout(S, wi), n = g.st === \"hold\" || g.st === \"shift\" ? word.length : g.li;\n    for (let i = 0; i \u003c n; i++) punch(S, word[i], L.o[i][0], ROWY[1] - (ROWY[1] - ROWY[0]) * shift, L.u, L.o[i][2], L.o[i][1], 1, steel, brass, shift === 0);\n    if (g.st === \"xfer\") {\n      // The finished punch flies from the cutter to its place in the row.\n      const m = ss(0, 1, g.e), r = S.rec[wi + \",\" + g.li] || [k, w];\n      const tx = L.o[g.li][0], ty = ROWY[1];\n      const ox = bo[0] + (tx - bo[0]) * m, oy = bo[1] + (ty - bo[1]) * m - 10 * sin(m * Math.PI);\n      punch(S, ch, ox, oy, u + (L.u - u) * m, r[1], r[0], 1, steel, brass);\n    }\n  }\n\n  // ---- Bars, collars, pivot, stylus and cutter.\n  const bar = (p, q, v) => {\n    const dx = q[0] - p[0], dy = q[1] - p[1], l = sqrt(dx * dx + dy * dy) || 1, nx = (-dy / l) * 0.45, ny = (dx / l) * 0.45;\n    line(rgb, p[0] + nx, p[1] + ny, q[0] + nx, q[1] + ny, steel, v);\n    line(rgb, p[0] - nx, p[1] - ny, q[0] - nx, q[1] - ny, steel, v);\n  };\n  bar([OX, OY], J, 95);\n  bar(J, T, 95);\n  bar(A, Pp, 75);\n  bar(D, Pp, 75);\n  dot(rgb, A[0], A[1], 1.2, steel, 150);\n  dot(rgb, D[0], D[1], 1.2, steel, 150);\n  dot(rgb, J[0], J[1], 1.1, steel, 140);\n  // The pivot on its bracket.\n  for (let y = OY + 1; y \u003c= OY + 5; y++) {\n    const hw = (y - OY) * 0.8;\n    for (let x = max(0, floor(OX - hw)); x \u003c= min(W - 1, floor(OX + hw)); x++) add(rgb, y * W + x, steel, 55);\n  }\n  for (let x = 0; x \u003c= 9; x++) add(rgb, (OY + 6) * W + x, steel, x % 2 ? 90 : 45);\n  dot(rgb, OX, OY, 1.4, hot, 210);\n  // The stage: P where the plain pantograph would cut, a ring; the link to\n  // the cutter C.\n  if (abs(C[0] - Pp[0]) > 0.6) line(rgb, Pp[0], Pp[1], C[0], C[1], dim, 120);\n  dot(rgb, Pp[0], Pp[1], 1.1, steel, 120);\n  dot(rgb, T[0], T[1], 1.2, hot, 230);\n  line(rgb, T[0] - 3, T[1], T[0] + 3, T[1], hot, 60);\n  line(rgb, T[0], T[1] - 3, T[0], T[1] + 3, hot, 60);\n  if (cutting) {\n    dot(rgb, C[0], C[1], 0.9, hot, 255);\n    for (let i = 0; i \u003c 3; i++) {\n      const a = Math.random() * 6.283, r = 0.8 + Math.random() * 2.2;\n      dot(rgb, C[0] + cos(a) * r, C[1] + sin(a) * r, 0.3, hot, 160 * Math.random());\n    }\n  } else dot(rgb, C[0], C[1], 0.8, steel, 120);\n\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","book-from-the-sky":"// ===== Patternflow pattern =====\n// Title:   Book from the Sky\n// Family:  type\n// Idea:    A page of invented characters in vertical columns, each put together from stock radicals and parts in the frames real characters use, is printed over again a column at a time from right to left as a thin new sheet is drawn across it, so a page that looks like Chinese and cannot be read keeps renewing itself.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Book from the Sky (Xu Bing, 1987-1991), about 4,000 invented characters cut as pearwood movable type in a Song-style face; the page after Chinese thread-bound books (ruled columns read top to bottom, right to left, a wider top margin than bottom); pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Ink=0..1, Speed=0.2..3, Strokes=-1..1, Notes=0..1\n//\n// Knob 1: Ink. Paper and ink: at 0 black ink on ivory paper; 0.25 indigo, as in the blue trial impressions of Qing printing; 0.5 vermilion, as in the red ones; 0.75 a rubbing, white characters on black; 1 gold on indigo paper.\n// Knob 2: Speed. How fast the new sheet is drawn across and printed: at 2 a column every 2.4 s, a page in 13.4 s and a 2 s rest before the next sheet; ten times slower at 0.2, half again as fast at 3.\n// Knob 3: Strokes. How many parts a character is built from. At 0 a quarter of the characters have a part split in two again, 7% are one part with a dot added, and a character has 7 pen lines on average (a line runs from pen down to pen up, so 口 is one); at -1 nothing is split, 23% are one part, 5.8 lines; at 1 85% are split, 10.9 lines.\n// Knob 4: Notes. How much of the page is commentary set as two columns of small characters inside one column, four to a place, as Chinese books set their notes: about 7% of the 55 places at 0.06, none at 0, nearly all at 1. Turning Strokes or Notes sets the columns of the new sheet that are not printed yet again.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- Components, as stroke lists. Each is \"wh\" (its own grid, w by h\n// points) and strokes, each stroke a run of x,y digit pairs joined by\n// straight lines; a pair given twice is a dot. Placed in a box, a component\n// is stretched to it, so a 5 by 5 part fills a 5 by 9 half as a tall one.\nconst LEFT = {\n  // Radicals in their narrow left-hand forms, 3 by 9.\n  ren: \"39 2003 1218\", shui: \"39 0011 0314 0826\", shou: \"39 0222 101807 0624\", mu: \"39 0222 1018 1306 2424\",\n  kou: \"39 0323260603\", ri: \"39 0121270701 0424\", yan: \"39 1010 0121 0323 0525280805\", jin: \"39 1001 1021 0323 0525 1318 0827\",\n  wang: \"39 0121 0424 1117 0827\", tu: \"39 0323 1117 0827\", he: \"39 2001 0222 1118 1306 2424\", mu2: \"39 0020280800 0323 0525\",\n  fu: \"39 0008 00202112232415\", xin: \"39 1018 0203 2121\", shi: \"39 0121 1104 0525280805\",\n};\nconst TOP = {\n  // Heads, 9 by 3: grass, roof, bamboo, net, lid, person, mountain, cover.\n  cao: \"93 0181 2022 6062\", mian: \"93 4040 02018182\", zhu: \"93 2002 1131 2222 7052 6181 7272\", wang: \"93 0080820200 3032 5052\",\n  tou: \"93 4041 0282\", ren: \"93 4002 4082\", shan: \"93 0002 4042 8082 0282\", mi: \"93 02018182\",\n};\nconst BOT = {\n  // Feet, 9 by 3: heart, fire dots, legs, dish, one.\n  xin: \"93 0112 2021327281 5050 7070\", huo: \"93 0211 3132 5152 7182\", er: \"93 303102 50528281\", min: \"93 1070 1012 3032 5052 7072 0282\", yi: \"93 0181\",\n};\nconst GEN = {\n  // Parts that go anywhere, small grids stretched to their box.\n  kou: \"33 0020220200\", ri: \"35 0020240400 0222\", mu: \"37 0020260600 0222 0424\", tian: \"55 0040440400 2024 0242\",\n  wang: \"55 0040 0242 0444 2024\", tu: \"54 1131 0343 2023\", gong: \"53 1030 2022 0242\", shi: \"55 0242 2024\",\n  mu4: \"55 0141 2024 2204 2244\", da: \"55 0141 202204 2244\", ren: \"55 202104 2244\", nv: \"55 201244 312304 0242\",\n  zi: \"55 003021 212414 0242\", you: \"55 00403104 1144\", li: \"55 01414434 202204\", cun: \"55 0141 303424 1213\",\n  ge: \"55 0141 1044 3214 3030\", jin: \"55 4011 111304 1242 3234\", qian: \"55 1002 114132 2204 2244\", pu: \"55 1002 1141 3114 1244\",\n  huo: \"55 0112 4132 202204 2244\", mi: \"55 0011 4031 0242 2024 2204 2244\", he: \"55 4011 0242 2124 2204 2244\", shan: \"54 0103 2023 4143 0343\",\n  bai: \"46 2011 0131350501 0333\", ji: \"55 00404202044443\", yi: \"55 0040044443\", ji2: \"55 101304 1030334443\",\n  shi2: \"55 1030 0242 222414 1304 3344\", yang: \"57 1010 3030 0141 1333 0545 2126\", bei: \"57 0040440400 0242 1506 3546\", ding: \"54 0040 202313\",\n  gong2: \"47 0030320204343626\", chong: \"57 2025 0141434301 0646 4545\",\n};\nconst RIGHT = {\n  // Right-hand parts that need the whole 5 by 9 half: short-tailed bird, head.\n  zhui: \"59 2003 1218 3030 2141 2343 2545 2848 3138\", ye: \"59 0040 2011 1232361612 1434 1708 3748\",\n};\nconst NARROW = {\n  // Narrow right-hand parts, 3 by 9: knife, ear, seal.\n  dao: \"39 0105 202817\", fu: \"39 0008 00202112232415\", jie: \"39 0020202515 0008\",\n};\n// Enclosures drawn on the whole 9 by 9, with the box left inside them:\n// mouth, broad, cliff, walk, borders, corpse.\nconst ENC = [\n  [\"0080880800\", 2, 2, 5, 5], [\"4040 1181 111608\", 3, 3, 6, 6], [\"1080 101608\", 3, 2, 6, 7],\n  [\"0011 032316273888\", 3, 0, 6, 6], [\"0800808877\", 2, 2, 5, 7], [\"10707212 101608\", 3, 4, 6, 5],\n];\n\nfunction comp(s) {\n  const [wh, ...st] = s.trim().split(\" \");\n  return { w: +wh[0], h: +wh[1], st: st.map((t) => Array.from(t, Number)) };\n}\nconst set = (o) => Object.keys(o).map((k) => Object.assign(comp(o[k]), { k }));\nconst SL = set(LEFT), ST = set(TOP), SB = set(BOT), SG = set(GEN), SR = set(RIGHT), SN = set(NARROW);\nconst SE = ENC.map(([s, x, y, w, h]) => Object.assign(comp(\"99 \" + s), { box: [x, y, w, h], k: \"e\" + s.length }));\nconst one = (a) => a[floor(Math.random() * a.length)];\n\n// Real characters that a frame and stock parts would make (休, 林, 字, 因,\n// 古), 78 of them, drawn again when they come up: at Strokes 0 that is 3.3%\n// of the characters drawn. Only these are checked. The Kangxi dictionary\n// (1716) holds 47,035 characters and none of it is here, so a page can\n// still carry a real one, which Xu Bing made sure his 4,000 never were.\nconst REAL = new Set(\n  (\"LR:ren+mu4 LR:ren+zi LR:ren+cun LR:ren+shi LR:ren+bai LR:ren+ding LR:ren+ge LR:shui+gong LR:shui+shi LR:shui+yang \" +\n    \"LR:shui+ding LR:shui+mu4 LR:shui+bai LR:shou+ding LR:shou+gong LR:shou+zhui LR:mu+cun LR:mu+tu LR:mu+mu4 LR:mu+zhui \" +\n    \"LR:kou+tu LR:kou+ding LR:kou+shi LR:kou+zhui LR:yan+shi LR:yan+yang LR:yan+ding LR:yan+zhui LR:yan+cun LR:jin+shi \" +\n    \"LR:jin+ding LR:jin+zhui LR:ri+wang LR:tu+zhui LR:xin+zhui LR:shi+ding LR:he+zhui LR:wang+li LR2:nv+zi LR2:mu4+mu4 \" +\n    \"LR2:nv+nv LR2:ren+ren TB:mian+zi TB:mian+nv TB:cao+tian TB:ren+wang TB2:kou+kou TB2:ri+ri TB2:tu+tu TB2:huo+huo \" +\n    \"TB2:shi+kou TBb:ri+yi TBb:tian+xin TBb:mu4+huo TBb:kou+er TB:mian+mu4 LRn:he+dao LRn:gong+fu LRn:you+fu \" +\n    \"LR:shui+ri LR:kou+kou LR:ren+li E0:ren E0:da E0:mu4 E0:kou E0:wang E0:zi \" +\n    \"E1:mu4 E1:tu E2:ding E2:li E3:da E3:cun E3:li E3:shi E4:ren E4:kou\").split(\" \"),\n);\n\n// Bresenham into a bitmap gw wide.\nfunction line(g, gw, x0, y0, x1, y1) {\n  const dx = Math.abs(x1 - x0), dy = -Math.abs(y1 - y0), sx = x0 \u003c x1 ? 1 : -1, sy = y0 \u003c y1 ? 1 : -1;\n  let e = dx + dy;\n  for (;;) {\n    g[y0 * gw + x0] = 1;\n    if (x0 === x1 && y0 === y1) return;\n    const e2 = 2 * e;\n    if (e2 >= dy) (e += dy), (x0 += sx);\n    if (e2 \u003c= dx) (e += dx), (y0 += sy);\n  }\n}\n// Stroke component c into the box; returns its stroke count.\nfunction put(g, gw, c, bx, by, bw, bh) {\n  const sx = c.w > 1 ? (bw - 1) / (c.w - 1) : 0, sy = c.h > 1 ? (bh - 1) / (c.h - 1) : 0;\n  for (const s of c.st) {\n    let px = bx + round(s[0] * sx), py = by + round(s[1] * sy);\n    for (let i = 2; i \u003c s.length; i += 2) {\n      const qx = bx + round(s[i] * sx), qy = by + round(s[i + 1] * sy);\n      line(g, gw, px, py, qx, qy);\n      (px = qx), (py = qy);\n    }\n  }\n  return c.st.length;\n}\n\n// A part in a box: a stock part, or at the next level the box split in two.\n// Small parts are not blown up past two points bigger than their grid.\nfunction part(g, box, nest, keys, depth) {\n  const [x, y, w, h] = box;\n  if (depth \u003c 2 && Math.random() \u003c nest) {\n    keys.push(\"+\");\n    if (w >= 5 && (w >= h || h \u003c 5)) {\n      const lw = floor((w - 1) / 2);\n      return part(g, [x, y, lw, h], nest * 0.6, keys, depth + 1) + part(g, [x + lw + 1, y, w - lw - 1, h], nest * 0.6, keys, depth + 1);\n    }\n    if (h >= 5) {\n      const th = floor((h - 1) / 2);\n      return part(g, [x, y, w, th], nest * 0.6, keys, depth + 1) + part(g, [x, y + th + 1, w, h - th - 1], nest * 0.6, keys, depth + 1);\n    }\n  }\n  const pool = w >= 5 && h >= 9 && Math.random() \u003c 0.12 ? SR : SG;\n  let c = one(pool);\n  for (let i = 0; i \u003c 6 && (c.w > w + 1 || c.h > h + 1); i++) c = one(pool);\n  keys.push(c.k);\n  const bw = c.w \u003c 5 && w > c.w ? min(w, c.w + 2) : w, bh = c.h \u003c 5 && h > c.h ? min(h, c.h + 2) : h;\n  return put(g, 9, c, x + floor((w - bw) / 2), y + floor((h - bh) / 2), bw, bh);\n}\n\n// One invented character into the 9 by 9 bitmap g. u is Strokes moved to\n// 0..1. Frames and their shares at u = 0.5: one part 7%, left radical and\n// right part 36%, two halves 7%, left part and narrow right 6%, head and\n// body 16%, two stacked 6%, body and foot 8%, enclosure 14%.\nfunction makeChar(g, u) {\n  const nest = u \u003c 0.5 ? 0.6 * u : 0.3 + 1.4 * (u - 0.5);\n  const single = u \u003c 0.5 ? 0.22 - 0.3 * u : 0.07 - 0.1 * (u - 0.5);\n  for (let tries = 0; ; tries++) {\n    g.fill(0);\n    const keys = [];\n    let r = Math.random(), n = 0, f;\n    const sh = (1 - single) / 0.93;\n    if (r \u003c single) {\n      // Every stock part alone is a real character (木, 力, 米), so a single\n      // part gets one dot more where there is room for it.\n      (f = \"S\"), (n = part(g, [0, 0, 9, 9], 0, keys, 2) + 1);\n      for (const i of [10, 16, 64, 70, 4, 36, 44].sort(() => Math.random() - 0.5)) {\n        let free = true;\n        for (let dy = -9; dy \u003c= 9; dy += 9) for (let dx = -1; dx \u003c= 1; dx++) if (g[i + dy + dx]) free = false;\n        if (free) {\n          g[i] = 1;\n          break;\n        }\n      }\n    } else if ((r = (r - single) / sh) \u003c 0.36) {\n      const c = one(SL);\n      (f = \"LR\"), keys.push(c.k), (n = put(g, 9, c, 0, 0, 3, 9) + part(g, [4, 0, 5, 9], nest, keys, 0));\n    } else if (r \u003c 0.43) (f = \"LR2\"), (n = part(g, [0, 0, 4, 9], 0, keys, 2) + part(g, [5, 0, 4, 9], 0, keys, 2));\n    else if (r \u003c 0.49) {\n      n = part(g, [0, 0, 5, 9], nest, keys, 0);\n      const c = one(SN);\n      (f = \"LRn\"), keys.push(c.k), (n += put(g, 9, c, 6, 0, 3, 9));\n    } else if (r \u003c 0.65) {\n      const c = one(ST);\n      (f = \"TB\"), keys.push(c.k), (n = put(g, 9, c, 0, 0, 9, 3) + part(g, [0, 4, 9, 5], nest, keys, 0));\n    } else if (r \u003c 0.71) (f = \"TB2\"), (n = part(g, [0, 0, 9, 4], 0, keys, 2) + part(g, [0, 5, 9, 4], 0, keys, 2));\n    else if (r \u003c 0.79) {\n      n = part(g, [0, 0, 9, 5], nest, keys, 0);\n      const c = one(SB);\n      (f = \"TBb\"), keys.push(c.k), (n += put(g, 9, c, 0, 6, 9, 3));\n    } else {\n      const i = floor(Math.random() * SE.length), c = SE[i];\n      (f = \"E\" + i), (n = put(g, 9, c, 0, 0, 9, 9) + part(g, c.box, nest, keys, 0));\n    }\n    if (tries \u003c 8 && REAL.has(f + \":\" + keys.join(\"+\"))) continue;\n    return n;\n  }\n}\n\n// ---- The page. A frame from x 1 to 62 and y 10 to 122, five columns 11\n// wide with a rule between each, eleven characters a column on a 10-row\n// pitch: 55 places. The top margin is 10 rows and the bottom 5, the wider\n// one above as in Chinese books. Columns read right to left, so the\n// printing strips run from x 64 down to 0, split at the rules.\nconst TOPY = 10, BOTY = 122, RULES = [13, 25, 37, 49], EDGES = [64, 49, 37, 25, 13, 0];\nconst STRIP = new Uint8Array(W);\nfor (let x = 0; x \u003c W; x++) STRIP[x] = x >= 49 ? 0 : x >= 37 ? 1 : x >= 25 ? 2 : x >= 13 ? 3 : 4;\n\nfunction makePage(u, notes) {\n  const ink = new Uint8Array(N), halo = new Uint8Array(N);\n  for (let x = 1; x \u003c= 62; x++) ink[TOPY * W + x] = ink[BOTY * W + x] = 1;\n  for (let y = TOPY; y \u003c= BOTY; y++) {\n    ink[y * W + 1] = ink[y * W + 62] = 1;\n    for (const rx of RULES) ink[y * W + rx] = 1;\n  }\n  const g = new Uint8Array(81), sg = new Uint8Array(16);\n  let strokes = 0, chars = 0, note = false;\n  const start = 0.6 * notes, keep = 0.5 + 0.5 * notes;\n  for (let j = 0; j \u003c 5; j++)\n    for (let k = 0; k \u003c 11; k++) {\n      const x0 = 3 + 12 * j, y0 = 12 + 10 * k;\n      note = Math.random() \u003c (note ? keep : start);\n      if (note) {\n        // Four small characters, two side by side, two down.\n        for (let q = 0; q \u003c 4; q++) {\n          sg.fill(0);\n          let c = one(SG);\n          while (c.w > 5 || c.h > 5) c = one(SG);\n          put(sg, 4, c, 0, 0, 4, 4);\n          const ox = x0 + (q & 1 ? 0 : 5), oy = y0 + (q >> 1) * 5;\n          for (let i = 0; i \u003c 16; i++) if (sg[i]) ink[(oy + (i >> 2)) * W + ox + (i & 3)] = 1;\n        }\n        continue;\n      }\n      strokes += makeChar(g, u);\n      chars++;\n      // Song faces cut horizontals thin and verticals thick. An LED cannot\n      // be thinner than one, so a pixel that only runs sideways is inked\n      // lighter (2) and the uprights stay full (1).\n      for (let i = 0; i \u003c 81; i++) {\n        if (!g[i]) continue;\n        const gx = i % 9, gy = floor(i / 9);\n        const side = (gx > 0 && g[i - 1]) || (gx \u003c 8 && g[i + 1]), up = (gy > 0 && g[i - 9]) || (gy \u003c 8 && g[i + 9]);\n        ink[(y0 + gy) * W + x0 + gx] = side && !up ? 2 : 1;\n      }\n    }\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (!ink[p] && (ink[p - 1] || ink[p + 1] || ink[p - W] || ink[p + W])) halo[p] = 1;\n    }\n  return { ink, halo, t0: new Float32Array(5).fill(1e9), strokes, chars };\n}\n\n// Paper grain for two sheets, alternating, so each sheet keeps its own.\nconst GRAIN = [new Float32Array(N), new Float32Array(N)];\nfor (let s = 0; s \u003c 2; s++)\n  for (let p = 0; p \u003c N; p++) {\n    let h = Math.imul(p + 7919 * (s + 1), 2654435761) >>> 0;\n    h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0;\n    GRAIN[s][p] = ((h ^ (h >>> 13)) >>> 0) / 4294967296 - 0.5;\n  }\n\n// Paper and ink along Ink: black on ivory, indigo, vermilion, a rubbing\n// (the paper inked black, the cut strokes left white), gold on indigo.\nconst PAL = [\n  [[238, 229, 205], [24, 22, 24]],\n  [[238, 229, 205], [30, 52, 128]],\n  [[238, 229, 205], [192, 48, 26]],\n  [[26, 26, 30], [228, 222, 206]],\n  [[26, 36, 96], [224, 182, 92]],\n];\n// Each holds for 0.175 either side of its stop, so the knob rests on whole\n// palettes and only passes through the grey between dark and light paper.\nfunction palette(k) {\n  const f = cl(k, 0, 1) * 4, i = min(3, floor(f)), a = PAL[i], b = PAL[i + 1];\n  let t = cl((f - i - 0.35) / 0.3, 0, 1);\n  t = t * t * (3 - 2 * t);\n  return [0, 1].map((j) => a[j].map((v, c) => v + (b[j][c] - v) * t));\n}\n\n// Timing. The new sheet's edge moves 2.5 × Speed LEDs a second; a strip\n// is printed 0.4/Speed s after the sheet has covered it, the impression\n// running down the strip in 2/Speed s (0.2 s and 1 s at Speed 2). Fresh\n// ink is 10% further from the paper than dry ink and darkens the paper\n// beside it by 12% while wet; both dry off in about a second. The page\n// underneath shows through the sheet at 13%, and horizontals are inked\n// at 72%.\nconst FRESH = 0.1, WET = 0.12, DRY = 0.9, SPREAD = 0.4, GHOST = 0.13, THIN = 0.72;\n\nexport function setup(params) {\n  params.s = { t: 0, ready: false, e: 67, rest: 0, sheet: 0, pages: null, u: 0.5, notes: 0.06, speed: 2, ink: 0, key: \"\" };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.ink = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.u = (cl(k[2], -1, 1) + 1) / 2;\n  S.notes = cl(k[3], 0, 1);\n  if (!S.ready) {\n    // The page is full from the first frame: the sheet on top printed\n    // long ago, one under it showing through, and the next one waiting.\n    const older = makePage(S.u, S.notes), old = makePage(S.u, S.notes);\n    older.t0.fill(-1e3), old.t0.fill(-1e3);\n    S.pages = [older, old, makePage(S.u, S.notes)];\n    S.ready = true;\n    S.key = S.u.toFixed(2) + S.notes.toFixed(2);\n  }\n  const key = S.u.toFixed(2) + S.notes.toFixed(2);\n  if (key !== S.key) {\n    // Strokes or Notes turned: the columns of the new sheet not printed yet\n    // are set again, so the change shows from the next column on.\n    S.key = key;\n    const nw = S.pages[2], re = makePage(S.u, S.notes);\n    for (let s = 0; s \u003c 5; s++)\n      if (nw.t0[s] > 1e8)\n        for (let y = 0; y \u003c H; y++)\n          for (let x = EDGES[s + 1]; x \u003c EDGES[s]; x++) (nw.ink[y * W + x] = re.ink[y * W + x]), (nw.halo[y * W + x] = re.halo[y * W + x]);\n  }\n  S.t += d;\n  const [, , nw] = S.pages;\n  if (S.e > 0) {\n    // A page turn is a wipe 67 LEDs long, 13.4 s at Speed 2, longer than\n    // the six seconds the map measures over; motion comes from a column\n    // changing at a time, never the page at once.\n    S.e = max(0, S.e - d * 2.5 * S.speed);\n    for (let s = 0; s \u003c 5; s++) if (nw.t0[s] > 1e8 && S.e \u003c= EDGES[s + 1]) nw.t0[s] = S.t + 0.4 / S.speed;\n    if (S.e === 0) S.rest = 4 / S.speed;\n  } else if ((S.rest -= d) \u003c= 0) {\n    S.pages = [S.pages[1], nw, makePage(S.u, S.notes)];\n    S.sheet ^= 1;\n    S.e = 67;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const [older, old, nw] = S.pages, t = S.t, pass = 2 / S.speed;\n  const [paper, ink] = palette(S.ink);\n  const dr = ink[0] - paper[0], dg = ink[1] - paper[1], db = ink[2] - paper[2];\n  const ga = GRAIN[S.sheet], gb = GRAIN[S.sheet ^ 1];\n  const e = S.e, shadowX = e \u003c 64 ? Math.ceil(e) - 1 : -1;\n  for (let y = 0; y \u003c H; y++) {\n    const rowF = cl((y - TOPY) / (BOTY - TOPY), 0, 1) * pass;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, top = x >= e;\n      const pg = top ? nw : old, under = top ? old : older;\n      const gr = top ? gb[p] : ga[p];\n      // Paper, its grain, and the page under it.\n      let a = 0.035 * gr;\n      if (under.ink[p]) a += GHOST;\n      const ti = pg.t0[STRIP[x]] + rowF;\n      if (t >= ti) {\n        const age = t - ti;\n        if (pg.ink[p]) a = (pg.ink[p] === 2 ? THIN : 1) + FRESH * exp(-age / DRY);\n        else if (pg.halo[p]) a += WET * exp(-age / SPREAD);\n      }\n      const sh = x === shadowX ? 0.97 : 1;\n      const r = (paper[0] + dr * a) * sh, g = (paper[1] + dg * a) * sh, b = (paper[2] + db * a) * sh;\n      display.setPixel(x, y, cl(r, 0, 255) | 0, cl(g, 0, 255) | 0, cl(b, 0, 255) | 0);\n    }\n  }\n}\n","catoptric-anamorphosis":"// ===== Patternflow pattern =====\n// Title:   Catoptric Anamorphosis\n// Family:  type\n// Idea:    A word is drawn on the floor round a mirror cylinder, warped into rings that wrap the cylinder's foot, and only in the cylinder's reflection, seen from the one eye the drawing was traced for, does it stand up straight; the camera sways round that eye, so the word reads and smears while the rings on the floor stay strange.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: catoptric (cylinder mirror) anamorphosis (Jean-François Niceron, La Perspective curieuse, 1638), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Away=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel, each letter a sixth of the wheel from the next: at 0 EYE is azure, violet and pink on grey paper.\n// Knob 2: Speed. The camera's sway and the turn of the words: at 2 the sway takes 14 s and a new word is drawn every 7 s; ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Word. The first word, then the others in turn: EYE, 눈 (eye), SEE, YOU.\n// Knob 4: Away. How far the camera wanders from the eye the floor was drawn for, on a figure of eight round the cylinder up to 60 degrees each way and up and down by 14 degrees. At the opening 0.06 it stays within 3.6 degrees and the word stands straight; at 0.3 it swings 18 degrees and the word slides round the mirror and leans; from 0.5 the word runs off the mirror's edge, while the rings on the floor only turn.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- The scene, in units of the cylinder's radius: the mirror stands on\n// the floor y = 0 round the axis x = z = 0, 3 high. The design eye E looks\n// at a point on the floor 1.6 in front of the axis, with a focal length of\n// 160 LEDs, so the cylinder fills rows 5 to 56, 36 LEDs across at its top\n// and 30 at its foot. The first frame traces the paper's grid (about 25 ms\n// in Node) and each word's first frame its ink (25 to 30 ms); after that a\n// frame is one ray per LED, off the mirror at most once, about 1.5 ms.\nconst RC = 1, HC = 3;\nconst E = [0, 6.2, 7.6], AIM = [0, 0, 1.6];\nconst F = 160;\n\n// ---- Letters as strokes in a unit box, y down: L a line, A an elliptic\n// arc (centre, radii, start and end angle in degrees, clockwise on screen).\nconst GLYPHS = {\n  E: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 0, 1, 0], [\"L\", 0, 0.5, 0.82, 0.5], [\"L\", 0, 1, 1, 1]],\n  Y: [[\"L\", 0, 0, 0.5, 0.5], [\"L\", 1, 0, 0.5, 0.5], [\"L\", 0.5, 0.5, 0.5, 1]],\n  S: [[\"A\", 0.5, 0.26, 0.5, 0.26, -25, -270], [\"A\", 0.5, 0.74, 0.5, 0.26, -90, 155]],\n  O: [[\"A\", 0.5, 0.5, 0.5, 0.5, 0, 360]],\n  U: [[\"L\", 0, 0, 0, 0.5], [\"A\", 0.5, 0.5, 0.5, 0.5, 180, 0], [\"L\", 1, 0.5, 1, 0]],\n  // 눈: ㄴ over ㅜ over ㄴ\n  \"눈\": [[\"L\", 0.1, 0, 0.1, 0.3], [\"L\", 0.1, 0.3, 0.9, 0.3], [\"L\", 0, 0.52, 1, 0.52], [\"L\", 0.5, 0.52, 0.5, 0.68], [\"L\", 0.1, 0.72, 0.1, 1], [\"L\", 0.1, 1, 0.9, 1]],\n};\nconst WORDS = [[\"E\", \"Y\", \"E\"], [\"눈\"], [\"S\", \"E\", \"E\"], [\"Y\", \"O\", \"U\"]];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A camera: position, forward, right and up, from its place and its aim.\nfunction camera(pos, aim, out) {\n  out.o = pos;\n  let fx = aim[0] - pos[0], fy = aim[1] - pos[1], fz = aim[2] - pos[2];\n  const l = sqrt(fx * fx + fy * fy + fz * fz);\n  fx /= l; fy /= l; fz /= l;\n  const rl = sqrt(fx * fx + fz * fz);\n  const rx = -fz / rl, rz = fx / rl;\n  out.fw = [fx, fy, fz];\n  out.rt = [rx, 0, rz];\n  out.up = [-rz * fy, rz * fx - rx * fz, rx * fy];\n  return out;\n}\n// The ray through LED (sx, sy) (fractional, from the top left) into D.\nconst D = [0, 0, 0];\nfunction ray(cam, sx, sy) {\n  const u = sx - W / 2, v = H / 2 - sy, fw = cam.fw, rt = cam.rt, up = cam.up;\n  const x = fw[0] * F + rt[0] * u + up[0] * v, y = fw[1] * F + rt[1] * u + up[1] * v, z = fw[2] * F + rt[2] * u + up[2] * v;\n  const l = 1 / sqrt(x * x + y * y + z * z);\n  D[0] = x * l; D[1] = y * l; D[2] = z * l;\n}\n// Where o + t D meets the cylinder's side (front), or -1.\nfunction hitCyl(ox, oy, oz, dx, dy, dz) {\n  const a = dx * dx + dz * dz, b = ox * dx + oz * dz, c = ox * ox + oz * oz - RC * RC, disc = b * b - a * c;\n  if (disc \u003c 0 || a \u003c 1e-12) return -1;\n  const t = (-b - sqrt(disc)) / a, y = oy + t * dy;\n  return t > 1e-6 && y >= 0 && y \u003c= HC ? t : -1;\n}\n// From E through LED (sx, sy): off the mirror and down to the floor. Writes\n// the floor point's angle round the axis (0 towards E) and radius to FP;\n// false if the ray misses the mirror or the reflection rises.\nconst FP = [0, 0];\nfunction design(cam, sx, sy) {\n  ray(cam, sx, sy);\n  const o = cam.o, t = hitCyl(o[0], o[1], o[2], D[0], D[1], D[2]);\n  if (t \u003c 0) return false;\n  const px = o[0] + t * D[0], py = o[1] + t * D[1], pz = o[2] + t * D[2];\n  const dn = D[0] * px + D[2] * pz; // normal (px, 0, pz) / RC\n  const rx = D[0] - 2 * dn * px, ry = D[1], rz = D[2] - 2 * dn * pz;\n  if (ry >= -1e-6) return false;\n  const s = -py / ry, qx = px + s * rx, qz = pz + s * rz;\n  FP[0] = atan2(qx, qz);\n  FP[1] = sqrt(qx * qx + qz * qz);\n  return true;\n}\n\n// ---- The floor drawing, kept in polar texels round the axis: angle\n// -126..126 degrees in 600 steps, radius 1..6.5 in 220.\nconst TH = 2.2, RA = 1, RB = 6.5, NT = 600, NR = 220;\nconst PAPER = 6.2; // the sheet under the drawing, out to radius 6.2\n// The word's place in E's picture: the rows whose reflection lands between\n// radius 1.32 and 6.0 straight in front, and 86% of the mirror's width,\n// which comes to rows 12.75 to 52.5 and columns 16.7 to 47.3.\nfunction region(cam) {\n  let v0 = 0, v1 = H;\n  for (let y = 0; y \u003c H; y += 0.25) {\n    if (!design(cam, W / 2, y)) continue;\n    if (FP[1] > 6.0) v0 = y + 0.25;\n    else if (FP[1] >= 1.32) v1 = y;\n  }\n  let half = 0;\n  const vm = (v0 + v1) / 2;\n  for (let x = W / 2; x \u003c W; x += 0.25) if (design(cam, x, vm)) half = x - W / 2;\n  return { u0: W / 2 - 0.86 * half, u1: W / 2 + 0.86 * half, v0, v1 };\n}\n\nfunction segDist(px, py, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - s[0]) * dx + (py - s[1]) * dy) / l, 0, 1) : 0;\n  const ex = s[0] + t * dx - px, ey = s[1] + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// The word as E should see it: ink coverage on a grid four to an LED over\n// the region, letters stacked from the top, and which letter each texel is.\nconst MS = 4;\nfunction wordMask(wi, reg) {\n  const word = WORDS[wi], n = word.length;\n  const MU = Math.ceil((reg.u1 - reg.u0) * MS) + 2, MV = Math.ceil((reg.v1 - reg.v0) * MS) + 2;\n  const mask = new Float32Array(MU * MV), id = new Uint8Array(MU * MV);\n  const gap = 2.5, cw = reg.u1 - reg.u0, ch = (reg.v1 - reg.v0 - (n - 1) * gap) / n;\n  const pen = n === 1 ? 3.4 : 2.6, hw = pen / 2;\n  for (let k = 0; k \u003c n; k++) {\n    const x0 = reg.u0, y0 = reg.v0 + k * (ch + gap), sx = cw - pen, sy = ch - pen;\n    const segs = [];\n    const P = (u, v) => [x0 + hw + u * sx, y0 + hw + v * sy];\n    for (const st of GLYPHS[word[k]]) {\n      if (st[0] === \"L\") segs.push([...P(st[1], st[2]), ...P(st[3], st[4])]);\n      else {\n        const [, cx, cy, rx, ry, a0, a1] = st, m = max(6, Math.ceil(abs(a1 - a0) / 8));\n        for (let i = 0; i \u003c m; i++) {\n          const b0 = ((a0 + ((a1 - a0) * i) / m) * PI) / 180, b1 = ((a0 + ((a1 - a0) * (i + 1)) / m) * PI) / 180;\n          segs.push([...P(cx + rx * cos(b0), cy + ry * sin(b0)), ...P(cx + rx * cos(b1), cy + ry * sin(b1))]);\n        }\n      }\n    }\n    // each stroke marks the texels within half a pen of it\n    for (const sg of segs) {\n      const xa = max(0, floor((min(sg[0], sg[2]) - hw - reg.u0) * MS) - 1), xb = min(MU - 1, Math.ceil((max(sg[0], sg[2]) + hw - reg.u0) * MS) + 1);\n      const ya = max(0, floor((min(sg[1], sg[3]) - hw - reg.v0) * MS) - 1), yb = min(MV - 1, Math.ceil((max(sg[1], sg[3]) + hw - reg.v0) * MS) + 1);\n      for (let my = ya; my \u003c= yb; my++)\n        for (let mx = xa; mx \u003c= xb; mx++) {\n          const o = my * MU + mx;\n          if (mask[o] >= 1) continue;\n          const cov = cl((hw - segDist(reg.u0 + (mx + 0.5) / MS, reg.v0 + (my + 0.5) / MS, sg)) * MS + 0.5, 0, 1);\n          if (cov > mask[o]) { mask[o] = cov; id[o] = k; }\n        }\n    }\n  }\n  return { mask, id, MU, MV, n };\n}\n\n// Trace a picture onto the floor: E's picture is cut into cells st LEDs\n// wide, each corner is sent off the mirror to the floor, and each cell's\n// two triangles are filled into the polar texels, every texel reading the\n// picture where its barycentric place falls in E's picture. look(u, v)\n// returns the picture there; skip(u, v) lets a cell with nothing in it go.\nfunction trace(cam, reg, st, look, put, skip) {\n  const nu = Math.ceil((reg.u1 - reg.u0) / st) + 1, nv = Math.ceil((reg.v1 - reg.v0) / st) + 1;\n  const A = new Float32Array(nu * nv), B = new Float32Array(nu * nv), ok = new Uint8Array(nu * nv);\n  for (let j = 0; j \u003c nv; j++)\n    for (let i = 0; i \u003c nu; i++)\n      if (design(cam, reg.u0 + i * st, reg.v0 + j * st)) {\n        const n = j * nu + i;\n        ok[n] = 1;\n        A[n] = ((FP[0] + TH) / (2 * TH)) * (NT - 1);\n        B[n] = ((FP[1] - RA) / (RB - RA)) * (NR - 1);\n      }\n  const tri = (a0, b0, u0, v0, a1, b1, u1, v1, a2, b2, u2, v2) => {\n    const det = (b1 - b2) * (a0 - a2) + (a2 - a1) * (b0 - b2);\n    if (abs(det) \u003c 1e-9) return;\n    const xa = max(0, Math.ceil(min(a0, a1, a2))), xb = min(NT - 1, floor(max(a0, a1, a2)));\n    const ya = max(0, Math.ceil(min(b0, b1, b2))), yb = min(NR - 1, floor(max(b0, b1, b2)));\n    for (let y = ya; y \u003c= yb; y++)\n      for (let x = xa; x \u003c= xb; x++) {\n        const w0 = ((b1 - b2) * (x - a2) + (a2 - a1) * (y - b2)) / det, w1 = ((b2 - b0) * (x - a2) + (a0 - a2) * (y - b2)) / det, w2 = 1 - w0 - w1;\n        if (w0 \u003c -1e-6 || w1 \u003c -1e-6 || w2 \u003c -1e-6) continue;\n        const u = w0 * u0 + w1 * u1 + w2 * u2, v = w0 * v0 + w1 * v1 + w2 * v2;\n        put(y * NT + x, u, v, look(u, v));\n      }\n  };\n  for (let j = 0; j + 1 \u003c nv; j++)\n    for (let i = 0; i + 1 \u003c nu; i++) {\n      const n = j * nu + i;\n      if (!ok[n] || !ok[n + 1] || !ok[n + nu] || !ok[n + nu + 1]) continue;\n      const u = reg.u0 + i * st, v = reg.v0 + j * st;\n      if (skip && skip(u, v, st)) continue;\n      tri(A[n], B[n], u, v, A[n + 1], B[n + 1], u + st, v, A[n + nu], B[n + nu], u, v + st);\n      tri(A[n + 1], B[n + 1], u + st, v, A[n + nu + 1], B[n + nu + 1], u + st, v + st, A[n + nu], B[n + nu], u, v + st);\n    }\n}\n\nfunction floorInk(wi, cam, reg) {\n  const wm = wordMask(wi, reg), ink = new Float32Array(NT * NR), lid = new Uint8Array(NT * NR);\n  const sample = (u, v) => {\n    const mx = (u - reg.u0) * MS - 0.5, my = (v - reg.v0) * MS - 0.5;\n    const ix = floor(mx), iy = floor(my);\n    if (ix \u003c 0 || iy \u003c 0 || ix >= wm.MU - 1 || iy >= wm.MV - 1) return 0;\n    const fx = mx - ix, fy = my - iy, o = iy * wm.MU + ix, m = wm.mask;\n    return (m[o] * (1 - fx) + m[o + 1] * fx) * (1 - fy) + (m[o + wm.MU] * (1 - fx) + m[o + wm.MU + 1] * fx) * fy;\n  };\n  trace(cam, reg, 0.25, sample, (o, u, v, c) => {\n    if (c \u003c= ink[o]) return;\n    ink[o] = c;\n    const mx = cl(round((u - reg.u0) * MS - 0.5), 0, wm.MU - 1), my = cl(round((v - reg.v0) * MS - 0.5), 0, wm.MV - 1);\n    lid[o] = wm.id[my * wm.MU + mx];\n  }, (u, v, st) => sample(u + st / 2, v + st / 2) === 0 && sample(u, v) === 0 && sample(u + st, v + st) === 0 && sample(u + st, v) === 0 && sample(u, v + st) === 0);\n  return { ink, lid };\n}\n\n// Niceron's craticule: a square grid laid over the word in E's picture, 6\n// cells across and 9 down, traced onto the paper with it, so the paper\n// carries the bent grid the drawing was made on.\nfunction craticule(cam, reg) {\n  const g = new Float32Array(NT * NR), cw = (reg.u1 - reg.u0) / 6, ch = (reg.v1 - reg.v0) / 9;\n  trace(cam, reg, 0.5, (u, v) => {\n    const a = abs((u - reg.u0) / cw - round((u - reg.u0) / cw)) * cw, b = abs((v - reg.v0) / ch - round((v - reg.v0) / ch)) * ch;\n    return cl(0.45 - min(a, b), 0, 0.25) * 4;\n  }, (o, u, v, c) => { if (c > g[o]) g[o] = c; });\n  return g;\n}\n\nexport function setup(params) {\n  const cam = camera(E, AIM, {}), reg = region(cam);\n  params.s = {\n    ph: 0, hue: 0, design: cam, reg, grid: craticule(cam, reg), cache: {}, k3: -1, word: 0, prev: -1, wipe: 1, next: 0,\n    cam: camera(E, AIM, {}), col: new Float32Array(9), away: 0.06,\n  };\n}\n\nfunction inkOf(S, wi) {\n  return S.cache[wi] || (S.cache[wi] = floorInk(wi, S.design, S.reg));\n}\n\nconst SWAY = 14, HOLD = 7, WIPE = 1.3; // seconds at Speed 2\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  const speed = cl(kv[1], 0.2, 3), k = (d * speed) / 2;\n  const k3 = cl(round(kv[2]), 0, WORDS.length - 1);\n  if (k3 !== S.k3) {\n    S.k3 = k3; S.word = k3; S.prev = -1; S.wipe = 1; S.next = HOLD;\n  }\n  S.next -= k;\n  if (S.next \u003c= 0) {\n    S.prev = S.word; S.word = (S.word + 1) % WORDS.length; S.wipe = 0; S.next = HOLD;\n  }\n  S.wipe = min(1, S.wipe + k / WIPE);\n  inkOf(S, S.word);\n  // The camera: round the axis by up to 60 degrees and up or down by up to\n  // 14, both scaled by Away, on a slow figure of eight through E.\n  S.away = cl(kv[3], 0, 1);\n  S.ph += (k * 2 * PI) / SWAY;\n  const az = S.away * (PI / 3) * sin(S.ph), el = S.away * 0.245 * sin(2 * S.ph + 0.6);\n  const r0 = sqrt(E[0] * E[0] + E[2] * E[2]), e0 = atan2(E[1], r0), L = sqrt(r0 * r0 + E[1] * E[1]);\n  const e1 = e0 + el, rr = L * cos(e1);\n  const pos = [rr * sin(az), L * sin(e1), rr * cos(az)];\n  const aim = [AIM[2] * sin(az), AIM[1], AIM[2] * cos(az)];\n  camera(pos, aim, S.cam);\n  for (let i = 0; i \u003c 3; i++) hsv(S.hue + 0.55 + i / 6, 0.85, 1, S.col, i * 3);\n}\n\n// ---- Shading. Ink on paper at a floor point: returns light in C.\nconst C = [0, 0, 0];\nfunction floorAt(S, x, z) {\n  const r = sqrt(x * x + z * z), th = atan2(x, z);\n  // bare floor: dark tiles a unit square, their joints a little lighter\n  const jx = abs(x - round(x)), jz = abs(z - round(z));\n  let br = 0.03, bg = 0.034, bb = 0.045;\n  if (min(jx, jz) \u003c 0.035) { br = 0.075; bg = 0.08; bb = 0.095; }\n  // the paper: a sheet out to PAPER, darker near the mirror's foot\n  if (r \u003c PAPER && abs(th) \u003c TH - 0.05) {\n    const edge = cl((PAPER - r) * 8, 0, 1) * cl((TH - 0.05 - abs(th)) * 20, 0, 1);\n    const occl = 1 - 0.55 * exp(-(r - RC) * 6);\n    br += (0.13 * occl - br) * edge; bg += (0.135 * occl - bg) * edge; bb += (0.15 * occl - bb) * edge;\n    const a = ((th + TH) / (2 * TH)) * (NT - 1), b = ((r - RA) / (RB - RA)) * (NR - 1);\n    const ia = floor(a), ib = floor(b);\n    if (ia >= 0 && ib >= 0 && ia \u003c NT - 1 && ib \u003c NR - 1) {\n      const fa = a - ia, fb = b - ib, o = ib * NT + ia;\n      const G = S.grid, gr = ((G[o] * (1 - fa) + G[o + 1] * fa) * (1 - fb) + (G[o + NT] * (1 - fa) + G[o + NT + 1] * fa) * fb) * edge;\n      br += 0.13 * gr; bg += 0.14 * gr; bb += 0.16 * gr;\n      // the new word wipes outwards from the mirror's foot over the old\n      const front = RC + S.wipe * (PAPER - RC + 0.4);\n      const mixNew = cl((front - r) * 3, 0, 1);\n      let ink = 0, id = 0;\n      for (let pass = 0; pass \u003c 2; pass++) {\n        const wi = pass ? S.prev : S.word, wgt = pass ? 1 - mixNew : mixNew;\n        if (wi \u003c 0 || wgt \u003c= 0) continue;\n        const T = S.cache[wi];\n        if (!T) continue;\n        const I = T.ink, c = (I[o] * (1 - fa) + I[o + 1] * fa) * (1 - fb) + (I[o + NT] * (1 - fa) + I[o + NT + 1] * fa) * fb;\n        if (c * wgt > ink) {\n          ink = c * wgt;\n          id = T.lid[I[o] > 0 ? o : I[o + 1] > 0 ? o + 1 : I[o + NT] > 0 ? o + NT : o + NT + 1];\n        }\n      }\n      if (ink > 0) {\n        const col = S.col, q = id * 3;\n        br += (col[q] * 0.95 - br) * ink; bg += (col[q + 1] * 0.95 - bg) * ink; bb += (col[q + 2] * 0.95 - bb) * ink;\n      }\n    }\n  }\n  C[0] = br; C[1] = bg; C[2] = bb;\n}\n// The room above, near black. From this eye no ray reaches it: the mirror\n// keeps a ray's fall, and the eye stands above the mirror's top.\nfunction skyAt() {\n  C[0] = 0.02; C[1] = 0.02; C[2] = 0.03;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const cam = S.cam, o = cam.o, ox = o[0], oy = o[1], oz = o[2];\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      ray(cam, px + 0.5, py + 0.5);\n      const dx = D[0], dy = D[1], dz = D[2];\n      let r = 0, g = 0, b = 0;\n      const tc = hitCyl(ox, oy, oz, dx, dy, dz);\n      // the top of the cylinder\n      const tt = dy \u003c 0 ? (HC - oy) / dy : -1;\n      const cx = ox + tt * dx, cz = oz + tt * dz;\n      if (tt > 0 && cx * cx + cz * cz \u003c= RC * RC && (tc \u003c 0 || tt \u003c tc)) {\n        const rr = sqrt(cx * cx + cz * cz);\n        const rim = cl((rr - 0.88) * 9, 0, 1);\n        r = 0.07 + 0.3 * rim; g = 0.075 + 0.3 * rim; b = 0.09 + 0.32 * rim;\n      } else if (tc > 0) {\n        // the mirror: reflect and look again, a little blue and dimmer,\n        // brighter where the ray grazes\n        const hx = ox + tc * dx, hy = oy + tc * dy, hz = oz + tc * dz;\n        const dn = dx * hx + dz * hz, rx = dx - 2 * dn * hx, ry = dy, rz = dz - 2 * dn * hz;\n        if (ry \u003c 0) floorAt(S, hx - (hy / ry) * rx, hz - (hy / ry) * rz);\n        else skyAt();\n        const k = 0.8 + 0.2 * Math.pow(1 - abs(dn), 4);\n        r = C[0] * k * 0.88; g = C[1] * k * 0.93; b = C[2] * k;\n      } else if (dy \u003c 0) {\n        const t = -oy / dy;\n        floorAt(S, ox + t * dx, oz + t * dz);\n        r = C[0]; g = C[1]; b = C[2];\n      } else {\n        skyAt();\n        r = C[0]; g = C[1]; b = C[2];\n      }\n      display.setPixel(px, py, (255 * cl(r, 0, 1)) | 0, (255 * cl(g, 0, 1)) | 0, (255 * cl(b, 0, 1)) | 0);\n    }\n}\n","lorem-ipsum":"// ===== Patternflow pattern =====\n// Title:   Lorem Ipsum\n// Family:  type\n// Idea:    Cicero's sentence from De finibus is set as a justified block of small type and turned letter by letter into the placeholder it became: an alignment computed at the start says which letters stay, the cut ones drop out of their lines and pile up at the foot of the panel, the kept ones slide into the new justified block, and the missing ones leap back out of the heap or fall in from above.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: lorem ipsum, from Cicero, De finibus bonorum et malorum 1.32-33 (45 BC), the source traced by Richard McClintock (Hampden-Sydney College); the alignment is a longest common subsequence by dynamic programming, the table of Robert Wagner and Michael Fischer's string-to-string correction (1974); pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Passage=0..3, Gravity=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together: at 0 the type is cream, letters on their way out turn slate blue and dim in the heap, and letters coming in are mint until they settle.\n// Knob 2: Speed. The clock of a turn. At 2 a turn takes 8.1 s: the cut letters fall from 0.35 s to about 2.7 s, the kept ones slide from 1.2 s to 2.6 s, the missing ones arrive from 2.4 s to about 4 s, and the new block holds 3.5 s before it turns back. The first turn starts 0.8 s in. Ten times slower at 0.2, half again as fast at 3.\n// Knob 3: Passage. Which sentence and the placeholder made from it: 0 Neque porro quisquam (1.32) and Lorem ipsum, 1 Ut enim ad minima (1.32) and Ut enim ad minim, 2 Quis autem vel eum (1.32) and Duis aute irure, 3 excepturi sint occaecati (1.33) and Excepteur sint occaecat. Turning it sends the block to the new sentence at the next turn.\n// Knob 4: Gravity. 240 LEDs/s² at 0, a third of that at -1, three times it at 1. A letter cut from the top line reaches the heap in about 0.9 s at 0, 1.6 s at -1 and 0.55 s at 1, and a letter leaping back out of the heap rises on the same gravity.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hsv = (h, s, v) => [5, 3, 1].map((n) => ((k) => 255 * v * (1 - s * max(0, min(k, 4 - k, 1))))((n + (h - floor(h)) * 6) % 6));\nconst mix = (a, b, t) => a.map((v, i) => v + (b[i] - v) * t);\n\n// ---- The type: 6 rows, the top one for ascenders, four for the x-height\n// and one for descenders; capitals stand on the top five. Rows from the top, comma between\n// rows, a missing row blank. Only the letters the eight passages use.\nconst FONT = {\n  a: \",.##,#.#,#.#,.##\", b: \"#..,##.,#.#,#.#,##.\", c: \",.##,#..,#..,.##\", d: \"..#,.##,#.#,#.#,.##\", e: \",.#.,###,#..,.##\",\n  f: \".##,.#.,###,.#.,.#.\", g: \",.##,#.#,#.#,.##,##.\", h: \"#..,##.,#.#,#.#,#.#\", i: \"#,,#,#,#\", l: \"#,#,#,#,#\",\n  m: \",####.,#.#.#,#.#.#,#.#.#\", n: \",##.,#.#,#.#,#.#\", o: \",.#.,#.#,#.#,.#.\", p: \",##.,#.#,#.#,##.,#..\", q: \",.##,#.#,#.#,.##,..#\",\n  r: \",#.#,##.,#..,#..\", s: \",.##,#..,..#,##.\", t: \".#.,###,.#.,.#.,..#\", u: \",#.#,#.#,#.#,.##\", v: \",#.#,#.#,#.#,.#.\",\n  x: \",#.#,.#.,.#.,#.#\", N: \"#..#,##.#,#.##,#..#,#..#\", L: \"#..,#..,#..,#..,###\", U: \"#.#,#.#,#.#,#.#,###\",\n  Q: \".##.,#..#,#..#,#..#,.##.,...#\", D: \"##.,#.#,#.#,#.#,##.\", E: \"###,#..,##.,#..,###\", \",\": \",,,,#,#\", \".\": \",,,,#\", \"?\": \"##.,..#,.#.,,.#.\",\n};\n// Each glyph in four turns (0 upright, 1 a quarter turn clockwise, 2 a\n// half, 3 a quarter back), with each column's top and bottom ink row, so a\n// letter lying on its side in the heap rests on its own strokes.\nconst GL = {};\nfor (const ch in FONT) {\n  const rows = FONT[ch].split(\",\"), w = max(...rows.map((r) => r.length));\n  const b0 = new Uint8Array(w * 6);\n  rows.forEach((r, y) => [...r].forEach((v, x) => (b0[y * w + x] = v === \"#\")));\n  GL[ch] = [0, 1, 2, 3].map((t) => {\n    const tw = t & 1 ? 6 : w, th = t & 1 ? w : 6, b = new Uint8Array(tw * th);\n    for (let y = 0; y \u003c 6; y++)\n      for (let x = 0; x \u003c w; x++) {\n        if (!b0[y * w + x]) continue;\n        const [nx, ny] = t === 0 ? [x, y] : t === 1 ? [5 - y, x] : t === 2 ? [w - 1 - x, 5 - y] : [y, w - 1 - x];\n        b[ny * tw + nx] = 1;\n      }\n    const top = new Int8Array(tw).fill(-1), bot = new Int8Array(tw).fill(-1);\n    for (let x = 0; x \u003c tw; x++)\n      for (let y = 0; y \u003c th; y++)\n        if (b[y * tw + x]) {\n          if (top[x] \u003c 0) top[x] = y;\n          bot[x] = y;\n        }\n    return { w: tw, h: th, b, top, bot };\n  });\n}\n\n// ---- The passages: Cicero's sentence, and the placeholder as it is set\n// today. The fourth starts in the middle of Cicero's sentence.\nconst PAIRS = [\n  [\n    \"Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem.\",\n    \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\",\n  ],\n  [\n    \"Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur?\",\n    \"Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\",\n  ],\n  [\n    \"Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?\",\n    \"Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\",\n  ],\n  [\n    \"excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga.\",\n    \"Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\",\n  ],\n];\n\n// The alignment: a longest common subsequence of the two strings, case\n// ignored, by the usual table filled from the ends (196 by 123 cells for\n// the first pair). Reading the table back gives \"=\" for a kept character,\n// \"-\" for one cut from a and \"+\" for one added from b; on a tie it cuts\n// before it adds, so a run of cuts stays together.\nfunction align(a, b) {\n  const n = a.length, m = b.length, L = new Int32Array((n + 1) * (m + 1)), M = m + 1;\n  const eq = (i, j) => a[i].toLowerCase() === b[j].toLowerCase();\n  for (let i = n - 1; i >= 0; i--)\n    for (let j = m - 1; j >= 0; j--) L[i * M + j] = eq(i, j) ? L[(i + 1) * M + j + 1] + 1 : max(L[(i + 1) * M + j], L[i * M + j + 1]);\n  const ops = [];\n  let i = 0, j = 0;\n  while (i \u003c n && j \u003c m) {\n    if (eq(i, j) && L[i * M + j] === L[(i + 1) * M + j + 1] + 1) ops.push(\"=\"), i++, j++;\n    else if (L[(i + 1) * M + j] >= L[i * M + j + 1]) ops.push(\"-\"), i++;\n    else ops.push(\"+\"), j++;\n  }\n  while (i++ \u003c n) ops.push(\"-\");\n  while (j++ \u003c m) ops.push(\"+\");\n  return ops;\n}\n\n// ---- Setting. Words are filled greedily into a 62 LED measure from x 1,\n// one LED between letters and three between words; every line but the\n// last is justified. The extra goes to the word spaces first, up to 4 more\n// each, then one LED at a time into the letter spaces from the left. A\n// line that would need more than that is left short, as a compositor would\n// have hyphenated it. Lines are 7 rows apart from y 2. Returns each\n// character's place, null for a space.\nconst MEAS = 62, X0 = 1, Y0 = 2, LP = 7;\nfunction layout(str) {\n  const words = [];\n  let at = 0;\n  for (const w of str.split(\" \")) words.push({ w, at }), (at += w.length + 1);\n  const wl = (w) => [...w].reduce((s, c) => s + GL[c][0].w + 1, -1);\n  const lines = [];\n  let cur = [], len = 0;\n  for (const wd of words) {\n    const add = wl(wd.w) + (cur.length ? 3 : 0);\n    if (cur.length && len + add > MEAS) lines.push(cur), (cur = []), (len = 0);\n    len += wl(wd.w) + (cur.length ? 3 : 0);\n    cur.push(wd);\n  }\n  lines.push(cur);\n  const pos = new Array(str.length).fill(null);\n  lines.forEach((ln, li) => {\n    const nat = ln.reduce((s, wd) => s + wl(wd.w), 0) + 3 * (ln.length - 1);\n    let extra = li \u003c lines.length - 1 ? MEAS - nat : 0;\n    const ws = new Array(ln.length).fill(0), lg = ln.map((wd) => new Array(wd.w.length).fill(0));\n    const nWs = ln.length - 1, nLg = ln.reduce((s, wd) => s + wd.w.length - 1, 0);\n    if (nWs) for (let k = 0; k \u003c nWs && extra > 0; k++) {\n      const give = min(4, floor(extra / (nWs - k)));\n      (ws[k] = give), (extra -= give);\n    }\n    for (let q = 0; q \u003c ln.length && extra > 0; q++) for (let c = 0; c \u003c ln[q].w.length - 1 && extra > 0; c++) lg[q][c]++, extra--;\n    let x = X0;\n    ln.forEach((wd, q) => {\n      for (let c = 0; c \u003c wd.w.length; c++) {\n        pos[wd.at + c] = { x, y: Y0 + li * LP, line: li };\n        x += GL[wd.w[c]][0].w + 1 + lg[q][c];\n      }\n      x += 2 + ws[q];\n    });\n  });\n  return pos;\n}\n\n// ---- Letters are bodies. Modes:\nconst LINE = 0, LOOSE = 1, FALL = 2, HEAP = 3, SLIDE = 4, DROP = 5, JUMP = 6, WAIT = 7;\n// Times in turn seconds (real seconds at Speed 2) after a turn starts.\nconst CUE = 0.35, CUT = 1.4, SLIDE_AT = 1.2, SLIDE_T = 1.0, IN_AT = 2.4, IN_SPREAD = 0.8, DONE = 4.6, HOLD = 3.5;\n// A heap letter fades after this long unless a later turn takes it back.\nconst LIFE = 28;\n\nexport function setup(params) {\n  params.s = { t: 0, ready: false, pair: 0, side: 0, text: \"\", line: [], bodies: [], next: 0, hue: 0, speed: 2, g: 240 };\n}\n\nfunction body(ch, x, y, mode) {\n  return { ch, rot: 0, x, y, vy: 0, mode, t0: 0, t1: 0, x0: x, y0: y, x1: x, y1: y, to: ch, landed: -9, fresh: false, spin: 0 };\n}\n\nfunction setText(S, str) {\n  const pos = layout(str);\n  S.text = str;\n  S.line = pos.map((p, i) => (p ? body(str[i], p.x, p.y, LINE) : null));\n  S.bodies = S.line.filter(Boolean);\n}\n\n// Start a turn from the text on the panel to str.\nfunction turn(S, str) {\n  const a = S.text, ops = align(a, str), pa = layout(a), pb = layout(str), t = S.t;\n  const nl = new Array(str.length).fill(null);\n  let nCut = 0, nIn = 0;\n  for (let k = 0, i = 0, j = 0; k \u003c ops.length; k++) {\n    if (ops[k] === \"-\" && pa[i]) nCut++;\n    if (ops[k] === \"+\" && pb[j]) nIn++;\n    if (ops[k] !== \"+\") i++;\n    if (ops[k] !== \"-\") j++;\n  }\n  let cut = 0, inn = 0;\n  for (let k = 0, i = 0, j = 0; k \u003c ops.length; k++) {\n    const o = ops[k];\n    if (o === \"=\") {\n      const b = S.line[i];\n      if (b && pb[j]) {\n        Object.assign(b, { mode: SLIDE, t0: t + SLIDE_AT + 0.03 * pa[i].line, x0: b.x, y0: b.y, x1: pb[j].x, y1: pb[j].y, to: str[j] });\n        b.t1 = b.t0 + SLIDE_T;\n        nl[j] = b;\n      }\n      i++, j++;\n    } else if (o === \"-\") {\n      const b = S.line[i];\n      // Cut letters go in reading order over CUT s, each turning towards\n      // the colour of the cut for CUE s before it falls.\n      if (b) Object.assign(b, { mode: LOOSE, t0: t + CUE + (CUT * cut++) / max(1, nCut - 1) });\n      i++;\n    } else {\n      if (pb[j]) {\n        const b = body(str[j], pb[j].x, -8, WAIT);\n        Object.assign(b, { t0: t + IN_AT + (IN_SPREAD * inn++) / max(1, nIn - 1), x1: pb[j].x, y1: pb[j].y });\n        nl[j] = b;\n        S.bodies.push(b);\n      }\n      j++;\n    }\n  }\n  S.text = str;\n  S.line = nl;\n  S.next = t + DONE + HOLD;\n}\n\n// Where a sprite at column x would come to rest on the surface.\nfunction restY(surf, sp, x) {\n  let y = 1e9;\n  for (let c = 0; c \u003c sp.w; c++) if (sp.bot[c] >= 0) y = min(y, surf[x + c] - 1 - sp.bot[c]);\n  return y;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.g = 240 * Math.pow(3, cl(k[3], -1, 1));\n  const pair = cl(round(k[2]), 0, 3);\n  const sd = (d * S.speed) / 2;\n  if (!S.ready) {\n    S.pair = pair;\n    setText(S, PAIRS[pair][0]);\n    S.next = 0.8;\n    S.ready = true;\n  }\n  S.t += sd;\n  const t = S.t, g = S.g;\n  if (t >= S.next) {\n    // Turn to the other side of the pair, or to Cicero's side of a new one.\n    if (pair !== S.pair) (S.pair = pair), (S.side = 0);\n    else S.side ^= 1;\n    turn(S, PAIRS[S.pair][S.side]);\n  }\n\n  // Timed modes.\n  const heap = S.bodies.filter((b) => b.mode === HEAP);\n  for (const b of S.bodies) {\n    if (b.mode === LOOSE && t >= b.t0) {\n      // A cut letter tips onto its side a third of the time each way.\n      const r = Math.random();\n      Object.assign(b, { mode: FALL, vy: 0, y0: b.y, spin: r \u003c 0.25 ? 1 : r \u003c 0.5 ? 3 : 0 });\n    } else if (b.mode === SLIDE) {\n      const u = cl((t - b.t0) / (b.t1 - b.t0), 0, 1), e = u * u * (3 - 2 * u);\n      b.x = b.x0 + (b.x1 - b.x0) * e;\n      b.y = b.y0 + (b.y1 - b.y0) * e;\n      if (u > 0.5) b.ch = b.to;\n      if (u >= 1) b.mode = LINE;\n    } else if (b.mode === WAIT && t >= b.t0) {\n      // A letter that is needed comes back out of the heap if one like it\n      // lies there, the highest first; otherwise it falls in from above.\n      let best = null;\n      for (const h of heap) if (h.mode === HEAP && h.ch.toLowerCase() === b.ch.toLowerCase() && (!best || h.y \u003c best.y)) best = h;\n      b.fresh = true;\n      if (best) {\n        best.mode = -1;\n        const dy = max(4, best.y - b.y1), T = sqrt((2 * dy) / g);\n        Object.assign(b, { mode: JUMP, x0: best.x, y0: best.y, x: best.x, y: best.y, rot: best.rot, t0: t, t1: t + T, vy: -g * T });\n      } else Object.assign(b, { mode: DROP, x: b.x1, y: -8 - 10 * Math.random(), vy: 0 });\n    } else if (b.mode === DROP) {\n      b.vy += g * sd;\n      b.y += b.vy * sd;\n      if (b.y >= b.y1) Object.assign(b, { y: b.y1, mode: LINE, landed: t });\n    } else if (b.mode === JUMP) {\n      const s = min(t - b.t0, b.t1 - b.t0), T = b.t1 - b.t0;\n      b.x = b.x0 + ((b.x1 - b.x0) * s) / T;\n      b.y = b.y0 + b.vy * s + 0.5 * g * s * s;\n      if (s > T * 0.4) b.rot = 0;\n      if (t >= b.t1) Object.assign(b, { x: b.x1, y: b.y1, mode: LINE, landed: t, rot: 0 });\n    }\n  }\n  S.bodies = S.bodies.filter((b) => b.mode !== -1 && !(b.mode === HEAP && t - b.landed > LIFE + 2));\n\n  // The heap. Resting letters are stacked from the bottom up on a surface\n  // of the highest ink in each column; one whose support has gone falls\n  // again. A falling letter lands on the surface, unless the column beside\n  // it lets it rest two rows lower, when it slides that way first.\n  const surf = new Float32Array(W).fill(H);\n  const rest = S.bodies.filter((b) => b.mode === HEAP).sort((p, q) => q.y - p.y);\n  for (const b of rest) {\n    const sp = GL[b.ch][b.rot], ry = restY(surf, sp, b.x);\n    if (b.y \u003c ry - 0.5) {\n      b.mode = FALL;\n      b.vy = 0;\n      continue;\n    }\n    b.y = ry;\n    for (let c = 0; c \u003c sp.w; c++) if (sp.top[c] >= 0) surf[b.x + c] = min(surf[b.x + c], ry + sp.top[c]);\n  }\n  const falling = S.bodies.filter((b) => b.mode === FALL).sort((p, q) => q.y - p.y);\n  for (const b of falling) {\n    if (b.spin && b.y - b.y0 > 4) (b.rot = b.spin), (b.spin = 0), (b.x = cl(round(b.x) - 1, 0, W - 6));\n    const sp = GL[b.ch][b.rot];\n    b.x = cl(round(b.x), 0, W - sp.w);\n    b.vy += g * sd;\n    b.y += b.vy * sd;\n    let ry = restY(surf, sp, b.x);\n    if (b.y \u003c ry) continue;\n    // Look one and two columns either way; step towards the lowest rest\n    // if it is 2 rows lower at one column or 3 at two.\n    let go = 0, low = ry;\n    for (const s of [-1, 1, -2, 2]) {\n      const nx = b.x + s;\n      if (nx \u003c 0 || nx > W - sp.w) continue;\n      const v = restY(surf, sp, nx);\n      if (v >= ry + 1 + abs(s) && v > low) (low = v), (go = s > 0 ? 1 : -1);\n    }\n    if (go) {\n      b.x += go;\n      b.y = ry;\n      b.vy *= 0.5;\n      continue;\n    }\n    Object.assign(b, { y: ry, vy: 0, mode: HEAP, landed: t });\n    for (let c = 0; c \u003c sp.w; c++) if (sp.top[c] >= 0) surf[b.x + c] = min(surf[b.x + c], ry + sp.top[c]);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const t = S.t, h = S.hue;\n  const cream = hsv(0.11 + h, 0.4, 0.95), slate = hsv(0.6 + h, 0.42, 0.8), mint = hsv(0.45 + h, 0.55, 1);\n  const buf = new Float32Array(W * H * 3);\n  const order = [LINE, SLIDE, LOOSE, HEAP, FALL, WAIT, DROP, JUMP];\n  for (const m of order)\n    for (const b of S.bodies) {\n      if (b.mode !== m || b.mode === WAIT) continue;\n      let c = cream, a = 1;\n      if (m === LOOSE) c = mix(cream, slate, cl(1 - (b.t0 - t) / CUE, 0, 1));\n      else if (m === FALL) c = slate;\n      else if (m === HEAP) {\n        const age = t - b.landed;\n        a = 1 - 0.45 * cl(age / 2, 0, 1);\n        if (age > LIFE) a *= cl(1 - (age - LIFE) / 2, 0, 1);\n        c = slate;\n      } else if (m === DROP || m === JUMP) c = mint;\n      else if (b.fresh && m === LINE) c = mix(mint, cream, cl((t - b.landed) / 1.5, 0, 1));\n      const sp = GL[b.ch][b.rot], bx = round(b.x), by = round(b.y);\n      for (let y = 0; y \u003c sp.h; y++) {\n        const py = by + y;\n        if (py \u003c 0 || py >= H) continue;\n        for (let x = 0; x \u003c sp.w; x++) {\n          const px = bx + x;\n          if (px \u003c 0 || px >= W || !sp.b[y * sp.w + x]) continue;\n          const p = (py * W + px) * 3;\n          buf[p] = c[0] * a, buf[p + 1] = c[1] * a, buf[p + 2] = c[2] * a;\n        }\n      }\n    }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p % W, floor(p / W), buf[p * 3] | 0, buf[p * 3 + 1] | 0, buf[p * 3 + 2] | 0);\n}\n","mastermind":"// ===== Patternflow pattern =====\n// Title:   Mastermind\n// Family:  algo\n// Idea:    All 1296 codes of four pegs in six colours stand as a 6 by 6 grid of 6 by 6 blocks at the top, and Knuth's minimax player plays real games on the board below: each guess splits the codes still possible into colours by the answer they would give, the answer comes, and every class but one fades out, so the grid empties to a single LED in at most five guesses.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Mastermind (Mordecai Meirowitz, 1970), minimax strategy (Donald E. Knuth, The Computer as Master Mind, 1976), expected size (Robert W. Irving, 1979), most parts (Barteld Kooi, 2005), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strategy=0..3, Codemaker=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the codes still possible are warm white, the six peg colours start from red, and the 14 answers each have their own colour.\n// Knob 2: Speed. Beats a second: 2 at 2, so one guess (search 1 beat, place 1, split 2, answer 1, fade 1.5) takes 3.25 s and a game about 17 s; 0.2 at 0.2, 3 at 3.\n// Knob 3: Strategy. How the codebreaker picks a guess from all 1296 codes. 0 Knuth's minimax: the guess whose largest answer class is smallest, 4.476 guesses a game over all 1296 secrets. 1 Irving's expected size: the smallest sum of squared class sizes, 4.395. 2 Kooi's most parts: the most answer classes, 4.373. Ties go to a code still possible, then the lowest. 3 A random code still possible, about 4.66. Turning it takes effect from the next guess.\n// Knob 4: Codemaker. 0 picks a secret at random and answers honestly. 1 cheats within the rules, behind a red shield: it keeps no secret and always gives the answer that leaves the most codes. Knuth's player still wins in 5 every time, Irving's in 5, Kooi's only in 6, the random one in 5 to 8.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\nconst mix = (a, b, u) => [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, a[2] + (b[2] - a[2]) * u];\n\n// ---- Codes. A code is four pegs in six colours, c = 216 p1 + 36 p2 + 6 p3 + p4,\n// so Knuth's 1122 is 7. The answer to guess g for secret s is b black pegs\n// (right colour, right place) and w white (right colour, wrong place), kept as\n// b * 5 + w. Of the 25 slots 14 occur; 3 black and 1 white cannot.\nconst N = 1296, DIG = new Uint8Array(N * 4), CNT = new Uint8Array(N * 6);\nfor (let c = 0; c \u003c N; c++)\n  for (let j = 0; j \u003c 4; j++) {\n    const d = floor(c / [216, 36, 6, 1][j]) % 6;\n    DIG[c * 4 + j] = d;\n    CNT[c * 6 + d]++;\n  }\nfunction answer(g, s) {\n  let b = 0, t = 0;\n  for (let j = 0; j \u003c 4; j++) if (DIG[g * 4 + j] === DIG[s * 4 + j]) b++;\n  for (let d = 0; d \u003c 6; d++) t += min(CNT[g * 6 + d], CNT[s * 6 + d]);\n  return b * 5 + t - b;\n}\nconst WIN = 20;\nconst ANS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 15, 20], CLS = new Int8Array(25).fill(-1);\nANS.forEach((a, i) => (CLS[a] = i));\n\n// The answer table, 1296 by 1296 bytes, built once on the first frame (about\n// 30 ms in Node, the only heavy frame): each guess's score is then |S| lookups.\nlet FB = null;\nfunction table() {\n  if (FB) return FB;\n  FB = new Uint8Array(N * N);\n  for (let g = 0; g \u003c N; g++)\n    for (let s = g; s \u003c N; s++) {\n      const a = answer(g, s);\n      FB[g * N + s] = a;\n      FB[s * N + g] = a;\n    }\n  return FB;\n}\n\n// ---- Strategies. Every guess is chosen over all 1296 codes, those already\n// ruled out too, by the sizes n_i of the classes it splits S into:\n// 0 Knuth (1976), the smallest largest n_i; 1 Irving (1979), the smallest\n// sum of n_i^2, which is the expected size of what is left; 2 Kooi (2005), the\n// most classes. Ties go to a code in S, then the lowest. 3 picks a random code\n// from S. Played offline against all 1296 secrets with this code: Knuth opens\n// 1122 and takes 5801 guesses, 4.476 a game, never more than 5 (1, 6, 62, 533\n// and 694 games of 1 to 5 guesses, as in Knuth's paper); Irving opens 1123,\n// 5696, 4.395, at most 6; Kooi opens 1123, 5668, 4.373, at most 6; random,\n// over ten seeds, 4.626 to 4.693 a game, at most 8.\nconst counts = new Int32Array(25);\nfunction score(strat, g, S, n) {\n  counts.fill(0);\n  const row = g * N;\n  for (let i = 0; i \u003c n; i++) counts[FB[row + S[i]]]++;\n  let v = 0;\n  if (strat === 0) for (let a = 0; a \u003c 25; a++) v = max(v, counts[a]);\n  else if (strat === 1) for (let a = 0; a \u003c 25; a++) v += counts[a] * counts[a];\n  else for (let a = 0; a \u003c 25; a++) v -= counts[a] > 0;\n  return v;\n}\n// The first guess of a game sees all 1296 codes, so it and its scores are the\n// same every game: kept after the first search.\nconst FIRST = [null, null, null];\n\n// A search in progress: the candidates are scored in slices of about 120,000\n// lookups a frame, half a millisecond in Node, so the first guess of a game\n// (1296 x 1296) spreads over 14 frames, inside its one beat at Speed 2.\nfunction search(strat) {\n  return { strat, g: 0, best: -1, bs: 0, bin: false, done: false, sc: new Float32Array(N) };\n}\nfunction step(G, q, budget) {\n  if (q.done) return;\n  const S = G.S, n = G.n;\n  if (q.strat === 3) {\n    q.best = S[floor(Math.random() * n)];\n    q.g = N;\n    q.done = true;\n    return;\n  }\n  if (n === N && FIRST[q.strat]) {\n    const f = FIRST[q.strat];\n    q.best = f.best;\n    q.bs = f.bs;\n    q.sc = f.sc;\n    q.g = N;\n    q.done = true;\n    return;\n  }\n  let work = 0;\n  while (q.g \u003c N && work \u003c budget) {\n    const g = q.g++, v = score(q.strat, g, S, n), inS = G.inS[g] === 1;\n    q.sc[g] = v;\n    if (q.best \u003c 0 || v \u003c q.bs || (v === q.bs && inS && !q.bin)) {\n      q.best = g;\n      q.bs = v;\n      q.bin = inS;\n    }\n    work += n;\n  }\n  if (q.g >= N) {\n    q.done = true;\n    if (n === N) FIRST[q.strat] = q;\n  }\n}\n\n// The codemaker. Honest: the answer for the secret. Cheating: the answer with\n// the most codes of S behind it, a random one of those on a tie, and 4 black\n// only once S is that one code. It never has to commit, since every answer it\n// gives fits some code still in S. Against it, in Node: Knuth 5 guesses and\n// Irving 5 in every one of 300 games, Kooi 6 in every one, random 5 to 8,\n// 6.25 on average over 2,000.\nfunction reply(G, g, adv) {\n  if (!adv) return FB[g * N + G.secret];\n  counts.fill(0);\n  for (let i = 0; i \u003c G.n; i++) counts[FB[g * N + G.S[i]]]++;\n  if (G.n === 1 && counts[WIN]) return WIN;\n  let top = 0, k = 0, pick = WIN;\n  for (let a = 0; a \u003c WIN; a++) top = max(top, counts[a]);\n  for (let a = 0; a \u003c WIN; a++) if (counts[a] === top && Math.random() * ++k \u003c 1) pick = a;\n  return pick;\n}\n\nfunction newGame(S) {\n  const G = {\n    secret: floor(Math.random() * N), S: new Int16Array(N), n: N, inS: new Uint8Array(N).fill(1),\n    rows: [], phase: \"choose\", ph: 0, q: null, g: -1, ans: -1,\n  };\n  for (let i = 0; i \u003c N; i++) G.S[i] = i;\n  G.q = search(S.strat);\n  return G;\n}\n// Keep the codes of S that give answer a to guess g.\nfunction cut(G, g, a) {\n  let m = 0;\n  for (let i = 0; i \u003c G.n; i++) {\n    const s = G.S[i];\n    if (FB[g * N + s] === a) G.S[m++] = s;\n    else G.inS[s] = 0;\n  }\n  G.n = m;\n}\nfunction settle(S, G) {\n  // The secret a cheating codemaker ends up with is the last code standing.\n  if (S.adv && G.n >= 1) G.secret = G.S[0];\n  G.rows.push({ g: G.g, ans: G.ans, rem: G.n });\n}\n\n// ---- Timing, in beats (Speed beats a second): search at least 1, place 1,\n// split 2, answer 1, fade 1.5; a solved board stays 3 beats, then 1.5 to clear.\nconst T = { choose: 1, place: 1, split: 2, answer: 1, fade: 1.5, reveal: 3, clear: 1.5 };\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, speed: 2, strat: 0, adv: 0, G: null, rgb: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.strat = cl(round(k[2]), 0, 3);\n  const adv = cl(round(k[3]), 0, 1);\n  table();\n  if (!S.G) {\n    // Open on a game in progress: the first guess is on the board and the\n    // 1296 codes are splitting by the answer they would give it.\n    S.adv = adv;\n    const G = (S.G = newGame(S));\n    while (!G.q.done) step(G, G.q, 1e9);\n    G.g = G.q.best;\n    G.ans = reply(G, G.g, adv);\n    G.phase = \"split\";\n  }\n  let G = S.G;\n  // Never left with no code standing; a fresh game if it ever were.\n  if (G.n === 0) G = S.G = newGame(S);\n  if (adv !== S.adv) {\n    S.adv = adv;\n    // An honest codemaker taking over needs a secret that fits every answer,\n    // the one on its way to the board too.\n    if (!adv) {\n      const fits = [];\n      for (let i = 0; i \u003c G.n; i++) if (G.phase === \"choose\" || FB[G.g * N + G.S[i]] === G.ans) fits.push(G.S[i]);\n      if (fits.length) G.secret = fits[floor(Math.random() * fits.length)];\n    }\n  }\n  if (G.phase === \"choose\" && G.q && G.q.strat !== S.strat && !G.q.done) G.q = search(S.strat);\n  if (G.phase === \"choose\") step(G, G.q, 120000);\n  G.ph += d * S.speed;\n  const end = T[G.phase];\n  if (G.ph \u003c end) return;\n  if (G.phase === \"choose\") {\n    if (!G.q.done) return;\n    G.g = G.q.best;\n    G.ans = reply(G, G.g, S.adv);\n    G.phase = \"place\";\n  } else if (G.phase === \"place\") G.phase = \"split\";\n  else if (G.phase === \"split\") G.phase = \"answer\";\n  else if (G.phase === \"answer\") G.phase = \"fade\";\n  else if (G.phase === \"fade\") {\n    cut(G, G.g, G.ans);\n    settle(S, G);\n    if (G.ans === WIN) G.phase = \"reveal\";\n    else {\n      G.phase = \"choose\";\n      G.q = search(S.strat);\n    }\n  } else if (G.phase === \"reveal\") G.phase = \"clear\";\n  else if (G.phase === \"clear\") {\n    S.G = newGame(S);\n    return;\n  }\n  G.ph = 0;\n}\n\n// ---- Layout. The grid: block row p1, block column p2, and inside a block row\n// p3 and column p4, one LED a code, blocks 6 LEDs with 3 dark between: 51 by\n// 51 at x 9, y 3. Bars of p1's colour run down the left, p2's along the top.\n// The board below, played from the near end as on a real one: the first\n// guess at the bottom (y 122), up to eight every 8 rows, each four 6 by 6\n// pegs, the key pegs in a 2 by 2 square and, at the right edge, how many\n// codes the answer left. The secret sits behind its shield at the far end,\n// y 57. A random player can need 8 guesses; Knuth's never more than 5.\nconst GX = 9, GY = 3, BP = 9, SY = 57, RY = 122, RP = 8, ROWS = 8, PX = 4, KX = 37;\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n};\nconst gx = (c) => GX + (floor(c / 36) % 6) * BP + (c % 6);\nconst gy = (c) => GY + floor(c / 216) * BP + (floor(c / 6) % 6);\n\nfunction put(rgb, x, y, c, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  rgb[p] += c[0] * v, rgb[p + 1] += c[1] * v, rgb[p + 2] += c[2] * v;\n}\nfunction peg(rgb, x, y, c, v) {\n  for (let j = 0; j \u003c 6; j++)\n    for (let i = 0; i \u003c 6; i++) {\n      const corner = (i === 0 || i === 5) && (j === 0 || j === 5);\n      put(rgb, x + i, y + j, c, corner ? v * 0.3 : v);\n    }\n}\nfunction number(rgb, n, xr, y, c, v) {\n  const s = String(n);\n  for (let i = 0; i \u003c s.length; i++) {\n    const g = GLYPH[s[s.length - 1 - i]], x = xr - 3 - 4 * i;\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") put(rgb, x + q, y + r, c, v);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.G) return;\n  const G = S.G, rgb = S.rgb, hue = S.hue, ph = G.ph;\n  rgb.fill(0);\n  const tone = hsv(0.12 + hue, 0.22, 0.85), ghost = hsv(0.62 + hue, 0.45, 0.115), white = [1, 1, 1];\n  const pegs = [0, 1, 2, 3, 4, 5].map((i) => hsv(0.02 + hue + i / 6, 0.85, 1));\n  const cls = ANS.map((a, i) => hsv(0.55 + hue + i * 0.382, 0.75, 1));\n  const kb = hsv(0.98 + hue, 0.8, 1), kw = hsv(0.6 + hue, 0.05, 1);\n  const live = G.phase === \"place\" || G.phase === \"split\" || G.phase === \"answer\" || G.phase === \"fade\";\n  const truth = live ? CLS[G.ans] : -1;\n\n  // The grid. While a guess is searched for, each code the search has scored\n  // shows how good a guess it would be: u is the best score so far over its\n  // own (for Kooi its parts over the most), and the LED runs from dim blue to\n  // gold as u^5, so only guesses near the best shine. When 1122 gets one white\n  // peg and leaves 256 codes, Knuth's best is a largest class of 44, met by 48\n  // codes, and half of all 1296 do no better than 57. The heat fades through\n  // the place beat.\n  const q = G.q, heat = (G.phase === \"choose\" || G.phase === \"place\") && q && q.strat \u003c 3;\n  const upto = G.phase === \"choose\" ? floor(min(ph / T.choose, q.g / N) * N) : N;\n  const keep = G.phase === \"place\" ? min(1, ph / 0.8) : 0;\n  for (let c = 0; c \u003c N; c++) {\n    let col;\n    if (!G.inS[c]) col = G.phase === \"clear\" ? mix(ghost, tone, min(1, ph / 1.2)) : ghost;\n    else if (G.phase === \"split\" || G.phase === \"answer\" || G.phase === \"fade\") {\n      const k = CLS[FB[G.g * N + c]], cc = cls[k];\n      if (G.phase === \"split\") col = mix(tone, cc, min(1, ph / 0.6));\n      else if (G.phase === \"answer\") col = k === truth ? mix(cc, white, 0.25 + 0.25 * sin(ph * PI * 4)) : cc;\n      else col = k === truth ? mix(cc, tone, min(1, ph / 1.2)) : mix(cc, ghost, min(1, ph / 1.2));\n    } else col = tone;\n    if (heat && c \u003c upto) {\n      const u = q.strat === 2 ? q.sc[c] / q.bs : q.bs / q.sc[c], u5 = u ** 5;\n      col = mix(hsv(0.62 + hue - 0.47 * u, 0.85 - 0.45 * u5, 0.14 + 0.86 * u5), col, keep);\n    }\n    put(rgb, gx(c), gy(c), col, 1);\n  }\n  for (let b = 0; b \u003c 6; b++) {\n    for (let j = 0; j \u003c 6; j++) {\n      put(rgb, 4, GY + b * BP + j, pegs[b], 0.5);\n      put(rgb, 5, GY + b * BP + j, pegs[b], 0.5);\n      put(rgb, GX + b * BP + j, 0, pegs[b], 0.5);\n    }\n  }\n  // The search front runs over all 1296 codes, ruled out or not, and the best\n  // guess so far shines. A random player rolls among S instead. Then the\n  // guess blinks until its answer is in.\n  if (G.phase === \"choose\" && q) {\n    if (q.strat \u003c 3) {\n      for (let i = 0; i \u003c 8; i++) if (upto - i >= 0 && upto - i \u003c N) put(rgb, gx(upto - i), gy(upto - i), white, 0.9 * (1 - i / 8));\n    } else for (let i = 0; i \u003c 6; i++) {\n      const c = G.S[floor(Math.random() * G.n)];\n      put(rgb, gx(c), gy(c), white, 0.8);\n    }\n    if (q.best >= 0 && upto > 60) put(rgb, gx(q.best), gy(q.best), white, 0.8);\n  } else if (live) put(rgb, gx(G.g), gy(G.g), white, 0.55 + 0.45 * sin(S.t * PI * 6));\n\n  // The board.\n  const fadeAll = G.phase === \"clear\" ? max(0, 1 - ph / 1.2) : 1;\n  const rows = G.rows.slice();\n  if (live) rows.push({ g: G.g, ans: G.ans, rem: -1, now: true });\n  const off = max(0, rows.length - ROWS);\n  for (let r = 0; r \u003c ROWS; r++) {\n    const y = RY - RP * r, R = rows[r + off];\n    if (!R) {\n      for (let j = 0; j \u003c 4; j++) for (let h = 0; h \u003c 4; h++) put(rgb, PX + 8 * j + 2 + (h & 1), y + 2 + (h >> 1), ghost, 1.3);\n      for (let h = 0; h \u003c 4; h++) put(rgb, KX + 3 * (h & 1), y + 3 * (h >> 1), ghost, 1.3);\n      continue;\n    }\n    // Pegs go in one by one through the place beat; keys through the answer.\n    const shown = R.now && G.phase === \"place\" ? floor(ph / 0.2) + 1 : 4;\n    for (let j = 0; j \u003c 4; j++) {\n      if (j \u003c shown) peg(rgb, PX + 8 * j, y, pegs[DIG[R.g * 4 + j]], 0.9 * fadeAll);\n      else for (let h = 0; h \u003c 4; h++) put(rgb, PX + 8 * j + 2 + (h & 1), y + 2 + (h >> 1), ghost, 1.3);\n    }\n    const keys = R.now ? (G.phase === \"answer\" ? min(4, floor(ph / 0.2)) : G.phase === \"fade\" ? 4 : 0) : 4;\n    const b = floor(R.ans / 5), w = R.ans % 5;\n    for (let h = 0; h \u003c 4; h++) {\n      const x = KX + 3 * (h & 1), yy = y + 3 * (h >> 1);\n      const kind = h \u003c keys ? (h \u003c b ? kb : h \u003c b + w ? kw : null) : null;\n      if (kind) for (let e = 0; e \u003c 4; e++) put(rgb, x + (e & 1), yy + (e >> 1), kind, fadeAll);\n      else put(rgb, x, yy, ghost, 1.3);\n    }\n    const rem = R.now ? (G.phase === \"fade\" && ph > 0.5 ? null : -1) : R.rem;\n    if (rem !== -1) number(rgb, rem === null ? countClass(G) : rem, 63, y + 1, tone, 0.75 * fadeAll);\n  }\n\n  // The secret: behind a hatched shield until it is found.\n  if (G.phase === \"reveal\" || G.phase === \"clear\") {\n    const open = G.phase === \"reveal\" ? min(1, ph / 0.5) : 1;\n    for (let j = 0; j \u003c 4; j++) peg(rgb, PX + 8 * j, SY, pegs[DIG[G.secret * 4 + j]], open * fadeAll);\n    if (G.phase === \"reveal\") put(rgb, gx(G.secret), gy(G.secret), white, 0.5 + 0.5 * sin(ph * PI * 3));\n  } else {\n    const sh = S.adv ? kb : ghost, v = S.adv ? 0.3 : 2.2;\n    for (let j = 0; j \u003c 6; j++) for (let x = PX; x \u003c PX + 30; x++) put(rgb, x, SY + j, sh, (x + j) % 4 === 0 ? v * 1.6 : v * 0.7);\n  }\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[p * 3], g = rgb[p * 3 + 1], b = rgb[p * 3 + 2];\n    if (r + g + b > 0) display.setPixel(p % W, floor(p / W), min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n\n// How many codes of S give the answer that came: shown as the fade runs.\nfunction countClass(G) {\n  let m = 0;\n  for (let i = 0; i \u003c G.n; i++) if (FB[G.g * N + G.S[i]] === G.ans) m++;\n  return m;\n}\n","platycosms":"// ===== Patternflow pattern =====\n// Title:   Platycosms\n// Family:  space\n// Idea:    You fly through a closed flat universe holding one three-armed jack, and every cube of space you look through shows a copy of it, turned by the gluing that brought you there: a quarter turn a step in the tetracosm, a half turn in the dicosm, the Hantzsche-Wendt screws in the didicosm, none in the 3-torus.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: flat 3-manifolds (Werner Nowacki, 1934; Walter Hantzsche and Hilmar Wendt, 1935), names after John Conway and Juan Pablo Rossetti (2003), the inside view after Jeffrey Weeks (The Shape of Space, 1985), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Space=0..3, Heading=0..1\n//\n// Knob 1: Hue. Turns the three arm colours round the wheel together: at 0 the long arm is green, the middle one azure and the short one pink, on a white hub.\n// Knob 2: Speed. How fast you fly: 0.44 cubes a second at 2, ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Space. 0 the tetracosm, whose cube is glued top to bottom with a quarter turn; 1 the dicosm, glued with a half turn; 2 the didicosm, the Hantzsche-Wendt manifold, two cubes big, so only every other cube holds a copy, and each copy is turned a half turn about x, y or z or not at all; 3 the torocosm, the 3-torus, where every copy faces the same way.\n// Knob 4: Heading. The angle between your flight and the z axis, the axis of the turn, from 0 to 90 degrees. At the opening 0.06 you fly 5.4 degrees off it, so in the tetracosm each copy you pass is turned a quarter turn from the one before, one every 2.3 s; at 1 you fly along x, the copies in line ahead of you all face the same way, and each layer to your left and right is turned a quarter more.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst F = 60; // focal length in LEDs: 94 degrees of view top to bottom, 56 across\nconst FOG = 1.9; // brightness falls by e every 1.9 cubes\nconst TMAX = 5.5; // a ray gives up after 5.5 cubes, where the fog leaves 5%\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- The jack, in the fundamental cube [0,1]^3: a hub, three rods along\n// +x, +y and +z of lengths 0.27, 0.18 and 0.32, and a ball on each end. It\n// stays inside [0.265, 0.735]^3, and so does every copy in its own cube,\n// since all the gluings below turn or reflect about the cube's centre lines.\n// The slab |y| \u003c 0.265 (mod 1) never meets a copy, and the camera flies in it.\nconst HUB = [0.356, 0.356, 0.34], HR = 0.075, ROD = 0.028;\nconst ARM = [0.272, 0.176, 0.32], BALL = [0.06, 0.053, 0.066];\n\n// ---- The deck group. For a cube (i, j, k) of the lattice, deck() finds\n// the map g^-1 that takes it back onto the fundamental cube, a signed\n// permutation and a shift: p_ref[a] = SG[c][a] * q[SRC[c][a]] + TR[a], where\n// c is the returned rotation class, or -1 for a cube of the didicosm that\n// holds no copy. Classes: 0 none, 1..3 one to three quarter turns undone\n// about z, 4..6 the half turns about x, y and z of the didicosm.\nconst SRC = [[0, 1, 2], [1, 0, 2], [0, 1, 2], [1, 0, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]];\nconst SG = [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, -1, -1], [-1, 1, -1], [-1, -1, 1]];\nconst TR = [0, 0, 0];\nconst md = (a, n) => ((a % n) + n) % n;\n// Didicosm generators, scaled by 2 so they carry unit cubes to unit cubes:\n// alpha (x+1, 1-y, -z), beta (-x, y+1, 1-z), gamma (1-x, -y, z+1). Their\n// squares are the steps of 2 along x, y and z, and alpha beta gamma = 1.\n// The cube parity i+j+k is kept, so the copies sit on the even cubes only:\n// the manifold is two cubes big. Per parity class (i, j, k mod 2 as bits):\n// the coset's class, its shift s, and where it sends the cube (0, 0, 0).\nconst HW = [[0, [0, 0, 0], [0, 0, 0]], null, null, [5, [0, 1, 1], [-1, 1, 0]], null, [4, [1, 1, 0], [1, 0, -1]], [6, [1, 0, 1], [0, -1, 1]], null];\nfunction deck(m, i, j, k) {\n  if (m === 2) {\n    const e = HW[md(i, 2) | (md(j, 2) \u003c\u003c 1) | (md(k, 2) \u003c\u003c 2)];\n    if (!e) return -1;\n    const c = e[0], D = SG[c], s = e[1], h = e[2];\n    // g = T(v) h with v = cell - h(cube 0), so g^-1(q) = D (q - v - s).\n    TR[0] = -D[0] * (i - h[0] + s[0]); TR[1] = -D[1] * (j - h[1] + s[1]); TR[2] = -D[2] * (k - h[2] + s[2]);\n    return c;\n  }\n  TR[2] = -k;\n  // Tetracosm: a step up z turns a quarter about the cube's axis x = y = 1/2;\n  // dicosm a half; torocosm none. Undo k of them.\n  const r = m === 0 ? md(-k, 4) : m === 1 ? 2 * md(k, 2) : 0;\n  if (r === 0) { TR[0] = -i; TR[1] = -j; }\n  else if (r === 1) { TR[0] = j + 1; TR[1] = -i; }\n  else if (r === 2) { TR[0] = i + 1; TR[1] = j + 1; }\n  else { TR[0] = -j; TR[1] = i + 1; }\n  return r;\n}\n\n// ---- Drawing. The panel is a depth buffer: every copy within 5.5 cubes of\n// the camera is cut into four parts (the hub ball and the three arms, each\n// in its own box), each part's box is projected to the screen, clipped at\n// the camera plane, and only the LEDs inside that rectangle trace a ray\n// against the part, in the copy's own frame, keeping the nearest hit. About\n// 160 copies are in reach, and a frame takes about 1.2 ms in Node; tracing\n// every cube along every ray instead took 5 to 7 ms.\nconst N = W * H;\nconst DIR = new Float64Array(N * 3), DEPTH = new Float64Array(N), LAM = new Float64Array(N), PART = new Int8Array(N);\n// Part boxes in the fundamental cube: lo x y z, hi x y z.\nconst PB = [\n  [HUB[0] - HR, HUB[1] - HR, HUB[2] - HR, HUB[0] + HR, HUB[1] + HR, HUB[2] + HR],\n  [HUB[0], HUB[1] - BALL[0], HUB[2] - BALL[0], HUB[0] + ARM[0] + BALL[0], HUB[1] + BALL[0], HUB[2] + BALL[0]],\n  [HUB[0] - BALL[1], HUB[1], HUB[2] - BALL[1], HUB[0] + BALL[1], HUB[1] + ARM[1] + BALL[1], HUB[2] + BALL[1]],\n  [HUB[0] - BALL[2], HUB[1] - BALL[2], HUB[2], HUB[0] + BALL[2], HUB[1] + BALL[2], HUB[2] + ARM[2] + BALL[2]],\n];\nconst CAMP = new Float64Array(24), RECT = new Float64Array(4);\nconst NEAR = 0.01;\nfunction addPt(u, v, z) {\n  const sx = W / 2 + (F * u) / z, sy = H / 2 - (F * v) / z;\n  if (sx \u003c RECT[0]) RECT[0] = sx;\n  if (sx > RECT[1]) RECT[1] = sx;\n  if (sy \u003c RECT[2]) RECT[2] = sy;\n  if (sy > RECT[3]) RECT[3] = sy;\n}\n// The screen rectangle of box b of the copy whose map is class c, shift TR.\nfunction rect(S, b, c) {\n  const { cam, fw, rt, up } = S, src = SRC[c], sg = SG[c], bx = PB[b];\n  let front = 0;\n  for (let q = 0; q \u003c 8; q++) {\n    // p_ref -> world: q[SRC[a]] = SG[a] (p[a] - TR[a])\n    const p0 = sg[0] * (bx[q & 1 ? 3 : 0] - TR[0]), p1 = sg[1] * (bx[q & 2 ? 4 : 1] - TR[1]), p2 = sg[2] * (bx[q & 4 ? 5 : 2] - TR[2]);\n    const X = (src[0] === 0 ? p0 : p1) - cam[0], Y = (src[1] === 1 ? p1 : p0) - cam[1], Z = p2 - cam[2];\n    const z = X * fw[0] + Y * fw[1] + Z * fw[2];\n    CAMP[q * 3] = X * rt[0] + Y * rt[1] + Z * rt[2];\n    CAMP[q * 3 + 1] = X * up[0] + Y * up[1] + Z * up[2];\n    CAMP[q * 3 + 2] = z;\n    if (z >= NEAR) front++;\n  }\n  if (!front) return false;\n  RECT[0] = RECT[2] = 1e9; RECT[1] = RECT[3] = -1e9;\n  for (let q = 0; q \u003c 8; q++) if (CAMP[q * 3 + 2] >= NEAR) addPt(CAMP[q * 3], CAMP[q * 3 + 1], CAMP[q * 3 + 2]);\n  if (front \u003c 8)\n    for (let q = 0; q \u003c 8; q++)\n      for (let e = 1; e \u003c 8; e \u003c\u003c= 1) {\n        const r = q | e;\n        if (r === q) continue;\n        const za = CAMP[q * 3 + 2], zb = CAMP[r * 3 + 2];\n        if (za \u003c NEAR === zb \u003c NEAR) continue;\n        const f = (NEAR - za) / (zb - za);\n        addPt(CAMP[q * 3] + f * (CAMP[r * 3] - CAMP[q * 3]), CAMP[q * 3 + 1] + f * (CAMP[r * 3 + 1] - CAMP[q * 3 + 1]), NEAR);\n      }\n  return RECT[0] \u003c W && RECT[1] > 0 && RECT[2] \u003c H && RECT[3] > 0;\n}\n\n// Ray o + t d against a ball at the centre (cx, cy, cz).\nfunction ball(ox, oy, oz, dx, dy, dz, cx, cy, cz, r) {\n  const qx = ox - cx, qy = oy - cy, qz = oz - cz;\n  const b = qx * dx + qy * dy + qz * dz, disc = b * b - (qx * qx + qy * qy + qz * qz - r * r);\n  if (disc \u003c 0) return 1e9;\n  const t = -b - sqrt(disc);\n  return t > 1e-4 ? t : 1e9;\n}\n// Trace part b for the LEDs in RECT, in the copy's frame (class c, shift TR).\nfunction raster(S, b, c) {\n  const { cam } = S, src = SRC[c], sg = SG[c];\n  const s0 = src[0], s1 = src[1], g0 = sg[0], g1 = sg[1], g2 = sg[2];\n  const ox = g0 * cam[s0] + TR[0] - HUB[0], oy = g1 * cam[s1] + TR[1] - HUB[1], oz = g2 * cam[2] + TR[2] - HUB[2];\n  const x0 = max(0, floor(RECT[0])), x1 = min(W - 1, floor(RECT[1])), y0 = max(0, floor(RECT[2])), y1 = min(H - 1, floor(RECT[3]));\n  const L = b ? ARM[b - 1] : 0, w = b ? BALL[b - 1] : HR, R2 = ROD * ROD;\n  for (let py = y0; py \u003c= y1; py++)\n    for (let px = x0, p = py * W + x0; px \u003c= x1; px++, p++) {\n      const p3 = p * 3;\n      const dx = g0 * DIR[p3 + s0], dy = g1 * DIR[p3 + s1], dz = g2 * DIR[p3 + 2];\n      let best = DEPTH[p], nx = 0, ny = 0, nz = 0, hit = false;\n      // the ball: the hub, or the end of arm b\n      const ex = b === 1 ? L : 0, ey = b === 2 ? L : 0, ez = b === 3 ? L : 0;\n      let t = ball(ox, oy, oz, dx, dy, dz, ex, ey, ez, w);\n      if (t \u003c best) {\n        best = t; hit = true;\n        nx = (ox + t * dx - ex) / w; ny = (oy + t * dy - ey) / w; nz = (oz + t * dz - ez) / w;\n      }\n      if (b) {\n        // the rod round the arm's axis, from the hub to the ball\n        const up = b === 1 ? oy : ox, uq = b === 3 ? oy : oz, ua = b === 1 ? ox : b === 2 ? oy : oz;\n        const dp = b === 1 ? dy : dx, dq = b === 3 ? dy : dz, da = b === 1 ? dx : b === 2 ? dy : dz;\n        const A = dp * dp + dq * dq, B = up * dp + uq * dq, D = B * B - A * (up * up + uq * uq - R2);\n        if (D > 0) {\n          t = (-B - sqrt(D)) / A;\n          const s = ua + t * da;\n          if (t > 1e-4 && t \u003c best && s > 0 && s \u003c L) {\n            best = t; hit = true;\n            const np = (up + t * dp) / ROD, nq = (uq + t * dq) / ROD;\n            if (b === 1) { nx = 0; ny = np; nz = nq; } else if (b === 2) { nx = np; ny = 0; nz = nq; } else { nx = np; ny = nq; nz = 0; }\n          }\n        }\n      }\n      if (hit) {\n        DEPTH[p] = best; PART[p] = b;\n        LAM[p] = max(0, -(nx * dx + ny * dy + nz * dz));\n      }\n    }\n}\n\n// ---- The cube edges, faint lines of the lattice the copies sit in, as in\n// Weeks's Curved Spaces. Each edge line within 5.5 of the camera is clipped\n// at the camera plane and stepped one LED at a time on the screen, with the\n// distance found by perspective-correct interpolation, so a jack in front\n// hides it.\nconst EDGE = new Float32Array(N);\nfunction edge(S, ax, ay, az, bx, by, bz) {\n  const { cam, fw, rt, up } = S;\n  let X = ax - cam[0], Y = ay - cam[1], Z = az - cam[2];\n  let u0 = X * rt[0] + Y * rt[1] + Z * rt[2], v0 = X * up[0] + Y * up[1] + Z * up[2], z0 = X * fw[0] + Y * fw[1] + Z * fw[2];\n  X = bx - cam[0]; Y = by - cam[1]; Z = bz - cam[2];\n  let u1 = X * rt[0] + Y * rt[1] + Z * rt[2], v1 = X * up[0] + Y * up[1] + Z * up[2], z1 = X * fw[0] + Y * fw[1] + Z * fw[2];\n  if (z0 \u003c NEAR && z1 \u003c NEAR) return;\n  if (z0 \u003c NEAR) { const f = (NEAR - z0) / (z1 - z0); u0 += f * (u1 - u0); v0 += f * (v1 - v0); z0 = NEAR; }\n  else if (z1 \u003c NEAR) { const f = (NEAR - z1) / (z0 - z1); u1 += f * (u0 - u1); v1 += f * (v0 - v1); z1 = NEAR; }\n  const x0 = W / 2 + (F * u0) / z0, y0 = H / 2 - (F * v0) / z0, x1 = W / 2 + (F * u1) / z1, y1 = H / 2 - (F * v1) / z1;\n  if ((x0 \u003c 0 && x1 \u003c 0) || (x0 >= W && x1 >= W) || (y0 \u003c 0 && y1 \u003c 0) || (y0 >= H && y1 >= H)) return;\n  // walk only the part of the screen segment that lies on the panel\n  let s0 = 0, s1 = 1;\n  const dx = x1 - x0, dy = y1 - y0;\n  if (dx) { const a = (0 - x0) / dx, b = (W - x0) / dx; s0 = max(s0, min(a, b)); s1 = min(s1, max(a, b)); }\n  if (dy) { const a = (0 - y0) / dy, b = (H - y0) / dy; s0 = max(s0, min(a, b)); s1 = min(s1, max(a, b)); }\n  if (s0 >= s1) return;\n  const n = Math.ceil((s1 - s0) * sqrt(dx * dx + dy * dy) * 1.3) + 1;\n  for (let i = 0; i \u003c= n; i++) {\n    const sg = s0 + ((s1 - s0) * i) / n, px = floor(x0 + sg * dx), py = floor(y0 + sg * dy);\n    if (px \u003c 0 || py \u003c 0 || px >= W || py >= H) continue;\n    const w = (1 - sg) / z0 + sg / z1, lam = sg / z1 / w;\n    const uu = u0 + lam * (u1 - u0), vv = v0 + lam * (v1 - v0), zz = 1 / w;\n    const dist = sqrt(uu * uu + vv * vv + zz * zz), p = py * W + px;\n    if (dist \u003c DEPTH[p]) { const e = exp(-dist / FOG); if (e > EDGE[p]) EDGE[p] = e; }\n  }\n}\nfunction edges(S) {\n  const cam = S.cam, R = Math.ceil(TMAX);\n  EDGE.fill(0);\n  for (let ax = 0; ax \u003c 3; ax++) {\n    const a1 = (ax + 1) % 3, a2 = (ax + 2) % 3;\n    for (let b = floor(cam[a1]) - R; b \u003c= floor(cam[a1]) + R + 1; b++)\n      for (let c = floor(cam[a2]) - R; c \u003c= floor(cam[a2]) + R + 1; c++) {\n        const db = b - cam[a1], dc = c - cam[a2], d2 = db * db + dc * dc;\n        if (d2 >= TMAX * TMAX) continue;\n        const L = sqrt(TMAX * TMAX - d2), A = [0, 0, 0], B = [0, 0, 0];\n        A[ax] = cam[ax] - L; B[ax] = cam[ax] + L; A[a1] = B[a1] = b; A[a2] = B[a2] = c;\n        edge(S, A[0], A[1], A[2], B[0], B[1], B[2]);\n      }\n  }\n}\n\nexport function setup(params) {\n  params.s = { t: 0, s: 0, hue: 0, m: 0, head: 0.06, cam: [0.1, 0.1, 0.1], fw: [0, 0, 1], rt: [1, 0, 0], up: [0, 1, 0], col: new Float32Array(12) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  const speed = cl(kv[1], 0.2, 3);\n  S.m = cl(Math.round(kv[2]), 0, 3);\n  S.head = cl(kv[3], 0, 1);\n  S.t += d * speed / 2;\n  S.s += d * speed * 0.22;\n  // Flight in the plane y = 0.03, heading th off the z axis, looking 12.6\n  // degrees right of the flight and 9 up, the gaze swaying 9 degrees left\n  // and right and 6 up and down.\n  const th = S.head * PI / 2;\n  const cam = S.cam;\n  cam[0] = 0.04 + 0.03 * sin(S.t * 0.7) + S.s * sin(th);\n  cam[1] = 0.03 + 0.025 * sin(S.t * 0.53);\n  cam[2] = 0.1 + S.s * cos(th);\n  const yaw = th + 0.22 + 0.16 * sin(S.t * 0.41), pitch = 0.16 + 0.1 * sin(S.t * 0.29);\n  const fw = S.fw, rt = S.rt, up = S.up;\n  fw[0] = sin(yaw) * cos(pitch); fw[1] = sin(pitch); fw[2] = cos(yaw) * cos(pitch);\n  rt[0] = cos(yaw); rt[1] = 0; rt[2] = -sin(yaw);\n  up[0] = fw[1] * rt[2] - fw[2] * rt[1];\n  up[1] = fw[2] * rt[0] - fw[0] * rt[2];\n  up[2] = fw[0] * rt[1] - fw[1] * rt[0];\n  // hub white, then the x, y and z arms\n  const col = S.col;\n  col[0] = 0.95; col[1] = 0.93; col[2] = 0.88;\n  hsv(S.hue + 0.56, 0.8, 1, col, 3);\n  hsv(S.hue + 0.9, 0.7, 1, col, 6);\n  hsv(S.hue + 0.3, 0.85, 1, col, 9);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cam, fw, rt, up, col, m } = S;\n  for (let py = 0, p = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++, p++) {\n      const sx = (px + 0.5 - W / 2) / F, sy = (H / 2 - py - 0.5) / F;\n      const dx = fw[0] + rt[0] * sx + up[0] * sy, dy = fw[1] + rt[1] * sx + up[1] * sy, dz = fw[2] + rt[2] * sx + up[2] * sy;\n      const l = 1 / sqrt(dx * dx + dy * dy + dz * dz);\n      DIR[p * 3] = dx * l; DIR[p * 3 + 1] = dy * l; DIR[p * 3 + 2] = dz * l;\n    }\n  DEPTH.fill(TMAX);\n  const ci = floor(cam[0]), cj = floor(cam[1]), ck = floor(cam[2]), R = Math.ceil(TMAX) + 1, RR = (TMAX + 0.87) * (TMAX + 0.87);\n  for (let a = -R; a \u003c= R; a++)\n    for (let b = -R; b \u003c= R; b++)\n      for (let c = -R; c \u003c= R; c++) {\n        const i = ci + a, j = cj + b, k = ck + c;\n        const vx = i + 0.5 - cam[0], vy = j + 0.5 - cam[1], vz = k + 0.5 - cam[2];\n        if (vx * vx + vy * vy + vz * vz > RR || vx * fw[0] + vy * fw[1] + vz * fw[2] \u003c -0.87) continue;\n        const cls = deck(m, i, j, k);\n        if (cls \u003c 0) continue;\n        for (let part = 0; part \u003c 4; part++) if (rect(S, part, cls)) raster(S, part, cls);\n      }\n  edges(S);\n  for (let p = 0; p \u003c N; p++) {\n    const e = EDGE[p] * 0.3;\n    let r = e * 0.55, g = e * 0.7, b = e;\n    const t = DEPTH[p];\n    if (t \u003c TMAX) {\n      const lam = LAM[p], fog = exp(-t / FOG);\n      const sh = (0.28 + 0.72 * lam) * fog, spec = lam > 0.9 ? (lam - 0.9) * 4 * fog : 0;\n      const cc = PART[p] * 3;\n      r = col[cc] * sh + spec; g = col[cc + 1] * sh + spec; b = col[cc + 2] * sh + spec;\n    }\n    display.setPixel(p % W, (p / W) | 0, (255 * cl(r, 0, 1)) | 0, (255 * cl(g, 0, 1)) | 0, (255 * cl(b, 0, 1)) | 0);\n  }\n}\n","apollonius-problem":"// ===== Patternflow pattern =====\n// Title:   Problem of Apollonius\n// Family:  geometry\n// Idea:    Three white circles drift over the panel and the up to eight circles that touch all three are drawn round them, each coloured by which of the three it touches from inside and which from outside, with a bright point at every touch; when two white circles cross or one nests in another, the eight merge in pairs and fade to four or none, and come back when they part.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: problem of Apollonius (Apollonius of Perga, c. 200 BC; solved by François Viète, 1600), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pair=0..4, Size=-1..1\n//\n// Knob 1: Hue. Turns the eight colours round the wheel together. Opposite signatures sit opposite on the wheel: at 0 the circle touching all three from outside is gold and the one holding all three is blue.\n// Knob 2: Speed. How fast the white circles drift: at 2 each centre's x and y run on sines of 37 to 71 seconds and each radius breathes on 19 to 31, at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Pair. 0 shows all eight. 1 to 4 light one of the four sign systems: its two circles stay bright with a faint wash inside, the rest dim to a fifth, and a line runs through the two centres and the radical centre of the white circles, the white point every system's line passes through.\n// Knob 4: Size. Scales the white circles by 2 to this power: at -1 they are 2.7 to 7.7 LEDs in radius and all eight are there 91% of the time; at 0.06, where it opens, 5.6 to 16, and 61%; at 1 11 to 31, and 13%, the rest mostly four.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, q, p, p, t, v][i], [t, v, v, q, p, p][i], [p, p, t, v, v, q][i]];\n}\n\n// ---- The three given circles. Radius at Size 0, breathing 18% on period\n// rp; the centre's x swings across the panel's width and its y through its\n// own band, y0 +- ay, each on its own sine and kept a radius from the edge.\n// Periods in seconds at Speed 2.\nconst GIVEN = [\n  { r: 9, y0: 34, ay: 30, px: 47, py: 61, ph: [0.3, 1.9], rp: 23 },\n  { r: 13, y0: 64, ay: 36, px: 59, py: 43, ph: [2.2, 0.4], rp: 31 },\n  { r: 6.5, y0: 94, ay: 30, px: 37, py: 71, ph: [4.1, 3.3], rp: 19 },\n];\n\n// ---- Solving. Circle i is (xi, yi, ri). A circle (x, y, r) touching it\n// satisfies (x - xi)^2 + (y - yi)^2 = (r + si ri)^2, si = +1 outside it and -1\n// on the other side of its rim. Subtracting circle 1's equation from 2's and\n// 3's leaves two equations linear in x, y and r; two of the three unknowns are\n// solved as linear in the third (the one whose 2 by 2 is largest, so three\n// centres in a row do not break it) and put into circle 1's equation, which\n// leaves a quadratic. s1 is held at +1: a root with r \u003c 0 is the circle of\n// radius -r for the opposite signs, so four sign systems give up to eight.\n// The roots come back in order of r, and each system fills two slots.\n// Checked over 30 minutes at Speed 2 and each of Size -1, 0.06, 0.5 and 1:\n// the worst miss of a found circle against the three was 3.7e-9 LEDs, every\n// touch point lay within 4e-11 of both rims, and each system's two centres\n// stood in line with the radical centre to within 2e-12 radians.\n// The count is 8, 4 or 0 and nothing else: 400,000 random triples gave 8 when\n// no two cross or all three do, 4 when one or two pairs cross, 0 when one\n// circle sits inside another and the third outside it. Eight is not always\n// one of each signature: with the centres near a line a system's two roots\n// can both be positive, two circles of one signature and none of its\n// opposite. At the opening Size, of the frames with eight, 40% held all eight\n// signatures.\nfunction solve(C, k, out) {\n  const s = [1, k & 1 ? -1 : 1, k & 2 ? -1 : 1];\n  const K = (i) => C[i][0] * C[i][0] + C[i][1] * C[i][1] - C[i][2] * C[i][2];\n  const M = [1, 2].map((j) => [2 * (C[j][0] - C[0][0]), 2 * (C[j][1] - C[0][1]), 2 * (s[j] * C[j][2] - s[0] * C[0][2]), K(j) - K(0)]);\n  let best = -1, f = 0;\n  for (let g = 0; g \u003c 3; g++) {\n    const p = (g + 1) % 3, q = (g + 2) % 3, d = abs(M[0][p] * M[1][q] - M[1][p] * M[0][q]);\n    if (d > best) (best = d), (f = g);\n  }\n  const p = (f + 1) % 3, q = (f + 2) % 3, det = M[0][p] * M[1][q] - M[1][p] * M[0][q];\n  out.n = 0;\n  if (abs(det) \u003c 1e-9) return;\n  // u = U0 + U1 t, t the free unknown.\n  const U0 = [0, 0, 0], U1 = [0, 0, 0];\n  U1[f] = 1;\n  U0[p] = (M[1][q] * M[0][3] - M[0][q] * M[1][3]) / det;\n  U1[p] = (M[0][q] * M[1][f] - M[1][q] * M[0][f]) / det;\n  U0[q] = (M[0][p] * M[1][3] - M[1][p] * M[0][3]) / det;\n  U1[q] = (M[1][p] * M[0][f] - M[0][p] * M[1][f]) / det;\n  const ex = U0[0] - C[0][0], ey = U0[1] - C[0][1], er = U0[2] + C[0][2];\n  const A = U1[0] * U1[0] + U1[1] * U1[1] - U1[2] * U1[2];\n  const B = 2 * (ex * U1[0] + ey * U1[1] - er * U1[2]);\n  const Cc = ex * ex + ey * ey - er * er;\n  const roots = [];\n  if (abs(A) \u003c 1e-12 * (abs(B) + abs(Cc) + 1e-30)) {\n    if (abs(B) > 1e-30) roots.push(-Cc / B);\n  } else {\n    const disc = B * B - 4 * A * Cc;\n    if (disc \u003c 0) return;\n    const sq = sqrt(disc), qq = -0.5 * (B + (B \u003c 0 ? -sq : sq));\n    roots.push(qq / A);\n    if (qq !== 0) roots.push(Cc / qq);\n  }\n  const sol = roots.map((t) => [U0[0] + U1[0] * t, U0[1] + U1[1] * t, U0[2] + U1[2] * t]).filter((u) => isFinite(u[2]) && abs(u[2]) > 1e-9 && abs(u[2]) \u003c 1e9);\n  sol.sort((a, b) => a[2] - b[2]);\n  for (const u of sol) {\n    const r = u[2], sg = r > 0 ? 1 : -1;\n    // Signature: bit i set when the circle touches circle i from its inner side.\n    let sig = 0;\n    for (let i = 0; i \u003c 3; i++) if (s[i] * sg \u003c 0) sig |= 4 >> i;\n    out.c[out.n++] = { x: u[0], y: u[1], r: abs(r), sig };\n  }\n}\n\n// The worst miss of a found circle against the three it should touch, in\n// LEDs: the distance between centres against r + ri or |r - ri|.\nfunction miss(C, c) {\n  let worst = 0;\n  for (let i = 0; i \u003c 3; i++) {\n    const d = sqrt((c.x - C[i][0]) ** 2 + (c.y - C[i][1]) ** 2);\n    worst = max(worst, min(abs(d - (c.r + C[i][2])), abs(d - abs(c.r - C[i][2]))));\n  }\n  return worst;\n}\n\nexport function setup(params) {\n  params.s = {\n    // The clock starts 7 s in, where all eight stand for the next 17 s.\n    t: 7, hue: 0, pair: 0, size: 0,\n    // Eight slots, two to a sign system: the circle last seen and how lit it is.\n    slot: Array.from({ length: 8 }, () => ({ c: null, on: false, a: 0 })),\n    C: [[0, 0, 1], [0, 0, 1], [0, 0, 1]], rc: null, worst: 0, count: 0,\n    rgb: new Float32Array(W * H * 3), out: { n: 0, c: [null, null] },\n  };\n}\n\nfunction place(S) {\n  const sc = 2 ** S.size;\n  for (let i = 0; i \u003c 3; i++) {\n    const g = GIVEN[i], r = g.r * sc * (1 + 0.18 * sin((2 * PI * S.t) / g.rp + g.ph[0]));\n    const mx = W / 2 - r - 1, lo = max(r + 1, g.y0 - g.ay), hi = max(lo, min(H - 1 - r, g.y0 + g.ay));\n    S.C[i][0] = W / 2 + max(0, mx) * sin((2 * PI * S.t) / g.px + g.ph[0]);\n    S.C[i][1] = (lo + hi) / 2 + ((hi - lo) / 2) * sin((2 * PI * S.t) / g.py + g.ph[1]);\n    S.C[i][2] = r;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.pair = cl(round(k[2]), 0, 4);\n  S.size = cl(k[3], -1, 1);\n  S.t += d * cl(k[1], 0.2, 3) * 0.5;\n  place(S);\n  let count = 0;\n  for (let sys = 0; sys \u003c 4; sys++) {\n    solve(S.C, sys, S.out);\n    for (let j = 0; j \u003c 2; j++) {\n      const sl = S.slot[2 * sys + j];\n      // One root: the second slot is the circle that just became a line.\n      const c = S.out.n === 2 ? S.out.c[j] : S.out.n === 1 && j === 0 ? S.out.c[0] : null;\n      sl.on = !!c;\n      if (c) {\n        sl.c = c;\n        count++;\n        S.worst = max(S.worst, miss(S.C, c));\n      }\n      // Fades: in over 0.4 s, out over 0.7 s, whatever the Speed.\n      sl.a = sl.on ? min(1, sl.a + d / 0.4) : max(0, sl.a - d / 0.7);\n    }\n  }\n  S.count = count;\n  // The radical centre: the point with equal power to all three circles,\n  // where r = 0 on every system's line of centres.\n  const C = S.C, a1 = 2 * (C[1][0] - C[0][0]), b1 = 2 * (C[1][1] - C[0][1]), a2 = 2 * (C[2][0] - C[0][0]), b2 = 2 * (C[2][1] - C[0][1]);\n  const K = (i) => C[i][0] * C[i][0] + C[i][1] * C[i][1] - C[i][2] * C[i][2], dd = a1 * b2 - a2 * b1;\n  S.rc = abs(dd) > 1e-6 ? [((K(1) - K(0)) * b2 - (K(2) - K(0)) * b1) / dd, (a1 * (K(2) - K(0)) - a2 * (K(1) - K(0))) / dd] : null;\n}\n\n// ---- Drawing. Additive light into a float buffer.\nfunction put(rgb, px, py, c, v) {\n  if (px \u003c 0 || px >= W || py \u003c 0 || py >= H || v \u003c= 0) return;\n  const p = 3 * (py * W + px);\n  rgb[p] += c[0] * v, rgb[p + 1] += c[1] * v, rgb[p + 2] += c[2] * v;\n}\n\n// An anti-aliased ring 1 LED wide, clipped to the panel. Rows the circle\n// does not reach are skipped, and in each row only the columns near the two\n// crossings are visited.\nfunction ring(rgb, cx, cy, r, c, v) {\n  const y0 = max(0, floor(cy - r - 1)), y1 = min(H - 1, floor(cy + r + 1));\n  for (let py = y0; py \u003c= y1; py++) {\n    const dy = py + 0.5 - cy, ro = r + 1, ri = r - 1;\n    const xo = ro * ro - dy * dy;\n    if (xo \u003c 0) continue;\n    const wo = sqrt(xo), wi = ri > 0 && ri * ri - dy * dy > 0 ? sqrt(ri * ri - dy * dy) : 0;\n    for (const sgn of [-1, 1]) {\n      const a = sgn \u003c 0 ? cx - wo : cx + wi, b = sgn \u003c 0 ? cx - wi : cx + wo;\n      const xa = max(0, floor(a)), xb = min(W - 1, floor(b));\n      for (let px = xa; px \u003c= xb; px++) {\n        const dx = px + 0.5 - cx, e = abs(sqrt(dx * dx + dy * dy) - r);\n        if (e \u003c 1) put(rgb, px, py, c, v * (1 - e));\n      }\n    }\n  }\n}\n\nfunction dot(rgb, x, y, c, v, rad) {\n  for (let py = floor(y - rad - 1); py \u003c= floor(y + rad + 1); py++)\n    for (let px = floor(x - rad - 1); px \u003c= floor(x + rad + 1); px++) {\n      const e = sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2);\n      if (e \u003c rad + 0.5) put(rgb, px, py, c, v * min(1, rad + 0.5 - e));\n    }\n}\n\nfunction disc(rgb, cx, cy, r, c, v) {\n  const y0 = max(0, floor(cy - r)), y1 = min(H - 1, floor(cy + r));\n  for (let py = y0; py \u003c= y1; py++) {\n    const dy = py + 0.5 - cy, w = r * r - dy * dy;\n    if (w \u003c= 0) continue;\n    const hw = sqrt(w), xa = max(0, floor(cx - hw + 0.5)), xb = min(W - 1, floor(cx + hw - 0.5));\n    for (let px = xa; px \u003c= xb; px++) put(rgb, px, py, c, v);\n  }\n}\n\nfunction line(rgb, x0, y0, x1, y1, c, v) {\n  const n = max(abs(x1 - x0), abs(y1 - y0)) | 0;\n  for (let i = 0; i \u003c= n; i++) {\n    const u = n ? i / n : 0;\n    put(rgb, floor(x0 + (x1 - x0) * u), floor(y0 + (y1 - y0) * u), c, v);\n  }\n}\n\n// Hue of a signature: the pair from one quadratic, sig and 7 - sig, opposite.\nconst SIGHUE = [0, 1, 2, 3, 7, 6, 5, 4];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.C) return;\n  const rgb = S.rgb, C = S.C;\n  rgb.fill(0);\n  const white = [1, 1, 1];\n\n  // A highlighted system: its line of centres, from edge to edge.\n  if (S.pair && S.rc) {\n    const a = S.slot[2 * (S.pair - 1)], b = S.slot[2 * (S.pair - 1) + 1], ends = [a, b].filter((q) => q.a > 0 && q.c);\n    const far = ends.length ? ends.reduce((u, q) => (abs(q.c.x - S.rc[0]) + abs(q.c.y - S.rc[1]) > abs(u.c.x - S.rc[0]) + abs(u.c.y - S.rc[1]) ? q : u)) : null;\n    if (far) {\n      let ux = far.c.x - S.rc[0], uy = far.c.y - S.rc[1];\n      const L = sqrt(ux * ux + uy * uy);\n      if (L > 1e-6) {\n        (ux /= L), (uy /= L);\n        line(rgb, S.rc[0] - ux * 300, S.rc[1] - uy * 300, S.rc[0] + ux * 300, S.rc[1] + uy * 300, white, 0.16);\n      }\n    }\n  }\n\n  // The solutions, then the given circles over them, then the touches.\n  const touch = [];\n  for (let q = 0; q \u003c 8; q++) {\n    const sl = S.slot[q];\n    if (sl.a \u003c= 0 || !sl.c) continue;\n    const c = sl.c, col = hsv(0.13 + S.hue + SIGHUE[c.sig] / 8, 0.78, 1);\n    const lit = S.pair && floor(q / 2) !== S.pair - 1 ? 0.2 : 1;\n    ring(rgb, c.x, c.y, c.r, col, 0.95 * sl.a * lit);\n    if (S.pair && lit === 1) {\n      // The lit pair: a faint wash inside each, and its centre.\n      disc(rgb, c.x, c.y, c.r, col, 0.11 * sl.a);\n      dot(rgb, c.x, c.y, col, 0.9 * sl.a, 0.7);\n    }\n    for (let i = 0; i \u003c 3; i++) {\n      const dx = C[i][0] - c.x, dy = C[i][1] - c.y, dd = sqrt(dx * dx + dy * dy);\n      if (dd \u003c 1e-9) continue;\n      // From the centre toward circle i, unless circle i holds this one.\n      const out = C[i][2] > c.r && dd \u003c C[i][2] ? -1 : 1;\n      touch.push([c.x + (out * c.r * dx) / dd, c.y + (out * c.r * dy) / dd, col, sl.a * lit]);\n    }\n  }\n  for (let i = 0; i \u003c 3; i++) ring(rgb, C[i][0], C[i][1], C[i][2], white, 0.62);\n  for (const [x, y, col, a] of touch) {\n    dot(rgb, x, y, col, 0.9 * a, 1.1);\n    dot(rgb, x, y, white, 0.8 * a, 0.45);\n  }\n  if (S.rc && S.pair) dot(rgb, S.rc[0], S.rc[1], white, 0.9, 0.8);\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[3 * p], g = rgb[3 * p + 1], b = rgb[3 * p + 2];\n    if (r + g + b > 0.004) display.setPixel(p % W, (p / W) | 0, min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n","sator-square":"// ===== Patternflow pattern =====\n// Title:   Sator Square\n// Family:  type\n// Idea:    The 25 letters of the word square found at Pompeii, cut in a stone tablet, are read by four lights at once (across, down, backwards and up, always standing on the same letter), then fly by the shortest matching to their places in Felix Grosser's Paternoster cross, which stands the full height of the panel with A and O at the four ends, hold while two lights read PATERNOSTER down and across to meet at the N, and fly home.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sator square (Pompeii, before AD 79; Dura-Europos), Paternoster cross (Felix Grosser, 1926), the assignment problem (Harold Kuhn, 1955), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Assign=0..2, Weather=0..1\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the letters glow gold and the four letters of the cross's ends, A and O, glow pale azure on grey stone.\n// Knob 2: Speed. One round of reading, flight, cross and flight home takes 14 s at 2, 9.3 s at 3 and 140 s at 0.2.\n// Knob 3: Assign. Which letter flies to which place of its kind. 0 is the matching with the least total travel, 537.6 LEDs for the 25 flights; 1 sends the k-th A of the square, read across, to the k-th A of the cross, read down and then across, 864.9 LEDs; 2 is the matching with the most travel, 1083.3 LEDs, so the flights cross over each other.\n// Knob 4: Weather. How long the tablet has stood out: at 0.06 the cuts are fresh; towards 1 the groove edges crumble and the stone pits and greys with lichen, and every letter keeps its own worn patches all through its flight.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, round, min, max, exp, sqrt, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters. Only eight are needed: S A T O R E P N. Three cuts of each:\n// 9 by 9 with 2 LED strokes for the tablet, 5 by 7 for the cross's upright,\n// 3 by 5 for its arm. The upright and the arm both need the same N, which\n// sits at the crossing in the 5 by 7 cut, so the 3 by 5 set has no N.\nconst BIG = {\n  S: [\".#######.\", \"##.....##\", \"##.......\", \"##.......\", \".#######.\", \".......##\", \".......##\", \"##.....##\", \".#######.\"],\n  A: [\"...###...\", \"..##.##..\", \"..##.##..\", \".##...##.\", \".##...##.\", \".#######.\", \"##.....##\", \"##.....##\", \"##.....##\"],\n  T: [\"#########\", \"#########\", \"...###...\", \"...###...\", \"...###...\", \"...###...\", \"...###...\", \"...###...\", \"...###...\"],\n  O: [\"..#####..\", \".##...##.\", \"##.....##\", \"##.....##\", \"##.....##\", \"##.....##\", \"##.....##\", \".##...##.\", \"..#####..\"],\n  R: [\"#######..\", \"##....##.\", \"##.....##\", \"##....##.\", \"#######..\", \"##..##...\", \"##...##..\", \"##....##.\", \"##.....##\"],\n  E: [\"#########\", \"##.......\", \"##.......\", \"##.......\", \"#######..\", \"##.......\", \"##.......\", \"##.......\", \"#########\"],\n  P: [\"#######..\", \"##....##.\", \"##.....##\", \"##....##.\", \"#######..\", \"##.......\", \"##.......\", \"##.......\", \"##.......\"],\n  N: [\"##.....##\", \"###....##\", \"####...##\", \"##.##..##\", \"##..##.##\", \"##...####\", \"##....###\", \"##.....##\", \"##.....##\"],\n};\nconst MID = {\n  A: [\".###.\", \"#...#\", \"#...#\", \"#####\", \"#...#\", \"#...#\", \"#...#\"],\n  P: [\"####.\", \"#...#\", \"#...#\", \"####.\", \"#....\", \"#....\", \"#....\"],\n  T: [\"#####\", \"..#..\", \"..#..\", \"..#..\", \"..#..\", \"..#..\", \"..#..\"],\n  E: [\"#####\", \"#....\", \"#....\", \"####.\", \"#....\", \"#....\", \"#####\"],\n  R: [\"####.\", \"#...#\", \"#...#\", \"####.\", \"#.#..\", \"#..#.\", \"#...#\"],\n  N: [\"#...#\", \"##..#\", \"#.#.#\", \"#..##\", \"#...#\", \"#...#\", \"#...#\"],\n  O: [\".###.\", \"#...#\", \"#...#\", \"#...#\", \"#...#\", \"#...#\", \".###.\"],\n  S: [\".####\", \"#....\", \"#....\", \".###.\", \"....#\", \"....#\", \"####.\"],\n};\nconst SMALL = {\n  A: [\".#.\", \"#.#\", \"###\", \"#.#\", \"#.#\"],\n  P: [\"##.\", \"#.#\", \"##.\", \"#..\", \"#..\"],\n  T: [\"###\", \".#.\", \".#.\", \".#.\", \".#.\"],\n  E: [\"###\", \"#..\", \"##.\", \"#..\", \"###\"],\n  R: [\"##.\", \"#.#\", \"##.\", \"#.#\", \"#.#\"],\n  O: [\".#.\", \"#.#\", \"#.#\", \"#.#\", \".#.\"],\n  S: [\".##\", \"#..\", \".#.\", \"..#\", \"##.\"],\n};\nconst bits = (set) => {\n  const o = {};\n  for (const k in set) o[k] = Uint8Array.from(set[k].join(\"\"), (c) => (c === \"#\" ? 1 : 0));\n  return o;\n};\nconst BIGB = bits(BIG), MIDB = bits(MID), SMALLB = bits(SMALL);\n\n// ---- The tablet. Rows SATOR AREPO TENET OPERA ROTAS read the same across\n// and down, and the same backwards: the square is left as it is by the half\n// turn and by reflection in either diagonal. Letters 9 by 9 on a 12 LED\n// pitch round (32.5, 64.5), on a slab 61 by 63 from (2, 33).\nconst SQUARE = [\"SATOR\", \"AREPO\", \"TENET\", \"OPERA\", \"ROTAS\"];\nconst SQ = [];\nfor (let r = 0; r \u003c 5; r++) for (let c = 0; c \u003c 5; c++) SQ.push({ ch: SQUARE[r][c], x: 32.5 + (c - 2) * 12, y: 64.5 + (r - 2) * 12 });\nconst SX0 = 2, SX1 = 63, SY0 = 33, SY1 = 96;\n\n// The four readings as paths over the 25 cells: across (rows left to\n// right), down (columns top to bottom), backwards (from the last letter) and\n// up (columns from the bottom right). Whatever step k the four lights are\n// on, they stand on the same letter; at k = 12 they meet on the N. A cell is\n// first lit at the least of its four indices, so every cell is lit by k = 12.\nconst PATHS = [(k) => k, (k) => (k % 5) * 5 + floor(k / 5), (k) => 24 - k, (k) => 24 - ((k % 5) * 5 + floor(k / 5))];\nconst FIRST = new Float32Array(25).fill(99);\nfor (const f of PATHS) for (let k = 0; k \u003c 25; k++) FIRST[f(k)] = min(FIRST[f(k)], k);\n\n// ---- Grosser's cross. A-PATERNOSTER-O down the middle, 13 letters 5 by 7\n// on rows 128/13 apart, so it stands the whole height; the same 13 across\n// row 64 in the 3 by 5 cut on a 5 LED pitch, sharing the N. 21 letters make\n// PATERNOSTER twice; the A and O left over (alpha and omega) end the arms.\nconst CROSS = \"APATERNOSTERO\";\nconst SLOT = [];\nfor (let j = 0; j \u003c 13; j++) SLOT.push({ ch: CROSS[j], x: 32.5, y: floor(((j + 0.5) * H) / 13) + 0.5, w: 5, h: 7, bm: MIDB, k: j, ao: j === 0 || j === 12 });\nfor (let i = 0; i \u003c 13; i++)\n  if (i !== 6) SLOT.push({ ch: CROSS[i], x: i \u003c 6 ? 27.5 - 5 * (5 - i) : 37.5 + 5 * (i - 7), y: 64.5, w: 3, h: 5, bm: SMALLB, k: i, ao: i === 0 || i === 12 });\n\n// The count, checked here so the cross can never be built from letters the\n// square does not have: square S2 A4 T4 O4 R4 E4 P2 N1; PATERNOSTER twice\n// with one N is P2 A2 T4 E4 R4 N1 O2 S2, 21 letters, and A2 O2 are left.\n{\n  const n = {};\n  for (const q of SQ) n[q.ch] = (n[q.ch] || 0) + 1;\n  for (const s of SLOT) n[s.ch]--;\n  for (const k in n) if (n[k] !== 0) throw new Error(\"Sator count is off at \" + k);\n}\n\n// ---- Which letter goes to which place of its kind. Up to four of a kind,\n// so every permutation is tried (24 at most). Totals of the 25 straight\n// distances, centre to centre: least 537.6 LEDs, reading order 864.9, most\n// 1083.3.\nfunction perms(n) {\n  if (n === 1) return [[0]];\n  const out = [];\n  for (const p of perms(n - 1)) for (let i = 0; i \u003c n; i++) out.push([...p.slice(0, i), n - 1, ...p.slice(i)]);\n  return out;\n}\nconst dist = (q, s) => sqrt((SQ[q].x - SLOT[s].x) ** 2 + (SQ[q].y - SLOT[s].y) ** 2);\nconst ASSIGN = [0, 1, 2].map((mode) => {\n  const a = new Int8Array(25);\n  for (const ch of \"SATORENP\") {\n    const from = [], to = [];\n    SQ.forEach((q, i) => q.ch === ch && from.push(i));\n    SLOT.forEach((s, i) => s.ch === ch && to.push(i));\n    if (mode === 1) {\n      from.forEach((q, i) => (a[q] = to[i]));\n      continue;\n    }\n    let best = null, bv = mode === 0 ? 1e9 : -1;\n    for (const p of perms(from.length)) {\n      let v = 0;\n      p.forEach((j, i) => (v += dist(from[i], to[j])));\n      if (mode === 0 ? v \u003c bv : v > bv) (bv = v), (best = p);\n    }\n    best.forEach((j, i) => (a[from[i]] = to[j]));\n  }\n  return a;\n});\n\n// ---- Time, in seconds at Speed 2. The tablet 5 s (lights read from 0.6 s,\n// 6.25 letters a second), out 2 s, the cross 5 s (read from 0.5 s, 5.2\n// letters a second), home 2 s. Each flight takes 1 s and starts 0.04 s after\n// the one before it in reading order. A fresh start comes in 3.4 s into the\n// tablet, at reading step 17.5, so the cross is up within 2.2 s.\nconst T_SQ = 5, T_OUT = 2, T_CR = 5, T_BACK = 2, CYCLE = T_SQ + T_OUT + T_CR + T_BACK;\nconst READ0 = 0.6, READ_RATE = 6.25, CREAD0 = 0.5, CREAD_RATE = 5.2, FLY = 1, STAG = 0.04, START = 3.4;\n\n// ---- Stone: grain, pits and lichen, fixed for the tablet.\nfunction hash(x, y, s) {\n  let h = (x * 374761393 + y * 668265263 + s * 2147483647) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nfunction vnoise(x, y, sc, s) {\n  const fx = x / sc, fy = y / sc, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  const sx = ax * ax * (3 - 2 * ax), sy = ay * ay * (3 - 2 * ay);\n  const a = hash(ix, iy, s), b = hash(ix + 1, iy, s), c = hash(ix, iy + 1, s), d = hash(ix + 1, iy + 1, s);\n  return (a + (b - a) * sx) * (1 - sy) + (c + (d - c) * sx) * sy;\n}\nconst GRAIN = new Float32Array(NP), PIT = new Float32Array(NP), LICH = new Float32Array(NP), CHIP = new Float32Array(NP);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x;\n    GRAIN[p] = 0.55 * hash(x, y, 1) + 0.45 * vnoise(x, y, 5, 2) - 0.5;\n    PIT[p] = hash(x, y, 3);\n    LICH[p] = 0.65 * vnoise(x, y, 7, 4) + 0.35 * vnoise(x, y, 2.5, 5);\n    CHIP[p] = hash(x, y, 6);\n  }\n// Carved grooves of the 25 cells, lit from the upper left: the wall under\n// an upper or left edge faces away from the light, the wall above a lower\n// or right edge faces it. 0 stone, 1 shadow wall, 2 lit wall, 3 floor.\nconst CUT = new Uint8Array(NP), NEAR = new Uint8Array(NP);\nfor (const q of SQ) {\n  const bm = BIGB[q.ch], x0 = round(q.x - 4.5), y0 = round(q.y - 4.5);\n  const m = (i, j) => (i \u003c 0 || j \u003c 0 || i > 8 || j > 8 ? 0 : bm[j * 9 + i]);\n  for (let j = 0; j \u003c 9; j++)\n    for (let i = 0; i \u003c 9; i++) {\n      const p = (y0 + j) * W + x0 + i;\n      if (!m(i, j)) {\n        if (m(i - 1, j) || m(i, j - 1) || m(i + 1, j) || m(i, j + 1)) NEAR[p] = 1;\n        continue;\n      }\n      const ul = !m(i - 1, j) || !m(i, j - 1) || !m(i - 1, j - 1), lr = !m(i + 1, j) || !m(i, j + 1) || !m(i + 1, j + 1);\n      CUT[p] = ul && !lr ? 1 : lr && !ul ? 2 : 3;\n    }\n}\n\nexport function setup(params) {\n  params.s = {\n    tau: START, hue: 0, speed: 2, mode: 0, wx: 0.06, dt: 0,\n    lr: new Float32Array(NP), lg: new Float32Array(NP), lb: new Float32Array(NP),\n    tr: new Float32Array(NP), tg: new Float32Array(NP), tb: new Float32Array(NP), tmp: new Float32Array(NP),\n    rgb: new Float32Array(NP * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.mode = cl(round(k[2]), 0, 2);\n  S.wx = cl(k[3], 0, 1);\n  S.tau += (d * S.speed) / 2;\n  S.dt = d;\n}\n\n// Bilinear sample of a bitmap at bitmap coordinates.\nfunction samp(bm, bw, bh, fx, fy) {\n  const ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  let v = 0;\n  if (iy >= 0 && iy \u003c bh) {\n    if (ix >= 0 && ix \u003c bw) v += bm[iy * bw + ix] * (1 - ax) * (1 - ay);\n    if (ix + 1 >= 0 && ix + 1 \u003c bw) v += bm[iy * bw + ix + 1] * ax * (1 - ay);\n  }\n  if (iy + 1 >= 0 && iy + 1 \u003c bh) {\n    if (ix >= 0 && ix \u003c bw) v += bm[(iy + 1) * bw + ix] * (1 - ax) * ay;\n    if (ix + 1 >= 0 && ix + 1 \u003c bw) v += bm[(iy + 1) * bw + ix + 1] * ax * ay;\n  }\n  return v;\n}\n\n// One letter of light into the light buffer: the tablet cut, scaled to w by\n// h, fading into the cross cut by mix, worn by letter q's own patches.\nfunction letter(S, q, a, b, bw, bh, mix, cx, cy, w, h, col, inten, home) {\n  const x0 = max(0, floor(cx - w / 2)), x1 = min(W - 1, ceil(cx + w / 2) - 1);\n  const y0 = max(0, floor(cy - h / 2)), y1 = min(H - 1, ceil(cy + h / 2) - 1);\n  const wx = S.wx, sub = w \u003c 8.5 ? 2 : 1;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      let va = 0, vb = 0;\n      for (let sy = 0; sy \u003c sub; sy++)\n        for (let sx = 0; sx \u003c sub; sx++) {\n          const u = (x + (sx + 0.5) / sub - (cx - w / 2)) / w, v = (y + (sy + 0.5) / sub - (cy - h / 2)) / h;\n          if (mix \u003c 1) va += samp(a, 9, 9, u * 9 - 0.5, v * 9 - 0.5);\n          if (mix > 0) vb += samp(b, bw, bh, u * bw - 0.5, v * bh - 0.5);\n        }\n      let val = (va * (1 - mix) + vb * mix) / (sub * sub);\n      if (val \u003c 0.02) continue;\n      const u = (x + 0.5 - (cx - w / 2)) / w, v = (y + 0.5 - (cy - h / 2)) / h;\n      const n = vnoise(u * 4 + q * 7.3, v * 4, 1, 40 + q);\n      val *= 1 - 0.8 * wx * ss(0.3, 0.6, n);\n      val *= inten;\n      const p = y * W + x;\n      // At home the light lies in the groove: least on the wall in shadow.\n      if (home) val *= CUT[p] === 1 ? 0.5 : CUT[p] === 2 ? 1 : 0.78;\n      if (col[0] * val > S.lr[p]) S.lr[p] = col[0] * val;\n      if (col[1] * val > S.lg[p]) S.lg[p] = col[1] * val;\n      if (col[2] * val > S.lb[p]) S.lb[p] = col[2] * val;\n    }\n}\n\nfunction blur(src, tmp, out) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (6 * src[p] + 4 * ((x > 0 ? src[p - 1] : 0) + (x \u003c W - 1 ? src[p + 1] : 0)) + (x > 1 ? src[p - 2] : 0) + (x \u003c W - 2 ? src[p + 2] : 0)) / 16;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      out[p] = (6 * tmp[p] + 4 * ((y > 0 ? tmp[p - W] : 0) + (y \u003c H - 1 ? tmp[p + W] : 0)) + (y > 1 ? tmp[p - 2 * W] : 0) + (y \u003c H - 2 ? tmp[p + 2 * W] : 0)) / 16;\n    }\n}\n\nfunction spot(rgb, x, y, rad, a, col) {\n  const r = ceil(rad * 2.2);\n  for (let j = max(0, floor(y - r)); j \u003c= min(H - 1, ceil(y + r)); j++)\n    for (let i = max(0, floor(x - r)); i \u003c= min(W - 1, ceil(x + r)); i++) {\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, v = a * exp(-(dx * dx + dy * dy) / (rad * rad));\n      const p = (j * W + i) * 3;\n      rgb[p] += col[0] * v, rgb[p + 1] += col[1] * v, rgb[p + 2] += col[2] * v;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, lr, lg, lb } = S, wx = S.wx, assign = ASSIGN[S.mode];\n  const tc = ((S.tau % CYCLE) + CYCLE) % CYCLE;\n  const gold = hsv(0.115 + S.hue, 0.6, 1), azure = hsv(0.55 + S.hue, 0.42, 1), warm = hsv(0.1 + S.hue, 0.25, 1);\n\n  // Where each letter is: p is its flight, 0 at home in the tablet, 1 in\n  // the cross.\n  const fly = new Float32Array(25);\n  let gone = 0;\n  for (let q = 0; q \u003c 25; q++) {\n    let p = 0;\n    if (tc >= T_SQ && tc \u003c T_SQ + T_OUT) p = ss(0, 1, (tc - T_SQ - STAG * q) / FLY);\n    else if (tc >= T_SQ + T_OUT && tc \u003c T_SQ + T_OUT + T_CR) p = 1;\n    else if (tc >= T_SQ + T_OUT + T_CR) p = 1 - ss(0, 1, (tc - T_SQ - T_OUT - T_CR - STAG * q) / FLY);\n    fly[q] = p;\n    gone += p / 25;\n  }\n\n  // ---- Stone, dimmed to 38% while the letters' light is away.\n  const dim = 1 - 0.62 * gone;\n  rgb.fill(0);\n  const stone = [0.82, 0.86, 0.93], moss = [0.72, 0.8, 0.55];\n  for (let y = SY0; y \u003c SY1; y++)\n    for (let x = SX0; x \u003c SX1; x++) {\n      const p = y * W + x;\n      let v = 62 * (1 + 0.32 * GRAIN[p]);\n      if (y === SY0 || x === SX0) v *= 1.45;\n      else if (y === SY1 - 1 || x === SX1 - 1) v *= 0.55;\n      const c = CUT[p];\n      if (c) {\n        const chip = CHIP[p] \u003c 0.45 * wx;\n        v *= chip ? 0.6 : c === 1 ? 0.3 : c === 2 ? 1.9 : 0.55;\n      } else if (NEAR[p] && CHIP[p] \u003c 0.4 * wx) v *= 0.45;\n      if (PIT[p] \u003c 0.1 * wx) v *= 0.35;\n      const l = ss(1 - 0.55 * wx, 1.05 - 0.55 * wx, LICH[p]) * min(1, wx * 2);\n      v *= dim;\n      const o = p * 3;\n      rgb[o] = v * (stone[0] + (moss[0] - stone[0]) * l);\n      rgb[o + 1] = v * (stone[1] + (moss[1] - stone[1]) * l);\n      rgb[o + 2] = v * (stone[2] + (moss[2] - stone[2]) * l);\n    }\n\n  // ---- The cross's own faint body of light, there as far as its letters\n  // have arrived: a band 8 LEDs wide down the middle and one across row 64.\n  const body = gone * gone * 34;\n  if (body > 0.5)\n    for (let y = 0; y \u003c H; y++) {\n      const by = exp(-(((y + 0.5 - 64.5) / 2.6) ** 2)), sh = 0.86 + 0.14 * sin(y * 0.35 - tc * 5);\n      for (let x = 0; x \u003c W; x++) {\n        const v = body * max(exp(-(((x + 0.5 - 32.5) / 4) ** 2)) * sh, by);\n        if (v \u003c 0.5) continue;\n        const o = (y * W + x) * 3;\n        rgb[o] += gold[0] * v, rgb[o + 1] += gold[1] * v, rgb[o + 2] += gold[2] * v;\n      }\n    }\n\n  // ---- Light. Trails fade in about 0.07 s.\n  const decay = exp(-S.dt / 0.07);\n  for (let p = 0; p \u003c NP; p++) (lr[p] *= decay), (lg[p] *= decay), (lb[p] *= decay);\n\n  const inSq = tc \u003c T_SQ, inCr = tc >= T_SQ + T_OUT && tc \u003c T_SQ + T_OUT + T_CR;\n  const step = (tc - READ0) * READ_RATE;\n  const cstep = (tc - T_SQ - T_OUT - CREAD0) * CREAD_RATE;\n  for (let q = 0; q \u003c 25; q++) {\n    const from = SQ[q], to = SLOT[assign[q]], p = fly[q];\n    let glow = 1;\n    if (inSq) glow = max(1 - ss(0, 0.6, tc), ss(FIRST[q], FIRST[q] + 1.2, step));\n    if (p \u003c= 0) {\n      letter(S, q, BIGB[from.ch], null, 9, 9, 0, from.x, from.y, 9, 9, gold, 0.1 + 0.72 * glow, true);\n      continue;\n    }\n    // A quadratic arc, bowed a fifth of its length to the left of the way\n    // out, so the 25 flights turn together.\n    const dx = to.x - from.x, dy = to.y - from.y, cx = (from.x + to.x) / 2 - 0.2 * dy, cy = (from.y + to.y) / 2 + 0.2 * dx;\n    const e = p, f = 1 - e;\n    const px = f * f * from.x + 2 * e * f * cx + e * e * to.x, py = f * f * from.y + 2 * e * f * cy + e * e * to.y;\n    const w = 9 + (to.w - 9) * e, h = 9 + (to.h - 9) * e;\n    const mix = ss(0.35, 0.8, e);\n    const ao = to.ao ? e : 0;\n    const col = [gold[0] + (azure[0] - gold[0]) * ao, gold[1] + (azure[1] - gold[1]) * ao, gold[2] + (azure[2] - gold[2]) * ao];\n    let inten = 0.95;\n    if (inCr) {\n      const fl = exp(-((cstep - to.k) ** 2) / 0.6);\n      inten = 0.78 + 0.4 * fl + (to.ao ? 0.14 * sin(tc * 3.1) : 0);\n    }\n    letter(S, q, BIGB[from.ch], to.bm[to.ch], to.w, to.h, mix, px, py, w, h, col, inten);\n  }\n\n  blur(lr, S.tmp, S.tr), blur(lg, S.tmp, S.tg), blur(lb, S.tmp, S.tb);\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3;\n    rgb[o] += 235 * lr[p] + 150 * S.tr[p];\n    rgb[o + 1] += 235 * lg[p] + 150 * S.tg[p];\n    rgb[o + 2] += 235 * lb[p] + 150 * S.tb[p];\n  }\n\n  // ---- The reading lights: four on the tablet, two on the cross.\n  if (inSq && step > -0.5 && step \u003c 25) {\n    const k = floor(step), fr = step - k;\n    for (const f of PATHS) {\n      const a = SQ[f(cl(k, 0, 24))], b = SQ[f(cl(k + 1, 0, 24))];\n      const sameLine = k >= 0 && k \u003c 24 && (k % 5 !== 4);\n      const m = sameLine ? ss(0.25, 0.75, fr) : 0;\n      const fade = (k \u003c 0 ? ss(-0.5, 0, step) : 1) * (sameLine || k >= 24 ? 1 : 1 - ss(0.55, 0.95, fr)) * (k > 0 && k % 5 === 0 ? ss(0, 0.2, fr) : 1);\n      spot(rgb, a.x + (b.x - a.x) * m, a.y + (b.y - a.y) * m, 4.2, 150 * fade, warm);\n    }\n  }\n  if (inCr && cstep > -0.5 && cstep \u003c 13) {\n    const k = floor(cstep), fr = cstep - k, m = ss(0.2, 0.8, fr);\n    const up = (j) => SLOT[cl(j, 0, 12)], arm = (i) => SLOT[i === 6 ? 6 : i \u003c 6 ? 13 + i : 12 + i];\n    const fade = ss(-0.5, 0, cstep) * (1 - ss(12.4, 13, cstep));\n    const a = up(k), b = up(k + 1);\n    spot(rgb, 32.5, a.y + (b.y - a.y) * m, 3.2, 110 * fade, warm);\n    const c = arm(cl(k, 0, 12)), d = arm(cl(k + 1, 0, 12));\n    spot(rgb, c.x + (d.x - c.x) * m, 64.5, 2.4, 110 * fade, warm);\n  }\n\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","tensegrity":"// ===== Patternflow pattern =====\n// Title:   Tensegrity\n// Family:  physics\n// Idea:    A tower of struts that never touch one another stands the height of the panel, held up by a net of cables in tension and turning slowly, and a weight on its top squeezes it shorter and twists it, because in a tensegrity compression and twist come together.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tensegrity (Kenneth Snelson, 1948; named by R. Buckminster Fuller), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Struts=3..6, Load=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the struts run from aqua at the foot to blue at the top, the cables are a dim pink and the weight is pale stone.\n// Knob 2: Speed. How fast the tower turns and how fast its own time runs: at 2 one turn in 16 seconds, at 0.2 one in 160 seconds with a plucked cable swinging in slow motion, at 3 one in 11 seconds.\n// Knob 3: Struts. Struts per stage, 3 to 6, five stages each time: 15 struts and 93 cables at 3, 30 and 186 at 6. Turning it builds the new tower and settles it before the next frame, which costs up to 7 ms.\n// Knob 4: Load. A weight on a guide up the axis, pressing on the top: 0 to 700 units, 42 at the start, which leaves the tower 1% shorter and its top turned 5.5 degrees. At 1 the 3-strut tower is 17% shorter and its top has turned 74 degrees further round; the 6-strut one 16% and 92.5 degrees.\n// Buttons: K1 tap plucks one of the longer cables on the near side: it swings as a string for two seconds at a pitch set by its tension, and if the tower is still its two ends are kicked so the whole tower shivers.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, atan2, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, q, p, p, t, v][i], [t, v, v, q, p, p][i], [p, p, t, v, v, q][i]];\n}\n\n// ---- The tower. Stage k is a tensegrity prism: n struts from its bottom\n// n-gon to its top n-gon, strut i from bottom node i to top node i + 1, a\n// side cable from bottom node i to top node i, and a ring of cables round\n// each n-gon. The prism alone settles with its top turned pi/2 - pi/n against\n// its bottom along the side cables, so pi/2 + pi/n along the struts. Run on\n// its own with this code's springs from 20 or 70 degrees round, cables 10%\n// short, it came to 30.0000, 45.0000, 54.0000 and 60.0000 degrees for n = 3,\n// 4, 5 and 6 (from 5 degrees too for 3 and 4; 5 and 6 went slack from there).\n// Stages overlap by a quarter of their height: stage k + 1's bottom n-gon\n// sits below stage k's top one, turned pi/n so its nodes fall between, and\n// hangs from it by a zigzag of 2n saddle cables; bottom-to-bottom and\n// top-to-top cables between the two stages pull the other way. Stacked, the\n// stages twist less than a lone prism: 20 to 24 degrees for n = 3, 33 to 38\n// for 4, 41 to 46 for 5, 46 to 52 for 6. No two struts share a node, and the\n// closest two pass 8.4 units apart at n = 3, 3.4 at n = 6 (3.0 under Load 1).\n// Units: the bare tower stands 143 to 150 units tall and is drawn 121 LEDs.\nconst STAGES = 5, HS = 34, OV = 9, R0 = 24, R1 = 17;\nconst ALL = 0.08; // every cable 8% shorter than the span it is built on: the prestress\nconst EA = 1800; // cable stiffness: tension = EA * stretch / rest length\nconst FMAX = 700; // the weight at Load 1, shared out over the top nodes\nconst KICK = 40; // a pluck, units a second sideways at each end of the cable\nconst HSUB = 1 / 120; // physics step while it runs, seconds of the tower's own time\n\nfunction build(n) {\n  const P = [], fix = [], struts = [], cables = [], B = [], T = [], stage = [];\n  const alpha = PI / 2 - PI / n;\n  let phi = 0;\n  for (let k = 0; k \u003c STAGES; k++) {\n    const r = R0 + ((R1 - R0) * k) / (STAGES - 1), zb = k * (HS - OV), zt = zb + HS;\n    B.push([]);\n    T.push([]);\n    for (let i = 0; i \u003c n; i++) {\n      const a = phi + (2 * PI * i) / n;\n      B[k].push(P.length / 3);\n      P.push(r * cos(a), zb, r * sin(a));\n      fix.push(k === 0);\n    }\n    for (let i = 0; i \u003c n; i++) {\n      const a = phi + alpha + (2 * PI * i) / n;\n      T[k].push(P.length / 3);\n      P.push(r * cos(a), zt, r * sin(a));\n      fix.push(false);\n    }\n    for (let i = 0; i \u003c n; i++) {\n      struts.push(B[k][i], T[k][(i + 1) % n]);\n      stage.push(k);\n      cables.push(B[k][i], T[k][i]);\n      cables.push(B[k][i], B[k][(i + 1) % n], T[k][i], T[k][(i + 1) % n]);\n    }\n    phi += alpha + PI / n;\n  }\n  for (let k = 0; k + 1 \u003c STAGES; k++)\n    for (let j = 0; j \u003c n; j++) {\n      cables.push(B[k + 1][j], T[k][j], B[k + 1][j], T[k][(j + 1) % n]);\n      cables.push(B[k + 1][j], B[k][j], T[k][j], T[k + 1][j]);\n    }\n  const N = P.length / 3, x = Float64Array.from(P);\n  const len = (a, b) => sqrt((x[3 * a] - x[3 * b]) ** 2 + (x[3 * a + 1] - x[3 * b + 1]) ** 2 + (x[3 * a + 2] - x[3 * b + 2]) ** 2);\n  const SL = new Float64Array(struts.length / 2), CL = new Float64Array(cables.length / 2);\n  for (let q = 0; q \u003c SL.length; q++) SL[q] = len(struts[2 * q], struts[2 * q + 1]);\n  for (let q = 0; q \u003c CL.length; q++) CL[q] = len(cables[2 * q], cables[2 * q + 1]) * (1 - ALL);\n  return {\n    n, N, x, v: new Float64Array(3 * N), xp: new Float64Array(3 * N), f: new Float64Array(3 * N),\n    fix, struts, cables, SL, CL, ten: new Float64Array(CL.length), top: T[STAGES - 1], stage,\n  };\n}\n\n// One step: cables pull (tension only), the weight presses, velocities damp,\n// then the struts are put back to length, four passes.\nfunction step(m, load, damp, h) {\n  const { x, v, xp, f, cables, CL, ten, struts, SL, fix, N } = m;\n  f.fill(0);\n  const w = load / m.top.length;\n  for (const i of m.top) f[3 * i + 1] -= w;\n  for (let q = 0; q \u003c CL.length; q++) {\n    const a = 3 * cables[2 * q], b = 3 * cables[2 * q + 1];\n    const dx = x[b] - x[a], dy = x[b + 1] - x[a + 1], dz = x[b + 2] - x[a + 2], L = sqrt(dx * dx + dy * dy + dz * dz);\n    const t = L > CL[q] ? (EA * (L - CL[q])) / CL[q] : 0;\n    ten[q] = t;\n    if (!t) continue;\n    const s = t / L;\n    f[a] += dx * s, f[a + 1] += dy * s, f[a + 2] += dz * s;\n    f[b] -= dx * s, f[b + 1] -= dy * s, f[b + 2] -= dz * s;\n  }\n  const keep = 1 - damp * h;\n  for (let i = 0; i \u003c N; i++) {\n    if (fix[i]) continue;\n    for (let d = 3 * i; d \u003c 3 * i + 3; d++) {\n      xp[d] = x[d];\n      v[d] = (v[d] + h * f[d]) * keep;\n      x[d] += h * v[d];\n    }\n  }\n  for (let it = 0; it \u003c 4; it++)\n    for (let q = 0; q \u003c SL.length; q++) {\n      const ia = struts[2 * q], ib = struts[2 * q + 1], a = 3 * ia, b = 3 * ib;\n      const dx = x[b] - x[a], dy = x[b + 1] - x[a + 1], dz = x[b + 2] - x[a + 2], L = sqrt(dx * dx + dy * dy + dz * dz);\n      const wa = fix[ia] ? 0 : 1, wb = fix[ib] ? 0 : 1, e = (L - SL[q]) / L / (wa + wb);\n      x[a] += dx * e * wa, x[a + 1] += dy * e * wa, x[a + 2] += dz * e * wa;\n      x[b] -= dx * e * wb, x[b + 1] -= dy * e * wb, x[b + 2] -= dz * e * wb;\n    }\n  // The weight runs on a guide up the axis, so the top nodes' centre stays on\n  // it. Without the guide the tower bowed sideways and folded under 150 to\n  // 200 units, while only 5 units shorter; with it, 900 left every cable taut.\n  let gx = 0, gz = 0;\n  for (const i of m.top) (gx += x[3 * i] / m.top.length), (gz += x[3 * i + 2] / m.top.length);\n  for (const i of m.top) (x[3 * i] -= gx), (x[3 * i + 2] -= gz);\n  for (let i = 0; i \u003c N; i++) if (!fix[i]) for (let d = 3 * i; d \u003c 3 * i + 3; d++) v[d] = (x[d] - xp[d]) / h;\n}\n\n// Settling before the first frame: 1/30 s steps, damped near critical for\n// the tower's slowest sway, until no node moves 0.002 units in 50 steps.\n// The bare tower takes 600 to 650 steps, under its weight 400 to 1,300 more.\nfunction relax(m, load, damp) {\n  const was = Float64Array.from(m.x);\n  let s = 0;\n  for (; s \u003c 4000; s++) {\n    step(m, load, damp, 1 / 30);\n    if (s % 50 === 49) {\n      let moved = 0;\n      for (let d = 0; d \u003c was.length; d++) (moved = max(moved, abs(m.x[d] - was[d]))), (was[d] = m.x[d]);\n      if (moved \u003c 0.002) break;\n    }\n  }\n  m.v.fill(0);\n  return s + 1;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, turn: 0.6, n: 0, m: null, hue: 0, load: 0.06, lnow: 0.06, acc: 0, pl: -1, plT: -9,\n    span: [0, 1], rgb: new Float32Array(W * H * 3), z: new Float32Array(W * H), order: [],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), n = cl(round(k[2]), 3, 6);\n  S.load = cl(k[3], 0, 1);\n  if (n !== S.n) {\n    // A new tower: settle it bare to fix the scale, then under its weight,\n    // overdamped so it does not overshoot. At the start knobs the first frame\n    // runs 650 + 500 steps, 1.5 ms in Node.\n    S.n = n;\n    S.m = build(n);\n    S.steps = relax(S.m, 0, 1.2);\n    const x = S.m.x;\n    let lo = 1e9, hi = -1e9;\n    for (let i = 0; i \u003c S.m.N; i++) (lo = min(lo, x[3 * i + 1])), (hi = max(hi, x[3 * i + 1]));\n    S.span = [lo, hi];\n    S.lnow = S.load;\n    S.steps += relax(S.m, S.lnow * FMAX, 2.5);\n  }\n  const m = S.m;\n  if (input.btnPressed && input.btnPressed[0]) {\n    // Pluck one of the longer cables on the side facing the camera. Its ends\n    // are kicked apart only once the last pluck has died down: kicks every\n    // 0.3 s used to pump the tower until it folded.\n    const c = cos(S.turn), sn = sin(S.turn), pick = [];\n    let lmax = 0;\n    for (let q = 0; q \u003c m.CL.length; q++) lmax = max(lmax, m.CL[q]);\n    for (let q = 0; q \u003c m.CL.length; q++) {\n      const a = 3 * m.cables[2 * q], b = 3 * m.cables[2 * q + 1];\n      if (m.fix[a / 3] && m.fix[b / 3]) continue;\n      if ((m.x[a] + m.x[b]) * sn + (m.x[a + 2] + m.x[b + 2]) * c > 12 && m.CL[q] > 0.5 * lmax) pick.push(q);\n    }\n    const q = pick.length ? pick[floor(Math.random() * pick.length)] : 0;\n    const a = 3 * m.cables[2 * q], b = 3 * m.cables[2 * q + 1];\n    let ke = 0;\n    for (let j = 0; j \u003c m.v.length; j++) ke += m.v[j] * m.v[j];\n    const ux = m.x[b + 2] - m.x[a + 2], uz = m.x[a] - m.x[b], L = sqrt(ux * ux + uz * uz) || 1;\n    if (ke \u003c 0.5 * KICK * KICK)\n      for (const [j, sg] of [[a, 1], [b, -1]]) if (!m.fix[j / 3]) (m.v[j] += (sg * KICK * ux) / L), (m.v[j + 2] += (sg * KICK * uz) / L);\n    S.pl = q;\n    S.plT = S.t;\n  }\n  // The tower's own time; a turned Load knob reaches it over half a second.\n  const sim = d * speed * 0.5;\n  S.lnow += (S.load - S.lnow) * min(1, sim / 0.5);\n  S.t += sim;\n  S.turn += sim * ((2 * PI) / 16);\n  S.acc += sim;\n  for (let i = 0; S.acc >= HSUB && i \u003c 40; i++) {\n    step(m, S.lnow * FMAX, 1.2, HSUB);\n    S.acc -= HSUB;\n  }\n  if (S.acc > HSUB) S.acc = 0;\n}\n\n// ---- Drawing. Orthographic, the camera 10 degrees above the horizon, the\n// tower turning about its axis. Each LED keeps the depth of what it shows.\nconst TILT = 0.17, TC = cos(TILT), TS = sin(TILT);\n\n// A 1 LED line from (x0, y0) to (x1, y1), bowed sideways by bow LEDs at\n// its middle, each sample shared between the two LEDs it falls across.\nfunction cable(rgb, zb, x0, y0, z0, x1, y1, z1, bow, col, v) {\n  const ex = x1 - x0, ey = y1 - y0, L = sqrt(ex * ex + ey * ey) || 1, nx = -ey / L, ny = ex / L;\n  const along = abs(ex) >= abs(ey), steps = (max(abs(ex), abs(ey)) + abs(bow) * 2) | 0;\n  for (let i = 0; i \u003c= steps; i++) {\n    const u = steps ? i / steps : 0, o = bow * sin(PI * u);\n    const fx = x0 + ex * u + nx * o, fy = y0 + ey * u + ny * o, z = z0 + (z1 - z0) * u;\n    const g = along ? fy - 0.5 : fx - 0.5, g0 = floor(g), w1 = g - g0;\n    for (let e = 0; e \u003c 2; e++) {\n      const px = along ? floor(fx) : g0 + e, py = along ? g0 + e : floor(fy);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px, wv = (e ? w1 : 1 - w1) * v;\n      if (z > zb[p] - 0.8) continue;\n      for (let j = 0; j \u003c 3; j++) rgb[3 * p + j] = max(rgb[3 * p + j], col[j] * wv);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.m) return;\n  const m = S.m, x = m.x, rgb = S.rgb, zb = S.z, n = m.n;\n  rgb.fill(0);\n  zb.fill(1e9);\n  const scale = 121 / (S.span[1] - S.span[0]), yc = (S.span[0] + S.span[1]) / 2;\n  const c = cos(S.turn), s = sin(S.turn);\n  const N = m.N, sx = new Float32Array(N), sy = new Float32Array(N), sz = new Float32Array(N);\n  for (let i = 0; i \u003c N; i++) {\n    const X = x[3 * i] * c - x[3 * i + 2] * s, Z = x[3 * i] * s + x[3 * i + 2] * c, Y = x[3 * i + 1] - yc;\n    sx[i] = 32 + scale * X;\n    sy[i] = 64.5 - scale * (Y * TC - Z * TS);\n    sz[i] = -Z; // smaller is nearer\n  }\n\n  // The weight: a disc on the top nodes, its thickness growing with Load.\n  if (S.load > 0.001) {\n    let cx = 0, cy = 0, cz = 0, rr = 0;\n    for (const i of m.top) (cx += x[3 * i] / n), (cy += x[3 * i + 1] / n), (cz += x[3 * i + 2] / n);\n    for (const i of m.top) rr = max(rr, sqrt((x[3 * i] - cx) ** 2 + (x[3 * i + 2] - cz) ** 2));\n    const R = rr * 0.72, th = 1.5 + 9 * S.load, X0 = cx * c - cz * s, Z0 = cx * s + cz * c, Y0 = cy + 0.5 - yc;\n    const col = hsv(0.08 + S.hue, 0.18, 1);\n    // The guide the weight runs on, up the axis to the top edge.\n    const rx = round(32 + scale * X0 - 0.5);\n    for (let py = 0; py \u003c 64.5 - scale * ((Y0 + th) * TC - Z0 * TS); py++)\n      if (rx >= 0 && rx \u003c W) (rgb[3 * (py * W + rx)] = 0.3 * col[0]), (rgb[3 * (py * W + rx) + 1] = 0.3 * col[1]), (rgb[3 * (py * W + rx) + 2] = 0.3 * col[2]);\n    for (let py = 0; py \u003c 30; py++)\n      for (let px = 0; px \u003c W; px++) {\n        const X = (px + 0.5 - 32) / scale - X0;\n        if (abs(X) >= R) continue;\n        const hz = sqrt(R * R - X * X), up = (64.5 - (py + 0.5)) / scale;\n        // Top face: the point at height Y0 + th whose screen row this is.\n        const zt = ((Y0 + th) * TC - up) / TS - Z0;\n        let v = 0, depth = 0;\n        if (abs(zt) \u003c= hz) (v = 0.5 + 0.2 * (zt / hz)), (depth = -(Z0 + zt));\n        else {\n          const ys = (up + (Z0 + hz) * TS) / TC;\n          if (ys >= Y0 && ys \u003c= Y0 + th) (v = 0.3 + 0.18 * (hz / R)), (depth = -(Z0 + hz));\n        }\n        if (!v) continue;\n        const p = py * W + px;\n        zb[p] = depth;\n        rgb[3 * p] = col[0] * v, rgb[3 * p + 1] = col[1] * v, rgb[3 * p + 2] = col[2] * v;\n      }\n  }\n\n  // Struts, far ones first: a bar 2.4 LEDs across, brighter at the near end\n  // and down its middle, with a dark rim that cuts whatever passes behind.\n  const ns = m.SL.length, ord = S.order;\n  ord.length = ns;\n  for (let q = 0; q \u003c ns; q++) ord[q] = q;\n  const mid = (q) => sz[m.struts[2 * q]] + sz[m.struts[2 * q + 1]];\n  ord.sort((a, b) => mid(b) - mid(a));\n  const RAD = 1.2, HALO = 1.5, DEEP = R0 + 2;\n  for (const q of ord) {\n    const a = m.struts[2 * q], b = m.struts[2 * q + 1];\n    const x0 = sx[a], y0 = sy[a], x1 = sx[b], y1 = sy[b], z0 = sz[a], z1 = sz[b];\n    const ex = x1 - x0, ey = y1 - y0, ll = ex * ex + ey * ey || 1;\n    const col = hsv(0.47 + S.hue + 0.04 * m.stage[q], 0.62, 1);\n    const reach = RAD + HALO + 0.5;\n    const X0 = max(0, floor(min(x0, x1) - reach)), X1 = min(W - 1, floor(max(x0, x1) + reach));\n    const Y0 = max(0, floor(min(y0, y1) - reach)), Y1 = min(H - 1, floor(max(y0, y1) + reach));\n    for (let py = Y0; py \u003c= Y1; py++)\n      for (let px = X0; px \u003c= X1; px++) {\n        const u = cl(((px + 0.5 - x0) * ex + (py + 0.5 - y0) * ey) / ll, 0, 1);\n        const dx = px + 0.5 - x0 - ex * u, dy = py + 0.5 - y0 - ey * u, dd = sqrt(dx * dx + dy * dy);\n        if (dd > reach) continue;\n        const z = z0 + (z1 - z0) * u, p = py * W + px;\n        if (dd \u003c RAD + 0.5) {\n          if (z >= zb[p]) continue;\n          const cov = min(1, RAD + 0.5 - dd), lit = (0.42 + 0.58 * cl((DEEP - z) / (2 * DEEP), 0, 1)) * (1 - 0.35 * (dd / (RAD + 0.5)) ** 2);\n          for (let j = 0; j \u003c 3; j++) rgb[3 * p + j] = rgb[3 * p + j] * (1 - cov) + col[j] * lit * cov;\n          if (cov > 0.4) zb[p] = z;\n        } else if (z + 1.5 \u003c zb[p]) {\n          const k = 0.2 + 0.8 * min(1, (dd - RAD - 0.5) / HALO) ** 2;\n          for (let j = 0; j \u003c 3; j++) rgb[3 * p + j] *= k;\n          zb[p] = z + 1.5;\n        }\n      }\n  }\n\n  // Cables: 1 LED lines, brighter the harder they pull, hidden behind struts.\n  // A plucked one swings as a string for two seconds, at a pitch that goes\n  // with the square root of its tension over its length, its envelope dim.\n  const nc = m.CL.length, pc = hsv(0.92 + S.hue, 0.4, 1), fl = hsv(0.13 + S.hue, 0.3, 1);\n  let tmax = 1, tsum = 0, lsum = 0;\n  for (let q = 0; q \u003c nc; q++) (tmax = max(tmax, m.ten[q])), (tsum += m.ten[q]), (lsum += m.CL[q]);\n  const age = S.t - S.plT;\n  for (let q = 0; q \u003c nc; q++) {\n    const a = m.cables[2 * q], b = m.cables[2 * q + 1];\n    const lv = 0.26 + 0.34 * (m.ten[q] / tmax);\n    if (q !== S.pl || age > 2) {\n      cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], 0, pc, lv);\n      continue;\n    }\n    const pk = 1 - age / 2, col = [0, 1, 2].map((j) => pc[j] + (fl[j] - pc[j]) * pk), v = lv + pk * (1 - lv);\n    const amp = 3.2 * pk * pk, w = 2 * PI * 2.2 * sqrt(m.ten[q] / (tsum / nc + 1e-9)) * (lsum / nc / m.CL[q]);\n    cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], amp, col, v * 0.35);\n    cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], -amp, col, v * 0.35);\n    cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], amp * cos(w * age), col, v);\n  }\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[3 * p], g = rgb[3 * p + 1], b = rgb[3 * p + 2];\n    if (r + g + b > 0.004) display.setPixel(p % W, (p / W) | 0, min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n","twindragon":"// ===== Patternflow pattern =====\n// Title:   Twindragon\n// Family:  fractal\n// Idea:    Every other LED is a Gaussian integer written in base -1+i, the panel is tiled with twindragons of 512 numbers each in its own dim hue, and a bright window counts through all of them at once, so its shape is always a few smaller twindragons that turn 135 degrees with every digit the count carries.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: base -1+i numeration (Walter Penney, 1965), twindragon (Chandler Davis and Donald Knuth, 1970), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Digits=9..12, Split=1..8\n//\n// Knob 1: Hue. Turns every tile round the wheel together: at 0 the tiles are teal, blue and magenta, a little warmer towards the bottom, and the windows run from white at the newest number to the tile's own hue.\n// Knob 2: Speed. How fast the count runs: at 2 one pass through the 512 numbers of a tile takes 8 s, 64 numbers a second; at 0.2 ten times slower, at 3 one and a half times faster. A tile of more digits counts faster, so a pass only grows by the square root of 2 a digit, as the tile's width does: 22.6 s at 12.\n// Knob 3: Digits. K, the digits each number in a tile has, 9 to 12. A tile holds 2^K numbers and the panel's 4096 lattice LEDs hold exactly 4096 / 2^K tiles' worth, so every number shows 8 times at 9 (15 tiles touch the panel), 4 at 10, 2 at 11 and once at 12, where the pieces of six tiles add up to one. A digit more turns the tiles 135 degrees and makes them 1.41 times wider.\n// Knob 4: Split. How many windows share the bright 18.5%, spread evenly through the count. At 1, 2, 4 and 8 each window runs through its own half, quarter or eighth of the tile, all the same shape: the twindragon is two, four or eight smaller ones. At 3, 5, 6 and 7 the gap between windows is not a power of two, so they start at different places in the count and come out in different shapes.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Base -1+i (Penney, 1965). Every Gaussian integer a+bi has one finite\n// expansion sum d_k (-1+i)^k with digits 0 and 1. The low digit is (a+b) mod 2;\n// take it off and divide by -1+i: (a+bi)/(-1+i) = ((b-a) + (-a-b)i)/2.\n// Checked in Node: all 160,801 points with |a|, |b| \u003c= 200 end in at most 22\n// digits and read back to themselves; the 2^22 strings of up to 22 digits give\n// 2^22 different numbers, so none of those points has a second expansion; and\n// for K = 2..12 the 2^K numbers of K digits are pairwise incongruent mod\n// (-1+i)^K, so their copies moved by multiples of (-1+i)^K tile the lattice\n// with no point twice.\n//\n// z = q (-1+i)^K + r, with r the K low digits. r read as a binary number is\n// where z comes in the count; q names the tile.\n//\n// ---- On the panel z = a+bi sits at origin + (a-b, a+b), which is (1+i) z: the\n// lattice is exactly the LEDs with x+y even, the others stay off.\nconst OX = 32, OY = 64;\n\n// ---- Levels. Each lit LED has four dark neighbours, so the map's detail is\n// the mean lit level / 255 and its edges are the share of lit LEDs over 40.\n// The windows hold the first numbers at or above 18.5% of the count: 95 of\n// 512 at K = 9. The panel is a whole number of tiles' worth for every K from 9\n// to 12 (each number shows 2^(12-K) times), so 760 of the 4096 lattice LEDs\n// are bright on every frame. Those sit at 255 and the other 81.45% dim at 40:\n// detail = (0.8145 * 40 + 0.1855 * 255) / 255 = 0.313, edges = 0.186, inside\n// the map's cell of edges under 0.21 and detail 0.297..0.375. Dim at 40 is\n// still lit (over 24) and still a soft step (not over 40). Split and Digits\n// move the bright share only between 18.5% and 18.8%.\nconst DIM = 40, SHARE = 0.185;\n\nfunction layout(K) {\n  const P = 1 \u003c\u003c K, idx = new Int32Array(W * H).fill(-1), tile = new Int32Array(W * H);\n  const keys = new Map();\n  const ty = [], tc = [];\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - OX, dy = y - OY;\n      if ((dx + dy) & 1) continue;\n      let a = (dx + dy) / 2, b = (dy - dx) / 2, r = 0;\n      for (let k = 0; k \u003c K; k++) {\n        const d = (a + b) & 1;\n        if (d) r |= 1 \u003c\u003c k;\n        a -= d;\n        const na = (b - a) / 2;\n        b = (-a - b) / 2;\n        a = na;\n      }\n      const key = a * 4096 + b;\n      let t = keys.get(key);\n      if (t === undefined) {\n        t = keys.size;\n        keys.set(key, t);\n        ty.push([0, 0]);\n        tc.push((((a + b) % 3) + 3) % 3);\n      }\n      ty[t][0] += y;\n      ty[t][1]++;\n      idx[y * W + x] = r;\n      tile[y * W + x] = t;\n    }\n  // A tile's hue follows its middle row down the panel, plus a step of 0.16\n  // by (qa + qb) mod 3. A tile's six neighbours sit at q +-1, +-i and\n  // +-(1+i), and none of those changes qa + qb by a multiple of 3, so two tiles\n  // that touch never share a hue.\n  const hue = ty.map(([s, n], t) => 0.12 * (s / n / H) + 0.16 * tc[t]);\n  return { K, P, idx, tile, hue };\n}\n\nexport function setup(params) {\n  params.s = { t: 0, n: 0, L: null, hue: 0, split: 1 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 9, 1], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), K = cl(round(k[2]), 9, 12);\n  S.split = cl(round(k[3]), 1, 8);\n  if (!S.L || S.L.K !== K) {\n    // Keep the place in the pass when the tile size changes.\n    const u = S.L ? S.n / S.L.P : 0.25;\n    S.L = layout(K);\n    S.n = u * S.L.P;\n  }\n  // 64 numbers a second at Speed 2 for K = 9, times sqrt 2 a digit more.\n  const rate = 32 * speed * Math.pow(sqrt(2), K - 9);\n  S.n = (S.n + d * rate) % S.L.P;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.L) return;\n  const { P, idx, tile, hue } = S.L, m = S.split, n = floor(S.n);\n  const cols = hue.map((h) => {\n    const c = hsv(0.48 + S.hue + h, 0.8, 1);\n    return [round(c[0] * DIM), round(c[1] * DIM), round(c[2] * DIM), 0.48 + S.hue + h];\n  });\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = idx[p];\n    if (r \u003c 0) continue;\n    const c = cols[tile[p]];\n    // How far back in the count this number is, as a share of the pass.\n    const ph = (((n - r) % P) + P) % P / P, f = ph * m - floor(ph * m);\n    const x = p % W, y = (p - x) / W;\n    if (f \u003c SHARE) {\n      // Bright: white at the newest number, the tile's own hue at the oldest,\n      // the brightest channel 255 all along.\n      const s = f / SHARE, b = hsv(c[3], 0.1 + 0.8 * s, 1);\n      display.setPixel(x, y, round(b[0] * 255), round(b[1] * 255), round(b[2] * 255));\n    } else display.setPixel(x, y, c[0], c[1], c[2]);\n  }\n}\n","eight-principles-of-yong":"// ===== Patternflow pattern =====\n// Title:   Eight Principles of Yong\n// Family:  type\n// Idea:    The character 永, eternity, stands the full height of the panel and a brush writes it in its five strokes in their standard order, and as it begins each of the eight basic strokes of regular script that the old teaching finds in it, the name of that method lights in red beside it: the dot, then the horizontal, the vertical and the hook in one stroke, the rising stroke turning into the long sweep, the short peck and the wave; the brush presses wider and lifts thinner, pauses and pools at its turns and runs dry in streaks toward the end of a long stroke, and when the character is done the eight light one after another before the ink fades and another is written.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Eight Principles of Yong (永字八法), the teaching of regular-script calligraphy that finds eight basic strokes in the one character 永, of traditional attribution (to Wang Xizhi in the 4th century, to the Sui monk Zhiyong and to others), with the eight under their old names 側 勒 努 趯 策 掠 啄 磔; the five strokes of 永 in their standard order; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Brush=-1..1, Ink=-1..1\n//\n// Knob 1: Hue. Turns ink, paper and names round the wheel together: at 0 gold ink on indigo paper with the names in vermilion, at 0.25 green ink on a dark plum paper, at 0.5 blue ink on dark olive with cyan names.\n// Knob 2: Speed. At 2 the character takes 6.7 s from the dot's first touch to the lift of the wave, the vertical alone about 1 s, then holds 2.3 s while the eight methods light in turn, 0.23 s each, and fades in 0.9 s, a round of 10.2 s; at 0.2 ten times slower, at 3 two thirds of that. A fresh start opens with the dot already down and the brush in the air.\n// Knob 3: Brush. The brush's size: at 0 the vertical comes out about 6.5 LEDs wide and the dot 8.4 where it presses, at -1 0.55 of that (the vertical 3.6) and at 1 1.45 (the vertical 9.5, wide enough to touch the name 努 beside it).\n// Knob 4: Ink. How much ink the brush carries and how fast it gives out across its 9 bristles. At the opening 0.06 a stroke starts full and the last third of the vertical, the tail of the sweep and the foot of the wave break into dry streaks; at -1 it starts with a fifth less and runs out 2.2 times faster, down to about a quarter of the bristles scratching; at 1 it hardly runs dry, the strokes swell by an eighth and the ink bleeds 3.2 LEDs into the paper over most of a second, nearly 5 where the brush rests.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The five strokes of 永 in their order, each a run of knots the brush\n// passes: x, y, brush radius in LEDs, the time to reach the knot from the\n// one before and the time the brush rests there pressing down (in beats, of\n// which Speed 2 plays 1.2 a second), and which of the eight methods the\n// stretch belongs to: 0 側 the dot, 1 勒 the horizontal, 2 努 the vertical,\n// 3 趯 the hook, 4 策 the rising stroke, 5 掠 the long sweep to the left, 6 啄\n// the short peck, 7 磔 the wave to the right. The second stroke carries three\n// methods and the third two, so five strokes hold all eight.\nconst STROKES = [\n  [[25.5, 4.5, 0.6, 0, 0, 0], [27.5, 6.5, 1.8, 0.1, 0, 0], [30.5, 10, 3.0, 0.14, 0, 0], [33.5, 14, 3.9, 0.14, 0, 0], [35, 16.5, 4.2, 0.1, 0.18, 0], [33.8, 18.2, 3.4, 0.08, 0, 0], [32.5, 17.6, 2.2, 0.06, 0, 0]],\n  [[14.5, 32.5, 0.7, 0, 0, 1], [16.5, 35, 2.6, 0.08, 0.1, 1], [20, 35, 2.4, 0.08, 0, 1], [26, 34, 2.3, 0.16, 0, 1], [32, 32.8, 2.3, 0.16, 0, 1], [35.5, 32.2, 2.2, 0.08, 0, 1], [37.5, 32, 2.0, 0.05, 0, 1],\n    [39.5, 34.8, 3.5, 0.08, 0.22, 2], [38.6, 40, 3.4, 0.08, 0, 2], [38, 55, 3.2, 0.22, 0, 2], [37.8, 72, 3.2, 0.24, 0, 2], [38, 90, 3.3, 0.24, 0, 2], [38.3, 104, 3.4, 0.2, 0, 2],\n    [38.4, 111, 3.8, 0.12, 0.25, 3], [35.5, 111.5, 3.0, 0.05, 0, 3], [31, 108, 2.0, 0.06, 0, 3], [27, 104.5, 1.0, 0.05, 0, 3], [24.5, 102.5, 0.25, 0.04, 0, 3]],\n  [[4.5, 63, 0.7, 0, 0, 4], [6.5, 65.5, 2.6, 0.08, 0.1, 4], [11, 63.5, 2.2, 0.08, 0, 4], [17, 60.5, 1.9, 0.1, 0, 4], [21.5, 58.3, 1.8, 0.07, 0, 4],\n    [24.5, 58.5, 2.6, 0.06, 0.18, 5], [24.6, 63, 2.9, 0.07, 0, 5], [23.6, 71, 3.0, 0.1, 0, 5], [21.5, 80, 2.8, 0.1, 0, 5], [18, 89, 2.4, 0.1, 0, 5], [13, 98, 1.9, 0.1, 0, 5], [7.5, 106, 1.2, 0.09, 0, 5], [3, 111, 0.5, 0.07, 0, 5], [1, 112.5, 0.15, 0.04, 0, 5]],\n  [[57, 41, 0.8, 0, 0, 6], [56, 43.5, 2.8, 0.07, 0.08, 6], [52.5, 47, 2.6, 0.06, 0, 6], [48.5, 51, 2.0, 0.05, 0, 6], [45, 54.5, 1.2, 0.04, 0, 6], [42.5, 56.5, 0.3, 0.03, 0, 6]],\n  [[42.5, 58.5, 0.6, 0, 0, 7], [44.2, 62.5, 1.3, 0.08, 0, 7], [46.6, 69, 1.9, 0.12, 0, 7], [49.2, 77, 2.6, 0.14, 0, 7], [51.6, 85, 3.3, 0.14, 0, 7], [53.8, 92, 4.0, 0.13, 0, 7], [55.6, 97, 4.5, 0.1, 0, 7], [57, 99.8, 4.7, 0.08, 0.25, 7], [59.6, 101.2, 3.4, 0.07, 0, 7], [61.6, 101.8, 2.0, 0.05, 0, 7], [63.2, 102, 0.6, 0.04, 0, 7]],\n];\n\n// The names of the eight methods, drawn for this pattern 13 LEDs square, and\n// where each stands beside its stroke, as diagrams of 永 often set them.\nconst NAMES = [\n  [\"..#..........\", \"..#.#####...#\", \".#..#...#.#.#\", \".#..#####.#.#\", \"##..#...#.#.#\", \".#..#####.#.#\", \".#..#...#.#.#\", \".#..#####.#.#\", \".#...#.#..#.#\", \".#..#...#...#\", \".#.#.....#..#\", \".#..........#\", \".#.........##\"],\n  [\".#.#...#.....\", \"#######.#....\", \".#.#....#....\", \".###.#######.\", \"...#....#...#\", \".#####..#...#\", \".#.#.#..#...#\", \".#####..#...#\", \"...#...#....#\", \"#######.....#\", \"...#...#....#\", \"...#..#..#..#\", \"...#.#....##.\"],\n  [\"..#...######.\", \"..#...#....#.\", \"#######...#..\", \".#..#..#.#...\", \".#.#....#....\", \"..##...#.#...\", \"##..#.#...##.\", \".....#.......\", \"############.\", \".....#.....#.\", \"....#......#.\", \"..##.....#.#.\", \"##........#..\"],\n  [\"..#...##.##..\", \"#####..#..#..\", \"..#...##.##..\", \".###...#..#..\", \".......#.##..\", \"#####.#.#....\", \"..#..#####...\", \".##.#.#..#...\", \"..#...####...\", \"..##..#..#...\", \".#..#.####...\", \".#..#.#......\", \"#....########\"],\n  [\".#.....#.....\", \"#####.#####..\", \"#....#..#....\", \".............\", \"#############\", \"......#......\", \".###########.\", \".#....#....#.\", \".#....#..###.\", \"......#......\", \"....#.#.#....\", \"..##..#..##..\", \"##....#....##\"],\n  [\".#.....#.....\", \".#..#######..\", \"####.........\", \".#...#####...\", \".#...#...#...\", \".###.#...#...\", \"##...#####...\", \".#.....#.....\", \".#...#.#.#...\", \".#..#..#..#..\", \".#.#...#...#.\", \".#.....#.....\", \"##....##.....\"],\n  [\".....########\", \".........#...\", \"........#...#\", \"####...#...#.\", \"#..#..#..##..\", \"#..#....##...\", \"#..#...#.#...\", \"#..#..#..##..\", \"#..#.#..##.#.\", \"####...#.#..#\", \"......#..#..#\", \".....#...#...\", \"........##...\"],\n  [\".......#...#.\", \"#####.####.##\", \"..#...#..#.#.\", \"..#....##..##\", \".#.....#...#.\", \".####.#...##.\", \"##..#.#######\", \".#..#...###..\", \".#..#..#.#.#.\", \".####.#..#..#\", \".........#...\", \".........#...\", \".........#...\"],\n];\nconst SPOT = [[11, 3], [1, 17], [22, 88], [10, 114], [1, 46], [1, 72], [50, 24], [47, 110]];\n\n// Paper: a fixed scatter of short fibres, and a grain per LED that roughens\n// the edge of every stroke.\nconst FIB = new Float32Array(N), GRAIN = new Float32Array(N);\n{\n  let s = 12345;\n  const rnd = () => ((s = (s * 1103515245 + 12345) >>> 0) / 4294967296);\n  for (let p = 0; p \u003c N; p++) GRAIN[p] = rnd() * 2 - 1;\n  for (let f = 0; f \u003c 170; f++) {\n    let x = rnd() * W, y = rnd() * H, a = rnd() * PI;\n    const len = 3 + rnd() * 6, v = 0.3 + rnd() * 0.7;\n    for (let k = 0; k \u003c len; k++, a += (rnd() - 0.5) * 0.5) {\n      x += cos(a);\n      y += sin(a);\n      const xi = floor(x), yi = floor(y);\n      if (xi >= 0 && xi \u003c W && yi >= 0 && yi \u003c H) FIB[yi * W + xi] = max(FIB[yi * W + xi], v);\n    }\n  }\n}\n\n// Bristles across the brush, and the beats a finished character holds and\n// takes to fade.\nconst NB = 9, HOLD = 2.8, FADE = 1.1;\n\n// Lays the strokes out as a timeline of brush samples a third of an LED\n// apart, with a little of a hand's wobble that differs from one writing to\n// the next.\nfunction build(S) {\n  const xs = [], ys = [], rs = [], ts = [], ds = [], ms = [], ss = [], ks = [], txs = [], tys = [];\n  const air = [];\n  let t = 0, px = 46, py = -6;\n  STROKES.forEach((knots, k) => {\n    const P = knots.map((q) => [q[0] + (Math.random() - 0.5) * 1.0, q[1] + (Math.random() - 0.5) * 1.0, q[2] * (0.94 + Math.random() * 0.12), q[3], q[4], q[5]]);\n    const dist = sqrt((P[0][0] - px) ** 2 + (P[0][1] - py) ** 2), at = 0.18 + dist / 150;\n    air.push([t, t + at, px, py, P[0][0], P[0][1], P[0][2]]);\n    t += at;\n    let s = 0, lx = P[0][0], ly = P[0][1];\n    const push = (x, y, r, tt, dw, m) => {\n      s += sqrt((x - lx) ** 2 + (y - ly) ** 2);\n      const dx = x - lx, dy = y - ly, L = sqrt(dx * dx + dy * dy);\n      if (L > 1e-3) txs.push(dx / L), tys.push(dy / L);\n      else txs.push(txs.length ? txs[txs.length - 1] : 1), tys.push(tys.length ? tys[tys.length - 1] : 0);\n      xs.push(x), ys.push(y), rs.push(r), ts.push(tt), ds.push(dw), ms.push(m), ss.push(s), ks.push(k);\n      lx = x;\n      ly = y;\n    };\n    push(P[0][0], P[0][1], P[0][2], t, P[0][4], P[0][5]);\n    t += P[0][4];\n    for (let i = 1; i \u003c P.length; i++) {\n      const a = P[max(0, i - 2)], b = P[i - 1], c = P[i], d = P[min(P.length - 1, i + 1)];\n      const L = sqrt((c[0] - b[0]) ** 2 + (c[1] - b[1]) ** 2), n = max(1, ceil(L / 0.33));\n      for (let j = 1; j \u003c= n; j++) {\n        const u = j / n, u2 = u * u, u3 = u2 * u;\n        const cr = (p0, p1, p2, p3) => 0.5 * (2 * p1 + (p2 - p0) * u + (2 * p0 - 5 * p1 + 4 * p2 - p3) * u2 + (3 * p1 - p0 - 3 * p2 + p3) * u3);\n        push(cr(a[0], b[0], c[0], d[0]), cr(a[1], b[1], c[1], d[1]), b[2] + (c[2] - b[2]) * u, t + c[3] * u, j === n ? c[4] : 0, c[5]);\n      }\n      t += c[3] + c[4];\n    }\n    px = P[P.length - 1][0];\n    py = P[P.length - 1][1];\n  });\n  S.n = xs.length;\n  S.x = Float32Array.from(xs), S.y = Float32Array.from(ys), S.r = Float32Array.from(rs), S.t = Float32Array.from(ts), S.d = Float32Array.from(ds);\n  S.m = Int8Array.from(ms), S.s = Float32Array.from(ss), S.k = Int8Array.from(ks), S.tx = Float32Array.from(txs), S.ty = Float32Array.from(tys);\n  S.air = air;\n  S.end = t;\n  // Each stroke's bristles: the ink level at which each one gives out, and\n  // a slow wobble along the stroke so the dry streaks break and rejoin.\n  S.theta = [];\n  S.wf = [];\n  S.wp = [];\n  for (let k = 0; k \u003c 5; k++) {\n    const th = [];\n    for (let b = 0; b \u003c NB; b++) th.push(0.08 + (0.84 * (b + Math.random())) / NB);\n    for (let b = NB - 1; b > 0; b--) {\n      const j = floor(Math.random() * (b + 1));\n      [th[b], th[j]] = [th[j], th[b]];\n    }\n    S.theta.push(th);\n    S.wf.push(Array.from({ length: NB }, () => 0.15 + Math.random() * 0.25));\n    S.wp.push(Array.from({ length: NB }, () => Math.random() * 6.3));\n  }\n  // The time each method starts, for its name.\n  S.mt = new Float32Array(8).fill(1e9);\n  for (let i = 0; i \u003c S.n; i++) if (S.t[i] \u003c S.mt[S.m[i]]) S.mt[S.m[i]] = S.t[i];\n}\n\nfunction fresh(S) {\n  S.T = 0;\n  S.i = 0;\n  S.dw = -1;\n  S.cov.fill(0);\n  S.bleed.fill(0);\n  S.mid.fill(-1);\n  S.t0.fill(-1);\n  build(S);\n}\n\nexport function setup(params) {\n  const S = (params.yong = {\n    cov: new Float32Array(N), bleed: new Float32Array(N), mid: new Int8Array(N), t0: new Float32Array(N),\n    hue: 0, speed: 2, brush: 0, ink: 0.06, started: false,\n  });\n  fresh(S);\n}\n\n// One brush sample pressed into the paper. grow is how far into its rest the\n// brush is, 0 to 1: a resting brush spreads and pools its ink.\nfunction stamp(S, i, grow) {\n  const k = S.k[i], s = S.s[i], q = S.ink, wet = max(0, q);\n  const rr = S.r[i] * (1 + 0.45 * S.brush) * (1 + 0.12 * wet) * (1 + 0.14 * grow);\n  if (rr \u003c 0.12) return;\n  const rate = 0.0055 * (1 - 0.6 * q) * (q \u003c 0 ? 1 - 0.3 * q : 1);\n  let L = 1.05 + 0.2 * q - s * rate;\n  if (grow > 0) L = max(L, 0.75 + 0.3 * grow);\n  const dens = cl(0.5 + 0.5 * L, 0.45, 1);\n  const hw = 3.2 * wet + 1.4 * grow * (0.25 + wet);\n  const cx = S.x[i], cy = S.y[i], nx = -S.ty[i], ny = S.tx[i];\n  const th = S.theta[k], wf = S.wf[k], wp = S.wp[k];\n  const R = rr + hw + 1;\n  const x0 = max(0, floor(cx - R)), x1 = min(W - 1, ceil(cx + R)), y0 = max(0, floor(cy - R)), y1 = min(H - 1, ceil(cy + R));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x - cx, dy = y - cy, dist = sqrt(dx * dx + dy * dy), p = y * W + x, d = dist - rr;\n      if (S.t0[p] \u003c 0 && d \u003c hw + 0.5) S.t0[p] = S.T;\n      const c = cl(0.6 - d + 0.35 * GRAIN[p], 0, 1);\n      if (c > 0) {\n        const u = (dx * nx + dy * ny) / rr;\n        const b = cl(floor((u + 1) * 0.5 * NB), 0, NB - 1);\n        const dep = cl((max(L, 0.3) + 0.28 * sin(s * wf[b] + wp[b]) - th[b]) * 5, 0, 1);\n        const v = c * dep * dens;\n        if (v > S.cov[p]) {\n          S.cov[p] = v;\n          S.mid[p] = S.m[i];\n        }\n      }\n      if (hw > 0.05 && d > -0.5 && d \u003c hw) {\n        const bv = (0.2 + 0.25 * wet) * cl(1 - (d + 0.6 * GRAIN[p] + 0.5 * FIB[p]) / hw, 0, 1);\n        if (bv > S.bleed[p]) S.bleed[p] = bv;\n      }\n    }\n}\n\nfunction advance(S, dt) {\n  S.T += dt * S.speed * 0.6;\n  const T = S.T;\n  if (S.dw >= 0) {\n    const g = min(1, (T - S.t[S.dw]) / S.d[S.dw]);\n    stamp(S, S.dw, g);\n    if (g >= 1) S.dw = -1;\n  }\n  while (S.i \u003c S.n && S.t[S.i] \u003c= T) {\n    const i = S.i++;\n    if (S.d[i] > 0) {\n      const g = min(1, (T - S.t[i]) / S.d[i]);\n      stamp(S, i, g);\n      if (g \u003c 1) {\n        S.dw = i;\n        break;\n      }\n    } else stamp(S, i, 0);\n  }\n  if (T > S.end + HOLD + FADE) fresh(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.yong) setup(params);\n  const S = params.yong, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.brush = cl(k[2], -1, 1);\n  S.ink = cl(k[3], -1, 1);\n  if (!S.started) {\n    // A fresh start opens with the dot written and the brush on its way to\n    // the horizontal.\n    S.started = true;\n    for (let j = 0; j \u003c 36; j++) advance(S, 1 / 30 / (S.speed * 0.6));\n  }\n  advance(S, dt);\n}\n\nexport function draw(display, params) {\n  const S = params.yong;\n  if (!S) return;\n  const T = S.T, h0 = 0.115 + S.hue;\n  const ink = hsv(h0, 0.72, 1, [0, 0, 0]), paper = hsv(h0 + 0.52, 0.78, 0.16, [0, 0, 0]), lab = hsv(h0 - 0.105, 0.78, 0.95, [0, 0, 0]);\n  const fade = T > S.end + HOLD ? cl(1 - (T - S.end - HOLD) / FADE, 0, 1) : 1;\n  // While the finished character holds, each method lights in turn.\n  const hiT = T - S.end - 0.3, hiM = hiT >= 0 && hiT \u003c 8 * 0.28 ? floor(hiT / 0.28) : -1, hiA = hiM >= 0 ? sin((PI * (hiT - hiM * 0.28)) / 0.28) : 0;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const f = 0.82 + 0.45 * FIB[p] + 0.06 * GRAIN[p];\n      let r = paper[0] * f, g = paper[1] * f, b = paper[2] * f;\n      const t0 = S.t0[p];\n      if (t0 >= 0) {\n        const age = T - t0, cv = S.cov[p], bl = S.bleed[p] * min(1, age / 0.9);\n        const a = max(cv, bl) * fade;\n        if (a > 0) {\n          r += (ink[0] - r) * a;\n          g += (ink[1] - g) * a;\n          b += (ink[2] - b) * a;\n          let wh = 0.5 * exp(-age / 0.35) * cv;\n          if (hiM >= 0 && S.mid[p] === hiM) wh += 0.55 * hiA * cv;\n          wh *= fade;\n          r += (255 - r) * wh;\n          g += (255 - g) * wh;\n          b += (255 - b) * wh;\n        }\n      }\n      display.setPixel(x, y, r, g, b);\n    }\n  // The names, each lighting as its method begins.\n  for (let m = 0; m \u003c 8; m++) {\n    const st = S.mt[m];\n    if (T \u003c st) continue;\n    const age = T - st;\n    let v = (0.62 + 0.38 * exp(-age / 0.6)) * min(1, age / 0.15) * fade;\n    if (m === hiM) v = min(1, v + 0.5 * hiA);\n    const G = NAMES[m], [ox, oy] = SPOT[m];\n    for (let gy = -1; gy \u003c= 13; gy++)\n      for (let gx = -1; gx \u003c= 13; gx++) {\n        const x = ox + gx, y = oy + gy;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const on = gy >= 0 && gy \u003c 13 && gx >= 0 && gx \u003c 13 && G[gy][gx] === \"#\";\n        if (on) display.setPixel(x, y, lab[0] * v + 40 * v * v, lab[1] * v + 40 * v * v, lab[2] * v + 40 * v * v);\n      }\n  }\n  // The brush between strokes, a faint ring where it will come down.\n  for (const a of S.air)\n    if (T >= a[0] && T \u003c a[1]) {\n      const u = (T - a[0]) / (a[1] - a[0]), e = u * u * (3 - 2 * u);\n      const bx = a[2] + (a[4] - a[2]) * e, by = a[3] + (a[5] - a[3]) * e, rr = 2.2 + 2 * (1 - e) + S.brush;\n      for (let y = max(0, floor(by - rr - 1)); y \u003c= min(H - 1, ceil(by + rr + 1)); y++)\n        for (let x = max(0, floor(bx - rr - 1)); x \u003c= min(W - 1, ceil(bx + rr + 1)); x++) {\n          const d = abs(sqrt((x - bx) ** 2 + (y - by) ** 2) - rr);\n          if (d \u003c 0.7) display.setPixel(x, y, 60 + ink[0] * 0.25, 60 + ink[1] * 0.25, 60 + ink[2] * 0.25);\n        }\n    }\n}\n","frenkel-kontorova":"// ===== Patternflow pattern =====\n// Title:   Frenkel-Kontorova\n// Family:  sim\n// Idea:    Balls joined by springs lie in a ring on a corrugated floor of 12 wells along the foot of the panel, with more or fewer balls than wells, so the chain bunches or stretches at kinks where it slips by one well, and a steady push drives those kinks round the ring while the panel above writes each moment as a row, oldest at the top, so every ball's worldline steps one well sideways each time a kink runs through it and the kinks cross the record as slanted bands, magenta where the chain is squeezed and green where it is stretched.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Frenkel-Kontorova model (Yakov Frenkel and Tatiana Kontorova, 1938), the damped chain of Kibble-Zurek Ions (pattern round 64), pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Drive=0..3, Misfit=0.86..1.2, Substrate=1..4\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the chain lying one ball to a well is blue, a squeezed kink magenta, a stretched kink green and the two marked balls cream; at 0.25 the chain is pink, squeezed kinks orange and stretched ones blue; at 0.5 the chain is a pale yellow with green and pink kinks.\n// Knob 2: Drive. The same push on every ball, 0.04 d + 0.1 d^2 times K = 1's strongest pull back into a well. At the opening 2 (0.48 of that pull) the two squeezed kinks run right at about 22 LEDs a second, round the ring in 2.9 s, and each ball steps one well right every 1.7 s; at 0.5 they creep, a ball stepping every 9 s; at 0 nothing moves but a shiver; at 3 the K = 1 chain tears loose and slides 3.2 wells a second, kinks and all.\n// Knob 3: Misfit. The chain's mean spacing over the well spacing, rounded to whole balls on the 12 wells. At 0.86 there are 14 balls, two too many, which bunch into two squeezed kinks that run with the push; at 0.945 13 balls and one such kink; at 1.03 twelve, one to a well, no kink and nothing moving until the whole chain tears loose; at 1.115 eleven, one ball short, and the stretched kink runs against the push at 22 LEDs a second; at 1.2 ten and two. A new count lays the chain out evenly and lets it settle into kinks.\n// Knob 4: Substrate. K, the depth of the wells against the springs, the floor V = K/4pi^2 (1 - cos 2 pi x) under springs of stiffness 1, drawn 3 + 1.25 K LEDs high. At 1 a squeezed kink is spread over four bonds and the opening push moves it easily; at 2.5 it sits mostly in one bond squeezed by 0.58 of a well and needs a push of 2 to move; at 3.25 the push of 2 cannot lift it over the next crest and the record stands still, and at 4 it takes a push of 3.\n// Buttons: K2 tap turns the push round, so the kinks turn back and their bands bend into a V.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// The ring: M wells P LEDs apart round the panel's width. Chain positions\n// are in wells, well j at x = j, drawn at column P j + P/2.\nconst M = 12, P = W / M, NMAX = 24;\n// The history: one row every ROW_T seconds in rows 0 to HR - 1, oldest on\n// top and newest at the bottom. The chain view under it: valley floors on\n// row YB.\nconst HR = 113, YB = 125, ROW_T = 1 / 12;\n// Simulation: TS time units a second in steps of DT, damping GAMMA.\nconst TS = 6, DT = 0.04, GAMMA = 0.3;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nfunction gauss() {\n  return (Math.random() + Math.random() + Math.random() - 1.5) * 2;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, x: new Float64Array(NMAX), v: new Float64Array(NMAX), f: new Float64Array(NMAX),\n    K: 1, F: 0, dir: 1, temp: 0.001, hue: 0, rowT: 0, head: 0, started: false,\n    hist: new Float32Array(HR * W * 3), strain: new Float32Array(W), sm: new Float32Array(W),\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],\n  };\n  return params.s;\n}\n\nfunction load(S, n) {\n  S.n = n;\n  const a = M / n, off = Math.random();\n  for (let i = 0; i \u003c n; i++) (S.x[i] = off + i * a), (S.v[i] = 0);\n}\n\nfunction forces(S) {\n  const n = S.n, x = S.x, f = S.f, k = S.K / TAU;\n  for (let i = 0; i \u003c n; i++) {\n    const xl = i > 0 ? x[i - 1] : x[n - 1] - M, xr = i \u003c n - 1 ? x[i + 1] : x[0] + M;\n    f[i] = xr - 2 * x[i] + xl - k * sin(TAU * x[i]) + S.F;\n  }\n}\n\nfunction step(S, h) {\n  const n = S.n, x = S.x, v = S.v, f = S.f;\n  forces(S);\n  const kick = sqrt(2 * GAMMA * S.temp * h), g = 1 - GAMMA * h;\n  for (let i = 0; i \u003c n; i++) {\n    v[i] = (v[i] + f[i] * h) * g + kick * gauss();\n    x[i] += v[i] * h;\n  }\n  if (x[0] >= M) for (let i = 0; i \u003c n; i++) x[i] -= M;\n  else if (x[0] \u003c 0) for (let i = 0; i \u003c n; i++) x[i] += M;\n}\n\n// Strain of each column: the stretch of the bond over it, in wells, spread\n// over five columns so a kink reads as a band.\nfunction strainRow(S) {\n  const n = S.n, x = S.x, st = S.strain, sm = S.sm;\n  for (let i = 0; i \u003c n; i++) {\n    const xa = x[i], xb = i \u003c n - 1 ? x[i + 1] : x[0] + M, s = xb - xa - 1;\n    const c0 = P * xa + P / 2, c1 = P * xb + P / 2;\n    for (let c = Math.ceil(c0 - 0.5); c \u003c c1 - 0.5; c++) st[((c % W) + W) % W] = s;\n  }\n  for (let c = 0; c \u003c W; c++)\n    sm[c] = (st[(c + W - 2) % W] + 2 * st[(c + W - 1) % W] + 3 * st[c] + 2 * st[(c + 1) % W] + st[(c + 2) % W]) / 9;\n  return sm;\n}\n\n// The colour of a strain: blue where the chain lies one ball to a well,\n// green where it is stretched, magenta where it is squeezed.\nfunction strainColour(S, s, v, o) {\n  const a = cl((abs(s) - 0.04) / 0.32, 0, 1);\n  const h = s > 0 ? 0.64 + (0.42 - 0.64) * a : 0.64 + (0.88 - 0.64) * a;\n  return hsv(h + S.hue, 0.55 + 0.35 * a, v, o);\n}\n\n// One row of the history: the strain as a dim band, each ball's worldline\n// over it, and two balls, the first and the middle one, in cream so their\n// steps can be followed down the record.\nfunction record(S) {\n  S.head = (S.head + 1) % HR;\n  const row = S.head * W * 3, hist = S.hist, sm = strainRow(S), c = S.c;\n  for (let X = 0; X \u003c W; X++) {\n    const s = sm[X], a = cl((abs(s) - 0.04) / 0.32, 0, 1);\n    strainColour(S, s, 0.05 + 0.42 * a * a, c);\n    hist[row + X * 3] = c[0];\n    hist[row + X * 3 + 1] = c[1];\n    hist[row + X * 3 + 2] = c[2];\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const px = (((P * S.x[i] + P / 2 - 0.5) % W) + W) % W, X0 = floor(px), fr = px - X0;\n    const s = sm[X0], a = cl((abs(s) - 0.04) / 0.32, 0, 1), tracer = i === 0 || i === S.n >> 1;\n    strainColour(S, s, 1, c);\n    if (tracer) (c[0] = 1), (c[1] = 0.95), (c[2] = 0.8);\n    const v = tracer ? 1 : 0.45 + 0.55 * a;\n    for (const [X, w] of [[X0, 1 - fr], [(X0 + 1) % W, fr]]) {\n      const o = row + X * 3, k = w * v;\n      const m = tracer ? 0 : 0.65 - 0.35 * a;\n      hist[o] = max(hist[o], (m + (1 - m) * c[0]) * k);\n      hist[o + 1] = max(hist[o + 1], (m + (1 - m) * c[1]) * k);\n      hist[o + 2] = max(hist[o + 2], (m + (1 - m) * c[2]) * k);\n    }\n  }\n}\n\nfunction advance(S, d) {\n  const steps = max(1, round((d * TS) / DT)), h = (d * TS) / steps;\n  for (let k = 0; k \u003c steps; k++) step(S, h);\n  S.rowT += d;\n  while (S.rowT >= ROW_T) {\n    S.rowT -= ROW_T;\n    record(S);\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0.86, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.K = cl(kv[3], 1, 4);\n  if (input.btnPressed && input.btnPressed[1]) S.dir = -S.dir;\n  const dr = cl(kv[1], 0, 3);\n  S.F = (S.dir * (0.04 * dr + 0.1 * dr * dr)) / TAU;\n  const n = cl(round(M / cl(kv[2], 0.86, 1.2)), 10, 14);\n  if (n !== S.n) load(S, n);\n  if (!S.started) {\n    S.started = true;\n    for (let f = 0; f \u003c HR * 3; f++) advance(S, 1 / 30);\n  }\n  advance(S, d);\n}\n\nfunction surface(S, X) {\n  const u = (X + 0.5) / P - 0.5, A = 3 + 1.25 * S.K;\n  return YB - (A * (1 - cos(TAU * u))) / 2;\n}\n\nfunction plot(rgb, X, Y, r, g, b, a) {\n  if (Y \u003c 0 || Y >= H || a \u003c= 0) return;\n  X = ((X % W) + W) % W;\n  const o = (Y * W + X) * 3;\n  rgb[o] = max(rgb[o], r * a);\n  rgb[o + 1] = max(rgb[o + 1], g * a);\n  rgb[o + 2] = max(rgb[o + 2], b * a);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, c = S.c, c2 = S.c2, n = S.n, x = S.x;\n  rgb.fill(0);\n  // The floor: a ridge line over a dim fill down to the valley floors.\n  hsv(0.64 + S.hue, 0.55, 1, c2);\n  for (let X = 0; X \u003c W; X++) {\n    const ys = surface(S, X);\n    for (let Y = floor(ys) + 1; Y \u003c= YB + 2; Y++) plot(rgb, X, Y, c2[0], c2[1], c2[2], 0.3 - 0.15 * cl((Y - ys) / 8, 0, 1));\n    plot(rgb, X, floor(ys), c2[0], c2[1], c2[2], 0.55 + 0.45 * (1 - (ys - floor(ys))));\n  }\n  // Bonds between the balls, coloured by their stretch, then the balls.\n  const sm = strainRow(S);\n  const bx = (i) => P * x[i] + P / 2 - 0.5;\n  const by = (X) => surface(S, ((X % W) + W) % W) - 1.8;\n  for (let i = 0; i \u003c n; i++) {\n    const xa = bx(i), xb = i \u003c n - 1 ? bx(i + 1) : bx(0) + W, ya = by(xa), yb = by(xb);\n    strainColour(S, (xb - xa) / P - 1, 1, c);\n    const len = max(2, Math.ceil(abs(xb - xa) + abs(yb - ya)) * 2);\n    for (let k = 0; k \u003c= len; k++) {\n      const t = k / len;\n      plot(rgb, round(xa + (xb - xa) * t), round(ya + (yb - ya) * t), c[0], c[1], c[2], 0.8);\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const X = bx(i), Y = by(X);\n    strainColour(S, sm[((round(X) % W) + W) % W], 1, c);\n    if (i === 0 || i === n >> 1) (c[0] = 1), (c[1] = 0.95), (c[2] = 0.8);\n    for (let yy = floor(Y - 3); yy \u003c= Math.ceil(Y + 3); yy++)\n      for (let xx = floor(X - 3); xx \u003c= Math.ceil(X + 3); xx++) {\n        const e2 = (xx - X) * (xx - X) + (yy - Y) * (yy - Y), a = cl(2.2 - e2 / 2.4, 0, 1);\n        const w = cl(1 - e2 / 3, 0, 1);\n        plot(rgb, xx, yy, c[0] + (1 - c[0]) * w, c[1] + (1 - c[1]) * w, c[2] + (1 - c[2]) * w, a);\n      }\n  }\n  // The history, oldest row on top.\n  for (let r = 0; r \u003c HR; r++) {\n    const src = ((S.head + 1 + r) % HR) * W * 3, dst = r * W * 3;\n    for (let k = 0; k \u003c W * 3; k++) rgb[dst + k] = S.hist[src + k];\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = (Y * W + X) * 3;\n      display.setPixel(X, Y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n    }\n}\n","granular-leidenfrost":"// ===== Patternflow pattern =====\n// Title:   Granular Leidenfrost\n// Family:  particle\n// Idea:    A tall box of inelastic grains four LEDs across stands on a floor that strikes every grain landing on it, and past a strength of shaking the grains part into a cold cluster packed as a crystal, some twenty layers of grains, floating on a thin hot gas of grains the floor keeps throwing up, the way a drop rides its own vapour on a hot plate; gentler shaking lets the cluster settle into a bed on the floor, harder shaking presses it to the lid, and more elastic grains melt it into gas.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the granular Leidenfrost effect (Peter Eshuis, Ko van der Weele, Devaraj van der Meer and Detlef Lohse, \"Granular Leidenfrost Effect: Experiment and Theory of Floating Particle Clusters\", Physical Review Letters 95, 258001, 2005), named after the drop on a hot plate (Johann Gottlob Leidenfrost, 1756), pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Shaking=0.5..3, Restitution=0.88..0.98, Grains=320..440\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 a cold grain is teal (27, 133, 179) and the hotter it is the further it turns, through violet to a pale pink (255, 128, 181) with a glow round the hottest; heat runs on a log scale from a grain moving at 1/18 of the floor's speed to one moving at it. At 0.25 cold is purple and hot pale yellow, at 0.5 cold is rust and hot mint, at 0.75 cold is green and hot lavender.\n// Knob 2: Shaking. The floor's speed U is 52 LEDs a second times the knob, under a gravity of 40 LEDs a second squared, so U squared over g and a grain's width, the shaking strength, is 4 at 0.5, 68 at the opening 2 and 152 at 3. At 0.5 the grains lie as a bed on the floor 76 LEDs deep with only its bottom rows warm; at 2 the crystal's underside rides about 40 LEDs above the floor on the gas with its top near row 30; at 3 it floats from 60 LEDs up and is pressed toward the lid.\n// Knob 3: Restitution. The share of their closing speed two grains keep when they collide, 0.88 at the opening. More elastic grains lose less inside the crystal, so it warms and rises: at 0.93 it floats from 64 to 116 LEDs up, and at 0.98 it melts into a gas that thins from the lid down, its top grains moving at a third of the floor's speed.\n// Knob 4: Grains. 320 to 440 in tens, 20 to 27.5 layers of 16. A new count starts a fresh box with 85% of the grains packed in rows from 52 LEDs up and the rest scattered under them. A heavier crystal sinks onto a thinner gas: 440 grains float from 28 LEDs up and stand to 116.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, exp, log10 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Lengths in LEDs, time in the panel's seconds. z counts up from the floor,\n// the top edge of the bottom row, to the lid, the top edge of row 0. Grains\n// are hard disks of radius R, 16 to a layer across the 64 columns.\nconst ZTOP = H - 1, R = 2, D = 2 * R, NMAX = 440;\nconst GRAV = 40;\n// The floor is a sawtooth driver in the limit of a small, fast stroke: it\n// stays at z = 0 and always meets a grain moving up at U, so a grain\n// landing at speed v leaves at U + E_FLOOR (U + v), with up to 15% of that\n// impact turned sideways by the floor's roughness.\nconst U_PER = 52, E_FLOOR = 0.8, E_WALL = 0.9, ROUGH = 0.15;\n// A substep is at most 1/240 s and short enough that the fastest grain\n// moves at most 1.2 LEDs in it, under a third of its width.\nconst SUBSTEP = 1 / 240, REACH = 1.2;\n// Grains are drawn a little smaller than they are, so a packed cluster\n// shows as grains and not as a slab.\nconst RD = 1.6;\n\nexport function setup(params) {\n  params.s = {\n    n: 0, hue: 0, U: 0, e: 0.88,\n    x: new Float32Array(NMAX), z: new Float32Array(NMAX), vx: new Float32Array(NMAX), vz: new Float32Array(NMAX),\n    heat: new Float32Array(NMAX),\n    head: new Int32Array(16 * 33), next: new Int32Array(NMAX),\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// A fresh box: 85% of the grains packed in staggered rows from 52 LEDs up,\n// the rest scattered under them as a gas, so the first seconds already\n// show a cluster settling onto its gas rather than a heap waking up.\nfunction start(S, n) {\n  S.n = n;\n  const per = W / D;\n  let i = 0;\n  for (let r = 0; i \u003c n * 0.85; r++)\n    for (let c = 0; c \u003c per && i \u003c n; c++, i++) {\n      S.x[i] = R + c * D + (r & 1 ? R * 0.5 : 0);\n      S.z[i] = 52 + r * D * 0.9;\n      S.vx[i] = (Math.random() - 0.5) * 4;\n      S.vz[i] = 0;\n    }\n  for (; i \u003c n; i++) {\n    S.x[i] = R + Math.random() * (W - D);\n    S.z[i] = R + Math.random() * 44;\n    S.vx[i] = (Math.random() - 0.5) * 80;\n    S.vz[i] = (Math.random() - 0.5) * 80;\n  }\n  S.heat.fill(0);\n}\n\n// One substep. Grains collide as hard disks with restitution e along the\n// line of centres, found through a grid of cells one grain across; any\n// overlap left is pushed apart along the same line.\nfunction step(S, h) {\n  const { x, z, vx, vz, head, next, n, U, e } = S;\n  for (let i = 0; i \u003c n; i++) {\n    vz[i] -= GRAV * h;\n    x[i] += vx[i] * h;\n    z[i] += vz[i] * h;\n    if (z[i] \u003c R) {\n      z[i] = R;\n      const s = U - vz[i];\n      if (s > 0) {\n        vz[i] = U + E_FLOOR * s;\n        vx[i] += (Math.random() - 0.5) * 2 * ROUGH * s;\n      }\n    } else if (z[i] > ZTOP - R) {\n      z[i] = ZTOP - R;\n      if (vz[i] > 0) vz[i] = -E_WALL * vz[i];\n    }\n    if (x[i] \u003c R) (x[i] = R), (vx[i] = abs(vx[i]) * E_WALL);\n    else if (x[i] > W - R) (x[i] = W - R), (vx[i] = -abs(vx[i]) * E_WALL);\n  }\n  const CW = W / D, CH = 33;\n  head.fill(-1);\n  for (let i = 0; i \u003c n; i++) {\n    const c = cl(floor(z[i] / D), 0, CH - 1) * CW + cl(floor(x[i] / D), 0, CW - 1);\n    next[i] = head[c];\n    head[c] = i;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const cx = cl(floor(x[i] / D), 0, CW - 1), cz = cl(floor(z[i] / D), 0, CH - 1);\n    for (let gz = max(0, cz - 1); gz \u003c= min(CH - 1, cz + 1); gz++)\n      for (let gx = max(0, cx - 1); gx \u003c= min(CW - 1, cx + 1); gx++)\n        for (let j = head[gz * CW + gx]; j >= 0; j = next[j]) {\n          if (j \u003c= i) continue;\n          const dx = x[j] - x[i], dz = z[j] - z[i], d2 = dx * dx + dz * dz;\n          if (d2 >= D * D || d2 \u003c 1e-9) continue;\n          const d = sqrt(d2), nx = dx / d, nz = dz / d;\n          const vn = (vx[j] - vx[i]) * nx + (vz[j] - vz[i]) * nz;\n          if (vn \u003c 0) {\n            const J = (-(1 + e) * vn) / 2;\n            vx[i] -= J * nx;\n            vz[i] -= J * nz;\n            vx[j] += J * nx;\n            vz[j] += J * nz;\n          }\n          const o = (D - d) / 2;\n          x[i] -= o * nx;\n          z[i] -= o * nz;\n          x[j] += o * nx;\n          z[j] += o * nz;\n        }\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0.88, 320], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.U = U_PER * cl(kv[1] ?? 2, 0.5, 3);\n  S.e = cl(kv[2] ?? 0.88, 0.88, 0.98);\n  const n = round(cl(kv[3] ?? 320, 320, 440) / 10) * 10;\n  if (n !== S.n) start(S, n);\n  let vm = 0;\n  for (let i = 0; i \u003c S.n; i++) vm = max(vm, S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]);\n  const sub = min(48, max(1, ceil(d / SUBSTEP), ceil((d * (sqrt(vm) + 3 * S.U)) / REACH)));\n  for (let k = 0; k \u003c sub; k++) step(S, d / sub);\n  // Each grain's heat, its squared speed smoothed over 0.375 s.\n  const a = 1 - exp(-d / 0.375);\n  for (let i = 0; i \u003c S.n; i++) S.heat[i] += a * (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i] - S.heat[i]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, c = S.c, U2 = S.U * S.U;\n  rgb.fill(0);\n  for (let i = 0; i \u003c S.n; i++) {\n    // Heat on a log scale against the floor's speed: 0 for a grain moving\n    // at 1/18 of U or slower, 1 for one moving at U.\n    const heat = cl(log10(max(1e-6, S.heat[i] / U2)) / 2.5 + 1, 0, 1);\n    hsv(0.55 + S.hue + 0.38 * heat, 0.85 - 0.35 * heat, 1, c);\n    const px = S.x[i], py = ZTOP - S.z[i], gl = 0.4 * heat * heat, rr = RD + (gl > 0.02 ? 3 : 0.6), body = 0.7 + 0.3 * heat;\n    for (let y = max(0, floor(py - rr)); y \u003c= min(H - 1, floor(py + rr)); y++)\n      for (let x = max(0, floor(px - rr)); x \u003c= min(W - 1, floor(px + rr)); x++) {\n        const dd = sqrt((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2);\n        const v = body * cl(RD + 0.5 - dd, 0, 1) + gl * exp(-max(0, dd - RD) / 1.4), o = (y * W + x) * 3;\n        rgb[o] += c[0] * v;\n        rgb[o + 1] += c[1] * v;\n        rgb[o + 2] += c[2] * v;\n      }\n  }\n  // The floor, the bottom row, brighter the faster it strikes.\n  const fl = 0.25 + (0.2 * S.U) / (3 * U_PER);\n  for (let x = 0, o = (H - 1) * W * 3; x \u003c W; x++, o += 3) (rgb[o] += fl * 0.9), (rgb[o + 1] += fl * 0.9), (rgb[o + 2] += fl);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","hellschreiber":"// ===== Patternflow pattern =====\n// Title:   Hellschreiber\n// Family:  type\n// Idea:    A Hellschreiber receiver prints a radio message onto paper tape a column at a time and the tape is cut between words and pasted strip under strip on a slate form: each column of a letter comes in as tone on and off from the bottom up, and the turning helix prints it twice, one copy above the other, so when the receiver's clock runs slow or fast the line slides down or up the tape and wraps from one copy into the other while one whole copy can always be read, and noise, fading and static crashes print as speckle, pale letters and short dashes the eye reads past; when the seventh strip is full the form slides up a slot.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Hellschreiber (Rudolf Hell, patented 1929) and the Feld-Hell timing of 122.5 baud, 7 columns a letter and 2.5 letters a second, each column sent from the bottom up; bold 5 by 7 capitals drawn for this pattern; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Paper=0..1, Speed=0.2..3, Noise=0..1, Drift=-1..1\n//\n// Knob 1: Paper. Turns form, tape and ink round the wheel together: at 0 cream tape with navy ink on a slate blue form and a gold print head; at 0.25 pale mint tape with plum ink on a purple form; at 0.5 pale blue tape with olive ink on a brown form; at 0.75 pink tape with dark green ink on a green form.\n// Knob 2: Speed. Columns a second, 8.75 times the knob: Feld-Hell's 17.5 (2.5 letters) at 2, so a strip of nine letters takes 3.6 s; 1.75 at 0.2 and 26 at 3. The form slides up a slot in 0.45 s, faster above 2.\n// Knob 3: Noise. The band's noise against a signal of 1: 0.19 rms at 0, where 2% of the blank tape takes a grey speck, up to 0.56 at 1, where a quarter of it does and 29% of the ink drops out; with it the fading deepens from 12% to 57% and static crashes, 1.5 to 5 rows of solid ink, come from one in 170 columns to one in 15. Both copies are printed at the same instant, so every speck and crash is printed twice.\n// Knob 4: Drift. The receiver's clock against the sender's, from 4% fast at -1 to 4% slow at 1. At the opening 0.06 it is 0.24% slow and the line steps down one row about every strip, a whole copy over the seven strips of the form; at 1 it falls a whole copy every 25 columns, so the letters slant down the tape and each wraps from the lower copy into the upper one; turned below 0 the line climbs instead.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The face: 5 columns by 7 rows, rows from the top, drawn bold for\n// this pattern, the letters and figures the messages use. Feld-Hell sends a\n// letter as 7 columns, the glyph's 5 and 2 blank; a space here is 7 blank\n// columns. The upright strokes are two columns wide, so when the receiver\n// is out of phase and a glyph's lower rows land one column to the left of\n// its upper rows (the print's own slant, on a tape one LED a column), the\n// stroke still joins.\nconst FACE = {\n  A: \".###.##.####.#########.####.####.##\", B: \"####.##.####.######.##.####.######.\", C: \".######...##...##...##...##....####\",\n  D: \"####.##.####.####.####.####.######.\", E: \"#######...##...####.##...##...#####\", F: \"#######...##...####.##...##...##...\",\n  G: \".######...##...##.####.####.##.####\", H: \"##.####.####.#########.####.####.##\", I: \"####..##...##...##...##...##..####.\",\n  J: \"..###...##...##...##...####.##.###.\", K: \"##..###.######.###..####.##.####..#\", L: \"##...##...##...##...##...##...#####\",\n  M: \"#...###.########.#.##...##...##...#\", N: \"#...###..####.##.####..###...##...#\", O: \".###.##.####.####.####.####.##.###.\",\n  P: \"####.##.####.######.##...##...##...\", Q: \".###.##.####.####.#########.#..##.#\", R: \"####.##.####.######.####.##.####.##\",\n  S: \".######...##....###....##...######.\", T: \"#####.##...##...##...##...##...##..\", U: \"##.####.####.####.####.####.##.###.\",\n  V: \"##.####.####.####.####.##.###...#..\", W: \"#...##...##.#.##.#.########.###...#\", X: \"##.####.##.###...#...###.##.####.##\",\n  Y: \"##.####.##.###..##...##...##...##..\", Z: \"#####...##..##..##..##...##...#####\", 1: \".##..###...##...##...##...##..####.\",\n  2: \".###.##.##...##..##..##..##...#####\", 5: \"#######...####....##...####.##.###.\", 7: \"#####...##..##..##...##...##...##..\",\n  9: \".###.##.####.##.####...##..##..##..\", \".\": \"..........................##...##..\", \"-\": \"...............####................\",\n};\n\n// Each glyph as 5 column masks, bit r the row r counted from the bottom,\n// since every column is sent from the bottom up.\nconst GLYPH = {};\nfor (const k in FACE) {\n  const f = FACE[k], cols = [];\n  for (let c = 0; c \u003c 5; c++) {\n    let m = 0;\n    for (let r = 0; r \u003c 7; r++) if (f[(6 - r) * 5 + c] === \"#\") m |= 1 \u003c\u003c r;\n    cols.push(m);\n  }\n  GLYPH[k] = cols;\n}\n\n// ---- What is sent: the teleprinter test line, then the machine's own\n// numbers. A message starts a fresh strip of tape; inside one, a strip holds\n// whole words up to 9 letters and is cut in the space after the last.\nconst MESSAGES = [\"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG\", \"RUDOLF HELL 1929\", \"FELD-HELL 122.5 BAUD\", \"7 COLUMNS A LETTER\", \"2.5 CHARS A SECOND\"];\nconst CAP = 9;\n// The column stream of one round of the messages, and the plan of strips\n// as [first column, end column) in it: one blank column of tape before the\n// first glyph, one after the last. Messages are 14 blank columns apart.\nconst COLS = [], PLAN = [];\nfor (const msg of MESSAGES) {\n  const words = msg.split(\" \");\n  let line = [];\n  const flush = () => {\n    if (!line.length) return;\n    const start = COLS.length;\n    line.forEach((w, i) => {\n      if (i) for (let c = 0; c \u003c 7; c++) COLS.push(0);\n      for (const ch of w) {\n        for (const m of GLYPH[ch]) COLS.push(m);\n        COLS.push(0, 0);\n      }\n    });\n    PLAN.push([start - 1, COLS.length - 1]);\n    for (let c = 0; c \u003c 5; c++) COLS.push(0);\n    line = [];\n  };\n  for (const w of words) {\n    const n = line.reduce((a, x) => a + x.length + 1, 0) + w.length;\n    if (n > CAP) flush();\n    line.push(w);\n  }\n  flush();\n  for (let c = 0; c \u003c 7; c++) COLS.push(0);\n}\nconst L = COLS.length;\n\n// ---- The form: seven slots of 18 rows from row 1, each a strip of tape 16\n// rows high (a blank row, the 14 rows the helix prints, a blank row) and a\n// gap of 2 rows of form.\nconst SLOT = 18, TAPE = 16, SLOTS = 7;\n// Feld-Hell turns 17.5 columns a second, 2.5 letters of 7 columns.\nconst COLS_PER_S = 17.5;\n\nconst hash = (a, b) => {\n  let h = Math.imul(a, 374761393) + Math.imul(b, 668265263);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction gauss() {\n  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n}\n\nfunction newStrip(S) {\n  const [a, b] = PLAN[S.pi];\n  const base = S.cyc * L;\n  // The receiver keeps turning while the tape that is cut away runs out.\n  while (S.phi \u003c base + a) S.phi += S.rho;\n  S.strips.push({ id: S.made, x0: 1 + floor(hash(S.made, 7) * 3), end: base + b, len: 0, ink: new Float32Array(W * 7) });\n  S.made++;\n}\n\n// One turn of the helix: one column of tape, the signal from sender time\n// phi to phi + rho, its 7 rows printed twice, one copy above the other.\n// Row y of the column is what the helix hears a fraction (y + 1/2) / 7 of\n// the way through the turn; when rho is not 1 that drifts through the\n// sender's rows from turn to turn.\nfunction turn(S) {\n  const st = S.strips[S.strips.length - 1], rho = S.rho, k = st.len;\n  for (let y = 0; y \u003c 7; y++) {\n    const t = S.phi + (rho * (y + 0.5)) / 7, c = floor(t), r = floor((t - c) * 7);\n    const bit = (COLS[((c % L) + L) % L] >> r) & 1;\n    // Fading: a slow swell of two periods, 140 and 53 columns.\n    const fade = 1 - S.depth * (0.5 + 0.5 * sin((2 * PI * t) / 140 + 1.3 * sin((2 * PI * t) / 53)));\n    let a = bit * fade + S.sigma * gauss();\n    if (t >= S.c0 && t \u003c S.c1) a += S.ca;\n    st.ink[k * 7 + y] = cl((a - 0.3) / 0.45, 0, 1);\n  }\n  // A static crash: a burst of 1.5 to 5 rows, somewhere in the next turn.\n  if (Math.random() \u003c S.crash) {\n    S.c0 = S.phi + rho * (1 + Math.random());\n    S.c1 = S.c0 + 0.2 + 0.5 * Math.random();\n    S.ca = 0.8 + 0.6 * Math.random();\n  }\n  st.len++;\n  S.phi += rho;\n  // The strip is cut one blank column after its last glyph, or at the edge.\n  if (S.phi >= st.end || st.x0 + st.len >= W - 1) {\n    if (++S.pi === PLAN.length) (S.pi = 0), S.cyc++;\n    newStrip(S);\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    strips: [], made: 0, pi: 0, cyc: 0, phi: PLAN[0][0] - 0.06, rho: 1, acc: 0, scroll: 0, ready: false,\n    hue: 0, speed: 2, sigma: 0.2, crash: 0.01, depth: 0.1, c0: -1, c1: -1, ca: 0,\n    buf: new Float32Array(W * H * 3),\n  };\n  newStrip(params.s);\n  return params.s;\n}\n\nfunction knobs(S, k) {\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] ?? 2, 0.2, 3);\n  const n = cl(k[2] || 0, 0, 1), dr = cl(k[3] ?? 0.06, -1, 1);\n  S.sigma = 0.19 + 0.37 * n;\n  S.crash = 0.006 + 0.06 * n;\n  S.depth = 0.12 + 0.45 * n;\n  // The receiver's turn against the sender's column: up to 4% slow or fast.\n  S.rho = 1 + 0.04 * dr;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const d = cl(dt || 0, 0, 0.1);\n  knobs(S, input.knobValues || [0, 2, 0, 0.06]);\n  if (!S.ready) {\n    // The form opens with five strips already pasted.\n    S.ready = true;\n    while (S.strips.length \u003c 6) turn(S);\n  }\n  S.acc += (d * COLS_PER_S * S.speed) / 2;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    turn(S);\n  }\n  // When the seventh slot is full the form slides up a slot in 0.45 s and\n  // the top strip leaves it.\n  const target = max(0, S.strips.length - SLOTS);\n  S.scroll = min(target, S.scroll + d * 2.2 * max(1, S.speed / 2));\n  while (S.scroll >= 1) {\n    S.strips.shift();\n    S.scroll -= 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const h = S.hue, buf = S.buf;\n  const F = hsv(0.58 + h, 0.42, 0.4), R = hsv(0.58 + h, 0.32, 0.52), P = hsv(0.11 + h, 0.1, 0.97), I = hsv(0.66 + h, 0.8, 0.24);\n  const HD = hsv(0.12 + h, 0.55, 1);\n  // The form, with a ruled line in the middle of each gap.\n  const off = S.scroll * SLOT;\n  for (let y = 0; y \u003c H; y++) {\n    const ry = (((y + off - 17.5) % SLOT) + SLOT) % SLOT;\n    const C = ry \u003c 1 ? R : F;\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3;\n      buf[p] = C[0];\n      buf[p + 1] = C[1];\n      buf[p + 2] = C[2];\n    }\n  }\n  const last = S.strips.length - 1;\n  S.strips.forEach((st, j) => {\n    const Y = Math.round(1 + SLOT * (j - S.scroll));\n    if (Y > H || Y + TAPE + 1 \u003c 0) return;\n    const x1 = st.x0 + st.len;\n    // Shadow under and right of the pasted strip.\n    for (let y = Y + 1; y \u003c= Y + TAPE; y++)\n      for (let x = st.x0 + 1; x \u003c= x1; x++) {\n        if (y \u003c 0 || y >= H || x >= W) continue;\n        if (y === Y + TAPE || x === x1) {\n          const p = (y * W + x) * 3;\n          buf[p] *= 0.55;\n          buf[p + 1] *= 0.55;\n          buf[p + 2] *= 0.55;\n        }\n      }\n    for (let y = Y; y \u003c Y + TAPE; y++) {\n      if (y \u003c 0 || y >= H) continue;\n      const pr = Y + 14 - y, row = pr >= 0 && pr \u003c 14 ? pr % 7 : -1;\n      for (let x = st.x0; x \u003c x1; x++) {\n        const k = x - st.x0, ink = row >= 0 ? st.ink[k * 7 + row] : 0, f = 0.93 + 0.07 * hash(st.id * 64 + k, y - Y);\n        const p = (y * W + x) * 3;\n        buf[p] = P[0] * f * (1 - ink) + I[0] * ink;\n        buf[p + 1] = P[1] * f * (1 - ink) + I[1] * ink;\n        buf[p + 2] = P[2] * f * (1 - ink) + I[2] * ink;\n      }\n    }\n    if (j === last) {\n      // The print head at the next column: a bar over the tape, and the two\n      // points where the helix touches it, one turn's progress up the copy.\n      const hx = min(W - 1, x1), ph = floor(S.acc * 7);\n      for (let y = Y - 1; y \u003c= Y + TAPE; y++) {\n        if (y \u003c 0 || y >= H) continue;\n        const p = (y * W + hx) * 3, dot = y === Y + 14 - ph || y === Y + 7 - ph;\n        buf[p] = dot ? 1 : HD[0];\n        buf[p + 1] = dot ? 1 : HD[1];\n        buf[p + 2] = dot ? 1 : HD[2];\n      }\n    }\n  });\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * buf[p]) | 0, (255 * buf[p + 1]) | 0, (255 * buf[p + 2]) | 0);\n    }\n}\n","hexachordal-theorem":"// ===== Patternflow pattern =====\n// Title:   Hexachordal Theorem\n// Family:  rhythm\n// Idea:    Six onsets in a cycle of twelve pulses play in the upper ring and the other six, the complementary rhythm, in the lower one, so every pulse sounds in exactly one of them; each pair of onsets is a chord across its ring coloured by how many pulses apart they are, and between the rings the pairs are counted into bars, the first rhythm's standing up and the complement's hanging down, and once a cycle an onset steps onto the rest beside it, the chords and bars change and the bars stay mirror images, as the hexachordal theorem says they must.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hexachordal theorem, that six of the twelve pitch classes and the other six have the same interval content (Milton Babbitt, 1950s; David Lewin, Journal of Music Theory, 1959 and 1960), read as rhythm (Godfried Toussaint, The Geometry of Musical Rhythm, 2013); the opening set is 6-Z44 of Allen Forte's list (1973), the Schoenberg hexachord, whose complement is 6-Z19; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pulses=12..20, Uneven=0..3\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the first rhythm's onsets are pale amber and the complement's pale azure, and the distances 1 to 6 run yellow, green, sea green, azure, violet and pink; at 0.5 the onsets are pale blue and pale peach and the distances run blue, violet, rose, orange, yellow-green and sea green.\n// Knob 2: Speed. Pulses a second, twice the knob: 4 at 2, so a cycle of 12 takes 3 s and the rhythm moves once every 3 s; 0.4 at 0.2 (30 s a cycle), 6 at 3 (2 s). An onset that sounds swells, sends out a ring that widens to about 19 LEDs across as it fades, lights its chords and their blocks in the bars, and the light dies away in about 0.2 s.\n// Knob 3: Pulses. The length of the cycle in even steps, 12, 14, 16, 18 or 20, with half the pulses in each rhythm, so 6 to 10 columns for the distances 1 to n/2 and 15 to 45 pairs a rhythm. The theorem holds for any even cycle filled half and half: of the 924 ways to choose 6 pulses of 12, 552 have a complement that is no turn or mirror image of them, and the bars still match; of the 12,870 ways to choose 8 of 16, 10,768.\n// Knob 4: Uneven. Moves 0 to 3 onsets from the first rhythm to its complement, 5 against 7, 4 against 8 and 3 against 9 on twelve pulses, and the mirror breaks in the plainest way: the complement's bars grow by exactly 2 blocks a column for each onset moved, and the last column, the half cycle, by 1, the extra blocks drawn pale.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [(i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255, (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255, (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255];\n}\n\n// The first rhythm plays in the ring at the top, its complement in the ring\n// at the bottom, and between them each distance between two onsets of a\n// rhythm is a block in a bar: the first rhythm's bars stand up from the\n// middle row, the complement's hang down.\nconst RING = [[32, 20], [32, 108]], R = 15.5, UP = 59, DOWN = 68;\n\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\n\n// The interval vector: how many pairs of onsets lie each distance apart\n// round the cycle, distance being the shorter way, 1 to n/2. who is 1 for\n// the first rhythm, 0 for its complement.\nfunction pairsOf(memb, n, who) {\n  const m = n / 2, by = [];\n  for (let d = 0; d \u003c= m; d++) by.push([]);\n  for (let i = 0; i \u003c n; i++)\n    if (memb[i] === who)\n      for (let j = i + 1; j \u003c n; j++)\n        if (memb[j] === who) {\n          const d = min(j - i, n - j + i);\n          by[d].push([i, j]);\n        }\n  return by;\n}\n\nfunction rebuild(S) {\n  const n = S.n, m = n / 2, a = m - S.k;\n  S.memb = new Int8Array(n);\n  if (n === 12 && S.k === 0 && !S.opened) {\n    // The opening hexachord, x x x . . x x . . x . . as a rhythm. Its\n    // complement is no turn or mirror image of it, and has the same bars.\n    for (const s of [0, 1, 2, 5, 6, 9]) S.memb[s] = 1;\n    S.opened = true;\n  } else {\n    const idx = Array.from({ length: n }, (_, i) => i);\n    for (let i = n - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [idx[i], idx[j]] = [idx[j], idx[i]];\n    }\n    for (let i = 0; i \u003c a; i++) S.memb[idx[i]] = 1;\n  }\n  S.off = new Float32Array(n);\n  S.mt = new Float32Array(n).fill(-9);\n  S.flip = new Float32Array(n).fill(-9);\n  S.fl = new Float32Array(n);\n  S.last = -1;\n  count(S);\n  S.dA = S.vA.slice();\n  S.dB = S.vB.slice();\n}\n\nfunction count(S) {\n  S.pA = pairsOf(S.memb, S.n, 1);\n  S.pB = pairsOf(S.memb, S.n, 0);\n  S.vA = S.pA.map((l) => l.length);\n  S.vB = S.pB.map((l) => l.length);\n}\n\n// One move a cycle: an onset of the first rhythm and the rest beside it\n// change places, so one onset of each rhythm steps one pulse. The move that\n// changes the bars is taken where there is one, and never the one that\n// would undo the move before.\nfunction move(S) {\n  const n = S.n, cand = [];\n  for (let i = 0; i \u003c n; i++)\n    if (S.memb[i] === 1)\n      for (const j of [(i + 1) % n, (i + n - 1) % n])\n        if (S.memb[j] === 0 && !(S.last >= 0 && ((S.lastA === j && S.lastB === i) || (S.lastA === i && S.lastB === j)))) cand.push([i, j]);\n  if (!cand.length) return;\n  const before = S.vA.join();\n  const changing = cand.filter(([i, j]) => {\n    S.memb[i] = 0, S.memb[j] = 1;\n    const v = pairsOf(S.memb, n, 1).map((l) => l.length).join();\n    S.memb[i] = 1, S.memb[j] = 0;\n    return v !== before;\n  });\n  const pool = changing.length ? changing : cand;\n  const [i, j] = pool[floor(Math.random() * pool.length)];\n  S.memb[i] = 0;\n  S.memb[j] = 1;\n  // The dots slide the short way round, one pulse.\n  const dj = (i - j + n) % n === 1 ? 1 : -1;\n  S.off[j] = dj;\n  S.off[i] = -dj;\n  S.mt[i] = S.mt[j] = S.time;\n  S.last = 1;\n  S.lastA = j;\n  S.lastB = i;\n  count(S);\n}\n\n// Uneven moves onsets from the first rhythm to its complement, one change\n// of colour each.\nfunction balance(S) {\n  const n = S.n, want = n / 2 - S.k;\n  let a = 0;\n  for (let i = 0; i \u003c n; i++) a += S.memb[i];\n  while (a !== want) {\n    const from = a > want ? 1 : 0, opts = [];\n    for (let i = 0; i \u003c n; i++) if (S.memb[i] === from) opts.push(i);\n    const s = opts[floor(Math.random() * opts.length)];\n    S.memb[s] = 1 - from;\n    S.flip[s] = S.time;\n    a += from ? -1 : 1;\n  }\n  count(S);\n}\n\nexport function setup(params) {\n  params.hx = { n: 0, k: -1, P: 0, pulse: -1, time: 0, opened: false, buf: new Float32Array(N * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.hx) setup(params);\n  const S = params.hx, kv = input.knobValues || [0, 2, 12, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = 2 * round(cl(kv[2], 12, 20) / 2), k = round(cl(kv[3], 0, 3));\n  if (n !== S.n) {\n    S.n = n;\n    S.k = k;\n    rebuild(S);\n  } else if (k !== S.k) {\n    S.k = k;\n    balance(S);\n  }\n  S.time += dt;\n  S.P += dt * S.speed * 2;\n  const pulse = floor(S.P);\n  if (pulse !== S.pulse) {\n    S.pulse = pulse;\n    const s = pulse % S.n;\n    if (s === 0 && pulse > 0) move(S);\n    S.fl[s] = 1;\n  }\n  const decay = exp(-dt / cl(0.85 / (S.speed * 2), 0.14, 0.7)), ease = 1 - exp(-dt / 0.25);\n  for (let i = 0; i \u003c S.n; i++) S.fl[i] *= decay;\n  for (let d = 0; d \u003c S.vA.length; d++) {\n    S.dA[d] += (S.vA[d] - S.dA[d]) * ease;\n    S.dB[d] += (S.vB[d] - S.dB[d]) * ease;\n  }\n}\n\nfunction plot(buf, x, y, c, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  if (c[0] * a > buf[p]) buf[p] = c[0] * a;\n  if (c[1] * a > buf[p + 1]) buf[p + 1] = c[1] * a;\n  if (c[2] * a > buf[p + 2]) buf[p + 2] = c[2] * a;\n}\n\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5));\n  for (let i = 0; i \u003c= n; i++) plot(buf, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, c, a);\n}\n\nfunction disc(buf, cx, cy, r, c, a) {\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const d = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      plot(buf, x, y, c, a * cl(r + 0.5 - d, 0, 1));\n    }\n}\n\nfunction ring(buf, cx, cy, r, c, a) {\n  const n = max(24, floor(r * 7));\n  for (let i = 0; i \u003c n; i++) plot(buf, cx + r * cos((2 * PI * i) / n), cy + r * sin((2 * PI * i) / n), c, a);\n}\n\nfunction digit(buf, x, y, v, c, a) {\n  const s = String(v);\n  let w = 0;\n  for (const ch of s) w += ch === \"1\" && s.length > 1 ? 2 : 4;\n  let cx = x - floor((w - 1) / 2);\n  for (const ch of s) {\n    const g = DIG[+ch], narrow = ch === \"1\" && s.length > 1;\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\" && !(narrow && q !== 1)) plot(buf, cx + q - (narrow ? 1 : 0), y + r, c, a);\n    cx += narrow ? 2 : 4;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.hx;\n  if (!S || !S.memb) return;\n  const buf = S.buf, n = S.n, m = n / 2, h0 = S.hue, t = S.time;\n  buf.fill(0);\n  const cA = hsv(h0 + 0.11, 0.5, 1), cB = hsv(h0 + 0.58, 0.5, 1), grey = hsv(h0 + 0.6, 0.25, 0.32);\n  const cls = [];\n  for (let d = 0; d \u003c= m; d++) cls.push(hsv(h0 + 0.15 + (0.77 * (d - 1)) / max(1, m - 1), 0.78, 1));\n  // Where each step's dot is drawn: a dot that has just moved slides there\n  // over 0.35 s.\n  const pos = (s, which) => {\n    const u = cl((t - S.mt[s]) / 0.35, 0, 1), e = u * u * (3 - 2 * u), q = s + S.off[s] * (1 - e);\n    const a = -PI / 2 + (2 * PI * q) / n, C = RING[which];\n    return [C[0] + R * cos(a), C[1] + R * sin(a)];\n  };\n  const head = S.P - floor(S.P / n) * n;\n  for (let w = 0; w \u003c 2; w++) {\n    const who = w === 0 ? 1 : 0, C = RING[w], P = w === 0 ? S.pA : S.pB, col = w === 0 ? cA : cB;\n    // A soft light spreads from an onset as it sounds, so the beat answers\n    // between the two rings from across the room.\n    for (let s = 0; s \u003c n; s++)\n      if (S.memb[s] === who && S.fl[s] > 0.04) {\n        const [x, y] = pos(s, w), f = S.fl[s];\n        for (let yy = max(0, floor(y - 13)); yy \u003c= min(H - 1, y + 13); yy++)\n          for (let xx = max(0, floor(x - 13)); xx \u003c min(W, x + 13); xx++) {\n            const d2 = (xx - x) ** 2 + (yy - y) ** 2;\n            if (d2 \u003c 169) plot(buf, xx, yy, col, 0.3 * f * exp(-d2 / 45));\n          }\n      }\n    ring(buf, C[0], C[1], R, grey, 1);\n    // Every pair of onsets is a chord, coloured by its distance, and lights\n    // when either end of it sounds; the rest of the ring's chords brighten a\n    // little with it, so the ring that is playing reads at a glance.\n    let rf = 0;\n    for (let s = 0; s \u003c n; s++) if (S.memb[s] === who && S.fl[s] > rf) rf = S.fl[s];\n    for (let d = 1; d \u003c= m; d++)\n      for (const [i, j] of P[d]) {\n        const [x0, y0] = pos(i, w), [x1, y1] = pos(j, w), f = max(S.fl[i], S.fl[j]);\n        line(buf, x0, y0, x1, y1, cls[d], 0.26 + 0.2 * rf + 0.54 * f);\n      }\n    for (let s = 0; s \u003c n; s++) {\n      const [x, y] = pos(s, w), fu = cl((t - S.flip[s]) / 0.4, 0, 1);\n      if (S.memb[s] === who) {\n        const f = S.fl[s];\n        disc(buf, x, y, 2.1 + 1.2 * f, col, (0.62 + 0.38 * f) * (0.3 + 0.7 * fu));\n        if (f > 0.05) ring(buf, x, y, 3 + 7 * (1 - f), col, 0.8 * f);\n      } else plot(buf, x, y, grey, 1.6);\n    }\n    // The beat, going round both rings at once with a tail one pulse long.\n    for (let j = 0; j \u003c= 16; j++) {\n      const a = -PI / 2 + (2 * PI * (head - j / 16)) / n;\n      plot(buf, C[0] + (R + 3) * cos(a), C[1] + (R + 3) * sin(a), [255, 255, 255], 0.9 * (1 - j / 17));\n    }\n    {\n      const a = -PI / 2 + (2 * PI * head) / n;\n      disc(buf, C[0] + (R + 3) * cos(a), C[1] + (R + 3) * sin(a), 0.9, [255, 255, 255], 0.9);\n    }\n  }\n  // The bars. Each block is one pair of onsets, the pairs of a distance\n  // stacked in order of their first onset; a block lights with its chord.\n  const slot = floor(62 / m), bw = slot - 2, x00 = floor((W - slot * m) / 2) + floor((slot - bw) / 2);\n  const hu = max(1, min(3, floor(19 / (m + S.k))));\n  for (let d = 1; d \u003c= m; d++) {\n    const x0 = x00 + (d - 1) * slot;\n    digit(buf, x0 + floor((bw - 1) / 2), 61, d, grey, 1.9);\n    for (let w = 0; w \u003c 2; w++) {\n      const v = w === 0 ? S.dA[d] : S.dB[d], P = w === 0 ? S.pA[d] : S.pB[d], other = w === 0 ? S.dB[d] : S.dA[d];\n      for (let b = 0; b \u003c Math.ceil(v - 0.02); b++) {\n        const part = min(1, v - b), pr = P[b], f = pr ? max(S.fl[pr[0]], S.fl[pr[1]]) : 0;\n        // Where one rhythm has more pairs than the other, the extra blocks\n        // are drawn pale: with Uneven at k they come to 2k in every column\n        // but the last, where they are k.\n        const extra = b >= other - 0.02, c = extra ? hsv(h0 + 0.6, 0.12, 1) : cls[d];\n        const rows = hu >= 2 ? hu - 1 : 1;\n        for (let r = 0; r \u003c rows * part; r++) {\n          const y = w === 0 ? UP - b * hu - r : DOWN + b * hu + r;\n          for (let x = x0; x \u003c x0 + bw; x++) plot(buf, x, y, c, (extra ? 0.55 : 0.5) + 0.5 * f);\n        }\n      }\n      // The count itself at the end of the bar, the interval vector read\n      // off one digit a column.\n      const tip = max(0, v) * hu, cnt = w === 0 ? S.vA[d] : S.vB[d];\n      digit(buf, x0 + floor((bw - 1) / 2), w === 0 ? round(UP - tip - 5) : round(DOWN + tip + 1), cnt, cls[d], 0.55);\n    }\n  }\n  for (let p = 0, i = 0; p \u003c N; p++, i += 3) display.setPixel(p % W, (p / W) | 0, 3 + buf[i], 4 + buf[i + 1], 10 + buf[i + 2]);\n}\n","ink-traps":"// ===== Patternflow pattern =====\n// Title:   Ink Traps\n// Family:  type\n// Idea:    Each sheet of newsprint is printed with one capital or figure twice, the upper one with ink traps cut into its joints and the lower one as drawn, and the ink then soaks out from the strokes into the paper, furthest where two strokes meet at a sharp angle, so the plain letter's crotches fill and its counters close while the trapped letter's notches fill back to the joints as they were drawn; then the sheet feeds up and the next letter is printed.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: ink traps as Matthew Carter cut them into Bell Centennial, drawn for AT&T's telephone directories at 6 point on newsprint and released by Mergenthaler Linotype in 1978; the wicking front that advances as the square root of time (Edward W. Washburn, 1921); pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Letters=0..2, Spread=-1..1\n//\n// Knob 1: Hue. The colour of the paper, the ink staying black: telephone-directory yellow (182, 164, 69) at 0, green at 0.25, blue at 0.5, pink at 0.75.\n// Knob 2: Speed. At 2 a sheet takes 6.4 s: the ink soaks for 3 s, its edge moving out as the square root of the time, the sheet holds 2.6 s and feeds up in 0.8 s. At 0.2 a sheet takes 64 s, at 3 it takes 4.3 s.\n// Knob 3: Letters. Which letters come round: 0 M, W, N and V (3, 3, 2 and 1 traps), 1 K, A, X, Y and Z, 2 the figures 4, 7 and 1. A new set feeds a fresh sheet at once.\n// Knob 4: Spread. How far the ink soaks. At the opening 0.06 the edge of a stroke moves out 1.5 LEDs, the spread the traps are cut for: every trapped joint prints within a LED of where it was drawn and the plain M's joints fill 6 to 12 LEDs out. At -1 the edge moves 0.5 LED, the plain M's joints fill 3 to 6 LEDs and the traps stay open as notches 4 to 8 LEDs deep. From 0.5 (2.1 LEDs) the traps fill shut and both letters clog alike, and at 1 (2.7 to 3 LEDs) the M's sharpest joints fill 20 LEDs out. Turning it down feeds a fresh sheet.\n\n// Bell Centennial (Matthew Carter for AT&T, 1978) was cut for 6 point type\n// printed fast on newsprint. Ink spreads into newsprint, and where two\n// strokes meet at a sharp angle the paper between them is near ink on both\n// sides, so the joint fills first and the letter clogs. Carter cut notches\n// into those joints, ink traps, so that the spreading ink fills the notch\n// and the joint comes out the way it was drawn. At display size the traps\n// show; at 6 point they fill.\n//\n// Here the panel is a magnifier, and the letters are plain straight-sided\n// capitals drawn for it, not Bell Centennial's own. The ink is a\n// concentration that diffuses into the paper, faster along the fibres,\n// which lie along the rows, and the paper turns dark wherever the\n// concentration passes 0.12. The variance of\n// the spread grows in proportion to the time, so the edge of a stroke moves\n// out as the square root of the time, the way a liquid wicks into a porous\n// sheet (Washburn, 1921). A straight edge moves out about 1.18 standard\n// deviations; a sharp corner fills further, since both strokes feed it.\n//\n// Each trap is the joint's own wedge pushed back into the ink by\n// D = 1.6 * (edge advance) / sin(half the angle), its sides then running\n// back to the drawn edges over the same length D. If every edge moved out\n// by the same distance, a factor of 1 would print the joint exactly where\n// it was drawn. Diffusion fills a sharp corner further than that, and 1.6\n// was found by printing the eleven joints of M, W, N and A at the opening\n// spread: at 1 every trap fills shut and the joint prints like the plain\n// one, 12 LEDs out on the M; at 1.4 some print within 1.5 LEDs and some\n// fill shut; at 1.6 all eleven print within a LED of the drawn vertex,\n// against 3.4 to 13.3 LEDs out for the plain letter; at 1.8 the notches\n// stay open 1 to 4 LEDs deep.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sin, cos, tan, exp, round, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The letters, drawn as convex pieces in a box 50 LEDs wide and 58\n// tall, x to the right and y down: R is a rectangle, P any convex polygon.\nconst GW = 50, GH = 58, GX = 7, GY = [2, 68];\nconst P = (...c) => {\n  const p = [];\n  for (let i = 0; i \u003c c.length; i += 2) p.push([c[i], c[i + 1]]);\n  let a = 0;\n  for (let i = 0; i \u003c p.length; i++) {\n    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % p.length];\n    a += x0 * y1 - x1 * y0;\n  }\n  return { p, o: a > 0 ? 1 : -1 };\n};\nconst R = (x0, y0, x1, y1) => P(x0, y0, x1, y0, x1, y1, x0, y1);\nconst GLYPHS = {\n  M: [R(0, 0, 10, 58), R(40, 0, 50, 58), P(0, 0, 11, 0, 30.5, 50, 19.5, 50), P(39, 0, 50, 0, 30.5, 50, 19.5, 50)],\n  W: [P(0, 0, 9, 0, 17.5, 58, 8.5, 58), P(20.5, 0, 29.5, 0, 17.5, 58, 8.5, 58), P(20.5, 0, 29.5, 0, 41.5, 58, 32.5, 58), P(41, 0, 50, 0, 41.5, 58, 32.5, 58)],\n  N: [R(0, 0, 10, 58), R(40, 0, 50, 58), P(0, 0, 12, 0, 50, 58, 38, 58)],\n  V: [P(0, 0, 11, 0, 30.5, 58, 19.5, 58), P(39, 0, 50, 0, 30.5, 58, 19.5, 58)],\n  K: [R(0, 0, 10, 58), P(36, 0, 50, 0, 6, 41, 6, 28.5), P(13, 24, 24, 24, 50, 58, 37, 58)],\n  A: [P(19.5, 0, 30.5, 0, 11, 58, 0, 58), P(19.5, 0, 30.5, 0, 50, 58, 39, 58), R(9, 36, 41, 44)],\n  X: [P(0, 0, 11, 0, 50, 58, 39, 58), P(39, 0, 50, 0, 11, 58, 0, 58)],\n  Y: [P(0, 0, 11, 0, 30, 32, 20, 32), P(39, 0, 50, 0, 30, 32, 20, 32), R(20, 30, 30, 58)],\n  Z: [R(0, 0, 50, 10), R(0, 48, 50, 58), P(36, 10, 50, 10, 14, 48, 0, 48)],\n  4: [R(31, 0, 41, 58), P(28, 0, 41, 0, 13, 37, 0, 37), R(0, 35, 50, 44)],\n  7: [R(0, 0, 50, 10), P(43, 0, 55, 0, 26, 58, 14, 58)],\n  1: [R(26, 0, 37, 58), P(31, 0, 31, 11, 13, 22, 9, 15)],\n};\nconst SETS = [[\"M\", \"W\", \"N\", \"V\"], [\"K\", \"A\", \"X\", \"Y\", \"Z\"], [\"4\", \"7\", \"1\"]];\n\nfunction inPoly(q, x, y) {\n  const p = q.p, n = p.length;\n  for (let i = 0; i \u003c n; i++) {\n    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % n];\n    if (q.o * ((x1 - x0) * (y - y0) - (y1 - y0) * (x - x0)) \u003c -1e-9) return false;\n  }\n  return true;\n}\nfunction ink(g, x, y) {\n  if (x \u003c 0 || x > GW || y \u003c 0 || y > GH) return false;\n  for (const q of g) if (inPoly(q, x, y)) return true;\n  return false;\n}\n\n// The joints: where an edge of one piece crosses an edge of another on the\n// outline of the letter and the paper between them is a wedge narrower than\n// 84 degrees.\nfunction crotches(g) {\n  const out = [];\n  for (let i = 0; i \u003c g.length; i++)\n    for (let j = i + 1; j \u003c g.length; j++)\n      for (let a = 0; a \u003c g[i].p.length; a++)\n        for (let b = 0; b \u003c g[j].p.length; b++) {\n          const [ax, ay] = g[i].p[a], [ax1, ay1] = g[i].p[(a + 1) % g[i].p.length];\n          const [bx, by] = g[j].p[b], [bx1, by1] = g[j].p[(b + 1) % g[j].p.length];\n          const dax = ax1 - ax, day = ay1 - ay, dbx = bx1 - bx, dby = by1 - by;\n          const den = dax * dby - day * dbx;\n          if (abs(den) \u003c 1e-9) continue;\n          const t = ((bx - ax) * dby - (by - ay) * dbx) / den, s = ((bx - ax) * day - (by - ay) * dax) / den;\n          if (t \u003c -1e-6 || t > 1 + 1e-6 || s \u003c -1e-6 || s > 1 + 1e-6) continue;\n          const vx = ax + t * dax, vy = ay + t * day;\n          if (vx \u003c 0.5 || vx > GW - 0.5 || vy \u003c 0.5 || vy > GH - 0.5) continue;\n          let paper = 0, sx = 0, sy = 0;\n          for (let k = 0; k \u003c 96; k++) {\n            const th = ((k + 0.5) / 96) * 2 * PI, cx = cos(th), cy = sin(th);\n            if (!ink(g, vx + 1.5 * cx, vy + 1.5 * cy)) paper++, (sx += cx), (sy += cy);\n          }\n          const deg = (paper / 96) * 360;\n          if (deg \u003c 8 || deg > 84) continue;\n          if (out.some((c) => abs(c.x - vx) + abs(c.y - vy) \u003c 1.5)) continue;\n          const l = hypot(sx, sy);\n          out.push({ x: vx, y: vy, bx: sx / l, by: sy / l, a: (deg * PI) / 180 });\n        }\n  return out;\n}\n\n// ---- Paper: hash value noise, stretched along the rows the way newsprint\n// fibres lie along the web.\nconst hash = (a, b, c) => {\n  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  h = Math.imul(h ^ (h >>> 16), 2246822519);\n  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n};\nfunction vn(x, y, k) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);\n  const a = hash(x0, y0, k), b = hash(x0 + 1, y0, k), c = hash(x0, y0 + 1, k), d = hash(x0 + 1, y0 + 1, k);\n  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n}\nconst K0 = 0.16;\nfunction makeSheet(seed) {\n  const F = new Float32Array(N), kh = new Float32Array(N), kv = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) F[y * W + x] = cl(0.5 + 0.7 * (vn(x / 6, y / 1.4, seed) - 0.5) + 0.5 * (vn(x / 2.2, y / 0.9, seed + 7) - 0.5), 0, 1);\n  let mh = 0, mv = 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      kh[i] = x \u003c W - 1 ? K0 * 1.15 * (0.55 + 0.45 * (F[i] + F[i + 1])) : 0;\n      kv[i] = y \u003c H - 1 ? K0 * 0.85 * (0.55 + 0.45 * (F[i] + F[i + W])) : 0;\n      mh += kh[i];\n      mv += kv[i];\n    }\n  return { F, kh, kv, step: (mh + mv) / N };\n}\n\n// ---- Timing at Speed 2, in seconds. The ink: the standard deviation of\n// the spread the traps are cut for (1.28 LEDs, an edge advance of 1.5), the\n// concentration at which paper turns dark, and how many standard\n// deviations a straight edge moves out at that concentration.\nconst T_SOAK = 3, T_HOLD = 2.6, T_FEED = 0.8;\nconst TRAPK = 1.6, SIGN = 1.28, TAU = 0.12, ZT = 1.175;\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.sheets = [makeSheet(11), makeSheet(23)];\n  s.u = new Float32Array(N);\n  s.du = new Float32Array(N);\n  s.cr = {};\n  s.set = -1;\n  s.li = 0;\n  s.p = 0;\n  s.phase = 0;\n  s.age = 0;\n  s.done = 0;\n  s.struck = false;\n}\n\nfunction strike(s, ch) {\n  const g = GLYPHS[ch];\n  if (!s.cr[ch])\n    s.cr[ch] = crotches(g).map((c) => {\n      const D = (TRAPK * ZT * SIGN) / sin(c.a / 2);\n      return { ...c, t: tan(c.a / 2), D, Lr: D };\n    });\n  const cr = s.cr[ch], u = s.u;\n  u.fill(0);\n  for (let half = 0; half \u003c 2; half++) {\n    const oy = GY[half];\n    for (let y = 0; y \u003c GH + 1; y++)\n      for (let x = 0; x \u003c GW + 1; x++) {\n        let c = 0;\n        for (let j = 0; j \u003c 4; j++)\n          for (let i = 0; i \u003c 4; i++) {\n            const px = x + (i + 0.5) / 4, py = y + (j + 0.5) / 4;\n            if (!ink(g, px, py)) continue;\n            let trap = false;\n            if (half === 0)\n              for (const t of cr) {\n                const dx = px - t.x, dy = py - t.y, A = dx * t.bx + dy * t.by + t.D, w = abs(dx * t.by - dy * t.bx);\n                if (A > 0 && A \u003c t.D + t.Lr && w \u003c A * t.t - t.D * t.t * max(0, (A - t.D) / t.Lr)) {\n                  trap = true;\n                  break;\n                }\n              }\n            if (!trap) c++;\n          }\n        const X = GX + x, Y = oy + y;\n        if (X \u003c W && Y \u003c H) u[Y * W + X] = c / 16;\n      }\n  }\n  s.done = 0;\n  s.age = 0;\n  s.struck = true;\n}\n\nfunction diffuse(s, f) {\n  const { u, du } = s, sh = s.sheets[s.p], kh = sh.kh, kv = sh.kv;\n  du.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const a = u[i];\n    if (kh[i]) {\n      const q = kh[i] * (u[i + 1] - a) * f;\n      du[i] += q;\n      du[i + 1] -= q;\n    }\n    if (kv[i]) {\n      const q = kv[i] * (u[i + W] - a) * f;\n      du[i] += q;\n      du[i + W] -= q;\n    }\n  }\n  for (let i = 0; i \u003c N; i++) u[i] += du[i];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const rate = cl(k[1], 0.2, 3) / 2;\n  const set = round(cl(k[2] || 0, 0, 2));\n  const k4 = cl(k[3] || 0, -1, 1) - 0.06, sig = SIGN * exp(k4 * (k4 \u003c 0 ? 1 : 0.56));\n  if (!s.struck) {\n    s.set = set;\n    strike(s, SETS[set][0]);\n  }\n  if (set !== s.set && s.phase === 0) {\n    s.set = set;\n    s.li = -1;\n    s.phase = 1;\n    s.feed = 0;\n  }\n  if (s.phase === 0) {\n    s.age += dt * rate;\n    const want = sig * sig * min(1, s.age / T_SOAK), st = s.sheets[s.p].step;\n    let need = want - s.done, n = 0;\n    while (need > 1e-4 && n \u003c 16) {\n      const f = min(1, need / st);\n      diffuse(s, f);\n      s.done += f * st;\n      need -= f * st;\n      n++;\n    }\n    // A sheet soaked past what the knob now asks for cannot unsoak: feed\n    // a fresh one.\n    if (s.age > T_SOAK + T_HOLD || (s.age > 0.3 && sig * sig \u003c 0.7 * s.done)) (s.phase = 1), (s.feed = 0);\n  } else {\n    s.feed += (dt * rate) / T_FEED;\n    if (s.feed >= 1) {\n      s.phase = 0;\n      s.p ^= 1;\n      const L = SETS[s.set];\n      s.li = (s.li + 1) % L.length;\n      strike(s, L[s.li]);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.struck) return;\n  const paper = hsv(0.14 + s.hue, 0.62, 182), INK = [4, 4, 8];\n  const e = s.phase === 1 ? s.feed * s.feed * (3 - 2 * s.feed) : 0, off = round(e * H);\n  const A = s.sheets[s.p], B = s.sheets[s.p ^ 1], u = s.u;\n  for (let y = 0; y \u003c H; y++) {\n    const sy = y + off, old = sy \u003c H, row = old ? sy : sy - H, F = old ? A.F : B.F;\n    const seam = s.phase === 1 && (sy === H - 1 || sy === H) ? 0.6 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const i = row * W + x, f = F[i];\n      const pb = (0.93 + 0.12 * (f - 0.5)) * seam;\n      let d = 0;\n      if (old) {\n        const v = u[i] + 0.04 * (f - 0.5);\n        d = cl((v - (TAU - 0.05)) / 0.1, 0, 1);\n        d = d * d * (3 - 2 * d);\n      }\n      display.setPixel(x, y, round(paper[0] * pb * (1 - d) + INK[0] * d), round(paper[1] * pb * (1 - d) + INK[1] * d), round(paper[2] * pb * (1 - d) + INK[2] * d));\n    }\n  }\n}\n","laguerre-cells":"// ===== Patternflow pattern =====\n// Title:   Laguerre Cells\n// Family:  cells\n// Idea:    Points scattered over the panel each own a Laguerre cell, the LEDs where |x - p|^2 - w is least, and Newton steps on the Kantorovich dual move the weights w until every cell holds the same share of a density that glows in three soft bumps, so the cells shrink to a fine mesh where it is dense and swell where it is thin while their edges stay straight; each cell is tinted by its mass error, violet while it holds too much and green while it holds too little, and every few seconds the bumps move and the cells chase them again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: power diagrams (Franz Aurenhammer, 1987), the Laguerre-Voronoi diagram of the power distance; cells of prescribed mass found by minimising a convex function of the weights (Aurenhammer, Hoffmann and Aronov, 1998); the damped Newton method for semi-discrete optimal transport (Jun Kitagawa, Quentin Mérigot and Boris Thibert, 2019); pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cells=24..64, Contrast=-1..1\n//\n// Knob 1: Hue. Turns three colours round the wheel together, a settled cell in the middle and a cell holding too much and too little 0.24 either side: at 0 teal, violet and green, at 0.25 violet, red and cyan, at 0.5 red, chartreuse and violet.\n// Knob 2: Speed. Each frame the weights take a share of the full Newton step, 1.5 times Speed a second, so at 2 a cell's error falls by a factor e every 0.33 s: the opening Voronoi diagram, whose fullest cell holds four times its share, is within 5% at 1.5 s and 2% at 2 s. A density holds 6 s and turns into the next in 1.6 s, the first at 4.4 s, while its bumps drift 2 LEDs round. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Cells. 24 to 64 sites, scattered as the best of 24 random tries each; each whole step scatters a new set, starting from weights of 0. At 24 the largest settled cell is about 1,000 LEDs and the smallest under 100; at 64, 400 and 31.\n// Knob 4: Contrast. The densest LED against the thinnest: 3 to 1 at -1, 12 to 1 at the opening 0.06, 40 to 1 at 1. At -1 the 24 settled cells run from 173 to 510 LEDs, at 1 from 58 to 1,350, and the cells away from the bumps grow spikes that reach between them.\n\n// A power diagram gives each site p_i a weight w_i and each point x to the\n// site with the least power |x - p_i|^2 - w_i. Two cells meet on a straight\n// line, where the powers are equal, and raising w_i pushes that line away\n// from p_i by (dw)/(2|p_i - p_j|). With all weights equal it is the Voronoi\n// diagram. Aurenhammer, Hoffmann and Aronov showed that for any sites and\n// any masses there are weights that give every cell its mass, the minimum\n// of a convex function of the weights; that is the semi-discrete optimal\n// transport of the density onto the sites with the cost |x - p|^2.\n//\n// The gradient of the dual is each cell's missing mass, m - mass_i, and its\n// Hessian the matrix of edges: for cells i and j, the density along their\n// common edge over 2|p_i - p_j|. An LED within half an LED of an edge\n// splits its mass between the two cells by how far it lies across, which\n// makes the mass move smoothly with the weights and gives those edge sums.\n// Each frame conjugate gradients solve the Newton step and the weights take\n// a share of it, so the errors fall smoothly enough to watch.\n//\n// A cell need not hold its own site. On this panel with 24 sites, 11 lie\n// outside their settled cells at the opening density and 17 after the\n// first change; with 64 sites it is 48 to 53.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, cos, sin, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst MAXC = 64;\n// Blocks of 8 by 8 LEDs, each with the sites that can own or border one of\n// its LEDs.\nconst B = 8, BX = W / B, BY = H / B;\n// Seconds at Speed 2: a density holds, then turns into the next.\nconst T_HOLD = 6, T_MORPH = 1.6, T_FIRST = 4.4;\n\nfunction newSites(s, n) {\n  s.n = n;\n  const X = s.px, Y = s.py;\n  // Best candidate: each new site the farthest of 24 tries from the others.\n  for (let i = 0; i \u003c n; i++) {\n    let bx = 0, by = 0, bd = -1;\n    for (let t = 0; t \u003c 24; t++) {\n      const x = 2 + Math.random() * (W - 4), y = 2 + Math.random() * (H - 4);\n      let d = 1e9;\n      for (let j = 0; j \u003c i; j++) d = min(d, (x - X[j]) ** 2 + (y - Y[j]) ** 2);\n      if (d > bd) (bd = d), (bx = x), (by = y);\n    }\n    X[i] = bx;\n    Y[i] = by;\n  }\n  s.w.fill(0);\n}\n\n// A density: three soft bumps, a log-density f from 0 to 1 that the\n// Contrast knob raises to a ratio of densest to thinnest.\nfunction newBumps() {\n  const b = [];\n  for (let k = 0; k \u003c 3; k++)\n    b.push({ x: 8 + Math.random() * (W - 16), y: 10 + Math.random() * (H - 20), r: 9 + Math.random() * 9, a: k ? 0.55 + 0.45 * Math.random() : 1, ph: Math.random() * 2 * PI });\n  return b;\n}\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.px = new Float64Array(MAXC);\n  s.py = new Float64Array(MAXC);\n  s.w = new Float64Array(MAXC);\n  s.mass = new Float64Array(MAXC);\n  s.err = new Float64Array(MAXC);\n  s.Hm = new Float64Array(MAXC * MAXC);\n  s.rho = new Float32Array(N);\n  s.f = new Float32Array(N);\n  s.own = new Uint8Array(N);\n  s.line = new Float32Array(N);\n  s.cand = new Uint8Array(BX * BY * MAXC);\n  s.cnt = new Uint8Array(BX * BY);\n  s.cg = [new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC)];\n  s.n = 0;\n  s.A = newBumps();\n  s.Bm = newBumps();\n  s.clock = 0;\n  s.next = T_FIRST;\n  s.morph = -1;\n  s.t = 0;\n}\n\nfunction density(s, lnR) {\n  const { rho, f } = s, A = s.A, Bm = s.Bm;\n  const m = s.morph \u003c 0 ? 0 : s.morph * s.morph * (3 - 2 * s.morph);\n  const bs = A.map((a, k) => {\n    const b = Bm[k], dr = 2;\n    return {\n      x: a.x + (b.x - a.x) * m + dr * cos(s.t * 0.3 + a.ph),\n      y: a.y + (b.y - a.y) * m + dr * sin(s.t * 0.22 + a.ph),\n      r: a.r + (b.r - a.r) * m,\n      a: a.a + (b.a - a.a) * m,\n    };\n  });\n  // Each bump is a product of a row and a column Gaussian, and exp(lnR f)\n  // is read from a table of 1025 steps.\n  const gx = s.gx || (s.gx = new Float32Array(3 * W)), gy = s.gy || (s.gy = new Float32Array(3 * H));\n  bs.forEach((b, k) => {\n    const q = 1 / (2 * b.r * b.r);\n    for (let x = 0; x \u003c W; x++) gx[k * W + x] = b.a * exp(-((x + 0.5 - b.x) ** 2) * q);\n    for (let y = 0; y \u003c H; y++) gy[k * H + y] = exp(-((y + 0.5 - b.y) ** 2) * q);\n  });\n  const lut = s.lut || (s.lut = new Float32Array(1025));\n  for (let j = 0; j \u003c= 1024; j++) lut[j] = exp((lnR * j) / 1024);\n  let tot = 0;\n  for (let y = 0; y \u003c H; y++) {\n    const a0 = gy[y], a1 = gy[H + y], a2 = gy[2 * H + y];\n    for (let x = 0; x \u003c W; x++) {\n      const v = min(1, a0 * gx[x] + a1 * gx[W + x] + a2 * gx[2 * W + x]), i = y * W + x;\n      f[i] = v;\n      tot += rho[i] = lut[round(v * 1024)];\n    }\n  }\n  return tot;\n}\n\n// Power distance |x - p|^2 - w for every LED: the owner, the runner-up and\n// how far the LED is from their common edge, in LEDs. An LED within half an\n// LED of the edge splits its mass between the two, so a cell's mass moves\n// smoothly with the weights, and the same LEDs give the derivatives.\nfunction assign(s) {\n  const { px, py, w, n, cand, cnt, rho, own, line, mass, Hm } = s;\n  let wmax = -1e9;\n  for (let i = 0; i \u003c n; i++) wmax = max(wmax, w[i]);\n  const r = B * 0.7072;\n  for (let by = 0; by \u003c BY; by++)\n    for (let bx = 0; bx \u003c BX; bx++) {\n      const cx = bx * B + B / 2, cy = by * B + B / 2, blk = by * BX + bx;\n      let U = 1e18;\n      const dc = s.cg[4];\n      for (let i = 0; i \u003c n; i++) {\n        const d = sqrt((px[i] - cx) ** 2 + (py[i] - cy) ** 2);\n        dc[i] = d;\n        U = min(U, (d + r) ** 2 - w[i]);\n      }\n      const reach = sqrt(max(0, U + wmax));\n      let c = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const lb = max(0, dc[i] - r) ** 2 - w[i];\n        if (lb - U \u003c 2 * (reach + dc[i] + r) + 1) cand[blk * MAXC + c++] = i;\n      }\n      cnt[blk] = c;\n    }\n  mass.fill(0, 0, n);\n  Hm.fill(0, 0, MAXC * MAXC);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const blk = (y >> 3) * BX + (x >> 3), c = cnt[blk], o = blk * MAXC;\n      const X = x + 0.5, Y = y + 0.5;\n      let b1 = 0, b2 = 0, d1 = 1e18, d2 = 1e18;\n      for (let k = 0; k \u003c c; k++) {\n        const i = cand[o + k], d = (X - px[i]) ** 2 + (Y - py[i]) ** 2 - w[i];\n        if (d \u003c d1) (d2 = d1), (b2 = b1), (d1 = d), (b1 = i);\n        else if (d \u003c d2) (d2 = d), (b2 = i);\n      }\n      const p = y * W + x, q = rho[p];\n      own[p] = b1;\n      let gap = 99;\n      if (c > 1) {\n        const sep = 2 * sqrt((px[b1] - px[b2]) ** 2 + (py[b1] - py[b2]) ** 2);\n        gap = (d2 - d1) / sep;\n        if (gap \u003c 0.5) {\n          const sh = 0.5 + gap, h = q / sep;\n          mass[b1] += q * sh;\n          mass[b2] += q * (1 - sh);\n          Hm[b1 * MAXC + b1] += h;\n          Hm[b2 * MAXC + b2] += h;\n          Hm[b1 * MAXC + b2] -= h;\n          Hm[b2 * MAXC + b1] -= h;\n        } else mass[b1] += q;\n      } else mass[b1] += q;\n      line[p] = gap;\n    }\n}\n\n// Newton on the Kantorovich dual: the gradient is each cell's missing mass,\n// the Hessian the matrix of edge densities just gathered. Conjugate\n// gradients solve H d = (m - mass); the weights move a damped share of d.\nfunction newton(s, m, step) {\n  const { n, Hm, w, mass, err } = s;\n  const [r, z, p, Ap] = s.cg;\n  let typ = 0, cntH = 0;\n  for (let i = 0; i \u003c n; i++) if (Hm[i * MAXC + i] > 0) (typ += Hm[i * MAXC + i]), cntH++;\n  typ = cntH ? typ / cntH : 1;\n  const eps = 1e-4 * typ;\n  for (let i = 0; i \u003c n; i++) {\n    err[i] = mass[i] / m - 1;\n    r[i] = m - mass[i];\n    // A cell with no edge in use yet gets a diagonal, so it grows back.\n    if (Hm[i * MAXC + i] \u003c= 0) Hm[i * MAXC + i] = 0.3 * typ;\n  }\n  const dw = s.dw || (s.dw = new Float64Array(MAXC));\n  dw.fill(0, 0, n);\n  const pre = (i) => 1 / (Hm[i * MAXC + i] + eps);\n  // The matrix as lists of each cell's neighbours, about six apiece.\n  const nb = s.nb || (s.nb = new Uint8Array(MAXC * MAXC)), nc = s.nc || (s.nc = new Uint8Array(MAXC));\n  for (let i = 0; i \u003c n; i++) {\n    let c = 0;\n    for (let j = 0; j \u003c n; j++) if (Hm[i * MAXC + j] !== 0) nb[i * MAXC + c++] = j;\n    nc[i] = c;\n  }\n  let rz = 0;\n  for (let i = 0; i \u003c n; i++) (z[i] = r[i] * pre(i)), (p[i] = z[i]), (rz += r[i] * z[i]);\n  const r0 = rz;\n  for (let it = 0; it \u003c 60 && rz > 1e-10 * r0; it++) {\n    let pAp = 0;\n    for (let i = 0; i \u003c n; i++) {\n      let v = eps * p[i];\n      const row = i * MAXC;\n      for (let k = 0; k \u003c nc[i]; k++) {\n        const j = nb[row + k];\n        v += Hm[row + j] * p[j];\n      }\n      Ap[i] = v;\n      pAp += p[i] * v;\n    }\n    if (pAp \u003c= 0) break;\n    const al = rz / pAp;\n    let rz2 = 0;\n    for (let i = 0; i \u003c n; i++) {\n      dw[i] += al * p[i];\n      r[i] -= al * Ap[i];\n      z[i] = r[i] * pre(i);\n      rz2 += r[i] * z[i];\n    }\n    const be = rz2 / rz;\n    rz = rz2;\n    for (let i = 0; i \u003c n; i++) p[i] = z[i] + be * p[i];\n  }\n  // No weight moves more than a third of a cell's mean area in one frame.\n  const lim = N / n / 3;\n  let mean = 0;\n  for (let i = 0; i \u003c n; i++) {\n    w[i] += cl(step * dw[i], -lim, lim);\n    mean += w[i];\n  }\n  mean /= n;\n  for (let i = 0; i \u003c n; i++) w[i] -= mean;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 24, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const sp = cl(k[1], 0.2, 3), rate = sp / 2;\n  const n = round(cl(k[2], 24, 64));\n  const lnR = 2.4 + 1.3 * cl(k[3] || 0, -1, 1);\n  if (n !== s.n) newSites(s, n);\n  s.t += dt * rate;\n  // The density holds, then turns into the next one.\n  s.clock += dt * rate;\n  if (s.morph \u003c 0 && s.clock >= s.next) s.morph = 0;\n  if (s.morph >= 0) {\n    s.morph += (dt * rate) / T_MORPH;\n    if (s.morph >= 1) {\n      s.A = s.Bm;\n      s.Bm = newBumps();\n      s.morph = -1;\n      s.next = s.clock + T_HOLD;\n    }\n  }\n  const tot = density(s, lnR);\n  assign(s);\n  newton(s, tot / n, min(1, 1.5 * sp * dt));\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.n) return;\n  const { n, own, line, f, err, px, py } = s;\n  const col = s.col || (s.col = new Float64Array(MAXC * 3));\n  const h0 = 0.5 + s.hue;\n  for (let i = 0; i \u003c n; i++) {\n    const e = cl(err[i] * 3, -1, 1);\n    hsv(h0 + 0.24 * e, 0.55 + 0.3 * abs(e), 1, col, i * 3);\n  }\n  const F = s.F || (s.F = new Float32Array(N * 3));\n  for (let p = 0; p \u003c N; p++) {\n    const i = own[p], v = 55 + 150 * f[p], g = line[p], L = g \u003c 1 ? 1 - g : 0;\n    const o = p * 3, c = i * 3;\n    F[o] = col[c] * v * (1 - L) + 215 * L;\n    F[o + 1] = col[c + 1] * v * (1 - L) + 215 * L;\n    F[o + 2] = col[c + 2] * v * (1 - L) + 215 * L;\n  }\n  // The sites, dim: most of them end up outside their own cells.\n  for (let i = 0; i \u003c n; i++) {\n    const o = (floor(py[i]) * W + floor(px[i])) * 3;\n    F[o] = F[o + 1] = F[o + 2] = 150;\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, min(255, round(F[p * 3])), min(255, round(F[p * 3 + 1])), min(255, round(F[p * 3 + 2])));\n}\n","multiplicative-chaos":"// ===== Patternflow pattern =====\n// Title:   Multiplicative Chaos\n// Family:  noise\n// Idea:    A log-correlated Gaussian field X on the panel's 64 by 128 lattice, reaching a quarter of an LED, is drawn as a deep blue relief lit from the upper left, and its Gaussian multiplicative chaos exp(gamma X - gamma^2 E[X^2] / 2), each LED's share of the frame's mass, glows over it from rose through gold to white: at gamma 1 the glow is a gold lace over the high ground that holds half the mass on about 78 LEDs, and as gamma rises past the critical value 2 it drains onto one or two white points on the highest ground, while every mode of the field wanders slowly so the lace drifts, splits and gathers somewhere else.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Gaussian multiplicative chaos (Jean-Pierre Kahane, \"Sur le chaos multiplicatif\", Ann. Sci. Math. Québec 9, 1985), its critical gamma = sqrt(2d) and thick points as reviewed by Rémi Rhodes and Vincent Vargas (Probability Surveys 11, 2014), pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gamma=1..2.5, Cutoff=0..1\n//\n// Knob 1: Hue. Turns relief and glow round the wheel together: at 0 a deep blue relief under a glow that runs rose, orange, gold to white; at 0.25 a magenta relief under green, at 0.5 a yellow one under sky blue, at 0.75 a green one under magenta.\n// Knob 2: Speed. Every mode of the field wanders as its own Ornstein-Uhlenbeck process, smoothed in time. At 2 the longest wave, 128 rows, forgets itself in 8 s and the finest, with the octaves below the LED, in 1.6 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Gamma. From 1 to 2.5, critical at 2. Averaged over 20 fields: at 1 a third of the LEDs glow (each holds more than 0.14 of an even share), the brightest 1% hold 52% of the mass and half of it lies on 78 LEDs, where X is near gamma E[X^2]; at 1.6 9% glow, 1% hold 90% and half sits on 6 LEDs; at 2 5% glow and half sits on 3; at 2.4 2% glow and one or two LEDs hold half. Past 1.3 the mass stops following gamma E[X^2] up and freezes on the field's highest LEDs, which on this lattice stand at 1.47 E[X^2], short of the 2 E[X^2] the maximum tends to as a lattice grows.\n// Knob 4: Cutoff. The finest scale the field reaches, epsilon = 2^(6 (k - 0.06) - 2) LEDs: at the opening 0.06 a quarter of an LED, the two octaves below the LED drawn LED by LED, so relief and glow are grainy at every LED; at 0.39 one LED, the field blurred to its lattice modes and the lace turned into soft gold clouds; 4 LEDs at 0.72 and 12.5 at 1, where the field is a few hills and 95% of the LEDs glow a dim rust red, the measure close to even.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, exp, log, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- FFT, radix 2, in place, on rows of 64 and columns of 128.\nconst CT = new Float64Array(64), ST = new Float64Array(64);\nfor (let i = 0; i \u003c 64; i++) (CT[i] = cos((2 * PI * i) / 128)), (ST[i] = sin((2 * PI * i) / 128));\nfunction revTable(n) {\n  const r = new Int32Array(n), b = Math.log2(n);\n  for (let i = 0; i \u003c n; i++) {\n    let v = 0;\n    for (let k = 0; k \u003c b; k++) if (i & (1 \u003c\u003c k)) v |= 1 \u003c\u003c (b - 1 - k);\n    r[i] = v;\n  }\n  return r;\n}\nconst REV64 = revTable(64), REV128 = revTable(128);\nfunction fft(re, im, n, off, step, rev) {\n  for (let i = 0; i \u003c n; i++) {\n    const j = rev[i];\n    if (j > i) {\n      const a = off + i * step, b = off + j * step;\n      let t = re[a];\n      re[a] = re[b];\n      re[b] = t;\n      t = im[a];\n      im[a] = im[b];\n      im[b] = t;\n    }\n  }\n  for (let len = 2; len \u003c= n; len \u003c\u003c= 1) {\n    const half = len >> 1, ts = 128 / len;\n    for (let s = 0; s \u003c n; s += len)\n      for (let k = 0; k \u003c half; k++) {\n        const wr = CT[k * ts], wi = ST[k * ts];\n        const a = off + (s + k) * step, b = a + half * step;\n        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;\n        re[b] = re[a] - xr;\n        im[b] = im[a] - xi;\n        re[a] += xr;\n        im[a] += xi;\n      }\n  }\n}\nfunction fft2(re, im) {\n  for (let y = 0; y \u003c H; y++) fft(re, im, W, y * W, 1, REV64);\n  for (let x = 0; x \u003c W; x++) fft(re, im, H, x, W, REV128);\n}\n\n// ---- The field's modes on the 64 x 128 torus, so it wraps round left to\n// right and top to bottom. Mode (m, n) has the eigenvalue LA of minus the\n// lattice Laplacian and standard deviation sqrt(2 pi / (LA N)), the\n// discrete Gaussian free field scaled so its covariance goes as log(1 / r):\n// C(r) - C(2r) comes to 0.71, 0.71 and 0.68 for r = 1, 2 and 4 LEDs against\n// log 2 = 0.69, and E[X^2] to 4.99. In that normalisation the critical gamma\n// is sqrt(2d) = 2. The modes are complex, so one transform gives two\n// independent fields, its real and imaginary parts; the real one is drawn.\nconst LA = new Float64Array(N), AMP = new Float64Array(N), TAU = new Float64Array(N);\nfor (let n = 0; n \u003c H; n++)\n  for (let m = 0; m \u003c W; m++) {\n    const i = n * W + m, l = 4 - 2 * cos((2 * PI * m) / W) - 2 * cos((2 * PI * n) / H);\n    LA[i] = l;\n    AMP[i] = i ? sqrt((2 * PI) / (l * N)) : 0;\n  }\n// Each mode's time constant against the longest wave's: the finest lattice\n// mode turns over five times as fast, and so do the octaves below the LED.\nconst LMIN = 4 - 2 * cos((2 * PI) / H) - 2;\nfor (let i = 1; i \u003c N; i++) TAU[i] = (LMIN / LA[i]) ** 0.2;\nconst TAUF = (LMIN / 8) ** 0.2;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Standard normal deviates, drawn once and then picked at random. The table\n// is moved to mean 0 and variance 1: a table mean of 0.01 picked 8,192\n// times a frame would add up, through every mode at once, into a bump.\nconst NT = new Float64Array(8192);\nfunction fillNormals() {\n  let m = 0, v = 0;\n  for (let i = 0; i \u003c 8192; i += 2) {\n    const a = sqrt(-2 * log(1 - Math.random())), b = 2 * PI * Math.random();\n    NT[i] = a * cos(b);\n    NT[i + 1] = a * sin(b);\n    m += NT[i] + NT[i + 1];\n  }\n  m /= 8192;\n  for (let i = 0; i \u003c 8192; i++) v += (NT[i] -= m) ** 2;\n  v = sqrt(v / 8192);\n  for (let i = 0; i \u003c 8192; i++) NT[i] /= v;\n}\nconst gauss = () => NT[(Math.random() * 8192) | 0];\n\nexport function setup(params) {\n  fillNormals();\n  const S = (params.s = {\n    hue: 0, speed: 2, gam: 1, cut: 0, eps: -1, qd: -1, vl: 1, vf: 0,\n    zr: new Float64Array(N), zi: new Float64Array(N), ar: new Float64Array(N), ai: new Float64Array(N),\n    fz: new Float64Array(N), fa: new Float64Array(N),\n    Q: new Float64Array(N), Z: new Float64Array(N), R: new Float64Array(N), F: new Float64Array(N),\n    re: new Float64Array(N), im: new Float64Array(N), X: new Float64Array(N),\n    rel: new Float64Array(RT * 3), glo: new Float64Array(GT * 4), th: -1,\n  });\n  // Each mode starts in its stationary law: the filtered value has variance\n  // 2/3 and covariance 2/3 with the process it filters.\n  const start = (z, a) => {\n    for (let i = 0; i \u003c N; i++) {\n      z[i] = gauss();\n      a[i] = (2 / 3) * z[i] + 0.4714 * gauss();\n    }\n  };\n  start(S.zr, S.ar);\n  start(S.zi, S.ai);\n  start(S.fz, S.fa);\n  return S;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] ?? 2, 0.2, 3);\n  S.gam = cl(k[2] ?? 1, 0, 3);\n  S.cut = cl(k[3] ?? 0.06, 0, 1);\n  // The cutoff epsilon in LEDs. Below one LED the lattice modes are all kept\n  // and the octaves between epsilon and the LED, log(1 / epsilon) of\n  // variance, are drawn as an independent normal at each LED: at a quarter\n  // of an LED they carry 1.39 of the field's 6.37. Above it the lattice\n  // modes are blurred by a Gaussian of width epsilon.\n  const eps = 2 ** (6 * (S.cut - 0.06) - 2);\n  if (eps !== S.eps) {\n    S.eps = eps;\n    const e2 = max(0, eps * eps - 1 / 16);\n    let v = 0;\n    for (let i = 1; i \u003c N; i++) {\n      const f = exp((-LA[i] * e2) / 2);\n      S.F[i] = AMP[i] * f * sqrt(1.5);\n      v += (AMP[i] * f) ** 2;\n    }\n    S.vl = v;\n    S.vf = max(0, log(1 / eps));\n  }\n  // Ornstein-Uhlenbeck steps seen through an exponential filter of half the\n  // time constant, which smooths each path in time; the filter leaves 2/3 of\n  // the variance, which F gives back. The longest wave's time constant is\n  // 8 s at Speed 2.\n  const qd = (d * S.speed) / (8 * 2);\n  if (qd !== S.qd) {\n    S.qd = qd;\n    for (let i = 1; i \u003c N; i++) {\n      const q = exp(-qd / TAU[i]);\n      S.Q[i] = q;\n      S.Z[i] = sqrt(1 - q * q);\n      S.R[i] = q * q;\n    }\n    const q = exp(-qd / TAUF);\n    S.fq = q;\n    S.fzz = sqrt(1 - q * q);\n    S.fr = q * q;\n  }\n  const { zr, zi, ar, ai, Q, Z, R, F, re, im, fz, fa, X } = S;\n  for (let i = 1; i \u003c N; i++) {\n    zr[i] = zr[i] * Q[i] + Z[i] * gauss();\n    zi[i] = zi[i] * Q[i] + Z[i] * gauss();\n    ar[i] = ar[i] * R[i] + zr[i] * (1 - R[i]);\n    ai[i] = ai[i] * R[i] + zi[i] * (1 - R[i]);\n    re[i] = ar[i] * F[i];\n    im[i] = ai[i] * F[i];\n  }\n  re[0] = im[0] = 0;\n  fft2(re, im);\n  const sf = sqrt(S.vf * 1.5), fq = S.fq, fzz = S.fzz, fr = S.fr;\n  for (let i = 0; i \u003c N; i++) {\n    fz[i] = fz[i] * fq + fzz * gauss();\n    fa[i] = fa[i] * fr + fz[i] * (1 - fr);\n    X[i] = re[i] + sf * fa[i];\n  }\n}\n\n// ---- Drawing. The relief: the field's height t = X / sd tints and lifts\n// it, and its slope toward the upper left (the sum of the two central\n// differences, halved) shades it. The glow: lm, the log of the LED's share\n// of the frame's mass against an even share, read from LO (e^-2, 0.14 of an\n// even share) to HI (e^3.5, 33 times one).\nconst KS = 0.4, KB = 0.16, LO = -2, HI = 3.5;\n// Relief colours over t from -3 to 3 in 64 steps; glow colours, with the\n// glow's own weight a and what is left of the relief k, over 256 steps.\nconst RT = 64, GT = 256;\nfunction tables(S) {\n  const c = [0, 0, 0];\n  for (let j = 0; j \u003c RT; j++) {\n    hsv(0.64 + S.hue - 0.03 * ((6 * j) / (RT - 1) - 3), 0.85, 1, c);\n    S.rel[j * 3] = c[0];\n    S.rel[j * 3 + 1] = c[1];\n    S.rel[j * 3 + 2] = c[2];\n  }\n  for (let j = 0; j \u003c GT; j++) {\n    const w = j / (GT - 1), a = min(1, 0.25 + 1.2 * w);\n    hsv(0.93 + S.hue + 0.22 * min(1, w * 1.25), 1 - w ** 4, 0.45 + 0.55 * w, c);\n    S.glo[j * 4] = 255 * a * c[0];\n    S.glo[j * 4 + 1] = 255 * a * c[1];\n    S.glo[j * 4 + 2] = 255 * a * c[2];\n    S.glo[j * 4 + 3] = 1 - 0.85 * a;\n  }\n  S.th = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.th !== S.hue) tables(S);\n  const X = S.X, g = S.gam, rel = S.rel, glo = S.glo, isd = 1 / sqrt(S.vl + S.vf), ts = (RT - 1) / 6;\n  // Each LED's share of the frame's mass: the log of the mean density is\n  // taken off, summed from the largest value down so it cannot overflow.\n  // The constant -g^2 E[X^2] / 2 of the chaos cancels in the share.\n  let mx = -1e9;\n  for (let i = 0; i \u003c N; i++) if (X[i] > mx) mx = X[i];\n  let sum = 0;\n  for (let i = 0; i \u003c N; i++) sum += exp(g * (X[i] - mx));\n  const off = g * mx + log(sum / N), gw = (GT - 1) / (HI - LO);\n  for (let y = 0; y \u003c H; y++) {\n    const r0 = y * W, ru = ((y + H - 1) & 127) * W, rd = ((y + 1) & 127) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const p = r0 + x, v = X[p];\n      const sh = (X[r0 + ((x + W - 1) & 63)] - X[r0 + ((x + 1) & 63)] + X[ru + x] - X[rd + x]) * 0.5;\n      const t = v * isd, tj = cl(((t + 3) * ts) | 0, 0, RT - 1) * 3;\n      const val = 255 * cl(0.38 + KB * t + KS * sh, 0.02, 1);\n      let r = rel[tj] * val, gg = rel[tj + 1] * val, b = rel[tj + 2] * val;\n      const lm = g * v - off;\n      if (lm > LO) {\n        const q = min(GT - 1, ((lm - LO) * gw) | 0) * 4, k = glo[q + 3];\n        r = r * k + glo[q];\n        gg = gg * k + glo[q + 1];\n        b = b * k + glo[q + 2];\n      }\n      display.setPixel(x, y, r > 255 ? 255 : r | 0, gg > 255 ? 255 : gg | 0, b > 255 ? 255 : b | 0);\n    }\n  }\n}\n","photon-disk":"// ===== Patternflow pattern =====\n// Title:   Photon Disk\n// Family:  type\n// Idea:    A dark glass disk with its letters cut clear in two rings turns anticlockwise in the lower half of the panel, and each time the glyph the line needs passes the window at twelve o'clock a short flash freezes it white for an instant and sends its light up through a lens that sizes the image onto a strip of brown film at the top, where the line builds up letter by letter in light while the film feeds up a line at a time.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lumitype phototypesetter, sold in the United States as the Photon (René Higonnet and Louis Moyroud, begun 1944, shown in France in September 1946), whose disk held eight rings of two 90-character fonts filmed at 12 sizes from 5 to 72 points; the first book set on it, Albro Gaul's The Wonderful World of Insects (1953); a 5 by 7 face drawn for this pattern; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Lens=1..2.25\n//\n// Knob 1: Hue. The colour of the light the flash leaves on the film and of the letters in the glass: azure at 0, violet at 0.25, orange at 0.5, green at 0.75. The flash itself is white and the film stays a dark brown.\n// Knob 2: Speed. The disk turns 0.4 times the knob a second, 0.8 at the opening 2, and a letter waits for its glyph to come round, so the flash fires 1.2 times a second on the title and its 26 letters on four lines take 21 s with the line feeds and a rest of 1.6 s at the end. At 0.2 a turn takes 12.5 s, the letters in the disk stand sharp and the title takes three minutes; at 3 the rings smear and it takes 14 s.\n// Knob 3: Text. 0 the title of the first book set on the machine, THE WONDERFUL WORLD OF INSECTS; 1 the pangram THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG., 36 flashes; 2 the disk's own 40 glyphs in ring order, where each comes to the window just after the one before, so at 2 the outer ring's letters land about 20 a second and the strobe seems to hold the disk still while A to Z run through the window; 3 R. HIGONNET & L. MOYROUD 1946. A new text starts two lines further down the film.\n// Knob 4: Lens. The magnification, 1 to 2.25 in quarter steps, and the lens slides to where a thin lens gives it, the distance from disk to film divided 1 to m: halfway at 1, 15.5 rows above the window, with letters 7 LEDs tall and 9 to the line; 10.9 rows above it at 2.25, with letters 15.75 LEDs tall and 4 to the line, a long word broken with the hyphen from the inner ring. A new size starts the text over two lines down, and letters already on the film keep the size they were set at.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// 5 x 7 capitals, figures and four marks, drawn for this pattern, row by row\n// from the top.\nconst GLYPHS = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", B: \"####. #...# #...# ####. #...# #...# ####.\", C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\", E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\",\n  G: \".###. #...# #.... #.### #...# #...# .####\", H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  J: \"..### ...#. ...#. ...#. ...#. #..#. .##..\", K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  M: \"#...# ##.## #.#.# #.#.# #...# #...# #...#\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\",\n  P: \"####. #...# #...# ####. #.... #.... #....\", Q: \".###. #...# #...# #...# #.#.# #..#. .##.#\", R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\", X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\", 0: \".###. #...# #..## #.#.# ##..# #...# .###.\",\n  1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", 2: \".###. #...# ....# ...#. ..#.. .#... #####\", 3: \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\", 6: \"..##. .#... #.... ####. #...# #...# .###.\",\n  7: \"##### ....# ...#. ..#.. .#... .#... .#...\", 8: \".###. #...# #...# .###. #...# #...# .###.\", 9: \".###. #...# #...# .#### ....# ...#. .##..\",\n  \".\": \"..... ..... ..... ..... ..... .##.. .##..\", \",\": \"..... ..... ..... ..... .##.. ..#.. .#...\",\n  \"&\": \".##.. #..#. #.#.. .#... #.#.# #..#. .##.#\", \"-\": \"..... ..... ..... ##### ..... ..... .....\",\n};\nconst FONT = {};\nfor (const k in GLYPHS) {\n  const s = GLYPHS[k].replace(/ /g, \"\"), b = new Uint8Array(35);\n  for (let i = 0; i \u003c 35; i++) b[i] = s[i] === \"#\" ? 1 : 0;\n  FONT[k] = b;\n}\n\n// The disk: centre and radius in LED units, two rings of glyphs with their\n// tops to the rim, the outer one the 26 capitals at radius 26 and the inner\n// one the figures and marks at radius 15. The window is at twelve o'clock.\nconst CX = 31.5, CY = 95.5, RD = 31.5, HUB = 8;\nconst RINGS = [\n  { chars: \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\", rc: 26 },\n  { chars: \"0123456789.,&-\", rc: 15 },\n];\nconst WHERE = {};\nRINGS.forEach((ring, r) => {\n  ring.n = ring.chars.length;\n  ring.g = [...ring.chars].map((ch, j) => ((WHERE[ch] = [r, j]), FONT[ch]));\n});\n\n// The film: a strip across the top 45 rows; the line being set has its foot\n// on row GB, between columns X0 and X0 + LW.\nconst FY1 = 44, GB = 41, X0 = 5, LW = 54;\n\n// The texts; the specimen of the disk's glyphs breaks its lines without a\n// hyphen.\nconst TEXTS = [\n  \"THE WONDERFUL WORLD OF INSECTS\",\n  \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.\",\n  \"ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789.,&-\",\n  \"R. HIGONNET & L. MOYROUD 1946\",\n];\nconst SPECIMEN = 2;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Every pixel of the disk with its radius, its angle in radians clockwise\n// from twelve o'clock, and which ring it can show.\nconst DISK = (() => {\n  const idx = [], ang = [], rad = [], ring = [];\n  for (let y = 64; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      if (r > RD + 0.5) continue;\n      let a = atan2(dx, -dy);\n      if (a \u003c 0) a += TAU;\n      idx.push(y * W + x), ang.push(a), rad.push(r);\n      ring.push(abs(r - RINGS[0].rc) \u003c 4.4 ? 0 : abs(r - RINGS[1].rc) \u003c 4.4 ? 1 : -1);\n    }\n  return { idx: Int32Array.from(idx), ang: Float32Array.from(ang), rad: Float32Array.from(rad), ring: Int8Array.from(ring) };\n})();\n\n// Glyph value at (col, row) in its own pixels, bilinear between the cells.\nfunction sample(g, col, row) {\n  if (col \u003c= -1 || col >= 5 || row \u003c= -1 || row >= 7) return 0;\n  const c0 = floor(col), r0 = floor(row), fc = col - c0, fr = row - r0;\n  let v = 0;\n  for (let k = 0; k \u003c 4; k++) {\n    const c = c0 + (k & 1), r = r0 + (k >> 1);\n    if (c \u003c 0 || c > 4 || r \u003c 0 || r > 6 || !g[r * 5 + c]) continue;\n    v += (k & 1 ? fc : 1 - fc) * (k >> 1 ? fr : 1 - fr);\n  }\n  return v;\n}\n\n// The glyph of ring r seen at a pixel of radius rr and disk angle b. The\n// angle off the glyph's centre line is under 0.23 radians, so sin and cos\n// are their first two terms.\nfunction diskGlyph(r, rr, b) {\n  const ring = RINGS[r], n = ring.n, jf = (b * n) / TAU, j = round(jf), d = ((jf - j) * TAU) / n, d2 = d * d;\n  const u = rr * d * (1 - d2 / 6), v = rr * (1 - d2 / 2) - ring.rc;\n  let k = j % n;\n  if (k \u003c 0) k += n;\n  return sample(ring.g[k], u + 2, 3 - v);\n}\n\n// A glyph at magnification m as coverage of the LEDs it falls on, 3 x 3\n// samples to an LED, kept once made.\nconst SCALED = {};\nfunction scaled(ch, m) {\n  const key = ch + m;\n  if (SCALED[key]) return SCALED[key];\n  const g = FONT[ch], w = ceil(5 * m), h = ceil(7 * m), cov = new Float32Array(w * h);\n  for (let py = 0; py \u003c h; py++)\n    for (let px = 0; px \u003c w; px++) {\n      let c = 0;\n      for (let sy = 0; sy \u003c 3; sy++)\n        for (let sx = 0; sx \u003c 3; sx++) {\n          const gx = floor((px + (sx + 0.5) / 3) / m), gy = floor((py + (sy + 0.5) / 3) / m);\n          if (gx \u003c 5 && gy \u003c 7 && g[gy * 5 + gx]) c++;\n        }\n      cov[py * w + px] = c / 9;\n    }\n  return (SCALED[key] = { w, h, cov });\n}\n\n// Lay a text out at magnification m: lines centred on the film, a word too\n// long for a line broken with a hyphen.\nfunction layout(text, m, plain) {\n  const adv = 6 * m, per = max(2, floor((LW + m) / adv)), lines = [], cut = plain ? per : per - 1, hy = plain ? \"\" : \"-\";\n  let cur = \"\";\n  for (let word of text.split(\" \")) {\n    while (word.length > per && !cur) lines.push(word.slice(0, cut) + hy), (word = word.slice(cut));\n    if (!cur) cur = word;\n    else if (cur.length + 1 + word.length \u003c= per) cur += \" \" + word;\n    else {\n      lines.push(cur), (cur = \"\");\n      while (word.length > per) lines.push(word.slice(0, cut) + hy), (word = word.slice(cut));\n      cur = word;\n    }\n  }\n  if (cur) lines.push(cur);\n  const out = [];\n  lines.forEach((line, k) => {\n    const x = round(X0 + (LW - (line.length * adv - m)) / 2);\n    [...line].forEach((ch, i) => out.push({ ch, line: k, x: x + i * adv }));\n  });\n  return { chars: out, lines: lines.length };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, phi: 0, prev: 0, hue: 0, speed: 2, text: 0, m: 1, job: null, jobs: 0, ci: 0, cur: 0,\n    state: \"seek\", wait: 0, film: 0, filmTo: 0, pen: X0, penTo: X0,\n    lit: [], flash: null, started: false, rgb: new Float32Array(W * H * 3),\n    c: [0, 0, 0], c2: [0, 0, 0], c3: [0, 0, 0],\n  };\n  return params.s;\n}\n\nfunction lp(m) {\n  return ceil(7 * m) + 3;\n}\n\n// Start the job over two blank lines on: a new layout at the knobs' size.\nfunction begin(S) {\n  S.job = layout(TEXTS[S.text], S.m, S.text === SPECIMEN);\n  S.ci = 0;\n  S.cur = 0;\n  S.jobs++;\n  S.filmTo += 2 * lp(S.m);\n  S.state = \"wait\";\n  S.wait = 0.4 * sqrt(2 / S.speed);\n}\n\nfunction advance(S, d) {\n  S.t += d;\n  S.prev = S.phi;\n  S.phi += d * TAU * 0.4 * S.speed;\n  const slow = sqrt(2 / S.speed);\n  // The film and the carriage ease to where they are sent.\n  S.film += (S.filmTo - S.film) * min(1, d / (0.09 * slow));\n  S.pen += (S.penTo - S.pen) * min(1, d / 0.025);\n  if (S.state === \"wait\") {\n    if ((S.wait -= d) > 0) return;\n    S.state = \"seek\";\n  }\n  if (S.state === \"hold\") {\n    if ((S.wait -= d) \u003c= 0) begin(S);\n    return;\n  }\n  const job = S.job;\n  if (S.ci >= job.chars.length) {\n    S.state = \"hold\";\n    S.wait = 1.6 * slow;\n    return;\n  }\n  const c = job.chars[S.ci];\n  if (c.line !== S.cur) {\n    // A new line: the film feeds up and the carriage goes back.\n    S.filmTo += (c.line - S.cur) * lp(S.m);\n    S.cur = c.line;\n    S.penTo = c.x;\n    S.state = \"wait\";\n    S.wait = 0.32 * slow;\n    return;\n  }\n  S.penTo = c.x;\n  if (c.ch === \" \") {\n    S.ci++;\n    return;\n  }\n  // The disk turns anticlockwise, phi radians so far, so glyph j stands at\n  // 2 pi j / n - phi clockwise from twelve and the letter after A comes\n  // to the window next.\n  const [r, j] = WHERE[c.ch], n = RINGS[r].n, off = (TAU * j) / n;\n  const a0 = (S.prev - off) / TAU, a1 = (S.phi - off) / TAU;\n  if (floor(a1) > floor(a0)) {\n    // The glyph crossed the window during this step: flash.\n    const at = floor(a1) * TAU + off;\n    S.flash = { t: S.t, r, j, phi: at, x: c.x, m: S.m };\n    S.lit.push({ ch: c.ch, x: c.x, fy: S.filmTo, m: S.m, t: S.t });\n    if (S.lit.length > 120) S.lit.shift();\n    S.ci++;\n    S.state = \"wait\";\n    S.wait = 0.01;\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1], 0.2, 3);\n  const text = cl(round(kv[2]), 0, 3), m = round(cl(kv[3], 1, 2.25) * 4) / 4;\n  if (!S.job || text !== S.text || m !== S.m) {\n    S.text = text, S.m = m;\n    begin(S);\n  }\n  if (!S.started) {\n    // Run the first copy through unseen, so the film opens with it set and\n    // the second copy a few letters in.\n    S.started = true;\n    for (let f = 0; f \u003c 2400 && !(S.jobs > 1 && S.ci > 6); f++) advance(S, 1 / 30);\n  }\n  advance(S, d);\n}\n\nfunction add(rgb, x, y, r, g, b, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  rgb[o] += r * a, rgb[o + 1] += g * a, rgb[o + 2] += b * a;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.job) return;\n  const rgb = S.rgb, c = S.c, c2 = S.c2, c3 = S.c3, t = S.t;\n  rgb.fill(0);\n  const light = hsv(0.55 + S.hue, 0.75, 1, c);\n\n  // The film: a dark strip with lighter edges.\n  const base = hsv(0.07, 0.45, 0.11, c2);\n  for (let y = 0; y \u003c= FY1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const edge = x === 1 || x === W - 2 ? 1.8 : 1;\n      add(rgb, x, y, base[0], base[1], base[2], edge);\n    }\n  // Exposed letters: white when the flash lands, cooling to the light.\n  for (const L of S.lit) {\n    const G = scaled(L.ch, L.m), top = round(GB - (S.film - L.fy) - 7 * L.m + 1);\n    if (top + G.h \u003c 0 || top > FY1) continue;\n    const w = exp(-(t - L.t) / 0.35);\n    const r0 = light[0] + (1 - light[0]) * w, g0 = light[1] + (1 - light[1]) * w, b0 = light[2] + (1 - light[2]) * w;\n    for (let py = 0; py \u003c G.h; py++) {\n      const y = top + py;\n      if (y \u003c 0 || y > FY1) continue;\n      for (let px = 0; px \u003c G.w; px++) {\n        const a = G.cov[py * G.w + px];\n        if (a) add(rgb, L.x + px, y, r0, g0, b0, a * 0.9);\n      }\n    }\n  }\n\n  // The disk.\n  // Each frame shows the disk over half the frame's turn, like a shutter\n  // open half the time.\n  const n = DISK.idx.length, span = 0.5 * (S.phi - S.prev), ns = cl(ceil((abs(span) * 28) / 1.2), 1, 6);\n  const glass = hsv(0.6 + S.hue, 0.3, 0.12, c3);\n  for (let q = 0; q \u003c n; q++) {\n    const p = DISK.idx[q], rr = DISK.rad[q], a = DISK.ang[q], ring = DISK.ring[q];\n    let r = glass[0], g = glass[1], b = glass[2];\n    if (rr > RD - 1) (r = 0.3), (g = 0.31), (b = 0.33);\n    else if (rr \u003c HUB) {\n      // The hub, with three bolts that turn with the disk.\n      let bolt = 0;\n      for (let k = 0; k \u003c 3; k++) {\n        const ba = (k * TAU) / 3 - S.phi, bx = CX + 4.6 * sin(ba), by = CY - 4.6 * cos(ba);\n        const x = (p % W) + 0.5, y = floor(p / W) + 0.5, e = (x - bx) * (x - bx) + (y - by) * (y - by);\n        bolt = max(bolt, cl(1.6 - e, 0, 1));\n      }\n      const v = 0.32 - 0.22 * bolt;\n      (r = v), (g = v * 1.02), (b = v * 1.06);\n    } else if (ring >= 0) {\n      let s = 0;\n      for (let k = 0; k \u003c ns; k++) s += diskGlyph(ring, rr, a + S.phi - (span * (k + 0.5)) / ns);\n      s /= ns;\n      r += s * (0.1 + 0.32 * light[0]), g += s * (0.1 + 0.32 * light[1]), b += s * (0.1 + 0.32 * light[2]);\n    }\n    rgb[p * 3] += r, rgb[p * 3 + 1] += g, rgb[p * 3 + 2] += b;\n  }\n\n  // The flash: the glyph at the window frozen white, a glow round it, and\n  // its light through the lens to the film.\n  const F = S.flash;\n  if (F) {\n    const age = t - F.t, e = exp(-age / 0.07), eb = exp(-age / 0.12);\n    if (e > 0.01) {\n      const rc = RINGS[F.r].rc, oy = CY - rc;\n      for (let y = floor(oy - 9); y \u003c= ceil(oy + 9); y++)\n        for (let x = 22; x \u003c 42; x++) {\n          const dx = x + 0.5 - CX, dy = y + 0.5 - CY, rr = sqrt(dx * dx + dy * dy);\n          let a = atan2(dx, -dy);\n          if (a \u003c 0) a += TAU;\n          const nn = RINGS[F.r].n, b = a + F.phi, jj = ((round((b * nn) / TAU) % nn) + nn) % nn;\n          const gv = abs(rr - rc) \u003c 4.4 && jj === F.j ? diskGlyph(F.r, rr, b) : 0;\n          const halo = exp(-(dx * dx + (y + 0.5 - oy) ** 2) / 22) * 0.35;\n          add(rgb, x, y, 1, 1, 1, gv * e * 1.2);\n          add(rgb, x, y, light[0], light[1], light[2], halo * e);\n        }\n    }\n    if (eb > 0.01) {\n      // Object 5 LEDs wide at the window, lens of half-width 7.5 where it\n      // gives magnification m for the outer ring, image 5m wide with its\n      // foot on the gate.\n      const m = F.m, o0 = CY - RINGS[0].rc, oy = CY - RINGS[F.r].rc, iy = GB + 1 - 3.5 * m, ix = F.x + 2.5 * m;\n      const ly = o0 - (o0 - iy) / (1 + m), ox = CX;\n      for (let y = floor(iy); y \u003c= ceil(oy); y++) {\n        const yc = y + 0.5;\n        let cx, hw;\n        if (yc >= ly) {\n          const u = (yc - ly) / (oy - ly);\n          (cx = ox), (hw = 7.5 + (2.5 - 7.5) * u);\n        } else {\n          const u = (ly - yc) / (ly - iy);\n          (cx = ox + (ix - ox) * u), (hw = 7.5 + (2.5 * m - 7.5) * u);\n        }\n        for (let x = floor(cx - hw - 1); x \u003c= ceil(cx + hw + 1); x++) {\n          const a = cl(hw + 0.5 - abs(x + 0.5 - cx), 0, 1);\n          add(rgb, x, y, light[0], light[1], light[2], a * eb * 0.45);\n        }\n      }\n    }\n  }\n\n  // The lens, at the height that gives the knob's magnification for the\n  // outer ring, and the carriage mark under the line.\n  {\n    const m = S.m, oy = CY - RINGS[0].rc, iy = GB + 1 - 3.5 * m, ly = oy - (oy - iy) / (1 + m);\n    const glow = F ? exp(-(t - F.t) / 0.12) : 0;\n    for (let x = 23; x \u003c= 40; x++) {\n      const u = (x + 0.5 - CX) / 8.5, hh = 1.6 * sqrt(max(0, 1 - u * u));\n      if (hh \u003c= 0) continue;\n      for (let y = floor(ly - hh); y \u003c= ceil(ly + hh); y++) {\n        const a = cl(hh + 0.5 - abs(y + 0.5 - ly), 0, 1);\n        add(rgb, x, y, 0.25 + 0.5 * light[0] * glow, 0.3 + 0.5 * light[1] * glow, 0.34 + 0.5 * light[2] * glow, a);\n      }\n    }\n    const px = round(S.pen);\n    for (let x = px; x \u003c px + 5 * m; x++) add(rgb, x, GB + 2, light[0], light[1], light[2], 0.45);\n  }\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, rgb[k] * 255) | 0, min(255, rgb[k + 1] * 255) | 0, min(255, rgb[k + 2] * 255) | 0);\n    }\n}\n","quousque-tandem":"// ===== Patternflow pattern =====\n// Title:   Quousque Tandem\n// Family:  type\n// Idea:    The opening line of Cicero's first speech against Catiline, the line Caslon's specimen sets in size after size, runs down the standing panel left aligned in a broad-nib roman, every other line leaning like the specimen's italic and each line a fixed fraction of the size of the one above, so the top lines read and the bottom closes up into a soft grey of type smaller than an LED, while the page zooms without end into its bottom left corner and every line grows into the size of the line above.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: William Caslon's specimen sheet dated 1734, its roman and italic in 14 sizes among 38 founts (Talbot Baines Reed's count, A History of the Old English Letter Foundries, 1887), which sets \"Quousque tandem abutere, Catilina, patientia nostra?\" from Cicero's first speech against Catiline (63 BC); the face here is drawn new with a broad nib, pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=0.7..0.9, Weight=0..1\n//\n// Knob 1: Hue. Turns the paper round the wheel with a near-black ink opposite it: cream paper (235, 216, 169) and a blue-black ink at 0, mint paper and a plum-black at 0.25, pale blue and a brown-black at 0.5, pink and a green-black at 0.75.\n// Knob 2: Speed. At 2 every line takes 2.5 s to grow into the line above, the page zooming 1.43 times at the opening ratio; 25 s at 0.2 and 1.7 s at 3. Roman and leaning lines swap places every period, so the picture comes round every two.\n// Knob 3: Ratio. Each line's size over the size of the line above. At the opening 0.7 the top line is 38 rows tall with capitals 24 LEDs high, 8 lines have capitals over 1.5 LEDs and the last 7 rows are the grey; at 0.8 the top line's capitals are 16 LEDs and 11 lines read; at 0.9 the capitals start at 8 LEDs, 17 lines read and the grey takes the last 21 rows.\n// Knob 4: Weight. The width of the nib: 0.089 em at the opening 0.06, where a stem is a tenth of an em, 3.5 LEDs in the top line; 0.083 em at 0 and 0.18 em at 1, where the letters go black, the counters close and the grey at the bottom darkens with them.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, log, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// ---- The face. Each letter is a skeleton in em units, y up from the\n// baseline, x from the letter's left edge, written with a broad nib held at\n// 30 degrees, so a stroke is thick across the nib and a hairline along it:\n// the slanted stress of an old-style roman, thin at eleven and five o'clock\n// in the o. Serifs and bars take a narrower nib (the number after a stroke).\n// Only the 19 letters and marks of the line are drawn.\nconst XH = 0.45, ASC = 0.74, DSC = 0.24, CAP = 0.665;\nfunction arc(cx, cy, rx, ry, a0, a1, n) {\n  const out = [];\n  n = n || max(6, ceil(abs(a1 - a0) / 9));\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    out.push(cx + rx * cos(a), cy + ry * sin(a));\n  }\n  return out;\n}\nconst S = 0.4;\nconst GLYPHS = {\n  \" \": [0.26],\n  o: [0.5, [arc(0.25, 0.225, 0.17, 0.215, 0, 360)]],\n  e: [0.45, [[0.08, 0.25, 0.4, 0.25], 0.6], [arc(0.235, 0.225, 0.16, 0.215, 8, 325)]],\n  a: [0.46, [[0.37, 0.06, ...arc(0.22, 0.3, 0.15, 0.13, 0, 145), 0.1, 0.34]], [[0.37, 0.26, ...arc(0.22, 0.13, 0.15, 0.13, 90, 300), 0.37, 0.08]], [[0.37, 0.06, 0.4, 0, 0.46, 0.02], S]],\n  n: [0.54, [[0.1, 0, 0.1, XH]], [[0.1, 0.33, ...arc(0.27, 0.29, 0.17, 0.15, 150, 0), 0.44, 0]], [[0.02, 0, 0.18, 0], S], [[0.36, 0, 0.52, 0], S], [[0.02, 0.42, 0.1, XH], S]],\n  m: [0.82, [[0.1, 0, 0.1, XH]], [[0.1, 0.33, ...arc(0.255, 0.29, 0.155, 0.15, 150, 0), 0.41, 0]], [[0.41, 0.33, ...arc(0.565, 0.29, 0.155, 0.15, 150, 0), 0.72, 0]],\n    [[0.02, 0, 0.18, 0], S], [[0.33, 0, 0.49, 0], S], [[0.64, 0, 0.8, 0], S], [[0.02, 0.42, 0.1, XH], S]],\n  u: [0.54, [[0.1, XH, ...arc(0.27, 0.16, 0.17, 0.16, 180, 360)]], [[0.44, XH, 0.44, 0]], [[0.44, 0, 0.52, 0], S], [[0.02, 0.42, 0.1, XH], S], [[0.36, 0.42, 0.44, XH], S]],\n  i: [0.28, [[0.13, 0, 0.13, XH]], [[0.04, 0, 0.22, 0], S], [[0.05, 0.42, 0.13, XH], S], [[0.12, 0.6, 0.145, 0.635]]],\n  l: [0.28, [[0.13, 0, 0.13, 0.72]], [[0.04, 0, 0.22, 0], S], [[0.05, 0.69, 0.13, 0.72], S]],\n  t: [0.32, [[0.12, 0.58, 0.12, 0.08, 0.15, 0.01, 0.22, 0, 0.29, 0.04]], [[0.02, 0.43, 0.27, 0.43], 0.6]],\n  d: [0.54, [[0.44, 0.37, ...arc(0.25, 0.225, 0.165, 0.215, 60, 300), 0.44, 0.07]], [[0.44, 0.72, 0.44, 0]], [[0.36, 0.69, 0.44, 0.72], S], [[0.44, 0, 0.52, 0], S]],\n  b: [0.54, [[0.1, 0.72, 0.1, 0]], [arc(0.29, 0.225, 0.16, 0.215, 120, -120)], [[0.02, 0.69, 0.1, 0.72], S]],\n  p: [0.54, [[0.1, XH, 0.1, -0.22]], [arc(0.29, 0.225, 0.16, 0.215, 120, -120)], [[0.02, 0.42, 0.1, XH], S], [[0.02, -0.22, 0.18, -0.22], S]],\n  q: [0.54, [[0.44, 0.37, ...arc(0.25, 0.225, 0.165, 0.215, 60, 300), 0.44, 0.07]], [[0.44, XH, 0.44, -0.22]], [[0.36, -0.22, 0.52, -0.22], S]],\n  r: [0.38, [[0.1, 0, 0.1, XH]], [[0.1, 0.32, 0.15, 0.4, 0.22, 0.445, 0.3, 0.45, 0.35, 0.42]], [[0.02, 0, 0.2, 0], S], [[0.02, 0.42, 0.1, XH], S]],\n  s: [0.4, [[...arc(0.2, 0.34, 0.12, 0.105, 15, 250), ...arc(0.2, 0.115, 0.135, 0.115, 90, -165)]]],\n  Q: [0.76, [arc(0.38, 0.33, 0.29, 0.335, 0, 360)], [[0.33, 0.02, 0.45, -0.06, 0.6, -0.13, 0.74, -0.16], 0.9]],\n  C: [0.68, [arc(0.38, 0.33, 0.28, 0.335, 42, 318)], [[0.585, 0.55, 0.6, 0.66], S]],\n  \",\": [0.24, [[0.1, 0.05, 0.09, -0.02, 0.05, -0.12]], [[0.08, 0.06, 0.11, 0.03]]],\n  \"?\": [0.42, [[...arc(0.21, 0.53, 0.13, 0.13, 160, -60), 0.21, 0.33, 0.21, 0.2]], [[0.2, 0.02, 0.225, 0.05]]],\n};\nconst LINE = \"Quousque tandem abutere, Catilina, patientia nostra? \";\n\n// ---- The strip: the line set once at E texels to the em, each texel an\n// ink count of 0..16 from a 4 by 4 supersample, kept as a summed-area table\n// two periods long. The ink over any box of the line, at any size, is then\n// four lookups, so a line a tenth of an LED high is as exact as a big one.\nconst E = 40, SS = 4, SH = Math.round((ASC + DSC) * E), BASE = ASC * E, K = E * SS;\nconst NIB = 0.088, NIB_A = (30 * PI) / 180, HAIR = 0.009, PAD = 0.08;\nconst DX = cos(NIB_A), DY = sin(NIB_A);\n\n// One letter at the 4x supersample, the nib stamped every eighth of a texel along\n// each stroke: a bar nib long and two hairlines wide, laid at 30 degrees.\nfunction glyphTile(ch, nib, hair) {\n  const g = GLYPHS[ch], TW = ceil((g[0] + 2 * PAD) * K), TH = SH * SS;\n  const t = new Uint8Array(TW * TH);\n  const stamp = (px, py, n) => {\n    const ex = DX * n + hair, ey = DY * n + hair;\n    const i0 = max(0, floor((px - ex + PAD) * K)), i1 = min(TW - 1, ceil((px + ex + PAD) * K));\n    const j0 = max(0, floor((ASC - py - ey) * K)), j1 = min(TH - 1, ceil((ASC - py + ey) * K));\n    for (let j = j0; j \u003c= j1; j++) {\n      const qy = ASC - (j + 0.5) / K - py;\n      for (let i = i0; i \u003c= i1; i++) {\n        const qx = (i + 0.5) / K - PAD - px;\n        if (abs(qx * DX + qy * DY) \u003c= n && abs(qx * DY - qy * DX) \u003c= hair) t[j * TW + i] = 1;\n      }\n    }\n  };\n  for (let s = 1; s \u003c g.length; s++) {\n    const pts = g[s][0], n = (nib / 2) * (g[s][1] || 1);\n    for (let p = 0; p + 3 \u003c pts.length; p += 2) {\n      const ax = pts[p], ay = pts[p + 1], bx = pts[p + 2], by = pts[p + 3];\n      const steps = max(1, ceil(sqrt((bx - ax) ** 2 + (by - ay) ** 2) * K * 2));\n      for (let q = 0; q \u003c= steps; q++) stamp(ax + ((bx - ax) * q) / steps, ay + ((by - ay) * q) / steps, n);\n    }\n  }\n  return { t, TW };\n}\n\nfunction buildStrip(weight) {\n  const nib = NIB * (0.94 + 1.1 * weight), hair = HAIR * (0.9 + 0.8 * weight);\n  let adv = 0;\n  const xs = [];\n  for (const ch of LINE) xs.push(adv), (adv += GLYPHS[ch][0]);\n  const P = round(adv * E), HW = P * SS, HH = SH * SS, hi = new Uint8Array(HW * HH), tiles = {};\n  LINE.split(\"\").forEach((ch, c) => {\n    if (ch === \" \") return;\n    const { t, TW } = tiles[ch] || (tiles[ch] = glyphTile(ch, nib, hair));\n    const o = round((xs[c] - PAD) * K);\n    for (let j = 0; j \u003c HH; j++)\n      for (let i = 0; i \u003c TW; i++) if (t[j * TW + i]) hi[j * HW + ((o + i + HW) % HW)] = 1;\n  });\n  const SW = 2 * P, SW1 = SW + 1, sat = new Int32Array((SH + 1) * SW1);\n  for (let r = 0; r \u003c SH; r++) {\n    let run = 0;\n    for (let c = 0; c \u003c SW; c++) {\n      const cc = c % P;\n      let n = 0;\n      for (let j = 0; j \u003c SS; j++) for (let i = 0; i \u003c SS; i++) n += hi[(r * SS + j) * HW + cc * SS + i];\n      run += n;\n      sat[(r + 1) * SW1 + c + 1] = sat[r * SW1 + c + 1] + run;\n    }\n  }\n  return { P, SW, sat };\n}\n\n// The ink above row v and left of column u, bilinear between the corners,\n// which is the exact area integral of ink that is constant over a texel.\nfunction satAt(st, u, v) {\n  const SW1 = st.SW + 1, sat = st.sat;\n  let iu = floor(u), iv = floor(v), fu = u - iu, fv = v - iv;\n  if (iu >= st.SW) (iu = st.SW - 1), (fu = 1);\n  if (iv >= SH) (iv = SH - 1), (fv = 1);\n  const o = iv * SW1 + iu, a = sat[o], b = sat[o + 1], c = sat[o + SW1], d = sat[o + SW1 + 1];\n  return (a + (b - a) * fu) * (1 - fv) + (c + (d - c) * fu) * fv;\n}\n\n// ---- The sheet. Line v (v = 0 the top line) fills rows 128 (1 - r^v) to\n// 128 (1 - r^(v+1)), its em that height over LEAD, its left edge 0.06 em in.\n// That is the picture of one page scaled by r about its bottom left corner\n// again and again, so moving every v down by one over a period zooms the\n// page by 1/r and each line takes the place and size of the line above.\nconst LEAD = 1.05, PERIOD = 2.5;\n// The grain: a checker of LEDs G levels lighter and darker over the whole\n// sheet, eased off where a soft step of the ink's own is already there so\n// the two never add up past a step of 40.\nconst G = 19.5, HARD = 60;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, w: -1, st: null, cache: {}, hue: 0, ratio: 0.7,\n    cov: new Float32Array(W * H), emRow: new Float32Array(H), F: new Float32Array(W + 1),\n    pc: [0, 0, 0], ic: [0, 0, 0],\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  const S0 = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0.7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S0.hue = kv[0] || 0;\n  const speed = cl(kv[1] ?? 2, 0.2, 3);\n  S0.ratio = cl(kv[2] ?? 0.7, 0.7, 0.9);\n  // The weight in sixteenths. A strip takes about 40 ms to build, so the\n  // last few are kept while the knob turns.\n  const w = round(cl(kv[3] ?? 0.06, 0, 1) * 16) / 16;\n  if (w !== S0.w) {\n    if (!S0.cache[w] && Object.keys(S0.cache).length >= 6) S0.cache = {};\n    S0.w = w;\n    S0.st = S0.cache[w] || (S0.cache[w] = buildStrip(w));\n  }\n  S0.t += (d * speed) / 2;\n}\n\nexport function draw(display, params) {\n  const S0 = params.s;\n  if (!S0 || !S0.st) return;\n  const st = S0.st, cov = S0.cov, emRow = S0.emRow, F = S0.F, P = st.P;\n  cov.fill(0);\n  emRow.fill(0);\n  const lr = log(S0.ratio), cyc = S0.t / PERIOD, ph = cyc % 1, n0 = floor(cyc);\n  const Y = (v) => H - H * exp(v * lr);\n  for (let k = 0; k \u003c 200; k++) {\n    const v = k - ph, top = Y(v), bot = Y(v + 1);\n    if (H - top \u003c 0.04) break;\n    if (bot \u003c= 0) continue;\n    const em = (bot - top) / LEAD, y0 = top + ((LEAD - 1) / 2) * em, sc = E / em, xl = 0.06 * em;\n    for (let y = max(0, floor(top)); y \u003c min(H, ceil(bot)); y++) {\n      const va = cl((y - y0) * sc, 0, SH), vb = cl((y + 1 - y0) * sc, 0, SH);\n      if (vb \u003c= va) continue;\n      if (em > emRow[y]) emRow[y] = em;\n      // Every other line leans 12 degrees for the italic: a texel row h\n      // above the baseline is read 0.21 h further left.\n      const sl = (k + n0) & 1 ? 0.21 * (BASE - (va + vb) / 2) : 0;\n      for (let x = 0; x \u003c= W; x++) F[x] = max(0, (x - xl) * sc - sl);\n      for (let x = 0, o = y * W; x \u003c W; x++) {\n        let u0 = F[x], u1 = F[x + 1];\n        if (u1 \u003c= u0) continue;\n        const wrap = floor(u0 / P) * P;\n        u0 -= wrap;\n        u1 -= wrap;\n        cov[o + x] += (satAt(st, u1, vb) - satAt(st, u0, vb) - satAt(st, u1, va) + satAt(st, u0, va)) / (16 * sc * sc);\n      }\n    }\n  }\n  // Type over 4 LEDs to the cap is drawn crisp, its coverage pushed toward\n  // ink or paper with a soft edge a quarter of an LED wide; under 1.5 LEDs\n  // it keeps its exact area, the grey of the small sizes.\n  for (let y = 0; y \u003c H; y++) {\n    const m = 1 + 3 * cl((emRow[y] * CAP - 1.5) / 2.5, 0, 1);\n    for (let x = 0, o = y * W; x \u003c W; x++) cov[o + x] = cl((min(1, cov[o + x]) - 0.5) * m + 0.5, 0, 1);\n  }\n  const pc = hsv(0.12 + S0.hue, 0.28, 0.92, S0.pc), ic = hsv(0.62 + S0.hue, 0.85, 0.075, S0.ic);\n  const con = 255 * (max(pc[0], pc[1], pc[2]) - max(ic[0], ic[1], ic[2])), hc = HARD / con;\n  const p0 = 255 * pc[0], p1 = 255 * pc[1], p2 = 255 * pc[2];\n  const d0 = 255 * ic[0] - p0, d1 = 255 * ic[1] - p1, d2 = 255 * ic[2] - p2;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const c = cov[o];\n      let gd = 0;\n      const nb = (e) => (e = abs(c - e)) \u003c hc && e > gd && (gd = e);\n      if (x > 0) nb(cov[o - 1]);\n      if (x \u003c W - 1) nb(cov[o + 1]);\n      if (y > 0) nb(cov[o - W]);\n      if (y \u003c H - 1) nb(cov[o + W]);\n      const a = G * max(0, 1 - (gd * con) / (2 * G)), g = (x + y) & 1 ? a : -a;\n      display.setPixel(x, y, cl(p0 + d0 * c + g, 0, 255) | 0, cl(p1 + d1 * c + g, 0, 255) | 0, cl(p2 + d2 * c + g, 0, 255) | 0);\n    }\n}\n","aharonov-bohm":"// ===== Patternflow pattern =====\n// Title:   Aharonov-Bohm\n// Family:  wave\n// Idea:    Plane waves run down the panel past a thin tube of magnetic flux a third of the way down, where no field reaches them, yet behind the tube the crests on the two sides of its shadow line come out shifted against each other by the flux in quanta and end at a torn seam, coloured by how far each crest has slipped behind the wave that would pass with no tube.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Aharonov-Bohm effect (Yakir Aharonov and David Bohm, 1959; Werner Ehrenberg and Raymond Siday, 1949), wavefront dislocations (Michael Berry, Robert Chambers, Mark Large, Colin Upstill and J. C. Walmsley, 1980), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wavelength=7..16, Flux=0.5..1.5\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 a crest that passes as if there were no tube is blue; at the opening flux of half a quantum the crests left of the shadow line come out a quarter wave ahead and turn green, those on the right a quarter wave behind and turn magenta, and a crest a whole wave out would be blue again.\n// Knob 2: Speed. How fast the crests run down: 8 LEDs a second at 2, 0.8 at 0.2 and 12 at 3.\n// Knob 3: Wavelength. The distance between crests, 7 LEDs at the opening, 16 at the top. A longer wave diffracts more: the band behind the tube where the two sides blend is about the square root of wavelength times distance wide, 25 LEDs across at the bottom row at 7 and 37 at 16.\n// Knob 4: Flux. The flux through the tube in flux quanta h/e. At 0.5 the two sides come out half a wave apart and the shadow line is an exact dark seam; at 1 the wave passes as if the tube were not there; at 1.5 it is half a wave again, the mirror image of 0.5. The wave only knows the flux modulo one quantum.\n\nconst W = 64, H = 128, N = W * H, HALF = W / 2;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, exp, pow, cbrt, atan2, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The tube sits on the corner between four LEDs, on the middle line, a third\n// of the way down.\nconst TX = 32, TY = 42;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Gamma on [1, 2] by Lanczos (g = 7, nine terms), good to about 1e-15.\nconst LZ = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7];\nfunction gamma(x) {\n  x -= 1;\n  let a = LZ[0];\n  const t = x + 7.5;\n  for (let i = 1; i \u003c 9; i++) a += LZ[i] / (x + i);\n  return sqrt(2 * PI) * pow(t, x + 0.5) * exp(-t) * a;\n}\n\n// Bessel functions J of orders nu0, nu0 + 1, ..., nu0 + M at z, for one\n// fractional part nu0 in [0, 1), by Miller's backward recurrence\n//   J(v - 1) = (2 v / z) J(v) - J(v + 1)\n// started from nothing well above z, then scaled by Neumann's sum\n//   (z / 2)^nu0 = sum over k of (nu0 + 2k) Gamma(nu0 + k) / k! J(nu0 + 2k),\n// whose weights w[k] depend on nu0 only.\nfunction weights(nu0, K) {\n  const w = new Float64Array(K + 1);\n  w[0] = gamma(nu0 + 1);\n  let g = w[0];\n  for (let k = 1; k \u003c= K; k++) {\n    w[k] = (nu0 + 2 * k) * g;\n    g = (g * (nu0 + k)) / (k + 1);\n  }\n  return w;\n}\nfunction besselRun(nu0, z, M, w, out) {\n  let fp = 0, f = 1e-30, sum = (M & 1) === 0 ? w[M >> 1] * f : 0;\n  out[M] = f;\n  for (let n = M; n >= 1; n--) {\n    const fm = ((2 * (nu0 + n)) / z) * f - fp;\n    fp = f;\n    f = fm;\n    out[n - 1] = f;\n    if (((n - 1) & 1) === 0) sum += w[(n - 1) >> 1] * f;\n    if (abs(f) > 1e200) {\n      for (let j = n - 1; j \u003c= M; j++) out[j] *= 1e-200;\n      (sum *= 1e-200), (fp *= 1e-200), (f *= 1e-200);\n    }\n  }\n  const sc = pow(z / 2, nu0) / sum;\n  for (let n = 0; n \u003c= M; n++) out[n] *= sc;\n}\n\n// The Aharonov-Bohm wave. Round the tube the vector potential circles with\n// A = a / r in units of the flux quantum, and the wave equation splits into\n// angular orders m, each with the radial Bessel function of order |m - a|.\n// With theta measured from the way the wave runs (down the panel), the\n// solution that is regular at the tube and whose incoming part is the plane\n// wave exp(i k x) is\n//   psi = sum over m of (-1)^m (-i)^|m - a| J_|m - a|(k r) exp(i m theta),\n// Aharonov and Bohm's series turned to face down the panel. At a = 0 it is\n// the plane wave to 1e-14; at a = 1/2 the orders m and 1 - m pair off and\n// cancel on theta = 0, so the shadow line is an exact zero.\n//\n// Which a? The flux F in quanta enters only as exp(2 pi i F) round a loop,\n// so F and F + 1 are the same physics, and a whole quantum can be taken out\n// by a gauge change. The picture takes one out, a = F - 1, so F = 1 is the\n// bare plane wave exactly, as F = 0 would be. Over the knob's range a runs\n// from -1/2 to 1/2: the two ends are both half a quantum, drawn in gauges a\n// quantum apart, and come out as mirror images, the same seam with the\n// colours of its sides swapped. The orders' sum is done for an LED and its\n// mirror across the shadow line at once, since they share r and differ only\n// in the sign of theta.\nconst MM = 260, ROWS = 32;\n\n// A field is worked out in a buffer of its own, ROWS rows a frame, while the\n// last finished one stays on the panel; the first appears after 4 frames.\nfunction newField() {\n  return { amp: new Float32Array(N), ph: new Float32Array(N), lag: new Float32Array(N), lam: 0, flux: 0, row: 0, a: 0, k: 0, nuP: 0, nuQ: 0, wP: null, wQ: null };\n}\nfunction begin(S, G, F, lam) {\n  const a = F - 1, fr = (x) => x - floor(x);\n  Object.assign(G, { lam, flux: F, row: 0, a, k: (2 * PI) / lam, nuP: fr(-a), nuQ: fr(a) });\n  G.wP = weights(G.nuP, MM);\n  G.wQ = weights(G.nuQ, MM);\n  const { fam, nn, cr, ci } = S;\n  for (let m = -MM; m \u003c= MM; m++) {\n    const d = m - a, j = m + MM, sg = m & 1 ? -1 : 1, nu = abs(d);\n    if (d >= 0) (fam[j] = 0), (nn[j] = round(d - G.nuP));\n    else (fam[j] = 1), (nn[j] = round(-d - G.nuQ));\n    cr[j] = sg * cos((PI * nu) / 2);\n    ci[j] = -sg * sin((PI * nu) / 2);\n  }\n}\nfunction rows(S, G, y0, y1) {\n  const { JP, JQ, fam, nn, cr, ci } = S, { amp, ph, lag, k, nuP, nuQ, wP, wQ } = G;\n  const put = (p, re, im, ox) => {\n    amp[p] = sqrt(re * re + im * im);\n    ph[p] = atan2(im, re);\n    // The slip behind the bare wave exp(i k x), in turns, -1/2 to 1/2.\n    const l = (ph[p] - ox) / (2 * PI);\n    lag[p] = l - round(l);\n  };\n  for (let y = y0; y \u003c y1; y++) {\n    const X = y + 0.5 - TY;\n    for (let x = HALF; x \u003c W; x++) {\n      const Y = x + 0.5 - TX, r = sqrt(X * X + Y * Y), th = atan2(Y, X), z = k * r;\n      let M = ceil(z + 8 * cbrt(z) + 16);\n      M = min(MM - 2, M + (M & 1));\n      besselRun(nuP, z, M + 1, wP, JP);\n      besselRun(nuQ, z, M + 1, wQ, JQ);\n      // A = sum c_m J cos(m theta), B = sum c_m J sin(m theta), both complex;\n      // psi(theta) = A + iB and psi(-theta) = A - iB.\n      let Ar = 0, Ai = 0, Br = 0, Bi = 0, cm = 1, sm = 0;\n      const c1 = cos(th), s1 = sin(th);\n      for (let m = 0; m \u003c= M; m++) {\n        let j = m + MM, J = fam[j] ? JQ[nn[j]] : JP[nn[j]];\n        (Ar += cr[j] * J * cm), (Ai += ci[j] * J * cm), (Br += cr[j] * J * sm), (Bi += ci[j] * J * sm);\n        if (m > 0) {\n          (j = MM - m), (J = fam[j] ? JQ[nn[j]] : JP[nn[j]]);\n          (Ar += cr[j] * J * cm), (Ai += ci[j] * J * cm), (Br -= cr[j] * J * sm), (Bi -= ci[j] * J * sm);\n        }\n        const t = cm * c1 - sm * s1;\n        sm = sm * c1 + cm * s1;\n        cm = t;\n      }\n      put(y * W + x, Ar - Bi, Ai + Br, k * X);\n      put(y * W + W - 1 - x, Ar + Bi, Ai - Br, k * X);\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, t: 0, cur: null, job: null, spare: [newField(), newField()],\n    JP: new Float64Array(MM + 2), JQ: new Float64Array(MM + 2),\n    fam: new Int8Array(2 * MM + 1), nn: new Int32Array(2 * MM + 1), cr: new Float64Array(2 * MM + 1), ci: new Float64Array(2 * MM + 1),\n    c: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 7, 0.5], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // A new field starts only when the wavelength or the flux has moved by a\n  // visible step; turning the knob again restarts it.\n  const lam = round(cl(k[2], 7, 16) * 20) / 20, flux = round(cl(k[3], 0.5, 1.5) * 200) / 200;\n  const aim = S.job || S.cur;\n  if (!aim || aim.lam !== lam || aim.flux !== flux) {\n    S.job = S.spare.find((G) => G !== S.cur);\n    begin(S, S.job, flux, lam);\n  }\n  if (S.job) {\n    const G = S.job, y1 = min(H, G.row + ROWS);\n    rows(S, G, G.row, y1);\n    G.row = y1;\n    if (y1 >= H) (S.cur = G), (S.job = null);\n  }\n  S.t += d;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cur) return;\n  const { amp, ph, lag, lam } = S.cur, c = S.c;\n  // Crests run down at 4 * Speed LEDs a second: the phase turns by k v t.\n  const wt = ((2 * PI) / lam) * 4 * S.speed * S.t, h0 = 0.62 + S.hue;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, A = amp[p];\n      const re = A * cos(ph[p] - wt);\n      const crest = re > 0 ? pow(re, 1.6) : 0;\n      const v = min(1, 0.07 * A + 0.93 * crest);\n      hsv(h0 + lag[p], 0.85 - 0.35 * crest * crest, v, c);\n      display.setPixel(x, y, (255 * c[0]) | 0, (255 * c[1]) | 0, (255 * c[2]) | 0);\n    }\n  // The tube itself, end on: a small white core.\n  for (let p = 0; p \u003c 4; p++) display.setPixel(31 + (p & 1), 41 + (p >> 1), 235, 235, 245);\n}\n","boustrophedon":"// ===== Patternflow pattern =====\n// Title:   Boustrophedon\n// Family:  type\n// Idea:    A point of light ploughs a field of twenty furrows line after line, turning under the cooled letters of its last pass and writing Hesiod's crane passage into the furrow behind it, mirrored on every line it ploughs back, so the eye follows the ox across the panel and down.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: boustrophedon, the archaic Greek way of writing as the ox turns (the law code of Gortyn, 5th century BC), reverse boustrophedon as in rongorongo; text from Hesiod, Works and Days 448-451, translated by Hugh G. Evelyn-White (1914); pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Way=-1..1, Words=0..2\n//\n// Knob 1: Hue. Turns the field and the letters round the wheel together: at 0 the furrows run from deep blue in the troughs to pale blue on the ridges, fresh letters are cream gold and cool to light blue over half a minute.\n// Knob 2: Speed. How fast the plough writes: 8 letters a second at 2, so a line of 15 takes under 2 s and the whole field of 300 about 40 s; 0.8 a second at 0.2, 12 at 3.\n// Knob 3: Way. How the plough turns at the end of a line, taken up at the start of the next one. At 0 boustrophedon: the plough turns and writes the next line right to left with every letter mirrored. At -1 every line runs left to right and the plough lifts and flies back to the left edge. At 1 reverse boustrophedon, as on the rongorongo tablets: the return lines are turned upside down, as if the field were turned round for each.\n// Knob 4: Words. How words are parted. At 0 by a column of three dots, the word divider of many archaic inscriptions; at 1 not at all, the letters run on as scriptio continua; at 2 by a blank, as we write now.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Capitals, 3 by 5, rows from the top. Archaic inscriptions were cut in\n// capitals with no small letters. Glyph 26 is the word divider, three dots in\n// a column; 27 is a blank.\nconst GLYPHS = [\n  \"010101111101101\", \"110101110101110\", \"011100100100011\", \"110101101101110\", \"111100110100111\",\n  \"111100110100100\", \"011100101101011\", \"101101111101101\", \"111010010010111\", \"001001001101010\",\n  \"101101110101101\", \"100100100100111\", \"101111111101101\", \"111101101101101\", \"010101101101010\",\n  \"110101110100100\", \"010101101110011\", \"110101110101101\", \"011100010001110\", \"111010010010010\",\n  \"101101101101111\", \"101101101101010\", \"101101111111101\", \"101101010101101\", \"101101010010010\",\n  \"111001010100111\", \"010000010000010\", \"000000000000000\",\n];\nconst FONT = GLYPHS.map((g) => Uint8Array.from(g, (c) => +c));\nconst DIV = 26, BLANK = 27;\n\n// Hesiod, Works and Days 448-451, in Evelyn-White's translation: \"Mark, when\n// you hear the voice of the crane who cries year by year from the clouds\n// above, for she gives the signal for ploughing and shows the season of rainy\n// winter; but she vexes the heart of the man who has no oxen.\" The stone has\n// no commas: only letters and word breaks are kept, and the end of the\n// sentence is one more word break before it starts again.\nconst SRC =\n  \"MARK WHEN YOU HEAR THE VOICE OF THE CRANE WHO CRIES YEAR BY YEAR FROM THE CLOUDS ABOVE FOR SHE GIVES THE SIGNAL FOR PLOUGHING AND SHOWS THE SEASON OF RAINY WINTER BUT SHE VEXES THE HEART OF THE MAN WHO HAS NO OXEN \";\n// The text as cells for each way of parting words, and where each cell came\n// from in SRC, so turning Words mid-line carries on from the same place.\nconst SEQ = [[], [], []], SPOS = [[], [], []];\nfor (let m = 0; m \u003c 3; m++)\n  for (let i = 0; i \u003c SRC.length; i++) {\n    const ch = SRC[i];\n    if (ch === \" \") {\n      if (m === 1) continue;\n      SEQ[m].push(m === 0 ? DIV : BLANK);\n    } else SEQ[m].push(ch.charCodeAt(0) - 65);\n    SPOS[m].push(i);\n  }\n\n// ---- The field. 15 letters a line, 4 LEDs a cell (3 and a gap), from x = 2;\n// 20 lines 6 rows apart from y = 4, the letter in the 5 rows of the furrow\n// and the ridge in the sixth. The furrows run on into the 4-row margins.\nconst NC = 15, NL = 20, CW = 4, LP = 6, X0 = 2, Y0 = 4, CELLS = NC * NL;\n// Across a furrow the ground climbs and falls by D a row, trough in the\n// middle of the letter, ridge between lines. Along it the soil is grained a\n// column at a time, so every pair of neighbours differs a little.\nconst LO = 6, D = 24;\nconst TRI = [2, 1, 0, 1, 2, 3];\nconst ROWB = new Float32Array(H), ROWT = new Float32Array(H);\nfor (let y = 0; y \u003c H; y++) {\n  const r = (((y - Y0) % LP) + LP) % LP;\n  ROWB[y] = LO + D * TRI[r];\n  ROWT[y] = TRI[r] / 3;\n}\nconst GRAIN = new Float32Array(W * H);\nfor (let p = 0; p \u003c W * H; p++) {\n  let h = (p * 2654435761) >>> 0;\n  h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0;\n  h = ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n  GRAIN[p] = (p % W) & 1 ? 20 + 10 * h : 6 * h;\n}\n\n// Letters give their own light, so cloud shadows pass them by. A fresh one\n// stands at C_NEW and sinks to C_OLD as it cools; each keeps a third of the\n// furrow's shape and most of its grain, so the strokes are not flat.\nconst C_NEW = 226, C_OLD = 216, TAU = 30, KEEP_SHAPE = 0.33, KEEP_GRAIN = 0.7;\n\n// Cells a second at Speed s; a turn costs one cell's time, the flight back\n// to the left edge three.\nconst RATE = 4;\n// Light of the share's point and of the turned soil behind it.\nconst SHARE = 220, WAKE = 60;\nconst turnLen = (way) => (way \u003c 0 ? 3 : 1);\n// Direction and orientation of grid line l written the given way:\n// orientation 0 upright, 1 mirrored, 2 turned 180 degrees. Rongorongo is\n// read from the bottom line up; here every way ploughs from the top down, so\n// only the turn at the end of a line changes.\nconst dirOf = (way, l) => (way !== 0 && way !== 1) || l % 2 === 0 ? 1 : -1;\nconst orientOf = (way, l) => (dirOf(way, l) > 0 ? 0 : way === 0 ? 1 : 2);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, ready: false, hue: 0, speed: 2, way: 0, words: 0,\n    line: 0, pos: 0, lineWay: 0, j: 0, cell: -1,\n    glyph: new Uint8Array(CELLS), orient: new Uint8Array(CELLS), birth: new Float32Array(CELLS),\n    // What lay in the cell under the plough before it got there.\n    oldG: 0, oldO: 0, oldB: 0,\n    rgb: new Float32Array(W * H * 3),\n  };\n}\n\n// Grid cell of in-line step i on grid line l, written in direction dir.\nconst cellAt = (l, i, dir) => l * NC + (dir > 0 ? i : NC - 1 - i);\n\n// The field the plough finds when it starts: the pass before, written the\n// same way, ending with the cells just before the opening words, its oldest\n// letters already cooled.\nfunction prefill(S) {\n  const seq = SEQ[S.words], P = seq.length, rate = RATE * S.speed;\n  const per = NC + turnLen(S.way);\n  for (let l = 0; l \u003c NL; l++) {\n    const dir = dirOf(S.way, l), o = orientOf(S.way, l);\n    for (let i = 0; i \u003c NC; i++) {\n      const k = l * NC + i, c = cellAt(l, i, dir);\n      S.glyph[c] = seq[(((k - CELLS) % P) + P) % P];\n      S.orient[c] = o;\n      S.birth[c] = -(NL * per - (l * per + i)) / rate;\n    }\n  }\n  S.j = 0;\n  S.lineWay = S.way;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.way = cl(round(k[2]), -1, 1);\n  const words = cl(round(k[3]), 0, 2);\n  if (words !== S.words) {\n    // Carry on from the same place in the sentence with the new parting.\n    const from = SPOS[S.words][S.j % SPOS[S.words].length];\n    const sp = SPOS[words];\n    let j = 0;\n    while (j \u003c sp.length && sp[j] \u003c from) j++;\n    S.j = j % sp.length;\n    S.words = words;\n  }\n  if (!S.ready) {\n    prefill(S);\n    S.ready = true;\n  }\n  S.t += d;\n  S.pos += d * RATE * S.speed;\n  const end = NC + turnLen(S.lineWay);\n  if (S.pos >= end) {\n    S.pos -= end;\n    S.line++;\n    S.lineWay = S.way;\n    S.cell = -1;\n  }\n  const l = S.line % NL, i = floor(S.pos);\n  if (i \u003c NC) {\n    const c = cellAt(l, i, dirOf(S.lineWay, l));\n    if (c !== S.cell) {\n      // The share reaches a new cell: what was there is turned under as the\n      // next letter of the text goes in.\n      S.cell = c;\n      S.oldG = S.glyph[c], S.oldO = S.orient[c], S.oldB = S.birth[c];\n      const seq = SEQ[S.words];\n      S.glyph[c] = seq[S.j % seq.length];\n      S.j = (S.j + 1) % seq.length;\n      S.orient[c] = orientOf(S.lineWay, l);\n      S.birth[c] = S.t;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const { rgb } = S, t = S.t, hue = S.hue;\n  const trough = hsv(0.66 + hue, 0.78, 1), ridge = hsv(0.55 + hue, 0.42, 1);\n  const fresh = hsv(0.12 + hue, 0.38, 1), cool = hsv(0.6 + hue, 0.5, 1);\n\n  // Cloud shadows drift over the soil, darkening it by up to 38%.\n  const cx = 0.07, cy = 0.045, wx = 0.035, wy = -0.06;\n  const ca = t * 0.9, cb = t * 0.7 + 1.7;\n\n  for (let y = 0; y \u003c H; y++) {\n    const base = ROWB[y], tt = ROWT[y];\n    let r0 = trough[0] + (ridge[0] - trough[0]) * tt, g0 = trough[1] + (ridge[1] - trough[1]) * tt, b0 = trough[2] + (ridge[2] - trough[2]) * tt;\n    const m = max(r0, g0, b0);\n    (r0 /= m), (g0 /= m), (b0 /= m);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      const cloud = 0.81 + 0.095 * (sin(cx * x + cy * y - ca) + sin(wx * x + wy * y + cb));\n      const v = (base + GRAIN[p]) * cloud;\n      rgb[p * 3] = r0 * v, rgb[p * 3 + 1] = g0 * v, rgb[p * 3 + 2] = b0 * v;\n    }\n  }\n\n  // The plough: where it is along the current line, and the column of the\n  // cell it is in that its share has reached.\n  const l = S.line % NL, dir = dirOf(S.lineWay, l), i = floor(S.pos), f = S.pos - i;\n  for (let c = 0; c \u003c CELLS; c++) {\n    const col = c % NC, row = floor(c / NC), x0 = X0 + col * CW, y0 = Y0 + row * LP;\n    const under = c === S.cell && i \u003c NC;\n    for (let q = 0; q \u003c 3; q++) {\n      // Under the plough, columns it has passed show the new letter and the\n      // rest the old one.\n      let g = S.glyph[c], o = S.orient[c], b = S.birth[c];\n      if (under) {\n        const u = dir > 0 ? (q + 0.5) / CW : (CW - 0.5 - q) / CW;\n        if (u >= f) (g = S.oldG), (o = S.oldO), (b = S.oldB);\n      }\n      const gl = FONT[g], age = t - b, w = exp(-age / TAU);\n      const lvl = C_OLD + (C_NEW - C_OLD) * w, glint = age \u003c 0.5 ? 40 * (1 - age / 0.5) : 0;\n      const cr = cool[0] + (fresh[0] - cool[0]) * w, cg = cool[1] + (fresh[1] - cool[1]) * w, cb2 = cool[2] + (fresh[2] - cool[2]) * w;\n      const cm = max(cr, cg, cb2);\n      for (let r = 0; r \u003c 5; r++) {\n        const sq = o === 0 ? q : 2 - q, sr = o === 2 ? 4 - r : r;\n        if (!gl[sr * 3 + sq]) continue;\n        const y = y0 + r, x = x0 + q, p = y * W + x;\n        const v = min(255, lvl + glint + KEEP_SHAPE * (ROWB[y] - LO) + KEEP_GRAIN * GRAIN[p]);\n        rgb[p * 3] = (cr / cm) * v, rgb[p * 3 + 1] = (cg / cm) * v, rgb[p * 3 + 2] = (cb2 / cm) * v;\n      }\n    }\n  }\n\n  // The point of the share, a warm light in the furrow, and the turned soil\n  // behind it glowing for a few cells. On the flight back to the left edge\n  // the share is lifted and dim.\n  let tx, ty, a = 1, wake = 1, wx0;\n  const yl = Y0 + l * LP + 2;\n  if (i \u003c NC) {\n    const col = dir > 0 ? i : NC - 1 - i;\n    tx = X0 + col * CW + (dir > 0 ? f * CW : (1 - f) * CW);\n    ty = yl;\n    wx0 = tx;\n  } else {\n    const u = (S.pos - NC) / turnLen(S.lineWay), sm = u * u * (3 - 2 * u);\n    const nl = (l + 1) % NL, xe = dir > 0 ? X0 + NC * CW : X0;\n    const xs = S.lineWay \u003c 0 ? X0 : dirOf(S.lineWay, nl) > 0 ? X0 : X0 + NC * CW;\n    const ny = Y0 + nl * LP + 2;\n    tx = xe + (xs - xe) * sm;\n    ty = yl + (ny - yl) * sm;\n    wx0 = xe;\n    wake = 1 - u;\n    if (S.lineWay \u003c 0) a = 0.35 + 0.65 * Math.abs(1 - 2 * u);\n  }\n  const lamp = hsv(0.1 + hue, 0.3, 1), soil = hsv(0.07 + hue, 0.55, 1);\n  for (let y = yl - 2; y \u003c= yl + 3; y++) {\n    const rw = y === yl + 3 ? 0.5 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const ahead = (x + 0.5 - wx0) * dir;\n      const v = WAKE * wake * rw * (ahead > 0 ? exp(-ahead * ahead) : exp(ahead / 7));\n      if (v \u003c 1) continue;\n      const p = (y * W + x) * 3;\n      rgb[p] += soil[0] * v, rgb[p + 1] += soil[1] * v, rgb[p + 2] += soil[2] * v;\n    }\n  }\n  const x0 = max(0, floor(tx - 9)), x1 = min(W - 1, floor(tx + 9)), y0 = max(0, floor(ty - 9)), y1 = min(H - 1, floor(ty + 9));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x + 0.5 - tx, dy = y + 0.5 - ty, r2 = dx * dx + dy * dy;\n      const v = a * (SHARE * exp(-r2 / 1.8) + 50 * exp(-r2 / 30));\n      const p = (y * W + x) * 3;\n      rgb[p] += lamp[0] * v, rgb[p + 1] += lamp[1] * v, rgb[p + 2] += lamp[2] * v;\n    }\n\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","calculator-words":"// ===== Patternflow pattern =====\n// Title:   Calculator Words\n// Family:  type\n// Idea:    A pocket calculator fills the panel and keys in a little sum, its keys lighting as they go down, then turns itself upside down so the answer on its seven-segment display reads as a word, 0.7734 as hELLO with the decimal point hanging at the top of the line, holds it, and turns back for the next riddle.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: upside-down calculator spelling on seven-segment displays (BEGHILOS, the 1970s pocket calculator pastime), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Words=0..3, Glow=0..1\n//\n// Knob 1: Hue. The colour of the display, with the operator keys and the body following it round the wheel: at 0 a blue-green vacuum fluorescent display over orange operator keys on a slate body; at 0.54 the red of the first LED calculators.\n// Knob 2: Speed. How fast the machine works: at 2 a key goes down every 0.22 s and the turn takes 1.3 s, so hELLO is keyed, turned, read and turned back in 7.7 s; at 0.2 it takes ten times as long, at 3 two thirds.\n// Knob 3: Words. Which riddles: 0 the classics (hELLO, BOSS, LOSE, GLOBE, GOOSE, EGGSHELL); 1 short words (hI, BEE, OIL, BIG, EGG, ShOE, SOIL); 2 long ones made by multiplying two numbers (LEGIBLE, SLEIGh, BOGGLE, OBLIGE, GIGGLE, SIZZLE, hOBBIES); 3 answers under 1, whose decimal point turns up at the top of the word (IGLOO, hELLO, SILO, SOLO, hOBO, BOO).\n// Knob 4: Glow. How much light the display spills: at 0 the unlit segments are almost gone and the digits stand sharp on dark glass; at the opening 0.06 the unlit segments show faintly as a ghost 8 in every place; at 1 the ghosts glow at half strength, a haze spreads round every lit digit, and the display's light falls over the body and the top rows of keys.\n// Buttons: any knob's button clears the calculator and starts the next riddle, when the calculator stands the right way up.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The riddles. Each is the sum the machine keys after C, written with *\n// and / for the keys x and the division sign; = follows. Read upside down,\n// a digit becomes the letter its segments make when turned: 0 O, 1 I, 2 Z,\n// 3 E, 4 h, 5 S, 7 L, 8 B, 9 G (a 9 with its tail turns into a 6 shape).\n// The order of the digits turns round as well, so 0.7734 reads hELLO.\n// Every answer was checked by turning the segment masks below, not by a\n// table of letters: the display is only ever drawn the right way up.\nconst SETS = [\n  // 0.7734 hELLO, 5508 BOSS, 3507 LOSE, 38079 GLOBE, 35009 GOOSE, and SHELL\n  // (77345) times 1000 plus 993, 77345993 EGGSHELL, the longest the 8 places\n  // hold.\n  [\"1-.2266\", \"68*81\", \"21*167\", \"9*4231\", \"13*2693\", \"155*499*1000+993\"],\n  // 14 hI, 338 BEE, 710 OIL, 918 BIG, 993 EGG, 3045 ShOE, 7105 SOIL.\n  [\"2*7\", \"13*26\", \"10*71\", \"27*34\", \"3*331\", \"35*87\", \"29*245\"],\n  // 3781937 LEGIBLE, 491375 SLEIGh, 379908 BOGGLE, 391780 OBLIGE, 379919\n  // GIGGLE, 372215 SIZZLE, 5318804 hOBBIES.\n  [\"967*3911\", \"125*3931\", \"519*732\", \"380*1031\", \"181*2099\", \"493*755\", \"4*1329701\"],\n  // 0.0791 IGLOO, 0.7734 hELLO, 0.715 SILO, 0.705 SOLO, 0.804 hOBO, 0.08 BOO.\n  [\".113*.7\", \"3.867/5\", \"1.43/2\", \"1.41/2\", \"4.02/5\", \".2*.4\"],\n];\n\n// ---- Seven segments, bit 0 to 6 for a to g: a the top bar, b and c the\n// right side from the top, d the bottom bar, e and f the left side from the\n// bottom, g the middle bar. A 6 keeps its top bar and a 9 its tail, a 7 has\n// no f: so a turned 7 is an L and not a 4 with a hook.\nconst SEG = { 0: 63, 1: 6, 2: 91, 3: 79, 4: 102, 5: 109, 6: 125, 7: 7, 8: 127, 9: 111, \"-\": 64 };\n// A digit is 5 LEDs wide and 11 tall, 1 LED strokes, with the corners left\n// dark so every segment stands apart; the decimal point sits one column to\n// the right of the bottom bar.\nconst SEGPX = [[], [], [], [], [], [], []];\nfor (let i = 1; i \u003c= 3; i++) SEGPX[0].push([i, 0]), SEGPX[3].push([i, 10]), SEGPX[6].push([i, 5]);\nfor (let j = 1; j \u003c= 4; j++) SEGPX[1].push([4, j]), SEGPX[5].push([0, j]), SEGPX[2].push([4, j + 5]), SEGPX[4].push([0, j + 5]);\nconst DIG_X = 5, DIG_P = 7, DIG_Y = 11;\n\n// ---- The keypad: 4 columns of 13 LEDs, 5 rows of 15, labels in 3 by 5.\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001001001001\", 8: \"111101111101111\", 9: \"111101111001111\",\n  C: \"011100100100011\", p: \"010111010000111\", \"%\": \"101001010100101\", d: \"010000111000010\", x: \"000101010101000\",\n  \"-\": \"000000111000000\", \"+\": \"000010111010000\", \"=\": \"000111000111000\", \".\": \"000000000000010\",\n};\nconst LAYOUT = [\n  [\"C\", \"p\", \"%\", \"d\"],\n  [\"7\", \"8\", \"9\", \"x\"],\n  [\"4\", \"5\", \"6\", \"-\"],\n  [\"1\", \"2\", \"3\", \"+\"],\n  [\"0\", null, \".\", \"=\"],\n];\nconst KEYS = [];\nLAYOUT.forEach((row, r) =>\n  row.forEach((id, c) => {\n    if (!id) return;\n    const wide = id === \"0\";\n    KEYS.push({ id, x: 3 + 15 * c, y: 32 + 19 * r, w: wide ? 28 : 13, kind: r === 0 ? 0 : c === 3 || id === \"=\" ? 2 : 1 });\n  }),\n);\nconst KEYIX = {};\nKEYS.forEach((k, i) => (KEYIX[k.id] = i));\n\n// Machine time is seconds at Speed 2.\nconst KEY = 0.22, HOLD = 0.8, TURN = 1.3, BACK = 1.1, PAUSE = 0.35;\n\n// ---- The arithmetic of a plain pocket calculator: an operator key works\n// out what is pending, left to right, and shows it.\nfunction fmt(v) {\n  if (!isFinite(v) || abs(v) >= 1e8) return \"E\";\n  const neg = v \u003c 0;\n  v = abs(v);\n  const ints = v \u003c 1 ? 1 : floor(Math.log10(v)) + 1;\n  let s = v.toFixed(max(0, 8 - ints));\n  if (s.indexOf(\".\") >= 0) s = s.replace(/0+$/, \"\").replace(/\\.$/, \"\");\n  return (neg ? \"-\" : \"\") + s;\n}\nfunction apply(a, op, b) {\n  return op === \"+\" ? a + b : op === \"-\" ? a - b : op === \"x\" ? a * b : b === 0 ? NaN : a / b;\n}\nfunction press(S, id) {\n  const c = S.calc;\n  if (id === \"C\") (c.acc = 0), (c.op = null), (c.entry = null), (c.disp = \"0\");\n  else if ((id >= \"0\" && id \u003c= \"9\") || id === \".\") {\n    if (c.entry === null) c.entry = id === \".\" ? \"0.\" : id;\n    else if (c.entry.replace(/\\D/g, \"\").length \u003c 8 && !(id === \".\" && c.entry.includes(\".\"))) c.entry += id;\n    c.disp = c.entry;\n  } else if (id === \"=\" || id === \"+\" || id === \"-\" || id === \"x\" || id === \"d\") {\n    if (c.entry !== null) {\n      c.acc = c.op ? apply(c.acc, c.op, Number(c.entry)) : Number(c.entry);\n      c.entry = null;\n      c.disp = fmt(c.acc);\n    }\n    c.op = id === \"=\" ? null : id;\n  }\n  if (KEYIX[id] !== undefined) S.pressed[KEYIX[id]] = S.clock;\n}\n\n// The display string, right aligned in 8 places, as segment masks with bit\n// 7 for the decimal point.\nfunction cells(disp) {\n  const out = new Uint8Array(8);\n  if (disp === \"E\") return (out[7] = 121), out;\n  let i = 7;\n  for (let j = disp.length - 1; j >= 0 && i >= 0; j--) {\n    const ch = disp[j];\n    if (ch === \".\") {\n      j--;\n      out[i--] = SEG[disp[j]] | 128;\n    } else out[i--] = SEG[ch];\n  }\n  return out;\n}\n\nfunction startRiddle(S) {\n  const list = SETS[S.set];\n  const expr = list[S.ri % list.length];\n  S.keys = [\"C\", ...expr.split(\"\").map((ch) => (ch === \"*\" ? \"x\" : ch === \"/\" ? \"d\" : ch)), \"=\"];\n  S.ki = 0;\n  S.mt = 0;\n  S.tEq = (S.keys.length - 1) * KEY;\n  S.read = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, glow: 0.06, set: -1, ri: 0, keys: [], ki: 0, mt: 0, tEq: 0, read: 0, clock: 0,\n    theta: 0, calc: { acc: 0, op: null, entry: null, disp: \"0\" },\n    pressed: new Float32Array(KEYS.length).fill(-99),\n    face: new Float32Array(W * H * 3), halo: new Float32Array(W * 32), tmp: new Float32Array(W * 32),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.glow = cl(k[3], 0, 1);\n  const set = min(3, floor(cl(k[2], 0, 3)));\n  if (S.set \u003c 0) (S.set = set), startRiddle(S);\n  const step = (d * S.speed) / 2;\n  S.mt += step;\n  S.clock += step;\n  // Keys go down on the beat; a long frame may hold more than one.\n  while (S.ki \u003c S.keys.length && S.mt >= S.ki * KEY) press(S, S.keys[S.ki++]);\n  if (S.ki === S.keys.length && !S.read) S.read = 1.6 + 0.15 * S.calc.disp.replace(/\\D/g, \"\").length;\n  const t0 = S.tEq + HOLD, t1 = t0 + TURN, t2 = t1 + (S.read || 9), t3 = t2 + BACK;\n  // Over, then back the way it came.\n  S.theta = S.mt \u003c t1 ? PI * ease((S.mt - t0) / TURN) : PI * (1 - ease((S.mt - t2) / BACK));\n  let next = S.mt >= t3 + PAUSE;\n  if (input.btnPressed && input.btnPressed.some(Boolean) && S.theta === 0) next = true;\n  if (next) {\n    if (set !== S.set) (S.set = set), (S.ri = 0);\n    else S.ri++;\n    startRiddle(S);\n  }\n}\n\n// ---- Drawing the face, always the right way up, into a buffer of its own.\nfunction put(F, x, y, c, m) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (F[o] = c[0] * m), (F[o + 1] = c[1] * m), (F[o + 2] = c[2] * m);\n}\nfunction add(F, x, y, c, m) {\n  const o = (y * W + x) * 3;\n  (F[o] += c[0] * m), (F[o + 1] += c[1] * m), (F[o + 2] += c[2] * m);\n}\n\nfunction drawFace(S) {\n  const F = S.face, hd = 0.46 + S.hue, g = S.glow;\n  const body = hsv(hd + 0.15, 0.32, 0.15), bezel = hsv(hd + 0.15, 0.3, 0.06), glass = hsv(hd, 0.7, 0.035 + 0.1 * g);\n  const lit = hsv(hd, 0.55, 1), ghost = hsv(hd, 0.65, 0.07 + 0.45 * g), haze = hsv(hd, 0.8, 1);\n  F.fill(0);\n  // Body: a rounded slab 62 by 126 with a lit top edge and a dark bottom.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const cx = x + 0.5, cy = y + 0.5;\n      const qx = max(5 - cx, 0, cx - 59), qy = max(5 - cy, 0, cy - 123), a = cl(4.5 - sqrt(qx * qx + qy * qy), 0, 1);\n      if (a \u003c= 0) continue;\n      const sh = y \u003c= 1 ? 1.5 : y >= 126 ? 0.55 : x \u003c= 1 ? 1.2 : x >= 62 ? 0.75 : 1;\n      put(F, x, y, body, a * sh);\n    }\n  for (let y = 5; y \u003c= 27; y++) for (let x = 2; x \u003c= 61; x++) put(F, x, y, y === 27 ? body : bezel, y === 27 ? 1.35 : 1);\n  for (let y = 6; y \u003c= 26; y++) for (let x = 3; x \u003c= 60; x++) put(F, x, y, glass, 1);\n\n  // Display. The haze is the lit segments blurred twice by a 5-wide box.\n  const cs = cells(S.calc.disp), Hz = S.halo, T = S.tmp;\n  Hz.fill(0);\n  for (let i = 0; i \u003c 8; i++) {\n    const x0 = DIG_X + DIG_P * i;\n    for (let s = 0; s \u003c 7; s++) {\n      const on = (cs[i] >> s) & 1;\n      for (const [dx, dy] of SEGPX[s]) {\n        put(F, x0 + dx, DIG_Y + dy, on ? lit : ghost, 1);\n        if (on) Hz[(DIG_Y + dy - 4) * W + x0 + dx] = 1;\n      }\n    }\n    const dp = (cs[i] >> 7) & 1;\n    put(F, x0 + 5, DIG_Y + 10, dp ? lit : ghost, 1);\n    if (dp) Hz[(DIG_Y + 6) * W + x0 + 5] = 1;\n  }\n  for (let pass = 0; pass \u003c 2; pass++) {\n    for (let y = 0; y \u003c 32; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let j = -2; j \u003c= 2; j++) a += Hz[y * W + cl(x + j, 0, W - 1)];\n        T[y * W + x] = a / 5;\n      }\n    for (let y = 0; y \u003c 32; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let j = -2; j \u003c= 2; j++) a += T[cl(y + j, 0, 31) * W + x];\n        Hz[y * W + x] = a / 5;\n      }\n  }\n  const hz = 0.25 + 1.6 * g;\n  for (let y = 6; y \u003c= 26; y++) for (let x = 3; x \u003c= 60; x++) add(F, x, y, haze, hz * Hz[(y - 4) * W + x]);\n\n  // Keys: function keys pale, number keys dark, operator keys in colour.\n  // A key that goes down drops one row, loses its shadow and lights up,\n  // fading over a quarter of a second of machine time.\n  const face = [hsv(hd + 0.15, 0.1, 0.42), hsv(hd + 0.15, 0.2, 0.22), hsv(hd + 0.62, 0.8, 0.62)];\n  const glowc = [hsv(hd + 0.15, 0.05, 0.85), hsv(hd, 0.45, 0.7), hsv(hd + 0.62, 0.55, 1)];\n  const ink = [hsv(hd + 0.15, 0.3, 0.07), hsv(hd + 0.15, 0.05, 0.8), hsv(hd + 0.62, 0.15, 1)];\n  const white = [1, 1, 1];\n  for (let i = 0; i \u003c KEYS.length; i++) {\n    const K = KEYS[i], P = max(0, Math.exp(-(S.clock - S.pressed[i]) / 0.25)), dy = P > 0.35 ? 1 : 0, kd = K.kind;\n    const col = [0, 1, 2].map((j) => face[kd][j] + (glowc[kd][j] - face[kd][j]) * P);\n    if (!dy) for (let x = K.x + 1; x \u003c K.x + K.w - 1; x++) put(F, x, K.y + 15, body, 0.45);\n    for (let r = 0; r \u003c 15; r++)\n      for (let q = 0; q \u003c K.w; q++) {\n        if ((r === 0 || r === 14) && (q === 0 || q === K.w - 1)) continue;\n        put(F, K.x + q, K.y + dy + r, col, r === 0 ? 1.3 : r === 14 ? 0.62 : q === K.w - 1 ? 0.85 : 1);\n      }\n    const gl = GLYPH[K.id], gx = K.x + (K.w >> 1) - 1, gy = K.y + dy + 5;\n    const ic = [0, 1, 2].map((j) => ink[kd][j] + (white[j] - ink[kd][j]) * P * (kd === 0 ? 0.3 : 1));\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (gl[r * 3 + q] === \"1\") put(F, gx + q, gy + r, ic, 1);\n  }\n  // The display's light falls on the body and the top rows of keys below\n  // it, as a vacuum fluorescent display does in a dark room.\n  const sp = 0.3 * g * g + 0.1 * g;\n  if (sp > 0)\n    for (let y = 28; y \u003c 100; y++) {\n      const m = sp * Math.exp(-(y - 28) / 16);\n      for (let x = 1; x \u003c 63; x++) add(F, x, y, haze, m * (0.6 + 0.4 * sin((PI * (x - 1)) / 61)));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  drawFace(S);\n  const F = S.face, th = S.theta, c = cos(th), s = sin(th);\n  const out = (x, y, r, g, b) => display.setPixel(x, y, (255 * min(1, r)) | 0, (255 * min(1, g)) | 0, (255 * min(1, b)) | 0);\n  if (s \u003c 1e-6) {\n    // At rest, either way up, the face lands on the LEDs one for one: a half\n    // turn about the panel's centre sends LED (x, y) to (63 - x, 127 - y).\n    const up = c > 0;\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const o = ((up ? y : H - 1 - y) * W + (up ? x : W - 1 - x)) * 3;\n        out(x, y, F[o], F[o + 1], F[o + 2]);\n      }\n    return;\n  }\n  // Turning: the face shrinks just enough that its corners stay on the\n  // panel, and holds at 0.45 while it lies more than 63 degrees over, so it\n  // does not swell at 90 degrees; every LED takes four bilinear samples.\n  const f = s > 2 * abs(c) ? 143.11 : 64 * abs(c) + 128 * s, sc = 64 / f;\n  const ic = c / sc, is = s / sc;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      for (let k = 0; k \u003c 4; k++) {\n        const px = x + 0.25 + 0.5 * (k & 1) - 32, py = y + 0.25 + 0.5 * (k >> 1) - 64;\n        const u = ic * px + is * py + 31.5, v = -is * px + ic * py + 63.5;\n        const u0 = floor(u), v0 = floor(v), fu = u - u0, fv = v - v0;\n        for (let j = 0; j \u003c 4; j++) {\n          const uu = u0 + (j & 1), vv = v0 + (j >> 1);\n          if (uu \u003c 0 || uu >= W || vv \u003c 0 || vv >= H) continue;\n          const wgt = ((j & 1) ? fu : 1 - fu) * ((j >> 1) ? fv : 1 - fv), o = (vv * W + uu) * 3;\n          (r += F[o] * wgt), (g += F[o + 1] * wgt), (b += F[o + 2] * wgt);\n        }\n      }\n      out(x, y, r / 4, g / 4, b / 4);\n    }\n}\n","caustic-letters":"// ===== Patternflow pattern =====\n// Title:   Caustic Letters\n// Family:  type\n// Idea:    The panel is the floor of a pool lit from above, and the water surface is shaped so the light it bends spells a word: while a gust or a dropped stone roughens it the light runs in a net of bright caustic lines, and as the ripples calm the same light gathers into the word, until the next disturbance breaks it and brings the next word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: goal-based caustics (Marios Papas, Wojciech Jarosz, Wenzel Jakob, Szymon Rusinkiewicz, Wojciech Matusik and Tim Weyrich, Goal-Based Caustics, 2011), high-contrast computational caustic design (Yuliy Schwartzburg, Romain Testuz, Andrea Tagliasacchi and Mark Pauly, 2014); the Knothe-Rosenblatt rearrangement (Murray Rosenblatt, 1952; Herbert Knothe, 1957) stands in here for the optimal-transport map the 2014 paper solves for; pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ripple=1..3, Focus=-1..1\n//\n// Knob 1: Hue. Turns the water light round the wheel: at 0 the dim light is a deep azure and the brightest lines a pale aqua.\n// Knob 2: Speed. A word's whole cycle, from the gust through the calm to the next gust, takes 8 s at 2, 80 s at 0.2 and 5.3 s at 3; the waves travel faster or slower with it.\n// Knob 3: Ripple. How high the waves stand, as a multiple of the opening height. At 1 the net of caustic lines has round cells 15 to 20 LEDs across and the calm word lies nearly still; at 3 the lines fold into sharp-cornered shards and the word trembles even in the calm.\n// Knob 4: Focus. Where the floor lies against the depth the surface was shaped for. At 0 the word is sharp. At -1 the floor is at half that depth and the word is a soft glow half way from even light. At 1 it is half as deep again and the light overshoots: each stroke pinches to a thin bright line, and the rows of the map show as faint threads across the gaps between letters.\n// Buttons: any knob's button drops a stone, which breaks the word now and brings the next one.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters, as strokes of round-ended pen. Latin capitals are drawn in a\n// unit box and stacked down the panel like a hotel sign; the three jamo of\n// 빛 (ㅂ, ㅣ and the final ㅊ) are drawn straight onto the 64 by 128 panel.\nconst G_ARC = [];\nfor (let a = 40; a \u003c= 350; a += 15) G_ARC.push([0.5 + 0.5 * cos((a * PI) / 180), 0.5 - 0.5 * sin((a * PI) / 180)]);\nG_ARC.push([0.55, 0.5 - 0.5 * sin((350 * PI) / 180)]);\nconst LATIN = {\n  L: [26, [[[0, 0], [0, 1], [1, 1]]]],\n  I: [18, [[[0.5, 0], [0.5, 1]], [[0.1, 0], [0.9, 0]], [[0.1, 1], [0.9, 1]]]],\n  G: [34, [G_ARC]],\n  H: [32, [[[0, 0], [0, 1]], [[1, 0], [1, 1]], [[0, 0.5], [1, 0.5]]]],\n  T: [36, [[[0, 0], [1, 0]], [[0.5, 0], [0.5, 1]]]],\n  W: [46, [[[0, 0], [0.22, 1], [0.5, 0.32], [0.78, 1], [1, 0]]]],\n  A: [38, [[[0, 1], [0.5, 0], [1, 1]], [[0.21, 0.66], [0.79, 0.66]]]],\n  V: [38, [[[0, 0], [0.5, 1], [1, 0]]]],\n  E: [28, [[[1, 0], [0, 0], [0, 1], [1, 1]], [[0, 0.5], [0.85, 0.5]]]],\n};\nconst BIT = [\n  [[[9, 8], [9, 58]], [[38, 8], [38, 58]], [[9, 33], [38, 33]], [[9, 58], [38, 58]]],\n  [[[53, 5], [53, 70]]],\n  [[[25, 77], [37, 77]], [[9, 88], [54, 88]], [[31, 92], [9, 121]], [[25.5, 100], [55, 121]]],\n];\n\n// A word becomes a list of segments [x0, y0, x1, y1] in LEDs and a pen radius.\nfunction layout(word) {\n  if (word === \"빛\") return { r: 3.2, segs: BIT.flat().flatMap(segsOf((x, y) => [x, y])) };\n  const n = word.length, ch = 124 / n, r = n > 4 ? 2.5 : 2.8, gap = n > 4 ? 4.2 : 5;\n  const segs = [];\n  for (let i = 0; i \u003c n; i++) {\n    const [w, strokes] = LATIN[word[i]];\n    const top = 2 + i * ch + r + gap / 2, h = ch - 2 * r - gap, left = 32 - w / 2;\n    for (const pl of strokes) segs.push(...segsOf((x, y) => [left + x * w, top + y * h])(pl));\n  }\n  return { r, segs };\n}\nfunction segsOf(map) {\n  return (pl) => {\n    const out = [];\n    for (let k = 0; k + 1 \u003c pl.length; k++) {\n      const [a, b] = map(pl[k][0], pl[k][1]), [c, d] = map(pl[k + 1][0], pl[k + 1][1]);\n      out.push([a, b, c, d]);\n    }\n    return out;\n  };\n}\n\n// The light the floor should receive: the word's mask, softened by one pass\n// of a 1-2-1 blur, over a floor of 0.1 so some light lands everywhere.\nconst FLOOR = 0.1;\nfunction density(word) {\n  const { r, segs } = layout(word);\n  const d2 = new Float32Array(W * H).fill(1e9), m = new Float32Array(W * H), rho = new Float32Array(W * H);\n  // Each segment only looks at the LEDs inside its own box.\n  for (const [a, b, c, d] of segs) {\n    const ex = c - a, ey = d - b, l2 = ex * ex + ey * ey;\n    const x0 = max(0, floor(min(a, c) - r - 1)), x1 = min(W - 1, floor(max(a, c) + r + 1));\n    const y0 = max(0, floor(min(b, d) - r - 1)), y1 = min(H - 1, floor(max(b, d) + r + 1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x + 0.5, py = y + 0.5;\n        const t = l2 > 0 ? cl(((px - a) * ex + (py - b) * ey) / l2, 0, 1) : 0;\n        const qx = px - a - t * ex, qy = py - b - t * ey, q = qx * qx + qy * qy;\n        if (q \u003c d2[y * W + x]) d2[y * W + x] = q;\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++) m[p] = cl(r + 0.5 - sqrt(d2[p]), 0, 1);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let dy = -1; dy \u003c= 1; dy++)\n        for (let dx = -1; dx \u003c= 1; dx++) s += m[cl(y + dy, 0, H - 1) * W + cl(x + dx, 0, W - 1)] * (2 - (dx & 1)) * (2 - (dy & 1));\n      rho[y * W + x] = FLOOR + s / 16;\n    }\n  return rho;\n}\n\n// ---- Photons. Two by two per LED leave the surface evenly, each from a\n// fixed random point inside its own quarter of the LED; on a regular grid\n// the rows of photons landed as dashed lines across the dim floor. The waves\n// are summed on the 65 by 129 corners of the LEDs, and each photon reads the\n// push under it bilinearly from its cell (PC) at the offsets in PFG.\nconst PX = 128, PY = 256, NP = PX * PY, GW = W + 1, GH = H + 1;\nconst SU = new Float32Array(NP), SV = new Float32Array(NP);\nconst jit = (p, k) => {\n  let h = Math.imul(p ^ (k * 0x9e3779b9), 0x85ebca6b) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst PC = new Int32Array(NP), PFG = new Float64Array(2 * NP);\nfor (let j = 0; j \u003c PY; j++)\n  for (let i = 0; i \u003c PX; i++) {\n    const p = j * PX + i, u = (i + jit(p, 1)) / 2, v = (j + jit(p, 2)) / 2;\n    const cx = min(W - 1, floor(u)), cy = min(H - 1, floor(v));\n    SU[p] = u, SV[p] = v, PC[p] = cy * GW + cx, PFG[2 * p] = u - cx, PFG[2 * p + 1] = v - cy;\n  }\n\n// ---- The Knothe-Rosenblatt map T from even light onto a density rho. The\n// height comes first: a photon's share of the way down the surface is\n// matched to the same share of rho's row sums. Then, inside the row it lands\n// in, its share across is matched to the same share of that row. Both are\n// inverse cumulative sums, read linearly inside an LED. T moves light only\n// down and then across, so it is not the cheapest map, the one the 2014\n// paper solves for by optimal transport, but it carries exactly rho.\nfunction knothe(rho) {\n  const Mc = new Float64Array(H + 1), C = new Float64Array(H * (W + 1));\n  for (let r = 0; r \u003c H; r++) {\n    let s = 0;\n    for (let c = 0; c \u003c W; c++) (C[r * (W + 1) + c] = s), (s += rho[r * W + c]);\n    C[r * (W + 1) + W] = s;\n    Mc[r + 1] = Mc[r] + s;\n  }\n  const TX = new Float32Array(NP), TY = new Float32Array(NP), M = Mc[H];\n  for (let p = 0; p \u003c NP; p++) {\n    const v = (SV[p] / H) * M;\n    let lo = 0, hi = H - 1;\n    while (lo \u003c hi) {\n      const mid = (lo + hi + 1) >> 1;\n      if (Mc[mid] \u003c= v) lo = mid;\n      else hi = mid - 1;\n    }\n    const r = lo, row = Mc[r + 1] - Mc[r], w = (SU[p] / W) * row, o = r * (W + 1);\n    let a = 0, b = W - 1;\n    while (a \u003c b) {\n      const mid = (a + b + 1) >> 1;\n      if (C[o + mid] \u003c= w) a = mid;\n      else b = mid - 1;\n    }\n    TY[p] = r + (v - Mc[r]) / row;\n    TX[p] = a + (w - C[o + a]) / rho[r * W + a];\n  }\n  return [TX, TY];\n}\n\nconst WORDS = [\"LIGHT\", \"빛\", \"WAVE\"];\n// A word's map takes about 20 ms, so each is made the first time it is needed.\nconst MAPS = [];\nconst mapOf = (i) => MAPS[i] || (MAPS[i] = knothe(density(WORDS[i])));\n\n// ---- Waves. A plane wave is a travelling sine on the surface; a photon is\n// pushed along the wave's direction by the surface slope, a cos(k.u - wt),\n// where a is set by f = a |k|, the fold number: past f = 1 neighbouring\n// photons cross and a caustic line is born. Deep-water dispersion,\n// w = sqrt(g k), lets long waves overtake short ones.\nconst GRAV = 25;\nfunction wave(dir, lambda, f) {\n  const k = (2 * PI) / lambda;\n  return { kx: k * cos(dir), ky: k * sin(dir), w: sqrt(GRAV * k), ph: Math.random() * 2 * PI, a: f / k, ex: cos(dir), ey: sin(dir) };\n}\nfunction gust() {\n  const d0 = Math.random() * 2 * PI, out = [];\n  for (let i = 0; i \u003c 4; i++) out.push(wave(d0 + (i - 1.5) * 0.75 + (Math.random() - 0.5) * 0.5, 10 + 14 * Math.random(), 1.1));\n  return out;\n}\n\nconst CYCLE = 8;\n\nfunction startCycle(S, drop) {\n  S.prev = S.word;\n  S.word = (S.word + 1) % WORDS.length;\n  S.ct = 0;\n  S.n++;\n  S.gust = gust();\n  // Every other word is broken by a drop instead of a gust: a ring of waves\n  // from one point, with a weaker gust under it.\n  S.drop = drop || S.n % 2 === 0;\n  S.dx = 10 + 44 * Math.random();\n  S.dy = 16 + 96 * Math.random();\n}\n\nexport function setup(params) {\n  const res = [];\n  for (let i = 0; i \u003c 3; i++) res.push(wave(0.6 + i * 2.1, 13 + 5 * i, 0.07));\n  params.s = {\n    t: 0, ct: 0.6, n: 0, word: 0, prev: 0, gust: gust(), drop: false, dx: 32, dy: 64, res,\n    hue: 0, speed: 2, ripple: 1, focus: 0.06,\n    key: \"\", B: new Float64Array(2 * NP),\n    GX: new Float64Array(GW * GH), GY: new Float64Array(GW * GH), E: new Float64Array((W + 2) * (H + 2)),\n    AX: new Float64Array(9), AY: new Float64Array(9),\n    CX: new Float64Array(9 * GW), SX: new Float64Array(9 * GW), CY: new Float64Array(9 * GH), SY: new Float64Array(9 * GH),\n    GR: new Float32Array(800), LUT: new Uint8Array(3072),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.ripple = cl(k[2], 1, 3);\n  S.focus = cl(k[3], -1, 1);\n  // Time runs in the seconds of Speed 2.\n  const step = (d * S.speed) / 2;\n  S.t += step;\n  S.ct += step;\n  if (S.ct >= CYCLE) startCycle(S, false);\n  if (input.btnPressed && input.btnPressed.some(Boolean) && S.ct > 0.5) startCycle(S, true);\n}\n\n// Wave q's push and its two tables of sines for this frame.\nfunction setWave(S, q, w, g) {\n  const { CX, SX, CY, SY, AX, AY } = S;\n  AX[q] = w.a * g * w.ex;\n  AY[q] = w.a * g * w.ey;\n  for (let i = 0; i \u003c GW; i++) (CX[q * GW + i] = cos(w.kx * i)), (SX[q * GW + i] = sin(w.kx * i));\n  for (let j = 0; j \u003c GH; j++) {\n    const b = w.ky * j - w.w * S.t + w.ph;\n    (CY[q * GH + j] = cos(b)), (SY[q * GH + j] = sin(b));\n  }\n}\n\n// The drop: a ring packet leaving the point at 20 LEDs a second, spreading\n// as it goes and weakening about as 1 / sqrt(r). GR holds its radial push.\nfunction addDrop(S, ct, amp) {\n  const { GX, GY, GR } = S;\n  const R = 20 * ct, sg = 3 + 1.6 * ct, kd = (2 * PI) / 9, ad = (2.6 / kd) * amp * exp(-ct / 2.2) * smooth(ct / 0.15);\n  for (let m = 0; m \u003c 800; m++) {\n    const r = m * 0.25, u = (r - R) / sg;\n    GR[m] = (ad * exp(-u * u) * sin(kd * (r - R))) / sqrt(1 + r / 12);\n  }\n  for (let j = 0; j \u003c GH; j++)\n    for (let i = 0; i \u003c GW; i++) {\n      const ux = i - S.dx, uy = j - S.dy, r = sqrt(ux * ux + uy * uy);\n      if (r \u003c 0.5) continue;\n      const g = GR[min(799, floor(r * 4))] / r;\n      GX[j * GW + i] += g * ux;\n      GY[j * GW + i] += g * uy;\n    }\n}\n\n// The push of the slope at each corner: cos(A + B) with A from the column\n// and B from the row, so the sines come from two short tables per wave.\nfunction sumWaves(S, nw) {\n  const { GX, GY, CX, SX, CY, SY, AX, AY } = S;\n  GX.fill(0);\n  GY.fill(0);\n  for (let q = 0; q \u003c nw; q++) {\n    const ax = AX[q], ay = AY[q], qx = q * GW;\n    for (let j = 0, o = 0; j \u003c GH; j++, o += GW) {\n      const cy = CY[q * GH + j], sy = SY[q * GH + j];\n      for (let i = 0; i \u003c GW; i++) {\n        const c = CX[qx + i] * cy - SX[qx + i] * sy;\n        GX[o + i] += ax * c;\n        GY[o + i] += ay * c;\n      }\n    }\n  }\n}\n\n// Land every photon and splat it bilinearly into E, which has a border of\n// one LED all round so the splat needs no tests.\nfunction splat(S, s) {\n  const { GX, GY, E, B } = S, EW = W + 2;\n  E.fill(0);\n  for (let p = 0; p \u003c NP; p++) {\n    const c = PC[p], f = PFG[2 * p], g = PFG[2 * p + 1], c2 = c + GW;\n    const dx = (GX[c] + (GX[c + 1] - GX[c]) * f) * (1 - g) + (GX[c2] + (GX[c2 + 1] - GX[c2]) * f) * g;\n    const dy = (GY[c] + (GY[c + 1] - GY[c]) * f) * (1 - g) + (GY[c2] + (GY[c2 + 1] - GY[c2]) * f) * g;\n    const fx = B[2 * p] + s * dx, fy = B[2 * p + 1] + s * dy;\n    const x0 = floor(fx), y0 = floor(fy);\n    if (x0 \u003c -1 || x0 >= W || y0 \u003c -1 || y0 >= H) continue;\n    const ax = fx - x0, ay = fy - y0, o = (y0 + 1) * EW + x0 + 1, by = 1 - ay;\n    E[o] += (1 - ax) * by;\n    E[o + 1] += ax * by;\n    E[o + EW] += (1 - ax) * ay;\n    E[o + EW + 1] += ax * ay;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const ct = S.ct, amp = S.ripple;\n\n  // The gust rises to its height at 0.9 s and dies away; the water is\n  // nearly still by 4.5 s.\n  const tau = 0.9, env = (ct / tau) * exp(1 - ct / tau);\n  let nw = 0;\n  if (env > 0.01) for (const w of S.gust) setWave(S, nw++, w, env * amp * (S.drop ? 0.3 : 1));\n  for (const w of S.res) setWave(S, nw++, w, amp);\n  sumWaves(S, nw);\n  if (S.drop && ct \u003c 6) addDrop(S, ct, amp);\n\n  // The floor at depth s of the shaped depth gets u + s (T(u) - u + slope\n  // push): s = 1 is in focus.\n  const s = 1 + 0.5 * S.focus;\n  // How much of the shaped relief shows through the waves: none while the\n  // gust stands above half its height, all of it once the water is still.\n  // The relief changes to the next word at 1 s, while none of it shows.\n  const calm = 1 - smooth(min(1, env / 0.5)), wi = ct \u003c 1 ? S.prev : S.word;\n  // Where each photon would land on still water, kept until the focus, the\n  // calm or the word changes.\n  const key = s + \",\" + calm + \",\" + wi, B = S.B, EW = W + 2;\n  if (key !== S.key) {\n    S.key = key;\n    const [TX, TY] = mapOf(wi), sc = s * calm;\n    for (let p = 0; p \u003c NP; p++) {\n      B[2 * p] = SU[p] + sc * (TX[p] - SU[p]) - 0.5;\n      B[2 * p + 1] = SV[p] + sc * (TY[p] - SV[p]) - 0.5;\n    }\n  }\n  splat(S, s);\n\n  // Tone map 1 - exp(-k E) through a table of 1024 steps of 1/16 photon:\n  // four photons an LED is even light, and the deep colour gives way to the\n  // pale one as the light piles up.\n  const deep = hsv(0.56 + S.hue, 0.85, 1), pale = hsv(0.47 + S.hue, 0.28, 1), LUT = S.LUT, E = S.E;\n  for (let m = 0; m \u003c 1024; m++) {\n    const b = 1 - exp(-0.13 * (m / 16)), w = b * b;\n    for (let ch = 0; ch \u003c 3; ch++) LUT[m * 3 + ch] = 255 * b * (deep[ch] + (pale[ch] - deep[ch]) * w);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0, p = (y + 1) * EW + 1; x \u003c W; x++, p++) {\n      const m = min(1023, (E[p] * 16) | 0) * 3;\n      display.setPixel(x, y, LUT[m], LUT[m + 1], LUT[m + 2]);\n    }\n}\n","langford-pairs":"// ===== Patternflow pattern =====\n// Title:   Langford Pairs\n// Family:  number\n// Idea:    A backtracking search stacks two blocks of each of n colours into a tower the height of the panel, placing the pairs from the largest down so that the two blocks of colour k have k blocks between them, with an arc beside the tower joining each pair, and every arrangement it finds slides aside onto a shelf of finished towers while the search goes on.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Langford's problem (C. Dudley Langford, Mathematical Gazette, 1958), solutions only for n ≡ 0 or 3 mod 4 (Roy O. Davies, 1959), Skolem sequences (Thoralf Skolem, 1957), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pairs=7..12, Rule=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 pairs 1, 2 and 3 are red, blue and yellow, the blocks Langford watched his son stack, and each larger pair is 0.58 of a turn on from the one before.\n// Knob 2: Speed. 40 steps a second at 2, where a step places a pair or takes one back; 4 at 0.2 and 60 at 3. After 2 s with nothing found the search doubles its pace every 1.5 s, up to 30,000 steps a second, so 9 gets through its 19,781 placements and fails about 15 s in; at each arrangement it finds it falls back to the knob's pace.\n// Knob 3: Pairs. n from 7 to 12, so the tower is 14 to 24 blocks of 128 / 2n rows. Counted once with its reversal, 7 has 26 arrangements, 8 has 150, 11 has 17,792 and 12 has 108,144; 9 and 10 have none, and their searches run out and fail. When a search has tried everything, n goes up by one, and 12 goes back to 7.\n// Knob 4: Rule. Below 0.5 Langford's rule, k blocks between the two of colour k. From 0.5 Skolem's, the two of colour k stand k places apart, so the two 1s touch; that works for n = 8 (252), 9 (1,328) and 12 (227,968), and fails for 7, 10 and 11.\n// Buttons: any knob's button gives up on this n and moves on to the next.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Layout. The search tower stands at the right, 10 LEDs wide, with the\n// arcs to its left and a progress line in the last column. Finished towers\n// are 5 LEDs wide, 7 apart, the newest at x 29 and the oldest falling off\n// the left edge.\nconst TX = 52, TW = 10, PBX = 63, SW = 5, SS = 7, S0 = 29, NMIN = 7, NMAX = 12;\nconst top = (n, i) => round((i * H) / (2 * n));\n\n// ---- The search. Pairs go in from n down to 1; pair k tries each place i\n// whose partner i + gap is free, from the top down. Langford's gap is k + 1 (k\n// blocks between), Skolem's is k. A reversed arrangement is the same one, so\n// pair n only tries the top half of its places; when it sits exactly in the\n// middle an arrangement and its reversal both turn up, and only the one that\n// reads smaller from the top is kept.\n// Enumerated this way: Langford 3:1, 4:1, 7:26, 8:150, 11:17792, 12:108144,\n// and none for 5, 6, 9, 10; Skolem 4:3, 5:5, 8:252, 9:1328, 12:227968.\nconst gap = (S, k) => k + 1 - S.rule;\nconst hiOf = (S, k) => {\n  const last = 2 * S.n - 1 - gap(S, k);\n  return k === S.n ? floor(last / 2) : last;\n};\n\nfunction fresh(S, n, rule) {\n  S.n = n;\n  S.rule = rule;\n  S.slot = new Int8Array(2 * n);\n  S.pos = new Int16Array(n + 2).fill(-1);\n  S.cur = new Int16Array(n + 2);\n  S.glow = new Float32Array(n + 2);\n  S.ghost = new Float32Array(n + 2);\n  S.gpos = new Int16Array(n + 2);\n  S.k = n;\n  S.found = 0;\n  S.stuck = 0;\n  S.acc = 0;\n  S.hold = 0;\n  S.end = -1;\n}\n\nfunction place(S, k, i) {\n  S.slot[i] = S.slot[i + gap(S, k)] = k;\n  S.pos[k] = i;\n  S.glow[k] = 1;\n}\nfunction unplace(S, k) {\n  const i = S.pos[k];\n  S.slot[i] = S.slot[i + gap(S, k)] = 0;\n  S.pos[k] = -1;\n  S.ghost[k] = 1;\n  S.gpos[k] = i;\n}\nfunction reversedFirst(S) {\n  const n = S.n, L = 2 * n, i = S.pos[n];\n  if (i !== L - 1 - gap(S, n) - i) return false;\n  for (let a = 0; a \u003c L; a++) if (S.slot[a] !== S.slot[L - 1 - a]) return S.slot[a] > S.slot[L - 1 - a];\n  return false;\n}\n\n// One step: place the next pair, or take one back. Returns 0 placed,\n// 1 taken back, 2 found, 3 found the reversal of one already kept, 4 done.\nfunction step(S) {\n  if (S.k === 0) {\n    unplace(S, 1);\n    S.k = 1;\n    return 1;\n  }\n  const k = S.k, g = gap(S, k), hi = hiOf(S, k), sl = S.slot;\n  for (let i = S.cur[k]; i \u003c= hi; i++) {\n    if (sl[i] || sl[i + g]) continue;\n    place(S, k, i);\n    S.cur[k] = i + 1;\n    if (k > 1) {\n      S.k = k - 1;\n      S.cur[k - 1] = 0;\n      return 0;\n    }\n    S.k = 0;\n    return reversedFirst(S) ? 3 : 2;\n  }\n  if (k === S.n) return 4;\n  unplace(S, k + 1);\n  S.k = k + 1;\n  return 1;\n}\n\n// How far through the tree the search is: pair n's place out of its range,\n// then pair n - 1's inside that, and so on four levels down.\nfunction progress(S) {\n  if (S.end >= 0) return 1;\n  let p = 0, w = 1;\n  for (let k = S.n; k > S.n - 4 && k >= 1; k--) {\n    const span = hiOf(S, k) + 1, at = S.pos[k] >= 0 ? S.pos[k] : min(span, S.cur[k]);\n    p += (w * at) / span;\n    w /= span;\n    if (S.pos[k] \u003c 0) break;\n  }\n  return cl(p, 0, 1);\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, speed: 2, kn: -1, krule: -1, shelf: [], flash: 0, rgb: new Float32Array(W * H * 3) };\n}\n\nfunction advance(S) {\n  fresh(S, S.n >= NMAX ? NMIN : S.n + 1, S.rule);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = cl(round(kv[2]), NMIN, NMAX), rule = kv[3] >= 0.5 ? 1 : 0;\n  if (n !== S.kn || rule !== S.krule) {\n    S.kn = n;\n    S.krule = rule;\n    fresh(S, n, rule);\n  }\n  // Time in the seconds of Speed 2.\n  const nom = (d * S.speed) / 2;\n  S.t += d;\n  const fade = exp(-d / 0.25), gfade = exp(-d / 0.12);\n  for (let k = 1; k \u003c= S.n; k++) (S.glow[k] *= fade), (S.ghost[k] *= gfade);\n  S.flash *= exp(-d / 0.3);\n  // The shelf eases toward its places; a tower that has left the panel goes.\n  S.shelf.forEach((tw, j) => (tw.x += (S0 - SS * j - tw.x) * (1 - exp(-d * 6))));\n  while (S.shelf.length && S.shelf[S.shelf.length - 1].x \u003c -SW - 1) S.shelf.pop();\n\n  if (input.btnPressed && input.btnPressed.some(Boolean)) return advance(S);\n  if (S.end >= 0) {\n    // The search has run out: 1.4 s to show it, then the next n.\n    S.end += nom;\n    if (S.end > 1.4) advance(S);\n    return;\n  }\n  if (S.hold > 0) {\n    S.hold -= nom;\n    return;\n  }\n  S.stuck += nom;\n  const rate = min(30000, 20 * S.speed * 2 ** (max(0, S.stuck - 2) / 1.5));\n  S.acc += d * rate;\n  let steps = floor(S.acc);\n  if (steps > 1000) (steps = 1000), (S.acc = 0);\n  else S.acc -= steps;\n  while (steps-- > 0) {\n    const r = step(S);\n    if (r === 2) {\n      S.found++;\n      S.shelf.unshift({ seq: Int8Array.from(S.slot), n: S.n, x: TX });\n      if (S.shelf.length > 8) S.shelf.length = 8;\n      S.hold = 0.35;\n      S.stuck = 0;\n      S.flash = 1;\n      S.acc = 0;\n      break;\n    }\n    if (r === 4) {\n      S.end = 0;\n      S.acc = 0;\n      break;\n    }\n  }\n}\n\n// A block from row y0 to y1 - 1 between columns x0 and x1 - 1, its last row\n// left dark as the seam to the next; the top row catches the light.\nfunction block(rgb, x0, x1, y0, y1, c, v) {\n  const last = y1 - 1 - (y1 - y0 > 3 ? 1 : 0);\n  for (let y = y0; y \u003c last; y++) {\n    const sh = v * (y === y0 ? 1 : y === last - 1 ? 0.58 : 0.8);\n    for (let x = max(0, x0); x \u003c min(W, x1); x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] += c[0] * sh;\n      rgb[o + 1] += c[1] * sh;\n      rgb[o + 2] += c[2] * sh;\n    }\n  }\n}\n\nfunction dot(rgb, x, y, c, a) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const px = x0 + i, py = y0 + j;\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const w = a * (i ? fx : 1 - fx) * (j ? fy : 1 - fy), o = (py * W + px) * 3;\n      rgb[o] += c[0] * w;\n      rgb[o + 1] += c[1] * w;\n      rgb[o + 2] += c[2] * w;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.slot) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  // Pair k's colour steps 0.58 of a turn, so 1, 2 and 3 open red, blue and\n  // yellow and neighbours never share a hue.\n  const pal = [];\n  for (let k = 0; k \u003c= NMAX; k++) pal.push(hsv(S.hue + 0.58 * (k - 1), 0.78, 1));\n\n  // The shelf. A tower leaving the search narrows from 10 LEDs to 5 as it goes.\n  for (const tw of S.shelf) {\n    const u = cl((tw.x - S0) / (TX - S0), 0, 1), x0 = round(tw.x), w = round(SW + (TW - SW) * u);\n    for (let i = 0; i \u003c 2 * tw.n; i++) block(rgb, x0, x0 + w, top(tw.n, i), top(tw.n, i + 1), pal[tw.seq[i]], 0.72 + 0.23 * u);\n  }\n\n  // The search tower: placed blocks, the empty places as faint frames, and a\n  // pair just taken back fading where it stood.\n  const n = S.n, L = 2 * n, fl = S.flash;\n  const failing = S.end >= 0 && S.found === 0, blink = failing && (S.end * 3) % 1 \u003c 0.5;\n  const frame = failing ? [blink ? 0.75 : 0.25, 0.12, 0.08] : S.end >= 0 ? [0.4, 0.45, 0.5] : [0.11, 0.13, 0.17];\n  for (let i = 0; i \u003c L; i++) {\n    const y0 = top(n, i), y1 = top(n, i + 1), k = S.slot[i];\n    if (k) {\n      const g = S.glow[k] * 0.45 + fl * 0.3, c = pal[k];\n      block(rgb, TX, TX + TW, y0, y1, [c[0] + (1 - c[0]) * g, c[1] + (1 - c[1]) * g, c[2] + (1 - c[2]) * g], 1);\n      continue;\n    }\n    for (let y = y0; y \u003c y1 - 1; y++)\n      for (let x = TX; x \u003c TX + TW; x++) {\n        if (y !== y0 && y !== y1 - 2 && x !== TX && x !== TX + TW - 1) continue;\n        const o = (y * W + x) * 3;\n        rgb[o] += frame[0], rgb[o + 1] += frame[1], rgb[o + 2] += frame[2];\n      }\n  }\n  for (let k = 1; k \u003c= n; k++) {\n    const a = S.ghost[k];\n    if (a \u003c 0.03 || S.pos[k] >= 0) continue;\n    for (const i of [S.gpos[k], S.gpos[k] + gap(S, k)]) if (!S.slot[i]) block(rgb, TX + 2, TX + TW - 2, top(n, i), top(n, i + 1), pal[k], 0.45 * a);\n  }\n\n  // Arcs: each placed pair joined by half an ellipse bulging left from the\n  // centres of its two blocks, wider for larger k.\n  for (let k = 1; k \u003c= n; k++) {\n    const i = S.pos[k];\n    if (i \u003c 0) continue;\n    const j = i + gap(S, k), ya = (top(n, i) + top(n, i + 1) - 1) / 2, yb = (top(n, j) + top(n, j + 1) - 1) / 2;\n    const yc = (ya + yb) / 2, ry = (yb - ya) / 2, rx = 2.5 + (11 * (k - 1)) / (n - 1);\n    const len = PI * sqrt((rx * rx + ry * ry) / 2), m = Math.ceil(len * 2.5), c = pal[k];\n    const a = 0.5 * (0.75 + S.glow[k] * 0.5 + fl * 0.4);\n    for (let s = 0; s \u003c= m; s++) {\n      const th = -PI / 2 + (PI * s) / m;\n      dot(rgb, TX - 1.5 - rx * cos(th), yc + ry * sin(th), c, a);\n    }\n  }\n\n  // The progress line: how much of the tree lies behind the search.\n  const py = progress(S) * H;\n  for (let y = 0; y \u003c H; y++) {\n    const v = y \u003c py ? (failing ? 0.5 : 0.32) : 0.06, o = (y * W + PBX) * 3;\n    rgb[o] += v * (failing ? 1 : 0.8);\n    rgb[o + 1] += v * (failing ? 0.25 : 0.85);\n    rgb[o + 2] += v * (failing ? 0.15 : 1);\n  }\n\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), (255 * min(1, rgb[p * 3])) | 0, (255 * min(1, rgb[p * 3 + 1])) | 0, (255 * min(1, rgb[p * 3 + 2])) | 0);\n}\n","letter-melt":"// ===== Patternflow pattern =====\n// Title:   Letter Melt\n// Family:  type\n// Idea:    A word of liquid stands in an invisible mould at the top of the panel, the mould lets go from the feet of the letters up so the strokes sag, drip and run down the full height into a pool on the floor, and then threads drawn up out of the pool fill the mould of the next word, MELT, 물, FLOW, 녹다, DRIP, from the top of each letter down until it sets.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 69, after Letter Sand (pattern round 64), particle fluid by double density relaxation (Simon Clavet, Philippe Beaudoin and Pierre Poulin, 2005)\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Heat=0..1\n//\n// Knob 1: Hue. Turns the liquid round the wheel. At 0 it is a teal body with a pale aqua rim, at 0.25 blue violet, at 0.5 rose, at 0.65 gold.\n// Knob 2: Speed. At 2 the fluid takes 60 steps a second and a word holds 1.8 s, melts in about 2.4 s and pours back in 2.9 s, so the five words come round in 36 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Word. 0 pours the five words in turn, MELT, 물, FLOW, 녹다 and DRIP. 1 to 5 hold one of them, and every pour goes back into that same mould.\n// Knob 4: Heat. Cold liquid is thick: at 0.06 the mould holds the word 1.8 s, the lower strokes sag for about a second before they drip, and the strokes hang in long threads on the way down. Hot liquid is thin and shivers in the mould: at 1 the mould lets go after 0.5 s and the letters fall apart in loose blobs that splash.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, round, PI, cos, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The fluid, in LEDs and simulation steps. One step is 1/60 s at Speed 2.\nconst SP = 1.4; // rest spacing of the particles\nconst HR = 3.0; // interaction radius\nconst GRAV = 0.025; // LEDs a step, a step\nconst RISE = 1.3; // how fast a poured thread climbs, LEDs a step\nconst POUR = 1.6; // seconds a pour draws particles for\nconst KS = 0.06; // stiffness against the rest density\nconst KN = 0.15; // near stiffness, which keeps particles apart and gives the surface its tension\nconst STROKE = 2.2; // stroke radius of the mould letters\nconst GX = Math.ceil(W / HR), GY = Math.ceil(H / HR);\n\n// Stroke centre lines in a unit box, y down. \"O\" is a stadium ring.\nconst LATIN = {\n  M: [[0, 1, 0, 0, 0.5, 0.55, 1, 0, 1, 1]],\n  E: [[1, 0, 0, 0, 0, 1, 1, 1], [0, 0.5, 0.8, 0.5]],\n  L: [[0, 0, 0, 1, 1, 1]],\n  T: [[0, 0, 1, 0], [0.5, 0, 0.5, 1]],\n  F: [[1, 0, 0, 0, 0, 1], [0, 0.47, 0.8, 0.47]],\n  O: \"ring\",\n  W: [[0, 0, 0.2, 1, 0.5, 0.45, 0.8, 1, 1, 0]],\n  D: [[0, 0, 0, 1, 0.45, 1, 1, 0.78, 1, 0.22, 0.45, 0, 0, 0]],\n  R: [[0, 1, 0, 0, 0.65, 0, 1, 0.14, 1, 0.34, 0.65, 0.48, 0, 0.48], [0.45, 0.48, 1, 1]],\n  I: [[0.5, 0, 0.5, 1], [0.1, 0, 0.9, 0], [0.1, 1, 0.9, 1]],\n  P: [[0, 1, 0, 0, 0.65, 0, 1, 0.15, 1, 0.37, 0.65, 0.52, 0, 0.52]],\n};\n// Hangul syllables drawn jamo by jamo in the same way.\nconst HANGUL = {\n  물: [\n    [0.18, 0, 0.82, 0, 0.82, 0.25, 0.18, 0.25, 0.18, 0],\n    [0, 0.42, 1, 0.42],\n    [0.5, 0.42, 0.5, 0.55],\n    [0.18, 0.66, 0.82, 0.66, 0.82, 0.83, 0.18, 0.83, 0.18, 1, 0.82, 1],\n  ],\n  녹: [[0.12, 0, 0.12, 0.25, 0.88, 0.25], [0.5, 0.34, 0.5, 0.5], [0, 0.5, 1, 0.5], [0.1, 0.67, 0.9, 0.67, 0.9, 1]],\n  다: [[0.5, 0.16, 0, 0.16, 0, 0.84, 0.5, 0.84], [0.8, 0, 0.8, 1], [0.8, 0.5, 1, 0.5]],\n};\nconst WORDS = [\"MELT\", \"물\", \"FLOW\", \"녹다\", \"DRIP\"];\n\n// Glyph boxes for a word: [char, x, y, w, h].\nfunction boxes(word) {\n  const n = [...word].length;\n  if (HANGUL[word[0]]) {\n    const w = n === 1 ? 56 : 29;\n    return [...word].map((c, i) => [c, n === 1 ? 4 : 2 + i * 31, 5, w, 44]);\n  }\n  return [...word].map((c, i) => [c, 1.5 + i * 16, 6, 13, 36]);\n}\n\n// The stroke segments of one glyph in its box, in LEDs.\nfunction segments(c, bx, by, bw, bh) {\n  const out = [], x0 = bx + STROKE, y0 = by + STROKE, sw = bw - 2 * STROKE, sh = bh - 2 * STROKE;\n  const g = LATIN[c] || HANGUL[c];\n  if (g === \"ring\") {\n    const r = sw / 2, cx = x0 + r, ya = y0 + r, yb = y0 + sh - r, pts = [];\n    for (let k = 0; k \u003c= 12; k++) pts.push(cx + r * cos(PI + (k * PI) / 12), ya + r * sin(PI + (k * PI) / 12));\n    for (let k = 0; k \u003c= 12; k++) pts.push(cx + r * cos((k * PI) / 12), yb + r * sin((k * PI) / 12));\n    pts.push(pts[0], pts[1]);\n    for (let i = 0; i + 3 \u003c pts.length; i += 2) out.push(pts[i], pts[i + 1], pts[i + 2], pts[i + 3]);\n    return out;\n  }\n  for (const pl of g)\n    for (let i = 0; i + 3 \u003c pl.length; i += 2) out.push(x0 + pl[i] * sw, y0 + pl[i + 1] * sh, x0 + pl[i + 2] * sw, y0 + pl[i + 3] * sh);\n  return out;\n}\n\nfunction segDist(px, py, s) {\n  let best = 1e9;\n  for (let i = 0; i \u003c s.length; i += 4) {\n    const ax = s[i], ay = s[i + 1], vx = s[i + 2] - ax, vy = s[i + 3] - ay;\n    const t = cl(((px - ax) * vx + (py - ay) * vy) / (vx * vx + vy * vy || 1), 0, 1);\n    const dx = px - ax - t * vx, dy = py - ay - t * vy;\n    best = min(best, dx * dx + dy * dy);\n  }\n  return sqrt(best);\n}\n\n// The mould of a word: its sites, a hexagonal lattice at the rest spacing\n// inside the strokes, read from the top row down, and the spouts under each\n// glyph that a pour draws its threads up through, one for every 16 LEDs of\n// width. Each spout keeps its sites top row first, so a pour fills each\n// letter from its top down.\nfunction mould(word) {\n  const xy = [], spouts = [], lists = [];\n  for (const [c, gx, gy, gw, gh] of boxes(word)) {\n    const m = max(1, round(gw / 16)), first = lists.length, segs = segments(c, gx, gy, gw, gh);\n    for (let k = 0; k \u003c m; k++) {\n      spouts.push(gx + (gw * (k + 0.5)) / m, gy + gh + 2);\n      lists.push([]);\n    }\n    for (let j = 0; ; j++) {\n      const y = 3 + j * SP * 0.866;\n      if (y > gy + gh) break;\n      if (y \u003c gy) continue;\n      for (let x = 0.5 + (j % 2) * SP * 0.5; x \u003c gx + gw; x += SP) {\n        if (x \u003c gx || segDist(x, y, segs) >= STROKE - 0.3) continue;\n        // The nearest spout of the glyph.\n        const k = first + min(m - 1, floor(((x - gx) / gw) * m));\n        lists[k].push(xy.length / 2);\n        xy.push(x, y);\n      }\n    }\n  }\n  const of = new Int32Array(xy.length / 2);\n  lists.forEach((l, k) => l.forEach((i) => (of[i] = k)));\n  return { xy: new Float64Array(xy), spouts: new Float64Array(spouts), lists: lists.map((l) => new Int32Array(l)), of, n: xy.length / 2 };\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nexport function setup(params) {\n  const MOULDS = WORDS.map(mould);\n  let most = 0;\n  for (const m of MOULDS) most = max(most, m.n);\n  const N = min(1500, most + 460), MP = N * 16;\n  // Rest density: what a particle in the middle of the lattice counts.\n  let rho0 = 0;\n  for (let j = -4; j \u003c= 4; j++)\n    for (let i = -4; i \u003c= 4; i++) {\n      const x = (i + (j % 2) * 0.5) * SP, y = j * SP * 0.866, r = sqrt(x * x + y * y);\n      if (r > 0 && r \u003c HR) rho0 += (1 - r / HR) ** 2;\n    }\n  params.s = {\n    N, MOULDS, rho0, word: -1, phase: 0, started: false,\n    // Doubles from the start, so the object keeps one shape.\n    pt: 0.5, acc: 0.5, hue: 0.5,\n    x: new Float64Array(N), y: new Float64Array(N), px: new Float64Array(N), py: new Float64Array(N),\n    vx: new Float64Array(N), vy: new Float64Array(N), st: new Uint8Array(N), site: new Int32Array(N),\n    rel: new Float64Array(N), kap: new Float64Array(N), tx: new Float64Array(N), ty: new Float64Array(N), rho: new Float64Array(N), rhn: new Float64Array(N),\n    pa: new Int32Array(MP), pb: new Int32Array(MP), pn: 0, qx: new Float64Array(MP), qy: new Float64Array(MP), qq: new Float64Array(MP),\n    cnt: new Int32Array(GX * GY + 1), fillc: new Int32Array(GX * GY), loose: new Int32Array(GX * GY), hd: new Uint8Array(N), idx: new Int32Array(N), cell: new Int32Array(N),\n    F: new Float32Array(W * H), V: new Float32Array(W * H), pal: new Float32Array(64 * 3), rim: new Float32Array(3),\n    nk: new Int32Array(8), arrived: 0, target: -1,\n  };\n  return params.s;\n}\n\n// Particle i takes site j of mould M in a given state, on a spring.\nfunction fix(S, i, M, j, state) {\n  S.st[i] = state;\n  S.site[i] = j;\n  S.kap[i] = 0.25;\n  S.tx[i] = M.xy[2 * j];\n  S.ty[i] = M.xy[2 * j + 1];\n}\n\n// Put word w in its mould and the rest of the particles in a pool on the\n// floor.\nfunction place(S, w) {\n  const M = S.MOULDS[w], per = floor((W - 1) / SP);\n  S.word = w;\n  for (let i = 0; i \u003c S.N; i++) {\n    if (i \u003c M.n) {\n      fix(S, i, M, i, 1);\n      S.x[i] = S.tx[i];\n      S.y[i] = S.ty[i];\n    } else {\n      const k = i - M.n, j = floor(k / per);\n      S.x[i] = 0.7 + (k % per) * SP + (j % 2) * SP * 0.5;\n      S.y[i] = H - 0.7 - j * SP * 0.866;\n      S.st[i] = 0;\n      S.kap[i] = 0;\n    }\n    S.vx[i] = S.vy[i] = 0;\n  }\n  S.phase = 0;\n  S.pt = 0;\n}\n\n// Counting sort of the particles into cells one interaction radius wide,\n// then every pair closer than the radius, each once, with its unit vector\n// and 1 - r/h, adding up both densities on the way. Returns the count.\nfunction neighbours(S) {\n  const { N, x, y, cnt, idx, cell, pa, pb, qx, qy, qq, rho, rhn, st, hd } = S;\n  cnt.fill(0);\n  // Particles the mould holds still skip each other: their springs keep\n  // them apart. While the mould lets go every pair counts.\n  for (let i = 0; i \u003c N; i++) hd[i] = (st[i] === 1 && S.phase !== 1) || st[i] === 3 ? 1 : 0;\n  rho.fill(0);\n  rhn.fill(0);\n  const loose = S.loose;\n  loose.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const c = cl(floor(y[i] / HR), 0, GY - 1) * GX + cl(floor(x[i] / HR), 0, GX - 1);\n    cell[i] = c;\n    cnt[c + 1]++;\n    if (!hd[i]) loose[c]++;\n  }\n  for (let c = 0; c \u003c GX * GY; c++) cnt[c + 1] += cnt[c];\n  const fill = S.fillc;\n  fill.set(cnt.subarray(0, GX * GY));\n  for (let i = 0; i \u003c N; i++) idx[fill[cell[i]]++] = i;\n  let n = 0;\n  const h2 = HR * HR, MP = pa.length;\n  for (let i = 0; i \u003c N; i++) {\n    const c = cell[i], cx = c % GX, cy = (c - cx) / GX, xi = x[i], yi = y[i], hi = hd[i];\n    let ri = 0, ni = 0;\n    for (let oy = 0; oy \u003c= 1; oy++)\n      for (let ox = -1; ox \u003c= 1; ox++) {\n        if (oy === 0 && ox \u003c 0) continue;\n        const nx = cx + ox, ny = cy + oy;\n        if (nx \u003c 0 || nx >= GX || ny >= GY) continue;\n        const cc = ny * GX + nx, own = cc === c;\n        if (hi && !loose[cc]) continue;\n        for (let k = cnt[cc], e = cnt[cc + 1]; k \u003c e; k++) {\n          const j = idx[k];\n          if (own && j \u003c= i) continue;\n          const dx = x[j] - xi, dy = y[j] - yi, r2 = dx * dx + dy * dy;\n          if (r2 >= h2 || n >= MP || (hi && hd[j])) continue;\n          const r = sqrt(r2) || 1e-4, q = 1 - r / HR, q2 = q * q, q3 = q2 * q;\n          pa[n] = i;\n          pb[n] = j;\n          qx[n] = dx / r;\n          qy[n] = dy / r;\n          qq[n++] = q;\n          ri += q2;\n          ni += q3;\n          rho[j] += q2;\n          rhn[j] += q3;\n        }\n      }\n    rho[i] += ri;\n    rhn[i] += ni;\n  }\n  return n;\n}\n\n// One step of the double density relaxation scheme: gravity, the pour's\n// steering, viscous impulses, a free step, the two densities and their\n// pressure displacements, the mould's springs, the walls, and velocity from\n// the change in position. Each part is a loop of its own with as few rare\n// branches as it can have.\nfunction step(S, visc, jit) {\n  const { N, st, vy } = S;\n  for (let i = 0; i \u003c N; i++) vy[i] += st[i] === 0 ? GRAV : 0;\n  if (S.phase === 2) steer(S);\n  viscosity(S, visc);\n  advance(S);\n  S.pn = neighbours(S);\n  relax(S);\n  if (S.phase === 1) melt(S);\n  springs(S, jit);\n  if (S.phase === 2) arrive(S);\n}\n\n// Drawn up: a thread rises at RISE LEDs a step to the spout under the\n// glyph, and from there each particle heads for its own site.\nfunction steer(S) {\n  const { N, st, x, y, vx, vy, site } = S, M = S.MOULDS[S.target];\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 2) continue;\n    const k = M.of[site[i]], spx = M.spouts[2 * k], spy = M.spouts[2 * k + 1];\n    let dvx, dvy;\n    if (y[i] > spy) {\n      dvx = cl((spx - x[i]) * 0.15, -0.8, 0.8);\n      dvy = -RISE;\n    } else {\n      const dx = M.xy[2 * site[i]] - x[i], dy = M.xy[2 * site[i] + 1] - y[i], d = sqrt(dx * dx + dy * dy) + 1e-6;\n      const sc = min(RISE, d * 0.25) / d;\n      dvx = dx * sc;\n      dvy = dy * sc;\n    }\n    vx[i] += (dvx - vx[i]) * 0.35;\n    vy[i] += (dvy - vy[i]) * 0.35;\n  }\n}\n\n// Viscous impulses between approaching neighbours, over last step's pairs.\nfunction viscosity(S, visc) {\n  const { pa, pb, qx, qy, qq, vx, vy } = S, n = S.pn;\n  for (let p = 0; p \u003c n; p++) {\n    const i = pa[p], j = pb[p], ux = qx[p], uy = qy[p];\n    const u = (vx[i] - vx[j]) * ux + (vy[i] - vy[j]) * uy;\n    if (u \u003c= 0) continue;\n    const I = qq[p] * (visc * u + 0.25 * u * u) * 0.5, ix = I * ux, iy = I * uy;\n    vx[i] -= ix;\n    vy[i] -= iy;\n    vx[j] += ix;\n    vy[j] += iy;\n  }\n}\n\nfunction advance(S) {\n  const { N, x, y, px, py, vx, vy } = S;\n  for (let i = 0; i \u003c N; i++) {\n    const f = min(1, 2.5 / sqrt(vx[i] * vx[i] + vy[i] * vy[i] + 1e-12));\n    vx[i] *= f;\n    vy[i] *= f;\n    px[i] = x[i];\n    py[i] = y[i];\n    x[i] += vx[i];\n    y[i] += vy[i];\n  }\n}\n\n// Double density relaxation: a pressure from each density, and every pair\n// pushed apart (or pulled together, near the surface) along its line.\nfunction relax(S) {\n  const { N, x, y, pa, pb, qx, qy, qq, rho, rhn, hd } = S, n = S.pn, rho0 = S.rho0;\n  for (let i = 0; i \u003c N; i++) {\n    const free = 1 - hd[i];\n    rho[i] = free * KS * (rho[i] - rho0);\n    rhn[i] = free * KN * rhn[i];\n  }\n  for (let p = 0; p \u003c n; p++) {\n    const i = pa[p], j = pb[p], q = qq[p];\n    const d = ((rho[i] + rho[j]) * q + (rhn[i] + rhn[j]) * q * q) * 0.5;\n    const dx = d * qx[p], dy = d * qy[p];\n    x[i] -= dx;\n    y[i] -= dy;\n    x[j] += dx;\n    y[j] += dy;\n  }\n}\n\n// The mould lets go: each held particle's spring weakens to nothing by its\n// release time, so the lower strokes sag before they drip.\nfunction melt(S) {\n  const { N, st, kap, rel } = S, t = S.pt;\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 1) continue;\n    const u = cl((rel[i] - t) / 0.9, 0, 1);\n    kap[i] = 0.25 * u * u;\n    if (u \u003c= 0) st[i] = 0;\n  }\n}\n\n// The springs, a shiver as hot as the liquid, the walls, and velocity.\nfunction springs(S, jit) {\n  const { N, x, y, px, py, vx, vy, kap, tx, ty } = S, j4 = jit * 4;\n  for (let i = 0; i \u003c N; i++) {\n    const k = kap[i];\n    const xi = x[i] + (tx[i] - x[i]) * k + (Math.random() - 0.5) * j4 * k;\n    const yi = y[i] + (ty[i] - y[i]) * k + (Math.random() - 0.5) * j4 * k;\n    x[i] = min(W - 0.5, max(0.5, xi));\n    y[i] = min(H - 0.5, max(0.5, yi));\n    vx[i] = x[i] - px[i];\n    vy[i] = y[i] - py[i];\n  }\n}\n\n// A drawn particle that reaches its site is held by the new mould.\nfunction arrive(S) {\n  const { N, st, x, y, site } = S, M = S.MOULDS[S.target];\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 2) continue;\n    const dx = M.xy[2 * site[i]] - x[i], dy = M.xy[2 * site[i] + 1] - y[i];\n    if (dx * dx + dy * dy \u003c 0.8) {\n      fix(S, i, M, site[i], 3);\n      S.arrived++;\n    }\n  }\n}\n\n// The free particle nearest the top of the pool under a spout.\nfunction pick(S, spx) {\n  const { N, st, x, y } = S;\n  let best = -1, bs = 1e9;\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 0) continue;\n    const sc = abs(x[i] - spx) * 2 + y[i];\n    if (sc \u003c bs) {\n      bs = sc;\n      best = i;\n    }\n  }\n  return best;\n}\n\n// The cycle, one step at a time: the mould holds, lets go, and a pour fills\n// the next mould.\nfunction tick(S, sel, heat) {\n  const { N, st, y } = S;\n  S.pt += 1 / 60;\n  if (S.phase === 0 && S.pt > 1.9 - 1.4 * heat) {\n    // The mould lets go from the feet of the letters up.\n    S.phase = 1;\n    S.pt = 0;\n    const spread = 1.1 - 0.6 * heat;\n    for (let i = 0; i \u003c N; i++) if (st[i] === 1) S.rel[i] = 0.1 + spread * cl((52 - y[i]) / 47, 0, 1) + Math.random() * 0.3;\n  } else if (S.phase === 1 && S.pt > 1.6) {\n    let held = 0, high = 0;\n    for (let i = 0; i \u003c N; i++) {\n      if (st[i] === 1) held++;\n      else if (y[i] \u003c 80) high++;\n    }\n    if (!held && (high \u003c N * 0.03 || S.pt > 5)) {\n      // Pour: each spout of the next word draws its sites, top row first,\n      // from the particles near the top of the pool under it.\n      S.phase = 2;\n      S.pt = 0;\n      S.target = sel ? sel - 1 : (S.word + 1) % WORDS.length;\n      S.nk.fill(0);\n      S.arrived = 0;\n    }\n  } else if (S.phase === 2) {\n    const M = S.MOULDS[S.target], f = min(1, S.pt / POUR);\n    let done = true;\n    for (let k = 0; k \u003c M.lists.length; k++) {\n      const l = M.lists[k];\n      while (S.nk[k] \u003c f * l.length) {\n        const i = pick(S, M.spouts[2 * k]);\n        if (i \u003c 0) break;\n        st[i] = 2;\n        S.kap[i] = 0;\n        S.site[i] = l[S.nk[k]++];\n      }\n      if (S.nk[k] \u003c l.length) done = false;\n    }\n    if (done && (S.arrived >= M.n || S.pt > POUR + 4)) {\n      // Set: the new word stands in its mould.\n      for (let i = 0; i \u003c N; i++) if (st[i] >= 2) fix(S, i, M, S.site[i], 1);\n      S.word = S.target;\n      S.target = -1;\n      S.phase = 0;\n      S.pt = 0;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06];\n  const rate = cl(kv[1], 0.2, 3) / 2, sel = cl(round(kv[2]), 0, 5), heat = cl(kv[3], 0, 1);\n  S.hue = kv[0] || 0;\n  if (!S.started) {\n    S.started = true;\n    S.acc = 0;\n    place(S, sel ? sel - 1 : 0);\n    S.pt = 0.4;\n  }\n  const visc = 0.5 * (1 - heat) ** 2 + 0.08, jit = 0.02 + 0.12 * heat;\n  S.acc += cl(dt || 0, 0, 0.1) * rate * 60;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    tick(S, sel, heat);\n    step(S, visc, jit);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { F, V, x, y, vx, vy, N, pal, rim } = S;\n  F.fill(0);\n  V.fill(0);\n  // Splat every particle into a density field and a speed field.\n  const R = 2.1, R2 = R * R;\n  for (let i = 0; i \u003c N; i++) {\n    const cx = x[i], cy = y[i], sp = sqrt(vx[i] * vx[i] + vy[i] * vy[i]);\n    const x0 = max(0, floor(cx - R + 0.5)), x1 = min(W - 1, floor(cx + R - 0.5));\n    const y0 = max(0, floor(cy - R + 0.5)), y1 = min(H - 1, floor(cy + R - 0.5));\n    for (let Y = y0; Y \u003c= y1; Y++) {\n      const dy = Y + 0.5 - cy;\n      for (let X = x0; X \u003c= x1; X++) {\n        const dx = X + 0.5 - cx, d2 = dx * dx + dy * dy;\n        if (d2 >= R2) continue;\n        const w = (1 - d2 / R2) ** 2, o = Y * W + X;\n        F[o] += w;\n        V[o] += w * sp;\n      }\n    }\n  }\n  // The body runs from a deep shade inside to the lit colour near the\n  // surface; the rim is pale.\n  const h0 = 0.47 + S.hue;\n  for (let k = 0; k \u003c 64; k++) {\n    const u = k / 63;\n    hsv(h0 + 0.07 * u, 0.82 + 0.1 * u, 0.78 - 0.4 * u, pal, k * 3);\n  }\n  hsv(h0 - 0.03, 0.35, 1, rim, 0);\n  const LX = -0.45, LY = -0.89;\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = Y * W + X, f = F[o];\n      if (f \u003c 0.35) continue;\n      const a = cl((f - 0.35) / 0.55, 0, 1);\n      const gx = (X \u003c W - 1 ? F[o + 1] : f) - (X > 0 ? F[o - 1] : f);\n      const gy = (Y \u003c H - 1 ? F[o + W] : f) - (Y > 0 ? F[o - W] : f);\n      const gl = sqrt(gx * gx + gy * gy) + 1e-6;\n      // Outward normal and its light.\n      const lit = (-gx * LX - gy * LY) / gl, edge = cl(1 - (f - 0.9) / 1.3, 0, 1);\n      const spec = edge * cl(lit, 0, 1) ** 3 * cl(gl, 0, 1);\n      const deep = cl((f - 0.9) / 2.2, 0, 1), k = floor(deep * 63) * 3;\n      const foam = cl((V[o] / f - 0.6) * 0.6, 0, 0.5);\n      const sh = 0.75 + 0.25 * cl(lit, -1, 1) * edge;\n      // The lit side of the surface and fast liquid take the pale rim colour.\n      const m = max(spec, foam);\n      const r = (pal[k] * sh * (1 - m) + rim[0] * m) * a;\n      const g = (pal[k + 1] * sh * (1 - m) + rim[1] * m) * a;\n      const b = (pal[k + 2] * sh * (1 - m) + rim[2] * m) * a;\n      display.setPixel(X, Y, min(255, r) | 0, min(255, g) | 0, min(255, b) | 0);\n    }\n}\n","nine-fold-seal":"// ===== Patternflow pattern =====\n// Title:   Nine-fold Seal\n// Family:  type\n// Idea:    A tall vermilion seal impression of eight Hangul syllables, read down the right column and then the left, folds every horizontal stroke back and forth into serpentines of one-LED lines until each syllable's box is full, as the nine-fold seal script of official seals did, and every few seconds it unfolds to plain letters and refolds into the next text.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: jiudie zhuan (九疊篆), the nine-fold seal script of official seals from the Song dynasty on and of Joseon official seals, applied to Hangul; texts: the heading of the Hangul Hunminjeongeum in Worin seokbo (1459), its gloss \"the right sounds that teach\", and two old wishes for long life; pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Ink=0..1, Speed=0.2..3, Plain=0..1, Press=0..1\n//\n// Knob 1: Ink. Turns the ink round the colour wheel at a fixed brightness. At 0 it is seal vermilion, at 0.5 a cyan blue, and the paper stays a dim warm grey.\n// Knob 2: Speed. At 2 a text holds folded for 3 s (the first for 2.4 s) and the change to the next, unfold, swap and refold, takes 4 s more; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Plain. How far the strokes may fold: 0 folds them until every box is full, 0.5 stops every fold seven or eight lines out from its stroke, 1 shows the plain letters.\n// Knob 4: Press. How unevenly the seal is pressed. The pressure rocks round the seal once in 6 s, and the side it leaves prints with bare patches: none at 0, a few LEDs in a hundred at the opening 0.06, while at 1 one LED of ink in seven fails everywhere and the far corner prints almost bare.\n// Buttons: any button starts the change to the next text at once.\n\nconst W = 64, H = 128;\nconst { floor, round, ceil, min, max, abs, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The seal. A border two LEDs thick runs round the panel's edge, a\n// divider two thick splits it into two columns, and every box is 27 by 29\n// LEDs. Strokes lie on a lattice of nodes two LEDs apart, 14 across and 15\n// down a box, so any two strokes that do not join keep one LED of paper\n// between them. That one-LED rhythm of ink and paper is the whole look of\n// the nine-fold script.\nconst NI = 14, NJ = 15, N = NI * NJ;\n// The right column is read first, top to bottom, then the left.\nconst COLX = [34, 3], ROWY = [3, 34, 65, 96];\n\nconst TEXTS = [\"세종어제훈민정음\", \"가르치는바른소리\", \"만수무강하옵소서\", \"천년만년살고지고\"];\n\n// Jamo as strokes [u0, v0, u1, v1] in their region, 0 to 1, every stroke\n// level or upright, as seal script draws them. A fifth number marks a\n// ring: ㅇ is a ring with its corners cut, so it never reads as ㅁ.\n// Initials by their Unicode index; finals are looked up through FIN.\nconst CONS = {\n  0: [[0, 0, 1, 0], [1, 0, 1, 1]], // ㄱ\n  2: [[0, 0, 0, 1], [0, 1, 1, 1]], // ㄴ\n  3: [[0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 1, 1]], // ㄷ\n  5: [[0, 0, 1, 0], [1, 0, 1, 0.5], [0, 0.5, 1, 0.5], [0, 0.5, 0, 1], [0, 1, 1, 1]], // ㄹ\n  6: [[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1]], // ㅁ\n  7: [[0, 0, 0, 1], [1, 0, 1, 1], [0, 0.5, 1, 0.5], [0, 1, 1, 1]], // ㅂ\n  // ㅅ squared off the way seal script squares 人: a stem and two legs\n  // that step outward twice.\n  9: [[0.5, 0, 0.5, 0.3], [0.25, 0.3, 0.75, 0.3], [0.25, 0.3, 0.25, 0.65], [0.75, 0.3, 0.75, 0.65], [0, 0.65, 0.25, 0.65], [0.75, 0.65, 1, 0.65], [0, 0.65, 0, 1], [1, 0.65, 1, 1]], // ㅅ\n  11: [[0.1, 0, 0.9, 1, 1]], // ㅇ\n  12: [[0, 0, 1, 0], [0.5, 0, 0.5, 0.3], [0.25, 0.3, 0.75, 0.3], [0.25, 0.3, 0.25, 0.65], [0.75, 0.3, 0.75, 0.65], [0, 0.65, 0.25, 0.65], [0.75, 0.65, 1, 0.65], [0, 0.65, 0, 1], [1, 0.65, 1, 1]], // ㅈ\n  14: [[0.3, 0, 0.7, 0], [0, 0.22, 1, 0.22], [0.5, 0.22, 0.5, 0.45], [0.25, 0.45, 0.75, 0.45], [0.25, 0.45, 0.25, 0.72], [0.75, 0.45, 0.75, 0.72], [0, 0.72, 0.25, 0.72], [0.75, 0.72, 1, 0.72], [0, 0.72, 0, 1], [1, 0.72, 1, 1]], // ㅊ\n  18: [[0.3, 0, 0.7, 0], [0, 0.25, 1, 0.25], [0.15, 0.5, 0.85, 1, 1]], // ㅎ\n};\nconst FIN = { 1: 0, 4: 2, 7: 3, 8: 5, 16: 6, 17: 7, 19: 9, 21: 11, 22: 12, 23: 14, 27: 18 };\nconst VOW = {\n  0: [[0, 0, 0, 1], [0, 0.5, 0.75, 0.5]], // ㅏ\n  4: [[0.25, 0.5, 1, 0.5], [1, 0, 1, 1]], // ㅓ\n  5: [[0, 0.5, 0.4, 0.5], [0.4, 0, 0.4, 1], [1, 0, 1, 1]], // ㅔ\n  6: [[0.25, 0.33, 1, 0.33], [0.25, 0.67, 1, 0.67], [1, 0, 1, 1]], // ㅕ\n  8: [[0.5, 0, 0.5, 1], [0, 1, 1, 1]], // ㅗ\n  13: [[0, 0, 1, 0], [0.5, 0, 0.5, 1]], // ㅜ\n  18: [[0, 0.5, 1, 0.5]], // ㅡ\n  20: [[0.5, 0, 0.5, 1]], // ㅣ\n};\n\n// Regions [i0, j0, i1, j1] in nodes for the initial, the vowel and the final.\nfunction regions(V, T) {\n  if (V === 0 || V === 4 || V === 5 || V === 6 || V === 20) {\n    const wide = V === 5, ic = wide ? 6 : 7, iv = wide ? 8 : 9;\n    return T ? [[0, 0, ic, 7], [iv, 0, 13, 8], [1, 10, 12, 14]] : [[0, 1, ic, 13], [iv, 0, 13, 14], null];\n  }\n  return T ? [[1, 0, 12, 4], [0, 6, 13, 8], [1, 10, 12, 14]] : [[1, 0, 12, 7], [0, 9, 13, 13], null];\n}\n\n// One syllable: its plain strokes in LEDs, the corner LEDs of its rings, and\n// the fold runs. Folding gives every free node of the box to the nearest\n// level stroke straight above or below it, and the nodes a stroke gets lie\n// in rows 1, 2, 3 ... away from it. Each run of such nodes hangs from the row\n// before at one end, the right end and the left end taking turns, so the\n// stroke becomes one ribbon folded back and forth. Nodes no level stroke can\n// reach, beside an upright with nothing level over it, go the same way to\n// the nearest upright stroke left or right of them.\nfunction build(ch) {\n  const c = ch.charCodeAt(0) - 0xac00;\n  const L = floor(c / 588), V = floor(c / 28) % 21, T = c % 28;\n  const reg = regions(V, T);\n  const strokes = [], corners = [];\n  const busy = new Uint8Array(N), hOwn = new Int16Array(N).fill(-1), vOwn = new Int16Array(N).fill(-1);\n  const add = (shape, r) => {\n    if (!shape || !r) return;\n    const [a, b, c2, d] = r;\n    const mi = (u) => a + round(u * (c2 - a)), mj = (v) => b + round(v * (d - b));\n    for (const s of shape) {\n      const i0 = mi(s[0]), j0 = mj(s[1]), i1 = mi(s[2]), j1 = mj(s[3]);\n      if (s[4]) {\n        strokes.push({ o: 1, i0: i0 + 1, j0, i1: i1 - 1, j1: j0 });\n        strokes.push({ o: 0, i0, j0: j0 + 1, i1: i0, j1: j1 - 1 });\n        strokes.push({ o: 0, i0: i1, j0: j0 + 1, i1, j1: j1 - 1 });\n        strokes.push({ o: 1, i0: i0 + 1, j0: j1, i1: i1 - 1, j1 });\n        for (const [ci, cj, dx, dy] of [[i0, j0, 1, 1], [i1, j0, -1, 1], [i0, j1, 1, -1], [i1, j1, -1, -1]]) {\n          busy[ci + cj * NI] = 2;\n          corners.push(2 * ci + dx, 2 * cj + dy);\n        }\n      } else strokes.push({ o: j0 === j1 ? 1 : 0, i0: min(i0, i1), j0: min(j0, j1), i1: max(i0, i1), j1: max(j0, j1) });\n    }\n  };\n  add(CONS[L], reg[0]);\n  add(VOW[V], reg[1]);\n  if (T) add(CONS[FIN[T]], reg[2]);\n  strokes.forEach((s, k) => {\n    for (let j = s.j0; j \u003c= s.j1; j++)\n      for (let i = s.i0; i \u003c= s.i1; i++) {\n        busy[i + j * NI] = 1;\n        if (s.o) hOwn[i + j * NI] = k;\n        else vOwn[i + j * NI] = k;\n      }\n  });\n\n  // Claims: stroke, side (+1 below or right of it, -1 above or left) and\n  // distance, first for the level strokes, then for the upright ones.\n  const own = new Int16Array(N).fill(-1), side = new Int8Array(N), dist = new Int8Array(N), kind = new Uint8Array(N);\n  for (let n = 0; n \u003c N; n++) {\n    if (busy[n]) continue;\n    const i = n % NI, j = floor(n / NI);\n    let bd = 99;\n    for (let jj = j - 1; jj >= 0; jj--) {\n      const m = i + jj * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && hOwn[m] >= 0) (own[n] = hOwn[m]), (side[n] = 1), (bd = dist[n] = j - jj);\n      break;\n    }\n    for (let jj = j + 1; jj \u003c NJ; jj++) {\n      const m = i + jj * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && hOwn[m] >= 0 && jj - j \u003c bd) (own[n] = hOwn[m]), (side[n] = -1), (dist[n] = jj - j);\n      break;\n    }\n    if (own[n] >= 0) kind[n] = 1;\n  }\n  for (let n = 0; n \u003c N; n++) if (kind[n]) busy[n] = 3;\n  for (let n = 0; n \u003c N; n++) {\n    if (busy[n]) continue;\n    const i = n % NI, j = floor(n / NI);\n    let bd = 99;\n    for (let ii = i - 1; ii >= 0; ii--) {\n      const m = ii + j * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && vOwn[m] >= 0) (own[n] = vOwn[m]), (side[n] = 1), (bd = dist[n] = i - ii);\n      break;\n    }\n    for (let ii = i + 1; ii \u003c NI; ii++) {\n      const m = ii + j * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && vOwn[m] >= 0 && ii - i \u003c bd) (own[n] = vOwn[m]), (side[n] = -1), (dist[n] = ii - i);\n      break;\n    }\n    if (own[n] >= 0) kind[n] = 2;\n  }\n\n  // Runs: [level, connector x, y, start x, y, end x, y], all in LEDs.\n  const runs = [];\n  let deepest = 0;\n  for (let n = 0; n \u003c N; n++) {\n    if (!kind[n]) continue;\n    const i = n % NI, j = floor(n / NI), lv = dist[n], sd = side[n], k = own[n], hz = kind[n] === 1;\n    // Only the first node of a run starts it.\n    const pi = hz ? i - 1 : i, pj = hz ? j : j - 1;\n    if (pi >= 0 && pj >= 0) {\n      const m = pi + pj * NI;\n      if (kind[m] === kind[n] && own[m] === k && side[m] === sd && dist[m] === lv) continue;\n    }\n    let e = hz ? i : j;\n    for (;;) {\n      const m = hz ? e + 1 + j * NI : i + (e + 1) * NI;\n      if ((hz ? e + 1 >= NI : e + 1 >= NJ) || kind[m] !== kind[n] || own[m] !== k || side[m] !== sd || dist[m] !== lv) break;\n      e++;\n    }\n    const lo = hz ? i : j;\n    // The turn falls at the far end and the near end in turn, row by row.\n    const atHi = (lv + (sd > 0 ? 1 : 0)) % 2 === 0;\n    const cA = atHi ? e : lo, cB = atHi ? lo : e;\n    if (hz) runs.push(lv, 2 * cA, 2 * j - sd, 2 * cA, 2 * j, 2 * cB, 2 * j);\n    else runs.push(lv, 2 * i - sd, 2 * cA, 2 * i, 2 * cA, 2 * i, 2 * cB);\n    deepest = max(deepest, lv);\n  }\n  const plain = [];\n  for (const s of strokes) plain.push(2 * s.i0, 2 * s.j0, 2 * s.i1, 2 * s.j1);\n  return { plain, corners, runs: Int16Array.from(runs), deepest };\n}\n\n// Seconds at Speed 2: the hold, the fold rate in rows a second, the lag of\n// each syllable behind the one before it, in rows, and the swap.\nconst HOLD = 3, RATE = 14, STAG = 0.8, FOLD = (NJ + 7 * STAG) / RATE, SWAP = 1;\n// Ink and paper levels, and how far the two dimmer channels wander per LED\n// (times -128..127). The brightest channel wanders by 3 at most, so two\n// neighbours of one kind never differ by more than 6.\nconst INK_V = 214, PAPER = [58, 40, 32], MOTTLE = 0.45, GRAIN = 0.24;\n\nfunction impression(S) {\n  // A new impression: the paper grain and the ink's mottle per LED, and the\n  // patches where ink fails to take, coarse blots with a fine speckle in them.\n  for (let p = 0; p \u003c W * H * 3; p++) S.grain[p] = floor(Math.random() * 256);\n  const GW = 24, GH = 46, g = new Float32Array(GW * GH);\n  for (let q = 0; q \u003c g.length; q++) g[q] = Math.random();\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const gx = x / 3, gy = y / 3, ix = floor(gx), iy = floor(gy), fx = gx - ix, fy = gy - iy;\n      const a = g[ix + iy * GW], b = g[ix + 1 + iy * GW], c = g[ix + (iy + 1) * GW], d = g[ix + 1 + (iy + 1) * GW];\n      const v = (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + d * fx) * fy;\n      S.blot[y * W + x] = 0.6 * v + 0.4 * Math.random();\n    }\n  // Spread the blot values evenly over 0..1 by rank, so Press means the\n  // share of ink that fails.\n  const order = Array.from(S.blot, (v, p) => p).sort((a, b) => S.blot[a] - S.blot[b]);\n  for (let r = 0; r \u003c order.length; r++) S.rank[order[r]] = r / order.length;\n}\n\nexport function setup(params) {\n  const S = (params.s = { ink: new Uint8Array(W * H), grain: new Uint8Array(W * H * 3), blot: new Float32Array(W * H), rank: new Float32Array(W * H) });\n  S.glyphs = TEXTS.map((t) => Array.from(t, build));\n  S.text = 0;\n  S.ph = 0;\n  // The first text holds 2.4 s, so the first change comes soon.\n  S.pt = HOLD - 2.4;\n  S.tau = 0;\n  S.hue = 0;\n  S.plain = 0;\n  S.press = 0.06;\n  S.F = new Float32Array(8);\n  S.q = 1;\n  impression(S);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3) / 2;\n  S.hue = k[0];\n  S.plain = cl(k[2], 0, 1);\n  S.press = cl(k[3], 0, 1);\n  S.tau += dt * sp;\n  S.pt += dt * sp;\n  if (S.ph === 0 && input.btnPressed && input.btnPressed.some(Boolean)) S.pt = HOLD;\n  if (S.ph === 0 && S.pt >= HOLD) (S.ph = 1), (S.pt = 0);\n  if (S.ph === 1 && S.pt >= FOLD) (S.ph = 2), (S.pt = 0);\n  if (S.ph === 2 && S.pt >= SWAP / 2 && !S.swapped) {\n    S.text = (S.text + 1) % TEXTS.length;\n    S.swapped = 1;\n    impression(S);\n  }\n  if (S.ph === 2 && S.pt >= SWAP) (S.ph = 3), (S.pt = 0), (S.swapped = 0);\n  if (S.ph === 3 && S.pt >= FOLD) (S.ph = 0), (S.pt = 0);\n  const u = S.pt * RATE, cap = (1 - S.plain) * NJ;\n  for (let i = 0; i \u003c 8; i++) {\n    let f = NJ;\n    if (S.ph === 1) f = NJ - max(0, u - i * STAG);\n    else if (S.ph === 2) f = 0;\n    else if (S.ph === 3) f = max(0, u - i * STAG);\n    S.F[i] = min(cl(f, 0, NJ), cap);\n  }\n  S.q = S.ph === 2 ? abs(1 - (2 * S.pt) / SWAP) : 1;\n}\n\nfunction line(ink, x0, y0, x1, y1, count) {\n  const dx = Math.sign(x1 - x0), dy = Math.sign(y1 - y0);\n  for (let s = 0; s \u003c count; s++) {\n    const x = x0 + dx * s, y = y0 + dy * s;\n    ink[y * W + x] = 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.glyphs) return;\n  const ink = S.ink;\n  ink.fill(0);\n  for (let x = 0; x \u003c W; x++) ink[x] = ink[W + x] = ink[(H - 2) * W + x] = ink[(H - 1) * W + x] = 1;\n  for (let y = 0; y \u003c H; y++) ink[y * W] = ink[y * W + 1] = ink[y * W + W - 2] = ink[y * W + W - 1] = 1;\n  for (let y = 2; y \u003c H - 2; y++) ink[y * W + 31] = ink[y * W + 32] = 1;\n\n  const text = S.glyphs[S.text], q = S.q;\n  for (let k = 0; k \u003c 8; k++) {\n    const g = text[k], ox = COLX[k >> 2], oy = ROWY[k & 3], F = S.F[k];\n    const pl = g.plain;\n    for (let s = 0; s \u003c pl.length; s += 4) {\n      const len = abs(pl[s + 2] - pl[s]) + abs(pl[s + 3] - pl[s + 1]) + 1;\n      line(ink, ox + pl[s], oy + pl[s + 1], ox + pl[s + 2], oy + pl[s + 3], round(q * len));\n    }\n    if (q > 0.6) for (let s = 0; s \u003c g.corners.length; s += 2) ink[(oy + g.corners[s + 1]) * W + ox + g.corners[s]] = 1;\n    const r = g.runs;\n    for (let s = 0; s \u003c r.length; s += 7) {\n      const u = F - (r[s] - 1);\n      if (u \u003c= 0) continue;\n      const len = abs(r[s + 5] - r[s + 3]) + abs(r[s + 6] - r[s + 4]) + 1;\n      const shown = min(len + 1, ceil(u * (len + 1)));\n      ink[(oy + r[s + 2]) * W + ox + r[s + 1]] = 1;\n      if (shown > 1) line(ink, ox + r[s + 3], oy + r[s + 4], ox + r[s + 5], oy + r[s + 6], shown - 1);\n    }\n  }\n\n  // Colour. Every ink LED has the same brightest channel and every paper LED\n  // the same level, so the picture has only hard steps; the sheen and the\n  // mottle move the other two channels only.\n  const hue = 0.025 + S.hue, full = hsv(hue, 0.8, 1), pale = hsv(hue, 0.38, 1);\n  let mi = 0;\n  for (let c = 1; c \u003c 3; c++) if (full[c] > full[mi]) mi = c;\n  const c1 = (mi + 1) % 3, c2 = (mi + 2) % 3;\n  const f1 = full[c1] * INK_V, f2 = full[c2] * INK_V, p1 = pale[c1] * INK_V - f1, p2 = pale[c2] * INK_V - f2;\n  // The pressure rocks round the seal; the side it has left prints thin.\n  const ang = (S.tau * 2 * PI) / 6, ca = cos(ang), sa = sin(ang), press = S.press;\n  // A sheen of pressure sweeps down the seal once every 5 s at Speed 2.\n  const band = ((S.tau / 5) % 1) * 230 - 40;\n  const rgb = [0, 0, 0];\n  const grain = S.grain, blot = S.rank;\n  for (let y = 0; y \u003c H; y++) {\n    const ny = (y - 63.5) / 64;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, j1 = grain[3 * p] - 128, j2 = grain[3 * p + 1] - 128, j3 = (grain[3 * p + 2] % 7) - 3;\n      let on = ink[p];\n      if (on) {\n        const t = 0.5 + 0.5 * (((x - 31.5) / 32) * ca + ny * sa);\n        if (blot[p] \u003c press * (0.15 + 0.85 * t * t)) on = 0;\n      }\n      if (on) {\n        const sh = max(0, 1 - abs(x * 0.5 + y - band) / 10);\n        const v = INK_V + j3;\n        rgb[mi] = v;\n        rgb[c1] = cl(f1 + p1 * sh + j1 * MOTTLE, 0, v) | 0;\n        rgb[c2] = cl(f2 + p2 * sh + (0.6 * j1 + 0.3 * j2) * MOTTLE, 0, v) | 0;\n        display.setPixel(x, y, rgb[0], rgb[1], rgb[2]);\n      } else {\n        const v = PAPER[0] + j3;\n        display.setPixel(x, y, v, cl(PAPER[1] + j1 * GRAIN, 0, v) | 0, cl(PAPER[2] + (0.6 * j1 + 0.3 * j2) * GRAIN, 0, v) | 0);\n      }\n    }\n  }\n}\n","penney-game":"// ===== Patternflow pattern =====\n// Title:   Penney's Game\n// Family:  data\n// Idea:    A fair coin is tossed into the top row from the right, each toss pushing the earlier ones left, until A's or B's triple fills the three slots at the right end; the finished game slides down a row, so the winning triples stack into a column under the two players' choices while a tall bar of wins settles onto the odds from Conway's leading numbers.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Penney's game (Walter Penney, Journal of Recreational Mathematics, 1969), its odds by John Horton Conway's leading numbers (Martin Gardner, Scientific American, 1974), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, A=0..7, Rival=0..6\n//\n// Knob 1: Hue. Turns all four colours round the wheel together: at 0 heads are gold and tails azure, A's wins pink and B's green.\n// Knob 2: Speed. Tosses a second: 10 at 2, 1 at 0.2, 15 at 3. A game of HHT against THH takes 6.5 tosses on average, so at 2 a new row comes down about once a second.\n// Knob 3: A. The triple A picks, in this order: HHT, THH, TTH, HTT, HTH, THT, HHH, TTT. The first four are a loop: each one is B's best reply to the one before it, and B's best reply to HTT is HHT again. Turning it starts the tally again.\n// Knob 4: Rival. B's triple, from the seven A left, ranked by its chance against A: 0 is the best reply, (not x2) x1 x2, which wins 2, 3 or 7 times to 1; 6 is the worst, from an even game against HHH or TTT down to losing 7 times to 1 against THH or HTT. Turning it starts the tally again.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Conway's leading numbers. A triple is three bits, oldest toss first,\n// heads 0 and tails 1. XY sets the bit worth 2^(L-1) when the last L tosses\n// of X are the first L of Y. B's odds against A are (AA - AB) : (BB - BA).\n// Checked against 200,000 simulated games for each of the eight A and its\n// best reply: the share B won came within 0.0013 of these numbers. This\n// pattern's own tally, run for an hour at Speed 3 (about 5,500 games a\n// matchup), came within one standard error on five matchups.\nconst N = 3, MASK = 7;\nconst corr = (X, Y) => {\n  let c = 0;\n  for (let L = N; L >= 1; L--) if ((X & ((1 \u003c\u003c L) - 1)) === Y >> (N - L)) c += 1 \u003c\u003c (L - 1);\n  return c;\n};\n// HHT, THH, TTH, HTT first: B's best reply to each is the next, and to HTT\n// it is HHT. Then HTH, THT, HHH and TTT.\nconst A_ORDER = [1, 4, 6, 3, 2, 5, 0, 7];\nfunction matchup(A, rank) {\n  const rivals = [];\n  for (let B = 0; B \u003c 8; B++) {\n    if (B === A) continue;\n    const a = corr(A, A) - corr(A, B), b = corr(B, B) - corr(B, A);\n    rivals.push({ B, a, b, p: a / (a + b) });\n  }\n  rivals.sort((u, v) => v.p - u.p || u.B - v.B);\n  const r = rivals[rank];\n  const g = (x, y) => (y ? g(y, x % y) : x);\n  const d = g(r.a, r.b);\n  // pB is B's chance of winning a game; the odds read A : B.\n  return { A, B: r.B, pB: r.p, oddsA: r.b / d, oddsB: r.a / d };\n}\n\n// ---- Type: digits and the letters A and B, 3 by 5.\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n  A: \"010101111101101\", B: \"110101110101110\",\n};\n\n// ---- Layout. The stream starts at row 14, one game every 5 rows: coins\n// 3 by 3 on a 4 LED pitch, an underline row and a gap. Each game is right\n// aligned on the window, the three slots at x = 44, 48 and 52 that the coin\n// has to match, so the triples that won stand in one column under A's and\n// B's own. 13 slots a row; a longer game shows its last 12 behind a mark.\nconst TOP = 14, PITCH = 5, XW = 52, SLOTS = 13, ROWS = 23;\nconst BX = 58, BW = 5, BY = TOP, BH = H - TOP;\nconst RATE = 5;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, key: \"\", m: null,\n    cur: [], games: [], aw: 0, bw: 0,\n    phase: 0, hold: 0, winner: -1, acc: 0, slide: 0, last: -9, won: -9,\n    rgb: new Float32Array(W * H * 3),\n  };\n}\n\n// One game from the first toss to the end, for filling the stream at once.\nfunction playOut(m) {\n  const g = [];\n  let w = 0;\n  for (;;) {\n    const c = Math.random() \u003c 0.5 ? 0 : 1;\n    g.push(c);\n    w = ((w \u003c\u003c 1) | c) & MASK;\n    if (g.length >= N && w === m.A) return { g, w: 0 };\n    if (g.length >= N && w === m.B) return { g, w: 1 };\n  }\n}\n\nfunction restart(S) {\n  S.games = [];\n  S.aw = S.bw = 0;\n  for (let i = 0; i \u003c ROWS; i++) {\n    const r = playOut(S.m);\n    S.games.push(r);\n    if (r.w) S.bw++;\n    else S.aw++;\n  }\n  S.cur = [];\n  S.phase = 0;\n  S.acc = 0;\n  S.slide = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const ai = cl(round(k[2]), 0, 7), ri = cl(round(k[3]), 0, 6), key = ai + \",\" + ri;\n  if (key !== S.key) {\n    S.key = key;\n    S.m = matchup(A_ORDER[ai], ri);\n    restart(S);\n  }\n  const m = S.m;\n  if (S.phase === 0) {\n    S.acc += d * RATE * S.speed;\n    while (S.acc >= 1 && S.phase === 0) {\n      S.acc -= 1;\n      const c = Math.random() \u003c 0.5 ? 0 : 1;\n      S.cur.push(c);\n      S.last = S.t;\n      const n = S.cur.length;\n      if (n >= N) {\n        const w = (S.cur[n - 3] \u003c\u003c 2) | (S.cur[n - 2] \u003c\u003c 1) | S.cur[n - 1];\n        if (w === m.A || w === m.B) {\n          S.winner = w === m.A ? 0 : 1;\n          if (S.winner) S.bw++;\n          else S.aw++;\n          S.phase = 1;\n          S.hold = 0;\n          S.won = S.t;\n        }\n      }\n    }\n  } else {\n    // The winning triple holds a moment, then the row goes down.\n    S.hold += d;\n    if (S.hold >= min(1.5, 0.7 / S.speed)) {\n      S.games.unshift({ g: S.cur, w: S.winner });\n      if (S.games.length > ROWS + 1) S.games.pop();\n      S.cur = [];\n      S.phase = 0;\n      S.acc = 0;\n      S.slide += PITCH;\n    }\n  }\n  S.slide = max(0, S.slide - d * PITCH * 6);\n}\n\nfunction put(rgb, x, y, c, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  rgb[p] += c[0] * v, rgb[p + 1] += c[1] * v, rgb[p + 2] += c[2] * v;\n}\n// A coin: a 3 by 3 disc with soft corners.\nfunction coin(rgb, x, y, c, v) {\n  for (let j = 0; j \u003c 3; j++) for (let i = 0; i \u003c 3; i++) put(rgb, x + i, y + j, c, i !== 1 && j !== 1 ? v * 0.35 : v);\n}\nfunction glyph(rgb, ch, x, y, c, v) {\n  const g = GLYPH[ch];\n  for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") put(rgb, x + q, y + r, c, v);\n}\nfunction number(rgb, n, xr, y, c, v) {\n  const s = String(n);\n  for (let i = 0; i \u003c s.length; i++) glyph(rgb, s[s.length - 1 - i], xr - 3 - 4 * i, y, c, v);\n}\n\n// One game's row with its top at y. live: the game still being tossed.\nfunction row(S, rgb, g, w, y, live, cols) {\n  if (y + 3 \u003c TOP - 1 || y >= H) return;\n  const n = g.length, show = n > SLOTS ? SLOTS - 1 : n, t = S.t;\n  for (let j = 0; j \u003c show; j++) {\n    const c = g[n - 1 - j], x = XW - 4 * j;\n    let v = j \u003c N ? 0.95 : 0.62;\n    if (live) {\n      v = j \u003c N ? 0.85 : 0.6;\n      if (j === 0) v = min(1, v + 0.6 * exp(-(t - S.last) * 8));\n    }\n    if (y >= TOP - 1) coin(rgb, x, y, c ? cols.T : cols.H, v);\n  }\n  if (n > SLOTS) for (let j = 0; j \u003c 3; j++) put(rgb, XW - 4 * (SLOTS - 1) + j, y + 1, cols.dim, 0.5);\n  if (w >= 0 && n >= N && y + 3 >= TOP) {\n    let v = 0.7;\n    if (live) v = 0.6 + 0.4 * (0.5 + 0.5 * Math.cos((t - S.won) * 18));\n    for (let x = XW - 8; x \u003c= XW + 2; x++) put(rgb, x, y + 3, w ? cols.B : cols.A, v);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.m) return;\n  const rgb = S.rgb, m = S.m, hue = S.hue;\n  rgb.fill(0);\n  const cols = {\n    H: hsv(0.14 + hue, 0.66, 1), T: hsv(0.57 + hue, 0.8, 1),\n    A: hsv(0.9 + hue, 0.62, 1), B: hsv(0.36 + hue, 0.72, 1),\n    dim: hsv(0.6 + hue, 0.1, 1), ink: hsv(0.6 + hue, 0.06, 1),\n  };\n\n  // Header: count, letter, triple, and the player's side of the odds.\n  for (let s = 0; s \u003c 2; s++) {\n    const y = 1 + 6 * s, c = s ? cols.B : cols.A, X = s ? m.B : m.A;\n    number(rgb, s ? S.bw : S.aw, 35, y, c, 0.75);\n    glyph(rgb, s ? \"B\" : \"A\", 38, y, c, 1);\n    for (let j = 0; j \u003c N; j++) coin(rgb, XW - 8 + 4 * j, y + 1, (X >> (N - 1 - j)) & 1 ? cols.T : cols.H, 1);\n    glyph(rgb, String(s ? m.oddsB : m.oddsA), 59, y, cols.ink, 0.9);\n  }\n\n  // The stream: the game being tossed at the top, the finished ones below.\n  const sl = round(S.slide);\n  row(S, rgb, S.cur, S.phase === 1 ? S.winner : -1, TOP - sl, true, cols);\n  for (let k = 0; k \u003c S.games.length; k++) {\n    const y = TOP + PITCH * (k + 1) - sl;\n    if (y >= H) break;\n    row(S, rgb, S.games[k].g, S.games[k].w, y, false, cols);\n  }\n\n  // The tally: A's share of the games from the top of the bar, B's below,\n  // and a white tick where Conway's numbers put the line.\n  const tot = S.aw + S.bw, ha = tot ? round((BH * S.aw) / tot) : 0;\n  for (let y = BY; y \u003c H; y++) {\n    const isA = y - BY \u003c ha, c = isA ? cols.A : cols.B;\n    for (let x = BX; x \u003c BX + BW; x++) put(rgb, x, y, c, 0.55);\n  }\n  const yt = BY + round(BH * (1 - m.pB));\n  for (let x = BX - 2; x \u003c W; x++) put(rgb, x, yt, cols.ink, x >= BX && x \u003c BX + BW ? 0.45 : 1);\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[p * 3], g = rgb[p * 3 + 1], b = rgb[p * 3 + 2];\n    if (r + g + b > 0) display.setPixel(p % W, floor(p / W), min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n","steiner-symmetrization":"// ===== Patternflow pattern =====\n// Title:   Steiner Symmetrization\n// Family:  line\n// Idea:    An irregular shape drawn as a hatch of parallel one-LED chords slides every chord along itself, each at its own moment so a shear wave runs down the stack, until its midpoint sits on a faint axis and chords cut by a gap close into one, then the hatch turns to a new axis and slides again, while a faint circle marks the disc of the same area and a bar at the foot shrinks the perimeter toward the disc's.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Steiner symmetrization (Jakob Steiner, 1838), repeated symmetrizations converging to the disc (Wilhelm Gross, 1917, after Wilhelm Blaschke's selection theorem in Kreis und Kugel, 1916), symmetrization in a finite set of directions (Daniel Klain, 2012), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Axes=0..8\n//\n// Knob 1: Hue. Turns the hatch round the wheel. At 0 the chords run from azure to violet along the axis, with the bar in amber.\n// Knob 2: Speed. At 2 a symmetrization takes about 2.1 s: the chords slide for up to 1.4 s, rest 0.2 s and the hatch turns for 0.5 s, and a shape that has come round holds 1.3 s and fades into the next. At 0.2 ten times slower, at 3 two thirds as long.\n// Knob 3: Shape. 0 takes the five starting shapes in turn, a crescent, an egg with a hole, a seven pointed star, two blobs and a comb; 1 to 5 start from one of them every time.\n// Knob 4: Axes. 0 turns the axis by 68.75 degrees, the golden angle of a half turn, every time, so no axis comes back and the shape rounds into the disc. 1 to 8 use that many axes, evenly spaced and drawn faintly. One axis does all its work in the first slide. With a few the shape settles into one with a mirror for every axis that is still not the disc: with two axes the star stops at 1.24 times the disc's perimeter, with three at 1.03, and from four on it comes within 1%.\n\nconst W = 64, H = 128, OX = 32, OY = 64;\nconst { floor, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Chords one LED apart, s from -72 to 72 along the axis, at most MAXP\n// pieces each.\nconst K = 144, S0 = -72, MAXP = 8, MAXC = 16;\n// The golden angle of a half turn, pi (2 - phi) for the golden ratio phi:\n// 68.75 degrees, so no two axes are ever the same.\nconst GOLD = (PI * (3 - sqrt(5))) / 2;\nconst BAR = 60;\n\n// Shapes as rings of points; a point is inside when a ray from it crosses\n// the rings an odd number of times, so a ring inside another is a hole.\nfunction arc(cx, cy, h, b, n, out, back) {\n  // A circular arc from (cx, cy - h) to (cx, cy + h) bulging left by b.\n  const R = (h * h + b * b) / (2 * b), p0 = Math.asin(h / R), C = cx - b + R;\n  for (let i = 0; i \u003c= n; i++) {\n    const u = back ? 1 - i / n : i / n, p = -p0 + 2 * p0 * u;\n    out.push(C - R * cos(p), cy + R * sin(p));\n  }\n  return out;\n}\nfunction ellipse(cx, cy, rx, ry, n, out) {\n  for (let i = 0; i \u003c n; i++) out.push(cx + rx * cos((2 * PI * i) / n), cy + ry * sin((2 * PI * i) / n));\n  return out;\n}\nconst SHAPES = [\n  // A crescent between two arcs on the same chord.\n  () => [arc(52, 64, 56, 12, 40, arc(52, 64, 56, 40, 60, []), true).slice(0, -2)],\n  // An egg with a round hole off its centre.\n  () => [ellipse(32, 64, 29, 40, 72, []), ellipse(39, 54, 14, 14, 40, [])],\n  // A seven pointed star, stretched to the panel.\n  () => {\n    const out = [];\n    for (let i = 0; i \u003c 14; i++) {\n      const a = (PI * i) / 7 - PI / 2 + 0.2, r = i % 2 ? 15 : 30;\n      out.push(32 + r * cos(a), 64 + 1.55 * r * sin(a));\n    }\n    return [out];\n  },\n  // Two blobs apart.\n  () => [ellipse(22, 37, 17, 24, 48, []), ellipse(42, 92, 19, 21, 48, [])],\n  // A comb of three teeth on a spine.\n  () => [[12, 14, 60, 14, 60, 30, 26, 30, 26, 56, 60, 56, 60, 72, 26, 72, 26, 98, 60, 98, 60, 114, 12, 114]],\n];\n\nfunction perimeter(rings) {\n  let p = 0;\n  for (const r of rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const j = (i + 2) % r.length;\n      p += sqrt((r[j] - r[i]) ** 2 + (r[j + 1] - r[i + 1]) ** 2);\n    }\n  return p;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    rings: null, shape: -1, n: 0, phase: 1, pt: 0.5, phi: PI / 2, from: PI / 2, to: PI / 2,\n    P0: 1, P: 1, Pfrom: 1, Pto: 1, A: 1, prevP: 1, still: 0, fade: 1, dir: 1,\n    cross: new Float64Array(K * MAXC), nc: new Int32Array(K),\n    a0: new Float64Array(K * MAXP), b0: new Float64Array(K * MAXP), a1: new Float64Array(K * MAXP), b1: new Float64Array(K * MAXP),\n    cnt: new Int32Array(K), L: new Float64Array(K), del: new Float64Array(K), dur: new Float64Array(K), u: new Float64Array(K), sp: new Float64Array(K),\n    col: new Float64Array(3), tmp: new Float64Array(3), ax: new Float64Array(16),\n    next: null, prog: 0.5, hue: 0.5, axes: 0,\n  };\n  return params.s;\n}\n\n// The pieces of every chord at angle phi: the line s = const through the\n// rings, crossings sorted along t and taken in pairs.\nfunction cut(S, phi, a, b, cnt) {\n  const { cross, nc } = S, ca = cos(phi), sa = sin(phi);\n  nc.fill(0);\n  for (const r of S.rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const j = (i + 2) % r.length;\n      const x1 = r[i] - OX, y1 = r[i + 1] - OY, x2 = r[j] - OX, y2 = r[j + 1] - OY;\n      const s1 = x1 * ca + y1 * sa, s2 = x2 * ca + y2 * sa;\n      if (s1 === s2) continue;\n      const t1 = -x1 * sa + y1 * ca, t2 = -x2 * sa + y2 * ca;\n      const lo = min(s1, s2), hi = max(s1, s2);\n      // Chords with lo \u003c= s \u003c hi, so a vertex is counted once. Both ends\n      // are tested on the same s, or rounding counts a vertex twice.\n      for (let k = max(0, floor(lo - S0 - 0.5)); k \u003c K; k++) {\n        const s = S0 + k + 0.5;\n        if (s \u003c lo) continue;\n        if (s >= hi) break;\n        const t = t1 + ((s - s1) / (s2 - s1)) * (t2 - t1);\n        let m = nc[k];\n        if (m >= MAXC) continue;\n        const o = k * MAXC;\n        while (m > 0 && cross[o + m - 1] > t) {\n          cross[o + m] = cross[o + m - 1];\n          m--;\n        }\n        cross[o + m] = t;\n        nc[k]++;\n      }\n    }\n  for (let k = 0; k \u003c K; k++) {\n    const n = min(MAXP, nc[k] >> 1), o = k * MAXC;\n    cnt[k] = n;\n    for (let j = 0; j \u003c n; j++) {\n      a[k * MAXP + j] = cross[o + 2 * j];\n      b[k * MAXP + j] = cross[o + 2 * j + 1];\n    }\n  }\n}\n\n// The total length of the chord at s, for the ends of the new shape.\nfunction lengthAt(S, phi, s) {\n  const ca = cos(phi), sa = sin(phi), ts = [];\n  for (const r of S.rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const j = (i + 2) % r.length;\n      const x1 = r[i] - OX, y1 = r[i + 1] - OY, x2 = r[j] - OX, y2 = r[j + 1] - OY;\n      const s1 = x1 * ca + y1 * sa, s2 = x2 * ca + y2 * sa;\n      if (s1 === s2 || s \u003c min(s1, s2) || s >= max(s1, s2)) continue;\n      ts.push(-x1 * sa + y1 * ca + ((s - s1) / (s2 - s1)) * (-x2 * sa + y2 * ca + x1 * sa - y1 * ca));\n    }\n  ts.sort((p, q) => p - q);\n  let L = 0;\n  for (let i = 0; i + 1 \u003c ts.length; i += 2) L += ts[i + 1] - ts[i];\n  return L;\n}\n\n// Start a symmetrization about the axis through the centre at angle phi:\n// each chord's pieces now, and where they end, stacked in their order into\n// one chord centred on the axis. The new shape is a ring through the ends\n// of the centred chords for every run of chords that are not empty, so two\n// blobs no chord crosses stay two.\nfunction begin(S, phi) {\n  const { a0, b0, a1, b1, cnt, L, del, dur, u, sp } = S;\n  S.phi = S.from = S.to = phi;\n  cut(S, phi, a0, b0, cnt);\n  const ca = cos(phi), sa = sin(phi);\n  let lo = 1e9, hi = -1e9;\n  for (const r of S.rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const s = (r[i] - OX) * ca + (r[i + 1] - OY) * sa;\n      lo = min(lo, s);\n      hi = max(hi, s);\n    }\n  for (let k = 0; k \u003c K; k++) {\n    let len = 0;\n    for (let j = 0; j \u003c cnt[k]; j++) len += b0[k * MAXP + j] - a0[k * MAXP + j];\n    L[k] = len;\n    let at = -len / 2;\n    for (let j = 0; j \u003c cnt[k]; j++) {\n      const o = k * MAXP + j, l = b0[o] - a0[o];\n      a1[o] = at;\n      b1[o] = at + l;\n      at += l;\n    }\n    // The shear wave runs along the axis, the other way each time.\n    const w = cl((S0 + k + 0.5 - lo) / max(1, hi - lo), 0, 1);\n    del[k] = 0.45 * (S.dir > 0 ? w : 1 - w) + 0.08 * Math.random();\n    dur[k] = 0.7 * (0.8 + 0.4 * Math.random());\n    u[k] = 0;\n    sp[k] = 0;\n  }\n  S.dir = -S.dir;\n  // Runs of (s, length). A run's open end reaches past its last chord as\n  // far as the lengths' slope says, at most to the empty chord beside it.\n  const e = 1e-4, runs = [];\n  let run = null;\n  const end = (r, back) => {\n    const n = r.length, l0 = back ? r[n - 1] : r[1], l1 = n > 2 ? (back ? r[n - 3] : r[3]) : 0;\n    const d = n > 2 ? min(1, l0 / max(1e-3, l1 - l0)) : 0.5, s = (back ? r[n - 2] : r[0]) + (back ? d : -d);\n    if (back) r.push(s, 0);\n    else r.unshift(s, 0);\n  };\n  for (let k = 0; k \u003c K; k++) {\n    const s = S0 + k + 0.5;\n    if (s \u003c= lo + e || s >= hi - e) continue;\n    if (L[k] > 0) {\n      if (!run) run = [];\n      run.push(s, L[k]);\n    } else if (run) {\n      end(run, true);\n      runs.push(run);\n      run = null;\n    }\n  }\n  if (run) runs.push(run);\n  if (!runs.length) runs.push([]);\n  // The shape's own ends, measured exactly.\n  if (runs[0][0] !== undefined && runs[0][1] === 0) runs[0].splice(0, 2);\n  runs[0].unshift(lo + e, lengthAt(S, phi, lo + e));\n  for (let i = 1; i \u003c runs.length; i++) end(runs[i], false);\n  runs[runs.length - 1].push(hi - e, lengthAt(S, phi, hi - e));\n  // Keep the area the shape started with: sampling a curved edge at one LED\n  // loses a sliver every time, so the lengths are scaled back up.\n  let area = 0;\n  for (const r of runs) for (let i = 0; i + 3 \u003c r.length; i += 2) area += ((r[i + 2] - r[i]) * (r[i + 1] + r[i + 3])) / 2;\n  const f = area > 0 ? S.A / area : 1;\n  S.next = runs.map((r) => {\n    const ring = [];\n    for (let i = 0; i \u003c r.length; i += 2) ring.push(OX + r[i] * ca + ((f * r[i + 1]) / 2) * sa, OY + r[i] * sa - ((f * r[i + 1]) / 2) * ca);\n    for (let i = r.length - 2; i >= 0; i -= 2) ring.push(OX + r[i] * ca - ((f * r[i + 1]) / 2) * sa, OY + r[i] * sa + ((f * r[i + 1]) / 2) * ca);\n    return ring;\n  });\n  S.Pfrom = S.P;\n  S.Pto = perimeter(S.next);\n  S.phase = 0;\n  S.pt = 0;\n}\n\nfunction newShape(S, sel) {\n  S.shape = sel ? sel - 1 : (S.shape + 1) % SHAPES.length;\n  S.rings = SHAPES[S.shape]();\n  S.P0 = S.P = S.prevP = perimeter(S.rings);\n  S.n = 0;\n  S.still = 0;\n  S.pt = 0;\n  S.phi = S.from = S.to = PI / 2;\n  // The area, for the disc's perimeter, from the chords of the first cut.\n  cut(S, S.phi, S.a0, S.b0, S.cnt);\n  let A = 0;\n  for (let k = 0; k \u003c K; k++) for (let j = 0; j \u003c S.cnt[k]; j++) A += S.b0[k * MAXP + j] - S.a0[k * MAXP + j];\n  S.A = A;\n}\n\nconst ease = (x) => x * x * (3 - 2 * x);\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = kv[0] || 0;\n  const rate = cl(kv[1], 0.2, 3) / 2, sel = cl(Math.round(kv[2]), 0, 5), axes = cl(Math.round(kv[3]), 0, 8);\n  S.axes = axes;\n  if (!S.rings) newShape(S, sel);\n  const d = cl(dt || 0, 0, 0.1) * rate;\n  S.pt += d;\n  if (S.phase === 0) {\n    // Slide: each chord eases from its pieces to the centred chord.\n    let all = true, sum = 0;\n    for (let k = 0; k \u003c K; k++) {\n      const x = cl((S.pt - S.del[k]) / S.dur[k], 0, 1), e = ease(x);\n      S.sp[k] = d > 0 ? (e - S.u[k]) / d : 0;\n      S.u[k] = e;\n      sum += e;\n      if (x \u003c 1) all = false;\n    }\n    S.prog = sum / K;\n    S.P = S.Pfrom + (S.Pto - S.Pfrom) * S.prog;\n    if (all) {\n      S.rings = S.next;\n      S.P = S.Pto;\n      S.n++;\n      S.still = abs(S.prevP - S.P) \u003c 0.002 * S.P ? S.still + 1 : 0;\n      S.prevP = S.P;\n      S.phase = 1;\n      S.pt = 0;\n      S.sp.fill(0);\n    }\n  } else if (S.phase === 1 && S.pt > (S.n ? 0.2 : 0.15)) {\n    // Rest, then turn to the next axis, or let a round or settled shape go.\n    const disc = 2 * sqrt(PI * S.A);\n    if (S.n && (S.P \u003c disc * 1.006 || S.still >= 2 || S.n >= 12)) {\n      S.phase = 3;\n      S.pt = 0;\n    } else if (!S.n) begin(S, S.phi);\n    else {\n      S.from = S.phi;\n      S.to = S.phi + (axes ? PI / axes : GOLD);\n      S.phase = axes === 1 ? 2.5 : 2;\n      S.pt = 0;\n    }\n  } else if (S.phase === 2) {\n    const x = cl(S.pt / 0.5, 0, 1);\n    S.phi = S.from + (S.to - S.from) * ease(x);\n    if (x >= 1) begin(S, S.to % (2 * PI));\n  } else if (S.phase === 2.5) {\n    // One axis: nothing to turn to.\n    if (S.pt > 0.3) begin(S, S.phi);\n  } else if (S.phase === 3) {\n    // Hold the shape it settled into, then fade into a new one.\n    S.fade = S.pt \u003c 1.3 ? 1 : max(0, 1 - (S.pt - 1.3) / 0.3);\n    if (S.pt > 1.6) {\n      newShape(S, sel);\n      S.phase = 4;\n      S.pt = 0;\n    }\n  } else if (S.phase === 4) {\n    S.fade = min(1, S.pt / 0.3);\n    if (S.pt > 0.6) {\n      S.fade = 1;\n      begin(S, S.phi);\n    }\n  }\n  if (S.phase !== 0) S.prog = 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.rings) return;\n  const sliding = S.phase === 0, { a0, b0, a1, b1, cnt, u, sp } = S;\n  if (!sliding) cut(S, S.phi, a0, b0, cnt);\n  const ca = cos(S.phi), sa = sin(S.phi), h0 = 0.56 + S.hue, f = S.fade, col = S.col;\n  // Every axis of a finite set, drawn faintly; the current one a little\n  // brighter.\n  const na = S.axes || 1, rd = sqrt(S.A / PI), ax = S.ax;\n  for (let m = 1; m \u003c na; m++) {\n    ax[2 * m] = sin(S.phi + (PI * m) / na);\n    ax[2 * m + 1] = cos(S.phi + (PI * m) / na);\n  }\n  for (let Y = 0; Y \u003c H - 6; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const x = X + 0.5 - OX, y = Y + 0.5 - OY, s = x * ca + y * sa, t = -x * sa + y * ca;\n      const k = floor(s - S0);\n      let lit = 0, piece = 0;\n      if (k >= 0 && k \u003c K)\n        for (let j = 0; j \u003c cnt[k]; j++) {\n          const o = k * MAXP + j;\n          const A = sliding ? a0[o] + (a1[o] - a0[o]) * u[k] : a0[o], B = sliding ? b0[o] + (b1[o] - b0[o]) * u[k] : b0[o];\n          const c = min(t - A, B - t) + 0.5;\n          if (c > lit) {\n            lit = min(1, c);\n            piece = j;\n          }\n        }\n      if (lit > 0) {\n        // Hue runs along the axis, odd and even chords alternate in\n        // brightness, a moving chord flares and pieces cut apart by a gap\n        // keep their own tint until they meet.\n        const w = (s + 40) / 80, mv = sliding ? cl(abs(sp[k]) * 0.012 * (abs(a1[k * MAXP + piece] - a0[k * MAXP + piece]) + 4), 0, 1) : 0;\n        const tint = sliding && piece % 2 ? 0.22 * (1 - u[k]) : 0;\n        hsv(h0 + 0.16 * cl(w, 0, 1) + tint, 0.75 - 0.45 * mv, (k & 1 ? 0.9 : 0.56) + 0.12 * mv, col);\n        const g = lit * f * (abs(t) \u003c 0.5 ? 1.15 : 1);\n        display.setPixel(X, Y, min(255, col[0] * g) | 0, min(255, col[1] * g) | 0, min(255, col[2] * g) | 0);\n        continue;\n      }\n      // Outside: the axes, and the disc of the same area as a faint ring.\n      let v = 0;\n      if (abs(t) \u003c 0.5) v = 0.24;\n      else if (na > 1)\n        for (let m = 1; m \u003c na; m++) if (abs(-x * ax[2 * m] + y * ax[2 * m + 1]) \u003c 0.5) v = 0.13;\n      if (abs(sqrt(x * x + y * y) - rd) \u003c 0.5) v = max(v, 0.16);\n      if (v > 0) {\n        hsv(h0 + 0.08, 0.45, v * f, col);\n        display.setPixel(X, Y, col[0] | 0, col[1] | 0, col[2] | 0);\n      }\n    }\n  // The perimeter bar: full width is the starting shape's perimeter, the\n  // white tick the disc's 2 sqrt(pi A).\n  const len = (BAR * S.P) / S.P0, tick = 2 + (BAR * 2 * sqrt(PI * S.A)) / S.P0;\n  const bar = hsv(h0 + 0.5, 0.8, 0.95, S.tmp);\n  for (let X = 2; X \u003c 2 + BAR; X++) {\n    const c = cl(len - (X - 2), 0, 1);\n    for (let Y = 124; Y \u003c 126; Y++) {\n      if (c > 0) display.setPixel(X, Y, (bar[0] * c * f) | 0, (bar[1] * c * f) | 0, (bar[2] * c * f) | 0);\n      else display.setPixel(X, Y, 30 * f, 30 * f, 34 * f);\n    }\n  }\n  const T = floor(tick);\n  for (let Y = 122; Y \u003c 128; Y++) display.setPixel(T, Y, 255 * f, 255 * f, 255 * f);\n}\n","whitney-graustein":"// ===== Patternflow pattern =====\n// Title:   Whitney-Graustein\n// Family:  topology\n// Idea:    A closed curve drawn as a bright line coloured by the direction of its tangent keeps reshaping without ever stopping, so it never leaves its class of turning number, the regions it encloses shaded by their winding number and a dial counting how often the tangent turns, and a change of class has to pass through a cusp: a small loop pulled tight until it vanishes, or a kink born from one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Whitney-Graustein theorem (Hassler Whitney, On regular closed curves in the plane, 1937, crediting William Caspar Graustein), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Turns=-2..3, Wobble=0..1\n//\n// Knob 1: Hue. Turns the colour wheel the tangent is painted with, and the region shades with it. At 0 a tangent pointing right is azure, regions of winding number 1 and 2 are violet and lilac, and regions of winding -1 are green.\n// Knob 2: Speed. At 2 the white marker runs round the curve in 4 s and a change of class takes 5 s, 2.4 of them on the way into and out of the cusp; 0.2 is ten times slower.\n// Knob 3: Turns. The turning number k, from -2 to 3, opening on 0, a figure eight. Each step of the knob is one change of class through one cusp, so a jump of three classes passes three.\n// Knob 4: Wobble. How far the curve strays from the plain shape of its class: three Fourier terms of the tangent angle, once, twice and three times round, reach 0.38, 0.28 and 0.18 radians at 0 and three times that at 1.\n// Buttons: a press moves the curve one class up (down from 3) through a cusp; a second press brings it back.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The curve. Its tangent angle is theta(t) = th0 + k t + p(t) for t\n// round the circle, so the tangent turns k times; p is periodic, three\n// Fourier terms whose sizes and phases drift. Its speed r(t) is solved\n// below so that the curve closes and never stops, so it stays regular and\n// every change of p is a regular homotopy: the class cannot change.\nconst NS = 600, DT = TAU / NS;\n// The plain shape of each class: theta = k t + b sin t. For k = 0 the\n// tangent swings 2.405 radians each way, the first zero of the Bessel\n// function J0, where the figure eight closes by itself.\nconst BASE = { \"-2\": 1.25, \"-1\": 0.5, 0: 2.405, 1: 0.5, 2: 1.25, 3: 1.6 };\nconst base = (k) => BASE[k] ?? 1.4;\n// Top strip for the dial and the number; the curve lives below it.\nconst TOP = 21, MARGIN = 3;\n\nfunction localTurn(S, d) {\n  // The kink, after the normal form (u^2, u^3 - s u) of a loop that is\n  // pulled tight into a cusp at s = 0 and smoothed away for s \u003c 0. Its\n  // tangent turns a full circle when s > 0 and not at all when s \u003c 0. The\n  // normal form's tangent only creeps back to straight, as 1/u; past\n  // |u| = 1.5 it is eased the rest of the way by |u| = 3, so the kink\n  // stays local.\n  const u = d / S.w, s = S.s;\n  let a = atan2(-2 * u, 3 * u * u - s);\n  const far = s > 0 && u > 0 ? TAU : 0;\n  if (s > 0 && u > 0) a += TAU;\n  const e = smooth((abs(u) - 1.5) / 1.5);\n  return a + (far - a) * e;\n}\n\nfunction build(S) {\n  const { kb, th0, b1, amp, ph, loop, mu, fade } = S;\n  const damp = S.damp;\n  // Wrapped Cauchy: (1 + rho) / (1 - rho), for the spread turn.\n  const q = (1 + S.rho) / (1 - S.rho);\n  const TH = S.TH;\n  let e0 = 0, e1 = 0, n = 0;\n  if (loop) {\n    e0 = localTurn(S, -PI);\n    e1 = localTurn(S, PI - 1e-9);\n    n = S.s > 0 ? 1 : 0;\n  }\n  for (let i = 0; i \u003c NS; i++) {\n    const t = i * DT;\n    let th = th0 + kb * t + b1 * sin(t) + damp * (amp[0] * sin(t + ph[0]) + amp[1] * sin(2 * t + ph[1]) + amp[2] * sin(3 * t + ph[2]));\n    if (loop) {\n      let d = t - S.t0;\n      d -= TAU * floor((d + PI) / TAU);\n      // The kink's turn, made exactly periodic.\n      let L = fade * (localTurn(S, d) - (e0 + ((e1 - e0 - TAU * n) * (d + PI)) / TAU));\n      // The same full turn as a wrapped Cauchy step: as rho falls to 0 it\n      // spreads evenly round the curve, where it is the turn of class k+1.\n      if (mu > 0) L += mu * (2 * Math.atan(q * Math.tan(d / 2)) + PI - L);\n      th += L;\n    }\n    TH[i] = th;\n  }\n  // Closure. The speed is r = exp(Re(conj(beta) e^(i theta))), positive\n  // for any beta, and beta minimises the convex sum of r over the samples:\n  // its gradient is the sum of r e^(i theta), the gap the curve would leave,\n  // and the minimum exists because the tangent points every way, or for\n  // k = 0 through more than a half turn. A few Newton steps from the last\n  // frame's beta find it.\n  const CS = S.CS, SN = S.SN;\n  for (let i = 0; i \u003c NS; i++) (CS[i] = cos(TH[i])), (SN[i] = sin(TH[i]));\n  let bu = S.bu, bv = S.bv;\n  for (let it = 0; it \u003c 12; it++) {\n    let gx = 0, gy = 0, hxx = 0, hxy = 0, hyy = 0;\n    for (let i = 0; i \u003c NS; i++) {\n      const c = CS[i], sn = SN[i], e = Math.exp(bu * c + bv * sn);\n      gx += e * c;\n      gy += e * sn;\n      hxx += e * c * c;\n      hxy += e * c * sn;\n      hyy += e * sn * sn;\n    }\n    const det = hxx * hyy - hxy * hxy;\n    let du = (hyy * gx - hxy * gy) / det, dv = (hxx * gy - hxy * gx) / det;\n    const st = sqrt(du * du + dv * dv);\n    if (st > 0.5) (du *= 0.5 / st), (dv *= 0.5 / st);\n    bu -= du;\n    bv -= dv;\n    if (st \u003c 1e-7) break;\n  }\n  // No closed curve has these tangents (a k = 0 curve whose tangent swings\n  // less than a half turn): report it and leave the last good curve alone.\n  let gx = 0, gy = 0;\n  for (let i = 0; i \u003c NS; i++) {\n    const e = Math.exp(bu * CS[i] + bv * SN[i]);\n    gx += e * CS[i];\n    gy += e * SN[i];\n  }\n  S.ok = Number.isFinite(bu) && Number.isFinite(bv) && abs(gx) + abs(gy) \u003c 1e-3 * NS;\n  if (!S.ok) return;\n  S.bu = bu;\n  S.bv = bv;\n  S.beta = sqrt(bu * bu + bv * bv);\n  let x = 0, y = 0;\n  const X = S.X, Y = S.Y;\n  for (let i = 0; i \u003c NS; i++) {\n    const r = Math.exp(bu * CS[i] + bv * SN[i]);\n    S.HT[i] = TH[i];\n    X[i] = x;\n    Y[i] = y;\n    x += r * CS[i] * DT;\n    y += r * SN[i] * DT;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    TH: new Float64Array(NS), HT: new Float64Array(NS), CS: new Float64Array(NS), SN: new Float64Array(NS), bu: 0, bv: 0, X: new Float64Array(NS), Y: new Float64Array(NS),\n    PX: new Float32Array(NS), PY: new Float32Array(NS),\n    rows: Array.from({ length: H }, () => []),\n    wind: new Int8Array(W * H),\n    kb: null, th0: 0, b1: 0, amp: [0, 0, 0], ph: [0, 0, 0],\n    loop: 0, mu: 0, rho: 0, damp: 1, fade: 0, s: 0, w: 0.4, t0: 0, phase: 0, pt: 0, dir: 0,\n    tau: 0, mark: 0, flash: 0, off: 0, hue: 0, wob: 0.3,\n    // Each harmonic of p drifts at its own pace.\n    rate: [0.11 + 0.05 * Math.random(), 0.17 + 0.05 * Math.random(), 0.23 + 0.05 * Math.random()],\n    seed: [Math.random() * TAU, Math.random() * TAU, Math.random() * TAU],\n  };\n}\n\n// Seconds at Speed 2 for easing the kink in, for the cusp, and for spreading\n// the new turn round the curve.\nconst EASE = 0.6, CUSP = 2.4, SPREAD = 2;\nconst S_MAX = 2;\n// The spread turn starts as wide as the kink: (1 - RHO) / (1 + RHO) = 0.2.\nconst RHO = 0.667;\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3) / 2;\n  S.hue = k[0];\n  S.wob = 0.5 + 1.0 * cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed.some(Boolean)) S.off = S.off ? 0 : 1;\n  const pick = cl(round(k[2]), -2, 3);\n  const target = S.off ? (pick \u003c 3 ? pick + 1 : pick - 1) : pick;\n  if (S.kb === null) (S.kb = target), (S.b1 = base(target));\n  S.tau += dt * sp;\n  // The marker goes round the curve once in 4 s at Speed 2.\n  S.mark = (S.mark + (dt * sp) / 4) % 1;\n  for (let m = 0; m \u003c 3; m++) {\n    S.amp[m] = S.wob * [0.75, 0.55, 0.35][m] * sin(S.rate[m] * TAU * S.tau * 0.5 + S.seed[m]);\n    S.ph[m] = S.seed[m] * 2 + S.tau * S.rate[m] * 1.3;\n  }\n  S.th0 += dt * sp * 0.05;\n\n  // Class changes, one step at a time.\n  if (!S.phase && target !== S.kb) {\n    S.dir = target > S.kb ? 1 : -1;\n    S.phase = 1;\n    S.pt = 0;\n    S.loop = 0;\n    build(S);\n    // The kink sits where the curve is farthest from its middle.\n    let cx = 0, cy = 0, best = -1;\n    for (let i = 0; i \u003c NS; i++) (cx += S.X[i]), (cy += S.Y[i]);\n    cx /= NS;\n    cy /= NS;\n    for (let i = 0; i \u003c NS; i += 3) {\n      const d = (S.X[i] - cx) ** 2 + (S.Y[i] - cy) ** 2;\n      if (d > best) (best = d), (S.t0 = i * DT);\n    }\n    // Next to class 0 the kink goes at t = 0, where the turn adds to the\n    // swing b1 sin t instead of cancelling it: a k = 0 curve needs its\n    // tangent to swing more than a half turn, or nothing closes it.\n    const lo = S.dir > 0 ? S.kb : S.kb - 1;\n    if (lo === 0 || lo === -1) S.t0 = 0;\n    S.loop = 1;\n    if (S.dir > 0) (S.fade = 0), (S.s = -S_MAX), (S.mu = 0), (S.rho = RHO);\n    else {\n      // Write the class-k curve as a class k-1 curve plus a full turn\n      // spread evenly round it, then gather that turn into a loop.\n      S.kb -= 1;\n      S.th0 -= PI - S.t0;\n      S.fade = 1;\n      S.s = S_MAX;\n      S.mu = 1;\n      S.rho = 0;\n    }\n  }\n  if (S.phase) {\n    S.pt += dt * sp;\n    // s runs from -S_MAX to S_MAX, slowest at the cusp so it can be seen.\n    const g = (u) => {\n      const v = 2 * cl(u, 0, 1) - 1;\n      return S_MAX * v * (0.2 + 0.8 * v * v);\n    };\n    const kLo = S.kb, kHi = S.kb + 1;\n    // Up runs the steps forward; down runs the same steps backward.\n    const p = S.dir > 0 ? S.pt : EASE + CUSP + SPREAD - S.pt;\n    // A bump grows, sharpens into a cusp, and a kink is born from it; the\n    // kink's full turn takes a wrapped Cauchy profile and spreads round the\n    // curve.\n    S.fade = cl(p / EASE, 0, 1);\n    S.s = g((p - EASE) / CUSP);\n    const v = cl((p - EASE - CUSP) / SPREAD, 0, 1);\n    S.mu = smooth(v / 0.3);\n    const spread = smooth((v - 0.3) / 0.7);\n    S.rho = RHO * (1 - spread);\n    S.b1 = base(kLo) + (base(kHi) - base(kLo)) * spread;\n    if (abs(S.s) \u003c 0.1 && S.fade > 0.99 && !S.mu) S.flash = 1;\n    if (S.pt >= EASE + CUSP + SPREAD) {\n      if (S.dir > 0) (S.kb += 1), (S.th0 += PI - S.t0);\n      S.loop = 0;\n      S.phase = 0;\n      S.mu = 0;\n      S.b1 = base(S.kb);\n    }\n  }\n  S.flash = max(0, S.flash - dt * 1.5);\n  // Where the wobble would push |beta| past 1.2, so that one stretch of the\n  // curve runs 11 times faster than another, or leaves nothing that closes,\n  // the wobble is turned down, and it comes back slowly.\n  S.damp = min(1, S.damp + dt * 0.3);\n  build(S);\n  for (let n = 0; n \u003c 12 && (!S.ok || S.beta > 1.2); n++) {\n    S.damp *= 0.8;\n    build(S);\n  }\n}\n\n// 3 by 5 digits and a minus.\nconst DIGITS = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\"];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.X || S.kb === null) return;\n  const { X, Y, HT: TH, PX, PY, rows, wind } = S;\n  // Fit the curve under the strip, a little taller than it is if there is room.\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c NS; i++) (x0 = min(x0, X[i])), (x1 = max(x1, X[i])), (y0 = min(y0, Y[i])), (y1 = max(y1, Y[i]));\n  const aw = W - 2 * MARGIN, ah = H - TOP - 2 * MARGIN;\n  const fx = aw / max(1e-6, x1 - x0), fy = ah / max(1e-6, y1 - y0);\n  const sx = min(fx, fy), sy = min(fy, sx * 1.8);\n  const cx = W / 2, cy = TOP + MARGIN + ah / 2, mx = (x0 + x1) / 2, my = (y0 + y1) / 2;\n  for (let i = 0; i \u003c NS; i++) {\n    PX[i] = cx + (X[i] - mx) * sx;\n    PY[i] = cy - (Y[i] - my) * sy;\n  }\n\n  // Winding numbers, row by row: each edge crossing the row's middle adds\n  // +1 going down the panel and -1 going up, counted from the left.\n  for (let y = 0; y \u003c H; y++) rows[y].length = 0;\n  for (let i = 0; i \u003c NS; i++) {\n    const j = (i + 1) % NS, ax = PX[i], ay = PY[i], bx = PX[j], by = PY[j];\n    if (ay === by) continue;\n    const dir = by > ay ? 1 : -1, lo = min(ay, by), hi = max(ay, by);\n    for (let y = Math.ceil(lo - 0.5); y + 0.5 \u003c hi && y \u003c H; y++) {\n      if (y \u003c 0 || y + 0.5 \u003c lo) continue;\n      rows[y].push(ax + ((y + 0.5 - ay) * (bx - ax)) / (by - ay), dir);\n    }\n  }\n  wind.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const r = rows[y];\n    if (!r.length) continue;\n    const idx = [];\n    for (let q = 0; q \u003c r.length; q += 2) idx.push(q);\n    idx.sort((a, b) => r[a] - r[b]);\n    let w = 0, q = 0;\n    for (let x = 0; x \u003c W; x++) {\n      while (q \u003c idx.length && r[idx[q]] \u003c x + 0.5) (w += r[idx[q] + 1]), q++;\n      wind[y * W + x] = w;\n    }\n  }\n  const hue0 = S.hue + 0.58;\n  const shade = (w) => {\n    if (!w) return null;\n    const a = min(3, abs(w));\n    return hsv(hue0 + (w > 0 ? 0.1 : -0.12) + 0.05 * a * Math.sign(w), 0.5, 0.16 + 0.12 * a);\n  };\n  const shades = {};\n  for (let w = -4; w \u003c= 4; w++) shades[w] = shade(w);\n  for (let y = TOP; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const c = shades[cl(wind[y * W + x], -4, 4)];\n      if (c) display.setPixel(x, y, c[0] * 255, c[1] * 255, c[2] * 255);\n    }\n\n  // The line, coloured by the direction it is drawn in.\n  const dirHue = (th) => atan2(sy * sin(th), sx * cos(th)) / TAU;\n  for (let i = 0; i \u003c NS; i++) {\n    const j = (i + 1) % NS, ax = PX[i], ay = PY[i], bx = PX[j], by = PY[j];\n    const c = hsv(hue0 + dirHue(TH[i]), 0.8, 1);\n    const steps = max(1, Math.ceil(2 * max(abs(bx - ax), abs(by - ay))));\n    for (let q = 0; q \u003c steps; q++) {\n      const u = q / steps;\n      display.setPixel(ax + (bx - ax) * u, ay + (by - ay) * u, c[0] * 255, c[1] * 255, c[2] * 255);\n    }\n  }\n\n  // The marker on the curve, and the dial: the colour wheel with a dot at\n  // the marker's tangent direction, which goes round k times while the\n  // marker goes round once.\n  const mi = floor(S.mark * NS) % NS, mth = TH[mi];\n  for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) display.setPixel(PX[mi] + dx, PY[mi] + dy, 255, 255, 255);\n  const DX = 11, DY = 10, DR = 7.5;\n  for (let y = 1; y \u003c 20; y++)\n    for (let x = 2; x \u003c 21; x++) {\n      const dx = x + 0.5 - DX, dy = y + 0.5 - DY, d = sqrt(dx * dx + dy * dy);\n      if (abs(d - DR) \u003c 0.75) {\n        const c = hsv(hue0 + atan2(-dy, dx) / TAU, 0.8, 0.55);\n        display.setPixel(x, y, c[0] * 255, c[1] * 255, c[2] * 255);\n      }\n    }\n  const ma = atan2(sy * sin(mth), sx * cos(mth));\n  const ddx = DX + DR * cos(ma), ddy = DY - DR * sin(ma);\n  for (let y = floor(ddy - 2); y \u003c= ddy + 2; y++)\n    for (let x = floor(ddx - 2); x \u003c= ddx + 2; x++) {\n      const d = sqrt((x + 0.5 - ddx) ** 2 + (y + 0.5 - ddy) ** 2);\n      if (d \u003c 1.7) display.setPixel(x, y, 255, 255, 255);\n    }\n  for (let y = floor(DY - 1); y \u003c= DY; y++) for (let x = floor(DX - 1); x \u003c= DX; x++) display.setPixel(x, y, 120, 120, 120);\n\n  // The turning number, doubled 3 by 5 digits.\n  const k = S.kb + (S.loop && (S.s > 0 || S.mu > 0) ? 1 : 0);\n  const lv = 150 + 105 * S.flash;\n  const dg = DIGITS[abs(k)] || DIGITS[0];\n  const ox = 40, oy = 5;\n  for (let b = 0; b \u003c 15; b++)\n    if (dg[b] === \"1\")\n      for (let e = 0; e \u003c 4; e++) display.setPixel(ox + 2 * (b % 3) + (e & 1), oy + 2 * floor(b / 3) + (e >> 1), lv, lv, lv);\n  if (k \u003c 0) for (let x = 31; x \u003c 37; x++) for (let e = 0; e \u003c 2; e++) display.setPixel(x, 9 + e, lv, lv, lv);\n\n  // The cusp flashes white, with a ring opening round it.\n  if (S.loop && S.flash > 0) {\n    const ci = floor(((S.t0 / TAU) % 1) * NS), px = PX[ci], py = PY[ci], rad = 2 + 7 * (1 - S.flash);\n    for (let y = floor(py - rad - 2); y \u003c= py + rad + 2; y++)\n      for (let x = floor(px - rad - 2); x \u003c= px + rad + 2; x++) {\n        const d = sqrt((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2);\n        const v = 255 * S.flash;\n        if (abs(d - rad) \u003c 0.7 || d \u003c 1.5) display.setPixel(x, y, v, v, v);\n      }\n  }\n}\n","composing-stick":"// ===== Patternflow pattern =====\n// Title:   Composing Stick\n// Family:  type\n// Idea:    Sorts fly one at a time from a type case whose lowercase boxes are sized by how often each letter is used into a composing stick, where the line reads left to right with every letter upside down (p shows as b, d as q) and is justified against the knee with em, en, thin and hair spaces, then turns over into the forme, where it reads right to left in mirror image (p as q), is inked and pressed onto a sheet at the foot of the panel, the only place it reads right, before the type flies back to its boxes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hand composition of movable type as Joseph Moxon set it out in Mechanick Exercises on the Whole Art of Printing (1683-84), with a simplified job case after the California job case (lowercase boxes sized by letter frequency, e the largest; capitals in equal boxes, J and U after Z); the pangram Sphinx of black quartz, judge my vow and the epitaph Benjamin Franklin wrote for himself (1728); an 8-row pixel face drawn for this pattern, in which b, d, p and q are one bitmap; pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Spacing=0..1\n//\n// Knob 1: Hue. The ink on the slab, the roller, the inked faces and the print: blue at 0, magenta at 0.25, orange at 0.5, green at 0.75. Metal, wood and paper keep their colours.\n// Knob 2: Speed. At 2 a sort leaves the case about every 0.3 s, and mind your p's and q's goes from case to sheet and back every 11 s, the Sphinx's three lines every 18 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Text. Each with its own measure, and the knee moves to it: 0 mind your p's and q's on 52 LEDs, 1 Sphinx of black quartz, judge my vow. on 60, 2 bob pop bid bud dub on 60, picked because in the stick bob reads pop and pop bob, and in the forme bid, bud and dub read as themselves, 3 The Body of B. Franklin, Printer on 56. Turning it starts the shop over on the new text.\n// Knob 4: Spacing. How a line is filled out to the measure: below 0.25 justified, each 3-em word space topped up with em, en, thin and hair spaces (the opening 0.06); to 0.5 letterspaced, one space between every two letters set as the letters go in and the rest in the word spaces; to 0.75 ragged, quads at the end; above that centred, quads at both ends. The last line is always quadded out. Hair spaces show as brass.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a.map((v, i) => v + (b[i] - v) * t);\nconst hsv = (h, s, v) => [5, 3, 1].map((n) => ((k) => 255 * v * (1 - s * max(0, min(k, 4 - k, 1))))((n + (h - floor(h)) * 6) % 6));\n\n// The face: 8 rows, 2 for ascenders, 4 for the x-height and 2 for\n// descenders; capitals stand on the upper 6. Rows top down, a missing row is\n// blank. b, d, p and q are one bitmap turned and mirrored.\nconst FONT = {\n  a: \",,.###,#..#,#..#,.###\", b: \"#...,#...,###.,#..#,#..#,###.\", c: \",,.##,#..,#..,.##\",\n  d: \"...#,...#,.###,#..#,#..#,.###\", e: \",,.##.,####,#...,.###\", f: \".##,.#.,###,.#.,.#.,.#.\",\n  g: \",,.###,#..#,#..#,.###,...#,.##.\", h: \"#...,#...,###.,#..#,#..#,#..#\", i: \"#,,#,#,#,#\",\n  j: \".#,,.#,.#,.#,.#,.#,#.\", k: \"#..,#..,#.#,##.,#.#,#.#\", l: \"#,#,#,#,#,#\",\n  m: \",,####.,#.#.#,#.#.#,#.#.#\", n: \",,###.,#..#,#..#,#..#\", o: \",,.##.,#..#,#..#,.##.\",\n  p: \",,###.,#..#,#..#,###.,#...,#...\", q: \",,.###,#..#,#..#,.###,...#,...#\", r: \",,#.##,##..,#...,#...\",\n  s: \",,.###,##..,..##,###.\", t: \",.#.,###,.#.,.#.,..#\", u: \",,#..#,#..#,#..#,.##.\",\n  v: \",,#.#,#.#,#.#,.#.\", w: \",,#...#,#.#.#,#.#.#,.#.#.\", x: \",,#..#,.##.,.##.,#..#\",\n  y: \",,#..#,#..#,#..#,.###,...#,.##.\", z: \",,####,..#.,.#..,####\",\n  \"'\": \"#,#\", \",\": \",,,,,#,#\", \".\": \",,,,,#\",\n  B: \"###.,#..#,###.,#..#,#..#,###.\", F: \"###,#..,##.,#..,#..,#..\", P: \"###.,#..#,#..#,###.,#...,#...\",\n  S: \".###,#...,.##.,...#,...#,###.\", T: \"###,.#.,.#.,.#.,.#.,.#.\",\n};\nconst GL = {};\nfor (const ch in FONT) {\n  const rows = FONT[ch].split(\",\"), w = max(...rows.map((r) => r.length)), bits = new Uint8Array(8 * w);\n  rows.forEach((r, y) => [...r].forEach((v, x) => (bits[y * w + x] = v === \"#\")));\n  GL[ch] = { w, bits };\n}\n\n// The body is 10 LEDs, so an em quad is 10 wide; the smaller spaces are its\n// fractions rounded to whole LEDs. A sort is its letter plus one LED of body.\nconst SPW = { em: 10, en: 5, thick: 3, thin: 2, hair: 1 };\nconst QUADS = [\"em\", \"en\", \"thin\", \"hair\"];\nconst LX = 2, BODY = 10, LINES = 3;\nconst STICK = 34, ROLL = 49, FORME = 55, SHEET = 93, PAPER0 = 90;\n\n// Each text with the measure its job is set to, in LEDs.\nconst TEXTS = [\n  [\"mind your p's and q's\", 52],\n  [\"Sphinx of black quartz, judge my vow.\", 60],\n  [\"bob pop bid bud dub\", 60],\n  [\"The Body of B. Franklin, Printer\", 56],\n];\n\n// The case. Lowercase on the left in four bands, each box about as big as\n// its letter is common; capitals on the right in equal boxes. A band gives\n// its rows, keys and inside widths; a divider follows every box.\nconst BANDS = [\n  [1, 4, [\"'\", \",\", \".\", \"k\", \"hair\", \"thin\", \"em\", \"fi\", \"fl\", \"ff\", \"ffi\"], [2, 2, 2, 4, 3, 4, 6, 2, 2, 2, 2]],\n  [6, 12, [\"j\", \"b\", \"c\", \"d\", \"e\", \"i\", \"s\", \"f\", \"g\"], [2, 2, 3, 4, 9, 4, 4, 3, 2]],\n  [14, 20, [\"z\", \"l\", \"m\", \"n\", \"h\", \"o\", \"y\", \"p\", \"w\", \"en\"], [2, 3, 3, 4, 4, 4, 3, 3, 3, 3]],\n  [22, 29, [\"x\", \"q\", \"v\", \"u\", \"t\", \"thick\", \"a\", \"r\"], [2, 2, 3, 3, 6, 6, 6, 6]],\n];\nconst CAPS = [\"1234567\", \"890$&?!\", \"ABCDEFG\", \"HIKLMNO\", \"PQRSTVW\", \"XYZJU;:\"];\nconst CASE_H = 31, CN = W * CASE_H;\n\nconst METAL = [206, 210, 218], WOOD = [150, 96, 48], FLOOR = [16, 10, 7], STEEL = [150, 158, 170], BED = [40, 44, 52];\nconst IRON = [70, 74, 84], FURN = [132, 92, 52], DARK = [18, 18, 22], PAPER = [196, 186, 160];\n// Pieces: body, edge and the shank's three rows; spaces by kind, hair spaces brass.\nconst BODYC = [86, 88, 96], SEAM = [50, 52, 58], SHANK = [[116, 120, 128], [28, 30, 34], [76, 80, 88]];\nconst SPC = { em: [36, 38, 44], en: [36, 38, 44], thick: [54, 56, 62], thin: [54, 56, 62], hair: [176, 132, 52] };\n\nfunction buildCase(S) {\n  const boxes = (S.boxes = []), at = (S.at = {});\n  const add = (key, x0, y0, x1, y1) => {\n    at[key] = boxes.length;\n    boxes.push({ x0, y0, x1, y1, cx: (x0 + x1 - 1) / 2, cy: (y0 + y1) / 2, fill: 0.4 + 0.25 * Math.random(), flash: 0 });\n  };\n  for (const [y0, y1, keys, ws] of BANDS) for (let i = 0, x = 1; i \u003c keys.length; x += ws[i++] + 1) add(keys[i], x, y0, x + ws[i], y1 + 1);\n  CAPS.forEach((row, r) => [...row].forEach((ch, c) => add(/[A-Z]/.test(ch) ? ch : \"c\" + r + c, 43 + 3 * c, 1 + 5 * r, 45 + 3 * c, 5 + 5 * r)));\n  // Each box holds a heap, higher in the middle, so a big box reads as a big mound.\n  S.owner = new Int16Array(CN).fill(-1);\n  S.heap = new Float32Array(CN);\n  boxes.forEach((b, i) => {\n    for (let y = b.y0; y \u003c b.y1; y++)\n      for (let x = b.x0; x \u003c b.x1; x++) {\n        S.owner[y * W + x] = i;\n        S.heap[y * W + x] = cl(1.5 - ((2 * x + 1 - b.x0 - b.x1) / (b.x1 - b.x0 + 1)) ** 2 - ((2 * y + 1 - b.y0 - b.y1) / (b.y1 - b.y0 + 1)) ** 2, 0, 1);\n      }\n  });\n  S.tex = Float32Array.from({ length: CN }, Math.random);\n  S.tone = Float32Array.from({ length: CN }, Math.random);\n}\n\nconst sortOf = (S, ch) => ({ ch, g: GL[ch], w: GL[ch].w + 1, box: S.at[ch] });\nconst spaceOf = (S, k, extra) => ({ sp: k, w: SPW[k], box: S.at[k], extra });\nconst widthOf = (ps) => ps.reduce((s, p) => s + p.w, 0);\nfunction split(n, out, S, extra = true) {\n  for (const k of QUADS) for (; n >= SPW[k]; n -= SPW[k]) out.push(spaceOf(S, k, extra));\n}\n\n// Greedy line breaks with a 3-em word space.\nfunction setText(S) {\n  const [text, M] = TEXTS[S.text];\n  S.M = M;\n  S.P0 = 32 - M / 2;\n  const lines = (S.lines = []);\n  let cur = [], cw = 0;\n  for (const w of text.split(\" \").map((w) => [...w].map((ch) => sortOf(S, ch)))) {\n    if (cur.length && cw + 3 + widthOf(w) > M) [cur, cw] = [(lines.push(cur), []), 0];\n    cw += (cur.length ? 3 : 0) + widthOf(w);\n    cur.push(w);\n  }\n  lines.push(cur);\n}\n\n// The line filled out to the measure by the Spacing knob's method. The last\n// line of a paragraph is never spread; it is quadded out.\nfunction justify(S, line, last) {\n  const mode = last && S.mode \u003c 2 ? 2 : S.mode, gaps = line.length - 1;\n  const slack = S.M - line.reduce((s, w) => s + widthOf(w), 0) - 3 * gaps;\n  const word = new Array(gaps).fill(0), letter = line.map((w) => new Array(w.length).fill(0));\n  let lead = 0, tail = 0;\n  if (mode === 0 && gaps) {\n    // Equal shares; the odd LEDs go first after punctuation, then from the left.\n    const q = floor(slack / gaps), punct = (i) => (/[,.]/.test(line[i].at(-1).ch) ? 1 : 0);\n    let r = slack - q * gaps;\n    word.fill(q);\n    for (const i of [...word.keys()].sort((a, b) => punct(b) - punct(a) || a - b)) if (r > 0) (word[i]++, r--);\n  } else if (mode === 1) {\n    // Letterspacing: the same space between every two letters, set as the\n    // letters are, and what is left in the word spaces.\n    const lg = line.reduce((s, w) => s + w.length - 1, 0), u = lg ? floor(slack / (lg + 2 * gaps)) : 0, r = slack - u * lg;\n    line.forEach((w, wi) => letter[wi].fill(u, 1));\n    for (let i = 0; i \u003c gaps; i++) word[i] = floor(r / gaps) + (i \u003c r % gaps ? 1 : 0);\n    if (!gaps) tail = r;\n  } else if (mode === 3) tail = slack - (lead = floor(slack / 2));\n  else tail = slack;\n  const out = [];\n  split(lead, out, S);\n  line.forEach((w, wi) => {\n    if (wi) {\n      out.push(spaceOf(S, \"thick\", false));\n      split(word[wi - 1], out, S);\n    }\n    w.forEach((p, j) => {\n      split(letter[wi][j], out, S, false);\n      out.push({ ...p });\n    });\n  });\n  split(tail, out, S);\n  return out;\n}\n\n// What a piece shows at column c, row r, the way it prints: 1 body, 2 face,\n// 3 the body's edge, 4 a space, which stands lower than the type.\nfunction cell(p, c, r) {\n  if (p.sp) return 4;\n  if (!c) return 3;\n  return r > 0 && r \u003c 9 && p.g.bits[(r - 1) * p.g.w + c - 1] ? 2 : 1;\n}\n\nfunction layout(ps) {\n  let x = 0;\n  return ps.map((p) => ({ p, x: (x += p.w) - p.w, gone: false }));\n}\n\n// The shop as it opens: the forme full and about to be inked, the last\n// sheet printed, and the first word of the next copy in the stick.\nfunction begin(S) {\n  setText(S);\n  S.just = S.lines.map((l, i) => justify(S, l, i === S.lines.length - 1));\n  S.forme = { lines: S.just.map(layout), phase: \"lock\", t: 0.25, inkY: 0, ink: 0, roll: ROLL };\n  S.sheet = { lines: S.forme.lines, P0: S.P0, x: 0, cut: H, press: -1 };\n  S.fl = [];\n  S.boxes.forEach((b) => (b.flash = 0));\n  newLine(S, 0);\n  const C = S.comp;\n  for (const p of C.ps) {\n    if (p.sp === \"thick\") break;\n    p.on = !p.extra;\n  }\n  targets(C);\n  C.ps.forEach((p) => (p.x = p.tx));\n}\n\nfunction newLine(S, li) {\n  S.comp = { li, ps: S.just[li].map((p) => ({ ...p, on: false, x: LX, tx: LX })), phase: \"set\", t: 0, busy: false };\n}\n\nfunction targets(C) {\n  let x = LX;\n  for (const p of C.ps) x += (p.tx = x, p.on ? p.w : 0);\n}\n\nconst fly = (S, x0, y0, x1, y1, T, col, land, ret) => S.fl.push({ x0, y0, x1, y1, t: 0, T, col, land, ret });\n\n// The compositor: sets the line sort by sort, then the spaces that justify\n// it, waits for the forme and slides the line in.\nfunction stepComp(S, d) {\n  const C = S.comp;\n  C.t -= d;\n  if (C.phase === \"set\" || C.phase === \"just\") {\n    if (C.busy || C.t > 0) return;\n    const p = C.ps.find((q) => !q.on && (C.phase === \"just\" || !q.extra));\n    if (!p) return C.phase === \"set\" ? (C.phase = \"just\") : Object.assign(C, { phase: \"tight\", t: 0.4 });\n    targets(C);\n    const b = S.boxes[p.box];\n    b.flash = 1;\n    b.fill = max(0.2, b.fill - 0.05);\n    C.busy = true;\n    fly(S, b.cx, b.cy, p.tx + p.w / 2, STICK + 4, p.sp ? 0.2 : 0.24, p.sp ? [120, 124, 132] : METAL, () => {\n      p.on = true;\n      targets(C);\n      p.x = p.tx;\n      Object.assign(C, { busy: false, t: 0.05 });\n    });\n  } else if (C.phase === \"tight\") {\n    if (C.t \u003c= 0) C.phase = \"wait\";\n  } else if (C.phase === \"wait\") {\n    if (S.forme.phase === \"fill\" && S.forme.lines.length === C.li) Object.assign(C, { phase: \"move\", t: 0.7, bits: lineBits(C.ps, S.M) });\n  } else if (C.t \u003c= 0) {\n    S.forme.lines.push(layout(C.ps));\n    newLine(S, (C.li + 1) % S.lines.length);\n  }\n}\n\n// A line as print-side codes, M by 10, hair spaces as 5.\nfunction lineBits(list, M) {\n  const bits = new Uint8Array(M * BODY);\n  let x = 0;\n  for (const p of list) {\n    for (let c = 0; c \u003c p.w; c++) for (let r = 0; r \u003c BODY; r++) if (x + c \u003c M) bits[r * M + x + c] = p.sp === \"hair\" ? 5 : cell(p, c, r);\n    x += p.w;\n  }\n  return bits;\n}\n\n// The forme's round, with each step's length at Speed 2.\nconst PH = { lock: 0.35, ink: 1.3, swap: 0.6, press: 0.9, hold: 0.7 };\nconst NEXT = { fill: \"lock\", lock: \"ink\", ink: \"swap\", swap: \"press\", press: \"hold\", hold: \"dist\" };\n\nfunction stepForme(S, d) {\n  const F = S.forme, SH = S.sheet;\n  F.t -= d;\n  const u = 1 - F.t / (PH[F.phase] || 1);\n  if (F.phase === \"ink\") {\n    // The roller runs down over the forme and back to the slab.\n    const bot = FORME + BODY * LINES - 2;\n    F.roll = u \u003c 0.55 ? ROLL + (bot - ROLL) * (u / 0.55) : bot + (ROLL - bot) * ((u - 0.55) / 0.45);\n    F.inkY = max(F.inkY, F.roll + 3);\n    F.ink = 1;\n  } else if (F.phase === \"swap\") {\n    // The last print slides out to the right, a fresh sheet in from the left.\n    SH.x = round(u \u003c 0.5 ? u * 132 : (u - 1) * 132);\n    if (u >= 0.5) SH.lines = null;\n  } else if (F.phase === \"press\") SH.press = SH.cut = PAPER0 - 3 + (H + 3 - PAPER0) * u;\n  else if (F.phase === \"dist\")\n    // Distribution: each piece goes back to its own box.\n    for (; F.t \u003c= 0; F.t += 0.045) {\n      let q = null, k = 0;\n      for (; k \u003c F.lines.length && !q; k++) q = F.lines[k].find((e) => !e.gone);\n      if (!q) {\n        if (!S.fl.some((f) => f.ret)) Object.assign(F, { lines: [], inkY: 0, ink: 0, phase: \"fill\", t: 0 });\n        break;\n      }\n      q.gone = true;\n      const b = S.boxes[q.p.box];\n      const back = () => {\n        b.flash = 0.7;\n        b.fill = min(0.95, b.fill + 0.05);\n      };\n      fly(S, 63 - S.P0 - q.x - q.p.w / 2, FORME + BODY * (k - 1) + 4, b.cx, b.cy, 0.32, q.p.sp ? [90, 94, 100] : mix(METAL, S.ink, 0.6), back, true);\n    }\n  if (F.phase === \"fill\" ? F.lines.length >= S.lines.length : F.phase !== \"dist\" && F.t \u003c= 0) {\n    if (F.phase === \"ink\") F.roll = ROLL;\n    if (F.phase === \"swap\") Object.assign(SH, { x: 0, lines: F.lines, P0: S.P0, cut: PAPER0 - 3 });\n    if (F.phase === \"press\") {\n      Object.assign(SH, { cut: H, press: -1 });\n      F.ink = 0.55;\n    }\n    F.phase = NEXT[F.phase];\n    F.t = PH[F.phase] || 0;\n  }\n}\n\nfunction put(F, x, y, c, a = 1) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  F[o] += (c[0] - F[o]) * a;\n  F[o + 1] += (c[1] - F[o + 1]) * a;\n  F[o + 2] += (c[2] - F[o + 2]) * a;\n}\n\nexport function setup(params) {\n  const S = (params.s = { text: -1, mode: -1, F: new Float32Array(N * 3), base: new Float32Array(N * 3) });\n  buildCase(S);\n  const B = S.base, g = (c, k) => c.map((v) => v * k);\n  // Case wood with a grain, the stick, the chase full of furniture.\n  for (let i = 0; i \u003c CN; i++) put(B, i % W, floor(i / W), S.owner[i] >= 0 ? FLOOR : g(WOOD, 0.8 + 0.25 * S.tone[i - (i % W) + (((i % W) * 7) % W)]));\n  for (let x = 0; x \u003c W; x++) {\n    put(B, x, STICK - 1, STEEL);\n    put(B, x, STICK + BODY + 3, g(STEEL, 0.85));\n    for (let y = STICK; y \u003c STICK + BODY + 3; y++) put(B, x, y, x \u003c LX ? STEEL : BED);\n  }\n  const top = FORME - 2, bot = FORME + BODY * LINES + 1;\n  for (let y = top; y \u003c= bot; y++)\n    for (let x = 0; x \u003c W; x++) put(B, x, y, y === top || y === bot || !x || x === W - 1 ? IRON : g(FURN, 0.75 + 0.2 * (((x * 5 + y * 11) % 7) / 7)));\n  S.paper = new Float32Array(W * (H - PAPER0));\n  for (let i = 0; i \u003c S.paper.length; i++) S.paper[i] = 1 - 0.12 * (floor(i / W) / (H - PAPER0)) - 0.05 * (abs((i % W) - 31.5) / 31.5);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0] || 0, 0, 1);\n  S.sp = cl(k[1] ?? 2, 0.2, 3) / 2;\n  S.ink = hsv(0.6 + S.hue, 0.85, 1);\n  const text = round(cl(k[2] || 0, 0, 3)), mode = min(3, floor(cl(k[3] ?? 0.06, 0, 1) * 4));\n  if (text !== S.text || mode !== S.mode) {\n    Object.assign(S, { text, mode });\n    begin(S);\n  }\n  const d = dt * S.sp;\n  for (const f of S.fl) if ((f.t += d) >= f.T && !f.done) (f.done = true), f.land();\n  S.fl = S.fl.filter((f) => !f.done);\n  stepComp(S, d);\n  stepForme(S, d);\n  for (const p of S.comp.ps) if (p.on) p.x += (p.tx - p.x) * min(1, d * 14);\n  for (const b of S.boxes) b.flash = max(0, b.flash - dt * 3);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.comp) return;\n  const F = S.F, ink = S.ink, FL = S.forme, SH = S.sheet, C = S.comp, M = S.M, P0 = S.P0;\n  F.set(S.base);\n  const colOf = (p, code, face) => (code === 2 ? face : code === 1 ? BODYC : code === 3 ? SEAM : SPC[p.sp]);\n\n  // The case: each box a heap of sorts as full as it is, lit when touched.\n  for (let i = 0; i \u003c CN; i++) {\n    const b = S.boxes[S.owner[i]];\n    if (!b) continue;\n    const h = S.heap[i], v = (40 + 90 * S.tone[i]) * (0.55 + 0.45 * h);\n    if (S.tex[i] \u003c b.fill * h) F.set([v, v * 1.02, v * 1.1], i * 3);\n    if (b.flash > 0) put(F, i % W, floor(i / W), [255, 226, 150], b.flash * 0.7);\n  }\n\n  // The knee, set to the measure, lights when the line is tight.\n  for (let y = STICK - 1; y \u003c STICK + BODY + 4; y++) for (let x = LX + M; x \u003c LX + M + 2; x++) put(F, x, y, C.phase === \"tight\" ? [240, 240, 228] : STEEL);\n  // Sorts in the stick, seen from the compositor's side: the line reads left\n  // to right and every face is upside down, the mirror of the print turned\n  // round. Below each face its shank, nick up, the nicks in one line.\n  if (C.phase !== \"move\")\n    for (const p of C.ps) {\n      if (!p.on) continue;\n      for (let c = 0, x = round(p.x); c \u003c p.w; c++, x++) {\n        if (x \u003c LX || x >= LX + M) continue;\n        for (let r = 0; r \u003c BODY; r++) put(F, x, STICK + r, colOf(p, cell(p, c, BODY - 1 - r), METAL));\n        for (let j = 0; j \u003c 3; j++) put(F, x, STICK + BODY + j, p.sp ? SPC[p.sp] : c ? SHANK[j] : SEAM, p.sp ? 1 - 0.1 * j : 1);\n      }\n    }\n\n  // The ink slab, and the roller resting on it or running over the forme.\n  for (let y = ROLL - 1; y \u003c ROLL + 4; y++) for (let x = 0; x \u003c W; x++) put(F, x, y, mix([0, 0, 0], ink, 0.42 + 0.1 * ((x * 3 + y * 5) % 4)));\n  const ry = round(FL.roll);\n  for (let x = 0; x \u003c W; x++) for (let j = 0; j \u003c 3; j++) put(F, x, ry + j, x \u003c 2 || x > 61 ? STEEL : mix([0, 0, 0], ink, 0.95 - 0.25 * j));\n  if (FL.phase === \"ink\") for (let x = 0; x \u003c W; x++) put(F, x, ry - 1, IRON);\n\n  // The forme: the lines seen from the face, mirrored and reading right to\n  // left, inked where the roller has passed. Slots past the text stay\n  // furniture; quoins at the foot open when it is locked.\n  const face = mix(METAL, ink, FL.ink);\n  for (let k = 0; k \u003c S.lines.length; k++) {\n    for (let y = FORME + BODY * k; y \u003c FORME + BODY * (k + 1); y++) for (let x = P0; x \u003c P0 + M; x++) put(F, x, y, DARK);\n    for (const q of FL.lines[k] || [])\n      if (!q.gone)\n        for (let c = 0; c \u003c q.p.w; c++)\n          for (let r = 0, y = FORME + BODY * k; r \u003c BODY; r++, y++) put(F, 63 - (P0 + q.x + c), y, colOf(q.p, cell(q.p, c, r), y \u003c FL.inkY ? face : METAL));\n  }\n  const locked = FL.phase !== \"fill\" && FL.phase !== \"dist\";\n  for (const qx of [18, 40]) for (let i = 0; i \u003c (locked ? 6 : 4); i++) put(F, qx + i, FORME + BODY * LINES, locked ? [200, 204, 210] : [110, 114, 120]);\n\n  // The line on its way from stick to forme turns over: upside down to the\n  // right way up, then mirrored, so for an instant it reads as it will print.\n  if (C.phase === \"move\") {\n    const s = cl(1 - C.t / 0.7, 0, 1), sy = cos(PI * cl(2 * s, 0, 1)), sx = cos(PI * cl(2 * s - 1, 0, 1));\n    const cx = LX + M / 2 + (32 - LX - M / 2) * s, cy = STICK + 5 + (FORME + BODY * C.li - STICK) * s;\n    const hw = (M / 2) * abs(sx), hh = (BODY / 2) * abs(sy), lit = 0.6 + 0.4 * abs(sx * sy);\n    const pal = [null, BODYC, METAL, SEAM, SPC.thick, SPC.hair].map((c) => c && c.map((v) => v * lit));\n    for (let y = floor(cy - hh); y \u003c cy + hh; y++)\n      for (let x = floor(cx - hw); x \u003c cx + hw; x++) {\n        const u = floor((x + 0.5 - cx) / (sx || 1e-3) + M / 2), v = floor((y + 0.5 - cy) / (sy || 1e-3) + BODY / 2);\n        const code = u >= 0 && u \u003c M && v >= 0 && v \u003c BODY ? C.bits[(BODY - 1 - v) * M + u] : 0;\n        if (code) put(F, x, y, pal[code]);\n      }\n  }\n\n  // The sheet, sliding in fresh before each impression; it takes the print\n  // as the cylinder passes, and only here does the line read right.\n  const tone = mix(PAPER, hsv(0.6 + S.hue, 0.95, 0.8), 0.94);\n  for (let i = 0; i \u003c S.paper.length; i++) {\n    const x = i % W, X = x + SH.x, g = S.paper[i], o = (PAPER0 * W + i - x + X) * 3;\n    if (!x || x === W - 1 || X \u003c 0 || X >= W) continue;\n    F[o] = PAPER[0] * g;\n    F[o + 1] = PAPER[1] * g;\n    F[o + 2] = PAPER[2] * g;\n  }\n  if (SH.lines)\n    SH.lines.forEach((line, k) => {\n      for (const q of line)\n        for (let c = 1; c \u003c q.p.w && !q.p.sp; c++)\n          for (let r = 1, y = SHEET + BODY * k + 1; r \u003c 9; r++, y++) if (y \u003c SH.cut && cell(q.p, c, r) === 2) put(F, SH.P0 + q.x + c + SH.x, y, tone);\n    });\n  if (SH.press >= 0) for (let x = 0; x \u003c W; x++) for (let j = 0; j \u003c 3; j++) put(F, x, round(SH.press) + j, [210 - 40 * j, 216 - 40 * j, 224 - 40 * j]);\n\n  // Sorts in flight, with a short trail.\n  for (const f of S.fl) {\n    const u = cl(f.t / f.T, 0, 1), e = u * u * (3 - 2 * u);\n    for (const [back, a] of [[0.08, 0.35], [0, 1]]) {\n      const ue = max(0, e - back);\n      const x = round(f.x0 + (f.x1 - f.x0) * ue), y = round(f.y0 + (f.y1 - f.y0) * ue - 6 * sin(PI * ue));\n      for (let j = 0; j \u003c 4; j++) put(F, x + (j & 1), y + (j >> 1), f.col, j > 1 ? a * 0.8 : a);\n    }\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, F[o], F[o + 1], F[o + 2]);\n}\n","delaunay-flips":"// ===== Patternflow pattern =====\n// Title:   Delaunay Flips\n// Family:  cells\n// Idea:    Points inside a rounded hull start in a bad triangulation, a fan from one corner or a sweep, and Lawson's flips take the worst illegal edge, draw the circle that has a fourth point inside it and swap the edge for the other diagonal, a dozen a second, until no triangle's circle holds a point, every triangle filled by its smallest angle from magenta slivers to teal near-equilateral ones; then the points drift and the flips keep coming.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lawson flips (Charles L. Lawson, 1977) toward the Delaunay triangulation (Boris Delaunay, 1934), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Circles=0..1\n//\n// Knob 1: Hue. Turns the colours round a wheel that skips red, orange and yellow. At 0 slivers, illegal edges and circles with a point inside are magenta, near-equilateral triangles, legal edges and empty circles teal, and the triangles between go violet and blue; at 0.25 slivers are green and good triangles blue, at 0.5 cyan and magenta, at 0.75 blue and green.\n// Knob 2: Speed. Flips 6 times Speed a second for 43 points and in proportion for more: at 2 the opening fan of 43 points needs 76 flips and is Delaunay 6.4 s after it is drawn; at 0.2 one flip every 0.83 s, each circle in plain view. In the drift that follows the points move 1.4 times Speed LEDs a second, less as they crowd, so 113 points move 0.62 of that.\n// Knob 3: Points. 30 to 90 points scattered inside, plus 13 to 23 fixed on the hull, so 43 points and 71 triangles at 30 and 113 points and 201 triangles at 90. Each whole step scatters a new set; the opening fan of 113 points took 324 flips, Delaunay 10.3 s after it was drawn at Speed 2.\n// Knob 4: Circles. Up to 0.08 only the circle under test and the fading circles of the last flips. Above it a growing share of all the triangles' circumcircles, all of them at 1: magenta while some point lies inside, teal when empty, so the bad start is a tangle of magenta circles and lines and the end is teal.\n// Buttons: K1 tap scatters a new set in the next bad triangulation.\n\n// Delaunay (1934): a triangulation of a point set where no point lies inside\n// any triangle's circumcircle. Lawson (1977): an edge shared by triangles\n// abc and dcb is illegal when d lies inside abc's circle, which is when the\n// angles at a and d add up past pi. Swapping it for ad raises the smallest\n// of the six angles, and flipping illegal edges in any order ends at the\n// Delaunay triangulation. The hull points never move, so the hull stays\n// convex and its edges are never flipped.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sg = (v) => (v \u003c 0 ? -1 : 1);\nconst frac = (v) => v - floor(v);\n// A colour wheel that skips red, orange and yellow (hue 0.98 round to 0.27),\n// which go maroon, brown and olive at the dim levels of the fills.\nconst wheel = (p) => 0.27 + 0.71 * p;\n\n// The hull: a superellipse |x/a|^3 + |y/b|^3 = 1 round the panel's middle,\n// of area AREA. Interior points keep 5 LEDs inside it.\nconst CX = 31.5, CY = 63.5, HA = 30.6, HB = 62.6, SP = 3, AREA = 6769;\nconst NMAX = 90 + 32, TMAX = 2 * NMAX;\nconst BUILD = 0.9, PROOF = 1.6, DRIFT = 10, ICEPS = 1e-6;\nconst inner = (x, y) => abs((x - CX) / (HA - 5)) ** SP + abs((y - CY) / (HB - 5)) ** SP \u003c 1;\n\nfunction hsv(h, s, v, out) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Predicates. Every stored triangle has orient > 0. ----\nconst orient = (P, a, b, c) =>\n  (P[2 * b] - P[2 * a]) * (P[2 * c + 1] - P[2 * a + 1]) - (P[2 * b + 1] - P[2 * a + 1]) * (P[2 * c] - P[2 * a]);\n// > 0 when d lies inside the circle through a, b, c (orient(a, b, c) > 0).\nfunction incircle(P, a, b, c, d) {\n  const dx = P[2 * d], dy = P[2 * d + 1];\n  const ax = P[2 * a] - dx, ay = P[2 * a + 1] - dy, bx = P[2 * b] - dx, by = P[2 * b + 1] - dy;\n  const cx = P[2 * c] - dx, cy = P[2 * c + 1] - dy;\n  const a2 = ax * ax + ay * ay, b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  return ax * (by * c2 - b2 * cy) - ay * (bx * c2 - b2 * cx) + a2 * (bx * cy - by * cx);\n}\n// The angle at a in the triangle a, b, c.\nfunction angle(P, a, b, c) {\n  const ux = P[2 * b] - P[2 * a], uy = P[2 * b + 1] - P[2 * a + 1], vx = P[2 * c] - P[2 * a], vy = P[2 * c + 1] - P[2 * a + 1];\n  return atan2(abs(ux * vy - uy * vx), ux * vx + uy * vy);\n}\n// The circle through a, b, c: centre x, centre y, radius.\nfunction circum(P, a, b, c, out) {\n  const ax = P[2 * a], ay = P[2 * a + 1];\n  const bx = P[2 * b] - ax, by = P[2 * b + 1] - ay, cx = P[2 * c] - ax, cy = P[2 * c + 1] - ay;\n  const d = 2 * (bx * cy - by * cx), b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  const ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d;\n  out[0] = ax + ux;\n  out[1] = ay + uy;\n  out[2] = sqrt(ux * ux + uy * uy);\n}\n\n// ---- A new point set: the hull points first, in order round it. ----\nfunction scatter(S) {\n  const P = S.P, n = S.n, nh = (S.nh = 8 + round(n / 6));\n  // Hull points evenly by arc length.\n  const M = 720, xs = [], ys = [], L = [0];\n  for (let i = 0; i \u003c= M; i++) {\n    const th = (i / M) * 2 * PI, c = cos(th), s = sin(th);\n    xs.push(CX + HA * sg(c) * abs(c) ** (2 / SP));\n    ys.push(CY + HB * sg(s) * abs(s) ** (2 / SP));\n    if (i) L.push(L[i - 1] + sqrt((xs[i] - xs[i - 1]) ** 2 + (ys[i] - ys[i - 1]) ** 2));\n  }\n  const off = Math.random();\n  for (let k = 0, j = 0; k \u003c nh; k++) {\n    const at = ((k + off) / nh) * L[M];\n    while (j \u003c M - 1 && L[j + 1] \u003c at) j++;\n    const f = (at - L[j]) / (L[j + 1] - L[j]);\n    P[2 * k] = xs[j] + (xs[j + 1] - xs[j]) * f;\n    P[2 * k + 1] = ys[j] + (ys[j + 1] - ys[j]) * f;\n  }\n  // Interior points by dart throwing, no two closer than dmin.\n  let dmin = (S.dmin = 0.72 * sqrt(AREA / (n + nh))), np = nh, tries = 0;\n  while (np \u003c nh + n) {\n    const x = 1 + Math.random() * 62, y = 1 + Math.random() * 126;\n    if (++tries > 3000) (dmin *= 0.9), (tries = 0);\n    if (!inner(x, y)) continue;\n    let ok = true;\n    for (let j = 0; j \u003c np && ok; j++) ok = (P[2 * j] - x) ** 2 + (P[2 * j + 1] - y) ** 2 >= dmin * dmin;\n    if (!ok) continue;\n    P[2 * np] = x;\n    P[2 * np + 1] = y;\n    S.th[np++] = Math.random() * 2 * PI;\n  }\n  S.np = np;\n}\n\n// ---- Bad triangulations, as flat lists of triangles. ----\n// A fan from hull point pv: the others by angle round it, a wedge between\n// each two neighbours, then a Graham scan along the fan's rim closes the\n// pockets between the rim and the hull.\nfunction fan(S, pv) {\n  const P = S.P, ids = [], tris = [];\n  const d2 = (i) => (P[2 * i] - P[2 * pv]) ** 2 + (P[2 * i + 1] - P[2 * pv + 1]) ** 2;\n  for (let i = 0; i \u003c S.np; i++) if (i !== pv) ids.push(i);\n  ids.sort((p, q) => -orient(P, pv, p, q) || d2(p) - d2(q));\n  for (let k = 0; k + 1 \u003c ids.length; k++) tris.push(pv, ids[k], ids[k + 1]);\n  const st = [ids[0], ids[1]];\n  for (let k = 2; k \u003c ids.length; k++) {\n    const q = ids[k];\n    for (let m = st.length; m >= 2 && orient(P, st[m - 2], st[m - 1], q) \u003c 0; m--) tris.push(st[m - 2], q, st.pop());\n    st.push(q);\n  }\n  return tris;\n}\n// A sweep: the points by distance from (qx, qy). Each new one lies outside\n// the hull of those before it and is joined to every hull edge it sees.\nfunction sweep(S, qx, qy) {\n  const P = S.P, ids = [];\n  const d2 = (i) => (P[2 * i] - qx) ** 2 + (P[2 * i + 1] - qy) ** 2;\n  for (let i = 0; i \u003c S.np; i++) ids.push(i);\n  ids.sort((p, q) => d2(p) - d2(q));\n  let hull = orient(P, ids[0], ids[1], ids[2]) > 0 ? ids.slice(0, 3) : [ids[0], ids[2], ids[1]];\n  const tris = hull.slice();\n  for (let k = 3; k \u003c ids.length; k++) {\n    const q = ids[k], m = hull.length, vis = hull.map((h, j) => orient(P, h, hull[(j + 1) % m], q) \u003c 0);\n    let s = 0, c = 0;\n    while (s \u003c m && !(vis[s] && !vis[(s + m - 1) % m])) s++;\n    if (s === m) continue;\n    for (; c \u003c m && vis[(s + c) % m]; c++) tris.push(hull[(s + c + 1) % m], hull[(s + c) % m], q);\n    const next = [hull[s], q];\n    for (let j = (s + c) % m; j !== s; j = (j + 1) % m) next.push(hull[j]);\n    hull = next;\n  }\n  return tris;\n}\n\n// Store the triangles and find each one's neighbours. Nb[3t + i] is the\n// triangle across t's side opposite its vertex i, or -1 on the hull.\nfunction link(S, tris) {\n  const V = S.V, Nb = S.Nb, T = (S.T = tris.length / 3), seen = new Map();\n  for (let i = 0; i \u003c tris.length; i++) V[i] = tris[i];\n  Nb.fill(-1);\n  for (let e = 0; e \u003c 3 * T; e++) {\n    const t = (e / 3) | 0, b = V[3 * t + ((e + 1) % 3)], c = V[3 * t + ((e + 2) % 3)];\n    const key = min(b, c) * 1024 + max(b, c), o = seen.get(key);\n    if (o === undefined) seen.set(key, e);\n    else (Nb[e] = (o / 3) | 0), (Nb[o] = t);\n  }\n}\n\n// Fans from the corners top left and bottom right take turns with sweeps\n// from the middle and from far above (which goes row by row).\nfunction restart(S) {\n  scatter(S);\n  const P = S.P, kind = S.cycle % 4;\n  if (kind % 2) link(S, kind === 1 ? sweep(S, CX, CY) : sweep(S, CX, -4000));\n  else {\n    const s = kind ? 1 : -1;\n    let pv = 0;\n    for (let i = 1; i \u003c S.nh; i++) if (s * ((P[2 * i] - P[2 * pv]) / HA + (P[2 * i + 1] - P[2 * pv + 1]) / HB) > 0) pv = i;\n    link(S, fan(S, pv));\n  }\n  Object.assign(S, { phase: 0, pt: 0, prog: 0, cand: -1, built: 0, flips: 0 });\n  S.rec.length = 0;\n}\n\n// ---- Edges and flips. Edge e = 3t + i is t's side opposite vertex i. ----\n// Into q: a (t's vertex i), b, c (the shared side), d across it, u, and\n// d's place j in u.\nfunction quad(S, e, q) {\n  const V = S.V, t = (e / 3) | 0, i = e % 3, u = S.Nb[e];\n  if (u \u003c 0) return false;\n  let j = 0;\n  while (S.Nb[3 * u + j] !== t) j++;\n  q[0] = V[e];\n  q[1] = V[3 * t + ((i + 1) % 3)];\n  q[2] = V[3 * t + ((i + 2) % 3)];\n  q[3] = V[3 * u + j];\n  q[4] = u;\n  q[5] = j;\n  return true;\n}\nfunction illegal(S, e) {\n  const q = S.q, P = S.P;\n  if (!quad(S, e, q)) return false;\n  const [a, b, c, d] = q;\n  return incircle(P, a, b, c, d) > ICEPS && orient(P, a, b, d) > 0 && orient(P, d, c, a) > 0;\n}\n// The illegal edge whose two opposite angles add up to the most.\nfunction pick(S) {\n  const P = S.P, q = S.q;\n  let best = -1, score = PI;\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    if (S.Nb[e] \u003c ((e / 3) | 0) || !illegal(S, e)) continue;\n    const s = angle(P, q[0], q[1], q[2]) + angle(P, q[3], q[2], q[1]);\n    if (s > score) (score = s), (best = e);\n  }\n  return best;\n}\n// t = a b c and u = d c b become t = a b d and u = d c a.\nfunction flip(S, e) {\n  const V = S.V, Nb = S.Nb, q = S.q;\n  quad(S, e, q);\n  const [a, b, c, d, u, j] = q, t = (e / 3) | 0, i = e % 3;\n  const nca = Nb[3 * t + ((i + 1) % 3)], nab = Nb[3 * t + ((i + 2) % 3)];\n  const nbd = Nb[3 * u + ((j + 1) % 3)], ndc = Nb[3 * u + ((j + 2) % 3)];\n  circum(S.P, a, b, c, S.cc);\n  S.rec.push({ a, d, b, c, t, u, at: S.t, cx: S.cc[0], cy: S.cc[1], r: S.cc[2] });\n  if (S.rec.length > 24) S.rec.shift();\n  V.set([a, b, d], 3 * t);\n  Nb.set([nbd, u, nab], 3 * t);\n  V.set([d, c, a], 3 * u);\n  Nb.set([nca, t, ndc], 3 * u);\n  for (let k = 0; k \u003c 3; k++) {\n    if (nbd >= 0 && Nb[3 * nbd + k] === u) Nb[3 * nbd + k] = t;\n    if (nca >= 0 && Nb[3 * nca + k] === t) Nb[3 * nca + k] = u;\n  }\n  S.flips++;\n}\n\n// ---- Drift: the interior points wander and push off close neighbours; a\n// step that would fold a triangle over is taken back. ----\nfunction drift(S, d) {\n  const P = S.P, Q = S.Q, V = S.V, v0 = 1.4 * S.speed * sqrt(43 / S.np), nh = S.nh, dm = S.dmin * 0.8;\n  Q.set(P);\n  for (let i = nh; i \u003c S.np; i++) {\n    const x = P[2 * i], y = P[2 * i + 1];\n    let th = S.th[i] + (Math.random() - 0.5) * 5 * sqrt(d);\n    if (!inner(x, y)) th = atan2(CY - y, CX - x) + Math.random() - 0.5;\n    S.th[i] = th;\n    Q[2 * i] += cos(th) * v0 * d;\n    Q[2 * i + 1] += sin(th) * v0 * d;\n  }\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    const t = (e / 3) | 0;\n    if (S.Nb[e] \u003c= t) continue;\n    const a = V[3 * t + ((e + 1) % 3)], b = V[3 * t + ((e + 2) % 3)];\n    const ex = P[2 * b] - P[2 * a], ey = P[2 * b + 1] - P[2 * a + 1], l = sqrt(ex * ex + ey * ey);\n    if (l >= dm || l \u003c 1e-6) continue;\n    const f = ((dm - l) / l) * 0.6 * d * S.speed;\n    if (a >= nh) (Q[2 * a] -= ex * f), (Q[2 * a + 1] -= ey * f);\n    if (b >= nh) (Q[2 * b] += ex * f), (Q[2 * b + 1] += ey * f);\n  }\n  for (let pass = 0, bad = true; bad; pass++) {\n    bad = false;\n    if (pass === 6) Q.set(P);\n    else\n      for (let t = 0; t \u003c S.T; t++) {\n        if (orient(Q, V[3 * t], V[3 * t + 1], V[3 * t + 2]) > 0.4) continue;\n        for (let k = 3 * t; k \u003c 3 * t + 3; k++) (Q[2 * V[k]] = P[2 * V[k]]), (Q[2 * V[k] + 1] = P[2 * V[k] + 1]);\n        bad = true;\n      }\n  }\n  P.set(Q);\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, circ: 0.06, n: 0, nh: 0, np: 0, cycle: 0, dmin: 8, btn: false,\n    P: new Float64Array(2 * NMAX), Q: new Float64Array(2 * NMAX), th: new Float64Array(NMAX),\n    V: new Int32Array(3 * TMAX), Nb: new Int32Array(3 * TMAX), T: 0,\n    phase: 0, pt: 0, prog: 0, cand: -1, built: 0, flips: 0, rec: [], q: [0, 0, 0, 0, 0, 0],\n    acc: new Float32Array(W * H * 3), fl: new Float32Array(TMAX), c: [0, 0, 0], cc: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// Phases: 0 the bad triangulation drawn in, 1 flipping, 2 every circle\n// shown empty, 3 drifting with flips, then a new set.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 30, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  S.circ = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 30, 90)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && S.n) S.cycle++, restart(S);\n  S.btn = btn;\n  if (n !== S.n) (S.n = n), restart(S);\n  S.t += d;\n  S.pt += d;\n  if (S.phase === 0) {\n    S.built = min(S.T, floor((S.T * S.pt) / BUILD));\n    if (S.pt >= BUILD) (S.phase = 1), (S.pt = 0), (S.built = S.T);\n    return;\n  }\n  if (S.phase === 2) {\n    if (S.pt >= PROOF) (S.phase = 3), (S.pt = 0);\n    return;\n  }\n  if (S.phase === 3) {\n    if (S.pt >= DRIFT) return S.cycle++, restart(S);\n    drift(S, d);\n  }\n  if (S.cand >= 0 && !illegal(S, S.cand)) S.cand = -1;\n  if (S.cand \u003c 0) (S.cand = pick(S)), (S.prog = 0);\n  if (S.cand >= 0) S.prog += (6 * S.speed * S.np * d) / 43;\n  for (; S.prog >= 1 && S.cand >= 0; S.prog--) flip(S, S.cand), (S.cand = pick(S));\n  if (S.cand \u003c 0) {\n    S.prog = 0;\n    if (S.phase === 1) (S.phase = 2), (S.pt = 0);\n  }\n}\n\n// ---- Drawing into acc, a float RGB buffer. ----\nfunction put(acc, x, y, c, w, sum) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  for (let i = 0; i \u003c 3; i++) acc[k + i] = sum ? acc[k + i] + c[i] * w : max(acc[k + i], c[i] * w);\n}\n// A line covering two LEDs across it, in proportion (Wu's way).\nfunction line(acc, x0, y0, x1, y1, c, w) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0;\n  for (let x = max(0, ceil(x0)); x \u003c= min(st ? H - 1 : W - 1, floor(x1)); x++) {\n    const y = y0 + (x - x0) * s, iy = floor(y), f = y - iy;\n    if (st) put(acc, iy, x, c, w * (1 - f)), put(acc, iy + 1, x, c, w * f);\n    else put(acc, x, iy, c, w * (1 - f)), put(acc, x, iy + 1, c, w * f);\n  }\n}\n// A circle: by rows where it runs steep, by columns where it runs flat.\nfunction ring(acc, cx, cy, r, c, w) {\n  if (!(r > 0.5 && r \u003c 1e5)) return;\n  const h = r * 0.7072;\n  for (let y = max(0, ceil(cy - h)); y \u003c= min(H - 1, floor(cy + h)); y++) {\n    const dx = sqrt(max(0, r * r - (y - cy) ** 2));\n    for (const x of [cx - dx, cx + dx]) {\n      const ix = floor(x), f = x - ix;\n      put(acc, ix, y, c, w * (1 - f), 1), put(acc, ix + 1, y, c, w * f, 1);\n    }\n  }\n  for (let x = max(0, ceil(cx - h)); x \u003c= min(W - 1, floor(cx + h)); x++) {\n    const dy = sqrt(max(0, r * r - (x - cx) ** 2));\n    for (const y of [cy - dy, cy + dy]) {\n      const iy = floor(y), f = y - iy;\n      put(acc, x, iy, c, w * (1 - f), 1), put(acc, x, iy + 1, c, w * f, 1);\n    }\n  }\n}\n// Triangle t filled by rows through the LED centres.\nfunction fill(S, t, c) {\n  const P = S.P, V = S.V, acc = S.acc, xs = [], ys = [];\n  for (let k = 0; k \u003c 3; k++) xs.push(P[2 * V[3 * t + k]]), ys.push(P[2 * V[3 * t + k] + 1]);\n  for (let y = max(0, ceil(min(...ys))); y \u003c= min(H - 1, floor(max(...ys))); y++) {\n    let lo = W, hi = -1;\n    for (let e = 0; e \u003c 3; e++) {\n      const ya = ys[e], yb = ys[(e + 1) % 3];\n      if ((ya - y) * (yb - y) > 0 || ya === yb) continue;\n      const x = xs[e] + ((y - ya) * (xs[(e + 1) % 3] - xs[e])) / (yb - ya);\n      (lo = min(lo, x)), (hi = max(hi, x));\n    }\n    for (let x = max(0, ceil(lo)); x \u003c= min(W - 1, floor(hi)); x++) acc.set(c, (y * W + x) * 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const P = S.P, V = S.V, Nb = S.Nb, acc = S.acc, c = S.c, cc = S.cc, q = S.q, fl = S.fl;\n  const pw = frac(0.831 + S.hue), pc = frac(0.324 + S.hue), hw = wheel(pw), hc = wheel(pc);\n  const built = S.phase === 0 ? S.built : S.T;\n  acc.fill(0);\n  // The two triangles a flip has just made light up for a moment.\n  fl.fill(0);\n  for (const r of S.rec) fl[r.t] = fl[r.u] = max(fl[r.t], exp(-(S.t - r.at) / 0.3));\n  // Each triangle by its smallest angle m: below 10 degrees bright in the\n  // sliver colour, from 50 degrees dim in the near-equilateral one.\n  for (let t = 0; t \u003c built; t++) {\n    const a = V[3 * t], b = V[3 * t + 1], d = V[3 * t + 2];\n    const m = min(angle(P, a, b, d), angle(P, b, d, a), angle(P, d, a, b)), u = cl(m / 0.87, 0, 1);\n    hsv(wheel(pw + (pc - pw) * u), 0.8, 0.2 + 0.36 * (1 - u) * (1 - u), c);\n    for (let i = 0; i \u003c 3; i++) c[i] += fl[t] * 0.35;\n    fill(S, t, c);\n  }\n  // Edges: legal ones pale, illegal ones in the sliver colour, the hull dim.\n  for (let e = 0; e \u003c 3 * built; e++) {\n    const t = (e / 3) | 0, u = Nb[e];\n    if (u >= 0 && u \u003c t) continue;\n    const a = V[3 * t + ((e + 1) % 3)], b = V[3 * t + ((e + 2) % 3)];\n    if (u \u003c 0) hsv(hc, 0.4, 0.4, c);\n    else if (illegal(S, e)) hsv(hw, 0.55, 0.85, c);\n    else hsv(hc, 0.2, 0.32, c);\n    line(acc, P[2 * a], P[2 * a + 1], P[2 * b], P[2 * b + 1], c, 1);\n  }\n  // The circumcircles the Circles knob asks for.\n  const show = (S.circ - 0.08) / 0.92, dim = min(1, sqrt(71 / S.T));\n  for (let t = 0; t \u003c S.T && show > 0 && S.phase; t++) {\n    const w = dim * cl((show - frac(t * 0.618034 + 0.13)) / 0.04, 0, 1);\n    if (w \u003c= 0) continue;\n    const a = V[3 * t], b = V[3 * t + 1], d = V[3 * t + 2];\n    let hit = false;\n    for (let p = 0; p \u003c S.np && !hit; p++) hit = p !== a && p !== b && p !== d && incircle(P, a, b, d, p) > ICEPS;\n    circum(P, a, b, d, cc);\n    hsv(hit ? hw : hc, hit ? 0.5 : 0.45, hit ? 0.36 : 0.3, c);\n    ring(acc, cc[0], cc[1], cc[2], c, w);\n  }\n  // The Delaunay moment: every circle at once, every one of them empty.\n  if (S.phase === 2) {\n    hsv(hc, 0.4, 0.45 * sin((PI * S.pt) / PROOF) ** 2, c);\n    for (let t = 0; t \u003c S.T; t++) {\n      circum(P, V[3 * t], V[3 * t + 1], V[3 * t + 2], cc);\n      ring(acc, cc[0], cc[1], cc[2], c, 1);\n    }\n  }\n  // Flips just made: the old edge and its circle fade, the new edge flashes.\n  for (const r of S.rec) {\n    const age = S.t - r.at;\n    if (age > 1.5) continue;\n    hsv(hw, 0.5, 1, c);\n    line(acc, P[2 * r.b], P[2 * r.b + 1], P[2 * r.c], P[2 * r.c + 1], c, exp(-age / 0.25));\n    ring(acc, r.cx, r.cy, r.r, c, 0.45 * exp(-age / 0.3));\n    line(acc, P[2 * r.a], P[2 * r.a + 1], P[2 * r.d], P[2 * r.d + 1], [1, 1, 1], exp(-age / 0.45));\n  }\n  // The edge under test, its circle brightening toward the flip, and the\n  // point inside that circle.\n  if (S.cand >= 0 && quad(S, S.cand, q)) {\n    const g = 0.45 + 0.55 * S.prog;\n    circum(P, q[0], q[1], q[2], cc);\n    hsv(hw, 0.3, 1, c);\n    ring(acc, cc[0], cc[1], cc[2], c, g);\n    line(acc, P[2 * q[1]], P[2 * q[1] + 1], P[2 * q[2]], P[2 * q[2] + 1], c, 1);\n    ring(acc, P[2 * q[3]], P[2 * q[3] + 1], 2.2, c, 0.6 * g);\n  }\n  // The points, white inside and tinted on the hull.\n  for (let i = 0; i \u003c S.np; i++) {\n    const x = P[2 * i], y = P[2 * i + 1], ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    if (i \u003c S.nh) hsv(hc, 0.35, 0.8, c);\n    else c[0] = c[1] = c[2] = 1;\n    put(acc, ix, iy, c, min(1, 1.6 * (1 - fx) * (1 - fy)));\n    put(acc, ix + 1, iy, c, min(1, 1.6 * fx * (1 - fy)));\n    put(acc, ix, iy + 1, c, min(1, 1.6 * (1 - fx) * fy));\n    put(acc, ix + 1, iy + 1, c, min(1, 1.6 * fx * fy));\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[k])) | 0, (255 * min(1, acc[k + 1])) | 0, (255 * min(1, acc[k + 2])) | 0);\n    }\n}\n","fibonacci-word":"// ===== Patternflow pattern =====\n// Title:   Fibonacci Word\n// Family:  fractal\n// Idea:    A pen reads the Fibonacci word 0100101001001... and takes one step for every digit, turning a quarter turn at every 0, left in an even place and right in an odd one, so 144 crisp steps of 4 LEDs draw a self-avoiding curve of squares nested in squares over the coarse curve of the first 34 digits, which lies in a faint band 5 LEDs wide, each coarse step giving way to the 5 or 3 fine steps that 0 -> 01001 and 1 -> 010 make of it; the three copies of those 34 digits inside the 144 then light in turn, and the panel dives into the first with a quarter turn and a 1 + sqrt 2 zoom until it stands where the whole stood, mirrored, and the pen draws the whole over it again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Fibonacci word fractal and its odd-even drawing rule (Alexis Monnerot-Dumaine, 2009), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=12..15, Angle=-1..1\n//\n// Knob 1: Hue. Turns the colour that runs half the wheel along the word, first digit to last: at 0 sea green through blue and violet to rose, at 0.25 blue through magenta and orange to yellow, at 0.5 rose through amber and lime to sea green, at 0.75 yellow through green and cyan to blue. The coarse curve and the tape of digits on the right edge take the same colours.\n// Knob 2: Speed. The pen draws 70 LEDs of line a second for every unit, 140 at the opening 2, so the 144 steps of order 12 take 4.1 s and a whole cycle of drawing, the 1.8 s look at the three copies and the 2.2 s dive takes 8.1 s; at 0.2 the drawing alone takes 41 s, at 3 it takes 2.7 s and the look and the dive shorten by a fifth.\n// Knob 3: Order. How many digits the pen reads, the Fibonacci number F(n): 12 for 144 steps of 4 LEDs (48 by 112 LEDs), 13 for 233 steps of 2 LEDs in a square 56 by 58, 14 for 377 steps of 2 LEDs (56 by 82), 15 for 610 steps of 2 LEDs, 58 by 138, so 6 rows at the top and 5 at the bottom run off the panel. The coarse curve under the pen is always order n - 3, and the order keeps its shape every three: 12 and 15 are long, 13 square, 14 one and a half times as long as wide.\n// Knob 4: Angle. The turn at each 0. From -0.1 to 0.1 it is exactly 90 degrees and the line stays on the LED grid; it goes down to 60 degrees at -1, where the squares open into a wiggling line that still never touches itself, and up to 120 degrees at 1, where the curve folds over itself into a lattice of triangles and 36 of the 144 steps retrace an earlier one. Off 90 degrees the line is antialiased and the whole is turned and scaled to fit the panel.\n\n// The rule. The Fibonacci word is the limit of S(0) = 0, S(1) = 01,\n// S(n) = S(n-1) S(n-2); its k-th digit, k from 1, is 2 + floor(k phi) -\n// floor((k + 1) phi). Read it from k = 1: step forward, and on a 0 turn\n// left when k is even and right when k is odd. Counting k from 0 instead\n// gives the mirror image. At 90 degrees the first F(n) digits draw the\n// curve of order n; a scratch walk to 28,657 steps found no point visited\n// twice and no two points one lattice step apart unless they are\n// consecutive, which is why even a 1-LED step would stay a clean line.\n// Of the F(n) steps, F(n-1) turn and F(n-2) go straight.\n//\n// Self-similarity. The word is fixed by 0 -> 01, 1 -> 0, so three orders\n// up each digit becomes a block, 0 -> 01001 and 1 -> 010, and the curve of\n// order n is the curve of order n - 3 with every step replaced by its block.\n// It follows the coarse curve mirrored and 1 + sqrt 2 = 2.414 times larger:\n// a least-squares fit of the block ends to the coarse corners is a mirror\n// map of scale 2.420 at 2,584 -> 10,946 steps. Length grows by phi^3 =\n// 4.236 for that, so the dimension of the limit is 3 log phi /\n// log(1 + sqrt 2) = 1.6379. With a turn angle a the\n// fitted ratio follows 1 + cos a + sqrt((1 + cos a)^2 + 1): 3.30 at 60\n// degrees, 1.64 against 1.618 at 120, where 3 log phi / log of it would be\n// 3, more than a plane curve can hold, and the curve overlaps itself.\n//\n// Also S(n) = S(n-3) S(n-4) S(n-3) S(n-3) S(n-4): the first F(n-3) digits\n// come back at F(n-2) and F(n-1), mirrored where that offset is odd. Those\n// are the three copies the panel lights before the dive.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sign, sin, cos, pow, atan2, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The word to 987 digits, and the Fibonacci numbers with F(1) = F(2) = 1.\nconst WORD = (() => {\n  let a = [0], b = [0, 1];\n  while (b.length \u003c 987) [a, b] = [b, b.concat(a)];\n  return b;\n})();\nconst FIB = [0, 1];\nwhile (FIB.length \u003c 20) FIB.push(FIB[FIB.length - 1] + FIB[FIB.length - 2]);\n// Coarse step j becomes fine steps BLK[j] .. BLK[j + 1] - 1 three orders up.\nconst BLK = new Int32Array(WORD.length + 1);\nfor (let j = 0; j \u003c WORD.length; j++) BLK[j + 1] = BLK[j] + (WORD[j] ? 3 : 5);\n\n// The walk in world coordinates. At exactly 90 degrees the turns are done\n// on integers so the points land exactly on the LED grid.\nfunction walk(N, deg, P) {\n  if (deg === 90) {\n    const DX = [1, 0, -1, 0], DY = [0, 1, 0, -1];\n    let x = 0, y = 0, d = 0;\n    P[0] = 0, P[1] = 0;\n    for (let i = 0; i \u003c N; i++) {\n      x += DX[d], y += DY[d];\n      P[2 * i + 2] = x, P[2 * i + 3] = y;\n      if (WORD[i] === 0) d = (d + ((i + 1) % 2 === 0 ? 1 : 3)) % 4;\n    }\n    return;\n  }\n  const th = (deg * PI) / 180;\n  let x = 0, y = 0, a = 0;\n  P[0] = 0, P[1] = 0;\n  for (let i = 0; i \u003c N; i++) {\n    x += cos(a), y += sin(a);\n    P[2 * i + 2] = x, P[2 * i + 3] = y;\n    if (WORD[i] === 0) a += (i + 1) % 2 === 0 ? th : -th;\n  }\n}\n\n// A camera is screen = a * w' + b in complex numbers, w' the world point\n// with y times mir. On the grid a is s or i s with s whole and b whole; off\n// it, the rotation that lets the curve stand largest, kept unless another\n// beats it by 3%.\nfunction camera(P, N, mir, grid, keep) {\n  const tryRot = (c, s) => {\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (let i = 0; i \u003c= N; i++) {\n      const x = P[2 * i], y = mir * P[2 * i + 1], X = c * x - s * y, Y = s * x + c * y;\n      if (X \u003c x0) x0 = X;\n      if (X > x1) x1 = X;\n      if (Y \u003c y0) y0 = Y;\n      if (Y > y1) y1 = Y;\n    }\n    return [x0, x1 - x0, y0, y1 - y0];\n  };\n  if (grid) {\n    let [x0, bw, y0, bh] = tryRot(1, 0), c = 1, s = 0;\n    if (bw > bh) ([x0, bw, y0, bh] = tryRot(0, 1)), (c = 0), (s = 1);\n    // 138.5 rows lets order 15 take 2 LEDs a step and run 5 rows off each end.\n    const k = max(1, floor(min(60 / max(1, bw), 138.5 / max(1, bh))));\n    return { ar: k * c, ai: k * s, br: floor((60 - k * bw) / 2) - k * x0, bi: floor((127 - k * bh) / 2) - k * y0, mir, psi: s ? 90 : 0 };\n  }\n  let best = null;\n  for (let d = 0; d \u003c 180; d += 3) {\n    const r = (d * PI) / 180, c = cos(r), s = sin(r), [x0, bw, y0, bh] = tryRot(c, s);\n    const k = min(58 / max(1e-6, bw), 125 / max(1e-6, bh));\n    const cand = { k, c, s, x0, bw, y0, bh, psi: d };\n    if (!best || k > best.k) best = cand;\n    if (keep === d) keep = cand;\n  }\n  if (keep && typeof keep === \"object\" && keep.k >= best.k * 0.97) best = keep;\n  const { k, c, s, x0, bw, y0, bh, psi } = best;\n  return { ar: k * c, ai: k * s, br: 1 + (58 - k * bw) / 2 - k * x0, bi: (127 - k * bh) / 2 - k * y0, mir, psi };\n}\n\nfunction project(P, N, cam, X, Y) {\n  for (let i = 0; i \u003c= N; i++) {\n    const x = P[2 * i], y = cam.mir * P[2 * i + 1];\n    X[i] = cam.ar * x - cam.ai * y + cam.br;\n    Y[i] = cam.ai * x + cam.ar * y + cam.bi;\n  }\n}\n\n// Least-squares similarity z -> alpha z + beta (or alpha conj z + beta)\n// taking the points (ax, ay) onto (bx, by). Returns [ar, ai, br, bi, err].\n// With snap the turn of alpha is rounded to a quarter, so a curve on the\n// grid stays on it.\nfunction simFit(n, ax, ay, bx, by, conj, snap) {\n  let mx = 0, my = 0, nx = 0, ny = 0;\n  for (let j = 0; j \u003c n; j++) mx += ax(j), my += (conj ? -1 : 1) * ay(j), nx += bx(j), ny += by(j);\n  mx /= n, my /= n, nx /= n, ny /= n;\n  let sr = 0, si = 0, ss = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const u = ax(j) - mx, v = (conj ? -1 : 1) * ay(j) - my, p = bx(j) - nx, q = by(j) - ny;\n    sr += u * p + v * q, si += u * q - v * p, ss += u * u + v * v;\n  }\n  let ar = sr / max(1e-9, ss), ai = si / max(1e-9, ss);\n  if (snap) {\n    const r = hypot(ar, ai), q = (((round(atan2(ai, ar) / (PI / 2)) % 4) + 4) % 4);\n    (ar = r * [1, 0, -1, 0][q]), (ai = r * [0, 1, 0, -1][q]);\n  }\n  const br = nx - (ar * mx - ai * my), bi = ny - (ai * mx + ar * my);\n  let err = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const u = ax(j), v = (conj ? -1 : 1) * ay(j);\n    err += hypot(ar * u - ai * v + br - bx(j), ai * u + ar * v + bi - by(j));\n  }\n  return [ar, ai, br, bi, err];\n}\n\n// Everything the panel needs for one order, angle and mirror: the fine\n// curve on screen and the coarse curve of order n - 3 placed by the\n// similarity that best lays its corners on the ends of their blocks.\nfunction geometry(n, deg, mir, keepPsi) {\n  const N = FIB[n], Nc = FIB[n - 3], grid = deg === 90;\n  const P = new Float64Array(2 * N + 2);\n  walk(N, deg, P);\n  const cam = camera(P, N, mir, grid, keepPsi);\n  const X = new Float64Array(N + 1), Y = new Float64Array(N + 1);\n  project(P, N, cam, X, Y);\n  const fits = [false, true].map((cj) =>\n    simFit(Nc + 1, (j) => P[2 * j], (j) => P[2 * j + 1], (j) => X[BLK[j]], (j) => Y[BLK[j]], cj, grid));\n  const f = fits[0][4] \u003c fits[1][4] ? fits[0] : fits[1], cj = f === fits[1];\n  const GX = new Float64Array(Nc + 1), GY = new Float64Array(Nc + 1);\n  for (let j = 0; j \u003c= Nc; j++) {\n    const u = P[2 * j], v = (cj ? -1 : 1) * P[2 * j + 1];\n    GX[j] = f[0] * u - f[1] * v + f[2];\n    GY[j] = f[1] * u + f[0] * v + f[3];\n  }\n  // The band round the coarse curve: 2 LEDs each side when its steps are\n  // near 10 LEDs long, 1 when they are near 5.\n  const hw = cl(round(0.22 * hypot(GX[1] - GX[0], GY[1] - GY[0])), 1, 2);\n  return { n, N, Nc, deg, mir, grid, cam, X, Y, GX, GY, hw, step: hypot(cam.ar, cam.ai) };\n}\n\n// How bright the coarse curve waits under the pen, and its band. The band\n// stays above 40 of 255, so its rim is a hard edge and not a glow.\nconst GHOST = 0.72, BANDV = 0.19;\n\nconst angleOf = (k) => {\n  const a = abs(k);\n  return a \u003c= 0.1 ? 90 : 90 + (k > 0 ? 30 : -30) * min(1, (a - 0.1) / 0.9);\n};\n\nfunction startDraw(S, ghost) {\n  S.phase = 0, S.pen = 0, S.pt = 0, S.gl = ghost;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, phase: 0, pen: 0, pt: 0, gl: GHOST, zt: 0, c: [0, 0, 0],\n    acc: new Float32Array(W * H * 3), band: new Float32Array(W * H), bandU: new Float32Array(W * H),\n  });\n  S.g = geometry(12, 90, 1, -1);\n  startDraw(S, GHOST);\n}\n\n// The dive: the screen similarity that takes the coarse prefix as drawn now\n// onto where the next (mirrored) picture's coarse curve stands. A power of\n// it, about its fixed point, is the zoom.\nfunction startZoom(S) {\n  const g = S.g, nx = geometry(g.n, g.deg, -g.mir, g.cam.psi);\n  const f = simFit(g.Nc + 1, (j) => g.X[j], (j) => g.Y[j], (j) => nx.GX[j], (j) => nx.GY[j], false);\n  const [ar, ai, br, bi] = f, dr = 1 - ar, di = -ai, dd = dr * dr + di * di;\n  S.z = { next: nx, r: hypot(ar, ai), phi: atan2(ai, ar), cx: (br * dr + bi * di) / max(1e-9, dd), cy: (bi * dr - br * di) / max(1e-9, dd) };\n  S.phase = 2, S.zt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 12, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const n = cl(round(k[2]), 12, 15), deg = angleOf(cl(k[3], -1, 1));\n  const f = 0.55 + 0.225 * S.speed, g0 = S.g;\n  if (n !== g0.n) {\n    S.g = geometry(n, deg, g0.mir, -1);\n    startDraw(S, GHOST);\n  } else if (abs(deg - g0.deg) > 0.05 || (deg === 90) !== g0.grid) {\n    S.g = geometry(n, deg, g0.mir, g0.cam.psi);\n    if (S.phase === 2) startDraw(S, GHOST);\n  }\n  const g = S.g;\n  if (S.phase === 0) {\n    S.pen += (70 * S.speed * d) / max(0.05, g.step);\n    S.gl += (GHOST - S.gl) * min(1, d * 2.5);\n    if (S.pen >= g.N) (S.pen = g.N), (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    S.pt += (d * f) / 1.8;\n    if (S.pt >= 1) startZoom(S);\n  } else {\n    S.zt += (d * f) / 2.2;\n    if (S.zt >= 1) {\n      S.g = S.z.next;\n      startDraw(S, 1);\n    }\n  }\n}\n\n// Additive light, one LED per unit of line.\nfunction splat(acc, x, y, w, r, g, b) {\n  const i = floor(x), j = floor(y), fx = x - i, fy = y - j;\n  for (let q = 0; q \u003c 4; q++) {\n    const ii = i + (q & 1), jj = j + (q >> 1);\n    if (ii \u003c 0 || ii >= W || jj \u003c 0 || jj >= H) continue;\n    const ww = w * (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy), o = (jj * W + ii) * 3;\n    acc[o] += r * ww, acc[o + 1] += g * ww, acc[o + 2] += b * ww;\n  }\n}\nfunction lineAA(acc, x0, y0, x1, y1, r, g, b, upto) {\n  if ((x0 \u003c -2 && x1 \u003c -2) || (x0 > W + 1 && x1 > W + 1) || (y0 \u003c -2 && y1 \u003c -2) || (y0 > H + 1 && y1 > H + 1)) return;\n  const L = hypot(x1 - x0, y1 - y0), m = max(1, ceil((L * upto) / 0.45)), w = (L * upto) / m;\n  for (let u = 0; u \u003c m; u++) {\n    const t = ((u + 0.5) / m) * upto;\n    splat(acc, x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, w, r, g, b);\n  }\n}\n// On the grid: the LEDs from (x0, y0) toward (x1, y1), the far end left to\n// the next step, cut at the share upto.\nfunction lineGrid(acc, x0, y0, x1, y1, r, g, b, upto) {\n  const L = abs(x1 - x0) + abs(y1 - y0), sx = sign(x1 - x0), sy = sign(y1 - y0), m = upto >= 1 ? L : floor(L * upto + 1e-9) + 1;\n  for (let u = 0; u \u003c m; u++) {\n    const x = x0 + sx * u, y = y0 + sy * u;\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3;\n    acc[o] += r, acc[o + 1] += g, acc[o + 2] += b;\n  }\n}\n\n// Every LED within hw of a segment joins the band at level v, the highest\n// level keeping its colour u, so crossings do not add up.\nfunction bandSeg(S, x0, y0, x1, y1, hw, v, u) {\n  if (v \u003c= 0.01) return;\n  const B = S.band, U = S.bandU, r = hw + 0.45, dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy;\n  const xa = max(0, floor(min(x0, x1) - r)), xb = min(W - 1, ceil(max(x0, x1) + r));\n  const ya = max(0, floor(min(y0, y1) - r)), yb = min(H - 1, ceil(max(y0, y1) + r));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const t = L2 > 0 ? cl(((x - x0) * dx + (y - y0) * dy) / L2, 0, 1) : 0, ex = x0 + dx * t - x, ey = y0 + dy * t - y;\n      if (ex * ex + ey * ey \u003c= r * r) {\n        const p = y * W + x;\n        if (v > B[p]) (B[p] = v), (U[p] = u);\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.g) return;\n  const acc = S.acc, c = S.c, h0 = 0.42 + S.hue;\n  acc.fill(0);\n  S.band.fill(0);\n  const g = S.g, N = g.N, Nc = g.Nc;\n  const col = (u, v, white) => {\n    hsv(h0 + 0.5 * u, 0.78 * (1 - white), v, c);\n    return c;\n  };\n  if (S.phase === 2) {\n    // The dive: every point of the curve under the similarity's power.\n    const z = S.z, e = smooth(S.zt), rr = pow(z.r, e), ph = z.phi * e, er = rr * cos(ph), ei = rr * sin(ph);\n    const out = 1 - smooth(S.zt / 0.6), zx = (x, y) => z.cx + er * (x - z.cx) - ei * (y - z.cy), zy = (x, y) => z.cy + ei * (x - z.cx) + er * (y - z.cy);\n    // The old band rides the dive out; a new one grows round the first copy,\n    // which is the next picture's coarse curve.\n    const vo = BANDV * (1 - smooth(e / 0.35)), vn = BANDV * smooth(e / 0.5);\n    for (let j = 0; j \u003c Nc; j++) {\n      const ax = g.GX[j], ay = g.GY[j], bx = g.GX[j + 1], by = g.GY[j + 1];\n      bandSeg(S, zx(ax, ay), zy(ax, ay), zx(bx, by), zy(bx, by), g.hw, vo, (BLK[j] + BLK[j + 1]) / (2 * N));\n      const cx = g.X[j], cy = g.Y[j], dx = g.X[j + 1], dy = g.Y[j + 1];\n      bandSeg(S, zx(cx, cy), zy(cx, cy), zx(dx, dy), zy(dx, dy), z.next.hw * e, vn, (BLK[j] + BLK[j + 1]) / (2 * N));\n    }\n    let px = 0, py = 0;\n    for (let i = 0; i \u003c= N; i++) {\n      const dx = g.X[i] - z.cx, dy = g.Y[i] - z.cy, x = z.cx + er * dx - ei * dy, y = z.cy + ei * dx + er * dy;\n      if (i > 0) {\n        const j = i - 1, pre = j \u003c Nc;\n        const u = pre ? ((j + 0.5) / N) * (1 - e) + ((BLK[j] + BLK[j + 1]) / (2 * N)) * e : (j + 0.5) / N;\n        const v = pre ? 1 : 0.45 * out;\n        if (v > 0.01) {\n          const w = pre ? 0.55 * (1 - e) : 0;\n          col(u, v, w);\n          lineAA(acc, px, py, x, y, c[0], c[1], c[2], 1);\n        }\n      }\n      px = x, py = y;\n    }\n  } else {\n    // The coarse curve, each step fading as the pen finishes its block, and\n    // its band, which stays.\n    const rate = max(0.5, 70 / max(0.05, g.step)), rd = g.grid ? round : (v) => v;\n    for (let j = 0; j \u003c Nc; j++) bandSeg(S, rd(g.GX[j]), rd(g.GY[j]), rd(g.GX[j + 1]), rd(g.GY[j + 1]), g.hw, BANDV, (BLK[j] + BLK[j + 1]) / (2 * N));\n    for (let j = 0; j \u003c Nc; j++) {\n      const gone = (S.pen - BLK[j + 1]) / (0.3 * rate) + (S.phase === 1 ? 8 * S.pt : 0), a = S.gl * (1 - cl(gone, 0, 1));\n      if (a \u003c= 0.01) continue;\n      col((BLK[j] + BLK[j + 1]) / (2 * N), a, 0.15);\n      if (g.grid) lineGrid(acc, round(g.GX[j]), round(g.GY[j]), round(g.GX[j + 1]), round(g.GY[j + 1]), c[0], c[1], c[2], 1);\n      else lineAA(acc, g.GX[j], g.GY[j], g.GX[j + 1], g.GY[j + 1], c[0], c[1], c[2], 1);\n    }\n    // The fine curve up to the pen. In the look (phase 1) the three copies\n    // of the first F(n-3) digits light in turn and the rest dims.\n    const offs = [0, FIB[g.n - 2], FIB[g.n - 1]];\n    let spot = [0, 0, 0], dim = 1;\n    if (S.phase === 1) {\n      const p = S.pt;\n      spot = [0.33, 0.52, 0.71].map((m0) => max(0, 1 - abs(p - m0) / 0.11));\n      spot[0] = max(spot[0], smooth((p - 0.8) / 0.15));\n      dim = 1 - 0.55 * smooth((p - 0.1) / 0.12);\n    }\n    const last = S.phase === 0 ? floor(S.pen) : N - 1, frac = S.phase === 0 ? S.pen - last : 1;\n    for (let i = 0; i \u003c= min(last, N - 1); i++) {\n      let s = 0;\n      for (let q = 0; q \u003c 3; q++) if (i >= offs[q] && i \u003c offs[q] + Nc) s = max(s, spot[q]);\n      const v = dim + (1 - dim) * s;\n      col((i + 0.5) / N, v, 0.6 * s);\n      const up = i \u003c last ? 1 : frac;\n      if (up \u003c= 0) continue;\n      if (g.grid) lineGrid(acc, g.X[i], g.Y[i], g.X[i + 1], g.Y[i + 1], c[0], c[1], c[2], up);\n      else lineAA(acc, g.X[i], g.Y[i], g.X[i + 1], g.Y[i + 1], c[0], c[1], c[2], up);\n    }\n    if (S.phase !== 0) {\n      col(1, dim, 0);\n      if (g.grid) lineGrid(acc, g.X[N], g.Y[N], g.X[N], g.Y[N], c[0], c[1], c[2], 1);\n    } else {\n      // The pen: a white point with a glow of the colour it is laying down.\n      const i = min(last, N - 1), x = g.X[i] + (g.X[i + 1] - g.X[i]) * frac, y = g.Y[i] + (g.Y[i + 1] - g.Y[i]) * frac;\n      col((i + 0.5) / N, 1, 0.3);\n      const px = g.grid ? round(x) : x, py = g.grid ? round(y) : y;\n      splat(acc, px, py, 1.6, 1, 1, 1);\n      for (const [ox, oy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) splat(acc, px + ox, py + oy, 0.45, c[0], c[1], c[2]);\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    if (S.band[p] \u003c= 0) continue;\n    col(S.bandU[p], S.band[p], 0);\n    acc[3 * p] += c[0], acc[3 * p + 1] += c[1], acc[3 * p + 2] += c[2];\n  }\n  // The tape: the word itself down the right edge, two rows a digit, the\n  // digit being read on row 64. A 0 is two LEDs wide, a 1 one. Read digits\n  // are lit in their colour, the rest wait dim; in the dive it rewinds.\n  const tape = S.phase === 0 ? S.pen : S.phase === 1 ? N : N * (1 - smooth(S.zt));\n  for (let y = 0; y \u003c H; y++) {\n    const q = tape + (y - 64) / 2, k = floor(q);\n    if (k \u003c 0 || k >= N || q - k >= 0.5) continue;\n    const now = k === floor(tape) && S.phase === 0;\n    col((k + 0.5) / N, k \u003c tape ? 1 : 0.32, now ? 1 : 0.1);\n    for (let x = WORD[k] ? 63 : 62; x \u003c 64; x++) {\n      const o = (y * W + x) * 3;\n      acc[o] += c[0], acc[o + 1] += c[1], acc[o + 2] += c[2];\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[o])) | 0, (255 * min(1, acc[o + 1])) | 0, (255 * min(1, acc[o + 2])) | 0);\n    }\n}\n","huffman-tree":"// ===== Patternflow pattern =====\n// Title:   Huffman Tree\n// Family:  type\n// Idea:    The symbols of a short text stand along the foot of the panel on dotted stems as tall as the logarithm of their counts, the two lightest nodes merge again and again into a parent that rises above them until one root stands at the top, every merge writing a 0 into the codes of the leaves under its left branch and a 1 under its right so the codes grow up the columns over the labels, and then the text streams down the tree into a bit string that comes out shorter than the fixed-length code under it.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: minimum-redundancy codes (David A. Huffman, 1952); coding the opening words of Charles Dickens's A Tale of Two Cities (1859), the perfect pangram Mr Jock, TV quiz PhD, bags few lynx, the first 100 digits of pi, and the first two lines of Yun Dong-ju's Seosi (1941) split into jamo; the 3 by 5 capitals of the Typewriter pattern (round 18), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Tie=0..2\n//\n// Knob 1: Hue. Turns the colours round the wheel: at 0 a 0 bit is azure, a 1 bit amber and the fixed-length strip rose; at 0.5 a 0 is red-orange, a 1 blue and the fixed strip green. Stems and labels keep a pale tint of the 0 colour.\n// Knob 2: Speed. At 2 the lightest merge takes 0.22 s and the root 0.48 s, so Dickens's 12 merges stand in 4.1 s, its 50 symbols stream in 7 s and the whole run with 3 s of totals and a 1 s fade lasts 15.7 s; at 0.2 it all takes ten times as long, at 3 two thirds as long.\n// Knob 3: Text. 0 Dickens, 13 symbols over 50 places, 169 bits against 200 at 4 bits a symbol; 1 the pangram, 27 symbols over 33 places, 148 against 165 at 5 bits, its 26 letters a level comb of 5 and 6 bit codes beside the space's 00; 2 the first 100 digits of pi, 332 against 400 at the 4 bits of binary-coded decimal, six digits taking 3 bits and four taking 4; 3 Seosi in jamo, 16 symbols over 58 places, 223 against 232.\n// Knob 4: Tie. Which of two equal weights merges first: 0 the older (leaves before merged nodes, earlier symbols first), 1 the newer, 2 a coin drawn anew each time the tree is rebuilt. The tree changes shape and the total never does: Dickens takes 169 bits under every rule while its longest code is 5 bits at 0 and 6 at 1, and the pangram's four 6-bit letters are M R J O at 0 and E W L Y at 1.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, exp, log2, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The 3 by 5 face, rows top to bottom, one bit per column: Typewriter's\n// capitals, the figures, and a space drawn as an open box.\nconst G3 = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\",\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\",\n  4: \"101101111001001\", 5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\",\n  8: \"111101111101111\", 9: \"111101111001111\",\n  \" \": \"000000000101111\", \"+\": \"000010111010000\", \"=\": \"000111000111000\", \"\u003c\": \"001010100010001\",\n};\n// Jamo drawn 5 by 5 for the Korean line, and its space.\nconst G5 = {\n  \"ㄱ\": \"1111100001000010000100001\", \"ㄲ\": \"1101101001010010100101001\", \"ㄴ\": \"1000010000100001000011111\",\n  \"ㄹ\": \"1111100001111111000011111\", \"ㅁ\": \"1111110001100011000111111\", \"ㅂ\": \"1000110001111111000111111\",\n  \"ㅅ\": \"0010000100010100101010001\", \"ㅇ\": \"0111010001100011000101110\", \"ㅈ\": \"1111100100001000101010001\",\n  \"ㅎ\": \"0010011111011101000101110\", \"ㅏ\": \"0100001000011100100001000\", \"ㅓ\": \"0001000010011100001000010\",\n  \"ㅜ\": \"0000011111001000010000100\", \"ㅡ\": \"0000000000111110000000000\", \"ㅣ\": \"0010000100001000010000100\",\n  \" \": \"0000000000000001000111111\",\n};\n\nconst TEXTS = [\n  // A Tale of Two Cities (1859), its first words, letters and spaces only.\n  \"IT WAS THE BEST OF TIMES IT WAS THE WORST OF TIMES\",\n  // A perfect pangram: every letter once, so 26 weights of 1 and the spaces.\n  \"MR JOCK TV QUIZ PHD BAGS FEW LYNX\",\n  // The first 100 digits of pi, 3 and 99 decimals.\n  \"3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067\",\n  // Yun Dong-ju, Seosi (1941): 죽는 날까지 하늘을 우러러 / 한 점 부끄럼이 없기를,\n  // split into the keys of the two-set keyboard (없 is ㅇ ㅓ ㅂ ㅅ, ㄲ one key).\n  \"ㅈㅜㄱㄴㅡㄴ ㄴㅏㄹㄲㅏㅈㅣ ㅎㅏㄴㅡㄹㅇㅡㄹ ㅇㅜㄹㅓㄹㅓ ㅎㅏㄴ ㅈㅓㅁ ㅂㅜㄲㅡㄹㅓㅁㅇㅣ ㅇㅓㅂㅅㄱㅣㄹㅡㄹ\",\n];\n\n// Rows. The text line, the Huffman strip and the fixed strip at the top, the\n// root under them; labels at the foot with the code band above them.\nconst LINE_Y = 1, HS_Y = 8, FS_Y = 16, STRIP_R = 7, ROOT_Y = 28;\n// Times in seconds at Speed 2.\nconst T0 = 0.3, TM = 0.32, PAUSE = 0.6, STREAM = 7, HOLD = 3, FADE = 1;\n\n// Huffman's construction. Symbols are counted in order of first appearance\n// and become leaves 0..k-1; each merge takes the two lightest nodes, the\n// first taken goes left (bit 0), and the parent joins the pool. Ties go by\n// the rule: 0 the older node first, 1 the newer, 2 a random key.\nfunction huffman(text, rule) {\n  const idx = new Map(), sym = [], seq = [];\n  for (const ch of text) {\n    if (!idx.has(ch)) idx.set(ch, sym.length), sym.push({ ch, w: 0 });\n    const i = idx.get(ch);\n    sym[i].w++;\n    seq.push(i);\n  }\n  const nodes = sym.map((s, i) => ({ w: s.w, leaf: i, a: -1, b: -1, up: -1, bit: 0, r: Math.random(), m: -1 }));\n  const pool = nodes.map((_, i) => i), merges = [];\n  const first = (i, j) => {\n    const p = nodes[i], q = nodes[j];\n    if (p.w !== q.w) return p.w \u003c q.w;\n    return rule === 0 ? i \u003c j : rule === 1 ? i > j : p.r \u003c q.r;\n  };\n  const take = () => {\n    let bi = 0;\n    for (let i = 1; i \u003c pool.length; i++) if (first(pool[i], pool[bi])) bi = i;\n    return pool.splice(bi, 1)[0];\n  };\n  while (pool.length > 1) {\n    const a = take(), b = take(), id = nodes.length;\n    nodes.push({ w: nodes[a].w + nodes[b].w, leaf: -1, a, b, up: -1, bit: 0, r: Math.random(), m: merges.length });\n    nodes[a].up = id, nodes[b].up = id, nodes[b].bit = 1;\n    merges.push(id);\n    pool.push(id);\n  }\n  const root = pool[0];\n  // Codes, read from the root: 0 for the left branch, 1 for the right.\n  const codes = sym.map((_, i) => {\n    let s = \"\";\n    for (let n = i; nodes[n].up >= 0; n = nodes[n].up) s = nodes[n].bit + s;\n    return s;\n  });\n  let total = 0, sigma = 0;\n  for (const i of seq) total += codes[i].length;\n  for (const id of merges) sigma += nodes[id].w;\n  return { sym, seq, nodes, merges, root, codes, total, sigma, maxLen: max(...codes.map((c) => c.length)) };\n}\n\nfunction prepare(S) {\n  const text = TEXTS[S.text], T = huffman(text, S.rule), k = T.sym.length, N = T.seq.length;\n  const big = S.text === 3, gw = big ? 5 : 3, m = (gw - 1) / 2;\n  // In-order leaves: the tree draws without crossings.\n  const order = [];\n  const walk = (n) => {\n    const q = T.nodes[n];\n    if (q.leaf >= 0) order.push(n);\n    else walk(q.a), walk(q.b);\n  };\n  walk(T.root);\n  const pitch = (W - 2 * m) / k, stagger = pitch \u003c gw + 1;\n  const band = max(T.maxLen, huffman(text, 0).maxLen, huffman(text, 1).maxLen);\n  const labelY = stagger ? 116 : 122, codeBottom = labelY - 2, Y0 = codeBottom - 2 * band + 1 - 3;\n  order.forEach((n, pos) => {\n    const q = T.nodes[n];\n    q.x = round(m + (pos + 0.5) * pitch - 0.5);\n    q.ly = stagger && pos % 2 === 0 ? 122 : labelY;\n  });\n  // Heights: a node of weight w stands log2(w) levels above the baseline,\n  // so the drop from the root to a leaf is log2(N / w), the leaf's ideal\n  // length in bits. Parents keep 2 rows above their children and never\n  // below an earlier merge, so the tree grows upwards in merge order.\n  let L = (Y0 - ROOT_Y) / log2(N);\n  for (let tries = 0; tries \u003c 40; tries++) {\n    for (const q of T.nodes) if (q.leaf >= 0) q.y = Y0 - round(log2(q.w) * L);\n    let prev = Y0;\n    for (const id of T.merges) {\n      const q = T.nodes[id], A = T.nodes[q.a], B = T.nodes[q.b];\n      q.x = (A.x + B.x) >> 1;\n      q.y = min(Y0 - round(log2(q.w) * L), A.y - 2, B.y - 2, prev);\n      prev = q.y;\n    }\n    if (T.nodes[T.root].y >= ROOT_Y) break;\n    L *= 0.97;\n  }\n  // Each leaf's ancestors from the leaf up, and where its bits go in the\n  // Huffman strip for every place in the text.\n  T.path = order.map(() => null);\n  for (let i = 0; i \u003c k; i++) {\n    const up = [];\n    for (let n = i; T.nodes[n].up >= 0; n = T.nodes[n].up) up.push(n);\n    T.path[i] = up;\n  }\n  T.pos = new Int32Array(N + 1);\n  for (let j = 0; j \u003c N; j++) T.pos[j + 1] = T.pos[j] + T.codes[T.seq[j]].length;\n  T.fb = ceil(log2(k));\n  T.fixed = T.fb * N;\n  T.cw = T.fixed \u003c= STRIP_R * 32 ? 2 : 1;\n  T.chars = [...text];\n  T.N = N, T.k = k, T.big = big, T.gw = gw, T.Y0 = Y0, T.codeBottom = codeBottom, T.L = L;\n  // A merge takes longer the heavier it is: the twigs go quickly, the\n  // trunk slowly, 0.6 to 1.5 times TM.\n  T.mS = [], T.mD = [], T.mT = [];\n  let at = T0;\n  for (const id of T.merges) {\n    const dur = TM * (0.5 + sqrt(T.nodes[id].w / N));\n    T.mS.push(at), T.mD.push(dur), T.mT.push(at + 0.8 * dur);\n    at += dur;\n  }\n  T.buildEnd = at;\n  T.ts = min(0.25, STREAM / N);\n  T.streamAt = T.buildEnd + PAUSE;\n  T.holdAt = T.streamAt + N * T.ts;\n  T.end = T.holdAt + HOLD + FADE;\n  S.T = T;\n  S.c = 0;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, c: 0, text: 0, rule: 0, hue: 0, speed: 2, T: null, buf: new Float32Array(W * H * 3) };\n  prepare(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const text = cl(round(k[2]), 0, 3), rule = cl(round(k[3]), 0, 2);\n  if (text !== S.text || rule !== S.rule) {\n    S.text = text, S.rule = rule;\n    prepare(S);\n    return;\n  }\n  S.c += (d * S.speed) / 2;\n  if (S.c >= S.T.end) prepare(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const T = S.T, c = S.c, buf = S.buf, nodes = T.nodes;\n  buf.fill(0);\n  const h0 = 0.55 + S.hue;\n  const BIT = [hsv(h0, 0.8, 1), hsv(h0 + 0.58, 0.85, 1)];\n  const PALE = hsv(h0, 0.55, 1), FIX = hsv(h0 + 0.3, 0.55, 1);\n  const fade = c > T.end - FADE ? 1 - sm((c - (T.end - FADE)) / FADE) : 1;\n  const put = (x, y, col, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    buf[i] = max(buf[i], col[0] * v), buf[i + 1] = max(buf[i + 1], col[1] * v), buf[i + 2] = max(buf[i + 2], col[2] * v);\n  };\n  const vline = (x, y0, y1, col, v) => {\n    for (let y = min(y0, y1); y \u003c= max(y0, y1); y++) put(x, y, col, v);\n  };\n  const hline = (x0, x1, y, col, v) => {\n    for (let x = min(x0, x1); x \u003c= max(x0, x1); x++) put(x, y, col, v);\n  };\n  const glyph = (ch, x0, y0, col, v) => {\n    const g5 = T.big && G5[ch], g = g5 || G3[ch];\n    if (!g) return;\n    const gw = g5 ? 5 : 3;\n    if (x0 + gw > W) return;\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c gw; q++) if (g[r * gw + q] === \"1\") put(x0 + q, y0 + r, col, v);\n  };\n  const WHITE = [1, 1, 1];\n  const N = T.N, M = T.merges.length, wN = nodes[T.root].w;\n  const br = (w) => 0.42 + 0.58 * sqrt(w / wN);\n\n  // Merge clock: how many merges are done, which one runs and how far.\n  let done = 0;\n  while (done \u003c M && c >= T.mT[done]) done++;\n  let running = -1, u = 0;\n  if (c >= T0 && c \u003c T.buildEnd) {\n    running = done \u003c M && c >= T.mS[done] ? done : done - 1;\n    u = (c - T.mS[running]) / T.mD[running];\n  }\n  let front = T.Y0;\n  if (c >= T0) {\n    if (running >= 0) {\n      const prev = running > 0 ? nodes[T.merges[running - 1]].y : T.Y0;\n      front = round(prev + (nodes[T.merges[running]].y - prev) * sm(u / 0.45));\n    } else front = nodes[T.root].y;\n  }\n  const isDone = (id) => nodes[id].leaf >= 0 || nodes[id].m \u003c done;\n\n  // Leaves' dotted stems: the count on a log scale.\n  for (let i = 0; i \u003c T.k; i++) {\n    const q = nodes[i];\n    for (let y = T.Y0; y > q.y; y -= 2) put(q.x, y, PALE, 0.4);\n  }\n  // Faint lines a bit apart, counted down from where the root would stand:\n  // a leaf whose node sits between lines j and j + 1 has an ideal length\n  // log2(N / w) between j and j + 1 bits.\n  for (let j = 1; ; j++) {\n    const y = round(T.Y0 - (log2(N) - j) * T.L);\n    if (y > T.Y0) break;\n    for (let x = (j & 1) * 2; x \u003c W; x += 4) put(x, y, PALE, 0.14);\n  }\n  // Under each bar a faint light down to the higher child: the 0 side left\n  // of the parent, the 1 side right of it.\n  for (let j = 0; j \u003c done; j++) {\n    const q = nodes[T.merges[j]], A = nodes[q.a], B = nodes[q.b], low = min(A.y, B.y), hh = low - q.y;\n    const e = 1 - exp(-(c - T.mT[j]) / 0.3);\n    for (let y = q.y + 1; y \u003c low; y++) {\n      const v = e * 0.21 * (1 - (0.75 * (y - q.y)) / hh);\n      for (let x = A.x + 1; x \u003c B.x; x++) if (x !== q.x) put(x, y, BIT[x \u003c q.x ? 0 : 1], v);\n    }\n  }\n  // Edges. A merged node's stem and half bar take its bit's colour, brighter\n  // for heavier nodes; an unmerged node's stem grows white up to the front.\n  for (let n = 0; n \u003c nodes.length; n++) {\n    const q = nodes[n];\n    if (!isDone(n)) continue;\n    const p = q.up >= 0 ? nodes[q.up] : null;\n    if (p && p.m \u003c done) {\n      vline(q.x, q.y, p.y, BIT[q.bit], br(q.w));\n      hline(q.x, p.x, p.y, BIT[q.bit], br(q.w));\n      // Heavy branches run two LEDs wide, inwards and upwards.\n      if (q.leaf \u003c 0 && q.w * 5 >= wN) {\n        vline(q.x + (q.bit ? -1 : 1), q.y - 1, p.y, BIT[q.bit], 0.8 * br(q.w));\n        hline(q.x, p.x, p.y - 1, BIT[q.bit], 0.8 * br(q.w));\n      }\n    } else if (p && p.m === running) {\n      const top = min(q.y, front);\n      vline(q.x, q.y, top, WHITE, 0.95);\n      if (u > 0.45) {\n        const f = sm((u - 0.45) / 0.35), xe = round(q.x + (p.x - q.x) * f);\n        if (f > 0) hline(q.x, xe, p.y, BIT[q.bit], 1);\n      }\n    } else if (n !== T.root) {\n      if (front \u003c q.y) vline(q.x, q.y, front, PALE, 0.55);\n    }\n    // The node itself.\n    if (n === T.root && done === M) vline(q.x, q.y, q.y - 2, WHITE, 1);\n    put(q.x, q.y, WHITE, q.leaf >= 0 ? 0.9 : 0.7);\n  }\n  // A merge just done flashes its bar.\n  if (done > 0) {\n    const id = T.merges[done - 1], q = nodes[id], e = exp(-(c - T.mT[done - 1]) / 0.25);\n    if (e > 0.05) hline(nodes[q.a].x, nodes[q.b].x, q.y, WHITE, e);\n  }\n\n  // Codes over the labels, growing upwards a bit per merge above the leaf.\n  for (let i = 0; i \u003c T.k; i++) {\n    const q = nodes[i], up = T.path[i], len = up.length;\n    let vis = 0;\n    while (vis \u003c len && nodes[nodes[up[vis]].up].m \u003c done) vis++;\n    for (let j = 0; j \u003c vis; j++) {\n      // j counts from the leaf: the bit of up[j]; it sits j rows above the bottom.\n      const n = up[j], y = T.codeBottom - 2 * j;\n      const fresh = exp(-(c - T.mT[nodes[nodes[n].up].m]) / 0.3);\n      put(q.x, y, BIT[nodes[n].bit], 0.85);\n      if (fresh > 0.05) put(q.x, y, WHITE, fresh);\n    }\n    // The leaf's column down to its label.\n    vline(q.x, T.codeBottom + 1, q.ly - 1, PALE, 0.3);\n  }\n\n  // Streaming: the current symbol's path lights from the root down, and its\n  // bits go into the Huffman strip while its fixed code goes in below.\n  let cur = -1, cu = 0, wrote = 0, wroteF = 0;\n  if (c >= T.streamAt) {\n    const s = (c - T.streamAt) / T.ts;\n    cur = min(N - 1, floor(s));\n    cu = s >= N ? 1 : s - cur;\n    const leaf = T.seq[cur], len = T.codes[leaf].length;\n    const shown = min(len, 1 + floor(cu * 1.6 * len));\n    wrote = T.pos[cur] + shown;\n    wroteF = cur * T.fb + min(T.fb, 1 + floor(cu * 1.6 * T.fb));\n    // Path: up[len-1] is the root's child; edges from the root down.\n    const up = T.path[leaf], e = s >= N ? 0 : 1 - 0.5 * cu;\n    for (let j = len - 1; j >= len - shown; j--) {\n      const q = nodes[up[j]], p = nodes[q.up];\n      vline(q.x, q.y, p.y, WHITE, e);\n      hline(q.x, p.x, p.y, WHITE, e);\n    }\n    const lf = nodes[leaf];\n    if (shown === len) for (let j = 0; j \u003c len; j++) put(lf.x, T.codeBottom - 2 * j, WHITE, e);\n  }\n\n  // Labels.\n  for (let i = 0; i \u003c T.k; i++) {\n    const q = nodes[i], lit = cur >= 0 && T.seq[cur] === i && c \u003c T.holdAt;\n    glyph(T.sym[i].ch, q.x - (T.gw >> 1), q.ly, lit ? WHITE : PALE, lit ? 1 : 0.85);\n  }\n\n  // Strips: the Huffman strip fills with placeholders a merge at a time,\n  // w cells for a merge of weight w, and they come to the code's length;\n  // the fixed strip waits at N times the fixed length from the start.\n  const cw = T.cw, per = W / cw;\n  const cell = (y0, i, col, v) => {\n    const x = (i % per) * cw, y = y0 + floor(i / per);\n    for (let q = 0; q \u003c cw; q++) put(x + q, y, col, v);\n  };\n  let held = 0;\n  for (let j = 0; j \u003c done; j++) held += nodes[T.merges[j]].w;\n  const GREY = FIX;\n  let bit = 0;\n  for (let i = 0; i \u003c T.total; i++) {\n    if (i \u003c wrote) {\n      // Which bit of which symbol: walk the text alongside.\n      while (T.pos[bit + 1] \u003c= i) bit++;\n      const b = T.codes[T.seq[bit]][i - T.pos[bit]];\n      cell(HS_Y, i, BIT[b === \"1\" ? 1 : 0], i >= T.pos[cur] && c \u003c T.holdAt ? 1 : 0.8);\n    } else if (i \u003c held) cell(HS_Y, i, PALE, 0.25);\n  }\n  for (let i = 0; i \u003c T.fixed; i++) {\n    if (i \u003c wroteF) {\n      const j = floor(i / T.fb), b = (T.seq[j] >> (T.fb - 1 - (i % T.fb))) & 1;\n      cell(FS_Y, i, GREY, b ? 0.7 : 0.32);\n    } else cell(FS_Y, i, GREY, 0.22);\n  }\n\n  // The line: the text before the first merge, each merge's sum while the\n  // tree grows, the text running through while it streams, then the totals.\n  const P = T.big ? 6 : 4;\n  if (done === 0 && running \u003c 1) {\n    for (let j = 0; j * P \u003c W && j \u003c N; j++) glyph(T.chars[j], j * P + 1, LINE_Y, PALE, 0.6);\n  } else if (c \u003c T.streamAt) {\n    const id = T.merges[running >= 0 ? running : M - 1], q = nodes[id];\n    const parts = [[String(nodes[q.a].w), BIT[0]], [\"+\", PALE], [String(nodes[q.b].w), BIT[1]]];\n    if (running \u003c 0 || u >= 0.8) parts.push([\"=\", PALE], [String(q.w), WHITE]);\n    let len = 0;\n    for (const [s] of parts) len += s.length;\n    let x = (W - len * 4 + 1) >> 1;\n    for (const [s, col] of parts) for (const ch of s) glyph(ch, x, LINE_Y, col, 1), (x += 4);\n  } else if (c \u003c T.holdAt) {\n    const chars = T.chars;\n    for (let j = 0; j \u003c 16; j++) {\n      const at = cur - 3 + j;\n      if (at \u003c 0 || at >= N || j * P >= W) continue;\n      glyph(chars[at], j * P + 1, LINE_Y, at === cur ? WHITE : PALE, at === cur ? 1 : at \u003c cur ? 0.35 : 0.65);\n    }\n  } else {\n    const a = String(T.total), b = String(T.fixed), len = a.length + 1 + b.length;\n    let x = (W - len * 4 + 1) >> 1;\n    for (const ch of a) glyph(ch, x, LINE_Y, BIT[1], 1), (x += 4);\n    glyph(\"\u003c\", x, LINE_Y, WHITE, 1), (x += 4);\n    for (const ch of b) glyph(ch, x, LINE_Y, GREY, 0.8), (x += 4);\n  }\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, buf[i] * fade)) | 0, (255 * min(1, buf[i + 1] * fade)) | 0, (255 * min(1, buf[i + 2] * fade)) | 0);\n    }\n}\n","josephus":"// ===== Patternflow pattern =====\n// Title:   Josephus Problem\n// Family:  rhythm\n// Idea:    A circle of n lamps fills the top half and a hand goes round it one place a tick, each lamp it passes still lit a beat and every k-th beat an accent that puts that lamp out, so the beat thins into rests as the circle empties, with a roll inside the ring drawing that rhythm and the survivor's number coming up when one lamp is left, while the bottom half holds the table of every circle from 1 to 64 lamps, one row each, coloured by the order its places went out with the survivor white, so the survivors J(n,k) run down the panel as a sawtooth and the row of the circle on top lights as it plays.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Josephus problem (Flavius Josephus, The Jewish War, 1st century; counting-out puzzle in Claude Gaspard Bachet's Problèmes plaisans et délectables, 1612), closed form J(2^m + L) = 2L + 1 (Graham, Knuth and Patashnik, Concrete Mathematics, 1989, chapter 1), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Step=2..7, Circle=8..64\n//\n// Knob 1: Hue. Turns the colours of the places put out round the wheel: at 0 the first ones out are a deep blue and the later ones teal, green and gold up to the white survivor, with the lamps still lit a cool white; at 0.25 they run from rose through orange and yellow to green, at 0.5 from yellow-green through red and magenta to blue.\n// Knob 2: Speed. The counting tempo: at 2 the hand passes 2(2 + n/6) places a second while every lamp is lit, 6.7 on the opening circle of 8 and 25 on a circle of 64, and hurries by the square root of n over the lamps left as they go out, so the circle of 8 is down to one lamp in 2.1 s and the circle of 64 in 6.4 s, each survivor then holding 1.3 s. At 0.2 the circle of 8 takes 21 s, at 3 it takes 1.4 s.\n// Knob 3: Step. k, the beat that goes out, 2 to 7. At 2, the classic, every second lamp goes, a circle of 16 halves its beats every time round (xXxX, x.X., x...X...) and the survivor column climbs 2 places a row and drops back to place 1 at 4, 8, 16, 32 and 64; at 3 it climbs 3 a row and drops at 4, 6, 9, 14, 21, 31 and 47; at 7 there are 15 drops and the roll counts up 1 to 7 in a staircase. A new k redraws the table and starts the circle on top again.\n// Knob 4: Circle. The circle the top starts from, 8 to 64 lamps, and the row of the table that lights with it. After each survivor the next circle has one lamp more, so from 8 the top reaches 64 in 6 minutes at Speed 2, and after 64 it comes back to this one.\n\nconst W = 64, H = 128, NMAX = 64, TOP = 63;\nconst { floor, round, min, max, abs, sqrt, exp, atan2, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The circle: centre (32, 32) in LED units, lamps between radius 22 and\n// 30.5, the hand's marker just inside them, place 0 at twelve o'clock and\n// the places counting clockwise.\nconst CX = 32, CY = 32, R1 = 22, R2 = 30.5, HR0 = 18.8, HR1 = 21.2, BR = 17.5;\n// The rhythm roll inside the circle: one column per tick, newest on the\n// right, bars standing on row SB.\nconst SX0 = 14, SX1 = 49, SB = 43, SN = SX1 - SX0 + 1;\n// The hue of the first place out at knob 0, a deep blue.\nconst HUE0 = 0.7, WHITE = [1, 1, 1];\n\n// 3 x 5 digits, row by row from the top, three bits a row.\nconst FONT = [\n  0b111101101101111, 0b010110010010111, 0b111001111100111, 0b111001111001111, 0b101101111001001,\n  0b111100111001111, 0b111100111101111, 0b111001001001001, 0b111101111101111, 0b111101111001111,\n];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Every pixel of the top square that a lamp or the hand can light, with its\n// angle as a fraction of a turn clockwise from twelve and its radius.\nconst RING = (() => {\n  const idx = [], ang = [], rad = [];\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      if (r \u003c BR || r > R2 + 0.6) continue;\n      let a = atan2(dx, -dy) / (2 * PI);\n      if (a \u003c 0) a += 1;\n      idx.push(y * W + x), ang.push(a), rad.push(r);\n    }\n  return { idx: Int32Array.from(idx), ang: Float32Array.from(ang), rad: Float32Array.from(rad) };\n})();\n\n// The table: for each circle n = 1..64 and each place, the turn at which it\n// went out, 0 first and n - 1 the survivor. Counting starts at place 0 as 1,\n// the k-th lamp counted goes out and counting goes on from the next lamp\n// still lit, the same walk the hand makes on top; its survivor is J(n, k),\n// with J(1) = 0 and J(n) = (J(n - 1) + k) mod n.\nfunction table(k) {\n  const ord = [], surv = new Int32Array(NMAX + 1);\n  for (let n = 1; n \u003c= NMAX; n++) {\n    const o = new Int32Array(n), on = new Uint8Array(n).fill(1);\n    let left = n, count = 0, r = 0;\n    for (let j = 0; left > 1; j++) {\n      const q = j % n;\n      if (on[q] && ++count === k) (on[q] = 0), (o[q] = r++), (count = 0), left--;\n    }\n    surv[n] = on.indexOf(1);\n    o[surv[n]] = n - 1;\n    ord[n] = o;\n  }\n  return { ord, surv };\n}\n\n// A fresh circle of n lamps, all lit, the hand just before place 0.\nfunction begin(S, n) {\n  S.n = n, S.alive.fill(0), S.alive.fill(1, 0, n), S.left = n, S.count = 0;\n  S.j = 0, S.ph = 0.55, S.phase = n > 1 ? 0 : 1, S.ht = 0, S.born = S.t;\n  S.flash.fill(0), S.gone.fill(-9);\n  roll(S, -1);\n}\n\nfunction roll(S, mark, c) {\n  S.roll[S.rh] = mark;\n  if (c) S.rollc[S.rh * 3] = c[0], S.rollc[S.rh * 3 + 1] = c[1], S.rollc[S.rh * 3 + 2] = c[2];\n  S.rh = (S.rh + 1) % SN;\n}\n\n// The colour of place i of circle m by the turn it went out at: the first\n// ones out a deep blue, then teal and green to gold for the last ones out,\n// rising in light, and the survivor white.\nfunction cellColour(S, m, i, o) {\n  const r = S.tab.ord[m][i];\n  if (r >= m - 1) return (o[0] = 1), (o[1] = 1), (o[2] = 1), o;\n  const u = m > 2 ? r / (m - 2) : 0;\n  return hsv(HUE0 + S.hue - 0.56 * u, 0.9 - 0.3 * u, 0.17 + 0.56 * pow(u, 1.8), o);\n}\n\n// The hand reaches place j mod n: a lit lamp is a beat, the k-th beat puts\n// it out; a lamp already out is a rest.\nfunction tick(S) {\n  const q = S.j % S.n;\n  S.j++;\n  if (!S.alive[q]) return roll(S, 0);\n  S.count++;\n  S.flash[q] = 1;\n  if (S.count \u003c S.k) return roll(S, S.count);\n  S.alive[q] = 0, S.gone[q] = S.t, S.count = 0, S.left--;\n  roll(S, 9, cellColour(S, S.n, q, S.c));\n  if (S.left \u003c= 1) (S.phase = 1), (S.ht = 0);\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, k: 2, n0: 8, n: 8, alive: new Uint8Array(NMAX), flash: new Float32Array(NMAX),\n    gone: new Float32Array(NMAX), left: 8, count: 0, j: 0, ph: 0, phase: 0, ht: 0, born: 0,\n    roll: new Int8Array(SN).fill(-2), rollc: new Float32Array(SN * 3), rh: 0,\n    fb: new Float32Array(W * H * 3), lamp: new Float32Array(NMAX * 3), burst: new Float32Array(NMAX), c: [0, 0, 0], pale: [0, 0, 0], tab: table(2),\n  });\n  begin(S, 8);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 8], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const k = cl(round(kv[2]), 2, 7), n0 = cl(round(kv[3]), 8, NMAX);\n  if (k !== S.k) (S.k = k), (S.tab = table(k)), begin(S, S.n);\n  if (n0 !== S.n0) (S.n0 = n0), begin(S, n0);\n  for (let i = 0; i \u003c S.n; i++) S.flash[i] *= exp(-d / 0.09);\n  if (S.phase === 0) {\n    // Ticks a second: more for a bigger circle, and faster as it empties.\n    let left = d;\n    while (left > 0 && S.phase === 0) {\n      const rate = S.speed * (2 + S.n / 6) * sqrt(S.n / S.left), need = (1 - S.ph) / rate;\n      if (need > left) {\n        S.ph += left * rate;\n        break;\n      }\n      left -= need, S.ph = 0;\n      tick(S);\n    }\n  } else if ((S.ht += d) > 0.7 + 1.2 / S.speed) {\n    // The next circle has one lamp more; after 64 the top goes back to the\n    // circle the Circle knob names.\n    begin(S, S.n \u003c NMAX ? S.n + 1 : S.n0);\n  }\n}\n\nfunction add(fb, p, r, g, b, a) {\n  fb[p * 3] += r * a, fb[p * 3 + 1] += g * a, fb[p * 3 + 2] += b * a;\n}\n\n// A number in doubled 3 x 5 digits, centred on column cx, its top on row y.\nfunction number(fb, v, cx, y, col, a) {\n  const str = String(v), x0 = round(cx - (str.length * 8 - 2) / 2);\n  for (let d = 0; d \u003c str.length; d++) {\n    const g = FONT[str.charCodeAt(d) - 48];\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++)\n        if ((g >> (14 - r * 3 - q)) & 1)\n          for (let e = 0; e \u003c 4; e++) add(fb, (y + r * 2 + (e >> 1)) * W + x0 + d * 8 + q * 2 + (e & 1), col[0], col[1], col[2], a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const fb = S.fb, c = S.c, n = S.n, t = S.t, lamp = S.lamp;\n  fb.fill(0);\n  // Lamps still lit are a cool white that the hue knob tints a little.\n  const pale = hsv(HUE0 + S.hue - 0.1, 0.14, 0.9, S.pale);\n  const fin = S.phase === 1, glow = fin ? 0.8 + 0.2 * Math.cos(S.ht * 9) : 0;\n  const fresh = cl((t - S.born) / 0.25, 0, 1);\n\n  // Lamp colours for this frame.\n  for (let i = 0; i \u003c n; i++) {\n    let r, g, b;\n    if (S.alive[i]) {\n      const f = S.flash[i], v = fin ? glow : (0.5 + 0.5 * f) * fresh;\n      r = fin ? 1 : pale[0] + (1 - pale[0]) * f, g = fin ? 0.97 : pale[1] + (1 - pale[1]) * f, b = fin ? 0.9 : pale[2] + (1 - pale[2]) * f;\n      r *= v, g *= v, b *= v;\n    } else {\n      cellColour(S, n, i, c);\n      const a = exp(-(t - S.gone[i]) / 0.22), dim = fin ? 0.7 : 0.42;\n      r = c[0] * dim + a, g = c[1] * dim + a * 0.95, b = c[2] * dim + a * 0.9;\n    }\n    lamp[i * 3] = r, lamp[i * 3 + 1] = g, lamp[i * 3 + 2] = b;\n    S.burst[i] = S.alive[i] ? 0 : exp(-(t - S.gone[i]) / 0.2);\n  }\n\n  // The lamps, as n wedges of the ring with a gap of about one LED between\n  // them, a lamp put out bursting inward for a moment, and the hand as a\n  // short bright mark just inside them.\n  const hand = fin ? -1 : (((S.j - 1 + S.ph) % n) + n) % n;\n  const I = RING.idx, A = RING.ang, RR = RING.rad;\n  for (let q = 0; q \u003c I.length; q++) {\n    const r = RR[q], p = I[q];\n    const u = A[q] * n + 0.5, i = floor(u) % n, f = u - floor(u);\n    const side = cl(min(f, 1 - f) * ((2 * PI * r) / n) - 0.1, 0, 1);\n    if (r >= R1 - 0.5) {\n      const a = side * cl(r - R1 + 0.5, 0, 1) * cl(R2 - r + 0.5, 0, 1);\n      if (a > 0) add(fb, p, lamp[i * 3], lamp[i * 3 + 1], lamp[i * 3 + 2], a);\n      continue;\n    }\n    if (S.burst[i] > 0.02) add(fb, p, 1, 0.95, 0.9, S.burst[i] * side * (0.35 + 0.65 * cl((r - BR) / (R1 - BR), 0, 1)));\n    if (hand >= 0 && r >= HR0 && r \u003c= HR1) {\n      let da = abs(A[q] - hand / n);\n      if (da > 0.5) da = 1 - da;\n      const a = cl(1.7 - da * 2 * PI * r, 0, 1);\n      if (a > 0) add(fb, p, 1, 1, 1, a * 0.9);\n    }\n  }\n\n  // The circle's size on top inside the ring, and once it is down to one\n  // lamp the survivor's place counted from 1, in white.\n  if (fin) number(fb, S.tab.surv[n] + 1, CX, 15, WHITE, glow);\n  else number(fb, n, CX, 15, pale, 0.55);\n\n  // The rhythm roll: a rest is a dot, a beat a bar as tall as its count, the\n  // k-th beat a full bar in the colour of the lamp it put out; a new circle\n  // leaves a dotted rule.\n  for (let s = 0; s \u003c SN; s++) {\n    const h = (S.rh + s) % SN, m = S.roll[h], x = SX0 + s, v = 0.3 + 0.7 * ((s + 1) / SN);\n    if (m === -2) continue;\n    if (m === -1) for (let y = SB - 12; y \u003c= SB; y += 2) add(fb, y * W + x, 0.35, 0.35, 0.4, v);\n    else if (m === 0) add(fb, SB * W + x, 0.4, 0.38, 0.36, v);\n    else if (m \u003c 9) {\n      const bh = 1 + round((10 * m) / S.k);\n      for (let y = SB - bh + 1; y \u003c= SB; y++) add(fb, y * W + x, pale[0], pale[1], pale[2], v * 0.8);\n    } else {\n      const rc = S.rollc;\n      for (let y = SB - 12; y \u003c= SB; y++) add(fb, y * W + x, rc[h * 3] * 0.6 + 0.4, rc[h * 3 + 1] * 0.6 + 0.4, rc[h * 3 + 2] * 0.6 + 0.4, v);\n    }\n  }\n\n  // The table: circle m on panel row 63 + m, place i in column i, the\n  // current row lit and filling in as the circle plays it, with the hand\n  // as a white cell.\n  for (let m = 1; m \u003c= NMAX; m++) {\n    const y = TOP + m, cur = m === n, gain = cur ? 1 : 0.9;\n    for (let i = 0; i \u003c m; i++) {\n      const p = y * W + i;\n      if (cur && S.alive[i] && !fin) {\n        add(fb, p, pale[0], pale[1], pale[2], 0.55 * fresh + 0.45 * S.flash[i]);\n        continue;\n      }\n      cellColour(S, m, i, c);\n      let a = gain;\n      if (cur && !fin) a += exp(-(t - S.gone[i]) / 0.22);\n      if (cur && fin && S.tab.surv[m] === i) a = 0.5 + 0.7 * glow;\n      add(fb, p, c[0], c[1], c[2], a);\n    }\n    if (cur) {\n      // The current row runs out to the right edge as a dotted line.\n      for (let x = m + 1; x \u003c W; x += 2) add(fb, y * W + x, pale[0], pale[1], pale[2], 0.35);\n      if (hand >= 0) add(fb, y * W + (round(hand) % m), 1, 1, 1, 1);\n    }\n  }\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, fb[k] * 255) | 0, min(255, fb[k + 1] * 255) | 0, min(255, fb[k + 2] * 255) | 0);\n    }\n}\n","ogham":"// ===== Patternflow pattern =====\n// Title:   Ogham\n// Family:  type\n// Idea:    A standing stone is seen corner-on with its edge running up the whole panel as the stemline, and an Ogham inscription is cut into it stroke by stroke from the bottom up, one to five strokes a letter, the B aicme on the right face, the H aicme on the left, the M aicme slanting across the edge from one face onto the other and the vowels notched on the edge itself, while a small Latin letter beside each group counts its strokes as they land (B, L, F, S, then N for five on the right) and the view climbs the stone with the chisel near the top, each cut a groove of a lit lower wall and a shaded upper one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Ogham alphabet of four aicmí of five letters as the Ogam tract of the Book of Ballymote sets it out (George Calder, Auraicept na n-Éces, 1917), its Old Irish letter names and the MAQI and MUCOI of the Primitive Irish memorial stones (Damian McManus, A Guide to Ogam, 1991); Typewriter's 3 by 5 capitals (pattern round 18); pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Turn=-1..1\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the cuts are pale gold on blue-grey slate, at 0.5 pale blue on a brown sandstone, the gloss letters a whiter tint of the cuts.\n// Knob 2: Speed. Strokes cut a second: 5 at the opening 2, 0.8 at 0.2, 13.6 at 3. Every fresh stone has its first 100 rows (the whole B aicme of the alphabet) cut at 25 a second, in 0.9 s, so the writing stands the panel's height at once; at 2 the alphabet's 60 strokes are done at 12.9 s (74 s at 0.2, 5.3 s at 3), then the stone holds 3 s with its top in view and a fresh one is started.\n// Knob 3: Text. Which inscription, each on its own stone: 0 the twenty letters in their four aicmí, 60 strokes over 380 rows of stone; 1 the four aicme names BEITHE HUATHA MUINE AILME, 59 strokes of which 40 are vowel notches; 2 the formula words ANM MAQI MUCOI, 34 strokes; 3 the Old Irish names of the first aicme, BEITHE LUIS FERN SAIL NIN, 76 strokes over 460 rows.\n// Knob 4: Turn. Turns the stone about its upright axis, 13 degrees at the opening 0.06 so the left face shows wider, 40 degrees each way at the ends: at -1 the right face comes round to you and the left one shrinks to a sliver, at 1 the reverse, and the strokes on the turning face shorten while the slanting M strokes kink at the edge.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The alphabet. Four aicmí (\"families\") of five letters, each letter\n// one to five strokes: the B aicme to the right of the stemline as it is\n// read upward, the H aicme to the left, the M aicme slanting across it, the\n// vowels notched on it. On a stone the stemline is the arris itself. The\n// third letter is F as the manuscripts give fern; the oldest stones wrote V\n// with it.\nconst AICME = [\n  [\"B\", \"L\", \"F\", \"S\", \"N\"],\n  [\"H\", \"D\", \"T\", \"C\", \"Q\"],\n  [\"M\", \"G\", \"NG\", \"Z\", \"R\"],\n  [\"A\", \"O\", \"U\", \"E\", \"I\"],\n];\nconst WHERE = {};\nAICME.forEach((a, g) => a.forEach((L, i) => (WHERE[L] = [g, i + 1])));\n// The inscriptions, a word to a group of letters. The alphabet in aicme\n// order; the aicmí named after their first letters; the words of the\n// memorial stones, ANM (\"name\") that opens some and the MAQI (\"son of\") and\n// MUCOI (\"of the kin of\") of X MAQI Y MUCOI Z, without any names; the Old\n// Irish names of the first five letters.\nconst TEXTS = [\n  [\"BLFSN\", \"HDTCQ\", \"MGNGZR\", \"AOUEI\"],\n  [\"BEITHE\", \"HUATHA\", \"MUINE\", \"AILME\"],\n  [\"ANM\", \"MAQI\", \"MUCOI\"],\n  [\"BEITHE\", \"LUIS\", \"FERN\", \"SAIL\", \"NIN\"],\n];\nconst parse = (w) => {\n  const out = [];\n  for (let i = 0; i \u003c w.length; i++) {\n    if (w[i] === \"N\" && w[i + 1] === \"G\") out.push(\"NG\"), i++;\n    else out.push(w[i]);\n  }\n  return out;\n};\n\n// Typewriter's 3 by 5 capitals (pattern round 18), the letters the gloss needs.\nconst FONT = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\", E: \"111100110100111\",\n  F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\", I: \"111010010010111\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", Q: \"010101101111011\", R: \"110101110101101\",\n  S: \"011100010001110\", T: \"111010010010010\", U: \"101101101101011\", Z: \"111001010100111\",\n};\n\n// ---- The stone: a square pillar seen corner-on, its axis at column CX, its\n// half diagonal one of RS, a stone to each text; heights v in rows, the\n// view climbing the stone with the chisel a whole row at a time so every\n// cut lands on one row of LEDs.\nconst CX = 35.5, RS = [24, 22.5, 25.5, 23.5], CAM0 = -10, VOFF = 40;\nconst PITCH = 4, LGAP = 10, WGAP = 20, BASE = 9;\n// How far each aicme's strokes reach along a face, in face units (one\n// unit is one LED when the face is square to you), and the M slant.\nconst REACH = [16, 16, 9, 2.4], SLANT = 0.42, CUT = 0.62;\n// A fresh stone's first RUN rows are cut at RUSH strokes a second, so the\n// writing stands the panel's height within a second; then the chisel goes\n// at the Speed knob's pace with the view holding it LEAD rows below the top.\nconst RUN = 100, RUSH = 25, LEAD = 116;\n\nconst hash = (a, b, c) => {\n  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  h = Math.imul(h ^ (h >>> 16), 2246822519);\n  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n};\n\nfunction newStone(S, ti) {\n  const letters = [], cuts = [];\n  let v = BASE - LGAP, t = 0.3;\n  TEXTS[ti].forEach((word, wi) => {\n    if (wi) (v += WGAP - LGAP), (t += 1.4);\n    for (const L of parse(word)) {\n      const [g, n] = WHERE[L];\n      v += LGAP;\n      if (letters.length) t += 0.9;\n      const v0 = v, first = cuts.length;\n      for (let i = 0; i \u003c n; i++) {\n        if (i) v += PITCH;\n        cuts.push({ g, v, t0: t, li: letters.length });\n        t += 1;\n      }\n      letters.push({ L, g, n, mid: (v0 + v) / 2, first });\n    }\n  });\n  S.letters = letters;\n  S.cuts = cuts;\n  S.end = t + 0.4;\n  S.top = v + 20;\n  S.r = RS[ti];\n  S.side = S.r * Math.SQRT2;\n  // Each face's grain: coarse blotches, a finer mottle and single-LED\n  // speckle, and the jagged line of its top, highest at the edge.\n  const U = ceil(S.side) + 2, V = S.top + VOFF + 30;\n  S.U = U;\n  S.V = V;\n  S.tex = [0, 1].map((f) => {\n    const T = new Float32Array(U * V);\n    const val = (gx, gy, sc, k) => {\n      const x = gx / sc, y = gy / sc, x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n      const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);\n      const a = hash(x0, y0, k), b = hash(x0 + 1, y0, k), c = hash(x0, y0 + 1, k), d = hash(x0 + 1, y0 + 1, k);\n      return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n    };\n    const seed = ti * 4 + f * 2 + 1;\n    for (let y = 0; y \u003c V; y++)\n      for (let x = 0; x \u003c U; x++)\n        T[y * U + x] = 0.62 + 0.42 * val(x, y, 9, seed) + 0.26 * val(x, y, 3, seed + 40) + 0.2 * hash(x, y, seed + 80);\n    return T;\n  });\n  S.tops = [0, 1].map((f) => {\n    const T = new Float32Array(U);\n    for (let u = 0; u \u003c U; u++) T[u] = S.top - 12 * (u / S.side) ** 2 - 2.5 * hash(u >> 1, f, ti + 9);\n    return T;\n  });\n  S.t = 0;\n  S.cam = CAM0;\n  S.phase = 0;\n  S.parts = [];\n  S.ci = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = { ti: -1, hue: 0, rate: 5, turn: 0, dim: 1, emit: 0 });\n  S.Cov = new Float32Array(W * H);\n  S.Fre = new Float32Array(W * H);\n  S.Wl = new Float32Array(W * H);\n  S.F = new Float32Array(W * H * 3);\n  S.colF = new Int8Array(W);\n  S.colU = new Float32Array(W);\n}\n\n// The cut in progress: the last one whose time has come.\nfunction current(S) {\n  const c = S.cuts;\n  let i = S.ci || 0;\n  if (i >= c.length || c[i].t0 > S.t) i = 0;\n  while (i + 1 \u003c c.length && c[i + 1].t0 \u003c= S.t) i++;\n  S.ci = i;\n  return i;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = 5 * exp(cl(k[1], 0.2, 3) - 2);\n  S.turn = cl(k[3] || 0, -1, 1);\n  const ti = round(cl(k[2] || 0, 0, 3));\n  if (ti !== S.ti) {\n    S.ti = ti;\n    newStone(S, ti);\n  }\n  // Carve, hold the finished stone with its top in view, darken, and\n  // start again on a fresh one.\n  let target;\n  if (S.phase === 0) {\n    const i = current(S), c = S.cuts[i], n = S.cuts[min(i + 1, S.cuts.length - 1)];\n    S.t += dt * (c.v \u003c RUN ? max(S.rate, RUSH) : S.rate);\n    S.dim = min(1, S.dim + dt / 0.5);\n    // The view aims between this cut and the next, so it climbs evenly.\n    const a = n === c ? 0 : cl((S.t - c.t0) / (n.t0 - c.t0), 0, 1);\n    target = c.v + (n.v - c.v) * a + REACH[2] * SLANT - LEAD;\n    if (S.t >= S.end) (S.phase = 1), (S.hold = 0);\n  } else {\n    target = S.top - 112;\n    S.hold += dt;\n    if (S.hold > 3) S.dim -= dt / 0.7;\n    if (S.dim \u003c= 0) {\n      S.dim = 0;\n      newStone(S, S.ti);\n    }\n  }\n  S.cam += (max(CAM0, target) - S.cam) * (1 - exp(-dt * 6));\n  // Stone dust off the chisel, in panel columns and stone rows.\n  const P = S.parts;\n  for (const p of P) {\n    p.x += p.vx * dt;\n    p.v += p.vv * dt;\n    p.vv -= 60 * dt;\n    p.life -= dt;\n  }\n  if (P.length && P[0].life \u003c= 0) S.parts = P.filter((p) => p.life > 0);\n  if (S.tip) {\n    S.emit += dt * 30;\n    while (S.emit >= 1) {\n      S.emit -= 1;\n      const sd = S.tip[2];\n      S.parts.push({ x: S.tip[0], v: S.tip[1], vx: sd * (6 + 14 * Math.random()) + 6 * (Math.random() - 0.5), vv: 4 + 14 * Math.random(), life: 0.3 + 0.4 * Math.random() });\n    }\n  }\n}\n\n// One straight piece of a cut as a capsule of radius rad. A cut is a groove\n// with two walls: under light from above, the lower wall faces up and is\n// lit (the cover buffer, its freshness alongside) and the upper wall a row\n// above it faces down into shade (the wall buffer).\nfunction seg(S, a, b, rad, fresh) {\n  const [ax, ay] = a, [bx, by] = b;\n  const x0 = max(0, floor(min(ax, bx) - rad - 1)), x1 = min(W - 1, ceil(max(ax, bx) + rad + 1));\n  const y0 = max(1, floor(min(ay, by) - rad - 1)), y1 = min(H - 1, ceil(max(ay, by) + rad + 1));\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay;\n      const u = L2 ? cl((px * dx + py * dy) / L2, 0, 1) : 0;\n      const ex = px - u * dx, ey = py - u * dy;\n      const c = cl(rad + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (c \u003c= 0) continue;\n      const o = y * W + x;\n      if (c > S.Cov[o]) S.Cov[o] = c;\n      if (c * fresh > S.Fre[o]) S.Fre[o] = c * fresh;\n      if (c > S.Wl[o - W]) S.Wl[o - W] = c;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cuts) return;\n  const { Cov, Fre, Wl, F, colF, colU } = S;\n  Cov.fill(0);\n  Fre.fill(0);\n  Wl.fill(0);\n  F.fill(0);\n  // The edge and the far corners across the panel, and how much of a face\n  // unit each face shows: cos(45 degrees + turn) on the right, cos(45 - turn)\n  // on the left.\n  const th = 0.7 * S.turn + 0.18 * (1 - S.turn * S.turn), r = S.r, side = S.side, ve = round(S.cam) + 64;\n  const sF = CX + r * sin(th), sR = CX + r * cos(th), sL = CX - r * cos(th);\n  const cs = [cos(PI / 4 + th), -cos(PI / 4 - th)];\n  const P = (f, u, v) => [sF + u * cs[f], 63.5 - (v - ve)];\n  // Each panel column: its face and how far along it.\n  for (let x = 0; x \u003c W; x++) {\n    const X = x + 0.5, f = X >= sF && X \u003c sR ? 0 : X \u003c sF && X >= sL ? 1 : -1;\n    colF[x] = f;\n    if (f >= 0) colU[x] = (X - sF) / cs[f];\n  }\n  const lit = (a) => 0.36 + 0.64 * max(0, (-0.55 * sin(a) + 0.8 * cos(a)) / 0.971);\n  const shade = [lit(th + PI / 4), lit(th - PI / 4)];\n  const hue = S.hue;\n  const stone = hsv(hue + 0.58, 0.3, 84), cutC = hsv(hue + 0.13, 0.42, 245), gloss = hsv(hue + 0.13, 0.18, 230);\n  const sky = hsv(hue + 0.62, 0.7, 1);\n  const Ye = (v) => 63.5 - (v - ve);\n\n  // ---- The cuts. Strokes start at the edge and run out along a face; an\n  // M stroke runs from the left face across the edge onto the right one.\n  const ci = S.phase === 0 ? current(S) : -1;\n  S.tip = null;\n  for (let i = 0; i \u003c S.cuts.length; i++) {\n    const c = S.cuts[i];\n    if (c.t0 > S.t) break;\n    const yc = Ye(c.v);\n    if (yc \u003c -12 || yc > H + 12) continue;\n    const p = cl((S.t - c.t0) / CUT, 0, 1);\n    const fresh = p \u003c 1 ? 1 : exp(-(S.t - c.t0 - CUT) / S.rate / 0.9);\n    const L = REACH[c.g], E = P(0, 0, c.v);\n    let tip, sd = 1;\n    if (c.g \u003c 2) {\n      tip = P(c.g, L * p, c.v);\n      sd = c.g ? -1 : 1;\n      seg(S, E, tip, 0.5, fresh);\n    } else if (c.g === 2) {\n      const a = P(1, L, c.v - L * SLANT), e = P(1, 0, c.v);\n      if (p \u003c= 0.5) {\n        tip = P(1, L * (1 - 2 * p), c.v - L * SLANT * (1 - 2 * p));\n        sd = -1;\n        seg(S, a, tip, 0.5, fresh);\n      } else {\n        tip = P(0, L * (2 * p - 1), c.v + L * SLANT * (2 * p - 1));\n        seg(S, a, e, 0.5, fresh);\n        seg(S, E, tip, 0.5, fresh);\n      }\n    } else {\n      tip = P(0, L * p, c.v);\n      seg(S, P(1, L * p, c.v), tip, 0.5, fresh);\n    }\n    if (i === ci && p \u003c 1) S.tip = [tip[0], ve + 63.5 - tip[1], sd];\n  }\n\n  // ---- Stone, sky and the cuts over them.\n  const top0 = S.tops;\n  for (let x = 0; x \u003c W; x++) {\n    const f = colF[x], u = colU[x], ui = f \u003c 0 ? 0 : min(S.U - 1, max(0, floor(u)));\n    // Lighter towards the edge, which stands nearest, and the edge itself\n    // catching the light along its whole height.\n    const e = abs(x + 0.5 - sF), edge = e \u003c 1.3 ? 0.45 * (1.3 - e) : 0, near = f \u003c 0 ? 0 : 1 - 0.3 * (u / side) ** 1.5;\n    for (let y = 0; y \u003c H; y++) {\n      const o = y * W + x;\n      const v = ve + 63 - y;\n      let R, G, B;\n      if (f \u003c 0 || v > top0[f][ui]) {\n        const s = 3 + 7 * (y / H);\n        R = sky[0] * s;\n        G = sky[1] * s;\n        B = sky[2] * s;\n      } else {\n        const vi = cl(floor(v) + VOFF, 0, S.V - 1);\n        const l = shade[f] * near * S.tex[f][vi * S.U + ui] + edge;\n        const c = Cov[o], w = Wl[o] * (1 - c), fr = Fre[o], fw = y \u003c H - 1 ? 0.5 * Fre[o + W] : 0;\n        const cc = (0.7 + 0.3 * shade[f]) * (1 - fr), cw = 0.4 * (0.7 + 0.3 * shade[f]) * (1 - fw);\n        R = stone[0] * l * (1 - c - w) + c * (cutC[0] * cc + 255 * fr) + w * (cutC[0] * cw + 200 * fw);\n        G = stone[1] * l * (1 - c - w) + c * (cutC[1] * cc + 255 * fr) + w * (cutC[1] * cw + 200 * fw);\n        B = stone[2] * l * (1 - c - w) + c * (cutC[2] * cc + 250 * fr) + w * (cutC[2] * cw + 200 * fw);\n      }\n      F[o * 3] = R;\n      F[o * 3 + 1] = G;\n      F[o * 3 + 2] = B;\n    }\n  }\n  const add = (x, y, c, a) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    F[o] += c[0] * a;\n    F[o + 1] += c[1] * a;\n    F[o + 2] += c[2] * a;\n  };\n\n  // ---- The chisel point and its dust.\n  if (S.tip) {\n    const tx = S.tip[0], ty = Ye(S.tip[1]), fl = 0.75 + 0.25 * Math.random();\n    for (let dy = -3; dy \u003c= 3; dy++)\n      for (let dx = -3; dx \u003c= 3; dx++) {\n        const d = sqrt((dx + 0.5 - (tx - floor(tx))) ** 2 + (dy + 0.5 - (ty - floor(ty))) ** 2);\n        const a = cl(1 - d / 3, 0, 1);\n        if (a > 0) add(tx + dx, ty + dy, [255, 245, 220], a * a * fl);\n      }\n  }\n  for (const p of S.parts) add(p.x, Ye(p.v), gloss, 0.8 * min(1, p.life / 0.3));\n\n  // ---- The gloss: beside each letter, the letter its strokes spell so\n  // far, so a five-stroke N reads B, L, F, S and then N as it is cut.\n  for (const Lt of S.letters) {\n    const yc = Ye(Lt.mid);\n    if (yc \u003c -4 || yc > H + 4) continue;\n    let done = 0, last = -1;\n    for (let j = 0; j \u003c Lt.n; j++) {\n      const c = S.cuts[Lt.first + j];\n      if (S.t >= c.t0 + CUT) (done = j + 1), (last = c.t0 + CUT);\n    }\n    if (!done) continue;\n    const key = AICME[Lt.g][done - 1], age = (S.t - last) / S.rate;\n    const a = done === Lt.n ? 0.75 + 0.25 * exp(-age / 0.6) : 1;\n    const col = done === Lt.n ? gloss : [255, 250, 240];\n    let x0 = 4 - ((key.length * 4 - 1) >> 1);\n    const y0 = round(yc - 3);\n    for (const ch of key) {\n      const b = FONT[ch];\n      for (let j = 0; j \u003c 15; j++) if (b[j] === \"1\") add(x0 + (j % 3), y0 + floor(j / 3), col, a);\n      x0 += 4;\n    }\n  }\n\n  const g0 = S.dim;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(min(255, F[o] * g0)), round(min(255, F[o + 1] * g0)), round(min(255, F[o + 2] * g0)));\n}\n","palimpsest":"// ===== Patternflow pattern =====\n// Title:   Palimpsest\n// Family:  type\n// Idea:    A parchment leaf carries two Greek texts at right angles, a prayer written across the page in brown iron-gall ink over a scraped-off treatise of Archimedes that runs down it, and the imaging band sweeps from plain light, where the old text is a faint ghost, to ultraviolet, where the parchment glows and the old ink shows dark, to the pseudocolour view that turns the old text red and leaves the prayer dark, while an X-ray beam rasters down the leaf and lights the iron of both inks behind it.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Archimedes Palimpsest (Archimedes' treatises copied in the 10th century, scraped and written over as a prayer book in 1229; multispectral imaging by Roger Easton, Keith Knox and William Christens-Barry and X-ray fluorescence imaging by Uwe Bergmann in the 2000s), Greek minuscule drawn for this pattern, pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Band=0..1, Speed=0.2..3, Page=0..3, Ink=-1..1\n//\n// Knob 1: Band. The light the leaf is seen in. 0 to 0.15 is plain light: ivory parchment, brown prayer, the old text an ochre ghost 8% darker than the page in red and 25% in blue. 0.4 to 0.6 is ultraviolet: the parchment glows blue and the iron in both inks puts the glow out, the prayer down to 42% of the page and the old text to 65%. 0.85 to 1 is pseudocolour: the red-light picture in the red channel and the ultraviolet one in green and blue, so the old text, pale in red and dark in ultraviolet, comes out red, and the prayer, dark in both, near black. Between, one picture fades into the next.\n// Knob 2: Speed. How fast the X-ray beam steps down the leaf, a spot running along it: 26 rows a second at 2, a pass every 6.5 s; 2.6 rows a second at 0.2. For about 16 rows behind the beam the leaf shows its iron map, both inks pale blue on near black, the scraped text as plain as the prayer.\n// Knob 3: Page. Which pair of texts, rounded to 0 to 3. 0: the Trisagion over the title of the Method. 1: the Lord's Prayer over the title and first words of the Measurement of a Circle. 2: Kyrie eleison over On Floating Bodies. 3: Glory to thee, our God over the Stomachion.\n// Knob 4: Ink. How much of the old ink the scraper left and how far both inks have bled into the parchment. At -1 the prayer's strokes spread 0.5 LED and the old text's 0.35, and even in ultraviolet the old text is a thin line at 75% of the page; at 1 they spread 0.8 and 0.95 LED and the old text shows ochre-brown in plain light, 21% darker than the page in red and 59% in blue.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Greek minuscule, at most 5 LEDs wide on 9 rows: 0 and 1 hold ascenders,\n// 2 to 6 the body, 7 and 8 descenders. Each glyph is its first inked row and\n// then its rows downward. No accents or breathings.\nconst FONT = {\n  α: [2, \".##.#\", \"#..#.\", \"#..#.\", \"#..#.\", \".##.#\"],\n  β: [0, \".##.\", \"#..#\", \"#..#\", \"###.\", \"#..#\", \"#..#\", \"###.\", \"#...\", \"#...\"],\n  γ: [2, \"#...#\", \".#.#.\", \".#.#.\", \"..#..\", \"..#..\", \".#.#.\", \"..#..\"],\n  δ: [0, \".###\", \"#...\", \".##.\", \"#..#\", \"#..#\", \"#..#\", \".##.\"],\n  ε: [2, \".###\", \"#...\", \"###.\", \"#...\", \".###\"],\n  ζ: [0, \"####\", \"..#.\", \".#..\", \"#...\", \"#...\", \"#...\", \".##.\", \"...#\", \"..#.\"],\n  η: [2, \"###.\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"...#\", \"...#\"],\n  θ: [0, \".##.\", \"#..#\", \"#..#\", \"####\", \"#..#\", \"#..#\", \".##.\"],\n  ι: [2, \"#.\", \"#.\", \"#.\", \"#.\", \".#\"],\n  κ: [2, \"#..#\", \"#.#.\", \"##..\", \"#.#.\", \"#..#\"],\n  λ: [0, \"#....\", \"#....\", \".#...\", \".#...\", \"..#..\", \".#.#.\", \"#...#\"],\n  μ: [2, \"#..#.\", \"#..#.\", \"#..#.\", \"#..#.\", \"###.#\", \"#....\", \"#....\"],\n  ν: [2, \"#...#\", \"#...#\", \".#..#\", \".#.#.\", \"..#..\"],\n  ξ: [0, \"####\", \".#..\", \"..#.\", \".##.\", \"#...\", \"#...\", \".##.\", \"...#\", \"..#.\"],\n  ο: [2, \".##.\", \"#..#\", \"#..#\", \"#..#\", \".##.\"],\n  π: [2, \"#####\", \".#.#.\", \".#.#.\", \".#.#.\", \".#.#.\"],\n  ρ: [2, \".##.\", \"#..#\", \"#..#\", \"#..#\", \"###.\", \"#...\", \"#...\"],\n  σ: [2, \".####\", \"#..#.\", \"#..#.\", \"#..#.\", \".##..\"],\n  ς: [2, \".###\", \"#...\", \"#...\", \".##.\", \"...#\", \"..#.\"],\n  τ: [2, \"####\", \".#..\", \".#..\", \".#..\", \"..##\"],\n  υ: [2, \"#..#\", \"#..#\", \"#..#\", \"#..#\", \".##.\"],\n  φ: [0, \"..#..\", \"..#..\", \".###.\", \"#.#.#\", \"#.#.#\", \"#.#.#\", \".###.\", \"..#..\", \"..#..\"],\n  χ: [2, \"#...#\", \".#.#.\", \"..#..\", \".#.#.\", \"#...#\"],\n  ψ: [0, \"..#..\", \"..#..\", \"#.#.#\", \"#.#.#\", \"#.#.#\", \".###.\", \"..#..\", \"..#..\", \"..#..\"],\n  ω: [2, \"#...#\", \"#...#\", \"#.#.#\", \"#.#.#\", \".#.#.\"],\n};\nconst GLYPH = {};\nfor (const ch in FONT) {\n  const [top, ...rows] = FONT[ch];\n  const w = max(...rows.map((r) => r.length)), px = [];\n  rows.forEach((r, j) => {\n    for (let i = 0; i \u003c r.length; i++) if (r[i] === \"#\") px.push(i, top + j);\n  });\n  GLYPH[ch] = { w, px };\n}\n\n// The pairs of texts: a prayer written across the leaf over the title or\n// opening words of one of Archimedes' treatises running down it. The words\n// repeat until the leaf is full. A sigma that ends a word is written final.\nconst PAGES = [\n  [\"αγιοσ ο θεοσ αγιοσ ισχυροσ αγιοσ αθανατοσ ελεησον ημασ\", \"περι των μηχανικων θεωρηματων προσ ερατοσθενη εφοδοσ\"],\n  [\"πατερ ημων ο εν τοισ ουρανοισ αγιασθητω το ονομα σου ελθετω η βασιλεια σου\", \"κυκλου μετρησισ πασ κυκλοσ ισοσ εστι τριγωνω ορθογωνιω\"],\n  [\"κυριε ελεησον\", \"περι οχουμενων\"],\n  [\"δοξα σοι ο θεοσ ημων δοξα σοι\", \"στομαχιον\"],\n].map((pair) => pair.map((t) => t.split(\" \").map((w) => w.replace(/σ$/, \"ς\"))));\n\n// The prayer: 12 lines 10 LEDs apart, 60 LEDs long from x 2. The treatise:\n// 5 lines 12 LEDs apart, the first at the right, each 124 LEDs long from y 2,\n// its letters turned a quarter turn clockwise so it reads downward.\nconst LINE = 10, OVER_LINES = 12, UNDER_LINE = 12, UNDER_LINES = 5, SPACE = 3;\n// Plain light: the parchment's colour, how much of each channel the prayer's\n// ink takes at full strength, and the grain, a share of the page's level.\nconst VIS = [226, 208, 168], INK = [0.62, 0.72, 0.84], GRAIN = 0.08;\n\nfunction lay(words, len, lines, put) {\n  // The words run on without a break, as a scribe filled a line: a word\n  // that reaches the end of a line goes on at the start of the next.\n  const text = words.join(\" \") + \" \";\n  let i = 0, line = 0, pos = 0;\n  while (line \u003c lines) {\n    const ch = text[i++ % text.length];\n    if (ch === \" \") {\n      if (pos > 0) pos += SPACE;\n      continue;\n    }\n    const g = GLYPH[ch];\n    if (pos + g.w > len) (line++, (pos = 0));\n    if (line >= lines) break;\n    // Pen pressure: each letter its own weight.\n    put(g, line, pos, 0.8 + 0.2 * Math.random());\n    pos += g.w + 1;\n  }\n}\n\n// Separable Gaussian blur of src into dst, sigma in LEDs.\nfunction blur(src, dst, tmp, sigma) {\n  const r = Math.ceil(sigma * 2.5), k = [];\n  let sum = 0;\n  for (let i = -r; i \u003c= r; i++) (k.push(exp((-i * i) / (2 * sigma * sigma))), (sum += k[k.length - 1]));\n  for (let i = 0; i \u003c k.length; i++) k[i] /= sum;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let v = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const xx = x + i;\n        if (xx >= 0 && xx \u003c W) v += src[y * W + xx] * k[i + r];\n      }\n      tmp[y * W + x] = v;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let v = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const yy = y + i;\n        if (yy >= 0 && yy \u003c H) v += tmp[yy * W + x] * k[i + r];\n      }\n      dst[y * W + x] = v;\n    }\n}\n\n// Smooth value noise from a coarse random lattice, cell size c.\nfunction lattice(c) {\n  const gw = floor(W / c) + 2, gh = floor(H / c) + 2, g = new Float32Array(gw * gh), out = new Float32Array(N);\n  for (let i = 0; i \u003c g.length; i++) g[i] = Math.random() * 2 - 1;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const fx = x / c, fy = y / c, ix = floor(fx), iy = floor(fy), u = smooth(fx - ix), v = smooth(fy - iy);\n      const a = g[iy * gw + ix], b = g[iy * gw + ix + 1], d = g[(iy + 1) * gw + ix], e = g[(iy + 1) * gw + ix + 1];\n      out[y * W + x] = (a + (b - a) * u) * (1 - v) + (d + (e - d) * u) * v;\n    }\n  return out;\n}\n\n// Grain whose neighbours keep apart: white noise with its local mean taken\n// out twice, each time spread back evenly over -1..1 by rank, then cut into\n// three equal parts, -1, 0 and 1. It has no clumps, and two neighbours\n// differ by a whole step four times in five.\nfunction grain() {\n  let n = new Float32Array(N);\n  for (let p = 0; p \u003c N; p++) n[p] = Math.random();\n  const idx = new Int32Array(N);\n  for (let pass = 0; pass \u003c 2; pass++) {\n    const h = new Float32Array(N);\n    for (let p = 0; p \u003c N; p++) {\n      const x = p % W, y = floor(p / W);\n      h[p] = n[p] - 0.25 * (n[y * W + ((x + 1) % W)] + n[y * W + ((x + W - 1) % W)] + n[((y + 1) % H) * W + x] + n[((y + H - 1) % H) * W + x]);\n    }\n    for (let p = 0; p \u003c N; p++) idx[p] = p;\n    idx.sort((a, b) => h[a] - h[b]);\n    for (let r = 0; r \u003c N; r++) n[idx[r]] = ((r + 0.5) / N) * 2 - 1;\n  }\n  for (let p = 0; p \u003c N; p++) n[p] = n[p] > 1 / 3 ? 1 : n[p] \u003c -1 / 3 ? -1 : 0;\n  return n;\n}\n\nexport function setup(params) {\n  // The parchment: a slow mottle in 2% steps, fibres that drink the ink\n  // unevenly, and a leaf edge that has gone darker. The grain goes on in\n  // build(), where the ink is known.\n  const base = new Float32Array(N), vig = new Float32Array(N), fibre = new Float32Array(N);\n  const m1 = lattice(16), m2 = lattice(5), f = lattice(2);\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W);\n    const edge = min(x + 0.5, W - 0.5 - x, y + 0.5, H - 0.5 - y);\n    base[p] = round((0.9 + 0.06 * m1[p] + 0.035 * m2[p]) * 50) / 50;\n    vig[p] = 0.72 + 0.28 * smooth(edge / 4);\n    fibre[p] = 0.85 + 0.15 * f[p];\n  }\n  params.s = {\n    P: new Float32Array(N), base, vig, gr: grain(), fibre,\n    oMask: new Float32Array(N), uMask: new Float32Array(N), tmp: new Float32Array(N),\n    O: new Float32Array(N), U: new Float32Array(N), Fe: new Float32Array(N),\n    last: new Float32Array(N * 3), fade: 1,\n    page: -1, ink: 9, band: 0, speed: 2, T: 0, beam: -12,\n  };\n}\n\nfunction build(S, page, ink) {\n  const { oMask, uMask } = S;\n  if (page !== S.page) {\n    oMask.fill(0);\n    uMask.fill(0);\n    const [over, under] = PAGES[page];\n    lay(over, 60, OVER_LINES, (g, line, pos, wt) => {\n      for (let i = 0; i \u003c g.px.length; i += 2) {\n        const x = 2 + pos + g.px[i], y = 4 + line * LINE + g.px[i + 1];\n        if (x \u003c W && y \u003c H) oMask[y * W + x] = wt;\n      }\n    });\n    lay(under, 124, UNDER_LINES, (g, line, pos, wt) => {\n      const left = 51 - line * UNDER_LINE;\n      for (let i = 0; i \u003c g.px.length; i += 2) {\n        const x = left + 8 - g.px[i + 1], y = 2 + pos + g.px[i];\n        if (x >= 0 && y \u003c H) uMask[y * W + x] = wt;\n      }\n    });\n  }\n  const s = (ink + 1) / 2;\n  blur(oMask, S.O, S.tmp, 0.5 + 0.3 * s);\n  blur(uMask, S.U, S.tmp, 0.35 + 0.6 * s);\n  // The X-ray map sees the iron, not the colour: the old text's iron is\n  // still there where the scraper took the colour, and the beam is broader\n  // than a pen stroke.\n  const { O, U, Fe, tmp, fibre } = S;\n  const iron = 0.55 + 0.35 * s;\n  for (let p = 0; p \u003c N; p++) Fe[p] = oMask[p] + iron * uMask[p];\n  blur(Fe, Fe, tmp, 0.75);\n  for (let p = 0; p \u003c N; p++) {\n    O[p] = 1 - exp(-3.4 * O[p] * fibre[p]);\n    U[p] = 1 - exp(-2.8 * U[p] * fibre[p]);\n    Fe[p] = 1 - exp(-2.6 * Fe[p]);\n  }\n  // The grain, except on the flanks of a stroke, where the ink has\n  // soaked in and the step from page to ink is the texture.\n  const { P, base, vig, gr } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), o = O[p];\n    let d = 0;\n    if (x > 0) d = max(d, abs(o - O[p - 1]));\n    if (x \u003c W - 1) d = max(d, abs(o - O[p + 1]));\n    if (y > 0) d = max(d, abs(o - O[p - W]));\n    if (y \u003c H - 1) d = max(d, abs(o - O[p + W]));\n    P[p] = (base[p] + GRAIN * gr[p] * (1 - smooth(d / 0.5))) * vig[p];\n  }\n  S.page = page;\n  S.ink = ink;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.band = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.05, 3);\n  const page = cl(round(k[2]), 0, PAGES.length - 1);\n  const ink = cl(k[3], -1, 1);\n  if (page !== S.page || abs(ink - S.ink) > 0.015) {\n    if (S.page >= 0 && page !== S.page) S.fade = 0;\n    build(S, page, ink);\n  }\n  S.fade = min(1, S.fade + dt / 0.6);\n  S.T += dt;\n  // The beam steps down 13 rows a second per unit of Speed and starts again\n  // above the leaf once it has left the bottom.\n  S.beam += dt * 13 * S.speed;\n  if (S.beam > H + 30) S.beam -= H + 42;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (S.page \u003c 0) return;\n  const { P, O, U, Fe, gr, last, T } = S;\n  const s = (S.ink + 1) / 2;\n  // How much the old ink darkens each picture.\n  const aVis = 0.12 + 0.9 * s * s, aRed = 0.3 * aVis, qUV = 0.35 + 0.55 * s;\n  // Band weights: plain light, ultraviolet, pseudocolour.\n  const b = S.band;\n  const tU = smooth((b - 0.15) / 0.25), tP = smooth((b - 0.6) / 0.25);\n  const wV = 1 - tU, wP = tP, wU = tU - tP;\n  const beam = S.beam, spot = (T * 150) % (W + 20) - 10;\n  const fade = smooth(S.fade);\n  for (let y = 0; y \u003c H; y++) {\n    // The iron map behind the beam: full for 10 rows, then fading.\n    const d = beam - y;\n    const xr = d \u003c 0 ? exp(-d * d * 0.5) : d \u003c 10 ? 1 : exp(-(d - 10) / 6);\n    const line = abs(d) \u003c 2 ? 1 - abs(d) / 2 : 0;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, pa = P[p], o = O[p], u = U[p];\n      let r = 0, g = 0, bl = 0;\n      if (wV > 0) {\n        // Plain light: iron-gall brown absorbs blue more than red, and the\n        // faded old ink is a pale ochre.\n        r += wV * VIS[0] * pa * (1 - INK[0] * o) * (1 - 0.35 * aVis * u);\n        g += wV * VIS[1] * pa * (1 - INK[1] * o) * (1 - 0.6 * aVis * u);\n        bl += wV * VIS[2] * pa * (1 - INK[2] * o) * (1 - aVis * u);\n      }\n      // Ultraviolet: the parchment fluoresces; any iron left quenches it.\n      const F = pa * (1 - 0.88 * o) * (1 - qUV * u);\n      if (wU > 0) {\n        r += wU * (20 + 90 * F);\n        g += wU * (24 + 120 * F);\n        bl += wU * (40 + 200 * F);\n      }\n      if (wP > 0) {\n        // Pseudocolour: red light in red, ultraviolet in green and blue,\n        // both stretched the same way.\n        const R = cl((pa * (1 - 0.85 * o) * (1 - aRed * u) - 0.2) * 1.35, 0, 1);\n        const G = cl((F - 0.2) * 1.35, 0, 1);\n        r += wP * 216 * R;\n        g += wP * 196 * G;\n        bl += wP * 200 * G;\n      }\n      if (xr > 0.004) {\n        // X-ray fluorescence: iron in either ink, pale blue on near black.\n        // Counting noise: the map is speckled where there is little iron.\n        const fe = Fe[p], sn = (1 - fe) * gr[p];\n        const k2 = xr * (0.9 + 0.1 * pa);\n        r += k2 * (14 + 6 * sn + 112 * fe - r);\n        g += k2 * (22 + 9 * sn + 176 * fe - g);\n        bl += k2 * (44 + 16 * sn + 196 * fe - bl);\n      }\n      if (line > 0) {\n        const sp = abs(x - spot) \u003c 3 ? 1 - abs(x - spot) / 3 : 0;\n        r += line * (30 + 120 * sp);\n        g += line * (44 + 140 * sp);\n        bl += line * (52 + 150 * sp);\n      }\n      if (fade \u003c 1) {\n        r = last[p * 3] + (r - last[p * 3]) * fade;\n        g = last[p * 3 + 1] + (g - last[p * 3 + 1]) * fade;\n        bl = last[p * 3 + 2] + (bl - last[p * 3 + 2]) * fade;\n      } else {\n        last[p * 3] = r;\n        last[p * 3 + 1] = g;\n        last[p * 3 + 2] = bl;\n      }\n      display.setPixel(x, y, min(255, max(0, r)), min(255, max(0, g)), min(255, max(0, bl)));\n    }\n  }\n}\n","parallel-transport":"// ===== Patternflow pattern =====\n// Title:   Parallel Transport\n// Family:  space\n// Idea:    A lit globe turns on the upper half and a gold arrow is carried round a loop on it without ever turning, leaving ghost arrows behind and tinting the area its loop has swept, and when the loop closes the arrow stands beside its white starting self turned by exactly that area, which a dial on the lower half has been adding up all the way round.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: parallel transport (Tullio Levi-Civita, 1917), its holonomy as enclosed area by Gauss-Bonnet (Carl Friedrich Gauss, 1827; Pierre Ossian Bonnet, 1848), Foucault's pendulum (Léon Foucault, 1851), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Loop=0..3, Size=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the globe is blue, the arrow gold, the swept area rose and the area swept backwards sea green; the globe keeps to the hues from green to violet so it never dims to brown.\n// Knob 2: Speed. At 2 the arrow goes round its loop in 6 s, then holds 2.6 s and fades 0.6 s before it starts again; at 0.2 a lap takes 60 s, at 3 it takes 4 s.\n// Knob 3: Loop. 0 the triangle from the north pole down a meridian, along the equator and back up another, which turns the arrow by its angle at the pole; 1 a circle of latitude, which turns it by 2 pi (1 - sin latitude), the same as 2 pi sin latitude the other way, the turn of Foucault's pendulum in a sidereal day; 2 a small geodesic square, whose four corners are each a little over 90 degrees and turn it by their excess; 3 two circles touching at a point, the first run counterclockwise and the second clockwise, so their areas cancel.\n// Knob 4: Size. The triangle's angle at the pole from 10 to 170 degrees, 90 at the opening 0.06; the latitude from 8 degrees (turn 309.9) to 85 (turn 1.4), 48.85 at 0.06, the Pantheon in Paris, turn 88.9; the square's centre to corner from 2 degrees (turn 0.14) to 30 (turn 32.8), 8 at 0.06, turn 2.2; the two circles 11 and 33 degrees at -1 (turn -51.5), both 22 at 0.06 (turn 0), 33 and 11 at 1 (turn 51.5).\n\nconst W = 64, H = 128, TOP = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, acos, asin, exp, log, round, PI } = Math;\nconst TAU = 2 * PI, DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst fr = (x) => x - floor(x);\nconst wrap = (a) => a - TAU * round(a / TAU);\n\nfunction hsv(h, s, v, o) {\n  h = fr(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Points and tangent vectors are plain [x, y, z] on the unit sphere, z north.\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst crs = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst nrm = (a) => {\n  const l = sqrt(dot(a, a)) || 1;\n  return [a[0] / l, a[1] / l, a[2] / l];\n};\nconst lin = (a, ka, b, kb) => [a[0] * ka + b[0] * kb, a[1] * ka + b[1] * kb, a[2] * ka + b[2] * kb];\nconst sph = (lat, lon) => [cos(lat) * cos(lon), cos(lat) * sin(lon), sin(lat)];\n\n// Parallel transport of a tangent vector v at a along the great circle to b.\n// It is the rotation about a x b that takes a to b, so it is exact for any\n// step; a loop sampled at 900 points is carried exactly round the geodesic\n// polygon through them.\nfunction carry(a, b, v) {\n  const d = dot(v, b) / (1 + dot(a, b));\n  return [v[0] - d * (a[0] + b[0]), v[1] - d * (a[1] + b[1]), v[2] - d * (a[2] + b[2])];\n}\n// Signed angle from u to v about the outward normal n, counterclockwise as\n// seen from outside the sphere.\nconst ang = (u, v, n) => atan2(dot(crs(u, v), n), dot(u, v));\n\n// Pieces of a loop: a great arc from a to b, or an arc of the small circle of\n// angular radius r about c, from x through the signed angle sweep.\nfunction gArc(a, b) {\n  const w = acos(cl(dot(a, b), -1, 1)), s = sin(w);\n  return { len: w, at: (t) => lin(a, sin((1 - t) * w) / s, b, sin(t * w) / s) };\n}\nfunction cArc(c, r, x, sweep) {\n  const e1 = nrm(lin(x, 1, c, -dot(x, c))), e2 = crs(c, e1);\n  return { len: abs(sweep) * sin(r), at: (t) => lin(c, cos(r), lin(e1, cos(sweep * t), e2, sin(sweep * t)), sin(r)) };\n}\n\n// Size runs -1..1 and opens at 0.06; pivot puts lo, mid, hi at -1, 0.06, 1.\nconst pivot = (u, lo, mid, hi) => (u \u003c 0.06 ? mid + ((lo - mid) * (0.06 - u)) / 1.06 : mid + ((hi - mid) * (u - 0.06)) / 0.94);\n\nconst KS = 900, NB = 720;\n\n// The loop, the arrow carried round it, the gauge it is measured against and\n// the area swept so far. The gauge at a point is the start arrow carried\n// back to the fan centre c and out again along great circles; the angle from\n// the gauge to the carried arrow is then the holonomy of the closed path\n// c, start, along the loop, here, c, which is the area of the fan from c over\n// the loop so far. At the end the gauge is the start arrow itself.\nfunction build(S, which, u) {\n  const N = [0, 0, 1];\n  let pieces, c, rb, want;\n  if (which === 0) {\n    const th = pivot(u, 10, 90, 170) * DEG, A = sph(0, -th / 2), B = sph(0, th / 2);\n    pieces = [gArc(N, A), gArc(A, B), gArc(B, N)];\n    c = nrm(lin(lin(N, 1, A, 1), 1, B, 1));\n    rb = acos(dot(c, A)), want = th;\n  } else if (which === 1) {\n    const ph = pivot(u, 8, 48.85, 85) * DEG;\n    pieces = [cArc(N, PI / 2 - ph, sph(ph, -0.6), TAU)];\n    c = N, rb = PI / 2 - ph, want = TAU * (1 - sin(ph));\n  } else if (which === 2) {\n    const rho = exp(pivot(u, log(2), log(8), log(30))) * DEG, la = 0.35;\n    c = sph(la, 0);\n    const e1 = [-sin(la), 0, cos(la)], e2 = crs(c, e1);\n    const V = (a) => lin(c, cos(rho), lin(e1, cos(a), e2, sin(a)), sin(rho));\n    const q = PI / 4, M = nrm(lin(V(3 * q), 1, V(5 * q), 1));\n    pieces = [gArc(M, V(5 * q)), gArc(V(5 * q), V(7 * q)), gArc(V(7 * q), V(q)), gArc(V(q), V(3 * q)), gArc(V(3 * q), M)];\n    rb = rho, want = 8 * Math.atan(1 / cos(rho)) - TAU;\n  } else {\n    const d = pivot(u, -0.5, 0, 0.5), r1 = 22 * DEG * (1 + d), r2 = 22 * DEG * (1 - d), P = sph(0.3, 0), E = [0, 1, 0];\n    const c1 = lin(P, cos(r1), E, sin(r1)), c2 = lin(P, cos(r2), E, -sin(r2)), F = cArc(c1, r1, P, -PI / 2).at(1);\n    // From the top of the first circle a quarter round to P, the second\n    // circle clockwise, then the rest of the first.\n    pieces = [cArc(c1, r1, F, PI / 2), cArc(c2, r2, P, -TAU), cArc(c1, r1, P, 1.5 * PI)];\n    c = P, rb = 2 * max(r1, r2), want = TAU * (cos(r2) - cos(r1));\n  }\n  let L = 0;\n  for (const p of pieces) L += p.len;\n  const ns = pieces.map((p) => max(4, round((KS * p.len) / L)));\n  const K = ns.reduce((a, b) => a + b, 0);\n  const P = new Float64Array(3 * (K + 1)), V = new Float64Array(3 * (K + 1));\n  const cum = new Float64Array(K + 1), psi = new Float64Array(K + 1), area = new Float64Array(K + 1);\n  let k = 0, prev = pieces[0].at(0);\n  P.set(prev, 0);\n  pieces.forEach((pc, i) => {\n    for (let j = 1; j \u003c= ns[i]; j++) {\n      const q = nrm(pc.at(j / ns[i]));\n      k++;\n      P.set(q, 3 * k);\n      cum[k] = cum[k - 1] + acos(cl(dot(prev, q), -1, 1));\n      prev = q;\n    }\n  });\n  const pt = (i) => [P[3 * i], P[3 * i + 1], P[3 * i + 2]];\n  const p0 = pt(0), t0 = nrm(lin(pt(1), 1, p0, -dot(pt(1), p0)));\n  // The arrow starts pointing back over the loop's right side, 135 degrees\n  // clockwise from the way it goes, so neither it nor the returned arrow lies\n  // along a leg at the openings.\n  let v = lin(t0, -Math.SQRT1_2, crs(p0, t0), -Math.SQRT1_2), g = carry(p0, c, v), ps = 0, ar = 0, last = 0;\n  V.set(v, 0);\n  // Azimuth bins about c remember which sample first swept them, how far\n  // from c the loop is there and which way it went.\n  const e1 = nrm(abs(c[2]) \u003c 0.9 ? crs([0, 0, 1], c) : crs([1, 0, 0], c)), e2 = crs(c, e1);\n  const bk = new Int32Array(NB).fill(-1), br = new Float32Array(NB), bs = new Int8Array(NB);\n  const azi = (p) => atan2(dot(p, e2), dot(p, e1));\n  for (let i = 0; i \u003c K; i++) {\n    const a = pt(i), b = pt(i + 1);\n    v = nrm(carry(a, b, v));\n    V.set(v, 3 * (i + 1));\n    const G = carry(c, b, g), x = ang(G, v, b);\n    ps += wrap(x - last), last = x, psi[i + 1] = ps;\n    const det = dot(c, crs(a, b));\n    ar += 2 * atan2(det, 1 + dot(c, a) + dot(a, b) + dot(b, c));\n    area[i + 1] = ar;\n    const da = acos(cl(dot(a, c), -1, 1)), db = acos(cl(dot(b, c), -1, 1));\n    if (da \u003c 2e-3 || db \u003c 2e-3) continue;\n    const za = azi(a), dz = wrap(azi(b) - za), sg = dz >= 0 ? 1 : -1;\n    const ia = floor(((za + PI) / TAU) * NB), n = round(abs(dz / TAU) * NB);\n    for (let j = 0; j \u003c= n; j++) {\n      const bb = (((ia + sg * j) % NB) + NB) % NB;\n      if (bk[bb] \u003c 0) (bk[bb] = i), (br[bb] = da + ((db - da) * j) / max(1, n)), (bs[bb] = sg);\n    }\n  }\n  Object.assign(S, { which, u, K, P, V, cum, psi, area, L, c, e1, e2, bk, br, bs, rb, want });\n  S.zoomT = max(1, (which === 2 ? 20 : 13) / (30 * sin(min(rb, PI / 2))));\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, which: -1, u: 0.06, s: 0, phase: 0, pt: 0, fresh: 1,\n    vlat: 0, vlon: 0, zoom: 1, buf: new Float32Array(W * H * 3), col: [0, 0, 0],\n  });\n  build(S, 0, 0.06);\n  return S;\n}\n\nfunction sampleAt(S, s) {\n  let lo = 0, hi = S.K;\n  while (hi - lo > 1) {\n    const m = (lo + hi) >> 1;\n    if (S.cum[m] \u003c= s) lo = m;\n    else hi = m;\n  }\n  const f = cl((s - S.cum[lo]) / max(1e-9, S.cum[hi] - S.cum[lo]), 0, 1), P = S.P, V = S.V, a = 3 * lo, b = 3 * hi;\n  const p = nrm([P[a] + (P[b] - P[a]) * f, P[a + 1] + (P[b + 1] - P[a + 1]) * f, P[a + 2] + (P[b + 2] - P[a + 2]) * f]);\n  let v = [V[a] + (V[b] - V[a]) * f, V[a + 1] + (V[b + 1] - V[a + 1]) * f, V[a + 2] + (V[b + 2] - V[a + 2]) * f];\n  v = nrm(lin(v, 1, p, -dot(v, p)));\n  return { p, v, k: lo, f, psi: S.psi[lo] + (S.psi[hi] - S.psi[lo]) * f, area: S.area[lo] + (S.area[hi] - S.area[lo]) * f };\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1] ?? 2, 0.2, 3);\n  const which = cl(round(kv[2] || 0), 0, 3), u = cl(kv[3] ?? 0.06, -1, 1);\n  if (which !== S.which || abs(u - S.u) > 0.002) build(S, which, u);\n  // A lap takes 12 / Speed seconds; the hold and the fade shorten more gently.\n  const slow = sqrt(2 / S.speed);\n  if (S.phase === 0) {\n    S.s += (S.speed / 12) * d;\n    if (S.s >= 1) (S.s = 1), (S.phase = 1), (S.pt = 0);\n  } else {\n    S.pt += d / slow;\n    if (S.pt > 3.2) (S.phase = 0), (S.s = 0);\n  }\n  // The view looks at a point between the fan centre and the arrow, from\n  // above the latitude it is at, north up; small loops are looked at whole\n  // and zoomed in until they are 13 LEDs across or more.\n  const now = sampleAt(S, S.s * S.L);\n  // Near the close it turns to the start point, so the two arrows face us.\n  const big = S.rb > 0.6 && S.which !== 3, w = big ? 1.3 + 3.7 * cl((S.s - 0.8) / 0.2, 0, 1) : S.which === 3 ? 0.8 * (1 - S.s) : 0;\n  const tv = nrm(lin(S.c, 1, now.p, w));\n  const tlat = cl(asin(tv[2]), -1.5, 1.5), tlon = atan2(tv[1], tv[0]) + (0.16 * sin(0.33 * S.t)) / S.zoom;\n  if (S.fresh) (S.vlat = tlat), (S.vlon = tlon), (S.zoom = S.zoomT), (S.fresh = 0);\n  const e = 1 - exp(-1.8 * d);\n  S.vlat += (tlat - S.vlat) * e;\n  S.vlon += wrap(tlon - S.vlon) * e;\n  S.zoom *= exp(log(S.zoomT / S.zoom) * e);\n  S.now = now;\n}\n\n// Additive drawing into the float buffer, clipped to the rows lo..hi-1.\nfunction splat(B, x, y, r, g, b, lo, hi) {\n  const i = floor(x - 0.5), j = floor(y - 0.5), fx = x - 0.5 - i, fy = y - 0.5 - j;\n  for (let q = 0; q \u003c 4; q++) {\n    const ii = i + (q & 1), jj = j + (q >> 1);\n    if (ii \u003c 0 || ii >= W || jj \u003c lo || jj >= hi) continue;\n    const w = (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy), k = (jj * W + ii) * 3;\n    B[k] += r * w, B[k + 1] += g * w, B[k + 2] += b * w;\n  }\n}\nfunction line(B, x0, y0, x1, y1, r, g, b, lo, hi) {\n  const len = sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)), n = max(1, ceil(len / 0.4)), w = max(len, 0.4) / n;\n  for (let i = 0; i \u003c n; i++) {\n    const f = (i + 0.5) / n;\n    splat(B, x0 + (x1 - x0) * f, y0 + (y1 - y0) * f, r * w, g * w, b * w, lo, hi);\n  }\n}\n\n// 3x5 glyphs, rows of three bits, 4 the left column.\nconst FONT = {\n  0: [7, 5, 5, 5, 7], 1: [2, 6, 2, 2, 7], 2: [7, 1, 7, 4, 7], 3: [7, 1, 3, 1, 7], 4: [5, 5, 7, 1, 1],\n  5: [7, 4, 7, 1, 7], 6: [7, 4, 7, 5, 7], 7: [7, 1, 1, 2, 2], 8: [7, 5, 7, 5, 7], 9: [7, 5, 7, 1, 7],\n  '-': [0, 0, 7, 0, 0], '.': [0, 0, 0, 0, 4], 'o': [2, 5, 2, 0, 0], ' ': [0, 0, 0, 0, 0],\n  T: [7, 2, 2, 2, 2], U: [5, 5, 5, 5, 7], R: [6, 5, 6, 5, 5], N: [6, 5, 5, 5, 5], A: [2, 5, 7, 5, 5], E: [7, 4, 6, 4, 7], '=': [0, 7, 0, 7, 0],\n};\nconst sc = (v) => (v \u003c 0.85 ? v : 0.85 + 0.15 * (1 - exp(-(v - 0.85) / 0.15)));\nconst gw = (ch) => (ch === '.' ? 1 : 3);\nfunction text(B, str, cx, y, r, g, b) {\n  let wd = -1;\n  for (const ch of str) wd += gw(ch) + 1;\n  let x = round(cx - wd / 2);\n  for (const ch of str) {\n    const gl = FONT[ch] || FONT[' '];\n    for (let row = 0; row \u003c 5; row++)\n      for (let col = 0; col \u003c gw(ch); col++)\n        if ((gl[row] >> (gw(ch) === 1 ? 2 : 2 - col)) & 1) {\n          const k = ((y + row) * W + x + col) * 3;\n          if (x + col >= 0 && x + col \u003c W) (B[k] += r), (B[k + 1] += g), (B[k + 2] += b);\n        }\n    x += gw(ch) + 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.now) return;\n  const B = S.buf, col = S.col, now = S.now, t = S.t;\n  B.fill(0);\n  const CX = 32, CY = 32, Rz = 30 * S.zoom;\n  const f = sph(S.vlat, S.vlon), rt = [-sin(S.vlon), cos(S.vlon), 0];\n  const up = [-sin(S.vlat) * cos(S.vlon), -sin(S.vlat) * sin(S.vlon), cos(S.vlat)];\n  const proj = (p) => [CX + Rz * dot(p, rt), CY - Rz * dot(p, up), dot(p, f)];\n  const fade = S.phase === 1 ? cl((3.2 - S.pt) / 0.6, 0, 1) : 1;\n  // Colours.\n  const bh = 0.3 + 0.55 * fr(S.hue + 0.52);\n  const body = hsv(bh, 0.7, 1, [0, 0, 0]), grid = hsv(bh, 0.3, 1, [0, 0, 0]);\n  const gold = hsv(S.hue + 0.13, 0.75, 1, [0, 0, 0]), pos = hsv(S.hue + 0.92, 0.6, 1, [0, 0, 0]), neg = hsv(S.hue + 0.45, 0.7, 1, [0, 0, 0]);\n  const pale = hsv(S.hue + 0.13, 0.2, 1, [0, 0, 0]);\n  // Graticule spacing: the coarsest of 30, 15, 10, 5, 2.5, 1 degrees that\n  // still leaves 9 LEDs between lines.\n  let gs = 30;\n  for (const g of [1, 2.5, 5, 10, 15, 30])\n    if (g * DEG * Rz >= 9) {\n      gs = g;\n      break;\n    }\n  const gr = gs * DEG;\n  // The globe, lit from the upper left; the swept fan tinted.\n  const Lx = -0.45, Ly = 0.5, Lz = 0.74, kNow = S.phase === 0 ? now.k : S.K;\n  const { c, e1, e2, bk, br, bs } = S;\n  for (let y = 0; y \u003c TOP; y++) {\n    const b = (CY - y - 0.5) / Rz;\n    for (let x = 0; x \u003c W; x++) {\n      const a = (x + 0.5 - CX) / Rz, q = a * a + b * b;\n      if (q >= 1) continue;\n      const z = sqrt(1 - q), edge = cl((1 - sqrt(q)) * Rz * 1.5, 0, 1);\n      const p = [a * rt[0] + b * up[0] + z * f[0], a * rt[1] + b * up[1] + z * f[1], a * rt[2] + b * up[2] + z * f[2]];\n      const sh = max(0, a * Lx + b * Ly + z * Lz), lit = 0.08 + 0.42 * sh * sh;\n      const lat = asin(cl(p[2], -1, 1)), lon = atan2(p[1], p[0]);\n      // Meridians close up toward the poles, so every second, fourth, ...\n      // one is dropped where they would come nearer than 9 LEDs.\n      const cg = gr * cos(lat) * Rz, mg = gr * (cg >= 9 ? 1 : min(64, 2 ** ceil(Math.log2(9 / max(cg, 0.01)))));\n      const dl = abs(lat / gr - round(lat / gr)) * gr * Rz, dm = abs(lon / mg - round(lon / mg)) * mg * cos(lat) * Rz;\n      const gl = max(0, 1 - dl / 0.8, 1 - dm / 0.8) * (0.07 + 0.1 * sh);\n      let tr = 0, tg = 0, tb = 0;\n      const zc = atan2(dot(p, e2), dot(p, e1)), bb = floor(((zc + PI) / TAU) * NB) % NB, kk = bk[bb];\n      if (kk >= 0 && kk \u003c kNow) {\n        const dd = acos(cl(dot(p, c), -1, 1)), m = cl((br[bb] - dd) * Rz + 0.5, 0, 1) * fade * (0.16 + 0.14 * sh);\n        const tc = bs[bb] > 0 ? pos : neg;\n        (tr = tc[0] * m), (tg = tc[1] * m), (tb = tc[2] * m);\n      }\n      const k = (y * W + x) * 3;\n      B[k] = (body[0] * lit + grid[0] * gl + tr) * edge;\n      B[k + 1] = (body[1] * lit + grid[1] * gl + tg) * edge;\n      B[k + 2] = (body[2] * lit + grid[2] * gl + tb) * edge;\n    }\n  }\n  // The loop: bright where the arrow has been, dim ahead of it.\n  const P = S.P, V = S.V;\n  let q0 = proj([P[0], P[1], P[2]]);\n  for (let i = 1; i \u003c= S.K; i++) {\n    const q1 = proj([P[3 * i], P[3 * i + 1], P[3 * i + 2]]);\n    if (q0[2] > 0 && q1[2] > 0) {\n      const w = (i \u003c= kNow ? 0.5 : 0.22) * (0.4 + 0.6 * fade);\n      line(B, q0[0], q0[1], q1[0], q1[1], pale[0] * w, pale[1] * w, pale[2] * w, 0, TOP);\n    }\n    q0 = q1;\n  }\n  // An arrow: a great-circle shaft 10 LEDs long and a head of two 4 LED barbs.\n  const Lr = 0.34 / S.zoom, Lh = 0.42 * Lr;\n  const arrow = (p, v, cc, w) => {\n    let a = proj(p);\n    if (a[2] \u003c= 0) return;\n    splat(B, a[0], a[1], cc[0] * w, cc[1] * w, cc[2] * w, 0, TOP);\n    for (let i = 1; i \u003c= 5; i++) {\n      const s = (Lr * i) / 5, b = proj(lin(p, cos(s), v, sin(s)));\n      if (b[2] > 0) line(B, a[0], a[1], b[0], b[1], cc[0] * w, cc[1] * w, cc[2] * w, 0, TOP);\n      a = b;\n    }\n    const tip = lin(p, cos(Lr), v, sin(Lr)), fw = lin(p, -sin(Lr), v, cos(Lr)), sd = crs(tip, fw), ta = proj(tip);\n    for (const sg of [-1, 1]) {\n      const dv = lin(fw, -cos(0.6), sd, sg * sin(0.6)), e = proj(lin(tip, cos(Lh), dv, sin(Lh)));\n      if (e[2] > 0 && ta[2] > 0) line(B, ta[0], ta[1], e[0], e[1], cc[0] * w, cc[1] * w, cc[2] * w, 0, TOP);\n    }\n  };\n  // Ghost arrows every 8 LEDs or so of loop, left as the arrow passes.\n  const nG = cl(round((S.L * Rz) / 8), 5, 16), sNow = S.s * S.L;\n  for (let j = 1; j \u003c nG; j++) {\n    const sj = (j * S.L) / nG;\n    if (sj > sNow) break;\n    const g = sampleAt(S, sj), w = 0.42 * fade * cl((sNow - sj) * Rz * 0.3, 0, 1);\n    arrow(g.p, g.v, gold, w);\n  }\n  const p0 = [P[0], P[1], P[2]], v0 = [V[0], V[1], V[2]], white = [0.85, 0.9, 1];\n  const hold = S.phase === 1 ? fade : 0;\n  arrow(p0, v0, white, 0.45 + 0.5 * hold);\n  arrow(now.p, now.v, gold, 1.15 * fade);\n  // At the close, an arc from the start arrow round to the returned one.\n  const turn = now.psi;\n  if (hold > 0) {\n    const ra = 0.62 * Lr, n0 = crs(p0, v0), n = max(8, ceil(abs(turn) * ra * Rz));\n    let a = null;\n    const blink = 0.75 + 0.25 * sin(t * 6);\n    for (let i = 0; i \u003c= n; i++) {\n      const al = (turn * i) / n, dir = lin(v0, cos(al), n0, sin(al)), b = proj(lin(p0, cos(ra), dir, sin(ra)));\n      const tc = turn >= 0 ? pos : neg, w = hold * blink;\n      if (a && a[2] > 0 && b[2] > 0) line(B, a[0], a[1], b[0], b[1], tc[0] * w, tc[1] * w, tc[2] * w, 0, TOP);\n      a = b;\n    }\n  }\n  // The dial: the area swept so far as a pie from twelve o'clock, positive\n  // counterclockwise, and the arrow's turn against the gauge as the needle.\n  const DX = 32, DY = 94, DR = 25, HUB = 9.5, A = S.phase === 0 ? now.area : S.area[S.K];\n  const tc = A >= 0 ? pos : neg;\n  for (let y = DY - DR - 2; y \u003c= DY + DR + 2; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - DX, dy = y + 0.5 - DY, r = sqrt(dx * dx + dy * dy);\n      if (r > DR + 1.5) continue;\n      const k = (y * W + x) * 3, ring = max(0, 1 - abs(r - DR) / 0.8) * 0.2;\n      (B[k] += ring * grid[0]), (B[k + 1] += ring * grid[1]), (B[k + 2] += ring * grid[2]);\n      if (r >= DR - 0.5 || r \u003c= HUB) continue;\n      const al = atan2(-dx, -dy), a1 = A >= 0 ? fr(al / TAU) * TAU : fr(-al / TAU) * TAU;\n      const m = cl((abs(A) - a1) * r + 0.5, 0, 1) * cl(r - HUB, 0, 1) * (0.14 + 0.3 * (r / DR)) * (0.5 + 0.5 * fade);\n      (B[k] += tc[0] * m), (B[k + 1] += tc[1] * m), (B[k + 2] += tc[2] * m);\n    }\n  const ray = (al, r0, r1, cc, w) =>\n    line(B, DX - sin(al) * r0, DY - cos(al) * r0, DX - sin(al) * r1, DY - cos(al) * r1, cc[0] * w, cc[1] * w, cc[2] * w, TOP, H);\n  for (let i = 0; i \u003c 12; i++) ray((i * PI) / 6, i % 3 ? DR - 2.5 : DR - 4, DR - 0.5, grid, i % 3 ? 0.35 : 0.6);\n  // Where this loop's turn will end.\n  const wt = S.want, wtc = wt >= 0 ? pos : neg;\n  ray(wt, DR - 1, DR + 2, wtc, 0.9);\n  ray(0, HUB + 1, DR - 2, white, 0.4 + 0.4 * hold);\n  const nd = S.phase === 0 ? turn : S.psi[S.K];\n  ray(nd, HUB + 1, DR - 2, gold, 1.1);\n  const tx = DX - sin(nd) * (DR - 2), ty = DY - cos(nd) * (DR - 2);\n  for (const sg of [-1, 1]) {\n    const bd = nd + PI + sg * 0.55;\n    line(B, tx, ty, tx - sin(bd) * 4.2, ty - cos(bd) * 4.2, gold[0] * 1.1, gold[1] * 1.1, gold[2] * 1.1, TOP, H);\n  }\n  // The turn in degrees in the hub, one decimal under 10.\n  const dg = (nd * 180) / PI;\n  let str = abs(dg) \u003c 9.95 ? (abs(dg) \u003c 0.05 ? '0.0' : dg.toFixed(1)) : String(round(dg));\n  str += 'o';\n  const tw = 0.75 + 0.25 * hold;\n  text(B, str, DX, DY - 2, tw, tw, tw);\n  text(B, 'TURN=AREA', DX, 122, pale[0] * 0.45, pale[1] * 0.45, pale[2] * 0.45);\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, floor(sc(B[o]) * 255), floor(sc(B[o + 1]) * 255), floor(sc(B[o + 2]) * 255));\n  }\n}\n","rose-criterion":"// ===== Patternflow pattern =====\n// Title:   Rose Criterion\n// Family:  noise\n// Idea:    A contrast-detail grid of fifty discs, five diameters across and ten contrasts down, is exposed photon by photon with Poisson counts and a little read noise, so the normalised picture starts as static, settles into grain and lets the discs rise out of it in order of contrast times diameter, while a faint line marks Rose's k = 5, the hyperbola C·d = const that sweeps from the top left corner toward the bottom right and stops where the dose runs out; then the exposure clears and builds again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rose's detection criterion k = C·sqrt(nA) (Albert Rose, \"The sensitivity performance of the human eye on an absolute scale\", J. Opt. Soc. Am. 38, 1948), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Exposure=0..1, Read noise=0..1\n//\n// Knob 1: Hue. The colour of the light: at 0 cyan grain with a gold k = 5 line, at 0.25 violet with a green line, at 0.5 coral with a blue line, at 0.75 lime with a magenta line.\n// Knob 2: Speed. How fast each exposure builds: at 2 the dose comes in over 3 s, holds 1.2 s and clears; at 0.2 it comes in over 30 s, at 3 over 2 s. The photon flux is the dose over that time.\n// Knob 3: Exposure. The dose a build stops at, in photons per LED: 25 at 0, 224 at 0.5, 2000 at 1. At 25 the k = 5 line stops at C·d = 1.15 with 7 of the 50 discs still in the grain; from 0.37 on every disc is seen, the last one (contrast 0.15, 9 LEDs) at 124 photons, and the rest of the dose only calms the grain.\n// Knob 4: Read noise. Gaussian noise each channel adds every time it reads its LED, 1 photon rms at 0 and 9 at 1. It adds to the shot noise, so the grain coarsens and the k = 5 line, drawn with it counted in, slows: at 1 the first disc needs 8 photons instead of 1.3, and at 25 photons 24 discs stay hidden.\n\n// Rose (1948): a disc of area A whose brightness differs by a fraction C\n// from a background that has caught n photons per unit area is seen when\n// k = C·sqrt(n·A), its excess count over the noise of the background count\n// in the same area, passes about 5. With A = pi·d²/4 the threshold is\n// C·d = 5 / sqrt(pi·n/4): at a given dose the seen and unseen discs of a\n// contrast-detail grid are split by a hyperbola, which moves out as 1/sqrt(n).\n//\n// Here A is the disc's own LED count (97, 69, 37, 21 and 9 for diameters\n// 11, 9, 7, 5 and 3) and n the photons per LED. Each LED keeps one count,\n// read by each of its three channels with its own read noise sigma, so one\n// read has variance n + sigma² and the line drawn is\n// C·sqrt(A)·n / sqrt(n + sigma²) = 5.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, log, cos, sin, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The grid: diameters across, contrasts down. Each disc is the LEDs whose\n// centres lie within d/2 of the centre of the LED at (COLX, ROWY), so every\n// disc in a column has the same shape and the same area.\nconst DIAM = [11, 9, 7, 5, 3];\nconst COLX = [6, 19, 32, 44, 57];\nconst ROWY = [6, 19, 32, 44, 57, 70, 83, 96, 108, 121];\nconst CONTRAST = ROWY.map((_, r) => 0.6 - 0.05 * r);\nconst K_ROSE = 5;\nconst CXS = COLX.map((x) => x + 0.5), CYS = ROWY.map((y) => y + 0.5);\n\n// The display: the count normalised by what the background should have\n// caught, so u = 1 on the background, then an exponential toe and a soft\n// shoulder, 1 - exp(-a·exp(BETA·(u - 1))). Equal steps of u read as equal\n// steps of brightness on the LEDs, and the background sits near L0 with\n// grain on both sides of it instead of piling up at black.\nconst L0 = 13, BETA = 6.5;\n// The gain runs out below this many expected photons, so the panel comes\n// up from black instead of blowing up the first few counts.\nconst FLOOR = 3.5;\n// How bright the k = 5 line is drawn.\nconst LINE = 150;\n// The tone curve, tabulated over t = BETA·(u - 1) in steps of 1/128.\nconst T0 = -10, TS = 128, TN = 15 * TS;\nconst TONE = new Float32Array(TN + 1);\nfor (let i = 0; i \u003c= TN; i++) TONE[i] = 1 - exp(-(L0 / 255) * exp(T0 + i / TS));\n\nfunction poisson(l, gauss) {\n  if (l \u003c= 0) return 0;\n  if (l > 15) return max(0, round(l + sqrt(l) * gauss()));\n  const u = Math.random();\n  let k = 0, p = exp(-l), s = p;\n  while (u > s && k \u003c 60) {\n    k++;\n    p *= l / k;\n    s += p;\n  }\n  return k;\n}\n\nexport function setup(params) {\n  const cidx = new Uint8Array(W * H);\n  const area = DIAM.map(() => 0);\n  DIAM.forEach((d, c) => {\n    const r2 = (d / 2) * (d / 2), R = d >> 1;\n    for (let i = -R; i \u003c= R; i++)\n      for (let j = -R; j \u003c= R; j++) {\n        if (i * i + j * j > r2) continue;\n        area[c]++;\n        ROWY.forEach((y, r) => (cidx[(y + j) * W + COLX[c] + i] = r + 1));\n      }\n  });\n  // Standard normal deviates, drawn once and picked at random at every read.\n  const norm = new Float32Array(4096);\n  for (let i = 0; i \u003c 4096; i += 2) {\n    const a = sqrt(-2 * log(1 - Math.random())), b = 2 * PI * Math.random();\n    norm[i] = a * cos(b);\n    norm[i + 1] = a * sin(b);\n  }\n  params.s = {\n    cidx, deff: area.map((a) => sqrt((4 * a) / PI)),\n    gauss: () => norm[(Math.random() * 4096) | 0],\n    count: new Float32Array(W * H), f: new Float32Array(W * H), dx: new Float32Array(W),\n    n: 0, hold: 0, stop: 25, sr: 1, hue: 0, lam: new Float32Array(11),\n    w: new Float32Array(3), lc: new Float32Array(3),\n  };\n  return params.s;\n}\n\n// The k = 5 threshold on C·d at dose n and read noise sr.\nconst lineK = (n, sr) => (n > 0 ? (K_ROSE * sqrt(n + sr * sr)) / (n * sqrt(PI / 4)) : 1e9);\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1] ?? 2, 0.2, 3);\n  S.stop = 25 * pow(80, cl(kv[2] || 0, 0, 1));\n  const rn = cl(kv[3] ?? 0.06, 0, 1);\n  S.sr = 1 + 8 * rn * rn;\n\n  if (S.n >= S.stop) {\n    S.hold += d * speed;\n    if (S.hold > 2.4) {\n      S.n = 0;\n      S.hold = 0;\n      S.count.fill(0);\n    }\n    return;\n  }\n  // Constant flux: the dose comes in over 6/speed seconds. A disc of\n  // contrast C catches 1 + C times the background's photons.\n  S.hold = 0;\n  const dn = min(S.stop - S.n, (S.stop * speed * d) / 6);\n  S.n += dn;\n  for (let k = 0; k \u003c= 10; k++) S.lam[k] = dn * (k ? 1 + CONTRAST[k - 1] : 1);\n  const cnt = S.count, ci = S.cidx, lam = S.lam, g = S.gauss;\n  for (let i = 0; i \u003c W * H; i++) cnt[i] += poisson(lam[ci[i]], g);\n}\n\n// Piecewise linear through the grid's centres, carried on past the ends.\nfunction interp(xs, ys, v) {\n  let i = 0;\n  while (i \u003c xs.length - 2 && v > xs[i + 1]) i++;\n  return ys[i] + ((v - xs[i]) * (ys[i + 1] - ys[i])) / (xs[i + 1] - xs[i]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const cnt = S.count, sr = S.sr, gauss = S.gauss, w = hsv(0.5 + S.hue, 0.55, 1, S.w);\n  const w0 = 255 * w[0], w1 = 255 * w[1], w2 = 255 * w[2];\n  // One read: t = BETA·(u - 1) as a row of the tone table.\n  const sc = (BETA * TS) / max(S.n, FLOOR), off = (-BETA - T0) * TS, rs = sr * sc;\n  const tone = (c) => {\n    const t = (c + rs * gauss() + off) | 0;\n    return TONE[t \u003c 0 ? 0 : t > TN ? TN : t];\n  };\n\n  // The line: where C(y)·d(x) crosses the k = 5 threshold, drawn on the seen side.\n  const K = lineK(S.n, sr), f = S.f, dx = S.dx;\n  for (let x = 0; x \u003c W; x++) dx[x] = max(0.3, interp(CXS, S.deff, x + 0.5));\n  for (let y = 0; y \u003c H; y++) {\n    const C = max(0.005, interp(CYS, CONTRAST, y + 0.5));\n    for (let x = 0; x \u003c W; x++) f[y * W + x] = C * dx[x] - K;\n  }\n  const lc = hsv(S.hue + 0.13, 0.75, 1, S.lc);\n  const l0 = lc[0] * LINE, l1 = lc[1] * LINE, l2 = lc[2] * LINE;\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, c = cnt[i] * sc;\n      // One count per LED, read once by each of its three channels.\n      let r = w0 * tone(c), g = w1 * tone(c), b = w2 * tone(c);\n      const v = f[i];\n      if (v >= 0 && ((x > 0 && f[i - 1] \u003c 0) || (x \u003c W - 1 && f[i + 1] \u003c 0) || (y > 0 && f[i - W] \u003c 0) || (y \u003c H - 1 && f[i + W] \u003c 0))) {\n        r = max(r, l0);\n        g = max(g, l1);\n        b = max(b, l2);\n      }\n      display.setPixel(x, y, r | 0, g | 0, b | 0);\n    }\n}\n","structure-ascii":"// ===== Patternflow pattern =====\n// Title:   Structure ASCII\n// Family:  type\n// Idea:    The outline of a big letter sways and melts from A to S to & to the Hangul syllable 글 behind a grid of character cells, lit only by a dim rim just inside its edge, and each cell the outline crosses takes the ASCII character whose strokes lie nearest the piece of outline inside it, so slashes, bars, underscores, parentheses and ticks join into the letter's contour, as in structure-based ASCII art; a fourth setting picks by ink instead, as tone-based ASCII art does.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Structure-based ASCII Art (Xuemiao Xu, Linling Zhang and Tien-Tsin Wong, SIGGRAPH 2010), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Cell=0..3\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the straight strokes are turquoise, curves and angles azure, corners and crossings green, dots and ticks lilac, and a rim 4 LEDs deep just inside the outline a dim blue (16, 19, 45), so the characters stand on the edge of a shape; at 0.5 the strokes are red.\n// Knob 2: Speed. At 2 a letter holds 4.5 s and melts into the next in 1.5 s, so the four take 24 s, while the drawing sways 0.12 radian (about 7 degrees) each way every 9 s. At 0.2 it all takes ten times as long, at 3 two thirds as long.\n// Knob 3: Set. The characters a cell may take, each set with the space. At 0 the 27 of the structure set (. , ' ` \" - _ = | / \\ ( ) \u003c > ^ v ~ o + L J 7 T Y V X); at 1 twelve of them (/ \\ | - _ . ' , ( ) \u003c >); at 2 only / \\ | and -. At 3 the tone ramp . : - = + * # % @, picked by how much of the cell the outline darkens, not by its shape.\n// Knob 4: Cell. The size of a character cell in LEDs: 5 by 8 at 0 (a grid of 12 by 16), 4 by 6 at 1 (16 by 21), 3 by 5 at 2 (21 by 25), and 7 by 11 at 3 (9 by 11), where each character is big enough to read.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The paper (Xu, Zhang and Wong 2010) compares a cell and a character with an\n// alignment-insensitive shape similarity and also deforms the drawing to suit\n// the characters. Here the drawing is never deformed, and the comparison is a\n// symmetric chamfer distance that lets the character slide by up to two LEDs\n// across (one in a 3 by 5 cell) and one up or down, at 0.12 for each LED of\n// slide; the character is still drawn in its own cell.\n\n// ---- The characters. Each is drawn as pen strokes in a unit cell, across\n// then down in tenths, so (0,0) is the top left corner and (10,10) the\n// bottom right; a stroke of one point is a dot. Strokes run to the cell's\n// edge where the character's line would go on into its neighbour, so two\n// slashes side by side meet. The second field is a class for colour:\n// 0 straight lines, 1 curves and angles, 2 corners and crossings, 3 dots.\nconst GLYPHS = [\n  [\" \", 3, []],\n  [\".\", 3, [[5, 10]]],\n  [\",\", 3, [[6, 8, 4, 10]]],\n  [\"'\", 3, [[5, 0, 5, 2]]],\n  [\"`\", 3, [[3, 0, 6, 3]]],\n  ['\"', 3, [[2, 0, 2, 2], [8, 0, 8, 2]]],\n  [\":\", 3, [[5, 3], [5, 8]]],\n  [\"-\", 0, [[0, 5, 10, 5]]],\n  [\"_\", 0, [[0, 10, 10, 10]]],\n  [\"=\", 0, [[0, 3, 10, 3], [0, 7, 10, 7]]],\n  [\"|\", 0, [[5, 0, 5, 10]]],\n  [\"/\", 0, [[0, 10, 10, 0]]],\n  [\"\\\\\", 0, [[0, 0, 10, 10]]],\n  [\"(\", 1, [[8, 0, 4, 2, 2, 5, 4, 8, 8, 10]]],\n  [\")\", 1, [[2, 0, 6, 2, 8, 5, 6, 8, 2, 10]]],\n  [\"\u003c\", 1, [[10, 0, 0, 5, 10, 10]]],\n  [\">\", 1, [[0, 0, 10, 5, 0, 10]]],\n  [\"^\", 1, [[0, 5, 5, 0, 10, 5]]],\n  [\"v\", 1, [[0, 4, 5, 10, 10, 4]]],\n  [\"~\", 1, [[0, 6, 3, 4, 7, 6, 10, 4]]],\n  [\"o\", 1, [[3, 4, 7, 4, 9, 6, 9, 8, 7, 10, 3, 10, 1, 8, 1, 6, 3, 4]]],\n  [\"+\", 2, [[0, 5, 10, 5], [5, 1, 5, 9]]],\n  [\"L\", 2, [[0, 0, 0, 10, 10, 10]]],\n  [\"J\", 2, [[10, 0, 10, 10, 0, 10]]],\n  [\"7\", 2, [[0, 0, 10, 0, 3, 10]]],\n  [\"T\", 2, [[0, 0, 10, 0], [5, 0, 5, 10]]],\n  [\"Y\", 2, [[0, 0, 5, 5, 10, 0], [5, 5, 5, 10]]],\n  [\"V\", 2, [[0, 0, 5, 10, 10, 0]]],\n  [\"X\", 2, [[0, 0, 10, 10], [10, 0, 0, 10]]],\n  [\"*\", 2, [[5, 2, 5, 8], [1, 3, 9, 7], [9, 3, 1, 7]]],\n  [\"#\", 2, [[3, 1, 3, 9], [7, 1, 7, 9], [0, 3, 10, 3], [0, 7, 10, 7]]],\n  [\"%\", 2, [[10, 0, 0, 10], [1, 1], [9, 9]]],\n  [\"@\", 2, [[10, 10, 0, 10, 0, 0, 10, 0, 10, 7, 4, 7, 4, 4, 7, 4]]],\n];\nconst GI = {};\nGLYPHS.forEach((g, i) => (GI[g[0]] = i));\nconst pick = (s) => Array.from(s, (c) => GI[c]);\n// The character sets, each with the space: 27 characters for structure, 12\n// of them, the four straight strokes, and a tone ramp of nine by ink.\nconst SETS = [\n  pick(\" .,'`\\\"-_=|/\\\\()\u003c>^v~o+LJ7TYVX\"),\n  pick(\" /\\\\|-_.',()\u003c>\"),\n  pick(\" /\\\\|-\"),\n  pick(\" .:-=+*#%@\"),\n];\nconst RAMP = SETS[3];\n\n// The cell sizes: width, height.\nconst CELLS = [\n  [5, 8],\n  [4, 6],\n  [3, 5],\n  [7, 11],\n];\n// The distance is capped at CAP LEDs; a shift of the character by one LED\n// across or down costs SHIFT.\nconst CAP = 3, SHIFT = 0.12;\n// The brightness and depth of the rim inside the letter.\nconst IN = 0.18, BAND = 4;\nconst SX = (cw) => (cw >= 4 ? 2 : 1), SY = 1;\n\n// Each character at each cell size: its bitmap, its lit LEDs, and the\n// distance from each LED of the cell and a border round it to the nearest\n// lit LED, so it can be compared shifted.\nfunction raster(strokes, cw, ch) {\n  const bm = new Uint8Array(cw * ch);\n  for (const pl of strokes) {\n    const P = [];\n    for (let i = 0; i \u003c pl.length; i += 2) P.push([(pl[i] / 10) * (cw - 1), (pl[i + 1] / 10) * (ch - 1)]);\n    if (P.length === 1) bm[round(P[0][1]) * cw + round(P[0][0])] = 1;\n    for (let i = 0; i + 1 \u003c P.length; i++) {\n      const [x0, y0] = P[i], [x1, y1] = P[i + 1];\n      const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n      for (let k = 0; k \u003c= n; k++) bm[floor(y0 + ((y1 - y0) * k) / n + 0.5) * cw + floor(x0 + ((x1 - x0) * k) / n + 0.5)] = 1;\n    }\n  }\n  return bm;\n}\nconst FONT = CELLS.map(([cw, ch]) => {\n  const bx = SX(cw), by = SY, ew = cw + 2 * bx, eh = ch + 2 * by;\n  return GLYPHS.map((g) => {\n    const bm = raster(g[2], cw, ch);\n    const ink = [];\n    for (let j = 0; j \u003c ch; j++) for (let i = 0; i \u003c cw; i++) if (bm[j * cw + i]) ink.push(i, j);\n    const dist = new Float32Array(ew * eh);\n    for (let b = 0; b \u003c eh; b++)\n      for (let a = 0; a \u003c ew; a++) {\n        let d = CAP * CAP;\n        for (let k = 0; k \u003c ink.length; k += 2) {\n          const dx = a - bx - ink[k], dy = b - by - ink[k + 1];\n          d = min(d, dx * dx + dy * dy);\n        }\n        dist[b * ew + a] = sqrt(d);\n      }\n    return { bm, ink, dist };\n  });\n});\n\n// ---- The big letters, as centre lines in a box 52 by 108 LEDs about the\n// panel's middle, y down; the outline is where the distance to the centre\n// line equals the stroke's half width.\nfunction arc(cx, cy, rx, ry, a0, a1, n) {\n  const pts = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    pts.push(cx + rx * cos(a), cy + ry * sin(a));\n  }\n  return pts;\n}\nconst LETTERS = [\n  { r: 7, lines: [[-22, 52, 0, -50, 22, 52], [-12, 18, 12, 18]] },\n  { r: 7, lines: [[...arc(1, -28, 20, 24, -25, -270, 12), ...arc(0, 25, 22, 27, -90, 155, 12)]] },\n  { r: 6, lines: [[23, 52, -10, 0, ...arc(-3, -32, 12, 19, 130, 405, 12), -16, 8, ...arc(-4, 32, 20, 21, 210, 60, 10), 21, 18]] },\n  { r: 4.5, lines: [[-22, -52, 20, -52, 20, -31], [-27, -14, 27, -14], [-20, 5, 20, 5, 20, 26, -20, 26, -20, 47, 22, 47]] },\n];\nfor (const L of LETTERS) {\n  const s = [];\n  for (const pl of L.lines) for (let i = 0; i + 3 \u003c pl.length; i += 2) s.push(pl[i], pl[i + 1], pl[i + 2], pl[i + 3]);\n  L.seg = new Float32Array(s);\n}\n\nfunction lineDist(seg, x, y) {\n  let best = 1e9;\n  for (let i = 0; i \u003c seg.length; i += 4) {\n    const ax = seg[i], ay = seg[i + 1], bx = seg[i + 2] - ax, by = seg[i + 3] - ay;\n    const px = x - ax, py = y - ay, L = bx * bx + by * by;\n    let t = L > 0 ? (px * bx + py * by) / L : 0;\n    t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n    const dx = px - t * bx, dy = py - t * by, d = dx * dx + dy * dy;\n    if (d \u003c best) best = d;\n  }\n  return sqrt(best);\n}\n\nconst LW = W + 1, LH = H + 1, CW = 33, CH = 65;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, set: 0, cell: 0,\n    // The field on every second LED corner, then on every corner.\n    g: new Float32Array(CW * CH), f: new Float32Array(LW * LH),\n    // The outline's piece in each LED square: up to two segments.\n    sq: new Float32Array(W * H * 8), nsq: new Uint8Array(W * H),\n    // Per cell: its character, and a hash of the LEDs the outline crossed.\n    ch: new Int16Array(32 * 32), sig: new Int32Array(32 * 32),\n    dt: new Float32Array(32 * 32), segs: new Float32Array(400), tl: new Int16Array(200),\n    rgb: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.t += cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3) / 2;\n  S.set = cl(round(k[2]), 0, 3);\n  const c = cl(round(k[3]), 0, CELLS.length - 1);\n  if (c !== S.cell || S.set !== S.lastSet) { S.ch.fill(0); S.sig.fill(0); }\n  S.cell = c;\n  S.lastSet = S.set;\n}\n\n// One letter holds HOLD units of the clock, then melts into the next in MELT.\nconst HOLD = 4.5, MELT = 1.5, PER = HOLD + MELT;\n\nfunction field(S) {\n  const n = floor(S.t / PER), u = S.t - n * PER;\n  const A = LETTERS[n % LETTERS.length], B = LETTERS[(n + 1) % LETTERS.length];\n  const m = smooth((u - HOLD) / MELT);\n  const th = 0.12 * sin((2 * PI * S.t) / 9), cs = cos(th), sn = sin(th), sc = 1 / 0.9;\n  const g = S.g, f = S.f;\n  for (let j = 0; j \u003c CH; j++)\n    for (let i = 0; i \u003c CW; i++) {\n      const X = 2 * i - 32, Y = 2 * j - 64;\n      const x = (cs * X + sn * Y) * sc, y = (-sn * X + cs * Y) * sc;\n      let v = lineDist(A.seg, x, y) - A.r;\n      if (m > 0) v = (1 - m) * v + m * (lineDist(B.seg, x, y) - B.r);\n      g[j * CW + i] = v;\n    }\n  // In between, the mean of the neighbours on the coarse lattice.\n  for (let j = 0; j \u003c LH; j++) {\n    const j0 = j >> 1, j1 = (j + 1) >> 1;\n    for (let i = 0; i \u003c LW; i++) {\n      const i0 = i >> 1, i1 = (i + 1) >> 1;\n      f[j * LW + i] = 0.25 * (g[j0 * CW + i0] + g[j0 * CW + i1] + g[j1 * CW + i0] + g[j1 * CW + i1]);\n    }\n  }\n}\n\n// Marching squares on the LED corners: the outline's piece in each LED square.\nfunction contour(S) {\n  const f = S.f, sq = S.sq, nsq = S.nsq;\n  const P = new Float32Array(8);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const a = f[y * LW + x], b = f[y * LW + x + 1], c = f[(y + 1) * LW + x + 1], d = f[(y + 1) * LW + x];\n      const q = y * W + x, ia = a \u003c 0, ib = b \u003c 0, ic = c \u003c 0, id = d \u003c 0;\n      nsq[q] = 0;\n      if (ia === ib && ib === ic && ic === id) continue;\n      // Where the outline crosses the top, right, bottom and left edges.\n      let np = 0;\n      if (ia !== ib) { P[np++] = x + a / (a - b); P[np++] = y; }\n      if (ib !== ic) { P[np++] = x + 1; P[np++] = y + b / (b - c); }\n      if (id !== ic) { P[np++] = x + d / (d - c); P[np++] = y + 1; }\n      if (ia !== id) { P[np++] = x; P[np++] = y + a / (a - d); }\n      const o = q * 8;\n      for (let k = 0; k \u003c np; k++) sq[o + k] = P[k];\n      if (np === 8 && (a + b + c + d \u003c 0) !== ia) {\n        // A saddle: pair top with left and right with bottom.\n        sq[o + 2] = P[6]; sq[o + 3] = P[7]; sq[o + 4] = P[2]; sq[o + 5] = P[3]; sq[o + 6] = P[4]; sq[o + 7] = P[5];\n      }\n      nsq[q] = np >> 2;\n    }\n}\n\n// The chamfer distance between a character shifted by sx, sy and the\n// outline is the distance from each of its lit LEDs to the outline, plus\n// the distance from each LED the outline crosses to its nearest lit LED,\n// over the count of both, plus SHIFT for each LED of shift. The shifts of\n// each cell size, cheapest first: sx, sy, cost.\nconst SHIFTS = CELLS.map(([cw]) => {\n  const L = [];\n  for (let sy = -SY; sy \u003c= SY; sy++) for (let sx = -SX(cw); sx \u003c= SX(cw); sx++) L.push([sx, sy, SHIFT * (abs(sx) + abs(sy))]);\n  return L.sort((a, b) => a[2] - b[2]).flat();\n});\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  field(S);\n  contour(S);\n  const [cw, ch] = CELLS[S.cell], font = FONT[S.cell];\n  const cols = floor(W / cw), rows = floor(H / ch);\n  const ox = floor((W - cols * cw) / 2), oy = floor((H - rows * ch) / 2);\n  const set = SETS[S.set], tone = S.set === 3, shifts = SHIFTS[S.cell];\n  const bx = SX(cw), by = SY, ew = cw + 2 * bx, eh = ch + 2 * by;\n  const sq = S.sq, nsq = S.nsq, rgb = S.rgb, dT = S.dt, segs = S.segs, tl = S.tl;\n  const h0 = 0.47 + S.hue, f = S.f;\n  // A faint rim BAND LEDs deep inside the outline, so the characters stand\n  // on the edge of a shape.\n  hsv(h0 + 0.18, 0.65, IN, rgb);\n  const ir = rgb[0] | 0, ig = rgb[1] | 0, ib = rgb[2] | 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const c = 0.25 * (f[y * LW + x] + f[y * LW + x + 1] + f[(y + 1) * LW + x] + f[(y + 1) * LW + x + 1]);\n      if (c \u003c 0 && c > -BAND) display.setPixel(x, y, ir, ig, ib);\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++) {\n      const gx = ox + c * cw, gy = oy + r * ch, id = r * 32 + c;\n      // The outline's pieces in this cell, and the LEDs they cross.\n      let ns = 0, nt = 0;\n      for (let j = 0; j \u003c ch; j++)\n        for (let i = 0; i \u003c cw; i++) {\n          const q = (gy + j) * W + gx + i;\n          if (!nsq[q]) continue;\n          tl[nt++] = j * ew + i + by * ew + bx;\n          for (let k = 0; k \u003c nsq[q] * 4; k += 4) {\n            const o = q * 8 + k;\n            segs[ns++] = sq[o] - gx; segs[ns++] = sq[o + 1] - gy; segs[ns++] = sq[o + 2] - gx; segs[ns++] = sq[o + 3] - gy;\n          }\n        }\n      if (!nt) { S.ch[id] = 0; continue; }\n      // Only a cell whose crossed LEDs changed is matched again.\n      let sig = nt;\n      for (let k = 0; k \u003c nt; k++) sig = (sig * 31 + tl[k]) | 0;\n      if (sig === S.sig[id] && S.ch[id]) { paint(display, S, S.ch[id], font, gx, gy, cw, ch, h0); continue; }\n      S.sig[id] = sig;\n      // Distance from each LED centre of the cell and its border to the outline.\n      for (let b = 0; b \u003c eh; b++)\n        for (let a = 0; a \u003c ew; a++) {\n          const px = a - bx + 0.5, py = b - by + 0.5;\n          let best = CAP * CAP;\n          for (let i = 0; i \u003c ns; i += 4) {\n            const ax = segs[i], ay = segs[i + 1], ux = segs[i + 2] - ax, uy = segs[i + 3] - ay;\n            const vx = px - ax, vy = py - ay, L = ux * ux + uy * uy;\n            let t = L > 0 ? (vx * ux + vy * uy) / L : 0;\n            t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n            const dx = vx - t * ux, dy = vy - t * uy, d = dx * dx + dy * dy;\n            if (d \u003c best) best = d;\n          }\n          dT[b * ew + a] = sqrt(best);\n        }\n      let g = 0;\n      if (tone) {\n        // Tone: how much of the cell the outline darkens, on the ramp from the space.\n        let ink = 0;\n        for (let j = 0; j \u003c ch; j++) for (let i = 0; i \u003c cw; i++) ink += max(0, 1 - dT[(j + by) * ew + i + bx]);\n        g = RAMP[min(9, round((ink / (cw * ch)) * 22))];\n      } else {\n        // Each character of the set at every shift, the cell's last character\n        // first; a shift is given up as soon as its sum cannot win.\n        const prev = S.ch[id];\n        let bestC = 1e9, prevC = 1e9;\n        for (let k = -1; k \u003c set.length; k++) {\n          const gi = k \u003c 0 ? prev : set[k];\n          if (k >= 0 && gi === prev) continue;\n          const G = font[gi], ink = G.ink, dist = G.dist, n = ink.length / 2 + nt;\n          let cbest = 1e9;\n          for (let m = 0; m \u003c shifts.length; m += 3) {\n            const sx = shifts[m], sy = shifts[m + 1], pen = shifts[m + 2];\n            const lim = ((k \u003c 0 ? cbest : min(cbest, bestC)) - pen) * n;\n            if (lim \u003c= 0) break;\n            let cost = 0;\n            const io = (sy + by) * ew + sx + bx;\n            for (let i = 0; i \u003c ink.length && cost \u003c lim; i += 2) cost += dT[ink[i + 1] * ew + ink[i] + io];\n            const so = -sy * ew - sx;\n            for (let i = 0; i \u003c nt && cost \u003c lim; i++) cost += dist[tl[i] + so];\n            if (cost \u003c lim) cbest = cost / n + pen;\n          }\n          if (k \u003c 0) prevC = cbest;\n          if (cbest \u003c bestC) { bestC = cbest; g = gi; }\n        }\n        // Hold on to the last character unless a new one fits clearly better.\n        if (prevC \u003c bestC + 0.08) g = prev;\n      }\n      S.ch[id] = g;\n      if (g) paint(display, S, g, font, gx, gy, cw, ch, h0);\n    }\n}\n\nfunction paint(display, S, g, font, gx, gy, cw, ch, h0) {\n  const G = GLYPHS[g], bm = font[g].bm, rgb = S.rgb;\n  hsv(h0 + [0, 0.12, -0.1, 0.3][G[1]], G[1] === 3 ? 0.5 : 0.85, 1, rgb);\n  for (let j = 0; j \u003c ch; j++)\n    for (let i = 0; i \u003c cw; i++) if (bm[j * cw + i]) display.setPixel(gx + i, gy + j, rgb[0] | 0, rgb[1] | 0, rgb[2] | 0);\n}\n","artin-braids":"// ===== Patternflow pattern =====\n// Title:   Artin Braids\n// Family:  topology\n// Idea:    A strip at the top holds three to seven coloured points seen from above, and generators of the braid group swap neighbours by half turns about their midpoints, while below it their history scrolls down the panel as a braid, each crossing drawn with the strand that passed in front whole and the one behind broken.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: braid groups (Emil Artin, 1925), the braid group as the fundamental group of the configuration space of n points in the plane (Ralph Fox and Lee Neuwirth, 1962), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Word=0..4\n//\n// Knob 1: Hue. Turns the strands' colours round the wheel. Strand k sits 0.8 k / (n - 1) of a turn on from the first, so first and last never meet; at 0 the first is azure, and three strands are azure, rose and yellow-green.\n// Knob 2: Speed. A generator takes 1.25 seconds at 2, 12.5 at 0.2 and 0.83 at 3. The braid keeps its shape at any speed; only the scrolling changes.\n// Knob 3: Strands. 3 to 7 points. Turning it starts the braid again with every point at home.\n// Knob 4: Word. Which braid word plays, round and round, starting again with every point home when it is turned: 0 random generators and inverses; 1 the full twist (s1 s2 ... s(n-1))^n, a pure braid that brings every colour home after n(n-1) crossings; 2 the Borromean braid (s1 s2^-1)^3 on three neighbouring strands, the three moving along; 3 the braid relation as a loop, s1 s2 s1 followed by the inverse of s2 s1 s2, six crossings that are the trivial braid; 4 a random positive braid, every crossing the same hand.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The strip is rows 0 to BAND - 1; below it, one row of the space-time\n// picture per S.dt of braid time, the newest at the top.\nconst BAND = 30, CY = 14.5, ROWS = H - BAND, KEEP = ROWS + 3;\n// One generator takes a unit of braid time: the half turn runs over the\n// first 0.9 of it, nearly at an even pace, and the points rest for the rest.\n// An even turn makes x a cosine of time, so each crossing is a smooth S.\nconst TURN = 0.9;\nconst ease = (p) => 0.7 * cl(p, 0, 1) + 0.3 * smooth(p);\n// Seconds a generator takes at Speed 2.\nconst GEN = 1.25;\n\n// 3 by 5 digits for the generator's index, and a minus for an inverse.\nconst DIGITS = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\"];\n\n// Convention. Seen from above, the strip's lower edge is the side nearer\n// the viewer of the braid below, so a point lower in the strip is in front.\n// s_i turns the points at places i and i+1 (counted by x) half a turn\n// counterclockwise about their midpoint: the left one goes round by the\n// lower side, in front, and the right one by the upper side, behind. So in\n// s_i the strand moving right crosses over, and in its inverse, turning\n// clockwise, under. Places and generators count from 0 in the code and from\n// 1 on the panel.\n\n// The next letter of the word, as [place, +1 or -1].\nfunction nextLetter(S) {\n  const n = S.n, c = S.c++;\n  switch (S.word) {\n    case 1: // the full twist, (s1 s2 ... s(n-1))^n\n      return [c % (n - 1), 1];\n    case 2: { // the Borromean braid (s1 s2^-1)^3 on places j, j+1, j+2\n      const j = floor(c / 6) % (n - 2);\n      return c % 2 ? [j + 1, -1] : [j, 1];\n    }\n    case 3: { // s1 s2 s1 s2^-1 s1^-1 s2^-1 on places j, j+1, j+2\n      const j = floor(c / 6) % (n - 2), k = c % 6;\n      return [j + [0, 1, 0, 1, 0, 1][k], k \u003c 3 ? 1 : -1];\n    }\n    case 4: // a random positive braid\n      return [floor(Math.random() * (n - 1)), 1];\n    default: {\n      // Random, but never a letter straight after its own inverse.\n      let i, s;\n      do {\n        i = floor(Math.random() * (n - 1));\n        s = Math.random() \u003c 0.5 ? 1 : -1;\n      } while (S.last && i === S.last[0] && s === -S.last[1]);\n      return [i, s];\n    }\n  }\n}\n\nfunction reset(S, n, word) {\n  S.n = n;\n  S.word = word;\n  S.sp = W / n;\n  S.r = S.sp / 2;\n  // Rows a generator takes: the crossings keep about the same slope for any\n  // number of strands, about 1.7 LEDs across a row at the steepest.\n  S.dt = 1 / cl(round(S.sp * 1.15), 11, 26);\n  S.perm = Array.from({ length: n }, (_, k) => k);\n  S.c = 0;\n  S.last = null;\n  S.g0 = 0;\n  S.gen = nextLetter(S);\n  S.home = 0;\n  // Samples of every strand's x and depth, KEEP of them in a ring.\n  S.hx = new Float32Array(KEEP * n);\n  S.hz = new Float32Array(KEEP * n);\n  S.k = 0;\n  S.t = 0;\n  // Pre-fill: run the braid until the picture reaches the bottom.\n  while (S.k \u003c KEEP) push(S);\n  S.t = (S.k - 1) * S.dt;\n  S.nowX = new Float32Array(n);\n  S.nowZ = new Float32Array(n);\n}\n\nconst placeX = (S, k) => (k + 0.5) * S.sp;\n\n// Move the braid on to time t, finishing generators on the way.\nfunction advance(S, t) {\n  while (t >= S.g0 + 1) {\n    const [i] = S.gen;\n    const p = S.perm;\n    [p[i], p[i + 1]] = [p[i + 1], p[i]];\n    S.last = S.gen;\n    S.g0 += 1;\n    S.gen = nextLetter(S);\n    if (p.every((s, k) => s === k)) S.home = 1;\n  }\n}\n\n// Each strand's x and depth at time t (after advance).\nfunction state(S, t, X, Z) {\n  const { n, perm, gen, r } = S;\n  for (let k = 0; k \u003c n; k++) {\n    X[perm[k]] = placeX(S, k);\n    Z[perm[k]] = 0;\n  }\n  const [i, s] = gen;\n  const th = PI * ease((t - S.g0) / TURN);\n  const m = (placeX(S, i) + placeX(S, i + 1)) / 2;\n  const a = perm[i], b = perm[i + 1];\n  X[a] = m - r * cos(th);\n  X[b] = m + r * cos(th);\n  // Depth is how far below the strip's middle line a point is.\n  Z[a] = s * r * sin(th);\n  Z[b] = -s * r * sin(th);\n}\n\nfunction push(S) {\n  const t = S.k * S.dt, o = (S.k % KEEP) * S.n;\n  advance(S, t);\n  state(S, t, S.hx.subarray(o, o + S.n), S.hz.subarray(o, o + S.n));\n  S.k++;\n}\n\nexport function setup(params) {\n  params.s = { n: 0, word: -1, rowZ: new Float32Array(W), rowS: new Int8Array(W), rowA: new Float32Array(W), px: new Float32Array(8), pz: new Float32Array(8), qx: new Float32Array(8), qz: new Float32Array(8) };\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const n = cl(round(k[2]), 3, 7), word = cl(round(k[3]), 0, 4);\n  if (n !== S.n || word !== S.word) reset(S, n, word);\n  S.t += (dt * cl(k[1], 0.05, 3)) / 2 / GEN;\n  while (S.k * S.dt \u003c= S.t) push(S);\n  advance(S, S.t);\n  state(S, S.t, S.nowX, S.nowZ);\n  S.home = max(0, S.home - dt * 1.2);\n}\n\nfunction setDisc(display, cx, cy, rad, rgb, lv) {\n  for (let y = max(0, floor(cy - rad - 1)); y \u003c= min(BAND - 1, floor(cy + rad + 1)); y++)\n    for (let x = max(0, floor(cx - rad - 1)); x \u003c= min(W - 1, floor(cx + rad + 1)); x++) {\n      const d = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2);\n      const a = cl(rad - d + 0.5, 0, 1);\n      if (a \u003c= 0) continue;\n      // A little white in the middle, like a bead lit from above.\n      const w = 0.45 * max(0, 1 - d / (rad * 0.7));\n      const v = a * lv;\n      display.setPixel(x, y, (rgb[0] * (1 - w) + w) * v * 255, (rgb[1] * (1 - w) + w) * v * 255, (rgb[2] * (1 - w) + w) * v * 255);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.n) return;\n  const { n, sp, r, dt, rowZ, rowS, rowA } = S;\n  const cols = [];\n  for (let s = 0; s \u003c n; s++) cols.push(hsv(0.55 + S.hue + (0.8 * s) / (n - 1), 0.78, 1));\n\n  // ---- The space-time picture. Row y shows the braid u = y + 0.5 - BAND\n  // rows ago. The newest sample sits frac of a row below the strip.\n  const last = S.k - 1, frac = (S.t - last * dt) / dt;\n  const hw = 0.15 * sp, gw = 0.07 * sp + 0.8, eps = 0.2 * r;\n  const { px, pz, qx, qz } = S;\n  for (let y = BAND; y \u003c H; y++) {\n    const u = y + 0.5 - BAND, mm = u - frac;\n    let w;\n    if (mm \u003c 0) {\n      // Between now and the newest sample.\n      const o = (last % KEEP) * n;\n      for (let s = 0; s \u003c n; s++) (px[s] = S.nowX[s]), (pz[s] = S.nowZ[s]), (qx[s] = S.hx[o + s]), (qz[s] = S.hz[o + s]);\n      w = (mm + frac) / max(frac, 1e-6);\n    } else {\n      const j = floor(mm);\n      if (last - j - 1 \u003c 0) break;\n      const o0 = ((last - j) % KEEP) * n, o1 = ((last - j - 1) % KEEP) * n;\n      for (let s = 0; s \u003c n; s++) (px[s] = S.hx[o0 + s]), (pz[s] = S.hz[o0 + s]), (qx[s] = S.hx[o1 + s]), (qz[s] = S.hz[o1 + s]);\n      w = mm - j;\n    }\n    rowS.fill(-1);\n    for (let s = 0; s \u003c n; s++) {\n      const xc = px[s] + (qx[s] - px[s]) * w, z = pz[s] + (qz[s] - pz[s]) * w;\n      // Across a sloped strand a row cuts a wider piece.\n      const sec = sqrt(1 + (qx[s] - px[s]) ** 2);\n      const reach = (hw + gw) * sec + 1;\n      for (let x = max(0, floor(xc - reach)); x \u003c= min(W - 1, floor(xc + reach)); x++) {\n        const d = abs(x + 0.5 - xc) / sec;\n        if (d >= hw + gw) continue;\n        const a = cl(hw - d + 0.5, 0, 1) * (1 - 0.4 * (d / hw) ** 2);\n        const held = rowS[x];\n        if (held \u003c 0 || (held !== s && z > rowZ[x] + eps)) {\n          // In front: its core, or the dark gap round it, covers what is behind.\n          rowS[x] = s;\n          rowZ[x] = z;\n          rowA[x] = max(0, a);\n        } else if (held === s) rowA[x] = max(rowA[x], a);\n        else if (z >= rowZ[x] - eps && a > rowA[x]) {\n          // Level with it: the brighter wins, and no gap is cut.\n          rowS[x] = s;\n          rowZ[x] = z;\n          rowA[x] = a;\n        }\n      }\n    }\n    // Older rows dim a little, and a strand behind is a little darker.\n    const fade = 1 - (0.4 * u) / ROWS;\n    for (let x = 0; x \u003c W; x++) {\n      const s = rowS[x];\n      if (s \u003c 0 || rowA[x] \u003c= 0) continue;\n      const v = rowA[x] * fade * (0.86 + (0.14 * rowZ[x]) / r);\n      const c = cols[s];\n      display.setPixel(x, y, c[0] * v * 255, c[1] * v * 255, c[2] * v * 255);\n    }\n  }\n\n  // ---- The strip. A faint floor, the home of each colour as a tick on the\n  // near edge (bright when its own strand stands on it), and a flash of the\n  // edges when every strand is home.\n  const home = S.home;\n  for (let x = 0; x \u003c W; x++) {\n    const e = 34 + 150 * home;\n    display.setPixel(x, 0, e, e, e * 1.1);\n    display.setPixel(x, BAND - 1, e, e, e * 1.1);\n    for (let y = 1; y \u003c BAND - 1; y++) display.setPixel(x, y, 5, 6, 12);\n  }\n  for (let k = 0; k \u003c n; k++) {\n    const c = cols[k], x0 = placeX(S, k), lv = S.perm[k] === k ? 0.9 : 0.3;\n    for (let x = floor(x0 - 2); x \u003c x0 + 2; x++) display.setPixel(x, BAND - 2, c[0] * lv * 255, c[1] * lv * 255, c[2] * lv * 255);\n  }\n  // The circle the turning pair runs on, while it turns.\n  const [gi, gs] = S.gen, p = (S.t - S.g0) / TURN;\n  if (p \u003c 1) {\n    const m = (placeX(S, gi) + placeX(S, gi + 1)) / 2, lv = 70 * sin(PI * cl(p, 0, 1)) ** 0.5;\n    for (let y = 1; y \u003c BAND - 1; y++)\n      for (let x = max(0, floor(m - r - 1)); x \u003c= min(W - 1, floor(m + r + 1)); x++) {\n        const d = abs(sqrt((x + 0.5 - m) ** 2 + (y + 0.5 - CY) ** 2) - r);\n        if (d \u003c 0.7) display.setPixel(x, y, lv, lv, lv * 1.15);\n      }\n  }\n  // The points.\n  const pr = cl(0.3 * sp, 2.3, 3.6);\n  for (let s = 0; s \u003c n; s++) setDisc(display, S.nowX[s], CY + S.nowZ[s], pr, cols[s], 1);\n  // The generator playing, as its index with a minus for an inverse.\n  const dg = DIGITS[gi + 1] || DIGITS[0];\n  for (let b = 0; b \u003c 15; b++) if (dg[b] === \"1\") display.setPixel(5 + (b % 3), 2 + floor(b / 3), 150, 150, 165);\n  if (gs \u003c 0) for (let x = 1; x \u003c 4; x++) display.setPixel(x, 4, 150, 150, 165);\n}\n","blinking-vortex":"// ===== Patternflow pattern =====\n// Title:   Blinking Vortex\n// Family:  sim\n// Idea:    Two point vortices one above the other take turns, each spinning the fluid round itself for half a period while the other rests, and soft bands of two dyes, traced back exactly through every turn, are stretched and folded into filaments until they are finer than an LED and blend to one even colour, when a fresh dye is laid.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the blinking vortex flow (Hassan Aref, Stirring by chaotic advection, J. Fluid Mech. 143, 1984), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strength=2..16, Dye=0..3\n//\n// Knob 1: Hue. Turns both dyes round the wheel: at 0 one is turquoise and the other violet, both brightest in blue, so where they are mixed finer than an LED the brightness holds and only the colour blends to periwinkle.\n// Knob 2: Speed. Half periods a second: 2.2 at 2, 0.22 at 0.2, 3.3 at 3.\n// Knob 3: Strength. The stirring strength mu = Gamma T / (2 pi a^2), with 2a the distance between the vortices: fluid at the midpoint turns mu/2 radians each half period. At 2 each vortex winds the bands into its own spiral and the bands beyond them stay whole while an S of mixed dye grows between; past about 5 the S fills the middle within two half periods. A dye lasts 12/mu half periods, 6 at 2 and 3 from 4 up. The whole history is traced again at the new strength, so the picture answers at once.\n// Knob 4: Dye. How the dye is laid: 0 bands across the panel, 20 rows each; 1 two halves either side of the line through the vortices, shaded in bands of 32 rows; 2 stripes down the panel, 16 columns each; 3 rings round the midpoint, 16 LEDs each. Every band is brightest along its middle and dark where the colour changes.\n// Buttons: any knob's button lays a fresh dye now.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Aref's flow had a circular wall; this one is the unbounded plane, so each\n// vortex alone is the exact point-vortex field: fluid at distance r turns\n// about it at Gamma / (2 pi r^2) radians a second and r never changes. A half\n// period is then an exact rotation by an angle that depends on r alone,\n//   theta(r) = Gamma T / (4 pi r^2) = mu a^2 / (2 r^2),\n// with 2a the distance between the vortices. The vortices themselves never\n// move: only one is on at a time, and a vortex is not moved by its own field.\nconst AV = 30, CX = 32, YA = 64 - AV, YB = 64 + AV, A2 = AV * AV;\n\n// A dye lasts 12 / mu half periods (3 to 6), then a fresh one fades in at\n// the start of the next. By then an S of dye mixed finer than an LED joins\n// the two vortices.\nconst life = (mu) => cl(round(12 / mu), 3, 6);\n// A fresh start begins this far into a dye, so the stirring shows at once.\nconst AHEAD = 2;\n\n// The angles reach thousands of radians next to a vortex, so sine and cosine\n// come from a table of 4096 steps with linear interpolation: an error near\n// 3e-7, far below an LED, at half the cost of Math.sin and Math.cos.\nconst TB = 4096, MASK = TB - 1, KT = TB / (2 * PI);\nconst SN = new Float64Array(TB + 1), CS = new Float64Array(TB + 1);\nfor (let i = 0; i \u003c= TB; i++) (SN[i] = sin(i / KT)), (CS[i] = cos(i / KT));\n\n// One sample an LED, at its centre, and the LED's own square traced back\n// with it: each half period's rotation has an exact Jacobian, so the square's\n// two edges are carried back step by step, and the dye is averaged over the\n// patch of the first dye they cover. Where the stirring has pulled one LED's\n// worth of fluid out over many bands, the LED shows their mean instead of\n// one band picked at random.\n//\n// The dye has two parts laid along one coordinate u: bands (u = y), stripes\n// (u = x) or rings round the midpoint (u = distance), or two halves either\n// side of the vortices (u = x - 32, with the shade along y). Its colour,\n// dye A or dye B, changes sharply every P / 2 along u. Its shade rises and\n// falls as a cosine of period P / 2, darkest where the colour changes and\n// brightest in the middle of each band. The two colours share\n// their brightest channel, so a colour edge never shows as a step in\n// brightness; only the shade does, and the shade is soft.\nconst LAYOUTS = [\n  { u: 1, P: 40 },\n  { u: 3, P: 64 },\n  { u: 0, P: 32 },\n  { u: 2, P: 32 },\n];\n// Shade: L0 - L1 cos(4 pi u / P), from 0.17 to 0.97.\nconst L0 = 0.57, L1 = 0.4;\n// The shade is averaged as if the LED were BLUR times its traced size, so a\n// band of shade fades into its mean before it is squeezed steep enough to\n// step more than 40 levels from one LED to the next; the colour is averaged\n// over the LED's own traced size.\nconst BLUR = 3;\n\n// The length of [0, P/2) mod P that lies below u.\nfunction below(u, P) {\n  const k = floor(u / P), r = u - k * P;\n  return k * (P / 2) + (r > P / 2 ? P / 2 : r);\n}\n\n// The share of dye A in a box of width w round u.\nfunction shareA(halves, u, w, P) {\n  if (halves) return w \u003c 1e-6 ? (u \u003c 0 ? 1 : 0) : cl(0.5 - u / w, 0, 1);\n  if (w \u003c 1e-3) return u - floor(u / P) * P \u003c P / 2 ? 1 : 0;\n  if (w > 1e7) return 0.5;\n  return (below(u + w / 2, P) - below(u - w / 2, P)) / w;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: AHEAD, f: 0, born: 0, gen: 0, old: -1, fade: 1,\n    hue: 0, mu: 2, layout: 0,\n    cv: [0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.mu = cl(k[2], 2, 16);\n  S.layout = cl(round(k[3]), 0, 3);\n  const rate = d * cl(k[1], 0.2, 3) * 1.1;\n  S.f += rate;\n  // A new dye fades in over 0.4 of a half period while the old one, still\n  // being stirred under it, fades out.\n  if (S.old >= 0 && (S.fade += rate * 2.5) >= 1) S.old = -1;\n  const lay = () => ((S.old = S.born), (S.born = S.n), (S.gen ^= 1), (S.fade = 0));\n  while (S.f >= 1) {\n    S.f -= 1;\n    S.n++;\n    if (S.old \u003c 0 && S.n - S.born >= life(S.mu)) lay();\n  }\n  // A press lays a fresh dye now.\n  if (input.btnPressed && input.btnPressed.some(Boolean) && S.old \u003c 0) lay();\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const n = S.n, f = S.f, c = (S.mu * A2) / 2, L = LAYOUTS[S.layout], gen = S.gen, cv = S.cv;\n  // The new dye was laid at the start of half period born: it has been turned\n  // by the whole half periods born..n-1 and part of n. An old dye still\n  // fading out has been turned longer.\n  const sNew = n - S.born + 1, sOld = S.old >= 0 ? n - S.old + 1 : -1;\n  const steps = max(sNew, sOld);\n  const fi = S.fade, wNew = sOld >= 0 ? fi * fi * (3 - 2 * fi) : 1;\n  // Both dyes keep blue as their brightest channel at the opening hue.\n  const dyeA = hsv(0.51 + S.hue, 0.75, 1), dyeB = hsv(0.79 + S.hue, 0.6, 1);\n  const col = (a, lv, g, ch) => lv * (g ? dyeB[ch] * a + dyeA[ch] * (1 - a) : dyeA[ch] * a + dyeB[ch] * (1 - a));\n  for (let j = 0; j \u003c H; j++)\n    for (let i = 0; i \u003c W; i++) {\n      let x = i + 0.5, y = j + 0.5;\n      // The LED's two edges, carried back with it.\n      let ux = 1, uy = 0, vx = 0, vy = 1;\n      // Undo the part of the current half period already turned, then the\n      // whole half periods before it, newest first. Half period m is\n      // stirred by vortex A when m is even and by B when it is odd.\n      let frac = f, m = n, aN = 0, lN = 0;\n      for (let s = 0; s \u003c steps; s++) {\n        const cy = m & 1 ? YB : YA, dx = x - CX, dy = y - cy, r2 = dx * dx + dy * dy + 1e-9;\n        const th = (frac * c) / r2;\n        let a = th * KT;\n        if (a > 1e9) a %= TB;\n        const a0 = a | 0, t = a - a0, q = a0 & MASK;\n        const co = CS[q] + t * (CS[q + 1] - CS[q]), sn = SN[q] + t * (SN[q + 1] - SN[q]);\n        // Back in time: rotate by minus the angle. The angle falls off as\n        // 1/r^2, so an edge e first shears by (2 theta / r^2)(d . e) along\n        // the circle and then turns with the point.\n        const sh = (2 * th) / r2, pu = sh * (dx * ux + dy * uy), pv = sh * (dx * vx + dy * vy);\n        const ux1 = ux - dy * pu, uy1 = uy + dx * pu, vx1 = vx - dy * pv, vy1 = vy + dx * pv;\n        ux = co * ux1 + sn * uy1, uy = co * uy1 - sn * ux1;\n        vx = co * vx1 + sn * vy1, vy = co * vy1 - sn * vx1;\n        x = CX + dx * co + dy * sn;\n        y = cy - dx * sn + dy * co;\n        frac = 1;\n        m--;\n        if (s + 1 === sNew) dyeAt(L, x, y, ux, uy, vx, vy, cv), (aN = cv[0]), (lN = cv[1]);\n      }\n      let r = col(aN, lN, gen, 0), g = col(aN, lN, gen, 1), b = col(aN, lN, gen, 2);\n      if (wNew \u003c 1) {\n        dyeAt(L, x, y, ux, uy, vx, vy, cv);\n        const k = 1 - wNew;\n        r = r * wNew + k * col(cv[0], cv[1], gen ^ 1, 0);\n        g = g * wNew + k * col(cv[0], cv[1], gen ^ 1, 1);\n        b = b * wNew + k * col(cv[0], cv[1], gen ^ 1, 2);\n      }\n      display.setPixel(i, j, (255 * min(1, r)) | 0, (255 * min(1, g)) | 0, (255 * min(1, b)) | 0);\n    }\n  // The vortices: the one stirring burns white, the resting one is a dim ring.\n  const on = n & 1 ? 1 : 0;\n  for (let v = 0; v \u003c 2; v++) {\n    const cy = v ? YB : YA, act = v === on;\n    for (let dy = -2; dy \u003c= 1; dy++)\n      for (let dx = -2; dx \u003c= 1; dx++) {\n        const r = sqrt((dx + 0.5) * (dx + 0.5) + (dy + 0.5) * (dy + 0.5));\n        const x = CX + dx, y = cy + dy;\n        if (act) {\n          const b = r \u003c 1 ? 255 : r \u003c 2 ? 150 : 0;\n          if (b) display.setPixel(x, y, b, b, b);\n        } else if (r > 1 && r \u003c 2.2) display.setPixel(x, y, 120, 120, 130);\n        else if (r \u003c 1) display.setPixel(x, y, 0, 0, 0);\n      }\n  }\n}\n\n// The dye at the traced-back point (x, y), averaged over what the LED's\n// traced-back edges cover: out[0] the share of dye A, out[1] the shade.\nfunction dyeAt(L, x, y, ux, uy, vx, vy, out) {\n  let u, w;\n  if (L.u === 1) (u = y), (w = abs(uy) + abs(vy));\n  else if (L.u === 0 || L.u === 3) (u = L.u === 3 ? x - CX : x), (w = abs(ux) + abs(vx));\n  else {\n    const dx = x - CX, dy = y - 64, r = sqrt(dx * dx + dy * dy) + 1e-9, gx = dx / r, gy = dy / r;\n    (u = r), (w = abs(gx * ux + gy * uy) + abs(gx * vx + gy * vy));\n  }\n  // A square pulled out longer than a period does not stay straight: the\n  // flow folds it, so it crosses the bands even when its two traced edges\n  // happen to lie along them. Past a period, its length counts as width.\n  const s = sqrt(ux * ux + uy * uy + vx * vx + vy * vy), fold = (s * s) / (s + L.P);\n  out[0] = shareA(L.u === 3, u, max(w, fold), L.P);\n  // The halves take their shade from bands along y.\n  let us = u, ws = w;\n  if (L.u === 3) (us = y), (ws = abs(uy) + abs(vy));\n  // A cosine averaged over a Gaussian as wide as the box keeps\n  // exp(-(k w)^2 / 24) of its swing, k its wavenumber.\n  const kw = ((4 * PI) / L.P) * BLUR * max(ws, fold);\n  out[1] = L0 - L1 * exp(-(kw * kw) / 24) * cos(((4 * PI) / L.P) * us);\n}\n","braille-relief":"// ===== Patternflow pattern =====\n// Title:   Braille Relief\n// Family:  type\n// Idea:    A page of embossed six-dot braille lies in the dark under a low lamp that circles it, so each raised dot shows only as a lit side and a long shadow, while a fingertip glow reads along the lines cell by cell and the print letter it has just felt surfaces small under the cell and fades.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: six-dot braille (Louis Braille, Procédé pour écrire les paroles, la musique et le plain-chant au moyen de points, 1829), uncontracted English letters; text from Helen Keller, The Story of My Life (1903); pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Relief=0.4..2.4, Light=0..1\n//\n// Knob 1: Hue. Turns the lamp, the shade and the print round the wheel together: at 0 a cream lamp on cool grey paper, blue-violet in the shadows, the print letters pale sky blue.\n// Knob 2: Speed. How fast the fingertip reads: 2.5 cells a second at 2, so the 40 cells of the first page take 16 s, 0.25 at 0.2 and 3.75 at 3. The lamp circles the page once in 16 s at 2, once in 36 s at 0.2, so the light moves however slowly the page is read.\n// Knob 3: Relief. The height of each dot, from 0.4 LED, barely raised, where the lamp finds a lit rim and a short shadow, to 2.4 LEDs, where every dot throws a shadow down the page across the dots behind it.\n// Knob 4: Light. How high the lamp stands: 3 degrees above the paper at 0 (4 at the opening 0.06), where the dots blaze on one side and their shadows run 19 times their height (14 at the opening); 20 degrees at 1, where the shadows shrink to under 3 times and the dots fade to a faint crescent.\n// Buttons: any knob's button turns to the next page.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Braille. Dots are numbered 1-2-3 down the left column and 4-5-6 down\n// the right. The first ten letters use only dots 1, 2, 4 and 5; k to t are\n// a to j with dot 3 added; u, v, x, y and z are a to e with dots 3 and 6\n// added; w stands outside the series as 2-4-5-6. A word broken at the end of\n// a line takes the hyphen, dots 3-6. Checked against Unicode's braille block:\n// a to z come out as U+2801 2803 2809 2819 2811 280B 281B 2813 280A 281A 2805\n// 2807 280D 281D 2815 280F 281F 2817 280E 281E 2825 2827 283A 282D 283D 2835.\nconst AJ = [[1], [1, 2], [1, 4], [1, 4, 5], [1, 5], [1, 2, 4], [1, 2, 4, 5], [1, 2, 5], [2, 4], [2, 4, 5]];\nconst DOTS = { \" \": [], \"-\": [3, 6], w: [2, 4, 5, 6] };\nfor (let i = 0; i \u003c 10; i++) {\n  DOTS[\"abcdefghij\"[i]] = AJ[i];\n  DOTS[\"klmnopqrst\"[i]] = [...AJ[i], 3];\n  if (i \u003c 5) DOTS[\"uvxyz\"[i]] = [...AJ[i], 3, 6];\n}\n\n// Helen Keller at the well-house, from chapter IV of The Story of My Life.\n// Grade 1 braille, letters and spaces only: the capital sign (dot 6) before\n// Everything and I is left out, and so are the comma and the full stops. No\n// number sign is needed, as the text has no numbers. 119 letters in 29 words\n// fill four pages with 4 hyphens and 354 raised dots.\nconst TEXT =\n  \"every|thing had a name and each name gave birth to a new thought as we re|turned to the house every ob|ject which i touched seemed to quiv|er with life\";\n\n// ---- The page. Dots 4 LEDs apart inside a cell, cells 10 apart, six to a\n// line; lines 18 apart, seven to a page, which leaves a gap of 7 rows under\n// each line for the print letter. Embossed braille keeps about 2.5 mm, 6 mm\n// and 10 mm; this page keeps the first two near that ratio and sets its lines\n// a little wider for the letters.\nconst DP = 4, CP = 10, NC = 6, LP = 18, NL = 7, X0 = 5, Y0 = 3, R = 1.75;\nconst PER = NC * NL;\n\n// Words go whole onto a line when they fit. A word that does not fit the\n// room left is broken at a syllable marked | in the text if its first part\n// and a hyphen fit, and otherwise starts a new line. A word longer than the\n// whole line (thought, touched) has no other way and is broken after five\n// letters.\nfunction paginate(text) {\n  const cells = [];\n  let col = 0;\n  const put = (ch) => {\n    cells.push(ch);\n    col = (col + 1) % NC;\n  };\n  const newline = () => {\n    while (col > 0) put(\" \");\n  };\n  for (const word of text.split(\" \")) {\n    const parts = word.split(\"|\");\n    let w = parts.join(\"\");\n    if (w.length > NC - col) {\n      let cut = 0;\n      for (let i = 1, k = 0; i \u003c parts.length; i++) {\n        k += parts[i - 1].length;\n        if (k + 1 \u003c= NC - col) cut = k;\n      }\n      if (cut) {\n        for (const ch of w.slice(0, cut)) put(ch);\n        put(\"-\");\n        w = w.slice(cut);\n      } else newline();\n    }\n    while (w.length > NC) {\n      for (const ch of w.slice(0, NC - 1)) put(ch);\n      put(\"-\");\n      w = w.slice(NC - 1);\n    }\n    for (const ch of w) put(ch);\n    if (col > 0) put(\" \");\n  }\n  while (cells.length % PER) cells.push(\" \");\n  const pages = [];\n  for (let i = 0; i \u003c cells.length; i += PER) pages.push(cells.slice(i, i + PER));\n  return pages;\n}\nconst PAGES = paginate(TEXT);\n// The fingertip stops at the last letter of a page, not at the blank cells\n// that pad the last page out.\nconst ENDS = PAGES.map((pg) => {\n  let e = PER;\n  while (e > 1 && pg[e - 1] === \" \") e--;\n  return e;\n});\n\n// Dot slot s = (line * NC + cell) * 6 + (dot - 1); its centre falls on a\n// corner between LEDs, so a dot is a round 4 by 4 patch.\nconst NS = PER * 6, SX = new Float32Array(NS), SY = new Float32Array(NS);\nfor (let s = 0; s \u003c NS; s++) {\n  const c = floor(s / 6), k = s % 6;\n  SX[s] = X0 + (c % NC) * CP + floor(k / 3) * DP;\n  SY[s] = Y0 + floor(c / NC) * LP + (k % 3) * DP;\n}\nconst raised = (page, s) => DOTS[page[floor(s / 6)]].includes((s % 6) + 1);\n\n// ---- Print letters, 3 by 5, as small capitals: lowercase would need\n// descenders the gap under a line has no room for.\nconst FONT = {\n  a: \"010101111101101\", b: \"110101110101110\", c: \"011100100100011\", d: \"110101101101110\",\n  e: \"111100110100111\", f: \"111100110100100\", g: \"011100101101011\", h: \"101101111101101\",\n  i: \"111010010010111\", j: \"001001001101010\", k: \"101101110101101\", l: \"100100100100111\",\n  m: \"101111111101101\", n: \"110101101101101\", o: \"010101101101010\", p: \"110101110100100\",\n  q: \"010101101110011\", r: \"110101110101101\", s: \"011100010001110\", t: \"111010010010010\",\n  u: \"101101101101111\", v: \"101101101101010\", w: \"101101111111101\", x: \"101101010101101\",\n  y: \"101101010010010\", z: \"111001010100111\", \"-\": \"000000111000000\",\n};\n\n// ---- Paper grain: a fixed field of tiny slopes from a hash, smoothed, so the\n// paper glints a little where its fibres face the lamp.\nconst GX = new Float32Array(W * H), GY = new Float32Array(W * H);\n{\n  const hz = new Float32Array(W * H);\n  for (let i = 0; i \u003c W * H; i++) {\n    let h = (i * 2654435761) >>> 0;\n    h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0;\n    h = Math.imul(h ^ (h >>> 13), 3266489917) >>> 0;\n    hz[i] = ((h ^ (h >>> 16)) >>> 0) / 4294967296 - 0.5;\n  }\n  const sm = new Float32Array(W * H);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let a = 0;\n      for (let dy = -1; dy \u003c= 1; dy++)\n        for (let dx = -1; dx \u003c= 1; dx++) a += hz[cl(y + dy, 0, H - 1) * W + cl(x + dx, 0, W - 1)];\n      sm[y * W + x] = a / 9;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      GX[y * W + x] = 0.04 * (sm[y * W + min(W - 1, x + 1)] - sm[y * W + max(0, x - 1)]);\n      GY[y * W + x] = 0.04 * (sm[min(H - 1, y + 1) * W + x] - sm[max(0, y - 1) * W + x]);\n    }\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, relief: 0.4, light: 0.06, az: -2.4,\n    page: 0, read: 0, cell: 0, hold: 0, turn: 0,\n    seen: new Float32Array(PER).fill(-99),\n    lift: new Float32Array(NS),\n    cov: new Float32Array(W * H), lit: new Float32Array(W * H), hgt: new Float32Array(W * H),\n    own: new Int16Array(W * H), sh: new Float32Array(W * H), rgb: new Float32Array(W * H * 3),\n  };\n  const S = params.s;\n  for (let s = 0; s \u003c NS; s++) S.lift[s] = raised(PAGES[0], s) ? 1 : 0;\n  S.seen[0] = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.relief = cl(k[2], 0.4, 2.4);\n  S.light = cl(k[3], 0, 1);\n  // The lamp keeps circling however slowly the page is read.\n  S.az += d * (0.15 + 0.12 * S.speed);\n  let page = PAGES[S.page];\n  if (S.turn === 0) {\n    // Reading: the fingertip steps cell by cell, gliding over the first\n    // quarter of each step.\n    S.read += d * 1.25 * S.speed;\n    const c = floor(S.read);\n    if (c >= ENDS[S.page]) (S.turn = 1), (S.hold = 0), (S.read = ENDS[S.page] - 1e-6);\n    else if (c !== S.cell) (S.cell = c), (S.seen[c] = S.t);\n  } else {\n    // The page turns: hold 1.2 s, the dots sink in 0.8 s, and the next\n    // page is embossed line by line from the top.\n    S.hold += d;\n    if (S.turn === 1) {\n      const u = cl((S.hold - 1.2) / 0.8, 0, 1);\n      for (let s = 0; s \u003c NS; s++) S.lift[s] = raised(page, s) ? 1 - u * u * (3 - 2 * u) : 0;\n      if (u >= 1) (S.turn = 2), (S.hold = 0), (S.page = (S.page + 1) % PAGES.length), (page = PAGES[S.page]), S.seen.fill(-99);\n    } else {\n      for (let s = 0; s \u003c NS; s++) {\n        const u = cl((S.hold - 0.18 * floor(s / 6 / NC)) / 0.5, 0, 1);\n        S.lift[s] = raised(page, s) ? u * u * (3 - 2 * u) : 0;\n      }\n      if (S.hold > 0.18 * NL + 0.5) {\n        S.turn = 0, S.read = 0, S.cell = 0;\n        S.seen.fill(-99);\n        S.seen[0] = S.t;\n      }\n    }\n  }\n  // Any button turns to the next page now.\n  if (S.turn === 0 && input.btnPressed && input.btnPressed.some(Boolean)) (S.turn = 1), (S.hold = 1.2);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cov, lit, hgt, own, sh, lift, rgb } = S;\n  // The lamp: elevation e, toward-the-lamp direction (ux, uy) on the page.\n  const e = ((3 + 17 * S.light) * PI) / 180, se = sin(e), ce = cos(e), te = se / ce;\n  const ux = cos(S.az), uy = sin(S.az), Lx = ce * ux, Ly = ce * uy;\n  cov.fill(0), lit.fill(0), hgt.fill(0), own.fill(-1), sh.fill(0);\n\n  // Domes: h = Hd (1 - r^2 / R^2), shaded at 3 by 3 points in each LED by\n  // the lamp's angle to the surface.\n  for (let s = 0; s \u003c NS; s++) {\n    const Hd = S.relief * lift[s];\n    if (Hd \u003c 0.01) continue;\n    const cx = SX[s], cy = SY[s], g = (2 * Hd) / (R * R);\n    for (let py = cy - 2; py \u003c cy + 2; py++)\n      for (let px = cx - 2; px \u003c cx + 2; px++) {\n        const p = py * W + px;\n        let n = 0, v = 0;\n        for (let sy = 0; sy \u003c 3; sy++)\n          for (let sx = 0; sx \u003c 3; sx++) {\n            const dx = px + (sx + 0.5) / 3 - cx, dy = py + (sy + 0.5) / 3 - cy, r2 = dx * dx + dy * dy;\n            if (r2 >= R * R) continue;\n            // Normal (g dx, g dy, 1), unnormalised.\n            const hx = g * dx, hy = g * dy;\n            v += max(0, (hx * Lx + hy * Ly + se) / sqrt(hx * hx + hy * hy + 1));\n            n++;\n          }\n        if (!n) continue;\n        cov[p] = n / 9, lit[p] = v / 9;\n        const dx = px + 0.5 - cx, dy = py + 0.5 - cy, r2 = dx * dx + dy * dy;\n        if (r2 \u003c R * R) (hgt[p] = Hd * (1 - r2 / (R * R))), (own[p] = s);\n      }\n  }\n\n  // Cast shadows. A point at height z0 is in the shadow of a dome when the\n  // ray from it toward the lamp, climbing te per LED, passes under the dome.\n  // For the paraboloid this has a closed form: with d the offset from the\n  // dome's centre split along (dp) and across (dq) the lamp's direction, the\n  // ray's lowest clearance is\n  //   f = Hd + te^2 R^2 / (4 Hd) - Hd dq^2 / R^2 + te dp - z0,\n  // reached at distance s = -dp - te R^2 / (2 Hd) along the ray, so the\n  // shadow on flat paper is a parabola Hd / te long. f > 0 is shadow, softened\n  // over a penumbra that widens with s.\n  for (let s = 0; s \u003c NS; s++) {\n    const Hd = S.relief * lift[s];\n    if (Hd \u003c 0.01) continue;\n    const cx = SX[s], cy = SY[s], len = Hd / te + R + 1;\n    const x0 = max(0, floor(min(cx, cx - len * ux) - R - 1)), x1 = min(W - 1, ceil(max(cx, cx - len * ux) + R + 1));\n    const y0 = max(0, floor(min(cy, cy - len * uy) - R - 1)), y1 = min(H - 1, ceil(max(cy, cy - len * uy) + R + 1));\n    const sStar0 = (te * R * R) / (2 * Hd), k0 = Hd + (te * te * R * R) / (4 * Hd), kq = Hd / (R * R);\n    for (let py = y0; py \u003c= y1; py++)\n      for (let px = x0; px \u003c= x1; px++) {\n        const p = py * W + px;\n        if (own[p] === s) continue;\n        const dx = px + 0.5 - cx, dy = py + 0.5 - cy, dp = dx * ux + dy * uy, dq = -dx * uy + dy * ux;\n        const ss = -dp - sStar0;\n        if (ss \u003c= 0) continue;\n        const f = k0 - kq * dq * dq + te * dp - hgt[p];\n        if (f \u003c= -0.3) continue;\n        const a = cl(f / (0.1 + 0.05 * ss) + 0.5, 0, 1);\n        if (a > sh[p]) sh[p] = a;\n      }\n  }\n\n  // The fingertip rests on the cell being read and glides on to the next\n  // one over the first quarter of each step.\n  const cell = min(PER - 1, floor(S.read)), fr = S.read - cell, gl = min(1, fr * 4);\n  let fx = X0 + (cell % NC) * CP + 2, fy = Y0 + floor(cell / NC) * LP + 4;\n  if (S.turn === 0 && cell > 0 && gl \u003c 1) {\n    const pc = cell - 1, sm = gl * gl * (3 - 2 * gl);\n    const qx = X0 + (pc % NC) * CP + 2, qy = Y0 + floor(pc / NC) * LP + 4;\n    (fx = qx + (fx - qx) * sm), (fy = qy + (fy - qy) * sm);\n  }\n  // The hand lifts while the page turns.\n  const touch = S.turn === 0 ? 1 : S.turn === 1 ? max(0, 1 - S.hold / 1.2) : 0;\n\n  // Compose. Brightness goes by the ratio of light on a surface to the\n  // light on bare paper, so the paper stays dim at every elevation; a\n  // distant lamp falls off a little across the page.\n  const lamp = hsv(0.11 + S.hue, 0.45, 1), shade = hsv(0.68 + S.hue, 0.7, 1), paperC = hsv(0.62 + S.hue, 0.12, 0.95);\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px;\n      const gx = GX[p], gy = GY[p];\n      const paper = max(0, (-gx * Lx - gy * Ly + se) / sqrt(1 + gx * gx + gy * gy));\n      let v = (lit[p] + (1 - cov[p]) * paper) * (1 - 0.92 * sh[p]);\n      let rho = v / se;\n      rho *= 1 + (0.3 * ((px - 32) * ux + (py - 64) * uy)) / 64;\n      const dx = px + 0.5 - fx, dy = py + 0.5 - fy, gf = touch * exp(-(dx * dx) / 12 - (dy * dy) / 30);\n      rho = rho * (1 + 1.2 * gf) + 0.5 * gf;\n      const b = 1 - exp(-0.16 * rho * rho), amb = 0.04 + 0.03 * cov[p];\n      // Dim light reads brown on LEDs, so the lamp's colour comes in with\n      // its brightness: the paper is a cool grey, the lit sides cream.\n      const w = b \u003c 0.15 ? 0 : b > 0.6 ? 1 : (b - 0.15) / 0.45;\n      rgb[p * 3] = (paperC[0] + (lamp[0] - paperC[0]) * w) * b + shade[0] * amb;\n      rgb[p * 3 + 1] = (paperC[1] + (lamp[1] - paperC[1]) * w) * b + shade[1] * amb;\n      rgb[p * 3 + 2] = (paperC[2] + (lamp[2] - paperC[2]) * w) * b + shade[2] * amb;\n    }\n\n  // The print letters, under the cells read so far, each surfacing as the\n  // fingertip reaches it and fading over 3 s.\n  const page = PAGES[S.page], ink = hsv(0.56 + S.hue, 0.45, 1);\n  for (let c = 0; c \u003c PER; c++) {\n    const age = S.t - S.seen[c], glyph = FONT[page[c]];\n    if (!glyph || age \u003c 0 || age > 3.2) continue;\n    let a = age \u003c 0.15 ? age / 0.15 : age \u003c 0.8 ? 1 : max(0, 1 - (age - 0.8) / 2.4);\n    if (S.turn) a *= touch;\n    if (a \u003c= 0.01) continue;\n    const lx = X0 + (c % NC) * CP + 1, ly = Y0 + floor(c / NC) * LP + 11;\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++) {\n        if (glyph[r * 3 + q] !== \"1\") continue;\n        const o = ((ly + r) * W + lx + q) * 3;\n        rgb[o] += ink[0] * a, rgb[o + 1] += ink[1] * a, rgb[o + 2] += ink[2] * a;\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), (255 * min(1, rgb[p * 3])) | 0, (255 * min(1, rgb[p * 3 + 1])) | 0, (255 * min(1, rgb[p * 3 + 2])) | 0);\n}\n","distance-field":"// ===== Patternflow pattern =====\n// Title:   Distance Field\n// Family:  type\n// Idea:    One glyph fills the panel, kept only as a coarse grid of signed distances whose texel centres show as dim dots, and every LED is drawn by magnifying that grid bilinearly and cutting it at a threshold, so W, S, K, 3, 빛 and ? keep crisp edges at any grid size while their corners round off and thin strokes vanish as the grid coarsens; an outline band and an outer glow come from the same field, and each glyph melts into the next by blending the two fields.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: signed distance fields for alpha-tested magnification (Chris Green, Valve, \"Improved Alpha-Tested Magnification for Vector Textures and Special Effects\", SIGGRAPH 2007), glyphs drawn for this pattern, pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Magnify=-1.5..1.8, Weight=-4..5\n//\n// Knob 1: Hue. Turns all three colours round the wheel together: at 0 a cyan glyph with a pale rim and a magenta glow.\n// Knob 2: Speed. How fast the glyphs come: at 2 each holds 2 seconds and melts into the next over 0.5, at 0.2 ten times slower; the glow's ripples move with it.\n// Knob 3: Magnify. How far the stored field is blown up, in octaves around 6 LEDs a texel where it opens (12 by 23 texels): at -1.5 a texel is 2 LEDs and the glyph is sharp, at 1 it is 12 LEDs and the corners are round, at 1.8 it is 21 LEDs, 4 by 8 texels, and the thin parts are gone.\n// Knob 4: Weight. Where the field is cut, in LEDs off the true outline: -4 thins every stroke by 8 LEDs, 0 is the drawn weight, 5 makes it 10 LEDs bolder and closes the small counters.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, abs, sqrt, exp, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Glyphs, as exact geometry in panel LEDs (x 0..64, y 0..128 down).\n// Each glyph is a union of simple polygons that may overlap: rectangles,\n// slanted bars cut level at both ends, and bands along an ellipse whose\n// arcs are flattened into chords of at most 5 degrees. The box is about\n// 56 by 116, x 4..60 and y 6..122. The round strokes are 12 LEDs wide, the\n// straight ones 8 to 15 and the Hangul ones 8 to 12, so at 12 LEDs a\n// texel the thin ones go first.\nconst rect = (x0, y0, x1, y1) => [[x0, y0], [x1, y0], [x1, y1], [x0, y1]];\n// A bar from a top edge centred on xt, wt wide, to a bottom edge on xb.\nconst bar = (xt, yt, wt, xb, yb, wb) => [[xt - wt / 2, yt], [xt + wt / 2, yt], [xb + wb / 2, yb], [xb - wb / 2, yb]];\n// A band hw either side of an ellipse from angle a0 to a1 in degrees,\n// clockwise on the panel (0 is right, 90 down), its ends cut along the\n// radius.\nfunction arc(cx, cy, rx, ry, hw, a0, a1) {\n  const n = ceil(abs(a1 - a0) / 5), out = [], inn = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, c = cos(a), s = sin(a);\n    out.push([cx + (rx + hw) * c, cy + (ry + hw) * s]);\n    inn.push([cx + (rx - hw) * c, cy + (ry - hw) * s]);\n  }\n  return out.concat(inn.reverse());\n}\nfunction disc(cx, cy, r) {\n  const p = [];\n  for (let i = 0; i \u003c 48; i++) p.push([cx + r * cos((i * PI) / 24), cy + r * sin((i * PI) / 24)]);\n  return p;\n}\n\n// The order alternates straight and round, so every melt turns a corner\n// into a curve or back.\nconst GLYPHS = [\n  // W: four bars, the inner two thinner and sharing the top apex.\n  [bar(9.5, 6, 11, 20, 122, 11), bar(31, 6, 8, 20, 122, 9), bar(33, 6, 8, 44, 122, 9), bar(54.5, 6, 11, 44, 122, 11)],\n  // S: two elliptic bowls meeting in the middle stroke at y 64.\n  [arc(32, 38, 22, 26, 6, -25, -280), arc(32, 90, 22, 26, 6, -100, 155)],\n  // K: the arm ends inside the stem, the leg starts inside the arm.\n  [rect(5, 6, 18, 122), bar(51, 6, 14, 12, 84, 12), bar(26, 56, 10, 51, 122, 15)],\n  // 3: a small bowl over a big one, a short tongue to the left where they\n  // meet, and a notch on the right between them.\n  [arc(30, 37, 22, 25, 6, -155, 100), arc(30, 89, 24, 27, 6, -100, 150), rect(17, 56, 32, 68)],\n  // 빛: ㅂ and ㅣ over the final ㅊ, whose top tick is the smallest stroke.\n  [\n    rect(5, 6, 15, 62), rect(28, 6, 38, 62), rect(5, 29, 38, 38), rect(5, 53, 38, 62), rect(47, 6, 57, 68),\n    rect(27, 69, 37, 77), rect(8, 81, 56, 90), bar(31, 88, 11, 10, 122, 12), bar(28, 92, 9, 54, 122, 12),\n  ],\n  // ?: a hook that turns into the stem, and a round dot.\n  [arc(32, 37, 22, 25, 6, -160, 92), rect(26, 58, 38, 92), disc(32, 112, 8.5)],\n];\n\n// Even-odd test against one simple polygon, kept flat as x0 y0 x1 y1 ...\n// after its bounding box.\nfunction flat(P) {\n  const f = new Float64Array(4 + 2 * P.length);\n  f[0] = f[1] = Infinity;\n  f[2] = f[3] = -Infinity;\n  P.forEach(([x, y], i) => {\n    f[4 + 2 * i] = x;\n    f[5 + 2 * i] = y;\n    if (x \u003c f[0]) f[0] = x;\n    if (y \u003c f[1]) f[1] = y;\n    if (x > f[2]) f[2] = x;\n    if (y > f[3]) f[3] = y;\n  });\n  return f;\n}\nfunction inPoly(f, x, y) {\n  if (x \u003c f[0] || y \u003c f[1] || x > f[2] || y > f[3]) return false;\n  let c = false;\n  for (let i = 4, j = f.length - 2; i \u003c f.length; j = i, i += 2) {\n    const xi = f[i], yi = f[i + 1], xj = f[j], yj = f[j + 1];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) c = !c;\n  }\n  return c;\n}\n\n// The outline of a union. Every polygon edge is split where any other\n// polygon's edge crosses it (or runs along it), and a piece is kept when a\n// point a hair to one side is in the union and a point to the other side is\n// not. Edges buried inside another polygon go, and so do edges where two\n// polygons only touch. The distance to the kept pieces is then the exact\n// distance to the glyph's outline, inside as well as outside: the plain\n// minimum of each polygon's own distance would be wrong inside, wherever\n// two strokes join.\nfunction outline(polys) {\n  const flats = polys.map(flat);\n  const inside = (x, y) => {\n    for (const f of flats) if (inPoly(f, x, y)) return true;\n    return false;\n  };\n  const segs = [];\n  polys.forEach((P, i) => {\n    for (let k = 0; k \u003c P.length; k++) {\n      const [ax, ay] = P[k], [bx, by] = P[(k + 1) % P.length];\n      const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n      if (L2 \u003c 1e-12) continue;\n      const ts = [0, 1];\n      polys.forEach((Q, j) => {\n        if (j === i) return;\n        for (let m = 0; m \u003c Q.length; m++) {\n          const [cx, cy] = Q[m], [ex, ey] = Q[(m + 1) % Q.length];\n          const fx = ex - cx, fy = ey - cy, den = dx * fy - dy * fx;\n          if (abs(den) \u003c 1e-12) {\n            if (abs((cx - ax) * dy - (cy - ay) * dx) \u003c 1e-9) ts.push(((cx - ax) * dx + (cy - ay) * dy) / L2, ((ex - ax) * dx + (ey - ay) * dy) / L2);\n            continue;\n          }\n          const u = ((cx - ax) * dy - (cy - ay) * dx) / den;\n          if (u >= 0 && u \u003c= 1) ts.push(((cx - ax) * fy - (cy - ay) * fx) / den);\n        }\n      });\n      const tt = ts.filter((t) => t >= 0 && t \u003c= 1).sort((a, b) => a - b);\n      const L = sqrt(L2), nx = (-dy / L) * 1e-4, ny = (dx / L) * 1e-4;\n      for (let q = 1; q \u003c tt.length; q++) {\n        if (tt[q] - tt[q - 1] \u003c 1e-9) continue;\n        const tm = (tt[q] + tt[q - 1]) / 2, mx = ax + dx * tm, my = ay + dy * tm;\n        if (inside(mx + nx, my + ny) !== inside(mx - nx, my - ny))\n          segs.push(ax + dx * tt[q - 1], ay + dy * tt[q - 1], ax + dx * tt[q], ay + dy * tt[q]);\n      }\n    }\n  });\n  return { segs: Float64Array.from(segs), inside };\n}\n\n// Signed distance in LEDs, negative inside.\nfunction sdf(G, x, y) {\n  const s = G.segs;\n  let d2 = Infinity;\n  for (let i = 0; i \u003c s.length; i += 4) {\n    const ax = s[i], ay = s[i + 1], dx = s[i + 2] - ax, dy = s[i + 3] - ay;\n    let t = ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy);\n    t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n    const ex = x - ax - t * dx, ey = y - ay - t * dy, e = ex * ex + ey * ey;\n    if (e \u003c d2) d2 = e;\n  }\n  return G.inside(x, y) ? -sqrt(d2) : sqrt(d2);\n}\n\n// The texel grid for a texel size of s LEDs: centres on LED centres, s\n// apart, the first at or left of the panel's first LED and the last at or\n// right of its last, so the reconstruction never runs off the field.\nfunction grid(s) {\n  const nx = ceil((W - 1) / s) + 1, ny = ceil((H - 1) / s) + 1;\n  const ox = -floor(((nx - 1) * s - (W - 1)) / 2), oy = -floor(((ny - 1) * s - (H - 1)) / 2);\n  // For each LED column and row: the texel to its left (above) and how far\n  // along to the next one, for the bilinear weights.\n  const xi = new Int16Array(W), xf = new Float32Array(W), yi = new Int16Array(H), yf = new Float32Array(H);\n  for (let x = 0; x \u003c W; x++) {\n    const g = (x - ox) / s, i = min(nx - 2, floor(g));\n    xi[x] = i;\n    xf[x] = g - i;\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const g = (y - oy) / s, j = min(ny - 2, floor(g));\n    yi[y] = j;\n    yf[y] = g - j;\n  }\n  return { s, nx, ny, ox, oy, xi, xf, yi, yf, fields: [] };\n}\n\n// Sample a glyph's exact distance at every texel centre (LED centres sit at\n// x + 0.5). This is the whole texture: nothing else of the glyph survives.\nfunction field(G, glyph) {\n  if (G.fields[glyph]) return G.fields[glyph];\n  const F = new Float32Array(G.nx * G.ny), O = OUTLINES[glyph];\n  for (let j = 0; j \u003c G.ny; j++)\n    for (let i = 0; i \u003c G.nx; i++) F[j * G.nx + i] = sdf(O, G.ox + i * G.s + 0.5, G.oy + j * G.s + 0.5);\n  return (G.fields[glyph] = F);\n}\n\nconst OUTLINES = GLYPHS.map(outline);\nconst NG = GLYPHS.length;\n// Seconds at Speed 2: a glyph holds HOLD, then melts into the next over MELT.\nconst HOLD = 2, MELT = 0.5, BEAT = HOLD + MELT;\n// The rim: a band this many LEDs wide just inside the cut.\nconst RIM = 1.3;\n\nexport function setup(params) {\n  params.s = { T: 0, ripple: 0, G: grid(6), F: null, hue: 0, weight: 0 };\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3) / 2;\n  S.T += dt * sp;\n  S.ripple += dt * sp * 0.55;\n  S.hue = k[0];\n  S.weight = cl(k[3], -6, 8);\n  const s = cl(round(6 * 2 ** cl(k[2], -2, 2)), 2, 21);\n  if (s !== S.G.s) S.G = grid(s);\n  // The texture of the moment: one glyph's field, or two blended while it\n  // melts. A blend of two distance fields is not itself a distance field,\n  // but its zero set slides from one outline to the other.\n  const n = floor(S.T / BEAT), u = smooth((S.T - n * BEAT - HOLD) / MELT);\n  const A = field(S.G, n % NG);\n  if (u \u003c= 0) S.F = A;\n  else {\n    const B = field(S.G, (n + 1) % NG);\n    if (!S.F || S.F === A || S.F === B || S.F.length !== A.length) S.F = new Float32Array(A.length);\n    for (let i = 0; i \u003c A.length; i++) S.F[i] = A[i] + (B[i] - A[i]) * u;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.F) return;\n  const { G, F, weight } = S;\n  const { nx, xi, xf, yi, yf } = G;\n  const buf = S.buf || (S.buf = new Float32Array(W * H * 3));\n  const [fr, fg, fb] = hsv(0.5 + S.hue, 0.78, 1);\n  const [rr, rg, rb] = hsv(0.47 + S.hue, 0.22, 1);\n  const [gr, gg, gb] = hsv(0.87 + S.hue, 0.72, 1);\n  const ph = S.ripple;\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    const r0 = yi[y] * nx, r1 = r0 + nx, v = yf[y];\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      // Bilinear magnification, what the texture unit does for free.\n      const i = xi[x], h = xf[x];\n      const top = F[r0 + i] + (F[r0 + i + 1] - F[r0 + i]) * h;\n      const bot = F[r1 + i] + (F[r1 + i + 1] - F[r1 + i]) * h;\n      const e = top + (bot - top) * v - weight;\n      // Alpha test, softened over one LED so the cut edge is crisp but not\n      // stair-stepped.\n      const a = cl(0.5 - e, 0, 1);\n      let R = 0, Gc = 0, B = 0;\n      if (a > 0) {\n        // Deeper inside is brighter, so the spine of each stroke shows.\n        const lv = 0.5 + 0.5 * smooth(-e / 6), rim = cl(e + RIM + 0.5, 0, 1);\n        R = a * (fr * lv + (rr - fr * lv) * rim);\n        Gc = a * (fg * lv + (rg - fg * lv) * rim);\n        B = a * (fb * lv + (rb - fb * lv) * rim);\n      }\n      if (a \u003c 1) {\n        // Outer glow from the same field: falls off with distance, with\n        // slow rings at fixed distances running outward.\n        const d = e > 0 ? e : 0;\n        const g = (1 - a) * 0.8 * exp(-d / 4.2) * (0.6 + 0.4 * cos(2 * PI * (d / 7 - ph)));\n        R += gr * g;\n        Gc += gg * g;\n        B += gb * g;\n      }\n      buf[p] = R;\n      buf[p + 1] = Gc;\n      buf[p + 2] = B;\n    }\n  }\n  // The texel centres, dim dots: dark holes where they fall in the glyph,\n  // faint light where they fall outside. Too dense to read below 4 LEDs.\n  const fade = cl((G.s - 2) / 3, 0, 1);\n  if (fade > 0) {\n    const [dr, dg, db] = hsv(0.6 + S.hue, 0.25, 0.28 * fade);\n    for (let j = 0; j \u003c G.ny; j++) {\n      const y = G.oy + j * G.s;\n      if (y \u003c 0 || y >= H) continue;\n      for (let i = 0; i \u003c nx; i++) {\n        const x = G.ox + i * G.s;\n        if (x \u003c 0 || x >= W) continue;\n        const e = F[j * nx + i] - weight, p = (y * W + x) * 3;\n        if (e \u003c 0) {\n          const k = 1 - 0.55 * fade;\n          buf[p] *= k;\n          buf[p + 1] *= k;\n          buf[p + 2] *= k;\n        } else {\n          buf[p] += dr;\n          buf[p + 1] += dg;\n          buf[p + 2] += db;\n        }\n      }\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, buf[p] * 255), min(255, buf[p + 1] * 255), min(255, buf[p + 2] * 255));\n}\n","dupin-cyclide":"// ===== Patternflow pattern =====\n// Title:   Dupin Cyclide\n// Family:  geometry\n// Idea:    A torus turns at the top of the panel and below it its image under an inversion in a sphere turns with it, a Dupin cyclide drawn as the two families of circles that are its lines of curvature, every torus circle landing on a circle, while a band of light runs round both families on both surfaces at once.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dupin cyclides (Charles Dupin, 1822), the surfaces whose lines of curvature are all circles, each the image of a torus, a circular cylinder or a circular cone under an inversion in a sphere; pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..2, Distance=0..1\n//\n// Knob 1: Hue. Turns both families round the wheel together: at 0 the circles round the tube are cyan and the circles round the hole rose.\n// Knob 2: Speed. How fast the pair turns and the band of light runs: one turn in 11 seconds at 2, in 112 at 0.2.\n// Knob 3: Shape. The torus tube against its centre circle, and so the cyclide's type: a ring torus and ring cyclide at 0 (tube half the radius), the horn pair at 1 where the hole closes to a point, and spindle pairs up to 2 where the tube is 1.6 times the radius and the surface passes through itself.\n// Knob 4: Distance. The gap between the torus and the centre of inversion below it, in outer radii of the torus: 1.2 at 0 and 1.45 at the opening 0.06, where the cyclide's tube is 3.1 times as thick at the bottom as at the top, out to 29 at 1, where the image is the torus again to within 9 per cent.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, cos, sin, exp, PI, hypot } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The torus: centre circle radius 1 in the plane z = 0, centred at (0, d, 0),\n// so it stands on edge facing the viewer, and the centre of inversion is the\n// origin, d below it. Meridians (u fixed, round the tube) and parallels (v\n// fixed, round the hole) are its two families of lines of curvature.\nconst NU = 18, NV = 10, K = 60;\n// Panel boxes: the torus above, the cyclide below.\nconst TOP = [1, 57], BOT = [63, 126], BW = 61;\n\nconst sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];\nconst add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];\n\n// The circle through three points: centre, radius and an orthonormal pair\n// spanning its plane.\nfunction circleThrough(A, B, C) {\n  const a = sub(A, C), b = sub(B, C), n = cross(a, b), nn = dot(n, n);\n  const c = add(C, scale(cross(sub(scale(b, dot(a, a)), scale(a, dot(b, b))), n), 1 / (2 * nn)));\n  const e1 = sub(A, c), rad = sqrt(dot(e1, e1));\n  const u = scale(e1, 1 / rad), w = cross(scale(n, 1 / sqrt(nn)), u);\n  return { c, rad, u, w };\n}\n\n// One circle of the torus, as centre, radius and plane.\nfunction torusCircle(fam, i, r, d, us) {\n  if (fam === 0) {\n    const u = us[i];\n    return { c: [cos(u), d + sin(u), 0], rad: r, u: [cos(u), sin(u), 0], w: [0, 0, 1] };\n  }\n  const v = (i / NV) * TAU;\n  return { c: [0, d, r * sin(v)], rad: 1 + r * cos(v), u: [1, 0, 0], w: [0, 1, 0] };\n}\nconst onCircle = (C, t) => add(C.c, add(scale(C.u, C.rad * cos(t)), scale(C.w, C.rad * sin(t))));\n// The inversion in the sphere of radius d about the origin, followed by the\n// point reflection through it (an anti-inversion), so the image hangs below\n// the centre the way the torus stands above it. Spheres go to spheres and\n// circles to circles either way.\nconst invert = (p, k2) => scale(p, -k2 / dot(p, p));\n\nfunction build(S) {\n  const r = S.r, d = (1 + r) * (1 + S.del), k2 = d * d;\n  // Where the meridians sit. The inversion stretches the side of the torus\n  // nearest the centre k2 / |p|^2 times, so meridians evenly spaced on the\n  // torus crowd on the image's thin side. Spacing them evenly in the square\n  // root of that stretch splits the crowding between the two surfaces, and\n  // the torus shows where the inversion pulls hardest.\n  const F = [0];\n  for (let j = 1; j \u003c= 720; j++) {\n    const u = -PI / 2 + ((j - 0.5) / 720) * TAU, q = cos(u) ** 2 + (d + sin(u)) ** 2;\n    F[j] = F[j - 1] + sqrt(k2 / q);\n  }\n  const us = [];\n  for (let i = 0, j = 0; i \u003c NU; i++) {\n    const want = (i / NU) * F[720];\n    while (F[j + 1] \u003c want) j++;\n    us.push(-PI / 2 + ((j + (want - F[j]) / (F[j + 1] - F[j] || 1)) / 720) * TAU);\n  }\n  const objs = [[], []];\n  for (let fam = 0; fam \u003c 2; fam++)\n    for (let i = 0; i \u003c (fam ? NV : NU); i++) {\n      const T = torusCircle(fam, i, r, d, us);\n      // A horn torus has a parallel of radius 0 where the hole closes, a\n      // point: there is no circle to draw.\n      if (abs(T.rad) \u003c 1e-3) continue;\n      objs[0].push({ fam, i, C: T });\n      // The image of a circle is a circle, so three image points fix it.\n      const P = [0, 1, 2].map((j) => invert(onCircle(T, (j * TAU) / 3 + 0.3), k2));\n      objs[1].push({ fam, i, C: circleThrough(P[0], P[1], P[2]) });\n    }\n  // Sample every circle and fit each surface to its box. The turn is about\n  // the vertical axis, and a half turn about it maps each surface onto\n  // itself, so the drawing is never wider than twice the largest distance\n  // from that axis.\n  S.objs = objs.map((list, o) => {\n    let ylo = 1e9, yhi = -1e9, rad = 0;\n    const pts = list.map(({ C }) => {\n      const a = new Float32Array(K * 3);\n      for (let j = 0; j \u003c K; j++) {\n        const p = onCircle(C, (j / K) * TAU);\n        a.set(p, j * 3);\n        ylo = min(ylo, p[1]);\n        yhi = max(yhi, p[1]);\n        rad = max(rad, hypot(p[0], p[2]));\n      }\n      return a;\n    });\n    const box = o ? BOT : TOP;\n    const s = min(BW / (2 * rad), (box[1] - box[0]) / (yhi - ylo));\n    return { list, pts, s, rad, ym: (ylo + yhi) / 2, cy: (box[0] + box[1]) / 2 };\n  });\n}\n\nexport function setup(params) {\n  params.s = { phi: 0.5, band: 0, key: \"\", R: new Float32Array(W * H), G: new Float32Array(W * H), B: new Float32Array(W * H) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1], 0.2, 3);\n  S.phi += dt * speed * 0.28;\n  S.band += dt * speed * 1.1;\n  // Shape: tube over centre radius 0.5 (ring) to 1 (horn) to 1.6 (spindle).\n  const sh = cl(k[2], 0, 2);\n  S.r = sh \u003c= 1 ? 0.5 + 0.5 * sh : 1 + 0.6 * (sh - 1);\n  // Distance: the gap between the torus and the centre, in outer radii.\n  S.del = 1.2 * exp(3.2 * cl(k[3], 0, 1));\n  const key = S.r.toFixed(4) + \",\" + S.del.toFixed(4);\n  if (key !== S.key) {\n    S.key = key;\n    build(S);\n  }\n}\n\n// An antialiased line one LED wide, kept as the brightest colour per LED.\nfunction line(S, x0, y0, x1, y1, r, g, b) {\n  const dx = x1 - x0, dy = y1 - y0, L = dx * dx + dy * dy;\n  const xa = max(0, floor(min(x0, x1) - 1)), xb = min(W - 1, floor(max(x0, x1) + 1));\n  const ya = max(0, floor(min(y0, y1) - 1)), yb = min(H - 1, floor(max(y0, y1) + 1));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x - x0, py = y - y0;\n      const t = L ? cl((px * dx + py * dy) / L, 0, 1) : 0;\n      const ex = px - t * dx, ey = py - t * dy;\n      const a = cl(1.05 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (a \u003c= 0) continue;\n      const p = y * W + x;\n      if (r * a > S.R[p]) S.R[p] = r * a;\n      if (g * a > S.G[p]) S.G[p] = g * a;\n      if (b * a > S.B[p]) S.B[p] = b * a;\n    }\n}\n\nexport function draw(display, params) {\n  if (!params.s || !params.s.objs) return;\n  const S = params.s;\n  S.R.fill(0);\n  S.G.fill(0);\n  S.B.fill(0);\n  const cphi = cos(S.phi), sphi = sin(S.phi);\n  const cols = [hsv(S.hue + 0.5, 0.8, 1), hsv(S.hue + 0.88, 0.62, 1)];\n  const sx = [], sy = [], sz = [];\n  S.objs.forEach((O, o) => {\n    const dim = o ? 1 : 0.8;\n    O.list.forEach(({ fam, i }, n) => {\n      const a = O.pts[n];\n      // The band of light: a soft bump running round each family's index,\n      // the same circles lit on the torus and on its image.\n      const N = fam ? NV : NU;\n      let g = (i - S.band * (fam ? 0.5 : 1)) % N;\n      if (g \u003c 0) g += N;\n      g = min(g, N - g);\n      const hl = exp(-g * g * 0.8);\n      const col = cols[fam];\n      for (let j = 0; j \u003c K; j++) {\n        const x = a[j * 3], y = a[j * 3 + 1], z = a[j * 3 + 2];\n        const xr = x * cphi + z * sphi, zr = -x * sphi + z * cphi;\n        sx[j] = W / 2 + xr * O.s;\n        sy[j] = O.cy - (y - O.ym) * O.s;\n        sz[j] = zr / O.rad;\n      }\n      for (let j = 0; j \u003c K; j++) {\n        const q = (j + 1) % K;\n        // Depth: the near side bright, the far side down to a fifth.\n        const depth = cl(0.5 + 0.25 * (sz[j] + sz[q]), 0, 1);\n        const v = dim * (0.1 + 0.9 * depth * depth) * (0.75 + 0.25 * hl);\n        const wv = 0.55 * hl * depth;\n        line(S, sx[j], sy[j], sx[q], sy[q], 255 * v * (col[0] * (1 - wv) + wv), 255 * v * (col[1] * (1 - wv) + wv), 255 * v * (col[2] * (1 - wv) + wv));\n      }\n    });\n  });\n  for (let p = 0; p \u003c W * H; p++) {\n    if (S.R[p] + S.G[p] + S.B[p] \u003c 1) continue;\n    display.setPixel(p % W, floor(p / W), min(255, S.R[p]) | 0, min(255, S.G[p]) | 0, min(255, S.B[p]) | 0);\n  }\n}\n","hanging-line":"// ===== Patternflow pattern =====\n// Title:   Hanging Line\n// Family:  type\n// Idea:    Kim Sowol's poem Azaleas types itself jamo by jamo, initial, vowel, final, in a geometric out-of-the-square Hangul after Ahn Sang-soo's face, every jamo one fixed shape so the syllables hang from a common top line with ragged bottoms, until the Frame knob squeezes each syllable into the same square box the way a conventional face does.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: 안상수체, the out-of-the-square (탈네모꼴) three-set Hangul face of Ahn Sang-soo (1985), whose 19 initials, 21 vowels and 27 finals each keep one shape; the jamo here are drawn after it for this pattern, not copied; the text is Kim Sowol's 진달래꽃 (Azaleas, 1922); pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=1..2, Frame=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel: at 0 the text is a pale azalea pink and each new jamo lands in full azalea magenta, under dim teal hanging lines.\n// Knob 2: Speed. Steps a second, a step being one jamo, a space or a line break: 4.4 at the opening 2, so the poem's 264 steps take a minute, 0.44 at 0.2 and 6.6 at 3.\n// Knob 3: Size. The jamo cell: 7 LEDs at 1, where up to five syllables fit a line and five and a half lines the panel, 13 LEDs at 2, where two or three do and the lines wrap again.\n// Knob 4: Frame. Out of the square at 0: each jamo one shape and size, every syllable hanging from its line's top. At 1 each syllable is stretched into the same 13 by 13 square, as a conventional (네모꼴) face resizes its jamo per syllable, and a syllable still being typed jumps in size as each jamo arrives. The opening 0.06 sits near the hanging line.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// 진달래꽃 in today's spelling: 94 syllables, 222 jamo.\nconst POEM = [\n  \"나 보기가 역겨워\", \"가실 때에는\", \"말없이 고이 보내 드리우리다\", \"\",\n  \"영변에 약산\", \"진달래꽃\", \"아름 따다 가실 길에 뿌리우리다\", \"\",\n  \"가시는 걸음걸음\", \"놓인 그 꽃을\", \"사뿐히 즈려밟고 가시옵소서\", \"\",\n  \"나 보기가 역겨워\", \"가실 때에는\", \"죽어도 아니 눈물 흘리우리다\", \"\",\n];\n\n// ---- The face. Drawn after 안상수체, not copied from it: straight strokes\n// and circles on a grid one LED apart at Size 1. A consonant fills a 7 by 7\n// cell (0..6), the same cell as an initial and as a final. Strokes are\n// polylines [x0, y0, x1, y1, ...]; a circle is [cx, cy, r, 0, 0] tagged by\n// length 5. Only the 16 consonant shapes and 11 vowels the poem uses are here.\nconst C = {\n  g: [[0, 0, 6, 0, 6, 6]],\n  n: [[0, 0, 0, 6, 6, 6]],\n  d: [[6, 0, 0, 0, 0, 6, 6, 6]],\n  r: [[0, 0, 6, 0, 6, 3, 0, 3, 0, 6, 6, 6]],\n  m: [[0, 0, 6, 0, 6, 6, 0, 6, 0, 0]],\n  b: [[0, 0, 0, 6, 6, 6, 6, 0], [0, 3, 6, 3]],\n  s: [[3, 0, 0, 6], [3, 0, 6, 6]],\n  o: [[3, 3, 3, 0, 0]],\n  j: [[0, 0, 6, 0], [3, 0, 0, 6], [3, 0, 6, 6]],\n  c: [[2, 0, 4, 0], [0, 2, 6, 2], [3, 2, 0, 6], [3, 2, 6, 6]],\n  // ㅎ's circle is too small for a round ring one LED wide to stay open at\n  // this size, so it is the eight-sided ring those LEDs make.\n  h: [[2, 0, 4, 0], [0, 1, 6, 1], [2, 3, 4, 3, 5, 4, 5, 5, 4, 6, 2, 6, 1, 5, 1, 4, 2, 3]],\n};\n// A double or a cluster sets two consonants side by side, each squeezed to\n// three LEDs.\nfunction pair(a, b) {\n  const sq = (st, dx) => (st.length === 5 ? [dx + st[0] / 3, st[1], st[2], 0, 0] : st.map((v, i) => (i % 2 ? v : dx + v / 3)));\n  return [...C[a].map((s) => sq(s, 0)), ...C[b].map((s) => sq(s, 4))];\n}\nconst INI = { 0: C.g, 1: pair(\"g\", \"g\"), 2: C.n, 3: C.d, 4: pair(\"d\", \"d\"), 5: C.r, 6: C.m, 7: C.b, 8: pair(\"b\", \"b\"), 9: C.s, 11: C.o, 12: C.j, 18: C.h };\nconst FIN = { 1: C.g, 4: C.n, 8: C.r, 11: pair(\"r\", \"b\"), 16: C.m, 17: C.b, 18: pair(\"b\", \"s\"), 21: C.o, 23: C.c, 27: C.h };\n// Vertical vowels stand right of the initial from x = 8; their stem runs\n// from the top down to y = 11, the middle of a final set under the initial\n// at y = 8..14, whether the syllable has a final or not: one shape.\nconst V = (list, x0, len) => list.map((s) => s.map((v, i) => (i % 2 ? (v === 99 ? len : v) : v + x0)));\nconst STEM = (x) => [x, 0, x, 99];\nconst VERT = {\n  0: [STEM(0), [0, 3, 2, 3]], // ㅏ\n  1: [STEM(0), [0, 3, 2, 3], STEM(4)], // ㅐ\n  2: [STEM(0), [0, 2, 2, 2], [0, 4, 2, 4]], // ㅑ\n  4: [[0, 3, 2, 3], STEM(2)], // ㅓ\n  5: [[0, 3, 2, 3], STEM(2), STEM(4)], // ㅔ\n  6: [[0, 2, 2, 2], [0, 4, 2, 4], STEM(2)], // ㅕ\n  20: [STEM(0)], // ㅣ\n};\n// Horizontal vowels hang under the initial from y = 8; the final goes two\n// rows under the vowel's lowest row.\nconst HORI = {\n  8: [[[3, 8, 3, 9], [0, 10, 6, 10]], 10], // ㅗ\n  13: [[[0, 8, 6, 8], [3, 8, 3, 10]], 10], // ㅜ\n  18: [[[0, 8, 6, 8]], 8], // ㅡ\n};\n// Compounds: the horizontal part under the initial, the vertical part\n// beside it with its stem down to the middle of where the final would sit.\nconst COMP = { 14: [13, 4] }; // ㅝ = ㅜ + ㅓ\n\n// A syllable as three stroke lists (initial, vowel, final) in grid units.\nfunction syllable(ch) {\n  const k = ch.charCodeAt(0) - 0xac00, ci = floor(k / 588), vi = floor((k % 588) / 28), fi = k % 28;\n  let vow, fy;\n  if (VERT[vi]) {\n    vow = V(VERT[vi], 8, 11);\n    fy = 8;\n  } else if (HORI[vi]) {\n    vow = HORI[vi][0];\n    fy = HORI[vi][1] + 2;\n  } else {\n    const [h, v] = COMP[vi];\n    fy = HORI[h][1] + 2;\n    vow = [...HORI[h][0], ...V(VERT[v], 8, fy + 3)];\n  }\n  const fin = fi ? FIN[fi].map((s) => (s.length === 5 ? [s[0], s[1] + fy, s[2], 0, 0] : s.map((v, i) => (i % 2 ? v + fy : v)))) : [];\n  return [INI[ci], vow, fin];\n}\n// The box a list of strokes fills: right and bottom edges, in LEDs.\nfunction extent(lists) {\n  let w = 1, h = 1;\n  for (const L of lists)\n    for (const s of L) {\n      if (s.length === 5) {\n        w = max(w, s[0] + s[2] + 1);\n        h = max(h, s[1] + s[2] + 1);\n      } else\n        for (let i = 0; i \u003c s.length; i += 2) {\n          w = max(w, s[i] + 1);\n          h = max(h, s[i + 1] + 1);\n        }\n    }\n  return [w, h];\n}\n\n// ---- The page. Each copy of the poem starts on a fresh line, so the\n// layout repeats copy after copy and the cursor can wrap round unseen.\nconst COPIES = 3, SQ = 13, TRACK = 2, SPACE = 4, LEAD = 4, MARGIN = 2;\n\nfunction tokens() {\n  const out = [];\n  let step = 0;\n  for (let c = 0; c \u003c COPIES; c++)\n    for (const line of POEM) {\n      if (line === \"\") {\n        out.push({ t: \"stanza\", step });\n        step += 2;\n        continue;\n      }\n      line.split(\" \").forEach((word, wi) => {\n        if (wi) out.push({ t: \"space\", step: step++ });\n        const syl = [...word].map((ch) => {\n          const parts = syllable(ch);\n          const n = parts[2].length ? 3 : 2;\n          const tok = { t: \"syl\", step, n, parts, ext: [extent([parts[0]]), extent([parts[0], parts[1]]), extent(parts)] };\n          step += n;\n          return tok;\n        });\n        out.push({ t: \"word\", syl });\n      });\n      out.push({ t: \"line\", step: step++ });\n    }\n  return { list: out, steps: step };\n}\n\nexport function setup(params) {\n  const { list, steps } = tokens();\n  const S = (params.s = { list, steps, copySteps: steps / COPIES, cur: 0, scroll: 0, key: \"\", blink: 0 });\n  S.maxH = 0;\n  for (const tk of list) if (tk.t === \"word\") for (const s of tk.syl) S.maxH = max(S.maxH, s.ext[2][1]);\n  // Open in the second copy, on 「아름 따다 가실 길에」, with the first\n  // copy's lines filling the page above.\n  let n = 0;\n  for (const tk of list)\n    if (tk.t === \"word\")\n      for (const s of tk.syl)\n        if (++n === 94 + 38) S.cur = s.step;\n  S.R = new Float32Array(W * H);\n  S.G = new Float32Array(W * H);\n  S.B = new Float32Array(W * H);\n}\n\n// Where every syllable goes for this Size and Frame: slot x, line top y,\n// slot width, in LEDs.\nfunction layout(S) {\n  const sc = S.size, f = S.frame;\n  const pitch = ((1 - f) * S.maxH + f * SQ + LEAD) * sc;\n  const adv = (w) => ((1 - f) * w + f * SQ + TRACK) * sc;\n  let x = MARGIN, y = 0, lineIx = 0;\n  S.laid = true;\n  const newLine = (gap) => {\n    x = MARGIN;\n    y += pitch * gap;\n    lineIx++;\n  };\n  for (const tk of S.list) {\n    if (tk.t === \"stanza\") newLine(0.45);\n    else if (tk.t === \"line\") newLine(1);\n    else if (tk.t === \"space\") {\n      if (x > MARGIN) x += SPACE * sc;\n    } else if (tk.t === \"word\") {\n      const wW = tk.syl.reduce((a, s) => a + adv(s.ext[2][0]), 0) - TRACK * sc;\n      if (x > MARGIN && x + wW > W - MARGIN) newLine(1);\n      for (const s of tk.syl) {\n        const aw = adv(s.ext[2][0]);\n        if (x > MARGIN && x + aw - TRACK * sc > W - MARGIN) newLine(1);\n        s.x = x;\n        s.y = y;\n        s.line = lineIx;\n        s.w = aw - TRACK * sc;\n        x += aw;\n      }\n    }\n  }\n  S.pitch = pitch;\n  // The height of one copy: where the first syllable of each copy sits.\n  const firsts = [];\n  let k = 0;\n  for (const tk of S.list) if (tk.t === \"word\") for (const s of tk.syl) if (k++ % 94 === 0) firsts.push(s.y);\n  S.period = firsts[1] - firsts[0];\n}\n\n// The syllable the cursor is on, or the last one before it.\nfunction caretSyl(S) {\n  let last = null;\n  for (const tk of S.list) {\n    if (tk.t !== \"word\") {\n      if (tk.step !== undefined && tk.step > S.cur) break;\n      continue;\n    }\n    for (const s of tk.syl) {\n      if (s.step > S.cur) return last;\n      last = s;\n    }\n  }\n  return last;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1], 0.2, 3);\n  S.size = cl(k[2], 1, 2);\n  S.frame = cl(k[3], 0, 1);\n  S.blink += dt;\n  S.cur += dt * speed * 2.2;\n  // Past the second copy, step back a copy: the page looks the same.\n  let jumped = false;\n  if (S.cur >= 2 * S.copySteps) {\n    S.cur -= S.copySteps;\n    jumped = true;\n  }\n  const key = S.size.toFixed(3) + \",\" + S.frame.toFixed(3);\n  const relaid = key !== S.key;\n  if (relaid) {\n    S.key = key;\n    layout(S);\n  }\n  if (jumped && !relaid) S.scroll -= S.period;\n  // Keep the cursor's line on the panel: its tallest possible syllable\n  // ends two rows above the bottom edge.\n  const cs = caretSyl(S);\n  S.caret = cs;\n  const lineH = ((1 - S.frame) * S.maxH + S.frame * SQ) * S.size;\n  const target = cs ? cs.y + lineH - (H - 3) : 0;\n  if (relaid || S.first === undefined) S.scroll = target;\n  else S.scroll += (target - S.scroll) * (1 - exp(-dt * 5));\n  S.first = 1;\n}\n\n// ---- Drawing: strokes as distances, one LED wide at Size 1.\nfunction plot(S, p, a, col) {\n  if (a \u003c= 0) return;\n  if (col[0] * a > S.R[p]) S.R[p] = col[0] * a;\n  if (col[1] * a > S.G[p]) S.G[p] = col[1] * a;\n  if (col[2] * a > S.B[p]) S.B[p] = col[2] * a;\n}\nfunction seg(S, x0, y0, x1, y1, hw, col) {\n  const dx = x1 - x0, dy = y1 - y0, L = dx * dx + dy * dy;\n  const xa = max(0, floor(min(x0, x1) - hw - 1)), xb = min(W - 1, floor(max(x0, x1) + hw + 1));\n  const ya = max(0, floor(min(y0, y1) - hw - 1)), yb = min(H - 1, floor(max(y0, y1) + hw + 1));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x - x0, py = y - y0, t = L ? cl((px * dx + py * dy) / L, 0, 1) : 0;\n      const ex = px - t * dx, ey = py - t * dy;\n      plot(S, y * W + x, cl(hw + 0.5 - sqrt(ex * ex + ey * ey), 0, 1), col);\n    }\n}\n// An ellipse ring; the distance to it is taken to first order.\nfunction ring(S, cx, cy, rx, ry, hw, col) {\n  for (let y = max(0, floor(cy - ry - hw - 1)); y \u003c= min(H - 1, cy + ry + hw + 1); y++)\n    for (let x = max(0, floor(cx - rx - hw - 1)); x \u003c= min(W - 1, cx + rx + hw + 1); x++) {\n      const u = (x - cx) / rx, v = (y - cy) / ry, k = sqrt(u * u + v * v);\n      const g = sqrt((u / rx) ** 2 + (v / ry) ** 2);\n      const d = g > 1e-6 ? (k * k - k) / g : min(rx, ry);\n      plot(S, y * W + x, cl(hw + 0.5 - abs(d), 0, 1), col);\n    }\n}\n\nexport function draw(display, params) {\n  if (!params.s || !params.s.laid) return;\n  const S = params.s, sc = S.size, f = S.frame, hw = 0.5 + 0.35 * (sc - 1);\n  S.R.fill(0);\n  S.G.fill(0);\n  S.B.fill(0);\n  const ink = hsv(S.hue + 0.93, 0.42, 0.9).map((v) => v * 255);\n  const hot = hsv(S.hue + 0.88, 0.85, 1).map((v) => v * 255);\n  const guide = hsv(S.hue + 0.5, 0.7, 0.2).map((v) => v * 255);\n  const lineH = ((1 - f) * S.maxH + f * SQ) * sc;\n  const top = S.scroll;\n  // The hanging lines: where each line's typed text ends.\n  const ends = new Map();\n  for (const tk of S.list) {\n    if (tk.t !== \"word\") continue;\n    for (const s of tk.syl) {\n      if (s.step > S.cur) break;\n      const y = s.y - top;\n      if (y + lineH \u003c 0 || y > H) continue;\n      ends.set(s.line, [y, max(ends.get(s.line)?.[1] ?? 0, s.x + s.w)]);\n      const typed = min(s.n, floor(S.cur - s.step) + 1);\n      // The box this much of the syllable fills, and the stretch that puts\n      // it in the square: none at Frame 0, all of it at 1.\n      const [bw, bh] = s.ext[typed - 1];\n      const fx = (1 - f + (f * SQ) / bw) * sc, fy = (1 - f + (f * SQ) / bh) * sc;\n      const ox = round(s.x), oy = round(y);\n      for (let j = 0; j \u003c typed; j++) {\n        const age = S.cur - s.step - j;\n        const glow = exp(-age / 4);\n        const col = ink.map((v, i) => v + (hot[i] - v) * glow);\n        for (const st of s.parts[j]) {\n          if (st.length === 5) ring(S, ox + round(st[0] * fx * 2) / 2, oy + round(st[1] * fy * 2) / 2, st[2] * fx, st[2] * fy, hw, col);\n          else\n            for (let i = 0; i + 3 \u003c st.length; i += 2)\n              seg(S, ox + round(st[i] * fx), oy + round(st[i + 1] * fy), ox + round(st[i + 2] * fx), oy + round(st[i + 3] * fy), hw, col);\n        }\n      }\n    }\n  }\n  // The guide: the top line every syllable hangs from, fading out toward\n  // the square, where a bottom line fades in.\n  for (const [, [y, xe]] of ends) {\n    const yt = round(y) - 2, yb = round(y + SQ * sc) + 1;\n    for (let x = MARGIN; x \u003c min(W, xe); x++) {\n      if (yt >= 0 && yt \u003c H) plot(S, yt * W + x, 1 - 0.6 * f, guide);\n      if (f > 0 && yb >= 0 && yb \u003c H) plot(S, yb * W + x, f, guide);\n    }\n  }\n  // The caret: the slot being typed, lit on its hanging line.\n  const c = S.caret;\n  if (c) {\n    const on = 0.55 + 0.45 * Math.cos(S.blink * 7);\n    const y = round(c.y - top) - 2;\n    if (y >= 0 && y \u003c H) for (let x = round(c.x); x \u003c min(W, c.x + c.w); x++) plot(S, y * W + x, on, hot);\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    if (S.R[p] + S.G[p] + S.B[p] \u003c 1) continue;\n    display.setPixel(p % W, floor(p / W), min(255, S.R[p]) | 0, min(255, S.G[p]) | 0, min(255, S.B[p]) | 0);\n  }\n}\n","radon-transform":"// ===== Patternflow pattern =====\n// Title:   Radon Transform\n// Family:  algo\n// Idea:    A beam takes half a turn round a few ellipses of different densities and counts the photons that get through, filling the bottom square row by row with a grainy sinogram, then each projection is filtered and smeared back across the top square along its own angle, so the ellipses build up out of crossing streaks, hold, and the panel clears for the next, slightly moved phantom.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Radon transform and its inversion (Johann Radon, 1917), filtered back-projection with the ramp filter (G. N. Ramachandran and A. V. Lakshminarayanan, 1971), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Angles=0..64, Filter=0..1\n//\n// Knob 1: Hue. Turns both squares round the wheel: at 0 the reconstruction runs from dark cyan to ice white and the sinogram from blue violet to purple.\n// Knob 2: Speed. At 2 the beam's half turn takes 1 s, reading the projections back takes 6 s, and the picture holds 1.5 s, dimming to 15% over its last 0.3 s before the next scan starts on an empty sinogram; at 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Angles. How many projections a half turn takes. 0 takes turns, doubling each cycle from 16: 16, 32, 64, then 4, 8 and round again. 1 to 64 hold that count; with few the shapes are crossed by the star of streaks, one per angle. The half turn has a fixed dose of photons shared by its projections: at 4 angles each bin gets 2,000 and the rows are clean, at 64 it gets 125 and they are grainy.\n// Knob 4: Filter. The filter each projection passes before it is smeared back: (1 - f) c + f |w|, with c the ramp's height at 1/400 of a cycle a sample. At 0 it is plain back-projection, every shape in a blurred 1/r halo; at 0.06 the edges already come through; at 1 it is the ramp alone, sharp, with dark lobes beside every streak. Plain back-projection smooths the photon noise away; the ramp turns it into fine grain.\n\nconst W = 64, Q = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, log, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The detector: NB bins one LED wide, wide enough to cover the square's\n// diagonal, so the corners get their share of every projection. The\n// sinogram shows the middle 64.\nconst NB = 92, MID = (NB - 1) / 2, OFF = (NB - Q) / 2, C = (Q - 1) / 2;\n// Ramachandran and Lakshminarayanan's ramp filter in space, one bin apart:\n// 1/4 at 0, -1/(pi n)^2 at odd n, 0 at even n. Its response rises as |w|\n// from 0 to 1/2 at the Nyquist frequency.\nconst KER = new Float32Array(2 * NB - 1);\nfor (let n = -(NB - 1); n \u003c NB; n++) KER[n + NB - 1] = n === 0 ? 0.25 : n & 1 ? -1 / (PI * PI * n * n) : 0;\n// The flat part of the Filter knob's blend, in the ramp's units.\nconst FLAT = 1 / 400;\n\n// A phantom is a list of ellipses [x0, y0, a, b, phi, density]. The line\n// integral of one along s at angle th is closed form: with\n// r2 = a^2 cos^2(th - phi) + b^2 sin^2(th - phi) and t = s - (x0 cos th +\n// y0 sin th) the line's distance from the centre, it is\n// 2 rho a b sqrt(r2 - t^2) / r2 where t^2 \u003c r2, and 0 elsewhere.\n// One projection, each bin the mean of the lines a quarter bin either side\n// of its middle.\nfunction project(E, th, out) {\n  out.fill(0);\n  const c = cos(th), sn = sin(th);\n  for (const [x0, y0, a, b, phi, rho] of E) {\n    const ca = cos(th - phi), sa = sin(th - phi);\n    const r2 = a * a * ca * ca + b * b * sa * sa, r = sqrt(r2), k = (rho * a * b) / r2, s0 = x0 * c + y0 * sn + MID;\n    for (let i = max(0, floor(s0 - r - 1)), e = min(NB - 1, floor(s0 + r + 1)); i \u003c= e; i++)\n      for (const d of [-0.25, 0.25]) {\n        const t = i + d - s0;\n        if (t * t \u003c r2) out[i] += k * sqrt(r2 - t * t);\n      }\n  }\n  return out;\n}\n\n// Photon counts. A line of attenuation p lets through exp(-MU p) of the\n// beam, so a bin that should count m photons counts a Poisson draw from m,\n// and the projection is read back as -ln(count / I0) / MU, as a scanner\n// reads it. One half turn has a fixed DOSE, shared by its projections: each\n// of N gets DOSE / N photons a bin, so few angles give clean rows and many\n// give grainy ones. The thickest line through the first phantom lets 5.4%\n// of the beam through.\nconst MU = 0.08, DOSE = 8000;\nconst gauss = () => sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\nfunction poisson(m) {\n  if (m > 40) return max(0, round(m + sqrt(m) * gauss()));\n  const L = exp(-m);\n  let k = 0;\n  for (let q = Math.random(); q > L; q *= Math.random()) k++;\n  return k;\n}\nfunction expose(p, I0) {\n  for (let i = 0; i \u003c p.length; i++) p[i] = -log(max(0.5, poisson(I0 * exp(-MU * p[i]))) / I0) / MU;\n  return p;\n}\n\nfunction ramp(p, q) {\n  for (let i = 0; i \u003c NB; i++) {\n    let s = 0;\n    for (let j = 0; j \u003c NB; j++) s += p[j] * KER[i - j + NB - 1];\n    q[i] = s;\n  }\n  return q;\n}\n\n// Every LED of the top square, (x, y) with y up, takes the value of the\n// projection at s = x cos th + y sin th, read between bins.\nfunction smear(acc, p, th) {\n  const c = cos(th), sn = sin(th);\n  for (let y = 0; y \u003c Q; y++) {\n    const u0 = -C * c + (C - y) * sn + MID;\n    for (let x = 0, k = y * Q; x \u003c Q; x++, k++) {\n      const u = u0 + x * c, i = floor(u);\n      if (i \u003c 0 || i >= NB - 1) continue;\n      const f = u - i;\n      acc[k] += p[i] + (p[i + 1] - p[i]) * f;\n    }\n  }\n}\n\n// The first phantom: a body and five inner shapes, one of them a hole.\nfunction firstPhantom() {\n  return [\n    [0, 0, 27, 22, 0.3, 0.5],\n    [-9, 6, 9, 5, 0.9, 0.35],\n    [8, 7, 7, 7, 0, -0.3],\n    [5, -9, 10, 4, -0.4, 0.3],\n    [-8, -8, 3, 3, 0, 0.7],\n    [12, -4, 2, 3.5, 0.5, 0.8],\n  ];\n}\n\n// The next phantom: the whole turns 26 to 43 degrees, the inner shapes\n// drift, and one of them is drawn anew. Everything stays inside a circle of\n// 28 LEDs, so every shadow falls inside the 64 bins the sinogram shows.\nfunction nextPhantom(E) {\n  const turn = 0.45 + Math.random() * 0.3, ct = cos(turn), st = sin(turn);\n  const out = E.map(([x, y, a, b, phi, rho], i) => {\n    let nx = x * ct - y * st, ny = x * st + y * ct;\n    if (i > 0) {\n      nx += (Math.random() - 0.5) * 6, ny += (Math.random() - 0.5) * 6;\n      const r = sqrt(nx * nx + ny * ny), lim = 15 - max(a, b) * 0.4;\n      if (r > lim) (nx *= lim / r), (ny *= lim / r);\n    }\n    return [nx, ny, a, b, phi + turn, rho];\n  });\n  const k = 1 + floor(Math.random() * (out.length - 1)), small = Math.random() \u003c 0.4;\n  const a = small ? 2 + Math.random() * 2 : 4 + Math.random() * 6, b = small ? 2 + Math.random() * 2 : 3 + Math.random() * 4;\n  const ang = Math.random() * 2 * PI, r = Math.random() * 10;\n  const rho = small ? 0.6 + Math.random() * 0.3 : Math.random() \u003c 0.4 ? -0.3 : 0.25 + Math.random() * 0.2;\n  out[k] = [r * cos(ang), r * sin(ang), a, b, Math.random() * PI, rho];\n  // The body breathes between rounder and longer.\n  out[0][2] = 25 + Math.random() * 3, out[0][3] = 19 + Math.random() * 5;\n  return out;\n}\n\n// The sinogram a scan at all 64 angles would count at the same dose a\n// projection, the middle 64 bins across, and its peak before the noise.\nfunction sinogram(E, out, I0) {\n  const p = new Float32Array(NB);\n  let peak = 1e-6;\n  for (let r = 0; r \u003c Q; r++) {\n    project(E, (r * PI) / Q, p);\n    for (let x = OFF; x \u003c OFF + Q; x++) peak = max(peak, p[x]);\n    expose(p, I0);\n    out.set(p.subarray(OFF, OFF + Q), r * Q);\n  }\n  return peak;\n}\n\nconst TURNS = [4, 8, 16, 32, 64];\n// At Speed 2 the beam's half turn takes SCAN seconds, reading the sinogram\n// back into the picture takes SWEEP, the result holds HOLD and the last\n// FADE of the hold clears both squares.\nconst SCAN = 1, SWEEP = 6, HOLD = 1.5, FADE = 0.25, DIM = 0.15, P0 = 0.75;\n\n// A new scan starts on a cleared panel.\nfunction startCycle(S, E) {\n  S.E = E;\n  S.cycle++;\n  S.scan = 0, S.prog = 0, S.hold = 0;\n  rebuild(S);\n}\n\nfunction anglesFor(S) {\n  return S.knobN > 0 ? S.knobN : TURNS[(S.cycle + 2) % TURNS.length];\n}\n\n// Start over for the current angle count: measure every projection the\n// beam has passed and smear back every one the reading has reached.\nfunction rebuild(S) {\n  S.N = anglesFor(S);\n  S.peak = sinogram(S.E, S.sino, DOSE / S.N);\n  S.P.fill(0), S.R.fill(0);\n  S.done = 0, S.measured = 0, S.taken.fill(-1);\n  measure(S);\n  take(S);\n}\n\n// The beam passes angle k pi / N and the detector counts its projection.\nfunction measure(S) {\n  while (S.measured \u003c S.N && S.measured / S.N \u003c= S.scan + 1e-9) {\n    const k = S.measured++;\n    expose(project(S.E, (k * PI) / S.N, S.proj[k]), DOSE / S.N);\n    // Its row of the sinogram, drawn up to 3 rows deep when the rows\n    // between projections leave room.\n    const r0 = round((k / S.N) * Q), deep = cl(floor(Q / S.N / 3), 1, 3);\n    for (let j = 0; j \u003c deep; j++) {\n      const r = (r0 + j) % Q;\n      S.taken[r] = k, S.depth[r] = j;\n      S.rows[r].set(S.proj[k].subarray(OFF, OFF + Q));\n    }\n  }\n}\n\n// The reading reaches projection k: it is filtered and smeared back.\nfunction take(S) {\n  while (S.done \u003c S.measured && S.done / S.N \u003c= S.prog + 1e-9) {\n    const th = (S.done * PI) / S.N, p = S.proj[S.done];\n    ramp(p, S.q);\n    smear(S.P, p, th);\n    smear(S.R, S.q, th);\n    S.lastP.set(p), S.lastQ.set(S.q), S.lastTh = th, S.lastT = S.t;\n    S.done++;\n  }\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, filt: 0.06, knobN: -1, N: 4, cycle: -1, scan: 0, prog: 0, hold: 0, done: 0, measured: 0, first: true,\n    proj: Array.from({ length: 64 }, () => new Float32Array(NB)),\n    E: firstPhantom(), P: new Float32Array(Q * Q), R: new Float32Array(Q * Q), shown: new Float32Array(Q * Q),\n    sino: new Float32Array(Q * Q), peak: 1, clear: 1,\n    q: new Float32Array(NB), lastP: new Float32Array(NB), lastQ: new Float32Array(NB), lastTh: 0, lastT: -9,\n    taken: new Int16Array(Q).fill(-1), depth: new Uint8Array(Q), rows: Array.from({ length: Q }, () => new Float32Array(Q)), gain: 0, hist: new Int32Array(256), c: [0, 0, 0],\n  });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.t += dt;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.filt = cl(k[3], 0, 1);\n  const kn = cl(round(k[2]), 0, 64);\n  if (S.first) {\n    // The panel opens with the scan done and the reading P0 of the way\n    // through, so the picture is built by 1.5 s and the first clearing\n    // falls at 3 s.\n    S.knobN = kn;\n    startCycle(S, S.E);\n    S.scan = 1, S.prog = P0;\n    measure(S);\n    take(S);\n    S.first = false;\n  } else if (kn !== S.knobN) {\n    S.knobN = kn;\n    if (anglesFor(S) !== S.N) rebuild(S);\n  }\n  const rate = S.speed / 2;\n  if (S.scan \u003c 1) {\n    S.scan = min(1, S.scan + (dt * rate) / SCAN);\n    measure(S);\n  }\n  if (S.prog \u003c 1) {\n    S.prog = min(1, S.prog + (dt * rate) / SWEEP);\n    take(S);\n  } else {\n    S.hold += dt * rate;\n    if (S.hold >= HOLD) startCycle(S, nextPhantom(S.E));\n  }\n  // Near the end of the hold both squares dim over FADE seconds to DIM of\n  // their light and stay there for the last 0.07 s.\n  S.clear = S.prog \u003c 1 ? 1 : DIM + (1 - DIM) * cl((HOLD - S.hold - 0.07) / FADE, 0, 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.first) return;\n  const c = S.c, f = S.filt, n = max(1, S.done), A = (1 - f) * FLAT, B = f;\n  const shown = S.shown;\n  // The reconstruction is the sum of the smeared projections so far over\n  // the full count, so it builds up from black. The gain follows the peak\n  // of their mean, eased so a new streak does not flash the scale.\n  let top = 1e-6;\n  for (let i = 0; i \u003c Q * Q; i++) {\n    const v = (A * S.P[i] + B * S.R[i]) / n;\n    shown[i] = v;\n    if (v > top) top = v;\n  }\n  // The scale is set by the brightest 0.5% of LEDs, so a few noise spikes\n  // do not darken the whole picture.\n  const hist = S.hist.fill(0);\n  for (let i = 0; i \u003c Q * Q; i++) if (shown[i] > 0) hist[min(255, floor((shown[i] / top) * 256))]++;\n  let b = 255;\n  for (let cnt = 0; b > 0 && (cnt += hist[b]) \u003c Q * Q * 0.005; ) b--;\n  const peak = (top * (b + 1)) / 256;\n  S.gain = S.gain > 0 ? S.gain + (1 / peak - S.gain) * 0.25 : 1 / peak;\n  const g = S.gain, env = S.clear;\n  // The newest projection flashes along its rays for a moment.\n  const fl = exp(-(S.t - S.lastT) / 0.25) * 0.5 * S.clear, cth = cos(S.lastTh), sth = sin(S.lastTh);\n  const hr = 0.55 + S.hue, hn = 0.78 + S.hue;\n  for (let y = 0; y \u003c Q; y++) {\n    const u0 = -C * cth + (C - y) * sth + MID;\n    for (let x = 0; x \u003c Q; x++) {\n      const i = y * Q + x;\n      let u = shown[i] * g * env;\n      if (fl > 0.01) {\n        const s = u0 + x * cth, j = floor(s);\n        if (j >= 0 && j \u003c NB - 1) {\n          const w = s - j, pv = S.lastP[j] + (S.lastP[j + 1] - S.lastP[j]) * w, qv = S.lastQ[j] + (S.lastQ[j + 1] - S.lastQ[j]) * w;\n          u += fl * (A * pv + B * qv) * g;\n        }\n      }\n      shown[i] = u;\n      if (u >= 0) {\n        // A soft shoulder above 0.7 instead of a hard clip at white.\n        const v = u \u003c 0.7 ? u : 1 - 0.3 * exp(-(u - 0.7) / 0.3);\n        hsv(hr - 0.05 + 0.1 * v, 0.85 - 0.75 * v * v, 0.06 + 0.94 * v ** 0.65, c);\n      } else hsv(hn, 0.65, min(0.5, -u * 0.9), c);\n      display.setPixel(x, y, 255 * c[0], 255 * c[1], 255 * c[2]);\n    }\n  }\n  // The sinogram, angle 0 at the top to 180 degrees at the bottom. Rows the\n  // beam has passed show the full sinogram dimly and the rows of the\n  // projections measured brightly, brightest once they are smeared back;\n  // rows ahead are dark. A row flashes white as it is smeared back.\n  const swept = S.scan >= 1 ? Q : floor(S.scan * Q + 1e-6) + 1, hs = 0.72 + S.hue, pk = S.peak;\n  for (let r = 0; r \u003c swept; r++) {\n    const tk = S.taken[r] >= 0;\n    const lv = (tk ? (S.taken[r] \u003c S.done ? 1 : 0.7) * (S.depth[r] ? 0.8 : 1) : 0.55) * S.clear;\n    const src = tk ? S.rows[r] : S.sino.subarray(r * Q, r * Q + Q);\n    const hot = tk && S.taken[r] === S.done - 1 ? exp(-(S.t - S.lastT) / 0.3) : 0;\n    for (let x = 0; x \u003c Q; x++) {\n      // An empty bin reads 0 give or take its noise, on a faint floor.\n      const v = cl(0.12 + 0.88 * (src[x] / pk), 0, 1), e = v ** 0.65;\n      hsv(hs - 0.04 + 0.12 * v, max(0, 0.8 - 0.55 * v * v - 0.6 * hot), lv * e * (1 - hot) + hot * (0.3 + 0.7 * v), c);\n      display.setPixel(x, Q + r, 255 * c[0], 255 * c[1], 255 * c[2]);\n    }\n  }\n  // While the beam turns: its place, a tick at each side of the sinogram,\n  // and its direction across the top square as a faint line.\n  if (S.scan \u003c 1) {\n    const r = min(Q - 1, floor(S.scan * Q));\n    for (const x of [0, 1, Q - 2, Q - 1]) display.setPixel(x, Q + r, 255, 255, 255);\n    const th = S.scan * PI, dx = -sin(th), dy = -cos(th);\n    for (let s = -44; s \u003c= 44; s += 0.5) {\n      const x = round(C + s * dx), y = round(C + s * dy);\n      if (x \u003c 0 || x >= Q || y \u003c 0 || y >= Q) continue;\n      const u = shown[y * Q + x];\n      hsv(hr, 0.3, min(1, 0.35 + max(0, u)), c);\n      display.setPixel(x, y, 255 * c[0], 255 * c[1], 255 * c[2]);\n    }\n  }\n}\n","shannon-approximations":"// ===== Patternflow pattern =====\n// Title:   Shannon's Approximations\n// Family:  type\n// Idea:    A page of 21 lines of 16 small capitals is typed over and over by a cursor that writes Claude Shannon's approximations to English, from 27 equiprobable symbols up through letter, digram and trigram statistics to word frequencies and word pairs, all counted from the opening of Pride and Prejudice, and every run of letters that is a real word of that text lights up, so the page turns from dim noise into lit words as the order rises.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the series of approximations to English in A Mathematical Theory of Communication, section 3 (Claude Shannon, 1948), counted from the opening of Pride and Prejudice (Jane Austen, 1813), 3x5 capitals drawn for this pattern, pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=0..5, Blackout=0..1\n//\n// Knob 1: Hue. Turns the page round the wheel: at 0 the words are sea green, word pairs from the book warm gold and the noise between them slate.\n// Knob 2: Speed. Letters a second, eight times the knob: 16 at 2, so the cursor goes round the 336 cells of the page in 21 s; 1.6 at 0.2, 24 at 3. Fresh letters burn white and cool over a second.\n// Knob 3: Order. Shannon's six steps, in whole steps: 0 the 27 symbols equiprobable, 1 letter frequencies, 2 digrams, 3 trigrams, 4 words by their frequency, 5 each word drawn after the word before it. A change rewrites the whole page from the top in 0.6 s. The bottom row is a gauge of the share of the page's letters that stand in real words.\n// Knob 4: Blackout. How the runs that are not words show: dim letters at 0, and turned up they sink under dark ink bars until at 1 only the real words stand on a blacked-out page.\n\nconst W = 64, H = 128;\nconst { floor, min, max, exp, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The opening of Pride and Prejudice, chapter 1 up to Lizzy, cut down to\n// Shannon's 27 symbols: capitals and the space. 2,812 symbols, 577 words,\n// 236 different words.\nconst TEXT =\n  \"IT IS A TRUTH UNIVERSALLY ACKNOWLEDGED THAT A SINGLE MAN IN POSSESSION OF A \" +\n  \"GOOD FORTUNE MUST BE IN WANT OF A WIFE HOWEVER LITTLE KNOWN THE FEELINGS OR \" +\n  \"VIEWS OF SUCH A MAN MAY BE ON HIS FIRST ENTERING A NEIGHBOURHOOD THIS TRUTH \" +\n  \"IS SO WELL FIXED IN THE MINDS OF THE SURROUNDING FAMILIES THAT HE IS \" +\n  \"CONSIDERED THE RIGHTFUL PROPERTY OF SOME ONE OR OTHER OF THEIR DAUGHTERS MY \" +\n  \"DEAR MR BENNET SAID HIS LADY TO HIM ONE DAY HAVE YOU HEARD THAT NETHERFIELD \" +\n  \"PARK IS LET AT LAST MR BENNET REPLIED THAT HE HAD NOT BUT IT IS RETURNED SHE \" +\n  \"FOR MRS LONG HAS JUST BEEN HERE AND SHE TOLD ME ALL ABOUT IT MR BENNET MADE \" +\n  \"NO ANSWER DO YOU NOT WANT TO KNOW WHO HAS TAKEN IT CRIED HIS WIFE \" +\n  \"IMPATIENTLY YOU WANT TO TELL ME AND I HAVE NO OBJECTION TO HEARING IT THIS \" +\n  \"WAS INVITATION ENOUGH WHY MY DEAR YOU MUST KNOW MRS LONG SAYS THAT \" +\n  \"NETHERFIELD IS TAKEN BY A YOUNG MAN OF LARGE FORTUNE FROM THE NORTH OF \" +\n  \"ENGLAND THAT HE CAME DOWN ON MONDAY IN A CHAISE AND FOUR TO SEE THE PLACE \" +\n  \"AND WAS SO MUCH DELIGHTED WITH IT THAT HE AGREED WITH MR MORRIS IMMEDIATELY \" +\n  \"THAT HE IS TO TAKE POSSESSION BEFORE MICHAELMAS AND SOME OF HIS SERVANTS ARE \" +\n  \"TO BE IN THE HOUSE BY THE END OF NEXT WEEK WHAT IS HIS NAME BINGLEY IS HE \" +\n  \"MARRIED OR SINGLE OH SINGLE MY DEAR TO BE SURE A SINGLE MAN OF LARGE FORTUNE \" +\n  \"FOUR OR FIVE THOUSAND A YEAR WHAT A FINE THING FOR OUR GIRLS HOW SO HOW CAN \" +\n  \"IT AFFECT THEM MY DEAR MR BENNET REPLIED HIS WIFE HOW CAN YOU BE SO TIRESOME \" +\n  \"YOU MUST KNOW THAT I AM THINKING OF HIS MARRYING ONE OF THEM IS THAT HIS \" +\n  \"DESIGN IN SETTLING HERE DESIGN NONSENSE HOW CAN YOU TALK SO BUT IT IS VERY \" +\n  \"LIKELY THAT HE MAY FALL IN LOVE WITH ONE OF THEM AND THEREFORE YOU MUST \" +\n  \"VISIT HIM AS SOON AS HE COMES I SEE NO OCCASION FOR THAT YOU AND THE GIRLS \" +\n  \"MAY GO OR YOU MAY SEND THEM BY THEMSELVES WHICH PERHAPS WILL BE STILL BETTER \" +\n  \"FOR AS YOU ARE AS HANDSOME AS ANY OF THEM MR BINGLEY MAY LIKE YOU THE BEST \" +\n  \"OF THE PARTY MY DEAR YOU FLATTER ME I CERTAINLY HAVE HAD MY SHARE OF BEAUTY \" +\n  \"BUT I DO NOT PRETEND TO BE ANYTHING EXTRAORDINARY NOW WHEN A WOMAN HAS FIVE \" +\n  \"GROWN UP DAUGHTERS SHE OUGHT TO GIVE OVER THINKING OF HER OWN BEAUTY IN SUCH \" +\n  \"CASES A WOMAN HAS NOT OFTEN MUCH BEAUTY TO THINK OF BUT MY DEAR YOU MUST \" +\n  \"INDEED GO AND SEE MR BINGLEY WHEN HE COMES INTO THE NEIGHBOURHOOD IT IS MORE \" +\n  \"THAN I ENGAGE FOR I ASSURE YOU BUT CONSIDER YOUR DAUGHTERS ONLY THINK WHAT \" +\n  \"AN ESTABLISHMENT IT WOULD BE FOR ONE OF THEM SIR WILLIAM AND LADY LUCAS ARE \" +\n  \"DETERMINED TO GO MERELY ON THAT ACCOUNT FOR IN GENERAL YOU KNOW THEY VISIT \" +\n  \"NO NEWCOMERS INDEED YOU MUST GO FOR IT WILL BE IMPOSSIBLE FOR US TO VISIT \" +\n  \"HIM IF YOU DO NOT YOU ARE OVER SCRUPULOUS SURELY I DARE SAY MR BINGLEY WILL \" +\n  \"BE VERY GLAD TO SEE YOU AND I WILL SEND A FEW LINES BY YOU TO ASSURE HIM OF \" +\n  \"MY HEARTY CONSENT TO HIS MARRYING WHICHEVER HE CHOOSES OF THE GIRLS THOUGH I \" +\n  \"MUST THROW IN A GOOD WORD FOR MY LITTLE LIZZY \";\n\n// Symbol 0 is the space, 1 to 26 the letters. The text is read as a ring\n// (its last space leads back to IT), so every context it holds has a\n// letter after it.\nconst ABC = \" ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\nconst SRC = Uint8Array.from(TEXT, (c) => ABC.indexOf(c));\nconst N = SRC.length;\n// Shannon's way of drawing the higher orders: open the book at a random\n// place where the last letters occur and copy the letter that follows. The\n// lists below are those places, by the last letter and by the last two.\nconst AFTER1 = Array.from({ length: 27 }, () => []);\nconst AFTER2 = Array.from({ length: 27 * 27 }, () => []);\nfor (let i = 0; i \u003c N; i++) {\n  AFTER1[SRC[i]].push(i);\n  AFTER2[SRC[(i + N - 1) % N] * 27 + SRC[i]].push(i);\n}\n// Words: the vocabulary, the running text as word ids, where each word\n// occurs, and every pair of words that stands side by side in the book.\nconst TOKS = TEXT.trim().split(\" \");\nconst VOCAB = new Map(), WORDS = [];\nfor (const w of TOKS) if (!VOCAB.has(w)) VOCAB.set(w, WORDS.length), WORDS.push(w);\nconst NV = WORDS.length, TID = TOKS.map((w) => VOCAB.get(w));\nconst SUCC = Array.from({ length: NV }, () => []);\nconst PAIRS = new Set();\nfor (let k = 0; k + 1 \u003c TID.length; k++) SUCC[TID[k]].push(k), PAIRS.add(TID[k] * NV + TID[k + 1]);\n\n// 3x5 capitals, rows top to bottom, a 1 is a lit LED.\nconst GLYPHS = [\n  \"010101111101101\", \"110101110101110\", \"011100100100011\", \"110101101101110\", \"111100110100111\",\n  \"111100110100100\", \"011100101101011\", \"101101111101101\", \"111010010010111\", \"001001001101010\",\n  \"101101110101101\", \"100100100100111\", \"101111111101101\", \"111101101101101\", \"010101101101010\",\n  \"110101110100100\", \"010101101110011\", \"110101110101101\", \"011100010001110\", \"111010010010010\",\n  \"101101101101111\", \"101101101101010\", \"101101111111101\", \"101101010101101\", \"101101010010010\",\n  \"111001010100111\",\n];\nconst FONT = GLYPHS.map((g) => Uint8Array.from(g, (c) => +c));\n\n// The page: 16 cells across, 4 LEDs each, and 21 lines 6 LEDs apart.\nconst COLS = 16, ROWS = 21, CELLS = COLS * ROWS, CW = 4, CH = 6, TOP = 1;\n// The fresh-ink glow fades with this time constant, and a wipe writes one\n// line every WIPE seconds.\nconst GLOW = 1, WIPE = 0.03;\n\nconst rnd = (n) => floor(Math.random() * n);\n\n// The next symbol at the current order.\nfunction nextSymbol(S) {\n  const o = S.order;\n  let c;\n  if (o >= 4) {\n    if (S.qi >= S.q.length) {\n      let id = -1;\n      if (o === 5 && S.pw >= 0 && SUCC[S.pw].length) id = TID[SUCC[S.pw][rnd(SUCC[S.pw].length)] + 1];\n      if (id \u003c 0) id = TID[rnd(TID.length)];\n      S.q = (S.h1 === 0 ? \"\" : \" \") + WORDS[id] + \" \";\n      S.qi = 0;\n      S.pw = id;\n    }\n    c = ABC.indexOf(S.q[S.qi++]);\n  } else {\n    S.q = \"\", S.qi = 0, S.pw = -1;\n    if (o === 0) c = rnd(27);\n    else {\n      let list = o === 3 ? AFTER2[S.h0 * 27 + S.h1] : o === 2 ? AFTER1[S.h1] : null;\n      // A context the book never has (a Q, or two letters a lower order\n      // put side by side) falls back to a lower order.\n      if (o === 3 && !list.length) list = AFTER1[S.h1];\n      c = list && list.length ? SRC[(list[rnd(list.length)] + 1) % N] : SRC[rnd(N)];\n    }\n  }\n  S.h0 = S.h1, S.h1 = c;\n  return c;\n}\n\n// Which cells are words. The page is read as one ring of text in typing\n// order, so a word may run over a line end, and from the bottom line back\n// to the top. Each run of letters is looked up in the vocabulary; two words\n// one space apart that stand side by side in the book are a pair.\nfunction classify(S) {\n  const P = S.P, C = S.cls, L = S.len;\n  C.fill(0), L.fill(0);\n  let s0 = -1;\n  for (let i = 0; i \u003c CELLS; i++) if (P[i] === 0) { s0 = i; break; }\n  if (s0 \u003c 0) return C.fill(1);\n  const runs = [];\n  let i = 1;\n  while (i \u003c= CELLS) {\n    if (P[(s0 + i) % CELLS] === 0) { i++; continue; }\n    const st = i;\n    let word = \"\";\n    while (i \u003c= CELLS && P[(s0 + i) % CELLS] !== 0) word += ABC[P[(s0 + i++) % CELLS]];\n    const id = VOCAB.get(word);\n    runs.push([st, i - st, id === undefined ? -1 : id, 0]);\n  }\n  for (let r = 0; r + 1 \u003c runs.length; r++) {\n    const a = runs[r], b = runs[r + 1];\n    if (a[2] >= 0 && b[2] >= 0 && b[0] === a[0] + a[1] + 1 && PAIRS.has(a[2] * NV + b[2])) a[3] = b[3] = 1;\n  }\n  let words = 0, letters = 0;\n  for (const [st, n, id, pair] of runs) {\n    const k = id \u003c 0 ? 1 : pair ? 3 : 2;\n    letters += n;\n    if (id >= 0) words += n;\n    for (let j = 0; j \u003c n; j++) {\n      const p = (s0 + st + j) % CELLS;\n      C[p] = k, L[p] = n;\n    }\n  }\n  S.share = words / max(1, letters);\n}\n\n// A fresh page at the current order, as if just typed at the current speed.\nfunction fillPage(S) {\n  for (let i = 0; i \u003c CELLS; i++) {\n    S.P[i] = nextSymbol(S);\n    S.T[i] = S.t - (CELLS - 1 - i) / S.cps;\n  }\n  S.cur = 0, S.acc = 0, S.dirty = true;\n}\n\nexport function setup(params) {\n  params.s = {\n    P: new Uint8Array(CELLS), T: new Float32Array(CELLS), NEXT: new Uint8Array(CELLS),\n    cls: new Uint8Array(CELLS), len: new Uint8Array(CELLS),\n    t: 0, cps: 16, order: -1, cur: 0, acc: 0, dirty: true, share: 0,\n    h0: 0, h1: 0, q: \"\", qi: 0, pw: -1, wipe: -1, wiped: 0, hue: 0, black: 0.06,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.t += dt;\n  S.hue = k[0];\n  S.cps = 8 * cl(k[1], 0.2, 3);\n  S.black = cl(k[3], 0, 1);\n  const order = cl(round(k[2]), 0, 5);\n  if (S.order \u003c 0) {\n    S.order = order;\n    fillPage(S);\n  } else if (order !== S.order) {\n    // A new order writes a whole new page, revealed a line at a time from\n    // the top; the cursor then goes on from the top-left cell.\n    S.order = order;\n    for (let i = 0; i \u003c CELLS; i++) S.NEXT[i] = nextSymbol(S);\n    S.wipe = S.t, S.wiped = 0;\n  }\n  if (S.wipe >= 0) {\n    const upto = min(ROWS, floor((S.t - S.wipe) / WIPE) + 1);\n    for (; S.wiped \u003c upto; S.wiped++)\n      for (let c = 0; c \u003c COLS; c++) {\n        const i = S.wiped * COLS + c;\n        S.P[i] = S.NEXT[i], S.T[i] = S.t;\n      }\n    S.dirty = true;\n    if (S.wiped >= ROWS) S.wipe = -1, S.cur = 0, S.acc = 0;\n    else return;\n  }\n  S.acc += dt * S.cps;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    S.P[S.cur] = nextSymbol(S);\n    S.T[S.cur] = S.t;\n    S.cur = (S.cur + 1) % CELLS;\n    S.dirty = true;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.order \u003c 0) return;\n  if (S.dirty) classify(S), (S.dirty = false);\n  const h = S.hue, B = S.black;\n  // Colours by class: 1 noise, 2 a word, 3 a word of a pair from the book.\n  const noise = hsv(h + 0.62, 0.5, 0.42), word = hsv(h + 0.45, 0.8, 1), pair = hsv(h + 0.12, 0.5, 1);\n  const ink = hsv(h + 0.64, 0.55, 0.2 * B);\n  const nl = (1 - B) * (1 - B);\n  const blink = S.wipe \u003c 0 && (S.t * 2.5) % 1 \u003c 0.6;\n  for (let i = 0; i \u003c CELLS; i++) {\n    const x0 = (i % COLS) * CW, y0 = TOP + floor(i / COLS) * CH;\n    const sym = S.P[i], k = S.cls[i];\n    if (i === S.cur && blink) {\n      for (let y = 0; y \u003c 5; y++) for (let x = 0; x \u003c 3; x++) display.setPixel(x0 + x, y0 + y, 200, 200, 190);\n      continue;\n    }\n    if (sym === 0) continue;\n    let col, lv;\n    if (k === 1) (col = noise), (lv = nl);\n    else {\n      col = k === 3 ? pair : word;\n      const n = S.len[i];\n      lv = n >= 3 ? 1 : n === 2 ? 0.8 : 0.6;\n    }\n    // Fresh ink burns toward white and cools into its class colour.\n    const g = exp(-(S.t - S.T[i]) / GLOW), wv = 235 * g;\n    const r = 255 * col[0] * lv * (1 - g) + wv, gg = 255 * col[1] * lv * (1 - g) + wv, b = 255 * col[2] * lv * (1 - g) + wv;\n    const bar = k === 1 && B > 0.01;\n    const f = FONT[sym - 1];\n    for (let y = 0, j = 0; y \u003c 5; y++)\n      for (let x = 0; x \u003c 3; x++, j++) {\n        if (f[j]) {\n          // Under the ink a noise letter fades into its bar.\n          if (bar) display.setPixel(x0 + x, y0 + y, min(255, r + 255 * ink[0]), min(255, gg + 255 * ink[1]), min(255, b + 255 * ink[2]));\n          else display.setPixel(x0 + x, y0 + y, min(255, r), min(255, gg), min(255, b));\n        } else if (bar) display.setPixel(x0 + x, y0 + y, 255 * ink[0], 255 * ink[1], 255 * ink[2]);\n        else if (g > 0.05) display.setPixel(x0 + x, y0 + y, 0.2 * wv, 0.2 * wv, 0.2 * wv);\n      }\n  }\n  // The bottom row is a gauge: the share of the page's letters that stand\n  // in real words, about 0, 2, 6 and 27% at orders 0 to 3 and 98% from 4 on.\n  const lit = round(W * S.share);\n  for (let x = 0; x \u003c W; x++) {\n    const c = x \u003c lit ? word : noise, v = x \u003c lit ? 200 : 110;\n    display.setPixel(x, H - 1, v * c[0], v * c[1], v * c[2]);\n  }\n}\n","silencio":"// ===== Patternflow pattern =====\n// Title:   Silencio\n// Family:  type\n// Idea:    Eugen Gomringer's constellation of fourteen words round one empty place is set on the panel, the Latin words turned a quarter like book spines and the Hangul ones upright, and the empty place drifts from slot to slot, the word it enters trailing off letter by letter while the word it leaves is spoken back in from its first letter, as a slow reading light passes along every line and goes dark over the gap.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: silencio (Eugen Gomringer, 1953), the best-known constellation of concrete poetry, with schweigen and silence, its German and English versions; the Latin letters and the Hangul 침묵 and 고요 drawn for this pattern, pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Hush=0..1\n//\n// Knob 1: Hue. Turns the words round the wheel from a pale azure at 0; the words nearest the silence lean a little towards violet.\n// Knob 2: Speed. How fast the reading light runs and the silence moves: at 2 the light takes a second over each word and pauses 0.6 between words, and the silence moves on every 3.6 seconds (5.4 when it is home); at 0.2 all of it ten times slower. The glow behind the light dies in 1.1 seconds at any speed, so a fast reading leaves whole words lit.\n// Knob 3: Word. 0 silencio, 1 schweigen, 2 silence, 3 침묵, 4 고요. The Latin words stand turned in five columns of three, the Hangul in Gomringer's own three columns of five; a new word empties the field and speaks back in.\n// Knob 4: Hush. Up to 0.1 one place is silent, as in the poem. Above that the silence spreads from it to its neighbours, trailing their words off, until at 1 nine of the fifteen places are silent and only the outer words still speak.\n// Buttons: any button moves the silence on at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Latin. A lowercase face 9 rows tall: rows 0 and 1 hold ascenders,\n// 2 to 6 the x-height, 7 and 8 the one descender (g). Only the ten letters\n// the three words use. Most are 3 wide; i is 1, l 2, w 5.\nconst LATIN = {\n  s: [\"...\", \"...\", \".##\", \"#..\", \".#.\", \"..#\", \"##.\", \"...\", \"...\"],\n  i: [\"#\", \".\", \"#\", \"#\", \"#\", \"#\", \"#\", \".\", \".\"],\n  l: [\"#.\", \"#.\", \"#.\", \"#.\", \"#.\", \"#.\", \".#\", \"..\", \"..\"],\n  e: [\"...\", \"...\", \".#.\", \"#.#\", \"###\", \"#..\", \".##\", \"...\", \"...\"],\n  n: [\"...\", \"...\", \"##.\", \"#.#\", \"#.#\", \"#.#\", \"#.#\", \"...\", \"...\"],\n  c: [\"...\", \"...\", \".##\", \"#..\", \"#..\", \"#..\", \".##\", \"...\", \"...\"],\n  o: [\"...\", \"...\", \".#.\", \"#.#\", \"#.#\", \"#.#\", \".#.\", \"...\", \"...\"],\n  h: [\"#..\", \"#..\", \"##.\", \"#.#\", \"#.#\", \"#.#\", \"#.#\", \"...\", \"...\"],\n  w: [\".....\", \".....\", \"#...#\", \"#...#\", \"#.#.#\", \"#.#.#\", \".#.#.\", \".....\", \".....\"],\n  g: [\"...\", \"...\", \".##\", \"#.#\", \"#.#\", \"#.#\", \".##\", \"..#\", \"##.\"],\n};\n\n// A Latin word turned a quarter clockwise, the way a spine reads in English:\n// the tops of the letters face right and the word runs down. Turned so, a\n// page of lines becomes columns read top to bottom and right to left, the\n// order of Korean set in vertical columns. A word is a list of letters, each\n// a flat list of LED offsets x, y from the word's top left.\nfunction latinWord(text) {\n  const rows = text.split(\"\").some((ch) => LATIN[ch].slice(7).some((r) => r.includes(\"#\"))) ? 9 : 7;\n  const letters = [];\n  let y = 0;\n  for (const ch of text) {\n    const g = LATIN[ch], px = [];\n    for (let gy = 0; gy \u003c rows; gy++)\n      for (let gx = 0; gx \u003c g[gy].length; gx++) if (g[gy][gx] === \"#\") px.push(rows - 1 - gy, y + gx);\n    letters.push(px);\n    y += g[0].length + 1;\n  }\n  return { w: rows, h: y - 1, letters };\n}\n\n// ---- Hangul. Each syllable is 7 by 11 and each digit marks the jamo a dot\n// belongs to, in writing order, so a Hangul word goes quiet and comes back\n// jamo by jamo: 침묵 has six letters (ㅊ ㅣ ㅁ, ㅁ ㅜ ㄱ), 고요 four (ㄱ ㅗ, ㅇ ㅛ).\nconst HANGUL = {\n  침: [\"..1...2\", \"11111.2\", \"..1...2\", \".1.1..2\", \"1...1.2\", \"......2\", \".......\", \".33333.\", \".3...3.\", \".3...3.\", \".33333.\"],\n  묵: [\".11111.\", \".1...1.\", \".1...1.\", \".11111.\", \".......\", \"2222222\", \"...2...\", \".......\", \".33333.\", \".....3.\", \".....3.\"],\n  고: [\".......\", \".11111.\", \".....1.\", \".....1.\", \".....1.\", \".....1.\", \".......\", \"...2...\", \"...2...\", \"2222222\", \".......\"],\n  요: [\".......\", \"..111..\", \".1...1.\", \".1...1.\", \".1...1.\", \"..111..\", \".......\", \"..2.2..\", \"..2.2..\", \"2222222\", \".......\"],\n};\n\nfunction hangulWord(text) {\n  const letters = [];\n  [...text].forEach((syl, k) => {\n    const g = HANGUL[syl], parts = [];\n    for (let y = 0; y \u003c g.length; y++)\n      for (let x = 0; x \u003c 7; x++) {\n        const d = +g[y][x];\n        if (!d) continue;\n        (parts[d - 1] = parts[d - 1] || []).push(k * 8 + x, y);\n      }\n    letters.push(...parts);\n  });\n  return { w: 15, h: 11, letters };\n}\n\nconst WORDS = [\"silencio\", \"schweigen\", \"silence\", \"침묵\", \"고요\"];\n\n// Fifteen places. Gomringer set three words to a line in five lines with\n// the middle of the third line empty. The Latin words, turned, fill five\n// columns of three (the first line is the right column); the Hangul ones\n// stand in his three columns of five. Either way the empty place is the\n// middle one.\nfunction layout(k) {\n  const latin = k \u003c 3;\n  const word = latin ? latinWord(WORDS[k]) : hangulWord(WORDS[k]);\n  const cols = latin ? 5 : 3, rows = latin ? 3 : 5, slots = [];\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++)\n      slots.push(\n        latin\n          ? { c, r, x: round((c + 0.5) * 12.8 - word.w / 2), y: round(((r + 0.5) * H) / 3 - word.h / 2), line: cols - 1 - c, at: r }\n          : { c, r, x: [3, 24, 46][c], y: 8 + 25 * r, line: r, at: c },\n      );\n  const n = word.letters.length;\n  // A reading light runs along each of the five lines word by word, a pause\n  // the length of 0.6 of a word between words.\n  const step = n * 1.6;\n  return { word, n, cols, rows, slots, home: (rows >> 1) * cols + (cols >> 1), step, line: step * 3 };\n}\n\nconst HOP = 3.6, TRANS = 1.5, RATE = 1 / 1.6;\n\nexport function setup(params) {\n  params.s = { T: 0, k: -1, L: null, q: null, qt: null, at: 0, prev: -1, next: 0, cx: 0, cy: 0, fx: 0, fy: 0, glide: 9, hush: 0, Lv: new Float32Array(N), Hu: new Float32Array(N), Bo: new Float32Array(N) };\n}\n\n// The places sorted into rings by distance from the silence; the hush\n// budget (1 place at Hush 0.1 or less, up to 9) fills them ring by ring and\n// shares out a ring it cannot fill, so neighbours trail off together.\nfunction targets(S) {\n  const { slots, n } = S.L, a = slots[S.at];\n  const budget = 1 + (max(0, S.hush - 0.1) / 0.9) * 8;\n  const d = slots.map((s) => round(sqrt((s.c - a.c) ** 2 + (s.r - a.r) ** 2) * 1000));\n  const rings = [...new Set(d)].sort((x, y) => x - y);\n  let left = budget;\n  S.reach = 0;\n  for (const ring of rings) {\n    const idx = [];\n    d.forEach((v, j) => v === ring && idx.push(j));\n    const f = cl(left / idx.length, 0, 1);\n    for (const j of idx) S.qt[j] = f * n;\n    if (f > 0) S.reach = ring / 1000;\n    left -= idx.length;\n  }\n}\n\nfunction useWord(S, k, first) {\n  S.k = k;\n  S.L = layout(k);\n  const m = S.L.slots.length;\n  S.q = new Float32Array(m);\n  S.qt = new Float32Array(m);\n  S.at = S.L.home;\n  S.prev = -1;\n  const h = S.L.slots[S.at];\n  S.cx = S.fx = h.c;\n  S.cy = S.fy = h.r;\n  S.glide = 9;\n  targets(S);\n  // The first word is there at once. A new word empties the field and comes\n  // back place by place in reading order, each spoken from its first letter.\n  S.L.slots.forEach((s, j) => (S.q[j] = first ? S.qt[j] : S.L.n + 1 + (s.line * 3 + s.at) * 0.2 * S.L.n));\n  S.next = S.T + (first ? HOP * 0.3 : HOP * 1.6);\n}\n\n// The silence moves to a neighbouring place, never straight back, and\n// leans home: a place's weight falls with the square of its distance from\n// the middle, so the poem's own form comes round often.\nfunction hop(S) {\n  const { slots, cols, rows, home } = S.L, a = slots[S.at];\n  const h = slots[home], opts = [], wts = [];\n  for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n    const c = a.c + dc, r = a.r + dr;\n    if (c \u003c 0 || r \u003c 0 || c >= cols || r >= rows) continue;\n    const j = r * cols + c;\n    if (j === S.prev) continue;\n    opts.push(j);\n    wts.push(1 / (1 + (c - h.c) ** 2 + (r - h.r) ** 2));\n  }\n  let u = Math.random() * wts.reduce((x, y) => x + y, 0), j = opts[0];\n  for (let i = 0; i \u003c opts.length; i++) if ((u -= wts[i]) \u003c= 0) {\n    j = opts[i];\n    break;\n  }\n  S.fx = S.cx;\n  S.fy = S.cy;\n  S.prev = S.at;\n  S.at = j;\n  S.glide = 0;\n  targets(S);\n  S.next = S.T + (j === home ? HOP * 1.5 : HOP);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const want = cl(round(k[2]), 0, 4);\n  if (S.k \u003c 0) {\n    S.hush = cl(k[3], 0, 1);\n    useWord(S, want, true);\n  } else if (want !== S.k) useWord(S, want, false);\n  if (abs(k[3] - S.hush) > 1e-4) {\n    S.hush = cl(k[3], 0, 1);\n    targets(S);\n  }\n  S.speed = cl(k[1], 0.05, 3);\n  const step = (dt * S.speed) / 2;\n  S.T += step;\n  if ((input.btnPressed || []).some(Boolean)) S.next = S.T;\n  if (S.T >= S.next) hop(S);\n  // Letters go and come at n letters in TRANS.\n  const rate = (S.L.n / TRANS) * step;\n  for (let j = 0; j \u003c S.q.length; j++) {\n    const d = S.qt[j] - S.q[j];\n    S.q[j] += abs(d) \u003c= rate ? d : Math.sign(d) * rate;\n  }\n  S.glide = min(9, S.glide + step / TRANS);\n  const e = smooth(S.glide), a = S.L.slots[S.at];\n  S.cx = S.fx + (a.c - S.fx) * e;\n  S.cy = S.fy + (a.r - S.fy) * e;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.L) return;\n  const { Lv, Hu, Bo } = S, { word, n, slots, step, line } = S.L;\n  Lv.fill(0);\n  const H0 = 0.56 + S.hue;\n  const pos = S.T * RATE * step;\n  // The sound dies away in 1.1 seconds whatever the speed, so a fast\n  // reader leaves a longer glow behind and a slow one barely any.\n  const tail = max(0.25, RATE * step * (S.speed / 2) * 1.1);\n  slots.forEach((s, j) => {\n    const quiet = S.q[j];\n    if (quiet >= n) return;\n    // Words near the silence speak more softly: full voice two places\n    // beyond the edge of the silence.\n    const dist = sqrt((s.c - S.cx) ** 2 + (s.r - S.cy) ** 2);\n    const near = 1 - smooth((dist - S.reach) / 2);\n    const voice = 1 - 0.34 * near;\n    // Where this line's reading light is, in letters; lines are staggered\n    // by the golden ratio so the five lights never march together.\n    const r = (((pos + s.line * line * 0.618) % line) + line) % line;\n    const hue = H0 + 0.07 * near;\n    word.letters.forEach((px, i) => {\n      const a = cl(n - quiet - i, 0, 1);\n      if (a \u003c= 0) return;\n      // A sound: quick to come, slow to die away behind the light.\n      let u = r - (s.at * step + i);\n      if (u \u003c -line / 2) u += line;\n      else if (u > line / 2) u -= line;\n      const boost = u >= 0 ? exp(-u / tail) : exp(-u * u * 0.8);\n      const v = a * voice * (0.48 + 0.52 * boost);\n      for (let p = 0; p \u003c px.length; p += 2) {\n        const o = (s.y + px[p + 1]) * W + s.x + px[p];\n        Lv[o] = v;\n        Hu[o] = hue;\n        Bo[o] = boost;\n      }\n    });\n  });\n  // A faint glow one LED round each letter; the silent places hold no\n  // letters, and the places sit at least 3 LEDs apart, so it never reaches\n  // into the silence.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      const v = Lv[o];\n      if (v > 0) {\n        const sat = 0.58 * (1 - 0.55 * Bo[o]);\n        const [r, g, b] = hsv(Hu[o], sat, v);\n        display.setPixel(x, y, r * 255, g * 255, b * 255);\n        continue;\n      }\n      let best = 0, hb = 0;\n      for (let dy = -1; dy \u003c= 1; dy++) {\n        const yy = y + dy;\n        if (yy \u003c 0 || yy >= H) continue;\n        for (let dx = -1; dx \u003c= 1; dx++) {\n          const xx = x + dx;\n          if (xx \u003c 0 || xx >= W) continue;\n          const w = Lv[yy * W + xx] * (dx && dy ? 0.14 : 0.24);\n          if (w > best) (best = w), (hb = Hu[yy * W + xx]);\n        }\n      }\n      if (best \u003c= 0) continue;\n      const [r, g, b] = hsv(hb, 0.75, best);\n      display.setPixel(x, y, r * 255, g * 255, b * 255);\n    }\n}\n","walsh-functions":"// ===== Patternflow pattern =====\n// Title:   Walsh Functions\n// Family:  wave\n// Idea:    The top half is the chart of all 64 two-dimensional Walsh functions on 8 by 8 LEDs, laid out in Walsh's sequency order, Paley's dyadic order or Sylvester's natural order, and the bottom half rebuilds a moving abstract picture from its Walsh-Hadamard coefficients, adding them one at a time in zigzag order over the chart, so the picture sharpens out of 8 by 8 blocks while the tile being added lights up above.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Walsh functions (Joseph L. Walsh, \"A closed set of normal orthogonal functions\", 1923), Sylvester's construction of Hadamard matrices (James Joseph Sylvester, 1867), Paley's dyadic ordering (Raymond Paley, 1932), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=0..2, Drop=0..63\n//\n// Knob 1: Hue. Turns both halves round the wheel: at 0 the chart is a checkerboard of blue and pink tiles and the picture runs from navy through teal to pale cyan.\n// Knob 2: Speed. How fast coefficients come: 6 a second at 2, so all 64 are in after 10.5 seconds; they leave three times faster and the count starts again. The picture drifts with it.\n// Knob 3: Order. How the 64 functions are laid out, and so the order they are added in: 0 sequency (Walsh, 1923), where the number of sign changes grows to the right and down; 1 dyadic (Paley, 1932); 2 natural, the rows of Sylvester's Hadamard matrix. Turning it slides every tile to its new place and starts the count again.\n// Knob 4: Drop. How many coefficients at the end of the zigzag are never added: 0 keeps all 64 and the picture comes back exactly; 48 keeps 16; 63 keeps only the mean of each 8 by 8 block. Dropped tiles go dark in the chart.\n\nconst S8 = 8;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The functions. Sylvester's matrix of order 8: row h, column x is\n// +1 or -1 by the parity of the bits h and x share. That is the natural\n// order. Paley's dyadic order takes row bitreverse(k), which multiplies\n// the Rademacher square waves named by the bits of k; Walsh's sequency\n// order takes row bitreverse(gray(k)), and its row k changes sign exactly\n// k times. setup() counts the sign changes and throws if any is wrong.\nconst bits = (v) => { let n = 0; for (; v; v &= v - 1) n++; return n; };\nconst HAD = (h, x) => (bits(h & x) & 1 ? -1 : 1);\nconst rev3 = (k) => ((k & 1) \u003c\u003c 2) | (k & 2) | ((k >> 2) & 1);\nconst gray = (k) => k ^ (k >> 1);\nconst ORDERS = [\n  Array.from({ length: S8 }, (_, k) => rev3(gray(k))), // sequency\n  Array.from({ length: S8 }, (_, k) => rev3(k)), // dyadic\n  Array.from({ length: S8 }, (_, k) => k), // natural\n];\nconst changes = (h) => { let n = 0; for (let x = 1; x \u003c S8; x++) if (HAD(h, x) !== HAD(h, x - 1)) n++; return n; };\n// Sequency of each natural row: 0 7 3 4 1 6 2 5.\nconst SEQ = Array.from({ length: S8 }, (_, h) => changes(h));\n\n// JPEG's zigzag over the 8 by 8 chart: [column, row] in the order added.\nconst ZIG = [];\nfor (let s = 0; s \u003c 2 * S8 - 1; s++)\n  for (let i = 0; i \u003c= s; i++) {\n    const a = s & 1 ? i : s - i, b = s - a;\n    if (a \u003c S8 && b \u003c S8) ZIG.push([b, a]);\n  }\n\n// In-place fast Walsh-Hadamard transform of an 8 by 8 block, rows then\n// columns, natural order, whole numbers only: three rounds of sums and\n// differences each way. Applied twice it gives the block back times 64.\nfunction fwht(B) {\n  for (let r = 0; r \u003c 64; r += 8)\n    for (let len = 1; len \u003c 8; len \u003c\u003c= 1)\n      for (let i = 0; i \u003c 8; i += len \u003c\u003c 1)\n        for (let j = i; j \u003c i + len; j++) {\n          const a = B[r + j], b = B[r + j + len];\n          B[r + j] = a + b;\n          B[r + j + len] = a - b;\n        }\n  for (let c = 0; c \u003c 8; c++)\n    for (let len = 1; len \u003c 8; len \u003c\u003c= 1)\n      for (let i = 0; i \u003c 8; i += len \u003c\u003c 1)\n        for (let j = i; j \u003c i + len; j++) {\n          const a = B[c + j * 8], b = B[c + (j + len) * 8];\n          B[c + j * 8] = a + b;\n          B[c + (j + len) * 8] = a - b;\n        }\n}\n\nexport function setup(params) {\n  // The check the knob names promise: sequency rows change sign 0..7\n  // times in order; a dyadic row's count is the Gray decoding of its index;\n  // the rows are orthogonal.\n  ORDERS[0].forEach((h, k) => { if (SEQ[h] !== k) throw new Error(\"sequency order is wrong at \" + k); });\n  ORDERS[1].forEach((h, k) => { let g = k; for (let m = k >> 1; m; m >>= 1) g ^= m; if (SEQ[h] !== g) throw new Error(\"dyadic order is wrong at \" + k); });\n  for (let a = 0; a \u003c S8; a++)\n    for (let b = 0; b \u003c S8; b++) {\n      let dot = 0;\n      for (let x = 0; x \u003c S8; x++) dot += HAD(a, x) * HAD(b, x);\n      if (dot !== (a === b ? S8 : 0)) throw new Error(\"rows \" + a + \" and \" + b + \" are not orthogonal\");\n    }\n  params.s = {\n    T: 1, dir: 1, wait: 0, clock: 0, order: 0, knob: -1, slide: 1,\n    from: null, img: new Int32Array(4096), rec: new Float64Array(4096), add: new Float64Array(4096), bump: 0,\n    blk: new Int32Array(64), R: new Float64Array(64), keepW: new Float64Array(64), hue: 0, keep: 64,\n  };\n}\n\n// Where each natural pair (hu, hv) sits on the chart in an order:\n// [column, row, zigzag index].\nfunction places(o) {\n  const inv = new Int8Array(S8);\n  ORDERS[o].forEach((h, k) => (inv[h] = k));\n  const at = new Int8Array(S8 * S8);\n  ZIG.forEach(([c, r], i) => (at[r * S8 + c] = i));\n  const P = [];\n  for (let hv = 0; hv \u003c S8; hv++)\n    for (let hu = 0; hu \u003c S8; hu++) {\n      const c = inv[hu], r = inv[hv];\n      P.push([c, r, at[r * S8 + c]]);\n    }\n  return P;\n}\nconst PLACES = [0, 1, 2].map(places);\n\n// The picture, whole numbers 0..255 on 64 by 64: a turning square and a\n// disc drifting past each other over a slowly turning ramp, brighter where\n// they overlap.\nfunction picture(S) {\n  const t = S.clock, img = S.img;\n  const sx = 30 + 10 * cos(t * 0.23), sy = 29 + 9 * sin(t * 0.31), a = t * 0.2, ca = cos(a), sa = sin(a);\n  const dx = 33 + 14 * cos(t * 0.37 + 2), dy = 35 + 13 * sin(t * 0.29 + 1);\n  const th = t * 0.13, ux = cos(th), uy = sin(th);\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c 64; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const lx = (px - sx) * ca + (py - sy) * sa, ly = (py - sy) * ca - (px - sx) * sa;\n      const sq = cl(0.5 - max(abs(lx), abs(ly)) + 12.5, 0, 1);\n      const dc = cl(11.5 - sqrt((px - dx) ** 2 + (py - dy) ** 2), 0, 1);\n      const v = 0.1 + 0.14 * (((px - 32) * ux + (py - 32) * uy) / 45) + 0.5 * sq + 0.4 * dc;\n      img[y * 64 + x] = round(cl(v, 0, 1) * 255);\n    }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3);\n  S.hue = k[0];\n  S.keep = 64 - cl(round(k[3]), 0, 63);\n  const o = cl(round(k[2]), 0, 2);\n  if (S.knob \u003c 0) (S.knob = S.order = o), (S.from = PLACES[o]);\n  else if (o !== S.order) {\n    // Slide from wherever the tiles are now, and count again from one.\n    S.from = current(S);\n    S.order = o;\n    S.slide = 0;\n    S.T = 1;\n    S.dir = 1;\n    S.wait = 0.4;\n  }\n  S.slide = min(1, S.slide + dt / 0.9);\n  S.clock += dt * sp * 0.5;\n  // The count: up at 3 x Speed a second to keep, a pause, down three times\n  // faster, a pause, again.\n  const rate = 3 * sp;\n  if (S.wait > 0) S.wait -= dt;\n  else if (S.dir > 0) {\n    S.T = min(S.keep, S.T + dt * rate);\n    if (S.T >= S.keep) (S.dir = -1), (S.wait = 1.4);\n  } else {\n    S.T = max(1, S.T - dt * rate * 3);\n    if (S.T \u003c= 1) (S.dir = 1), (S.wait = 0.6);\n  }\n  if (S.T > S.keep) S.T = S.keep;\n\n  // Transform every 8 by 8 block of the picture, then rebuild it from the\n  // first floor(T) coefficients in zigzag order and a share of the next.\n  picture(S);\n  const { img, rec, add, blk, keepW, R } = S;\n  const n = floor(S.T), part = S.T - n, P = PLACES[S.order];\n  let fN = -1;\n  P.forEach(([, , i], f) => {\n    keepW[f] = i \u003c n ? 1 : i === n && n \u003c S.keep ? part : 0;\n    if (i === n && n \u003c S.keep) fN = f;\n  });\n  S.bump = fN \u003c 0 ? 0 : sin(PI * part);\n  for (let by = 0; by \u003c 8; by++)\n    for (let bx = 0; bx \u003c 8; bx++) {\n      const o0 = by * 512 + bx * 8;\n      for (let y = 0; y \u003c 8; y++) for (let x = 0; x \u003c 8; x++) blk[y * 8 + x] = img[o0 + y * 64 + x];\n      fwht(blk);\n      // What the coefficient now fading in adds to this block: its own\n      // basis image, as large as the coefficient.\n      const c = fN \u003c 0 ? 0 : blk[fN] / 64;\n      for (let y = 0; y \u003c 8; y++) for (let x = 0; x \u003c 8; x++) add[o0 + y * 64 + x] = c * HAD(fN & 7, x) * HAD(fN >> 3, y);\n      // Inverse: the same transform on the kept coefficients, over 64. Kept\n      // whole, they stay whole numbers; only the one fading in is a share.\n      for (let f = 0; f \u003c 64; f++) R[f] = blk[f] * keepW[f];\n      fwht(R);\n      for (let y = 0; y \u003c 8; y++) for (let x = 0; x \u003c 8; x++) rec[o0 + y * 64 + x] = R[y * 8 + x] / 64;\n    }\n}\n\n// Where the tiles are drawn now: on the way from the old layout to the new.\nfunction current(S) {\n  const to = PLACES[S.order], e = smooth(S.slide);\n  return to.map(([c, r, i], f) => [S.from[f][0] + (c - S.from[f][0]) * e, S.from[f][1] + (r - S.from[f][1]) * e, i]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.from) return;\n  const pos = current(S);\n  const T = S.T, keep = S.keep;\n  // The chart. Tile f is the natural pair (hu, hv) = (f % 8, f / 8); its\n  // colour belongs to the function, by its two sequencies, so it travels\n  // with the tile: a checkerboard of two hues in sequency order.\n  for (let f = 0; f \u003c 64; f++) {\n    const hu = f & 7, hv = f >> 3, su = SEQ[hu], sv = SEQ[hv], i = PLACES[S.order][f][2];\n    const hueF = 0.59 + S.hue + 0.31 * ((su + sv) & 1) + (0.06 * (su + sv)) / 14;\n    let L, flash = 0;\n    if (i >= keep) L = 0.1;\n    else {\n      const inn = cl(T - i, 0, 1);\n      flash = T > i ? exp(-(T - i) * 0.8) : 0;\n      L = 0.34 + 0.5 * inn;\n    }\n    const [pr, pg, pb] = hsv(hueF, 0.75 - 0.6 * flash, min(1, L + 0.5 * flash));\n    const [nr, ng, nb] = hsv(hueF, 0.6, 0.04 + 0.06 * L + 0.25 * flash);\n    const ox = round(pos[f][0] * 8), oy = round(pos[f][1] * 8);\n    for (let y = 0; y \u003c 8; y++) {\n      const sy = HAD(hv, y);\n      for (let x = 0; x \u003c 8; x++) {\n        const plus = HAD(hu, x) * sy > 0;\n        display.setPixel(ox + x, oy + y, min(255, (plus ? pr : nr) * 255), min(255, (plus ? pg : ng) * 255), min(255, (plus ? pb : nb) * 255));\n      }\n    }\n  }\n  // The rebuilt picture below.\n  const rec = S.rec;\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c 64; x++) {\n      const v = cl(rec[y * 64 + x] / 255, 0, 1);\n      const [r, g, b] = hsv(0.6 + S.hue - 0.16 * v, 0.85 - 0.6 * v * v, 0.13 + 0.87 * v);\n      // A white stamp of the term coming in, where it changes the picture.\n      const w = S.bump * min(1, abs(S.add[y * 64 + x]) / 48) * 0.45;\n      display.setPixel(x, 64 + y, min(255, (r + w) * 255), min(255, (g + w) * 255), min(255, (b + w) * 255));\n    }\n}\n","barrier-grid":"// ===== Patternflow pattern =====\n// Title:   Barrier Grid\n// Family:  type\n// Idea:    A barrier of dark bars with one slit in every two to four columns slides one column at a time over a print that interleaves a word and its negative column by column, so each step turns the word from light to shadow and back, every fourth step brings the next word, the frames mix while the barrier glides, and a tilted barrier lays moire bands across the word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: barrier-grid animation as in the scanimation books of Rufus Butler Seder (Gallop!, 2007); moire of two superposed line gratings (Lord Rayleigh, 1874), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Frames=2..4, Tilt=0..1\n//\n// Knob 1: Hue. The light behind the slits: at 0 the word glows gold and its negative is the opposite blue, and turning it moves the pair round the wheel, always opposite each other the way a colour negative is.\n// Knob 2: Speed. How fast the barrier steps: at 2 a step every 1.6 seconds (held 0.96 s, gliding 0.64 s) and a new word every 6.4 seconds, at 0.2 a step every 16 seconds, at 3 one every 1.07.\n// Knob 3: Frames. How many frames the print interleaves, which is the period of the line screen and of the barrier: at 2 every other column is lit, at 3 every third, at 4 every fourth, with the bars wider in between.\n// Knob 4: Tilt. Turns the barrier against the print, so the slits drift sideways down the panel by up to three periods at 1 (tilt squared, so 0.06 is nearly level): moire bands cross the word, light in one band and shadow in the next, and roll down it while the barrier glides.\n\nconst W = 64, H = 128, N = W * H;\nconst Q = 3; // supersampling of the glyph masks\nconst { floor, round, min, max, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Words of light and of looking. A Hangul word is one syllable filling the\n// panel; a Latin word is four letters, two by two, 28 by 58 LEDs each.\nconst WORDS = [\"빛\", \"LOOK\", \"달\", \"NEON\", \"별\", \"HALO\", \"밤\", \"SEEN\"];\n\n// Shapes: [kind, add, ...]. kind 0 a rounded box x0 y0 x1 y1 tl tr br bl,\n// kind 1 a thick segment x0 y0 x1 y1 width.\nfunction glyph(ch, w, h, s, t) {\n  const P = [];\n  const rr = (x0, y0, x1, y1, tl = 0, tr = 0, br = 0, bl = 0, add = 1) => P.push([0, add, x0, y0, x1, y1, tl, tr, br, bl]);\n  const ln = (x0, y0, x1, y1, wd, add = 1) => P.push([1, add, x0, y0, x1, y1, wd]);\n  const R = 13, r = 5;\n  switch (ch) {\n    case \"O\":\n      rr(0, 0, w, h, R, R, R, R);\n      rr(s, t, w - s, h - t, r, r, r, r, 0);\n      break;\n    case \"L\":\n      rr(0, 0, s, h);\n      rr(0, h - t, w, h);\n      break;\n    case \"K\":\n      rr(0, 0, s, h);\n      ln(s - 1, h * 0.58, w - 5, 4, 10);\n      ln(s + 5, h * 0.42, w - 5, h - 4, 10);\n      rr(w - 9, 0, w, 6, 0, 0, 0, 0, 0);\n      break;\n    case \"N\":\n      rr(0, 0, s, h);\n      rr(w - s, 0, w, h);\n      ln(4, 4, w - 4, h - 4, 10);\n      break;\n    case \"E\":\n      rr(0, 0, s, h);\n      rr(0, 0, w, t);\n      rr(0, round(h / 2 - t / 2), w - 4, round(h / 2 + t / 2));\n      rr(0, h - t, w, h);\n      break;\n    case \"H\":\n      rr(0, 0, s, h);\n      rr(w - s, 0, w, h);\n      rr(0, round(h / 2 - t / 2), w, round(h / 2 + t / 2));\n      break;\n    case \"A\":\n      rr(0, 0, w, h, R, R, 0, 0);\n      rr(s, t, w - s, h + 1, r, r, 0, 0, 0);\n      rr(0, round(h * 0.55), w, round(h * 0.55) + t);\n      break;\n    case \"S\": {\n      // Two bowls sharing the middle bar, each open on one side.\n      const m = round(h / 2 - t / 2);\n      rr(0, 0, w, m + t, R, R, R, R);\n      rr(s, t, w - s, m, r, r, r, r, 0);\n      rr(w - s, t + 4, w + 1, m, 0, 0, 0, 0, 0);\n      rr(0, m, w, h, R, R, R, R);\n      rr(s, m + t, w - s, h - t, r, r, r, r, 0);\n      rr(-1, m + t, s, h - t - 4, 0, 0, 0, 0, 0);\n      break;\n    }\n    default:\n      hangul(ch, w, h, s, t, rr, ln);\n  }\n  return P;\n}\n\n// The four Hangul syllables, each one filling the panel: the initial top\n// left, the vowel's stem on the right, the final across the lower half. The\n// coordinates are the panel's, and the upright strokes stand on multiples of\n// 4 LEDs, so a stroke covers whole columns of the line screen.\nfunction hangul(ch, w, h, s, t, rr, ln) {\n  // ㅂ, ㄷ, ㄹ and ㅁ from bars.\n  const b = (x0, y0, x1, y1) => {\n    const m = round(y0 + (y1 - y0) * 0.45);\n    rr(x0, y0, x0 + s, y1);\n    rr(x1 - s, y0, x1, y1);\n    rr(x0, m, x1, m + t);\n    rr(x0, y1 - t, x1, y1);\n  };\n  const d = (x0, y0, x1, y1) => {\n    rr(x0, y0, x1, y0 + t);\n    rr(x0, y0, x0 + s, y1);\n    rr(x0, y1 - t, x1, y1);\n  };\n  const rieul = (x0, y0, x1, y1) => {\n    const m = round((y0 + y1) / 2 - t / 2);\n    rr(x0, y0, x1, y0 + t);\n    rr(x1 - s, y0, x1, m + t);\n    rr(x0, m, x1, m + t);\n    rr(x0, m, x0 + s, y1);\n    rr(x0, y1 - t, x1, y1);\n  };\n  const mieum = (x0, y0, x1, y1) => {\n    rr(x0, y0, x1, y1, 2, 2, 2, 2);\n    rr(x0 + s, y0 + t, x1 - s, y1 - t, 0, 0, 0, 0, 0);\n  };\n  // ㅏ: the stem with its arm to the right.\n  const a = () => {\n    rr(44, 4, 56, 68);\n    rr(56, 30, 64, 39);\n  };\n  if (ch === \"빛\") {\n    b(4, 8, 40, 64);\n    rr(48, 4, 60, 70);\n    rr(28, 74, 36, 82);\n    rr(4, 84, 60, 93);\n    ln(32, 95, 12, 124, 13);\n    ln(32, 95, 52, 124, 13);\n  } else if (ch === \"달\") {\n    d(4, 8, 36, 64);\n    a();\n    rieul(8, 76, 56, 124);\n  } else if (ch === \"별\") {\n    b(4, 8, 32, 64);\n    rr(48, 4, 60, 70);\n    rr(36, 20, 48, 29);\n    rr(36, 42, 48, 51);\n    rieul(8, 76, 56, 124);\n  } else if (ch === \"밤\") {\n    b(4, 8, 36, 64);\n    a();\n    mieum(8, 76, 56, 124);\n  }\n}\n\nfunction inside(p, x, y) {\n  if (p[0] === 0) {\n    if (x \u003c p[2] || x > p[4] || y \u003c p[3] || y > p[5]) return false;\n    const cx = (p[2] + p[4]) / 2, cy = (p[3] + p[5]) / 2;\n    const left = x \u003c cx, top = y \u003c cy;\n    const r = left ? (top ? p[6] : p[9]) : top ? p[7] : p[8];\n    if (r \u003c= 0) return true;\n    const dx = left ? p[2] + r - x : x - (p[4] - r);\n    const dy = top ? p[3] + r - y : y - (p[5] - r);\n    if (dx \u003c= 0 || dy \u003c= 0) return true;\n    return dx * dx + dy * dy \u003c= r * r;\n  }\n  const ex = p[4] - p[2], ey = p[5] - p[3];\n  const u = cl(((x - p[2]) * ex + (y - p[3]) * ey) / (ex * ex + ey * ey), 0, 1);\n  const dx = x - p[2] - u * ex, dy = y - p[3] - u * ey;\n  return dx * dx + dy * dy \u003c= (p[6] * p[6]) / 4;\n}\n\n// The shapes of a word placed on the panel, each with the rows and columns\n// of the supersampled mask it may touch.\nfunction layout(word) {\n  const chars = [...word];\n  const big = chars.length === 1;\n  const cells = big ? [[0, 0, 64, 128]] : [[2, 4, 28, 58], [34, 4, 28, 58], [2, 66, 28, 58], [34, 66, 28, 58]];\n  const out = [];\n  chars.forEach((ch, gi) => {\n    const [cx, cy, w, h] = cells[gi];\n    for (const p of glyph(ch, w, h, big ? 12 : 8, big ? 9 : 7)) {\n      let x0, y0, x1, y1;\n      if (p[0] === 0) (x0 = p[2]), (y0 = p[3]), (x1 = p[4]), (y1 = p[5]);\n      else {\n        const r = p[6] / 2;\n        (x0 = min(p[2], p[4]) - r), (x1 = max(p[2], p[4]) + r), (y0 = min(p[3], p[5]) - r), (y1 = max(p[3], p[5]) + r);\n      }\n      out.push({\n        p, cx, cy,\n        sx0: max(cx * Q, floor((cx + x0) * Q)), sx1: min((cx + w) * Q, ceil((cx + x1) * Q)),\n        sy0: max(cy * Q, floor((cy + y0) * Q)), sy1: min((cy + h) * Q, ceil((cy + y1) * Q)),\n      });\n    }\n  });\n  return out;\n}\n\n// A word's mask is built 8 rows at a time, a few frames ahead of the step\n// that needs it, so no frame pays for a whole word. Each shape inks (1) or\n// cuts (0) the samples inside it, in order, and the samples are averaged\n// back to coverage per LED.\nconst CHUNK = 8;\nfunction buildRows(B, rows) {\n  const r0 = B.row, r1 = min(H, r0 + rows);\n  const hi = B.hi, WQ = W * Q;\n  for (const sh of B.shapes) {\n    const sy0 = max(sh.sy0, r0 * Q), sy1 = min(sh.sy1, r1 * Q);\n    for (let sy = sy0; sy \u003c sy1; sy++)\n      for (let sx = sh.sx0; sx \u003c sh.sx1; sx++)\n        if (inside(sh.p, (sx + 0.5) / Q - sh.cx, (sy + 0.5) / Q - sh.cy)) hi[sy * WQ + sx] = sh.p[1];\n  }\n  for (let y = r0; y \u003c r1; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let n = 0;\n      for (let j = 0; j \u003c Q; j++) for (let i = 0; i \u003c Q; i++) n += hi[(y * Q + j) * WQ + x * Q + i];\n      B.m[y * W + x] = n / (Q * Q);\n    }\n  B.row = r1;\n}\n\nfunction job(S, wi) {\n  if (!S.jobs[wi]) S.jobs[wi] = { shapes: layout(WORDS[wi]), hi: new Uint8Array(W * Q * H * Q), m: new Float32Array(N), row: 0 };\n  return S.jobs[wi];\n}\n\n// The mask now: finished at once if the background builder has not got there.\nfunction mask(S, wi) {\n  const B = job(S, wi);\n  if (B.row \u003c H) buildRows(B, H);\n  return B.m;\n}\n\nexport function setup(params) {\n  params.s = { jobs: [], u: 0, hue: 0, n: 2, tilt: 0.06, col: new Float32Array(H * 6), bar: new Float32Array(6) };\n}\n\n// The stream of frames: each word four times, light, shadow, light, shadow.\nconst REPEAT = 4;\nconst wordOf = (f) => floor(f / REPEAT) % WORDS.length;\n\n// A step lasts STEP seconds at Speed 2, and the barrier glides for the last\n// GLIDE of it. The bars are pierced on a checkerboard: a hole catches G1 of\n// the light in the slits beside it and lets G2 of the print under the bar\n// show through. OVER brightens a half-open column, so in mid-glide both\n// frames shine at 0.8.\nconst STEP = 1.6, GLIDE = 0.4;\nconst G1 = 0.35, G2 = 0.2, OVER = 1.6;\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.hue = k[0];\n  S.n = cl(round(k[2]), 2, 4);\n  S.tilt = cl(k[3], 0, 1);\n  S.u += (dt * cl(k[1], 0.05, 3)) / 2 / STEP;\n  // Build ahead: the first unfinished word among those the print holds now\n  // and the next one it will need.\n  for (let f = floor(S.u); f \u003c= floor(S.u) + S.n + REPEAT; f++) {\n    const B = job(S, wordOf(f));\n    if (B.row \u003c H) {\n      buildRows(B, CHUNK);\n      break;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  const n = S.n;\n  const K = floor(S.u);\n  const e = S.u - K;\n  const g = e \u003c 1 - GLIDE ? 0 : (e - 1 + GLIDE) / GLIDE;\n  // The barrier's place in columns: on step K the slits stand over the\n  // columns of slot K mod n, and in the glide they ease one column right.\n  const b = K + g * g * (3 - 2 * g);\n  // Slot s of the print holds the frame f of K..K+n-1 with f = s mod n. A\n  // slot the barrier has just left is printed again with the frame n steps\n  // on, so the print always carries the frame on show and the next n-1.\n  const fw = [], fn = [];\n  for (let s = 0; s \u003c n; s++) {\n    const f = K + ((((s - K) % n) + n) % n);\n    fw.push(mask(S, wordOf(f)));\n    fn.push(f % 2);\n  }\n  // Light for the word (gold at Hue 0) and for its negative (the opposite\n  // blue), a little warmer down the panel.\n  const col = S.col;\n  for (let y = 0; y \u003c H; y++) {\n    hsv(0.11 + S.hue - 0.05 * (y / H), 0.62, 1, col, y * 6);\n    hsv(0.61 + S.hue - 0.05 * (y / H), 0.62, 1, col, y * 6 + 3);\n  }\n  // The bars' own faint indigo, and the pale light of the print under them.\n  const bar = S.bar;\n  hsv(0.7, 0.7, 0.1, bar, 0);\n  hsv(0.7, 0.3, 1, bar, 3);\n  const shift = S.tilt * S.tilt * 3 * n;\n  const o = [0, 0, 0, 0], V = [0, 0, 0, 0];\n  const g1 = (G1 * 2) / n, g2 = (G2 * 2) / n;\n  for (let y = 0; y \u003c H; y++) {\n    // How open each slot's columns are in this row: a slit one column wide,\n    // box-filtered over the LED, so the openings of the n slots add to 1.\n    const by = b + shift * (y / (H - 1) - 0.5);\n    for (let k = 0; k \u003c n; k++) {\n      let d = (k - by) % n;\n      if (d \u003c 0) d += n;\n      o[k] = max(0, 1 - min(d, n - d));\n    }\n    const c0 = y * 6;\n    for (let x = 0; x \u003c W; x++) {\n      const s = x % n, p = y * W + x;\n      // Every slot's print at this LED, and the light the slits pass, which\n      // is what a hole in a bar here would catch.\n      let vr = 0, vg = 0, vb = 0;\n      for (let k = 0; k \u003c n; k++) {\n        const v = fn[k] ? 1 - fw[k][p] : fw[k][p];\n        V[k] = v;\n        const c = c0 + fn[k] * 3, w = o[k] * v;\n        vr += col[c] * w;\n        vg += col[c + 1] * w;\n        vb += col[c + 2] * w;\n      }\n      const os = o[s], lit = V[s] * min(1, OVER * os), c = c0 + fn[s] * 3, shut = 1 - os;\n      let r = col[c] * lit + bar[0] * shut, gg = col[c + 1] * lit + bar[1] * shut, bb = col[c + 2] * lit + bar[2] * shut;\n      if ((x + y) & 1) {\n        const h1 = shut * g1, h2 = shut * g2 * V[s];\n        r += h1 * vr + h2 * bar[3];\n        gg += h1 * vg + h2 * bar[4];\n        bb += h1 * vb + h2 * bar[5];\n      }\n      display.setPixel(x, y, min(255, r * 255) | 0, min(255, gg * 255) | 0, min(255, bb * 255) | 0);\n    }\n  }\n}\n","etaoin-shrdlu":"// ===== Patternflow pattern =====\n// Title:   Etaoin Shrdlu\n// Family:  data\n// Idea:    A passage set in a 3 by 5 face comes loose one letter at a time from its last line, and each letter falls into one of sixteen columns kept sorted by how often the letter has come, so the columns trade places as one overtakes another and the labels under them end up spelling the passage's own etaoin shrdlu above the order the Linotype keyboard was built on.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: pattern round 66, after the Linotype (Ottmar Mergenthaler, 1886), whose lowercase keys ran etaoin shrdlu cmfwyp vbgkqj by letter frequency, and the line ETAOIN SHRDLU that operators left in newspapers; counting Lewis Carroll's Alice's Adventures in Wonderland (1865), Lorem ipsum from Cicero's De finibus bonorum et malorum (45 BC), ten pangrams, and the cryptogram Legrand breaks by counting in Edgar Allan Poe's The Gold-Bug (1843); the 3 by 5 face from the Typewriter pattern (round 18), with figures and Poe's symbols added\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Forget=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. Each letter keeps one colour, set by its place in the Linotype's order: at 0 E is cyan, the rest of ETAOIN blue, SHRDLU indigo to magenta and the rare letters red, orange and gold, so a passage close to that order reads as one rainbow across the columns and Lorem ipsum as a broken one.\n// Knob 2: Speed. Letters coming loose a second: 8 at 2, so Alice's 464 letters take 58 s; 0.8 at 0.2 and 12 at 3. They also fall a little harder as it turns up.\n// Knob 3: Text. Each ends on its own order: 0 Alice, ETIONS AHRDWG, six of the twelve in the Linotype's places; 1 Lorem ipsum, IETAOU NLRDSM, two; 2 ten pangrams, every letter 10 times or more and 17 of them exactly 10, none; 3 Poe's cryptogram, 8;4)‡* 56(†10, which is ETHSON AIRDFL, five.\n// Knob 4: Forget. How far back the columns count: the last 520 letters at 0.06, which is all of every passage here, 113 at 0.5 and only the last 20 at 1, where each letter is a sort 15 rows tall with its face on it and the order changes at 80 of 100 landings against 18 at 0.06.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp, sqrt, sin, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Layout, rows y down. Seven lines of type at the top (6 rows each), the\n// reading line last; sixteen columns 4 LEDs apart standing on row 113 and at\n// most 62 rows tall; the passage's labels on rows 116-120 and the\n// Linotype's order on rows 122-126.\nconst LINES = 7;\nconst READ_Y = 37;\nconst BASE = 113;\nconst MAXH = 62;\nconst LABEL_Y = 116;\nconst REF_Y = 122;\nconst SLOTS = 16;\n// Under floor(S) letters in the tallest column the scale stops growing, so\n// early in a passage each letter is a sort 62 / 9 = 6.9 rows tall with its\n// face on it. Counting only the last 20, the floor drops to 4 and a sort is\n// 15.5 rows.\nconst floorUnits = (S) => cl(S.keep / 5, 4, 9);\nconst HOLD = 6;\nconst DRAIN = 1.2;\n\n// The Linotype's lowercase keys, column by column.\nconst LINO = \"ETAOINSHRDLUCMFWYPVBGKQJXZ\";\n\n// The 3 by 5 face, rows top to bottom, one bit per column. The letters and\n// most punctuation are Typewriter's; the figures and Poe's dagger, double\n// dagger, pilcrow, asterisk and brackets are new.\nconst GLYPHS = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\", \".\": \"000000000000010\", \",\": \"000000000010100\",\n  \"-\": \"000000111000000\", \"!\": \"010010010000010\", \"?\": \"110001010000010\", \"'\": \"010010000000000\",\n  \":\": \"000010000010000\", \";\": \"000010000010100\",\n  \"0\": \"111101101101111\", \"1\": \"010110010010111\", \"2\": \"111001111100111\", \"3\": \"111001011001111\",\n  \"4\": \"101101111001001\", \"5\": \"111100111001111\", \"6\": \"111100111101111\", \"8\": \"111101111101111\",\n  \"9\": \"111101111001111\", \"†\": \"010111010010010\", \"‡\": \"010111010111010\", \"¶\": \"011111011011011\",\n  \"*\": \"101010111010101\", \"(\": \"001010010010001\", \")\": \"100010010010100\",\n};\nconst BITS = {};\nfor (const ch in GLYPHS) BITS[ch] = GLYPHS[ch].split(\"\").map(Number);\n\n// Poe's key, letter to symbol, as Legrand reads it out: 8 is e, ; is t, and\n// so on. The cryptogram is the plaintext below put through it, so the counts\n// are the plaintext's: 8 33, ; 26, 4 19, the start of Legrand's own table.\nconst KEY = { A: \"5\", B: \"2\", C: \"-\", D: \"†\", E: \"8\", F: \"1\", G: \"3\", H: \"4\", I: \"6\", L: \"0\", M: \"9\", N: \"*\", O: \"‡\", P: \".\", R: \"(\", S: \")\", T: \";\", U: \"?\", V: \"¶\", Y: \":\" };\nconst PLAIN =\n  \"A GOOD GLASS IN THE BISHOP'S HOSTEL IN THE DEVIL'S SEAT FORTY-ONE DEGREES AND THIRTEEN MINUTES NORTHEAST AND BY NORTH MAIN BRANCH SEVENTH LIMB EAST SIDE SHOOT FROM THE LEFT EYE OF THE DEATH'S-HEAD A BEE LINE FROM THE TREE THROUGH THE SHOT FIFTY FEET OUT\";\n\nconst TEXTS = [\n  // Alice's Adventures in Wonderland (1865), the first two sentences.\n  \"ALICE WAS BEGINNING TO GET VERY TIRED OF SITTING BY HER SISTER ON THE BANK, AND OF HAVING NOTHING TO DO: ONCE OR TWICE SHE HAD PEEPED INTO THE BOOK HER SISTER WAS READING, BUT IT HAD NO PICTURES OR CONVERSATIONS IN IT, 'AND WHAT IS THE USE OF A BOOK,' THOUGHT ALICE 'WITHOUT PICTURES OR CONVERSATIONS?' SO SHE WAS CONSIDERING IN HER OWN MIND (AS WELL AS SHE COULD, FOR THE HOT DAY MADE HER FEEL VERY SLEEPY AND STUPID), WHETHER THE PLEASURE OF MAKING A DAISY-CHAIN WOULD BE WORTH THE TROUBLE OF GETTING UP AND PICKING THE DAISIES, WHEN SUDDENLY A WHITE RABBIT WITH PINK EYES RAN CLOSE BY HER.\",\n  \"LOREM IPSUM DOLOR SIT AMET, CONSECTETUR ADIPISCING ELIT, SED DO EIUSMOD TEMPOR INCIDIDUNT UT LABORE ET DOLORE MAGNA ALIQUA. UT ENIM AD MINIM VENIAM, QUIS NOSTRUD EXERCITATION ULLAMCO LABORIS NISI UT ALIQUIP EX EA COMMODO CONSEQUAT. DUIS AUTE IRURE DOLOR IN REPREHENDERIT IN VOLUPTATE VELIT ESSE CILLUM DOLORE EU FUGIAT NULLA PARIATUR. EXCEPTEUR SINT OCCAECAT CUPIDATAT NON PROIDENT, SUNT IN CULPA QUI OFFICIA DESERUNT MOLLIT ANIM ID EST LABORUM.\",\n  \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS. SPHINX OF BLACK QUARTZ, JUDGE MY VOW. JACKDAWS LOVE MY BIG SPHINX OF QUARTZ. HOW VEXINGLY QUICK DAFT ZEBRAS JUMP! THE FIVE BOXING WIZARDS JUMP QUICKLY. WALTZ, BAD NYMPH, FOR QUICK JIGS VEX. GLIB JOCKS QUIZ NYMPH TO VEX DWARF. QUICK ZEPHYRS BLOW, VEXING DAFT JIM. TWO DRIVEN JOCKS HELP FAX MY BIG QUIZ.\",\n  null,\n];\n\n// A passage as lines of at most 16 characters and the list of letters to\n// count, each with its line, column, token (what it looks like) and key (the\n// letter it stands for, which sets its colour).\nfunction prepare(t) {\n  const lines = [];\n  if (t === 3) {\n    // Poe printed the cryptogram run together, so it breaks every 16.\n    let s = \"\";\n    for (const ch of PLAIN) if (KEY[ch]) s += KEY[ch];\n    for (let i = 0; i \u003c s.length; i += 16) lines.push(s.slice(i, i + 16));\n  } else {\n    let line = \"\";\n    for (const word of TEXTS[t].split(\" \")) {\n      if (line && line.length + 1 + word.length > 16) {\n        lines.push(line);\n        line = word;\n      } else line = line ? line + \" \" + word : word;\n    }\n    lines.push(line);\n  }\n  const back = {};\n  for (const k in KEY) back[KEY[k]] = k;\n  const letters = [];\n  lines.forEach((s, li) => {\n    for (let c = 0; c \u003c s.length; c++) {\n      const ch = s[c];\n      if (t === 3 ? back[ch] : ch >= \"A\" && ch \u003c= \"Z\") letters.push({ tok: ch, key: t === 3 ? back[ch] : ch, line: li, col: c });\n    }\n  });\n  return { lines, letters, cipher: t === 3 };\n}\n\nfunction hsv(h, s, v) {\n  h = (((h % 1) + 1) % 1) * 6;\n  const i = floor(h), f = h - i;\n  const p = v * (1 - s), q = v * (1 - s * f), u = v * (1 - s * (1 - f));\n  const c = [[v, u, p], [q, v, p], [p, v, u], [p, q, v], [u, p, v], [v, p, q]][i % 6];\n  return [c[0] * 255, c[1] * 255, c[2] * 255];\n}\n\n// A letter's colour: its key's place in the Linotype's order round the wheel.\nconst colourOf = (S, tok) => hsv(0.5 + S.hue + LINO.indexOf(S.keyOf[tok] || tok) * 0.031, 0.78, 1);\n\nexport function setup(params) {\n  params.s = { started: false };\n}\n\n// Start a passage: no counts, no columns, its first line onto the galley.\nfunction begin(S, t) {\n  S.textIdx = t;\n  S.text = prepare(t);\n  S.read = 0;\n  S.line = -1;\n  S.cnt = {};\n  S.keyOf = {};\n  for (const L of S.text.letters) S.keyOf[L.tok] = L.key;\n  S.cols = [];\n  S.cx = {};\n  S.flash = {};\n  S.queue = [];\n  S.head = 0;\n  S.fall = [];\n  S.acc = 0;\n  S.phase = 0;\n  S.pt = 0;\n  S.drain = 1;\n  feed(S, 0, false);\n}\n\n// Put passage lines up to li onto the galley; it scrolls up a line for each.\nfunction feed(S, li, still) {\n  while (S.line \u003c li) {\n    S.line++;\n    S.galley.push({ s: S.text.lines[S.line], slug: null, li: S.line });\n    if (!still) S.scroll += 6;\n  }\n  if (S.galley.length > 12) S.galley.splice(0, S.galley.length - 12);\n}\n\nconst slotX = (i) => i * 4;\n\nfunction bubbleLeft(S, i) {\n  const c = S.cols, n = S.cnt;\n  while (i > 0 && n[c[i]] > n[c[i - 1]]) {\n    const a = c[i];\n    c[i] = c[i - 1];\n    c[i - 1] = a;\n    i--;\n  }\n}\n\n// The letter not in a column with the highest count, if it beats the last column.\nfunction promote(S) {\n  const c = S.cols;\n  let best = null;\n  for (const k in S.cnt) if (S.cnt[k] > 0 && !c.includes(k) && (best === null || S.cnt[k] > S.cnt[best])) best = k;\n  if (best === null) return;\n  if (c.length \u003c SLOTS) {\n    c.push(best);\n    if (S.cx[best] === undefined) S.cx[best] = slotX(c.length - 1);\n    bubbleLeft(S, c.length - 1);\n  } else if (S.cnt[best] > S.cnt[c[SLOTS - 1]]) {\n    S.cx[best] = S.cx[c[SLOTS - 1]];\n    c[SLOTS - 1] = best;\n    bubbleLeft(S, SLOTS - 1);\n  }\n}\n\n// A letter has landed: count it, forget the oldest past the keep, re-sort.\nfunction land(S, tok) {\n  S.cnt[tok] = (S.cnt[tok] || 0) + 1;\n  S.queue.push(tok);\n  const i = S.cols.indexOf(tok);\n  if (i >= 0) {\n    bubbleLeft(S, i);\n    S.flash[tok] = 1;\n  } else promote(S);\n  trim(S);\n}\n\nfunction trim(S) {\n  while (S.queue.length - S.head > S.keep) {\n    const old = S.queue[S.head++];\n    S.cnt[old]--;\n    const c = S.cols;\n    let i = c.indexOf(old);\n    if (i >= 0) {\n      if (S.cnt[old] \u003c= 0) c.splice(i, 1);\n      else\n        while (i \u003c c.length - 1 && S.cnt[c[i]] \u003c S.cnt[c[i + 1]]) {\n          c[i] = c[i + 1];\n          c[i + 1] = old;\n          i++;\n        }\n    }\n    promote(S);\n  }\n  if (S.head > 2000) {\n    S.queue = S.queue.slice(S.head);\n    S.head = 0;\n  }\n}\n\nconst tallest = (S) => {\n  let m = 0;\n  for (const k of S.cols) m = max(m, S.cnt[k]);\n  return m;\n};\n\n// One step of the machine.\nfunction step(S, dt) {\n  const L = S.text.letters;\n  S.scroll = max(0, S.scroll - max(S.scroll * (1 - exp(-dt * 7)), dt * 6));\n  if (S.phase === 0) {\n    S.acc += dt * S.rate;\n    while (S.acc >= 1 && S.read \u003c L.length) {\n      S.acc -= 1;\n      const l = L[S.read++];\n      // The slot in the reading line before the scroll moves it.\n      const y0 = READ_Y + S.scroll - 6 * (S.line - l.line);\n      // While there are free columns a new letter takes one as it leaves.\n      if (S.cols.length \u003c SLOTS && !S.cols.includes(l.tok)) {\n        S.cnt[l.tok] = S.cnt[l.tok] || 0;\n        S.cols.push(l.tok);\n        if (S.cx[l.tok] === undefined) S.cx[l.tok] = slotX(S.cols.length - 1);\n      }\n      S.fall.push({ tok: l.tok, x: l.col * 4, x0: l.col * 4, y: y0, y0, t: 0, T: 0 });\n      if (S.read \u003c L.length) feed(S, L[S.read].line, false);\n    }\n    if (S.read >= L.length) S.acc = 0;\n  }\n  for (const f of S.fall) {\n    f.t += dt;\n    if (!f.T) {\n      const i = S.cols.indexOf(f.tok);\n      const top = i >= 0 ? BASE - S.cnt[f.tok] * S.scale - 4 : BASE - 4;\n      const d = max(1, top - f.y0);\n      f.T = (S.vy + sqrt(S.vy * S.vy + 2 * S.g * d)) / S.g;\n    }\n    f.y = f.y0 - S.vy * f.t + 0.5 * S.g * f.t * f.t;\n    const i = S.cols.indexOf(f.tok);\n    f.pi = i \u003c 0;\n    if (!f.pi) {\n      const u = sm(0, 1, f.t / f.T);\n      f.x = f.x0 + (S.cx[f.tok] - f.x0) * u;\n      if (f.y >= BASE - S.cnt[f.tok] * S.scale - 4) f.done = true;\n    } else {\n      f.x0 = f.x;\n      if (f.y >= BASE - 4) f.done = true;\n    }\n  }\n  if (S.fall.some((f) => f.done)) {\n    for (const f of S.fall) if (f.done) land(S, f.tok);\n    S.fall = S.fall.filter((f) => !f.done);\n  }\n  // Columns slide to their slots; the scale follows the tallest.\n  S.cols.forEach((k, i) => {\n    S.cx[k] += (slotX(i) - S.cx[k]) * (1 - exp(-dt * 9));\n  });\n  for (const k in S.flash) S.flash[k] = max(0, S.flash[k] - dt * 3);\n  const target = MAXH / max(floorUnits(S), tallest(S));\n  S.scale += (target - S.scale) * (1 - exp(-dt * 5));\n\n  if (S.phase === 0 && S.read >= L.length && S.fall.length === 0) {\n    // The passage is spent: cast its own order as a line.\n    S.phase = 1;\n    S.pt = 0;\n    const c = S.cols;\n    const s = c.slice(0, 6).join(\"\") + \" \" + c.slice(6, 12).join(\"\");\n    S.galley.push({ s, slug: s.split(\"\").map((ch) => (ch === \" \" ? null : colourOf(S, ch))), li: -1 });\n    S.scroll += 6;\n  } else if (S.phase === 1) {\n    S.pt += dt;\n    if (S.pt > HOLD) {\n      S.phase = 2;\n      S.pt = 0;\n    }\n  } else if (S.phase === 2) {\n    S.pt += dt;\n    S.drain = 1 - sm(0, DRAIN, S.pt);\n    if (S.pt > DRAIN) begin(S, S.next);\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] === undefined ? 2 : k[1], 0.2, 3);\n  S.rate = 4 * speed;\n  S.g = 150 * (0.6 + 0.2 * speed);\n  S.vy = 18;\n  const tx = cl(round(k[2] || 0), 0, 3);\n  S.keep = round(20 * 32 ** (1 - cl(k[3] === undefined ? 0.06 : k[3], 0, 1)));\n  S.next = tx;\n  if (!S.started) {\n    S.started = true;\n    S.galley = [];\n    S.scroll = 0;\n    S.scale = MAXH / floorUnits(S);\n    begin(S, tx);\n    // Read 28% of the passage (50 to 130 letters) before the first frame,\n    // then run a second and a half so letters are in the air.\n    const L = S.text.letters;\n    const pre = cl(round(0.28 * L.length), 50, 130);\n    for (let i = 0; i \u003c pre; i++) {\n      const l = L[S.read++];\n      if (S.read \u003c L.length) feed(S, L[S.read].line, true);\n      land(S, l.tok);\n    }\n    S.scroll = 0;\n    S.cols.forEach((c, i) => (S.cx[c] = slotX(i)));\n    S.scale = MAXH / max(floorUnits(S), tallest(S));\n    for (const c in S.flash) S.flash[c] = 0;\n    for (let i = 0; i \u003c 45; i++) step(S, 1 / 30);\n  }\n  if (tx !== S.textIdx && S.phase !== 2) {\n    // A new text: the columns drain and the new passage starts from its top.\n    S.phase = 2;\n    S.pt = 0;\n    S.fall = [];\n  }\n  trim(S);\n  step(S, dt);\n}\n\nfunction glyph(display, ch, x0, y0, r, g, b, a) {\n  const bits = BITS[ch];\n  if (!bits || a \u003c= 0.02) return;\n  const R = round(min(255, r * a)), G = round(min(255, g * a)), B = round(min(255, b * a));\n  for (let j = 0; j \u003c 15; j++) {\n    if (!bits[j]) continue;\n    const x = x0 + (j % 3), y = y0 + floor(j / 3);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, R, G, B);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.started) return;\n  const colour = {};\n  const col = (tok) => colour[tok] || (colour[tok] = colourOf(S, tok));\n  const pulse = S.phase === 1 ? 0.8 + 0.2 * sin(S.pt * 5) : 1;\n\n  // Letters with no column fall behind the columns and go out at the floor.\n  for (const f of S.fall) if (f.pi) glyph(display, f.tok, round(f.x), round(f.y), 150, 150, 160, 0.75);\n\n  // The columns: a solid bar with a seam at each letter, or, when a letter\n  // has room, a stack of sorts each showing its letter in the middle.\n  const s = S.scale;\n  const sorts = sm(5, 6.5, s);\n  const face = floor(max(0, s - 6) / 2);\n  for (const tok of S.cols) {\n    const c = col(tok);\n    const x0 = round(S.cx[tok]);\n    const n = S.cnt[tok];\n    const h = n * s * S.drain;\n    const bits = BITS[tok];\n    const fl = S.flash[tok] || 0;\n    for (let r = 0; r \u003c h && r \u003c MAXH + 2; r++) {\n      const y = BASE - r;\n      const cover = min(1, h - r);\n      const unit = floor(r / s), o = r - unit * s;\n      const top = unit >= n - 1;\n      for (let dx = 0; dx \u003c 3; dx++) {\n        const seam = s >= 2.5 && o > s - 1;\n        const solid = seam ? 0.42 : 0.9;\n        const gr = 4 - floor(o - face);\n        const stamp = seam ? 0 : gr >= 0 && gr \u003c 5 ? (bits[gr * 3 + dx] ? 1 : 0.28) : 0.28;\n        const v = (solid + (stamp - solid) * sorts) * cover;\n        if (v \u003c= 0.02) continue;\n        const w = top ? fl * 0.8 : 0;\n        const R = c[0] * v * (1 - w) + 255 * w * cover, G = c[1] * v * (1 - w) + 255 * w * cover, B = c[2] * v * (1 - w) + 255 * w * cover;\n        const x = x0 + dx;\n        if (x >= 0 && x \u003c W) display.setPixel(x, y, round(min(255, R)), round(min(255, G)), round(min(255, B)));\n      }\n    }\n  }\n\n  // Labels under the columns, and under them the Linotype's order. Where a\n  // column's letter stands where the Linotype put it, both light. At the end\n  // of Poe's cryptogram the bottom row turns into the key.\n  const keyRow = S.text.cipher && S.phase > 0;\n  S.cols.forEach((tok) => {\n    const c = col(tok);\n    const x = round(S.cx[tok]);\n    glyph(display, tok, x, LABEL_Y, c[0], c[1], c[2], pulse * S.drain);\n  });\n  for (let i = 0; i \u003c SLOTS; i++) {\n    const tok = S.cols[i];\n    const settled = tok !== undefined && abs(S.cx[tok] - slotX(i)) \u003c 0.6;\n    const match = settled && S.keyOf[tok] === LINO[i];\n    if (keyRow) {\n      if (tok === undefined) continue;\n      const c = col(tok);\n      glyph(display, S.keyOf[tok], round(S.cx[tok]), REF_Y, c[0], c[1], c[2], (match ? 1 : 0.55) * S.drain);\n    } else if (match) {\n      const c = col(tok);\n      glyph(display, LINO[i], slotX(i), REF_Y, 0.5 * c[0] + 128, 0.5 * c[1] + 128, 0.5 * c[2] + 128, S.drain);\n    } else glyph(display, LINO[i], slotX(i), REF_Y, 84, 80, 92, 1);\n  }\n\n  // The galley: what has been read is dim, the rest of the reading line is\n  // lit and the next letter to come loose shows its colour. A cast order\n  // line keeps its colours.\n  const G = S.galley;\n  const L = S.text.letters;\n  const next = S.phase === 0 && S.read \u003c L.length ? L[S.read] : null;\n  for (let j = 0; j \u003c G.length && j \u003c LINES + 1; j++) {\n    const ln = G[G.length - 1 - j];\n    const y = READ_Y - 6 * j + round(S.scroll);\n    if (y \u003c -5 || y > READ_Y + 6) continue;\n    const live = ln.li >= 0 && ln.li === S.line && j === 0 && S.phase === 0;\n    for (let c = 0; c \u003c ln.s.length; c++) {\n      const ch = ln.s[c];\n      if (ch === \" \") continue;\n      if (ln.slug) {\n        const cc = ln.slug[c];\n        const a = j === 0 ? pulse : 0.45;\n        glyph(display, ch, c * 4, y, cc[0], cc[1], cc[2], a);\n      } else if (live && next && c === next.col) {\n        const cc = col(ch);\n        glyph(display, ch, c * 4, y, 0.4 * cc[0] + 150, 0.4 * cc[1] + 150, 0.4 * cc[2] + 150, 1);\n      } else if (live && next && c > next.col) glyph(display, ch, c * 4, y, 236, 224, 202, 1);\n      else glyph(display, ch, c * 4, y, 236, 224, 202, 0.33);\n    }\n  }\n\n  // Letters in the air, white as they leave the line and their colour as they fall.\n  for (const f of S.fall) {\n    if (f.pi) continue;\n    const c = col(f.tok);\n    const w = max(0, 1 - f.t / 0.35);\n    glyph(display, f.tok, round(f.x), round(f.y), c[0] + (255 - c[0]) * w, c[1] + (255 - c[1]) * w, c[2] + (255 - c[2]) * w, 1);\n  }\n}\n","golomb-ruler":"// ===== Patternflow pattern =====\n// Title:   Golomb Ruler\n// Family:  number\n// Idea:    A ruler runs down the panel with a mark on some of its 128 rows, every pair of marks is joined by an arc as tall as the distance it measures, and a caliper sweeps the lengths 1 to 127, lighting the arcs of each length and ticking a length scale on the right edge, so the optimal 14-mark Golomb ruler lights one arc or none at each length and Wichmann's ruler lights at least one, with the sevens piling up.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sidon sets (Simon Sidon, 1932) and Golomb rulers (W. C. Babcock's radio channels, 1953; named for Solomon W. Golomb), sparse rulers (Brian Wichmann, 1963), the greedy Sidon sequence (Abdul Majid Mian and Sarvadaman Chowla, 1944), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ruler=0..3, Shape=-1..1\n//\n// Knob 1: Hue. Turns the length colours round the wheel: at 0 the short arcs are sea green and the long ones run through blue and violet to rose; at 0.5 they run from rose through yellow to green.\n// Knob 2: Speed. How fast the caliper measures: 16 lengths a second at 2, so a sweep of 1 to 127 takes 8 s, then the whole picture holds 1.5 s and fades back to its ghost in 1 s. At 0.2 a sweep takes 80 s, at 3 it takes 5.3 s.\n// Knob 3: Ruler. Which marks: 0 the optimal Golomb ruler, 14 marks on 0..127 whose 91 arcs measure every length from 1 to 55 once and 36 longer ones never; 1 Mian and Chowla's greedy Sidon set, 12 marks on 0..122 whose 66 arcs already miss 22; 2 fourteen random marks with both ends, drawn anew each sweep, which on average measure 66 lengths and repeat 20 of them; 3 Wichmann's ruler W(1,16), 23 marks whose 253 arcs measure every length, 7 sixteen times, 14 fifteen times and so on down the multiples of 7.\n// Knob 4: Shape. The outline of every arc, a half superellipse: straight chevrons at -1, where the arcs from one mark run along one ray and the picture turns into a lattice of crossing rays; half ellipses near the opening 0.06; square brackets like the dimension lines of a drawing at 1.\n\nconst W = 64, H = 128, L = 127;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, exp, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The optimal Golomb ruler with 14 marks: its 91 differences are all\n// different and 127 is the shortest length that holds 14 such marks.\nconst GOLOMB = [0, 4, 6, 20, 35, 52, 59, 77, 78, 86, 89, 99, 122, 127];\n\n// Mian and Chowla's greedy Sidon sequence 1, 2, 4, 8, 13, ...: each term the\n// least number that keeps all pairwise sums (so all differences) distinct.\n// Shifted to start at 0, twelve terms fit, up to 122.\nfunction mianChowla() {\n  const T = [1], sums = new Set([2]);\n  for (let k = 2; k - 1 \u003c= L; k++) {\n    let ok = !sums.has(2 * k);\n    for (const a of T) if (sums.has(k + a)) ok = false;\n    if (!ok) continue;\n    for (const a of T) sums.add(k + a);\n    sums.add(2 * k);\n    T.push(k);\n  }\n  return T.map((a) => a - 1);\n}\n\n// Wichmann's ruler W(r, s): steps 1 (r times), r+1, 2r+1 (r times),\n// 4r+3 (s times), 2r+2 (r+1 times), 1 (r times). Length\n// 4r(r+s+2)+3(s+1) with 4r+s+3 marks; W(1,16) is 127 long with 23.\nfunction wichmann(r, s) {\n  const steps = [];\n  const put = (v, n) => { for (let i = 0; i \u003c n; i++) steps.push(v); };\n  put(1, r), put(r + 1, 1), put(2 * r + 1, r), put(4 * r + 3, s), put(2 * r + 2, r + 1), put(1, r);\n  const m = [0];\n  for (const v of steps) m.push(m[m.length - 1] + v);\n  return m;\n}\n\n// Fourteen random marks on 0..127, the ends always among them.\nfunction randomRuler() {\n  const set = new Set([0, L]);\n  while (set.size \u003c 14) set.add(1 + floor(Math.random() * (L - 1)));\n  return [...set].sort((a, b) => a - b);\n}\n\nconst RULERS = [() => GOLOMB, mianChowla, randomRuler, () => wichmann(1, 16)];\n\n// Geometry. The spine stands at x = X0; an arc for the marks a \u003c b leaves\n// the spine at rows a and b and bulges right to X0 + A, A in proportion to\n// b - a, so the 127-row arc reaches column X0 + AMAX. The length scale is\n// the right edge: row d is the length d.\nconst X0 = 1.5, AMAX = 52.5, SX = 63;\n\n// Superellipse exponent from the Shape knob: 1 chevron, 2 ellipse, 8 bracket.\nconst expo = (k) => (k \u003c 0 ? pow(2, 1 + k) : pow(2, 1 + 2 * k));\n\n// One arc's light as a list of pixels and weights: the half superellipse\n// sampled along its angle, each piece of the polyline cut into steps of at\n// most 0.4 LED and splatted bilinearly with its length as weight. Each arc\n// owns a slot of cap entries in the shared arrays.\nconst TMP = new Float32Array(W * H), TOUCH = new Int32Array(W * H);\nconst cap = (d) => 104 + 12 * d;\nfunction arcPixels(S, i, p) {\n  const [a, b, d] = S.pairs[i], A = (AMAX * d) / L, B = d / 2, c = (a + b) / 2, e = 2 / p;\n  const n = 24 + 2 * ceil(A + B), at = S.off[i], room = cap(d), I = S.I, Wt = S.Wt;\n  let nt = 0, px = X0, py = a;\n  const splat = (x, y, w) => {\n    const i = floor(x), j = floor(y), fx = x - i, fy = y - j;\n    for (let q = 0; q \u003c 4; q++) {\n      const ii = i + (q & 1), jj = j + (q >> 1);\n      if (ii \u003c 0 || ii >= W || jj \u003c 0 || jj >= H) continue;\n      const ww = w * (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy);\n      if (ww \u003c= 0) continue;\n      const k = jj * W + ii;\n      if (TMP[k] === 0) {\n        if (nt >= room) continue;\n        TOUCH[nt++] = k;\n      }\n      TMP[k] += ww;\n    }\n  };\n  for (let s = 1; s \u003c= n; s++) {\n    const th = -PI / 2 + (PI * s) / n, cs = max(0, cos(th)), sn = sin(th);\n    const x = X0 + A * pow(cs, e), y = c + B * (sn \u003c 0 ? -pow(-sn, e) : pow(sn, e));\n    const len = sqrt((x - px) * (x - px) + (y - py) * (y - py)), k = max(1, ceil(len / 0.4));\n    for (let u = 0; u \u003c k; u++) {\n      const f = (u + 0.5) / k;\n      splat(px + (x - px) * f, py + (y - py) * f, len / k);\n    }\n    px = x, py = y;\n  }\n  for (let q = 0; q \u003c nt; q++) {\n    const k = TOUCH[q];\n    I[at + q] = k, Wt[at + q] = min(1.4, TMP[k]);\n    TMP[k] = 0;\n  }\n  S.np[i] = nt;\n}\n\n// Marks, pairs (shortest first) and how many pairs measure each length. The\n// arcs are drawn over the next few frames, shortest first.\nfunction useRuler(S, which, p) {\n  S.which = which;\n  const m = RULERS[which]();\n  const P = [];\n  for (let i = 0; i \u003c m.length; i++) for (let j = i + 1; j \u003c m.length; j++) P.push([m[i], m[j], m[j] - m[i]]);\n  P.sort((u, v) => u[2] - v[2]);\n  const cnt = new Int32Array(L + 1);\n  for (const q of P) cnt[q[2]]++;\n  S.marks = m, S.pairs = P, S.cnt = cnt;\n  // Denser rulers draw each arc fainter so 253 arcs do not burn to white.\n  S.gain = min(1, pow(91 / P.length, 0.75));\n  S.tm = new Float64Array(P.length).fill(-1);\n  const off = new Int32Array(P.length + 1);\n  for (let i = 0; i \u003c P.length; i++) off[i + 1] = off[i] + cap(P[i][2]);\n  S.off = off, S.np = new Int32Array(P.length);\n  S.I = new Int32Array(off[P.length]), S.Wt = new Float32Array(off[P.length]);\n  S.geoP = p, S.redo = 0;\n}\n\nfunction restart(S) {\n  S.d = 0, S.phase = 0, S.pt = 0;\n  S.tm.fill(-1);\n  S.next = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, which: -1, shape: 0.06, d: 0, phase: 0, pt: 0, next: 0,\n    acc: new Float32Array(W * H * 3), mf: new Float32Array(L + 1), c: [0, 0, 0],\n  });\n  useRuler(S, 0, expo(0.06));\n  restart(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.shape = cl(k[3], -1, 1);\n  const which = cl(round(k[2]), 0, 3), p = expo(S.shape);\n  if (which !== S.which) useRuler(S, which, p), restart(S);\n  // When the shape has moved by a visible amount the arcs are drawn again,\n  // shortest first and a share each frame, so the new outline spreads out\n  // from the spine over a few frames instead of costing one long frame. A\n  // pass runs to the end before the next one starts.\n  if (S.redo >= S.pairs.length && abs(p - S.geoP) / p > 0.02) (S.geoP = p), (S.redo = 0);\n  for (let budget = 1800; S.redo \u003c S.pairs.length && budget > 0; S.redo++) {\n    arcPixels(S, S.redo, p);\n    budget -= 20 + S.pairs[S.redo][2];\n  }\n  // Sweep: the caliper opens from 0 to 127, then the picture holds and fades.\n  if (S.phase === 0) {\n    S.d += 8 * S.speed * d;\n    const P = S.pairs;\n    while (S.next \u003c P.length && P[S.next][2] \u003c= S.d) S.tm[S.next++] = S.t;\n    if (S.d >= L + 1) (S.phase = 1), (S.pt = 0);\n  } else {\n    S.pt += d * (0.5 + S.speed / 4);\n    if (S.pt > 2.5) {\n      if (S.which === 2) useRuler(S, 2, S.geoP);\n      restart(S);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.I) return;\n  const acc = S.acc, c = S.c, P = S.pairs, I = S.I, Wt = S.Wt, off = S.off, np = S.np, t = S.t;\n  acc.fill(0);\n  const h0 = 0.44 + S.hue;\n  // Measured arcs hold their colour; after the hold they fade to the ghost.\n  const fade = S.phase === 1 ? cl((S.pt - 1.5) / 1, 0, 1) : 0;\n  const ghost = 0.16, mf = S.mf;\n  mf.fill(0);\n  for (let i = 0; i \u003c P.length; i++) {\n    const dd = P[i][2], tm = S.tm[i];\n    let e = ghost, flash = 0;\n    if (tm >= 0) {\n      e = 1 - (1 - ghost) * fade;\n      flash = exp(-(t - tm) / 0.2);\n      mf[P[i][0]] = max(mf[P[i][0]], flash), mf[P[i][1]] = max(mf[P[i][1]], flash);\n    }\n    hsv(h0 + 0.46 * (dd / L), 0.8 - 0.6 * flash, 1, c);\n    const gn = S.gain * e, r = c[0] * gn + flash, g = c[1] * gn + flash, b = c[2] * gn + flash;\n    for (let q = off[i], qe = off[i] + np[i]; q \u003c qe; q++) {\n      const k = I[q] * 3, w = Wt[q];\n      acc[k] += r * w, acc[k + 1] += g * w, acc[k + 2] += b * w;\n    }\n  }\n  // The caliper's jaw: a faint vertical line where arcs of the current\n  // length touch it with their tips.\n  if (S.phase === 0) {\n    const xj = X0 + (AMAX * S.d) / L, i = floor(xj), f = xj - i;\n    for (let y = 0; y \u003c H; y++) {\n      if (i >= 0 && i \u003c W) acc[(y * W + i) * 3 + 2] += 0.12 * (1 - f), acc[(y * W + i) * 3] += 0.06 * (1 - f), acc[(y * W + i) * 3 + 1] += 0.06 * (1 - f);\n      if (i + 1 \u003c W) acc[(y * W + i + 1) * 3 + 2] += 0.12 * f, acc[(y * W + i + 1) * 3] += 0.06 * f, acc[(y * W + i + 1) * 3 + 1] += 0.06 * f;\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * (1 - exp(-1.5 * acc[k]))) | 0, (255 * (1 - exp(-1.5 * acc[k + 1]))) | 0, (255 * (1 - exp(-1.5 * acc[k + 2]))) | 0);\n    }\n  // The spine and its marks.\n  for (let y = 0; y \u003c H; y++) display.setPixel(0, y, 40, 40, 48);\n  // A mark burns white while an arc from it is being measured.\n  for (const m of S.marks) {\n    const f = mf[m], v = (170 + 85 * f) | 0;\n    display.setPixel(0, m, 255, 250, 240);\n    display.setPixel(1, m, v, v - 5, v - 15);\n    if (f > 0.05) display.setPixel(2, m, (255 * f) | 0, (255 * f) | 0, (255 * f) | 0);\n  }\n  // The length scale: row d ticks once measured, 2 + n LEDs long when n\n  // pairs share the length, white for a moment as the caliper passes; a\n  // length nobody measures blinks dark red and stays a gap. Rows the\n  // caliper has not reached keep a faint dot.\n  const cur = S.phase === 0 ? floor(S.d) : L + 1, rate = 8 * S.speed;\n  for (let dd = 1; dd \u003c= L; dd++) {\n    const n = S.cnt[dd], since = S.phase === 0 ? (S.d - dd) / rate : 9;\n    if (dd > cur) {\n      display.setPixel(SX, dd, 34, 34, 40);\n      continue;\n    }\n    if (n === 0) {\n      const b = exp(-since / 0.5);\n      if (b > 0.1) display.setPixel(SX, dd, (200 * b) | 0, (30 * b) | 0, (40 * b) | 0);\n      continue;\n    }\n    const fl = exp(-since / 0.25);\n    hsv(h0 + 0.46 * (dd / L), 0.7 * (1 - fl), 1 - 0.6 * fade, c);\n    const len = 2 + n;\n    for (let x = SX; x > SX - len; x--) display.setPixel(x, dd, (c[0] * 255) | 0, (c[1] * 255) | 0, (c[2] * 255) | 0);\n  }\n  if (S.phase === 0) {\n    display.setPixel(SX, cur, 255, 255, 255);\n    display.setPixel(SX - 1, cur, 255, 255, 255);\n  }\n}\n","gridfonts":"// ===== Patternflow pattern =====\n// Title:   Gridfonts\n// Family:  type\n// Idea:    Three lines of three lowercase letters are built only from short strokes joining neighbouring points of a faint 3 by 7 dot grid, as in Douglas Hofstadter's gridfonts, and when the style changes every letter on the panel takes back and draws in its strokes by the same rule at once, cutting its corners, raising gables, opening stencil gaps or turning to outline.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: gridfonts and the Letter Spirit project (Douglas Hofstadter, 1980s; Gary McGraw's thesis, 1995; Hofstadter and the Fluid Analogies Research Group, Fluid Concepts and Creative Analogies, 1995), letters and styles drawn for this pattern, pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Style=0..6, Grid=0..1\n//\n// Knob 1: Hue. Turns the letters round the wheel from sea green at 0; each style keeps its own small step off that colour.\n// Knob 2: Speed. How fast strokes draw and the pages turn: at 2 something changes every 4 seconds, at 0.2 every 40.\n// Knob 3: Style. At 0 the six styles take turns: one change puts a new style on the same words, the next brings new words in that style. 1 to 6 hold one style while the words change: Square, Cut, Lean, Gable, Stencil, Outline.\n// Knob 4: Grid. What shows of the grid under the letters: only its points at 0, brighter up to 0.33, and from 0.1 upward, more and more, all 56 quanta of each letter's cell, the strokes every letter could have used.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The grid of one letter: 3 points across and 7 down, point p = 3 * row +\n// column with row 0 at the top. Rows 2 to 4 are the central zone, from the\n// x-height down to the baseline; rows 0 and 1 hold ascenders, 5 and 6\n// descenders.\nconst GC = 3, GR = 7, GP = GC * GR;\n// A quantum joins two points that are neighbours across, down or on a\n// diagonal. Counted here: 14 across, 18 down and 24 diagonals, 56 in all.\nconst QA = [], QB = [];\nconst QID = new Int8Array(GP * GP).fill(-1);\nfor (let p = 0; p \u003c GP; p++)\n  for (let q = p + 1; q \u003c GP; q++)\n    if (max(abs((q % GC) - (p % GC)), abs(floor(q / GC) - floor(p / GC))) === 1) {\n      QID[p * GP + q] = QID[q * GP + p] = QA.length;\n      QA.push(p);\n      QB.push(q);\n    }\nconst NQ = QA.length;\n\n// The panel: points 7 LEDs apart, three letters a line with an empty square\n// between letters, so the points of all nine letters fall on one lattice of\n// 9 by 19 points. Lines share a row of points: one line's descender row is\n// the next line's ascender row, and the pages are chosen so that no\n// descender meets an ascender there.\nconst SQ = 7, X0 = 3, PITCH = 3 * SQ, LINE = 6 * SQ, CELLS = 9;\n\n// The base face, written as pen paths. Each pair of digits is a point,\n// column then row, and the pen goes straight from one to the next, so one\n// step of a path may run over two quanta in a line.\nconst BASE = {\n  a: \"022224040323\",\n  b: \"0004242202\",\n  c: \"22020424\",\n  d: \"2024040222\",\n  e: \"032322020424\",\n  f: \"201014 0222\",\n  g: \"240402222606\",\n  h: \"0004 022224\",\n  i: \"1214 1011\",\n  j: \"121606 1011\",\n  k: \"0004 221303 1324\",\n  l: \"1014\",\n  m: \"04022224 1214\",\n  n: \"04022224\",\n  o: \"0222240402\",\n  p: \"0602222404\",\n  q: \"2622020424\",\n  r: \"040222\",\n  s: \"220203232404\",\n  t: \"1114 0222 1424\",\n  u: \"02042422\",\n  v: \"0203142322\",\n  w: \"0204132422\",\n  x: \"0224 2204\",\n  y: \"020424 222606\",\n  z: \"02220424\",\n};\n\n// A path string to directed quanta [from point, to point] in pen order.\nfunction parse(src) {\n  const out = [];\n  for (const path of src.split(\" \"))\n    for (let i = 2; i + 1 \u003c path.length; i += 2) {\n      let c = +path[i - 2], r = +path[i - 1];\n      const c1 = +path[i], r1 = +path[i + 1];\n      const sc = Math.sign(c1 - c), sr = Math.sign(r1 - r);\n      for (let n = max(abs(c1 - c), abs(r1 - r)); n > 0; n--) {\n        out.push([r * GC + c, (r + sr) * GC + c + sc]);\n        c += sc;\n        r += sr;\n      }\n    }\n  return out;\n}\n\nconst col = (p) => p % GC, row = (p) => floor(p / GC);\nconst other = (s, p) => (s[0] === p ? s[1] : s[0]);\n\n// Style rules. Each takes a letter's directed quanta and gives new ones, the\n// same rule for every letter, which is what Hofstadter meant by a gridfont\n// having one spirit.\n\n// Cut corners. Where exactly two quanta meet at a point, one across and one\n// down, both go and the diagonal across the corner takes their place. The\n// mask says which corners of a box: 1 top left, 2 top right, 4 bottom left,\n// 8 bottom right. A quantum is used by one corner at most.\nfunction cut(list, mask) {\n  const at = Array.from({ length: GP }, () => []);\n  list.forEach((s, i) => (at[s[0]].push(i), at[s[1]].push(i)));\n  const out = list.slice(), gone = new Uint8Array(list.length);\n  list.forEach((s, i) => {\n    for (const p of [s[1], s[0]]) {\n      if (gone[i] || at[p].length !== 2) continue;\n      const j = at[p][0] === i ? at[p][1] : at[p][0];\n      if (gone[j]) continue;\n      const a = other(s, p), b = other(list[j], p);\n      const horiz = (q) => row(q) === row(p), vert = (q) => col(q) === col(p);\n      let hq, vq;\n      if (horiz(a) && vert(b)) (hq = a), (vq = b);\n      else if (vert(a) && horiz(b)) (hq = b), (vq = a);\n      else continue;\n      const east = col(hq) > col(p), south = row(vq) > row(p);\n      const bit = east ? (south ? 1 : 4) : south ? 2 : 8;\n      if (!(mask & bit)) continue;\n      out[i] = s[1] === p ? [a, b] : [b, a];\n      gone[i] = gone[j] = 1;\n      out[j] = null;\n    }\n  });\n  return out.filter(Boolean);\n}\n\n// Gables. A full bar at the x-height whose both ends go on down becomes a\n// roof peaked one square higher; a full bar on the baseline whose both ends\n// come up becomes a keel one square lower. A stroke that met the middle of\n// the bar is carried on to the peak or the keel.\nfunction gable(list) {\n  const out = list.map((s) => s.slice());\n  const has = (a, b) => out.findIndex((s) => (s[0] === a && s[1] === b) || (s[0] === b && s[1] === a));\n  const goes = (p, dr) => out.some((s) => (s[0] === p || s[1] === p) && row(other(s, p)) === row(p) + dr);\n  for (const [r, dr] of [[2, 1], [4, -1]]) {\n    const L = r * GC, M = L + 1, R = L + 2, apex = M - dr * GC;\n    const i = has(L, M), j = has(M, R);\n    if (i \u003c 0 || j \u003c 0 || !goes(L, dr) || !goes(R, dr)) continue;\n    const meets = out.some((s, k) => k !== i && k !== j && (s[0] === M || s[1] === M));\n    out[i] = out[i].map((p) => (p === M ? apex : p));\n    out[j] = out[j].map((p) => (p === M ? apex : p));\n    if (meets) out.push(dr > 0 ? [apex, M] : [M, apex]);\n  }\n  return out;\n}\n\n// Six styles. cut is a corner mask for cut(), gable says gable() runs, gap\n// opens every quantum away from the points it joins so each one stands\n// alone as in a stencil, ring draws a stroke as its outline, and hue is the\n// style's step off the Hue knob.\nconst STYLES = [\n  { name: \"Square\", hue: 0, cut: 0, gable: 0, gap: 0, ring: 0 },\n  { name: \"Cut\", hue: 0.06, cut: 15, gable: 0, gap: 0, ring: 0 },\n  { name: \"Lean\", hue: -0.06, cut: 1 | 8, gable: 0, gap: 0, ring: 0 },\n  { name: \"Gable\", hue: 0.12, cut: 0, gable: 1, gap: 0, ring: 0 },\n  { name: \"Stencil\", hue: -0.12, cut: 0, gable: 0, gap: 1, ring: 0 },\n  { name: \"Outline\", hue: 0.18, cut: 0, gable: 0, gap: 0, ring: 1 },\n];\nconst NS = STYLES.length;\n\nconst idOf = (s) => QID[s[0] * GP + s[1]];\nconst keyOf = (l) => l.map(idOf).sort((a, b) => a - b).join();\nconst bits = (m) => (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1);\n\n// Every letter in every style, as directed quanta with no quantum twice.\nconst FACES = STYLES.map((st) => {\n  const make = (ch, mask) => {\n    let l = parse(BASE[ch]);\n    if (mask) l = cut(l, mask);\n    if (st.gable) l = gable(l);\n    const seen = new Uint8Array(NQ);\n    return l.filter((s) => {\n      const id = idOf(s);\n      if (id \u003c 0 || seen[id]) return false;\n      return (seen[id] = 1);\n    });\n  };\n  const face = {};\n  for (const ch in BASE) face[ch] = make(ch, st.cut);\n  // The letter comes before the style. Cut makes u the same quanta as v, so\n  // a letter the rule turns into another letter backs off, cutting as many\n  // of its corners as it can and still be itself.\n  const clash = (ch) => Object.keys(face).some((o) => o !== ch && keyOf(face[o]) === keyOf(face[ch]));\n  for (const ch in BASE) {\n    if (!st.cut || !clash(ch) || keyOf(face[ch]) === keyOf(parse(BASE[ch]))) continue;\n    const masks = [];\n    for (let m = st.cut - 1; m >= 0; m--) if ((m & st.cut) === m) masks.push(m);\n    masks.sort((a, b) => bits(b) - bits(a));\n    for (const m of masks) if (((face[ch] = make(ch, m)), !clash(ch))) break;\n  }\n  return face;\n});\n\n// Pages of three three-letter lines. Three of them are the alphabet, a to\n// z, the way a gridfont is shown.\nconst PAGES = [\"the\", \"sly\", \"fox\", \"abc\", \"def\", \"ghi\", \"web\", \"zig\", \"zag\", \"jkl\", \"mno\", \"pqr\", \"sea\", \"and\", \"sky\", \"stu\", \"vwx\", \"yz \", \"art\", \"for\", \"all\"]\n  .join(\"\")\n  .match(/.{9}/g);\n\n// Timing in seconds at Speed 2: a change every BEAT; quanta that leave take\n// back over BACK, those that come draw over DRAW one STEP apart in pen order,\n// after the leaving is done; each letter starts LAG after the one before.\nconst BEAT = 4, BACK = 0.3, DRAW = 0.2, STEP = 0.09, LAG = 0.06, CLEAR = 0.4;\n\n// Stroke profile against distance from the stroke's middle line, 64 steps\n// a LED: a 1 LED core, a shoulder to 1.25 LEDs and a glow that dies by 3.5.\nconst PROF = new Float32Array(256);\nfor (let k = 0; k \u003c 256; k++) {\n  const d = k / 64;\n  PROF[k] = d \u003c 0.55 ? 1 : d \u003c 1.25 ? 1 - ((d - 0.55) / 0.7) * 0.55 : 0.45 * exp(-(d - 1.25) * 1.35);\n}\nconst REACH = 3.5;\n// The outline style lights the edge of a stroke this far out.\nconst RING = 2.1;\n\nexport function setup(params) {\n  // The lattice points, and every quantum of every cell as a one-LED line.\n  const dot = new Uint8Array(N), mesh = new Uint8Array(N);\n  for (let gy = 0; gy \u003c= 18; gy++) for (let gx = 0; gx \u003c 9; gx++) dot[gy * SQ * W + X0 + gx * SQ] = 1;\n  for (let c = 0; c \u003c CELLS; c++) {\n    const ox = X0 + (c % 3) * PITCH, oy = floor(c / 3) * LINE;\n    for (let id = 0; id \u003c NQ; id++) {\n      const ax = ox + col(QA[id]) * SQ, ay = oy + row(QA[id]) * SQ;\n      const sx = col(QB[id]) - col(QA[id]), sy = row(QB[id]) - row(QA[id]);\n      for (let k = 1; k \u003c SQ; k++) {\n        const x = ax + sx * k, y = ay + sy * k;\n        if (y \u003c H) mesh[y * W + x] = 1;\n      }\n    }\n  }\n  const Q = CELLS * NQ;\n  params.s = {\n    dot, mesh, D: new Float32Array(N), B: new Float32Array(N), Wh: new Float32Array(N),\n    kind: new Uint8Array(Q), t0: new Float32Array(Q), dir: new Uint8Array(Q), ord: new Uint8Array(Q),\n    T: 0, next: BEAT, page: 0, style: 0, knob: -1, flip: 0, ready: false,\n    from: STYLES[0], to: STYLES[0], styleT: -9, hue: 0, grid: 0.06,\n  };\n}\n\n// Send the current page in the current style to the cells. Quanta the old\n// and the new letter share stay lit; the rest take back or draw in. kind is\n// 0 dark, 1 drawing or drawn, 2 taking back.\nfunction show(S, first) {\n  const text = PAGES[S.page], face = FACES[S.style];\n  const want = new Int16Array(NQ);\n  for (let c = 0; c \u003c CELLS; c++) {\n    want.fill(-1);\n    const list = face[text[c]] || [];\n    list.forEach((s, j) => (want[idOf(s)] = j));\n    for (let id = 0; id \u003c NQ; id++) {\n      const k = c * NQ + id;\n      if (S.kind[k] !== 1 || want[id] >= 0) continue;\n      // One that has not begun to draw just never comes.\n      if (S.t0[k] > S.T) S.kind[k] = 0;\n      else (S.kind[k] = 2), (S.t0[k] = S.T + c * LAG);\n    }\n    let n = 0;\n    const start = S.T + c * LAG + (first ? 0 : CLEAR);\n    list.forEach((s, j) => {\n      const id = idOf(s), k = c * NQ + id;\n      S.dir[k] = s[0] === QA[id] ? 0 : 1;\n      S.ord[k] = j;\n      if (S.kind[k] === 1) return;\n      S.kind[k] = 1;\n      S.t0[k] = start + n++ * STEP;\n    });\n  }\n}\n\nconst blend = (S) => {\n  const e = smooth((S.T - S.styleT) / 0.9), f = S.from, t = S.to;\n  return { hue: f.hue + (t.hue - f.hue) * e, gap: f.gap + (t.gap - f.gap) * e, ring: f.ring + (t.ring - f.ring) * e };\n};\n\nfunction restyle(S, style) {\n  // The blend starts from wherever the last one had got to.\n  S.from = blend(S);\n  S.to = STYLES[style];\n  S.style = style;\n  S.styleT = S.T;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.grid = cl(k[3], 0, 1);\n  const want = cl(round(k[2]), 0, NS);\n  if (!S.ready) {\n    S.ready = true;\n    S.knob = want;\n    S.style = want > 0 ? want - 1 : 0;\n    S.from = S.to = STYLES[S.style];\n    show(S, true);\n  } else if (want !== S.knob) {\n    S.knob = want;\n    if (want > 0 && want - 1 !== S.style) {\n      restyle(S, want - 1);\n      show(S, false);\n    }\n  }\n  S.T += (dt * cl(k[1], 0.05, 3)) / 2;\n  while (S.T >= S.next) {\n    S.next += BEAT;\n    // Held: new words each beat. Taking turns: a new style on the same\n    // words, then new words in that style.\n    if (S.knob === 0 && (S.flip ^= 1)) restyle(S, (S.style + 1) % NS);\n    else S.page = (S.page + 1) % PAGES.length;\n    show(S, false);\n  }\n}\n\n// One stroke from (x0, y0) to (x1, y1), its pen position running s0 to s1.\n// Each LED keeps the distance to the nearest stroke (so the outline of\n// strokes that meet is one outline) and how near that stroke's stretch is\n// to the light running along the pen path at P.\nfunction stroke(S, x0, y0, x1, y1, s0, s1, P, fade) {\n  const { D, B } = S;\n  const bx0 = max(0, floor(min(x0, x1) - REACH)), bx1 = min(W - 1, ceil(max(x0, x1) + REACH));\n  const by0 = max(0, floor(min(y0, y1) - REACH)), by1 = min(H - 1, ceil(max(y0, y1) + REACH));\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-6;\n  for (let y = by0; y \u003c= by1; y++)\n    for (let x = bx0; x \u003c= bx1; x++) {\n      const t = cl(((x - x0) * dx + (y - y0) * dy) / L2, 0, 1);\n      const ex = x - x0 - t * dx, ey = y - y0 - t * dy;\n      const d = sqrt(ex * ex + ey * ey) + fade, p = y * W + x;\n      if (d >= D[p]) continue;\n      D[p] = d;\n      const u = s0 + (s1 - s0) * t - P;\n      B[p] = u * u \u003c 9 ? exp(-u * u * 1.2) : 0;\n    }\n}\n\n// The pen's head while a quantum draws: a small white spark.\nfunction spark(Wh, x, y, lv) {\n  for (let yy = max(0, floor(y - 2)); yy \u003c= min(H - 1, ceil(y + 2)); yy++)\n    for (let xx = max(0, floor(x - 2)); xx \u003c= min(W - 1, ceil(x + 2)); xx++) {\n      const d2 = (xx - x) * (xx - x) + (yy - y) * (yy - y);\n      const v = lv * exp(-d2 / 1.1), p = yy * W + xx;\n      if (v > Wh[p]) Wh[p] = v;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.ready) return;\n  const { D, B, Wh, kind, t0, dir, ord, T } = S;\n  D.fill(REACH);\n  B.fill(0);\n  Wh.fill(0);\n  const { hue, gap, ring } = blend(S);\n  for (let c = 0; c \u003c CELLS; c++) {\n    const ox = X0 + (c % 3) * PITCH, oy = floor(c / 3) * LINE;\n    // A light runs along each letter's pen path, a quantum in 0.3 s, the\n    // letters a little apart in reading order.\n    const P = ((T - c * 0.23) * 3.3) % 18 - 2;\n    for (let id = 0; id \u003c NQ; id++) {\n      const k = c * NQ + id, kd = kind[k];\n      if (!kd) continue;\n      const tt = T - t0[k];\n      let u0 = 0, u1 = 1, fade = 0, head = 0;\n      if (kd === 1) {\n        const p = tt / DRAW;\n        if (p \u003c= 0) continue;\n        if (p \u003c 1) (u1 = p), (head = 1 - p * 0.5);\n      } else {\n        const q = tt / BACK;\n        if (q >= 1) continue;\n        if (q > 0) (u0 = q), (fade = 1.2 * q);\n      }\n      let a = QA[id], b = QB[id];\n      if (dir[k]) [a, b] = [b, a];\n      const ax = ox + col(a) * SQ, ay = oy + row(a) * SQ;\n      const dx = (col(b) - col(a)) * SQ, dy = (row(b) - row(a)) * SQ;\n      // Stencil: pull both ends back from the points.\n      const g = (gap * 1.8) / sqrt(dx * dx + dy * dy);\n      u0 = max(u0, g);\n      u1 = min(u1, 1 - g);\n      if (u1 \u003c= u0) continue;\n      const o = ord[k];\n      stroke(S, ax + dx * u0, ay + dy * u0, ax + dx * u1, ay + dy * u1, o + u0, o + u1, P, fade);\n      if (head > 0) spark(Wh, ax + dx * u1, ay + dy * u1, head);\n    }\n  }\n  const [lr, lg, lb] = hsv(0.42 + S.hue + hue, 0.72, 1);\n  const [gr, gg, gb] = hsv(0.36 + S.hue + hue, 0.35, 1);\n  const G = S.grid;\n  const dotL = 44 + 60 * min(1, G * 3), meshL = 78 * max(0, (G - 0.08) / 0.92);\n  const rc = RING * ring;\n  const { dot, mesh } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const d = D[p];\n    let v = 0, w = Wh[p];\n    if (d \u003c REACH) {\n      const k = (abs(d - rc) * 64) | 0;\n      v = k \u003c 256 ? PROF[k] : 0;\n      const b = B[p];\n      w += 0.3 * b * v;\n      v *= 0.7 + 0.3 * b;\n    }\n    const base = (dot[p] ? dotL : mesh[p] ? meshL : 0) * (1 - v);\n    // The middle of a lit stroke runs a little toward white.\n    const hot = v > 0.75 ? (v - 0.75) * 1.2 : 0;\n    display.setPixel(\n      p % W,\n      (p / W) | 0,\n      min(255, 255 * (lr * v + (1 - lr) * hot + w) + gr * base),\n      min(255, 255 * (lg * v + (1 - lg) * hot + w) + gg * base),\n      min(255, 255 * (lb * v + (1 - lb) * hot + w) + gb * base),\n    );\n  }\n}\n","hodograph":"// ===== Patternflow pattern =====\n// Title:   Hodograph\n// Family:  physics\n// Idea:    Bodies of different eccentricity go round one Sun in the upper half with Kepler's timing, each trailing a fan of three equal-time slices, and below them each body's velocity, drawn from one common origin, runs round a circle set off from that origin by e times its radius.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hodograph of motion under an inverse-square force (William Rowan Hamilton, 1846), Kepler's equation and the law of equal areas (Johannes Kepler, 1609), Feynman's lost lecture (Richard Feynman, 1964; David and Judith Goodstein, 1996), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Eccentricity=0.6..0.95, Bodies=3..6\n//\n// Knob 1: Hue. Turns the bodies' colours round the wheel together: at 0 the first three are cyan, magenta and green and the fourth to sixth azure, rose and yellow, while the Sun stays pale gold and the origin of the velocities white.\n// Knob 2: Speed. How fast time runs. At 1 the three opening bodies go round in 3.2, 5.3 and 7.1 seconds, the period growing as the 3/2 power of the semi-major axis; at the opening 2 they take 1.6, 2.6 and 3.5 seconds.\n// Knob 3: Eccentricity. The eccentricity of the most eccentric body, with the others spread evenly below it: 0.2, 0.4 and 0.6 at the opening 0.6. At 0.95 that body moves 39 times faster at periapsis than at apoapsis, its hodograph is the largest circle with the origin 0.05 of a radius inside its rim, and the other hodographs shrink round the origin.\n// Knob 4: Bodies. Three to six bodies, their eccentricities spread evenly up to Knob 3's (six at 0.6 run 0.1, 0.2 ... 0.6), their apoapses from 13 to 29.5 units and their apse lines turned 137.5 degrees (the golden angle) from one another; each half of the panel is fitted to the new set.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, PI, round, hypot } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst wrap = (v) => v - TAU * floor(v / TAU);\n\n// Upper half: the orbits round the Sun. Lower half: velocity space, every\n// velocity drawn from one origin O. World y runs up in both. Each half is\n// fitted to its own box, BOX LEDs square, centred on row MID[0] or MID[1].\nconst BOX = 57, MID = [30, 97];\n// Apoapses run from Q0 to Q1 in world units, and an orbit with semi-major\n// axis 20 takes T20 seconds at Speed 1. One Sun, so one mu for every body.\nconst Q0 = 13, Q1 = 29.5, T20 = 8;\nconst MU = (TAU / T20) ** 2 * 8000;\n// Each body's fan covers this share of its period, in BANDS equal-time slices.\nconst FAN = 0.3, BANDS = 3;\n// The arrow at a body is this share of the same velocity's length below.\nconst ARROW = 0.55;\n// Equal steps of true anomaly marked on every orbit and hodograph.\nconst BEADS = 12;\nconst TAB = 1024;\n// Body colours at Hue 0: cyan, magenta, green, azure, rose, yellow.\nconst HUES = [0.5, 0.83, 0.3, 0.64, 0.97, 0.14];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Kepler's equation M = E - e sin E by Newton's method from E = M. Over e\n// up to 0.95 and 20 000 values of M it settles within 7 steps.\nfunction kepler(M, e) {\n  let E = M;\n  for (let k = 0; k \u003c 20; k++) {\n    const d = (E - e * sin(E) - M) / (1 - e * cos(E));\n    E -= d;\n    if (abs(d) \u003c 1e-13) break;\n  }\n  return E;\n}\n\n// Mean anomaly at true anomaly th in [0, 2 pi], through the eccentric anomaly.\nfunction meanAt(e, th) {\n  const E = 2 * atan2(sqrt(1 - e) * sin(th / 2), sqrt(1 + e) * cos(th / 2));\n  return E - e * sin(E);\n}\n\n// The claim, checked: velocities from Kepler's equation at 720 equal steps\n// of time, a least-squares circle through them (Kasa's fit, which is not\n// told the answer), the largest distance of a velocity from that circle as\n// a share of its radius, and how far the circle's offset from the origin\n// is from e times its radius.\nfunction check() {\n  let radial = 0, offset = 0;\n  for (let e = 0; e \u003c 0.96; e += 0.05) {\n    const pts = [];\n    for (let k = 0; k \u003c 720; k++) {\n      const E = kepler((TAU * k) / 720, e), q = 1 - e * cos(E);\n      pts.push([-sin(E) / q, (sqrt(1 - e * e) * cos(E)) / q]);\n    }\n    let a = 0, b = 0, c = 0, d = 0, f = 0, n = pts.length, u = 0, v = 0, z = 0;\n    for (const [x, y] of pts) {\n      const r = x * x + y * y;\n      a += x * x; b += x * y; c += y * y; d += x; f += y; u += x * r; v += y * r; z += r;\n    }\n    const det3 = (m) =>\n      m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);\n    const A = [a, b, d, b, c, f, d, f, n], rhs = [-u, -v, -z], D = det3(A);\n    const sol = [0, 1, 2].map((col) => det3(A.map((m, i) => (i % 3 === col ? rhs[floor(i / 3)] : m))) / D);\n    const cx = -sol[0] / 2, cy = -sol[1] / 2, R = sqrt(cx * cx + cy * cy - sol[2]);\n    for (const [x, y] of pts) radial = max(radial, abs(hypot(x - cx, y - cy) - R) / R);\n    offset = max(offset, abs(hypot(cx, cy) / R - e));\n  }\n  return { radial, offset };\n}\n\nfunction body() {\n  return {\n    e: 0, a: 1, p: 1, Q: 1, nm: 1, R: 1, w0: 0, w: 0, cw: 1, sw: 0, M0: 0, M: 0,\n    x: 0, y: 0, vx: 0, vy: 0, psi: 0, span: 0, hx: 0, hy: 0, hr: 1, mt: new Float64Array(TAB + 1), col: new Float32Array(3),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, n: 0, emax: -1, hue: 0,\n    // Orbit scale and the Sun's LED; hodograph scale and the origin's LED.\n    so: 1, fx: 31.5, fy: 31, hs: 1, ox: 31.5, oy: 96,\n    b: [0, 1, 2, 3, 4, 5].map(body),\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3),\n    check: check(),\n  };\n  return params.s;\n}\n\n// Scale and centre that fit a world box into a half of the panel.\nfunction fit(x0, x1, y0, y1, row) {\n  const s = BOX / max(x1 - x0, y1 - y0);\n  return [s, 31.5 - (s * (x0 + x1)) / 2, row + (s * (y0 + y1)) / 2];\n}\n\n// The orbits' box with every apse line turned by tilt, as [x0, x1, y0, y1].\nfunction orbitBox(S, tilt) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c S.n; i++) {\n    const B = S.b[i], w = B.w0 + tilt, cw = cos(w), sw = sin(w), b = B.a * sqrt(1 - B.e * B.e);\n    const cx = -B.a * B.e * cw, cy = -B.a * B.e * sw;\n    const ex = sqrt(B.a * B.a * cw * cw + b * b * sw * sw), ey = sqrt(B.a * B.a * sw * sw + b * b * cw * cw);\n    x0 = min(x0, cx - ex); x1 = max(x1, cx + ex); y0 = min(y0, cy - ey); y1 = max(y1, cy + ey);\n  }\n  return [x0, x1, y0, y1];\n}\n\n// The bodies: eccentricities spread evenly up to the knob's, apoapses from\n// Q0 to Q1, apse lines turned by the golden angle from one another, and the\n// whole set turned to the tilt that lets it stand largest in its square.\n// Then both halves are fitted: the orbits by their box, the hodographs by\n// theirs, each circle of radius R = mu / h centred e R from O, square to\n// the apse line.\nfunction build(S, n, emax) {\n  S.n = n;\n  S.emax = emax;\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i], e = (emax * (i + 1)) / n;\n    B.e = e;\n    B.Q = Q0 + ((Q1 - Q0) * i) / (n - 1);\n    B.a = B.Q / (1 + e);\n    B.p = B.a * (1 - e * e);\n    B.nm = sqrt(MU / (B.a * B.a * B.a));\n    B.R = sqrt(MU / B.p);\n    B.w0 = i * 2.39996;\n    B.M0 = 0.6 + i * 2.6;\n    for (let k = 0; k \u003c= TAB; k++) B.mt[k] = meanAt(e, (TAU * k) / TAB);\n  }\n  let tilt = 0, best = 1e9;\n  for (let k = 0; k \u003c 60; k++) {\n    const [x0, x1, y0, y1] = orbitBox(S, (PI * k) / 60), size = max(x1 - x0, y1 - y0);\n    if (size \u003c best - 1e-9) (best = size), (tilt = (PI * k) / 60);\n  }\n  let u0 = 1e9, u1 = -1e9, v0 = 1e9, v1 = -1e9;\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i];\n    B.w = B.w0 + tilt;\n    B.cw = cos(B.w);\n    B.sw = sin(B.w);\n    const hx = -B.e * B.R * B.sw, hy = B.e * B.R * B.cw;\n    u0 = min(u0, hx - B.R); u1 = max(u1, hx + B.R); v0 = min(v0, hy - B.R); v1 = max(v1, hy + B.R);\n  }\n  const [x0, x1, y0, y1] = orbitBox(S, tilt);\n  [S.so, S.fx, S.fy] = fit(x0, x1, y0, y1, MID[0]);\n  [S.hs, S.ox, S.oy] = fit(u0, u1, v0, v1, MID[1]);\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i];\n    B.hr = B.R * S.hs;\n    B.hx = -B.e * B.hr * B.sw;\n    B.hy = B.e * B.hr * B.cw;\n  }\n}\n\nfunction meanOf(B, th) {\n  const f = (wrap(th) / TAU) * TAB, k = min(TAB - 1, floor(f));\n  return B.mt[k] + (B.mt[k + 1] - B.mt[k]) * (f - k);\n}\n\n// Position (from the Sun) and velocity of a body at time t, by Kepler's\n// equation, both in world axes.\nfunction place(B, t) {\n  const e = B.e, M = wrap(B.M0 + B.nm * t), E = kepler(M, e);\n  const cE = cos(E), sE = sin(E), s1 = sqrt(1 - e * e), k = (B.nm * B.a) / (1 - e * cE);\n  const px = B.a * (cE - e), py = B.a * s1 * sE, vx = -k * sE, vy = k * s1 * cE;\n  B.M = M;\n  B.x = px * B.cw - py * B.sw;\n  B.y = px * B.sw + py * B.cw;\n  B.vx = vx * B.cw - vy * B.sw;\n  B.vy = vx * B.sw + vy * B.cw;\n  // The directions of the velocity now and at the oldest edge of the fan.\n  // O is inside every hodograph, so the direction turns one way only, and\n  // the fan below lies between these two.\n  const Eo = kepler(wrap(M - TAU * FAN), e);\n  B.psi = atan2(vy, vx) + B.w;\n  B.span = wrap(B.psi - atan2(s1 * cos(Eo), -sin(Eo)) - B.w);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1], 0.2, 3), emax = cl(kv[2], 0.6, 0.95), n = cl(round(kv[3]), 3, 6);\n  if (n !== S.n || emax !== S.emax) build(S, n, emax);\n  S.t += d * speed;\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i];\n    place(B, S.t);\n    hsv(S.hue + HUES[i], 0.8, 1, B.col);\n  }\n}\n\n// Brightness of a fan at a given age, as a share of the fan's window:\n// equal-time slices alternate bright and dim, fading toward the oldest.\nfunction fan(age) {\n  return (1 - age) ** 0.7 * (floor(age * BANDS) % 2 ? 0.26 : 0.5);\n}\n\nfunction put(rgb, x, y, c, v) {\n  const o = (y * W + x) * 3;\n  if (rgb[o] \u003c c[0] * v) rgb[o] = c[0] * v;\n  if (rgb[o + 1] \u003c c[1] * v) rgb[o + 1] = c[1] * v;\n  if (rgb[o + 2] \u003c c[2] * v) rgb[o + 2] = c[2] * v;\n}\n\n// A soft point at panel coordinates (px, py), weights split over the four\n// nearest LEDs, each keeping the brighter value.\nfunction dot(rgb, px, py, c, v) {\n  const x0 = floor(px), y0 = floor(py), fx = px - x0, fy = py - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const x = x0 + i, y = y0 + j;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      put(rgb, x, y, c, v * (i ? fx : 1 - fx) * (j ? fy : 1 - fy));\n    }\n}\n\nfunction line(rgb, x0, y0, x1, y1, c, v) {\n  const n = max(1, Math.ceil(hypot(x1 - x0, y1 - y0) * 2.2));\n  for (let k = 0; k \u003c= n; k++) dot(rgb, x0 + ((x1 - x0) * k) / n, y0 + ((y1 - y0) * k) / n, c, v);\n}\n\nfunction disc(rgb, px, py, rad, c, core) {\n  for (let y = max(0, floor(py - rad - 1)); y \u003c= min(H - 1, Math.ceil(py + rad + 1)); y++)\n    for (let x = max(0, floor(px - rad - 1)); x \u003c= min(W - 1, Math.ceil(px + rad + 1)); x++) {\n      const d = hypot(x - px, y - py), v = cl(rad + 0.5 - d, 0, 1);\n      if (v \u003c= 0) continue;\n      const w = core * cl(1 - d / rad, 0, 1), o = (y * W + x) * 3;\n      rgb[o] = max(rgb[o], c[0] * v + (1 - c[0]) * w);\n      rgb[o + 1] = max(rgb[o + 1], c[1] * v + (1 - c[1]) * w);\n      rgb[o + 2] = max(rgb[o + 2], c[2] * v + (1 - c[2]) * w);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, n = S.n, bs = S.b, c = S.c, win = TAU * FAN;\n  const so = S.so, fx = S.fx, fy = S.fy, hs = S.hs, ox = S.ox, oy = S.oy;\n  rgb.fill(0);\n\n  // The fans in the orbits: an LED's direction from the Sun is a true\n  // anomaly on every orbit, the orbit's radius there says whether the LED is\n  // inside, and the time since the body passed that direction picks the slice.\n  for (let y = 0; y \u003c 64; y++) {\n    const dy = (fy - y) / so;\n    for (let x = 0; x \u003c W; x++) {\n      const dx = (x - fx) / so, d = sqrt(dx * dx + dy * dy), phi = atan2(dy, dx);\n      for (let i = 0; i \u003c n; i++) {\n        const B = bs[i];\n        if (d > B.Q + 1) continue;\n        const th = phi - B.w, age = wrap(B.M - meanOf(B, th)) / win;\n        if (age >= 1) continue;\n        const edge = (B.p / (1 + B.e * cos(th)) - d) * so + 0.5;\n        if (edge \u003c= 0) continue;\n        put(rgb, x, y, B.col, fan(age) * min(1, edge));\n      }\n    }\n  }\n  // The same fans in velocity space: the ray from O through an LED meets\n  // each hodograph at one velocity, whose angle round its circle's centre is\n  // the true anomaly plus a quarter turn.\n  for (let y = 64; y \u003c H; y++) {\n    const wy = oy - y;\n    for (let x = 0; x \u003c W; x++) {\n      const wx = x - ox, d = sqrt(wx * wx + wy * wy);\n      if (d \u003c 1e-6) continue;\n      const ux = wx / d, uy = wy / d, psi = atan2(wy, wx);\n      for (let i = 0; i \u003c n; i++) {\n        const B = bs[i];\n        if (wrap(B.psi - psi) > B.span) continue;\n        const ex = wx - B.hx, ey = wy - B.hy, edge = B.hr + 0.5 - sqrt(ex * ex + ey * ey);\n        if (edge \u003c= 0) continue;\n        const uc = ux * B.hx + uy * B.hy;\n        const s = uc + sqrt(max(0, uc * uc - B.hx * B.hx - B.hy * B.hy + B.hr * B.hr));\n        const th = atan2(s * uy - B.hy, s * ux - B.hx) - B.w - PI / 2;\n        const age = wrap(B.M - meanOf(B, th)) / win;\n        if (age >= 1) continue;\n        put(rgb, x, y, B.col, fan(age) * min(1, edge));\n      }\n    }\n  }\n\n  for (let i = 0; i \u003c n; i++) {\n    const B = bs[i], e = B.e, s1 = sqrt(1 - e * e), A = B.a * so;\n    // The orbit, brighter where the body has just been.\n    for (let k = 0; k \u003c 420; k++) {\n      const E = (TAU * k) / 420, px = A * (cos(E) - e), py = A * s1 * sin(E);\n      const age = wrap(B.M - (E - e * sin(E))) / win;\n      dot(rgb, fx + px * B.cw - py * B.sw, fy - (px * B.sw + py * B.cw), B.col, age \u003c 1 ? 0.95 - 0.5 * age : 0.4);\n    }\n    // The hodograph, the same way.\n    const nh = max(90, round(B.hr * 9));\n    for (let k = 0; k \u003c nh; k++) {\n      const th = (TAU * k) / nh, vx = -B.hr * sin(th), vy = B.hr * (e + cos(th));\n      const age = wrap(B.M - meanAt(e, th)) / win;\n      dot(rgb, ox + vx * B.cw - vy * B.sw, oy - (vx * B.sw + vy * B.cw), B.col, age \u003c 1 ? 0.95 - 0.5 * age : 0.4);\n    }\n    // The circle's centre, e times its radius from O.\n    dot(rgb, ox + B.hx, oy - B.hy, B.col, 0.6);\n    // Feynman's beads: the orbit at equal steps of angle round the Sun, and\n    // the velocities there, which fall at equal steps round the circle.\n    for (let k = 0; k \u003c 3; k++) c[k] = 0.55 + 0.45 * B.col[k];\n    for (let k = 0; k \u003c BEADS; k++) {\n      const th = (TAU * k) / BEADS, r = (B.p * so) / (1 + e * cos(th));\n      const px = r * cos(th), py = r * sin(th), vx = -B.hr * sin(th), vy = B.hr * (e + cos(th));\n      dot(rgb, fx + px * B.cw - py * B.sw, fy - (px * B.sw + py * B.cw), c, 1);\n      dot(rgb, ox + vx * B.cw - vy * B.sw, oy - (vx * B.sw + vy * B.cw), c, 1);\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const B = bs[i], col = B.col;\n    for (let k = 0; k \u003c 3; k++) c[k] = 0.5 + 0.5 * col[k];\n    const bx = fx + B.x * so, by = fy - B.y * so, tx = ox + B.vx * hs, ty = oy - B.vy * hs;\n    // A thread from the body to the tip of its velocity, the velocity arrow\n    // at the body, and the same velocity from O.\n    line(rgb, bx, by, tx, ty, col, 0.16);\n    line(rgb, bx, by, bx + (tx - ox) * ARROW, by + (ty - oy) * ARROW, c, 1);\n    line(rgb, ox, oy, tx, ty, c, 1);\n    disc(rgb, tx, ty, 1.2, col, 0.6);\n    disc(rgb, bx, by, 1.5, col, 0.8);\n  }\n  c[0] = 1; c[1] = 0.86; c[2] = 0.6;\n  disc(rgb, fx, fy, 1.8, c, 1);\n  c[0] = c[1] = c[2] = 1;\n  disc(rgb, ox, oy, 0.9, c, 1);\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n    }\n}\n","shapley-folkman":"// ===== Patternflow pattern =====\n// Title:   Shapley-Folkman\n// Family:  geometry\n// Idea:    Four bands down the panel hold one nonconvex shape and its Minkowski averages of 2, 4 and 8 copies, each summed exactly on a lattice, so its bays and holes close band by band toward the convex hull drawn faintly round it, the distance still to go halving at every band and every point coloured by the band where it first appears.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Shapley-Folkman lemma (Lloyd Shapley and Jon Folkman, first published by Ross Starr, 1969), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..4, Hull=0..1\n//\n// Knob 1: Hue. Turns the four layer colours round a wheel that skips orange. At 0 the shape is teal and the parts added at 2, 4 and 8 copies azure, indigo and violet; at 0.25 blue, violet, magenta and yellow; at 0.75 lime, green, cyan and azure. The uncovered part of the hull is gold at 0 and turns with them.\n// Knob 2: Speed. How fast the shape moves: at 2 the moon's bite, the pearls and the ring's gap go round in 9 s, the star turns one point in 1.8 s and the comb's teeth rise and fall every 6.9 s; at 0.2 ten times slower, at 3 two thirds of that. Every band follows at once, since all four are summed again each frame.\n// Knob 3: Shape. 0 a moon (an ellipse with a bite), 1 three pearls, 2 an open ring, 3 a comb, 4 a five-pointed star; in between, the two neighbours blend and break into pieces. At 1 copy they leave 43, 51, 45, 37 and 45% of their hull uncovered, at 8 copies 3.7, 1.3, 0.7, 0.9 and 4.4%.\n// Knob 4: Hull. The convex hull is a faint line at 0 and at the opening 0.06. From 0.1 the part of the hull a band has not covered yet is hatched in gold, the hatching at full strength by 0.4, and from there it fills in until at 1 that whole part is gold. It is the gap the lemma says shrinks like 1/n: for the moon, 43, 20, 8.6 and 3.7% of the hull in the four bands.\n\n// The Shapley-Folkman lemma: in the plane, a point of the convex hull of a\n// sum of n sets is a sum of n points, one from each set, of which at most\n// two come from a set's hull instead of the set. So the average of n copies\n// of a shape S, A(n) = (S + ... + S) / n, comes within 2D/n of every point\n// of S's hull, where D is how far the hull reaches from S itself: the\n// average fills toward the hull like 1/n. A(1), A(2), A(4) and A(8) also\n// nest, since (a + b) / 2 = (a + a + b + b) / 4.\n//\n// The panel takes S as the lattice points, one per LED, inside the shape,\n// sums the point sets exactly (8 copies make a lattice of 465 by 217),\n// and lights each LED by the share of A(n)'s points that fall inside it.\n// Brightness is never how many ways a point can be reached: that count is\n// the bell of the central limit theorem, a different statement.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, cos, sin, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// One band per n. The shape's lattice is SW by SH points, one per LED,\n// placed at (X0, Y0) inside each 32-row band.\nconst NS = [1, 2, 4, 8], NMAX = 8;\nconst SW = 59, SH = 28, X0 = 4, Y0 = 2, BAND = 32;\nconst CX = (SW - 1) / 2, CY = (SH - 1) / 2;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Lattice sets as bitmaps: w by h points, rows of 32-bit words. ----\nfunction bitmap(w, h) {\n  const ww = ((w + 31) >> 5) + 1;\n  return { w, h, ww, b: new Uint32Array(ww * h) };\n}\nconst has = (B, x, y) => (B.b[y * B.ww + (x >> 5)] >>> (x & 31)) & 1;\n\n// dst |= src moved by (dx, dy).\nfunction orShift(dst, src, dx, dy) {\n  const q = dx >> 5, r = dx & 31, sw = src.ww, dw = dst.ww, sb = src.b, db = dst.b;\n  const used = (src.w + 31) >> 5;\n  for (let y = 0; y \u003c src.h; y++) {\n    const so = y * sw, d0 = (y + dy) * dw + q;\n    if (r === 0) for (let i = 0; i \u003c used; i++) db[d0 + i] |= sb[so + i];\n    else\n      for (let i = 0; i \u003c used; i++) {\n        const v = sb[so + i];\n        if (!v) continue;\n        db[d0 + i] |= v \u003c\u003c r;\n        db[d0 + i + 1] |= v >>> (32 - r);\n      }\n  }\n}\n\n// The points of B with one of their eight neighbours outside B.\nfunction boundary(B, xs, ys) {\n  const { h, ww, b } = B, used = (B.w + 31) >> 5;\n  const hor = (o, i) => {\n    const m = b[o + i];\n    if (!m) return 0;\n    return m & ((m \u003c\u003c 1) | (i > 0 ? b[o + i - 1] >>> 31 : 0)) & ((m >>> 1) | (i + 1 \u003c used ? b[o + i + 1] \u003c\u003c 31 : 0));\n  };\n  let n = 0;\n  for (let y = 0; y \u003c h; y++)\n    for (let i = 0; i \u003c used; i++) {\n      const m = b[y * ww + i];\n      if (!m) continue;\n      const inner = y > 0 && y \u003c h - 1 ? hor(y * ww, i) & hor((y - 1) * ww, i) & hor((y + 1) * ww, i) : 0;\n      let e = m & ~inner;\n      while (e) {\n        const t = e & -e;\n        xs[n] = i * 32 + 31 - Math.clz32(t);\n        ys[n++] = y;\n        e ^= t;\n      }\n    }\n  return n;\n}\n\n// One point from each 8-connected piece of S.\nfunction pieces(S, lab, stack, out) {\n  out.length = 0;\n  lab.fill(0);\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      if (lab[y * SW + x] || !has(S, x, y)) continue;\n      out.push(x, y);\n      let sp = 0;\n      stack[sp++] = y * SW + x;\n      lab[y * SW + x] = 1;\n      while (sp) {\n        const p = stack[--sp], px = p % SW, py = (p - px) / SW;\n        for (let yy = max(0, py - 1); yy \u003c= min(SH - 1, py + 1); yy++)\n          for (let xx = max(0, px - 1); xx \u003c= min(SW - 1, px + 1); xx++) {\n            const k = yy * SW + xx;\n            if (!lab[k] && has(S, xx, yy)) (lab[k] = 1), (stack[sp++] = k);\n          }\n      }\n    }\n}\n\n// C = A + S, the Minkowski sum of lattice sets. Shifting the small S to\n// every point of A would do; it is enough to shift it to the boundary\n// points of A, and add one copy of A for each piece of S. For a piece P of\n// S and a sum x = p + a, the set x - P is connected and holds a; either it\n// leaves A, and then it crosses A's boundary, or it stays inside A and\n// x lies in A shifted by any one point of P. S is at most 64 points wide,\n// so each of its rows, moved by 0 to 31 bits, is kept ready as three words.\nfunction sum(C, A, St, reps, xs, ys) {\n  const cb = C.b, cw = C.ww, pre = St.pre, y0 = St.ylo, y1 = St.yhi;\n  cb.fill(0);\n  const n = boundary(A, xs, ys);\n  for (let k = 0; k \u003c n; k++) {\n    const x = xs[k], p0 = (x & 31) * SH * 3;\n    let o = (ys[k] + y0) * cw + (x >> 5);\n    for (let y = y0, p = p0 + y0 * 3; y \u003c= y1; y++, p += 3, o += cw) {\n      cb[o] |= pre[p];\n      cb[o + 1] |= pre[p + 1];\n      cb[o + 2] |= pre[p + 2];\n    }\n  }\n  for (let k = 0; k \u003c reps.length; k += 2) orShift(C, A, reps[k], reps[k + 1]);\n}\n\n// ---- The shapes, as rough signed distances in LEDs (inside \u003c 0). ----\n// The lattice is 59 wide and 28 tall; U and V scale a unit circle to it.\nconst U = 28.5, V = 13;\nconst len = (x, y) => sqrt(x * x + y * y);\nconst SHAPES = [\n  // Moon: an ellipse with a bite out of it, the bite going round.\n  (x, y, p) => {\n    const u = x / U, v = y / V, bu = u - 0.45 * cos(p), bv = v - 0.45 * sin(p);\n    return max(len(u, v) - 1, 0.75 - len(bu, bv)) * V;\n  },\n  // Pearls: three discs going round an ellipse.\n  (x, y, p) => {\n    let d = 1e9;\n    for (let j = 0; j \u003c 3; j++) {\n      const a = p + (TAU * j) / 3;\n      d = min(d, len(x - 21 * cos(a), y - 6.5 * sin(a)) - 6.5);\n    }\n    return d;\n  },\n  // Open ring: an elliptic band with a gap going round.\n  (x, y, p) => {\n    const u = x / U, v = y / V, r = len(u, v);\n    const a = atan2(v, u) - p, g = abs(atan2(sin(a), cos(a)));\n    return max(abs(r - 0.8) - 0.2, (0.55 - g) * r) * V;\n  },\n  // Comb: a back along the bottom and four teeth rising and falling.\n  (x, y, p) => {\n    let d = max(abs(x) - 28.5, abs(y - 10.5) - 3);\n    for (let j = 0; j \u003c 4; j++) {\n      const tx = -21.4 + 14.25 * j, top = -13 + 7 * (0.5 + 0.5 * sin(p * 1.3 + j * 1.9));\n      d = min(d, max(abs(x - tx) - 3.2, max(top - y, y - 10)));\n    }\n    return d;\n  },\n  // Star: five points turning, seen flattened to fit the band.\n  (x, y, p) => {\n    const u = x / U, v = y / V, r = len(u, v);\n    const a = atan2(v, u) - p, k = (a * 5) / TAU, f = abs(k - floor(k) - 0.5) * 2;\n    return (r - (0.38 + 0.62 * f * f)) * V * 1.4;\n  },\n];\n\nexport function setup(params) {\n  const sums = [null];\n  for (let k = 1; k \u003c= NMAX; k++) sums.push(bitmap(k * (SW - 1) + 1, k * (SH - 1) + 1));\n  const big = sums[NMAX - 1].w * sums[NMAX - 1].h;\n  params.s = {\n    phase: 0, hue: 0, shape: 0, hk: 0.06,\n    sums, xs: new Int32Array(big), ys: new Int32Array(big),\n    lab: new Uint8Array(SW * SH), stack: new Int32Array(SW * SH * 9), reps: [],\n    cov: new Float32Array(NS.length * SW * SH), sd: new Float32Array(SW * SH),\n    hull: [], pre: new Uint32Array(32 * SH * 3), ylo: 0, yhi: -1, ex: new Float64Array(SW * SH * 3),\n    pop: new Uint8Array(256).map((_, i) => (i.toString(2).match(/1/g) || []).length),\n    c: new Float32Array(3), lay: new Float32Array(NS.length * 9), unc: new Float32Array(SW * SH), rgb: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\n// Rasterise the shape at this phase and knob, then the sums 2..8.\nfunction build(S) {\n  const A = S.sums[1];\n  A.b.fill(0);\n  const k = cl(S.shape, 0, 4), i0 = min(3, floor(k)), f = k - i0;\n  const fa = SHAPES[i0], fb = SHAPES[i0 + 1];\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      const px = x - CX, py = y - CY;\n      let d = fa(px, py, S.phase);\n      if (f > 0) d = d * (1 - f) + fb(px, py, S.phase) * f;\n      if (d \u003c= 0) A.b[y * A.ww + (x >> 5)] |= 1 \u003c\u003c (x & 31);\n    }\n  pieces(A, S.lab, S.stack, S.reps);\n  S.ylo = SH;\n  S.yhi = -1;\n  for (let y = 0; y \u003c SH; y++) {\n    const w0 = A.b[y * A.ww], w1 = A.b[y * A.ww + 1];\n    if (w0 | w1) (S.ylo = min(S.ylo, y)), (S.yhi = y);\n    for (let r = 0; r \u003c 32; r++) {\n      const p = (r * SH + y) * 3;\n      S.pre[p] = w0 \u003c\u003c r;\n      S.pre[p + 1] = r ? (w0 >>> (32 - r)) | (w1 \u003c\u003c r) : w1;\n      S.pre[p + 2] = r ? w1 >>> (32 - r) : 0;\n    }\n  }\n  for (let n = 1; n \u003c NMAX; n++) sum(S.sums[n + 1], S.sums[n], S, S.reps, S.xs, S.ys);\n  hullOf(S);\n  // Coverage of each LED: the share of the n by n lattice points of the\n  // n-fold sum that fall in it, since A(n) is that sum shrunk by 1/n.\n  for (let bi = 0; bi \u003c NS.length; bi++) {\n    const n = NS[bi], B = S.sums[n], o = bi * SW * SH, h = n >> 1, mask = (1 \u003c\u003c n) - 1;\n    for (let y = 0; y \u003c SH; y++)\n      for (let x = 0; x \u003c SW; x++) {\n        let c = 0;\n        const a = n * x - h;\n        for (let r = n * y - h; r \u003c n * y - h + n; r++) {\n          if (r \u003c 0 || r >= B.h) continue;\n          const row = r * B.ww;\n          if (a \u003c 0) {\n            c += S.pop[B.b[row] & ((1 \u003c\u003c (a + n)) - 1)];\n            continue;\n          }\n          const wi = a >> 5, off = a & 31;\n          let v = B.b[row + wi] >>> off;\n          if (off + n > 32) v |= B.b[row + wi + 1] \u003c\u003c (32 - off);\n          c += S.pop[v & mask];\n        }\n        S.cov[o + y * SW + x] = c / (n * n);\n      }\n  }\n}\n\n// Convex hull of the shape's lattice points (monotone chain), then each\n// LED's signed distance to it, negative inside.\nfunction hullOf(S) {\n  const n = boundary(S.sums[1], S.xs, S.ys), P = [];\n  for (let k = 0; k \u003c n; k++) P.push([S.xs[k], S.ys[k]]);\n  P.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n  const cr = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);\n  const lo = [], up = [];\n  for (const p of P) {\n    while (lo.length >= 2 && cr(lo[lo.length - 2], lo[lo.length - 1], p) \u003c= 0) lo.pop();\n    lo.push(p);\n  }\n  for (let i = P.length - 1; i >= 0; i--) {\n    const p = P[i];\n    while (up.length >= 2 && cr(up[up.length - 2], up[up.length - 1], p) \u003c= 0) up.pop();\n    up.push(p);\n  }\n  const Hl = lo.slice(0, -1).concat(up.slice(0, -1));\n  S.hull = Hl;\n  // The chain turns left at every corner, reading y as up, so the inside\n  // is on the left of each edge; an LED's distance is the largest it lies\n  // outside any edge, which is exact inside and close enough near it.\n  const m = Hl.length, E = S.ex;\n  for (let i = 0; i \u003c m; i++) {\n    const a = Hl[i], b = Hl[(i + 1) % m], ex = b[0] - a[0], ey = b[1] - a[1], L = sqrt(ex * ex + ey * ey) || 1;\n    E[i * 3] = ey / L;\n    E[i * 3 + 1] = -ex / L;\n    E[i * 3 + 2] = (a[1] * ex - a[0] * ey) / L;\n  }\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      let d = -1e9;\n      for (let i = 0; i \u003c m * 3; i += 3) d = max(d, x * E[i] + y * E[i + 1] + E[i + 2]);\n      S.sd[y * SW + x] = m \u003c 3 ? 9 : d;\n    }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1] ?? 2, 0.2, 3);\n  S.shape = cl(kv[2] || 0, 0, 4);\n  S.hk = cl(kv[3] ?? 0.06, 0, 1);\n  S.phase += d * speed * 0.35;\n  build(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, c = S.c, L = S.lay, unc = S.unc, cov = S.cov, A = SW * SH;\n  rgb.fill(0);\n  // The uncovered part of the hull: gold hatching that comes in from Hull\n  // 0.1 to 0.4, then fills between its lines up to 1. Gold dimmed evenly\n  // would read brown.\n  const hk = S.hk, hatch = cl((hk - 0.1) / 0.3, 0, 1) * 0.85, fill = cl((hk - 0.4) / 0.6, 0, 1) * 0.85;\n  // Colour by n: each band's points are coloured by the band where they\n  // first appear, since A(1), A(2), A(4) and A(8) each hold the one before.\n  // Older layers are deep, the layer new in this band is pale and bright.\n  // The wheel skips orange, which goes brown at the depth of the old\n  // layers: the knob runs from yellow through green, blue and violet to red.\n  const wheel = (p) => 0.16 + (p - floor(p)) * 0.84;\n  for (let j = 0; j \u003c NS.length; j++) {\n    const h = wheel(S.hue + 0.352 + 0.136 * j);\n    hsv(h, 0.88, 0.58, c);\n    L.set(c, j * 9);\n    hsv(h + 0.03, 0.45, 1, c);\n    L.set(c, j * 9 + 3);\n    hsv(h, 0.9, 0.85, c);\n    L.set(c, j * 9 + 6);\n  }\n  hsv(S.hue + 0.13, 0.8, 1, c);\n  const fr = c[0], fg = c[1], fb = c[2];\n  for (let bi = 0; bi \u003c NS.length; bi++) {\n    const n = NS[bi], o = bi * A;\n    for (let k = 0; k \u003c A; k++) unc[k] = cl(0.5 - S.sd[k], 0, 1) * (1 - cov[o + k]);\n    for (let y = 0; y \u003c SH; y++)\n      for (let x = 0; x \u003c SW; x++) {\n        const k = y * SW + x, cv = cov[o + k], sd = S.sd[k];\n        let r = 0, g = 0, b = 0, acc = 0;\n        for (let j = 0; j \u003c= bi; j++) {\n          const cj = min(cov[j * A + k], cv), lj = cj - acc;\n          if (lj \u003c= 0) continue;\n          acc = cj;\n          const q = j * 9 + (bi === 0 ? 6 : j === bi ? 3 : 0);\n          r += L[q] * lj;\n          g += L[q + 1] * lj;\n          b += L[q + 2] * lj;\n        }\n        // The filling edge: lit points next to the part of the hull still\n        // uncovered glow in the new layer's pale colour.\n        let u = 0;\n        if (cv > 0) {\n          if (x > 0) u = max(u, unc[k - 1]);\n          if (x \u003c SW - 1) u = max(u, unc[k + 1]);\n          if (y > 0) u = max(u, unc[k - SW]);\n          if (y \u003c SH - 1) u = max(u, unc[k + SW]);\n        }\n        const glow = u * cv * 0.7, gq = bi * 9 + 3;\n        const line = cl(1 - abs(sd) / 0.8, 0, 1) * (0.14 + 0.5 * hk);\n        const gap = unc[k] * ((x + y) % 3 ? fill : hatch);\n        const q = ((bi * BAND + Y0 + y) * W + X0 + x) * 3;\n        rgb[q] = r + L[gq] * glow + fr * gap + line * 0.8;\n        rgb[q + 1] = g + L[gq + 1] * glow + fg * gap + line * 0.75;\n        rgb[q + 2] = b + L[gq + 2] * glow + fb * gap + line * 0.6;\n      }\n    // n dots at the left edge: the number of copies summed.\n    for (let j = 0; j \u003c n; j++) {\n      const Y = bi * BAND + 16 - ((n - 1) * 3) / 2 + j * 3;\n      const q = ((Y | 0) * W + 1) * 3;\n      rgb[q] = L[bi * 9 + 3];\n      rgb[q + 1] = L[bi * 9 + 4];\n      rgb[q + 2] = L[bi * 9 + 5];\n    }\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const q = (Y * W + X) * 3;\n      display.setPixel(X, Y, min(255, rgb[q] * 255) | 0, min(255, rgb[q + 1] * 255) | 0, min(255, rgb[q + 2] * 255) | 0);\n    }\n}\n","subpixel":"// ===== Patternflow pattern =====\n// Title:   Subpixel\n// Family:  type\n// Idea:    Two letters stored as TrueType outlines drift by fractions of a pixel over a magnified pixel grid that is scan-converted again every frame, as red, green and blue subpixel stripes, as grey coverage or as one-bit pixels, so the raster jumps and its colour fringes shimmer while the thin outline glides on top.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: TrueType quadratic outlines and its pixel-centre rule for scan conversion (Apple, 1991), ClearType subpixel rendering (Microsoft, announced 1998), FreeType's default LCD filter and light hinting, pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Letters=0..2, Speed=0.2..3, Mode=0..3, Hint=0..2\n//\n// Knob 1: Letters. Which pair: a over g at 13.2 pixels to the em or R over & at 12.2, on pixels six LEDs square, or 한 over 글 at 19.5 on pixels three LEDs square.\n// Knob 2: Speed. How fast the outlines drift and breathe: at 2 they travel half a pixel a second and swell and shrink by 5.5 percent over 15 seconds, at 0.2 ten times slower.\n// Knob 3: Mode. How the grid is filled: 0 subpixel stripes, each pixel three LED columns red, green and blue, each lit by the coverage of its own third after FreeType's five-tap filter; 1 the same three values as the colour of the whole pixel, where the fringes show; 2 grey coverage; 3 one bit, a pixel lit when its centre is inside, TrueType's first rule.\n// Knob 4: Hint. Snapping to the grid: 0 none; 1 the baseline, heights and horizontal strokes on pixel rows, as FreeType's light hinting does; 2 the vertical stems as well, each a whole number of pixels wide, so the hinted letter keeps its shape and moves only in whole-pixel jumps while the outline glides.\n// Buttons: K2 tap holds the outlines still, tap again to let them drift.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sin, cos, sqrt, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- Outlines. Units per em 1000, y up, baseline 0. A contour is a list of\n// points [x, y, on]: on 1 lies on the curve, on 0 is a quadratic control\n// point off it, and two off points in a row have an implied on point half\n// way between them, which is how TrueType stores a glyph. As in TrueType,\n// outer contours run clockwise and holes counter-clockwise, contours may\n// overlap, and the fill rule is nonzero winding. Each contour carries its\n// own stems for the hinter.\n\n// \"x,y\" on the curve, \"~x,y\" off it.\nconst pts = (s) => s.trim().split(/\\s+/).map((t) => {\n  const off = t[0] === \"~\";\n  const [x, y] = t.slice(off ? 1 : 0).split(\",\").map(Number);\n  return [x, y, off ? 0 : 1];\n});\n\nfunction rect(x0, y0, x1, y1) {\n  return { p: [[x0, y0, 1], [x0, y1, 1], [x1, y1, 1], [x1, y0, 1]], hx: [[x0, x1]], hy: [[y0, y1]] };\n}\n\n// An oval as eight off points and no on points at all: the implied on\n// points between them fall on the ellipse at every 45 degrees, the extremes\n// among them. A ring is the oval and a smaller one turned the other way.\nfunction oval(cx, cy, rx, ry, hole) {\n  const k = 1 / cos(PI / 8), p = [];\n  for (let i = 0; i \u003c 8; i++) {\n    const a = PI / 8 - (i * PI) / 4;\n    p.push([cx + rx * k * cos(a), cy + ry * k * sin(a), 0]);\n  }\n  return hole ? p.reverse() : p;\n}\nfunction ring(cx, cy, rx, ry, tx, ty) {\n  const hx = [[cx - rx, cx - rx + tx], [cx + rx - tx, cx + rx]], hy = [[cy - ry, cy - ry + ty], [cy + ry - ty, cy + ry]];\n  return [{ p: oval(cx, cy, rx, ry, false), hx, hy }, { p: oval(cx, cy, rx - tx, ry - ty, true), hx, hy }];\n}\n\n// A stroke: a centre line of on points with at most one control point\n// between them, \"x,y,w\" giving the width from that point on. The outline is\n// the line offset to the left going forward and to the right coming back,\n// each control point moved to where the offset tangents meet, so the\n// result is again quadratic. The ends are cut square.\nfunction stroke(s, hx, hy) {\n  const c = s.trim().split(/\\s+/).map((t) => {\n    const off = t[0] === \"~\";\n    const v = t.slice(off ? 1 : 0).split(\",\").map(Number);\n    return { x: v[0], y: v[1], on: !off, w: v[2] };\n  });\n  let w = 0;\n  for (const q of c) if (q.on) (w = q.w || w), (q.w = w);\n  const n = c.length;\n  const dir = (a, b) => {\n    const dx = b.x - a.x, dy = b.y - a.y, l = Math.hypot(dx, dy) || 1;\n    return [dx / l, dy / l];\n  };\n  // Tangent at each point.\n  const t = c.map((q, i) => {\n    const a = i > 0 ? dir(c[i - 1], q) : null, b = i \u003c n - 1 ? dir(q, c[i + 1]) : null;\n    if (!a) return b;\n    if (!b || !q.on) return a;\n    const x = a[0] + b[0], y = a[1] + b[1], l = Math.hypot(x, y) || 1;\n    return [x / l, y / l];\n  });\n  const side = (sg) => {\n    const out = [];\n    for (let i = 0; i \u003c n; i++) {\n      const q = c[i];\n      if (q.on) {\n        const d = (sg * q.w) / 2;\n        out.push([q.x + d * t[i][1], q.y - d * t[i][0], 1]);\n        continue;\n      }\n      // Meet the offset tangent lines of the two on points either side.\n      const A = c[i - 1], B = c[i + 1], ta = dir(A, q), tb = dir(q, B);\n      const da = (sg * A.w) / 2, db = (sg * B.w) / 2;\n      const ax = A.x + da * ta[1], ay = A.y - da * ta[0], bx = B.x + db * tb[1], by = B.y - db * tb[0];\n      const den = ta[0] * tb[1] - ta[1] * tb[0];\n      if (abs(den) \u003c 1e-6) out.push([(ax + bx) / 2, (ay + by) / 2, 0]);\n      else {\n        const u = ((bx - ax) * tb[1] - (by - ay) * tb[0]) / den;\n        out.push([ax + u * ta[0], ay + u * ta[1], 0]);\n      }\n    }\n    return out;\n  };\n  return { p: [...side(-1), ...side(1).reverse()], hx: hx || [], hy: hy || [] };\n}\n\nconst poly = (s, hx, hy) => ({ p: pts(s), hx: hx || [], hy: hy || [] });\n\nconst GLYPHS = {\n  // Double-storey a: stem, arch with a cut terminal, and the bowl hung\n  // from a shelf.\n  a: () => [\n    rect(416, 0, 512, 372),\n    stroke(\"464,360,96 ~464,490 290,490,84 ~176,490 112,424,80\", [[416, 512]], [[448, 532]]),\n    stroke(\"470,259,82 300,259 ~95,259 95,145,94 ~95,31 235,31,86 ~385,31 462,124,90\", [[48, 142], [416, 512]], [[-12, 74], [218, 300]]),\n  ],\n  // Double-storey g: a round upper bowl with an ear, a link and a lower loop.\n  g: () => [\n    ...ring(250, 352, 172, 180, 90, 80),\n    rect(360, 468, 548, 532),\n    stroke(\"178,204,76 ~112,132 180,98,72 ~226,64 330,64,74 ~500,64 500,-62,88 ~500,-194 275,-194,72 ~50,-194 50,-72,88 ~50,34 190,74,70\", [[6, 94], [456, 544]], [[27, 101], [-230, -158]]),\n  ],\n  R: () => [\n    rect(80, 0, 182, 700),\n    stroke(\"130,655,90 330,655 ~484,655 484,491,98 ~484,327 330,327,90 130,327\", [[80, 182], [435, 533]], [[610, 700], [282, 372]]),\n    poly(\"440,0 288,330 404,330 558,0\", [], [[0, 330]]),\n  ],\n  // Ampersand as one stroke: up the diagonal from the right foot, round the\n  // small upper loop, down across itself into the bowl and up the arm.\n  \"&\": () => [\n    stroke(\"588,26,100 ~468,160 332,308,94 ~202,452 205,548,88 ~208,662 305,662,84 ~402,662 402,562,86 ~402,470 292,400,90 ~85,270 85,160,96 ~85,31 252,31,86 ~420,31 490,158,92 ~528,228 546,330,88\", [[37, 133], [161, 249], [359, 445]], [[-12, 74], [620, 704]]),\n  ],\n  // Hangul in a 1000 square, gothic strokes 100 wide and 85 high.\n  \"한\": () => [\n    rect(245, 862, 405, 942), rect(80, 728, 570, 812), ...ring(325, 553, 178, 123, 92, 80),\n    rect(650, 372, 750, 950), rect(750, 622, 885, 706),\n    rect(150, 70, 250, 330), rect(150, 70, 882, 155),\n  ],\n  \"글\": () => [\n    rect(130, 845, 835, 930), rect(742, 700, 835, 930),\n    rect(45, 560, 955, 645),\n    rect(150, 385, 850, 466), rect(762, 228, 852, 466), rect(150, 228, 852, 308),\n    rect(150, 70, 240, 308), rect(150, 70, 870, 150),\n  ],\n};\n\n// Alignment zones for the Latin letters: the flat height and the\n// overshoot of round letters past it. Hinted, both land on one pixel line.\nconst ZONES = [[0, -12], [520, 532], [700, 712], [-220, -232]];\n\n// A set: the glyphs, how many LEDs one pixel takes, and the size in pixels\n// per em. Hangul packs three jamo into one square, so it gets twice the pixels.\nconst SETS = [\n  { g: [\"a\", \"g\"], zoom: 6, ppem: 13.2, gap: 1.3, zones: true },\n  { g: [\"R\", \"&\"], zoom: 6, ppem: 12.2, gap: 1.3, zones: true },\n  { g: [\"한\", \"글\"], zoom: 3, ppem: 19.5, gap: 3.2, zones: false },\n];\n\n// Flatten a contour list to line segments at unit scale, for the bounds.\nfunction bounds(contours) {\n  let x0 = 1e9, y0 = 1e9, x1 = -1e9, y1 = -1e9;\n  const seg = new Float32Array(4096);\n  const n = flatten(contours.map((c) => c.p.map((q) => [q[0], -q[1], q[2]])), seg, 0, 4);\n  for (let i = 0; i \u003c n * 4; i += 2) {\n    x0 = min(x0, seg[i]), x1 = max(x1, seg[i]);\n    y0 = min(y0, -seg[i + 1]), y1 = max(y1, -seg[i + 1]);\n  }\n  return { x0, y0, x1, y1 };\n}\n\n// Decode TrueType contours (already in pixels, y down) to quadratic pieces\n// and cut each into straight segments fine enough at `fine` LEDs a pixel.\n// Writes x0 y0 x1 y1 per segment from index n; returns the new count.\nfunction flatten(cs, seg, n, fine) {\n  const cap = seg.length >> 2;\n  const line = (ax, ay, bx, by) => {\n    if (n \u003c cap) (seg[n * 4] = ax), (seg[n * 4 + 1] = ay), (seg[n * 4 + 2] = bx), (seg[n * 4 + 3] = by), n++;\n  };\n  const quad = (ax, ay, qx, qy, bx, by) => {\n    const dev = (Math.hypot(ax - 2 * qx + bx, ay - 2 * qy + by) / 4) * fine;\n    const k = cl(ceil(sqrt(dev / 0.08)), 1, 24);\n    let px = ax, py = ay;\n    for (let i = 1; i \u003c= k; i++) {\n      const u = i / k, v = 1 - u;\n      const x = v * v * ax + 2 * u * v * qx + u * u * bx, y = v * v * ay + 2 * u * v * qy + u * u * by;\n      line(px, py, x, y);\n      (px = x), (py = y);\n    }\n  };\n  for (const p of cs) {\n    const m = p.length;\n    let s = p.findIndex((q) => q[2]);\n    let sx, sy;\n    if (s \u003c 0) (sx = (p[m - 1][0] + p[0][0]) / 2), (sy = (p[m - 1][1] + p[0][1]) / 2), (s = 0);\n    else (sx = p[s][0]), (sy = p[s][1]), (s = s + 1);\n    let cx = sx, cy = sy, ctl = null;\n    for (let k = 0; k \u003c m; k++) {\n      const q = p[(s + k) % m];\n      if (q[2]) {\n        if (ctl) quad(cx, cy, ctl[0], ctl[1], q[0], q[1]);\n        else line(cx, cy, q[0], q[1]);\n        (cx = q[0]), (cy = q[1]), (ctl = null);\n      } else if (ctl) {\n        const mx = (ctl[0] + q[0]) / 2, my = (ctl[1] + q[1]) / 2;\n        quad(cx, cy, ctl[0], ctl[1], mx, my);\n        (cx = mx), (cy = my), (ctl = q);\n      } else ctl = q;\n    }\n    if (ctl) quad(cx, cy, ctl[0], ctl[1], sx, sy);\n    else line(cx, cy, sx, sy);\n  }\n  return n;\n}\n\n// ---- Hinting. Each stem's two edges go to whole pixel lines with the\n// stem's width rounded, never under one pixel; an edge in an alignment zone\n// goes to the zone's line, which takes the overshoot with it at these sizes.\n// Every other point is moved in proportion between the edges either side of\n// it, the way TrueType's IUP instruction moves the points no instruction\n// touched, here per contour. `zones` are the zones the contour reaches.\nconst inZone = (z, u) => u >= min(z[0], z[1]) - 2 && u \u003c= max(z[0], z[1]) + 2;\nfunction edgeMap(stems, zones, f) {\n  const out = [];\n  const zoneOf = (u) => zones.find((z) => inZone(z, u)) || null;\n  for (const [a, b] of stems) {\n    const pa = f(a), pb = f(b), w = max(1, round(abs(pb - pa))), sg = pb > pa ? 1 : -1;\n    const za = zoneOf(a), zb = zoneOf(b);\n    let ha;\n    if (za) ha = round(f(za[0]));\n    else if (zb) ha = round(f(zb[0])) - sg * w;\n    else ha = round((pa + pb) / 2 - (sg * w) / 2);\n    out.push([a, ha], [b, ha + sg * w]);\n  }\n  for (const z of zones) out.push([z[0], round(f(z[0]))], [z[1], round(f(z[0]))]);\n  out.sort((p, q) => p[0] - q[0]);\n  // Keep the order: a later edge never crosses an earlier one.\n  const dec = f(1) \u003c f(0);\n  for (let i = 1; i \u003c out.length; i++) {\n    if (dec ? out[i][1] > out[i - 1][1] : out[i][1] \u003c out[i - 1][1]) out[i][1] = out[i - 1][1];\n  }\n  return out;\n}\nfunction mapEdge(E, f, u) {\n  const n = E.length;\n  if (!n) return f(u);\n  if (u \u003c= E[0][0]) return E[0][1] + f(u) - f(E[0][0]);\n  if (u >= E[n - 1][0]) return E[n - 1][1] + f(u) - f(E[n - 1][0]);\n  let i = 1;\n  while (E[i][0] \u003c u) i++;\n  const [ua, ha] = E[i - 1], [ub, hb] = E[i];\n  return ub > ua ? ha + ((u - ua) / (ub - ua)) * (hb - ha) : ha;\n}\n\n// The FreeType default LCD filter, in 256ths across five subpixels.\nconst FIR = [8, 77, 86, 77, 8].map((v) => v / 256);\n\nexport function setup(params) {\n  const sets = SETS.map((s) => {\n    const glyphs = s.g.map((ch) => {\n      const contours = GLYPHS[ch]().flat();\n      // A contour reaches a zone when one of its points or stem edges is in it.\n      const reach = (c, z) => c.p.some((q) => inZone(z, q[1])) || c.hy.some((e) => inZone(z, e[0]) || inZone(z, e[1]));\n      for (const c of contours) c.zones = s.zones ? ZONES.filter((z) => reach(c, z)) : [];\n      return { contours, box: bounds(contours) };\n    });\n    // Stack the two glyphs with a gap and centre the stack on the grid.\n    const GW = floor(W / s.zoom), GH = floor(H / s.zoom), sc = s.ppem / 1000;\n    const hs = glyphs.map((g) => (g.box.y1 - g.box.y0) * sc);\n    let y = (GH - hs[0] - hs[1] - s.gap) / 2;\n    glyphs.forEach((g, i) => {\n      g.cx = GW / 2;\n      g.cy = y + hs[i] / 2;\n      g.ux = (g.box.x0 + g.box.x1) / 2;\n      g.uy = (g.box.y0 + g.box.y1) / 2;\n      y += hs[i] + s.gap;\n    });\n    return { ...s, glyphs, GW, GH, X0: (W - GW * s.zoom) >> 1, Y0: (H - GH * s.zoom) >> 1 };\n  });\n  params.s = {\n    sets, set: 0, mode: 0, hint: 0, T: 0, hold: false,\n    seg: new Float32Array(4 * 6000), outl: new Float32Array(4 * 6000), nSeg: 0, nOut: 0,\n    cx: new Float32Array(256 * MAXC), cd: new Int8Array(256 * MAXC), cnt: new Int32Array(256),\n    bins: new Float32Array(43 * 64), bit: new Uint8Array(43 * 22), fir: new Float32Array(43 * 64),\n    mask: new Uint8Array(W * H), line: new Float32Array(W * H), offs: new Float32Array(1024), nOff: 0,\n  };\n}\n\n// Where glyph i of the set sits now: drift in pixels and a breathing scale.\nfunction pose(S, set, i) {\n  const T = S.T, ph = i * 2.1;\n  const g = set.glyphs[i];\n  const dx = 0.55 * sin(0.37 * T + ph) + 0.3 * sin(0.83 * T + 1.3 * ph);\n  const dy = 0.45 * sin(0.29 * T + 0.7 + ph) + 0.25 * sin(0.71 * T + 2 * ph);\n  const sc = (set.ppem / 1000) * (1 + 0.055 * sin(0.21 * T + 1.7 * ph));\n  return { ox: g.cx + dx, oy: g.cy + dy, sc, g };\n}\n\n// Place one glyph's contours in grid pixels, y down, hinted on the axes\n// asked. A hinted axis first puts the glyph's origin on a whole pixel, the\n// baseline on a pixel row as text lines are set, so the hinted glyph keeps\n// one shape wherever the outline drifts and moves only in whole pixels.\nfunction place(S, set, i, hint) {\n  const { ox, oy, sc, g } = pose(S, set, i);\n  const fx = (u) => ox + (u - g.ux) * sc, fy = (v) => oy - (v - g.uy) * sc;\n  return g.contours.map((c) => {\n    if (!hint) return c.p.map((q) => [fx(q[0]), fy(q[1]), q[2]]);\n    const y0 = fy(0), sy = (v) => fy(v) + round(y0) - y0;\n    const Ey = edgeMap(c.hy, c.zones, sy);\n    if (hint \u003c 2) return c.p.map((q) => [fx(q[0]), mapEdge(Ey, sy, q[1]), q[2]]);\n    const x0 = fx(0), sx = (u) => fx(u) + round(x0) - x0;\n    const Ex = edgeMap(c.hx, [], sx);\n    return c.p.map((q) => [mapEdge(Ex, sx, q[0]), mapEdge(Ey, sy, q[1]), q[2]]);\n  });\n}\n\n// ---- Scan conversion. Horizontal sample lines k = 0..L-1 sit at\n// y = (k + 0.5 - b) / a in the segments' units. On each, the crossings are\n// sorted and walked under nonzero winding, and span(k, x0, x1) gets every\n// run that is inside, exact in x.\nconst MAXC = 48;\nfunction scan(S, seg, nseg, L, a, b, span) {\n  const { cx, cd, cnt } = S;\n  cnt.fill(0, 0, L);\n  for (let s = 0; s \u003c nseg; s++) {\n    const x0 = seg[s * 4], y0 = seg[s * 4 + 1], x1 = seg[s * 4 + 2], y1 = seg[s * 4 + 3];\n    if (y0 === y1) continue;\n    const d = y1 > y0 ? 1 : -1, ya = min(y0, y1), yb = max(y0, y1);\n    const k0 = max(0, ceil(a * ya + b - 0.5)), k1 = min(L - 1, ceil(a * yb + b - 0.5) - 1);\n    for (let k = k0; k \u003c= k1; k++) {\n      if (cnt[k] >= MAXC) continue;\n      const y = (k + 0.5 - b) / a, j = k * MAXC + cnt[k]++;\n      cx[j] = x0 + ((y - y0) * (x1 - x0)) / (y1 - y0);\n      cd[j] = d;\n    }\n  }\n  for (let k = 0; k \u003c L; k++) {\n    const n = cnt[k], o = k * MAXC;\n    for (let i = 1; i \u003c n; i++) {\n      const x = cx[o + i], dd = cd[o + i];\n      let j = i - 1;\n      while (j >= 0 && cx[o + j] > x) (cx[o + j + 1] = cx[o + j]), (cd[o + j + 1] = cd[o + j]), j--;\n      (cx[o + j + 1] = x), (cd[o + j + 1] = dd);\n    }\n    let w = 0, start = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const was = w;\n      w += cd[o + i];\n      if (!was && w) start = cx[o + i];\n      else if (was && !w) span(k, start, cx[o + i]);\n    }\n  }\n}\n\n// Seven sample lines a pixel row (five on the finer Hangul grid). Coverage\n// is gathered per third of a pixel, so one pass gives the grey value of a\n// pixel and of its three subpixels. The middle line runs through the pixel\n// centres and gives the one-bit raster: TrueType's first rule, a pixel is\n// on when its centre is inside the outline.\nfunction rasterise(S, set) {\n  const { GW, GH } = set;\n  const SS = set.zoom > 3 ? 7 : 5, mid = (SS - 1) >> 1, NB = GW * 3;\n  const { bins, bit } = S;\n  bins.fill(0, 0, GH * NB);\n  bit.fill(0, 0, GH * GW);\n  scan(S, S.seg, S.nSeg, GH * SS, SS, 0, (k, xa, xb) => {\n    const row = (k / SS) | 0, u0 = cl(xa * 3, 0, NB), u1 = cl(xb * 3, 0, NB);\n    for (let q = floor(u0); q \u003c u1 && q \u003c NB; q++) bins[row * NB + q] += min(u1, q + 1) - max(u0, q);\n    if (k % SS === mid) for (let p = max(0, ceil(xa - 0.5)); p \u003c min(GW, ceil(xb - 0.5)); p++) bit[row * GW + p] = 1;\n  });\n  for (let i = 0; i \u003c GH * NB; i++) bins[i] /= SS;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.set = cl(round(k[0]), 0, SETS.length - 1);\n  S.mode = cl(round(k[2]), 0, 3);\n  S.hint = cl(round(k[3]), 0, 2);\n  if (input.btnPressed && input.btnPressed[1]) S.hold = !S.hold;\n  if (!S.hold) S.T += dt * cl(k[1], 0.05, 3);\n  const set = S.sets[S.set];\n  // The true outline and its off-curve points, for drawing, and the outline\n  // the raster is made from, which is the hinted one when hinting is on.\n  let n = 0;\n  S.nOff = 0;\n  for (let i = 0; i \u003c 2; i++) {\n    const cs = place(S, set, i, 0);\n    for (const c of cs) for (const q of c) if (!q[2] && S.nOff \u003c 512) (S.offs[S.nOff * 2] = q[0]), (S.offs[S.nOff * 2 + 1] = q[1]), S.nOff++;\n    n = flatten(cs, S.outl, n, set.zoom);\n  }\n  S.nOut = n;\n  if (S.hint) {\n    n = 0;\n    for (let i = 0; i \u003c 2; i++) n = flatten(place(S, set, i, S.hint), S.seg, n, set.zoom);\n  } else S.seg.set(S.outl.subarray(0, n * 4));\n  S.nSeg = n;\n  rasterise(S, set);\n}\n\n// An outline as a thin line on the LEDs, added into acc. Overlapping\n// contours leave edges inside the letter, so a stretch of line is drawn only\n// where one side of it is outside: the outline is first filled at one sample\n// per LED.\nfunction trace(S, set, sg, nseg, acc) {\n  const { mask } = S, z = set.zoom, X0 = set.X0, Y0 = set.Y0;\n  mask.fill(0);\n  scan(S, sg, nseg, H, z, Y0, (k, xa, xb) => {\n    for (let x = max(0, ceil(X0 + xa * z - 0.5)); x \u003c min(W, ceil(X0 + xb * z - 0.5)); x++) mask[k * W + x] = 1;\n  });\n  const inside = (x, y) => {\n    const i = round(x), j = round(y);\n    return i >= 0 && j >= 0 && i \u003c W && j \u003c H && mask[j * W + i];\n  };\n  acc.fill(0);\n  for (let s = 0; s \u003c nseg; s++) {\n    const ax = X0 + sg[s * 4] * z - 0.5, ay = Y0 + sg[s * 4 + 1] * z - 0.5;\n    const bx = X0 + sg[s * 4 + 2] * z - 0.5, by = Y0 + sg[s * 4 + 3] * z - 0.5;\n    const len = Math.hypot(bx - ax, by - ay);\n    if (len \u003c 1e-6) continue;\n    const nx = (by - ay) / len, ny = (ax - bx) / len, k = max(1, ceil(len / 0.3)), wt = len / k;\n    for (let i = 0; i \u003c k; i++) {\n      const u = (i + 0.5) / k, x = ax + u * (bx - ax), y = ay + u * (by - ay);\n      if (inside(x + nx * 1.2, y + ny * 1.2) && inside(x - nx * 1.2, y - ny * 1.2)) continue;\n      const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n      for (let q = 0; q \u003c 4; q++) {\n        const px = xi + (q & 1), py = yi + (q >> 1);\n        if (px \u003c 0 || py \u003c 0 || px >= W || py >= H) continue;\n        acc[py * W + px] += wt * (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy);\n      }\n    }\n  }\n}\n\n// The outline's pen: white over the stripes, rose over white pixels.\nconst PEN = [[255, 255, 255], [255, 64, 176], [255, 64, 176], [255, 64, 176]];\n\nexport function draw(display, params) {\n  const S = params.s;\n  const set = S.sets[S.set];\n  const { GW, GH, zoom: z, X0, Y0 } = set, NB = GW * 3;\n  const { bins, bit, fir, line, mode } = S;\n  // The subpixel values, filtered along each row across pixel borders.\n  if (mode \u003c 2)\n    for (let j = 0; j \u003c GH; j++)\n      for (let q = 0; q \u003c NB; q++) {\n        let v = 0;\n        for (let t = -2; t \u003c= 2; t++) {\n          const r = q + t;\n          if (r >= 0 && r \u003c NB) v += FIR[t + 2] * bins[j * NB + r];\n        }\n        fir[j * NB + q] = v;\n      }\n  trace(S, set, S.outl, S.nOut, line);\n  const pen = z > 3 ? 1.25 : 0.7, P = PEN[mode];\n  // The control points off the curve, one LED each.\n  for (let i = 0; i \u003c S.nOff; i++) {\n    const x = round(X0 + S.offs[i * 2] * z - 0.5), y = round(Y0 + S.offs[i * 2 + 1] * z - 0.5);\n    if (x >= 0 && y >= 0 && x \u003c W && y \u003c H) line[y * W + x] = max(line[y * W + x], 0.6 / pen);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      const gx = x - X0, gy = y - Y0;\n      if (gx >= 0 && gy >= 0 && gx \u003c GW * z && gy \u003c GH * z) {\n        const i = (gx / z) | 0, j = (gy / z) | 0, o = j * NB + i * 3;\n        if (mode === 0) {\n          // The LCD under a loupe: each third of the pixel a stripe of its own primary.\n          const sub = (((gx - i * z) * 3) / z) | 0, v = fir[o + sub] * 255;\n          if (sub === 0) r = v;\n          else if (sub === 1) g = v;\n          else b = v;\n        } else if (mode === 1) (r = fir[o] * 255), (g = fir[o + 1] * 255), (b = fir[o + 2] * 255);\n        else r = g = b = (mode === 2 ? (bins[o] + bins[o + 1] + bins[o + 2]) / 3 : bit[j * GW + i]) * 255;\n        // The grid: a faint dot at each pixel corner where nothing is lit.\n        if (gx % z === 0 && gy % z === 0 && r + g + b \u003c 40) r = g = b = 30;\n      }\n      const a = min(1, line[y * W + x] * pen);\n      if (a > 0) (r += (P[0] - r) * a), (g += (P[1] - g) * a), (b += (P[2] - b) * a);\n      display.setPixel(x, y, r, g, b);\n    }\n}\n","syllable-odometer":"// ===== Patternflow pattern =====\n// Title:   Syllable Odometer\n// Family:  type\n// Idea:    Three reels of Hangul jamo roll like the wheels of an odometer through all 11,172 modern syllables in Unicode order, the final fastest, then the vowel, then the initial, while a big syllable above them shows what they spell, solid when it is one of the 2,350 that KS C 5601-1987 encoded and hollow when it is not, two rolling counters count every syllable and the encoded ones, and a map of the current initial's 21 vowels by 28 finals lights up as the odometer passes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Hangul Syllables block, U+AC00 + (initial x 21 + vowel) x 28 + final (Unicode 2.0, 1996), against the 2,350 precomposed syllables (wansung) of KS C 5601-1987, now KS X 1001; the 9 by 11 combining Hangul face of Wongoji (pattern round 64); pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Initial=0..18, Skip=0..1\n//\n// Knob 1: Hue. Turns the palette round the wheel: at 0 the encoded syllables are amber and the missing ones blue-violet, at 0.25 green and rose, at 0.5 azure and lime; the reels and the first counter stay a pale tint of the encoded colour.\n// Knob 2: Speed. Steps a second: 0.5 at 0.2, 6 at the opening 2 (the first vowel row in 4.6 seconds, the 588 syllables of ㄱ in 94, all 11,172 in 30 minutes), 48 at 3.\n// Knob 3: Initial. Sets the slowest wheel by hand, 0 for ㄱ (가) up to 18 for ㅎ (하): the panel opens on the first syllable of that initial, and turned later the odometer spins on to it, starts a new map and counts on from there.\n// Knob 4: Skip. How long the odometer stays on a syllable KS C 5601 left out, as a share of a step: all of it at 0, 0.94 at the opening 0.06, none at 1, where it counts like a wansung machine that has only the 2,350 and spins over the other 8,822 between them (all 11,172 in 6.5 minutes at Speed 2).\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, asin, cos, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The 2,350. Bit i is syllable U+AC00 + i, six bits a character, low\n// bit first. Built offline by decoding the EUC-KR bytes B0A1..C8FE (rows\n// B0..C8, cells A1..FE: 25 rows of 94) and marking each syllable they give.\n// The decoded set has 2,350 syllables in Unicode order, misses 똠 (U+B620),\n// and per initial ㄱ..ㅎ holds 171 120 141 128 86 127 129 129 73 163 86 208\n// 135 82 112 107 106 105 142.\nconst A64 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nconst KS =\n  \"Tew/+EBsDMRAoAREAAwkFsnHRA7AXGwOSEBoAMZlrBTUwKQEBIDMRArAREgCwkHuGMRAwABAACwEBsAERAAATOwKQAAAAMZBrR\" +\n  \"XUwOyEBsDMQAAAAAAAwFBsDMBApAREAGSAAAAMVArDDEAMwAAACERAjABAAAwEBuGEQAwATEwEQEBMAEAAAATV4KCAAAAMRArA\" +\n  \"Xew+6EBsDMRAhAAAAAwGNsDORA7ATEwMREAAAMRBrwREAEAAAAAERALATEgKwkBsCEAAQABAAAQEBMAMQAjATcwaUEBAAMRBrQ\" +\n  \"X+4+4EBsDEAAAAAAAAwlNsKNRA7AREAMQEAAAMZFrKREAAQAAABERALABAAAwEBsCEAAQABAAIQEBoCERAhATWwKQAAAAMZA7B\" +\n  \"TEwO4EBsDAAAAAAAAAwENsDORA7ABAAEAAAAAMRAgABEAAQAAAAEBAAAAAAAwEBGCAAAAABAAAQEBMCAAAAATGwCQEBMAERArA\" +\n  \"TEwe8EBsDMBAoAAAAAwEBsDORArATEwOQEAoAMRArARAAIAAAABERArAREgKwEBsCEAAQABAAAwEBkCMRArATEwaGAAAAMRArA\" +\n  \"Tfwa6EBsHMQAgAAAAAwEFsGORA7ATEAuQAAAAsRBrARAAMAAAAAERAqAREgCwlHsiGRAKABAAAQEBAAERAJAREQCAAAAAMZB7K\" +\n  \"f+wKyEBsjMBACAAAAAwkFsGMZA7ATEgOSEAAAcRArARAAEQAAABMRADARAAAwkHsiFQAQABAAAwEBACERApATEwCAAAAAMRBrD\" +\n  \"TUwO4EBsDMAABAAAAAwkBkDEAAgADAwOAAAAAMRAjAAAAAAAAAAEAAAABAAIwEBkCAAAAAAAAAAAAAAEAAgAREwAAAAAAMRArA\" +\n  \"bewOyEBsDMRArAREQIwnNsDNRA7ATEwOQEBACcRBrITEAIQEBkBERALATEwKwkBsqFAAQATEQIwEBsCMQApATMwKAAAAAMZgrQ\" +\n  \"bEwM4EBMDAAAgAAAAAwEFMDERAAAAAAAAEAAAMZBjATAAEQAAABERADABAAAwEBMCEAAQABAAAQEAAAAAAgATU4AQEBEAMRArA\" +\n  \"zd4O2EBsDMRCroREgAwsH8XNRArAX0wPeEBsBMxlrCTEwOwEAkCMRArATEwKwEHsCMRAzATEwIwEBsCMRArCTE06fEBkAMxh7R\" +\n  \"TXwewEBsDMVAhAREAAwEFsGMRArAREwMQAAAAMRBrjDEgKQAAADERArATAAIwEHsCEAAQABAAAwEBsAERABATEwKAAAAAMZBrZ\" +\n  \"TlwOwEBsDEBAgAAAAAwEBsDEAAgABAAEAAAAAMRArCDEAEQAAABERADAAAAIwEBMCEAAwAAAAAQAAAAEAAAABAQKAAAAAMRAjh\" +\n  \"TFwewEBsDEVAhAAAAAwEBsDMRArARAAEQEAACMRArAREAIAAAAAERArABAQAwEBsCEAAQARAAAQEBsCERAhATEwKAAAAAM5ArA\" +\n  \"TEwKwEBsDMAAgAAAAAwkBsDMRArAREwOQAAAAMRArATEQIQAAACEQAAABAAAwEBsCERAgABAAIwEBsCERABATEwIAAAAAMRArA\" +\n  \"TMwOwEBsDEAAgAAAAAwEFsDMRArARAAEQEAAAMRArQRAAAQAAAAEBAoABAAAwEBsCEAAQABAAAwEBMCERAhATWwCQEBMAMRArA\" +\n  \"XUwOyEBsDMAAAAAAAAwEBsDMRArAREwMQABoAMRArABAAIAAAAAEBAAAREgCwkFsCEAAgAAAAAQEBkAERApAREwCAAAAAMRArA\" +\n  \"TEyKwEBsDEAAgAAAAAwEFsCMRArATEwOQEBIAMRIrITEAKwEAgCMRAqAREgCwEhkCERAhATEAIwEBsCMRApATPwKSEBMCMRArA\";\nconst ALL = 11172;\n\n// ---- The face: Wongoji's 9 by 11 combining Hangul (pattern round 64).\n// Jamo are strokes, lists of points in a box w by h; a syllable puts them in\n// boxes that depend on its vowel and on whether it has a final.\nconst INI = \"g gg n d dd r m b bb s ss o j jj c k t p h\".split(\" \");\nconst FIN = \". g gg gs n nj nh d r rg rm rb rs rt rp rh m b bs s ss o j c k t p h\".split(\" \");\n\nfunction ring(w, h, ox, oy) {\n  const rw = min(w, h + 2), rh = min(h, w + 1);\n  ox += (w - rw) >> 1;\n  oy += (h - rh) >> 1;\n  const R = rw - 1, B = rh - 1, c = R >> 1;\n  const pts = rh \u003c= 2 ? [[1, 0], [R - 1, 0], [R - 1, B], [1, B]] : [[c, 0], [1, 0], [0, 1], [0, B - 1], [1, B], [R - 1, B], [R, B - 1], [R, 1], [R - 1, 0], [c + 1, 0]];\n  return pts.map(([x, y]) => [x + ox, y + oy]);\n}\nfunction legs(w, h, y0) {\n  const c = (w - 1) >> 1, d = h - 1 - y0;\n  const xl = max(0, round(c - 1.3 * d)), xr = min(w - 1, round(c + (w % 2 ? 0 : 1) + 1.3 * d));\n  return [[[c, y0], [xl, h - 1]], [[c, y0 + max(1, round(d / 3))], [xr, h - 1]]];\n}\nfunction cons(k, w, h, tail) {\n  const c = (w - 1) >> 1, m = (h - 1) >> 1, S = [];\n  switch (k) {\n    case \"g\":\n      S.push(tail && h >= 6 ? [[0, 0], [w - 1, 0], [w - 1, h - 3], [w - 3, h - 1]] : [[0, 0], [w - 1, 0], [w - 1, h - 1]]);\n      break;\n    case \"n\":\n      S.push([[0, 0], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"d\":\n      S.push([[0, 0], [w - 1, 0]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"r\":\n      if (h >= 5) S.push([[0, 0], [w - 1, 0], [w - 1, m]], [[0, m], [w - 2, m]], [[0, m + 1], [0, h - 1], [w - 1, h - 1]]);\n      else {\n        const z = w >> 1;\n        S.push([[0, 0], [w - 1, 0], [w - 1, 1], [z, 1]], [[z, 2], [0, 2], [0, h - 1], [w - 1, h - 1]]);\n      }\n      break;\n    case \"m\":\n      S.push([[0, 0], [0, h - 1]], [[0, 0], [w - 1, 0], [w - 1, h - 1]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"b\":\n      S.push([[0, 0], [0, h - 1]], [[w - 1, 0], [w - 1, h - 1]], [[1, m], [w - 2, m]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"s\":\n      S.push(...legs(w, h, 0));\n      break;\n    case \"o\":\n      S.push(ring(w, h, 0, 0));\n      break;\n    case \"j\":\n      S.push([[0, 0], [w - 1, 0]], ...legs(w, h, 1));\n      break;\n    case \"c\":\n      S.push([[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ...legs(w, h, 2));\n      break;\n    case \"k\":\n      S.push([[0, 0], [w - 1, 0], [w - 1, h - 1]], [[0, h >> 1], [w - 2, h >> 1]]);\n      break;\n    case \"t\":\n      S.push([[0, 0], [w - 1, 0]], [[1, m], [w - 1, m]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"p\": {\n      const a = w >= 5 ? 1 : 0;\n      S.push([[0, 0], [w - 1, 0]], [[a, 1], [a, h - 2]], [[w - 1 - a, 1], [w - 1 - a, h - 2]], [[0, h - 1], [w - 1, h - 1]]);\n      break;\n    }\n    case \"h\":\n      S.push(w >= 7 ? [[c - 1, 0], [c + 1, 0]] : [[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ring(w, h - 2, 0, 2));\n      break;\n  }\n  return S;\n}\n// One consonant, or a double or cluster side by side, in a box at (x, y).\nfunction group(key, x, y, w, h, tail) {\n  const parts = [...key], out = [];\n  const put = (list, dx) => list.forEach((s) => out.push(s.map(([a, b]) => [a + x + dx, b + y])));\n  if (parts.length === 1) put(cons(parts[0], w, h, tail), 0);\n  else {\n    const w1 = (w - 1) >> 1;\n    put(cons(parts[0], w1, h, false), 0);\n    put(cons(parts[1], w - 1 - w1, h, false), w1 + 1);\n  }\n  return out;\n}\n// Vowels, as in Wongoji: vertical ones are the initial's width, then lines\n// [0, x] and ticks [1, x0, x1, slot]; horizontal ones ticks above [2, x],\n// bars [3, x0, x1] and stems below [4, x]; compounds have both.\nconst VV = {\n  0: [5, [0, 6], [1, 7, 8, 0]],\n  1: [5, [0, 6], [1, 7, 7, 0], [0, 8]],\n  2: [5, [0, 6], [1, 7, 8, 1], [1, 7, 8, 2]],\n  3: [5, [0, 6], [1, 7, 7, 1], [1, 7, 7, 2], [0, 8]],\n  4: [5, [1, 6, 7, 0], [0, 8]],\n  5: [4, [1, 5, 5, 0], [0, 6], [0, 8]],\n  6: [5, [1, 6, 7, 1], [1, 6, 7, 2], [0, 8]],\n  7: [4, [1, 5, 5, 1], [1, 5, 5, 2], [0, 6], [0, 8]],\n  20: [6, [0, 7]],\n};\nconst HV = { 8: [[2, 4], [3, 0, 8]], 12: [[2, 2], [2, 6], [3, 0, 8]], 13: [[3, 0, 8], [4, 4]], 17: [[3, 0, 8], [4, 2], [4, 6]], 18: [[3, 0, 8]] };\nconst MV = {\n  9: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 8, 0]]],\n  10: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 7, 0], [0, 8]]],\n  11: [6, [[2, 2], [3, 0, 5]], [[0, 7]]],\n  14: [5, [[3, 0, 4], [4, 2]], [[1, 5, 6, 3], [0, 8]]],\n  15: [4, [[3, 0, 3], [4, 2]], [[1, 5, 5, 3], [0, 6], [0, 8]]],\n  16: [6, [[3, 0, 5], [4, 3]], [[0, 7]]],\n  19: [6, [[3, 0, 5]], [[0, 7]]],\n};\nconst FREE = new Set([\"g\", \"gg\", \"s\", \"ss\", \"j\", \"jj\", \"c\", \"k\"]);\nconst NEED4 = new Set([\"r\", \"b\", \"bb\", \"c\", \"k\", \"t\", \"h\"]);\n\nfunction vparts(parts, y0, y1, bar, out) {\n  const mid = (y0 + y1) >> 1;\n  for (const p of parts) {\n    if (p[0] === 0) out.push([[p[1], y0], [p[1], y1]]);\n    else {\n      const y = p[3] === 0 ? mid : p[3] === 1 ? mid - 1 : p[3] === 2 ? mid + 1 : bar + 1;\n      out.push([[p[1], y], [p[2], y]]);\n    }\n  }\n}\nfunction hparts(parts, bar, stem, out) {\n  for (const p of parts) {\n    if (p[0] === 2) out.push([[p[1], bar - 1], [p[1], bar - 1]]);\n    else if (p[0] === 3) out.push([[p[1], bar], [p[2], bar]]);\n    else out.push([[p[1], bar + 1], [p[1], bar + stem]]);\n  }\n}\n\n// Syllable s (0..11171) as three stroke lists: initial, vowel, final.\nfunction jamo(s) {\n  const ci = floor(s / 588), vi = floor((s % 588) / 28), fi = s % 28;\n  const ini = INI[ci], has = fi > 0, vow = [];\n  let box;\n  const fbox = FIN[fi].length > 1 ? [0, 7, 9, 4] : [1, 7, 7, 4];\n  if (VV[vi]) {\n    const [iw, ...parts] = VV[vi];\n    box = has ? [0, 0, iw, 5] : [0, 2, iw, 7];\n    vparts(parts, has ? 0 : 1, has ? 5 : 9, 0, vow);\n  } else if (HV[vi]) {\n    const up = vi === 8 || vi === 12, down = vi === 13 || vi === 17;\n    let bar = 7;\n    if (!has) {\n      box = [1, 1, 7, 5];\n      if (up) bar = 8;\n    } else if (up) {\n      box = FREE.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = 5;\n    } else if (down) {\n      box = NEED4.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = box[3] + 1;\n    } else {\n      box = [1, 0, 7, 4];\n      bar = 5;\n    }\n    hparts(HV[vi], bar, has ? 1 : 2, vow);\n  } else {\n    const [iw, hp, vp] = MV[vi];\n    const up = hp[0][0] === 2, flat = hp.length === 1;\n    let bar;\n    if (!has) {\n      box = [0, 1, iw, flat ? 5 : 4];\n      bar = up || flat ? 7 : 6;\n    } else {\n      box = [0, 0, iw, flat ? 4 : 3];\n      bar = up || flat ? 5 : 4;\n    }\n    hparts(hp, bar, has ? 1 : 2, vow);\n    vparts(vp, has ? 0 : 1, has ? 5 : 9, bar, vow);\n  }\n  const tail = !has && VV[vi] && (ini === \"g\" || ini === \"k\");\n  return [group(ini, box[0], box[1], box[2], box[3], tail), vow, has ? group(FIN[fi], fbox[0], fbox[1], fbox[2], fbox[3], false) : []];\n}\n\n// Strokes to LEDs: a bitmap bw by bh, and the diagonal steps inside each\n// stroke, which the big glyph joins (the legs of ㅅ, ㅈ, ㅊ).\nfunction bitmap(strokes, bw, bh) {\n  const bits = new Uint8Array(bw * bh), diag = [];\n  for (const st of strokes) {\n    let lx = null, ly = null;\n    for (let i = 0; i \u003c st.length; i++) {\n      const [x0, y0] = st[i], [x1, y1] = st[min(i + 1, st.length - 1)];\n      const n = max(abs(x1 - x0), abs(y1 - y0));\n      for (let j = 0; j \u003c= n; j++) {\n        const x = round(x0 + ((x1 - x0) * j) / (n || 1)), y = round(y0 + ((y1 - y0) * j) / (n || 1));\n        if (x === lx && y === ly) continue;\n        if (x >= 0 && y >= 0 && x \u003c bw && y \u003c bh) bits[y * bw + x] = 1;\n        if (lx !== null && x !== lx && y !== ly) diag.push([lx, ly, x, y]);\n        lx = x;\n        ly = y;\n      }\n    }\n  }\n  return { bits, diag };\n}\n\n// ---- Layout.\n// The big glyph: the 9 by 11 face drawn 5 LEDs a column and 4 a row, each\n// lit LED of the face a round dot joined to its lit neighbours.\nconst GX = 9.5, GY = 2, SX = 5, SY = 4, GR = 2.0, GH = 46;\n// The counters, the reels and the map.\nconst CY = 49;\nconst RY = 70, RH = 14, RT = 15, RW = 20, RXS = [1, 22, 43], P = 21;\nconst MX = 4, MY = 86;\n\n// A row of the 3 by 5 digits, each row a 3-bit number, left bit high.\nconst DIG = [\"75557\", \"26227\", \"71747\", \"71317\", \"55711\", \"74717\", \"74757\", \"71122\", \"75757\", \"75717\"].map((s) => [...s].map(Number));\n\n// One reel's tape: each symbol drawn two LEDs a dot, centred in its own\n// stretch of P rows.\nfunction tape(symbols) {\n  const T = new Float32Array(RW * symbols.length * P);\n  symbols.forEach((strokes, k) => {\n    if (!strokes) {\n      // The empty final: a dotted slot.\n      for (let i = 0; i \u003c 7; i++)\n        for (let j = 0; j \u003c 7; j++) {\n          if ((i > 0 && i \u003c 6 && j > 0 && j \u003c 6) || (i + j) % 2) continue;\n          for (let a = 0; a \u003c 2; a++) for (let b = 0; b \u003c 2; b++) T[(k * P + 3 + 2 * j + b) * RW + 3 + 2 * i + a] = 0.55;\n        }\n      return;\n    }\n    const { bits } = bitmap(strokes, 9, 11);\n    let x0 = 9, x1 = -1, y0 = 11, y1 = -1;\n    for (let y = 0; y \u003c 11; y++)\n      for (let x = 0; x \u003c 9; x++)\n        if (bits[y * 9 + x]) {\n          x0 = min(x0, x);\n          x1 = max(x1, x);\n          y0 = min(y0, y);\n          y1 = max(y1, y);\n        }\n    const ox = (RW >> 1) - (x1 + x0 + 1), oy = k * P + (P >> 1) - (y1 + y0 + 1);\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        if (!bits[y * 9 + x]) continue;\n        for (let a = 0; a \u003c 2; a++) for (let b = 0; b \u003c 2; b++) T[(oy + 2 * y + b) * RW + ox + 2 * x + a] = 1;\n      }\n  });\n  return T;\n}\n\nexport function setup(params) {\n  const S = (params.s = { n: 0, p: 0, acc: 0, k3: -1, shown: -1, mapC: -1, fade: 0, rk: -1 });\n  // The set, and for each syllable how many of the 2,350 come at or before it.\n  S.ks = new Uint8Array(ALL);\n  S.rank = new Uint16Array(ALL);\n  let i = 0;\n  for (let c = 0; c \u003c KS.length; c++) {\n    const v = A64.indexOf(KS[c]);\n    for (let b = 0; b \u003c 6 && i \u003c ALL; b++) S.ks[i++] = (v >> b) & 1;\n  }\n  for (let s = 0, r = 0; s \u003c ALL; s++) S.rank[s] = r += S.ks[s];\n  // The three tapes: 19 initials, 21 vowels (as they stand beside or under\n  // ㅇ), 28 finals with the empty one first.\n  const box = (key) => group(key, key.length > 1 ? 0 : 1, 2, key.length > 1 ? 9 : 7, 7, false);\n  S.tapes = [\n    tape(INI.map(box)),\n    tape(Array.from({ length: 21 }, (_, v) => jamo(11 * 588 + v * 28)[1])),\n    tape(FIN.map((f, k) => (k ? box(f) : null))),\n  ];\n  S.row = new Float32Array(RW);\n  S.G = new Float32Array(W * GH);\n  S.E = new Float32Array(W * GH);\n  S.B = new Float32Array(W * GH);\n  S.Hl = new Float32Array(W * GH);\n  S.F = new Float32Array(W * H * 3);\n}\n\n// The big glyph of syllable s into S.G (coverage) and S.E (its outline).\nfunction bigGlyph(S, s) {\n  const { bits, diag } = bitmap(jamo(s).flat(), 9, 11);\n  const segs = diag.slice();\n  for (let y = 0; y \u003c 11; y++)\n    for (let x = 0; x \u003c 9; x++) {\n      if (!bits[y * 9 + x]) continue;\n      segs.push([x, y, x, y]);\n      if (x \u003c 8 && bits[y * 9 + x + 1]) segs.push([x, y, x + 1, y]);\n      if (y \u003c 10 && bits[(y + 1) * 9 + x]) segs.push([x, y, x, y + 1]);\n    }\n  const G = S.G;\n  G.fill(0);\n  for (const [a, b, c, d] of segs) {\n    const ax = GX + (a + 0.5) * SX, ay = GY + (b + 0.5) * SY, bx = GX + (c + 0.5) * SX, by = GY + (d + 0.5) * SY;\n    const dx = bx - ax, dy = by - ay, L = dx * dx + dy * dy;\n    for (let y = max(0, floor(min(ay, by) - GR - 1)); y \u003c= min(GH - 1, floor(max(ay, by) + GR + 1)); y++)\n      for (let x = max(0, floor(min(ax, bx) - GR - 1)); x \u003c= min(W - 1, floor(max(ax, bx) + GR + 1)); x++) {\n        const px = x + 0.5 - ax, py = y + 0.5 - ay;\n        const u = L ? cl((px * dx + py * dy) / L, 0, 1) : 0;\n        const ex = px - u * dx, ey = py - u * dy;\n        const v = cl(GR + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n        if (v > G[y * W + x]) G[y * W + x] = v;\n      }\n  }\n  // The outline: lit LEDs with an unlit neighbour.\n  const E = S.E;\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const g = G[y * W + x];\n      let lo = 1;\n      if (g > 0.3) for (const [ox, oy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) lo = min(lo, x + ox \u003c 0 || x + ox >= W || y + oy \u003c 0 || y + oy >= GH ? 0 : G[(y + oy) * W + x + ox]);\n      E[y * W + x] = g > 0.3 && lo \u003c 0.5 ? g : 0;\n    }\n  // A soft halo round the strokes, for the encoded syllables: a box blur\n  // five LEDs wide, across and then down.\n  const B = S.B, Hl = S.Hl;\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let i = -2; i \u003c= 2; i++) s += x + i >= 0 && x + i \u003c W ? G[y * W + x + i] : 0;\n      B[y * W + x] = s / 5;\n    }\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let i = -2; i \u003c= 2; i++) s += y + i >= 0 && y + i \u003c GH ? B[(y + i) * W + x] : 0;\n      Hl[y * W + x] = max(0, s / 5 - G[y * W + x]);\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1], 0.2, 3);\n  const d = speed - 2;\n  S.rate = 6 * exp(1.83 * d + 0.25 * d * d);\n  S.skip = cl(k[3], 0, 1);\n  // The Initial knob sets the slowest wheel when it is turned; the first\n  // frame starts there without spinning.\n  const c = round(cl(k[2], 0, 18));\n  if (c !== S.k3) {\n    const base = floor(S.n / ALL) * ALL;\n    let to = base + c * 588;\n    if (S.k3 >= 0 && to \u003c= S.n) to += ALL;\n    if (S.k3 \u003c 0) S.p = to;\n    S.n = to;\n    S.acc = 0;\n    S.k3 = c;\n  }\n  // Count: the odometer stays a whole step on each syllable, on a missing\n  // one 1 - Skip of a step.\n  const stay = (s) => (S.ks[s % ALL] ? 1 : 1 - S.skip);\n  S.acc += dt * S.rate;\n  for (let i = 0; i \u003c 4000 && S.acc >= stay(S.n); i++) {\n    S.acc -= stay(S.n);\n    S.n++;\n  }\n  // The wheels rest on the count and turn to the next syllable in the last\n  // 0.08 seconds of the stay (the whole stay when stays are shorter),\n  // then a quick spring smooths them, so a jump spins through what lies\n  // between.\n  const g = S.n % ALL, next = (g + 1) % ALL, cost = stay(g);\n  const w = cost > 0 ? min(1, (0.08 * S.rate) / cost) : 1, phi = cost > 0 ? cl(S.acc / cost, 0, 1) : 1;\n  const e = cl((phi - 1 + w) / w, 0, 1), turn = w >= 1 ? e : e * e * (3 - 2 * e);\n  const spring = 1 - exp(-dt * 30);\n  S.p += (S.n + turn - S.p) * spring;\n  if (abs(S.n + turn - S.p) \u003c 0.002) S.p = S.n + turn;\n  // The glyph and the map read the count.\n  if (g !== S.shown) {\n    S.shown = g;\n    bigGlyph(S, g);\n  }\n  // A new initial starts a new map; the last one fades out over it.\n  const ci = floor(g / 588);\n  if (ci !== S.mapC) {\n    S.mapOld = S.mapC;\n    S.oldAt = S.mapC === (ci + 18) % 19 ? 587 : S.at;\n    S.mapC = ci;\n    S.fade = S.mapOld \u003c 0 ? 0 : 1;\n  }\n  S.at = g % 588;\n  // The count of the 2,350 turns with the wheels when the next syllable is\n  // one of them, and starts again after 힣.\n  const rk = S.rank[g] + (S.ks[next] ? turn : 0);\n  S.rk = rk \u003c S.rk - 50 || S.rk \u003c 0 ? rk : S.rk + (rk - S.rk) * spring;\n  if (abs(rk - S.rk) \u003c 0.002) S.rk = rk;\n  S.fade = max(0, S.fade - dt / 0.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.shown \u003c 0) return;\n  const F = S.F;\n  F.fill(0);\n  const hue = 0.1 + S.hue;\n  const lit = hsv(hue, 0.85, 255), miss = hsv(hue + 0.6, 0.6, 255), pale = hsv(hue + 0.02, 0.3, 255);\n  const add = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    F[o] += c[0] * a;\n    F[o + 1] += c[1] * a;\n    F[o + 2] += c[2] * a;\n  };\n  const g = S.shown, inSet = S.ks[g] === 1;\n\n  // The big glyph: solid when encoded, a hollow outline when not.\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      if (inSet) {\n        const v = S.G[y * W + x] + 0.3 * S.Hl[y * W + x];\n        if (v > 0) add(x, y, lit, v);\n      } else {\n        const v = S.E[y * W + x];\n        if (v > 0) add(x, y, miss, 0.75 * v);\n      }\n    }\n\n  // The counters, rolling like the reels: the syllable's place among all\n  // 11,172, and among the 2,350. A digit turns while every digit to its\n  // right turns from 9 to 0.\n  const roll = (val, digits, x0, c, a) => {\n    const fl = floor(val), fr = val - fl;\n    for (let d = 0, m = 1; d \u003c digits; d++, m *= 10) {\n      const base = floor(fl / m) % 10, sh = round((fl % m === m - 1 ? fr : 0) * 7), x = x0 + (digits - 1 - d) * 4;\n      for (const [dig, oy] of [[base, -sh], [(base + 1) % 10, 7 - sh]])\n        for (let r = 0; r \u003c 5; r++) {\n          if (r + oy \u003c 0 || r + oy > 4) continue;\n          for (let b = 0; b \u003c 3; b++) if (DIG[dig][r] & (4 >> b)) add(x + b, CY + r + oy, c, a);\n        }\n    }\n  };\n  roll(min(ALL, (S.p % ALL) + 1), 5, 1, pale, 0.8);\n  roll(S.rk, 4, 48, inSet ? lit : miss, inSet ? 1 : 0.5);\n\n  // The reels: each a wheel of radius RT seen through a window 2 RH tall,\n  // its symbols squeezed and dimmed towards the window's edges.\n  const p = S.p, fr = p - floor(p), q = floor(p);\n  const pos = [\n    (floor(q / 588) % 19) + (q % 588 === 587 ? fr : 0),\n    (floor(q / 28) % 21) + (q % 28 === 27 ? fr : 0),\n    (q % 28) + fr,\n  ];\n  const len = [19, 21, 28];\n  for (let r = 0; r \u003c 3; r++) {\n    const T = S.tapes[r], span = len[r] * P, uc = pos[r] * P + (P >> 1);\n    for (let y = RY - RH; y \u003c RY + RH; y++) {\n      let shade = 0;\n      const row = S.row.fill(0);\n      for (let s = 0; s \u003c 4; s++) {\n        const dy = y + (s + 0.5) / 4 - RY, th = asin(cl(dy / RT, -1, 1));\n        let u = floor(uc + RT * th) % span;\n        if (u \u003c 0) u += span;\n        const w = cos(th);\n        shade += w / 4;\n        for (let x = 0; x \u003c RW; x++) row[x] += (T[u * RW + x] * w) / 4;\n      }\n      for (let x = 0; x \u003c RW; x++) {\n        add(RXS[r] + x, y, pale, 0.11 * shade + 0.89 * row[x]);\n      }\n    }\n  }\n\n  // The map: the current initial's 21 vowels down and 28 finals across.\n  // Ahead of the odometer the encoded cells wait faintly; behind it they\n  // burn, fresh ones brighter for a moment.\n  const ci = S.mapC, at = g % 588;\n  const cell = (x, y, c, a) => {\n    add(x, y, c, a);\n    add(x + 1, y, c, a);\n    add(x, y + 1, c, a * 0.45);\n    add(x + 1, y + 1, c, a * 0.45);\n  };\n  for (let v = 0; v \u003c 21; v++)\n    for (let f = 0; f \u003c 28; f++) {\n      const k = v * 28 + f, x = MX + 2 * f, y = MY + 2 * v, on = S.ks[ci * 588 + k];\n      let c, a;\n      if (k === at) (c = [255, 255, 255]), (a = 1);\n      else if (k > at) (c = pale), (a = on ? 0.24 : 0.06);\n      else {\n        const age = (at - k) / S.rate, glow = exp(-age / 0.7);\n        c = on ? lit : miss;\n        a = on ? 0.75 + 0.25 * glow : 0.2 + 0.3 * glow;\n      }\n      if (S.fade > 0 && k \u003c= S.oldAt) {\n        const o = S.ks[S.mapOld * 588 + k];\n        cell(x, y, o ? lit : miss, (o ? 0.9 : 0.2) * S.fade * S.fade);\n      }\n      cell(x, y, c, a);\n    }\n  // The current vowel row, marked at both sides.\n  for (const x of [1, 2, 61, 62]) add(x, MY + 2 * floor(at / 28), pale, 0.7);\n\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(min(255, F[o])), round(min(255, F[o + 1])), round(min(255, F[o + 2])));\n}\n","wilkinson-polynomial":"// ===== Patternflow pattern =====\n// Title:   Wilkinson's Polynomial\n// Family:  algo\n// Idea:    The twenty roots of (x - 1)(x - 2)...(x - 20) stand up the panel as beads, and as a change in the x^19 coefficient sweeps on a log scale up past Wilkinson's 2^-23 and back, the upper ten meet in pairs and fly apart sideways into the complex plane leaving arcs, inside a sparkling nebula of everywhere a root can be pushed by nudging every coefficient a little, whose bright core fills a fifth of the panel while the roots sit on the integers and shrinks to specks once they have split.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Wilkinson's polynomial (James H. Wilkinson, 1959; \"The perfidious polynomial\", 1984), the Ehrlich-Aberth simultaneous root iteration (Louis W. Ehrlich, 1967; Oliver Aberth, 1973), pseudozero sets (Ronald G. Mosier, 1986; Kim-Chuan Toh and Lloyd N. Trefethen, 1994), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phase=0..1, Cloud=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the arcs and cloud dots run from purple at root 1 to rose at root 20 and the nebula is blue at its edge and cyan in its core; at 0.33 the arcs are yellow to green on a red and magenta nebula, at 0.66 cyan to blue on green and amber.\n// Knob 2: Speed. At 2 the change climbs from 2^-35 to 2^-21 in 6 seconds and comes back down in 6, lingering at both ends; at 0.2 a round takes two minutes, at 3 eight seconds.\n// Knob 3: Phase. Which way the change pushes, as a turn of the complex plane: a_19 becomes -210 - eps e^(2 pi i Phase). At 0 it is Wilkinson's: roots 16 and 17 meet first, at eps = 1.42e-10, then 14 and 15, 18 and 19, 12 and 13, and 10 and 11 at 1.91e-8, so at 2^-23 there are five pairs, the widest 16.73 +- 2.81i. At 0.5 eps pushes the other way and the neighbours change partners: 15 and 16 meet first, then 17-18, 13-14, 19-20, 11-12, and 9-10 just past 2^-23. At 0.25 and 0.75 eps is imaginary, there are no conjugate pairs, and no two roots come closer than 0.91: they peel off the axis one by one, alternately to the left and to the right.\n// Knob 4: Cloud. delta, the size of the random relative nudges given to every coefficient below the top one, from 2^-45 at 0 to 2^-39 at 1; at the start 2^-44.6, about 330 times the rounding error of a double. There, with the roots on the integers, the dots of roots 13 to 16 land up to 1.7 away while root 5 moves 1e-4 and root 1 1e-11, and the delta set the clouds stay inside covers 19% of the panel; at 2^-23 it covers 2.4%. At 1 it covers 46% at the bottom of the sweep and still 45% at 2^-23.\n// Buttons: K1 tap eases the change to exactly 2^-23 and holds it there for three seconds. K3 tap moves the change one power down, x^19, x^18 and on to the constant term 20!, then x^19 again: the roots first go home, then the sweep starts over on the new coefficient, scaled so that it pushes its most sensitive root as hard as 2^-23 pushes root 16; at x^0 the pairs run from 3-4 to 17-18.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, exp, log2, cos, sin, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = () => Math.random();\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The plane: the real axis runs up the panel, RY rows to a unit, with\n// Re = RE0 at the bottom edge, so root k sits on the middle of row\n// 123 - 6 (k - 1); the imaginary axis runs across, CX columns to a unit,\n// with Im = 0 on the middle of column 31.\nconst RY = 6, RE0 = 0.25, CX = 9, XC = 31.5;\nconst toX = (im) => XC + im * CX, toY = (re) => H - (re - RE0) * RY;\n\n// The coefficients a_j of p(x) = (x - 1)...(x - 20), lowest first: a_19 =\n// -210, a_0 = 20!. In doubles a_3 to a_7 are already rounded, which is\n// harmless here: they only scale the nudges and the level below.\nconst A = new Float64Array(21);\nA[0] = 1;\nfor (let k = 1; k \u003c= 20; k++) for (let j = k; j >= 0; j--) A[j] = (j ? A[j - 1] : 0) - k * A[j];\nconst AB = A.map(abs);\n// SENS[k]: the largest first-order shift a relative change of a_k gives any\n// root, |a_k| r^k / |p'(r)| at its worst r (root 16 for a_19, root 10 for\n// a_0). A K3 tap moves the change to another power, scaled by these.\nconst SENS = new Float64Array(20);\nfor (let k = 0; k \u003c 20; k++)\n  for (let r = 1; r \u003c= 20; r++) {\n    let d = 1;\n    for (let j = 1; j \u003c= 20; j++) if (j !== r) d *= abs(r - j);\n    SENS[k] = max(SENS[k], (AB[k] * r ** k) / d);\n  }\n\n// The sweep runs log2 of the change from LO to HI and back, easing at both\n// ends. At LO every root is within 0.07 of home (root 16 the farthest, under\n// half a row); at HI root 20 is at 21.39 and the widest pair at\n// 16.77 +- 3.49i, inside the panel's 31 columns either side.\nconst LO = -35, HI = -21, WILK = -23;\n\n// The Ehrlich-Aberth iteration for all roots of p(z) + sum C_j z^j, j \u003c 20,\n// at once, from the starting points in Z (re, im pairs), at most `iters`\n// sweeps, roots with index below `from` held where they are. p and p' come\n// from the product form, which stays accurate next to the roots where the\n// expanded coefficients would cancel to nothing. Run from rest with eps =\n// 2^-23 it gives Wilkinson's table to nine places: 1 to 4 to the last\n// digit, 4.999999928, 6.000006944, 6.999697234, 8.007267603, 8.917250249,\n// 10.095266145 +- 0.643500904i, 11.793633881 +- 1.652329728i,\n// 13.992358137 +- 2.518830070i, 16.730737466 +- 2.812624894i,\n// 19.502439400 +- 1.940330347i and 20.846908101. STEP[i] keeps each root's\n// last step squared.\nconst STEP = new Float64Array(20);\nfunction aberth(Z, Cr, Ci, iters, from) {\n  let big = 0;\n  for (let it = 0; it \u003c iters; it++) {\n    big = 0;\n    for (let i = from; i \u003c 20; i++) {\n      const zr = Z[2 * i], zi = Z[2 * i + 1];\n      let pr = 1, pi = 0, dr = 0, di = 0;\n      for (let k = 1; k \u003c= 20; k++) {\n        const ur = zr - k;\n        const t = dr * ur - di * zi + pr;\n        di = dr * zi + di * ur + pi;\n        dr = t;\n        const s = pr * ur - pi * zi;\n        pi = pr * zi + pi * ur;\n        pr = s;\n      }\n      let qr = 0, qi = 0, er = 0, ei = 0;\n      for (let j = 19; j >= 0; j--) {\n        const t = er * zr - ei * zi + qr;\n        ei = er * zi + ei * zr + qi;\n        er = t;\n        const s = qr * zr - qi * zi + Cr[j];\n        qi = qr * zi + qi * zr + Ci[j];\n        qr = s;\n      }\n      const fr = pr + qr, fi = pi + qi, gr = dr + er, gi = di + ei;\n      let m = gr * gr + gi * gi;\n      if (!(m > 0)) continue;\n      const wr = (fr * gr + fi * gi) / m, wi = (fi * gr - fr * gi) / m;\n      let ar = 0, ai = 0;\n      for (let j = 0; j \u003c 20; j++)\n        if (j !== i) {\n          const xr = zr - Z[2 * j], xi = zi - Z[2 * j + 1], mm = xr * xr + xi * xi;\n          if (mm > 0) (ar += xr / mm), (ai -= xi / mm);\n        }\n      const br = 1 - (wr * ar - wi * ai), bi = -(wr * ai + wi * ar);\n      m = br * br + bi * bi;\n      if (!(m > 0)) continue;\n      const sr = (wr * br + wi * bi) / m, si = (wi * br - wr * bi) / m;\n      Z[2 * i] -= sr;\n      Z[2 * i + 1] -= si;\n      const st = sr * sr + si * si;\n      STEP[i] = st;\n      if (st > big) big = st;\n    }\n    if (big \u003c 1e-24) break;\n  }\n  return big;\n}\n\n// A real polynomial keeps real iterates real, so a root that is on the\n// axis gets a tiny imaginary part, alternating up the axis, before each\n// solve: two roots that meet can then leave the axis in opposite ways.\nconst ORD = [];\nfunction seed(Z) {\n  ORD.length = 0;\n  for (let i = 0; i \u003c 20; i++) ORD.push(i);\n  ORD.sort((a, b) => Z[2 * a] - Z[2 * b]);\n  for (let k = 0; k \u003c 20; k++) {\n    const i = ORD[k];\n    if (abs(Z[2 * i + 1]) \u003c 1e-9) Z[2 * i + 1] = k & 1 ? 1e-9 : -1e-9;\n  }\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  const Z = new Float64Array(40);\n  for (let i = 0; i \u003c 20; i++) Z[2 * i] = i + 1;\n  params.s = {\n    ph: 0.17, e2: LO, pow: 19, pk: 19, hold: 0, warm: 0,\n    Z, Zo: new Float64Array(40), Zw: new Float64Array(40),\n    Cr: new Float64Array(20), Ci: new Float64Array(20), Br: new Float64Array(20), Bi: new Float64Array(20),\n    TI: F(N), TC: new Uint8Array(N), CR: F(N), CG: F(N), CB: F(N), DR: F(N), DG: F(N), DB: F(N),\n    R: F(N), G: F(N), B: F(N), pal: F(60), col: F(3), hue: 0, ld: -45, th: 0,\n  };\n}\n\n// Trails: each root draws the segment it moved along this frame into TI as\n// a line about three LEDs wide, each LED it touches at its own brightness\n// between 0.6 and 1 of the line's, keeping the brighter of that and what\n// is there. Trails fade over three and a half seconds.\nfunction trail(S, x0, y0, x1, y1, c) {\n  const n = max(1, Math.ceil(2 * hypot(x1 - x0, y1 - y0)));\n  if (n > 200) return;\n  for (let s = 0; s \u003c= n; s++) {\n    const x = x0 + ((x1 - x0) * s) / n, y = y0 + ((y1 - y0) * s) / n;\n    for (let yy = floor(y - 2); yy \u003c= y + 1; yy++)\n      for (let xx = floor(x - 2); xx \u003c= x + 1; xx++) {\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const w = (1 - hypot(xx + 0.5 - x, yy + 0.5 - y) / 1.7) * (0.6 + 0.4 * rnd()), p = yy * W + xx;\n        if (w > S.TI[p]) (S.TI[p] = w), (S.TC[p] = c);\n      }\n  }\n}\n\nfunction splat(R, G, B, x, y, r, g, b) {\n  const ix = floor(x - 0.5), iy = floor(y - 0.5), ax = x - 0.5 - ix, ay = y - 0.5 - iy;\n  for (let q = 0; q \u003c 4; q++) {\n    const xx = ix + (q & 1), yy = iy + (q >> 1);\n    if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n    const w = (q & 1 ? ax : 1 - ax) * (q >> 1 ? ay : 1 - ay), p = yy * W + xx;\n    R[p] += w * r, G[p] += w * g, B[p] += w * b;\n  }\n}\n\n// The change: a_k, k = S.pk, becomes a_k + sign(a_k) eps e^(2 pi i th),\n// so with k = 19 and th = 0 it is Wilkinson's -210 - eps, eps = 2^e2. For\n// another k, eps is scaled by |a_k| SENS[19] / (210 SENS[k]).\nfunction perturb(S) {\n  const k = S.pk, a = 2 * PI * S.th, e = 2 ** S.e2 * (AB[k] / 210) * (SENS[19] / SENS[k]) * Math.sign(A[k]);\n  S.Cr.fill(0), S.Ci.fill(0);\n  S.Cr[k] = e * cos(a);\n  S.Ci[k] = e * sin(a);\n}\n\nfunction step(S, d, sp, clouds) {\n  // A K3 tap first takes the change back down to LO, where every root is\n  // home, then moves it to the next power and starts the sweep again from\n  // the bottom. K1's hold stops the sweep and eases the change to 2^-23.\n  // Either way the change moves at most ten octaves a second.\n  let to;\n  if (S.pk !== S.pow) {\n    to = LO;\n    if (S.e2 \u003c LO + 0.3) (S.pk = S.pow), (S.ph = 0);\n  } else if (S.hold > 0) (S.hold -= d), (to = WILK);\n  else {\n    S.ph += (d * sp) / 24;\n    to = LO + ((HI - LO) * (1 - cos(2 * PI * S.ph))) / 2;\n  }\n  S.e2 += cl(to - S.e2, -10 * d, 10 * d);\n  perturb(S);\n  const { Z, Zo } = S;\n  Zo.set(Z);\n  seed(Z);\n  aberth(Z, S.Cr, S.Ci, 40, 0);\n  for (let i = 0; i \u003c 40; i++) if (!Number.isFinite(Z[i])) Z.set(Zo), (i = 40);\n  for (let i = 0; i \u003c 20; i++) trail(S, toX(Zo[2 * i + 1]), toY(Zo[2 * i]), toX(Z[2 * i + 1]), toY(Z[2 * i]), i);\n  if (clouds) cloud(S, clouds);\n}\n\n// Clouds: eight times a frame, every coefficient below the top one of the\n// current polynomial is also multiplied by 1 + delta u_j, u_j uniform in\n// [-1, 1], and all twenty roots are solved again from the current ones.\n// Each root whose last step was under 1e-4 lands as a dot of its root's\n// colour and its own brightness, and fades over two seconds. With 24\n// sweeps 99.9% land even with the roots on the integers, where the\n// nudged copies are hardest.\nfunction cloud(S, n) {\n  const { Z, Zw, Br, Bi, Cr, Ci, CR, CG, CB, pal } = S, dl = 2 ** S.ld;\n  for (let m = 0; m \u003c n; m++) {\n    for (let j = 0; j \u003c 20; j++) (Br[j] = Cr[j] + dl * (2 * rnd() - 1) * A[j]), (Bi[j] = Ci[j]);\n    Zw.set(Z);\n    seed(Zw);\n    aberth(Zw, Br, Bi, 24, 0);\n    for (let i = 0; i \u003c 20; i++) {\n      if (!(STEP[i] \u003c= 1e-8)) continue;\n      const w = 0.25 + 0.75 * rnd();\n      const x = floor(toX(Zw[2 * i + 1])), y = floor(toY(Zw[2 * i]));\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = y * W + x;\n      (CR[q] = w * pal[3 * i]), (CG[q] = w * pal[3 * i + 1]), (CB[q] = w * pal[3 * i + 2]);\n    }\n  }\n}\n\n// The nebula. z is a root of some polynomial whose coefficients below the\n// top one differ from the current ones by at most a share delta each\n// exactly when |p(z) + C(z)| \u003c= delta sum |a_j| |z|^j (Mosier 1986), so\n// L = log2 of the ratio is the smallest such delta, in octaves. Each frame\n// 1200 LEDs picked at random take a grain for a random point inside them:\n// in the delta set (L \u003c ld) a grain lights with a chance up to 70% and up\n// to full brightness, in the 16 delta and 256 delta sets around it the\n// chance and the brightness fall off to 20% and 65, and the colour runs\n// from cyan in the core to blue at the edge. Beyond 256 delta the grains\n// stay under 25, the LEDs' threshold, and take any colour. Grains fade over\n// three seconds.\nfunction dust(S, n) {\n  const { Cr, Ci, DR, DG, DB, col } = S;\n  for (let m = 0; m \u003c n; m++) {\n    const p = floor(rnd() * N), x = (p & 63) + rnd(), y = (p >> 6) + rnd();\n    const zr = RE0 + (H - y) / RY, zi = (x - XC) / CX;\n    let pr = 1, pi = 0;\n    for (let j = 1; j \u003c= 20; j++) {\n      const ur = zr - j, s = pr * ur - pi * zi;\n      pi = pr * zi + pi * ur;\n      pr = s;\n    }\n    // Plus the perturbation, and sum |a_j| |z|^j.\n    let qr = 0, qi = 0;\n    for (let j = 19; j >= 0; j--) {\n      const s = qr * zr - qi * zi + Cr[j];\n      qi = qr * zi + qi * zr + Ci[j];\n      qr = s;\n    }\n    (pr += qr), (pi += qi);\n    const r = hypot(zr, zi);\n    let sum = 0;\n    for (let j = 19; j >= 0; j--) sum = sum * r + AB[j];\n    const L = log2(hypot(pr, pi) / sum + 1e-300), depth = S.ld - L, q = cl((depth + 8) / 14, 0, 1);\n    hsv(S.hue + 0.68 - 0.2 * q, 0.8, 1, col, 0);\n    if (depth > -8) {\n      const v = rnd() \u003c 0.2 + 0.5 * q ? 25 + (40 + 190 * q) * rnd() : 24.9 * rnd(), w = 0.4 * rnd();\n      DR[p] = v * (col[0] + w * (1 - col[0])), DG[p] = v * (col[1] + w * (1 - col[1])), DB[p] = v * (col[2] + w * (1 - col[2]));\n    } else (DR[p] = 24.99 * rnd()), (DG[p] = 24.99 * rnd()), (DB[p] = 24.99 * rnd());\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const sp = cl(kv[1], 0.2, 3);\n  S.th = cl(kv[2], 0, 1);\n  S.ld = -45 + 6 * cl(kv[3], 0, 1);\n  for (let i = 0; i \u003c 20; i++) hsv(S.hue + 0.8 + (0.17 * i) / 19, 0.75, 1, S.pal, 3 * i);\n  const p = input.btnPressed || [];\n  if (p[0]) S.hold = 3;\n  if (p[2]) S.pow = S.pow ? S.pow - 1 : 19;\n  // The roots are walked up from home to the sweep's opening place, 2^-31.4,\n  // and the first second and a half is run before the first frame, so the\n  // first pairs have left the axis and drawn their arcs; at Speed 2, 2^-23\n  // then comes at 1 s and the top at 2.5 s.\n  if (!S.warm) {\n    S.warm = 1;\n    const u = (1 - cos(2 * PI * S.ph)) / 2, e0 = LO + (HI - LO) * u;\n    for (let e = LO; e \u003c e0; e += 0.25) (S.e2 = min(e, e0)), perturb(S), seed(S.Z), aberth(S.Z, S.Cr, S.Ci, 40, 0);\n    S.e2 = e0;\n    for (let i = 0; i \u003c 45; i++) step(S, 1 / 30, sp, i > 30 ? 4 : 0), fade(S, 1 / 30), dust(S, 900);\n  }\n  step(S, d, sp, 8);\n  fade(S, d);\n  dust(S, 1200);\n}\n\nfunction fade(S, d) {\n  const ft = exp(-d / 3.5), fc = exp(-d / 2), fd = exp(-d / 3);\n  const { TI, CR, CG, CB, DR, DG, DB } = S;\n  for (let p = 0; p \u003c N; p++) {\n    TI[p] *= ft;\n    CR[p] *= fc, CG[p] *= fc, CB[p] *= fc;\n    DR[p] *= fd, DG[p] *= fd, DB[p] *= fd;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.warm) return;\n  const { TI, TC, CR, CG, CB, DR, DG, DB, R, G, B, pal, Z } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const ti = TI[p], c = 3 * TC[p], tv = ti > 0.02 ? 190 * ti : 0;\n    R[p] = DR[p] + tv * pal[c] + 235 * CR[p];\n    G[p] = DG[p] + tv * pal[c + 1] + 235 * CG[p];\n    B[p] = DB[p] + tv * pal[c + 2] + 235 * CB[p];\n  }\n  // The integers 1 to 20 marked on both edges, longer at every fifth.\n  for (let k = 1; k \u003c= 20; k++) {\n    const y = 123 - 6 * (k - 1), l = k % 5 ? 2 : 3;\n    for (let x = 0; x \u003c l; x++) for (const xx of [x, 63 - x]) (R[y * W + xx] += 30), (G[y * W + xx] += 34), (B[y * W + xx] += 40);\n  }\n  for (let i = 0; i \u003c 20; i++) {\n    const x = toX(Z[2 * i + 1]), y = toY(Z[2 * i]), c = 3 * i;\n    splat(R, G, B, x, y, 160 + 300 * pal[c], 160 + 300 * pal[c + 1], 160 + 300 * pal[c + 2]);\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, cl(R[p], 0, 255) | 0, cl(G[p], 0, 255) | 0, cl(B[p], 0, 255) | 0);\n}\n","zermelo-navigation":"// ===== Patternflow pattern =====\n// Title:   Zermelo Navigation\n// Family:  line\n// Idea:    A harbour at the foot of the panel sends out, twice a second, the front of every place a boat rowing at one speed could have reached by then, and the fronts climb the whole panel bent by a current of eddies or a wandering jet, fold into corners where two ways round meet, string beads along the thin quickest routes to six places, and stop at hatched shadows where water pours in from beyond the panel faster than any boat can row.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Zermelo's navigation problem (Ernst Zermelo, 1931), arrival times by Dijkstra's algorithm (Edsger Dijkstra, 1959) on a 32-heading stencil, pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Current=0..2.5, Shape=0..1, Harbour=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together: at 0 a front leaves the harbour gold, turns green halfway and reaches the far coast blue, and the shadows are rose.\n// Knob 2: Current. The fastest water, in boat speeds. At 0 the fronts are circles and the routes straight lines; up to 1 every LED is reached, at any shape, harbour and moment; past 1 shadows open, at Shape 0 on 1.6% of the panel at 1.5, 5.5% at 2 (the opening) and 11.5% at 2.5.\n// Knob 3: Shape. Three eddies at 0, two on the left side and one on the right, and at 1 a jet leaving the coast at the bottom centre that wanders more as it climbs; between, both at part strength. With the harbour inside a jet faster than the boat the fronts become teardrops carried up the jet, and at first only a cone above the harbour is reached: at Shape 1 and Current 2 the water there runs at 1.99 boat speeds and the cone's half-angle is asin(1 / 1.99) = 30 degrees.\n// Knob 4: Harbour. Where the harbour stands on the coast, from column 8 at -1 to column 56 at 1. At Shape 0 the shadows do not move with it, the same 448 LEDs at Current 2 wherever it stands, since they belong to the current and the panel's edges.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, sin, cos, round, PI, cosh } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst INF = 1e9;\nconst HY = 121; // the harbour's row\nconst RATE = 18; // the boat's speed in LEDs per second\nconst GAP = 9; // a new front every GAP / RATE seconds\nconst SOLVE = 20; // frames over which one field of arrival times is solved\nconst NP = 240; // tracers in the water\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The stencil: every step (a, b) with |a|, |b| \u003c= 3 and gcd 1, 32 headings.\n// The widest gap between headings is 18.4 degrees, so in still water a\n// stencil path is at most 1 / cos(9.2 deg) - 1 = 1.3% longer than the\n// straight line; measured over the panel it is 0.66% on average.\nconst SA = [], SB = [], SL = [], SUX = [], SUY = [];\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\nfor (let a = -3; a \u003c= 3; a++)\n  for (let b = -3; b \u003c= 3; b++)\n    if ((a || b) && gcd(abs(a), abs(b)) === 1) {\n      const l = sqrt(a * a + b * b);\n      SA.push(a); SB.push(b); SL.push(l); SUX.push(a / l); SUY.push(b / l);\n    }\nconst ND = SA.length;\n\n// Ground speed along unit heading u in current w, the boat rowing at 1:\n// s solves |s u - w| = 1, s = u.w + sqrt(1 - |w|^2 + (u.w)^2). Returns the\n// time per unit length, or INF when no heading of the boat makes way along\n// u. While |w| \u003c 1 every u makes way; past 1 only a cone around w does.\nfunction slow(wx, wy, ux, uy) {\n  const d = ux * wx + uy * wy, disc = 1 - wx * wx - wy * wy + d * d;\n  if (disc \u003c 0) return INF;\n  const s = d + sqrt(disc);\n  return s > 1e-4 ? 1 / s : INF;\n}\n\n// The current at (x, y) in LEDs, in boat speeds. Both parts come from a\n// stream function psi, w = (dpsi/dy, -dpsi/dx), so no water is made or lost\n// inside the panel; it only comes in and goes out through the edges.\nfunction current(F, x, y, out) {\n  let wx = 0, wy = 0;\n  if (F.ge) {\n    // Gaussian eddies, psi = G exp(-r^2 / 2R^2) with R = 13 and G = S R\n    // sqrt(e), so the fastest water, at r = R, runs at S. Their centres sit\n    // 4 LEDs inside the sides, and the half of each that reaches past the\n    // edge brings water in through it.\n    const R2 = 169;\n    for (let k = 0; k \u003c 9; k += 3) {\n      const dx = x - F.E[k], dy = y - F.E[k + 1], e = (F.E[k + 2] * F.ge * exp(-(dx * dx + dy * dy) / (2 * R2))) / R2;\n      wx -= dy * e;\n      wy += dx * e;\n    }\n  }\n  if (F.gj) {\n    // A jet leaving the coast at the bottom centre, wandering more as it\n    // climbs: psi = J L tanh((x - X(y)) / L), X = 32 + A(y) sin(k y + phase).\n    const L = 13, k = (2 * PI) / 52, A = 9 * (1 - y / H), ph = k * y + F.th;\n    const X = 32 + A * sin(ph), dX = (-9 / H) * sin(ph) + A * k * cos(ph), c = 1 / cosh((x - X) / L), j = F.gj * c * c;\n    wx -= j * dX;\n    wy -= j;\n  }\n  out[0] = wx;\n  out[1] = wy;\n}\n\n// Where the quickest routes go: the top corners, two places on the far\n// coast and one on each side halfway up.\nconst TARGETS = [4, 2, 22, 1, 42, 1, 60, 2, 2, 62, 62, 62];\n\nexport function setup(params) {\n  params.s = {\n    WX: new Float32Array(N), WY: new Float32Array(N), Tn: new Float32Array(N), pred: new Int32Array(N),\n    done: new Uint8Array(N), pos: new Int32Array(N), hp: new Int32Array(N), hn: 0,\n    Ta: new Float32Array(N), Tb: new Float32Array(N), T: new Float32Array(N), DWX: new Float32Array(N), DWY: new Float32Array(N),\n    ra: 120, rb: 120, routes: [], fade: 1, solving: false, src: 0, t: 0, tau: 0, started: false,\n    px: new Float32Array(NP), py: new Float32Array(NP), pa: new Float32Array(NP),\n    rgb: new Float32Array(N * 3), lut: new Float32Array(65 * 3), sh: new Float32Array(3), hue: 0,\n    F: { ge: 0, gj: 0, th: 0, hx: 32, E: new Float32Array(9) }, w: [0, 0],\n  };\n  return params.s;\n}\n\n// An indexed binary heap keyed on Tn, so a node's key can drop in place.\nfunction up(S, i, v) {\n  const hp = S.hp, pos = S.pos, T = S.Tn, key = T[v];\n  while (i > 0) {\n    const p = (i - 1) >> 1, pv = hp[p];\n    if (T[pv] \u003c= key) break;\n    hp[i] = pv;\n    pos[pv] = i;\n    i = p;\n  }\n  hp[i] = v;\n  pos[v] = i;\n}\n\nfunction pop(S) {\n  const hp = S.hp, pos = S.pos, T = S.Tn, top = hp[0];\n  pos[top] = -1;\n  const n = --S.hn;\n  if (n > 0) {\n    const last = hp[n], key = T[last];\n    let i = 0;\n    for (;;) {\n      let c = 2 * i + 1;\n      if (c >= n) break;\n      if (c + 1 \u003c n && T[hp[c + 1]] \u003c T[hp[c]]) c++;\n      if (T[hp[c]] >= key) break;\n      hp[i] = hp[c];\n      pos[hp[i]] = i;\n      i = c;\n    }\n    hp[i] = last;\n    pos[last] = i;\n  }\n  return top;\n}\n\n// Start a solve for the knobs and the clock `at` seconds: the eddies ride\n// small circles and the jet's meander travels up it, once in 40 s.\nfunction begin(S, kv, at) {\n  const F = S.F, th = (at * 2 * PI) / 40, cur = cl(kv[1] ?? 2, 0, 2.5), m = cl(kv[2] || 0, 0, 1);\n  F.th = th;\n  F.ge = cur * 13 * 1.6487 * (1 - m);\n  F.gj = cur * m;\n  F.hx = 32 + 24 * cl(kv[3] ?? 0.06, -1, 1);\n  const E = F.E;\n  E[0] = 4 + 3 * sin(th); E[1] = 88 + 3 * cos(th); E[2] = 1;\n  E[3] = 60 - 3 * sin(th + 2); E[4] = 57 + 4 * cos(th + 2); E[5] = -1;\n  E[6] = 4 + 3 * sin(th + 4); E[7] = 26 + 4 * cos(th + 4); E[8] = 1;\n  const w = S.w;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      current(F, x + 0.5, y + 0.5, w);\n      S.WX[y * W + x] = w[0];\n      S.WY[y * W + x] = w[1];\n    }\n  S.Tn.fill(INF);\n  S.done.fill(0);\n  S.pos.fill(-1);\n  S.hn = 0;\n  const src = (S.src = HY * W + round(F.hx));\n  S.Tn[src] = 0;\n  S.pred[src] = -1;\n  up(S, S.hn++, src);\n  S.solving = true;\n}\n\n// Dijkstra over the stencil, settling at most `budget` LEDs. A step is\n// rowed in the mean of the currents at its two ends, and a step along which\n// no heading makes way in that current is not taken. The mean of the two\n// ends' slowness was tried first: it shut every step with either end too\n// fast to row along, and the opening's shadow shrank as the grid was made\n// finer, 756 LEDs on the LED grid and 472 on a grid four times finer. With\n// the mean current it is 441 and 444, and the arrival times of the two\n// grids differ by 0.69% at the median.\nfunction work(S, budget) {\n  const T = S.Tn, WX = S.WX, WY = S.WY, done = S.done, pred = S.pred, pos = S.pos;\n  while (S.hn > 0 && budget-- > 0) {\n    const u = pop(S);\n    done[u] = 1;\n    const ux = u % W, uy = (u - ux) / W, tu = T[u], wx = WX[u], wy = WY[u];\n    for (let k = 0; k \u003c ND; k++) {\n      const vx = ux + SA[k], vy = uy + SB[k];\n      if (vx \u003c 0 || vx >= W || vy \u003c 0 || vy >= H) continue;\n      const v = vy * W + vx;\n      if (done[v]) continue;\n      const a = slow(0.5 * (wx + WX[v]), 0.5 * (wy + WY[v]), SUX[k], SUY[k]);\n      if (a >= INF) continue;\n      const tv = tu + SL[k] * a;\n      if (tv \u003c T[v]) {\n        T[v] = tv;\n        pred[v] = u;\n        up(S, pos[v] >= 0 ? pos[v] : S.hn++, v);\n      }\n    }\n  }\n  return S.hn === 0;\n}\n\n// A solved field becomes the one faded in; the routes are traced back from\n// each target along the steps that reached it, and the colour scale is set\n// by the mean time to the far coast.\nfunction finish(S) {\n  // A lone LED left unreached among reached ones is the stencil's doing, not\n  // the current's (51 of 1,713 shadows over 45 settings, never wider than\n  // one LED): it takes the mean of its four neighbours.\n  const Tn = S.Tn;\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const i = y * W + x;\n      if (Tn[i] \u003c INF || Tn[i - 1] >= INF || Tn[i + 1] >= INF || Tn[i - W] >= INF || Tn[i + W] >= INF) continue;\n      Tn[i] = (Tn[i - 1] + Tn[i + 1] + Tn[i - W] + Tn[i + W]) / 4;\n      S.pred[i] = i - 1;\n    }\n  S.Ta.set(S.Tb);\n  S.Tb.set(S.Tn);\n  S.DWX.set(S.WX);\n  S.DWY.set(S.WY);\n  S.fade = 0;\n  S.solving = false;\n  S.routes = [];\n  for (let k = 0; k \u003c TARGETS.length; k += 2) {\n    let v = TARGETS[k + 1] * W + TARGETS[k];\n    if (S.Tn[v] >= INF) continue;\n    const path = [];\n    for (; v >= 0 && path.length \u003c N; v = S.pred[v]) path.push(v);\n    S.routes.push(path);\n  }\n  let sum = 0, n = 0;\n  for (let x = 0; x \u003c W; x++)\n    if (S.Tn[x] \u003c INF) {\n      sum += S.Tn[x];\n      n++;\n    }\n  S.ra = S.rb;\n  S.rb = n ? max(40, sum / n) : 120;\n}\n\nfunction spawn(S, i) {\n  S.px[i] = Math.random() * W;\n  S.py[i] = Math.random() * H;\n  S.pa[i] = 0;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.t += d;\n  S.tau += d * RATE;\n  if (!S.started) {\n    // The first field is solved whole, and fronts have been leaving the\n    // harbour for ever, so the panel opens full.\n    S.started = true;\n    begin(S, kv, S.t);\n    work(S, N);\n    finish(S);\n    S.Ta.set(S.Tb);\n    S.ra = S.rb;\n    S.fade = 1;\n    for (let i = 0; i \u003c NP; i++) {\n      spawn(S, i);\n      S.pa[i] = Math.random() * 3;\n    }\n  }\n  // Then one field is solved every SOLVE frames, a slice per frame, for the\n  // knobs as they are and the clock when it will be shown, and fades in.\n  if (!S.solving) begin(S, kv, S.t + SOLVE / 30);\n  if (work(S, Math.ceil(N / SOLVE))) finish(S);\n  S.fade = min(1, S.fade + 1 / SOLVE);\n  for (let i = 0; i \u003c NP; i++) {\n    const c = (S.py[i] | 0) * W + (S.px[i] | 0);\n    S.px[i] += S.DWX[c] * RATE * d;\n    S.py[i] += S.DWY[c] * RATE * d;\n    S.pa[i] += d;\n    if (S.px[i] \u003c 0 || S.px[i] >= W || S.py[i] \u003c 0 || S.py[i] >= H || S.pa[i] > 3) spawn(S, i);\n  }\n}\n\nfunction put(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  if (rgb[o] \u003c r) rgb[o] = r;\n  if (rgb[o + 1] \u003c g) rgb[o + 1] = g;\n  if (rgb[o + 2] \u003c b) rgb[o + 2] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const rgb = S.rgb, Ta = S.Ta, Tb = S.Tb, a = S.fade, tau = S.tau, T = S.T, lut = S.lut, sh = S.sh;\n  rgb.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const p = Ta[i], q = Tb[i];\n    T[i] = p >= INF || q >= INF ? (a \u003c 0.5 ? p : q) : p + (q - p) * a;\n  }\n  // Front colours by arrival time over the time to the far coast.\n  for (let k = 0; k \u003c= 64; k++) hsv(S.hue + 0.13 + (0.55 * k) / 64, 1, 1, lut, k * 3);\n  const sc = 64 / (S.ra + (S.rb - S.ra) * a);\n  hsv(S.hue + 0.92, 0.75, 1, sh, 0);\n  // The current: short pale streaks drifting with the water.\n  for (let i = 0; i \u003c NP; i++) {\n    const x = S.px[i], y = S.py[i], o = (y | 0) * W + (x | 0), wx = S.DWX[o], wy = S.DWY[o];\n    const f = min(1, S.pa[i] * 2, (3 - S.pa[i]) * 2), n = wx * wx + wy * wy \u003c 0.09 ? 1 : 3;\n    for (let k = 0; k \u003c n; k++) {\n      const v = f * (75 - 20 * k);\n      put(rgb, floor(x - wx * k * 0.9), floor(y - wy * k * 0.9), v * 0.6, v * 0.75, v);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, t = T[i], o = i * 3;\n      const l = x > 0 ? T[i - 1] : INF, r = x \u003c W - 1 ? T[i + 1] : INF, u = y > 0 ? T[i - W] : INF, dn = y \u003c H - 1 ? T[i + W] : INF;\n      if (t >= INF) {\n        // The shadow: no heading of the boat ever gets here. Hatched, with\n        // its rim lit.\n        const v = l \u003c INF || r \u003c INF || u \u003c INF || dn \u003c INF ? 0.55 : (x + y) % 4 === 0 ? 0.32 : 0;\n        if (v) {\n          rgb[o] = max(rgb[o], sh[0] * v);\n          rgb[o + 1] = max(rgb[o + 1], sh[1] * v);\n          rgb[o + 2] = max(rgb[o + 2], sh[2] * v);\n        }\n        continue;\n      }\n      // Distance to the nearest front in LEDs from the slope of T, taken\n      // as the steeper side so a fold does not smear.\n      const gx = max(l \u003c INF ? t - l : 0, r \u003c INF ? r - t : 0, l \u003c INF ? l - t : 0, r \u003c INF ? t - r : 0);\n      const gy = max(u \u003c INF ? t - u : 0, dn \u003c INF ? dn - t : 0, u \u003c INF ? u - t : 0, dn \u003c INF ? t - dn : 0);\n      const g = max(0.25, sqrt(gx * gx + gy * gy));\n      const q = (tau - t) / GAP, f = q - floor(q), dl = (min(f, 1 - f) * GAP) / g, behind = (f * GAP) / g;\n      // A line on the front and a short glow on the harbour side of it.\n      // Where the boats barely make way the fronts crowd together; from 3.5\n      // LEDs apart down to 1.5 they melt into a steady dim glow rather than\n      // shimmer.\n      const line = dl \u003c 1.1 ? 1 - dl / 1.1 : 0, tail = behind \u003c 9 ? 0.16 * exp(-behind / 2.5) : 0;\n      const sp = cl((GAP / g - 1.5) / 2, 0, 1), v = max(line, tail) * sp + 0.12 * (1 - sp);\n      if (v \u003c= 0.01) continue;\n      const c = min(64, (t * sc) | 0) * 3;\n      rgb[o] = max(rgb[o], lut[c] * v);\n      rgb[o + 1] = max(rgb[o + 1], lut[c + 1] * v);\n      rgb[o + 2] = max(rgb[o + 2], lut[c + 2] * v);\n    }\n  // The quickest routes, and a bead where each front crosses one: the\n  // place on the front that route's boat has got to.\n  for (const path of S.routes)\n    for (let k = 1; k \u003c path.length; k++) {\n      const p0 = path[k - 1], p1 = path[k];\n      const x0 = p0 % W, y0 = (p0 / W) | 0, x1 = p1 % W, y1 = (p1 / W) | 0, n = max(abs(x1 - x0), abs(y1 - y0));\n      for (let j = 0; j \u003c n; j++) put(rgb, round(x0 + ((x1 - x0) * j) / n), round(y0 + ((y1 - y0) * j) / n), 95, 95, 105);\n      const t0 = T[p0], t1 = T[p1], lv = tau - GAP * Math.ceil((tau - t0) / GAP);\n      if (t0 > t1 && lv >= t1) {\n        const s = (lv - t1) / (t0 - t1);\n        put(rgb, round(x1 + (x0 - x1) * s), round(y1 + (y0 - y1) * s), 255, 255, 255);\n      }\n    }\n  const hx = S.src % W;\n  for (let dy = -1; dy \u003c= 1; dy++)\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const v = dx || dy ? 120 : 255;\n      put(rgb, hx + dx, HY + dy, v, v, v);\n    }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, (i / W) | 0, min(255, rgb[o]) | 0, min(255, rgb[o + 1]) | 0, min(255, rgb[o + 2]) | 0);\n  }\n}\n","anamorphosis":"// ===== Patternflow pattern =====\n// Title:   Anamorphosis\n// Family:  type\n// Idea:    A word is painted across slabs, boxes and pillars floating at many depths, as if thrown on them by a projector at one point of view, and the camera swings round the cluster so the coloured fragments scatter and slide past one another, closing up into the word only in the moment it passes that point.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: anamorphic painting from one point of view (Hans Holbein the Younger, The Ambassadors, 1533; Felice Varini's wall paintings), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Flatten=0..1\n//\n// Knob 1: Hue. Turns the letter colours round the wheel together. Each letter keeps its own colour, evenly spaced, so the letters of a word are as far apart in hue as they can be: at 0 HERE is sky blue, violet, orange and green.\n// Knob 2: Speed. The camera flies a figure eight round the cluster, out to 52 degrees either side and 17 degrees up and down, and crosses the point of view at its middle. At 2 it crosses at 4 s and then every 8 s, slowing there to a quarter of its pace, so the word stands whole for about a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Word. HERE, NOW, LOOK, 여기 (here) and 지금 (now), stacked down the panel a letter or a syllable at a time.\n// Knob 4: Flatten. At 0 the thirteen pieces of the first cut (eight slabs, four boxes and a pillar) stand from 5.4 to 14.6 units from the point of view, each scaled by its distance so it fills its own rectangle of the picture there, and every fragment slides its own way once the camera leaves. Turned up they gather onto one plane 10 units away, the middle of the cluster, and at 1 the word is a flat sign that reads, foreshortened, from anywhere.\n// Buttons: K1 tap cuts the picture into a new set of pieces.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst F = 116; // focal length in LEDs, the same for the camera and the point of view\nconst DV = 10; // the point of view V stands at (0, 0, DV) and looks down -z at the origin\nconst YF = -8.6; // the floor\nconst MW = 128, MH = 256; // the word is drawn into V's picture at twice the panel's resolution\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Glyphs as strokes in a unit box, y down: L a line, A an elliptic arc\n// (centre, radii, start and end angle in degrees, clockwise on screen).\nconst GLYPHS = {\n  H: [[\"L\", 0, 0, 0, 1], [\"L\", 1, 0, 1, 1], [\"L\", 0, 0.5, 1, 0.5]],\n  E: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 0, 1, 0], [\"L\", 0, 0.5, 0.82, 0.5], [\"L\", 0, 1, 1, 1]],\n  R: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 0, 0.66, 0], [\"A\", 0.66, 0.27, 0.34, 0.27, -90, 90], [\"L\", 0, 0.54, 0.66, 0.54], [\"L\", 0.5, 0.54, 1, 1]],\n  N: [[\"L\", 0, 1, 0, 0], [\"L\", 0, 0, 1, 1], [\"L\", 1, 1, 1, 0]],\n  O: [[\"A\", 0.5, 0.5, 0.5, 0.5, 0, 360]],\n  W: [[\"L\", 0, 0, 0.22, 1], [\"L\", 0.22, 1, 0.5, 0.25], [\"L\", 0.5, 0.25, 0.78, 1], [\"L\", 0.78, 1, 1, 0]],\n  L: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 1, 1, 1]],\n  K: [[\"L\", 0, 0, 0, 1], [\"L\", 1, 0, 0.08, 0.6], [\"L\", 0.36, 0.42, 1, 1]],\n  // Hangul syllables drawn whole, each in a square box.\n  \"여\": [[\"A\", 0.27, 0.5, 0.25, 0.3, 0, 360], [\"L\", 0.86, 0, 0.86, 1], [\"L\", 0.6, 0.33, 0.86, 0.33], [\"L\", 0.6, 0.67, 0.86, 0.67]],\n  \"기\": [[\"L\", 0.02, 0.1, 0.56, 0.1], [\"L\", 0.56, 0.1, 0.5, 0.92], [\"L\", 0.88, 0, 0.88, 1]],\n  \"지\": [[\"L\", 0.04, 0.1, 0.62, 0.1], [\"L\", 0.36, 0.1, 0.04, 0.9], [\"L\", 0.36, 0.4, 0.64, 0.9], [\"L\", 0.9, 0, 0.9, 1]],\n  \"금\": [[\"L\", 0.12, 0, 0.86, 0], [\"L\", 0.86, 0, 0.86, 0.3], [\"L\", 0, 0.48, 1, 0.48], [\"L\", 0.16, 0.68, 0.84, 0.68], [\"L\", 0.16, 0.68, 0.16, 1], [\"L\", 0.84, 0.68, 0.84, 1], [\"L\", 0.16, 1, 0.84, 1]],\n};\nconst WORDS = [[\"H\", \"E\", \"R\", \"E\"], [\"N\", \"O\", \"W\"], [\"L\", \"O\", \"O\", \"K\"], [\"여\", \"기\"], [\"지\", \"금\"]];\n\nfunction segDist(px, py, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - s[0]) * dx + (py - s[1]) * dy) / l, 0, 1) : 0;\n  const ex = s[0] + t * dx - px, ey = s[1] + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// The word in V's picture: coverage 0..1 and the letter each texel belongs to.\nconst hitS = new Uint8Array(MW * MH * 4);\nfunction buildWord(wi) {\n  const word = WORDS[wi], n = word.length, hangul = wi >= 3;\n  const S = MW / W; // texels per LED\n  const margin = 3, gap = hangul ? 5 : n === 4 ? 4 : 5;\n  const ch = (H - 2 * margin - (n - 1) * gap) / n, cw = 60;\n  const pen = hangul ? 7.4 : n === 4 ? 7.2 : 8.4;\n  const mask = new Float32Array(MW * MH), id = new Uint8Array(MW * MH);\n  for (let k = 0; k \u003c n; k++) {\n    const x0 = (W - cw) / 2, y0 = margin + k * (ch + gap), hw = pen / 2;\n    const sx = cw - pen, sy = ch - pen;\n    const segs = [];\n    for (const st of GLYPHS[word[k]]) {\n      const P = (u, v) => [(x0 + hw + u * sx) * S, (y0 + hw + v * sy) * S];\n      if (st[0] === \"L\") segs.push([...P(st[1], st[2]), ...P(st[3], st[4])]);\n      else {\n        const [, cx, cy, rx, ry, a0, a1] = st, m = max(4, Math.ceil(abs(a1 - a0) / 10));\n        for (let i = 0; i \u003c m; i++) {\n          const b0 = ((a0 + ((a1 - a0) * i) / m) * PI) / 180, b1 = ((a0 + ((a1 - a0) * (i + 1)) / m) * PI) / 180;\n          segs.push([...P(cx + rx * cos(b0), cy + ry * sin(b0)), ...P(cx + rx * cos(b1), cy + ry * sin(b1))]);\n        }\n      }\n    }\n    // Each stroke marks the samples within half a pen of it, two by two to a\n    // texel, then the texels count their marked samples.\n    const r = hw * S, SW = MW * 2;\n    const ty0 = max(0, floor((y0 - 1) * S)), ty1 = min(MH, Math.ceil((y0 + ch + 1) * S));\n    hitS.fill(0, ty0 * 2 * SW, ty1 * 2 * SW);\n    for (const sg of segs) {\n      const xa = max(0, floor((min(sg[0], sg[2]) - r) * 2)), xb = min(SW - 1, Math.ceil((max(sg[0], sg[2]) + r) * 2));\n      const ya = max(0, floor((min(sg[1], sg[3]) - r) * 2)), yb = min(MH * 2 - 1, Math.ceil((max(sg[1], sg[3]) + r) * 2));\n      for (let y = ya; y \u003c= yb; y++)\n        for (let x = xa; x \u003c= xb; x++) if (!hitS[y * SW + x] && segDist((x + 0.5) / 2, (y + 0.5) / 2, sg) \u003c= r) hitS[y * SW + x] = 1;\n    }\n    for (let y = ty0; y \u003c ty1; y++)\n      for (let x = 0; x \u003c MW; x++) {\n        const o = y * 2 * SW + x * 2, hit = hitS[o] + hitS[o + 1] + hitS[o + SW] + hitS[o + SW + 1];\n        if (hit) {\n          mask[y * MW + x] = hit / 4;\n          id[y * MW + x] = k;\n        }\n      }\n  }\n  return { mask, id, n };\n}\n\n// V's picture cut into rectangles, each the front face of one piece.\nfunction cutCells(random) {\n  const cells = [];\n  const cut = (x0, y0, x1, y1, d) => {\n    const w = x1 - x0, h = y1 - y0;\n    if (d > 0 && (w * h \u003c 700 || (w * h \u003c 1300 && random() \u003c 0.4) || d > 5)) {\n      cells.push([x0, y0, x1, y1]);\n      return;\n    }\n    const vert = h > 1.7 * w ? false : w > 1.4 * h ? true : random() \u003c 0.5;\n    const u = 0.32 + 0.36 * random();\n    if (vert) {\n      const xm = round(x0 + w * u);\n      cut(x0, y0, xm, y1, d + 1);\n      cut(xm, y0, x1, y1, d + 1);\n    } else {\n      const ym = round(y0 + h * u);\n      cut(x0, y0, x1, ym, d + 1);\n      cut(x0, ym, x1, y1, d + 1);\n    }\n  };\n  cut(0, 0, W, H, 0);\n  // Depths evenly spread, then shuffled, so near and far pieces mix.\n  const n = cells.length, rank = [];\n  for (let i = 0; i \u003c n; i++) rank.push(-1 + (2 * (i + 0.5)) / n);\n  for (let i = n - 1; i > 0; i--) {\n    const j = floor(random() * (i + 1)), t = rank[i];\n    rank[i] = rank[j];\n    rank[j] = t;\n  }\n  return cells.map((c, i) => ({ c, r: rank[i], kind: c[3] - c[1] > 2.2 * (c[2] - c[0]) ? 2 : random() \u003c 0.45 ? 0 : 1 }));\n}\n\n// World boxes from the cells for a given flatness: a piece at distance d\n// from V is scaled by d so its front face fills its cell exactly from V.\nfunction buildBoxes(S) {\n  const spread = 0.5 * (1 - S.flat);\n  S.boxes = S.cells.map(({ c, r, kind }) => {\n    const d = DV * (1 + spread * r);\n    const x0 = ((c[0] - 32) * d) / F, x1 = ((c[2] - 32) * d) / F;\n    const y0 = ((64 - c[3]) * d) / F, y1 = ((64 - c[1]) * d) / F;\n    const zf = DV - d, w = x1 - x0, h = y1 - y0;\n    // 0 a slab, 1 a box as deep as its short side, 2 a pillar as deep as it is wide.\n    const th = kind === 0 ? 0.14 : kind === 1 ? min(w, h) : w;\n    return [x0, y0, zf - th, x1, y1, zf];\n  });\n  S.vr = new Float32Array(S.boxes.length * 4);\n  S.cr = new Float32Array(S.boxes.length * 4);\n  rects(S.boxes, 0, 0, DV, [0, 0, -1], [1, 0, 0], [0, 1, 0], S.vr);\n}\n\n// Each box's bounding rectangle on the screen of a camera, so a ray only\n// tests the boxes whose rectangle holds its LED.\nfunction rects(boxes, ox, oy, oz, fw, rt, up, out) {\n  for (let i = 0; i \u003c boxes.length; i++) {\n    const b = boxes[i];\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (let c = 0; c \u003c 8; c++) {\n      const X = b[c & 1 ? 3 : 0] - ox, Y = b[c & 2 ? 4 : 1] - oy, Z = b[c & 4 ? 5 : 2] - oz;\n      const z = X * fw[0] + Y * fw[1] + Z * fw[2];\n      if (z \u003c 0.05) { x0 = y0 = -1e9; x1 = y1 = 1e9; break; }\n      const sx = 32 + (F * (X * rt[0] + Y * rt[1] + Z * rt[2])) / z, sy = 64 - (F * (X * up[0] + Y * up[1] + Z * up[2])) / z;\n      x0 = min(x0, sx); x1 = max(x1, sx); y0 = min(y0, sy); y1 = max(y1, sy);\n    }\n    out[i * 4] = x0 - 1; out[i * 4 + 1] = x1 + 1; out[i * 4 + 2] = y0 - 1; out[i * 4 + 3] = y1 + 1;\n  }\n}\n\n// A fixed generator, so the pieces stand where they were looked at; a K1 tap\n// gives it a new seed.\nfunction generator(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\nconst SEED = 7;\n\nexport function setup(params) {\n  params.s = {\n    cells: cutCells(generator(SEED)), boxes: [], vr: null, cr: null, flat: -1, word: -1, words: {}, w: null,\n    p: -0.25, hue: 0, cam: [0, 0, DV], fw: [0, 0, -1], rt: [1, 0, 0], up: [0, 1, 0],\n    hit: { t: 0, b: -1, ax: 0 }, col: [0, 0, 0], pal: new Float32Array(12),\n  };\n}\n\nconst T_LOOP = 16; // seconds for the whole figure eight at Speed 2\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  const speed = cl(kv[1], 0.2, 3);\n  const wi = cl(round(kv[2]), 0, WORDS.length - 1);\n  if (wi !== S.word) {\n    S.word = wi;\n    S.w = S.words[wi] || (S.words[wi] = buildWord(wi));\n  }\n  const flat = cl(kv[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.cells = cutCells(generator(floor(random() * 4294967296)));\n    S.flat = -1;\n  }\n  if (abs(flat - S.flat) > 1e-4) {\n    S.flat = flat;\n    buildBoxes(S);\n  }\n  S.p += (d * speed) / 2 / T_LOOP;\n  // A figure eight through V, slowed to a quarter of its pace there.\n  const tau = 2 * PI * S.p, ts = tau - 0.375 * sin(2 * tau);\n  const th = (52 * PI * sin(ts)) / 180, ph = (17 * PI * sin(2 * ts)) / 180;\n  const r = DV * (1 - 0.16 * sin(ts) * sin(ts));\n  const cam = S.cam;\n  cam[0] = r * cos(ph) * sin(th);\n  cam[1] = r * sin(ph);\n  cam[2] = r * cos(ph) * cos(th);\n  const l = sqrt(cam[0] * cam[0] + cam[1] * cam[1] + cam[2] * cam[2]);\n  const fw = S.fw, rt = S.rt, up = S.up;\n  fw[0] = -cam[0] / l; fw[1] = -cam[1] / l; fw[2] = -cam[2] / l;\n  // right = forward x world up, up = right x forward\n  const rl = sqrt(fw[2] * fw[2] + fw[0] * fw[0]);\n  rt[0] = -fw[2] / rl; rt[1] = 0; rt[2] = fw[0] / rl;\n  up[0] = rt[1] * fw[2] - rt[2] * fw[1];\n  up[1] = rt[2] * fw[0] - rt[0] * fw[2];\n  up[2] = rt[0] * fw[1] - rt[1] * fw[0];\n  rects(S.boxes, cam[0], cam[1], cam[2], fw, rt, up, S.cr);\n}\n\n// The nearest box along o + t d for 0 \u003c t \u003c tmax, testing only the boxes\n// whose screen rectangle in rc holds (sx, sy); fills h.\nfunction trace(boxes, rc, sx, sy, ox, oy, oz, dx, dy, dz, tmax, h) {\n  const ix = 1 / (abs(dx) \u003c 1e-9 ? 1e-9 : dx), iy = 1 / (abs(dy) \u003c 1e-9 ? 1e-9 : dy), iz = 1 / (abs(dz) \u003c 1e-9 ? 1e-9 : dz);\n  let best = tmax, bi = -1, bax = 0;\n  for (let i = 0; i \u003c boxes.length; i++) {\n    if (sx \u003c rc[i * 4] || sx > rc[i * 4 + 1] || sy \u003c rc[i * 4 + 2] || sy > rc[i * 4 + 3]) continue;\n    const b = boxes[i];\n    let t0 = (b[0] - ox) * ix, t1 = (b[3] - ox) * ix;\n    if (t0 > t1) { const q = t0; t0 = t1; t1 = q; }\n    let a0 = (b[1] - oy) * iy, a1 = (b[4] - oy) * iy;\n    if (a0 > a1) { const q = a0; a0 = a1; a1 = q; }\n    let c0 = (b[2] - oz) * iz, c1 = (b[5] - oz) * iz;\n    if (c0 > c1) { const q = c0; c0 = c1; c1 = q; }\n    let tn = t0, ax = 0;\n    if (a0 > tn) { tn = a0; ax = 1; }\n    if (c0 > tn) { tn = c0; ax = 2; }\n    const tf = min(t1, a1, c1);\n    if (tn > 1e-6 && tn \u003c= tf && tn \u003c best) { best = tn; bi = i; bax = ax; }\n  }\n  h.t = best; h.b = bi; h.ax = bax;\n  return bi;\n}\n\nconst LX = 0.42, LY = 0.78, LZ = 0.46; // light from above, right and in front\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.w) return;\n  const { boxes, cam, fw, rt, up, hit, col, pal } = S, wd = S.w, mask = wd.mask, ids = wd.id;\n  for (let k = 0; k \u003c wd.n; k++) {\n    hsv(S.hue + 0.55 + k / wd.n, 1, 1, col);\n    pal[k * 3] = col[0]; pal[k * 3 + 1] = col[1]; pal[k * 3 + 2] = col[2];\n  }\n  const ox = cam[0], oy = cam[1], oz = cam[2];\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const sx = px + 0.5 - 32, sy = 64 - py - 0.5;\n      const dx = fw[0] * F + rt[0] * sx + up[0] * sy;\n      const dy = fw[1] * F + rt[1] * sx + up[1] * sy;\n      const dz = fw[2] * F + rt[2] * sx + up[2] * sy;\n      let r = 0, g = 0, b = 0;\n      const tf = dy \u003c 0 ? (YF - oy) / dy : 1e9;\n      trace(boxes, S.cr, px + 0.5, py + 0.5, ox, oy, oz, dx, dy, dz, tf, hit);\n      const dl = sqrt(dx * dx + dy * dy + dz * dz), foot = (hit.t * dl) / F; // world size of one LED there\n      if (hit.b >= 0) {\n        const B = boxes[hit.b], t = hit.t, ax = hit.ax;\n        const X = ox + t * dx, Y = oy + t * dy, Z = oz + t * dz;\n        const dd = ax === 0 ? dx : ax === 1 ? dy : dz, sg = dd > 0 ? -1 : 1;\n        const lam = max(0, sg * (ax === 0 ? LX : ax === 1 ? LY : LZ));\n        // Where V sees this point: its place in V's picture, and whether\n        // anything stands between it and V.\n        let paint = 0, pk = 0;\n        const depth = DV - Z;\n        if (depth > 0.1) {\n          const u = 32 + (F * X) / depth, v = 64 - (F * Y) / depth;\n          const mx = u * 2 - 0.5, my = v * 2 - 0.5;\n          if (mx >= 0 && my >= 0 && mx \u003c MW - 1 && my \u003c MH - 1) {\n            const ix = floor(mx), iy = floor(my), fx = mx - ix, fy = my - iy, o = iy * MW + ix;\n            const m = (mask[o] * (1 - fx) + mask[o + 1] * fx) * (1 - fy) + (mask[o + MW] * (1 - fx) + mask[o + MW + 1] * fx) * fy;\n            if (m > 0.02) {\n              pk = ids[mask[o] > 0 ? o : mask[o + 1] > 0 ? o + 1 : mask[o + MW] > 0 ? o + MW : o + MW + 1];\n              const vx = X, vy = Y, vz = Z - DV;\n              if (trace(boxes, S.vr, u, v, 0, 0, DV, vx, vy, vz, 1 - 1e-3, hit) \u003c 0) paint = m;\n            }\n          }\n        }\n        // The surface: dim slate, lit from one side, its edges drawn faintly.\n        let e;\n        if (ax === 0) e = min(Y - B[1], B[4] - Y, Z - B[2], B[5] - Z);\n        else if (ax === 1) e = min(X - B[0], B[3] - X, Z - B[2], B[5] - Z);\n        else e = min(X - B[0], B[3] - X, Y - B[1], B[4] - Y);\n        const edge = cl(1 - e / (0.9 * foot), 0, 1);\n        const base = 0.13 + 0.17 * lam + 0.2 * edge * (1 - paint);\n        r = base * 0.86; g = base * 0.93; b = base * 1.12;\n        if (paint > 0) {\n          const pv = min(1, 0.8 + 0.45 * lam);\n          r += (pal[pk * 3] * pv - r) * paint;\n          g += (pal[pk * 3 + 1] * pv - g) * paint;\n          b += (pal[pk * 3 + 2] * pv - b) * paint;\n        }\n      } else if (tf \u003c 1e9) {\n        // The floor: a faint grid one unit square.\n        const X = ox + tf * dx, Z = oz + tf * dz, fo = (tf * dl) / F;\n        const gx = abs(X - round(X)), gz = abs(Z - round(Z));\n        const ln = cl(1 - min(gx, gz) / max(0.02, 0.8 * fo), 0, 1) * cl(1.6 - fo * 5, 0, 1);\n        const fade = cl(1 - (X * X + Z * Z) / 260, 0, 1);\n        r = g = b = (0.03 + 0.14 * ln) * fade;\n        b *= 1.25;\n      }\n      display.setPixel(px, py, floor(cl(r, 0, 1) * 255), floor(cl(g, 0, 1) * 255), floor(cl(b, 0, 1) * 255));\n    }\n}\n","foam-coarsening":"// ===== Patternflow pattern =====\n// Title:   Foam Coarsening\n// Family:  cells\n// Idea:    A fine two-dimensional foam coarsens by Potts-model Monte Carlo on the panel, every cell coloured by how many neighbours it has, so the cells with fewer than six sides glow one colour and shrink away with a spark while the cells with more than six glow the far colour and swell, whatever their size, as von Neumann's law says; when only a fraction of the cells are left a new fine foam is laid down from the top.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: von Neumann's law for two-dimensional foams (John von Neumann, 1952), grain-boundary motion (W. W. Mullins, 1956), Potts-model grain growth (M. P. Anderson, D. J. Srolovitz, G. S. Grest and P. S. Sahni, 1984), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Noise=0..1\n//\n// Knob 1: Hue. Turns the side-count colours round the wheel together. At 0 a six-sided cell is cyan, the shrinking five-, four- and three-sided cells go green, lime and orange, and the growing seven-, eight- and nine-sided cells blue, violet and pink.\n// Knob 2: Speed. Monte Carlo sweeps a second, 3.5 at 2 for the finest foam. At the start knobs the 640 seeds leave 608 cells once two sweeps have rounded their walls, and the first new foam comes down after 7.0 s, then one every 8.2 s; at 3 every 5.4 s, at 0.2 every 79 s. A coarser foam gets more sweeps, as the square root of its cell size, since its cells take longer to die.\n// Knob 3: Size. How many cells a new foam is laid down with: 640 at 0, 12.8 LEDs each, down to 60 at 1, 137 LEDs each, evenly in the logarithm between. A foam is laid anew when fewer than 45% of its cells are left: every 8.2 s at 0, 19 s at 0.5 and 32 s at 1, at Speed 2.\n// Knob 4: Noise. The temperature of the Monte Carlo, from 0.12 to 1.22 of a bond. Low, the walls are smooth arcs that slide; high, they shiver and roughen, a cell can lose a corner and win it back, and the foam coarsens faster, a new one every 6.6 s at 1.\n\n// In a two-dimensional foam the walls meet three at a time at 120 degrees\n// and each wall moves toward its centre of curvature at a speed set by its\n// curvature. Add up the turning round a cell with n sides: the walls must\n// turn through 2 pi, the corners take n times pi / 3 of it, so the walls'\n// curvature sums to (pi / 3)(6 - n), and the area changes as\n// dA/dt = kappa (n - 6), independent of the cell's size (von Neumann 1952 for\n// soap froth, Mullins 1956 for grain boundaries). A five-sided cell shrinks\n// even when it is the biggest on the panel.\n//\n// The panel runs the large-Q Potts model the way Anderson, Srolovitz, Grest\n// and Sahni grew grains in 1984: every LED holds the number of its grain,\n// a bond between unlike neighbours costs one, and a Monte Carlo step offers\n// an LED the grain of one of its eight neighbours and takes it when the cost\n// does not rise, or with exp(-rise / T) when it does. The grid is a torus,\n// so no cell touches a wall of the panel's own.\n//\n// Checked by running this file's own update at the start knobs for 300 s,\n// the side counts read every half second and the frames with a front left\n// out (two cells are neighbours when one LED face parts them). Grouped by n,\n// the mean dA/dt in LEDs a second is -3.15 for four sides, -1.50 for five,\n// 0.20 for six, 2.05 for seven, 3.92 for eight, 5.62 for nine and 7.31 for\n// ten. The line through them is 1.77 (n - 5.85), r^2 0.9997, which at 3.5\n// sweeps a second is 0.51 LEDs a sweep for each side. Three-sided cells\n// shrink at only 2.52: they are a few LEDs across, too small for the lattice\n// to bend their walls. The mean side count is 5.87; a lattice cannot draw\n// every short wall, so it stays under the 6 Euler's formula gives a torus.\n\nconst W = 64, H = 128, N = W * H, MAXG = 2048, SHIFT = 11;\nconst { floor, min, exp, sqrt, abs, round, random, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Moore neighbours on the torus: right, left, down, up, then the corners.\nconst NB = new Int32Array(N * 8);\nconst DX = [1, -1, 0, 0, 1, -1, 1, -1], DY = [0, 0, 1, -1, 1, 1, -1, -1];\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++)\n    for (let k = 0; k \u003c 8; k++) NB[(y * W + x) * 8 + k] = ((y + DY[k] + H) % H) * W + ((x + DX[k] + W) % W);\n\nconst FRESH = 640, FEWEST = 60, LEFT = 0.45;\nconst SPARK = 0.35;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  out[1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  out[2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n}\n\nexport function setup(params) {\n  params.s = {\n    g: new Int32Array(N), area: new Int32Array(MAXG), sides: new Uint8Array(MAXG), shown: new Float32Array(MAXG),\n    keys: new Int32Array(N * 2), list: new Int32Array(FRESH),\n    alive: 0, C: 0, laid: 0, debt: 0, T: -1, boltz: new Float32Array(9),\n    front: -1, sx: null, sy: null, sid: null,\n    sparks: [], hue: 0, speed: 2, c: [0, 0, 0], palette: new Float32Array(13 * 3), first: true,\n  };\n}\n\n// The grain of the nearest new seed to an LED centre, on the torus. Only\n// the seeds in a band of rows round it are tried: the band is three seed\n// spacings each way, and a Poisson foam leaves a disc that wide empty about\n// once in 10^12 tries.\nfunction band(S, y) {\n  const { sy } = S, R = 3 * sqrt(N / sy.length) + 2, list = S.list;\n  let m = 0;\n  for (let i = 0; i \u003c sy.length; i++) {\n    let dy = abs(y - sy[i]);\n    if (dy > H / 2) dy = H - dy;\n    if (dy \u003c= R) list[m++] = i;\n  }\n  return m;\n}\n\nfunction nearest(S, x, y, m) {\n  const { sx, sy, sid, list } = S;\n  let best = 1e9, id = sid[0];\n  for (let j = 0; j \u003c m; j++) {\n    const i = list[j];\n    let dx = abs(x - sx[i]), dy = abs(y - sy[i]);\n    if (dx > W / 2) dx = W - dx;\n    if (dy > H / 2) dy = H - dy;\n    const d = dx * dx + dy * dy;\n    if (d \u003c best) (best = d), (id = sid[i]);\n  }\n  return id;\n}\n\n// Seeds for a new Poisson Voronoi foam, each with a grain number no LED holds.\nfunction newSeeds(S, count) {\n  const { area } = S;\n  const sx = new Float32Array(count), sy = new Float32Array(count), sid = new Int32Array(count);\n  let next = 0;\n  for (let i = 0; i \u003c count; i++) {\n    while (area[next] > 0) next++;\n    S.shown[next] = 99;\n    sid[i] = next++;\n    sx[i] = random() * W;\n    sy[i] = random() * H;\n  }\n  S.sx = sx;\n  S.sy = sy;\n  S.sid = sid;\n}\n\nfunction give(S, i, id) {\n  const { g, area } = S, old = g[i];\n  if (old === id) return;\n  if (--area[old] === 0) S.alive--;\n  if (area[id]++ === 0) S.alive++;\n  g[i] = id;\n}\n\nfunction layRow(S, y) {\n  const m = band(S, y + 0.5);\n  for (let x = 0; x \u003c W; x++) give(S, y * W + x, nearest(S, x + 0.5, y + 0.5, m));\n}\n\nfunction layAll(S) {\n  const { g, area } = S;\n  area.fill(0);\n  newSeeds(S, S.C);\n  for (let y = 0; y \u003c H; y++) {\n    const m = band(S, y + 0.5);\n    for (let x = 0; x \u003c W; x++) {\n      const id = nearest(S, x + 0.5, y + 0.5, m);\n      g[y * W + x] = id;\n      area[id]++;\n    }\n  }\n  S.alive = 0;\n  for (let i = 0; i \u003c MAXG; i++) if (area[i] > 0) S.alive++;\n  S.laid = S.C;\n  for (let i = 0; i \u003c MAXG; i++) S.shown[i] = 0;\n}\n\n// Monte Carlo attempts: an LED is offered one neighbour's grain.\nfunction steps(S, count) {\n  const { g, area, boltz, sparks } = S;\n  for (let a = 0; a \u003c count; a++) {\n    const i = (random() * N) | 0, o = i * 8;\n    const b = g[NB[o + ((random() * 8) | 0)]], c = g[i];\n    if (b === c) continue;\n    let rise = 0;\n    for (let k = 0; k \u003c 8; k++) {\n      const q = g[NB[o + k]];\n      if (q === c) rise++;\n      else if (q === b) rise--;\n    }\n    if (rise > 0 && random() >= boltz[rise]) continue;\n    g[i] = b;\n    area[b]++;\n    if (--area[c] === 0) {\n      S.alive--;\n      if (sparks.length \u003c 64) sparks.push({ x: i % W, y: (i / W) | 0, life: SPARK });\n    }\n  }\n}\n\n// The side count of every grain: grains are neighbours when one LED face\n// parts them. Pairs are packed into one integer, sorted and counted once.\nfunction countSides(S) {\n  const { g, keys, sides } = S;\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const a = g[i], r = g[NB[i * 8]], d = g[NB[i * 8 + 2]];\n    if (r !== a) keys[m++] = a \u003c r ? (a \u003c\u003c SHIFT) | r : (r \u003c\u003c SHIFT) | a;\n    if (d !== a) keys[m++] = a \u003c d ? (a \u003c\u003c SHIFT) | d : (d \u003c\u003c SHIFT) | a;\n  }\n  const pairs = keys.subarray(0, m).sort();\n  sides.fill(0);\n  let prev = -1;\n  for (let j = 0; j \u003c m; j++) {\n    const k = pairs[j];\n    if (k === prev) continue;\n    prev = k;\n    sides[k >> SHIFT]++;\n    sides[k & (MAXG - 1)]++;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.C = round(FRESH * pow(FEWEST / FRESH, cl(kv[2], 0, 1)));\n  const T = 0.12 + 1.1 * cl(kv[3], 0, 1);\n  if (T !== S.T) {\n    S.T = T;\n    for (let k = 0; k \u003c 9; k++) S.boltz[k] = exp(-k / T);\n  }\n  if (S.first) {\n    S.first = false;\n    layAll(S);\n    steps(S, 2 * N);\n    countSides(S);\n    for (let i = 0; i \u003c MAXG; i++) S.shown[i] = S.sides[i] - 6;\n  }\n\n  // A new foam comes down from the top as a front, row by row.\n  if (S.front \u003c 0 && (S.alive \u003c LEFT * S.laid || abs(S.C - S.laid) > 0.25 * S.laid)) {\n    newSeeds(S, S.C);\n    S.laid = S.C;\n    S.front = 0;\n  }\n  if (S.front >= 0) {\n    const to = min(H, S.front + (d * S.speed * H) / 2.4);\n    for (let y = floor(S.front); y \u003c floor(to); y++) layRow(S, y);\n    S.front = to >= H ? -1 : to;\n  }\n\n  // Sweeps a second, faster for a coarse foam so its cells still come and go.\n  const rate = 1.75 * S.speed * sqrt(FRESH / S.laid);\n  S.debt += rate * d * N;\n  const n = floor(S.debt);\n  S.debt -= n;\n  steps(S, n);\n  countSides(S);\n\n  const ease = min(1, d * 8);\n  for (let i = 0; i \u003c MAXG; i++) {\n    if (S.area[i] === 0) continue;\n    const want = cl(S.sides[i] - 6, -3, 3);\n    // A grain just laid takes its colour at once.\n    S.shown[i] = S.shown[i] > 50 ? want : S.shown[i] + (want - S.shown[i]) * ease;\n  }\n  for (const s of S.sparks) s.life -= d * S.speed * 0.5;\n  S.sparks = S.sparks.filter((s) => s.life > 0);\n\n  // Thirteen colours for n - 6 from -3 to 3 in half steps.\n  for (let j = 0; j \u003c 13; j++) {\n    const v = j / 2 - 3;\n    hsv(S.hue + 0.5 + 0.13 * v, v === 0 ? 0.45 : 0.9, v === 0 ? 0.85 : 1, S.c);\n    S.palette[j * 3] = S.c[0];\n    S.palette[j * 3 + 1] = S.c[1];\n    S.palette[j * 3 + 2] = S.c[2];\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.first) return;\n  const { g, shown, palette } = S;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, a = g[i];\n      // A wall is the LED whose right or lower neighbour is another grain.\n      if (g[NB[i * 8]] !== a || g[NB[i * 8 + 2]] !== a) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const j = round((shown[a] + 3) * 2) * 3;\n      display.setPixel(x, y, palette[j], palette[j + 1], palette[j + 2]);\n    }\n  // A cell that has just shrunk away flashes white where it closed.\n  for (const s of S.sparks) {\n    const v = 255 * (s.life / SPARK);\n    display.setPixel(s.x, s.y, v, v, v);\n    if (s.life > SPARK / 2) {\n      const u = v * 0.45;\n      display.setPixel((s.x + 1) % W, s.y, u, u, u);\n      display.setPixel((s.x + W - 1) % W, s.y, u, u, u);\n      display.setPixel(s.x, (s.y + 1) % H, u, u, u);\n      display.setPixel(s.x, (s.y + H - 1) % H, u, u, u);\n    }\n  }\n}\n","hunminjeongeum":"// ===== Patternflow pattern =====\n// Title:   Hunminjeongeum\n// Family:  type\n// Idea:    The letter-making chapter of the Hunminjeongeum Haerye grows down the panel as a family tree: the five basic consonants are drawn, each column copies its letter one step down and adds a stroke that lights up as it is drawn (ㄱ to ㅋ, ㄴ to ㄷ to ㅌ, ㅁ to ㅂ to ㅍ, ㅅ to ㅈ to ㅊ, ㅇ to ㆆ to ㅎ), the three letters of a different body (ㆁ, ㄹ, ㅿ) fade in apart, and below them the dot of heaven, the line of earth and the line of man fly together into the eight vowels.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Jejahae, the chapter on how the letters were made, in the Hunminjeongeum Haerye (King Sejong; Jeong In-ji and seven scholars, 1446), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Style=0..1, Weight=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the strokes a letter takes over are warm gold, the stroke it adds and the vowels' dots are cyan, a stroke being drawn glows near white, and the three letters of a different body are lilac.\n// Knob 2: Speed. At 2 the eight basic letters are drawn stroke by stroke in the first 1.3 s, the second row of each tree grows from 1.05 s, the third from 2.1 s, and the odd three fade in from 3.3 s; from 4.5 s a glow runs down the trees every 2.5 s, and at 15 s everything but the basic letters fades and grows again. At 0.2 ten times slower; at 3 one and a half times faster.\n// Knob 3: Style. 0 is the Haerye's own letterforms of 1446: geometric strokes of one weight, ㅇ a circle, the vowels' dots round and apart from their stem, ㅅ an even pair of legs, a short upright tick on ㅊ and ㅎ, in a warm ink. Turning it moves them to today's forms: the dots stretch into short strokes off the stem, the right leg of ㅅ, ㅈ and ㅊ starts from the middle of the left, the ticks lie flat, the ink cools to white, and the four letters no longer used (ㆍ, ㆁ, ㆆ, ㅿ) fade to an eighth.\n// Knob 4: Weight. The stroke, from 1.5 LED at 0 (1.6 at the opening 0.06) to 3.3 LED at 1; the dots stay rounder than the stroke and grow less.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, exp, atan2, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// Strokes in a unit box, y down. C is a capsule from (x0, y0) to (x1, y1)\n// with r times the pen's half width, and a second set of numbers gives\n// today's form where it differs; a dot is a capsule of length 0 and a large\n// r. O is a ring (centre, radius). A stroke with \"from\" is taken over from\n// another letter, [letter, stroke]; one with add: 1 is the stroke this letter\n// adds; acc: 1 is drawn in the accent colour.\nconst C = (x0, y0, x1, y1, o = {}) => ({ ...o, k: \"C\", h: [x0, y0, x1, y1, o.r || 1], m: o.m ? [...o.m, o.mr || 1] : [x0, y0, x1, y1, o.mr || o.r || 1] });\nconst O = (cx, cy, r, o = {}) => ({ ...o, k: \"O\", h: [cx, cy, r] });\nconst DOT = 2.1;\n\n// The letters: name, place (column, row, area) and strokes. The consonant\n// tree has five columns and three rows; the odd three sit in their own row;\n// the vowels have the three basic letters on one row and the eight made from\n// them on two rows of four.\nconst L = {};\nconst def = (id, area, col, row, lev, strokes, extra = {}) => (L[id] = { id, area, col, row, lev, strokes, ...extra });\n// Consonants, the Jejahae's five shapes: the tongue root closing the throat,\n// the tongue touching the upper gum, the mouth, a tooth, the throat.\ndef(\"ㄱ\", \"c\", 0, 0, 0, [C(0.12, 0.15, 0.86, 0.15), C(0.86, 0.15, 0.86, 0.9)]);\ndef(\"ㄴ\", \"c\", 1, 0, 0, [C(0.15, 0.1, 0.15, 0.85), C(0.15, 0.85, 0.9, 0.85)]);\ndef(\"ㅁ\", \"c\", 2, 0, 0, [C(0.15, 0.15, 0.15, 0.85), C(0.15, 0.15, 0.85, 0.15), C(0.85, 0.15, 0.85, 0.85), C(0.15, 0.85, 0.85, 0.85)]);\ndef(\"ㅅ\", \"c\", 3, 0, 0, [C(0.5, 0.12, 0.1, 0.88), C(0.5, 0.12, 0.9, 0.88, { m: [0.31, 0.5, 0.88, 0.88] })]);\ndef(\"ㅇ\", \"c\", 4, 0, 0, [O(0.5, 0.5, 0.37)]);\n// Each stroke louder by one: ㄱ to ㅋ, ㄴ to ㄷ to ㅌ, ㅁ to ㅂ to ㅍ,\n// ㅅ to ㅈ to ㅊ, ㅇ to ㆆ to ㅎ.\ndef(\"ㅋ\", \"c\", 0, 1, 1, [C(0.12, 0.15, 0.86, 0.15, { from: [\"ㄱ\", 0] }), C(0.86, 0.15, 0.86, 0.9, { from: [\"ㄱ\", 1] }), C(0.12, 0.52, 0.86, 0.52, { add: 1 })]);\ndef(\"ㄷ\", \"c\", 1, 1, 1, [C(0.15, 0.15, 0.15, 0.85, { from: [\"ㄴ\", 0] }), C(0.15, 0.85, 0.88, 0.85, { from: [\"ㄴ\", 1] }), C(0.15, 0.15, 0.88, 0.15, { add: 1 })]);\ndef(\"ㅌ\", \"c\", 1, 2, 2, [C(0.15, 0.15, 0.15, 0.85, { from: [\"ㄷ\", 0] }), C(0.15, 0.85, 0.88, 0.85, { from: [\"ㄷ\", 1] }), C(0.15, 0.15, 0.88, 0.15, { from: [\"ㄷ\", 2] }), C(0.15, 0.5, 0.88, 0.5, { add: 1 })]);\ndef(\"ㅂ\", \"c\", 2, 1, 1, [\n  C(0.17, 0.45, 0.17, 0.88, { from: [\"ㅁ\", 0] }), C(0.17, 0.45, 0.83, 0.45, { from: [\"ㅁ\", 1] }), C(0.83, 0.45, 0.83, 0.88, { from: [\"ㅁ\", 2] }),\n  C(0.17, 0.88, 0.83, 0.88, { from: [\"ㅁ\", 3] }), C(0.17, 0.1, 0.17, 0.45, { add: 1 }), C(0.83, 0.1, 0.83, 0.45, { add: 1 }),\n]);\n// ㅍ has as many strokes as ㅂ in the Haerye's own letterforms, so nothing\n// is added here: ㅂ's strokes move into ㅍ, and the letter keeps no accent.\ndef(\"ㅍ\", \"c\", 2, 2, 2, [\n  C(0.33, 0.5, 0.33, 0.85, { from: [\"ㅂ\", 0] }), C(0.08, 0.15, 0.92, 0.15, { from: [\"ㅂ\", 1] }), C(0.67, 0.5, 0.67, 0.85, { from: [\"ㅂ\", 2] }),\n  C(0.08, 0.85, 0.92, 0.85, { from: [\"ㅂ\", 3] }), C(0.33, 0.15, 0.33, 0.5, { from: [\"ㅂ\", 4] }), C(0.67, 0.15, 0.67, 0.5, { from: [\"ㅂ\", 5] }),\n], { moved: 1 });\ndef(\"ㅈ\", \"c\", 3, 1, 1, [\n  C(0.5, 0.16, 0.12, 0.88, { from: [\"ㅅ\", 0] }), C(0.5, 0.16, 0.88, 0.88, { from: [\"ㅅ\", 1], m: [0.31, 0.52, 0.86, 0.88] }), C(0.1, 0.16, 0.9, 0.16, { add: 1 }),\n]);\ndef(\"ㅊ\", \"c\", 3, 2, 2, [\n  C(0.5, 0.34, 0.14, 0.9, { from: [\"ㅈ\", 0] }), C(0.5, 0.34, 0.86, 0.9, { from: [\"ㅈ\", 1], m: [0.33, 0.62, 0.86, 0.9] }), C(0.1, 0.34, 0.9, 0.34, { from: [\"ㅈ\", 2] }),\n  C(0.5, 0.04, 0.5, 0.24, { add: 1, m: [0.32, 0.14, 0.68, 0.14] }),\n]);\ndef(\"ㆆ\", \"c\", 4, 1, 1, [O(0.5, 0.63, 0.27, { from: [\"ㅇ\", 0] }), C(0.12, 0.2, 0.88, 0.2, { add: 1 })], { old: 1 });\ndef(\"ㅎ\", \"c\", 4, 2, 2, [O(0.5, 0.69, 0.23, { from: [\"ㆆ\", 0] }), C(0.12, 0.33, 0.88, 0.33, { from: [\"ㆆ\", 1] }), C(0.5, 0.04, 0.5, 0.22, { add: 1, m: [0.3, 0.14, 0.7, 0.14] })]);\n// The three that are not made by adding a stroke: ㆁ takes the throat's\n// circle, ㄹ and ㅿ copy the tongue and the tooth with a different body.\ndef(\"ㆁ\", \"x\", 0, 0, 3, [C(0.5, 0.04, 0.5, 0.3), O(0.5, 0.63, 0.29)], { old: 1 });\ndef(\"ㄹ\", \"x\", 1, 0, 3, [C(0.12, 0.12, 0.86, 0.12), C(0.86, 0.12, 0.86, 0.5), C(0.86, 0.5, 0.14, 0.5), C(0.14, 0.5, 0.14, 0.88), C(0.14, 0.88, 0.88, 0.88)]);\ndef(\"ㅿ\", \"x\", 3, 0, 3, [C(0.5, 0.12, 0.1, 0.86), C(0.5, 0.12, 0.9, 0.86), C(0.1, 0.86, 0.9, 0.86)], { old: 1 });\n// Vowels: heaven round, earth flat, man upright.\ndef(\"ㆍ\", \"b\", 0, 0, 0, [C(0.5, 0.5, 0.5, 0.5, { r: DOT * 1.25, acc: 1, mr: DOT * 1.25 })], { old: 1 });\ndef(\"ㅡ\", \"b\", 1, 0, 0, [C(0.06, 0.5, 0.94, 0.5)]);\ndef(\"ㅣ\", \"b\", 2, 0, 0, [C(0.5, 0.06, 0.5, 0.94)]);\n// First out: one dot with earth or man. Again out: a second dot, from ㅣ.\nconst dot = (x, y, from, m, add) => C(x, y, x, y, { r: DOT, acc: 1, from, m, add });\ndef(\"ㅗ\", \"v\", 0, 0, 1, [C(0.06, 0.7, 0.94, 0.7, { from: [\"ㅡ\", 0] }), dot(0.5, 0.38, [\"ㆍ\", 0], [0.5, 0.7, 0.5, 0.4])]);\ndef(\"ㅏ\", \"v\", 1, 0, 1, [C(0.36, 0.06, 0.36, 0.94, { from: [\"ㅣ\", 0] }), dot(0.7, 0.5, [\"ㆍ\", 0], [0.36, 0.5, 0.68, 0.5])]);\ndef(\"ㅜ\", \"v\", 2, 0, 1, [C(0.06, 0.3, 0.94, 0.3, { from: [\"ㅡ\", 0] }), dot(0.5, 0.62, [\"ㆍ\", 0], [0.5, 0.3, 0.5, 0.6])]);\ndef(\"ㅓ\", \"v\", 3, 0, 1, [C(0.64, 0.06, 0.64, 0.94, { from: [\"ㅣ\", 0] }), dot(0.3, 0.5, [\"ㆍ\", 0], [0.32, 0.5, 0.64, 0.5])]);\ndef(\"ㅛ\", \"v\", 0, 1, 2, [C(0.06, 0.7, 0.94, 0.7, { from: [\"ㅗ\", 0] }), dot(0.31, 0.38, [\"ㅗ\", 1], [0.35, 0.7, 0.35, 0.4]), dot(0.69, 0.38, null, [0.65, 0.7, 0.65, 0.4], 1)]);\ndef(\"ㅑ\", \"v\", 1, 1, 2, [C(0.36, 0.06, 0.36, 0.94, { from: [\"ㅏ\", 0] }), dot(0.7, 0.31, [\"ㅏ\", 1], [0.36, 0.35, 0.68, 0.35]), dot(0.7, 0.69, null, [0.36, 0.65, 0.68, 0.65], 1)]);\ndef(\"ㅠ\", \"v\", 2, 1, 2, [C(0.06, 0.3, 0.94, 0.3, { from: [\"ㅜ\", 0] }), dot(0.31, 0.62, [\"ㅜ\", 1], [0.35, 0.3, 0.35, 0.6]), dot(0.69, 0.62, null, [0.65, 0.3, 0.65, 0.6], 1)]);\ndef(\"ㅕ\", \"v\", 3, 1, 2, [C(0.64, 0.06, 0.64, 0.94, { from: [\"ㅓ\", 0] }), dot(0.3, 0.31, [\"ㅓ\", 1], [0.32, 0.35, 0.64, 0.35]), dot(0.3, 0.69, null, [0.32, 0.65, 0.64, 0.65], 1)]);\nconst ORDER = Object.keys(L);\n\n// Boxes on the panel. Consonants: five columns 12.8 LEDs apart, glyphs\n// 12 x 14, rows 19 apart. The odd three on row 57. Vowels: the basic three\n// on row 77, the eight on rows 94 and 111, glyphs 15 x 15.\nfunction place(g) {\n  if (g.area === \"c\" || g.area === \"x\") {\n    const cx = 6.4 + g.col * 12.8;\n    return [cx - 6, g.area === \"x\" ? 57 : 1 + g.row * 19, 12, 14];\n  }\n  if (g.area === \"b\") return [12 + g.col * 20 - 7.5, 77, 15, 15];\n  return [8 + g.col * 16 - 7.5, 94 + g.row * 17, 15, 15];\n}\nfor (const id of ORDER) {\n  const g = L[id];\n  g.box = place(g);\n  for (const s of g.strokes) if (s.acc === undefined) s.acc = s.add || 0;\n}\n\n// Beats at Speed 2, in seconds of build time.\nconst TRACE = 0.26, FLY = 0.5, T_LEV = [0, 1.05, 2.1, 3.3], STAG = 0.12, GLOW = 0.7, PULSE = 2.5, T_CYCLE = 15, T_FADE = 1;\n\nfunction startOf(g) {\n  return T_LEV[g.lev] + (g.area === \"v\" ? 0.3 + g.col * STAG : g.area === \"x\" ? g.col * 0.25 : g.col * STAG);\n}\n\nexport function setup(params) {\n  params.s = { T: 0, cyc: 0, hue: 0, speed: 2, style: 0, w: 0.8, buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.style = cl(kv[2], 0, 1);\n  S.w = 0.75 + 0.9 * cl(kv[3], 0, 1);\n  S.T += (d * S.speed) / 2;\n  // After the hold, everything but the basic letters fades and grows again.\n  if (S.T > T_CYCLE + T_FADE) {\n    S.T = T_LEV[1] - 0.3;\n    S.cyc++;\n  }\n}\n\n// One stroke's shape on the panel for a letter, at the current style: a\n// capsule [x0, y0, x1, y1, r] or a ring [cx, cy, R, 0, 0] in LEDs.\nfunction shape(S, g, s, out) {\n  const [bx, by, bw, bh] = g.box, st = S.style;\n  if (s.k === \"O\") {\n    out[0] = bx + s.h[0] * bw;\n    out[1] = by + s.h[1] * bh;\n    out[2] = s.h[2] * min(bw, bh);\n    out[3] = out[4] = 0;\n    return out;\n  }\n  for (let i = 0; i \u003c 4; i++) {\n    const v = s.h[i] + (s.m[i] - s.h[i]) * st;\n    out[i] = (i & 1 ? by + v * bh : bx + v * bw);\n  }\n  // A dot is rounder than the pen and grows less with Weight.\n  const rad = (k) => (k > 1.5 ? (k > 2.2 ? 0.95 + 1.2 * S.w : 0.75 + S.w) : S.w);\n  out[4] = rad(s.h[4]) + (rad(s.m[4]) - rad(s.h[4])) * st;\n  return out;\n}\n\nfunction segDist(px, py, x0, y0, x1, y1) {\n  const dx = x1 - x0, dy = y1 - y0, l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / l, 0, 1) : 0;\n  const ex = x0 + t * dx - px, ey = y0 + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// Paints one stroke: coverage over a 1-LED edge, plus a soft halo when it\n// glows. u is how much of it is drawn (a capsule from its start, a ring\n// from the top going left, the way ㅇ is written).\nfunction paint(S, k, g5, u, rgb, alpha, glow, w) {\n  const buf = S.buf, ring = k === \"O\";\n  let x0 = g5[0], y0 = g5[1], x1 = g5[2], y1 = g5[3], r = g5[4];\n  if (!ring && u \u003c 1) (x1 = x0 + (x1 - x0) * u), (y1 = y0 + (y1 - y0) * u);\n  const R = ring ? g5[2] : 0, pr = ring ? w : r, halo = glow > 0.01 ? 2.6 : 0;\n  const ext = (ring ? R + pr : pr) + halo + 1;\n  const xa = max(0, floor((ring ? x0 : min(x0, x1)) - ext)), xb = min(W - 1, Math.ceil((ring ? x0 : max(x0, x1)) + ext));\n  const ya = max(0, floor((ring ? y0 : min(y0, y1)) - ext)), yb = min(H - 1, Math.ceil((ring ? y0 : max(y0, y1)) + ext));\n  const sweep = u * 2 * PI;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let d;\n      if (ring) {\n        const dx = px - x0, dy = py - y0;\n        let a = atan2(-dx, -dy);\n        if (a \u003c 0) a += 2 * PI;\n        if (u >= 1 || a \u003c= sweep) d = abs(sqrt(dx * dx + dy * dy) - R);\n        else {\n          const ex = x0 - R * sin(sweep), ey = y0 - R * cos(sweep);\n          d = min(sqrt((px - x0) ** 2 + (py - y0 + R) ** 2), sqrt((px - ex) ** 2 + (py - ey) ** 2));\n        }\n      } else d = segDist(px, py, x0, y0, x1, y1);\n      const cov = cl(pr + 0.5 - d, 0, 1) * alpha;\n      let v = cov;\n      if (halo) v = max(v, glow * 0.55 * exp(-((d - pr) * (d - pr)) / 2.2) * alpha);\n      if (v \u003c= 0.004) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = max(buf[o], rgb[0] * v);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * v);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * v);\n    }\n}\n\nfunction line(S, x0, y0, x1, y1, rgb, a) {\n  paint(S, \"C\", [x0, y0, x1, y1, 0.35], 1, rgb, a, 0, 0);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, T = S.T, st = S.style, h = S.hue;\n  buf.fill(0);\n  // The ink cools from the warm tone of the printed page to plain white.\n  const ink = hsv(h + 0.11 - 0.03 * st, 0.55 - 0.45 * st, 0.9, [0, 0, 0]);\n  const acc = hsv(h + 0.5, 0.72, 1, [0, 0, 0]);\n  const odd = hsv(h + 0.78, 0.38, 0.8, [0, 0, 0]);\n  const hot = hsv(h + 0.5, 0.15, 1, [0, 0, 0]);\n  const dim = hsv(h + 0.5, 0.5, 0.3, [0, 0, 0]);\n  // Fade of everything grown, at the end of a cycle.\n  const fadeAll = T > T_CYCLE ? 1 - (T - T_CYCLE) / T_FADE : 1;\n  const tmp = [0, 0, 0, 0, 0], src = [0, 0, 0, 0, 0], g5 = [0, 0, 0, 0, 0], col = [0, 0, 0];\n  // Rules between consonants, the odd three and vowels.\n  if (T > T_LEV[3] - 0.2) {\n    const a = cl((T - T_LEV[3] + 0.2) / 0.6, 0, 1) * fadeAll * 0.5;\n    for (let x = 2; x \u003c 62; x += 3) line(S, x, 54.5, x + 1, 54.5, dim, a);\n  }\n  const ar = cl(T / 0.8, 0, 1) * 0.5;\n  for (let x = 2; x \u003c 62; x += 3) line(S, x, 74, x + 1, 74, dim, ar);\n  // The last pulse of the hold: a glow that runs down each tree.\n  const tEnd = T_LEV[3] + 1.2, pT = T > tEnd ? T - tEnd - floor((T - tEnd) / PULSE) * PULSE : -9;\n  for (const id of ORDER) {\n    const g = L[id], t0 = startOf(g), lt = g.lev === 0 && S.cyc > 0 ? 99 : T - t0;\n    if (lt \u003c 0) continue;\n    const grown = g.lev > 0 ? fadeAll : 1;\n    const oldDim = g.old ? 1 - 0.88 * st : 1;\n    const isOdd = g.area === \"x\";\n    // The tree's branch from the letter above.\n    if (g.area === \"c\" && g.lev > 0) {\n      const [bx, by] = g.box, cx = bx + 6, u = ease(lt / FLY);\n      line(S, cx, by - 4.2, cx, by - 4.2 + 3.4 * u, dim, grown * 0.8);\n    }\n    let nAdd = 0;\n    for (let i = 0; i \u003c g.strokes.length; i++) {\n      const s = g.strokes[i];\n      shape(S, g, s, g5);\n      let u = 1, alpha = grown * oldDim, glow = 0, rgb = ink;\n      if (isOdd) {\n        alpha *= ease(lt / 0.9);\n        rgb = odd;\n      } else if (g.lev === 0) {\n        // Basic letters: drawn stroke by stroke.\n        const a = lt - i * TRACE;\n        if (a \u003c 0) continue;\n        u = ease(a / TRACE);\n        glow = a \u003c TRACE ? 1 : exp(-(a - TRACE) / GLOW) * 0.6;\n        rgb = s.acc ? acc : ink;\n      } else if (s.from) {\n        // Taken over: flies from the letter it came from.\n        const f = L[s.from[0]];\n        shape(S, f, f.strokes[s.from[1]], src);\n        const e = ease(lt / FLY);\n        for (let j = 0; j \u003c 5; j++) tmp[j] = src[j] + (g5[j] - src[j]) * e;\n        for (let j = 0; j \u003c 5; j++) g5[j] = tmp[j];\n        rgb = s.acc ? acc : ink;\n        // ㅍ's strokes and the vowels' dots light as they land.\n        if (g.moved || s.acc) glow = lt \u003c FLY ? 0.5 * e : exp(-(lt - FLY) / GLOW);\n      } else {\n        // The added stroke: drawn after the rest has landed, glowing.\n        const a = lt - FLY - nAdd * TRACE;\n        nAdd++;\n        if (a \u003c 0) continue;\n        u = ease(a / TRACE);\n        glow = a \u003c TRACE ? 1 : exp(-(a - TRACE) / GLOW);\n        rgb = acc;\n      }\n      if (pT >= 0 && !isOdd && (s.add || (g.moved && g.lev > 0) || (s.acc && g.lev > 0))) {\n        const q = pT - (g.lev - 1) * 0.45 - (g.area === \"v\" ? 0.2 : 0);\n        if (q >= 0) glow = max(glow, exp(-q / 0.45) * 0.9);\n      }\n      if (glow > 0.02) {\n        const k = min(1, glow) * 0.8;\n        for (let j = 0; j \u003c 3; j++) col[j] = rgb[j] + (hot[j] - rgb[j]) * k;\n        paint(S, s.k, g5, u, col, alpha, glow, S.w);\n      } else paint(S, s.k, g5, u, rgb, alpha, 0, S.w);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, buf[o]) | 0, min(255, buf[o + 1]) | 0, min(255, buf[o + 2]) | 0);\n    }\n}\n","inversions":"// ===== Patternflow pattern =====\n// Title:   Inversions\n// Family:  type\n// Idea:    A two-syllable word stands on the panel, one 64 x 64 syllable above the other, and the whole panel turns slowly about its centre, so that at half a turn the same strokes read as another word, 곰국 (bone broth) as 논문 (a thesis), rests there, and turns on back to the first.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rotational lettering, Inversions (Scott Kim, 1981), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..8, Weight=-1..1\n//\n// Knob 1: Hue. The colour belongs to the panel, not to the word: a gradient runs from the top row to the bottom one, at 0 from sea green through cyan to blue, and the letters pass through it as they turn, so the syllable on top is always the top colour. The light a stroke leaves behind as it swings is a deeper shade of the same row.\n// Knob 2: Speed. At 2 a half turn takes 1.6 s and the word rests 2 s at each end, so it reads the second word from 1.95 s to 3.95 s and the first again from 5.55 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. Nine words, each checked LED by LED against its turned reading: 곰국 turns into 논문, 공공 into 운운, 눅눅 into 녹녹, 용융 into itself, MOM into WOW, and NOON, SWIMS, pod and suns into themselves.\n// Knob 4: Weight. The pen, from 2.1 LEDs at -1 through 5.9 at the start to 9.1 at 1, for Hangul and three letters; NOON and suns take 0.85 of it and SWIMS 0.7. The strokes are round-capped lines and rings sampled 16 times an LED, and the turned bitmap equals the other word's at every weight.\n// Buttons: K1 tap starts the next half turn at once.\n\nconst W = 64, H = 128, N = W * H, SS = 4;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The word list. Each turns half round into the word in the comment; the\n// knob line above says how the pairs were checked.\nconst WORDS = [\"곰국\", \"공공\", \"눅눅\", \"용융\", \"MOM\", \"NOON\", \"SWIMS\", \"pod\", \"suns\"];\n// 논문, 운운, 녹녹, 용융, WOW, NOON, SWIMS, pod, suns\n\n// Primitives, all in panel coordinates with integer or half-integer ends so\n// that turning about (32, 64) maps every one exactly onto another:\n// [1, x0, x1, y] a horizontal stroke, [2, y0, y1, x] a vertical one,\n// [0, x0, y0, x1, y1] a slanted one, [3, cx, cy, rx, ry, cut, flip] an\n// elliptic ring, cut 0 whole, 1 its upper half, 2 the bowl of an S; flip\n// reads the cut turned half round.\nfunction line(out, x0, y0, x1, y1) {\n  if (y0 === y1) out.push([1, min(x0, x1), max(x0, x1), y0]);\n  else if (x0 === x1) out.push([2, min(y0, y1), max(y0, y1), x0]);\n  else out.push([0, x0, y0, x1, y1]);\n}\nconst ring = (out, cx, cy, rx, ry, cut, flip) => out.push([3, cx, cy, rx, ry, cut || 0, flip || 0]);\n\n// ---- Hangul ----\n// A syllable with a horizontal vowel is three rows in its 64 x 64 cell: the\n// initial consonant in a box at the top, the vowel's bar across the middle,\n// the final in a box at the bottom. The bottom box is the top box turned half\n// round the cell's centre (32, 32), and the bars of ㅗ and ㅜ sit two rows\n// either side of row 32, so a turned syllable swaps its initial and final,\n// turns each over, and is a syllable again when the turned shapes are jamo:\n// ㄱ turns into ㄴ, ㅁ ㅇ ㄹ ㅍ into themselves, ㅗ into ㅜ, ㅛ into ㅠ, ㅡ stays.\nconst CHO = { 0: \"g\", 2: \"n\", 5: \"r\", 6: \"m\", 11: \"o\", 17: \"p\" };\nconst JONG = { 1: \"g\", 4: \"n\", 8: \"r\", 16: \"m\", 21: \"o\", 26: \"p\" };\nconst BOX_T = 6, BOX_B = 18, BOX_L = 11, BOX_R = 53;\n\nfunction consonant(out, k, l, t, r, b) {\n  const m = (t + b) / 2;\n  if (k === \"g\") line(out, l, t, r, t), line(out, r, t, r, b);\n  else if (k === \"n\") line(out, l, t, l, b), line(out, l, b, r, b);\n  else if (k === \"m\") line(out, l, t, r, t), line(out, r, t, r, b), line(out, l, b, r, b), line(out, l, t, l, b);\n  else if (k === \"o\") ring(out, (l + r) / 2, m, 13, (b - t) / 2);\n  else if (k === \"r\") line(out, l, t, r, t), line(out, r, t, r, m), line(out, l, m, r, m), line(out, l, m, l, b), line(out, l, b, r, b);\n  else if (k === \"p\") line(out, l, t, r, t), line(out, l, b, r, b), line(out, l + 10, t, l + 10, b), line(out, r - 10, t, r - 10, b);\n}\n\nfunction vowel(out, v, oy) {\n  // 8 ㅗ, 12 ㅛ, 13 ㅜ, 17 ㅠ, 18 ㅡ.\n  if (v === 18) return line(out, 6, oy + 32, 58, oy + 32);\n  const up = v === 8 || v === 12, bar = oy + (up ? 35.5 : 28.5), tip = oy + (up ? 28.5 : 35.5);\n  line(out, 6, bar, 58, bar);\n  for (const x of v === 8 || v === 13 ? [32] : [24, 40]) line(out, x, tip, x, bar);\n}\n\nfunction syllable(out, ch, oy) {\n  const c = ch.charCodeAt(0) - 0xac00, cho = floor(c / 588), jung = floor((c % 588) / 28), jong = c % 28;\n  consonant(out, CHO[cho], BOX_L, oy + BOX_T, BOX_R, oy + BOX_B);\n  vowel(out, jung, oy);\n  consonant(out, JONG[jong], BOX_L, oy + 64 - BOX_B, BOX_R, oy + 64 - BOX_T);\n}\n\n// ---- Latin ----\n// Letters stand one above another at a whole-number pitch centred on row 64,\n// so the turn sends slot i to slot n - 1 - i. M is drawn with upright sides\n// so that W is the same strokes turned, n is an arch on two stems and u the\n// arch turned, p and d share one bowl and a stem the length of the other's.\nfunction letter(out, ch, l, t, r, b, a) {\n  const c = (l + r) / 2, m = (t + b) / 2, hx = (r - l) / 2, q = (b - t) / 4, v = round(0.62 * (b - t));\n  if (ch === \"N\") line(out, l, b, l, t), line(out, l, t, r, b), line(out, r, b, r, t);\n  else if (ch === \"O\" || ch === \"o\") ring(out, c, m, hx, (b - t) / 2);\n  else if (ch === \"I\") line(out, c, t, c, b), line(out, c - 7, t, c + 7, t), line(out, c - 7, b, c + 7, b);\n  else if (ch === \"M\") line(out, l, b, l, t), line(out, l, t, c, t + v), line(out, c, t + v, r, t), line(out, r, t, r, b);\n  else if (ch === \"W\") line(out, l, t, l, b), line(out, l, b, c, b - v), line(out, c, b - v, r, b), line(out, r, b, r, t);\n  else if (ch === \"S\" || ch === \"s\") ring(out, c, t + q, hx, q, 2, 0), ring(out, c, b - q, hx, q, 2, 1);\n  else if (ch === \"n\") line(out, l, b, l, t + hx), line(out, r, b, r, t + hx), ring(out, c, t + hx, hx, hx, 1, 0);\n  else if (ch === \"u\") line(out, l, t, l, b - hx), line(out, r, t, r, b - hx), ring(out, c, b - hx, hx, hx, 1, 1);\n  else if (ch === \"p\") ring(out, c, m, hx, (b - t) / 2), line(out, l, t, l, b + a);\n  else if (ch === \"d\") ring(out, c, m, hx, (b - t) / 2), line(out, r, t - a, r, b);\n}\n\nconst LATIN = {\n  3: { pitch: 42, pen: 1, caps: [12, 52, 34], low: [17, 47, 18, 9] },\n  4: { pitch: 32, pen: 0.85, caps: [12, 52, 24], low: [15, 49, 22, 0] },\n  5: { pitch: 25, pen: 0.7, caps: [13, 51, 16], low: [16, 48, 14, 0] },\n};\n\nfunction wordPrims(word) {\n  const out = [];\n  if (word.charCodeAt(0) >= 0xac00) {\n    syllable(out, word[0], 0);\n    syllable(out, word[1], 64);\n    return out;\n  }\n  const n = word.length, L = LATIN[n];\n  for (let i = 0; i \u003c n; i++) {\n    const ch = word[i], yc = 64 + (i - (n - 1) / 2) * L.pitch;\n    const caps = ch \u003c \"a\", [l, r, h, a] = caps ? [L.caps[0], L.caps[1], L.caps[2], 0] : L.low;\n    const narrow = ch === \"S\" ? (n === 5 ? 7 : 4) : ch === \"s\" ? 4 : 0;\n    letter(out, ch, l + narrow, yc - h / 2, r - narrow, yc + h / 2, a);\n  }\n  return out;\n}\n\n// The pen for a weight, thinner for four and five letters, in eighths of an\n// LED with an odd numerator: samples sit on odd eighths, so no sample is ever\n// exactly half a pen from a straight stroke and none can tip either way.\nfunction penOf(word, weight) {\n  const scale = word.charCodeAt(0) >= 0xac00 ? 1 : LATIN[word.length].pen;\n  return (2 * round((5.6 + 3.5 * weight) * scale * 4) + 1) / 8;\n}\n\n// One sample against one primitive: within half the pen of the stroke.\nfunction inside(p, px, py, hw, hw2) {\n  const k = p[0];\n  if (k === 1) {\n    const dx = px \u003c p[1] ? p[1] - px : px > p[2] ? px - p[2] : 0, dy = py - p[3];\n    return dx * dx + dy * dy \u003c= hw2;\n  }\n  if (k === 2) {\n    const dy = py \u003c p[1] ? p[1] - py : py > p[2] ? py - p[2] : 0, dx = px - p[3];\n    return dx * dx + dy * dy \u003c= hw2;\n  }\n  if (k === 0) {\n    const ax = p[1], ay = p[2], ux = p[3] - ax, uy = p[4] - ay, l2 = ux * ux + uy * uy;\n    const t = cl(((px - ax) * ux + (py - ay) * uy) / l2, 0, 1), ex = ax + t * ux - px, ey = ay + t * uy - py;\n    return ex * ex + ey * ey \u003c= hw2;\n  }\n  let dx = px - p[1], dy = py - p[2];\n  if (p[6]) (dx = -dx), (dy = -dy);\n  const rx = p[3], ry = p[4], nx = dx / rx, ny = dy / ry;\n  if (p[5] === 1 && dy > 0) return false;\n  // The S bowl leaves out its lower right quarter and the upper right up to\n  // about 35 degrees, where the stroke ends.\n  if (p[5] === 2 && dx > 0 && (dy > 0 || -ny \u003c 0.7 * nx)) return false;\n  const q = sqrt(nx * nx + ny * ny), g = sqrt((nx / rx) * (nx / rx) + (ny / ry) * (ny / ry));\n  if (q === 0) return min(rx, ry) \u003c= hw;\n  return (abs(q - 1) * q) / g \u003c= hw;\n}\n\n// The word's bitmap: 16 samples an LED, the count of those inside a stroke.\nfunction render(prims, pen, out) {\n  const hw = pen / 2, hw2 = hw * hw, bits = new Uint16Array(N);\n  for (const p of prims) {\n    let x0, x1, y0, y1;\n    if (p[0] === 1) (x0 = p[1]), (x1 = p[2]), (y0 = y1 = p[3]);\n    else if (p[0] === 2) (y0 = p[1]), (y1 = p[2]), (x0 = x1 = p[3]);\n    else if (p[0] === 0) (x0 = min(p[1], p[3])), (x1 = max(p[1], p[3])), (y0 = min(p[2], p[4])), (y1 = max(p[2], p[4]));\n    else (x0 = p[1] - p[3]), (x1 = p[1] + p[3]), (y0 = p[2] - p[4]), (y1 = p[2] + p[4]);\n    const X0 = max(0, floor(x0 - hw - 1)), X1 = min(W - 1, floor(x1 + hw + 1));\n    const Y0 = max(0, floor(y0 - hw - 1)), Y1 = min(H - 1, floor(y1 + hw + 1));\n    for (let y = Y0; y \u003c= Y1; y++)\n      for (let x = X0; x \u003c= X1; x++) {\n        const o = y * W + x;\n        let b = bits[o];\n        if (b === 0xffff) continue;\n        for (let j = 0; j \u003c SS; j++)\n          for (let i = 0; i \u003c SS; i++) {\n            const bit = 1 \u003c\u003c (j * SS + i);\n            if (!(b & bit) && inside(p, x + (i + 0.5) / SS, y + (j + 0.5) / SS, hw, hw2)) b |= bit;\n          }\n        bits[o] = b;\n      }\n  }\n  for (let o = 0; o \u003c N; o++) {\n    let b = bits[o], c = 0;\n    while (b) (b &= b - 1), c++;\n    out[o] = c;\n  }\n  return out;\n}\n\n// Beats at Speed 2, in seconds: the rest at each end and the half turn.\nconst REST = 2, TURN = 1.6;\n\nexport function setup(params) {\n  params.s = {\n    word: -1, pen: -1, hits: new Uint8Array(N), cov: new Float32Array(N), trail: new Float32Array(N),\n    ph: REST - 0.35, ang: 0, hue: -1, row: new Float32Array(H * 3), ghost: new Float32Array(H * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const word = cl(round(kv[2]), 0, WORDS.length - 1), pen = penOf(WORDS[word], cl(kv[3], -1, 1));\n  if (word !== S.word || pen !== S.pen) {\n    S.word = word;\n    S.pen = pen;\n    render(wordPrims(WORDS[word]), pen, S.hits);\n  }\n  if (input.btnPressed && input.btnPressed[0] && S.rest) S.ph = S.half * (REST + TURN) + REST;\n  S.ph += (d * cl(kv[1], 0.2, 3)) / 2;\n  const k = floor(S.ph / (REST + TURN)), u = S.ph - k * (REST + TURN);\n  S.rest = u \u003c REST;\n  S.half = k;\n  S.ang = (k + (S.rest ? 0 : ease((u - REST) / TURN))) * PI;\n  S.dt = d;\n  if (kv[0] !== S.hue) {\n    S.hue = kv[0];\n    for (let y = 0; y \u003c H; y++) {\n      const h = S.hue + 0.42 + 0.2 * (y / (H - 1));\n      hsv(h, 0.72, 1, S.row, y * 3);\n      hsv(h + 0.07, 1, 0.5, S.ghost, y * 3);\n    }\n  }\n}\n\n// Bilinear read of the word's bitmap at word-space (x, y), LED centres on\n// whole numbers.\nfunction sample(hits, x, y) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  let v = 0;\n  if (y0 >= 0 && y0 \u003c H) {\n    const o = y0 * W;\n    if (x0 >= 0 && x0 \u003c W) v += hits[o + x0] * (1 - fx) * (1 - fy);\n    if (x0 + 1 >= 0 && x0 + 1 \u003c W) v += hits[o + x0 + 1] * fx * (1 - fy);\n  }\n  if (y0 + 1 >= 0 && y0 + 1 \u003c H) {\n    const o = (y0 + 1) * W;\n    if (x0 >= 0 && x0 \u003c W) v += hits[o + x0] * (1 - fx) * fy;\n    if (x0 + 1 >= 0 && x0 + 1 \u003c W) v += hits[o + x0 + 1] * fx * fy;\n  }\n  return v;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.word \u003c 0) return;\n  const { hits, cov, trail, row, ghost } = S;\n  if (S.rest) {\n    // At rest the panel shows the bitmap itself, or the bitmap read from the\n    // far corner: LED (x, y) shows LED (63 - x, 127 - y).\n    const flip = S.half % 2 === 1;\n    for (let o = 0; o \u003c N; o++) cov[o] = hits[flip ? N - 1 - o : o] / 16;\n  } else {\n    // Turning, the word shrinks so its 128 rows lie down across 64 columns\n    // at a quarter turn, losing a row or two of each end against the sides.\n    const a = S.ang, sn = sin(a), s = 1 - 0.47 * sn * sn, c = cos(a) / s, si = sn / s;\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let v = 0;\n        for (let j = 0; j \u003c 2; j++)\n          for (let i = 0; i \u003c 2; i++) {\n            const u = x + 0.25 + 0.5 * i - 32, w = y + 0.25 + 0.5 * j - 64;\n            v += sample(hits, 31.5 + c * u + si * w, 63.5 - si * u + c * w);\n          }\n        cov[y * W + x] = v / 64;\n      }\n  }\n  const fade = exp(-S.dt / 0.09);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x, c = cov[o], t = max(c, trail[o] * fade);\n      trail[o] = t;\n      const g = t - c;\n      display.setPixel(x, y, row[y * 3] * c + ghost[y * 3] * g, row[y * 3 + 1] * c + ghost[y * 3 + 1] * g, row[y * 3 + 2] * c + ghost[y * 3 + 2] * g);\n    }\n}\n","jacobi-geodesics":"// ===== Patternflow pattern =====\n// Title:   Jacobi Geodesics\n// Family:  space\n// Idea:    A three-axis ellipsoid stands the height of the panel and turns, and 36 geodesics leave one of its four umbilics in every direction at once: their front wraps the body and closes again to a single point at the opposite umbilic, then comes home; past the middle of K4 one long geodesic winds instead, filling the band between its two caustic lines of curvature.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: geodesics on the triaxial ellipsoid (Carl Gustav Jacob Jacobi, 1839), their caustics (Michel Chasles, 1846), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Launch=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel: at 0 the fan runs from cyan at its two ends through blue to violet in the middle of its directions, the body is a dim blue with rose lines of curvature, the long geodesic is violet and its caustics warm white. The body keeps to the hues from green to violet, which stay colours this dim.\n// Knob 2: Speed. At 2 the front runs 27 LEDs a second, so the fan from the umbilic closes at the opposite one after 4.7 s and is home at 9.3 s, and a new fan leaves after a 0.6 s fade. The body turns half round in the time of one pass, so the closing point faces you. At 0.2 ten times slower.\n// Knob 3: Axes. The half axes are 1 (60 LEDs, up the panel), 0.5 and c, with c from 0.2 at 0 to 0.45 at 1. The umbilics sit in the plane of the longest and shortest axes, at 0.884 of the half length at 0 and 0.970 at 1, nearer the tips as the body grows rounder, and the way from one to the opposite one is half the perimeter of that principal ellipse, 2.101 at 0 and 2.360 at 1.\n// Knob 4: Launch. Up to 0.08 the fan starts exactly on the umbilic. To 0.5 its start slides along the same principal ellipse toward the waist and the front no longer closes but folds into cusps. From 0.5 one geodesic leaves the end of the middle axis at 10 degrees from the long axis, turning to 60 at 1: at Axes 0 it circles the short axis over both tips up to 0.68, passes through the umbilics there, and then circles the long axis in a belt round the waist that narrows until, at 1, its caustics run between 0.50 and 0.57 of the half length above and below it.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, asin, atan2, PI, exp, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst SC = 60; // LEDs per unit: the long half axis a = 1 is 60 LEDs\nconst NB = 36; // rays in the fan\nconst DS = 0.02; // arc length between trail points\nconst STEP = 0.005; // largest RK4 step\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The body x^2 + y^2/b^2 + z^2/c^2 = 1, x up the panel.\nfunction setAxes(S, k) {\n  S.b = 0.5;\n  S.c = 0.5 * (0.4 + 0.5 * k);\n  S.A = 1; S.B = 1 / (S.b * S.b); S.C = 1 / (S.c * S.c);\n  const b2 = S.b * S.b, c2 = S.c * S.c;\n  // The four umbilics, in the plane of the long and short axes.\n  S.ux = sqrt((1 - b2) / (1 - c2));\n  S.uz = S.c * sqrt((b2 - c2) / (1 - c2));\n  // Half the perimeter of that principal ellipse: every geodesic from an\n  // umbilic reaches the opposite one after exactly this length.\n  let per = 0, px = 1, pz = 0;\n  for (let i = 1; i \u003c= 2000; i++) {\n    const t = (PI * i) / 2000, x = cos(t), z = S.c * sin(t);\n    per += hypot(x - px, z - pz);\n    px = x; pz = z;\n  }\n  S.hp = per;\n}\n\n// Geodesic acceleration on F = 0: x'' = -(v.Hv / |grad F|^2) grad F.\nfunction acc(S, p, v, o) {\n  const gx = p[0] * S.A, gy = p[1] * S.B, gz = p[2] * S.C;\n  const k = -(v[0] * v[0] * S.A + v[1] * v[1] * S.B + v[2] * v[2] * S.C) / (gx * gx + gy * gy + gz * gz);\n  o[0] = k * gx; o[1] = k * gy; o[2] = k * gz;\n}\n\n// Back onto the surface and the tangent plane, at unit speed.\nfunction settle(S, p, v) {\n  const s = 1 / sqrt(p[0] * p[0] * S.A + p[1] * p[1] * S.B + p[2] * p[2] * S.C);\n  p[0] *= s; p[1] *= s; p[2] *= s;\n  const gx = p[0] * S.A, gy = p[1] * S.B, gz = p[2] * S.C;\n  const d = (v[0] * gx + v[1] * gy + v[2] * gz) / (gx * gx + gy * gy + gz * gz);\n  v[0] -= d * gx; v[1] -= d * gy; v[2] -= d * gz;\n  const n = hypot(v[0], v[1], v[2]);\n  v[0] /= n; v[1] /= n; v[2] /= n;\n}\n\nconst K1 = [0, 0, 0], K2 = [0, 0, 0], K3 = [0, 0, 0], K4 = [0, 0, 0], P2 = [0, 0, 0], V2 = [0, 0, 0], VA = [0, 0, 0], VB = [0, 0, 0];\nfunction rk4(S, p, v, h) {\n  acc(S, p, v, K1);\n  for (let i = 0; i \u003c 3; i++) { P2[i] = p[i] + 0.5 * h * v[i]; V2[i] = v[i] + 0.5 * h * K1[i]; }\n  acc(S, P2, V2, K2);\n  for (let i = 0; i \u003c 3; i++) { VA[i] = V2[i]; P2[i] = p[i] + 0.5 * h * VA[i]; V2[i] = v[i] + 0.5 * h * K2[i]; }\n  acc(S, P2, V2, K3);\n  for (let i = 0; i \u003c 3; i++) { VB[i] = V2[i]; P2[i] = p[i] + h * VB[i]; V2[i] = v[i] + h * K3[i]; }\n  acc(S, P2, V2, K4);\n  for (let i = 0; i \u003c 3; i++) {\n    p[i] += (h / 6) * (v[i] + 2 * VA[i] + 2 * VB[i] + V2[i]);\n    v[i] += (h / 6) * (K1[i] + 2 * K2[i] + 2 * K3[i] + K4[i]);\n  }\n  settle(S, p, v);\n}\n\n// The two ellipsoidal coordinates c^2 \u003c mu \u003c b^2 \u003c nu \u003c 1 of a point on the\n// body: the roots besides 0 of sum x_i^2 / (a_i^2 - s) = 1.\nfunction ellc(S, x, y, z, out) {\n  const A2 = 1, B2 = S.b * S.b, C2 = S.c * S.c, x2 = x * x, y2 = y * y, z2 = z * z;\n  const bb = x2 + y2 + z2 - A2 - B2 - C2, cc = A2 * B2 + A2 * C2 + B2 * C2 - x2 * (B2 + C2) - y2 * (A2 + C2) - z2 * (A2 + B2);\n  const dq = sqrt(max(0, bb * bb - 4 * cc));\n  out[0] = (-bb - dq) / 2;\n  out[1] = (-bb + dq) / 2;\n  return out;\n}\n\n// A point on the principal ellipse of the long and short axes, at parameter t.\nconst onEllipse = (S, t) => [cos(t), 0, S.c * sin(t)];\n\nexport function setup(params) {\n  params.s = {\n    b: 0.5, c: 0.2, A: 1, B: 4, C: 25, ux: 0, uz: 0, hp: 2,\n    axes: -1, launch: -1, mode: 0, hue: 0, speed: 2,\n    s: 0, rho: 0, fade: 1, rays: [], lam: 0, caustic: [],\n    buf: new Float32Array(W * H * 3), G1: new Float32Array(W * H), G2: new Float32Array(W * H), SH: new Float32Array(W * H),\n    col: [0, 0, 0], e: [0, 0],\n  };\n}\n\n// The fan: NB rays from the start, one per direction. Launch below 0.08\n// starts on the umbilic.\nfunction launchFan(S) {\n  const L = S.launch, tu = atan2(S.uz / S.c, S.ux);\n  const off = cl((L - 0.08) / 0.42, 0, 1);\n  const t = tu + off * 0.55 * (PI / 2 - tu);\n  const p0 = onEllipse(S, t), e1 = [-sin(t), 0, S.c * cos(t)], l = hypot(e1[0], e1[2]);\n  e1[0] /= l; e1[2] /= l;\n  S.rays = [];\n  for (let k = 0; k \u003c NB; k++) {\n    const al = (2 * PI * (k + 0.5)) / NB;\n    const p = p0.slice(), v = [cos(al) * e1[0], sin(al), cos(al) * e1[2]];\n    settle(S, p, v);\n    S.rays.push({ p, v, tr: [p[0], p[1], p[2]], acc: 0, al });\n  }\n  S.s = 0;\n  S.fade = 1;\n}\n\n// One long geodesic from the end of the middle axis, (0, b, 0), aimed at\n// beta from the long axis, run 24 units ahead so its band is already half\n// filled. Its constant is lambda = mu (t.e_nu)^2 + nu (t.e_mu)^2 with e_mu\n// and e_nu the principal directions; here mu = c^2, nu = 1 and those are z\n// and x, so lambda = c^2 cos^2 beta + sin^2 beta. The geodesic keeps to\n// mu \u003c= lambda, a ring round the short axis over both tips, when lambda \u003c\n// b^2, and to nu >= lambda, a belt round the long axis, when lambda > b^2.\nfunction launchOne(S) {\n  const u = (S.launch - 0.5) / 0.5, be = ((10 + 50 * u) * PI) / 180;\n  const p = [0, S.b, 0], v = [cos(be), 0, sin(be)];\n  settle(S, p, v);\n  S.lam = S.c * S.c * cos(be) * cos(be) + sin(be) * sin(be);\n  S.caustic = causticLines(S, S.lam);\n  const r = { p, v, tr: [p[0], p[1], p[2]], acc: 0, al: be };\n  S.rays = [r];\n  advance(S, r, 24, 3000);\n  S.s = 0;\n  S.fade = 1;\n}\n\n// The lines of curvature at lambda, as point lists: two closed curves.\nfunction causticLines(S, lam) {\n  const a2 = 1, b2 = S.b * S.b, c2 = S.c * S.c, out = [];\n  for (const sg of [1, -1]) {\n    const pts = [];\n    for (let i = 0; i \u003c= 160; i++) {\n      const ph = (2 * PI * i) / 160;\n      let x, y, z;\n      if (lam > b2) {\n        const mu = c2 + (b2 - c2) * sin(ph) * sin(ph), nu = lam;\n        x = sg * sqrt(max(0, ((a2 - mu) * (a2 - nu)) / ((a2 - b2) * (a2 - c2))));\n        y = (cos(ph) \u003c 0 ? -1 : 1) * S.b * sqrt(max(0, ((b2 - mu) * (nu - b2)) / ((a2 - b2) * (b2 - c2))));\n        z = (sin(ph) \u003c 0 ? -1 : 1) * S.c * sqrt(max(0, ((mu - c2) * (nu - c2)) / ((a2 - c2) * (b2 - c2))));\n      } else {\n        const mu = lam, nu = b2 + (a2 - b2) * sin(ph) * sin(ph);\n        x = (cos(ph) \u003c 0 ? -1 : 1) * sqrt(max(0, ((a2 - mu) * (a2 - nu)) / ((a2 - b2) * (a2 - c2))));\n        y = (sin(ph) \u003c 0 ? -1 : 1) * S.b * sqrt(max(0, ((b2 - mu) * (nu - b2)) / ((a2 - b2) * (b2 - c2))));\n        z = sg * S.c * sqrt(max(0, ((mu - c2) * (nu - c2)) / ((a2 - c2) * (b2 - c2))));\n      }\n      pts.push(x, y, z);\n    }\n    out.push(pts);\n  }\n  return out;\n}\n\n// Moves a ray on by length L, dropping a trail point every DS, keeping at most cap.\nfunction advance(S, r, L, cap) {\n  let left = L;\n  while (left > 1e-9) {\n    const h = min(STEP, left, DS - r.acc + 1e-12);\n    rk4(S, r.p, r.v, h);\n    left -= h;\n    r.acc += h;\n    if (r.acc >= DS - 1e-9) {\n      r.acc = 0;\n      r.tr.push(r.p[0], r.p[1], r.p[2]);\n      if (r.tr.length > cap * 3) r.tr.splice(0, r.tr.length - cap * 3);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const ax = cl(kv[2], 0, 1), L = cl(kv[3], 0, 1);\n  let fresh = false;\n  if (abs(ax - S.axes) > 1e-4) { S.axes = ax; setAxes(S, ax); fresh = true; }\n  if (abs(L - S.launch) > 1e-4) { S.launch = L; fresh = true; }\n  S.mode = S.launch \u003c 0.5 ? 0 : 1;\n  if (fresh) (S.mode ? launchOne : launchFan)(S);\n  const ds = (0.45 * S.speed * d) / 2;\n  if (S.mode === 0) {\n    // Out to the opposite umbilic and home again, then a short fade and a new fan.\n    if (S.s \u003c 2 * S.hp) {\n      const step = min(ds, 2 * S.hp - S.s);\n      for (const r of S.rays) advance(S, r, step, 45);\n      S.s += step;\n    } else {\n      S.fade -= d * 1.6;\n      if (S.fade \u003c= 0) launchFan(S);\n    }\n  } else {\n    advance(S, S.rays[0], ds, 3000);\n    S.s += ds;\n  }\n  // Half a turn for every pass from umbilic to umbilic.\n  S.rho += (PI * ds) / S.hp;\n}\n\n// How close a LED is to a level line of G, n lines over 0..1, in LEDs, from\n// the step to its neighbours: 1 on the line, 0 a LED away.\nfunction gridLine(G, SH, p, px, py, n) {\n  const g = G[p], gx = px + 1 \u003c W && SH[p + 1] >= 0 ? abs(G[p + 1] - g) : 0, gy = py + 1 \u003c H && SH[p + W] >= 0 ? abs(G[p + W] - g) : 0;\n  const gr = max(gx, gy, 1e-4), f = abs(g * n - round(g * n)) / n;\n  return cl(1 - f / gr / 0.9, 0, 1);\n}\n\nfunction plot(buf, x, y, r, g, b) {\n  const x0 = floor(x - 0.5), y0 = floor(y - 0.5), fx = x - 0.5 - x0, fy = y - 0.5 - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = x0 + i, Y = y0 + j;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const w = (i ? fx : 1 - fx) * (j ? fy : 1 - fy) * 1.5, o = (Y * W + X) * 3;\n      buf[o] = max(buf[o], r * w); buf[o + 1] = max(buf[o + 1], g * w); buf[o + 2] = max(buf[o + 2], b * w);\n    }\n}\n\nfunction line(buf, x0, y0, x1, y1, r, g, b) {\n  const n = max(1, Math.ceil(hypot(x1 - x0, y1 - y0) / 0.6));\n  for (let i = 0; i \u003c= n; i++) plot(buf, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, r, g, b);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.axes \u003c 0) return;\n  const { buf, G1, G2, SH, col } = S;\n  const cr = cos(S.rho), sr = sin(S.rho), b = S.b, c = S.c, b2 = b * b, c2 = c * c;\n  const hb = 0.5 + S.hue, e = S.e;\n  buf.fill(0);\n  // The body: orthographic, seen along z after turning by rho about x.\n  for (let py = 0; py \u003c H; py++) {\n    const x = (64 - py - 0.5) / SC;\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, yp = (px + 0.5 - 32) / SC;\n      // y = yp cr + zp sr, z = -yp sr + zp cr; solve for the front zp.\n      const qa = (sr * sr) / b2 + (cr * cr) / c2, qb = 2 * yp * cr * sr * (1 / b2 - 1 / c2);\n      const qc = x * x + yp * yp * ((cr * cr) / b2 + (sr * sr) / c2) - 1;\n      const disc = qb * qb - 4 * qa * qc;\n      if (disc \u003c= 0) { SH[p] = -1; continue; }\n      const zp = (-qb + sqrt(disc)) / (2 * qa), y = yp * cr + zp * sr, z = -yp * sr + zp * cr;\n      const nx = x, ny = y / b2, nz = z / c2, nl = sqrt(nx * nx + ny * ny + nz * nz);\n      const vz = (ny * sr + nz * cr) / nl, vy = (ny * cr - nz * sr) / nl;\n      SH[p] = cl(0.35 + 0.65 * (0.55 * vz + 0.35 * (nx / nl) - 0.25 * vy), 0, 1) * cl(disc * 40, 0, 1);\n      ellc(S, x, y, z, e);\n      G1[p] = (2 / PI) * asin(sqrt(cl((e[0] - c2) / (b2 - c2), 0, 1)));\n      G2[p] = (2 / PI) * asin(sqrt(cl((e[1] - b2) / (1 - b2), 0, 1)));\n    }\n  }\n  hsv(hb + 0.42, 0.55, 1, col);\n  const lr = col[0], lg = col[1], lb = col[2];\n  // The body's own dim colour keeps to the hues from green to violet, since\n  // red, orange and yellow read brown this dim.\n  hsv(0.3 + 0.55 * ((((hb + 0.12) % 1) + 1) % 1), 0.75, 1, col);\n  const br = col[0], bg = col[1], bb = col[2];\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px;\n      if (SH[p] \u003c 0) continue;\n      const sh = SH[p], o = p * 3;\n      // Lines of curvature: six of mu, eight of nu, about a LED wide.\n      const ln = max(gridLine(G1, SH, p, px, py, 6), gridLine(G2, SH, p, px, py, 8));\n      // The band a long geodesic keeps to, lit faintly.\n      let band = 0;\n      if (S.mode === 1) {\n        const m = (G1[p] * PI) / 2, nn = (G2[p] * PI) / 2;\n        const mu = c2 + (b2 - c2) * sin(m) * sin(m), nu = b2 + (1 - b2) * sin(nn) * sin(nn);\n        band = S.lam > b2 ? (nu >= S.lam ? 1 : 0) : mu \u003c= S.lam ? 1 : 0;\n      }\n      const v = (0.09 + 0.16 * sh) * (1 + 0.9 * band);\n      buf[o] = v * br + ln * lr * 0.17 * (0.4 + 0.6 * sh);\n      buf[o + 1] = v * bg + ln * lg * 0.17 * (0.4 + 0.6 * sh);\n      buf[o + 2] = v * bb + ln * lb * 0.17 * (0.4 + 0.6 * sh);\n    }\n  // Body point to screen, and whether it faces us.\n  const proj = (x, y, z, out) => {\n    out[0] = 32 + SC * (y * cr - z * sr);\n    out[1] = 64 - SC * x;\n    out[2] = (y / b2) * sr + (z / c2) * cr > 0 ? 1 : 0.3;\n    return out;\n  };\n  const q0 = [0, 0, 0], q1 = [0, 0, 0];\n  // Caustics of the long geodesic.\n  if (S.mode === 1) {\n    hsv(hb + 0.62, 0.25, 1, col);\n    for (const pts of S.caustic)\n      for (let i = 3; i \u003c pts.length; i += 3) {\n        proj(pts[i - 3], pts[i - 2], pts[i - 1], q0);\n        proj(pts[i], pts[i + 1], pts[i + 2], q1);\n        const w = 0.6 * min(q0[2], q1[2]);\n        line(buf, q0[0], q0[1], q1[0], q1[1], col[0] * w, col[1] * w, col[2] * w);\n      }\n  }\n  // Trails and the front.\n  const f = S.fade, nr = S.rays.length;\n  for (let k = 0; k \u003c nr; k++) {\n    const r = S.rays[k], tr = r.tr, n = tr.length / 3;\n    hsv(S.mode ? hb + 0.3 : hb + 0.17 * (1 - cos(r.al)), 0.85, 1, col);\n    for (let i = 1; i \u003c n; i++) {\n      proj(tr[i * 3 - 3], tr[i * 3 - 2], tr[i * 3 - 1], q0);\n      proj(tr[i * 3], tr[i * 3 + 1], tr[i * 3 + 2], q1);\n      const age = (n - i) / n, w = f * min(q0[2], q1[2]) * (S.mode ? 0.5 + 0.5 * exp(-age * 4) : 0.15 + 0.6 * (1 - age));\n      line(buf, q0[0], q0[1], q1[0], q1[1], col[0] * w, col[1] * w, col[2] * w);\n    }\n  }\n  if (S.mode === 0 && S.s > 0) {\n    for (let k = 0; k \u003c nr; k++) {\n      const r = S.rays[k], r2 = S.rays[(k + 1) % nr];\n      proj(r.p[0], r.p[1], r.p[2], q0);\n      proj(r2.p[0], r2.p[1], r2.p[2], q1);\n      hsv(hb + 0.17 * (1 - cos(r.al)), 0.5, 1, col);\n      const w = f * min(q0[2], q1[2]);\n      line(buf, q0[0], q0[1], q1[0], q1[1], col[0] * w, col[1] * w, col[2] * w);\n    }\n  } else if (S.mode === 1) {\n    const r = S.rays[0];\n    proj(r.p[0], r.p[1], r.p[2], q0);\n    plot(buf, q0[0], q0[1], q0[2], q0[2], q0[2]);\n  }\n  // The four umbilics.\n  for (const [sx, sz] of [[1, 1], [1, -1], [-1, 1], [-1, -1]]) {\n    proj(sx * S.ux, 0, sz * S.uz, q0);\n    const w = q0[2] > 0.5 ? 1 : 0.35;\n    plot(buf, q0[0], q0[1], w, w, w);\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, floor(cl(buf[o], 0, 1) * 255), floor(cl(buf[o + 1], 0, 1) * 255), floor(cl(buf[o + 2], 0, 1) * 255));\n  }\n}\n","klein-sails":"// ===== Patternflow pattern =====\n// Title:   Klein's Sails\n// Family:  number\n// Idea:    The integer lattice flows along hyperbolas under the real powers of an integer matrix that fixes the line y = ax and its conjugate, with the X of the two lines standing lengthwise on the panel, and in each corner of the X the boundary of the convex hull of the lattice points, Klein's sail, slides along itself, its corners on the convergents of a towards y = ax, until after one unit of flow every point and every corner sits where another one was and the loop closes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Klein's sails of continued fractions (Felix Klein, 1895), periodic continued fractions of quadratic irrationals (Joseph-Louis Lagrange, 1770), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Number=0..5, Zoom=10..22\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the sail below the line y = ax and its copy through the centre are azure, the other two rose, the two lines a near-white lilac and the lattice points dim teal with short tails along their hyperbolas.\n// Knob 2: Speed. The flow in hyperbolic angle, 0.32 a second at 2, so a point keeps its product of distances to the two lines and moves 37% further out along y = ax each second. One loop takes log e seconds over 0.32: 5.5 s for the square root of 2, 3.0 s for the golden ratio. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Number. Which quadratic irrational a, with its continued fraction and the matrix M that loops the flow: 0 the square root of 2 = [1; 2, 2, ...] with M = [[3, 2], [4, 3]], 1 the golden ratio [1; 1, 1, ...] with [[1, 1], [1, 2]], 2 the square root of 3 = [1; 1, 2, 1, 2, ...] with [[2, 1], [3, 2]], 3 the square root of 5 = [2; 4, 4, ...] with [[9, 4], [20, 9]], 4 the square root of 7 = [2; 1, 1, 1, 4, ...] with [[8, 3], [21, 8]], 5 (1 + square root of 13) / 2 = [2; 3, 3, ...] with [[4, 3], [9, 7]]. A sail edge runs through a_k - 1 lattice points between its corners, and its a_k is written beside it when there is room.\n// Knob 4: Zoom. LEDs between neighbouring lattice points, 10 to 22. At 10 the panel is 6.4 lattice steps wide and each sail keeps two or three corners on it for the square root of 2, four for the golden ratio; at 22 it is 2.9 steps wide with one or two corners a sail, and an edge is long enough to count the lattice points along it.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, exp, log, atan, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// a is the larger root of a^2 = P a + Q, and the unit e = A + B a of Z[a]\n// is the fundamental one. Multiplying by e in the basis 1, a is the integer\n// matrix [[A, B], [B Q, A + B P]] whose determinant is the norm of e; it\n// sends (1, a) to e (1, a) and (1, a') to e' (1, a'). With norm -1 it swaps\n// two corners of the X, so the flow loops on its square.\nconst NUMS = [\n  { P: 0, Q: 2, A: 1, B: 1 },\n  { P: 1, Q: 1, A: 0, B: 1 },\n  { P: 0, Q: 3, A: 2, B: 1 },\n  { P: 0, Q: 5, A: 2, B: 1 },\n  { P: 0, Q: 7, A: 8, B: 3 },\n  { P: 1, Q: 3, A: 1, B: 1 },\n];\n\nconst gcd = (a, b) => {\n  a = abs(a);\n  b = abs(b);\n  while (b) [a, b] = [b, a % b];\n  return a;\n};\nconst mul = (m, v) => [m[0] * v[0] + m[1] * v[1], m[2] * v[0] + m[3] * v[1]];\n\nfunction prepare(num) {\n  const { P, Q, A, B } = num, root = sqrt(P * P + 4 * Q);\n  const al = (P + root) / 2, al2 = (P - root) / 2;\n  let M = [A, B, B * Q, A + B * P], e = A + B * al;\n  if (M[0] * M[3] - M[1] * M[2] \u003c 0) (M = [M[0] * M[0] + M[1] * M[2], M[0] * M[1] + M[1] * M[3], M[2] * M[0] + M[3] * M[2], M[2] * M[1] + M[3] * M[3]]), (e *= e);\n  const Mi = [M[3], -M[1], -M[2], M[0]];\n  // Eigen-coordinates: n = u (1, a) + w (1, a').\n  const den = al - al2;\n  const eig = (x, y) => [(y - al2 * x) / den, (al * x - y) / den];\n  // The corners of the X: K1 holds u > 0, w > 0 (the positive x axis, below\n  // y = a x), K2 holds u > 0, w \u003c 0 (above it); K3 and K4 are their negatives.\n  const sails = [];\n  for (const sign of [1, -1]) {\n    const pts = [];\n    const R = 40;\n    for (let x = -R; x \u003c= R; x++)\n      for (let y = -R; y \u003c= R; y++) {\n        const [u, w] = eig(x, y);\n        if (u > 0 && sign * w > 0) pts.push([u, sign * w, x, y]);\n      }\n    pts.sort((p, q) => p[0] - q[0]);\n    // The lower left hull in (u, w): a point that does not lie lower than the\n    // last corner is inside the hull plus the corner's quadrant, and a corner\n    // that the next point sees on its far side is no corner. The turn is read\n    // from the integer coordinates, so points on an edge never count as\n    // corners by a rounding error.\n    const hull = [];\n    for (const p of pts) {\n      if (hull.length && p[1] >= hull[hull.length - 1][1]) continue;\n      while (hull.length >= 2) {\n        const o = hull[hull.length - 2], a = hull[hull.length - 1];\n        const c = (a[2] - o[2]) * (p[3] - o[3]) - (a[3] - o[3]) * (p[2] - o[2]);\n        if (sign * c >= 0) hull.pop();\n        else break;\n      }\n      hull.push(p);\n    }\n    // One period: from the corner nearest the middle of the corner of the X\n    // to its image under M, which is again a corner.\n    let i0 = 0;\n    for (let i = 1; i \u003c hull.length; i++) if (abs(log(hull[i][0] / hull[i][1])) \u003c abs(log(hull[i0][0] / hull[i0][1]))) i0 = i;\n    const to = mul(M, [hull[i0][2], hull[i0][3]]);\n    let j = i0 + 1;\n    while (j \u003c hull.length && !(hull[j][2] === to[0] && hull[j][3] === to[1])) j++;\n    const period = hull.slice(i0, j).map((p) => [p[2], p[3]]);\n    // The whole sail, as far as the flow can bring it onto the panel.\n    const verts = [];\n    for (let k = -6; k \u003c= 6; k++) {\n      let m = [1, 0, 0, 1];\n      for (let s = 0; s \u003c abs(k); s++) {\n        const n = k > 0 ? M : Mi;\n        m = [n[0] * m[0] + n[1] * m[2], n[0] * m[1] + n[1] * m[3], n[2] * m[0] + n[3] * m[2], n[2] * m[1] + n[3] * m[3]];\n      }\n      for (const v of period) verts.push(mul(m, v));\n    }\n    sails.push(verts.map((v) => [...v, ...eig(v[0], v[1])]));\n  }\n  // The K2 corner's bisector stands straight up.\n  const th1 = atan(al), th2 = atan(al2), gam = PI / 2 - (th1 + th2 + PI) / 2;\n  return { al, al2, e, le: log(e), M, eig, sails, cg: cos(gam), sg: sin(gam), th1, th2 };\n}\n\nexport function setup(params) {\n  params.s = { idx: -1, num: null, t: 0, buf: new Float32Array(W * H * 3), tail: new Float32Array(W * H), hue: -1, cols: [] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const idx = cl(round(kv[2]), 0, NUMS.length - 1);\n  if (idx !== S.idx) {\n    S.idx = idx;\n    S.num = NUMS[idx].prep || (NUMS[idx].prep = prepare(NUMS[idx]));\n    S.t = 0;\n    S.tail.fill(0);\n  }\n  S.zoom = cl(kv[3], 10, 22);\n  S.t += (d * 0.16 * cl(kv[1], 0.2, 3)) / S.num.le;\n  S.t -= floor(S.t);\n  S.dt = d;\n  if (kv[0] !== S.hue) {\n    S.hue = kv[0];\n    const h = kv[0] + 0.56;\n    S.cols = [hsv(h, 0.7, 1, [0, 0, 0]), hsv(h + 0.36, 0.55, 1, [0, 0, 0]), hsv(h + 0.2, 0.18, 0.88, [0, 0, 0]), hsv(h - 0.06, 0.55, 0.62, [0, 0, 0])];\n  }\n}\n\n// Lights a soft line from (x0, y0) to (x1, y1), its value kept where higher.\nfunction seg(buf, x0, y0, x1, y1, wid, rgb, k) {\n  if ((x0 \u003c -2 && x1 \u003c -2) || (x0 > W + 1 && x1 > W + 1) || (y0 \u003c -2 && y1 \u003c -2) || (y0 > H + 1 && y1 > H + 1)) return;\n  const X0 = max(0, floor(min(x0, x1) - wid)), X1 = min(W - 1, ceil(max(x0, x1) + wid));\n  const Y0 = max(0, floor(min(y0, y1) - wid)), Y1 = min(H - 1, ceil(max(y0, y1) + wid));\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy || 1e-9;\n  for (let y = Y0; y \u003c= Y1; y++)\n    for (let x = X0; x \u003c= X1; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / l2, 0, 1);\n      const ex = px - t * dx, ey = py - t * dy, a = cl(wid / 2 + 0.5 - sqrt(ex * ex + ey * ey), 0, 1) * k;\n      if (a \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = max(buf[o], rgb[0] * a);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * a);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * a);\n    }\n}\n\nfunction dot(buf, cx, cy, r, rgb, k) {\n  const X0 = max(0, floor(cx - r - 1)), X1 = min(W - 1, floor(cx + r + 1)), Y0 = max(0, floor(cy - r - 1)), Y1 = min(H - 1, floor(cy + r + 1));\n  for (let y = Y0; y \u003c= Y1; y++)\n    for (let x = X0; x \u003c= X1; x++) {\n      const ex = x + 0.5 - cx, ey = y + 0.5 - cy, a = cl(r + 0.5 - sqrt(ex * ex + ey * ey), 0, 1) * k;\n      if (a \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = max(buf[o], rgb[0] * a);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * a);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * a);\n    }\n}\n\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\nfunction digit(buf, d, x0, y0, rgb) {\n  const b = DIG[d];\n  for (let r = 0; r \u003c 5; r++)\n    for (let q = 0; q \u003c 3; q++) {\n      const x = x0 + q, y = y0 + r;\n      if (b[r * 3 + q] !== \"1\" || x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = rgb[0];\n      buf[o + 1] = rgb[1];\n      buf[o + 2] = rgb[2];\n    }\n}\n\n// The picture at flow time t: every lattice point n at M^t n, the sails\n// carried along with it. M^t stretches u by e^t and shrinks w by e^t.\nfunction frame(S, t, buf, tail) {\n  const N = S.num, z = S.zoom, et = exp(t * N.le), al = N.al, al2 = N.al2, { cg, sg } = N;\n  const [cA, cB, cL, cD] = S.cols;\n  // Plane (x, y) to panel.\n  const px = (x, y) => 32 + z * (x * cg - y * sg), py = (x, y) => 64 - z * (x * sg + y * cg);\n  const at = (u, w) => {\n    const U = u * et, V = w / et, x = U + V, y = U * al + V * al2;\n    return [px(x, y), py(x, y)];\n  };\n  buf.fill(0);\n  // Lattice points: the panel, two LEDs wider each way, pulled back by M^-t\n  // into the integer plane is a parallelogram; its columns are scanned.\n  const corners = [];\n  for (const [X, Y] of [[-2, -2], [W + 2, -2], [W + 2, H + 2], [-2, H + 2]]) {\n    const a = (X - 32) / z, b = (64 - Y) / z, x = a * cg + b * sg, y = -a * sg + b * cg;\n    const [u, w] = N.eig(x, y), U = u / et, V = w * et;\n    corners.push([U + V, U * al + V * al2]);\n  }\n  const xs = corners.map((c) => c[0]);\n  for (let x = ceil(min(...xs)); x \u003c= floor(max(...xs)); x++) {\n    let lo = Infinity, hi = -Infinity;\n    for (let i = 0; i \u003c 4; i++) {\n      const a = corners[i], b = corners[(i + 1) % 4];\n      if ((a[0] - x) * (b[0] - x) > 0 || a[0] === b[0]) continue;\n      const y = a[1] + ((x - a[0]) * (b[1] - a[1])) / (b[0] - a[0]);\n      lo = min(lo, y);\n      hi = max(hi, y);\n    }\n    for (let y = ceil(lo); y \u003c= floor(hi); y++) {\n      const [u, w] = N.eig(x, y), [X, Y] = at(u, w);\n      if (X \u003c -2 || X > W + 2 || Y \u003c -2 || Y > H + 2) continue;\n      // A small square of light split over the four LEDs nearest it, read\n      // from the LED centres so a point on a border splits evenly instead of\n      // tipping one way on a rounding error.\n      const cx = X - 0.5 + 1e-9, cy = Y - 0.5 + 1e-9, xi = floor(cx), yi = floor(cy), fx = cx - xi, fy = cy - yi;\n      for (const [dx, dy, a] of [[0, 0, (1 - fx) * (1 - fy)], [1, 0, fx * (1 - fy)], [0, 1, (1 - fx) * fy], [1, 1, fx * fy]]) {\n        const xx = xi + dx, yy = yi + dy;\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tail[yy * W + xx] = max(tail[yy * W + xx], 0.3 + 0.7 * a);\n      }\n    }\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const v = tail[i] * 0.8;\n    buf[i * 3] = cD[0] * v;\n    buf[i * 3 + 1] = cD[1] * v;\n    buf[i * 3 + 2] = cD[2] * v;\n  }\n  // The two lines, through the centre.\n  for (const th of [N.th1, N.th2]) {\n    const c = cos(th) * 200, s = sin(th) * 200;\n    seg(buf, px(-c, -s), py(-c, -s), px(c, s), py(c, s), 1, cL, 1);\n  }\n  // The four sails, their corners and the lattice points on their edges.\n  for (let k = 0; k \u003c 4; k++) {\n    const sail = N.sails[k & 1], sgn = k \u003c 2 ? 1 : -1, col = k & 1 ? cB : cA;\n    let prev = null;\n    for (let i = 0; i \u003c sail.length; i++) {\n      const v = sail[i], p = at(sgn * v[2], sgn * v[3]);\n      if (prev) {\n        seg(buf, prev[0], prev[1], p[0], p[1], 1.2, col, 0.85);\n        const a = sail[i - 1], g = gcd(v[0] - a[0], v[1] - a[1]);\n        for (let j = 1; j \u003c g; j++) {\n          const q = at(sgn * (a[2] + ((v[2] - a[2]) * j) / g), sgn * (a[3] + ((v[3] - a[3]) * j) / g));\n          dot(buf, q[0], q[1], 0.9, col, 1);\n        }\n        // The edge's a_k beside its middle, on the side away from the centre.\n        const mx = (prev[0] + p[0]) / 2, my = (prev[1] + p[1]) / 2, ln = Math.hypot(p[0] - prev[0], p[1] - prev[1]);\n        if (ln > 16.37 && g \u003c 10 && mx > 3.13 && mx \u003c W - 3.13 && my > 3.13 && my \u003c H - 3.13) {\n          const ox = mx - 32, oy = my - 64, on = Math.hypot(ox, oy) || 1;\n          digit(buf, g, round(mx + (ox / on) * 4.5 - 1 + 1e-6), round(my + (oy / on) * 4.5 - 2 + 1e-6), col);\n        }\n      }\n      prev = p;\n    }\n    for (const v of sail) {\n      const p = at(sgn * v[2], sgn * v[3]);\n      dot(buf, p[0], p[1], 1.5, col, 1);\n      dot(buf, p[0], p[1], 0.6, [255, 255, 255], 0.9);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.num) return;\n  const fade = exp(-S.dt / 0.3);\n  for (let i = 0; i \u003c W * H; i++) S.tail[i] *= fade;\n  frame(S, S.t, S.buf, S.tail);\n  const b = S.buf;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, b[o], b[o + 1], b[o + 2]);\n    }\n}\n","long-division":"// ===== Patternflow pattern =====\n// Title:   Long Division\n// Family:  type\n// Idea:    Long division of 1/p is written down the panel in drawn digits: a zero falls from the dividend, a quotient digit goes up top, the product is written under and ruled off, the remainder goes below, until a remainder comes back, it and the numerator glow gold and a bar is drawn over the repeating quotient digits.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the period of 1/p as the order of 10 mod p (Carl Friedrich Gauss, 1801), Midy's theorem (Etienne Midy, 1836), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Divisor=7..97, Base=10..16\n//\n// Knob 1: Hue. Turns the sheet round the wheel: at 0 the working is cyan and the quotient violet, and the remainder that comes halfway through an even period is green. The two numbers that close the cycle, the bar over the repetend and Midy's sum are always gold.\n// Knob 2: Speed. At 2 a step with a two-digit product takes 1.2 s and each later step 0.88 times the one before, down to 0.3 of it. 1/7 is worked out in 5.4 s, its bar is drawn by 7.0 s and Midy's sum by 8.6 s, and the next numerator comes at 11.1 s; 1/97 closes its cycle at 41.5 s. The first frame already has 2.4 s of the sheet written at the knob's speed. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Divisor. The prime p, snapped to the nearest prime from 7 to 97. In base 10 the quotient repeats after the order of 10 mod p: 6 digits for 7 and 13, 16 for 17, 18 for 19, 8 for 73, 96 for 97. When the sheet runs off the panel the view follows the staircase down and right, the quotient and dividend rows stay pinned at the top, and once the cycle closes the view runs back up the staircase while the bar is drawn. Each new sheet takes the next numerator, 1/p, 2/p, 3/p and on; for 7, 17, 19, 23, 29, 47, 59, 61 and 97 they all repeat the same digits from a different place.\n// Knob 4: Base. Works the division in bases 10 to 16, with A to F past nine. 1/7 has period 6 in base 10 (142857) and 12 (186A35), 3 in base 11 (163) and 16 (249), 2 in base 13 (1B), 1 in base 15 (2) and stops after one digit in base 14 (2). When the period is even, the remainder p - n comes exactly halfway and the two halves of the repetend add to a row of the base's top digit: 142 + 857 = 999, 186 + A35 = BBB. The sum is written in the corner when the halves are four digits or less.\n// Buttons: K1 tap goes on to the next numerator.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sin, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Digits 0-9, A-F and a plus sign, 6 x 7 with two-LED downstrokes, the way a\n// soft pencil leaves them on squared paper: an open 4, a flagged 1 with no\n// foot, a 9 with a tail.\nconst GLYPHS = [\n  [\".####.\", \"##..##\", \"##..##\", \"##..##\", \"##..##\", \"##..##\", \".####.\"],\n  [\"..##..\", \".###..\", \"..##..\", \"..##..\", \"..##..\", \"..##..\", \"..##..\"],\n  [\".####.\", \"##..##\", \"....##\", \"...##.\", \"..##..\", \".##...\", \"######\"],\n  [\".####.\", \"##..##\", \"....##\", \"..###.\", \"....##\", \"##..##\", \".####.\"],\n  [\"##..##\", \"##..##\", \"##..##\", \"######\", \"....##\", \"....##\", \"....##\"],\n  [\"######\", \"##....\", \"#####.\", \"....##\", \"....##\", \"##..##\", \".####.\"],\n  [\"..###.\", \".##...\", \"##....\", \"#####.\", \"##..##\", \"##..##\", \".####.\"],\n  [\"######\", \"....##\", \"...##.\", \"..##..\", \".##...\", \".##...\", \".##...\"],\n  [\".####.\", \"##..##\", \"##..##\", \".####.\", \"##..##\", \"##..##\", \".####.\"],\n  [\".####.\", \"##..##\", \"##..##\", \".#####\", \"....##\", \"...##.\", \".###..\"],\n  [\"..##..\", \".####.\", \"##..##\", \"##..##\", \"######\", \"##..##\", \"##..##\"],\n  [\"#####.\", \"##..##\", \"##..##\", \"#####.\", \"##..##\", \"##..##\", \"#####.\"],\n  [\".####.\", \"##..##\", \"##....\", \"##....\", \"##....\", \"##..##\", \".####.\"],\n  [\"####..\", \"##.##.\", \"##..##\", \"##..##\", \"##..##\", \"##.##.\", \"####..\"],\n  [\"######\", \"##....\", \"##....\", \"#####.\", \"##....\", \"##....\", \"######\"],\n  [\"######\", \"##....\", \"##....\", \"#####.\", \"##....\", \"##....\", \"##....\"],\n  [\"......\", \"..##..\", \"..##..\", \"######\", \"..##..\", \"..##..\", \"......\"],\n];\nconst PLUS = 16;\nconst FONT = GLYPHS.map((rows) => {\n  const m = new Uint8Array(42);\n  for (let y = 0; y \u003c 7; y++) for (let x = 0; x \u003c 6; x++) m[y * 6 + x] = rows[y][x] === \"#\" ? 1 : 0;\n  return m;\n});\n\n// The squared paper: cells 7 LEDs wide and 9 high. Row 0 holds the quotient,\n// row 1 the divisor, the bracket and the dividend; after that odd rows hold\n// a number brought down and even rows the product under it, nudged up one LED\n// so the rule under a product has a clear LED on both sides.\nconst CW = 7, CH = 9, X0 = 1, Y0 = 2, BR = 3, DP = 2, CLIP = 19;\nconst PRIMES = [7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];\n\nconst K_DIV = 0, K_NUM = 1, K_Q0 = 2, K_QUOT = 3, K_PROD = 4, K_REM = 5, K_DOWN = 6, K_MIDY = 7, K_SUM = 8;\n\nconst digits = (v, b) => {\n  const d = [];\n  do {\n    d.unshift(v % b);\n    v = floor(v / b);\n  } while (v > 0);\n  return d;\n};\nconst rowY = (r) => Y0 + r * CH - (r >= 2 && r % 2 === 0 ? 1 : 0);\n\nexport function setup(params) {\n  params.s = {\n    p: 0, b: 0, n: 1, sheet: null, t: 0, camX: 0, camY: 0, fresh: true,\n    hue: 0, speed: 2, buf: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// Lays the whole sheet out as a timeline: every glyph and rule gets its cell\n// and the sheet-second it is written, at Speed 2.\nfunction newSheet(S) {\n  const p = S.p, b = S.b, n = S.n;\n  const pd = digits(p, b), nd = digits(n, b), lenP = pd.length, c1 = lenP + nd.length - 1;\n  const items = [], rules = [], steps = [];\n  const add = (k, g, row, col, t0, d) => {\n    items.push({ k, g, row, col, t0, d, glow: 0, half: 0 });\n    return items.length - 1;\n  };\n  pd.forEach((g, i) => add(K_DIV, g, 1, i, 0.06 * i, 0.12));\n  const numItems = nd.map((g, i) => add(K_NUM, g, 1, lenP + i, 0.18 + 0.06 * i, 0.12));\n  add(K_Q0, 0, 0, c1, 0.4, 0.12);\n  let t = 0.6, r = n, rowN = 1, k = 0, end = null;\n  let remItems = numItems.slice();\n  const seen = new Map([[n, { step: 0, items: numItems.slice() }]]);\n  while (!end && k \u003c 200) {\n    k++;\n    const f = max(0.3, pow(0.88, k - 1));\n    const N = r * b, q = floor(N / p), P = q * p, r2 = N - P, cu = c1 + k;\n    const st = { k, q, cu, rowN, t0: t };\n    // The zero for step 1 is the dividend's own first zero; after that each\n    // one falls from the dividend row to sit beside the remainder.\n    if (k > 1) {\n      remItems.push(add(K_DOWN, 0, rowN, cu, t, 0.3 * f));\n      t += 0.36 * f;\n    } else remItems.push(-1);\n    st.tq = t;\n    add(K_QUOT, q, 0, cu, t, 0.2 * f);\n    t += 0.24 * f;\n    if (q > 0) {\n      const dp = digits(P, b);\n      for (let i = dp.length - 1; i >= 0; i--) {\n        add(K_PROD, dp[i], rowN + 1, cu - (dp.length - 1 - i), t, 0.1 * f);\n        t += 0.12 * f;\n      }\n      rules.push({ row: rowN + 1, a: cu - dp.length + 1, b: cu, t0: t, d: 0.12 * f });\n      t += 0.14 * f;\n      const dr = digits(r2, b);\n      remItems = [];\n      for (let i = dr.length - 1; i >= 0; i--) {\n        remItems.unshift(add(K_REM, dr[i], rowN + 2, cu - (dr.length - 1 - i), t, 0.1 * f));\n        t += 0.12 * f;\n      }\n      rowN += 2;\n    }\n    st.rowR = rowN;\n    steps.push(st);\n    if (r2 === 0) {\n      end = { term: true };\n      for (const i of remItems) if (i >= 0) items[i].glow = 1;\n    }\n    else if (seen.has(r2)) end = { from: seen.get(r2), mine: remItems.filter((i) => i >= 0) };\n    else seen.set(r2, { step: k, items: remItems.filter((i) => i >= 0) });\n    r = r2;\n    t += 0.08 * f;\n  }\n  const S2 = { p, b, n, lenP, c1, items, rules, steps, tEnd: t, end, L: 0, vin: null, midy: false };\n  let tail = t + 2.4;\n  if (end.from) {\n    const j = end.from.step, L = k - j;\n    S2.L = L;\n    for (const i of end.mine) items[i].glow = 1;\n    for (const i of end.from.items) items[i].glow = 1;\n    // Midy: with an even period the remainder halfway is p - n, and each\n    // quotient digit there on is the base's top digit minus the one half a\n    // period back.\n    if (L % 2 === 0) {\n      const half = steps[j + L / 2 - 1];\n      for (const it of items) if (it.k === K_REM && it.row === half.rowR && half.q > 0) it.half = 1;\n    }\n    const dV = 0.5 + 0.035 * L;\n    S2.vin = { a: c1 + j + 1, b: c1 + k, j, t0: t + 0.9, d: dV };\n    tail = t + 0.9 + dV + 0.3;\n    if (L % 2 === 0 && L / 2 \u003c= 4) {\n      // The sum is written in the corner the staircase leaves empty.\n      const qs = steps.slice(j, k).map((s) => s.q), h = L / 2;\n      let tm = tail;\n      const put = (k2, g, row, col) => {\n        add(k2, g, row, col, tm, 0.1);\n        tm += 0.11;\n      };\n      for (let i = 0; i \u003c h; i++) put(K_MIDY, qs[i], 11, 1 + i);\n      put(K_MIDY, PLUS, 12, 0);\n      for (let i = 0; i \u003c h; i++) put(K_MIDY, qs[h + i], 12, 1 + i);\n      S2.midyRule = { t0: tm, d: 0.15, a: 0, b: h };\n      tm += 0.2;\n      for (let i = h - 1; i >= 0; i--) put(K_SUM, b - 1, 13, 1 + i);\n      S2.midy = true;\n      tail = tm;\n    }\n    tail += 1.6;\n  }\n  // The sheet slides up by its own height, so a short one is not followed by\n  // an empty panel.\n  S2.lift = min(H + 12, rowY(max(S2.midy ? 13 : 0, rowN)) + 12);\n  S2.tOut = tail;\n  S2.tNext = tail + 0.9;\n  S.sheet = S2;\n  S.t = 0;\n  S.cur = 0;\n}\n\n// The x of a column before the view scrolls: the bracket takes three LEDs\n// between the divisor and the dividend, and the decimal point two.\nconst colX = (Sh, c) => X0 + c * CW + (c >= Sh.lenP ? BR : 0) + (c > Sh.c1 ? DP : 0);\n\nfunction camTarget(S) {\n  const Sh = S.sheet, t = S.t;\n  let row = 1, col = Sh.c1 + 1;\n  if (Sh.vin && t >= Sh.vin.t0) {\n    // Back up the staircase as the bar is drawn from the last digit to the first.\n    const u = ease((t - Sh.vin.t0) / Sh.vin.d), L = Sh.L;\n    const s = Sh.steps[Sh.vin.j + max(0, L - 1 - floor(u * L))];\n    row = s.rowR;\n    col = s.cu;\n    if (u >= 1) row = col = 0;\n  } else if (S.t >= 0.6) {\n    // Each step is framed when it starts: down to its remainder and across\n    // to the cell where the next zero will land.\n    const st = Sh.steps;\n    while (S.cur + 1 \u003c st.length && st[S.cur + 1].t0 \u003c= t) S.cur++;\n    const s = st[S.cur];\n    row = s.rowR;\n    col = s.cu + (S.cur + 1 \u003c st.length ? 1 : 0);\n  }\n  const tx = max(0, colX(Sh, col) + CW + 1 - W), ty = max(0, rowY(row) + 7 - (H - 1));\n  return [tx, ty];\n}\n\nfunction advance(S, d) {\n  S.t += d;\n  const Sh = S.sheet;\n  if (S.t >= Sh.tNext) {\n    S.n = (S.n % (S.p - 1)) + 1;\n    newSheet(S);\n    S.camX = S.camY = 0;\n    return;\n  }\n  const [tx, ty] = camTarget(S), k = 1 - exp(-d * (Sh.vin && S.t >= Sh.vin.t0 ? 9 : 6));\n  S.camX += (tx - S.camX) * k;\n  S.camY += (ty - S.camY) * k;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 7, 10];\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1], 0.2, 3);\n  const want = cl(kv[2], 7, 97);\n  let p = 7;\n  for (const q of PRIMES) if (abs(q - want) \u003c abs(p - want)) p = q;\n  const b = cl(round(kv[3]), 10, 16);\n  if (p !== S.p || b !== S.b) {\n    S.p = p;\n    S.b = b;\n    S.n = 1;\n    newSheet(S);\n    S.camX = S.camY = 0;\n  }\n  if (input.btnPressed && input.btnPressed[0]) S.sheet.tNext = S.t;\n  const step = 1 / 30;\n  if (S.fresh) {\n    // The first frame comes with 2.4 s of the sheet already written.\n    S.fresh = false;\n    for (let i = 0; i \u003c 72; i++) advance(S, (step * S.speed) / 2);\n  }\n  let rem = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  while (rem > 1e-9) {\n    const d = min(step, rem);\n    advance(S, d);\n    rem -= d;\n  }\n}\n\nfunction hash(a, b, c) {\n  let h = Math.imul(a, 73856093) ^ Math.imul(b, 19349663) ^ Math.imul(c, 83492791);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) & 255) / 255;\n}\n\nfunction put(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  if (r > buf[o]) buf[o] = r;\n  if (g > buf[o + 1]) buf[o + 1] = g;\n  if (b > buf[o + 2]) buf[o + 2] = b;\n}\n\n// One glyph, written top to bottom as u goes from 0 to 1, with the grain of\n// a pencil: each LED of each written glyph keeps its own pressure.\nfunction glyph(S, g, x0, y0, u, rgb, seed, yMin, xMin) {\n  const m = FONT[g], rows = u >= 1 ? 7 : floor(u * 7.99), buf = S.buf;\n  for (let y = 0; y \u003c rows; y++) {\n    const yy = y0 + y;\n    if (yy \u003c yMin || yy >= H) continue;\n    for (let x = 0; x \u003c 6; x++) {\n      if (!m[y * 6 + x] || x0 + x \u003c xMin) continue;\n      const v = 0.8 + 0.2 * hash(seed, x, y);\n      put(buf, x0 + x, yy, rgb[0] * v, rgb[1] * v, rgb[2] * v);\n    }\n  }\n}\n\nfunction hline(S, x0, x1, y, rgb, yMin) {\n  if (y \u003c yMin || y >= H) return;\n  for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) put(S.buf, x, y, rgb[0], rgb[1], rgb[2]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.sheet) return;\n  const Sh = S.sheet, buf = S.buf, t = S.t, c = S.c, h0 = S.hue + 0.5;\n  buf.fill(0);\n  const out = t > Sh.tOut ? round(ease((t - Sh.tOut) / 0.9) * Sh.lift) : 0;\n  const camX = round(S.camX), camY = round(S.camY), fx = colX(Sh, Sh.c1 + 1);\n  // Once the view has scrolled, the pinned rows keep one empty cell after the\n  // decimal point with an ellipsis in it, so 0.0103 never reads as 0.03.\n  const xCut = S.camX >= 1 ? fx + CW : -99;\n  const pulse = 0.82 + 0.18 * sin((t - Sh.tEnd) * 6);\n  const gold = [0, 0, 0], work = [0, 0, 0], quot = [0, 0, 0], ink = [0, 0, 0];\n  hsv(0.13, 0.55, pulse, gold);\n  hsv(h0 + 0.25, 0.7, 1, quot);\n  const yMinWork = CLIP - out;\n  // Where a cell lands on the panel: rows 0 and 1 stay pinned at the top,\n  // and the columns at and left of the numerator's last digit stay put.\n  const at = (row, col) => {\n    const pinnedRow = row \u003c= 1, frozen = pinnedRow && col \u003c= Sh.c1;\n    const x = colX(Sh, col) - (frozen ? 0 : camX) + 1;\n    const y = rowY(row) - (pinnedRow ? 0 : camY) - out;\n    return [x, y, pinnedRow && !frozen];\n  };\n  // The dividend's zeros, as far as the paper goes.\n  hsv(h0, 0.5, 0.5, work);\n  const cur = Sh.steps.length ? Sh.c1 + Sh.steps.length + 2 : 0;\n  for (let col = Sh.c1 + 1; col \u003c Sh.c1 + 199; col++) {\n    const [x, y] = at(1, col);\n    if (x >= W || col > cur) break;\n    if (x \u003c xCut - 6 || t \u003c 0.3 + 0.03 * (col - Sh.c1)) continue;\n    glyph(S, 0, x, y, 1, work, col * 7 + 3, -99, xCut);\n  }\n  // The bracket and the bar over the dividend, then the decimal points.\n  hsv(h0, 0.35, 0.8, ink);\n  const bx = colX(Sh, Sh.lenP) - 2, by = rowY(1) - out, y0 = rowY(0) - out;\n  const ub = cl((t - 0.1) / 0.4, 0, 1);\n  if (ub > 0) {\n    put(buf, bx, by - 1, ink[0], ink[1], ink[2]);\n    put(buf, bx, by, ink[0], ink[1], ink[2]);\n    for (let y = by + 1; y \u003c by + 7; y++) put(buf, bx + 1, y, ink[0], ink[1], ink[2]);\n    put(buf, bx, by + 7, ink[0], ink[1], ink[2]);\n    hline(S, bx + 1, bx + 1 + round((W - bx) * ub), by - 1, ink, -99);\n    put(buf, fx - 1, by + 6, ink[0], ink[1], ink[2]);\n    if (t > 0.45) put(buf, fx - 1, y0 + 6, quot[0], quot[1], quot[2]);\n    if (xCut > 0)\n      for (let i = 1; i \u003c 6; i += 2) {\n        put(buf, fx + i, by + 6, work[0], work[1], work[2]);\n        if (t > 0.6) put(buf, fx + i, y0 + 6, quot[0] * 0.6, quot[1] * 0.6, quot[2] * 0.6);\n      }\n  }\n  // The rules under the products.\n  hsv(h0, 0.5, 0.62, ink);\n  for (const r of Sh.rules) {\n    if (t \u003c r.t0) break;\n    const [xa, y] = at(r.row, r.a), [xb] = at(r.row, r.b);\n    if (y + 8 \u003c yMinWork || y >= H || xb + 6 \u003c 0 || xa - 1 >= W) continue;\n    const u = cl((t - r.t0) / r.d, 0, 1);\n    hline(S, xb + 6 - round((xb + 7 - xa) * u), xb + 6, y + 8, ink, yMinWork);\n  }\n  if (Sh.midyRule && t >= Sh.midyRule.t0) {\n    const u = cl((t - Sh.midyRule.t0) / Sh.midyRule.d, 0, 1), y = rowY(12) + 8 - out;\n    hline(S, X0, X0 + round((Sh.midyRule.b * CW + 7) * u), y, ink, -99);\n  }\n  // Every glyph written so far.\n  const glowOn = t >= Sh.tEnd;\n  for (let i = 0; i \u003c Sh.items.length; i++) {\n    const it = Sh.items[i];\n    if (t \u003c it.t0) break;\n    let x, y, pinned;\n    if (it.k === K_MIDY || it.k === K_SUM) {\n      x = X0 + it.col * CW + 1;\n      y = rowY(it.row) - out;\n      pinned = false;\n    } else [x, y, pinned] = at(it.row, it.col);\n    let u = (t - it.t0) / it.d;\n    if (it.k === K_DOWN && u \u003c 1) {\n      // The zero falls from the dividend row to its place.\n      const y1 = rowY(1) - out, e = ease(u);\n      y = round(y1 + (y - y1) * e);\n      u = 1;\n    }\n    if (x \u003c= -6 || x >= W || y \u003c= -8 || y >= H) continue;\n    const yMin = it.row >= 2 ? yMinWork : -99;\n    let rgb;\n    if (it.glow && glowOn) rgb = gold;\n    else {\n      const k = it.k;\n      if (k === K_DIV) hsv(h0, 0.3, 0.95, c);\n      else if (k === K_QUOT || k === K_Q0 || k === K_MIDY) hsv(h0 + 0.25, 0.7, 1, c);\n      else if (k === K_SUM) hsv(0.13, 0.55, 1, c);\n      else if (it.half) hsv(h0 - 0.17, 0.6, 1, c);\n      else hsv(h0, 0.7, k === K_PROD ? 0.78 : k === K_DOWN ? 0.88 : 1, c);\n      // Fresh graphite: white as it is written, settling into its colour.\n      const w = 1 - cl((t - it.t0 - it.d) / 0.35, 0, 1);\n      c[0] += (255 - c[0]) * w * 0.85;\n      c[1] += (255 - c[1]) * w * 0.85;\n      c[2] += (255 - c[2]) * w * 0.85;\n      rgb = c;\n    }\n    glyph(S, it.g, x, y, cl(u, 0, 1), rgb, i * 13 + 5, yMin, pinned ? xCut : -99);\n  }\n  // The bar over the repetend, drawn from its last digit back to its first.\n  if (Sh.vin && t >= Sh.vin.t0) {\n    const v = Sh.vin, u = ease((t - v.t0) / v.d);\n    const [xa] = at(0, v.a), [xb] = at(0, v.b), y = y0 - 2;\n    const xl = round(xb + 6 - (xb + 6 - xa) * u);\n    hline(S, max(xl, xCut, fx - 1), xb + 6, y, gold, -99);\n  }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p & 63, p >> 6, buf[p * 3], buf[p * 3 + 1], buf[p * 3 + 2]);\n}\n","mcmullen-carpet":"// ===== Patternflow pattern =====\n// Title:   McMullen Carpet\n// Family:  fractal\n// Idea:    A Bedford-McMullen self-affine carpet fills the panel: the square is cut into m columns and n > m rows, a few cells are kept and the same cut repeats inside each, every LED is shaded by how much of it stays kept level after level, and the view zooms m times across and n times down into one kept cell until the picture comes back exactly, which an even zoom never does.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: self-affine carpets (Tim Bedford, 1984; Curtis T. McMullen, 1984), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pattern=0..5, Iso=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the points that stay in the kept cells all the way down are near white, the holes cut at deeper levels step from dark blue through teal to pale cyan, the holes cut at the first level are black, and the two dimensions in the corner are pale gold. The holes skip orange, which reads brown when dark.\n// Knob 2: Speed. How fast the view zooms. At 2 one level, m times across and n times down, takes 3 s; at 0.2 30 s and at 3 2 s. Each level dives into a kept cell picked at random, and since the picture at the end of a level is the picture at its start, the dive never jumps.\n// Knob 3: Pattern. Six carpets, m columns across and n rows down, n always on the long side. The corner gives the Hausdorff dimension, log_m of the sum over columns of t_j^(log_n m) with t_j the kept cells in column j (McMullen), over the box dimension log_m r + log_n(N / r) with r the columns that keep a cell and N the kept cells. 0: 2 x 3, t = 3, 1, 1.585 (log_2 3) and 1.631. 1: 3 x 4, t = 4, 1, 2, 1.589 and 1.611. 2: 2 x 3, t = 2, 1, 1.350 and 1.369. 3: 3 x 5, t = 5, 1, 2, 1.569 and 1.609. 4: 2 x 6, t = 5, 1, 1.518 and 1.613. 5: 2 x 4, t = 2, 2, every column keeping the same number, and both are 1.500.\n// Knob 4: Iso. Up to 0.1 the zoom is the affine one, m^t across and n^t down, and repeats every level. Above it the vertical rate slides from n towards m, so at 1 the zoom is the same in both directions: the picture never comes back, the carpet flattens into wide bands, and after two levels the view fades and starts again from the whole square.\n\nconst W = 64, H = 128;\nconst { floor, min, max, log, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The carpets: m columns across, n rows down, rows written top to bottom,\n// X for a kept cell.\nconst PATTERNS = [\n  { m: 2, n: 3, rows: [\"X.\", \"XX\", \"X.\"] },\n  { m: 3, n: 4, rows: [\"X.X\", \"XX.\", \"X..\", \"X.X\"] },\n  { m: 2, n: 3, rows: [\"X.\", \".X\", \"X.\"] },\n  { m: 3, n: 5, rows: [\"X.X\", \"X..\", \"XX.\", \"X.X\", \"X..\"] },\n  { m: 2, n: 6, rows: [\"X.\", \"X.\", \".X\", \"X.\", \"X.\", \"X.\"] },\n  { m: 2, n: 4, rows: [\"X.\", \".X\", \"X.\", \".X\"] },\n];\n\n// Dimensions of one carpet. The column counts t_j go over the m columns,\n// the strips of the weaker contraction 1/m.\nfunction dims(P) {\n  const { m, n, rows } = P, t = new Array(m).fill(0);\n  let N = 0;\n  for (let b = 0; b \u003c n; b++) for (let a = 0; a \u003c m; a++) if (rows[b][a] === \"X\") t[a]++, N++;\n  const th = log(m) / log(n);\n  let s = 0, r = 0;\n  for (const x of t) if (x) (s += pow(x, th)), r++;\n  return { t, N, r, haus: log(s) / log(m), box: log(r) / log(m) + log(N / r) / log(n) };\n}\n\n// The holes are dark, and a dark orange reads brown on the panel, so their\n// hues go round a wheel with orange (0.03 to 0.16) cut out.\nconst wheel = (h) => 0.16 + (h - floor(h)) * 0.87;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Samples per LED: 2 across and 4 down, since the cells flatten as they\n// shrink and the vertical detail runs out first.\nconst SX = 2, SY = 4, CS = W * SX, RS = H * SY, KMAX = 12, PAL = 32;\n\nexport function setup(params) {\n  params.s = {\n    pat: -1, P: null, D: null, info: null,\n    t: 0, cell: [0, 0], iso: 0, fade: 1, hue: 0, speed: 2,\n    xa: new Uint8Array(CS * KMAX), yb: new Uint8Array(RS * KMAX),\n    lev: new Float32Array(W * H * 3), pal: new Float32Array(3 * (PAL + 1)),\n    cs: new Float32Array(3 * KMAX), bl: new Float32Array(3 * KMAX), mean: new Float32Array(6), tmp: new Float32Array(3), L0: 4,\n  };\n}\n\nfunction choose(S, k) {\n  S.pat = k;\n  const P = PATTERNS[k];\n  S.P = P;\n  S.D = new Uint8Array(P.m * P.n);\n  S.kept = [];\n  for (let b = 0; b \u003c P.n; b++) for (let a = 0; a \u003c P.m; a++) if (P.rows[b][a] === \"X\") (S.D[a * P.n + b] = 1), S.kept.push([a, b]);\n  S.info = dims(P);\n  // At t = 0 the digits run until a cell is about one and a half samples\n  // tall; the shades are spread over that many levels and one more.\n  S.L0 = log(RS / 1.5) / log(P.n);\n  S.t = 0;\n  S.fade = 1;\n  pick(S);\n}\n\n// The next level dives into a kept cell picked at random, preferring one\n// off the top and bottom rows so the dive stays on the panel's middle.\nfunction pick(S) {\n  const n = S.P.n, inner = S.kept.filter(([, b]) => b > 0 && b \u003c n - 1);\n  const pool = inner.length ? inner : S.kept;\n  S.cell = pool[floor(Math.random() * pool.length)];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const k = cl(round(kv[2]), 0, PATTERNS.length - 1);\n  if (k !== S.pat) choose(S, k);\n  S.iso = kv[3] \u003c= 0.1 ? 0 : cl((kv[3] - 0.1) / 0.9, 0, 1);\n  S.t += (d * S.speed) / 6;\n  if (S.iso === 0) {\n    S.fade = min(1, S.fade + d * 3);\n    if (S.t >= 1) {\n      S.t -= 1;\n      pick(S);\n    }\n  } else {\n    // The even zoom does not come back to its start, so it runs two levels\n    // and fades out, and the whole square fades back in.\n    const T = 2;\n    S.fade = S.t \u003c 0.12 ? S.t / 0.12 : S.t > T - 0.25 ? max(0, (T - S.t) / 0.25) : 1;\n    if (S.t >= T) {\n      S.t = 0;\n      pick(S);\n    }\n  }\n}\n\n// 3 x 5 digits and the letters the corner needs.\nconst GL = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001001001001\", 8: \"111101111101111\", 9: \"111101111001111\",\n  \".\": \"000000000000010\", H: \"101101111101101\", B: \"110101110101110\", \" \": \"000000000000000\",\n};\n\nfunction text(buf, s, x0, y0, r, g, b) {\n  for (let i = 0; i \u003c s.length; i++) {\n    const m = GL[s[i]];\n    if (!m) continue;\n    const w = s[i] === \".\" ? 2 : 4, dx = s[i] === \".\" ? -1 : 0;\n    for (let y = 0; y \u003c 5; y++)\n      for (let x = 0; x \u003c 3; x++)\n        if (m[y * 3 + x] === \"1\") {\n          const o = ((y0 + y) * W + x0 + x + dx) * 3;\n          buf[o] = r;\n          buf[o + 1] = g;\n          buf[o + 2] = b;\n        }\n    x0 += w;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const { m, n } = S.P, t = S.t, D = S.D, xa = S.xa, yb = S.yb, pal = S.pal, buf = S.lev;\n  const [a, b] = S.cell;\n  // The zoom's centre is the fixed point of the map into cell (a, b),\n  // (x, y) -> ((x + a) / m, (y + b) / n): x* = a / (m - 1), y* = b / (n - 1).\n  const fx = a / (m - 1), fy = b / (n - 1);\n  const sx = pow(m, -t), sy = pow(n, -t * (1 - S.iso)) * pow(m, -t * S.iso);\n  // Base-m digits of every column sample and base-n digits of every row\n  // sample, KMAX deep. A sample is in the level-k carpet when its first k\n  // digit pairs are all kept cells.\n  for (let c = 0; c \u003c CS; c++) {\n    let x = fx + ((c + 0.5) / CS - fx) * sx;\n    x = cl(x, 0, 1 - 1e-12);\n    for (let k = 0; k \u003c KMAX; k++) {\n      const dgt = floor(x * m);\n      xa[c * KMAX + k] = dgt;\n      x = x * m - dgt;\n    }\n  }\n  for (let r = 0; r \u003c RS; r++) {\n    let y = fy + ((r + 0.5) / RS - fy) * sy;\n    y = cl(y, 0, 1 - 1e-12);\n    for (let k = 0; k \u003c KMAX; k++) {\n      const dgt = floor(y * n);\n      yb[r * KMAX + k] = dgt;\n      y = y * n - dgt;\n    }\n  }\n  // Shading. A sample that leaves the kept cells at level e is a hole cut\n  // e levels down, and the level is read t levels down, v = e - t, so at\n  // t = 1 every value is what it was at t = 0 and the loop has no seam.\n  // Below the level whose cells are a sample tall the digits stop: the\n  // sample takes the mean shade of what a kept cell holds, since a share\n  // rho = N / (m n) of its area stays kept at every further level. Two stop\n  // levels are blended so the stop never pops.\n  const h0 = S.hue + 0.42, VC = S.L0 + 1, rho = S.info.N / (m * n);\n  for (let q = 0; q \u003c= PAL; q++) {\n    const v = (q / PAL) * VC, u = v / VC;\n    if (q === PAL) hsv(wheel(h0 - 0.02), 0.12, 1, pal, q * 3);\n    else hsv(wheel(h0 + 0.06 - 0.1 * u), 0.8 - 0.5 * u, v \u003c 0.02 ? 0 : 0.1 + 0.75 * pow(u, 0.9), pal, q * 3);\n  }\n  const shade = (v, out, o) => {\n    const p = v \u003c= 0 ? 0 : v >= VC ? PAL : (v / VC) * PAL;\n    const q0 = floor(p), fr = p - q0, q1 = min(PAL, q0 + 1);\n    out[o] = pal[q0 * 3] * (1 - fr) + pal[q1 * 3] * fr;\n    out[o + 1] = pal[q0 * 3 + 1] * (1 - fr) + pal[q1 * 3 + 1] * fr;\n    out[o + 2] = pal[q0 * 3 + 2] * (1 - fr) + pal[q1 * 3 + 2] * fr;\n  };\n  const Lf = log(RS / (1.5 * sy)) / log(n);\n  const ks = min(KMAX - 2, max(1, floor(Lf))), kf = cl(Lf - ks, 0, 1), cs = S.cs, mean = S.mean;\n  for (let e = 0; e \u003c= ks + 1; e++) shade(e - t, cs, e * 3);\n  for (let L = ks; L \u003c= ks + 1; L++) {\n    let R = 0, G = 0, B = 0, w = 1;\n    for (let j = 0; j \u003c 24; j++) {\n      const pj = j === 23 ? w : w * (1 - rho);\n      shade(L + j - t, S.tmp, 0);\n      R += S.tmp[0] * pj;\n      G += S.tmp[1] * pj;\n      B += S.tmp[2] * pj;\n      w *= rho;\n    }\n    mean[(L - ks) * 3] = R;\n    mean[(L - ks) * 3 + 1] = G;\n    mean[(L - ks) * 3 + 2] = B;\n  }\n  // The colour of a sample that stays in e levels: below ks the mean if it\n  // got that far, the hole if not; the same at ks + 1; then the blend.\n  const f = S.fade / (SX * SY), k2 = ks + 1, bl = S.bl;\n  for (let e = 0; e \u003c= k2; e++)\n    for (let c = 0; c \u003c 3; c++) {\n      const v0 = e \u003c ks ? cs[e * 3 + c] : mean[c], v1 = e \u003c k2 ? cs[e * 3 + c] : mean[3 + c];\n      bl[e * 3 + c] = (v0 + (v1 - v0) * kf) * f;\n    }\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      let R = 0, G = 0, B = 0;\n      for (let j = 0; j \u003c SY; j++) {\n        const yo = (py * SY + j) * KMAX;\n        for (let i = 0; i \u003c SX; i++) {\n          const xo = (px * SX + i) * KMAX;\n          let e = 0;\n          while (e \u003c k2 && D[xa[xo + e] * n + yb[yo + e]]) e++;\n          R += bl[e * 3];\n          G += bl[e * 3 + 1];\n          B += bl[e * 3 + 2];\n        }\n      }\n      const o = (py * W + px) * 3;\n      buf[o] = R;\n      buf[o + 1] = G;\n      buf[o + 2] = B;\n    }\n  // The two dimensions, Hausdorff over box, on a dark plate in the corner.\n  const hs = \"H\" + S.info.haus.toFixed(3), bs = \"B\" + S.info.box.toFixed(3);\n  for (let y = H - 15; y \u003c H; y++)\n    for (let x = 0; x \u003c 25; x++) {\n      const o = (y * W + x) * 3;\n      buf[o] *= 0.2;\n      buf[o + 1] *= 0.2;\n      buf[o + 2] *= 0.2;\n    }\n  const tc = [0, 0, 0];\n  hsv(S.hue + 0.12, 0.45, 0.95, tc, 0);\n  text(buf, hs, 2, H - 14, tc[0], tc[1], tc[2]);\n  text(buf, bs, 2, H - 7, tc[0] * 0.8, tc[1] * 0.8, tc[2] * 0.8);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, buf[o] | 0, buf[o + 1] | 0, buf[o + 2] | 0);\n    }\n}\n","mouse-tale":"// ===== Patternflow pattern =====\n// Title:   Mouse's Tale\n// Family:  type\n// Idea:    Lewis Carroll's Mouse's Tale hangs down the panel as the tail it was printed as, one or two words a line, each line set where the tail's curve has got to and in smaller type the lower it hangs, from a hand-drawn 5 by 7 face through 4 by 6 and 3 by 5 to the bare shapes of the words, a dot a letter and a dot a word at the tip, while the tail sways slowly and the poem runs down it, new lines coming in at the top and the last ones fading at the tip.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: The Mouse's Tale, a figured poem (Lewis Carroll, Alice's Adventures in Wonderland, 1865), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sway=1..3, Taper=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel. At 0 the top of the tail is aqua, and the ink turns through green to a yellow at the tip, deeper the lower it hangs.\n// Knob 2: Speed. How fast the poem runs down the tail: half a line a second at 2, so the 53 lines come round every 106 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Sway. How far the tail swings. At 1 it bends gently and sways once every 9 s; at 3 the bends reach 1.6 times as far, the tip lashes from wall to wall, and it sways once every 4.5 s.\n// Knob 4: Taper. How soon the type shrinks. Near 0 the 5 by 7 face holds the top 54 rows, six lines, then two lines of 4 by 6, three of 3 by 5, four of word shapes, six of a dot a letter and five of a dot a word: 26 lines. At 1 only the top line is big, and 42 lines hang there, 30 of them dots.\n\n// Carroll set the tale in Chapter III so that it reads down a mouse's long\n// tail: short lines, each shifted to follow the curve, and the type stepping\n// down in size until the last words are tiny. Here the poem loops: the line\n// that comes in at the top is the one before the top line, so the tail always\n// reads downward in the poem's order, and the last line, death, sits just\n// above the first, Fury said.\n//\n// The text is the 1865 tale as the common reprints give it, with the italic\n// \"you\" set plain. The three faces are drawn here, 5 by 7, 4 by 6 and 3 by 5,\n// each with its descenders lifted into the cell as small LCD faces do. Below\n// those every letter keeps only its word shape on 2 by 3: an ascender LED,\n// a body LED or two, a descender LED. Then one LED a letter, then one a word.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sin, PI, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  out[1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  out[2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n}\n\n// The three drawn faces. Each glyph is its width, then one base-32 digit a\n// row from the top, the leftmost LED the highest bit: \"a\" in 5 by 7 is\n// 5, then 0 0 e 1 f h f, rows .....  .....  .###.  ....#  .####  #...#  .####\nconst FACES = [\n  { \"a\": \"500e1fhf\", \"b\": \"5ggmphhu\", \"c\": \"500egghe\", \"d\": \"511djhhf\", \"e\": \"500ehvge\", \"f\": \"5698s888\", \"g\": \"50fhhf1e\", \"h\": \"5ggmphhh\", \"i\": \"540c444e\", \"j\": \"520622ic\", \"k\": \"5ggikoki\", \"l\": \"5c44444e\", \"m\": \"500qllhh\", \"n\": \"500mphhh\", \"o\": \"500ehhhe\", \"p\": \"500uhugg\", \"r\": \"500mpggg\", \"s\": \"500ege1u\", \"t\": \"588s8896\", \"u\": \"500hhhjd\", \"v\": \"500hhha4\", \"w\": \"500hhlla\", \"y\": \"500hhf1e\", \"C\": \"5ehggghe\", \"F\": \"5vgguggg\", \"I\": \"5e44444e\", \"L\": \"5ggggggv\", \"S\": \"5fgge11u\", \"T\": \"5v444444\", \"W\": \"5hhhllla\", \",\": \"20000312\", \".\": \"20000033\", \"'\": \"23120000\", \":\": \"20330033\", \";\": \"20330312\", \"-\": \"5000v000\", \"\\\"\": \"5r9i0000\" },\n  { \"a\": \"4007997\", \"b\": \"488e99e\", \"c\": \"4007887\", \"d\": \"4117997\", \"e\": \"4006f87\", \"f\": \"434e444\", \"g\": \"4079716\", \"h\": \"488e999\", \"i\": \"1101111\", \"j\": \"3101152\", \"k\": \"4889ae9\", \"l\": \"2222221\", \"m\": \"500ulll\", \"n\": \"400e999\", \"o\": \"4006996\", \"p\": \"40e9e88\", \"r\": \"3005644\", \"s\": \"4007c3e\", \"t\": \"3227221\", \"u\": \"4009997\", \"v\": \"3005552\", \"w\": \"500hlla\", \"y\": \"4099716\", \"C\": \"4788887\", \"F\": \"4f8e888\", \"I\": \"3722227\", \"L\": \"488888f\", \"S\": \"478611e\", \"T\": \"3722222\", \"W\": \"5hhllla\", \",\": \"2000012\", \".\": \"1000001\", \"'\": \"2120000\", \":\": \"1001001\", \";\": \"2001012\", \"-\": \"4000f00\", \"\\\"\": \"3550000\" },\n  { \"a\": \"300353\", \"b\": \"344656\", \"c\": \"300343\", \"d\": \"311353\", \"e\": \"300376\", \"f\": \"212322\", \"g\": \"303536\", \"h\": \"344655\", \"i\": \"110111\", \"j\": \"210112\", \"k\": \"344565\", \"l\": \"111111\", \"m\": \"500ull\", \"n\": \"300655\", \"o\": \"300252\", \"p\": \"306564\", \"r\": \"200322\", \"s\": \"300326\", \"t\": \"322723\", \"u\": \"300553\", \"v\": \"300552\", \"w\": \"500lla\", \"y\": \"305536\", \"C\": \"334443\", \"F\": \"374644\", \"I\": \"372227\", \"L\": \"344447\", \"S\": \"334216\", \"T\": \"372222\", \"W\": \"5hhlla\", \",\": \"100011\", \".\": \"100001\", \"'\": \"111000\", \":\": \"101001\", \";\": \"101011\", \"-\": \"300700\", \"\\\"\": \"355000\" },\n];\n\n// The six sizes down the tail: the three faces, word shapes on 2 by 3, a\n// dot a letter, a dot a word. Height, line pitch, the width of a space and\n// the gap between letters.\nconst SIZES = [\n  { h: 7, pitch: 9, space: 4, gap: 1 },\n  { h: 6, pitch: 8, space: 3, gap: 1 },\n  { h: 5, pitch: 6, space: 3, gap: 1 },\n  { h: 3, pitch: 4, space: 2, gap: 1 },\n  { h: 1, pitch: 2, space: 1, gap: 0 },\n  { h: 1, pitch: 2, space: 1, gap: 0 },\n];\nconst LAST = SIZES.length - 1;\n// How bright the shadow under the faces is, against its letter.\nconst SHADOW = 0.22;\n\n// Word shapes: a letter on 2 by 3 keeps whether it rises, sits or hangs.\nconst RISE = \"bdfhklt\", HANG = \"gjpy\", NARROW = \"fijlrt\", RIGHT = \"dgjy\";\nfunction shape(ch) {\n  if (ch === \"I\") return [1, [1, 1, 0]];\n  if (ch === \"W\") return [3, [7, 7, 0]];\n  if (ch >= \"A\" && ch \u003c= \"Z\") return [2, [3, 3, 0]];\n  if (ch === \",\") return [1, [0, 0, 1]];\n  if (ch === \"'\" || ch === '\"') return [1, [1, 0, 0]];\n  if (ch === \"-\") return [2, [0, 3, 0]];\n  if (\".:;\".includes(ch)) return [1, [0, 1, 0]];\n  const w = NARROW.includes(ch) ? 1 : ch === \"m\" || ch === \"w\" ? 3 : 2;\n  const stem = w === 1 ? 1 : RIGHT.includes(ch) ? 1 : 1 \u003c\u003c (w - 1);\n  return [w, [RISE.includes(ch) ? stem : 0, (1 \u003c\u003c w) - 1, HANG.includes(ch) ? stem : 0]];\n}\n\nfunction glyph(size, ch) {\n  if (size >= 3) return shape(ch);\n  const code = FACES[size][ch];\n  if (!code) return [2, [0, 0, 0, 0, 0, 0, 0].slice(0, SIZES[size].h)];\n  const rows = [];\n  for (let i = 1; i \u003c code.length; i++) rows.push(parseInt(code[i], 32));\n  return [+code[0], rows];\n}\n\n// One line drawn at one size: width, height and its lit LEDs.\nfunction render(text, size) {\n  const S = SIZES[size], h = S.h;\n  if (size === LAST) {\n    const words = text.split(\" \").length, w = 2 * words - 1, bits = new Uint8Array(w);\n    for (let i = 0; i \u003c words; i++) bits[2 * i] = 1;\n    return { w, h, bits };\n  }\n  const parts = [];\n  let w = 0, joined = false;\n  for (const ch of text) {\n    if (ch === \" \") {\n      w += S.space;\n      joined = false;\n      continue;\n    }\n    if (joined) w += S.gap;\n    const [gw, rows] = size === 4 ? [1, [1]] : glyph(size, ch);\n    parts.push({ x: w, gw, rows });\n    w += gw;\n    joined = true;\n  }\n  const bits = new Uint8Array(max(1, w) * h);\n  for (const p of parts)\n    for (let r = 0; r \u003c h; r++)\n      for (let c = 0; c \u003c p.gw; c++) if ((p.rows[r] >> (p.gw - 1 - c)) & 1) bits[r * w + p.x + c] = 1;\n  return { w, h, bits };\n}\n\n// The tale, broken into lines of one or two words that fit 50 LEDs in the\n// largest face. The em dash after \"you.\" is set as a dash.\nconst TALE =\n  \"'Fury said to a mouse, That he met in the house, \\\"Let us both go to law: I will prosecute you.- Come, I'll take no denial; \" +\n  \"We must have a trial: For really this morning I've nothing to do.\\\" Said the mouse to the cur, \\\"Such a trial, dear Sir, \" +\n  \"With no jury or judge, would be wasting our breath.\\\" \\\"I'll be judge, I'll be jury,\\\" Said cunning old Fury: \" +\n  \"\\\"I'll try the whole cause, and condemn you to death.\\\"'\";\n\nfunction breakLines() {\n  const words = TALE.split(\" \"), lines = [];\n  for (let i = 0; i \u003c words.length; ) {\n    const two = i + 1 \u003c words.length ? words[i] + \" \" + words[i + 1] : null;\n    if (two && render(two, 0).w \u003c= 50) (lines.push(two), (i += 2));\n    else lines.push(words[i++]);\n  }\n  return lines;\n}\n\nexport function setup(params) {\n  const lines = breakLines();\n  params.s = {\n    lines,\n    drawn: lines.map((t) => SIZES.map((_, k) => render(t, k))),\n    q: 0, t: 0, hue: 0, speed: 2, sway: 1, taper: 0.06,\n    Y: new Float32Array(80), buf: new Float32Array(W * H * 3), ink: new Uint8Array(W * H), c: [0, 0, 0],\n  };\n}\n\n// How far down the sizes the tail is at row y, 0 at the top to 5.9 at the\n// tip; the size is its whole part.\nconst depth = (S, y) => 5.9 * pow(cl(y / H, 0, 1), 1.85 - 1.25 * S.taper);\nconst sizeAt = (S, y) => min(LAST, floor(depth(S, y)));\n\n// The tail's centre line at row y and time t.\nfunction centre(S, y) {\n  const u = cl(y / H, 0, 1), z = depth(S, y), s = S.sway;\n  const room = 6 + 4.6 * z;\n  const wag = 0.32 * s * sin(S.t * ((2 * PI) / 9) * (1 + 0.5 * (s - 1)) - 2.4 * u) * (0.4 + u);\n  return W / 2 + room * (0.62 + 0.19 * (s - 1)) * sin(2 * PI * (0.55 * u + 0.8 * u * u) + 0.7 + wag);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.sway = cl(kv[2], 1, 3);\n  S.taper = cl(kv[3], 0, 1);\n  S.t += d;\n  S.q += (d * S.speed) / 4;\n  // Line tops down the tail, each a pitch of its own size below the last.\n  const Y = S.Y;\n  Y[0] = 2;\n  let n = 0;\n  while (Y[n] \u003c H + 2 && n \u003c Y.length - 1) {\n    Y[n + 1] = Y[n] + SIZES[sizeAt(S, Y[n])].pitch;\n    n++;\n  }\n  S.slots = n;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.slots) return;\n  const { buf, ink, Y, c, lines, drawn } = S, L = lines.length;\n  buf.fill(0);\n  ink.fill(0);\n  const Q = floor(S.q), f = S.q - Q;\n  for (let i = -1; i \u003c S.slots; i++) {\n    const y0 = i \u003c 0 ? Y[0] - SIZES[0].pitch : Y[i], y1 = Y[i + 1];\n    const y = round(y0 + f * (y1 - y0));\n    if (y >= H) break;\n    const size = sizeAt(S, max(0, y)), z = depth(S, y), img = drawn[(((i - Q) % L) + L) % L][size];\n    const x = cl(round(centre(S, y + img.h / 2) - img.w / 2), 0, W - img.w);\n    const u = cl(y / H, 0, 1);\n    // The ink deepens down the tail, and the last dots fade at the tip.\n    hsv(S.hue + 0.47 - 0.3 * u, 0.65 + 0.25 * u, cl((6.1 - z) / 0.9, 0.2, 1), c);\n    for (let r = 0; r \u003c img.h; r++) {\n      const yy = y + r;\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let k = 0; k \u003c img.w; k++) {\n        if (!img.bits[r * img.w + k]) continue;\n        const o = (yy * W + x + k) * 3;\n        buf[o] = c[0];\n        buf[o + 1] = c[1];\n        buf[o + 2] = c[2];\n        if (size \u003c 3) ink[yy * W + x + k] = 1;\n      }\n    }\n  }\n  // The faces cast a faint shadow one LED down and to the right, as type\n  // pressed into paper does. Word shapes and dots cast none.\n  for (let y = H - 1; y > 0; y--)\n    for (let x = W - 1; x >= 0; x--) {\n      const p = y * W + x, o = p * 3;\n      if (ink[p] || buf[o] + buf[o + 1] + buf[o + 2] > 0) continue;\n      const from = ink[p - W] ? p - W : x > 0 && ink[p - W - 1] ? p - W - 1 : -1;\n      if (from \u003c 0) continue;\n      const q = from * 3;\n      buf[o] = buf[q] * SHADOW;\n      buf[o + 1] = buf[q + 1] * SHADOW;\n      buf[o + 2] = buf[q + 2] * SHADOW;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, buf[o], buf[o + 1], buf[o + 2]);\n    }\n}\n","sedimenting-cloud":"// ===== Patternflow pattern =====\n// Title:   Sedimenting Cloud\n// Family:  particle\n// Idea:    A ball of heavy particles sinks through syrup as one body, each particle moved by its own weight and the Stokeslet flow of all the others, so the cloud falls seven times faster than one particle alone, turns over inside like a drop, sheds a thin tail upward, opens a hole on its axis and comes apart, drawn as an elevation over a plan with the camera riding along.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Stokes' law (George Gabriel Stokes, 1851), the viscous drop (Jacques Hadamard and Witold Rybczynski, 1911), regularized Stokeslets (Ricardo Cortez, 2001), falling clouds of particles (Johannes Nitsche and George Batchelor, 1997; Bloen Metzger, Maxime Nicolas and Elisabeth Guazzelli, 2007), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Particles=300..600, View=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 a particle sinking through the cloud faster than the cloud is cyan and one rising through it is violet, so the elevation shows the column going down the middle and the shell coming up the outside; the tail is pale gold.\n// Knob 2: Speed. At 2 the story runs at 8 T a second, T being the time the cloud's collective speed takes to cover one starting radius, with one Adams-Bashforth step a frame (a step is never longer than 0.3 T). With 300 particles the hole on the axis shows in the plan at about 20 s and the cloud comes apart at about 31 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Particles. 300 to 600, in tens. The particles keep their spacing, so the cloud is drawn 13 LEDs across its radius at 300 and 16.4 at 600. Fewer particles come apart sooner: of 8 clouds of 300, six split between 176 and 310 T and two thinned into the tail instead; four clouds of 450 split between 349 and 435 T; of four clouds of 600, two split at about 455 T. A new cloud starts 40 T after a split, when the tail holds 65% of the particles, or at 300 + 0.4 N T.\n// Knob 4: View. Turns the cloud about the vertical by up to half a turn, in both views at once. The plan, below the folding line, is the cloud seen from above with its far side up, laid out under the elevation as a first-angle drawing has it.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, exp, log, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Units: the cloud's starting radius is 1 and a lone particle settles at 1,\n// z pointing down. N a / R = 5, so a particle's Stokeslet carries\n// F / (8 pi mu) = 3a/4 = 3.75 / N, and the cloud should fall at about\n// 1 + 1.2 N a / R = 7, the speed of a drop as viscous as the fluid around it\n// (Hadamard and Rybczynski). T, the time for that collective speed of 6 to\n// cover one radius, is the clock the story is told in.\nconst NAR = 5, T = 1 / (1.2 * NAR), EPS = 0.05, E2 = EPS * EPS;\n// The drawing: a radius is 13 LEDs for 300 particles, and grows as the cube\n// root of the count, so the particles keep their spacing on the panel. The\n// elevation has the cloud's centre at row YS and squeezes heights above U0\n// radii logarithmically with scale LS; the plan has its centre at row YP.\nconst YS = 38, YP = 97, U0 = 1.5, LS = 0.8, XY = 68;\n\nexport function setup(params) {\n  params.s = { n: 0, buf: new Float32Array(W * H * 3), c: [0, 0, 0], frame: 0 };\n}\n\nfunction newCloud(S, n) {\n  S.n = n;\n  S.k = 0.75 * (NAR / n);\n  for (const key of [\"x\", \"y\", \"z\", \"vx\", \"vy\", \"vz\", \"wx\", \"wy\", \"wz\"]) S[key] = new Float64Array(n);\n  S.tail = new Uint8Array(n);\n  for (let i = 0; i \u003c n; i++) {\n    let x, y, z;\n    do {\n      x = 2 * Math.random() - 1;\n      y = 2 * Math.random() - 1;\n      z = 2 * Math.random() - 1;\n    } while (x * x + y * y + z * z > 1);\n    S.x[i] = x;\n    S.y[i] = y;\n    S.z[i] = z;\n  }\n  S.t = 0;\n  S.hp = 0;\n  S.seen = 0;\n  S.cx = S.cy = S.cz = 0;\n  S.camX = S.camY = S.camZ = 0;\n  S.split = -1;\n  S.fade = 0;\n}\n\n// Velocities: each particle's own settling plus the regularized Stokeslet of\n// every other, G = [I (r^2 + 2 e^2) + r r^T] / (r^2 + e^2)^(3/2) applied to\n// the weight z. G is even in r, so one pair gives both particles the same\n// vector.\nfunction velocity(S, X, Y, Z, VX, VY, VZ) {\n  const n = S.n;\n  VX.fill(0);\n  VY.fill(0);\n  VZ.fill(0);\n  for (let i = 0; i \u003c n; i++) {\n    const xi = X[i], yi = Y[i], zi = Z[i];\n    let ax = 0, ay = 0, az = 0;\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = X[j] - xi, dy = Y[j] - yi, dz = Z[j] - zi;\n      const s = dx * dx + dy * dy + dz * dz + E2, inv = 1 / (s * sqrt(s));\n      const vx = dx * dz * inv, vy = dy * dz * inv, vz = (s + E2 + dz * dz) * inv;\n      ax += vx;\n      ay += vy;\n      az += vz;\n      VX[j] += vx;\n      VY[j] += vy;\n      VZ[j] += vz;\n    }\n    VX[i] += ax;\n    VY[i] += ay;\n    VZ[i] += az;\n  }\n  const k = S.k;\n  for (let i = 0; i \u003c n; i++) {\n    VX[i] *= k;\n    VY[i] *= k;\n    VZ[i] = VZ[i] * k + 1;\n  }\n}\n\n// One step of the two-step Adams-Bashforth rule, one velocity sum a step,\n// with the weight of the last velocity scaled for a step that changed size.\nfunction step(S, h) {\n  const n = S.n, { x, y, z, vx, vy, vz, wx, wy, wz } = S;\n  velocity(S, x, y, z, vx, vy, vz);\n  const c = S.hp > 0 ? h / (2 * S.hp) : 0;\n  for (let i = 0; i \u003c n; i++) {\n    x[i] += h * (vx[i] + c * (vx[i] - wx[i]));\n    y[i] += h * (vy[i] + c * (vy[i] - wy[i]));\n    z[i] += h * (vz[i] + c * (vz[i] - wz[i]));\n    wx[i] = vx[i];\n    wy[i] = vy[i];\n    wz[i] = vz[i];\n  }\n  S.hp = h;\n  S.t += h / T;\n}\n\n// The cloud's centre: the mean of the particles that are not in the tail.\nfunction centre(S) {\n  const n = S.n, { x, y, z, tail } = S;\n  let sx = 0, sy = 0, sz = 0, m = 0;\n  for (let i = 0; i \u003c n; i++) {\n    if (tail[i]) continue;\n    sx += x[i];\n    sy += y[i];\n    sz += z[i];\n    m++;\n  }\n  if (m > 0) {\n    S.cx = sx / m;\n    S.cy = sy / m;\n    S.cz = sz / m;\n  }\n}\n\n// Friends of friends with a link of 0.32 radii. A particle in a group of\n// fewer than ten, more than 1.2 radii above the centre, is in the tail; the\n// groups of 15% or more are returned with their centres.\nfunction groups(S) {\n  const n = S.n, { x, y, z } = S, lab = new Int32Array(n).fill(-1), out = [], sizes = [], stack = [];\n  const L2 = 0.32 * 0.32;\n  for (let i = 0; i \u003c n; i++) {\n    if (lab[i] >= 0) continue;\n    const g = sizes.length;\n    lab[i] = g;\n    stack.push(i);\n    let size = 0, sx = 0, sy = 0;\n    while (stack.length) {\n      const p = stack.pop();\n      size++;\n      sx += x[p];\n      sy += y[p];\n      for (let j = 0; j \u003c n; j++) {\n        if (lab[j] >= 0) continue;\n        const dx = x[j] - x[p], dy = y[j] - y[p], dz = z[j] - z[p];\n        if (dx * dx + dy * dy + dz * dz \u003c L2) {\n          lab[j] = g;\n          stack.push(j);\n        }\n      }\n    }\n    sizes.push(size);\n    if (size >= 0.15 * n) out.push({ size, x: sx / size, y: sy / size });\n  }\n  for (let i = 0; i \u003c n; i++) S.tail[i] = sizes[lab[i]] \u003c 10 && z[i] - S.cz \u003c -1.2 ? 1 : 0;\n  return out.sort((a, b) => b.size - a.size);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 300, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1], 0.2, 3);\n  S.view = cl(kv[3], 0, 1);\n  const n = Math.round(cl(kv[2], 300, 600) / 10) * 10;\n  if (n !== S.n || (input.btnPressed && input.btnPressed[0])) newCloud(S, n);\n  // Speed 2 tells the story at 8 T a second, one step a frame.\n  const h = d * S.speed * 4 * T, parts = Math.ceil(h / (0.3 * T));\n  for (let p = 0; p \u003c parts; p++) step(S, h / parts);\n  S.frame++;\n  if (S.frame % 12 === 0) {\n    const big = groups(S);\n    // Split: the two biggest groups lie more than a radius apart across, three\n    // looks running (the ring's groups flicker before it really parts).\n    const apart = big.length >= 2 && Math.hypot(big[0].x - big[1].x, big[0].y - big[1].y) > 1;\n    S.seen = apart ? S.seen + 1 : 0;\n    if (S.split \u003c 0 && S.seen >= 3) S.split = S.t;\n  }\n  centre(S);\n  // After a split the daughters fall apart for 40 T; then a new cloud. So\n  // too when the tail has taken 65% of the particles, or at 300 + 0.4 N T.\n  let left = 0;\n  for (let i = 0; i \u003c n; i++) left += 1 - S.tail[i];\n  if ((S.split >= 0 && S.t > S.split + 40) || left \u003c 0.35 * n || S.t > 300 + 0.4 * n) S.fade += (d * S.speed) / 2;\n  if (S.fade > 1) newCloud(S, n);\n  const a = 1 - exp(-d * 6);\n  S.camX += (S.cx - S.camX) * a;\n  S.camY += (S.cy - S.camY) * a;\n  S.camZ += (S.cz - S.camZ) * min(1, a * 2);\n}\n\n// The side view's row for a height u above the centre, in radii.\nfunction rowOf(u, RP) {\n  if (u \u003c= U0) return YS - RP * u;\n  return YS - RP * (U0 + LS * log(1 + (u - U0) / LS));\n}\n\nfunction splat(buf, px, py, r, g, b, I) {\n  if (px \u003c -1 || px >= W || py \u003c -1 || py >= H) return;\n  // Bilinear, so a particle moving a fraction of an LED still moves.\n  const x0 = floor(px), y0 = floor(py), fx = px - x0, fy = py - y0;\n  for (let q = 0; q \u003c 4; q++) {\n    const xx = x0 + (q & 1), yy = y0 + (q >> 1);\n    if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n    const wgt = (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy) * I;\n    const o = (yy * W + xx) * 3;\n    buf[o] += r * wgt;\n    buf[o + 1] += g * wgt;\n    buf[o + 2] += b * wgt;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const { buf, c } = S, n = S.n;\n  for (let p = 0; p \u003c buf.length; p++) buf[p] *= 0.86;\n  const ph = S.view * PI, cp = cos(ph), sp = sin(ph), RP = 13 * Math.cbrt(n / 300);\n  const fade = (1 - cl(S.fade, 0, 1)) * cl(S.t / 3, 0, 1);\n  const tailC = [0, 0, 0];\n  hsv(S.hue + 0.14, 0.5, 1, tailC);\n  // The cloud's own sinking speed, to colour each particle by how fast it\n  // sinks or rises through the cloud.\n  let vm = 0, m = 0;\n  for (let i = 0; i \u003c n; i++)\n    if (!S.tail[i]) {\n      vm += S.wz[i];\n      m++;\n    }\n  vm /= max(1, m);\n  for (let i = 0; i \u003c n; i++) {\n    const ax = S.x[i] - S.camX, ay = S.y[i] - S.camY, dz = S.z[i] - S.camZ;\n    // Turned about the vertical by the View knob: across the panel and depth.\n    const sx = ax * cp + ay * sp, w = ay * cp - ax * sp;\n    const px = 32 + sx * RP;\n    if (S.tail[i]) {\n      splat(buf, px, rowOf(-dz, RP), tailC[0], tailC[1], tailC[2], 0.55 * fade);\n      continue;\n    }\n    // Sky blue for a particle sinking through the cloud, violet for one\n    // rising through it.\n    const rise = cl(vm - S.wz[i], -1, 1);\n    hsv(S.hue + 0.6 + 0.16 * rise, 0.5 + 0.3 * abs(rise), 1, c);\n    // Elevation, lit by nearness to the viewer.\n    let near = cl(0.5 - w / 2.4, 0, 1);\n    splat(buf, px, rowOf(-dz, RP), c[0], c[1], c[2], (0.14 + 0.34 * near) * fade);\n    // Plan, seen from above and laid out below the elevation as in a\n    // first-angle drawing: the far side at the top, lit by height.\n    near = cl(0.5 - dz / 2, 0, 1);\n    splat(buf, px, YP - w * RP, c[0], c[1], c[2], (0.14 + 0.34 * near) * fade);\n  }\n  // The folding line between the two views, dotted and dim.\n  for (let x = 1; x \u003c W; x += 3) {\n    const o = (XY * W + x) * 3;\n    buf[o] = max(buf[o], 0.1);\n    buf[o + 1] = max(buf[o + 1], 0.1);\n    buf[o + 2] = max(buf[o + 2], 0.12);\n  }\n  // Light adds up where particles crowd; the brightest channel is eased into\n  // range and the other two keep their ratio to it, so crowds stay coloured.\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3, L = max(buf[o], buf[o + 1], buf[o + 2]);\n    const k = L > 1e-4 ? (255 * (1 - exp(-1.6 * L))) / L : 0;\n    display.setPixel(p & 63, p >> 6, buf[o] * k, buf[o + 1] * k, buf[o + 2] * k);\n  }\n}\n","ammann-beenker":"// ===== Patternflow pattern =====\n// Title:   Ammann-Beenker\n// Family:  geometry\n// Idea:    An eightfold aperiodic tiling of squares and 45 degree rhombi, made from four families of parallel lines, slides in its hidden perpendicular space, and every so often a row of hexagons across the panel flips at once, the square and two rhombi in each sliding round to swap places and flaring white before they settle.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ammann-Beenker tiling (Robert Ammann, 1977; Frans Beenker, 1982), built as the dual of a tetragrid after Nicolaas de Bruijn's pentagrids (1981), with its phason flips, pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Phason=0.2..3, Size=8..16, Glow=0..1\n//\n// Knob 1: Hue. Turns the squares and the rhombi round the colour wheel together; at 0 the squares are deep blue and the rhombi gold.\n// Knob 2: Phason. How fast the grids slide in perpendicular space: at 2 a row of hexagons flips about twice a second, at 0.2 once in six seconds, at 3 three times a second.\n// Knob 3: Size. The tile edge in LEDs, 8 to 16: at 8 a star of eight rhombi is 30 LEDs across, at 16 one star fills the width of the panel.\n// Knob 4: Glow. How much of the light belongs to the flips: at 0 the tiles burn at full strength and a flip glows for a second, at 1 the tiles stand dim and each flipped row stays lit for four seconds, a trace of where the phason has passed.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5;\nconst { floor, ceil, cos, sin, exp, min, max, abs, hypot, SQRT1_2: R } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The four grid directions, 45 degrees apart, which are also the tile edges,\n// and the same four turned three times as far: shifting the grids along\n// those moves the tiling in perpendicular space only. It carries the picture\n// nowhere; it only flips tiles.\nconst E = [[1, 0], [R, R], [0, 1], [-R, R]];\nconst EP = [[1, 0], [-R, R], [0, -1], [R, R]];\n// Each pair of families crosses in tiles: 0-2 and 1-3 make the squares, the\n// other four pairs the 45 degree rhombi in their four turns.\nconst PAIRS = [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]];\nconst OTHER = [[2, 3], [1, 3], [1, 2], [0, 3], [0, 2], [0, 1]];\n// Where the grids start, a generic shift so that no three lines meet, and\n// the way the shift drifts in perpendicular space. Each family runs along a\n// diagonal of the square grid the two others make (e1 lies along e0 + e2),\n// so a line that reaches one crossing of that grid reaches every crossing on\n// the same diagonal in the same instant: the flips come in rows across the\n// panel, a hexagon of one square and two rhombi turning over at each.\nconst G0 = [0.137, 0.291, 0.443, 0.619];\nconst DIR = [cos(1.17), sin(1.17)];\n// The middle of the panel: where the tiling's corners sit on average.\nconst OX = -(G0[0] + G0[1] * R - G0[3] * R) + 0.5, OY = -(G0[1] * R + G0[2] + G0[3] * R) + 0.5 + R;\n// A flip slides its three tiles for SLIDE seconds.\nconst SLIDE = 0.45;\nconst LIGHT = [255, 238, 200];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const c = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[o] = c[0] * 255;\n  out[o + 1] = c[1] * 255;\n  out[o + 2] = c[2] * 255;\n}\n\nexport function setup(params) {\n  params.ab = { t: 0, u: 0, frame: 0, size: 8, tiles: new Map(), list: [], buf: new Float32Array(N * 3), col: new Float32Array(6 * 3) };\n}\n\n// Every crossing of two grid lines near the panel is a tile, named by its\n// two families and two line numbers, a name it keeps while the grids slide.\n// Its corner is the sum of the strip numbers it lies in, one per family\n// (Nicolaas de Bruijn's construction). When the grids have slid so that a\n// line of the third family has passed the crossing, the corner jumps by one\n// edge: the tile has flipped.\nfunction tile(A) {\n  const g = [0, 0, 0, 0], s = A.size;\n  for (let i = 0; i \u003c 4; i++) g[i] = G0[i] + A.u * (DIR[0] * EP[i][0] + DIR[1] * EP[i][1]);\n  // Corners lie near twice their crossing, so the crossings needed lie\n  // within half the panel, counted in edges, plus a margin.\n  const hx = (W / 2 / s + 2.5) / 2, hy = (H / 2 / s + 2.5) / 2;\n  const frame = ++A.frame, T = A.tiles, list = (A.list = []);\n  for (let q = 0; q \u003c 6; q++) {\n    const [j, k] = PAIRS[q], ej = E[j], ek = E[k], det = ej[0] * ek[1] - ej[1] * ek[0];\n    const rj = hx * abs(ej[0]) + hy * abs(ej[1]), rk = hx * abs(ek[0]) + hy * abs(ek[1]);\n    for (let mj = floor(-rj - g[j]); mj \u003c= ceil(rj - g[j]); mj++)\n      for (let mk = floor(-rk - g[k]); mk \u003c= ceil(rk - g[k]); mk++) {\n        const bj = mj + g[j], bk = mk + g[k];\n        const px = (bj * ek[1] - bk * ej[1]) / det, py = (ej[0] * bk - ek[0] * bj) / det;\n        if (abs(px) > hx || abs(py) > hy) continue;\n        let vx = mj * ej[0] + mk * ek[0] - OX, vy = mj * ej[1] + mk * ek[1] - OY;\n        for (const i of OTHER[q]) {\n          const K = ceil(px * E[i][0] + py * E[i][1] - g[i]);\n          vx += K * E[i][0];\n          vy += K * E[i][1];\n        }\n        const id = (q * 4096 + (mj & 4095)) * 4096 + (mk & 4095);\n        let t = T.get(id);\n        if (!t) T.set(id, (t = { q, vx, vy, fx: vx, fy: vy, ft: -99, seen: 0 }));\n        else if (t.seen === frame - 1 && (abs(t.vx - vx) > 1e-6 || abs(t.vy - vy) > 1e-6)) {\n          // Slide from wherever it was drawn last.\n          const [dx, dy] = drawn(t, A.t);\n          t.fx = dx;\n          t.fy = dy;\n          t.ft = A.t;\n        }\n        t.vx = vx;\n        t.vy = vy;\n        t.seen = frame;\n        list.push(t);\n      }\n  }\n  if (frame % 60 === 0) for (const [id, t] of T) if (t.seen \u003c frame - 30) T.delete(id);\n}\n\nfunction drawn(t, now) {\n  const a = cl((now - t.ft) / SLIDE, 0, 1), e = 1 - a * a * (3 - 2 * a);\n  return [t.vx + (t.fx - t.vx) * e, t.vy + (t.fy - t.vy) * e];\n}\n\nexport function update(dt, input, params) {\n  if (!params.ab) setup(params);\n  const A = params.ab, k = input.knobValues || [0, 2, 8, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  A.hue = k[0];\n  A.size = cl(k[2], 8, 16);\n  A.glow = cl(k[3], 0, 1);\n  A.t += dt;\n  A.u += dt * cl(k[1], 0.2, 3) * 0.016;\n  tile(A);\n}\n\n// One tile onto the LEDs: a parallelogram at (ax, ay) on edges u and w in\n// colour (r, g, b). LEDs within half an LED of its edges stay dark, so the\n// tiles sit apart by a dark joint one LED wide.\nfunction para(buf, ax, ay, ux, uy, wx, wy, r, g, b) {\n  const det = ux * wy - uy * wx, hu = abs(det) / hypot(wx, wy), hw = abs(det) / hypot(ux, uy);\n  const x0 = max(0, floor(min(ax, ax + ux, ax + wx, ax + ux + wx))), x1 = min(W - 1, ceil(max(ax, ax + ux, ax + wx, ax + ux + wx)));\n  const y0 = max(0, floor(min(ay, ay + uy, ay + wy, ay + uy + wy))), y1 = min(H - 1, ceil(max(ay, ay + uy, ay + wy, ay + uy + wy)));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x - ax, dy = y - ay;\n      const a = (dx * wy - dy * wx) / det, c = (ux * dy - uy * dx) / det;\n      if (a \u003c 0 || a > 1 || c \u003c 0 || c > 1) continue;\n      const m = cl((min(min(a, 1 - a) * hu, min(c, 1 - c) * hw) - 0.35) * 2, 0, 1), p = (y * W + x) * 3;\n      buf[p] = r * m;\n      buf[p + 1] = g * m;\n      buf[p + 2] = b * m;\n    }\n}\n\nexport function draw(display, params) {\n  const A = params.ab;\n  if (!A || !A.list.length) return;\n  const buf = A.buf, col = A.col, s = A.size, now = A.t;\n  buf.fill(0);\n  // Squares deep blue and rhombi gold at Hue 0, each turn of a tile a little\n  // lighter or darker. Glow dims the tiles at rest and lengthens the light\n  // a flip leaves.\n  const rest = 1 - 0.62 * A.glow, fade = 0.7 + 3.3 * A.glow;\n  for (let q = 0; q \u003c 6; q++) {\n    const c = q === 1 ? [0.6, 0.85, 0.62] : q === 4 ? [0.6, 0.8, 0.9] : [0.11, 0.9, [1, 0, 0.86, 0.93, 0, 0.8][q]];\n    hsv(A.hue + c[0], c[1], c[2], col, q * 3);\n  }\n  // Tiles at rest first, then the sliding ones over the dark hexagon they\n  // leave, so they never hide behind a neighbour.\n  const moving = [];\n  for (const t of A.list) {\n    if (now - t.ft \u003c SLIDE) moving.push(t);\n    else put(buf, col, t, t.vx, t.vy, s, rest, 0.75 * exp(-(now - t.ft - SLIDE) / fade));\n  }\n  for (const t of moving) {\n    const [vx, vy] = drawn(t, now);\n    put(buf, col, t, vx, vy, s, 1, 0.75);\n  }\n  for (let p = 0, y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, buf[p], buf[p + 1], buf[p + 2]);\n}\n\n// A tile in its colour at brightness v, whitened by lift: the light of a flip.\nfunction put(buf, col, t, vx, vy, s, v, lift) {\n  const [j, k] = PAIRS[t.q], c = t.q * 3;\n  const r = col[c] * v, g = col[c + 1] * v, b = col[c + 2] * v;\n  para(buf, CX + vx * s, CY + vy * s, E[j][0] * s, E[j][1] * s, E[k][0] * s, E[k][1] * s, r + (LIGHT[0] - r) * lift, g + (LIGHT[1] - g) * lift, b + (LIGHT[2] - b) * lift);\n}\n","broad-nib":"// ===== Patternflow pattern =====\n// Title:   Broad Nib\n// Family:  type\n// Idea:    A broad-edged pen writes Latin mottoes in capitals down a ruled panel, a word a line, stroke by stroke, and every stroke comes out thick or thin by how its direction meets the angle of the nib, so turning the nib re-inks every letter on the page while the pen is still writing.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: broad-edge pen lettering (Edward Johnston, Writing & Illuminating & Lettering, 1906) and the pen model of METAFONT (Donald Knuth, 1979), pattern round 64, writing mottoes from Pliny the Elder, Suetonius and Seneca\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Angle=30..180, Speed=0.2..3, Weight=-1..1, Slant=0..20\n//\n// Knob 1: Angle. The angle of the nib edge to the line, in degrees: at 30 the pen of Johnston's capitals, thick downstrokes and lighter cross strokes; at 90 the contrast turns over, the stems go to hairlines and the cross strokes are heavy; at 180 the pen lies flat and the cross strokes thin to hairlines.\n// Knob 2: Speed. How fast the pen moves: at 2 a downstroke takes a sixth of a second, a page of four words 9 to 15 seconds and the finished page holds for two and a half; at 0.2 the pen is ten times slower.\n// Knob 3: Weight. The nib's width against the height of the capitals: 5.2 nib widths at 0, 8.5 at -1 for a light hand, 3.9 at 1 for a heavy one that closes the counters.\n// Knob 4: Slant. Leans the letters to the right like an italic hand, up to 20 degrees, the whole page at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, cos, sin, tan, sqrt, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Skeleton capitals in a box ten units high, y down from the cap line to the\n// base line: the advance width, then the strokes in the order and direction a\n// pen writes them. M moves, L draws a line, E cx cy rx ry a0 a1 an arc of an\n// ellipse from angle a0 to a1 in degrees (0 right, 90 down).\nconst GLYPHS = {\n  A: \"7|M3.5 0L0 10|M3.5 0L7 10|M1.3 6.6L5.7 6.6\",\n  B: \"5.7|M0 0L0 10|M0 0L2.8 0E2.8 2.4 2.4 2.4 270 450L0 4.8|M0 4.8L3.1 4.8E3.1 7.4 2.6 2.6 270 450L0 10\",\n  C: \"6.1|E3.7 5 3.7 5 305 55\",\n  D: \"7|M0 0L0 10|M0 0L2.2 0E2.2 5 4.8 5 270 450L0 10\",\n  E: \"5.2|M0 0L0 10|M0 0L5 0|M0 4.9L4.2 4.9|M0 10L5.2 10\",\n  F: \"5|M0 0L0 10|M0 0L5 0|M0 4.9L4.2 4.9\",\n  G: \"7.1|E3.7 5 3.7 5 305 25|M4.3 5.7L7.1 5.7L7.1 9.6\",\n  I: \"0|M0 0L0 10\",\n  L: \"5|M0 0L0 10L5 10\",\n  M: \"8.4|M0.5 0L0 10|M0.5 0L4.2 10|M7.9 0L4.2 10|M7.9 0L8.4 10\",\n  N: \"6.6|M0 0L0 10|M0 0L6.6 10|M6.6 0L6.6 10\",\n  O: \"7.4|E3.7 5 3.7 5 270 90|E3.7 5 3.7 5 270 450\",\n  P: \"5.6|M0 0L0 10|M0 0L2.8 0E2.8 2.7 2.8 2.7 270 450L0 5.4\",\n  R: \"6|M0 0L0 10|M0 0L2.6 0E2.6 2.6 2.6 2.6 270 450L0 5.2|M2.4 5.2L6 10\",\n  S: \"5.3|E2.5 2.5 2.4 2.5 335 90E2.6 7.5 2.7 2.5 270 515\",\n  T: \"6.6|M0 0L6.6 0|M3.3 0L3.3 10\",\n  U: \"6.6|M0 0L0 6.6E3.3 6.6 3.3 3.4 180 0|M6.6 0L6.6 10\",\n  V: \"7|M0 0L3.5 10|M7 0L3.5 10\",\n};\n// Four mottoes about writing and time, a word a line: no day without a line\n// (Pliny the Elder on Apelles, Natural History, 77), spoken words fly and\n// written ones stay (a medieval proverb), make haste slowly (Augustus, after\n// Suetonius, 121) and art is long, life is short (Hippocrates, in Seneca's\n// Latin, 49).\nconst PAGES = [\n  [\"NULLA\", \"DIES\", \"SINE\", \"LINEA\"],\n  [\"VERBA\", \"VOLANT\", \"SCRIPTA\", \"MANENT\"],\n  [\"FESTINA\", \"LENTE\"],\n  [\"ARS\", \"LONGA\", \"VITA\", \"BREVIS\"],\n];\n// Ink and the red of the first letter, the rubric, for each page in turn.\nconst INKS = [\n  [[255, 228, 178], [255, 70, 38]],\n  [[120, 168, 255], [255, 196, 70]],\n  [[255, 204, 96], [255, 70, 38]],\n  [[90, 226, 176], [255, 120, 60]],\n];\n// The tallest capitals, and their height in nib widths at Weight 0.\nconst HMAX = 26, NIBS = 5.2;\n\n// Each glyph's strokes as polylines in its unit box.\nfunction parse(src) {\n  const [w, ...strokes] = src.split(\"|\");\n  return {\n    w: +w,\n    strokes: strokes.map((s) => {\n      const tk = s.match(/[MLE]|-?[\\d.]+/g), pts = [];\n      for (let i = 0; i \u003c tk.length; ) {\n        const c = tk[i++];\n        if (c === \"M\" || c === \"L\") pts.push([+tk[i++], +tk[i++]]);\n        else {\n          const [cx, cy, rx, ry, a0, a1] = tk.slice(i, i + 6).map(Number);\n          i += 6;\n          const n = ceil(abs(a1 - a0) / 6);\n          for (let j = 0; j \u003c= n; j++) {\n            const a = ((a0 + ((a1 - a0) * j) / n) * PI) / 180;\n            pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n          }\n        }\n      }\n      return pts;\n    }),\n  };\n}\nconst FONT = {};\nfor (const c in GLYPHS) FONT[c] = parse(GLYPHS[c]);\n\n// Lays out one page: each word on its own line as large as the width lets\n// it be, condensed by up to a third before it shrinks, the lines spread\n// evenly down the panel. Strokes come out in LEDs, cut into pieces no\n// longer than an LED and a half so the pen can stop anywhere along them.\nfunction layout(words) {\n  const lines = words.map((word) => {\n    const gl = [...word].map((c) => FONT[c]), sw = gl.reduce((s, g) => s + g.w, 0);\n    let ky = HMAX / 10, kx = ky;\n    for (; ky > 0.6; ky -= 0.05) {\n      const nib = (ky * 10) / NIBS, gap = nib + 1.2 * ky;\n      kx = (W - 3 - (gl.length - 1) * gap - nib * 0.9) / sw;\n      if (kx >= 0.7 * ky) break;\n    }\n    return { gl, ky, kx: min(kx, ky), gap: (ky * 10) / NIBS + 1.2 * ky };\n  });\n  let total = lines.reduce((s, l) => s + l.ky * 10, 0), room = H - total;\n  if (room \u003c 6 * (lines.length + 1)) {\n    const f = (H - 6 * (lines.length + 1)) / total;\n    for (const l of lines) (l.ky *= f), (l.kx *= f), (l.gap *= f);\n    total *= f;\n    room = H - total;\n  }\n  const strokes = [];\n  strokes.rules = [];\n  let y = room / (lines.length + 1);\n  lines.forEach((l, li) => {\n    const hgt = l.ky * 10, wid = l.gl.reduce((s, g) => s + g.w * l.kx, 0) + (l.gl.length - 1) * l.gap;\n    let x = (W - 1 - wid) / 2;\n    l.gl.forEach((g, gi) => {\n      for (const pts of g.strokes) {\n        const out = [];\n        for (let i = 0; i \u003c pts.length; i++) {\n          const px = x + pts[i][0] * l.kx, py = y + pts[i][1] * l.ky;\n          if (i) {\n            const [qx, qy] = out[out.length - 1], n = ceil(sqrt((px - qx) ** 2 + (py - qy) ** 2) / 1.5);\n            for (let j = 1; j \u003c= n; j++) out.push([qx + ((px - qx) * j) / n, qy + ((py - qy) * j) / n]);\n          } else out.push([px, py]);\n        }\n        const xy = new Float32Array(out.flat()), cum = new Float32Array(out.length);\n        for (let i = 1; i \u003c out.length; i++) cum[i] = cum[i - 1] + sqrt((xy[2 * i] - xy[2 * i - 2]) ** 2 + (xy[2 * i + 1] - xy[2 * i - 1]) ** 2);\n        strokes.push({ xy, cum, len: cum[out.length - 1], hgt, mid: y + hgt / 2, rubric: li === 0 && gi === 0, laid: new Float32Array(out.length).fill(-1) });\n      }\n      x += g.w * l.kx + l.gap;\n    });\n    strokes.rules.push(Math.round(y), Math.round(y + hgt));\n    y += hgt + room / (lines.length + 1);\n  });\n  return strokes;\n}\n\nexport function setup(params) {\n  params.bn = {\n    t: 0, page: -1, strokes: [], si: 0, d: 0, mode: \"lift\", lift: 1, from: [32, -10], to: [32, -10], timer: 0, fadeOut: 1, pen: [32, -10], started: false,\n    angle: PI / 6, speed: 2, weight: 0, slant: 0,\n    cov: new Float32Array(N), covR: new Float32Array(N), wet: new Float32Array(N),\n  };\n}\n\nfunction nextPage(B) {\n  B.page = (B.page + 1) % PAGES.length;\n  B.strokes = layout(PAGES[B.page]);\n  // The page is ruled in faint pencil at the cap line and base line of each\n  // line of writing, as a scribe rules it before the pen comes.\n  B.rule = new Uint8Array(H);\n  for (const r of B.strokes.rules) if (r >= 0 && r \u003c H) B.rule[r] = 1;\n  B.si = 0;\n  B.d = 0;\n  B.fadeOut = 1;\n  startLift(B, B.pen, B.strokes[0]);\n}\n\nfunction startLift(B, from, s) {\n  B.mode = \"lift\";\n  B.from = [from[0], from[1]];\n  B.to = [s.xy[0], s.xy[1]];\n  const dist = sqrt((B.to[0] - from[0]) ** 2 + (B.to[1] - from[1]) ** 2);\n  B.lift = 0;\n  B.liftT = max(0.06, dist / (5 * rate(B, s)));\n}\n\n// The pen's speed on a stroke in LEDs a second, in proportion to the height\n// of its letters, so big and small words take the same time a stroke.\nconst rate = (B, s) => B.speed * 3 * s.hgt;\n\n// The pen, as a little machine: write a stroke, lift and move to the next,\n// and when the page is done hold it, let it fade and turn to the next.\nfunction step(B, dt) {\n  B.t += dt;\n  if (B.mode === \"write\") {\n    const s = B.strokes[B.si];\n    B.d += rate(B, s) * dt;\n    for (let i = 0; i \u003c s.cum.length && s.cum[i] \u003c= B.d; i++) if (s.laid[i] \u003c 0) s.laid[i] = B.t;\n    B.pen = at(s, B.d);\n    if (B.d >= s.len) {\n      B.si++;\n      if (B.si \u003c B.strokes.length) startLift(B, B.pen, B.strokes[B.si]);\n      else (B.mode = \"hold\"), (B.timer = 1.2 + 2.6 / B.speed);\n    }\n  } else if (B.mode === \"lift\") {\n    B.lift = min(1, B.lift + dt / B.liftT);\n    const e = B.lift * B.lift * (3 - 2 * B.lift);\n    B.pen = [B.from[0] + (B.to[0] - B.from[0]) * e, B.from[1] + (B.to[1] - B.from[1]) * e];\n    if (B.lift >= 1) {\n      B.mode = \"write\";\n      B.d = 0;\n      B.strokes[B.si].laid[0] = B.t;\n    }\n  } else if (B.mode === \"hold\") {\n    B.timer -= dt;\n    if (B.timer \u003c= 0) (B.mode = \"fade\"), (B.timer = 0.8);\n  } else {\n    B.timer -= dt;\n    B.fadeOut = max(0, B.timer / 0.8);\n    if (B.timer \u003c= 0) nextPage(B);\n  }\n}\n\n// The point at distance d along a stroke.\nfunction at(s, d) {\n  const n = s.cum.length;\n  if (d >= s.len) return [s.xy[2 * n - 2], s.xy[2 * n - 1]];\n  let i = 0;\n  while (i \u003c n - 2 && s.cum[i + 1] \u003c d) i++;\n  const f = (d - s.cum[i]) / max(1e-6, s.cum[i + 1] - s.cum[i]);\n  return [s.xy[2 * i] + (s.xy[2 * i + 2] - s.xy[2 * i]) * f, s.xy[2 * i + 1] + (s.xy[2 * i + 3] - s.xy[2 * i + 1]) * f];\n}\n\nexport function update(dt, input, params) {\n  if (!params.bn) setup(params);\n  const B = params.bn, k = input.knobValues || [30, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  B.angle = (cl(k[0], 30, 180) * PI) / 180;\n  B.speed = cl(k[1], 0.2, 3);\n  B.weight = cl(k[2], -1, 1);\n  B.slant = (cl(k[3], 0, 20) * PI) / 180;\n  if (!B.started) {\n    // The panel opens on a page already a third written.\n    B.started = true;\n    nextPage(B);\n    for (let i = 0; i \u003c 100; i++) step(B, 1 / 30);\n  }\n  step(B, dt);\n}\n\n// Ink one piece of a stroke: the nib, a segment of half length h along\n// (nx, ny), swept from (ax, ay) to (bx, by), covers a parallelogram, as the\n// pen of METAFONT does. Each LED takes its distance to the nearest edge,\n// softened over one LED, so where the pen runs along its own edge it still\n// leaves a hairline one LED wide. wet is how fresh the ink is.\nfunction sweep(B, buf, ax, ay, bx, by, nx, ny, h, wet) {\n  const sx = bx - ax, sy = by - ay, L = sqrt(sx * sx + sy * sy), mx = (ax + bx) / 2, my = (ay + by) / 2;\n  const ux = L > 1e-4 ? sx / L : 0, uy = L > 1e-4 ? sy / L : 0;\n  const sn = abs(ux * nx + uy * ny), cr = abs(ux * ny - uy * nx);\n  const eA = h * cr, eB = (L * cr) / 2, eC = h + (L * sn) / 2, eD = L / 2 + h * sn;\n  const r = h + 1.5;\n  const x0 = max(0, floor(min(ax, bx) - r)), x1 = min(W - 1, ceil(max(ax, bx) + r));\n  const y0 = max(0, floor(min(ay, by) - r)), y1 = min(H - 1, ceil(max(ay, by) + r));\n  const W2 = B.wet;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const qx = x - mx, qy = y - my;\n      let d = max(abs(qx * ny - qy * nx) - eB, abs(qx * nx + qy * ny) - eC);\n      if (L > 1e-4) d = max(d, abs(qx * uy - qy * ux) - eA, abs(qx * ux + qy * uy) - eD);\n      const c = 0.85 - d;\n      if (c \u003c= 0) continue;\n      const p = y * W + x, v = c > 1 ? 1 : c;\n      if (v > buf[p]) buf[p] = v;\n      const w = v * wet;\n      if (w > W2[p]) W2[p] = w;\n    }\n}\n\nexport function draw(display, params) {\n  const B = params.bn;\n  if (!B || !B.started) return;\n  const { cov, covR, wet } = B;\n  cov.fill(0);\n  covR.fill(0);\n  wet.fill(0);\n  const nx = cos(B.angle), ny = -sin(B.angle), sh = tan(B.slant), wf = NIBS - (B.weight \u003c 0 ? 3.3 : 1.3) * B.weight;\n  const done = B.mode === \"write\" ? B.si + 1 : B.si;\n  for (let k = 0; k \u003c done && k \u003c B.strokes.length; k++) {\n    const s = B.strokes[k], lim = k === B.si && B.mode === \"write\" ? B.d : 1e9, h = s.hgt / wf / 2, buf = s.rubric ? covR : cov;\n    const X = (i) => s.xy[2 * i] + (s.mid - s.xy[2 * i + 1]) * sh;\n    for (let i = 0; i + 1 \u003c s.cum.length && s.cum[i] \u003c lim; i++) {\n      let bx = X(i + 1), by = s.xy[2 * i + 3];\n      if (s.cum[i + 1] > lim) {\n        const f = (lim - s.cum[i]) / (s.cum[i + 1] - s.cum[i]);\n        by = s.xy[2 * i + 1] + (by - s.xy[2 * i + 1]) * f;\n        bx = X(i) + (bx - X(i)) * f;\n      }\n      const age = s.laid[i] \u003c 0 ? 9 : B.t - s.laid[i];\n      sweep(B, buf, X(i), s.xy[2 * i + 1], bx, by, nx, ny, h, exp(-age / 0.5));\n    }\n  }\n  const [ink, rub] = INKS[B.page], f = B.fadeOut;\n  const rule = B.rule;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const a = cov[p], b = covR[p], c = max(a, b);\n      if (c \u003c= 0) {\n        const r = rule[y] * f;\n        display.setPixel(x, y, 30 * r, 34 * r, 54 * r);\n        continue;\n      }\n      const wa = a / (a + b), w = wet[p] * 0.6;\n      let r = (ink[0] * wa + rub[0] * (1 - wa)) * c, g = (ink[1] * wa + rub[1] * (1 - wa)) * c, bl = (ink[2] * wa + rub[2] * (1 - wa)) * c;\n      r += (255 * c - r) * w;\n      g += (255 * c - g) * w;\n      bl += (255 * c - bl) * w;\n      display.setPixel(x, y, r * f, g * f, bl * f);\n    }\n  // The nib itself, a short bar of light at the pen's point, dark round its\n  // edge so it reads on the ink; dimmer while the pen is lifted.\n  if (B.mode === \"write\" || B.mode === \"lift\") {\n    const s = B.strokes[min(B.si, B.strokes.length - 1)], h = s.hgt / wf / 2;\n    const px = B.pen[0] + (s.mid - B.pen[1]) * sh, py = B.pen[1], v = B.mode === \"write\" ? 1 : 0.55;\n    for (let y = max(0, floor(py - h - 2)); y \u003c= min(H - 1, ceil(py + h + 2)); y++)\n      for (let x = max(0, floor(px - h - 2)); x \u003c= min(W - 1, ceil(px + h + 2)); x++) {\n        const qx = x - px, qy = y - py, d = max(abs(qx * ny - qy * nx), abs(qx * nx + qy * ny) - h);\n        if (d \u003c 0.6) display.setPixel(x, y, 255 * v, 255 * v, 255 * v);\n        else if (d \u003c 1.5) display.setPixel(x, y, 0, 0, 0);\n      }\n  }\n}\n","counterforms":"// ===== Patternflow pattern =====\n// Title:   Counterforms\n// Family:  type\n// Idea:    Four tall bold letters stand dark on the dark panel and only their counters, the holes inside A, B, D, O, P, R and the digits, light up like windows lit from inside, so the word is read through its holes and the glow they spill on the strokes, and between words the windows drain and the next word's fill one by one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after the counter as the white shape that makes a letter (Gerrit Noordzij, De streek, 1985) and windows lit in a facade at night\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Words=0..2, Body=0..1\n//\n// Knob 1: Hue. The lamplight in the windows: warm gold at 0, then green, sky blue, violet and rose round the wheel, each window a little off the next.\n// Knob 2: Speed. How fast the windows fill and drain and the words change: at 2 a word every 8 seconds, at 0.2 one in 80.\n// Knob 3: Words. Which words: 0 four-letter words made only of letters with counters (DOOR, ROAD, DROP, BOAR, BARD, ROAR), 1 four-digit numbers made only of 0, 4, 6, 8 and 9 (4096, 8086, 6809, 9600, 8008), 2 two Hangul syllables built from the closed jamo ㅁ, ㅂ and ㅇ (봄밤, 엄마, 아빠, 마음).\n// Knob 4: Body. How much of the letter body shows besides the light the windows throw on it: none at 0, a faint stone just above what the panel shows at the opening 0.06, moonlit at 0.5, the whole letter standing out at 1.\n\nconst W = 64, H = 128, N = W * H;\nconst Q = 3; // supersampling of the glyph mask\nconst HW = W * Q, HH = H * Q;\nconst { floor, round, min, max, sin, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Every word in a set has only glyphs with counters, so every glyph shows.\nconst SETS = [\n  [\"DOOR\", \"ROAD\", \"DROP\", \"BOAR\", \"BARD\", \"ROAR\"],\n  [\"4096\", \"8086\", \"6809\", \"9600\", \"8008\"],\n  [\"봄밤\", \"엄마\", \"아빠\", \"마음\"],\n];\n\n// The face. A glyph is a list of shapes drawn in order into its cell, each\n// one adding ink (1) or cutting it away (0): rounded rectangles with a radius\n// per corner [x0, y0, x1, y1, tl, tr, br, bl] and thick lines. The cell is\n// w by h LEDs and the stroke s LEDs thick.\nfunction glyph(ch, w, h, s) {\n  const P = [];\n  const rr = (x0, y0, x1, y1, tl, tr, br, bl, add = 1) => P.push([0, add, x0, y0, x1, y1, tl, tr, br, bl]);\n  const box = (x0, y0, x1, y1, add = 1) => rr(x0, y0, x1, y1, 0, 0, 0, 0, add);\n  const ln = (x0, y0, x1, y1, wd, add = 1) => P.push([1, add, x0, y0, x1, y1, wd]);\n  const inr = (r) => (r > 0 ? max(1.5, r - s) : 0);\n  const ring = (x0, y0, x1, y1, tl, tr, br, bl) => {\n    rr(x0, y0, x1, y1, tl, tr, br, bl);\n    rr(x0 + s, y0 + s, x1 - s, y1 - s, inr(tl), inr(tr), inr(br), inr(bl), 0);\n  };\n  const R = 10, D = 13;\n  let flip = false;\n  switch (ch) {\n    case \"O\": ring(0, 0, w, h, D, D, D, D); break;\n    case \"0\": ring(0, 0, w, h, D, D, D, D); box(w / 2 - 1.5, h * 0.3, w / 2 + 1.5, h * 0.7); break;\n    case \"D\": ring(0, 0, w, h, 0, D, D, 0); break;\n    case \"A\": {\n      const y = round(h * 0.5);\n      rr(0, 0, w, h, R + 3, R + 3, 0, 0);\n      rr(s, s, w - s, h + 2, inr(R + 3), inr(R + 3), 0, 0, 0);\n      box(0, y, w, y + s);\n      break;\n    }\n    case \"B\": {\n      const m = round(s + (h - 3 * s) * 0.47);\n      ring(0, 0, w - 2, m + s, 0, R, R, 0);\n      ring(0, m, w, h, 0, R, R, 0);\n      break;\n    }\n    case \"P\":\n    case \"R\": {\n      const m = round(h * 0.56);\n      ring(0, 0, w, m, 0, R, R, 0);\n      box(0, 0, s, h);\n      if (ch === \"R\") ln(w * 0.4, m - s / 2, w - s / 2, h + 2, s * 1.1);\n      break;\n    }\n    case \"8\": {\n      const m = round(s + (h - 3 * s) * 0.46);\n      ring(1, 0, w - 1, m + s, D - 1, D - 1, D - 1, D - 1);\n      ring(0, m, w, h, D, D, D, D);\n      break;\n    }\n    case \"9\": flip = true; // a 6 turned half round\n    // falls through\n    case \"6\": {\n      const m = round(h * 0.42);\n      rr(0, 0, w, h, D, D, D, D);\n      rr(s, m + s, w - s, h - s, inr(D), inr(D), inr(D), inr(D), 0);\n      box(s, s, w + 2, m, 0);\n      box(w * 0.62, -1, w + 2, s + 1, 0);\n      break;\n    }\n    case \"4\": {\n      const x = w - s - 2, y = round(h * 0.64);\n      box(x, 0, x + s, h);\n      box(0, y, w, y + s);\n      ln(x + s * 0.5, s * 0.5, s * 0.55, y + s * 0.5, s * 1.15);\n      break;\n    }\n    // Hangul syllables, built from bars: initial, vowel and final in their\n    // usual places in a square cell.\n    default:\n      hangul(ch, w, h, s, box, rr);\n  }\n  return { P, flip };\n}\n\nfunction hangul(ch, w, h, s, box, rr) {\n  // ㅂ in a box; ㅃ as two of them; ㅁ a closed square; ㅇ a closed oval.\n  const b = (x0, y0, x1, y1) => {\n    const m = round(y0 + (y1 - y0) * 0.22);\n    box(x0, y0, x0 + s, y1);\n    box(x1 - s, y0, x1, y1);\n    box(x0, m, x1, m + s);\n    box(x0, y1 - s, x1, y1);\n  };\n  const m = (x0, y0, x1, y1) => {\n    rr(x0, y0, x1, y1, 2, 2, 2, 2);\n    box(x0 + s, y0 + s, x1 - s, y1 - s, 0);\n  };\n  const o = (x0, y0, x1, y1) => {\n    // A circle when the box is wide, an upright oval when it is tall.\n    if (x1 - x0 > y1 - y0) {\n      const c = (x0 + x1) / 2, d = y1 - y0;\n      (x0 = c - d / 2), (x1 = c + d / 2);\n    }\n    const r = min(x1 - x0, y1 - y0) / 2;\n    rr(x0, y0, x1, y1, r, r, r, r);\n    const q = max(1.5, r - s);\n    rr(x0 + s, y0 + s, x1 - s, y1 - s, q, q, q, q, 0);\n  };\n  const i0 = { 봄: b, 밤: b, 엄: o, 마: m, 아: o, 빠: b, 음: o }[ch];\n  const vertical = \"밤엄마아빠\".includes(ch);\n  const final = \"봄밤엄음\".includes(ch);\n  if (vertical) {\n    // Initial on the left, the vowel's long stem on the right, final below.\n    const yb = final ? round(h * 0.47) : h - 6;\n    const yt = final ? 0 : 6;\n    const sx = w - (ch === \"빠\" ? 13 : 16);\n    if (ch === \"빠\") {\n      const half = round((sx - 4) / 2);\n      b(0, yt, half, yb);\n      b(half + 2, yt, sx - 3, yb);\n    } else if (ch === \"엄\") i0(4, yt, sx - 13, yb);\n    else i0(0, yt, sx - 6, yb);\n    box(sx, 0, sx + s, final ? yb + 1 : h);\n    const my = round((final ? yb : h) * 0.5 - s / 2);\n    if (ch === \"엄\") box(sx - 11, my, sx, my + s);\n    else box(sx + s, my, w, my + s);\n    if (final) m(4, yb + 6, w - 4, h);\n  } else {\n    // Initial on top, the vowel's long bar across the middle, final below.\n    const yb = round(h * 0.38);\n    i0(round(w * 0.17), 0, round(w * 0.83), yb);\n    const by = yb + 8;\n    if (ch === \"봄\") box(round(w / 2 - s / 2), yb + 2, round(w / 2 + s / 2), by);\n    box(0, by, w, by + s);\n    m(6, by + s + 5, w - 6, h);\n  }\n}\n\nfunction inside(p, x, y) {\n  if (p[0] === 0) {\n    if (x \u003c p[2] || x > p[4] || y \u003c p[3] || y > p[5]) return false;\n    const cx = (p[2] + p[4]) / 2, cy = (p[3] + p[5]) / 2;\n    const left = x \u003c cx, top = y \u003c cy;\n    const r = left ? (top ? p[6] : p[9]) : top ? p[7] : p[8];\n    if (r \u003c= 0) return true;\n    const dx = left ? p[2] + r - x : x - (p[4] - r);\n    const dy = top ? p[3] + r - y : y - (p[5] - r);\n    if (dx \u003c= 0 || dy \u003c= 0) return true;\n    return dx * dx + dy * dy \u003c= r * r;\n  }\n  const ex = p[4] - p[2], ey = p[5] - p[3];\n  const t = cl(((x - p[2]) * ex + (y - p[3]) * ey) / (ex * ex + ey * ey), 0, 1);\n  const dx = x - p[2] - t * ex, dy = y - p[3] - t * ey;\n  return dx * dx + dy * dy \u003c= (p[6] * p[6]) / 4;\n}\n\n// Cells for a word: four glyphs two by two, or two Hangul syllables one\n// above the other.\nfunction cells(n) {\n  if (n === 4) return [[2, 4, 28, 58], [34, 4, 28, 58], [2, 66, 28, 58], [34, 66, 28, 58]];\n  return [[2, 2, 60, 61], [2, 65, 60, 61]];\n}\n\n// Ink the word into a mask at Q times the panel's resolution, flood the\n// paper from the panel's edge, and whatever paper the flood cannot reach is a\n// counter. Each counter is labelled, and the mask is brought back to LEDs as\n// coverage.\nfunction build(S, word) {\n  const ink = S.hi;\n  ink.fill(0);\n  const chars = [...word];\n  const cs = cells(chars.length);\n  chars.forEach((ch, gi) => {\n    const [cx, cy, w, h] = cs[gi];\n    const s = chars.length === 4 ? 6 : 5;\n    const { P, flip } = glyph(ch, w, h, s);\n    // Each shape inks or cuts only the samples inside its own box, in order.\n    for (const p of P) {\n      let x0, y0, x1, y1;\n      if (p[0] === 0) (x0 = p[2]), (y0 = p[3]), (x1 = p[4]), (y1 = p[5]);\n      else {\n        const r = p[6] / 2;\n        (x0 = min(p[2], p[4]) - r), (x1 = max(p[2], p[4]) + r), (y0 = min(p[3], p[5]) - r), (y1 = max(p[3], p[5]) + r);\n      }\n      if (flip) [x0, x1, y0, y1] = [w - x1, w - x0, h - y1, h - y0];\n      const sx0 = max(cx * Q, floor((cx + x0) * Q)), sx1 = min((cx + w) * Q, Math.ceil((cx + x1) * Q));\n      const sy0 = max(cy * Q, floor((cy + y0) * Q)), sy1 = min((cy + h) * Q, Math.ceil((cy + y1) * Q));\n      for (let sy = sy0; sy \u003c sy1; sy++)\n        for (let sx = sx0; sx \u003c sx1; sx++) {\n          let x = (sx + 0.5) / Q - cx, y = (sy + 0.5) / Q - cy;\n          if (flip) (x = w - x), (y = h - y);\n          if (inside(p, x, y)) ink[sy * HW + sx] = p[1];\n        }\n    }\n  });\n  // Flood the outside (label 2) from every paper sample on the edge.\n  const lab = S.lab;\n  for (let i = 0; i \u003c HW * HH; i++) lab[i] = ink[i] ? 1 : 0;\n  const st = S.stack;\n  const flood = (seed, l) => {\n    let n = 0, sp = 0, x0 = 1e9, x1 = -1, y0 = 1e9, y1 = -1, gx = 0;\n    st[sp++] = seed;\n    lab[seed] = l;\n    while (sp) {\n      const i = st[--sp];\n      const x = i % HW, y = (i / HW) | 0;\n      n++;\n      gx += x;\n      if (x \u003c x0) x0 = x;\n      if (x > x1) x1 = x;\n      if (y \u003c y0) y0 = y;\n      if (y > y1) y1 = y;\n      if (x > 0 && !lab[i - 1]) (lab[i - 1] = l), (st[sp++] = i - 1);\n      if (x \u003c HW - 1 && !lab[i + 1]) (lab[i + 1] = l), (st[sp++] = i + 1);\n      if (y > 0 && !lab[i - HW]) (lab[i - HW] = l), (st[sp++] = i - HW);\n      if (y \u003c HH - 1 && !lab[i + HW]) (lab[i + HW] = l), (st[sp++] = i + HW);\n    }\n    return { n, x0: x0 / Q, x1: (x1 + 1) / Q, y0: y0 / Q, y1: (y1 + 1) / Q, gx: gx / n / Q };\n  };\n  for (let x = 0; x \u003c HW; x++) for (const y of [0, HH - 1]) if (!lab[y * HW + x]) flood(y * HW + x, 2);\n  for (let y = 0; y \u003c HH; y++) for (const x of [0, HW - 1]) if (!lab[y * HW + x]) flood(y * HW + x, 2);\n  // Every sample still unlabelled is inside a counter.\n  const counters = [];\n  let next = 3;\n  for (let i = 0; i \u003c HW * HH; i++)\n    if (!lab[i]) {\n      const c = flood(i, next++);\n      if (c.n \u003c Q * Q * 3) continue; // a speck, not a window\n      // Reading order: by glyph cell, then top to bottom.\n      const cyc = (c.y0 + c.y1) / 2;\n      c.cell = cs.findIndex(([x, y, w, h]) => c.gx >= x && c.gx \u003c x + w && cyc >= y && cyc \u003c y + h);\n      c.label = next - 1;\n      counters.push(c);\n    }\n  counters.sort((a, b) => a.cell - b.cell || a.y0 - b.y0 || a.x0 - b.x0);\n  const byLabel = new Int16Array(next).fill(-1);\n  counters.forEach((c, k) => (byLabel[c.label] = k));\n  // Back to LEDs.\n  S.body.fill(0);\n  S.cov.fill(0);\n  S.cid.fill(-1);\n  const tally = new Int32Array(counters.length);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let b = 0, best = -1, bn = 0;\n      tally.fill(0);\n      for (let j = 0; j \u003c Q; j++)\n        for (let i = 0; i \u003c Q; i++) {\n          const l = lab[(y * Q + j) * HW + x * Q + i];\n          if (l === 1) b++;\n          else if (l >= 3) {\n            const k = byLabel[l];\n            if (k \u003c 0) continue;\n            if (++tally[k] > bn) (bn = tally[k]), (best = k);\n          }\n        }\n      const p = y * W + x;\n      S.body[p] = b / (Q * Q);\n      if (best >= 0) {\n        S.cid[p] = best;\n        S.cov[p] = bn / (Q * Q);\n        const c = counters[best];\n        S.hf[p] = cl((y + 0.5 - c.y0) / (c.y1 - c.y0), 0, 1);\n      }\n    }\n  S.counters = counters.map((c, k) => ({ y0: c.y0, y1: c.y1, area: c.n / (Q * Q), tint: TINTS[k % TINTS.length], beat: k * 1.7 }));\n}\n\n// Each window a little off the next, the way lamps in a row of rooms differ.\nconst TINTS = [0, 0.02, -0.025, 0.035, -0.012, 0.012, -0.035, 0.006];\n\nexport function setup(params) {\n  params.s = {\n    hi: new Uint8Array(HW * HH), lab: new Int32Array(HW * HH), stack: new Int32Array(HW * HH),\n    body: new Float32Array(N), cov: new Float32Array(N), cid: new Int16Array(N),\n    L: new Float32Array(N * 3), T: new Float32Array(N * 3), B: new Float32Array(N * 3), hf: new Float32Array(N), lut: new Float32Array(64 * 16 * 3),\n    counters: [], set: -1, word: 0, t: 0, time: 0, hue: 0, bodyK: 0.06,\n  };\n}\n\n// The word's life in seconds at Speed 2: the windows fill one after another,\n// hold, drain from the last window back, and the dark letters wait a moment\n// for the next word.\nconst STAGGER = 0.42, FILL = 1.0, HOLD = 3.4, DRAIN = 1.1, DARK = 0.55;\nfunction life(S) {\n  return S.counters.length * STAGGER + FILL + HOLD + DRAIN + DARK;\n}\n\n// How full window k is, 0..1, at word time t.\nfunction level(S, k, t) {\n  const n = S.counters.length;\n  const a = k * STAGGER;\n  const full = n * STAGGER + FILL;\n  if (t \u003c full + HOLD) {\n    const u = cl((t - a) / FILL, 0, 1);\n    return u * u * (3 - 2 * u);\n  }\n  const d = t - full - HOLD - (n - 1 - k) * 0.08;\n  const u = 1 - cl(d / DRAIN, 0, 1);\n  return u * u * (3 - 2 * u);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.hue = k[0];\n  const sp = cl(k[1], 0.05, 3) / 2;\n  const set = cl(round(k[2]), 0, SETS.length - 1);\n  S.bodyK = cl(k[3], 0, 1);\n  if (set !== S.set) {\n    // A new set opens with its first word already lit.\n    S.set = set;\n    S.word = 0;\n    build(S, SETS[set][0]);\n    S.t = S.counters.length * STAGGER + FILL + 0.4;\n  }\n  S.time += dt;\n  S.t += dt * sp;\n  if (S.t >= life(S)) {\n    S.t -= life(S);\n    S.word = (S.word + 1) % SETS[S.set].length;\n    build(S, SETS[S.set][S.word]);\n  }\n}\n\n// How the stone answers the light thrown on it, by the light's level.\nconst SPILL = 0.8;\nconst TONE = new Float32Array(1024);\n\n// Box blur of radius r along rows or columns, A into B, the three colour\n// channels together.\nfunction blur(A, B, r, horizontal) {\n  const len = horizontal ? W : H, lines = horizontal ? H : W;\n  const step = horizontal ? 3 : W * 3;\n  const norm = 1 / (2 * r + 1);\n  for (let l = 0; l \u003c lines; l++) {\n    const base = horizontal ? l * W * 3 : l * 3;\n    let ar = A[base] * r, ag = A[base + 1] * r, ab = A[base + 2] * r;\n    for (let i = 0; i \u003c= r; i++) {\n      const q = base + i * step;\n      ar += A[q];\n      ag += A[q + 1];\n      ab += A[q + 2];\n    }\n    const last = base + (len - 1) * step;\n    for (let i = 0, q = base; i \u003c len; i++, q += step) {\n      B[q] = ar * norm;\n      B[q + 1] = ag * norm;\n      B[q + 2] = ab * norm;\n      const ai = i + r + 1 \u003c len ? q + (r + 1) * step : last;\n      const ao = i - r > 0 ? q - r * step : base;\n      ar += A[ai] - A[ao];\n      ag += A[ai + 1] - A[ao + 1];\n      ab += A[ai + 2] - A[ao + 2];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (S.set \u003c 0) return;\n  const { L, T, B, body, cov, cid, hf, counters, lut } = S;\n  // Each window's lamp: its tint, a slow breath, how full it is, and its\n  // colour from the paler top of the pane to the deeper bottom.\n  const lamp = counters.map((c, k) => {\n    const lv = level(S, k, S.t);\n    const h = 0.115 + S.hue + c.tint;\n    for (let j = 0; j \u003c 16; j++) {\n      const u = j / 15;\n      const [r, g, b] = hsv(h - 0.02 * u, 0.4 + 0.42 * u, 1);\n      lut[(k * 16 + j) * 3] = r;\n      lut[(k * 16 + j) * 3 + 1] = g;\n      lut[(k * 16 + j) * 3 + 2] = b;\n    }\n    return { lv, top: c.y1 - lv * (c.y1 - c.y0), glow: 0.86 + 0.14 * sin(S.time * 1.15 + c.beat) };\n  });\n  L.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    const k = cid[p];\n    if (k \u003c 0) continue;\n    const m = lamp[k];\n    if (m.lv \u003c= 0) continue;\n    const y = (p / W) | 0;\n    // The light stands in the window like a liquid: lit below its surface,\n    // with a brighter rim while it is still moving.\n    const f = cl(y + 1 - m.top, 0, 1);\n    if (f \u003c= 0) continue;\n    const u = hf[p];\n    const rim = m.lv \u003c 0.999 ? 0.5 * exp(-((y + 0.5 - m.top) ** 2) / 2) : 0;\n    const v = 236 * cov[p] * f * min(1.3, m.glow * (0.8 + 0.2 * (1 - u)) + rim);\n    const q = (k * 16 + round(u * 15)) * 3;\n    L[p * 3] = lut[q] * v;\n    L[p * 3 + 1] = lut[q + 1] * v;\n    L[p * 3 + 2] = lut[q + 2] * v;\n  }\n  // The light thrown out of the windows onto the strokes round them, strong\n  // on the inner edge and fading across the stroke; the night air outside\n  // the letters takes almost none of it.\n  blur(L, T, 4, true);\n  blur(T, B, 4, false);\n  blur(B, T, 3, true);\n  blur(T, B, 3, false);\n  // A square root, so the knob's opening 0.06 already lifts the stone to\n  // about 37/255, the faintest the panel shows.\n  const moon = Math.sqrt(S.bodyK);\n  if (!TONE[1]) for (let i = 1; i \u003c 1024; i++) TONE[i] = (SPILL * 255 * (i / 1020) ** 0.42) / (i / 4);\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const bd = body[p];\n      const o = p * 3;\n      const s = max(B[o], B[o + 1], B[o + 2]);\n      // The stone answers the light with a softer curve than linear, so the\n      // far side of a stroke still shows.\n      const lift = s > 0.5 ? bd * TONE[min(1023, (s * 4) | 0)] + 0.1 * (1 - bd) : 0;\n      display.setPixel(\n        x, y,\n        cl(L[o] + B[o] * lift + bd * moon * 120, 0, 255),\n        cl(L[o + 1] + B[o + 1] * lift + bd * moon * 128, 0, 255),\n        cl(L[o + 2] + B[o + 2] * lift + bd * moon * 150, 0, 255),\n      );\n    }\n}\n","hill-regions":"// ===== Patternflow pattern =====\n// Title:   Hill's Regions\n// Family:  particle\n// Idea:    Seven test particles in the rotating frame of two masses, stood upright so the masses sit one above the other, are fenced in by the zero-velocity curve of their Jacobi constant, and lowering the constant opens the necks at the Lagrange points L1, L2 and L3 one by one, so the particles leak from one mass to the other and out past the small one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: collinear and triangular Lagrange points (Leonhard Euler, 1767; Joseph-Louis Lagrange, 1772), Jacobi integral of the circular restricted three-body problem (Carl Jacobi, 1836), zero-velocity curves and Hill's regions (George William Hill, 1878), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Jacobi=0..4, Mass=0.1..0.5, Trail=2..10\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the forbidden region is dark violet with the curves of lower C drawn in it as a contour map, its edge pale cyan, the trails run from amber through lime to teal, the large mass is pale gold and the small one sky blue. The dark wall skips orange and yellow, which read brown on the panel.\n// Knob 2: Jacobi. The Jacobi constant C = 2 Omega - v^2 as a ladder whose whole numbers count the open necks: at 0 C is above C1 and each mass keeps its own particles, the neck at L1 between the masses opens at 0.5, the one at L2 beyond the small mass at 1.5, the one at L3 beyond the large mass at 2.5, and at 4 C = 3 - mu + mu^2 and the last walls round L4 and L5 shrink to points. At mu = 0.1 that is C = 3.715 at 0, C1 = 3.597 at 0.5, C2 = 3.467 at 1.5, 3.283 at the opening 2, C3 = 3.100 at 2.5 and 2.910 at 4. The four-dot mark on a Lagrange point brightens when its neck is open, and a particle a moving wall lands on starts again.\n// Knob 3: Mass. The small mass's share mu, from 0.1 to 0.5. At 0.1 the small mass sits on row 23, L1 13 rows below it and L2 16 rows above; at 0.5 the masses are equal, the picture is symmetric about the middle row, and L2 and L3 open together.\n// Knob 4: Trail. Seconds of path each particle leaves behind, 2 to 10. Time runs at 0.9 units a second, so the frame turns once every 7 seconds and a particle close to the large mass circles it in about one.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, round, exp, hypot, PI, cos, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The rotating frame: the primary, mass 1 - mu, at (-mu, 0) and the\n// secondary, mass mu, at (1 - mu, 0), turning once in 2 pi. The x axis runs\n// up the panel, S LEDs to a unit, with x = XC on the middle row.\nconst S = 46, XC = 0.02;\nconst toRow = (x) => 63.5 - (x - XC) * S;\nconst toCol = (y) => 31.5 + y * S;\n\n// Twice the effective potential, 2 Omega = x^2 + y^2 + 2(1 - mu)/r1 + 2 mu/r2.\n// The Jacobi constant is C = 2 Omega - v^2, so v^2 = 2 Omega - C and the\n// particle can never be where 2 Omega \u003c C.\nfunction omega2(mu, x, y) {\n  const r1 = hypot(x + mu, y), r2 = hypot(x - 1 + mu, y);\n  return x * x + y * y + (2 * (1 - mu)) / r1 + (2 * mu) / r2;\n}\n// d Omega / dx on the axis, whose three roots are L3 \u003c L1 \u003c L2.\nfunction omx(mu, x) {\n  const a = x + mu, b = x - 1 + mu;\n  return x - ((1 - mu) * a) / abs(a * a * a) - (mu * b) / abs(b * b * b);\n}\nfunction root(mu, lo, hi) {\n  let flo = omx(mu, lo);\n  for (let i = 0; i \u003c 80; i++) {\n    const m = (lo + hi) / 2, fm = omx(mu, m);\n    if (fm * flo > 0) (lo = m), (flo = fm);\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\nfunction lagrange(st) {\n  const mu = st.mu, e = 1e-9;\n  const L1 = root(mu, -mu + e, 1 - mu - e);\n  const L2 = root(mu, 1 - mu + e, 3);\n  const L3 = root(mu, -3, -mu - e);\n  st.L = [\n    [L1, 0],\n    [L2, 0],\n    [L3, 0],\n    [0.5 - mu, sqrt(3) / 2],\n    [0.5 - mu, -sqrt(3) / 2],\n  ];\n  st.CL = [omega2(mu, L1, 0), omega2(mu, L2, 0), omega2(mu, L3, 0), 3 - mu + mu * mu];\n}\n\n// The Jacobi knob as a ladder: at 0.5 the L1 neck is about to open, at 1.5\n// L2, at 2.5 L3, and at 4 the last forbidden islands round L4 and L5 shrink\n// to points. So the knob's whole number is how many necks are open.\nfunction jacobiOf(st, k) {\n  const [c1, c2, c3, c4] = st.CL;\n  const nodes = [\n    [0, c1 + 0.6 * (c1 - c2) + 0.04],\n    [0.5, c1],\n    [1.5, c2],\n    [2.5, c3],\n    [4, c4],\n  ];\n  for (let i = 1; i \u003c nodes.length; i++)\n    if (k \u003c= nodes[i][0]) {\n      const [k0, a] = nodes[i - 1], [k1, b] = nodes[i];\n      return a + ((b - a) * (k - k0)) / (k1 - k0);\n    }\n  return c4;\n}\n\n// The field of 2 Omega and its gradient over the panel, built when mu changes.\nfunction buildField(st) {\n  const mu = st.mu;\n  for (let r = 0; r \u003c H; r++) {\n    const x = XC + (63.5 - r) / S;\n    for (let c = 0; c \u003c W; c++) {\n      const y = (c - 31.5) / S, o = r * W + c;\n      const ax = x + mu, bx = x - 1 + mu;\n      const r1 = hypot(ax, y), r2 = hypot(bx, y);\n      const k1 = (1 - mu) / (r1 * r1 * r1), k2 = mu / (r2 * r2 * r2);\n      st.F[o] = x * x + y * y + (2 * (1 - mu)) / r1 + (2 * mu) / r2;\n      const gx = 2 * (x - k1 * ax - k2 * bx), gy = 2 * (y - k1 * y - k2 * y);\n      st.G[o] = max(1e-6, hypot(gx, gy));\n    }\n  }\n}\n\n// Equations of motion in the rotating frame:\n//   x'' = 2 y' + dOmega/dx,  y'' = -2 x' + dOmega/dy.\nfunction deriv(mu, s, out) {\n  const [x, y, vx, vy] = s;\n  const ax = x + mu, bx = x - 1 + mu;\n  const r1 = hypot(ax, y), r2 = hypot(bx, y);\n  const k1 = (1 - mu) / (r1 * r1 * r1), k2 = mu / (r2 * r2 * r2);\n  out[0] = vx;\n  out[1] = vy;\n  out[2] = 2 * vy + x - k1 * ax - k2 * bx;\n  out[3] = -2 * vx + y - k1 * y - k2 * y;\n}\n\nconst K = [new Float64Array(4), new Float64Array(4), new Float64Array(4), new Float64Array(4)], T = new Float64Array(4);\nfunction rk4(mu, s, h) {\n  deriv(mu, s, K[0]);\n  for (let i = 0; i \u003c 4; i++) T[i] = s[i] + 0.5 * h * K[0][i];\n  deriv(mu, T, K[1]);\n  for (let i = 0; i \u003c 4; i++) T[i] = s[i] + 0.5 * h * K[1][i];\n  deriv(mu, T, K[2]);\n  for (let i = 0; i \u003c 4; i++) T[i] = s[i] + h * K[2][i];\n  deriv(mu, T, K[3]);\n  for (let i = 0; i \u003c 4; i++) s[i] += (h / 6) * (K[0][i] + 2 * K[1][i] + 2 * K[2][i] + K[3][i]);\n}\n\n// Body radii in frame units, the drawn disc and the collision.\nconst bodyR = (m) => 0.035 + 0.06 * Math.cbrt(m);\n\n// The LEDs a particle can reach from the masses without crossing a wall,\n// found by a flood fill over the allowed region whenever C or mu moves.\nfunction reach(st) {\n  const key = st.mu + \"/\" + st.C;\n  if (st.maskKey === key) return;\n  st.maskKey = key;\n  const M = st.mask, Q = st.queue, F = st.F, C = st.C;\n  M.fill(0);\n  let n = 0, qh = 0;\n  for (const x of [-st.mu, 1 - st.mu]) {\n    const o = round(toRow(x)) * W + 32;\n    if (o >= 0 && o \u003c N && !M[o]) (M[o] = 1), (Q[n++] = o);\n  }\n  while (qh \u003c n) {\n    const o = Q[qh++], c = o % W;\n    for (const q of [o - W, o + W, c > 0 ? o - 1 : -1, c \u003c W - 1 ? o + 1 : -1])\n      if (q >= 0 && q \u003c N && !M[q] && F[q] > C + 0.02) (M[q] = 1), (Q[n++] = q);\n  }\n  st.reachable = n;\n}\n\n// A particle starts anywhere the masses can reach, with the speed its\n// Jacobi constant gives it there, in a random direction. Half of them start\n// in the lobe of the smaller mass, so there is always something to leak.\nfunction spawn(st, p) {\n  const mu = st.mu, C = st.C;\n  reach(st);\n  const L1 = st.L[0][0];\n  for (let tries = 0; tries \u003c 80; tries++) {\n    let x, y;\n    if (Math.random() \u003c 0.45) {\n      const r = bodyR(mu) + 0.01 + Math.random() * 0.8 * (1 - mu - L1), a = Math.random() * 2 * PI;\n      x = 1 - mu + r * cos(a);\n      y = r * sin(a);\n    } else {\n      const o = st.queue[floor(Math.random() * st.reachable)];\n      x = XC + (63.5 - floor(o / W) - Math.random() + 0.5) / S;\n      y = ((o % W) - 31.5 + Math.random() - 0.5) / S;\n    }\n    if (hypot(x + mu, y) \u003c bodyR(1 - mu) + 0.03 || hypot(x - 1 + mu, y) \u003c bodyR(mu) + 0.01) continue;\n    const v2 = omega2(mu, x, y) - C;\n    if (v2 \u003c= 0.01) continue;\n    const v = sqrt(v2), b = Math.random() * 2 * PI;\n    p.s[0] = x;\n    p.s[1] = y;\n    p.s[2] = v * cos(b);\n    p.s[3] = v * sin(b);\n    break;\n  }\n  p.n = 0;\n  p.age = 0;\n  p.out = 0;\n}\n\n// Put the speed back on the shell of the Jacobi constant, so the particle\n// keeps to the region the panel draws for it even as the knob moves.\nfunction shell(st, p) {\n  const s = p.s, v2 = omega2(st.mu, s[0], s[1]) - st.C, v = hypot(s[2], s[3]);\n  if (v2 \u003c= 0) {\n    s[2] = s[3] = 0;\n    return v2 \u003c -0.05;\n  }\n  if (v > 1e-9) {\n    const f = sqrt(v2) / v;\n    s[2] *= f;\n    s[3] *= f;\n  }\n  return false;\n}\n\nconst NP = 7, HIST = 320;\n\nexport function setup(params) {\n  params.st = {\n    mu: -1, C: 0, k: [0, 2, 0.1, 2],\n    F: new Float32Array(N), G: new Float32Array(N), mask: new Uint8Array(N), queue: new Int32Array(N), maskKey: '', reachable: 0,\n    R: new Float32Array(N), Gc: new Float32Array(N), B: new Float32Array(N),\n    parts: [], t: 0, frame: 0, c: new Float32Array(3),\n  };\n}\n\nfunction step(st, p, T) {\n  const mu = st.mu, s = p.s;\n  let left = T;\n  while (left > 0) {\n    const r1 = hypot(s[0] + mu, s[1]), r2 = hypot(s[0] - 1 + mu, s[1]);\n    // Small steps near a mass: a Kepler orbit there gets 300 steps a turn.\n    const h = min(left, 0.004, 0.02 * min(r1 ** 1.5, (r2 ** 1.5) / sqrt(mu / 0.1)));\n    rk4(mu, s, h);\n    left -= h;\n    if (r1 \u003c bodyR(1 - mu) * 0.8 || r2 \u003c bodyR(mu) * 0.8) return true;\n  }\n  return shell(st, p);\n}\n\nexport function update(dt, input, params) {\n  if (!params.st) setup(params);\n  const st = params.st, kv = input.knobValues || [0, 2, 0.1, 2], d = cl(dt || 0, 0, 0.1);\n  st.k = [kv[0], cl(kv[1], 0, 4), cl(kv[2], 0.1, 0.5), cl(kv[3], 2, 10)];\n  const mu = st.k[2];\n  if (abs(mu - st.mu) > 1e-6) {\n    st.mu = mu;\n    lagrange(st);\n    buildField(st);\n  }\n  st.C = jacobiOf(st, st.k[1]);\n  if (!st.parts.length) {\n    for (let i = 0; i \u003c NP; i++) {\n      const p = { s: new Float64Array(4), hx: new Float32Array(HIST), hy: new Float32Array(HIST), n: 0, head: 0, age: 0, out: 0, hue: i / NP };\n      spawn(st, p);\n      st.parts.push(p);\n    }\n    // Run the opening for ten seconds so the longest trails are there at once.\n    for (let f = 0; f \u003c 300; f++) advance(st, 1 / 30);\n  }\n  advance(st, d);\n}\n\nconst SPEED = 0.9;\n\nfunction advance(st, d) {\n  st.t += d;\n  for (const p of st.parts) {\n    p.age += d;\n    // A particle sitting in a wall the knob just moved over starts again.\n    let dead = shell(st, p);\n    if (!dead) dead = step(st, p, d * SPEED);\n    const row = toRow(p.s[0]), col = toCol(p.s[1]);\n    if (row \u003c -12 || row > H + 12 || col \u003c -12 || col > W + 12) p.out += d;\n    else p.out = 0;\n    if (dead || p.out > 0.6) {\n      spawn(st, p);\n      continue;\n    }\n    p.head = (p.head + 1) % HIST;\n    p.hx[p.head] = col;\n    p.hy[p.head] = row;\n    p.n = min(HIST, p.n + 1);\n  }\n}\n\nfunction splat(st, x, y, v, c) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(st, ix, iy, (1 - fx) * (1 - fy) * v, c);\n  add(st, ix + 1, iy, fx * (1 - fy) * v, c);\n  add(st, ix, iy + 1, (1 - fx) * fy * v, c);\n  add(st, ix + 1, iy + 1, fx * fy * v, c);\n}\nfunction add(st, x, y, v, c) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = y * W + x;\n  st.R[o] += v * c[0];\n  st.Gc[o] += v * c[1];\n  st.B[o] += v * c[2];\n}\n\nexport function draw(display, params) {\n  const st = params.st;\n  if (!st || st.mu \u003c 0) return;\n  const { F, G, R, Gc, B, c } = st, C = st.C, hue = st.k[0];\n  const wall = [0, 0, 0], edge = [0, 0, 0], topo = [0, 0, 0], glow = [0, 0, 0];\n  // The wall's dark hue skips orange and yellow, which read brown and olive.\n  const wh = 0.2 + 0.8 * frac(hue + 0.7);\n  hsv(wh, 0.75, 0.2, wall, 0);\n  hsv(wh, 0.55, 0.36, topo, 0);\n  hsv(hue + 0.52, 0.45, 1, edge, 0);\n  hsv(wh - 0.1, 0.6, 0.07, glow, 0);\n  const DL = 0.06;\n  for (let o = 0; o \u003c N; o++) {\n    const f = F[o], g = G[o] / S;\n    // Distance in LEDs to the zero-velocity curve 2 Omega = C.\n    const dist = (f - C) / g;\n    let r = 0, gg = 0, b = 0;\n    if (dist \u003c 0) {\n      // The forbidden region, with the curves of lower C it would retreat\n      // to drawn in it as a contour map.\n      const q = f / DL, dl = abs(q - round(q)) * DL / g;\n      const line = cl(1 - dl / 0.7, 0, 1);\n      r = wall[0] + (topo[0] - wall[0]) * line;\n      gg = wall[1] + (topo[1] - wall[1]) * line;\n      b = wall[2] + (topo[2] - wall[2]) * line;\n    } else {\n      // The allowed region, faintly lit by the speed a particle has there.\n      const v = cl((f - C) * 0.8, 0, 1);\n      r = glow[0] * v;\n      gg = glow[1] * v;\n      b = glow[2] * v;\n    }\n    const e = cl(1.15 - abs(dist) / 0.9, 0, 1);\n    R[o] = r + (edge[0] - r) * e;\n    Gc[o] = gg + (edge[1] - gg) * e;\n    B[o] = b + (edge[2] - b) * e;\n  }\n  // Lagrange points: bright when their neck is open, dim when shut.\n  for (let i = 0; i \u003c 5; i++) {\n    const [x, y] = st.L[i];\n    const open = i \u003c 3 ? C \u003c st.CL[i] : C \u003c st.CL[3] + 1e-9;\n    const v = open ? 0.9 : 0.35;\n    c[0] = c[1] = c[2] = v;\n    const rr = toRow(x), cc = toCol(y);\n    for (const [dx, dy] of [[-2, 0], [2, 0], [0, -2], [0, 2]]) splat(st, cc + dx, rr + dy, 0.8, c);\n  }\n  // The trails, oldest faintest.\n  const tr = st.k[3] * 30;\n  for (const p of st.parts) {\n    hsv(hue + 0.08 + p.hue * 0.5, 0.6, 1, c, 0);\n    const m = min(p.n, floor(tr), HIST);\n    const fadeIn = cl(p.age / 0.4, 0, 1);\n    for (let j = 1; j \u003c m; j++) {\n      const a = (p.head - j + 1 + HIST) % HIST, b = (p.head - j + HIST) % HIST;\n      const x0 = p.hx[a], y0 = p.hy[a], x1 = p.hx[b], y1 = p.hy[b];\n      const w = 1.5 * (1 - j / m) ** 1.2 * fadeIn;\n      const L = hypot(x1 - x0, y1 - y0), n = max(1, Math.ceil(L * 2));\n      if (L > 30) continue;\n      for (let i = 0; i \u003c n; i++) splat(st, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, (w * 0.9 * L) / n, c);\n    }\n    c[0] = c[0] * 0.3 + 0.7;\n    c[1] = c[1] * 0.3 + 0.7;\n    c[2] = c[2] * 0.3 + 0.7;\n    if (p.n) splat(st, p.hx[p.head], p.hy[p.head], 2 * fadeIn, c);\n  }\n  // The two masses.\n  const mu = st.mu;\n  for (const [mx, m, h] of [\n    [-mu, 1 - mu, 0.13],\n    [1 - mu, mu, 0.55],\n  ]) {\n    const rr = toRow(mx), cc = toCol(0), rad = bodyR(m) * S;\n    hsv(hue + h, 0.35, 1, c, 0);\n    for (let y = floor(rr - rad - 1); y \u003c= rr + rad + 1; y++)\n      for (let x = floor(cc - rad - 1); x \u003c= cc + rad + 1; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const dd = hypot(x - cc, y - rr), a = cl(rad + 0.5 - dd, 0, 1);\n        const o = y * W + x;\n        R[o] += (c[0] - R[o]) * a;\n        Gc[o] += (c[1] - Gc[o]) * a;\n        B[o] += (c[2] - B[o]) * a;\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++)\n      display.setPixel(x, y, round(min(1, R[o]) * 255), round(min(1, Gc[o]) * 255), round(min(1, B[o]) * 255));\n}\n","indian-rope-trick":"// ===== Patternflow pattern =====\n// Title:   Indian Rope Trick\n// Family:  physics\n// Idea:    A chain of three rigid links stands upside down the full height of the panel on a pivot that buzzes up and down too fast and too little to see, and every few seconds a tap sets it swaying until the vibration brings it back to vertical; turn the shaking down past the threshold and the chain topples, swings down past the pivot and is lifted upright to topple again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: inverted pendulum stabilised by a vibrating pivot (Andrew Stephenson, 1908; Pyotr Kapitza, 1951), the Indian rope trick of an n-link inverted pendulum (David Acheson, 1993; David Acheson and Tom Mullin, Nature, 1993), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Shake=0..3, Links=3..6, Nudge=0..1\n//\n// Knob 1: Hue. Turns the links' colour round the wheel: brass at 0, green at 0.25, sky blue at 0.5, violet at 0.75 and brass again at 1, every other link a deeper shade (copper at 0); the joints stay white.\n// Knob 2: Shake. The pivot's peak speed A w in units of sqrt(g L), L the whole chain's height. Below about 1.25 nothing holds the chain up: it topples over the side, swings down past the pivot, lies there 1.3 s and is stood up again. From 1.3 every chain stands, at the opening 2 it rides out the taps, and shaken harder still six links shiver and fall again from about 2.15 and five from about 2.7, while three and four still stand at 3. At 2 the three links' pivot moves 0.74 LED each way, 66 times a second.\n// Knob 3: Links. Three links, the triple pendulum Acheson and Mullin stood on its head, then four, five and six, always 116 LEDs tall together. More links need a faster shake, so the drive runs at 60 n sqrt(g / l) for n links of length l: 66 Hz for three, 187 Hz for six.\n// Knob 4: Nudge. How hard the tap is, every 2.5 to 3.5 s at the top joint or another: at the opening 0.06 the top sways 7 to 17 LEDs, each swing about 0.6 of the one before, so the next tap usually finds it still moving; from about 0.5 most taps knock the chain over.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sin, cos, sqrt, exp, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The chain stands 116 LEDs tall on a pivot at row 121, centred.\nconst L_PX = 116, PX = 31.5, PY = 121;\n// sqrt(L / g) for the whole chain's height L, in panel seconds; the time a\n// chain that tall takes to start falling. The panel runs slower than a bench.\nconst TAU = 0.75;\n// Joint friction, per natural time of one link, and a drag on every bit of\n// the chain in proportion to its speed, per panel second.\nconst DAMP = 0.06, DRAG = 0.7;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = null;\n}\n\nfunction makeChain(n) {\n  const S = {\n    n,\n    l: L_PX / n,\n    th: new Float64Array(n), om: new Float64Array(n),\n    k: [0, 1, 2, 3].map(() => [new Float64Array(n), new Float64Array(n)]),\n    t1: new Float64Array(n), o1: new Float64Array(n),\n    M: new Float64Array(n * n), f: new Float64Array(n), sn: new Float64Array(n), cs: new Float64Array(n),\n    t: 0, // physics time, panel seconds\n  };\n  // A link of length l falls on the time scale sqrt(l / g).\n  const tau = TAU / sqrt(n);\n  S.G = 1 / (tau * tau); // g / l\n  S.w = (60 * n) / tau; // drive, rad per panel second\n  S.b = DAMP / tau;\n  return S;\n}\n\n// The equations of motion of n identical uniform rods hinged end to end, the\n// first on a pivot driven up and down as A cos(w t). Angles from the upward\n// vertical; in the pivot's frame gravity becomes g - A w^2 cos(w t). With\n// mass and length scaled out, for links i, j counted from the bottom,\n//   sum_j a_ij th_j'' = - sum_j c_ij sin(th_i - th_j) th_j'^2\n//                       + (g_eff / l)(n - i - 1/2) sin th_i + friction,\n// where a_ii = n - i - 2/3 (zero-based i), a_ij = c_ij cos(th_i - th_j) and\n// c_ij = n - max(i, j) - 1/2: the rods above i and half of the higher of the\n// two. The n by n system is solved for th'' at every evaluation.\nfunction accel(S, th, om, t, out) {\n  const { n, M, f, sn, cs } = S;\n  const geff = S.G - S.Al * S.w * S.w * cos(S.w * t);\n  for (let i = 0; i \u003c n; i++) {\n    sn[i] = sin(th[i]);\n    cs[i] = cos(th[i]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    let r = geff * (n - i - 0.5) * sn[i];\n    for (let j = 0; j \u003c n; j++) {\n      if (j === i) {\n        M[i * n + j] = n - i - 2 / 3;\n        continue;\n      }\n      const c = n - max(i, j) - 0.5;\n      M[i * n + j] = c * (cs[i] * cs[j] + sn[i] * sn[j]);\n      r -= c * (sn[i] * cs[j] - cs[i] * sn[j]) * om[j] * om[j];\n    }\n    r -= S.b * (om[i] - (i > 0 ? om[i - 1] : 0));\n    if (i + 1 \u003c n) r += S.b * (om[i + 1] - om[i]);\n    f[i] = r;\n  }\n  solve(n, M, f, out);\n  // A drag proportional to the mass matrix adds -DRAG th' to every link.\n  for (let i = 0; i \u003c n; i++) out[i] -= DRAG * om[i];\n}\n\n// Gaussian elimination; the matrix is symmetric positive definite, so no pivoting.\nfunction solve(n, M, f, out) {\n  for (let k = 0; k \u003c n; k++) {\n    const d = M[k * n + k];\n    for (let r = k + 1; r \u003c n; r++) {\n      const q = M[r * n + k] / d;\n      if (!q) continue;\n      for (let c = k; c \u003c n; c++) M[r * n + c] -= q * M[k * n + c];\n      f[r] -= q * f[k];\n    }\n  }\n  for (let k = n - 1; k >= 0; k--) {\n    let s = f[k];\n    for (let c = k + 1; c \u003c n; c++) s -= M[k * n + c] * out[c];\n    out[k] = s / M[k * n + k];\n  }\n}\n\n// One classical Runge-Kutta step.\nfunction rk4(S, dt) {\n  const { n, th, om, k, t1, o1 } = S;\n  const hs = [0, 0.5, 0.5, 1];\n  for (let s = 0; s \u003c 4; s++) {\n    const h = hs[s] * dt, src = k[s ? s - 1 : 0];\n    for (let i = 0; i \u003c n; i++) {\n      t1[i] = th[i] + (s ? h * src[0][i] : 0);\n      o1[i] = om[i] + (s ? h * src[1][i] : 0);\n    }\n    k[s][0].set(o1);\n    accel(S, t1, o1, S.t + h, k[s][1]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    th[i] += (dt / 6) * (k[0][0][i] + 2 * k[1][0][i] + 2 * k[2][0][i] + k[3][0][i]);\n    om[i] += (dt / 6) * (k[0][1][i] + 2 * k[1][1][i] + 2 * k[2][1][i] + k[3][1][i]);\n  }\n  S.t += dt;\n}\n\n// A tap: a sideways impulse J at the top of link s, passed as P = J / (m l).\n// Its generalised impulse is J l cos th_i on every link up to s, and the kick\n// in angular velocity is the scaled mass matrix's inverse applied to P cos th_i.\nfunction tap(S, s, P) {\n  const { n, M, f, th, om } = S;\n  for (let i = 0; i \u003c n; i++) {\n    for (let j = 0; j \u003c n; j++) M[i * n + j] = i === j ? n - i - 2 / 3 : (n - max(i, j) - 0.5) * cos(th[i] - th[j]);\n    f[i] = i \u003c= s ? P * cos(th[i]) : 0;\n  }\n  const d = new Float64Array(n);\n  solve(n, M, f, d);\n  for (let i = 0; i \u003c n; i++) om[i] += d[i];\n}\n\n// Joint positions in LEDs for the chain's angles and the pivot's height.\nfunction joints(S, th, lift, out) {\n  let x = PX, y = PY - lift;\n  out[0] = x;\n  out[1] = y;\n  for (let i = 0; i \u003c S.n; i++) {\n    x += S.l * sin(th[i]);\n    y -= S.l * cos(th[i]);\n    out[2 * i + 2] = x;\n    out[2 * i + 3] = y;\n  }\n}\n\nconst wrap = (a) => a - 2 * PI * round(a / (2 * PI));\n\nexport function update(dt, input, params) {\n  const P = params;\n  const kv = input.knobValues || [0, 2, 3, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  P.hue = kv[0] || 0;\n  const shake = cl(kv[1], 0, 3);\n  const n = round(cl(kv[2], 3, 6));\n  P.nudge = cl(kv[3], 0, 1);\n  if (!P.s || P.s.n !== n) {\n    const old = P.s;\n    P.s = makeChain(n);\n    P.R = new Float32Array(N);\n    P.Gc = new Float32Array(N);\n    P.B = new Float32Array(N);\n    P.ghost = new Float32Array(N * 3);\n    P.pos = new Float64Array(2 * n + 2);\n    P.blur = [];\n    P.mode = \"stand\";\n    P.timer = 0;\n    P.nextTap = old ? 1.2 : 0.9;\n    P.s.th[n - 1] = 0.01;\n    P.time = old ? P.time : 0;\n  }\n  const S = P.s;\n  P.time += dt;\n  // The pivot's amplitude as a share of a link: A w = shake sqrt(g L) and\n  // sqrt(g L) = sqrt(n) l / tau for links of length l.\n  S.Al = (shake * sqrt(S.n) * sqrt(S.G)) / S.w;\n  P.ampPx = S.Al * S.l;\n  // Taps every 2.5 to 3.5 s, at the top joint twice as often as any other.\n  if (P.mode === \"stand\") {\n    P.nextTap -= dt;\n    if (P.nextTap \u003c= 0) {\n      P.nextTap = 2.5 + Math.random();\n      const s = Math.random() \u003c 0.5 ? S.n - 1 : floor(Math.random() * S.n);\n      const side = Math.random() \u003c 0.5 ? -1 : 1;\n      // The impulse in units of m sqrt(g l), m and l one link's mass and length.\n      const imp = side * (0.16 + 0.5 * P.nudge + 2.6 * P.nudge * P.nudge) * sqrt(S.n);\n      tap(S, s, imp * sqrt(S.G));\n      joints(S, S.th, 0, P.pos);\n      P.flash = { x: P.pos[2 * s + 2], y: P.pos[2 * s + 3], side, life: 1 };\n    }\n  }\n  if (P.flash) P.flash.life -= dt * 3;\n  // Steps of about 0.25 radian of the drive; four snapshots a frame for blur.\n  const steps = max(4, Math.ceil((dt * S.w) / 0.25));\n  const h = dt / steps;\n  P.blur.length = 0;\n  for (let i = 1; i \u003c= steps; i++) {\n    if (P.mode !== \"lift\") rk4(S, h);\n    else S.t += h;\n    if (i % Math.ceil(steps / 4) === 0 || i === steps) {\n      const out = new Float64Array(2 * S.n + 2);\n      joints(S, S.th, P.ampPx * cos(S.w * S.t), out);\n      P.blur.push(out);\n    }\n  }\n  // Fallen: the top has dropped below 60 percent of the chain's height, or a\n  // link lies past horizontal. After 1.3 s fallen it is lifted back upright\n  // over 0.9 s, every link easing to a small lean.\n  joints(S, S.th, 0, P.pos);\n  const topH = PY - P.pos[2 * S.n + 1];\n  let worst = 0;\n  for (let i = 0; i \u003c S.n; i++) worst = max(worst, abs(wrap(S.th[i])));\n  if (P.mode === \"stand\" && (topH \u003c 0.6 * L_PX || worst > 1.7)) {\n    P.mode = \"fallen\";\n    P.timer = 0;\n  } else if (P.mode === \"fallen\") {\n    P.timer += dt;\n    if (P.timer > 1.3) {\n      P.mode = \"lift\";\n      P.timer = 0;\n      P.from = Array.from(S.th, wrap);\n      P.to = P.from.map((a, i) => (i === S.n - 1 ? 0.02 * Math.sign(a || 1) : 0));\n    }\n  } else if (P.mode === \"lift\") {\n    P.timer += dt / 0.9;\n    const u = min(1, P.timer), e = u * u * (3 - 2 * u);\n    for (let i = 0; i \u003c S.n; i++) {\n      S.th[i] = P.from[i] + (P.to[i] - P.from[i]) * e;\n      S.om[i] = 0;\n    }\n    if (u >= 1) {\n      P.mode = \"stand\";\n      P.nextTap = 2.5;\n    }\n  }\n}\n\n// Additive light: a soft disc or a segment's capsule.\nfunction stamp(P, x, y, r, v, c) {\n  const x0 = max(0, floor(x - r - 1)), x1 = min(W - 1, Math.ceil(x + r + 1));\n  const y0 = max(0, floor(y - r - 1)), y1 = min(H - 1, Math.ceil(y + r + 1));\n  for (let Y = y0; Y \u003c= y1; Y++)\n    for (let X = x0; X \u003c= x1; X++) {\n      const d = Math.hypot(X - x, Y - y);\n      const a = cl(r + 0.5 - d, 0, 1) * v;\n      if (a \u003c= 0) continue;\n      const p = Y * W + X;\n      P.R[p] += a * c[0];\n      P.Gc[p] += a * c[1];\n      P.B[p] += a * c[2];\n    }\n}\n\n// A rod's cross-section by squared distance from its axis, in eighths of an\n// LED squared: a core about 3 LEDs thick and a soft glow either side.\nconst PROF = new Float32Array(201);\nfor (let k = 0; k \u003c= 200; k++) {\n  const d2 = k / 8;\n  PROF[k] = cl(1.85 - sqrt(d2), 0, 1) + 0.35 * exp(-d2 / 4) + 0.15 * exp(-d2 / 16);\n}\n\nfunction rod(P, ax, ay, bx, by, v, c) {\n  const dx = bx - ax, dy = by - ay, len2 = dx * dx + dy * dy || 1;\n  const pad = 5;\n  const x0 = max(0, floor(min(ax, bx) - pad)), x1 = min(W - 1, Math.ceil(max(ax, bx) + pad));\n  const y0 = max(0, floor(min(ay, by) - pad)), y1 = min(H - 1, Math.ceil(max(ay, by) + pad));\n  for (let Y = y0; Y \u003c= y1; Y++)\n    for (let X = x0; X \u003c= x1; X++) {\n      const u = cl(((X - ax) * dx + (Y - ay) * dy) / len2, 0, 1);\n      const ex = X - ax - u * dx, ey = Y - ay - u * dy;\n      const k = ((ex * ex + ey * ey) * 8 + 0.5) | 0;\n      if (k > 200) continue;\n      const a = PROF[k] * v, p = Y * W + X;\n      P.R[p] += a * c[0];\n      P.Gc[p] += a * c[1];\n      P.B[p] += a * c[2];\n    }\n}\n\nexport function draw(display, params) {\n  const P = params;\n  const S = P.s;\n  if (!S) return;\n  const { R, Gc, B, ghost } = P;\n  R.fill(0);\n  Gc.fill(0);\n  B.fill(0);\n  const col = [0, 0, 0];\n  // Brass at Hue 0.\n  hsv(P.hue + 0.11, 0.62, 1, col);\n  const deep = [0, 0, 0];\n  hsv(P.hue + 0.06, 0.8, 0.88, deep);\n  const n = S.n;\n  // The plumb line the chain should stand on, dotted.\n  for (let y = PY - L_PX; y \u003c PY; y += 3) stamp(P, PX, y, 0.3, 0.16, [0.6, 0.7, 0.9]);\n  // The chain at four moments of the frame, so the shake and the sway blur.\n  const wgt = 1 / P.blur.length;\n  for (const J of P.blur) {\n    for (let i = 0; i \u003c n; i++) {\n      // Links alternate bright and deeper brass, so each reads as its own rod.\n      const c = i & 1 ? deep : col;\n      rod(P, J[2 * i], J[2 * i + 1], J[2 * i + 2], J[2 * i + 3], wgt * (i & 1 ? 0.8 : 1), c);\n    }\n    for (let i = 0; i \u003c= n; i++) stamp(P, J[2 * i], J[2 * i + 1], i === 0 ? 2.1 : 1.8, wgt * 1.1, [1, 0.96, 0.9]);\n  }\n  // The tap: a white spark at the struck joint, thrown out on the side it came from.\n  if (P.flash && P.flash.life > 0) {\n    const f = P.flash;\n    for (let k = 0; k \u003c 4; k++) stamp(P, f.x - f.side * (2 + 2.2 * k * (1 - f.life)), f.y, 1.2 - 0.2 * k, f.life * 0.8, [1, 1, 1]);\n  }\n  // The shaker under the pivot: a block whose top plate rides with the pivot,\n  // drawn where it is this frame.\n  const lift = P.ampPx * cos(S.w * S.t);\n  const top = PY + 2 - lift;\n  for (let y = floor(top); y \u003c H; y++)\n    for (let x = 18; x \u003c 46; x++) {\n      const cover = cl(y + 1 - top, 0, 1);\n      const p = y * W + x;\n      const plate = y - top \u003c 2;\n      const edge = x === 18 || x === 45;\n      const v = cover * (plate ? 0.62 : edge ? 0.3 : 0.17);\n      R[p] += v * 0.75;\n      Gc[p] += v * 0.82;\n      B[p] += v * 0.95;\n    }\n  // The coil's hum: a glow in the block, brighter for a harder shake.\n  const hum = min(1, P.ampPx * 0.9) * (0.75 + 0.25 * sin(P.time * 40));\n  for (let x = 24; x \u003c 40; x++) stamp(P, x, 125.5, 0.6, 0.18 * hum, [1, 0.25, 0.5]);\n  // A short afterglow, so a fast swing leaves a fan behind it.\n  const keep = exp(-1 / 30 / 0.3);\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    ghost[q] = max(ghost[q] * keep, R[p] * 0.55);\n    ghost[q + 1] = max(ghost[q + 1] * keep, Gc[p] * 0.55);\n    ghost[q + 2] = max(ghost[q + 2] * keep, B[p] * 0.55);\n    const r = max(R[p], ghost[q]), g = max(Gc[p], ghost[q + 1]), b = max(B[p], ghost[q + 2]);\n    display.setPixel(p % W, (p / W) | 0, round(min(1, r) * 255), round(min(1, g) * 255), round(min(1, b) * 255));\n  }\n}\n","kibble-zurek-ions":"// ===== Patternflow pattern =====\n// Title:   Kibble-Zurek Ions\n// Family:  particle\n// Idea:    A chain of 30 to 40 ions standing the height of the panel buckles into a zigzag each time its transverse trap is lowered past the critical value, the quench freezes in kinks where the two orientations of the zigzag meet, and the chain prints its history outward on both sides, one rib per ion every quarter second, magenta and green for the two orientations with yellow seams where the kinks run.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kibble-Zurek mechanism (Tom Kibble, 1976; Wojciech Zurek, 1985), the linear-zigzag transition of ion chains (Shmuel Fishman, Gabriele De Chiara, Tommaso Calarco and Giovanna Morigi, 2008), kinks quenched into ion crystals (Karsten Pyka and others, 2013; Stefan Ulm and others, 2013), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Quench=0.2..3, Ions=30..40, Heat=0..1\n//\n// Knob 1: Hue. Turns the four colours round the wheel together. At 0 the two orientations of the zigzag are magenta and green, the straight chain blue and the kinks yellow; at 0.25 the orientations are orange and azure on a rose chain; at 0.5 magenta and green trade places and the straight chain turns yellow.\n// Knob 2: Quench. How fast the transverse trap frequency falls from 1.3 to 0.42 times its critical value: in 10 s at 0.2, 3.2 s at 1, 0.78 s at 2 and 0.19 s at 3. Over 60 quenches of 30 ions, counted 1.2 s into the hold, that freezes in 0.15 kinks at 0.2, 0.73 at 1, 1.9 at 2 and 2.1 at 3; during the 4 s hold about half of them slide out at the ends.\n// Knob 3: Ions. 30 to 40 ions, the axial trap set so a straight chain of any count reaches from row 5 to row 122. Thirty ions sit 3.3 rows apart in the middle and 6.5 at the ends and buckle when the transverse frequency drops below 12.0 times the axial one; forty sit 2.4 rows apart, buckle below 15.5 times and have room for more kinks, 3.1 a quench at Quench 3.\n// Knob 4: Heat. The temperature of the random kicks that stand for the cooling laser's photon recoil. At 0.06 they only decide which way each stretch of the chain buckles; at 0.5 the zigzag shivers and the kinks drift; toward 1 kinks and antikinks pop up in pairs and the history breaks into short domains.\n\nconst W = 64, H = 128, CX = 31.5, CY = 63.5;\nconst { floor, min, max, abs, sqrt, exp, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: lengths in LEDs, time in 1 / omega_z, the axial trap frequency, so\n// the axial force is -y. The Coulomb constant K is set per ion count so the\n// linear chain reaches HALF rows each way from the middle.\nconst HALF = 58;\n// The transverse trap frequency as a fraction of its critical value: RHI\n// holds the chain straight, RLO is the bottom of the quench. At RLO all but\n// the two end ions on each side buckle, 2.9 LEDs off the axis for 30 ions.\nconst RHI = 1.3, RLO = 0.42;\nconst DT = 0.004, GAMMA = 2, RATE = 1;\n// The transverse axis is drawn XS times wider than the axial one, so the\n// zigzag of 30 ions spans 12 columns.\nconst XS = 2;\n// History: KW columns each side of the chain, one every KT seconds.\nconst KW = 19, KT = 0.25;\n// Phases of the cycle in seconds: straight hold, quench (from the knob),\n// zigzag hold, release.\nconst T_LIN = 1, T_HOLD = 4, T_UP = 1;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The straight chain of n ions for Coulomb constant 1, by Newton's method,\n// then scaled to HALF; and the critical transverse stiffness, the largest\n// eigenvalue of the transverse Coulomb matrix (its zigzag mode).\nfunction chainFor(n) {\n  const z = new Float64Array(n);\n  for (let i = 0; i \u003c n; i++) z[i] = (i - (n - 1) / 2) * 0.9;\n  const J = new Float64Array(n * n), f = new Float64Array(n);\n  for (let it = 0; it \u003c 60; it++) {\n    J.fill(0);\n    let err = 0;\n    for (let i = 0; i \u003c n; i++) {\n      let fi = -z[i], dii = -1;\n      for (let j = 0; j \u003c n; j++) {\n        if (j === i) continue;\n        const d = z[i] - z[j], ad = abs(d);\n        fi += (d > 0 ? 1 : -1) / (d * d);\n        const c = 2 / (ad * ad * ad);\n        dii -= c;\n        J[i * n + j] = c;\n      }\n      J[i * n + i] = dii;\n      f[i] = -fi;\n      err = max(err, abs(fi));\n    }\n    if (err \u003c 1e-10) break;\n    // Gaussian elimination on J dz = -f.\n    for (let c = 0; c \u003c n; c++) {\n      const p = J[c * n + c];\n      for (let r = c + 1; r \u003c n; r++) {\n        const m = J[r * n + c] / p;\n        if (!m) continue;\n        for (let k = c; k \u003c n; k++) J[r * n + k] -= m * J[c * n + k];\n        f[r] -= m * f[c];\n      }\n    }\n    let lim = 1;\n    for (let r = n - 1; r >= 0; r--) {\n      let s = f[r];\n      for (let k = r + 1; k \u003c n; k++) s -= J[r * n + k] * f[k];\n      f[r] = s / J[r * n + r];\n    }\n    for (let i = 1; i \u003c n; i++) {\n      const gap = z[i] - z[i - 1], close = f[i - 1] - f[i];\n      if (close > 0.5 * gap) lim = min(lim, (0.5 * gap) / close);\n    }\n    for (let i = 0; i \u003c n; i++) z[i] += lim * f[i];\n  }\n  const s = HALF / z[n - 1], K = s * s * s;\n  for (let i = 0; i \u003c n; i++) z[i] *= s;\n  const M = new Float64Array(n * n);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) {\n      if (i === j) continue;\n      const d = abs(z[i] - z[j]), c = K / (d * d * d);\n      M[i * n + i] += c;\n      M[i * n + j] -= c;\n    }\n  let v = new Float64Array(n), u = new Float64Array(n), lam = 0;\n  for (let i = 0; i \u003c n; i++) v[i] = i % 2 ? 1 : -1;\n  for (let it = 0; it \u003c 400; it++) {\n    let nn = 0;\n    for (let i = 0; i \u003c n; i++) {\n      let a = 0;\n      for (let j = 0; j \u003c n; j++) a += M[i * n + j] * v[j];\n      u[i] = a;\n      nn += a * a;\n    }\n    lam = sqrt(nn);\n    for (let i = 0; i \u003c n; i++) v[i] = u[i] / lam;\n  }\n  return { n, K, z, kxc: lam };\n}\n\nexport function setup(params) {\n  params.s = {\n    chains: {}, c: null, n: 0,\n    x: new Float64Array(40), y: new Float64Array(40), vx: new Float64Array(40), vy: new Float64Array(40),\n    fx: new Float64Array(40), fy: new Float64Array(40), rank: new Int32Array(40), phi: new Float64Array(40),\n    hy: new Float32Array(KW * 40), hp: new Float32Array(KW * 40), hn: new Uint8Array(KW), head: 0, kt: 0,\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3), ck: new Float32Array(3),\n    phase: 0, pt: 0, r: RHI, tq: 1, temp: 0.002, hue: 0, kinks: [], started: false,\n  };\n  return params.s;\n}\n\nfunction load(S, n) {\n  if (!S.chains[n]) S.chains[n] = chainFor(n);\n  const c = (S.c = S.chains[n]);\n  S.n = n;\n  for (let i = 0; i \u003c n; i++) {\n    S.x[i] = 0;\n    S.y[i] = c.z[i];\n    S.vx[i] = S.vy[i] = 0;\n    S.rank[i] = i;\n  }\n  S.phase = 0;\n  S.pt = 0;\n  S.r = RHI;\n}\n\nfunction gauss() {\n  return (Math.random() + Math.random() + Math.random() - 1.5) * 2;\n}\n\nfunction step(S, h) {\n  const n = S.n, x = S.x, y = S.y, vx = S.vx, vy = S.vy, fx = S.fx, fy = S.fy, K = S.c.K;\n  const kx = S.c.kxc * S.r * S.r;\n  for (let i = 0; i \u003c n; i++) {\n    fx[i] = -kx * x[i];\n    fy[i] = -y[i];\n  }\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = x[i] - x[j], dy = y[i] - y[j], r2 = dx * dx + dy * dy, inv = K / (r2 * sqrt(r2));\n      fx[i] += dx * inv;\n      fy[i] += dy * inv;\n      fx[j] -= dx * inv;\n      fy[j] -= dy * inv;\n    }\n  const kick = sqrt(2 * GAMMA * S.temp * h), g = 1 - GAMMA * h;\n  for (let i = 0; i \u003c n; i++) {\n    vx[i] = (vx[i] + fx[i] * h) * g + kick * gauss();\n    vy[i] = (vy[i] + fy[i] * h) * g + kick * gauss();\n    x[i] += vx[i] * h;\n    y[i] += vy[i] * h;\n  }\n}\n\n// Order the ions along the axis and read the zigzag order parameter of\n// each, its sideways offset with the sign flipped on every other ion.\nfunction order(S) {\n  const n = S.n, rank = S.rank, y = S.y;\n  for (let a = 1; a \u003c n; a++) {\n    const v = rank[a];\n    let b = a - 1;\n    while (b >= 0 && y[rank[b]] > y[v]) {\n      rank[b + 1] = rank[b];\n      b--;\n    }\n    rank[b + 1] = v;\n  }\n  for (let a = 0; a \u003c n; a++) S.phi[a] = (a % 2 ? 1 : -1) * S.x[rank[a]];\n}\n\n// A kink sits between two neighbours that have both buckled, more than\n// BUCKLED LEDs off the axis, with opposite signs of the order parameter.\nconst BUCKLED = 0.35;\nfunction kinks(S) {\n  const rank = S.rank, phi = S.phi;\n  S.kinks.length = 0;\n  for (let a = 0; a + 1 \u003c S.n; a++) {\n    const pa = phi[a], pb = phi[a + 1];\n    if (pa * pb \u003c 0 && abs(pa) > BUCKLED && abs(pb) > BUCKLED) {\n      const ya = S.y[rank[a]], yb = S.y[rank[a + 1]];\n      S.kinks.push(CY + ya + ((yb - ya) * abs(pa)) / (abs(pa) + abs(pb)));\n    }\n  }\n}\n\nfunction advance(S, d) {\n  // The cycle: straight, quench, zigzag, release.\n  S.pt += d;\n  if (S.phase === 0 && S.pt >= T_LIN) (S.phase = 1), (S.pt = 0);\n  if (S.phase === 1 && S.pt >= S.tq) (S.phase = 2), (S.pt = 0);\n  if (S.phase === 2 && S.pt >= T_HOLD) (S.phase = 3), (S.pt = 0);\n  if (S.phase === 3 && S.pt >= T_UP) (S.phase = 0), (S.pt = 0);\n  S.r = S.phase === 0 ? RHI : S.phase === 1 ? RHI + ((RLO - RHI) * S.pt) / S.tq : S.phase === 2 ? RLO : RLO + ((RHI - RLO) * S.pt) / T_UP;\n  const steps = max(1, round((d * RATE) / DT)), h = (d * RATE) / steps;\n  for (let k = 0; k \u003c steps; k++) step(S, h);\n  order(S);\n  kinks(S);\n  S.kt += d;\n  if (S.kt >= KT) {\n    S.kt -= KT;\n    S.head = (S.head + 1) % KW;\n    const b = S.head * 40;\n    S.hn[S.head] = S.n;\n    for (let a = 0; a \u003c S.n; a++) {\n      S.hy[b + a] = S.y[S.rank[a]] + CY;\n      S.hp[b + a] = S.phi[a];\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 30, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const q = cl(kv[1], 0.2, 3);\n  S.tq = 10 * 30 ** (-(q - 0.2) / 2.4);\n  const n = cl(round(kv[2]), 30, 40);\n  const heat = cl(kv[3], 0, 1);\n  S.temp = 0.002 + 3 * heat * heat * heat;\n  if (n !== S.n) load(S, n);\n  if (!S.started) {\n    // Run quenches until one has frozen in a kink (four at most), and open\n    // 1.2 s into its hold, with the history beside it already full.\n    S.started = true;\n    for (let tries = 0, f = 0; f \u003c 3000; f++) {\n      advance(S, 1 / 30);\n      if (S.phase === 2 && S.pt >= 1.2 && S.pt \u003c 1.2 + 1 / 30) {\n        if (S.kinks.length || ++tries >= 4) break;\n      }\n    }\n  }\n  advance(S, d);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.c) return;\n  const rgb = S.rgb, c = S.c, ck = S.ck;\n  rgb.fill(0);\n  hsv(0.1667 + S.hue, 1, 1, ck);\n  // History: the newest column touches the chain's zone and older ones move\n  // out. Each ion leaves a rib in its colour, one row high while it is on\n  // the axis and two once it has buckled, from blue through violet to\n  // magenta or through cyan to green; yellow fills the gap at a kink.\n  const inner = 12;\n  for (let k = 0; k \u003c KW; k++) {\n    const col = ((S.head - k) % KW + KW) % KW, b = col * 40, n = S.hn[col];\n    const xl = floor(CX) - inner - k, xr = Math.ceil(CX) + inner + k;\n    let prevY = -9, prevP = 0;\n    for (let a = 0; a \u003c n; a++) {\n      const p = S.hp[b + a], Y = floor(S.hy[b + a]);\n      const s = cl((abs(p) - 0.25) / 0.3, 0, 1);\n      hsv(S.hue + 0.6667 + (p > 0 ? 0.1667 : -0.3333) * s, 1, 1, c);\n      const r = c[0], g = c[1], bl = c[2];\n      for (let y = Y; y \u003c= Y + (s > 0.5 ? 1 : 0); y++) {\n        if (y \u003c 0 || y >= H) continue;\n        for (const X of [xl, xr]) {\n          if (X \u003c 0 || X >= W) continue;\n          const i = (y * W + X) * 3;\n          rgb[i] = r;\n          rgb[i + 1] = g;\n          rgb[i + 2] = bl;\n        }\n      }\n      if (p * prevP \u003c 0 && abs(p) > BUCKLED && abs(prevP) > BUCKLED)\n        for (let y = prevY + 2; y \u003c Y; y++) {\n          if (y \u003c 0 || y >= H) continue;\n          for (const X of [xl, xr]) {\n            if (X \u003c 0 || X >= W) continue;\n            const i = (y * W + X) * 3;\n            rgb[i] = ck[0];\n            rgb[i + 1] = ck[1];\n            rgb[i + 2] = ck[2];\n          }\n        }\n      prevY = Y;\n      prevP = p;\n    }\n  }\n  // Kink ticks beside the chain.\n  for (const yk of S.kinks) {\n    const Y = round(yk);\n    if (Y \u003c 0 || Y >= H) continue;\n    for (let X = floor(CX) - inner + 2; X \u003c= Math.ceil(CX) + inner - 2; X++) {\n      if (abs(X - CX) \u003c 8) continue;\n      const i = (Y * W + X) * 3;\n      rgb[i] = ck[0];\n      rgb[i + 1] = ck[1];\n      rgb[i + 2] = ck[2];\n    }\n  }\n  // Ions: a disc in their colour, with a pale core.\n  for (let a = 0; a \u003c S.n; a++) {\n    const i = S.rank[a], p = S.phi[a];\n    const px = CX + XS * S.x[i], py = CY + S.y[i];\n    const s = cl((abs(p) - 0.25) / 0.3, 0, 1);\n    hsv(S.hue + 0.6667 + (p > 0 ? 0.1667 : -0.3333) * s, 1, 1, c);\n    const hr = c[0], hg = c[1], hb = c[2];\n    for (let Y = max(0, floor(py - 3)); Y \u003c= min(H - 1, Math.ceil(py + 3)); Y++)\n      for (let X = max(0, floor(px - 3)); X \u003c= min(W - 1, Math.ceil(px + 3)); X++) {\n        const e2 = (X - px) * (X - px) + (Y - py) * (Y - py);\n        const halo = cl((exp(-((e2 / 5) ** 3)) - 0.25) / 0.5, 0, 1), core = exp(-e2 / 0.6);\n        if (halo \u003c= 0) continue;\n        const o = (Y * W + X) * 3;\n        rgb[o] = max(rgb[o], hr * halo + (255 - hr) * core * 0.8);\n        rgb[o + 1] = max(rgb[o + 1], hg * halo + (255 - hg) * core * 0.8);\n        rgb[o + 2] = max(rgb[o + 2], hb * halo + (255 - hb) * core * 0.8);\n      }\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = (Y * W + X) * 3;\n      display.setPixel(X, Y, min(255, rgb[o]) | 0, min(255, rgb[o + 1]) | 0, min(255, rgb[o + 2]) | 0);\n    }\n}\n","letter-sand":"// ===== Patternflow pattern =====\n// Title:   Letter Sand\n// Family:  type\n// Idea:    A word of four wide bold letters stacked down the panel is made of grains of sand: it stands, crumbles from the bottom letter up with each letter running out from its foot, and the grains fall and slide into a pile whose layers keep the letters' colours in order, until a stream of sand rises from a pit in the pile and builds the next word of the sediment cycle, ROCK, SAND, DUNE, DUST, SILT, LOAM, from each letter's foot up.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after falling-sand games and bottles of layered craft sand\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Grain=1..3, Wind=-1..1\n//\n// Knob 1: Hue. Turns the four sand colours round the wheel together. At 0 the letters from the top are gold, rose, turquoise and violet, like a bottle of craft sand; at 0.25 green, lime, indigo and red; at 0.5 blue, aqua, rose and lime.\n// Knob 2: Speed. Everything at once. At 2 a grain in the air falls up to 75 LEDs a second and a word takes about 10.6 s, 2.4 s standing, 4.7 s crumbling and 2.9 to 3.8 s rising again, so the six words come round in 64 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Grain. The size of a grain: one LED at 1, where SAND is 1,262 grains, a 2 by 2 block at 2 (394 grains) and a 3 by 3 block at 3 (204). The letters stay about 36 LEDs wide and 20 tall; a new size rebuilds the sand around the word that stands.\n// Knob 4: Wind. Blows across the falling grains and leans the rising stream. At 0.06 a breath: the stream barely leans and now and then a grain on the pile rolls one cell to the right. At 1 or -1 every other step of a falling grain is a step sideways, so the sand pours at 27 degrees, the pile creeps against one wall and the stream bows over.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The sediment cycle, one word a turn: rock weathers to sand, wind heaps it\n// into a dune and lifts the finest as dust, water carries silt, and silt\n// settles into loam.\nconst WORDS = [\"ROCK\", \"SAND\", \"DUNE\", \"DUST\", \"SILT\", \"LOAM\"];\n\n// A wide bold face drawn as stroke centre lines on a 4 by 4 grid, y down.\n// Straight strokes have square ends; the short diagonals cut the corners.\nconst C = 0.9, D = 4 - C;\nconst GLYPH = {\n  A: [[0, 4, 0, C, C, 0, D, 0, 4, C, 4, 4], [0, 2.2, 4, 2.2]],\n  C: [[4, 0, C, 0, 0, C, 0, D, C, 4, 4, 4]],\n  D: [[0, 0, D, 0, 4, C, 4, D, D, 4, 0, 4, 0, 0]],\n  E: [[4, 0, 0, 0, 0, 4, 4, 4], [0, 2, 3.2, 2]],\n  I: [[1, 0, 3, 0], [2, 0, 2, 4], [1, 4, 3, 4]],\n  K: [[0, 0, 0, 4], [0, 2, 1.6, 2, 4, 0], [1.6, 2, 4, 4]],\n  L: [[0, 0, 0, 4, 4, 4]],\n  M: [[0, 4, 0, 0, 2, 2.2, 4, 0, 4, 4]],\n  N: [[0, 4, 0, 0, 4, 4, 4, 0]],\n  O: [[C, 0, D, 0, 4, C, 4, D, D, 4, C, 4, 0, D, 0, C, C, 0]],\n  R: [[0, 4, 0, 0, D, 0, 4, C, 4, 2 - C, D, 2, 0, 2], [2, 2, 4, 4]],\n  S: [[4, 0, C, 0, 0, C, 0, 2 - C, C, 2, D, 2, 4, 2 + C, 4, D, D, 4, 0, 4]],\n  T: [[0, 0, 4, 0], [2, 0, 2, 4]],\n  U: [[0, 0, 0, D, C, 4, D, 4, 4, D, 4, 0]],\n};\n// For each grain size, in cells: letter width and height, stroke width of\n// the uprights and of the bars, the gap between letters and the top margin.\nconst LAYOUT = [\n  null,\n  { lw: 36, lh: 19, sx: 5, sy: 3, gap: 3, top: 3 },\n  { lw: 18, lh: 10, sx: 3, sy: 2, gap: 2, top: 2 },\n  { lw: 12, lh: 7, sx: 3, sy: 1, gap: 1, top: 1 },\n];\n// Slot colours, top letter first: gold, rose, turquoise, violet, as in a\n// bottle of layered craft sand.\nconst HUES = [0.12, 0.96, 0.48, 0.74];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The cells of one letter, relative to its box.\nfunction raster(ch, L) {\n  const { lw, lh, sx, sy } = L, hx = sx / 2, hy = sy / 2;\n  const mx = (x) => (sx - 1) / 2 + (x / 4) * (lw - sx), my = (y) => (sy - 1) / 2 + (y / 4) * (lh - sy);\n  const segs = [];\n  for (const pl of GLYPH[ch]) for (let i = 0; i + 3 \u003c pl.length; i += 2) segs.push([mx(pl[i]), my(pl[i + 1]), mx(pl[i + 2]), my(pl[i + 3])]);\n  const out = [];\n  for (let Y = 0; Y \u003c lh; Y++)\n    for (let X = 0; X \u003c lw; X++)\n      for (const [ax, ay, bx, by] of segs) {\n        let d;\n        if (abs(ay - by) \u003c 1e-6) d = max(max(0, min(ax, bx) - X, X - max(ax, bx)) / hx, abs(Y - ay) / hy);\n        else if (abs(ax - bx) \u003c 1e-6) d = max(max(0, min(ay, by) - Y, Y - max(ay, by)) / hy, abs(X - ax) / hx);\n        else {\n          const ux = (X - ax) / hx, uy = (Y - ay) / hy, vx = (bx - ax) / hx, vy = (by - ay) / hy;\n          const t = cl((ux * vx + uy * vy) / (vx * vx + vy * vy), 0, 1);\n          d = sqrt((ux - t * vx) ** 2 + (uy - t * vy) ** 2);\n        }\n        if (d \u003c 1) {\n          out.push(X, Y);\n          break;\n        }\n      }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = { g: 0, trail: new Float32Array(W * H * 3), pal: new Float32Array(12), tmp: new Float32Array(3) };\n  return params.s;\n}\n\n// Build the grid for grain size g, with word w standing and the rest of the\n// sand lying on the floor in old layers.\nfunction build(S, g, w) {\n  const L = LAYOUT[g];\n  const cw = floor(W / g), ch = floor(H / g);\n  S.g = g;\n  S.L = L;\n  S.cw = cw;\n  S.ch = ch;\n  S.ox = floor((W - cw * g) / 2);\n  S.oy = H - ch * g;\n  // Target cells of every word, top letter first.\n  S.targets = WORDS.map((word) => {\n    const cells = [];\n    const x0 = floor((cw - L.lw) / 2);\n    for (let k = 0; k \u003c 4; k++) {\n      const r = raster(word[k], L), y0 = L.top + k * (L.lh + L.gap);\n      for (let i = 0; i \u003c r.length; i += 2) cells.push(x0 + r[i], y0 + r[i + 1], k);\n    }\n    return cells;\n  });\n  let most = 0;\n  for (const t of S.targets) most = max(most, t.length / 3);\n  const T = (S.T = most + (5 - g) * cw);\n  S.grid = new Int32Array(cw * ch);\n  S.x = new Float32Array(T);\n  S.y = new Float32Array(T);\n  S.st = new Uint8Array(T); // 0 loose sand, 1 held in a letter, 2 in flight\n  S.col = new Uint8Array(T); // slot colour 0..3\n  S.from = new Uint8Array(T);\n  S.shade = new Float32Array(T);\n  S.rel = new Float32Array(T);\n  S.fx0 = new Float32Array(T);\n  S.fy0 = new Float32Array(T);\n  S.fcx = new Float32Array(T);\n  S.fcy = new Float32Array(T);\n  S.fdx = new Float32Array(T);\n  S.fdy = new Float32Array(T);\n  S.ft = new Float32Array(T);\n  S.fdur = new Float32Array(T);\n  S.slot = new Int32Array(T);\n  S.stamp = new Int32Array(T);\n  S.step = 0;\n  for (let i = 0; i \u003c T; i++) S.shade[i] = 0.72 + 0.28 * Math.random();\n  // The word.\n  const tg = S.targets[w];\n  let i = 0;\n  for (let j = 0; j \u003c tg.length; j += 3, i++) put(S, i, tg[j], tg[j + 1], 1, tg[j + 2]);\n  // The rest on the floor, in bands of the four colours, bottom up.\n  for (let y = ch - 1; i \u003c T; y--)\n    for (let x = 0; x \u003c cw && i \u003c T; x++, i++) put(S, i, x, y, 0, (floor((ch - 1 - y) / 2) + 3) % 4);\n  S.word = w;\n  S.phase = 0;\n  S.pt = 0;\n  S.flying = 0;\n}\n\nfunction put(S, i, x, y, st, col) {\n  S.x[i] = x;\n  S.y[i] = y;\n  S.st[i] = st;\n  S.col[i] = col;\n  S.grid[y * S.cw + x] = i + 1;\n}\n\n// One step of falling sand: each loose grain drops a cell if it can, else\n// slides one cell diagonally down; returns how many fell or slid. Wind tips a falling grain sideways, and\n// now and then rolls a grain on the surface one cell downwind, so a pile in\n// the wind creeps and grows a steep lee side.\nfunction fall(S, wind) {\n  const cw = S.cw, ch = S.ch, grid = S.grid, stamp = S.stamp, step = ++S.step;\n  const dir = wind > 0 ? 1 : -1, creep = abs(wind) * 0.06;\n  let moved = 0;\n  const flip = (S.flip = !S.flip);\n  for (let y = ch - 1; y >= 0; y--)\n    for (let k = 0; k \u003c cw; k++) {\n      const x = flip ? k : cw - 1 - k, o = y * cw + x, id = grid[o];\n      if (!id || S.st[id - 1] !== 0 || stamp[id - 1] === step) continue;\n      const i = id - 1, b = o + cw, floor_ = y === ch - 1;\n      let to = -1;\n      if (!floor_ && !grid[b]) {\n        // Grains in the air fall at slightly different speeds, so a\n        // crumbling letter smears into a curtain on the way down.\n        if (Math.random() > S.shade[i]) continue;\n        to = b;\n        const xx = x + dir;\n        if (Math.random() \u003c abs(wind) * 0.5 && xx >= 0 && xx \u003c cw && !grid[b + dir]) to = b + dir;\n      } else if (!floor_) {\n        const first = Math.random() \u003c 0.5 + wind * 0.4 ? 1 : -1;\n        for (const dx of [first, -first]) {\n          const xx = x + dx;\n          if (xx >= 0 && xx \u003c cw && !grid[b + dx]) {\n            to = b + dx;\n            break;\n          }\n        }\n      }\n      if (to >= 0) moved++;\n      else if ((y === 0 || !grid[o - cw]) && Math.random() \u003c creep) {\n        const xx = x + dir;\n        if (xx >= 0 && xx \u003c cw && !grid[o + dir]) to = o + dir;\n      }\n      if (to \u003c 0) continue;\n      grid[o] = 0;\n      grid[to] = id;\n      stamp[i] = step;\n      S.x[i] = to % cw;\n      S.y[i] = floor(to / cw);\n    }\n  return moved;\n}\n\n// The top grain of the pile in column x: the highest of the loose grains\n// stacked without a gap from the floor. The two rows on the floor are\n// bedrock and stay.\nfunction topOf(S, x) {\n  let y = S.ch - 1, top = -1;\n  if (S.grid[y * S.cw + x] && S.grid[(y - 1) * S.cw + x]) y -= 2;\n  else return -1;\n  for (; y >= 0; y--) {\n    const id = S.grid[y * S.cw + x];\n    if (!id || S.st[id - 1] !== 0) break;\n    top = id - 1;\n  }\n  return top;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const rate = cl(kv[1], 0.2, 3) / 2;\n  const g = cl(round(kv[2]), 1, 3);\n  S.wind = cl(kv[3], -1, 1);\n  if (g !== S.g) {\n    // A new grain size rebuilds the sand around the word standing now. The\n    // first build opens 0.8 s into the hold.\n    const first = !S.g;\n    build(S, g, first ? 0 : S.word);\n    S.pt = first ? 0.8 : 0;\n  }\n  const t = d * rate;\n  S.pt += t;\n  // Falling sand runs 75 LEDs a second at Speed 2.\n  S.acc = (S.acc || 0) + (t * 75) / g;\n  let moved = 0;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    moved += fall(S, S.wind);\n  }\n  if (S.phase === 0) {\n    // While the word holds, now and then a grain with nothing under it\n    // runs out of a letter's foot.\n    const L = S.L;\n    for (let k = 0; k \u003c S.T / 60; k++) {\n      const i = floor(Math.random() * S.T);\n      if (S.st[i] === 1 && S.y[i] === L.top + S.col[i] * (L.lh + L.gap) + L.lh - 1 && !S.grid[(S.y[i] + 1) * S.cw + S.x[i]] && Math.random() \u003c t * 3) S.st[i] = 0;\n    }\n  }\n  if (S.phase === 0 && S.pt > 2.4) {\n    // Crumble: the bottom letter goes first, each letter from its foot up.\n    S.phase = 1;\n    S.pt = 0;\n    const L = S.L;\n    for (let i = 0; i \u003c S.T; i++)\n      if (S.st[i] === 1) {\n        const k = S.col[i], y0 = L.top + k * (L.lh + L.gap), up = (y0 + L.lh - 1 - S.y[i]) / L.lh;\n        S.rel[i] = (3 - k) * 0.6 + up * 0.95 + Math.random() * 0.12;\n      }\n  } else if (S.phase === 1) {\n    let held = 0;\n    for (let i = 0; i \u003c S.T; i++)\n      if (S.st[i] === 1) {\n        if (S.rel[i] \u003c= S.pt) S.st[i] = 0;\n        else held++;\n      }\n    if (!held && ((!moved && S.pt > 2.5) || S.pt > 8)) {\n      // Assemble the next word: queue its cells top letter first, each\n      // letter from its foot up.\n      S.phase = 2;\n      S.pt = 0;\n      S.word = (S.word + 1) % WORDS.length;\n      const tg = S.targets[S.word], n = tg.length / 3, ord = [];\n      for (let j = 0; j \u003c n; j++) {\n        const x = tg[3 * j], y = tg[3 * j + 1];\n        ord.push([tg[3 * j + 2] * 100000 - y * 1000 + (y % 2 ? x : -x), j]);\n      }\n      ord.sort((a, b) => a[0] - b[0]);\n      S.queue = ord.map((o) => o[1]);\n      S.next = 0;\n      S.launch = 0;\n    }\n  } else if (S.phase === 2) {\n    const tg = S.targets[S.word], cw = S.cw;\n    S.launch += (t * 440) / (g * g);\n    while (S.launch >= 1 && S.next \u003c S.queue.length) {\n      S.launch -= 1;\n      // Take the highest grain near the mouth, which wanders slowly over\n      // the pile; the sand around slides into the pit it digs. Sand still\n      // heaped up into the letter about to be built goes first.\n      const j0 = S.queue[S.next], L = S.L;\n      const foot = L.top + tg[3 * j0 + 2] * (L.lh + L.gap) + L.lh + 1;\n      const mouth = round(cw / 2 + (cw / 5) * Math.sin(S.pt * 0.9));\n      let best = -1, high = -1;\n      for (let x = 0; x \u003c cw; x++) {\n        const id = topOf(S, x);\n        if (id \u003c 0) continue;\n        if (high \u003c 0 || S.y[id] \u003c S.y[high]) high = id;\n        if (abs(x - mouth) \u003c= 3 && (best \u003c 0 || S.y[id] \u003c S.y[best])) best = id;\n      }\n      if (high >= 0 && (best \u003c 0 || S.y[high] \u003c= foot)) best = high;\n      if (best \u003c 0) break;\n      const j = S.queue[S.next++], i = best;\n      S.grid[S.y[i] * cw + S.x[i]] = 0;\n      S.st[i] = 2;\n      S.from[i] = S.col[i];\n      S.col[i] = tg[3 * j + 2];\n      S.slot[i] = j;\n      // Every grain for one letter rides the same two control points, so\n      // the grains in flight draw one rising stream from the top of the\n      // pile to a point under the letter, where it fans out into the\n      // letter's cells. The stream sways, and the wind leans it.\n      const x0 = S.x[i], y0 = S.y[i], k = S.col[i];\n      const yb = L.top + k * (L.lh + L.gap) + L.lh + 2, lx = cw / 2;\n      const lean = (S.wind * 14 + 5 * Math.sin(S.pt * 1.3)) / g, jit = () => (Math.random() - 0.5) * 2;\n      S.fx0[i] = x0;\n      S.fy0[i] = y0;\n      S.fcx[i] = x0 + lean + jit();\n      S.fcy[i] = y0 - 0.55 * (y0 - yb) + jit();\n      S.fdx[i] = lx + 0.6 * lean + 1.5 * jit();\n      S.fdy[i] = yb + 0.1 * (y0 - yb) + jit();\n      S.ft[i] = 0;\n      S.fdur[i] = 0.9 + Math.random() * 0.1;\n      S.flying++;\n    }\n    for (let i = 0; i \u003c S.T; i++) {\n      if (S.st[i] !== 2) continue;\n      S.ft[i] += t;\n      const j = S.slot[i], x1 = tg[3 * j], y1 = tg[3 * j + 1];\n      let u = S.ft[i] / S.fdur[i];\n      if (u >= 1) {\n        S.flying--;\n        const o = y1 * cw + x1, there = S.grid[o];\n        if (there) {\n          // A loose grain already sits in the cell: it joins the letter and\n          // the newcomer drops in as loose sand beside it.\n          const k = there - 1;\n          S.st[k] = 1;\n          S.col[k] = S.col[i];\n          let yy = y1 - 1;\n          while (yy > 0 && S.grid[yy * cw + x1]) yy--;\n          put(S, i, x1, yy, 0, S.col[i]);\n        } else put(S, i, x1, y1, 1, S.col[i]);\n        continue;\n      }\n      u = u * u * (3 - 2 * u);\n      const v = 1 - u, a = v * v * v, b = 3 * v * v * u, c = 3 * v * u * u, e = u * u * u;\n      S.x[i] = a * S.fx0[i] + b * S.fcx[i] + c * S.fdx[i] + e * x1;\n      S.y[i] = a * S.fy0[i] + b * S.fcy[i] + c * S.fdy[i] + e * y1;\n    }\n    if (S.next >= S.queue.length && !S.flying) {\n      S.phase = 0;\n      S.pt = 0;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.g) return;\n  const g = S.g, pal = S.pal, tr = S.trail, c = S.tmp;\n  for (let k = 0; k \u003c 4; k++) hsv(HUES[k] + S.hue, 0.78, 1, pal, k * 3);\n  for (let o = 0; o \u003c tr.length; o++) tr[o] *= 0.75;\n  const rgb = (S.rgb = S.rgb || new Float32Array(W * H * 3));\n  rgb.set(tr);\n  for (let i = 0; i \u003c S.T; i++) {\n    const sh = S.shade[i];\n    let r = pal[S.col[i] * 3] * sh, gg = pal[S.col[i] * 3 + 1] * sh, b = pal[S.col[i] * 3 + 2] * sh;\n    let X = S.ox + round(S.x[i] * g), Y = S.oy + round(S.y[i] * g);\n    if (S.st[i] === 2) {\n      // In flight: brighter, turning from the old colour to the new.\n      const u = cl(S.ft[i] / S.fdur[i], 0, 1), f = S.from[i] * 3, k = S.col[i] * 3;\n      r = min(255, (pal[f] + (pal[k] - pal[f]) * u) * 1.2);\n      gg = min(255, (pal[f + 1] + (pal[k + 1] - pal[f + 1]) * u) * 1.2);\n      b = min(255, (pal[f + 2] + (pal[k + 2] - pal[f + 2]) * u) * 1.2);\n    }\n    for (let yy = 0; yy \u003c g; yy++)\n      for (let xx = 0; xx \u003c g; xx++) {\n        const px = X + xx, py = Y + yy;\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const o = (py * W + px) * 3;\n        rgb[o] = r;\n        rgb[o + 1] = gg;\n        rgb[o + 2] = b;\n        if (S.st[i] === 2) {\n          tr[o] = max(tr[o], r * 0.45);\n          tr[o + 1] = max(tr[o + 1], gg * 0.45);\n          tr[o + 2] = max(tr[o + 2], b * 0.45);\n        }\n      }\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = (Y * W + X) * 3;\n      display.setPixel(X, Y, rgb[o] | 0, rgb[o + 1] | 0, rgb[o + 2] | 0);\n    }\n}\n","polynomial-amoeba":"// ===== Patternflow pattern =====\n// Title:   Polynomial Amoeba\n// Family:  topology\n// Idea:    The amoeba of a curve f(z, w) = 0 whose Newton polygon is a hexagon with three interior points, solved row by row as the image of its zeros under (log|z|, log|w|), breathes slowly between a fat starfish and the thin tropical ladder it shrinks onto, and its three stacked holes open and close by turns as the middle coefficients rise and fall.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: amoebas of polynomials (Israel Gelfand, Mikhail Kapranov and Andrei Zelevinsky, 1994), holes and interior lattice points (Mikael Forsberg, Mikael Passare and August Tsikh, 2000), amoebas of maximal area (Grigory Mikhalkin and Hans Rullgard, 2001), tropical limit (Grigory Mikhalkin, 2005), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lift=-1..1, Phase=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together; at 0 the body is sea green, bluer along its diagonal tentacles, the holes are violet and the tropical curve a pale gold thread.\n// Knob 2: Speed. How fast the tide of t runs: at 2 the amoeba goes from starfish to ladder and back in 22 seconds, at 0.2 in 3 minutes 40, at 3 in 15 seconds; the coefficients drift at the same pace.\n// Knob 3: Lift. The size of the three middle coefficients, those of z w, z w^2 and z w^3: at -1 they are too small for any hole and the amoeba is a cross of tentacles, at 0 they rise and fall so the holes open and close by turns, at 1 all three stand wide open.\n// Knob 4: Phase. The arguments of the coefficients: at 0 they are real with Harnack's signs (-1)^(ij), and the amoeba covers the most it can (Mikhalkin and Rullgard: a simple Harnack curve's amoeba has the largest area); turned up they spread round the circle, the body thins and the holes change size and slide.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, log, exp, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst SC = 7; // LEDs to one unit of log|z| or log|w|\nconst XC = 32, YC = 64;\nconst K = 64; // samples of arg w round each row's circle\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The Newton polygon: the hexagon (1,0) (2,1) (2,3) (1,4) (0,3) (0,1), with\n// interior points (1,1), (1,2), (1,3). f is quadratic in z, so each row\n// (fixed |w|) is solved with the quadratic formula.\nconst MON = [[0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [2, 1], [2, 2], [2, 3]];\nconst NM = MON.length;\nconst MI = MON.map((m) => m[0]), MJ = MON.map((m) => m[1]);\nconst INNER = [4, 5, 6];\nconst ALPHA = 1.4, BETA = 1.4;\n\nexport function setup(params) {\n  const cs = new Float64Array((K + 1) * 5 * 2);\n  for (let k = 0; k \u003c= K; k++)\n    for (let j = 0; j \u003c 5; j++) {\n      cs[(k * 5 + j) * 2] = cos((2 * PI * k * j) / K);\n      cs[(k * 5 + j) * 2 + 1] = sin((2 * PI * k * j) / K);\n    }\n  const seed = MON.map((m, k) => (k * 0.618034 + 0.31) % 1);\n  params.s = {\n    cs, seed, t: 0, hue: 0, lift: 0, phase: 0, started: false,\n    v: new Float64Array(NM), ph: new Float64Array(NM),\n    cov: new Float32Array(N), F: new Float32Array(N * 3), h: 1,\n  };\n}\n\n// The coefficients at tide time t: |c| = exp(h v) and arg c. The valuations v\n// are a concave lift of the hexagon's points, so every point stands on the\n// upper hull and the tropical curve is a ladder of three cells; the inner\n// points' lifts wander, the outer ones drift a little.\nfunction coefficients(S) {\n  const t = S.t;\n  // The tide of t: with c = t^v the amoeba drawn at scale 1 / log t shrinks\n  // onto the tropical curve as t grows (Mikhalkin). h = log t swings between\n  // 0.64 and 3.9; the panel opens near the fattest and thins for ten seconds.\n  S.h = exp(0.45 + 0.9 * sin((2 * PI * (t - 5)) / 22));\n  for (let m = 0; m \u003c NM; m++) {\n    const [i, j] = MON[m];\n    const r = S.seed[m];\n    let v = -(ALPHA * (i - 1) * (i - 1) + BETA * (j - 2) * (j - 2));\n    // The middle point has the most neighbours pressing on its hole, so it\n    // stands a little higher.\n    if (INNER.includes(m)) v += (S.lift \u003c 0 ? 1.9 : 1.2) * S.lift + 0.45 * sin(t * (0.21 + 0.05 * (m - 5)) + 1.3 + 2.1 * (m - 4)) - 0.1 + (m === 5 ? 0.35 : 0);\n    else v += 0.35 * sin(t * (0.11 + 0.07 * r) + 6.28 * r);\n    S.v[m] = v;\n    // Harnack's signs, (-1)^(ij), and the Phase knob spreading the\n    // arguments away from them.\n    S.ph[m] = ((i * j) & 1 ? PI : 0) + S.phase * (PI * (2 * r - 1) * 1.6 + 0.25 * sin(t * 0.13 + 9 * r));\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.hue = k[0];\n  S.lift = cl(k[2], -1, 1);\n  S.phase = cl(k[3], 0, 1);\n  S.t += (dt * cl(k[1], 0.05, 3)) / 2;\n}\n\n// One row: |w| = exp(h Y). For each sample of arg w, the two roots z of\n// A(w) + B(w) z + C(w) z^2 = 0, sorted by |z|. Each of the lower and upper\n// root is continuous round the circle, so each sweeps one interval of\n// x = log|z| / h, and the two intervals together are the row of the amoeba.\n// Where the roots swap round the circle the two intervals overlap, and their\n// union is still exact.\nfunction row(S, y, cov) {\n  const h = S.h, Y = (YC - y - 0.5) / SC;\n  let top = -1e9;\n  for (let m = 0; m \u003c NM; m++) top = max(top, S.v[m] + MJ[m] * Y);\n  const pr = S.pr, pi = S.pi;\n  for (let m = 0; m \u003c NM; m++) {\n    const a = exp(h * (S.v[m] + MJ[m] * Y - top));\n    pr[m] = a * cos(S.ph[m]);\n    pi[m] = a * sin(S.ph[m]);\n  }\n  const cs = S.cs;\n  // Squared moduli of the lower and upper root, their least and greatest.\n  let loA = Infinity, loB = 0, hiA = Infinity, hiB = 0;\n  const o = y * W;\n  for (let x = 0; x \u003c W; x++) cov[o + x] = 0;\n  // A(w), B(w), C(w): the coefficients of z^0, z^1, z^2, by powers of w.\n  const A1r = pr[0], A1i = pi[0], A2r = pr[1], A2i = pi[1], A3r = pr[2], A3i = pi[2];\n  const B0r = pr[3], B0i = pi[3], B1r = pr[4], B1i = pi[4], B2r = pr[5], B2i = pi[5], B3r = pr[6], B3i = pi[6], B4r = pr[7], B4i = pi[7];\n  const C1r = pr[8], C1i = pi[8], C2r = pr[9], C2i = pi[9], C3r = pr[10], C3i = pi[10];\n  for (let k = 0; k \u003c= K; k++) {\n    const c0 = k * 10;\n    const e1r = cs[c0 + 2], e1i = cs[c0 + 3], e2r = cs[c0 + 4], e2i = cs[c0 + 5];\n    const e3r = cs[c0 + 6], e3i = cs[c0 + 7], e4r = cs[c0 + 8], e4i = cs[c0 + 9];\n    const ar = A1r * e1r - A1i * e1i + A2r * e2r - A2i * e2i + A3r * e3r - A3i * e3i;\n    const ai = A1r * e1i + A1i * e1r + A2r * e2i + A2i * e2r + A3r * e3i + A3i * e3r;\n    const br = B0r + B1r * e1r - B1i * e1i + B2r * e2r - B2i * e2i + B3r * e3r - B3i * e3i + B4r * e4r - B4i * e4i;\n    const bi = B0i + B1r * e1i + B1i * e1r + B2r * e2i + B2i * e2r + B3r * e3i + B3i * e3r + B4r * e4i + B4i * e4r;\n    const cr = C1r * e1r - C1i * e1i + C2r * e2r - C2i * e2i + C3r * e3r - C3i * e3i;\n    const ci = C1r * e1i + C1i * e1r + C2r * e2i + C2i * e2r + C3r * e3i + C3i * e3r;\n    // Discriminant D = B^2 - 4AC and the root of larger modulus,\n    // q = -(B + sqrt D) / 2 with the sign that keeps B and sqrt D from\n    // cancelling: |q|^2 = (|B|^2 + |D| + 2 |Re(conj(B) sqrt D)|) / 4, and\n    // |Re(conj(B) sqrt D)|^2 = (|B|^2 |D| + Re(conj(B)^2 D)) / 2. The roots\n    // are z1 = q / C and z2 = A / q.\n    const dr = br * br - bi * bi - 4 * (ar * cr - ai * ci);\n    const di = 2 * br * bi - 4 * (ar * ci + ai * cr);\n    const dm = sqrt(dr * dr + di * di);\n    const b2 = br * br + bi * bi;\n    const q2 = (b2 + dm + 2 * sqrt(max(0, (b2 * dm + (br * br - bi * bi) * dr + 2 * br * bi * di) / 2))) / 4;\n    const r1 = q2 / (cr * cr + ci * ci), r2 = (ar * ar + ai * ai) / q2;\n    const lo = r1 \u003c r2 ? r1 : r2, hi = r1 \u003c r2 ? r2 : r1;\n    if (lo \u003c loA) loA = lo;\n    if (lo > loB) loB = lo;\n    if (hi \u003c hiA) hiA = hi;\n    if (hi > hiB) hiB = hi;\n  }\n  // To LEDs: x = log|z| / h.\n  const px = (r) => cl(XC + (log(r) / (2 * h)) * SC, -4, W + 4);\n  let a1 = px(loA), b1 = px(loB), a2 = px(hiA), b2 = px(hiB);\n  // The union of the two intervals, as coverage of each LED.\n  if (a2 \u003c= b1) (b1 = max(b1, b2)), (a2 = 1e9);\n  span(cov, o, a1, b1);\n  if (a2 \u003c 1e8) span(cov, o, a2, b2);\n}\n\n// Coverage of [a, b] on a row.\nfunction span(cov, o, a, b) {\n  a = max(a, 0);\n  b = min(b, W);\n  for (let x = floor(a); x \u003c b; x++) cov[o + x] = min(1, cov[o + x] + min(b, x + 1) - max(a, x));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.pr) {\n    S.pr = new Float64Array(NM);\n    S.pi = new Float64Array(NM);\n  }\n  coefficients(S);\n  const { cov, F, v } = S;\n  for (let y = 0; y \u003c H; y++) row(S, y, cov);\n  // The body's colour follows the edge of the Newton polygon its piece is\n  // dual to: ladder sides, rungs and side tentacles, and the two diagonals.\n  const tone = [0, 1, 2, 3].map((d) => hsv(0.42 + S.hue + 0.06 * d, 0.6 - 0.06 * d, 1));\n  const hole = hsv(0.8 + S.hue, 0.6, 72);\n  const line = [255, 228, 176];\n  const blend = S.started ? 0.5 : 1;\n  S.started = true;\n  const gb = new Float64Array(3), gs = new Float64Array(3), gm = new Int32Array(3), gn = new Int32Array(3);\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    const Y = (YC - y - 0.5) / SC;\n    // Along a row only i X changes, so each power of z keeps its best and\n    // second-best monomial for the whole row.\n    gb.fill(-1e9);\n    gs.fill(-1e9);\n    for (let m = 0; m \u003c NM; m++) {\n      const i = MI[m], val = v[m] + MJ[m] * Y;\n      if (val > gb[i]) (gs[i] = gb[i]), (gn[i] = gm[i]), (gb[i] = val), (gm[i] = m);\n      else if (val > gs[i]) (gs[i] = val), (gn[i] = m);\n    }\n    for (let x = 0; x \u003c W; x++, p++) {\n      const X = (x + 0.5 - XC) / SC;\n      // The tropical polynomial max(v + iX + jY): the winning monomial, the\n      // runner-up, and the winner's lead as distance to the tropical curve.\n      let w = 0;\n      for (let i = 1; i \u003c 3; i++) if (gb[i] + i * X > gb[w] + w * X) w = i;\n      const b1 = gb[w] + w * X, m1 = gm[w];\n      let b2 = gs[w] + w * X, m2 = gn[w];\n      for (let i = 0; i \u003c 3; i++)\n        if (i !== w && gb[i] + i * X > b2) (b2 = gb[i] + i * X), (m2 = gm[i]);\n      const di = MI[m1] - MI[m2], dj = MJ[m1] - MJ[m2];\n      const dist = ((b1 - b2) * SC) / sqrt(di * di + dj * dj);\n      const c = cov[p];\n      // Outside the amoeba: night, and the holes, where an inner monomial\n      // wins, a deep violet.\n      let r = 6, g = 9, b = 16;\n      if (m1 >= 4 && m1 \u003c= 6) (r = hole[0]), (g = hole[1]), (b = hole[2]);\n      if (c > 0) {\n        const t = tone[di === 0 ? 1 : dj === 0 ? 0 : di * dj > 0 ? 2 : 3];\n        const lv = 205 + 50 * max(0, 1 - dist * dist * 0.04);\n        r += (t[0] * lv - r) * c;\n        g += (t[1] * lv - g) * c;\n        b += (t[2] * lv - b) * c;\n      }\n      if (dist \u003c 0.8) {\n        const a = 0.5 * (1 - dist / 0.8);\n        r += (line[0] - r) * a;\n        g += (line[1] - g) * a;\n        b += (line[2] - b) * a;\n      }\n      const q = p * 3;\n      F[q] += (r - F[q]) * blend;\n      F[q + 1] += (g - F[q + 1]) * blend;\n      F[q + 2] += (b - F[q + 2]) * blend;\n      display.setPixel(x, y, F[q], F[q + 1], F[q + 2]);\n    }\n  }\n}\n","rivers-of-white":"// ===== Patternflow pattern =====\n// Title:   Rivers of White\n// Family:  type\n// Idea:    The opening paragraph of A Tale of Two Cities is set justified in a 3 by 5 pixel face down the whole panel, and wherever the stretched word spaces of successive lines line up into rivers of white the paragraph lights them, so the typesetter's flaw glows and meanders while the column narrows and widens and the rivers break and re-form.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after the rivers of white that justified type has always made, with total-fit line breaking (Donald Knuth and Michael Plass, 1981), setting Charles Dickens's A Tale of Two Cities (1859)\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fit=0..1, Space=0..1\n//\n// Knob 1: Hue. The colour of the light in the rivers: ice blue at 0, violet at 0.25, peach at 0.5, green at 0.75 and ice blue again at 1; the type stays warm.\n// Knob 2: Speed. How fast the column breathes between 64 and 54 LEDs wide and the light runs down the rivers: at 2 one breath takes 10 s, at 0.2 it takes 100 s.\n// Knob 3: Fit. How the lines are broken: at 0 greedily, as many words as fit on each line in turn, the way a word processor does; from 0.02 to 0.15 by Knuth and Plass's total fit, the breaks that make the whole paragraph's spacing least bad; and turned further each column a word space shares with the space on the line above costs more, until at 1 the breaks steer the spaces apart and the rivers mostly dry up.\n// Knob 4: Space. The natural word space: 3 LEDs at the opening, 4, 5 and 6 as it turns. Wider spaces line up more easily, and at 6 the rivers braid through the whole page.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The 3 by 5 face, rows top to bottom; punctuation is one LED wide.\nconst GLYPHS = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\", \"-\": \"000000111000000\",\n  \".\": \"00001\", \",\": \"00011\", \";\": \"01011\", \":\": \"01010\", \"'\": \"11000\", \"!\": \"11101\",\n};\n\n// Charles Dickens, A Tale of Two Cities (1859), the first paragraph. The dash\n// before IN SHORT is set close, as the book sets it.\nconst TEXT =\n  \"IT WAS THE BEST OF TIMES, IT WAS THE WORST OF TIMES, IT WAS THE AGE OF WISDOM, IT WAS THE AGE OF FOOLISHNESS, \" +\n  \"IT WAS THE EPOCH OF BELIEF, IT WAS THE EPOCH OF INCREDULITY, IT WAS THE SEASON OF LIGHT, IT WAS THE SEASON OF DARKNESS, \" +\n  \"IT WAS THE SPRING OF HOPE, IT WAS THE WINTER OF DESPAIR, WE HAD EVERYTHING BEFORE US, WE HAD NOTHING BEFORE US, \" +\n  \"WE WERE ALL GOING DIRECT TO HEAVEN, WE WERE ALL GOING DIRECT THE OTHER WAY-IN SHORT, THE PERIOD WAS SO FAR LIKE \" +\n  \"THE PRESENT PERIOD, THAT SOME OF ITS NOISIEST AUTHORITIES INSISTED ON ITS BEING RECEIVED, FOR GOOD OR FOR EVIL, \" +\n  \"IN THE SUPERLATIVE DEGREE OF COMPARISON ONLY.\";\n\n// A line is 5 rows of type and 1 of leading; 21 lines fill rows 1 to 126.\nconst LH = 6, TOP = 1, LINES = 21;\n// The narrowest column still holds FOOLISHNESS, and INCREDULITY, at 45 LEDs.\nconst MIN_M = 46;\n\n// Each word as a list of column masks, one bit per row, with a blank column\n// between letters.\nfunction shapeWords() {\n  return TEXT.split(\" \").map((w) => {\n    const cols = [];\n    for (const ch of w) {\n      const g = GLYPHS[ch];\n      const gw = g.length / 5;\n      if (cols.length) cols.push(0);\n      for (let i = 0; i \u003c gw; i++) {\n        let m = 0;\n        for (let j = 0; j \u003c 5; j++) if (g[j * gw + i] === \"1\") m |= 1 \u003c\u003c j;\n        cols.push(m);\n      }\n    }\n    return cols;\n  });\n}\n\nexport function setup(params) {\n  const P = params;\n  P.words = shapeWords();\n  P.wl = P.words.map((c) => c.length);\n  P.n = P.words.length;\n  P.cache = new Map();\n  P.phase = 0;\n  P.flow = 0;\n  P.key = \"\";\n  P.ink = new Uint8Array(N); // type\n  P.target = new Float32Array(N); // river light wanted now\n  P.light = new Float32Array(N); // river light shown, easing toward it\n  P.halo = new Float32Array(N);\n  P.tmp = new Float32Array(N);\n  P.started = false;\n}\n\n// ---- Line breaking -------------------------------------------------------\n\n// A line of words a..b-1 at measure M with natural space S: its words' width,\n// gap count and slack against natural spacing; null if it cannot fit even at\n// the tightest space S - 1 (a single word always fits, overhanging if it must).\nfunction lineOf(P, a, b, M, S) {\n  let w = 0;\n  for (let i = a; i \u003c b; i++) w += P.wl[i];\n  const g = b - a - 1;\n  if (g > 0 && w + (S - 1) * g > M) return null;\n  return { w, g, slack: M - w - S * g };\n}\n\n// How bad a line is: the square of how far each space is stretched or shrunk\n// from natural, in LEDs; shrinking counts eight times; a lone word on a\n// justified line pays a great deal; the last line is set ragged and is free.\nfunction badness(L, last) {\n  if (last) return L.slack >= 0 ? 0 : 1e6;\n  if (L.g === 0) return 60 + L.slack * L.slack;\n  const r = L.slack / L.g;\n  return r >= 0 ? r * r : 8 * r * r;\n}\n\n// The word spaces of a justified line as inclusive column ranges, the stretch\n// spread from left to right as evenly as whole LEDs allow.\nfunction gapsOf(P, a, b, M, S, x0, last) {\n  const L = lineOf(P, a, b, M, S) || { w: 0, g: b - a - 1, slack: 0 };\n  const out = [];\n  const extra = last || L.g === 0 ? 0 : L.slack;\n  let x = x0;\n  for (let i = a, k = 0; i \u003c b - 1; i++, k++) {\n    x += P.wl[i];\n    const s = S + floor((extra * (k + 1)) / L.g) - floor((extra * k) / L.g);\n    out.push(x, x + s - 1);\n    x += s;\n  }\n  return out;\n}\n\n// Columns shared between the spaces of two lines.\nfunction overlap(A, B) {\n  let s = 0;\n  for (let i = 0; i \u003c A.length; i += 2)\n    for (let j = 0; j \u003c B.length; j += 2) {\n      const o = min(A[i + 1], B[j + 1]) - max(A[i], B[j]) + 1;\n      if (o > 0) s += o;\n    }\n  return s;\n}\n\n// Greedy: as many words as fit at natural spacing, line after line.\nfunction greedy(P, M, S) {\n  const br = [0];\n  for (let a = 0; a \u003c P.n; ) {\n    let b = a + 1;\n    while (b \u003c P.n) {\n      const L = lineOf(P, a, b + 1, M, S);\n      if (!L || L.slack \u003c 0) break;\n      b++;\n    }\n    br.push(b);\n    a = b;\n  }\n  return br;\n}\n\n// Total fit with a river toll: the breaks of least total badness, plus mu for\n// every column a line's spaces share with the spaces of the line above. The\n// toll needs the line above, so a state is the pair (start of the line above,\n// start of this line); with mu = 0 it is Knuth and Plass's total fit.\nfunction totalFit(P, M, S, mu, x0) {\n  const n = P.n;\n  const ends = [];\n  for (let a = 0; a \u003c n; a++) {\n    const l = [];\n    for (let b = a + 1; b \u003c= n; b++) {\n      if (!lineOf(P, a, b, M, S)) break;\n      l.push(b);\n    }\n    ends.push(l);\n  }\n  const gaps = new Map();\n  const gp = (a, b) => {\n    const k = a * 512 + b;\n    let v = gaps.get(k);\n    if (!v) gaps.set(k, (v = gapsOf(P, a, b, M, S, x0, b === n)));\n    return v;\n  };\n  // cost[a] maps the start of the line above to the best cost of setting\n  // words 0..a-1 with that line last.\n  const cost = [], back = [];\n  for (let a = 0; a \u003c= n; a++) {\n    cost.push(new Map());\n    back.push(new Map());\n  }\n  cost[0].set(-1, 0);\n  for (let a = 0; a \u003c n; a++) {\n    for (const [p, c0] of cost[a]) {\n      const above = p >= 0 ? gp(p, a) : null;\n      for (const b of ends[a]) {\n        const L = lineOf(P, a, b, M, S);\n        let c = c0 + badness(L, b === n);\n        if (above && mu > 0) c += mu * overlap(above, gp(a, b));\n        const was = cost[b].get(a);\n        if (was === undefined || c \u003c was) {\n          cost[b].set(a, c);\n          back[b].set(a, p);\n        }\n      }\n    }\n  }\n  let best = Infinity, last = -1;\n  for (const [p, c] of cost[n]) if (c \u003c best) (best = c), (last = p);\n  const br = [n];\n  for (let b = n, a = last; a >= 0; ) {\n    br.push(a);\n    const p = back[b].get(a);\n    b = a;\n    a = p;\n  }\n  return br.reverse();\n}\n\n// The page for a measure: every visible line's words as [x, word] pairs and\n// its spaces, cached because the column passes the same widths again.\nfunction layout(P, M) {\n  const key = M + \"/\" + P.S + \"/\" + P.mu.toFixed(3);\n  let L = P.cache.get(key);\n  if (L) return L;\n  const x0 = floor((W - M) / 2);\n  const br = P.mu \u003c 0 ? greedy(P, M, P.S) : totalFit(P, M, P.S, P.mu, x0);\n  const lines = [];\n  for (let i = 0; i + 1 \u003c br.length && i \u003c LINES; i++) {\n    const a = br[i], b = br[i + 1], last = b === P.n;\n    const gaps = gapsOf(P, a, b, M, P.S, x0, last);\n    const xs = [x0];\n    for (let k = 0; k \u003c gaps.length; k += 2) xs.push(gaps[k + 1] + 1);\n    lines.push({ a, b, xs, gaps });\n  }\n  // Rivers: a space joins a space on the next line when they share a column;\n  // each space carries the most lines any chain through it spans.\n  const down = lines.map((l) => new Array(l.gaps.length / 2).fill(1));\n  const up = lines.map((l) => new Array(l.gaps.length / 2).fill(1));\n  const touch = (A, i, B, j) => max(A[i], B[j]) \u003c= min(A[i + 1], B[j + 1]);\n  for (let i = lines.length - 2; i >= 0; i--)\n    for (let k = 0; k \u003c down[i].length; k++)\n      for (let m = 0; m \u003c down[i + 1].length; m++)\n        if (touch(lines[i].gaps, 2 * k, lines[i + 1].gaps, 2 * m)) down[i][k] = max(down[i][k], 1 + down[i + 1][m]);\n  for (let i = 1; i \u003c lines.length; i++)\n    for (let k = 0; k \u003c up[i].length; k++)\n      for (let m = 0; m \u003c up[i - 1].length; m++)\n        if (touch(lines[i].gaps, 2 * k, lines[i - 1].gaps, 2 * m)) up[i][k] = max(up[i][k], 1 + up[i - 1][m]);\n  for (let i = 0; i \u003c lines.length; i++) lines[i].run = down[i].map((d, k) => d + up[i][k] - 1);\n  L = { lines, x0, M };\n  if (P.cache.size > 400) P.cache.clear();\n  P.cache.set(key, L);\n  return L;\n}\n\n// How brightly a space glows for the lines its river spans: two lines are a\n// coincidence, three a river, six a flood.\nconst glowOf = (run) => (run \u003c 2 ? 0 : run === 2 ? 0.16 : min(1, 0.4 + 0.15 * (run - 3)));\n\nfunction paint(P, L) {\n  const { ink, target } = P;\n  ink.fill(0);\n  target.fill(0);\n  L.lines.forEach((ln, i) => {\n    const y0 = TOP + i * LH;\n    // Type.\n    for (let k = ln.a; k \u003c ln.b; k++) {\n      const cols = P.words[k], x = ln.xs[k - ln.a];\n      for (let c = 0; c \u003c cols.length; c++) {\n        const X = x + c;\n        if (X \u003c 0 || X >= W || !cols[c]) continue;\n        for (let j = 0; j \u003c 5; j++) if (cols[c] & (1 \u003c\u003c j)) ink[(y0 + j) * W + X] = 1;\n      }\n    }\n    // The spaces of rivers: a space is lit dimly across its width and fully in\n    // the columns it shares with the spaces above and below, the channel the\n    // river runs down; the leading is lit where it steps to the next line.\n    const prev = L.lines[i - 1], next = L.lines[i + 1];\n    for (let k = 0; k \u003c ln.run.length; k++) {\n      const v = glowOf(ln.run[k]);\n      if (!v) continue;\n      const g0 = ln.gaps[2 * k], g1 = ln.gaps[2 * k + 1];\n      for (let y = y0; y \u003c y0 + 5; y++) for (let x = g0; x \u003c= g1; x++) target[y * W + x] = max(target[y * W + x], 0.28 * v);\n      for (const [nb, dy] of [[prev, -1], [next, 5]]) {\n        if (!nb) continue;\n        for (let m = 0; m \u003c nb.run.length; m++) {\n          const a = max(g0, nb.gaps[2 * m]), b = min(g1, nb.gaps[2 * m + 1]);\n          if (a > b) continue;\n          const w = min(v, glowOf(nb.run[m]));\n          for (let x = a; x \u003c= b; x++) {\n            for (let y = y0; y \u003c y0 + 5; y++) target[y * W + x] = max(target[y * W + x], w);\n            if (dy > 0) target[(y0 + dy) * W + x] = max(target[(y0 + dy) * W + x], w);\n          }\n        }\n      }\n    }\n  });\n}\n\nexport function update(dt, input, params) {\n  const P = params;\n  if (!P.words) setup(P);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  P.hue = k[0] || 0;\n  P.speed = cl(k[1], 0.2, 3);\n  const fit = cl(k[2], 0, 1);\n  // Greedy at the very bottom, plain total fit up to 0.15, then the river toll\n  // rises to 100 per shared column at 1.\n  P.mu = fit \u003c 0.02 ? -1 : fit \u003c= 0.15 ? 0 : 100 * ((fit - 0.15) / 0.85) ** 2;\n  P.S = cl(round(3 + 3 * cl(k[3], 0, 1)), 3, 6);\n  // The column breathes from full width down to 54 LEDs and back; the\n  // opening frame is 1.4 radians into a breath (2.2 s at Speed 2), already\n  // drawing in.\n  P.phase += (dt * 2 * PI * P.speed) / 20;\n  const breath = (1 - cos(P.phase + 1.4)) / 2;\n  const M = max(MIN_M, round(64 - 10 * breath));\n  P.flow += dt * P.speed * 0.3;\n  const L = layout(P, M);\n  const key = L.M + \"/\" + P.S + \"/\" + P.mu;\n  if (key !== P.key) {\n    P.key = key;\n    P.page = L;\n    paint(P, L);\n  }\n  // River light eases in and out over a fifth of a second as rivers form and break.\n  const e = P.started ? 1 - exp(-dt / 0.2) : 1;\n  P.started = true;\n  const { light, target, halo, tmp } = P;\n  for (let p = 0; p \u003c N; p++) light[p] += (target[p] - light[p]) * e;\n  // The halo: the light spread two LEDs each way, across then down.\n  for (let y = 0; y \u003c H; y++) {\n    let s = 0;\n    const r = y * W;\n    for (let x = -2; x \u003c W; x++) {\n      if (x + 2 \u003c W) s += light[r + x + 2];\n      if (x - 3 >= 0) s -= light[r + x - 3];\n      if (x >= 0) tmp[r + x] = s / 5;\n    }\n  }\n  for (let x = 0; x \u003c W; x++) {\n    let s = 0;\n    for (let y = -2; y \u003c H; y++) {\n      if (y + 2 \u003c H) s += tmp[(y + 2) * W + x];\n      if (y - 3 >= 0) s -= tmp[(y - 3) * W + x];\n      if (y >= 0) halo[y * W + x] = s / 5;\n    }\n  }\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function draw(display, params) {\n  const P = params;\n  if (!P.page) return;\n  const c = [0, 0, 0];\n  // Ice blue at Hue 0, pale enough to read as white light.\n  hsv(P.hue + 0.56, 0.56, 1, c);\n  const [rr, rg, rb] = c;\n  const { ink, light, halo } = P;\n  const ft = P.flow;\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    // Light runs down the rivers in slow swells.\n    const wave = 0.74 + 0.26 * sin(2 * PI * (y / 30 - ft));\n    for (let x = 0; x \u003c W; x++, p++) {\n      const h = halo[p];\n      if (ink[p]) {\n        // The type, warm parchment, catching a little of the river light.\n        const g = 0.7 * h;\n        display.setPixel(x, y, round(min(255, 178 + 80 * g * rr)), round(min(255, 136 + 80 * g * rg)), round(min(255, 84 + 80 * g * rb)));\n      } else {\n        const v = light[p] * wave * 0.92 + h * 0.24;\n        display.setPixel(x, y, round(min(255, 255 * v * rr)), round(min(255, 255 * v * rg)), round(min(255, 255 * v * rb)));\n      }\n    }\n  }\n}\n","wongoji":"// ===== Patternflow pattern =====\n// Title:   Wongoji\n// Family:  type\n// Idea:    A pen writes Yun Dong-ju's Prelude (1941) in vertical lines on Korean manuscript paper, stroke by stroke in a 9 by 11 Hangul face the pattern composes from jamo, each square cell top to bottom and the columns right to left, and turns the page when the sheet is full.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after wongoji manuscript paper and the johab Hangul bitmap fonts that drew each jamo in several sets (beol) by the vowel beside it and the final under it; the poem is Yun Dong-ju's Seosi (Prelude), written 20 November 1941\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Paper=0..1, Speed=0.2..3, Brush=0..1, Hand=0..1\n//\n// Knob 1: Paper. Five sheets, each holding over most of its fifth of the knob and giving way to the next in a short cross-fade: at 0 night paper with vermilion lines and cream ink that shines gold while wet, at 0.25 hanji with red lines and brown-black ink, at 0.5 white school paper with green lines and blue-black ink, at 0.75 a blackboard ruled in chalk, at 1 blueprint.\n// Knob 2: Speed. The pen draws 34 LEDs of stroke a second per unit, and its lifts and rests shorten with it: at 2 a syllable takes about a second, a sheet about 29 seconds and the whole poem, 95 syllables on four sheets, 109 seconds with its page turns; at 3 a sheet takes 20 seconds, at 0.2 over four minutes.\n// Knob 3: Brush. At 0 a pen, every stroke one LED wide and even. Turned up, the brush presses a dot beside each stroke's start, lifts at its end and runs dry here and there, and the ink bleeds into the paper round it over a second after the pen passes, up to 42 percent of full ink at 1.\n// Knob 4: Hand. The chance that a jamo is written one LED aside, 0.6 times Hand, and one LED up or down, half that: at the opening 0.06 one jamo in 28 strays aside and one in 56 up or down, at 1 three in five aside, and the page reads as a quick hand.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs, exp, hypot, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];\n\n// The sheet: 5 columns of 10 square cells, 12 LEDs apart, so each cell has\n// 11 by 11 LEDs inside its lines; a glyph is 9 wide and 11 tall. A 9 by 9\n// face in 10-LED cells gave 72 cells a sheet, but a final ㄹ under ㅡ then\n// had 3 rows and closed into a block, in 12 of the poem's 95 syllables.\nconst X0 = 1, Y0 = 3, P = 12, NC = 5, NR = 10;\n\n// Yun Dong-ju, Seosi (Prelude), November 1941. # is the title, @ the author.\nconst POEM = [\n  \"#서시\",\n  \"@윤동주\",\n  \"죽는 날까지 하늘을 우러러\",\n  \"한 점 부끄럼이 없기를,\",\n  \"잎새에 이는 바람에도\",\n  \"나는 괴로워했다.\",\n  \"별을 노래하는 마음으로\",\n  \"모든 죽어 가는 것을 사랑해야지\",\n  \"그리고 나한테 주어진 길을\",\n  \"걸어가야겠다.\",\n  \"\",\n  \"오늘 밤에도 별이 바람에 스치운다.\",\n];\n\n// ---- The face. Jamo are strokes in writing order, each a list of points\n// in a box w by h; a syllable puts them in boxes that depend on its vowel\n// and on whether it has a final, the way the johab fonts kept several\n// forms of each jamo. Over all 11,172 syllables that gives each initial 16\n// or 17 forms, each vowel 2 or 3 and each final 1: 391 jamo pictures.\nconst INI = \"g gg n d dd r m b bb s ss o j jj c k t p h\".split(\" \");\nconst FIN = \". g gg gs n nj nh d r rg rm rb rs rt rp rh m b bs s ss o j c k t p h\".split(\" \");\n\nfunction ring(w, h, ox, oy) {\n  const rw = min(w, h + 2), rh = min(h, w + 1);\n  ox += (w - rw) >> 1;\n  oy += (h - rh) >> 1;\n  const R = rw - 1, B = rh - 1, c = R >> 1;\n  const pts = rh \u003c= 2 ? [[1, 0], [R - 1, 0], [R - 1, B], [1, B]] : [[c, 0], [1, 0], [0, 1], [0, B - 1], [1, B], [R - 1, B], [R, B - 1], [R, 1], [R - 1, 0], [c + 1, 0]];\n  return pts.map(([x, y]) => [x + ox, y + oy]);\n}\n\n// Two legs from an apex: the s shape, also under the bar of j and c.\nfunction legs(w, h, y0) {\n  const c = (w - 1) >> 1, d = h - 1 - y0;\n  const xl = max(0, round(c - 1.3 * d)), xr = min(w - 1, round(c + (w % 2 ? 0 : 1) + 1.3 * d));\n  return [[[c, y0], [xl, h - 1]], [[c, y0 + max(1, round(d / 3))], [xr, h - 1]]];\n}\n\nfunction cons(k, w, h, tail) {\n  const c = (w - 1) >> 1, m = (h - 1) >> 1, S = [];\n  switch (k) {\n    case \"g\":\n      S.push(tail && h >= 6 ? [[0, 0], [w - 1, 0], [w - 1, h - 3], [w - 3, h - 1]] : [[0, 0], [w - 1, 0], [w - 1, h - 1]]);\n      break;\n    case \"n\":\n      S.push([[0, 0], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"d\":\n      S.push([[0, 0], [w - 1, 0]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"r\":\n      if (h >= 5) S.push([[0, 0], [w - 1, 0], [w - 1, m]], [[0, m], [w - 2, m]], [[0, m + 1], [0, h - 1], [w - 1, h - 1]]);\n      else {\n        // Four rows: the middle bar breaks into a step, the way ㄹ is written fast.\n        const z = w >> 1;\n        S.push([[0, 0], [w - 1, 0], [w - 1, 1], [z, 1]], [[z, 2], [0, 2], [0, h - 1], [w - 1, h - 1]]);\n      }\n      break;\n    case \"m\":\n      S.push([[0, 0], [0, h - 1]], [[0, 0], [w - 1, 0], [w - 1, h - 1]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"b\":\n      S.push([[0, 0], [0, h - 1]], [[w - 1, 0], [w - 1, h - 1]], [[1, m], [w - 2, m]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"s\":\n      S.push(...legs(w, h, 0));\n      break;\n    case \"o\":\n      S.push(ring(w, h, 0, 0));\n      break;\n    case \"j\":\n      S.push([[0, 0], [w - 1, 0]], ...legs(w, h, 1));\n      break;\n    case \"c\":\n      S.push([[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ...legs(w, h, 2));\n      break;\n    case \"k\": {\n      const mk = (h >> 1);\n      S.push([[0, 0], [w - 1, 0], [w - 1, h - 1]], [[0, mk], [w - 2, mk]]);\n      break;\n    }\n    case \"t\":\n      S.push([[0, 0], [w - 1, 0]], [[1, m], [w - 1, m]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"p\": {\n      const a = w >= 5 ? 1 : 0;\n      S.push([[0, 0], [w - 1, 0]], [[a, 1], [a, h - 2]], [[w - 1 - a, 1], [w - 1 - a, h - 2]], [[0, h - 1], [w - 1, h - 1]]);\n      break;\n    }\n    case \"h\":\n      S.push(w >= 7 ? [[c - 1, 0], [c + 1, 0]] : [[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ring(w, h - 2, 0, 2));\n      break;\n  }\n  return S;\n}\n\n// One consonant, or a double or cluster side by side, in a box at (x, y).\nfunction group(key, x, y, w, h, tail) {\n  const parts = [...key];\n  const out = [];\n  if (parts.length === 1) {\n    for (const s of cons(parts[0], w, h, tail)) out.push(s.map(([a, b]) => [a + x, b + y]));\n    return out;\n  }\n  const w1 = (w - 1) >> 1, w2 = w - 1 - w1;\n  for (const s of cons(parts[0], w1, h, false)) out.push(s.map(([a, b]) => [a + x, b + y]));\n  for (const s of cons(parts[1], w2, h, false)) out.push(s.map(([a, b]) => [a + x + w1 + 1, b + y]));\n  return out;\n}\n\n// Vowels. Vertical ones: the initial's width, then lines [0, x] and ticks\n// [1, x0, x1, slot] (slot 0 the middle, 1 above it, 2 below it, 3 the row\n// under a horizontal bar). Horizontal ones: ticks above [2, x], bars\n// [3, x0, x1], stems below [4, x].\nconst VV = {\n  0: [5, [0, 6], [1, 7, 8, 0]],\n  1: [5, [0, 6], [1, 7, 7, 0], [0, 8]],\n  2: [5, [0, 6], [1, 7, 8, 1], [1, 7, 8, 2]],\n  3: [5, [0, 6], [1, 7, 7, 1], [1, 7, 7, 2], [0, 8]],\n  4: [5, [1, 6, 7, 0], [0, 8]],\n  5: [4, [1, 5, 5, 0], [0, 6], [0, 8]],\n  6: [5, [1, 6, 7, 1], [1, 6, 7, 2], [0, 8]],\n  7: [4, [1, 5, 5, 1], [1, 5, 5, 2], [0, 6], [0, 8]],\n  20: [6, [0, 7]],\n};\nconst HV = { 8: [[2, 4], [3, 0, 8]], 12: [[2, 2], [2, 6], [3, 0, 8]], 13: [[3, 0, 8], [4, 4]], 17: [[3, 0, 8], [4, 2], [4, 6]], 18: [[3, 0, 8]] };\nconst MV = {\n  9: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 8, 0]]],\n  10: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 7, 0], [0, 8]]],\n  11: [6, [[2, 2], [3, 0, 5]], [[0, 7]]],\n  14: [5, [[3, 0, 4], [4, 2]], [[1, 5, 6, 3], [0, 8]]],\n  15: [4, [[3, 0, 3], [4, 2]], [[1, 5, 5, 3], [0, 6], [0, 8]]],\n  16: [6, [[3, 0, 5], [4, 3]], [[0, 7]]],\n  19: [6, [[3, 0, 5]], [[0, 7]]],\n};\n// Initials whose bottom row is clear in the middle, so the tick of ㅗ may sit\n// right under them; and initials that need four rows to read.\nconst FREE = new Set([\"g\", \"gg\", \"s\", \"ss\", \"j\", \"jj\", \"c\", \"k\"]);\nconst NEED4 = new Set([\"r\", \"b\", \"bb\", \"c\", \"k\", \"t\", \"h\"]);\n\nfunction vparts(parts, y0, y1, bar, out) {\n  const mid = (y0 + y1) >> 1;\n  for (const p of parts) {\n    if (p[0] === 0) out.push([[p[1], y0], [p[1], y1]]);\n    else {\n      const y = p[3] === 0 ? mid : p[3] === 1 ? mid - 1 : p[3] === 2 ? mid + 1 : bar + 1;\n      out.push([[p[1], y], [p[2], y]]);\n    }\n  }\n}\nfunction hparts(parts, bar, stem, out) {\n  for (const p of parts) {\n    if (p[0] === 2) out.push([[p[1], bar - 1], [p[1], bar - 1]]);\n    else if (p[0] === 3) out.push([[p[1], bar], [p[2], bar]]);\n    else out.push([[p[1], bar + 1], [p[1], bar + stem]]);\n  }\n}\n\n// The strokes of one syllable in a 9 by 11 box, each jamo moved by its own\n// offset for the Hand knob.\nfunction syllable(code, off) {\n  const s = code - 0xac00;\n  const ci = floor(s / 588), vi = floor((s % 588) / 28), fi = s % 28;\n  const ini = INI[ci], has = fi > 0, out = [], vow = [];\n  let box, fbox = FIN[fi].length > 1 ? [0, 7, 9, 4] : [1, 7, 7, 4];\n  if (VV[vi]) {\n    const [iw, ...parts] = VV[vi];\n    box = has ? [0, 0, iw, 5] : [0, 2, iw, 7];\n    vparts(parts, has ? 0 : 1, has ? 5 : 9, 0, vow);\n  } else if (HV[vi]) {\n    const up = vi === 8 || vi === 12, down = vi === 13 || vi === 17;\n    let bar = 7;\n    if (!has) {\n      box = [1, 1, 7, 5];\n      if (up) bar = 8;\n    } else if (up) {\n      box = FREE.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = 5;\n    } else if (down) {\n      box = NEED4.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = box[3] + 1;\n    } else {\n      box = [1, 0, 7, 4];\n      bar = 5;\n    }\n    hparts(HV[vi], bar, has ? 1 : 2, vow);\n  } else {\n    const [iw, hp, vp] = MV[vi];\n    const up = hp[0][0] === 2, flat = hp.length === 1;\n    let bar;\n    if (!has) {\n      box = [0, 1, iw, flat ? 5 : 4];\n      bar = up || flat ? 7 : 6;\n    } else {\n      box = [0, 0, iw, flat ? 4 : 3];\n      bar = up || flat ? 5 : 4;\n    }\n    hparts(hp, bar, has ? 1 : 2, vow);\n    vparts(vp, has ? 0 : 1, has ? 5 : 9, bar, vow);\n  }\n  const tail = !has && VV[vi] && (ini === \"g\" || ini === \"k\");\n  const mv = (list, o) => list.map((st) => st.map(([x, y]) => [x + o[0], y + o[1]]));\n  out.push(...mv(group(ini, box[0], box[1], box[2], box[3], tail), off[0]));\n  out.push(...mv(vow, off[1]));\n  if (has) out.push(...mv(group(FIN[fi], fbox[0], fbox[1], fbox[2], fbox[3], false), off[2]));\n  return out;\n}\n\n// Marks: in vertical writing the comma and the full stop sit high on the right.\nconst MARKS = { \",\": [[[5, 1], [7, 3]]], \".\": [[[6, 0], [5, 1], [6, 2], [7, 1], [6, 0]]] };\n\nfunction strokesOf(ch, off) {\n  const code = ch.codePointAt(0);\n  if (code >= 0xac00 && code \u003c= 0xd7a3) return syllable(code, off);\n  return MARKS[ch] ? MARKS[ch].map((s) => s.map(([x, y]) => [x + off[0][0], y + off[0][1]])) : [];\n}\n\n// Points to pixels, in drawing order.\nfunction raster(stroke) {\n  const px = [];\n  for (let i = 0; i \u003c stroke.length; i++) {\n    const [x0, y0] = stroke[i], [x1, y1] = stroke[min(i + 1, stroke.length - 1)];\n    const n = max(abs(x1 - x0), abs(y1 - y0));\n    for (let j = 0; j \u003c= n; j++) {\n      const x = round(x0 + ((x1 - x0) * j) / (n || 1)), y = round(y0 + ((y1 - y0) * j) / (n || 1));\n      const l = px[px.length - 1];\n      if (!l || l[0] !== x || l[1] !== y) px.push([x, y]);\n    }\n  }\n  return px;\n}\n\n// ---- The manuscript: columns of 10 cells, a new column for every line, a\n// wrapped line going on one cell down, the title in the middle of its\n// column and the author's name ending one cell from the foot of the next.\nfunction layout() {\n  const cols = [];\n  const blank = () => new Array(NR).fill(null);\n  for (const line of POEM) {\n    const col = blank();\n    if (line[0] === \"#\" || line[0] === \"@\") {\n      const t = [...line.slice(1)];\n      const s = line[0] === \"#\" ? (NR - t.length) >> 1 : NR - 1 - t.length;\n      t.forEach((ch, i) => (col[s + i] = ch));\n      cols.push(col);\n      continue;\n    }\n    let cur = col, r = 0;\n    for (const word of line.split(\" \").filter(Boolean)) {\n      const chs = [...word];\n      if (r > 0 && r + 1 + chs.length > NR) {\n        cols.push(cur);\n        cur = blank();\n        r = 1;\n      } else if (r > 0) r++;\n      for (const ch of chs) cur[r++] = ch;\n    }\n    cols.push(cur);\n  }\n  const cells = [];\n  cols.forEach((col, ci) => col.forEach((ch, r) => ch && cells.push({ page: floor(ci / NC), col: ci % NC, row: r, ch, rnd: [0, 1, 2, 3, 4, 5].map(() => Math.random()) })));\n  return { cells, pages: Math.ceil(cols.length / NC) };\n}\n\nconst cellX = (c) => X0 + P * (NC - 1 - c) + 2;\nconst cellY = (r) => Y0 + P * r + 1;\n\n// Paper, grid, ink, fresh ink and the pen, for the Paper knob: night paper\n// with vermilion lines, hanji with red, school paper with green, a\n// blackboard with chalk, and blueprint.\nconst SETS = [\n  [[3, 4, 10], [196, 58, 40], [236, 230, 212], [255, 214, 140], [255, 196, 96]],\n  [[232, 218, 186], [206, 64, 46], [26, 20, 16], [96, 36, 26], [150, 30, 20]],\n  [[224, 232, 220], [46, 148, 92], [24, 36, 124], [70, 110, 230], [40, 70, 220]],\n  [[14, 44, 30], [150, 190, 120], [236, 240, 226], [255, 250, 190], [255, 255, 255]],\n  [[8, 20, 56], [72, 146, 210], [226, 236, 255], [150, 220, 255], [255, 255, 255]],\n];\n\nexport function setup(params) {\n  const S = (params.s = { ...layout(), started: false, t: 0 });\n  S.ink = new Float32Array(N);\n  S.when = new Float32Array(N);\n  S.halo = new Float32Array(N);\n  S.glow = new Float32Array(N);\n  S.leaf = new Float32Array(N);\n  S.grid = new Float32Array(N);\n  for (let y = Y0; y \u003c= Y0 + P * NR; y++)\n    for (let x = X0; x \u003c= X0 + P * NC; x++) {\n      const vx = (x - X0) % P === 0, hy = (y - Y0) % P === 0;\n      if (!vx && !hy) continue;\n      const edge = x === X0 || x === X0 + P * NC || y === Y0 || y === Y0 + P * NR;\n      S.grid[y * W + x] = edge ? 1 : 0.5;\n    }\n  S.F = new Float32Array(N * 3);\n}\n\n// Ink one LED, light the paper round it for a moment, and with the Brush up\n// let the ink bleed into its four neighbours.\nfunction inkAt(S, x, y, a, t) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  if (a > S.ink[p]) S.ink[p] = a;\n  S.when[p] = t;\n  for (let dy = -1; dy \u003c= 1; dy++)\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const xx = x + dx, yy = y + dy;\n      if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) S.glow[yy * W + xx] = t;\n    }\n  const b = S.brush;\n  if (b > 0)\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n      const q = p + dy * W + dx, xx = x + dx;\n      if (xx \u003c 0 || xx >= W || q \u003c 0 || q >= N) continue;\n      const v = 0.42 * b * a;\n      if (v > S.halo[q]) S.halo[q] = v;\n    }\n}\n\nfunction prepare(S, cell) {\n  // The hand: each jamo steps one LED aside with a chance of 0.6 Hand, and\n  // one LED up or down with half that.\n  const o = (i, k) => {\n    const r = cell.rnd[i] * 2 - 1;\n    return abs(r) > 1 - 0.6 * k * S.hand ? Math.sign(r) : 0;\n  };\n  const off = [[o(0, 1), o(1, 0.5)], [o(2, 1), o(3, 0.5)], [o(4, 1), o(5, 0.5)]];\n  const x = cellX(cell.col), y = cellY(cell.row);\n  cell.px = strokesOf(cell.ch, off).map((st) => raster(st).map(([a, b]) => [a + x, b + y]));\n}\n\n// A stroke's LEDs from `from` up to `upto`. With the Brush up it presses a\n// dot beside the stroke's start, lifts at its end and runs dry here and there.\nfunction inkStroke(S, st, upto, from, t) {\n  const b = S.brush, n = st.length;\n  for (let i = from; i \u003c upto; i++) {\n    const [x, y] = st[i];\n    let a = 1;\n    if (b > 0) {\n      if (i === n - 1 && n > 2) a = 1 - 0.35 * b;\n      else if (i > 0) a = 1 - 0.3 * b * Math.random();\n    }\n    inkAt(S, x, y, a, t);\n    if (i === 0 && b > 0.05) inkAt(S, x - 1, y, 0.55 * b, t);\n  }\n}\n\nfunction startPage(S, page) {\n  S.page = page;\n  S.ink.fill(0);\n  S.halo.fill(0);\n  S.when.fill(-99);\n  S.glow.fill(-99);\n}\n\n// The pen: writes, lifts between strokes, rests between cells, and at the\n// foot of a page waits, then the page turns.\nfunction step(S, dt) {\n  S.t += dt;\n  const v = 34 * S.speed, q = 2 / S.speed;\n  let left = dt;\n  while (left > 0) {\n    if (S.mode === \"wait\") {\n      const u = min(left, S.timer);\n      S.timer -= u;\n      left -= u;\n      if (S.timer > 0) return;\n      S.mode = S.next;\n      if (S.mode === \"turn\") {\n        S.leaf.set(S.ink);\n        S.leafHalo = Float32Array.from(S.halo);\n        S.turn = 0;\n        const done = S.ci >= S.cells.length;\n        if (done) S.ci = 0;\n        startPage(S, S.cells[S.ci].page);\n        S.mode = \"turning\";\n      }\n      continue;\n    }\n    if (S.mode === \"turning\") {\n      S.turn += left / 1.6;\n      left = 0;\n      if (S.turn >= 1) {\n        S.turn = 0;\n        S.mode = \"cell\";\n      }\n      return;\n    }\n    if (S.mode === \"cell\") {\n      if (S.ci >= S.cells.length) {\n        S.mode = \"wait\";\n        S.timer = 4;\n        S.next = \"turn\";\n        continue;\n      }\n      const cell = S.cells[S.ci];\n      if (cell.page !== S.page) {\n        S.mode = \"wait\";\n        S.timer = 1.2;\n        S.next = \"turn\";\n        continue;\n      }\n      prepare(S, cell);\n      S.si = 0;\n      S.pos = 0;\n      S.mode = \"lift\";\n      S.from = S.pen;\n      const to = cell.px[0] ? cell.px[0][0] : S.pen;\n      S.lift = 0;\n      S.liftT = 0.12 * q + hypot(to[0] - S.pen[0], to[1] - S.pen[1]) / (4 * v);\n      continue;\n    }\n    if (S.mode === \"lift\") {\n      const cell = S.cells[S.ci];\n      const u = min(left, S.liftT - S.lift);\n      S.lift += u;\n      left -= u;\n      const to = cell.px[S.si] ? cell.px[S.si][0] : S.pen;\n      const f = S.lift / S.liftT;\n      S.nib = [S.from[0] + (to[0] - S.from[0]) * f, S.from[1] + (to[1] - S.from[1]) * f];\n      if (S.lift \u003c S.liftT) return;\n      if (!cell.px[S.si]) {\n        S.ci++;\n        S.mode = \"cell\";\n        continue;\n      }\n      S.mode = \"draw\";\n      S.pos = 0;\n      S.done = 0;\n      continue;\n    }\n    if (S.mode === \"draw\") {\n      const cell = S.cells[S.ci], st = cell.px[S.si];\n      const u = min(left, (st.length - S.pos) / v);\n      S.pos += u * v;\n      left -= u;\n      const upto = min(st.length, floor(S.pos) + 1);\n      inkStroke(S, st, upto, S.done, S.t - left);\n      S.done = upto;\n      S.pen = st[upto - 1];\n      S.nib = S.pen;\n      if (S.done \u003c st.length) return;\n      S.si++;\n      S.from = S.pen;\n      S.mode = \"lift\";\n      S.lift = 0;\n      const to = cell.px[S.si] ? cell.px[S.si][0] : S.pen;\n      S.liftT = (cell.px[S.si] ? 0.05 : 0.1) * q + hypot(to[0] - S.pen[0], to[1] - S.pen[1]) / (4 * v);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.paper = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.brush = cl(k[2], 0, 1);\n  S.hand = cl(k[3], 0, 1);\n  if (!S.started) {\n    S.started = true;\n    // The panel opens on the first sheet with the title, the author and the\n    // first column of the poem already written, and the pen has been at the\n    // next column for four seconds at the knob's speed.\n    startPage(S, 0);\n    S.ci = 0;\n    while (S.cells[S.ci].page === 0 && S.cells[S.ci].col \u003c 3) {\n      const cell = S.cells[S.ci++];\n      prepare(S, cell);\n      for (const st of cell.px) inkStroke(S, st, st.length, 0, -50);\n    }\n    S.pen = [cellX(2) + 4, cellY(9) + 6];\n    S.nib = S.pen;\n    S.mode = \"cell\";\n    for (let i = 0; i \u003c 120; i++) step(S, 1 / 30);\n  }\n  step(S, dt);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  // Each set holds over most of its stretch of the knob and gives way to the\n  // next in a short cross-fade, so no muddy half-way sheet lasts long.\n  const u = S.paper * 4, i0 = min(3, floor(u)), f = u - i0, sm = cl((f - 0.3) / 0.4, 0, 1);\n  const [paper, grid, ink, wet, pen] = [0, 1, 2, 3, 4].map((j) => mix(SETS[i0][j], SETS[i0 + 1][j], sm * sm * (3 - 2 * sm)));\n  const inner = mix(paper, grid, 0.5), glowC = mix(ink, wet, 0.35);\n  const F = S.F, t = S.t;\n  // One LED of a sheet: paper or line, then ink, then the bleed round the\n  // ink, which spreads for a second after the pen passes; on the sheet being\n  // written, fresh ink and the paper round it glow for a moment.\n  const shade = (p, I, Hh, fresh, out, o) => {\n    const g = S.grid[p], c = g ? (g === 1 ? grid : inner) : paper;\n    let a = I[p];\n    if (Hh[p] > a) {\n      const age = t - S.glow[p], h = Hh[p] * (fresh && age \u003c 4 ? 1 - exp(-age / 0.6) : 1);\n      if (h > a) a = h;\n    }\n    let r = c[0] + (ink[0] - c[0]) * a, gg = c[1] + (ink[1] - c[1]) * a, b = c[2] + (ink[2] - c[2]) * a;\n    if (fresh) {\n      const age = t - (I[p] > 0 ? S.when[p] : S.glow[p]);\n      if (age \u003c 4) {\n        const w = I[p] > 0 ? 0.75 * exp(-age / 0.8) : 0.32 * exp(-age / 0.5), c2 = I[p] > 0 ? wet : glowC;\n        r += (c2[0] - r) * w;\n        gg += (c2[1] - gg) * w;\n        b += (c2[2] - b) * w;\n      }\n    }\n    out[o] = r;\n    out[o + 1] = gg;\n    out[o + 2] = b;\n  };\n  for (let p = 0; p \u003c N; p++) shade(p, S.ink, S.halo, true, F, p * 3);\n  // The pen's nib, bright while it writes and dimmer while it is lifted.\n  if (S.mode !== \"turning\" && S.nib) {\n    const [nx, ny] = S.nib, down = S.mode === \"draw\";\n    const x = round(nx), y = round(ny);\n    const k = down ? 1 : 0.6;\n    for (const [dx, dy, a] of [[0, 0, 1], [1, 0, 0.5], [-1, 0, 0.5], [0, 1, 0.5], [0, -1, 0.5], [1, 1, 0.22], [-1, 1, 0.22], [1, -1, 0.22], [-1, -1, 0.22]]) {\n      const X = x + dx, Y = y + dy;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const o = (Y * W + X) * 3;\n      for (let j = 0; j \u003c 3; j++) F[o + j] += (pen[j] - F[o + j]) * a * k;\n    }\n  }\n  // A turning page: the written leaf folds over towards the binding at the\n  // right edge, shading as it goes, over the fresh sheet.\n  if (S.mode === \"turning\") {\n    const e = S.turn * S.turn * (3 - 2 * S.turn), th = (e * PI) / 2, lw = W * cos(th);\n    const edge = W - lw, tmp = [0, 0, 0];\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const o = (y * W + x) * 3;\n        if (x >= edge && lw > 0.5) {\n          const sx = floor(W - ((W - x - 0.5) * W) / lw);\n          shade(y * W + cl(sx, 0, W - 1), S.leaf, S.leafHalo, false, tmp, 0);\n          const l = 0.45 + 0.55 * cos(th) + 0.25 * exp(-(x - edge) / 2) * (1 - cos(th));\n          F[o] = tmp[0] * l;\n          F[o + 1] = tmp[1] * l;\n          F[o + 2] = tmp[2] * l;\n        } else {\n          const d = 1 - 0.6 * exp(-(edge - x) / 5) * (1 - e);\n          F[o] *= d;\n          F[o + 1] *= d;\n          F[o + 2] *= d;\n        }\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(min(255, F[o])), round(min(255, F[o + 1])), round(min(255, F[o + 2])));\n}\n","excursion-sets":"// ===== Patternflow pattern =====\n// Title:   Excursion Sets\n// Family:  noise\n// Idea:    A smooth Gaussian random field on a 64 by 96 torus is cut at a level that sweeps up and down, each island of the set above the level filled in a cool tint and each lake inside land in pink, while the strip below plots islands minus lakes, the Euler characteristic, against the level, the dots gathering round the curve u e^(-u^2/2) that Adler's formula predicts.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler characteristic of Gaussian excursion sets (Robert Adler and Abraham Hasofer, 1976; Robert Adler, 1981), its use on brain images (Keith Worsley, 1992), bit-quad counting (Stephen Gray, 1971), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=3..8, Level=-1.5..1.5\n//\n// Knob 1: Hue. Turns the islands and lakes round the wheel together. At 0 the islands are cyan, going azure the higher their peak stands above the level, and the lakes pink, going violet the deeper they are; at 0.5 the islands go red to orange and the lakes green. The land that winds round the torus stays a dim teal and the sea black, whatever the knob.\n// Knob 2: Speed. At 2 the level climbs from -2.40 to 2.52 in 12 s and comes back in 12 s, and every wave of the field turns at its own rate of up to 0.35 rad/s, so the field forgets itself in about 9 s (pi / 0.35). At 0.2 ten times slower; at 3 one and a half times faster.\n// Knob 3: Scale. The width sigma in LEDs of the Gaussian that blurs white noise into the field. At 3 the expected count at u = 1 is 13.1 islands more than lakes, and 240 independent fields gave 13.3 (and -13.0 at u = -1); at 5 it is 4.7 and they gave 4.6; at 8 it is 1.8. The plot is scaled so the curve always peaks 11 rows from its axis.\n// Knob 4: Level. The middle of the sweep, its span shrinking as it moves off centre. At the opening 0.06 the level swings from -2.40 to 2.52 and the dots draw the whole curve; at 1.5 it swings from 0 to 3 and the panel stays among islands, at -1.5 from -3 to 0 among lakes.\n//\n// On a torus the Euler characteristic and the boundary length of the domain\n// are 0, so of Adler's three terms only the area's is left:\n// E chi{f >= u} = A sqrt(lx ly) (2 pi)^(-3/2) u e^(-u^2/2), with A = 64 x 96\n// and lx = ly = 1 / (2 sigma^2) the variance of the field's slope.\n\nconst W = 64, FH = 96, A = W * FH, H = 128;\nconst { floor, round, min, max, abs, exp, sqrt, cos, sin, PI, random, log } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nfunction gauss() {\n  let u = 0;\n  while (u === 0) u = random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * random());\n}\n\n// 3 x 5 digits for the two counts.\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\n\n// The strip: its axis row, and the rows above and below the axis the curve\n// may use at its peak.\nconst AXIS = 112, PEAK_ROWS = 11, U_MAX = 3;\nconst OMEGA = 0.35, SWEEP = 12;\n\nexport function setup(params) {\n  params.s = {\n    sigma: 0, modes: 0, mm: null, nn: null, c0r: null, c0i: null, om: null, th: null,\n    M: 0, cx: null, sx: null, cy: null, sy: null, gr: null, gi: null,\n    f: new Float32Array(A), lab: new Int32Array(A), ux: new Int16Array(A), uy: new Int16Array(A),\n    stack: new Int32Array(A), cWrap: new Uint8Array(A), cExt: new Float32Array(A), cSet: new Uint8Array(A), cArea: new Int32Array(A),\n    hits: new Float32Array(W * 32), hitSign: new Int8Array(W * 32),\n    phase: -0.21, u: 0, chi: 0, blobs: 0, holes: 0, peak: 1, hue: 0, c: [0, 0, 0],\n  };\n}\n\n// The field is the real part of a sum of plane waves e^(ik.x) over the\n// torus's own wave vectors, each with a complex Gaussian amplitude of\n// variance exp(-sigma^2 k^2): white noise blurred by a Gaussian of width\n// sigma, whose covariance is exp(-r^2 / 4 sigma^2). Waves past |k| = 3.4 /\n// sigma carry less than 1e-5 of the variance and are left out.\nfunction build(S, sigma) {\n  S.sigma = sigma;\n  const kc = 3.4 / sigma, M = Math.ceil((kc * W) / (2 * PI)), N = Math.ceil((kc * FH) / (2 * PI));\n  const mm = [], nn = [], amp = [];\n  let sum = 0, lx = 0, ly = 0;\n  for (let m = -M; m \u003c= M; m++)\n    for (let n = -N; n \u003c= N; n++) {\n      const kx = (2 * PI * m) / W, ky = (2 * PI * n) / FH, k2 = kx * kx + ky * ky;\n      if (k2 > kc * kc) continue;\n      const sp = exp(-sigma * sigma * k2);\n      mm.push(m);\n      nn.push(n);\n      amp.push(sqrt(sp / 2));\n      sum += sp;\n      lx += sp * kx * kx;\n      ly += sp * ky * ky;\n    }\n  const K = mm.length, norm = 1 / sqrt(sum / 2);\n  S.modes = K;\n  S.M = M;\n  S.mm = Int8Array.from(mm);\n  S.nn = Int8Array.from(nn);\n  S.c0r = new Float32Array(K);\n  S.c0i = new Float32Array(K);\n  S.om = new Float32Array(K);\n  S.th = new Float32Array(K);\n  for (let i = 0; i \u003c K; i++) {\n    S.c0r[i] = amp[i] * gauss() * norm;\n    S.c0i[i] = amp[i] * gauss() * norm;\n    S.om[i] = OMEGA * (2 * random() - 1);\n    S.th[i] = 2 * PI * random();\n  }\n  // Second spectral moments of the unit-variance field, and from them the\n  // expected Euler characteristic at its peak u = 1: A sqrt(lx ly) (2 pi)^-3/2 e^-1/2.\n  S.lam = sqrt(lx * ly) / sum;\n  S.peak = A * S.lam * Math.pow(2 * PI, -1.5) * exp(-0.5);\n  const MW = 2 * M + 1, NW = 2 * N + 1;\n  S.cx = new Float32Array(MW * W);\n  S.sx = new Float32Array(MW * W);\n  for (let m = -M; m \u003c= M; m++)\n    for (let x = 0; x \u003c W; x++) {\n      const a = (2 * PI * m * x) / W;\n      S.cx[(m + M) * W + x] = cos(a);\n      S.sx[(m + M) * W + x] = sin(a);\n    }\n  S.N = N;\n  S.cy = new Float32Array(NW * FH);\n  S.sy = new Float32Array(NW * FH);\n  for (let n = -N; n \u003c= N; n++)\n    for (let y = 0; y \u003c FH; y++) {\n      const a = (2 * PI * n * y) / FH;\n      S.cy[(n + N) * FH + y] = cos(a);\n      S.sy[(n + N) * FH + y] = sin(a);\n    }\n  S.gr = new Float32Array(MW * FH);\n  S.gi = new Float32Array(MW * FH);\n  S.hits.fill(0);\n}\n\n// The expected Euler characteristic of {f >= u} on the torus: its Euler\n// characteristic and boundary length are 0, so of the three terms of the\n// kinematic formula only the area's is left.\n// The fill of an island or a lake fades as it grows, from v at 60 LEDs to\n// half of v at 1000, so the big ones near the median do not swamp the panel.\nconst fillOf = (area, v) => v * (1 - 0.5 * cl(Math.log(area / 60) / Math.log(1000 / 60), 0, 1));\n\nconst expected = (S, u) => S.peak * exp(0.5) * u * exp(-u * u / 2);\n\nfunction synth(S) {\n  const { M, N, gr, gi, cy, sy, cx, sx, f, mm, nn, c0r, c0i, th } = S;\n  gr.fill(0);\n  gi.fill(0);\n  for (let i = 0; i \u003c S.modes; i++) {\n    const c = cos(th[i]), s = sin(th[i]);\n    const ar = c0r[i] * c - c0i[i] * s, ai = c0r[i] * s + c0i[i] * c;\n    const go = (mm[i] + M) * FH, yo = (nn[i] + N) * FH;\n    for (let y = 0; y \u003c FH; y++) {\n      const ey = cy[yo + y], fy = sy[yo + y];\n      gr[go + y] += ar * ey - ai * fy;\n      gi[go + y] += ar * fy + ai * ey;\n    }\n  }\n  const MW = 2 * M + 1;\n  for (let y = 0; y \u003c FH; y++) {\n    const row = y * W;\n    for (let x = 0; x \u003c W; x++) f[row + x] = 0;\n    for (let j = 0; j \u003c MW; j++) {\n      const a = gr[j * FH + y], b = gi[j * FH + y], o = j * W;\n      for (let x = 0; x \u003c W; x++) f[row + x] += a * cx[o + x] - b * sx[o + x];\n    }\n  }\n}\n\nconst N8X = [1, -1, 0, 0, 1, 1, -1, -1], N8Y = [0, 0, 1, -1, 1, -1, 1, -1];\n\n// Components of the lit set, eight-connected, and of the dark set,\n// four-connected, so the two count each other's holes. Each pixel keeps its\n// unwrapped position from the fill; reaching a pixel of the same component at\n// another position means the component winds round the torus. Islands minus\n// lakes, counting only the components that do not wind, is the Euler\n// characteristic Gray's bit quads give; the two agreed on all 640 fields\n// tried, each cut at 11 levels.\nfunction label(S, u) {\n  const { f, lab, ux, uy, stack, cWrap, cExt, cSet, cArea } = S;\n  lab.fill(-1);\n  let id = 0, blobs = 0, holes = 0;\n  for (let p = 0; p \u003c A; p++) {\n    if (lab[p] >= 0) continue;\n    const lit = f[p] >= u, nb = lit ? 8 : 4;\n    let sp = 0, wraps = 0, ext = f[p], area = 1;\n    lab[p] = id;\n    ux[p] = p & 63;\n    uy[p] = p >> 6;\n    stack[sp++] = p;\n    while (sp) {\n      const q = stack[--sp], qx = ux[q], qy = uy[q];\n      for (let k = 0; k \u003c nb; k++) {\n        const x = qx + N8X[k], y = qy + N8Y[k];\n        const r = (((y % FH) + FH) % FH) * W + (x & 63);\n        if ((f[r] >= u) !== lit) continue;\n        if (lab[r] === id) {\n          if (ux[r] !== x || uy[r] !== y) wraps = 1;\n          continue;\n        }\n        lab[r] = id;\n        ux[r] = x;\n        uy[r] = y;\n        stack[sp++] = r;\n        area++;\n        const v = f[r];\n        if (lit ? v > ext : v \u003c ext) ext = v;\n      }\n    }\n    cWrap[id] = wraps;\n    cExt[id] = ext;\n    cSet[id] = lit ? 1 : 0;\n    cArea[id] = area;\n    if (!wraps) {\n      if (lit) blobs++;\n      else holes++;\n    }\n    id++;\n  }\n  S.blobs = blobs;\n  S.holes = holes;\n  S.chi = blobs - holes;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), sigma = cl(k[2], 3, 8), c = cl(k[3], -1.5, 1.5);\n  if (abs(sigma - S.sigma) > 0.04) build(S, sigma);\n  const r = (d * speed) / 2;\n  for (let i = 0; i \u003c S.modes; i++) S.th[i] += S.om[i] * r;\n  // A triangle wave with rounded turns, so the level spends equal time at\n  // every height between them.\n  S.phase += r / (2 * SWEEP);\n  const tri = (2 / PI) * Math.asin(0.985 * sin(2 * PI * S.phase)) / ((2 / PI) * Math.asin(0.985));\n  const span = 2.5 - (2 / 3) * abs(c);\n  S.u = c + span * tri;\n  synth(S);\n  label(S, S.u);\n  // The count lands in the strip at the level's column and fades over 20 s.\n  const fade = exp(-r / 10);\n  for (let i = 0; i \u003c S.hits.length; i++) S.hits[i] *= fade;\n  const col = round(((S.u + U_MAX) / (2 * U_MAX)) * (W - 1));\n  const row = round(AXIS - S.chi * (PEAK_ROWS / S.peak)) - 96;\n  if (col >= 0 && col \u003c W && row >= 1 && row \u003c 32) {\n    S.hits[row * W + col] = 1;\n    S.hitSign[row * W + col] = S.chi > 0 ? 1 : S.chi \u003c 0 ? -1 : 0;\n  }\n}\n\nfunction digits(display, n, x0, y0, rgb, alignRight) {\n  const s = String(n);\n  let x = alignRight ? x0 - 4 * s.length + 1 : x0;\n  for (let i = 0; i \u003c s.length; i++, x += 4) {\n    const g = DIG[s.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") display.setPixel(x + q, y0 + r, rgb[0], rgb[1], rgb[2]);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cx) return;\n  const { f, lab, cWrap, cExt, cSet, cArea, c } = S, u = S.u, h = S.hue;\n  const hb = h + 0.5, hh = h + 0.87;\n  for (let p = 0; p \u003c A; p++) {\n    const id = lab[p], x = p & 63, y = p >> 6;\n    const lit = cSet[id] === 1;\n    // An edge pixel has a four-neighbour on the other side of the level.\n    const L = (x + 63) & 63, R = (x + 1) & 63, U = ((y + FH - 1) % FH) * W, D = ((y + 1) % FH) * W, row = y * W;\n    const edge = (f[row + L] >= u) !== lit || (f[row + R] >= u) !== lit || (f[U + x] >= u) !== lit || (f[D + x] >= u) !== lit;\n    if (lit) {\n      if (cWrap[id]) hsv(0.54, 0.55, edge ? 0.5 : 0.2, c);\n      else {\n        // An island's tint follows how far its peak stands above the level.\n        const t = cl((cExt[id] - u) / 1.6, 0, 1);\n        hsv(hb + 0.11 * t, 0.85 - 0.25 * (1 - t), edge ? 1 : fillOf(cArea[id], 0.5), c);\n      }\n    } else if (cWrap[id]) {\n      c[0] = c[1] = c[2] = 0;\n    } else {\n      const t = cl((u - cExt[id]) / 1.6, 0, 1);\n      hsv(hh - 0.07 * t, 0.6, edge ? 1 : fillOf(cArea[id], 0.45), c);\n    }\n    display.setPixel(x, y, c[0], c[1], c[2]);\n  }\n\n  // The strip: the axis, the expected curve, the counts so far, the level.\n  for (let y = 96; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n  const sc = PEAK_ROWS / S.peak, b = [0, 0, 0], o = [0, 0, 0];\n  hsv(hb + 0.05, 0.85, 1, b);\n  hsv(hh, 0.7, 1, o);\n  for (let x = 0; x \u003c W; x++) {\n    display.setPixel(x, AXIS, 34, 34, 40);\n    display.setPixel(x, 96, 30, 30, 36);\n  }\n  for (let i = 0; i \u003c 32 * W; i++) {\n    const v = S.hits[i];\n    if (v \u003c 0.04) continue;\n    const s = S.hitSign[i], col = s > 0 ? b : s \u003c 0 ? o : [200, 200, 200];\n    const a = 0.25 + 0.75 * v;\n    display.setPixel(i & 63, 96 + (i >> 6), col[0] * a, col[1] * a, col[2] * a);\n  }\n  let prev = null;\n  for (let x = 0; x \u003c W; x++) {\n    const uu = -U_MAX + (2 * U_MAX * x) / (W - 1), yy = AXIS - expected(S, uu) * sc;\n    const lo = prev === null ? yy : min(yy, prev), hi = prev === null ? yy : max(yy, prev);\n    for (let y = floor(lo); y \u003c= Math.ceil(hi); y++) {\n      if (y \u003c 97 || y > 127) continue;\n      const w = y \u003c lo ? 1 - (lo - y) : y > hi ? 1 - (y - hi) : 1;\n      if (w \u003c= 0) continue;\n      const g = 150 * w + 40;\n      display.setPixel(x, y, g, g, g + 10);\n    }\n    prev = yy;\n  }\n  const col = round(((u + U_MAX) / (2 * U_MAX)) * (W - 1));\n  for (let y = 97; y \u003c H; y++) display.setPixel(col, y, 60, 60, 70);\n  const ry = round(AXIS - S.chi * sc);\n  const now = S.chi > 0 ? b : S.chi \u003c 0 ? o : [255, 255, 255];\n  for (let dy = -1; dy \u003c= 1; dy++)\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const yy = ry + dy, xx = col + dx;\n      if (yy >= 97 && yy \u003c H && xx >= 0 && xx \u003c W && (dx === 0 || dy === 0)) display.setPixel(xx, yy, now[0], now[1], now[2]);\n    }\n  // Islands at the top left, lakes at the bottom right, where the curve\n  // never goes.\n  digits(display, S.blobs, 1, 98, b, false);\n  digits(display, S.holes, 62, 122, o, true);\n}\n","izhikevich-network":"// ===== Patternflow pattern =====\n// Title:   Izhikevich Network\n// Family:  rhythm\n// Idea:    A thousand of Izhikevich's model neurons, 800 excitatory and 200 inhibitory with random synapses and noisy thalamic input, write their spike raster down the panel two milliseconds a row, so the population rhythms stand as horizontal bands of synchrony.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: simple model of spiking neurons (Eugene Izhikevich, 2003), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drive=-1.5..3, Inhibition=0.8..1.6\n//\n// Knob 1: Hue. Turns both kinds of cell round the wheel together, skipping red-orange to orange, which reads brown when dim. At 0 the 800 excitatory cells are azure and the 200 inhibitory cells magenta; a column that fires two or more spikes in one row goes paler, toward white.\n// Knob 2: Speed. At 2 the raster moves 14 rows a second, 28 ms of the network, so it runs 36 times slower than a brain and the panel holds the last 256 ms; at 0.2 it moves 1.4 rows a second, at 3, 21.\n// Knob 3: Drive. The thalamic noise: each excitatory cell gets 5 + Drive mV times a fresh Gaussian every millisecond and each inhibitory cell 0.4 of that, so 0 is the paper's 5 and 2. At -1.5 the cells fire 1.6 times a second and the panel is nearly dark; at -1, 4.2 times in bursts 180 to 900 ms apart; at 0, 8.5 times in bursts every 124 ms; at 3, 15 times, and the bands break into a 50 Hz ripple.\n// Knob 4: Inhibition. Scales every inhibitory synapse against the paper's. At 0.8 the network locks into a burst every 124 ms, 8.1 Hz, with an autocorrelation of 0.63; at 1, the paper's network, the bursts loosen to 0.16 and a weak ripple near 30 Hz shows between them; at 1.6 the bursts are gone and a 38 Hz rhythm runs through the raster as thin stripes 13 rows apart.\n// Buttons: K1 tap gives every cell 12 mV more input for 2 ms: the whole network fires one volley about 18 ms long, falls silent for about 120 ms and comes back in a burst.\n\nconst W = 64, H = 128, NE = 800, NI = 200, N = NE + NI, EC = 50, MS = 2, KICK = 12;\nconst { floor, sqrt, log, cos, sin, PI, min } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// A fixed generator, so the network is the same one every time the pattern\n// opens and each knob setting means the same rhythm.\nfunction mulberry(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nexport function setup(params) {\n  const rnd = mulberry(2003);\n  const a = new Float32Array(N), b = new Float32Array(N), c = new Float32Array(N), d = new Float32Array(N);\n  const col = new Uint8Array(N);\n  // Izhikevich's listing draws re and ri uniform on [0, 1]; here they are\n  // drawn sorted, so the columns run from regular spiking on the left to\n  // chattering cells, and the inhibitory ones from slow to fast.\n  const re = Array.from({ length: NE }, rnd).sort((x, y) => x - y);\n  const ri = Array.from({ length: NI }, rnd).sort((x, y) => x - y);\n  for (let i = 0; i \u003c NE; i++) {\n    const r2 = re[i] * re[i];\n    a[i] = 0.02; b[i] = 0.2; c[i] = -65 + 15 * r2; d[i] = 8 - 6 * r2;\n    col[i] = floor((i * EC) / NE);\n  }\n  for (let k = 0; k \u003c NI; k++) {\n    const i = NE + k;\n    a[i] = 0.02 + 0.08 * ri[k]; b[i] = 0.25 - 0.05 * ri[k]; c[i] = -65; d[i] = 2;\n    col[i] = EC + floor((k * (W - EC)) / NI);\n  }\n  // The weights S(i, j) are stored by the firing cell j, so a spike adds\n  // one run of 1000 numbers and a quiet cell costs nothing.\n  const S = new Float32Array(N * N);\n  for (let j = 0; j \u003c N; j++) {\n    const o = j * N;\n    if (j \u003c NE) for (let i = 0; i \u003c N; i++) S[o + i] = 0.5 * rnd();\n    else for (let i = 0; i \u003c N; i++) S[o + i] = -rnd();\n  }\n  const v = new Float64Array(N).fill(-65), u = new Float64Array(N);\n  for (let i = 0; i \u003c N; i++) u[i] = b[i] * v[i];\n  params.s = {\n    a, b, c, d, col, S, v, u, I: new Float32Array(N), fired: new Int32Array(N),\n    rnd: mulberry(1963), spare: 0, hasSpare: false,\n    rows: new Uint8Array(W * H), cur: new Uint8Array(W), head: 0, acc: 0,\n    fresh: true, hue: 0, drive: 5, inh: 1, kick: 0, rgb: [0, 0, 0],\n  };\n}\n\nfunction randn(S) {\n  if (S.hasSpare) { S.hasSpare = false; return S.spare; }\n  let x = S.rnd();\n  while (x === 0) x = S.rnd();\n  const r = sqrt(-2 * log(x)), th = 2 * PI * S.rnd();\n  S.spare = r * sin(th);\n  S.hasSpare = true;\n  return r * cos(th);\n}\n\n// One millisecond of the network, as in the paper's listing: thalamic noise,\n// reset of the cells at 30 mV, their synapses, and two half steps of v.\nfunction step(S) {\n  const { a, b, c, d, v, u, I, fired, col, cur } = S;\n  const gE = S.drive, gI = 0.4 * S.drive, wI = S.inh;\n  const kick = S.kick > 0 ? (S.kick--, KICK) : 0;\n  for (let i = 0; i \u003c NE; i++) I[i] = gE * randn(S) + kick;\n  for (let i = NE; i \u003c N; i++) I[i] = gI * randn(S) + kick;\n  let nf = 0;\n  for (let i = 0; i \u003c N; i++)\n    if (v[i] >= 30) {\n      fired[nf++] = i;\n      v[i] = c[i];\n      u[i] += d[i];\n      if (cur[col[i]] \u003c 255) cur[col[i]]++;\n    }\n  const Sw = S.S;\n  for (let k = 0; k \u003c nf; k++) {\n    const j = fired[k], o = j * N, w = j \u003c NE ? 1 : wI;\n    for (let i = 0; i \u003c N; i++) I[i] += w * Sw[o + i];\n  }\n  for (let i = 0; i \u003c N; i++) {\n    let x = v[i];\n    const ui = u[i], Ii = I[i];\n    x += 0.5 * (0.04 * x * x + 5 * x + 140 - ui + Ii);\n    x += 0.5 * (0.04 * x * x + 5 * x + 140 - ui + Ii);\n    v[i] = x;\n    u[i] = ui + a[i] * (b[i] * x - ui);\n  }\n}\n\n// Ends the row being written: it becomes the top row and the rest move down.\nfunction pushRow(S) {\n  S.head = (S.head + H - 1) % H;\n  S.rows.set(S.cur, S.head * W);\n  S.cur.fill(0);\n}\n\nfunction runRows(S, n) {\n  for (let r = 0; r \u003c n; r++) {\n    for (let m = 0; m \u003c MS; m++) step(S);\n    pushRow(S);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.drive = 5 + cl(k[2], -1.5, 3);\n  S.inh = cl(k[3], 0.8, 1.6);\n  if (input.btnPressed && input.btnPressed[0]) S.kick = 2;\n  if (S.fresh) {\n    // The paper's run starts every cell at -65 mV, and the first 50 ms are\n    // one big volley with 100 quiet ones after it. The panel opens 300 ms\n    // in, already full.\n    S.fresh = false;\n    for (let m = 0; m \u003c 300; m++) step(S);\n    S.cur.fill(0);\n    runRows(S, H);\n  }\n  const rate = 7 * cl(k[1], 0.2, 3);\n  S.acc += cl(dt || 0, 0, 0.1) * rate;\n  let n = floor(S.acc);\n  S.acc -= n;\n  n = min(n, 8);\n  runRows(S, n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, h = S.hue;\n  // The wheel skips red-orange to orange (0 to 0.11), which reads brown\n  // when dim. At Hue 0 the excitatory cells are azure, the inhibitory\n  // ones magenta.\n  const wheel = (f) => 0.11 + 0.89 * (f - floor(f));\n  const hE = wheel(h + 0.528), hI = wheel(h + 0.843);\n  const sat = [0, 0.8, 0.5, 0.25], val = [0, 0.82, 1, 1];\n  for (let y = 0; y \u003c H; y++) {\n    const o = ((S.head + y) % H) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const n = S.rows[o + x];\n      if (!n) { display.setPixel(x, y, 0, 0, 0); continue; }\n      const m = min(3, n);\n      hsv(x \u003c EC ? hE : hI, sat[m], val[m], rgb);\n      display.setPixel(x, y, rgb[0] | 0, rgb[1] | 0, rgb[2] | 0);\n    }\n  }\n}\n","jamo-assembly":"// ===== Patternflow pattern =====\n// Title:   Jamo Assembly\n// Family:  type\n// Idea:    A Korean word is built down the tall panel one syllable block at a time: the slots its vowel calls for open as faint outlines, the initial consonant, the vowel and the final fly in from the panel's edges as separate letters in three colours, shrink or stretch into their slots and lock with a flash, and beside each block its code point counts up from U+AC00 as the pieces land, until the word holds in one paler colour and flies apart to be built again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hangul syllable blocks, 모아쓰기 of the Hunminjeongeum (King Sejong, created 1443, promulgated 1446), the Unicode Hangul Syllables block at U+AC00 (Unicode 2.0, 1996), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Flight=0..1\n//\n// Knob 1: Hue. Turns the three roles round the wheel together. At 0 initials are cyan, vowels violet-pink and finals yellow, a finished block pales 80% of the way to azure, and the code point is azure grey; at 0.5 the roles are red, green and blue and the finished word salmon.\n// Knob 2: Speed. At 2 a syllable starts every 1.15 s with its pieces 0.3 s apart, a flight takes 0.95 s, the word holds 2.6 s after its last piece locks and flies apart in about 1 s: one round is 8.6 s for 모아쓰기, 6.4 s for a two-syllable word and 5.1 s for 빛. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Phrase. 0 모아쓰기, 1 훨훨, 2 패턴, 3 흐름, 4 한글, 5 괜찮아, 6 훈민정음, 7 빛. A one- or two-syllable word gets 56-LED blocks, 괜찮아 39, the four-syllable words 28. Between them the initial sits beside a vertical vowel (아 기 패 턴 한 찮 민 정 빛), above a horizontal one (모 쓰 흐 름 글 훈 음) and in the corner of a compound (훨 괜), with a final under them in 13 of the 20 blocks and doubled letters in 쓰 (ㅆ) and 찮 (ㄶ).\n// Knob 4: Flight. How the pieces fly in. At 0 they come in on an arc bent by 0.3 of their path, turn 0.3 rad and land in 0.9 s with a small overshoot; at 1 the arc bends by 0.9, they spin through up to 3.2 rad, overshoot further, take 1.8 s and leave trails that fade in 0.16 s instead of 0.06 s. A piece keeps the flight time it set off with, so a turn shows on the next pieces.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, exp, cos, sin, PI, random, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst PHRASES = [\"모아쓰기\", \"훨훨\", \"패턴\", \"흐름\", \"한글\", \"괜찮아\", \"훈민정음\", \"빛\"];\n\n// The basic letters as strokes on a 20 x 20 grid, y down. A stroke is a\n// polyline of x, y pairs; one that starts with O is an ellipse cx, cy, rx, ry.\nconst O = -1;\nconst BASE = {\n  \"ㄱ\": [[3, 3, 17, 3, 17, 18]],\n  \"ㄴ\": [[3, 2, 3, 17, 18, 17]],\n  \"ㄷ\": [[17, 3, 3, 3, 3, 17, 18, 17]],\n  \"ㄹ\": [[3, 2, 17, 2, 17, 10, 3, 10, 3, 18, 18, 18]],\n  \"ㅁ\": [[3, 3, 17, 3, 17, 17, 3, 17, 3, 3]],\n  \"ㅂ\": [[3, 2, 3, 18, 17, 18, 17, 2], [3, 10, 17, 10]],\n  \"ㅅ\": [[10, 2, 2, 18], [10, 2, 18, 18]],\n  \"ㅇ\": [[O, 10, 10, 7.5, 7.5]],\n  \"ㅈ\": [[3, 3, 17, 3], [10, 3, 3, 18], [10, 3, 17, 18]],\n  \"ㅊ\": [[10, 0, 10, 4], [3, 5, 17, 5], [10, 5, 3, 19], [10, 5, 17, 19]],\n  \"ㅋ\": [[3, 3, 17, 3, 17, 18], [3, 10, 17, 10]],\n  \"ㅌ\": [[17, 2, 3, 2, 3, 18, 18, 18], [3, 10, 17, 10]],\n  \"ㅍ\": [[2, 3, 18, 3], [2, 17, 18, 17], [7, 3, 7, 17], [13, 3, 13, 17]],\n  \"ㅎ\": [[10, 0, 10, 3], [3, 5, 17, 5], [O, 10, 13, 5.5, 5]],\n  \"ㅣ\": [[10, 1, 10, 19]],\n  \"ㅏ\": [[7, 1, 7, 19], [7, 10, 17, 10]],\n  \"ㅑ\": [[7, 1, 7, 19], [7, 7, 17, 7], [7, 13, 17, 13]],\n  \"ㅓ\": [[13, 1, 13, 19], [3, 10, 13, 10]],\n  \"ㅕ\": [[13, 1, 13, 19], [3, 7, 13, 7], [3, 13, 13, 13]],\n  \"ㅐ\": [[5, 1, 5, 19], [5, 10, 13, 10], [15, 0, 15, 20]],\n  \"ㅒ\": [[5, 1, 5, 19], [5, 7, 13, 7], [5, 13, 13, 13], [15, 0, 15, 20]],\n  \"ㅔ\": [[2, 10, 9, 10], [9, 1, 9, 19], [16, 0, 16, 20]],\n  \"ㅖ\": [[2, 7, 9, 7], [2, 13, 9, 13], [9, 1, 9, 19], [16, 0, 16, 20]],\n  \"ㅡ\": [[1, 10, 19, 10]],\n  \"ㅗ\": [[10, 4, 10, 13], [1, 13, 19, 13]],\n  \"ㅛ\": [[7, 4, 7, 13], [13, 4, 13, 13], [1, 13, 19, 13]],\n  \"ㅜ\": [[1, 7, 19, 7], [10, 7, 10, 16]],\n  \"ㅠ\": [[1, 7, 19, 7], [7, 7, 7, 16], [13, 7, 13, 16]],\n};\n// The 19 initials, 21 vowels and 27 finals in Unicode's order, each spelled\n// with the basic letters it is built from.\nconst INIT = [\"ㄱ\", \"ㄱㄱ\", \"ㄴ\", \"ㄷ\", \"ㄷㄷ\", \"ㄹ\", \"ㅁ\", \"ㅂ\", \"ㅂㅂ\", \"ㅅ\", \"ㅅㅅ\", \"ㅇ\", \"ㅈ\", \"ㅈㅈ\", \"ㅊ\", \"ㅋ\", \"ㅌ\", \"ㅍ\", \"ㅎ\"];\nconst MED = [\"ㅏ\", \"ㅐ\", \"ㅑ\", \"ㅒ\", \"ㅓ\", \"ㅔ\", \"ㅕ\", \"ㅖ\", \"ㅗ\", \"ㅗㅏ\", \"ㅗㅐ\", \"ㅗㅣ\", \"ㅛ\", \"ㅜ\", \"ㅜㅓ\", \"ㅜㅔ\", \"ㅜㅣ\", \"ㅠ\", \"ㅡ\", \"ㅡㅣ\", \"ㅣ\"];\nconst FIN = [\"\", \"ㄱ\", \"ㄱㄱ\", \"ㄱㅅ\", \"ㄴ\", \"ㄴㅈ\", \"ㄴㅎ\", \"ㄷ\", \"ㄹ\", \"ㄹㄱ\", \"ㄹㅁ\", \"ㄹㅂ\", \"ㄹㅅ\", \"ㄹㅌ\", \"ㄹㅍ\", \"ㄹㅎ\", \"ㅁ\", \"ㅂ\", \"ㅂㅅ\", \"ㅅ\", \"ㅅㅅ\", \"ㅇ\", \"ㅈ\", \"ㅊ\", \"ㅋ\", \"ㅌ\", \"ㅍ\", \"ㅎ\"];\nconst HORIZONTAL = \"ㅗㅛㅜㅠㅡ\";\n\n// The slots on a 20 x 20 block, [x, y, w, h]: the initial, the vowel (two\n// rects for a compound: its horizontal part and its vertical part) and the\n// final, by the vowel's shape and whether there is a final.\nconst SLOTS = {\n  V: [[1, 3, 11, 14], [[12, 0, 7, 20]]],\n  VF: [[1, 1, 11, 10], [[12, 0, 7, 12]], [3, 13, 14, 7]],\n  H: [[3, 1, 14, 10], [[0, 10, 20, 9]]],\n  HF: [[3, 0, 14, 7], [[0, 6, 20, 6]], [3, 13, 14, 7]],\n  C: [[1, 1, 11, 9], [[0, 9, 14, 8], [13, 0, 7, 20]]],\n  CF: [[1, 0, 11, 6], [[0, 5, 14, 6], [13, 0, 7, 13]], [3, 13, 14, 7]],\n};\n\n// 3 x 5 hex digits for the code point, top row first, 4 is the left column.\nconst HEX = [[7, 5, 5, 5, 7], [2, 6, 2, 2, 7], [7, 1, 7, 4, 7], [7, 1, 3, 1, 7], [5, 5, 7, 1, 1], [7, 4, 7, 1, 7], [7, 4, 7, 5, 7], [7, 1, 1, 2, 2],\n  [7, 5, 7, 5, 7], [7, 5, 7, 1, 7], [2, 5, 7, 5, 5], [6, 5, 6, 5, 6], [3, 4, 4, 4, 3], [6, 5, 5, 5, 6], [7, 4, 6, 4, 7], [7, 4, 6, 4, 4]];\n\n// The timeline, in seconds at Speed 2.\n// A flight takes 0.9 s with Flight at 0 and 1.8 s at 1; a piece keeps the\n// time it set off with.\nconst STEP = 1.15, LAG = 0.3, HOLD = 2.6, OUT = 0.9, REST = 0.1;\nconst flyTime = (F) => 0.9 + 0.9 * F;\n\nexport function setup(params) {\n  params.s = { phrase: -1, t: 0, syl: [], pieces: [], end: 0, hue: 0, flight: 0, buf: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0] };\n}\n\n// Lay a letter group (one to two basic letters side by side) into a rect.\nfunction split(letters, r) {\n  if (letters.length === 1) return [{ ch: letters, r }];\n  const w = r[2] * 0.47;\n  return [{ ch: letters[0], r: [r[0], r[1], w, r[3]] }, { ch: letters[1], r: [r[0] + r[2] - w, r[1], w, r[3]] }];\n}\n\n// Where a piece enters: out from its slot along (dx, dy) until its centre is\n// past the panel's edge by half.\nfunction edgeStart(tx, ty, dx, dy, half) {\n  let t = 1e9;\n  if (dx > 1e-6) t = min(t, (W + half - tx) / dx);\n  if (dx \u003c -1e-6) t = min(t, (-half - tx) / dx);\n  if (dy > 1e-6) t = min(t, (H + half - ty) / dy);\n  if (dy \u003c -1e-6) t = min(t, (-half - ty) / dy);\n  return [tx + dx * t, ty + dy * t];\n}\n\nfunction build(S, idx) {\n  S.phrase = idx;\n  const word = PHRASES[idx], n = word.length;\n  const B = n \u003c= 2 ? 56 : floor((124 - (n - 1) * 3) / n), gap = n \u003c= 2 ? 4 : 3;\n  const x0 = (W - B) / 2, y0 = (H - (n * B + (n - 1) * gap)) / 2;\n  S.B = B;\n  S.syl = [];\n  S.pieces = [];\n  for (let s = 0; s \u003c n; s++) {\n    const code = word.charCodeAt(s) - 0xac00;\n    const L = floor(code / 588), V = floor((code % 588) / 28), T = code % 28;\n    const shape = MED[V].length === 2 ? \"C\" : HORIZONTAL.includes(MED[V]) ? \"H\" : \"V\";\n    const slots = SLOTS[shape + (T ? \"F\" : \"\")];\n    const bx = x0, by = y0 + s * (B + gap);\n    const syl = { L, V, T, bx, by, B, pieces: [], t0: 0.15 + s * STEP };\n    const groups = [split(INIT[L], slots[0])];\n    groups.push(MED[V].length === 2 ? [{ ch: MED[V][0], r: slots[1][0] }, { ch: MED[V][1], r: slots[1][1] }] : [{ ch: MED[V], r: slots[1][0] }]);\n    if (T) groups.push(split(FIN[T], slots[2]));\n    groups.forEach((subs, role) => {\n      // The piece's box is the union of its sub-rects, in block units.\n      let ux0 = 20, uy0 = 20, ux1 = 0, uy1 = 0;\n      for (const u of subs) {\n        ux0 = min(ux0, u.r[0]); uy0 = min(uy0, u.r[1]);\n        ux1 = max(ux1, u.r[0] + u.r[2]); uy1 = max(uy1, u.r[1] + u.r[3]);\n      }\n      const k = B / 20;\n      const p = {\n        role, syl: s,\n        subs: subs.map((u) => ({ g: BASE[u.ch], rel: [(u.r[0] - ux0) / (ux1 - ux0), (u.r[1] - uy0) / (uy1 - uy0), u.r[2] / (ux1 - ux0), u.r[3] / (uy1 - uy0)] })),\n        slot: subs.map((u) => [bx + u.r[0] * k, by + u.r[1] * k, u.r[2] * k, u.r[3] * k]),\n        tx: bx + ((ux0 + ux1) / 2) * k, ty: by + ((uy0 + uy1) / 2) * k, tw: (ux1 - ux0) * k, th: (uy1 - uy0) * k,\n        launch: syl.t0 + role * LAG,\n      };\n      // Enter from the side the slot faces, give or take 75 degrees.\n      let ax = p.tx - (bx + B / 2), ay = p.ty - (by + B / 2);\n      const a = Math.atan2(ay, ax) + (random() - 0.5) * 2.6;\n      ax = cos(a); ay = sin(a);\n      const SZ = B * 0.8;\n      [p.sx, p.sy] = edgeStart(p.tx, p.ty, ax, ay, SZ * 0.35);\n      // Leave outward from the block's centre, give or take 30 degrees.\n      const b = Math.atan2(p.ty - (by + B / 2), p.tx - (bx + B / 2)) + (random() - 0.5) * 1.05;\n      p.ex = cos(b); p.ey = sin(b);\n      p.bend = random() \u003c 0.5 ? -1 : 1;\n      p.spin = random() \u003c 0.5 ? -1 : 1;\n      p.SZ = SZ;\n      syl.pieces.push(p);\n      S.pieces.push(p);\n    });\n    S.syl.push(syl);\n  }\n}\n\n// Lock, hold and leave times from the flights as they stand: a piece in the\n// air keeps its own flight time, one still waiting takes the knob's.\nfunction schedule(S) {\n  const fly = flyTime(S.flight);\n  let last = 0;\n  for (const p of S.pieces) {\n    if (p.fly === undefined && S.t >= p.launch) p.fly = fly;\n    p.lock = p.launch + (p.fly === undefined ? fly : p.fly);\n    last = max(last, p.lock);\n  }\n  const hold = last + HOLD;\n  S.syl.forEach((syl, s) => {\n    syl.done = 0;\n    for (const p of syl.pieces) {\n      syl.done = max(syl.done, p.lock);\n      p.out = hold + s * 0.12 + (2 - p.role) * 0.05;\n    }\n  });\n  S.end = hold + (S.syl.length - 1) * 0.12 + 0.1 + 0.7 * OUT + REST;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.flight = cl(k[3], 0, 1);\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  S.tau = tau;\n  const idx = round(cl(k[2], 0, PHRASES.length - 1));\n  if (idx !== S.phrase) {\n    build(S, idx);\n    // The very first build opens with the first pieces already in the air.\n    S.t = S.started ? 0 : 0.55;\n    S.started = true;\n  }\n  S.t += tau;\n  schedule(S);\n  if (S.t > S.end) {\n    build(S, idx);\n    S.t = 0;\n    schedule(S);\n  }\n}\n\n// Ease in and out, overshooting the slot by more as s grows.\nfunction easeBack(u, s) {\n  const c = s * 1.525;\n  return u \u003c 0.5 ? ((2 * u) ** 2 * ((c + 1) * 2 * u - c)) / 2 : ((2 * u - 2) ** 2 * ((c + 1) * (2 * u - 2) + c) + 2) / 2;\n}\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Where a piece is at time t: box centre, size, rotation, and visibility.\nfunction pose(S, p, t) {\n  const F = S.flight;\n  if (t \u003c p.launch) return null;\n  if (t \u003c p.lock) {\n    const u = (t - p.launch) / (p.lock - p.launch), q = easeBack(u, 0.4 + 1.6 * F), m = smooth(u * 1.15);\n    // A quadratic curve bent sideways by 0.3 to 0.9 of its length.\n    const mx = (p.sx + p.tx) / 2, my = (p.sy + p.ty) / 2, dx = p.tx - p.sx, dy = p.ty - p.sy;\n    const bend = (0.3 + 0.6 * F) * p.bend;\n    const cx = mx - dy * bend, cy = my + dx * bend;\n    const a = (1 - q) * (1 - q), b = 2 * (1 - q) * q, c = q * q;\n    return { x: a * p.sx + b * cx + c * p.tx, y: a * p.sy + b * cy + c * p.ty, w: p.SZ + (p.tw - p.SZ) * m, h: p.SZ + (p.th - p.SZ) * m, r: p.spin * (0.3 + 2.9 * F) * (1 - m) ** 2, a: 1 };\n  }\n  if (t \u003c p.out) return { x: p.tx, y: p.ty, w: p.tw, h: p.th, r: 0, a: 1 };\n  const u = (t - p.out) / OUT;\n  if (u >= 1) return null;\n  const e = u * u, dist = 90 * e;\n  return { x: p.tx + p.ex * dist, y: p.ty + p.ey * dist, w: p.tw + (p.SZ - p.tw) * e, h: p.th + (p.SZ - p.th) * e, r: p.spin * (0.3 + 2.9 * F) * e, a: 1 - u * u };\n}\n\n// Max-blend a stroke segment of width w into the buffer.\nfunction seg(buf, x0, y0, x1, y1, w, c) {\n  const r = w / 2 + 0.5;\n  const lx = max(0, floor(min(x0, x1) - r)), hx = min(W - 1, ceil(max(x0, x1) + r));\n  const ly = max(0, floor(min(y0, y1) - r)), hy = min(H - 1, ceil(max(y0, y1) + r));\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-9;\n  for (let y = ly; y \u003c= hy; y++)\n    for (let x = lx; x \u003c= hx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0;\n      const u = cl((px * dx + py * dy) / L2, 0, 1), ex = px - u * dx, ey = py - u * dy;\n      const f = cl(r - sqrt(ex * ex + ey * ey), 0, 1);\n      if (f \u003c= 0) continue;\n      const i = (y * W + x) * 3;\n      if (buf[i] \u003c c[0] * f) buf[i] = c[0] * f;\n      if (buf[i + 1] \u003c c[1] * f) buf[i + 1] = c[1] * f;\n      if (buf[i + 2] \u003c c[2] * f) buf[i + 2] = c[2] * f;\n    }\n}\n\nfunction drawPiece(buf, p, ps, w, c) {\n  const co = cos(ps.r), si = sin(ps.r);\n  const map = (rel, gx, gy) => {\n    const lx = (rel[0] + (rel[2] * gx) / 20 - 0.5) * ps.w, ly = (rel[1] + (rel[3] * gy) / 20 - 0.5) * ps.h;\n    return [ps.x + lx * co - ly * si, ps.y + lx * si + ly * co];\n  };\n  for (const sub of p.subs)\n    for (const st of sub.g) {\n      const pts = [];\n      if (st[0] === O) {\n        for (let i = 0; i \u003c= 24; i++) {\n          const a = (i / 24) * 2 * PI;\n          pts.push(map(sub.rel, st[1] + st[3] * cos(a), st[2] + st[4] * sin(a)));\n        }\n      } else for (let i = 0; i \u003c st.length; i += 2) pts.push(map(sub.rel, st[i], st[i + 1]));\n      for (let i = 1; i \u003c pts.length; i++) seg(buf, pts[i - 1][0], pts[i - 1][1], pts[i][0], pts[i][1], w, c);\n    }\n}\n\nfunction rectOutline(buf, r, c) {\n  const x0 = round(r[0]), y0 = round(r[1]), x1 = round(r[0] + r[2]) - 1, y1 = round(r[1] + r[3]) - 1;\n  const put = (x, y) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    for (let j = 0; j \u003c 3; j++) buf[i + j] = max(buf[i + j], c[j]);\n  };\n  for (let x = x0; x \u003c= x1; x++) { put(x, y0); put(x, y1); }\n  for (let y = y0 + 1; y \u003c y1; y++) { put(x0, y); put(x1, y); }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.phrase \u003c 0) return;\n  const buf = S.buf, c = S.c, c2 = S.c2, t = S.t, h0 = S.hue + 0.5;\n  // Trails: what was drawn fades in 0.06 s at Speed 2 with Flight at 0, in\n  // 0.16 s at 1.\n  const fade = exp(-(S.tau || 0) / (0.06 + 0.1 * S.flight));\n  for (let i = 0; i \u003c buf.length; i++) buf[i] *= fade;\n  const w = cl(S.B * 0.08, 1.5, 4.2);\n  // Slot outlines while a piece is on its way, fading once it locks.\n  for (const p of S.pieces) {\n    const g = t \u003c p.launch - 0.15 ? 0 : t \u003c p.lock ? 1 : max(0, 1 - (t - p.lock) / 0.4);\n    if (g \u003c= 0) continue;\n    hsv(h0 + p.role / 3, 0.7, 0.22 * g, c);\n    for (const r of p.slot) rectOutline(buf, r, c);\n  }\n  for (const syl of S.syl) {\n    // The block's square from its first launch until it is whole.\n    const g = t \u003c syl.t0 - 0.1 ? 0 : t \u003c syl.done ? 1 : max(0, 1 - (t - syl.done) / 0.6);\n    if (g > 0) {\n      c[0] = c[1] = c[2] = 0.1 * g;\n      rectOutline(buf, [syl.bx - 1, syl.by - 1, syl.B + 2, syl.B + 2], c);\n    }\n  }\n  for (const p of S.pieces) {\n    const ps = pose(S, p, t);\n    if (!ps) continue;\n    const syl = S.syl[p.syl];\n    hsv(h0 + p.role / 3, 0.75, 1, c);\n    // A whole block pales toward one colour; a piece flashes white as it locks.\n    const one = smooth((t - syl.done - 0.25) / 0.6) * (t \u003c p.out ? 1 : 1 - smooth((t - p.out) / 0.3));\n    hsv(h0 + 0.08, 0.5, 1, c2);\n    const fl = t >= p.lock && t \u003c p.out ? exp(-(t - p.lock) / 0.18) : 0;\n    for (let j = 0; j \u003c 3; j++) c[j] = ((c[j] + (c2[j] - c[j]) * one * 0.8) * (1 - fl) + fl) * ps.a;\n    drawPiece(buf, p, ps, w * (t \u003c p.lock ? 1 + 0.3 * (1 - (t - p.launch) / (p.lock - p.launch)) : 1), c);\n  }\n  // Beside each block, its code point as the pieces land: U+AC00, then\n  // + initial x 588, + vowel x 28, + final.\n  const out = S.out || (S.out = new Float32Array(buf.length));\n  out.set(buf);\n  for (const syl of S.syl) {\n    if (t \u003c syl.t0) continue;\n    const [pi, pv, pf] = syl.pieces;\n    let v = 0xac00, lastLock = syl.t0;\n    if (t >= pi.lock) { v += syl.L * 588; lastLock = pi.lock; }\n    if (t >= pv.lock) { v += syl.V * 28; lastLock = pv.lock; }\n    if (pf && t >= pf.lock) { v += syl.T; lastLock = pf.lock; }\n    const gone = t \u003c pi.out ? 1 : max(0, 1 - (t - pi.out) / 0.4), fl = exp(-(t - lastLock) / 0.25);\n    hsv(h0 + 0.08, 0.4, (0.5 + 0.5 * fl) * gone, c);\n    const xd = round(syl.bx + syl.B + (syl.bx - 3) / 2), yd = round(syl.by + syl.B / 2 - 11.5);\n    for (let d = 0; d \u003c 4; d++) {\n      const g = HEX[(v >> (12 - 4 * d)) & 15];\n      for (let ry = 0; ry \u003c 5; ry++)\n        for (let rx = 0; rx \u003c 3; rx++)\n          if (g[ry] & (4 >> rx)) {\n            const x = xd + rx, y = yd + d * 6 + ry;\n            if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n            const i = (y * W + x) * 3;\n            for (let j = 0; j \u003c 3; j++) out[i + j] = max(out[i + j], c[j]);\n          }\n    }\n  }\n  for (let p = 0, i = 0; p \u003c W * H; p++, i += 3)\n    display.setPixel(p & 63, p >> 6, round(cl(out[i], 0, 1) * 255), round(cl(out[i + 1], 0, 1) * 255), round(cl(out[i + 2], 0, 1) * 255));\n}\n","kaprekar-routine":"// ===== Patternflow pattern =====\n// Title:   Kaprekar's Routine\n// Family:  type\n// Idea:    A worksheet of Kaprekar's routine runs down the panel in large drawn digits: the digits of a number fly one by one, largest first, into descending order on the line below, that row turns half round like a carousel into ascending order under it, the two are subtracted column by column from the right with the borrows marked, and the difference becomes the next line, until 6174 comes back and the two 6174s light up gold.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kaprekar's routine and the constant 6174 (D. R. Kaprekar, 1949), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Digits=4..7, Start=0..1\n//\n// Knob 1: Hue. Turns the digits round the wheel. Each digit value keeps its own colour, so a digit can be followed as it moves: at 0 a 0 is cyan, a 9 violet and the rest between; the number the routine comes back to is always gold.\n// Knob 2: Speed. At 2 the start is written in 1.5 s and the first step takes 4.7 s (the sort 1.2 s, the turn 0.9 s, the rule 0.3 s, four columns of 0.45 s and a pause), each later step 0.86 times the one before, down to half. A seven-step start has 6174 on the sheet at 23.8 s and finds it again at 26.1 s; the pair glows 3.5 s, the sheet slides away and a new start comes at 30.5 s. At 0.2 ten times slower; at 3 one and a half times faster.\n// Knob 3: Digits. 4: all 9990 starts from 0000 to 9999 whose digits are not all the same reach 6174 within 7 steps. 5: no number stays; every start falls within 6 steps into the 2-cycle 53955, 59994 (3190 starts) or one of the 4-cycles 61974, 82962, 75933, 63954 (48,480) and 62964, 71973, 83952, 74943 (48,320). 6: 549945 (1950 starts) and 631764 (62,520) stay put, and the rest fall into the 7-cycle 840852, 860832, 862632, 642654, 420876, 851742, 750843, within 13 steps. 7: all 9,999,990 starts fall into one 8-cycle through 7509843, within 13 steps. A sheet stops when a number comes back, and with a cycle every line of the loop lights up.\n// Knob 4: Start. Which starts the sheet takes, by the steps they need: at 0 the farthest (7 steps for 4 digits, 6 for 5, 13 for 6 and 7), at 1 the nearest, one step. Each start is a random arrangement of a random digit multiset that needs that many. At 0 with 4 digits the 2184 seven-step starts leave only 8 different numbers after their first subtraction, and those run into three tails, so the sheet keeps ending in the same lines: 8172, 7443, 3996, 6264, 4176 or 7992, 7173, 6354, 3087, 8352 or 5994, 5355, 1998, 8082, 8532.\n// Buttons: K1 tap starts a new sheet.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI, random, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The digits, drawn as strokes on a 10 x 16 grid with the pen's centre kept\n// inside 1..9 and 1..15: L for a line, A for an arc (centre, radius, start\n// and end angle in degrees, y pointing down, so the angle grows clockwise).\nconst STROKES = [\n  [[\"A\", 5, 5, 4, 180, 360], [\"L\", 9, 5, 9, 11], [\"A\", 5, 11, 4, 0, 180], [\"L\", 1, 11, 1, 5]],\n  [[\"L\", 5.6, 1, 5.6, 15], [\"L\", 5.6, 1, 2.2, 4.4]],\n  [[\"A\", 5, 5, 4, 180, 390], [\"L\", 8.46, 7, 1, 15], [\"L\", 1, 15, 9, 15]],\n  [[\"A\", 5, 4.5, 3.5, 195, 450], [\"A\", 5, 11.5, 3.6, 270, 525], [\"L\", 3.2, 8, 5, 8]],\n  [[\"L\", 7, 15, 7, 1], [\"L\", 7, 1, 1, 11], [\"L\", 1, 11, 9.4, 11]],\n  [[\"L\", 8.8, 1, 2.3, 1], [\"L\", 2.3, 1, 2.03, 7.53], [\"A\", 5, 10.5, 4.2, 225, 500]],\n  [[\"A\", 5, 10.8, 4, 0, 360], [\"A\", 9.5, 10.8, 8.5, 180, 258]],\n  [[\"L\", 1, 1, 9, 1], [\"L\", 9, 1, 3.6, 15]],\n  [[\"A\", 5, 4.6, 3.4, 0, 360], [\"A\", 5, 11.2, 3.8, 0, 360]],\n  [[\"A\", 5, 5.2, 4, 0, 360], [\"A\", 0.5, 5.2, 8.5, 0, 78]],\n];\n\n// Layout for 4 to 7 digits: the left margin that holds the minus sign and the\n// step count, the glyph's width and height, the pen, and the gap between lines.\nconst LAYOUT = {\n  4: { margin: 8, gw: 12, gh: 19, pen: 2.4, gap: 5 },\n  5: { margin: 9, gw: 9, gh: 14, pen: 1.9, gap: 5 },\n  6: { margin: 7, gw: 8, gh: 12, pen: 1.6, gap: 4 },\n  7: { margin: 7, gw: 7, gh: 10, pen: 1.35, gap: 4 },\n};\nconst MAX_STEPS = { 4: 7, 5: 6, 6: 13, 7: 13 };\n\n// Beats of each phase at Speed 2, in seconds.\nconst T_INTRO = 0.25, T_SLIDE = 0.3, T_FLIP = 0.9, T_RULE = 0.3, T_COL = 0.45, T_SETTLE = 0.45, T_FINAL = 3.5, T_OUT = 0.9;\n\nfunction segments(strokes) {\n  const out = [];\n  for (const s of strokes) {\n    if (s[0] === \"L\") out.push([s[1], s[2], s[3], s[4]]);\n    else {\n      const [, cx, cy, r, a0, a1] = s, n = max(2, Math.ceil(abs(a1 - a0) / 8));\n      for (let i = 0; i \u003c n; i++) {\n        const b0 = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, b1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * PI) / 180;\n        out.push([cx + r * cos(b0), cy + r * sin(b0), cx + r * cos(b1), cy + r * sin(b1)]);\n      }\n    }\n  }\n  return out;\n}\n\nfunction segDist(px, py, x0, y0, x1, y1) {\n  const dx = x1 - x0, dy = y1 - y0, l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / l, 0, 1) : 0;\n  const ex = x0 + t * dx - px, ey = y0 + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// Renders the ten digits at one size: 4 x 4 samples a pixel, a sample lit\n// when it lies within half the pen of a stroke.\nfunction renderGlyphs(L) {\n  const { gw, gh, pen } = L, sx = (gw - pen) / 8, sy = (gh - pen) / 14, hw = pen / 2;\n  const glyphs = [];\n  for (let d = 0; d \u003c 10; d++) {\n    const segs = segments(STROKES[d]).map(([a, b, c, e]) => [hw + (a - 1) * sx, hw + (b - 1) * sy, hw + (c - 1) * sx, hw + (e - 1) * sy]);\n    const g = new Float32Array(gw * gh);\n    for (let y = 0; y \u003c gh; y++)\n      for (let x = 0; x \u003c gw; x++) {\n        let hit = 0;\n        for (let j = 0; j \u003c 4; j++)\n          for (let i = 0; i \u003c 4; i++) {\n            const px = x + (i + 0.5) / 4, py = y + (j + 0.5) / 4;\n            for (const s of segs)\n              if (segDist(px, py, s[0], s[1], s[2], s[3]) \u003c= hw) {\n                hit++;\n                break;\n              }\n          }\n        g[y * gw + x] = hit / 16;\n      }\n    glyphs.push(g);\n  }\n  return glyphs;\n}\n\nconst toDigits = (v, n) => {\n  const d = new Int8Array(n);\n  for (let i = n - 1; i >= 0; i--, v = floor(v / 10)) d[i] = v % 10;\n  return d;\n};\nconst toValue = (d) => {\n  let v = 0;\n  for (let i = 0; i \u003c d.length; i++) v = v * 10 + d[i];\n  return v;\n};\nfunction kStep(v, n) {\n  const d = Array.from(toDigits(v, n)).sort((a, b) => a - b);\n  let asc = 0, desc = 0;\n  for (let i = 0; i \u003c n; i++) {\n    asc = asc * 10 + d[i];\n    desc = desc * 10 + d[n - 1 - i];\n  }\n  return desc - asc;\n}\n\n// Every multiset of n digits, not all the same, grouped by how many steps a\n// number made of it takes to reach the fixed point or the cycle.\nfunction classify(n) {\n  const cache = new Map();\n  const enter = (y) => {\n    const path = [], seen = new Set();\n    let z = y;\n    while (!seen.has(z) && !cache.has(z)) {\n      seen.add(z);\n      path.push(z);\n      z = kStep(z, n);\n    }\n    if (!cache.has(z)) {\n      let c = z;\n      do {\n        cache.set(c, 0);\n        c = kStep(c, n);\n      } while (c !== z);\n    }\n    for (let i = path.length - 1; i >= 0; i--) if (!cache.has(path[i])) cache.set(path[i], cache.get(kStep(path[i], n)) + 1);\n    return cache.get(y);\n  };\n  const by = [];\n  const digits = [];\n  const rec = (pos, lo) => {\n    if (pos === n) {\n      if (digits[0] === digits[n - 1]) return;\n      let asc = 0, desc = 0;\n      for (let i = 0; i \u003c n; i++) {\n        asc = asc * 10 + digits[i];\n        desc = desc * 10 + digits[n - 1 - i];\n      }\n      const e = enter(desc - asc) + 1;\n      (by[e] || (by[e] = [])).push(digits.slice());\n      return;\n    }\n    for (let d = lo; d \u003c= 9; d++) {\n      digits.push(d);\n      rec(pos + 1, d);\n      digits.pop();\n    }\n  };\n  rec(0, 0);\n  return by;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, L: null, glyphs: null, fonts: {}, cell: 0, classes: {}, target: -1,\n    lines: [], phase: \"intro\", t: 0, k: 0, cam: 0, glow: [],\n    buf: new Float32Array(W * H * 3), hue: 0, speed: 2, c: [0, 0, 0], gold: [0, 0, 0],\n  };\n}\n\nfunction slotX(S, j) {\n  return round(S.L.margin + j * S.cell + (S.cell - S.L.gw) / 2);\n}\n\nfunction pickStart(S) {\n  const n = S.n, by = S.classes[n] || (S.classes[n] = classify(n));\n  let t = S.target;\n  while (t > 1 && !by[t]) t--;\n  const pool = by[t], ms = pool[floor(random() * pool.length)].slice();\n  // A random arrangement of the multiset, not starting with 0 if it can help it.\n  for (let tries = 0; tries \u003c 8; tries++) {\n    for (let i = n - 1; i > 0; i--) {\n      const j = floor(random() * (i + 1)), x = ms[i];\n      ms[i] = ms[j];\n      ms[j] = x;\n    }\n    if (ms[0] !== 0) break;\n  }\n  return Int8Array.from(ms);\n}\n\nfunction newSheet(S) {\n  const L = LAYOUT[S.n];\n  S.L = L;\n  S.cell = (W - L.margin) / S.n;\n  S.glyphs = S.fonts[S.n] || (S.fonts[S.n] = renderGlyphs(L));\n  S.pitch = L.gh + L.gap;\n  const dig = pickStart(S);\n  S.lines = [{ kind: \"N\", dig, y: 4, value: toValue(dig), step: 0 }];\n  S.phase = \"intro\";\n  S.t = 0;\n  S.k = 0;\n  S.cam = 0;\n  S.glow = [];\n}\n\nconst last = (S) => S.lines[S.lines.length - 1];\n\n// The next step's three lines: the digits sorted down, the same flipped, and\n// the difference with the borrows it needs.\nfunction beginStep(S) {\n  const n = S.n, top = last(S), src = top.dig;\n  const order = Array.from(src, (d, i) => [d, i]).sort((a, b) => b[0] - a[0] || a[1] - b[1]);\n  const D = Int8Array.from(order, (o) => o[0]);\n  const A = Int8Array.from(D).reverse();\n  const R = new Int8Array(n), dots = new Uint8Array(n), ticks = new Uint8Array(n);\n  let borrow = 0;\n  for (let j = n - 1; j >= 0; j--) {\n    let v = D[j] - borrow - A[j];\n    if (v \u003c 0) {\n      v += 10;\n      ticks[j] = 1;\n      if (j > 0) dots[j - 1] = 1;\n      borrow = 1;\n    } else borrow = 0;\n    R[j] = v;\n  }\n  const p = S.pitch, y = top.y;\n  S.k++;\n  S.lines.push({ kind: \"D\", dig: D, y: y + p, from: order.map((o) => o[1]), dots, ticks });\n  S.lines.push({ kind: \"A\", dig: A, y: y + 2 * p });\n  S.lines.push({ kind: \"R\", dig: R, y: y + 3 * p + 3, value: toValue(R), step: S.k });\n  S.phase = \"slide\";\n  S.t = 0;\n}\n\nconst pace = (S) => max(0.5, Math.pow(0.86, S.k - 1));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = cl(round(kv[2]), 4, 7), maxT = MAX_STEPS[n];\n  const target = maxT - round(cl(kv[3], 0, 1) * (maxT - 1));\n  if (n !== S.n || target !== S.target) {\n    S.n = n;\n    S.target = target;\n    newSheet(S);\n  }\n  if (input.btnPressed && input.btnPressed[0]) newSheet(S);\n  let r = (d * S.speed) / 2;\n  // Phases run on beats; one frame can cross several short ones.\n  for (let guard = 0; guard \u003c 6 && r > 0; guard++) {\n    const f = S.phase === \"intro\" || S.phase === \"final\" || S.phase === \"out\" ? 1 : pace(S);\n    const dur =\n      S.phase === \"intro\" ? T_INTRO * S.n + 0.5 :\n      S.phase === \"slide\" ? T_SLIDE * S.n * f :\n      S.phase === \"flip\" ? T_FLIP * f :\n      S.phase === \"rule\" ? T_RULE * f :\n      S.phase === \"sub\" ? T_COL * S.n * f :\n      S.phase === \"settle\" ? T_SETTLE * f :\n      S.phase === \"final\" ? T_FINAL : T_OUT;\n    const used = min(r, dur - S.t);\n    S.t += used;\n    r -= used;\n    if (S.t \u003c dur - 1e-9) break;\n    S.t = 0;\n    if (S.phase === \"intro\") beginStep(S);\n    else if (S.phase === \"slide\") S.phase = \"flip\";\n    else if (S.phase === \"flip\") S.phase = \"rule\";\n    else if (S.phase === \"rule\") S.phase = \"sub\";\n    else if (S.phase === \"sub\") S.phase = \"settle\";\n    else if (S.phase === \"settle\") {\n      const R = last(S);\n      let hit = -1;\n      for (let i = 0; i \u003c S.lines.length - 1; i++) if ((S.lines[i].kind === \"N\" || S.lines[i].kind === \"R\") && S.lines[i].value === R.value) hit = i;\n      if (hit >= 0) {\n        S.glow = [];\n        for (let i = hit; i \u003c S.lines.length; i++) if (S.lines[i].kind === \"N\" || S.lines[i].kind === \"R\") S.glow.push(i);\n        S.phase = \"final\";\n      } else beginStep(S);\n    } else if (S.phase === \"final\") S.phase = \"out\";\n    else newSheet(S);\n  }\n  // The view follows the lowest line being written.\n  const L = S.L, bottom = last(S).y + L.gh + 3;\n  const want = max(0, bottom - (H - 6));\n  S.cam += (want - S.cam) * (1 - exp(-d * 5));\n}\n\nfunction blit(S, d, x0, y0, rgb) {\n  const { gw, gh } = S.L, g = S.glyphs[d], buf = S.buf;\n  const xi = round(x0), yi = round(y0);\n  for (let y = 0; y \u003c gh; y++) {\n    const yy = yi + y;\n    if (yy \u003c 0 || yy >= H) continue;\n    for (let x = 0; x \u003c gw; x++) {\n      const v = g[y * gw + x], xx = xi + x;\n      if (v \u003c= 0 || xx \u003c 0 || xx >= W) continue;\n      const o = (yy * W + xx) * 3;\n      buf[o] = max(buf[o], rgb[0] * v);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * v);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * v);\n    }\n  }\n}\n\nfunction rect(S, x0, y0, w, h, r, g, b) {\n  for (let y = round(y0); y \u003c round(y0) + h; y++)\n    for (let x = round(x0); x \u003c round(x0) + w; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      S.buf[o] = max(S.buf[o], r);\n      S.buf[o + 1] = max(S.buf[o + 1], g);\n      S.buf[o + 2] = max(S.buf[o + 2], b);\n    }\n}\n\nconst SMALL = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\nfunction small(S, v, x0, y0, g) {\n  const s = String(v);\n  for (let i = 0; i \u003c s.length; i++) {\n    const b = SMALL[s.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (b[r * 3 + q] === \"1\") rect(S, x0 + 4 * i + q, y0 + r, 1, 1, g, g, g + 12);\n  }\n}\n\n// Alpha over: a glyph in flight covers what it passes.\nfunction blitOver(S, d, x0, y0, rgb) {\n  const { gw, gh } = S.L, g = S.glyphs[d], buf = S.buf;\n  const xi = round(x0), yi = round(y0);\n  for (let y = 0; y \u003c gh; y++) {\n    const yy = yi + y;\n    if (yy \u003c 0 || yy >= H) continue;\n    for (let x = 0; x \u003c gw; x++) {\n      const a = g[y * gw + x], xx = xi + x;\n      if (a \u003c= 0 || xx \u003c 0 || xx >= W) continue;\n      const o = (yy * W + xx) * 3;\n      buf[o] += (rgb[0] - buf[o]) * a;\n      buf[o + 1] += (rgb[1] - buf[o + 1]) * a;\n      buf[o + 2] += (rgb[2] - buf[o + 2]) * a;\n    }\n  }\n}\n\nconst STAGE = { intro: 0, slide: 1, flip: 2, rule: 3, sub: 4, settle: 5, final: 6, out: 7 };\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.L) return;\n  const { L, buf, c, gold } = S, n = S.n;\n  buf.fill(0);\n  const ph = S.phase, st = STAGE[ph], f = pace(S), h0 = S.hue + 0.5;\n  const dy = S.cam + (ph === \"out\" ? ease(S.t / T_OUT) * (H + 20) : 0);\n  const pulse = 0.78 + 0.22 * sin(S.t * 6);\n  hsv(0.13, 0.5, 1, gold);\n  const g = [gold[0] * pulse, gold[1] * pulse, gold[2] * pulse];\n  const nl = S.lines.length, top = st === 0 ? 0 : nl - 4;\n  const u = ph === \"slide\" ? S.t / (T_SLIDE * n * f) : ph === \"flip\" ? S.t / (T_FLIP * f) : ph === \"rule\" ? S.t / (T_RULE * f) : 0;\n  const colT = ph === \"sub\" ? S.t / (T_COL * f) : st > 4 ? n + 1 : -1;\n  const colour = (dv, v, sat) => hsv(h0 + 0.034 * dv, sat, v, c);\n  const lnD = st > 0 ? S.lines[nl - 3] : null;\n  for (let li = 0; li \u003c nl; li++) {\n    const ln = S.lines[li], y = ln.y - dy;\n    if (y > H || y + L.gh + 3 \u003c -3) continue;\n    const cur = li >= top + 1 && st > 0, glow = st >= 6 && S.glow.indexOf(li) >= 0;\n    const base = li \u003c top ? 0.4 : li === top && st > 0 ? 0.6 : 1;\n    for (let j = 0; j \u003c n; j++) {\n      let v = base, sat = 0.72;\n      if (ln.kind === \"N\" && st === 0 && j >= floor(S.t / T_INTRO)) continue;\n      if (li === top && ph === \"slide\") {\n        // A digit dims once it has been picked for the sorted row.\n        let picked = false;\n        for (let k = 0; k \u003c n; k++) if (lnD.from[k] === j && u * n - k > 0) picked = true;\n        v = picked ? 0.6 : 1;\n      }\n      if (cur && ln.kind === \"D\" && st === 1 && u * n - j \u003c 1) continue;\n      if (cur && ln.kind === \"A\" && st \u003c= 2) continue;\n      if (cur && ln.kind === \"R\") {\n        if (st \u003c 4) continue;\n        const k = n - 1 - j;\n        if (colT \u003c k + 0.5) continue;\n        // The digit is written white and settles into its colour.\n        sat = 0.72 * cl((colT - k - 0.5) * 2, 0, 1);\n      }\n      if (cur && ph === \"sub\" && (ln.kind === \"D\" || ln.kind === \"A\") && j === n - 1 - floor(colT)) {\n        v = 1;\n        sat = 0.12;\n      }\n      if (glow) blit(S, ln.dig[j], slotX(S, j), y, g);\n      else {\n        colour(ln.dig[j], v, sat);\n        blit(S, ln.dig[j], slotX(S, j), y, c);\n      }\n    }\n    // Borrows: a tick before the digit that takes ten, a dot over the one\n    // that gives it.\n    if (ln.kind === \"D\" && ln.ticks && (!cur || st >= 4)) {\n      const w = n === 4 ? 2 : 1, b = (li \u003c top ? 0.45 : 1) * 255;\n      for (let j = 0; j \u003c n; j++) {\n        if (ln.ticks[j] && colT + (cur ? 0 : 99) >= n - 1 - j + 0.25) rect(S, slotX(S, j) - 2, y + 1, 1, round(L.gh * 0.42), b, b * 0.85, b * 0.35);\n        if (ln.dots[j] && colT + (cur ? 0 : 99) >= n - 2 - j + 0.25) rect(S, slotX(S, j) + round((L.gw - w) / 2), y - 1 - w, w, w, b, b * 0.85, b * 0.35);\n      }\n    }\n    if (ln.kind === \"A\" && (!cur || st >= 3)) {\n      const b = (li \u003c top ? 0.45 : 1) * 190, my = y + round(L.gh / 2) - 1;\n      rect(S, 1, my, L.margin - 3, n === 4 ? 2 : 1, b, b, b);\n      const rw = cur && ph === \"rule\" ? round((W - 2) * ease(u)) : W - 2;\n      rect(S, 1, y + L.gh + 1, rw, 1, b * 0.75, b * 0.75, b * 0.8);\n    }\n    if (ln.kind === \"R\" && (!cur || st >= 5)) small(S, ln.step, 1, y + L.gh - 5, li \u003c top ? 50 : 90);\n  }\n  if (ph === \"slide\") {\n    // The sorted row is picked one digit at a time, the largest first, each\n    // flying from its place in the line above.\n    const lnN = S.lines[nl - 4];\n    for (let k = 0; k \u003c n; k++) {\n      const uk = u * n - k;\n      if (uk \u003c= 0 || uk >= 1) continue;\n      const i = lnD.from[k], e = ease(uk);\n      const x = slotX(S, i) + (slotX(S, k) - slotX(S, i)) * ease(uk * 1.2);\n      const yy = lnN.y + (lnD.y - lnN.y) * e - 2 * sin(PI * e) - dy;\n      colour(lnD.dig[k], 1, 0.3);\n      blitOver(S, lnD.dig[k], x, yy, c);\n    }\n  }\n  if (ph === \"flip\") {\n    // The copy drops a line, then turns half round like a carousel seen from\n    // a little below, the digits behind swinging low and dim, so it lands\n    // reversed.\n    const lnA = S.lines[nl - 2], e = ease(u / 0.3), th = PI * ease((u - 0.3) / 0.7), cx = L.margin + (n * S.cell) / 2;\n    const dx = (j) => slotX(S, j) + L.gw / 2 - cx, zmax = abs(dx(0)) || 1;\n    const idx = [];\n    for (let j = 0; j \u003c n; j++) idx.push(j);\n    idx.sort((a, b) => dx(b) - dx(a));\n    for (const j of idx) {\n      const z = -dx(j) * sin(th);\n      const x = cx + dx(j) * cos(th) - L.gw / 2;\n      const yy = lnD.y + (lnA.y - lnD.y) * e + (z \u003c 0 ? -z * 0.55 : -z * 0.08) - dy;\n      colour(lnD.dig[j], 0.55 + 0.45 * (0.5 + (0.5 * z) / zmax), 0.3);\n      blitOver(S, lnD.dig[j], x, yy, c);\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p & 63, p >> 6, buf[p * 3], buf[p * 3 + 1], buf[p * 3 + 2]);\n}\n","maxwell-fish-eye":"// ===== Patternflow pattern =====\n// Title:   Maxwell's Fish-Eye\n// Family:  line\n// Idea:    Inside Maxwell's fish-eye lens, where the index falls off as n0 / (1 + r^2/R^2), 24 rays leave a point source and bend along circles, pulses of light run out along all of them at once, and the ring their heads draw swells, turns over and closes on the image point -R^2 P / |P|^2, every pulse arriving together, while the source drifts and its image swings round the far side of the dotted circle r = R.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Maxwell's fish-eye lens (James Clerk Maxwell, 1854), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Source=-1..1, Profile=0..1\n//\n// Knob 1: Hue. Turns the fan's colours round the wheel together. At 0 the ray aimed straight at the image is cyan and the one aimed straight away violet, with the pulses paled towards white; at 0.25 the fan runs violet to red, at 0.5 red to yellow-green.\n// Knob 2: Speed. At 2 a pulse takes 2.95 s from the source to the image and a new one leaves every 1.18 s, so the arrivals fall between the departures; the source swings 24 degrees either side of the vertical through the centre in 13.7 s and its distance breathes in and out by a fifth over 22.9 s. At 0.2 everything is ten times slower, at 3 a pulse crosses in 1.96 s.\n// Knob 3: Source. How far the source sits from the centre, as R e^(K/2) with R = 30 LEDs: at the opening 0 it wanders between 24.6 and 36.6 LEDs out and its image the same, on the far side; at 1 the source rides 40 to 60 LEDs up near the top and the image closes in to 15 to 22 below the centre; at -1 the two swap.\n// Knob 4: Profile. Bends the index away from Maxwell's to n0 / (1 + r^2/R^2)^q. Up to 0.1 q = 1 and all 24 rays land within 0.01 LED of the image; then q rises to 1.5 at 1, the rays cross in a cusped caustic instead of a point, and the pulses never come closer together than 3.8 LEDs at 0.25, 9.4 at 0.5 and 8.5 at 1.\n\n// The rays are integrated, not drawn as circles. With n0 = 2 the optical\n// length from the source P to the image -R^2 P / |P|^2 is pi R on every ray,\n// the length of half a great circle on a sphere of radius R: the fish-eye is\n// that sphere seen through stereographic projection, and its rays are the\n// great circles. Checked by RK4 in this file and in a separate script: each\n// ray is a circle to 1e-8 R, lands on the image to 0.01 LED, and crosses the\n// dotted circle r = R at the two ends of one diameter (the sphere's\n// equator, which a great circle cuts at opposite points; the angle at which\n// a ray crosses it is not fixed, anything from 37 to 90 degrees for a source\n// at R/2).\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, sin, cos, abs, PI, hypot } = Math;\nconst TAU = 2 * PI;\nconst OX = 31.5, OY = 63.5, R = 30, R2 = R * R;\nconst NR = 24, MAXS = 700;\nconst HALF = PI * R; // optical length from source to image, n0 = 2\nconst GAP = HALF * 0.4; // optical length between pulses\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, ph: 0,\n    acc: new Float32Array(W * H * 3),\n    xs: new Float32Array(NR * MAXS), ys: new Float32Array(NR * MAXS), ls: new Float32Array(NR * MAXS),\n    cnt: new Int32Array(NR),\n    c: [0, 0, 0],\n    k1: [0, 0, 0, 0], k2: [0, 0, 0, 0], k3: [0, 0, 0, 0], k4: [0, 0, 0, 0],\n    px: OX, py: 20, qx: OX, qy: 100,\n  };\n}\n\n// n = 2 / (1 + r^2/R^2)^q, Maxwell's own at q = 1. A ray is stepped in\n// its length s along the panel: it turns towards higher n at the rate\n// d(theta)/ds = grad(ln n) . (-sin theta, cos theta), with\n// grad(ln n) = -2 q x / (R^2 + r^2), and gathers optical length dL = n ds.\n// RK4, with steps from 0.8 LEDs near the centre to 1.5% of r far out.\nfunction deriv(x, y, th, q, o) {\n  const r2 = x * x + y * y, g = (-2 * q) / (R2 + r2), c = cos(th), s = sin(th);\n  o[0] = c; o[1] = s; o[2] = g * (y * c - x * s); o[3] = q === 1 ? 2 / (1 + r2 / R2) : 2 / (1 + r2 / R2) ** q;\n}\n\nfunction trace(S, k, x, y, th, q, Lmax) {\n  const base = k * MAXS, a = S.k1, b = S.k2, c3 = S.k3, d = S.k4;\n  let L = 0, c = 1;\n  S.xs[base] = x; S.ys[base] = y; S.ls[base] = 0;\n  while (L \u003c Lmax && c \u003c MAXS) {\n    const h = 0.8 + 0.015 * sqrt(x * x + y * y);\n    deriv(x, y, th, q, a);\n    deriv(x + (h / 2) * a[0], y + (h / 2) * a[1], th + (h / 2) * a[2], q, b);\n    deriv(x + (h / 2) * b[0], y + (h / 2) * b[1], th + (h / 2) * b[2], q, c3);\n    deriv(x + h * c3[0], y + h * c3[1], th + h * c3[2], q, d);\n    x += (h / 6) * (a[0] + 2 * b[0] + 2 * c3[0] + d[0]);\n    y += (h / 6) * (a[1] + 2 * b[1] + 2 * c3[1] + d[1]);\n    th += (h / 6) * (a[2] + 2 * b[2] + 2 * c3[2] + d[2]);\n    L += (h / 6) * (a[3] + 2 * b[3] + 2 * c3[3] + d[3]);\n    S.xs[base + c] = x; S.ys[base + c] = y; S.ls[base + c] = L; c++;\n  }\n  S.cnt[k] = c;\n}\n\nfunction splat(acc, x, y, r, g, b) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++) {\n    const yy = iy + j;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = j ? fy : 1 - fy;\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = wy * (i ? fx : 1 - fx), o = (yy * W + xx) * 3;\n      acc[o] += r * w; acc[o + 1] += g * w; acc[o + 2] += b * w;\n    }\n  }\n}\n\nfunction seg(acc, x0, y0, x1, y1, r, g, b) {\n  if ((x0 \u003c -2 && x1 \u003c -2) || (x0 > W + 1 && x1 > W + 1) || (y0 \u003c -2 && y1 \u003c -2) || (y0 > H + 1 && y1 > H + 1)) return;\n  const len = hypot(x1 - x0, y1 - y0), n = Math.ceil(len / 0.6) || 1;\n  const w = len / n;\n  for (let i = 0; i \u003c n; i++) {\n    const t = (i + 0.5) / n;\n    splat(acc, x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, r * w, g * w, b * w);\n  }\n}\n\nfunction glow(acc, x, y, rad, r, g, b) {\n  const x0 = max(0, floor(x - rad * 2)), x1 = min(W - 1, floor(x + rad * 2) + 1);\n  const y0 = max(0, floor(y - rad * 2)), y1 = min(H - 1, floor(y + rad * 2) + 1);\n  for (let yy = y0; yy \u003c= y1; yy++)\n    for (let xx = x0; xx \u003c= x1; xx++) {\n      const d2 = ((xx - x) ** 2 + (yy - y) ** 2) / (rad * rad);\n      const w = exp(-d2);\n      const o = (yy * W + xx) * 3;\n      acc[o] += r * w; acc[o + 1] += g * w; acc[o + 2] += b * w;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0]; S.speed = k[1]; S.src = k[2]; S.q = 1 + 0.5 * max(0, (k[3] - 0.1) / 0.9) ** 1.5;\n  S.t += dt * S.speed;\n  S.ph += dt * S.speed * 16;\n  const sw = 0.42 * sin(S.t * 0.23);\n  const d = R * exp(0.5 * S.src + 0.2 * sin(S.t * 0.137 + 1));\n  S.px = d * sin(sw); S.py = -d * cos(sw);\n  const m = R2 / (d * d);\n  S.qx = -m * S.px; S.qy = -m * S.py;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const acc = S.acc;\n  acc.fill(0);\n  const c = S.c;\n  // the circle r = R, dotted\n  for (let i = 0; i \u003c 96; i++) {\n    const a = (TAU * i) / 96;\n    splat(acc, OX + R * cos(a), OY + R * sin(a), 0.16, 0.14, 0.2);\n  }\n  const Lmax = HALF * 1.6;\n  const axis = Math.atan2(S.qy - S.py, S.qx - S.px);\n  const Lp = S.ph % GAP;\n  for (let k = 0; k \u003c NR; k++) {\n    const off = (TAU * (k + 0.5)) / NR;\n    trace(S, k, S.px, S.py, axis + off, S.q, Lmax);\n    const wide = abs(((off + PI) % TAU) - PI) / PI; // 0 for the ray aimed at the image, 1 for the one aimed away\n    hsv(S.hue + 0.5 + 0.28 * wide, 0.85, 1, c);\n    const base = k * MAXS, cnt = S.cnt[k];\n    for (let i = 1; i \u003c cnt; i++) {\n      const L = S.ls[base + i];\n      const dim = L \u003c HALF ? 0.22 : 0.13 * max(0, 1 - (L - HALF) / (0.6 * HALF));\n      seg(acc, OX + S.xs[base + i - 1], OY + S.ys[base + i - 1], OX + S.xs[base + i], OY + S.ys[base + i], c[0] * dim, c[1] * dim, c[2] * dim);\n    }\n    // pulses, GAP apart in optical length, so the arrivals fall between the departures\n    for (let pz = 0; pz \u003c 4; pz++) {\n      const Lh = Lp + pz * GAP;\n      const fade = Lh \u003c HALF ? 1 : max(0, 1 - (Lh - HALF) / (0.5 * HALF));\n      for (let i = 1; i \u003c cnt; i++) {\n        const L0 = S.ls[base + i - 1], L1 = S.ls[base + i];\n        if (L1 \u003c Lh - 8 || L0 > Lh) continue;\n        const a = min(1, max(0, 1 - (Lh - L1) / 8));\n        const v = 1.2 * a * a * fade;\n        seg(acc, OX + S.xs[base + i - 1], OY + S.ys[base + i - 1], OX + S.xs[base + i], OY + S.ys[base + i], (c[0] * 0.6 + 0.4) * v, (c[1] * 0.6 + 0.4) * v, (c[2] * 0.6 + 0.4) * v);\n      }\n    }\n  }\n  glow(acc, OX + S.px, OY + S.py, 1.3, 1.4, 1.0, 0.6);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, 255 * (1 - exp(-acc[o] * 1.6)), 255 * (1 - exp(-acc[o + 1] * 1.6)), 255 * (1 - exp(-acc[o + 2] * 1.6)));\n    }\n}\n","moffatt-eddies":"// ===== Patternflow pattern =====\n// Title:   Moffatt Eddies\n// Family:  sim\n// Idea:    A wedge of syrup stands on its point, stirred far above, and Moffatt's similarity solution fills it with a stack of counter-rotating eddies that shrink by a fixed ratio toward the corner, each one drawn with its own stream lines on its own log scale between white dividing stream lines, with tracers circling in every eddy while the view sinks into the corner one eddy at a time.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Moffatt eddies in a corner (H. Keith Moffatt, 1964), their photograph (Sadatoshi Taneda, 1979), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Angle=28..100, Truth=0..1\n//\n// Knob 1: Hue. Turns the two eddy colours together along the hues from green to pink, leaving out red, orange and yellow, which read brown this dim: at 0 the eddies turning one way are teal and the ones turning the other way violet, at 0.4 violet and green, at 0.6 magenta and sky blue. The dividing stream lines stay white and the walls grey.\n// Knob 2: Speed. At 2 the view sinks into the corner by one eddy every 3.0 s at 28 degrees (6.6 s at 100), and a tracer goes round its stream line in 1.6 to 2.3 s whatever the size of its eddy. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Angle. The wedge's opening 2 alpha, from 28 degrees, where its walls meet the panel's top corners, to 100. The exponent lambda solves sin(2 (lambda - 1) alpha) = -(lambda - 1) sin(2 alpha): at 28 degrees lambda = 9.636 + 4.516i and each eddy is 2.005 times smaller than the one above it and its fluid moves 406 times slower; at 60 degrees 5.000 and 688, at 90 16.57 and 2189, at 100 29.27 and 4322, when one eddy fills the panel. Past 146.3 degrees lambda turns real and the eddies are gone.\n// Knob 4: Truth. At 0 every eddy is drawn and turned on its own scale, so the deep ones still glow and turn. Turned up, brightness and turning follow the real flow: at 1 brightness is the log of the speed over three decades below an eddy whose outer edge is at the top of the panel. At 28 degrees an eddy brightens from 0.13 to full as its outer edge climbs from row 66 to the top, the eddy under it stays dark, and its tracers turn 203 times slower than the ones above. That is about what Taneda's camera saw.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, exp, log, sqrt, sin, cos, sinh, cosh, atan2, atan, PI, random, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst CX = 32, CY = 128; // the corner, at the middle of the bottom edge\nconst TN = 513; // samples of the angular profile across the wedge\nconst NP = 64; // tracers\nconst TL = 9; // trail points per tracer\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// cos and sin of a complex number x + iy, as [re, im].\nconst ccos = (x, y) => [cos(x) * cosh(y), -sin(x) * sinh(y)];\nconst csin = (x, y) => [sin(x) * cosh(y), cos(x) * sinh(y)];\n\n// Stokes flow in the wedge |theta| \u003c alpha with psi even in theta, so the\n// fluid crosses the bisector: psi = Re[r^lambda f(theta)] with\n// f = A cos(lambda theta) + C cos((lambda - 2) theta). No slip on both walls\n// (f = f' = 0 at theta = alpha) leaves a 2x2 system whose determinant,\n// (l - 2) cos(l a) sin((l - 2) a) - l sin(l a) cos((l - 2) a), reduces to\n// sin(2 (l - 1) a) + (l - 1) sin(2 a) = 0. Newton on p = l - 1, followed\n// from a 2 degree wedge, where 2 p a is near the root 4.2124 + 2.2507i of\n// sin z = -z, up to the wedge asked for.\nfunction solve(S, deg) {\n  let from = S.deg, pr = S.pr, pi = S.pi;\n  if (!(from > 0) || abs(deg - from) > 60) {\n    from = 2;\n    const a0 = (PI / 180) * 1;\n    pr = 4.212392 / (2 * a0); pi = 2.250729 / (2 * a0);\n  }\n  const steps = max(1, Math.ceil(abs(deg - from) / 1));\n  for (let s = 1; s \u003c= steps; s++) {\n    const d = from + ((deg - from) * s) / steps, a = (PI / 180) * d * 0.5, s2 = sin(2 * a);\n    for (let it = 0; it \u003c 30; it++) {\n      const [sr, si] = csin(2 * a * pr, 2 * a * pi), [cr, ci] = ccos(2 * a * pr, 2 * a * pi);\n      const fr = sr + pr * s2, fi = si + pi * s2, dr = 2 * a * cr + s2, di = 2 * a * ci;\n      const dd = dr * dr + di * di;\n      const qr = (fr * dr + fi * di) / dd, qi = (fi * dr - fr * di) / dd;\n      pr -= qr; pi -= qi;\n      if (abs(qr) + abs(qi) \u003c 1e-12) break;\n    }\n  }\n  S.deg = deg; S.pr = pr; S.pi = pi;\n  const al = (PI / 180) * deg * 0.5, lr = pr + 1, li = pi;\n  S.al = al; S.a = lr; S.mu = li; S.c = lr / li;\n  // Each eddy is rho times the next one in, and its speeds exp(pi (a - 1) / mu) times.\n  S.rho = exp(PI / li);\n  // The angular profile: f = cos((l-2) a) cos(l t) - cos(l a) cos((l-2) t).\n  const [Ar, Ai] = ccos((lr - 2) * al, li * al), [Cr, Ci] = ccos(lr * al, li * al);\n  let prev = 0;\n  for (let j = 0; j \u003c TN; j++) {\n    const t = -al + (2 * al * j) / (TN - 1);\n    const [xr, xi] = ccos(lr * t, li * t), [yr, yi] = ccos((lr - 2) * t, li * t);\n    const fr = Ar * xr - Ai * xi - (Cr * yr - Ci * yi), fi = Ar * xi + Ai * xr - (Cr * yi + Ci * yr);\n    let g = atan2(fi, fr);\n    if (j > 0) { while (g - prev > PI) g -= 2 * PI; while (g - prev \u003c -PI) g += 2 * PI; }\n    prev = g;\n    S.arg[j] = g;\n    S.lf[j] = 0.5 * log(fr * fr + fi * fi + 1e-300);\n  }\n  const off = S.arg[(TN - 1) >> 1];\n  for (let j = 0; j \u003c TN; j++) {\n    S.arg[j] -= off;\n    S.G[j] = S.lf[j] - S.c * S.arg[j];\n  }\n  for (let j = 1; j \u003c TN - 1; j++) S.da[j] = (S.arg[j + 1] - S.arg[j - 1]) / ((4 * al) / (TN - 1));\n  S.da[0] = S.da[1]; S.da[TN - 1] = S.da[TN - 2];\n  // ln u = G(t) + c x + ln sin x - ln m, x in [0, pi) across one eddy; the\n  // largest e^(c x) sin x is at x = pi - atan(1/c).\n  const xs = PI - atan(1 / S.c);\n  let gm = -1e9;\n  for (let j = 0; j \u003c TN; j++) gm = max(gm, S.G[j]);\n  S.lnm = gm + S.c * xs + log(sin(xs));\n}\n\n// The field at a screen point, into q: inside, the eddy index k, xh (0..pi\n// across the eddy), lu (ln of |psi| over the eddy's own scale, so the same\n// numbers in every eddy) and gc, the length of grad chi in 1/LED.\nfunction field(S, x, y, q) {\n  const dx = x - CX, dy = CY - y, r = hypot(dx, dy), t = atan2(dx, dy);\n  q.r = r; q.t = t;\n  if (r \u003c 1e-6 || abs(t) >= S.al) { q.inside = 0; return q; }\n  const fj = ((t + S.al) / (2 * S.al)) * (TN - 1), j = min(TN - 2, floor(fj)), w = fj - j;\n  const arg = S.arg[j] + (S.arg[j + 1] - S.arg[j]) * w;\n  const G = S.G[j] + (S.G[j + 1] - S.G[j]) * w;\n  const da = S.da[j] + (S.da[j + 1] - S.da[j]) * w;\n  const chi = S.mu * log(r) + arg + S.phi;\n  const k = floor((chi - PI / 2) / PI), xh = chi - PI / 2 - k * PI;\n  q.inside = 1; q.k = k; q.xh = xh;\n  q.lu = G + S.c * xh + log(max(1e-30, sin(xh))) - S.lnm;\n  q.gc = sqrt(S.mu * S.mu + da * da) / r;\n  return q;\n}\n\nexport function setup(params) {\n  params.s = {\n    arg: new Float64Array(TN), lf: new Float64Array(TN), G: new Float64Array(TN), da: new Float64Array(TN),\n    deg: 0, pr: 0, pi: 0, al: 0, a: 0, mu: 1, c: 1, rho: 1, lnm: 0,\n    phi: 0, hue: 0, truth: 0, speed: 2, kap: 0, spin: 1,\n    px: new Float32Array(NP), py: new Float32Array(NP), pu: new Float32Array(NP), pk: new Int32Array(NP),\n    tx: new Float32Array(NP * TL), ty: new Float32Array(NP * TL), tick: 0,\n    q: {}, q2: {}, rgb: new Float32Array(W * H * 3), col: [0, 0, 0],\n    K: new Float64Array(W * H), LU: new Float32Array(W * H), TH: new Float32Array(W * H), DM: new Float32Array(W * H),\n  };\n}\n\n// A tracer on a random stream line. Fresh tracers spread over every eddy\n// from the newest one at least 5 LEDs across up to the top of the panel; a\n// tracer whose eddy has left the panel comes back in one of them, picked by\n// size, so the big eddies near the top keep enough tracers.\nfunction spawn(S, i, deep) {\n  const q = S.q, size = min(S.rho - 1, 2 * sin(S.al));\n  const k0 = Math.ceil((S.mu * log(5 / size) - PI / 2 + S.phi) / PI);\n  const k1 = floor((S.mu * log(124) - PI / 2 + S.phi) / PI);\n  for (let tries = 0; tries \u003c 40; tries++) {\n    let k = k0 + floor(random() * (max(k0, k1) - k0 + 1));\n    if (deep) for (let kk = k1, tot = 0; kk >= k0; kk--) {\n      const z = exp((0.8 * (kk - k1) * PI) / S.mu);\n      tot += z;\n      if (random() * tot \u003c z) k = kk;\n    }\n    const t = (random() * 2 - 1) * S.al * 0.8, xh = random() * PI;\n    const fj = ((t + S.al) / (2 * S.al)) * (TN - 1), j = floor(fj);\n    const r = exp((k * PI + PI / 2 + xh - S.arg[j] - S.phi) / S.mu);\n    const x = CX + r * sin(t), y = CY - r * cos(t);\n    field(S, x, y, q);\n    if (!q.inside || q.k !== k || y \u003c 0) continue;\n    const u = exp(q.lu);\n    if (u \u003c 0.015 || u > 0.85) continue;\n    S.px[i] = x; S.py[i] = y; S.pu[i] = u; S.pk[i] = k;\n    for (let n = 0; n \u003c TL; n++) { S.tx[i * TL + n] = x; S.ty[i * TL + n] = y; }\n    return;\n  }\n  S.pu[i] = -1;\n}\n\n// The tracer velocity: the dive's outward stretch plus the flow along the\n// stream lines of eddy k. The flow is scaled by a constant on each stream line,\n// so the paths are the real ones, and every stream line of every eddy goes\n// round in about the same time (Truth 0) or at its eddy's real rate.\nfunction vel(S, x, y, k, iu, out) {\n  const q = S.q2, h = 0.2;\n  field(S, x + h, y, q); const ux1 = q.inside && q.k === k ? exp(q.lu) : 0;\n  field(S, x - h, y, q); const ux0 = q.inside && q.k === k ? exp(q.lu) : 0;\n  field(S, x, y + h, q); const uy1 = q.inside && q.k === k ? exp(q.lu) : 0;\n  field(S, x, y - h, q); const uy0 = q.inside && q.k === k ? exp(q.lu) : 0;\n  const gx = (ux1 - ux0) / (2 * h), gy = (uy1 - uy0) / (2 * h);\n  const R = exp((k * PI + PI - S.phi) / S.mu);\n  const slow = exp(-S.truth * (S.a - 2) * max(0, log(120 / R)));\n  const sg = k & 1 ? 1 : -1, f = sg * R * R * S.spin * slow * iu;\n  out[0] = -gy * f + S.kap * (x - CX);\n  out[1] = gx * f + S.kap * (y - CY);\n  out[2] = gx; out[3] = gy;\n  return out;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.truth = cl(kv[3], 0, 1);\n  const deg = cl(kv[2], 28, 100);\n  let fresh = false;\n  if (abs(deg - S.deg) > 0.05) { solve(S, deg); fresh = true; }\n  // The dive: one eddy grows into the next one's place every T seconds.\n  const T = (3 * sqrt(log(S.rho) / log(2))) / (S.speed / 2);\n  const om = PI / T;\n  S.kap = om / S.mu;\n  // A loop takes about 3.2 / (spin mu^2) s, measured from 28 to 100 degrees.\n  S.spin = (0.65 * S.speed) / (S.mu * S.mu);\n  S.phi -= om * d;\n  if (S.phi \u003c -2 * PI) { S.phi += 2 * PI; for (let i = 0; i \u003c NP; i++) S.pk[i] += 2; }\n  if (fresh) for (let i = 0; i \u003c NP; i++) spawn(S, i, false);\n  const v = [0, 0, 0, 0], v2 = [0, 0, 0, 0], q = S.q;\n  for (let i = 0; i \u003c NP; i++) {\n    if (S.pu[i] \u003c 0) { spawn(S, i, true); continue; }\n    let x = S.px[i], y = S.py[i];\n    const k = S.pk[i], iu = 1 / S.pu[i]; // eddies keep their index as the field slides\n    vel(S, x, y, k, iu, v);\n    const sp = hypot(v[0], v[1]) * d, r = hypot(x - CX, y - CY);\n    const n = max(1, min(8, Math.ceil(sp / max(0.3, 0.08 * r))));\n    const h = d / n;\n    for (let s = 0; s \u003c n; s++) {\n      vel(S, x, y, k, iu, v);\n      vel(S, x + 0.5 * h * v[0], y + 0.5 * h * v[1], k, iu, v2);\n      x += h * v2[0]; y += h * v2[1];\n    }\n    // Back onto the stream line it started on.\n    field(S, x, y, q);\n    if (q.inside && q.k === k) {\n      vel(S, x, y, k, iu, v);\n      const g2 = v[2] * v[2] + v[3] * v[3], e = exp(q.lu) - S.pu[i];\n      if (g2 > 1e-9) { x -= (e * v[2]) / g2; y -= (e * v[3]) / g2; }\n    }\n    field(S, x, y, q);\n    const gone = exp((k * PI + PI / 2 - S.phi) / S.mu) > 135;\n    if (!q.inside || q.k !== k || gone) { spawn(S, i, true); continue; }\n    S.px[i] = x; S.py[i] = y;\n  }\n  // Trails ride the dive with their tracers.\n  const g = exp(S.kap * d);\n  for (let n = 0; n \u003c NP * TL; n++) { S.tx[n] = CX + (S.tx[n] - CX) * g; S.ty[n] = CY + (S.ty[n] - CY) * g; }\n  S.tick += d;\n  if (S.tick > 1 / 30) {\n    S.tick = 0;\n    for (let i = 0; i \u003c NP; i++) {\n      for (let n = TL - 1; n > 0; n--) { S.tx[i * TL + n] = S.tx[i * TL + n - 1]; S.ty[i * TL + n] = S.ty[i * TL + n - 1]; }\n      S.tx[i * TL] = S.px[i]; S.ty[i * TL] = S.py[i];\n    }\n  }\n}\n\nfunction splat(rgb, x, y, r, g, b) {\n  const x0 = floor(x - 0.5), y0 = floor(y - 0.5), fx = x - 0.5 - x0, fy = y - 0.5 - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = x0 + i, Y = y0 + j;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const w = (i ? fx : 1 - fx) * (j ? fy : 1 - fy), p = (Y * W + X) * 3;\n      rgb[p] = max(rgb[p], r * w * 1.6); rgb[p + 1] = max(rgb[p + 1], g * w * 1.6); rgb[p + 2] = max(rgb[p + 2], b * w * 1.6);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.deg) return;\n  const rgb = S.rgb, q = S.q, c = S.col;\n  // Two hues apart on a wheel from green to pink, without the red, orange and\n  // yellow that read brown when dim: teal and violet at 0.\n  const hA = 0.3 + 0.64 * frac(0.266 + S.hue), hB = 0.3 + 0.64 * frac(0.781 + S.hue);\n  const K = S.K, LU = S.LU, TH = S.TH, DM = S.DM;\n  const top = log(124), span = S.c * PI, deep = 3 * log(10);\n  const lev = (lu) => (lu > -0.3 ? 0 : lu > -1 ? 1 : lu > -2.1 ? 2 : lu > -3.6 ? 3 : lu > -5.6 ? 4 : 5);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      field(S, x + 0.5, y + 0.5, q);\n      if (!q.inside) { K[p] = -1e9; continue; }\n      K[p] = q.k; LU[p] = q.lu; TH[p] = PI / q.gc;\n      // Truth: how far the real speed in this eddy sits below the speed in an\n      // eddy whose outer edge is at the top of the panel, over three decades.\n      const o = (S.a - 1) * min(0, (q.k * PI + 1.5 * PI - S.phi) / S.mu - top);\n      DM[p] = cl(1 + (S.truth * o) / deep, 0, 1);\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3;\n      if (K[p] === -1e9) {\n        const dx = x + 0.5 - CX, dy = CY - y - 0.5, r = hypot(dx, dy);\n        const e = abs(atan2(dx, dy)) - S.al, dw = r * sin(e), sw = r * cos(e);\n        // The solid: the wall line and a band of hatching behind it.\n        const hm = dw \u003c 6 && ((sw + dw) % 4 + 4) % 4 \u003c 1 ? 0.2 * (1 - dw / 6) : 0;\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = max(cl(1 - dw, 0, 1) * 0.5, hm);\n        continue;\n      }\n      const k = K[p], lu = LU[p], th = TH[p], dm = DM[p];\n      const b = cl(1 + lu / span, 0, 1);\n      const hue = k & 1 ? hB : hA;\n      let sep = 0, ring = 0;\n      const n = lev(lu);\n      for (let e = 0; e \u003c 4; e++) {\n        const X = x + (e === 0 ? 1 : e === 1 ? -1 : 0), Y = y + (e === 2 ? 1 : e === 3 ? -1 : 0);\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const pp = Y * W + X;\n        if (K[pp] === -1e9) continue;\n        if (K[pp] !== k) sep = 1;\n        else if (n \u003c 5 && lev(LU[pp]) > n) ring = 1;\n      }\n      sep *= cl((th - 2) / 4, 0, 1);\n      ring *= cl((th - 8) / 10, 0, 1);\n      hsv(hue, 0.9 - 0.35 * ring, dm * (0.12 + 0.25 * b + 0.5 * ring), c);\n      const dx = x + 0.5 - CX, dy = CY - y - 0.5, r = hypot(dx, dy);\n      const dw = r * sin(S.al - abs(atan2(dx, dy))), wl = cl(1 - dw, 0, 1) * 0.5;\n      const sv = sep * (0.35 + 0.55 * dm);\n      rgb[o] = max(c[0] + sv, wl); rgb[o + 1] = max(c[1] + sv, wl); rgb[o + 2] = max(c[2] + sv, wl);\n    }\n  for (let i = 0; i \u003c NP; i++) {\n    if (S.pu[i] \u003c 0) continue;\n    const dm = cl(1 + (S.truth * (S.a - 1) * min(0, (S.pk[i] * PI + 1.5 * PI - S.phi) / S.mu - top)) / deep, 0, 1);\n    for (let n = TL - 1; n > 0; n--) {\n      const b = dm * 0.7 * (1 - n / TL);\n      splat(rgb, S.tx[i * TL + n], S.ty[i * TL + n], b, b, b);\n    }\n    const X = floor(S.px[i]), Y = floor(S.py[i]);\n    if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) { const o = (Y * W + X) * 3; rgb[o] = rgb[o + 1] = rgb[o + 2] = max(rgb[o], dm); }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, floor(cl(rgb[o], 0, 1) * 255), floor(cl(rgb[o + 1], 0, 1) * 255), floor(cl(rgb[o + 2], 0, 1) * 255));\n  }\n}\n","simpson-paradox":"// ===== Patternflow pattern =====\n// Title:   Simpson's Paradox\n// Family:  data\n// Idea:    Three to five coloured clouds of points each rise to the right along their own least-squares line while the groups slide up and down like a seesaw, so the white least-squares line through all the points together swings through level and falls, and a slope gauge at the foot keeps every group's bar on the plus side while the pooled bar crosses to minus.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Simpson's paradox (Edward H. Simpson, 1951; named by Colin R. Blyth, 1972), after associations that vanish on pooling (Karl Pearson, 1899; G. Udny Yule, 1903), ordinary least squares (Adrien-Marie Legendre, 1805), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Groups=3..5, Spread=0..1\n//\n// Knob 1: Hue. Turns the groups' colours round the wheel together. At 0 three groups are amber, sea green and violet, four amber, green, blue and pink, five amber, green, cyan, violet and pink; the pooled line, its bar and the zero mark stay white whatever the knob.\n// Knob 2: Speed. At 2 one seesaw takes 12 s: the groups hold in the reversed order for 2 s, slide for 4 s, hold in agreement for 2 s and slide back for 4 s, and the pooled slope crosses zero near 3.6 s and 9.5 s of the first round. The points wander inside their groups on the same clock. At 0.2 one seesaw takes 120 s, at 3 it takes 8 s.\n// Knob 3: Groups. 3, 4 or 5 groups of 48, 38 or 30 points. Every group's own slope is 1.5 by construction, while the line through the group means tilts from -1.5 to +1.2; the fitted pooled slope ran from -1.33 to +1.30 with three groups and from -1.44 to +1.24 with five, and crosses zero where that tilt is -1.5 W / B, W the variance of x inside a group and B the variance of the group means: -0.14 for three groups, -0.09 for four, -0.06 for five.\n// Knob 4: Spread. The scatter of each point about its group's line, 5 LEDs at 0 and 11.5 at 1 with three groups, less with more groups as they get narrower. The groups' fitted slopes shiver more on the gauge: at the opening 0.06 they stayed between 0.97 and 2.08 over ten minutes, at 1 between 0.12 and 3.00 over an hour, never below zero. The pooled slope hardly moves, as scatter inside the groups adds nothing to the tilt between them.\n\nconst W = 64, H = 128;\n// The plot fills rows 0..107; the slope gauge sits in rows 110..127.\nconst PH = 108, GY = 110;\nconst { floor, round, min, max, abs, sqrt, exp, cos, log, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nfunction gauss() {\n  let u = random();\n  while (u \u003c 1e-12) u = random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * random());\n}\n\n// Inside a group a point sits at x = cx + HX u and y = cy + SLOPE HX u + sigma e,\n// so the group's own trend is SLOPE (rows per column, y counted upward).\nconst SLOPE = 1.5;\n// The group centres stand at fixed columns, SX either side of the middle,\n// and their heights follow a tilt MB that the seesaw sweeps.\nconst SX = 21, YC = PH / 2;\nconst MB_LO = -1.5, MB_HI = 1.2;\n// The seesaw, in seconds at Speed 2.\nconst HOLD_LO = 2, GLIDE = 4, HOLD_HI = 2, CYCLE = HOLD_LO + GLIDE + HOLD_HI + GLIDE;\nconst NPTS = [0, 0, 0, 48, 38, 30];\n\nexport function setup(params) {\n  params.s = {\n    G: 0, n: 0, gi: [], home: [], w: [], e: [], x: [], y: [],\n    t: 0.4, mb: MB_LO, hue: 0, spread: 0,\n    fit: [], pooled: { b: 0, a: 0 }, sign: -1, flash: 0,\n    buf: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\nfunction populate(S, G) {\n  S.G = G;\n  const per = NPTS[G];\n  S.n = G * per;\n  S.gi = []; S.home = []; S.w = []; S.e = []; S.x = new Float64Array(S.n); S.y = new Float64Array(S.n);\n  for (let g = 0; g \u003c G; g++)\n    for (let i = 0; i \u003c per; i++) {\n      S.gi.push(g);\n      // Stratified along the group so every cloud covers its width.\n      S.home.push(-1 + (2 * (i + random())) / per);\n      S.w.push(0.12 * gauss());\n      S.e.push(gauss());\n    }\n  S.fit = [];\n  for (let g = 0; g \u003c G; g++) S.fit.push({ b: SLOPE, a: 0, x0: 0, x1: 0, mx: 0, my: 0 });\n}\n\nfunction tilt(t) {\n  t = t % CYCLE;\n  if (t \u003c HOLD_LO) return MB_LO;\n  t -= HOLD_LO;\n  if (t \u003c GLIDE) return MB_LO + (MB_HI - MB_LO) * ease(t / GLIDE);\n  t -= GLIDE;\n  if (t \u003c HOLD_HI) return MB_HI;\n  t -= HOLD_HI;\n  return MB_HI + (MB_LO - MB_HI) * ease(t / GLIDE);\n}\n\n// Ordinary least squares of y on x over the points whose group passes keep.\nfunction ols(S, keep, out) {\n  let n = 0, sx = 0, sy = 0;\n  for (let i = 0; i \u003c S.n; i++) if (keep(S.gi[i])) { n++; sx += S.x[i]; sy += S.y[i]; }\n  const mx = sx / n, my = sy / n;\n  let sxx = 0, sxy = 0, lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c S.n; i++)\n    if (keep(S.gi[i])) {\n      const dx = S.x[i] - mx;\n      sxx += dx * dx;\n      sxy += dx * (S.y[i] - my);\n      lo = min(lo, S.x[i]);\n      hi = max(hi, S.x[i]);\n    }\n  out.b = sxy / sxx;\n  out.a = my - out.b * mx;\n  out.mx = mx; out.my = my; out.x0 = lo; out.x1 = hi;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  const G = round(cl(k[2], 3, 5));\n  S.spread = cl(k[3], 0, 1);\n  if (G !== S.G) populate(S, G);\n  S.t += tau;\n  S.mb = tilt(S.t);\n  // The points wander inside their groups on Ornstein-Uhlenbeck walks: the\n  // scatter e keeps variance 1, and the offset w from a point's home along\n  // the group keeps a deviation of 0.12 of the half-width.\n  const th = 0.5, de = sqrt(2 * th * tau);\n  for (let i = 0; i \u003c S.n; i++) {\n    S.w[i] += -th * S.w[i] * tau + 0.12 * de * gauss();\n    S.e[i] += -th * S.e[i] * tau + de * gauss();\n  }\n  const half = (G - 1) / 2, HX = min(9, (0.47 * 2 * SX) / (G - 1));\n  // The scatter shrinks faster than the groups' width, so that over an hour\n  // at the widest spread no group's fitted slope fell below 0.12.\n  const sigma = (5 + 6.5 * S.spread) * (HX / 9) ** 1.5;\n  for (let i = 0; i \u003c S.n; i++) {\n    const kg = (S.gi[i] - half) / half, cx = W / 2 + SX * kg, cy = YC + S.mb * SX * kg;\n    const u = cl(S.home[i] + S.w[i], -1, 1);\n    S.x[i] = cx + HX * u;\n    S.y[i] = cy + SLOPE * HX * u + sigma * S.e[i];\n  }\n  for (let g = 0; g \u003c G; g++) ols(S, (j) => j === g, S.fit[g]);\n  ols(S, () => true, S.pooled);\n  const sign = S.pooled.b >= 0 ? 1 : -1;\n  if (sign !== S.sign) S.flash = 1;\n  S.sign = sign;\n  S.flash = max(0, S.flash - d / 0.6);\n}\n\nfunction groupHue(S, g) {\n  return S.hue + 0.12 + (S.G === 3 ? g * 0.3 : (g * 0.8) / (S.G - 1));\n}\n\n// Add a line y = a + b x (y upward in plot rows) between columns x0 and x1,\n// anti-aliased, width w, colour c times v, into the buffer with max blending.\nfunction line(buf, a, b, x0, x1, w, c, v) {\n  const nrm = sqrt(1 + b * b), r = w / 2 + 0.5;\n  for (let py = 0; py \u003c PH; py++) {\n    const yu = PH - 1 - py;\n    // Columns where the line passes within r of this row.\n    const xa = b === 0 ? -1 : (yu - a) / b, span = (r * nrm) / max(abs(b), 1e-6);\n    let lo = b === 0 ? 0 : floor(xa - span), hi = b === 0 ? W - 1 : Math.ceil(xa + span);\n    lo = max(lo, 0, floor(x0));\n    hi = min(hi, W - 1, Math.ceil(x1));\n    for (let x = lo; x \u003c= hi; x++) {\n      const dd = abs(b * x - yu + a) / nrm;\n      let f = cl(r - dd, 0, 1);\n      // Soft ends.\n      f *= cl(x - x0 + 1, 0, 1) * cl(x1 - x + 1, 0, 1);\n      if (f \u003c= 0) continue;\n      const p = (py * W + x) * 3;\n      for (let j = 0; j \u003c 3; j++) buf[p + j] = max(buf[p + j], c[j] * v * f);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.G) return;\n  const buf = S.buf, c = S.c, white = [1, 1, 1];\n  buf.fill(0);\n  // A faint wash round each point in its group's colour.\n  for (let i = 0; i \u003c S.n; i++) {\n    hsv(groupHue(S, S.gi[i]), 0.85, 1, c);\n    const X = S.x[i], Y = PH - 1 - S.y[i];\n    for (let dy = -2; dy \u003c= 2; dy++)\n      for (let dx = -2; dx \u003c= 2; dx++) {\n        const x = round(X) + dx, y = round(Y) + dy;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= PH) continue;\n        const r2 = (x - X) * (x - X) + (y - Y) * (y - Y), f = 0.12 * exp(-r2 / 3);\n        const p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) buf[p + j] = min(0.3, buf[p + j] + c[j] * f);\n      }\n  }\n  // Each group's own line, pale, across its points and faintly beyond.\n  for (let g = 0; g \u003c S.G; g++) {\n    const f = S.fit[g];\n    hsv(groupHue(S, g), 0.45, 1, c);\n    line(buf, f.a, f.b, 0, W - 1, 0.9, c, 0.13);\n    line(buf, f.a, f.b, f.x0 - 1, f.x1 + 1, 1.0, c, 0.75);\n  }\n  // The pooled line, white, thicker for a moment when its sign turns.\n  line(buf, S.pooled.a, S.pooled.b, 0, W - 1, 1.5 + 1.5 * S.flash, white, 1);\n  // Each group's mean as a small pale cross on its line.\n  for (let g = 0; g \u003c S.G; g++) {\n    const f = S.fit[g], X = round(f.mx), Y = round(PH - 1 - f.my);\n    hsv(groupHue(S, g), 0.3, 1, c);\n    for (let a = -2; a \u003c= 2; a++)\n      for (const [x, y] of [[X + a, Y], [X, Y + a]]) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= PH) continue;\n        const p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) buf[p + j] = c[j];\n      }\n  }\n  // The points on top, one LED each in full colour.\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = round(S.x[i]), y = round(PH - 1 - S.y[i]);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= PH) continue;\n    hsv(groupHue(S, S.gi[i]), 0.9, 1, c);\n    const p = (y * W + x) * 3;\n    buf[p] = c[0]; buf[p + 1] = c[1]; buf[p + 2] = c[2];\n  }\n  // The gauge: one bar per group and the pooled bar in white, from the zero\n  // mark in column 31, 16 LEDs per unit of slope, plus to the right.\n  const bars = S.G + 1, th = bars \u003c= 4 ? 3 : 2, gap = 1;\n  const top = GY + floor((H - GY - (bars * th + (bars - 1) * gap)) / 2);\n  for (let r = 0; r \u003c bars; r++) {\n    const pooled = r === S.G, b = pooled ? S.pooled.b : S.fit[r].b;\n    if (pooled) c[0] = c[1] = c[2] = 1;\n    else hsv(groupHue(S, r), 0.8, 1, c);\n    const len = cl(b * 16, -31, 31), y0 = top + r * (th + gap);\n    const xa = 32 + min(0, len), xb = 32 + max(0, len);\n    for (let y = y0; y \u003c y0 + th; y++)\n      for (let x = floor(xa); x \u003c Math.ceil(xb); x++) {\n        if (x \u003c 0 || x >= W) continue;\n        const f = cl(min(x + 1 - xa, xb - x), 0, 1) * (pooled ? 1 : 0.85);\n        const p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) buf[p + j] = c[j] * f;\n      }\n  }\n  for (let y = GY - 1; y \u003c H; y++) {\n    const p = (y * W + 31) * 3;\n    for (let j = 0; j \u003c 3; j++) buf[p + j] = max(buf[p + j], 0.35);\n  }\n  for (let p = 0, i = 0; p \u003c W * H; p++, i += 3)\n    display.setPixel(p & 63, p >> 6, round(cl(buf[i], 0, 1) * 255), round(cl(buf[i + 1], 0, 1) * 255), round(cl(buf[i + 2], 0, 1) * 255));\n}\n","trip-let":"// ===== Patternflow pattern =====\n// Title:   Trip-let\n// Family:  type\n// Idea:    A block carved as the intersection of three extruded letters turns in a slanting beam of light, a third of a turn at a time about its own diagonal, and each time one of its axes comes round to the beam the long shadow it throws across the floor stops being a lump and becomes a whole letter, G, then E, then B.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the trip-let of Gödel, Escher, Bach (Douglas Hofstadter, 1979), letters drawn for this pattern, pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Letters=0..5, Haze=0..1\n//\n// Knob 1: Hue. Turns the three lights round the wheel together. At 0 the beam is a pale azure white, so the pool on the floor is pale blue and the letter in it deep violet, and the block's faces take a violet light from the front left and a pink one from the right; at 0.5 the beam is pale peach and the block yellow-green.\n// Knob 2: Speed. At 2 the block holds each lined-up pose 1.6 s and takes 2.4 s over the next third of a turn, so the three letters come round every 12 s. At 0.2 a letter holds 16 s, at 3 a whole round takes 8 s.\n// Knob 3: Letters. Which block hangs in the beam: 0 GEB, 1 EGB (the cover's second block), 2 LED, 3 SUN, 4 ONE, 5 SEE, carved from 235, 240, 150, 182, 200 and 216 of the 512 voxels. Each was checked with all three letters whole in its shadow; with these glyphs YES, EYE, LUX, FUN and HUE are not, and LED only became whole once the right side of the D was carried down into its second row from the bottom.\n// Knob 4: Haze. Dust in the air, so the beam shows: the sky above the block reads 31/255 at the opening 0.06, 91 at 0.5 and 159 at 1, with the dark column of the shadow running from the block down to its letter.\n\n// The block is built from the letters and the shadows are cast from the\n// block: each frame a shadow map is marched through the voxels along the\n// beam, and the floor and the haze are lit or not from that map alone.\n// Read back at the 18 lined-up poses, each map matches its letter, scaled\n// to four texels a cell, on all 3600 texels, and the floor shows it as a\n// 32 x 32 LED letter, four LEDs a cell, without one LED wrong.\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, PI } = Math;\nconst N = 8, U = 4, HALFB = (N * U) / 2;\n// Camera: orthographic, looking down at EL. The light comes from behind the\n// block, ALPHA from straight up, at the same elevation as the camera, which\n// is what lets the long shadow read on the panel at its true shape.\nconst EL = (35 * PI) / 180, SE = sin(EL), CE = cos(EL);\nconst ALPHA = PI / 2 - EL, SA = sin(ALPHA), CA = cos(ALPHA);\n// The block's centre hangs HB above the floor, 39.07 units, chosen so that\n// at the lined-up poses every texel of the shadow lands on one LED.\nconst HB = 32 / SA;\nconst YC = 64; // screen row of the point of the floor under the block\nconst RP = 30; // radius of the beam\nconst MS = 2 * RP; // shadow map texels a side, one world unit each\nconst WFAR = 80; // where the map's lines of light start, below the block\n\n// 8x8 letters, rows from the top, bit 7 the left column.\nconst GLYPHS = {\n  G: [0x7e, 0xff, 0xc0, 0xcf, 0xcf, 0xc3, 0xff, 0x7e],\n  E: [0xff, 0xff, 0xc0, 0xfc, 0xfc, 0xc0, 0xff, 0xff],\n  B: [0xfe, 0xff, 0xc3, 0xfe, 0xfe, 0xc3, 0xff, 0xfe],\n  L: [0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xff, 0xff],\n  D: [0xfe, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xfe],\n  S: [0x7f, 0xff, 0xc0, 0xfe, 0x7f, 0x03, 0xff, 0xfe],\n  U: [0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0x7e],\n  N: [0xc3, 0xe3, 0xf3, 0xdb, 0xdb, 0xcf, 0xc7, 0xc3],\n  O: [0x7e, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0x7e],\n};\nconst WORDS = [\"GEB\", \"EGB\", \"LED\", \"SUN\", \"ONE\", \"SEE\"];\n\nconst lit = (ch, h, v) => (GLYPHS[ch][N - 1 - v] >> (N - 1 - h)) & 1;\n\n// The block: voxel (x, y, z) is solid when all three letters are lit where\n// it falls. Letter 0 is seen along x (h = y, v = z), letter 1 along y\n// (h = z, v = x), letter 2 along z (h = x, v = y).\nfunction carve(S, word) {\n  const vox = S.vox;\n  for (let x = 0; x \u003c N; x++)\n    for (let y = 0; y \u003c N; y++)\n      for (let z = 0; z \u003c N; z++)\n        vox[(x * N + y) * N + z] = lit(word[0], y, z) & lit(word[1], z, x) & lit(word[2], x, y);\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\nexport function setup(params) {\n  params.s = {\n    vox: new Uint8Array(N * N * N),\n    word: -1,\n    phase: 0,\n    R: new Float64Array(9),\n    top: new Float32Array(MS * MS),\n    hit: [0, 0],\n    key: [0, 0, 0],\n    fill: [0, 0, 0],\n    side: [0, 0, 0],\n  };\n}\n\nconst ease = (f) => f * f * f * (f * (f * 6 - 15) + 10);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = k[1];\n  S.haze = k[3];\n  const w = max(0, min(WORDS.length - 1, Math.round(k[2])));\n  if (w !== S.word) {\n    S.word = w;\n    carve(S, WORDS[w]);\n  }\n  S.phase += (dt * S.speed) / 8;\n  // A third of a turn about the block's diagonal at each step, so its axes\n  // come round x -> light, y -> light, z -> light: letter 0, 1, 2 in turn.\n  const step = floor(S.phase), f = S.phase - step;\n  const HOLD = 0.4;\n  const g = f \u003c HOLD ? 0 : ease((f - HOLD) / (1 - HOLD));\n  const th = (-2 * PI / 3) * (1 + step + g);\n  const c = cos(th), s = sin(th), t = 1 - c, a = 1 / sqrt(3);\n  // Rodrigues about (a, a, a): D maps x -> y -> z -> x at th = 2 pi / 3.\n  const d0 = c + a * a * t, d1 = a * a * t - a * s, d2 = a * a * t + a * s;\n  // Then T, whose columns are x, (0, CA, -SA) and (0, SA, CA), tilts z\n  // towards the light.\n  // R = T D, rows of D: [d0 d1 d2], [d2 d0 d1], [d1 d2 d0].\n  const R = S.R;\n  R[0] = d0; R[1] = d1; R[2] = d2;\n  R[3] = CA * d2 + SA * d1; R[4] = CA * d0 + SA * d2; R[5] = CA * d1 + SA * d0;\n  R[6] = -SA * d2 + CA * d1; R[7] = -SA * d0 + CA * d2; R[8] = -SA * d1 + CA * d0;\n}\n\n// Amanatides-Woo through the voxel grid from grid point (ox, oy, oz) along\n// (dx, dy, dz). Returns the entry t of the first solid voxel, its face in\n// S.hit as axis and sign, or -1. With last it returns the exit t of the last\n// solid voxel instead.\nfunction march(S, ox, oy, oz, dx, dy, dz, last) {\n  let t0 = -1e9, t1 = 1e9, ax = -1;\n  const E = 1e-12;\n  if (abs(dx) \u003c E) { if (ox \u003c 0 || ox > N) return -1; }\n  else { let a = -ox / dx, b = (N - ox) / dx; if (a > b) { const q = a; a = b; b = q; } if (a > t0) { t0 = a; ax = 0; } if (b \u003c t1) t1 = b; }\n  if (abs(dy) \u003c E) { if (oy \u003c 0 || oy > N) return -1; }\n  else { let a = -oy / dy, b = (N - oy) / dy; if (a > b) { const q = a; a = b; b = q; } if (a > t0) { t0 = a; ax = 1; } if (b \u003c t1) t1 = b; }\n  if (abs(dz) \u003c E) { if (oz \u003c 0 || oz > N) return -1; }\n  else { let a = -oz / dz, b = (N - oz) / dz; if (a > b) { const q = a; a = b; b = q; } if (a > t0) { t0 = a; ax = 2; } if (b \u003c t1) t1 = b; }\n  if (t0 > t1 || t1 \u003c 0) return -1;\n  let t = max(t0, 0);\n  const te = t + 1e-6;\n  let ix = floor(ox + dx * te), iy = floor(oy + dy * te), iz = floor(oz + dz * te);\n  ix = ix \u003c 0 ? 0 : ix >= N ? N - 1 : ix;\n  iy = iy \u003c 0 ? 0 : iy >= N ? N - 1 : iy;\n  iz = iz \u003c 0 ? 0 : iz >= N ? N - 1 : iz;\n  const sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, sz = dz > 0 ? 1 : -1;\n  const ddx = abs(dx) \u003c E ? 1e9 : abs(1 / dx), ddy = abs(dy) \u003c E ? 1e9 : abs(1 / dy), ddz = abs(dz) \u003c E ? 1e9 : abs(1 / dz);\n  let mx = abs(dx) \u003c E ? 1e9 : ((dx > 0 ? ix + 1 : ix) - ox) / dx;\n  let my = abs(dy) \u003c E ? 1e9 : ((dy > 0 ? iy + 1 : iy) - oy) / dy;\n  let mz = abs(dz) \u003c E ? 1e9 : ((dz > 0 ? iz + 1 : iz) - oz) / dz;\n  const vox = S.vox;\n  let found = -1;\n  for (;;) {\n    if (vox[(ix * N + iy) * N + iz]) {\n      if (!last) { S.hit[0] = ax; S.hit[1] = ax === 0 ? -sx : ax === 1 ? -sy : -sz; return t; }\n      found = min(mx, my, mz);\n    }\n    if (mx \u003c= my && mx \u003c= mz) { ix += sx; t = mx; mx += ddx; ax = 0; if (ix \u003c 0 || ix >= N) break; }\n    else if (my \u003c= mz) { iy += sy; t = my; my += ddy; ax = 1; if (iy \u003c 0 || iy >= N) break; }\n    else { iz += sz; t = mz; mz += ddz; ax = 2; if (iz \u003c 0 || iz >= N) break; }\n  }\n  return found;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const R = S.R, top = S.top;\n  const key = S.key, fill = S.fill, side = S.side;\n  hsv(S.hue + 0.55, 0.16, 1.25, key);\n  hsv(S.hue + 0.71, 0.62, 1, fill);\n  hsv(S.hue + 0.9, 0.5, 1, side);\n  // world (relative to the block's centre) -> grid\n  const gx = (x, y, z) => (R[0] * x + R[3] * y + R[6] * z) / U + N / 2;\n  const gy = (x, y, z) => (R[1] * x + R[4] * y + R[7] * z) / U + N / 2;\n  const gz = (x, y, z) => (R[2] * x + R[5] * y + R[8] * z) / U + N / 2;\n  // beam frame: eu = x, ev = (0, CA, -SA), eL = (0, SA, CA) towards the light\n  const Ly = SA, Lz = CA;\n  const lgx = (R[3] * Ly + R[6] * Lz) / U, lgy = (R[4] * Ly + R[7] * Lz) / U, lgz = (R[5] * Ly + R[8] * Lz) / U;\n  // Shadow map over the beam's cross-section: how far along eL the block\n  // reaches on each line of light (-1e9 where the line misses it).\n  for (let j = 0; j \u003c MS; j++)\n    for (let i = 0; i \u003c MS; i++) {\n      const u = i - RP + 0.5, v = j - RP + 0.5;\n      const x = u, y = v * CA - WFAR * SA, z = -v * SA - WFAR * CA;\n      const t = march(S, gx(x, y, z), gy(x, y, z), gz(x, y, z), lgx, lgy, lgz, true);\n      top[j * MS + i] = t \u003c 0 ? -1e9 : t - WFAR;\n    }\n  const lit3 = (x, y, z) => {\n    // x, y, z relative to the block's centre\n    const v = y * CA - z * SA, w = y * SA + z * CA;\n    const i = floor(x + RP), j = floor(v + RP);\n    if (i \u003c 0 || j \u003c 0 || i >= MS || j >= MS) return 1;\n    return top[j * MS + i] > w ? 0 : 1;\n  };\n  // camera: forward f = (0, CE, -SE), up = (0, SE, CE), right = x\n  const fy = CE, fz = -SE;\n  const cgx = (R[3] * fy + R[6] * fz) / U, cgy = (R[4] * fy + R[7] * fz) / U, cgz = (R[5] * fy + R[8] * fz) / U;\n  // two fills without shadows: the sky from the front left, a weaker one from the right\n  const AX = -0.62, AY = -0.62, AZ = 0.48, BX = 0.85, BY = -0.35, BZ = 0.4;\n  const al = 1 / Math.hypot(AX, AY, AZ), bl = 1 / Math.hypot(BX, BY, BZ);\n  const hazeK = 0.0012 + 0.007 * S.haze;\n  for (let py = 0; py \u003c H; py++) {\n    const Y = YC - (py + 0.5);\n    for (let px = 0; px \u003c W; px++) {\n      const X = px + 0.5 - W / 2;\n      // the ray through this LED, relative to the block's centre\n      const cx = X, cy = Y * SE, cz = Y * CE - HB;\n      let r = 0, g = 0, b = 0;\n      const tc = -(cy * fy + cz * fz);\n      const ex = cx, ey = cy + fy * tc, ez = cz + fz * tc;\n      let tBlock = 1e9;\n      if (ex * ex + ey * ey + ez * ez \u003c HALFB * HALFB * 3) {\n        const t0 = tc - 2 * HALFB;\n        const ox = cx, oy = cy + fy * t0, oz = cz + fz * t0;\n        const tt = march(S, gx(ox, oy, oz), gy(ox, oy, oz), gz(ox, oy, oz), cgx, cgy, cgz, false);\n        if (tt >= 0) {\n          tBlock = t0 + tt;\n          const ax = S.hit[0], sg = S.hit[1];\n          const nx = R[ax] * sg, ny = R[3 + ax] * sg, nz = R[6 + ax] * sg;\n          const hx = cx, hy = cy + fy * tBlock, hz = cz + fz * tBlock;\n          let kl = max(0, ny * Ly + nz * Lz);\n          if (kl > 0) {\n            const q = 0.05;\n            const qx = hx + nx * q, qy = hy + ny * q, qz = hz + nz * q;\n            if (march(S, gx(qx, qy, qz), gy(qx, qy, qz), gz(qx, qy, qz), lgx, lgy, lgz, false) >= 0) kl = 0;\n          }\n          const fa = max(0, (nx * AX + ny * AY + nz * AZ) * al), fb = max(0, (nx * BX + ny * BY + nz * BZ) * bl);\n          r = key[0] * kl + fill[0] * (0.05 + 0.7 * fa) + side[0] * 0.35 * fb;\n          g = key[1] * kl + fill[1] * (0.05 + 0.7 * fa) + side[1] * 0.35 * fb;\n          b = key[2] * kl + fill[2] * (0.05 + 0.7 * fa) + side[2] * 0.35 * fb;\n        }\n      }\n      // floor: world z = 0, which is z = -HB here\n      const tf = (cz + HB) / SE;\n      if (tBlock > 1e8) {\n        const wx = cx, wy = cy + fy * tf;\n        if (abs(wx) \u003c= W / 2 && wy \u003c 40 && wy > -110) {\n          const v = wy * CA + HB * SA;\n          const rr = sqrt(wx * wx + v * v);\n          const pool = rr \u003c RP - 0.5 ? 1 : rr > RP + 0.5 ? 0 : RP + 0.5 - rr;\n          const kk = pool > 0 ? pool * lit3(wx, wy, -HB) * CA : 0;\n          const ff = 0.12;\n          r = key[0] * kk + fill[0] * ff;\n          g = key[1] * kk + fill[1] * ff;\n          b = key[2] * kk + fill[2] * ff;\n        }\n      }\n      // haze in the beam, in front of whatever the ray meets\n      if (abs(cx) \u003c RP) {\n        const hw = sqrt(RP * RP - cx * cx);\n        const v0 = cy * CA - cz * SA, dv = fy * CA - fz * SA;\n        let ta = (-hw - v0) / dv, tb = (hw - v0) / dv;\n        if (ta > tb) { const q = ta; ta = tb; tb = q; }\n        tb = min(tb, tf, tBlock);\n        ta = max(ta, -200);\n        if (tb > ta) {\n          const n = 16, dtt = (tb - ta) / n;\n          let acc = 0;\n          for (let i = 0; i \u003c n; i++) {\n            const t = ta + (i + 0.5) * dtt;\n            acc += lit3(cx, cy + fy * t, cz + fz * t);\n          }\n          const hz = acc * dtt * hazeK;\n          r += key[0] * hz; g += key[1] * hz; b += key[2] * hz;\n        }\n      }\n      display.setPixel(px, py, min(255, r * 255), min(255, g * 255), min(255, b * 255));\n    }\n  }\n}\n","type-mosaic":"// ===== Patternflow pattern =====\n// Title:   Type Mosaic\n// Family:  type\n// Idea:    A word is spelled one big raised letter at a time on the faces of a turning four-sided prism, lit by a lamp that circles it, and the whole picture is set in small 3 by 5 letters, digits and signs, each cell taking the glyph whose ink matches the brightness there.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Studies in Perception I (Kenneth Knowlton and Leon Harmon, 1966), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Cell=0..2\n//\n// Knob 1: Hue. Turns the type round the wheel, skipping red-orange to orange, which reads brown when dim. At 0 the letters alternate cyan and pink face by face, their brightest glyphs nearly white, on a face of dim violet dots.\n// Knob 2: Speed. At 2 a letter holds 2.2 s and the prism turns a quarter in 0.8 s, so TYPE takes 12 s; the lamp goes round once in 10 s, and each small glyph gives way to another of the same ink every 2.2 to 6.7 s. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Word. The word the prism spells: TYPE at 0, then INK, 1966, LOOK and BELL at 4.\n// Knob 4: Cell. The size of the small type. At 0 each glyph has a cell of 4 by 6 LEDs, 336 of them on a 16 by 21 grid; at 1 a cell of 5 by 8, 192 glyphs; at 2 the glyphs are drawn double, 6 by 10 in cells of 7 by 11, and the big letter is set in 99 of them, where the small type reads first and the big letter second.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The small type: a 3 by 5 face drawn for this pattern, rows top to bottom,\n// capitals and a few lower case letters with their bowls in the bottom three\n// rows. Each glyph's ink is its number of lit dots, 1 to 13 of 15.\nconst SMALL = {\n  \".\": \"000000000000010\", \",\": \"000000000010100\", \":\": \"000010000010000\", \"'\": \"010010000000000\",\n  \"-\": \"000000111000000\", \"^\": \"010101000000000\", \"_\": \"000000000000111\", \";\": \"000010000010100\",\n  '\"': \"101101000000000\", \"!\": \"010010010000010\", \"~\": \"000011110000000\",\n  \"+\": \"000010111010000\", x: \"000101010101000\", \"/\": \"001001010100100\", \"\u003c\": \"001010100010001\",\n  \">\": \"100010001010100\", v: \"000000101101010\", \"\\\\\": \"100100010001001\",\n  \"=\": \"000111000111000\", \"?\": \"111001010000010\", \"%\": \"101001010100101\", J: \"001001001101010\",\n  \"7\": \"111001010010010\", T: \"111010010010010\", L: \"100100100100111\", C: \"011100100100011\",\n  Y: \"101101010010010\", S: \"011100010001110\",\n  \"1\": \"010110010010111\", F: \"111100110100100\",\n  V: \"101101101101010\", X: \"101101010101101\", I: \"111010010010111\", Z: \"111001010100111\",\n  \"4\": \"101101111001001\", G: \"011100101101011\", N: \"110101101101101\",\n  K: \"101101110101101\", A: \"010101111101101\", P: \"111101111100100\", D: \"110101101101110\", R: \"110101110101101\",\n  \"2\": \"111001111100111\", \"3\": \"111001111001111\", \"5\": \"111100111001111\", U: \"101101101101111\",\n  H: \"101101111101101\", \"#\": \"101111101111101\", E: \"111100111100111\", B: \"110101111101110\",\n  \"0\": \"111101101101111\", \"6\": \"111100111101111\", \"9\": \"111101111001111\", M: \"101111111101101\", W: \"101101111111101\",\n  \"8\": \"111101111101111\", Q: \"111101101111111\", \"@\": \"111101111100111\",\n  o: \"000000111101111\", n: \"000000110101101\", u: \"000000101101111\", r: \"000000011100100\",\n  c: \"000000011100011\", h: \"100100111101101\", b: \"100100111101111\", d: \"001001111101111\",\n};\nconst GL = Object.values(SMALL).map((s) => Array.from(s, (c) => c === \"1\"));\nconst INK = GL.map((g) => g.filter(Boolean).length);\nconst MAXINK = max(...INK);\n// CLASS[k] lists the glyphs with ink k; an empty class borrows its neighbour.\nconst CLASS = [];\nfor (let k = 0; k \u003c= MAXINK; k++) CLASS.push(GL.map((_, i) => i).filter((i) => INK[i] === k));\nfor (let k = 1; k \u003c= MAXINK; k++) if (!CLASS[k].length) CLASS[k] = CLASS[k - 1].length ? CLASS[k - 1] : CLASS[k + 1];\n\n// The big letters as strokes on the prism face: x across from -18 to 18\n// LEDs (stretched 4% below), y down from 12 to 116, each stroke a list of\n// points, drawn as round strokes R LEDs in radius.\nfunction arc(cx, cy, rx, ry, a0, a1, n = 10) {\n  const pts = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n;\n    pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return pts;\n}\nconst HP = PI / 2;\nconst BIG = {\n  T: [[[-18, 12], [18, 12]], [[0, 12], [0, 116]]],\n  Y: [[[-18, 12], [0, 62]], [[18, 12], [0, 62]], [[0, 62], [0, 116]]],\n  P: [[[-18, 116], [-18, 12]], [[-18, 12], [2, 12], ...arc(2, 38, 16, 26, -HP, HP), [-18, 64]]],\n  E: [[[-18, 12], [-18, 116]], [[-18, 12], [18, 12]], [[-18, 62], [12, 62]], [[-18, 116], [18, 116]]],\n  I: [[[0, 12], [0, 116]], [[-14, 12], [14, 12]], [[-14, 116], [14, 116]]],\n  N: [[[-18, 116], [-18, 12], [18, 116], [18, 12]]],\n  K: [[[-18, 12], [-18, 116]], [[18, 12], [-16, 70]], [[-6, 56], [18, 116]]],\n  1: [[[-12, 30], [2, 12], [2, 116]], [[-14, 116], [18, 116]]],\n  9: [arc(0, 42, 18, 30, 0, 2 * PI, 16), [[18, 42], [18, 86], ...arc(0, 86, 18, 30, 0, HP + 0.6, 6)]],\n  6: [arc(0, 86, 18, 30, 0, 2 * PI, 16), [[-18, 86], [-18, 42], ...arc(0, 42, 18, 30, PI, PI + HP + 0.6, 6)]],\n  L: [[[-18, 12], [-18, 116], [18, 116]]],\n  O: [arc(0, 64, 18, 52, 0, 2 * PI, 24)],\n  B: [[[-18, 12], [-18, 116]], [[-18, 12], [2, 12], ...arc(2, 37, 14, 25, -HP, HP, 8), [-18, 62]], [[-18, 62], [4, 62], ...arc(4, 89, 14, 27, -HP, HP, 8), [-18, 116]]],\n};\n// Each stroke as segments: x0, y0, x1, y1.\nconst SEG = {}, XS = 1.04;\nfor (const ch in BIG) {\n  const s = [];\n  for (const pl of BIG[ch]) for (let i = 0; i + 1 \u003c pl.length; i++) s.push(XS * pl[i][0], pl[i][1], XS * pl[i + 1][0], pl[i + 1][1]);\n  SEG[ch] = new Float32Array(s);\n}\nconst WORDS = [\"TYPE\", \"INK\", \"1966\", \"LOOK\", \"BELL\"];\n// The prism's half width, the stroke's radius, and the cell sizes.\nconst PW = 30, R = 12;\nconst CELLS = [\n  { cw: 4, ch: 6, sc: 1 },\n  { cw: 5, ch: 8, sc: 1 },\n  { cw: 7, ch: 11, sc: 2 },\n];\n\n// Distance from (x, y) to the nearest stroke, and the unit vector from the\n// stroke out to the point, written to out.\nfunction dist(seg, x, y, out) {\n  let best = 1e9, bx0 = 0, by0 = 0;\n  for (let i = 0; i \u003c seg.length; i += 4) {\n    const ax = seg[i], ay = seg[i + 1], bx = seg[i + 2] - ax, by = seg[i + 3] - ay;\n    const px = x - ax, py = y - ay, L = bx * bx + by * by;\n    const t = L > 0 ? cl((px * bx + py * by) / L, 0, 1) : 0;\n    const dx = px - t * bx, dy = py - t * by, d = dx * dx + dy * dy;\n    if (d \u003c best) { best = d; bx0 = dx; by0 = dy; }\n  }\n  const d = sqrt(best);\n  out[0] = d;\n  out[1] = d > 1e-6 ? bx0 / d : 0;\n  out[2] = d > 1e-6 ? by0 / d : 0;\n  return d;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, word: 0, cell: 0, seed: new Float32Array(1024), rate: new Float32Array(1024), rgb: [0, 0, 0], dd: [0, 0, 0] };\n  for (let i = 0; i \u003c 1024; i++) {\n    params.s.seed[i] = Math.random() * 64;\n    params.s.rate[i] = 0.15 + 0.3 * Math.random();\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.t += cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3) / 2;\n  S.word = cl(round(k[2]), 0, WORDS.length - 1);\n  S.cell = cl(round(k[3]), 0, CELLS.length - 1);\n}\n\n// The prism turns a quarter at a time: each letter holds HOLD units, then\n// turns away to the left while the next comes in from the right.\nconst HOLD = 2.2, TURN = 0.8, PER = HOLD + TURN;\n// The lamp stands 40 degrees off the face's normal and goes round it once\n// in LAMP units of the clock, from the upper left at the start.\nconst LS = 0.64, LZ = 0.77, LAMP = 10, SH = 8;\nconst ease = (u) => u * u * (3 - 2 * u);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const word = WORDS[S.word], n = floor(S.t / PER), s = S.t - n * PER;\n  const phi = s \u003c HOLD ? 0 : ease((s - HOLD) / TURN) * HP;\n  const faces = [\n    { a: -phi, ch: word[n % word.length], k: n },\n    { a: HP - phi, ch: word[(n + 1) % word.length], k: n + 1 },\n  ];\n  const az = -0.75 * PI + (2 * PI * S.t) / LAMP, LX = LS * cos(az), LY = LS * sin(az);\n  const shx = -SH * LX, shy = -SH * LY;\n  for (const f of faces) {\n    f.c = cos(f.a);\n    f.x0 = PW * sin(f.a);\n    // The light in the face's own frame: x along the face, z out of it.\n    f.lx = LX * cos(f.a) - LZ * sin(f.a);\n    f.lz = LX * sin(f.a) + LZ * cos(f.a);\n    f.seg = SEG[f.ch];\n  }\n  const { cw, ch, sc } = CELLS[S.cell];\n  const cols = floor(W / cw), rows = floor(H / ch);\n  const ox = floor((W - cols * cw) / 2), oy = floor((H - rows * ch) / 2);\n  const rgb = S.rgb, h = S.hue, dd = S.dd;\n  const wheel = (f) => 0.11 + 0.89 * (f - floor(f));\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++) {\n      const cx = ox + c * cw + (cw - 1) / 2 - 31.5, cy = oy + r * ch + (ch - 1) / 2;\n      // Which face of the prism this cell sees, and where on it.\n      let face = null, u = 0;\n      for (const f of faces) {\n        if (f.c \u003c= 0.001) continue;\n        const uu = (cx - f.x0) / (PW * f.c);\n        if (uu >= -1 && uu \u003c= 1) { face = f; u = uu; break; }\n      }\n      if (!face) continue;\n      const fx = u * PW, d = dist(face.seg, fx, cy, dd);\n      let tone, letter = false;\n      if (d \u003c R) {\n        // A round stroke: its normal leans out from the stroke's spine.\n        const q = d / R, nz = sqrt(1 - q * q);\n        const diff = max(0, q * (dd[1] * face.lx + dd[2] * LY) + nz * face.lz);\n        tone = 0.18 + 0.82 * diff;\n        letter = true;\n      } else {\n        // The flat face, lighter at the top, and the stroke's shadow on it.\n        tone = (0.05 + 0.2 * (1 - cy / H)) * (0.3 + max(0, face.lz));\n        if (dist(face.seg, fx - shx, cy - shy, dd) \u003c R) tone *= 0.15;\n      }\n      let ink = round(tone * MAXINK);\n      if (ink \u003c 1) continue;\n      ink = min(MAXINK, ink);\n      const cls = CLASS[ink], id = r * 32 + c;\n      const g = GL[cls[floor(S.seed[id] + S.t * S.rate[id]) % cls.length]];\n      if (letter) hsv(wheel(h + 0.44 + 0.38 * (face.k % 2)), 0.9 - 0.6 * tone, 1, rgb);\n      else hsv(wheel(h + 0.68), 0.8, 0.5, rgb);\n      const gx = ox + c * cw, gy = oy + r * ch;\n      for (let j = 0; j \u003c 5; j++)\n        for (let i = 0; i \u003c 3; i++)\n          if (g[j * 3 + i])\n            for (let yy = 0; yy \u003c sc; yy++)\n              for (let xx = 0; xx \u003c sc; xx++) display.setPixel(gx + i * sc + xx, gy + j * sc + yy, rgb[0] | 0, rgb[1] | 0, rgb[2] | 0);\n    }\n}\n","word-ladder":"// ===== Patternflow pattern =====\n// Title:   Word Ladder\n// Family:  type\n// Idea:    Lewis Carroll's word ladders build themselves down the tall panel: the first word writes itself stroke by stroke with the goal word waiting dimly at the bottom, each new rung is lowered from the one above while the ink of its one changed letter runs into the new letter on a lit cell, so the changed column zig-zags down the ladder until the goal lights, holds and clears for the next ladder.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Doublets (Lewis Carroll, 1879), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ladder=0..11, Weight=0..1\n//\n// Knob 1: Hue. Turns the ladder's colours along the hues from green to pink, leaving out red, orange and yellow, which read brown on a dim cell. At 0 the words run from azure at the top through blue to violet at the goal, each changed letter white on a cell of its rung's colour; at 0.5 pink at the top, then green down to teal.\n// Knob 2: Speed. At 2 the first word takes 1.4 s to write, each rung 1.15 s, the solved ladder holds 2.6 s and clears in 1.1 s, so HEAD to TAIL is solved at 7.2 s and the next ladder starts at 10.9 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Ladder. Which of twelve ladders the panel starts on; after it the next follows. 0 is HEAD heal teal tell tall TAIL, the example Carroll gave when Doublets began in Vanity Fair on 29 March 1879. Then FOUR to FIVE, PIG to STY, WHEAT to BREAD, EYE to LID, COLD to WARM, FLOUR to BREAD, ONE to TWO in eight steps, APE to MAN, WET to DRY, LESS to MORE and TEA to HOT. The rungs share the 128 rows, 21 rows each for HEAD to TAIL, 14 for ONE to TWO, and the letters grow to fit: 16 LEDs tall for HEAD, 12 for WHEAT, 19 for EYE.\n// Knob 4: Weight. The pen: at 0 a hairline one LED wide, at the opening 0.06 still a hairline, at 1 a bold stroke 4 to 5 LEDs wide on HEAD, where the counters of A and D shrink to a slot.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Carroll's rule: every rung a word, and each differs from the one above in\n// exactly one letter. A ladder that breaks it is dropped here.\nconst LADDERS = [\n  \"HEAD HEAL TEAL TELL TALL TAIL\",\n  \"FOUR FOUL FOOL FOOT FORT FORE FIRE FIVE\",\n  \"PIG WIG WAG WAY SAY STY\",\n  \"WHEAT CHEAT CHEAP CHEEP CREEP CREED BREED BREAD\",\n  \"EYE DYE DIE DID LID\",\n  \"COLD CORD CARD WARD WARM\",\n  \"FLOUR FLOOR FLOOD BLOOD BROOD BROAD BREAD\",\n  \"ONE OWE EWE EYE DYE DOE TOE TOO TWO\",\n  \"APE APT OPT OAT MAT MAN\",\n  \"WET BET BAT BAY DAY DRY\",\n  \"LESS LOSS LOSE LORE MORE\",\n  \"TEA PEA PET POT HOT\",\n]\n  .map((s) => s.split(\" \"))\n  .filter((w) => w.every((a, r) => r === 0 || (a.length === w[0].length && [...a].filter((ch, i) => ch !== w[r - 1][i]).length === 1)));\n\n// The capitals, drawn for this pattern as pen strokes on a grid 4 wide and\n// 6 tall, y down, each stroke a polyline in the order a hand would draw it.\nconst STROKES = {\n  A: [[0, 6, 1.6, 0, 2.4, 0, 4, 6], [0.65, 4, 3.35, 4]],\n  B: [[0, 6, 0, 0, 2.8, 0, 3.7, 0.8, 3.7, 2.2, 2.8, 3, 0, 3], [2.8, 3, 4, 3.9, 4, 5.1, 3, 6, 0, 6]],\n  C: [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5]],\n  D: [[0, 0, 0, 6, 2.4, 6, 4, 4.4, 4, 1.6, 2.4, 0, 0, 0]],\n  E: [[4, 0, 0, 0, 0, 6, 4, 6], [0, 3, 3, 3]],\n  F: [[4, 0, 0, 0, 0, 6], [0, 3, 3, 3]],\n  G: [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 3.4, 2.2, 3.4]],\n  H: [[0, 0, 0, 6], [4, 0, 4, 6], [0, 3, 4, 3]],\n  I: [[1, 0, 3, 0], [2, 0, 2, 6], [1, 6, 3, 6]],\n  L: [[0, 0, 0, 6, 4, 6]],\n  M: [[0, 6, 0, 0, 2, 3.6, 4, 0, 4, 6]],\n  N: [[0, 6, 0, 0, 4, 6, 4, 0]],\n  O: [[1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5, 0, 1, 1, 0]],\n  P: [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2.2, 3, 3.2, 0, 3.2]],\n  R: [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2.2, 3, 3.2, 0, 3.2], [2, 3.2, 4, 6]],\n  S: [[4, 1, 3, 0, 1, 0, 0, 1, 0, 2, 1, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],\n  T: [[0, 0, 4, 0], [2, 0, 2, 6]],\n  U: [[0, 0, 0, 5, 1, 6, 3, 6, 4, 5, 4, 0]],\n  V: [[0, 0, 2, 6, 4, 0]],\n  W: [[0, 0, 1, 6, 2, 2.4, 3, 6, 4, 0]],\n  Y: [[0, 0, 2, 3, 4, 0], [2, 3, 2, 6]],\n};\n\n// Every letter resampled to NP points spaced evenly along its strokes, in\n// stroke order, so any letter can flow into any other point by point.\nconst NP = 120;\nconst GLYPH = {};\nfor (const ch in STROKES) {\n  const st = STROKES[ch];\n  let total = 0;\n  for (const s of st) for (let i = 2; i \u003c s.length; i += 2) total += Math.hypot(s[i] - s[i - 2], s[i + 1] - s[i - 1]);\n  const pts = new Float32Array(NP * 2);\n  let n = 0;\n  for (const s of st) {\n    for (let i = 2; i \u003c s.length; i += 2) {\n      const len = Math.hypot(s[i] - s[i - 2], s[i + 1] - s[i - 1]);\n      const share = (len / total) * NP;\n      const from = n, to = min(NP, round(from + share + (i === s.length - 2 && s === st[st.length - 1] ? NP : 0)));\n      for (let k = from; k \u003c to; k++) {\n        const t = to - from > 1 ? (k - from) / (to - from - 1) : 0;\n        pts[2 * k] = s[i - 2] + (s[i] - s[i - 2]) * t;\n        pts[2 * k + 1] = s[i - 1] + (s[i + 1] - s[i - 1]) * t;\n      }\n      n = to;\n    }\n  }\n  GLYPH[ch] = pts;\n}\n\nexport function setup(params) {\n  params.s = {\n    lad: -1, k3: -1, t: 0, hue: 0, speed: 2, weight: 0.06,\n    ink: new Float32Array(W * H * 3), col: [0, 0, 0],\n    PALE: [0, 1, 2, 3, 4, 5, 6, 7, 8].map(() => [0, 0, 0]), ACC: [0, 1, 2, 3, 4, 5, 6, 7, 8].map(() => [0, 0, 0]),\n    CELL: [0, 1, 2, 3, 4, 5, 6, 7, 8].map(() => [0, 0, 0]),\n  };\n}\n\nconst T_WRITE = 1.4, T_STEP = 1.15, T_HOLD = 2.6, T_CLEAR = 1.1;\nconst length = (n) => T_WRITE + (n - 1) * T_STEP + T_HOLD + T_CLEAR;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.weight = cl(kv[3], 0, 1);\n  const k3 = cl(round(kv[2]), 0, LADDERS.length - 1);\n  if (k3 !== S.k3) { S.k3 = k3; S.lad = k3; S.t = 0; }\n  S.t += (d * S.speed) / 2;\n  if (S.t > length(LADDERS[S.lad].length)) { S.t = 0; S.lad = (S.lad + 1) % LADDERS.length; }\n}\n\n// Lays a letter's points into the ink, each a disc of radius rad.\nfunction stamp(S, ch, x0, y0, sx, sy, rad, c, bright, upto) {\n  const pts = GLYPH[ch], ink = S.ink, n = upto === undefined ? NP : upto;\n  for (let k = 0; k \u003c n; k++) dot(ink, x0 + pts[2 * k] * sx, y0 + pts[2 * k + 1] * sy, rad, c, bright);\n}\n\nfunction dot(ink, x, y, rad, c, b) {\n  const r = rad + 0.5, xa = max(0, floor(x - r)), xb = min(W - 1, floor(x + r)), ya = max(0, floor(y - r)), yb = min(H - 1, floor(y + r));\n  for (let Y = ya; Y \u003c= yb; Y++)\n    for (let X = xa; X \u003c= xb; X++) {\n      const dx = X + 0.5 - x, dy = Y + 0.5 - y, w = cl(r - sqrt(dx * dx + dy * dy), 0, 1) * b;\n      if (w \u003c= 0) continue;\n      const o = (Y * W + X) * 3;\n      if (c[0] * w > ink[o]) ink[o] = c[0] * w;\n      if (c[1] * w > ink[o + 1]) ink[o + 1] = c[1] * w;\n      if (c[2] * w > ink[o + 2]) ink[o + 2] = c[2] * w;\n    }\n}\n\nfunction box(S, x0, y0, w, h, c, b) {\n  const ink = S.ink;\n  for (let y = max(0, round(y0)); y \u003c min(H, round(y0 + h)); y++)\n    for (let x = max(0, round(x0)); x \u003c min(W, round(x0 + w)); x++) {\n      const o = (y * W + x) * 3;\n      ink[o] = max(ink[o], c[0] * b); ink[o + 1] = max(ink[o + 1], c[1] * b); ink[o + 2] = max(ink[o + 2], c[2] * b);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.lad \u003c 0) return;\n  const words = LADDERS[S.lad], n = words.length, L = words[0].length, ink = S.ink;\n  ink.fill(0);\n  const rh = H / n, cw = (W - 4) / L;\n  const gh = min(rh * 0.74, (cw - 3) * 1.5), gw = min(cw - 3, gh * (L \u003c 4 ? 0.8 : 0.68));\n  const sx = gw / 4, sy = gh / 6;\n  const rad = 0.42 + S.weight * 0.1 * gh;\n  // The colour walks from the first word to the goal, azure to violet at 0,\n  // on the hues from green to pink: red, orange and yellow read brown on a\n  // dim cell.\n  const col = S.col, PALE = S.PALE, ACC = S.ACC, CELL = S.CELL;\n  for (let r = 0; r \u003c n; r++) {\n    const u = 0.39 + S.hue + (0.44 * r) / (n - 1), h = 0.3 + 0.64 * (u - floor(u));\n    hsv(h, 0.7, 1, PALE[r]);\n    hsv(h, 0.12, 1, ACC[r]);\n    hsv(h, 0.9, 1, CELL[r]);\n  }\n  const gx = (i) => 2 + i * cw + (cw - gw) / 2, gy = (r) => r * rh + (rh - gh) / 2;\n  const diff = (r) => { const a = words[r - 1], b = words[r]; for (let i = 0; i \u003c L; i++) if (a[i] !== b[i]) return i; return -1; };\n\n  const t = S.t, steps = n - 1;\n  const tEnd = T_WRITE + steps * T_STEP;\n  // How many rungs stand finished, and the one being lowered.\n  const done = t \u003c T_WRITE ? 1 : min(n, 1 + floor((t - T_WRITE) / T_STEP));\n  const live = t >= T_WRITE && t \u003c tEnd ? done : -1;\n  const tau = live > 0 ? t - T_WRITE - (live - 1) * T_STEP : 0;\n  const hold = t >= tEnd ? t - tEnd : -1;\n  const clear = hold > T_HOLD ? hold - T_HOLD : -1;\n  const fade = (r) => (clear \u003c 0 ? 1 : 1 - ease((clear - r * 0.07) / 0.35));\n\n  for (let r = 0; r \u003c n; r++) {\n    const f = fade(r);\n    if (f \u003c= 0) continue;\n    const y0 = gy(r), pale = PALE[r], acc = ACC[r], cell = CELL[r];\n    if (r \u003c done && r !== live) {\n      // A finished rung: the changed letter on its tinted cell.\n      const c = r > 0 ? diff(r) : -1;\n      let pulse = 0;\n      if (hold >= 0 && r > 0) pulse = max(0, 1 - abs(hold - 0.25 - r * 0.16) / 0.25);\n      if (c >= 0) box(S, 2 + c * cw + 1, r * rh + 1, cw - 2, rh - 2, cell, (0.3 + 0.3 * pulse) * f);\n      for (let i = 0; i \u003c L; i++) {\n        const ch = words[r][i];\n        if (r === 0 && t \u003c T_WRITE) {\n          // The first word writes itself, letter after letter in stroke order.\n          const p = cl((t / (T_WRITE * 0.85)) * L - i, 0, 1);\n          stamp(S, ch, gx(i), y0, sx, sy, rad, pale, f, floor(p * NP));\n        } else {\n          const goal = r === n - 1 && hold >= 0 ? max(0, 1 - hold / 0.6) : 0;\n          stamp(S, ch, gx(i), y0, sx, sy, rad, i === c ? acc : pale, f * (1 + 0.6 * pulse + goal));\n        }\n      }\n    } else if (r === live) {\n      // Lowering a copy of the rung above while one letter re-forms.\n      const c = diff(r), a = words[r - 1], drop = ease(tau / 0.5);\n      const yd = gy(r - 1) + drop * rh;\n      box(S, 2 + c * cw + 1, r * rh + 1, cw - 2, rh - 2, cell, 0.3 * ease((tau - 0.3) / 0.5));\n      if (r === n - 1) for (let i = 0; i \u003c L; i++) stamp(S, words[r][i], gx(i), y0, sx, sy, rad, pale, 0.38 * (1 - drop));\n      for (let i = 0; i \u003c L; i++) if (i !== c) stamp(S, a[i], gx(i), yd, sx, sy, rad, pale, 0.25 + 0.75 * drop);\n      // The changed letter rides down as the old glyph, then its ink runs\n      // point by point, in stroke order, into the new glyph.\n      const p0 = GLYPH[a[c]], p1 = GLYPH[words[r][c]], x0 = gx(c);\n      for (let k = 0; k \u003c NP; k++) {\n        const e = ease((tau - 0.3 - 0.35 * (k / NP)) / 0.4);\n        const xa = x0 + p0[2 * k] * sx, ya = yd + p0[2 * k + 1] * sy;\n        const xb = x0 + p1[2 * k] * sx, yb = y0 + p1[2 * k + 1] * sy;\n        const sw = sin(PI * e) * gh * 0.18, an = (2 * PI * k) / NP;\n        for (let j = 0; j \u003c 3; j++) col[j] = pale[j] + (acc[j] - pale[j]) * min(1, e * 3);\n        dot(ink, xa + (xb - xa) * e + sw * cos(an), ya + (yb - ya) * e + sw * sin(an), rad, col, (0.25 + 0.75 * drop) * (1 + 0.5 * sin(PI * e)));\n      }\n    } else {\n      // A rung still to find: blanks, and the goal word waiting dimly.\n      const a = t \u003c T_WRITE ? cl(t / T_WRITE, 0, 1) : 1;\n      if (r === n - 1) for (let i = 0; i \u003c L; i++) stamp(S, words[r][i], gx(i), y0, sx, sy, rad, pale, 0.38 * a * f);\n      else for (let i = 0; i \u003c L; i++) box(S, gx(i), y0 + gh - 1, gw, 1, pale, 0.3 * a * f);\n    }\n  }\n  // The rails, down to the lowest rung so far: the panel's two edge columns.\n  const reach = t \u003c T_WRITE ? (rh * t) / T_WRITE : live > 0 ? (live - 1 + ease(tau / 0.5)) * rh + rh : done * rh;\n  for (let y = 0; y \u003c min(H, round(reach)); y++) {\n    const r = min(n - 1, floor(y / rh)), f = fade(r) * 0.6;\n    if (f \u003c= 0) continue;\n    box(S, 0, y, 1, 1, PALE[r], f);\n    box(S, W - 1, y, 1, 1, PALE[r], f);\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, round(cl(ink[o], 0, 1) * 255), round(cl(ink[o + 1], 0, 1) * 255), round(cl(ink[o + 2], 0, 1) * 255));\n  }\n}\n","abrikosov-lattice":"// ===== Patternflow pattern =====\n// Title:   Abrikosov Lattice\n// Family:  physics\n// Idea:    A rotating Bose-Einstein condensate fills the tall panel in the lowest Landau level, its phase drawn as hue and its density as brightness, so each quantised vortex is a black core round which every hue turns once, the cores stand in Abrikosov's triangular lattice and turn with the fluid, and turning up the rotation packs them closer, Feynman's 2 m Omega / h to each unit of area, while new ones come in from the dark rim.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Abrikosov vortex lattice (Alexei Abrikosov, 1957), triangular vortex lattice (W. H. Kleiner, L. M. Roth and S. H. Autler, 1964), areal density of quantised vortices (Richard Feynman, 1955), vortex lattices in rotating Bose-Einstein condensates (K. W. Madison, F. Chevy, W. Wohlleben and J. Dalibard, 2000; J. R. Abo-Shaeer, C. Raman, J. M. Vogels and W. Ketterle, 2001), rapidly rotating condensate in the lowest Landau level (Tin-Lun Ho, 2001), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rotation=0.3..0.95, Round=0..1\n//\n// Knob 1: Hue. Turns the wheel the phase is drawn on. At 0 phase zero is azure, and the hues run azure, violet, magenta, red, gold, green and cyan anticlockwise round every core; at 0.5 phase zero is orange. Blue is paled toward periwinkle so that it does not read as a hole beside the cores, which are the only black.\n// Knob 2: Speed. How fast the lattice turns, anticlockwise with the flow round the cores, at 0.25 Speed Omega / omega radians a second: at 2 and the opening Rotation 0.3 it turns 0.15 rad/s, a sixth of a turn, the lattice's own symmetry, in 7 s; at 0.2 in 70 s, at 3 in 4.7 s.\n// Knob 3: Rotation. Omega / omega, from 0.3 to 0.95. Feynman's rule puts 2 m Omega / h vortices on each unit of area, so the spacing goes as 1 / sqrt(Omega): 25 LEDs at 0.3, where 9 to 13 cores sit in the bright cloud and 15 to 17 on the panel; 17.7 LEDs at 0.6, with 21 to 23 in the cloud; 14 LEDs at 0.95, with 31 to 37 in the cloud and 47 to 51 on the panel. The lattice closes in on the central core, so new vortices come in from the dark rim, and it turns faster in step with Omega.\n// Knob 4: Round. The trap's aspect. The cloud's half axes are 33 LEDs across and 33 (2 - Round) down: 64 at the opening 0.06, so the cloud fills the tall panel; 49.5 at 0.5; 33 at 1, a round cloud with 7 cores in it at the opening Rotation and the top and bottom of the panel dark.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, exp, cos, sin, atan2, round, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Abrikosov's lattice function in the lowest Landau level, Landau gauge,\n// lengths in the magnetic length l: Phi(x, y) = sum_n C_n e^(i q n y)\n// e^(-(x - q n)^2 / 2), with C_n = 1 for even n and i for odd n and\n// q^2 = pi sqrt 3, the triangular lattice of Kleiner, Roth and Autler. Its\n// zeros sit at (q/2, Ly/4) + the lattice, Ly = 2 pi / q, one to each area\n// 2 pi l^2, spacing D = sqrt(4 pi / sqrt 3) = 2.694 l.\nconst Q = sqrt(PI * sqrt(3)), LY = TAU / Q, D = sqrt((4 * PI) / sqrt(3)), X0 = Q / 2, Y0 = LY / 4;\nconst OUT = [0, 0];\nfunction phi(x, y) {\n  let re = 0, im = 0;\n  const n0 = round(x / Q), c = cos(Q * y), s = sin(Q * y);\n  // e^(i q n y) for n = n0 - 3 by one cos and sin, then by rotation.\n  let er = cos(Q * (n0 - 3) * y), ei = sin(Q * (n0 - 3) * y);\n  for (let n = n0 - 3; n \u003c= n0 + 3; n++) {\n    const u = x - Q * n, g = exp(-u * u / 2);\n    if (n & 1) (re -= ei * g), (im += er * g);\n    else (re += er * g), (im += ei * g);\n    const t = er * c - ei * s;\n    ei = er * s + ei * c;\n    er = t;\n  }\n  OUT[0] = re;\n  OUT[1] = im;\n  return OUT;\n}\n\n// Phi over one magnetic cell, x in [0, 2q) and y in [0, Ly), tabled once:\n// Phi(x + 2q j, y + Ly m) = e^(2 i q j y) Phi(x, y), so the table and one\n// phase give Phi anywhere.\nconst TX = 168, TY = 96, TRe = new Float32Array((TX + 1) * (TY + 1)), TIm = new Float32Array((TX + 1) * (TY + 1));\nfor (let j = 0; j \u003c= TY; j++)\n  for (let i = 0; i \u003c= TX; i++) {\n    const f = phi((i / TX) * 2 * Q, (j / TY) * LY);\n    TRe[j * (TX + 1) + i] = f[0];\n    TIm[j * (TX + 1) + i] = f[1];\n  }\n// The largest |Phi| in the table, the brightest point of every cell.\nlet MX = 0;\nfor (let o = 0; o \u003c TRe.length; o++) MX = max(MX, sqrt(TRe[o] * TRe[o] + TIm[o] * TIm[o]));\n// Phi at (x, y) from the table: modulus and argument.\nconst LOOK = [0, 0];\nfunction look(x, y) {\n  const jx = floor(x / (2 * Q)), my = floor(y / LY), u = ((x - jx * 2 * Q) / (2 * Q)) * TX, v = ((y - my * LY) / LY) * TY;\n  let i = floor(u), j = floor(v);\n  if (i >= TX) i = TX - 1;\n  if (j >= TY) j = TY - 1;\n  const fu = u - i, fv = v - j, o = j * (TX + 1) + i;\n  const re = (TRe[o] * (1 - fu) + TRe[o + 1] * fu) * (1 - fv) + (TRe[o + TX + 1] * (1 - fu) + TRe[o + TX + 2] * fu) * fv;\n  const im = (TIm[o] * (1 - fu) + TIm[o + 1] * fu) * (1 - fv) + (TIm[o + TX + 1] * (1 - fu) + TIm[o + TX + 2] * fu) * fv;\n  LOOK[0] = sqrt(re * re + im * im);\n  LOOK[1] = atan2(im, re) + 2 * Q * jx * y;\n  return LOOK;\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, rot: 0.3, round: 0.06, angle: 0, ek: -1, E: new Float32Array(N), A: new Float32Array(N), P: new Float32Array(N) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.rot = cl(k[2], 0.3, 0.95);\n  S.round = cl(k[3], 0, 1);\n  S.angle += d * 0.25 * S.speed * S.rot;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // Feynman's rule: vortices per area 2 m Omega / h, so the spacing goes as\n  // 1 / sqrt(Omega): 25 LEDs at Omega = 0.3 omega.\n  const dl = 25 * sqrt(0.3 / S.rot), sc = D / dl; // l per LED\n  const { A, P, E } = S, ca = cos(S.angle), sa = sin(S.angle), tmp = [0, 0, 0];\n  if (S.ek !== S.round) {\n    // The cloud: half axes 33 LEDs across and 33 (2 - Round) down, its\n    // envelope exp(-r^6), flat inside and falling over about 8 LEDs.\n    S.ek = S.round;\n    const a = 33, b = 33 * (2 - S.round);\n    for (let Y = 0, p = 0; Y \u003c H; Y++)\n      for (let X = 0; X \u003c W; X++, p++) {\n        const r2 = ((X - 31.5) / a) ** 2 + ((Y - 63.5) / b) ** 2;\n        E[p] = exp(-(r2 * r2 * r2));\n      }\n  }\n  // In the lab frame the condensate is this function in the symmetric gauge,\n  // f(z) e^(-|z|^2 / 4) with f holomorphic: Phi times e^(-i x y / 2), moved\n  // by a magnetic translation so a zero sits on the cloud's centre, and\n  // turned with the lattice, which keeps that form. So every zero winds\n  // the phase once anticlockwise. The cloud's envelope multiplies it, the\n  // slowly varying density times the lattice that many vortices make.\n  for (let Y = 0, p = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++, p++) {\n      const px = (X - 31.5) * sc, py = (63.5 - Y) * sc;\n      // Into the lattice's turning frame, then onto Abrikosov's function\n      // with a zero on the cloud's centre.\n      const x = ca * px + sa * py, y = -sa * px + ca * py;\n      const f = look(x + X0, y + Y0), m = f[0];\n      // Symmetric gauge about the centre: arg Phi - x y / 2 - x0 y.\n      P[p] = f[1] - (x * y) / 2 - X0 * y;\n      A[p] = m * E[p];\n    }\n  // Brightness |psi|^1.25: a core is dark, below half brightness, over a\n  // disc 0.4 of the spacing across, 10 LEDs at the opening, where the\n  // steepest step between neighbours is 28 / 255.\n  for (let p = 0; p \u003c N; p++) {\n    const u = min(1, A[p] / MX), v = u * sqrt(sqrt(u)), h = S.hue + 0.6 + P[p] / TAU, e = max(0, 1 - abs(h - floor(h) - 0.667) * 7);\n    hsv(h, 1 - 0.35 * e * e, v, tmp);\n    display.setPixel(p & 63, p >> 6, round(tmp[0] * 255), round(tmp[1] * 255), round(tmp[2] * 255));\n  }\n}\n","balanced-rhythms":"// ===== Patternflow pattern =====\n// Title:   Balanced Rhythms\n// Family:  rhythm\n// Idea:    A playhead goes round a ring of steps and every onset it strikes adds its own unit vector to a walk drawn below, tip to tail, and when the onsets are perfectly balanced, their roots of unity summing to zero, the walk closes on its starting point at the end of every bar, even for the six onsets of 30 steps that no union of regular polygons can make.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: vanishing sums of roots of unity (N. G. de Bruijn, 1953; I. J. Schoenberg, 1964), the sizes a vanishing sum can have (T. Y. Lam and K. H. Leung, 2000), perfectly balanced rhythms and scales (Andrew Milne, David Bulger, Steffen Herff and William Sethares, 2015), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rhythm=0..1, Rotate=0..1\n//\n// Knob 1: Hue. Turns the components' colours round the wheel together. At 0 pentagons and the clave's three side are azure, triangles and its two side violet, digons green and a second triangle or digon pink; at 0.5 they are red, lime, magenta and cyan. The walk's edges and the wedges it sweeps take the colour of the component their onset came from. Orange is skipped, as it reads brown when dim.\n// Knob 2: Speed. One bar, once round the ring, takes 6 / Speed seconds: 3 s at 2, ten steps a second on 30 steps, 30 s at 0.2, 2 s at 3. Each onset flashes, draws its vector from the ring's centre and adds the same vector to the walk below, drawn out over 0.22 s.\n// Knob 3: Rhythm. Below 0.2, 6 onsets of 30 steps, 5, 6, 12, 18, 24 and 25: the pentagon from step 0 and the triangle from step 5, less the digon 0 and 15 joining them, dashed, so the walk's tent of two edges at 60 degrees either side of the top stands in for the pentagon's missing edge. It is balanced and no union of polygons; of the 2^30 sets of steps, 146,854 are balanced, 26,640 of them are no union of polygons, and the 30 smallest of those, 6 onsets each, are all turns of this one. To 0.4 a pentagon, a triangle and a digon, one for each prime of 30, 10 onsets; to 0.6 the pentagon with two vertices split by two triangles, 7 onsets; to 0.8 a triangle and two digons on 12 steps, 7 onsets, where with two primes every one of the 100 balanced sets is a union of polygons; then the son clave of 16 steps, 0, 3, 6, 10 and 12, which is not balanced: each bar's walk ends 0.082 of a step from its start, dashed, and the walk runs on four bars before it starts again.\n// Knob 4: Rotate. Turns one component round the ring, and a balanced rhythm stays balanced. In the first rhythm the triangle goes two steps a stop, 5 to 13, which moves the split to another vertex of the pentagon and turns the whole rhythm by 12 steps; in the second and fourth a digon goes one step a stop, and where it lands on an onset already there that step counts twice, a bigger dot and a walk edge twice as long; in the third the second triangle splits vertex 6, 18, 12 or 24 in turn. In the clave it turns the two side a step at a time and the miss grows from 0.082 to 0.710, 1.385, 2.009 and 2.556 steps. It opens at 0.06, the rhythms as listed.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, cos, sin, exp, round, ceil, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without its orange, 0.03 to 0.15, which reads brown when dim.\nconst wheel = (h) => 0.15 + (h - floor(h)) * 0.88;\n\n// The ring: centre (31.5, 31.5), radius 27, step k at 2 pi k / N clockwise\n// from the top. The walk below: centred on (31.5, 96.5) in a 58 x 54 box.\nconst CX = 31.5, CY = 31.5, RING = 27, WX = 31.5, WY = 96.5, WW = 58, WH = 54;\n// A component is a regular m-gon from step `off`, or a set of steps; `turn`\n// lists where Rotate puts it. `links` are digons taken away: the antipodal\n// pair with one end in each of the two components named.\nconst RHYTHMS = [\n  // A pentagon and a triangle, less the digon joining them: 6 onsets of 30,\n  // balanced and no union of polygons.\n  { N: 30, comps: [{ m: 5, off: 0, c: 0 }, { m: 3, off: 5, c: 1, turn: [5, 7, 9, 11, 13] }], links: [[0, 1]] },\n  // A pentagon, a triangle and a digon, one for each prime of 30: 10 onsets.\n  { N: 30, comps: [{ m: 5, off: 1, c: 0 }, { m: 3, off: 0, c: 1 }, { m: 2, off: 2, c: 2, turn: [2, 3, 4, 5, 6] }], links: [] },\n  // The pentagon with two of its vertices split by two triangles: 7 onsets.\n  { N: 30, comps: [{ m: 5, off: 0, c: 0 }, { m: 3, off: 5, c: 1 }, { m: 3, off: 11, c: 3, turn: [11, 13, 17, 19] }], links: [[0, 1], [0, 2]] },\n  // 12 steps, two primes: a triangle and two digons, 7 onsets.\n  { N: 12, comps: [{ m: 3, off: 0, c: 1 }, { m: 2, off: 1, c: 2, turn: [1, 2, 3, 4, 5] }, { m: 2, off: 5, c: 3 }], links: [] },\n  // The son clave of 16 steps, which is not balanced, its two side turned.\n  { N: 16, comps: [{ set: [0, 3, 6], c: 0 }, { set: [10, 12], c: 1, turn: [0, 1, 2, 3, 4] }], links: [] },\n];\n\n// An unbalanced walk keeps four bars, then starts again.\nconst KEEP = 4;\n\nfunction build(S, which, j) {\n  const R = RHYTHMS[which], N = R.N;\n  const pts = R.comps.map((c) => {\n    const t = c.turn ? c.turn[min(c.turn.length - 1, round(j * (c.turn.length - 1)))] : c.off ?? 0;\n    if (c.set) return c.set.map((k) => (k + t) % N);\n    const out = [];\n    for (let i = 0; i \u003c c.m; i++) out.push((t + (i * N) / c.m) % N);\n    return out;\n  });\n  const coef = new Int32Array(N), owner = new Int32Array(N).fill(-1);\n  pts.forEach((p, ci) =>\n    p.forEach((k) => {\n      coef[k]++;\n      if (owner[k] \u003c 0) owner[k] = R.comps[ci].c;\n    }),\n  );\n  const links = [];\n  for (const [a, b] of R.links) {\n    const k = pts[a].find((p) => pts[b].includes((p + N / 2) % N));\n    links.push(k);\n    coef[k]--;\n    coef[(k + N / 2) % N]--;\n  }\n  // The onsets in time order, each with its vector (sin, -cos) on the\n  // screen, as long as its weight.\n  const on = [];\n  for (let k = 0; k \u003c N; k++) if (coef[k] > 0) on.push(k);\n  const vx = new Float64Array(N), vy = new Float64Array(N);\n  for (let k = 0; k \u003c N; k++) {\n    const a = (2 * PI * k) / N;\n    vx[k] = coef[k] * sin(a);\n    vy[k] = -coef[k] * cos(a);\n  }\n  let x = 0, y = 0;\n  const P = [[0, 0]];\n  for (const k of on) P.push([(x += vx[k]), (y += vy[k])]);\n  const fx = x, fy = y, balanced = sqrt(fx * fx + fy * fy) \u003c 1e-9;\n  // Fit the walk, one bar when it closes, four when it does not.\n  const fit = balanced ? 1 : KEEP;\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let b = 0; b \u003c fit; b++)\n    for (const [px, py] of P) {\n      x0 = min(x0, px + b * fx);\n      x1 = max(x1, px + b * fx);\n      y0 = min(y0, py + b * fy);\n      y1 = max(y1, py + b * fy);\n    }\n  const e = min(WW / max(1e-6, x1 - x0), WH / max(1e-6, y1 - y0), 24);\n  Object.assign(S, {\n    which, j, N, pts, coef, owner, links, on, vx, vy, P, fx, fy, balanced, e,\n    ox: WX - ((x0 + x1) / 2) * e, oy: WY - ((y0 + y1) / 2) * e,\n    phase: -1e-6, pos: [0, 0], start: [0, 0], verts: [[0, 0]], hist: [], kept: 0,\n    fire: new Float64Array(N).fill(-99), edgeAt: -99, closeAt: -99,\n  });\n}\n\nexport function setup(params) {\n  params.s = null;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  let S = params.s;\n  if (!S) S = params.s = { clock: 0, maxClose: 0, barCount: 0, col: new Float32Array(15), R: new Float32Array(NP), G: new Float32Array(NP), B: new Float32Array(NP) };\n  const which = min(RHYTHMS.length - 1, floor(cl(k[2], 0, 1) * RHYTHMS.length)), j = cl(k[3], 0, 1);\n  const R = RHYTHMS[which], turns = R.comps.find((c) => c.turn)?.turn.length ?? 1;\n  const jj = round(j * (turns - 1)) / max(1, turns - 1);\n  if (S.which !== which || S.j !== jj) build(S, which, jj);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.clock += d;\n  // One bar takes 6 / Speed seconds.\n  const old = S.phase * S.N;\n  S.phase += d / (6 / S.speed);\n  const now = S.phase * S.N;\n  for (let a = floor(old) + 1; a \u003c= floor(now); a++) {\n    const step = ((a % S.N) + S.N) % S.N;\n    if (step === 0) {\n      // A new bar. The walk should be back where the bar began.\n      const ex = S.pos[0] - S.start[0], ey = S.pos[1] - S.start[1];\n      if (S.balanced && a > 0) S.maxClose = max(S.maxClose, sqrt(ex * ex + ey * ey));\n      if (a > 0) S.barCount++;\n      if (!S.balanced) {\n        S.hist.push(S.verts);\n        if (++S.kept >= KEEP) (S.kept = 0), (S.hist = []), (S.pos = [0, 0]);\n      }\n      S.start = [S.pos[0], S.pos[1]];\n      S.verts = [[S.pos[0], S.pos[1]]];\n    }\n    if (S.coef[step] > 0) {\n      S.pos = [S.pos[0] + S.vx[step], S.pos[1] + S.vy[step]];\n      S.verts.push(S.pos);\n      S.fire[step] = S.clock;\n      S.edgeAt = S.clock;\n      const cx = S.pos[0] - S.start[0], cy = S.pos[1] - S.start[1];\n      if (S.balanced && S.verts.length > 2 && sqrt(cx * cx + cy * cy) \u003c 1e-9) S.closeAt = S.clock;\n    }\n  }\n}\n\n// Light into the float frame: a bilinear dot, and lines of them.\nfunction dot(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  put(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  put(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  put(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  put(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction put(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction line(S, x0, y0, x1, y1, v, c, o, dash) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, ceil(len * 2.5)), w = (v * len) / n;\n  for (let i = 0; i \u003c= n; i++) {\n    if (dash && floor((i / n) * len / 2) % 2) continue;\n    dot(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n  }\n}\n// A line two LEDs wide: two lines half an LED either side.\nfunction thick(S, x0, y0, x1, y1, v, c, o) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) || 1, nx = (-(y1 - y0) / len) * 0.45, ny = ((x1 - x0) / len) * 0.45;\n  line(S, x0 + nx, y0 + ny, x1 + nx, y1 + ny, v * 0.75, c, o);\n  line(S, x0 - nx, y0 - ny, x1 - nx, y1 - ny, v * 0.75, c, o);\n}\n// A round dot of radius r, its rim soft.\nfunction disc(S, x, y, r, v, c, o) {\n  for (let iy = floor(y - r - 1); iy \u003c= ceil(y + r + 1); iy++)\n    for (let ix = floor(x - r - 1); ix \u003c= ceil(x + r + 1); ix++) {\n      const d = sqrt((ix + 0.5 - x) ** 2 + (iy + 0.5 - y) ** 2), f = cl(r + 0.5 - d, 0, 1);\n      if (f > 0) put(S, ix, iy, f * v, c, o);\n    }\n}\nconst WHITE = [1, 1, 1, 0.35, 0.35, 0.35, 1, 0.25, 0.3];\n\n// Fill a convex polygon with v of colour c, row by row: a pixel is in when\n// its centre is. Two wedges that share an edge share no pixel.\nfunction fill(S, poly, v, c, o) {\n  const n = poly.length;\n  if (n \u003c 3) return;\n  let y0 = 1e9, y1 = -1e9;\n  for (const q of poly) (y0 = min(y0, q[1])), (y1 = max(y1, q[1]));\n  for (let y = max(0, ceil(y0 - 0.5)); y \u003c= min(H - 1, floor(y1 - 0.5)); y++) {\n    const py = y + 0.5 + 6.1e-5;\n    let xa = 1e9, xb = -1e9;\n    for (let i = 0; i \u003c n; i++) {\n      const a = poly[i], b = poly[(i + 1) % n];\n      if ((a[1] \u003c= py && b[1] > py) || (b[1] \u003c= py && a[1] > py)) {\n        const x = a[0] + ((py - a[1]) / (b[1] - a[1])) * (b[0] - a[0]);\n        xa = min(xa, x);\n        xb = max(xb, x);\n      }\n    }\n    // Centres x + 0.5 in [xa, xb).\n    for (let x = max(0, ceil(xa - 0.5 - 3.7e-5)); x \u003c= min(W - 1, ceil(xb - 0.5 - 3.7e-5) - 1); x++) {\n      const p = y * W + x;\n      S.R[p] += v * c[o];\n      S.G[p] += v * c[o + 1];\n      S.B[p] += v * c[o + 2];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, G, B, col, N, coef, owner } = S;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  // Component colours: azure, violet, green, pink at Hue 0.\n  for (let c = 0; c \u003c 4; c++) hsv(wheel(0.49 + S.hue + [0, 0.19, 0.77, 0.4][c]), 0.75, 1, col, c * 3);\n  const t = S.clock;\n  const ang = (k) => (2 * PI * k) / N;\n  const rx = (k, r) => CX + r * sin(ang(k)), ry = (k, r) => CY - r * cos(ang(k));\n\n  // The ring, faint, and the playhead with its arc trailing behind and a\n  // faint hand from the centre.\n  const u = S.phase - floor(S.phase);\n  for (let i = 0; i \u003c 160; i++) dot(S, CX + RING * sin((2 * PI * i) / 160), CY - RING * cos((2 * PI * i) / 160), 0.16, WHITE, 3);\n  for (let i = 0; i \u003c 48; i++) {\n    const a = 2 * PI * u - (i / 48) * 1.1;\n    dot(S, CX + (RING + 3.5) * sin(a), CY - (RING + 3.5) * cos(a), 0.6 * (1 - i / 48), WHITE, 0);\n  }\n  disc(S, CX + (RING + 3.5) * sin(2 * PI * u), CY - (RING + 3.5) * cos(2 * PI * u), 1.2, 1, WHITE, 0);\n  line(S, CX, CY, CX + (RING - 3) * sin(2 * PI * u), CY - (RING - 3) * cos(2 * PI * u), 0.22, WHITE, 0);\n  // The polygons inside, each lit up a moment when one of its onsets is struck.\n  const comps = RHYTHMS[S.which].comps;\n  S.pts.forEach((p, ci) => {\n    const c = comps[ci].c, sorted = [...p].sort((a, b) => a - b);\n    let f = 0;\n    for (const k of p) f = max(f, exp(-(t - S.fire[k]) / 0.3));\n    for (let i = 0; i \u003c sorted.length; i++) {\n      const a = sorted[i], b = sorted[(i + 1) % sorted.length];\n      if (sorted.length === 2 && i === 1) break;\n      line(S, rx(a, RING - 2), ry(a, RING - 2), rx(b, RING - 2), ry(b, RING - 2), 0.4 + 0.5 * f, col, c * 3);\n    }\n  });\n  // The digons taken away, dashed.\n  for (const k of S.links) {\n    line(S, rx(k, RING - 2), ry(k, RING - 2), rx(k + N / 2, RING - 2), ry(k + N / 2, RING - 2), 0.55, WHITE, 3, true);\n    // Its ends, emptied: a hollow ring where each polygon lost a vertex.\n    for (const q of [k, k + N / 2])\n      for (let i = 0; i \u003c 16; i++) dot(S, rx(q, RING) + 2.2 * cos((PI * i) / 8), ry(q, RING) + 2.2 * sin((PI * i) / 8), 0.16, WHITE, 0);\n  }\n  // The steps: onsets in their colours, flashing white as they are struck,\n  // with their vectors from the centre; rests a dim grey.\n  for (let k = 0; k \u003c N; k++) {\n    const x = rx(k, RING), y = ry(k, RING);\n    if (coef[k] > 0) {\n      const f = exp(-(t - S.fire[k]) / 0.35), c = owner[k] * 3;\n      const tmp = [col[c] + (1 - col[c]) * f, col[c + 1] + (1 - col[c + 1]) * f, col[c + 2] + (1 - col[c + 2]) * f];\n      disc(S, x, y, (coef[k] > 1 ? 2.3 : 1.6) + 0.6 * f, 0.75 + 0.25 * f, tmp, 0);\n      const fv = exp(-(t - S.fire[k]) / 0.4);\n      if (fv > 0.02) thick(S, CX, CY, rx(k, RING - 2.5), ry(k, RING - 2.5), fv, col, c);\n    } else dot(S, x, y, 0.7, WHITE, 3);\n  }\n\n  // The walk.\n  const e = S.e, X = (p) => S.ox + p[0] * e, Y = (p) => S.oy + p[1] * e;\n  const verts = S.verts, last = verts.length - 1;\n  // The edge struck last is drawn out over 0.22 s.\n  const ease = min(1, (t - S.edgeAt) / 0.22), ee = 1 - (1 - ease) ** 3;\n  let tipx = verts[last][0], tipy = verts[last][1];\n  if (last > 0 && ease \u003c 1) {\n    tipx = verts[last - 1][0] + (verts[last][0] - verts[last - 1][0]) * ee;\n    tipy = verts[last - 1][1] + (verts[last][1] - verts[last - 1][1]) * ee;\n  }\n  const tip = [X([tipx, tipy]), Y([tipx, tipy])];\n  const own = (i) => owner[S.on[i % S.on.length]] * 3;\n  const sx = X(S.start), sy = Y(S.start);\n  if (S.balanced) {\n    // The whole bar's polygon, faint, from where this bar began.\n    const poly = S.P.slice(0, -1).map((p) => [X([p[0] + S.start[0], p[1] + S.start[1]]), Y([p[0] + S.start[0], p[1] + S.start[1]])]);\n    fill(S, poly, 0.12, col, 0);\n    for (let i = 0; i \u003c S.on.length; i++) {\n      const a = poly[i], b = poly[(i + 1) % poly.length];\n      line(S, a[0], a[1], b[0], b[1], 0.35, col, own(i));\n    }\n    // The part swept so far this bar, a wedge from the start to each edge in\n    // the edge's colour.\n    for (let i = 1; i \u003c= last; i++) {\n      const a = [X(verts[i - 1]), Y(verts[i - 1])], b = i === last ? tip : [X(verts[i]), Y(verts[i])];\n      fill(S, [[sx, sy], a, b], 0.22, col, own(i - 1));\n    }\n  } else {\n    // Earlier bars of the walk, dimmer, each with its miss dashed in red.\n    for (const h of S.hist) {\n      for (let i = 1; i \u003c h.length; i++) line(S, X(h[i - 1]), Y(h[i - 1]), X(h[i]), Y(h[i]), 0.45, col, own(i - 1));\n      line(S, X(h[h.length - 1]), Y(h[h.length - 1]), X(h[0]), Y(h[0]), 0.8, WHITE, 6, true);\n      disc(S, X(h[h.length - 1]), Y(h[h.length - 1]), 1, 0.8, WHITE, 6);\n    }\n  }\n  for (let i = 1; i \u003c last; i++) thick(S, X(verts[i - 1]), Y(verts[i - 1]), X(verts[i]), Y(verts[i]), 0.9, col, own(i - 1));\n  if (last > 0) thick(S, X(verts[last - 1]), Y(verts[last - 1]), tip[0], tip[1], 1.1, col, own(last - 1));\n  if (!S.balanced && last > 0) line(S, tip[0], tip[1], sx, sy, 0.6, WHITE, 6, true);\n  // The start, ringing when the walk comes back to it, and the tip.\n  const fc = exp(-(t - S.closeAt) / 0.45);\n  disc(S, sx, sy, 1.3 + fc, 0.7 + 0.3 * fc, WHITE, 0);\n  if (fc > 0.02) for (let i = 0; i \u003c 32; i++) dot(S, sx + (2.5 + 6 * (1 - fc)) * cos((2 * PI * i) / 32), sy + (2.5 + 6 * (1 - fc)) * sin((2 * PI * i) / 32), 0.6 * fc, WHITE, 0);\n  disc(S, tip[0], tip[1], 1.2, 1, WHITE, 0);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","berggren-tree":"// ===== Patternflow pattern =====\n// Title:   Berggren Tree\n// Family:  number\n// Idea:    Berggren's ternary tree of primitive Pythagorean triples grows from (3, 4, 5) one generation at a time over the plane of the legs, odd leg up and even leg across, its A and C branches running along the parabolas c - b = k^2 and c - a = 2n^2 on whose crossings every primitive triple sits, its B branches jumping between them, while the window widens to keep the newest generation at the edge and the crossings that are multiples never light.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euclid's formula for Pythagorean triples (Euclid, c. 300 BC), tree of primitive Pythagorean triples (B. Berggren, 1934), rediscovered (F. J. M. Barning, 1963; A. Hall, 1970), the count N / 2 pi of primitive triples with c below N (D. N. Lehmer, 1900), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Reach=-1..1, Root=0..1\n//\n// Knob 1: Hue. Turns the three matrices' colours round the wheel, skipping orange and yellow. At 0 the A branches and the triples A made are azure, C's rose and B's pale violet, with (3, 4, 5) white; at 0.25 violet, green and pink, at 0.5 red, cyan and pale green, at 0.75 green, blue and pale azure. The faint parabolas take the colour of their branches.\n// Knob 2: Speed. At 2 the first tree opens three generations grown, the window reaching odd legs of 173 and even legs of 86, and takes the rest of a 12 s run to grow to the full Reach: at Reach 0 one generation every 1.1 s, full at 8.7 s. It holds 4 s while a pulse runs out from the root a generation at a time, then fades and starts again from (3, 4, 5) alone, every 16 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Reach. How far the window has widened when the run ends: odd legs up to 128 u and even legs up to 64 u, u = 4 x 2^Reach. At 0 the legs reach 512 and 256 and the window holds 61 triples down to the 10th generation, on 71 crossings of the two families, 10 of them multiples like 9 (3, 4, 5) that stay dark; at -1, 30 triples to the 6th generation, at 1, 124 to the 14th. The window starts at 0.18 of its last size at Reach 0 (0.28 at -1, 0.12 at 1) and widens as (G + 8)^2 with the generation G.\n// Knob 4: Root. Bends the plane from the legs, z^2 for z = m + i n, at 0.06 and below, to z itself at 1, the plane of Euclid's (m, n): the parabolas straighten, the C branches stand upright with n fixed, the A branches run at 45 degrees with m - n fixed, and the triples sit on the lattice of coprime m > n of opposite parity.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, abs, sqrt, atan2, cos, sin, pow, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n// The wheel without its orange and yellow, 0.03 to 0.17.\nconst wheel = (h) => 0.17 + (h - floor(h)) * 0.86;\n\n// Every primitive triple is (m^2 - n^2, 2mn, m^2 + n^2) for one pair m > n\n// > 0, coprime and of opposite parity, and Berggren's matrices A, B and C on\n// (a, b, c) are, on (m, n):\n//   A: (m, n) -> (2m - n, m)   keeps m - n, so c - b = (m - n)^2\n//   B: (m, n) -> (2m + n, m)\n//   C: (m, n) -> (m + 2n, n)   keeps n, so c - a = 2 n^2\n// from (2, 1), which is (3, 4, 5). A child's c is always larger than its\n// parent's, so cutting the tree at c \u003c= CB keeps every triple up to CB.\nconst UMAX = 8, CB = 170 * UMAX;\nconst NM = [2], NN = [1], ND = [0], NX = [-1], NPAR = [-1];\nfor (let i = 0; i \u003c NM.length; i++) {\n  const m = NM[i], n = NN[i], kids = [[2 * m - n, m], [2 * m + n, m], [m + 2 * n, n]];\n  for (let k = 0; k \u003c 3; k++) {\n    const M = kids[k][0], N = kids[k][1];\n    if (M * M + N * N > CB) continue;\n    NM.push(M);\n    NN.push(N);\n    ND.push(ND[i] + 1);\n    NX.push(k);\n    NPAR.push(i);\n  }\n}\nconst NNODE = NM.length;\nconst RUN = 12, HOLD = 4, G0 = 8;\n\nexport function setup(params) {\n  params.s = {\n    rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3), c: new Float32Array(3), cols: [0, 1, 2].map(() => new Float32Array(3)),\n    o: [0, 0], key: \"\", deep: 1, tau: 0, hold: 0, fade: 0, G: 0, started: false,\n    hue: 0, speed: 2, uf: 4, u: 1, p: 2, sc: 1,\n  };\n}\n\n// Where (m, n) lands: z = m + i n raised to the power p and scaled so that\n// |z|^2 = 128 u reaches the top row. At p = 2 that is the odd leg a up and\n// the even leg b across, u legs to an LED; at p = 1 the lattice of (m, n).\nfunction proj(S, m, n, out) {\n  if (S.p === 2) {\n    out[0] = 2 * m * n * S.sc;\n    out[1] = H - 1 - (m * m - n * n) * S.sc;\n    return;\n  }\n  const r2 = m * m + n * n, th = atan2(n, m) * S.p, rp = pow(r2, S.p / 2) * S.sc;\n  out[0] = rp * sin(th);\n  out[1] = H - 1 - rp * cos(th);\n}\nconst inside = (x, y) => x >= -0.5 && x \u003c W - 0.5 && y >= -0.5 && y \u003c H - 0.5;\nfunction scale(S, u) {\n  S.u = u;\n  S.sc = 128 / pow(128 * u, S.p / 2);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.uf = 4 * pow(2, cl(k[2], -1, 1));\n  S.p = 2 - cl((k[3] - 0.06) / 0.94, 0, 1);\n  // The deepest generation with a triple inside the window at full reach.\n  const key = S.uf.toFixed(4) + \",\" + S.p.toFixed(4);\n  if (key !== S.key) {\n    S.key = key;\n    scale(S, S.uf);\n    S.deep = 1;\n    for (let i = 0; i \u003c NNODE; i++) {\n      proj(S, NM[i], NN[i], S.o);\n      if (inside(S.o[0], S.o[1])) S.deep = max(S.deep, ND[i]);\n    }\n  }\n  // The first tree opens three generations grown; the later ones start\n  // from (3, 4, 5) alone.\n  if (!S.started) {\n    S.started = true;\n    S.tau = (3 * RUN) / (S.deep + 1);\n  }\n  const g = d * (S.speed / 2);\n  S.fade = max(0, S.fade - d / 0.6);\n  if (S.tau \u003c RUN) S.tau = min(RUN, S.tau + g);\n  else {\n    S.hold += g;\n    if (S.hold > HOLD) {\n      S.old.set(S.rgb);\n      S.tau = S.hold = 0;\n      S.fade = 1;\n    }\n  }\n  // One generation after another, each in the same share of the run, and\n  // the window widening as (G + G0)^2, the way the reach of a generation\n  // along A or C grows, so the newest one always spans the panel.\n  const D = S.deep + 1;\n  S.G = (D * S.tau) / RUN;\n  scale(S, S.uf * ((S.G + G0) / (D + G0)) ** 2);\n}\n\n// While the grown tree holds, a pulse runs out from the root through the\n// generations, one generation every RUN / (deep + 1) at Speed 2.\nfunction wave(S, d) {\n  if (S.tau \u003c RUN) return 0;\n  const at = (S.hold / HOLD) * (S.deep + 2) - 0.5, e = (d - at) / 0.6;\n  return exp(-e * e);\n}\n\nfunction put(rgb, x, y, r, g, b) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  if (r > rgb[o]) rgb[o] = r;\n  if (g > rgb[o + 1]) rgb[o + 1] = g;\n  if (b > rgb[o + 2]) rgb[o + 2] = b;\n}\n\n// A straight run in (m, n) from its start to t1 of the way, through the\n// projection: for A and C the run lies on m - n = k or n = const, so the\n// branch is drawn along its parabola.\nfunction branch(S, rgb, m0, n0, m1, n1, t1, col, w) {\n  const o = S.o;\n  proj(S, m0, n0, o);\n  const x0 = o[0], y0 = o[1];\n  proj(S, m0 + (m1 - m0) * t1, n0 + (n1 - n0) * t1, o);\n  const steps = max(2, min(300, floor((abs(o[0] - x0) + abs(o[1] - y0)) * 1.5)));\n  const r = col[0] * w, g = col[1] * w, b = col[2] * w;\n  for (let i = 0; i \u003c= steps; i++) {\n    const t = (t1 * i) / steps;\n    proj(S, m0 + (m1 - m0) * t, n0 + (n1 - n0) * t, o);\n    if (o[1] \u003c -1 || o[0] > W) return;\n    put(rgb, o[0], o[1], r, g, b);\n  }\n  // A branch still growing carries a white spark at its tip.\n  if (t1 \u003c 1) put(rgb, o[0], o[1], 255, 255, 255);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, cols, o } = S;\n  rgb.fill(0);\n  const h = S.hue, G = S.G;\n  hsv(wheel(0.452 + h), 0.75, 1, cols[0]); // A\n  hsv(wheel(0.72 + h), 0.3, 1, cols[1]); // B\n  hsv(wheel(0.88 + h), 0.6, 1, cols[2]); // C\n  // The two families the branches run along, faint: m - n = k for odd k,\n  // c - b = k^2, starting up the left edge at a = k^2, and n = 1, 2, ...,\n  // c - a = 2 n^2, starting along the foot at b = 2 n^2. Every primitive\n  // triple sits on a crossing, but not every crossing is primitive: (6, 3)\n  // is 9 (3, 4, 5), and the tree never lights it.\n  const top = sqrt(200 * S.u) + 2;\n  hsv(wheel(0.452 + h), 0.5, 0.19, S.c);\n  for (let k = 1; k \u003c top; k += 2) branch(S, rgb, k, 0, k + top, top, 1, S.c, 1);\n  hsv(wheel(0.88 + h), 0.45, 0.19, S.c);\n  for (let n = 1; n \u003c top; n++) branch(S, rgb, n, n, n + 2 * top, n, 1, S.c, 1);\n  // The branches: growing for a generation, then A and C stay as the\n  // parabolas they lie on and B, which jumps between them, fades.\n  for (let i = 1; i \u003c NNODE; i++) {\n    const f = G - (ND[i] - 1);\n    if (f \u003c= 0) continue;\n    const j = NPAR[i], k = NX[i];\n    proj(S, NM[j], NN[j], o);\n    if (!inside(o[0], o[1])) continue;\n    const w = (k === 1 ? (f \u003c 1 ? 0.5 : 0) : f \u003c 1 ? 1 : max(0.55, 1 - (f - 1) * 0.45)) + wave(S, ND[i]) * 0.5;\n    if (w > 0) branch(S, rgb, NM[j], NN[j], NM[i], NN[i], min(1, f), cols[k], w);\n  }\n  // The triples, five-LED crosses in the colour of the matrix that made\n  // them, white as they arrive and the root (3, 4, 5) white for good.\n  for (let i = 0; i \u003c NNODE; i++) {\n    const age = G - ND[i];\n    if (age \u003c 0) continue;\n    proj(S, NM[i], NN[i], o);\n    const x = round(o[0]), y = round(o[1]);\n    if (x \u003c -1 || y \u003c -1 || x > W || y > H) continue;\n    const k = NX[i], fl = k \u003c 0 ? 1 : max(0, 1 - age, wave(S, ND[i])), col = cols[max(0, k)];\n    const R = col[0] + (255 - col[0]) * fl, Gg = col[1] + (255 - col[1]) * fl, B = col[2] + (255 - col[2]) * fl;\n    put(rgb, x, y, 160 + R * 0.4, 160 + Gg * 0.4, 160 + B * 0.4);\n    put(rgb, x + 1, y, R * 0.8, Gg * 0.8, B * 0.8);\n    put(rgb, x - 1, y, R * 0.8, Gg * 0.8, B * 0.8);\n    put(rgb, x, y + 1, R * 0.8, Gg * 0.8, B * 0.8);\n    put(rgb, x, y - 1, R * 0.8, Gg * 0.8, B * 0.8);\n  }\n  const fd = S.fade, old = S.old;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      let r = min(255, rgb[p]), gg = min(255, rgb[p + 1]), b = min(255, rgb[p + 2]);\n      if (fd > 0) (r = max(r, old[p] * fd)), (gg = max(gg, old[p + 1] * fd)), (b = max(b, old[p + 2] * fd));\n      (rgb[p] = r), (rgb[p + 1] = gg), (rgb[p + 2] = b);\n      display.setPixel(x, y, r, gg, b);\n    }\n}\n","busy-beaver":"// ===== Patternflow pattern =====\n// Title:   Busy Beaver\n// Family:  algo\n// Idea:    The busy beaver Turing machines write their tapes as space-time diagrams, tape across and time down, the five-state champion's 47,176,870 steps folding into a stack of triangles that zooms out as it grows, one triangle for each pass of its Collatz-like loop.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: busy beaver game (Tibor Rado, 1962), S(3) = 21 (Shen Lin and Tibor Rado, 1965), S(4) = 107 (Allen Brady, 1983), five-state champion (Heiner Marxen and Juergen Buntrock, 1989), its Collatz-like loop (Pascal Michel, 1993), S(5) = 47,176,870 proved (bbchallenge, 2024), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Machine=0..3, Clock=0..1\n//\n// Knob 1: Hue. Turns the tape colour round the wheel, skipping orange and yellow. At 0 the tape is azure, pale where it holds solid 1s and deep blue where it holds the champion's stripes 100 100 100, averaged to a third; the head's left turns are gold and its right turns rose, the sides of every triangle.\n// Knob 2: Speed. At 2 the champion opens 100 turns and 3592 steps in, and its turns grow 9.4 percent a second, a new triangle about every 6 s (0.6, 6.9, 13.0, 18.9, 24.8, 30.6, 36.3, 42.0 and 48.7 s). From 45.7 s, 9.9 million steps in, the panel spends no more than 2.4 million steps a second and the zoom waits for the machine; it halts at 62.2 s, holds 6 s and starts again. At 0.2 ten times slower, halting at 636 s; at 3 it halts at 41.5 s. The small machines take 3 s for their whole run at 2 and hold 3 s.\n// Knob 3: Machine. 0 is the five-state champion of Heiner Marxen and Juergen Buntrock, 47,176,870 steps, 12,258 turns and 4098 ones over 12,289 cells; 1 is Allen Brady's four-state champion, 107 steps and 13 ones over 14 cells, 4 LEDs a cell and 1 row a step; 2 is the three-state machine of 21 steps and 5 ones, 12 LEDs a cell and 5 rows a step; 3 is the two-state one, 6 steps and 4 ones, 16 LEDs a cell and 15 rows a step. The counts sit at the top left for the champion and under the small diagrams, steps above and the 1s on the tape now below, and turn white at the halt.\n// Knob 4: Clock. What a row of the champion counts. At 0 every sweep, turn to turn, gets the same height and the triangles have straight sides; at 1 every step does, and they swell into arches as the sweeps lengthen, until at the halt the last pass, 30.2 of the 47.2 million steps, takes the bottom 82 rows. At the opening 0.06 a row is nearly a sweep. The small machines always give each step its own band of rows.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, log } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The machines in the notation of bbchallenge: for each state A, B, ... the\n// moves on reading 0 and on reading 1, each the symbol to write, the way to\n// go and the next state, Z for halt.\nconst MACHINES = [\n  \"1RB1LC_1RC1RB_1RD0LE_1LA1LD_1RZ0LA\", // Marxen and Buntrock, 5 states\n  \"1RB1LB_1LA0LC_1RZ1LD_1RD0RA\", // Brady, 4 states\n  \"1RB1RZ_1LB0RC_1LC1LA\", // Lin and Rado, 3 states\n  \"1RB1LB_1LA1RZ\", // 2 states\n];\nfunction parse(text) {\n  const st = text.split(\"_\"), n = st.length;\n  const wr = new Int8Array(2 * n), dr = new Int8Array(2 * n), nx = new Int8Array(2 * n);\n  for (let s = 0; s \u003c n; s++)\n    for (let r = 0; r \u003c 2; r++) {\n      const m = st[s].slice(3 * r, 3 * r + 3), o = 2 * s + r;\n      wr[o] = m.charCodeAt(0) - 48;\n      dr[o] = m[1] === \"R\" ? 1 : -1;\n      nx[o] = m[2] === \"Z\" ? -1 : m.charCodeAt(2) - 65;\n    }\n  return { wr, dr, nx, n };\n}\nconst TABLES = MACHINES.map(parse);\n\n// The tape: the start cell sits at ORG, with room for the champion's 12,243\n// cells to the left and 45 to the right.\nconst TL = 16384, ORG = 13600;\n// Snapshots of the tape, as running counts of 1s over blocks of 2^bs cells,\n// never more than NB blocks, taken at every step for the first 256 and\n// after that at a turn of the head once the steps or the turns have grown\n// by a 200th since the last one: 1894 over the champion's run.\nconst SMAX = 4096, NB = 256, BLK = NB + 2;\nconst RATE = 0.09, TAU0 = 100, CAP = 40000, RUN = 3, HOLD = 3, HOLD5 = 6;\nconst SMALL_H = 110, SH = [0.55, 0.2, 0.75, 0.37, 0.9];\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\n\nexport function setup(params) {\n  params.s = {\n    tape: new Uint8Array(TL), blk: new Int32Array(TL), pool: new Uint16Array(SMAX * BLK),\n    sStep: new Float64Array(SMAX), sTurn: new Int32Array(SMAX), sHead: new Int32Array(SMAX), sState: new Int8Array(SMAX),\n    sP0: new Int32Array(SMAX), sBs: new Int8Array(SMAX), sNb: new Int16Array(SMAX), sLo: new Int32Array(SMAX), sHi: new Int32Array(SMAX),\n    tStep: new Float64Array(16384), tPos: new Int32Array(16384), tState: new Int8Array(16384),\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3), cs: new Float32Array(SMAX),\n    tw: new Float32Array(W * H), trgb: new Float32Array(W * H * 3), tx: new Int16Array(16384), ty: new Int16Array(16384),\n    pal: new Float32Array(9), sc: [0, 1, 2, 3, 4].map(() => new Float32Array(3)), white: [255, 255, 255],\n    m: -1, hue: 0, speed: 2, q: 0.06, fins: [],\n  };\n}\n\nfunction fresh(S, m) {\n  S.m = m;\n  S.T = TABLES[m];\n  S.tape.fill(0);\n  S.blk.fill(0);\n  S.h = ORG;\n  S.st = 0;\n  S.steps = 0;\n  S.lo = S.hi = ORG;\n  S.bs = 0;\n  S.lastD = 0;\n  S.nt = 0;\n  S.ns = 0;\n  S.lastSnapStep = 0;\n  S.lastSnapTurn = 0;\n  S.halted = false;\n  S.r = 0;\n  S.hold = 0;\n  S.tmp = false;\n  snap(S, false);\n  if (m === 0) advance(S, TAU0, 1e9);\n  else S.fin = S.fins[m] || (S.fins[m] = measure(S.T));\n}\n\n// A small machine's whole run on a scratch tape: its steps and the cells it\n// visits, so its diagram can be laid out before it starts.\nfunction measure(T) {\n  const tape = new Uint8Array(64);\n  let h = 32, st = 0, steps = 0, lo = 32, hi = 32;\n  while (st >= 0 && steps \u003c 1000) {\n    const o = 2 * st + tape[h];\n    tape[h] = T.wr[o];\n    h += T.dr[o];\n    st = T.nx[o];\n    steps++;\n    lo = min(lo, h);\n    hi = max(hi, h);\n  }\n  return { steps, lo: lo - 32 + ORG, hi: hi - 32 + ORG };\n}\n\nfunction snap(S, tmp) {\n  if (S.ns >= SMAX) return;\n  S.tmp = tmp;\n  const j = S.ns++, bs = S.bs, p0 = S.lo >> bs, nb = (S.hi >> bs) - p0 + 1, o = j * BLK;\n  const { pool, blk } = S;\n  pool[o] = 0;\n  for (let b = 0; b \u003c nb; b++) pool[o + b + 1] = pool[o + b] + blk[p0 + b];\n  S.sStep[j] = S.steps;\n  S.sTurn[j] = S.nt;\n  S.sHead[j] = S.h;\n  S.sState[j] = S.st;\n  S.sP0[j] = p0;\n  S.sBs[j] = bs;\n  S.sNb[j] = nb;\n  S.sLo[j] = S.lo;\n  S.sHi[j] = S.hi;\n  if (!tmp) {\n    S.lastSnapStep = S.steps;\n    S.lastSnapTurn = S.nt;\n  }\n}\n\n// Doubles the block size of the running counts when the tape outgrows NB.\nfunction coarsen(S) {\n  const { blk } = S, n = TL >> S.bs;\n  for (let i = 0; i \u003c n / 2; i++) blk[i] = blk[2 * i] + blk[2 * i + 1];\n  for (let i = n / 2; i \u003c n; i++) blk[i] = 0;\n  S.bs++;\n}\n\n// Runs the machine until it has made `turns` turns or `steps` steps more.\nfunction advance(S, turns, budget) {\n  if (S.halted) return 0;\n  // A snapshot left at the end of the last frame only stood for the bottom\n  // row; the run goes on from the one before it.\n  if (S.tmp) {\n    S.ns--;\n    S.tmp = false;\n  }\n  const { tape, blk, tStep, tPos, tState } = S, { wr, dr, nx } = S.T;\n  let h = S.h, st = S.st, steps = S.steps, lo = S.lo, hi = S.hi, lastD = S.lastD, bs = S.bs, nt = S.nt;\n  const end = steps + budget;\n  while (steps \u003c end && nt \u003c turns) {\n    const sym = tape[h], o = 2 * st + sym, w = wr[o], d = dr[o];\n    let turned = false;\n    if (w !== sym) {\n      tape[h] = w;\n      blk[h >> bs] += w - sym;\n    }\n    if (d !== lastD) {\n      if (lastD !== 0) {\n        tStep[nt] = steps;\n        tPos[nt] = h;\n        tState[nt] = st;\n        nt++;\n        turned = true;\n      }\n      lastD = d;\n    }\n    h += d;\n    st = nx[o];\n    steps++;\n    if (h \u003c lo || h > hi) {\n      if (h \u003c lo) lo = h;\n      else hi = h;\n      if ((hi >> bs) - (lo >> bs) >= NB) {\n        S.bs = bs;\n        coarsen(S);\n        bs = S.bs;\n      }\n    }\n    if (st \u003c 0) {\n      S.halted = true;\n      break;\n    }\n    if (steps \u003c 256 || (turned && ((steps - S.lastSnapStep) * 200 >= steps || (nt - S.lastSnapTurn) * 200 >= nt))) {\n      S.h = h; S.st = st; S.steps = steps; S.lo = lo; S.hi = hi; S.nt = nt;\n      snap(S, false);\n    }\n  }\n  const did = budget - (end - steps);\n  S.h = h; S.st = st; S.steps = steps; S.lo = lo; S.hi = hi; S.lastD = lastD; S.nt = nt;\n  if (S.halted) {\n    S.st = -1;\n    snap(S, false);\n  } else if (S.lastSnapStep !== steps) snap(S, true);\n  return did;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.q = cl(k[3], 0, 1);\n  const m = cl(floor(k[2] + 0.5), 0, 3);\n  if (m !== S.m) fresh(S, m);\n  const g = d * (S.speed / 2);\n  if (S.halted) {\n    S.hold += g;\n    if (S.hold > (m === 0 ? HOLD5 : HOLD)) fresh(S, m);\n    return;\n  }\n  if (m === 0) {\n    // The turns grow by RATE a second at Speed 2, unless that would take\n    // more than CAP steps a frame; then the zoom waits for the machine.\n    const r = S.r + g, target = floor(TAU0 * exp(RATE * r)), budget = floor(CAP * S.speed * 30 * d);\n    const did = target > S.nt ? advance(S, target, max(1, budget)) : 0;\n    S.r = did >= budget ? log(max(S.nt, TAU0) / TAU0) / RATE : r;\n  } else {\n    S.r += g;\n    const want = floor((S.fin.steps * S.r) / RUN);\n    if (want > S.steps) advance(S, 1e9, want - S.steps);\n  }\n}\n\n// Where a snapshot sits down the panel, 0 to 1: the share of sweeps (each\n// sweep, turn to turn, one unit, its steps spread evenly through it) mixed\n// with the share of steps by the Clock knob.\nfunction clocks(S) {\n  const { tStep, sStep, sTurn, cs } = S, nt = S.nt, now = S.steps, q = S.q;\n  const tk = nt > 0 ? tStep[nt - 1] : 0, prev = nt > 1 ? tStep[nt - 1] - tStep[nt - 2] : 1;\n  const curLen = max(1, now - tk, prev), sigNow = max(1e-9, nt + (now - tk) / curLen);\n  for (let j = 0; j \u003c S.ns; j++) {\n    const s = sStep[j], kk = sTurn[j];\n    const a = kk > 0 ? tStep[kk - 1] : 0, b = kk \u003c nt ? tStep[kk] : a + curLen;\n    cs[j] = (1 - q) * ((kk + (s - a) / max(1, b - a)) / sigNow) + q * (s / max(1, now));\n  }\n  return sigNow;\n}\n\n// The running count of 1s left of cell p in snapshot j, blocks interpolated.\nfunction cum(S, j, p) {\n  const bs = S.sBs[j], u = p / (1 \u003c\u003c bs) - S.sP0[j], nb = S.sNb[j], o = j * BLK, pool = S.pool;\n  if (u \u003c= 0) return 0;\n  if (u >= nb) return pool[o + nb];\n  const i = floor(u);\n  return pool[o + i] + (pool[o + i + 1] - pool[o + i]) * (u - i);\n}\n\nfunction shade(S, dn, out) {\n  const P = S.pal;\n  if (dn \u003c= 1 / 3) {\n    const u = dn * 3;\n    for (let i = 0; i \u003c 3; i++) out[i] = P[3 + i] + (P[i] - P[3 + i]) * u;\n  } else {\n    const u = (dn - 1 / 3) * 1.5;\n    for (let i = 0; i \u003c 3; i++) out[i] = P[i] + (P[6 + i] - P[i]) * u;\n  }\n}\n\n// The champion: every row the tape at one moment, the window the whole tape\n// so far, each LED the share of 1s in its 1/64 of it.\nfunction drawChampion(S) {\n  const { rgb, c, tw, trgb } = S, col = [0, 0, 0];\n  const sigNow = clocks(S), cs = S.cs, lo = S.lo, ext = S.hi - S.lo + 1, C = ext / W;\n  let j = 0;\n  for (let y = 0; y \u003c H; y++) {\n    const want = (y + 1) / H - 1e-9;\n    while (j + 1 \u003c S.ns && cs[j + 1] \u003c= want) j++;\n    const sl = S.sLo[j], sh = S.sHi[j] + 1;\n    // Each LED averages a whole number of the stripes' 3 cells and of the\n    // snapshot's blocks, so 100 100 100 comes out a third everywhere\n    // instead of beating against the LEDs.\n    const u = 3 \u003c\u003c S.sBs[j], wf = u * Math.ceil(C / u - 1e-9);\n    for (let x = 0; x \u003c W; x++) {\n      const a = lo + x * C, b = a + C;\n      if (b \u003c= sl || a >= sh) continue;\n      const m = (a + b) / 2;\n      const dn = (cum(S, j, m + wf / 2) - cum(S, j, m - wf / 2)) / wf;\n      shade(S, cl(dn, 0, 1), col);\n      const o = (y * W + x) * 3;\n      rgb[o] = col[0];\n      rgb[o + 1] = col[1];\n      rgb[o + 2] = col[2];\n    }\n  }\n  // Every turn of the head in the colour of the state it turned in. The\n  // champion turns left in A and right in D, so the head draws the sides\n  // of its own triangles.\n  tw.fill(0);\n  trgb.fill(0);\n  const { tStep, tPos, tState, nt } = S, q = S.q;\n  const TX = S.tx, TY = S.ty;\n  for (let i = 0; i \u003c nt; i++) {\n    const cc = (1 - q) * ((i + 1) / sigNow) + q * (tStep[i] / max(1, S.steps));\n    const y = min(H - 1, floor(cc * H)), x = min(W - 1, floor((tPos[i] - lo) / C)), P = S.sc[tState[i]];\n    TX[i] = x;\n    TY[i] = y;\n    // Joined to the turn two before it, on the same side, so the sides\n    // stay whole lines while a sweep is taller than a row.\n    let x1 = x, y1 = y;\n    if (i >= 2 && tState[i - 2] === tState[i] && abs(TX[i - 2] - x) \u003c= 3 && y - TY[i - 2] \u003c= 8) (x1 = TX[i - 2]), (y1 = TY[i - 2]);\n    const n = max(1, abs(x - x1), y - y1);\n    for (let k = n === 1 && x1 === x && y1 === y ? 0 : 1; k \u003c= n; k++) {\n      const px = round(x1 + ((x - x1) * k) / n), py = round(y1 + ((y - y1) * k) / n), p = py * W + px;\n      tw[p]++;\n      trgb[p * 3] += P[0];\n      trgb[p * 3 + 1] += P[1];\n      trgb[p * 3 + 2] += P[2];\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    if (!tw[p]) continue;\n    const w = min(1, 0.6 + tw[p] * 0.2), o = p * 3, n = tw[p];\n    for (let i = 0; i \u003c 3; i++) rgb[o + i] = rgb[o + i] * (1 - w) + (trgb[o + i] / n) * w;\n  }\n  // The head now, at the foot of the diagram.\n  if (!S.halted) {\n    const x = min(W - 1, floor((S.h - lo) / C)), P = S.sc[S.st];\n    for (let y = H - 4; y \u003c H; y++) {\n      const o = (y * W + x) * 3;\n      rgb[o] = y === H - 1 ? 255 : P[0];\n      rgb[o + 1] = y === H - 1 ? 255 : P[1];\n      rgb[o + 2] = y === H - 1 ? 255 : P[2];\n    }\n  }\n}\n\n// A small machine: one row band for every step, the cells as blocks over\n// the tape its whole run will use, a dark line between bands and cells\n// once they are 4 LEDs or more.\nfunction drawSmall(S) {\n  const { rgb } = S, col = [0, 0, 0], F = S.fin, ext = F.hi - F.lo + 1;\n  const cw = floor(W / ext), x0 = floor((W - cw * ext) / 2), rh = floor(SMALL_H / (F.steps + 1));\n  for (let j = 0; j \u003c S.ns; j++) {\n    const sl = S.sLo[j], sh = S.sHi[j], hd = S.sHead[j], st = S.sState[j];\n    for (let p = sl; p \u003c= sh; p++) {\n      const one = cum(S, j, p + 1) - cum(S, j, p) > 0.5;\n      shade(S, one ? 1 : 0, col);\n      if (p === hd) {\n        const P = st >= 0 ? S.sc[st] : S.white;\n        for (let i = 0; i \u003c 3; i++) col[i] = one ? P[i] * 0.75 + col[i] * 0.25 : P[i] * 0.8;\n      }\n      const xa = x0 + (p - F.lo) * cw, xb = xa + cw - (cw >= 4 && rh >= 4 ? 1 : 0);\n      const ya = j * rh, yb = ya + rh - (rh >= 4 ? 1 : 0);\n      for (let y = ya; y \u003c yb; y++)\n        for (let x = xa; x \u003c xb; x++) {\n          const o = (y * W + x) * 3;\n          rgb[o] = col[0];\n          rgb[o + 1] = col[1];\n          rgb[o + 2] = col[2];\n        }\n    }\n  }\n}\n\nfunction number(rgb, n, x, y, P) {\n  const s = String(n);\n  for (let i = 0; i \u003c s.length; i++) {\n    const g = DIG[s.charCodeAt(i) - 48];\n    for (let k = 0; k \u003c 15; k++)\n      if (g[k] === \"1\") {\n        const o = ((y + floor(k / 3)) * W + x + 4 * i + (k % 3)) * 3;\n        rgb[o] = P[0];\n        rgb[o + 1] = P[1];\n        rgb[o + 2] = P[2];\n      }\n  }\n}\n\n// Orange and yellow read brown on an LED when dim, so the tape takes its\n// hue from a wheel without 0.03 to 0.17.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c } = S;\n  rgb.fill(0);\n  const h0 = wheel(0.477 + S.hue), P = S.pal;\n  hsv(h0, 0.9, 0.5, c);\n  P[0] = c[0]; P[1] = c[1]; P[2] = c[2];\n  P[3] = 7; P[4] = 9; P[5] = 16;\n  hsv(h0 - 0.03, 0.28, 1, c);\n  P[6] = c[0]; P[7] = c[1]; P[8] = c[2];\n  for (let i = 0; i \u003c 5; i++) {\n    hsv(h0 + SH[i], 0.75, 1, c);\n    S.sc[i][0] = c[0]; S.sc[i][1] = c[1]; S.sc[i][2] = c[2];\n  }\n  if (S.m === 0) drawChampion(S);\n  else drawSmall(S);\n  // The counts: steps, then the 1s on the tape now.\n  let ones = 0;\n  for (let b = S.lo >> S.bs; b \u003c= S.hi >> S.bs; b++) ones += S.blk[b];\n  hsv(h0 + 0.5, 0.12, S.halted ? 0.95 : 0.55, c);\n  const y = S.m === 0 ? 1 : 114;\n  number(rgb, S.steps, 1, y, c);\n  hsv(h0 - 0.03, 0.35, S.halted ? 1 : 0.7, c);\n  number(rgb, ones, 1, y + 7, c);\n  for (let p = 0, yy = 0; yy \u003c H; yy++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, yy, min(255, rgb[p]), min(255, rgb[p + 1]), min(255, rgb[p + 2]));\n}\n","feynman-checkerboard":"// ===== Patternflow pattern =====\n// Title:   Feynman Checkerboard\n// Family:  wave\n// Idea:    Time runs down the panel and space across it on Feynman's light-cone lattice, where a particle steps one site left or right each row and every corner multiplies its amplitude by i epsilon: four such zigzag paths fall from the source with each corner marked in the colour of i^R, the exact sum over all 2^128 of them glows underneath as phase and brightness, and its gold mean position trembles from side to side, Schroedinger's Zitterbewegung.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dirac equation (Paul Dirac, 1928), Zitterbewegung (Erwin Schroedinger, 1930), Feynman's checkerboard (Richard Feynman; Richard Feynman and Albert Hibbs, Quantum Mechanics and Path Integrals, 1965, problem 2-6), continuum limit of the checkerboard (Ted Jacobson and Lawrence Schulman, 1984), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mass=0.08..0.4, Focus=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the source's own phase is azure, so the field opens azure at the top and turns through violet, red, gold and green as its phase runs on down the panel; a corner dot is azure, violet, red or green as the path has made 0, 1, 2 or 3 corners mod 4, and the mean is pale gold. At 0.5 the field opens amber and the mean turns lavender.\n// Knob 2: Speed. How fast the present, the row the paths have reached, runs down: 16 rows a second per unit, so at 2 a sweep takes 4 s and the paths fade for 0.6 s at the bottom before four new ones leave the source; at 0.2 a sweep takes 40 s, at 3 it takes 2.7 s. Rows the present has passed are lit fully, rows ahead of it at 0.6, and the opening sweep starts on row 40.\n// Knob 3: Mass. epsilon = m dt, from 0.08 to 0.4. A path turns with probability eps / (1 + eps) a step, every 13.5 rows at 0.08 and every 3.5 at 0.4; the packet's phase turns once in 2 pi / atan(eps) rows, 79 at 0.08 and 16.5 at 0.4; and the mean trembles with a period of pi / atan(eps) rows, 39 at 0.08, where it swings 3 to 6 LEDs peak to peak, and 8.3 at 0.4, where it swings 0.5 to 1.2.\n// Knob 4: Focus. The source packet's width, sigma = 1.5 (1 - Focus)^1.5 / eps sites, two sites to an LED: 17 sites at the opening 0.06, 1.4 Compton wavelengths 1 / eps, where the mean trembles clearly; 6.6 sites at 0.5; at 1 a single site, the point source of Feynman's propagator, whose cone edges are the one path with no corner (right) and the one that turns at once (left), whose phase bands are the hyperbolas of constant proper time, and whose mean runs right at 0.92 c and leaves the panel on row 69.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, exp, atan2, round, ceil, hypot, PI, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The lattice: two sites to an LED across, one time step to a row down.\n// The panel shows sites M .. M + 127 of a line of NX = 384 sites, and the\n// line runs 192 sites either side of the source, past the 128 that light\n// covers in the panel's 128 steps. Amplitude that leaves the panel's sides\n// is still carried, comes back when its paths do, and never meets an end:\n// the panel shows the free propagator, exactly.\nconst C = 2, M = 128, NX = 128 + 2 * M, X0 = M + 64;\nconst ux = (s) => (s - M + 0.5) / C - 0.5; // site -> splat x\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, eps: 0.08, focus: 0.06, key: '',\n    Rr: new Float64Array(NX), Ri: new Float64Array(NX), Lr: new Float64Array(NX), Li: new Float64Array(NX),\n    nRr: new Float64Array(NX), nRi: new Float64Array(NX), nLr: new Float64Array(NX), nLi: new Float64Array(NX),\n    rho: new Float32Array(N), ph: new Float32Array(N), V: new Float32Array(N), mean: new Float64Array(H), tot: new Float64Array(H),\n    D: new Float32Array(N),\n    paths: [], R: new Float32Array(N), G: new Float32Array(N), B: new Float32Array(N), c: new Float32Array(15),\n  };\n}\n\n// One step of the checkerboard, unitary form: going straight costs\n// a = 1 / sqrt(1 + eps^2), a corner b = i eps / sqrt(1 + eps^2), so a path\n// with R corners carries (i eps)^R / (1 + eps^2)^(T/2).\n//   R(x, t+1) = a R(x-1, t) + b L(x-1, t)\n//   L(x, t+1) = a L(x+1, t) + b R(x+1, t)\nfunction field(S) {\n  const eps = S.eps, a = 1 / sqrt(1 + eps * eps), b = eps / sqrt(1 + eps * eps);\n  let { Rr, Ri, Lr, Li, nRr, nRi, nLr, nLi } = S;\n  Rr.fill(0); Ri.fill(0); Lr.fill(0); Li.fill(0);\n  // The source: a Gaussian packet at rest in the right-moving component,\n  // width sigma sites, on the sites of one parity.\n  const sigma = S.sigma;\n  let n = 0;\n  for (let s = 0; s \u003c NX; s++) {\n    const d = s - X0;\n    if (d & 1) continue;\n    const g = sigma \u003c 0.5 ? +(d === 0) : exp((-d * d) / (4 * sigma * sigma));\n    Rr[s] = g;\n    n += g * g;\n  }\n  n = 1 / sqrt(n);\n  for (let s = 0; s \u003c NX; s++) Rr[s] *= n;\n  const { rho, ph, mean, tot } = S;\n  for (let t = 0; t \u003c H; t++) {\n    let m = 0, p = 0;\n    for (let s = 0; s \u003c NX; s++) {\n      const q = Rr[s] * Rr[s] + Ri[s] * Ri[s] + Lr[s] * Lr[s] + Li[s] * Li[s];\n      p += q;\n      m += q * s;\n    }\n    mean[t] = m / p;\n    tot[t] = p;\n    // The brightness scale of the row: the densest site within t/2 + 2 sigma\n    // of the centre, so the two straight paths along a point source's cone\n    // do not black out the rest; brightness is (density / scale)^0.4.\n    let mx = 0;\n    const half = max(2, floor(t / 2 + 2 * S.sigma));\n    for (let s = max(1, X0 - half); s \u003c= min(NX - 2, X0 + half); s++) {\n      const q = Rr[s] * Rr[s] + Ri[s] * Ri[s] + Lr[s] * Lr[s] + Li[s] * Li[s];\n      if (q > mx) mx = q;\n    }\n    const ref = mx > 0 ? mx : 1;\n    // The live site under LED X on row t is M + 2X + (t & 1).\n    for (let X = 0; X \u003c W; X++) {\n      const s = M + 2 * X + ((t + X0) & 1), o = t * W + X;\n      rho[o] = Rr[s] * Rr[s] + Ri[s] * Ri[s] + Lr[s] * Lr[s] + Li[s] * Li[s];\n      ph[o] = atan2(Ri[s] + Li[s], Rr[s] + Lr[s]) / (2 * PI);\n      S.V[o] = min(1, (rho[o] / ref) ** 0.4);\n    }\n    for (let s = 1; s \u003c NX - 1; s++) {\n      nRr[s] = a * Rr[s - 1] - b * Li[s - 1];\n      nRi[s] = a * Ri[s - 1] + b * Lr[s - 1];\n      nLr[s] = a * Lr[s + 1] - b * Ri[s + 1];\n      nLi[s] = a * Li[s + 1] + b * Rr[s + 1];\n    }\n    nRr[0] = nRi[0] = nLr[0] = nLi[0] = 0;\n    nRr[NX - 1] = nRi[NX - 1] = nLr[NX - 1] = nLi[NX - 1] = 0;\n    [Rr, nRr] = [nRr, Rr];\n    [Ri, nRi] = [nRi, Ri];\n    [Lr, nLr] = [nLr, Lr];\n    [Li, nLi] = [nLi, Li];\n  }\n  Object.assign(S, { Rr, Ri, Lr, Li, nRr, nRi, nLr, nLi });\n}\n\n// A path sampled with weight |amplitude| = eps^R: a corner at each step with\n// probability eps / (1 + eps), starting right-moving from a site drawn from\n// the packet.\nfunction sample(S) {\n  const eps = S.eps, pc = eps / (1 + eps), xs = new Int16Array(H), k = new Uint8Array(H);\n  let s = X0;\n  if (S.sigma >= 0.5) {\n    let g;\n    do g = sqrt(-2 * Math.log(1 - Math.random())) * Math.cos(2 * PI * Math.random()) * S.sigma;\n    while (abs(g) > 3 * S.sigma);\n    s = X0 + 2 * round(g / 2);\n  }\n  let dir = 1, R = 0;\n  for (let t = 0; t \u003c H; t++) {\n    xs[t] = s;\n    k[t] = R;\n    if (Math.random() \u003c pc) (dir = -dir), R++;\n    s += dir;\n  }\n  return { xs, k };\n}\n\n// The present: a row that runs down the panel at 16 rows a second per unit\n// of Speed, then waits HOLD rows' worth of time at the bottom while the\n// paths fade, and starts again from the source with new paths.\nconst HOLD = 20, NP = 4;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.08, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.eps = cl(kv[2], 0.08, 0.4);\n  S.focus = cl(kv[3], 0, 1);\n  S.sigma = (1.5 * (1 - S.focus) ** 1.5) / S.eps;\n  const key = S.eps.toFixed(4) + '/' + S.sigma.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    field(S);\n    S.paths = [];\n  }\n  if (!S.paths.length) {\n    for (let i = 0; i \u003c NP; i++) S.paths.push(sample(S));\n    if (S.front === undefined) S.front = 40;\n  }\n  S.front += d * 16 * S.speed;\n  if (S.front > H + HOLD) {\n    S.front = 0;\n    for (let i = 0; i \u003c NP; i++) S.paths[i] = sample(S);\n  }\n}\n\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction line(S, x0, y0, x1, y1, v, c, o) {\n  const L = hypot(x1 - x0, y1 - y0), n = max(1, ceil(L * 3)), w = (v * L) / n;\n  for (let i = 1; i \u003c= n; i++) splat(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, G, B, c, V, ph, mean, D } = S;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  D.fill(1);\n  const tmp = [0, 0, 0], now = S.front, head = min(H - 1, now), fade = now > H ? max(0, 1 - (now - H) / HOLD) : 1;\n  // Shade under the lines first, so they read over the field.\n  const shade = (x, y, k) => {\n    const ix = round(x), iy = round(y);\n    if (iy \u003c 0 || iy >= H) return;\n    for (let X = ix - 1; X \u003c= ix + 1; X++) if (X >= 0 && X \u003c W) D[iy * W + X] = min(D[iy * W + X], k);\n  };\n  for (let t = 0; t \u003c= min(H - 1, now); t++) shade(ux(mean[t]), t, 0.35);\n  if (fade > 0) for (const P of S.paths) for (let t = 0; t \u003c= head; t++) shade(ux(P.xs[t]), t, 1 - 0.65 * fade);\n  // The field: phase as hue, the amplitude as brightness, full in the rows\n  // the present has passed and brightest just behind it, faint ahead of it.\n  for (let t = 0; t \u003c H; t++) {\n    const u = cl((now - t) / 8 + 0.5, 0, 1), lit = 0.34 + 0.2 * u * u * (3 - 2 * u) + (t \u003c= now ? 0.14 * exp(-(now - t) / 10) : 0);\n    for (let X = 0; X \u003c W; X++) {\n      const o = t * W + X;\n      hsv(S.hue + 0.55 + ph[o], 0.85, V[o] * lit * D[o], tmp, 0);\n      R[o] = tmp[0];\n      G[o] = tmp[1];\n      B[o] = tmp[2];\n    }\n  }\n  c[0] = c[1] = c[2] = 0.3; // cone\n  c[3] = c[4] = c[5] = 1; // white\n  hsv(S.hue + 0.14, 0.55, 1, c, 9); // the mean\n  // The light cone of the packet's centre.\n  for (let t = 0; t \u003c H; t += 2) {\n    splat(S, ux(X0 + t), t, 1, c, 0);\n    splat(S, ux(X0 - t), t, 1, c, 0);\n  }\n  // The paths, down to the present.\n  if (fade > 0)\n    for (const P of S.paths) {\n      for (let t = 0; t + 1 \u003c= head; t++) {\n        const v = 0.3 + 0.65 * exp(-(head - t) / 24);\n        line(S, ux(P.xs[t]), t, ux(P.xs[t + 1]), t + 1, v * fade, c, 3);\n      }\n      for (let t = 1; t + 1 \u003c= head; t++)\n        if (P.k[t + 1] !== P.k[t]) {\n          hsv(S.hue + 0.55 + P.k[t + 1] / 4, 1, 1, c, 6);\n          splat(S, ux(P.xs[t]), t, 2 * fade, c, 6);\n        }\n      const t0 = floor(head), f = head - t0;\n      if (t0 \u003c H - 1) splat(S, ux(P.xs[t0] + (P.xs[t0 + 1] - P.xs[t0]) * f), head, 1.5 * fade, c, 3);\n    }\n  // The mean position, row by row: drawn through the past, dotted ahead.\n  for (let t = 0; t \u003c H; t++) if (t \u003c= now || t % 3 === 0) splat(S, ux(mean[t]), t, t \u003c= now ? 1.2 : 0.6, c, 9);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","heesch-tiles":"// ===== Patternflow pattern =====\n// Title:   Heesch Tiles\n// Family:  cells\n// Idea:    One tile whose edges keep bending covers the whole panel with no gap and no overlap, each bent edge carried onto its partner the way Heesch paired them (translated T, half-turned C about its own midpoint, glide-reflected G, or turned about a shared corner, C3 and C4), and every 8 s the tiling passes on to the next of six Heesch types, each copy coloured by which way it is turned or flipped and brightest at its first corner.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the 28 types of plane tiling by one asymmetric tile (Heinrich Heesch, 1935), Flächenschluss (Heinrich Heesch and Otto Kienzle, 1963), the 93 isohedral tiling types (Branko Grünbaum and G. C. Shephard, 1977), isohedral tilings parameterised for drawing (Craig S. Kaplan and David H. Salesin, 2000), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Type=0..5, Size=-1..1\n//\n// Knob 1: Hue. Turns the class colours round a wheel that skips orange, which reads brown once shaded. At 0 the copies turned like the first tile are azure, the next class pink, then green and violet: two colours where the group has two classes (the half-turned copies of CCCC and TCTC, the mirrored ones of TG1G1TG2G2), three for C3C3C3C3C3C3, four for C4C4C4C4, and TTTT, where every copy is a translate, all azure. At 0.5 the four are red, cyan, violet and green.\n// Knob 2: Speed. At 2 the edge bends run through their quickest wave in 12 s and their slowest in 22 s, the corners wander over 27 s, the tiling drifts 0.9 LEDs a second right and 1.6 up, and each type holds 8 s before the next sweeps down the panel in 1.2 s, tile by tile, so the six come round every 55 s. At 0.2 everything is ten times slower, at 3 one and a half times faster.\n// Knob 3: Type. The type on the panel now; the cycle goes on from it. 0 C3C3C3C3C3C3 (group p3: a hexagon whose corners V0, V2, V4 are 3-fold centres and whose corner V1 wanders, three classes), 1 TG1G1TG2G2 (pg: one translated pair and two glide-reflected pairs, so mirrored columns alternate), 2 CCCC (p2: any quadrilateral, each edge half-turned about its own midpoint), 3 TCTC (p2: a parallelogram with one translated pair and two C edges), 4 TTTT (p1), 5 C4C4C4C4 (p4: a square turned a quarter about two opposite corners, four classes).\n// Knob 4: Size. The area of one tile, 290 x 2^(1.6 K) LEDs: 96 at -1, about 85 tiles on the panel; 310 at the opening 0.06, about 26; 880 at 1, about 9.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, sin, cos, sqrt, min, max, abs, atan2, PI, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Orange reads brown on an LED once it is shaded, so the class colours come\n// from a wheel without 0.03 to 0.17.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\n// Isometries as [a, b, c, d, e, f]: (x, y) -> (a x + b y + e, c x + d y + f).\nconst mul = (M, K) => [\n  M[0] * K[0] + M[1] * K[2], M[0] * K[1] + M[1] * K[3],\n  M[2] * K[0] + M[3] * K[2], M[2] * K[1] + M[3] * K[3],\n  M[0] * K[4] + M[1] * K[5] + M[4], M[2] * K[4] + M[3] * K[5] + M[5],\n];\nconst inv = (M) => {\n  const det = M[0] * M[3] - M[1] * M[2], a = M[3] / det, b = -M[1] / det, c = -M[2] / det, d = M[0] / det;\n  return [a, b, c, d, -(a * M[4] + b * M[5]), -(c * M[4] + d * M[5])];\n};\nconst Tr = (x, y) => [1, 0, 0, 1, x, y];\nconst Rot = (p, th) => {\n  const c = cos(th), s = sin(th);\n  return [c, -s, s, c, p[0] - c * p[0] + s * p[1], p[1] - s * p[0] - c * p[1]];\n};\nconst Half = (p, q) => Rot([(p[0] + q[0]) / 2, (p[1] + q[1]) / 2], PI);\n// Reflect in the vertical line x = xa, then move dy along it.\nconst Glide = (xa, dy) => [-1, 0, 0, 1, 2 * xa, dy];\nconst ap = (M, p) => [M[0] * p[0] + M[1] * p[1] + M[4], M[2] * p[0] + M[3] * p[1] + M[5]];\n\n// An edge from P to Q, NS steps, bent off the chord by h(s) times its length.\n// Every bend is a sum of sin(k pi s) sin(pi s), so it leaves both corners\n// along the chord and the corner angles of the polygon stay.\nconst NS = 10;\nfunction edge(P, Q, h) {\n  const dx = Q[0] - P[0], dy = Q[1] - P[1], pts = [];\n  for (let i = 0; i \u003c= NS; i++) {\n    const s = i / NS, o = h(s);\n    pts.push([P[0] + dx * s - dy * o, P[1] + dy * s + dx * o]);\n  }\n  return pts;\n}\nconst mapPts = (M, pts) => pts.map((p) => ap(M, p));\nconst rev = (pts) => pts.slice().reverse();\n\n// Bends. A free edge (the first of a T, G, C3 or C4 pair) may take any\n// shape; a C edge must turn into itself under a half-turn about its\n// midpoint, so its bend is odd about s = 1/2. Seen from either end of its\n// chord, an edge never strays further off it than the angle the chord\n// makes there with the line to the tile's centre, times 0.9: the edge then\n// stays inside a rhombus on its chord whose two halves lie in the fan\n// triangles (centre, corner, corner) of the two tiles it parts. Those\n// triangles never overlap, so no two bent edges meet but at a corner and\n// the copies still cover the plane once.\nfunction limit(u, A, tm) {\n  let r = 0;\n  for (let i = 1; i \u003c 40; i++) {\n    const s = i / 40;\n    r = max(r, abs(u(s)) / min(s, 1 - s));\n  }\n  const a = r > 0 ? min(A, tm / r) : A;\n  return (s) => a * u(s);\n}\nfunction freeBend(c, A, tm) {\n  return limit((s) => sin(PI * s) * (c[0] * sin(PI * s) + 0.8 * c[1] * sin(2 * PI * s) + 0.3 * c[2] * sin(3 * PI * s)), A, tm);\n}\nfunction oddBend(c, A, tm) {\n  return limit((s) => sin(PI * s) * (1.3 * c[0] * sin(2 * PI * s) + 0.5 * c[1] * sin(4 * PI * s)), A, tm);\n}\n// The tangent of the stray allowed: 0.9 of the smallest angle between a\n// chord and the line from its end to the centre of the corners.\nfunction stray(V) {\n  const n = V.length;\n  let cx = 0, cy = 0, m = PI;\n  for (const p of V) {\n    cx += p[0] / n;\n    cy += p[1] / n;\n  }\n  const ang = (o, a, b) => {\n    const ax = a[0] - o[0], ay = a[1] - o[1], bx = b[0] - o[0], by = b[1] - o[1];\n    return abs(atan2(ax * by - ay * bx, ax * bx + ay * by));\n  };\n  for (let i = 0; i \u003c n; i++) {\n    const p = V[i], q = V[(i + 1) % n], C = [cx, cy];\n    m = min(m, ang(p, q, C), ang(q, p, C));\n  }\n  return Math.tan(0.9 * m);\n}\n\n// The six types. Each returns the corners V in order round the tile\n// (counter-clockwise), the edges as point lists from V[i] to V[i+1], the\n// isometry n[i] that carries the tile onto its neighbour across edge i,\n// and how many orientation classes the group has. c(j) is edge j's slowly\n// turning bend coefficients and g(j) a slow wave for the corners.\nconst TYPES = [\n  {\n    name: \"C3C3C3C3C3C3\", m: 3,\n    build(c, g, A) {\n      // V0, V2, V4 are a fixed equilateral triangle of 3-fold centres; V1\n      // wanders, and V3, V5 follow it by turns of -120 degrees.\n      const V = [];\n      for (let i = 0; i \u003c 6; i++) V.push([cos((i * PI) / 3), sin((i * PI) / 3)]);\n      V[1] = [V[1][0] + 0.18 * g(0), V[1][1] + 0.18 * g(1)];\n      const r0 = Rot(V[0], -TAU / 3), r2 = Rot(V[2], -TAU / 3), r4 = Rot(V[4], -TAU / 3);\n      V[3] = ap(r2, V[1]);\n      V[5] = ap(r4, V[3]);\n      const tm = stray(V);\n      const e1 = edge(V[1], V[2], freeBend(c(0), A, tm)), e3 = edge(V[3], V[4], freeBend(c(1), A, tm)), e5 = edge(V[5], V[0], freeBend(c(2), A, tm));\n      const E = [rev(mapPts(r0, e5)), e1, rev(mapPts(r2, e1)), e3, rev(mapPts(r4, e3)), e5];\n      return { V, E, n: [r0, inv(r2), r2, inv(r4), r4, inv(r0)] };\n    },\n  },\n  {\n    name: \"TG1G1TG2G2\", m: 2,\n    build(c, g, A) {\n      // T moves the tile up by h; the glides g1, g2 reflect it in vertical\n      // lines and move it half of h, so mirrored columns alternate.\n      const w = 1, h = 1.25, s = 0.22 * g(0), p = 0.32 + 0.12 * g(1), q = -0.32 + 0.12 * g(2);\n      const V = [[0, 0], [w, s], [w + p, s + h / 2], [w, s + h], [0, h], [q, h / 2]], tm = stray(V);\n      const g1 = Glide(w + p / 2, h / 2), g2 = Glide(q / 2, -h / 2), t = Tr(0, h);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e1 = edge(V[1], V[2], freeBend(c(1), A, tm)), e4 = edge(V[4], V[5], freeBend(c(2), A, tm));\n      const E = [e0, e1, mapPts(g1, e1), rev(mapPts(t, e0)), e4, mapPts(g2, e4)];\n      return { V, E, n: [inv(t), inv(g1), g1, t, inv(g2), g2] };\n    },\n  },\n  {\n    name: \"CCCC\", m: 2,\n    build(c, g, A) {\n      // Any quadrilateral tiles by half-turns about its edge midpoints.\n      const V = [[0.12 * g(0), 0.1 * g(1)], [1.1 + 0.12 * g(2), 0.08 * g(3)], [1.18 + 0.1 * g(4), 1.02 + 0.1 * g(5)], [-0.12 + 0.1 * g(6), 0.9 + 0.1 * g(7)]];\n      const E = [], n = [], tm = stray(V);\n      for (let i = 0; i \u003c 4; i++) {\n        const P = V[i], Q = V[(i + 1) % 4];\n        E.push(edge(P, Q, oddBend(c(i), A * 1.15, tm)));\n        n.push(Half(P, Q));\n      }\n      return { V, E, n };\n    },\n  },\n  {\n    name: \"TCTC\", m: 2,\n    build(c, g, A) {\n      const u = [1.15, 0.22 * g(0)], v = [0.28 * g(1), 1];\n      const V = [[0, 0], u, [u[0] + v[0], u[1] + v[1]], v], tm = stray(V);\n      const t = Tr(v[0], v[1]);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e1 = edge(V[1], V[2], oddBend(c(1), A * 1.15, tm)), e3 = edge(V[3], V[0], oddBend(c(2), A * 1.15, tm));\n      const E = [e0, e1, rev(mapPts(t, e0)), e3];\n      return { V, E, n: [inv(t), Half(V[1], V[2]), t, Half(V[3], V[0])] };\n    },\n  },\n  {\n    name: \"TTTT\", m: 1,\n    build(c, g, A) {\n      const u = [1.1, 0.25 * g(0)], v = [0.3 * g(1), 1];\n      const V = [[0, 0], u, [u[0] + v[0], u[1] + v[1]], v], tm = stray(V);\n      const tu = Tr(u[0], u[1]), tv = Tr(v[0], v[1]);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e1 = edge(V[1], V[2], freeBend(c(1), A, tm));\n      const E = [e0, e1, rev(mapPts(tv, e0)), rev(mapPts(inv(tu), e1))];\n      return { V, E, n: [inv(tv), tu, tv, inv(tu)] };\n    },\n  },\n  {\n    name: \"C4C4C4C4\", m: 4,\n    build(c, g, A) {\n      // A square with 4-fold centres at V0 and V2: edge V0V1 turns a quarter\n      // about V0 into V0V3, edge V2V3 a quarter about V2 into V2V1.\n      const V = [[0, 0], [1, 0], [1, 1], [0, 1]], tm = stray(V);\n      const r0 = Rot(V[0], PI / 2), r2 = Rot(V[2], PI / 2);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e2 = edge(V[2], V[3], freeBend(c(1), A, tm));\n      const E = [e0, rev(mapPts(r2, e2)), e2, rev(mapPts(r0, e0))];\n      return { V, E, n: [inv(r0), r2, inv(r2), r0] };\n    },\n  },\n];\n\n// At Size 0 each tile covers this many LEDs; every edge asks for a bend of\n// BEND times its length, and gets it unless its stray limit says less.\nconst AREA = 290, BEND = 0.45;\nconst PERIOD = 8, WIPE = 1.2;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, size: 0, type: -1, base: -1, next: -1, since: 0, wipe: 1,\n    ox: 0, oy: 0,\n    own: [new Int32Array(N), new Int32Array(N)], cnt: [new Uint8Array(N), new Uint8Array(N)],\n    tiles: [[], []], frames: 0, bad: 0, c: [0, 0, 0],\n  };\n}\n\nfunction polygonArea(V) {\n  let a = 0;\n  for (let i = 0; i \u003c V.length; i++) {\n    const p = V[i], q = V[(i + 1) % V.length];\n    a += p[0] * q[1] - q[0] * p[1];\n  }\n  return abs(a) / 2;\n}\n\n// The tiling of type k at time t, rasterised into own (tile index per LED)\n// and cnt (how many tiles cover each LED centre).\nfunction tile(S, k, slot) {\n  const ty = TYPES[k], t = S.t;\n  const c = (j) => [sin(0.53 * t + 1.7 * j + 0.3 * k), sin(0.37 * t + 2.9 * j + 1.1 * k), sin(0.29 * t + 4.1 * j + 2.3 * k)];\n  const g = (j) => sin(0.23 * t + 1.9 * j + k);\n  const T = ty.build(c, g, BEND);\n  const sc = sqrt((AREA * Math.pow(2, 1.6 * S.size)) / polygonArea(T.V));\n  // The boundary, closed, in tile units.\n  const poly = [];\n  for (const e of T.E) for (let i = 0; i \u003c e.length - 1; i++) poly.push(e[i]);\n  let cx = 0, cy = 0;\n  for (const p of T.V) {\n    cx += p[0] / T.V.length;\n    cy += p[1] / T.V.length;\n  }\n  let rad = 0;\n  for (const p of poly) rad = max(rad, sqrt((p[0] - cx) ** 2 + (p[1] - cy) ** 2));\n  // Tile units to LEDs: scale, and put the first tile's centre at the\n  // panel's centre plus the drift.\n  const view = [sc, 0, 0, sc, 32 + S.ox - sc * cx, 64 + S.oy - sc * cy];\n  const own = S.own[slot], cnt = S.cnt[slot], tiles = [], np = poly.length, Q = new Float64Array(2 * np);\n  own.fill(-1);\n  cnt.fill(0);\n  // Every copy is found from the first by crossing edges, and a copy is\n  // known by where its centre lands.\n  const seen = new Set([round(cx * 64) * 65536 + round(cy * 64)]), queue = [[1, 0, 0, 1, 0, 0]], reach = sc * rad + 2;\n  for (let qi = 0; qi \u003c queue.length; qi++) {\n    const M = queue[qi], F = mul(view, M), ux = F[0] * cx + F[1] * cy + F[4], uy = F[2] * cx + F[3] * cy + F[5];\n    if (ux \u003c -reach || ux > W + reach || uy \u003c -reach || uy > H + reach) continue;\n    const id = tiles.length, det = M[0] * M[3] - M[1] * M[2];\n    // The orientation class: the turn of the tile, and for a mirrored copy\n    // the turn of its mirror image, in steps of a full turn over the\n    // rotations the group has.\n    const steps = det > 0 ? ty.m : ty.m / 2;\n    const ang = atan2(M[2], M[0]);\n    const cls = det > 0 || ty.m \u003c 2 ? round((ang / TAU) * steps + steps) % steps : steps + (round((atan2(-M[2], -M[0]) / TAU) * steps + steps) % steps);\n    tiles.push({ Fi: inv(F), cy: uy, cls });\n    for (let i = 0; i \u003c np; i++) {\n      const x = poly[i][0], y = poly[i][1];\n      Q[2 * i] = F[0] * x + F[1] * y + F[4];\n      Q[2 * i + 1] = F[2] * x + F[3] * y + F[5];\n    }\n    fill(Q, np, id, own, cnt);\n    for (const nb of T.n) {\n      const K = mul(M, nb), key = round((K[0] * cx + K[1] * cy + K[4]) * 64) * 65536 + round((K[2] * cx + K[3] * cy + K[5]) * 64);\n      if (seen.has(key)) continue;\n      seen.add(key);\n      queue.push(K);\n    }\n  }\n  S.tiles[slot] = tiles;\n  S.v0 = T.V[0];\n  S.rad = rad;\n  return tiles;\n}\n\n// Even-odd scanline fill of LED centres (x + 0.5, y + 0.5), half-open on\n// both axes, so two tiles that share an edge split the LEDs along it. Each\n// segment drops its crossings into the rows it spans.\nconst rowX = [];\nfor (let r = 0; r \u003c H; r++) rowX.push([]);\nfunction fill(Q, n, id, own, cnt) {\n  let r0 = H, r1 = -1;\n  for (let i = 0; i \u003c n; i++) {\n    const j = (i + 1) % n;\n    let ax = Q[2 * i], ay = Q[2 * i + 1], bx = Q[2 * j], by = Q[2 * j + 1];\n    if (ay === by) continue;\n    if (ay > by) {\n      const tx = ax, ty = ay;\n      ax = bx;\n      ay = by;\n      bx = tx;\n      by = ty;\n    }\n    // Rows whose centre yc has ay \u003c= yc \u003c by.\n    const ra = max(0, Math.ceil(ay - 0.5)), rb = min(H - 1, Math.ceil(by - 0.5) - 1);\n    if (ra > rb) continue;\n    const k = (bx - ax) / (by - ay);\n    for (let r = ra; r \u003c= rb; r++) rowX[r].push(ax + (r + 0.5 - ay) * k);\n    if (ra \u003c r0) r0 = ra;\n    if (rb > r1) r1 = rb;\n  }\n  for (let r = r0; r \u003c= r1; r++) {\n    const xs = rowX[r];\n    if (xs.length > 2) xs.sort((p, q) => p - q);\n    else if (xs.length === 2 && xs[0] > xs[1]) xs.reverse();\n    for (let j = 0; j + 1 \u003c xs.length; j += 2) {\n      const c0 = max(0, Math.ceil(xs[j] - 0.5)), c1 = min(W - 1, Math.ceil(xs[j + 1] - 0.5) - 1);\n      for (let x = c0, p = r * W + c0; x \u003c= c1; x++, p++) {\n        own[p] = id;\n        cnt[p]++;\n      }\n    }\n    xs.length = 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  S.hue = k[0];\n  S.size = cl(k[3], -1, 1);\n  const base = round(cl(k[2], 0, 5));\n  if (base !== S.base) {\n    // A turned knob shows its type now, and the cycle goes on from there.\n    if (S.base \u003c 0) S.type = base;\n    else {\n      S.next = base;\n      S.wipe = 0;\n    }\n    S.base = base;\n    S.since = 0;\n  }\n  S.t += tau;\n  S.since += tau;\n  S.ox += tau * 0.9;\n  S.oy -= tau * 1.6;\n  if (S.wipe >= 1 && S.since >= PERIOD) {\n    S.next = (S.type + 1) % TYPES.length;\n    S.wipe = 0;\n    S.since = 0;\n  }\n  if (S.wipe \u003c 1) {\n    S.wipe += tau / WIPE;\n    if (S.wipe >= 1) {\n      S.type = S.next;\n      S.next = -1;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.c;\n  const slots = [[S.type, 0]];\n  if (S.next >= 0 && S.wipe \u003c 1) slots.push([S.next, 1]);\n  const info = [];\n  for (const [k, slot] of slots) {\n    const tiles = tile(S, k, slot);\n    info.push({ k, slot, tiles, v0: S.v0, fall: -2.2 / (S.rad * S.rad) });\n    S.frames++;\n    for (let p = 0; p \u003c N; p++) if (S.cnt[slot][p] !== 1) S.bad++;\n  }\n  // The wipe runs down the panel tile by tile: a tile of the new type shows\n  // once its centre is above the line.\n  const line = -20 + (H + 40) * ease(cl(S.wipe, 0, 1));\n  // Each class's colour at full brightness.\n  const pal = [];\n  for (let i = 0; i \u003c 4; i++) {\n    hsv(wheel(S.hue + CLASS[i]), 0.78, 255, c);\n    pal.push([c[0], c[1], c[2]]);\n  }\n  // Which tiling each LED shows, and the tile there, as one number, so the\n  // grout also runs along the seam of a wipe.\n  const kk = S.kk || (S.kk = new Int32Array(N)), lay = S.lay || (S.lay = new Uint8Array(N));\n  const own0 = S.own[0], own1 = S.own[1], two = info.length > 1;\n  for (let p = 0; p \u003c N; p++) {\n    const id = own1[p];\n    lay[p] = two && id >= 0 && info[1].tiles[id].cy \u003c line ? 1 : 0;\n    kk[p] = lay[p] ? -2 - id : own0[p];\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p & 63, y = p >> 6, L = info[lay[p]];\n    const id = lay[p] ? own1[p] : own0[p];\n    if (id \u003c 0 || S.cnt[L.slot][p] !== 1) {\n      // Never seen: a gap or an overlap would show white.\n      display.setPixel(x, y, 255, 255, 255);\n      continue;\n    }\n    const T = L.tiles[id], F = T.Fi, xc = x + 0.5, yc = y + 0.5, me = kk[p];\n    // Grout where the LED to the right or below belongs to another tile.\n    const grout = (x \u003c W - 1 && kk[p + 1] !== me) || (y \u003c H - 1 && kk[p + W] !== me);\n    // Shade: brightest at the tile's first corner, so its turn shows.\n    const qx = F[0] * xc + F[1] * yc + F[4] - L.v0[0], qy = F[2] * xc + F[3] * yc + F[5] - L.v0[1];\n    const v = (0.45 + 0.55 * exp((qx * qx + qy * qy) * L.fall)) * (grout ? 0.14 : 1);\n    const col = pal[T.cls & 3];\n    display.setPixel(x, y, round(col[0] * v), round(col[1] * v), round(col[2] * v));\n  }\n}\n\n// Class colours on the wheel: azure, pink, green, violet at Hue 0.\nconst CLASS = [0.477, 0.849, 0.186, 0.686];\nconst ease = (u) => u * u * (3 - 2 * u);\n","riemann-function":"// ===== Patternflow pattern =====\n// Title:   Riemann's Function\n// Family:  fractal\n// Idea:    A pen draws Duistermaat's curve phi(t), the complex form of Riemann's non-differentiable function, as a heart of spirals across the top of the panel, and the loupe below dives into one rational point of it, where the curve turns a right angle or, at p/q with p and q both odd, runs straight through with Gerver's derivative -1/2.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Riemann's non-differentiable function (Bernhard Riemann, c. 1861, reported by Karl Weierstrass, 1872), non-differentiability at the irrationals (G. H. Hardy, 1916), differentiability at p/q with p and q odd (Joseph Gerver, 1970), the complex curve phi (J. J. Duistermaat, 1991), the corner of a polygonal vortex filament under the binormal flow (Francisco de la Hoz and Luis Vega, 2014), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Point=0..1, Depth=0..1\n//\n// Knob 1: Hue. Turns the curve's colours round the wheel; they run by the distance from t = 1, so the heart is coloured the same on both halves, as phi(2 - t) = -conj phi(t) makes it. At 0 the top centre, t = 1, is azure, the sides violet and the tip, t = 0, pink; at 0.25 violet to green, at 0.5 yellow to cyan, at 0.75 green to violet. Orange is skipped, as it reads brown when dim. In the loupe the hue also swings by 0.07 once every factor 16 in s = t - t0, bands that flow outward as the loupe dives.\n// Knob 2: Speed. One lap of the pen round t in [0, 2] takes 16 / Speed seconds: 8 s at 2, 80 s at 0.2, 5.3 s at 3. The last 0.3 s of its trail burns white, the curve it has passed stays bright for about a fifth of a lap and settles to 40 percent. The loupe dives in and comes out once a lap, deepest just as the pen passes its point, which it lights up; at Speed 2 that is 2.5 s in.\n// Knob 3: Point. The rational t0 the loupe dives into, boxed on the heart: 1 below 0.2, 1/2 to 0.4, 1/3 to 0.6, 0 (the tip) to 0.8, then 2/3. At 1 and 1/3, p and q both odd, the curve passes straight through, horizontal, phi'(t0) = -1/2, a bowtie of small rosettes, one every 8 s^2 in s, closing on the point; the pattern's own sums give (phi(1 + s) - phi(1)) / s = -0.300 - 0.181i, -0.410, -0.456 and -0.490 at s = 1/32, 1/128, 1/512 and 1/2048. Elsewhere it turns a right angle along c e^(i pi / 4) sqrt s and -c e^(-i pi / 4) sqrt |s|, c the mean of e^(i pi p r^2 / q) over r mod 2q: arms up and left at 1/2, where |phi(t0 + s) - phi(t0)| / sqrt s reaches 0.70711 = 1 / sqrt 2 by s = 1e-7; the V of the tip, 0.99997 at s = 7.5e-9; arms up-left and down-left at 2/3, 0.57738 against 1 / sqrt 3 = 0.57735. The dim grey lines in the loupe are these predicted tangents.\n// Knob 4: Depth. How far the loupe dives, 2^(4 + 4 Depth) times the loupe's opening scale, 200 LEDs a unit: 16 times at 0, 19 at the opening 0.06, where the loupe is 1/48 of the heart's width, 64 at 0.5 and 256 at 1, 1/644 of it. At t0 = 1 the bowtie stands 14 LEDs tall at the loupe's ends at 0.5 and 8 at 1, and 2 in the middle at both.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, cos, sin, exp, round, ceil, abs, log2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without its orange, 0.03 to 0.15, which reads brown when dim.\nconst wheel = (h) => 0.15 + (h - floor(h)) * 0.88;\n\n// phi(t) = sum over n >= 1 of e^(i pi n^2 t) / (i pi n^2). The table of the\n// whole period sums the first NT terms: past n = 128 a term moves the top\n// view by less than 1/600 of an LED.\nconst NT = 128;\n// The whole period t in [0, 2), G samples.\nconst G = 12288, HG = 2 / G;\n// The rational points the loupe can dive into, p / q.\nconst POINTS = [[1, 1], [1, 2], [1, 3], [0, 1], [2, 3]];\n\n// The top view: 77 LEDs a unit, phi(1) = i pi / 12 near the top.\nconst TS = 77, TX = 31.5, TY = 31.2;\n// The loupe: rows 74 to 127, centre (31.5, 100.5), half width RHO0 / M.\nconst LY0 = 74, LCX = 31.5, LCY = 100.5, RHO0 = 0.16;\n\n// Fresnel auxiliary functions f(w), g(w): the integral of e^(i pi u^2 / 2)\n// from w to infinity is (g + i f) e^(i pi w^2 / 2). A power series below\n// w = 3, the asymptotic series above.\nconst FG = [0, 0];\nfunction fresnelFG(w) {\n  if (w >= 3) {\n    const x = PI * w * w, x2 = 1 / (x * x);\n    FG[0] = (1 - 3 * x2 + 105 * x2 * x2 - 10395 * x2 * x2 * x2) / (PI * w);\n    FG[1] = (1 - 15 * x2 + 945 * x2 * x2) / (PI * PI * w * w * w);\n    return;\n  }\n  const a = PI / 2, w2 = w * w, w4 = w2 * w2;\n  let C = 0, S = 0, tc = w, ts = a * w * w2;\n  for (let n = 0; n \u003c 32; n++) {\n    C += tc / (4 * n + 1);\n    S += ts / (4 * n + 3);\n    tc *= (-a * a * w4) / ((2 * n + 1) * (2 * n + 2));\n    ts *= (-a * a * w4) / ((2 * n + 2) * (2 * n + 3));\n  }\n  const th = a * w2, A = 0.5 - C, B = 0.5 - S, co = cos(th), si = sin(th);\n  FG[0] = B * co - A * si;\n  FG[1] = A * co + B * si;\n}\n// I(s), the terms past a cut at n = N summed as an integral from L = N + 1/2:\n// the sum over n > N of (e^(i pi n^2 s) - 1) / (i pi n^2). Near a rational\n// p/q every term there carries the same mean factor c, so c I(s) puts back\n// the square-root corner the cut series would round off.\nconst IC = [0, 0];\nfunction tail(s, L) {\n  const as = abs(s), ph = PI * L * L * s;\n  let re = sin(ph) / (PI * L), im = (1 - cos(ph)) / (PI * L);\n  fresnelFG(L * sqrt(2 * as));\n  const r = sqrt(2 * as), pa = PI * L * L * as, cp = cos(pa), sp = sin(pa);\n  const pr = r * (FG[1] * cp - FG[0] * sp), pi = r * (FG[1] * sp + FG[0] * cp);\n  if (s >= 0) (re += pr), (im += pi);\n  else (re -= pr), (im += pi);\n  IC[0] = re;\n  IC[1] = im;\n}\n\nlet GX = null, GY = null;\n// The whole curve once, by turning each term's phasor a step at a time.\nfunction curve() {\n  if (GX) return;\n  GX = new Float64Array(G + 1);\n  GY = new Float64Array(G + 1);\n  for (let n = 1; n \u003c= NT; n++) {\n    const k = PI * n * n, a = 1 / k, rc = cos(k * HG), rs = sin(k * HG);\n    // 1 / (i pi n^2) = -i / (pi n^2)\n    let x = 0, y = -a;\n    for (let i = 0; i \u003c= G; i++) {\n      GX[i] += x;\n      GY[i] += y;\n      const nx = x * rc - y * rs;\n      y = x * rs + y * rc;\n      x = nx;\n    }\n  }\n}\n\n// The loupe's polyline for one point: shells about s = 0, each 4 times\n// thinner than the last, from s = 1/8 down to 1/8 / 4^12 = 7.5e-9, each\n// summed by turning its terms' phasors in even steps, then the rest of the\n// period from the table. Near p/q with p and q odd the curve runs along its\n// tangent as a train of small rosettes, one every 8 s^2 in s and 3.1 s^1.5\n// across (3.29 at s = 1/32, 3.11 at 1/256, summed to 3000 terms), so there\n// the shells take enough steps for each rosette as the loupe will show it:\n// 800 steps from s = 1/8 to 1/32, 16 to a rosette from 1/512 to 1/2048, where\n// at 256 times a rosette is up to 5 LEDs across. Inside s = 1/2048 they are\n// 1.7 LEDs at most and the 1024 terms a shell sums there no longer hold them,\n// so those shells take 240 steps and draw the line. A shell sums 256 terms out\n// to s = 1/32 and 1024 inside it.\nconst S0 = 1 / 8, SHELLS = 12, QODD = [800, 800, 1300, 2600, 3100], QCORNER = [600], QMIN = 240, GROUP = 120;\nconst CUT = (j) => (j \u003c 2 ? 256 : 1024);\nconst NS = 1024;\nfunction loupe(S, which) {\n  const [p, q] = POINTS[which], t0 = p / q;\n  // c, the mean of e^(i pi p r^2 / q) over r mod 2q: zero exactly when p and\n  // q are both odd.\n  let cr = 0, ci = 0;\n  for (let r = 0; r \u003c 2 * q; r++) {\n    const a = (PI * p * r * r) / q;\n    cr += cos(a);\n    ci += sin(a);\n  }\n  cr /= 2 * q;\n  ci /= 2 * q;\n  if (abs(cr) \u003c 1e-9) cr = 0;\n  if (abs(ci) \u003c 1e-9) ci = 0;\n  const odd = cr === 0 && ci === 0;\n  // The terms e^(i pi n^2 t0) / (i pi n^2) = (sin - i cos) / (pi n^2).\n  // For each cut N: phi at t0 cut there, and the coefficients' own part past\n  // it. With B_n the partial sums of e^(i pi m^2 t0) - c, the terms past N\n  // add (\u003cB> - B_N) times one more term, \u003cB> the mean of B over a period;\n  // this keeps the slope at the point, \u003cB> - c / 2, which comes to -1/2 at\n  // every p/q with p and q odd.\n  const AR = new Float64Array(NS + 1), AI = new Float64Array(NS + 1);\n  let px = 0, py = 0, br = 0, bi = 0, mr = 0, mi = 0;\n  const at = {};\n  for (let n = 1; n \u003c= NS; n++) {\n    const k = PI * n * n, ph = (PI * ((n * n * p) % (2 * q))) / q;\n    AR[n] = sin(ph) / k;\n    AI[n] = -cos(ph) / k;\n    px += AR[n];\n    py += AI[n];\n    br += cos(ph) - cr;\n    bi += sin(ph) - ci;\n    if (n \u003c= 2 * q) (mr += br / (2 * q)), (mi += bi / (2 * q));\n    if (n === NT || n === 256 || n === NS) at[n] = [px, py, br, bi];\n  }\n  const cut = {};\n  for (const N of [NT, 256, NS]) {\n    const [x, y, b1, b2] = at[N];\n    cut[N] = [N + 0.5, mr - b1, mi - b2, x, y];\n  }\n  const xs = [], ys = [], ss = [];\n  const put = (s, x, y, N) => {\n    const [L, kr, ki, ox, oy] = cut[N];\n    tail(s, L);\n    // K (e^(i pi L^2 s) - 1) / (i pi L^2)\n    const ph = PI * L * L * s, fr = sin(ph) / (PI * L * L), fi = (1 - cos(ph)) / (PI * L * L);\n    xs.push(x - ox + cr * IC[0] - ci * IC[1] + kr * fr - ki * fi);\n    ys.push(y - oy + cr * IC[1] + ci * IC[0] + kr * fi + ki * fr);\n    ss.push(s);\n  };\n  // Each term's phasor and its turn for one step, side by side.\n  const WT = new Float64Array(4 * (NS + 1));\n  const shell = (sa, sb, Q, N) => {\n    // sa to sb in Q steps, the end sb left out.\n    const h = (sb - sa) / Q;\n    for (let n = 1, o = 4; n \u003c= N; n++, o += 4) {\n      const k = PI * n * n, c0 = cos(k * sa), s0 = sin(k * sa);\n      WT[o] = AR[n] * c0 - AI[n] * s0;\n      WT[o + 1] = AR[n] * s0 + AI[n] * c0;\n      WT[o + 2] = cos(k * h);\n      WT[o + 3] = sin(k * h);\n    }\n    const end = 4 * N + 4;\n    for (let i = 0; i \u003c Q; i++) {\n      let x = 0, y = 0;\n      for (let o = 4; o \u003c end; o += 4) {\n        const wr = WT[o], wi = WT[o + 1], rc = WT[o + 2], rs = WT[o + 3];\n        x += wr;\n        y += wi;\n        WT[o] = wr * rc - wi * rs;\n        WT[o + 1] = wr * rs + wi * rc;\n      }\n      put(sa + i * h, x, y, N);\n    }\n  };\n  const QS = (j) => (odd ? QODD[j] : QCORNER[j]) || QMIN;\n  // At t0 = 0 and 1 the curve is its own mirror about the point,\n  // z(-s) = -conj z(s), from phi(2 - t) = -conj phi(t); one side is enough.\n  if (q === 1) {\n    for (let j = SHELLS - 1; j >= 0; j--) shell(S0 / 4 ** (j + 1), S0 / 4 ** j, QS(j), CUT(j));\n    const m = xs.length;\n    for (let i = m - 1; i >= 0; i--) xs.push(-xs[i]), ys.push(ys[i]), ss.push(-ss[i]);\n    // The mirrored half runs from -S0 in to -S0 / 4^12: move it to the front\n    // so the line runs -S0 .. 0 .. S0.\n    const nx = xs.splice(m), ny = ys.splice(m), ns = ss.splice(m);\n    xs.unshift(...nx, 0);\n    ys.unshift(...ny, 0);\n    ss.unshift(...ns, 0);\n  } else {\n    for (let j = 0; j \u003c SHELLS; j++) shell(-S0 / 4 ** j, -S0 / 4 ** (j + 1), QS(j), CUT(j));\n    xs.push(0), ys.push(0), ss.push(0);\n    for (let j = SHELLS - 1; j >= 0; j--) shell(S0 / 4 ** (j + 1), S0 / 4 ** j, QS(j), CUT(j));\n  }\n  // The rest of the period from the table, from t0 + S0 round to t0 - S0.\n  const i0 = ceil((t0 + S0) / HG - 1e-9), i1 = floor((t0 + 2 - S0) / HG + 1e-9);\n  for (let i = i0; i \u003c= i1; i++) {\n    const g = ((i % G) + G) % G;\n    let s = i * HG - t0;\n    s -= 2 * floor((s + 1) / 2);\n    put(s, GX[g], GY[g], NT);\n  }\n  // Keep a sample only once the curve has moved a quarter of an LED from the\n  // last one kept, as the loupe shows it when that sample is at its edge:\n  // 1/180 of the distance to phi(t0), and no less than 1/200 of an LED at\n  // 256 times.\n  const n0 = xs.length, kx = [], ky = [], ks = [], gs = [];\n  let lx = 1e9, ly = 1e9;\n  for (let i = 0; i \u003c n0; i++) {\n    const x = xs[i], y = ys[i], r = sqrt(x * x + y * y), d = sqrt((x - lx) ** 2 + (y - ly) ** 2);\n    if (ss[i] !== 0 && d \u003c max(r / 180, 1e-7) && i \u003c n0 - 1) continue;\n    if (kx.length % GROUP === 0) gs.push(kx.length);\n    kx.push(x), ky.push(y), ks.push(ss[i]);\n    (lx = x), (ly = y);\n  }\n  const n = kx.length, ng = gs.length;\n  gs.push(n);\n  const box = new Float64Array(ng * 5);\n  for (let g = 0; g \u003c ng; g++) {\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9, len = 0;\n    for (let i = gs[g]; i \u003c= gs[g + 1]; i++) {\n      const k = i % n, x = kx[k], y = ky[k];\n      x0 = min(x0, x);\n      x1 = max(x1, x);\n      y0 = min(y0, y);\n      y1 = max(y1, y);\n      if (i > gs[g]) len += sqrt((x - kx[(i - 1) % n]) ** 2 + (y - ky[(i - 1) % n]) ** 2);\n    }\n    box.set([x0, x1, y0, y1, len], g * 5);\n  }\n  S.lx = Float64Array.from(kx);\n  S.ly = Float64Array.from(ky);\n  S.ls = Float64Array.from(ks);\n  S.lg = Int32Array.from(gs);\n  S.lbox = box;\n  S.t0 = t0;\n  S.c = [cr, ci];\n  S.which = which;\n  S.lcol = null;\n}\n\n// Top view splats: for each LED a line of the curve crosses, how much line\n// from which stretch of t, NB stretches to the period. Built once.\nconst NB = 1024, PB = G / NB;\nlet TE = null;\nfunction topSplats() {\n  if (TE) return;\n  const P = [], Wt = [], I = [], acc = new Float32Array(NP), seen = [];\n  const touch = (a, b, v) => {\n    if (a \u003c 0 || a >= W || b \u003c 0 || b >= LY0 - 2 || v \u003c= 0) return;\n    const p = b * W + a;\n    if (acc[p] === 0) seen.push(p);\n    acc[p] += v;\n  };\n  for (let bk = 0; bk \u003c NB; bk++) {\n    for (let i = bk * PB; i \u003c (bk + 1) * PB; i++) {\n      const x0 = TX + GX[i] * TS, y0 = TY - GY[i] * TS, x1 = TX + GX[i + 1] * TS, y1 = TY - GY[i + 1] * TS;\n      const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, ceil(len * 2)), w = len / n;\n      for (let k = 0; k \u003c n; k++) {\n        const u = (k + 0.5) / n, x = x0 + (x1 - x0) * u, y = y0 + (y1 - y0) * u;\n        const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n        touch(ix, iy, (1 - fx) * (1 - fy) * w);\n        touch(ix + 1, iy, fx * (1 - fy) * w);\n        touch(ix, iy + 1, (1 - fx) * fy * w);\n        touch(ix + 1, iy + 1, fx * fy * w);\n      }\n    }\n    for (const p of seen) P.push(p), Wt.push(acc[p]), I.push(bk), (acc[p] = 0);\n    seen.length = 0;\n  }\n  TE = { p: Int32Array.from(P), w: Float32Array.from(Wt), i: Int32Array.from(I) };\n}\n\nexport function setup(params) {\n  params.s = null;\n}\n\nfunction init(params) {\n  curve();\n  topSplats();\n  const S = {\n    clock: 0, hue: -1, which: -1,\n    bcol: new Float32Array(NB * 3), bb: new Float32Array(NB), bw: new Float32Array(NB),\n    R: new Float32Array(NP), Gc: new Float32Array(NP), B: new Float32Array(NP), D: new Float32Array(NP),\n  };\n  params.s = S;\n  return S;\n}\n\n// Azure at t = 1, the top, to pink at t = 0 and 2, the tip: mirror-symmetric\n// like the curve, phi(2 - t) = -conj phi(t).\nconst hueAt = (S, t, band = 0) => wheel(0.5 + S.hue + 0.42 * abs(1 - t) + band);\n\nexport function update(dt, input, params) {\n  const S = params.s || init(params);\n  const k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(k[1], 0.2, 3);\n  const which = min(POINTS.length - 1, floor(cl(k[2], 0, 1) * POINTS.length));\n  if (which !== S.which) loupe(S, which);\n  S.depth = 4 + 4 * cl(k[3], 0, 1);\n  if (k[0] !== S.hue) {\n    S.hue = k[0];\n    for (let b = 0; b \u003c NB; b++) hsv(hueAt(S, (b + 0.5) * PB * HG), 0.72, 1, S.bcol, b * 3);\n    S.lcol = null;\n  }\n  S.clock += d;\n}\n\nfunction add(S, x, y, v, r, g, b) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  put(S, ix, iy, (1 - fx) * (1 - fy) * v, r, g, b);\n  put(S, ix + 1, iy, fx * (1 - fy) * v, r, g, b);\n  put(S, ix, iy + 1, (1 - fx) * fy * v, r, g, b);\n  put(S, ix + 1, iy + 1, fx * fy * v, r, g, b);\n}\nfunction put(S, x, y, v, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c LY0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * r;\n  S.Gc[p] += v * g;\n  S.B[p] += v * b;\n  S.D[p] += v;\n}\n// Light straight into the frame, after the tone curve: a bilinear dot, and\n// a thin line of them kept to rows `top` and below.\nfunction dot(S, x, y, v, top = 0) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  lit(S, ix, iy, (1 - fx) * (1 - fy) * v, top);\n  lit(S, ix + 1, iy, fx * (1 - fy) * v, top);\n  lit(S, ix, iy + 1, (1 - fx) * fy * v, top);\n  lit(S, ix + 1, iy + 1, fx * fy * v, top);\n}\nfunction lit(S, a, b, v, top) {\n  if (a \u003c 0 || a >= W || b \u003c top || b >= H) return;\n  const p = b * W + a;\n  S.R[p] += v;\n  S.Gc[p] += v;\n  S.B[p] += v;\n}\nfunction glow(S, x0, y0, x1, y1, v, top) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, ceil(len * 1.5)), w = (v * len) / (n + 1);\n  for (let k = 0; k \u003c= n; k++) dot(S, x0 + ((x1 - x0) * k) / n, y0 + ((y1 - y0) * k) / n, w, top);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, Gc, B, D, bcol, bb, bw } = S;\n  R.fill(0);\n  Gc.fill(0);\n  B.fill(0);\n  D.fill(0);\n  // One lap of the pen takes 16 / Speed seconds; at Speed 2 it reaches the\n  // loupe's point 2.5 s in, as deep as the loupe goes.\n  const T = 16 / S.speed, lap = S.clock / T + S.t0 / 2 - 2.5 / 8;\n  const tp = 2 * (lap - floor(lap));\n  const base = 0.4, tau = T / 5;\n  const age = (t) => {\n    let a = tp - t;\n    a -= 2 * floor(a / 2);\n    return (a * T) / 2;\n  };\n  for (let b = 0; b \u003c NB; b++) bb[b] = base + (1 - base) * exp(-age((b + 0.5) * PB * HG) / tau);\n  // The top view.\n  const { p: EP, w: EW, i: EI } = TE;\n  // The last third of a second behind the pen burns white.\n  for (let b = 0; b \u003c NB; b++) bw[b] = exp(-age((b + 0.5) * PB * HG) / 0.3);\n  for (let e = 0; e \u003c EP.length; e++) {\n    const p = EP[e], b = EI[e], w = EW[e], v = w * bb[b], h = bw[b];\n    R[p] += v * (bcol[b * 3] + (1 - bcol[b * 3]) * h);\n    Gc[p] += v * (bcol[b * 3 + 1] + (1 - bcol[b * 3 + 1]) * h);\n    B[p] += v * (bcol[b * 3 + 2] + (1 - bcol[b * 3 + 2]) * h);\n    D[p] += w;\n  }\n\n  // The dive: magnification 2^(depth w), deepest when the pen is at t0.\n  let ph = lap - S.t0 / 2;\n  ph -= floor(ph);\n  const wv = (1 + cos(2 * PI * ph)) / 2, M = 2 ** (S.depth * wv);\n  const kz = (32 * M) / RHO0;\n  const { lx, ly, ls, lg, lbox } = S, n = lx.length, ng = lg.length - 1;\n  if (!S.lcol) {\n    S.lcol = new Float32Array(n * 3);\n    for (let i = 0; i \u003c n; i++) {\n      let t = S.t0 + ls[i];\n      t -= 2 * floor(t / 2);\n      // Bands of scale: the hue swings once every factor 16 in |s|.\n      const band = ls[i] === 0 ? 0 : 0.07 * cos((PI * log2(abs(ls[i]))) / 2);\n      hsv(hueAt(S, t, band), 0.72, 1, S.lcol, i * 3);\n    }\n  }\n  const lc = S.lcol;\n  // The loupe lights up as the pen passes its point.\n  const lb = 0.65 + 0.35 * exp(-age(S.t0) / tau);\n  const xmin = -1, xmax = W + 1, ymin = LY0 - 1, ymax = H + 1;\n  for (let g = 0; g \u003c ng; g++) {\n    const o = g * 5;\n    if (LCX + lbox[o + 1] * kz \u003c xmin || LCX + lbox[o] * kz > xmax || LCY - lbox[o + 2] * kz \u003c ymin || LCY - lbox[o + 3] * kz > ymax) continue;\n    const a = lg[g], e = lg[g + 1], gap = (lbox[o + 4] * kz) / (e - a);\n    const step = gap >= 0.5 ? 1 : min(64, floor(0.5 / gap));\n    for (let i = a; i \u003c e; i += step) {\n      const j = min(i + step, e) % n;\n      let x0 = LCX + lx[i] * kz, y0 = LCY - ly[i] * kz, x1 = LCX + lx[j] * kz, y1 = LCY - ly[j] * kz;\n      if ((x0 \u003c xmin && x1 \u003c xmin) || (x0 > xmax && x1 > xmax) || (y0 \u003c ymin && y1 \u003c ymin) || (y0 > ymax && y1 > ymax)) continue;\n      let dx = x1 - x0, dy = y1 - y0, len = sqrt(dx * dx + dy * dy);\n      if (len > 40) {\n        // Clip a long segment to the loupe (Liang-Barsky).\n        let u0 = 0, u1 = 1, ok = true;\n        const P4 = [-dx, dx, -dy, dy], Q4 = [x0 - xmin, xmax - x0, y0 - ymin, ymax - y0];\n        for (let c = 0; c \u003c 4 && ok; c++) {\n          const pp = P4[c], qq = Q4[c];\n          if (pp === 0) ok = qq >= 0;\n          else {\n            const r = qq / pp;\n            if (pp \u003c 0) r > u1 ? (ok = false) : r > u0 && (u0 = r);\n            else r \u003c u0 ? (ok = false) : r \u003c u1 && (u1 = r);\n          }\n        }\n        if (!ok) continue;\n        const ax = x0 + dx * u0, ay = y0 + dy * u0;\n        x1 = x0 + dx * u1;\n        y1 = y0 + dy * u1;\n        x0 = ax;\n        y0 = ay;\n        dx = x1 - x0;\n        dy = y1 - y0;\n        len = sqrt(dx * dx + dy * dy);\n      }\n      const m = max(1, ceil(len)), w = len / m;\n      const r = lc[i * 3] * lb, gg = lc[i * 3 + 1] * lb, b = lc[i * 3 + 2] * lb;\n      for (let k = 0; k \u003c m; k++) {\n        const u = (k + 0.5) / m;\n        add(S, x0 + dx * u, y0 + dy * u, w, r, gg, b);\n      }\n    }\n  }\n\n  // Tone: the average colour times min(1, D)^0.6.\n  for (let p = 0; p \u003c NP; p++) {\n    const dd = D[p];\n    if (dd > 0) {\n      const f = min(1, dd) ** 0.6 / dd;\n      R[p] *= f;\n      Gc[p] *= f;\n      B[p] *= f;\n    }\n  }\n\n  // Guides in the loupe: Gerver's tangent, or the corner's two arms along\n  // c e^(i pi/4) and -c e^(-i pi/4).\n  const [cr, ci] = S.c, gv = 0.18;\n  if (cr === 0 && ci === 0) glow(S, 0, LCY, W - 1, LCY, gv, LY0);\n  else {\n    const m = sqrt(cr * cr + ci * ci), e = 80;\n    for (const [ar, ai] of [[(cr - ci) / sqrt(2), (cr + ci) / sqrt(2)], [-(cr + ci) / sqrt(2), (cr - ci) / sqrt(2)]])\n      glow(S, LCX, LCY, LCX + (ar / m) * e, LCY - (ai / m) * e, gv, LY0);\n  }\n  // The loupe's window on the top view, and its point.\n  const g0 = round(S.t0 / HG) % G, cx = TX + GX[g0] * TS, cy = TY - GY[g0] * TS;\n  const wx = (RHO0 / M) * TS, wy = wx * (27 / 32);\n  if (wx >= 1.5) {\n    const v = 0.45;\n    glow(S, cx - wx, cy - wy, cx + wx, cy - wy, v, 0);\n    glow(S, cx - wx, cy + wy, cx + wx, cy + wy, v, 0);\n    glow(S, cx - wx, cy - wy, cx - wx, cy + wy, v, 0);\n    glow(S, cx + wx, cy - wy, cx + wx, cy + wy, v, 0);\n  }\n  dot(S, cx, cy, 0.8);\n  // The pen.\n  {\n    const f = tp / HG, i = min(G - 1, floor(f)), u = f - i;\n    const x = TX + (GX[i] + (GX[i + 1] - GX[i]) * u) * TS, y = TY - (GY[i] + (GY[i + 1] - GY[i]) * u) * TS;\n    dot(S, x, y, 2.5);\n    for (const [ox, oy] of [[-1.2, 0], [1.2, 0], [0, -1.2], [0, 1.2]]) dot(S, x + ox, y + oy, 0.45);\n  }\n  // The loupe's top edge.\n  for (let x = 0; x \u003c W; x += 2) dot(S, x, LY0 - 2, 0.22);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, Gc[p]) * 255), round(min(1, B[p]) * 255));\n}\n","veech-octagon":"// ===== Patternflow pattern =====\n// Title:   Veech Octagon\n// Family:  topology\n// Idea:    Four straight lines on each surface run in one shared direction across the regular octagon with opposite sides glued, above, and the double regular pentagon, below, leaving by a side and coming back by the side glued to it; in most directions they fill their surface evenly, and in the directions Veech's dichotomy picks out they close up and the surface falls apart into two cylinders of closed lines, each its own colour.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: straight-line flow on flat surfaces (Ralph Fox and Richard Kershner, 1936), unique ergodicity in almost every direction (Steven Kerckhoff, Howard Masur and John Smillie, 1986), translation surfaces from regular polygons and the Veech dichotomy (William Veech, 1989), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Direction=45..135, Trail=0..1\n//\n// Knob 1: Hue. Turns the two cylinders round the wheel together. At 0 the shorter cylinder is azure and the longer violet, the lines pale lavender with a white comet at each head, and a surface whose direction fills it dark slate; at 0.25 violet and red, at 0.5 red and green, at 0.75 green and teal. Orange and dark yellow are skipped, as they read brown.\n// Knob 2: Speed. The lines run 0.8 x Speed sides a second, 1.6 at 2 (36 LEDs a second), so a line in the octagon's middle cylinder, 2.41 sides round, closes every 1.5 s. Each line keeps the stretch it ran in the last Trail seconds, so Speed sets its length too: at 0.2 a line is 0.9 sides long and no longer reaches round its cylinder, at 3 it is 13 sides.\n// Knob 3: Direction. The direction of every line, in degrees from the horizontal. Within 1 degree of a periodic direction it snaps to it. The octagon's are 45, 90 and 135, along its sides, where it splits into its middle band, 1 + sqrt 2 = 2.414 sides round, and the two trapezoids either side of it glued into one cylinder 2 + sqrt 2 = 3.414 round, with inverse moduli 2.414 and 4.828, one exactly twice the other; and 67.5 and 112.5, along its diagonals, where the cylinders are 1.848 and 4.461 round and both have inverse modulus 2 cot(pi/8) = 4.828, the thin one showing as two corner triangles. The double pentagon's are 72 and 108, along its sides, cylinders phi = 1.618 and phi^2 = 2.618 round with inverse moduli both 2 cot(pi/5) = 2.753, and 54, 90 and 126, through its corners, 4.980 and 8.057 round with inverse moduli both 26.07, tan^2 72 = 9.47 times thinner. At 90 both surfaces close. Between the snaps the knob passes periodic directions too, densely, but they close only on long lines, 11.90 and 16.84 sides at 56.70 for the octagon, and a direction off them by any amount fills. It opens at 45: the octagon closed, the pentagon filling.\n// Knob 4: Trail. How many seconds of line each head keeps, T = 4 + 56 K4^1.3: 5.5 s at the opening, 8.7 sides at Speed 2, so each closed line in the octagon has been round 2.5 to 3.6 times and glows, while in the pentagon the same length lies as fresh parallel strokes. Every part is as bright as it is recent, falling to nothing at T. At 1 the trail is 60 s, 96 sides, and a surface that fills is an even silver.\n// Buttons: K1 tap starts all eight lines again from new random points. The first ones start from fixed points, two in each cylinder of the octagon at 45 degrees.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, cos, sin, abs, round, ceil, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without orange and dark yellow, 0.03 to 0.17, which read brown.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\n// A translation surface: convex polygons with side 1, y up, each side glued\n// to a parallel side by a translation. For a polygon symmetric about its\n// centre, or a polygon and its copy turned through a half turn, the side\n// from a to b goes to the side from -b to -a, and the translation is\n// -(a + b).\nfunction build(polys, partner) {\n  return polys.map((V, p) =>\n    V.map((a, i) => {\n      const b = V[(i + 1) % V.length], ex = b[0] - a[0], ey = b[1] - a[1], [to, j] = partner(p, i);\n      return { ax: a[0], ay: a[1], ex, ey, nx: -ey, ny: ex, len2: ex * ex + ey * ey, to, j, tx: -(a[0] + b[0]), ty: -(a[1] + b[1]) };\n    }),\n  );\n}\n// The regular octagon, sides horizontal at the top and bottom, side i glued\n// to side i + 4. Area 2 (1 + sqrt 2) = 4.83.\nconst RO = (1 + sqrt(2)) / 2;\nconst OCT_V = [[-0.5, -RO], [0.5, -RO], [RO, -0.5], [RO, 0.5], [0.5, RO], [-0.5, RO], [-RO, 0.5], [-RO, -0.5]];\n// The double pentagon: a regular pentagon standing on a horizontal side and\n// its copy turned through a half turn, glued along that side, every other\n// side of one glued to the parallel side of the other. Area 3.44.\nconst C72 = cos((2 * PI) / 5), S72 = sin((2 * PI) / 5), HP = S72 + sin(PI / 5);\nconst PEN_A = [[-0.5, 0], [0.5, 0], [0.5 + C72, S72], [0, HP], [-0.5 - C72, S72]];\nconst PEN_B = PEN_A.map(([x, y]) => [-x, -y]);\n\n// On the panel: 22.8 LEDs a side. The octagon, 55 LEDs across, at the top;\n// the double pentagon, 37 across and 70 tall, below it.\nconst SC = 22.8;\nconst SURF = [\n  { polys: [OCT_V], E: build([OCT_V], (p, i) => [0, (i + 4) % 8]), cx: 32, cy: 28.1, dirs: [45, 67.5, 90, 112.5, 135] },\n  { polys: [PEN_A, PEN_B], E: build([PEN_A, PEN_B], (p, i) => [1 - p, i]), cx: 32, cy: 92.6, dirs: [54, 72, 90, 108, 126] },\n];\nconst SNAP = 1; // degrees either side of a periodic direction that snap to it\nconst RAYS = 4; // lines on each surface\nconst VEL = 0.8; // sides a second at Speed 1\nconst COMET = 0.5; // sides of white behind each head\n\n// From (x, y) in polygon p along (ux, uy): the distance to the side the line\n// leaves by, that side, and where along it, 0 to 1.\nconst EX = [0, 0, 0];\nfunction exit(E, p, x, y, ux, uy, skip) {\n  const es = E[p];\n  let bt = Infinity, bi = -1;\n  for (let i = 0; i \u003c es.length; i++) {\n    if (i === skip) continue;\n    const e = es[i], un = ux * e.nx + uy * e.ny;\n    if (un >= -1e-15) continue;\n    const t = ((e.ax - x) * e.nx + (e.ay - y) * e.ny) / un;\n    if (t \u003c bt) (bt = t), (bi = i);\n  }\n  if (bi \u003c 0) return null;\n  const e = es[bi];\n  EX[0] = bt \u003c 0 ? 0 : bt;\n  EX[1] = bi;\n  EX[2] = ((x + bt * ux - e.ax) * e.ex + (y + bt * uy - e.ay) * e.ey) / e.len2;\n  return EX;\n}\n// The length of the closed line through (x0, y0) in polygon p0, or -1 when\n// it runs into the corner, the one cone point of angle 6 pi, first.\nfunction period(E, p0, x0, y0, ux, uy) {\n  let p = p0, x = x0, y = y0, skip = -1, L = 0;\n  for (let k = 0; k \u003c 120; k++) {\n    const r = exit(E, p, x, y, ux, uy, skip);\n    if (!r) return -1;\n    const t = r[0], i = r[1], s = r[2];\n    if (k > 0 && p === p0) {\n      const dx = x0 - x, dy = y0 - y, along = dx * ux + dy * uy;\n      if (abs(dx * uy - dy * ux) \u003c 1e-9 && along > -1e-12 && along \u003c= t + 1e-12) return L + along;\n    }\n    if (s \u003c 1e-9 || s > 1 - 1e-9) return -1;\n    const e = E[p][i];\n    x += t * ux + e.tx;\n    y += t * uy + e.ty;\n    L += t;\n    p = e.to;\n    skip = e.j;\n  }\n  return -1;\n}\nfunction inside(E, p, x, y) {\n  for (const e of E[p]) if ((x - e.ax) * e.nx + (y - e.ay) * e.ny \u003c 0) return false;\n  return true;\n}\n\nexport function setup(params) {\n  // Every LED whose centre falls inside a polygon, with its point there.\n  const who = new Int8Array(NP).fill(-1), poly = new Int8Array(NP), px = new Float64Array(NP), py = new Float64Array(NP);\n  for (let s = 0; s \u003c 2; s++) {\n    const S = SURF[s];\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const mx = (x + 0.5 - S.cx) / SC, my = (S.cy - y - 0.5) / SC;\n        for (let p = 0; p \u003c S.E.length; p++)\n          if (inside(S.E, p, mx, my)) {\n            const o = y * W + x;\n            (who[o] = s), (poly[o] = p), (px[o] = mx), (py[o] = my);\n          }\n      }\n  }\n  params.s = {\n    who, poly, px, py, maps: {}, heads: [null, null], dir: 45, started: false, prev: false,\n    k: [0, 2, 45, 0.06], rgb: new Float32Array(NP * 3), tb: new Float32Array(NP), c: new Float32Array(24), clock: 0,\n  };\n}\n\n// The cylinders of surface s in direction d: every LED inside it gets the\n// rank of its closed line's length, shortest first, so each cylinder is one\n// number.\nfunction cylinders(S, s, d) {\n  const key = s + \":\" + d;\n  if (S.maps[key]) return S.maps[key];\n  const E = SURF[s].E, ux = cos((d * PI) / 180), uy = sin((d * PI) / 180);\n  const len = new Float64Array(NP).fill(-1), lens = [];\n  for (let o = 0; o \u003c NP; o++) {\n    if (S.who[o] !== s) continue;\n    const c = period(E, S.poly[o], S.px[o], S.py[o], ux, uy);\n    len[o] = c;\n    if (c > 0 && !lens.some((v) => abs(v - c) \u003c 1e-6)) lens.push(c);\n  }\n  lens.sort((a, b) => a - b);\n  const rank = new Int8Array(NP).fill(-1);\n  for (let o = 0; o \u003c NP; o++) if (len[o] > 0) rank[o] = lens.findIndex((v) => abs(v - len[o]) \u003c 1e-6);\n  return (S.maps[key] = { rank, lens });\n}\n\n// The first lines start at fixed points, two in each cylinder of the\n// octagon at 45 degrees; a tap of K1 draws new ones at random.\nconst FIRST = [\n  [[0, 0.15, 0.1], [0, -0.75, 0.55], [0, 0.55, -0.85], [0, 0.95, 0.35]],\n  [[0, 0.05, 0.6], [0, -0.3, 1.0], [1, 0.2, -0.5], [1, -0.35, -1.0]],\n];\nfunction launch(s) {\n  const E = SURF[s].E;\n  for (;;) {\n    const p = floor(random() * E.length), x = (random() - 0.5) * 3.2, y = (random() - 0.5) * 3.2;\n    if (inside(E, p, x, y)) return { p, x, y, skip: -1 };\n  }\n}\n// Move a point a distance L along (ux, uy), through the glued sides.\nfunction flow(E, h, L, ux, uy) {\n  for (let k = 0; k \u003c 400 && L > 0; k++) {\n    const r = exit(E, h.p, h.x, h.y, ux, uy, h.skip);\n    if (!r) return;\n    const t = r[0], i = r[1];\n    if (t > L) {\n      h.x += L * ux;\n      h.y += L * uy;\n      h.skip = -1;\n      return;\n    }\n    const e = E[h.p][i];\n    h.x += t * ux + e.tx;\n    h.y += t * uy + e.ty;\n    h.p = e.to;\n    h.skip = e.j;\n    L -= t;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 45, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.k[0] = k[0];\n  S.k[1] = cl(k[1], 0.2, 3);\n  S.k[2] = cl(k[2], 45, 135);\n  S.k[3] = cl(k[3], 0, 1);\n  const press = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started || (press && !S.prev)) {\n    S.heads = S.started\n      ? [0, 1].map((s) => Array.from({ length: RAYS }, () => launch(s)))\n      : FIRST.map((f) => f.map(([p, x, y]) => ({ p, x, y, skip: -1 })));\n    S.started = true;\n  }\n  S.prev = press;\n  // Snap to the nearest direction in which either surface is periodic.\n  let dir = S.k[2];\n  for (const sf of SURF) for (const p of sf.dirs) if (abs(dir - p) \u003c= SNAP) dir = p;\n  S.dir = dir;\n  const ux = cos((dir * PI) / 180), uy = sin((dir * PI) / 180);\n  for (let s = 0; s \u003c 2; s++) for (const hd of S.heads[s]) flow(SURF[s].E, hd, VEL * S.k[1] * d, ux, uy);\n  S.clock += d;\n}\n\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction splatT(S, x, y, v) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy, T = S.tb;\n  if (ix \u003c 0 || iy \u003c 0 || ix >= W - 1 || iy >= H - 1) return;\n  const p = iy * W + ix;\n  T[p] += (1 - fx) * (1 - fy) * v;\n  T[p + 1] += fx * (1 - fy) * v;\n  T[p + W] += (1 - fx) * fy * v;\n  T[p + W + 1] += fx * fy * v;\n}\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  S.rgb[p] += v * c[o];\n  S.rgb[p + 1] += v * c[o + 1];\n  S.rgb[p + 2] += v * c[o + 2];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c, who } = S, h = S.k[0], dir = S.dir;\n  rgb.fill(0);\n  S.tb.fill(0);\n  // Colours: 0 and 3 the two cylinders, 6 a surface in a direction that\n  // fills it, 9 the sides, 12 the line, 15 its head.\n  hsv(wheel(0.48 + h), 0.85, 0.42, c, 0);\n  hsv(wheel(0.7 + h), 0.7, 0.42, c, 3);\n  hsv(wheel(0.6 + h), 0.35, 0.11, c, 6);\n  hsv(wheel(0.6 + h), 0.25, 0.42, c, 9);\n  hsv(wheel(0.62 + h), 0.15, 1, c, 12);\n  c[15] = c[16] = c[17] = 1;\n\n  for (let s = 0; s \u003c 2; s++) {\n    const sf = SURF[s], periodic = sf.dirs.includes(dir), m = periodic ? cylinders(S, s, dir) : null;\n    for (let o = 0; o \u003c NP; o++) {\n      if (who[o] !== s) continue;\n      const r = m ? m.rank[o] : -1, q = r === 0 ? 0 : r === 1 ? 3 : 6, p = o * 3;\n      rgb[p] = c[q];\n      rgb[p + 1] = c[q + 1];\n      rgb[p + 2] = c[q + 2];\n    }\n    // The sides, the double pentagon's inner side dotted.\n    for (let pi = 0; pi \u003c sf.E.length; pi++)\n      for (let i = 0; i \u003c sf.E[pi].length; i++) {\n        const e = sf.E[pi][i], inner = s === 1 && i === 0;\n        if (inner && pi === 1) continue;\n        const x0 = sf.cx + SC * e.ax, y0 = sf.cy - SC * e.ay, n = ceil(SC * 3);\n        for (let j = 0; j \u003c= n; j++) {\n          if (inner && j % 6 > 2) continue;\n          splat(S, x0 + (SC * e.ex * j) / n, y0 - (SC * e.ey * j) / n, inner ? 0.18 : 0.36, c, 9);\n        }\n      }\n    // The lines: back from each head as far as it came in the last Trail\n    // seconds, each part as bright as it is recent, so where a line closes\n    // on itself it adds up.\n    const Ltr = VEL * S.k[1] * (4 + 56 * S.k[3] ** 1.3), E = sf.E, wpass = 0.7 * min(1, sqrt(10 / Ltr));\n    const ux = cos((dir * PI) / 180), uy = sin((dir * PI) / 180);\n    for (const hd of S.heads[s]) {\n      const b = { p: hd.p, x: hd.x, y: hd.y, skip: -1 };\n      let done = 0;\n      for (let kk = 0; kk \u003c 600 && done \u003c Ltr; kk++) {\n        const r = exit(E, b.p, b.x, b.y, -ux, -uy, b.skip);\n        if (!r) break;\n        const t = min(r[0], Ltr - done), i = r[1];\n        const n = max(1, ceil(t * SC * 3));\n        for (let j = 0; j \u003c= n; j++) {\n          const u = (t * j) / n, w = 1 - (done + u) / Ltr;\n          const ww = (t * SC) / n;\n          splatT(S, sf.cx + SC * (b.x - u * ux), sf.cy - SC * (b.y - u * uy), wpass * w * ww);\n          if (done + u \u003c COMET) splat(S, sf.cx + SC * (b.x - u * ux), sf.cy - SC * (b.y - u * uy), 0.7 * (1 - (done + u) / COMET) * ww, c, 15);\n        }\n        done += t;\n        if (t \u003c r[0]) break;\n        if (r[2] \u003c 1e-9 || r[2] > 1 - 1e-9) break;\n        const e = E[b.p][i];\n        b.x -= t * ux - e.tx;\n        b.y -= t * uy - e.ty;\n        b.p = e.to;\n        b.skip = e.j;\n      }\n      splat(S, sf.cx + SC * hd.x, sf.cy - SC * hd.y, 1.2, c, 15);\n    }\n  }\n  // The lines over the surfaces, through 1 - e^(-x), so a line that closes\n  // and runs over itself many times stays below the white of the heads.\n  for (let o = 0, p = 0; o \u003c NP; o++, p += 3) {\n    const v = S.tb[o];\n    if (v \u003c= 0) continue;\n    const g = 0.86 * (1 - Math.exp(-1.6 * v));\n    rgb[p] += g * c[12];\n    rgb[p + 1] += g * c[13];\n    rgb[p + 2] += g * c[14];\n  }\n\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, round(min(1, rgb[p]) * 255), round(min(1, rgb[p + 1]) * 255), round(min(1, rgb[p + 2]) * 255));\n}\n","void-and-cluster":"// ===== Patternflow pattern =====\n// Title:   Void and Cluster\n// Family:  noise\n// Idea:    Clumpy white noise rearranges itself into blue noise as Ulichney's void-and-cluster method moves the dot at the tightest cluster into the largest void, again and again, until the move would put it back; then the settled dots are ranked one by one into a dither array and a threshold falls and rises through the ranks, so the dots leave and return in rank order, coloured by rank.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: blue noise (Robert Ulichney, 1988), the void-and-cluster method for dither arrays (Robert Ulichney, 1993), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Density=-1..1, Sigma=1.5..4\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the settling dots are azure, the crowded ones pink and pale, a dot a swap has just put down flashes white, and the ranked dots run from a pale azure at rank 0 through violet to pink at the top of the cycle; at 0.5 the dots are orange-red and the ranks run through yellow to green. The voids glow lavender to violet whatever the knob, as a dim warm glow reads brown.\n// Knob 2: Speed. At 2 the white noise stands still for 0.5 s, the swaps start at 36 a second and reach 243 a second, 0.16 of the 1516 dots, 0.8 s later, and the pattern settles after 431 to 464 swaps at 2.6 s; the threshold then falls to 0.45 of the settled count, rises to 1.45 and comes back in 6.3 s, and fresh white noise falls at 8.9 s. At 0.2 everything is ten times slower, settling at 26 s; at 3 it settles at 1.8 s.\n// Knob 3: Density. The share of LEDs lit in the settled pattern, 0.185 x 1.7^K: 891 dots at -1, 1516 at the opening 0, 2576 at 1, where the top of the cycle stops at 0.45 of the panel. A new value scatters fresh white noise.\n// Knob 4: Sigma. The width in LEDs of the Gaussian that measures clusters and voids. It opens at Ulichney's 1.5, where every threshold of the dither array keeps 7 to 9 percent of white noise's power below half the principal frequency sqrt(g); at 2.5 the settled dots keep 37 percent and at 4 83 percent, as the filter grows too wide to see the dots' own spacing: the swaps stop after 187 instead of 448 and the small clumps stay. A new value scatters fresh white noise.\n// Buttons: K1 tap scatters fresh white noise.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, exp, ceil, min, max, round, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The rank cycle after the dots settle, in seconds at Speed 2: hold, fall to\n// LO of the settled count, rise to HI, fall back, hold.\nconst HOLD0 = 0.4, FALL = 1.4, RISE = 2.8, BACK = 1.2, HOLD1 = 0.5;\nconst LO = 0.45, HI = 1.45;\n// Swaps a second at Speed 2, as a share of the dots.\nconst RATE = 0.16;\nconst STILL = 0.5, RAMP = 0.8, FLASH = 0.45, GHOST = 0.35;\n\nexport function setup(params) {\n  params.s = {\n    B: new Uint8Array(N), E: new Float64Array(N), ones: new Int32Array(N), at: new Int32Array(N), n: 0,\n    B2: new Uint8Array(N), E2: new Float64Array(N),\n    rank: new Int32Array(N), top: 0, np: 0,\n    flash: new Float32Array(N), ghost: new Float32Array(N),\n    K: null, R: 0, KW: 0, Ks: 0, sigma: 0, rho: 0,\n    mode: 0, t: 0, budget: 0, swaps: 0, thr: 0, dir: 0,\n    hue: 0, c: [0, 0, 0], fresh: true,\n  };\n}\n\nfunction kernel(S, sigma) {\n  S.sigma = sigma;\n  S.R = min(15, ceil(3 * sigma));\n  S.KW = 2 * S.R + 1;\n  S.K = new Float64Array(S.KW * S.KW);\n  S.Ks = 0;\n  for (let dy = -S.R; dy \u003c= S.R; dy++)\n    for (let dx = -S.R; dx \u003c= S.R; dx++) {\n      const v = exp(-(dx * dx + dy * dy) / (2 * sigma * sigma));\n      S.K[(dy + S.R) * S.KW + dx + S.R] = v;\n      S.Ks += v;\n    }\n}\n\n// Add (s = 1) or take away (s = -1) one dot's Gaussian from the energy E,\n// on the torus 64 x 128 the panel wraps into.\nfunction splat(S, E, p, s) {\n  const x = p & 63, y = p >> 6, R = S.R, KW = S.KW, K = S.K;\n  for (let dy = -R; dy \u003c= R; dy++) {\n    const row = (((y + dy) % H) + H) % H * W, k = (dy + R) * KW + R;\n    for (let dx = -R; dx \u003c= R; dx++) E[row + ((x + dx) & 63)] += s * K[k + dx];\n  }\n}\n\nfunction addOne(S, p) {\n  S.B[p] = 1;\n  S.at[p] = S.n;\n  S.ones[S.n++] = p;\n  splat(S, S.E, p, 1);\n}\nfunction removeOne(S, p) {\n  S.B[p] = 0;\n  const i = S.at[p], last = S.ones[--S.n];\n  S.ones[i] = last;\n  S.at[last] = i;\n  splat(S, S.E, p, -1);\n}\n\n// White noise: exactly rho N dots, every LED as likely as every other.\nfunction scatter(S) {\n  S.B.fill(0);\n  S.E.fill(0);\n  S.n = 0;\n  const want = round(S.rho * N);\n  const idx = new Int32Array(N);\n  for (let i = 0; i \u003c N; i++) idx[i] = i;\n  for (let i = 0; i \u003c want; i++) {\n    const j = i + floor(random() * (N - i)), t = idx[i];\n    idx[i] = idx[j];\n    idx[j] = t;\n    addOne(S, idx[i]);\n  }\n  S.rank.fill(-1);\n  S.flash.fill(0);\n  S.ghost.fill(0);\n  S.mode = 0;\n  S.t = 0;\n  S.budget = 0;\n  S.swaps = 0;\n}\n\nconst tightest = (S) => {\n  let c = -1, m = -1;\n  for (let i = 0; i \u003c S.n; i++) {\n    const p = S.ones[i];\n    if (S.E[p] > m) {\n      m = S.E[p];\n      c = p;\n    }\n  }\n  return c;\n};\nconst largestVoid = (B, E) => {\n  let v = -1, m = 1e30;\n  for (let p = 0; p \u003c N; p++)\n    if (!B[p] && E[p] \u003c m) {\n      m = E[p];\n      v = p;\n    }\n  return v;\n};\n\n// One swap of the initial pattern. Returns false once the dot taken from\n// the tightest cluster would go straight back into the largest void.\nfunction swap(S) {\n  const c = tightest(S);\n  removeOne(S, c);\n  const v = largestVoid(S.B, S.E);\n  if (v === c) {\n    addOne(S, c);\n    return false;\n  }\n  addOne(S, v);\n  S.flash[v] = 1;\n  S.ghost[c] = 1;\n  S.swaps++;\n  return true;\n}\n\n// The settled pattern is the prototype. Phase 1 takes its dots away, tightest\n// cluster first, ranking them from np - 1 down to 0; phase 2 starts again\n// from the prototype and fills the largest void, ranking from np up.\nfunction rankPrototype(S) {\n  S.np = S.n;\n  S.B2.set(S.B);\n  S.E2.set(S.E);\n  for (let r = S.n - 1; r >= 0; r--) {\n    const c = tightest(S);\n    S.rank[c] = r;\n    removeOne(S, c);\n  }\n  S.top = S.np;\n}\nfunction rankUpTo(S, n) {\n  while (S.top \u003c n) {\n    const v = largestVoid(S.B2, S.E2);\n    S.rank[v] = S.top++;\n    S.B2[v] = 1;\n    splat(S, S.E2, v, 1);\n  }\n}\n\nconst ease = (u) => u * u * (3 - 2 * u);\nfunction threshold(S, t) {\n  const np = S.np;\n  if (t \u003c HOLD0) return np;\n  t -= HOLD0;\n  if (t \u003c FALL) return np + (LO - 1) * np * ease(t / FALL);\n  t -= FALL;\n  if (t \u003c RISE) return LO * np + (HI - LO) * np * ease(t / RISE);\n  t -= RISE;\n  if (t \u003c BACK) return HI * np + (1 - HI) * np * ease(t / BACK);\n  return np;\n}\nconst CYCLE = HOLD0 + FALL + RISE + BACK + HOLD1;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  const rho = 0.185 * Math.pow(1.7, cl(k[2], -1, 1)), sigma = cl(k[3], 1.5, 4);\n  const press = input.btnPressed && input.btnPressed[0];\n  if (S.fresh || press || Math.abs(rho - S.rho) > 0.004 || Math.abs(sigma - S.sigma) > 0.05) {\n    S.fresh = false;\n    S.rho = rho;\n    kernel(S, sigma);\n    scatter(S);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    if (S.flash[p] > 0) S.flash[p] = max(0, S.flash[p] - tau / FLASH);\n    if (S.ghost[p] > 0) S.ghost[p] = max(0, S.ghost[p] - tau / GHOST);\n  }\n  S.t += tau;\n  if (S.mode === 0) {\n    // The white noise stands still for STILL, then the swaps start slowly,\n    // one at a time to the eye, and reach RATE in RAMP more.\n    if (S.t > STILL) S.budget += tau * RATE * S.n * min(1, 0.15 + (S.t - STILL) / RAMP);\n    while (S.budget >= 1) {\n      S.budget -= 1;\n      if (!swap(S)) {\n        rankPrototype(S);\n        S.mode = 1;\n        S.t = 0;\n        break;\n      }\n    }\n  } else {\n    if (S.t >= CYCLE) {\n      scatter(S);\n      return;\n    }\n    const thr = min(0.45 * N, threshold(S, S.t));\n    S.dir = thr > S.thr + 1e-9 ? 1 : thr \u003c S.thr - 1e-9 ? -1 : 0;\n    S.thr = thr;\n    rankUpTo(S, ceil(S.thr) + 1);\n  }\n}\n\n// A dot of the pattern being settled: the azure of the opening hue, going\n// pink and pale the more crowded it is against white noise of the same\n// density, and white for an instant where a swap has just put it.\nfunction dotColour(S, E, p, h0, out) {\n  const z = (E[p] - 1) / (S.rho * (S.Ks - 1)), w = cl((z - 1.05) / 0.8, 0, 1), f = S.flash[p];\n  hsv(h0 + 0.43 * w, (0.8 - 0.4 * w) * (1 - f), 1, out);\n}\n// A ranked dot: from the opening azure at rank 0 down the wheel through\n// green to yellow at the top of the cycle.\nfunction rankColour(S, r, h0, sat, out) {\n  const u = r / (HI * S.np);\n  hsv(h0 + 0.38 * u, (0.25 + 0.6 * u) * sat, 1, out);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.c, c2 = [0, 0, 0], h0 = S.hue + 0.55;\n  const put = (p, r, g, b) => display.setPixel(p & 63, p >> 6, round(r * 255), round(g * 255), round(b * 255));\n  if (S.mode === 0) {\n    const mean = S.rho * S.Ks, vh = 0.74 + 0.12 * (S.hue - floor(S.hue));\n    for (let p = 0; p \u003c N; p++) {\n      if (S.B[p]) dotColour(S, S.E, p, h0, c);\n      else if (S.ghost[p] > 0) hsv(h0 + 0.43, 0.5, 0.6 * S.ghost[p], c);\n      else {\n        // The voids glow where the energy falls below half its mean, in a\n        // cool hue whatever the knob, since a dim warm one reads brown.\n        const g = cl(1 - S.E[p] / (0.5 * mean), 0, 1);\n        hsv(vh, 0.4, 0.5 * g, c);\n      }\n      put(p, c[0], c[1], c[2]);\n    }\n    return;\n  }\n  const thr = S.thr, mix = cl(S.t / HOLD0, 0, 1);\n  for (let p = 0; p \u003c N; p++) {\n    const r = S.rank[p];\n    if (r \u003c 0 || r >= thr + 1) {\n      display.setPixel(p & 63, p >> 6, 0, 0, 0);\n      continue;\n    }\n    // The dots within 2% of the ranks below the threshold are arriving, white\n    // as they come, or leaving, fading as they go.\n    const a = cl((thr - r) / (0.02 * S.np), 0, 1);\n    rankColour(S, r, h0, S.dir > 0 ? a : 1, c);\n    if (mix \u003c 1 && r \u003c S.np) {\n      dotColour(S, S.E2, p, h0, c2);\n      for (let i = 0; i \u003c 3; i++) c[i] = c2[i] + (c[i] - c2[i]) * mix;\n    }\n    const v = S.dir \u003c 0 ? 0.25 + 0.75 * a : 1;\n    put(p, c[0] * v, c[1] * v, c[2] * v);\n  }\n}\n","yard-sale":"// ===== Patternflow pattern =====\n// Title:   Yard-Sale Model\n// Family:  data\n// Idea:    Sixty-four agents start with equal wealth and trade in random pairs, a fair coin deciding who takes a fraction of the poorer one's wealth, and the Lorenz curve on top sags from its diagonal, the sorted fortunes below fall away to one tall bar, and the Gini coefficient climbs toward 1 along the bottom, unless a tax pulls everyone back toward the mean.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lorenz curve (Max Lorenz, 1905), Gini coefficient (Corrado Gini, 1912), yard-sale model of asset exchange (Anirban Chakraborti, 2002; named by Brian Hayes, 2002), wealth condensation and redistribution (Bruce Boghosian and coauthors, 2014 and 2017), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fraction=0.2..0.6, Tax=0..1\n//\n// Knob 1: Hue. Turns the picture round the wheel. At 0 the gap between the diagonal and the Lorenz curve is azure, the bars rise from violet through blue to azure at the starting level and pale toward the top, and the curve, the trace and the one followed agent are cream; at 0.25 the gap is violet, at 0.5 red, at 0.75 green. Orange and dark yellow are skipped, as they read brown.\n// Knob 2: Speed. The clock a run is played on. A run is 1600 rounds of 32 trades, one trade per agent a round on average, on a log clock: the rounds done plus 40 grow e-fold every 5.4 s at Speed 2, so rounds 0 to 40, 40 to 120, 120 to 280 and so on each take 3.7 s, and the run reaches 1600 at 20 s. The trace across the bottom is drawn against the same log clock. At 0.2 ten times slower, at 3 one and a half times faster. The first run opens 14 rounds in, already off the diagonal; every later one starts equal.\n// Knob 3: Fraction. The share f of the poorer agent's wealth a trade moves. Over 16 economies at a time with no tax, the Gini coefficient averaged 0.54 at 50 rounds, 0.66 at 100, 0.77 at 200, 0.86 at 400, 0.92 at 800 and 0.95 at 1600 for f = 0.2; for f = 0.4 it was 0.77 at 50 rounds and 0.92 at 200, for f = 0.6 0.88 at 50. A run stops when the economy on the panel reaches 0.95 or 1600 rounds, holds 2.5 s and starts again equal: every 22 s at f = 0.2 (23 of 54 runs went the whole 1600 rounds), every 15 s at 0.4, every 11 s at 0.6.\n// Knob 4: Tax. Up to 0.1 there is none; above it every agent pays chi = 0.08 ((K4 - 0.1) / 0.9)^2 of its wealth a round into a pot shared equally, Boghosian's redistribution, and the Gini settles: at f = 0.2 on 0.69 at K4 = 0.25 (chi = 0.0022), 0.41 at 0.5 (0.0158), 0.28 at 0.75 (0.042) and 0.21 at 1 (0.08). In the Fokker-Planck limit it depends on chi / f^2 only; at chi / f^2 = 0.395 the steady Gini was 0.407, 0.403 and 0.396 for f = 0.2, 0.3 and 0.4.\n// Buttons: K1 tap restarts the economy with everyone equal.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, log, round, random, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without orange and dark yellow, 0.03 to 0.17, which read brown.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\n// N agents, W0 units each, so the total is N W0 = 64000 whole units and no\n// trade or tax can make or lose one.\nconst N = 64, W0 = 1000, TOTAL = N * W0;\n// The economy on the panel and 15 more run side by side from the same\n// start; the band their Gini coefficients span is drawn behind its own.\nconst E = 16;\n// A round is N / 2 trades, one for each agent on average. A run is 1600\n// rounds on a clock that runs in log time, r = R0 (e^(t / TAU) - 1), so\n// rounds 0 to 40, 40 to 120, 120 to 280 and so on each take the same time:\n// TAU = 5.4 s at Speed 2 and the whole run 20 s.\nconst R0 = 40, RUN = 1600, LRUN = log(1 + RUN / R0), TAU = 5.4;\nconst LZ = 63, BAR0 = 101, BARH = 34, TR0 = 127, TRH = 23;\nconst GSTOP = 0.95, HOLD = 2.5, BLOG = 20;\n\nexport function setup(params) {\n  params.s = {\n    w: new Int32Array(N * E), sorted: new Int32Array(N), ids: new Int32Array(N), L: new Float32Array(N + 1),\n    trace: new Float32Array(W).fill(-1), lo: new Float32Array(W).fill(-1), hi: new Float32Array(W).fill(-1),\n    rgb: new Float32Array(NP * 3), c: new Float32Array(12),\n    old: new Float32Array(NP * 3), rounds: 0, clock: 0, gini: 0, hold: 0, fade: 0, started: false,\n    k: [0, 2, 0.2, 0.06], prev: false,\n  };\n}\n\nfunction restart(S) {\n  S.w.fill(W0);\n  S.trace.fill(-1);\n  S.lo.fill(-1);\n  S.hi.fill(-1);\n  S.trace[0] = S.lo[0] = S.hi[0] = 0;\n  S.rounds = S.clock = S.gini = S.hold = 0;\n  S.old.set(S.rgb);\n  S.fade = 1;\n}\n\n// One round of economy e: N / 2 trades, then the tax. In a trade two agents\n// are drawn, a fair coin picks the winner, and the winner takes f times the\n// poorer agent's wealth, rounded at random to a whole unit so the mean is\n// exact. The tax takes chi of every agent's wealth, rounded the same way,\n// and shares the pot out equally; the units it cannot share go one each to\n// agents drawn at random.\nfunction round1(w, o, f, chi) {\n  for (let t = 0; t \u003c N / 2; t++) {\n    const i = o + floor(random() * N);\n    let j = o + floor(random() * (N - 1));\n    if (j >= i) j++;\n    const d = floor(f * min(w[i], w[j]) + random());\n    if (random() \u003c 0.5) (w[i] += d), (w[j] -= d);\n    else (w[i] -= d), (w[j] += d);\n  }\n  if (chi > 0) {\n    let pot = 0;\n    for (let i = o; i \u003c o + N; i++) {\n      const p = floor(chi * w[i] + random());\n      w[i] -= p;\n      pot += p;\n    }\n    const each = floor(pot / N);\n    for (let i = o; i \u003c o + N; i++) w[i] += each;\n    for (let r = pot - each * N; r > 0; r--) w[o + floor(random() * N)]++;\n  }\n}\n\n// Sort economy e by wealth and read its Gini coefficient off the Lorenz\n// curve: G = 1 - 2 * (area under it), the area by trapezoids, exact in\n// whole units.\nfunction sortAndGini(S, e) {\n  const { w, ids, sorted } = S, o = e * N;\n  for (let i = 0; i \u003c N; i++) ids[i] = i;\n  ids.sort((a, b) => w[o + a] - w[o + b] || a - b);\n  let cum = 0, area = 0;\n  for (let k = 0; k \u003c N; k++) {\n    const v = w[o + ids[k]];\n    sorted[k] = v;\n    area += 2 * cum + v;\n    cum += v;\n  }\n  return 1 - area / (N * TOTAL);\n}\n// The column of the trace a round falls in.\nconst colOf = (r) => min(W - 1, round(((W - 1) * log(1 + r / R0)) / LRUN));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.k[0] = k[0];\n  S.k[1] = cl(k[1], 0.2, 3);\n  S.k[2] = cl(k[2], 0.2, 0.6);\n  S.k[3] = cl(k[3], 0, 1);\n  const f = S.k[2], t4 = max(0, (S.k[3] - 0.1) / 0.9), chi = 0.08 * t4 * t4;\n  const press = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started || (press && !S.prev)) {\n    restart(S);\n    // The first run opens 0.3 TAU into its clock, 14 rounds in, so the\n    // curve has already left the diagonal; every later run starts equal.\n    if (!S.started) (S.clock = 0.3 * TAU), (S.fade = 0);\n    S.started = true;\n  }\n  S.prev = press;\n  S.fade = max(0, S.fade - d / 0.6);\n  if (S.hold > 0) {\n    S.hold += d;\n    if (S.hold > HOLD) restart(S);\n  } else {\n    S.clock += (d * S.k[1]) / 2;\n    const target = min(RUN, floor(R0 * (Math.exp(S.clock / TAU) - 1)));\n    while (S.rounds \u003c target) {\n      for (let e = 0; e \u003c E; e++) round1(S.w, e * N, f, chi);\n      S.rounds++;\n      const col = colOf(S.rounds);\n      if (col !== colOf(S.rounds + 1) || S.rounds === target) {\n        const g = sortAndGini(S, 0);\n        let lo = g, hi = g;\n        for (let e = 1; e \u003c E; e++) {\n          const ge = sortAndGini(S, e);\n          lo = min(lo, ge);\n          hi = max(hi, ge);\n        }\n        S.trace[col] = g;\n        S.lo[col] = lo;\n        S.hi[col] = hi;\n      }\n    }\n    if (S.rounds >= RUN) S.hold = 1e-6;\n  }\n  S.gini = sortAndGini(S, 0);\n  if (S.hold === 0 && S.gini >= GSTOP) S.hold = 1e-6;\n}\n\nfunction add(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  rgb[o] += r;\n  rgb[o + 1] += g;\n  rgb[o + 2] += b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c, sorted, L } = S, h = S.k[0];\n  sortAndGini(S, 0);\n  rgb.fill(0);\n  // Colours: 0 the gap between the diagonal and the curve, 3 the share\n  // under the curve, 6 the curve and the trace.\n  hsv(wheel(0.48 + h), 0.75, 0.52, c, 0);\n  hsv(wheel(0.68 + h), 0.6, 0.1, c, 3);\n  hsv(0.12 + h, 0.15, 1, c, 6);\n\n  // The Lorenz square, rows 0 to 63: share of agents across, share of\n  // wealth up. L(k) is the wealth of the poorest k agents over the total.\n  L[0] = 0;\n  for (let kk = 0; kk \u003c N; kk++) L[kk + 1] = L[kk] + sorted[kk] / TOTAL;\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5) / W, p = u * N, i = min(N - 1, floor(p)), lv = L[i] + (L[i + 1] - L[i]) * (p - i);\n    const yd = LZ - u * LZ, yl = LZ - lv * LZ;\n    for (let y = 0; y \u003c= LZ; y++) {\n      if (y \u003c yd - 0.5) continue;\n      if (y \u003c yl - 0.5) add(rgb, x, y, c[0] * 255, c[1] * 255, c[2] * 255);\n      else add(rgb, x, y, c[3] * 255, c[4] * 255, c[5] * 255);\n    }\n  }\n  for (let x = 0; x \u003c W; x++) add(rgb, x, round(LZ - ((x + 0.5) / W) * LZ), 40, 40, 40);\n  // A dot every tenth of the agents and every tenth of the wealth.\n  for (let i = 1; i \u003c 10; i++)\n    for (let j = 1; j \u003c 10; j++) add(rgb, round((i * W) / 10 - 0.5), round(LZ - (j * LZ) / 10), 34, 34, 38);\n  // The curve as an unbroken line: in each column, every row between its\n  // heights at the column's two edges.\n  for (let x = 0; x \u003c W; x++) {\n    const ya = LZ - L[x] * LZ, yb = LZ - L[x + 1] * LZ;\n    for (let y = round(yb); y \u003c= round(ya); y++) add(rgb, x, y, c[6] * 230, c[7] * 230, c[8] * 230);\n  }\n\n  // The sorted fortunes, rows 67 to 101, poorest at the left, on a log\n  // scale, log(1 + w / 20) over log(1 + all / 20), each LED coloured by its\n  // height: violet low, the hue of the gap at the starting level, paler\n  // above it. Agent 0 is drawn cream, so one fortune can be followed as it\n  // changes rank.\n  const top = log(1 + TOTAL / BLOG), y0 = (BARH * log(1 + W0 / BLOG)) / top;\n  for (let kk = 0; kk \u003c N; kk++) {\n    const hgt = (BARH * log(1 + sorted[kk] / BLOG)) / top;\n    for (let y = 0; y \u003c hgt; y++) {\n      const a = min(1, hgt - y);\n      if (y \u003c y0) hsv(wheel(0.72 + h - (0.24 * y) / y0), 0.8, 0.45 + (0.35 * y) / y0, c, 0);\n      else hsv(wheel(0.48 + h), 0.8 * (1 - (y - y0) / (BARH - y0)) + 0.1, 0.8 + (0.2 * (y - y0)) / (BARH - y0), c, 0);\n      if (S.ids[kk] === 0) add(rgb, kk, BAR0 - y, c[6] * 230 * a, c[7] * 230 * a, c[8] * 230 * a);\n      else add(rgb, kk, BAR0 - y, c[0] * 255 * a, c[1] * 255 * a, c[2] * 255 * a);\n    }\n  }\n  for (let x = 0; x \u003c W; x += 2) add(rgb, x, round(BAR0 - y0), 50, 50, 50);\n\n  // The Gini trace, rows 104 to 127, against rounds on a log scale: G = 0 at\n  // the bottom and 1 at the top, the highest a 64-agent economy can reach,\n  // 1 - 1/64, dotted. Behind the panel's own economy, bright, the band from\n  // the lowest to the highest of the sixteen.\n  for (let x = 0; x \u003c W; x += 2) add(rgb, x, round(TR0 - (1 - 1 / N) * TRH), 50, 50, 50);\n  hsv(wheel(0.48 + h), 0.75, 0.42, c, 0);\n  hsv(wheel(0.48 + h), 0.75, 0.16, c, 3);\n  for (let x = 0; x \u003c W; x++) {\n    const g = S.trace[x];\n    if (g \u003c 0) continue;\n    const yt = round(TR0 - g * TRH), ylo = round(TR0 - S.lo[x] * TRH), yhi = round(TR0 - S.hi[x] * TRH);\n    for (let y = yhi; y \u003c= TR0; y++) {\n      const o = y \u003c= ylo ? 0 : 3;\n      add(rgb, x, y, c[o] * 255, c[o + 1] * 255, c[o + 2] * 255);\n    }\n    add(rgb, x, yt, c[6] * 255, c[7] * 255, c[8] * 255);\n  }\n\n  const fd = S.fade, old = S.old;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      let r = min(255, rgb[p]), g = min(255, rgb[p + 1]), b = min(255, rgb[p + 2]);\n      if (fd > 0) (r = r * (1 - fd) + old[p] * fd), (g = g * (1 - fd) + old[p + 1] * fd), (b = b * (1 - fd) + old[p + 2] * fd);\n      (rgb[p] = r), (rgb[p + 1] = g), (rgb[p + 2] = b);\n      display.setPixel(x, y, r, g, b);\n    }\n}\n","art-gallery":"// ===== Patternflow pattern =====\n// Title:   Art Gallery\n// Family:  geometry\n// Idea:    A tall random gallery is drawn corner by corner, cut into triangles by clipping its ears one at a time, its corners given three colours so that every triangle has one of each, and then guards step out on the corners of the rarest colour and their light spreads over every LED they can see until the whole gallery is lit, which is Steve Fisk's proof that n/3 guards always suffice.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: art gallery problem (Victor Klee, 1973), art gallery theorem and the comb that needs every guard (Václav Chvátal, 1975), two ears theorem (Gary Meisters, 1975), three-colouring proof (Steve Fisk, 1978), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Corners=12..30, Depth=0.6..0.95\n//\n// Knob 1: Hue. Turns the three corner colours round together, on a wheel that skips orange and yellow. At 0 they are green, azure and pink; at 0.17 cyan, violet and red; at 0.5 violet, red and cyan. The guards' light is a pale version of whichever colour is rarest.\n// Knob 2: Speed. At 2 the outline takes 1 s, the ears 2.2 s, the colours 2 s and the guards 0.8 s; the light takes 2.4 s and 0.6 s more for every guard after the first; then the gallery stays lit for 2.4 s and fades in 0.8 s. That is 13.4 s for a gallery with 4 guards and 17 s for one with 10. At 0.2 it is ten times as long, at 3 two thirds as long.\n// Knob 3: Corners. n, 12 to 30. At 12 the gallery has 10 triangles, 9 diagonals and at most 4 guards; at 21 it has 19, 18 and 7; at 30 it has 28, 27 and 10. A new value starts a new gallery once the knob has rested for 0.35 s.\n// Knob 4: Depth. How far the inner corners cut in from the edge toward the spine down the middle, 0.7 to 1 times this. At 0.6 they reach 42 to 60% of the way and one guard sees 90% of a 12-corner gallery on average, 68% of a 30-corner one; at 0.95 they reach 67 to 95%, and one guard sees 74% and 41%. Every third gallery is Chvátal's comb, n/3 teeth whose tips no point sees two of, so it needs all n/3 guards and the colouring gives it that many; Depth narrows its teeth from 68% to 54% of their spacing.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, PI, exp, acos } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, x) => {\n  const t = cl((x - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The acts of one gallery, in seconds at Speed 2, and when each one ends.\n// The light act lasts as long as its guards need: they switch on 0.6 s\n// apart and each front runs out at 60 LEDs a second.\nconst T_OUT = 1, T_EAR = 2.2, T_COL = 2, T_GRD = 0.8, T_HOLD = 2.4, T_FADE = 0.8, GAP = 0.6, FRONT = 60;\nconst A1 = T_OUT, A2 = A1 + T_EAR, A3 = A2 + T_COL, A4 = A3 + T_GRD;\n// Rows of visibility worked out per frame. A gallery of 30 corners with\n// 10 guards costs up to 2 ms a frame this way for the first 32 frames,\n// and the light needs it 6 seconds in.\nconst VIS_ROWS = 4;\n\n// Hues on a wheel that skips orange through yellow, which read brown and\n// olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\nconst cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// A star around a vertical spine from row 32 to row 96. Each corner sits on\n// the ray from the spine to an even step round the edge of the panel, and\n// the rays never cross, so the polygon is simple whatever the radii. An\n// outer corner lies near the edge, an inner one depth x (0.7..1) of the way\n// in toward the spine.\nfunction star(n, depth) {\n  const X0 = 1.2, X1 = 62.8, Y0 = 1.2, Y1 = 126.8, CX = 32, S0 = 32, S1 = 96;\n  const a = X1 - X0, b = Y1 - Y0, per = 2 * (a + b);\n  const off = Math.random() * per, P = [];\n  let run = 1;\n  for (let i = 0; i \u003c n; i++) {\n    let s = (off + ((i + 0.5 + (Math.random() - 0.5) * 0.5) * per) / n) % per, qx, qy;\n    if (s \u003c a) (qx = X0 + s), (qy = Y0);\n    else if ((s -= a) \u003c b) (qx = X1), (qy = Y0 + s);\n    else if ((s -= b) \u003c a) (qx = X1 - s), (qy = Y1);\n    else (qx = X0), (qy = Y1 - (s - a));\n    // An inner corner never follows an inner one and always follows two\n    // outer ones; after one outer corner it comes with chance 0.6.\n    const inner = run > 0 && i \u003c n - 1 && (run > 1 || Math.random() \u003c 0.6);\n    run = inner ? 0 : run + 1;\n    const oy = cl(qy, S0, S1), r = inner ? 1 - depth * (0.7 + 0.3 * Math.random()) : 0.92 + 0.08 * Math.random();\n    P.push([CX + (qx - CX) * r, oy + (qy - oy) * r]);\n  }\n  return P;\n}\n\n// Chvátal's comb: a bar down one side and k = n / 3 teeth across the panel,\n// each tooth a triangle whose tip only a point inside that tooth's own cone\n// can see. A tooth w wide at its base and 48 long, in front of a bar 12\n// deep, has a cone 1.25 w wide at the back wall, so teeth narrower than 0.8\n// of their spacing keep the cones apart. Corners: two at the back, k tips\n// and two at every valley, 3k in all, and any left over go on the back wall.\nfunction comb(n, depth) {\n  const k = floor(n / 3), extra = n - 3 * k, yT = 1.5, yB = 126.5, xb = 2.2, xs = 14, xt = 62.3;\n  const s = (yB - yT) / k, w = s * (0.92 - 0.4 * depth), P = [[xb, yT]];\n  for (let e = 1; e \u003c= extra; e++) P.push([xb - 1.2, yT + ((yB - yT) * e) / (extra + 1)]);\n  P.push([xb, yB]);\n  for (let j = 0; j \u003c k; j++) {\n    const yc = yB - (j + 0.5) * s;\n    P.push([xt, yc]);\n    if (j \u003c k - 1) P.push([xs, yc - w / 2], [xs, yc - s + w / 2]);\n  }\n  const fx = Math.random() \u003c 0.5, fy = Math.random() \u003c 0.5;\n  return P.map(([x, y]) => [fx ? W - x : x, fy ? H - y : y]);\n}\n\nfunction segDist(p, a, b) {\n  const dx = b[0] - a[0], dy = b[1] - a[1], t = cl(((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / (dx * dx + dy * dy), 0, 1);\n  return Math.hypot(p[0] - a[0] - t * dx, p[1] - a[1] - t * dy);\n}\n\n// Every corner at least 2 LEDs from every edge that does not end at it, so\n// no part of the gallery is thinner than the panel can show.\nfunction roomy(P) {\n  const n = P.length;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) {\n      if (j === i || (j + 1) % n === i) continue;\n      if (segDist(P[i], P[j], P[(j + 1) % n]) \u003c 2) return false;\n    }\n  return true;\n}\n\nfunction angleAt(a, b, c) {\n  const ux = a[0] - b[0], uy = a[1] - b[1], vx = c[0] - b[0], vy = c[1] - b[1];\n  return acos(cl((ux * vx + uy * vy) / (Math.hypot(ux, uy) * Math.hypot(vx, vy) + 1e-9), -1, 1));\n}\n\n// Ear clipping. Meisters: a polygon with more than three corners has two\n// ears, corners whose triangle with their neighbours lies inside it, so\n// clipping one always leaves a smaller polygon to clip. Of the ears on\n// offer this takes the one with the widest smallest angle, which keeps the\n// triangles fat enough to read on 64 columns.\nfunction triangulate(P, sgn) {\n  const idx = P.map((_, i) => i), tris = [];\n  while (idx.length > 3) {\n    let best = 0, bq = -1;\n    const m = idx.length;\n    for (let t = 0; t \u003c m; t++) {\n      const a = idx[(t + m - 1) % m], b = idx[t], c = idx[(t + 1) % m];\n      if (cross(P[a], P[b], P[c]) * sgn \u003c= 1e-9) continue;\n      let ok = true;\n      for (const v of idx) {\n        if (v === a || v === b || v === c) continue;\n        const p = P[v];\n        if (cross(P[a], P[b], p) * sgn >= -1e-9 && cross(P[b], P[c], p) * sgn >= -1e-9 && cross(P[c], P[a], p) * sgn >= -1e-9) {\n          ok = false;\n          break;\n        }\n      }\n      if (!ok) continue;\n      const q = min(angleAt(P[c], P[a], P[b]), angleAt(P[a], P[b], P[c]), angleAt(P[b], P[c], P[a]));\n      if (q > bq) (bq = q), (best = t);\n    }\n    tris.push([idx[(best + m - 1) % m], idx[best], idx[(best + 1) % m]]);\n    idx.splice(best, 1);\n  }\n  tris.push([idx[0], idx[1], idx[2]]);\n  return tris;\n}\n\nfunction newGallery(S) {\n  const n = S.nWant, depth = S.dWant, isComb = S.count % 3 === 2;\n  let P = null;\n  for (let tries = 0; tries \u003c 40 && !P; tries++) {\n    const Q = isComb ? comb(n, depth) : star(n, depth * (1 - tries * 0.012));\n    if (isComb || roomy(Q)) P = Q;\n  }\n  let area = 0;\n  for (let i = 0; i \u003c n; i++) area += cross([0, 0], P[i], P[(i + 1) % n]);\n  const sgn = area > 0 ? 1 : -1, tris = triangulate(P, sgn), T = tris.length;\n  // Fisk: walk the dual tree from the triangle nearest the middle. Its three\n  // corners take the three colours; every triangle after it shares a\n  // diagonal, so two corners already have colours and the third takes the\n  // colour left over.\n  let start = 0, bd = 1e9;\n  tris.forEach((t, i) => {\n    const d = Math.hypot((P[t[0]][0] + P[t[1]][0] + P[t[2]][0]) / 3 - 32, (P[t[0]][1] + P[t[1]][1] + P[t[2]][1]) / 3 - 64);\n    if (d \u003c bd) (bd = d), (start = i);\n  });\n  const col = new Int8Array(n).fill(-1), step = new Int16Array(n), done = new Int16Array(T), seen = new Uint8Array(T), queue = [start];\n  let k = 0;\n  seen[start] = 1;\n  while (queue.length) {\n    const ti = queue.shift(), t = tris[ti];\n    if (ti === start) for (let c = 0; c \u003c 3; c++) (col[t[c]] = c), (step[t[c]] = k++);\n    else\n      for (const v of t)\n        if (col[v] \u003c 0) {\n          let used = 0;\n          for (const u of t) if (col[u] >= 0) used += col[u];\n          col[v] = 3 - used;\n          step[v] = k++;\n        }\n    done[ti] = max(step[t[0]], step[t[1]], step[t[2]]);\n    for (let j = 0; j \u003c T; j++) {\n      if (seen[j]) continue;\n      let shared = 0;\n      for (const v of tris[j]) if (v === t[0] || v === t[1] || v === t[2]) shared++;\n      if (shared === 2) (seen[j] = 1), queue.push(j);\n    }\n  }\n  const cnt = [0, 0, 0];\n  for (let i = 0; i \u003c n; i++) cnt[col[i]]++;\n  let rare = 0;\n  for (let c = 1; c \u003c 3; c++) if (cnt[c] \u003c cnt[rare]) rare = c;\n  const guards = [];\n  for (let i = 0; i \u003c n; i++) if (col[i] === rare) guards.push(i);\n  // Which triangle holds each LED centre, and where in it.\n  const tri = S.tri.fill(-1), bary = S.bary, vis = S.vis.fill(0);\n  tris.forEach((t, ti) => {\n    const a = P[t[0]], b = P[t[1]], c = P[t[2]], d = cross(a, b, c);\n    const x0 = max(0, floor(min(a[0], b[0], c[0]))), x1 = min(W - 1, ceil(max(a[0], b[0], c[0])));\n    const y0 = max(0, floor(min(a[1], b[1], c[1]))), y1 = min(H - 1, ceil(max(a[1], b[1], c[1])));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const p = [x + 0.5, y + 0.5], l0 = cross(b, c, p) / d, l1 = cross(c, a, p) / d, l2 = 1 - l0 - l1, o = y * W + x;\n        if (l0 \u003c -1e-6 || l1 \u003c -1e-6 || l2 \u003c -1e-6 || tri[o] >= 0) continue;\n        tri[o] = ti;\n        // How much of each corner's colour this LED takes: e^(9 l) for\n        // barycentric l, so each corner's colour holds the third of the\n        // triangle nearest it and they blend where the thirds meet.\n        const e0 = exp(9 * l0), e1 = exp(9 * l1), e2 = exp(9 * l2), es = e0 + e1 + e2;\n        bary[o * 3] = e0 / es;\n        bary[o * 3 + 1] = e1 / es;\n        bary[o * 3 + 2] = e2 / es;\n      }\n  });\n  let nIn = 0;\n  for (let o = 0; o \u003c W * H; o++) if (tri[o] >= 0) S.ins[nIn++] = o;\n  S.nIn = nIn;\n  const A5 = A4 + (guards.length - 1) * GAP + 2.4;\n  Object.assign(S, { P, n, tris, col, step, done, guards, sgn, t: 0, visRow: 0, isComb, dirty: -1, nNow: n, dNow: depth, A5, A6: A5 + T_HOLD, A7: A5 + T_HOLD + T_FADE });\n  S.count++;\n}\n\n// A guard at corner G sees the LED centre p when p is in the gallery and\n// the segment from G to p crosses no edge. On its own this test left 3 of\n// 2.5 million LEDs dark over 630 galleries, centres lying on a line\n// through a corner, which the triangle below takes care of. Edges ending at G cannot cross\n// it; if the segment leaves through G's own corner it has to come back in\n// across some other edge, so those are the only ones to test.\nfunction visRows(S, rows) {\n  const { P, n, guards, tri, vis } = S;\n  for (let r = 0; r \u003c rows && S.visRow \u003c H; r++, S.visRow++) {\n    const y = S.visRow + 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const o = S.visRow * W + x;\n      if (tri[o] \u003c 0) continue;\n      const px = x + 0.5, own = S.tris[tri[o]];\n      for (let g = 0; g \u003c guards.length; g++) {\n        // Fisk: every triangle has one corner of each colour, so one guard\n        // stands on a corner of the triangle this LED is in, and a triangle\n        // is convex, so that guard sees it without a test.\n        if (own.indexOf(guards[g]) >= 0) vis[o] |= 1 \u003c\u003c g;\n        if (vis[o] & (1 \u003c\u003c g)) continue;\n        const gi = guards[g], G = P[gi];\n        let clear = true;\n        for (let j = 0; j \u003c n && clear; j++) {\n          const j1 = (j + 1) % n;\n          if (j === gi || j1 === gi) continue;\n          const A = P[j], B = P[j1];\n          const d1 = (B[0] - A[0]) * (G[1] - A[1]) - (B[1] - A[1]) * (G[0] - A[0]);\n          const d2 = (B[0] - A[0]) * (y - A[1]) - (B[1] - A[1]) * (px - A[0]);\n          if (d1 * d2 >= 0) continue;\n          const d3 = (px - G[0]) * (A[1] - G[1]) - (y - G[1]) * (A[0] - G[0]);\n          const d4 = (px - G[0]) * (B[1] - G[1]) - (y - G[1]) * (B[0] - G[0]);\n          if (d3 * d4 \u003c 0) clear = false;\n        }\n        if (clear) vis[o] |= 1 \u003c\u003c g;\n      }\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    count: 0, nWant: 12, dWant: 0.6, tri: new Int16Array(W * H), bary: new Float32Array(W * H * 3), vis: new Uint16Array(W * H), ins: new Int32Array(W * H), nIn: 0, gx: new Float32Array(16), gy: new Float32Array(16), gr: new Float32Array(16), dc: [0, 0, 0], ec: [0, 0, 0],\n    buf: new Float32Array(W * H * 3), lifts: new Float32Array(32), tc: new Float32Array(32 * 9), hue: 0, C: [[0, 0, 0], [0, 0, 0], [0, 0, 0]], L: [0, 0, 0], c: [0, 0, 0], P: null,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 12, 0.6], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.nWant = round(cl(kv[2], 12, 30));\n  S.dWant = cl(kv[3], 0.6, 0.95);\n  if (!S.P) newGallery(S);\n  // A turned knob starts a new gallery once it has rested for 0.35 s.\n  if (S.nWant !== S.nNow || abs(S.dWant - S.dNow) > 0.02) {\n    if (S.dirty \u003c 0) S.dirty = 0;\n    if ((S.dirty += d) > 0.35) S.count--, newGallery(S);\n  } else S.dirty = -1;\n  S.t += (d * cl(kv[1], 0.2, 3)) / 2;\n  if (S.visRow \u003c H) visRows(S, VIS_ROWS);\n  if (S.t >= S.A7) newGallery(S);\n}\n\nfunction round(v) {\n  return floor(v + 0.5);\n}\n\n// Xiaolin Wu's line, mixed over what is there, so a grey diagonal is a\n// bright seam on the dark gallery and a dark one on the lit gallery.\nfunction line(B, x0, y0, x1, y1, c, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  let t;\n  if (steep) (t = x0), (x0 = y0), (y0 = t), (t = x1), (x1 = y1), (y1 = t);\n  if (x0 > x1) (t = x0), (x0 = x1), (x1 = t), (t = y0), (y0 = y1), (y1 = t);\n  const k = (y1 - y0) / (x1 - x0 || 1e-9);\n  for (let u = ceil(x0 - 0.5); u \u003c= floor(x1 - 0.5); u++) {\n    const v = y0 + k * (u + 0.5 - x0) - 0.5, vi = floor(v), f = v - vi;\n    plot(B, steep ? vi : u, steep ? u : vi, c, a * (1 - f));\n    plot(B, steep ? vi + 1 : u, steep ? u : vi + 1, c, a * f);\n  }\n}\n\nfunction plot(B, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  a = min(1, a);\n  B[o] += (c[0] - B[o]) * a;\n  B[o + 1] += (c[1] - B[o + 1]) * a;\n  B[o + 2] += (c[2] - B[o + 2]) * a;\n}\n\nfunction dot(B, x, y, r, c, a) {\n  for (let yy = floor(y - r); yy \u003c= y + r; yy++)\n    for (let xx = floor(x - r); xx \u003c= x + r; xx++) {\n      const q = Math.hypot(xx + 0.5 - x, yy + 0.5 - y) / r;\n      if (q \u003c 1) plot(B, xx, yy, c, a * min(1, 1.6 * (1 - q)));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const { P, n, tris, col, step, done, guards, tri, bary, vis, buf: B, C, L } = S, t = S.t, nt = tris.length;\n  const earAt = (k) => A1 + (T_EAR * (k + 0.5)) / nt, colAt = (s) => A2 + (T_COL * (s + 0.5)) / n;\n  for (let c = 0; c \u003c 3; c++) hsv(wheel(0.1 + S.hue + c / 3), 1, 1, C[c]);\n  const rare = col[guards[0]], G = C[rare];\n  for (let c = 0; c \u003c 3; c++) L[c] = 0.35 * G[c] + 0.65;\n  const fade = 1 - ss(S.A6, S.A7, t), base = hsv(wheel(0.46 + S.hue), 0.45, 0.12 * ss(0.3, A1, t), S.c);\n  // The light: guard k's front is FRONT x (t - A4 - k GAP) LEDs out.\n  const gx = S.gx, gy = S.gy, gr = S.gr;\n  for (let k = 0; k \u003c guards.length; k++) (gx[k] = P[guards[k]][0]), (gy[k] = P[guards[k]][1]), (gr[k] = FRONT * (t - A4 - k * GAP));\n  // Per triangle: the ear flashes as it is clipped and stays a shade\n  // lighter after; once its three corners have colours it takes a soft\n  // tint from them, each corner's colour strongest near that corner.\n  const lifts = S.lifts, tc = S.tc;\n  for (let i = 0; i \u003c nt; i++) {\n    const ea = t - earAt(i), ta = 0.3 * ss(colAt(done[i]), colAt(done[i]) + 0.4, t);\n    lifts[i] = ea > 0 ? 1.7 + 2.5 * exp(-ea / 0.3) : 1;\n    for (let k = 0; k \u003c 9; k++) tc[i * 9 + k] = C[col[tris[i][(k / 3) | 0]]][k % 3] * ta;\n  }\n  // What no guard sees yet sinks into shadow.\n  const sh = 1 - 0.4 * ss(A4, A4 + 1, t), ng = guards.length, lightOn = t > A4;\n  B.fill(0);\n  for (let j = 0; j \u003c S.nIn; j++) {\n      const o = S.ins[j], x = o % W, y = (o / W) | 0, ti = tri[o];\n      const lift = lifts[ti], w0 = bary[o * 3], w1 = bary[o * 3 + 1], w2 = bary[o * 3 + 2], q = ti * 9;\n      let r = base[0] * lift + w0 * tc[q] + w1 * tc[q + 3] + w2 * tc[q + 6];\n      let g = base[1] * lift + w0 * tc[q + 1] + w1 * tc[q + 4] + w2 * tc[q + 7];\n      let b = base[2] * lift + w0 * tc[q + 2] + w1 * tc[q + 5] + w2 * tc[q + 8];\n      if (lightOn) {\n        let lit = 0, rim = 0;\n        const m = vis[o];\n        for (let k = 0; k \u003c ng; k++) {\n          if (!(m & (1 \u003c\u003c k)) || gr[k] \u003c= 0) continue;\n          const ddx = x + 0.5 - gx[k], ddy = y + 0.5 - gy[k], d2 = ddx * ddx + ddy * ddy, R = gr[k];\n          if (R > 8 && d2 \u003c (R - 8) * (R - 8)) {\n            lit++;\n            continue;\n          }\n          const e = R - sqrt(d2);\n          if (e > -3) (lit += cl(e / 4, 0, 1)), (rim += exp(-e * e / 8));\n        }\n        if (lit > 0 || rim > 0) {\n          // A lit LED shows its colours at 1.2 times their strength where\n          // one guard sees it, 1.5 where two do and up to 1.8 where many\n          // do, with a little of the guards' light.\n          const l = 1 - Math.pow(0.5, lit), gain = 0.6 + 1.2 * l, v = 0.32 * l + 0.3 * min(1, rim);\n          (r = r * gain + L[0] * v), (g = g * gain + L[1] * v), (b = b * gain + L[2] * v);\n        } else (r *= sh), (g *= sh), (b *= sh);\n      }\n      B[o * 3] = r;\n      B[o * 3 + 1] = g;\n      B[o * 3 + 2] = b;\n    }\n  // Diagonals, each drawn from one end to the other as its ear goes.\n  const dc = hsv(wheel(0.37 + S.hue), 0.15, 0.62, S.dc);\n  for (let k = 0; k \u003c nt - 1; k++) {\n    const u = cl((t - earAt(k) + 0.06) / 0.2, 0, 1);\n    if (u \u003c= 0) continue;\n    const a = P[tris[k][0]], c = P[tris[k][2]];\n    line(B, a[0], a[1], a[0] + (c[0] - a[0]) * u, a[1] + (c[1] - a[1]) * u, dc, 1);\n  }\n  // The outline, drawn round from corner 0 during the first act.\n  const ec = hsv(wheel(0.37 + S.hue), 0.3, 1, S.ec), drawn = (t / T_OUT) * n;\n  for (let i = 0; i \u003c n; i++) {\n    const u = cl(drawn - i, 0, 1);\n    if (u \u003c= 0) break;\n    const a = P[i], b = P[(i + 1) % n];\n    line(B, a[0], a[1], a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, ec, 1);\n  }\n  // Corners: white until coloured, then their colour; the guards' corners\n  // grow a ring once the colouring is done and the others step back.\n  const white = [1, 1, 1];\n  const gOn = ss(A3, A3 + 0.5, t), pulse = 0.75 + 0.25 * Math.sin(t * 6);\n  for (let i = 0; i \u003c n; i++) {\n    if (drawn \u003c i) break;\n    const cs = ss(colAt(step[i]) - 0.05, colAt(step[i]) + 0.15, t), isG = col[i] === rare;\n    const cc = cs > 0 ? C[col[i]] : white, back = isG ? 1 : 1 - 0.5 * gOn;\n    dot(B, P[i][0], P[i][1], 1.3 + 0.6 * cs, cc, back);\n    if (isG && gOn > 0) {\n      const rr = 2.4 + 1.6 * gOn;\n      for (let k = 0; k \u003c 28; k++) {\n        const an = (k / 28) * 2 * PI;\n        plot(B, floor(P[i][0] + rr * Math.cos(an)), floor(P[i][1] + rr * Math.sin(an)), G, gOn * pulse);\n      }\n      dot(B, P[i][0], P[i][1], 1.2, white, gOn);\n    }\n  }\n  const f255 = fade * 255;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, B[o] * f255) | 0, min(255, B[o + 1] * f255) | 0, min(255, B[o + 2] * f255) | 0);\n}\n","binary-lens":"// ===== Patternflow pattern =====\n// Title:   Binary Lens\n// Family:  space\n// Idea:    Two point masses on a tilted circular orbit lens the sky behind them, and the panel is their magnification map in the source plane by inverse ray shooting, dim blue with contours of equal magnification and bright caustic folds that meet in cusps and change, as the pair swings from upright to lying across, from two astroids to one six-cusp loop to a small central caustic with two triangles, while a star drifts over the map and its light curve scrolls along the bottom with a spike at every fold it crosses.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: gravitational lensing by two point masses (Peter Schneider and Alfred Weiss, 1986), inverse ray shooting (Joachim Wambsganss, Peter Schneider and Bohdan Paczynski, 1986), the three caustic topologies of the binary lens (Hans Erdl and Peter Schneider, 1993), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mass ratio=0.2..1, Orbit=15..60\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the map is deep blue where nothing is magnified, violet inside the caustics and nearly white on the folds, with teal contours and a green star and light curve; at 0.25 the map is magenta with green folds, at 0.5 green, at 0.75 teal with blue folds. The wheel runs from green to magenta and skips red, orange and lime, which read maroon, brown and olive when dim.\n// Knob 2: Speed. 2 is real time: the star crosses the map at 1.2 Einstein radii, 34 LEDs, a second, the light curve holds the last 6.4 s, and at the bottom of Orbit the pair goes round in 24 s; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Mass ratio. q = m2 / m1 from 0.2 to 1, the masses adding to 1. At 0.2 the masses are 0.83 and 0.17 and the caustics are lopsided: the loop is a bent triangle, the lighter mass has the smaller astroid in the wide pair, and the topology changes at separations 0.74 and 1.82. At 1 the pair is equal, the caustics are symmetric and the changes come at 0.71 and 2, as Erdl and Schneider found.\n// Knob 4: Orbit. How fast the pair goes round its circle, 15 to 60 degrees a second: once in 24 s at 15, once in 6 s at 60. The circle has radius 2.3 and is tilted 76 degrees, so the separation on the sky runs from 2.3 with the pair upright, two astroids one above the other, to 0.54 lying across, a small central caustic with two triangles above and below; with equal masses the pair spends 34% of its turn wide, 53% in the six-cusp loop and 13% close, swinging fast through the close part. At 15 the opening shows the loop, the close pair at about 2 s and the wide pair from 6 s.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The map: rows 0 to 99, 28 LEDs to the Einstein radius of the total mass,\n// centred on the centre of mass. The light curve fills rows 102 to 127.\nconst MH = 100, PX = 28, MX = 32, MY = 50, CY0 = 102, CH = 26;\n// Rays: an image-plane grid 2 to the LED each way, so a patch with no\n// lensing gets 4 rays per LED. Each ray is split over the four LEDs round\n// where it lands. With a whole number of rays to the LED that split sums\n// to the same on every LED, so the grid leaves no moire where the lensing\n// is weak: a first try that dropped each ray into one cell of a grid twice\n// as fine, at 2.3 rays to the LED, drew dark arcs 5 LEDs apart all over\n// the dim parts. The grid spreads past the map by a margin that holds the\n// images of its edge: a source 1.1 Einstein radii out has its bright image\n// 0.6 further out, and a mass 1.9 out holds images 0.4 beyond itself.\nconst SUB = 2, HX = 1.8, HY = 2.35, STEP = 1 / (PX * SUB);\nconst NX = Math.ceil((2 * HX) / STEP), NY = Math.ceil((2 * HY) / STEP);\n// The counts carry a border one LED wide, so the edge LEDs get their whole\n// share.\nconst PW = W + 2, PH = MH + 2;\n// The orbit: a circle of radius A Einstein radii seen tilted, cos i = CI,\n// with its long axis along the panel's long axis. The projected\n// separation runs from A = 2.3 when the pair stands upright (two astroids\n// one above the other) to A CI = 0.54 when it lies across (the two small\n// triangles then sit above and below the central caustic). Both fit the\n// tall map, 1.8 from the centre to its top: the wide pair's astroids reach\n// 1.7 at q = 0.2 and the close pair's triangles 1.5 at q = 1.\nconst A = 2.3, CI = 0.235;\n// The light curve: one column every 0.1 s, log magnification from 1 to 16.\nconst COL_DT = 0.1, MU_TOP = 16;\n// Contours of the map, a factor 1.12 apart.\nconst CSTEP = log(1.12);\n// The star crosses the map at 1.2 Einstein radii a second. Its\n// magnification is the rays landing on a soft disk 2 LEDs in radius.\nconst VSRC = 1.2, RSRC = 2 / PX;\n// The star's trail on the map: its last 10 places, 1 s.\nconst TRAIL = 10;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel from green through blue and violet to\n// magenta, which skips red, orange and lime: dim, they read maroon, brown\n// and olive.\nconst wheel = (h) => 0.3 + 0.56 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    t: 0, ready: false, drawn: false, phi: 0, q: 0.2, om: 15, hue: 0, half: 0,\n    // Two half-grids of ray counts, one shot each frame, and the star's\n    // count from each.\n    cnt: [new Float32Array(PW * PH), new Float32Array(PW * PH)], star: [1, 1],\n    mu: new Float32Array(W * MH), lm: new Float32Array(W * MH), tmp: new Float32Array(W * MH), c3: [0, 0, 0],\n    lut: new Float32Array(256 * 3),\n    curve: new Float32Array(W), colSum: 0, colN: 0, colT: 0, tx: new Float32Array(TRAIL), ty: new Float32Array(TRAIL),\n    sx: 0, sy: 0, vx: 0, vy: 0,\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// A new crossing: in at a random point of the map's edge, aimed at a\n// point within 0.7 Einstein radii of the centre.\nfunction newTrack(S) {\n  const ex = MX / PX, ey = MY / PX, side = floor(Math.random() * 4);\n  let x, y;\n  if (side \u003c 2) {\n    x = (Math.random() * 2 - 1) * ex;\n    y = side ? ey : -ey;\n  } else {\n    y = (Math.random() * 2 - 1) * ey;\n    x = side === 2 ? ex : -ex;\n  }\n  const ax = (Math.random() * 2 - 1) * 0.7, ay = (Math.random() * 2 - 1) * 0.7;\n  const dx = ax - x, dy = ay - y, l = sqrt(dx * dx + dy * dy);\n  S.sx = x;\n  S.sy = y;\n  S.vx = (dx / l) * VSRC;\n  S.vy = (dy / l) * VSRC;\n}\n\n// The masses: the centre of mass at the origin, m1 + m2 = 1.\nfunction lenses(S) {\n  const m1 = 1 / (1 + S.q), m2 = S.q / (1 + S.q), dx = A * CI * sin(S.phi), dy = A * cos(S.phi);\n  return { m1, m2, x1: -dx * m2, y1: -dy * m2, x2: dx * m1, y2: dy * m1 };\n}\n\n// Shoot every stride-th row of the ray grid starting at row off, through\n// the lens equation zeta = z - sum m_i / conj(z - z_i), which in real\n// numbers is zeta = z - sum m_i (z - z_i) / |z - z_i|^2. Each ray is split\n// over four LEDs of cnt (if given) and adds a weight (1 - r^2 / R^2)^2 to\n// the star if it lands within R of it; the return value is the star's\n// magnification.\nfunction shoot(S, L, cnt, off, stride) {\n  const { m1, m2, x1, y1, x2, y2 } = L, sx = S.sx, sy = S.sy, r2 = RSRC * RSRC, ir2 = 1 / r2;\n  const ox = MX + 0.5, oy = MY + 0.5;\n  let star = 0;\n  for (let j = off; j \u003c NY; j += stride) {\n    const y = -HY + (j + 0.5) * STEP, dy1 = y - y1, dy2 = y - y2, e1 = dy1 * dy1, e2 = dy2 * dy2;\n    let x = -HX + 0.5 * STEP;\n    for (let i = 0; i \u003c NX; i++, x += STEP) {\n      const dx1 = x - x1, dx2 = x - x2;\n      const k1 = m1 / (dx1 * dx1 + e1), k2 = m2 / (dx2 * dx2 + e2);\n      const zx = x - k1 * dx1 - k2 * dx2, zy = y - k1 * dy1 - k2 * dy2;\n      const ux = zx - sx, uy = zy - sy, u2 = ux * ux + uy * uy;\n      if (u2 \u003c r2) {\n        const w = 1 - u2 * ir2;\n        star += w * w;\n      }\n      if (!cnt) continue;\n      const px = zx * PX + ox, py = zy * PX + oy;\n      // Written this way round so a ray that hits a mass dead on (NaN) is\n      // dropped too.\n      if (!(px >= 0 && py >= 0 && px \u003c PW - 1 && py \u003c PH - 1)) continue;\n      const ix = px | 0, iy = py | 0, fx = px - ix, fy = py - iy, o = iy * PW + ix, gx = 1 - fx;\n      cnt[o] += gx * (1 - fy);\n      cnt[o + 1] += fx * (1 - fy);\n      cnt[o + PW] += gx * fy;\n      cnt[o + PW + 1] += fx * fy;\n    }\n  }\n  // Rays per unit area of the image plane, for the rows shot, against the\n  // soft disk's area pi R^2 / 3.\n  return star / ((PI * r2) / 3 / (STEP * STEP * stride));\n}\n\n// A box 5 LEDs wide, across and then down, in place.\nfunction blur(a, t) {\n  for (let y = 0; y \u003c MH; y++) {\n    const r = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0, n = 0;\n      for (let k = max(0, x - 2); k \u003c= min(W - 1, x + 2); k++, n++) s += a[r + k];\n      t[r + x] = s / n;\n    }\n  }\n  for (let x = 0; x \u003c W; x++)\n    for (let y = 0; y \u003c MH; y++) {\n      let s = 0, n = 0;\n      for (let k = max(0, y - 2); k \u003c= min(MH - 1, y + 2); k++, n++) s += t[k * W + x];\n      a[y * W + x] = s / n;\n    }\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  // A circular orbit keeps an even pace in its own plane; seen tilted, the\n  // pair swings fast across the panel when close and slowly when upright.\n  S.phi += ((S.om * PI) / 180) * dt;\n  S.sx += S.vx * dt;\n  S.sy += S.vy * dt;\n  if (abs(S.sx) > MX / PX + 0.1 || abs(S.sy) > MY / PX + 0.1) newTrack(S);\n}\n\nfunction pushColumn(S, mu) {\n  S.curve.copyWithin(0, 1);\n  S.curve[W - 1] = mu;\n  S.tx.copyWithin(0, 1);\n  S.ty.copyWithin(0, 1);\n  S.tx[TRAIL - 1] = S.sx;\n  S.ty[TRAIL - 1] = S.sy;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.2, 15], dd = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.q = cl(kv[2], 0.2, 1);\n  S.om = cl(kv[3], 15, 60);\n  if (!S.ready) {\n    // The first frame runs the 6.4 s the light curve holds, with every\n    // fourth row of the grid and only the star's count.\n    S.ready = true;\n    S.t = -W * COL_DT;\n    // At t = 0 the orbit is 60 degrees on from upright, so the opening\n    // seconds go from the six-cusp loop to the close pair lying across, at\n    // 2 s with the Orbit knob at the bottom, and back out.\n    S.phi = ((60 - S.om * W * COL_DT) * PI) / 180;\n    newTrack(S);\n    for (let k = 0; k \u003c W; k++) {\n      step(S, COL_DT);\n      pushColumn(S, shoot(S, lenses(S), null, k % 4, 4));\n    }\n  }\n  const h = (dd * speed) / 2;\n  step(S, h);\n  S.colT += h;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const L = lenses(S), rgb = S.rgb, hue = S.hue;\n  // This frame's half of the grid; the other half is the last frame's.\n  for (let k = 0; k \u003c (S.drawn ? 1 : 2); k++) {\n    const f = S.cnt[S.half];\n    f.fill(0);\n    S.star[S.half] = shoot(S, L, f, S.half, 2);\n    S.half ^= 1;\n  }\n  S.drawn = true;\n  const muStar = (S.star[0] + S.star[1]) / 2;\n  S.colSum += muStar;\n  S.colN++;\n  while (S.colT >= COL_DT) {\n    pushColumn(S, S.colSum / S.colN);\n    S.colT -= COL_DT;\n    S.colSum = muStar;\n    S.colN = 1;\n  }\n  // Magnification: rays per LED over the rays per LED with no lens.\n  const c0 = S.cnt[0], c1 = S.cnt[1], mu = S.mu, norm = 1 / (SUB * SUB);\n  for (let y = 0; y \u003c MH; y++)\n    for (let x = 0, o = (y + 1) * PW + 1; x \u003c W; x++, o++) mu[y * W + x] = (c0[o] + c1[o]) * norm;\n  // Colours by log magnification: deep blue at 1, violet inside the\n  // caustics where there are five images and the magnification is 3 or\n  // more, nearly white on the folds.\n  const lut = S.lut;\n  for (let i = 0; i \u003c 256; i++) {\n    const l = i / 255;\n    hsv(wheel(0.56 + hue + 0.3 * l), 0.9 - 0.7 * l * l, 0.13 + 0.87 * l ** 0.8, lut, i * 3);\n  }\n  const kl = 255 / log(MU_TOP), lm = S.lm;\n  for (let p = 0; p \u003c W * MH; p++) {\n    const m = mu[p], i = m > 1 ? min(255, (log(m) * kl) | 0) : 0, o = p * 3, q = i * 3;\n    lm[p] = log(max(m, 0.05)) / CSTEP;\n    rgb[o] = lut[q];\n    rgb[o + 1] = lut[q + 1];\n    rgb[o + 2] = lut[q + 2];\n  }\n  // Contours of equal magnification outside the caustics, every 12%, so the\n  // dim part of the map shows its slope: wide loops round the pair far out,\n  // closing in and bending where the caustics pull them.\n  // The contours are read from the map smoothed twice by a box 5 LEDs\n  // wide: raw, the few rays to an LED make them speckle.\n  blur(lm, S.tmp);\n  blur(lm, S.tmp);\n  const cc = hsv(wheel(0.4 + hue), 0.6, 1, S.c3, 0), top = log(2.6) / CSTEP;\n  for (let y = 1; y \u003c MH - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, f = lm[p];\n      if (f > top || f \u003c 0.7) continue;\n      const gx = (lm[p + 1] - lm[p - 1]) / 2, gy = (lm[p + W] - lm[p - W]) / 2, g = sqrt(gx * gx + gy * gy);\n      if (g \u003c 1e-3) continue;\n      const e = abs(f - Math.round(f)) / g, v = 1 - e / 0.7;\n      if (v \u003c= 0) continue;\n      const k = v * 0.2 * min(1, (top - f) / 1.5), o = p * 3;\n      rgb[o] += cc[0] * k;\n      rgb[o + 1] += cc[1] * k;\n      rgb[o + 2] += cc[2] * k;\n    }\n  rgb.fill(0, W * MH * 3);\n  const add = (x, y, c, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || v \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += c[0] * v;\n    rgb[o + 1] += c[1] * v;\n    rgb[o + 2] += c[2] * v;\n  };\n  const dot = (cx, cy, rad, c, pk) => {\n    for (let y = floor(cy - rad); y \u003c= cy + rad; y++)\n      for (let x = floor(cx - rad); x \u003c= cx + rad; x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, q = (dx * dx + dy * dy) / (rad * rad);\n        if (q \u003c 1 && y \u003c MH) add(x, y, c, pk * (1 - q) * (1 - q));\n      }\n  };\n  // The two masses, small and grey, the heavier one larger.\n  const g = [0.7, 0.7, 0.7];\n  dot(L.x1 * PX + MX, L.y1 * PX + MY, 1.2 + 0.8 * L.m1, g, 0.45);\n  dot(L.x2 * PX + MX, L.y2 * PX + MY, 1.2 + 0.8 * L.m2, g, 0.45);\n  // The star and its trail.\n  const sc = hsv(wheel(0.18 + hue), 0.55, 1, S.c, 0);\n  for (let k = 1; k \u003c TRAIL; k++) {\n    const ax = S.tx[k - 1], ay = S.ty[k - 1], bx = k \u003c TRAIL - 1 ? S.tx[k] : S.sx, by = k \u003c TRAIL - 1 ? S.ty[k] : S.sy;\n    if ((bx - ax) ** 2 + (by - ay) ** 2 > 0.09) continue;\n    for (let s = 0; s \u003c 4; s++) {\n      const f = s / 4, x = (ax + (bx - ax) * f) * PX + MX, y = (ay + (by - ay) * f) * PX + MY;\n      dot(x, y, 1.2, sc, 0.22 * (k / TRAIL) ** 2);\n    }\n  }\n  dot(S.sx * PX + MX, S.sy * PX + MY, 2.4, sc, 1.6);\n  // The light curve: log magnification, a filled column per 0.1 s, the\n  // newest on the right.\n  const lt = log(MU_TOP);\n  for (let x = 0; x \u003c W; x++) {\n    const v = cl(log(max(1, S.curve[x])) / lt, 0, 1) * (CH - 1) + 1;\n    for (let r = 0; r \u003c CH; r++) {\n      const cover = cl(v - r, 0, 1);\n      if (cover \u003c= 0) break;\n      const top = v - r \u003c 1.5;\n      add(x, CY0 + CH - 1 - r, sc, cover * (top ? 0.95 : 0.16 + 0.22 * (r / CH)));\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const pk = max(1, rgb[o], rgb[o + 1], rgb[o + 2]), k = 255 / pk;\n    display.setPixel(p % W, (p / W) | 0, (rgb[o] * k) | 0, (rgb[o + 1] * k) | 0, (rgb[o + 2] * k) | 0);\n  }\n}\n","canard-explosion":"// ===== Patternflow pattern =====\n// Title:   Canard Explosion\n// Family:  rhythm\n// Idea:    The van der Pol oscillator walks through its family of limit cycles from a tiny Hopf cycle round the fold of the cubic, through ducks that ride the repelling middle branch further and further before jumping back, to ducks with a head and the full relaxation loop, each cycle left in the phase plane as a fading band so the family stands as nested loops, while x(t) runs down the lower panel and turns from small ripples into wide square spikes.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: relaxation oscillations (Balthasar van der Pol, 1926), the Lienard plane (Alfred-Marie Lienard, 1928), canard cycles and the canard explosion (Eric Benoit, Jean-Louis Callot, Francine Diener and Marc Diener, 1981), the explosion by geometric singular perturbation (Martin Krupa and Peter Szmolyan, 2001), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Epsilon=0.04..0.2, Pace=0.6..3\n//\n// Knob 1: Hue. Turns the family's colours round the wheel. At 0 the smallest cycles are teal, the ducks azure to violet and the relaxation loop magenta, over attracting branches drawn green and a dashed repelling branch drawn rose; at 0.5 the family runs from violet through red to lime and cyan. The wheel skips orange, which reads brown when dim.\n// Knob 2: Speed. At 2 the oscillator runs 2.5 units of its slow time a second: a Hopf cycle goes round in 0.5 s, the relaxation loop in 1.6 s and the longest duck in 2 s, and the trace below moves 15 rows a second. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Epsilon. The ratio of the fast time to the slow, 0.04 to 0.2, in eps x' = y - (x^3 / 3 - x), y' = a - x. At 0.04 the ducks are sharp: every cycle from the duck that turns back at x = 0 to the one whose head reaches x = -1.47 lies in an interval of a 1.8e-11 wide at a = 0.9948377923, the jumps are flat and the corners square. At 0.1 the same stretch of the family is 1.3e-4 wide and the loops round off; at 0.2 it is 0.023 wide, the ducks are fat and the relaxation loop reaches only x = -1.52. The family is found again by bisection a quarter second after the knob stops, 5 to 20 ms of work.\n// Knob 4: Pace. How fast the walk goes through the family of 18 cycles (17 at eps = 0.2), 0.6 to 3 cycles a second at Speed 2, out and back with a pause at each end. The parameter a changes only as the point crosses x = a going right, so each cycle is run whole. A ghost fades by e in 4 seconds. At 0.6 a duck runs one or two loops before the next takes over and five or six earlier cycles still show; at 3 the walk moves on several cycles each loop and goes from the Hopf cycle to the relaxation loop in 6 seconds.\n\nconst W = 64, H = 128, PH = 76, T0 = 79, TH = H - T0;\n// The phase plane: x from -XR to XR across, y from YT at the top to -YT.\n// Both are fitted to the family of each eps: the loops overshoot the folds\n// before they jump, up to y = 1.02 at eps = 0.04 and 1.57 at 0.2, so the\n// plane runs to 1.08 and 1.66. use(S) sets them from the state before any\n// drawing.\nlet XR = 2.2, YT = 1.1;\nconst use = (S) => {\n  XR = S.xr;\n  YT = S.yt;\n};\nconst PX = (x) => ((x + XR) * W) / (2 * XR), PY = (y) => ((YT - y) * PH) / (2 * YT);\nconst { floor, ceil, min, max, abs, exp, sqrt, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Slow time a second at Speed 2 is 2 x RATE; trace rows per unit of slow time.\nconst RATE = 1.25, TR = 6;\n// Every bisection starts here on the right attracting branch. From x = 1.95\n// the branch pulls the point onto the slow manifold by e^(-2.75 / eps)\n// before the fold, below rounding error at eps = 0.04, so the canard that\n// follows depends on a alone.\nconst X0 = 1.95;\nconst HOLD = 1.5, GHOST = 4;\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// One RK4 step of eps x' = y - (x^3/3 - x), y' = a - x. The live point and\n// the bisection use this same step at the same h, so the cycle the\n// bisection found is the cycle the point settles on.\nlet RX = 0, RY = 0;\nfunction rk4(x, y, a, ie, h) {\n  const k1x = (y - x * (x * x / 3 - 1)) * ie, k1y = a - x;\n  let xx = x + 0.5 * h * k1x, yy = y + 0.5 * h * k1y;\n  const k2x = (yy - xx * (xx * xx / 3 - 1)) * ie, k2y = a - xx;\n  xx = x + 0.5 * h * k2x;\n  yy = y + 0.5 * h * k2y;\n  const k3x = (yy - xx * (xx * xx / 3 - 1)) * ie, k3y = a - xx;\n  xx = x + h * k3x;\n  yy = y + h * k3y;\n  const k4x = (yy - xx * (xx * xx / 3 - 1)) * ie, k4y = a - xx;\n  RX = x + (h / 6) * (k1x + 2 * k2x + 2 * k3x + k4x);\n  RY = y + (h / 6) * (k1y + 2 * k2y + 2 * k3y + k4y);\n}\n\n// How far left the cycle reaches, from one pass: down the right branch,\n// round the fold, along the middle branch and off. x_min runs from near 1\n// for the smallest cycles through -1 at the maximal canard to about -1.9\n// for the relaxation loop, so it orders the whole family.\nfunction firstPass(a, ie, h) {\n  let x = X0, y = X0 * (X0 * X0 / 3 - 1), xmin = 9, below = false;\n  const M = ceil(14 / h);\n  for (let i = 0; i \u003c M; i++) {\n    rk4(x, y, a, ie, h);\n    const px = x;\n    x = RX;\n    y = RY;\n    if (x \u003c xmin) xmin = x;\n    if (x \u003c a) below = true;\n    else if (below && px \u003c a) return xmin;\n  }\n  return xmin;\n}\n\n// Run until the loops agree, then keep one loop, crossing to crossing of\n// x = a going right.\nfunction settle(a, ie, h, most) {\n  let x = X0, y = X0 * (X0 * X0 / 3 - 1), xmin = 9, prev = 9, below = false, loops = 0, rec = null, n = 0;\n  const M = ceil(400 / h);\n  for (let i = 0; i \u003c M; i++) {\n    rk4(x, y, a, ie, h);\n    const px = x;\n    x = RX;\n    y = RY;\n    if (rec) {\n      if (n \u003c rec.length / 2) {\n        rec[2 * n] = x;\n        rec[2 * n + 1] = y;\n        n++;\n      }\n    }\n    if (x \u003c xmin) xmin = x;\n    if (x \u003c a) below = true;\n    else if (below && px \u003c a) {\n      if (rec) return { a, pts: rec, n, xmin, period: n * h };\n      loops++;\n      if ((loops >= 2 && abs(xmin - prev) \u003c 3e-4) || loops >= most) rec = new Float32Array(2 * ceil(12 / h));\n      prev = xmin;\n      xmin = 9;\n      below = false;\n    }\n  }\n  return { a, pts: rec || new Float32Array(2), n, xmin: prev, period: n * h };\n}\n\n// Max-blend an antialiased segment into a PH-row raster.\nfunction seg(buf, x0, y0, x1, y1, v, rows) {\n  const n = max(1, ceil(max(abs(x1 - x0), abs(y1 - y0)) * 2));\n  for (let s = 0; s \u003c= n; s++) {\n    const f = s / n, x = x0 + (x1 - x0) * f - 0.5, y = y0 + (y1 - y0) * f - 0.5;\n    const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n    for (let k = 0; k \u003c 4; k++) {\n      const xx = xi + (k & 1), yy = yi + (k >> 1);\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= rows) continue;\n      const w = v * ((k & 1) ? fx : 1 - fx) * ((k >> 1) ? fy : 1 - fy) * 1.6;\n      const o = yy * W + xx;\n      if (w > buf[o]) buf[o] = min(1, w);\n    }\n  }\n}\n\nfunction rasterize(m) {\n  const stroke = new Float32Array(W * PH), inside = new Uint8Array(W * PH), xs = [];\n  for (let r = 0; r \u003c PH; r++) xs.push([]);\n  const P = m.pts, n = m.n;\n  for (let i = 0; i \u003c n; i++) {\n    const j = (i + 1) % n, x0 = PX(P[2 * i]), y0 = PY(P[2 * i + 1]), x1 = PX(P[2 * j]), y1 = PY(P[2 * j + 1]);\n    seg(stroke, x0, y0, x1, y1, 1, PH);\n    // Scanline crossings at row centres, for the even-odd fill.\n    const lo = min(y0, y1), hi = max(y0, y1);\n    for (let r = ceil(lo - 0.5); r + 0.5 \u003c hi; r++) {\n      if (r \u003c 0 || r >= PH) continue;\n      const yc = r + 0.5;\n      if (yc \u003c lo || yc >= hi) continue;\n      xs[r].push(x0 + ((x1 - x0) * (yc - y0)) / (y1 - y0));\n    }\n  }\n  for (let r = 0; r \u003c PH; r++) {\n    const c = xs[r].sort((p, q) => p - q);\n    for (let k = 0; k + 1 \u003c c.length; k += 2)\n      for (let x = max(0, ceil(c[k] - 0.5)); x \u003c W && x + 0.5 \u003c c[k + 1]; x++) inside[r * W + x] = 1;\n  }\n  m.stroke = stroke;\n  m.inside = inside;\n}\n\n// The family for one eps: three Hopf cycles at a = 1 - f dc, where dc =\n// eps / 8 + 3 eps^2 / 32 is the canard point to second order; fourteen\n// ducks found by bisection on x_min, nine headless and five with a head;\n// and the relaxation loop at a = 1 - 3 dc.\nfunction family(S, eps) {\n  const h = eps / 8, ie = 1 / eps, dc = eps / 8 + (3 * eps * eps) / 32;\n  const samples = [];\n  const meas = (a) => {\n    const v = firstPass(a, ie, h);\n    samples.push(a, v);\n    return v;\n  };\n  const aLo = 1 - 3 * dc, aHi = 1 - 0.5 * dc;\n  const xR = meas(aLo), xH = meas(aHi);\n  const as = [1 - 0.15 * dc, 1 - 0.4 * dc, 1 - 0.65 * dc];\n  const targets = [0.55, 0.38, 0.2, 0, -0.2, -0.4, -0.6, -0.78, -0.92];\n  for (let j = 1; j \u003c= 5; j++) targets.push(-1 + ((xR + 1) * j) / 5.6);\n  for (const T of targets) {\n    if (!(T \u003c xH && T > xR)) continue;\n    // The tightest bracket any earlier bisection left.\n    let lo = aLo, hi = aHi;\n    for (let i = 0; i \u003c samples.length; i += 2) {\n      const a = samples[i], v = samples[i + 1];\n      if (v \u003c T && a > lo) lo = a;\n      if (v >= T && a \u003c hi) hi = a;\n    }\n    for (let it = 0; it \u003c 64; it++) {\n      const mid = 0.5 * (lo + hi);\n      if (mid \u003c= lo || mid >= hi) break;\n      const v = meas(mid);\n      if (v \u003c T) lo = mid;\n      else hi = mid;\n      if (abs(v - T) \u003c 0.004) {\n        hi = mid;\n        break;\n      }\n    }\n    as.push(hi);\n  }\n  as.push(aLo);\n  const fam = [];\n  let ex = 0, ey = 0;\n  for (let i = 0; i \u003c as.length; i++) {\n    const m = settle(as[i], ie, h, i \u003c 3 ? 80 : 4);\n    if (m.n \u003c 8) continue;\n    m.hopf = i \u003c 3;\n    for (let j = 0; j \u003c 2 * m.n; j += 2) {\n      ex = max(ex, abs(m.pts[j]));\n      ey = max(ey, abs(m.pts[j + 1]));\n    }\n    fam.push(m);\n  }\n  S.xr = max(2.2, 1.03 * ex);\n  S.yt = 1.06 * ey;\n  use(S);\n  for (const m of fam) rasterize(m);\n  cubicRasters(S);\n  fam.sort((p, q) => q.xmin - p.xmin);\n  // Each pixel takes the smallest cycle round it, so nested cycles leave\n  // nested bands.\n  const band = new Int8Array(W * PH).fill(-1);\n  for (let k = fam.length - 1; k >= 0; k--) for (let p = 0; p \u003c W * PH; p++) if (fam[k].inside[p]) band[p] = k;\n  S.eps = eps;\n  S.h = h;\n  S.fam = fam;\n  S.band = band;\n  S.ghost = new Float32Array(fam.length);\n  S.kc = cl(S.kc, 0, fam.length - 1);\n  S.x = fam[S.kc].pts[0];\n  S.y = fam[S.kc].pts[1];\n}\n\nfunction cubicRasters(S) {\n  // The critical manifold y = x^3/3 - x: outer branches attract, the\n  // middle one repels.\n  const att = new Float32Array(W * PH), rep = new Float32Array(W * PH), side = new Uint8Array(W * PH);\n  const f = (x) => x * (x * x / 3 - 1);\n  for (let i = 0; i \u003c 400; i++) {\n    const x0 = -XR + (2 * XR * i) / 400, x1 = -XR + (2 * XR * (i + 1)) / 400;\n    const mid = abs(0.5 * (x0 + x1)) \u003c 1;\n    // The repelling branch is dashed.\n    if (mid && floor(i / 6) % 2) continue;\n    seg(mid ? rep : att, PX(x0), PY(f(x0)), PX(x1), PY(f(x1)), 1, PH);\n  }\n  for (let r = 0; r \u003c PH; r++)\n    for (let c = 0; c \u003c W; c++) {\n      const x = ((c + 0.5) * 2 * XR) / W - XR, y = YT - ((r + 0.5) * 2 * YT) / PH;\n      side[r * W + c] = y > f(x) ? 1 : 0;\n    }\n  S.att = att;\n  S.rep = rep;\n  S.side = side;\n}\n\nexport function setup(params) {\n  params.s = {\n    eps: 0, h: 0, fam: [], band: null, ghost: null, kc: 0, walk: 0, dir: 1,\n    x: X0, y: X0 * (X0 * X0 / 3 - 1), acc: 0, rowT: 0, cmin: 9, cmax: -9,\n    tmin: new Float32Array(TH).fill(NaN), tmax: new Float32Array(TH), tk: new Int8Array(TH), ta: new Float32Array(TH), head: 0,\n    tail: new Float32Array(512), ti: 0, tn: 0,\n    xr: 2.2, yt: 1.1, wantEps: 0, still: 0, hue: 0, tl: new Float32Array(W * PH), rgb: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],\n  };\n}\n\nfunction pushRow(S) {\n  S.head = (S.head + TH - 1) % TH;\n  S.tmin[S.head] = S.cmin;\n  S.tmax[S.head] = S.cmax;\n  S.tk[S.head] = S.kc;\n  S.ta[S.head] = S.fam[S.kc].a;\n  S.cmin = S.cmax = S.x;\n}\n\nfunction sim(S, d, speed, pace) {\n  const N = S.fam.length;\n  S.walk += S.dir * pace * d * speed * 0.5;\n  if (S.walk > N - 1 + HOLD) {\n    S.walk = N - 1 + HOLD;\n    S.dir = -1;\n  } else if (S.walk \u003c -HOLD) {\n    S.walk = -HOLD;\n    S.dir = 1;\n  }\n  const fade = exp(-(d * speed * 0.5) / GHOST);\n  for (let k = 0; k \u003c N; k++) S.ghost[k] *= fade;\n  const h = S.h, ie = 1 / S.eps;\n  S.acc += d * speed * RATE;\n  let a = S.fam[S.kc].a;\n  while (S.acc >= h) {\n    S.acc -= h;\n    const px = S.x;\n    rk4(S.x, S.y, a, ie, h);\n    S.x = RX;\n    S.y = RY;\n    if (px \u003c a && S.x >= a && S.y > a * (a * a / 3 - 1)) {\n      // A loop is done: the next cycle of the walk takes over here.\n      const was = S.fam[S.kc];\n      S.kc = cl(round(S.walk), 0, N - 1);\n      const m = S.fam[S.kc];\n      a = m.a;\n      // Out of a Hopf cycle the point sits by the weakly unstable focus and\n      // would take a dozen loops to spiral out to a duck, so it is set on\n      // the new cycle where that cycle crosses x = a.\n      if (was.hopf && !m.hopf) {\n        S.x = m.pts[0];\n        S.y = m.pts[1];\n      }\n    }\n    S.ghost[S.kc] = 1;\n    S.tail[S.ti] = S.x;\n    S.tail[S.ti + 1] = S.y;\n    S.ti = (S.ti + 2) % S.tail.length;\n    S.tn = min(S.tn + 1, S.tail.length / 2);\n    if (S.x \u003c S.cmin) S.cmin = S.x;\n    if (S.x > S.cmax) S.cmax = S.x;\n    S.rowT += h * TR;\n    if (S.rowT >= 1) {\n      S.rowT -= 1;\n      pushRow(S);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.04, 0.6], d = cl(dt || 0, 0, 0.1);\n  use(S);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), eps = cl(kv[2], 0.04, 0.2), pace = cl(kv[3], 0.6, 3);\n  if (!S.fam.length) {\n    family(S, eps);\n    // Open going up the walk at the duck that turns back near x = -0.5,\n    // with up to eight seconds already run to get there, so the ghosts and\n    // the trace are there from the first frame. At the opening Pace the\n    // first duck with a head comes 6 seconds in.\n    const N = S.fam.length, at = 0.5 * (N - 1), pre = min(8, (at + HOLD) / pace);\n    S.walk = at - pace * pre;\n    S.kc = cl(round(S.walk), 0, N - 1);\n    const m = S.fam[S.kc];\n    S.x = m.pts[0];\n    S.y = m.pts[1];\n    S.cmin = S.cmax = S.x;\n    for (let i = 0; i \u003c round(pre * 30); i++) sim(S, 1 / 30, 2, pace);\n    S.wantEps = eps;\n    return;\n  }\n  // A new eps is taken once the knob has rested for a quarter second.\n  if (abs(eps - S.wantEps) > 1e-6) {\n    S.wantEps = eps;\n    S.still = 0;\n  } else S.still += d;\n  if (abs(S.wantEps - S.eps) > 1e-6 && S.still > 0.25) family(S, S.wantEps);\n  sim(S, d, speed, pace);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.fam.length) return;\n  use(S);\n  const rgb = S.rgb, fam = S.fam, N = fam.length, c = S.c, c2 = S.c2, hue = S.hue;\n  rgb.fill(0);\n  const add = (o, col, v) => {\n    rgb[o] += col[0] * v;\n    rgb[o + 1] += col[1] * v;\n    rgb[o + 2] += col[2] * v;\n  };\n  const colOf = (k, s, v, out) => hsv(wheel(0.22 + (0.58 * k) / max(1, N - 1) + hue), s, v, out);\n  // The two sides of the cubic: above it the fast flow runs right, below it left.\n  const up = hsv(wheel(0.25 + hue), 0.45, 0.1, [0, 0, 0]), dn = hsv(wheel(0.62 + hue), 0.45, 0.1, [0, 0, 0]);\n  const cols = [];\n  for (let k = 0; k \u003c N; k++) cols.push(colOf(k, 0.75, 1, [0, 0, 0]));\n  for (let p = 0; p \u003c W * PH; p++) {\n    const o = p * 3;\n    add(o, S.side[p] ? up : dn, 1);\n    const b = S.band[p];\n    if (b >= 0) add(o, cols[b], 0.42 * S.ghost[b]);\n  }\n  // Ghost outlines.\n  for (let k = 0; k \u003c N; k++) {\n    const g = S.ghost[k];\n    if (g \u003c 0.02 || k === S.kc) continue;\n    const st = fam[k].stroke, col = cols[k];\n    for (let p = 0; p \u003c W * PH; p++) if (st[p] > 0) add(p * 3, col, st[p] * g * 0.6);\n  }\n  const att = hsv(wheel(0.07 + hue), 0.6, 0.42, [0, 0, 0]), rep = hsv(wheel(0.97 + hue), 0.6, 0.5, [0, 0, 0]);\n  for (let p = 0; p \u003c W * PH; p++) {\n    if (S.att[p] > 0) add(p * 3, att, S.att[p]);\n    if (S.rep[p] > 0) add(p * 3, rep, S.rep[p]);\n  }\n  // The cycle being run.\n  colOf(S.kc, 0.35, 1, c);\n  const st = fam[S.kc].stroke;\n  for (let p = 0; p \u003c W * PH; p++) if (st[p] > 0) add(p * 3, c, st[p] * 0.75);\n  // The equilibrium at (a, f(a)), the centre the Hopf cycle grew from.\n  const a = fam[S.kc].a, ex = PX(a), ey = PY(a * (a * a / 3 - 1));\n  for (const [dx, dy, v] of [[0, 0, 0.7], [1, 0, 0.3], [-1, 0, 0.3], [0, 1, 0.3], [0, -1, 0.3]]) {\n    const xx = floor(ex) + dx, yy = floor(ey) + dy;\n    if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c PH) add((yy * W + xx) * 3, rep, v * 2);\n  }\n  // The point and its last 0.3 units of slow time.\n  const tl = S.tl.fill(0), L = min(S.tn - 1, ceil(0.3 / S.h)), TL = S.tail.length;\n  for (let i = 0; i \u003c L; i++) {\n    const j0 = (S.ti - 2 * (i + 1) + 2 * TL) % TL, j1 = (S.ti - 2 * (i + 2) + 2 * TL) % TL;\n    seg(tl, PX(S.tail[j0]), PY(S.tail[j0 + 1]), PX(S.tail[j1]), PY(S.tail[j1 + 1]), 1 - i / L, PH);\n  }\n  for (let p = 0; p \u003c W * PH; p++) if (tl[p] > 0) add(p * 3, c, tl[p] * 0.9);\n  const qx = PX(S.x), qy = PY(S.y);\n  for (let yy = floor(qy - 3); yy \u003c= qy + 3; yy++)\n    for (let xx = floor(qx - 3); xx \u003c= qx + 3; xx++) {\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= PH) continue;\n      const dx = xx + 0.5 - qx, dy = yy + 0.5 - qy, r2 = dx * dx + dy * dy;\n      add((yy * W + xx) * 3, [1, 1, 1], 1.6 * exp(-r2 / 2.2));\n    }\n  // The axis between: ticks at x = -2, -1, 0, 1, 2 and a mark at x = a.\n  const ax = hsv(wheel(0.5 + hue), 0.2, 1, c2);\n  for (let x = 0; x \u003c W; x++) add(((PH + 1) * W + x) * 3, ax, 0.12);\n  for (let t = -2; t \u003c= 2; t++) {\n    const xx = floor(PX(t));\n    for (let yy = PH; yy \u003c= PH + 2; yy++) if (xx >= 0 && xx \u003c W) add((yy * W + xx) * 3, ax, 0.35);\n  }\n  for (let yy = PH; yy \u003c= PH + 2; yy++) add((yy * W + cl(floor(ex), 0, W - 1)) * 3, rep, 0.8);\n  // x(t) running down, newest row on top, filled from the equilibrium\n  // x = a out to the trace.\n  for (let r = 0; r \u003c TH; r++) {\n    const i = (S.head + r) % TH, lo = S.tmin[i], hi = S.tmax[i];\n    if (lo !== lo) continue;\n    const k = S.tk[i], col = cols[min(k, N - 1)], e = PX(S.ta[i]), x0 = PX(lo), x1 = PX(hi), y = T0 + r;\n    const age = 1 - (0.55 * r) / TH;\n    // A faint rule across the trace where the next cycle of the family took over.\n    const j = (i + 1) % TH;\n    if (r \u003c TH - 1 && S.tmin[j] === S.tmin[j] && S.tk[j] !== k) for (let x = 0; x \u003c W; x++) add((y * W + x) * 3, col, 0.13 * age);\n    const fl = min(e, x0), fr = max(e, x1);\n    for (let x = max(0, floor(fl)); x \u003c W && x \u003c fr; x++) {\n      const cx = x + 0.5;\n      // Coverage of the pixel by the bright stroke [x0 - 0.5, x1 + 0.5].\n      const sc = cl(min(cx + 0.5, x1 + 1) - max(cx - 0.5, x0 - 1), 0, 1);\n      const fc = cl(min(cx + 0.5, fr) - max(cx - 0.5, fl), 0, 1);\n      // The fill brightens from the equilibrium out to the trace.\n      const q = abs(cx - e) / max(1, abs((cx \u003c e ? x0 : x1) - e));\n      add((y * W + x) * 3, col, age * ((0.2 + 0.36 * min(1, q)) * fc + 0.9 * sc));\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","crackling-noise":"// ===== Patternflow pattern =====\n// Title:   Crackling Noise\n// Family:  noise\n// Idea:    A random-field Ising magnet at zero temperature is swept from all down to all up, one avalanche at a time, and each avalanche of flipped spins crawls out across the dark panel in its own colour, the colour drifting along the sweep, until the panel is a patchwork of clusters of every size; then the field is swept back down, the avalanches go dim in another patchwork, and a new disorder is dealt.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Barkhausen noise (Heinrich Barkhausen, 1919), hysteresis and avalanches in the zero-temperature random-field Ising model (James Sethna, Karin Dahmen, Sivan Kartha, James Krumhansl, Bruce Roberts and Joel Shore, 1993), crackling noise (James Sethna, Karin Dahmen and Christopher Myers, 2001), the critical disorder of the two-dimensional model (Djordje Spasojevic, Sanja Janicevic and Milan Knezevic, 2011), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Disorder=1.05..2.6, Grain=0..1.6\n//\n// Knob 1: Hue. Turns the whole sweep round the wheel. At 0 the first avalanches are teal and the colour drifts through blue and violet to pink by the last; at 0.5 it starts magenta, reaches red a quarter of the way through and goes on from green to cyan. The dim colours of the way back skip orange, which reads brown.\n// Knob 2: Speed. At 2 the panel flips 474 spins a second, so an avalanche of 1000 spins takes 2.1 seconds to crawl out and a whole sweep up takes 17 seconds (the first opens 30% done and ends at 12); 0.2 is ten times slower, 3 half as fast again. The way down runs twice as fast, and the holds of 1.5 s at the top and 1 s at the bottom scale with the knob.\n// Knob 3: Disorder. R, the width of the Gaussian random field against a coupling of 1 to each of 4 neighbours. At 0.85 and below one avalanche snaps nine tenths of the 64 x 128 panel (the critical width on an endless lattice is 0.54), so the range starts above it. At 1.05 a sweep is about 130 avalanches, the biggest 1000 to 2000 spins and 16 of 100 or more; at 1.6 about 830 with the biggest near 170; at 2.6 about 2400, four in ten of them a lone spin and none over 50.\n// Knob 4: Grain. The correlation length of the field: white noise blurred by a Gaussian of 0 to 1.6 LEDs and scaled back to width R. Below 0.25 the field is uncorrelated, the classic model, and the clusters have ragged edges; at 0.8 they are rounded blobs and there are 2.5 times as many; at 1.6 the field is smooth enough that a flat edge of flipped spins holds still, so the avalanches grow as rectangles nested inside each other.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, abs, sqrt, log, exp, cos, ceil, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Spins flipped per second at Speed 2, and the share of the first sweep\n// already done when the pattern opens.\nconst RATE = 474, OPEN = 0.3;\n// Seconds held at the top and at the bottom of the loop, at Speed 2.\nconst HOLD_UP = 1.5, HOLD_DOWN = 1;\n// The hue of a flip is set by how far through the sweep its avalanche started.\nconst SPAN = 0.62;\n// Skips orange through lime, which read brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nfunction gauss() {\n  let u = 0;\n  while (u === 0) u = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * Math.random());\n}\n\nfunction makeSweep() {\n  return {\n    seq: new Int16Array(N), // sites in the order they flip\n    pos: new Int16Array(N), // where each site is in seq\n    av: new Int32Array(N), // the avalanche each site flipped in\n    start: new Int32Array(N + 1), // where each avalanche starts in seq\n    n: 0, // avalanches\n    jit: new Float32Array(N), // per avalanche: hue jitter and saturation\n    sat: new Float32Array(N),\n    col: new Float32Array(N * 3),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    R: -1, grain: -1, hue: -1, phase: 0, cur: 0, wait: 0, started: false,\n    white: new Float64Array(N), h: new Float64Array(N), tmp: new Float64Array(N),\n    key: new Float64Array(N), fl: new Uint8Array(N),\n    hk: new Float64Array(6 * N), hs: new Int32Array(6 * N),\n    up: makeSweep(), dn: makeSweep(),\n    bg: new Float32Array(N * 3),\n  };\n}\n\nfunction deal(S) {\n  for (let i = 0; i \u003c N; i++) S.white[i] = gauss();\n  for (const sw of [S.up, S.dn])\n    for (let a = 0; a \u003c N; a++) {\n      sw.jit[a] = (Math.random() - 0.5) * 0.08;\n      sw.sat[a] = 0.5 + 0.45 * Math.random();\n    }\n}\n\n// The frozen field: the white noise, blurred on the torus by a Gaussian of\n// radius grain, then shifted to mean 0 and scaled to standard deviation R.\nfunction makeField(S) {\n  const { white, h, tmp } = S, sg = S.grain;\n  if (sg \u003c 0.25) h.set(white);\n  else {\n    const r = ceil(2.5 * sg), k = new Float64Array(2 * r + 1);\n    for (let d = -r; d \u003c= r; d++) k[d + r] = exp((-d * d) / (2 * sg * sg));\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let d = -r; d \u003c= r; d++) a += k[d + r] * white[y * W + ((x + d + 4 * W) % W)];\n        tmp[y * W + x] = a;\n      }\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let d = -r; d \u003c= r; d++) a += k[d + r] * tmp[((y + d + 4 * H) % H) * W + x];\n        h[y * W + x] = a;\n      }\n  }\n  let m = 0, v = 0;\n  for (let i = 0; i \u003c N; i++) m += h[i];\n  m /= N;\n  for (let i = 0; i \u003c N; i++) v += (h[i] -= m) * h[i];\n  const f = S.R / sqrt(v / N);\n  for (let i = 0; i \u003c N; i++) h[i] *= f;\n}\n\n// One branch of the hysteresis loop. Spin i, still down, flips up once\n// h_i + H + J (up neighbours - down neighbours) > 0 with J = 1, so its\n// key h_i + 2 (up neighbours) - 4 says the field H at which it goes. The\n// sweep raises H just to the largest key left, flips that spin, and lets\n// the avalanche run at that H, breadth first, each flip adding 2 to the key\n// of its neighbours. The way back down is the same sweep for the field -h,\n// since flipping every spin and both fields maps one branch onto the other.\n// Keys only grow, so a heap with stale entries skipped does the search.\nfunction sweep(S, sw, sign) {\n  const { key, fl, hk, hs, h } = S, seq = sw.seq;\n  let hn = 0;\n  const push = (k, s) => {\n    let i = hn++;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (hk[p] >= k) break;\n      hk[i] = hk[p];\n      hs[i] = hs[p];\n      i = p;\n    }\n    hk[i] = k;\n    hs[i] = s;\n  };\n  const pop = () => {\n    const k = hk[--hn], s = hs[hn];\n    let i = 0;\n    for (;;) {\n      let c = 2 * i + 1;\n      if (c >= hn) break;\n      if (c + 1 \u003c hn && hk[c + 1] > hk[c]) c++;\n      if (hk[c] \u003c= k) break;\n      hk[i] = hk[c];\n      hs[i] = hs[c];\n      i = c;\n    }\n    hk[i] = k;\n    hs[i] = s;\n  };\n  fl.fill(0);\n  for (let i = 0; i \u003c N; i++) push((key[i] = sign * h[i] - 4), i);\n  let pos = 0, n = 0;\n  while (pos \u003c N) {\n    let i, k;\n    do {\n      i = hs[0];\n      k = hk[0];\n      pop();\n    } while (fl[i] || k !== key[i]);\n    const field = -k;\n    sw.start[n] = pos;\n    fl[i] = 1;\n    seq[pos++] = i;\n    for (let q = pos - 1; q \u003c pos; q++) {\n      const s = seq[q], x = s % W, y = (s - x) / W;\n      for (let d = 0; d \u003c 4; d++) {\n        const j = d === 0 ? y * W + ((x + 1) % W) : d === 1 ? y * W + ((x + W - 1) % W) : d === 2 ? ((y + 1) % H) * W + x : ((y + H - 1) % H) * W + x;\n        if (fl[j]) continue;\n        key[j] += 2;\n        if (key[j] + field > 0) {\n          fl[j] = 1;\n          seq[pos++] = j;\n        } else push(key[j], j);\n      }\n    }\n    n++;\n  }\n  sw.start[n] = N;\n  sw.n = n;\n  for (let a = 0; a \u003c n; a++) for (let p = sw.start[a]; p \u003c sw.start[a + 1]; p++) {\n    sw.av[seq[p]] = a;\n    sw.pos[seq[p]] = p;\n  }\n}\n\n// Colours per avalanche. Up: by where it started in the sweep, a little\n// jitter so neighbours from the same moment part, and brightness by size,\n// 232 for a lone spin up to 255 from 400 spins. Down: the same drift, dim.\nfunction paint(S) {\n  for (const [sw, up] of [[S.up, true], [S.dn, false]]) {\n    for (let a = 0; a \u003c sw.n; a++) {\n      const m = sw.start[a] / N, size = sw.start[a + 1] - sw.start[a];\n      if (up) hsv(wheel(0.27 + S.hue + SPAN * m + sw.jit[a]), sw.sat[a], 0.91 + 0.09 * min(1, log(size) / log(400)), sw.col, a * 3);\n      else hsv(wheel(0.6 + S.hue + 0.4 * m + 2 * sw.jit[a]), sw.sat[a] + 0.05, 0.12 + 0.24 * (sw.sat[a] - 0.5), sw.col, a * 3);\n    }\n  }\n}\n\nfunction rebuild(S) {\n  makeField(S);\n  sweep(S, S.up, 1);\n  sweep(S, S.dn, -1);\n  paint(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1.05, 0];\n  const d = cl(dt || 0, 0, 0.1), speed = cl(kv[1], 0.2, 3) / 2;\n  const R = cl(kv[2], 1.05, 2.6), grain = cl(kv[3], 0, 1.6), hue = cl(kv[0], 0, 1);\n  if (!S.started) {\n    deal(S);\n    S.started = true;\n    // The first sweep opens part done, so the patchwork is already there.\n    S.cur = OPEN * N;\n  }\n  if (abs(R - S.R) > 1e-4 || abs(grain - S.grain) > 1e-3) {\n    // A new disorder width or grain reshapes the same noise and the\n    // sweep stays as far through as it was.\n    S.R = R;\n    S.grain = grain;\n    S.hue = hue;\n    rebuild(S);\n  } else if (abs(hue - S.hue) > 1e-4) {\n    S.hue = hue;\n    paint(S);\n  }\n  // 0 up, 1 held up, 2 down, 3 held down.\n  if (S.phase === 0 || S.phase === 2) {\n    S.cur += RATE * (S.phase === 2 ? 2 : 1) * speed * d;\n    if (S.cur >= N) {\n      S.cur = N;\n      S.phase++;\n      S.wait = S.phase === 1 ? HOLD_UP : HOLD_DOWN;\n    }\n  } else {\n    S.wait -= speed * d;\n    if (S.wait \u003c= 0) {\n      if (S.phase === 3) {\n        // The dim patchwork of the way down stays under the next sweep.\n        for (let i = 0; i \u003c N; i++) {\n          const o = S.dn.av[i] * 3;\n          S.bg[i * 3] = S.dn.col[o];\n          S.bg[i * 3 + 1] = S.dn.col[o + 1];\n          S.bg[i * 3 + 2] = S.dn.col[o + 2];\n        }\n        deal(S);\n        rebuild(S);\n      }\n      S.phase = (S.phase + 1) % 4;\n      S.cur = 0;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.R \u003c 0) return;\n  const c = floor(S.cur), ph = S.phase, up = S.up, dn = S.dn;\n  for (let i = 0; i \u003c N; i++) {\n    let col = up.col, o = up.av[i] * 3;\n    if (ph === 0) {\n      if (up.pos[i] >= c) {\n        col = S.bg;\n        o = i * 3;\n      }\n    } else if (ph === 3 || (ph === 2 && dn.pos[i] \u003c c)) {\n      col = dn.col;\n      o = dn.av[i] * 3;\n    }\n    display.setPixel(i % W, (i / W) | 0, col[o] | 0, col[o + 1] | 0, col[o + 2] | 0);\n  }\n}\n","greenhill-column":"// ===== Patternflow pattern =====\n// Title:   Greenhill Column\n// Family:  physics\n// Idea:    Eight elastic columns of different stiffness stand clamped along the bottom row and grow upward at a steady rate, each straight until it passes its own critical height, marked by a white tick, where it buckles under its own weight into the heavy elastica, solved every frame by shooting on the tip angle, and swings over until its tip points below the horizontal, when it shrinks back, straightens and grows again, so the stiffest one in the middle stands tallest.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: buckling of a heavy column under its own weight (Leonhard Euler, 1778; Alfred George Greenhill, 1881), Euler's flagpole with a weight on top (Leonhard Euler, 1744), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=3..64, Top weight=0..40\n//\n// Knob 1: Hue. At 0 the columns run from azure for the softest through blue and violet to rose for the stiffest, dim while straight and bright where they bend hardest; the knob turns them all round the wheel together, skipping orange, yellow and lime, which read brown and olive when dim.\n// Knob 2: Speed. At 2 the columns grow 8 LEDs a second and shrink back at 16. The stiffest takes 1 to 3 s to grow from where it last shrank back to its tick, 2 s more to fall over and about 2 s to shrink and straighten. At 0.2 they grow 0.8 LEDs a second, at 3 12.\n// Knob 3: Spread. The stiffest column's EI over the softest's, 3 to 64, in equal ratios between. Greenhill's height goes as the cube root of EI, so at 3 the eight columns buckle at 83 to 120 LEDs, at 16 at 48 to 120 and at 64 at 30 to 120.\n// Knob 4: Top weight. A weight P on every tip, 0 to 40 LEDs' worth of column. Near 0 it is Greenhill's column, buckling at 83 to 120 LEDs at Spread 3; at 20 they buckle at 67 to 103, at 40 at 56 to 90. Euler's flagpole, the top weight alone, buckles where P = pi^2 EI / (4 L^2), 67 to 117 LEDs at 40, and the softer a column the closer it comes: at Spread 64 and 40 the softest buckles at 14 LEDs against the flagpole's 15.\n\nconst W = 64, H = 128, NC = 8, NS = 24;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Lengths in LEDs, weight per LED of column Q = 1. Greenhill's column\n// buckles once q L^3 / EI passes 7.837, where (2/3) sqrt(q L^3 / EI) reaches\n// 1.866, the first zero of the Bessel function J_-1/3 in his solution;\n// Euler had tried the same problem in 1778. The stiffest column has EI =\n// 120^3 / 7.837, so with no top weight it buckles at 120 LEDs, and the\n// others step down in EI by equal ratios to 1 / Spread of it.\nconst Q = 1, LTOP = 120, GREENHILL = 7.837;\n// The tip angle at which a column gives up and shrinks back: 100 degrees,\n// reached at 1.14 times the critical height with no top weight.\nconst DROOP = (100 * PI) / 180;\n// Where each column stands, left to right: its rank in stiffness, 0 the\n// softest, so the stiffest stand in the middle.\nconst RANK = [0, 2, 4, 6, 7, 5, 3, 1];\nconst BASEY = H - 0.5;\n// The pen: a core 2.6 LEDs wide at full strength and a glow out to 4.5,\n// tabulated by squared distance.\nconst R2 = 4.5 * 4.5, PEN_STEP = 12, PEN = new Float32Array(Math.ceil(R2 * PEN_STEP) + 1);\nfor (let i = 0; i \u003c PEN.length; i++) {\n  const dd = sqrt(i / PEN_STEP);\n  PEN[i] = dd \u003c= 1.3 ? 1 : 0.7 * exp(-((dd - 1.3) * (dd - 1.3)) / 4.5);\n}\n\n// The heavy elastica: EI theta''(s) = -(q (L - s) + P) sin theta, with s\n// measured up the column. Scaled to s in [0, 1] it is theta'' = -(lam (1 -\n// s) + mu) sin theta, lam = q L^3 / EI and mu = P L^2 / EI. This integrates\n// it by RK4 in NS steps from the free top, where theta = alpha and theta' = 0\n// (no moment), down to the clamp, and returns theta there, which must be 0.\n// If th is given it gets theta and theta' at the points s = i / NS.\nfunction shoot(alpha, lam, mu, th, dth) {\n  let t = alpha, w = 0, s = 1;\n  const h = -1 / NS;\n  if (th) {\n    th[NS] = t;\n    dth[NS] = 0;\n  }\n  for (let i = NS - 1; i >= 0; i--) {\n    const a1 = -(lam * (1 - s) + mu), a2 = -(lam * (1 - s - h / 2) + mu), a3 = -(lam * (1 - s - h) + mu);\n    const k1t = w, k1w = a1 * sin(t);\n    const k2t = w + (h / 2) * k1w, k2w = a2 * sin(t + (h / 2) * k1t);\n    const k3t = w + (h / 2) * k2w, k3w = a2 * sin(t + (h / 2) * k2t);\n    const k4t = w + h * k3w, k4w = a3 * sin(t + h * k3t);\n    t += (h / 6) * (k1t + 2 * k2t + 2 * k3t + k4t);\n    w += (h / 6) * (k1w + 2 * k2w + 2 * k3w + k4w);\n    s += h;\n    if (th) {\n      th[i] = t;\n      dth[i] = w;\n    }\n  }\n  return t;\n}\n\n// The linear problem u'' = -(lam (1 - s) + mu) u with u(1) = 1, u'(1) = 0:\n// the column is critical where u(0) first reaches 0.\nfunction linear(lam, mu) {\n  let u = 1, w = 0, s = 1;\n  const h = -1 / NS;\n  for (let i = 0; i \u003c NS; i++) {\n    const a1 = -(lam * (1 - s) + mu), a2 = -(lam * (1 - s - h / 2) + mu), a3 = -(lam * (1 - s - h) + mu);\n    const k1u = w, k1w = a1 * u;\n    const k2u = w + (h / 2) * k1w, k2w = a2 * (u + (h / 2) * k1u);\n    const k3u = w + (h / 2) * k2w, k3w = a2 * (u + (h / 2) * k2u);\n    const k4u = w + h * k3w, k4w = a3 * (u + h * k3u);\n    u += (h / 6) * (k1u + 2 * k2u + 2 * k3u + k4u);\n    w += (h / 6) * (k1w + 2 * k2w + 2 * k3w + k4w);\n    s += h;\n  }\n  return u;\n}\n\n// The critical height of a column of stiffness EI under top weight P, by\n// bisection on L between 0 and its Greenhill height.\nfunction critical(EI, P) {\n  let lo = 0, hi = Math.cbrt((GREENHILL * EI) / Q) * 1.0001;\n  for (let it = 0; it \u003c 28; it++) {\n    const L = (lo + hi) / 2;\n    if (linear((Q * L * L * L) / EI, (P * L * L) / EI) > 0) lo = L;\n    else hi = L;\n  }\n  return (lo + hi) / 2;\n}\n\n// The tip angle of the buckled column, by bisection, starting from a\n// bracket round the last answer and falling back to a scan down from pi.\n// The bifurcation is supercritical, so the answer grows from 0 at the\n// critical height: 41 degrees at 1.02 times it, 88 at 1.10.\nfunction tipAngle(lam, mu, prev, ratio) {\n  let lo = -1, hi = -1;\n  if (prev > 0.02) {\n    const a = max(1e-4, prev - 0.12), b = min(PI - 1e-4, prev + 0.12);\n    if (shoot(a, lam, mu) \u003c 0 && shoot(b, lam, mu) > 0) {\n      lo = a;\n      hi = b;\n    }\n  }\n  if (lo \u003c 0) {\n    if (shoot(1e-4, lam, mu) > 0 && ratio \u003c 1.5) return 0;\n    for (let k = 47; k >= 1; k--) {\n      const a = (k * PI) / 48;\n      if (shoot(a, lam, mu) \u003c 0) {\n        lo = a;\n        hi = ((k + 1) * PI) / 48 - 1e-4;\n        break;\n      }\n    }\n    if (lo \u003c 0) return 0;\n  }\n  for (let it = 0; it \u003c 20; it++) {\n    const m = (lo + hi) / 2;\n    if (shoot(m, lam, mu) \u003c 0) lo = m;\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\n// Hue h in turns, with orange, yellow and lime (0.03 to 0.25) skipped,\n// since they read brown and olive when dim.\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 0.78;\n  if (h >= 0.03) h += 0.22;\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  const cols = [];\n  for (let k = 0; k \u003c NC; k++)\n    cols.push({ x: 3.5 + 8 * k, rank: RANK[k], EI: 1, Lc: 60, L: 0, grow: 1, side: 1, back: 0.8, alpha: 0, th: new Float64Array(NS + 1), dth: new Float64Array(NS + 1) });\n  params.s = { cols, spread: -1, P: -1, hue: 0, started: false, rgb: new Float32Array(W * H * 3), cb: new Float32Array(W * H), touched: new Int32Array(W * H), c: [0, 0, 0] };\n  return params.s;\n}\n\nfunction pickSide(c) {\n  c.side = Math.random() \u003c 0.5 ? -1 : 1;\n  c.back = 0.8 + 0.12 * Math.random();\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 3, 0], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1], 0.2, 3), spread = cl(kv[2], 3, 64), P = cl(kv[3], 0, 40);\n  if (spread !== S.spread || P !== S.P) {\n    S.spread = spread;\n    S.P = P;\n    for (const c of S.cols) {\n      c.EI = ((Q * LTOP ** 3) / GREENHILL) * spread ** (-(NC - 1 - c.rank) / (NC - 1));\n      c.Lc = critical(c.EI, P);\n    }\n  }\n  if (!S.started) {\n    // Pre-roll: every column starts somewhere in its cycle, from its\n    // shrink-back height to 1.11 times its critical height, 80% of them\n    // growing.\n    S.started = true;\n    for (const c of S.cols) {\n      pickSide(c);\n      c.L = c.Lc * (c.back + (1.11 - c.back) * Math.random());\n      c.grow = Math.random() \u003c 0.8 ? 1 : -1;\n    }\n  }\n  const rate = 4 * speed * d;\n  for (const c of S.cols) {\n    // Shrinking runs at twice the growth rate, and faster when a knob has\n    // left a column more than 1.2 times its new critical height.\n    c.L = max(4, c.grow > 0 ? c.L + rate : c.L - max(2 * rate, 3 * d * (c.L - 1.2 * c.Lc)));\n    const lam = (Q * c.L * c.L * c.L) / c.EI, mu = (S.P * c.L * c.L) / c.EI;\n    c.alpha = c.L > c.Lc ? tipAngle(lam, mu, c.alpha, c.L / c.Lc) : 0;\n    if (c.grow > 0 && c.alpha > DROOP) c.grow = -1;\n    else if (c.grow \u003c 0 && c.L \u003c c.back * c.Lc) {\n      c.grow = 1;\n      pickSide(c);\n    }\n    if (c.alpha > 0) shoot(c.alpha, lam, mu, c.th, c.dth);\n    else {\n      c.th.fill(0);\n      c.dth.fill(0);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, cb = S.cb, touched = S.touched, col = S.c;\n  rgb.fill(0);\n  for (const c of S.cols) {\n    let nt = 0;\n    const seg = c.L / NS;\n    let x = c.x, y = BASEY;\n    for (let i = 0; i \u003c NS; i++) {\n      const t0 = c.th[i], t1 = c.th[i + 1], tm = (t0 + t1) / 2;\n      const nx = x + c.side * sin(tm) * seg, ny = y - cos(tm) * seg;\n      const steps = max(1, Math.ceil(seg));\n      for (let k = 0; k \u003c steps; k++) {\n        const f = (k + 0.5) / steps, px = x + (nx - x) * f, py = y + (ny - y) * f;\n        // Bending stress: the curvature times the length, 0 on a straight\n        // column and about 4 at the clamp when the tip is horizontal.\n        const kap = abs(c.dth[i] + (c.dth[i + 1] - c.dth[i]) * f);\n        const b = 0.42 + 0.58 * min(1, kap / 4);\n        const x0 = max(0, floor(px - 4.5)), x1 = min(W - 1, Math.ceil(px + 4.5));\n        const y0 = max(0, floor(py - 4.5)), y1 = min(H - 1, Math.ceil(py + 4.5));\n        for (let Y = y0; Y \u003c= y1; Y++) {\n          const dy = Y + 0.5 - py;\n          for (let X = x0; X \u003c= x1; X++) {\n            const dx = X + 0.5 - px, d2 = dx * dx + dy * dy;\n            if (d2 >= R2) continue;\n            const v = b * PEN[(d2 * PEN_STEP) | 0], p = Y * W + X;\n            if (cb[p] === 0) touched[nt++] = p;\n            if (v > cb[p]) cb[p] = v;\n          }\n        }\n      }\n      x = nx;\n      y = ny;\n    }\n    hsv(0.48 + S.hue + 0.065 * c.rank, 0.78, 1, col);\n    for (let k = 0; k \u003c nt; k++) {\n      const p = touched[k], v = cb[p], o = p * 3;\n      // Hot spots of stress go toward white.\n      const wv = max(0, v - 0.75) * 1.6;\n      const r = v * col[0] + wv, g = v * col[1] + wv, bl = v * col[2] + wv;\n      if (r > rgb[o]) rgb[o] = r;\n      if (g > rgb[o + 1]) rgb[o + 1] = g;\n      if (bl > rgb[o + 2]) rgb[o + 2] = bl;\n      cb[p] = 0;\n    }\n  }\n  // The ticks: a white bar 7 LEDs wide at each column's critical height,\n  // dimmer over the three LEDs where a straight column passes through it.\n  for (const c of S.cols) {\n    const ty = floor(BASEY - c.Lc);\n    if (ty \u003c 0 || ty >= H) continue;\n    const cx = floor(c.x);\n    for (let X = cx - 3; X \u003c= cx + 3; X++) {\n      if (X \u003c 0 || X >= W) continue;\n      const o = (ty * W + X) * 3, v = abs(X - cx) \u003c= 1 ? 0.55 : 0.85;\n      rgb[o] = max(rgb[o], v);\n      rgb[o + 1] = max(rgb[o + 1], v);\n      rgb[o + 2] = max(rgb[o + 2], v);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","holditch-ring":"// ===== Patternflow pattern =====\n// Title:   Holditch Ring\n// Family:  line\n// Idea:    A chord of fixed length slides round a tall convex oval with both ends on it, the point that splits it into a and b leaves a gold trace, the ring between the oval and the trace fills behind the a-part, and an ellipse with semi-axes a and b in the middle fills with the same area of light as it goes, so both close together when the lap ends, and the next lap runs on a new oval with a different ring and the same ellipse.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Holditch's theorem (Hamnet Holditch, 1858), support functions and Minkowski sums of convex bodies (Hermann Minkowski, 1903), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Split=0.25..0.5, Chord=36..44\n//\n// Knob 1: Hue. Turns the colours round together. At 0 the oval is pale cyan, the trace gold and the ring and the ellipse violet; at 0.33 the oval is pink, the trace teal and the fills green; at 0.67 pale lime, violet and azure.\n// Knob 2: Speed. At 2 a lap takes 6 seconds, then the full ring and ellipse pulse together for 1.2 s and the oval morphs into the next of six in 1.8 s, 9 seconds in all; at 0.2 the cycle takes 90 seconds, at 3 six.\n// Knob 3: Split. a / (a + b), 0.25 to 0.5. With the opening 36 LED chord, at 0.25 a is 9 and b 27, the ring holds pi x 9 x 27 = 763 square LEDs and the ellipse is 18 wide and 54 tall; at 0.5 a and b are both 18, the ring holds 1018 and the ellipse is a circle 36 across.\n// Knob 4: Chord. a + b, 36 to 44 LEDs. At a split of 0.25 the ring and the ellipse hold 763 square LEDs at 36 and 1140 at 44, and at 0.5 up to 1521. At 46 the first point ahead would jump 14 LEDs across the pointed end of the egg, and the chord would no longer slide.\n\nconst W = 64, H = 128, CX = 32, CY = 64;\nconst { floor, ceil, min, max, abs, sqrt, PI, cos, sin, atan2, hypot } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, x) => {\n  const t = cl((x - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n// Points on the oval, taken at K even steps of the outward normal, and\n// chord positions per lap.\nconst K = 240, N = 240;\n// One cycle at Speed 2, in seconds.\nconst LAP = 6, HOLD = 1.2, MORPH = 1.8;\n\n// The ovals, each a Minkowski sum: its support function is the sum of its\n// parts', so a blend of two ovals taken normal by normal is convex all the\n// way through. Parts: [0, A, B] an ellipse, [1, w, h] a rectangle,\n// [2, r] a disc, [3, points] a polygon. In turn: an ellipse, a rounded\n// rectangle, an egg, a stadium, a shield and a lozenge, each 58 x 122 LEDs,\n// with ey where the ellipse sits best inside its trace. A tall rounded\n// triangle was tried and left out: at its point a 40 LED chord already\n// jumps 39 LEDs from one side to the other.\nconst OVALS = [\n  { p: [[0, 29, 61]], ey: 64 },\n  { p: [[1, 17, 49], [2, 12]], ey: 64 },\n  { p: [[0, 25, 52], [3, [[0, -9], [4, 9], [-4, 9]]]], ey: 70 },\n  { p: [[1, 0, 32], [2, 29]], ey: 64 },\n  { p: [[3, [[-12, -44], [12, -44], [12, 28], [0, 44], [-12, 28]]], [2, 17]], ey: 60 },\n  { p: [[3, [[0, -40], [9, -20], [9, 20], [0, 40], [-9, 20], [-9, -20]]], [0, 20, 21]], ey: 64 },\n];\n\n// The point of an oval whose outward normal is (c, s).\nfunction support(oval, c, s, out) {\n  let x = 0, y = 0;\n  for (const q of oval.p) {\n    if (q[0] === 0) {\n      const h = hypot(q[1] * c, q[2] * s);\n      (x += (q[1] * q[1] * c) / h), (y += (q[2] * q[2] * s) / h);\n    } else if (q[0] === 1) (x += c \u003c 0 ? -q[1] : q[1]), (y += s \u003c 0 ? -q[2] : q[2]);\n    else if (q[0] === 2) (x += q[1] * c), (y += q[1] * s);\n    else {\n      let best = -1e9, bx = 0, by = 0;\n      for (const v of q[1]) {\n        const d = v[0] * c + v[1] * s;\n        if (d > best) (best = d), (bx = v[0]), (by = v[1]);\n      }\n      (x += bx), (y += by);\n    }\n  }\n  out[0] = x;\n  out[1] = y;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// Soft fills take hues from a wheel that skips orange through yellow,\n// which read brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    f: 0, t: 0, ox: new Float32Array(K), oy: new Float32Array(K), arc: new Float64Array(K + 1),\n    sx: new Float32Array((N + 1) * 4), ang: new Float64Array(N + 1), area: new Float64Array(N + 1),\n    key: \"\", ring: new Uint8Array(W * H), tn: new Uint8Array(H), tx: new Float32Array(H * 8), xl: new Float32Array(H), xr: new Float32Array(H), buf: new Float32Array(W * H * 3),\n    c: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], tmp: [0, 0], tmq: [0, 0],\n  };\n}\n\n// The oval at morph m between oval f and the next one.\nfunction buildOval(S, m) {\n  const A = OVALS[S.f % OVALS.length], B = OVALS[(S.f + 1) % OVALS.length], p = S.tmp, q = S.tmq;\n  for (let i = 0; i \u003c K; i++) {\n    const psi = ((i + 0.5) / K) * TAU, c = cos(psi), s = sin(psi);\n    support(A, c, s, p);\n    support(B, c, s, q);\n    S.ox[i] = CX + p[0] + (q[0] - p[0]) * m;\n    S.oy[i] = CY + p[1] + (q[1] - p[1]) * m;\n  }\n  S.arc[0] = 0;\n  for (let i = 1; i \u003c= K; i++) S.arc[i] = S.arc[i - 1] + hypot(S.ox[i % K] - S.ox[i - 1], S.oy[i % K] - S.oy[i - 1]);\n  // Start each lap at the top of the oval, normal straight up.\n  S.u0 = S.arc[(3 * K) / 4];\n  S.ey = A.ey + (B.ey - A.ey) * m;\n}\n\n// The point of the oval at arc length u, and the edge it lies on.\nfunction at(S, u, out) {\n  const per = S.arc[K];\n  u = ((u % per) + per) % per;\n  let lo = 0, hi = K;\n  while (hi - lo > 1) {\n    const md = (lo + hi) >> 1;\n    if (S.arc[md] \u003c= u) lo = md;\n    else hi = md;\n  }\n  const f = (u - S.arc[lo]) / (S.arc[lo + 1] - S.arc[lo] || 1), j = (lo + 1) % K;\n  out[0] = S.ox[lo] + (S.ox[j] - S.ox[lo]) * f;\n  out[1] = S.oy[lo] + (S.oy[j] - S.oy[lo]) * f;\n  out[2] = lo;\n}\n\n// The other end of the chord: walking on from P, the first point of the\n// oval at distance L, solved exactly on the edge where it lies.\nfunction far(S, px, py, edge, L, out) {\n  for (let k = 0; k \u003c K; k++) {\n    const i = (edge + k) % K, j = (i + 1) % K;\n    const ax = k ? S.ox[i] : px, ay = k ? S.oy[i] : py, bx = S.ox[j], by = S.oy[j];\n    if (hypot(bx - px, by - py) \u003c L) continue;\n    const dx = bx - ax, dy = by - ay, fx = ax - px, fy = ay - py;\n    const a = dx * dx + dy * dy, b = 2 * (fx * dx + fy * dy), c = fx * fx + fy * fy - L * L;\n    const t = (-b + sqrt(max(0, b * b - 4 * a * c))) / (2 * a);\n    out[0] = ax + dx * t;\n    out[1] = ay + dy * t;\n    return;\n  }\n}\n\n// N + 1 chord positions round the lap: P, the split point D, the chord's\n// angle unwrapped, and the area the a-part has swept so far, quad by quad.\nfunction sampleLap(S, sp, L) {\n  const p = [0, 0, 0], q = [0, 0], per = S.arc[K], X = S.sx;\n  let prev = 0;\n  for (let k = 0; k \u003c= N; k++) {\n    at(S, S.u0 + (k / N) * per, p);\n    far(S, p[0], p[1], p[2], L, q);\n    X[k * 4] = p[0];\n    X[k * 4 + 1] = p[1];\n    X[k * 4 + 2] = p[0] + (q[0] - p[0]) * sp;\n    X[k * 4 + 3] = p[1] + (q[1] - p[1]) * sp;\n    let an = atan2(q[1] - p[1], q[0] - p[0]);\n    if (k) {\n      while (an - prev > PI) an -= TAU;\n      while (an - prev \u003c -PI) an += TAU;\n    }\n    S.ang[k] = prev = an;\n    S.area[k] = k ? S.area[k - 1] + quadArea(X, k - 1) : 0;\n  }\n  S.dir = S.ang[N] > S.ang[0] ? 1 : -1;\n  // The last quad meets the first again, so the a-part has swept the ring\n  // once: the total is pi a b to a few parts in ten thousand.\n  S.total = abs(S.area[N]);\n}\n\nfunction quadArea(X, k) {\n  const a = k * 4, b = a + 4;\n  const px = [X[a], X[a + 2], X[b + 2], X[b]], py = [X[a + 1], X[a + 3], X[b + 3], X[b + 1]];\n  let s = 0;\n  for (let i = 0; i \u003c 4; i++) s += px[i] * py[(i + 1) % 4] - px[(i + 1) % 4] * py[i];\n  return s / 2;\n}\n\n// Marks the LED centres inside triangle a b c with v.\nfunction tri(M, ax, ay, bx, by, cx, cy, v) {\n  const d = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(d) \u003c 1e-9) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, ceil(max(ay, by, cy)));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const l0 = ((cx - bx) * (py - by) - (cy - by) * (px - bx)) / d, l1 = ((ax - cx) * (py - cy) - (ay - cy) * (px - cx)) / d;\n      if (l0 >= -1e-6 && l1 >= -1e-6 && 1 - l0 - l1 >= -1e-6) {\n        const o = y * W + x;\n        if (M[o] \u003c v) M[o] = v;\n      }\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.25, 36], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.sp = cl(kv[2], 0.25, 0.5);\n  S.L = cl(kv[3], 36, 44);\n  S.t += (d * cl(kv[1], 0.2, 3)) / 2;\n  if (S.t >= LAP + HOLD + MORPH) (S.t -= LAP + HOLD + MORPH), S.f++;\n  const m = ss(LAP + HOLD, LAP + HOLD + MORPH, S.t);\n  // The lap is worked out again only when the oval or a knob has moved.\n  const key = S.f + \",\" + m.toFixed(4) + \",\" + S.sp.toFixed(4) + \",\" + S.L.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    buildOval(S, m);\n    sampleLap(S, S.sp, S.L);\n  }\n}\n\n// Xiaolin Wu's line, mixed over what is there.\nfunction line(B, x0, y0, x1, y1, c, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  let t;\n  if (steep) (t = x0), (x0 = y0), (y0 = t), (t = x1), (x1 = y1), (y1 = t);\n  if (x0 > x1) (t = x0), (x0 = x1), (x1 = t), (t = y0), (y0 = y1), (y1 = t);\n  const k = (y1 - y0) / (x1 - x0 || 1e-9);\n  for (let u = ceil(x0 - 0.5); u \u003c= floor(x1 - 0.5); u++) {\n    const v = y0 + k * (u + 0.5 - x0) - 0.5, vi = floor(v), f = v - vi;\n    plot(B, steep ? vi : u, steep ? u : vi, c, a * (1 - f));\n    plot(B, steep ? vi + 1 : u, steep ? u : vi + 1, c, a * f);\n  }\n}\n\nfunction plot(B, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  a = min(1, a);\n  B[o] += (c[0] - B[o]) * a;\n  B[o + 1] += (c[1] - B[o + 1]) * a;\n  B[o + 2] += (c[2] - B[o + 2]) * a;\n}\n\nfunction dot(B, x, y, r, c, a) {\n  for (let yy = floor(y - r); yy \u003c= y + r; yy++)\n    for (let xx = floor(x - r); xx \u003c= x + r; xx++) {\n      const q = hypot(xx + 0.5 - x, yy + 0.5 - y) / r;\n      if (q \u003c 1) plot(B, xx, yy, c, a * min(1, 1.6 * (1 - q)));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.key) return;\n  const B = S.buf, X = S.sx, M = S.ring, t = S.t, [cBase, cOval, cFill, cTrace, cA, cB] = S.c, h = S.hue;\n  hsv(wheel(0.43 + h), 0.25, 0.11, cBase);\n  hsv(0.53 + h, 0.45, 1, cOval);\n  hsv(wheel(0.73 + h), 0.7, 0.6, cFill);\n  hsv(0.13 + h, 0.65, 1, cTrace);\n  hsv(wheel(0.73 + h), 0.35, 1, cA);\n  hsv(0.53 + h, 0.1, 0.9, cB);\n  // How far round the lap the chord is, and how bright the fills are: they\n  // pulse together in the hold and sink back to a ghost at the end of the\n  // morph, ready for the next lap to fill them again.\n  const lap = cl(t / LAP, 0, 1), kf = lap * N, k = min(N - 1, floor(kf)), fr = kf - k;\n  const full = t >= LAP, pulse = full ? 1 + 0.25 * sin((PI * (t - LAP)) / HOLD) * (t \u003c LAP + HOLD ? 1 : 0) : 1;\n  const sink = ss(LAP + HOLD + MORPH - 0.5, LAP + HOLD + MORPH, t), lit = (full ? 1 - sink * 0.65 : 1) * pulse, ghost = 0.35;\n  // The chord now, exactly, between sample k and k + 1.\n  const p = [0, 0, 0], q = [0, 0];\n  at(S, S.u0 + lap * S.arc[K], p);\n  far(S, p[0], p[1], p[2], S.L, q);\n  const sp = S.sp, dx = p[0] + (q[0] - p[0]) * sp, dy = p[1] + (q[1] - p[1]) * sp;\n  // The ring is what lies inside the oval and outside the trace. M marks\n  // the LEDs the a-part has swept so far, quad by quad. With a \u003c b the\n  // a-part can dip a little inside the trace and come back out; that part\n  // counts once forward and once back, so it is no part of the ring.\n  M.fill(0);\n  for (let i = 0; i \u003c (full ? N : k); i++) {\n    const a = i * 4, b = a + 4;\n    tri(M, X[a], X[a + 1], X[a + 2], X[a + 3], X[b + 2], X[b + 3], 2);\n    tri(M, X[a], X[a + 1], X[b + 2], X[b + 3], X[b], X[b + 1], 2);\n  }\n  if (!full) {\n    const a = k * 4;\n    tri(M, X[a], X[a + 1], X[a + 2], X[a + 3], dx, dy, 2);\n    tri(M, X[a], X[a + 1], dx, dy, p[0], p[1], 2);\n  }\n  // The ellipse fills as a sector with the area the ring has so far:\n  // parametric angle 2 A / (a b), which comes to 2 pi as the lap closes.\n  const ea = sp * S.L, eb = S.L - ea, ecx = CX, ecy = S.ey;\n  const swept = full ? S.total : abs(S.area[k] + (S.area[k + 1] - S.area[k]) * fr);\n  const phi = full ? TAU : min(TAU, (2 * swept) / (ea * eb)), a0 = S.ang[0], dir = S.dir;\n  // Row by row, where the oval starts and ends.\n  const xl = S.xl.fill(1e9), xr = S.xr.fill(-1e9);\n  for (let i = 0; i \u003c K; i++) {\n    const j = (i + 1) % K, y0 = S.oy[i], y1 = S.oy[j];\n    for (let y = ceil(min(y0, y1) - 0.5); y \u003c= floor(max(y0, y1) - 0.5); y++) {\n      if (y \u003c 0 || y >= H || y0 === y1) continue;\n      const x = S.ox[i] + ((S.ox[j] - S.ox[i]) * (y + 0.5 - y0)) / (y1 - y0);\n      if (x \u003c xl[y]) xl[y] = x;\n      if (x > xr[y]) xr[y] = x;\n    }\n  }\n  // Where the whole trace crosses each row, for an inside test by parity.\n  const tn = S.tn.fill(0), tx = S.tx;\n  for (let i = 0; i \u003c N; i++) {\n    const x0 = X[i * 4 + 2], y0 = X[i * 4 + 3], x1 = X[i * 4 + 6], y1 = X[i * 4 + 7];\n    for (let y = max(0, ceil(min(y0, y1) - 0.5)); y \u003c= min(H - 1, floor(max(y0, y1) - 0.5)); y++) {\n      const yc = y + 0.5;\n      if (yc >= y0 === yc >= y1 || tn[y] >= 8) continue;\n      tx[y * 8 + tn[y]++] = x0 + ((x1 - x0) * (yc - y0)) / (y1 - y0);\n    }\n  }\n  B.fill(0);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const cov = cl(x + 1 - xl[y], 0, 1) * cl(xr[y] - x, 0, 1);\n      if (cov \u003c= 0) continue;\n      let r = cBase[0], g = cBase[1], b = cBase[2], f = 0, inT = 0;\n      for (let c = 0; c \u003c tn[y]; c++) if (tx[y * 8 + c] \u003c x + 0.5) inT ^= 1;\n      if (!inT) f = M[o] ? lit : ghost;\n      const u = (x + 0.5 - ecx) / ea, v = (y + 0.5 - ecy) / eb;\n      if (u * u + v * v \u003c= 1) {\n        const beta = atan2(v, u);\n        f = (((dir * (beta - a0)) % TAU) + TAU) % TAU \u003c= phi ? lit : ghost;\n      }\n      (r += cFill[0] * f), (g += cFill[1] * f), (b += cFill[2] * f);\n      B[o * 3] = r * cov;\n      B[o * 3 + 1] = g * cov;\n      B[o * 3 + 2] = b * cov;\n    }\n  // The ellipse's rim, faint, and its hand at the parametric angle reached.\n  for (let i = 0; i \u003c 96; i++) {\n    const a1 = (i / 96) * TAU, a2 = ((i + 1) / 96) * TAU;\n    line(B, ecx + ea * cos(a1), ecy + eb * sin(a1), ecx + ea * cos(a2), ecy + eb * sin(a2), cA, 0.45);\n  }\n  const ha = a0 + dir * phi, hx = ecx + ea * cos(ha), hy = ecy + eb * sin(ha);\n  line(B, ecx, ecy, hx, hy, cA, 0.9);\n  // Every eighth chord of the lap so far, faint, and a tail of the last 36\n  // behind the chord, fading.\n  for (let i = 0; i \u003c (full ? N : k); i++) {\n    let al = i % 8 ? 0 : 0.16;\n    if (!full && k - i \u003c 36 && i % 3 === 0) al = max(al, 0.45 * (1 - (k - i) / 36));\n    if (al \u003c= 0) continue;\n    const a = i * 4, px = X[a], py = X[a + 1];\n    line(B, px, py, px + (X[a + 2] - px) / sp, py + (X[a + 3] - py) / sp, cB, al);\n  }\n  // The oval.\n  for (let i = 0; i \u003c K; i++) {\n    const j = (i + 1) % K;\n    line(B, S.ox[i], S.oy[i], S.ox[j], S.oy[j], cOval, 0.95);\n  }\n  // The trace of the split point, as far as the chord has gone.\n  const kk = full ? N : k;\n  for (let i = 0; i \u003c kk; i++) line(B, X[i * 4 + 2], X[i * 4 + 3], X[i * 4 + 6], X[i * 4 + 7], cTrace, 1);\n  if (!full) line(B, X[k * 4 + 2], X[k * 4 + 3], dx, dy, cTrace, 1);\n  // The chord: the a-part in the fill's colour, the b-part white.\n  line(B, p[0], p[1], dx, dy, cA, 1);\n  line(B, dx, dy, q[0], q[1], cB, 1);\n  dot(B, p[0], p[1], 1.6, cB, 1);\n  dot(B, q[0], q[1], 1.6, cB, 1);\n  dot(B, dx, dy, 2, cTrace, 1);\n  dot(B, hx, hy, 1.8, cTrace, 1);\n  for (let i = 0, o = 0; i \u003c W * H; i++, o += 3)\n    display.setPixel(i % W, (i / W) | 0, min(255, B[o] * 255) | 0, min(255, B[o + 1] * 255) | 0, min(255, B[o + 2] * 255) | 0);\n}\n","monge-transport":"// ===== Patternflow pattern =====\n// Title:   Monge Transport\n// Family:  algo\n// Idea:    Particles filling one abstract shape are paired at random with places in another shape in the other half of the panel, the pairing is untangled by swapping the targets of any two particles whose swap shortens the total of |x - y|^p, so the dim target dots sort into the colours of the particles bound for them and the sample rays stop crossing, and then every particle slides along its ray at once and the pile lands as the new shape with its colour wheel rearranged by the map.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the problem of deblais et remblais and its rays that never cross (Gaspard Monge, 1781), the relaxed problem (Leonid Kantorovich, 1942), the quadratic cost and its monotone map (Yann Brenier, 1987), displacement interpolation (Robert McCann, 1997), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Particles=150..400, Exponent=1..2\n//\n// Knob 1: Hue. Turns the colour wheel each pile carries. A particle's hue is its angle round the middle of the shape it starts in and its saturation its distance out, pale at the middle. At 0 the opening lobes run from green and yellow on the left to pink and violet on the right; at 0.5 the wheel is turned half round, blue and violet on the left, yellow and green on the right.\n// Knob 2: Speed. At 2 a round takes 7.5 seconds: 3.5 s of untangling, 2.6 s of travel and 1.4 s at rest while the colours settle into the new shape's own wheel. The opening round untangles in 1.8 s, so the first pile leaves at 1.8 s and lands at 4.4 s. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Particles. 150 to 400 in steps of 25, on a jittered grid that fills 1500 LEDs of each shape, the grid 3.2 LEDs apart at 150 and 1.9 at 400. A random pairing takes about 5 swaps a particle to untangle, 720 at 150 and 1800 at 400.\n// Knob 4: Exponent. p in the cost |x - y|^p. At 1, Monge's own cost, every crossing pair of rays is a swap that shortens the total, so when the untangling ends no two rays cross; many plans cost the same there, and the pile keeps left and right but lands with top and bottom shuffled. Any p above 1, even 1.02, also sorts top to top, and the pile slides over keeping its wheel while about one pair of rays in 60 crosses at a shallow angle. At 2, Brenier's quadratic cost, one pair in 35 crosses, but no two particles are ever in the same place at the same moment.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, atan2, cos, sin, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// LEDs each shape fills, and seconds of each stage at Speed 2.\n// The opening round untangles in T_OPEN, so its pile is moving by 2 seconds.\nconst AREA = 1500, T_U = 3.5, T_M = 2.6, T_R = 1.4, T_OPEN = 1.8;\n// Rays drawn through the untangling and the travel, from particles spread\n// out over the source.\nconst WITNESS = 8;\nconst MAXN = 400;\n// Pair checks of planning a frame.\nconst BUDGET = 50000;\n\n// Filled shapes in a box from -1 to 1 across the half panel.\nconst SHAPES = [\n  (u, v) => u * u + v * v \u003c 0.85, // disk\n  (u, v) => {\n    const r = u * u + v * v;\n    return r > 0.2 && r \u003c 0.85;\n  }, // annulus\n  (u, v) => (u + 0.45) * (u + 0.45) + v * v \u003c 0.27 || (u - 0.45) * (u - 0.45) + v * v \u003c 0.27, // two lobes\n  (u, v) => abs(v) \u003c 0.92 && abs(u) > 0.2 && abs(u) \u003c 0.7, // bar pair\n  (u, v) => v \u003c 0.75 && abs(u) \u003c (0.95 * (v + 0.92)) / 1.67, // triangle\n  (u, v) => (abs(u) \u003c 0.3 && abs(v) \u003c 0.95) || (abs(v) \u003c 0.3 && abs(u) \u003c 0.95), // cross\n  (u, v) => u * u + v * v \u003c 0.92 && (u - 0.5) * (u - 0.5) + v * v > 0.4, // crescent\n  (u, v) => abs(u) + abs(v) \u003c 0.95, // diamond\n  (u, v) => {\n    const m = max(abs(u), abs(v));\n    return m > 0.42 && m \u003c 0.92;\n  }, // square ring\n  (u, v) => sqrt(u * u + v * v) \u003c 0.66 + 0.3 * cos(3 * atan2(v, u)), // trefoil\n];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, p: -1, g: 3, half: 0, src: 2, dst: 4, rot: 0, dRot: 0, phase: 0, t: 0, tu: T_U, tm: T_M, base: 0, job: 0, turn: false,\n    X: new Float64Array(2 * MAXN), Y: new Float64Array(2 * MAXN), P: new Float64Array(2 * MAXN), F: new Float64Array(2 * MAXN),\n    hue: new Float64Array(MAXN), sat: new Float64Array(MAXN), hue0: new Float64Array(MAXN), sat0: new Float64Array(MAXN),\n    hueTo: new Float64Array(MAXN), satTo: new Float64Array(MAXN),\n    sig: new Int32Array(MAXN), inv: new Int32Array(MAXN), work: new Int32Array(MAXN), ord: new Int32Array(MAXN),\n    C: new Float64Array(MAXN * MAXN),\n    sw: new Int16Array(2 * 60 * MAXN), cross: new Uint8Array(60 * MAXN), gain: new Float32Array(60 * MAXN), K: 0, k: 0,\n    wit: new Int32Array(WITNESS), flash: [], rgb: new Float32Array(W * H * 3), pc: new Float32Array(W * H * 3), pa: new Float32Array(W * H), c: [0, 0, 0],\n  };\n}\n\n// N points of shape kind in the given half: a jittered grid of spacing\n// sqrt(AREA / N), and the shape scaled about the middle of the half until\n// N grid points fall inside it. Extra points from the last step of the\n// scale are dropped at random.\nfunction sample(S, kind, half, rot, out) {\n  const N = S.n, inside = SHAPES[kind], cr = cos(rot), sr = sin(rot);\n  let g = sqrt(AREA / N);\n  for (let tries = 0; tries \u003c 12; tries++, g *= 0.96) {\n    const m = Math.ceil(64 / g) + 2, pts = [];\n    for (let i = 0; i \u003c m; i++)\n      for (let j = 0; j \u003c m; j++) pts.push((i - (m - 1) / 2 + (Math.random() - 0.5) * 0.12) * g, (j - (m - 1) / 2 + (Math.random() - 0.5) * 0.12) * g);\n    // A point must also stay in its half, whatever the turn of the shape.\n    const inAt = (k, s) => {\n      if (abs(pts[k]) > 30.6 || abs(pts[k + 1]) > 30.6) return false;\n      const x = pts[k] / (31 * s), y = pts[k + 1] / (31 * s);\n      return inside(x * cr + y * sr, y * cr - x * sr);\n    };\n    const count = (s) => {\n      let c = 0;\n      for (let k = 0; k \u003c pts.length; k += 2) if (inAt(k, s)) c++;\n      return c;\n    };\n    if (count(1.25) \u003c N) continue;\n    let lo = 0.2, hi = 1.25;\n    for (let it = 0; it \u003c 16; it++) {\n      const s = (lo + hi) / 2;\n      if (count(s) >= N) hi = s;\n      else lo = s;\n    }\n    const keep = [];\n    for (let k = 0; k \u003c pts.length; k += 2) if (inAt(k, hi)) keep.push(k);\n    while (keep.length > N) keep.splice(floor(Math.random() * keep.length), 1);\n    for (let i = 0; i \u003c N; i++) {\n      out[2 * i] = 32 + pts[keep[i]];\n      out[2 * i + 1] = 32 + 64 * half + pts[keep[i] + 1];\n    }\n    S.g = g;\n    return;\n  }\n}\n\n// Each particle's colour from where it sits: hue by angle round the\n// centre of the pile, saturation by distance out.\nfunction wheelOf(S, pos, hue, sat) {\n  const N = S.n;\n  let cx = 0, cy = 0, rm = 0;\n  for (let i = 0; i \u003c N; i++) {\n    cx += pos[2 * i] / N;\n    cy += pos[2 * i + 1] / N;\n  }\n  for (let i = 0; i \u003c N; i++) rm = max(rm, Math.hypot(pos[2 * i] - cx, pos[2 * i + 1] - cy));\n  for (let i = 0; i \u003c N; i++) {\n    const dx = pos[2 * i] - cx, dy = pos[2 * i + 1] - cy;\n    hue[i] = atan2(-dx, -dy) / (2 * PI) + 0.5;\n    sat[i] = 0.25 + 0.75 * pow(Math.hypot(dx, dy) / max(1, rm), 0.8);\n  }\n}\n\n// Untangling. From the pairing now in sig, try pairs of particles and\n// swap the targets of i and j whenever |x_i - y_b|^p + |x_j - y_a|^p is\n// shorter than |x_i - y_a|^p + |x_j - y_b|^p. At p = 1 two crossing rays\n// always qualify, by the triangle inequality at the point where they\n// cross, so the plan that comes out has none. The work runs ahead of what\n// is shown, a budget of pair checks a frame, and the swaps it finds are\n// played back over the stage.\nfunction startPlan(S) {\n  S.work.set(S.sig.subarray(0, S.n));\n  S.K = 0;\n  S.k = 0;\n  S.job = 1;\n  S.jr = 0;\n  S.jpass = 0;\n  S.rng = (Math.random() * 2147483647) | 1;\n}\n\nfunction record(S, i, j, a, b, d) {\n  if (S.K \u003c S.cross.length) {\n    S.sw[2 * S.K] = i;\n    S.sw[2 * S.K + 1] = j;\n    S.gain[S.K] = d;\n    S.cross[S.K] = crosses(S.X, S.Y, i, a, j, b) ? 1 : 0;\n    S.K++;\n  }\n  S.work[i] = b;\n  S.work[j] = a;\n}\n\nfunction newPass(S) {\n  const ord = S.ord;\n  for (let i = 0; i \u003c S.n; i++) ord[i] = i;\n  for (let i = S.n - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = ord[i];\n    ord[i] = ord[j];\n    ord[j] = t;\n  }\n  S.jx = 0;\n  S.jany = false;\n}\n\nfunction work(S, budget) {\n  const N = S.n, C = S.C, X = S.X, Y = S.Y, w = S.work, ord = S.ord, h = S.p / 2;\n  while (budget > 0 && S.job) {\n    if (S.job === 1) {\n      // The costs, a row a step.\n      const i = S.jr;\n      for (let j = 0; j \u003c N; j++) {\n        const dx = X[2 * i] - Y[2 * j], dy = X[2 * i + 1] - Y[2 * j + 1];\n        C[i * N + j] = pow(dx * dx + dy * dy, h);\n      }\n      budget -= N;\n      if (++S.jr === N) {\n        S.job = 2;\n        S.jr = N * N;\n      }\n    } else if (S.job === 2) {\n      // N^2 pairs at random from a xorshift stream, so the swaps play back\n      // spread over the whole pile.\n      let t = min(S.jr, budget), r = S.rng;\n      S.jr -= t;\n      budget -= t;\n      for (; t > 0; t--) {\n        r ^= r \u003c\u003c 13;\n        r ^= r >>> 17;\n        r ^= r \u003c\u003c 5;\n        const i = ((r >>> 16) * N) >>> 16, j = ((r & 0xffff) * N) >>> 16;\n        if (i === j) continue;\n        const a = w[i], b = w[j], d = C[i * N + a] + C[j * N + b] - C[i * N + b] - C[j * N + a];\n        if (d > 1e-9) record(S, i, j, a, b, d);\n      }\n      S.rng = r;\n      if (!S.jr) {\n        S.job = 3;\n        newPass(S);\n      }\n    } else {\n      // Then whole passes over every pair, in a fresh order each time,\n      // until one finds nothing.\n      const x = S.jx, i = ord[x];\n      for (let y = x + 1; y \u003c N; y++) {\n        const j = ord[y], a = w[i], b = w[j], d = C[i * N + a] + C[j * N + b] - C[i * N + b] - C[j * N + a];\n        if (d > 1e-9) {\n          record(S, i, j, a, b, d);\n          S.jany = true;\n        }\n      }\n      budget -= N - x;\n      if (++S.jx >= N - 1) {\n        if (!S.jany || ++S.jpass >= 40) S.job = 0;\n        else newPass(S);\n      }\n    }\n  }\n}\n\nfunction crosses(X, Y, i, a, j, b) {\n  const ax = X[2 * i], ay = X[2 * i + 1], bx = Y[2 * a], by = Y[2 * a + 1];\n  const cx = X[2 * j], cy = X[2 * j + 1], dx = Y[2 * b], dy = Y[2 * b + 1];\n  const o = (px, py, qx, qy, rx, ry) => (qx - px) * (ry - py) - (qy - py) * (rx - px);\n  return o(ax, ay, bx, by, cx, cy) * o(ax, ay, bx, by, dx, dy) \u003c 0 && o(cx, cy, dx, dy, ax, ay) * o(cx, cy, dx, dy, bx, by) \u003c 0;\n}\n\nfunction shuffle(S) {\n  const N = S.n, sig = S.sig;\n  for (let i = 0; i \u003c N; i++) sig[i] = i;\n  for (let i = N - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = sig[i];\n    sig[i] = sig[j];\n    sig[j] = t;\n  }\n  for (let i = 0; i \u003c N; i++) S.inv[sig[i]] = i;\n}\n\n// Rays to draw all the time: particles spread over the source, each the\n// one farthest from those already picked.\nfunction pickWitnesses(S) {\n  const N = S.n, X = S.X, d = new Float64Array(N).fill(1e9);\n  let pick = floor(Math.random() * N);\n  for (let w = 0; w \u003c WITNESS; w++) {\n    S.wit[w] = pick;\n    let best = 0;\n    for (let i = 0; i \u003c N; i++) {\n      d[i] = min(d[i], Math.hypot(X[2 * i] - X[2 * pick], X[2 * i + 1] - X[2 * pick + 1]));\n      if (d[i] > d[best]) best = i;\n    }\n    pick = best;\n  }\n}\n\n// A new round: the pile sits in S.X, the next shape is dealt in the other half.\nfunction deal(S, fresh) {\n  const N = S.n;\n  if (fresh) {\n    sample(S, S.src, S.half, S.rot, S.X);\n    wheelOf(S, S.X, S.hue, S.sat);\n  }\n  sample(S, S.dst, 1 - S.half, S.dRot, S.Y);\n  S.P.set(S.X.subarray(0, 2 * N));\n  shuffle(S);\n  pickWitnesses(S);\n  startPlan(S);\n  S.phase = 0;\n  S.t = 0;\n  S.tu = T_U;\n  S.base = 0;\n  S.flash = [];\n}\n\nconst ease = (u) => 1 - pow(1 - cl(u, 0, 1), 2.2);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 150, 1];\n  const d = cl(dt || 0, 0, 0.1) * (cl(kv[1], 0.2, 3) / 2);\n  S.hueK = cl(kv[0], 0, 1);\n  const n = cl(round(cl(kv[2], 150, 400) / 25) * 25, 150, 400), p = cl(kv[3], 1, 2);\n  if (n !== S.n) {\n    // A new count deals the same two shapes again, with the short\n    // untangling of the opening.\n    S.n = n;\n    S.p = p;\n    deal(S, true);\n    S.tu = T_OPEN;\n  } else if (abs(p - S.p) > 1e-4) {\n    S.p = p;\n    if (S.phase === 0) {\n      // Plan again from the pairing played so far and play the new plan\n      // over what is left of the stage.\n      startPlan(S);\n      S.base = ease(S.t / S.tu);\n    } else if (S.phase === 1) {\n      // Mid flight: plan from where the particles are now, and turn them\n      // towards their new targets once the plan is done.\n      S.X.set(S.P.subarray(0, 2 * S.n));\n      startPlan(S);\n      S.turn = true;\n    }\n  }\n  S.t += d;\n  for (const f of S.flash) f.life -= d;\n  S.flash = S.flash.filter((f) => f.life > 0);\n  const N = S.n;\n  if (S.job) work(S, S.phase === 0 && S.t >= S.tu ? 1e9 : BUDGET);\n  if (S.phase === 0) {\n    // Until the work is done its length is a guess, and nothing it has\n    // not found yet is played.\n    const e = ease(S.t / S.tu), base = S.base || 0, total = S.job ? S.K * 1.15 : S.K;\n    const want = min(S.K, S.t >= S.tu ? S.K : floor((total * (e - base)) / max(1e-6, 1 - base)));\n    const k0 = S.k;\n    applyTo(S, want);\n    // Flash the swap of this frame that took the most off the total,\n    // a crossing one if there is one.\n    let best = -1;\n    for (let k = k0; k \u003c S.k; k++) if (best \u003c 0 || S.cross[k] > S.cross[best] || (S.cross[k] === S.cross[best] && S.gain[k] > S.gain[best])) best = k;\n    if (best >= 0 && S.flash.length \u003c 3) S.flash.push({ i: S.sw[2 * best], j: S.sw[2 * best + 1], life: 0.2 });\n    if (S.t >= S.tu) {\n      S.phase = 1;\n      S.t = 0;\n      S.tm = T_M;\n      S.turn = false;\n      S.F.set(S.X.subarray(0, 2 * N));\n    }\n  } else if (S.phase === 1 && S.turn && !S.job) {\n    applyTo(S, S.K);\n    S.F.set(S.P.subarray(0, 2 * N));\n    S.tm = max(0.8, S.tm - S.t);\n    S.t = 0;\n    S.turn = false;\n  }\n  if (S.phase === 1) {\n    const u = cl(S.t / S.tm, 0, 1), e = u * u * (3 - 2 * u);\n    for (let i = 0; i \u003c N; i++) {\n      const a = S.sig[i];\n      S.P[2 * i] = S.F[2 * i] + (S.Y[2 * a] - S.F[2 * i]) * e;\n      S.P[2 * i + 1] = S.F[2 * i + 1] + (S.Y[2 * a + 1] - S.F[2 * i + 1]) * e;\n    }\n    if (S.t >= S.tm) {\n      S.phase = 2;\n      S.t = 0;\n      // The pile now sits in the new shape; its colours drift to that\n      // shape's own wheel while it rests.\n      for (let i = 0; i \u003c N; i++) {\n        S.X[2 * i] = S.P[2 * i];\n        S.X[2 * i + 1] = S.P[2 * i + 1];\n      }\n      wheelOf(S, S.X, S.hueTo, S.satTo);\n      S.hue0.set(S.hue.subarray(0, N));\n      S.sat0.set(S.sat.subarray(0, N));\n    }\n  } else if (S.phase === 2) {\n    const u = cl(S.t / (T_R * 0.8), 0, 1), e = u * u * (3 - 2 * u);\n    for (let i = 0; i \u003c N; i++) {\n      const dh = S.hueTo[i] - S.hue0[i] - round(S.hueTo[i] - S.hue0[i]);\n      S.hue[i] = S.hue0[i] + dh * e;\n      S.sat[i] = S.sat0[i] + (S.satTo[i] - S.sat0[i]) * e;\n    }\n    if (S.t >= T_R) {\n      // The pile becomes the source; a new shape in the half it left.\n      S.half = 1 - S.half;\n      S.src = S.dst;\n      S.rot = S.dRot;\n      let k = floor(Math.random() * (SHAPES.length - 1));\n      if (k >= S.src) k++;\n      S.dst = k;\n      S.dRot = floor(Math.random() * 8) * (PI / 4);\n      S.base = 0;\n      deal(S, false);\n    }\n  }\n}\n\nfunction applyTo(S, want) {\n  for (; S.k \u003c want; S.k++) {\n    const i = S.sw[2 * S.k], j = S.sw[2 * S.k + 1], a = S.sig[i], b = S.sig[j];\n    S.sig[i] = b;\n    S.sig[j] = a;\n    S.inv[b] = i;\n    S.inv[a] = j;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, N = S.n, c = S.c, hk = 0.55 + S.hueK;\n  rgb.fill(0);\n  const add = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += r;\n    rgb[o + 1] += g;\n    rgb[o + 2] += b;\n  };\n  const line = (x0, y0, x1, y1, r, g, b) => {\n    const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n    if (n \u003c 1) return;\n    const steep = abs(y1 - y0) > abs(x1 - x0);\n    for (let s = 0; s \u003c= n; s++) {\n      const f = s / n, x = x0 + (x1 - x0) * f - 0.5, y = y0 + (y1 - y0) * f - 0.5;\n      if (steep) {\n        const xi = floor(x), fx = x - xi, yi = round(y);\n        add(xi, yi, r * (1 - fx), g * (1 - fx), b * (1 - fx));\n        add(xi + 1, yi, r * fx, g * fx, b * fx);\n      } else {\n        const yi = floor(y), fy = y - yi, xi = round(x);\n        add(xi, yi, r * (1 - fy), g * (1 - fy), b * (1 - fy));\n        add(xi, yi + 1, r * fy, g * fy, b * fy);\n      }\n    }\n  };\n  // The targets not yet reached: one dim dot each, in the colour of the\n  // particle meant for it.\n  if (S.phase \u003c 2)\n    for (let j = 0; j \u003c N; j++) {\n      const i = S.inv[j];\n      hsv(S.hue[i] + hk, S.sat[i], 0.55, c);\n      add(floor(S.Y[2 * j]), floor(S.Y[2 * j + 1]), c[0], c[1], c[2]);\n    }\n  // The sample rays, from where each particle is to where it is going.\n  if (S.phase \u003c 2)\n    for (let w = 0; w \u003c WITNESS; w++) {\n      const i = S.wit[w], a = S.sig[i];\n      hsv(S.hue[i] + hk, S.sat[i] * 0.7, 0.26, c);\n      line(S.P[2 * i], S.P[2 * i + 1], S.Y[2 * a], S.Y[2 * a + 1], c[0], c[1], c[2]);\n    }\n  for (const f of S.flash) {\n    const v = 0.75 * (f.life / 0.2);\n    for (const i of [f.i, f.j]) {\n      const a = S.sig[i];\n      line(S.P[2 * i], S.P[2 * i + 1], S.Y[2 * a], S.Y[2 * a + 1], v, v, v);\n      add(floor(S.Y[2 * a]), floor(S.Y[2 * a + 1]), v, v, v);\n    }\n  }\n  // The particles: squares a little wider than the grid. Their colour and\n  // cover add up apart from the rest, so two half-covered LEDs on a seam\n  // make a whole one, and then lie over the dots and rays.\n  const q = (S.g * 1.14) / 2, pc = S.pc, pa = S.pa;\n  pc.fill(0);\n  pa.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    hsv(S.hue[i] + hk, S.sat[i], 1, c);\n    const px = S.P[2 * i], py = S.P[2 * i + 1];\n    for (let y = floor(py - q); y \u003c py + q; y++) {\n      if (y \u003c 0 || y >= H) continue;\n      const cy = min(y + 1, py + q) - max(y, py - q);\n      if (cy \u003c= 0) continue;\n      for (let x = floor(px - q); x \u003c px + q; x++) {\n        if (x \u003c 0 || x >= W) continue;\n        const a = cy * (min(x + 1, px + q) - max(x, px - q));\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        pa[y * W + x] += a;\n        pc[o] += c[0] * a;\n        pc[o + 1] += c[1] * a;\n        pc[o + 2] += c[2] * a;\n      }\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const a = pa[p];\n    if (a \u003c= 0) continue;\n    const k = 1 / max(1, a), b = 1 - min(1, a);\n    rgb[o] = rgb[o] * b + pc[o] * k;\n    rgb[o + 1] = rgb[o + 1] * b + pc[o + 1] * k;\n    rgb[o + 2] = rgb[o + 2] * b + pc[o + 2] * k;\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","paul-trap":"// ===== Patternflow pattern =====\n// Title:   Paul Trap\n// Family:  particle\n// Idea:    Ions in a linear Paul trap whose axis runs the length of the panel repel each other into a Coulomb crystal, a zigzag when the RF is weak, a string of round dots when it is strong and a twisted three-dimensional crystal when more ions crowd in, each ion off the RF null smeared across the axis by its micromotion as a camera sees it, until past q = 0.908 the Mathieu equation has no stable solution and the ions boil out sideways while new ones load at the ends.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Mathieu equation (Émile Mathieu, 1868), the Paul trap (Wolfgang Paul, 1953), structural transitions of ion Coulomb crystals (Daniel Dubin, 1993; John Schiffer, 1993), the critical ratio of the zigzag (Daniel Enzer and others, 2000), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ions=16..40, RF q=0.3..0.95\n//\n// Knob 1: Hue. Turns the fluorescence round the wheel. At 0 the ions are azure with pale cores, the near side of a 3D crystal cyan and the far side blue; at 0.25 violet, at 0.5 rose, at 0.75 green, then cyan back to azure. Orange and yellow are skipped, since they read brown and olive when dim.\n// Knob 2: Speed. At 2 the simulation runs 38 RF periods a second: the oven fills an empty trap with 16 ions in half a second, they settle into a crystal by 1 s, and a knock from the background gas every 4 s or so melts part of it for a moment. At 0.2 ten times slower, so the first seconds show the load; at 3 half as fast again.\n// Knob 3: Ions. 16 to 40 ions, two of them dark impurities that leave gaps. The end caps are set so that a string of that many ions would be 122 rows long. At q = 0.3, 16 ions make a flat zigzag and 20 a zigzag that twists toward the camera; from 28 up the crystal is a spindle of shells, 32 LEDs across and 79 rows tall at 40 ions, with the outer ions drawn as dashes by their micromotion. Enzer's ratio puts the string at q = 0.54 for 16 ions, 0.72 for 20 and 0.86 for 24, but above about 0.7 a crystal with ions off the axis heats itself in the RF and melts in patches, so from 24 up it never lines up cleanly.\n// Knob 4: RF q. The Mathieu q of the drive, 0.3 to 0.95. At 0.3 sixteen ions make a zigzag 10 LEDs across; it narrows as q rises and lines up into a string of round dots between 0.50 and 0.54, which holds to 0.9 with a shiver near the end. At a = 0 nothing is stable past 0.908; the small static field that lays the zigzag flat splits that edge, so past 0.903 the ions fly out toward the camera and past 0.915 sideways, at 0.95 swinging 1.8 times wider every RF period, and the new ions the oven loads at the ends race inward and burst into smears. Turned back, the trap refills and cools into a crystal again, and a quick turn from string to zigzag can freeze in a kink where the zigzag changes sides.\n\nconst W = 64, H = 128, CX = 31.5, CY = 63.5, NMAX = 40;\nconst { floor, min, max, abs, sqrt, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: lengths in LEDs, time tau = Omega t / 2, mass 1. In tau the radial\n// equation is the Mathieu equation x'' + (a - 2 q cos 2 tau) x = F, and one\n// RF period is pi. The step is a fortieth of it; velocity Verlet at that\n// step puts the edge of stability at q = 0.9074 instead of 0.9081. With a\n// twentieth the edge was 0.905 and a string of 16 ions melted at q = 0.9.\n// RATE is tau per second at Speed 1.\nconst DT = PI / 40, RATE = 60;\n// Half the length of a string of N ions in a harmonic well, for a Coulomb\n// constant and an axial frequency of 1, from a relaxation run at N = 12, 16\n// ... 48. The axial frequency for N ions is then chosen so that the string\n// would reach SPAN LEDs either side of the centre.\nconst HALF = [3.2187, 3.8175, 4.3281, 4.7778, 5.1825, 5.5522, 5.8939, 6.2125, 6.5141, 6.7941];\nconst SPAN = 61;\n// The Coulomb constant, in LED^3 / tau^2. With it the axial frequency for\n// 16 ions is 0.050, and Enzer's critical ratio of radial to axial frequency,\n// 0.73 N^0.86 = 7.9, asks for a radial frequency of 0.40, which the RF gives\n// at q = 0.54. The simulated crystal straightens between 0.50 and 0.54.\nconst KC = 10.2;\n// A small static quadrupole, a = -0.007 across the panel and +0.007 toward\n// the camera, makes the picture plane the weaker radial direction, so the\n// zigzag lies flat across the panel. At 0.005 it twisted out of the plane.\nconst AS = 0.007;\n// Doppler cooling damps every bright ion's velocity at GAMMA per tau, and\n// the recoil of the scattered photons heats it toward TEMP. The dark ions\n// scatter nothing and are cooled only through their neighbours.\nconst GAMMA = 0.05, TEMP = 0.0012;\n// Background gas: one ion takes a hard knock every COLL tau on average, 4.2 s\n// at Speed 2, and the crystal melts round it and freezes again. An ion\n// RLOST from the axis has reached an electrode. While the trap holds fewer\n// ions than it should, the oven loads one every LOAD tau, at alternate ends.\nconst COLL = 500, KICK = 5, RLOST = 38, LOAD = 4;\n\n// A gamma of 0.75 on the way out lifts the faint smears of hot ions.\nconst GAMMA_LUT = new Uint8Array(1024);\nfor (let i = 0; i \u003c 1024; i++) GAMMA_LUT[i] = Math.round(255 * (i / 1023) ** 0.75);\n\nfunction halfOf(n) {\n  const f = cl((n - 12) / 4, 0, HALF.length - 1.001), i = floor(f);\n  return HALF[i] + (HALF[i + 1] - HALF[i]) * (f - i);\n}\n\n// The fluorescence colour, hue h in turns, with orange and yellow (0.03\n// to 0.2) skipped since they read brown and olive when dim.\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 0.83;\n  if (h >= 0.03) h += 0.17;\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nconst gauss = () => {\n  let u = 1 - Math.random();\n  return sqrt(-2 * Math.log(u)) * cos(2 * PI * Math.random());\n};\n\nexport function setup(params) {\n  const S = (params.s = {\n    n: 0, target: 16, q: 0.3, tau: 0, wz: 0.047, ws: 0.047, nextColl: COLL, loadAt: 0, end: 1,\n    x: new Float64Array(NMAX), y: new Float64Array(NMAX), z: new Float64Array(NMAX),\n    vx: new Float64Array(NMAX), vy: new Float64Array(NMAX), vz: new Float64Array(NMAX),\n    ax: new Float64Array(NMAX), ay: new Float64Array(NMAX), az: new Float64Array(NMAX),\n    dark: new Uint8Array(NMAX),\n    // Per frame sums of each ion's position, the camera's exposure.\n    sx: new Float64Array(NMAX), sxx: new Float64Array(NMAX), sy: new Float64Array(NMAX), syy: new Float64Array(NMAX),\n    sz: new Float64Array(NMAX), sn: new Float64Array(NMAX),\n    rgb: new Float32Array(W * H * 3), gx: new Float32Array(W), hx: new Float32Array(W), gy: new Float32Array(H), hy: new Float32Array(H),\n    hue: 0, c: [0, 0, 0], w: [0, 0, 0], started: false, loaded: 0, darkSet: false,\n  });\n  return S;\n}\n\nfunction axialFor(n) {\n  return sqrt(KC) * (halfOf(n) / SPAN) ** 1.5;\n}\n\nfunction addIon(S, y, hot, dark) {\n  const i = S.n++;\n  S.x[i] = gauss() * hot;\n  S.z[i] = gauss() * hot;\n  S.y[i] = y;\n  const v = hot * 0.06;\n  S.vx[i] = gauss() * v;\n  S.vz[i] = gauss() * v;\n  S.vy[i] = gauss() * v;\n  S.dark[i] = dark ? 1 : 0;\n  S.sx[i] = S.sxx[i] = S.sy[i] = S.syy[i] = S.sz[i] = S.sn[i] = 0;\n  return i;\n}\n\nfunction removeIon(S, i) {\n  const j = --S.n;\n  if (i === j) return;\n  for (const a of [S.x, S.y, S.z, S.vx, S.vy, S.vz, S.ax, S.ay, S.az, S.dark, S.sx, S.sxx, S.sy, S.syy, S.sz, S.sn]) a[i] = a[j];\n}\n\nfunction darkCount(S) {\n  let d = 0;\n  for (let i = 0; i \u003c S.n; i++) d += S.dark[i];\n  return d;\n}\n\n// The acceleration of every ion at phase tau.\nfunction forces(S, tau) {\n  const n = S.n, x = S.x, y = S.y, z = S.z, ax = S.ax, ay = S.ay, az = S.az;\n  const rf = 2 * S.q * cos(2 * tau), w2 = S.wz * S.wz;\n  const kx = -w2 / 2 - AS - rf, kz = -w2 / 2 + AS + rf;\n  for (let i = 0; i \u003c n; i++) {\n    ax[i] = -kx * x[i];\n    az[i] = -kz * z[i];\n    ay[i] = -w2 * y[i];\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const xi = x[i], yi = y[i], zi = z[i];\n    let fx = 0, fy = 0, fz = 0;\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = xi - x[j], dy = yi - y[j], dz = zi - z[j];\n      const r2 = dx * dx + dy * dy + dz * dz + 0.05, f = KC / (r2 * sqrt(r2));\n      fx += f * dx;\n      fy += f * dy;\n      fz += f * dz;\n      ax[j] -= f * dx;\n      ay[j] -= f * dy;\n      az[j] -= f * dz;\n    }\n    ax[i] += fx;\n    ay[i] += fy;\n    az[i] += fz;\n  }\n}\n\nfunction step(S) {\n  const n = S.n, h = DT;\n  for (let i = 0; i \u003c n; i++) {\n    S.vx[i] += 0.5 * h * S.ax[i];\n    S.vy[i] += 0.5 * h * S.ay[i];\n    S.vz[i] += 0.5 * h * S.az[i];\n    S.x[i] += h * S.vx[i];\n    S.y[i] += h * S.vy[i];\n    S.z[i] += h * S.vz[i];\n  }\n  S.tau += h;\n  forces(S, S.tau);\n  const kick = sqrt(2 * GAMMA * TEMP * h);\n  for (let i = 0; i \u003c n; i++) {\n    S.vx[i] += 0.5 * h * S.ax[i];\n    S.vy[i] += 0.5 * h * S.ay[i];\n    S.vz[i] += 0.5 * h * S.az[i];\n    if (S.dark[i]) continue;\n    // Doppler cooling and the recoil of the scattered photons.\n    const g = 1 - GAMMA * h;\n    S.vx[i] = S.vx[i] * g + kick * (Math.random() - 0.5) * 3.46;\n    S.vy[i] = S.vy[i] * g + kick * (Math.random() - 0.5) * 3.46;\n    S.vz[i] = S.vz[i] * g + kick * (Math.random() - 0.5) * 3.46;\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    S.sx[i] += S.x[i];\n    S.sxx[i] += S.x[i] * S.x[i];\n    S.sy[i] += S.y[i];\n    S.syy[i] += S.y[i] * S.y[i];\n    S.sz[i] += S.z[i];\n    S.sn[i]++;\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 16, 0.3], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1], 0.2, 3);\n  S.target = cl(Math.round(kv[2]), 16, NMAX);\n  S.q = cl(kv[3], 0.3, 0.95);\n  if (!S.started) {\n    // The trap opens empty and the oven fills it from the ends.\n    S.started = true;\n    S.wz = S.ws = axialFor(S.target);\n  }\n  // The end caps follow the ion count with a time constant of 40 tau.\n  S.ws = axialFor(S.target);\n  for (let i = 0; i \u003c S.n; i++) S.sx[i] = S.sxx[i] = S.sy[i] = S.syy[i] = S.sz[i] = S.sn[i] = 0;\n  const steps = min(120, Math.round((d * speed * RATE) / DT));\n  for (let k = 0; k \u003c steps; k++) {\n    S.wz += (S.ws - S.wz) * 0.002;\n    step(S);\n    // Losses: an ion that has reached an electrode or left past an end cap.\n    for (let i = S.n - 1; i >= 0; i--)\n      if (S.x[i] * S.x[i] + S.z[i] * S.z[i] > RLOST * RLOST || abs(S.y[i]) > 90 || !(abs(S.x[i]) \u003c 1e6)) {\n        removeIon(S, i);\n        if (S.loadAt \u003c S.tau) S.loadAt = S.tau + LOAD;\n      }\n    if (S.n > S.target && S.tau > S.loadAt) {\n      // Fewer ions wanted: the end cap opens for the outermost one.\n      let o = 0;\n      for (let i = 1; i \u003c S.n; i++) if (abs(S.y[i]) > abs(S.y[o])) o = i;\n      removeIon(S, o);\n      S.loadAt = S.tau + LOAD * 0.5;\n    } else if (S.n \u003c S.target && S.tau > S.loadAt) {\n      // An atom is ionised on the axis at one end and comes in at 0.6 LEDs\n      // per tau. After a loss a new ion is dark one time in ten while the\n      // crystal holds fewer than two.\n      S.end = -S.end;\n      const dk = S.loaded >= S.target && darkCount(S) \u003c 2 && Math.random() \u003c 0.1;\n      S.loaded++;\n      const i = addIon(S, S.end * (SPAN * 0.95), 0.1, dk);\n      S.vy[i] = -S.end * 0.6;\n      S.loadAt = S.tau + LOAD;\n    }\n    // When the first load is in, the two ions nearest two fifths of the way\n    // up and two fifths of the way down go dark, as after a reaction with the\n    // background gas, so the gaps open inside the crystal.\n    if (!S.darkSet && S.n === S.target) {\n      S.darkSet = true;\n      for (const yd of [-0.4 * SPAN, 0.4 * SPAN]) {\n        let b = 0;\n        for (let i = 1; i \u003c S.n; i++) if (abs(S.y[i] - yd) \u003c abs(S.y[b] - yd)) b = i;\n        S.dark[b] = 1;\n      }\n    }\n    if (S.tau > S.nextColl) {\n      S.nextColl = S.tau - COLL * Math.log(1 - Math.random());\n      if (S.n) {\n        const i = floor(Math.random() * S.n);\n        const ux = gauss(), uy = gauss(), uz = gauss(), u = sqrt(ux * ux + uy * uy + uz * uz) || 1;\n        S.vx[i] += (KICK * ux) / u;\n        S.vy[i] += (KICK * uy) / u;\n        S.vz[i] += (KICK * uz) / u;\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, gx = S.gx, hx = S.hx, gy = S.gy, hy = S.hy, c = S.c, w = S.w, q = S.q;\n  // Each frame keeps 40% of the last one, an exposure a little longer than a frame.\n  for (let o = 0; o \u003c rgb.length; o++) rgb[o] *= 0.4;\n  for (let i = 0; i \u003c S.n; i++) {\n    if (S.dark[i] || !S.sn[i]) continue;\n    const n = S.sn[i], mx = S.sx[i] / n, my = S.sy[i] / n, mz = S.sz[i] / n;\n    // The spread over the exposure: secular motion as measured, and at\n    // least the micromotion an ion at mx has, amplitude q mx / 2.\n    const mm = (q * mx) / 2;\n    const vxx = max(S.sxx[i] / n - mx * mx, (mm * mm) / 2), vyy = max(0, S.syy[i] / n - my * my);\n    // Depth: toward the camera is brighter, bigger and paler.\n    const dz = cl(mz / 10, -1, 1);\n    const s0 = 0.8 + 0.18 * dz, sh = 3.3 + 0.5 * dz;\n    const sx = sqrt(s0 * s0 + vxx), sy = sqrt(s0 * s0 + vyy), tx = sqrt(sh * sh + vxx), ty = sqrt(sh * sh + vyy);\n    const spread = (s0 * s0) / (sx * sy);\n    const lum = (0.72 + 0.28 * dz) * spread ** 0.25;\n    hsv(0.46 + S.hue - 0.05 * dz, 0.85, 1, c);\n    hsv(0.46 + S.hue - 0.05 * dz, 0.3 - 0.15 * dz, 1, w);\n    const px = mx + CX, py = my + CY;\n    const x0 = max(0, floor(px - 3 * tx)), x1 = min(W - 1, Math.ceil(px + 3 * tx));\n    const y0 = max(0, floor(py - 3 * ty)), y1 = min(H - 1, Math.ceil(py + 3 * ty));\n    if (x0 > x1 || y0 > y1) continue;\n    for (let X = x0; X \u003c= x1; X++) {\n      const e = X - px;\n      gx[X] = exp((-e * e) / (2 * sx * sx));\n      hx[X] = exp((-e * e) / (2 * tx * tx));\n    }\n    for (let Y = y0; Y \u003c= y1; Y++) {\n      const e = Y - py;\n      gy[Y] = exp((-e * e) / (2 * sy * sy));\n      hy[Y] = exp((-e * e) / (2 * ty * ty));\n    }\n    const A = 0.75 * lum, B = 0.21 * lum;\n    for (let Y = y0; Y \u003c= y1; Y++)\n      for (let X = x0; X \u003c= x1; X++) {\n        const core = A * gx[X] * gy[Y], halo = B * hx[X] * hy[Y], o = (Y * W + X) * 3;\n        rgb[o] += core * w[0] + halo * c[0];\n        rgb[o + 1] += core * w[1] + halo * c[1];\n        rgb[o + 2] += core * w[2] + halo * c[2];\n      }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, GAMMA_LUT[min(1023, (rgb[o] * 1023) | 0)], GAMMA_LUT[min(1023, (rgb[o + 1] * 1023) | 0)], GAMMA_LUT[min(1023, (rgb[o + 2] * 1023) | 0)]);\n}\n","taylor-unmixing":"// ===== Patternflow pattern =====\n// Title:   Taylor Unmixing\n// Family:  sim\n// Idea:    Round drops of dye in a very viscous fluid between two walls are sheared by plane Couette flow into thin streaks that wrap round the panel many times and lay down a fine slanted lattice of colours, then the walls run back the same distance and the drops come back where they started, sharp when there is no diffusion and as fainter vertical smears when there is.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: plane Couette flow (Maurice Couette, 1890), shear dispersion (G. I. Taylor, 1953), kinematic reversibility of Stokes flow shown with dye in glycerine (G. I. Taylor, film \"Low Reynolds Number Flows\", 1966), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Turns=2..8, Diffusion=0..1\n//\n// Knob 1: Hue. Moves the seven dyes round the wheel together. At 0 they are lime, green, cyan, azure, blue, violet and pink; the seven sit evenly round the wheel, so every 1/7 of the knob the same set comes back with the colours handed on, and in between one dye passes through red. The wheel skips orange and yellow, which read brown and olive where a streak thins out.\n// Knob 2: Speed. At 2 one cycle takes 10.4 seconds: 0.8 s at rest, 3.4 s of shearing, 0.6 s held, 3.4 s back, 1.4 s with the drops returned and 0.8 s while they fade and fresh drops take their place. At 0.2 it takes 104 s, at 3 it takes 6.9 s. Diffusion runs on the same clock, so Speed does not change how blurred the drops come back.\n// Knob 3: Turns. How far each wall travels before it turns back, in panel heights: 2 to 8, so 256 to 1024 rows, the two walls going opposite ways. At 2 the shear across the 60 columns of fluid reaches 8.5, a drop 29 columns wide becomes a streak 247 rows long that wraps the panel almost twice, and its lines lie 15 columns apart; at 5 the shear reaches 21 and the lines 6 apart; at 8 it reaches 34, a drop wraps the panel 7.7 times and its lines lie 3.8 columns apart. The travel follows the knob over about half a second.\n// Knob 4: Diffusion. The dye's diffusivity D = 0.6 k^3 LEDs squared per second. At 0 the drops return exactly, and at the opening 0.06 (D = 0.00013) they look the same. At 0.5 (D = 0.075) a drop comes back 1.4 times as tall at 2 turns and 4.6 times as tall at 8; at 1 (D = 0.6) 2.8 and 10 times as tall, with a third and a tenth of its brightness, and at 8 turns the dye has mixed into soft columns. The streaks blur first: at 8 turns a streak is 0.2 LED thick and diffusion crosses that almost at once, which is why a little D spoils the return.\n\nconst W = 64, H = 128, FL = 2, FR = 62, WF = FR - FL;\nconst { floor, ceil, min, max, abs, sqrt, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\n// The phases of one cycle, in seconds at Speed 2.\nconst T_REST = 0.8, T_FWD = 3.4, T_HOLD = 0.6, T_BACK = 3.4, T_BACKREST = 1.4, T_SWAP = 0.8;\nconst T_CYCLE = T_REST + T_FWD + T_HOLD + T_BACK + T_BACKREST + T_SWAP;\n// The film opens in the middle of the forward stroke, so the first second is\n// already streaks and the drops come back at 4.9 s.\nconst T_OPEN = T_REST + 0.75 * T_FWD;\nconst NB = 7;\n// Each pixel is read as a small Gaussian of this variance, so a streak\n// thinner than an LED dims in proportion instead of flickering.\nconst PIX = 0.1;\n// Dye hues skip orange to lime: wheel(h) runs lime, green, cyan, blue, violet, pink, red.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Wall travel S at cycle time tau, as a fraction of the full travel.\nfunction travel(tau) {\n  if (tau \u003c T_REST) return 0;\n  tau -= T_REST;\n  if (tau \u003c T_FWD) return (1 - cos((PI * tau) / T_FWD)) / 2;\n  tau -= T_FWD;\n  if (tau \u003c T_HOLD) return 1;\n  tau -= T_HOLD;\n  if (tau \u003c T_BACK) return (1 + cos((PI * tau) / T_BACK)) / 2;\n  return 0;\n}\n\n// A fresh set of drops: seven rows down the panel, each in one of three\n// lanes across it, no two neighbours in the same lane.\nfunction drops() {\n  const set = [], hues = [0, 1, 2, 3, 4, 5, 6];\n  for (let i = NB - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = hues[i];\n    hues[i] = hues[j];\n    hues[j] = t;\n  }\n  const lanes = [13, 30, 47];\n  let lane = floor(Math.random() * 3);\n  const y0 = Math.random() * H;\n  for (let i = 0; i \u003c NB; i++) {\n    lane = (lane + 1 + floor(Math.random() * 2)) % 3;\n    const s = 5 + Math.random() * 1.6;\n    set.push({\n      x: lanes[lane] + (Math.random() - 0.5) * 5,\n      y: y0 + (i * H) / NB + (Math.random() - 0.5) * 4,\n      s0: s * s, sxx: s * s, sxy: 0, syy: s * s, hue: hues[i] / NB,\n    });\n  }\n  return set;\n}\n\n// One step of the covariance under a shear g = dGamma over a time h with\n// diffusivity D. For a shear rate constant over the step this is exact:\n// Sigma' = F Sigma F^T + 2 D integral of F(s) F(s)^T, F = [[1, 0], [g, 1]].\nfunction shearStep(b, g, h, D) {\n  const sxx = b.sxx, sxy = b.sxy, syy = b.syy;\n  b.syy = syy + 2 * g * sxy + g * g * sxx + 2 * D * (h + (g * g * h) / 3);\n  b.sxy = sxy + g * sxx + D * g * h;\n  b.sxx = sxx + 2 * D * h;\n}\n\nexport function setup(params) {\n  params.s = {\n    tau: -1, smax: 0, S: 0, Sprev: 0, set: drops(), old: null,\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0], hue: 0,\n  };\n}\n\nfunction advance(S, dtau, D) {\n  // Small steps, so the drops keep up with the walls at full speed.\n  const n = max(1, ceil(dtau / 0.02));\n  for (let k = 0; k \u003c n; k++) {\n    const t0 = S.tau, t1 = S.tau + dtau / n;\n    const cyc = floor(t1 / T_CYCLE) > floor(t0 / T_CYCLE);\n    const s1 = (cyc ? 0 : travel(t1 - floor(t1 / T_CYCLE) * T_CYCLE)) * S.smax;\n    // The strain is taken from the travel actually made, so the total comes\n    // back to exactly 0 with the walls even if Turns moved on the way.\n    const g = (2 * (s1 - S.S)) / WF, h = t1 - t0;\n    for (const b of S.set) shearStep(b, g, h, D);\n    if (S.old) for (const b of S.old) shearStep(b, 0, h, D);\n    S.tau = t1;\n    S.S = s1;\n    // The swap: the returned drops fade out while new ones are laid down.\n    const ph = S.tau - floor(S.tau / T_CYCLE) * T_CYCLE;\n    if (!S.old && ph >= T_CYCLE - T_SWAP) {\n      S.old = S.set;\n      S.set = drops();\n    }\n    if (cyc) S.old = null;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), turns = cl(kv[2], 2, 8), k4 = cl(kv[3], 0, 1);\n  const D = 0.6 * k4 * k4 * k4;\n  S.Sprev = S.S;\n  if (S.tau \u003c 0) {\n    // First frame: run the cycle from its start to the opening point, so\n    // the streaks carry the diffusion they would have gathered.\n    S.smax = turns * H;\n    S.tau = 0;\n    advance(S, T_OPEN, D);\n    S.Sprev = S.S;\n    return;\n  }\n  // The travel follows the knob over about half a second, so the walls\n  // never jump. The drops still come home, because S returns to 0.\n  S.smax += (turns * H - S.smax) * min(1, d * 2.5);\n  advance(S, (d * speed) / 2, D);\n}\n\nfunction drawSet(S, set, fade) {\n  const rgb = S.rgb, c = S.c;\n  for (const b of set) {\n    const cx = b.x, cy = b.y + (2 * b.x / WF - 1) * S.S;\n    const sxx = b.sxx + PIX, sxy = b.sxy, syy = b.syy + PIX;\n    const det = sxx * syy - sxy * sxy, det0 = (b.s0 + PIX) * (b.s0 + PIX);\n    // Dye is conserved: the peak falls as the patch spreads.\n    const amp = sqrt(det0 / det) * fade;\n    const v = det / sxx, sv = sqrt(v), slope = sxy / sxx;\n    const R = min(H * 2, ceil(4.2 * sv));\n    hsv(wheel(b.hue + S.hue), 0.85, 1, c);\n    for (let col = FL; col \u003c FR; col++) {\n      const dx = col - FL + 0.5 - cx, wx = amp * exp((-0.5 * dx * dx) / sxx);\n      if (wx \u003c 0.004) continue;\n      let mu = cy + slope * dx - 0.5;\n      mu -= floor(mu / H) * H;\n      const r0 = floor(mu) - R;\n      // Gaussian down the column by recurrence: g(j+1) = g(j) e1, e1 *= e2.\n      let dy = r0 - mu, g = wx * exp((-0.5 * dy * dy) / v), e1 = exp(-(2 * dy + 1) / (2 * v));\n      const e2 = exp(-1 / v);\n      for (let r = r0; r \u003c= r0 + 2 * R + 1; r++) {\n        if (g > 0.003) {\n          const o = ((((r % H) + H) % H) * W + col) * 3;\n          rgb[o] += c[0] * g;\n          rgb[o + 1] += c[1] * g;\n          rgb[o + 2] += c[2] * g;\n        }\n        g *= e1;\n        e1 *= e2;\n      }\n    }\n  }\n}\n\nfunction rings(S, set, w) {\n  if (w \u003c 0.01) return;\n  const rgb = S.rgb, c = S.c;\n  for (const b of set) {\n    const r = 2.3 * sqrt(b.s0);\n    hsv(wheel(b.hue + S.hue), 0.6, 1, c);\n    for (let yy = floor(b.y - r - 2); yy \u003c= b.y + r + 2; yy++)\n      for (let xx = max(FL, floor(FL + b.x - r - 2)); xx \u003c= min(FR - 1, FL + b.x + r + 2); xx++) {\n        const dx = xx - FL + 0.5 - b.x, dy = yy + 0.5 - b.y, e = abs(sqrt(dx * dx + dy * dy) - r);\n        if (e >= 0.9) continue;\n        const v = 0.16 * w * (1 - e / 0.9), o = ((((yy % H) + H) % H) * W + xx) * 3;\n        rgb[o] += c[0] * v;\n        rgb[o + 1] += c[1] * v;\n        rgb[o + 2] += c[2] * v;\n      }\n  }\n}\n\n// Wall ticks: one every 8 rows, a longer brighter one every 32, carried by\n// the wall and smeared over the frame's travel.\nfunction tick(y) {\n  const m = y - floor(y / 32) * 32, u = m - floor(m / 8) * 8;\n  const big = m \u003c 8;\n  return cl(1 - abs(u - (big ? 1.5 : 1)) / (big ? 1.8 : 1.1), 0, 1) * (big ? 1 : 0.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  // The dark fluid.\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    rgb[o] = 0.008;\n    rgb[o + 1] = 0.015;\n    rgb[o + 2] = 0.034;\n  }\n  const ph = S.tau - floor(S.tau / T_CYCLE) * T_CYCLE;\n  // The swap: the returned drops fade out, then the fresh ones fade in.\n  const u = S.old ? cl((ph - (T_CYCLE - T_SWAP)) / T_SWAP, 0, 1) : 1;\n  const fo = 1 - sm(u / 0.5), fn = sm((u - 0.4) / 0.6);\n  if (S.old) drawSet(S, S.old, fo);\n  drawSet(S, S.set, fn);\n  // Where each drop started, as a faint ring at 2.3 sigma, the edge the\n  // drop shows at. It comes up over the last 40% of the way back and goes\n  // in the first 30% of the next stroke.\n  let ring = 0;\n  if (ph \u003c T_REST) ring = 1;\n  else if (ph \u003c T_REST + 0.3 * T_FWD) ring = 1 - (ph - T_REST) / (0.3 * T_FWD);\n  else if (ph > T_REST + T_FWD + T_HOLD + 0.6 * T_BACK) ring = min(1, (ph - (T_REST + T_FWD + T_HOLD + 0.6 * T_BACK)) / (0.4 * T_BACK));\n  if (S.old) rings(S, S.old, ring * fo);\n  rings(S, S.set, ring * fn);\n  // The walls: left moves by -S, right by +S.\n  const wc = hsv(0.6 + S.hue * 0.2, 0.2, 1, [0, 0, 0]);\n  const ds = S.S - S.Sprev, n = min(40, max(1, ceil(abs(ds) * 1.5)));\n  for (let r = 0; r \u003c H; r++) {\n    let tl = 0, tr = 0;\n    for (let k = 0; k \u003c n; k++) {\n      const s = S.Sprev + (ds * (k + 0.5)) / n;\n      tl += tick(r + 0.5 + s);\n      tr += tick(r + 0.5 - s);\n    }\n    tl /= n;\n    tr /= n;\n    for (const [x, t] of [[0, tl], [1, tl], [62, tr], [63, tr]]) {\n      const o = (r * W + x) * 3, v = 0.16 + 0.95 * t;\n      rgb[o] = wc[0] * v;\n      rgb[o + 1] = wc[1] * v;\n      rgb[o + 2] = wc[2] * v;\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const x = p % W, y = (p / W) | 0;\n    if (x \u003c FL || x >= FR) display.setPixel(x, y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n    else display.setPixel(x, y, (255 * (1 - exp(-2.2 * rgb[o]))) | 0, (255 * (1 - exp(-2.2 * rgb[o + 1]))) | 0, (255 * (1 - exp(-2.2 * rgb[o + 2]))) | 0);\n  }\n}\n","thomson-kink":"// ===== Patternflow pattern =====\n// Title:   Thomson Kink\n// Family:  wave\n// Idea:    A charge runs up and down the middle of the panel and keeps reversing or stopping dead, every change sends out a sphere of news at the speed of light, and each field line is a chain of straight spokes, each aimed at where the charge would now be had it kept the velocity it had between two changes, joined by bright sideways kinks across the expanding shells.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: field of a uniformly moving charge (Oliver Heaviside, 1888), radiation as a kink in the field lines (J. J. Thomson, 1904), Purcell's drawing of the kink (Edward Purcell, 1965), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=12..32, Velocity=0.3..0.9\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the regions where the news says the charge is moving down are blue, moving up green and standing still near black, the shells and kinks rose and the spokes white; at 0.25 the regions are violet and teal with aqua kinks, at 0.5 green and blue with cyan-blue kinks. The wheel runs from green to magenta and skips red, orange and lime, which read maroon, brown and olive when dim.\n// Knob 2: Speed. 2 is real time with light at 36 LEDs a second, so a shell born in the middle reaches the top and bottom rows in 1.8 s while the charge changes its mind every 0.32 to 0.6 s, and four or five shells are out at once; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Lines. 12 to 32 field lines, an even number, spaced evenly in the angle they would have round a charge at rest: every 30 degrees at 12, every 15 at 24, every 11 at 32. Each keeps that label in every region, so it stays one line through all the kinks.\n// Knob 4: Velocity. The charge's speed as a fraction of light, 0.3 to 0.9. At 0.3 the charge moves 11 LEDs a second, and a reversal puts the two pieces of the 75 degree line 18 LEDs apart along a shell 30 LEDs out; at 0.6 the kink of the 75 degree line runs 72 degrees round its shell and the shells read as rings; at 0.9 the charge moves 32 LEDs a second, gamma is 2.3, the spokes crowd towards the horizontal, each shell is a bright ring of lines running along it and the shells pile up in front of the charge. A new speed starts at the charge's next change and spreads out with the news.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Light in LEDs per second of the simulation, the axis the charge runs\n// on, and how far it may stray from the middle row.\nconst C = 36, XC = 32, YC = 64, ROAM = 36;\n// The kink shell's thickness in LEDs: the change takes 2.2 / 36 = 0.06 s.\nconst SHELL = 2.2;\n// A shell is forgotten once it is wider than this; no LED is that far from\n// any place the charge has been.\nconst RFORGET = 125;\n// Seconds between changes, and the share of changes that stop the charge.\nconst GAP0 = 0.32, GAP1 = 0.6, STOP = 0.3;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel from green through blue and violet to\n// magenta, which skips red, orange and lime: dim, they read maroon, brown\n// and olive.\nconst wheel = (h) => 0.3 + 0.56 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    T: 0, ready: false, beta: 0.3, hue: 0, n: 12,\n    // The changes, oldest first: time, the row where it happened, and the\n    // velocity after it, in LEDs a second (positive is down the panel).\n    ch: [], u0: 0, next: 0,\n    acc: new Float32Array(W * H * 3),\n    col: [[0, 0, 0], [0, 0, 0], [0, 0, 0]], kc: [0, 0, 0], lc: [0, 0, 0], sc: [0, 0, 0], c: [0, 0, 0],\n    sh: [],\n  };\n}\n\n// Where the charge is at time t, from the last change before it.\nfunction posAt(S, t) {\n  const ch = S.ch;\n  for (let i = ch.length - 1; i >= 0; i--) if (ch[i].t \u003c= t) return ch[i].p + ch[i].u * (t - ch[i].t);\n  return YC + S.u0 * (t - (ch.length ? ch[0].t : t));\n}\nconst velAt = (S) => (S.ch.length ? S.ch[S.ch.length - 1].u : S.u0);\n\n// The charge changes its mind at time t: it reverses, or stops dead, or\n// sets off again, now with the knob's speed. A change that would carry it\n// past the end of its run turns it round instead.\nfunction change(S, t) {\n  const y = posAt(S, t), u = velAt(S), v = S.beta * C;\n  const gap = GAP0 + (GAP1 - GAP0) * Math.random();\n  let nu;\n  if (u !== 0) nu = Math.random() \u003c STOP ? 0 : -Math.sign(u) * v;\n  else nu = (Math.random() \u003c 0.7 ? (y \u003c YC ? 1 : -1) : y \u003c YC ? -1 : 1) * v;\n  if (abs(y + nu * gap - YC) > ROAM) nu = y + nu * gap > YC ? -v : v;\n  if (u === 0 && nu === 0) nu = v;\n  S.ch.push({ t, p: y, u: nu });\n  S.next = t + gap;\n}\n\nfunction advance(S, T) {\n  while (S.next \u003c= T) change(S, S.next);\n  // Forget the shells that have left the panel, and with them the\n  // velocity the charge had before them.\n  while (S.ch.length > 1 && C * (T - S.ch[0].t) > RFORGET) S.u0 = S.ch.shift().u;\n  S.T = T;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 12, 0.3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.n = 2 * Math.round(cl(kv[2], 12, 32) / 2);\n  S.beta = cl(kv[3], 0.3, 0.9);\n  if (!S.ready) {\n    // The first frame starts the charge 4 s in the past, so the panel\n    // opens full of shells.\n    S.ready = true;\n    S.u0 = S.beta * C;\n    S.ch = [];\n    S.next = -4;\n    advance(S, 0);\n  }\n  advance(S, S.T + (d * speed) / 2);\n}\n\n// The far end of a ray from s (inside the sphere) along unit d where it\n// leaves the sphere of centre (XC, cy) and radius r, as a distance.\nfunction exitRay(sx, sy, dx, dy, cy, r) {\n  const ox = sx - XC, oy = sy - cy, b = ox * dx + oy * dy, c = ox * ox + oy * oy - r * r;\n  return -b + sqrt(max(0, b * b - c));\n}\n\n// Antialiased line, added into the buffer. Each column (or row, for a\n// steep line) gets one unit of ink split between the two LEDs the line\n// passes between, scaled by the length of line it holds, so a polyline is\n// even along its whole length and its joints do not flare.\nfunction line(acc, x0, y0, x1, y1, c, a) {\n  // Clip to the panel with a one-LED margin.\n  let t0 = 0, t1 = 1;\n  const dx = x1 - x0, dy = y1 - y0;\n  const clip = (p, q) => {\n    if (p === 0) return q >= 0;\n    const r = q / p;\n    if (p \u003c 0) {\n      if (r > t1) return false;\n      if (r > t0) t0 = r;\n    } else {\n      if (r \u003c t0) return false;\n      if (r \u003c t1) t1 = r;\n    }\n    return true;\n  };\n  if (!clip(-dx, x0 + 1) || !clip(dx, W + 1 - x0) || !clip(-dy, y0 + 1) || !clip(dy, H + 1 - y0)) return;\n  const ax = x0 + dx * t0, ay = y0 + dy * t0, bx = x0 + dx * t1, by = y0 + dy * t1;\n  const steep = abs(by - ay) > abs(bx - ax);\n  let u0 = steep ? ay : ax, v0 = steep ? ax : ay, u1 = steep ? by : bx, v1 = steep ? bx : by;\n  if (u1 \u003c u0) {\n    let t = u0;\n    u0 = u1;\n    u1 = t;\n    t = v0;\n    v0 = v1;\n    v1 = t;\n  }\n  const du = u1 - u0;\n  if (du \u003c 1e-6) return;\n  const g = (v1 - v0) / du, k = a * sqrt(1 + g * g);\n  for (let ui = floor(u0); ui \u003c= floor(u1); ui++) {\n    const cover = min(u1, ui + 1) - max(u0, ui);\n    if (cover \u003c= 0) continue;\n    const um = (max(u0, ui) + min(u1, ui + 1)) / 2;\n    const vv = v0 + g * (um - u0) - 0.5, vi = floor(vv), f = vv - vi;\n    for (let s = 0; s \u003c 2; s++) {\n      const p = vi + s, w = (s ? f : 1 - f) * cover * k;\n      const x = steep ? p : ui, y = steep ? ui : p;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      acc[o] += c[0] * w;\n      acc[o + 1] += c[1] * w;\n      acc[o + 2] += c[2] * w;\n    }\n  }\n}\n\n// The kink across a shell centred on row cy, from the inner face to the\n// outer one. In a thin shell the line runs along the shell, so it is drawn\n// as a spiral piece round the shell's centre: angle and radius both go\n// linearly from one end to the other. A straight chord would cut through\n// the inside once the kink spans a wide angle, as it does above 0.5 c. It\n// is drawn twice, 0.9 LED apart, so it reads two LEDs wide.\nfunction arc(acc, cy, x0, y0, x1, y1, c, a) {\n  const r0 = sqrt((x0 - XC) ** 2 + (y0 - cy) ** 2), r1 = sqrt((x1 - XC) ** 2 + (y1 - cy) ** 2);\n  const f0 = Math.atan2(x0 - XC, y0 - cy), f1 = Math.atan2(x1 - XC, y1 - cy);\n  const steps = 1 + floor(max(abs(f1 - f0) * max(r0, r1), abs(r1 - r0)) / 1.5);\n  for (let side = -1; side \u003c= 1; side += 2) {\n    let px = 0, py = 0;\n    for (let s = 0; s \u003c= steps; s++) {\n      const f = f0 + ((f1 - f0) * s) / steps, r = r0 + ((r1 - r0) * s) / steps + side * 0.45;\n      const qx = XC + r * sin(f), qy = cy + r * cos(f);\n      if (s) line(acc, px, py, qx, qy, c, a * 0.7);\n      px = qx;\n      py = qy;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const acc = S.acc, T = S.T, ch = S.ch, m = ch.length, hue = S.hue;\n  acc.fill(0);\n  // The shells, newest last: centre row, radius, thickness, and for the\n  // region just inside each one the velocity and where the charge would\n  // now be had it kept that velocity.\n  const sh = S.sh;\n  sh.length = 0;\n  for (let i = 0; i \u003c m; i++) {\n    const r = C * (T - ch[i].t), b = abs(ch[i].u) / C, ub = i ? ch[i - 1].u : S.u0;\n    sh.push({\n      cy: ch[i].p, r, w: min(SHELL, 1.2 * r * (1 - b)), u: ch[i].u, s: ch[i].p + ch[i].u * (T - ch[i].t),\n      jump: abs(ch[i].u - ub) / (2 * C),\n    });\n  }\n  // Region i lies inside shell i and outside shell i + 1; region -1 lies\n  // outside every shell and holds the velocity before the oldest change.\n  const sOut = m ? ch[0].p + S.u0 * (T - ch[0].t) : posAt(S, T);\n  // Tints: news of moving down, moving up, standing.\n  const tint = S.col;\n  hsv(wheel(0.59 + hue), 0.9, 0.25, tint[0]);\n  hsv(wheel(0.14 + hue), 0.85, 0.2, tint[1]);\n  hsv(wheel(0.36 + hue), 0.4, 0.09, tint[2]);\n  const glow = hsv(wheel(0.99 + hue), 0.65, 1, S.sc);\n  for (let y = 0; y \u003c H; y++) {\n    const py = y + 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5 - XC, o = (y * W + x) * 3;\n      let reg = -1, g = 0;\n      for (let i = 0; i \u003c m; i++) {\n        const e = sh[i], dy = py - e.cy, dd = sqrt(px * px + dy * dy);\n        if (dd \u003c e.r) reg = i;\n        // A faint ring on every shell, brightest at right angles to the\n        // motion: the radiated energy goes as sin^2.\n        const q = (dd - e.r) / 1.6;\n        if (q > -3 && q \u003c 3 && dd > 0.1) {\n          const sn = px / dd;\n          g += e.jump * (0.12 + 0.88 * sn * sn) * exp(-q * q) * (40 / (40 + e.r));\n        }\n      }\n      const u = reg \u003c 0 ? S.u0 : sh[reg].u, tc = u > 0 ? tint[0] : u \u003c 0 ? tint[1] : tint[2];\n      acc[o] = tc[0] + glow[0] * g * 0.5;\n      acc[o + 1] = tc[1] + glow[1] * g * 0.5;\n      acc[o + 2] = tc[2] + glow[2] * g * 0.5;\n    }\n  }\n  // The field lines. Line j has the angle theta it would have round a\n  // charge at rest. In a region whose charge moves at beta it leaves that\n  // charge's extrapolated place at theta' with tan theta' = gamma tan theta\n  // (Heaviside's field, squeezed towards the plane across the motion).\n  const lc = hsv(wheel(0.45 + hue), 0.12, 1, S.lc), kc = hsv(wheel(0.99 + hue), 0.45, 1, S.kc);\n  const n = S.n;\n  const dirs = new Float32Array(2 * (m + 1));\n  for (let j = 0; j \u003c n; j++) {\n    const th = ((j + 0.5) * 2 * PI) / n, st = sin(th), ct = cos(th);\n    // Directions per region; slot m holds region -1.\n    for (let i = -1; i \u003c m; i++) {\n      const u = i \u003c 0 ? S.u0 : sh[i].u, b = abs(u) / C, gm = 1 / sqrt(1 - b * b);\n      const ex = gm * st, ey = ct, l = sqrt(ex * ex + ey * ey), k = i \u003c 0 ? 2 * m : 2 * i;\n      dirs[k] = ex / l;\n      dirs[k + 1] = ey / l;\n    }\n    // From the charge out: the newest region first.\n    let ax = XC, ay = m ? sh[m - 1].s : sOut;\n    const kink = 0.25 + 0.95 * abs(st);\n    for (let i = m - 1; i >= -1; i--) {\n      const k = i \u003c 0 ? 2 * m : 2 * i, dx = dirs[k], dy = dirs[k + 1];\n      const sx = XC, sy = i \u003c 0 ? sOut : sh[i].s;\n      // Where this region's spoke starts: at the charge, or where its ray\n      // leaves the outer face of the shell inside it.\n      let t0 = 0;\n      if (i \u003c m - 1) t0 = exitRay(sx, sy, dx, dy, sh[i + 1].cy, sh[i + 1].r + sh[i + 1].w / 2);\n      const bx0 = sx + dx * t0, by0 = sy + dy * t0;\n      if (i \u003c m - 1) arc(acc, sh[i + 1].cy, ax, ay, bx0, by0, kc, kink);\n      // Where it ends: the inner face of its own shell, or far off.\n      let t1 = i \u003c 0 ? 400 : exitRay(sx, sy, dx, dy, sh[i].cy, sh[i].r - sh[i].w / 2);\n      if (t1 \u003c t0) t1 = t0;\n      const ex = sx + dx * t1, ey = sy + dy * t1;\n      line(acc, bx0, by0, ex, ey, lc, 0.46);\n      ax = ex;\n      ay = ey;\n      if (ex \u003c -2 || ex > W + 2 || ey \u003c -2 || ey > H + 2) {\n        // Off the panel; the rest of the chain could still swing back in\n        // through a kink, so keep going only while it is near.\n        if (ex \u003c -40 || ex > W + 40 || ey \u003c -40 || ey > H + 40) break;\n      }\n    }\n  }\n  // The charge itself.\n  const qy = m ? sh[m - 1].s : sOut, cc = hsv(wheel(0.45 + hue), 0.15, 1, S.c);\n  for (let y = floor(qy - 4); y \u003c= qy + 4; y++)\n    for (let x = XC - 5; x \u003c XC + 5; x++) {\n      if (y \u003c 0 || y >= H) continue;\n      const dx = x + 0.5 - XC, dy = y + 0.5 - qy, d2 = dx * dx + dy * dy, v = 1.3 * exp(-d2 / 1.6) + 0.25 * exp(-d2 / 7);\n      const o = (y * W + x) * 3;\n      acc[o] += cc[0] * v;\n      acc[o + 1] += cc[1] * v;\n      acc[o + 2] += cc[2] * v;\n    }\n  // Where lines pile up, scale the LED down as a whole instead of clipping\n  // each channel, so a crowded kink stays rose and does not wash to white.\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const pk = max(1, acc[o], acc[o + 1], acc[o + 2]), k = 255 / pk;\n    display.setPixel(p % W, (p / W) | 0, (acc[o] * k) | 0, (acc[o + 1] * k) | 0, (acc[o + 2] * k) | 0);\n  }\n}\n","cornu-spiral":"// ===== Patternflow pattern =====\n// Title:   Cornu Spiral\n// Family:  line\n// Idea:    The Euler spiral curls its two arms into their eyes at (1/2, 1/2) and (-1/2, -1/2) across the top of the panel, a bright phasor chord slides along it from one eye or across a fixed arc of it, and the square of that chord's length, the light Fresnel diffraction puts at one point behind a straight edge or a slit, is traced below as a fringe profile and shown under it as the fringes themselves.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler spiral (Leonhard Euler, 1744), Fresnel integrals (Augustin-Jean Fresnel, 1818), Cornu spiral as a diffraction calculator (Marie Alfred Cornu, 1874), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Slit=0..1, Spread=0..1\n//\n// Knob 1: Hue. Turns the spiral and the light round the wheel together. At 0 the spiral is sky blue and the light, the chord, the profile and the fringes, gold; at 0.25 violet and green, at 0.5 red and blue, at 0.75 green and pink. The spiral skips the orange part of the wheel, which reads brown when dim.\n// Knob 2: Speed. At 2 the point on the screen crosses it in 5 s and comes back in 5 s, slowing at both ends, so the chord's free end runs up the spiral and back; at 0.2 a crossing takes 50 s, at 3 it takes 3.3 s.\n// Knob 3: Slit. At 0 a straight edge: the chord runs from the lower eye, the screen spans w = -2 to 5 in Fresnel units, the light rises from 0 in the shadow through 0.25 at the edge to 1.37 at w = 1.22 and rings down to 1, the dotted line. Above 0 a slit of width a = 0.6 + 7.4 (1 - K3)^1.5, the screen w = -6 to 6, and the chord joins the two ends of an arc a long: at 0.25 (a = 5.4) Fresnel fringes stand inside the slit's image, at 0.5 (a = 3.2) two humps of 1.42 with a dip to 1.05 between them, at 0.75 (a = 1.5) one peak of 1.08 with dark zeros at w = +-1.31, and at 1 (a = 0.6) a broad hump of only 0.18 whose zeros sit at w = +-3.33 = 2 / a, the Fraunhofer sinc squared. The profile is scaled so its highest point stands 42 rows tall.\n// Knob 4: Spread. The light's band of wavelengths. At 0 one wavelength in the colour of K1; at 1 white light, 650, 530 and 450 nm in red, green and blue, each with its own chord to its own point of the spiral, since w scales as one over the square root of the wavelength. Behind the straight edge the first fringe is then white with a blue rim toward the shadow and an orange one away from it, the next ones pass through pink, sky blue, yellow, violet and green, and past w = 4.4 they wash out to white. It opens at 0.06, close to one wavelength.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, cos, sin, exp, round, ceil, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without its orange and yellow, 0.03 to 0.17.\nconst wheel = (h) => 0.17 + (h - floor(h)) * 0.86;\n\n// C(t) and S(t), the Fresnel integrals of cos and sin of pi s^2 / 2 from 0\n// to t, tabled every 1/200 for |t| \u003c= 12 by Simpson's rule on eight\n// substeps a step: C(1) = 0.7798934004 and S(1) = 0.4382591474, and the\n// whole table is within 5e-11 of one built on 64 substeps. Between entries\n// the spiral is read as a straight chord, at most 0.005 LED off the curve\n// at t = 12, where at 39.5 LEDs a unit a coil is one LED across; everything\n// past that is the eye.\nconst TM = 12, TS = 200, NT = 2 * TM * TS + 1, I0 = TM * TS;\nconst FC = new Float64Array(NT), FS = new Float64Array(NT);\nlet tabled = false;\nfunction fresnel() {\n  if (tabled) return;\n  const h = 1 / TS, m = 8, q = h / m;\n  let c = 0, s = 0;\n  for (let i = 1; i \u003c= I0; i++) {\n    const a = (i - 1) * h;\n    let sc = 0, ss = 0;\n    for (let j = 0; j \u003c= m; j++) {\n      const u = a + j * q, ph = (PI * u * u) / 2, wt = j === 0 || j === m ? 1 : j & 1 ? 4 : 2;\n      sc += wt * cos(ph);\n      ss += wt * sin(ph);\n    }\n    c += (sc * q) / 3;\n    s += (ss * q) / 3;\n    FC[I0 + i] = c;\n    FS[I0 + i] = s;\n    FC[I0 - i] = -c;\n    FS[I0 - i] = -s;\n  }\n  tabled = true;\n}\nconst ZP = [0, 0];\nfunction Z(t) {\n  let f = (cl(t, -TM, TM) + TM) * TS, i = floor(f);\n  if (i > NT - 2) i = NT - 2;\n  f -= i;\n  ZP[0] = FC[i] + (FC[i + 1] - FC[i]) * f;\n  ZP[1] = FS[i] + (FS[i + 1] - FS[i]) * f;\n  return ZP;\n}\n\n// The spiral's plane on the panel: 39.5 LEDs a unit about (31.5, 30), S up.\n// C runs to +-0.780 (columns 0.7 to 62.3), S to +-0.714 (rows 1.8 to 58.2);\n// the eyes sit at (11.75, 49.75) and (51.25, 10.25).\nconst SC = 39.5, CX = 31.5, CY = 30;\nconst lx = (c) => CX + c * SC, ly = (s) => CY - s * SC;\n// The profile: I = 0 on row 112, the highest value 42 rows up; the screen\n// on rows 116 to 127, its LEDs as bright as the light that falls there.\nconst PB = 112, PH = 42, BAND = 116;\n// Wavelengths over the middle one at full Spread: 650 / 530 and 450 / 530.\nconst DL = [0.226, 0, -0.151], PRIM = [1, 0, 0, 0, 1, 0, 0, 0, 1];\n\nexport function setup(params) {\n  fresnel();\n  // The whole spiral once, as the length of curve under each LED.\n  const D = new Float32Array(W * 64);\n  const step = SC / TS;\n  for (let i = 0; i \u003c NT; i++) {\n    const x = lx(FC[i]), y = ly(FS[i]), ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    const put = (a, b, v) => {\n      if (a >= 0 && a \u003c W && b >= 0 && b \u003c 64) D[b * W + a] += v;\n    };\n    put(ix, iy, (1 - fx) * (1 - fy) * step);\n    put(ix + 1, iy, fx * (1 - fy) * step);\n    put(ix, iy + 1, (1 - fx) * fy * step);\n    put(ix + 1, iy + 1, fx * fy * step);\n  }\n  for (let p = 0; p \u003c D.length; p++) D[p] = min(1, D[p]) ** 0.75;\n  params.s = {\n    hue: 0, speed: 2, slit: 0, spread: 0.06, clock: 0, phase: 0, warm: false, D,\n    last: new Float32Array(W), xh: 0, I: new Float32Array(W * 3),\n    A: new Float32Array(W * 65), R: new Float32Array(N), G: new Float32Array(N), B: new Float32Array(N), c: new Float32Array(24),\n  };\n}\n\n// Where the screen point is, 0..1 across, from the sweep's phase: there and\n// back, slowing at both ends.\nconst ease = (ph) => {\n  const u = ph - 2 * floor(ph / 2), f = u \u003c 1 ? u : 2 - u;\n  return (1 - cos(PI * f)) / 2;\n};\n\nfunction mark(S, x0, x1, t) {\n  // Columns the head passed between x0 and x1 were lit at time t.\n  const a = max(0, ceil(min(x0, x1) - 1e-9)), b = min(W - 1, floor(max(x0, x1)));\n  for (let c = a; c \u003c= b; c++) S.last[c] = t;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.slit = cl(k[2], 0, 1);\n  S.spread = cl(k[3], 0, 1);\n  const rate = S.speed / 10; // crossings a second\n  if (!S.warm) {\n    // Open as if the head had just come back across the screen from the\n    // right, so the whole profile is already there, brightest at the left.\n    S.last.fill(-99);\n    let px = W - 0.5;\n    for (let i = 1; i \u003c= 200; i++) {\n      const ph = i / 200 - 1, x = ease(ph) * W - 0.5;\n      mark(S, px, x, ph / rate);\n      px = x;\n    }\n    S.xh = -0.5;\n    S.warm = true;\n  }\n  S.clock += d;\n  S.phase += d * rate;\n  const x = ease(S.phase) * W - 0.5;\n  mark(S, S.xh, x, S.clock);\n  S.xh = x;\n}\n\n// Accumulate light into the float frame: a bilinear splat, and lines as\n// splats every third of an LED so a line carries the same light per LED of\n// length at any slope.\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction line(S, x0, y0, x1, y1, v, c, o, ends) {\n  const L = hypot(x1 - x0, y1 - y0), n = max(1, ceil(L * 3)), w = (v * L) / n;\n  for (let i = ends ? 0 : 1; i \u003c= n; i++) splat(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, G, B, c, D, I, last } = S, sp = S.spread, slit = S.slit > 0;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  // Colours: 0 the dim spiral, 3 the lit arc, 6 the light, 9.. the three\n  // wavelengths, 18 white, 21 grey.\n  hsv(wheel(0.48 + S.hue), 0.8, 0.32, c, 0);\n  hsv(wheel(0.48 + S.hue), 0.4, 0.8, c, 3);\n  hsv(0.13 + S.hue, 0.85, 1, c, 6);\n  for (let q = 0; q \u003c 3; q++)\n    for (let ch = 0; ch \u003c 3; ch++) c[9 + q * 3 + ch] = ((1 - sp) * c[6 + ch]) / 3 + sp * PRIM[q * 3 + ch];\n  c[18] = c[19] = c[20] = 1;\n  c[21] = c[22] = c[23] = 0.2;\n\n  // The screen in Fresnel units and the slit, a = 0.6 + 7.4 (1 - K3)^1.5.\n  const a = 0.6 + 7.4 * (1 - S.slit) ** 1.5;\n  const w0 = slit ? -6 : -2, w1 = slit ? 6 : 5, ws = (w1 - w0) / W;\n  const rs = [0, 1, 2].map((q) => 1 / sqrt(1 + sp * DL[q]));\n  let Imax = 0;\n  for (let col = 0; col \u003c W; col++) {\n    const w = w0 + (col + 0.5) * ws;\n    for (let q = 0; q \u003c 3; q++) {\n      let dx, dy;\n      if (slit) {\n        const p = Z((w - a / 2) * rs[q]), px = p[0], py = p[1], e = Z((w + a / 2) * rs[q]);\n        dx = e[0] - px;\n        dy = e[1] - py;\n      } else {\n        const e = Z(w * rs[q]);\n        dx = e[0] + 0.5;\n        dy = e[1] + 0.5;\n      }\n      const v = (I[col * 3 + q] = (dx * dx + dy * dy) / 2);\n      if (v > Imax) Imax = v;\n    }\n  }\n  const ks = PH / Imax;\n\n  // The spiral, dim, and the part of it that lets light through bright: from\n  // the lower eye up to the chord's end behind a straight edge, the arc a\n  // long inside a slit.\n  for (let y = 0, p = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const v = D[p];\n      if (v > 0) (R[p] = v * c[0]), (G[p] = v * c[1]), (B[p] = v * c[2]);\n    }\n  const wh = w0 + (S.xh + 0.5) * ws;\n  const t1 = slit ? wh - a / 2 : -TM, t2 = slit ? wh + a / 2 : wh;\n  const i1 = max(0, ceil((t1 + TM) * TS)), i2 = min(NT - 1, floor((t2 + TM) * TS)), st = SC / TS;\n  // The lit arc goes through the same tone curve as the spiral, so the\n  // coils round an eye stay rings instead of piling up into a white disc.\n  const A = S.A;\n  A.fill(0);\n  for (let i = i1; i \u003c= i2; i++) {\n    const x = lx(FC[i]), y = ly(FS[i]), ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy, p = iy * W + ix;\n    A[p] += (1 - fx) * (1 - fy) * st;\n    A[p + 1] += fx * (1 - fy) * st;\n    A[p + W] += (1 - fx) * fy * st;\n    A[p + W + 1] += fx * fy * st;\n  }\n  for (let p = 0; p \u003c A.length; p++)\n    if (A[p] > 0) {\n      const v = min(1, A[p]) ** 0.75;\n      R[p] += v * c[3];\n      G[p] += v * c[4];\n      B[p] += v * c[5];\n    }\n  // The unobstructed wave's chord, eye to eye, length sqrt 2: I = 1.\n  for (let u = 0.04; u \u003c 1; u += 0.06) splat(S, lx(u - 0.5), ly(u - 0.5), 0.9, c, 21);\n  // The chords, one a wavelength, each from its own two points.\n  for (let q = 0; q \u003c 3; q++) {\n    let x0, y0;\n    if (slit) {\n      const p = Z((wh - a / 2) * rs[q]);\n      (x0 = lx(p[0])), (y0 = ly(p[1]));\n    } else (x0 = lx(-0.5)), (y0 = ly(-0.5));\n    const e = Z((slit ? wh + a / 2 : wh) * rs[q]), x1 = lx(e[0]), y1 = ly(e[1]);\n    line(S, x0, y0, x1, y1, 1.15, c, 9 + q * 3, true);\n    splat(S, x1, y1, 0.9, c, 9 + q * 3);\n    if (slit) splat(S, x0, y0, 0.9, c, 9 + q * 3);\n  }\n  splat(S, lx(0.5), ly(0.5), 0.5, c, 18);\n  splat(S, lx(-0.5), ly(-0.5), 0.5, c, 18);\n\n  // The profile: I = 1 dotted, the geometric shadow's edges dotted, the\n  // curve brightest where the head has just been, and the head itself.\n  if (PB - ks > PB - PH - 6) for (let x = 0; x \u003c W; x += 2) add(S, x, round(PB - ks), 0.9, c, 21);\n  const edges = slit ? [-a / 2, a / 2] : [0];\n  for (const e of edges) {\n    const ex = round((e - w0) / ws - 0.5);\n    for (let y = PB - PH; y \u003c= PB; y += 2) add(S, ex, y, 0.8, c, 21);\n  }\n  const now = S.clock, glow = (col) => 0.45 + 0.55 * exp(-(now - last[col]) / 2.2);\n  for (let q = 0; q \u003c 3; q++)\n    for (let col = 0; col \u003c W - 1; col++) {\n      const g = (glow(col) + glow(col + 1)) / 2;\n      line(S, col, PB - I[col * 3 + q] * ks, col + 1, PB - I[(col + 1) * 3 + q] * ks, g, c, 9 + q * 3, col === 0);\n    }\n  const xh = S.xh, ia = floor(cl(xh, 0, W - 2)), fa = cl(xh - ia, 0, 1);\n  const Ih = I[ia * 3 + 1] * (1 - fa) + I[(ia + 1) * 3 + 1] * fa, yh = PB - Ih * ks;\n  for (let y = yh + 2; y \u003c= PB; y += 2) splat(S, xh, y, 0.5, c, 21);\n  splat(S, xh, yh, 1.6, c, 18);\n  // The screen.\n  for (let col = 0; col \u003c W; col++) {\n    const r = [0, 0, 0];\n    for (let q = 0; q \u003c 3; q++) {\n      const v = I[col * 3 + q] / Imax;\n      for (let ch = 0; ch \u003c 3; ch++) r[ch] += v * c[9 + q * 3 + ch];\n    }\n    for (let y = BAND; y \u003c H; y++) {\n      const p = y * W + col;\n      (R[p] = r[0]), (G[p] = r[1]), (B[p] = r[2]);\n    }\n  }\n  splat(S, xh, BAND - 2, 1, c, 18);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","eulers-officers":"// ===== Patternflow pattern =====\n// Title:   Euler's Officers\n// Family:  cells\n// Idea:    Two officer squares stand one above the other, each cell a ring in the colour of its rank and a core in the colour of its regiment: on top Euler's 36 officers in a best attempt where four cells at the corners of a rectangle repeat two pairs and pulse white, below an order-10 Graeco-Latin square where all 100 colour pairs appear once, while one regiment after another lights up to show it is a transversal of the ranks, one cell in every row, column and rank.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler's 36 officers problem (Leonhard Euler, 1782), no pair of order 6 (Gaston Tarry, 1900), orthogonal Latin squares of order 10, \"Euler's spoilers\" (R. C. Bose, S. S. Shrikhande and E. T. Parker, 1959), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Core=-1..1, Shuffle=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the ten ranks and regiments of the bottom square are red, orange, yellow, lime, green, teal, azure, blue, violet and magenta, and the six of the top square red, amber, green, teal, azure and purple, spread round the same wheel. Each 0.1 moves the bottom square's colours one place on; at 0.5 every colour stands opposite where it was, red turned teal.\n// Knob 2: Speed. At 2 the next regiment lights up every 1.5 s, so the ten transversals of the order-10 square come round in 15 s and the six regiments of the order-6 attempt in 9 s, and the clash cells fade to white and back every 2.4 s. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Core. How much of a cell the regiment's core takes. At -1 there is no core and each square shows only its ranks, a Latin square on its own; at -0.5 the core is the centre LED of the 5 x 5 cells below and 3 x 3 of the 9 x 9 cells on top; at 0 3 x 3 and 5 x 5; at 0.5 the bottom square shows only regiments and the top one a 7 x 7 core in a ring one LED wide; at 1 both show only the regiments, the second Latin square.\n// Knob 4: Shuffle. Swaps two rows or two columns of one square, both of its Latin squares together, which keeps every pair it had: 2.4 x K4 swaps a second at Speed 2, so one every 7 s at the opening 0.06 and none at 0. A swap fades the colours of the two lines into each other over 0.4 s, round the wheel so no LED dims, and puts white ticks at their ends.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, cos, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The squares: R gives each cell's rank row by row, G its regiment.\n// Order 6 (top) is the best a search found for Euler's officers. It took 40\n// random rank squares and split each one every way into six regiments, and\n// 15 of them reached 34 of the 36 pairs, 15 reached 32, three 31 and seven\n// 30: a square with no transversal cannot do better than 6 x 5. 34 is the\n// most there can be. Tarry's 1900 search of every case rules out 36, and 35\n// cannot happen either, since five regiments that are transversals leave a\n// sixth that is one too. Here the four cells in rows 1 and 5, columns 3 and\n// 6 (from the top left) hold only two pairs between them, amber with green\n// and red with purple at Hue 0, each twice; red with green and amber with\n// purple never appear. The code below counts the pairs and marks the cells\n// of every pair it meets twice.\nconst R6 = \"231450523104015243104532450321342015\";\nconst G6 = \"012345253401301254140523435012524130\";\n// Order 10 (bottom): the fifth random rank square the search drew had 872\n// transversals, and an exact-cover search picked 10 disjoint ones out of\n// them; transversal k is regiment k. (The first four, with 804 to 892\n// transversals, gave no cover inside two million steps.) All 100 pairs\n// appear once, which the same count finds here.\nconst R10 = \"8054267913170842536951360427983285679041041953867268921504379647803125792138450645739162802360791854\";\nconst G10 = \"3621054789217486039595034286171365792840573864902180429715636290135478795628310404873169524819507236\";\n\n// Ten hues placed by eye on the LED wheel, which crowds the greens: rank or\n// regiment k of an order-n square sits at slot k / n + Hue, and a slot maps\n// to a hue through these stops.\nconst STOPS = [0, 0.075, 0.15, 0.25, 0.37, 0.47, 0.56, 0.65, 0.76, 0.87, 1];\nfunction slotHue(t) {\n  t -= floor(t);\n  const i = floor(t * 10), f = t * 10 - i;\n  return STOPS[i] + (STOPS[i + 1] - STOPS[i]) * f;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Both squares are 59 LEDs square at columns 2..60. The top one has cells of\n// 9 x 9 LEDs at a pitch of 10, rows 2..60; the bottom one 5 x 5 at a pitch\n// of 6, rows 67..125. A dark LED line runs between the cells.\nfunction makeSquare(n, ranks, regs, oy) {\n  const pitch = n === 6 ? 10 : 6, lit = pitch - 1, nn = n * n;\n  const A = new Int8Array(nn), B = new Int8Array(nn), clash = new Uint8Array(nn);\n  for (let i = 0; i \u003c nn; i++) (A[i] = +ranks[i]), (B[i] = +regs[i]);\n  // Orthogonality, counted: a pair met twice marks both of its cells.\n  const seen = new Int16Array(nn);\n  for (let i = 0; i \u003c nn; i++) seen[A[i] * n + B[i]]++;\n  let clashes = 0;\n  for (let i = 0; i \u003c nn; i++) if (seen[A[i] * n + B[i]] > 1) (clash[i] = 1), clashes++;\n  const perm = () => Array.from({ length: n }, (_, i) => i);\n  return {\n    n, pitch, lit, ox: 2, oy, A, B, clash, clashes, rowP: perm(), colP: perm(),\n    // Display cell colours as slots, with the fade of a swap.\n    fromA: new Float32Array(nn), fromB: new Float32Array(nn), t0: new Float32Array(nn).fill(-9),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, core: 0, shuffle: 0.06, clock: 0, swapAcc: 0.5,\n    sq: [makeSquare(6, R6, G6, 2), makeSquare(10, R10, G10, 67)],\n    ticks: [], rgb: new Float32Array(W * H * 3), c: new Float32Array(6),\n  };\n}\n\nconst FADE = 0.4;\n\n// The slot a display cell shows now, part way through a swap's fade.\nfunction slotNow(S, q, i, from, to) {\n  const a = cl((S.clock - q.t0[i]) / FADE, 0, 1);\n  if (a >= 1) return to;\n  let d = to - from;\n  d -= round(d);\n  return from + d * (0.5 - 0.5 * cos(PI * a));\n}\n\nfunction swap(S) {\n  const q = S.sq[random() \u003c 0.5 ? 0 : 1], n = q.n, rows = random() \u003c 0.5;\n  const i = floor(random() * n);\n  let j = floor(random() * (n - 1));\n  if (j >= i) j++;\n  const P = rows ? q.rowP : q.colP;\n  // Note where each touched cell's colours are, then swap the two lines.\n  for (let k = 0; k \u003c n; k++)\n    for (const l of [i, j]) {\n      const d = rows ? l * n + k : k * n + l;\n      const r = rows ? P[l] : q.rowP[k], c = rows ? q.colP[k] : P[l];\n      q.fromA[d] = slotNow(S, q, d, q.fromA[d], q.A[r * n + c] / n);\n      q.fromB[d] = slotNow(S, q, d, q.fromB[d], q.B[r * n + c] / n);\n      q.t0[d] = S.clock;\n    }\n  const t = P[i];\n  P[i] = P[j];\n  P[j] = t;\n  S.ticks.push({ q, rows, i, j, t0: S.clock });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.core = cl(k[2], -1, 1);\n  S.shuffle = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.clock += ds;\n  S.swapAcc += ds * 2.4 * S.shuffle;\n  while (S.swapAcc >= 1) {\n    S.swapAcc -= 1;\n    swap(S);\n  }\n  S.ticks = S.ticks.filter((t) => S.clock - t.t0 \u003c FADE + 0.2);\n}\n\n// How lit a regiment is: each one in turn for 1.5 s, rising and falling\n// over the first and last 0.4 s.\nconst STEP = 1.5, FRAME = 0.25, BASE = 0.88, SAT = 0.88;\nfunction glow(S, n, reg) {\n  const u = S.clock / STEP, now = floor(u) % n;\n  if (reg !== now) return 0;\n  const f = u - floor(u), e = min(f, 1 - f) / (0.4 / STEP);\n  return e >= 1 ? 1 : 0.5 - 0.5 * cos(PI * e);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, c = S.c;\n  rgb.fill(0);\n  // A cell's LED lies in the core when its square ring (Chebyshev distance\n  // from the cell's centre) is under rho times half the pitch.\n  const rho = (1 + S.core) / 2;\n  // The clash cells fade to white and back every 2.4 s; white keeps the\n  // LED at the level it had, so the pulse moves nothing on the map.\n  const pulse = 0.5 - 0.5 * cos((2 * PI * S.clock) / 2.4);\n  for (const q of S.sq) {\n    const n = q.n, half = (q.lit - 1) / 2, rc = rho * (half + 1);\n    for (let r = 0; r \u003c n; r++)\n      for (let col = 0; col \u003c n; col++) {\n        const d = r * n + col, cell = q.rowP[r] * n + q.colP[col];\n        const sa = slotNow(S, q, d, q.fromA[d], q.A[cell] / n);\n        const sb = slotNow(S, q, d, q.fromB[d], q.B[cell] / n);\n        const g = glow(S, n, q.B[cell]);\n        // Cells stand at 0.88 of full and the lit regiment at full, with a\n        // faint white frame in the dark line round each of its cells.\n        const v = BASE + (1 - BASE) * g;\n        const whiten = q.clash[cell] ? pulse : 0;\n        hsv(slotHue(sa + S.hue), SAT * (1 - whiten), v, c, 0);\n        hsv(slotHue(sb + S.hue), SAT, v, c, 3);\n        const x0 = q.ox + col * q.pitch, y0 = q.oy + r * q.pitch, L = q.lit;\n        for (let yy = 0; yy \u003c L; yy++)\n          for (let xx = 0; xx \u003c L; xx++) {\n            const cheb = max(Math.abs(xx - half), Math.abs(yy - half));\n            const p = ((y0 + yy) * W + x0 + xx) * 3, o = cheb \u003c rc ? 3 : 0;\n            // The lit regiment's centre LED turns white: one white point in\n            // every row and every column.\n            const wh = cheb === 0 ? g : 0;\n            rgb[p] = wh * v + c[o] * (1 - wh);\n            rgb[p + 1] = wh * v + c[o + 1] * (1 - wh);\n            rgb[p + 2] = wh * v + c[o + 2] * (1 - wh);\n          }\n        if (g > 0)\n          for (let k = -1; k \u003c= L; k++)\n            for (const [x, y] of [[x0 + k, y0 - 1], [x0 + k, y0 + L], [x0 - 1, y0 + k], [x0 + L, y0 + k]]) {\n              const p = (y * W + x) * 3;\n              rgb[p] = rgb[p + 1] = rgb[p + 2] = max(rgb[p], FRAME * g);\n            }\n      }\n  }\n  // White ticks at the two ends of each swapped row or column.\n  for (const t of S.ticks) {\n    const q = t.q, a = cl(1 - (S.clock - t.t0 - FADE) / 0.2, 0, 1) * 0.8;\n    const span = q.n * q.pitch - 1;\n    for (const l of [t.i, t.j])\n      for (let s = 0; s \u003c q.lit; s++) {\n        const along = l * q.pitch + s;\n        const ends = t.rows\n          ? [[0, q.oy + along], [1, q.oy + along], [q.ox + span + 1, q.oy + along], [q.ox + span + 2, q.oy + along]]\n          : [[q.ox + along, q.oy - 1], [q.ox + along, q.oy + span + 1]];\n        for (const [x, y] of ends) {\n          if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n          const p = (y * W + x) * 3;\n          rgb[p] = rgb[p + 1] = rgb[p + 2] = max(rgb[p], a);\n        }\n      }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, round(rgb[p] * 255), round(rgb[p + 1] * 255), round(rgb[p + 2] * 255));\n}\n","giant-component":"// ===== Patternflow pattern =====\n// Title:   Giant Component\n// Family:  data\n// Idea:    Random edges join the dots of a 21 by 32 grid one at a time, every component wearing a colour of its own and the largest one cream, and just after the edges pass half the number of dots the cream giant component floods the panel, while a plot underneath draws its share against the edges added over the curve Erdős and Rényi's theory gives.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random graph phase transition (Paul Erdős and Alfréd Rényi, 1959 and 1960), explosive percolation (Dimitris Achlioptas, Raissa D'Souza and Joel Spencer, 2009), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Choice=0..1\n//\n// Knob 1: Hue. Turns the components' colours round the wheel; a vertex alone stays a dim slate dot and the largest component stays cream. At 0 the components take hues from azure through blue and violet to pink, at 0.25 from violet through red to lime, at 0.5 from rose through lime and green to cyan, at 0.75 from green through cyan and blue to violet; orange and dark yellow are skipped, as they read brown. The plot's dim lines turn with them, blue at 0.\n// Knob 2: Speed. Edges added a second, 0.064 x Speed x n: at 2 the first graph opens with 0.2 n edges already in, passes the threshold n / 2 at 2.3 s and reaches 1.28 n, where the plot ends, at 8.4 s; it holds 2 s and a fresh graph starts from no edges, every 12 s. At 0.2 ten times slower, at 3 one and a half times faster. Each new edge is drawn as a line for 0.25 s at Speed 2, faint when it only brings in a vertex that was alone, brighter the larger the smaller of the two components it joins.\n// Knob 3: Size. The grid, rounded: at -1 16 x 24 = 384 vertices as 3 x 3 LED dots 4 LEDs apart, at the opening 0 21 x 32 = 672 as 2 x 2 dots 3 apart, at 1 32 x 48 = 1536 single LEDs 2 apart. The larger the graph, the sharper the turn: over 200 graphs each, the largest component held 11.9, 10.4 and 8.0 percent of the vertices at n / 2 edges, falling as n^(-1/3), and at 0.75 n edges 57.5, 57.8 and 58.2 percent against the 58.3 of theory. A new value starts a fresh graph.\n// Knob 4: Choice. The chance that an edge is chosen by the product rule of Achlioptas, D'Souza and Spencer: two candidates are drawn and the one whose two components have the smaller product of sizes is kept. It opens at 0.06, almost the plain random graph. At 1 the components stay small and many past n / 2, the giant waits until 0.83 n edges and then grows from a tenth of the vertices to seven tenths in 0.07 n more, 0.5 s at Speed 2, where the plain graph takes 0.35 n and 2.75 s, and the plot rises as a cliff. Over 200 graphs of 672 vertices the edges it took the largest component to grow from the square root of n to n / 2 were 0.30 n with no choice and 0.16 n with it, and for 200000 vertices, off the panel, 0.23 n and 0.022 n: the jump grows sharper without end, explosive percolation.\n// Buttons: K1 tap starts a fresh graph from no edges.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, exp, log2, round, random, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The vertex grids: spacing, columns, rows, dot size, left margin. Each\n// stands 95 rows tall over the top of the panel, one dark LED between dots.\nconst GRIDS = [[4, 16, 24, 3, 0], [3, 21, 32, 2, 1], [2, 32, 48, 1, 0]];\nconst NMAX = 32 * 48;\n// The plot below them: edges added across, 0 to TMAX n over its 64\n// columns, the largest component's share up, 0 on row PY0 and 1 PH rows\n// higher.\nconst PY0 = 126, PH = 25, PC = 64, TMAX = 1.28;\nconst RATE = 0.064, T0 = 0.2, HOLD = 2, FADE = 0.6, LIFE = 0.25, NL = 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Orange and yellow read brown and olive on an LED unless they are bright,\n// so the components take their hues from a wheel without 0.03 to 0.17, and\n// the dim lines of the plot from one that runs only from green to rose.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\nconst dimWheel = (h) => 0.3 + 0.7 * (h - floor(h));\n\n// The share of vertices in the giant component of G(n, m) as n grows,\n// m = t n: the root theta of theta = 1 - exp(-2 t theta), zero up to t = 1/2.\nconst THEORY = new Float32Array(PC);\nfor (let c = 0; c \u003c PC; c++) {\n  const k = (2 * (c + 0.5) * TMAX) / PC;\n  let th = 1;\n  for (let i = 0; i \u003c 400; i++) th = 1 - exp(-k * th);\n  THEORY[c] = k \u003c= 1 ? 0 : th;\n}\n\nexport function setup(params) {\n  params.s = {\n    par: new Int32Array(NMAX), sz: new Int32Array(NMAX), hu: new Float32Array(NMAX),\n    share: new Float32Array(PC), lines: new Int32Array(NL * 3), age: new Float32Array(NL).fill(9), nl: 0,\n    rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3), c: new Float32Array(3),\n    n: 0, grid: 1, t: 0, m: 0, big: 1, bigRoot: 0, hold: 0, fade: 0, started: false,\n    hue: 0, speed: 2, size: 1, choice: 0.06,\n  };\n}\n\n// Union-find, with path halving and union by size.\nfunction find(par, a) {\n  while (par[a] !== a) a = par[a] = par[par[a]];\n  return a;\n}\n\nfunction fresh(S) {\n  const g = GRIDS[S.size];\n  S.grid = S.size;\n  S.n = g[1] * g[2];\n  for (let v = 0; v \u003c S.n; v++) (S.par[v] = v), (S.sz[v] = 1), (S.hu[v] = random());\n  S.share.fill(-1);\n  S.t = S.m = S.hold = S.nl = 0;\n  S.big = 1;\n  S.bigRoot = 0;\n  S.age.fill(9);\n}\n\n// One edge. With probability Choice two candidate edges are drawn and the\n// one whose two components have the smaller product of sizes is kept, the\n// product rule of Achlioptas, D'Souza and Spencer; otherwise one edge,\n// uniformly at random, as in G(n, m). The line it leaves remembers the\n// smaller of the two components it joined, 0 for an edge inside one.\nfunction addEdge(S) {\n  const { par, sz } = S, n = S.n;\n  let a = floor(random() * n), b = floor(random() * (n - 1));\n  if (b >= a) b++;\n  if (random() \u003c S.choice) {\n    let c = floor(random() * n), d = floor(random() * (n - 1));\n    if (d >= c) d++;\n    if (sz[find(par, c)] * sz[find(par, d)] \u003c sz[find(par, a)] * sz[find(par, b)]) (a = c), (b = d);\n  }\n  let ra = find(par, a), rb = find(par, b), small = 0;\n  if (ra !== rb) {\n    if (sz[ra] \u003c sz[rb]) {\n      const t = ra;\n      ra = rb;\n      rb = t;\n    }\n    small = sz[rb];\n    par[rb] = ra;\n    sz[ra] += small;\n    if (sz[ra] >= S.big) (S.big = sz[ra]), (S.bigRoot = ra);\n  }\n  const k = S.nl++ % NL;\n  S.lines[k * 3] = a;\n  S.lines[k * 3 + 1] = b;\n  S.lines[k * 3 + 2] = small;\n  S.age[k] = 0;\n  S.m++;\n}\n\n// Edges up to t n, the largest share noted in the column t falls in.\nfunction grow(S, t) {\n  S.t = min(TMAX, t);\n  const target = floor(S.t * S.n);\n  while (S.m \u003c target) {\n    addEdge(S);\n    S.share[min(PC - 1, floor((S.m / S.n / TMAX) * PC))] = S.big / S.n;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.size = cl(round(k[2]), -1, 1) + 1;\n  S.choice = cl(k[3], 0, 1);\n  // The first graph opens with T0 n edges already in, so the threshold\n  // comes 2.3 s in at Speed 2; the later ones start from no edges.\n  if (!S.started) {\n    fresh(S);\n    grow(S, T0);\n    S.started = true;\n  }\n  if (S.hold > HOLD || S.size !== S.grid || (input.btnPressed && input.btnPressed[0])) {\n    S.old.set(S.rgb);\n    S.fade = 1;\n    fresh(S);\n  }\n  const h = d * (S.speed / 2);\n  S.fade = max(0, S.fade - d / FADE);\n  for (let i = 0; i \u003c NL; i++) S.age[i] += h;\n  if (S.t \u003c TMAX) grow(S, S.t + 2 * h * RATE);\n  else S.hold += h;\n}\n\nfunction add(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  rgb[o] += r;\n  rgb[o + 1] += g;\n  rgb[o + 2] += b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, old, par, sz, hu, c } = S, g = GRIDS[S.grid], sp = g[0], nc = g[1], dot = g[3], ox = g[4], fd = S.fade, h = S.hue;\n  rgb.fill(0);\n  const cx = (v) => (v % nc) * sp + ox, cy = (v) => floor(v / nc) * sp;\n  // The vertices: the largest component cream, a vertex alone a dim slate\n  // dot, every other component a colour of its own that it keeps through\n  // each merge it wins, brighter as it grows.\n  const lift = dot === 1 ? 1.15 : 1;\n  for (let v = 0; v \u003c S.n; v++) {\n    const r = find(par, v), s = sz[r];\n    if (r === S.bigRoot && s > 1) hsv(h + 0.12, 0.12, 1, c, 0);\n    else if (s === 1) hsv(0.62, 0.4, 0.2 * lift, c, 0);\n    else hsv(wheel(h + 0.4 + 0.5 * hu[r]), 0.8, min(1, (0.6 + 0.3 * min(1, log2(s) / 5)) * lift), c, 0);\n    const x0 = cx(v), y0 = cy(v), R = c[0] * 255, G = c[1] * 255, B = c[2] * 255;\n    for (let yy = 0; yy \u003c dot; yy++) for (let xx = 0; xx \u003c dot; xx++) add(rgb, x0 + xx, y0 + yy, R, G, B);\n  }\n  // The newest edges, as lines between the centres of their dots: faint\n  // when they only bring in a vertex that was alone or close a cycle,\n  // bright when they join two components of some size.\n  const half = (dot - 1) / 2;\n  for (let i = 0; i \u003c NL; i++) {\n    if (S.age[i] >= LIFE) continue;\n    const a = S.lines[i * 3], b = S.lines[i * 3 + 1], small = S.lines[i * 3 + 2];\n    const w = (small ? 80 + 130 * min(1, log2(small) / 4) : 50) * (1 - S.age[i] / LIFE);\n    const ax = cx(a) + half, ay = cy(a) + half, bx = cx(b) + half, by = cy(b) + half;\n    const steps = max(1, round(max(abs(bx - ax), abs(by - ay))));\n    for (let j = 0; j \u003c= steps; j++) {\n      const u = j / steps;\n      add(rgb, round(ax + (bx - ax) * u), round(ay + (by - ay) * u), w, w, w);\n    }\n  }\n  // The plot: the threshold n / 2 dashed, the share the theory gives as n\n  // grows dim behind, and the share measured so far, with the ground under\n  // it tinted and its newest point brightest.\n  hsv(dimWheel(h + 0.5), 0.6, 0.45, c, 0);\n  const tc = floor((0.5 / TMAX) * PC), TR = c[0] * 255, TG = c[1] * 255, TB = c[2] * 255;\n  for (let y = PY0 - PH; y \u003c= PY0; y += 2) add(rgb, tc, y, TR, TG, TB);\n  let last = -1;\n  for (let x = 0; x \u003c PC; x++) {\n    add(rgb, x, PY0 + 1, 28, 28, 30);\n    add(rgb, x, round(PY0 - THEORY[x] * PH), TR * 0.85, TG * 0.85, TB * 0.85);\n    if (S.share[x] >= 0) last = x;\n  }\n  hsv(h + 0.12, 0.12, 1, c, 0);\n  for (let x = 0; x \u003c= last; x++) {\n    const s = S.share[x] >= 0 ? S.share[x] : 0, y1 = round(PY0 - s * PH), w = x === last ? 255 : 190;\n    for (let y = y1 + 1; y \u003c= PY0; y++) add(rgb, x, y, c[0] * 44, c[1] * 44, c[2] * 44);\n    add(rgb, x, y1, c[0] * w, c[1] * w, c[2] * w);\n  }\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      let r = min(255, rgb[p]), gg = min(255, rgb[p + 1]), b = min(255, rgb[p + 2]);\n      if (fd > 0) (r = r * (1 - fd) + old[p] * fd), (gg = gg * (1 - fd) + old[p + 1] * fd), (b = b * (1 - fd) + old[p + 2] * fd);\n      (rgb[p] = r), (rgb[p + 1] = gg), (rgb[p + 2] = b);\n      display.setPixel(x, y, r, gg, b);\n    }\n}\n","hough-transform":"// ===== Patternflow pattern =====\n// Title:   Hough Transform\n// Family:  algo\n// Idea:    Points land one by one on the top square, most of them on a few slowly turning line segments and the rest anywhere, and as each lands its sinusoid rho = x cos theta + y sin theta is swept column by column into the accumulator below while the line through the point at that theta turns round it above; the sinusoids of collinear points all cross at one bright peak, the strongest peaks are picked, and each one's line is drawn back across the square and its sinusoids tinted in one colour, while old points and their votes fade.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hough transform (Paul Hough, 1962), its rho-theta form (Richard Duda and Peter Hart, 1972), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=2..6, Noise=0.3..0.9\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the accumulator glows deep blue through azure to white and the found lines are lime, magenta, gold, sky, violet and green; the accumulator keeps to a strip of the wheel without orange and yellow, which go brown when dim, so at 0.25 it is violet, at 0.5 rose and magenta, at 0.75 teal and green, while the lines go the whole way round. The points stay white.\n// Knob 2: Speed. At 2 eight points land a second, the newest point's sinusoid sweeps the 64 columns in 0.11 s, a point and its votes fade by e every 6 s and are gone after 18 s, and each line turns 0.4 to 1 degree a second while its distance from the centre drifts 3 to 7 LEDs either way over 1.5 to 3.5 minutes; at 0.2 all of it ten times slower, a point every 1.25 s whose sweep takes 1.06 s, at 3 half as fast again.\n// Knob 3: Lines. How many line segments the points come from and how many peaks are picked, 2 to 6, rounded. At 2, with the opening's noise, each line holds about 16 of the 46 points' worth of weight, and in three 2-minute runs the picked peaks found the lines 99% of the time, within 0.15 rad of theta and 4 LEDs of rho; with 4 lines 81%, with 6 lines 64%, and a third of the 6 peaks then stand on crossings of noise.\n// Knob 4: Noise. The share of landing points that fall anywhere on the square instead of on a line: 0.3 at the opening, so the noise sinusoids lace the accumulator thinly in blue; at 0.6 the 2 lines are still found 87% of the time; at 0.9 one point in ten is on a line, the noise weaves a mesh whose crossings stand as high as the lines' peaks, and the 2 lines are found 20% of the time.\n\nconst W = 64, H = 128, SQ = 64, NT = 64, NR = 64;\nconst { floor, min, max, round, abs, sin, cos, exp, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The accumulator's colours come off a strip of the wheel that skips red,\n// orange and yellow, which turn brown and olive when dim: u from 0 to 1\n// runs green, cyan, blue, violet, magenta to rose.\nconst wheel = (u) => 0.34 + 0.63 * (u - floor(u));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Image space is the top 64 x 64, with its origin at the centre of the\n// square, between LEDs 31 and 32, and y down. A line is the set of points\n// with x cos theta + y sin theta = rho, theta in [0, pi) across the 64\n// columns of the bottom square and rho in [-32, 32) down its 64 rows, one\n// LED of rho a row. Only a point in a corner, more than 32 LEDs from the\n// centre, has a sinusoid that leaves through the top or the bottom for a\n// stretch of theta, and every line that passes within 32 LEDs of the\n// centre has its bin. Crossing theta = pi turns (theta, rho) into (theta - pi, -rho):\n// column 64 is column 0 with its rows upside down.\nconst R = 32, DT = PI / NT, C0 = 31.5;\nconst CE = new Float64Array(NT + 1), SE = new Float64Array(NT + 1);\nfor (let j = 0; j \u003c= NT; j++) (CE[j] = cos(j * DT)), (SE[j] = sin(j * DT));\nconst rowOf = (rho) => ((rho + R) / (2 * R)) * NR;\n\n// Points land at RATE a second and fade by e every TAU seconds, both in\n// panel time, Speed 2 being 1; a point older than 3 TAU is gone. The\n// accumulator is cast afresh every frame from the points there are, each\n// with its weight e^(-age / TAU), so it is always the exact transform of\n// the points on the square, and it fades as they do. FLASH is how long the\n// newest point's sweep across the columns takes.\nconst RATE = 8, TAU = 6, FLASH = 0.85 / RATE, MAXP = 200, LMAX = 6;\n// The colours the found lines and their peaks take, as hue offsets.\nconst LINE_HUES = [0.3, 0.86, 0.14, 0.55, 0.74, 0.4];\n// Where the six lines start in theta, as fractions of pi.\nconst BASE = [0.3, 0.66, 0.48, 0.12, 0.84, 0.2];\n\nexport function setup(params) {\n  const lines = [];\n  for (let i = 0; i \u003c LMAX; i++) {\n    // Spread the lines out in theta, the first two a third of the way in\n    // from either end of the accumulator, and give each a turn of its own,\n    // so two peaks start apart and drift past each other only now and then.\n    // A line's points come from the stretch a to b of its chord across the\n    // square, which slides 0.12 of the chord either way.\n    lines.push({\n      th: PI * (BASE[i] + 0.06 * random()), w: (random() \u003c 0.5 ? -1 : 1) * (0.007 + 0.01 * random()),\n      r0: (random() * 2 - 1) * 14, ra: 3 + 4 * random(), rw: 0.03 + 0.04 * random(), rp: 6.3 * random(),\n      a: 0.04 + 0.3 * random(), b: 0.65 + 0.3 * random(), sp: 0.2 + 0.2 * random(),\n    });\n  }\n  params.s = {\n    hue: 0, speed: 2, L: 2, q: 0.3, T: 0, acc: 0, warm: false, vref: 8,\n    lines, n: 0, newest: -1,\n    px: new Int8Array(MAXP), py: new Int8Array(MAXP), age: new Float32Array(MAXP), ln: new Int8Array(MAXP), own: new Int8Array(MAXP),\n    A: new Float32Array(NT * NR),\n    peaks: [],\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3),\n  };\n}\n\n// Where line i is now: its normal angle and its distance from the centre.\nfunction lineNow(S, i) {\n  const L = S.lines[i];\n  return [L.th + L.w * S.T, L.r0 + L.ra * sin(L.rw * S.T + L.rp)];\n}\n\n// Take point i out, moving the last point into its place.\nfunction drop(S, i) {\n  const e = --S.n;\n  S.px[i] = S.px[e], S.py[i] = S.py[e], S.age[i] = S.age[e], S.ln[i] = S.ln[e];\n  if (S.newest === e) S.newest = i;\n}\n\nfunction spawn(S) {\n  // Drop the oldest point when the store is full.\n  if (S.n >= MAXP) {\n    let o = 0;\n    for (let i = 1; i \u003c S.n; i++) if (S.age[i] > S.age[o]) o = i;\n    drop(S, o);\n  }\n  let x, y, li = -1;\n  if (random() \u003c S.q) {\n    x = floor(random() * SQ);\n    y = floor(random() * SQ);\n  } else {\n    li = floor(random() * S.L);\n    const [th, rho] = lineNow(S, li), L = S.lines[li];\n    const c = cos(th), s = sin(th), fx = rho * c, fy = rho * s;\n    // The chord of the line across the square, t along the direction\n    // (-sin, cos) from the foot of the normal, and the segment the points\n    // come from: a stretch of the chord that slides slowly along it.\n    let t0 = -99, t1 = 99;\n    for (const [p, d] of [[fx, -s], [fy, c]]) {\n      if (abs(d) \u003c 1e-6) continue;\n      const ta = (-C0 - p) / d, tb = (C0 - p) / d;\n      t0 = max(t0, min(ta, tb));\n      t1 = min(t1, max(ta, tb));\n    }\n    if (t1 - t0 \u003c 8) return;\n    const slide = 0.12 * sin(L.sp * S.T + L.rp);\n    const a = cl(L.a + slide, 0, 0.6), b = cl(L.b + slide, a + 0.3, 1);\n    const t = t0 + (t1 - t0) * (a + (b - a) * random());\n    x = round(fx - s * t + C0);\n    y = round(fy + c * t + C0);\n    if (x \u003c 0 || x >= SQ || y \u003c 0 || y >= SQ) return;\n  }\n  const k = S.n++;\n  S.px[k] = x, S.py[k] = y, S.age[k] = 0, S.ln[k] = li;\n  S.newest = k;\n}\n\n// One point's votes: in column j the sinusoid runs from rho(theta_j) to\n// rho(theta_j+1), and the point's weight is spread evenly over the rows it\n// passes, at least one row's width, so every column gets the same weight\n// and a steep stretch of the curve is drawn as a dim run, not a dotted one.\nfunction cast(A, x, y, w, nj) {\n  const X = x - C0 + 0.5, Y = y - C0 + 0.5;\n  let ra = rowOf(X * CE[0] + Y * SE[0]);\n  for (let j = 0; j \u003c nj; j++) {\n    const rb = rowOf(X * CE[j + 1] + Y * SE[j + 1]);\n    let lo = min(ra, rb), hi = max(ra, rb);\n    ra = rb;\n    if (hi - lo \u003c 1) {\n      const m = (lo + hi) / 2;\n      lo = m - 0.5;\n      hi = m + 0.5;\n    }\n    const k = w / (hi - lo);\n    for (let r = max(0, floor(lo)), e = min(NR - 1, floor(hi)); r \u003c= e; r++) {\n      const o = min(hi, r + 1) - max(lo, r);\n      if (o > 0) A[r * NT + j] += k * o;\n    }\n  }\n}\n\n// The accumulator at column j, row r, reading past the ends through the\n// theta = pi seam.\nfunction at(A, j, r) {\n  if (j \u003c 0) (j += NT), (r = NR - 1 - r);\n  else if (j >= NT) (j -= NT), (r = NR - 1 - r);\n  return r \u003c 0 || r >= NR ? 0 : A[r * NT + j];\n}\n\n// The L strongest peaks: bins at least as high as every bin within 3, over\n// a quarter of the highest and over 2.5 points' worth of votes, refined to\n// a fraction of a bin by a parabola through each axis's three bins.\nfunction findPeaks(S) {\n  const A = S.A, cand = [];\n  let top = 0;\n  for (let i = 0; i \u003c NT * NR; i++) top = max(top, A[i]);\n  const floorV = max(2.5, 0.25 * top);\n  for (let r = 0; r \u003c NR; r++)\n    for (let j = 0; j \u003c NT; j++) {\n      const v = A[r * NT + j];\n      if (v \u003c floorV) continue;\n      let ok = true;\n      for (let dr = -3; dr \u003c= 3 && ok; dr++)\n        for (let dj = -3; dj \u003c= 3; dj++) {\n          if (!dr && !dj) continue;\n          const u = at(A, j + dj, r + dr);\n          if (u > v || (u === v && (dr \u003c 0 || (dr === 0 && dj \u003c 0)))) {\n            ok = false;\n            break;\n          }\n        }\n      if (ok) cand.push([v, j, r]);\n    }\n  cand.sort((a, b) => b[0] - a[0]);\n  const out = [];\n  for (const [v, j, r] of cand) {\n    if (out.length >= S.L) break;\n    const l = at(A, j - 1, r), rr = at(A, j + 1, r), u = at(A, j, r - 1), d = at(A, j, r + 1);\n    const fj = j + cl((0.5 * (l - rr)) / (l - 2 * v + rr || -1), -0.5, 0.5);\n    const fr = r + cl((0.5 * (u - d)) / (u - 2 * v + d || -1), -0.5, 0.5);\n    out.push({ v, j, r, th: (fj + 0.5) * DT, rho: ((fr + 0.5) / NR) * 2 * R - R, slot: -1 });\n  }\n  // Each peak keeps the colour of the peak nearest it last frame, within 6\n  // bins; a new one takes a free colour.\n  const used = new Uint8Array(LMAX);\n  for (const p of out) {\n    let best = -1, bd = 36;\n    S.peaks.forEach((q, i) => {\n      if (q.slot \u003c 0 || used[q.slot]) return;\n      let dj = abs(q.j - p.j), dr = abs(q.r - p.r);\n      if (dj > NT / 2) (dj = NT - dj), (dr = abs(NR - 1 - q.r - p.r));\n      const dd = dj * dj + dr * dr;\n      if (dd \u003c bd) (bd = dd), (best = i);\n    });\n    if (best >= 0) p.slot = S.peaks[best].slot;\n    else for (let k = 0; k \u003c LMAX; k++) if (!used[k] && !out.some((o) => o.slot === k)) { p.slot = k; break; }\n    if (p.slot >= 0) used[p.slot] = 1;\n  }\n  S.peaks = out;\n}\n\n// How many columns of a point's sinusoid are cast: all 64 once its sweep\n// of FLASH seconds is over. Only the newest point sweeps, so when the next\n// one lands a sweep still running is finished at once.\nconst sweepAge = (S, i) => (i === S.newest ? S.age[i] : 1e9);\nconst sweepOf = (age) => min(NT, floor((NT * age) / FLASH) + 1);\n\nfunction step(S, d) {\n  S.T += d;\n  for (let i = 0; i \u003c S.n; i++) S.age[i] += d;\n  for (let i = 0; i \u003c S.n; )\n    if (S.age[i] > 3 * TAU) drop(S, i);\n    else i++;\n  S.acc += d * RATE;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    spawn(S);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.3], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.L = round(cl(k[2], 2, 6));\n  S.q = cl(k[3], 0.3, 0.9);\n  if (!S.warm) {\n    // Open on a square that has been filling for 12 s.\n    for (let i = 0; i \u003c 360; i++) step(S, 1 / 30);\n    S.warm = true;\n  }\n  step(S, (d * S.speed) / 2);\n  S.A.fill(0);\n  // The newest point casts its votes column by column as its sweep passes.\n  for (let i = 0; i \u003c S.n; i++) cast(S.A, S.px[i], S.py[i], exp(-S.age[i] / TAU), sweepOf(sweepAge(S, i)));\n  findPeaks(S);\n  // Each point within 1 LED of a found line belongs to it, the nearest if\n  // two are that close: those are the votes that made the peak.\n  for (let i = 0; i \u003c S.n; i++) {\n    const X = S.px[i] - C0 + 0.5, Y = S.py[i] - C0 + 0.5;\n    let best = -1, bd = 1;\n    for (const p of S.peaks) {\n      const dd = abs(X * cos(p.th) + Y * sin(p.th) - p.rho);\n      if (p.slot >= 0 && dd \u003c bd) (bd = dd), (best = p.slot);\n    }\n    S.own[i] = best;\n  }\n  let top = 0;\n  for (let i = 0; i \u003c NT * NR; i++) top = max(top, S.A[i]);\n  // The brightness scale follows the highest bin slowly, so a peak that\n  // grows brightens instead of the whole accumulator dimming round it.\n  S.vref += (max(4, top) - S.vref) * min(1, d * 1.5);\n}\n\nfunction add(S, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] += r, o[p + 1] += g, o[p + 2] += b;\n}\nfunction lift(S, x, y, c) {\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = max(o[p], c[0] * 255), o[p + 1] = max(o[p + 1], c[1] * 255), o[p + 2] = max(o[p + 2], c[2] * 255);\n}\nfunction put(S, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = r, o[p + 1] = g, o[p + 2] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.rgb, c = S.c, A = S.A, hu = S.hue;\n  o.fill(0);\n  // The accumulator: deep blue at a trace of a vote, azure, then white only\n  // near the top, on brightness (v / vref)^0.85, so one fresh noise\n  // sinusoid alone shows at about 45 of 255 and the peaks stand out of the\n  // band of flat sinusoids that the points near the centre lay along rho = 0.\n  for (let r = 0; r \u003c NR; r++)\n    for (let j = 0; j \u003c NT; j++) {\n      const v = A[r * NT + j] / S.vref;\n      if (v \u003c= 0.004) continue;\n      const b = min(1, v) ** 0.85;\n      hsv(wheel(hu + 0.476 - 0.15 * b), 1 - (0.8 * max(0, b - 0.7)) / 0.3, 0.06 + 0.94 * b, c, 0);\n      put(S, j, SQ + r, c[0] * 255, c[1] * 255, c[2] * 255);\n    }\n  // The sinusoids of the points a found line owns, in that line's colour\n  // at their weight, each LED kept at the brighter of it and the heat, so\n  // the bundle runs into its peak and the peak stays white.\n  for (let i = 0; i \u003c S.n; i++) {\n    if (S.own[i] \u003c 0 || sweepAge(S, i) \u003c FLASH) continue;\n    hsv(hu + LINE_HUES[S.own[i]], 0.85, 0.55 * exp(-S.age[i] / TAU) ** 1.5, c, 0);\n    const X = S.px[i] - C0 + 0.5, Y = S.py[i] - C0 + 0.5;\n    let ra = rowOf(X * CE[0] + Y * SE[0]);\n    for (let j = 0; j \u003c NT; j++) {\n      const rb = rowOf(X * CE[j + 1] + Y * SE[j + 1]);\n      for (let r = floor(min(ra, rb)), e = floor(max(ra, rb)); r \u003c= e; r++) if (r >= 0 && r \u003c NR) lift(S, j, SQ + r, c);\n      ra = rb;\n    }\n  }\n  // The newest points' sinusoids in white over the columns cast so far, the\n  // cursor column brightest; a finished one fades over the next 1.5 sweeps.\n  // While a point sweeps, the line through it whose normal is at the\n  // cursor's theta turns round it on the square: each bin of the sinusoid\n  // is one of those lines.\n  const HOLD = 1.5 / RATE;\n  for (let i = 0; i \u003c S.n; i++) {\n    const age = S.age[i];\n    if (age >= FLASH + HOLD) continue;\n    const sa = sweepAge(S, i), nj = sweepOf(sa), a = sa \u003c FLASH ? 1 : min(1, 1 - (age - FLASH) / HOLD);\n    const X = S.px[i] - C0 + 0.5, Y = S.py[i] - C0 + 0.5;\n    let ra = rowOf(X * CE[0] + Y * SE[0]);\n    for (let j = 0; j \u003c nj; j++) {\n      const rb = rowOf(X * CE[j + 1] + Y * SE[j + 1]), g = (j === nj - 1 && sa \u003c FLASH ? 255 : 200) * a;\n      for (let r = floor(min(ra, rb)), e = floor(max(ra, rb)); r \u003c= e; r++) if (r >= 0 && r \u003c NR) add(S, j, SQ + r, g, g, g);\n      ra = rb;\n    }\n    if (sa \u003c FLASH) {\n      const th = (nj - 0.5) * DT, cs = cos(th), sn = sin(th), rho = X * cs + Y * sn;\n      for (let y = 0; y \u003c SQ; y++)\n        for (let x = 0; x \u003c SQ; x++) {\n          const dd = abs((x - C0 + 0.5) * cs + (y - C0 + 0.5) * sn - rho);\n          if (dd \u003c 1) add(S, x, y, 90 * (1 - dd), 90 * (1 - dd), 90 * (1 - dd));\n        }\n    }\n  }\n  // The found lines across the image square, each in its peak's colour,\n  // 2.4 LEDs wide and fading out from the middle.\n  for (const p of S.peaks) {\n    if (p.slot \u003c 0) continue;\n    hsv(hu + LINE_HUES[p.slot], 0.85, 1, c, 0);\n    const cs = cos(p.th), sn = sin(p.th), str = 0.35 + 0.4 * min(1, p.v / S.vref);\n    for (let y = 0; y \u003c SQ; y++)\n      for (let x = 0; x \u003c SQ; x++) {\n        const dd = abs((x - C0) * cs + (y - C0) * sn - p.rho);\n        if (dd \u003c 1.2) {\n          const a = (1 - dd / 1.2) * str * 255;\n          add(S, x, y, c[0] * a, c[1] * a, c[2] * a);\n        }\n      }\n    // Its peak: four LEDs in the same colour at the corners of the 5 x 5\n    // round the bin, leaving the glow of the crossing inside them alone.\n    for (let dr = -2; dr \u003c= 2; dr += 4)\n      for (let dj = -2; dj \u003c= 2; dj += 4) {\n        let j = p.j + dj, r = p.r + dr;\n        if (j \u003c 0) (j += NT), (r = NR - 1 - r);\n        else if (j >= NT) (j -= NT), (r = NR - 1 - r);\n        if (r >= 0 && r \u003c NR) put(S, j, SQ + r, c[0] * 255, c[1] * 255, c[2] * 255);\n      }\n  }\n  // The points, white, as bright as their weight, 255 new and 50 when they\n  // go; the point sweeping has a ring.\n  for (let i = 0; i \u003c S.n; i++) {\n    const w = exp(-S.age[i] / TAU), x = S.px[i], y = S.py[i], g = 40 + 215 * w;\n    put(S, x, y, g, g, g);\n    if (sweepAge(S, i) \u003c FLASH) {\n      const e = 200;\n      for (const [dx, dy] of [[-2, 0], [2, 0], [0, -2], [0, 2], [-1, -1], [1, -1], [-1, 1], [1, 1]])\n        if (y + dy >= 0 && y + dy \u003c SQ) add(S, x + dx, y + dy, e, e, e);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, round(o[p])), min(255, round(o[p + 1])), min(255, round(o[p + 2])));\n}\n","jordan-curve":"// ===== Patternflow pattern =====\n// Title:   Jordan Curve\n// Family:  topology\n// Idea:    One long winding simple closed curve fills the panel and slowly reshapes without ever touching itself; a probe wanders over it casting a ray to the far end of the panel, the ray's crossings with the curve are marked in gold and counted in pips along the top, and from the probe a flood of the colour the count's parity names, odd inside and even outside, spreads through the region it stands in until inside and outside come up as two interlocking territories.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Jordan curve theorem (Camille Jordan, 1887), its first proof accepted as complete (Oswald Veblen, 1905), the crossing-number test for a point in a polygon (M. Shimrat, 1962), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tension=-1..1, Probes=1..4\n//\n// Knob 1: Hue. Moves both territories along a strip of the wheel that leaves out red, orange and yellow, which go brown when dim: at 0 the inside is teal and the outside violet, at 0.25 blue and crimson, at 0.5 violet and teal, at 0.75 crimson and blue. The curve stays white, the crossings and the count gold, the probe white.\n// Knob 2: Speed. At 2 the probe walks 7 LEDs a second, a flood takes 250 LEDs a frame and rests 0.8 s once its region is full, fresh colour fades by e every 5 s down to a third, and the curve is offered 60 changes a second, of which about 7 cells take one, each sliding across in 0.7 s; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Tension. How much the curve's length costs: a cell changes side with Metropolis probability min(1, e^-dE), E = -beta L + 0.03 (A - A*)^2, L the lattice edges the curve crosses, and beta = 0.4 - 0.5 x Tension below 0 and 0.4 - 1.1 x Tension above. At -1 (beta 0.9) inside and outside are two trees of corridors one cell wide and the curve is about 1390 LEDs long; at the opening 0 (beta 0.4) it is about 1220 LEDs round a branching coral of 127 of the 242 free cells, and a ray crosses it 8 times on average, up to 18; at 0.5 about 940 LEDs; at 1 (beta -0.7) one lobed blob of about 310.\n// Knob 4: Probes. 1 to 4, rounded, each with its own ray, its own row of pips and its own two floods, so with 4 both territories are refreshed most of the time.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs, sqrt, sin, cos, exp, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Region colours come off a strip of the wheel that skips red, orange and\n// yellow, which turn brown and olive when dim.\nconst wheel = (u) => 0.34 + 0.63 * (u - floor(u));\n\n// The curve is the zero set of a function that is linear on each triangle\n// of a jittered triangular lattice of cells SP LEDs apart. A cell holds a\n// value u in [-1, 1] and is inside where u is positive. Within a triangle\n// whose corners are not all one sign the zero set is one straight segment,\n// so the zero set is a union of disjoint simple closed curves and never\n// touches itself. A cell changes side only when that keeps the cells\n// inside one connected piece and the cells outside another, so there is\n// exactly one curve. The cells within MARGIN of the panel's edge are held\n// outside, so the outside reaches the edge all round and a ray that ends\n// there ends outside.\nconst BETA0 = 0.4, LAMBDA = 0.03, FILL = 0.47;\n// Tries a second, the seconds a changing cell takes to slide across, the\n// floor and fade time of fresh colour, LEDs a flood takes a frame at Speed\n// 1, the probe's speed, the ray's swing rate and a flood's rest.\nconst TRY = 60, SLIDE = 0.7, PFLOOR = 0.35, PTAU = 5, FLOOD = 125, VEL = 7, RAYW = 0.35, REST = 0.8;\nconst SP = 5.5, RH = (SP * Math.sqrt(3)) / 2, MARGIN = 4.5;\nconst NCOL = Math.ceil(W / SP) + 3, NROW = Math.ceil(H / RH) + 3, NC = NCOL * NROW;\n// Six neighbours of each cell in turning order: right, up-right, up-left,\n// left, down-left, down-right.\nconst NB = new Int32Array(NC * 6).fill(-1);\nfor (let j = 0; j \u003c NROW; j++)\n  for (let i = 0; i \u003c NCOL; i++) {\n    const c = j * NCOL + i, odd = j & 1;\n    const nb = [[i + 1, j], [i + odd, j - 1], [i - 1 + odd, j - 1], [i - 1, j], [i - 1 + odd, j + 1], [i + odd, j + 1]];\n    nb.forEach(([a, b], k) => {\n      if (a >= 0 && a \u003c NCOL && b >= 0 && b \u003c NROW) NB[c * 6 + k] = b * NCOL + a;\n    });\n  }\n// Triangles: each cell with its right and down-right neighbours, and with\n// its down-right and down-left ones.\nconst TRI = [];\nfor (let c = 0; c \u003c NC; c++) {\n  const r = NB[c * 6], dr = NB[c * 6 + 5], dl = NB[c * 6 + 4];\n  if (r >= 0 && dr >= 0) TRI.push(c, dr, r);\n  if (dr >= 0 && dl >= 0) TRI.push(c, dl, dr);\n}\nconst NT = TRI.length / 3;\n\nexport function setup(params) {\n  const CX = new Float32Array(NC), CY = new Float32Array(NC), FIXED = new Uint8Array(NC), LT = new Int32Array(N);\n  // The lattice is jittered once, by up to 0.22 of the spacing, small\n  // enough that no triangle turns over.\n  for (let j = 0; j \u003c NROW; j++)\n    for (let i = 0; i \u003c NCOL; i++) {\n      const c = j * NCOL + i, a = random() * 2 * PI, r = 0.22 * SP * sqrt(random());\n      CX[c] = (i - 1.5 + (j & 1 ? 0.5 : 0)) * SP + (W - (NCOL - 3) * SP) / 2 + r * cos(a);\n      CY[c] = (j - 1.5) * RH + (H - (NROW - 3) * RH) / 2 + r * sin(a);\n      let full = true;\n      for (let k = 0; k \u003c 6; k++) if (NB[c * 6 + k] \u003c 0) full = false;\n      FIXED[c] = !full || CX[c] \u003c MARGIN || CX[c] > W - 1 - MARGIN || CY[c] \u003c MARGIN || CY[c] > H - 1 - MARGIN ? 1 : 0;\n    }\n  // Each LED's triangle and its three barycentric weights; and each\n  // triangle's gradient of the three weights, for the distance to the curve.\n  const LV = new Int32Array(N * 3).fill(-1), LW = new Float32Array(N * 3), GR = new Float32Array(NT * 6);\n  for (let t = 0; t \u003c NT; t++) {\n    const a = TRI[3 * t], b = TRI[3 * t + 1], c = TRI[3 * t + 2];\n    const x0 = CX[a], y0 = CY[a], x1 = CX[b], y1 = CY[b], x2 = CX[c], y2 = CY[c];\n    const det = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n    // d lambda_k / dx and / dy.\n    GR[6 * t] = (y1 - y2) / det, GR[6 * t + 1] = (x2 - x1) / det;\n    GR[6 * t + 2] = (y2 - y0) / det, GR[6 * t + 3] = (x0 - x2) / det;\n    GR[6 * t + 4] = (y0 - y1) / det, GR[6 * t + 5] = (x1 - x0) / det;\n    const xa = max(0, floor(min(x0, x1, x2))), xb = min(W - 1, Math.ceil(max(x0, x1, x2)));\n    const ya = max(0, floor(min(y0, y1, y2))), yb = min(H - 1, Math.ceil(max(y0, y1, y2)));\n    for (let y = ya; y \u003c= yb; y++)\n      for (let x = xa; x \u003c= xb; x++) {\n        const p = y * W + x;\n        if (LV[3 * p] >= 0) continue;\n        const l1 = ((x - x0) * (y2 - y0) - (x2 - x0) * (y - y0)) / det;\n        const l2 = ((x1 - x0) * (y - y0) - (x - x0) * (y1 - y0)) / det;\n        const l0 = 1 - l1 - l2;\n        if (l0 \u003c -1e-6 || l1 \u003c -1e-6 || l2 \u003c -1e-6) continue;\n        LV[3 * p] = a, LV[3 * p + 1] = b, LV[3 * p + 2] = c;\n        LW[3 * p] = l0, LW[3 * p + 1] = l1, LW[3 * p + 2] = l2;\n        LT[p] = t;\n      }\n  }\n  const u = new Float32Array(NC).fill(-1), tgt = new Int8Array(NC).fill(-1);\n  // Start from one cell in the middle.\n  let c0 = 0, bd = 1e9;\n  for (let c = 0; c \u003c NC; c++) {\n    const d = (CX[c] - W / 2) ** 2 + (CY[c] - H / 2) ** 2;\n    if (!FIXED[c] && d \u003c bd) (bd = d), (c0 = c);\n  }\n  u[c0] = 1, tgt[c0] = 1;\n  let free = 0;\n  for (let c = 0; c \u003c NC; c++) if (!FIXED[c]) free++;\n  params.s = {\n    hue: 0, speed: 2, tension: 0, nprobe: 1, warm: false,\n    LV, LW, GR, LT, FIXED, CX, CY, u, tgt, area: 1, free, busy: [],\n    f: new Float32Array(N), gt: new Float32Array(NT),\n    paint: new Float32Array(N), cls: new Int8Array(N), heal: new Int32Array(2 * N), glow: new Float32Array(N), side: new Int8Array(N),\n    probes: [], tryAcc: 0, rgb: new Float32Array(N * 3), c: new Float32Array(3), c2: new Float32Array(3),\n  };\n}\n\n// Can cell c change sides without changing the topology? Its neighbours,\n// read round in turn, must be one run of in and one run of out: then adding\n// it to either side glues a disc to that side along an arc.\nfunction simple(S, c) {\n  let runs = 0;\n  const u = S.u;\n  for (let k = 0; k \u003c 6; k++) {\n    const a = u[NB[c * 6 + k]] > 0, b = u[NB[c * 6 + ((k + 1) % 6)]] > 0;\n    if (a !== b) runs++;\n  }\n  return runs === 2;\n}\n\nfunction inCount(S, c) {\n  let n = 0;\n  for (let k = 0; k \u003c 6; k++) if (S.u[NB[c * 6 + k]] > 0) n++;\n  return n;\n}\n\n// One Metropolis try: a cell, if simple and with no neighbour already\n// moving, changes sides with probability min(1, e^-dE), where\n// E = -beta L + LAMBDA (A - A*)^2, L the number of lattice edges the curve\n// crosses, A the cells inside and A* = FILL of the free cells. No two\n// neighbours move at once, so a cell that was simple when it set off is\n// still simple when its value crosses zero. instant flips it at once (for\n// the warm-up); otherwise its value starts to slide towards the other sign.\nfunction attempt(S, beta, instant) {\n  const c = floor(random() * NC);\n  if (S.FIXED[c] || S.u[c] !== S.tgt[c]) return;\n  for (let k = 0; k \u003c 6; k++) {\n    const n = NB[c * 6 + k];\n    if (S.u[n] !== S.tgt[n]) return;\n  }\n  if (!simple(S, c)) return;\n  const k = inCount(S, c), isIn = S.u[c] > 0;\n  const dL = isIn ? 2 * k - 6 : 6 - 2 * k, dA = isIn ? -1 : 1;\n  const A0 = S.free * FILL, a = S.area - A0;\n  const dE = -beta * dL + LAMBDA * ((a + dA) ** 2 - a ** 2);\n  if (dE > 0 && random() >= exp(-dE)) return;\n  S.area += dA;\n  S.tgt[c] = isIn ? -1 : 1;\n  if (instant) S.u[c] = S.tgt[c];\n  else S.busy.push(c);\n}\n\n// A probe keeps a flood for each side, so a flood it left behind on\n// crossing the curve runs on to the end of its region.\nconst flood = (sign, cls) => ({ sign, cls, q: new Int32Array(N), seen: new Int32Array(N), gen: 0, head: 0, tail: 0, rest: 0 });\nfunction newProbe(S, i) {\n  return { x: 12 + random() * 40, y: 16 + random() * 96, h: random() * 2 * PI, ray: PI / 2, down: 1, ph: random() * 2 * PI, F: [flood(1, 1), flood(-1, 2)], hits: [], i };\n}\n\n// The function at any point of the panel, read bilinearly off the LEDs.\nfunction fAt(S, x, y) {\n  const f = S.f;\n  x = cl(x, 0, W - 1.001);\n  y = cl(y, 0, H - 1.001);\n  const i = floor(x), j = floor(y), a = x - i, b = y - j, p = j * W + i;\n  return (f[p] * (1 - a) + f[p + 1] * a) * (1 - b) + (f[p + W] * (1 - a) + f[p + W + 1] * a) * b;\n}\n\n// March the probe's ray to the panel's edge in quarter-LED steps; every\n// change of sign is a crossing, placed where the line through the two\n// samples meets zero. A tangency the steps miss loses two crossings at\n// once and leaves the parity alone.\nfunction castRay(S, P) {\n  const dx = cos(P.ray), dy = sin(P.ray);\n  // From the centre of the LED the probe stands on, so the parity and the\n  // sign the flood follows are read at the same point.\n  P.sx = round(P.x);\n  P.sy = round(P.y);\n  let tmax = 1e9;\n  if (dx > 1e-6) tmax = min(tmax, (W - 0.5 - P.sx) / dx);\n  if (dx \u003c -1e-6) tmax = min(tmax, (-0.5 - P.sx) / dx);\n  if (dy > 1e-6) tmax = min(tmax, (H - 0.5 - P.sy) / dy);\n  if (dy \u003c -1e-6) tmax = min(tmax, (-0.5 - P.sy) / dy);\n  P.tmax = tmax;\n  P.hits.length = 0;\n  let prev = fAt(S, P.sx, P.sy);\n  for (let t = 0.25; t \u003c= tmax; t += 0.25) {\n    const v = fAt(S, P.sx + dx * t, P.sy + dy * t);\n    if ((v > 0) !== (prev > 0)) P.hits.push(t - 0.25 + (0.25 * prev) / (prev - v));\n    prev = v;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tension = cl(k[2], -1, 1);\n  S.nprobe = round(cl(k[3], 1, 4));\n  const beta = BETA0 - (S.tension \u003c 0 ? 0.5 : 1.1) * S.tension, ds = (d * S.speed) / 2;\n  if (!S.warm) {\n    // Grow the opening curve from one cell, 90000 tries at the knob's beta.\n    for (let i = 0; i \u003c 90000; i++) attempt(S, beta, true);\n    S.warm = true;\n  }\n  // Shape: tries at TRY a second, each accepted one sliding its cell's\n  // value across zero in SLIDE seconds.\n  S.tryAcc += ds * TRY;\n  while (S.tryAcc >= 1) {\n    S.tryAcc -= 1;\n    attempt(S, beta, false);\n  }\n  const step = (2 * ds) / SLIDE;\n  for (let i = 0; i \u003c S.busy.length; ) {\n    const c = S.busy[i], g = S.tgt[c];\n    S.u[c] = g > 0 ? min(1, S.u[c] + step) : max(-1, S.u[c] - step);\n    if (S.u[c] === g) {\n      S.busy[i] = S.busy[S.busy.length - 1];\n      S.busy.pop();\n    } else i++;\n  }\n  // The function on every LED, and each triangle's gradient length. An LED\n  // the curve has swept over to the other side loses its colour. Fresh\n  // paint fades by e every PTAU seconds down to PFLOOR, the glow of a flood\n  // front by e every 0.15 s.\n  const { LV, LW, GR, u, f } = S;\n  const cls = S.cls, side = S.side, paint = S.paint, glow = S.glow, heal = S.heal;\n  const fade = min(1, ds / PTAU), gf = exp(-ds / 0.15);\n  for (let p = 0; p \u003c N; p++) {\n    const q = 3 * p;\n    const v = (f[p] = LV[q] \u003c 0 ? -1 : LW[q] * u[LV[q]] + LW[q + 1] * u[LV[q + 1]] + LW[q + 2] * u[LV[q + 2]]);\n    const sd = v > 0 ? 1 : -1;\n    if (sd !== side[p]) (cls[p] = 0), (side[p] = sd);\n    if (paint[p] > PFLOOR) paint[p] -= (paint[p] - PFLOOR) * fade;\n    glow[p] *= gf;\n  }\n  for (let t = 0; t \u003c NT; t++) {\n    const a = u[TRI[3 * t]], b = u[TRI[3 * t + 1]], c = u[TRI[3 * t + 2]];\n    const gx = a * GR[6 * t] + b * GR[6 * t + 2] + c * GR[6 * t + 4], gy = a * GR[6 * t + 1] + b * GR[6 * t + 3] + c * GR[6 * t + 5];\n    S.gt[t] = sqrt(gx * gx + gy * gy) + 1e-6;\n  }\n  // A dark LED takes the colour of a coloured neighbour on its own side, one\n  // LED a frame, so colour creeps on within a region it has already reached\n  // and never crosses the curve. A region no flood has reached stays dark.\n  let nh = 0;\n  for (let p = 0; p \u003c N; p++) {\n    if (cls[p]) continue;\n    const x = p & 63, sd = side[p];\n    const q = x > 0 && side[p - 1] === sd && cls[p - 1] > 0 ? p - 1\n      : x \u003c W - 1 && side[p + 1] === sd && cls[p + 1] > 0 ? p + 1\n      : p >= W && side[p - W] === sd && cls[p - W] > 0 ? p - W\n      : p \u003c N - W && side[p + W] === sd && cls[p + W] > 0 ? p + W : -1;\n    if (q >= 0) (heal[nh++] = p), (heal[nh++] = q);\n  }\n  for (let i = 0; i \u003c nh; i += 2) (cls[heal[i]] = cls[heal[i + 1]]), (paint[heal[i]] = paint[heal[i + 1]]);\n  while (S.probes.length \u003c S.nprobe) S.probes.push(newProbe(S, S.probes.length));\n  S.probes.length = S.nprobe;\n  const budget = round(FLOOD * S.speed);\n  for (const P of S.probes) {\n    // Wander: a heading that turns at random, turned back off the margin.\n    P.h += (random() - 0.5) * 6 * ds;\n    let vx = cos(P.h) * VEL * ds, vy = sin(P.h) * VEL * ds;\n    if (P.x + vx \u003c 8 || P.x + vx > W - 9) (P.h = PI - P.h), (vx = -vx);\n    if (P.y + vy \u003c 8 || P.y + vy > H - 9) (P.h = -P.h), (vy = -vy);\n    P.x += vx;\n    P.y += vy;\n    // The ray aims at the farther end of the panel, down from the top half\n    // and up from the bottom half with 32 rows of slack between, leans\n    // towards the middle column by up to 29 degrees and swings 29 degrees\n    // either way about that; it turns at most 1.5 radians a second, so a\n    // change of end sweeps it round through the horizontal.\n    if (P.down > 0 && P.y > 80) P.down = -1;\n    else if (P.down \u003c 0 && P.y \u003c 48) P.down = 1;\n    P.ph += RAYW * ds;\n    let dr = P.down * (PI / 2 + (0.5 * (P.x - 31.5)) / 31.5) + 0.5 * sin(P.ph) - P.ray;\n    dr -= 2 * PI * round(dr / (2 * PI));\n    P.ray += cl(dr, -1.5 * ds, 1.5 * ds);\n    castRay(S, P);\n    // Odd: the probe is inside, and the inside's flood is the one it may\n    // start, once that flood has run out and rested REST seconds.\n    const Fh = P.F[P.hits.length & 1 ? 0 : 1], pl = P.sy * W + P.sx;\n    if (Fh.head >= Fh.tail && (Fh.rest -= ds) \u003c= 0) {\n      Fh.rest = REST;\n      Fh.gen++;\n      Fh.head = Fh.tail = 0;\n      Fh.q[Fh.tail++] = pl;\n      Fh.seen[pl] = Fh.gen;\n    }\n    // The flood takes a random LED off its front each time, Eden's growth\n    // rather than a breadth-first wave, so in the open it spreads as a\n    // ragged disc instead of a diamond.\n    for (const F of P.F)\n      for (let n = 0; n \u003c budget && F.head \u003c F.tail; n++) {\n        const r = F.head + floor(random() * (F.tail - F.head)), p = F.q[r];\n        F.q[r] = F.q[F.head++];\n        if ((f[p] > 0 ? 1 : -1) !== F.sign) continue;\n        S.cls[p] = F.cls;\n        S.paint[p] = 1;\n        S.glow[p] = 1;\n        const x = p & 63, y = p >> 6;\n        if (x > 0) push(S, F, p - 1);\n        if (x \u003c W - 1) push(S, F, p + 1);\n        if (y > 0) push(S, F, p - W);\n        if (y \u003c H - 1) push(S, F, p + W);\n      }\n  }\n}\nfunction push(S, P, p) {\n  if (P.seen[p] === P.gen) return;\n  if ((S.f[p] > 0 ? 1 : -1) !== P.sign) return;\n  P.seen[p] = P.gen;\n  P.q[P.tail++] = p;\n}\n\nfunction put(S, x, y, r, g, b) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = r, o[p + 1] = g, o[p + 2] = b;\n}\nfunction lift(S, x, y, v) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = max(o[p], v), o[p + 1] = max(o[p + 1], v), o[p + 2] = max(o[p + 2], v);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.rgb, c = S.c, c2 = S.c2, hu = S.hue;\n  // Inside and outside colours, at 150 fresh and 52 faded; an LED no flood\n  // has coloured is all but dark, and a flood front glows 70 brighter.\n  hsv(wheel(hu + 0.2), 0.85, 1, c, 0);\n  hsv(wheel(hu + 0.68), 0.75, 1, c2, 0);\n  for (let p = 0; p \u003c N; p++) {\n    const q = 3 * p, kc = S.cls[p], a = S.paint[p] * 150, g = S.glow[p] * 70;\n    const col = kc === 1 ? c : c2;\n    let r = 0, gg = 0, b = 0;\n    if (kc) (r = col[0] * a + g), (gg = col[1] * a + g), (b = col[2] * a + g);\n    else r = gg = b = 8;\n    // The curve, white and about 1.7 LEDs wide: an LED's distance to the\n    // zero set is |f| over the gradient's length on its triangle.\n    const t = S.LT[p], dd = abs(S.f[p]) / S.gt[t], k = cl2(1 - dd / 0.85);\n    o[q] = r + (235 - r) * k, o[q + 1] = gg + (235 - gg) * k, o[q + 2] = b + (235 - b) * k;\n  }\n  // Each probe's ray, a pale line no brighter than the curve; its\n  // crossings as gold beads on the curve; its count as gold pips along the\n  // top, one row a probe; the probe a white cross.\n  for (const P of S.probes) {\n    const dx = cos(P.ray), dy = sin(P.ray);\n    for (let t = 1.5; t \u003c P.tmax; t += 0.5) lift(S, P.sx + dx * t, P.sy + dy * t, 150);\n    for (const t of P.hits) {\n      const x = P.sx + dx * t, y = P.sy + dy * t;\n      for (const [ex, ey] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) put(S, x + ex, y + ey, 190, 120, 10);\n      put(S, x, y, 255, 200, 40);\n    }\n    for (let i = 0; i \u003c P.hits.length; i++) put(S, 2 + 2 * (i % 30), 1 + 2 * P.i + 8 * floor(i / 30), 255, 200, 40);\n    for (const [ex, ey] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) put(S, P.sx + ex, P.sy + ey, 255, 255, 255);\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, round(o[p])), min(255, round(o[p + 1])), min(255, round(o[p + 2])));\n}\nconst cl2 = (v) => (v \u003c 0 ? 0 : v > 1 ? 1 : v);\n","penrose-diagram":"// ===== Patternflow pattern =====\n// Title:   Penrose Diagram\n// Family:  space\n// Idea:    All of flat spacetime folded into one triangle the panel's exact shape, the worldline r = 0 up the left edge and light at 45 degrees, its curves of constant time and radius crowding into the corners at infinity, while a now surface climbs from past to future infinity, gold pulses leave r = 0 once a unit of time, and an observer accelerating away carries a mirror that sends back every pulse sent before t = 0, later and later, while every pulse sent after runs past its horizon to future null infinity.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: conformal compactification of Minkowski spacetime (Roger Penrose, 1963), Penrose-Carter diagrams (Brandon Carter, 1966), hyperbolic motion (Max Born, 1909), the horizon of the uniformly accelerated frame (Wolfgang Rindler, 1966), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Grid=0..2, Accel=-2..3\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the curves of constant time are blue, the curves of constant radius green, the pulses gold and the observer magenta; at 0.5 the time curves turn amber, the radius curves rose, the pulses blue and the observer green. The edges and the now surface stay white, the haze of curves along the null infinities slate, the region past the horizon a faint violet and the region behind the mirror a faint plum.\n// Knob 2: Speed. How fast the now surface climbs. Its foot runs up the left edge at a constant pace on the panel, so t = tan(theta) in time: at 2 from i- to i+ in 6.3 s, then 0.7 s in which the pulses fade before the next climb; at 0.2 a climb takes 63 s, at 3 it takes 4.2 s. The first climb opens two ninths of the way up, at t = -1.2.\n// Knob 3: Grid. The spacing of the grid curves and of the pulses, 2^-Grid: one unit of time and radius at 0, half a unit at 1, a quarter at 2. A pulse leaves r = 0 where a curve of constant time meets the left edge, leaving out any that would start within 4 LEDs of the last, so 11 pulses cross the panel at 0, 17 at 1 and 21 at 2.\n// Knob 4: Accel. The observer's proper acceleration a = 2^(Accel - 1), from 1/8 to 4, opening at 0.52. Its worldline r^2 - t^2 = 1/a^2 crosses t = 0 at r = 1/a, 58 LEDs from the left edge at a = 1/8, 44 at the opening, 31.5 at a = 1, where it is the straight column R = pi/2, and 10 at a = 4. A pulse sent at t_k \u003c 0 comes back to r = 0 at t = 1/(a^2 |t_k|): at the opening the one sent at t = -1 returns at 3.68 and the one at -9 at 0.41.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, atan, tan, sqrt, max, min, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The diagram. With u = t - r and v = t + r, U = atan u and V = atan v, the\n// coordinates T = U + V and R = V - U fill the triangle R >= 0,\n// |T| + R \u003c= pi. One LED is pi/63 in both, so i+ sits on LED (0, 0), i0 on\n// (63, 63) and i- on (0, 126): the triangle is the panel's 64 x 127 LEDs,\n// and a light ray, T - R or T + R constant, is an exact LED diagonal.\n// Future null infinity is the diagonal x = y, past null infinity\n// x + y = 126, and the worldline r = 0 is column 0. Row 127 lies outside.\nconst K = PI / 63;\nconst IN = new Uint8Array(N), TT = new Float64Array(N), RR = new Float64Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x, T = (63 - y) * K, R = x * K;\n    if (x + Math.abs(63 - y) >= 63) continue;\n    const u = tan((T - R) / 2), v = tan((T + R) / 2);\n    IN[p] = 1;\n    TT[p] = (u + v) / 2;\n    RR[p] = (v - u) / 2;\n  }\n// An LED's four neighbours that are inside too, so a contour test reads\n// only finite fields.\nconst NB = [];\nfor (let p = 0; p \u003c N; p++) {\n  const x = p & 63, y = p >> 6, l = [];\n  if (IN[p]) for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n    const q = p + dy * W + dx;\n    if (x + dx >= 0 && x + dx \u003c W && y + dy >= 0 && y + dy \u003c H && IN[q]) l.push(q);\n  }\n  NB.push(l);\n}\n\n// A level curve f = c drawn as LEDs one wide: an LED on the high side with\n// a neighbour on the low side. Where two or more curves pass between an\n// LED and its neighbour, toward the corners and along the null\n// infinities, the curves crowd closer than the LEDs and the LED is marked\n// haze (val + 2) instead: drawn dim, as the infinitely many curves there.\nfunction contour(F, step, off, out, val) {\n  for (let p = 0; p \u003c N; p++) {\n    if (!IN[p]) continue;\n    const f = floor((F[p] - off) / step);\n    let lo = 0, g = 0;\n    for (const q of NB[p]) {\n      lo = max(lo, f - floor((F[q] - off) / step));\n      g = max(g, Math.abs(F[p] - F[q]) / step);\n    }\n    if (g > HAZE) {\n      if (out[p] === 0 || out[p] > 2) out[p] = val + 2;\n    } else if (lo === 1) out[p] = val;\n  }\n}\nconst HAZE = 0.5;\n\n// Map an event (t, r) to its LED.\nfunction led(t, r) {\n  const U = atan(t - r), V = atan(t + r);\n  return [round((V - U) / K), round(63 - (U + V) / K)];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, grid: -1, acc: 99, phase: 0.2, tn: -1e9,\n    G: new Uint8Array(N), O: new Uint8Array(N), now: new Uint8Array(N), sim: new Uint8Array(N), F: new Float64Array(N), gO: new Float64Array(N), ox: 0, oy: 0,\n    pulses: [], R: new Uint8Array(N), Gc: new Uint8Array(N), B: new Uint8Array(N), c: [0, 0, 0],\n  };\n}\n\n// The grid: 1 marks a curve of constant t, 2 of constant r, 3 and 4 their\n// haze, all at the spacing d, and a pulse at each t = k d.\nfunction buildGrid(S, d) {\n  S.G.fill(0);\n  contour(RR, d, 0, S.G, 2);\n  contour(TT, d, 0, S.G, 1);\n  S.pulses = [];\n  // Toward i+ and i- the rays crowd closer than an LED. Counting out from\n  // t = 0 both ways, a pulse whose ray would start within 4 LEDs of the\n  // last one kept is left out, so each ray drawn stands on its own.\n  for (const dir of [1, -1]) {\n    let last = 63;\n    for (let k = dir > 0 ? 0 : -1; Math.abs(k) \u003c= 400; k += dir) {\n      const tk = k * d, c = round(63 - (2 * atan(tk)) / K);\n      if (k !== 0 && Math.abs(c - last) \u003c 4) continue;\n      if (c \u003c 2 || c > 124) break;\n      S.pulses.push({ tk, c });\n      last = c;\n    }\n  }\n}\n\n// The observer: r^2 - t^2 = 1/a^2, that is u v = -1/a^2, with u \u003c 0. Read\n// the triangle as the half x >= 0 of 1+1 Minkowski spacetime, x for r, and\n// the observer, its mirror, its horizon u = 0 and its line of simultaneity\n// are exact; read as the radial diagram of 3+1 spacetime, each LED is a\n// sphere of radius r and each pulse a spherical shell. A pulse sent at\n// t_k \u003c 0 runs out along u = t_k, meets the observer at v = -1/(a^2 t_k)\n// and comes back along that v; a pulse sent at t_k >= 0 never meets it.\n// gO > 1 is the side of the worldline away from r = 0.\nfunction buildObserver(S, a) {\n  S.O.fill(0);\n  const g = S.gO;\n  for (let p = 0; p \u003c N; p++) if (IN[p]) g[p] = a * a * (RR[p] * RR[p] - TT[p] * TT[p]);\n  for (let p = 0; p \u003c N; p++) {\n    if (!IN[p] || g[p] \u003c 1) continue;\n    for (const q of NB[p])\n      if (g[q] \u003c 1) {\n        S.O[p] = 1;\n        break;\n      }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const grid = cl(k[2], 0, 2), acc = cl(k[3], -2, 3);\n  if (grid !== S.grid) {\n    S.grid = grid;\n    buildGrid(S, 2 ** -grid);\n  }\n  if (acc !== S.acc) {\n    S.acc = acc;\n    S.a = 2 ** (acc - 1);\n    buildObserver(S, S.a);\n  }\n  // One cycle is 14/speed seconds: 90% climbing, 10% fading.\n  S.phase += (d * S.speed) / 14;\n  if (S.phase >= 1) S.phase -= 1;\n  const climb = min(1, S.phase / 0.9);\n  const th = cl(-PI / 2 + PI * climb, -PI / 2 + 1e-4, PI / 2 - 1e-4);\n  S.tn = tan(th);\n  S.fade = S.phase \u003c 0.9 ? 1 : 1 - (S.phase - 0.9) / 0.1;\n  S.now.fill(0);\n  contour(TT, 1e9, S.tn, S.now, 1);\n  // The observer's own now: its line of simultaneity at this event is\n  // t = r tanh(eta), eta its rapidity, a line through the origin event\n  // (0, 63) that runs to i0 and tips toward the horizon as eta grows.\n  const ro = sqrt(1 / (S.a * S.a) + S.tn * S.tn), beta = S.tn / ro, F = S.F;\n  for (let p = 0; p \u003c N; p++) F[p] = IN[p] ? TT[p] - beta * RR[p] : 0;\n  S.sim.fill(0);\n  contour(F, 1e9, 0, S.sim, 1);\n  [S.ox, S.oy] = led(S.tn, ro);\n}\n\nfunction put(S, p, h, s, v) {\n  const c = S.c;\n  hsv(h, s, v / 255, c);\n  S.R[p] = round(c[0] * 255);\n  S.Gc[p] = round(c[1] * 255);\n  S.B[p] = round(c[2] * 255);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const hu = S.hue, G = S.G, O = S.O, tn = S.tn, f = S.fade, ox = S.ox, oy = S.oy;\n  S.R.fill(0);\n  S.Gc.fill(0);\n  S.B.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    if (!IN[p]) continue;\n    const x = p & 63, y = p >> 6;\n    // Above the horizon u = 0 lie the events the observer never sees, and\n    // behind the mirror, r^2 - t^2 > 1/a^2, those no pulse reaches.\n    if (x + y \u003c 63) put(S, p, 0.78, 0.5, 34);\n    else if (S.gO[p] > 1) put(S, p, 0.9, 0.55, 30);\n    const g = G[p];\n    if (g === 2) put(S, p, hu + 0.4, 0.8, 150);\n    else if (g === 1) put(S, p, hu + 0.6, 0.7, 170);\n    else if (g) put(S, p, 0.62, 0.35, 50);\n    if (O[p]) put(S, p, hu + 0.86, 0.75, 230);\n    else if (x + y === 63 && y >= 32 && (y & 1)) put(S, p, hu + 0.86, 0.6, 170);\n  }\n  // Pulses: each ray runs from (0, c) up the diagonal x + y = c, drawn as\n  // far as the now surface has come. The observer carries a mirror: a\n  // pulse sent before t = 0 meets it and comes back in along the diagonal\n  // x - y = constant to r = 0, arriving at t = v = -1/(a^2 t_k), later the\n  // closer t_k is to 0. A pulse sent after t = 0 never meets it and runs on\n  // to future null infinity at x = c / 2.\n  if (f > 0)\n    for (const P of S.pulses) {\n      if (P.tk > tn) continue;\n      let head = -1, x = 0, y = P.c;\n      for (; x \u003c= 63; x++, y--) {\n        const p = y * W + x;\n        if (y \u003c 0 || !IN[p] || TT[p] > tn || S.gO[p] >= 1) break;\n        put(S, p, hu + 0.13, 0.85, 215 * f);\n        head = p;\n      }\n      if (P.tk \u003c 0 && x \u003c= 63 && S.gO[y * W + x] >= 1 && TT[y * W + x] \u003c= tn) {\n        // The echo turns at the last LED before the mirror and runs back up\n        // to r = 0.\n        for (x -= 2; x >= 0; x--, y--) {\n          const p = y * W + x;\n          if (TT[p] > tn) break;\n          put(S, p, hu + 0.11, 0.7, 215 * f);\n          head = p;\n        }\n      }\n      if (head >= 0 && f === 1) put(S, head, 0, 0, 255);\n    }\n  for (let p = 0; p \u003c N; p++) if (S.now[p]) put(S, p, hu + 0.55, 0.12, 255);\n  // The edges: the worldline r = 0 and the two null infinities.\n  for (let y = 1; y \u003c 126; y++) put(S, y * W, 0, 0, 190);\n  for (let x = 1; x \u003c 63; x++) {\n    put(S, x * W + x, hu + 0.75, 0.55, 200);\n    put(S, (126 - x) * W + x, hu + 0.75, 0.55, 200);\n  }\n  for (const p of [0, 63 * W + 63, 126 * W]) put(S, p, 0, 0, 255);\n  if (f \u003c 1) return out(display, S);\n  // The observer's own now: its line of simultaneity.\n  for (let p = 0; p \u003c N; p++) if (S.sim[p] && !S.now[p]) put(S, p, hu + 0.86, 0.5, 230);\n  for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) {\n    const x = ox + dx, y = oy + dy;\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(S, y * W + x, 0, 0, 255);\n  }\n  out(display, S);\n}\n\nfunction out(display, S) {\n  for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, S.R[p], S.Gc[p], S.B[p]);\n}\n","phase-spiral":"// ===== Patternflow pattern =====\n// Title:   Phase Spiral\n// Family:  sim\n// Idea:    Three thousand parallel sheets of mass fall through each other along a line, each pulled by a force that only changes when two of them cross, and their phase portrait, position across the panel and velocity up it, winds a cold strip into a two-armed spiral whose turns multiply and thin round a settling white core, every sheet coloured by where it began on the strip.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: one-dimensional self-gravitating sheet model (Michel Hénon, 1964; Frank Hohl and Marc Feix, 1967), violent relaxation (Donald Lynden-Bell, 1967), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=0.1..1.2, Lumps=0..1\n//\n// Knob 1: Hue. Turns the ramp along the strip round the wheel. At 0 the sheet that starts at the left end is azure and the one at the right end rose, through blue, violet and magenta between; at 0.25 magenta through red to yellow, at 0.5 orange through yellow to sea green, at 0.75 green through cyan to blue. Where many sheets share an LED the colour goes toward white, so the core is pale at every setting.\n// Knob 2: Speed. Sheet time per second, 1.6 x Speed: 3.2 at 2, where the cold strip falls to the middle in 0.49 s and, once it has settled, the sheet from the end of the strip goes round in 2.3 s and one from a tenth or a quarter of the way along in 1 s, and that difference is what winds the spiral; 0.32 at 0.2 and 4.8 at 3. A fresh strip starts every 72 units of sheet time, 22.5 s at 2 (the first one after 17.5 s, as it opens 16 units in).\n// Knob 3: Spread. Half the height of the starting strip, its velocities spread evenly over plus and minus this, in units where the strip is 2 wide and a sheet with all the others on one side feels an acceleration of 1. Twice the kinetic energy over the potential starts at Spread squared: 0.01 at the opening 0.1, a cold collapse that winds the thinnest spiral; 1 at Spread 1, a waterbag in virial balance that only rocks and sheds two arms from its corners; 1.44 at 1.2, a hot one that swells first. A new value starts a fresh strip.\n// Knob 4: Lumps. Bunches the strip's sheets into four lumps, moving each by 0.95 x Lumps x sin(4 pi u) / (4 pi) from its even place u: at 1 the strip is 39 times as dense in the middle of a lump as halfway between two. Each lump falls in on itself first and spins up a little spiral, and the four then fall together and merge, which keeps the cloud ringing: the virial ratio still swings between 0.3 and 3 after 36 units, where a smooth strip has settled within 25 percent of 1 by 16. It opens at 0.06, almost smooth. A new value starts a fresh strip.\n// Buttons: K1 tap starts a fresh strip at once, falling from rest; the old spiral fades out over 0.9 s at Speed 2.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, exp, round, random, sin, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: the starting strip runs from x = -1 to 1, and a sheet with every\n// other sheet on one side is pulled toward them at 1. Inside a uniform\n// strip the pull is -x, so a cold strip would swing as a pendulum of period\n// 2 pi and fall to a point at pi / 2; any spread of velocities or of\n// density breaks that up. Phase space (x, v) is drawn with x across the\n// panel, SX LEDs to a unit, and v up it, SV LEDs to a unit.\nconst N = 3072;\nconst XC = 32, VC = 64, SX = 22, SV = 44;\nconst DT = 0.04, RATE = 1.6, PRE = 16, CYCLE = 72, FADE = 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    x: new Float64Array(N), xs: new Float64Array(N), v: new Float64Array(N), a: new Float64Array(N), f: new Float32Array(N),\n    ord: new Int32Array(N), bin: new Int32Array(N), cnt: new Int32Array(N + 1),\n    px: new Float32Array(N), py: new Float32Array(N), fresh: true, used: [0.1, 0.06],\n    D: new Float32Array(NP), F: new Float32Array(NP), rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3),\n    lut: new Float32Array(256 * 3), t: 0, fade: 0, started: false, hue: 0, speed: 2, spread: 0.1, lumps: 0.06,\n  };\n}\n\n// The pull on every sheet, from its rank. A counting sort into N bins\n// across the sheets' present extent puts them nearly in order, and an\n// insertion sort mends the few that share a bin, so the order is exact and\n// the cost does not grow with the number of crossings, about N^2 every\n// period. A sheet with k sheets on its left and N - 1 - k on its right is\n// pulled toward the heavier side by (N - 1 - 2k) / N, constant until the\n// next crossing: between crossings every sheet flies a parabola.\nfunction ranks(S, lo, hi) {\n  const { x, xs, a, ord, bin, cnt } = S, sc = (N - 1) / (hi - lo + 1e-12);\n  cnt.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const b = ((x[i] - lo) * sc) | 0;\n    bin[i] = b;\n    cnt[b + 1]++;\n  }\n  for (let b = 1; b \u003c= N; b++) cnt[b] += cnt[b - 1];\n  for (let i = 0; i \u003c N; i++) {\n    const k = cnt[bin[i]]++;\n    ord[k] = i;\n    xs[k] = x[i];\n  }\n  for (let k = 1; k \u003c N; k++) {\n    const xk = xs[k];\n    if (xs[k - 1] \u003c= xk) continue;\n    const j = ord[k];\n    let m = k - 1;\n    while (m >= 0 && xs[m] > xk) (xs[m + 1] = xs[m]), (ord[m + 1] = ord[m]), m--;\n    (xs[m + 1] = xk), (ord[m + 1] = j);\n  }\n  for (let k = 0; k \u003c N; k++) a[ord[k]] = (N - 1 - 2 * k) / N;\n}\n\n// A leapfrog step: kick with the pull of the last order, drift, sort again.\n// Across one cycle from rest at DT the total energy moved by 1 part in\n// 10^4; the coarser opening run, 0.05 through the first collapse and 0.1\n// after, lands within 0.4 percent of it.\nfunction step(S, dt) {\n  const { x, v, a } = S;\n  let lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c N; i++) {\n    v[i] += dt * a[i];\n    const xi = (x[i] += dt * v[i]);\n    if (xi \u003c lo) lo = xi;\n    if (xi > hi) hi = xi;\n  }\n  ranks(S, lo, hi);\n  S.t += dt;\n}\n\n// A fresh strip, a waterbag: the sheets evenly along x, bunched into four\n// lumps by Lumps, and their velocities spread evenly over +-Spread by the\n// golden-ratio sequence, which fills the rectangle without the clumps and\n// holes of random draws. f is a sheet's place along the strip, 0 at the\n// left end and 1 at the right, and picks its colour for good.\nfunction fresh(S) {\n  const { x, v, f } = S, A = 0.95 * S.lumps, V0 = S.spread, r0 = random();\n  for (let i = 0; i \u003c N; i++) {\n    const q = (i + 0.5) / N, u = 2 * q - 1;\n    f[i] = q;\n    x[i] = u + (A / (4 * PI)) * sin(4 * PI * u);\n    v[i] = V0 * (2 * ((i * 0.6180339887 + r0) % 1) - 1);\n  }\n  S.t = 0;\n  S.used = [V0, S.lumps];\n  ranks(S, -1, 1);\n  S.fresh = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.spread = cl(k[2], 0.1, 1.2);\n  S.lumps = cl(k[3], 0, 1);\n  // The first strip opens 16 units in, past the violent part of its\n  // relaxation, so the spiral has two turns by 2 s; the later ones start\n  // from rest and show the collapse.\n  if (!S.started) {\n    fresh(S);\n    while (S.t \u003c PRE) step(S, S.t \u003c 3 ? 0.05 : 0.1);\n    S.started = true;\n  }\n  const moved = abs(S.spread - S.used[0]) > 0.01 || abs(S.lumps - S.used[1]) > 0.01;\n  if (S.t > CYCLE || moved || (input.btnPressed && input.btnPressed[0])) {\n    S.old.set(S.rgb);\n    S.fade = 1;\n    fresh(S);\n  }\n  const h = d * S.speed * RATE;\n  S.fade = max(0, S.fade - h / FADE);\n  const n = Math.ceil(h / DT - 1e-9);\n  for (let i = 0; i \u003c n; i++) step(S, h / n);\n}\n\n// Brightness and the share of white for a density d, the number of\n// sheets on an LED, in steps of 1/32.\nconst NB = 512, BR = new Float32Array(NB), WH = new Float32Array(NB);\nfor (let e = 0; e \u003c NB; e++) (BR[e] = (1 - exp(-(e + 0.5) / 32 / 0.35)) * 255), (WH[e] = cl(((e + 0.5) / 32 - 2) / 6, 0, 0.7));\n\nfunction splat(D, F, px, py, w, f) {\n  const ix = floor(px), iy = floor(py);\n  if (ix \u003c 0 || iy \u003c 0 || ix >= W - 1 || iy >= H - 1) return;\n  const tx = px - ix, ty = py - iy, p = iy * W + ix;\n  const w00 = w * (1 - tx) * (1 - ty), w10 = w * tx * (1 - ty), w01 = w * (1 - tx) * ty, w11 = w * tx * ty;\n  D[p] += w00;\n  D[p + 1] += w10;\n  D[p + W] += w01;\n  D[p + W + 1] += w11;\n  F[p] += w00 * f;\n  F[p + 1] += w10 * f;\n  F[p + W] += w01 * f;\n  F[p + W + 1] += w11 * f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { x, v, f, D, F, rgb, old, lut, px, py } = S, fd = S.fade;\n  for (let i = 0; i \u003c 256; i++) hsv(S.hue + 0.55 + 0.4 * (i / 255), 0.8, 1, lut, i * 3);\n  D.fill(0);\n  F.fill(0);\n  // Each sheet is laid down bilinearly where it is now and, if it moved\n  // more than 0.8 LED since the last frame, halfway back as well, so an\n  // arm sliding along itself reads as a line and not a row of dots. An LED\n  // shows the mean place along the strip of the sheets on it.\n  for (let i = 0; i \u003c N; i++) {\n    const qx = XC + x[i] * SX - 0.5, qy = VC - v[i] * SV - 0.5;\n    if (S.fresh) (px[i] = qx), (py[i] = qy);\n    const mx = 0.5 * (qx + px[i]), my = 0.5 * (qy + py[i]);\n    if ((qx - mx) ** 2 + (qy - my) ** 2 \u003c 0.16) splat(D, F, qx, qy, 1, f[i]);\n    else splat(D, F, qx, qy, 0.5, f[i]), splat(D, F, mx, my, 0.5, f[i]);\n    (px[i] = qx), (py[i] = qy);\n  }\n  S.fresh = false;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x2 = 0; x2 \u003c W; x2++, p++) {\n      const d = D[p], o = p * 3;\n      let r = 0, g = 0, b = 0;\n      if (d > 0.004) {\n        const q = min(255, round((F[p] / d) * 255)) * 3, e = min(NB - 1, (d * 32) | 0), br = BR[e], wh = WH[e];\n        r = (lut[q] * (1 - wh) + wh) * br;\n        g = (lut[q + 1] * (1 - wh) + wh) * br;\n        b = (lut[q + 2] * (1 - wh) + wh) * br;\n      }\n      if (fd > 0) (r = r * (1 - fd) + old[o] * fd), (g = g * (1 - fd) + old[o + 1] * fd), (b = b * (1 - fd) + old[o + 2] * fd);\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n      display.setPixel(x2, y, r, g, b);\n    }\n}\n","randu-planes":"// ===== Patternflow pattern =====\n// Title:   RANDU Planes\n// Family:  number\n// Idea:    Consecutive triples of IBM's RANDU generator tumble as a cloud of points in a unit cube, and each time the view passes along the planes 9x - 6y + z = n the cloud snaps into the 15 parallel lines it always lay on, one colour per plane.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: multiplicative congruential generator (D. H. Lehmer, 1949), RANDU (IBM, 1960s), the spectral test (R. R. Coveyou and R. D. MacPherson, 1967), random numbers fall mainly in the planes (George Marsaglia, 1968), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Generator=0..3, Points=1.8..8\n//\n// Knob 1: Hue. Turns the plane colours round the wheel. At 0 the 15 planes run from azure through violet, red and orange to green, top to bottom at one alignment and bottom to top at the next, as the cube turns over; the cube's edges stay a faint grey.\n// Knob 2: Speed. How fast the cube tumbles. At 2 the view lines up with the planes every 3.2 s, first at 2.5 s, and lingers there: it turns at a tenth of its mean pace while the planes stand edge on, so the lines hold for about 0.4 s, and at 1.9 times it while they face the viewer. At 0.2 the alignments come 32 s apart, at 3 every 2.1 s.\n// Knob 3: Generator. Picks the multiplier a of x -> a x mod m, and the view always passes along that generator's own widest planes. At 0 RANDU's 65539 = 2^16 + 3 puts the triples on 15 planes 5.2 LEDs apart; at 1 65541 = 2^16 + 5 on 35 planes 2.1 LEDs apart, the same trick one step on; at 2 George Marsaglia's 69069 mod 2^32 (1972) on 394 planes 0.16 LEDs apart, and at 3 the minimal standard 16807 mod 2^31 - 1 of Stephen Park and Keith Miller (1988) on 764 planes 0.09 LEDs apart, so for these two the cloud never lines up.\n// Knob 4: Points. How many triples, in thousands: 1800 at the opening, 8000 at the top, where every line at an alignment is solid.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, sqrt, sin, cos, abs, min, max, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The generators: multiplier, modulus, and the shortest integer u with\n// u1 + a u2 + a^2 u3 = 0 mod m/g, found by lattice reduction, where g is\n// the gcd of the differences between outputs: 2 for RANDU, 4 for the\n// multipliers 5 mod 8 that keep x mod 4, 1 for the prime modulus. Every\n// triple p = (x, a x mod m, a^2 x mod m) / m then has u . p in Z + c for\n// one fixed c, so it lies on one of the planes u . p = n + c, 1/|u|\n// apart. All products stay below 2^53, so the doubles are exact.\nconst GENS = [\n  { a: 65539, m: 2 ** 31, u: [9, -6, 1] },\n  { a: 65541, m: 2 ** 31, u: [25, -10, 1] },\n  { a: 69069, m: 2 ** 32, u: [22, 13, -359] },\n  { a: 16807, m: 2 ** 31 - 1, u: [90, -44, 631] },\n];\nconst MAXP = 8000;\nconst LING = 0.9;\nconst mulmod = (a, x, m) => {\n  const y = a * x;\n  return y - floor(y / m) * m;\n};\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, gen: -9, count: 1800, psi: 0.687,\n    qh: new Float64Array(MAXP), qn: new Float64Array(MAXP), qw: new Float64Array(MAXP), col: new Uint8Array(MAXP),\n    ncol: 15, sc: 56, h: [1, 0, 0], n: [0, 1, 0], w: [0, 0, 1],\n    R: new Uint8Array(N), G: new Uint8Array(N), B: new Uint8Array(N), Z: new Float32Array(N), c: [0, 0, 0],\n  };\n}\n\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst unit = (a) => {\n  const l = sqrt(dot(a, a));\n  return [a[0] / l, a[1] / l, a[2] / l];\n};\nconst l1 = (a) => abs(a[0]) + abs(a[1]) + abs(a[2]);\n\n// The view: the cube tumbles about a screen-horizontal axis h that lies in\n// the planes, so twice a turn the view looks along them and they stand\n// edge on as horizontal lines stacked down the panel. Of all such axes, h\n// is the one along which the cube is narrowest, so it fits the 64 LEDs.\nfunction aim(S, g) {\n  const n = unit(g.u);\n  const e1 = unit(cross(n, abs(n[0]) \u003c 0.9 ? [1, 0, 0] : [0, 1, 0])), e2 = cross(n, e1);\n  let best = null;\n  for (let i = 0; i \u003c 360; i++) {\n    const t = (i * PI) / 360, h = [0, 1, 2].map((j) => e1[j] * cos(t) + e2[j] * sin(t));\n    if (!best || l1(h) \u003c l1(best)) best = h;\n  }\n  S.n = n;\n  S.h = best;\n  S.w = cross(n, best);\n  S.sc = min(56, 62 / l1(best));\n}\n\nfunction build(S) {\n  const g = GENS[S.gen], m = g.m, u = g.u;\n  aim(S, g);\n  // Overlapping triples of consecutive outputs from the odd seed 12345.\n  let x = 12345, y = mulmod(g.a, x, m), z = mulmod(g.a, y, m);\n  const pl = new Int32Array(MAXP);\n  let lo = 1e9, hi = -1e9;\n  for (let k = 0; k \u003c MAXP; k++) {\n    const p = [x / m - 0.5, y / m - 0.5, z / m - 0.5];\n    S.qh[k] = dot(p, S.h);\n    S.qn[k] = dot(p, S.n);\n    S.qw[k] = dot(p, S.w);\n    pl[k] = floor((u[0] * x + u[1] * y + u[2] * z) / m + 0.125);\n    lo = min(lo, pl[k]);\n    hi = max(hi, pl[k]);\n    x = y;\n    y = z;\n    z = mulmod(g.a, z, m);\n  }\n  // One colour per plane where there are at most 15; past that the plane\n  // index mod 15, so neighbouring planes never share a colour.\n  const count = hi - lo + 1;\n  S.ncol = min(15, count);\n  for (let k = 0; k \u003c MAXP; k++) S.col[k] = (pl[k] - lo) % 15;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const gen = round(cl(k[2], 0, 3));\n  if (gen !== S.gen) {\n    S.gen = gen;\n    build(S);\n  }\n  S.count = round(1000 * cl(k[3], 1.8, 8));\n  // psi runs at a constant rate, pi every 3.2 s at Speed 2; the tumble\n  // angle phi = psi - LING sin(2 psi) / 2 is psi itself at each alignment\n  // (psi a multiple of pi) but moves there at a tenth of the pace, so the\n  // lines hold for about 0.4 s.\n  S.psi += (d * S.speed * PI) / 6.4;\n}\n\nfunction put(S, x, y, z, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  if (z \u003c S.Z[p]) return;\n  S.Z[p] = z;\n  S.R[p] = r;\n  S.G[p] = g;\n  S.B[p] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const phi = S.psi - (LING * sin(2 * S.psi)) / 2, cp = cos(phi), sp = sin(phi), sc = S.sc, c = S.c;\n  S.R.fill(0);\n  S.G.fill(0);\n  S.B.fill(0);\n  S.Z.fill(-9);\n  // The cube's edges, faint, behind everything.\n  const corner = (i) => {\n    const q = [(i & 1) - 0.5, ((i >> 1) & 1) - 0.5, ((i >> 2) & 1) - 0.5];\n    const a = dot(q, S.n), b = dot(q, S.w);\n    return [31.5 + sc * dot(q, S.h), 63.5 - sc * (a * cp + b * sp)];\n  };\n  for (let i = 0; i \u003c 8; i++)\n    for (const bit of [1, 2, 4]) {\n      if (i & bit) continue;\n      const [x0, y0] = corner(i), [x1, y1] = corner(i | bit);\n      const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n      for (let t = 0; t \u003c= n; t++) put(S, round(x0 + ((x1 - x0) * t) / n), round(y0 + ((y1 - y0) * t) / n), -5, 34, 36, 44);\n    }\n  const pal = [];\n  for (let j = 0; j \u003c 15; j++) {\n    hsv(S.hue + 0.55 + (0.8 * j) / max(1, S.ncol - 1), 0.85, 1, c);\n    pal.push([c[0], c[1], c[2]]);\n  }\n  for (let k = 0; k \u003c S.count; k++) {\n    const a = S.qn[k], b = S.qw[k];\n    // Screen right is h and up is n cos phi + w sin phi, so the depth\n    // toward the viewer, h x up, is n sin phi - w cos phi.\n    const y = 63.5 - sc * (a * cp + b * sp), z = a * sp - b * cp;\n    // Nearer points brighter: 0.5 at the back of the cube, 1 at the front.\n    const v = 255 * (0.75 + 0.29 * z), col = pal[S.col[k]];\n    put(S, round(31.5 + sc * S.qh[k]), round(y), z, round(col[0] * v), round(col[1] * v), round(col[2] * v));\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, S.R[p], S.G[p], S.B[p]);\n}\n","richardson-dividers":"// ===== Patternflow pattern =====\n// Title:   Richardson Dividers\n// Family:  fractal\n// Idea:    A random self-similar curve of dimension D runs corner to corner across the top of the panel while a pair of dividers walks along it at a fixed opening, swinging from point to point and laying down a polygon of equal chords that cuts off the curve's bays, and each finished walk drops the point (log s, log L) onto a log-log plot below, so as the opening shrinks from 23 LEDs to under one in ten steps of 0.7 the points climb a straight line of slope 1 - D.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Richardson's divider method (Lewis Fry Richardson, 1961), fractal dimension of a coastline (Benoit Mandelbrot, 1967), dimension of random recursive constructions (R. Daniel Mauldin and S. C. Williams, 1986), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Roughness=-1..1, Cutoff=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the curve is lilac, the dividers' polygon, its bays and the measured points sea green and the dividers white; at 0.25 the curve pink and the polygon blue, at 0.5 lime and pink, at 0.75 teal and yellow. The curve skips the orange part of the wheel, which reads brown when dim.\n// Knob 2: Speed. At 2 each opening takes 1.45 s, a walk of 1.1 s and a pause of 0.35 s with the polygon complete, so the ten openings of one curve take 14.5 s before a fresh curve fades in; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Roughness. Sets the dimension D = 1.27 + 0.25 x K3: 1.02 at -1, about the coast of South Africa in Richardson's table, 1.27 at 0, a little above the west coast of Britain, and 1.52 at 1. The curve grows from 109 LEDs long, a gentle wobble, through 501 to 2,185, a crumpled line that is shrunk to fit, and the slope of the line on the plot goes from -0.02 to -0.52; over 60 curves each the fitted slope of the ten points averaged -0.019, -0.137, -0.261, -0.371 and -0.496 at the five stops, a little shallower than 1 - D. The curve keeps its random choices, so turning the knob bends the same curve.\n// Knob 4: Cutoff. The curve stops dividing once a piece is no longer than 0.3 x 100^K4 LEDs: 0.40 at the opening 0.06, where the pieces average 0.19 LEDs, far under the smallest opening of 0.93, so the points keep to the line; 3 at 0.5, pieces of 1.3, and 30 at 1, where the curve is a polygon of 10 to 16 pieces averaging 12.5 LEDs. The plot's dotted mark stands at the mean piece, and to the left of it the points go flat: dividers shorter than a piece measure the polygon's own length.\n// Buttons: K1 tap draws a fresh curve and starts again from the widest opening.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, acos, atan2, pow, hypot, log10, round, ceil, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nconst wheel = (h) => 0.17 + (h - floor(h)) * 0.86;\n\n// A 32-bit hash for the curve's random choices: each piece's choices come\n// from its own id, and its four children's ids from it, so a change of D\n// or of the cutoff redraws the same tree of choices.\nfunction hash(a) {\n  a = Math.imul(a ^ (a >>> 16), 0x7feb352d);\n  a = Math.imul(a ^ (a >>> 15), 0x846ca68b);\n  return (a ^ (a >>> 16)) >>> 0;\n}\n\n// The curve runs from one corner of rows 0 to 85 to the other, (4, 4) to\n// (60, 82) or (60, 4) to (4, 82), 96 LEDs. Every piece P -> Q is replaced\n// by four: P -> P1 and P3 -> Q along the piece, each r long, and two up to\n// an apex off to one side, a coin flip deciding which. r is the Koch-type\n// ratio for D, 1 / (2 + 2 cos theta) with 2 + 2 cos theta = 4^(1/D), times\n// a random factor in 0.85..1.15; the apex sits at 0.5 + delta along the\n// piece, delta random in -0.07..0.07, and at the height h that makes\n// 2 r^D + r2^D + r3^D = 1, to 1e-15 after four Newton steps. Every\n// generator then has similarity dimension D, so by Mauldin and Williams\n// the curve has dimension D, and the random ratios smear the log-periodic\n// staircase one fixed ratio puts into L(s).\nconst TOP = 86;\nfunction makeCurve(seed, D, cut) {\n  const c = pow(4, 1 / D) / 2 - 1, rK = 1 / (2 + 2 * c), hK = rK * sin(acos(c));\n  const right = seed & 1, sx = right ? 4 : 60, ex = right ? 60 : 4;\n  const X = [sx], Y = [4];\n  const emit = (ax, ay, bx, by, id, depth) => {\n    const dx = bx - ax, dy = by - ay, len = hypot(dx, dy);\n    if (len \u003c= cut || depth > 9) {\n      X.push(bx);\n      Y.push(by);\n      return;\n    }\n    const z = hash(id), f = z & 2 ? 1 : -1;\n    const de = 0.07 * ((((z >>> 2) & 1023) / 1023) * 2 - 1);\n    const r = min(rK * (1 + 0.15 * ((((z >>> 12) & 1023) / 1023) * 2 - 1)), 0.48 - abs(de));\n    const a1 = 0.5 + de - r, a2 = 0.5 - de - r, rd = 2 * pow(r, D);\n    let h = hK;\n    for (let it = 0; it \u003c 4; it++) {\n      const q2 = a1 * a1 + h * h, q3 = a2 * a2 + h * h;\n      const g = rd + pow(q2, D / 2) + pow(q3, D / 2) - 1, gp = D * h * (pow(q2, D / 2 - 1) + pow(q3, D / 2 - 1));\n      h = max(1e-4, h - g / max(gp, 1e-6));\n    }\n    const nx = -dy * f, ny = dx * f;\n    const p1x = ax + r * dx, p1y = ay + r * dy, p3x = bx - r * dx, p3y = by - r * dy;\n    const p2x = ax + (0.5 + de) * dx + h * nx, p2y = ay + (0.5 + de) * dy + h * ny;\n    const k = Math.imul(id, 4) + 0x9e37;\n    emit(ax, ay, p1x, p1y, hash(k), depth + 1);\n    emit(p1x, p1y, p2x, p2y, hash(k + 1), depth + 1);\n    emit(p2x, p2y, p3x, p3y, hash(k + 2), depth + 1);\n    emit(p3x, p3y, bx, by, hash(k + 3), depth + 1);\n  };\n  emit(sx, 4, ex, 82, hash(seed), 0);\n  // Shrink it about its middle into columns 1 to 62 and rows 1 to 84 if it\n  // came out bigger; the plot divides L by the end-to-end length.\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c X.length; i++) (x0 = min(x0, X[i])), (x1 = max(x1, X[i])), (y0 = min(y0, Y[i])), (y1 = max(y1, Y[i]));\n  const sc = min(1, 61 / (x1 - x0), 83 / (y1 - y0)), mx = (x0 + x1) / 2, my = (y0 + y1) / 2;\n  const n = X.length - 1, PX = new Float32Array(n + 1), PY = new Float32Array(n + 1);\n  for (let i = 0; i \u003c= n; i++) (PX[i] = 31.5 + (X[i] - mx) * sc), (PY[i] = 42.5 + (Y[i] - my) * sc);\n  let len = 0;\n  for (let i = 0; i \u003c n; i++) len += hypot(PX[i + 1] - PX[i], PY[i + 1] - PY[i]);\n  const C = { seed, D, cut, n, X: PX, Y: PY, l0: hypot(PX[n] - PX[0], PY[n] - PY[0]), piece: len / n, walks: [], rows: null, ras: null };\n  for (let k = 0; k \u003c NO; k++) C.walks.push(walk(C, OPEN[k]));\n  return C;\n}\n\n// The openings, 23 LEDs down to 0.93 in ten steps of 0.7.\nconst NO = 10, OPEN = [];\nfor (let k = 0; k \u003c NO; k++) OPEN.push(23 * pow(0.7, k));\n\n// Richardson's walk: from the tip on the curve, the next tip is the first\n// point further along the curve at distance s, found on the piece that\n// first leaves the circle of radius s; the walk ends when the rest of the\n// curve stays inside the circle, and the length is n s plus that last gap.\nfunction walk(C, s) {\n  const { X, Y, n } = C, tx = [X[0]], ty = [Y[0]], tj = [0];\n  let cx = X[0], cy = Y[0], ax = cx, ay = cy, i = 0;\n  const s2 = s * s;\n  for (;;) {\n    let hit = false;\n    for (; i \u003c n; i++) {\n      const bx = X[i + 1], by = Y[i + 1];\n      if ((bx - cx) * (bx - cx) + (by - cy) * (by - cy) >= s2) {\n        const dx = bx - ax, dy = by - ay, fx = ax - cx, fy = ay - cy, A = dx * dx + dy * dy, B = 2 * (fx * dx + fy * dy);\n        const Cq = fx * fx + fy * fy - s2, t = (-B + sqrt(max(0, B * B - 4 * A * Cq))) / (2 * A);\n        cx = ax = ax + t * dx;\n        cy = ay = ay + t * dy;\n        tx.push(cx);\n        ty.push(cy);\n        tj.push(i);\n        hit = true;\n        break;\n      }\n      ax = bx;\n      ay = by;\n    }\n    if (!hit) break;\n  }\n  const steps = tx.length - 1, gap = hypot(X[n] - cx, Y[n] - cy);\n  return { s, tx, ty, tj, steps, gap, L: steps * s + gap };\n}\n\n// What a frame needs of a curve beyond its points: the light it leaves on\n// each LED, and where it crosses the middle of each row, for the bays.\nfunction prepare(C) {\n  const { X, Y, n } = C, ras = new Float32Array(W * TOP), rx = [], ri = [];\n  for (let y = 0; y \u003c TOP; y++) rx.push([]), ri.push([]);\n  for (let i = 0; i \u003c n; i++) {\n    const x0 = X[i], y0 = Y[i], x1 = X[i + 1], y1 = Y[i + 1], len = hypot(x1 - x0, y1 - y0), m = max(1, ceil(len * 3));\n    for (let j = 0; j \u003c m; j++) {\n      const t = (j + 0.5) / m, x = x0 + (x1 - x0) * t, y = y0 + (y1 - y0) * t, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy, w = len / m;\n      if (ix >= 0 && ix \u003c W - 1 && iy >= 0 && iy \u003c TOP - 1) {\n        const p = iy * W + ix;\n        ras[p] += (1 - fx) * (1 - fy) * w;\n        ras[p + 1] += fx * (1 - fy) * w;\n        ras[p + W] += (1 - fx) * fy * w;\n        ras[p + W + 1] += fx * fy * w;\n      }\n    }\n    const ya = min(y0, y1), yb = max(y0, y1);\n    for (let y = max(0, ceil(ya - 0.5)); y \u003c TOP && y + 0.5 \u003c yb; y++) {\n      rx[y].push(x0 + ((x1 - x0) * (y + 0.5 - y0)) / (y1 - y0));\n      ri[y].push(i);\n    }\n  }\n  for (let p = 0; p \u003c ras.length; p++) ras[p] = min(1, ras[p]) ** 0.6;\n  C.ras = ras;\n  C.rows = rx.map((a) => Float32Array.from(a));\n  C.rowi = ri.map((a) => Int32Array.from(a));\n}\n\nconst T_WALK = 1.1, T_HOLD = 0.35, T_OPEN = T_WALK + T_HOLD, T_FADE = 0.5;\nconst points = (C) => C.walks.map((w) => [log10(w.s), log10(w.L / C.l0)]);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, D: 1.27, cut: 0.39, warm: false, k: 0, t: 0, fade: 1, ay: null,\n    cur: null, old: null, ghosts: [],\n    R: new Float32Array(N), G: new Float32Array(N), B: new Float32Array(N), c: new Float32Array(18), xs: new Float32Array(4096),\n  };\n}\n\nconst newSeed = () => (Math.random() * 4294967296) >>> 0;\n\nfunction fresh(S) {\n  if (S.cur) {\n    // The finished curve's points stay on the plot, dimmer, for two curves.\n    S.ghosts.unshift({ D: S.cur.D, cut: S.cur.cut, pts: points(S.cur) });\n    S.ghosts.length = min(S.ghosts.length, 2);\n    S.old = S.cur;\n  }\n  S.cur = makeCurve(newSeed(), S.D, S.cut);\n  prepare(S.cur);\n  S.k = 0;\n  S.t = 0;\n  S.fade = S.old ? 0 : 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const D = 1.27 + 0.25 * cl(k[2], -1, 1), cut = 0.3 * pow(100, cl(k[3], 0, 1));\n  if (!S.warm) {\n    // Open with two curves already measured, so the plot shows the line.\n    S.D = D;\n    S.cut = cut;\n    for (let g = 0; g \u003c 2; g++) S.ghosts.push({ D, cut, pts: points(makeCurve(newSeed(), D, cut)) });\n    fresh(S);\n    S.warm = true;\n  }\n  if (abs(D - S.D) > 0.002 || abs(cut - S.cut) / S.cut > 0.01) {\n    // The same choices bent to the new D or cut at the new length; points\n    // measured on another curve leave the plot.\n    S.D = D;\n    S.cut = cut;\n    S.cur = makeCurve(S.cur.seed, D, cut);\n    prepare(S.cur);\n    S.ghosts = S.ghosts.filter((g) => abs(g.D - D) \u003c 0.002 && abs(g.cut - cut) / cut \u003c 0.01);\n  }\n  if (input.btnPressed && input.btnPressed[0]) fresh(S);\n  const ds = (d * S.speed) / 2;\n  // Where the plot's middle sits: the mean of the ghost points and of all\n  // ten points of the curve being walked, known before it is walked.\n  let sum = 0, cnt = 0;\n  for (const g of S.ghosts) for (const p of g.pts) (sum += p[1]), cnt++;\n  for (const p of points(S.cur)) (sum += p[1]), cnt++;\n  const want = sum / cnt;\n  S.ay = S.ay === null ? want : S.ay + (want - S.ay) * min(1, ds * 6);\n  S.fade = min(1, S.fade + ds / T_FADE);\n  S.t += ds;\n  while (S.t >= T_OPEN) {\n    S.t -= T_OPEN;\n    if (++S.k >= NO) fresh(S);\n  }\n}\n\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction line(S, x0, y0, x1, y1, v, c, o) {\n  const L = hypot(x1 - x0, y1 - y0), n = max(1, ceil(L * 3)), w = (v * L) / n;\n  for (let i = 1; i \u003c= n; i++) splat(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n}\n\n// The plot: log10 s across, 37.4 LEDs a decade, from -0.1 at column 3 to\n// 1.45 at column 61, and log10 (L / L0) up at 44 rows a decade on rows 87\n// to 124. Only the slope means anything on a log-log plot, so the plot\n// holds the middle of all its points, which falls at the openings' mean\n// log10 s = 0.665, on row 105.5, and the points spread up and down from it.\nconst KX = 58 / 1.55, KY = 44, PB = 124, PT = 87, PC = 105.5, MLS = log10(23) + 4.5 * log10(0.7);\nconst plx = (ls) => 3 + (ls + 0.1) * KX;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cur) return;\n  const { R, G, B, c, cur } = S;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  // 0 the curve, 3 the polygon and points, 6 the bays, 9 white, 12 grey,\n  // 15 the dim points of earlier curves.\n  hsv(wheel(0.65 + S.hue), 0.62, 0.7, c, 0);\n  hsv(0.42 + S.hue, 0.8, 1, c, 3);\n  hsv(0.42 + S.hue, 0.8, 0.38, c, 6);\n  c[9] = c[10] = c[11] = 1;\n  c[12] = c[13] = c[14] = 0.3;\n  hsv(0.42 + S.hue, 0.45, 0.6, c, 15);\n\n  const w = cur.walks[S.k], done = S.t >= T_WALK, prog = done ? w.steps : (S.t / T_WALK) * w.steps;\n  const m = min(w.steps, floor(prog)), fr = done ? 0 : prog - m;\n  // Bays: the curve up to the tip and the polygon back to the start bound\n  // them, filled by the even-odd rule along the middle of each row.\n  const jt = done ? cur.n : w.tj[m], tipx = w.tx[m], tipy = w.ty[m], xs = S.xs;\n  for (let y = 0; y \u003c TOP; y++) {\n    const rx = cur.rows[y], ri = cur.rowi[y], yc = y + 0.5;\n    let n = 0;\n    for (let q = 0; q \u003c rx.length && n \u003c 4000; q++) if (ri[q] \u003c jt) xs[n++] = rx[q];\n    const cross = (x0, y0, x1, y1) => {\n      if (y0 \u003c= yc !== y1 \u003c= yc && n \u003c 4096) xs[n++] = x0 + ((x1 - x0) * (yc - y0)) / (y1 - y0);\n    };\n    if (!done) cross(cur.X[jt], cur.Y[jt], tipx, tipy);\n    for (let q = 0; q \u003c m; q++) cross(w.tx[q], w.ty[q], w.tx[q + 1], w.ty[q + 1]);\n    if (done) cross(tipx, tipy, cur.X[cur.n], cur.Y[cur.n]);\n    if (n \u003c 2) continue;\n    const a = xs.subarray(0, n).sort();\n    for (let q = 0; q + 1 \u003c n; q += 2)\n      for (let x = max(0, ceil(a[q] - 0.5)); x \u003c= min(W - 1, floor(a[q + 1] - 0.5)); x++) add(S, x, y, 1, c, 6);\n  }\n  // The curve, the one it replaces fading out.\n  const f = S.fade, ease = f * f * (3 - 2 * f);\n  for (let p = 0; p \u003c W * TOP; p++) {\n    let v = cur.ras[p] * ease;\n    if (S.old && f \u003c 1) v += S.old.ras[p] * (1 - ease);\n    if (v > 0) (R[p] += v * c[0]), (G[p] += v * c[1]), (B[p] += v * c[2]);\n  }\n  // The polygons of the openings already walked on this curve stay, dim,\n  // each finer one closer to the curve, down to 7.9 LEDs; finer ones lie on\n  // the curve. The one under way is bright, less so the finer it is, so a\n  // fine polygon does not bury the curve under it.\n  for (let o = 0; o \u003c min(S.k, 4); o++) {\n    const v = cur.walks[o];\n    for (let q = 0; q \u003c v.steps; q++) line(S, v.tx[q], v.ty[q], v.tx[q + 1], v.ty[q + 1], 0.6, c, 15);\n    line(S, v.tx[v.steps], v.ty[v.steps], cur.X[cur.n], cur.Y[cur.n], 0.6, c, 15);\n  }\n  // The polygon so far, and the gap to the curve's end once it is done.\n  const pv = 0.2 + 0.75 * min(1, w.s / 8);\n  for (let q = 0; q \u003c m; q++) line(S, w.tx[q], w.ty[q], w.tx[q + 1], w.ty[q + 1], pv, c, 3);\n  if (done) line(S, tipx, tipy, cur.X[cur.n], cur.Y[cur.n], pv, c, 3);\n  // The dividers: standing on the last two tips, or pivoting on the last\n  // tip while the other leg swings over to the next one, the hinge 0.45 s\n  // off the chord.\n  const px = tipx, py = tipy;\n  let qx, qy;\n  if (!done && m \u003c w.steps) {\n    const a0 = m > 0 ? atan2(w.ty[m - 1] - py, w.tx[m - 1] - px) : atan2(w.ty[1] - py, w.tx[1] - px) - PI;\n    let a1 = atan2(w.ty[m + 1] - py, w.tx[m + 1] - px);\n    while (a1 \u003c a0) a1 += 2 * PI;\n    const a = a0 + (a1 - a0) * fr;\n    qx = px + w.s * cos(a);\n    qy = py + w.s * sin(a);\n  } else if (m > 0) (qx = w.tx[m - 1]), (qy = w.ty[m - 1]);\n  else (qx = px + w.s * 0.6), (qy = py + w.s * 0.8);\n  const ex = qx - px, ey = qy - py, el = hypot(ex, ey) || 1;\n  const hx = (px + qx) / 2 + (ey / el) * 0.45 * w.s, hy = (py + qy) / 2 - (ex / el) * 0.45 * w.s;\n  line(S, px, py, hx, hy, 0.9, c, 9);\n  line(S, qx, qy, hx, hy, 0.9, c, 9);\n  splat(S, px, py, 1.4, c, 9);\n  splat(S, qx, qy, 1.4, c, 9);\n\n  // The plot. The line has slope 1 - D through the middle of the points.\n  const ay = S.ay, ply = (ll) => PC - (ll - ay) * KY;\n  const mine = points(cur).slice(0, S.k + (done ? 1 : 0));\n  for (let x = 1; x \u003c W - 1; x += 0.5) {\n    const yy = ply(ay + (1 - S.D) * ((x - 3) / KX - 0.1 - MLS));\n    if (yy >= PT - 1 && yy \u003c= PB + 1) splat(S, x, yy, 0.5, c, 12);\n  }\n  // The openings: a faint column each, evenly spaced in log s, and a tick\n  // under each along the bottom, the one being walked white.\n  for (let q = 0; q \u003c NO; q++) {\n    const x = round(plx(log10(OPEN[q])) - 0.5);\n    for (let y = PT + (q & 1); y \u003c= PB; y += 2) add(S, x, y, 0.55, c, 12);\n    add(S, x, 126, q === S.k ? 1 : 0.8, c, q === S.k ? 9 : 12);\n    add(S, x, 127, q === S.k ? 1 : 0.8, c, q === S.k ? 9 : 12);\n  }\n  // The curve's mean piece, where the line has to stop.\n  const lf = plx(log10(cur.piece));\n  if (lf > 1 && lf \u003c W - 1) for (let y = PT; y \u003c= PB; y += 3) splat(S, lf, y, 1, c, 12);\n  for (let g = S.ghosts.length - 1; g >= 0; g--)\n    for (const p of S.ghosts[g].pts) {\n      const x = plx(p[0]), y = ply(p[1]);\n      if (y > PT - 3 && y \u003c PB + 2) for (let q = 0; q \u003c 4; q++) add(S, round(x - 0.5) + (q & 1), round(y - 0.5) + (q >> 1), g ? 0.5 : 0.75, c, 15);\n    }\n  for (const p of mine) {\n    const x = round(plx(p[0]) - 0.5), y = round(ply(p[1]) - 0.5);\n    if (y > PT - 3 && y \u003c PB + 2) for (let q = 0; q \u003c 4; q++) add(S, x + (q & 1), y + (q >> 1), 1, c, 3);\n  }\n  // The walk under way: its length so far rising as a bar at its opening.\n  const xo = plx(log10(w.s)), sofar = log10(max(1e-6, (m + fr) * w.s + (done ? w.gap : 0)) / cur.l0);\n  for (let y = PB; y >= max(PT - 3, ply(sofar)); y -= 1) splat(S, xo, y, 0.4, c, 9);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","rutherford-shadow":"// ===== Patternflow pattern =====\n// Title:   Rutherford Shadow\n// Family:  physics\n// Idea:    A parallel beam of equal-energy particles streams up the panel past a repelling nucleus a third of the way up, each particle on its own Coulomb hyperbola with the nucleus at the outer focus, and since every hyperbola only touches the parabola with its focus at the nucleus and its vertex d below it, the beam leaves a sharp parabolic shadow above the nucleus, its edge lit by the orbits that bunch along it while the few head-on particles turn back down in gold.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rutherford scattering, tan(theta/2) = d / 2b (Ernest Rutherford, 1911), after the gold-foil scattering of alpha particles (Hans Geiger and Ernest Marsden, 1909), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Charge=1..6, Attract=0..1\n//\n// Knob 1: Hue. Turns the beam's colours round the wheel together. At 0 particles that came in on the left of the nucleus are cyan, those on the right violet, and those turned back by more than 90 degrees gold; at 0.25 violet, red and green; at 0.5 red, lime and azure; at 0.75 lime, cyan and magenta. The nucleus stays warm white.\n// Knob 2: Speed. At 2 a particle far from the nucleus moves 45 LEDs a second and crosses the panel in about 3 s, its trail about 10 LEDs long. At 0.2 all of it is ten times slower, at 3 half as fast again; the trails keep their length.\n// Knob 3: Charge. The head-on turning distance d, in LEDs, which grows with the nucleus's charge over the beam's energy. The shadow is the parabola Y = X^2 / 4d - d, Y up the panel from the nucleus: at 1 it is 4 LEDs wide level with the nucleus and 37 wide on the top row, at 2 8 and 53, at 3 12 wide and filling the top 4 rows, at 6 24 wide and filling every row above row 49. A particle with impact parameter under d / 2 turns back by more than 90 degrees, 1 in 72 of the beam at 1 and 1 in 12 at 6.\n// Knob 4: Attract. Turns the charge through zero: the turning distance is d cos(pi K4), 0.98 d at the opening 0.06, 0.71 d at 0.25, nothing at 0.5, where the beam runs straight through, and -d at 1, where the nucleus attracts as hard as it repelled. There the orbits bend in, cross behind the nucleus and fill the shadow, cyan into the violet half and violet into the cyan, and a particle that would pass within 0.35 LED of the centre is taken in, those with impact parameter under 0.69 LED at d = 1.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, sin, cos, atan, round, random, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Units: one LED, and one second at Speed 2. The nucleus sits at the corner\n// of four LEDs, 42 rows above the bottom edge. Orbits are worked in its own\n// frame: X to the right, Y up the panel (downstream), so an LED at panel\n// (x, y) is X = x - XN, Y = YN - y.\nconst XN = 32, YN = 86;\nconst V0 = 45; // beam speed far from the nucleus, LEDs a second\nconst BMAX = 36; // impact parameters fill -36..36, 4 LEDs past each edge\nconst FLUX = 1.2; // particles a second per LED of beam width\nconst TAU = 0.1; // trail fade, seconds\nconst TRAIL = 0.9; // what a trail lays on one LED\nconst TAU_L = 3, GLOW = 0.016, GLOW_REF = 0.1; // the long exposure's fade and gain\nconst RNUC = 0.35; // an attracted particle this close is taken in\nconst CAP = 1400;\n\n// The shadow. Put X = r cos(phi), Y = r sin(phi) into the orbit equation\n// below and it becomes b^2 - X b + (s / 2)(r + Y) = 0, a quadratic in the\n// impact parameter b of the orbits through (X, Y). Two orbits, both from\n// the same side, pass a point where X^2 > 2 s (r + Y); none where it is\n// less; and on X^2 = 2 s (r + Y), which is the parabola Y = X^2 / 4s - s,\n// the two meet in one, b = X / 2, which touches the parabola there. A\n// separate leapfrog run of 2000 orbits from 4000 LEDs below, energy kept to\n// 1e-9, found the nearest any came to the axis at heights -0.9 d to 80\n// LEDs equal to 2 sqrt(d (Y + d)) to four decimals, at b = X / 2 each time.\n// In this pattern, 20 s at each of five repelling settings put one of\n// 572,000 particle positions inside the parabola, by 0.00003 LED; every\n// position lay within 0.026 LED of its exact hyperbola and every energy\n// within 0.06% of V0^2 / 2. Attracting (s \u003c 0) the discriminant\n// X^2 + 2|s|(r + Y) never vanishes: through every point pass two orbits,\n// one from each side, and there is no envelope and no shadow. Above about\n// Y = d/2 the two even share the beam's own flux between them, so in the\n// plane they cross behind the nucleus without bunching.\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, d: 1, q: 1, acc: 0, warm: false, n: 0,\n    X: new Float64Array(CAP), Y: new Float64Array(CAP), VX: new Float64Array(CAP), VY: new Float64Array(CAP),\n    B: new Float32Array(CAP), px: new Float32Array(CAP), py: new Float32Array(CAP),\n    R: new Float32Array(N), G: new Float32Array(N), Bl: new Float32Array(N), c: [0, 0, 0],\n    L: new Float32Array(N * 3), Lt: new Float32Array(N * 3), Lb: new Float32Array(N * 3), head: new Int16Array(N),\n  };\n}\n\n// Place a new particle exactly on its incoming orbit where it crosses Y.\n// For impact parameter b > 0 and signed turning distance s (s > 0 repels),\n// the orbit equation u'' + u = -s / 2b^2 with the particle coming in from\n// phi = -pi/2 gives u = 1/r = cos(phi) / b - (s / 2b^2) (1 + sin(phi)).\n// Energy and angular momentum b V0 then give the velocity.\nfunction spawn(S, b, Y) {\n  if (S.n >= CAP) return;\n  const s = S.d * S.q, ab = b \u003c 0 ? -b : b, sg = b \u003c 0 ? -1 : 1;\n  const c = s / (2 * ab * ab);\n  const u = (ph) => cos(ph) / ab - c * (1 + sin(ph));\n  let X, YY, vx, vy;\n  if (s === 0) {\n    X = ab;\n    YY = Y;\n    vx = 0;\n    vy = V0;\n  } else {\n    // y(phi) = sin(phi) / u(phi) rises from -infinity on the incoming leg\n    // up to the closest approach (repelled) or to the side of the nucleus.\n    let lo = -PI / 2 + 1e-12, hi = s > 0 ? -atan(s / (2 * ab)) : 0;\n    for (let i = 0; i \u003c 44; i++) {\n      const m = 0.5 * (lo + hi);\n      if (sin(m) / u(m) \u003c Y) lo = m;\n      else hi = m;\n    }\n    const ph = 0.5 * (lo + hi), uu = u(ph), r = 1 / uu;\n    X = r * cos(ph);\n    YY = r * sin(ph);\n    const v2 = V0 * V0 * (1 - s * uu), vt = ab * V0 * uu, vr = -sqrt(max(0, v2 - vt * vt));\n    vx = vr * cos(ph) - vt * sin(ph);\n    vy = vr * sin(ph) + vt * cos(ph);\n  }\n  const i = S.n++;\n  S.X[i] = sg * X;\n  S.Y[i] = YY;\n  S.VX[i] = sg * vx;\n  S.VY[i] = vy;\n  S.B[i] = b;\n  S.px[i] = XN + S.X[i];\n  S.py[i] = YN - S.Y[i];\n}\n\nfunction kill(S, i) {\n  const j = --S.n;\n  S.X[i] = S.X[j];\n  S.Y[i] = S.Y[j];\n  S.VX[i] = S.VX[j];\n  S.VY[i] = S.VY[j];\n  S.B[i] = S.B[j];\n  S.px[i] = S.px[j];\n  S.py[i] = S.py[j];\n}\n\n// Kick-drift-kick leapfrog in the nucleus's frame, the step cut so that no\n// step moves a particle more than a twentieth of its distance from the\n// nucleus or lets the force turn it by more than about that.\nfunction advance(S, ds) {\n  const k = (S.d * S.q * V0 * V0) / 2, ak = k \u003c 0 ? -k : k;\n  for (let i = 0; i \u003c S.n; i++) {\n    let x = S.X[i], y = S.Y[i], vx = S.VX[i], vy = S.VY[i], t = ds, dead = false;\n    for (let it = 0; it \u003c 4000 && t > 0; it++) {\n      const r2 = x * x + y * y, r = sqrt(r2), sp = sqrt(vx * vx + vy * vy) + 1e-9;\n      if (r \u003c RNUC) {\n        dead = true;\n        break;\n      }\n      let h = 0.05 * (r / sp);\n      if (ak > 0) h = min(h, 0.05 * sqrt((r2 * r) / ak));\n      h = min(h, t);\n      t -= h;\n      let f = k / (r2 * r);\n      vx += 0.5 * h * f * x;\n      vy += 0.5 * h * f * y;\n      x += h * vx;\n      y += h * vy;\n      const q2 = x * x + y * y;\n      f = k / (q2 * sqrt(q2));\n      vx += 0.5 * h * f * x;\n      vy += 0.5 * h * f * y;\n    }\n    S.X[i] = x;\n    S.Y[i] = y;\n    S.VX[i] = vx;\n    S.VY[i] = vy;\n    const px = XN + x, py = YN - y;\n    if (dead || py \u003c -3 || py > H + 4 || px \u003c -4 || px > W + 4) {\n      kill(S, i);\n      i--;\n    }\n  }\n}\n\nfunction feed(S, ds) {\n  // Poisson arrivals across the beam; each one starts a random part of this\n  // step's travel below the panel's bottom edge.\n  S.acc += ds * FLUX * 2 * BMAX;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    let b = (2 * random() - 1) * BMAX;\n    if (b > -0.01 && b \u003c 0.01) b = 0.01;\n    spawn(S, b, YN - H - 1 - random() * V0 * ds);\n  }\n}\n\n// One trail colour per particle: the side of the beam it came from, cyan on\n// the left and violet on the right, and gold once it has been turned back\n// by more than 90 degrees, tan(theta / 2) = |s| / 2|b| > 1.\nfunction colour(S, b, out) {\n  const ab = b \u003c 0 ? -b : b, s = S.d * S.q;\n  if ((s \u003c 0 ? -s : s) > 2 * ab) hsv(S.hue + 0.12, 0.85, 1, out);\n  else hsv(S.hue + (b \u003c 0 ? 0.52 : 0.78), 0.9, 1, out);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.d = cl(kv[2], 1, 6);\n  S.q = cos(PI * cl(kv[3], 0, 1));\n  if (Math.abs(S.q) \u003c 1e-6) S.q = 0;\n  if (!S.warm) {\n    // Open on the beam already flowing: 3.27 s of it, enough for a\n    // particle to cross all 128 rows. The first 2.93 s go in steps of\n    // 1/15 s and only lay the long exposure, weighted by how much of it\n    // would have faded by then; the trails need just the last 0.33 s.\n    S.warm = true;\n    for (let i = 0; i \u003c 44; i++) step(S, 1 / 15, exp(-(43 - i) / 15 / TAU_L));\n    for (let i = 0; i \u003c 10; i++) step(S, 1 / 30, 0);\n    return;\n  }\n  step(S, (d * S.speed) / 2);\n}\n\nfunction step(S, ds, early) {\n  for (let j = 0; j \u003c S.n; j++) (S.px[j] = XN + S.X[j]), (S.py[j] = YN - S.Y[j]);\n  feed(S, ds);\n  advance(S, ds);\n  lay(S, ds, early);\n}\n\n// Trails add, so where the orbits bunch the LEDs burn brighter.\nfunction dep(S, x, y, r, g, b) {\n  const ix = floor(x), iy = floor(y);\n  if (ix \u003c 0 || ix >= W || iy \u003c 0 || iy >= H) return;\n  const p = iy * W + ix;\n  S.R[p] += r;\n  S.G[p] += g;\n  S.Bl[p] += b;\n}\n\n// Fade the trails by one step and lay each particle's path over it, the\n// path it took this step, dimmer towards where it was. An early step of the\n// opening lays only the long exposure, at weight early.\nfunction lay(S, ds, early) {\n  const R = S.R, G = S.G, B = S.Bl, c = S.c, L = S.L, fade = exp(-ds / TAU), fadeL = exp(-ds / TAU_L);\n  if (!early) {\n    for (let p = 0; p \u003c N; p++) {\n      R[p] *= fade;\n      G[p] *= fade;\n      B[p] *= fade;\n    }\n    for (let p = 0; p \u003c N * 3; p++) L[p] *= fadeL;\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const x1 = XN + S.X[i], y1 = YN - S.Y[i], x0 = S.px[i], y0 = S.py[i];\n    colour(S, S.B[i], c);\n    const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), m = min(40, 1 + floor(len * 2));\n    // Each sample stands for len / m of path, so a trail lays TRAIL on each\n    // LED of path it crosses, at any speed.\n    const share = (TRAIL * len) / m;\n    for (let j = 0; j \u003c m; j++) {\n      const a = j / m, w = share * exp((-(1 - a) * ds) / TAU);\n      const x = x0 + (x1 - x0) * a, y = y0 + (y1 - y0) * a;\n      if (!early) dep(S, x, y, c[0] * w, c[1] * w, c[2] * w);\n      // The long exposure: path length, in the particle's colour.\n      const ix = floor(x), iy = floor(y);\n      if (ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c H) {\n        const p = (iy * W + ix) * 3, e = (len / m) * (early || 1);\n        L[p] += c[0] * e;\n        L[p + 1] += c[1] * e;\n        L[p + 2] += c[2] * e;\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const R = S.R, G = S.G, B = S.Bl, L = S.L, Lb = S.Lb;\n  // The long exposure, blurred over 3 x 3 LEDs (across, then down), glows\n  // faintly under the trails: the beam's own density, dark in the shadow\n  // and brightest just outside its edge.\n  const T = S.Lt;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 3, a = x > 0 ? q - 3 : q, b = x \u003c W - 1 ? q + 3 : q;\n      for (let ch = 0; ch \u003c 3; ch++) T[q + ch] = L[a + ch] + L[q + ch] + L[b + ch];\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 3, a = y > 0 ? q - 3 * W : q, b = y \u003c H - 1 ? q + 3 * W : q;\n      const r = T[a] + T[q] + T[b], g = T[a + 1] + T[q + 1] + T[b + 1], bl = T[a + 2] + T[q + 2] + T[b + 2];\n      // Squared, so the glow is faint over the open beam and twice the\n      // density along the edge shows four times as bright.\n      const k = (max(r, g, bl) * GLOW * GLOW) / (81 * GLOW_REF);\n      Lb[q] = r * k;\n      Lb[q + 1] = g * k;\n      Lb[q + 2] = bl * k;\n    }\n  // Each head is a near-white LED drawn over its trail, left out of the\n  // trail itself so a slow beam does not smear it.\n  const head = S.head, c = S.c;\n  head.fill(-1);\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = floor(XN + S.X[i]), y = floor(YN - S.Y[i]);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) head[y * W + x] = i;\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      // The nucleus: four warm white LEDs.\n      if ((x === XN - 1 || x === XN) && (y === YN - 1 || y === YN)) display.setPixel(x, y, 255, 236, 200);\n      else if (head[p] >= 0) {\n        colour(S, S.B[head[p]], c);\n        display.setPixel(x, y, round(140 + 115 * c[0]), round(140 + 115 * c[1]), round(140 + 115 * c[2]));\n      } else {\n        const q = p * 3;\n        display.setPixel(x, y, round(min(1, R[p] + Lb[q]) * 255), round(min(1, G[p] + Lb[q + 1]) * 255), round(min(1, B[p] + Lb[q + 2]) * 255));\n      }\n    }\n}\n","clebsch-surface":"// ===== Patternflow pattern =====\n// Title:   Clebsch Surface\n// Family:  space\n// Idea:    Clebsch's diagonal cubic surface turns slowly about its three-fold axis inside a flat glass spheroid that stands the height of the panel, shaded by its normal in one colour for each of its two sides, with all 27 of its real lines drawn on it, the twelve of Schläfli's double six in two colours and the other fifteen in a third, dimmer where a sheet hides them, while a white focus steps from line to line and lights the ten lines that meet it and the points where they cross it.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Clebsch diagonal surface (Alfred Clebsch, 1871), the 27 lines on a cubic surface (Arthur Cayley and George Salmon, 1849), the double six (Ludwig Schläfli, 1858), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Glass=0..1, Tilt=12..60\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 one side of the surface is steel blue and the other mauve, one six of the double six is cyan and the other pink, and the fifteen other lines are green; at 0.5 the sides are rose and teal, the sixes magenta and azure and the fifteen violet. The wheel skips orange through lime, which read brown and olive when dim.\n// Knob 2: Speed. At 2 the surface turns a third of the way round its axis, which brings it back to the same shape, in 12 seconds, and every 2.5 seconds the focus steps to one of the ten lines that meet it; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Glass. At 0 the surface is opaque and a line behind a sheet keeps a fifth of its light; at 1 each sheet lets 65% of what is behind it through, so the back sheets show and a line behind one sheet keeps 72% of its light.\n// Knob 4: Tilt. How far the axis turns towards the eye, 12 to 60 degrees. At 12 the axis lies nearly across the panel and the spheroid's outline stands 118 LEDs tall; towards 60 the eye looks down the axis onto the three-fold star round the Eckardt point (1/3, 1/3, 1/3), and the outline shrinks to keep within the width.\n\nconst W = 64, H = 128;\nconst { sqrt, sin, cos, abs, min, max, floor, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst S5 = sqrt(5);\n\n// The surface, in the affine form with the three coordinates on an equal\n// footing: F = 81 (x^3 + y^3 + z^3) - 189 (x^2 y + x^2 z + y^2 x + y^2 z +\n// z^2 x + z^2 y) + 54 xyz + 126 (xy + yz + zx) - 9 (x^2 + y^2 + z^2) -\n// 9 (x + y + z) + 1. Swapping coordinates keeps it, so the line x = y = z is\n// an axis of three-fold symmetry; it meets the surface once, at\n// (1/3, 1/3, 1/3), where three of the lines cross (an Eckardt point).\nfunction F(x, y, z) {\n  return (\n    81 * (x * x * x + y * y * y + z * z * z) -\n    189 * (x * x * (y + z) + y * y * (x + z) + z * z * (x + y)) +\n    54 * x * y * z +\n    126 * (x * y + y * z + z * x) -\n    9 * (x * x + y * y + z * z) -\n    9 * (x + y + z) +\n    1\n  );\n}\n// Its gradient, into g.\nfunction grad(x, y, z, g) {\n  g[0] = 243 * x * x - 189 * (2 * x * (y + z) + y * y + z * z) + 54 * y * z + 126 * (y + z) - 18 * x - 9;\n  g[1] = 243 * y * y - 189 * (2 * y * (x + z) + x * x + z * z) + 54 * x * z + 126 * (x + z) - 18 * y - 9;\n  g[2] = 243 * z * z - 189 * (2 * z * (x + y) + x * x + y * y) + 54 * x * y + 126 * (x + y) - 18 * z - 9;\n}\n\n// The 27 lines, each from a base line and its images under the six ways of\n// permuting x, y, z. Fifteen have rational points: three through the\n// Eckardt point, three each through (1/6, 1/6, 0) and (0, 0, -1/3) along\n// (1, -1, 0), and six through (-1/30, 0, 1/10) along (3, 0, 1). The other\n// twelve need sqrt 5: the line through (0, (5 + s sqrt5) / 30, (5 + 3 s\n// sqrt5) / 30) and ((1 - s sqrt5) / 12, 0, (3 + s sqrt5) / 12), with s = 1\n// or -1, and its images. Those twelve are a double six.\nfunction buildLines() {\n  const base = [\n    [[1 / 3, 1 / 3, 1 / 3], [1, -1, 0], 0],\n    [[1 / 6, 1 / 6, 0], [1, -1, 0], 0],\n    [[0, 0, -1 / 3], [1, -1, 0], 0],\n    [[-1 / 30, 0, 1 / 10], [3, 0, 1], 0],\n  ];\n  for (const s of [1, -1]) {\n    const P = [0, (5 + s * S5) / 30, (5 + 3 * s * S5) / 30], Q = [(1 - s * S5) / 12, 0, (3 + s * S5) / 12];\n    base.push([P, [Q[0] - P[0], Q[1] - P[1], Q[2] - P[2]], 1]);\n  }\n  const perms = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]];\n  const L = [];\n  for (const [P, D, irr] of base)\n    for (const p of perms) {\n      const q = [P[p[0]], P[p[1]], P[p[2]]], e = [D[p[0]], D[p[1]], D[p[2]]];\n      const n = sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2]);\n      const d = [e[0] / n, e[1] / n, e[2] / n];\n      // The point nearest the origin stands for the line.\n      const k = q[0] * d[0] + q[1] * d[1] + q[2] * d[2];\n      const m = [q[0] - k * d[0], q[1] - k * d[1], q[2] - k * d[2]];\n      if (L.some((l) => abs(l.p[0] - m[0]) + abs(l.p[1] - m[1]) + abs(l.p[2] - m[2]) \u003c 1e-9 && abs(abs(l.d[0] * d[0] + l.d[1] * d[1] + l.d[2] * d[2]) - 1) \u003c 1e-9)) continue;\n      L.push({ p: m, d, irr, cls: 2, nb: [] });\n    }\n  // Two lines meet when they lie in one plane: (q - p) . (d x e) = 0, which\n  // also holds for parallel lines, and those meet at infinity.\n  const meets = (a, b) => {\n    const cx = a.d[1] * b.d[2] - a.d[2] * b.d[1], cy = a.d[2] * b.d[0] - a.d[0] * b.d[2], cz = a.d[0] * b.d[1] - a.d[1] * b.d[0];\n    return abs((b.p[0] - a.p[0]) * cx + (b.p[1] - a.p[1]) * cy + (b.p[2] - a.p[2]) * cz) \u003c 1e-9;\n  };\n  for (let i = 0; i \u003c L.length; i++) for (let j = 0; j \u003c L.length; j++) if (i !== j && meets(L[i], L[j])) L[i].nb.push(j);\n  // Where they meet: p + s d = q + t e gives s = ((q - p) x e) . n / |n|^2\n  // with n = d x e; parallel lines have no finite point.\n  for (const a of L)\n    a.at = a.nb.map((j) => {\n      const b = L[j], d = a.d, e = b.d;\n      const nx = d[1] * e[2] - d[2] * e[1], ny = d[2] * e[0] - d[0] * e[2], nz = d[0] * e[1] - d[1] * e[0];\n      const nn = nx * nx + ny * ny + nz * nz;\n      if (nn \u003c 1e-12) return null;\n      const wx = b.p[0] - a.p[0], wy = b.p[1] - a.p[1], wz = b.p[2] - a.p[2];\n      const s = ((wy * e[2] - wz * e[1]) * nx + (wz * e[0] - wx * e[2]) * ny + (wx * e[1] - wy * e[0]) * nz) / nn;\n      return [a.p[0] + s * d[0], a.p[1] + s * d[1], a.p[2] + s * d[2]];\n    });\n  // The double six splits in two by meeting: each of its lines meets five\n  // of the other six and none of its own six.\n  const irr = L.map((l, i) => i).filter((i) => L[i].irr);\n  L[irr[0]].cls = 0;\n  for (let sweep = 0; sweep \u003c 12; sweep++)\n    for (const i of irr)\n      if (L[i].cls \u003c 2) for (const j of L[i].nb) if (L[j].irr && L[j].cls === 2) L[j].cls = 1 - L[i].cls;\n  return L;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob turns hues on a wheel that skips orange through lime, which\n// read brown and olive when dim. Hues are given as they look at knob 0,\n// from 0.28 round to 1.02.\nconst tone = (h, k) => 0.28 + 0.74 * ((((h - 0.28) / 0.74 + k) % 1 + 1) % 1);\n\n// The centre of the view sits on the axis at (C0, C0, C0): there the\n// farthest of the 27 lines passes 0.456 from it, the least for any point\n// on the axis.\nconst C0 = 0.1;\nconst UX = 1 / sqrt(3);\nconst E1 = [1 / sqrt(2), -1 / sqrt(2), 0], E2 = [1 / sqrt(6), 1 / sqrt(6), -2 / sqrt(6)];\n\nexport function setup(params) {\n  params.s = {\n    L: buildLines(),\n    th: 0.4,\n    focus: 0,\n    prev: -1,\n    since: 0,\n    hue: 0,\n    glass: 0,\n    tilt: 12,\n    T: new Float32Array(W * H * 3),\n    nT: new Int8Array(W * H),\n    rgb: new Float32Array(W * H * 3),\n    ln: new Float32Array(W * H * 4),\n    g: new Float64Array(3),\n    r: new Float64Array(3),\n    c4: new Float64Array(12),\n    side: [new Float32Array(3), new Float32Array(3)],\n    cls: [new Float32Array(3), new Float32Array(3), new Float32Array(3)],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 12], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.glass = cl(kv[2], 0, 1);\n  S.tilt = cl(kv[3], 12, 60);\n  // A third of a turn in 12 s at Speed 2.\n  S.th += (d * speed * 2 * PI) / 72;\n  S.since += (d * speed) / 2;\n  // Every 2.5 s at Speed 2 the focus steps to one of the ten lines that meet\n  // it, not back to the one it came from.\n  if (S.since >= 2.5) {\n    S.since -= 2.5;\n    const nb = S.L[S.focus].nb.filter((j) => j !== S.prev);\n    S.prev = S.focus;\n    S.focus = nb[floor(Math.random() * nb.length) % nb.length];\n  }\n}\n\n// Real roots of a3 t^3 + a2 t^2 + a1 t + a0 in [t0, t1], ascending, into r,\n// at most the first `most` of them; returns how many. hint is a guess at\n// the first. The cubic's turning points cut the interval into pieces on\n// which it is monotone, and each piece whose ends differ in sign holds one\n// root.\nfunction cubicRoots(a3, a2, a1, a0, t0, t1, r, most, hint) {\n  let c1 = t1, c2 = t1;\n  const A = 3 * a3, B = 2 * a2, C = a1;\n  if (abs(A) > 1e-12) {\n    const disc = B * B - 4 * A * C;\n    if (disc > 0) {\n      const q = -0.5 * (B + (B >= 0 ? sqrt(disc) : -sqrt(disc)));\n      const u = q / A, v = q !== 0 ? C / q : u;\n      c1 = min(u, v);\n      c2 = max(u, v);\n    }\n  } else if (abs(B) > 1e-12) c1 = -C / B;\n  let n = 0, lo = t0, flo = ((a3 * t0 + a2) * t0 + a1) * t0 + a0;\n  for (let k = 0; k \u003c 3 && lo \u003c t1; k++) {\n    let hi = k === 0 ? c1 : k === 1 ? c2 : t1;\n    if (hi \u003c= lo) continue;\n    if (hi > t1) hi = t1;\n    const fhi = ((a3 * hi + a2) * hi + a1) * hi + a0;\n    if (flo \u003c 0 !== fhi \u003c 0 || fhi === 0) {\n      // Newton from the hint when it falls in the bracket (the next LED's\n      // root is close), else from the secant point, kept inside the bracket\n      // by halving.\n      let a = lo, b = hi, m = n === 0 && hint > lo && hint \u003c hi ? hint : (lo * fhi - hi * flo) / (fhi - flo);\n      for (let it = 0; it \u003c 12; it++) {\n        const fm = ((a3 * m + a2) * m + a1) * m + a0;\n        if (fm === 0) break;\n        if (fm \u003c 0 === flo \u003c 0) a = m;\n        else b = m;\n        let nm = m - fm / ((A * m + B) * m + C);\n        if (!(nm > a && nm \u003c b)) nm = 0.5 * (a + b);\n        const step = nm - m;\n        m = nm;\n        if (step \u003c 2e-3 && step > -2e-3) break;\n      }\n      r[n++] = m;\n      if (n === most) break;\n    }\n    lo = hi;\n    flo = fhi;\n  }\n  return n;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { L, T, nT, rgb, ln, g, r } = S;\n  // B is the spheroid's radius along the axis and A across it, twice B. The\n  // surface meets its axis only at the Eckardt point and spreads out across\n  // it, so a flat spheroid holds more of it than a ball would.\n  const B = 0.75, A = 2 * B, glass = S.glass, hue = S.hue;\n  // The view: the axis u lies across the panel, turned towards the eye by\n  // the tilt, and the surface turns about it, so the panel's height runs\n  // along the directions the surface spreads in.\n  const yaw = (S.tilt * PI) / 180;\n  const ct = cos(S.th), st = sin(S.th), cp = cos(yaw), sp = sin(yaw);\n  const U = [ct * E1[0] + st * E2[0], ct * E1[1] + st * E2[1], ct * E1[2] + st * E2[2]];\n  const p2 = [-st * E1[0] + ct * E2[0], -st * E1[1] + ct * E2[1], -st * E1[2] + ct * E2[2]];\n  const E = [cp * p2[0] + sp * UX, cp * p2[1] + sp * UX, cp * p2[2] + sp * UX];\n  const R = [cp * UX - sp * p2[0], cp * UX - sp * p2[1], cp * UX - sp * p2[2]];\n  const vx = -E[0], vy = -E[1], vz = -E[2];\n  // LEDs per unit: the outline is sqrt(B^2 cos^2 + A^2 sin^2) wide either\n  // side of the middle and A tall, and whichever is tighter sets the scale.\n  const k = min(31.5 / sqrt(B * B * cp * cp + A * A * sp * sp), 63 / A);\n  // Along the view direction the cubic's top coefficient is the same for\n  // every ray, and so is the gradient of its cubic part at v.\n  const a3 = 81 * (vx * vx * vx + vy * vy * vy + vz * vz * vz) - 189 * (vx * vx * (vy + vz) + vy * vy * (vx + vz) + vz * vz * (vx + vy)) + 54 * vx * vy * vz;\n  const g3x = 243 * vx * vx - 189 * (2 * vx * (vy + vz) + vy * vy + vz * vz) + 54 * vy * vz;\n  const g3y = 243 * vy * vy - 189 * (2 * vy * (vx + vz) + vx * vx + vz * vz) + 54 * vx * vz;\n  const g3z = 243 * vz * vz - 189 * (2 * vz * (vx + vy) + vx * vx + vy * vy) + 54 * vx * vy;\n  const qv = 126 * (vx * vy + vy * vz + vz * vx) - 9 * (vx * vx + vy * vy + vz * vz);\n  // Ray against spheroid: the ray's parts along u and across it.\n  const vu = (vx + vy + vz) * UX, vpx = vx - vu * UX, vpy = vy - vu * UX, vpz = vz - vu * UX;\n  const iA2 = 1 / (A * A), iB2 = 1 / (B * B);\n  const qa = (vpx * vpx + vpy * vpy + vpz * vpz) * iA2 + vu * vu * iB2;\n  const ru = (R[0] + R[1] + R[2]) * UX, rpx = R[0] - ru * UX, rpy = R[1] - ru * UX, rpz = R[2] - ru * UX;\n\n  // The light comes from up and to the left of the eye.\n  const lx0 = -0.45, ly0 = 0.6, lz0 = 0.66;\n  const Lx = lx0 * R[0] + ly0 * U[0] + lz0 * E[0], Ly = lx0 * R[1] + ly0 * U[1] + lz0 * E[1], Lz = lx0 * R[2] + ly0 * U[2] + lz0 * E[2];\n  const hn = 1 / sqrt((Lx + E[0]) ** 2 + (Ly + E[1]) ** 2 + (Lz + E[2]) ** 2);\n  const Hx = (Lx + E[0]) * hn, Hy = (Ly + E[1]) * hn, Hz = (Lz + E[2]) * hn;\n  // The two sides: where F > 0 and where F \u003c 0.\n  const side = S.side;\n  hsv(tone(0.6, hue), 0.5, 1, side[0], 0);\n  hsv(tone(0.8, hue), 0.38, 1, side[1], 0);\n  // Each sheet lets through this much of what is behind it. An opaque\n  // surface needs only the first sheet along each ray: a line behind it is\n  // dimmed the same however many more there are.\n  const pass = glass * 0.65, most = pass > 0 ? 3 : 1;\n\n  // Every surface point the ray through each LED meets inside the spheroid,\n  // t measured from the plane through the centre: the cubic F(o + t v) =\n  // a3 t^3 + a2 t^2 + a1 t + a0, a1 the gradient at o along v and a2 from\n  // the polarised cubic part. Along a row a0 is a cubic in the column, a1 a\n  // quadratic and a2 linear, so after four columns each is carried by its\n  // differences.\n  const c4 = S.c4;\n  for (let py = 0, p = 0; py \u003c H; py++) {\n    const sy = (H / 2 - py - 0.5) / k;\n    for (let j = 0; j \u003c 4; j++) {\n      const sx = (j + 0.5 - W / 2) / k;\n      const ox = C0 + sx * R[0] + sy * U[0], oy = C0 + sx * R[1] + sy * U[1], oz = C0 + sx * R[2] + sy * U[2];\n      grad(ox, oy, oz, g);\n      c4[j] = F(ox, oy, oz);\n      c4[4 + j] = g[0] * vx + g[1] * vy + g[2] * vz;\n      c4[8 + j] = g3x * ox + g3y * oy + g3z * oz + qv;\n    }\n    // The ray against the spheroid, qa t^2 + qb t + qc = 0, with qb linear\n    // and qc quadratic in sx along the row.\n    const hx = sy * U[0], hy = sy * U[1], hz = sy * U[2], hu = (hx + hy + hz) * UX;\n    const hpx = hx - hu * UX, hpy = hy - hu * UX, hpz = hz - hu * UX;\n    const qb0 = 2 * ((hpx * vpx + hpy * vpy + hpz * vpz) * iA2 + hu * vu * iB2), qbx = 2 * ((rpx * vpx + rpy * vpy + rpz * vpz) * iA2 + ru * vu * iB2);\n    const qc0 = (hpx * hpx + hpy * hpy + hpz * hpz) * iA2 + hu * hu * iB2 - 1;\n    const qcx = 2 * ((hpx * rpx + hpy * rpy + hpz * rpz) * iA2 + hu * ru * iB2), qcxx = (rpx * rpx + rpy * rpy + rpz * rpz) * iA2 + ru * ru * iB2;\n    let a0 = c4[0], d01 = c4[1] - c4[0], d02 = c4[2] - 2 * c4[1] + c4[0];\n    const d03 = c4[3] - 3 * c4[2] + 3 * c4[1] - c4[0];\n    let a1 = c4[4], d11 = c4[5] - c4[4];\n    const d12 = c4[6] - 2 * c4[5] + c4[4];\n    let a2 = c4[8];\n    const d21 = c4[9] - c4[8];\n    let hint = NaN;\n    for (let px = 0; px \u003c W; px++, p++) {\n      if (px > 0) {\n        a0 += d01;\n        d01 += d02;\n        d02 += d03;\n        a1 += d11;\n        d11 += d12;\n        a2 += d21;\n      }\n      const o = p * 3;\n      rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n      nT[p] = -1;\n      const sx = (px + 0.5 - W / 2) / k, qb = qb0 + qbx * sx, qc = qc0 + (qcx + qcxx * sx) * sx;\n      const disc = qb * qb - 4 * qa * qc;\n      if (disc \u003c= 0) {\n        hint = NaN;\n        continue;\n      }\n      const sq = sqrt(disc), t0 = (-qb - sq) / (2 * qa), t1 = (-qb + sq) / (2 * qa);\n      // A faint glass shell where the ray grazes the spheroid.\n      const sk = (t1 - t0) * k, rim = sk \u003c 8 ? 0.2 * (1 - sk / 8) * (1 - sk / 8) : 0;\n      rgb[o] = rim * 0.6;\n      rgb[o + 1] = rim * 0.75;\n      rgb[o + 2] = rim;\n      const ox = C0 + sx * R[0] + hx, oy = C0 + sx * R[1] + hy, oz = C0 + sx * R[2] + hz;\n      const n = cubicRoots(a3, a2, a1, a0, t0, t1, r, most, hint);\n      hint = n > 0 ? r[0] : NaN;\n      nT[p] = n;\n      let through = 1, cr = 0, cg = 0, cb = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const t = (T[o + i] = r[i]);\n        if (through \u003c 0.02) continue;\n        grad(ox + t * vx, oy + t * vy, oz + t * vz, g);\n        const nl = sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]) || 1;\n        let nx = g[0] / nl, ny = g[1] / nl, nz = g[2] / nl;\n        // Which side faces the eye: the gradient points to F > 0.\n        const facing = nx * E[0] + ny * E[1] + nz * E[2], col = side[facing > 0 ? 0 : 1];\n        if (facing \u003c 0) (nx = -nx), (ny = -ny), (nz = -nz);\n        const dif = max(0, nx * Lx + ny * Ly + nz * Lz);\n        let sp2 = max(0, nx * Hx + ny * Hy + nz * Hz);\n        sp2 *= sp2;\n        sp2 *= sp2;\n        sp2 *= sp2;\n        const spec = 0.45 * sp2 * sp2 * sp2;\n        // Depth cue: the far side of the spheroid is dimmer.\n        const fog = 1 - 0.5 * cl((t + A) / (2 * A), 0, 1);\n        const lum = (0.13 + 0.42 * dif + 0.25 * abs(facing)) * fog, a = through * (1 - pass);\n        cr += a * (col[0] * lum + spec);\n        cg += a * (col[1] * lum + spec);\n        cb += a * (col[2] * lum + spec);\n        through *= pass;\n      }\n      rgb[o] = rgb[o] * through + cr;\n      rgb[o + 1] = rgb[o + 1] * through + cg;\n      rgb[o + 2] = rgb[o + 2] * through + cb;\n    }\n  }\n\n  // The lines, sampled every LED. A sample is a point of the surface, and\n  // the sheets the ray through its LED meets before it hide it. The LED's\n  // centre is up to half an LED off the line, so the sample's depth is\n  // carried there along the surface's tangent plane before comparing.\n  ln.fill(0);\n  const plot = (X, Y, Z, cr, cg, cb, base, hid, wide, reach, top) => {\n    const sx = X * R[0] + Y * R[1] + Z * R[2], sy = X * U[0] + Y * U[1] + Z * U[2], tz = X * vx + Y * vy + Z * vz;\n    const fx = W / 2 + sx * k - 0.5, fy = H / 2 - sy * k - 0.5;\n    const cx = round(fx), cy = round(fy);\n    if (cx \u003c 0 || cx >= W || cy \u003c 0 || cy >= H) return;\n    const pc = cy * W + cx, n = nT[pc];\n    let m = 0;\n    if (n > 0) {\n      grad(X + C0, Y + C0, Z + C0, g);\n      const gv = g[0] * vx + g[1] * vy + g[2] * vz;\n      let tc = tz;\n      if (abs(gv) > 1e-6 * (abs(g[0]) + abs(g[1]) + abs(g[2]))) {\n        const dsx = (cx - fx) / k, dsy = (fy - cy) / k;\n        tc -= ((g[0] * R[0] + g[1] * R[1] + g[2] * R[2]) * dsx + (g[0] * U[0] + g[1] * U[1] + g[2] * U[2]) * dsy) / gv;\n      }\n      for (let i = 0; i \u003c n; i++) if (T[pc * 3 + i] \u003c tc - 0.03) m++;\n    }\n    const fog = 1 - 0.5 * cl((tz + A) / (2 * A), 0, 1);\n    const a = base * fog * (m === 0 ? 1 : hid + (1 - hid) * pass ** m * glass);\n    // Laid over the LEDs it is near, a soft disc of radius about\n    // sqrt(1.2 / wide) LEDs.\n    for (let yy = cy - reach; yy \u003c= cy + reach; yy++) {\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let xx = cx - reach; xx \u003c= cx + reach; xx++) {\n        if (xx \u003c 0 || xx >= W) continue;\n        const ex = xx - fx, ey = yy - fy, w = cl(1.2 - (ex * ex + ey * ey) * wide, 0, 1) * a, q = (yy * W + xx) * 4;\n        if (top) {\n          // Laid on top of what is there.\n          const o = ln[q + 3], b = o > 0 ? 1 - w : 0;\n          ln[q] = ln[q] * b + cr * (1 - b);\n          ln[q + 1] = ln[q + 1] * b + cg * (1 - b);\n          ln[q + 2] = ln[q + 2] * b + cb * (1 - b);\n          ln[q + 3] = max(o, w);\n        } else if (w > ln[q + 3]) {\n          ln[q + 3] = w;\n          ln[q] = cr;\n          ln[q + 1] = cg;\n          ln[q + 2] = cb;\n        }\n      }\n    }\n  };\n  // Line colours: the two sixes of the double six, then the fifteen.\n  const cls = S.cls;\n  hsv(tone(0.5, hue), 0.85, 1, cls[0], 0);\n  hsv(tone(0.95, hue), 0.75, 1, cls[1], 0);\n  hsv(tone(0.3, hue), 0.7, 1, cls[2], 0);\n  // The focus and the ten lines that meet it are lit; the other sixteen,\n  // skew to it, are dimmed. The focus turns white over 0.3 s, and where it\n  // runs behind a sheet it keeps half its light, the others a fifth.\n  const F0 = S.focus, nbs = L[F0].nb, fin = min(1, S.since / 0.3);\n  // Where a line enters and leaves the spheroid, as s along it, into S.s0\n  // and S.s1.\n  const span = (P, D) => {\n    const wx = P[0] - C0, wy = P[1] - C0, wz = P[2] - C0, wu = (wx + wy + wz) * UX, du = (D[0] + D[1] + D[2]) * UX;\n    const wpx = wx - wu * UX, wpy = wy - wu * UX, wpz = wz - wu * UX, dpx = D[0] - du * UX, dpy = D[1] - du * UX, dpz = D[2] - du * UX;\n    const qa2 = (dpx * dpx + dpy * dpy + dpz * dpz) * iA2 + du * du * iB2;\n    const qb2 = 2 * ((wpx * dpx + wpy * dpy + wpz * dpz) * iA2 + wu * du * iB2);\n    const qc2 = (wpx * wpx + wpy * wpy + wpz * wpz) * iA2 + wu * wu * iB2 - 1;\n    const disc = qb2 * qb2 - 4 * qa2 * qc2;\n    if (disc \u003c= 0) return false;\n    S.s0 = (-qb2 - sqrt(disc)) / (2 * qa2);\n    S.s1 = (-qb2 + sqrt(disc)) / (2 * qa2);\n    return true;\n  };\n  for (let li = 0; li \u003c L.length; li++) {\n    const l = L[li], P = l.p, D = l.d;\n    if (!span(P, D)) continue;\n    const s0 = S.s0, s1 = S.s1, isF = li === F0;\n    const base = isF || nbs.includes(li) ? 1 : 0.3, wh = isF ? 0.7 * fin : 0;\n    const col = cls[l.irr ? l.cls : 2];\n    const cr = col[0] + (1 - col[0]) * wh, cg = col[1] + (1 - col[1]) * wh, cb = col[2] + (1 - col[2]) * wh;\n    const steps = max(2, round((s1 - s0) * k));\n    for (let e = 0; e \u003c= steps; e++) {\n      const s = s0 + ((s1 - s0) * e) / steps;\n      plot(P[0] - C0 + s * D[0], P[1] - C0 + s * D[1], P[2] - C0 + s * D[2], cr, cg, cb, base, isF ? 0.5 : 0.2, isF ? 0.5 : 1.3, 1, false);\n    }\n  }\n  // The points where the ten meet the focus, white, those inside the\n  // spheroid; a line parallel to the focus meets it at infinity.\n  for (const X of L[F0].at) {\n    if (!X) continue;\n    const x = X[0] - C0, y = X[1] - C0, z = X[2] - C0, u = (x + y + z) * UX;\n    const px = x - u * UX, py = y - u * UX, pz = z - u * UX;\n    if ((px * px + py * py + pz * pz) * iA2 + u * u * iB2 >= 1) continue;\n    plot(x, y, z, 1, 1, 1, fin, 0.5, 0.3, 2, true);\n  }\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3, q = p * 4, w = ln[q + 3];\n      display.setPixel(\n        x,\n        y,\n        (255 * cl(rgb[o] * (1 - w) + ln[q] * w, 0, 1)) | 0,\n        (255 * cl(rgb[o + 1] * (1 - w) + ln[q + 1] * w, 0, 1)) | 0,\n        (255 * cl(rgb[o + 2] * (1 - w) + ln[q + 2] * w, 0, 1)) | 0,\n      );\n    }\n}\n","granular-demon":"// ===== Patternflow pattern =====\n// Title:   Granular Demon\n// Family:  particle\n// Idea:    Grains on a shaken floor fly between tall boxes through a window in each wall, and since a crowded box loses its energy in collisions and stops sending grains up to the window while a sparse one keeps throwing them over, one box fills with a cold heap lying low and the others keep a few hot grains flying to the lid, until the walls slide up, the grains spread out and the next run picks its box.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Maxwell's demon in a vibrated granular gas (Holger Schlichting and Volker Nordmark, 1996), the flux model F(n) = n^2 exp(-B n^2) (Jens Eggers, 1999), the sudden collapse of a granular cluster in several compartments (Devaraj van der Meer, Ko van der Weele and Detlef Lohse, 2002), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shaking=130..260, Boxes=2..5\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 a cold box and its slow grains are azure, a hot box pink and the fast grains paler pink, violet between; at 0.5 cold is rose and hot is blue. The scale runs the other way round when it would cross the orange to lime gap, which reads brown when dim.\n// Knob 2: Speed. 2 runs the simulation in real time, gravity 300 LEDs a second squared, so a grain leaving the floor at 275 LEDs a second just reaches the lid; 0.2 is ten times slower and 3 half as fast again. A run ends once one box has held 85% of the 240 grains, or the windows have stayed quiet, for 8 seconds, or at 45 seconds; then the walls slide up for 3 seconds while the floor shakes at 300, slide back down, and the shaking eases to the knob's over 1.5 seconds.\n// Knob 3: Shaking. The floor's speed U, 130 to 260 LEDs a second: a grain falling onto it at v leaves at U + 0.7 (U + v). At 130 two boxes split about 10 seconds into a run and the fuller one keeps 97.7% of the grains (Eggers's flux model, fitted to this floor, says 97.9%); at 150, 92.7% (93.0%); from about 170 the even split holds. More boxes cluster under harder shaking, with a sudden collapse into one box after a long even spell: three boxes up to 160, four up to 200, five up to 230, and five at 130 freeze with the grains in two boxes until the reset.\n// Knob 4: Boxes. 2 to 5 boxes across the 64 columns, the walls one LED thick at k x 64 / n, each with a window 40 rows tall from 50 to 90 LEDs above the floor. A new count deals the grains out evenly again.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, exp, log, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The demon is the grains themselves. A box of grains at temperature T\n// holds them in a barometric layer of height T / g, and collisions, each\n// losing 1 - 0.85^2 = 28% of the energy along the line of centres, cool it\n// faster the more grains it has. So the flux F(n) out through a window\n// first rises with n and then falls: Eggers wrote F(n) = A n^2 exp(-B n^2),\n// and an even split of N grains between two boxes is unstable once\n// B N^2 > 4. Measured here with the window turned into a counting mirror,\n// F(n) peaks near n = 80 when the floor moves at 130 (a fit gives B N^2 =\n// 8.1 for N = 240) and near n = 160 when it moves at 260 (2.8).\n\n// Lengths are in LEDs, time in seconds of the simulation. z counts up from\n// the floor, the bottom edge of row 125, to the lid, the top edge of row 0.\nconst ZTOP = 126;\nconst N = 240, RAD = 0.5, DIA = 1;\nconst GRAV = 300;\n// Restitution: grain on grain, grain on the floor, grain on a wall or lid.\nconst E_GG = 0.85, E_FL = 0.7, E_WL = 0.9;\n// Substep and a speed cap, so no grain moves more than 0.86 LED a substep.\nconst SUB = 1 / 650, VMAX = 560;\n// The window in every inner wall, from its sill to its lintel.\nconst ZW0 = 50, ZW1 = 90;\n// A bounce off the rough floor turns up to 30% of its speed sideways.\nconst ROUGH = 0.3;\n// The Shaking knob's range and the shaking of a reset, all floor speeds.\nconst U_LO = 130, U_HI = 260, U_RESET = 300;\n// The reset, in seconds: the walls slide up, stay up, slide down, and the\n// shaking eases back to the knob.\nconst LIFT = 0.6, OPEN = 2.4, EASE = 1.5;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel that skips orange through lime, which\n// reads brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    nb: 0, phase: 1, pt: 0, run: 0, held: 0, hue: 0, shake: 0, zb: 0,\n    x: new Float32Array(N), z: new Float32Array(N), vx: new Float32Array(N), vz: new Float32Array(N),\n    ox: new Float32Array(N), oz: new Float32Array(N),\n    head: new Int32Array(W * (ZTOP + 2)), next: new Int32Array(N),\n    count: new Int32Array(5), nsm: new Float32Array(5), temp: new Float32Array(5),\n    cross: new Float32Array(4), flux: new Float32Array(4),\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// A fresh start: the grains dealt out evenly, nb of them to a round, at\n// random spots in the lower half of their boxes.\nfunction start(S, nb) {\n  S.nb = nb;\n  S.walls = [];\n  for (let k = 1; k \u003c nb; k++) S.walls.push((W * k) / nb);\n  for (let i = 0; i \u003c N; i++) {\n    const b = i % nb, x0 = (W * b) / nb + (b ? 1 : RAD), x1 = (W * (b + 1)) / nb - (b \u003c nb - 1 ? 1 : RAD);\n    S.x[i] = x0 + Math.random() * (x1 - x0);\n    S.z[i] = RAD + Math.random() * 60;\n    S.vx[i] = (Math.random() - 0.5) * 60;\n    S.vz[i] = (Math.random() - 0.5) * 60;\n  }\n  S.temp.fill(8000);\n  S.nsm.fill(N / nb);\n  S.flux.fill(0);\n  S.phase = 1;\n  S.run = 0;\n  S.held = 0;\n  S.zb = 0;\n}\n\nconst boxOf = (S, x) => min(S.nb - 1, floor((x * S.nb) / W));\n\n// One substep. The floor is a sawtooth driver in the limit of a small\n// stroke: it stays at z = 0 and always meets a grain moving up at U, so a\n// grain falling at v leaves at U + E_FL (U + v). Grains collide as hard\n// disks one LED across with restitution E_GG, found through a grid of\n// one-LED cells; overlaps are pushed apart along the line of centres.\nfunction step(S, h, U) {\n  const { x, z, vx, vz, head, next, walls } = S, zb = S.zb;\n  for (let i = 0; i \u003c N; i++) {\n    const px = x[i], pz = z[i];\n    vz[i] -= GRAV * h;\n    let sp = vx[i] * vx[i] + vz[i] * vz[i];\n    if (sp > VMAX * VMAX) {\n      sp = VMAX / sqrt(sp);\n      vx[i] *= sp;\n      vz[i] *= sp;\n    }\n    x[i] += vx[i] * h;\n    z[i] += vz[i] * h;\n    if (z[i] \u003c RAD) {\n      z[i] = RAD;\n      const s = U - vz[i];\n      if (s > 0) {\n        vz[i] = U + E_FL * s;\n        vx[i] += (Math.random() - 0.5) * 2 * ROUGH * s;\n      }\n    } else if (z[i] > ZTOP - RAD) {\n      z[i] = ZTOP - RAD;\n      if (vz[i] > 0) vz[i] = -E_WL * vz[i];\n    }\n    if (x[i] \u003c RAD) (x[i] = RAD), (vx[i] = abs(vx[i]) * E_WL);\n    else if (x[i] > W - RAD) (x[i] = W - RAD), (vx[i] = -abs(vx[i]) * E_WL);\n    // The inner walls, slabs one LED thick standing above zb (0 unless a\n    // reset has lifted them). A grain may overlap a slab only below its\n    // bottom edge or inside its window, its whole body between sill and\n    // lintel.\n    for (let k = 0; k \u003c walls.length; k++) {\n      const xk = walls[k];\n      if (abs(x[i] - xk) >= RAD + 0.5) continue;\n      const open = (zi) => zi + RAD \u003c= zb || (zi - RAD >= ZW0 && zi + RAD \u003c= ZW1);\n      if (open(z[i])) {\n        if (zb === 0 && (px - xk) * (x[i] - xk) \u003c 0) S.cross[k] += 1;\n        break;\n      }\n      if (zb === 0 && abs(px - xk) \u003c RAD + 0.5 && open(pz)) {\n        // Inside the window's tunnel: it hit the sill or the lintel.\n        if (z[i] \u003c ZW0 + RAD) (z[i] = ZW0 + RAD), (vz[i] = abs(vz[i]) * E_WL);\n        else (z[i] = ZW1 - RAD), (vz[i] = -abs(vz[i]) * E_WL);\n      } else {\n        const side = px !== xk ? (px \u003c xk ? -1 : 1) : x[i] \u003c xk ? -1 : 1;\n        x[i] = xk + side * (RAD + 0.5);\n        if (vx[i] * side \u003c 0) vx[i] = -vx[i] * E_WL;\n      }\n      break;\n    }\n  }\n  head.fill(-1);\n  for (let i = 0; i \u003c N; i++) {\n    const c = cl(floor(z[i]), 0, ZTOP + 1) * W + cl(floor(x[i]), 0, W - 1);\n    next[i] = head[c];\n    head[c] = i;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const cx = floor(x[i]), cz = floor(z[i]);\n    for (let gz = max(0, cz - 1); gz \u003c= min(ZTOP + 1, cz + 1); gz++)\n      for (let gx = max(0, cx - 1); gx \u003c= min(W - 1, cx + 1); gx++)\n        for (let j = head[gz * W + gx]; j >= 0; j = next[j]) {\n          if (j \u003c= i) continue;\n          const dx = x[j] - x[i], dz = z[j] - z[i], d2 = dx * dx + dz * dz;\n          if (d2 >= DIA * DIA || d2 \u003c 1e-9) continue;\n          const d = sqrt(d2), nx = dx / d, nz = dz / d;\n          const vn = (vx[j] - vx[i]) * nx + (vz[j] - vz[i]) * nz;\n          if (vn \u003c 0) {\n            const J = (-(1 + E_GG) * vn) / 2;\n            vx[i] -= J * nx;\n            vz[i] -= J * nz;\n            vx[j] += J * nx;\n            vz[j] += J * nz;\n          }\n          const o = (DIA - d) / 2;\n          x[i] -= o * nx;\n          z[i] -= o * nz;\n          x[j] += o * nx;\n          z[j] += o * nz;\n        }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, U_LO, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), knobU = cl(kv[2], U_LO, U_HI), nb = round(cl(kv[3], 2, 5));\n  if (nb !== S.nb) start(S, nb);\n  const g = (d * speed) / 2;\n  // Phase 1 runs at the knob's shaking. Phase 0 is the reset: the walls\n  // slide up and the floor shakes at U_RESET, which spreads a heap that\n  // stronger shaking alone cannot lift over a window 50 LEDs up; then the\n  // walls slide back down and the shaking eases to the knob.\n  let level = 0;\n  if (S.phase === 0) {\n    S.pt += g;\n    const t = S.pt, up = LIFT + OPEN;\n    S.zb = t \u003c LIFT ? (ZTOP + 1) * (t / LIFT) : t \u003c up ? ZTOP + 1 : t \u003c up + LIFT ? (ZTOP + 1) * (1 - (t - up) / LIFT) : 0;\n    level = t \u003c up + LIFT ? 1 : max(0, 1 - (t - up - LIFT) / EASE);\n    if (t >= up + LIFT + EASE) (S.phase = 1), (S.run = 0), (S.held = 0), (S.zb = 0);\n  } else S.run += g;\n  S.shake = knobU + (U_RESET - knobU) * level;\n  S.ox.set(S.x);\n  S.oz.set(S.z);\n  const n = max(1, ceil(g / SUB - 1e-6));\n  for (let k = 0; k \u003c n; k++) step(S, g / n, S.shake);\n  const cnt = S.count;\n  cnt.fill(0);\n  const tsum = [0, 0, 0, 0, 0];\n  for (let i = 0; i \u003c N; i++) {\n    const b = boxOf(S, S.x[i]);\n    cnt[b]++;\n    tsum[b] += (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]) / 2;\n  }\n  // Each box's granular temperature, the mean kinetic energy a grain,\n  // smoothed over 0.6 s; an empty box keeps the last value it had.\n  const a = 1 - exp(-g / 0.6);\n  for (let b = 0; b \u003c S.nb; b++) {\n    if (cnt[b]) S.temp[b] += a * (tsum[b] / cnt[b] - S.temp[b]);\n    S.nsm[b] += a * (cnt[b] - S.nsm[b]);\n  }\n  // Crossings through each window a second, smoothed over 0.4 s.\n  const af = 1 - exp(-g / 0.4);\n  let moved = 0;\n  for (let k = 0; k \u003c S.nb - 1; k++) {\n    S.flux[k] += af * (S.cross[k] / max(1e-6, g) - S.flux[k]);\n    S.cross[k] = 0;\n    moved += S.flux[k];\n  }\n  // A run ends once one box has held 85% of the grains, or the windows\n  // have stayed quiet, for 8 s, or after 45 s.\n  if (S.phase === 1) {\n    let top = 0;\n    for (let b = 0; b \u003c S.nb; b++) top = max(top, cnt[b]);\n    S.held = top >= 0.85 * N || moved \u003c 0.3 ? S.held + g : 0;\n    if (S.held > 8 || S.run > 45) (S.phase = 0), (S.pt = 0);\n  }\n}\n\n// Colours: a cold box or grain is azure at knob 0 and a hot one pink, on\n// log T from 3,000 to 40,000 (LEDs per second, squared). The scale runs\n// SPAN round the knob's wheel from the cold hue, back the other way when\n// it would run past the wheel's end, so it never jumps across the gap.\nconst P_COLD = 0.43, SPAN = 0.43;\nconst heatOf = (T) => cl(log(max(1, T) / 3000) / log(40000 / 3000), 0, 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.nb) return;\n  const rgb = S.rgb, c = S.c, hue = S.hue;\n  const pc = P_COLD + hue - floor(P_COLD + hue), span = pc + SPAN \u003c 1 ? SPAN : -SPAN;\n  const tint = (heat) => wheel(pc + span * heat);\n  rgb.fill(0);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += col[0] * a;\n    rgb[o + 1] += col[1] * a;\n    rgb[o + 2] += col[2] * a;\n  };\n  // Each box glows in the colour of its temperature T, fading upward as\n  // the square root of the barometric profile exp(-g z / T): two scale\n  // heights T / g to fall by 1/e, short over a cold heap, the whole box\n  // over a hot gas. A box with no grains has no gas, and its glow fades\n  // below two grains.\n  for (let b = 0; b \u003c S.nb; b++) {\n    const T = max(50, S.temp[b]);\n    hsv(tint(heatOf(T)), 0.85, 1, c);\n    const amp = 0.42 * min(1, S.nsm[b] / 2);\n    const x0 = b ? floor((W * b) / S.nb) + 1 : 0, x1 = b \u003c S.nb - 1 ? floor((W * (b + 1)) / S.nb) : W;\n    for (let y = 0; y \u003c ZTOP; y++) {\n      const v = amp * exp((-GRAV * (ZTOP - y - 0.5)) / (2 * T));\n      for (let x = x0; x \u003c x1; x++) add(x, y, c, v);\n    }\n  }\n  // The walls above their bottom edge, and the sill and lintel of each\n  // window, which flare with the grains passing through it.\n  const wall = [0.55, 0.6, 0.75], lip = [1, 1, 1];\n  const rs = floor(ZTOP - ZW0), rl = floor(ZTOP - ZW1) - 1, yb = ZTOP - S.zb;\n  S.walls.forEach((xk, k) => {\n    const col = floor(xk);\n    for (let y = 0; y \u003c yb; y++) if (y \u003c= rl || y >= rs) add(col, y, wall, 0.4);\n    if (rs \u003c yb) {\n      const f = 0.25 + 0.6 * min(1, S.flux[k] / 30);\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        add(col + dx, rs, lip, dx ? f * 0.6 : f);\n        add(col + dx, rl, lip, dx ? f * 0.6 : f);\n      }\n    }\n  });\n  // The floor, brighter the harder it shakes.\n  const fl = [0.85, 0.85, 0.95];\n  for (let y = ZTOP; y \u003c H; y++) for (let x = 0; x \u003c W; x++) add(x, y, fl, 0.2 + 0.4 * min(1, S.shake / U_HI));\n  // Grains, coloured by their own kinetic energy on the boxes' scale and\n  // paler the faster, each a streak from where it was a frame ago with a\n  // faint halo round its head, so a crowd of grains reads as a heap.\n  for (let i = 0; i \u003c N; i++) {\n    const ke = (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]) / 2, heat = heatOf(ke);\n    hsv(tint(heat), 0.7 - 0.45 * heat, 0.75 + 0.25 * heat, c);\n    const x1 = S.x[i], z1 = S.z[i], x0 = S.ox[i], z0 = S.oz[i];\n    const m = min(12, ceil(max(abs(x1 - x0), abs(z1 - z0))));\n    for (let e = m - 1; e >= 0; e--) {\n      const f = e / m;\n      add(floor(x0 + (x1 - x0) * f), floor(ZTOP - (z0 + (z1 - z0) * f)), c, 0.1 + 0.3 * f);\n    }\n    const hx = floor(x1), hy = floor(ZTOP - z1);\n    add(hx, hy, c, 0.95);\n    add(hx - 1, hy, c, 0.13);\n    add(hx + 1, hy, c, 0.13);\n    add(hx, hy - 1, c, 0.13);\n    add(hx, hy + 1, c, 0.13);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","hawkes-process":"// ===== Patternflow pattern =====\n// Title:   Hawkes Process\n// Family:  rhythm\n// Idea:    Four streams of a mutually exciting Hawkes process run down the panel as a scrolling time line, each stream's intensity a filled band that jumps wide at every event and relaxes back, each event a pulse joined by a line to the event that begot it, so a burst shows as a tree growing up from one immigrant through its children and grandchildren, now and then into the next stream.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: self-exciting point process (Alan Hawkes, 1971), its cluster representation (Alan Hawkes and David Oakes, 1974), thinning simulation (Yosihiko Ogata, 1981), each event's parent drawn from the parts of the intensity (Jiancang Zhuang, Yosihiko Ogata and David Vere-Jones, 2002), time rescaling of the compensator (Yosihiko Ogata, 1988), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Branching=0.7..0.95, Decay=2..8\n//\n// Knob 1: Hue. Turns the bands and the events round the wheel together. At 0 the bands are teal, the immigrants pale gold and their descendants gold, yellow, lime and green by generation; at 0.25 violet bands with green trees, at 0.5 pink with blue, at 0.75 green with magenta. The bands skip orange, which reads brown when dim.\n// Knob 2: Speed. At 2 the time line moves 16 rows a second, so the panel holds the last 8 seconds of the process, now at the top; at 0.2 it moves 1.6 rows a second and holds 80 seconds, at 3 it moves 24 and holds 5.3.\n// Knob 3: Branching. n, the mean number of children of each event, 0.7 to 0.95. Each stream's mean rate is mu / (1 - n): at 0.7 it is 0.83 events a second, 27 on the panel, a cluster has 3.3 events on average and half the clusters are a lone immigrant; at 0.85 it is 1.7 a second and 6.7 to a cluster; at 0.95 it is 5 a second, 20 to a cluster, one cluster in 14 has 50 or more and every ten minutes or so one of several hundred fills the panel.\n// Knob 4: Decay. beta, how fast an event's push fades, 2 to 8 a second. At 2 the push lasts 0.5 s on average, 8 rows, so a child comes about 8 rows above its parent and the trees stand tall; at 8 it lasts 2 rows, the bands are thin with sharp spikes and a burst lies almost flat across the streams. The push in a middle stream is n x beta x 0.7 a second, 0.98 at the opening, against 0.25 from the immigrants.\n\nconst W = 64, H = 128, LANES = 4, LW = W / LANES, MAXE = 4096;\n// Immigrants per second in each stream, and rows the time line moves per second.\nconst MU = 0.25, V = 16;\n// Where a child lands: its own stream 70% of the time, a neighbour the\n// rest. The matrix is symmetric with rows summing to 1, so every event has\n// Poisson(n) children whatever its stream and each stream's mean rate is\n// mu / (1 - n).\nconst M = [\n  [0.85, 0.15, 0, 0],\n  [0.15, 0.7, 0.15, 0],\n  [0, 0.15, 0.7, 0.15],\n  [0, 0, 0.15, 0.85],\n];\nconst { floor, min, max, abs, exp, log } = Math;\n// The bands skip orange through lime, which reads brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0.7, beta: 2, T: 0, s: 0, E: new Float64Array(LANES), id: 0,\n    t: new Float64Array(MAXE), x: new Float32Array(MAXE), lane: new Int8Array(MAXE), par: new Int32Array(MAXE), gen: new Int16Array(MAXE),\n    rgb: new Float32Array(W * H * 3), lam: new Float32Array(H * LANES), hue: 0, c: [0, 0, 0],\n  };\n}\n\n// The excitation of each stream at time s from every event kept, used\n// when the knobs change n or beta.\nfunction recompute(S) {\n  S.E.fill(0);\n  const a = S.n * S.beta;\n  for (let id = max(0, S.id - MAXE); id \u003c S.id; id++) {\n    const i = id % MAXE, e = a * exp(-S.beta * (S.s - S.t[i]));\n    for (let k = 0; k \u003c LANES; k++) S.E[k] += e * M[S.lane[i]][k];\n  }\n}\n\nfunction decayTo(S, s) {\n  const f = exp(-S.beta * (s - S.s));\n  for (let k = 0; k \u003c LANES; k++) S.E[k] *= f;\n  S.s = s;\n}\n\n// An event in stream k at time S.s. Its parent is drawn the way the\n// intensity is made up: an immigrant with chance mu / lambda_k, else the\n// child of event i with chance a M[lane_i][k] e^(-beta (s - t_i)) /\n// lambda_k. That is the cluster process of Hawkes and Oakes read\n// backwards, and it gives the trees their true law.\nfunction addEvent(S, k) {\n  const lam = MU + S.E[k], a = S.n * S.beta;\n  let u = Math.random() * lam, par = -1;\n  if (u >= MU) {\n    u -= MU;\n    for (let id = S.id - 1; id >= max(0, S.id - MAXE); id--) {\n      const i = id % MAXE, c = a * M[S.lane[i]][k] * exp(-S.beta * (S.s - S.t[i]));\n      par = id;\n      u -= c;\n      if (u \u003c 0) break;\n    }\n  }\n  const i = S.id % MAXE;\n  S.t[i] = S.s;\n  S.lane[i] = k;\n  S.par[i] = par;\n  S.gen[i] = par >= 0 && par > S.id - MAXE ? S.gen[par % MAXE] + 1 : 0;\n  // Across its stream: near the parent if the parent shares the stream,\n  // anywhere in it otherwise.\n  const c = k * LW + LW / 2;\n  let x = c + (Math.random() - 0.5) * (LW - 5);\n  if (S.gen[i] > 0 && S.lane[par % MAXE] === k) x = cl(S.x[par % MAXE] + (Math.random() - 0.5) * 5, c - LW / 2 + 2.5, c + LW / 2 - 2.5);\n  S.x[i] = x;\n  S.id++;\n  for (let j = 0; j \u003c LANES; j++) S.E[j] += a * M[k][j];\n}\n\n// Ogata's thinning: between events every intensity only decays, so the\n// total intensity now bounds it until the next event. Draw a gap from that\n// bound, then keep the point with chance lambda(s) / bound.\nfunction simulate(S, T, most) {\n  for (let guard = 0; guard \u003c most; guard++) {\n    let bound = 0;\n    for (let k = 0; k \u003c LANES; k++) bound += MU + S.E[k];\n    const w = -log(1 - Math.random()) / bound;\n    if (S.s + w > T) {\n      decayTo(S, T);\n      return;\n    }\n    decayTo(S, S.s + w);\n    let lam = 0;\n    for (let k = 0; k \u003c LANES; k++) lam += MU + S.E[k];\n    if (Math.random() * bound > lam) continue;\n    let u = Math.random() * lam, k = 0;\n    for (; k \u003c LANES - 1; k++) if ((u -= MU + S.E[k]) \u003c 0) break;\n    addEvent(S, k);\n  }\n  decayTo(S, T);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.7, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), n = cl(kv[2], 0.7, 0.95), beta = cl(kv[3], 2, 8);\n  if (abs(n - S.n) > 1e-6 || abs(beta - S.beta) > 1e-6) {\n    S.n = n;\n    S.beta = beta;\n    recompute(S);\n  }\n  // The first frame runs 30 seconds of the process at once, so the time\n  // line opens full.\n  S.T += S.T ? (d * speed) / 2 : 30;\n  simulate(S, S.T, S.id ? 2000 : 40000);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, lam = S.lam, T = S.T, a = S.n * S.beta, b = S.beta;\n  rgb.fill(0);\n  // Row r is time T - r / V. The intensity of each stream at every row,\n  // from the bottom row up, decaying and adding the events as it passes them.\n  const t0 = T - (H - 0.5) / V, E = [0, 0, 0, 0];\n  let id = max(0, S.id - MAXE);\n  for (; id \u003c S.id && S.t[id % MAXE] \u003c= t0; id++) {\n    const i = id % MAXE, e = a * exp(-b * (t0 - S.t[i]));\n    for (let k = 0; k \u003c LANES; k++) E[k] += e * M[S.lane[i]][k];\n  }\n  const first = id;\n  let tp = t0;\n  for (let r = H - 1; r >= 0; r--) {\n    const tr = T - (r + 0.5) / V, f = exp(-b * (tr - tp));\n    for (let k = 0; k \u003c LANES; k++) E[k] *= f;\n    for (; id \u003c S.id && S.t[id % MAXE] \u003c= tr; id++) {\n      const i = id % MAXE, e = a * exp(-b * (tr - S.t[i]));\n      for (let k = 0; k \u003c LANES; k++) E[k] += e * M[S.lane[i]][k];\n    }\n    for (let k = 0; k \u003c LANES; k++) lam[r * LANES + k] = MU + E[k];\n    tp = tr;\n  }\n  // The bands: half-width 7.4 (1 - e^(-lambda / 0.8 beta)) LEDs, which\n  // saturates at the edge of the stream. At the opening knobs the\n  // immigrants alone keep it 2 LEDs wide and one event in a middle stream\n  // widens it to 8.\n  const band = hsv(wheel(0.36 + S.hue), 0.7, 1, S.c);\n  const add = (x, y, c, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || v \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += c[0] * v;\n    rgb[o + 1] += c[1] * v;\n    rgb[o + 2] += c[2] * v;\n  };\n  for (let r = 0; r \u003c H; r++)\n    for (let k = 0; k \u003c LANES; k++) {\n      // lam now holds the half-width, for the strokes below.\n      const w = (lam[r * LANES + k] = (LW / 2 - 0.6) * (1 - exp(-lam[r * LANES + k] / (0.8 * b)))), c = k * LW + LW / 2;\n      for (let x = k * LW; x \u003c (k + 1) * LW; x++) {\n        const dd = abs(x + 0.5 - c), cov = cl(w - dd + 0.5, 0, 1);\n        if (cov \u003c= 0) continue;\n        const q = dd / max(0.5, w), g = w / (LW / 2);\n        add(x, r, band, cov * (0.07 + 0.22 * g + 0.3 * q * q * q * q));\n      }\n    }\n  // Each event is a jump in its stream's intensity: a bright stroke across\n  // the band on the row where it happened.\n  for (let j = first; j \u003c S.id; j++) {\n    const i = j % MAXE, y = floor((T - S.t[i]) * V), k = S.lane[i], c = k * LW + LW / 2;\n    if (y \u003c 0 || y >= H) continue;\n    const w = lam[min(H - 1, y + 1) * LANES + k] * 0.5 + lam[y * LANES + k] * 0.5;\n    for (let x = k * LW; x \u003c (k + 1) * LW; x++) add(x, y, band, 0.35 * cl(w - abs(x + 0.5 - c) + 0.5, 0, 1));\n  }\n  // Parent to child, a line from row to row.\n  const col = [0, 0, 0];\n  for (let j = first; j \u003c S.id; j++) {\n    const i = j % MAXE, p = S.par[i];\n    if (p \u003c 0 || p \u003c= S.id - MAXE) continue;\n    const q = p % MAXE, y1 = (T - S.t[i]) * V, y0 = (T - S.t[q]) * V, x1 = S.x[i], x0 = S.x[q];\n    const steps = max(1, Math.ceil(max(abs(y1 - y0), abs(x1 - x0))));\n    hsv(0.08 + S.hue + 0.07 * S.gen[i], 0.6, 1, col);\n    for (let s = 0; s \u003c= steps; s++) {\n      const f = s / steps, x = x0 + (x1 - x0) * f - 0.5, y = floor(y0 + (y1 - y0) * f), xi = floor(x), fx = x - xi;\n      add(xi, y, col, 0.45 * (1 - fx));\n      add(xi + 1, y, col, 0.45 * fx);\n    }\n  }\n  // The events: pulses that flash as they happen.\n  for (let j = first; j \u003c S.id; j++) {\n    const i = j % MAXE, y = (T - S.t[i]) * V, x = S.x[i], age = T - S.t[i];\n    hsv(0.08 + S.hue + 0.07 * S.gen[i], S.gen[i] ? 0.55 : 0.2, 1, col);\n    const rad = (S.gen[i] ? 1.3 : 1.9) + 1.5 * exp(-age * 4), pk = 0.9 + exp(-age * 4);\n    for (let yy = floor(y - rad); yy \u003c= y + rad; yy++)\n      for (let xx = floor(x - rad); xx \u003c= x + rad; xx++) {\n        const dx = xx + 0.5 - x, dy = yy + 0.5 - y, d2 = (dx * dx + dy * dy) / (rad * rad);\n        if (d2 \u003c 1) add(xx, yy, col, pk * (1 - d2));\n      }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","kohonen-map":"// ===== Patternflow pattern =====\n// Title:   Kohonen Map\n// Family:  data\n// Idea:    A lattice of 288 nodes thrown as a random tangle over a shape of faint dots, an annulus, two crescents or a tall S, learns the shape by Kohonen's rule, each dot pulling its nearest node and that node's lattice neighbours toward it, so the tangle draws together, unfolds into a woven cloth coloured by lattice place and spreads over the shape as the neighbourhood shrinks, or as a chain folds into a Peano-like curve; it holds, fades, and the next shape starts.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the self-organizing map (Teuvo Kohonen, 1982), its topographic error (Kimmo Kiviluoto, 1996), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lattice=0..1, Radius=0.5..3\n//\n// Knob 1: Hue. Turns the cloth's colours round the wheel together. A node's hue is set by its place along the lattice's long side and its whiteness by its place across the short side: at 0 the long side runs azure, blue, violet, magenta; at 0.25 violet to teal; at 0.5 rose to blue. The scale runs the other way round when it would cross the orange to lime gap, which reads brown when dim.\n// Knob 2: Speed. 2 anneals in 14 seconds on 9,000 samples a second, about 440 a node: the neighbourhood radius falls from a quarter of the lattice's long side (6 nodes for the sheet, 72 for the chain) to the Radius knob and the learning rate from 0.5 to 0.02, both exponentially, and the first 2.5 seconds learn up to 3,000 times slower so the tangle is seen drawing together. The map then holds 5 seconds, still learning at the last rate, and fades in 0.6. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Lattice. The 288 nodes as a 12 x 24 sheet at 0, then 8 x 36, 6 x 48, 4 x 72, 3 x 96 and 2 x 144, and a chain of 288 at 1; a new lattice starts the shape again from a tangle. A sheet is drawn as a cloth, its cells fainter where stretched and darker where turned over; a ribbon follows the S and the crescents and leaves the annulus open as a C; the chain is a curve through its nodes in order, and at the opening Radius it folds back and forth until it is 828 LEDs long on the annulus, 0.76 of sqrt(288 x area), the length of a path through 288 even cells.\n// Knob 4: Radius. The neighbourhood radius the anneal ends at, 0.5 to 3 lattice steps. At 0.5 the sheet reaches the shape's edges: on the annulus after the hold a dot lies 1.52 LEDs from its nearest node on average (the quantization error; 288 even square cells would give 1.44), and 16% of dots have their two nearest nodes not side by side on the lattice (Kiviluoto's topographic error), nearly all of them diagonal neighbours. At 3 the sheet stays smooth and shrinks inside the shape: quantization error 3.62, topographic error 9.8%.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, exp, cos, sin, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Kohonen's map: a lattice of nodes, each with a weight, here a point of\n// the panel. For every sample x the best-matching node c (the nearest\n// weight) and its lattice neighbours k move toward x:\n//   w_k += alpha h(|k - c|) (x - w_k),  h(d) = exp(-d^2 / (2 sigma^2)),\n// with d measured on the lattice, not on the panel. While sigma spans the\n// lattice every node moves almost alike and the map orders itself; as\n// sigma shrinks the nodes spread out over the data, and nodes that are\n// neighbours on the lattice mostly stay neighbours on the panel.\n\n// Lattices of 288 nodes, from the sheet to the chain.\nconst DIMS = [[12, 24], [8, 36], [6, 48], [4, 72], [3, 96], [2, 144], [1, 288]];\nconst NODES = 288;\n// The anneal, in seconds at Speed 2: the neighbourhood radius falls from a\n// quarter of the lattice's long side to the Radius knob, the learning rate\n// from A0 to A1, both exponentially; then the map holds, fades and a new\n// shape starts.\nconst ANNEAL = 14, HOLD = 5, FADE = 0.6, A0 = 0.5, A1 = 0.02, RAMP = 2.5;\n// Samples a second of simulated time.\nconst RATE = 9000;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\n// The data: three shapes in panel coordinates, each a sampler that draws\n// points about evenly over its area.\nconst SHAPES = [\n  // An elliptical annulus, outer semi-axes 30 x 60, inner 15 x 34.\n  (out) => {\n    for (;;) {\n      const x = 2 + Math.random() * 60, y = 4 + Math.random() * 120;\n      const u = (x - 32) / 30, v = (y - 64) / 60, a = (x - 32) / 15, b = (y - 64) / 34;\n      if (u * u + v * v \u003c= 1 && a * a + b * b >= 1) return (out[0] = x), (out[1] = y), out;\n    }\n  },\n  // Two crescents, the two moons turned upright: half rings of radius 1\n  // and width 0.5, the second turned half a turn and shifted by (0.5, 1),\n  // drawn 30 LEDs to the unit across and 33 down.\n  (out) => {\n    const th = Math.random() * PI, r = sqrt(0.5625 + Math.random() * (1.5625 - 0.5625));\n    let X, Y;\n    if (Math.random() \u003c 0.5) (X = r * sin(th)), (Y = r * cos(th));\n    else (X = 0.5 - r * sin(th)), (Y = 1 - r * cos(th));\n    out[0] = 32 + 30 * (X - 0.25);\n    out[1] = 64 + 33 * (Y - 0.5);\n    return out;\n  },\n  // A tall S: two elliptical arcs of 250 degrees, 12 LEDs thick, the lower\n  // the upper turned half a turn. The offset across the arc is drawn with\n  // weight r + t, as an even spread over a ring of mean radius 26 would be.\n  (out) => {\n    const s = Math.random() \u003c 0.5 ? 1 : -1, ph = (20 + Math.random() * 250) * (PI / 180);\n    const t = sqrt(400 + Math.random() * (1024 - 400)) - 26;\n    out[0] = 32 + s * (24 + t) * cos(ph);\n    out[1] = 62 - s * (28 + (28 + t) * sin(ph));\n    return out;\n  },\n];\n\nexport function setup(params) {\n  params.s = {\n    dim: -1, shape: 0, phase: 0, pt: 0, hue: 0, sigma: 1,\n    wx: new Float32Array(NODES), wy: new Float32Array(NODES),\n    hx: new Float32Array(NODES + 1), samp: new Float32Array(240), ns: 0,\n    rgb: new Float32Array(W * H * 3), col: new Float32Array(NODES * 3), c: [0, 0, 0], p: [0, 0],\n  };\n}\n\nfunction start(S, dim, next) {\n  if (next) S.shape = (S.shape + 1) % SHAPES.length;\n  S.dim = dim;\n  [S.cols, S.rows] = DIMS[dim];\n  // The random tangle: every node at a random spot of the panel.\n  for (let k = 0; k \u003c NODES; k++) {\n    S.wx[k] = 2 + Math.random() * 60;\n    S.wy[k] = 4 + Math.random() * 120;\n  }\n  S.phase = 0;\n  S.pt = 0;\n}\n\n// One step of Kohonen's rule: the node nearest the sample wins, and it and\n// its lattice neighbours move toward the sample by alpha times a Gaussian\n// of their lattice distance from the winner.\nfunction learn(S, x, y, alpha, sigma, R) {\n  const { wx, wy, cols, rows, hx } = S;\n  let best = 0, bd = Infinity;\n  for (let k = 0; k \u003c NODES; k++) {\n    const dx = wx[k] - x, dy = wy[k] - y, d = dx * dx + dy * dy;\n    if (d \u003c bd) (bd = d), (best = k);\n  }\n  const bi = best % cols, bj = (best / cols) | 0;\n  for (let j = max(0, bj - R); j \u003c= min(rows - 1, bj + R); j++) {\n    const hj = hx[abs(j - bj)];\n    for (let i = max(0, bi - R); i \u003c= min(cols - 1, bi + R); i++) {\n      const k = j * cols + i, a = alpha * hj * hx[abs(i - bi)];\n      wx[k] += a * (x - wx[k]);\n      wy[k] += a * (y - wy[k]);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.5], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), dim = round(cl(kv[2], 0, 1) * (DIMS.length - 1)), rad = cl(kv[3], 0.5, 3);\n  if (dim !== S.dim) start(S, dim, false);\n  const g = (d * speed) / 2;\n  S.pt += g;\n  if (S.phase === 0 && S.pt >= ANNEAL) (S.phase = 1), (S.pt = 0);\n  else if (S.phase === 1 && S.pt >= HOLD) (S.phase = 2), (S.pt = 0);\n  else if (S.phase === 2 && S.pt >= FADE) return start(S, dim, true);\n  const f = S.phase === 0 ? S.pt / ANNEAL : 1;\n  // The first RAMP seconds learn slowly, the rate rising 3,000-fold, so\n  // the tangle is seen drawing itself together before the map orders.\n  const ramp = S.phase === 0 && S.pt \u003c RAMP ? 10 ** (-3.5 * (1 - S.pt / RAMP)) : 1;\n  const s0 = max(S.cols, S.rows) / 4, sigma = s0 * (rad / s0) ** f, alpha = A0 * (A1 / A0) ** f * ramp;\n  const R = min(max(S.cols, S.rows), ceil(3 * sigma));\n  for (let k = 0; k \u003c= R; k++) S.hx[k] = exp((-k * k) / (2 * sigma * sigma));\n  S.sigma = sigma;\n  const n = round(g * RATE), p = S.p, keep = S.samp.length / 2;\n  S.ns = 0;\n  for (let k = 0; k \u003c n; k++) {\n    SHAPES[S.shape](p);\n    learn(S, p[0], p[1], alpha, sigma, R);\n    if (S.ns \u003c keep) (S.samp[2 * S.ns] = p[0]), (S.samp[2 * S.ns + 1] = p[1]), S.ns++;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.dim \u003c 0) return;\n  const rgb = S.rgb, col = S.col, { cols, rows, wx, wy } = S;\n  rgb.fill(0);\n  const fade = S.phase === 2 ? 1 - S.pt / FADE : S.phase === 0 ? min(1, S.pt / 0.3) : 1;\n  // Node colours from lattice coordinates: hue along the long side,\n  // whiteness across the short one.\n  const pc = 0.4 + S.hue - floor(0.4 + S.hue), span = pc + 0.4 \u003c= 1 ? 0.4 : -0.4, c = S.c;\n  for (let j = 0, k = 0; j \u003c rows; j++)\n    for (let i = 0; i \u003c cols; i++, k++) {\n      const u = cols > 1 ? i / (cols - 1) : 0.5, v = rows > 1 ? j / (rows - 1) : 0;\n      hsv(wheel(pc + span * v), 0.95 - 0.55 * u, 1, c);\n      col[3 * k] = c[0];\n      col[3 * k + 1] = c[1];\n      col[3 * k + 2] = c[2];\n    }\n  const add = (x, y, r, g, b, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += r * a;\n    rgb[o + 1] += g * a;\n    rgb[o + 2] += b * a;\n  };\n  const top = (x, y, r, g, b, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], r * a);\n    rgb[o + 1] = max(rgb[o + 1], g * a);\n    rgb[o + 2] = max(rgb[o + 2], b * a);\n  };\n  if (cols > 1) {\n    // The cloth: each lattice cell a quad of two triangles, colours mixed\n    // across it, fainter the more it is stretched past the area a cell\n    // would have if the nodes shared the shape evenly. A cell turned over,\n    // its corners in the other order round from most cells', shows its\n    // back, darker.\n    const A0c = 3600 / ((cols - 1) * (rows - 1));\n    let turn = 0;\n    for (let j = 0; j \u003c rows - 1; j++)\n      for (let i = 0; i \u003c cols - 1; i++) {\n        const a = j * cols + i;\n        turn += (wx[a + 1] - wx[a]) * (wy[a + cols] - wy[a]) - (wy[a + 1] - wy[a]) * (wx[a + cols] - wx[a]) > 0 ? 1 : -1;\n      }\n    for (let j = 0; j \u003c rows - 1; j++)\n      for (let i = 0; i \u003c cols - 1; i++) {\n        const a = j * cols + i, b = a + 1, cc = a + cols + 1, dd = a + cols;\n        const cr = (wx[b] - wx[a]) * (wy[dd] - wy[a]) - (wy[b] - wy[a]) * (wx[dd] - wx[a]);\n        const alpha = (cr * turn >= 0 ? 0.5 : 0.22) * cl(A0c / max(1e-3, abs(cr)), 0.1, 1);\n        tri(rgb, wx, wy, col, a, b, cc, alpha);\n        tri(rgb, wx, wy, col, a, cc, dd, alpha);\n      }\n  }\n  // The lattice's threads: a line from each node to its right and lower\n  // neighbours, so a sheet reads as woven and a chain as a curve.\n  const seg = (k0, k1, a) => {\n    const x0 = wx[k0], y0 = wy[k0], x1 = wx[k1], y1 = wy[k1], o0 = 3 * k0, o1 = 3 * k1;\n    const m = max(1, ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5));\n    for (let e = 0; e \u003c m; e++) {\n      const t = e / m;\n      top(floor(x0 + (x1 - x0) * t), floor(y0 + (y1 - y0) * t), col[o0] + (col[o1] - col[o0]) * t, col[o0 + 1] + (col[o1 + 1] - col[o0 + 1]) * t, col[o0 + 2] + (col[o1 + 2] - col[o0 + 2]) * t, a);\n    }\n  };\n  const thread = cols > 1 ? 0.85 : 0.95;\n  for (let j = 0; j \u003c rows; j++)\n    for (let i = 0; i \u003c cols; i++) {\n      const k = j * cols + i;\n      if (i + 1 \u003c cols) seg(k, k + 1, thread);\n      if (j + 1 \u003c rows) seg(k, k + cols, thread);\n    }\n  // The data, the samples of this frame, faint.\n  for (let k = 0; k \u003c S.ns; k++) add(floor(S.samp[2 * k]), floor(S.samp[2 * k + 1]), 1, 1, 1, 0.22);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 1] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 2] * fade, 0, 1)) | 0);\n}\n\n// A triangle of three nodes, its colour mixed by barycentric weights at\n// each LED centre inside it. Overlapping cells keep the brighter, so a\n// crumpled map does not burn white.\nfunction tri(rgb, wx, wy, col, a, b, c, alpha) {\n  const ax = wx[a], ay = wy[a], bx = wx[b], by = wy[b], cx = wx[c], cy = wy[c];\n  const det = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(det) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, ceil(max(ay, by, cy)));\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const l1 = ((px - ax) * (cy - ay) - (py - ay) * (cx - ax)) / det;\n      const l2 = ((bx - ax) * (py - ay) - (by - ay) * (px - ax)) / det;\n      const l0 = 1 - l1 - l2;\n      if (l0 \u003c 0 || l1 \u003c 0 || l2 \u003c 0) continue;\n      const o = (y * W + x) * 3;\n      rgb[o] = max(rgb[o], (l0 * col[3 * a] + l1 * col[3 * b] + l2 * col[3 * c]) * alpha);\n      rgb[o + 1] = max(rgb[o + 1], (l0 * col[3 * a + 1] + l1 * col[3 * b + 1] + l2 * col[3 * c + 1]) * alpha);\n      rgb[o + 2] = max(rgb[o + 2], (l0 * col[3 * a + 2] + l1 * col[3 * b + 2] + l2 * col[3 * c + 2]) * alpha);\n    }\n  }\n}\n","laser-speckle":"// ===== Patternflow pattern =====\n// Title:   Laser Speckle\n// Family:  noise\n// Idea:    Laser light through a diffuser: the panel is the Fourier transform of a small pupil full of random phases, so every LED is the sum of 191 random phasors, lit by the squared length of the sum and coloured by its phase; the grains boil as the diffuser's phases turn, a window at the top shows the pupil changing from disc to ring, pinhole pair, square, slit and triangle while the grains take the shape of its diffraction pattern, and the histogram along the bottom follows the exponential law e^-I.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: laser speckle as a random walk of phasors (Lord Rayleigh, 1880), the statistics of speckle (J. W. Goodman, 1975), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pupil=5..14, Looks=1..8\n//\n// Knob 1: Hue. Adds one phase to the whole field, which turns every grain's hue round the wheel together; the window's tint and the bars turn with it. At 0 the bars are blue and the curve over them cream.\n// Knob 2: Speed. How fast the diffuser turns and the pupil changes shape. Every sample's phase turns at its own rate, normal with a spread of 0.9 radians a second at 2, so the intensity at an LED is correlated exp(-0.81 t^2) with itself t seconds before: half after 0.93 s, 0.15 after 1.5 s; each of the eight pupils holds 9 s, the last 2.5 of them blending into the next. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Pupil. The pupil's radius in samples of the frequency plane, 5 to 14 across and twice that down, since the panel has twice as many rows as columns; the disc holds 191 samples at 5 and 1,321 at 14. A bigger pupil makes finer grains: the intensity's autocorrelation falls to half 3.4 LEDs out at 5, 2.1 at 8 and 1.2 at 14, so a grain is about 66 LEDs over the pupil's diameter in samples, against (2 J1(z) / z)^2 = 1/2 at z = 1.62. The window draws the pupil at one size; its shape, not its size, is what it shows.\n// Knob 4: Looks. How many speckle patterns from independent diffusers are added, 1 to 8. One look has contrast sigma / \u003cI> of 1.00 and the exponential histogram; 2 have 0.70, 4 have 0.49 and 8 have 0.35, as 1 / sqrt(n), and the histogram rises into the gamma law the curve draws. The dark gaps between the grains fill in. Brightness is the mean intensity over 1 + 2 / sqrt(n) times its mean, the same for every LED, so the brightest grains stay full.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, log, cos, sin, atan2, PI, round } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n// The pupil: u runs across the 64 columns' frequencies and v down the 128\n// rows', so a pupil RU samples wide in u and 2 RU tall in v makes round\n// grains. Its largest box, RU_MAX either side.\nconst RU_MAX = 14, SU = 2 * RU_MAX + 1, SV = 4 * RU_MAX + 1, NS = SU * SV;\nconst LOOKS = 8;\n// Brightness is intensity over TONE times the mean, so a third of the mean\n// is the faintest LED that reads, and one LED in twenty is full. With n\n// looks the scale is 1 + (TONE - 1) / sqrt(n), the mean plus about two\n// standard deviations, which keeps the brightest LEDs full; it is the same\n// for every LED, so the contrast is what it is.\nconst TONE = 3, SAT = 0.82;\n// Each pupil shape holds SHAPE_T units and the last MORPH_T of them blend\n// into the next. A unit is a second at Speed 2.\nconst SHAPE_T = 9, MORPH_T = 2.5;\n// The spread of the diffuser's phase rates, radians a unit.\nconst BOIL = 0.9;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The colour of each of 256 phases at full value.\nconst LUT = new Float32Array(256 * 3);\nfor (let i = 0, c = [0, 0, 0]; i \u003c 256; i++) {\n  hsv(i / 256, SAT, 1, c);\n  LUT.set(c, i * 3);\n}\n\n// A radix-2 FFT, in place along n entries of re/im spaced by stride.\nfunction tables(n) {\n  const rev = new Uint16Array(n), cs = new Float64Array(n / 2), sn = new Float64Array(n / 2);\n  const bits = round(log(n) / log(2));\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c bits; b++) r |= ((i >> b) & 1) \u003c\u003c (bits - 1 - b);\n    rev[i] = r;\n  }\n  for (let k = 0; k \u003c n / 2; k++) (cs[k] = cos((TAU * k) / n)), (sn[k] = sin((TAU * k) / n));\n  return { n, rev, cs, sn };\n}\nconst TX = tables(W), TY = tables(H);\nfunction fft(re, im, off, stride, T) {\n  const n = T.n, rev = T.rev;\n  for (let i = 0; i \u003c n; i++) {\n    const j = rev[i];\n    if (j > i) {\n      const a = off + i * stride, b = off + j * stride;\n      let t = re[a];\n      re[a] = re[b];\n      re[b] = t;\n      t = im[a];\n      im[a] = im[b];\n      im[b] = t;\n    }\n  }\n  for (let size = 2; size \u003c= n; size \u003c\u003c= 1) {\n    const half = size >> 1, step = n / size;\n    for (let i = 0; i \u003c n; i += size)\n      for (let k = 0; k \u003c half; k++) {\n        const c = T.cs[k * step], s = T.sn[k * step];\n        const a = off + (i + k) * stride, b = a + half * stride;\n        const tr = re[b] * c - im[b] * s, ti = re[b] * s + im[b] * c;\n        re[b] = re[a] - tr;\n        im[b] = im[a] - ti;\n        re[a] += tr;\n        im[a] += ti;\n      }\n  }\n}\n\n// The pupil shapes as signed distances in pupil units (a across, b down,\n// the rim of the disc at 1): negative inside.\nconst len = (a, b) => sqrt(a * a + b * b);\nconst SHAPES = [\n  (a, b) => len(a, b) - 1, // disc\n  (a, b) => max(len(a, b) - 1, 0.6 - len(a, b)), // annulus\n  (a, b) => min(len(a - 0.62, b), len(a + 0.62, b)) - 0.36, // two pinholes side by side\n  (a, b) => max(abs(a), abs(b)) - 0.86, // square\n  (a, b) => max(len(a, b) - 1, 0.84 - len(a, b)), // thin ring\n  (a, b) => max(abs(a) - 0.24, abs(b) - 1), // slit, narrow across\n  (a, b) => len(abs(a) - 0.5, abs(b) - 0.5) - 0.3, // four pinholes\n  (a, b) => max(b - 0.5, max(-0.866 * a - 0.5 * b, 0.866 * a - 0.5 * b) - 0.5), // triangle\n];\nconst NAMES = SHAPES.length;\n\n// One look: a diffuser of its own, each pupil sample with a starting phase\n// and a rate, and the field it makes.\nfunction newLook() {\n  const L = { p0: new Float32Array(NS), w: new Float32Array(NS), I: new Float32Array(N), zr: new Float32Array(N), zi: new Float32Array(N), at: -1 };\n  for (let i = 0; i \u003c NS; i++) {\n    L.p0[i] = Math.random() * TAU;\n    // A normal rate, by Box and Muller.\n    L.w[i] = BOIL * sqrt(-2 * log(1 - Math.random())) * cos(TAU * Math.random());\n  }\n  return L;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    looks: [], re: new Float64Array(N), im: new Float64Array(N), P: new Float32Array(NS), sumP: 1,\n    clock: 0, boil: 0, ru: 5, n: 1, hue: 0, next: 0,\n    Iavg: new Float32Array(N), zr: new Float32Array(N), zi: new Float32Array(N), hist: new Float32Array(16), histOk: false,\n  });\n  for (let k = 0; k \u003c LOOKS; k++) S.looks.push(newLook());\n}\n\n// The pupil's amplitude at every sample of the box, for radius ru and the\n// shape schedule: soft-edged over one sample, so it changes smoothly with\n// the knob and as one shape blends into the next.\nfunction pupil(S) {\n  const ru = S.ru, rv = 2 * ru, i0 = floor(S.clock / SHAPE_T), f = S.clock / SHAPE_T - i0;\n  const A = SHAPES[i0 % NAMES], B = SHAPES[(i0 + 1) % NAMES];\n  const m = smooth((f * SHAPE_T - (SHAPE_T - MORPH_T)) / MORPH_T);\n  let sum = 0;\n  for (let j = 0; j \u003c SV; j++)\n    for (let i = 0; i \u003c SU; i++) {\n      const a = (i - RU_MAX) / ru, b = (j - 2 * RU_MAX) / rv;\n      const pa = cl(0.5 - A(a, b) * ru, 0, 1), pb = m > 0 ? cl(0.5 - B(a, b) * ru, 0, 1) : 0;\n      const p = pa + (pb - pa) * m;\n      S.P[j * SU + i] = p;\n      sum += p * p;\n    }\n  S.sumP = max(sum, 1e-6);\n}\n\n// The field of one look: put P e^{i phi} on the frequency plane, transform\n// the rows that hold any of it, then every column. I is |E|^2 over the sum\n// of P^2, the mean intensity, so I has mean 1 whatever the pupil.\nfunction field(S, L) {\n  const re = S.re, im = S.im, P = S.P, t = S.boil;\n  re.fill(0);\n  im.fill(0);\n  const rv = min(2 * RU_MAX, Math.ceil(2 * S.ru) + 1);\n  for (let j = 0; j \u003c SV; j++) {\n    const v = j - 2 * RU_MAX;\n    if (abs(v) > rv) continue;\n    const row = ((v + H) % H) * W;\n    for (let i = 0; i \u003c SU; i++) {\n      const s = j * SU + i, p = P[s];\n      if (p \u003c= 0) continue;\n      const ph = L.p0[s] + L.w[s] * t, o = row + ((i - RU_MAX + W) % W);\n      re[o] = p * cos(ph);\n      im[o] = p * sin(ph);\n    }\n  }\n  for (let v = -rv; v \u003c= rv; v++) fft(re, im, ((v + H) % H) * W, 1, TX);\n  for (let x = 0; x \u003c W; x++) fft(re, im, x, W, TY);\n  // zr + i zi is |E| E, the field weighted by its own amplitude: summed over\n  // the looks it gives each LED the phase of whichever look is brightest there.\n  const k = 1 / S.sumP, I = L.I;\n  for (let p = 0; p \u003c N; p++) {\n    const q = (re[p] * re[p] + im[p] * im[p]) * k, a = sqrt(q * k);\n    I[p] = q;\n    L.zr[p] = re[p] * a;\n    L.zi[p] = im[p] * a;\n  }\n  L.at = t;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 5, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.ru = cl(kv[2], 5, 14);\n  const n = round(cl(kv[3], 1, LOOKS));\n  const g = (d * speed) / 2;\n  S.clock += g;\n  S.boil += g;\n  pupil(S);\n  // Up to three looks are brought up to date each frame, in turn; a look\n  // newly added is done at once.\n  for (let k = 0; k \u003c n; k++) if (S.looks[k].at \u003c 0 || k >= S.n) field(S, S.looks[k]);\n  S.n = n;\n  for (let c = 0; c \u003c min(n, 3); c++) {\n    S.next = (S.next + 1) % n;\n    field(S, S.looks[S.next]);\n  }\n  // The mean of the looks, its phase, and its histogram, eased over a few frames.\n  const Ia = S.Iavg, Zr = S.zr, Zi = S.zi, hist = S.hist, cnt = new Float32Array(16);\n  Ia.fill(0);\n  Zr.fill(0);\n  Zi.fill(0);\n  for (let k = 0; k \u003c n; k++) {\n    const L = S.looks[k], I = L.I;\n    for (let p = 0; p \u003c N; p++) (Ia[p] += I[p] / n), (Zr[p] += L.zr[p]), (Zi[p] += L.zi[p]);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const b = floor(Ia[p] / BIN);\n    if (b \u003c 16) cnt[b]++;\n  }\n  const ease = S.histOk ? min(1, d * 6) : 1;\n  for (let b = 0; b \u003c 16; b++) hist[b] += (cnt[b] / (N * BIN) - hist[b]) * ease;\n  S.histOk = true;\n}\n\n// The density of the mean of n exponentials with mean 1: a gamma law.\nfunction gammaPdf(x, n) {\n  let lf = 0;\n  for (let k = 2; k \u003c n; k++) lf += log(k);\n  return x \u003c= 0 ? (n === 1 ? 1 : 0) : exp(n * log(n) + (n - 1) * log(x) - n * x - lf);\n}\n\n// The window at the top: the pupil drawn at a fixed size, its rim at\n// PR LEDs, over a dark disc of radius WR. The histogram along the bottom:\n// 16 bins of the mean intensity, BIN times the mean wide, HB rows tall\n// for a density of HD.\nconst WX = 31.5, WY = 11.5, WR = 11, PR = 8.5, HB = 22, HD = 1.25, BIN = 0.2;\nconst c3 = [0, 0, 0];\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.looks[0].at \u003c 0) return;\n  const n = S.n, Ia = S.Iavg, hue = S.hue, L0 = S.looks[0], tone = 1 + (TONE - 1) / sqrt(n);\n  const i0 = floor(S.clock / SHAPE_T), f = S.clock / SHAPE_T - i0;\n  const A = SHAPES[i0 % NAMES], B = SHAPES[(i0 + 1) % NAMES];\n  const m = smooth((f * SHAPE_T - (SHAPE_T - MORPH_T)) / MORPH_T);\n  const curve = new Float32Array(W);\n  for (let x = 0; x \u003c W; x++) curve[x] = H - 1 - (gammaPdf(((x + 0.5) * BIN) / 4, n) / HD) * HB;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      const v = min(1, Ia[p] / tone), c = ((floor((atan2(S.zi[p], S.zr[p]) / TAU + hue) * 256) % 256) + 256) % 256;\n      let r = v * LUT[c * 3], g = v * LUT[c * 3 + 1], b = v * LUT[c * 3 + 2];\n      const dw = len(x - WX, y - WY);\n      if (dw \u003c WR + 1) {\n        // The window: the field dims to a fifth, a thin rim, the pupil inside.\n        const k = cl(WR + 0.5 - dw, 0, 1) * 0.8;\n        (r *= 1 - k), (g *= 1 - k), (b *= 1 - k);\n        const a = (x - WX) / PR, bb = (y - WY) / PR;\n        const pa = cl(0.5 - A(a, bb) * PR, 0, 1), pb = cl(0.5 - B(a, bb) * PR, 0, 1), pu = pa + (pb - pa) * m;\n        if (pu > 0) {\n          // Tinted by the diffuser's phase at that sample of the first look.\n          const si = cl(round(a * S.ru) + RU_MAX, 0, SU - 1), sj = cl(round(bb * 2 * S.ru) + 2 * RU_MAX, 0, SV - 1), s = sj * SU + si;\n          hsv((L0.p0[s] + L0.w[s] * S.boil) / TAU + hue, 0.4, 0.95 * pu, c3);\n          (r += c3[0]), (g += c3[1]), (b += c3[2]);\n        }\n        const ring = cl(1 - abs(dw - WR) * 1.5, 0, 1) * 0.35;\n        (r += ring), (g += ring), (b += ring);\n      }\n      if (y >= H - HB - 2) {\n        // The histogram: the field dims, the bars rise, the law is a line of dots.\n        const k = cl((y - (H - HB - 2)) / 2, 0, 1) * 0.75;\n        (r *= 1 - k), (g *= 1 - k), (b *= 1 - k);\n        const bin = x >> 2, top = H - 1 - (S.hist[bin] / HD) * HB;\n        if ((x & 3) !== 3 && y > top) {\n          hsv(0.62 + hue - bin * 0.012, 0.45, 0.5, c3);\n          (r += c3[0]), (g += c3[1]), (b += c3[2]);\n        }\n        const dc = abs(y - curve[x]), dn = x \u003c W - 1 ? abs(curve[x + 1] - curve[x]) : 0;\n        if (dc \u003c max(0.8, dn + 0.3) && y \u003c H) (r = 1), (g = 0.95), (b = 0.75);\n      }\n      display.setPixel(x, y, (255 * cl(r, 0, 1)) | 0, (255 * cl(g, 0, 1)) | 0, (255 * cl(b, 0, 1)) | 0);\n    }\n}\n","quadratic-reciprocity":"// ===== Patternflow pattern =====\n// Title:   Quadratic Reciprocity\n// Family:  number\n// Idea:    Two 64 x 64 tables of Legendre symbols (p/q), one LED per pair of 64 odd primes, light where p is a square mod q and dark where it is not, the top table in the primes' own order and the bottom one with the primes 1 mod 4 first, while a cross walks the diagonal comparing each pair with its mirror image, white where the two agree and green where they differ, which happens exactly when both primes are 3 mod 4, so the green builds a plaid on top and fills one corner block below.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: law of quadratic reciprocity (Adrien-Marie Legendre, 1785), conjectured by Leonhard Euler and first proved by Carl Friedrich Gauss (1796, published 1801), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..5, Start=0..400, Law=0.25..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a residue is pale aqua and a non-residue deep indigo, the pairs the law flips lean to rose and plum, the diagonal is grey and the marks are white and green; at 0.5 the residues are pink, the non-residues dark green, the flipped pairs lean to blue and the marks are white and violet. The wheel skips orange through lime, which read brown and olive when dim.\n// Knob 2: Speed. At 2 the cross moves 2 primes a second, down the 64 primes and back up in 63 seconds; a green mark fades to a third while the cross goes 12 primes on, 6 seconds, and a white one while it goes 2. 0.2 is ten times slower and 5 two and a half times faster.\n// Knob 3: Start. Which 64 odd primes the tables use: at 0 the first 64, 3 to 313, of which 30 are 1 mod 4 and 34 are 3 mod 4; at 400 the 64 from the 401st on, 2753 to 3307, 33 and 31. The law holds in every window, and the bottom corner block is always the primes 3 mod 4 against each other.\n// Knob 4: Law. How far the pairs of two primes 3 mod 4, the pairs the law says are flipped across the diagonal, lean towards rose: a quarter of the way at 0.25, a faint plaid on top and a pale 34 x 34 block in the bottom table's corner, and all the way at 1. The green marks fall on this tint and nowhere else.\n\nconst W = 64, H = 128, N = 64;\nconst { floor, max, abs, round, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Odd primes up to 4000 by a sieve; the last one Start reaches is the\n// 464th, 3307.\nconst PRIMES = (() => {\n  const top = 4000, comp = new Uint8Array(top + 1), out = [];\n  for (let i = 3; i \u003c= top; i += 2) {\n    if (comp[i]) continue;\n    out.push(i);\n    for (let j = i * i; j \u003c= top; j += 2 * i) comp[j] = 1;\n  }\n  return out;\n})();\n\n// The Legendre symbol (a/p) for an odd prime p by Euler's criterion:\n// a^((p - 1) / 2) is 1 mod p when a is a nonzero square mod p, p - 1 when it\n// is not, 0 when p divides a. Numbers stay below 4000^2, exact in doubles.\nfunction legendre(a, p) {\n  a %= p;\n  if (a === 0) return 0;\n  let e = (p - 1) / 2, b = a, r = 1;\n  while (e > 0) {\n    if (e & 1) r = (r * b) % p;\n    b = (b * b) % p;\n    e >>= 1;\n  }\n  return r === 1 ? 1 : -1;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob turns hues on a wheel that skips orange through lime, which\n// read brown and olive when dim. Hues are given as they look at knob 0,\n// from 0.28 round to 1.02.\nconst tone = (h, k) => 0.28 + 0.74 * ((((h - 0.28) / 0.74 + k) % 1 + 1) % 1);\n\n// The tables for the 64 primes from index start. leg[i * N + j] = (p_i /\n// p_j) with p_i the row's prime, and 0 on the diagonal. ord[r] is the prime\n// shown at row and column r of the bottom table: the primes 1 mod 4 in\n// order, then those 3 mod 4.\nfunction build(S, start) {\n  S.start = start;\n  const P = PRIMES.slice(start, start + N);\n  S.P = P;\n  S.three = P.map((p) => p % 4 === 3);\n  for (let i = 0; i \u003c N; i++) for (let j = 0; j \u003c N; j++) S.leg[i * N + j] = i === j ? 0 : legendre(P[i], P[j]);\n  const ord = [];\n  for (let i = 0; i \u003c N; i++) if (!S.three[i]) ord.push(i);\n  S.n1 = ord.length;\n  for (let i = 0; i \u003c N; i++) if (S.three[i]) ord.push(i);\n  S.ord = ord;\n  S.mark.fill(0);\n}\n\nexport function setup(params) {\n  params.s = {\n    start: -1,\n    P: [],\n    three: [],\n    leg: new Int8Array(N * N),\n    ord: [],\n    n1: 0,\n    // The walk: k is a position along the 64 primes, going down then up.\n    k: 0,\n    dir: 1,\n    // The marks the cross leaves, one per pair, fading.\n    mark: new Float32Array(N * N),\n    hue: 0,\n    law: 0.25,\n    cross: new Float32Array(N),\n    pal: new Float32Array(30),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.25], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 5);\n  const start = round(cl(kv[2], 0, 400));\n  S.law = cl(kv[3], 0.25, 1);\n  if (start !== S.start) build(S, start);\n  // 2 primes a second at Speed 2, bouncing at the ends.\n  S.k += S.dir * d * speed;\n  if (S.k > N - 1) (S.k = 2 * (N - 1) - S.k), (S.dir = -1);\n  if (S.k \u003c 0) (S.k = -S.k), (S.dir = 1);\n  // The cross is on each prime by how near the walk is to it, so it slides\n  // from one row to the next without a jump.\n  for (let i = 0; i \u003c N; i++) S.cross[i] = max(0, 1 - abs(i - S.k));\n  // The cross leaves a mark on every pair it passes, (p/q) in row p and\n  // (q/p) in column p. Where the pair and its mirror differ the mark is\n  // green and fades to 1/e while the walk goes 12 primes on, 6 s at Speed\n  // 2; where they agree it is white and fades in 2 primes.\n  const fadeD = exp((-d * speed) / 12), fadeA = exp((-d * speed) / 2);\n  const { leg, mark, cross } = S;\n  for (let i = 0; i \u003c N; i++)\n    for (let j = 0; j \u003c N; j++) {\n      const q = i * N + j;\n      let m = mark[q] * (leg[q] !== leg[j * N + i] ? fadeD : fadeA);\n      const c = max(cross[i], cross[j]);\n      if (c > m) m = c;\n      mark[q] = m;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.start \u003c 0) return;\n  const { leg, mark, three, ord, pal, hue, law } = S;\n  // Colours: residue, non-residue; the same two tinted for the flipped\n  // pairs; the agreeing and differing marks of the cross; the diagonal.\n  hsv(tone(0.5, hue), 0.4, 0.9, pal, 0);\n  hsv(tone(0.68, hue), 0.85, 0.2, pal, 3);\n  hsv(tone(0.96, hue), 0.5, 0.95, pal, 6);\n  hsv(tone(0.88, hue), 0.9, 0.32, pal, 9);\n  hsv(tone(0.5, hue), 0.08, 1, pal, 12);\n  hsv(tone(0.5, hue), 0.25, 0.6, pal, 15);\n  hsv(tone(0.34, hue), 0.8, 1, pal, 18);\n  hsv(tone(0.34, hue), 0.95, 0.66, pal, 21);\n  hsv(tone(0.5, hue), 0.12, 0.5, pal, 24);\n  const c = [0, 0, 0];\n  for (let half = 0; half \u003c 2; half++)\n    for (let y = 0; y \u003c N; y++) {\n      const i = half ? ord[y] : y;\n      for (let x = 0; x \u003c N; x++) {\n        const j = half ? ord[x] : x, q = i * N + j, v = leg[q];\n        if (v === 0) {\n          // (p/p) = 0: the diagonal, the mirror's axis.\n          c[0] = pal[24];\n          c[1] = pal[25];\n          c[2] = pal[26];\n        } else {\n          // The base colour, tinted by Law where both primes are 3 mod 4.\n          const b = v > 0 ? 0 : 3, flip = three[i] && three[j] ? law : 0;\n          for (let e = 0; e \u003c 3; e++) c[e] = pal[b + e] + (pal[b + 6 + e] - pal[b + e]) * flip;\n          // The marks: white where the pair agrees with its mirror, green\n          // where it does not.\n          const m = mark[q];\n          if (m > 0.004) {\n            const w = leg[j * N + i] === v ? (v > 0 ? 12 : 15) : v > 0 ? 18 : 21;\n            for (let e = 0; e \u003c 3; e++) c[e] += (pal[w + e] - c[e]) * m;\n          }\n        }\n        display.setPixel(x, y + half * N, (255 * cl(c[0], 0, 1)) | 0, (255 * cl(c[1], 0, 1)) | 0, (255 * cl(c[2], 0, 1)) | 0);\n      }\n    }\n}\n","seam-carving":"// ===== Patternflow pattern =====\n// Title:   Seam Carving\n// Family:  algo\n// Idea:    An image of discs, rings, bands and a stripe fills the panel, its cumulative energy map sweeps down it row by row, and the cheapest eight-connected seam climbs back up from the bottom in white; then seam after seam lights the full height of the panel and is taken out, the columns closing in until the image is nearly a third narrower and the discs are still round, and after a map of the narrow image its cheapest seams are doubled one by one in mint until it is full width again and a new image is drawn.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: seam carving (Shai Avidan and Ariel Shamir, 2007), forward energy (Michael Rubinstein, Ariel Shamir and Shai Avidan, 2008), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Carve=20..40, Forward=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the ground runs from dark azure at the top to violet at the bottom with teal bands, the shapes are gold, rose, cyan, magenta and sky blue, and the energy map runs from indigo through magenta to gold; at 0.5 the ground is crimson with magenta bands and the shapes are blue, red, green, sea green and orange. The ground's wheel skips orange to lime, which reads brown when dim.\n// Knob 2: Speed. 2 is one unit of the timeline a second: the image fades in for 0.5 s, the map sweeps down in 0.7 s, the first seam climbs in 0.3 s and the map fades in 0.3 s, the carving takes 5.5 s whatever the count, the narrow image's map 1.6 s, the growing 4.5 s, and the full image rests 1.2 s: 14.6 s an image. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Carve. How many seams come out before the image grows back, 20 to 40 of its 64 columns; no row of a fresh image is more than 26 columns of shape. At 20 the image ends 44 columns wide and the carving takes 24 shape pixels an image, mostly half-lit rim pixels, out of the 2,560 it removes; at 30 it takes 93 and at 40, when some rows have no ground left, 376, and the discs come out oval. The growing doubles at most an eighth of the columns at a time, re-planned on the wider image after each batch: 5, 6, 6 and 3 seams at 20.\n// Knob 4: Forward. Mixes the seam cost from Avidan and Shamir's gradient energy at 0 to Rubinstein's forward energy at 1, the cost of the edges a removal creates. The rim light on the image is the energy the knob uses: at 0 every outline glows, at 1 only the edges a removal would join, so the tops and bottoms of the discs and the bands go dark. A seam straight down the flat middle of a disc creates no edge, so at 1 the carving takes 78 shape pixels an image instead of 24, and a disc can grow back as a capsule.\n\nconst W = 64, H = 128, F = 8, N = W * H;\nconst { floor, min, max, abs, sqrt, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n// The timeline, in units of a second at Speed 2.\nconst T_IN = 0.5, T_MAP = 0.7, T_TRACE = 0.3, T_UNMAP = 0.3, T_CARVE = 5.5, T_GROW = 4.5, T_REST = 1.2;\n// The narrow image's map: a pause, the sweep, a hold and the fade.\nconst H_PAUSE = 0.3, H_MAP = 0.7, H_HOLD = 0.3, H_FADE = 0.3, T_HOLD = H_PAUSE + H_MAP + H_HOLD + H_FADE;\n// Within one seam's slot of the carving: it climbs, holds, then closes.\nconst Q_TRACE = 0.3, Q_CLOSE = 0.5;\n// Within one seam's slot of the growing: its pixels light, then the copies open.\nconst G_OPEN = 0.3, G_FADE = 0.9;\n// Every pixel carries a random number; JIT of it is added to the cost so\n// that ties across flat ground break at random instead of to the left.\nconst JIT = 0.004;\n// Rim light: the energy shown on the image, at GLOW for an energy of E_REF.\nconst GLOW = 0.42, E_REF = 0.5;\n// Hues at knob 0. The ground goes through a wheel that skips orange to\n// lime: 0.62 azure at the top to 0.71 violet at the bottom, bands 0.55 teal.\nconst BG0 = 0.46, SH0 = 0.12, PALETTE = [0, 0.83, 0.38, 0.79, 0.45];\n// Shapes: 0 a shaded disc, 1 a thin ring, 2 a thick ring, 3 a ring round a disc.\nconst KINDS = [0, 0, 1, 2, 3];\n// The ground's hue for knob k and the pixel's offset: the offset is\n// folded back at the wheel's ends rather than wrapped, so the gradient\n// never jumps from rose to lime halfway down the panel.\nfunction groundHue(k, off) {\n  let t = BG0 + k - floor(BG0 + k) + off;\n  t = t \u003c 0 ? -t : t > 1 ? 2 - t : t;\n  return 0.28 + 0.74 * t;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// A pixel is F floats: 0..2 its colour at knob 0, which the energy reads;\n// 3 its hue offset, 4 saturation, 5 value; 6 its tie-breaking random\n// number; 7 is 1 for the ground, whose hue goes through the skipping wheel.\n// Rows are W pixels apart in memory and the first S.w of them are the image.\nconst tmp = [0, 0, 0];\nfunction setRef(img, o) {\n  hsv(img[o + 7] ? groundHue(0, img[o + 3]) : SH0 + img[o + 3], img[o + 4], img[o + 5], tmp);\n  img[o] = tmp[0];\n  img[o + 1] = tmp[1];\n  img[o + 2] = tmp[2];\n}\n// Lay colour (h, s, v) over a pixel with coverage a. Hue is not blended:\n// the edge pixel takes the hue of whichever covers more of it.\nfunction lay(img, o, a, h, s, v, ground) {\n  if (a \u003c= 0) return;\n  a = min(1, a);\n  if (a >= 0.5) (img[o + 3] = h), (img[o + 7] = ground);\n  img[o + 4] += (s - img[o + 4]) * a;\n  img[o + 5] += (v - img[o + 5]) * a;\n}\n\n// A fresh image: a vertical gradient for ground, one or two teal bands,\n// often a thin diagonal stripe from edge to edge, then discs and rings\n// placed so no row is more than 26 columns shape, which leaves the seams\n// at least 38 columns of ground in every row.\nfunction paint(S) {\n  const img = S.img, R = Math.random;\n  S.w = W;\n  const h0 = R() * 0.04, h1 = h0 + 0.08 + R() * 0.04;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0, t = y / (H - 1); x \u003c W; x++) {\n      const o = (y * W + x) * F;\n      img[o + 3] = h0 + (h1 - h0) * t;\n      img[o + 4] = 0.78;\n      img[o + 5] = 0.36 - 0.1 * t;\n      img[o + 6] = R();\n      img[o + 7] = 1;\n    }\n  const nb = 1 + (R() \u003c 0.6 ? 1 : 0);\n  for (let b = 0; b \u003c nb; b++) {\n    const y0 = 6 + floor(R() * (H - 16)), hb = 3 + floor(R() * 4);\n    for (let y = y0; y \u003c y0 + hb; y++) for (let x = 0; x \u003c W; x++) lay(img, (y * W + x) * F, 1, -0.1, 0.72, 0.5, 1);\n  }\n  if (R() \u003c 0.7) {\n    // The stripe: centre line from (0, ya) to (63, yb), 2.4 LEDs across.\n    const ya = 10 + R() * (H - 20), dy = (R() \u003c 0.5 ? -1 : 1) * (26 + R() * 30), yb = cl(ya + dy, 4, H - 5);\n    const k = (yb - ya) / (W - 1), nrm = 1 / sqrt(1 + k * k), hs = PALETTE[floor(R() * PALETTE.length)];\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const d = abs(y - (ya + k * x)) * nrm;\n        lay(img, (y * W + x) * F, 1.7 - d, hs, 0.55, 0.78, 0);\n      }\n  }\n  const cov = new Float32Array(H), shapes = [];\n  for (let tries = 0; tries \u003c 500 && shapes.length \u003c 9; tries++) {\n    const r = 5 + R() * 9, cx = 2.5 + r + R() * (W - 5 - 2 * r), cy = 2.5 + r + R() * (H - 5 - 2 * r);\n    let ok = true;\n    for (const s of shapes) if ((s.cx - cx) ** 2 + (s.cy - cy) ** 2 \u003c (s.r + r + 3) ** 2) ok = false;\n    for (let y = floor(cy - r); ok && y \u003c= cy + r; y++) if (cov[y] + 2 * sqrt(max(0, r * r - (y - cy) ** 2)) > 26) ok = false;\n    if (!ok) continue;\n    for (let y = floor(cy - r); y \u003c= cy + r; y++) cov[y] += 2 * sqrt(max(0, r * r - (y - cy) ** 2));\n    shapes.push({ cx, cy, r, kind: KINDS[floor(R() * KINDS.length)], h: PALETTE[floor(R() * PALETTE.length)], pale: R() \u003c 0.15 });\n  }\n  for (const s of shapes) {\n    const sat = s.pale ? 0.18 : 0.8;\n    for (let y = max(0, floor(s.cy - s.r - 1)); y \u003c= min(H - 1, s.cy + s.r + 1); y++)\n      for (let x = max(0, floor(s.cx - s.r - 1)); x \u003c= min(W - 1, s.cx + s.r + 1); x++) {\n        const d = sqrt((x + 0.5 - s.cx) ** 2 + (y + 0.5 - s.cy) ** 2), o = (y * W + x) * F;\n        // Discs are shaded like a ball, half as bright at the rim, which also\n        // gives their insides an energy the seams would rather go round.\n        if (s.kind === 0) lay(img, o, s.r + 0.5 - d, s.h, sat, 1 - 0.5 * (d / s.r) ** 2, 0);\n        else if (s.kind === 1) lay(img, o, 1.8 - abs(d - s.r + 1.3), s.h, sat, 0.95, 0);\n        else if (s.kind === 2) lay(img, o, min(s.r + 0.5 - d, d - 0.5 * s.r + 0.5), s.h, sat, 0.92, 0);\n        else {\n          lay(img, o, 1.6 - abs(d - s.r + 1.1), s.h, sat, 0.95, 0);\n          lay(img, o, 0.42 * s.r + 0.5 - d, s.h + 0.5, sat, 1 - 0.45 * (d / (0.42 * s.r)) ** 2, 0);\n        }\n      }\n  }\n  for (let o = 0; o \u003c N * F; o += F) setRef(img, o);\n}\n\nconst d3 = (a, o1, o2) => abs(a[o1] - a[o2]) + abs(a[o1 + 1] - a[o2 + 1]) + abs(a[o1 + 2] - a[o2 + 2]);\n\n// The dynamic programme over rows, on the first w columns of img.\n// Backward energy is Avidan and Shamir's e1, |dI/dx| + |dI/dy| summed over\n// the colours, central differences with the border pixel repeated. Forward\n// energy is the cost of the new neighbours a removal makes: taking (x, y)\n// joins x - 1 and x + 1 in row y, CU = |I(x+1,y) - I(x-1,y)|; if the seam\n// came from (x - 1, y - 1) the pixel (x, y - 1) also comes to sit over\n// (x - 1, y), CL = CU + |I(x,y-1) - I(x-1,y)|, and from (x + 1, y - 1)\n// CR = CU + |I(x,y-1) - I(x+1,y)|. With f the knob,\n// M(x,y) = (1 - f) e1(x,y) + min over the three of M(x', y-1) + f C.\n// back holds the move that won (-1, 0, +1); seam gets the cheapest path,\n// one pixel a row, from the least M in the bottom row back up.\nfunction carveDP(img, w, f, M, back, seam) {\n  for (let y = 0; y \u003c H; y++) {\n    const yu = y > 0 ? y - 1 : 0, yd = y \u003c H - 1 ? y + 1 : y;\n    for (let x = 0; x \u003c w; x++) {\n      const o = (y * W + x) * F, ol = (y * W + (x > 0 ? x - 1 : 0)) * F, or = (y * W + (x \u003c w - 1 ? x + 1 : x)) * F;\n      const cu = d3(img, ol, or);\n      const e1 = 0.5 * (cu + d3(img, (yu * W + x) * F, (yd * W + x) * F));\n      const base = (1 - f) * e1 + JIT * img[o + 6], i = y * W + x;\n      if (y === 0) {\n        M[i] = base + f * cu;\n        back[i] = 0;\n        continue;\n      }\n      const ou = (yu * W + x) * F, j = i - W;\n      let best = M[j] + f * cu, mv = 0;\n      if (x > 0) {\n        const v = M[j - 1] + f * (cu + d3(img, ou, ol));\n        if (v \u003c best) (best = v), (mv = -1);\n      }\n      if (x \u003c w - 1) {\n        const v = M[j + 1] + f * (cu + d3(img, ou, or));\n        if (v \u003c best) (best = v), (mv = 1);\n      }\n      M[i] = base + best;\n      back[i] = mv;\n    }\n  }\n  let x = 0;\n  for (let c = 1, o = (H - 1) * W; c \u003c w; c++) if (M[o + c] \u003c M[o + x]) x = c;\n  for (let y = H - 1; y >= 0; y--) {\n    seam[y] = x;\n    x += back[y * W + x];\n  }\n  return M[(H - 1) * W + seam[H - 1]];\n}\n\n// Take one pixel out of every row; the rest of the row moves left.\nfunction removeSeam(img, ids, w, seam) {\n  for (let y = 0; y \u003c H; y++) {\n    const r = y * W, s = seam[y];\n    img.copyWithin((r + s) * F, (r + s + 1) * F, (r + w) * F);\n    ids.copyWithin(r + s, r + s + 1, r + w);\n  }\n}\n\n// Each row's M from its least to its greatest, kept for drawing the map. A\n// row's span is held to at least a third of the widest, so a row of plain\n// ground shows dark instead of its tie-breaking noise stretched to full.\nfunction rowRange(S, w, M) {\n  let top = 1e-6;\n  for (let y = 0; y \u003c H; y++) {\n    let a = Infinity, b = -Infinity;\n    for (let x = 0, o = y * W; x \u003c w; x++) (a = min(a, M[o + x])), (b = max(b, M[o + x]));\n    S.mlo[y] = a;\n    S.mhi[y] = b - a;\n    top = max(top, b - a);\n  }\n  for (let y = 0; y \u003c H; y++) S.mhi[y] = max(S.mhi[y], top / 3);\n}\n\n// The rim light: the energy the knob uses, per pixel. Forward energy has no\n// cost of its own at a pixel, only at a move; the cheapest move, straight\n// down, costs CU, and half of it is shown to match e1's half differences.\n// Each pixel's colour with its rim light is kept until the image, the hue\n// or the knob changes.\nfunction prepare(S) {\n  const img = S.img, w = S.w, f = S.f, hue = S.hue, C = S.C;\n  for (let y = 0; y \u003c H; y++) {\n    const yu = y > 0 ? y - 1 : 0, yd = y \u003c H - 1 ? y + 1 : y;\n    for (let x = 0; x \u003c w; x++) {\n      const i = y * W + x, o = i * F, ol = (y * W + (x > 0 ? x - 1 : 0)) * F, or = (y * W + (x \u003c w - 1 ? x + 1 : x)) * F;\n      const dx = d3(img, ol, or), dy = d3(img, (yu * W + x) * F, (yd * W + x) * F);\n      const e = min(1, (0.5 * (dx + (1 - f) * dy)) / E_REF);\n      S.G[i] = e;\n      hsv(img[o + 7] ? groundHue(hue, img[o + 3]) : SH0 + hue + img[o + 3], img[o + 4], img[o + 5], tmp);\n      C[i * 3] = tmp[0];\n      C[i * 3 + 1] = tmp[1];\n      C[i * 3 + 2] = tmp[2];\n    }\n  }\n  S.gw = w;\n  S.gf = f;\n  S.gh = hue;\n  S.dirty = false;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    img: new Float32Array(N * F), ids: new Int16Array(N), w: W,\n    M: new Float32Array(N), M2: new Float32Array(N), back: new Int8Array(N), seam: new Int16Array(H), mlo: new Float32Array(H), mhi: new Float32Array(H),\n    G: new Float32Array(N), C: new Float32Array(N * 3), gw: -1, gf: -1, gh: -1, dirty: true,\n    // The growing's plan: a copy carved down on the side, and the seams it gave.\n    T: new Float32Array(N * F), Tids: new Int16Array(N), tw: 0, plan: [], need: 0,\n    act: new Int16Array(H),\n    ph: 0, pt: 0, q: 0, k: 20, f: 0, hue: 0, removed: 0, grown: 0, inserted: false,\n    out: new Float32Array(N * 3), last: new Float32Array(N * 3),\n  });\n  paint(S);\n  S.ph = 0;\n}\n\n// Plan b seams to double: carve them out of a copy of the image one after\n// another, recording each by the ids of its pixels, which are the columns\n// of the image as it stands now. Avidan and Shamir enlarge this way, since\n// doubling the one cheapest seam over and over would stretch one column.\nfunction planStart(S, b) {\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c S.w; x++) S.ids[y * W + x] = x;\n  S.T.set(S.img);\n  S.Tids.set(S.ids);\n  S.tw = S.w;\n  S.plan = [];\n  S.need = b;\n}\nfunction planStep(S) {\n  if (S.plan.length >= S.need) return;\n  // The first plan's map is the one drawn; the rest go to a spare.\n  carveDP(S.T, S.tw, S.f, S.plan.length ? S.M2 : S.M, S.back, S.seam);\n  const ids = new Int16Array(H);\n  for (let y = 0; y \u003c H; y++) ids[y] = S.Tids[y * W + S.seam[y]];\n  if (S.plan.length === 0) rowRange(S, S.tw, S.M);\n  S.plan.push(ids);\n  removeSeam(S.T, S.Tids, S.tw, S.seam);\n  S.tw--;\n}\n\n// Double planned seam j: after its pixel in every row goes a new one, the\n// mean of it and its right neighbour. act holds where the new pixels are.\nfunction insertSeam(S, ids) {\n  const img = S.img, w = S.w;\n  for (let y = 0; y \u003c H; y++) {\n    const r = y * W;\n    let c = 0;\n    while (c \u003c w - 1 && S.ids[r + c] !== ids[y]) c++;\n    img.copyWithin((r + c + 2) * F, (r + c + 1) * F, (r + w) * F);\n    S.ids.copyWithin(r + c + 2, r + c + 1, r + w);\n    const o = (r + c) * F, n = (r + c + 1) * F, o2 = c + 1 \u003c w ? (r + c + 2) * F : o;\n    for (let k = 0; k \u003c 7; k++) img[n + k] = 0.5 * (img[o + k] + img[o2 + k]);\n    // Hues average the short way round the wheel; the ground keeps its wheel.\n    let dh = img[o2 + 3] - img[o + 3];\n    dh -= round(dh);\n    img[n + 3] = img[o + 3] + 0.5 * dh;\n    img[n + 7] = img[o + 7];\n    img[n + 6] = Math.random();\n    S.ids[r + c + 1] = -1;\n    S.act[y] = c + 1;\n  }\n  S.w++;\n}\n// The pixels of a planned seam in the image as it stands.\nfunction locate(S, ids) {\n  for (let y = 0; y \u003c H; y++) {\n    let c = 0;\n    while (c \u003c S.w - 1 && S.ids[y * W + c] !== ids[y]) c++;\n    S.act[y] = c;\n  }\n}\n\nfunction enter(S, ph) {\n  S.ph = ph;\n  S.pt = 0;\n  if (ph === 1) {\n    // The map, and the first seam with it.\n    carveDP(S.img, S.w, S.f, S.M, S.back, S.seam);\n    rowRange(S, S.w, S.M);\n    S.act.set(S.seam);\n  } else if (ph === 4) {\n    S.removed = 0;\n    S.q = Q_TRACE;\n  } else if (ph === 5) {\n    S.grow = S.removed;\n    S.grown = 0;\n    planStart(S, min(S.grow, floor(S.w / 8)));\n    planStep(S);\n  } else if (ph === 6) {\n    S.q = 0;\n    S.inserted = false;\n    S.done = 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 20, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.k = round(cl(kv[2], 20, 40));\n  S.f = cl(kv[3], 0, 1);\n  const g = (d * speed) / 2;\n  S.pt += g;\n  if (S.ph === 0) {\n    if (S.pt >= T_IN) enter(S, 1);\n  } else if (S.ph === 1) {\n    if (S.pt >= T_MAP) enter(S, 2);\n  } else if (S.ph === 2) {\n    if (S.pt >= T_TRACE) enter(S, 3);\n  } else if (S.ph === 3) {\n    if (S.pt >= T_UNMAP) enter(S, 4);\n  } else if (S.ph === 4) {\n    // The carving: k seams in T_CARVE, each in its slot of q from 0 to 1.\n    S.q += (g * S.k) / T_CARVE;\n    while (S.q >= 1) {\n      removeSeam(S.img, S.ids, S.w, S.act);\n      S.w--;\n      S.removed++;\n      S.dirty = true;\n      S.q -= 1;\n      if (S.removed >= S.k || S.w \u003c= 8) {\n        enter(S, 5);\n        break;\n      }\n      carveDP(S.img, S.w, S.f, S.M, S.back, S.seam);\n      S.act.set(S.seam);\n    }\n  } else if (S.ph === 5) {\n    // The narrow image's map, while the plan is carved on the side.\n    for (let n = 0; n \u003c 3; n++) planStep(S);\n    if (S.pt >= T_HOLD) {\n      while (S.plan.length \u003c S.need) planStep(S);\n      enter(S, 6);\n      locate(S, S.plan[0]);\n    }\n  } else if (S.ph === 6) {\n    // The growing: the planned seams doubled, one slot each.\n    S.q += (g * S.grow) / T_GROW;\n    for (;;) {\n      if (!S.inserted && S.q >= G_OPEN) {\n        insertSeam(S, S.plan[S.done]);\n        S.inserted = true;\n        S.dirty = true;\n      }\n      if (S.q \u003c 1) break;\n      S.q -= 1;\n      S.inserted = false;\n      S.done++;\n      S.grown++;\n      if (S.grown >= S.grow) {\n        enter(S, 7);\n        break;\n      }\n      if (S.done >= S.plan.length) {\n        // A batch is used up: plan the next one on the wider image.\n        planStart(S, min(S.grow - S.grown, floor(S.w / 8)));\n        while (S.plan.length \u003c S.need) planStep(S);\n        S.done = 0;\n      }\n      locate(S, S.plan[S.done]);\n    }\n  } else if (S.ph === 7) {\n    if (S.pt >= T_REST) {\n      S.last.set(S.out);\n      paint(S);\n      S.dirty = true;\n      enter(S, 0);\n    }\n  }\n}\n\nconst row = new Float32Array(W * 3), c = [0, 0, 0], h2 = [0, 0, 0];\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.dirty || S.gf !== S.f || S.gw !== S.w || S.gh !== S.hue) prepare(S);\n  const w = S.w, out = S.out, hue = S.hue;\n  // What is lit and how: the map's share a, the sweep's front row, the\n  // active seam's light and the width of its pixel.\n  let mapA = 0, front = -1, light = 0, lightFrom = H, aw = 1, x0 = floor((W - w) / 2), grow = false;\n  const off = (n) => floor((W - n) / 2);\n  const ph = S.ph;\n  if (ph === 1) (mapA = 1), (front = (S.pt / T_MAP) * H);\n  else if (ph === 2) (mapA = 1), (light = 1), (lightFrom = H * (1 - S.pt / T_TRACE));\n  else if (ph === 3) (mapA = 1 - smooth(S.pt / T_UNMAP)), (light = 1), (lightFrom = 0);\n  else if (ph === 4) {\n    const q = S.q;\n    light = 1;\n    lightFrom = q \u003c Q_TRACE ? H * (1 - q / Q_TRACE) : 0;\n    const p = smooth((q - Q_CLOSE) / (1 - Q_CLOSE));\n    aw = 1 - p;\n    x0 = off(w) + p * (off(w - 1) - off(w));\n  } else if (ph === 5) {\n    const t = S.pt - H_PAUSE;\n    if (t > 0 && t \u003c H_MAP) (mapA = 1), (front = (t / H_MAP) * H);\n    else if (t >= H_MAP) mapA = 1 - smooth((t - H_MAP - H_HOLD) / H_FADE);\n  } else if (ph === 6) {\n    const q = S.q;\n    grow = true;\n    light = q \u003c G_FADE ? 1 : 1 - (q - G_FADE) / (1 - G_FADE);\n    lightFrom = q \u003c G_OPEN ? H * (1 - q / G_OPEN) : 0;\n    if (S.inserted) {\n      const p = smooth((q - G_OPEN) / (G_FADE - G_OPEN));\n      aw = p;\n      x0 = off(w - 1) + p * (off(w) - off(w - 1));\n    }\n  }\n  // Seam lights: warm white for a carved seam, pale mint for a doubled one.\n  const sl = grow ? [0.72, 1, 0.86] : [1, 0.94, 0.8];\n  for (let y = 0; y \u003c H; y++) {\n    row.fill(0);\n    const act = light > 0 || aw !== 1 ? S.act[y] : -1;\n    let pos = x0;\n    for (let i = 0; i \u003c w; i++) {\n      const wd = i === act ? aw : 1;\n      if (wd \u003c= 0) continue;\n      const gl = GLOW * S.G[y * W + i] * (1 - mapA), oc = (y * W + i) * 3;\n      for (let k = 0; k \u003c 3; k++) c[k] = S.C[oc + k] + (1 - S.C[oc + k]) * gl;\n      if (mapA > 0 && (front \u003c 0 || y \u003c front)) {\n        // The cumulative energy map, each row from its least M to its greatest.\n        const m = sqrt((S.M[y * W + i] - S.mlo[y]) / S.mhi[y]);\n        hsv(0.72 + hue + 0.4 * m, 0.9 - 0.45 * m * m, 0.16 + 0.84 * m, h2);\n        for (let k = 0; k \u003c 3; k++) c[k] += (h2[k] - c[k]) * mapA;\n      }\n      if (front >= 0 && y === floor(front)) for (let k = 0; k \u003c 3; k++) c[k] += (1 - c[k]) * 0.6;\n      if (i === act && light > 0 && y >= lightFrom) {\n        const a = light * (grow ? 0.85 : 0.9);\n        for (let k = 0; k \u003c 3; k++) c[k] += (sl[k] - c[k]) * a;\n      }\n      // Lay the pixel over the LEDs it covers, by area.\n      const a = pos, b = pos + wd;\n      pos = b;\n      for (let x = max(0, floor(a)), x1 = min(W - 1, Math.ceil(b) - 1); x \u003c= x1; x++) {\n        const cov = min(b, x + 1) - max(a, x);\n        if (cov \u003c= 0) continue;\n        row[x * 3] += c[0] * cov;\n        row[x * 3 + 1] += c[1] * cov;\n        row[x * 3 + 2] += c[2] * cov;\n      }\n    }\n    // The first image fades in from black, every later one from the last.\n    const fade = ph === 0 ? smooth(S.pt / T_IN) : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      for (let k = 0; k \u003c 3; k++) out[o + k] = S.last[o + k] + (row[x * 3 + k] - S.last[o + k]) * fade;\n      display.setPixel(x, y, (255 * cl(out[o], 0, 1)) | 0, (255 * cl(out[o + 1], 0, 1)) | 0, (255 * cl(out[o + 2], 0, 1)) | 0);\n    }\n  }\n}\n","seifert-surface":"// ===== Patternflow pattern =====\n// Title:   Seifert Surface\n// Family:  topology\n// Idea:    A knot drawn as a closed braid down the panel goes through Seifert's algorithm step by step: its crossings are smoothed so it falls apart into nested Seifert circles, each circle fills with a disc at its own depth, a half-twisted band joins two discs at every crossing, and the finished surface rocks in 3-D with its two faces in two colours, each band turning from gold to blue across its half twist, before the next knot.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Seifert's algorithm (Herbert Seifert, 1934), every knot a closed braid (James Alexander, 1923), homogeneous braids give a minimal-genus surface (John Stallings, 1978), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knot=0..7, Tilt=40..80\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the face every disc shows the viewer is blue on the outer disc, indigo and violet further in, the other face is gold, the knot pale gold, and each Seifert circle a light tint of its disc.\n// Knob 2: Speed. At 2 one knot takes 17.2 seconds: 1.4 to draw it along its orientation, the crossings smoothed from 2.2 to 3.6, the discs in from 3.8 to 5.4, the bands one after another from 5.8 to 8.8, then the finished surface rocks twice while a bright run goes round its edge at 40 LEDs a second, and fades from 16.4. 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Knot. The knot to start from, then on round the list: 0 the trefoil 3_1 (sigma1^3), 1 the figure eight 4_1 ((sigma1 sigma2^-1)^2), 2 5_1 (sigma1^5), 3 5_2 (sigma1^3 sigma2 sigma1^-1 sigma2), 4 6_2 (sigma1^-1 sigma2 sigma1^-1 sigma2^3), 5 6_3 (sigma1^-1 sigma2^2 sigma1^-2 sigma2), 6 7_1 (sigma1^7), 7 8_19 ((sigma1 sigma2)^4). The surfaces have genus 1, 1, 2, 2, 2, 2, 3, 3; all but 5_2's are the least the knot allows, and 5_2, genus 1, gets 2 from this braid.\n// Knob 4: Tilt. How far the view turns about the panel's upright middle, 40 to 80 degrees. The discs lie 22 LEDs apart in depth, so at the full turn they slide 14 LEDs apart at 40 and 22 at 80, where they stand as thin plates with the bands bridging them. The knot itself is drawn turned a fifth as far, and the finished surface rocks between a fifth of the Tilt and all of it.\n\nconst W = 64, H = 128, NPX = W * H;\nconst { floor, ceil, min, max, cos, sin, abs, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\n\n// Knots as closed braids: the number of strands, and the word (i for\n// sigma_i, -i for its inverse). Each closes up to one component.\nconst KNOTS = [\n  { name: \"3_1\", n: 2, w: [1, 1, 1] },\n  { name: \"4_1\", n: 3, w: [1, -2, 1, -2] },\n  { name: \"5_1\", n: 2, w: [1, 1, 1, 1, 1] },\n  { name: \"5_2\", n: 3, w: [1, 1, 1, 2, -1, 2] },\n  { name: \"6_2\", n: 3, w: [-1, 2, -1, 2, 2, 2] },\n  { name: \"6_3\", n: 3, w: [-1, 2, 2, -1, -1, 2] },\n  { name: \"7_1\", n: 2, w: [1, 1, 1, 1, 1, 1, 1] },\n  { name: \"8_19\", n: 3, w: [1, 2, 1, 2, 1, 2, 1, 2] },\n];\n// The steps of one knot, in seconds at Speed 2.\nconst T_HOLD = 1.4, T_SMOOTH = 2.2, T_DISCS = 3.8, T_BANDS = 5.8, T_DONE = 8.8, T_FADE = 16.4, T_NEXT = 17.2;\n// Depth between stacked discs, in LEDs.\nconst DZ = 22;\nconst STEP = 0.6;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The diagram, in LEDs about the panel's middle column. The braid runs\n// down the left and strand i comes back up the right, so once the\n// crossings are smoothed strand i is the rounded rectangle \"loop i\", the\n// loops nested one inside the next: wide apart on the left where the\n// bands go, close on the right. Disc i lies at depth z = (i - (n-1)/2) DZ,\n// the inner discs nearer the viewer. Every loop runs down its left side,\n// so the Seifert circles are oriented alike and every disc turns the same\n// face to the viewer.\nfunction layout(K) {\n  const n = K.n, c = K.w.length, dl = n === 2 ? 22 : 15, dr = n === 2 ? 8 : 6;\n  const loops = [];\n  for (let i = 0; i \u003c n; i++)\n    loops.push({ l: -30 + i * dl, r: 26 - dr * i, t: 4 + 7 * i, b: 124 - 7 * i, rc: 12 - 2 * i, z: (i - (n - 1) / 2) * DZ });\n  let top = -1e9, bot = 1e9;\n  for (const L of loops) (top = max(top, L.t + L.rc)), (bot = min(bot, L.b - L.rc));\n  const gap = (bot - top) / c, h = min(8, 0.36 * gap);\n  const cross = K.w.map((g, k) => ({ i: abs(g) - 1, sg: g > 0 ? 1 : -1, y: top + (k + 0.5) * gap }));\n  return { n, c, loops, cross, h, top, bot };\n}\n\n// A point of crossing k's band: u runs from the left loop (u = 0) to the\n// right one (u = 1), v across from -1 to 1. The band's width turns half\n// round about its core on the way, the sense of the turn set by the\n// crossing's sign, so its two edges pass over each other once: those edges\n// are the knot's two strands at the crossing.\nfunction bandPoint(G, k, u, v, out) {\n  const X = G.cross[k], A = G.loops[X.i], B = G.loops[X.i + 1];\n  const h = G.h, e = -X.sg;\n  out[0] = A.l + u * (B.l - A.l);\n  out[1] = X.y + v * h * cos(PI * u);\n  out[2] = A.z + u * (B.z - A.z) + v * h * e * sin(PI * u);\n}\n\n// The knot, walked along its orientation as one closed polyline. Every\n// point keeps where it sits in the knot, where it sits once the crossings\n// are smoothed, its crossing (or -1), the Seifert circle it lands on, and\n// how far along the knot it is.\nfunction walk(G) {\n  const P = [];\n  const add = (x, y, z, sx, sy, sz, k, circ) => P.push([x, y, z, sx, sy, sz, k, circ]);\n  const line = (i, x0, y0, x1, y1) => {\n    const z = G.loops[i].z, m = max(1, ceil(hypot(x1 - x0, y1 - y0) / STEP));\n    for (let j = 0; j \u003c m; j++) {\n      const x = x0 + ((x1 - x0) * j) / m, y = y0 + ((y1 - y0) * j) / m;\n      add(x, y, z, x, y, z, -1, i);\n    }\n  };\n  const arc = (i, cx, cy, a0, a1) => {\n    const L = G.loops[i], m = max(2, ceil((L.rc * abs(a1 - a0)) / STEP));\n    for (let j = 0; j \u003c m; j++) {\n      const t = a0 + ((a1 - a0) * j) / m, x = cx + L.rc * cos(t), y = cy + L.rc * sin(t);\n      add(x, y, L.z, x, y, L.z, -1, i);\n    }\n  };\n  // Loop i from the foot of the braid round the bottom, up the right and\n  // over the top, back to the head of the braid.\n  const around = (i) => {\n    const { l, r, t, b, rc } = G.loops[i];\n    line(i, l, G.bot, l, b - rc);\n    arc(i, l + rc, b - rc, PI, PI / 2);\n    line(i, l + rc, b, r - rc, b);\n    arc(i, r - rc, b - rc, PI / 2, 0);\n    line(i, r, b - rc, r, t + rc);\n    arc(i, r - rc, t + rc, 0, -PI / 2);\n    line(i, r - rc, t, l + rc, t);\n    arc(i, l + rc, t + rc, -PI / 2, -PI);\n    line(i, l, t + rc, l, G.top);\n  };\n  const q = [0, 0, 0];\n  let p = 0, guard = 0;\n  do {\n    let y = G.top;\n    G.cross.forEach((X, k) => {\n      if (X.i !== p && X.i + 1 !== p) return;\n      line(p, G.loops[p].l, y, G.loops[p].l, X.y - G.h);\n      const down = X.i === p, i0 = X.i, i1 = X.i + 1;\n      const m = max(8, ceil(hypot(G.loops[i1].l - G.loops[i0].l, 2 * G.h, G.loops[i1].z - G.loops[i0].z) / STEP));\n      for (let j = 0; j \u003c m; j++) {\n        // Down a strand from loop i to loop i + 1 (or back): its first half\n        // smooths onto the loop it came from, its second onto the other.\n        const w = j / m, u = down ? w : 1 - w, first = w \u003c 0.5;\n        bandPoint(G, k, u, down ? -1 : 1, q);\n        const circ = down === first ? i0 : i1, L = G.loops[circ];\n        add(q[0], q[1], q[2], L.l, X.y - G.h + 2 * w * G.h, L.z, k, circ);\n      }\n      p = down ? i1 : i0;\n      y = X.y + G.h;\n    });\n    line(p, G.loops[p].l, y, G.loops[p].l, G.bot);\n    around(p);\n  } while (p !== 0 && ++guard \u003c 4);\n  const n = P.length, D = new Float32Array(n * 9);\n  let s = 0;\n  P.forEach((e, j) => {\n    for (let t = 0; t \u003c 8; t++) D[j * 9 + t] = e[t];\n    D[j * 9 + 8] = s;\n    const f = P[(j + 1) % n];\n    s += hypot(f[0] - e[0], f[1] - e[1], f[2] - e[2]);\n  });\n  return { D, n, length: s, passes: guard + 1 };\n}\n\nexport function buildKnot(index) {\n  const K = KNOTS[((index % KNOTS.length) + KNOTS.length) % KNOTS.length];\n  const G = layout(K);\n  G.name = K.name;\n  G.word = K.w;\n  G.knot = walk(G);\n  return G;\n}\n\nexport function setup(params) {\n  params.s = {\n    G: null, idx: -1, knob: -1, t: 0, hue: 0, tilt: 0.7,\n    zb: new Float32Array(NPX), rgb: new Float32Array(NPX * 3), hz: new Float32Array(NPX), cz: new Float32Array(NPX),\n    lr: new Float32Array(NPX * 3), gl: new Float32Array(NPX * 3), gv: new Float32Array(NPX * 3), c: [0, 0, 0], q: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 40];\n  const g = (cl(dt || 0, 0, 0.1) * cl(kv[1], 0.2, 3)) / 2;\n  S.hue = cl(kv[0], 0, 1);\n  S.tilt = (cl(kv[3], 40, 80) * PI) / 180;\n  const knob = floor(cl(kv[2], 0, 7) + 1e-6);\n  if (knob !== S.knob) (S.knob = knob), (S.idx = knob), (S.G = buildKnot(knob)), (S.t = 0);\n  S.t += g;\n  if (S.t >= T_NEXT) (S.t -= T_NEXT), (S.idx += 1), (S.G = buildKnot(S.idx));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.G) return;\n  const G = S.G, t = S.t, { zb, rgb, hz, cz, lr, c: col, q } = S;\n  const n = G.n, nc = G.c;\n  // The view turns about the panel's upright middle: a fifth of the Tilt\n  // while the knot and its circles are drawn, out to the whole Tilt as the\n  // discs come in, then rocking between the two while the surface is whole.\n  const tl = S.tilt;\n  let phi = tl * (0.18 + 0.06 * sin(t * 1.3));\n  if (t > T_DISCS) phi += (tl - phi) * ease((t - T_DISCS) / 2);\n  if (t > T_DONE) phi = tl * (0.6 + 0.4 * cos((PI * (t - T_DONE)) / 1.9));\n  const cp = cos(phi), sp = sin(phi);\n  const fade = t > T_FADE ? 1 - ease((t - T_FADE) / (T_NEXT - T_FADE - 0.05)) : 1;\n  const smooth = ease((t - T_SMOOTH) / 1.4);\n  const bandOf = (k) => ease((t - T_BANDS - (k * 2.4) / max(1, nc - 1)) / 0.6);\n  const discOf = (i) => ease((t - T_DISCS - 0.4 * i) / 0.8);\n  zb.fill(-1e9);\n  rgb.fill(0);\n  hz.fill(-1e9);\n  cz.fill(-1e9);\n  lr.fill(0);\n  const H0 = S.hue;\n  // Two faces: the face every disc turns to the viewer is blue to violet,\n  // a shade per disc; the other face is gold.\n  const face = (i, v, out) => hsv(H0 + 0.58 + 0.09 * i, 0.75, v, out);\n  const other = (v, out) => hsv(H0 + 0.12, 0.85, v, out);\n  // Discs: each LED is taken back through the turn onto each disc's plane,\n  // and the nearest disc that holds it wins.\n  for (let i = 0; i \u003c n; i++) {\n    const A = discOf(i);\n    if (A \u003c= 0) continue;\n    const L = G.loops[i];\n    if (cp > 0) face(i, 0.62 * A * fade, col);\n    else other(0.62 * A * fade, col);\n    const mx = (L.l + L.r) / 2, hw = (L.r - L.l) / 2 - L.rc, my = (L.t + L.b) / 2, hh = (L.b - L.t) / 2 - L.rc;\n    // Only the columns the turned disc can reach.\n    const xa = max(0, floor(32 + min(L.l * cp, L.r * cp) + L.z * sp - 1)), xb = min(W - 1, ceil(32 + max(L.l * cp, L.r * cp) + L.z * sp + 1));\n    const ic = 1 / cp, off = 32 + L.z * sp, r2 = L.rc * L.rc, kx = 0.6 / (L.r - L.l), ky = 0.6 / (L.b - L.t);\n    for (let y = max(0, floor(L.t)); y \u003c= min(H - 1, ceil(L.b)); y++) {\n      const dy = abs(y + 0.5 - my) - hh;\n      if (dy > L.rc) continue;\n      const sy = 1 - (y - L.t) * ky;\n      for (let x = xa; x \u003c= xb; x++) {\n        const xm = (x + 0.5 - off) * ic;\n        const dx = abs(xm - mx) - hw;\n        if (dx > L.rc || (dx > 0 && dy > 0 && dx * dx + dy * dy > r2)) continue;\n        const d = -xm * sp + L.z * cp, p = y * W + x;\n        if (d \u003c= zb[p]) continue;\n        zb[p] = d;\n        // A soft light from the upper left.\n        const shade = 0.78 + 0.22 * cl(sy - (xm - L.l) * kx, 0, 1);\n        rgb[p * 3] = col[0] * shade;\n        rgb[p * 3 + 1] = col[1] * shade;\n        rgb[p * 3 + 2] = col[2] * shade;\n      }\n    }\n  }\n  // Bands, sampled finely and splatted with the depth test. Where a band\n  // turns to the viewer the face the discs show, it takes their colour;\n  // where its half twist shows the other face, gold.\n  for (let k = 0; k \u003c nc; k++) {\n    const B = bandOf(k);\n    if (B \u003c= 0) continue;\n    const X0 = G.cross[k], A = G.loops[X0.i], Bl = G.loops[X0.i + 1], hb = G.h, e = -X0.sg;\n    const ddx = Bl.l - A.l, ddz = Bl.z - A.z;\n    const NU = ceil(hypot(ddx, ddz) * 1.6), NV = ceil(hb * 3.2);\n    for (let iu = 0; iu \u003c= NU; iu++) {\n      const u = iu / NU, cu = cos(PI * u), su = sin(PI * u);\n      const x = A.l + u * ddx, zc = A.z + u * ddz;\n      for (let iv = 0; iv \u003c= NV; iv++) {\n        const v = -1 + (2 * iv) / NV;\n        const y = X0.y + v * hb * cu, z = zc + v * hb * e * su;\n        const X = 32 + x * cp + z * sp, d = -x * sp + z * cp;\n        const px = floor(X), py = floor(y);\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const p = py * W + px;\n        if (d \u003c= zb[p]) continue;\n        // The face's normal, d/du x d/dv; the band is oriented to agree\n        // with the disc it runs into at u = 1.\n        const uy = -v * hb * PI * su, uz = ddz + v * hb * e * PI * cu, vy = hb * cu, vz = hb * e * su;\n        const nx = uy * vz - uz * vy, nz = ddx * vy;\n        const lit = 0.7 + (0.3 * abs(-nx * sp + nz * cp)) / (hypot(nx, nz) + 1e-9);\n        if (nx * sp - nz * cp > 0) face(X0.i + u, 0.85 * lit * fade, col);\n        else other(0.95 * lit * fade, col);\n        // A band coming in shows through to what lies behind it.\n        if (B > 0.5) zb[p] = d;\n        rgb[p * 3] += (col[0] - rgb[p * 3]) * B;\n        rgb[p * 3 + 1] += (col[1] - rgb[p * 3 + 1]) * B;\n        rgb[p * 3 + 2] += (col[2] - rgb[p * 3 + 2]) * B;\n      }\n    }\n  }\n  // The curve. The points of the crossing strands first mark the LEDs round\n  // them as passed at their depth; then a point draws its core only where\n  // nothing a good way nearer passes close by, which leaves the gap of an\n  // under-crossing.\n  const KD = G.knot.D, KN = G.knot.n, len = G.knot.length;\n  const drawn = t \u003c T_HOLD ? len * ease(t / T_HOLD) : len + 1;\n  const pos = (j, out) => {\n    const o = j * 9, k = KD[o + 6];\n    const m = k >= 0 ? smooth * (1 - bandOf(k)) : 0;\n    out[0] = KD[o] + (KD[o + 3] - KD[o]) * m;\n    out[1] = KD[o + 1] + (KD[o + 4] - KD[o + 1]) * m;\n    out[2] = KD[o + 2] + (KD[o + 5] - KD[o + 2]) * m;\n  };\n  for (let j = 0; j \u003c KN; j++) {\n    if (KD[j * 9 + 8] > drawn) break;\n    if (KD[j * 9 + 6] \u003c 0) continue;\n    pos(j, q);\n    const X = 32 + q[0] * cp + q[2] * sp, d = -q[0] * sp + q[2] * cp, Y = q[1];\n    for (let yy = max(0, floor(Y - 2.6)); yy \u003c= min(H - 1, floor(Y + 2.6)); yy++)\n      for (let xx = max(0, floor(X - 2.6)); xx \u003c= min(W - 1, floor(X + 2.6)); xx++) {\n        const ex = xx + 0.5 - X, ey = yy + 0.5 - Y;\n        if (ex * ex + ey * ey > 6.76) continue;\n        const p = yy * W + xx;\n        if (d > hz[p]) hz[p] = d;\n      }\n  }\n  // One knot in white, then its Seifert circles each in its disc's colour,\n  // then white again as the bands make it the surface's edge. A bright run\n  // goes round it the way it is oriented.\n  const circ = ease((t - T_SMOOTH) / 0.8) * (1 - ease((t - T_BANDS) / 2.6));\n  const runAt = ((t * 40) % (len + 60)) - 30;\n  // The knot is a pale tint of the gold face; it draws thinner once it is\n  // the edge of the surface.\n  const pale = [0, 0, 0];\n  hsv(H0 + 0.12, 0.22, 0.95, pale);\n  const rad = 1.2 - 0.4 * ease((t - T_BANDS) / 2);\n  for (let j = 0; j \u003c KN; j++) {\n    const o = j * 9, s = KD[o + 8];\n    if (s > drawn) break;\n    pos(j, q);\n    const X = 32 + q[0] * cp + q[2] * sp, d = -q[0] * sp + q[2] * cp, Y = q[1];\n    hsv(H0 + 0.58 + 0.09 * KD[o + 7], 0.5, 1, col);\n    const run = t \u003c T_SMOOTH || t > T_DONE ? cl(1 - abs(s - runAt) / 16, 0, 1) : 0;\n    const wv = (1 - circ) * (1 - 0.45 * run);\n    const tip = t \u003c T_HOLD ? cl(1 - (drawn - s) / 12, 0, 1) : 0;\n    const r = col[0] * circ + wv * pale[0] + run * 1.0 * (1 - circ) + tip;\n    const gg = col[1] * circ + wv * pale[1] + run * 0.75 * (1 - circ) + tip;\n    const bb = col[2] * circ + wv * pale[2] + run * 0.2 * (1 - circ) + tip;\n    for (let yy = max(0, floor(Y - rad)); yy \u003c= min(H - 1, floor(Y + rad)); yy++)\n      for (let xx = max(0, floor(X - rad)); xx \u003c= min(W - 1, floor(X + rad)); xx++) {\n        const ex = xx + 0.5 - X, ey = yy + 0.5 - Y;\n        if (ex * ex + ey * ey > rad * rad) continue;\n        const p = yy * W + xx;\n        if (d \u003c hz[p] - 3 || d \u003c zb[p] - 3 || d \u003c cz[p]) continue;\n        cz[p] = d;\n        lr[p * 3] = r * fade;\n        lr[p * 3 + 1] = gg * fade;\n        lr[p * 3 + 2] = bb * fade;\n      }\n  }\n  // A faint glow round the curve where nothing else is lit: the curve\n  // blurred over five LEDs each way, a row pass and then a column pass.\n  const { gl, gv } = S, glow = t \u003c T_DISCS + 2;\n  if (glow) {\n    for (let y = 0; y \u003c H; y++)\n      for (let ch = 0; ch \u003c 3; ch++) {\n        let acc = 0;\n        for (let x = -2; x \u003c W; x++) {\n          if (x + 2 \u003c W) acc += lr[(y * W + x + 2) * 3 + ch];\n          if (x - 3 >= 0) acc -= lr[(y * W + x - 3) * 3 + ch];\n          if (x >= 0) gl[(y * W + x) * 3 + ch] = acc;\n        }\n      }\n    for (let x = 0; x \u003c W; x++)\n      for (let ch = 0; ch \u003c 3; ch++) {\n        let acc = 0;\n        for (let y = -2; y \u003c H; y++) {\n          if (y + 2 \u003c H) acc += gl[((y + 2) * W + x) * 3 + ch];\n          if (y - 3 >= 0) acc -= gl[((y - 3) * W + x) * 3 + ch];\n          if (y >= 0) gv[(y * W + x) * 3 + ch] = acc * 0.035;\n        }\n      }\n  }\n  for (let p = 0; p \u003c NPX; p++) {\n    const src = cz[p] > -1e8 ? lr : zb[p] > -1e8 || !glow ? rgb : gv;\n    const o = p * 3;\n    display.setPixel(p % W, (p / W) | 0, (255 * cl(src[o], 0, 1)) | 0, (255 * cl(src[o + 1], 0, 1)) | 0, (255 * cl(src[o + 2], 0, 1)) | 0);\n  }\n}\n","voderberg-tiling":"// ===== Patternflow pattern =====\n// Title:   Voderberg Tiling\n// Family:  cells\n// Idea:    Copies of Voderberg's nine-sided tile, a 12-degree sliver with a barb at its point, lie in his two-armed spiral: each cycle opens close on the middle, where two tiles shut a third in and then two shut in a pair, then backs out while the tiling grows tile by tile along its arms, turns slowly with the colour running out along each arm, and unwinds from the middle.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Voderberg's tile and spiral tiling (Heinz Voderberg, 1936), spiral tilings in Tilings and Patterns (Branko Grünbaum and G. C. Shephard, 1987), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=16..44, Arms=2..6\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 one arm runs from teal at the middle to blue at the rim and the other from violet to rose; a tile that points in is a fifth darker than one that points out, each tile brightens toward its wide end, and the grout is dark. The colours also creep a quarter of the way round the wheel in a cycle and move on a step between cycles.\n// Knob 2: Speed. At 2 a cycle takes 34 seconds: 2.2 on the four tiles at the middle, 8 for the tiling to grow out to the rim while the view backs out, 20 of the whole spiral turning at 3 degrees a second with a slow wave of light running out along the arms, and 4 to unwind from the middle. Tiles not yet laid show at a seventh of their brightness. 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Size. How long one tile is once the view has backed out: 16 LEDs at the opening, about 300 tiles on the panel and two turns of each arm from the middle to the top edge, up to 44 LEDs and about 40 tiles. At the start of a cycle a tile is 64 LEDs plus 1.4 times this long, 86 at the opening.\n// Knob 4: Arms. 2 is Voderberg's own spiral: below the middle the tiles lie in rings round one point and above it in the same rings turned half round, slipped one ring along, so each ring runs on into the next and two arms wind out. 4 and 6 slip the rings two and three rings along, four and six arms of the same tile; the knob rounds to 2, 4 or 6. Only the 2-arm spiral holds the four tiles of the opening, so 4 and 6 go straight to the growth.\n\nconst W = 64, H = 128, NPX = W * H;\nconst { floor, ceil, min, max, cos, sin, sqrt, atan2, round, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\nconst EPS = (12 * PI) / 180;\n// Rings of tiles built round each centre; ten reach past the corners of the\n// panel at the smallest size.\nconst NRING = 10;\n// The cycle, in seconds at Speed 2.\nconst INTRO = 2.2, GROW = 8, HOLD_END = 30, UNWIND = 4, CYCLE = HOLD_END + UNWIND;\n// At the opening a tile is 64 LEDs long plus 1.4 times the knob's size.\nconst L_INTRO = 64, L_INTRO_K = 1.4;\n// Tiles not yet laid, or already taken up, show faintly at this level.\nconst GHOST = 0.14;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nconst rot = (p, a) => [p[0] * cos(a) - p[1] * sin(a), p[0] * sin(a) + p[1] * cos(a)];\n\n// Voderberg's nonagon. Z is the apex, ZT = 1 and U is T turned 12 degrees\n// about Z, so ZTU is the thin isosceles triangle; S is the middle of ZT and\n// R is S turned back 12 degrees. The tile's two long sides are the chain\n// Z a1 a2 a3 T and the same chain turned 12 degrees about Z, Z b1 b2 b3 U,\n// so 30 tiles turned about Z close up into a regular 30-gon, and its other\n// side U T is the triangle's base. b1 = T + Z - U makes Z b1 T U a\n// parallelogram, and the chain Z b1 b2 b3 U T is the same chain read\n// backwards after a half turn about S (so S lies on b2 b3), which lets a\n// tile and its half turn about S fit against each other along all five of\n// those edges. The one point left free, a2, is fixed by one more ruler and\n// compass step: on the line through a1 square to RS (so the corner at a1\n// is square) at distance ZT from U. a3 is a2 turned half round R.\n// Angles: 12 at Z, 90 at a1 and U, 158.67 at a2 and b2, 201.33 at a3 and\n// b3, 78 at T, 270 at b1; the area is that of the triangle, sin(12)/2.\nexport function voderbergTile() {\n  const T = [1, 0], U = rot(T, EPS), R = rot([0.5, 0], -EPS);\n  const b1 = [T[0] - U[0], T[1] - U[1]], a1 = rot(b1, -EPS);\n  const d = [cos(-EPS / 2), sin(-EPS / 2)];\n  const f = [a1[0] - U[0], a1[1] - U[1]];\n  const B = f[0] * d[0] + f[1] * d[1], C = f[0] * f[0] + f[1] * f[1] - 1;\n  const t = -B - sqrt(B * B - C);\n  const a2 = [a1[0] + t * d[0], a1[1] + t * d[1]];\n  const a3 = [2 * R[0] - a2[0], 2 * R[1] - a2[1]];\n  return [[0, 0], a1, a2, a3, T, U, rot(a3, EPS), rot(a2, EPS), b1];\n}\n\n// The tiling. Round a centre the tiles lie in rings one tile long: ring 0 is\n// the 30 tiles turned about Z; in ring r, the tile of ring 0 turned j times\n// is moved out r times its own ZT and then 0..r times its barb edge Z a1,\n// and between two such neighbours sits the half turn of the first about\n// the middle of its a2 a3 edge, pointing in (ring r holds 30 (2r + 1)\n// tiles, which is its area over the tile's). Voderberg's spiral takes\n// the lower half of these rings round Z and the upper half of the same\n// rings turned half round a point slipped one ring along ZT: ring r below\n// runs on into ring r + 1 above, so the rings become two arms. A slip of k\n// rings gives 2k arms. Each tile keeps s = ring + k * (angle / 180), its\n// place along its arm, which grows by 2k a turn.\nexport function buildTiling(k) {\n  const X = voderbergTile();\n  const list = [];\n  const push = (poly, ring, kind) => {\n    let mx = 0, my = 0;\n    for (const p of poly) (mx += p[0]), (my += p[1]);\n    if (my >= 0) return -1;\n    list.push({ poly, ring, kind, mx: mx / 9, my: my / 9 });\n    return list.length - 1;\n  };\n  const special = [push(X, 0, 0), -1];\n  for (let j = 1; j \u003c 30; j++) {\n    const at = push(X.map((p) => rot(p, j * EPS)), 0, 0);\n    if (j === 29) special[1] = at;\n  }\n  for (let r = 1; r \u003c= NRING; r++)\n    for (let j = 0; j \u003c 30; j++) {\n      const F = X.map((p) => rot(p, j * EPS));\n      const uj = rot([1, 0], j * EPS), um = rot([1, 0], (j - 1) * EPS);\n      for (let i = 0; i \u003c= r; i++) {\n        const sx = r * uj[0] + i * (um[0] - uj[0]), sy = r * uj[1] + i * (um[1] - uj[1]);\n        const O = F.map((p) => [p[0] + sx, p[1] + sy]);\n        push(O, r, 1);\n        if (i \u003c r) {\n          const rx = O[2][0] + O[3][0], ry = O[2][1] + O[3][1];\n          push(O.map((p) => [rx - p[0], ry - p[1]]), r, 2);\n        }\n      }\n    }\n  const half = list.length, n = 2 * half, c = k / 2;\n  // Coordinates are centred on the spiral's middle, half way between Z and\n  // the slipped centre. Per tile: centre x, y, reach, s, arm parity, kind.\n  const V = new Float32Array(n * 18), info = new Float32Array(n * 6);\n  list.forEach((t, a) => {\n    const th = -atan2(t.my, t.mx);\n    for (let h = 0; h \u003c 2; h++) {\n      const id = a + h * half, mx = h ? c - t.mx : t.mx - c, my = h ? -t.my : t.my;\n      let rad = 0;\n      for (let q = 0; q \u003c 9; q++) {\n        const x = h ? c - t.poly[q][0] : t.poly[q][0] - c, y = h ? -t.poly[q][1] : t.poly[q][1];\n        V[id * 18 + q * 2] = x;\n        V[id * 18 + q * 2 + 1] = y;\n        rad = max(rad, hypot(x - mx, y - my));\n      }\n      info[id * 6] = mx;\n      info[id * 6 + 1] = my;\n      info[id * 6 + 2] = rad;\n      info[id * 6 + 3] = t.ring + (k * th) / PI;\n      info[id * 6 + 4] = (t.ring + (h ? k : 0)) & 1;\n      info[id * 6 + 5] = t.kind;\n    }\n  });\n  // X, A = X turned -12 degrees about Z, B = X turned half round S, A' = A\n  // turned half round S: A and B shut X in, A and A' shut in X and B.\n  return { n, V, info, X: special[0], A: special[1], B: special[0] + half, A2: special[1] + half };\n}\n\nexport function setup(params) {\n  params.s = {\n    k: 0, T: null, sizeFor: 0, sVis: 6, id: new Int32Array(NPX), shade: new Float32Array(NPX),\n    c: 0, turn: 0, dir: 1, hue0: 0, P: new Float32Array(18), xs: new Float32Array(12), rgb: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 16, 2];\n  const g = (cl(dt || 0, 0, 0.1) * cl(kv[1], 0.2, 3)) / 2;\n  S.hue = cl(kv[0], 0, 1);\n  S.size = cl(kv[2], 16, 44);\n  const k = cl(round(cl(kv[3], 2, 6) / 2), 1, 3);\n  if (k !== S.k) (S.k = k), (S.T = buildTiling(k)), (S.sizeFor = 0);\n  if (S.size !== S.sizeFor) {\n    // The furthest place along the arms that the panel shows at this size,\n    // whichever way the tiling is turned: the growth ends there.\n    const reach = hypot(32, 64) / S.size, info = S.T.info;\n    S.sVis = 0;\n    for (let t = 0; t \u003c S.T.n; t++)\n      if (hypot(info[t * 6], info[t * 6 + 1]) - info[t * 6 + 2] \u003c reach) S.sVis = max(S.sVis, info[t * 6 + 3]);\n    S.sizeFor = S.size;\n  }\n  S.c += g;\n  S.turn += g * 0.05 * S.dir;\n  if (S.c >= CYCLE) {\n    // A new cycle: the colours move on a step and the turn reverses.\n    S.c -= CYCLE;\n    S.dir = -S.dir;\n    S.hue0 += 0.08 + 0.1 * Math.random();\n    S.turn = (Math.random() \u003c 0.5 ? 0 : PI) + 0.4 * (Math.random() - 0.5);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const { id, shade, P, xs, rgb } = S;\n  const { n, V, info } = S.T, k = S.k, c = S.c;\n  const intro = k === 1 ? INTRO : 0.8;\n  // The view: close on the middle with X standing up, backing out to the\n  // tile size of the knob while the tiling grows.\n  const z = ease((c - intro + 0.4) / (GROW * 0.75));\n  const L = S.size + (L_INTRO + (L_INTRO_K - 1) * S.size) * (1 - z) * (1 - z);\n  const th = PI / 2 + S.turn, ct = cos(th), st = sin(th);\n  // The growth front and the unwinding front run along the arms in s.\n  const front = c \u003c intro ? -1 : 0.2 + ((c - intro) * (S.sVis + 0.4)) / GROW;\n  const back = c \u003c HOLD_END ? -1 : ((c - HOLD_END) * (S.sVis + 0.7)) / (UNWIND - 0.4);\n  const T = S.T;\n  // The opening on the 2-arm spiral: X, then A and B round it, then A' and\n  // B pale too, before the rest grows.\n  const lightX = k === 1 ? ease(c / 0.5) : 0;\n  const lightAB = k === 1 ? ease((c - 0.5) / 0.5) : 0;\n  const lightA2 = k === 1 ? ease((c - 1.25) / 0.5) : 0;\n  const paleX = k === 1 ? 1 - ease((c - 1.95) / 0.45) : 0;\n  const paleB = k === 1 ? ease((c - 1.25) / 0.35) * paleX : 0;\n  const alphaOf = (t) => {\n    const s = info[t * 6 + 3];\n    let a = cl((front - s) / 0.25, 0, 1);\n    if (k === 1) {\n      if (t === T.X) a = max(a, lightX);\n      else if (t === T.A || t === T.B) a = max(a, lightAB);\n      else if (t === T.A2) a = max(a, lightA2);\n    }\n    if (back >= 0) a *= cl((s - back) / 0.6, 0, 1);\n    return a;\n  };\n  id.fill(-1);\n  const cx = 32, cy = 64;\n  for (let t = 0; t \u003c n; t++) {\n    const o = t * 6;\n    const mx = info[o], my = info[o + 1];\n    const px = cx + L * (ct * mx - st * my), py = cy - L * (st * mx + ct * my), pr = L * info[o + 2] + 1;\n    if (px + pr \u003c 0 || px - pr > W || py + pr \u003c 0 || py - pr > H) continue;\n    // Scanline fill of the nonagon: an LED belongs to the tile its centre\n    // falls in. The shade runs from the point (0) to the far end (1).\n    const vo = t * 18;\n    let ymin = 1e9, ymax = -1e9;\n    for (let q = 0; q \u003c 9; q++) {\n      const x = V[vo + q * 2], y = V[vo + q * 2 + 1];\n      P[q * 2] = cx + L * (ct * x - st * y);\n      P[q * 2 + 1] = cy - L * (st * x + ct * y);\n      if (P[q * 2 + 1] \u003c ymin) ymin = P[q * 2 + 1];\n      if (P[q * 2 + 1] > ymax) ymax = P[q * 2 + 1];\n    }\n    const zx = P[0], zy = P[1], ex = P[8] - zx, ey = P[9] - zy, e2 = ex * ex + ey * ey;\n    const y0 = max(0, ceil(ymin - 0.5)), y1 = min(H - 1, floor(ymax - 0.5));\n    for (let y = y0; y \u003c= y1; y++) {\n      const yc = y + 0.5;\n      let m = 0;\n      for (let q = 0; q \u003c 9; q++) {\n        const q2 = q === 8 ? 0 : q + 1;\n        const ax = P[q * 2], ay = P[q * 2 + 1], bx = P[q2 * 2], by = P[q2 * 2 + 1];\n        if ((ay \u003c= yc && yc \u003c by) || (by \u003c= yc && yc \u003c ay)) xs[m++] = ax + ((yc - ay) * (bx - ax)) / (by - ay);\n      }\n      for (let i = 1; i \u003c m; i++) {\n        const v = xs[i];\n        let j = i - 1;\n        while (j >= 0 && xs[j] > v) (xs[j + 1] = xs[j]), j--;\n        xs[j + 1] = v;\n      }\n      for (let i = 0; i + 1 \u003c m; i += 2) {\n        const xa = max(0, ceil(xs[i] - 0.5)), xb = min(W - 1, floor(xs[i + 1] - 0.5));\n        for (let x = xa; x \u003c= xb; x++) {\n          id[y * W + x] = t;\n          shade[y * W + x] = cl(((x + 0.5 - zx) * ex + (yc - zy) * ey) / e2, 0, 1);\n        }\n      }\n    }\n  }\n  // Grout is darker on big tiles, lighter on small ones, so a small tiling\n  // does not go grey.\n  const grout = 0.18 + 0.22 * cl((30 - L) / 14, 0, 1);\n  const wave = c > intro ? 1 : 0;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const t = id[p];\n      if (t \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const o = t * 6, s = info[o + 3], arm = info[o + 4], kind = info[o + 5];\n      const a = alphaOf(t);\n      // Colour runs along each arm with s, and creeps outward with time.\n      const run = (0.045 * s) / k - 0.008 * c;\n      let hue = S.hue + S.hue0 + 0.47 + run + (arm ? 0.36 : 0);\n      let sat = 0.78, val = (kind === 2 ? 0.8 : 1) * (0.72 + 0.28 * shade[p]);\n      val *= 1 - 0.18 * wave * (0.5 + 0.5 * cos(2 * PI * (s / (2 * k) - 0.11 * c)));\n      // The tiles of the opening: pale X (and B), A and B bright.\n      if (k === 1 && paleX > 0) {\n        if (t === T.X || (t === T.B && paleB > 0)) sat *= 1 - 0.85 * (t === T.X ? paleX : paleB);\n      }\n      // A new tile flashes pale as it lands.\n      const fresh = front > 0 && a > 0 ? cl(1 - (front - s) / 0.5, 0, 1) : 0;\n      sat *= 1 - 0.6 * fresh;\n      hsv(hue, sat, val, rgb);\n      const seam = (x \u003c W - 1 && id[p + 1] !== t) || (y \u003c H - 1 && id[p + W] !== t) || (x > 0 && id[p - 1] \u003c 0) || (y > 0 && id[p - W] \u003c 0);\n      const kk = (GHOST + (1 - GHOST) * a) * (seam ? grout : 1) * 255;\n      display.setPixel(x, y, (rgb[0] * kk) | 0, (rgb[1] * kk) | 0, (rgb[2] * kk) | 0);\n    }\n}\n","wigner-cat":"// ===== Patternflow pattern =====\n// Title:   Wigner Cat\n// Family:  wave\n// Idea:    The Wigner function of light in a Kerr medium glows on a slowly turning phase plane, warm where it is positive and cool where it is negative, as one coherent lump splits at the fractional revivals into Schrodinger cats of 2, 3 and 4 lumps round a circle with bands of interference fringes between every pair, shears through a rosette into one lump on the far side at half the revival time and comes back down the sequence.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Wigner quasi-probability function (Eugene Wigner, 1932), the two-lump cat of a Kerr medium (Bernard Yurke and David Stoler, 1986), its cats of n lumps at the fractional revivals (K. Tara, G. S. Agarwal and S. Chaturvedi, 1993), Husimi's Q function as a smoothed Wigner function (Kodi Husimi, 1940), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Decoherence=0..1, Amplitude=2..3.2\n//\n// Knob 1: Hue. Turns both signs round the wheel together. At 0 the positive lumps and fringes are rose with pale peaks and the negative fringes azure; at 0.25 lime and violet, at 0.5 aqua and orange, at 0.75 violet and green.\n// Knob 2: Speed. At 2 the phase plane turns once in 24 seconds, and the Kerr clock holds each cat 3.2 seconds, each single lump 1.6, and takes 1.3 to move on, so the cycle 1, 2, 3, 4, far lump, 4, 3, 2 takes 33 seconds and starts each time at a new angle; at 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Decoherence. Random Gaussian kicks to the field, of variance s2 = 0.5 x knob^2 in x and in p, which smooths W with a Gaussian of that variance. At 0 the state is pure and the 2-lump cat's fringes swing to 1.9 times the lump height either side of zero; at 0.25 they keep 61% of that and the lumps 94% of theirs, at 0.5 the fringes keep 14% and the lumps 80%. At 1 the variance is the vacuum's own, W has become Husimi's Q function and is nowhere negative: lumps alone, twice as wide.\n// Knob 4: Amplitude. |alpha| of the starting coherent state, 2 to 3.2, a mean of 4 to 10 photons. The plane is scaled to keep the circle on the panel: at 2 a lump is 14 LEDs wide and 28 tall to 1/e, the 2-lump cat's fringes 8 columns or 16 rows apart, and the cats run to 4 lumps; at 3.2 a lump is 10 wide, the fringes 3.5 columns apart, and the cats run to 7 lumps before the far lump.\n\nconst W = 64, H = 128, NF = 36;\n// Rows per column for one unit of p against one of x: the phase plane is\n// drawn twice as tall as wide, an oscillator whose orbits are 1:2 ellipses.\nconst STRETCH = 2;\n// At Speed 2: one turn of the plane, the hold at a stop and the move between stops, in seconds.\nconst TURN = 24, HOLD = 3.2, MOVE = 1.3;\nconst LMAX = 168, GAMMA = 1.35, TOP = 0.72, HUE_POS = 0.985, HUE_NEG = 0.57;\nconst { floor, ceil, min, max, abs, sqrt, exp, cos, sin, asin, PI, SQRT2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Units: x = (a + a^dagger)/sqrt2, p = (a - a^dagger)/(i sqrt2), hbar = 1,\n// so the coherent state |alpha> sits at x = sqrt2 Re alpha, p = sqrt2 Im\n// alpha and its Wigner function is exp(-(x - x0)^2 - (p - p0)^2) / pi.\n//\n// The grid, rebuilt when the amplitude changes: column i is x_i = (i -\n// 31.5) h, row r is p_r = (63.5 - r) h / STRETCH. The Wigner transform\n//   W(x, p) = (1/pi) Int psi*(x + y) psi(x - y) e^(2ipy) dy\n// is summed over y_j = j h, which puts x +- y on the same grid of columns,\n// extended J columns each side. A sum with step h repeats W every pi / h\n// in p, 16 or more, where W has long died away, so it is exact.\nfunction build(S, a) {\n  S.a = a;\n  const X0 = SQRT2 * a, kx = 31 / (X0 + 1.55), h = 1 / kx;\n  // psi ~ exp(-(x - x0)^2 / 2) has fallen to 3e-4 four units out.\n  const J = ceil((X0 + 4) * kx), G = W + 2 * J;\n  S.kx = kx;\n  S.h = h;\n  S.J = J;\n  S.G = G;\n  // Hermite functions phi_k(x) by their three-term recurrence.\n  const phi = (S.phi = new Float64Array(NF * G));\n  for (let m = 0; m \u003c G; m++) {\n    const x = (m - J - 31.5) * h;\n    let p0 = PI ** -0.25 * exp((-x * x) / 2), p1 = SQRT2 * x * p0;\n    phi[m] = p0;\n    phi[G + m] = p1;\n    for (let k = 1; k + 1 \u003c NF; k++) {\n      const p2 = sqrt(2 / (k + 1)) * x * p1 - sqrt(k / (k + 1)) * p0;\n      phi[(k + 1) * G + m] = p2;\n      p0 = p1;\n      p1 = p2;\n    }\n  }\n  // |\u003ck|alpha>| = e^(-|alpha|^2/2) alpha^k / sqrt(k!).\n  const amp = (S.amp = new Float64Array(NF));\n  amp[0] = exp((-a * a) / 2);\n  for (let k = 1; k \u003c NF; k++) amp[k] = (amp[k - 1] * a) / sqrt(k);\n  // cos and sin of 2 p_r y_j.\n  const J1 = J + 1;\n  S.C = new Float32Array(H * J1);\n  S.Sn = new Float32Array(H * J1);\n  for (let r = 0; r \u003c H; r++) {\n    const p = ((63.5 - r) * h) / STRETCH;\n    for (let j = 0; j \u003c J1; j++) {\n      const t = 2 * p * j * h;\n      S.C[r * J1 + j] = cos(t);\n      S.Sn[r * J1 + j] = sin(t);\n    }\n  }\n  S.pr = new Float64Array(G);\n  S.pi = new Float64Array(G);\n  S.gr = new Float64Array(J1);\n  S.gi = new Float64Array(J1);\n  S.damp = new Float64Array(J1);\n  S.s2 = -1;\n  // How many cats before the far lump: lumps 2 alpha sin(pi/n) apart, at\n  // least five of their own standard deviations (1/2 in units of alpha).\n  // Closer than that the fringes of neighbours run over the lumps and the\n  // cat reads as a rosette; those cats still pass on the way to u = 1/2.\n  S.N = cl(floor(PI / asin(min(1, 1.25 / a))), 3, 8);\n  S.k = min(S.k, 2 * S.N - 1);\n}\n\n// The Kerr clock. Under H = K n^2 the coherent state picks up the phase\n// e^(-i K t k^2) on |k>. At K t = 2 pi m / q that phase is periodic in k\n// with period q, so it is a finite Fourier sum and the state is a sum of\n// coherent states round the circle: Yurke and Stoler's cats. At u = K t /\n// 2 pi = (n - 1) / (2n) exactly n of the coefficients are non-zero, so the\n// stops u = 0, 1/4, 1/3, 3/8, 2/5 ... hold cats of 1, 2, 3, 4, 5 lumps;\n// they crowd towards u = 1/2, where e^(-i pi k^2) = (-1)^k is the single\n// lump at -alpha, and the mirror stops 1 - u bring them back to the full\n// revival at u = 1.\n//\n// For such a sum psi = sum_j b_j |alpha_j> the Wigner function has a closed\n// form, from W(beta) = (2/pi) \u003cpsi| D(beta) (-1)^n D(beta)^dagger |psi>:\n//   W(beta) = (2/pi) sum_jk b_j* b_k \u003calpha_j|alpha_k> e^(-2 (beta - alpha_j)* (beta - alpha_k)),\n// beta = (x + ip)/sqrt2, a Gaussian lump for j = k and a Gaussian times\n// fringes for j != k. The transform below works at every u, between the\n// cats too, and at the cats it agrees with this sum to 2e-7.\nfunction stopU(N, k) {\n  if (k \u003c= 0 || k >= 2 * N) return k \u003c= 0 ? 0 : 1;\n  if (k \u003c N) return k / (2 * (k + 1));\n  if (k === N) return 0.5;\n  const n = 2 * N - k + 1;\n  return 1 - (n - 1) / (2 * n);\n}\n\nexport function setup(params) {\n  params.s = {\n    a: -1, k: 1, ph: HOLD - 1.2, th: 0.6, u: 0.25, wref: 0,\n    Wg: new Float32Array(W * H), tmp: new Float32Array(W), cr: new Float64Array(NF), ci: new Float64Array(NF),\n    pos: [0, 0, 0], neg: [0, 0, 0], hue: -1,\n  };\n}\n\n// The Fock coefficients at Kerr time u, turned by th: the free oscillator\n// adds e^(-i th k), which turns the whole plane clockwise.\nfunction kerr(S, u, th) {\n  const { amp, cr, ci } = S;\n  for (let k = 0; k \u003c NF; k++) {\n    const q = u * k * k, ph = -2 * PI * (q - floor(q)) - th * k;\n    cr[k] = amp[k] * cos(ph);\n    ci[k] = amp[k] * sin(ph);\n  }\n}\n\n// W on the grid for the state with Fock coefficients S.cr, S.ci; s2 is the\n// variance of the Gaussian that smooths it. Smoothing in p is the factor\n// exp(-2 s2 y^2) under the y integral; smoothing in x is a blur along each\n// row.\nfunction wigner(S, s2) {\n  const { G, J, h, phi, cr, ci, pr, pi, gr, gi, C, Sn, damp, Wg } = S, J1 = J + 1;\n  pr.fill(0);\n  pi.fill(0);\n  for (let k = 0; k \u003c NF; k++) {\n    const o = k * G, a = cr[k], b = ci[k];\n    if (abs(a) + abs(b) \u003c 1e-12) continue;\n    for (let m = 0; m \u003c G; m++) {\n      const f = phi[o + m];\n      pr[m] += a * f;\n      pi[m] += b * f;\n    }\n  }\n  if (s2 !== S.s2) {\n    S.s2 = s2;\n    for (let j = 0; j \u003c J1; j++) damp[j] = (j ? 2 : 1) * exp(-2 * s2 * (j * h) ** 2) * (h / PI);\n    const sg = sqrt(s2) * S.kx, R = ceil(3 * sg);\n    S.ker = new Float64Array(R + 1);\n    for (let d = 0; d \u003c= R; d++) S.ker[d] = exp((-d * d) / (2 * sg * sg));\n  }\n  for (let i = 0; i \u003c W; i++) {\n    const c = i + J;\n    let jm = 0;\n    for (let j = 0; j \u003c J1; j++) {\n      // psi*(x + y) psi(x - y), weighted for the one-sided sum.\n      const ar = pr[c + j], ai = pi[c + j], br = pr[c - j], bi = pi[c - j], d = damp[j];\n      gr[j] = (ar * br + ai * bi) * d;\n      gi[j] = (ar * bi - ai * br) * d;\n      if (abs(gr[j]) + abs(gi[j]) > 1e-7) jm = j + 1;\n    }\n    for (let r = 0, o = 0; r \u003c H; r++, o += J1) {\n      let w = 0;\n      for (let j = 0; j \u003c jm; j++) w += gr[j] * C[o + j] - gi[j] * Sn[o + j];\n      Wg[r * W + i] = w;\n    }\n  }\n  if (s2 > 0) {\n    const ker = S.ker, R = ker.length - 1, tmp = S.tmp;\n    for (let r = 0; r \u003c H; r++) {\n      const o = r * W;\n      for (let x = 0; x \u003c W; x++) {\n        let s = 0, n = 0;\n        for (let d = -R; d \u003c= R; d++) {\n          const xx = x + d;\n          if (xx \u003c 0 || xx >= W) continue;\n          const k = ker[d \u003c 0 ? -d : d];\n          s += k * Wg[o + xx];\n          n += k;\n        }\n        tmp[x] = s / n;\n      }\n      Wg.set(tmp, o);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), dec = cl(kv[2], 0, 1), a = cl(kv[3], 2, 3.2);\n  if (abs(a - S.a) > 1e-4) build(S, a);\n  const g = (d * speed) / 2;\n  S.th += (g * 2 * PI) / TURN;\n  S.ph += g;\n  // A single lump, at the start or at u = 1/2, is held half as long as a cat.\n  let hold = S.k % S.N ? HOLD : HOLD / 2;\n  if (S.ph >= hold + MOVE) {\n    S.ph -= hold + MOVE;\n    S.k = (S.k + 1) % (2 * S.N);\n    hold = S.k % S.N ? HOLD : HOLD / 2;\n  }\n  const u0 = stopU(S.N, S.k), u1 = stopU(S.N, S.k + 1);\n  let e = cl((S.ph - hold) / MOVE, 0, 1);\n  e = e * e * e * (e * (e * 6 - 15) + 10);\n  S.u = u0 + (u1 - u0) * e;\n  kerr(S, S.u, S.th);\n  wigner(S, 0.5 * dec * dec);\n  // The brightest |W| of the frame sets the scale, followed in about a\n  // third of a second: a cat of n lumps has lumps 1/n as high as the\n  // coherent state's, and this keeps the cat of 4 as bright as the cat of 2.\n  let m = 0;\n  for (let p = 0; p \u003c W * H; p++) m = max(m, abs(S.Wg[p]));\n  S.wref = S.wref > 0 ? S.wref + (m - S.wref) * min(1, 3 * d) : m;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.Wg || !S.wref) return;\n  const pos = hsv(HUE_POS + S.hue, 0.72, 1, S.pos), neg = hsv(HUE_NEG + S.hue, 0.85, 1, S.neg);\n  const Wg = S.Wg, k = 1 / (TOP * S.wref);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const w = Wg[p] * k, v = min(1, w \u003c 0 ? -w : w), c = w \u003c 0 ? neg : pos;\n      // The peaks go pale, so a lump reads as a glow rather than a disc.\n      const L = LMAX * v ** GAMMA, wh = 0.4 * v * v * v;\n      display.setPixel(x, y, (L * (c[0] + (1 - c[0]) * wh)) | 0, (L * (c[1] + (1 - c[1]) * wh)) | 0, (L * (c[2] + (1 - c[2]) * wh)) | 0);\n    }\n}\n","beckett-gray":"// ===== Patternflow pattern =====\n// Title:   Beckett-Gray\n// Family:  rhythm\n// Idea:    Six performers are six lanes of a score that scrolls down two rows a beat, so the whole 64-beat cycle of a Beckett-Gray code stands on the panel at once, each lane lit while its performer is on stage, dim when it has just come on and a step brighter each time one before it leaves, until it turns white at the head of the queue and is the next to go, with one lane flashing at the now line on every beat, while the reflected Gray code on a knob sends a performer off out of turn at 26 of its 32 exits, each one marked red.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Beckett-Gray codes (Donald Knuth, 2005), after Samuel Beckett's Quad (1981), with the reflected binary Gray code (Frank Gray, 1953), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Code=0..3, Rows=2..8\n//\n// Knob 1: Hue. Turns the six lane colours round the wheel together. At 0 the lanes run cyan, azure, blue, violet, magenta and pink from left to right; at 0.5 magenta, lime, green, aqua, cyan and azure. The lanes' wheel skips orange and yellow, which read brown in the dim cells at the back of the queue, and red, which marks an exit out of turn. The head of the queue is always near white.\n// Knob 2: Speed. Beats a second: 2 at the opening, so the score moves 4 rows a second and the 64-beat cycle goes round in 32 s; 0.2 is a beat every 5 s, 3 a cycle in 21 s.\n// Knob 3: Code. 0 is a 6-bit Beckett-Gray code: 64 states, one bit a beat, and every one of its 32 exits is the performer on stage longest. 1 is a 5-bit one, 32 beats, so the panel shows two cycles. 2 is four performers, as in Beckett's own Quad: no Beckett-Gray code exists for 4 bits (nor for 3), and this 16-beat cycle is one of the 96 of the 2688 directed cycles through the empty stage that break the rule only once, at the 14th switch, so the panel shows that one red exit four times. 3 is the reflected Gray code on 6 bits, in which 26 of the 32 exits are out of turn: the first lane leaves out of turn at 15 of its 16 exits, the second at 7 of 8, the third at 3 of 4 and the fourth at 1 of 2.\n// Knob 4: Rows. Rows a beat on the panel: 2 at the opening, the whole 64-beat cycle in 128 rows; 4 shows 32 beats, 8 shows 16, each as an 8-row block.\n\nconst W = 64, H = 128;\nconst { floor, exp, max, min, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The now line: rows above it are the beats to come, rows below the beats\n// just gone, and both scroll down through it.\nconst NOW = 96;\n\n// The codes as the bit each beat switches, the last switch closing the\n// cycle back to the empty stage. The two Beckett-Gray codes were found by a\n// depth-first search that lets a performer leave only from the front of the\n// queue; the same search over every 3- and 4-bit cycle finds none. The 4-bit\n// cycle was the first of the fewest-violation ones in a search over all\n// 2688 directed Hamiltonian cycles of the 4-cube through 0.\nconst CODES = [\n  { n: 6, t: \"0102101320102430232415323141502354310402535240415350241314505145\" },\n  { n: 5, t: \"01020132010432104342132340412304\" },\n  { n: 4, t: \"0102131202313203\" },\n  // Frank Gray's reflected code: switch k switches the lowest bit set in\n  // k + 1, and the last one the top bit, back to the empty stage.\n  { n: 6, t: null },\n];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown, and red is kept for the exits out of\n// turn, so the lanes' wheel runs from lime to pink and skips the rest.\nconst wheel = (h) => 0.25 + 0.69 * (h - floor(h));\n\n// Play a code from the empty stage. For every beat: the state, the lane that\n// switched as the beat began and how (1 enters, 2 leaves from the front of\n// the queue, 3 leaves out of turn), and each lane's place in the queue, 0 for\n// the one on stage longest, -1 for off stage. The checks a code must pass are\n// counted on the way and kept with it: each state once, one bit a switch,\n// back to the empty stage after the last switch, and the exits out of turn,\n// none for the two Beckett-Gray codes.\nfunction play(code) {\n  const n = code.n, L = 1 \u003c\u003c n;\n  const t = new Int8Array(L);\n  for (let k = 0; k \u003c L; k++) t[k] = code.t ? code.t.charCodeAt(k) - 48 : k \u003c L - 1 ? 31 - Math.clz32((k + 1) & -(k + 1)) : n - 1;\n  const state = new Int32Array(L), ev = new Int8Array(L), kind = new Int8Array(L), rank = new Int8Array(L * n).fill(-1);\n  const seen = new Uint8Array(L);\n  let s = 0, repeats = 0, multi = 0, out = 0;\n  const queue = [];\n  for (let k = 0; k \u003c= L; k++) {\n    if (k > 0) {\n      const b = t[k - 1];\n      s ^= 1 \u003c\u003c b;\n      const kk = k % L;\n      ev[kk] = b;\n      if (s >> b & 1) (queue.push(b), (kind[kk] = 1));\n      else {\n        const at = queue.indexOf(b);\n        kind[kk] = at === 0 ? 2 : 3;\n        if (at !== 0) out++;\n        queue.splice(at, 1);\n      }\n    }\n    if (k === L) break;\n    state[k] = s;\n    if (seen[s]++) repeats++;\n    for (let r = 0; r \u003c queue.length; r++) rank[k * n + queue[r]] = r;\n  }\n  for (let k = 0; k \u003c L; k++) {\n    const x = state[k] ^ state[(k + 1) % L];\n    if (!x || x & (x - 1)) multi++;\n  }\n  return { n, L, state, ev, kind, rank, out, ok: repeats === 0 && multi === 0 && s === 0 };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, code: -1, rows: 2, beat: 0, speed: 2,\n    codes: CODES.map(play),\n    col: new Float32Array(64 * 6 * 3), red: new Uint8Array(64 * 6), img: new Float32Array(W * H * 3),\n  };\n}\n\n// Lane colours, one a performer, and the colour of a cell by its place in\n// the queue: the newest on stage dimmest and most saturated, a step brighter\n// each place it moves up, near white at the head.\nfunction laneColour(S, C, k, i, out, o) {\n  const r = C.rank[k * C.n + i];\n  if (r \u003c 0) return (out[o] = out[o + 1] = out[o + 2] = 0);\n  const h = wheel(0.38 + 0.12 * i * (6 / C.n) + S.hue);\n  if (r === 0) {\n    hsv(h, 0.22, 1, out, o);\n    return;\n  }\n  hsv(h, min(1, 0.62 + 0.07 * r), max(0.4, 0.92 - 0.12 * (r - 1)), out, o);\n}\n\nfunction colours(S) {\n  const C = S.codes[S.code];\n  for (let k = 0; k \u003c C.L; k++)\n    for (let i = 0; i \u003c C.n; i++) {\n      laneColour(S, C, k, i, S.col, (k * C.n + i) * 3);\n      // The last beat on stage of a performer who leaves out of turn is red.\n      const nx = (k + 1) % C.L;\n      S.red[k * C.n + i] = C.ev[nx] === i && C.kind[nx] === 3 ? 1 : 0;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  const hue = cl(kv[0], 0, 1), code = cl(floor(cl(kv[2], 0, 3) + 0.5), 0, 3);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.rows = cl(kv[3], 2, 8);\n  if (hue !== S.hue || code !== S.code) {\n    S.hue = hue;\n    S.code = code;\n    colours(S);\n  }\n  S.beat += d * S.speed;\n  if (S.beat > 1e6) S.beat -= 64 * 4096;\n}\n\n// Lane i spans [x0, x0 + w).\nfunction lanes(n) {\n  const p = floor(60 / n), w = p - 2, m = (W - n * p) / 2 + 1;\n  return { p, w, m };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.code \u003c 0) return;\n  const C = S.codes[S.code], n = C.n, L = C.L, R = S.rows, b = S.beat, img = S.img;\n  const { p, w, m } = lanes(n);\n  img.fill(0);\n  const mod = (k) => ((k % L) + L) % L;\n  for (let y = 0; y \u003c H; y++) {\n    // Row y covers the beats from lo to hi; a row across a switch mixes the\n    // two beats by how much of the row each takes, so the score slides\n    // smoothly instead of jumping a row at a time.\n    const hi = b + (NOW - y) / R, lo = hi - 1 / R;\n    const k1 = floor(hi), k0 = floor(lo), f = k1 > k0 ? (hi - k1) * R : 1;\n    const a0 = mod(k0), a1 = mod(k1);\n    // The beats gone are dimmer, and the two rows at the now line show the\n    // stage as it stands: performers on it brighter, empty places grey.\n    const past = y >= NOW ? 0.55 : 1, line = y === NOW - 1 || y === NOW;\n    let redRow = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const o0 = (a0 * n + i) * 3, o1 = (a1 * n + i) * 3;\n      let cr = S.col[o1] * f + S.col[o0] * (1 - f), cg = S.col[o1 + 1] * f + S.col[o0 + 1] * (1 - f), cb = S.col[o1 + 2] * f + S.col[o0 + 2] * (1 - f);\n      const red = S.red[a1 * n + i] * f + S.red[a0 * n + i] * (1 - f);\n      if (red > 0) (cr += (1 - cr) * red), (cg -= (cg - 0.12) * red), (cb -= (cb - 0.08) * red);\n      redRow = max(redRow, red);\n      if (line) {\n        if (cr + cg + cb > 0.05) (cr = cr * 0.75 + 0.25), (cg = cg * 0.75 + 0.25), (cb = cb * 0.75 + 0.25);\n        else cr = cg = cb = 0.16;\n      }\n      const x0 = m + i * p;\n      for (let x = x0; x \u003c x0 + w; x++) {\n        const q = (y * W + x) * 3;\n        img[q] = cr * past;\n        img[q + 1] = cg * past;\n        img[q + 2] = cb * past;\n      }\n    }\n    // Exits out of turn are marked in both margins as well.\n    if (redRow > 0) for (const x of [0, 1, W - 2, W - 1]) (img[(y * W + x) * 3] = redRow * past), (img[(y * W + x) * 3 + 1] = 0.1 * redRow * past);\n  }\n  // The pulse: the lane that switched as this beat began flashes at the now\n  // line, white for an entry, its own colour for an exit from the front of\n  // the queue, red for an exit out of turn, and the flash runs out along the\n  // now line to both edges.\n  const kn = mod(floor(b + 1e-9)), ph = b + 1e-9 - floor(b + 1e-9), A = exp(-ph * 2.6);\n  const i = C.ev[kn], kd = C.kind[kn], x0 = m + i * p, xc = x0 + (w - 1) / 2;\n  const pc = [1, 1, 1];\n  if (kd === 2) hsv(wheel(0.38 + 0.12 * i * (6 / n) + S.hue), 0.55, 1, pc, 0);\n  else if (kd === 3) (pc[1] = 0.15), (pc[2] = 0.08);\n  for (let y = NOW - 14; y \u003c NOW + 12; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = max(0, abs(x - xc) - w / 2), dy = y \u003c NOW ? NOW - 1 - y : y - NOW;\n      const g = A * (dx > 0 ? exp(-dx * dx / 8 - dy * dy / 3) + (dy === 0 ? 0.7 * exp(-dx / 12) : 0) : exp(-dy * dy / 40));\n      if (g \u003c 0.01) continue;\n      const q = (y * W + x) * 3;\n      for (let e = 0; e \u003c 3; e++) img[q + e] += (pc[e] - img[q + e]) * min(1, g);\n    }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, (255 * cl(img[q], 0, 1)) | 0, (255 * cl(img[q + 1], 0, 1)) | 0, (255 * cl(img[q + 2], 0, 1)) | 0);\n}\n","hanging-chain":"// ===== Patternflow pattern =====\n// Title:   Hanging Chain\n// Family:  physics\n// Idea:    A chain of 32 beads hangs from the middle of the top row and swings in one of its first five normal modes, the J0 Bessel shapes Daniel Bernoulli found for it, while a fading long exposure behind it fills in the swept envelope with its pinched nodes at the heights the zeros of J0 predict, marked by small ticks.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: small oscillations of a hanging chain (Daniel Bernoulli, 1732), the first appearance of the Bessel function J0, taken up by Leonhard Euler (1781), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mode=1..5, Mix=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the chain is cyan with near-white beads, the exposure behind it blue violet and the node ticks pale yellow; at 0.25 the chain is violet over a pink exposure, at 0.5 red over lime, at 0.75 yellow green over teal. The dim exposure skips the orange and yellow part of the wheel, which reads brown and olive.\n// Knob 2: Speed. At 2 the first mode swings once every 2.4 seconds, as a chain 2.1 m long would in real time, and the fifth once every 0.39 s; 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Mode. Which normal mode the chain is let go in, rounded to a whole number 1 to 5. Mode n has n - 1 nodes, at 19% of the way up from the free end for mode 2, at 8% and 41% for mode 3, and for mode 5 at 3%, 14%, 34% and 62%, and swings j(0,n) / j(0,1) times as often as the first: 2.296, 3.601, 4.910 and 6.222 times on these 32 beads, against 2.295, 3.599, 4.903 and 6.209 for the continuous chain.\n// Knob 4: Mix. How much of the other four modes is let go with the chosen one. At 0 the chain holds one mode and the exposure settles into its clean envelope; at the opening 0.06 each other mode comes in at a tenth of the chosen one's swing at the free end and the chain shivers as it swings; at 1 all five come in equally and, since their frequencies are not in whole ratios, the chain's shape never repeats.\n// Buttons: K1 tap lets the chain go again from its starting shape.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, round, abs, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The first five zeros of J0.\nconst J0Z = [2.404826, 5.520078, 8.653728, 11.791534, 14.930918];\n// Beads, and where the chain hangs on the panel. The suspension is row 0\n// and bead k hangs k links below it. With all the mass in the beads, the\n// link above bead k carries the weight of the N - k + 1 beads below it,\n// which is what a continuous chain carries at the middle of that link if\n// its free end sits half a link below the last bead. So the continuous\n// chain this one stands for is N + 1/2 links long, its free end at row 125.\nconst N = 32, YFREE = 125, LPX = YFREE / (N + 0.5);\nconst CX = 31.5, HALF = 29;\n// Chain time is measured in units of sqrt(l / g), one link's own time.\n// The first mode swings once every 29.8 units; RATE units a second at\n// Speed 1 make that 2.4 s at Speed 2.\nconst RATE = 6.2;\n// The leapfrog step, in chain units. The stiffest mode of 32 beads has\n// omega near 11.3, so the step must stay below 2 / 11.3 = 0.18; at 0.03\n// the energy stays within 3e-4 of where it started.\nconst HSTEP = 0.03;\n// The exposure fades by e every TAU chain units, about one swing of the\n// first mode.\nconst TAU = 30;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Tension in the link above bead k, in bead weights; zero below the last.\nconst T = (k) => (k \u003c= N ? N - k + 1 : 0);\n// Dim orange and yellow read brown and olive, so the exposure's wheel\n// skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\n// The linearised bead chain is x'' = -K x with K tridiagonal:\n//   (K x)_k = T_k (x_k - x_{k-1}) + T_{k+1} (x_k - x_{k+1}),  x_0 = 0.\n// A mode with K v = lambda v is found by running that row from the free\n// end upward with v_N = 1: the row for bead k gives v_{k-1}, and lambda is\n// an eigenvalue when the value it gives at the suspension, v_0, is zero.\n// This is Bernoulli's own way down the chain, link by link.\nfunction upward(lam, v) {\n  v[N] = 1;\n  v[N - 1] = ((T(N) - lam) * v[N]) / T(N);\n  for (let k = N - 1; k >= 1; k--) v[k - 1] = ((T(k) + T(k + 1) - lam) * v[k] - T(k + 1) * v[k + 1]) / T(k);\n  return v[0];\n}\nfunction modes() {\n  const out = [], v = new Float64Array(N + 1);\n  let lam = 1e-4, f = upward(lam, v);\n  while (out.length \u003c 5) {\n    const next = lam + 0.002, g = upward(next, v);\n    if (f * g \u003c 0) {\n      let lo = lam, hi = next;\n      for (let i = 0; i \u003c 50; i++) {\n        const m = (lo + hi) / 2;\n        if (upward(m, v) * upward(lo, v) \u003c= 0) hi = m;\n        else lo = m;\n      }\n      upward((lo + hi) / 2, v);\n      v[0] = 0;\n      out.push({ lam: (lo + hi) / 2, v: Float64Array.from(v) });\n    }\n    (lam = next), (f = g);\n  }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    modes: modes(),\n    x: new Float64Array(N + 2), p: new Float64Array(N + 2), a: new Float64Array(N + 2),\n    row: new Float32Array(H), prev: new Float32Array(H),\n    E: new Float32Array(W * H), scale: HALF,\n    hue: 0, speed: 2, mode: 1, mix: 0.06, key: \"\", warm: false, t: 0,\n    col: new Float32Array(15),\n  };\n}\n\nfunction accel(S) {\n  const { x, a } = S;\n  for (let k = 1; k \u003c= N; k++) a[k] = -T(k) * (x[k] - x[k - 1]) + T(k + 1) * (x[k + 1] - x[k]);\n}\n\n// Let go from rest in the chosen mode plus Mix of each other one. Every\n// mode is 1 at the free end and no more than 1 anywhere, so at the moment\n// of release the free end is out by the sum of the weights, which is put\n// at HALF LEDs from the plumb line.\nfunction release(S) {\n  const { x, p } = S, w = S.modes.map((_, i) => (i === S.mode - 1 ? 1 : 0.25 * sqrt(S.mix) + 0.75 * S.mix));\n  const sum = w.reduce((u, v) => u + v, 0);\n  S.scale = HALF / sum;\n  x.fill(0);\n  p.fill(0);\n  S.modes.forEach((m, i) => {\n    for (let k = 1; k \u003c= N; k++) x[k] += w[i] * m.v[k];\n  });\n  accel(S);\n  S.t = 0;\n  rows(S, S.prev);\n}\n\n// Where the chain crosses each row, in LEDs from the plumb line: straight\n// links between the beads, so the chain is a function of height.\nfunction rows(S, out) {\n  const { x } = S;\n  for (let y = 0; y \u003c H; y++) {\n    const u = min(y / LPX, N), k = min(floor(u), N - 1), f = u - k;\n    out[y] = S.scale * (x[k] * (1 - f) + x[k + 1] * f);\n  }\n}\n\n// Velocity Verlet, the leapfrog: symplectic, so the energy wobbles at the\n// size of the step squared and does not drift. After each step the chain's\n// crossing of each row moved from prev to row, and the exposure gets the\n// time the chain spent over each LED it passed: the step over the LEDs\n// crossed, so the turning points, where the chain lingers, burn brightest.\nfunction step(S, span) {\n  const n = max(1, ceil(span / HSTEP)), h = span / n, { x, p, a, row, prev, E } = S;\n  const fade = exp(-span / TAU);\n  for (let i = 0; i \u003c E.length; i++) E[i] *= fade;\n  for (let s = 0; s \u003c n; s++) {\n    for (let k = 1; k \u003c= N; k++) p[k] += 0.5 * h * a[k];\n    for (let k = 1; k \u003c= N; k++) x[k] += h * p[k];\n    accel(S);\n    for (let k = 1; k \u003c= N; k++) p[k] += 0.5 * h * a[k];\n    rows(S, row);\n    const top = min(H - 1, floor(N * LPX));\n    for (let y = 0; y \u003c= top; y++) {\n      const a0 = CX + min(prev[y], row[y]), a1 = CX + max(prev[y], row[y]);\n      const i0 = cl(floor(a0), 0, W - 1), i1 = cl(floor(a1), 0, W - 1), wgt = h / (i1 - i0 + 1);\n      for (let i = i0; i \u003c= i1; i++) E[y * W + i] += wgt;\n      prev[y] = row[y];\n    }\n  }\n  S.t += span;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.mode = cl(round(k[2]), 1, 5);\n  S.mix = cl(k[3], 0, 1);\n  // A new mode or mix lets the chain go again; the old exposure fades out.\n  const key = S.mode + \":\" + S.mix.toFixed(3);\n  if (key !== S.key || (input.btnPressed && input.btnPressed[0])) {\n    S.key = key;\n    release(S);\n  }\n  if (!S.warm) {\n    // Open on a chain that has been swinging for a second and a half.\n    for (let i = 0; i \u003c 45; i++) step(S, (2 * RATE) / 30);\n    S.warm = true;\n  }\n  step(S, d * S.speed * RATE);\n}\n\nfunction put(display, x, y, c, o, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  display.setPixel(x, y, round(c[o] * v), round(c[o + 1] * v), round(c[o + 2] * v));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.col, h = S.hue;\n  hsv(wheel(h + 0.78), 0.75, 1, c, 0); // exposure\n  hsv(h + 0.52, 0.85, 1, c, 3); // links\n  hsv(h + 0.52, 0.25, 1, c, 6); // beads\n  hsv(h + 0.15, 0.45, 1, c, 9); // node ticks\n  hsv(h + 0.6, 0.3, 1, c, 12); // plumb line and suspension\n  const { E, row, x } = S, bead = N * LPX;\n  // The rest position, a dotted plumb line, and the ticks where mode n's\n  // nodes fall on the continuous chain: J0(j_n sqrt(s / L)) = 0 at\n  // s / L = (j_m / j_n)^2 for each zero j_m below j_n.\n  const tick = new Uint8Array(H), n = S.mode;\n  for (let m = 0; m \u003c n - 1; m++) tick[round(YFREE * (1 - (J0Z[m] / J0Z[n - 1]) ** 2))] = 1;\n  for (let y = 0; y \u003c H; y++)\n    for (let xx = 0; xx \u003c W; xx++) {\n      // The exposure, toned so a wide swing still reads and a narrow one\n      // does not burn out.\n      const e = E[y * W + xx], b = e > 0 ? 1 - exp(-e / 1.1) : 0;\n      let v = 150 * b, o = 0;\n      if (xx === 31 && (y & 1) === 0 && y \u003c= bead + 1 && v \u003c 46) (v = 46), (o = 12);\n      if (tick[y] && abs(xx - CX) > 2 && abs(xx - CX) \u003c 6) (v = max(v, 150)), (o = 9);\n      if (tick[y] && (xx \u003c 3 || xx > W - 4)) (v = 150), (o = 9);\n      if (y === 0 && abs(xx - CX) \u003c 5) (v = 200), (o = 12);\n      put(display, xx, y, c, o, v);\n    }\n  // The links, a line one LED wide down the chain's crossing of each row,\n  // stretched across the row where the chain leans.\n  const top = min(H - 1, floor(bead));\n  for (let y = 0; y \u003c= top; y++) {\n    const up = y > 0 ? (row[y - 1] + row[y]) / 2 : row[0], dn = y \u003c top ? (row[y] + row[y + 1]) / 2 : row[y];\n    const lo = CX + min(up, dn) - 0.5, hi = CX + max(up, dn) + 0.5;\n    for (let i = floor(lo); i \u003c= floor(hi); i++) {\n      const cover = min(hi, i + 1) - max(lo, i);\n      if (cover > 0.05) put(display, i, y, c, 3, 80 + 140 * min(1, cover));\n    }\n  }\n  // The beads, small round dots brighter than the links.\n  for (let k = 1; k \u003c= N; k++) {\n    const bx = CX + S.scale * x[k], by = k * LPX;\n    for (let yy = floor(by) - 1; yy \u003c= floor(by) + 2; yy++)\n      for (let xx = floor(bx) - 1; xx \u003c= floor(bx) + 2; xx++) {\n        const dx = xx + 0.5 - bx, dy = yy + 0.5 - by, w = cl(1.9 - sqrt(dx * dx + dy * dy), 0, 1);\n        if (w > 0.1) put(display, xx, yy, c, 6, 120 + 135 * w);\n      }\n  }\n}\n","hard-squares":"// ===== Patternflow pattern =====\n// Title:   Hard Squares\n// Family:  particle\n// Idea:    Particles that may not touch hop on and off the LEDs as a hard-square lattice gas whose activity grows down the panel like pressure under gravity, so a sparse twinkling gas at the top thickens into a fluid and, below the row where the activity passes its critical 3.796, freezes into the checkerboard crystal, cyan on one sublattice and gold on the other, whose domain walls slowly coarsen.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hard-square lattice gas (D. S. Gaunt and M. E. Fisher, 1965), its critical activity 3.796 (R. J. Baxter, I. G. Enting and S. K. Tsang, 1980), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gravity=6..16, Activity=-1..1\n//\n// Knob 1: Hue. Turns both crystal colours round the wheel. At 0 a particle on the even sublattice is cyan and one on the odd sublattice gold; at 0.25 violet and green, at 0.5 red and blue, at 0.75 lime and magenta. The faint checker of empty sites stays slate above the critical row and plum below it.\n// Knob 2: Speed. Sweeps a second, every site offered a particle or a vacancy once a sweep on average: 4 at 2, 0.4 at 0.2 and 6 at 3. At 4 a gas particle at the top lives about a quarter of a second, while the crystal's domains grow over minutes: in one run the bottom 20 rows went from half cyan and half gold to 95% one colour in nine minutes.\n// Knob 3: Gravity. How fast the activity grows down the panel: at 6 it rises e^6, about 400 times, from 0.028 on the top row to 11 on the bottom row, with the critical 3.796 on row 104, so a gas, a fluid and a crystal stack up over the height. At 16 it rises e^16, the top 56 rows are all but empty and gas turns to crystal over the 40 rows between rows 64 and 104.\n// Knob 4: Activity. Multiplies the activity on every row by e^(2.5 x): 1.16 at the opening 0.06. At -1 it is divided by 12, the bottom row only reaches 0.8 and the whole panel stays a gas; at 1 it is multiplied by 12, the critical row rises to row 55 and the crystal takes the lower 73 rows.\n// Buttons: K1 tap empties the lattice. The gas comes back within a second and the crystal nucleates anew from the bottom up, in small domains of both colours.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, exp, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The critical activity of hard squares: below it the particles take both\n// sublattices alike, above it most of them choose one.\nconst LC = 3.796;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const rgb = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[0] = rgb[0];\n  out[1] = rgb[1];\n  out[2] = rgb[2];\n}\n\n// Levels. Every particle has four empty neighbours, since no two touch. An\n// empty site shows a faint checker: level 40 where x + y is even, dark\n// where it is odd. A particle on an even site sits among dark LEDs and one\n// on an odd site among LEDs at 40, so the odd one is drawn 40 brighter and\n// both stand 110 above their neighbours: the measured detail does not care\n// which sublattice a domain chose. Each pair of LEDs that touches a\n// particle is a hard step and every other pair a soft step of 40, so the\n// measured edges are about twice the density, 0.40 at the opening's 0.20.\nconst PE = 150, PO = 190;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, grav: 6, act: 0.06, acc: 0, warm: false, yc: H,\n    occ: new Uint8Array(N), pOn: new Float32Array(H),\n  };\n}\n\n// The activity lambda is exp(G y / 127) up to a constant, the barometric\n// law, with lambda_c on row 107 before Activity shifts it. S.yc is the first\n// row at or past lambda_c.\nfunction profile(S) {\n  const YF = 107;\n  S.yc = -1;\n  for (let y = 0; y \u003c H; y++) {\n    const lam = LC * exp((S.grav * (y - YF)) / (H - 1) + 2.5 * S.act);\n    S.pOn[y] = lam / (1 + lam);\n    if (lam >= LC && S.yc \u003c 0) S.yc = y;\n  }\n  if (S.yc \u003c 0) S.yc = H;\n}\n\n// Heat-bath (Glauber) moves: a random site whose four neighbours are empty\n// is occupied with probability lambda / (1 + lambda), and any other site\n// is emptied. The rows wrap round in x; above row 0 and below row 127 there\n// is nothing.\nfunction sweep(S, n) {\n  const occ = S.occ, pOn = S.pOn;\n  for (let i = 0; i \u003c n; i++) {\n    const p = floor(random() * N), x = p & 63, y = p >> 6;\n    const free =\n      !occ[y * W + ((x + 1) & 63)] && !occ[y * W + ((x + 63) & 63)] &&\n      (y === 0 || !occ[p - W]) && (y === H - 1 || !occ[p + W]);\n    occ[p] = free && random() \u003c pOn[y] ? 1 : 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.grav = cl(k[2], 6, 16);\n  S.act = cl(k[3], -1, 1);\n  profile(S);\n  if (input.btnPressed && input.btnPressed[0]) S.occ.fill(0);\n  if (!S.warm) {\n    // Open on a panel 150 sweeps after an empty start.\n    sweep(S, 150 * N);\n    S.warm = true;\n  }\n  S.acc += d * S.speed * 2 * N;\n  const n = floor(S.acc);\n  S.acc -= n;\n  sweep(S, n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const occ = S.occ;\n  const ce = [0, 0, 0], co = [0, 0, 0], cb = [0, 0, 0], cc = [0, 0, 0];\n  hsv(S.hue + 0.5, 1, PE / 255, ce);\n  hsv(S.hue + 0.12, 1, PO / 255, co);\n  // The faint checker turns from slate to plum on the row where lambda\n  // passes lambda_c.\n  hsv(0.6, 0.55, 40 / 255, cb);\n  hsv(0.8, 0.45, 40 / 255, cc);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const even = ((x + y) & 1) === 0;\n      const col = occ[p] ? (even ? ce : co) : even ? (y \u003c S.yc ? cb : cc) : null;\n      if (col) display.setPixel(x, y, round(col[0] * 255), round(col[1] * 255), round(col[2] * 255));\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n}\n","hexagrammum-mysticum":"// ===== Patternflow pattern =====\n// Title:   Hexagrammum Mysticum\n// Family:  line\n// Idea:    Six points slide round an ellipse and the 60 hexagons through them are drawn one a second, each with its sides run out until opposite sides meet, the three meeting points ringed and Pascal's line through all three flashing white, while the Pascal lines of the last eleven hexagons stay behind faintly in the colour of their Steiner triple, so that every third hexagon closes a triple and a gold Steiner point flares where its three lines meet.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pascal's hexagrammum mysticum theorem (Blaise Pascal, 1639), Steiner points (Jakob Steiner, 1828), Kirkman points (Thomas Kirkman, 1849), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=12..60, Spread=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the Pascal lines left behind are cyan, azure, blue and violet, a colour for each of the last four triples in turn, the current hexagon's three pairs of opposite sides pink, green and amber, the Steiner points pale gold and the ellipse slate blue; at 0.5 the old lines turn pink, red, lime and green, the sides aqua, violet and blue, the Steiner points pale blue. Pascal's line is always white. The faint colours skip orange and yellow, which read brown and olive when dim.\n// Knob 2: Speed. Hexagons a second, half the knob: one a second at 2, so all 60 go by in a minute and a Steiner point closes every 3 s; 0.2 is one hexagon every 10 s, 3 one every 0.67 s. The six points turn round the ellipse together once in 79 s at 2, each swaying 0.08 rad about its place with a period between 6 and 11 s.\n// Knob 3: Lines. How many of the latest Pascal lines stay drawn, the current one with them, each fading with age. 12 at the opening: the last three or four triples, so three or four Steiner points. At 30 half of the 60; at 60 all of them, with all 20 Steiner points and the 60 Kirkman points as small gold dots, where three lines meet that are not a Steiner triple and no two of which share a crossing of chords.\n// Knob 4: Spread. Draws the six points from the searched gaps towards six equal ones, 85% of the way at 1. Over a minute at 0, 68% of the crossings of opposite sides and 78% of the Steiner points fall on the panel; at 0.25 59% and 60%; at 0.5 55% and 51%; at 1 50% and 50%, as more pairs of sides turn nearly parallel and meet far off.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sin, cos, exp, hypot, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The ellipse the panel shows, centre and half axes in LEDs.\nconst CX = 31.5, CY = 63.5, AX = 16, BY = 34;\n\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n\n// The 60 hexagons on six points, each listed once: from point 0, the way\n// round that visits the lower of its two neighbours first.\nconst HEX = [];\n(function perm(arr, rest) {\n  if (!rest.length) return void (arr[1] \u003c arr[5] && HEX.push(arr));\n  for (let i = 0; i \u003c rest.length; i++) perm([...arr, rest[i]], rest.filter((_, j) => j !== i));\n})([0], [1, 2, 3, 4, 5]);\nconst hexIndex = (h) => {\n  // Turn and reverse an ordering to its listed form.\n  const z = h.indexOf(0), r = [0, 1, 2, 3, 4, 5].map((k) => h[(z + k) % 6]);\n  const f = r[1] \u003c r[5] ? r : [0, r[5], r[4], r[3], r[2], r[1]];\n  return HEX.findIndex((g) => g.every((v, k) => v === f[k]));\n};\n\n// Steiner's triples. Split the six points into two triangles; a hexagon that\n// steps from one to the other every side uses six of the nine chords between\n// them and leaves out three, one from each point: a matching of the two\n// triangles. The three hexagons whose left-out matchings are the even\n// permutations meet in one point, and the three odd ones in another, so the\n// ten splits give the 20 Steiner points, and every hexagon is in one.\nconst STEINER = [];\nfor (let p = 1; p \u003c 6; p++)\n  for (let q = p + 1; q \u003c 6; q++) {\n    const A = [0, p, q], B = [0, 1, 2, 3, 4, 5].filter((v) => !A.includes(v));\n    const tri = [[], []];\n    for (const [x, y, z] of [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]) {\n      // The hexagon A0 Bx A1 By A2 Bz leaves out A0-By, A1-Bz, A2-Bx.\n      const m = [y, z, x], sign = (m[0] - m[1]) * (m[0] - m[2]) * (m[1] - m[2]) > 0 ? 0 : 1;\n      const k = hexIndex([A[0], B[x], A[1], B[y], A[2], B[z]]);\n      if (!tri[sign].includes(k)) tri[sign].push(k);\n    }\n    STEINER.push(tri[0], tri[1]);\n  }\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  // The hexagons go round triple by triple, so every third one closes a\n  // Steiner point.\n  const order = [], tripleOf = new Int8Array(60);\n  STEINER.forEach((t, j) => t.forEach((k) => (order.push(k), (tripleOf[k] = j))));\n  params.s = {\n    t: 0, clock: 0, speed: 2, hue: 0, keep: 12, spread: 0,\n    order, tripleOf, kirkman: [],\n    img: new Float32Array(W * H * 3), pts: [], lines: [],\n  };\n  findKirkman(params.s);\n}\n\n// Kirkman's triples are found by number, once, on six fixed points of an\n// ellipse: the triples of Pascal lines that meet in one point, no two of\n// them meeting at one of the 45 crossings of chords, that are not\n// Steiner's. It finds 60, three through every line.\nfunction findKirkman(S) {\n  const P = [0.3, 1.2, 2.0, 3.4, 4.1, 5.3].map((a) => [cos(a), 1.6 * sin(a), 1]);\n  const L = HEX.map((h) => pascal(P, h).line);\n  const chords = (h) => h.map((v, i) => (1 \u003c\u003c v) | (1 \u003c\u003c h[(i + 1) % 6]));\n  const shares = (a, b) => {\n    // Two hexagons share a crossing when a pair of their opposite sides is\n    // the same pair of chords.\n    const ca = chords(HEX[a]), cb = chords(HEX[b]);\n    for (let i = 0; i \u003c 3; i++) for (let j = 0; j \u003c 3; j++) {\n      const x = [ca[i], ca[i + 3]].sort().join(), y = [cb[j], cb[j + 3]].sort().join();\n      if (x === y) return true;\n    }\n    return false;\n  };\n  const st = new Set(STEINER.map((t) => [...t].sort((a, b) => a - b).join()));\n  for (let i = 0; i \u003c 60; i++)\n    for (let j = i + 1; j \u003c 60; j++) {\n      if (shares(i, j)) continue;\n      const X = cross(L[i], L[j]);\n      for (let k = j + 1; k \u003c 60; k++) {\n        const d = abs(X[0] * L[k][0] + X[1] * L[k][1] + X[2] * L[k][2]) / hypot(X[0], X[1], X[2]);\n        if (d \u003c 1e-9 && !shares(i, k) && !shares(j, k) && !st.has([i, j, k].join())) S.kirkman.push([i, j, k]);\n      }\n    }\n}\n\n// Pascal's line of hexagon h on points P: the crossings of its three pairs\n// of opposite sides, and the line through the first and last, normalised so\n// that a x + b y + c is the distance in LEDs.\nfunction pascal(P, h) {\n  const side = (i) => cross(P[h[i]], P[h[(i + 1) % 6]]);\n  const X = [0, 1, 2].map((i) => cross(side(i), side(i + 3)));\n  const l = cross(X[0], X[2]), n = hypot(l[0], l[1]) || 1;\n  return { X, line: [l[0] / n, l[1] / n, l[2] / n] };\n}\n\n// Where the six points sit round the ellipse, as the angles between\n// neighbours. An even spread sends crossings far off: at six equal gaps 12\n// of the 45 crossings of chords are at infinity, because chords half a turn\n// apart are parallel. These gaps came out of a search over spreads with no\n// gap below 0.6, scored by the share of those 45 crossings and of the 20\n// Steiner points on the panel as the six turn round the ellipse together,\n// less a penalty for crowding to one side: 70% and 84% stay on the panel,\n// against 48% and 50% at equal gaps.\nconst GAPS = [1.766, 1.384, 0.602, 0.601, 0.604, 1.327];\nconst BASE = GAPS.map((g, i) => GAPS.slice(0, i).reduce((a, b) => a + b, 0));\nconst SWAY = [0.31, 0.43, 0.37, 0.53, 0.29, 0.47];\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 12, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.keep = round(cl(kv[2], 12, 60));\n  S.spread = 0.85 * cl(kv[3], 0, 1);\n  S.t += d * S.speed;\n  // Hexagons a second: half the speed, one a second at 2.\n  S.clock += d * S.speed * 0.5;\n  const tau = S.t;\n  // The six points turn round the ellipse together and each sways about its\n  // place; Spread draws them towards six equal gaps.\n  const th = BASE.map((c, i) => c + S.spread * ((PI * i) / 3 + 0.6 - c) - 0.9 + 0.04 * tau + 0.08 * sin(SWAY[i] * tau + i * 2.1));\n  const P = th.map((t) => [CX + AX * cos(t), CY + BY * sin(t), 1]);\n  S.pts = P;\n  S.lines = HEX.map((h) => pascal(P, h));\n}\n\n// Additive, anti-aliased drawing into a float image.\nfunction add(img, x, y, r, g, b, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const q = (y * W + x) * 3;\n  img[q] += r * a;\n  img[q + 1] += g * a;\n  img[q + 2] += b * a;\n}\n\n// A line a x + b y + c = 0 with a, b normalised, between the parameters\n// s0 and s1 along it (measured from the foot of the origin), at width w.\nfunction line(img, L, col, a, s0 = -1e9, s1 = 1e9, w = 0.9) {\n  const [la, lb, lc] = L, fx = -la * lc, fy = -lb * lc, tx = -lb, ty = la;\n  const span = (x, y) => (x - fx) * tx + (y - fy) * ty;\n  if (abs(lb) > abs(la)) {\n    for (let x = 0; x \u003c W; x++) {\n      const yc = -(la * x + lc) / lb;\n      if (yc \u003c -3 || yc > H + 2) continue;\n      for (let y = floor(yc - 1.5); y \u003c= floor(yc + 1.5) + 1; y++) {\n        const dd = abs(la * x + lb * y + lc), sp = span(x, y);\n        if (dd \u003c w + 0.6 && sp >= s0 && sp \u003c= s1) add(img, x, y, col[0], col[1], col[2], a * cl(1 - (dd - 0.15) / w, 0, 1));\n      }\n    }\n  } else {\n    for (let y = 0; y \u003c H; y++) {\n      const xc = -(lb * y + lc) / la;\n      if (xc \u003c -3 || xc > W + 2) continue;\n      for (let x = floor(xc - 1.5); x \u003c= floor(xc + 1.5) + 1; x++) {\n        const dd = abs(la * x + lb * y + lc), sp = span(x, y);\n        if (dd \u003c w + 0.6 && sp >= s0 && sp \u003c= s1) add(img, x, y, col[0], col[1], col[2], a * cl(1 - (dd - 0.15) / w, 0, 1));\n      }\n    }\n  }\n}\n\nfunction dot(img, X, rad, col, a) {\n  if (abs(X[2]) \u003c 1e-12) return;\n  const x = X[0] / X[2], y = X[1] / X[2];\n  if (x \u003c -rad - 2 || x > W + rad + 2 || y \u003c -rad - 2 || y > H + rad + 2) return;\n  for (let py = floor(y - rad - 1); py \u003c= y + rad + 1; py++)\n    for (let px = floor(x - rad - 1); px \u003c= x + rad + 1; px++) {\n      const r = hypot(px - x, py - y);\n      add(img, px, py, col[0], col[1], col[2], a * cl(rad + 0.5 - r, 0, 1));\n    }\n}\n\nfunction ring(img, X, rad, col, a) {\n  if (abs(X[2]) \u003c 1e-12) return;\n  const x = X[0] / X[2], y = X[1] / X[2];\n  if (x \u003c -rad - 2 || x > W + rad + 2 || y \u003c -rad - 2 || y > H + rad + 2) return;\n  for (let py = floor(y - rad - 1); py \u003c= y + rad + 1; py++)\n    for (let px = floor(x - rad - 1); px \u003c= x + rad + 1; px++) add(img, px, py, col[0], col[1], col[2], a * cl(1 - abs(hypot(px - x, py - y) - rad) / 0.8, 0, 1));\n}\n\nfunction glow(img, X, rad, col, a) {\n  if (abs(X[2]) \u003c 1e-12) return;\n  const x = X[0] / X[2], y = X[1] / X[2], R = rad * 2.5;\n  if (x \u003c -R || x > W + R || y \u003c -R || y > H + R) return;\n  for (let py = floor(y - R); py \u003c= y + R; py++)\n    for (let px = floor(x - R); px \u003c= x + R; px++) {\n      const r2 = (px - x) * (px - x) + (py - y) * (py - y);\n      add(img, px, py, col[0], col[1], col[2], a * exp(-r2 / (rad * rad)));\n    }\n}\n\n// Colours, as hues before Hue turns them: the four triples on the panel at\n// the opening take four cool hues in turn, the current hexagon's three pairs\n// of opposite sides three warm ones, and the Steiner points are pale gold.\n// The faint colours go through a wheel that skips orange and yellow, which\n// read brown and olive when dim.\nconst TRIPLE = [0.376, 0.471, 0.576, 0.682];\nconst PAIR = [0.92, 0.3, 0.12];\nconst GOLD = 0.14;\nconst wheel = (h) => 0.18 + 0.85 * (h - floor(h));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.pts.length) return;\n  const img = S.img, P = S.pts, hu = S.hue;\n  img.fill(0);\n  const c = [0, 0, 0];\n  // The ellipse.\n  hsv(wheel(0.494 + hu), 0.45, 0.4, c, 0);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const u = (x - CX) / AX, v = (y - CY) / BY, dd = abs((u * u + v * v - 1) / (2 * hypot(u / AX, v / BY)));\n      if (dd \u003c 1.4) add(img, x, y, c[0], c[1], c[2], cl(1.2 - dd, 0, 1));\n    }\n  const cur = floor(S.clock), ph = S.clock - cur, n = S.order.length;\n  // Past Pascal lines, fading with age, in the colour of their triple. The\n  // order is a cycle, so at the start the lines of its last lap are there.\n  const present = new Float32Array(60);\n  for (let age = S.keep - 1; age >= 1; age--) {\n    const k = S.order[(((cur - age) % n) + n) % n], fade = 1 - (age - 1) / S.keep;\n    present[k] = fade;\n    hsv(wheel(TRIPLE[S.tripleOf[k] % 4] + hu), 0.75, 1, c, 0);\n    line(img, S.lines[k].line, c, 0.1 + 0.2 * fade);\n  }\n  // The current hexagon: its sides grow out into long lines, then the three\n  // crossings of opposite sides light, then Pascal's line through them.\n  const k = S.order[cur % n], h = HEX[k], pl = S.lines[k];\n  const grow = 1 - (1 - cl(ph / 0.3, 0, 1)) ** 2, pop = cl((ph - 0.28) / 0.1, 0, 1), flash = cl((ph - 0.4) / 0.08, 0, 1), dim = cl((ph - 0.55) / 0.45, 0, 1);\n  for (let i = 0; i \u003c 6; i++) {\n    const A = P[h[i]], B = P[h[(i + 1) % 6]], l = cross(A, B), nn = hypot(l[0], l[1]), L = [l[0] / nn, l[1] / nn, l[2] / nn];\n    const fx = -L[0] * L[2], fy = -L[1] * L[2], tx = -L[1], ty = L[0];\n    const sa = (A[0] - fx) * tx + (A[1] - fy) * ty, sb = (B[0] - fx) * tx + (B[1] - fy) * ty;\n    const lo = min(sa, sb), hi = max(sa, sb), X = pl.X[i % 3];\n    hsv(PAIR[i % 3] + hu, 0.7, 1, c, 0);\n    // The whole side faintly, the chord bright, and the stretch from the\n    // chord out to where it meets its opposite side growing in.\n    line(img, L, c, 0.14 * grow);\n    line(img, L, c, 0.95, lo, hi, 1.1);\n    const far = abs(X[2]) \u003c 1e-9 * hypot(X[0], X[1]);\n    const sx = far ? (X[0] * tx + X[1] * ty > 0 ? 1e4 : -1e4) : (X[0] / X[2] - fx) * tx + (X[1] / X[2] - fy) * ty;\n    const e = 0.62 - 0.25 * dim;\n    if (sx > hi) line(img, L, c, e, hi, hi + (min(sx, hi + 300) - hi) * grow);\n    else if (sx \u003c lo) line(img, L, c, e, lo - (lo - max(sx, lo - 300)) * grow, lo);\n  }\n  if (flash > 0) {\n    present[k] = 1;\n    line(img, pl.line, [1, 1, 1], 0.35 + 0.65 * flash * (1 - 0.45 * dim), -1e9, 1e9, 1.15);\n  }\n  for (let i = 0; i \u003c 3; i++) {\n    hsv(PAIR[i] + hu, 0.55, 1, c, 0);\n    ring(img, pl.X[i], 2.6, c, 1.4 * pop * (1 - 0.4 * dim));\n    dot(img, pl.X[i], 0.9, [1, 1, 1], pop);\n  }\n  // Steiner points where all three lines of a triple are drawn; the point\n  // the current hexagon closes flares.\n  hsv(GOLD + hu, 0.45, 1, c, 0);\n  STEINER.forEach((t) => {\n    const a = min(present[t[0]], present[t[1]], present[t[2]]);\n    if (a \u003c= 0) return;\n    const X = cross(S.lines[t[0]].line, S.lines[t[1]].line);\n    const fresh = t.includes(k) ? flash * (1 - dim * 0.7) : 0;\n    glow(img, X, 1.4 + 2.2 * fresh, c, 0.45 + 0.35 * a + 0.8 * fresh);\n    dot(img, X, 0.7 + 0.6 * fresh, [1, 1, 1], 0.6 + 0.4 * a);\n  });\n  // Kirkman points, small, once all three of their lines are drawn.\n  for (const [i, j, q] of S.kirkman) {\n    const a = min(present[i], present[j], present[q]);\n    if (a > 0) dot(img, cross(S.lines[i].line, S.lines[j].line), 0.5, c, 0.35 + 0.45 * a);\n  }\n  // The six points.\n  for (const X of P) dot(img, X, 1.25, [1, 1, 1], 1);\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, (255 * min(1, img[q])) | 0, (255 * min(1, img[q + 1])) | 0, (255 * min(1, img[q + 2])) | 0);\n}\n","kp-web":"// ===== Patternflow pattern =====\n// Title:   KP Web\n// Family:  wave\n// Idea:    Exact line-soliton solutions of the Kadomtsev-Petviashvili equation glow as ridges on a dark field, coloured by their height, while time runs through each one: a Y junction whose stem grows up the panel, two kinds of X crossing, and webs from the totally nonnegative Grassmannian whose holes shrink to a single crossing and open again in another shape.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kadomtsev-Petviashvili equation (Boris Kadomtsev and Vladimir Petviashvili, 1970), resonant Y junction (John Miles, 1977), KP web solutions (Yuji Kodama, 2004), their classification by the totally nonnegative Grassmannian (Yuji Kodama and Lauren Williams, 2011), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Type=0..6, Angle=0..1\n//\n// Knob 1: Hue. Turns both ends of the height ramp round the wheel. At 0 the tallest ridges are aqua, the lowest violet and those between lavender blue, and where u rises above the tallest line, as where the two O solitons cross, the light goes white; at 0.5 the tall ones are pink and the low ones green. The wheel skips dim orange, which reads brown.\n// Knob 2: Speed. At 2 one sweep of time through a solution lasts 9 seconds, half a second of it fading out and in; at 0.2 it lasts 90, at 3 six. A web is smallest at the middle of its sweep, and its farthest junction is 100 LEDs out at either end; a lone Y or X runs 112 LEDs, bottom to top or top to bottom.\n// Knob 3: Type. Below 1 the panel tours the six types, one per sweep: the T web, Gr(2,5), Gr(3,6), Y, O, P. From 1 up it holds one, each sweep on a fresh random point of its cell: 1 the Y junction of Gr(1,3), 2 the O type and 3 the P type of Gr(2,4), each an X, 4 the T web of Gr(2,4), whose box has a tall stem on one side, 5 the Gr(2,5) web and 6 the Gr(3,6) web, with 10 and 20 exponentials in tau and several holes.\n// Knob 4: Angle. Scales every k_j by 0.55 at 0 up to 1.25 at 1, the window rescaled so a ridge keeps its width in LEDs, and the slope of the line [i, j] is k_i + k_j: the T web's far lines lean 24 degrees off upright at 0, 25 at the opening 0.06 and 45 at 1. The same solution is rebuilt as it turns.\n\nconst W = 64, H = 128;\nconst { floor, min, max, exp, log, sqrt, abs, round, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// KP-II, (-4u_t + 6uu_x + u_xxx)_x + 3u_yy = 0, has the exact solutions\n// u = 2 (ln tau)_xx with tau = sum over k-subsets I of Delta_I(A) E_I, where\n// E_I = prod_{i\u003cj in I}(k_j - k_i) * exp(sum_{j in I} theta_j) and\n// theta_j = k_j x + k_j^2 y + k_j^3 t. A is a k x N matrix whose maximal\n// minors Delta_I are all >= 0; which of them vanish picks the cell of the\n// totally nonnegative Grassmannian, and the cell picks the web.\n// With softmax weights w_I = Delta_I E_I / tau, (ln tau)_x is the mean of\n// kappa_I = sum k_j and (ln tau)_xx its variance, so u = 2 Var_w(kappa)\n// and no exponential is ever taken of more than 0: no overflow in tau.\n\nfunction subsets(n, k) {\n  const out = [];\n  const rec = (s, cur) => {\n    if (cur.length === k) return void out.push(cur.slice());\n    for (let i = s; i \u003c n; i++) cur.push(i), rec(i + 1, cur), cur.pop();\n  };\n  rec(0, []);\n  return out;\n}\n\nfunction det(M) {\n  const n = M.length, a = M.map((r) => r.slice());\n  let d = 1;\n  for (let c = 0; c \u003c n; c++) {\n    let p = c;\n    for (let r = c + 1; r \u003c n; r++) if (abs(a[r][c]) > abs(a[p][c])) p = r;\n    if (abs(a[p][c]) \u003c 1e-300) return 0;\n    if (p !== c) [a[p], a[c]] = [a[c], a[p]], (d = -d);\n    d *= a[c][c];\n    for (let r = c + 1; r \u003c n; r++) {\n      const f = a[r][c] / a[c][c];\n      for (let j = c; j \u003c n; j++) a[r][j] -= f * a[c][j];\n    }\n  }\n  return d;\n}\n\n// A strictly totally positive k x N matrix: the kernel exp(alpha_i beta_j)\n// with both sequences increasing, its columns scaled by random weights.\n// Every maximal minor is positive, so this is the top cell.\nfunction topCell(r, N) {\n  const beta = [];\n  let b = 0;\n  for (let j = 0; j \u003c N; j++) beta.push((b += 0.6 + 0.5 * random()));\n  const d = beta.map(() => exp(2 * (random() - 0.5)));\n  return Array.from({ length: r }, (_, i) => beta.map((bj, j) => d[j] * exp(i * 0.9 * bj)));\n}\nconst rnd = () => exp(2.4 * (random() - 0.5));\n\n// The six types. k is the base set of k_j; follow 'x' keeps the window at\n// one height so the junction travels up or down, 'xy' follows the web.\nconst TYPES = [\n  // Gr(1,3): one soliton [1,3] below, two above, meeting in Miles' resonant\n  // Y. k_1 + k_3 = 0 stands the stem upright; the sum of the k climbs the\n  // junction up the panel, so the stem grows.\n  { k: [-1, 0.3, 1], cell: () => [[1, rnd(), rnd()]], follow: \"x\", s0: 1.0 },\n  // Gr(2,4) O type, Delta_12 = Delta_34 = 0: the solitons [1,2] and [3,4]\n  // cross in an X, and where they cross u rises above the sum of their\n  // heights (0.26 against 0.24 at the opening Angle).\n  { k: [-1.3, -0.45, 0.25, 1.05], cell: () => [[1, rnd(), 0, 0], [0, 0, 1, rnd()]], follow: \"x\", s0: 1.0 },\n  // P type, Delta_14 = Delta_23 = 0: [1,4] and [2,3] cross, and the tall\n  // one's crest dips where they do (from 1.10 to 0.92).\n  { k: [-1.3, 0.1, 0.9, 1.2], cell: () => [[1, 0, 0, -rnd()], [0, 1, rnd(), 0]], follow: \"x\", s0: 1.0 },\n  // T type, every minor positive: [1,3] and [2,4] far away, four resonant\n  // Y junctions round a box in the middle.\n  { k: [-1.2, -0.4, 0.4, 1.2], cell: () => topCell(2, 4), follow: \"xy\", s0: 0.85 },\n  { k: [-1.2, -0.6, 0, 0.6, 1.2], cell: () => topCell(2, 5), follow: \"xy\", s0: 0.76 },\n  { k: [-1.25, -0.75, -0.25, 0.25, 0.75, 1.25], cell: () => topCell(3, 6), follow: \"xy\", s0: 0.68 },\n];\nconst TOUR = [3, 4, 5, 0, 1, 2];\n\n// At the ends of a sweep the farthest junction sits this many LEDs from the\n// window's middle: a lone junction or crossing runs the panel's height, a\n// web grows past the panel's edges so its holes fill it.\nconst REACH = { x: 56, xy: 100 };\n\nfunction build(type, a, A) {\n  const T = TYPES[type], k = T.k.map((v) => v * a), N = k.length, r = A.length;\n  const terms = [];\n  for (const I of subsets(N, r)) {\n    const D = det(A.map((row) => I.map((j) => row[j])));\n    if (D \u003c= 1e-9) continue;\n    let V = 1, p = 0, q = 0, c3 = 0;\n    for (let x = 0; x \u003c I.length; x++) for (let y = x + 1; y \u003c I.length; y++) V *= k[I[y]] - k[I[x]];\n    for (const j of I) (p += k[j]), (q += k[j] * k[j]), (c3 += k[j] ** 3);\n    terms.push({ I, c: log(D * V), p, q, c3 });\n  }\n  // The tallest line soliton that can appear: two terms whose index sets\n  // differ in one place balance along the line [i, j], height (k_i - k_j)^2 / 2.\n  let umax = 0;\n  for (const A of terms) for (const B of terms) if (A.I.filter((j) => !B.I.includes(j)).length === 1) umax = max(umax, (A.p - B.p) ** 2 / 2);\n  // s0 is LEDs per unit of x and y for the base set; scaled with the spread\n  // so a ridge of a given k_i - k_j keeps its width in LEDs.\n  return { terms, umax, follow: T.follow, S: T.s0 * a, A };\n}\n\n// Triple points: where three exponentials tie and none is bigger. These\n// are the junctions of the web.\nfunction vertices(terms, t) {\n  const out = [], n = terms.length;\n  for (let a = 0; a \u003c n; a++)\n    for (let b = a + 1; b \u003c n; b++)\n      for (let c = b + 1; c \u003c n; c++) {\n        const A = terms[a], B = terms[b], C = terms[c];\n        const a11 = A.p - B.p, a12 = A.q - B.q, r1 = B.c - A.c + (B.c3 - A.c3) * t;\n        const a21 = B.p - C.p, a22 = B.q - C.q, r2 = C.c - B.c + (C.c3 - B.c3) * t;\n        const d = a11 * a22 - a12 * a21;\n        if (abs(d) \u003c 1e-9) continue;\n        const x = (r1 * a22 - a12 * r2) / d, y = (a11 * r2 - a21 * r1) / d;\n        const f = A.c + A.p * x + A.q * y + A.c3 * t;\n        let top = true;\n        for (const M of terms) if (M.c + M.p * x + M.q * y + M.c3 * t > f + 1e-7) { top = false; break; }\n        if (top) out.push([x, y]);\n      }\n  return out;\n}\nconst centroid = (v) => {\n  let x = 0, y = 0;\n  for (const p of v) (x += p[0]), (y += p[1]);\n  return [x / max(1, v.length), y / max(1, v.length)];\n};\n\n// One sweep: a fresh point of the cell (or the same one, when only Angle\n// turned), the moment its web is smallest, and a window moving at constant\n// speed with the junctions' middle.\nfunction newSweep(S, keep) {\n  const type = keep ? S.type : S.typeKnob \u003c 1 ? TOUR[S.tour++ % 6] : min(5, floor(S.typeKnob) - 1);\n  const B = build(type, S.a, keep ? S.B.A : TYPES[type].cell());\n  let tm = 0, best = 1e9;\n  if (B.follow === \"xy\")\n    for (let t = -24; t \u003c= 24; t += 1) {\n      const v = vertices(B.terms, t);\n      let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n      for (const p of v) (x0 = min(x0, p[0])), (x1 = max(x1, p[0])), (y0 = min(y0, p[1])), (y1 = max(y1, p[1]));\n      if (x1 - x0 + y1 - y0 \u003c best) (best = x1 - x0 + y1 - y0), (tm = t);\n    }\n  const c0 = centroid(vertices(B.terms, tm)), c1 = centroid(vertices(B.terms, tm + 1));\n  const vx = c1[0] - c0[0], vy = B.follow === \"xy\" ? c1[1] - c0[1] : 0;\n  // How far each junction strays from the window per unit of t, in LEDs.\n  const v2 = vertices(B.terms, tm + 10);\n  let spread = 1e-6;\n  for (const p of v2) {\n    const dx = (p[0] - c0[0] - 10 * vx) * B.S, dy = (p[1] - c0[1] - 10 * vy) * B.S;\n    spread = max(spread, sqrt(dx * dx + dy * dy) / 10);\n  }\n  Object.assign(S, { B, type, tm, T: REACH[B.follow] / spread, cx: c0[0], cy: c0[1], vx, vy });\n}\n\n// Dim orange reads brown on the panel, so the wheel skips 0.03 to 0.16.\nfunction hsv(h) {\n  h = 0.16 + 0.87 * (h - 0.16 - floor(h - 0.16));\n  const q = (h - floor(h)) * 6, i = floor(q), f = q - i;\n  return [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i % 6];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, typeKnob: 0, a: 0.6, tour: 0, B: null, phase: 0,\n    ph: new Float64Array(0), dp: new Float64Array(0), rgb: [0, 0, 0],\n    edge: new Float64Array(W + 1), evar: new Float64Array(W + 1), epair: new Float64Array(W + 1),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const a = 0.55 + 0.7 * cl(k[3], 0, 1), tk = cl(k[2], 0, 6);\n  const typeNow = (x) => (x \u003c 1 ? -1 : min(5, floor(x) - 1));\n  if (!S.B || typeNow(tk) !== typeNow(S.typeKnob)) {\n    S.typeKnob = tk;\n    S.a = a;\n    newSweep(S, false);\n    // A new type opens just after its sweep has faded in.\n    S.phase = 0.06;\n  } else if (abs(a - S.a) > 0.01) {\n    // Angle rebuilds the same solution with the new k and keeps its time.\n    S.a = a;\n    newSweep(S, true);\n  }\n  S.phase += (d * S.speed) / 18;\n  if (S.phase >= 1) newSweep(S, false), (S.phase -= 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.B) return;\n  const { terms, umax, S: sc } = S.B, n = terms.length;\n  const t = S.tm + (2 * S.phase - 1) * S.T;\n  const cx = S.cx + S.vx * (t - S.tm), cy = S.cy + S.vy * (t - S.tm);\n  // Fade in and out at the ends of the sweep.\n  const fade = min(1, S.phase / 0.06, (1 - S.phase) / 0.06);\n  const ph = S.ph.length === n ? S.ph : (S.ph = new Float64Array(n)), dp = S.dp.length === n ? S.dp : (S.dp = new Float64Array(n));\n  for (let i = 0; i \u003c n; i++) dp[i] = terms[i].p / sc;\n  const cHi = hsv(S.hue + 0.49), cLo = hsv(S.hue + 0.86);\n  const M = S.edge, V = S.evar, P = S.epair;\n  for (let Y = 0; Y \u003c H; Y++) {\n    // The softmax is taken at the 65 edges between the LEDs of a row. The\n    // mean of kappa there is (ln tau)_x, so u averaged over an LED's width\n    // is exactly 2 (mean_right - mean_left) / width: a box filter in x for\n    // the price of one more point a row.\n    const y = cy + (Y - 63.5) / sc, x0 = cx - 32 / sc;\n    for (let i = 0; i \u003c n; i++) {\n      const T = terms[i];\n      ph[i] = T.c + T.p * x0 + T.q * y + T.c3 * t;\n    }\n    for (let X = 0; X \u003c= W; X++) {\n      let m = -1e300;\n      for (let i = 0; i \u003c n; i++) if (ph[i] > m) m = ph[i];\n      let s = 0, s1 = 0, s2 = 0, sw = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const e = ph[i] - m;\n        if (e > -24) {\n          const w = exp(e), p = terms[i].p;\n          s += w;\n          s1 += w * p;\n          s2 += w * p * p;\n          sw += w * w;\n        }\n        ph[i] += dp[i];\n      }\n      const mu = s1 / s;\n      M[X] = mu;\n      V[X] = s2 / s - mu * mu;\n      // u = sum over pairs of w_I w_J (kappa_I - kappa_J)^2, and on a line\n      // where two terms balance 1 - sum w^2 = 2 w (1 - w), so Var / that is\n      // the local soliton's height, smooth through the junctions.\n      P[X] = 1 - sw / (s * s);\n    }\n    for (let X = 0; X \u003c W; X++) {\n      const u = 2 * (M[X + 1] - M[X]) * sc, pr = P[X] + P[X + 1];\n      const amp = pr > 1e-6 ? (V[X] + V[X + 1]) / pr : 0;\n      const ar = cl(amp / umax, 0.02, 1), r = u / umax;\n      // Brightness: the ridge's profile u / height, a little sharpened, times\n      // the 0.3 power of its height, so a low ridge still shows. Colour: the\n      // local soliton's height, cLo for the lowest, cHi for the tallest.\n      // Where u rises above the tallest line, as where two O solitons cross,\n      // the light goes white.\n      const prof = cl(u / (umax * ar), 0, 1.5), g = sqrt(ar), wh = cl((r - 1) / 1.5, 0, 0.7);\n      const v = min(1, prof ** 0.7 * ar ** 0.3) * fade;\n      const rgb = S.rgb;\n      for (let c = 0; c \u003c 3; c++) rgb[c] = v * ((cHi[c] * g + cLo[c] * (1 - g)) * (1 - wh) + wh);\n      display.setPixel(X, Y, round(rgb[0] * 255), round(rgb[1] * 255), round(rgb[2] * 255));\n    }\n  }\n}\n","loop-soup":"// ===== Patternflow pattern =====\n// Title:   Loop Soup\n// Family:  noise\n// Idea:    Closed random walks on a lattice of every other LED, rooted anywhere and sized by the scale-invariant loop measure so that each octave of length holds half as many loops as the one below, are born as a Poisson cloud, draw themselves with a white head until they close, and fade after seven seconds, while every cluster of loops that share a site takes the colour of its longest loop, so at the opening c = 1 the soup shows dozens of separate clusters of every size, and as c rises they merge into one that holds nine tenths of the ink.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Brownian loop soup (Gregory Lawler and Wendelin Werner, 2004), random walk loop soup (Gregory Lawler and José Trujillo Ferreras, 2007), CLE from loop-soup clusters (Scott Sheffield and Wendelin Werner, 2012), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Log2 c=-2..2, Smallest=-1..4\n//\n// Knob 1: Hue. Turns every cluster's colour round the wheel together. Each loop takes the next hue of a golden-ratio sequence, 0.618 of the wheel on from the last, and a cluster shows the hue of its longest loop, so when a long loop is drawn across smaller clusters they all take its colour, and when it fades they get their own back. The wheel skips the orange stretch that reads brown on a fading loop.\n// Knob 2: Speed. At 2 a loop lives 7 s: its head draws it in 0.57 s for 4 steps, 0.22 s longer for each doubling up to 2.55 s for 2048, it shines at full as it closes, eases to 70% and fades over its last 2.5 s. At c = 1 about 20 loops are born a second. 0.2 is ten times slower, 3 one and a half times faster.\n// Knob 3: Log2 c. The intensity c is 2 to this power, 0.25 to 4, and 1 at the opening 0. The loops alive at any moment are a Poisson soup of c/2 times the random walk loop measure, the normalisation in which c is the central charge, and c = 0.25, 0.5 and 1 go with CLE(kappa) for kappa = 2.81, 3 and 4. Measured over six runs of a minute: up to c = 1.4 the largest of 23 to 59 clusters holds about a third of the inked LEDs and crosses the panel from top to bottom in at most 1% of frames; at 2 it crosses in 6%, at 2.8 in 30% holding 59% of the ink, and at 4 in 86% holding 90%. The ink covers 6% of the panel at 0.25, 21% at 1 and 52% at 4.\n// Knob 4: Smallest. The shortest loop, 2 round(2 x 2^K4) steps: at -1 two steps, a dash over one edge and the commonest loop of the measure, 128 of them on the panel at c = 1; at the opening 4 steps, at 2 16 and at 4 64. The small loops are the glue: at c = 4 the largest cluster holds 92% of the ink with the two-step loops in, 90% from 4 steps, 79% from 16 and 71% from 64, and it crosses the panel in 93%, 86%, 58% and 24% of frames.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, log, round, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The lattice: one site every other LED, 32 x 64 on the panel, and the\n// LED between two neighbouring sites is the edge joining them. The soup\n// lives on a bigger lattice, M sites past every side, so loops come in\n// from off the panel and clusters join off it too.\nconst SW = 32, SH = 64, M = 40, GW = SW + 2 * M, GH = SH + 2 * M;\n// Loops have 2j steps, j up to JMAX; the longest, 1024 to 2048 steps, are\n// about 70 LEDs across.\nconst JMAX = 1024;\n// A loop lives LIFE seconds of soup time and fades for the last FADE.\nconst LIFE = 7, FADE = 2.5;\nconst GOLD = 0.618034;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\n// The random walk loop measure: the loops of 2j steps rooted at one site\n// weigh p(2j) / 2j, p(2j) the chance a simple random walk is back at its\n// start after 2j steps, (C(2j, j) / 4^j)^2, about 1 / (pi j). So per site\n// the loops of 2j to 4j steps weigh about 1 / (4 pi j): half as much each\n// octave up, the scale invariance of Lawler and Werner's Brownian loop\n// measure dt dA / (2 pi t^2).\nconst WJ = new Float64Array(JMAX + 1);\n{\n  let r = 1;\n  for (let j = 1; j \u003c= JMAX; j++) {\n    r *= (2 * j - 1) / (2 * j);\n    WJ[j] = (r * r) / (2 * j);\n  }\n}\n// Loops of 2j steps are rooted up to this many sites off the panel.\nconst reach = (j) => min(M, ceil(1.5 * sqrt(j)));\nconst area = (j) => (SW + 2 * reach(j)) * (SH + 2 * reach(j));\n\n// Loops alive at once, per unit of lambda, for the shortest loop 2 jmin.\nfunction table(jmin) {\n  const cum = new Float64Array(JMAX + 1);\n  let t = 0;\n  for (let j = 1; j \u003c= JMAX; j++) {\n    if (j >= jmin) t += WJ[j] * area(j);\n    cum[j] = t;\n  }\n  return cum;\n}\n\nfunction poisson(mu) {\n  // Knuth for small means, a rounded normal for big ones.\n  if (mu > 30) return max(0, round(mu + sqrt(mu) * gauss()));\n  let k = 0, p = 1;\n  const L = exp(-mu);\n  for (;;) {\n    p *= Math.random();\n    if (p \u003c L) return k;\n    k++;\n  }\n}\nfunction gauss() {\n  const u = Math.random() || 1e-9, v = Math.random();\n  return sqrt(-2 * log(u)) * Math.cos(6.283185 * v);\n}\n\n// A uniform random walk bridge of 2j steps from site (a, b). Turned 45\n// degrees, a simple random walk is two independent coin-flip walks, so a\n// walk that comes back is two shuffles of j heads and j tails.\nfunction makeLoop(S, j, a, b, age) {\n  const n = 2 * j, u = new Int8Array(n), v = new Int8Array(n);\n  for (let i = 0; i \u003c n; i++) u[i] = v[i] = i \u003c j ? 1 : -1;\n  for (let i = n - 1; i > 0; i--) {\n    let k = floor(Math.random() * (i + 1)), t = u[i];\n    u[i] = u[k];\n    u[k] = t;\n    k = floor(Math.random() * (i + 1));\n    t = v[i];\n    v[i] = v[k];\n    v[k] = t;\n  }\n  // site[t] is the lattice cell after t steps (or -1 off the lattice);\n  // led[2t] the edge LED of step t and led[2t + 1] the site LED it reaches.\n  const site = new Int32Array(n + 1), led = new Int32Array(2 * n);\n  let x = a, y = b;\n  const cell = (x, y) => (x >= -M && x \u003c SW + M && y >= -M && y \u003c SH + M ? (y + M) * GW + x + M : -1);\n  const px = (X, Y) => (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H ? Y * W + X : -1);\n  site[0] = cell(x, y);\n  for (let t = 0; t \u003c n; t++) {\n    const dx = (u[t] + v[t]) >> 1, dy = (u[t] - v[t]) >> 1;\n    led[2 * t] = px(2 * x + dx, 2 * y + dy);\n    x += dx;\n    y += dy;\n    site[t + 1] = cell(x, y);\n    led[2 * t + 1] = px(2 * x, 2 * y);\n  }\n  // A loop draws itself in 0.35 s for two steps and 0.22 s more for each\n  // doubling, 2.55 s for 2048.\n  const trace = 0.35 + 0.22 * log(j) / log(2);\n  S.loops.push({ j, n, a, b, x1: x, y1: y, site, led, age, trace, hue: (S.seq++ * GOLD) % 1, p: 0 });\n}\n\nfunction birth(S, j, age) {\n  const r = reach(j);\n  const a = floor(-r + Math.random() * (SW + 2 * r)), b = floor(-r + Math.random() * (SH + 2 * r));\n  makeLoop(S, j, a, b, age);\n}\n\nfunction pickJ(S) {\n  const cum = S.cum, t = Math.random() * cum[JMAX];\n  let lo = S.jmin, hi = JMAX;\n  while (lo \u003c hi) {\n    const m = (lo + hi) >> 1;\n    if (cum[m] \u003c t) lo = m + 1;\n    else hi = m;\n  }\n  return lo;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, c: 1, jmin: 2, cum: table(2), loops: [], seq: 0, warm: false,\n    owner: new Int32Array(GW * GH), lev: new Float32Array(W * H), hueAt: new Float32Array(W * H),\n    white: new Uint8Array(W * H), col: new Float32Array(3),\n  };\n}\n\nconst drawnSteps = (L) => (L.age >= L.trace ? L.n : floor((L.n * L.age) / L.trace));\n// A loop's brightness: full as it closes, easing to 70% and fading out.\nconst bright = (L) => {\n  if (L.age \u003c L.trace) return 1;\n  const a = L.age - L.trace;\n  if (L.age > LIFE - FADE) return 0.7 * max(0, (LIFE - L.age) / FADE);\n  return 0.7 + 0.3 * exp(-a / 0.6);\n};\n\nfunction find(par, i) {\n  while (par[i] !== i) i = par[i] = par[par[i]];\n  return i;\n}\n\nfunction step(S, ds) {\n  const lam = S.c / 2;\n  // Age and drop.\n  const loops = S.loops;\n  let w = 0;\n  for (const L of loops) {\n    L.age += ds;\n    if (L.age \u003c LIFE) loops[w++] = L;\n  }\n  loops.length = w;\n  // Poisson births: lam = c/2 times the measure, spread over a lifetime, so\n  // the loops alive at any moment are a loop soup of central charge c.\n  const k = poisson((lam * S.cum[JMAX] * ds) / LIFE);\n  for (let i = 0; i \u003c k; i++) birth(S, pickJ(S), Math.random() * ds);\n}\n\n// Clusters: loops that share a site, drawn so far, on or off the panel.\nfunction cluster(S) {\n  const { loops, owner } = S, n = loops.length, par = new Int32Array(n);\n  owner.fill(-1);\n  for (let i = 0; i \u003c n; i++) par[i] = i;\n  for (let i = 0; i \u003c n; i++) {\n    const L = loops[i], s = L.site, k = drawnSteps(L);\n    for (let t = 0; t \u003c= k; t++) {\n      const g = s[t];\n      if (g \u003c 0) continue;\n      const o = owner[g];\n      if (o \u003c 0) owner[g] = i;\n      else {\n        const ra = find(par, o), rb = find(par, i);\n        if (ra !== rb) par[ra] = rb;\n      }\n    }\n  }\n  // Each cluster takes the colour of its longest loop, the oldest of those.\n  const lead = new Int32Array(n).fill(-1);\n  for (let i = 0; i \u003c n; i++) {\n    const r = find(par, i), l = lead[r];\n    if (l \u003c 0 || loops[i].n > loops[l].n || (loops[i].n === loops[l].n && loops[i].age > loops[l].age)) lead[r] = i;\n  }\n  for (let i = 0; i \u003c n; i++) loops[i].p = loops[lead[find(par, i)]].hue;\n  S.par = par;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.c = 2 ** cl(k[2], -2, 2);\n  const jmin = max(1, round(2 * 2 ** cl(k[3], -1, 4)));\n  if (jmin !== S.jmin) {\n    S.jmin = jmin;\n    S.cum = table(jmin);\n    S.loops = S.loops.filter((L) => L.j >= jmin);\n  }\n  if (!S.warm) {\n    // Open on a soup already at its steady state: every length its Poisson\n    // count, each loop somewhere in its life.\n    const lam = S.c / 2;\n    for (let j = jmin; j \u003c= JMAX; j++) {\n      const q = poisson(lam * WJ[j] * area(j));\n      for (let i = 0; i \u003c q; i++) birth(S, j, Math.random() * LIFE);\n    }\n    S.warm = true;\n  }\n  step(S, (d * S.speed) / 2);\n  cluster(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { lev, hueAt, white, col } = S;\n  lev.fill(0);\n  white.fill(0);\n  for (const L of S.loops) {\n    const b = bright(L), k = drawnSteps(L), led = L.led;\n    if (b \u003c= 0) continue;\n    // The root LED, then every step drawn so far.\n    const r = led[2 * L.n - 1];\n    if (r >= 0 && b > lev[r]) (lev[r] = b), (hueAt[r] = L.p);\n    for (let i = 0; i \u003c 2 * k; i++) {\n      const p = led[i];\n      if (p >= 0 && b > lev[p]) (lev[p] = b), (hueAt[p] = L.p);\n    }\n    // The walker's head, white, while the loop is being drawn.\n    if (k \u003c L.n && k > 0) {\n      const p = led[2 * k - 1];\n      if (p >= 0) white[p] = 1;\n    }\n  }\n  const h0 = S.hue + 0.5;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (white[p]) {\n        display.setPixel(x, y, 255, 255, 255);\n        continue;\n      }\n      const v = lev[p];\n      if (v \u003c= 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      hsv(wheel(h0 + hueAt[p]), 0.8, v, col, 0);\n      display.setPixel(x, y, round(col[0] * 255), round(col[1] * 255), round(col[2] * 255));\n    }\n}\n","mirror-curves":"// ===== Patternflow pattern =====\n// Title:   Mirror Curves\n// Family:  topology\n// Idea:    A light ray runs at 45 degrees round a 4 x 8 grid of dots on a board that wraps like a torus, bouncing off the two-sided mirrors on half of the 64 sites between the dots, and each closed path it makes is one strand of an alternating link, woven over and under at every free crossing and coloured on its own, while about once a second a mirror turns or moves, joining or splitting strands, and the new colour runs out along the strand from that mirror.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: mirror curves (Slavik Jablan, 2001), Lunda designs from the Chokwe sona (Paulus Gerdes, 1990s), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mirrors=0.5..1, Join=0..1\n//\n// Knob 1: Hue. Turns the eight strand colours round the wheel together. At 0 they are sky, amber, green, magenta, turquoise, violet, lime and pink; at 0.5 each takes the colour opposite, sky turning orange and green magenta. The dots and mirrors stay white and the faint field behind stays blue and violet.\n// Knob 2: Speed. At 2 the whole board drifts one LED right and one down every 0.67 s, a mirror turns or moves every 0.83 s, and its new colour runs along the strand at 130 LEDs a second. At 0.2 all of it is ten times slower; at 3 half as fast again.\n// Knob 3: Mirrors. The share of the 64 sites that hold a mirror: 32 at 0.5, so a strand bends at about every other site, 48 at 0.75, and all 64 at 1, where no strand crosses another and every strand is a closed loop fenced in by mirrors. The lit LEDs go from 800 to 864.\n// Knob 4: Join. How many strands the walk keeps: 8 at 0, 6 at 0.25, 5 at 0.5, 3 at 0.75, and at 1 a single closed curve through all 128 segments, the board drawn in one stroke as the sona drawers aimed to draw it.\n// Buttons: K3 tap frames the board for 4 seconds: every inner mirror is lifted, the 12 sites on the panel's left and top edges take mirrors along the edge, the drift stops, and the 4 x 8 rectangle is drawn by gcd(4, 8) = 4 strands. A second tap, or the end of the 4 seconds, puts the mirrors back.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, max, round, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const rgb = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[0] = rgb[0];\n  out[1] = rgb[1];\n  out[2] = rgb[2];\n}\n\n// The grid in half-cell units: a cell is 16 LEDs, so u runs 0..7 across and\n// v 0..15 down, both wrapping. Dots sit at (odd, odd), cell corners at\n// (even, even), and the crossing sites, the midpoints of the cell edges, at\n// u + v odd: 64 of them. The strands run between sites in 45-degree steps,\n// so every lit LED has x + y even and the four LEDs round it dark; where\n// x + y is odd the panel is always dark, and where it is even and nothing\n// is drawn it shows the field at level 40. A kept crossing drops four LEDs\n// from the strand under it and a mirror two, so with M mirrors the panel\n// holds 736 + 2M LEDs at 255 in every frame: 800 at the opening, which\n// puts the measured edges at 0.195 and the detail at 0.318.\nconst HC = 8, NU = W / HC, NV = H / HC;\nconst mod = (a, m) => ((a % m) + m) % m;\nconst SU = [], SV = [], SITE = new Int16Array(NU * NV).fill(-1);\nfor (let v = 0; v \u003c NV; v++)\n  for (let u = 0; u \u003c NU; u++)\n    if ((u + v) & 1) {\n      SITE[v * NU + u] = SU.length;\n      SU.push(u);\n      SV.push(v);\n    }\nconst NS = SU.length;\nconst siteAt = (u, v) => SITE[mod(v, NV) * NU + mod(u, NU)];\n// Segment 2s runs from site s down-right, 2s + 1 up-right, 8 LED steps each.\n// A site's four ports: 0 up-left, 1 up-right, 2 down-left, 3 down-right.\nconst PORT = new Int16Array(NS * 4);\nfor (let s = 0; s \u003c NS; s++) {\n  const u = SU[s], v = SV[s];\n  PORT[s * 4] = 2 * siteAt(u - 1, v - 1);\n  PORT[s * 4 + 1] = 2 * s + 1;\n  PORT[s * 4 + 2] = 2 * siteAt(u - 1, v + 1) + 1;\n  PORT[s * 4 + 3] = 2 * s;\n}\n// Which port pairs with which: a crossing goes straight on, a mirror lying\n// across the panel (kind 1) sends the ray back up or down, a mirror\n// standing up (kind 2) back left or right.\nconst PAIR = [[3, 2, 1, 0], [1, 0, 3, 2], [2, 3, 0, 1]];\n// The far end of segment k: its site and the port it arrives at.\nconst segEnd = (k) => {\n  const s = k >> 1, up = k & 1;\n  return [siteAt(SU[s] + 1, SV[s] + (up ? -1 : 1)), up ? 2 : 0];\n};\n\n// Strand hues. After a change each strand keeps the hue it shares most\n// segments with, and a new strand takes one that no other strand holds.\nconst PAL = [0.56, 0.12, 0.34, 0.84, 0.47, 0.7, 0.2, 0.92];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, share: 0.5, join: 0.06, target: 8, clock: 0,\n    kind: new Int8Array(NS), comp: new Int16Array(NS * 2), slot: new Int8Array(NS * 2),\n    hA: new Float32Array(NS * 2), hB: new Float32Array(NS * 2), t0: new Float32Array(NS * 2),\n    ox: 0, oy: 0, panT: 0, evT: 0, fresh: true, comps: 0, frame: 0, saved: null,\n    R: new Uint8Array(N), G: new Uint8Array(N), B: new Uint8Array(N), c: [0, 0, 0],\n  };\n}\n\nfunction mirrorCount(S) {\n  let m = 0;\n  for (let s = 0; s \u003c NS; s++) if (S.kind[s]) m++;\n  return m;\n}\n\n// Union the two segments each site joins; the classes are the closed\n// components of the curve.\nfunction components(S) {\n  const P = new Int16Array(NS * 2);\n  for (let i = 0; i \u003c P.length; i++) P[i] = i;\n  const find = (a) => {\n    while (P[a] !== a) a = P[a] = P[P[a]];\n    return a;\n  };\n  for (let s = 0; s \u003c NS; s++) {\n    const pr = PAIR[S.kind[s]];\n    for (let a = 0; a \u003c 4; a++)\n      if (pr[a] > a) {\n        const x = find(PORT[s * 4 + a]), y = find(PORT[s * 4 + pr[a]]);\n        if (x !== y) P[x] = y;\n      }\n  }\n  const id = new Int16Array(NS * 2).fill(-1);\n  let n = 0;\n  for (let k = 0; k \u003c NS * 2; k++) {\n    const r = find(k);\n    if (id[r] \u003c 0) id[r] = n++;\n    S.comp[k] = id[r];\n  }\n  S.comps = n;\n  return n;\n}\n\n// After a change, each new component keeps the colour slot it shares most\n// segments with, biggest overlap first; the rest take free slots. Segments\n// whose slot changed take the new hue as a wave running out from the\n// changed sites along the strand.\nfunction recolour(S, from) {\n  const n = components(S), K = PAL.length;\n  const cnt = new Int32Array(n * K);\n  for (let k = 0; k \u003c NS * 2; k++) cnt[S.comp[k] * K + S.slot[k]]++;\n  const order = [];\n  for (let i = 0; i \u003c n * K; i++) if (cnt[i]) order.push(i);\n  order.sort((a, b) => cnt[b] - cnt[a]);\n  const got = new Int8Array(n).fill(-1), used = new Int16Array(K);\n  for (const i of order) {\n    const c = floor(i / K), sl = i % K;\n    if (got[c] \u003c 0 && !used[sl]) (got[c] = sl), used[sl]++;\n  }\n  for (let c = 0; c \u003c n; c++)\n    if (got[c] \u003c 0) {\n      let best = 0;\n      for (let sl = 1; sl \u003c K; sl++) if (used[sl] \u003c used[best]) best = sl;\n      got[c] = best;\n      used[best]++;\n    }\n  // Distance along the curve from the changed sites, in segments.\n  const dist = new Int16Array(NS * 2).fill(-1), q = [];\n  for (const s of from)\n    for (let a = 0; a \u003c 4; a++) {\n      const k = PORT[s * 4 + a];\n      if (dist[k] \u003c 0) (dist[k] = 0), q.push(k);\n    }\n  for (let i = 0; i \u003c q.length; i++) {\n    const k = q[i];\n    const ends = [[k >> 1, k & 1 ? 1 : 3], segEnd(k)];\n    for (const [s, a] of ends) {\n      const j = PORT[s * 4 + PAIR[S.kind[s]][a]];\n      if (dist[j] \u003c 0) (dist[j] = dist[k] + 1), q.push(j);\n    }\n  }\n  for (let k = 0; k \u003c NS * 2; k++) {\n    const sl = got[S.comp[k]];\n    if (S.fresh) {\n      S.hA[k] = S.hB[k] = PAL[sl];\n    } else if (sl !== S.slot[k]) {\n      S.hA[k] = hueNow(S, k);\n      S.hB[k] = PAL[sl];\n      S.t0[k] = S.clock + 0.06 * max(0, dist[k]);\n    }\n    S.slot[k] = sl;\n  }\n}\n\nfunction hueNow(S, k) {\n  const a = cl((S.clock - S.t0[k]) / 0.12, 0, 1);\n  let dh = S.hB[k] - S.hA[k];\n  dh -= round(dh);\n  return S.hA[k] + dh * a;\n}\n\nfunction pick(S, want) {\n  // Random site of the wanted kind (mirror or crossing).\n  let s;\n  do s = floor(random() * NS);\n  while (want ? !S.kind[s] : S.kind[s]);\n  return s;\n}\n\nfunction setMirrors(S, M) {\n  let m = mirrorCount(S);\n  const ch = [];\n  while (m \u003c M) {\n    const s = pick(S, false);\n    S.kind[s] = 1 + floor(random() * 2);\n    ch.push(s);\n    m++;\n  }\n  while (m > M) {\n    const s = pick(S, true);\n    S.kind[s] = 0;\n    ch.push(s);\n    m--;\n  }\n  return ch;\n}\n\nfunction propose(S) {\n  // Half the time a mirror turns a quarter turn; otherwise it moves to a\n  // free crossing. Either way the count of mirrors stays.\n  if (random() \u003c 0.5 || mirrorCount(S) === NS) {\n    const s = pick(S, true);\n    return [[s, 3 - S.kind[s]]];\n  }\n  const a = pick(S, true), b = pick(S, false);\n  return [[b, 1 + floor(random() * 2)], [a, 0]];\n}\n\n// How far the link is from what the walk wants: the wanted number of\n// strands first, then no strand much longer than the others.\nfunction score(S) {\n  const n = components(S), len = new Int16Array(n);\n  let big = 0;\n  for (let k = 0; k \u003c NS * 2; k++) big = max(big, ++len[S.comp[k]]);\n  return 200 * Math.abs(n - S.target) + big;\n}\n\nfunction event(S) {\n  // A change that leaves the link further from that is made only when 24\n  // tries find nothing better.\n  const now = score(S);\n  let best = null, bestD = 1e9;\n  for (let tries = 0; tries \u003c 24; tries++) {\n    const ch = propose(S), old = ch.map(([s]) => S.kind[s]);\n    for (const [s, kd] of ch) S.kind[s] = kd;\n    const dd = score(S) - now;\n    ch.forEach(([s], i) => (S.kind[s] = old[i]));\n    if (dd \u003c= 4) {\n      best = ch;\n      break;\n    }\n    if (dd \u003c bestD) (bestD = dd), (best = ch);\n  }\n  for (const [s, kd] of best) S.kind[s] = kd;\n  recolour(S, best.map(([s]) => s));\n}\n\n// The seam of the torus, where column 0 meets column 63 and row 0 meets\n// row 127. Mirrors along all twelve of its sites make the board a framed\n// 4 x 8 rectangle, and a framed board with no other mirror is drawn by\n// gcd(4, 8) = 4 strands.\nconst SEAM = [];\nfor (let s = 0; s \u003c NS; s++) if (SU[s] === 0 || SV[s] === 0) SEAM.push(s);\n\nfunction frame(S, on) {\n  if (on) {\n    S.saved = S.kind.slice();\n    S.kind.fill(0);\n    for (const s of SEAM) S.kind[s] = SU[s] === 0 ? 2 : 1;\n    S.ox = S.oy = 0;\n    S.frame = 4;\n    recolour(S, SEAM);\n  } else if (S.saved) {\n    S.kind.set(S.saved);\n    S.saved = null;\n    S.frame = 0;\n    recolour(S, SEAM);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.share = cl(k[2], 0.5, 1);\n  S.join = cl(k[3], 0, 1);\n  S.target = round(8 - 7 * S.join);\n  const ds = (d * S.speed) / 2;\n  S.clock += ds;\n  if (input.btnPressed && input.btnPressed[2]) frame(S, S.frame \u003c= 0);\n  if (S.frame > 0) {\n    S.frame -= d;\n    if (S.frame \u003c= 0) frame(S, false);\n    return;\n  }\n  const M = round(S.share * NS);\n  if (mirrorCount(S) !== M) {\n    const ch = setMirrors(S, M);\n    recolour(S, ch);\n  }\n  if (S.fresh) {\n    // Open on a board the walk has already brought to its strand count.\n    for (let i = 0; i \u003c 80; i++) event(S);\n    S.fresh = false;\n  }\n  // The board is a torus exactly the panel's size, so a step of one LED\n  // right and one down keeps every lit LED on the even class.\n  S.panT += ds * 1.5;\n  while (S.panT >= 1) {\n    S.panT -= 1;\n    S.ox = (S.ox + 1) % W;\n    S.oy = (S.oy + 1) % H;\n  }\n  S.evT += ds * 1.2;\n  while (S.evT >= 1) {\n    S.evT -= 1;\n    event(S);\n  }\n}\n\nfunction put(S, x, y, h, sat) {\n  const c = S.c, p = mod(y, H) * W + mod(x, W);\n  hsv(h, sat, 1, c);\n  S.R[p] = round(c[0] * 255);\n  S.G[p] = round(c[1] * 255);\n  S.B[p] = round(c[2] * 255);\n}\nfunction dim(S, x, y) {\n  const p = mod(y, H) * W + mod(x, W);\n  S.R[p] = S.G[p] = S.B[p] = 40;\n}\n// The field shades the faces of the diagram in two colours, blue round\n// the dots and violet round the cell corners. A mirror only ever joins two\n// faces of the same colour, so the checkerboard holds whatever the mirrors do.\nfunction bg(S, x, y) {\n  x = mod(x, W);\n  y = mod(y, H);\n  const p = y * W + x, c = S.c;\n  if ((x + y) & 1) {\n    S.R[p] = S.G[p] = S.B[p] = 0;\n    return;\n  }\n  const dx = (x & 15) - 8, dy = (y & 15) - 8;\n  const inDot = (dx \u003c 0 ? -dx : dx) + (dy \u003c 0 ? -dy : dy) \u003c 8;\n  hsv(inDot ? 0.62 : 0.76, inDot ? 0.7 : 0.5, 1, c);\n  S.R[p] = round(c[0] * 40);\n  S.G[p] = round(c[1] * 40);\n  S.B[p] = round(c[2] * 40);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) bg(S, x, y);\n  const hu = S.hue;\n  // Strands.\n  for (let k = 0; k \u003c NS * 2; k++) {\n    const s = k >> 1, dv = k & 1 ? -1 : 1, h = hu + hueNow(S, k);\n    for (let t = 1; t \u003c 8; t++) put(S, SU[s] * HC + t, SV[s] * HC + dv * t, h, 1);\n  }\n  for (let s = 0; s \u003c NS; s++) {\n    const x = SU[s] * HC, y = SV[s] * HC, kd = S.kind[s];\n    if (kd === 0) {\n      // Alternating: at a site on a vertical cell edge (u even) the\n      // down-right strand goes over, on a horizontal edge the up-right one.\n      const d1 = (SU[s] & 1) === 0;\n      const ov = PORT[s * 4 + (d1 ? 3 : 1)];\n      put(S, x, y, hu + hueNow(S, ov), 1);\n      for (let t = 1; t \u003c= 2; t++) {\n        if (d1) bg(S, x + t, y - t), bg(S, x - t, y + t);\n        else bg(S, x + t, y + t), bg(S, x - t, y - t);\n      }\n    } else {\n      // Each pair of arms turns back two LEDs short of the mirror over a flat\n      // end of three LEDs, and the mirror is a white LED at the site with a\n      // grey one, at the field's level, each side of it.\n      const ax = kd === 1 ? 2 : 0, ay = 2 - ax;\n      bg(S, x - 1, y - 1), bg(S, x + 1, y - 1), bg(S, x - 1, y + 1), bg(S, x + 1, y + 1);\n      put(S, x - ay, y - ax, hu + hueNow(S, PORT[s * 4]), 1);\n      put(S, x + ay, y + ax, hu + hueNow(S, PORT[s * 4 + 3]), 1);\n      put(S, x, y, 0, 0);\n      dim(S, x - ax, y - ay);\n      dim(S, x + ax, y + ay);\n    }\n  }\n  // Dots at the cell centres.\n  for (let v = 1; v \u003c NV; v += 2) for (let u = 1; u \u003c NU; u += 2) put(S, u * HC, v * HC, 0, 0);\n  for (let y = 0; y \u003c H; y++) {\n    const sy = mod(y - S.oy, H) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const p = sy + mod(x - S.ox, W);\n      display.setPixel(x, y, S.R[p], S.G[p], S.B[p]);\n    }\n  }\n}\n","print-gallery":"// ===== Patternflow pattern =====\n// Title:   Print Gallery\n// Family:  fractal\n// Idea:    A checker of square rings in four to eight colours, which holds itself scaled down by s, is seen through de Smit and Lenstra's map, log z divided by 2 pi i / (2 pi i + log s), so its nested copies join into spiral arms and its white frame into one spiral line, and an endless zoom turns the panel round and in until after one period it shows the same picture to the last LED.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the conformal map behind M. C. Escher's Print Gallery (Bart de Smit and Hendrik Lenstra, 2003), the Droste effect, pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=16..256, Unwind=0..1\n//\n// Knob 1: Hue. Turns the ring colours round the wheel together, each ring a light cell beside a dark one. At 0 and Scale 16 the four rings run aqua, azure, violet and magenta; at 0.5 pink, red, green and sea green. The wheel skips dim orange, which reads brown.\n// Knob 2: Speed. The zoom passes one ring of the base, a factor 2, every 1.4 seconds at 2, so one period at Scale 16 takes 5.6 seconds and at 256 takes 11.2; 0.2 is ten times slower, 3 one and a half times faster.\n// Knob 3: Scale. The Droste factor s, snapped to 16, 32, 64, 128 or 256: the base holds 4 to 8 rings before it repeats, and they become as many spiral arms. One period of the twisted picture is a zoom of 10.2 with a turn of 59 degrees at 16, 18.0 and 110 degrees at 64, and 22.6 and 158 degrees at 256, the factor Escher drew.\n// Knob 4: Unwind. Undoes the twist. Up to 0.1 the map is Escher's, from 0.9 the panel shows the plain Droste picture of nested squares, and in between the picture tears along the ray left of the centre, where the rings fail to meet by s to the power of the twist: at Scale 16 and 0.5 the two sides are two rings apart.\n\nconst W = 64, H = 128;\nconst { floor, max, exp, log, sqrt, cos, sin, atan2, abs, round, PI, LN2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The base picture is a Droste picture: square rings, each twice the size of\n// the one inside it, the ring between half-sides 2^j and 2^(j+1) a checker of\n// cells 2^(j-1) wide with dark grout between them. Ring j takes colour j mod\n// m, and ring 0 has a white frame round its inside, so the picture holds\n// itself scaled by 1/s, s = 2^m, and by no smaller factor. f(z) = f(z / s):\n// in w = log z it is periodic under the lattice Z log s + Z 2 pi i.\n// The twisted picture shows f(exp(w / beta)), beta = 2 pi i / (2 pi i + log s),\n// so 1 / beta = 1 - i log s / (2 pi). Then 2 pi i / beta = log s + 2 pi i is\n// a lattice vector and the picture is single-valued: once round the centre\n// takes a ring to the same-coloured ring s times bigger, and the m rings of\n// a period join into m spiral arms. Between 1 and 1 / beta the seam along the\n// cut, the ray to the left of the centre, does not close.\n\n// Each subsample's log-polar place, fixed: ln r in LEDs and the angle. Out\n// past 20 LEDs from the centre a cell is 7 LEDs or more and 2 x 2 samples\n// clean its edges; inside, where the rings shrink, 3 x 3.\nconst START = new Int32Array(W * H + 1), FP = new Float32Array(W * H);\nconst LRa = [], THa = [];\nfor (let y = 0, p = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++, p++) {\n    const dx = x + 0.5 - 32, dy = y + 0.5 - 64, r = sqrt(dx * dx + dy * dy);\n    const ss = r \u003c 20 ? 3 : 2;\n    START[p] = LRa.length;\n    for (let j = 0; j \u003c ss; j++)\n      for (let i = 0; i \u003c ss; i++) {\n        const ex = x + (i + 0.5) / ss - 32, ey = y + (j + 0.5) / ss - 64;\n        LRa.push(0.5 * log(ex * ex + ey * ey + 1e-9));\n        THa.push(atan2(ey, ex));\n      }\n    // 1 / r: how far one LED reaches in log z.\n    FP[p] = 1 / max(r, 1e-3);\n  }\nSTART[W * H] = LRa.length;\nconst LR = Float32Array.from(LRa), TH = Float32Array.from(THa);\n\n// Dim orange reads brown on the panel, so the wheel skips 0.03 to 0.16.\nfunction hsv(h, s, v, out, o) {\n  h = 0.16 + 0.87 * (h - 0.16 - floor(h - 0.16));\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, m: 4, tw: 1, zoom: 0, pal: new Float32Array(9 * 3 * 3), palKey: \"\", mean: [0, 0, 0] };\n}\n\n// The twist for Unwind u: 1 (Escher's map) up to 0.1, 0 (the plain Droste\n// picture) from 0.9, straight between.\nconst twistOf = (u) => 1 - cl((u - 0.1) / 0.8, 0, 1);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // s snaps to a power of two: m rings to a period.\n  S.m = cl(round(Math.log2(cl(k[2], 16, 256))), 4, 8);\n  S.tw = twistOf(cl(k[3], 0, 1));\n  // One ring of the base, a factor 2, every 1.4 s at Speed 2. zoom runs\n  // down, so the base point under each LED moves inward: the panel zooms in.\n  S.zoom -= (d * S.speed * LN2) / 2.8;\n  const L = S.m * LN2;\n  if (S.zoom \u003c -L) S.zoom += L;\n}\n\n// Palette: per ring colour, light cell, dark cell, frame.\nfunction palette(S) {\n  const key = S.hue.toFixed(4) + \",\" + S.m;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const m = S.m, P = S.pal;\n  let r = 0, g = 0, b = 0;\n  for (let j = 0; j \u003c m; j++) {\n    const h = S.hue + 0.5 + (0.62 * j) / m;\n    hsv(h, 0.72, 1, P, j * 9);\n    hsv(h + 0.03, 0.9, 0.3, P, j * 9 + 3);\n    hsv(h, 0.12, 1, P, j * 9 + 6);\n    r += (P[j * 9] + P[j * 9 + 3]) / (2 * m);\n    g += (P[j * 9 + 1] + P[j * 9 + 4]) / (2 * m);\n    b += (P[j * 9 + 2] + P[j * 9 + 5]) / (2 * m);\n  }\n  // Grout covers a sixth of the base.\n  S.mean = [0.83 * r, 0.83 * g, 0.83 * b];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  // 1 / beta = 1 - i c1, c1 = log s / (2 pi) at full twist.\n  const m = S.m, L = m * LN2, c1 = (S.tw * L) / (2 * PI), P = S.pal, zoom = S.zoom;\n  // |1 / beta|: how much the map stretches log z.\n  const na = sqrt(1 + c1 * c1), mean = S.mean;\n  for (let p = 0; p \u003c W * H; p++) {\n    // Near the centre one LED covers more of the base than its samples can\n    // hold, so it fades to the picture's mean colour.\n    const fp = FP[p] * na, keep = cl((0.3 - fp) / 0.15, 0, 1);\n    let r = 0, g = 0, b = 0;\n    if (keep > 0) {\n      const q0 = START[p], q1 = START[p + 1];\n      for (let q = q0; q \u003c q1; q++) {\n        // w / beta = (1 - i c1)(ln r + i theta), and the zoom.\n        const lr = LR[q], th = TH[q];\n        let re = lr + c1 * th + zoom;\n        const im = th - c1 * lr;\n        // Reduce to the ring: re mod ln 2, then the square norm into [1, 2).\n        let j = floor(re / LN2);\n        re -= j * LN2;\n        const e = exp(re), X = e * cos(im), Y = e * sin(im);\n        let ax = abs(X), ay = abs(Y), n = ax > ay ? ax : ay;\n        if (n \u003c 1) (ax *= 2), (ay *= 2), (n *= 2), j--;\n        else if (n >= 2) (ax *= 0.5), (ay *= 0.5), (n *= 0.5), j++;\n        const c = ((j % m) + m) % m;\n        const gx = ax * 2, gy = ay * 2, fx = gx - floor(gx), fy = gy - floor(gy);\n        let o = -1;\n        if (c === 0 && n \u003c 1.07) o = c * 9 + 6;\n        else if (fx > 0.045 && fx \u003c 0.955 && fy > 0.045 && fy \u003c 0.955)\n          o = c * 9 + (((floor(gx) + floor(gy) + (X \u003c 0) + (Y \u003c 0)) & 1) ? 3 : 0);\n        if (o >= 0) (r += P[o]), (g += P[o + 1]), (b += P[o + 2]);\n      }\n      const inv = 1 / (q1 - q0);\n      r *= inv;\n      g *= inv;\n      b *= inv;\n    }\n    const f = 1 - keep;\n    r = r * keep + mean[0] * f;\n    g = g * keep + mean[1] * f;\n    b = b * keep + mean[2] * f;\n    display.setPixel(p % W, (p / W) | 0, round(r * 255), round(g * 255), round(b * 255));\n  }\n}\n","rayleigh-taylor":"// ===== Patternflow pattern =====\n// Title:   Rayleigh-Taylor\n// Family:  sim\n// Idea:    A heavy fluid rests on a light one across the middle of the panel, and the faint ripple on the line between them grows until heavy fingers fall to the bottom with mushroom caps that curl at their rims while light bubbles rise to the top, the two fluids churning into each other until a fresh layer settles in.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rayleigh-Taylor instability (Lord Rayleigh, 1883; G. I. Taylor, 1950), Boussinesq vorticity-streamfunction flow, pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Modes=3..9, Viscosity=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the heavy fluid is orchid violet, the light fluid dark teal, fluid mixed half and half azure, and the sharp line between them pale lilac; at 0.25 orange over indigo through purple, at 0.5 green over dark magenta through red, at 0.75 sky blue over dark green through green. The light fluid and the mixture skip the orange and yellow part of the wheel, which reads brown and olive when dim.\n// Knob 2: Speed. At 2 the opening ripple grows by e every 0.54 s, the mushroom caps curl over about 3 s into a layer, the heavy fingers reach the floor and the light bubbles the lid between 5 and 6.5 s, and at 8.6 s the churned column fades over 1 s into a fresh layer. At 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Modes. How many half waves of the first ripple fit across the box, 3 to 9, rounded; each layer also carries the next wave up and the next down at under a third of the size, so the fingers come out unequal. At 3 two heavy fingers fall and two light bubbles rise, 43 LEDs apart, one of each against a wall; at 9 five thin ones of each, 14 LEDs apart. The shorter waves grow faster, by e in 0.54 s at 3, 0.41 s at 6 and 0.37 s at 9, where the square root of A g k alone would give 0.49, 0.35 and 0.28 s: the line between the fluids is 2 LEDs thick, which slows a short wave more than a long one. A new value starts a fresh layer.\n// Knob 4: Viscosity. nu = 0.1 x 400^K4 LEDs squared a second, and the density diffuses at a quarter of that plus 0.05: nu is 0.14 at the opening 0.06, 2 at 0.5 and 40 at 1. At the opening the caps roll up into tight curls and the stems shed small ones; at 0.5 the fingers fall as smooth tongues with one curl each; at 1 a ripple of three half waves grows by e only every 1.3 s, one of six dies away, and soft blurred fingers sag into each other.\n// Buttons: K1 tap starts a fresh layer.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sin, cos, sqrt, round, abs, tanh, random, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: one LED and one second at Speed 2. G is the reduced gravity A g,\n// in LEDs per second squared; the heavy fluid is rho = +1, the light -1.\nconst G = 28;\nconst Y0 = 63.5, DELTA = 1, A0 = 0.25;\nconst CYCLE = 8.6, FADE = 1;\nconst NU0 = 0.1, NUR = 400;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The box has free-slip walls on all four sides: the side walls at column\n// 0 and at column 64, one past the panel's edge, the floor and the lid one\n// row outside the panel, at rows -1 and 128. The streamfunction and the\n// vorticity are zero on every wall, so across the panel both are sums of\n// sin(pi k x / 64), k = 1..63, and a sine transform of each row turns the\n// Poisson equation into one tridiagonal solve down the panel per k. The\n// transform is a complex FFT of length 128 over the row and its mirror\n// image turned upside down, two rows at a time.\nconst NF = 128, LOGF = 7, K = 63;\nconst REV = new Uint8Array(NF), CS = new Float64Array(NF / 2), SN = new Float64Array(NF / 2);\nfor (let i = 0; i \u003c NF; i++) {\n  let r = 0;\n  for (let b = 0; b \u003c LOGF; b++) r |= ((i >> b) & 1) \u003c\u003c (LOGF - 1 - b);\n  REV[i] = r;\n}\nfor (let i = 0; i \u003c NF / 2; i++) (CS[i] = cos((TAU * i) / NF)), (SN[i] = -sin((TAU * i) / NF));\nfunction fft(re, im) {\n  for (let i = 0; i \u003c NF; i++) {\n    const j = REV[i];\n    if (j > i) {\n      let t = re[i];\n      (re[i] = re[j]), (re[j] = t);\n      t = im[i];\n      (im[i] = im[j]), (im[j] = t);\n    }\n  }\n  for (let size = 2; size \u003c= NF; size \u003c\u003c= 1) {\n    const half = size >> 1, step = NF / size;\n    for (let s = 0; s \u003c NF; s += size)\n      for (let k = 0; k \u003c half; k++) {\n        const wr = CS[k * step], wi = SN[k * step], a = s + k, b = a + half;\n        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;\n        (re[b] = re[a] - xr), (im[b] = im[a] - xi);\n        (re[a] += xr), (im[a] += xi);\n      }\n  }\n}\n\n// The sine transform S_k = sum_x f_x sin(pi k x / 64), k = 1..63, of each\n// row of f into column k of R (R[k H + y]). An odd sequence's FFT is -2i\n// times its sine transform, so of two rows packed into one FFT, row y\n// comes out in the imaginary part and row y + 1 in the real part.\nfunction toModes(S, f, R) {\n  const { zr, zi } = S;\n  for (let y = 0; y \u003c H; y += 2) {\n    zr[0] = zi[0] = zr[64] = zi[64] = 0;\n    for (let x = 1, o = y * W + 1; x \u003c= K; x++, o++) {\n      const a = f[o], b = f[o + W];\n      (zr[x] = a), (zi[x] = b), (zr[NF - x] = -a), (zi[NF - x] = -b);\n    }\n    fft(zr, zi);\n    for (let k = 1; k \u003c= K; k++) (R[k * H + y] = -0.5 * zi[k]), (R[k * H + y + 1] = 0.5 * zr[k]);\n  }\n}\n// The transform is its own inverse but for a factor 2 / 64. Column 0 is\n// the side wall.\nfunction fromModes(S, R, f) {\n  const { zr, zi } = S;\n  for (let y = 0; y \u003c H; y += 2) {\n    zr[0] = zi[0] = zr[64] = zi[64] = 0;\n    for (let k = 1; k \u003c= K; k++) {\n      const a = R[k * H + y], b = R[k * H + y + 1];\n      (zr[k] = a), (zi[k] = b), (zr[NF - k] = -a), (zi[NF - k] = -b);\n    }\n    fft(zr, zi);\n    f[y * W] = f[(y + 1) * W] = 0;\n    for (let x = 1, o = y * W + 1; x \u003c= K; x++, o++) (f[o] = -zi[x] / 64), (f[o + W] = zr[x] / 64);\n  }\n}\n\n// Solves (b - D2) out = rhs * scale down column o of the modes, D2 the\n// second difference in y, with out = 0 on the walls at rows -1 and 128.\nfunction tri(S, R, o, b, scale) {\n  const { cp, dp } = S, diag = b + 2;\n  for (let y = 0; y \u003c H; y++) {\n    const den = diag + (y ? cp[y - 1] : 0);\n    cp[y] = -1 / den;\n    dp[y] = (R[o + y] * scale + (y ? dp[y - 1] : 0)) / den;\n  }\n  R[o + H - 1] = dp[H - 1];\n  for (let y = H - 2; y >= 0; y--) R[o + y] = dp[y] - cp[y] * R[o + y + 1];\n}\n\nexport function setup(params) {\n  const f = () => new Float64Array(NP);\n  params.s = {\n    w: f(), r: f(), psi: f(), u: f(), v: f(), wa: f(), ra: f(), wb: f(), rb: f(), tmp: f(),\n    DX: new Float32Array(NP), DY: new Float32Array(NP), WR: f(), PR: f(),\n    zr: new Float64Array(NF), zi: new Float64Array(NF), cp: new Float64Array(H), dp: new Float64Array(H),\n    t: 0, total: 0, fade: 0, old: new Float32Array(NP * 3), rgb: new Float32Array(NP * 3), started: false,\n    hue: 0, speed: 2, modes: 3, layer: 3, nu: 0.2, kappa: 0.1, col: new Float32Array(12),\n  };\n}\n\n// A fresh layer: heavy over light across row Y0, the line between them a\n// smooth step DELTA LEDs thick, rippled by cos(pi m x / 64), the wave that\n// meets both side walls square, for the chosen m, and fainter by m - 1\n// and m + 1 so the fingers come out unequal.\nfunction fresh(S) {\n  const { w, r, psi, u, v } = S, m0 = (S.layer = S.modes);\n  const waves = [[m0, A0 * (random() \u003c 0.5 ? -1 : 1)]];\n  for (const m of [m0 - 1, m0 + 1]) waves.push([m, A0 * 0.3 * (2 * random() - 1)]);\n  for (let x = 0; x \u003c W; x++) {\n    let yi = Y0;\n    for (const [m, a] of waves) yi += a * cos((PI * m * x) / 64);\n    for (let y = 0; y \u003c H; y++) r[y * W + x] = tanh((yi - y) / DELTA);\n  }\n  w.fill(0);\n  psi.fill(0);\n  u.fill(0);\n  v.fill(0);\n  S.total = r.reduce((a, b) => a + b, 0);\n  S.t = 0;\n}\n\n// Two fields sampled bilinearly at one point, both ways held inside the\n// panel, into PAIR.\nconst PAIR = new Float64Array(2);\nfunction pair(f, g, x, y) {\n  x = x \u003c 0 ? 0 : x > W - 1 ? W - 1 : x;\n  y = y \u003c 0 ? 0 : y > H - 1 ? H - 1 : y;\n  const xf = min(floor(x), W - 2), yf = min(floor(y), H - 2), fx = x - xf, fy = y - yf, o = yf * W + xf;\n  const w00 = (1 - fx) * (1 - fy), w10 = fx * (1 - fy), w01 = (1 - fx) * fy, w11 = fx * fy;\n  PAIR[0] = w00 * f[o] + w10 * f[o + 1] + w01 * f[o + W] + w11 * f[o + W + 1];\n  PAIR[1] = w00 * g[o] + w10 * g[o + 1] + w01 * g[o + W] + w11 * g[o + W + 1];\n}\n\n// MacCormack advection of vorticity and density: a semi-Lagrangian step\n// back along the flow (midpoint rule), one forward again to see what it\n// lost, half that put back, and the result held inside the four values\n// it came from.\nfunction advect(S, dt) {\n  const { w, r, u, v, wa, ra, wb, rb, DX, DY } = S, hd = 0.5 * dt;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      pair(u, v, x - hd * u[p], y - hd * v[p]);\n      const dx = cl(x - dt * PAIR[0], 0, W - 1), dy = cl(y - dt * PAIR[1], 0, H - 1);\n      (DX[p] = dx), (DY[p] = dy);\n      pair(w, r, dx, dy);\n      (wa[p] = PAIR[0]), (ra[p] = PAIR[1]);\n    }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      pair(u, v, x + hd * u[p], y + hd * v[p]);\n      pair(wa, ra, x + dt * PAIR[0], y + dt * PAIR[1]);\n      (wb[p] = PAIR[0]), (rb[p] = PAIR[1]);\n    }\n  for (let p = 0; p \u003c NP; p++) {\n    const o = min(floor(DY[p]), H - 2) * W + min(floor(DX[p]), W - 2);\n    let lo = min(w[o], w[o + 1], w[o + W], w[o + W + 1]), hi = max(w[o], w[o + 1], w[o + W], w[o + W + 1]);\n    wb[p] = cl(wa[p] + 0.5 * (w[p] - wb[p]), lo, hi);\n    lo = min(r[o], r[o + 1], r[o + W], r[o + W + 1]);\n    hi = max(r[o], r[o + 1], r[o + W], r[o + W + 1]);\n    rb[p] = cl(ra[p] + 0.5 * (r[p] - rb[p]), lo, hi);\n  }\n  w.set(wb);\n  r.set(rb);\n}\n\n// One step of the flow:\n//   w_t + u . grad w = A g d(rho)/dx + nu lap w,   lap psi = -w,\n//   rho_t + u . grad rho = kappa lap rho,\n// with y pointing down the panel, the way gravity pulls, u = d psi / dy\n// and v = -d psi / dx. Advection first, then the kick the moved density\n// gives the vorticity, which makes the step a symplectic Euler step of the\n// growing wave, then the density's diffusion, then viscosity and the\n// Poisson solve, both in the sine modes across the panel.\nfunction step(S, dt) {\n  const { w, r, psi, u, v, tmp, WR, PR } = S;\n  advect(S, dt);\n  // Buoyancy.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) w[p] += dt * G * 0.5 * (r[x \u003c W - 1 ? p + 1 : p] - r[x > 0 ? p - 1 : p + 1]);\n  // The density's diffusion, with no flux through the walls, in as many\n  // explicit steps as keep it stable.\n  const kd = S.kappa * dt, n = Math.ceil(kd / 0.2), kap = kd / n;\n  for (let i = 0; i \u003c n; i++) {\n    for (let y = 0, p = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++, p++) {\n        const sum = r[x > 0 ? p - 1 : p + 1] + r[x \u003c W - 1 ? p + 1 : p] + r[y > 0 ? p - W : p] + r[y \u003c H - 1 ? p + W : p];\n        tmp[p] = r[p] + kap * (sum - 4 * r[p]);\n      }\n    r.set(tmp);\n  }\n  // The MacCormack step does not keep the total of the density: over a\n  // cycle the heavy fluid would drift by 1 to 2%. What it gained or lost\n  // is handed back where the fluids meet, in proportion to 1 - rho^2, as\n  // Priestley's fixer does for semi-Lagrangian weather models.\n  let sum = 0, wt = 0;\n  for (let p = 0; p \u003c NP; p++) (sum += r[p]), (wt += 1 - r[p] * r[p]);\n  const fix = wt > 0 ? (S.total - sum) / wt : 0;\n  for (let p = 0; p \u003c NP; p++) r[p] += fix * (1 - r[p] * r[p]);\n  toModes(S, w, WR);\n  const nd = S.nu * dt;\n  for (let k = 1; k \u003c= K; k++) {\n    const k2 = 4 * sin((PI * k) / NF) ** 2, o = k * H;\n    // (1 - nu dt lap) w' = w, as (1 / (nu dt) + k2 - D2) w' = w / (nu dt).\n    tri(S, WR, o, k2 + 1 / nd, 1 / nd);\n    // -lap psi = w', as (k2 - D2) psi = w'.\n    for (let y = 0; y \u003c H; y++) PR[o + y] = WR[o + y];\n    tri(S, PR, o, k2, 1);\n  }\n  fromModes(S, WR, w);\n  fromModes(S, PR, psi);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const up = y > 0 ? psi[p - W] : 0, dn = y \u003c H - 1 ? psi[p + W] : 0;\n      const lf = x > 0 ? psi[p - 1] : -psi[p + 1], rt = x \u003c W - 1 ? psi[p + 1] : 0;\n      u[p] = 0.5 * (dn - up);\n      v[p] = -0.5 * (rt - lf);\n    }\n  S.t += dt;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.modes = cl(round(k[2]), 3, 9);\n  S.nu = NU0 * NUR ** cl(k[3], 0, 1);\n  S.kappa = 0.05 + S.nu / 4;\n  if (!S.started) {\n    fresh(S);\n    S.started = true;\n  }\n  const h = (d * S.speed) / 2;\n  if (S.t > CYCLE || S.modes !== S.layer || (input.btnPressed && input.btnPressed[0])) {\n    S.old.set(S.rgb);\n    S.fade = 1;\n    fresh(S);\n  }\n  S.fade = max(0, S.fade - h / FADE);\n  if (h > 0) step(S, h);\n}\n\n// Dim orange and yellow read brown and olive, so the light fluid's wheel\n// skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.col, h = S.hue, { r, w, rgb, old } = S, f = S.fade;\n  hsv(h + 0.8, 0.65, 0.82, c, 0); // heavy\n  hsv(wheel(h + 0.53), 0.8, 0.24, c, 3); // light\n  hsv(wheel(h + 0.66), 0.7, 0.5, c, 6); // half and half\n  hsv(h + 0.7, 0.12, 1, c, 9); // the sharp line between them\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      // The two fluids and their mixture on a ramp through a third hue,\n      // and where the density changes sharply, a pale line as a\n      // shadowgraph shows it; spinning fluid a little brighter.\n      const q = 0.5 * (1 + r[p]), a = q \u003c 0.5 ? 3 : 6, b = q \u003c 0.5 ? 6 : 0, t = q \u003c 0.5 ? 2 * q : 2 * q - 1;\n      const gx = r[x \u003c W - 1 ? p + 1 : p] - r[x > 0 ? p - 1 : p], gy = r[y \u003c H - 1 ? p + W : p] - r[y > 0 ? p - W : p];\n      const e = min(1, 0.6 * sqrt(gx * gx + gy * gy)), hl = e * e, vb = 1 + 0.03 * min(10, abs(w[p]));\n      for (let ch = 0; ch \u003c 3; ch++) {\n        const base = c[a + ch] + t * (c[b + ch] - c[a + ch]);\n        const val = min(1, (base * (1 - 0.6 * hl) + 0.75 * c[9 + ch] * hl) * vb) * 255;\n        rgb[p * 3 + ch] = f > 0 ? val * (1 - f) + old[p * 3 + ch] * f : val;\n      }\n      display.setPixel(x, y, round(rgb[p * 3]), round(rgb[p * 3 + 1]), round(rgb[p * 3 + 2]));\n    }\n}\n","tukey-depth":"// ===== Patternflow pattern =====\n// Title:   Tukey Depth\n// Family:  data\n// Idea:    Thirty drifting points colour every LED by its Tukey depth, the fewest of them in any closed half-plane holding it, so the cloud stands as nested convex polygons each one point deeper than the last, and every eight seconds two of the points fly 160 LEDs off the panel, pulling the outer polygons after them as wedges and the orange mean out of the core, while the white ring of the Tukey median, the centroid of the deepest polygon, barely moves.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: halfspace depth and the Tukey median (John W. Tukey, 1975), centerpoint theorem (Richard Rado, 1946), breakdown point of the Tukey median (David L. Donoho and Miriam Gasko, 1992), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Outliers=0..0.4\n//\n// Knob 1: Hue. Turns the regions' colours round the wheel together. At 0 they run from violet at the hull through blue to aqua at the deepest, and the mean is orange; at 0.25 from red through magenta and violet to a blue core, the mean green; at 0.5 from green through yellow and red to violet, the mean blue; at 0.75 from blue through teal and green to yellow, the mean pink. The points and the median's ring stay white.\n// Knob 2: Speed. At 2 each coordinate of a point is a sum of three sines with periods between 15 and 63 s, and an outing takes 8 s: the outliers fly out in 1.5 s, stay out 4.5 s while their group swings round the middle a quarter of a radian a second, and come back in 1.5 s; each new set leaves 137 degrees further round than the last. 0.2 is ten times slower, 3 one and a half times faster.\n// Knob 3: Points. 30 to 90 points. Each level is one point deeper, so the deepest region sits at depth 11 to 14 with 30 points, 25 to 28 with 60 and 38 to 42 with 90, never under the third of the points the centerpoint theorem promises (10, 20, 30), and the bands grow finer as the count rises.\n// Knob 4: Outliers. The share of the points that fly out each outing, rounded: 2 of 30 at the opening 0.06. They go 160 LEDs from the middle, well off the panel; with 2 of 30 the mean moves 11 LEDs on average and the median 2.6, and measured in the clean data the median keeps 89% of the deepest depth while the mean keeps 40%. At 0.2 (6 of 30) the mean moves 32 LEDs and the median 7. Past a third, the breakdown point, the median gives way too: at 0.34 (10 of 30) it moves 49 LEDs and at 0.4 it leaves the panel with the outliers. A mean dragged off the panel waits on its rim.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, round, ceil, PI } = Math;\nconst random = () => Math.random();\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst NMAX = 90;\n// One outing of the outliers, in T (seconds at Speed 2).\nconst OUT = 8;\n// How far out the outliers go: two and a half half-heights of the panel.\nconst FAR = 160;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const pts = [];\n  for (let i = 0; i \u003c NMAX; i++) {\n    // Each point's place in the cloud is three sines a coordinate at slow\n    // frequencies of its own, scaled to unit variance.\n    const f = [], ph = [];\n    for (let m = 0; m \u003c 6; m++) {\n      f.push(0.1 + 0.32 * random());\n      ph.push(2 * PI * random());\n    }\n    pts.push({ f, ph, w: 0, jx: 2 * PI * random(), jy: 2 * PI * random(), jf: 0.5 + 0.5 * random() });\n  }\n  params.s = {\n    hue: 0, speed: 2, n: 30, out: 0.06, T: 0, pts,\n    px: new Float64Array(NMAX), py: new Float64Array(NMAX),\n    depth: new Uint8Array(W * H), polys: [], kmax: 0,\n    mx: 32, my: 64, tx: 32, ty: 64, trail: new Float32Array(180).fill(-99), ti: 0, pal: new Float32Array(3 * 64), c: new Float32Array(3),\n  };\n}\n\n// Keep nx x + ny y \u003c= c of a convex polygon [x0, y0, x1, y1, ...].\nfunction clip(P, nx, ny, c) {\n  const out = [], m = P.length, eps = 1e-9 * (abs(nx) + abs(ny) + abs(c));\n  for (let i = 0; i \u003c m; i += 2) {\n    const j = (i + 2) % m, ax = P[i], ay = P[i + 1], bx = P[j], by = P[j + 1];\n    const da = nx * ax + ny * ay - c, db = nx * bx + ny * by - c;\n    if (da \u003c= eps) out.push(ax, ay);\n    if ((da \u003c -eps && db > eps) || (da > eps && db \u003c -eps)) {\n      const t = da / (da - db);\n      out.push(ax + t * (bx - ax), ay + t * (by - ay));\n    }\n  }\n  return out;\n}\n\n// A cheap hash of a point and an outing, 0..1, to choose who flies out.\nconst rank = (i, c) => {\n  const v = sin(i * 12.9898 + c * 78.233) * 43758.5453;\n  return v - floor(v);\n};\n\nfunction place(S) {\n  const { pts, px, py, n, T } = S;\n  // The cloud: an upright ellipse that sways a little.\n  const th = 0.3 * sin(0.13 * T), ct = cos(th), st = sin(th);\n  const cx = 32 + 2 * sin(0.21 * T + 1), cy = 64 + 4 * sin(0.17 * T);\n  // The outliers go out together every OUT seconds of T, a new set each\n  // time, FAR LEDs from the middle, well off the panel, drift round there\n  // and come back for the last quarter of the outing.\n  const c = floor(T / OUT), psi = 2.4 * c + 0.25 * (T - c * OUT);\n  const gx = 32 + FAR * cos(psi), gy = 64 + FAR * sin(psi);\n  const k = sqrt(2 / 3);\n  for (let i = 0; i \u003c n; i++) {\n    const p = pts[i];\n    let zx = 0, zy = 0;\n    for (let q = 0; q \u003c 3; q++) {\n      zx += sin(p.f[q] * T + p.ph[q]);\n      zy += sin(p.f[q + 3] * T + p.ph[q + 3]);\n    }\n    zx *= k * 10;\n    zy *= k * 19;\n    let x = cx + ct * zx - st * zy, y = cy + st * zx + ct * zy;\n    const w = p.w;\n    if (w > 0) {\n      const ox = gx + 4 * sin(p.jf * T + p.jx), oy = gy + 4 * sin(p.jf * T + p.jy);\n      const e = w * w * (3 - 2 * w);\n      x += e * (ox - x);\n      y += e * (oy - y);\n    }\n    px[i] = x;\n    py[i] = y;\n  }\n}\n\n// The regions {depth >= k}. A line through two data points with a points\n// strictly on one side and b on the other puts every LED strictly on the\n// a side at depth a or less, so {depth >= a + 1} lies in the closed other\n// side; {depth >= k} is exactly the intersection of all those half-planes,\n// one convex polygon for each k, each inside the one before.\nfunction regions(S) {\n  const { px, py, n } = S, half = n >> 1;\n  const lev = Array.from({ length: half + 2 }, () => []);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      const nx = py[i] - py[j], ny = px[j] - px[i], c0 = nx * px[i] + ny * py[i];\n      let a = 0, b = 0;\n      for (let k = 0; k \u003c n; k++) {\n        if (k === i || k === j) continue;\n        const s = nx * px[k] + ny * py[k] - c0;\n        if (s > 0) a++;\n        else if (s \u003c 0) b++;\n      }\n      if (a \u003c= b) lev[a + 1].push(nx, ny, c0);\n      if (b \u003c= a) lev[b + 1].push(-nx, -ny, -c0);\n    }\n  let P = [-500, -500, 600, -500, 600, 700, -500, 700];\n  const polys = [];\n  for (let k = 1; k \u003c= half + 1; k++) {\n    const L = lev[k];\n    for (let q = 0; q \u003c L.length && P.length; q += 3) P = clip(P, L[q], L[q + 1], L[q + 2]);\n    if (!P.length) break;\n    polys.push(P);\n  }\n  S.polys = polys;\n  S.kmax = polys.length;\n  // The Tukey median: the centroid of the deepest region.\n  const D = polys[polys.length - 1] || [32, 64];\n  let A = 0, gx = 0, gy = 0, vx = 0, vy = 0;\n  for (let i = 0; i \u003c D.length; i += 2) {\n    const j = (i + 2) % D.length, cr = D[i] * D[j + 1] - D[j] * D[i + 1];\n    A += cr;\n    gx += (D[i] + D[j]) * cr;\n    gy += (D[i + 1] + D[j + 1]) * cr;\n    vx += D[i];\n    vy += D[i + 1];\n  }\n  if (abs(A) > 1e-6) {\n    S.tx = gx / (3 * A);\n    S.ty = gy / (3 * A);\n  } else {\n    S.tx = vx / (D.length / 2);\n    S.ty = vy / (D.length / 2);\n  }\n  // Every LED's depth, row by row from the polygons.\n  const depth = S.depth;\n  depth.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5, row = y * W;\n    for (let k = 0; k \u003c polys.length; k++) {\n      const P = polys[k];\n      let lo = 1e9, hi = -1e9;\n      for (let i = 0; i \u003c P.length; i += 2) {\n        const j = (i + 2) % P.length, y1 = P[i + 1], y2 = P[j + 1];\n        if ((y1 \u003c= yc && yc \u003c y2) || (y2 \u003c= yc && yc \u003c y1)) {\n          const x = P[i] + ((yc - y1) * (P[j] - P[i])) / (y2 - y1);\n          if (x \u003c lo) lo = x;\n          if (x > hi) hi = x;\n        }\n      }\n      if (hi \u003c lo) break;\n      const x0 = max(0, ceil(lo - 0.5)), x1 = min(W - 1, floor(hi - 0.5));\n      for (let x = x0; x \u003c= x1; x++) depth[row + x] = k + 1;\n    }\n  }\n  let sx = 0, sy = 0;\n  for (let i = 0; i \u003c n; i++) {\n    sx += px[i];\n    sy += py[i];\n  }\n  S.mx = sx / n;\n  S.my = sy / n;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.n = round(cl(k[2], 30, 90));\n  S.out = cl(k[3], 0, 0.4);\n  S.T += d * S.speed * 0.5;\n  const m = round(S.out * S.n), c = floor(S.T / OUT), out = S.T / OUT - c \u003c 0.75;\n  // This outing's outliers: the m points of lowest rank.\n  const order = [];\n  for (let i = 0; i \u003c S.n; i++) order.push(i);\n  order.sort((a, b) => rank(a, c) - rank(b, c));\n  const want = new Uint8Array(NMAX);\n  if (out) for (let q = 0; q \u003c m; q++) want[order[q]] = 1;\n  // A point flies out or comes back over 1.5 s.\n  for (let i = 0; i \u003c NMAX; i++) {\n    const p = S.pts[i];\n    p.w = want[i] ? min(1, p.w + d * S.speed / 3) : max(0, p.w - d * S.speed / 3);\n  }\n  place(S);\n  regions(S);\n  S.ti = (S.ti + 1) % 90;\n  S.trail[2 * S.ti] = S.mx;\n  S.trail[2 * S.ti + 1] = S.my;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { depth, pal, n } = S, half = n / 2, h = S.hue;\n  // Level k: hue from violet at the hull to aqua at the deepest, brighter\n  // inwards. Each region's rim is at full, its fill at 59% on odd levels\n  // and 37% on even ones, so neighbouring levels always differ.\n  const K = S.kmax;\n  for (let k = 1; k \u003c= K; k++) {\n    const u = min(1, k / half);\n    hsv(wheel(0.95 + h - 0.5 * u), 0.85 - 0.35 * u, 0.5 + 0.5 * u, pal, 3 * k);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, k = depth[p];\n      if (!k) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      // An LED of {depth >= k} next to a shallower one is the polygon's rim.\n      const rim = (x > 0 && depth[p - 1] \u003c k) || (x \u003c W - 1 && depth[p + 1] \u003c k) || (y > 0 && depth[p - W] \u003c k) || (y \u003c H - 1 && depth[p + W] \u003c k);\n      const g = rim ? 255 : k & 1 ? 150 : 95;\n      display.setPixel(x, y, round(pal[3 * k] * g), round(pal[3 * k + 1] * g), round(pal[3 * k + 2] * g));\n    }\n  const c = S.c;\n  hsv(0.1 + h, 0.8, 1, c, 0);\n  const put = (x, y, r, g, b) => {\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, r, g, b);\n  };\n  // Where the mean has been over the last three seconds, fading.\n  const tr = S.trail, L = tr.length / 2;\n  for (let q = 0; q \u003c L; q++) {\n    const a = ((S.ti - q + L) % L) * 2, f = 1 - 0.75 * q / L;\n    if (tr[a] \u003c -50) continue;\n    put(floor(tr[a]), floor(tr[a + 1]), round(c[0] * 255 * f), round(c[1] * 255 * f), round(c[2] * 255 * f));\n  }\n  // The data: white dots.\n  for (let i = 0; i \u003c n; i++) put(floor(S.px[i]), floor(S.py[i]), 255, 255, 255);\n  // The mean: an orange plus with a black rim, held on the panel when the\n  // outliers drag it off.\n  const mx = cl(floor(S.mx), 2, W - 3), my = cl(floor(S.my), 2, H - 3);\n  for (const [dx, dy] of [[-3, 0], [3, 0], [0, -3], [0, 3], [-2, -1], [-2, 1], [2, -1], [2, 1], [-1, -2], [1, -2], [-1, 2], [1, 2], [-1, -1], [1, -1], [-1, 1], [1, 1]])\n    put(mx + dx, my + dy, 0, 0, 0);\n  for (const [dx, dy] of [[0, 0], [-1, 0], [1, 0], [0, -1], [0, 1], [-2, 0], [2, 0], [0, -2], [0, 2]])\n    put(mx + dx, my + dy, round(c[0] * 255), round(c[1] * 255), round(c[2] * 255));\n  // The Tukey median: a white ring with a black inside.\n  const tx = floor(S.tx), ty = floor(S.ty);\n  for (let dy = -3; dy \u003c= 3; dy++)\n    for (let dx = -3; dx \u003c= 3; dx++) {\n      const r = sqrt(dx * dx + dy * dy);\n      if (r > 1.9 && r \u003c 3.1) put(tx + dx, ty + dy, 255, 255, 255);\n      else if (r \u003c= 1.9) put(tx + dx, ty + dy, 0, 0, 0);\n    }\n}\n","bicycle-tracks":"// ===== Patternflow pattern =====\n// Title:   Bicycle Tracks\n// Family:  line\n// Idea:    A front point weaves up the tall panel with a rear point a fixed wheelbase behind it that always rolls straight at it, so the rear track cuts inside every turn of the front track, and a comb of segments from the rear track forward to the front one, each one wheelbase long and tangent to the rear track, fills the lunes between them and shows which way the bicycle went; every 34 seconds or so the rider rides two laps of a circle, the rear spirals onto the smaller circle the bicycle's monodromy holds, and it leaves straight up along a tractrix.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the tractrix (Claude Perrault's question, 1670; Christiaan Huygens, 1692) as the track of a bicycle's rear wheel, the tangent rule of \"Which Way Did the Bicycle Go?\" (Joseph Konhauser, Dan Velleman and Stan Wagon, 1996), and bicycle monodromy as a Möbius map (Robert Foote, 1998; Mark Levi and Serge Tabachnikov, 2009), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wheelbase=16..24, Bar=50..70\n//\n// Knob 1: Hue. Turns both tracks round the wheel together. At 0 the front track is rose and the rear track cyan, with each tangent segment fading from cyan at its rear end to rose at its front end; at 0.25 the front is green and the rear blue, at 0.5 azure and magenta, at 0.75 violet and green. The wheel skips orange and yellow, which read brown and olive on the dim segments.\n// Knob 2: Speed. The front point rides 13 LEDs a second times the knob: 26 at 2, where a weave of 37 to 50 rows passes in 2.2 to 3.7 seconds; 2.6 at 0.2 and 39 at 3. After 560 LEDs of weaving, 21.5 seconds at 2, the rider straightens up near one side and rides its loop, 10 to 15 seconds at 2.\n// Knob 3: Wheelbase. The fixed distance L between the two points, 16 to 24 LEDs, and the length of every tangent segment. The loop's radius is 1.3 L + 1 up to 28: at 16 the front circles on 21.8 and the rear settles on 14.8, at 24 the front on 28 and the rear on 14.4. A lune is widest where the bar is held, at L tan(bar / 2): 7.5 LEDs at 16 and 11.2 at 24, with the bar at 50 degrees.\n// Knob 4: Bar. The angle from the frame the rider holds the bar at through each turn, 50 to 70 degrees. While it is held the front runs on a circle of radius L / sin(bar) and the rear inside it on L / tan(bar), 1.31 L and 0.84 L at 50 degrees, 1.06 L and 0.36 L at 70. A weave (two turns) takes 45 rows at 50 degrees and 23 at 70, with L at 16 (medians over 400 seconds). The rear never rolls slower than cos 70 = 0.34 of the front's speed, so it never stops or backs up.\n\n// The bicycle: F is the front point, R the rear, L = |F - R|. The rear\n// wheel cannot slide sideways, so R always moves along the frame, towards F,\n// at the speed of F's motion along the frame:\n//   dR/ds = ((F - R) . T) (F - R) / L^2,\n// with T the front's unit velocity and s its arc. That keeps |F - R| = L\n// (the derivative of |D|^2 is 2 (D . T)(1 - |D|^2 / L^2)), so the segment\n// from R to F is the tangent to the rear track and meets the front track\n// exactly L ahead. Perrault asked in 1670 what curve a watch traces when\n// its chain is pulled along a straight line; that curve, the tractrix, is\n// this rear track when the front rides a straight line, and Huygens named it\n// in 1692. Konhauser, Velleman and Wagon turned the tangent rule round: of\n// two tracks, the one whose forward tangents always meet the other at the\n// same distance is the rear one, so the tracks say which way the bicycle\n// went. When the front rides a closed loop, where the rear ends up after a\n// lap is a Möbius map of where it started (Foote, 1998). For a circle of\n// radius r > L it has two fixed points; riding forward one attracts, the\n// rear circling on radius sqrt(r^2 - L^2) with the frame tangent to it, and\n// the rear comes in by a factor exp(-2 pi sqrt(r^2 - L^2) / L) each lap.\n// Levi and Tabachnikov (2009) proved Menzin's conjecture of 1906, that the\n// same happens on any convex loop holding more area than pi L^2.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan, atan2, ceil, hypot, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst wrap = (a) => a - TAU * round(a / TAU);\n// Integration step and record spacing, in LEDs of the front's arc, and a\n// tangent segment every COMB records.\nconst STEP = 0.2, SPACE = 0.5, COMB = 8, RING = 3000;\n// While riding the rear sits L + TOP rows from the top, so the front is\n// never above row TOP.\nconst TOP = 8;\n// Arc before the opening, before the first loop, and between loops.\nconst PRE = 320, FIRST = 330, RIDE = 560;\n// Loops: two laps and a bit of a circle of radius 1.3 L + 1, at least\n// L + 4 and at most RMAX, kept MARGIN inside the panel's sides.\nconst LAPS = 2, RMAX = 28, MARGIN = 3;\n// The rider weaves along a guide line that wanders across the panel, 140\n// rows a wave and 15 LEDs either side: the bar is held at the knob's angle\n// to one side until the frame has swung SWING radians past the line to the\n// guide, then thrown to the other side over RELAX LEDs. SWING itself\n// swells and fades by 35% once every 390 LEDs.\nconst G_AMP = 15, G_K = TAU / 140, SWING = 0.72, MOD_K = TAU / 390, RELAX = 3;\n// Hues at knob 0 before the wheel below bends them: rose and cyan.\nconst HUE_F = 0.865, HUE_R = 0.297, GLOW = 1;\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const R = Math.random;\n  params.s = {\n    ready: false, hue: 0, v: 26, L: 16, Lk: 16, bar: 0.87, side: 1, run: 0,\n    // Guide phases, and the phase of the swing's swell.\n    g0: R() * TAU, g1: R() * TAU, mph: R() * TAU,\n    // y: front x, front Y (up), the bar's angle from the frame, rear x, rear Y.\n    y: new Float64Array(5), t: new Float64Array(5), k: [0, 1, 2, 3].map(() => new Float64Array(5)),\n    arc: 0, next: 0, sig: 0,\n    mode: 0, turn: 1, r: 0, cx: 0, cy: 0, b0: 0, len: 0, due: 1e9, wait: 0, fade: 0, edge: 32, blend: 0,\n    hx: new Float64Array(RING), hy: new Float64Array(RING), gx: new Float64Array(RING), gy: new Float64Array(RING), n: 0,\n    buf: new Float32Array(W * H * 3), glow: new Float32Array(W * H * 3), tmp2: new Float32Array(W * H * 3),\n    cf: new Float32Array(3), cr: new Float32Array(3),\n  };\n}\n\nconst guide = (s, Y) => 32 + G_AMP * (0.7 * sin(G_K * Y + s.g0) + 0.3 * sin(1.73 * G_K * Y + s.g1));\n\n// Derivatives along the front's arc. On a loop the front is a given circle\n// and only the rear moves by the equation; riding, the front goes where the\n// bar points, the bar follows the rider, and the rear by the same equation.\nfunction deriv(s, y, ds, out) {\n  const L = s.L;\n  let tx, ty;\n  if (s.mode === 1) {\n    const b = s.b0 - (s.turn * (s.sig + ds)) / s.r;\n    y[0] = s.cx + s.r * cos(b);\n    y[1] = s.cy + s.r * sin(b);\n    tx = s.turn * sin(b);\n    ty = -s.turn * cos(b);\n    out[0] = out[1] = out[2] = 0;\n  } else if (s.mode === 2) {\n    // Off a loop the front rides straight up while the rear swings in\n    // behind it on a tractrix.\n    tx = out[2] = out[0] = 0;\n    ty = out[1] = 1;\n  } else {\n    const phi = atan2(y[0] - y[3], y[1] - y[4]), th = phi + y[2];\n    tx = sin(th);\n    ty = cos(th);\n    // While a loop is due the rider stops weaving and steers by pure\n    // pursuit for a line near the panel's edge, where the loop starts.\n    const f = s.fade, ay = y[4] + 1.5 * L + 10, ax = (1 - f) * guide(s, ay) + f * s.edge;\n    const a = wrap(atan2(ax - y[3], ay - y[4]) - phi);\n    const nav = cl(atan((2 * L * sin(a)) / hypot(ax - y[3], ay - y[4])), -0.6, 0.6);\n    const want = (1 - f) * s.side * s.bar + f * nav;\n    out[0] = tx;\n    out[1] = ty;\n    out[2] = (want - y[2]) / RELAX;\n  }\n  const dx = y[0] - y[3], dy = y[1] - y[4], p = (dx * tx + dy * ty) / (L * L);\n  out[3] = p * dx;\n  out[4] = p * dy;\n}\n\n// One classical Runge-Kutta step of length h along the front's arc.\nfunction rk4(s, h) {\n  const y = s.y, t = s.t, [a, b, c, d] = s.k;\n  deriv(s, y, 0, a);\n  for (let i = 0; i \u003c 5; i++) t[i] = y[i] + 0.5 * h * a[i];\n  deriv(s, t, h / 2, b);\n  for (let i = 0; i \u003c 5; i++) t[i] = y[i] + 0.5 * h * b[i];\n  deriv(s, t, h / 2, c);\n  for (let i = 0; i \u003c 5; i++) t[i] = y[i] + h * c[i];\n  deriv(s, t, h, d);\n  for (let i = 0; i \u003c 5; i++) y[i] += (h / 6) * (a[i] + 2 * b[i] + 2 * c[i] + d[i]);\n  // On a loop the front is placed on its circle exactly.\n  if (s.mode === 1) (s.sig += h), deriv(s, y, 0, a);\n  s.mph = wrap(s.mph + MOD_K * h);\n  s.arc += h;\n}\n\nconst loopR = (L) => min(RMAX, max(L + 4, 1.3 * L + 1));\n\n// A loop starts on a circle through the front, tangent to it, that fits\n// across the panel; it waits for one of radius loopR, easing by a LED for\n// every 40 it waits, but never under L + 3.\nfunction tryLoop(s) {\n  const y = s.y, th = atan2(y[0] - y[3], y[1] - y[4]) + y[2], c = cos(th), x = y[0], lo = MARGIN, hi = W - MARGIN;\n  // Turning right the centre is r to the right of the heading, at x + r c.\n  const right = min((x - lo) / (1 - c + 1e-9), 1 + c > 1e-9 ? (hi - x) / (1 + c) : 1e9);\n  const left = min(1 + c > 1e-9 ? (x - lo) / (1 + c) : 1e9, (hi - x) / (1 - c + 1e-9));\n  const want = loopR(s.L), turn = right >= left ? 1 : -1, r = min(want, max(right, left));\n  if (r \u003c max(s.L + 3, want - s.wait / 40)) return;\n  s.cx = x + turn * r * c;\n  s.cy = y[1] - turn * r * sin(th);\n  s.b0 = atan2(y[1] - s.cy, x - s.cx);\n  s.turn = turn;\n  s.r = r;\n  s.sig = 0;\n  // Whole laps and then on to where the front heads straight up, at the\n  // circle's side.\n  const extra = turn > 0 ? -th : th;\n  s.len = r * (LAPS * TAU + extra - TAU * floor(extra / TAU));\n  s.mode = 1;\n}\n\n// Ride arc more LEDs of the front's track, recording both points every\n// SPACE LEDs.\nfunction advance(s, arc) {\n  const end = s.arc + arc, y = s.y;\n  while (s.arc \u003c end - 1e-9) {\n    let h = min(STEP, end - s.arc, s.next - s.arc);\n    if (s.mode === 1) h = min(h, s.len - s.sig);\n    if (h > 1e-12) rk4(s, h);\n    if (s.mode === 1) {\n      if (s.sig >= s.len - 1e-9) (s.mode = 2), (s.run = 0);\n    } else if (s.mode === 2) {\n      // Straight on until the frame points within 0.2 radians of up; then\n      // the bar takes over from there, so the track has no corner.\n      const phi = atan2(y[0] - y[3], y[1] - y[4]);\n      s.run += h;\n      if (abs(phi) \u003c 0.2 || s.run > 4 * s.L) (y[2] = -phi), (s.mode = 0), (s.due = RIDE), (s.wait = 0), (s.side = phi \u003c 0 ? 1 : -1);\n    } else {\n      // The weave: throw the bar over once the frame has swung far enough\n      // past the line to the guide, or the front comes within 6 LEDs of a\n      // side of the panel.\n      const phi = atan2(y[0] - y[3], y[1] - y[4]), ay = y[4] + 1.5 * s.L + 10;\n      const a = wrap(atan2(guide(s, ay) - y[3], ay - y[4]) - phi), sw = SWING * (1 + 0.35 * sin(s.mph));\n      if (s.side > 0 && (a \u003c -sw || y[0] > W - 6)) s.side = -1;\n      else if (s.side \u003c 0 && (a > sw || y[0] \u003c 6)) s.side = 1;\n      if (s.due \u003c= 0) {\n        if (s.wait === 0) s.edge = y[0] \u003c 32 ? 32 - loopR(s.L) + 1 : 32 + loopR(s.L) - 1;\n        s.wait += h;\n        s.fade = min(1, s.fade + h / 40);\n        tryLoop(s);\n      } else (s.due -= h), (s.fade = max(0, s.fade - h / 40));\n    }\n    if (s.arc >= s.next - 1e-9) {\n      const i = s.n % RING;\n      s.hx[i] = y[0];\n      s.hy[i] = y[1];\n      s.gx[i] = y[3];\n      s.gy[i] = y[4];\n      s.n++;\n      s.next += SPACE;\n    }\n  }\n}\n\nfunction start(s) {\n  const y = s.y;\n  y[0] = y[3] = guide(s, 0);\n  y[1] = s.L;\n  y[2] = 0;\n  y[4] = 0;\n  s.arc = s.next = 0;\n  s.due = 1e9;\n  advance(s, PRE);\n  s.due = FIRST;\n  s.ready = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 16, 50], d = cl(dt || 0, 0, 0.1), y = s.y;\n  s.hue = cl(kv[0], 0, 1);\n  s.v = 13 * cl(kv[1], 0.2, 3);\n  s.bar = (cl(kv[3], 50, 70) * PI) / 180;\n  // On a loop the wheelbase stays under the loop's radius until it ends.\n  s.Lk = cl(kv[2], 16, 24);\n  const L = s.mode === 1 ? min(s.Lk, s.r - 1) : s.Lk;\n  if (L !== s.L) {\n    // A new wheelbase: the rear slides along the frame to the new distance.\n    const dx = y[3] - y[0], dy = y[4] - y[1], m = hypot(dx, dy) || 1;\n    y[3] = y[0] + (dx * L) / m;\n    y[4] = y[1] + (dy * L) / m;\n    s.L = L;\n  }\n  if (!s.ready) start(s);\n  advance(s, s.v * d);\n  // The view eases onto a loop and back off it over 0.8 seconds.\n  s.blend = cl(s.blend + (s.mode === 1 ? d : -d) / 0.8, 0, 1);\n  // Keep the numbers small on a long run.\n  if (y[4] > 1e5) {\n    const k = 1e5, m = min(s.n, RING);\n    y[1] -= k;\n    y[4] -= k;\n    s.cy -= k;\n    s.g0 = wrap(s.g0 + G_K * k);\n    s.g1 = wrap(s.g1 + 1.73 * G_K * k);\n    for (let i = 0; i \u003c m; i++) (s.hy[i] -= k), (s.gy[i] -= k);\n  }\n}\n\n// A box blur of radius 2 along rows (step 1, n of them, len long, stride\n// W) or columns (step W, n = W, len = H, stride 1), three channels.\nfunction box(src, dst, step, len, n, stride) {\n  for (let r = 0; r \u003c n; r++)\n    for (let e = 0; e \u003c 3; e++) {\n      const base = r * stride * 3 + e, st = step * 3;\n      let acc = 0;\n      for (let j = 0; j \u003c 2 && j \u003c len; j++) acc += src[base + j * st];\n      for (let j = 0; j \u003c len; j++) {\n        if (j + 2 \u003c len) acc += src[base + (j + 2) * st];\n        if (j - 3 >= 0) acc -= src[base + (j - 3) * st];\n        dst[base + j * st] = acc / 5;\n      }\n    }\n}\n\n// A round dot 2.8 LEDs across with a soft edge, kept by the brighter of\n// what is there and what lands.\nfunction dot(B, x, y, c, k) {\n  const x0 = floor(x - 1.4), y0 = floor(y - 1.4);\n  for (let yy = y0; yy \u003c= y0 + 3; yy++) {\n    if (yy \u003c 0 || yy >= H) continue;\n    for (let xx = x0; xx \u003c= x0 + 3; xx++) {\n      if (xx \u003c 0 || xx >= W) continue;\n      const u = xx + 0.5 - x, v = yy + 0.5 - y, w = k * cl(1.4 - sqrt(u * u + v * v), 0, 1);\n      if (w \u003c= 0) continue;\n      const o = (yy * W + xx) * 3;\n      for (let e = 0; e \u003c 3; e++) if (c[e] * w > B[o + e]) B[o + e] = c[e] * w;\n    }\n  }\n}\n\n// A thin line from a to b, its colour fading from ca to cb, each sample\n// laid over its four nearest LEDs.\nfunction line(B, ax, ay, bx, by, ca, cb, k) {\n  const m = ceil(hypot(bx - ax, by - ay) * 2) || 1;\n  for (let j = 0; j \u003c= m; j++) {\n    const u = j / m, x = ax + (bx - ax) * u - 0.5, y = ay + (by - ay) * u - 0.5;\n    const ix = floor(x), iy = floor(y), tx = x - ix, ty = y - iy;\n    for (let dy = 0; dy \u003c 2; dy++) {\n      const yy = iy + dy;\n      if (yy \u003c 0 || yy >= H) continue;\n      const wy = dy ? ty : 1 - ty;\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const xx = ix + dx;\n        if (xx \u003c 0 || xx >= W) continue;\n        const w = min(1, (dx ? tx : 1 - tx) * wy * 2.6) * k, o = (yy * W + xx) * 3;\n        for (let e = 0; e \u003c 3; e++) {\n          const v = (ca[e] + (cb[e] - ca[e]) * u) * w;\n          if (v > B[o + e]) B[o + e] = v;\n        }\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.ready) return;\n  const B = s.buf, G = s.glow, T = s.tmp2, cf = s.cf, cr = s.cr, y = s.y;\n  B.fill(0);\n  hsv(wheel(HUE_F + s.hue), 0.9, 1, cf, 0);\n  hsv(wheel(HUE_R + s.hue), 0.94, 1, cr, 0);\n  const e = s.blend * s.blend * (3 - 2 * s.blend);\n  const cam = (1 - e) * (y[4] + s.L + TOP) + e * (s.cy + s.r + 6);\n  const m = min(s.n, RING), first = s.n - m;\n  // The two tracks, then a glow round them: the tracks blurred by two\n  // passes of a 5-LED box each way and added at GLOW.\n  for (let j = first; j \u003c s.n; j++) {\n    const i = j % RING, rb = cam - s.gy[i], rf = cam - s.hy[i];\n    if (rb > -3 && rb \u003c H + 3) dot(B, s.gx[i], rb, cr, 1);\n    if (rf > -3 && rf \u003c H + 3) dot(B, s.hx[i], rf, cf, 1);\n  }\n  box(B, T, 1, W, H, W);\n  box(T, G, 1, W, H, W);\n  box(G, T, W, H, W, 1);\n  box(T, G, W, H, W, 1);\n  for (let o = 0; o \u003c W * H * 3; o++) B[o] += GLOW * G[o];\n  // The comb over it: the frame every 4 LEDs of the ride, from the rear\n  // point to the front point, one wheelbase long and tangent to the rear\n  // track, fading from 0.7 near the top to 0.45 at the bottom.\n  for (let j = first; j \u003c s.n; j++) {\n    if (j % COMB) continue;\n    const i = j % RING, ra = cam - s.gy[i], fa = cam - s.hy[i];\n    if ((ra \u003c -2 && fa \u003c -2) || (ra > H + 2 && fa > H + 2)) continue;\n    line(B, s.gx[i], ra, s.hx[i], fa, cr, cf, 0.7 - 0.25 * cl((ra + fa) / (2 * H), 0, 1));\n  }\n  // On a loop, a dotted ring where the rear settles.\n  if (e > 0.01 && s.r > s.L) {\n    const rho = sqrt(s.r * s.r - s.L * s.L), n = floor((TAU * rho) / 3), wh = [0.8, 0.8, 0.85];\n    for (let j = 0; j \u003c n; j++) {\n      const a = (j / n) * TAU;\n      dot(B, s.cx + rho * cos(a), cam - (s.cy + rho * sin(a)), wh, 0.3 * e);\n    }\n  }\n  // The frame now, white-cored, and the two points.\n  const wf = [cf[0] * 0.5 + 0.5, cf[1] * 0.5 + 0.5, cf[2] * 0.5 + 0.5], wr = [cr[0] * 0.5 + 0.5, cr[1] * 0.5 + 0.5, cr[2] * 0.5 + 0.5];\n  line(B, y[3], cam - y[4], y[0], cam - y[1], wr, wf, 0.9);\n  dot(B, y[3], cam - y[4], wr, 1.2);\n  dot(B, y[0], cam - y[1], wf, 1.2);\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, (B[o] * 255) | 0), min(255, (B[o + 1] * 255) | 0), min(255, (B[o + 2] * 255) | 0));\n}\n","galperin-billiard":"// ===== Patternflow pattern =====\n// Title:   Galperin Billiard\n// Family:  physics\n// Idea:    A heavy block slides down a rail onto a light one above a wall at the bottom, and every collision, block on block or light block on wall, lights one dot of a tally that groups itself in tens, hundreds and thousands, so with masses 100, 10,000 or 1,000,000 times apart it reads 31, 314 or 3141; above it the two velocities, scaled by the square roots of the masses, are a point on the energy circle that zigzags from the circle's left end to its right, one chord per collision, sweeping the disc until it lands in the wedge of angle arctan(sqrt(m/M)) where no collision is left.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Gregory Galperin, Playing pool with π (2003), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Digits=1..3, Warp=0..8\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the heavy block is violet and the light one cyan, the swept disc runs violet through blue to green from left to right, and the tally is cyan, its thousands at k = 3 cyan, violet, green and rose; at 0.5 the heavy block is green, the light one pink and the disc runs green through rose to violet. The wheel skips orange to lime, and the unswept disc stays slate blue.\n// Knob 2: Speed. 2 is real time away from the burst, the heavy block coming down at 60 rows a second; 0.2 is ten times slower and 3 half as fast again. At 2, with Warp at its opening 0.06, the blocks meet 1.4 to 1.7 seconds into a run, the heavy block is off the top about 4 seconds in, and the tally holds 1.8 seconds before the next run.\n// Knob 3: Digits. k from 1 to 3: M = 100^k m, so 100, 10,000 or 1,000,000 times the light block, and the collisions number 31, 314 and 3141, the count of steps of theta = arctan(sqrt(m/M)), 5.71, 0.573 or 0.0573 degrees, that fit below pi (equal blocks, k = 0, would give 3). The heavy block is 4 + 6k rows tall. The tally's dots are 4, 1 and 1 LEDs wide at a pitch of 5, 2 and 1. At k = 3 the middle 90% of the collisions fall within 3.4 ms and the closest two are 0.27 microseconds apart.\n// Knob 4: Warp. Seconds of slow motion added to the burst at Speed 2, from 0 to 8, shared evenly so each collision gets Warp / n of them: at the opening 0.06 the burst runs at nearly real time and the middle 90% of k = 3's collisions pass within two frames; at 8 they come 393 a second, and k = 1's 31 come four a second.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, exp, atan, atan2, cos, sin, round, PI, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The rail: the wall's top edge is row 125's top; z counts rows up from it.\n// The light block starts Z1 rows up: at 16 the last collision of k = 2,\n// the latest of the four, still happens on the panel, the heavy block 98\n// rows up.\nconst FLOOR = 125, V0 = 60, HL = 4, Z1 = 16;\nconst HOLD = 1.8, FADE = 0.6;\n// The energy circle and the tally beside the rail.\nconst CX = 37.5, CY = 25.5, R = 24, TX = 13, TB = 124;\n// The tally's thousands at k = 3, as hues at knob 0 (they go through the\n// wheel below): cyan, violet, green, rose.\nconst BAND = [0.5, 0.75, 0.36, 0.92];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel that skips orange through yellow to lime,\n// which read brown and olive when dim. Hues here are given as they look at\n// knob 0, from 0.28 round to 1.02.\nconst tone = (h, k) => 0.28 + 0.74 * (((h - 0.28) / 0.74 + k) % 1);\n\n// The collisions, event by event and in closed form: the blocks move at\n// constant speed between events, so each next event time is a gap divided\n// by a closing speed. Velocities are positive up, away from the wall. The\n// light block (mass m) sits at z1, HL rows tall; the heavy one (mass M =\n// 100^k m) has its lower face at z2. Block on block, momentum and energy\n// give v' = ((m - M) v + 2 M V) / (m + M) and V' = ((M - m) V + 2 m v) /\n// (m + M), here with r = m / M; at the wall v' = -v. It stops when the\n// light block moves up no faster than the heavy one: 0 \u003c= v \u003c= V.\nfunction collide(k, hh) {\n  const r = 1 / 100 ** k;\n  let v = 0, V = -V0, z1 = Z1, z2 = FLOOR - hh, t = 0;\n  const T = [0], A = [z1], B = [z2], VL = [v], VH = [V], kind = [0];\n  for (let guard = 0; guard \u003c 400000; guard++) {\n    const tb = V \u003c v ? max(0, z2 - z1 - HL) / (v - V) : Infinity;\n    const tw = v \u003c 0 ? max(0, z1) / -v : Infinity;\n    if (tb === Infinity && tw === Infinity) break;\n    if (tb \u003c= tw) {\n      t += tb;\n      z1 += v * tb;\n      z2 = z1 + HL;\n      const nv = ((r - 1) * v + 2 * V) / (1 + r), nV = ((1 - r) * V + 2 * r * v) / (1 + r);\n      v = nv;\n      V = nV;\n      kind.push(1);\n    } else {\n      t += tw;\n      z1 = 0;\n      z2 += V * tw;\n      v = -v;\n      kind.push(2);\n    }\n    T.push(t), A.push(z1), B.push(z2), VL.push(v), VH.push(V);\n  }\n  return { T, A, B, VL, VH, kind, n: T.length - 1, r };\n}\n\n// The slow motion. Display time s = tau + b N(tau), where N climbs by one\n// across each collision, linearly between the midpoints of the gaps around\n// it, and b = Warp / n. Far from the burst s runs with tau; inside it each\n// collision gets b seconds however close the next one is. Both directions\n// are exact on the piecewise linear knots.\nfunction warp(E, b) {\n  const T = E.T, n = E.n, m = new Float64Array(n + 1), sk = new Float64Array(n + 1);\n  m[0] = T[1] - (T[2] - T[1]) / 2;\n  for (let j = 1; j \u003c n; j++) m[j] = (T[j] + T[j + 1]) / 2;\n  m[n] = T[n] + (T[n] - T[n - 1]) / 2;\n  for (let j = 0; j \u003c= n; j++) sk[j] = m[j] + b * j;\n  E.m = m;\n  E.sk = sk;\n  E.b = b;\n}\nfunction tauOf(E, s) {\n  const { m, sk, n } = E;\n  if (s \u003c= sk[0]) return s;\n  if (s >= sk[n]) return s - E.b * n;\n  let lo = 0, hi = n;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (sk[mid] \u003c= s) lo = mid;\n    else hi = mid;\n  }\n  const span = sk[lo + 1] - sk[lo];\n  return span > 0 ? m[lo] + ((s - sk[lo]) * (m[lo + 1] - m[lo])) / span : m[lo];\n}\nfunction sOf(E, tau) {\n  const { m, n } = E;\n  if (tau \u003c= m[0]) return tau;\n  if (tau >= m[n]) return tau + E.b * n;\n  let lo = 0, hi = n;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (m[mid] \u003c= tau) lo = mid;\n    else hi = mid;\n  }\n  const span = m[lo + 1] - m[lo];\n  return tau + E.b * (lo + (span > 0 ? (tau - m[lo]) / span : 0));\n}\n// Collisions done by time tau.\nfunction doneBy(E, tau) {\n  let lo = 0, hi = E.n + 1;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (E.T[mid] \u003c= tau) lo = mid;\n    else hi = mid;\n  }\n  return lo;\n}\n\n// Where collision i's dot sits in the tally: hundreds are squares of ten\n// rows of ten, filled from the bottom; squares run five to a row at pitch 1\n// and two at pitch 2 (k = 0 and 1 never fill one), and at pitch 1 each two\n// rows of squares, a thousand, stand apart from the next by a row.\nfunction tallyAt(k, i) {\n  const p = [16, 5, 2, 1][k], side = 10 * p + (p > 1 ? p : 0), per = max(1, floor((W - TX + (p > 1 ? p : 0)) / side));\n  const q = floor(i / 100), rr = i % 100, sr = floor(q / per), sc = q % per;\n  const x = TX + sc * side + (rr % 10) * p;\n  const y = TB - sr * 10 * p - (p === 1 ? floor(sr / 2) : sr * p) - floor(rr / 10) * p;\n  return [x, y, p > 1 ? p - 1 : 1];\n}\n\nexport function setup(params) {\n  params.s = { k: -1, warpS: -1, s: 0, phase: 0, pt: 0, hue: 0, rgb: new Float32Array(W * H * 3), E: null, c: [0, 0, 0], c2: [0, 0, 0] };\n}\n\n// The run ends once the heavy block is off the top and the last collision\n// half a second gone.\nconst endOf = (E) => max(sOf(E, E.T[E.n] + (H + 4 - E.B[E.n]) / max(1, E.VH[E.n])), E.sAt[E.n] + 0.5);\n\nfunction start(S, k, wsec) {\n  S.k = k;\n  S.hh = HL + 6 * k;\n  S.E = collide(k, S.hh);\n  S.warpS = wsec;\n  warp(S.E, wsec / S.E.n);\n  const E = S.E;\n  // Points on the energy circle: (sqrt(M) V, sqrt(m) v) / (sqrt(M) V0).\n  const q = sqrt(E.r);\n  E.px = E.VH.map((V) => V / V0);\n  E.py = E.VL.map((v) => (q * v) / V0);\n  E.theta = atan(q);\n  E.sAt = E.T.map((t) => sOf(E, t));\n  E.sEnd = endOf(E);\n  S.s = 0;\n  S.phase = 0;\n  S.pt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), k = round(cl(kv[2], 1, 3)), wsec = cl(kv[3], 0, 8);\n  if (k !== S.k) start(S, k, wsec);\n  else if (abs(wsec - S.warpS) > 1e-3) {\n    // A new warp keeps the moment on screen where it is.\n    const E = S.E, tau = tauOf(E, S.s);\n    S.warpS = wsec;\n    warp(E, wsec / E.n);\n    E.sAt = E.T.map((t) => sOf(E, t));\n    E.sEnd = endOf(E);\n    S.s = sOf(E, tau);\n  }\n  const g = (d * speed) / 2;\n  if (S.phase === 0) {\n    S.s += g;\n    if (S.s >= S.E.sEnd + HOLD) (S.phase = 1), (S.pt = 0);\n  } else {\n    S.pt += g;\n    if (S.pt >= FADE) start(S, k, wsec);\n  }\n}\n\n// A point laid over its four nearest LEDs by how close it falls.\nfunction splat(rgb, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = (dx ? tx : 1 - tx) * wy * a, o = (yy * W + xx) * 3;\n      rgb[o] = max(rgb[o], c[0] * w);\n      rgb[o + 1] = max(rgb[o + 1], c[1] * w);\n      rgb[o + 2] = max(rgb[o + 2], c[2] * w);\n    }\n  }\n}\nfunction line(rgb, x0, y0, x1, y1, c, a) {\n  const len = hypot(x1 - x0, y1 - y0), m = max(1, ceil(len * 2));\n  for (let e = 0; e \u003c= m; e++) splat(rgb, x0 + ((x1 - x0) * e) / m, y0 + ((y1 - y0) * e) / m, c, a * 1.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.E) return;\n  const E = S.E, rgb = S.rgb, th = E.theta, hue = S.hue, c = S.c, c2 = S.c2;\n  const s = min(S.s, E.sEnd + HOLD), tau = tauOf(E, s), done = doneBy(E, tau);\n  const fade = S.phase === 1 ? 1 - S.pt / FADE : min(1, s / 0.3);\n  rgb.fill(0);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += col[0] * a;\n    rgb[o + 1] += col[1] * a;\n    rgb[o + 2] += col[2] * a;\n  };\n  const since = (j) => s - E.sAt[j];\n\n  // The energy circle. Inside it, the part the chords have swept: the\n  // polygon of every point so far, which is the disc on the start's side\n  // of the latest chord, less the thin caps outside each chord joining two\n  // points on the same side.\n  const cx = E.px, cy = E.py, T2 = floor(done / 2), B2 = ceil(done / 2);\n  const ti = 2 * T2, bi = done > 0 ? 2 * B2 - 1 : 0;\n  const ex = cx[bi] - cx[ti], ey = cy[bi] - cy[ti];\n  const ref = ex * (cy[0] - cy[ti]) - ey * (cx[0] - cx[ti]);\n  const cth = cos(th);\n  // The unswept disc and the rim stay slate blue whatever the hue: dim\n  // and turned to red they read brown.\n  const disc = [0.45, 0.6, 1];\n  const swept = c2;\n  for (let y = floor(CY - R - 1); y \u003c= ceil(CY + R + 1); y++)\n    for (let x = floor(CX - R - 1); x \u003c= ceil(CX + R + 1); x++) {\n      const ux = (x + 0.5 - CX) / R, uy = (CY - y - 0.5) / R, rr = hypot(ux, uy);\n      if (rr > 1 + 1.5 / R) continue;\n      // The rim, a pixel and a half wide.\n      const rim = cl(1 - abs(rr - 1) * R / 0.9, 0, 1);\n      if (rim > 0) add(x, y, disc, 0.4 * rim);\n      if (rr >= 1) continue;\n      let a = 0.09;\n      if (done >= 2 && (ex * (uy - cy[ti]) - ey * (ux - cx[ti])) * ref > 0) {\n        const phi = atan2(uy, ux);\n        let ok = true;\n        if (phi >= 0) {\n          const j = floor((PI - phi) / (2 * th));\n          if (j \u003c T2) ok = ux * cos(PI - th * (2 * j + 1)) + uy * sin(PI - th * (2 * j + 1)) \u003c= cth;\n        } else {\n          const j = floor((phi + PI) / (2 * th));\n          if (j \u003c B2) ok = ux * cos(-PI + th * (2 * j + 1)) + uy * sin(-PI + th * (2 * j + 1)) \u003c= cth;\n        }\n        if (ok) a = 0.55;\n      }\n      if (a > 0.1) hsv(tone(0.76 - 0.2 * (ux + 1), hue), 0.7, 1, swept);\n      add(x, y, a > 0.1 ? swept : disc, a);\n    }\n  // The wedge 0 \u003c= angle \u003c= theta, where v \u003c= V and no collision is left.\n  const goal = [1, 0.95, 0.8];\n  line(rgb, CX, CY, CX + R, CY, goal, 0.35);\n  line(rgb, CX, CY, CX + R * cos(th), CY - R * sin(th), goal, 0.35);\n  // The chords: every one so far, faint (the last 400 at k = 3, the older\n  // ones lie under the swept disc), and the newest bright.\n  const chord = [0.85, 0.95, 1], keep = [0.6, 0.45, 0.16, 0.12][S.k];\n  for (let j = max(1, done - 400); j \u003c= done; j++) {\n    const age = since(j), a = keep + 0.7 * exp(-age / 0.25);\n    line(rgb, CX + R * cx[j - 1], CY - R * cy[j - 1], CX + R * cx[j], CY - R * cy[j], chord, min(1, a));\n  }\n  // The state point.\n  const sx = CX + R * cx[done], sy = CY - R * cy[done];\n  for (const [dx, dy] of [[0, 0], [-0.7, 0], [0.7, 0], [0, -0.7], [0, 0.7]]) splat(rgb, sx + dx, sy + dy, [1, 1, 1], 1);\n\n  // The tally, one dot per collision; the newest flash white.\n  for (let i = 0; i \u003c done; i++) {\n    const [x, y, w] = tallyAt(S.k, i), q = floor(i / 100);\n    const band = S.k === 3 ? BAND[floor(i / 1000)] : BAND[0];\n    hsv(tone(band, hue), 0.75, q % 2 ? 0.62 : 0.9, c);\n    const f = 0.9 * exp(-since(i + 1) / 0.3);\n    for (let e = 0; e \u003c 3; e++) c2[e] = c[e] + (1 - c[e]) * f;\n    for (let yy = 0; yy \u003c w; yy++) for (let xx = 0; xx \u003c w; xx++) add(x + xx, y - yy, c2, 1);\n  }\n\n  // The rail, the wall and the blocks.\n  const rail = hsv(tone(0.62, hue), 0.35, 1, [0, 0, 0]);\n  for (let y = 0; y \u003c FLOOR; y++) add(5, y, rail, 0.16);\n  // The last wall hit and the last block hit, for a flash.\n  let lastW = -1, lastB = -1;\n  for (let j = done; j >= 1 && (lastW \u003c 0 || lastB \u003c 0) && j > done - 3; j--) {\n    if (E.kind[j] === 2 && lastW \u003c 0) lastW = j;\n    if (E.kind[j] === 1 && lastB \u003c 0) lastB = j;\n  }\n  const wf = lastW > 0 ? exp(-since(lastW) / 0.15) : 0;\n  const wall = hsv(tone(0.3, hue), 0.25, 1, [0, 0, 0]);\n  for (let y = FLOOR; y \u003c H; y++) for (let x = 0; x \u003c 11; x++) add(x, y, wall, 0.55 + 0.45 * wf);\n  const at = (j0, z0, v0) => z0 + v0 * (tau - E.T[j0]);\n  const z1 = at(done, E.A[done], E.VL[done]), z2 = at(done, E.B[done], E.VH[done]);\n  const light = hsv(tone(0.5, hue), 0.7, 1, [0, 0, 0]);\n  const heavy = hsv(tone(0.78, hue), 0.7, 1, [0, 0, 0]);\n  const block = (za, zb, x0, x1, col, a) => {\n    const ya = FLOOR - zb, yb = FLOOR - za;\n    for (let y = max(0, floor(ya)); y \u003c= min(H - 1, floor(yb)); y++) {\n      const cov = min(y + 1, yb) - max(y, ya);\n      if (cov > 0) for (let x = x0; x \u003c= x1; x++) add(x, y, col, a * cov);\n    }\n  };\n  const bf = lastB > 0 ? exp(-since(lastB) / 0.15) : 0;\n  block(z1, z1 + HL, 2, 8, light, 0.9);\n  block(z2, z2 + S.hh, S.k ? 0 : 2, S.k ? 10 : 8, heavy, 0.85);\n  // The face where they meet glows on each hit.\n  if (bf > 0.02) block(z2 - 0.5, z2 + 0.5, S.k ? 0 : 2, S.k ? 10 : 8, [1, 1, 1], 0.8 * bf);\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 1] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 2] * fade, 0, 1)) | 0);\n}\n","medial-axis":"// ===== Patternflow pattern =====\n// Title:   Medial Axis\n// Family:  algo\n// Idea:    A fire lit along a closed curve that fills the panel burns inward and outward at one speed, its fronts drawn as staggered dashes of the distance to the curve, and every LED takes the colour of the point of the curve nearest it, so the medial axis shows as a pale seam where that point jumps across and the fronts fold into corners: a tall tree that grows a long new branch from every bump a fraction of an LED high.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: medial axis and the grassfire transform (Harry Blum, 1967), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bumps=0..1, Width=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 an LED is teal where its nearest point is on the right of the curve, blue where it is at the top or bottom and magenta where it is on the left, in 32 steps round the curve; outside the curve the same hues go pale. At 0.5 the right is magenta, the top and bottom yellow and the left teal.\n// Knob 2: Speed. The fronts move 1.5 times the knob in LEDs a second: 3 at 2, so a front lit on the curve reaches the deepest point, about 29 LEDs in, after 9.5 seconds; 0.3 at 0.2 and 4.5 at 3. At 2 the blob's five harmonics drift 0.07 to 0.13 radians a second and the bumps travel round the curve 1 to 3.6 LEDs a second; both scale with the knob.\n// Knob 3: Bumps. Adds ripples of 11, 14, 17, 21, 25 and 29 waves round the curve, 1.6 down to 0.7 LEDs high, one more each sixth of the knob. At 0 the axis is a trunk with a fork, 3.5 ends inside the curve on average. Ripples a fifth of an LED high (0.02) give it 8 ends, half an LED (0.05) 15 and the whole first ripple (0.17) 26, each new branch running from its ripple deep into the curve to the trunk; past that the count stays at 21 to 24 while the branches crowd and the pale seams grow from 5% of the inside to 16%.\n// Knob 4: Width. The distance between fronts, 6.2 + 8 x knob LEDs: 6.7 at the opening 0.06, 14.2 at 1. The dashes stay about 12 LEDs long along the curve, so wide fronts break into squarer blocks.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, cos, sin, PI, round } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Vertices of the curve.\nconst N = 384;\n// The blob: harmonic k of the radius, its amplitude and its drift in\n// radians a second at Speed 2.\nconst LOW = [[2, 0.09, 0.13], [3, 0.08, -0.09], [4, 0.07, 0.07], [5, 0.05, -0.11], [6, 0.035, 0.1]];\n// The bumps, in LEDs along the outward ray, k waves round the curve. Bumps\n// brings them in one after another.\nconst BUMPS = [[11, 1.6, 0.21], [14, 1.3, -0.17], [17, 1.1, 0.13], [21, 0.9, -0.23], [25, 0.8, 0.19], [29, 0.7, -0.15]];\n// The margin left between the blob and the panel's edges.\nconst M = 2;\n// Length of a dash along the curve, in LEDs.\nconst DASH = 12;\n// The sawtooth's height: each front is 255 on its bright side.\nconst A = 255;\n\n// Vertex angles spaced evenly by arc length round a 29 x 61 ellipse.\nconst TH = new Float32Array(N), CO = new Float32Array(N), SI = new Float32Array(N);\n{\n  const K = 4096, acc = new Float64Array(K + 1);\n  for (let k = 0; k \u003c K; k++) {\n    const a = (k + 0.5) / K * TAU;\n    acc[k + 1] = acc[k] + Math.hypot(29 * sin(a), 61 * cos(a));\n  }\n  for (let i = 0, k = 0; i \u003c N; i++) {\n    const target = (i / N) * acc[K];\n    while (acc[k + 1] \u003c target) k++;\n    TH[i] = ((k + (target - acc[k]) / (acc[k + 1] - acc[k])) / K) * TAU;\n    CO[i] = cos(TH[i]);\n    SI[i] = sin(TH[i]);\n  }\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    clock: 0, ph: 0, hue: 0, speed: 2, bumps: 0, width: 5,\n    px: new Float32Array(N), py: new Float32Array(N),\n    // Per segment: start, direction, 1 / length squared, length, arc start.\n    ax: new Float32Array(N), ay: new Float32Array(N), dx: new Float32Array(N), dy: new Float32Array(N),\n    il: new Float32Array(N), len: new Float32Array(N), arc: new Float32Array(N), per: 1,\n    F: new Int16Array(NP), D2: new Float32Array(NP), T: new Float32Array(NP), U: new Float32Array(NP),\n    G: new Float32Array(NP), IN: new Uint8Array(NP),\n    DIS: new Float32Array(NP), SH: new Float32Array(NP), HT: new Float32Array(NP),\n    CR: new Float32Array(NP), CG: new Float32Array(NP), CB: new Float32Array(NP), frame: 0, ready: false,\n    xs: new Float32Array(H * 32), xc: new Int32Array(H),\n    pal: new Float32Array(256 * 6), palHue: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.bumps = cl(kv[2], 0, 1);\n  s.width = 6.2 + 8 * cl(kv[3], 0, 1);\n  s.clock += d * s.speed / 2;\n  // The fronts move 1.5 x Speed LEDs a second.\n  s.ph += (d * 1.5 * s.speed) / s.width;\n  s.ph -= floor(s.ph);\n}\n\n// The curve at this moment: the blob scaled to the panel less the margin,\n// then the bumps pushed out along the ray from its centre.\nfunction curve(s) {\n  const { px, py } = s, t = s.clock;\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c N; i++) {\n    let r = 1;\n    for (const [k, a, w] of LOW) r += a * cos(k * TH[i] + w * t + k);\n    px[i] = r * CO[i];\n    py[i] = r * SI[i];\n    x0 = min(x0, px[i]); x1 = max(x1, px[i]); y0 = min(y0, py[i]); y1 = max(y1, py[i]);\n  }\n  const sx = (W - 1 - 2 * M) / (x1 - x0), sy = (H - 1 - 2 * M) / (y1 - y0), cx = M - x0 * sx, cy = M - y0 * sy;\n  const nb = s.bumps * BUMPS.length;\n  for (let i = 0; i \u003c N; i++) {\n    const X = px[i] * sx, Y = py[i] * sy, rho = sqrt(X * X + Y * Y);\n    let b = 0;\n    for (let j = 0; j \u003c BUMPS.length && j \u003c nb; j++) {\n      const [k, a, w] = BUMPS[j];\n      b += min(1, nb - j) * a * cos((k * TAU * i) / N + w * t * 4 + j * 2.1);\n    }\n    const f = 1 + b / rho;\n    px[i] = cx + X * f;\n    py[i] = cy + Y * f;\n  }\n  let arc = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const j = i + 1 === N ? 0 : i + 1, dx = px[j] - px[i], dy = py[j] - py[i], l2 = dx * dx + dy * dy;\n    s.ax[i] = px[i]; s.ay[i] = py[i]; s.dx[i] = dx; s.dy[i] = dy;\n    s.il[i] = l2 > 0 ? 1 / l2 : 0;\n    s.len[i] = sqrt(l2);\n    s.arc[i] = arc;\n    arc += s.len[i];\n  }\n  s.per = arc;\n}\n\n// Inside or out, row by row: where the curve's edges cross each row's\n// centre line, sorted, filled between pairs.\nfunction fill(s) {\n  const { xs, xc, IN, px, py } = s;\n  xc.fill(0);\n  IN.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const j = i + 1 === N ? 0 : i + 1, ya = py[i], yb = py[j];\n    if (ya === yb) continue;\n    const lo = min(ya, yb), hi = max(ya, yb);\n    for (let y = max(0, Math.ceil(lo)); y \u003c hi && y \u003c H; y++) {\n      if (xc[y] \u003c 32) xs[y * 32 + xc[y]++] = px[i] + ((y - ya) * (px[j] - px[i])) / (yb - ya);\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const n = xc[y], o = y * 32;\n    for (let a = 1; a \u003c n; a++) {\n      const v = xs[o + a];\n      let b = a - 1;\n      while (b >= 0 && xs[o + b] > v) (xs[o + b + 1] = xs[o + b]), b--;\n      xs[o + b + 1] = v;\n    }\n    for (let a = 0; a + 1 \u003c n; a += 2) {\n      for (let x = max(0, Math.ceil(xs[o + a])); x \u003c W && x \u003c xs[o + a + 1]; x++) IN[y * W + x] = 1;\n    }\n  }\n}\n\n// The feature transform: for every LED the nearest segment of the curve,\n// the squared distance to it and where on it the nearest point lies. The\n// arrays sit in module variables so the two small functions below inline.\nlet AX, AY, DX, DY, IL, FF, DD, TT, tt = 0;\nfunction sd(i, x, y) {\n  const ex = x - AX[i], ey = y - AY[i];\n  let t = (ex * DX[i] + ey * DY[i]) * IL[i];\n  t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n  tt = t;\n  const fx = ex - t * DX[i], fy = ey - t * DY[i];\n  return fx * fx + fy * fy;\n}\n// Try segment c for LED p, then walk along the curve while it gets nearer.\n// A segment within two of the one held is skipped: the one held is already\n// the nearest of its neighbours.\nfunction relax(p, x, y, c) {\n  if (c \u003c 0) return;\n  const e = FF[p];\n  if (e >= 0) {\n    const k = c > e ? c - e : e - c;\n    if (k \u003c= 2 || k >= N - 2) return;\n  }\n  let bd = sd(c, x, y);\n  if (bd >= DD[p]) return;\n  let bt = tt;\n  for (;;) {\n    const j = c + 1 === N ? 0 : c + 1, d = sd(j, x, y);\n    if (d \u003c bd) (bd = d), (bt = tt), (c = j);\n    else break;\n  }\n  for (;;) {\n    const j = c === 0 ? N - 1 : c - 1, d = sd(j, x, y);\n    if (d \u003c bd) (bd = d), (bt = tt), (c = j);\n    else break;\n  }\n  FF[p] = c;\n  DD[p] = bd;\n  TT[p] = bt;\n}\nfunction transform(s) {\n  (AX = s.ax), (AY = s.ay), (DX = s.dx), (DY = s.dy), (IL = s.il), (FF = s.F), (DD = s.D2), (TT = s.T);\n  const F = FF, D2 = DD;\n  F.fill(-1);\n  D2.fill(1e9);\n  // Seeds: the LED nearest each vertex takes that vertex's segment, walked\n  // to the nearest segment around it.\n  for (let i = 0; i \u003c N; i++) {\n    const x = round(AX[i]), y = round(AY[i]);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    relax(y * W + x, x, y, i);\n  }\n  // Two raster passes carry the nearest segment from neighbour to neighbour.\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0, p = y * W; x \u003c W; x++, p++) {\n      if (x > 0) relax(p, x, y, F[p - 1]);\n      if (y > 0) {\n        relax(p, x, y, F[p - W]);\n        if (x > 0) relax(p, x, y, F[p - W - 1]);\n        if (x \u003c W - 1) relax(p, x, y, F[p - W + 1]);\n      }\n    }\n    for (let x = W - 2, p = y * W + x; x >= 0; x--, p--) relax(p, x, y, F[p + 1]);\n  }\n  for (let y = H - 1; y >= 0; y--) {\n    for (let x = W - 1, p = y * W + x; x >= 0; x--, p--) {\n      if (x \u003c W - 1) relax(p, x, y, F[p + 1]);\n      if (y \u003c H - 1) {\n        relax(p, x, y, F[p + W]);\n        if (x \u003c W - 1) relax(p, x, y, F[p + W + 1]);\n        if (x > 0) relax(p, x, y, F[p + W - 1]);\n      }\n    }\n    for (let x = 1, p = y * W + 1; x \u003c W; x++, p++) relax(p, x, y, F[p - 1]);\n  }\n}\n\n// Everything that depends on the curve and not on the phase of the fire:\n// the distance of each LED, its dash, its screen offset and its colour.\n//\n// The dashes and the screen are there for the study map. Bands of the\n// distance rise along the normal and stay flat along the front, so where\n// the curve runs up the panel only the steps along a row change. With every\n// rise kept under 40 levels, the mean step between neighbours stayed at\n// 0.151 of full scale with bands alone, and no height or width of band took\n// it past 0.16. The half-band jumps between dashes and the screen's steps\n// along the fronts give the columns their share too: 0.203.\nfunction field(s) {\n  curve(s);\n  fill(s);\n  transform(s);\n  const { F, D2, T, U, G, IN, arc, len, pal, ax, ay, dx, dy, DIS, SH, HT, CR, CG, CB } = s, per = s.per, half = per / 2;\n  for (let p = 0; p \u003c NP; p++) U[p] = arc[F[p]] + T[p] * len[F[p]];\n  // How far apart along the curve the nearest points of two neighbours\n  // lie: a few LEDs off the medial axis, up to half the curve across it.\n  G.fill(0);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      if (x \u003c W - 1) {\n        let g = abs(U[p] - U[p + 1]);\n        if (g > half) g = per - g;\n        if (g > G[p]) G[p] = g;\n        if (g > G[p + 1]) G[p + 1] = g;\n      }\n      if (y \u003c H - 1) {\n        let g = abs(U[p] - U[p + W]);\n        if (g > half) g = per - g;\n        if (g > G[p]) G[p] = g;\n        if (g > G[p + W]) G[p + W] = g;\n      }\n    }\n  if (s.palHue !== s.hue) {\n    // Round the curve the hue runs from teal on the right through blue at\n    // the top and bottom to magenta on the left; outside it the same hues\n    // go pale.\n    for (let i = 0; i \u003c 256; i++) {\n      const tri = 1 - abs(1 - 2 * (i / 256));\n      hsv(0.42 + s.hue + 0.5 * tri, 0.85, 1, pal, i * 6);\n      hsv(0.42 + s.hue + 0.5 * tri, 0.38, 1, pal, i * 6 + 3);\n    }\n    s.palHue = s.hue;\n  }\n  const rise = A / s.width, nd = 2 * max(2, round(per / (2 * DASH))), dl = per / nd;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const i = F[p], d = sqrt(D2[p]), u = U[p];\n      DIS[p] = d;\n      SH[p] = 0.5 * (floor(u / dl) & 1);\n      // The screen: rows, or columns where the normal is nearer vertical,\n      // alternate up and down by as much as the step to the neighbour across\n      // leaves under 38 levels. It needs the direction to the nearest point,\n      // or across the segment for an LED on the curve.\n      let gx, gy, gn;\n      if (d > 0.3) (gx = abs(x - ax[i] - T[p] * dx[i])), (gy = abs(y - ay[i] - T[p] * dy[i])), (gn = d);\n      else (gx = abs(dy[i])), (gy = abs(dx[i])), (gn = len[i] || 1);\n      const row = gx >= gy, del = (38 - (rise * (row ? gy : gx)) / gn) / 2;\n      HT[p] = del > 0 ? ((row ? y : x) & 1 ? del : -del) : 0;\n      // The hue steps 32 times round the curve.\n      const o = ((floor((u / per) * 32) & 31) \u003c\u003c 3) * 6 + (IN[p] ? 0 : 3);\n      const wh = cl((G[p] - 3) / 9, 0, 1) * 0.8;\n      CR[p] = pal[o] + (1 - pal[o]) * wh;\n      CG[p] = pal[o + 1] + (1 - pal[o + 1]) * wh;\n      CB[p] = pal[o + 2] + (1 - pal[o + 2]) * wh;\n    }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  // The curve moves a small fraction of an LED a frame, so its field is\n  // worked out every other frame; the fire moves every frame.\n  if (!s.ready || (s.frame++ & 1) === 0) field(s), (s.ready = true);\n  const { DIS, SH, HT, CR, CG, CB } = s, w = s.width, ph = s.ph;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      // A sawtooth of the distance: each front bright on its trailing side,\n      // dark ahead of it, the brightness fading back towards the curve.\n      // Every other dash runs half a band behind.\n      const f = DIS[p] / w - ph + SH[p];\n      let lv = A * (f - floor(f)) + HT[p];\n      lv = lv \u003c 0 ? 0 : lv > 255 ? 255 : lv;\n      display.setPixel(x, y, round(CR[p] * lv), round(CG[p] * lv), round(CB[p] * lv));\n    }\n}\n","ostwald-ripening":"// ===== Patternflow pattern =====\n// Title:   Ostwald Ripening\n// Family:  sim\n// Idea:    A few hundred droplets sit still in a slightly supersaturated solution and trade matter through it: every drop smaller than the mean radius is magenta and shrinks ever faster until it blinks out, every larger one is green and swells, the solution glows faint magenta round the small drops and green round the large ones while specks of solute drift from the one to the other, and when fewer than a fifth are left a new population condenses in the gaps.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ostwald ripening (Wilhelm Ostwald, 1896) and the Lifshitz-Slyozov-Wagner theory of coarsening (Ilya Lifshitz and Vitaly Slyozov, 1961; Carl Wagner, 1961), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drops=200..500, Spread=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 growing drops and the poorer solution round them are green, shrinking drops and the richer solution magenta, and drops within 30% of the mean radius pale towards white; at 0.25 growing is azure and shrinking green, at 0.5 violet and cyan, at 0.75 rose and blue. The wheel skips orange and yellow, which read brown in the faint field.\n// Knob 2: Speed. At 2 the kinetics run one time unit a second, K = 0.42 r0^3 for a population that starts at radius r0, and a population ripens down to 18% of its drops in 13 to 19 seconds and is renewed over 1.6 seconds; at 0.2 a population lasts about 3 minutes, at 3 about 12 seconds.\n// Knob 3: Drops. How many droplets a new population starts with, 200 to 500, covering 17% of the panel: at 200 they start at radius 1.49 LEDs and the 37 left at the renewal average 2.4 (the largest 3.8); at 500 they start at 0.94 and the 91 left average 1.5 (the largest 2.4).\n// Knob 4: Spread. How unequal the starting radii are: r0 (1 + s g), with g a sum of three uniform numbers scaled to deviation 1, s from 0.12 at 0 to 0.45 at 1 (0.14 at the opening), and the radius kept between 0.35 r0 and 2.2 r0. At 0.14 a population of 200 keeps 136 drops after 3 seconds; at 0.45 only 93, as the smallest go at once.\n\n// Each drop exchanges matter with a mean field. By the Gibbs-Thomson effect\n// the solution at a drop's surface is richer the smaller the drop,\n// c(r) = c_inf (1 + a / r), and in the quasi-static diffusion field round it\n// the excess over the mean c falls off as r / d. A drop gains volume at the\n// rate 4 pi D r (c - c(r)), which in reduced units is\n//   d(r^3)/dt = 3 K (r / r_c - 1),   dr/dt = (K / r)(1 / r_c - 1 / r),\n// where r_c is the radius in balance with the field. The total volume is\n// fixed, so the sum of the rates is zero and r_c is exactly the mean radius.\n// Lifshitz and Slyozov, and Wagner, showed that then r_c^3 grows as\n// (4/9) K t and the distribution of r / \u003cr> tends to one shape, with its\n// peak near 1.13 and nothing past 3/2. Run with a million drops from this\n// pattern's own start, ripen() below gave \u003cr>^3 growing at 0.446 K over the\n// time the count fell from 50,000 to 10,000 (R^2 0.9999), with the scaled\n// sizes peaking near 1.13 and none past 1.35.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (u) => u * u * (3 - 2 * u);\n// Capacity, the share of the panel a new population covers, the rate (K =\n// RATE r0^3, with time in seconds at Speed 2), when to renew (the share of\n// drops left) and how long the renewal takes, in seconds at Speed 2.\nconst CAP = 620, AREA = 0.17, RATE = 0.42, END = 0.18, RENEW = 1.6;\n// Solute specks: how many at most, how many a second leave the shrinking\n// drops, and how far the field reaches round a drop.\nconst MOTES = 200, EMIT = 110, REACH = 8;\n// Hues at knob 0 before the wheel bends them: green and magenta.\nconst HUE_G = 0.135, HUE_S = 0.81;\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    ready: false, hue: 0, speed: 2, n0: 200, spread: 0.14,\n    // Drops: centre, volume r^3, radius, how far a new drop has condensed\n    // (0..1), and whether it belongs to the population a renewal dissolves.\n    n: 0, x: new Float32Array(CAP), y: new Float32Array(CAP), v: new Float64Array(CAP), r: new Float32Array(CAP),\n    grow: new Float32Array(CAP), old: new Uint8Array(CAP),\n    K: 1, rc: 1, renew: -1, merges: 0,\n    // Specks of solute.\n    m: 0, mx: new Float32Array(MOTES), my: new Float32Array(MOTES), ml: new Float32Array(MOTES), emit: 0,\n    // Pops where drops vanish: x, y, age.\n    pops: [],\n    field: new Float32Array(N), owner: new Int16Array(N), buf: new Float32Array(N * 3),\n    cg: new Float32Array(3), cs: new Float32Array(3), tmp: new Float32Array(3),\n  };\n}\n\n// The kinetics, one step of the mean-field equation on the volumes v[0..n):\n// r_c is the mean radius, and a drop whose volume reaches zero is gone\n// (its slot is set to -1). Returns r_c.\nfunction ripen(v, n, dt, K) {\n  let sr = 0, live = 0;\n  for (let i = 0; i \u003c n; i++) if (v[i] > 0) (sr += Math.cbrt(v[i])), live++;\n  if (!live) return 0;\n  const rc = sr / live;\n  for (let i = 0; i \u003c n; i++) {\n    if (v[i] \u003c= 0) continue;\n    v[i] += 3 * K * (Math.cbrt(v[i]) / rc - 1) * dt;\n    if (v[i] \u003c= 0) v[i] = -1;\n  }\n  return rc;\n}\n\n// A new population: radii r0 (1 + spread g) with g roughly normal, placed\n// at random with a gap of a LED from every drop already there.\nfunction populate(s) {\n  const n0 = s.n0, r0 = sqrt((AREA * N) / (PI * n0));\n  s.K = RATE * r0 * r0 * r0;\n  const first = s.n;\n  for (let k = 0; k \u003c n0 && s.n \u003c CAP; k++) {\n    const g = (Math.random() + Math.random() + Math.random() - 1.5) * 2;\n    const r = r0 * cl(1 + s.spread * g, 0.35, 2.2);\n    for (let tries = 0; tries \u003c 40; tries++) {\n      const x = r + Math.random() * (W - 2 * r), y = r + Math.random() * (H - 2 * r);\n      let ok = true;\n      for (let j = 0; j \u003c s.n && ok; j++) {\n        const dx = s.x[j] - x, dy = s.y[j] - y, need = s.r[j] + r + 1;\n        if (dx * dx + dy * dy \u003c need * need) ok = false;\n      }\n      if (!ok) continue;\n      const i = s.n++;\n      s.x[i] = x;\n      s.y[i] = y;\n      s.v[i] = r * r * r;\n      s.r[i] = r;\n      s.grow[i] = first ? 0 : 1;\n      s.old[i] = 0;\n      break;\n    }\n  }\n}\n\nfunction remove(s, i) {\n  const j = --s.n;\n  s.x[i] = s.x[j];\n  s.y[i] = s.y[j];\n  s.v[i] = s.v[j];\n  s.r[i] = s.r[j];\n  s.grow[i] = s.grow[j];\n  s.old[i] = s.old[j];\n}\n\n// Two drops that touch run together, keeping their volume.\nfunction merge(s) {\n  for (let i = 0; i \u003c s.n; i++)\n    for (let j = i + 1; j \u003c s.n; j++) {\n      const dx = s.x[j] - s.x[i], dy = s.y[j] - s.y[i], need = s.r[i] + s.r[j] + 0.3;\n      if (dx * dx > need * need || dx * dx + dy * dy >= need * need || s.old[i] || s.old[j]) continue;\n      const vi = s.v[i], vj = s.v[j], v = vi + vj;\n      s.x[i] = (s.x[i] * vi + s.x[j] * vj) / v;\n      s.y[i] = (s.y[i] * vi + s.y[j] * vj) / v;\n      s.v[i] = v;\n      s.r[i] = Math.cbrt(v);\n      remove(s, j);\n      s.merges++;\n      j = i;\n    }\n}\n\n// The field round the drops: each adds (1 - r / r_c) / d outside itself,\n// the excess of a drop's surface over the mean carried out as 1 / d, faded\n// to nothing REACH LEDs past its edge. Positive near small drops, negative\n// near large ones. owner marks the LEDs inside each drop.\nfunction field(s) {\n  const F = s.field, O = s.owner, rc = s.rc;\n  F.fill(0);\n  O.fill(-1);\n  for (let i = 0; i \u003c s.n; i++) {\n    const r = s.r[i] * (s.old[i] ? 1 : sm(s.grow[i])), cx = s.x[i], cy = s.y[i];\n    if (r \u003c= 0.05) continue;\n    const e = s.old[i] ? 0 : 1 - s.r[i] / rc, R = r + REACH;\n    const x0 = max(0, floor(cx - R)), x1 = min(W - 1, floor(cx + R)), y0 = max(0, floor(cy - R)), y1 = min(H - 1, floor(cy + R));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, d = sqrt(dx * dx + dy * dy), p = y * W + x;\n        if (d \u003c r) {\n          O[p] = i;\n          continue;\n        }\n        if (d >= R) continue;\n        const t = 1 - (d - r) / REACH;\n        F[p] += (e / d) * t * t;\n      }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 200, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.n0 = round(cl(kv[2], 200, 500));\n  s.spread = 0.12 + 0.33 * cl(kv[3], 0, 1);\n  if (!s.ready) {\n    populate(s);\n    s.ready = true;\n  }\n  const g = d * s.speed;\n  if (s.renew >= 0) {\n    // A renewal: the old drops dissolve while the new ones condense.\n    s.renew += g / 2 / RENEW;\n    let sr = 0, k = 0;\n    for (let i = 0; i \u003c s.n; i++) if (!s.old[i]) (s.grow[i] = min(1, s.renew)), (sr += s.r[i]), k++;\n    // The new drops are measured against their own mean from the start.\n    s.rc = sr / max(1, k);\n    if (s.renew >= 1) {\n      for (let i = s.n - 1; i >= 0; i--) if (s.old[i]) remove(s, i);\n      s.renew = -1;\n    }\n  } else {\n    // Ripening, in steps of at most 1/60 of a second.\n    const steps = Math.ceil(g / 2 / (1 / 60)) || 1, h = g / 2 / steps;\n    for (let k = 0; k \u003c steps; k++) s.rc = ripen(s.v, s.n, h, s.K) || s.rc;\n    for (let i = s.n - 1; i >= 0; i--) {\n      if (s.v[i] \u003c 0) {\n        s.pops.push([s.x[i], s.y[i], 0]);\n        remove(s, i);\n      } else s.r[i] = Math.cbrt(s.v[i]);\n    }\n    merge(s);\n    if (s.n \u003c= max(8, s.n0 * END)) {\n      for (let i = 0; i \u003c s.n; i++) s.old[i] = 1;\n      populate(s);\n      s.renew = 0;\n    }\n  }\n  if (s.renew >= 0) {\n    // The dissolving drops shrink as the renewal runs.\n    const f = 1 - sm(min(1, s.renew));\n    for (let i = 0; i \u003c s.n; i++) if (s.old[i]) s.r[i] = Math.cbrt(s.v[i]) * f;\n  }\n  field(s);\n  motes(s, d * s.speed / 2);\n  for (const p of s.pops) p[2] += d * s.speed / 2;\n  s.pops = s.pops.filter((p) => p[2] \u003c 0.4);\n}\n\n// Specks of solute leave the shrinking drops and wander down the field to\n// the growing ones, which take them in.\nfunction motes(s, g) {\n  const F = s.field, O = s.owner;\n  s.emit += EMIT * g;\n  while (s.emit >= 1 && s.renew \u003c 0) {\n    s.emit -= 1;\n    if (s.m >= MOTES) continue;\n    // Pick a shrinking drop, the more often the faster it loses volume.\n    for (let tries = 0; tries \u003c 12; tries++) {\n      const i = floor(Math.random() * s.n), out = 1 - s.r[i] / s.rc;\n      if (out \u003c= 0 || Math.random() > out * 2) continue;\n      const a = Math.random() * TAU, k = s.m++;\n      s.mx[k] = s.x[i] + (s.r[i] + 0.7) * cos(a);\n      s.my[k] = s.y[i] + (s.r[i] + 0.7) * sin(a);\n      s.ml[k] = 0;\n      break;\n    }\n  }\n  if (s.renew >= 0) s.emit = 0;\n  for (let k = s.m - 1; k >= 0; k--) {\n    let x = s.mx[k], y = s.my[k];\n    const xi = cl(floor(x), 1, W - 2), yi = cl(floor(y), 1, H - 2), p = yi * W + xi;\n    const gx = (F[p + 1] - F[p - 1]) / 2, gy = (F[p + W] - F[p - W]) / 2;\n    // Down the gradient, at most a LED a frame, and a random walk.\n    const sp = sqrt(gx * gx + gy * gy) + 1e-9, v = min(30, 600 * sp) * g;\n    x += (-gx / sp) * v + (Math.random() - 0.5) * 3 * sqrt(g);\n    y += (-gy / sp) * v + (Math.random() - 0.5) * 3 * sqrt(g);\n    s.ml[k] += g;\n    const q = floor(y) * W + floor(x), o = x >= 0 && x \u003c W && y >= 0 && y \u003c H ? O[q] : -2;\n    if (o === -2 || s.ml[k] > 2.5 || (o >= 0 && s.r[o] > s.rc)) {\n      const j = --s.m;\n      s.mx[k] = s.mx[j];\n      s.my[k] = s.my[j];\n      s.ml[k] = s.ml[j];\n      continue;\n    }\n    s.mx[k] = x;\n    s.my[k] = y;\n  }\n}\n\nfunction add(B, x, y, c, k) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  B[o] = min(1, B[o] + c[0] * k);\n  B[o + 1] = min(1, B[o + 1] + c[1] * k);\n  B[o + 2] = min(1, B[o + 2] + c[2] * k);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.ready) return;\n  const B = s.buf, F = s.field, cg = s.cg, cs = s.cs, c = s.tmp;\n  hsv(wheel(HUE_G + s.hue), 0.85, 1, cg, 0);\n  hsv(wheel(HUE_S + s.hue), 0.8, 1, cs, 0);\n  // The field: magenta where the solution is richer than the mean, green\n  // where it is poorer, faint.\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const f = F[p], a = min(0.45, abs(f) * 3), col = f > 0 ? cs : cg;\n    B[o] = col[0] * a;\n    B[o + 1] = col[1] * a;\n    B[o + 2] = col[2] * a;\n  }\n  // The specks, pale in the colour of the field they cross.\n  const wh = [0.85, 0.85, 0.9];\n  for (let k = 0; k \u003c s.m; k++) {\n    const life = s.ml[k], a = 0.55 * min(1, life * 8) * min(1, (2.5 - life) * 2);\n    const x = floor(s.mx[k]), y = floor(s.my[k]), col = F[cl(y, 0, H - 1) * W + cl(x, 0, W - 1)] > 0 ? cs : cg;\n    for (let e = 0; e \u003c 3; e++) c[e] = 0.5 * (wh[e] + col[e]);\n    add(B, x, y, c, a);\n  }\n  // The drops: pale when near the mean radius, green the more they exceed\n  // it, magenta the more they fall short.\n  for (let i = 0; i \u003c s.n; i++) {\n    const r = s.r[i] * (s.old[i] ? 1 : sm(s.grow[i])), cx = s.x[i], cy = s.y[i];\n    if (r \u003c= 0.05) continue;\n    // A drop of the old population dissolving in a renewal is pale.\n    const q = s.old[i] ? 0 : s.r[i] / s.rc - 1, t = min(1, abs(q) / 0.3), col = q > 0 ? cg : cs;\n    for (let e = 0; e \u003c 3; e++) c[e] = 0.9 * (wh[e] * (1 - t) + col[e] * t);\n    const x0 = max(0, floor(cx - r - 1)), x1 = min(W - 1, floor(cx + r + 1)), y0 = max(0, floor(cy - r - 1)), y1 = min(H - 1, floor(cy + r + 1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, a = cl(r + 0.5 - sqrt(dx * dx + dy * dy), 0, 1);\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        for (let e = 0; e \u003c 3; e++) B[o + e] = B[o + e] * (1 - a) + c[e] * a;\n      }\n  }\n  // A drop that vanishes leaves a ring that opens and fades.\n  for (const [px, py, age] of s.pops) {\n    const u = age / 0.4, rr = 0.6 + 2.6 * u, k = 0.8 * (1 - u), m = Math.ceil(TAU * rr * 1.5);\n    for (let j = 0; j \u003c m; j++) {\n      const a = (j / m) * TAU;\n      add(B, floor(px + rr * cos(a)), floor(py + rr * sin(a)), cs, k / 2);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, (B[o] * 255) | 0, (B[o + 1] * 255) | 0, (B[o + 2] * 255) | 0);\n}\n","pentagon-tilings":"// ===== Patternflow pattern =====\n// Title:   Pentagon Tilings\n// Family:  cells\n// Idea:    The plane tiled by copies of one convex pentagon with thin dark grout, each tile coloured by which way it is turned and whether it is flipped, drifting slowly up the panel and to the left; the knob steps through five of the fifteen kinds, from Reinhardt's type 1, whose pentagon keeps changing shape while it tiles, through the Cairo tiling and Reinhardt's six-fold type 5 to Marjorie Rice's type 13 and the type 15 found in 2015, each new tiling replacing the old one tile by tile.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tilings by one convex pentagon: types 1, 4 and 5 (Karl Reinhardt, 1918), type 13 (Marjorie Rice, 1976-77), type 15 (Casey Mann, Jennifer McLoud-Mann and David Von Derau, 2015), the list of fifteen shown complete (Michaël Rao, 2017), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Type=0..4, Size=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. A tile's colour says how it is turned: at 0 an unturned tile is cyan and the hue moves half way round the wheel as the turn goes from 0 to 360 degrees, so the Cairo tiling's four turns are cyan, azure, violet and magenta; a flipped tile takes a paler tint a little further on. At 0.5 the unturned tiles are red.\n// Knob 2: Speed. The tiles drift up and to the left at 1.5 x Speed LEDs a second, 3 at the opening, and type 1 runs round its loop of shapes in 32 / Speed seconds, 16 s at the opening; 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Type. 0 is type 1 (B + C = 180, two tiles a period), its pentagon morphing with B from 70 to 110 degrees; 1 the Cairo tiling, type 4 (b = c, d = e, B = D = 90, four tiles round each right-angled corner); 2 type 5 (a = b, d = e, A = 60, D = 120, six round A); 3 Rice's type 13 (d = 2a = 2e, B = E = 90, 2A + D = 360, eight tiles a period); 4 type 15 (a = c = e, b = 2a, angles 150, 60, 135, 105 and 90, twelve tiles a period). A change sweeps down the panel in 1.1 s, the new tiles taking over one at a time.\n// Knob 4: Size. Every tiling is scaled so a tile covers the area of a square 12 LEDs on a side at 0 (13 at the opening) up to 28 at 1: about 50 tiles on the panel at the opening and 10 at the end.\n\nconst W = 64, H = 128;\nconst { floor, min, max, cos, sin, atan2, hypot, sqrt, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst D2R = PI / 180;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// An isometry [c, s, m, tx, ty] sends p to R(th) diag(1, m) p + t.\nconst ap = (g, p) => {\n  const y = g[2] * p[1];\n  return [g[0] * p[0] - g[1] * y + g[3], g[1] * p[0] + g[0] * y + g[4]];\n};\nconst rot = (th, q) => {\n  const c = cos(th), s = sin(th);\n  return [c, s, 1, q[0] - c * q[0] + s * q[1], q[1] - s * q[0] - c * q[1]];\n};\n\n// The pentagon from its angles A..E (degrees) and sides, side a = EA,\n// b = AB, c = BC, d = CD, e = DE: walk from A along AB and turn by\n// 180 - angle at each corner. sides(x, y) gives the five sides with two of\n// them unknown; the walk must close, which fixes x and y.\nfunction pentagon(ang, sides) {\n  const walk = (sd) => {\n    const v = [[0, 0]];\n    let dir = 0, x = 0, y = 0;\n    for (let k = 1; k \u003c= 5; k++) {\n      x += sd[k % 5] * cos(dir);\n      y += sd[k % 5] * sin(dir);\n      if (k \u003c 5) v.push([x, y]), (dir += (180 - ang[k]) * D2R);\n    }\n    return { v, end: [x, y] };\n  };\n  const g0 = walk(sides(0, 0)).end, gx = walk(sides(1, 0)).end, gy = walk(sides(0, 1)).end;\n  const a = [gx[0] - g0[0], gx[1] - g0[1]], b = [gy[0] - g0[0], gy[1] - g0[1]], det = a[0] * b[1] - b[0] * a[1];\n  return walk(sides((-g0[0] * b[1] + g0[1] * b[0]) / det, (-a[0] * g0[1] + a[1] * g0[0]) / det)).v;\n}\n\n// A copy glued to tile g: the copy's corner b on g's corner a, the copy's\n// edge b -> bi along g's edge a -> ai, the copy mirrored when m = -1.\nfunction glue(v, g, a, ai, b, bi, m) {\n  const V = ap(g, v[a]), U = ap(g, v[ai]);\n  const th = atan2(U[1] - V[1], U[0] - V[0]) - atan2(m * (v[bi][1] - v[b][1]), v[bi][0] - v[b][0]);\n  const c = cos(th), s = sin(th), lx = v[b][0], ly = m * v[b][1];\n  return [c, s, m, V[0] - (c * lx - s * ly), V[1] - (s * lx + c * ly)];\n}\n// A tiling from gluings: G builds the tiles of one period from tile 0, and\n// each row of L glues a copy that is a translate of tile k, giving one of\n// the two periods.\nfunction glued(v, G, L) {\n  const isos = [[1, 0, 1, 0, 0]];\n  for (const [f, a, ai, b, bi, m] of G) isos.push(glue(v, isos[f], a, ai, b, bi, m));\n  const T = L.map(([f, a, ai, b, bi, m, k]) => {\n    const g = glue(v, isos[f], a, ai, b, bi, m);\n    return [g[3] - isos[k][3], g[4] - isos[k][4]];\n  });\n  return { v, isos, T };\n}\n\n// Type 1, B + C = 180: AB and DC parallel. B = (0, 0), C = (1, 0), the\n// sides AB and DC leave at angle be with lengths b and d, and E sits over\n// AD at base angles chosen to keep every corner under 165 degrees. The\n// shape runs round a loop as w goes from 0 to 2 pi; every member tiles by\n// the copy turned half round about the midpoint of BC, the two making a\n// hexagon D E A D' E' A' with opposite sides parallel, which tiles by\n// translation.\nfunction type1(w) {\n  const be = (90 + 20 * sin(w)) * D2R, b = 1 + 0.3 * sin(2 * w + 1), d = 1 + 0.3 * sin(w + 2);\n  const u = [cos(be), sin(be)];\n  const A = [b * u[0], b * u[1]], B = [0, 0], C = [1, 0], D = [1 + d * u[0], d * u[1]];\n  const corner = (o, p, q) => {\n    const x = [p[0] - o[0], p[1] - o[1]], y = [q[0] - o[0], q[1] - o[1]];\n    return Math.acos((x[0] * y[0] + x[1] * y[1]) / hypot(x[0], x[1]) / hypot(y[0], y[1]));\n  };\n  const gA = (165 * D2R - corner(A, B, D)) * (0.5 + 0.12 * sin(3 * w));\n  const gD = (165 * D2R - corner(D, A, C)) * (0.5 - 0.12 * sin(3 * w + 0.7));\n  const dir = atan2(D[1] - A[1], D[0] - A[0]);\n  const r1 = [cos(dir + gA), sin(dir + gA)], r2 = [cos(dir + PI - gD), sin(dir + PI - gD)];\n  const t = ((D[0] - A[0]) * r2[1] - (D[1] - A[1]) * r2[0]) / (r1[0] * r2[1] - r1[1] * r2[0]);\n  const E = [A[0] + t * r1[0], A[1] + t * r1[1]];\n  const v = [A, B, C, D, E];\n  const r = rot(PI, [0.5, 0]), E2 = ap(r, E), A2 = ap(r, A);\n  return { v, isos: [[1, 0, 1, 0, 0], r], T: [[D[0] - E2[0], D[1] - E2[1]], [E[0] - A2[0], E[1] - A2[1]]] };\n}\n\n// Type 4, b = c, d = e, B = D = 90: the Cairo pentagon (angles 120, 90,\n// 120, 90, 120, four sides 1 and a = sqrt 3 - 1). Quarter turns about B and\n// about D generate it: four tiles round B, and R_D R_B^-1 a translation.\nfunction type4() {\n  const v = pentagon([120, 90, 120, 90, 120], (x, y) => [y, 1, 1, x, x]), B = v[1], D = v[3];\n  const dx = D[0] - B[0], dy = D[1] - B[1];\n  return { v, isos: [0, 1, 2, 3].map((k) => rot((k * PI) / 2, B)), T: [[dx + dy, dy - dx], [dx - dy, dx + dy]] };\n}\n\n// Type 5, a = b, d = e, A = 60, D = 120 (here B = 140, C = 100, E = 120):\n// sixth turns about A, third turns about D.\nfunction type5() {\n  const v = pentagon([60, 140, 100, 120, 120], (x, y) => [1, 1, y, x, x]), D = v[3];\n  const c = cos((2 * PI) / 3), s = sin((2 * PI) / 3);\n  const T1 = [D[0] - (c * D[0] - s * D[1]), D[1] - (s * D[0] + c * D[1])];\n  const c6 = cos(PI / 3), s6 = sin(PI / 3);\n  return { v, isos: [0, 1, 2, 3, 4, 5].map((k) => rot((k * PI) / 3, [0, 0])), T: [T1, [c6 * T1[0] - s6 * T1[1], s6 * T1[0] + c6 * T1[1]]] };\n}\n\n// Type 13, d = 2a = 2e, B = E = 90, 2A + D = 360 (here A = C = 112, D =\n// 136): eight tiles a period, in two orbits of the symmetry group.\nfunction type13() {\n  const v = pentagon([112, 90, 112, 136, 90], (x, y) => [1, x, y, 2, 1]);\n  return glued(v, [[0, 2, 3, 3, 2, 1], [0, 3, 4, 2, 3, -1], [0, 0, 4, 3, 4, 1], [0, 1, 2, 1, 2, -1], [1, 0, 4, 3, 4, 1], [2, 3, 4, 0, 4, -1], [3, 1, 2, 1, 2, -1]], [[0, 0, 1, 0, 1, -1, 2], [4, 3, 4, 0, 4, -1, 7]]);\n}\n\n// Type 15, a = c = e = 1, b = 2, d = sqrt 2 / (sqrt 3 - 1), A = 150, B = 60,\n// C = 135, D = 105, E = 90: twelve tiles a period, in three orbits of the\n// symmetry group.\nfunction type15() {\n  // The walk is solved for d and e; e comes out 1.\n  const v = pentagon([150, 60, 135, 105, 90], (x, y) => [1, 2, 1, x, y]);\n  return glued(v, [[0, 0, 4, 1, 2, 1], [0, 3, 4, 1, 2, -1], [0, 1, 2, 2, 1, 1], [1, 0, 1, 3, 4, -1], [1, 0, 4, 3, 4, 1], [3, 3, 4, 1, 2, -1], [3, 0, 4, 1, 2, 1], [4, 1, 2, 0, 4, -1], [6, 3, 4, 0, 4, -1], [7, 0, 4, 3, 4, 1], [8, 2, 3, 3, 2, -1]], [[0, 0, 1, 0, 1, -1, 2], [9, 1, 2, 0, 4, -1, 11]]);\n}\n\nconst GRID = 20;\n\n// Lookup for one tiling: every tile of a period and its translates by up\n// to two periods, as five edge lines each, filed in a GRID x GRID grid over\n// the period cell in lattice coordinates. A point is found by reducing it\n// into the cell and testing the few tiles filed in its grid square.\nfunction prepare(t) {\n  const { v, isos, T } = t;\n  const det = T[0][0] * T[1][1] - T[0][1] * T[1][0];\n  let area = 0;\n  for (let k = 0; k \u003c 5; k++) area += v[k][0] * v[(k + 1) % 5][1] - v[(k + 1) % 5][0] * v[k][1];\n  // Aspect: the tile's turn, as a fraction of a whole turn, and its hand.\n  const asp = isos.map((g) => [((atan2(g[1], g[0]) / (2 * PI) + 1.0001) % 1), g[2]]);\n  const lines = [], cells = [];\n  for (let g = 0; g \u003c GRID * GRID; g++) cells.push([]);\n  isos.forEach((g, k) => {\n    let p = v.map((q) => ap(g, q));\n    if (g[2] \u003c 0) p = p.reverse();\n    for (let i = -2; i \u003c= 2; i++)\n      for (let j = -2; j \u003c= 2; j++) {\n        const ox = i * T[0][0] + j * T[1][0], oy = i * T[0][1] + j * T[1][1];\n        const q = p.map((r) => [r[0] + ox, r[1] + oy]);\n        let a0 = 9, a1 = -9, b0 = 9, b1 = -9, cx = 0, cy = 0;\n        for (const [x, y] of q) {\n          const a = (x * T[1][1] - y * T[1][0]) / det, b = (T[0][0] * y - T[0][1] * x) / det;\n          (a0 = min(a0, a)), (a1 = max(a1, a)), (b0 = min(b0, b)), (b1 = max(b1, b)), (cx += x / 5), (cy += y / 5);\n        }\n        if (a1 \u003c 0 || a0 > 1 || b1 \u003c 0 || b0 > 1) continue;\n        const id = lines.length;\n        const L = [k, cx, cy];\n        for (let e = 0; e \u003c 5; e++) {\n          const P = q[e], Q = q[(e + 1) % 5], len = hypot(Q[0] - P[0], Q[1] - P[1]);\n          // inside when nx x + ny y >= c, the value the distance to the edge\n          const nx = -(Q[1] - P[1]) / len, ny = (Q[0] - P[0]) / len;\n          L.push(nx, ny, nx * P[0] + ny * P[1]);\n        }\n        lines.push(L);\n        for (let ga = max(0, floor(a0 * GRID)); ga \u003c= min(GRID - 1, floor(a1 * GRID)); ga++)\n          for (let gb = max(0, floor(b0 * GRID)); gb \u003c= min(GRID - 1, floor(b1 * GRID)); gb++) cells[ga * GRID + gb].push(id);\n      }\n  });\n  return { T, det, area: area / 2, asp, lines, cells, n: isos.length };\n}\n\nconst BUILD = [null, type4, type5, type13, type15];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, size: 12, type: 0, prev: -1, wipe: 1, w: 0,\n    // Where the middle of the panel sits in each tiling, in its own lattice\n    // coordinates, so the changing shapes of type 1 stay put round it.\n    pan: BUILD.map(() => [0.3, 0.6]),\n    tilings: BUILD.map((f) => (f ? prepare(f()) : null)),\n    rgb: new Float32Array(3), hit: new Float64Array(4),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.size = 12 + 16 * cl(kv[3], 0, 1);\n  const ty = round(cl(kv[2], 0, 4));\n  if (ty !== s.type) (s.prev = s.type), (s.type = ty), (s.wipe = 0);\n  s.wipe = min(1, s.wipe + d * 0.9);\n  // Type 1 runs round its loop of shapes once in 32 / Speed seconds.\n  s.w += d * s.speed * ((2 * PI) / 32);\n  s.tilings[0] = prepare(type1(s.w));\n  // The tiles drift up and to the left at 1.5 LEDs a second per unit of\n  // Speed.\n  s.tilings.forEach((t, i) => {\n    const sc = s.size / sqrt(t.area), vx = (d * s.speed * 1.2) / sc, vy = (-d * s.speed * 0.9) / sc, P = s.pan[i], T = t.T;\n    P[0] = (P[0] + (vx * T[1][1] - vy * T[1][0]) / t.det + 1) % 1;\n    P[1] = (P[1] + (T[0][0] * vy - T[0][1] * vx) / t.det + 1) % 1;\n  });\n}\n\n// The tile under tiling point (x, y): its period index and aspect, the\n// distance to its nearest edge, and its centre.\nfunction locate(t, x, y, out) {\n  const { T, det, cells, lines } = t;\n  const a = (x * T[1][1] - y * T[1][0]) / det, b = (T[0][0] * y - T[0][1] * x) / det;\n  const ia = floor(a), ib = floor(b);\n  const rx = x - ia * T[0][0] - ib * T[1][0], ry = y - ia * T[0][1] - ib * T[1][1];\n  const list = cells[min(GRID - 1, floor((a - ia) * GRID)) * GRID + min(GRID - 1, floor((b - ib) * GRID))];\n  let best = -1, bd = -1e9;\n  for (let n = 0; n \u003c list.length; n++) {\n    const L = lines[list[n]];\n    let dm = 1e9;\n    for (let e = 3; e \u003c 18; e += 3) dm = min(dm, L[e] * rx + L[e + 1] * ry - L[e + 2]);\n    if (dm > bd) (bd = dm), (best = list[n]);\n  }\n  const L = lines[best];\n  out[0] = L[0];\n  out[1] = bd;\n  out[2] = L[1] + ia * T[0][0] + ib * T[1][0];\n  out[3] = L[2] + ia * T[0][1] + ib * T[1][1];\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { rgb, hit } = s;\n  const cur = s.tilings[s.type], old = s.prev >= 0 && s.wipe \u003c 1 ? s.tilings[s.prev] : null;\n  // The front of a change of type runs down the panel on a slant; a tile of\n  // the new tiling shows once its centre is above the front.\n  const front = -20 + s.wipe * 190;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let t = cur, ti = s.type;\n      for (let pass = 0; pass \u003c 2; pass++) {\n        // Each tiling is scaled so a tile covers size^2 LEDs.\n        const sc = s.size / sqrt(t.area), P = s.pan[ti], T = t.T;\n        const ox = P[0] * T[0][0] + P[1] * T[1][0], oy = P[0] * T[0][1] + P[1] * T[1][1];\n        locate(t, (x - 31.5) / sc + ox, (63.5 - y) / sc + oy, hit);\n        if (old && t === cur) {\n          const cx = 31.5 + (hit[2] - ox) * sc, cy = 63.5 - (hit[3] - oy) * sc;\n          if (cy + 0.35 * cx > front) {\n            (t = old), (ti = s.prev);\n            continue;\n          }\n        }\n        const [turn, hand] = t.asp[hit[0]];\n        hsv(0.47 + s.hue + 0.5 * turn + (hand > 0 ? 0 : 0.05), hand > 0 ? 0.62 : 0.36, hand > 0 ? 0.95 : 0.85, rgb);\n        // Grout: the LED darkens within about half an LED of an edge.\n        const g = cl((hit[1] * sc - 0.3) / 0.7, 0, 1);\n        const k = g * (0.8 + 0.2 * cl(hit[1] * sc / 4, 0, 1));\n        display.setPixel(x, y, (255 * rgb[0] * k) | 0, (255 * rgb[1] * k) | 0, (255 * rgb[2] * k) | 0);\n        break;\n      }\n    }\n}\n","sinai-walk":"// ===== Patternflow pattern =====\n// Title:   Sinai's Walk\n// Family:  noise\n// Idea:    A random potential runs down the panel as a jagged ridge, one site to a row and each site with its own coin for a step up or down; 3,000 walkers start on one row of this one landscape and run on a clock of log t, so a pool fills every valley to depth log t and rises steadily while the walkers glow in the pool that holds them, stay there until it spills over a ridge into a deeper valley, then pour over together, until they gather in the deepest valley on the panel and a fresh landscape is drawn.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random walk in a random environment (Fred Solomon, 1975), Sinai's walk and its (log t)^2 law (Yakov Sinai, 1982), the walkers' localization in one valley (Andrei Golosov, 1984), the transient walk X_t ~ t^kappa (Harry Kesten, M. V. Kozlov and Frank Spitzer, 1975), the valleys of depth h as h-extrema (Jacques Neveu and Jim Pitman, 1989), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bias=0..1, Disorder=1.2..2.4\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 each valley's ground has its own shade between azure and violet, the valley holding the walkers a fifth brighter, the pools are cyan with a bright surface line and the walkers pale gold; at 0.5 the ground runs rose to magenta, the pools are pink and the walkers pale blue. The wheel skips orange to lime, which reads brown on the dim ground.\n// Knob 2: Speed. How fast log t runs: 1 a second at 2, so a walker has taken 19 steps after 3 seconds, 2,980 after 8 and 162,750 after 12; 0.1 a second at 0.2 and 1.5 at 3. A run ends 4.5 units of log t after the walkers' valley first reaches the deepest point of the panel, at log t 9.7 for the median landscape at the opening Disorder, then holds 1.8 seconds.\n// Knob 3: Bias. 0 is Sinai's recurrent walk: log rho = log((1 - omega)/omega) has mean 0, the walkers start on row 64 and the potential wanders with no slope. Above 0 the mean of log rho is -Bias x Disorder^2 / 2, which makes E[rho^kappa] = 1 at kappa = Bias exactly; the ridge leans, the start moves up to row 4 by Bias 0.25, and the walkers go down the panel a trap at a time as Kesten, Kozlov and Spitzer's X_t ~ t^kappa. At Bias 0.5 and Disorder 1.2 the median walker on an open line is 100 sites out after 10,000 steps and 4,420 after 10 million.\n// Knob 4: Disorder. sigma, the spread of log rho at each site, 1.2 to 2.4. The ridge draws V at 2.6 columns a unit, narrower when it would pass column 52. At 1.2 the median landscape spans 19 units and the walkers' valley reaches its deepest point at log t 5.2; at 2.4 it spans 38 and reaches it at 10.3, and one landscape in seven has its walkers' valley still short of the deepest point when the run stops at the cap, log t 19 (180 million steps).\n\nconst W = 64, H = 128, L = 128, NW = 3000;\nconst { floor, ceil, min, max, abs, sqrt, exp, log, cos, sin, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// log t a second at Speed 2, the longest run, and the hold and fade after it.\nconst RATE = 1, H_CAP = 19, HOLD = 1.8, FADE = 0.7;\n// The ridge puts the lowest V at column X0 and draws V at K_PX columns a\n// unit, so a pool rises K_PX columns for each unit of log t; a landscape\n// that would run past column X0 + SPAN is drawn narrower to fit.\nconst X0 = 2, SPAN = 50, K_PX = 2.6;\n// Base hues on the knob's wheel: ground, pools, walkers.\nconst HUE_GROUND = 0.46, HUE_POOL = 0.3, HUE_WALK = 0.13;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The wheel skips orange through yellow to lime, which reads brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction normals(n) {\n  const z = new Float64Array(n);\n  for (let i = 0; i \u003c n; i += 2) {\n    const r = sqrt(-2 * log(1 - Math.random())), a = 2 * PI * Math.random();\n    z[i] = r * cos(a);\n    if (i + 1 \u003c n) z[i + 1] = r * sin(a);\n  }\n  return z;\n}\n\n// The environment. Site x sends a walker down the panel, to x + 1, with\n// chance omega_x and up with 1 - omega_x. log rho_x = log((1 - omega_x) /\n// omega_x) = sigma Z_x - mu with Z_x standard normal, so E[rho^k] =\n// exp(-mu k + sigma^2 k^2 / 2), which is 1 at k = 2 mu / sigma^2: mu =\n// kappa sigma^2 / 2 puts the Kesten-Kozlov-Spitzer exponent on the knob.\n// V(x) = sum of log rho up to x is the potential; the walk's resting\n// measure is about exp(-V), so walkers gather where V is low.\nfunction environment(Z, sigma, kappa) {\n  const mu = (kappa * sigma * sigma) / 2, n = Z.length;\n  const omega = new Float64Array(n), V = new Float64Array(n);\n  for (let x = 0; x \u003c n; x++) {\n    const lr = sigma * Z[x] - mu;\n    omega[x] = 1 / (1 + exp(lr));\n    if (x > 0) V[x] = V[x - 1] + lr;\n  }\n  return { omega, V };\n}\n\n// One step of the walk as an L x L matrix; the end rows hold the walker\n// where a step would leave the panel.\nfunction transition(omega) {\n  const P = new Float64Array(L * L);\n  for (let x = 0; x \u003c L; x++) {\n    P[x * L + min(L - 1, x + 1)] += omega[x];\n    P[x * L + max(0, x - 1)] += 1 - omega[x];\n  }\n  return P;\n}\n// P squared, inside the band where P can be non-zero. Products under 1e-13\n// are dropped: a row loses less than 1e-10 of its weight.\nfunction square(P, bw) {\n  const R = new Float64Array(L * L);\n  for (let i = 0; i \u003c L; i++) {\n    const oi = i * L;\n    for (let m = max(0, i - bw), m1 = min(L - 1, i + bw); m \u003c= m1; m++) {\n      const p = P[oi + m];\n      if (p \u003c 1e-13) continue;\n      const om = m * L;\n      for (let j = max(0, m - bw), j1 = min(L - 1, m + bw); j \u003c= j1; j++) R[oi + j] += p * P[om + j];\n    }\n  }\n  return R;\n}\nfunction cdf(P) {\n  const C = new Float32Array(L * L);\n  for (let i = 0, o = 0; i \u003c L; i++) {\n    let s = 0;\n    for (let j = 0; j \u003c L; j++, o++) C[o] = s += P[o];\n  }\n  return C;\n}\n\n// The bottoms of the valleys of depth h: b is one when, walking away from\n// it either way, V climbs h above V(b), or meets a wall, before it dips\n// below V(b). These are Neveu and Pitman's h-minima; between two of them V\n// rises at least h above both.\nfunction bottoms(V, h, out) {\n  let n = 0;\n  for (let b = 0; b \u003c L; b++) {\n    const vb = V[b];\n    if ((b > 0 && V[b - 1] \u003c vb) || (b \u003c L - 1 && V[b + 1] \u003c vb)) continue;\n    let ok = true;\n    for (let x = b - 1; x >= 0; x--) {\n      if (V[x] \u003c vb) { ok = false; break; }\n      if (V[x] >= vb + h) break;\n    }\n    if (ok)\n      for (let x = b + 1; x \u003c L; x++) {\n        if (V[x] \u003c vb) { ok = false; break; }\n        if (V[x] >= vb + h) break;\n      }\n    if (ok) out[n++] = b;\n  }\n  return n;\n}\n// The bottom of the valley of depth h that holds site s: Sinai's b(log t),\n// where his theorem puts the walker at time t. The valley's walls are the\n// highest points between its bottom and the next bottoms either side.\nfunction valleyOf(V, h, s, buf) {\n  const n = bottoms(V, h, buf);\n  for (let i = 0; i \u003c n; i++) {\n    let wall = L;\n    if (i \u003c n - 1) {\n      wall = buf[i];\n      for (let x = buf[i]; x \u003c= buf[i + 1]; x++) if (V[x] > V[wall]) wall = x;\n    }\n    if (s \u003c= wall) return buf[i];\n  }\n  return buf[n - 1];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, kappa: -1, sigma: -1, Z: null, buf: new Int16Array(L), buf2: new Int16Array(L),\n    pos: new Int16Array(NW), u: new Float32Array(NW),\n    rgb: new Float32Array(W * H * 3), pool: new Float32Array(L), mine: new Uint8Array(L), owner: new Int16Array(L), c: [0, 0, 0],\n    age: 0,\n  };\n  for (let j = 0; j \u003c NW; j++) params.s.u[j] = Math.random();\n}\n\nfunction build(S, kappa, sigma, fresh) {\n  if (fresh || !S.Z) S.Z = normals(L);\n  S.kappa = kappa;\n  S.sigma = sigma;\n  const { omega, V } = environment(S.Z, sigma, kappa);\n  S.V = V;\n  let lo = 0, hi = 0;\n  for (let x = 1; x \u003c L; x++) {\n    if (V[x] \u003c V[lo]) lo = x;\n    if (V[x] > V[hi]) hi = x;\n  }\n  S.vmin = V[lo];\n  S.scale = min(K_PX, SPAN / max(1e-6, V[hi] - V[lo]));\n  S.P = transition(omega);\n  S.bw = 1;\n  S.C = [cdf(S.P)];\n  // Unbiased, the walkers start on the middle row; with a bias, near the top.\n  S.s0 = round(64 - 60 * min(1, 4 * kappa));\n  S.pos.fill(S.s0);\n  // The depth at which the start's valley first reaches the deepest point\n  // of the panel. The walkers cross later than that: an escape over a\n  // barrier of height H takes e^H times a factor from the widths of the\n  // valley and the barrier, and half of them are across 3.2 units of log t\n  // after it in the median landscape at sigma 1.2, 1.9 at 2.4. The run\n  // goes on 4.5 units, a factor of 90 in time.\n  let a = 0, b = V[hi] - V[lo] + 1;\n  for (let k = 0; k \u003c 24; k++) {\n    const m = (a + b) / 2;\n    if (valleyOf(V, m, S.s0, S.buf) === lo) b = m;\n    else a = m;\n  }\n  S.hEnd = min(H_CAP, max(5, b + 4.5));\n  S.h = 0;\n  S.t = 0;\n  S.phase = 0;\n  S.pt = 0;\n  S.age = 0;\n}\n\n// Every walker takes 2^k steps at once, drawn from row pos of P^(2^k).\nfunction jump(S, k) {\n  const C = S.C[k], pos = S.pos;\n  for (let j = 0; j \u003c NW; j++) {\n    const o = pos[j] * L, u = Math.random() * C[o + L - 1];\n    let lo = 0, hi = L - 1;\n    while (lo \u003c hi) {\n      const mid = (lo + hi) >> 1;\n      if (C[o + mid] > u) hi = mid;\n      else lo = mid + 1;\n    }\n    pos[j] = lo;\n  }\n}\n\n// Bring the walkers to time floor(e^h) - 1 in jumps of powers of two,\n// squaring the matrix once more when a longer jump is due.\nfunction advance(S) {\n  let rem = floor(exp(S.h) - 1) - S.t, squared = 0;\n  for (let n = 0; n \u003c 6 && rem >= 1; n++) {\n    let k = floor(Math.log2(rem));\n    while (k > S.C.length - 1 && S.C.length \u003c 31 && squared \u003c (S.bw \u003c 32 ? 4 : 1)) {\n      S.P = square(S.P, S.bw);\n      S.bw = min(L, 2 * S.bw);\n      S.C.push(cdf(S.P));\n      squared++;\n    }\n    k = min(k, S.C.length - 1);\n    jump(S, k);\n    S.t += 2 ** k;\n    rem -= 2 ** k;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 1.2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), kappa = cl(kv[2], 0, 1), sigma = cl(kv[3], 1.2, 2.4);\n  if (abs(kappa - S.kappa) > 1e-4 || abs(sigma - S.sigma) > 1e-4) build(S, kappa, sigma, false);\n  const g = (d * speed) / 2;\n  S.age += g;\n  if (S.phase === 0) {\n    S.h = min(S.hEnd, S.h + g * RATE);\n    advance(S);\n    if (S.h >= S.hEnd) (S.phase = 1), (S.pt = 0);\n  } else {\n    // Settled: the pools stop rising, and each frame every walker takes\n    // the longest jump made so far, so they keep moving inside their valley.\n    S.pt += g;\n    jump(S, S.C.length - 1);\n    if (S.phase === 1 && S.pt >= HOLD) (S.phase = 2), (S.pt = 0);\n    else if (S.phase === 2 && S.pt >= FADE) build(S, kappa, sigma, true);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.V) return;\n  const V = S.V, rgb = S.rgb, pool = S.pool, mine = S.mine, buf = S.buf;\n  const px = (v) => X0 + (v - S.vmin) * S.scale;\n  const fade = S.phase === 2 ? 1 - S.pt / FADE : min(1, S.age / 0.5);\n  rgb.fill(0);\n  // The pools: each valley of depth h filled from its bottom to V(bottom)\n  // + h, spreading along the rows while V stays under that level.\n  mine.fill(0);\n  const n = bottoms(V, S.h, buf), b0 = valleyOf(V, S.h, S.s0, S.buf2);\n  // Each valley's ground takes a tint of its own from its bottom, from the\n  // bottom to the top of its walls, so as log t grows the valleys merge\n  // and the deeper one's tint spreads over the shallower.\n  const owner = S.owner;\n  for (let i = 0, from = 0; i \u003c n; i++) {\n    const b = buf[i], lv = V[b] + S.h;\n    let lo = b, hi = b, wall = L - 1;\n    while (lo > 0 && V[lo - 1] \u003c= lv) lo--;\n    while (hi \u003c L - 1 && V[hi + 1] \u003c= lv) hi++;\n    for (let y = lo; y \u003c= hi; y++) (pool[y] = lv), (mine[y] = b === b0 ? 2 : 1);\n    if (i \u003c n - 1) {\n      wall = b;\n      for (let x = b; x \u003c= buf[i + 1]; x++) if (V[x] > V[wall]) wall = x;\n    }\n    for (let y = from; y \u003c= wall; y++) owner[y] = b;\n    from = wall + 1;\n  }\n  const ground = S.c;\n  const ridge = hsv(wheel(HUE_GROUND + S.hue - 0.04), 0.3, 1, [0, 0, 0]);\n  const water = hsv(wheel(HUE_POOL + S.hue), 0.85, 1, [0, 0, 0]);\n  const walk = hsv(HUE_WALK + S.hue, 0.5, 1, [0, 0, 0]);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || x >= W || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += col[0] * a;\n    rgb[o + 1] += col[1] * a;\n    rgb[o + 2] += col[2] * a;\n  };\n  for (let y = 0; y \u003c H; y++) {\n    const r = px(V[y]), ri = floor(r), fr = r - ri;\n    // Ground: lit most near the ridge, fading in to a floor that still\n    // reads. The valley's tint folds back at the ends of the wheel rather\n    // than wrapping round, so no valley jumps from rose to lime beside its\n    // neighbour.\n    const b = owner[y], base = HUE_GROUND + S.hue;\n    let tp = base - floor(base) + 0.24 * (((b * 0.618034) % 1) - 0.5);\n    tp = tp \u003c 0 ? -tp : tp > 0.999 ? 1.998 - tp : tp;\n    hsv(wheel(tp), 0.75, b === b0 ? 1.2 : 1, ground);\n    for (let x = 0; x \u003c= ri && x \u003c W; x++) {\n      const a = (0.15 + 0.3 * exp(-(r - x - 0.5) / 6)) * (x === ri ? fr : 1);\n      add(x, y, ground, a);\n    }\n    // The ridge, joined to the row above so the profile stays one line.\n    const ra = y > 0 ? px(V[y - 1]) : r;\n    for (let x = floor(min(r, ra)); x \u003c= floor(max(r, ra)); x++) add(x, y, ridge, x === ri ? 0.85 : 0.55);\n    if (mine[y]) {\n      const p = min(W - 0.5, px(pool[y])), m = mine[y] === 2;\n      for (let x = ri + 1; x \u003c p; x++) add(x, y, water, m ? 0.3 : 0.17);\n      add(floor(p), y, water, m ? 0.75 : 0.4);\n    }\n  }\n  // The walkers: each one a dot in its row, at its own fixed share of the\n  // way across the pool and dimmer the further out, so a crowded row glows\n  // across its whole width. A walker outside every pool, still on its way\n  // out of a valley Sinai's clock has already drained, gets five columns.\n  for (let j = 0; j \u003c NW; j++) {\n    const y = S.pos[j], r = px(V[y]);\n    const w = mine[y] ? max(2, min(W - 1, px(pool[y])) - r) : 5;\n    add(floor(r + 1 + S.u[j] * w), y, walk, 0.14 - 0.07 * S.u[j]);\n  }\n  // Sinai's b(log t), white at the right edge; the start row, dim.\n  for (let x = 60; x \u003c W; x++) add(x, S.s0, ridge, 0.3);\n  for (let x = 58; x \u003c W; x++) add(x, b0, [1, 1, 1], 0.9);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 1] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 2] * fade, 0, 1)) | 0);\n}\n","solenoid":"// ===== Patternflow pattern =====\n// Title:   Solenoid\n// Family:  fractal\n// Idea:    A solid torus stands on the panel as a dim glass ring and turns about its upright axis every 12 seconds, and inside it runs one closed strand that the Smale-Williams map has wound 16 times round, two bundles of eight that each split in two and again down to pairs, so any slice across the tube cuts it in a Cantor set; each strand wears a dark collar that cuts the strands passing behind it.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Smale-Williams solenoid (Stephen Smale, 1967; Robert F. Williams, 1967), the dyadic solenoid (Leopold Vietoris, 1927; David van Dantzig, 1930), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Level=-3..3, Lambda=0..1\n//\n// Knob 1: Hue. Turns the strand colours round the wheel together. At 0 they run from green through cyan to violet-blue: the colour follows the turning of the first term e^(is/2)/2, so where the two bundles of f(T) are green and violet, half a circuit on they are both cyan, and a whole circuit on they have swapped, because the two bundles are one tube going round twice. At 0.5 the same runs from magenta through red to yellow. The body of T stays slate.\n// Knob 2: Speed. The ring turns once in 24 / Speed seconds: 12 s at 2, so it goes from face-on (two tall arcs of cable at the sides, black in the hole) to edge-on (one column of cable down the middle) in 3 s. 120 s at 0.2, 8 s at 3.\n// Knob 3: Level. The level k is 4 plus the knob, 1 to 7: f^k(T) is one tube wound 2^k times round, so 2 strands at -3 (a double helix), 16 at 0 and 128 at 3. Between whole numbers the newest term of z grows in, so turning the knob up splits every strand in two inside its own tube; the picture follows the knob within a second.\n// Knob 4: Lambda. The contraction of f(th, z) = (2 th, lambda z + e^(i th)/2), 0.49 at 0 down to 0.22 at 1 (0.474 at the opening). The Cantor set in a slice has dimension log 2 / log(1/lambda), 0.97 down to 0.46, and the two halves of a finest bundle sit lambda^(k-1) R apart: at level 4, 1.6 LEDs at the opening and 0.16 at 0.22, where each pair fuses into one line.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, cos, sin, sqrt, PI, round, abs } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The solid torus T = S1 x D2. Its centre line is a stadium in the plane\n// of the panel: straight sides of half length HS joined by half circles of\n// radius A, run at constant speed. The disc has radius R.\nconst A = 24, HS = 30, R = 15;\nconst PER = 4 * HS + TAU * A;\n// The disc coordinate z is read in a frame that turns TWIST times round\n// the tube per circuit: another way of putting S1 x D2 into space, with\n// the same map in (th, z). In space it winds the strands round the tube\n// like a cable, so they cross the panel slanted instead of running in\n// parallel lines up its sides.\n//\n// The map is f(th, z) = (2 th, lambda z + e^(i th)/2). It sends the unit\n// disc bundle into itself (|f| \u003c= lambda + 1/2 \u003c 1), and the slice of f(T)\n// over 2 th is two discs of radius lambda round +-e^(i th)/2, apart while\n// lambda \u003c 1/2, so f is one to one. f^k(T) is a tube of radius lambda^k\n// round the curve z(s) = 1/2 sum_{m=1..k} lambda^(m-1) e^(i s / 2^m) over\n// th = s mod 2 pi, which closes after s = 2 pi 2^k: 2^k turns.\nconst TWIST = 10;\n// Steps of the circle per turn of a strand (under 0.9 LED a step), and the\n// dark collar: a strand blacks out what lies more than COLLAR LEDs behind\n// it, one LED round, so a strand passing in front reads as in front.\nconst NT = 1000, COLLAR = 3;\n// Brightness of the body of T, the glass the strands lie in. Over black\n// the collars would vanish; over the body every strand shows its edge.\nconst BODY = 0.55;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Centre point and outward normal at torus angle th.\nfunction centre(th, o, out) {\n  let u = (th / TAU) * PER;\n  if (u \u003c 2 * HS) return (out[o] = A), (out[o + 1] = -HS + u), (out[o + 2] = 1), (out[o + 3] = 0);\n  u -= 2 * HS;\n  if (u \u003c PI * A) {\n    const al = u / A;\n    return (out[o] = A * cos(al)), (out[o + 1] = HS + A * sin(al)), (out[o + 2] = cos(al)), (out[o + 3] = sin(al));\n  }\n  u -= PI * A;\n  if (u \u003c 2 * HS) return (out[o] = -A), (out[o + 1] = HS - u), (out[o + 2] = -1), (out[o + 3] = 0);\n  u -= 2 * HS;\n  const al = PI + u / A;\n  return (out[o] = A * cos(al)), (out[o + 1] = -HS + A * sin(al)), (out[o + 2] = cos(al)), (out[o + 3] = sin(al));\n}\n\nexport function setup(params) {\n  // Centre line, normal and the turning frame, per step of th.\n  const C = new Float64Array(NT * 6);\n  for (let j = 0; j \u003c NT; j++) {\n    centre((TAU * j) / NT, j * 6, C);\n    C[j * 6 + 4] = cos((TWIST * TAU * j) / NT);\n    C[j * 6 + 5] = sin((TWIST * TAU * j) / NT);\n  }\n  params.s = {\n    C, hue: 0, speed: 2, level: 4, shown: 4, lam: 0.47, phi: -PI / 3,\n    zb: new Float32Array(N), hb: new Float32Array(N), vb: new Float32Array(N), rgb: new Float32Array(3),\n    er: new Float64Array(10), ei: new Float64Array(10), sr: new Float64Array(10), si: new Float64Array(10),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.level = 4 + cl(kv[2], -3, 3);\n  s.lam = 0.49 - 0.27 * cl(kv[3], 0, 1);\n  // The level eases to the knob, so strands split in two or merge. The\n  // view opens 60 degrees short of face-on and turns about the upright.\n  s.shown += (s.level - s.shown) * min(1, d * 3);\n  s.phi += d * s.speed * (TAU / 24);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { C, zb, hb, vb, rgb, er, ei, sr, si } = s;\n  zb.fill(-1e9);\n  // Per LED: the depth that holds it, and what it shows: a strand's hue,\n  // or -1 a collar, -2 the body, -3 nothing.\n  hb.fill(-3);\n  const L = s.shown, k = floor(L + 1e-6), w = L - k, K = w > 1e-3 ? k + 1 : k, M = 1 \u003c\u003c K, lam = s.lam;\n  const cp = cos(s.phi), sp = sin(s.phi), F = 220, Dm = A + R, hue0 = 0.5 + s.hue;\n\n  // The body of T: every LED within R of the projected centre line, since\n  // the shadow of a tube is the union of the shadows of its spheres.\n  for (let j = 0; j \u003c NT; j += 15) {\n    const o = j * 6, x = C[o], y = C[o + 1];\n    const Z = -x * sp, f = F / (F - Z), qx = 31.5 + x * cp * f, qy = 63.5 - y * f, rr = R * f;\n    const y0 = max(0, ceil(qy - rr)), y1 = min(H - 1, floor(qy + rr));\n    for (let yy = y0; yy \u003c= y1; yy++) {\n      const hw = sqrt(max(0, rr * rr - (yy - qy) * (yy - qy)));\n      const x0 = max(0, ceil(qx - hw)), x1 = min(W - 1, floor(qx + hw));\n      for (let xx = x0, p = yy * W + x0; xx \u003c= x1; xx++, p++) (zb[p] = -1e8), (hb[p] = -2);\n    }\n  }\n\n  // z(s) = 1/2 sum_{m=1..K} lam^(m-1) e^(i s / 2^m); the last term grows in\n  // while the level rises from K - 1 to K.\n  const amp = [];\n  for (let m = 1, a = 0.5; m \u003c= K; m++, a *= lam) amp.push(m === K && w > 1e-3 ? a * w : a);\n  // From 64 strands on, every second or fourth step: the strands of a\n  // bundle lie closer than an LED there and fill each other's gaps.\n  const step = K > 5 ? 1 \u003c\u003c (K - 5) : 1, ds = (TAU * step) / NT;\n  for (let m = 0; m \u003c K; m++) (sr[m] = cos(ds / (2 \u003c\u003c m))), (si[m] = sin(ds / (2 \u003c\u003c m)));\n\n  const write = (p, Z, h, v) => {\n    const zh = Z - COLLAR, px = p % W;\n    if (px > 0 && zh > zb[p - 1]) (zb[p - 1] = zh), (hb[p - 1] = -1);\n    if (px \u003c W - 1 && zh > zb[p + 1]) (zb[p + 1] = zh), (hb[p + 1] = -1);\n    if (p >= W && zh > zb[p - W]) (zb[p - W] = zh), (hb[p - W] = -1);\n    if (p \u003c N - W && zh > zb[p + W]) (zb[p + W] = zh), (hb[p + W] = -1);\n    if (Z \u003c= zb[p]) return;\n    zb[p] = Z;\n    hb[p] = h;\n    vb[p] = v;\n  };\n\n  // The strand of level K is one closed curve, s from 0 to 2 pi 2^K, over\n  // the angle th = s mod 2 pi. It is plotted as a thin 8-connected line: a\n  // pixel that only turns the corner between two diagonal neighbours is\n  // dropped.\n  let ap = -1, aZ = 0, ah = 0, av = 0, bp = -1, bZ = 0, bh = 0, bv = 0;\n  const total = NT * M;\n  for (let i = 0; i \u003c total; i += step) {\n    const j = i % NT;\n    if (j === 0) {\n      // Exact phases at the start of every turn, so rounding never builds up.\n      const sv = (TAU * i) / NT;\n      for (let m = 0; m \u003c K; m++) (er[m] = cos(sv / (2 \u003c\u003c m))), (ei[m] = sin(sv / (2 \u003c\u003c m)));\n    }\n    let zr = 0, zi = 0;\n    for (let m = 0; m \u003c K; m++) {\n      zr += amp[m] * er[m];\n      zi += amp[m] * ei[m];\n      const r2 = er[m] * sr[m] - ei[m] * si[m];\n      ei[m] = er[m] * si[m] + ei[m] * sr[m];\n      er[m] = r2;\n    }\n    const o = j * 6, cq = C[o + 4], sq = C[o + 5];\n    const ur = zr * cq - zi * sq, ui = zr * sq + zi * cq;\n    const x = C[o] + R * ur * C[o + 2], y = C[o + 1] + R * ur * C[o + 3], z = R * ui;\n    const X = x * cp + z * sp, Z = -x * sp + z * cp;\n    const f = F / (F - Z);\n    const px = round(31.5 + X * f), py = round(63.5 - y * f);\n    if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) {\n      if (ap >= 0) write(ap, aZ, ah, av);\n      if (bp >= 0) write(bp, bZ, bh, bv);\n      ap = bp = -1;\n      continue;\n    }\n    const p = py * W + px;\n    if (p === bp) {\n      if (Z > bZ) bZ = Z;\n      continue;\n    }\n    const sv = (TAU * i) / NT;\n    const h = hue0 + 0.16 * cos(sv / 2) + 0.07 * cos(sv / 4);\n    const v = cl((Z + Dm) / (2 * Dm), 0, 1);\n    if (ap >= 0 && bp >= 0) {\n      const ax = ap % W, ay = (ap / W) | 0, bx = bp % W, by = (bp / W) | 0;\n      if (abs(ax - px) === 1 && abs(ay - py) === 1 && abs(bx - ax) + abs(by - ay) === 1 && abs(bx - px) + abs(by - py) === 1) {\n        (bp = p), (bZ = Z), (bh = h), (bv = v);\n        continue;\n      }\n    }\n    if (ap >= 0) write(ap, aZ, ah, av);\n    (ap = bp), (aZ = bZ), (ah = bh), (av = bv);\n    (bp = p), (bZ = Z), (bh = h), (bv = v);\n  }\n  if (ap >= 0) write(ap, aZ, ah, av);\n  if (bp >= 0) write(bp, bZ, bh, bv);\n\n  const body = [0, 0, 0];\n  hsv(0.68, 0.4, BODY, body, 0);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const h = hb[p];\n      if (h >= 0) {\n        // Near strands pale, far ones deep, all at full level.\n        hsv(h, 0.95 - 0.5 * vb[p], 1, rgb, 0);\n        display.setPixel(x, y, (255 * rgb[0]) | 0, (255 * rgb[1]) | 0, (255 * rgb[2]) | 0);\n      } else if (h === -2) display.setPixel(x, y, (255 * body[0]) | 0, (255 * body[1]) | 0, (255 * body[2]) | 0);\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n}\n","stokes-drift":"// ===== Patternflow pattern =====\n// Title:   Stokes Drift\n// Family:  wave\n// Idea:    A deep-water wave runs to the right across a cross-section of water 109 LEDs deep, and the particles stepped through its velocity field each trace a little orbit that falls short of closing, so the dye lines dropped straight down lean forward at the top along the curve e^(2kz) while the dots far below hardly stir.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Stokes drift (George Gabriel Stokes, 1847), against the trochoidal wave (Franz Gerstner, 1802), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Steepness=0.15..0.4, Gerstner=0..1\n//\n// Knob 1: Hue. Turns the four dye lines round the wheel together, magenta, gold, mint and azure at 0 from the left, and the dots' pale tint with them, pale green at 0; the surface stays white.\n// Knob 2: Speed. The wave's period, 2.6 s divided by the knob: 1.3 s at 2, 13 s at 0.2 and 0.87 s at 3. The wavelength stays 256 LEDs, four panel widths, so the panel shows a quarter of a wave.\n// Knob 3: Steepness. ak, the wave's amplitude times its wavenumber. At 0.15 the surface rises and falls 6.1 LEDs either side of its mean and the water at the top creeps 5.8 LEDs a period; at 0.25 10.2 LEDs and 16 a period; at 0.4 16.3 LEDs and 41 a period. The drift halves every 14.1 LEDs of depth, the orbits every 28.2. New dye drops when the top of the old has run 48 LEDs or after 12 periods.\n// Knob 4: Gerstner. Where each particle reads the wave's velocity. At 0 it reads it where it is, Airy's linear wave in Euler's view, and the orbits leave the drift omega k a^2 e^(2kz) behind; at 1 it reads it at the centre of its own orbit, which is Gerstner's exact trochoidal wave, whose orbits close and the dye lines only sway. In between the drift is close to 1 minus the knob times the full one: 0.94 at the opening 0.06, 0.52 at 0.5.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, exp, sin, cos, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Wavelength and domain: the water is periodic over one wavelength, 256\n// LEDs, and the panel shows the first 64 of it.\nconst L = 256, K = (2 * PI) / L;\n// The mean surface sits on row 18; depth runs down to row 127, 109 LEDs.\nconst SURF = 18, DEEP = H - 1 - SURF;\n// Material: a dot every 8 LEDs across and down, four dye lines of 220\n// points packed towards the top, and a chain of 256 surface particles.\nconst DX = 8, DZ = 8, NLINE = 4, NPT = 220, NSURF = 256;\nconst LINE_X = [8, 24, 40, 56];\nconst HUES = [0.88, 0.13, 0.42, 0.6];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A set of particles: position (x, z), z up from the mean surface, x not\n// wrapped so a particle's whole run can be read; and (rx, rz), the centre of\n// its orbit as the linear wave would have it. Dots and the surface are\n// placed by their centres and seated on their orbits.\nfunction pack(n) {\n  return { n, x: new Float64Array(n), z: new Float64Array(n), rx: new Float64Array(n), rz: new Float64Array(n) };\n}\nfunction place(P, i, x, z) {\n  P.x[i] = P.rx[i] = x;\n  P.z[i] = P.rz[i] = z;\n}\n\nexport function setup(params) {\n  const nd = (L / DX) * floor(DEEP / DZ + 1);\n  const s = {\n    ph: 0, hue: 0, speed: 2, ak: 0.15, akSeat: -1, g: 0.06, age: 0, fade: 0,\n    dots: pack(nd), lines: pack(NLINE * NPT), old: pack(NLINE * NPT), surf: pack(NSURF),\n    trail: new Float32Array(W * H), rgb: new Float32Array(W * H * 3), c: new Float32Array(3),\n  };\n  let i = 0;\n  for (let z = -4; z >= -DEEP; z -= DZ) for (let x = 4; x \u003c L; x += DX) place(s.dots, i++, x, z);\n  s.dots.n = i;\n  for (let j = 0; j \u003c NSURF; j++) place(s.surf, j, j * (L / NSURF), 0);\n  seat(s);\n  dye(s);\n  params.s = s;\n}\n\n// Fresh dye lines, dropped straight down from the surface chain to the bottom,\n// their points packed towards the top where the water moves most. Each\n// point's orbit centre is found from where it is.\nfunction dye(s) {\n  const a = s.ak / K;\n  for (let l = 0; l \u003c NLINE; l++) {\n    const x0 = LINE_X[l], top = level(s.surf, x0);\n    for (let k = 0; k \u003c NPT; k++) {\n      const i = l * NPT + k, z0 = top + (-DEEP - top) * (k / (NPT - 1)) ** 1.6;\n      s.lines.x[i] = s.lines.rx[i] = x0;\n      s.lines.z[i] = s.lines.rz[i] = z0;\n      centre(s.lines, i, a, s.ph, 12);\n    }\n  }\n  s.age = 0;\n}\n\n// The height of the surface chain above x: the pair of neighbours that\n// straddles x, wrapped onto one wavelength.\nfunction level(S, x) {\n  for (let j = 0; j \u003c S.n; j++) {\n    const k = j + 1 \u003c S.n ? j + 1 : 0;\n    const x1 = S.x[j] - floor(S.x[j] / L) * L;\n    let x2 = S.x[k] - floor(S.x[k] / L) * L;\n    if (x2 \u003c x1 - L / 2) x2 += L;\n    for (const xx of [x, x + L])\n      if (xx >= x1 && xx \u003c x2) return S.z[j] + ((S.z[k] - S.z[j]) * (xx - x1)) / (x2 - x1);\n  }\n  return 0;\n}\n\n// The surface is a material line, and at steep waves its particles bunch\n// at some crests and leave gaps elsewhere. When a gap opens past 1.2 LEDs\n// the chain is laid out again at even steps along the same curve, each new\n// point with its own orbit centre.\nfunction even(s) {\n  const S = s.surf, n = S.n, a = s.ak / K, cum = new Float64Array(n + 1);\n  let gap = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const k = j + 1 \u003c n ? j + 1 : 0, dx = S.x[k] + (k ? 0 : L) - S.x[j], d = Math.hypot(dx, S.z[k] - S.z[j]);\n    cum[j + 1] = cum[j] + d;\n    gap = max(gap, d);\n  }\n  if (gap \u003c 1.2) return;\n  const ox = Float64Array.from(S.x), oz = Float64Array.from(S.z), orx = Float64Array.from(S.rx), orz = Float64Array.from(S.rz);\n  for (let m = 0, j = 0; m \u003c n; m++) {\n    const want = (cum[n] * m) / n;\n    while (cum[j + 1] \u003c want) j++;\n    const k = j + 1 \u003c n ? j + 1 : 0, u = (want - cum[j]) / max(1e-9, cum[j + 1] - cum[j]), w = k ? 0 : L;\n    S.x[m] = ox[j] + (ox[k] + w - ox[j]) * u;\n    S.z[m] = oz[j] + (oz[k] - oz[j]) * u;\n    S.rx[m] = orx[j] + (orx[k] + w - orx[j]) * u;\n    S.rz[m] = orz[j] + (orz[k] - orz[j]) * u;\n    centre(S, m, a, s.ph, 6);\n  }\n}\n\n// The orbit centre r of a particle at p: p = r + xi(r), where the linear\n// wave moves a particle by xi = a e^(k rz) (-sin, cos)(k rx - phase); found\n// by turns of the fixed point from the last centre.\nfunction centre(P, i, a, ph, turns) {\n  const x = P.x[i], z = P.z[i];\n  let rx = P.rx[i], rz = P.rz[i];\n  for (let it = 0; it \u003c turns; it++) {\n    const e = a * exp(K * rz), th = K * rx - ph;\n    rx = x + e * sin(th);\n    rz = z - e * cos(th);\n  }\n  P.rx[i] = rx;\n  P.rz[i] = rz;\n}\n\n// Every particle put back on its orbit for steepness ak, keeping the orbit's\n// centre, and the surface chain's centres on the mean surface. After a turn\n// of Steepness the old orbits would leave dots above the new troughs, and a\n// particle above the water rides the linear wave's crest away.\nfunction seat(s) {\n  const a = s.ak / K;\n  for (const P of [s.dots, s.lines, s.old, s.surf])\n    for (let i = 0; i \u003c P.n; i++) {\n      if (P === s.surf) P.rz[i] = 0;\n      const rz = min(0, P.rz[i]), e = a * exp(K * rz), th = K * P.rx[i] - s.ph;\n      P.rz[i] = rz;\n      P.x[i] = P.rx[i] - e * sin(th);\n      P.z[i] = rz + e * cos(th);\n    }\n  s.akSeat = s.ak;\n}\n\n// One step of every particle in a set from phase ph by dph (radians of the\n// wave, so dt = dph / omega). The velocity of the linear deep-water wave\n// eta = a cos(kx - wt) is a w e^(kz) (cos, sin)(kx - wt); per radian of\n// phase, which is how it is stepped here, the w drops out. Airy's particles\n// read it where they are; Gerstner's read it at their orbit's centre. The\n// knob g reads it at centre + (1 - g)(where they are - centre). Only the\n// Airy reading feels the wave's gradient across the orbit, and that is all\n// the drift there is: nothing pushes a particle forward by hand.\nfunction step(P, ph, dph, ak, g) {\n  const a = ak / K, h = dph, f = 1 - g;\n  for (let i = 0; i \u003c P.n; i++) {\n    centre(P, i, a, ph, 2);\n    const x = P.x[i], z = P.z[i], rx = P.rx[i], rz = P.rz[i];\n    // Classical fourth-order Runge-Kutta with the centre held for the step.\n    let k1x, k1z, k2x, k2z, k3x, k3z, k4x, k4z, px, pz, e, th;\n    px = rx + f * (x - rx);\n    pz = rz + f * (z - rz);\n    e = a * exp(K * pz);\n    th = K * px - ph;\n    k1x = e * cos(th);\n    k1z = e * sin(th);\n    px = rx + f * (x + 0.5 * h * k1x - rx);\n    pz = rz + f * (z + 0.5 * h * k1z - rz);\n    e = a * exp(K * pz);\n    th = K * px - ph - 0.5 * h;\n    k2x = e * cos(th);\n    k2z = e * sin(th);\n    px = rx + f * (x + 0.5 * h * k2x - rx);\n    pz = rz + f * (z + 0.5 * h * k2z - rz);\n    e = a * exp(K * pz);\n    k3x = e * cos(K * px - ph - 0.5 * h);\n    k3z = e * sin(K * px - ph - 0.5 * h);\n    px = rx + f * (x + h * k3x - rx);\n    pz = rz + f * (z + h * k3z - rz);\n    e = a * exp(K * pz);\n    th = K * px - ph - h;\n    k4x = e * cos(th);\n    k4z = e * sin(th);\n    P.x[i] = x + (h / 6) * (k1x + 2 * k2x + 2 * k3x + k4x);\n    P.z[i] = z + (h / 6) * (k1z + 2 * k2z + 2 * k3z + k4z);\n    // A particle thrown over the crests is put back on its orbit.\n    if (!(P.z[i] \u003c 1.6 * a)) {\n      const c = min(0, rz), e2 = a * exp(K * c);\n      P.x[i] = rx - e2 * sin(K * rx - ph - h);\n      P.z[i] = c + e2 * cos(K * rx - ph - h);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0.15, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.ak = cl(kv[2], 0.15, 0.4);\n  s.g = cl(kv[3], 0, 1);\n  if (s.ak !== s.akSeat) seat(s);\n  // Phase advance this frame, in steps of at most 0.1 rad.\n  const dph = ((2 * PI) / 2.6) * s.speed * d, n = Math.ceil(dph / 0.1);\n  for (let k = 0; k \u003c n; k++) {\n    for (const P of [s.dots, s.lines, s.surf]) step(P, s.ph, dph / n, s.ak, s.g);\n    if (s.fade > 0) step(s.old, s.ph, dph / n, s.ak, s.g);\n    s.ph += dph / n;\n  }\n  // The surface chain's orbit centres are eased back onto the mean surface,\n  // a twentieth a frame. Left alone, at Steepness past 0.33 particles that\n  // started at a crest and at a trough settle at slightly different mean\n  // heights, drift at different speeds and fold the line within a minute.\n  const S = s.surf, a = s.ak / K;\n  for (let j = 0; j \u003c S.n; j++) {\n    centre(S, j, a, s.ph, 2);\n    const dz = 0.05 * S.rz[j];\n    S.rz[j] -= dz;\n    S.z[j] -= dz;\n  }\n  even(s);\n  s.age += dph;\n  s.fade = max(0, s.fade - d * 1.2);\n  // New dye when the top of the lines has run 48 LEDs ahead, or after 12\n  // periods; the old lines fade out over a second.\n  const run = s.lines.x[0] - LINE_X[0];\n  if (run > 48 || s.age > 12 * 2 * PI) {\n    const t = s.old;\n    s.old = s.lines;\n    s.lines = t;\n    s.fade = 1;\n    dye(s);\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const T = s.trail, B = s.rgb, c = s.c;\n  // The dots leave a short trail, so each traces its orbit.\n  for (let i = 0; i \u003c W * H; i++) T[i] *= 0.9;\n  B.fill(0);\n  const wrap = (x) => x - floor(x / L) * L;\n  const splat = (buf, x, y, v) => {\n    const x0 = floor(x - 0.5), y0 = floor(y - 0.5), fx = x - 0.5 - x0, fy = y - 0.5 - y0;\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const X = x0 + dx, Y = y0 + dy;\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const wgt = (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy);\n        buf[Y * W + X] += v * wgt;\n      }\n  };\n  const D = s.dots;\n  for (let i = 0; i \u003c D.n; i++) {\n    let x = wrap(D.x[i]);\n    if (x > L - 1) x -= L;\n    if (x \u003c W + 1) splat(T, x, SURF - D.z[i], 0.3);\n  }\n  // A line through a chain of points, drawn as samples every half LED, each\n  // lighting its four nearest LEDs by how near it falls.\n  const chain = (P, from, to, r, g, b, closed) => {\n    for (let i = from; i \u003c to - (closed ? 0 : 1); i++) {\n      const j = i + 1 \u003c to ? i + 1 : from;\n      const x1 = wrap(P.x[i]);\n      let x2 = wrap(P.x[j]);\n      if (x2 - x1 > L / 2) x2 -= L;\n      else if (x1 - x2 > L / 2) x2 += L;\n      const y1 = SURF - P.z[i], y2 = SURF - P.z[j];\n      const m = max(1, Math.ceil(2 * max(abs(x2 - x1), abs(y2 - y1))));\n      for (let k = 0; k \u003c m; k++) {\n        const u = k / m, y = y1 + (y2 - y1) * u;\n        let xx = x1 + (x2 - x1) * u;\n        if (xx > W + 1) xx -= L;\n        if (xx \u003c -1 || xx > W + 1) continue;\n        const x0 = floor(xx - 0.5), y0 = floor(y - 0.5), fx = xx - 0.5 - x0, fy = y - 0.5 - y0;\n        for (let dy = 0; dy \u003c 2; dy++)\n          for (let dx = 0; dx \u003c 2; dx++) {\n            const X = x0 + dx, Y = y0 + dy;\n            if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n            const wgt = min(1, 2 * (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy)), o = (Y * W + X) * 3;\n            B[o] = max(B[o], r * wgt);\n            B[o + 1] = max(B[o + 1], g * wgt);\n            B[o + 2] = max(B[o + 2], b * wgt);\n          }\n      }\n    }\n  };\n  for (let l = 0; l \u003c NLINE; l++) {\n    hsv(HUES[l] + s.hue, 0.75, 1, c, 0);\n    chain(s.lines, l * NPT, (l + 1) * NPT, c[0], c[1], c[2], false);\n    if (s.fade > 0) chain(s.old, l * NPT, (l + 1) * NPT, c[0] * s.fade * 0.6, c[1] * s.fade * 0.6, c[2] * s.fade * 0.6, false);\n  }\n  chain(s.surf, 0, NSURF, 0.85, 0.88, 0.95, true);\n  // The dots in a pale tint half the wheel from the first dye line.\n  hsv(HUES[0] + 0.5 + s.hue, 0.55, 0.62, c, 0);\n  const dr = c[0], dg = c[1], db = c[2];\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3, t = min(0.5, T[p]);\n      display.setPixel(x, y, round(min(1, B[o] + t * dr) * 255), round(min(1, B[o + 1] + t * dg) * 255), round(min(1, B[o + 2] + t * db) * 255));\n    }\n}\n","terrell-rotation":"// ===== Patternflow pattern =====\n// Title:   Terrell Rotation\n// Family:  space\n// Idea:    A sheet of cubes and spheres slides up past a pinhole camera at a share of light's speed, and each LED shows the light that left the sheet earlier and reaches the camera now, so the cubes look turned to show their undersides instead of squashed, the spheres keep round outlines while their nets swing round, and the colours shift towards blue below, where the light left parts coming on.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Terrell-Penrose rotation (James Terrell, 1959; Roger Penrose, 1959), after Anton Lampa (1924), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beta=0.5..0.95, Distance=2..8\n//\n// Knob 1: Hue. The sheet's colour at rest, azure at 0, turned round the wheel. The Doppler shift moves each LED along the wheel from there by 0.12 times the log of the Doppler factor: towards violet where the light left a part coming towards the camera, towards green where it left a part going away.\n// Knob 2: Speed. How fast the sheet slides on the panel, not its speed against light's: 0.45 times the knob in cells of the sheet's own length a second, 0.9 at 2, so a new row comes in about every 1.1 s whatever Beta is.\n// Knob 3: Beta. The sheet's speed as a share of light's, from 0.5, where a cube seen straight out from the camera looks turned 30 degrees, through 36.9 at 0.6 to 64.2 at 0.9 and 71.8 at 0.95, the arcsine of Beta, showing its trailing underside; the spheres stay round. The rows bunch up towards the top, and straight out the light arrives with the Doppler factor 1/gamma, 0.44 at 0.9.\n// Knob 4: Distance. The camera's distance from the sheet, 2 to 8 cells, with the lens zoomed to keep three columns across the panel: it sees 54 degrees above and below the middle at 2, where the near rows bend, and 19 degrees at 8, where every cube is turned by nearly the same angle.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, acos, atan2, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The sheet in its own rest frame, in cells: a cube or a sphere on every\n// cell of a square grid in the plane z = D, chequered, cubes 0.5 on a side\n// and spheres 0.68 across, so neither touches a neighbour.\nconst HC = 0.25, RS = 0.34, HM = 0.34;\n// The net on each sphere: its pole looks back at the camera along -z,\n// parallels every 30 degrees and six meridians.\nconst DPAR = PI / 6, DMER = PI / 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    phi: 0, hue: 0, speed: 2, beta: 0, dist: 2, key: \"\",\n    // Per LED: the ray in the sheet's frame (ex, ey, ez) and the Doppler\n    // factor of light arriving along it.\n    ray: new Float32Array(W * H * 4), rgb: new Float32Array(3),\n  };\n}\n\n// One pixel is one direction at the camera. Light reaching the camera from\n// camera-frame direction d (unit, y up the panel) left the sheet along the\n// sheet-frame direction (dx, gamma (dy + beta), dz) / (gamma (1 + beta dy)):\n// aberration, the whole of the effect. Emission point and arrival meet on a\n// straight line in the sheet's frame, so a ray traced there from the\n// camera's present place finds what the LED shows. 1 / (gamma (1 + beta dy))\n// is the Doppler factor. Rays only change with Beta and the lens.\nfunction aim(s) {\n  const b = s.beta, g = 1 / sqrt(1 - b * b), F = 23 * s.dist, R = s.ray;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 4) {\n      const X = (x + 0.5 - 32) / F, A = (64 - y - 0.5) / F, n = 1 / sqrt(X * X + A * A + 1);\n      const dy = A * n, k = 1 / (g * (1 + b * dy));\n      R[o] = X * n * k;\n      R[o + 1] = g * (dy + b) * k;\n      R[o + 2] = n * k;\n      R[o + 3] = k;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.beta = cl(kv[2], 0.5, 0.95);\n  s.dist = cl(kv[3], 2, 8);\n  // phi is how far the camera has gone through the sheet, in the sheet's\n  // own cells.\n  s.phi += d * 0.45 * s.speed;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const key = s.beta.toFixed(4) + \"/\" + s.dist.toFixed(3);\n  if (key !== s.key) aim(s), (s.key = key);\n  const R = s.ray, D = s.dist, F = 23 * D, phi = s.phi % 2, out = s.rgb, h0 = 0.56 + s.hue;\n  const z0 = D - HM, z1 = D + HM;\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 4) {\n      const ex = R[o], ey = R[o + 1], ez = R[o + 2], dop = R[o + 3];\n      // The slab the sheet fills, and the cells the ray crosses inside it.\n      const t0 = z0 / ez, t1 = z1 / ez;\n      const ya = -phi + t0 * ey, yb = -phi + t1 * ey, xa = t0 * ex, xb = t1 * ex;\n      const jlo = Math.ceil(min(ya, yb) - HM), jhi = floor(max(ya, yb) + HM);\n      const clo = max(-2, Math.ceil(min(xa, xb) - HM)), chi = min(2, floor(max(xa, xb) + HM));\n      let best = 1e9, kind = 0, bj = 0, bc = 0, axis = 0;\n      for (let j = jlo; j \u003c= jhi; j++)\n        for (let c = clo; c \u003c= chi; c++) {\n          // Local ray origin: the camera relative to this cell's centre.\n          const ox = -c, oy = -phi - j, oz = -D;\n          if (((j + c) & 1) === 0) {\n            // A cube, by slabs.\n            let tn = -1e9, tf = 1e9, ax = 0;\n            const ix = 1 / ex, iy = 1 / ey;\n            let a = (-HC - ox) * ix, b2 = (HC - ox) * ix;\n            if (a > b2) [a, b2] = [b2, a];\n            if (a > tn) (tn = a), (ax = 0);\n            if (b2 \u003c tf) tf = b2;\n            a = (-HC - oy) * iy;\n            b2 = (HC - oy) * iy;\n            if (a > b2) [a, b2] = [b2, a];\n            if (a > tn) (tn = a), (ax = 1);\n            if (b2 \u003c tf) tf = b2;\n            a = (-HC - oz) / ez;\n            b2 = (HC - oz) / ez;\n            if (a > tn) (tn = a), (ax = 2);\n            if (b2 \u003c tf) tf = b2;\n            if (tn \u003c= tf && tn > 0 && tn \u003c best) (best = tn), (kind = 1), (bj = j), (bc = c), (axis = ax);\n          } else {\n            const b2 = ox * ex + oy * ey + oz * ez, cc = ox * ox + oy * oy + oz * oz - RS * RS, disc = b2 * b2 - cc;\n            if (disc \u003c= 0) continue;\n            const t = -b2 - sqrt(disc);\n            if (t > 0 && t \u003c best) (best = t), (kind = 2), (bj = j), (bc = c);\n          }\n        }\n      if (!kind) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const px = best * ex - bc, py = best * ey - phi - bj, pz = best * ez - D;\n      // The size of one LED on the surface, in cells: Z / F across, and a\n      // Doppler factor shorter along the motion, then stretched where the\n      // surface is seen edge on.\n      const foot = (best * ez) / (F * sqrt(dop));\n      let fill, line;\n      if (kind === 1) {\n        const ea = axis === 0 ? abs(ex) : axis === 1 ? abs(ey) : ez;\n        const u = axis === 0 ? max(abs(py), abs(pz)) : axis === 1 ? max(abs(px), abs(pz)) : max(abs(px), abs(py));\n        const L = (foot * ez) / max(0.22, ea);\n        line = cl(1.15 - (HC - u) / L, 0, 1);\n        // The face towards the camera's side is brightest, the rows' tops and\n        // bottoms next, the sides dimmest.\n        fill = axis === 2 ? 0.17 : axis === 1 ? 0.12 : 0.085;\n      } else {\n        const mx = px / RS, my = py / RS, mz = pz / RS;\n        const facing = -(mx * ex + my * ey + mz * ez);\n        const th = acos(cl(-mz, -1, 1)), ps = atan2(my, mx);\n        const dp = RS * abs(th - round(th / DPAR) * DPAR), dm = RS * Math.sin(th) * abs(ps - round(ps / DMER) * DMER);\n        const L = foot / max(0.25, facing);\n        line = max(cl(1.1 - dp / L, 0, 1), cl(1.1 - dm / L, 0, 1) * cl(th * 3, 0, 1));\n        // The pole itself, and the rim where the ray grazes the outline.\n        if (th \u003c 0.2) line = 1;\n        const rim = (1 - facing) * (1 - facing);\n        line = max(line, rim * rim * 1.4);\n        fill = 0.06 + 0.1 * facing;\n      }\n      // Doppler: hue along the wheel by 0.12 times the log of the factor, blue\n      // for light from parts coming on, held short of yellow, which reads olive\n      // when dim; and brightness by a softened searchlight, the\n      // factor to the power 0.6 where the true intensity goes as its cube.\n      const ld = Math.log(dop);\n      const bright = cl(Math.exp(0.6 * ld), 0.5, 1.35);\n      const v = min(1, (fill + (0.95 - fill) * line) * bright);\n      hsv(h0 + cl(0.12 * ld, -0.24, 0.16), 0.85 - 0.4 * line, v, out, 0);\n      display.setPixel(x, y, round(out[0] * 255), round(out[1] * 255), round(out[2] * 255));\n    }\n}\n","zagier-windmill":"// ===== Patternflow pattern =====\n// Title:   Zagier's Windmills\n// Family:  number\n// Idea:    A prime p one more than a multiple of four is drawn as a windmill of p cells, a central square with four rectangular sails, and Zagier's involution and the swap of the sails take turns redrawing it: Zagier's map keeps the windmill's outline and cuts a new central square from it, the swap turns every sail on its side, and the walk from Zagier's one fixed point ends at a windmill with square sails that slide together into the two squares whose areas add up to p, while below the plane of sail sizes y and z plots every windmill of p on its hyperbola and the zigzag path the walk took.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fermat's theorem on sums of two squares (Pierre de Fermat, 1640; Leonhard Euler, 1749), Zagier's one-sentence proof (Don Zagier, 1990, after Roger Heath-Brown, 1984), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Prime=1..13, Zoom=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the central square is pale gold and the sails on its top, right, bottom and left are green, cyan, blue and violet; in the plot the hyperbolas and Zagier's steps are gold and the swaps pale blue. At 0.5 the square is pale blue and the sails pink, red, orange and lime.\n// Knob 2: Speed. At 2 each step of the walk takes 1 second and holds half a second; the first windmill grows in 0.8 s and the end, a pause, the slide into two squares, the show and the fade, takes 4.4 s. So 13 takes 8.2 s, 97 with its walk of 26 steps 44 s, and the 14 primes 5.1 minutes. 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Prime. Which prime the cycle opens with: 1 is 13, 2 is 17, and so on to 13, which is 113. After 113 the cycle comes round to 5, whose windmill (1, 1, 1) is a plus that both maps leave alone, then 13 again. The walks are 2, 4, 4, 6, 10, 6, 10, 20, 20, 26, 10, 16 and 22 steps long, and for each of these primes the walk passes through every windmill of p, 3 for 13 and 23 for 113.\n// Knob 4: Zoom. 1 to 2.5 times the size that fits the windmill into the top 64 rows, which is 8 LEDs a cell for small windmills and 1 LED for the plus of 113, 57 cells across; at most 14 LEDs a cell. Turned up, the central square and the roots of the sails fill the top, where Zagier's map makes its cut, and the long sails run off the edges.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, cos, sin, atan2, round, log, PI, SQRT2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n// The primes one more than a multiple of four whose first windmill, a plus\n// sign (p + 1) / 2 cells across, fits the 64 columns.\nconst PR = [5, 13, 17, 29, 37, 41, 53, 61, 73, 89, 97, 101, 109, 113];\n// Seconds at Speed 2: the first windmill grows, each step of the walk\n// moves and holds, then the pause, the slide into two squares, the show\n// and the fade.\nconst GROW = 0.8, STEP = 1.0, HOLD = 0.5, PAUSE = 0.4, SLIDE = 1.4, SHOW = 2.0, FADE = 0.6;\n// The plot of sail sizes: y across from column 3, z up from row 126.\nconst PX = 3, PY = 126, PS = 58;\n\n// Zagier's involution on x^2 + 4yz = p, and which of its three cases ran.\nfunction zag(x, y, z) {\n  if (x \u003c y - z) return [x + 2 * z, z, y - x - z, 1];\n  if (x \u003c 2 * y) return [2 * y - x, y, x - y + z, 2];\n  return [x - 2 * y, x - y + z, y, 3];\n}\n\n// The walk for p: from Zagier's fixed point (1, 1, (p - 1) / 4), swap and\n// Zagier's map in turn until the swap would fix the windmill (y = z). Each\n// windmill keeps a turning sense: Zagier's middle case keeps the outline of\n// the mirror image, so it flips the sense, and the outline then stays put.\nfunction plan(p) {\n  const k = (p - 1) / 4, path = [[1, 1, k, 1]];\n  for (let t = path[0]; t[1] !== t[2]; ) {\n    t = [t[0], t[2], t[1], t[3]];\n    path.push(t);\n    if (t[1] === t[2]) break;\n    const z = zag(t[0], t[1], t[2]);\n    t = [z[0], z[1], z[2], z[3] === 2 ? -t[3] : t[3]];\n    path.push(t);\n  }\n  const S = [];\n  for (let x = 1; x * x \u003c p; x += 2) {\n    const m = (p - x * x) / 4;\n    for (let y = 1; y \u003c= m; y++) if (m % y === 0) S.push([x, y, m / y]);\n  }\n  const n = path.length - 1, end = GROW + n * (STEP + HOLD);\n  const lm = [];\n  for (let x = 1; x * x \u003c p; x += 2) lm.push(log((p - x * x) / 4));\n  return { p, k, path, S, n, lm, end, total: end + PAUSE + SLIDE + SHOW + FADE };\n}\n\n// The five pieces of a windmill, each as a rectangle (centre u, centre v,\n// half width, half height, turn) in cells about the centre of its square:\n// the square, then the sails on its top, right, bottom and left. Each sail\n// is y cells along its side, starting from a corner, and z cells out. A\n// turning sense of -1 mirrors the windmill.\nfunction mill(x, y, z, h, out) {\n  const c = x / 2;\n  const R = [[-c, c, -c, c], [-c, -c + y, c, c + z], [c, c + z, c - y, c], [c - y, c, -c - z, -c], [-c - z, -c, -c, -c + y]];\n  for (let i = 0; i \u003c 5; i++) {\n    const r = R[i], o = i * 5;\n    out[o] = (h * (r[0] + r[1])) / 2;\n    out[o + 1] = (r[2] + r[3]) / 2;\n    out[o + 2] = (r[1] - r[0]) / 2;\n    out[o + 3] = (r[3] - r[2]) / 2;\n    out[o + 4] = 0;\n  }\n  return out;\n}\n// The windmill with square sails as the squares x^2 and (2y)^2, side by\n// side and one cell apart, its four sails the quarters of the second.\nfunction squares(x, y, out) {\n  const c = x / 2, L = -c - y, B = -c - floor((max(x, 2 * y) - x) / 2), R = L + x + 1;\n  const Q = [[L + c, B + c, c], [R + y / 2, B + 1.5 * y, y / 2], [R + 1.5 * y, B + 1.5 * y, y / 2], [R + 1.5 * y, B + y / 2, y / 2], [R + y / 2, B + y / 2, y / 2]];\n  for (let i = 0; i \u003c 5; i++) {\n    const o = i * 5;\n    (out[o] = Q[i][0]), (out[o + 1] = Q[i][1]), (out[o + 2] = out[o + 3] = Q[i][2]), (out[o + 4] = 0);\n  }\n  return out;\n}\nconst span = (t) => max(t[0] + 2 * t[2], 2 * t[1] - t[0]);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, clock: 0, idx: -1, first: -1, hue: -1, rate: 1, zoom: 1, P: null,\n    ra: new Float32Array(25), rb: new Float32Array(25), pal: new Float32Array(24),\n    buf: new Float32Array(W * H * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const first = round(cl(kv[2], 1, 13));\n  s.rate = cl(kv[1], 0.2, 3) / 2;\n  s.zoom = 1 + 1.5 * cl(kv[3], 0, 1);\n  const hue = cl(kv[0], 0, 1);\n  if (hue !== s.hue) {\n    // The square pale gold, the sails green, cyan, blue and violet.\n    s.hue = hue;\n    hsv(0.13 + hue, 0.3, 1, s.pal, 0);\n    [0.36, 0.5, 0.63, 0.79].forEach((h, i) => hsv(h + hue, 0.78, 1, s.pal, 3 + i * 3));\n    hsv(0.6 + hue, 0.25, 1, s.pal, 15);\n    hsv(0.12 + hue, 0.55, 1, s.pal, 18);\n  }\n  if (first !== s.first) (s.first = first), (s.idx = first), (s.P = plan(PR[first])), (s.t = 0);\n  s.t += d * s.rate;\n  s.clock += d * s.rate;\n  if (s.t >= s.P.total) (s.t -= s.P.total), (s.idx = (s.idx + 1) % PR.length), (s.P = plan(PR[s.idx]));\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.P) return;\n  const P = s.P, B = s.buf, pal = s.pal, t = s.t;\n  B.fill(0);\n  const add = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    B[o] = max(B[o], r);\n    B[o + 1] = max(B[o + 1], g);\n    B[o + 2] = max(B[o + 2], b);\n  };\n  // Where the walk is: step i moving with progress e, or the end.\n  let i = 0, e = 0, grow = 1, slide = 0, fade = 1;\n  if (t \u003c GROW) grow = ease(t / GROW);\n  else if (t \u003c P.end) {\n    const u = (t - GROW) / (STEP + HOLD);\n    i = floor(u) + 1;\n    e = ease(((u - floor(u)) * (STEP + HOLD)) / STEP);\n  } else {\n    i = P.n;\n    slide = ease((t - P.end - PAUSE) / SLIDE);\n    fade = 1 - ease((t - P.end - PAUSE - SLIDE - SHOW) / FADE);\n  }\n  const a = P.path[max(0, i - 1)], b = P.path[i];\n  const ra = s.ra, rb = s.rb;\n  // The pieces this frame: ra, and for a step of Zagier's map the new\n  // pieces rb, cut in as a square that spreads out from the centre.\n  let cut = -1, fit;\n  if (t \u003c GROW) mill(1, 1, P.k * grow, 1, ra), (fit = span(b));\n  else if (t \u003c P.end && i % 2 === 1) {\n    // The swap: every sail turns a quarter about its middle, the way the\n    // windmill turns, while its middle slides to where the turned sail\n    // belongs: y cells along and z out become z along and y out.\n    mill(a[0], a[1], a[2], a[3], ra);\n    mill(b[0], b[1], b[2], b[3], rb);\n    for (let j = 5; j \u003c 25; j += 5) {\n      ra[j] += (rb[j] - ra[j]) * e;\n      ra[j + 1] += (rb[j + 1] - ra[j + 1]) * e;\n      ra[j + 4] = (e * PI * a[3]) / 2;\n    }\n    fit = span(a) + (span(b) - span(a)) * e;\n  } else if (t \u003c P.end) {\n    mill(a[0], a[1], a[2], a[3], ra);\n    mill(b[0], b[1], b[2], b[3], rb);\n    cut = e * (span(a) / 2 + 1);\n    fit = span(a) + (span(b) - span(a)) * e;\n  } else {\n    mill(b[0], b[1], b[2], b[3], ra);\n    squares(b[0], b[1], rb);\n    for (let j = 0; j \u003c 25; j++) ra[j] += (rb[j] - ra[j]) * slide;\n    fit = span(b) + (b[0] + 1 + 2 * b[1] - span(b)) * slide;\n  }\n  const cs = min(14, min(8, 58 / fit) * s.zoom), light = s.clock * 1.6 * b[3];\n  // Which piece an LED falls in, leaving its place in that piece in lu, lv\n  // (cells from the piece's corner) for the ruling of the cells.\n  let lu = 0, lv = 0;\n  const piece = (R, U, V) => {\n    for (let j = 0; j \u003c 5; j++) {\n      const o = j * 5, an = R[o + 4];\n      let du = U - R[o], dv = V - R[o + 1];\n      if (an !== 0) {\n        const c = cos(an), sn = sin(an), t0 = c * du + sn * dv;\n        (dv = c * dv - sn * du), (du = t0);\n      }\n      if (abs(du) \u003c R[o + 2] && abs(dv) \u003c R[o + 3]) return (lu = du + R[o + 2]), (lv = dv + R[o + 3]), j;\n    }\n    return -1;\n  };\n  // The top: the windmill on squared paper, one ruled line a cell, or\n  // every 2 or 4 cells when cells are small.\n  const step = cs >= 3 ? 1 : cs >= 1.5 ? 2 : 4;\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const U = (x + 0.5 - 31.5) / cs, V = (31.5 - (y + 0.5)) / cs;\n      const j = cut >= 0 && max(abs(U), abs(V)) \u003c cut ? piece(rb, U, V) : piece(ra, U, V);\n      if (j \u003c 0) {\n        const gu = U - 0.5, gv = V - 0.5, nu = round(gu / step) * step, nv = round(gv / step) * step;\n        if (abs(gu - nu) * cs \u003c 0.5 || abs(gv - nv) * cs \u003c 0.5) add(x, y, (0.05 + 0.13 * pal[12]) * fade, (0.05 + 0.13 * pal[13]) * fade, (0.05 + 0.13 * pal[14]) * fade);\n        continue;\n      }\n      // A light turns round the windmill the way its sails turn.\n      let k = (0.8 + 0.2 * cos(atan2(V, U) - light)) * fade;\n      if (cs >= 3.5 && ((lu - floor(lu)) * cs \u003c 1 || (lv - floor(lv)) * cs \u003c 1)) k *= 0.62;\n      // The front of the new central square as it spreads.\n      if (cut >= 0 && abs(max(abs(U), abs(V)) - cut) * cs \u003c 0.8) k = 1;\n      add(x, y, pal[j * 3] * k, pal[j * 3 + 1] * k, pal[j * 3 + 2] * k);\n    }\n\n  // The bottom: the plane of sail sizes, log y across and log z up. Every\n  // windmill of p lies on the hyperbola yz = (p - x^2) / 4 of its square's\n  // side x, which these axes draw as a straight line; the swap keeps x, so\n  // it slides a windmill along its own line, mirrored in the diagonal\n  // y = z, and Zagier's map jumps from line to line.\n  const lo = log(0.7), sc = PS / (log(P.k / 0.7) - lo), f2 = fade * min(1, t / GROW + 0.2);\n  const cur = t \u003c P.end && e \u003c 0.5 ? a : b, R2 = SQRT2;\n  for (let y = PY - PS; y \u003c PY; y++)\n    for (let x = PX; x \u003c PX + PS; x++) {\n      const lY = lo + (x + 0.5 - PX) / sc, lZ = lo + (PY - (y + 0.5)) / sc, q = lY + lZ;\n      let band = 0, hc = 0;\n      for (let j = 0; j \u003c P.lm.length; j++) {\n        if (q \u003c= P.lm[j]) band = j + 1;\n        if ((abs(q - P.lm[j]) * sc) / R2 \u003c 0.6) hc = 2 * j + 1;\n      }\n      // Below the outer line the bands between the lines, tinted with the\n      // sail colours, rippling along the lines in towards the diagonal.\n      if (band) {\n        const c = band & 1 ? 9 : 12, k = (0.15 + 0.06 * cos(abs(lY - lZ) * sc * 0.55 + s.clock * 3)) * f2;\n        add(x, y, pal[c] * k, pal[c + 1] * k, pal[c + 2] * k);\n      }\n      if ((abs(lY - lZ) * sc) / R2 \u003c 0.6) add(x, y, 0.3 * f2, 0.3 * f2, 0.34 * f2);\n      if (hc) {\n        const k = (hc === cur[0] ? 0.8 : 0.34) * f2;\n        add(x, y, pal[18] * k, pal[19] * k, pal[20] * k);\n      }\n    }\n  // The walk so far, segment by segment, the swaps in pale blue and\n  // Zagier's steps in gold, then the windmills of p as dots: grey until the\n  // walk reaches them, gold after, the one shown above white.\n  const at = (tr) => [PX + (log(tr[1]) - lo) * sc, PY - (log(tr[2]) - lo) * sc];\n  const segs = t \u003c GROW ? 0 : t \u003c P.end ? i : P.n;\n  for (let j = 1; j \u003c= segs; j++) {\n    const [x0, y0] = at(P.path[j - 1]), [x1, y1] = at(P.path[j]);\n    const reach = j === i && t \u003c P.end ? e : 1, n = max(1, round(max(abs(x1 - x0), abs(y1 - y0)) * reach));\n    const c = j % 2 ? 15 : 18, k = 0.9 * fade;\n    for (let q = 0; q \u003c= n; q++) {\n      const u = (q / n) * reach;\n      add(floor(x0 + (x1 - x0) * u), floor(y0 + (y1 - y0) * u), pal[c] * k, pal[c + 1] * k, pal[c + 2] * k);\n    }\n  }\n  const rad = cl(sc * 0.12, 0.8, 3), pulse = 0.75 + 0.25 * cos(s.clock * 7);\n  for (const tr of P.S) {\n    const [cx, cy] = at(tr);\n    let seen = false;\n    for (let q = 0; q \u003c= segs; q++) if (P.path[q][0] === tr[0] && P.path[q][1] === tr[1] && P.path[q][2] === tr[2]) seen = true;\n    const now = tr[0] === cur[0] && tr[1] === cur[1] && tr[2] === cur[2];\n    const k = (now ? pulse : seen ? 0.9 : 0.45) * f2, r = now ? 1 : seen ? pal[18] : 0.8, g = now ? 1 : seen ? pal[19] : 0.8, bl = now ? 1 : seen ? pal[20] : 0.85;\n    for (let yy = floor(cy - rad); yy \u003c= cy + rad; yy++)\n      for (let xx = floor(cx - rad); xx \u003c= cx + rad; xx++)\n        if ((xx + 0.5 - cx) ** 2 + (yy + 0.5 - cy) ** 2 \u003c= rad * rad + 0.3) add(xx, yy, r * k, g * k, bl * k);\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, round(B[o] * 255)), min(255, round(B[o + 1] * 255)), min(255, round(B[o + 2] * 255)));\n}\n","andrews-curves":"// ===== Patternflow pattern =====\n// Title:   Andrews Curves\n// Family:  data\n// Idea:    Forty synthetic points in five dimensions, three Gaussian clusters of 13 and one outlier, each become Andrews' curve f(t) = x1/sqrt 2 + x2 sin t + x3 cos t + x4 sin 2t + x5 cos 2t with t running down the panel, so the clusters hang as three braided bundles and the outlier strays, and as a grand tour turns the data the bundles twist past each other while the shaded gap between the outlier's white curve and its neighbour's keeps one root mean square, the fixed bar along the bottom.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Andrews plots (David F. Andrews, 1972), turned by the grand tour (Daniel Asimov, 1985), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=0.12..0.6, Dims=5..9\n//\n// Knob 1: Hue. Turns the three clusters round the wheel together. At 0 they are cyan, violet and green; at 0.25 indigo, rose and cyan; at 0.5 rose, green and blue. The marked pair stays white with a grey gap, and the wheel skips orange and yellow, which read brown and olive on the faint edges of the curves.\n// Knob 2: Speed. How fast the grand tour turns. At 2 each of the ten coordinate planes of five dimensions turns at its own rate between 0.10 and 0.20 radians a second, the rates linearly independent so the tour never repeats; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Spread. Each cluster's standard deviation in every coordinate, as a share of R, the distance from the middle to a cluster centre; the centres stand R sqrt 3 = 1.73 R apart and the outlier 1.72 R from each. At 0.12 a point lies on average 0.26 R from its centre in five dimensions and the bundles are tight ropes; at 0.6 it lies 1.3 R off, the clusters overlap and the curves spread into one tangle.\n// Knob 4: Dims. The data's dimension, 5 to 9; each two coordinates past the first add a harmonic, so the curves run to cos 2t at 5, cos 3t at 7 and cos 4t at 9 and the braids wind tighter. The clusters differ only in the first five coordinates, the rest is spread, and the gap's bar is 14.6 LEDs at 5, 12.6 at 7 and 11.3 at 9, held to three decimals through a minute of touring at each (the axis narrows as the dimension grows).\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The data: three synthetic Gaussian clusters of PER points each in up to\n// DMAX dimensions, and one outlier. Cluster centres sit R from the middle,\n// 120 degrees apart, so any two are R sqrt 3 apart.\nconst DMAX = 9, PER = 13, NC = 3, N = NC * PER + 1, R = 1;\n// Tour radians a second at Speed 1.\nconst RATE = 0.11;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nfunction gauss() {\n  const u = Math.random() || 1e-9, v = Math.random();\n  return sqrt(-2 * Math.log(u)) * cos(2 * PI * v);\n}\n\nexport function setup(params) {\n  // Two orthonormal directions in the first five coordinates carry the\n  // triangle of centres; a third, square to both, carries the outlier.\n  const basis = [];\n  for (let k = 0; k \u003c 3; k++) {\n    const v = new Float64Array(DMAX);\n    for (let i = 0; i \u003c 5; i++) v[i] = gauss();\n    for (const b of basis) {\n      let d = 0;\n      for (let i = 0; i \u003c DMAX; i++) d += v[i] * b[i];\n      for (let i = 0; i \u003c DMAX; i++) v[i] -= d * b[i];\n    }\n    let n = 0;\n    for (let i = 0; i \u003c DMAX; i++) n += v[i] * v[i];\n    for (let i = 0; i \u003c DMAX; i++) v[i] /= sqrt(n);\n    basis.push(v);\n  }\n  const centre = [], z = [];\n  for (let c = 0; c \u003c NC; c++) {\n    const a = (2 * PI * c) / NC, v = new Float64Array(DMAX);\n    for (let i = 0; i \u003c DMAX; i++) v[i] = R * (cos(a) * basis[0][i] + sin(a) * basis[1][i]);\n    centre.push(v);\n  }\n  // Each point keeps its own standard normal draw; Spread scales it.\n  for (let p = 0; p \u003c N; p++) {\n    const v = new Float64Array(DMAX);\n    for (let i = 0; i \u003c DMAX; i++) v[i] = gauss();\n    z.push(v);\n  }\n  // Asimov's torus method: every coordinate plane turns at its own rate,\n  // the rates linearly independent over the rationals (fractional parts of\n  // square roots of primes), so the product of turns wanders densely\n  // through all rotations.\n  const primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151];\n  const rate = [];\n  for (let i = 0, k = 0; i \u003c DMAX; i++) for (let j = i + 1; j \u003c DMAX; j++, k++) rate.push([i, j, 0.3 + 0.7 * (sqrt(primes[k]) % 1)]);\n  // Sines and cosines of each row's t, for the harmonics.\n  const trig = new Float64Array(H * DMAX);\n  for (let r = 0; r \u003c H; r++) {\n    const t = -PI + (2 * PI * (r + 0.5)) / H;\n    trig[r * DMAX] = 1 / Math.SQRT2;\n    for (let i = 1; i \u003c DMAX; i++) {\n      const k = (i + 1) >> 1;\n      trig[r * DMAX + i] = i & 1 ? sin(k * t) : cos(k * t);\n    }\n  }\n  // The outlier stands 1.4 R from the middle, square to the centres' plane,\n  // and is marked together with the member of the first cluster nearest to\n  // it at the opening Spread.\n  const outlier = basis[2].map((x) => 1.4 * R * x);\n  let near = 0, best = 1e9;\n  for (let p = 0; p \u003c PER; p++) {\n    let d2 = 0;\n    for (let i = 0; i \u003c 5; i++) d2 += (centre[0][i] + 0.12 * z[p][i] - outlier[i]) ** 2;\n    if (d2 \u003c best) (best = d2), (near = p);\n  }\n  params.s = {\n    centre, z, outlier, rate, trig, tau: 0,\n    hue: 0, speed: 2, spread: 0.12, d: 5,\n    Q: new Float64Array(DMAX * DMAX), x: new Float64Array(N * DMAX), y: new Float64Array(N * DMAX),\n    f: new Float32Array(N * H), acc: new Float32Array(NP * 3), col: new Float32Array(NC * 3 + 3), pair: [near, N - 1],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.12, 5], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.spread = cl(kv[2], 0.12, 0.6);\n  S.d = cl(round(kv[3]), 5, DMAX);\n  S.tau += d * S.speed * RATE;\n}\n\n// The tour's rotation of the first D coordinates at time tau: the turns of\n// every plane among them, taken in a fixed order.\nfunction tour(S, D) {\n  const Q = S.Q;\n  Q.fill(0);\n  for (let i = 0; i \u003c D; i++) Q[i * DMAX + i] = 1;\n  for (const [i, j, w] of S.rate) {\n    if (j >= D) continue;\n    const a = w * S.tau, c = cos(a), s = sin(a);\n    for (let k = 0; k \u003c D; k++) {\n      const qi = Q[i * DMAX + k], qj = Q[j * DMAX + k];\n      Q[i * DMAX + k] = c * qi - s * qj;\n      Q[j * DMAX + k] = s * qi + c * qj;\n    }\n  }\n}\n\n// Splat a point onto its four nearest LEDs, adding colour c scaled by a.\nfunction splat(acc, x, y, c, o, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = (dx ? tx : 1 - tx) * wy * a, p = (yy * W + xx) * 3;\n      acc[p] += c[o] * w;\n      acc[p + 1] += c[o + 1] * w;\n      acc[p + 2] += c[o + 2] * w;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const D = S.d, { x, y, f, acc, trig, Q, col } = S;\n  // The observations in their own coordinates.\n  for (let p = 0; p \u003c N; p++)\n    for (let i = 0; i \u003c DMAX; i++) {\n      const base = p \u003c NC * PER ? S.centre[floor(p / PER)][i] + S.spread * S.z[p][i] : S.outlier[i];\n      x[p * DMAX + i] = i \u003c D ? base : 0;\n    }\n  tour(S, D);\n  for (let p = 0; p \u003c N; p++)\n    for (let i = 0; i \u003c D; i++) {\n      let v = 0;\n      for (let k = 0; k \u003c D; k++) v += Q[i * DMAX + k] * x[p * DMAX + k];\n      y[p * DMAX + i] = v;\n    }\n  // Andrews' curves: f(t) = y1 / sqrt 2 + y2 sin t + y3 cos t + y4 sin 2t + ...\n  // By Cauchy-Schwarz |f| is at most |y| sqrt(D / 2), and a turn keeps |y|,\n  // so the axis is fixed for each D: R sqrt(D / 2), the most a centre's\n  // curve can reach, is 22 LEDs either side of the middle.\n  const sc = 22 / (R * sqrt(D / 2));\n  for (let p = 0; p \u003c N; p++)\n    for (let r = 0; r \u003c H; r++) {\n      let v = 0;\n      for (let i = 0; i \u003c D; i++) v += y[p * DMAX + i] * trig[r * DMAX + i];\n      f[p * H + r] = W / 2 + v * sc;\n    }\n  // Cyan, violet and green at Hue 0.\n  for (let c = 0; c \u003c NC; c++) hsv(wheel(0.58 + S.hue + [0, 0.27, 0.73][c]), 0.8, 1, col, c * 3);\n  col[9] = col[10] = col[11] = 1;\n  acc.fill(0);\n  const [pa, pb] = S.pair;\n  // The gap between the two marked curves, shaded faintly.\n  for (let r = 0; r \u003c H; r++) {\n    const a = f[pa * H + r], b = f[pb * H + r], lo = max(0, Math.ceil(min(a, b))), hi = min(W - 1, floor(max(a, b)));\n    for (let c = lo; c \u003c= hi; c++) {\n      const o = (r * W + c) * 3;\n      acc[o] += 0.1;\n      acc[o + 1] += 0.1;\n      acc[o + 2] += 0.12;\n    }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const ci = p \u003c NC * PER ? floor(p / PER) * 3 : 9, mark = p === pa || p === pb;\n    const a = mark ? 0.7 : 0.2;\n    for (let r = 0; r + 1 \u003c H; r++) {\n      const xa = f[p * H + r], xb = f[p * H + r + 1], len = Math.hypot(xb - xa, 1), m = Math.ceil(len * 3);\n      for (let e = 0; e \u003c m; e++) splat(acc, xa + ((xb - xa) * e) / m, r + 0.5 + e / m, col, mark ? 9 : ci, ((a * len) / m) * 3);\n    }\n  }\n  // Parseval: the mean of (f_x - f_y)^2 over t is |x - y|^2 / 2, and a\n  // turn keeps |x - y|, so the gap's root mean square over the 128 rows\n  // (exact for these few harmonics) never moves while the curves do. It is\n  // measured from the drawn curves each frame and laid as a bar, that many\n  // LEDs long, across the bottom two rows with a dark row above.\n  let ss = 0;\n  for (let r = 0; r \u003c H; r++) ss += (f[pa * H + r] - f[pb * H + r]) ** 2;\n  const half = sqrt(ss / H) / 2;\n  for (let c = 0; c \u003c W; c++) {\n    const e = half - abs(c + 0.5 - W / 2);\n    if (e \u003c -2) continue;\n    for (let r = H - 3; r \u003c H; r++) {\n      const o = (r * W + c) * 3;\n      acc[o] = acc[o + 1] = acc[o + 2] = r === H - 3 ? 0 : cl(e + 0.5, 0, 1);\n    }\n  }\n  // Where curves pile up the light saturates on the brightest channel and\n  // the others follow in proportion, so a dense bundle glows in its own\n  // colour instead of washing to white.\n  for (let p = 0, o = 0; p \u003c NP; p++, o += 3) {\n    const m = max(acc[o], acc[o + 1], acc[o + 2]), k = m > 0 ? (255 * (1 - exp(-2.2 * m))) / m : 0;\n    display.setPixel(p % W, (p / W) | 0, (acc[o] * k) | 0, (acc[o + 1] * k) | 0, (acc[o + 2] * k) | 0);\n  }\n}\n","bloch-oscillations":"// ===== Patternflow pattern =====\n// Title:   Bloch Oscillations\n// Family:  wave\n// Idea:    A quantum particle on a chain of sites laid across the panel feels a steady force along the chain, and with time running down the scrolling panel it never slides away: started on one site it breathes out into a lens of Bessel fringes 50 sites wide and back to a point once every Bloch period, a broad packet swings from side to side instead, and the hue gives the quasi-momentum, which the force winds steadily through the band.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Bloch oscillations (Felix Bloch, 1929; Clarence Zener, 1934) and the Wannier-Stark ladder (Gregory Wannier, 1960), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Force=0.16..0.64, Width=0..1\n//\n// Knob 1: Hue. Turns the wheel the quasi-momentum k is read on, k being the phase step from each site to the next. At 0 the bottom of the band (k = 0) is azure, a packet moving right at full speed (k = pi/2) violet, one moving left (k = -pi/2) green, and the top of the band (k = pi), where a broad packet is Bragg-reflected and turns back, red; orange takes a narrower slice of k than the other colours. The lens from one site opens violet on its right edge and lime on its left, and as the force winds k down, the right edge turns through blue to azure and the left edge through red to pink.\n// Knob 2: Speed. How fast the carpet climbs: one row is 0.75 in units of hbar / J. At 2 sixteen rows a second, so one Bloch period at the opening Force passes in 3.3 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Force. F in units of J per site, 0.16 to 0.64. The Bloch period 2 pi / F is 52 rows at 0.16, 26 at 0.32 and 13 at 0.64, and the lens from one site opens to 4J/F either side, 25, 12.5 and 6.3 sites, which is 57, 31 and 17 lit LEDs at its widest. A broad packet swings 24.9, 12.4 and 6.2 sites from side to side, against 4J/F. Turning it mid-run changes the field from the next row on; if more than half the particle has swung off the panel it starts again in the middle.\n// Knob 4: Width. The starting packet. Up to 0.1 a single site, and the rows are J_n(4J/F sin(Ft/2))^2 to within 3e-8 of the closed form; above, a Gaussian of width 6 u^2 sites (u from 0 at 0.1 to 1 at 1) moving right at k = pi/2. At 0.3 (0.3 sites) the lens keeps its fringes; at 0.4 (0.7 sites) they are gone and a bright violet edge, the part moving right, runs down the lens from upper left to lower right; at 0.5 (1.2 sites) the lens has become one band swinging in an S, 25 sites peak to peak at the opening Force, and at 1 (6 sites) the band is 38 LEDs wide. Each turn starts the packet again.\n\nconst W = 64, H = 128;\n// Sites on the chain, and the one under the panel's middle. The panel\n// shows sites C - 32 to C + 31; the chain runs 64 further each way, past\n// any swing the knobs allow, so its ends are never reached.\nconst NS = 192, C = 96;\n// Time per row in units of hbar / J, cut into SUB exact steps; the row\n// shows the probability averaged over them.\nconst TROW = 0.75, SUB = 4, DT = TROW / SUB;\n// Rows per second at Speed 1.\nconst RATE = 8;\n// Bessel orders kept in one step: J_m(2 dt) for m > MB is below 1e-12.\nconst MB = 10;\n// Brightness from the probability on a log scale: 10^LMIN is dark, 10^(LMIN + LSPAN) full.\nconst LMIN = -3.2, LSPAN = 2.4;\nconst { floor, min, max, abs, sin, cos, sqrt, exp, round, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, F: 0.16, wid: 0, begun: false,\n    re: new Float64Array(NS), im: new Float64Array(NS), nr: new Float64Array(NS), ni: new Float64Array(NS),\n    // The step's kernel: Re and Im of i^m J_m(a) e^{-i m F dt / 2}, m = -MB..MB.\n    kr: new Float64Array(2 * MB + 1), ki: new Float64Array(2 * MB + 1), kF: -1,\n    // The last 128 rows: probability and phase per site, newest at head - 1.\n    rho: new Float32Array(W * H), ph: new Float32Array(W * H), head: 0, prog: 0, launched: 0,\n    acc: new Float64Array(W), rgb: new Float32Array(W * H * 3),\n  };\n}\n\n// J_0..J_MB at a small argument, by the power series.\nfunction besselSmall(a, out) {\n  for (let m = 0; m \u003c= MB; m++) {\n    let term = (a / 2) ** m, s = 0;\n    for (let k = 1; k \u003c= m; k++) term /= k;\n    for (let k = 0; k \u003c 20; k++) {\n      s += term;\n      term *= -((a / 2) ** 2) / ((k + 1) * (k + 1 + m));\n    }\n    out[m] = s;\n  }\n}\n\n// The exact propagator of the tilted chain over one step dt, found by\n// taking out the phase e^{-i F n t} and summing the hopping in momentum\n// space with the Jacobi-Anger expansion. With\n// H = -J sum (|n>\u003cn+1| + h.c.) + F sum n |n>\u003cn| and J = 1,\n//   psi_n(t + dt) = e^{-i F n dt} sum_m i^m J_m(a) e^{-i m F dt / 2} psi_{n+m}(t),\n//   a = (4J / F) sin(F dt / 2).\n// The site index n is counted from C.\nfunction kernel(S) {\n  const F = S.F, a = (4 / F) * sin((F * DT) / 2), b = new Float64Array(MB + 1);\n  besselSmall(a, b);\n  for (let m = -MB; m \u003c= MB; m++) {\n    const Jm = m >= 0 ? b[m] : m & 1 ? -b[-m] : b[-m], p = m * (PI / 2 - (F * DT) / 2);\n    S.kr[m + MB] = Jm * cos(p);\n    S.ki[m + MB] = Jm * sin(p);\n  }\n  S.kF = F;\n}\n\nfunction step(S) {\n  if (S.kF !== S.F) kernel(S);\n  const { re, im, nr, ni, kr, ki } = S, F = S.F;\n  for (let n = 0; n \u003c NS; n++) {\n    let sr = 0, si = 0;\n    const lo = max(-MB, -n), hi = min(MB, NS - 1 - n);\n    for (let m = lo; m \u003c= hi; m++) {\n      const a = kr[m + MB], b = ki[m + MB], x = re[n + m], y = im[n + m];\n      sr += a * x - b * y;\n      si += a * y + b * x;\n    }\n    const p = -F * (n - C) * DT, c = cos(p), s = sin(p);\n    nr[n] = sr * c - si * s;\n    ni[n] = sr * s + si * c;\n  }\n  re.set(nr);\n  im.set(ni);\n}\n\n// A packet on the middle site: a Gaussian of width sigma (one site at 0)\n// with momentum pi / 2, so a broad one starts at full speed to the right\n// and swings evenly about the middle.\nfunction launch(S) {\n  const sg = S.wid, { re, im } = S;\n  let nrm = 0;\n  for (let n = 0; n \u003c NS; n++) {\n    const x = n - C, g = sg > 0 ? exp(-(x * x) / (4 * sg * sg)) : x === 0 ? 1 : 0;\n    re[n] = g * cos((PI / 2) * x);\n    im[n] = g * sin((PI / 2) * x);\n    nrm += g * g;\n  }\n  nrm = 1 / sqrt(nrm);\n  for (let n = 0; n \u003c NS; n++) (re[n] *= nrm), (im[n] *= nrm);\n  S.launched = S.wid;\n}\n\n// One row: SUB steps, probability averaged over them, phase at the last.\nfunction row(S) {\n  const { acc, re, im } = S;\n  acc.fill(0);\n  for (let k = 0; k \u003c SUB; k++) {\n    step(S);\n    for (let x = 0; x \u003c W; x++) {\n      const n = C - 32 + x;\n      acc[x] += (re[n] * re[n] + im[n] * im[n]) / SUB;\n    }\n  }\n  // Half the probability left the panel after a turn of Force mid-swing:\n  // start again from the middle.\n  let on = 0;\n  for (let x = 0; x \u003c W; x++) on += acc[x];\n  if (on \u003c 0.5) launch(S);\n  const o = S.head * W;\n  for (let x = 0; x \u003c W; x++) {\n    const n = C - 32 + x;\n    S.rho[o + x] = acc[x];\n    // The local quasi-momentum, the phase step from this site to the next.\n    S.ph[o + x] = atan2(re[n] * im[n + 1] - im[n] * re[n + 1], re[n] * re[n + 1] + im[n] * im[n + 1]);\n  }\n  S.head = (S.head + 1) % H;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.16, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.F = cl(k[2], 0.16, 0.64);\n  // Width: one site up to 0.1, then sigma = 6 u^2 sites, so the turn from\n  // breathing to swinging (sigma 0.5 to 2) gets the first half of the knob.\n  const u = max(0, (cl(k[3], 0, 1) - 0.1) / 0.9);\n  S.wid = 6 * u * u;\n  if (!S.begun) {\n    launch(S);\n    for (let r = 0; r \u003c H; r++) row(S);\n    S.begun = true;\n  }\n  if (abs(S.wid - S.launched) > 1e-6) launch(S);\n  S.prog += d * S.speed * RATE;\n  while (S.prog >= 1) {\n    S.prog -= 1;\n    row(S);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rho, ph, rgb } = S, hb = 0.55 + S.hue;\n  for (let y = 0; y \u003c H; y++) {\n    const r = (S.head + y) % H;\n    for (let x = 0; x \u003c W; x++) {\n      const p = r * W + x, o = (y * W + x) * 3;\n      const L = cl((Math.log10(rho[p] + 1e-12) - LMIN) / LSPAN, 0, 1);\n      if (L \u003c= 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n      // k round the wheel, with orange given a narrower slice of it. Dim\n      // orange and yellow read brown and olive, so there they are lifted\n      // and paled toward peach and butter.\n      const u = hb + ph[p] / (2 * PI), h = u + 0.07 * sin(2 * PI * (u - 0.11));\n      const wm = cl(1 - abs(h - floor(h) - 0.12) / 0.1, 0, 1);\n      hsv(h, (0.85 - 0.45 * L * L) * (1 - 0.3 * wm), min(1, (0.06 + 0.94 * L) * (1 + 0.35 * wm)), rgb, o);\n    }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(255 * rgb[o]), round(255 * rgb[o + 1]), round(255 * rgb[o + 2]));\n}\n","dead-leaves":"// ===== Patternflow pattern =====\n// Title:   Dead Leaves\n// Family:  noise\n// Idea:    Flat discs with radii from half an LED to 20 LEDs come down one after another, each slipping in under the ones already there so it shows only in the gaps, until the last hole closes, a white ring runs out from it and the panel holds an exact sample of the scale-invariant dead leaves picture, where hue gives each leaf's size and every octave of size covers the same share.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: dead leaves model (Georges Matheron, 1968), scale invariant with radii by r^-3 (Ann Lee, David Mumford and Jinggang Huang, 2001), sampled exactly from below (Wilfrid Kendall and Elke Thönnes, 1999), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Grain=0.5..4, Law=-1..1\n//\n// Knob 1: Hue. Turns the size colours round the wheel together. At 0 leaves of radius half an LED are pink-magenta and each doubling of the radius steps 0.072 back round the wheel, through violet and blue to cyan at 16 to 20 LEDs; at 0.25 the small leaves are orange-red and the big ones violet, at 0.5 green down to red, at 0.75 blue down to lime. A leaf whose hue falls between orange and yellow takes only the two bright levels, so it never reads brown or olive.\n// Knob 2: Speed. At 2 the leaves come down 3.2 deep a second, about 4,900 leaves a second at the opening Grain: the panel is 95% covered after 0.9 s and the last hole closes after 2.8 s (median of 40 samples, 2.3 to 3.2 s for the middle 80%), and the white ring runs out at 60 LEDs a second while the finished sample holds 2.2 s before the next one starts under it, the old leaves showing through its holes one level darker and greyed. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Grain. The smallest radius, 0.5 to 4 LEDs. At 0.5 a sample takes about 13,500 leaves and the five octaves of radius from half an LED to 16 each cover 19 to 20% of the panel; at 4 only the octaves from 4 up are left, 500 leaves make a sample, and the picture is big overlapping discs in blue and cyan.\n// Knob 4: Law. The exponent a of the radius density r^-a, 3 + K4 outside a dead zone of 0.1 either side of 0, so the opening 0.06 is exactly 3, the law under which the picture looks the same at every scale. At -1 (a = 2) the big leaves take over: radii 8 to 16 cover 42% of the panel and those under 1 LED 2.5%. At 1 (a = 4) the smallest octave covers 51% and the panel turns to magenta grain.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, PI, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The largest leaf's radius in LEDs.\nconst RMAX = 20;\n// Leaf depth per second at Speed 1: how many leaves, on average, have come\n// down over any one LED. The uncovered share is e^-depth.\nconst RATE = 1.6;\n// Seconds the finished sample holds at Speed 1, and how fast the ring runs\n// out, in LEDs a second at Speed 1.\nconst HOLD = 4.4, RING = 30;\n// Every leaf is one of four flat levels, 45 apart. The holes show the\n// sample before, each leaf one level down and greyed, so two leaves side by\n// side, old or new, either match in level or differ by 45 or more.\nconst TIERS = [255, 210, 165, 120, 75], OLD_SAT = 0.35;\n// Hue tells a leaf's size: the smallest, half an LED across in radius, are\n// magenta at the opening, and each doubling of the radius steps OCT back\n// round the wheel, through violet, blue and cyan to green at 20 LEDs. Each\n// leaf strays a little either side, by up to JIT.\nconst H0 = 0.88, OCT = 0.072, JIT = 0.03;\n// Dim orange and yellow read brown and olive: a leaf whose hue falls there\n// takes one of the two bright tiers instead.\nconst warm = (h) => ((h = h - floor(h)), h > 0.03 && h \u003c 0.22);\n\n// hsv with an integer value v: the brightest channel is v exactly.\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = (v * (1 - s) + 0.5) | 0, q = (v * (1 - f * s) + 0.5) | 0, t = (v * (1 - (1 - f) * s) + 0.5) | 0;\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nfunction sample() {\n  return {\n    id: new Int32Array(N).fill(-1), left: N, n: 0, depth: 0,\n    cx: [], cy: [], r: [], hu: [], sa: [], lv: [],\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    cur: sample(), old: null, hue: 0, speed: 2, rmin: 0.5, alpha: 3,\n    phase: 0, pt: 0, last: [32, 64], rgb: new Uint8Array(N * 3),\n  };\n}\n\n// One radius from the density r^-alpha on [rmin, RMAX], by inverting its\n// distribution function.\nfunction radius(a, alpha) {\n  const u = Math.random();\n  if (abs(alpha - 1) \u003c 1e-6) return a * (RMAX / a) ** u;\n  const e = 1 - alpha, lo = a ** e, hi = RMAX ** e;\n  return (lo + u * (hi - lo)) ** (1 / e);\n}\n\n// The leaves are a Poisson process of discs. Only those that reach the\n// panel matter: a leaf of radius r reaches it when its centre lies in the\n// panel grown by r on every side, so radii are drawn from r^-alpha times\n// that box's area (by rejection) and the centre is uniform in the box. A\n// leaf then adds pi r^2 / box to the mean depth over every LED.\nfunction leaf(S, D) {\n  const big = (W + 2 * RMAX) * (H + 2 * RMAX);\n  let r, box;\n  do {\n    r = radius(S.rmin, S.alpha);\n    box = (W + 2 * r) * (H + 2 * r);\n  } while (Math.random() * big > box);\n  const cx = -r + Math.random() * (W + 2 * r), cy = -r + Math.random() * (H + 2 * r);\n  D.depth += (PI * r * r) / box;\n  // Seen from below: the leaf shows only on LEDs no earlier leaf covers.\n  const k = D.n++;\n  D.cx.push(cx);\n  D.cy.push(cy);\n  D.r.push(r);\n  D.hu.push(-OCT * Math.log2(r / 0.5) + (Math.random() - 0.5) * 2 * JIT);\n  D.sa.push(0.55 + 0.35 * Math.random());\n  D.lv.push(floor(Math.random() * TIERS.length));\n  const x0 = max(0, ceil(cx - r - 0.5)), x1 = min(W - 1, floor(cx + r - 0.5));\n  const y0 = max(0, ceil(cy - r - 0.5)), y1 = min(H - 1, floor(cy + r - 0.5));\n  const r2 = r * r, id = D.id;\n  for (let y = y0; y \u003c= y1; y++) {\n    const dy = y + 0.5 - cy;\n    for (let x = x0; x \u003c= x1; x++) {\n      const p = y * W + x;\n      if (id[p] >= 0) continue;\n      const dx = x + 0.5 - cx;\n      if (dx * dx + dy * dy > r2) continue;\n      id[p] = k;\n      if (--D.left === 0) S.last = [x, y];\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.rmin = cl(kv[2], 0.5, 4);\n  // Law: a dead zone of 0.1 round the middle keeps the exponent at 3.\n  const k4 = cl(kv[3], -1, 1), e = abs(k4) > 0.1 ? (Math.sign(k4) * (abs(k4) - 0.1)) / 0.9 : 0;\n  S.alpha = 3 + e;\n  const g = d * S.speed;\n  if (S.phase === 1) {\n    S.pt += g;\n    if (S.pt > HOLD) {\n      // The held sample steps one level down and greys. It shows through\n      // the holes of the next one until they close.\n      S.old = S.cur;\n      S.cur = sample();\n      S.phase = 0;\n    }\n  }\n  if (S.phase === 0) {\n    const D = S.cur, goal = D.depth + g * RATE;\n    while (D.left > 0 && D.depth \u003c goal) leaf(S, D);\n    if (D.left === 0) (S.phase = 1), (S.pt = 0);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, D = S.cur, O = S.old, hb = H0 + S.hue;\n  const ring = S.phase === 1 ? S.pt * RING : -1, [lx, ly] = S.last;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3;\n      let k = D.id[p], L = D;\n      if (k \u003c 0 && O) (L = O), (k = O.id[p]);\n      if (k \u003c 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n      const h = hb + L.hu[k], t = L.lv[k], fresh = L === D, v = TIERS[(warm(h) ? t & 1 : t) + (fresh ? 0 : 1)];\n      // Each leaf pales toward its centre, so a disc reads as a disc even\n      // where only a sliver of it shows. Only the weaker channels change.\n      const dx = x + 0.5 - L.cx[k], dy = y + 0.5 - L.cy[k], f = min(1, sqrt(dx * dx + dy * dy) / L.r[k]);\n      hsv(h, L.sa[k] * (0.6 + 0.4 * f) * (fresh ? 1 : OLD_SAT), v, rgb, o);\n    }\n  // The moment the last hole closes the sample is exact: a white ring runs\n  // out from where that hole was.\n  if (ring >= 0) {\n    for (let y = 0, p = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++, p++) {\n        const dd = sqrt((x - lx) ** 2 + (y - ly) ** 2);\n        if (dd \u003c= ring && dd > ring - 1.5) rgb[p * 3] = rgb[p * 3 + 1] = rgb[p * 3 + 2] = 255;\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o], rgb[o + 1], rgb[o + 2]);\n}\n","elliptic-law":"// ===== Patternflow pattern =====\n// Title:   Elliptic Law\n// Family:  particle\n// Idea:    The eigenvalues of a random real matrix whose entries wander drift as glowing particles inside an ellipse that stands up the panel, mirrored in pairs across the real axis down its middle, and whenever a mirrored pair meets on the axis it splits into two real eigenvalues that run apart along it, or two real ones meet and leave it as a pair.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: circular law (Jean Ginibre, 1965; Vyacheslav Girko, 1984), elliptic law (Hans-Jürgen Sommers, Andrea Crisanti, Haim Sompolinsky and Yaakov Stein, 1988), real eigenvalues of a real Gaussian matrix (Alan Edelman, Eric Kostlan and Michael Shub, 1994), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tau=0.333..1, Size=40..80\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the complex eigenvalues are cyan over a deep blue glow and the real ones pale violet, at 0.25 violet and red, at 0.5 rose and green, at 0.75 green and azure. The wheel skips the orange and yellow stretch, which reads brown when dim.\n// Knob 2: Speed. How fast the matrix entries wander. At 2 an entry's correlation with where it was first falls to zero after 4.9 s, an eigenvalue in the middle of the ellipse moves about 12 LEDs a second, and somewhere on the axis a pair meets or parts about 6.5 times a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Tau. The correlation between the entries J_ij and J_ji, from 1/3 to 1. The ellipse has half-axes 1 + Tau along the real axis and 1 - Tau across it, drawn so the real half-axis is always 61 LEDs: at 1/3 it is 61 LEDs wide and fills the panel, at 0.6 30 wide, at 0.8 14, and at 1 the matrix is symmetric and every eigenvalue lies on the axis. A 40 x 40 matrix has 7.6 real eigenvalues on average at 1/3, 10.4 at 0.6 and 15.1 at 0.8 (4,000 matrices each).\n// Knob 4: Size. The matrix is 40 x 40 to 80 x 80. The ellipse stays the same size and fills more evenly, and the share of real eigenvalues falls: at Tau 1/3 a 40 x 40 matrix has 7.6 of them on average and an 80 x 80 one 10.5, close to Peter Forrester and Taro Nagao's sqrt(2N/pi (1 + Tau)/(1 - Tau)) (2008), which gives 7.1 and 10.1.\n\nconst W = 64, H = 128, NPX = W * H, NM = 80;\nconst { floor, min, max, sqrt, exp, sin, cos, log, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The real half-axis in LEDs, and the centre of the panel.\nconst RPX = 61, CX = 32, CY = 64;\n// Entry clock: units of the entries' own time per second at Speed 1. In one\n// unit a resting entry turns one radian of its oscillation (below).\nconst RATE = 0.22;\n// Damping of each entry's velocity, per unit of entry time.\nconst GAMMA = 0.8;\n// Short trails fade by e in TRAIL seconds, the long exposure in EXPO.\nconst TRAIL = 0.3, EXPO = 3.5;\n// A spark where a pair met on the axis lasts this long.\nconst SPARK = 0.4;\n\nfunction gauss() {\n  let u = 0;\n  while (u \u003c 1e-12) u = Math.random();\n  return sqrt(-2 * log(u)) * cos(TAU * Math.random());\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel skips 0.03..0.18, orange through yellow, which reads brown and\n// olive when dim, and runs the rest a little faster.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const g = new Float64Array(NM * NM), v = new Float64Array(NM * NM);\n  for (let i = 0; i \u003c NM * NM; i++) (g[i] = gauss()), (v[i] = gauss());\n  params.s = {\n    g, v, hue: 0, speed: 2, tau: 1 / 3, n: 40,\n    a: new Float64Array(NM * NM), wr: new Float64Array(NM), wi: new Float64Array(NM),\n    // Eigenvalues as LED positions, this frame and last.\n    px: new Float32Array(NM), py: new Float32Array(NM), re: new Uint8Array(NM),\n    qx: new Float32Array(NM), qy: new Float32Array(NM), qre: new Uint8Array(NM), qn: 0,\n    trail: new Float32Array(NPX * 3), expo: new Float32Array(NPX * 2), rgb: new Float32Array(NPX * 3), flash: [],\n    pal: new Float32Array(15), palHue: -1, solved: false, fails: 0,\n  };\n}\n\n// Each entry of the matrix is built from N(0, 1) numbers g that move as the\n// position of a damped oscillator kicked by noise, a two-dimensional\n// Ornstein-Uhlenbeck process whose resting law is N(0, 1) for g and its\n// velocity v alike. A step of h units turns (g, v) by h radians, which keeps\n// that law, then takes v through an exact Ornstein-Uhlenbeck step, which keeps it\n// too; so at every moment the matrix is a fresh draw of the ensemble, and\n// g moves smoothly enough for the eigenvalues to glide instead of jitter.\nfunction wander(S, h) {\n  const { g, v, n } = S, c = cos(h), s = sin(h), e = exp(-GAMMA * h), k = sqrt(1 - e * e);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0, o = i * NM; j \u003c n; j++, o++) {\n      const a = g[o], b = v[o];\n      g[o] = a * c + b * s;\n      v[o] = (b * c - a * s) * e + k * gauss();\n    }\n}\n\n// The elliptic ensemble from those numbers: above the diagonal g holds the\n// symmetric parts, below it the antisymmetric ones, so\n//   J_ij = (c1 g_ij + c2 g_ji) / sqrt N,  J_ji = (c1 g_ij - c2 g_ji) / sqrt N,\n// with c1^2 = (1 + tau)/2 and c2^2 = (1 - tau)/2: every entry has variance\n// 1/N and E J_ij J_ji = tau/N.\nfunction build(S) {\n  const { g, a, n, tau } = S, r = 1 / sqrt(n), c1 = sqrt((1 + tau) / 2) * r, c2 = sqrt((1 - tau) / 2) * r;\n  for (let i = 0; i \u003c n; i++) {\n    a[i * n + i] = sqrt(1 + tau) * g[i * NM + i] * r;\n    for (let j = i + 1; j \u003c n; j++) {\n      const p = g[i * NM + j], q = g[j * NM + i];\n      a[i * n + j] = c1 * p + c2 * q;\n      a[j * n + i] = c1 * p - c2 * q;\n    }\n  }\n}\n\n// Reduction to upper Hessenberg form by stabilised elementary similarity\n// transforms (row and column swaps, then elimination below the subdiagonal).\nfunction hessenberg(a, n) {\n  for (let m = 1; m \u003c n - 1; m++) {\n    let x = 0, i = m;\n    for (let j = m; j \u003c n; j++) if (abs(a[j * n + m - 1]) > abs(x)) (x = a[j * n + m - 1]), (i = j);\n    if (i !== m) {\n      for (let j = m - 1; j \u003c n; j++) {\n        const t = a[i * n + j];\n        a[i * n + j] = a[m * n + j];\n        a[m * n + j] = t;\n      }\n      for (let j = 0; j \u003c n; j++) {\n        const t = a[j * n + i];\n        a[j * n + i] = a[j * n + m];\n        a[j * n + m] = t;\n      }\n    }\n    if (x === 0) continue;\n    for (i = m + 1; i \u003c n; i++) {\n      let y = a[i * n + m - 1];\n      if (y === 0) continue;\n      y /= x;\n      a[i * n + m - 1] = y;\n      for (let j = m; j \u003c n; j++) a[i * n + j] -= y * a[m * n + j];\n      for (let j = 0; j \u003c n; j++) a[j * n + m] += y * a[j * n + i];\n    }\n  }\n}\n\n// Francis's implicit double-shift QR on the Hessenberg matrix, eigenvalues\n// only. Each sweep chases a 3 x 3 Householder bulge down the subdiagonal\n// with the two shifts the trailing 2 x 2 block gives, a pair of complex\n// conjugates kept in real arithmetic; a small subdiagonal entry splits off\n// one real eigenvalue or a 2 x 2 block whose roots are a real pair or a\n// conjugate pair. Real roots come back with wi exactly 0.\nfunction francis(a, n, wr, wi) {\n  let nn = n - 1, t = 0, anorm = 0, p = 0, q = 0, r = 0, x, y, z, w, s, u, v, l, m;\n  for (let i = 0; i \u003c n; i++) for (let j = max(i - 1, 0); j \u003c n; j++) anorm += abs(a[i * n + j]);\n  while (nn >= 0) {\n    let its = 0;\n    do {\n      for (l = nn; l > 0; l--) {\n        s = abs(a[(l - 1) * n + l - 1]) + abs(a[l * n + l]);\n        if (s === 0) s = anorm;\n        if (abs(a[l * n + l - 1]) + s === s) {\n          a[l * n + l - 1] = 0;\n          break;\n        }\n      }\n      x = a[nn * n + nn];\n      if (l === nn) {\n        wr[nn] = x + t;\n        wi[nn--] = 0;\n      } else {\n        y = a[(nn - 1) * n + nn - 1];\n        w = a[nn * n + nn - 1] * a[(nn - 1) * n + nn];\n        if (l === nn - 1) {\n          p = 0.5 * (y - x);\n          q = p * p + w;\n          z = sqrt(abs(q));\n          x += t;\n          if (q >= 0) {\n            z = p + (p >= 0 ? z : -z);\n            wr[nn - 1] = wr[nn] = x + z;\n            if (z) wr[nn] = x - w / z;\n            wi[nn - 1] = wi[nn] = 0;\n          } else {\n            wr[nn - 1] = wr[nn] = x + p;\n            wi[nn - 1] = -(wi[nn] = z);\n          }\n          nn -= 2;\n        } else {\n          if (its === 60) return false;\n          // Exceptional shifts after 10 and 20 sweeps without a split.\n          if (its === 10 || its === 20) {\n            t += x;\n            for (let i = 0; i \u003c= nn; i++) a[i * n + i] -= x;\n            s = abs(a[nn * n + nn - 1]) + abs(a[(nn - 1) * n + nn - 2]);\n            y = x = 0.75 * s;\n            w = -0.4375 * s * s;\n          }\n          ++its;\n          // Where the bulge can start: two small subdiagonals in a row.\n          for (m = nn - 2; m >= l; m--) {\n            z = a[m * n + m];\n            r = x - z;\n            s = y - z;\n            p = (r * s - w) / a[(m + 1) * n + m] + a[m * n + m + 1];\n            q = a[(m + 1) * n + m + 1] - z - r - s;\n            r = a[(m + 2) * n + m + 1];\n            s = abs(p) + abs(q) + abs(r);\n            p /= s;\n            q /= s;\n            r /= s;\n            if (m === l) break;\n            u = abs(a[m * n + m - 1]) * (abs(q) + abs(r));\n            v = abs(p) * (abs(a[(m - 1) * n + m - 1]) + abs(z) + abs(a[(m + 1) * n + m + 1]));\n            if (u + v === v) break;\n          }\n          for (let i = m; i \u003c nn - 1; i++) {\n            a[(i + 2) * n + i] = 0;\n            if (i !== m) a[(i + 2) * n + i - 1] = 0;\n          }\n          // Chase the bulge.\n          for (let k = m; k \u003c nn; k++) {\n            if (k !== m) {\n              p = a[k * n + k - 1];\n              q = a[(k + 1) * n + k - 1];\n              r = k + 1 !== nn ? a[(k + 2) * n + k - 1] : 0;\n              if ((x = abs(p) + abs(q) + abs(r)) !== 0) (p /= x), (q /= x), (r /= x);\n            }\n            const sg = sqrt(p * p + q * q + r * r);\n            if ((s = p >= 0 ? sg : -sg) === 0) continue;\n            if (k === m) {\n              if (l !== m) a[k * n + k - 1] = -a[k * n + k - 1];\n            } else a[k * n + k - 1] = -s * x;\n            p += s;\n            x = p / s;\n            y = q / s;\n            z = r / s;\n            q /= p;\n            r /= p;\n            for (let j = k; j \u003c= nn; j++) {\n              p = a[k * n + j] + q * a[(k + 1) * n + j];\n              if (k + 1 !== nn) {\n                p += r * a[(k + 2) * n + j];\n                a[(k + 2) * n + j] -= p * z;\n              }\n              a[(k + 1) * n + j] -= p * y;\n              a[k * n + j] -= p * x;\n            }\n            const top = nn \u003c k + 3 ? nn : k + 3;\n            for (let i = l; i \u003c= top; i++) {\n              p = x * a[i * n + k] + y * a[i * n + k + 1];\n              if (k + 1 !== nn) {\n                p += z * a[i * n + k + 2];\n                a[i * n + k + 2] -= p * r;\n              }\n              a[i * n + k + 1] -= p * q;\n              a[i * n + k] -= p;\n            }\n          }\n        }\n      }\n    } while (l \u003c nn - 1);\n  }\n  return true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1 / 3, 40], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.tau = cl(kv[2], 1 / 3, 1);\n  S.n = cl(floor(kv[3] + 0.5), 40, NM);\n  wander(S, d * S.speed * RATE);\n  build(S);\n  hessenberg(S.a, S.n);\n  // A failed solve keeps last frame's eigenvalues; none failed in 18,000\n  // frames at the knobs' ends.\n  if (!francis(S.a, S.n, S.wr, S.wi)) {\n    S.fails++;\n    return;\n  }\n  // Last frame's positions, for the trails and to spot a meeting on the axis.\n  S.qx.set(S.px);\n  S.qy.set(S.py);\n  S.qre.set(S.re);\n  S.qn = S.solved ? S.qn : 0;\n  const sc = RPX / (1 + S.tau);\n  for (let k = 0; k \u003c S.n; k++) {\n    S.px[k] = CX + S.wi[k] * sc;\n    S.py[k] = CY - S.wr[k] * sc;\n    S.re[k] = S.wi[k] === 0 ? 1 : 0;\n  }\n  const qn = S.qn;\n  S.qn = S.n;\n  S.solved = true;\n  // An eigenvalue whose nearest one last frame was of the other kind has\n  // just crossed over: a real one born from a conjugate pair meeting on the\n  // axis, or a complex one from two real ones meeting. A spark marks where.\n  if (qn === S.n)\n    for (let k = 0; k \u003c S.n; k++) {\n      let best = 1e9, bj = -1;\n      for (let j = 0; j \u003c qn; j++) {\n        const dx = S.qx[j] - S.px[k], dy = S.qy[j] - S.py[k], e = dx * dx + dy * dy;\n        if (e \u003c best) (best = e), (bj = j);\n      }\n      if (bj \u003c 0 || S.qre[bj] === S.re[k] || best > 36) continue;\n      const fy = S.re[k] ? S.py[k] : S.qy[bj];\n      if (S.flash.some((f) => abs(f.y - fy) \u003c 3 && f.age \u003c 0.2)) continue;\n      if (S.flash.length \u003c 12) S.flash.push({ y: fy, age: 0, real: S.re[k] });\n    }\n  for (const f of S.flash) f.age += d;\n  S.flash = S.flash.filter((f) => f.age \u003c SPARK);\n  S.dt = d;\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  hsv(wheel(0.58 + h), 0.75, 1, P, 0); // complex heads and trails\n  hsv(wheel(0.9 + h), 0.6, 1, P, 3); // real heads and trails\n  hsv(wheel(0.63 + h), 0.85, 1, P, 6); // long exposure, complex\n  hsv(wheel(0.92 + h), 0.7, 1, P, 9); // long exposure, real\n  hsv(wheel(0.6 + h), 0.5, 1, P, 12); // the law's ellipse\n  S.palHue = S.hue;\n}\n\n// A point spread over its four nearest LEDs by how close it falls.\nfunction splat(buf, x, y, c0, c1, c2, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const k = (dx ? tx : 1 - tx) * wy * a, p = (yy * W + xx) * 3;\n      buf[p] = max(buf[p], c0 * k);\n      buf[p + 1] = max(buf[p + 1], c1 * k);\n      buf[p + 2] = max(buf[p + 2], c2 * k);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.solved) return;\n  if (S.palHue !== S.hue) palette(S);\n  const P = S.pal, n = S.n, tr = S.trail, ex = S.expo, rgb = S.rgb, d = S.dt || 1 / 30;\n  // Trails and exposure fade with panel time, so they keep their length in\n  // LEDs at any Speed.\n  const ft = exp(-d / TRAIL), fe = exp(-d / EXPO);\n  for (let i = 0; i \u003c NPX * 3; i++) tr[i] *= ft;\n  for (let i = 0; i \u003c NPX * 2; i++) ex[i] *= fe;\n  // Each eigenvalue draws a line back to the nearest of last frame's, and\n  // drops a little light into the long exposure, which builds up the\n  // ellipse's even density and the line of real eigenvalues.\n  for (let k = 0; k \u003c n; k++) {\n    const x = S.px[k], y = S.py[k], o = S.re[k] ? 3 : 0;\n    let best = 1e9, bx = x, by = y;\n    for (let j = 0; j \u003c S.qn; j++) {\n      const dx = S.qx[j] - x, dy = S.qy[j] - y, e = dx * dx + dy * dy;\n      if (e \u003c best) (best = e), (bx = S.qx[j]), (by = S.qy[j]);\n    }\n    if (best > 100) (bx = x), (by = y);\n    const m = Math.ceil(sqrt((bx - x) ** 2 + (by - y) ** 2) * 2) || 1;\n    for (let e = 0; e \u003c= m; e++) splat(tr, bx + ((x - bx) * e) / m, by + ((y - by) * e) / m, P[o] * 0.8, P[o + 1] * 0.8, P[o + 2] * 0.8, 1.6);\n    const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, ch = S.re[k] ? 1 : 0;\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const xx = ix + dx, yy = iy + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        ex[(yy * W + xx) * 2 + ch] += (dx ? tx : 1 - tx) * (dy ? ty : 1 - ty) * d * (ch ? 3 : 24);\n      }\n  }\n  // The law: the ellipse with half-axes 1 + tau and 1 - tau, a thin line.\n  const sc = RPX / (1 + S.tau), ah = (1 - S.tau) * sc, bh = (1 + S.tau) * sc;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3;\n      let R = tr[o], G = tr[o + 1], B = tr[o + 2];\n      // Exposure, through a soft knee so a busy spot does not burn out.\n      const e0 = ex[p * 2], e1 = ex[p * 2 + 1];\n      const k0 = 0.4 * (1 - exp(-e0 * 1.4)), k1 = 0.5 * (1 - exp(-e1 * 1.2));\n      R += P[6] * k0 + P[9] * k1;\n      G += P[7] * k0 + P[10] * k1;\n      B += P[8] * k0 + P[11] * k1;\n      // Distance to the ellipse, roughly in LEDs.\n      const u = (x + 0.5 - CX) / max(ah, 0.3), v = (y + 0.5 - CY) / bh, rr = sqrt(u * u + v * v);\n      const gx = u / max(ah, 0.3), gy = v / bh, gl = sqrt(gx * gx + gy * gy) || 1;\n      const dist = (abs(rr - 1) * rr) / gl;\n      if (dist \u003c 1.2 && ah > 1) {\n        const a = 0.3 * (1 - dist / 1.2);\n        R += P[12] * a;\n        G += P[13] * a;\n        B += P[14] * a;\n      }\n      (rgb[o] = R), (rgb[o + 1] = G), (rgb[o + 2] = B);\n    }\n  // Sparks where a pair met on the axis: a short bar across the axis that\n  // shrinks as it fades, in the colour of what was born there.\n  for (const f of S.flash) {\n    const u = f.age / SPARK, a = (1 - u) * (1 - u), o = f.real ? 3 : 0, half = 4.5 * (1 - u) + 1;\n    const iy = floor(f.y);\n    for (let dy = -1; dy \u003c= 1; dy++) {\n      const yy = iy + dy;\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let xx = floor(CX - half); xx \u003c CX + half; xx++) {\n        if (xx \u003c 0 || xx >= W) continue;\n        const w = a * (dy ? 0.45 : 1) * min(1, half - abs(xx + 0.5 - CX) + 0.5), q = (yy * W + xx) * 3;\n        for (let e = 0; e \u003c 3; e++) rgb[q + e] += (0.6 + P[o + e]) * w;\n      }\n    }\n  }\n  for (let k = 0; k \u003c n; k++) {\n    const x = S.px[k], y = S.py[k], o = S.re[k] ? 3 : 0;\n    const ix = floor(x - 0.5), iy = floor(y - 0.5);\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const xx = ix + dx, yy = iy + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const q = (yy * W + xx) * 3;\n        for (let e = 0; e \u003c 3; e++) rgb[q + e] = max(rgb[q + e], 0.45 + P[o + e] * 0.6);\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * min(1, rgb[o])) | 0, (255 * min(1, rgb[o + 1])) | 0, (255 * min(1, rgb[o + 2])) | 0);\n}\n","erdos-discrepancy":"// ===== Patternflow pattern =====\n// Title:   Erdős Discrepancy\n// Family:  rhythm\n// Idea:    A rhythm of hits (+1) and rests (-1) is heard by 64 listeners side by side, listener d taking only every d-th beat, and each writes the running sum of what it hears down its own column, one row a step with the newest at the bottom over a row of the beat itself, so the completely multiplicative rhythm weaves a quiet tartan, one set of nested bands coloured column by column by the rhythm's own signs, while coin-flip beats tear it into loud streaks, and whenever a sum beats the record so far the cells that did it light white.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Erdős discrepancy problem (Paul Erdős, 1932), solved by Terence Tao (2015), with the character-like functions of Peter Borwein, Stephen Choi and Michael Coons (2010), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Prime=3..13\n//\n// Knob 1: Hue. Turns both colours round the wheel together. At 0 sums above zero are aqua and sums below zero magenta, with records and the beat row white; at 0.25 blue and red, at 0.5 pink and green, at 0.75 lime and azure. The wheel skips orange and yellow, which read brown and olive in the dim cells of small sums.\n// Knob 2: Speed. Steps a second, 4 x Speed: 8 at 2, so the 127 rows of carpet turn over in 16 s, 0.8 at 0.2 and 12 at 3. A run goes on to step 6,561 = 3^8, 13.7 minutes at 2, and starts again from the first 128 steps with fresh coin flips.\n// Knob 3: Noise. Each beat is a coin flip instead of the multiplicative rhythm with chance Noise squared: 6% at 0.25, 25% at 0.5, 56% at 0.75, every beat at 1. At 0 every column is plus or minus the same walk, so the carpet is one column of bands times the rhythm's first 64 signs. At step 1,000 the 64 sums average 4 at 0 (all equal in size), 10 at 0.25, 18 at 0.5 and 25 at 0.75 and 1, and the record by then is 6 at 0 against 92 at 1 (mean of eight runs).\n// Knob 4: Prime. The prime p of the character-like rhythm, the one of 3, 5, 7, 11 and 13 nearest the knob: x_n is the residue symbol mod p of n with every factor p taken out. Its running sum is a sum over the base-p digits of the step, so it grows like the digit count: at p = 3 each digit 1 adds one, and the largest sum up to step m is floor(log3(2m + 1)), never above log3 m + 1 (checked to m = 600,000), with the records at m = 1, 4, 13, 40, 121, 364, 1093 and 3280 lighting whole rows. Records by step 6,561 reach 8 at p = 3, 6 at 5, 10 at 7, 11 at 11 and 7 at 13; at 5 and 13 the sums change sign, so the bands swap colours row by row.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Steps a second at Speed 1, and the step at which the walk starts over.\nconst RATE = 4, LAST = 6561;\nconst PRIMES = [3, 5, 7, 11, 13];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Quadratic residues mod p, as +1 / -1 by residue.\nfunction legendre(p) {\n  const t = new Int8Array(p).fill(-1);\n  t[0] = 0;\n  for (let a = 1; a \u003c p; a++) t[(a * a) % p] = 1;\n  return t;\n}\n\n// A 32-bit integer hash, for the coin flips: each beat n has its own draw,\n// fixed for the run, so every listener hears the same beat the same way.\nfunction hash(n) {\n  n = Math.imul(n ^ (n >>> 16), 0x7feb352d);\n  n = Math.imul(n ^ (n >>> 15), 0x846ca68b);\n  return (n ^ (n >>> 16)) >>> 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    M: 0, acc: 0, seed: 0, p: 3, noise: 0, hue: 0, speed: 2, chi: null,\n    cur: new Int32Array(W + 1), ring: new Int16Array(H * W), mark: new Uint8Array(H * W),\n    rec: 0, pal: new Float32Array(2), palHue: -1, key: '',\n  };\n}\n\n// Beat n of the rhythm. Borwein, Choi and Coons' character-like function\n// takes out every factor p and reads the rest as a residue mod p; with\n// Noise the beat is a coin flip instead, with that chance.\nfunction term(S, n) {\n  const h = hash(n + S.seed);\n  if ((h >>> 8) / 16777216 \u003c S.noise) return h & 1 ? 1 : -1;\n  const p = S.p;\n  while (n % p === 0) n /= p;\n  return S.chi[n % p];\n}\n\n// One step m for all 64 listeners: listener d hears beat m d.\nfunction step(S) {\n  const m = ++S.M, row = (m % H) * W, cur = S.cur;\n  let top = 0;\n  for (let d = 1; d \u003c= W; d++) {\n    cur[d] += term(S, m * d);\n    S.ring[row + d - 1] = cur[d];\n    S.mark[row + d - 1] = 0;\n    top = max(top, abs(cur[d]));\n  }\n  // A new record discrepancy: the cells that set it.\n  if (top > S.rec) {\n    S.rec = top;\n    for (let d = 1; d \u003c= W; d++) if (abs(cur[d]) === top) S.mark[row + d - 1] = 1;\n  }\n}\n\n// Start over from step 0 and run up to step `to`, as after a knob turn.\nfunction rebuild(S, to) {\n  S.M = 0;\n  S.rec = 0;\n  S.cur.fill(0);\n  S.ring.fill(0);\n  S.mark.fill(0);\n  while (S.M \u003c to) step(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  // The share of coin flips is the knob squared, so the first half of its\n  // turn opens the carpet up gradually.\n  const noise = cl(kv[2], 0, 1) ** 2;\n  // The prime nearest the knob.\n  let p = 3;\n  for (const q of PRIMES) if (abs(q - kv[3]) \u003c abs(p - kv[3])) p = q;\n  if (!S.chi) S.seed = floor(Math.random() * 1e9);\n  // A turned knob rewrites the whole walk so far with the new rhythm.\n  const key = p + ':' + noise.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    S.p = p;\n    S.chi = legendre(p);\n    S.noise = noise;\n    rebuild(S, max(H, S.M));\n  }\n  S.acc += d * S.speed * RATE;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    if (S.M >= LAST) {\n      S.seed = floor(Math.random() * 1e9);\n      rebuild(S, H);\n    } else step(S);\n  }\n}\n\n// The hue wheel skips orange through yellow, which read brown and olive on\n// the dim cells of small sums.\nconst wheel = (h) => 0.25 + 0.78 * (h - floor(h));\nfunction palette(S) {\n  const P = S.pal;\n  P[0] = wheel(0.282 + S.hue); // sums above zero: aqua at Hue 0\n  P[1] = wheel(0.732 + S.hue); // sums below zero: magenta\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.chi) return;\n  if (S.palHue !== S.hue) palette(S);\n  const P = S.pal, c = [0, 0, 0], M = S.M, beat = 1 - S.acc;\n  for (let y = 0; y \u003c H; y++) {\n    // The bottom row plays the newest step; the carpet rises above it, the\n    // newest sums on row 126.\n    const m = y === H - 1 ? M : M - (H - 2 - y), row = (((m % H) + H) % H) * W;\n    // Older rows dim a little toward the top, so the carpet reads as\n    // written from the bottom.\n    const age = 0.7 + 0.3 * (y / (H - 2));\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      if (m >= 1 && y === H - 1) {\n        // The beat itself: a hit lights, a rest stays dark, fading over the step.\n        const prev = m > 1 ? S.ring[(((m - 1) % H) * W) + x] : 0;\n        if (S.ring[row + x] > prev) r = g = b = 0.3 + 0.7 * beat;\n      } else if (m >= 1) {\n        const s = S.ring[row + x], a = abs(s);\n        if (S.mark[row + x]) (r = 1), (g = 1), (b = 1);\n        else if (a) {\n          // Brightness climbs from 0.28 at 1 to full at 5, then the colour\n          // whitens a step for each doubling, nearly white past 80.\n          hsv(s > 0 ? P[0] : P[1], 0.9 - 0.7 * cl(Math.log2(a / 5) / 4, 0, 1), min(1, 0.1 + 0.18 * a), c, 0);\n          (r = c[0] * age), (g = c[1] * age), (b = c[2] * age);\n        }\n      }\n      display.setPixel(x, y, (255 * r) | 0, (255 * g) | 0, (255 * b) | 0);\n    }\n  }\n}\n","golomb-trominoes":"// ===== Patternflow pattern =====\n// Title:   Golomb Trominoes\n// Family:  cells\n// Idea:    Two 64 x 64 boards, each short one cell, are tiled with 3-LED L trominoes exactly as Golomb's proof lays them, and as each board's blinking hole walks one LED at a time the trominoes between its old and new place re-lay in a white flash, one tromino inside a 2 x 2 block but up to 63 when it crosses the board's middle, while the field's hue marks the nested L-shaped shells of the proof closing in on the hole.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tromino tiling of the deficient 2^n board (Solomon W. Golomb, 1954), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lift=0..4, Cell=1..4\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the 2 x 2 trominoes are azure and navy in the outermost shell and turn cyan, aqua, green, lime and yellow shell by shell towards the hole; the 4 x 4 trominoes are plum, 8 x 8 gold, 16 x 16 lime and 32 x 32 rose, and the trominoes the proof lays round the hole, one a level, are white. At 0.5 the shells run orange, red, pink and violet and the levels aqua, blue and violet. The dim colours skip the orange and yellow part of the wheel, which reads brown and olive.\n// Knob 2: Speed. The hole walks 9 LEDs a second for each unit, 18 at the opening 2, on a straight line that reflects off the board's edges. A step that stays inside a 2 x 2 block re-lays that one tromino; a step over the line between two blocks of side 2^k re-lays at most 2^k - 1 trominoes (3, 7, 15, 31, 63) and about two thirds of that on average. At 2 the two holes cross their board's middle at 0.8 s and 0.7 s and then on average every 3.5 s. 0.2 is ten times slower.\n// Knob 3: Lift. Leaves the lowest levels of the proof unlaid. At 0 every tromino is laid; 1 to 4 leave whole blocks of 4, 8, 16 and 32 cells a side (on a 16-cell board no more than 8), each one square in its tone short the one cell that the trominoes above it, or the hole, took. Each such square is the proof's induction hypothesis: a smaller board short one cell, which the same proof tiles.\n// Knob 4: Cell. LEDs to a cell: 1 below 1.5, 2 below 3.5, then 4, so each half of the panel is a board of 64, 32 or 16 cells a side, laid with 1365, 341 or 85 trominoes. The hole still walks 18 LEDs a second at Speed 2, so on the bigger cells it takes fewer, larger steps.\n\n// Each half of the panel is one square board, W LEDs a side.\nconst W = 64, H = 128;\nconst { floor, min, max, exp, round, cos, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Three colours are enough for Golomb's tiling, and they come from the\n// proof itself. The 2 x 2 trominoes fill three quarters of the board in\n// two tones: bright where the block is missing its top left or bottom\n// right cell, dark where it is missing the other two. Two trominoes of the\n// same tone never share an edge, and no two trominoes laid at a bigger\n// level ever touch each other, so those all take the third colour, with\n// its hue by the level that laid them. Checked for every hole of boards\n// 16, 32 and 64 cells wide: the rule breaks on at most four edges, all\n// within two cells of the hole.\n// The field's hue says how far the cell sits from the hole in the proof:\n// its shell is the smallest block holding both, and shell k is the three\n// quarters of the hole's 2^k block that the hole is not in: an L tromino\n// scaled up 2^(k-1) times. Outermost shell azure, then cyan, aqua, green,\n// lime and yellow inwards.\nconst SHUE = [0.6, 0.5, 0.42, 0.34, 0.27, 0.2];\n// Bigger levels: plum for 4 x 4, gold for 8 x 8, lime, rose. The board's\n// middle tromino always lies round the hole and shows white.\nconst LHUE = [0, 0, 0.98, 0.13, 0.3, 0.98, 0.75];\n// Palette slots: 2 (n - shell) + tone for the field (0 bright, 1 dark),\n// 12 + level for levels 2..6, 19 for the trominoes the proof lays round\n// the hole and 20 for the hole.\n// The block sides Lift leaves unlaid: 1 lays every tromino; a 2 x 2 block\n// short one cell is a tromino already, so the next is 4.\nconst LIFT = [0, 2, 3, 4, 5];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nfunction makeBoard(y0, u, v, ang) {\n  const M = W * W;\n  return {\n    y0, u, v, dx: cos(ang), dy: sin(ang), hx: -1, hy: -1,\n    lev: new Int8Array(M), ori: new Int8Array(M), lev2: new Int8Array(M), ori2: new Int8Array(M),\n    bori: Array.from({ length: 7 }, () => new Int8Array(M)),\n    rgb: new Float32Array(M * 3), flash: new Float32Array(M), fresh: true,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, lift: 0, c: 0, n: 6, S: 64, acc: 0, t: 0,\n    // Two boards, one on each half of the panel, their holes set off on\n    // straight lines that cross the boards' middles early.\n    boards: [makeBoard(0, 0.37, 0.29, 0.56), makeBoard(H - W, 0.71, 0.4, 2.2)],\n    pal: new Float32Array(63), palHue: -1,\n  };\n}\n\n// Golomb's proof as a program: in a block with one cell taken, lay one\n// tromino over the inner corners of the three quarters that do not hold\n// it, and each of those quarters now has a cell taken too. Every cell\n// records the level of the tromino that covers it (the block's side is\n// 2^level) and which corner of the 2 x 2 at the block's centre that\n// tromino leaves out.\nfunction lay(B, n, hx, hy) {\n  const S = 1 \u003c\u003c n, lev = B.lev2, ori = B.ori2;\n  lev[hy * S + hx] = 0;\n  ori[hy * S + hx] = -1;\n  const rec = (x0, y0, L, hx, hy) => {\n    if (!L) return;\n    const h = 1 \u003c\u003c (L - 1), cx = x0 + h, cy = y0 + h, q = (hx >= cx ? 1 : 0) + (hy >= cy ? 2 : 0);\n    B.bori[L][(y0 >> L) * (S >> L) + (x0 >> L)] = q;\n    for (let k = 0; k \u003c 4; k++) {\n      const ix = cx - 1 + (k & 1), iy = cy - 1 + (k >> 1), qx = x0 + (k & 1 ? h : 0), qy = y0 + (k & 2 ? h : 0);\n      if (k === q) rec(qx, qy, L - 1, hx, hy);\n      else {\n        lev[iy * S + ix] = L;\n        ori[iy * S + ix] = q;\n        rec(qx, qy, L - 1, ix, iy);\n      }\n    }\n  };\n  rec(0, 0, n, hx, hy);\n}\n\n// Shell of a cell: the side, as a level, of the smallest block holding both\n// it and the hole.\nconst shellOf = (x, y, hx, hy) => 32 - Math.clz32((x ^ hx) | (y ^ hy));\n\n// Move the hole one cell along its line: whichever of the two grid lines\n// ahead it reaches first. At the board's edge the line reflects.\nfunction step(B, S) {\n  for (let guard = 0; guard \u003c 4; guard++) {\n    const px = B.u * S, py = B.v * S, cx = floor(px), cy = floor(py);\n    const tx = B.dx > 0 ? (cx + 1 - px) / B.dx : B.dx \u003c 0 ? (px - cx) / -B.dx : 1e9;\n    const ty = B.dy > 0 ? (cy + 1 - py) / B.dy : B.dy \u003c 0 ? (py - cy) / -B.dy : 1e9;\n    if (tx \u003c= ty) {\n      const nx = cx + (B.dx > 0 ? 1 : -1);\n      if (nx \u003c 0 || nx >= S) {\n        B.dx = -B.dx;\n        continue;\n      }\n      B.u = (nx + (B.dx > 0 ? 1e-6 : 1 - 1e-6)) / S;\n      B.v = (py + B.dy * tx) / S;\n    } else {\n      const ny = cy + (B.dy > 0 ? 1 : -1);\n      if (ny \u003c 0 || ny >= S) {\n        B.dy = -B.dy;\n        continue;\n      }\n      B.v = (ny + (B.dy > 0 ? 1e-6 : 1 - 1e-6)) / S;\n      B.u = (px + B.dx * ty) / S;\n    }\n    return;\n  }\n}\n\n// Re-lay the board for the hole's cell; every cell whose tromino changed\n// flashes.\nfunction relay(S, B, n) {\n  const N = 1 \u003c\u003c n, hx = cl(floor(B.u * N), 0, N - 1), hy = cl(floor(B.v * N), 0, N - 1);\n  if (hx === B.hx && hy === B.hy && !B.fresh) return;\n  lay(B, n, hx, hy);\n  const M = N * N;\n  for (let p = 0; p \u003c M; p++) {\n    if (!B.fresh && (B.lev[p] !== B.lev2[p] || B.ori[p] !== B.ori2[p])) B.flash[p] = 1;\n    B.lev[p] = B.lev2[p];\n    B.ori[p] = B.ori2[p];\n  }\n  if (B.fresh) B.flash.fill(0), (B.snap = true);\n  B.fresh = false;\n  B.hx = hx;\n  B.hy = hy;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const c = [1, 1, 2, 2, 4][cl(round(kv[3]), 1, 4)];\n  if (c !== S.c) {\n    S.c = c;\n    S.n = 6 - (c === 1 ? 0 : c === 2 ? 1 : 2);\n    S.S = 64 / c;\n    for (const B of S.boards) B.fresh = true;\n  }\n  const n = S.n, N = S.S;\n  S.lift = min(LIFT[cl(round(kv[2]), 0, 4)], n - 1);\n  // The hole walks nine LEDs a second for each unit of Speed, whatever the\n  // cell size.\n  S.t += d;\n  S.acc += (d * S.speed * 9) / c;\n  let steps = floor(S.acc);\n  S.acc -= steps;\n  for (const B of S.boards) {\n    relay(S, B, n);\n    for (let k = 0; k \u003c steps; k++) {\n      step(B, N);\n      relay(S, B, n);\n    }\n    // Each cell eases to its slot's colour in about an eighth of a second,\n    // so a shell that changes hue dissolves into the next; flashes fade.\n    if (S.palHue !== S.hue) palette(S);\n    const P = S.pal, u = S.lift, fv = B.snap ? 1 : min(1, d * 8), ff = exp(-d / 0.25), rgb = B.rgb;\n    B.snap = false;\n    for (let y = 0, p = 0; y \u003c N; y++)\n      for (let x = 0; x \u003c N; x++, p++) {\n        const o = B.ori[p], L = B.lev[p];\n        const sh = shellOf(x, y, B.hx, B.hy);\n        let k;\n        if (o \u003c 0) (k = 20), (B.flash[p] = 0);\n        else if (L === sh && L > u) k = 19;\n        else if (L > max(u, 1)) k = 12 + L;\n        else {\n          // Below the lift a cell takes the tone of its whole unlaid block.\n          const q = u ? B.bori[u][(y >> u) * (N >> u) + (x >> u)] : o;\n          k = 2 * (n - sh) + (q === 0 || q === 3 ? 0 : 1);\n        }\n        for (let e = 0; e \u003c 3; e++) rgb[p * 3 + e] += (P[k * 3 + e] - rgb[p * 3 + e]) * fv;\n        B.flash[p] *= ff;\n      }\n  }\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  for (let k = 0; k \u003c 6; k++) {\n    hsv(SHUE[k] + h, 0.72, 1, P, 6 * k);\n    hsv(wheel(SHUE[k] + 0.05 + h), 0.9, 0.27, P, 6 * k + 3);\n  }\n  // The 4 x 4 trominoes are half bright, so their hue skips orange too.\n  for (let L = 2; L \u003c= 6; L++) hsv(L === 2 ? wheel(LHUE[2] + h) : LHUE[L] + h, 0.75, L === 2 ? 0.62 : 0.95, P, (12 + L) * 3);\n  hsv(0.6 + h, 0.04, 1, P, 57);\n  P[60] = P[61] = P[62] = 0;\n  S.palHue = h;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.c) return;\n  const c = S.c, N = S.S, blink = S.t * 3 - floor(S.t * 3) \u003c 0.5;\n  for (const B of S.boards) {\n    for (let y = 0; y \u003c W; y++) {\n      const cy = floor(y / c);\n      for (let x = 0; x \u003c W; x++) {\n        const p = cy * N + floor(x / c), o = p * 3, r = B.rgb;\n        // The hole blinks white three times a second.\n        const f = B.ori[p] \u003c 0 ? (blink ? 1 : 0) : B.flash[p] * 0.8;\n        display.setPixel(x, B.y0 + y, (255 * (r[o] + (1 - r[o]) * f)) | 0, (255 * (r[o + 1] + (1 - r[o + 1]) * f)) | 0, (255 * (r[o + 2] + (1 - r[o + 2]) * f)) | 0);\n      }\n    }\n  }\n}\n","multiplicative-cascade":"// ===== Patternflow pattern =====\n// Title:   Multiplicative Cascade\n// Family:  fractal\n// Idea:    The panel's mass is halved thirteen times, across and down in turn, down to single LEDs, each half taking a random log-normal weight of mean 1, and every LED shows the log of its own share as light and the share of its 8 x 8 block as hue, so a patchwork of mint and violet rectangles of every size glitters at the LED level while the weights turn over level by level from the two halves down to the single LEDs and mass flows from half to half at each scale; Spread pushes the weights across the Kahane-Peyrière threshold, past which the total mass drains away and what is left gathers into a few sparks.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: multiplicative cascade (Benoit Mandelbrot, 1974), with the degeneracy threshold of Jean-Pierre Kahane and Jacques Peyrière (1976), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=0.4..1.6, Couple=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 heavy 8 x 8 blocks are mint, middling ones blue and light ones violet, with the heaviest LEDs near white; at 0.25 heavy blocks turn blue and light ones red; at 0.5 heavy ones pink and light ones green; at 0.75 heavy ones yellow and light ones azure. Dim orange and yellow are lifted by up to half so they do not read brown.\n// Knob 2: Speed. The weights turn over one level at a time, from the panel's two halves down to the single LEDs. At 2 a level takes 1.2 s to turn from its old draws to new ones, the next level starts 0.4 s later, and the sweep comes round every 6.4 s. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Spread. tau = E[W log2 W] for each weight W = exp(sigma G - sigma^2 / 2), from 0.4 to 1.6 (sigma 0.74 to 1.49). Kahane and Peyrière's threshold is tau = 1: below it the mass survives every halving, at and above it the total dies away. Medians of 2,000 cascades: at 0.4 the total mass is 0.64 after 7 halvings and 0.61 after 13, 98% of the LEDs show above the black floor and the heaviest 1% hold half the mass; at 1 the total falls from 0.24 to 0.15, half the LEDs show and the top 1% hold 86%; at 1.6 it falls from 0.057 to 0.019, 16% show and the top 1% hold 95%. The floor stays at 1/8100 of an even share, so lost mass shows as dark.\n// Knob 4: Couple. The correlation of the two halves' log weights at every split, -1 to 1. At -1 one half gains in log exactly what the other loses, so mass trades across every split line and each split shows a hard step; at the opening 0.06 the halves are close to independent, Mandelbrot's canonical cascade; at 1 both halves of a split take the same weight, no split line has a step of its own and the patches grow larger and softer. Each weight keeps its own law, so the threshold stays at tau = 1 (John Biggins, 1977), though after 13 halvings at Spread 1 the median total mass is 0.25 at -1, 0.15 at 0 and 0.08 at 1.\n\nconst W = 64, H = 128, N = W * H;\n// Thirteen halvings, across and down in turn, take the panel to single\n// LEDs. Node 1 is the panel, nodes 2n and 2n + 1 the halves of node n, and\n// nodes 8192..16383 the LEDs.\nconst L = 13, NODES = 1 \u003c\u003c (L + 1);\nconst { floor, min, max, sqrt, cos, sin, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The window of log mass shown, in units of the natural log of mass times\n// 8192: 0 is an LED's even share of the panel's mass, LO is shown black and\n// HI white. It does not move with the knobs, so lost mass shows as dark.\nconst LO = -9, HI = 2;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nfunction gauss() {\n  let u = 0;\n  while (u === 0) u = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * Math.random());\n}\n\n// Which LED each leaf is: bit k of the path from the panel down picks the\n// upper or lower half for odd k and the left or right half for even k.\nconst LED = new Int16Array(N);\nfor (let n = 0; n \u003c N; n++) {\n  let x = 0, y = 0;\n  for (let k = 1; k \u003c= L; k++) {\n    const b = (n >> (L - k)) & 1;\n    if (k & 1) y = y * 2 + b;\n    else x = x * 2 + b;\n  }\n  LED[n] = y * W + x;\n}\n\n// The weights change one level at a time, coarse to fine: level k starts\n// k - 1 steps after the panel's own halves, takes SPAN steps to turn from\n// its old draws to new ones, and the sweep comes round every CYCLE steps.\nconst SPAN = 3, CYCLE = 16, STEPS = 2.5;\n// Steps of block weight in the colour table.\nconst HB = 16;\n\nexport function setup(params) {\n  const S = {\n    hue: -1, speed: 2, tau: 0.4, rho: 0, phi: 0, cyc: new Int32Array(L + 1).fill(-1),\n    a: new Float32Array(NODES), b: new Float32Array(NODES),\n    acc: new Float32Array(NODES), g: new Float32Array(NODES), pal: new Float32Array(HB * 256 * 3),\n  };\n  // Each weight's normal G turns from one draw a to the next b along a\n  // quarter circle, cos(t) a + sin(t) b, which is again standard normal at\n  // every moment, so the cascade's law holds while it moves.\n  for (let n = 2; n \u003c NODES; n++) {\n    S.a[n] = gauss();\n    S.b[n] = gauss();\n  }\n  params.s = S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.tau = cl(kv[2], 0.4, 1.6);\n  S.rho = cl(kv[3], -1, 1);\n  if (kv[0] !== S.hue) palette(S, cl(kv[0], 0, 1));\n  const { a, b, g: G, acc } = S;\n  S.phi += (d * S.speed * STEPS) / 2;\n  for (let k = 1; k \u003c= L; k++) {\n    const sk = S.phi - (k - 1), c = floor(sk / CYCLE), u = sk - c * CYCLE;\n    if (c !== S.cyc[k]) {\n      // A new turn for this level: the old target is the new start.\n      S.cyc[k] = c;\n      for (let n = 1 \u003c\u003c k; n \u003c 2 \u003c\u003c k; n++) {\n        a[n] = b[n];\n        b[n] = gauss();\n      }\n    }\n    const p = cl(u / SPAN, 0, 1), t = (PI / 2) * p * p * (3 - 2 * p), ct = cos(t), st = sin(t);\n    for (let n = 1 \u003c\u003c k; n \u003c 2 \u003c\u003c k; n++) G[n] = ct * a[n] + st * b[n];\n  }\n  // Spread is tau = E[W log2 W]; for W = exp(sigma G - sigma^2 / 2) that is\n  // sigma^2 / (2 ln 2).\n  const sig = sqrt(2 * Math.LN2 * S.tau), half = (sig * sig) / 2;\n  const r = S.rho, r2 = sqrt(1 - r * r);\n  // The first half takes its own normal; the second takes rho times its\n  // sibling's plus its own, so both are standard normal and their\n  // correlation is rho. Each half's log weight adds to its parent's log mass.\n  acc[1] = 0;\n  for (let n = 2; n \u003c NODES; n += 2) {\n    const g1 = G[n], g2 = r * g1 + r2 * G[n + 1], up = acc[n >> 1] - half;\n    acc[n] = up + sig * g1;\n    acc[n + 1] = up + sig * g2;\n  }\n}\n\n// Colour by two depths of the same cascade: the hue says how heavy the\n// LED's 8 x 8 block (seven halvings down) is against a typical block at\n// this Spread, the light says how heavy the LED itself is against an even\n// share. Rows of the table are HB steps of block weight, columns 256 steps\n// of LED weight.\nfunction palette(S, hue) {\n  S.hue = hue;\n  for (let j = 0; j \u003c HB; j++) {\n    const z = (2 * j) / (HB - 1) - 1;\n    for (let i = 0; i \u003c 256; i++) {\n      const v = i / 255;\n      const h = 0.62 + hue - 0.2 * z - 0.05 * v, hh = h - floor(h);\n      // Orange and yellow are lifted so that dim ones do not read brown, and\n      // deep blue is paled a little, since it reads darkest on the LEDs.\n      const warm = max(0, cos(2 * PI * (hh - 0.11))) ** 2, blue = max(0, cos(2 * PI * (hh - 0.67)));\n      const sat = 0.95 - 0.12 * blue - 0.7 * v ** 5;\n      hsv(h, sat, i ? min(1, (0.08 + 0.92 * v) * (1 + 0.5 * warm)) : 0, S.pal, (j * 256 + i) * 3);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { acc, pal } = S, k = 255 / (HI - LO);\n  // A block seven halvings down carries seven weights; its log weight\n  // against an even share has mean -7 sigma^2 / 2 and spread sigma sqrt 7.\n  const sig = sqrt(2 * Math.LN2 * S.tau), m7 = (-7 * sig * sig) / 2, s7 = 1 / (sig * sqrt(7));\n  for (let n = 0; n \u003c N; n++) {\n    const p = LED[n], x = p & 63, y = p >> 6;\n    const v = acc[N + n] - LO;\n    if (v \u003c= 0) {\n      display.setPixel(x, y, 0, 0, 0);\n      continue;\n    }\n    const z = Math.tanh((acc[(N + n) >> 6] - m7) * s7 * 0.8);\n    const c = ((((z + 1) * (HB - 1)) / 2 + 0.5) | 0) * 768 + min(255, (v * k) | 0) * 3;\n    display.setPixel(x, y, (255 * pal[c]) | 0, (255 * pal[c + 1]) | 0, (255 * pal[c + 2]) | 0);\n  }\n}\n","random-organization":"// ===== Patternflow pattern =====\n// Title:   Random Organization\n// Family:  sim\n// Idea:    Disks in a periodic box are sheared, one side sliding up and the other down and back once a cycle, every disk that touched another during the cycle is kicked a short random step, and the share kicked, traced along the bottom, falls cycle by cycle until below a critical strain the box finds places where nobody touches and freezes for good, while above it the flashing never stops.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random organization under periodic shear (Laurent Corté, Paul Chaikin, Jerry Gollub and David Pine, 2008), an absorbing-state phase transition, pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strain=1..4, Density=0.2..0.35\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 calm disks are teal, disks that have touched another this cycle gold, disks touching right now pale gold, a kick flashes white, and the material grid is slate; at 0.25 calm disks are violet and touched ones green, at 0.5 pink and blue, at 0.75 green and magenta. The calm colour skips orange and yellow, which read brown and olive at its level.\n// Knob 2: Speed. Shear cycles a second, 0.75 x Speed: 1.5 at 2, 0.15 at 0.2, 2.25 at 3. At the opening Strain and Density the box froze after a median of 89 cycles over 30 runs, a minute at Speed 2; it then shears on calm for 10 cycles and a fresh box is dropped.\n// Knob 3: Strain. The strain amplitude gamma0, 1 to 4: the panel's side columns travel 32 x gamma0 rows each way and back every cycle, and the grid's squares lean into parallelograms that steep. At the opening Density (83 disks) the median run froze after 89 cycles at 1, 219 at 2 and 504 at 2.5; at 3 half of 8 runs were still going after 6,000 cycles, and at 3.5 and 4 none stopped, with 52% and 63% of the disks kicked every cycle.\n// Knob 4: Density. The disks' area fraction, 0.2 to 0.35: 83 to 146 disks of radius 2.5 LEDs in the 64 x 128 box, added at random or taken away at the end of a cycle. At the opening Strain the median run froze after 89 cycles at 0.2, 216 at 0.24 and 839 at 0.27; at 0.3 none of 8 runs stopped in 6,000 cycles, 44% of the disks kicked every cycle, and 65% at 0.35.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, cos, sin, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Disk radius in LEDs, the kick (a random step up to KICK diameters), the\n// most disks the arrays hold, and the calm cycles held before a fresh box.\nconst R = 2.5, D = 2 * R, KICK = 0.75, NMAX = 260, HOLD = 10;\n// Shear cycles a second at Speed 1.\nconst RATE = 0.75;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob's wheel skips orange through yellow, which reads brown and olive\n// on dim disks.\nconst wheel = (h) => 0.18 + 0.85 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    n: 0, X: new Float64Array(NMAX), Y: new Float64Array(NMAX),\n    first: new Float32Array(NMAX), age: new Float32Array(NMAX), flash: new Float32Array(NMAX),\n    pa: new Int16Array(2048), pb: new Int16Array(2048), lo: new Float32Array(2048), hi: new Float32Array(2048), np: 0,\n    phase: 0, g0: 1, gNext: 1, phi: 0.2, cps: 2, hue: 0, born: false,\n    hist: new Float32Array(W).fill(-1), quiet: 0, cycles: 0, f: 1,\n    rgb: new Float32Array(NP * 3), pal: new Float32Array(18), palHue: -1,\n  };\n}\n\nconst count = (phi) => cl(round((phi * W * H) / (PI * R * R)), 4, NMAX);\n\nfunction scatter(S, i) {\n  S.X[i] = Math.random() * W;\n  S.Y[i] = Math.random() * H;\n  S.age[i] = 0;\n  S.flash[i] = 1;\n}\n\n// A fresh box: disks dropped anywhere, overlaps and all.\nfunction stir(S) {\n  S.n = count(S.phi);\n  for (let i = 0; i \u003c S.n; i++) scatter(S, i);\n  S.hist.fill(-1);\n  S.quiet = 0;\n  S.cycles = 0;\n}\n\n// The whole cycle's contacts, worked out before it starts. Under the shear\n// y -> y + g (x - 32) a pair with reference separation (dx, dy) sits at\n// (dx, dy + g dx), so it touches at strain g when |dy + g dx| \u003c sqrt(D^2 - dx^2).\n// That is an interval of g; where it meets [0, g0] the pair collides this\n// cycle, and its lower end is the strain of first contact. The box is\n// periodic in x and y, and its x images ride the shear with it\n// (Lees-Edwards), so dx is the nearest image and dy is tried a box up and down.\nfunction contacts(S) {\n  const { n, X, Y, first } = S, g0 = S.g0;\n  first.fill(1e9, 0, n);\n  S.np = 0;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      let dx = X[j] - X[i];\n      dx -= W * round(dx / W);\n      if (dx >= D || dx \u003c= -D) continue;\n      const h = sqrt(D * D - dx * dx);\n      for (let m = -1; m \u003c= 1; m++) {\n        const dy = Y[j] - Y[i] + m * H;\n        let a, b;\n        if (abs(dx) \u003c 1e-9) {\n          if (abs(dy) >= h) continue;\n          (a = 0), (b = g0);\n        } else {\n          const u = (-h - dy) / dx, v = (h - dy) / dx;\n          (a = max(0, min(u, v))), (b = min(g0, max(u, v)));\n          if (a >= b) continue;\n        }\n        if (a \u003c first[i]) first[i] = a;\n        if (a \u003c first[j]) first[j] = a;\n        if (S.np \u003c 2048) {\n          S.pa[S.np] = i;\n          S.pb[S.np] = j;\n          S.lo[S.np] = a;\n          S.hi[S.np] = b;\n          S.np++;\n        }\n      }\n    }\n}\n\n// End of a cycle, back at zero strain: every disk that touched anyone is\n// moved a random step up to KICK diameters, the rest stay exactly put.\nfunction endCycle(S) {\n  let k = 0;\n  for (let i = 0; i \u003c S.n; i++) {\n    if (S.first[i] > 1e8) {\n      S.age[i] += 1;\n      continue;\n    }\n    k++;\n    const a = Math.random() * TAU, m = Math.random() * KICK * D;\n    S.X[i] = (S.X[i] + m * cos(a) + W) % W;\n    S.Y[i] = (S.Y[i] + m * sin(a) + H) % H;\n    S.age[i] = 0;\n    S.flash[i] = 1;\n  }\n  S.f = S.n ? k / S.n : 0;\n  S.hist.copyWithin(0, 1);\n  S.hist[W - 1] = S.f;\n  S.cycles++;\n  S.quiet = k ? 0 : S.quiet + 1;\n}\n\n// Density turned: disks are added at random or the last ones taken away.\nfunction resize(S) {\n  const want = count(S.phi);\n  while (S.n \u003c want) scatter(S, S.n++);\n  if (S.n > want) S.n = want;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.cps = cl(kv[1], 0.2, 3);\n  S.gNext = cl(kv[2], 1, 4);\n  S.phi = cl(kv[3], 0.2, 0.35);\n  if (!S.born) {\n    stir(S);\n    S.g0 = S.gNext;\n    contacts(S);\n    S.born = true;\n  }\n  for (let i = 0; i \u003c S.n; i++) S.flash[i] = max(0, S.flash[i] - d * 4);\n  S.phase += d * S.cps * RATE;\n  while (S.phase >= 1) {\n    S.phase -= 1;\n    endCycle(S);\n    if (S.quiet >= HOLD) stir(S);\n    resize(S);\n    S.g0 = S.gNext;\n    contacts(S);\n  }\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  hsv(wheel(h + 0.376), 0.65, 1, P, 0); // calm disks, teal at Hue 0\n  hsv(h + 0.13, 0.85, 0.9, P, 3); // disks that touched this cycle, gold\n  hsv(wheel(h + 0.5), 0.45, 0.3, P, 6); // the sheared material grid\n  hsv(h + 0.13, 0.4, 1, P, 9); // touching right now, pale gold\n  hsv(h + 0.13, 0.55, 0.85, P, 12); // activity trace\n  S.palHue = S.hue;\n}\n\n// One disk at lab centre (cx, cy), soft at the rim, kept brightest per LED.\nfunction disk(S, cx, cy, r, g, b) {\n  const rgb = S.rgb, x0 = floor(cx - R - 1), y0 = floor(cy - R - 1);\n  for (let yy = y0; yy \u003c= y0 + 2 * R + 2; yy++) {\n    const py = ((yy % H) + H) % H, ey = yy + 0.5 - cy;\n    for (let xx = x0; xx \u003c= x0 + 2 * R + 2; xx++) {\n      if (xx \u003c 0 || xx >= W) continue;\n      const ex = xx + 0.5 - cx, k = cl(R + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (k \u003c= 0) continue;\n      const p = (py * W + xx) * 3;\n      if (rgb[p] \u003c r * k) rgb[p] = r * k;\n      if (rgb[p + 1] \u003c g * k) rgb[p + 1] = g * k;\n      if (rgb[p + 2] \u003c b * k) rgb[p + 2] = b * k;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  if (S.palHue !== S.hue) palette(S);\n  const P = S.pal, rgb = S.rgb, g = (S.g0 * (1 - cos(TAU * S.phase))) / 2;\n  // How far the strain has reached this cycle: contacts up to here have happened.\n  const reach = S.phase \u003c 0.5 ? g : S.g0;\n  rgb.fill(0);\n  // The material grid: squares 16 LEDs on a side in the unsheared box. The\n  // shear tilts their rows into parallelograms and slides the columns\n  // along themselves.\n  for (let x = 0; x \u003c W; x++) {\n    const off = g * (x + 0.5 - 32);\n    for (let y = 0; y \u003c H; y++) {\n      const v = (((y + 0.5 - off) % 16) + 16) % 16, k = max(cl(1.2 - abs(v - 8), 0, 1), x % 16 === 8 ? 0.6 : 0);\n      if (k \u003c= 0) continue;\n      const p = (y * W + x) * 3;\n      rgb[p] = P[6] * k;\n      rgb[p + 1] = P[7] * k;\n      rgb[p + 2] = P[8] * k;\n    }\n  }\n  // Which disks touch right now.\n  const now = new Uint8Array(S.n);\n  for (let q = 0; q \u003c S.np; q++) if (g > S.lo[q] && g \u003c S.hi[q]) now[S.pa[q]] = now[S.pb[q]] = 1;\n  for (let i = 0; i \u003c S.n; i++) {\n    let o = S.first[i] \u003c= reach ? 3 : 0;\n    if (now[i]) o = 9;\n    // A calm disk kicked lately is brighter, settling over a few cycles to\n    // the steady level of disks that have stopped moving.\n    const f = S.flash[i], v = o ? 1 : 0.5 + 0.35 * Math.exp(-S.age[i] / 4);\n    let r = P[o] * v, gg = P[o + 1] * v, b = P[o + 2] * v;\n    (r += f * (1 - r)), (gg += f * (1 - gg)), (b += f * (1 - b));\n    const cx = S.X[i], cy = S.Y[i] + g * (S.X[i] - 32);\n    disk(S, cx, cy, r, gg, b);\n    // Images across the side edges ride the shear 64 * g further.\n    if (cx \u003c R + 1) disk(S, cx + W, cy + g * W, r, gg, b);\n    if (cx > W - R - 1) disk(S, cx - W, cy - g * W, r, gg, b);\n  }\n  // Activity: the share of disks kicked in each of the last 64 cycles, one\n  // column a cycle, newest on the right, full height 16 rows.\n  for (let x = 0; x \u003c W; x++) {\n    const f = S.hist[x];\n    if (f \u003c 0) continue;\n    const top = round(f * 16);\n    for (let k = 0; k \u003c= top; k++) {\n      const p = ((H - 1 - k) * W + x) * 3, a = k === top ? 1 : 0.35;\n      rgb[p] = max(rgb[p], P[12] * a);\n      rgb[p + 1] = max(rgb[p + 1], P[13] * a);\n      rgb[p + 2] = max(rgb[p + 2], P[14] * a);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, (255 * min(1, rgb[p])) | 0, (255 * min(1, rgb[p + 1])) | 0, (255 * min(1, rgb[p + 2])) | 0);\n}\n","tree-peano-curve":"// ===== Patternflow pattern =====\n// Title:   Tree Peano Curve\n// Family:  line\n// Idea:    A uniform spanning tree of the panel's 32 x 64 blocks of 2 x 2 LEDs grows by Wilson's loop-erased random walks, and its Peano curve, which winds round the tree through every one of the 8192 LEDs once on its way from the bottom left corner to the top left, is coloured green to magenta in the order it passes them, so its space-filling sweep up the panel shows as fractal fronts while pale fronts and short runners flow along it, and every 8 seconds a new tree is grown and its curve traced in.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: uniform spanning tree by loop-erased random walks (David Wilson, 1996), its Peano curve converges to SLE(8) (Gregory Lawler, Oded Schramm and Wendelin Werner, 2004), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bands=1..8, Stretch=-1..1\n//\n// Knob 1: Hue. Turns the curve's colours round the wheel. At 0 the curve runs from green at the bottom left corner through teal and blue to magenta at the top left; at 0.25 from azure through violet and red to orange; at 0.5 from violet through red and yellow to teal; at 0.75 from red through yellow and green to azure. Orange and yellow are lifted most of the way to full light between fronts, so they never sink to brown.\n// Knob 2: Speed. At 2 each tree lasts 8 s: colour flows over its curve for 3.6 s, Wilson's walks grow the next tree in 2 s (about 5,600 steps of 840 walks, the first slowly), and the next curve is traced in from the corner in 2.4 s. Fronts run 1,024 LEDs a second along the curve and the 51 runners 40. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Bands. How many pale fronts run along the curve at once, 1 to 8. A front lights the stretch of curve it has just passed, so its edge is the outline of the region the curve has filled so far, the discrete SLE(8) hull. At 1 one front sweeps up the panel and each LED is passed every 8 s at Speed 2; at 8 eight fronts run 1,024 LEDs apart and each LED is passed every second.\n// Knob 4: Stretch. An upright edge of the grid weighs e^(2.5 x Stretch) times a level one, 12 times at 1, and the walks step up and down that much more often, which makes the tree the weighted uniform one. At -1 a fifth of the tree's 2,047 edges stand upright and the curve lies in long level folds, at the opening 0.06 just over half do, and at 1 four fifths do and the curve hangs in tall columns.\n\nconst W = 64, H = 128, N = W * H;\n// The tree lives on the 32 x 64 grid of 2 x 2 LED blocks.\nconst X = 32, Y = 64, M = X * Y;\nconst { floor, min, max, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Direction bits of a tree edge out of a block.\nconst E = 1, WE = 2, S_ = 4, NO = 8;\n// Seconds at Speed 2: colour flows over the finished curve, then Wilson's\n// walks grow the next tree, then the next curve is traced in from a to b.\nconst FLOW = 3.6, GROW = 2.0, TRACE = 2.4;\n// A front runs the whole cycle in this many seconds at Speed 2, whatever\n// the number of bands, so more bands pass each LED more often.\nconst LAP = 8;\n// The hue at a at knob 0, and how far round the wheel it turns by b.\nconst HUE0 = 0.3, SPAN = 0.6;\n// Runners: a bright head every GAP LEDs along the curve with a tail TAIL\n// LEDs long, running from a to b at RUN LEDs a second at Speed 2, so the\n// way the curve winds shows LED by LED.\nconst GAP = 160, TAIL = 32, RUN = 40;\nconst TL = new Float32Array(GAP);\nfor (let i = 0; i \u003c TAIL; i++) TL[i] = 0.8 * Math.pow(1 - i / TAIL, 1.6);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The wired arc: the blocks along the bottom, up the right side and back\n// along the top, joined in one path that every tree contains. The left side\n// is free. The curve then runs from the bottom left corner (a) to the top\n// left corner (b), which is Lawler, Schramm and Werner's set-up.\nconst ARC = [];\nfor (let i = 0; i \u003c X; i++) ARC.push((Y - 1) * X + i);\nfor (let j = Y - 2; j >= 0; j--) ARC.push(j * X + X - 1);\nfor (let i = X - 2; i >= 0; i--) ARC.push(i);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, bands: 1, stretch: 0,\n    adj: new Uint8Array(M), nadj: new Uint8Array(M),\n    sOld: new Int16Array(N).fill(-1), sNew: new Int16Array(N),\n    log: new Int16Array(1 \u003c\u003c 16), nlog: 0,\n    inT: new Uint8Array(M), par: new Int16Array(M), born: new Float32Array(M), blen: new Int16Array(M),\n    path: new Int16Array(M), pos: new Int16Array(M), plen: 0, k: 0,\n    phase: -1, pt: 0, phi: 0, psi: 0,\n    rgb: new Float32Array(N * 3), pal: new Float32Array(1024 * 3), warm: new Float32Array(1024), palKey: -1,\n  };\n}\n\nfunction link(adj, p, out) {\n  const x = p & 63, y = p >> 6, b = (y >> 1) * X + (x >> 1), sx = x & 1, sy = y & 1;\n  out[0] = adj[b] & (sx ? E : WE) ? p + (sx ? 1 : -1) : p ^ 64;\n  out[1] = adj[b] & (sy ? S_ : NO) ? p + (sy ? W : -W) : p ^ 1;\n}\n\nconst dirOf = (a, b) => (b === a + 1 ? E : b === a - 1 ? WE : b === a + X ? S_ : NO);\n\n// Wilson's algorithm with the arc as root: from each block not yet in the\n// tree a random walk runs until it meets the tree, and its loop erasure is\n// added. Edge weights wh (across) and wv (up and down) bias the walk, which\n// makes the tree the weighted uniform one. Every step is logged so the\n// walks can be shown afterwards at the pace of the panel.\nfunction wilson(S, wh, wv) {\n  const inT = new Uint8Array(M), nxt = new Int16Array(M).fill(-1), adj = S.nadj;\n  adj.fill(0);\n  for (const v of ARC) inT[v] = 1;\n  for (let k = 0; k + 1 \u003c ARC.length; k++) {\n    const a = ARC[k], b = ARC[k + 1];\n    adj[a] |= dirOf(a, b);\n    adj[b] |= dirOf(b, a);\n  }\n  const order = new Int16Array(M);\n  for (let i = 0; i \u003c M; i++) order[i] = i;\n  for (let i = M - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = order[i];\n    order[i] = order[j];\n    order[j] = t;\n  }\n  let n = 0, log = S.log;\n  const put = (v) => {\n    if (n >= log.length) {\n      const big = new Int16Array(log.length * 2);\n      big.set(log);\n      log = S.log = big;\n    }\n    log[n++] = v;\n  };\n  for (let o = 0; o \u003c M; o++) {\n    const s = order[o];\n    if (inT[s]) continue;\n    put(s);\n    let u = s;\n    while (!inT[u]) {\n      const i = u % X, j = (u / X) | 0;\n      const a = i > 0 ? wh : 0, b = i \u003c X - 1 ? wh : 0, c = j > 0 ? wv : 0, d = j \u003c Y - 1 ? wv : 0;\n      let r = Math.random() * (a + b + c + d);\n      const v = (r -= a) \u003c 0 ? u - 1 : (r -= b) \u003c 0 ? u + 1 : (r -= c) \u003c 0 ? u - X : u + X;\n      nxt[u] = v;\n      put(v);\n      u = v;\n    }\n    for (u = s; !inT[u]; u = nxt[u]) {\n      inT[u] = 1;\n      adj[u] |= dirOf(u, nxt[u]);\n      adj[nxt[u]] |= dirOf(nxt[u], u);\n    }\n  }\n  S.nlog = n;\n}\n\n// The curve. Each block starts as a ring round its own four LEDs; every tree\n// edge cuts the two facing sides of two rings and joins them across, so the\n// tree's 2047 edges join the 2048 rings into one cycle through all 8192\n// LEDs, the outline of the thickened tree. It is cut where it leaves the\n// bottom left corner: the Peano path from a to b first, then 254 LEDs back\n// round the outside of the arc.\nfunction trace(adj, s) {\n  s.fill(-1);\n  const nb = [0, 0];\n  let prev = 127 * W, p = 126 * W, k = 0;\n  while (k \u003c N && s[p] \u003c 0) {\n    s[p] = k++;\n    link(adj, p, nb);\n    const q = nb[0] !== prev ? nb[0] : nb[1];\n    prev = p;\n    p = q;\n  }\n  return k;\n}\n\nfunction startGrow(S) {\n  const a = S.stretch * 1.25;\n  wilson(S, exp(-a), exp(a));\n  S.inT.fill(0);\n  for (const v of ARC) S.inT[v] = 1;\n  S.born.fill(-9);\n  S.pos.fill(-1);\n  S.plen = 0;\n  S.k = 0;\n}\n\n// One logged step of the walks: start, step, erase a loop, or join the tree.\n// Erasing each loop as it closes gives back the same tree Wilson's run built.\nfunction replay(S) {\n  const v = S.log[S.k++], { path, pos, inT } = S;\n  if (S.plen === 0) {\n    path[0] = v;\n    pos[v] = 0;\n    S.plen = 1;\n  } else if (inT[v]) {\n    for (let i = 0; i \u003c S.plen; i++) {\n      const u = path[i];\n      inT[u] = 1;\n      pos[u] = -1;\n      S.par[u] = i + 1 \u003c S.plen ? path[i + 1] : v;\n      S.born[u] = S.pt;\n      S.blen[u] = S.plen;\n    }\n    S.plen = 0;\n  } else if (pos[v] >= 0) {\n    for (let i = pos[v] + 1; i \u003c S.plen; i++) pos[path[i]] = -1;\n    S.plen = pos[v] + 1;\n  } else {\n    pos[v] = S.plen;\n    path[S.plen++] = v;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.bands = cl(kv[2], 1, 8);\n  S.stretch = cl(kv[3], -1, 1);\n  const g = (d * S.speed) / 2;\n  S.phi += (g * S.bands) / LAP;\n  S.psi += g * RUN;\n  if (S.phase \u003c 0) {\n    // The first tree is grown at once and traced in from black.\n    startGrow(S);\n    S.adj.set(S.nadj);\n    trace(S.adj, S.sNew);\n    S.phase = 2;\n    S.pt = 0;\n    return;\n  }\n  S.pt += g;\n  if (S.phase === 0 && S.pt >= FLOW) {\n    S.phase = 1;\n    S.pt = 0;\n    S.sOld.set(S.sNew);\n    startGrow(S);\n  } else if (S.phase === 1) {\n    const want = floor(pow(cl(S.pt / GROW, 0, 1), 2.5) * S.nlog);\n    while (S.k \u003c want) replay(S);\n    if (S.pt >= GROW) {\n      S.adj.set(S.nadj);\n      trace(S.adj, S.sNew);\n      S.phase = 2;\n      S.pt = 0;\n    }\n  } else if (S.phase === 2 && S.pt >= TRACE) {\n    S.phase = 0;\n    S.pt = 0;\n  }\n}\n\n// A monotone turn of the hue circle that hurries through orange and\n// yellow, which read brown and olive when dim.\nconst warp = (h) => h + (0.5 / (2 * Math.PI)) * Math.sin(2 * Math.PI * (h - 0.11));\n\n// Hue by place along the whole curve, from a to b; brightness and a\n// whitening by how long ago the last front passed.\nfunction palette(S) {\n  const key = S.hue;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const P = S.pal, h0 = HUE0 + S.hue;\n  for (let i = 0; i \u003c 1024; i++) {\n    // Deep blue is paled a little, since it reads darkest on the LEDs.\n    const h = warp(h0 + SPAN * (i / 1023));\n    hsv(h, 0.88 - 0.3 * max(0, Math.cos(2 * Math.PI * (h - 0.66))), 1, P, i * 3);\n    // Orange and yellow keep most of their light even long after a front,\n    // so they never sink to brown and olive.\n    S.warm[i] = 0.65 * pow(max(0, Math.cos(2 * Math.PI * (h - 0.11))), 2);\n  }\n}\n// Palette index by place on the cycle: up the hues along the Peano path,\n// then back down them along the 254 LEDs that close the cycle round the\n// outside of the arc, so the closing run meets a in a's own colour.\nconst PATH = N - 254, HP = new Int16Array(N);\nfor (let s = 0; s \u003c N; s++) HP[s] = s \u003c PATH ? ((s * 1023) / PATH) | 0 : (((N - s) * 1023) / (N - PATH)) | 0;\nconst VL = new Float32Array(1024), WL = new Float32Array(1024);\nfor (let i = 0; i \u003c 1024; i++) {\n  const u = i / 1023;\n  VL[i] = 0.45 + 0.55 * u;\n  WL[i] = 0.55 * Math.pow(u, 8);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.phase \u003c 0) return;\n  palette(S);\n  const rgb = S.rgb, P = S.pal, K = S.bands, phi = S.phi, sN = S.sNew, sO = S.sOld;\n  const ph = S.phase, pt = S.pt;\n  const head = ph === 2 ? (pt / TRACE) * N : N + 1e9;\n  const dim = ph === 1 ? 1 - 0.6 * cl(pt / 0.4, 0, 1) : 0.4;\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    // Behind the head of a trace the new curve, ahead of it the old one.\n    let s = sN[p], f = 1, tip = 0;\n    if (ph === 1 || s > head) {\n      s = sO[p];\n      f = dim;\n      if (s \u003c 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n    } else if (ph === 2 && head - s \u003c 160) tip = (1 - (head - s) / 160) ** 2;\n    let u = (K * s) / N - phi;\n    u -= floor(u);\n    const i = HP[s], c = i * 3, ui = (u * 1023) | 0;\n    // A runner's tail, if one is passing.\n    let a = (S.psi - s) % GAP;\n    if (a \u003c 0) a += GAP;\n    const t = ph === 1 ? 0 : TL[a | 0];\n    const lo = VL[ui] + (1 - VL[ui]) * S.warm[i];\n    f *= lo + (1 - lo) * t;\n    const w = WL[ui] + (1 - WL[ui]) * t * 0.6;\n    for (let e = 0; e \u003c 3; e++) {\n      const v = (P[c + e] + (1 - P[c + e]) * w) * f;\n      // The tip of the curve being traced in glows white.\n      rgb[o + e] = v + (1 - v) * tip;\n    }\n  }\n  if (ph === 1) {\n    // Wilson's walks: the loop-erased path still walking, and the branches\n    // that have just joined the tree, drawn through the top left LED of\n    // each block.\n    const at = (v, c) => {\n      const x = (v % X) * 2, y = ((v / X) | 0) * 2, o = (y * W + x) * 3;\n      for (let e = 0; e \u003c 3; e++) rgb[o + e] += (1 - rgb[o + e]) * c;\n    };\n    const mid = (a, b, c) => {\n      const x = (a % X) + (b % X), y = ((a / X) | 0) + ((b / X) | 0), o = (y * W + x) * 3;\n      for (let e = 0; e \u003c 3; e++) rgb[o + e] += (1 - rgb[o + e]) * c;\n    };\n    for (let v = 0; v \u003c M; v++) {\n      const age = pt - S.born[v];\n      if (age \u003c 0 || age > 0.6) continue;\n      // Long branches flash longer than the many short ones at the end.\n      const c = 0.85 * min(1, S.blen[v] / 8) * exp(-age / 0.18);\n      at(v, c);\n      mid(v, S.par[v], c);\n    }\n    for (let i = 0; i \u003c S.plen; i++) {\n      at(S.path[i], 0.95);\n      if (i) mid(S.path[i - 1], S.path[i], 0.95);\n    }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","twist-writhe":"// ===== Patternflow pattern =====\n// Title:   Twist and Writhe\n// Family:  topology\n// Idea:    A closed ribbon, twisted Lk times round a flat circle, folds through a figure-eight into a tall supercoil while its two coloured edges stay linked the same number of times, so the twist of its two-toned faces unwinds as the writhe of its centre line grows, and a bar along the bottom shows Tw and Wr adding up to the same whole number all the way.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Călugăreanu-White-Fuller theorem Lk = Tw + Wr (Gheorghe Călugăreanu, 1959; James H. White, 1969; F. Brock Fuller, 1971), supercoiled DNA (Jerome Vinograd, 1965), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lk=3..6, Coil=3..6\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the ribbon's front face is azure and its back violet, its edges pink and lime; at 0.25 purple and rose with green and aqua edges, at 0.5 red and green with cyan and blue, at 0.75 green and sky blue with violet and magenta. The wheel skips orange and yellow, which read brown on the shaded far side.\n// Knob 2: Speed. At 2 a cycle takes 12 s: the loop lies flat for 1.2 s, coils for 4.5 s, holds for 1.8 s and uncoils for 4.5 s, while the view turns half a turn, slowly while the loop is flat. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Lk. The linking number of the two edges, a whole number from 3 to 6. On the flat circle it is all twist: the ribbon turns over 2 Lk times round the loop, a half-turn every 47 LEDs of ribbon at 3 and every 24 at 6. Turning it cuts the ribbon, turns one end and joins it again, as a type I topoisomerase does to a ring of DNA one turn at a time.\n// Knob 4: Coil. The writhe the centre line reaches at the deepest point of the cycle, 3 to 6, so the twist left there is Lk - Coil. At 3 the supercoil winds 4.3 half-turns and stands 106 LEDs tall and 14 across; at 6 it winds 8.1 and is 8 across, its strands 6 LEDs apart. Past Lk the ribbon comes out twisted the other way, and the Tw bar runs back to the mark, striped.\n\nconst W = 64, H = 128, NPX = W * H;\nconst { floor, min, max, sqrt, sin, cos, abs, atan2, asin, round, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Points on the centre line, and its length in LEDs: a circle of radius 45.\nconst M = 144, LEN = TAU * 45;\n// Half the ribbon's width, in LEDs.\nconst HW = 3;\n// Where the middle of the ribbon sits on the panel; the bar is below.\nconst CX = 32, CY = 57;\n// The cycle at Speed 2, in seconds: flat, coiling, held, uncoiling.\nconst FLAT = 1.2, UP = 4.5, HOLD = 1.8, DOWN = 4.5, CYCLE = FLAT + UP + HOLD + DOWN;\n// Writhe of the coiling family below at q = 0, 0.5, 1, ... 9 half-turns,\n// from the same Gauss integral the pattern runs, used only to pick the q\n// whose writhe is the knob's target. The writhe shown is computed afresh.\nconst WR_OF_Q = [0, 0.124, 0.454, 0.823, 1.189, 1.584, 1.979, 2.375, 2.771, 3.166, 3.56, 3.954, 4.347, 4.74, 5.132, 5.525, 5.917, 6.309, 6.701];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips 0.03..0.18.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const K = M * 4;\n  params.s = {\n    t: 0, hue: 0, speed: 2, lk: 3, coil: 3, q: 0,\n    P: new Float64Array(M * 3), T: new Float64Array(M * 3), U: new Float64Array(M * 3), P1: new Float64Array(M * 3),\n    Q: new Float64Array(K * 3), cum: new Float64Array(K + 1),\n    wr: 0, tw: 0, phi: 0, yaw: 0,\n    sx: new Float32Array(M * 2), sy: new Float32Array(M * 2), sz: new Float32Array(M * 2), face: new Float32Array(M),\n    zb: new Float32Array(NPX), rgb: new Float32Array(NPX * 3), pal: new Float32Array(18), palHue: -1,\n  };\n}\n\n// The coiling family, q half-turns deep. An oval in the xz-plane, a circle\n// at q = 0 and a rounded long loop (superellipse exponent 0.6) from q = 2,\n// is twisted about its long axis z by q pi from bottom to top, so its two\n// long sides wind round each other q half-turns as the two strands of a\n// supercoil; the oval stretches so the strands keep a pitch of about 42\n// degrees. It never passes through itself: at each height its two strands\n// sit on opposite sides of the axis. The curve is then laid out at equal\n// steps of arc length and scaled to LEN, so the ribbon keeps its length.\nfunction shape(S, q) {\n  const { P, Q, cum } = S, K = M * 4;\n  const b = sqrt(1 + ((q * PI) / 1.8) ** 2), p = 1 - 0.4 * min(1, q / 2), kap = -(q * PI) / (2 * b);\n  for (let i = 0; i \u003c K; i++) {\n    const th = (TAU * i) / K, c = cos(th), s = sin(th);\n    const x = (c \u003c 0 ? -1 : 1) * abs(c) ** p, z = b * (s \u003c 0 ? -1 : 1) * abs(s) ** p, ps = kap * z;\n    Q[i * 3] = x * cos(ps);\n    Q[i * 3 + 1] = x * sin(ps);\n    Q[i * 3 + 2] = z;\n  }\n  cum[0] = 0;\n  for (let i = 0; i \u003c K; i++) {\n    const j = ((i + 1) % K) * 3, o = i * 3;\n    cum[i + 1] = cum[i] + hypot(Q[j] - Q[o], Q[j + 1] - Q[o + 1], Q[j + 2] - Q[o + 2]);\n  }\n  const k0 = LEN / cum[K];\n  for (let i = 0, k = 0; i \u003c M; i++) {\n    const s = (cum[K] * i) / M;\n    while (cum[k + 1] \u003c s) k++;\n    const f = (s - cum[k]) / (cum[k + 1] - cum[k] || 1), o = k * 3, j = ((k + 1) % K) * 3;\n    for (let e = 0; e \u003c 3; e++) P[i * 3 + e] = (Q[o + e] + f * (Q[j + e] - Q[o + e])) * k0;\n  }\n}\n\n// The writhe by the Gauss double integral over the closed polygon, each\n// pair of segments in closed form: the solid angle the one sees the other\n// under, signed, over 4 pi (Konstantin Klenin and Jörg Langowski, 2000).\nfunction writhe(P) {\n  let w = 0;\n  const r = S12, n = N12;\n  for (let i = 0; i \u003c M; i++) {\n    const a = i * 3, b = ((i + 1) % M) * 3, fx = P[b] - P[a], fy = P[b + 1] - P[a + 1], fz = P[b + 2] - P[a + 2];\n    for (let j = i + 2; j \u003c M; j++) {\n      if (i === 0 && j === M - 1) continue;\n      const c = j * 3, d = ((j + 1) % M) * 3;\n      // r13, r14, r24, r23: from the ends of segment i to those of j.\n      (r[0] = P[c] - P[a]), (r[1] = P[c + 1] - P[a + 1]), (r[2] = P[c + 2] - P[a + 2]);\n      (r[3] = P[d] - P[a]), (r[4] = P[d + 1] - P[a + 1]), (r[5] = P[d + 2] - P[a + 2]);\n      (r[6] = P[d] - P[b]), (r[7] = P[d + 1] - P[b + 1]), (r[8] = P[d + 2] - P[b + 2]);\n      (r[9] = P[c] - P[b]), (r[10] = P[c + 1] - P[b + 1]), (r[11] = P[c + 2] - P[b + 2]);\n      for (let k = 0; k \u003c 12; k += 3) {\n        const v = (k + 3) % 12;\n        const x = r[k + 1] * r[v + 2] - r[k + 2] * r[v + 1], y = r[k + 2] * r[v] - r[k] * r[v + 2], z = r[k] * r[v + 1] - r[k + 1] * r[v];\n        const l = sqrt(x * x + y * y + z * z) || 1;\n        (n[k] = x / l), (n[k + 1] = y / l), (n[k + 2] = z / l);\n      }\n      let om = 0;\n      for (let k = 0; k \u003c 12; k += 3) {\n        const v = (k + 3) % 12;\n        om += asin(cl(n[k] * n[v] + n[k + 1] * n[v + 1] + n[k + 2] * n[v + 2], -1, 1));\n      }\n      // The sign: (r34 x r12) . r13.\n      const ex = P[d] - P[c], ey = P[d + 1] - P[c + 1], ez = P[d + 2] - P[c + 2];\n      const sg = (ey * fz - ez * fy) * r[0] + (ez * fx - ex * fz) * r[1] + (ex * fy - ey * fx) * r[2];\n      w += sg > 0 ? om : sg \u003c 0 ? -om : 0;\n    }\n  }\n  return (2 * w) / (4 * PI);\n}\nconst S12 = new Float64Array(12), N12 = new Float64Array(12);\n\n// Rotate v (at o in V) about the unit axis that turns t0 into t1, by the\n// angle between them: parallel transport along the polygon, which adds no\n// twist. Writes into out at p.\nfunction transport(V, o, t0, t1, out, p) {\n  const ax = t0[1] * t1[2] - t0[2] * t1[1], ay = t0[2] * t1[0] - t0[0] * t1[2], az = t0[0] * t1[1] - t0[1] * t1[0];\n  const s = hypot(ax, ay, az), c = t0[0] * t1[0] + t0[1] * t1[1] + t0[2] * t1[2];\n  const vx = V[o], vy = V[o + 1], vz = V[o + 2];\n  if (s \u003c 1e-12) {\n    (out[p] = vx), (out[p + 1] = vy), (out[p + 2] = vz);\n    return;\n  }\n  const kx = ax / s, ky = ay / s, kz = az / s, kd = (kx * vx + ky * vy + kz * vz) * (1 - c);\n  out[p] = vx * c + (ky * vz - kz * vy) * s + kx * kd;\n  out[p + 1] = vy * c + (kz * vx - kx * vz) * s + ky * kd;\n  out[p + 2] = vz * c + (kx * vy - ky * vx) * s + kz * kd;\n}\n\n// The ribbon. Tangents at the points, a parallel-transported normal P1\n// round the loop, and its holonomy phi: how far P1 has turned about the\n// tangent when it comes back to the start. A closed ribbon turns about the\n// curve a whole number of times relative to P1 less phi / 2 pi, so its\n// twist is m - phi / 2 pi. The twist is spread evenly, as in an elastic rod\n// at rest, and m is the whole number that makes the two edges link Lk\n// times: by the theorem the one that brings Tw + Wr nearest Lk. Tw is then\n// measured off the built ribbon, angle by angle. Over whole cycles at every\n// Lk with Coil 3, 4.5 and 6, the Gauss linking integral of the two edges\n// came out Lk exactly each time, and Tw + Wr stayed within 0.005 of it.\nfunction ribbon(S) {\n  const { P, T, U, P1 } = S, t0 = [0, 0, 0], t1 = [0, 0, 0], tmp = [0, 0, 0];\n  for (let i = 0; i \u003c M; i++) {\n    const a = ((i + M - 1) % M) * 3, b = ((i + 1) % M) * 3, o = i * 3;\n    const x = P[b] - P[a], y = P[b + 1] - P[a + 1], z = P[b + 2] - P[a + 2], l = hypot(x, y, z) || 1;\n    T[o] = x / l;\n    T[o + 1] = y / l;\n    T[o + 2] = z / l;\n  }\n  // Start P1 pointing into the loop, square to the tangent.\n  {\n    const d = -(P[0] * T[0] + P[1] * T[1] + P[2] * T[2]);\n    let x = -P[0] + d * T[0], y = -P[1] + d * T[1], z = -P[2] + d * T[2];\n    const l = hypot(x, y, z) || 1;\n    (P1[0] = x / l), (P1[1] = y / l), (P1[2] = z / l);\n  }\n  const tv = (o, out) => ((out[0] = T[o]), (out[1] = T[o + 1]), (out[2] = T[o + 2]));\n  for (let i = 1; i \u003c= M; i++) {\n    tv((i - 1) * 3, t0);\n    tv((i % M) * 3, t1);\n    if (i \u003c M) transport(P1, (i - 1) * 3, t0, t1, P1, i * 3);\n    else transport(P1, (M - 1) * 3, t0, t1, tmp, 0);\n  }\n  // tmp is P1 carried once round; phi is its angle from P1 at the start.\n  const p2x = T[1] * P1[2] - T[2] * P1[1], p2y = T[2] * P1[0] - T[0] * P1[2], p2z = T[0] * P1[1] - T[1] * P1[0];\n  S.phi = atan2(tmp[0] * p2x + tmp[1] * p2y + tmp[2] * p2z, tmp[0] * P1[0] + tmp[1] * P1[1] + tmp[2] * P1[2]);\n  const m = round(S.lk - S.wr + S.phi / TAU), tw = m - S.phi / TAU;\n  for (let i = 0; i \u003c M; i++) {\n    const o = i * 3, th = (TAU * tw * i) / M, c = cos(th), s = sin(th);\n    const qx = T[o + 1] * P1[o + 2] - T[o + 2] * P1[o + 1], qy = T[o + 2] * P1[o] - T[o] * P1[o + 2], qz = T[o] * P1[o + 1] - T[o + 1] * P1[o];\n    U[o] = c * P1[o] + s * qx;\n    U[o + 1] = c * P1[o + 1] + s * qy;\n    U[o + 2] = c * P1[o + 2] + s * qz;\n  }\n  // The twist of the ribbon as built: each U carried to the next point,\n  // and the angle it is then short of that point's U, about the tangent.\n  let sum = 0;\n  for (let i = 0; i \u003c M; i++) {\n    const j = ((i + 1) % M) * 3;\n    tv(i * 3, t0);\n    tv(j, t1);\n    transport(U, i * 3, t0, t1, tmp, 0);\n    const wx = t1[1] * tmp[2] - t1[2] * tmp[1], wy = t1[2] * tmp[0] - t1[0] * tmp[2], wz = t1[0] * tmp[1] - t1[1] * tmp[0];\n    sum += atan2(U[j] * wx + U[j + 1] * wy + U[j + 2] * wz, U[j] * tmp[0] + U[j + 1] * tmp[1] + U[j + 2] * tmp[2]);\n  }\n  S.tw = sum / TAU;\n}\n\n// The q whose writhe is w, from the table.\nfunction qFor(w) {\n  if (w \u003c= 0) return 0;\n  for (let k = 1; k \u003c WR_OF_Q.length; k++)\n    if (WR_OF_Q[k] >= w) return 0.5 * (k - 1 + (w - WR_OF_Q[k - 1]) / (WR_OF_Q[k] - WR_OF_Q[k - 1]));\n  return 9;\n}\n\nconst ease = (x) => x * x * (3 - 2 * x);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 3, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.lk = cl(round(kv[2]), 3, 6);\n  S.coil = cl(kv[3], 3, 6);\n  S.t = (S.t + (d * S.speed) / 2) % CYCLE;\n  const t = S.t;\n  const g = t \u003c FLAT ? 0 : t \u003c FLAT + UP ? ease((t - FLAT) / UP) : t \u003c FLAT + UP + HOLD ? 1 : ease(1 - (t - FLAT - UP - HOLD) / DOWN);\n  S.q = qFor(S.coil * g);\n  shape(S, S.q);\n  S.wr = writhe(S.P);\n  ribbon(S);\n  // The view turns half a turn a cycle, slowly while the loop is flat so it\n  // is seen at a slant (it would not fit the panel face on), faster while\n  // it is coiled.\n  const ph = t / CYCLE;\n  S.yaw = (2.1 + PI * ph - 0.44 * sin(TAU * ph)) % TAU;\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  hsv(wheel(0.65 + h), 0.75, 1, P, 0); // front face\n  hsv(wheel(0.86 + h), 0.8, 0.7, P, 3); // back face\n  hsv(wheel(1.05 + h), 0.6, 1, P, 6); // edge one\n  hsv(wheel(0.26 + h), 0.7, 1, P, 9); // edge two\n  hsv(wheel(0.65 + h), 0.6, 1, P, 12); // Tw bar, the front face's colour\n  hsv(wheel(0.1 + h), 0.12, 0.95, P, 15); // Wr bar\n  S.palHue = S.hue;\n}\n\n// Fill a triangle with depth test, at LED centres.\nfunction tri(S, x0, y0, z0, x1, y1, z1, x2, y2, z2, r, g, b) {\n  const area = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(area) \u003c 1e-6) return;\n  const { zb, rgb } = S;\n  const xa = max(0, floor(min(x0, x1, x2))), xb = min(W - 1, floor(max(x0, x1, x2)));\n  const ya = max(0, floor(min(y0, y1, y2))), yb = min(H - 1, floor(max(y0, y1, y2)));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const w0 = ((x1 - px) * (y2 - py) - (x2 - px) * (y1 - py)) / area;\n      const w1 = ((x2 - px) * (y0 - py) - (x0 - px) * (y2 - py)) / area;\n      const w2 = 1 - w0 - w1;\n      if (w0 \u003c -1e-4 || w1 \u003c -1e-4 || w2 \u003c -1e-4) continue;\n      const z = w0 * z0 + w1 * z1 + w2 * z2, p = y * W + x;\n      if (z \u003c= zb[p]) continue;\n      zb[p] = z;\n      (rgb[p * 3] = r), (rgb[p * 3 + 1] = g), (rgb[p * 3 + 2] = b);\n    }\n}\n\n// Nearer is brighter.\nconst shadeOf = (z) => 0.5 + 0.5 * cl((z + 46) / 92, 0, 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { P, U, T, sx, sy, sz, face, zb, rgb } = S, C = S.pal;\n  zb.fill(-1e9);\n  rgb.fill(0);\n  const cy = cos(S.yaw), sy0 = sin(S.yaw), el = 0.3, ce = cos(el), se = sin(el);\n  // Project: turn about the vertical, tip the top away by el, look along +y.\n  // k = 0 the edge at +HW U, k = 1 the one at -HW U.\n  const proj = (x, y, z, o) => {\n    const x1 = x * cy - y * sy0, y1 = x * sy0 + y * cy;\n    const y2 = y1 * ce + z * se, z2 = z * ce - y1 * se;\n    sx[o] = CX + x1;\n    sy[o] = CY - z2;\n    sz[o] = -y2;\n  };\n  for (let i = 0; i \u003c M; i++) {\n    const o = i * 3;\n    for (let k = 0; k \u003c 2; k++) {\n      const s = k ? -HW : HW;\n      proj(P[o] + s * U[o], P[o + 1] + s * U[o + 1], P[o + 2] + s * U[o + 2], i * 2 + k);\n    }\n    // Which face looks at us: the normal T x U against the view.\n    const nx = T[o + 1] * U[o + 2] - T[o + 2] * U[o + 1], ny = T[o + 2] * U[o] - T[o] * U[o + 2], nz = T[o] * U[o + 1] - T[o + 1] * U[o];\n    const y1 = nx * sy0 + ny * cy;\n    face[i] = -(y1 * ce + nz * se);\n  }\n  // Faces, as two triangles a segment.\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M, a = i * 2, b = j * 2, f = (face[i] + face[j]) / 2;\n    const o = f >= 0 ? 0 : 3, lit = (0.35 + 0.65 * min(1, abs(f) * 1.4)) * shadeOf((sz[a] + sz[b] + sz[a + 1] + sz[b + 1]) / 4);\n    const r = C[o] * lit, g = C[o + 1] * lit, bl = C[o + 2] * lit;\n    tri(S, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], sx[b + 1], sy[b + 1], sz[b + 1], r, g, bl);\n    tri(S, sx[a], sy[a], sz[a], sx[b + 1], sy[b + 1], sz[b + 1], sx[a + 1], sy[a + 1], sz[a + 1], r, g, bl);\n  }\n  // The two edges, a line each, a little in front of the faces they bound.\n  for (let k = 0; k \u003c 2; k++) {\n    const o = 6 + k * 3;\n    for (let i = 0; i \u003c M; i++) {\n      const a = i * 2 + k, b = ((i + 1) % M) * 2 + k, n = Math.ceil(hypot(sx[b] - sx[a], sy[b] - sy[a]) * 2.5) || 1;\n      for (let e = 0; e \u003c n; e++) {\n        const u = e / n, x = sx[a] + (sx[b] - sx[a]) * u, y = sy[a] + (sy[b] - sy[a]) * u, z = sz[a] + (sz[b] - sz[a]) * u + 1.5;\n        const ix = floor(x), iy = floor(y);\n        if (ix \u003c 0 || ix >= W || iy \u003c 0 || iy >= H) continue;\n        const p = iy * W + ix;\n        if (z \u003c zb[p]) continue;\n        zb[p] = z;\n        const l = 0.25 + 0.75 * shadeOf(z);\n        (rgb[p * 3] = C[o] * l), (rgb[p * 3 + 1] = C[o + 1] * l), (rgb[p * 3 + 2] = C[o + 2] * l);\n      }\n    }\n  }\n  // The bar: Wr from 0, then Tw from where Wr ends, which always stops at\n  // the mark at Lk. A negative Tw runs back from Wr to Lk, striped.\n  const X0 = 6, UNIT = 8, row = (y, a, b, o, stripe) => {\n    const lo = min(a, b), hi = max(a, b);\n    for (let x = floor(X0 + lo * UNIT); x \u003c X0 + hi * UNIT; x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const cover = min(1, x + 1 - (X0 + lo * UNIT), X0 + hi * UNIT - x);\n      if (cover \u003c= 0) continue;\n      const l = cover * (stripe && (x & 1) ? 0.45 : 1);\n      for (let e = 0; e \u003c 3; e++) rgb[(y * W + x) * 3 + e] = C[o + e] * l;\n    }\n  };\n  for (const y of [119, 120]) row(y, 0, S.wr, 15, false);\n  for (const y of [122, 123]) row(y, S.wr, S.wr + S.tw, 12, S.tw \u003c 0);\n  for (let v = 0; v \u003c= 7; v++) {\n    const x = X0 + v * UNIT;\n    if (x >= W) break;\n    rgb[(125 * W + x) * 3] = rgb[(125 * W + x) * 3 + 1] = rgb[(125 * W + x) * 3 + 2] = 0.3;\n  }\n  // The mark at Lk in the two edges' colours: it counts how often they link.\n  const lx = X0 + S.lk * UNIT;\n  for (let y = 118; y \u003c= 126; y++) {\n    const o = y \u003c 122 ? 6 : 9;\n    for (let e = 0; e \u003c 3; e++) rgb[(y * W + lx) * 3 + e] = C[o + e];\n  }\n  for (let p = 0; p \u003c NPX; p++) display.setPixel(p % W, (p / W) | 0, (255 * min(1, rgb[p * 3])) | 0, (255 * min(1, rgb[p * 3 + 1])) | 0, (255 * min(1, rgb[p * 3 + 2])) | 0);\n}\n","buffon-noodle":"// ===== Patternflow pattern =====\n// Title:   Buffon's Noodle\n// Family:  data\n// Idea:    Needles drop one after another onto a floor of lines 16 LEDs apart, warm where they cross a line and cool where they miss, with a white tick on the line at every crossing, while the count of crossings against the length dropped estimates pi below, and bending every needle into an arc of the same length leaves the average alone until, as a closed circle 16 LEDs across, each one crosses exactly twice and the estimate stops wobbling on pi.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Buffon's needle (Georges-Louis Leclerc, Comte de Buffon, 1777) and Barbier's noodle (Joseph-Emile Barbier, 1860), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Length=0.2..1, Bend=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the needles that cross a line are gold and those that miss are azure; at 0.25 green and magenta, at 0.5 blue and orange. The floor lines stay slate.\n// Knob 2: Speed. Needles a second, five times the knob: 10 at 2, 1 at 0.2, 15 at 3. A needle lies about 4 seconds at 2 and longer when the drops are slower, so at Length 0.2 the floor holds about 40 needles at 2 and 13 at 0.2. The first 12 fall in the first half second whatever the knob says.\n// Knob 3: Length. The needle's length as a share of pi times the line spacing: 0.2 opens on needles 10 LEDs long that cross 0.4 lines on average, 0.5 on 25 LEDs crossing 1, and 1 on 50 LEDs crossing 2. Longer needles leave sooner, about 2 seconds at 1, so the floor carries about the same ink. The estimate is 2 x (length dropped) / (16 x crossings), so any length gives pi on average.\n// Knob 4: Bend. Bends each new needle into a circular arc of the same length, turning through Bend x 360 degrees: 0.06 is a needle bowed by 22 degrees, 0.5 a half circle, 1 a closed ring. The average count never changes. At Length 1 and Bend 1 the ring is 16 LEDs across, crosses exactly two lines every time, and the error bars of the trace fall flat onto the pi line.\n// Buttons: K1 tap starts the count again. It also starts again by itself half a second after Length or Bend comes to rest at a new value.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Line spacing, the floor's last row, and line k's height: the centre of\n// row 16k, so rows 0, 16, ... 96 carry the lines.\nconst D = 16, FLOOR = 96, Y0 = 0.5;\n// The trace: one column per drop, the newest on the right, beside a pi\n// sign; the windowed estimate is over the last WIN drops.\nconst TX = 7, HIST = W - TX, WIN = 24, TMID = 116, TAMP = 10;\n// Hue of the crossing needles at knob 0 (gold), and the missing ones\n// opposite it on the wheel.\nconst HUE0 = 0.13;\n\n// 3 x 5 digits, row by row from the top, three bits a row.\nconst FONT = {\n  0: 0b111101101101111, 1: 0b010110010010111, 2: 0b111001111100111, 3: 0b111001111001111,\n  4: 0b101101111001001, 5: 0b111100111001111, 6: 0b111100111101111, 7: 0b111001001001001,\n  8: 0b111101111101111, 9: 0b111101111001111, \"-\": 0b000000111000000,\n};\n// A pi sign, five bits a row.\nconst PI_SIGN = [0b11111, 0b01010, 0b01010, 0b01010, 0b10011];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, acc: 0, acc0: 0, burst: 12, needles: [], epoch: 0,\n    hue: 0, speed: 2, share: 0.2, bend: 0.06, ref: null, settle: 0,\n    // Since the last start: drops, length dropped and crossings.\n    n: 0, sumL: 0, sumC: 0,\n    winL: new Float64Array(WIN), winC: new Float64Array(WIN), wi: 0, wn: 0,\n    // The trace, oldest first: the running estimate, the windowed one, and\n    // a mark where the count started again.\n    cum: new Float64Array(HIST).fill(NaN), win: new Float64Array(HIST).fill(NaN), mark: new Uint8Array(HIST),\n    rgb: new Float32Array(W * H * 3), warm: [0, 0, 0], cool: [0, 0, 0],\n  };\n}\n\n// The noodle's shape. It is a circular arc of length L turning through th,\n// placed by its centroid G and the direction a from the arc's centre to\n// its midpoint; the arc's centre sits c behind G. For th near 0 it is the\n// straight needle through G, square to a. A point s along the arc (from\n// -L/2 to L/2) lies at G + (R cos(s/R) - c) u + R sin(s/R) v, with u the\n// direction a and v a quarter turn on.\nfunction shape(L, th) {\n  if (th \u003c 1e-3) return { R: 0, c: 0 };\n  const R = L / th;\n  return { R, c: (R * sin(th / 2)) / (th / 2) };\n}\nfunction rel(nd, s, o) {\n  const ca = cos(nd.a), sa = sin(nd.a);\n  let pu, pv;\n  if (nd.R === 0) (pu = 0), (pv = s);\n  else (pu = nd.R * cos(s / nd.R) - nd.c), (pv = nd.R * sin(s / nd.R));\n  o[0] = pu * ca - pv * sa;\n  o[1] = pu * sa + pv * ca;\n}\n\n// Every crossing of the noodle with the lines y = 16k + 0.5, all of them,\n// not just the ones on the panel, as positions s along it. Exact: a\n// straight needle meets a line at one s, a circle at the two angles whose\n// sine puts it on the line, kept when they fall inside the arc.\nfunction crossings(nd) {\n  const out = [], L = nd.L, k0 = Math.ceil((nd.gy - L - Y0) / D), k1 = floor((nd.gy + L - Y0) / D);\n  const ca = cos(nd.a), sa = sin(nd.a);\n  for (let k = k0; k \u003c= k1; k++) {\n    const y = D * k + Y0;\n    if (nd.R === 0) {\n      // y(s) = gy + s cos a\n      if (abs(ca) \u003c 1e-12) continue;\n      const s = (y - nd.gy) / ca;\n      if (abs(s) \u003c L / 2) out.push(s);\n    } else {\n      const oy = nd.gy - nd.c * sa, v = (y - oy) / nd.R;\n      if (abs(v) >= 1) continue;\n      const b = asin(v);\n      for (const beta of [b, PI - b]) {\n        const d = (((beta - (nd.a - nd.th / 2)) % TAU) + TAU) % TAU;\n        if (d \u003c nd.th) out.push((d - nd.th / 2) * nd.R);\n      }\n    }\n  }\n  return out;\n}\n\nfunction drop(S, fall) {\n  const R = Math.random;\n  // Four draws a drop whatever the knobs, so drop i lands in the same place\n  // at every Length and Bend and only its shape differs.\n  const gx = 2 + 60 * R(), gy = Y0 + FLOOR * R(), a = TAU * R(), spin = (R() \u003c 0.5 ? -1 : 1) * (1.5 + 2 * R());\n  const L = S.share * PI * D, th = S.bend * TAU, sh = shape(L, th);\n  const nd = { gx, gy, a, spin, L, th, R: sh.R, c: sh.c, age: 0, fall, landed: false, epoch: S.epoch };\n  nd.cross = crossings(nd);\n  S.needles.push(nd);\n}\n\nfunction land(S, nd) {\n  nd.landed = true;\n  // Long needles go sooner, so the floor holds about as much ink at any\n  // Length: about 4 seconds at Speed 2 and Length 0.2, 2 at Length 1.\n  nd.life = 4 * sqrt(2 / S.speed) * (0.2 / (nd.L / (PI * D))) ** 0.4;\n  if (nd.epoch !== S.epoch) return;\n  const C = nd.cross.length;\n  S.n++;\n  S.sumL += nd.L;\n  S.sumC += C;\n  S.winL[S.wi] = nd.L;\n  S.winC[S.wi] = C;\n  S.wi = (S.wi + 1) % WIN;\n  S.wn = min(WIN, S.wn + 1);\n  let wl = 0, wc = 0;\n  for (let i = 0; i \u003c S.wn; i++) (wl += S.winL[i]), (wc += S.winC[i]);\n  S.cum.copyWithin(0, 1);\n  S.win.copyWithin(0, 1);\n  S.mark.copyWithin(0, 1);\n  S.cum[HIST - 1] = S.sumC ? (2 * S.sumL) / (D * S.sumC) : Infinity;\n  S.win[HIST - 1] = wc ? (2 * wl) / (D * wc) : Infinity;\n  S.mark[HIST - 1] = S.n === 1 ? 1 : 0;\n}\n\nfunction restart(S) {\n  S.epoch++;\n  S.n = S.sumL = S.sumC = 0;\n  S.wi = S.wn = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.share = cl(kv[2], 0.2, 1);\n  S.bend = cl(kv[3], 0, 1);\n  // A new Length or Bend starts the count again once the knob rests, so the\n  // readout is about the noodle on the floor.\n  if (!S.ref) S.ref = [S.share, S.bend];\n  if (abs(S.share - S.ref[0]) > 0.004 || abs(S.bend - S.ref[1]) > 0.004) (S.ref = [S.share, S.bend]), (S.settle = 0.5);\n  if (S.settle > 0 && (S.settle -= d) \u003c= 0) restart(S);\n  if (input.btnPressed && input.btnPressed[0]) restart(S);\n  S.t += d;\n  const fall = 0.32 * cl(2 / S.speed, 0.7, 2);\n  // The first dozen fall in half a second, so the floor is never bare.\n  if (S.burst > 0) {\n    S.acc0 += d * 24;\n    while (S.acc0 >= 1 && S.burst > 0) S.acc0--, S.burst--, drop(S, 0.3);\n  } else {\n    S.acc += d * 5 * S.speed;\n    while (S.acc >= 1) S.acc--, drop(S, fall);\n  }\n  for (const nd of S.needles) {\n    nd.age += d;\n    if (!nd.landed && nd.age >= nd.fall) land(S, nd);\n  }\n  S.needles = S.needles.filter((nd) => !nd.landed || nd.age \u003c nd.fall + nd.life);\n}\n\n// Lines are laid as points every third of an LED, each lighting its four\n// nearest LEDs by how close it falls, and an LED keeps the brightest\n// colour laid on it, so a heap of needles never washes out to white.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy > FLOOR) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.8) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\nfunction put(S, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  S.rgb[p] = max(S.rgb[p], c[0] * a);\n  S.rgb[p + 1] = max(S.rgb[p + 1], c[1] * a);\n  S.rgb[p + 2] = max(S.rgb[p + 2], c[2] * a);\n}\nfunction text(S, str, x, y, colOf) {\n  for (let i = 0; i \u003c str.length; i++) {\n    const ch = str[i];\n    if (ch === \".\") {\n      put(S, x, y + 4, colOf(i), 1);\n      x += 2;\n      continue;\n    }\n    const g = FONT[ch];\n    if (g === undefined) {\n      x += 4;\n      continue;\n    }\n    for (let r = 0; r \u003c 5; r++) for (let b = 0; b \u003c 3; b++) if ((g >> (14 - r * 3 - b)) & 1) put(S, x + b, y + r, colOf(i), 1);\n    x += 4;\n  }\n}\n// Error to trace rows: about 1.7 rows for 0.05, 5 for 0.25, never past 10.\nconst errRows = (e) => (e === Infinity ? TAMP : (TAMP * e) / (abs(e) + 0.25));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb } = S;\n  rgb.fill(0);\n  const warm = hsv(HUE0 + S.hue, 0.8, 1, S.warm), cool = hsv(HUE0 + 0.45 + S.hue, 0.75, 1, S.cool);\n  // The floor lines are slate whatever the hue: a tinted grey would turn\n  // brown wherever the wheel puts orange.\n  const slate = [0.24, 0.28, 0.34];\n  for (let y = 0; y \u003c= FLOOR; y += D) for (let x = 0; x \u003c W; x++) put(S, x, y, slate, 1);\n  const o = [0, 0], white = [1, 1, 1];\n  // Falling needles first, so landed ones lie over them.\n  const order = S.needles.slice().sort((p, q) => (p.landed === q.landed ? 0 : p.landed ? 1 : -1));\n  for (const nd of order) {\n    let k = 1, rot = 0, keep = 1, dash = 0;\n    const c = nd.cross.length ? warm : cool;\n    let tint = c;\n    if (!nd.landed) {\n      // Falling: drawn dashed, larger and turning, as if seen from above,\n      // settling on its spot as it lands. The colour stays at full\n      // strength, since a dimmed gold reads brown on the panel.\n      const u = nd.age / nd.fall, e = (1 - u) * (1 - u);\n      k = 1 + 0.9 * e;\n      rot = nd.spin * e;\n      dash = 1.5;\n    } else {\n      const age = nd.age - nd.fall, left = nd.life - age;\n      // A white flash on landing, and at the end the needle draws in from\n      // both ends to its middle instead of going dark.\n      const fl = max(0, 1 - age / 0.25);\n      tint = [c[0] + (1 - c[0]) * fl, c[1] + (1 - c[1]) * fl, c[2] + (1 - c[2]) * fl];\n      keep = cl(left / 0.6, 0, 1);\n    }\n    const cr = cos(rot), sr = sin(rot), half = (nd.L / 2) * keep, n = Math.ceil(nd.L * keep * k * 3) + 1;\n    for (let i = 0; i \u003c= n; i++) {\n      const s = -half + (2 * half * i) / n;\n      if (dash && floor((k * (s + half)) / dash) % 2) continue;\n      rel(nd, s, o);\n      plot(S, nd.gx + k * (o[0] * cr - o[1] * sr), nd.gy + k * (o[0] * sr + o[1] * cr), tint, 1);\n    }\n  }\n  // The crossings: a white dash on the line where each one meets it, wide\n  // on landing and narrowing to three LEDs.\n  for (const nd of S.needles) {\n    if (!nd.landed) continue;\n    const age = nd.age - nd.fall, keep = cl((nd.life - age) / 0.6, 0, 1);\n    for (const s of nd.cross) {\n      if (abs(s) > (nd.L / 2) * keep) continue;\n      rel(nd, s, o);\n      const x = floor(nd.gx + o[0]), y = floor(nd.gy + o[1]);\n      if (y > FLOOR) continue;\n      const arm = 1 + max(0, 3 * (1 - age / 0.4));\n      for (let dx = -3; dx \u003c= 3; dx++) put(S, x + dx, y, white, cl(arm + 0.5 - abs(dx), 0, 1));\n      if (age \u003c 0.3) put(S, x, y - 1, white, 1 - age / 0.3), put(S, x, y + 1, white, 1 - age / 0.3);\n    }\n  }\n\n  // The readout. The running estimate to four places: the digits that agree\n  // with pi in white, the rest cool when it is too high (too few crossings)\n  // and warm when too low. The drop count on the right.\n  const est = S.sumC ? (2 * S.sumL) / (D * S.sumC) : Infinity;\n  const str = est \u003c 10 ? est.toFixed(4) : \"-.----\", ref = PI.toFixed(4);\n  let agree = 0;\n  while (agree \u003c str.length && str[agree] === ref[agree]) agree++;\n  const over = est > PI;\n  text(S, str, 1, 99, (i) => (i \u003c agree ? white : over ? cool : warm));\n  const ns = String(min(S.n, 99999));\n  text(S, ns, W - 4 * ns.length, 99, () => slate.map((v) => v * 2));\n  // The pi line, dotted, with its sign.\n  for (let x = TX; x \u003c W; x += 2) put(S, x, TMID, white, 0.35);\n  for (let r = 0; r \u003c 5; r++) for (let b = 0; b \u003c 5; b++) if ((PI_SIGN[r] >> (4 - b)) & 1) put(S, 1 + b, TMID - 2 + r, white, 0.8);\n  // Each drop's column: a bar from the pi line to the estimate over the last\n  // 24 drops, and a white line through the running estimate.\n  let prev = NaN;\n  for (let i = 0; i \u003c HIST; i++) {\n    const x = TX + i, wv = S.win[i], cv = S.cum[i];\n    if (S.mark[i]) for (let y = TMID - TAMP; y \u003c= TMID + TAMP; y++) put(S, x, y, slate, 1.6);\n    if (!Number.isNaN(wv)) {\n      // Its body is a checkerboard at full strength rather than a dim fill,\n      // which would turn the gold brown.\n      const r = errRows(wv - PI), c = r \u003c 0 ? warm : cool, top = Math.round(r);\n      for (let j = 1; j \u003c= abs(top); j++) if (j === abs(top) || (j + x) % 2 === 0) put(S, x, TMID - Math.sign(top) * j, c, 1);\n    }\n    if (!Number.isNaN(cv)) {\n      const y = TMID - errRows(cv - PI);\n      if (!Number.isNaN(prev)) {\n        const lo = min(prev, y), hi = max(prev, y);\n        for (let yy = Math.round(lo); yy \u003c= Math.round(hi); yy++) put(S, x, yy, white, 0.95);\n      } else put(S, x, Math.round(y), white, 0.95);\n      prev = y;\n    } else prev = NaN;\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","burrows-wheeler":"// ===== Patternflow pattern =====\n// Title:   Burrows-Wheeler\n// Family:  algo\n// Idea:    The 128 rotations of a text stand as 128 rows of coloured letters and glide into sorted order, so the last column at the right edge gathers into runs; then the rows fade to their first and last letters and come back one at a time as the LF walk rebuilds them from the last column alone.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Burrows-Wheeler transform (Michael Burrows and David Wheeler, 1994), with its perfect clustering on Sturmian words (Sabrina Mantaci, Antonio Restivo and Marinella Sciortino, 2003) and on interval exchange words (Sebastien Ferenczi and Luca Zamboni, 2013), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=0..3, Letters=2..6\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the first letter is bright gold and the last a dim violet at a sixth of its brightness, with green, cyan and blue between them when there are more letters. The run marks, the walk and the mark beside the text's own row are white.\n// Knob 2: Speed. At 2 one text takes 6.6 seconds: 0.4 in rotation order, 1 gliding into sorted order, 1.2 sorted, 1.2 with the shared prefixes lit, 0.3 fading to the first and last columns, 2 for the LF walk at 64 rows a second, and 0.5 for a last look. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Order. How much structure the text has. At 0 every letter is drawn at random; with 2 letters the last column breaks into 64 runs on average and a row needs 8 letters to tell it from its neighbours. At 1 each letter follows a fixed rule on the two before it four times in five, and at 2 the text strings together copies of three short words; for 2 letters both bring the last column down to 25 to 28 runs, and the rows need 17 or 18 letters. At 3 the text is perfectly clustering and the last column is one run per letter in falling order: for 2 letters a Sturmian word, the first one of slope 49/128 next to the Fibonacci word's 0.382, and for more letters the coding of an interval exchange that turns the order of its intervals round. 95% of the rows of the Sturmian word share all 53 letters on the panel with a neighbour.\n// Knob 4: Letters. The size of the alphabet, 2 to 6. Each letter is a step dimmer than the one before, from full brightness down to a sixth of it, so two different letters side by side always differ in brightness as well as colour.\n\nconst W = 64, H = 128, N = 128;\nconst { floor, round, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The first letter of each rotation stands 3 LEDs wide at the left edge\n// and the last 5 wide at the right, the two columns the transform keeps.\n// Between them the next 52 letters, and a gutter for the run marks.\nconst FW = 3, BX = 4, MC = 52, GX = 56, LX = 59;\n// Hue of the first letter at knob 0, and how far round the wheel the\n// alphabet spreads.\nconst HUE0 = 0.13, SPREAD = 0.7;\n// The phases of one text, in seconds at Speed 2: rotation order, the glide,\n// the sorted hold, the shared prefixes, the fade to the first and last\n// columns, the LF walk, and a last look at the whole sorted matrix.\nconst PH = [0.4, 1.0, 1.2, 1.2, 0.3, 2.0, 0.5];\nconst END = PH.reduce((a, b) => a + b, 0);\nconst at = (k) => PH.slice(0, k).reduce((a, b) => a + b, 0);\n// A letter whose row is not known yet is drawn on every other LED of a\n// checkerboard, at this brightness.\nconst GHOST = 0.75;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst rnd = (k) => floor(Math.random() * k);\n\n// The coding of a discrete interval exchange with the order of its\n// intervals turned round: point x in interval k moves to x - s_k + t_k, with\n// t_k the length of the intervals after k. When the map is one cycle of all\n// 128 points, its coding is perfectly clustering: the last column of the\n// sorted rotations is the letters in falling order, one run each.\nfunction exchange(lens) {\n  const m = lens.length, s = [], t = [];\n  let acc = 0;\n  for (let k = 0; k \u003c m; k++) s.push(acc), (acc += lens[k]);\n  for (let k = 0; k \u003c m; k++) t.push(N - s[k] - lens[k]);\n  const lab = (x) => {\n    let k = m - 1;\n    while (x \u003c s[k]) k--;\n    return k;\n  };\n  const w = new Uint8Array(N);\n  let x = rnd(N), c = 0;\n  const x0 = x;\n  do {\n    const k = lab(x);\n    w[c++] = k;\n    x = x - s[k] + t[k];\n  } while (x !== x0 && c \u003c N);\n  return c === N ? w : null;\n}\n\n// Two letters open on the Sturmian word of slope 49/128, the nearest to the\n// Fibonacci word's 1/phi^2 that 128 allows; later texts cut 128 at random.\nfunction clustering(m, first) {\n  if (m === 2 && first) return exchange([79, 49]);\n  for (;;) {\n    // Cut 128 into m pieces of at least 8.\n    const cuts = [];\n    while (cuts.length \u003c m - 1) {\n      const c = 8 + rnd(N - 15);\n      if (cuts.every((d) => abs(d - c) >= 8)) cuts.push(c);\n    }\n    cuts.sort((a, b) => a - b);\n    const lens = [];\n    let prev = 0;\n    for (const c of cuts) lens.push(c - prev), (prev = c);\n    lens.push(N - prev);\n    if (lens[0] \u003c 8) continue;\n    const w = exchange(lens);\n    if (w) return w;\n  }\n}\n\nfunction makeText(order, m, first) {\n  const T = new Uint8Array(N);\n  if (order === 0) for (let i = 0; i \u003c N; i++) T[i] = rnd(m);\n  else if (order === 1) {\n    // Each letter follows a fixed rule on the two before it, four times in\n    // five.\n    const rule = Array.from({ length: m * m }, () => rnd(m));\n    T[0] = rnd(m);\n    T[1] = rnd(m);\n    for (let i = 2; i \u003c N; i++) T[i] = Math.random() \u003c 0.8 ? rule[T[i - 2] * m + T[i - 1]] : rnd(m);\n  } else if (order === 2) {\n    const words = Array.from({ length: 3 }, () => Array.from({ length: 5 + rnd(7) }, () => rnd(m)));\n    let i = 0;\n    while (i \u003c N) for (const c of words[rnd(3)]) if (i \u003c N) T[i++] = c;\n  } else return clustering(m, first);\n  return T;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, sp: 2, ord: -1, m: -1, tau: 0,\n    T: null, rank: new Int32Array(N), L: new Uint8Array(N), walk: new Int32Array(N),\n    keep: new Int32Array(N), seen: new Int32Array(N), rowRot: new Int32Array(H),\n    pos: new Float64Array(N), ord128: Array.from({ length: N }, (_, i) => i),\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(6 * 3), palKey: \"\",\n  };\n}\n\n// Sort the rotations, read off the last column, and take the LF walk from\n// the row that holds the text itself.\nfunction build(s, first) {\n  const T = makeText(s.ord, s.m, first);\n  s.T = T;\n  const idx = Array.from({ length: N }, (_, i) => i);\n  idx.sort((a, b) => {\n    for (let k = 0; k \u003c N; k++) {\n      const d = T[(a + k) % N] - T[(b + k) % N];\n      if (d) return d;\n    }\n    return a - b;\n  });\n  for (let r = 0; r \u003c N; r++) (s.rank[idx[r]] = r), (s.L[r] = T[(idx[r] + N - 1) % N]);\n  // LF(r): the row of the rotation one letter earlier, found from the last\n  // column alone as the count of smaller letters plus the count of the\n  // same letter above row r.\n  const C = new Int32Array(8), occ = new Int32Array(8), lf = new Int32Array(N);\n  for (let r = 0; r \u003c N; r++) C[s.L[r] + 1]++;\n  for (let c = 1; c \u003c 8; c++) C[c] += C[c - 1];\n  for (let r = 0; r \u003c N; r++) lf[r] = C[s.L[r]] + occ[s.L[r]]++;\n  let r = s.rank[0];\n  for (let k = 0; k \u003c N; k++) (s.walk[k] = r), (r = lf[r]);\n  // The prefix each sorted row shares with a neighbour, plus the letter\n  // that tells them apart.\n  const lcp = (a, b) => {\n    let k = 0;\n    while (k \u003c N && T[(a + k) % N] === T[(b + k) % N]) k++;\n    return k;\n  };\n  for (let q = 0; q \u003c N; q++) {\n    const up = q > 0 ? lcp(idx[q - 1], idx[q]) : 0, dn = q \u003c N - 1 ? lcp(idx[q], idx[q + 1]) : 0;\n    s.keep[q] = max(up, dn) + 1;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.sp = cl(kv[1], 0.2, 3);\n  const ord = round(cl(kv[2], 0, 3)), m = round(cl(kv[3], 2, 6));\n  // A turn of Order or Letters starts over at once with a new text, so the\n  // knob shows in the first sort.\n  if (ord !== s.ord || m !== s.m) {\n    s.ord = ord;\n    s.m = m;\n    s.tau = 0;\n    build(s, true);\n  }\n  s.tau += d * (s.sp / 2);\n  if (s.tau >= END) {\n    s.tau -= END;\n    build(s, false);\n  }\n}\n\nfunction palette(s) {\n  const P = s.pal, m = s.m;\n  for (let k = 0; k \u003c m; k++) {\n    const u = k / (m - 1);\n    hsv(HUE0 + s.hue + SPREAD * u, 0.7 + 0.2 * u, 1 - 0.84 * u, P, k * 3);\n  }\n  s.palKey = s.hue + \":\" + m;\n}\n\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.T) return;\n  if (s.palKey !== s.hue + \":\" + s.m) palette(s);\n  const { buf: B, pal: P, T, rank, keep, tau } = s;\n  B.fill(0);\n  const put = (x, y, o, k) => {\n    const i = (y * W + x) * 3;\n    B[i] += P[o] * k;\n    B[i + 1] += P[o + 1] * k;\n    B[i + 2] += P[o + 2] * k;\n  };\n  const white = (x, y, k) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    B[i] += k;\n    B[i + 1] += k;\n    B[i + 2] += k;\n  };\n\n  // Which rotation sits on each row: rotation i glides from row i to its\n  // sorted row, all of them at once, and the rows are dealt out in the\n  // order of where they have got to, so two rows crossing swap places\n  // and no row is ever empty.\n  const g = ease((tau - at(1)) / PH[1]), pos = s.pos, ord = s.ord128;\n  for (let i = 0; i \u003c N; i++) (pos[i] = i + (rank[i] - i) * g), (ord[i] = i);\n  ord.sort((a, b) => pos[a] - pos[b] || a - b);\n  for (let y = 0; y \u003c H; y++) s.rowRot[y] = ord[y];\n\n  // How far each sorted row stays solid. In the prefix phase the ghost\n  // sweeps in from the right and stops at the shared prefix; then it goes\n  // on to column 1, leaving the first column, which is the last column\n  // sorted. The walk makes each row it reaches solid again.\n  const pref = ease((tau - at(3)) / 0.5), drop = ease((tau - at(4)) / PH[4]);\n  const inWalk = tau >= at(5) && tau \u003c at(6);\n  const step = inWalk ? min(N - 1, floor(((tau - at(5)) / PH[5]) * N)) : -1;\n  s.seen.fill(0);\n  if (inWalk) for (let k = 0; k \u003c= step; k++) s.seen[s.walk[k]] = 1;\n  const ghostAll = tau >= at(4) && tau \u003c at(6);\n\n  for (let y = 0; y \u003c H; y++) {\n    const i = s.rowRot[y], q = rank[i];\n    // Letters 0..solid-1 are solid; letter 0 is the first column.\n    let solid = MC + 1;\n    if (tau >= at(3) && tau \u003c at(4)) solid = round(MC + 1 + (keep[q] - MC - 1) * pref);\n    if (ghostAll) solid = round(keep[q] + (1 - keep[q]) * drop);\n    if (inWalk && s.seen[q]) solid = MC + 1;\n    const fo = T[i] * 3;\n    for (let x = 0; x \u003c FW; x++) put(x, y, fo, 1);\n    for (let c = 1; c \u003c= MC; c++) {\n      const o = T[(i + c) % N] * 3, x = BX + c - 1;\n      if (c \u003c solid) put(x, y, o, 1);\n      else if (((x + y) & 1) === 0) put(x, y, o, GHOST);\n    }\n    // The letter that tells the row from its neighbours, lit white while\n    // the prefixes show, so the sorted contexts draw their own outline.\n    if (tau >= at(3) && tau \u003c at(4) && keep[q] \u003c= MC + 1) {\n      const c = keep[q] - 1;\n      if (c === 0) for (let x = 0; x \u003c FW; x++) white(x, y, 0.6 * pref);\n      else white(BX + c - 1, y, 0.6 * pref);\n    }\n    // The last letter of the rotation.\n    const lo = T[(i + N - 1) % N] * 3;\n    for (let x = LX; x \u003c W; x++) put(x, y, lo, 1);\n  }\n\n  // Run marks in the gutter, once the rows are sorted: one at the top of\n  // each run of the last column.\n  const sorted = ease((tau - at(2)) / 0.4);\n  if (sorted > 0)\n    for (let q = 1; q \u003c N; q++)\n      if (s.L[q] !== s.L[q - 1]) for (let x = GX; x \u003c LX; x++) white(x, q, 0.55 * sorted);\n\n  // The walk: the row it stands on flashes, and a line runs from its last\n  // letter to the same letter's place in the first column, the next row.\n  if (inWalk) {\n    for (let back = 0; back \u003c 3; back++) {\n      const k = step - back;\n      if (k \u003c 0 || k >= N - 1) continue;\n      const r0 = s.walk[k], r1 = s.walk[k + 1], a = (0.7 * (3 - back)) / 3;\n      if (back === 0) for (let x = BX; x \u003c GX; x++) white(x, r0, 0.35);\n      for (let x = FW; x \u003c LX; x++) white(x, round(r0 + ((r1 - r0) * (LX - 1 - x)) / (LX - 1 - FW)), a * 0.6);\n      if (back === 0) for (let x = 0; x \u003c FW; x++) white(x, r1, 0.6);\n    }\n  }\n  // The text itself: a white mark beside the row it is on.\n  const home = s.rowRot.indexOf(0);\n  if (home >= 0) for (let x = GX; x \u003c LX; x++) white(x, home, x === GX ? 1 : 0.6);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, min(255, round(B[p] * 255)), min(255, round(B[p + 1] * 255)), min(255, round(B[p + 2] * 255)));\n}\n","hex-theorem":"// ===== Patternflow pattern =====\n// Title:   Hex Theorem\n// Family:  cells\n// Idea:    A Hex board stands on its long diagonal and fills one random cell at a time until one colour's chain joins that colour's two edges and lights up with a pulse running along it; on the full board the loser's cells flood in from both of its edges and stop against the chain, and Gale's walk threads the seam between the colours from the bottom corner out to the corner that names the winner.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hex theorem (David Gale, 1979), on the game of Hex (Piet Hein, 1942; John Nash, 1948), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=7..15, Bias=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 player A, who owns the lower right and upper left edges, is azure and player B, who owns the other two, is magenta, on dark slate empty cells; a winning chain brightens, its shortest path runs near white, and the loser's two floods take two pale tints of its colour. At 0.25 A is violet and B lime, at 0.5 A rose and B teal, at 0.75 A green and B blue. The wheel skips the stretch from orange to yellow, which reads brown and olive on the dim cells.\n// Knob 2: Speed. At 2 a 7 x 7 board fills at 18 cells a second and is full in 2.7 s; a 15 x 15 board fills at 57 a second and is full in 4 s. The win holds the filling for 0.45 s, then the proof takes 1.9 s, the hold 1.3 s and the clearing wave 0.9 s, so a 7 x 7 board turns over every 7.3 s. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Size. The board's side, 7 to 15 cells. Cells are about 8 LEDs across at 7 and 4 at 15, stood 18 to 21% taller than regular so the long diagonal runs 116 rows. At even odds the first chain shows when 86% of a 7 x 7 board is filled (median of 2,000 boards) and 91% of a 15 x 15 board, and Gale's walk is 32 and 110 edges long.\n// Knob 4: Bias. Each cell goes to A with chance 0.5 + 0.25 x Bias, from 0.25 to 0.75, and 0.515 at the opening 0.06. A then wins 56% of 7 x 7 boards and 59% of 15 x 15; at Bias 0.5 (0.625) 87% and 97%. With a bias the chain shows when the winner holds about half the board, the threshold of site percolation on the triangular lattice: after 80% of the cells at 0.625 and 67% at 0.75.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, round } = Math;\nconst R3 = sqrt(3);\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The six neighbours in turn round a cell, in axial coordinates (q, r).\nconst DQ = [1, 1, 0, -1, -1, 0], DR = [0, -1, -1, 0, 1, 1];\n// Board seconds at Speed 2: a 7 x 7 board fills in FILL, longer boards as\n// the square root of their side; then the pause on the win, the proof\n// (flood and walk), the hold and the clearing wave.\nconst FILL = 2.7, PAUSE = 0.45, PROOF = 1.9, HOLD = 1.3, CLEAR = 0.9;\n// The two players' hues at knob 0, before the wheel below bends them.\nconst HUE_A = 0.324, HUE_B = 0.797;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob's wheel skips the stretch from orange through yellow to lime,\n// which reads brown and olive on the dim cells.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    n: 0, hue: 0, speed: 2, p: 0.5, clock: 0,\n    rgb: new Float32Array(N * 3), cc: null, tmp: new Float32Array(3),\n  };\n}\n\n// Pixel to cell, once per board size. Cell (q, r) sits at\n// x = (q - r) s / 2, y = -(q + r) h, so (0, 0) is the bottom corner,\n// (n-1, n-1) the top, and the rows r = 0 and r = n - 1 are the lower right\n// and upper left sides.\nfunction layout(S, n) {\n  const s = 58 / n;\n  const ky = min(1.25, 116 / (s * (R3 * (n - 1) + 2 / R3)));\n  const h = (s * R3 / 2) * ky, ox = 32, oy = 64 + (n - 1) * h;\n  const cell = new Int16Array(N).fill(-1), shade = new Float32Array(N), side = new Uint8Array(N);\n  const hexm = (dq, dr) => max(abs(dq + dr / 2), abs(dr + dq / 2), abs((dq - dr) / 2));\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const u = (x + 0.5 - ox) / (s / 2), v = (oy - y - 0.5) / h;\n      const fq = (u + v) / 2, fr = (v - u) / 2, fs = -fq - fr;\n      let q = round(fq), r = round(fr);\n      const t = round(fs), eq = abs(q - fq), er = abs(r - fr), es = abs(t - fs);\n      if (eq > er && eq > es) q = -r - t;\n      else if (er > es) r = -q - t;\n      if (q >= 0 && q \u003c n && r >= 0 && r \u003c n) {\n        cell[p] = r * n + q;\n        // A soft seam a pixel wide where two cells meet.\n        shade[p] = cl(((0.5 - hexm(fq - q, fr - r)) * s - 0.3) / 0.9, 0, 1);\n        continue;\n      }\n      // Outside: how far to the nearest cell of the board, for the home edges.\n      const cq = cl(q, 0, n - 1), cr = cl(r, 0, n - 1);\n      let m = 9;\n      for (let k = -1; k \u003c 6; k++) {\n        const aq = cq + (k \u003c 0 ? 0 : DQ[k]), ar = cr + (k \u003c 0 ? 0 : DR[k]);\n        if (aq \u003c 0 || aq >= n || ar \u003c 0 || ar >= n) continue;\n        m = min(m, hexm(fq - aq, fr - ar));\n      }\n      const out = (m - 0.5) * s;\n      const a = cl(out - 0.4, 0, 1) * cl(2.8 - out, 0, 1);\n      if (a \u003c= 0) continue;\n      shade[p] = a;\n      side[p] = max(-fr, fr - (n - 1)) > max(-fq, fq - (n - 1)) ? 1 : 2;\n    }\n  Object.assign(S, { s, h, ox, oy, cell, shade, side });\n}\n\nfunction newBoard(S, n) {\n  if (n !== S.n) layout(S, n), (S.cc = new Float32Array(n * n * 3));\n  S.n = n;\n  const M = n * n;\n  S.cells = new Uint8Array(M);\n  S.at = new Float32Array(M).fill(-99);\n  // Each cell's draw is made as the board is laid and held against Bias\n  // when the cell's turn comes, so a turn of the knob recolours only the\n  // cells still to come.\n  S.u = new Float32Array(M);\n  S.order = new Int16Array(M);\n  for (let i = 0; i \u003c M; i++) (S.order[i] = i), (S.u[i] = Math.random());\n  for (let i = M - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = S.order[i];\n    S.order[i] = S.order[j];\n    S.order[j] = t;\n  }\n  // Union-find over the cells and four side nodes: A's rows r = 0 and\n  // r = n - 1, then B's columns q = 0 and q = n - 1.\n  S.par = new Int16Array(M + 4);\n  for (let i = 0; i \u003c M + 4; i++) S.par[i] = i;\n  S.k = 0;\n  S.acc = 0;\n  S.wait = 0;\n  S.winner = 0;\n  S.winAt = 0;\n  S.path = [];\n  S.onPath = new Int16Array(M).fill(-1);\n  S.club = new Uint8Array(M);\n  S.flood = new Int16Array(M);\n  S.fmax = 1;\n  S.walk = null;\n  S.phase = 0;\n  S.pt = 0;\n}\n\nfunction find(P, i) {\n  while (P[i] !== i) (P[i] = P[P[i]]), (i = P[i]);\n  return i;\n}\nfunction join(P, a, b) {\n  a = find(P, a);\n  b = find(P, b);\n  if (a !== b) P[a] = b;\n}\n\nfunction place(S) {\n  const n = S.n, M = n * n, P = S.par, i = S.order[S.k++], c = S.u[i] \u003c S.p ? 1 : 2;\n  S.cells[i] = c;\n  S.at[i] = S.clock;\n  const q = i % n, r = (i / n) | 0;\n  for (let k = 0; k \u003c 6; k++) {\n    const aq = q + DQ[k], ar = r + DR[k];\n    if (aq >= 0 && aq \u003c n && ar >= 0 && ar \u003c n && S.cells[ar * n + aq] === c) join(P, i, ar * n + aq);\n  }\n  if (c === 1) {\n    if (r === 0) join(P, i, M);\n    if (r === n - 1) join(P, i, M + 1);\n  } else {\n    if (q === 0) join(P, i, M + 2);\n    if (q === n - 1) join(P, i, M + 3);\n  }\n  if (!S.winner) {\n    if (find(P, M) === find(P, M + 1)) win(S, 1);\n    else if (find(P, M + 2) === find(P, M + 3)) win(S, 2);\n  }\n  if (S.winner) {\n    // The winning chain's whole cluster, which grows as the board fills.\n    const root = find(P, S.winner === 1 ? M : M + 2);\n    for (let j = 0; j \u003c M; j++) S.club[j] = S.cells[j] === S.winner && find(P, j) === root ? 1 : 0;\n  }\n}\n\nconst onSide = (n, c, i, which) => (c === 1 ? ((i / n) | 0) === (which ? n - 1 : 0) : i % n === (which ? n - 1 : 0));\n\n// Breadth-first distances through colour c from one of its sides.\nfunction bfs(S, c, which, dist) {\n  const n = S.n, M = n * n, queue = new Int16Array(M);\n  dist.fill(-1);\n  let head = 0, tail = 0;\n  for (let i = 0; i \u003c M; i++) if (S.cells[i] === c && onSide(n, c, i, which)) (dist[i] = 0), (queue[tail++] = i);\n  while (head \u003c tail) {\n    const i = queue[head++], q = i % n, r = (i / n) | 0;\n    for (let k = 0; k \u003c 6; k++) {\n      const aq = q + DQ[k], ar = r + DR[k], j = ar * n + aq;\n      if (aq \u003c 0 || aq >= n || ar \u003c 0 || ar >= n || S.cells[j] !== c || dist[j] >= 0) continue;\n      dist[j] = dist[i] + 1;\n      queue[tail++] = j;\n    }\n  }\n}\n\n// The first chain: the shortest path through the winner's cells from one\n// home edge to the other, found the moment the two edges join.\nfunction win(S, c) {\n  const n = S.n, M = n * n, d0 = new Int16Array(M);\n  S.winner = c;\n  S.winAt = S.clock;\n  S.wait = PAUSE;\n  bfs(S, c, 0, d0);\n  let end = -1;\n  for (let i = 0; i \u003c M; i++) if (d0[i] >= 0 && onSide(n, c, i, 1) && (end \u003c 0 || d0[i] \u003c d0[end])) end = i;\n  const path = [end];\n  while (d0[path[path.length - 1]] > 0) {\n    const i = path[path.length - 1], q = i % n, r = (i / n) | 0;\n    for (let k = 0; k \u003c 6; k++) {\n      const aq = q + DQ[k], ar = r + DR[k], j = ar * n + aq;\n      if (aq >= 0 && aq \u003c n && ar >= 0 && ar \u003c n && d0[j] === d0[i] - 1) {\n        path.push(j);\n        break;\n      }\n    }\n  }\n  path.reverse();\n  S.path = path;\n  path.forEach((i, k) => (S.onPath[i] = k));\n}\n\n// On the full board: the loser's cells reached from each of its edges, by\n// distance, and Gale's walk. The walk starts at the bottom corner on the\n// seam between the two border rows, and at every corner of a cell it meets\n// it turns so that A stays on one hand and B on the other. It cannot close\n// or stop, so it leaves at another corner, and which one says who won.\nfunction proof(S) {\n  const n = S.n, M = n * n, lose = 3 - S.winner, d = new Int16Array(M);\n  S.flood.fill(-1);\n  for (const which of [0, 1]) {\n    bfs(S, lose, which, d);\n    for (let i = 0; i \u003c M; i++) if (d[i] >= 0) S.flood[i] = which * 1000 + d[i];\n  }\n  S.fmax = 1;\n  for (let i = 0; i \u003c M; i++) if (S.flood[i] >= 0) S.fmax = max(S.fmax, S.flood[i] % 1000);\n  const col = (q, r) => {\n    const qi = q >= 0 && q \u003c n, ri = r >= 0 && r \u003c n;\n    if (qi && ri) return S.cells[r * n + q];\n    if (!qi && !ri) return 0;\n    return ri ? 2 : 1;\n  };\n  const px = (q, r) => S.ox + ((q - r) * S.s) / 2, py = (q, r) => S.oy - (q + r) * S.h;\n  const vert = (a, b, c) => [(px(a[0], a[1]) + px(b[0], b[1]) + px(c[0], c[1])) / 3, (py(a[0], a[1]) + py(b[0], b[1]) + py(c[0], c[1])) / 3];\n  // The cell beside both a and b that is not x.\n  const other = (a, b, x) => {\n    const dq = b[0] - a[0], dr = b[1] - a[1];\n    let k = 0;\n    while (DQ[k] !== dq || DR[k] !== dr) k++;\n    const u = [a[0] + DQ[(k + 5) % 6], a[1] + DR[(k + 5) % 6]];\n    return u[0] === x[0] && u[1] === x[1] ? [a[0] + DQ[(k + 1) % 6], a[1] + DR[(k + 1) % 6]] : u;\n  };\n  let a = [0, -1], b = [-1, 0], back = [-1, -1], ahead = [0, 0];\n  const pts = [vert(a, b, back)];\n  for (let guard = 0; guard \u003c 4 * M + 20; guard++) {\n    pts.push(vert(a, b, ahead));\n    const c = col(ahead[0], ahead[1]);\n    if (c === 0) break;\n    let dropped;\n    if (c === 1) (dropped = a), (a = ahead);\n    else (dropped = b), (b = ahead);\n    ahead = other(a, b, dropped);\n  }\n  S.walk = pts;\n  S.walkEnd = ahead[0] === n ? 2 : 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = cl(floor(kv[2] + 0.5), 7, 15);\n  S.p = 0.5 + 0.25 * cl(kv[3], -1, 1);\n  if (n !== S.n) newBoard(S, n);\n  const g = (d * S.speed) / 2;\n  S.clock += g;\n  const M = n * n;\n  if (S.phase === 0) {\n    if (S.wait > 0) S.wait -= g;\n    else {\n      S.acc += (g * M) / (FILL * sqrt(n / 7));\n      while (S.acc >= 1 && S.k \u003c M) {\n        S.acc -= 1;\n        const had = S.winner;\n        place(S);\n        if (!had && S.winner) break;\n      }\n      if (S.k >= M) (S.phase = 1), (S.pt = 0), proof(S);\n    }\n  } else {\n    S.pt += g;\n    if (S.phase === 1 && S.pt >= PROOF + HOLD) (S.phase = 2), (S.pt = 0);\n    else if (S.phase === 2 && S.pt >= CLEAR) newBoard(S, n);\n  }\n}\n\n// Lines for the walk: points every third of a pixel, each laid over its\n// four nearest LEDs by how close it falls, so the thread stays white\n// across the small cells of a big board.\nfunction plot(rgb, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 2.5) * a, p = (yy * W + xx) * 3;\n      for (let k = 0; k \u003c 3; k++) rgb[p + k] += (c[k] - rgb[p + k]) * w;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cells) return;\n  const n = S.n, M = n * n, cc = S.cc, rgb = S.rgb, T = S.tmp;\n  const hA = wheel(HUE_A + S.hue), hB = wheel(HUE_B + S.hue);\n  const end = S.phase >= 1, pt = S.pt;\n  const pulse = (S.clock - S.winAt) / 1.3;\n  for (let i = 0, o = 0; i \u003c M; i++, o += 3) {\n    const c = S.cells[i];\n    if (!c) {\n      (cc[o] = 0.1), (cc[o + 1] = 0.1), (cc[o + 2] = 0.15);\n      continue;\n    }\n    const hc = c === 1 ? hA : hB;\n    // Once a chain has won, the other cells step back.\n    let s = 0.85, v = S.winner ? 0.5 : 0.62;\n    if (S.club[i]) (s = 0.72), (v = 1);\n    if (end && !S.club[i]) {\n      // The full board: the loser's cells light up from each of its edges,\n      // a little apart on the wheel, and stop against the chain.\n      const f = S.flood[i];\n      const at = f >= 0 ? (f % 1000) / S.fmax : 2;\n      const lit = S.phase === 2 ? (f >= 0 ? 1 : 0) : cl((pt / (PROOF * 0.6) - at) * 3, 0, 1);\n      hsv(hc + lit * (f >= 1000 ? 0.035 : -0.035), 0.62 - 0.17 * lit, 0.3 + 0.5 * lit, cc, o);\n    } else hsv(hc, s, v, cc, o);\n    const k = S.onPath[i];\n    if (k >= 0) {\n      // The chain lights from end to end at 30 cells a second, then a pulse runs along it.\n      const shown = (S.clock - S.winAt) * 30 - k;\n      if (shown > 0) {\n        const ph = pulse - floor(pulse) - k / S.path.length;\n        const w = 0.4 + 0.55 * exp(-((ph - round(ph)) ** 2) * 60) + 0.4 * exp(-shown / 6);\n        for (let e = 0; e \u003c 3; e++) cc[o + e] += (1 - cc[o + e]) * min(1, w);\n      }\n    }\n    // A fresh cell flashes white.\n    const age = S.clock - S.at[i];\n    if (age \u003c 0.4) {\n      const f = 0.85 * exp(-age / 0.1);\n      for (let e = 0; e \u003c 3; e++) cc[o + e] += (1 - cc[o + e]) * f;\n    }\n  }\n  // The clearing wave runs down the board.\n  let cut = -1;\n  if (S.phase === 2) cut = (pt / CLEAR) * (H + 30) - 15;\n  hsv(hA, 0.9, 1, T, 0);\n  const eA = [T[0], T[1], T[2]];\n  hsv(hB, 0.9, 1, T, 0);\n  const eB = [T[0], T[1], T[2]];\n  const { cell, shade, side } = S;\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const i = cell[p];\n    if (i >= 0) {\n      let a = shade[p];\n      if (cut > -2) a *= cl((floor(p / W) - cut) / 12, 0, 1);\n      (rgb[o] = cc[i * 3] * a), (rgb[o + 1] = cc[i * 3 + 1] * a), (rgb[o + 2] = cc[i * 3 + 2] * a);\n    } else if (side[p]) {\n      const e = side[p] === 1 ? eA : eB, a = shade[p];\n      (rgb[o] = e[0] * a), (rgb[o + 1] = e[1] * a), (rgb[o + 2] = e[2] * a);\n    } else rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n  }\n  // Gale's walk, drawn in along the seams after the flood has started,\n  // with a spark at its head; once it is out, the spark runs it again\n  // from the bottom corner every 1.2 seconds.\n  if (S.phase >= 1 && S.walk) {\n    const pts = S.walk, L = pts.length - 1, drawn = S.phase === 1 && pt \u003c PROOF;\n    const f = drawn ? cl((pt - PROOF * 0.25) / (PROOF * 0.75), 0, 1) * L : L;\n    const head = drawn ? f : (((S.phase === 1 ? pt - PROOF : pt + HOLD) / 1.2) % 1) * L;\n    const col = [0.95, 0.95, 0.86], hot = [1, 1, 1];\n    for (let k = 0; k \u003c L && k \u003c f; k++) {\n      const [xa, ya] = pts[k], [xb, yb] = pts[k + 1], u = min(1, f - k);\n      const len = Math.hypot(xb - xa, yb - ya), m = Math.ceil(len * 3 * u) || 1;\n      for (let e = 0; e \u003c= m; e++) {\n        const y = ya + ((yb - ya) * u * e) / m, a = cut > -2 ? cl((y - cut) / 12, 0, 1) : 1;\n        if (a \u003c= 0) continue;\n        const x = xa + ((xb - xa) * u * e) / m, near = cl(1 - abs(k + (u * e) / m - head) / 3, 0, 1);\n        plot(rgb, x, y, near > 0 ? hot : col, (0.8 + 0.2 * near) * a);\n        if (near > 0.5) for (const [dx, dy] of [[-0.6, 0], [0.6, 0], [0, -0.6], [0, 0.6]]) plot(rgb, x + dx, y + dy, hot, near * a);\n      }\n    }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","imaginary-geometry":"// ===== Patternflow pattern =====\n// Title:   Imaginary Geometry\n// Family:  noise\n// Idea:    Thirteen flow lines of a drifting Gaussian free field leave one point on the bottom edge as a fan of angles and climb to one point on the top edge, each turning wherever the field turns it, so a line of larger angle always stays to the left, and where two come within an LED they run on together as one and part again without ever crossing.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: imaginary geometry, the flow lines of the Gaussian free field (Jason Miller and Scott Sheffield, 2016); Gaussian Free Field (round 52) draws the same field's level lines, this one its flow lines, pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Kappa=0.5..3, Spread=4..6.2\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the lines run from magenta on the left (the largest angle) through violet and blue to cyan on the right, with white marks where a line joins another for four LEDs or more. Behind them the direction a line of angle 0 would take at each LED shows as a faint hue, 22 of 255 in its brightest channel; that faint wheel skips orange and yellow, which read brown and olive so dark.\n// Knob 2: Speed. How fast the field drifts. Each of its 2,048 sine modes is a smooth random process whose law stays the free field's: at 2 the largest mode forgets itself in 1.5 s and the finest, 4 LEDs from crest to crest, in 0.24 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Kappa. The SLE parameter. It sets chi = 2/sqrt(kappa) - sqrt(kappa)/2, from 2.47 at 0.5 to 0.29 at 3, and the lines turn by the field divided by chi. At 0.5 they wobble round a lens 37 LEDs wide at mid-height and ride on another line for 7% of their length, at 1 for 19%. At 2 they braid into one winding bundle 26 LEDs wide, riding together 42% of the way, and at 3 into a ribbon 11 LEDs wide, 55%. The field is smoothed over 1.2 LEDs up to kappa 1.55, then over a width that grows to 4.1 LEDs at 3, so that a line's turning stays near 0.6 radians per LED, root mean square, and the line stays a line.\n// Knob 4: Spread. The fan of angles, in radians: thirteen lines evenly from -2 to +2 at 4, up to -3.1 to +3.1 at 6.2. At kappa 0.5 the lens is 37 LEDs wide at mid-height at 4 and 57 at 6.2, where the outermost lines hug the side edges: a line whose angle reached pi would run along the bottom edge.\n// Buttons: K1 tap draws a new field, and the fan grows from the bottom point again over about a second.\n\nconst W = 64, H = 128, NX = W + 1, NY = H + 1, NN = NX * NY;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, atan2, hypot, PI } = Math;\nconst TAU = 2 * PI, HALF = PI / 2;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Lines, sine modes across and up, and points a line may hold.\nconst NL = 13, MM = 32, NM = 64, MAXP = 3000;\n// The root on the bottom edge and the target on the top, both at x = 32.\n// Positions are in LEDs with v measured up from the bottom edge, and the\n// field lives on the 65 x 129 nodes at the LED corners.\nconst RX = 32;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The field is h0 + lambda U + chi V. h0 is the free field, zero on the\n// edges. lambda U carries the boundary values -lambda left of the root and\n// +lambda right of it that make the angle-0 line from root to target an\n// SLE(kappa), with lambda = pi / sqrt(kappa). chi V is the coordinate change\n// h o phi - chi arg phi' from the half-plane: V is the boundary's own\n// turning, 0 along the bottom, pi/2 up the sides and pi along the top,\n// minus on the left. U and V jump at the root and the target, so each is\n// split into those jumps, written out (argR, argT), and a smooth rest\n// solved once on the nodes.\nconst argR = (u, v) => atan2(v, u - RX);\nconst argT = (u, v) => (v >= H ? (u >= RX ? 0 : -PI) : atan2(v - H, u - RX));\n\n// Laplace's equation inside, the edge nodes held: over-relaxed sweeps.\nfunction harmonic(F) {\n  const om = 2 / (1 + sin(PI / NY));\n  for (let it = 0; it \u003c 4000; it++) {\n    let worst = 0;\n    for (let j = 1; j \u003c H; j++)\n      for (let i = 1; i \u003c W; i++) {\n        const p = j * NX + i, d = om * (0.25 * (F[p - 1] + F[p + 1] + F[p - NX] + F[p + NX]) - F[p]);\n        F[p] += d;\n        if (abs(d) > worst) worst = abs(d);\n      }\n    if (worst \u003c 1e-7) break;\n  }\n}\n\n// Sine modes of the 64 x 128 rectangle. With the free field's covariance\n// -log|x - y|, mode (m, n) has standard deviation sqrt(2 pi / mu) on the\n// orthonormal basis, mu being its eigenvalue. TC is its time constant in\n// seconds at Speed 1: 3 s for the largest, down as mu^-1/4.\nconst SXT = new Float64Array(MM * NX), SYT = new Float64Array(NM * NY);\nfor (let m = 0; m \u003c MM; m++) for (let i = 0; i \u003c NX; i++) SXT[m * NX + i] = sin((PI * (m + 1) * i) / W);\nfor (let n = 0; n \u003c NM; n++) for (let j = 0; j \u003c NY; j++) SYT[n * NY + j] = sin((PI * (n + 1) * j) / H);\nconst MU = new Float64Array(MM * NM), AMP = new Float64Array(MM * NM), TC = new Float64Array(MM * NM);\nfor (let m = 0; m \u003c MM; m++)\n  for (let n = 0; n \u003c NM; n++) {\n    const q = m * NM + n, mu = PI * PI * (((m + 1) / W) ** 2 + ((n + 1) / H) ** 2);\n    MU[q] = mu;\n    AMP[q] = sqrt((2 * PI) / mu) * (2 / sqrt(W * H));\n    TC[q] = 3 * (MU[0] / mu) ** 0.25;\n  }\n\nfunction gauss() {\n  const a = Math.random() || 1e-12, b = Math.random();\n  return sqrt(-2 * log(a)) * cos(TAU * b);\n}\n\nexport function setup(params) {\n  const SU = new Float64Array(NN), SV = new Float64Array(NN);\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c NX; i++) {\n      if (i > 0 && i \u003c W && j > 0 && j \u003c H) continue;\n      const p = j * NX + i;\n      let ud, vd;\n      if (j === 0) (ud = i \u003c RX ? -1 : i > RX ? 1 : 0), (vd = i === 0 ? -PI / 4 : i === W ? PI / 4 : 0);\n      else if (j === H) (ud = i \u003c RX ? -1 : i > RX ? 1 : 0), (vd = i === 0 ? (-3 * PI) / 4 : i === W ? (3 * PI) / 4 : i \u003c RX ? -PI : i > RX ? PI : 0);\n      else if (i === 0) (ud = -1), (vd = -HALF);\n      else (ud = 1), (vd = HALF);\n      const at = argT(i, j), aR = j === 0 ? ud : 1 - (2 / PI) * argR(i, j);\n      // The two ends themselves take the rest's limit there, which is 0.\n      const end = i === RX && (j === 0 || j === H);\n      SU[p] = end ? 0 : ud - aR - (1 + (2 / PI) * at);\n      SV[p] = end ? 0 : vd - (PI + 2 * at);\n    }\n  harmonic(SU);\n  harmonic(SV);\n  // The jumps at the nodes too, for the look-up away from the two ends.\n  const AR = new Float64Array(NN), AV = new Float64Array(NN);\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c NX; i++) {\n      const p = j * NX + i, at = argT(i, j);\n      AR[p] = 2 + (2 / PI) * (at - argR(i, j));\n      AV[p] = PI + 2 * at;\n    }\n  const K = MM * NM, X = new Float64Array(K), Y = new Float64Array(K);\n  for (let q = 0; q \u003c K; q++) (X[q] = gauss()), (Y[q] = gauss() / TC[q]);\n  params.s = {\n    SU, SV, AR, AV, X, Y, C: new Float64Array(K), B: new Float64Array(MM * NY), h: new Float64Array(NN), P: new Float64Array(NN), F: new Float64Array(NN),\n    own: new Int16Array(W * H), pts: Array.from({ length: NL }, () => new Float32Array(MAXP * 2)), vis: Array.from({ length: NL }, () => new Uint8Array(MAXP)), np: new Int32Array(NL),\n    jx: new Float32Array(40), jy: new Float32Array(40), nj: 0,\n    rgb: new Float32Array(W * H * 3), col: new Float64Array(3), pal: new Float32Array(192), palHue: -1,\n    t: 0, hue: 0, speed: 2, kappa: 0.5, spread: 4, chi: 1, lc: 1, eps: 1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.5, 4], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.kappa = cl(kv[2], 0.5, 3);\n  S.spread = cl(kv[3], 4, 6.2);\n  if (input.btnPressed && input.btnPressed[0]) {\n    for (let q = 0; q \u003c S.X.length; q++) (S.X[q] = gauss()), (S.Y[q] = gauss() / TC[q]);\n    S.t = 0;\n  }\n  S.t += d;\n  const rk = sqrt(S.kappa);\n  S.chi = 2 / rk - rk / 2;\n  // lambda / chi = 2 pi / (4 - kappa): how far the boundary values turn a line.\n  S.lc = PI / rk / S.chi;\n  // A line turns by the gradient of h / chi, whose spread is 1 / (sqrt 2 eps\n  // chi) for a field smoothed over eps: eps keeps that near 0.6 rad per LED,\n  // and never under 1.2 LEDs, where the finest modes run out.\n  S.eps = max(1.2, 1 / (sqrt(2) * S.chi * 0.6));\n  // Each mode is a critically damped oscillator driven by noise: its path is\n  // smooth, so the lines glide, and its law stays the unit normal.\n  const de = d * S.speed, X = S.X, Y = S.Y;\n  for (let q = 0; q \u003c X.length; q++) {\n    const tc = TC[q];\n    Y[q] += (-2 * Y[q] / tc - X[q] / (tc * tc)) * de + (2 / (tc * sqrt(tc))) * sqrt(de) * gauss();\n    X[q] += Y[q] * de;\n  }\n  const C = S.C, e2 = (S.eps * S.eps) / 2, kmax2 = 4.6 / e2;\n  let mTop = 0;\n  for (let m = 0; m \u003c MM; m++)\n    for (let n = 0; n \u003c NM; n++) {\n      const q = m * NM + n;\n      if (MU[q] > kmax2) {\n        C[q] = 0;\n        continue;\n      }\n      C[q] = AMP[q] * exp(-MU[q] * e2) * X[q];\n      if (m + 1 > mTop) mTop = m + 1;\n    }\n  // Mode k is even or odd about the middle as k is odd or even, so each sum\n  // serves a node and its mirror.\n  const B = S.B, h = S.h;\n  for (let m = 0; m \u003c mTop; m++)\n    for (let j = 0; j \u003c= H / 2; j++) {\n      let e = 0, o = 0;\n      for (let n = 0; n \u003c NM; n += 2) {\n        e += C[m * NM + n] * SYT[n * NY + j];\n        o += C[m * NM + n + 1] * SYT[(n + 1) * NY + j];\n      }\n      B[m * NY + j] = e + o;\n      B[m * NY + H - j] = e - o;\n    }\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c= W / 2; i++) {\n      let e = 0, o = 0;\n      for (let m = 0; m \u003c mTop; m += 2) {\n        e += SXT[m * NX + i] * B[m * NY + j];\n        if (m + 1 \u003c mTop) o += SXT[(m + 1) * NX + i] * B[(m + 1) * NY + j];\n      }\n      h[j * NX + i] = e + o;\n      h[j * NX + W - i] = e - o;\n    }\n  // P is the angle field without the jumps at the ends, F with them.\n  const P = S.P, F = S.F, ic = 1 / S.chi, lc = S.lc;\n  for (let p = 0; p \u003c NN; p++) {\n    P[p] = h[p] * ic + lc * S.SU[p] + S.SV[p];\n    F[p] = P[p] + lc * S.AR[p] + S.AV[p];\n  }\n  trace(S);\n}\n\n// h / chi at a point: the angle a line of angle 0 turns from north. Within\n// 6 LEDs of either end the jumps are written out instead of interpolated.\nfunction phiAt(S, u, v) {\n  const fu = cl(u, 0, W - 1e-6), fv = cl(v, 0, H - 1e-6), i = floor(fu), j = floor(fv), a = fu - i, b = fv - j, p = j * NX + i;\n  if ((u - RX) ** 2 + v * v > 36 && (u - RX) ** 2 + (v - H) ** 2 > 36) {\n    const F = S.F;\n    return (F[p] * (1 - a) + F[p + 1] * a) * (1 - b) + (F[p + NX] * (1 - a) + F[p + NX + 1] * a) * b;\n  }\n  const P = S.P, rest = (P[p] * (1 - a) + P[p + 1] * a) * (1 - b) + (P[p + NX] * (1 - a) + P[p + NX + 1] * a) * b;\n  const at = argT(u, min(v, H));\n  return rest + S.lc * (2 + (2 / PI) * (at - argR(u, max(v, 0)))) + PI + 2 * at;\n}\n\n// Each line follows exp(i (h / chi + theta)) from the root, by midpoint steps\n// of half an LED that shorten near the ends. The middle line goes first and\n// the rest pair off outward. A line that steps into an LED an earlier line\n// holds rides with it, undrawn, until it steps into a free LED again. In the\n// smoothed field two lines of different angle cannot even touch, since they\n// would cross with the larger angle going right; in the free field itself\n// lines whose angles differ by less than pi kappa / (4 - kappa) do touch\n// and bounce off. Drawn at one LED, both look like this.\nfunction trace(S) {\n  const own = S.own, grow = S.t \u003c 2.5 ? 180 * S.t : 1e9, lc = S.lc, sp = S.spread, mid = (NL - 1) / 2;\n  own.fill(0);\n  S.nj = 0;\n  for (let k = 0; k \u003c= mid; k++)\n    for (const L of k ? [mid + k, mid - k] : [mid]) {\n      const th = -sp / 2 + (sp * L) / (NL - 1), pts = S.pts[L], vis = S.vis[L], id = L + 1;\n      // Near the root the field is the half-plane's alone, and the line of\n      // angle theta leaves along the one ray it maps to itself.\n      const a0 = (HALF + th + lc) / (1 + (2 * lc) / PI);\n      let u = RX + cos(a0), v = sin(a0), n = 0, len = 0, ride = false, ju = 0, jv = 0, rc = 0;\n      (vis[n] = 1), (pts[2 * n] = RX), (pts[2 * n++ + 1] = 0);\n      (vis[n] = 1), (pts[2 * n] = u), (pts[2 * n++ + 1] = v);\n      let ci = floor(u), cj = floor(H - v);\n      while (n \u003c MAXP) {\n        const rr = hypot(u - RX, v), rt = hypot(u - RX, v - H), s = cl(0.15 * min(rr, rt), 0.05, 0.5);\n        let f = HALF + th + phiAt(S, u, v);\n        f = HALF + th + phiAt(S, u + 0.5 * s * cos(f), v + 0.5 * s * sin(f));\n        u += s * cos(f);\n        v += s * sin(f);\n        len += s;\n        if (rt \u003c 0.8 || u \u003c 0.05 || u > W - 0.05 || v \u003c 0.05 || v > H - 0.05 || len > grow) break;\n        const ni = floor(u), nj = floor(H - v);\n        if (ni !== ci || nj !== cj) {\n          let o = own[nj * W + ni];\n          if (ni !== ci && nj !== cj) {\n            // A diagonal step: the side LED nearer the path counts too, so\n            // two lines cannot slip past each other through a corner.\n            const sx = abs(u - max(ni, ci)) \u003c abs(H - v - max(nj, cj)) ? ci : ni, sy = sx === ci ? nj : cj, os = own[sy * W + sx];\n            if (os && os !== id) o = o || os;\n            else if (!o && rr > 3.5) own[sy * W + sx] = id;\n          }\n          // The lines all leave the root together, so the first 3.5 LEDs are shared.\n          const held = rr > 3.5 && o && o !== id;\n          if (held && !ride) (ju = u), (jv = v), (rc = 0);\n          if (held && ++rc === 4 && S.nj \u003c 40) (S.jx[S.nj] = ju), (S.jy[S.nj++] = jv);\n          ride = held;\n          if (!held) own[nj * W + ni] = id;\n          (ci = ni), (cj = nj);\n        }\n        vis[n] = ride ? 0 : 1;\n        (pts[2 * n] = u), (pts[2 * n++ + 1] = v);\n      }\n      S.np[L] = n;\n    }\n}\n\n// Lines are laid as points every third of an LED, each lighting its four\n// nearest LEDs by how close it falls; an LED keeps the brightest.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, col = S.col, pal = S.pal, F = S.F;\n  // The faint wheel runs from lime round through blue and magenta to red,\n  // leaving out orange and yellow.\n  if (S.palHue !== S.hue) {\n    for (let k = 0; k \u003c 64; k++) {\n      const fh = k / 64 + S.hue;\n      hsv(0.22 + 0.8 * (fh - floor(fh)), 0.6, 0.088, col);\n      (pal[3 * k] = col[0]), (pal[3 * k + 1] = col[1]), (pal[3 * k + 2] = col[2]);\n    }\n    S.palHue = S.hue;\n  }\n  for (let r = 0, o = 0; r \u003c H; r++)\n    for (let c = 0; c \u003c W; c++, o += 3) {\n      const p = (H - 1 - r) * NX + c, f = (F[p] + F[p + 1] + F[p + NX] + F[p + NX + 1]) / (4 * TAU), q = 3 * ((64 * (f - floor(f))) | 0);\n      (rgb[o] = pal[q]), (rgb[o + 1] = pal[q + 1]), (rgb[o + 2] = pal[q + 2]);\n    }\n  // Line colours go round half the wheel by angle, cyan to magenta at 0.\n  const c = [0, 0, 0];\n  for (let L = 0; L \u003c NL; L++) {\n    const pts = S.pts[L], vis = S.vis[L], n = S.np[L];\n    hsv(0.45 + S.hue + (0.45 * L) / (NL - 1), 0.8, 1, c);\n    for (let k = 0; k + 1 \u003c n; k++) {\n      if (!vis[k + 1]) continue;\n      const xa = pts[2 * k], ya = H - pts[2 * k + 1], xb = pts[2 * k + 2], yb = H - pts[2 * k + 3];\n      const m = Math.ceil(hypot(xb - xa, yb - ya) * 3) || 1;\n      for (let e = 0; e \u003c m; e++) plot(S, xa + ((xb - xa) * e) / m, ya + ((yb - ya) * e) / m, c, 1);\n    }\n  }\n  const white = [1, 1, 1];\n  for (let k = 0; k \u003c S.nj; k++) plot(S, S.jx[k], H - S.jy[k], white, 0.85);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","question-mark":"// ===== Patternflow pattern =====\n// Title:   Question Mark Function\n// Family:  number\n// Idea:    Minkowski's question mark function rises as a filled staircase that zooms for ever into a quadratic irrational, the Farey fractions marked where the dyadic levels meet the stair, while the point's continued fraction digits and the binary digits of its image scroll past underneath as the same runs.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Minkowski's question mark function (Hermann Minkowski, 1904), with Denjoy's continued fraction sum (Arnaud Denjoy, 1938), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Point=0..5, Depth=3..7\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the staircase is azure with a pale rim, the Farey marks and their dyadic lines rose, and the point pale gold, with the lines of its own Stern-Brocot path in a pale grey gold. Underneath, runs of noughts are rose and runs of ones azure.\n// Knob 2: Speed. At 2 the bits scroll past at 0.6 a second, so the golden point's loop, where the picture shrinks 6.9 times across and 4 times up, takes 3.3 seconds and the silver point's, 34 times across and 16 up, takes 6.7. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Point. The quadratic irrational the zoom falls into: 0 the golden point 1/phi = [0; 1, 1, 1, ...], where ? is 2/3; 1 the silver point sqrt(2) - 1 = [0; 2, 2, ...], ? = 2/5; 2 sqrt(3) - 1 = [0; 1, 2, 1, 2, ...], ? = 6/7; 3 (sqrt(3) - 1)/2 = [0; 2, 1, ...], ? = 2/7; 4 [0; 3, 3, ...], ? = 2/9; 5 [0; 1, 3, ...], ? = 14/15.\n// Knob 4: Depth. How many levels of the Farey tree are marked, counted from the window's own scale: 3 marks the 7 fractions down to the quarters and fifths on the whole graph, 7 marks 127, and each loop of the zoom fades in the next levels as they grow into view. As on a ruler, the deeper the level the fainter its lines.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, pow, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Hue of the staircase at knob 0, azure so the panel never opens on red,\n// and the turn to the marks' colour.\nconst HUE0 = 0.56, MARK = 0.4;\n// The graph's box and the two bars under it, in LED rows.\nconst GT = 1, GB = 105, BAR1 = 110, BAR2 = 120, CELL = 3;\n// The periods of the continued fractions the knob chooses from.\nconst POINTS = [[1], [2], [1, 2], [2, 1], [3], [1, 3]];\n// Bits a second at Speed 2.\nconst RATE = 0.6;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Denjoy's sum: x = [0; a1, a2, ...] goes to 2 (2^-A1 - 2^-A2 + ...), with\n// A_k the sum of the first k partial quotients.\nfunction qm(x) {\n  if (x \u003c= 0) return 0;\n  if (x >= 1) return 1;\n  let y = 0, sg = 1, pw = 2;\n  for (let k = 0; k \u003c 80 && x > 1e-13; k++) {\n    const inv = 1 / x, a = floor(inv);\n    x = inv - a;\n    pw *= pow(2, -a);\n    y += sg * pw;\n    sg = -sg;\n    if (pw \u003c 1e-16) break;\n  }\n  return y;\n}\n\n// The point's map phi(t) = [0; a1, ..., ap + t] as a Moebius matrix, its\n// two fixed points, and the multiplier at the attracting one. An odd period\n// turns the picture over, so it is taken twice.\nfunction point(k) {\n  let a = POINTS[k];\n  if (a.length % 2) a = a.concat(a);\n  let m00 = 1, m01 = 0, m10 = 0, m11 = 1;\n  for (const q of a) {\n    // Multiply by [[0, 1], [1, q]]: t -> 1 / (q + t).\n    const n00 = m01, n01 = m00 + q * m01, n10 = m11, n11 = m10 + q * m11;\n    m00 = n00; m01 = n01; m10 = n10; m11 = n11;\n  }\n  // m10 x^2 + (m11 - m00) x - m01 = 0.\n  const b = m11 - m00, disc = sqrt(b * b + 4 * m10 * m01);\n  const r1 = (-b + disc) / (2 * m10), r2 = (-b - disc) / (2 * m10);\n  const x0 = r1 > 0 && r1 \u003c 1 ? r1 : r2, x1 = x0 === r1 ? r2 : r1;\n  const kap = 1 / (m10 * x0 + m11) ** 2;\n  let A = 0;\n  // The binary digits of ?(x0), the units digit first: a1 noughts, a2\n  // ones, a3 noughts and so on.\n  const bits = [];\n  for (let i = 0; i \u003c a.length; i++) {\n    for (let j = 0; j \u003c a[i]; j++) bits.push(i % 2);\n    A += a[i];\n  }\n  return { a, A, x0, x1, kap, y0: qm(x0), bits, sig: pow(2, -A) };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, sp: 2, pk: -1, P: null, z: 0, depth: 3, ys: new Float64Array(W + 1),\n    mk: [], buf: new Float32Array(W * H * 3), pal: new Float32Array(24), palHue: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.sp = cl(kv[1], 0.2, 3);\n  const pk = round(cl(kv[2], 0, POINTS.length - 1));\n  s.depth = cl(kv[3], 3, 7);\n  if (pk !== s.pk) {\n    s.pk = pk;\n    s.P = point(pk);\n    s.z = 0;\n  }\n  // One loop of the zoom is one period of the digits, A bits.\n  s.z += (d * RATE * (s.sp / 2)) / s.P.A;\n  s.z -= floor(s.z);\n}\n\nfunction palette(s) {\n  const P = s.pal, h = HUE0 + s.hue;\n  hsv(h, 0.8, 1, P, 0); // stair fill, scaled down the column\n  hsv(h - 0.03, 0.3, 1, P, 3); // stair edge\n  hsv(h + MARK, 0.6, 1, P, 6); // mark\n  hsv(h + MARK, 0.55, 0.36, P, 9); // dyadic arm\n  hsv(h + 0.62, 0.45, 1, P, 12); // probe ring and path\n  hsv(h + MARK, 0.8, 0.95, P, 15); // a run of noughts\n  hsv(h, 0.75, 0.95, P, 18); // a run of ones\n  hsv(h + 0.62, 0.22, 0.42, P, 21); // dyadic arm on the point's path\n  s.palHue = s.hue;\n}\n\n// Screen to x and back. u = (x - x0)/(x - x1) turns phi into u -> kap u,\n// so the window kap^z u(s) for s in [0, 1] is the whole graph at z = 0 and\n// its copy one period down at z = 1, and the loop has no seam.\nfunction uOf(P, x) { return (x - P.x0) / (x - P.x1); }\nfunction xOf(P, u) { return (P.x0 - u * P.x1) / (1 - u); }\n\n// The Stern-Brocot tree inside the window: each mediant of two Farey\n// neighbours goes to the midpoint of their images, which is what ? is.\nfunction walk(s, P, xlo, xhi, a, b, c, dd, ylo, yhi, lev, maxLev, path) {\n  if (lev > maxLev) return;\n  if (c / dd \u003c xlo || a / b > xhi) return;\n  const p = a + c, q = b + dd, m = p / q, ym = (ylo + yhi) / 2;\n  const onPath = path && P.x0 > a / b && P.x0 \u003c c / dd;\n  s.mk.push(m, ym, lev, onPath ? 1 : 0);\n  walk(s, P, xlo, xhi, a, b, p, q, ylo, ym, lev + 1, maxLev, onPath);\n  walk(s, P, xlo, xhi, p, q, c, dd, ym, yhi, lev + 1, maxLev, onPath);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.P) return;\n  if (s.palHue !== s.hue) palette(s);\n  const { buf: B, pal: C, P, z } = s;\n  B.fill(0);\n  const add = (x, y, o, k) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    B[i] += C[o] * k;\n    B[i + 1] += C[o + 1] * k;\n    B[i + 2] += C[o + 2] * k;\n  };\n  const kx = pow(P.kap, z), ky = pow(P.sig, z);\n  const sx = (x) => xOf(P, uOf(P, x) / kx); // x -> screen 0..1\n  const xs = (t) => xOf(P, kx * uOf(P, t)); // screen 0..1 -> x\n  const ry = (y) => P.y0 + (y - P.y0) / ky; // y -> screen 0..1, up\n  const GHt = GB - GT;\n  const row = (r) => GB - r * GHt; // screen up 0..1 -> LED row (float)\n\n  // The stair: ? at the 65 column edges. It only rises, so between two\n  // edges the graph fills exactly the span of the two values.\n  for (let c = 0; c \u003c= W; c++) s.ys[c] = row(ry(qm(xs(c / W))));\n  for (let c = 0; c \u003c W; c++) {\n    const top = s.ys[c + 1], bot = s.ys[c];\n    // Fill from the floor of the box up to the low end of the span,\n    // brightest just under the rim.\n    const yTop = max(GT, floor(top)), yBot = min(GB, floor(bot));\n    for (let y = GB; y > yBot; y--) add(c, y, 0, 0.18 + 0.5 * exp((-5 * (y - bot)) / GHt));\n    // The span itself, a riser where ? climbs and a tread where it is flat.\n    for (let y = yBot; y >= yTop; y--) if (y >= GT && y \u003c= GB) add(c, y, 3, 0.9);\n  }\n\n  // Farey marks down to Depth levels below the window's own scale. A level\n  // grows one period deeper each loop, so rel = level - A z is the same at\n  // z = 0 and z = 1.\n  const D = s.depth, maxLev = floor(D + P.A * z) + 1;\n  s.mk.length = 0;\n  const xlo = xs(0), xhi = xs(1);\n  walk(s, P, xlo, xhi, 0, 1, 1, 1, 0, 1, 1, maxLev, true);\n  const mk = s.mk;\n  for (let i = 0; i \u003c mk.length; i += 4) {\n    const rel = mk[i + 2] - P.A * z, w = cl(D + 1 - rel, 0, 1);\n    if (w \u003c= 0) continue;\n    const px = floor(sx(mk[i]) * W), py = round(row(ry(mk[i + 1])));\n    if (px \u003c 0 || px >= W) continue;\n    const path = mk[i + 3] === 1;\n    // A dyadic line from the left edge to its fraction, above the stair,\n    // and a cut down through the fill under it. Like the ticks of a ruler,\n    // the deeper the level the fainter both are.\n    const tick = w * (1 - 0.65 * cl((rel - 1) / max(1, D - 1), 0, 1));\n    if (py >= GT && py \u003c= GB) {\n      for (let x = 0; x \u003c px; x++) add(x, py, path ? 21 : 9, tick);\n      for (let y = py + 2; y \u003c= GB; y++) {\n        const i3 = (y * W + px) * 3;\n        B[i3] *= 1 - 0.7 * tick;\n        B[i3 + 1] *= 1 - 0.7 * tick;\n        B[i3 + 2] *= 1 - 0.7 * tick;\n      }\n      const o = path ? 12 : 6;\n      add(px, py, o, w);\n      if (rel \u003c D - 1.5) add(px, py - 1, o, 0.6 * w), add(px + 1, py, o, 0.6 * w), add(px - 1, py, o, 0.6 * w), add(px, py + 1, o, 0.4 * w);\n    }\n  }\n\n  // The point itself, fixed at the centre of the zoom.\n  const qx = floor(P.x0 * W), qy = round(row(P.y0));\n  for (let dy = -2; dy \u003c= 2; dy++)\n    for (let dx = -2; dx \u003c= 2; dx++) {\n      const x = qx + dx, y = qy + dy;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const i3 = (y * W + x) * 3, ring = max(abs(dx), abs(dy)) === 2 && abs(dx) + abs(dy) \u003c 4;\n      B[i3] *= 0.15;\n      B[i3 + 1] *= 0.15;\n      B[i3 + 2] *= 0.15;\n      if (ring) add(x, y, 12, 1);\n    }\n  add(qx, qy, 3, 1.5);\n\n  // Underneath: the continued fraction as blocks a_k cells wide, and the\n  // binary digits of ?(x0) as cells, noughts dim and ones bright. Each block\n  // sits over the run of bits it becomes, so a gap in the top bar falls\n  // wherever the bits below change. Both scroll A cells a loop and the\n  // digits repeat every A cells, so the loop has no seam.\n  const bits = P.bits, L = bits.length, off = round(P.A * z * CELL);\n  for (let x = 0; x \u003c W; x++) {\n    const q = x + off, k = floor(q / CELL) % L, e = q % CELL, bit = bits[k];\n    const last = e === CELL - 1, runEnd = last && bits[(k + 1) % L] !== bit, o = bit ? 18 : 15;\n    if (!runEnd) for (let y = BAR1; y \u003c BAR1 + 7; y++) add(x, y, o, y === BAR1 || y === BAR1 + 6 ? 0.95 : 0.4);\n    if (!last) for (let y = BAR2; y \u003c BAR2 + 6; y++) add(x, y, o, bit ? 1 : 0.25);\n  }\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, min(255, round(B[p] * 255)), min(255, round(B[p + 1] * 255)), min(255, round(B[p + 2] * 255)));\n}\n","tissot-indicatrix":"// ===== Patternflow pattern =====\n// Title:   Tissot's Indicatrix\n// Family:  space\n// Idea:    A lattice of equal small circles on a turning sphere, each drawn as the ellipse a map projection makes of it: on Mercator they stay circles but swell towards the top and bottom edges, the row at 80 degrees nearly six times as wide as the equator's, and as the projection blends into an equal-area one the same circles flatten into ellipses that all cover the same area and turn one colour.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Tissot's indicatrix (Nicolas Auguste Tissot, 1859) on the Mercator projection (Gerardus Mercator, 1569) and Lambert's cylindrical equal-area projection (Johann Heinrich Lambert, 1772), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tilt=25..90, Blend=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a circle is cyan at its smallest (the Mercator equator), azure where it covers three times that, violet at 14 times (latitude 75 on Mercator) and pink-magenta from 42 times (latitude 81); its outline is a paler tint of the same colour and the graticule is a dim mauve. The wheel leaves out orange and yellow, which read brown and olive in the dim fills.\n// Knob 2: Speed. How fast the sphere turns about its own axis: at 2 ten degrees a second, a whole turn in 36 s and a circle across the 180 degrees of the panel in 18 s. At 0.2 one degree a second, at 3 fifteen.\n// Knob 3: Tilt. How far the projection's axis leans from the sphere's, in degrees. It opens at 25: the sphere's pole sits just inside the top edge with the meridians fanning out from it, the circles travel on curved paths, and each one swells as its path carries it towards the top or bottom edge and shrinks back. The normal aspect, where the circles only glide sideways in nine rows, would be 0; the knob stops at 25 so the panel opens on circles that change size as they move. At 90 the transverse aspect: the pole sits at the centre and the circles wheel round it. On Mercator a circle's size depends only on its height on the map, so at every tilt the rows near the top and bottom edge are the ones at 14 LEDs in radius against 2.5 in the middle.\n// Knob 4: Blend. The projection's height, blended from Mercator at 0 to the equal-area cylindrical projection that fits the same box at 1, whose standard parallels are at 55.7 degrees. At 1 a circle on the equator is three times as tall as wide and one at 80 degrees ten times as wide as tall, and every one covers 61 square LEDs; on Mercator they run from 19 to 650. It opens at 0.06, nearly all Mercator.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, atan2, log, tan, PI } = Math;\nconst TAU = 2 * PI, DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// 180 degrees of longitude across, so 64 / pi LEDs to the radian, and\n// Mercator's y = ln tan(pi/4 + phi/2) from -pi to pi down the 128 rows:\n// y reaches pi at 85.0511 degrees, the cut Web Mercator makes for its\n// square world, and the box is exactly 1:2.\nconst SC = W / PI, PHIMAX = 2 * Math.atan(Math.exp(PI)) - PI / 2, SMAX = sin(PHIMAX);\n// The circles' geodesic radius, and h * k of the equal-area map, in LEDs\n// squared per steradian.\nconst RAD = 7 * DEG, HKEA = (SC * W) / SMAX;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel from lime round through blue and magenta to red, without the\n// orange and yellow that turn brown and olive when dim.\nconst wheel = (f) => 0.22 + 0.8 * (f - floor(f));\n\n// Circle centres: rows every 20 degrees of latitude, each with as many\n// circles as fit 20 degrees apart round it, odd rows shifted half a step.\n// No two centres are closer than 19.7 degrees, so the 7-degree circles\n// never touch. The poles are left out: they are 10 degrees from the 80 row.\nconst CL = [];\nfor (let r = -4; r \u003c= 4; r++) {\n  const lat = r * 20 * DEG, n = Math.round(18 * cos(lat));\n  for (let k = 0; k \u003c n; k++) CL.push([lat, ((k + (r & 1 ? 0.5 : 0)) / n) * TAU]);\n}\nconst NC = CL.length;\n\nexport function setup(params) {\n  params.s = { spin: 0, hue: 0, speed: 2, tilt: 25 * DEG, blend: 0.06, rgb: new Float32Array(W * H * 3), col: new Float64Array(3), o: [0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 25, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.tilt = cl(kv[2], 25, 90) * DEG;\n  S.blend = cl(kv[3], 0, 1);\n  S.spin = (S.spin + d * S.speed * 5 * DEG) % TAU;\n}\n\n// A point of the sphere, turned about the sphere's axis, then seen in the\n// projection's frame, whose axis leans from the sphere's by the tilt\n// towards the middle of the panel: o gets latitude and longitude there.\nfunction rot(S, lat, lon, o) {\n  const cp = cos(lat), x0 = cp * cos(lon + S.spin), y0 = cp * sin(lon + S.spin), z0 = sin(lat);\n  const ct = cos(S.tilt), st = sin(S.tilt);\n  o[0] = asin(cl(-x0 * st + z0 * ct, -1, 1));\n  o[1] = atan2(y0, x0 * ct + z0 * st);\n}\n// Height above the middle row, in LEDs: Mercator blended into the\n// equal-area map scaled to the same box.\nconst yOf = (b, phi) => (1 - b) * SC * log(tan(PI / 4 + phi / 2)) + (b * W * sin(phi)) / SMAX;\n\n// Lines are laid as points, each lighting its four nearest LEDs by how\n// close it falls; an LED keeps the brightest.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\n\n// A graticule line, sampled along the sphere and joined on the panel. A\n// join is skipped where the line leaves the visible half or the cut.\nfunction gratLine(S, c, lat0, lon0, lat1, lon1, steps) {\n  const o = S.o, b = S.blend;\n  let px = 0, py = 0, ok = false;\n  for (let k = 0; k \u003c= steps; k++) {\n    const u = k / steps;\n    rot(S, lat0 + (lat1 - lat0) * u, lon0 + (lon1 - lon0) * u, o);\n    const inside = abs(o[0]) \u003c PHIMAX + 0.02 && abs(o[1]) \u003c PI / 2 + 0.05;\n    const x = W / 2 + SC * o[1], y = H / 2 - yOf(b, cl(o[0], -1.55, 1.55));\n    if (inside && ok && abs(x - px) + abs(y - py) \u003c 20) {\n      const m = Math.ceil(Math.hypot(x - px, y - py) * 2.5) || 1;\n      for (let e = 1; e \u003c= m; e++) plot(S, px + ((x - px) * e) / m, py + ((y - py) * e) / m, c, 1);\n    }\n    (px = x), (py = y), (ok = inside);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, col = S.col, b = S.blend, o = S.o;\n  rgb.fill(0);\n  // The sphere's graticule every 30 degrees, and its poles.\n  const gc = [0, 0, 0];\n  hsv(wheel(0.85 + S.hue), 0.3, 0.32, gc);\n  for (let k = 0; k \u003c 12; k++) gratLine(S, gc, -PI / 2, k * 30 * DEG, PI / 2, k * 30 * DEG, 360);\n  for (let k = -2; k \u003c= 2; k++) gratLine(S, gc, k * 30 * DEG, 0, k * 30 * DEG, TAU, 720);\n  for (const lat of [PI / 2, -PI / 2]) {\n    rot(S, lat, 0, o);\n    if (abs(o[0]) \u003c PHIMAX && abs(o[1]) \u003c PI / 2) plot(S, W / 2 + SC * o[1], H / 2 - yOf(b, o[0]), [0.85, 0.85, 0.85], 1);\n  }\n  // Each circle as its indicatrix: a cylindrical map keeps meridians and\n  // parallels square, so the ellipse lies along the panel's axes with\n  // semi-axes r k across and r h up, k = SC / cos phi along the parallel\n  // and h = dy/dphi along the meridian. On Mercator h = k.\n  for (let i = 0; i \u003c NC; i++) {\n    rot(S, CL[i][0], CL[i][1], o);\n    const ph = o[0], la = o[1];\n    if (abs(ph) > PHIMAX || abs(la) > PI / 2 + 0.3) continue;\n    const cp = cos(ph), k = SC / cp, h = ((1 - b) * SC) / cp + (b * W * cp) / SMAX;\n    const A = RAD * k, B = RAD * h, cx = W / 2 + SC * la, cy = H / 2 - yOf(b, ph);\n    // The colour is h k against the equal-area map's, on a log scale from\n    // the Mercator equator's 0.32 up to 13.5.\n    const tn = cl((log((h * k) / HKEA) + 1.15) / 3.75, 0, 1);\n    hsv(wheel(0.35 + 0.44 * tn + S.hue), 0.7, 1, col);\n    // A circle fades over the last 4 degrees before the cut, where it is\n    // about 20 LEDs across on Mercator, so it does not drop out whole.\n    const fade = cl((PHIMAX - abs(ph)) / (4 * DEG), 0, 1);\n    const lr = 0.55 + 0.45 * col[0], lg = 0.55 + 0.45 * col[1], lb = 0.55 + 0.45 * col[2];\n    const x0 = max(0, floor(cx - A - 1)), x1 = min(W - 1, floor(cx + A + 1)), y0 = max(0, floor(cy - B - 1)), y1 = min(H - 1, floor(cy + B + 1));\n    for (let yy = y0; yy \u003c= y1; yy++)\n      for (let xx = x0; xx \u003c= x1; xx++) {\n        // Distance to the outline in LEDs, to first order: (rho - 1) / |grad rho|.\n        const qx = (xx + 0.5 - cx) / A, qy = (yy + 0.5 - cy) / B, r2 = qx * qx + qy * qy, r = sqrt(r2) || 1e-9;\n        const dist = (r - 1) / (sqrt((qx / A) ** 2 + (qy / B) ** 2) / r || 1);\n        const line = cl(1 - abs(dist) / 0.8, 0, 1), fill = dist \u003c 0 ? cl(-dist, 0, 1) * (0.16 + 0.14 * (1 - r2)) : 0;\n        const v = max(line, fill) * fade;\n        if (v \u003c= 0) continue;\n        const p = (yy * W + xx) * 3, pale = line > fill;\n        const cr = (pale ? lr : col[0]) * v, cg = (pale ? lg : col[1]) * v, cb = (pale ? lb : col[2]) * v;\n        if (rgb[p] \u003c cr) rgb[p] = cr;\n        if (rgb[p + 1] \u003c cg) rgb[p + 1] = cg;\n        if (rgb[p + 2] \u003c cb) rgb[p + 2] = cb;\n      }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","toussaint-wilczek":"// ===== Patternflow pattern =====\n// Title:   Toussaint-Wilczek\n// Family:  particle\n// Idea:    Two species of random walkers sprinkled evenly over the panel annihilate wherever they meet, and the chance surplus of one or the other in each patch survives as green and magenta domains that grow like the square root of time behind dark fizzing seams.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: diffusion-limited annihilation A + B -> 0 (A. A. Ovchinnikov and Ya. B. Zeldovich, 1978; Doug Toussaint and Frank Wilczek, 1983), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Density=80..320, Excess=0..1\n//\n// Knob 1: Hue. Turns both species round the wheel together, B always 0.47 of a turn from A. At 0 A is spring green and B magenta; at 0.25 blue and orange; at 0.6 red and aquamarine. The dim glow of each domain behind its walkers skips the orange and yellow part of the wheel, which reads brown and olive when dark.\n// Knob 2: Speed. Hops a second for every walker, 4 for each unit: 8 at 2, 0.8 at 0.2, 12 at 3. The panel is sprinkled again after 100 hops, every 12.5 seconds at 2, so the 2 to 8 second window sees hops 16 to 64, where a row crosses a domain in 16 LEDs on average at the start and 29 at the end, the square root of four times the hops.\n// Knob 3: Density. How many A and how many B each LED gets at the sprinkle, as Poisson means, from 80 to 320. Most cancel on the spot and about 10 a LED are left at 80 (20 at 320). The domains grow at the same pace at any Density, and only their fill changes: after 40 hops 0.71 walkers a LED are left at 80 and 1.40 at 320, the square root of four times as many, and 45% or 64% of the LEDs hold one.\n// Knob 4: Excess. A surplus of A over B at the sprinkle, 1.6 x knob^2 a LED: 0.006 at the opening 0.06, 47 walkers on the whole panel, 0.4 at 0.5 and 1.6 at 1. The surplus never cancels, so the magenta minority dies out while the green fills in: at 1 the 2,011 B left after 8 hops are 4 after 96, and at 0.5 the 4,881 are 556.\n// Buttons: K1 tap sprinkles the panel afresh.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Hops per walker per second at Speed 1. At 8 hops a second the 2 to 8\n// second window spans hops 16 to 64, where the LEDs holding a walker fall\n// from 59% to 39%: dense enough to read every domain, sparse enough that\n// the seams between them are already dark.\nconst RATE = 4;\n// Hops per walker before the panel is sprinkled again. By 100 a row\n// crosses a domain in 37 LEDs on average, on a panel 64 wide, and the\n// walls start to set the domains' size instead of the walk.\nconst LIFE = 100;\n// Hue of species A at knob 0; B sits opposite.\nconst HUE_A = 0.38;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the glow's hue wheel skips\n// 0.03..0.18 and runs the rest a little faster.\nconst glowHue = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  let seed = (Math.random() * 4294967296) >>> 0 || 1;\n  params.s = {\n    // Signed count per LED: A is positive, B negative. An A and a B on one\n    // LED cancel at once, so a sign says which species is there.\n    m: new Int32Array(N), pos: new Int32Array(N), neg: new Int32Array(N),\n    spark: new Float32Array(N), glow: new Float32Array(N), tmp: new Float32Array(N),\n    hops: 0, hue: 0, speed: 2, n0: 80, ex: 0.06, born: false, extinct: 0,\n    rnd: () => {\n      seed ^= seed \u003c\u003c 13;\n      seed ^= seed >>> 17;\n      seed ^= seed \u003c\u003c 5;\n      return seed >>> 0;\n    },\n    pal: new Float32Array(24), palHue: -1, rgb: new Float32Array(N * 3),\n  };\n}\n\n// A Poisson count, by its normal: the means here are 80 and up.\nfunction poisson(S, l) {\n  const u = (S.rnd() + 1) / 4294967297, v = S.rnd() / 4294967296;\n  return max(0, floor(l + sqrt(l) * sqrt(-2 * log(u)) * cos(2 * PI * v) + 0.5));\n}\n\n// Every LED gets a Poisson number of A and of B; what is left after they\n// cancel on the spot is the starting field. Its sign is white noise, and\n// the walk smooths it: a patch L LEDs wide keeps a surplus of about L times\n// the square root of the Density, so the density left falls as one over\n// the square root of the hops (Toussaint and Wilczek's t^(-d/4) in two\n// dimensions), not as one over the hops the well-stirred rate law gives.\n// Over 5 to 80 hops it fell with exponent -0.49 at Density 80.\nfunction sprinkle(S) {\n  const d = 1.6 * S.ex * S.ex;\n  let sum = 0;\n  for (let i = 0; i \u003c N; i++) sum += S.m[i] = poisson(S, S.n0) - poisson(S, S.n0);\n  // The two species start exactly level, or level but for the Excess: a\n  // chance surplus over the whole panel would hand it to one colour within\n  // seconds. Each correction adds or cancels one particle on a random LED.\n  for (let k = Math.round(d * N) - sum, s = k > 0 ? 1 : -1; k !== 0; k -= s) S.m[S.rnd() % N] += s;\n  S.hops = 0;\n  S.extinct = 0;\n  S.spark.fill(0);\n}\n\n// One sub-step: each walker hops to a random neighbour with chance p, the\n// walls reflect, and opposite signs arriving on one LED annihilate in pairs.\n// The signed sum is the whole reaction; the spark marks where it happened.\nfunction step(S, p) {\n  const { m, pos, neg, spark } = S;\n  pos.fill(0);\n  neg.fill(0);\n  const P = floor(p * 1073741824);\n  let nA = 0, nB = 0;\n  for (let y = 0, i = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, i++) {\n      let k = m[i];\n      if (!k) continue;\n      const to = k > 0 ? pos : neg;\n      k = abs(k);\n      if (m[i] > 0) nA += k;\n      else nB += k;\n      for (let j = 0; j \u003c k; j++) {\n        const r = S.rnd();\n        if (r >>> 2 >= P) {\n          to[i]++;\n          continue;\n        }\n        const d = r & 3;\n        let xx = x, yy = y;\n        if (d === 0) xx = x + 1 \u003c W ? x + 1 : x - 1;\n        else if (d === 1) xx = x > 0 ? x - 1 : x + 1;\n        else if (d === 2) yy = y + 1 \u003c H ? y + 1 : y - 1;\n        else yy = y > 0 ? y - 1 : y + 1;\n        to[yy * W + xx]++;\n      }\n    }\n  for (let i = 0; i \u003c N; i++) {\n    const a = pos[i], b = neg[i];\n    m[i] = a - b;\n    if (a && b) spark[i] = 1;\n  }\n  S.nA = nA;\n  S.nB = nB;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 80, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.n0 = cl(kv[2], 80, 320);\n  S.ex = cl(kv[3], 0, 1);\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (!S.born || tap || S.hops > LIFE || S.extinct > 40) {\n    sprinkle(S);\n    S.born = true;\n  }\n  // Hops this frame, split into sub-steps of at most one hop each, so a walker\n  // moves on some frames and not others instead of jumping two LEDs.\n  const want = d * S.speed * RATE, n = Math.ceil(want - 1e-9);\n  for (let k = 0; k \u003c n; k++) step(S, want / n);\n  S.hops += want;\n  if (!S.nA || !S.nB) S.extinct += want;\n  for (let i = 0; i \u003c N; i++) S.spark[i] *= exp(-d * 3.5);\n  // The glow: the signed field blurred by two box passes of radius 2, scaled\n  // by its own spread so it holds its brightness while the walkers thin out.\n  const { m, glow, tmp } = S;\n  for (let i = 0; i \u003c N; i++) glow[i] = m[i];\n  for (let pass = 0; pass \u003c 2; pass++) {\n    for (let y = 0; y \u003c H; y++) {\n      let acc = 0;\n      const o = y * W;\n      for (let x = -2; x \u003c= 2; x++) acc += glow[o + cl(x, 0, W - 1)];\n      for (let x = 0; x \u003c W; x++) {\n        tmp[o + x] = acc / 5;\n        acc += glow[o + min(W - 1, x + 3)] - glow[o + max(0, x - 2)];\n      }\n    }\n    for (let x = 0; x \u003c W; x++) {\n      let acc = 0;\n      for (let y = -2; y \u003c= 2; y++) acc += tmp[cl(y, 0, H - 1) * W + x];\n      for (let y = 0; y \u003c H; y++) {\n        glow[y * W + x] = acc / 5;\n        acc += tmp[min(H - 1, y + 3) * W + x] - tmp[max(0, y - 2) * W + x];\n      }\n    }\n  }\n  let ss = 0;\n  for (let i = 0; i \u003c N; i++) ss += glow[i] * glow[i];\n  S.rms = sqrt(ss / N) || 1;\n}\n\nfunction palette(S) {\n  const P = S.pal, h = HUE_A + S.hue;\n  hsv(h, 0.8, 1, P, 0); // A particle\n  hsv(h + 0.47, 0.75, 1, P, 3); // B particle\n  hsv(glowHue(h), 0.85, 1, P, 6); // A glow\n  hsv(glowHue(h + 0.47), 0.85, 1, P, 9); // B glow\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { m, glow, spark, pal: P, rgb } = S;\n  const inv = 1 / (1.6 * S.rms);\n  for (let i = 0, o = 0; i \u003c N; i++, o += 3) {\n    const k = m[i];\n    if (k) {\n      const c = k > 0 ? 0 : 3, a = abs(k), L = a === 1 ? 0.93 : a === 2 ? 0.97 : 1;\n      rgb[o] = P[c] * L;\n      rgb[o + 1] = P[c + 1] * L;\n      rgb[o + 2] = P[c + 2] * L;\n      continue;\n    }\n    // Gaps stay dark against the walkers, which keeps the speckle sharp; a\n    // gap next to walkers lifts a little, so steps between gaps are soft.\n    const x = i % W, nb = (x + 1 \u003c W && m[i + 1] ? 1 : 0) + (x > 0 && m[i - 1] ? 1 : 0) + (i + W \u003c N && m[i + W] ? 1 : 0) + (i >= W && m[i - W] ? 1 : 0);\n    const g = glow[i] * inv, c = g > 0 ? 6 : 9, a = min(1, abs(g)) * 0.2 + 0.01 + 0.01 * nb, sp = spark[i] * 0.45;\n    rgb[o] = P[c] * a + sp;\n    rgb[o + 1] = P[c + 1] * a + sp;\n    rgb[o + 2] = P[c + 2] * a + sp;\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * min(1, rgb[o])) | 0, (255 * min(1, rgb[o + 1])) | 0, (255 * min(1, rgb[o + 2])) | 0);\n}\n","universal-cover":"// ===== Patternflow pattern =====\n// Title:   Universal Cover\n// Family:  topology\n// Idea:    A dot loops round a figure-eight at the foot of the panel, one loop a step, while its lift walks the four-way tree above that covers it, the fractal cross of the free group on a and b; the view re-roots on the lift every step so the tree slides and regrows round it, and the reduced word, drawn back to the root and spelled in a strip of blocks, grows by half a letter a step unless Return pulls the lift home.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: universal cover of the figure-eight, the Cayley graph of the free group F2 (Henri Poincaré, 1895; Max Dehn, 1910), with the escape of random walk on the free group (Harry Kesten, 1959), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Return=0.25..0.85, Depth=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the letter a, the left loop and every horizontal edge, is aqua and b, the right loop and every vertical edge, is magenta; the word's path runs in pale tints of the two, the dot and its lift are white and the root wears a gold ring. At 0.25 a is blue and b red, at 0.5 a pink and b aqua, at 0.75 a green and b blue. The wheel skips orange, yellow and lime, which read brown and olive on the dim outer branches.\n// Knob 2: Speed. At 2 a step, one loop of the figure-eight below and one edge of the tree above, takes 0.75 s. The lift leaves first and the view follows a quarter of a step behind, so the lift runs up to a quarter of its edge ahead of the centre, 4 LEDs on an a edge and 5.6 on a b edge, before the tree slides under it. Every vertex of the tree lies over the wedge point, and all of them blink as the dot passes it. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Return. The chance a step cancels the word's last letter and sends the lift back towards the root; the other three letters share the rest, and from the root all four lead away. At 0.25 that is the simple random walk, every letter equally likely: the word grows by half a letter a step, Kesten's escape speed, and was 50.2 letters long after 100 steps (mean of 300 runs). At 0.5 the length is a fair coin's walk, 8.3 letters after 100 steps; at 0.6 it averages 2.5, and at 0.85 the lift sits on the root 41% of the time and the word averages 0.71 letters.\n// Knob 4: Depth. How many levels of the tree are drawn round the lift, 4 + 2.5 x Depth, from 1.5 to 6.5, the last one fading in. The lift's own edges lengthen as levels drop so the drawing stays 60 LEDs wide: an a edge is 23 LEDs at -1, 15.9 at the opening 0.06 and 15.2 at 1, and a b edge 1.4 times that. Each level halves the edge and dims it by a fifth.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, exp, cos, sin, PI, LN2 } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (t) => t * t * (3 - 2 * t);\n// Letters: 0 a, 1 a^-1, 2 b, 3 b^-1; the inverse of l is l ^ 1. a runs right\n// in the tree, b runs up.\nconst DX = [1, -1, 0, 0], DY = [0, 0, -1, 1];\n// The tree's centre, how much longer a b edge is drawn than an a edge, the\n// strip that spells the word, and the figure-eight's wedge point and radius.\nconst TX = 32, TY = 43, KB = 1.4, WY = 88, BX = 32, BY = 110, BR = 14.5;\n// Seconds a step takes at Speed 2.\nconst STEP = 0.75;\nconst WHITE = [1, 1, 1];\nconst HUE_A = 0.276, HUE_B = 0.73;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel skips orange, yellow and lime, which read brown and olive on\n// the dim outer branches.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, ret: 0.25, depth: 0, L0: 15, levels: 4,\n    word: [], x: 0, back: false, t: 0, steps: 0, at: 1,\n    rgb: new Float32Array(N * 3), col: new Float32Array(12), c: 0, w: 0,\n  };\n  next(params.s);\n}\n\n// The next step: back along the word's last letter with chance Return, or\n// on along one of the other three. From the root all four lead away.\nfunction next(S) {\n  const word = S.word, last = word.length ? word[word.length - 1] : -1;\n  if (last >= 0 && Math.random() \u003c S.ret) S.x = last ^ 1;\n  else {\n    const k = floor(Math.random() * (last >= 0 ? 3 : 4));\n    let l = 0;\n    for (let seen = -1; ; l++) if (l !== (last ^ 1) || last \u003c 0) if (++seen === k) break;\n    S.x = l;\n  }\n  S.back = last >= 0 && S.x === (last ^ 1);\n  S.t = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.25, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.ret = cl(kv[2], 0.25, 0.85);\n  S.depth = cl(kv[3], -1, 1);\n  // Levels of the tree drawn round the lift, the last one fading in.\n  S.levels = 4 + 2.5 * S.depth;\n  // The lift's own edges are as long as keeps the drawn tree 60 LEDs wide:\n  // the levels add up to 2 - 2^(1 - levels) edges each way.\n  S.L0 = 30 / (2 - Math.pow(2, 1 - S.levels));\n  S.t += (d * S.speed) / 2 / STEP;\n  if (S.t >= 1) {\n    if (S.back) S.word.pop();\n    else S.word.push(S.x);\n    S.steps++;\n    next(S);\n  }\n  // The dot and its lift ease out of the wedge point and into the next\n  // node; the view follows a little behind.\n  S.w = ss(cl(S.t, 0, 1));\n  S.c = ss(cl((S.t - 0.25) / 0.75, 0, 1));\n  // Near either end of a step the dot is at the wedge point and the lift\n  // at a vertex.\n  S.at = exp(-min(S.t, 1 - S.t) / 0.07);\n}\n\n// The tree stops above the strip, so a zoomed-in tree never runs over\n// the figure-eight.\nlet YMAX = H;\nfunction plot(rgb, x, y, c, o, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= YMAX) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.8) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[o] * w) rgb[p] = c[o] * w;\n      if (rgb[p + 1] \u003c c[o + 1] * w) rgb[p + 1] = c[o + 1] * w;\n      if (rgb[p + 2] \u003c c[o + 2] * w) rgb[p + 2] = c[o + 2] * w;\n    }\n  }\n}\nfunction seg(rgb, xa, ya, xb, yb, c, o, a) {\n  if (max(xa, xb) \u003c -1 || min(xa, xb) > W + 1 || max(ya, yb) \u003c -1 || min(ya, yb) > H + 1) return;\n  const n = Math.ceil(Math.hypot(xb - xa, yb - ya) * 3) || 1;\n  for (let e = 0; e \u003c= n; e++) plot(rgb, xa + ((xb - xa) * e) / n, ya + ((yb - ya) * e) / n, c, o, a);\n}\n\n// The tree drawn from u, the node the lift leaves. An edge is drawn\n// L0 / 2^e long, e being its nearer end's distance from the root of the\n// view: from u at the start of a step and from v at the end, so e slides\n// from d to d - 1 on v's side and to d + 1 elsewhere while the view\n// follows. The edge from u to v keeps e = 0.\nfunction grow(S, rgb, x, y, d, inV, last) {\n  const c = S.c, L0 = S.L0, col = S.col;\n  for (let l = 0; l \u003c 4; l++) {\n    if (last >= 0 && l === (last ^ 1)) continue;\n    const e = d === 0 ? (l === S.x ? 0 : c) : inV ? d - c : d + c;\n    const len = L0 * exp(-e * LN2) * (l >= 2 ? KB : 1);\n    if (e >= S.levels || len \u003c 0.5) continue;\n    const nx = x + DX[l] * len, ny = y + DY[l] * len;\n    const a = Math.pow(0.8, e) * cl(len / 2, 0.3, 1) * cl(S.levels - e, 0, 1);\n    // Edges near the lift are drawn up to two LEDs wide.\n    const half = e \u003c 1 ? 0.45 * (1 - e) : 0;\n    if (half > 0.05) {\n      const ox = l >= 2 ? half : 0, oy = l >= 2 ? 0 : half;\n      seg(rgb, x - ox, y - oy, nx - ox, ny - oy, col, l >= 2 ? 3 : 0, a);\n      seg(rgb, x + ox, y + oy, nx + ox, ny + oy, col, l >= 2 ? 3 : 0, a);\n    } else seg(rgb, x, y, nx, ny, col, l >= 2 ? 3 : 0, a);\n    // Every vertex lies over the wedge point, and they all blink as the\n    // dot passes it.\n    if (S.at > 0.03 && len > 1.2) plot(rgb, nx, ny, WHITE, 0, S.at * a * 1.2);\n    grow(S, rgb, nx, ny, d + 1, d === 0 ? l === S.x : inV, l);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, col = S.col, L0 = S.L0, x = S.x;\n  rgb.fill(0);\n  const hA = wheel(HUE_A + S.hue), hB = wheel(HUE_B + S.hue);\n  hsv(hA, 0.8, 1, col, 0); // a edges\n  hsv(hB, 0.75, 1, col, 3); // b edges\n  hsv(hA, 0.35, 1, col, 6); // a on the word's path\n  hsv(hB, 0.3, 1, col, 9); // b on the word's path\n  // u sits back from the centre by the share of its edge to v that the\n  // view has covered.\n  const luv = L0 * (x >= 2 ? KB : 1);\n  const ux = TX - DX[x] * luv * S.c, uy = TY - DY[x] * luv * S.c;\n  YMAX = WY - 2;\n  grow(S, rgb, ux, uy, 0, false, -1);\n\n  // The reduced word, drawn back from u to the root. On a step that\n  // cancels the last letter the edge to v is that letter, and it goes out\n  // behind the lift as the lift runs down it.\n  const word = S.word, m = word.length;\n  let px = ux, py = uy, rootSeen = 0;\n  for (let j = m - 1, dd = 0; j >= 0; j--, dd++) {\n    const l = word[j] ^ 1, inV = dd === 0 ? l === x : (word[m - 1] ^ 1) === x;\n    const e = dd === 0 ? (l === x ? 0 : S.c) : inV ? dd - S.c : dd + S.c;\n    const len = L0 * exp(-e * LN2) * (l >= 2 ? KB : 1);\n    let sx = px, sy = py;\n    if (dd === 0 && S.back) (sx = px + DX[l] * len * S.w), (sy = py + DY[l] * len * S.w);\n    const nx = px + DX[l] * len, ny = py + DY[l] * len;\n    for (const r of [-0.5, 0.5]) {\n      const ox = l >= 2 ? r : 0, oy = l >= 2 ? 0 : r;\n      seg(rgb, sx + ox, sy + oy, nx + ox, ny + oy, col, l >= 2 ? 9 : 6, 1);\n    }\n    (px = nx), (py = ny);\n    if (len \u003c 0.3) break;\n    if (j === 0) rootSeen = cl(len / 2, 0, 1);\n  }\n  if (m === 0) rootSeen = 1;\n  // The step itself: on a step away from the root the word gains x, drawn\n  // out behind the lift.\n  const lx = ux + DX[x] * luv * S.w, ly = uy + DY[x] * luv * S.w;\n  if (!S.back)\n    for (const r of [-0.5, 0.5]) {\n      const ox = x >= 2 ? r : 0, oy = x >= 2 ? 0 : r;\n      seg(rgb, ux + ox, uy + oy, lx + ox, ly + oy, col, x >= 2 ? 9 : 6, 1);\n    }\n  const gold = [1, 0.93, 0.7];\n  // The root, the identity, while it is near enough to see.\n  if (rootSeen > 0) {\n    const rx = m === 0 ? ux : px, ry = m === 0 ? uy : py;\n    for (let k = 0; k \u003c 24; k++) plot(rgb, rx + 2.6 * cos((TAU * k) / 24), ry + 2.6 * sin((TAU * k) / 24), gold, 0, rootSeen);\n  }\n  // The lift.\n  for (let yy = -3; yy \u003c= 3; yy++)\n    for (let xx = -3; xx \u003c= 3; xx++) if (Math.hypot(xx, yy) \u003c= 2.6) plot(rgb, lx + xx * 0.6, ly + yy * 0.6, WHITE, 0, 1);\n  YMAX = H;\n\n  // The word as a strip, oldest letter at the left: a in its colour, b in\n  // its own, the inverses at half strength. Past 16 letters the start slides off.\n  const shown = S.back ? m - S.w : m + (S.t > 0 ? S.w : 0);\n  const total = Math.ceil(shown), first = max(0, total - 16);\n  for (let j = first; j \u003c total; j++) {\n    const l = j \u003c m ? word[j] : x, a = j \u003c shown - 1 ? 1 : shown - j;\n    const bright = (l & 1 ? 0.45 : 1) * a, o = l >= 2 ? 9 : 6;\n    const x0 = 1 + (j - first) * 4;\n    for (let yy = WY; yy \u003c WY + 3; yy++)\n      for (let xx = x0; xx \u003c x0 + 3; xx++) {\n        const p = (yy * W + xx) * 3;\n        for (let k = 0; k \u003c 3; k++) rgb[p + k] = max(rgb[p + k], col[o + k] * bright);\n      }\n  }\n\n  // The figure-eight: loop a on the left, loop b on the right, both run\n  // anticlockwise from the wedge point, and the dot goes round the loop of\n  // this step's letter, backwards for an inverse.\n  for (let k = 0; k \u003c 200; k++) {\n    const th = (TAU * k) / 200;\n    plot(rgb, BX - BR + BR * cos(th), BY - BR * sin(th), col, 0, 0.7);\n    plot(rgb, BX + BR - BR * cos(th), BY + BR * sin(th), col, 3, 0.7);\n  }\n  // Arrowheads at the tops of the loops show which way the letter runs.\n  for (const side of [-1, 1]) {\n    const cx = BX + side * BR, ty = BY - BR, o = side \u003c 0 ? 0 : 3;\n    for (let k = 1; k \u003c= 3; k++) {\n      plot(rgb, cx - 1.2 + k, ty - k * 0.9, col, o, 0.9);\n      plot(rgb, cx - 1.2 + k, ty + k * 0.9, col, o, 0.9);\n    }\n  }\n  const loopA = x \u003c 2, sgn = x & 1 ? -1 : 1, o = loopA ? 6 : 9;\n  const at = (u) => {\n    const th = sgn * TAU * u;\n    return loopA ? [BX - BR + BR * cos(th), BY - BR * sin(th)] : [BX + BR - BR * cos(th), BY + BR * sin(th)];\n  };\n  const steps = floor(S.w * 120);\n  for (let k = 0; k \u003c= steps; k++) {\n    const u = (k / 120), [qx, qy] = at(u);\n    plot(rgb, qx, qy, col, o, 0.35 + 0.65 * (u / max(S.w, 1e-3)));\n  }\n  if (S.at > 0.03) for (let k = 0; k \u003c 28; k++) plot(rgb, BX + 3.4 * cos((TAU * k) / 28), BY + 3.4 * sin((TAU * k) / 28), WHITE, 0, S.at);\n  const [dx, dy] = at(S.w);\n  for (let yy = -3; yy \u003c= 3; yy++)\n    for (let xx = -3; xx \u003c= 3; xx++) if (Math.hypot(xx, yy) \u003c= 2.6) plot(rgb, dx + xx * 0.6, dy + yy * 0.6, WHITE, 0, 1);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let xx = 0; xx \u003c W; xx++, p += 3) display.setPixel(xx, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","vortex-sheet":"// ===== Patternflow pattern =====\n// Title:   Vortex Sheet\n// Family:  sim\n// Idea:    A vortex sheet runs up the panel between a stream flowing down on its left and one flowing up on its right, and a small ripple on it grows and rolls up into a double-branched spiral that winds the two fluids into each other in thinner and thinner layers.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kelvin-Helmholtz instability of a vortex sheet (Hermann von Helmholtz, 1868; Lord Kelvin, 1871), computed past Moore's curvature singularity (Derek Moore, 1979) with Robert Krasny's vortex-blob method (1986), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Blob=0.15..0.5, Waves=1..4\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the left stream is dark teal with azure tracers, the right one dark violet with magenta tracers, and the sheet pale lavender; at 0.25 indigo and maroon with a pink sheet; at 0.5 maroon and green with a pale yellow one. The dark streams skip the orange and yellow part of the wheel, which reads brown and olive when dim.\n// Knob 2: Speed. At 2 each stream runs 22 LEDs a second at one wave on the panel, the ripple grows by e every 1.1 seconds at the opening Blob, and a fresh sheet starts every 8.6 seconds. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Blob. Krasny's delta, how far each point vortex of the sheet is smoothed, from 0.15 to 0.5. A smaller blob grows the ripple faster and winds the spiral tighter: the ripple grows at 2.64 a unit of time at 0.15, 2.34 at 0.25 and 1.72 at 0.5, against pi for the bare sheet, and 8 seconds into a sheet the row through the core crosses it 25 times at 0.15, 19 at 0.25, 13 at 0.35 and 9 at 0.5. Below 0.15 the 340 points could no longer hold the core and the sheet frayed.\n// Knob 4: Waves. How many wavelengths of the sheet stand on the panel, 1 to 4: one period is 128, 64, 43 or 32 LEDs tall, and each rolls up into its own spiral, so 1 opens on one spiral 62 LEDs wide by 8 seconds and 4 makes a chain of four small ones. The sheet is computed over one period and repeated, so four cost what one does.\n// Buttons: K1 tap starts a fresh sheet with a new ripple.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Sheet time units per second at Speed 1. In one unit the far streams\n// slide one wavelength past each other, half a wavelength each way.\nconst RATE = 0.175;\n// Points on a fresh sheet, the most it may grow to, and the widest gap\n// (in wavelengths) before a point is put in between. 340 points keep a\n// frame near 2 ms; at the opening Blob a sheet has them all after about 3.5\n// seconds, and the core goes on winding with the points it has.\nconst N0 = 96, NMAX = 340, GAP = 0.015;\n// A sheet is started again at this age, when the core has wound into a\n// disc the LEDs no longer part.\nconst AGE = 3.0;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the streams' hue wheel\n// skips 0.03..0.18 and runs the rest a little faster.\nconst dimHue = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const M = NMAX + 8;\n  params.s = {\n    n: 0, x: new Float64Array(M), y: new Float64Array(M), g: new Float64Array(M), w: new Float64Array(M),\n    // RK4 stages, and the trig of each point packed for the kernel.\n    k: Array.from({ length: 8 }, () => new Float64Array(M)), x0: new Float64Array(M), y0: new Float64Array(M),\n    pk: new Float64Array(M * 5),\n    tx: new Float64Array(600), ty: new Float64Array(600), nt: 0, tWaves: 0,\n    tu: new Float64Array(600), tv: new Float64Array(600),\n    t: 0, born: false, hue: 0, speed: 2, delta: 0.15, waves: 1,\n    side: new Uint8Array(NP), flip: new Int16Array((W + 2) * H), rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3), fade: 0,\n    pal: new Float32Array(24), palHue: -1,\n  };\n}\n\n// A fresh sheet: Krasny's ripple x = G + a sin 2 pi G, y = -a sin 2 pi G,\n// with a random phase and size, so each roll-up stands at its own height\n// and comes a little sooner or later. A second harmonic was tried for\n// variety; below Blob 0.25 it rolled up into a second small spiral that\n// tangled with the first.\nfunction start(S) {\n  const R = Math.random, a = 0.035 + 0.02 * R(), ph = R();\n  S.n = N0;\n  for (let i = 0; i \u003c N0; i++) {\n    const G = i / N0, e = a * sin(TAU * (G + ph));\n    S.g[i] = G;\n    S.x[i] = G + e;\n    S.y[i] = -e;\n  }\n  S.t = 0;\n  S.nt = 0;\n}\n\n// Circulation carried by each point: half the gap in G to each neighbour.\nfunction weights(S) {\n  const { n, g, w } = S;\n  for (let i = 0; i \u003c n; i++) {\n    const a = i ? g[i - 1] : g[n - 1] - 1, b = i + 1 \u003c n ? g[i + 1] : g[0] + 1;\n    w[i] = (b - a) / 2;\n  }\n}\n\n// The blob kernel for one period of the sheet, with total circulation 1:\n//   u_i = -1/2 sum w_j sinh 2pi(y_i - y_j) / D,  v_i = 1/2 sum w_j sin 2pi(x_i - x_j) / D,\n//   D = cosh 2pi(y_i - y_j) - cos 2pi(x_i - x_j) + delta^2.\n// The differences come from products of each point's own trig, packed five\n// numbers a point with its weight, and each pair is visited once since the\n// kernel is odd.\nfunction pack(S, X, Y) {\n  const { n, w, pk } = S;\n  for (let i = 0, o = 0; i \u003c n; i++, o += 5) {\n    const a = TAU * X[i], e = exp(TAU * Y[i]), ie = 1 / e;\n    pk[o] = cos(a);\n    pk[o + 1] = sin(a);\n    pk[o + 2] = (e + ie) / 2;\n    pk[o + 3] = (e - ie) / 2;\n    pk[o + 4] = w[i];\n  }\n}\nfunction velocity(S, X, Y, U, V) {\n  const { n, pk } = S, d2 = S.delta * S.delta;\n  pack(S, X, Y);\n  U.fill(0, 0, n);\n  V.fill(0, 0, n);\n  for (let i = 0, oi = 0; i \u003c n; i++, oi += 5) {\n    const ci = pk[oi], si = pk[oi + 1], hi = pk[oi + 2], gi = pk[oi + 3], wi = pk[oi + 4];\n    let ui = 0, vi = 0;\n    for (let j = i + 1, o = oi + 5; j \u003c n; j++, o += 5) {\n      const cj = pk[o], sj = pk[o + 1], hj = pk[o + 2], gj = pk[o + 3], wj = pk[o + 4];\n      const q = 0.5 / (hi * hj - gi * gj - ci * cj - si * sj + d2), fu = (gi * hj - hi * gj) * q, fv = (si * cj - ci * sj) * q;\n      ui -= wj * fu;\n      vi += wj * fv;\n      U[j] += wi * fu;\n      V[j] -= wi * fv;\n    }\n    U[i] += ui;\n    V[i] += vi;\n  }\n}\n\nfunction rk4(S, h) {\n  const { n, x, y, x0, y0, k } = S;\n  for (let i = 0; i \u003c n; i++) (x0[i] = x[i]), (y0[i] = y[i]);\n  const cs = [0, 0.5, 0.5, 1];\n  for (let st = 0; st \u003c 4; st++) {\n    if (st) for (let i = 0; i \u003c n; i++) (x[i] = x0[i] + cs[st] * h * k[2 * st - 2][i]), (y[i] = y0[i] + cs[st] * h * k[2 * st - 1][i]);\n    velocity(S, x, y, k[2 * st], k[2 * st + 1]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    x[i] = x0[i] + (h / 6) * (k[0][i] + 2 * k[2][i] + 2 * k[4][i] + k[6][i]);\n    y[i] = y0[i] + (h / 6) * (k[1][i] + 2 * k[3][i] + 2 * k[5][i] + k[7][i]);\n  }\n}\n\n// Where a gap has opened wider than GAP, a point goes in at the middle G,\n// placed on the cubic through the four points around it. The points run\n// once round the period in order of G; the one after the last is the\n// first moved on by a whole period, so a point that goes in there is\n// simply added at the end.\nfunction refine(S) {\n  const { x, y, g } = S;\n  const at = (q, o) => {\n    const n = S.n, f = floor(q / n), m = q - f * n;\n    o[0] = x[m] + f;\n    o[1] = y[m];\n    o[2] = g[m] + f;\n  };\n  const a = [0, 0, 0], b = [0, 0, 0], c = [0, 0, 0], e = [0, 0, 0];\n  for (let i = 0; i \u003c S.n && S.n \u003c NMAX; i++) {\n    at(i, b);\n    at(i + 1, c);\n    const dx = c[0] - b[0], dy = c[1] - b[1];\n    if (dx * dx + dy * dy \u003c GAP * GAP) continue;\n    at(i - 1, a);\n    at(i + 2, e);\n    const n = S.n;\n    for (let m = n; m > i + 1; m--) (x[m] = x[m - 1]), (y[m] = y[m - 1]), (g[m] = g[m - 1]);\n    x[i + 1] = (-a[0] + 9 * b[0] + 9 * c[0] - e[0]) / 16;\n    y[i + 1] = (-a[1] + 9 * b[1] + 9 * c[1] - e[1]) / 16;\n    g[i + 1] = (b[2] + c[2]) / 2;\n    S.n++;\n    i++;\n  }\n}\n\n// Tracers: dots laid on a grid of the period, moved by the sheet's own\n// velocity, so the two streams and the winding read away from the sheet.\nfunction seedTracers(S) {\n  const sc = H / S.waves, rows = max(2, round(sc / 6)), cols = 11;\n  S.nt = 0;\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++) {\n      if (S.nt >= 600) break;\n      S.tx[S.nt] = (r + 0.5) / rows;\n      S.ty[S.nt] = ((c + 0.5) / cols - 0.5) * (W / sc);\n      S.nt++;\n    }\n  S.tWaves = S.waves;\n}\n\n// Tracers feel every other point of the sheet, each carrying the\n// circulation of two: they only have to read the streams, and it halves\n// their cost.\nfunction tracerVel(S, TX, TY, n, U, V) {\n  const { pk } = S, d2 = S.delta * S.delta, np = S.n;\n  for (let i = 0; i \u003c n; i++) {\n    const a = TAU * TX[i], e = exp(TAU * TY[i]), ie = 1 / e;\n    const ci = cos(a), si = sin(a), hi = (e + ie) / 2, gi = (e - ie) / 2;\n    let u = 0, v = 0;\n    for (let j = 0, o = 0; j + 1 \u003c np; j += 2, o += 10) {\n      const cj = pk[o], sj = pk[o + 1], hj = pk[o + 2], gj = pk[o + 3];\n      const q = (0.5 * (pk[o + 4] + pk[o + 9])) / (hi * hj - gi * gj - ci * cj - si * sj + d2);\n      u -= (gi * hj - hi * gj) * q;\n      v += (si * cj - ci * sj) * q;\n    }\n    U[i] = u;\n    V[i] = v;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.15, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.delta = cl(kv[2], 0.15, 0.5);\n  S.waves = cl(round(kv[3]), 1, 4);\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (!S.born || tap || S.t > AGE) {\n    if (S.born) S.fade = 1;\n    start(S);\n    S.born = true;\n  }\n  if (S.tWaves !== S.waves || !S.nt) seedTracers(S);\n  S.fade = max(0, S.fade - d * 2);\n  // A point at the core's centre turns at up to pi / delta^2 radians a unit\n  // of time if all the circulation sat in its blob, and about half does.\n  // Steps are cut so RK4 turns it under 2.5 radians, inside its stable 2.8;\n  // at Speed 3 that is one step a frame, and a run with four times the\n  // steps put every point within 0.05 LED of it after 2.6 units.\n  const h = d * S.speed * RATE, sub = Math.ceil(h / (2.5 / (PI / (2 * S.delta * S.delta))));\n  for (let k = 0; k \u003c sub; k++) {\n    weights(S);\n    rk4(S, h / sub);\n    S.t += h / sub;\n    refine(S);\n  }\n  // Tracers take one step with the sheet where it now is.\n  weights(S);\n  pack(S, S.x, S.y);\n  const nt = S.nt, TX = S.tx, TY = S.ty, TU = S.tu, TV = S.tv;\n  tracerVel(S, TX, TY, nt, TU, TV);\n  for (let i = 0; i \u003c nt; i++) {\n    TX[i] += h * TU[i];\n    TY[i] += h * TV[i];\n    TX[i] -= floor(TX[i]);\n  }\n}\n\nfunction palette(S) {\n  const P = S.pal, h = 0.55 + S.hue;\n  hsv(dimHue(h), 0.8, 0.26, P, 0); // left fluid\n  hsv(dimHue(h + 0.3), 0.8, 0.26, P, 3); // right fluid\n  hsv(h, 0.6, 0.75, P, 6); // left tracers\n  hsv(h + 0.3, 0.6, 0.75, P, 9); // right tracers\n  hsv(h + 0.15, 0.3, 0.95, P, 12); // sheet\n  S.palHue = S.hue;\n}\n\n// Points laid along a line every third of an LED, each lighting its four\n// nearest LEDs by how close it falls; an LED keeps the brightest.\nfunction plot(S, x, y, P, o, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const k = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c P[o] * k) rgb[p] = P[o] * k;\n      if (rgb[p + 1] \u003c P[o + 1] * k) rgb[p + 1] = P[o + 1] * k;\n      if (rgb[p + 2] \u003c P[o + 2] * k) rgb[p + 2] = P[o + 2] * k;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { x, y, n, rgb, flip } = S, P = S.pal;\n  const sc = H / S.waves, ox = W / 2;\n  const PX = (Y) => ox + Y * sc, PY = (X, k) => (X + k) * sc;\n  // Which fluid each LED holds: the crossings of the sheet to its left,\n  // counted row by row. The sheet spans every row, so the far left is\n  // always the left stream.\n  flip.fill(0);\n  for (let k = -1; k \u003c= S.waves; k++)\n    for (let i = 0; i \u003c n; i++) {\n      const j = i + 1 \u003c n ? i + 1 : 0, wrap = j === 0 ? 1 : 0;\n      const ya = PY(x[i], k), yb = PY(x[j] + wrap, k), xa = PX(y[i]), xb = PX(y[j]);\n      const lo = Math.ceil(min(ya, yb) - 0.5), hi = Math.ceil(max(ya, yb) - 0.5);\n      for (let r = max(0, lo); r \u003c min(H, hi); r++) {\n        const f = (r + 0.5 - ya) / (yb - ya), xc = xa + f * (xb - xa);\n        flip[r * (W + 2) + cl(Math.ceil(xc - 0.5), 0, W)] ^= 1;\n      }\n    }\n  for (let r = 0; r \u003c H; r++) {\n    let par = 0;\n    for (let c = 0; c \u003c W; c++) {\n      par ^= flip[r * (W + 2) + c];\n      const p = (r * W + c) * 3, o = par ? 3 : 0;\n      rgb[p] = P[o];\n      rgb[p + 1] = P[o + 1];\n      rgb[p + 2] = P[o + 2];\n      S.side[r * W + c] = par;\n    }\n  }\n  // Tracers, in the colour of the fluid they are in now, each with a streak\n  // of where it was a tenth of a second ago.\n  const back = 0.1 * S.speed * RATE;\n  for (let k = -1; k \u003c= S.waves; k++)\n    for (let i = 0; i \u003c S.nt; i++) {\n      const px = PX(S.ty[i]), py = PY(S.tx[i], k);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const o = S.side[floor(py) * W + floor(px)] ? 9 : 6, ex = S.tv[i] * back * sc, ey = S.tu[i] * back * sc;\n      for (let e = 3; e >= 0; e--) plot(S, px - (ex * e) / 3, py - (ey * e) / 3, P, o, 1 - e * 0.22);\n    }\n  // The sheet on top.\n  for (let k = -1; k \u003c= S.waves; k++)\n    for (let i = 0; i \u003c n; i++) {\n      const j = i + 1 \u003c n ? i + 1 : 0, wrap = j === 0 ? 1 : 0;\n      const xa = PX(y[i]), ya = PY(x[i], k), xb = PX(y[j]), yb = PY(x[j] + wrap, k);\n      if ((ya \u003c -2 && yb \u003c -2) || (ya > H + 2 && yb > H + 2)) continue;\n      const m = Math.ceil(Math.hypot(xb - xa, yb - ya) * 3) || 1;\n      for (let e = 0; e \u003c= m; e++) plot(S, xa + ((xb - xa) * e) / m, ya + ((yb - ya) * e) / m, P, 12, 1);\n    }\n  const f = S.fade, old = S.old;\n  for (let r = 0, p = 0; r \u003c H; r++)\n    for (let c = 0; c \u003c W; c++, p += 3) {\n      let R = rgb[p], G = rgb[p + 1], B = rgb[p + 2];\n      if (f > 0) (R = R * (1 - f) + old[p] * f), (G = G * (1 - f) + old[p + 1] * f), (B = B * (1 - f) + old[p + 2] * f);\n      else (old[p] = R), (old[p + 1] = G), (old[p + 2] = B);\n      display.setPixel(c, r, (255 * min(1, R)) | 0, (255 * min(1, G)) | 0, (255 * min(1, B)) | 0);\n    }\n}\n","vuza-canon":"// ===== Patternflow pattern =====\n// Title:   Vuza Canon\n// Family:  rhythm\n// Idea:    Twelve voices play the same six-note rhythm from twelve different entries in a cycle of 72 beats, scrolling up the panel one beat a row, and every row holds exactly one note, so the voices tile time with no beat doubled or missed while neither the rhythm nor the entries repeat inside the cycle.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rhythmic tiling canons (Dan Tudor Vuza, 1991), the non-periodic factorisations of cyclic groups (Gyorgy Hajos, 1950; N. G. de Bruijn, 1953), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Canon=0..3, Focus=0..12\n//\n// Knob 1: Hue. Turns the six note colours round the wheel together. At 0 the six notes of the rhythm run gold, green, cyan, azure, violet and magenta in the order each voice plays them; at 0.5 they run blue, violet, red, orange, lime and cyan.\n// Knob 2: Speed. Beats a second, 4.5 times the knob: 9 at 2, so a cycle of 72 passes the now line in 8 seconds; 0.9 at 0.2 (80 seconds) and 13.5 at 3 (5.3 seconds).\n// Knob 3: Canon. 0 is Vuza's canon of Z72: the rhythm A = {0, 8, 16, 18, 26, 34}, gaps 8, 8, 2, 8, 8, 38, in 12 voices entering at B = {0, 1, 5, 6, 12, 25, 29, 36, 42, 48, 49, 53}. 1 swaps the roles: 6 voices entering at A play B, the same 72 notes in the same colours regrouped so each column is one colour. 2 is a tiling with the rhythm {0, 1, 8, 9, 16, 17} whose entries {0, 2, 4, 6} + {0, 24, 48} repeat every 24 beats, so the picture comes round three times a cycle. 3 is the plainest tiling, 6 consecutive beats in 12 voices 6 apart: one staircase.\n// Knob 4: Focus. 0 lights every voice alike. 1 to 12 pick one voice: it is drawn white-cored with a stem joining its notes, and each of its notes rules a faint line across the panel, so its rhythm lies over the roll as a ruler (for Vuza's A, lines 8, 8, 2, 8 and 8 rows apart, then 38 rows of nothing), while the other voices narrow to two LEDs. With 6 voices, 1 and 2 pick the first, 3 and 4 the second, and so on.\n\nconst W = 64, H = 128, N = 72;\nconst { floor, min, max, exp, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The now line, with 104 beats of the past above it and 23 to come below.\nconst NOW = 104;\n// The six note colours at knob 0, a sixth of the wheel apart from gold to\n// magenta, skipping red and orange.\nconst HUES = [0.14, 0.3, 0.46, 0.6, 0.74, 0.88];\n\n// Each canon as a rhythm played by voices at a set of entries, and which of\n// the two the colours follow. A tiling has |A| x |B| = 72 and every sum\n// a + b distinct mod 72; build() checks it and keeps the voice and colour\n// of each beat.\nconst CANONS = [\n  { rhythm: [0, 8, 16, 18, 26, 34], entries: [0, 1, 5, 6, 12, 25, 29, 36, 42, 48, 49, 53], colourBy: \"rhythm\" },\n  { rhythm: [0, 1, 5, 6, 12, 25, 29, 36, 42, 48, 49, 53], entries: [0, 8, 16, 18, 26, 34], colourBy: \"entries\" },\n  { rhythm: [0, 1, 8, 9, 16, 17], entries: [0, 2, 4, 6, 24, 26, 28, 30, 48, 50, 52, 54], colourBy: \"rhythm\" },\n  { rhythm: [0, 1, 2, 3, 4, 5], entries: [0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66], colourBy: \"rhythm\" },\n];\n\nfunction build(c) {\n  const voice = new Int8Array(N).fill(-1), colour = new Int8Array(N), note = new Int8Array(N);\n  c.rhythm.forEach((a, i) =>\n    c.entries.forEach((b, j) => {\n      const t = (a + b) % N;\n      if (voice[t] >= 0) throw new Error(\"not a tiling\");\n      voice[t] = j;\n      note[t] = i;\n      colour[t] = c.colourBy === \"rhythm\" ? i : j;\n    }),\n  );\n  return { voices: c.entries.length, voice, colour, note, entries: c.entries };\n}\nconst TABLES = CANONS.map(build);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    // p is the beat on the now line, counted from the start.\n    p: 0, bps: 9, hue: 0, canon: 0, focus: 0, since: 0, last: 0,\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(18), palHue: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.bps = 4.5 * cl(kv[1], 0.2, 3);\n  s.canon = round(cl(kv[2], 0, 3));\n  s.focus = round(cl(kv[3], 0, 12));\n  s.p += d * s.bps;\n  const b = floor(s.p);\n  if (b !== s.last) (s.last = b), (s.since = 0);\n  else s.since += d;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const B = s.buf, P = s.pal;\n  if (s.palHue !== s.hue) {\n    for (let i = 0; i \u003c 6; i++) hsv(HUES[i] + s.hue, 0.8, 1, P, i * 3);\n    s.palHue = s.hue;\n  }\n  B.fill(0);\n  const set = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    B[o] = max(B[o], r);\n    B[o + 1] = max(B[o + 1], g);\n    B[o + 2] = max(B[o + 2], b);\n  };\n  const T = TABLES[s.canon], nv = T.voices, pitch = floor(60 / nv), lit = nv > 6 ? pitch - 1 : pitch - 2;\n  const x0 = (W - pitch * nv + (pitch - lit)) >> 1;\n  // With 6 voices, focus 1 and 2 pick the first, 3 and 4 the second.\n  const fv = s.focus ? floor(((s.focus - 1) * nv) / 12) : -1;\n  const now = floor(s.p), flash = exp(-s.since * 9);\n  const mod = (b) => ((b % N) + N) % N;\n\n  // The scale on the left: a tick every 8 beats, and a dotted line across\n  // where a cycle of 72 begins.\n  for (let y = 0; y \u003c H; y++) {\n    const b = now - (NOW - y), t = mod(b);\n    if (t % 8 === 0) set(0, y, 0.3, 0.32, 0.38);\n    if (t === 0) for (let x = 0; x \u003c W; x += 2) set(x, y, 0.32, 0.34, 0.42);\n  }\n  // A dim lane down the middle of each voice's column, so the voices read as\n  // columns between their notes. It also keeps a fifth of the panel lit:\n  // with the notes alone the picture lit 7% and stretched the study map's\n  // fill axis past its end.\n  for (let v = 0; v \u003c nv; v++) {\n    const cx = x0 + v * pitch + (lit >> 1);\n    for (let y = 0; y \u003c H; y++) set(cx, y, 0.11, 0.115, 0.13);\n  }\n  // The focused voice rules a faint line across the panel at each of its\n  // notes, so its rhythm reads as a ruler laid over the others, and a stem\n  // joins its notes down its own column.\n  if (fv >= 0) {\n    const cx = x0 + fv * pitch + (lit >> 1);\n    let prev = -1;\n    for (let y = 0; y \u003c H; y++) {\n      const t = mod(now - (NOW - y));\n      if (T.voice[t] !== fv) continue;\n      for (let x = 2; x \u003c W; x++) set(x, y, 0.2, 0.2, 0.24);\n      if (prev >= 0) for (let yy = prev + 1; yy \u003c y; yy++) set(cx, yy, 0.45, 0.45, 0.5);\n      prev = y;\n    }\n  }\n  // The notes: one a row, since the voices tile time.\n  for (let y = 0; y \u003c H; y++) {\n    const b = now - (NOW - y), t = mod(b), v = T.voice[t], c = T.colour[t] * 3;\n    const r = P[c], g = P[c + 1], bl = P[c + 2], xl = x0 + v * pitch;\n    const future = y > NOW, hit = y === NOW;\n    let a = xl, z = xl + lit;\n    // Others narrow to their middle two LEDs while one voice is in focus,\n    // and the beats still to come are drawn the same way.\n    if ((fv >= 0 && v !== fv) || future) (a = xl + (lit >> 1) - 1), (z = a + 2);\n    for (let x = a; x \u003c z; x++) {\n      if (fv === v && !future) {\n        // White-cored: the middle LEDs whitened, the ends in the note colour.\n        const core = x > xl && x \u003c xl + lit - 1 ? 0.55 : 0;\n        set(x, y, r + (1 - r) * core, g + (1 - g) * core, bl + (1 - bl) * core);\n      } else set(x, y, r, g, bl);\n    }\n    if (hit) {\n      // The note that sounds flashes white and throws a glow along the now\n      // line in its colour.\n      for (let x = xl - 2; x \u003c xl + lit + 2; x++) {\n        const k = x \u003c xl || x >= xl + lit ? 0.6 * flash : flash;\n        set(x, y, r + (1 - r) * k, g + (1 - g) * k, bl + (1 - bl) * k);\n        set(x, y - 1, r * k, g * k, bl * k);\n        set(x, y + 1, r * k, g * k, bl * k);\n      }\n      // The line itself is grey, coloured only near the note: a dim gold\n      // line across the panel would read brown.\n      for (let x = 0; x \u003c W; x++) {\n        const dd = x \u003c xl ? xl - x : x >= xl + lit ? x - xl - lit + 1 : 0, k = 0.7 * flash * exp(-dd / 8);\n        set(x, y, 0.26 + r * k, 0.27 + g * k, 0.3 + bl * k);\n      }\n    }\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, round(B[o] * 255)), min(255, round(B[o + 1] * 255)), min(255, round(B[o + 2] * 255)));\n}\n","arcsine-law":"// ===== Patternflow pattern =====\n// Title:   Arcsine Law\n// Family:  data\n// Idea:    48 fair random walks come down the panel a row a step, each LED one toss of the coin, bright for a step up and dark for a step down, coloured warm while its walk is above zero and cool below, so the tosses look like noise while most columns run in long stretches of one colour; after 126 steps the warm cells rise to the top of each column and the columns sort themselves by how many there are, so the boundary between the colours draws the arcsine quantile curve, while a histogram beside them gathers every walk so far into Lévy's U-shaped law, its exact values marked by white dots.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: arcsine laws (Paul Lévy, 1939)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Statistic=0..2, Drift=-1..1\n//\n// Knob 1: Hue. Turns every colour around the wheel together. At 0 a walk above zero is amber and below zero azure, pale near zero and deeper the further out it is, a step down drawn at a third of the brightness of a step up, with lavender histogram bars; at 0.25 green above and magenta below, at 0.5 the two sides trade colours.\n// Knob 2: Speed. 20 rows a second per unit: 40 at the opening 2, so a batch of 126 steps comes down in 3.2 s, settles and sorts in 1.4 s and holds for 1.4 s; at 0.2 a batch takes 32 s to come down, at 3 it takes 2.1 s. Walks that are not drawn feed the histogram at 120 a second per unit.\n// Knob 3: Statistic. Which of Lévy's three the columns sort by and the histogram counts. At 0 the time above zero: the warm cells rise to the top of their column. At 1 the last zero: the cells before each walk's last return to zero are dimmed, leaving a bright tail of one colour below it. At 2 the first time of the maximum: the cells after each walk's highest point so far are dimmed. All three histograms settle on the same U.\n// Knob 4: Drift. A step goes up with chance (1 + mu) / 2. mu is 0 within 0.08 of the middle, so the opening 0.06 is the fair walk, then grows as the square to 0.014 at 0.3, 0.052 at 0.5 and 0.25 at either end, where nearly every column floods one colour. Any drift breaks the law: at 0.5 the histogram of time above zero lies 0.19 from it in Kolmogorov distance, while the last zero, which only asks whether the walk comes back, lies 0.051 from it.\n\nconst W = 64, H = 128;\n// 48 walks of 126 steps, one a column, step t drawn in row t - 1; then a\n// dark column and the histogram, 15 columns wide, its bins two rows tall on\n// the same time axis as the walks.\nconst NW = 48, N = 126, HX = 49, HL = 15, NB = 64;\nconst { floor, round, min, max, abs, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The exact laws for N = 126 steps, bin k of the histogram. The time spent\n// above zero (counting a step as above when either end of it is) and the\n// last zero both take the value 2k with probability u(2k) u(N - 2k), where\n// u(2m) = C(2m, m) / 4^m is the chance of being at zero at time 2m: the\n// discrete arcsine law of Feller's textbook (1950). The first time of the\n// maximum is k with probability a(k) b(N - k): a(k) the chance a walk stays\n// above zero for k steps, b(m) the chance it stays at or below zero for m,\n// both by following the walk step by step. Lévy's arcsine law is the limit\n// of all three.\nconst U = new Float64Array(N + 1);\nU[0] = 1;\nfor (let m = 1; 2 * m \u003c= N; m++) U[2 * m] = (U[2 * m - 2] * (2 * m - 1)) / (2 * m);\nfunction stay(strict) {\n  // out[k]: chance that S_1..S_k all stay above zero (strict) or at or\n  // below zero, by the distribution of the walk killed when it leaves.\n  const out = new Float64Array(N + 1), off = N + 1;\n  let p = new Float64Array(2 * N + 3), q = new Float64Array(2 * N + 3);\n  p[off] = 1;\n  out[0] = 1;\n  for (let k = 1; k \u003c= N; k++) {\n    q.fill(0);\n    let tot = 0;\n    for (let x = 1; x \u003c 2 * N + 2; x++) {\n      const v = 0.5 * (p[x - 1] + p[x + 1]);\n      const y = x - off;\n      if (strict ? y > 0 : y \u003c= 0) (q[x] = v), (tot += v);\n    }\n    [p, q] = [q, p];\n    out[k] = tot;\n  }\n  return out;\n}\nconst PB = [new Float64Array(NB), new Float64Array(NB), new Float64Array(NB)];\n{\n  const a = stay(true), b = stay(false);\n  for (let k = 0; k \u003c NB; k++) PB[0][k] = PB[1][k] = U[2 * k] * U[N - 2 * k];\n  for (let t = 0; t \u003c= N; t++) PB[2][t >> 1] += a[t] * b[N - t];\n}\n// The histogram's scale puts the third bin from either end at full length,\n// so the bins at the very ends run off the band.\nconst PFULL = PB[0][2];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, stat: 0, mu: 0, init: false,\n    // The batch on show: positions S[i * (N + 1) + t].\n    S: new Int16Array(NW * (N + 1)), row: 0, phase: 0, clock: 0,\n    pos: new Int16Array(NW), lz: new Int16Array(NW), tm: new Int16Array(NW), top: new Int16Array(NW),\n    // Sorting: each walk's target column and each cell's target row.\n    X: new Int16Array(NW), R: new Int16Array(NW * N), sortStat: -1,\n    // The last sorted picture, shown on every other LED below the new\n    // batch's front.\n    prev: new Float32Array(NW * N * 3),\n    hist: [new Float64Array(NB), new Float64Array(NB), new Float64Array(NB)], walks: 0, histMu: 0,\n    fb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// One walk's three statistics from its positions w[0..N].\nfunction stats(w, o, out) {\n  let pos = 0, lz = 0, tm = 0, top = 0;\n  for (let t = 1; t \u003c= N; t++) {\n    const a = w[o + t - 1], b = w[o + t];\n    if (a + b > 0) pos++;\n    if (b === 0) lz = t;\n    if (b > top) (top = b), (tm = t);\n  }\n  out[0] = pos;\n  out[1] = lz;\n  out[2] = tm;\n}\n\nconst tmpW = new Int16Array(N + 1), tmpS = [0, 0, 0];\nfunction hiddenWalk(S) {\n  const p = (1 + S.mu) / 2;\n  tmpW[0] = 0;\n  for (let t = 1; t \u003c= N; t++) tmpW[t] = tmpW[t - 1] + (Math.random() \u003c p ? 1 : -1);\n  stats(tmpW, 0, tmpS);\n  addStats(S, tmpS);\n}\nfunction addStats(S, st) {\n  S.hist[0][st[0] >> 1]++;\n  S.hist[1][st[1] >> 1]++;\n  S.hist[2][st[2] >> 1]++;\n  S.walks++;\n}\n\nfunction stepRow(S) {\n  const t = S.row + 1, p = (1 + S.mu) / 2, A = S.S;\n  for (let i = 0; i \u003c NW; i++) {\n    const o = i * (N + 1), b = (A[o + t] = A[o + t - 1] + (Math.random() \u003c p ? 1 : -1)), a = A[o + t - 1];\n    if (a + b > 0) S.pos[i]++;\n    if (b === 0) S.lz[i] = t;\n    if (b > S.top[i]) (S.top[i] = b), (S.tm[i] = t);\n  }\n  S.row = t;\n}\n\nfunction newBatch(S) {\n  S.S.fill(0);\n  S.pos.fill(0);\n  S.lz.fill(0);\n  S.tm.fill(0);\n  S.top.fill(0);\n  S.row = 0;\n  S.phase = 0;\n  S.clock = 0;\n}\n\n// The statistic each walk is sorted by, and where each cell goes: for the\n// time above zero the cells above zero rise to the top of their column in\n// their order and the rest sink below them; for the other two the cells\n// stay in their rows.\nfunction plan(S) {\n  const st = S.stat === 0 ? S.pos : S.stat === 1 ? S.lz : S.tm, A = S.S;\n  const idx = [...Array(NW).keys()].sort((a, b) => st[a] - st[b] || A[a * (N + 1) + N] - A[b * (N + 1) + N] || a - b);\n  idx.forEach((w, r) => (S.X[w] = r));\n  for (let i = 0; i \u003c NW; i++) {\n    const o = i * (N + 1);\n    let up = 0, down = S.pos[i];\n    for (let t = 1; t \u003c= N; t++) {\n      const above = A[o + t - 1] + A[o + t] > 0;\n      S.R[i * N + t - 1] = S.stat === 0 ? (above ? up++ : down++) : t - 1;\n    }\n  }\n  S.sortStat = S.stat;\n}\n\n// A cell is one toss of the coin: bright when the step went up, dark when\n// it went down, so the tosses read as noise. Its hue is the sign of the\n// running total, warm above zero and cool below, paler near zero and\n// deeper the further the walk is out in units of sqrt(t), and that hue\n// runs in long stretches. Cells are dimmed before the last zero or after\n// the maximum when those are the statistic.\nfunction shade(S, i, t, out) {\n  const o = i * (N + 1), a = S.S[o + t - 1], b = S.S[o + t], m = min(1, abs(a + b) / (2.2 * sqrt(t))), up = b > a;\n  if (a + b > 0) hsv(0.11 + S.hue, 0.3 + 0.7 * m, up ? 1 : 0.3, out);\n  else hsv(0.6 + S.hue, 0.3 + 0.65 * m, up ? 0.85 : 0.25, out);\n  let dim = false;\n  if (S.stat === 1) dim = t \u003c= S.lz[i];\n  else if (S.stat === 2) dim = t > S.tm[i];\n  if (dim) {\n    const g = (out[0] + out[1] + out[2]) / 3;\n    for (let c = 0; c \u003c 3; c++) out[c] = 0.2 * (0.4 * out[c] + 0.6 * g);\n  }\n  return out;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.stat = cl(round(kv[2]), 0, 2);\n  // Drift: none within 0.08 of the middle, then growing as the square to\n  // 0.25 at either end; the chance of a step up is (1 + mu) / 2.\n  const k4 = cl(kv[3], -1, 1), e = max(0, (abs(k4) - 0.08) / 0.92);\n  S.mu = (k4 \u003c 0 ? -1 : 1) * 0.25 * e * e;\n  if (S.mu !== S.histMu) {\n    for (const h of S.hist) h.fill(0);\n    S.walks = 0;\n    S.histMu = S.mu;\n  }\n  if (!S.init) {\n    // The first batch comes down a dark panel; each later one comes down\n    // over the sorted picture of the one before.\n    S.init = true;\n    newBatch(S);\n  }\n  // Walks nobody sees feed the histogram, 8 a frame at Speed 2.\n  S.hidden = (S.hidden || 0) + (d * 30 * 8 * S.speed) / 2;\n  while (S.hidden >= 1) hiddenWalk(S), S.hidden--;\n  const rate = 20 * S.speed, slow = sqrt(2 / S.speed);\n  S.clock += d;\n  if (S.phase === 0) {\n    const want = min(N, floor(S.clock * rate));\n    while (S.row \u003c want) stepRow(S);\n    if (S.row >= N) {\n      for (let i = 0; i \u003c NW; i++) addStats(S, [S.pos[i], S.lz[i], S.tm[i]]);\n      plan(S);\n      S.phase = 1;\n      S.clock = 0;\n    }\n  } else {\n    if (S.stat !== S.sortStat) plan(S), (S.clock = 0), (S.phase = 1);\n    if (S.phase === 1 && S.clock > 1.4 * slow) (S.phase = 2), (S.clock = 0);\n    if (S.phase === 2 && S.clock > 1.4 * slow) keep(S), newBatch(S);\n  }\n}\n\n// Store the sorted picture of the batch as the backdrop.\nfunction keep(S) {\n  const P = S.prev, c = S.c;\n  P.fill(0);\n  for (let i = 0; i \u003c NW; i++)\n    for (let t = 1; t \u003c= N; t++) {\n      shade(S, i, t, c);\n      const q = (S.R[i * N + t - 1] * NW + S.X[i]) * 3;\n      P[q] = c[0];\n      P[q + 1] = c[1];\n      P[q + 2] = c[2];\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.init) return;\n  const fb = S.fb, c = S.c, P = S.prev;\n  fb.fill(0);\n  if (S.phase === 0) {\n    // The old picture below the front on every other LED, the new walks\n    // above it.\n    for (let r = S.row; r \u003c N; r++)\n      for (let x = (r + 1) & 1; x \u003c NW; x += 2) {\n        const q = (r * W + x) * 3, s = (r * NW + x) * 3;\n        fb[q] = P[s];\n        fb[q + 1] = P[s + 1];\n        fb[q + 2] = P[s + 2];\n      }\n    for (let i = 0; i \u003c NW; i++)\n      for (let t = 1; t \u003c= S.row; t++) {\n        shade(S, i, t, c);\n        const q = ((t - 1) * W + i) * 3;\n        fb[q] = c[0];\n        fb[q + 1] = c[1];\n        fb[q + 2] = c[2];\n      }\n  } else {\n    // Settle first, then slide the columns into their order.\n    const u = S.phase === 2 ? 1 : S.clock / (1.4 * sqrt(2 / S.speed));\n    const ey = ease(u * 2), ex = ease(u * 2 - 1);\n    for (let i = 0; i \u003c NW; i++) {\n      const x = round(i + (S.X[i] - i) * ex);\n      for (let t = 1; t \u003c= N; t++) {\n        const y = round(t - 1 + (S.R[i * N + t - 1] - (t - 1)) * ey);\n        shade(S, i, t, c);\n        const q = (y * W + x) * 3;\n        fb[q] = c[0];\n        fb[q + 1] = c[1];\n        fb[q + 2] = c[2];\n      }\n    }\n  }\n  // Once the columns stand in order, a dot in each marks where Lévy's law\n  // puts that rank: column r of 48 at N sin^2(pi (r + 1/2) / 96), the\n  // arcsine quantile. The boundary of the batch should hug it.\n  if (S.phase === 2) {\n    const v = 0.85 * min(1, S.clock / 0.4);\n    for (let r = 0; r \u003c NW; r++) {\n      const sn = sin((PI * (r + 0.5)) / (2 * NW)), y = min(N - 1, floor(N * sn * sn)), q = (y * W + r) * 3;\n      for (let j = 0; j \u003c 3; j++) fb[q + j] += (255 - fb[q + j]) * v;\n    }\n  }\n  // The histogram of the chosen statistic over every walk so far, and the\n  // exact law as a dot at the length each bar should reach.\n  const h = S.hist[S.stat], pb = PB[S.stat], n = max(1, S.walks), sc = HL / PFULL;\n  for (let k = 0; k \u003c NB; k++) {\n    const len = (h[k] / n) * sc, ex = pb[k] * sc;\n    for (let j = 0; j \u003c HL; j++) {\n      const f = cl(len - j, 0, 1), y0 = 2 * k;\n      let r = 0, g = 0, b = 0;\n      // The bar, the shortfall from the law dimmer, and the law's dot.\n      const sf = j >= len && j \u003c ex - 0.5 ? 0.3 : 0;\n      if (f > 0 || sf) hsv(0.8 + S.hue, 0.35, f > 0 ? 0.3 + 0.6 * f : sf, c), (r = c[0]), (g = c[1]), (b = c[2]);\n      if (abs(j + 0.5 - ex) \u003c 0.5) (r = 255), (g = 255), (b = 255);\n      for (let y = y0; y \u003c y0 + 2; y++) {\n        const q = (y * W + HX + j) * 3;\n        fb[q] = r;\n        fb[q + 1] = g;\n        fb[q + 2] = b;\n      }\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p % W, (p / W) | 0, fb[p * 3] | 0, fb[p * 3 + 1] | 0, fb[p * 3 + 2] | 0);\n}\n","nodal-domains":"// ===== Patternflow pattern =====\n// Title:   Nodal Domains\n// Family:  noise\n// Idea:    Berry's random wave, 40 plane waves of one wavelength in random directions each drifting at its own frequency, cut at a level into its nodal domains, each domain one flat colour that stays with it from frame to frame and runs from rose to gold above the level and from violet to cyan below as the domain grows, the largest one pale, while a white spark marks each saddle where two domains just merged or one just split.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random wave model (Michael Berry, 1977), with the percolation picture of nodal domains (Eugene Bogomolny and Charles Schmit, 2002)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=0..1, Level=-1..1\n//\n// Knob 1: Hue. Turns every colour around the wheel together. At 0 the domains above the level run from rose through orange to gold and those below from blue violet to cyan, with the largest domain cream or sky blue; at 0.25 above is lime to green and below pink to violet, at 0.5 the two sides trade warm and cool.\n// Knob 2: Speed. Each wave turns its phase at its own rate, drawn from a normal law with a spread of 0.3 radians a second per unit: 0.6 at the opening 2, where a domain changes shape within a second or two and the panel sees about 55 merges and as many splits a second; 0.06 at 0.2, and 0.9 at 3.\n// Knob 3: Wavenumber. The wavelength of all 40 waves, 8 LEDs at 0 and 5.5 at 1, zooming about the middle of the panel. Bogomolny and Schmit's count for an area the size of the panel goes from 25 domains to 53; the panel shows about 54 and 95, because its edges cut domains into pieces.\n// Knob 4: Level. Where psi is cut, in units of its standard deviation; it opens at 0.06, next to the critical level 0, where domains of both signs can reach across the panel. At 1 only 16% of the panel lies above the level, the warm side breaks into about 100 islands and one cool domain holds 85% of the panel; at -1 the same with the sides swapped.\n\nconst W = 64, H = 128, N = W * H, J = 40, MAXID = 4096;\nconst { floor, abs, sqrt, sin, cos, log, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Bogomolny and Schmit: nodal domains per unit of k^2 / (4 pi) of area,\n// which is the number of eigenvalues below k^2 per unit area (Weyl).\nconst BS = (3 * sqrt(3) - 5) / PI;\n\n// Colour follows a domain's size. Above the level a domain runs from rose\n// when it is a single lobe of a few LEDs through orange to gold when it is\n// as big as 1,500 LEDs; below the level from blue violet through blue to\n// cyan. Each domain keeps a small hue offset of its own, and the largest\n// domain on the panel is drawn in a light tint, cream above the level and\n// sky blue below.\nconst RAMP = [[0.97, 0.8, 1, 0.13, 0.95, 1], [0.7, 0.75, 0.95, 0.5, 0.9, 0.95]];\nconst PALE = [[0.57, 0.5, 1], [0.14, 0.38, 1]];\nconst A0 = log(8), A1 = log(1500);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nconst gauss = () => sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, wn: 0, lev: 0.06, k: -1, nc: 0, count: 0, bulk: 0,\n    th: new Float64Array(J), ph: new Float64Array(J), om: new Float64Array(J),\n    AR: new Float64Array(W * J), AI: new Float64Array(W * J), CR: new Float64Array(J), CI: new Float64Array(J), SR: new Float64Array(J), SI: new Float64Array(J),\n    V: new Float64Array(N), sg: new Uint8Array(N), par: new Int32Array(N), comp: new Int32Array(N),\n    area: new Int32Array(N), csign: new Uint8Array(N), cid: new Int32Array(N),\n    id: new Int32Array(N).fill(-1), fl: new Float32Array(N), dec: new Uint8Array(N), dec0: new Uint8Array(N),\n    idSign: new Uint8Array(MAXID), idHue: new Float64Array(MAXID), idLA: new Float64Array(MAXID), bigId: -1, used: new Uint8Array(MAXID), taken: new Uint8Array(MAXID),\n    free: [], pairs: new Map(), c: [0, 0, 0],\n  });\n  for (let i = MAXID - 1; i >= 0; i--) S.free.push(i);\n  // Wave directions spread over half a turn, one in each of J equal slots at\n  // a random place in it; phases uniform; each wave its own frequency.\n  for (let j = 0; j \u003c J; j++) {\n    S.th[j] = (PI * (j + Math.random())) / J;\n    S.ph[j] = 2 * PI * Math.random();\n    S.om[j] = gauss();\n  }\n}\n\nfunction find(par, p) {\n  while (par[p] !== p) p = par[p] = par[par[p]];\n  return p;\n}\nfunction union(par, a, b) {\n  a = find(par, a);\n  b = find(par, b);\n  if (a \u003c b) par[b] = a;\n  else if (b \u003c a) par[a] = b;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.wn = cl(kv[2], 0, 1);\n  S.lev = cl(kv[3], -1, 1);\n  // Wavelength in LEDs: 8 at 0, 5.5 at 1.\n  const lam = 8 / (1 + 0.4545 * S.wn), k = (2 * PI) / lam;\n  const AR = S.AR, AI = S.AI, CR = S.CR, CI = S.CI, SR = S.SR, SI = S.SI, th = S.th, ph = S.ph, om = S.om;\n  if (k !== S.k) {\n    S.k = k;\n    for (let j = 0; j \u003c J; j++) {\n      SR[j] = cos(k * sin(th[j]));\n      SI[j] = sin(k * sin(th[j]));\n      for (let x = 0; x \u003c W; x++) {\n        const a = k * cos(th[j]) * (x - (W - 1) / 2);\n        AR[x * J + j] = cos(a);\n        AI[x * J + j] = sin(a);\n      }\n    }\n  }\n  // psi = sum_j a cos(k (x cos th + y sin th) + ph), the real part of a\n  // column factor times a row factor; a = sqrt(2 / J) gives variance 1. The\n  // row factor starts at the top row and turns by k sin th from row to row.\n  const amp = sqrt(2 / J), V = S.V;\n  for (let j = 0; j \u003c J; j++) {\n    ph[j] += d * S.speed * 0.3 * om[j];\n    const b = (-k * sin(th[j]) * (H - 1)) / 2 + ph[j];\n    CR[j] = amp * cos(b);\n    CI[j] = amp * sin(b);\n  }\n  for (let y = 0; y \u003c H; y++) {\n    if (y)\n      for (let j = 0; j \u003c J; j++) {\n        const r = CR[j] * SR[j] - CI[j] * SI[j];\n        CI[j] = CR[j] * SI[j] + CI[j] * SR[j];\n        CR[j] = r;\n      }\n    // The column factor's real part is even about the middle column and its\n    // imaginary part odd, so one pair of sums serves a column and its mirror.\n    const r = y * W;\n    for (let x = 0; x \u003c W / 2; x++) {\n      const o = x * J;\n      let e = 0, q = 0;\n      for (let j = 0; j \u003c J; j++) {\n        e += AR[o + j] * CR[j];\n        q += AI[o + j] * CI[j];\n      }\n      V[r + x] = e - q;\n      V[r + W - 1 - x] = e + q;\n    }\n  }\n  label(S);\n  match(S, d);\n  // What Bogomolny and Schmit expect for an area of the panel's size, far\n  // from any edge.\n  S.bulk = (BS * N * k * k) / (4 * PI);\n}\n\n// Components of {psi > c} and of {psi \u003c c}: 4-neighbours of one sign join,\n// and in a 2 by 2 cell whose corners alternate in sign the value of the\n// bilinear surface at its saddle decides which diagonal pair is joined (the\n// asymptotic decider), so these are the domains of the bilinear surface\n// through the LEDs.\nfunction label(S) {\n  const V = S.V, sg = S.sg, par = S.par, c = S.lev, dec = S.dec0;\n  // dec keeps which diagonal each cell joined, 1 or 2, for the last two\n  // frames, so match can tell where a saddle crossed the level.\n  S.dec0 = S.dec;\n  S.dec = dec;\n  dec.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    sg[p] = V[p] > c ? 1 : 0;\n    par[p] = p;\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, s = sg[p];\n      if (x \u003c W - 1 && sg[p + 1] === s) union(par, p, p + 1);\n      if (y \u003c H - 1) {\n        if (sg[p + W] === s) union(par, p, p + W);\n        const q = p + W + 1;\n        if (x \u003c W - 1 && sg[q] === s && sg[p + 1] !== s && sg[p + W] !== s) {\n          const a = V[p] - c, b = V[p + 1] - c, e = V[p + W] - c, f = V[q] - c;\n          const sad = (a * f - b * e) / (a + f - b - e);\n          if (sad > 0 === (s === 1)) union(par, p, q), (dec[p] = 1);\n          else union(par, p + 1, p + W), (dec[p] = 2);\n        }\n      }\n    }\n  const comp = S.comp, area = S.area, csign = S.csign;\n  let nc = 0;\n  // Each root is the lowest LED of its domain, so it comes first.\n  for (let p = 0; p \u003c N; p++) {\n    const r = find(par, p);\n    if (r === p) {\n      comp[p] = nc;\n      area[nc] = 0;\n      csign[nc++] = sg[p];\n    } else comp[p] = comp[r];\n    area[comp[p]]++;\n  }\n  S.nc = S.count = nc;\n  let big = 0;\n  for (let i = 1; i \u003c nc; i++) if (area[i] > area[big]) big = i;\n  S.big = big;\n}\n\n// Each domain takes over the colour of the old domain of its sign that it\n// overlaps most, largest overlaps first. So a domain that splits keeps its\n// colour on the larger piece, and of two that merge the one with the larger\n// overlap keeps its colour.\nfunction match(S, d) {\n  const comp = S.comp, id = S.id, sg = S.sg, idSign = S.idSign, pairs = S.pairs, nc = S.nc, cid = S.cid, taken = S.taken, used = S.used;\n  const fl = S.fl, decay = exp(-4 * d);\n  for (let p = 0; p \u003c N; p++) fl[p] *= decay;\n  if (S.k === S.k0) saddles(S);\n  S.k0 = S.k;\n  pairs.clear();\n  let run = 0, key = -1;\n  for (let p = 0; p \u003c= N; p++) {\n    const o = p \u003c N ? id[p] : -1;\n    const kk = o >= 0 && idSign[o] === sg[p] ? comp[p] * MAXID + o : -1;\n    if (kk !== key || p === N) {\n      if (key >= 0) pairs.set(key, (pairs.get(key) || 0) + run);\n      key = kk;\n      run = 0;\n    }\n    run++;\n  }\n  const list = [...pairs].sort((a, b) => b[1] - a[1]);\n  cid.fill(-1, 0, nc);\n  taken.fill(0);\n  for (const [kk] of list) {\n    const ci = floor(kk / MAXID), o = kk % MAXID;\n    if (cid[ci] \u003c 0 && !taken[o]) (cid[ci] = o), (taken[o] = 1);\n  }\n  for (let o = 0; o \u003c MAXID; o++) if (used[o] && !taken[o]) (used[o] = 0), S.free.push(o);\n  for (let i = 0; i \u003c nc; i++)\n    if (cid[i] \u003c 0 && S.free.length) {\n      const o = S.free.pop();\n      used[o] = 1;\n      cid[i] = o;\n      idSign[o] = S.csign[i];\n      S.idHue[o] = 0.05 * (Math.random() - 0.5);\n      S.idLA[o] = log(S.area[i]);\n    }\n  for (let p = 0; p \u003c N; p++) id[p] = cid[comp[p]];\n  // The size a colour shows eases toward the true size in about a quarter\n  // of a second, so a big domain that touches a neighbour at one saddle and\n  // lets go again does not flicker. The pale mark stays on the domain that\n  // has it until another one is a quarter bigger.\n  const e = 1 - exp(-d / 0.25), area = S.area;\n  let bi = -1, top = 0;\n  for (let i = 0; i \u003c nc; i++) {\n    const o = cid[i];\n    S.idLA[o] += (log(area[i]) - S.idLA[o]) * e;\n    if (o === S.bigId) bi = i;\n    if (area[i] > top) top = area[i];\n  }\n  if (bi \u003c 0 || area[bi] * 1.25 \u003c top) S.bigId = cid[S.big];\n}\n\n// A merge or a split happens where a saddle of psi crosses the level: an LED\n// changes sign, or a cell's saddle value does. Around each such place, two\n// LEDs of one sign that were in different domains last frame and are in one\n// now mark a merge, and two that were in one and are now apart mark a split.\n// The 3 by 3 LEDs around it flash white.\nfunction saddles(S) {\n  const id = S.id, sg = S.sg, comp = S.comp, idSign = S.idSign, dec = S.dec, dec0 = S.dec0, fl = S.fl;\n  let n = 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = id[p];\n      if (!((o >= 0 && idSign[o] !== sg[p]) || (dec[p] && dec0[p] && dec[p] !== dec0[p]))) continue;\n      const x0 = x > 0 ? x - 1 : 0, x1 = x \u003c W - 1 ? x + 1 : x, y0 = y > 0 ? y - 1 : 0, y1 = y \u003c H - 1 ? y + 1 : y;\n      let hit = false;\n      for (let q = 0; q \u003c 9 && !hit; q++) {\n        const a = x - 1 + (q % 3), b = y - 1 + floor(q / 3);\n        if (a \u003c x0 || a > x1 || b \u003c y0 || b > y1) continue;\n        const u = b * W + a, ou = id[u];\n        if (ou \u003c 0 || idSign[ou] !== sg[u]) continue;\n        for (let r = q + 1; r \u003c 9; r++) {\n          const a2 = x - 1 + (r % 3), b2 = y - 1 + floor(r / 3);\n          if (a2 \u003c x0 || a2 > x1 || b2 \u003c y0 || b2 > y1) continue;\n          const v = b2 * W + a2, ov = id[v];\n          if (ov \u003c 0 || sg[v] !== sg[u] || idSign[ov] !== sg[v]) continue;\n          if ((ou !== ov) === (comp[u] === comp[v])) {\n            hit = true;\n            break;\n          }\n        }\n      }\n      if (hit) {\n        if (fl[p] \u003c 1) n++;\n        for (let b = y0; b \u003c= y1; b++) for (let a = x0; a \u003c= x1; a++) fl[b * W + a] = 1;\n      }\n    }\n  S.events = n;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const V = S.V, id = S.id, comp = S.comp, fl = S.fl, c = S.c, lev = S.lev, nc = S.nc;\n  const R = S.R || (S.R = new Float32Array(N * 3));\n  for (let i = 0; i \u003c nc; i++) {\n    const o = S.cid[i], s = S.idSign[o];\n    if (S.cid[i] === S.bigId) hsv(PALE[s][0] + S.hue, PALE[s][1], PALE[s][2], c);\n    else {\n      const u = cl((S.idLA[o] - A0) / (A1 - A0), 0, 1), P = RAMP[s ? 0 : 1];\n      hsv(P[0] + (P[3] - P[0] + (s ? 1 : 0)) * u + S.idHue[o] + S.hue, P[1] + (P[4] - P[1]) * u, P[2] + (P[5] - P[2]) * u, c);\n    }\n    R[i * 3] = c[0];\n    R[i * 3 + 1] = c[1];\n    R[i * 3 + 2] = c[2];\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, v = V[p] - lev;\n      // Distance to the level line in LEDs, the value over the gradient; the\n      // line is drawn dark, about one LED wide.\n      const gx = ((x \u003c W - 1 ? V[p + 1] : V[p]) - (x > 0 ? V[p - 1] : V[p])) / (x > 0 && x \u003c W - 1 ? 2 : 1);\n      const gy = ((y \u003c H - 1 ? V[p + W] : V[p]) - (y > 0 ? V[p - W] : V[p])) / (y > 0 && y \u003c H - 1 ? 2 : 1);\n      const f = cl((abs(v) / (sqrt(gx * gx + gy * gy) + 1e-6) - 0.2) / 0.6, 0, 1);\n      // A spark lights the saddle white, the line through it included.\n      const q = comp[p] * 3, w = 0.85 * fl[p], g = f * (1 - w), h = 255 * w;\n      display.setPixel(x, y, (R[q] * g + h) | 0, (R[q + 1] * g + h) | 0, (R[q + 2] * g + h) | 0);\n    }\n}\n","pearcey-cusp":"// ===== Patternflow pattern =====\n// Title:   Pearcey Cusp\n// Family:  wave\n// Idea:    The Pearcey integral, the wave field at the tip of a cusp caustic, computed at every LED: from a bright focus near the top its intensity opens downward into a lattice of bright spots whose wavefronts flow down the panel, and each exact zero of the field, a phase vortex, carries a mark coloured by the way its phase turns.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pearcey integral (Trevor Pearcey, 1946), the cusp diffraction catastrophe (Michael Berry and Colin Upstill, 1980)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=-1..1, Tilt=-1..1\n//\n// Knob 1: Hue. The colour of the light. At 0 it is green inside the ray caustic, where three rays cross, and teal outside it, where one ray passes; a zero is marked pink when the phase climbs clockwise round it and amber when it climbs anticlockwise. At 0.25 the light is violet and at 0.5 rose; 0.75 turns it gold.\n// Knob 2: Speed. How fast the phase turns: 0.4 turns a second for each unit, 0.8 at the opening 2. The crests run down the panel and wheel anticlockwise round a pink zero, clockwise round an amber one.\n// Knob 3: Wavenumber. The wavenumber k in octaves around the opening view, with the ray caustic held still: at 0 the panel spans x from -12 to 12 and y from 2 to -10 and holds 76 zeros; at -1 it is 0.59 of that across and 0.71 down, 18 zeros; at 1 it is 1.68 across and 1.41 down, about 285 zeros, packed as close as the LEDs can mark them.\n// Knob 4: Tilt. Adds a t^3 term to the phase, up to 1.5 t^3 at either end. A shift of t removes it again, so the field is the same Pearcey field on sheared axes: the cusp's axis leans 21 LEDs left at 1 or right at -1 by the bottom row, and its tip rises 9 rows.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The opening view in Pearcey units: x across, y down the panel.\nconst XH = 12, YT = 2, YB = -10;\n\n// Quadrature nodes. P(x, y) is the integral over real t of\n// exp(i (t^4 + y t^2 + x t)). Cauchy lets the path leave the real axis, and\n// on t(s) = s + i K s^3 / (s^2 + C^2) the integrand is real-axis-like near\n// the stationary points and dies as exp(-s^4) far out. The integrand is\n// analytic along the path, so the trapezoid rule converges geometrically:\n// 169 nodes agree with an 80-digit sum on the path t = s e^(i pi/8) to\n// 3e-10 of the field's size at 40 LEDs, tilted views among them.\nconst HS = 0.06, CC = 5, KK = 0.5, SM = 5, J = 2 * Math.ceil(SM / HS) + 1;\nconst SR = new Float64Array(J), SI = new Float64Array(J), WR = new Float64Array(J), WI = new Float64Array(J);\nfor (let j = 0; j \u003c J; j++) {\n  const s = (j - (J - 1) / 2) * HS, d = s * s + CC * CC;\n  SR[j] = s;\n  SI[j] = (KK * s * s * s) / d;\n  // dt = t'(s) ds\n  WR[j] = HS;\n  WI[j] = (HS * KK * s * s * (s * s + 3 * CC * CC)) / (d * d);\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, kn: NaN, tl: NaN, ph: 0,\n    re: new Float64Array(N), im: new Float64Array(N), amp: new Float32Array(N), ur: new Float32Array(N), ui: new Float32Array(N),\n    zs: new Int8Array(N), nz: 0, rays: new Float32Array(N), xs: new Float64Array(W), ys: new Float64Array(H),\n    Er: new Float64Array(W * J), Ei: new Float64Array(W * J), Br: new Float64Array(J), Bi: new Float64Array(J), c: [0, 0, 0],\n  };\n}\n\n// The whole field for wavenumber knob kn and tilt knob tl. Scaling the\n// wavenumber k by 2^kn scales x by k^(3/4) and y by k^(1/2), which keeps the\n// ray caustic 8 y^3 + 27 x^2 = 0 at the same LEDs. The cubic coefficient\n// scales by k^(1/4), which keeps the lean the same.\nfunction field(S, kn, tl) {\n  const s = 2 ** (kn / 2), sx = s ** 1.5, a = 1.5 * tl * sqrt(s), q = a / 4;\n  const { re, im, xs, ys, Er, Ei, Br, Bi } = S;\n  for (let m = 0; m \u003c W; m++) xs[m] = sx * XH * ((2 * m + 1) / W - 1);\n  for (let r = 0; r \u003c H; r++) ys[r] = s * (YT + ((YB - YT) * (r + 0.5)) / H);\n  // The path shifted left by a/4 is the one that suits the t^3 term, since\n  // t = u - a/4 turns t^4 + a t^3 into u^4 plus lower powers.\n  for (let m = 0; m \u003c W; m++)\n    for (let j = 0; j \u003c J; j++) {\n      const x = xs[m], e = exp(-x * SI[j]), ang = x * (SR[j] - q);\n      Er[m * J + j] = e * cos(ang);\n      Ei[m * J + j] = e * sin(ang);\n    }\n  for (let r = 0; r \u003c H; r++) {\n    const y = ys[r];\n    for (let j = 0; j \u003c J; j++) {\n      const tr = SR[j] - q, ti = SI[j];\n      const t2r = tr * tr - ti * ti, t2i = 2 * tr * ti, t3r = t2r * tr - t2i * ti, t3i = t2r * ti + t2i * tr;\n      const pr = t2r * t2r - t2i * t2i + a * t3r + y * t2r, pi = 2 * t2r * t2i + a * t3i + y * t2i, g = exp(-pi);\n      const fr = g * cos(pr), fi = g * sin(pr);\n      Br[j] = fr * WR[j] - fi * WI[j];\n      Bi[j] = fr * WI[j] + fi * WR[j];\n    }\n    for (let m = 0; m \u003c W; m++) {\n      let ar = 0, ai = 0;\n      for (let j = 0, o = m * J; j \u003c J; j++, o++) {\n        const er = Er[o], ei = Ei[o], br = Br[j], bi = Bi[j];\n        ar += br * er - bi * ei;\n        ai += br * ei + bi * er;\n      }\n      re[r * W + m] = ar;\n      im[r * W + m] = ai;\n    }\n  }\n  // Brightness: the amplitude |P| over 2.2, nearly linear, which is the\n  // square root of the intensity: the dim fan outside the cusp still reads\n  // while the focus, |P|^2 = 6.9 at most, does not swamp the lattice.\n  const { amp, ur, ui, zs, rays } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const A = sqrt(re[p] * re[p] + im[p] * im[p]);\n    amp[p] = min(1, (A / 2.2) ** 0.95);\n    ur[p] = A > 0 ? re[p] / A : 0;\n    ui[p] = A > 0 ? im[p] / A : 0;\n  }\n  // The ray picture, for the tint: on the sheared axes u = x - a y / 2 +\n  // a^3 / 8, v = y - 3 a^2 / 8 the caustic is 8 v^3 + 27 u^2 = 0. Inside it\n  // three rays cross each point, outside one. rays runs from 0 outside to 1\n  // inside across about two LEDs, by the caustic's value over its gradient.\n  const ex = (2 * sx * XH) / W, ey = (s * (YT - YB)) / H;\n  for (let r = 0; r \u003c H; r++)\n    for (let m = 0; m \u003c W; m++) {\n      const y = ys[r], u = xs[m] - (a * y) / 2 + (a * a * a) / 8, v = y - (3 * a * a) / 8;\n      const f = 8 * v * v * v + 27 * u * u, gx = 54 * u * ex, gy = 24 * v * v * ey;\n      rays[r * W + m] = cl(0.5 - f / sqrt(gx * gx + gy * gy + 1e-9) / 2, 0, 1);\n    }\n  // Zeros: the phase winds by a whole turn round a square of four LEDs.\n  // The sign of the turn is the vortex's charge; the LED of the four with\n  // the least amplitude carries the mark.\n  zs.fill(0);\n  let nz = 0;\n  const wrap = (d) => d - 2 * PI * round(d / (2 * PI));\n  for (let r = 0; r \u003c H - 1; r++)\n    for (let m = 0; m \u003c W - 1; m++) {\n      const p = r * W + m, c4 = [p, p + 1, p + W + 1, p + W];\n      let w = 0;\n      for (let k = 0; k \u003c 4; k++) {\n        const u = c4[k], v = c4[(k + 1) & 3];\n        w += wrap(atan2(im[v], re[v]) - atan2(im[u], re[u]));\n      }\n      const n = round(w / (2 * PI));\n      if (n) {\n        let b = c4[0];\n        for (let k = 1; k \u003c 4; k++) if (amp[c4[k]] \u003c amp[b]) b = c4[k];\n        zs[b] = n > 0 ? 1 : -1;\n        nz++;\n      }\n    }\n  S.nz = nz;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const kn = cl(k[2], -1, 1), tl = cl(k[3], -1, 1);\n  if (abs(kn - S.kn) > 1e-4 || abs(tl - S.tl) > 1e-4 || S.kn !== S.kn) {\n    S.kn = kn;\n    S.tl = tl;\n    field(S, kn, tl);\n  }\n  // A monochromatic wave keeps its intensity and turns its phase. P obeys\n  // dP/dy = -i d2P/dx2, the paraxial wave equation with y as minus the\n  // distance travelled, so the light runs down the panel; drawing the real\n  // part of P exp(i w t) moves each crest toward lower phase, down with it.\n  S.ph += d * S.speed * 0.4 * 2 * PI;\n  if (S.ph > 2 * PI) S.ph -= 2 * PI;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { amp, ur, ui, zs, rays, c } = S, cr = cos(S.ph), ci = sin(S.ph), h0 = 0.47 + S.hue;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, a = amp[p];\n      if (zs[p]) {\n        // A vortex: pink when the phase climbs going clockwise round the\n        // square on the panel (right, down, left, up), amber the other way.\n        hsv(zs[p] > 0 ? h0 + 0.48 : h0 + 0.67, 0.75, 0.95, c);\n      } else {\n        // The real part of the turning field over its amplitude: 1 on a\n        // crest. Crests brighten and whiten, troughs dim.\n        const w = 0.5 + 0.5 * (ur[p] * cr - ui[p] * ci), w2 = w * w;\n        hsv(h0 + 0.12 * (1 - rays[p]) - 0.1 * w, 0.85 - 0.5 * a * w2, a * (0.4 + 0.6 * w2), c);\n      }\n      display.setPixel(x, y, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n}\n","smale-horseshoe":"// ===== Patternflow pattern =====\n// Title:   Smale Horseshoe\n// Family:  fractal\n// Idea:    Smale's horseshoe map squeezes the square in the middle of the panel sideways and stretches it up past the top, then bends it back down over itself, fold after fold; the panel holds the folded ribbon of the fifth image, 32 strands about an LED wide that cross the square gold where the ribbon runs up and azure where it runs down, turning in nested arches above and nested U's below; where they cross the eight horizontal strips of points that stay in the square for three more folds they turn white, the invariant Cantor set on which the map is the shift on two symbols.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Smale's horseshoe (Stephen Smale, 1965)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strands=-1..1, Squeeze=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the rising strands are gold and the falling ones azure, with violet stable strands and white crossings; at 0.5 the rising strands turn blue and the falling ones orange.\n// Knob 2: Speed. One fold a cycle. At 2 a cycle takes 3 s and holds still for the first half; the squeeze and stretch take 0.45 s of the rest and the bend 1.05 s. At 0.2 a cycle takes 30 s, at 3 two seconds.\n// Knob 3: Strands. Which Cantor family shows. At 0 both: the images of the panel as vertical strands and the points that stay in the square for three more folds as faint violet bands, white where they cross. At -1 only the images. Towards +1 the images fade and the violet bands brighten to full, the stable set alone.\n// Knob 4: Squeeze. The factor lambda by which a fold narrows the square, 0.445 at 0 down to 0.285 at 1 (0.435 at the opening), with the stretch mu = 2 + (pi/2)(1 - lambda), 2.89 at the opening. The level drawn keeps the finest strands near an LED wide: the fifth image's 32 strands up to 0.15 and the fourth's 16 up to 0.66; from there on the third's 8, with gaps that widen as lambda falls.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (t) => t * t * (3 - 2 * t);\n\n// The domain D is the panel: x from 0 to 64, Y from 0 at the bottom row to\n// 128. The square Q runs from Y = C to QT; the cap A lies below it and the\n// cap B above.\nconst C = 32, QT = 96, HQ = 64;\n// A cycle: held still for HOLD of it, then the homotopy, its first T1 the\n// straight squeeze and stretch and the rest the bend.\nconst HOLD = 0.5, T1 = 0.3;\n\n// f lays D along a U-shaped centre line, squeezed by lambda across it and\n// stretched along it by mu through Q. The left leg runs up the left edge of\n// Q and the right leg down the right edge; between them the bend of radius R\n// turns over in B. A goes to the left foot below Q, shifted sideways only,\n// and B to the right foot, turned over. So f(D) lies in D and meets Q in two\n// vertical strips, each lambda wide; the horizontal strip of Q between the\n// two that feed the legs goes round the bend.\nfunction geom(S, lam) {\n  S.lam = lam;\n  S.w = 32 * lam;\n  S.R = 32 - S.w;\n  // The bend runs as fast as the legs: pi R = mu (HQ - 2 HQ / mu).\n  S.mu = 2 + (PI * S.R) / HQ;\n  S.len = 2 * C + HQ * S.mu;\n  // The level drawn: the finest vertical strands near an LED wide, the\n  // finest horizontal ones near an LED tall.\n  S.nf = cl(floor(log(0.85 / 64) / log(lam)), 2, 6);\n  S.nb = cl(floor(log(0.9 / HQ) / log(1 / S.mu)), 2, 6);\n}\n\n// From arc length along the centre line back to the height Y in D.\nconst isig = (S, s) => (s \u003c C ? s : s \u003c= C + HQ * S.mu ? C + (s - C) / S.mu : QT + s - C - HQ * S.mu);\n\n// The preimage under f of a point of f(D), into P. P[2] is 1 when that\n// point's piece of the strand runs the other way up from its preimage: the\n// right leg and foot, and the half of the bend past the top. False when the\n// point is not in f(D).\nfunction finv(S, X, Y, P) {\n  const lam = S.lam, w2 = 2 * S.w;\n  if (Y \u003c= QT) {\n    if (X \u003c= w2) {\n      P[0] = X / lam;\n      P[1] = Y \u003c C ? Y : C + (Y - C) / S.mu;\n      P[2] = 0;\n      return true;\n    }\n    if (X >= 64 - w2) {\n      P[0] = (64 - X) / lam;\n      P[1] = Y \u003c C ? QT + C - Y : QT - (Y - C) / S.mu;\n      P[2] = 1;\n      return true;\n    }\n    return false;\n  }\n  const dx = X - 32, dy = Y - QT, r = sqrt(dx * dx + dy * dy);\n  if (abs(r - S.R) > S.w) return false;\n  const th = atan2(dy, dx);\n  P[0] = 32 + (S.R - r) / lam;\n  P[1] = C + (HQ + S.R * (PI - th)) / S.mu;\n  P[2] = th \u003c PI / 2 ? 1 : 0;\n  return true;\n}\n\n// How many times a point can be pulled back by f and stay in D, up to nf:\n// a point of f^d(D) outside f^(d+1)(D). In Q this is the depth of the gap\n// of the Cantor set it sits in. The parity of the turns over in the first\n// nf - 1 pulls goes to S.o1 and in all nf to S.o2: whether the strand of\n// f^nf(D) through the point runs up (0) or down (1). Strands next to each\n// other always run opposite ways.\nfunction fdepth(S, X, Y, P) {\n  let k = 0, o = 0;\n  P[0] = X;\n  P[1] = Y;\n  S.o1 = 0;\n  while (k \u003c S.nf && finv(S, P[0], P[1], P)) {\n    o ^= P[2];\n    k++;\n    if (k === S.nf - 1) S.o1 = o;\n  }\n  S.o2 = o;\n  return k;\n}\n\n// How many times f can push a point forward and keep it in Q, up to nb + 1.\n// It depends on the height alone: the horizontal strips.\nfunction bdepth(S, Y) {\n  let k = 0;\n  const mu = S.mu, h = HQ / mu;\n  while (k \u003c= S.nb && Y >= C && Y \u003c= QT) {\n    k++;\n    const q = Y - C;\n    if (q \u003c h) Y = C + mu * q;\n    else if (q > HQ - h) Y = C + mu * (HQ - q);\n    else return k;\n  }\n  return k;\n}\n\n// The homotopy from the identity at tau = 0 to f at tau = 1: the panel\n// squeezed toward its left edge and stretched straight up along the centre\n// line, then the part above Q bent over, the bend's angle growing to pi.\n// phase() fixes the shape for one tau; minv() takes a point back through it\n// into P, with P[2] set where the bend has turned the strand downward, and\n// is false outside the image.\nfunction phase(S, tau) {\n  S.tau = tau;\n  if (tau \u003c T1) {\n    const a = ss(tau / T1);\n    S.sx = 1 - a + a * S.lam;\n    S.sq = 1 - a + a * S.mu;\n    S.gt = QT * (1 - a) + a * (C + HQ * S.mu);\n  } else {\n    S.phi = PI * ss((tau - T1) / (1 - T1));\n    S.ct = cos(PI - S.phi);\n    S.st = sin(PI - S.phi);\n  }\n}\n\nfunction minv(S, X, Y, P) {\n  P[2] = 0;\n  if (S.tau \u003c T1) {\n    const x = X / S.sx, y = Y \u003c C ? Y : Y \u003c= S.gt ? C + (Y - C) / S.sq : QT + Y - S.gt;\n    if (x > 64 || y > 128) return false;\n    P[0] = x;\n    P[1] = y;\n    return true;\n  }\n  const phi = S.phi, lam = S.lam, w = S.w, R = S.R;\n  let s = -1, u = 0;\n  if (Y \u003c= QT) {\n    if (X \u003c= 2 * w) (s = Y), (u = (X - w) / lam);\n  } else {\n    const dx = X - 32, dy = Y - QT, r = sqrt(dx * dx + dy * dy);\n    if (abs(r - R) \u003c= w) {\n      const th = atan2(dy, dx);\n      if (th >= PI - phi) {\n        s = QT + R * (PI - th);\n        u = (R - r) / lam;\n        P[2] = th \u003c PI / 2 ? 1 : 0;\n      }\n    }\n  }\n  if (s \u003c 0) {\n    // Past the bend the strip runs straight on, along its tangent.\n    const ct = S.ct, st = S.st, px = X - 32 - R * ct, py = Y - QT - R * st;\n    const sl = px * st - py * ct, off = -px * ct - py * st;\n    if (sl >= 0 && abs(off) \u003c= w) {\n      s = QT + R * phi + sl;\n      u = off / lam;\n      P[2] = phi > PI / 2 ? 1 : 0;\n    }\n  }\n  if (s \u003c 0 || s > S.len) return false;\n  P[0] = 32 + u;\n  P[1] = isig(S, s);\n  return true;\n}\n\nexport function setup(params) {\n  // The first second shows the folded ribbon still; the first stretch\n  // starts at 1.5 s.\n  params.s = { ph: 0.98, hue: 0, strands: 0, lam: 0, nf: 5, nb: 4, tau: 0, sx: 1, sq: 1, gt: QT, phi: 0, ct: -1, st: 0, o1: 0, o2: 0, c: [0, 0, 0], P: [0, 0, 0], pal: new Float64Array(15) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.strands = cl(k[2], -1, 1);\n  const lam = 0.445 - 0.16 * cl(k[3], 0, 1);\n  if (lam !== S.lam) geom(S, lam);\n  S.ph += (d * cl(k[1], 0.2, 3)) / 6;\n  S.ph -= floor(S.ph);\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const tau = S.ph \u003c HOLD ? 0 : (S.ph - HOLD) / (1 - HOLD);\n  phase(S, tau);\n  const P = S.P, c = S.c, pal = S.pal, h = S.hue, nf = S.nf, nb = S.nb;\n  const wf = min(1, 1 - S.strands), wb = min(1, 1 + S.strands), vb = 0.3 + 0.7 * max(0, S.strands);\n  // Rising strands gold and falling strands azure; where a stable strand\n  // crosses them, near white. The stable strands alone are violet.\n  const cols = [0.12, 0.85, 1, 0.58, 0.75, 0.8, 0.12, 0.12, 1, 0.58, 0.3, 0.9, 0.78, 0.65, vb];\n  for (let n = 0; n \u003c 15; n += 3) {\n    hsv(h + cols[n], cols[n + 1], cols[n + 2], c);\n    pal[n] = c[0];\n    pal[n + 1] = c[1];\n    pal[n + 2] = c[2];\n  }\n  for (let j = 0; j \u003c H; j++) {\n    const Y = 127.5 - j;\n    for (let i = 0; i \u003c W; i++) {\n      // The drawn depths move with the ribbon and climb by tau through the\n      // fold, so the picture at the end of a cycle is the one it began with:\n      // f maps the strands of each level onto those of the next.\n      let v = tau - 1, e = 0, dn = 0;\n      if (minv(S, i + 0.5, Y, P)) {\n        const fl = P[2];\n        e = max(0, bdepth(S, P[1]) - tau);\n        v = fdepth(S, P[0], P[1], P) + tau;\n        // Which way the strand runs, by the turns of the last nf pulls,\n        // handing over to the last nf - 1 as the fold adds one more.\n        dn = (1 - tau) * (S.o2 ^ fl) + tau * (S.o1 ^ fl);\n      } else if (tau > 0.6 && i + 0.5 > 2 * S.w && i + 0.5 \u003c 64 - 2 * S.w) {\n        // In the gap the ribbon leaves between its legs, the stable strips\n        // of Q come back while the bend closes.\n        e = nb - 1 + ((tau - 0.6) / 0.4) * (bdepth(S, Y) - nb + 1);\n      }\n      const F = wf * cl(v - (nf - 1), 0, 1), B = wb * cl(e - (nb - 1), 0, 1);\n      const up = 1 - dn, a = F * (1 - B), b = F * B, g = (1 - F) * B;\n      for (let q = 0; q \u003c 3; q++) c[q] = a * (up * pal[q] + dn * pal[3 + q]) + b * (up * pal[6 + q] + dn * pal[9 + q]) + g * pal[12 + q];\n      display.setPixel(i, j, min(255, c[0]) | 0, min(255, c[1]) | 0, min(255, c[2]) | 0);\n    }\n  }\n}\n","stable-marriage":"// ===== Patternflow pattern =====\n// Title:   Stable Marriage\n// Family:  algo\n// Idea:    Gale and Shapley's deferred acceptance between 16 people along the top edge and 16 along the bottom, every proposal a line that runs the panel's full height; a proposal held stays lit and one turned away flashes and fades, and when a receiver trades up the line it held snaps in two. Once the top has its stable matching the bottom proposes on the same lists, and then the pairs where the two stable matchings differ swap back and forth.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: deferred acceptance (David Gale and Lloyd Shapley, 1962)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Agreement=0..1, Choosy=0..1\n//\n// Knob 1: Hue. Each end of a line, and the tile of each person, is coloured by the rank that person gives the partner: at 0 a first choice is green and the last pink, with blue at about the fifth. Turning it moves the whole scale round the colour wheel.\n// Knob 2: Speed. Rounds a second: 2 at the opening 2. In a round every free proposer sends one proposal; a round of eight or more takes a whole round's time, a round of one, as in the chains of rejections that end a run, 0.35 of it. A proposal takes 0.6 of its round to cross.\n// Knob 3: Agreement. How much everyone shares one ranking of the other side, left best. At 0 each list is an independent shuffle and the lines cross every which way: a run takes 47 proposals on average, close to n ln n = 44, and in 9 runs of 10 the two sides' matchings differ. At 1 everyone agrees: all 16 first proposals land on the bottom left, the run takes 136 proposals in 16 rounds, and it ends in 16 parallel lines, the one stable matching.\n// Knob 4: Choosy. The share of the other side each person refuses outright, from none at 0 to three quarters at 1, where 7.5 of the 16 on each side stay single on average. A single person's tile is dim grey, and the same people are single in both stable matchings.\n\nconst W = 64, H = 128, n = 16, SP = W / n, Y0 = 4, Y1 = 123;\nconst { floor, min, max, abs, sqrt, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst XP = (i) => SP * i + (SP >> 1);\n// Rank given to someone a person will not take.\nconst NO = 999;\n// The phases of a cycle. The top proposes and its matching holds; the\n// bottom proposes on the same lists and its matching holds; then the two are\n// compared, and the panel fades to new lists.\nconst RUN_A = 0, HOLD_A = 1, RUN_B = 2, HOLD_B = 3, COMPARE = 4, FADE = 5;\n// Lengths in rounds; FLY is when the proposals of a round arrive.\nconst T_HOLD_A = 3, T_HOLD_B = 2, T_CMP = 8, T_FADE = 1.5, FLY = 0.6, T_GONE = 0.8;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, agree: -1, choosy: -1, phase: RUN_A, pt: 0, rt: 0, decided: true,\n    // Lists: lt[i * n + k] is the k-th choice of top person i, lb the same\n    // for the bottom; rkt and rkb hold the rank each gives, NO if refused.\n    lt: new Int8Array(n * n), lb: new Int8Array(n * n), nt: new Int8Array(n), nb: new Int8Array(n),\n    rkt: new Int16Array(n * n), rkb: new Int16Array(n * n),\n    nx: new Int8Array(n), hold: new Int8Array(n), hb: new Float64Array(n), rl: 1,\n    ma: new Int8Array(n), mb: new Int8Array(n), props: 0, propsA: 0, propsB: 0, rounds: 0,\n    fx: [],\n    buf: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],\n  };\n}\n\n// Preferences: top person i values bottom person j at\n// A (1 - j / (n - 1)) + (1 - A) u with u uniform, and the bottom the same way,\n// so at A = 1 everyone ranks the other side left to right. Each pair is\n// refused by each side with chance c.\nfunction newPrefs(S) {\n  const A = S.agree, c = 0.75 * S.choosy, u = new Float64Array(n), idx = [];\n  for (let side = 0; side \u003c 2; side++) {\n    const L = side ? S.lb : S.lt, R = side ? S.rkb : S.rkt, len = side ? S.nb : S.nt;\n    for (let i = 0; i \u003c n; i++) {\n      idx.length = 0;\n      for (let j = 0; j \u003c n; j++) {\n        u[j] = A * (1 - j / (n - 1)) + (1 - A) * Math.random();\n        R[i * n + j] = NO;\n        if (Math.random() >= c) idx.push(j);\n      }\n      idx.sort((a, b) => u[b] - u[a]);\n      len[i] = idx.length;\n      for (let k = 0; k \u003c idx.length; k++) {\n        L[i * n + k] = idx[k];\n        R[i * n + idx[k]] = k + 1;\n      }\n    }\n  }\n}\n\n// Ranks seen from each end of the pair (top a, bottom b).\nconst rankTop = (S, a, b) => S.rkt[a * n + b];\nconst rankBot = (S, a, b) => S.rkb[b * n + a];\n\nfunction startRun(S, side) {\n  S.side = side;\n  S.nx.fill(0);\n  S.hold.fill(-1);\n  S.props = 0;\n  S.rounds = 0;\n  S.rt = S.t - 1;\n  S.rl = 1;\n  S.decided = true;\n  S.fx = S.fx.filter((e) => e.k >= 2);\n}\n\n// The proposals of one round leave together: every free proposer with\n// someone left on the list sends one. Returns how many left.\nfunction sendRound(S) {\n  const side = S.side, L = side ? S.lb : S.lt, len = side ? S.nb : S.nt, held = new Uint8Array(n);\n  for (let r = 0; r \u003c n; r++) if (S.hold[r] >= 0) held[S.hold[r]] = 1;\n  let sent = 0;\n  for (let p = 0; p \u003c n; p++) {\n    if (held[p] || S.nx[p] >= len[p]) continue;\n    const r = L[p * n + S.nx[p]++];\n    S.fx.push({ k: side, a: side ? r : p, b: side ? p : r, t0: S.t });\n    sent++;\n  }\n  S.props += sent;\n  if (sent) S.rounds++;\n  return sent;\n}\n\n// The receivers answer: each keeps the best of what it holds and what just\n// arrived, among those it will take, and turns the rest away.\nfunction decide(S) {\n  const side = S.side, fly = [], keep = [];\n  for (const e of S.fx) (e.k === side ? fly : keep).push(e);\n  const best = new Int8Array(n).fill(-1), bestRank = new Int16Array(n).fill(NO);\n  for (let r = 0; r \u003c n; r++) {\n    const h = S.hold[r];\n    if (h >= 0) {\n      best[r] = h;\n      bestRank[r] = side ? rankTop(S, r, h) : rankBot(S, h, r);\n    }\n  }\n  for (const e of fly) {\n    const p = side ? e.b : e.a, r = side ? e.a : e.b, rk = side ? rankTop(S, r, p) : rankBot(S, p, r);\n    if (rk \u003c bestRank[r]) (best[r] = p), (bestRank[r] = rk);\n  }\n  for (const e of fly) {\n    const p = side ? e.b : e.a, r = side ? e.a : e.b;\n    if (best[r] === p && S.hold[r] !== p) continue;\n    keep.push({ k: 2, a: e.a, b: e.b, t0: S.t });\n  }\n  for (let r = 0; r \u003c n; r++)\n    if (best[r] !== S.hold[r]) {\n      const o = S.hold[r];\n      if (o >= 0) keep.push({ k: 3, a: side ? r : o, b: side ? o : r, t0: S.t });\n      S.hold[r] = best[r];\n      S.hb[r] = S.t;\n    }\n  S.fx = keep;\n}\n\n// The run's matching as top person to bottom person, -1 for single.\nfunction matching(S, m) {\n  m.fill(-1);\n  for (let r = 0; r \u003c n; r++) {\n    const p = S.hold[r];\n    if (p >= 0) S.side ? (m[r] = p) : (m[p] = r);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const ag = cl(k[2], 0, 1), ch = cl(k[3], 0, 1);\n  if (abs(ag - S.agree) > 0.02 || abs(ch - S.choosy) > 0.02) {\n    // New lists from the start whenever Agreement or Choosy moves.\n    S.agree = ag;\n    S.choosy = ch;\n    newPrefs(S);\n    S.fx = [];\n    S.phase = RUN_A;\n    S.pt = S.t;\n    startRun(S, 0);\n  }\n  S.t += d * S.speed;\n  const T = S.t, el = T - S.pt;\n  if (S.phase === RUN_A || S.phase === RUN_B) {\n    if (!S.decided && T - S.rt >= FLY * S.rl) {\n      decide(S);\n      S.decided = true;\n    }\n    if (S.decided && T - S.rt >= S.rl - 1e-9) {\n      S.rt = T;\n      const sent = sendRound(S);\n      // A round of one proposal, the chains of rejections that end a run,\n      // takes 0.35 of the time of a round of eight or more.\n      S.rl = 0.35 + 0.65 * min(1, (sent - 1) / 7);\n      for (const e of S.fx) if (e.k \u003c 2 && e.t0 === T) e.fl = FLY * S.rl;\n      if (sent) S.decided = false;\n      else {\n        // Nobody free has anyone left to ask: the matching is stable.\n        if (S.phase === RUN_A) matching(S, S.ma), (S.propsA = S.props), (S.phase = HOLD_A);\n        else matching(S, S.mb), (S.propsB = S.props), (S.phase = HOLD_B);\n        S.pt = T;\n      }\n    }\n  } else if (S.phase === HOLD_A && el >= T_HOLD_A) {\n    S.phase = RUN_B;\n    S.pt = T;\n    startRun(S, 1);\n  } else if (S.phase === HOLD_B && el >= T_HOLD_B) {\n    S.phase = COMPARE;\n    S.pt = T;\n  } else if (S.phase === COMPARE && el >= T_CMP) {\n    S.phase = FADE;\n    S.pt = T;\n  } else if (S.phase === FADE && el >= T_FADE) {\n    newPrefs(S);\n    S.fx = [];\n    S.phase = RUN_A;\n    S.pt = T;\n    startRun(S, 0);\n  }\n  S.fx = S.fx.filter((e) => e.k \u003c 2 || T - e.t0 \u003c T_GONE);\n}\n\n// Rank to colour: green for a first choice through blue to pink for a last.\nfunction rankCol(S, rank, o) {\n  const q = rank >= NO ? 1 : (rank - 1) / (n - 1);\n  return hsv(0.3 + S.hue + 0.6 * sqrt(q), 0.85, 1, o);\n}\n\n// Where lines cross, each channel keeps the brighter of the two.\nfunction add(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W) return;\n  const o = (y * W + x) * 3;\n  buf[o] = max(buf[o], r);\n  buf[o + 1] = max(buf[o + 1], g);\n  buf[o + 2] = max(buf[o + 2], b);\n}\n\n// The line from top person a to bottom person b over rows ya..yb, its\n// colour running from ca at the top end to cb at the bottom, times v. Each\n// row lights the LEDs within LW / 2 of the line, the edge ones in part.\nconst LW = 1.5;\nfunction line(buf, a, b, ya, yb, ca, cb, v, white) {\n  const xa = XP(a), xb = XP(b), y0 = max(Y0, Math.ceil(ya)), y1 = min(Y1, floor(yb));\n  for (let y = y0; y \u003c= y1; y++) {\n    const f = (y - Y0) / (Y1 - Y0), x = xa + (xb - xa) * f;\n    const r = ((ca[0] + (cb[0] - ca[0]) * f) * (1 - white) + 255 * white) * v, g = ((ca[1] + (cb[1] - ca[1]) * f) * (1 - white) + 255 * white) * v, bl = ((ca[2] + (cb[2] - ca[2]) * f) * (1 - white) + 255 * white) * v;\n    for (let xi = floor(x - LW / 2); xi \u003c= x + LW / 2; xi++) {\n      const k = cl(LW / 2 + 0.5 - abs(xi - x), 0, 1);\n      if (k > 0) add(buf, xi, y, r * k, g * k, bl * k);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, c = S.c, c2 = S.c2, T = S.t, el = T - S.pt, ph = S.phase;\n  buf.fill(0);\n  const fade = ph === FADE ? max(0, 1 - el / T_FADE) : 1;\n  const pair = (a, b, v, white) => {\n    rankCol(S, rankTop(S, a, b), c);\n    rankCol(S, rankBot(S, a, b), c2);\n    line(buf, a, b, Y0, Y1, c, c2, v, white);\n  };\n  // The first stable matching stays as dim ghosts while the bottom proposes.\n  if (ph === RUN_B || ph === HOLD_B) for (let a = 0; a \u003c n; a++) if (S.ma[a] >= 0) pair(a, S.ma[a], 0.25, 0.3);\n  if (ph \u003c= HOLD_B) {\n    // Held proposals; one just taken glows white for half a round.\n    for (let r = 0; r \u003c n; r++) {\n      const p = S.hold[r];\n      if (p \u003c 0) continue;\n      const a = S.side ? r : p, b = S.side ? p : r, g = max(0, 1 - (T - S.hb[r]) * 2);\n      pair(a, b, 0.85 + 0.15 * g, 0.5 * g);\n    }\n  } else {\n    // Compare: pairs in both matchings stay; the others swap between the\n    // top's best matching and the bottom's best, a full swing in 4 rounds.\n    const w = 0.5 + 0.5 * cos((PI * el) / 2);\n    for (let a = 0; a \u003c n; a++) {\n      const x = S.ma[a], y = S.mb[a];\n      if (x >= 0 && x === y) pair(a, x, 0.45 * fade, 0);\n      else {\n        if (x >= 0) pair(a, x, w * fade, 0.25 * w);\n        if (y >= 0) pair(a, y, (1 - w) * fade, 0.25 * (1 - w));\n      }\n    }\n  }\n  for (const e of S.fx) {\n    const age = T - e.t0;\n    if (e.k \u003c 2) {\n      // In flight: the proposer's end coloured by the rank it gives, a white\n      // head running across the panel.\n      const fr = min(1, age / e.fl), down = e.k === 0;\n      rankCol(S, down ? rankTop(S, e.a, e.b) : rankBot(S, e.a, e.b), c);\n      const yh = down ? Y0 + (Y1 - Y0) * fr : Y1 - (Y1 - Y0) * fr;\n      line(buf, e.a, e.b, down ? Y0 : yh, down ? yh : Y1, c, c, 0.55, 0.15);\n      line(buf, e.a, e.b, yh - 3, yh + 3, c, c, 0.9, 0.8);\n    } else if (e.k === 2) {\n      // Turned away: a flash that fades.\n      const q = 1 - age / T_GONE;\n      rankCol(S, rankTop(S, e.a, e.b), c);\n      rankCol(S, rankBot(S, e.a, e.b), c2);\n      line(buf, e.a, e.b, Y0, Y1, c, c2, 0.8 * q * q, 0.6 * q);\n    } else {\n      // Snapped: the line breaks at its middle and each half pulls back to\n      // its own person.\n      const q = age / T_GONE, mid = (Y0 + Y1) / 2, l = (mid - Y0) * (1 - q);\n      rankCol(S, rankTop(S, e.a, e.b), c);\n      rankCol(S, rankBot(S, e.a, e.b), c2);\n      line(buf, e.a, e.b, Y0, Y0 + l - 1, c, c2, 0.9 * (1 - q), 0.3);\n      line(buf, e.a, e.b, Y1 - l + 1, Y1, c, c2, 0.9 * (1 - q), 0.3);\n    }\n  }\n  // People: a tile of three by three LEDs at each end, in the colour of the\n  // rank of what they hold now, dim grey while single.\n  const mt = new Int8Array(n).fill(-1), mbm = new Int8Array(n).fill(-1);\n  if (ph \u003c= HOLD_B) {\n    for (let r = 0; r \u003c n; r++) {\n      const p = S.hold[r];\n      if (p \u003c 0) continue;\n      S.side ? ((mt[r] = p), (mbm[p] = r)) : ((mt[p] = r), (mbm[r] = p));\n    }\n  } else {\n    const m = ph === COMPARE && cos((PI * el) / 2) \u003c 0 ? S.mb : S.ma;\n    for (let a = 0; a \u003c n; a++) if (m[a] >= 0) (mt[a] = m[a]), (mbm[m[a]] = a);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    for (const top of [1, 0]) {\n      const o = top ? mt[i] : mbm[i];\n      if (o >= 0) rankCol(S, top ? rankTop(S, i, o) : rankBot(S, o, i), c);\n      else c[0] = c[1] = c[2] = 60;\n      const y0 = top ? 0 : H - 3;\n      for (let y = y0; y \u003c y0 + 3; y++) for (let x = XP(i) - 1; x \u003c= XP(i) + 1; x++) add(buf, x, y, c[0] * fade, c[1] * fade, c[2] * fade);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) | 0, min(255, buf[o + 1]) | 0, min(255, buf[o + 2]) | 0);\n}\n","stit-tessellation":"// ===== Patternflow pattern =====\n// Title:   STIT Tessellation\n// Family:  cells\n// Idea:    The panel starts as one cell, and as in Nagel and Weiss's STIT process every cell waits an exponential time at a rate of its perimeter over pi before a random line among those that hit it cuts it in two, so each new segment flashes white and ends on older ones in T junctions, never crossing them; once the cells reach their density the view dives toward a slowly wandering point while the cutting runs on for just the time that restores the same law, since the tessellation at time t scaled by t is the one at time 1, and cells that leave the panel are dropped.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: STIT tessellations (Werner Nagel and Viola Weiss, 2005)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Cells=0..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. A cut gives its two halves the parent's colour stepped 0.05 to 0.1 round the wheel in opposite directions, one lighter and one darker, kept within 0.34 of the centre, so the oldest lines part families of colour. At 0 the centre is blue and the cells run from lime through cyan and violet to rose; at 0.5 the centre is orange.\n// Knob 2: Speed. At 2 the first cells reach their density in 1.5 s; then the view closes in by e^0.24 a second, twice as close every 2.9 s, and about 18 cuts land a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Axes. The share of the cutting lines that run along the two axes instead of in a uniform direction. At 0 the isotropic STIT; at 1 every line is horizontal or vertical and the cells are rectangles, the Mondrian process (Daniel Roy and Yee Whye Teh, 2008). Between the two a mix, still a STIT.\n// Knob 4: Cells. The scale of the dive, which keeps the panel looking at the process at time 1/kappa in LED units, 1 + 384/(pi kappa) + 8192/(pi kappa^2) cells on average: 42 at 0, 46 at the opening, 89 at 0.5, 194 at 1.\n// Buttons: K1 tap starts over from one cell: the dive pauses while the STIT grows again from time zero.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Edge times: the panel's border is never drawn.\nconst BORDER = -1e9;\n\n// A cell is a convex polygon in LED units: corners x, y and for each edge,\n// from corner i to i + 1, the time it was cut. clk is the exponential mass\n// left on its clock; hv and lv its colour.\nfunction props(c) {\n  const x = c.x, y = c.y, n = x.length;\n  let a = 0, p = 0, x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c n; i++) {\n    const j = i + 1 === n ? 0 : i + 1;\n    a += x[i] * y[j] - x[j] * y[i];\n    p += sqrt((x[j] - x[i]) ** 2 + (y[j] - y[i]) ** 2);\n    if (x[i] \u003c x0) x0 = x[i];\n    if (x[i] > x1) x1 = x[i];\n    if (y[i] \u003c y0) y0 = y[i];\n    if (y[i] > y1) y1 = y[i];\n  }\n  c.area = abs(a) / 2;\n  c.per = p;\n  c.x0 = x0;\n  c.x1 = x1;\n  c.y0 = y0;\n  c.y1 = y1;\n  return c;\n}\n\nconst windowCell = () => props({ x: [0, W, W, 0], y: [0, 0, H, H], t: [BORDER, BORDER, BORDER, BORDER], clk: 0, hv: 0, lv: 0 });\n\n// The part of cell c where nx x + ny y \u003c= p, or null. The cut edge carries\n// time tc; edges cut short keep their own.\nfunction half(c, nx, ny, p, tc) {\n  const x = c.x, y = c.y, t = c.t, n = x.length, ox = [], oy = [], ot = [];\n  for (let i = 0; i \u003c n; i++) {\n    const j = i + 1 === n ? 0 : i + 1;\n    const si = nx * x[i] + ny * y[i] - p, sj = nx * x[j] + ny * y[j] - p;\n    if (si \u003c= 0) {\n      ox.push(x[i]);\n      oy.push(y[i]);\n      ot.push(t[i]);\n    }\n    if ((si \u003c 0 && sj > 0) || (si > 0 && sj \u003c 0)) {\n      const f = si / (si - sj);\n      ox.push(x[i] + f * (x[j] - x[i]));\n      oy.push(y[i] + f * (y[j] - y[i]));\n      ot.push(si \u003c 0 ? tc : t[i]);\n    }\n  }\n  if (ox.length \u003c 3) return null;\n  const o = props({ x: ox, y: oy, t: ot, clk: c.clk, hv: c.hv, lv: c.lv });\n  return o.area > 1e-6 ? o : null;\n}\n\n// The rate at which a cell is cut, the measure of the lines that hit it:\n// lines in a uniform direction with weight 1 - m give perimeter / pi by\n// Cauchy's formula, lines along the two axes with weight m give half the\n// width plus half the height.\nconst rate = (c, m) => ((1 - m) * c.per) / PI + (m * (c.x1 - c.x0 + c.y1 - c.y0)) / 2;\n\n// A line from that measure among the lines that hit c, as nx x + ny y = p.\nfunction cutLine(c, m, L) {\n  const bw = c.x1 - c.x0, bh = c.y1 - c.y0;\n  if (Math.random() * rate(c, m) \u003c (m * (bw + bh)) / 2) {\n    if (Math.random() * (bw + bh) \u003c bw) (L[0] = 1), (L[1] = 0), (L[2] = c.x0 + Math.random() * bw);\n    else (L[0] = 0), (L[1] = 1), (L[2] = c.y0 + Math.random() * bh);\n    return;\n  }\n  // Uniform direction, uniform offset across the cell's bounding circle,\n  // kept when the line meets the cell.\n  const cx = (c.x0 + c.x1) / 2, cy = (c.y0 + c.y1) / 2, r = sqrt(bw * bw + bh * bh) / 2;\n  for (;;) {\n    const th = Math.random() * PI, nx = cos(th), ny = sin(th), p = nx * cx + ny * cy + (2 * Math.random() - 1) * r;\n    let lo = 1e9, hi = -1e9;\n    for (let i = 0; i \u003c c.x.length; i++) {\n      const s = nx * c.x[i] + ny * c.y[i];\n      if (s \u003c lo) lo = s;\n      if (s > hi) hi = s;\n    }\n    if (p > lo && p \u003c hi) {\n      L[0] = nx;\n      L[1] = ny;\n      L[2] = p;\n      return;\n    }\n  }\n}\n\nconst clock = () => -log(1 - Math.random());\n// Folds v back into -r..r.\nconst refl = (v, r) => (v > r ? 2 * r - v : v \u003c -r ? -2 * r - v : v);\n\nfunction split(S, k, tc) {\n  const c = S.cells[k], L = S.L;\n  cutLine(c, S.m, L);\n  const a = half(c, L[0], L[1], L[2], tc), b = half(c, -L[0], -L[1], -L[2], tc);\n  if (!a || !b) return;\n  a.clk = clock();\n  b.clk = clock();\n  // The two halves take their parent's colour, one a step one way round\n  // the wheel and lighter or darker, the other the opposite step.\n  const dh = (Math.random() \u003c 0.5 ? 1 : -1) * (0.05 + 0.05 * Math.random()), dl = Math.random() \u003c 0.5 ? 0.1 : -0.1;\n  a.hv = refl(c.hv + dh, 0.34);\n  b.hv = refl(c.hv - dh, 0.34);\n  a.lv = refl(c.lv + dl, 0.2);\n  b.lv = refl(c.lv - dl, 0.2);\n  S.cells[k] = a;\n  S.cells.push(b);\n  S.splits++;\n}\n\nexport function setup(params) {\n  params.s = { time: 0, hue: 0, m: 0, kap: 9, T: 0, cells: [windowCell()], splits: 0, L: [0, 0, 0], c: [0, 0, 0], zx: W / 2, zy: H / 2, ph: 0, seen: new Uint8Array(W * H) };\n  params.s.cells[0].clk = clock();\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.m = cl(k[2], 0, 1);\n  S.kap = 9.6 * 0.4167 ** cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.cells = [windowCell()];\n    S.cells[0].clk = clock();\n    S.T = 0;\n  }\n  const tau = d * cl(k[1], 0.2, 3);\n  S.time += d;\n  S.ph += tau;\n  // In LED units the panel shows the process at time 1/kappa. From one\n  // cell it first runs up to that time, in 1.5 s at Speed 2. Then the dive:\n  // the view closes in by z on a point that wanders slowly, and the process\n  // runs on for the time that brings it back to the same law, because Y(t)\n  // scaled by t has the law of Y(1). STIT's restriction to a window is a\n  // STIT in that window, so the cells can be clipped to the panel and the\n  // ones that leave it dropped.\n  let z = 1, dlt;\n  if (S.T \u003c 1 / S.kap) {\n    dlt = min(1 / S.kap - S.T, tau / (3 * S.kap));\n    S.T += dlt;\n  } else {\n    z = exp(0.12 * tau);\n    dlt = (1 - 1 / z) / S.kap;\n  }\n  S.zx = W / 2 + 14 * sin(0.21 * S.ph);\n  S.zy = H / 2 + 34 * sin(0.13 * S.ph + 1);\n  const cells = S.cells, out = [];\n  for (let i = 0; i \u003c cells.length; i++) {\n    let c = cells[i];\n    if (z !== 1) {\n      for (let v = 0; v \u003c c.x.length; v++) {\n        c.x[v] = S.zx + z * (c.x[v] - S.zx);\n        c.y[v] = S.zy + z * (c.y[v] - S.zy);\n      }\n      props(c);\n      if (c.x1 \u003c= 0 || c.x0 >= W || c.y1 \u003c= 0 || c.y0 >= H) continue;\n      if (c.x0 \u003c 0) c = half(c, -1, 0, 0, BORDER);\n      if (c && c.x1 > W) c = half(c, 1, 0, W, BORDER);\n      if (c && c.y0 \u003c 0) c = half(c, 0, -1, 0, BORDER);\n      if (c && c.y1 > H) c = half(c, 0, 1, H, BORDER);\n    }\n    if (c) out.push(c);\n  }\n  S.cells = out;\n  // Each cell's clock runs at its rate; when it runs out the cell is cut.\n  const n = out.length;\n  for (let i = 0; i \u003c n; i++) {\n    const c = out[i];\n    c.clk -= rate(c, S.m) * dlt;\n    if (c.clk \u003c= 0) split(S, i, S.time);\n  }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const seen = S.seen, c = S.c, now = S.time, ex = [], ey = [], ed = [], et = [];\n  seen.fill(0);\n  for (const cell of S.cells) {\n    hsv(S.hue + 0.62 + cell.hv, 0.7, 0.78 + cell.lv, c);\n    const r = c[0], g = c[1], b = c[2];\n    // The drawn edges: unit normal, offset and the time of the cut.\n    const x = cell.x, y = cell.y, t = cell.t, n = x.length;\n    ex.length = ey.length = ed.length = et.length = 0;\n    for (let i = 0; i \u003c n; i++) {\n      if (t[i] === BORDER) continue;\n      const j = i + 1 === n ? 0 : i + 1, dx = x[j] - x[i], dy = y[j] - y[i], l = sqrt(dx * dx + dy * dy) || 1;\n      ex.push(-dy / l);\n      ey.push(dx / l);\n      ed.push((-dy * x[i] + dx * y[i]) / l);\n      et.push(t[i]);\n    }\n    // Fill the LEDs whose centres the cell holds, row by row, with a dark\n    // line where a centre lies within 0.62 LED of an edge, flashing white\n    // for half a second after the cut.\n    const j0 = max(0, Math.ceil(cell.y0 - 0.5)), j1 = min(H - 1, floor(cell.y1 - 0.5));\n    for (let row = j0; row \u003c= j1; row++) {\n      const yc = row + 0.5;\n      let xl = 1e9, xr = -1e9;\n      for (let i = 0; i \u003c n; i++) {\n        const j = i + 1 === n ? 0 : i + 1;\n        if ((y[i] - yc) * (y[j] - yc) > 0 || y[i] === y[j]) continue;\n        const xx = x[i] + ((yc - y[i]) / (y[j] - y[i])) * (x[j] - x[i]);\n        if (xx \u003c xl) xl = xx;\n        if (xx > xr) xr = xx;\n      }\n      const i0 = max(0, Math.ceil(xl - 0.5)), i1 = min(W - 1, Math.ceil(xr - 0.5) - 1);\n      for (let col = i0; col \u003c= i1; col++) {\n        const p = row * W + col;\n        if (seen[p]) continue;\n        seen[p] = 1;\n        const xc = col + 0.5;\n        let dm = 9, tm = BORDER;\n        for (let e = 0; e \u003c ex.length; e++) {\n          const dd = abs(ex[e] * xc + ey[e] * yc - ed[e]);\n          if (dd \u003c dm) (dm = dd), (tm = et[e]);\n        }\n        const w = cl((0.62 - dm) / 0.3, 0, 1), f = exp(-(now - tm) / 0.5) * 255;\n        display.setPixel(col, row, (r + w * (f - r)) | 0, (g + w * (f - g)) | 0, (b + w * (f - b)) | 0);\n      }\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) if (!seen[p]) display.setPixel(p % W, (p / W) | 0, 0, 0, 0);\n}\n","stormer-trap":"// ===== Patternflow pattern =====\n// Title:   Størmer Trap\n// Family:  particle\n// Idea:    Charged particles in the field of a magnetic dipole lying across the panel are integrated in three dimensions: each one spirals along a faint field-line loop that stands up to the top or the bottom of the panel and turns back at a mirror point near the centre, while the whole belt drifts slowly round the dipole's axis, positive charges one way and negative ones the other; the few inside the loss cone reach the small sphere at the centre and flash where they land.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Størmer's problem, charged particles in a dipole field (Carl Størmer, 1907)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Energy=0..1, Pitch=0..90\n//\n// Knob 1: Hue. Turns both charges round the colour wheel together. At 0 the positive charges are gold and the negative ones sky blue, at 0.5 blue and orange; the field lines stay a faint violet.\n// Knob 2: Speed. At 2 a particle covers 100 LEDs a second and one on an outer shell goes from one mirror point to the other and back in two to three seconds, while the belt takes about 100 s to drift once round. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Energy. The particles' momentum against the field, given as the outermost shell's distance from the centre in Størmer lengths, from 0.19 at 0 to 1 at 1. At 0 a gyration at the top of an outer loop is 4.5 LEDs across and the magnetic moment holds to a fifth of a percent. Størmer showed that a particle on the equator nearer than sqrt(2) - 1 = 0.414 of his length can never leave, whatever its direction, and the outermost shell passes that at 0.47. Around 0.5 the gyrations swell to 24 LEDs and the moment breaks; past it the orbits begin to leave the panel, two a second at 0.75 and at 1 nearly all of them within a second or two.\n// Knob 4: Pitch. The smallest angle, in degrees, between a particle's velocity and the field where it crosses the equator; each particle starts between it and 60% of the way to 90. At 0 most dive deep toward the sphere, and the few inside the loss cone (1.9 degrees on the outermost shell, 4.9 on the innermost) land on it within one bounce. At 90 they all stay on the equator, a tall thin ellipse in the tilted view, and only gyrate and drift.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// NP particles on shells LMIN to LMAX LEDs from the centre at the equator,\n// round a sphere of radius RS. RATE is the simulated time per second at\n// Speed 1; a particle moves one LED per unit of it.\nconst NP = 48, RS = 8, LMIN = 34, LMAX = 62, RATE = 50;\n// The view is turned TILT radians about the vertical, so a ring round the\n// dipole's axis shows as a narrow ellipse instead of a line.\nconst TILT = 0.21, CT = cos(TILT), ST = sin(TILT);\n// Largest gyration angle and largest distance one Boris step may take.\nconst DPHI = 0.3, DMAX = 0.5;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The dipole points along +x, across the panel; y is up and z comes out of\n// the panel toward the viewer. B = k (3 x r / r^5 - x_hat / r^3), with k the\n// dipole moment times the charge-to-mass ratio, so that a charge s = +1 or -1\n// feels dv/dt = s v x B.\nfunction field(x, y, z, k, o) {\n  const r2 = x * x + y * y + z * z, i3 = k / (r2 * sqrt(r2)), f = (3 * x) / r2;\n  o[0] = i3 * (f * x - 1);\n  o[1] = i3 * f * y;\n  o[2] = i3 * f * z;\n}\n\n// The latitude where a particle of equatorial pitch angle a mirrors: there\n// the field is 1 / sin^2(a) times its equatorial value, and along a dipole\n// field line B / B_eq = sqrt(1 + 3 sin^2 l) / cos^6 l.\nfunction mirrorLat(s2) {\n  let lo = 0, hi = PI / 2 - 1e-6;\n  for (let i = 0; i \u003c 40; i++) {\n    const m = (lo + hi) / 2, c = cos(m), sn = sin(m), g = (c * c * c * c * c * c) / sqrt(1 + 3 * sn * sn);\n    if (g > s2) lo = m;\n    else hi = m;\n  }\n  return lo;\n}\n\n// Equatorial distance from the centre in Størmer lengths for the outermost\n// shell, from the Energy knob. The Størmer length is sqrt(k / v) with v = 1.\nconst sOf = (u) => 0.19 * (1 / 0.19) ** u;\n\nexport function setup(params) {\n  const F = (n) => new Float64Array(n);\n  const S = (params.s = {\n    hue: 0, speed: 2, en: 0, pitch: 0, k: 1, cst: 1,\n    x: F(NP), y: F(NP), z: F(NP), vx: F(NP), vy: F(NP), vz: F(NP), sg: new Int8Array(NP), tc: F(NP), rh: F(NP), L: F(NP), a: F(NP), want: new Uint8Array(NP),\n    tp: new Float32Array(N), tn: new Float32Array(N), fx: new Float32Array(N), fl: new Float32Array(N), b: F(3), c: [0, 0, 0], d: [0, 0, 0],\n    lost: 0, esc: 0, started: false,\n  });\n  // The faint field lines in the plane of the panel: x = L cos^2 l sin l and\n  // y = +-L cos^3 l, from the sphere on one side round to the sphere on the\n  // other, for six shells.\n  for (const L of [16, 26, 36, 46, 56, 66]) {\n    const lh = Math.acos(sqrt(RS / L));\n    for (let t = -lh; t \u003c= lh; t += 0.002) {\n      const c = cos(t), x = CT * L * c * c * sin(t), y = L * c * c * c;\n      splat(S.fl, CX + x, CY - y, 1);\n      splat(S.fl, CX + x, CY + y, 1);\n    }\n  }\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) m = max(m, S.fl[i]);\n  for (let i = 0; i \u003c N; i++) S.fl[i] = min(1, S.fl[i] / (0.55 * m));\n}\n\nfunction splat(A, px, py, w) {\n  const x0 = floor(px), y0 = floor(py), fx = px - x0, fy = py - y0;\n  if (x0 >= 0 && x0 \u003c W && y0 >= 0 && y0 \u003c H) A[y0 * W + x0] += w * (1 - fx) * (1 - fy);\n  if (x0 + 1 >= 0 && x0 + 1 \u003c W && y0 >= 0 && y0 \u003c H) A[y0 * W + x0 + 1] += w * fx * (1 - fy);\n  if (x0 >= 0 && x0 \u003c W && y0 + 1 >= 0 && y0 + 1 \u003c H) A[(y0 + 1) * W + x0] += w * (1 - fx) * fy;\n  if (x0 + 1 >= 0 && x0 + 1 \u003c W && y0 + 1 >= 0 && y0 + 1 \u003c H) A[(y0 + 1) * W + x0 + 1] += w * fx * fy;\n}\n\n// Puts particle i on a shell L at a random point of its bounce: its guiding\n// centre goes on the field line at a latitude inside its mirror latitude,\n// with the pitch angle there that keeps the magnetic moment\n// sin^2(a) / B the same as at the equator, then the particle is set off by\n// its gyration radius in a random gyration phase.\nfunction inject(S, i) {\n  const R = Math.random;\n  const sg = i & 1 ? -1 : 1, L = LMIN + (LMAX - LMIN) * R();\n  const a = ((S.pitch + 0.6 * (90 - S.pitch) * R()) * PI) / 180, s2 = sin(a) ** 2;\n  // A guiding centre whose mirror point lies inside the sphere starts above\n  // the sphere: it is in the loss cone and will land on its way down.\n  const lm = min(mirrorLat(s2), 0.97 * Math.acos(sqrt(RS / L))), l0 = lm * sin(2 * PI * R());\n  const c = cos(l0), r = L * c * c, ph = 2 * PI * R(), rho = r * c;\n  const gx = r * sin(l0), gy = rho * cos(ph), gz = rho * sin(ph);\n  const b = S.b;\n  field(gx, gy, gz, S.k, b);\n  const bm = sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]), hx = b[0] / bm, hy = b[1] / bm, hz = b[2] / bm;\n  const sl = min(1, (s2 * bm * L * L * L) / S.k), vp = sqrt(sl), va = sqrt(1 - sl) * (R() \u003c 0.5 ? -1 : 1);\n  // Two unit vectors across the field line.\n  let ex = -hy, ey = hx, ez = 0, n = sqrt(ex * ex + ey * ey);\n  if (n \u003c 1e-6) (ex = 0), (ey = -hz), (ez = hy), (n = sqrt(ey * ey + ez * ez));\n  ex /= n;\n  ey /= n;\n  ez /= n;\n  const fx = hy * ez - hz * ey, fy = hz * ex - hx * ez, fz = hx * ey - hy * ex, ps = 2 * PI * R(), cp = cos(ps), sp = sin(ps);\n  const ux = vp * (cp * ex + sp * fx), uy = vp * (cp * ey + sp * fy), uz = vp * (cp * ez + sp * fz);\n  S.vx[i] = va * hx + ux;\n  S.vy[i] = va * hy + uy;\n  S.vz[i] = va * hz + uz;\n  // The gyration radius vector is s (b_hat x v_perp) / B.\n  S.x[i] = gx + (sg * (hy * uz - hz * uy)) / bm;\n  S.y[i] = gy + (sg * (hz * ux - hx * uz)) / bm;\n  S.z[i] = gz + (sg * (hx * uy - hy * ux)) / bm;\n  S.sg[i] = sg;\n  S.L[i] = L;\n  S.a[i] = a;\n  S.want[i] = 0;\n  S.tc[i] = 0;\n  field(S.x[i], S.y[i], S.z[i], S.k, b);\n  S.rh[i] = max(sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]) / DPHI, 1 / DMAX);\n}\n\n// Advances particle i by T of simulated time with the Boris pusher, which\n// turns the velocity about the local field by exactly the angle the field\n// gives and so keeps the speed fixed to rounding. Steps are short enough for\n// about 0.3 rad of gyration and half an LED of travel. A step length read\n// straight off the field would break the pusher's symmetry in time, and the\n// magnetic moment then drifted by a quarter in 20 s; so the step density\n// follows Hairer and Söderlind's reversible rule, the mean of the densities\n// either side of a position equal to the one the field there asks for. The\n// time a particle runs past its frame is taken off its next one. Every step\n// leaves its light on the panel, weighted by the time it took and by depth.\nfunction push(S, i, T) {\n  const b = S.b, k = S.k, sg = S.sg[i], A = sg > 0 ? S.tp : S.tn, esc = max(1.6 * LMAX, S.cst);\n  let x = S.x[i], y = S.y[i], z = S.z[i], vx = S.vx[i], vy = S.vy[i], vz = S.vz[i], rh = S.rh[i], n = 0;\n  T += S.tc[i];\n  while (T > 0 && n++ \u003c 6000) {\n    field(x, y, z, k, b);\n    const bm = sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]), g = max(bm / DPHI, 1 / DMAX);\n    let rn = 2 * g - rh;\n    if (rn \u003c 0.5 * g) rn = g;\n    const h = 1 / rn, hm = 0.5 * (h + 1 / rh);\n    rh = rn;\n    const tx = 0.5 * sg * hm * b[0], ty = 0.5 * sg * hm * b[1], tz = 0.5 * sg * hm * b[2], q = 2 / (1 + tx * tx + ty * ty + tz * tz);\n    const wx = vx + vy * tz - vz * ty, wy = vy + vz * tx - vx * tz, wz = vz + vx * ty - vy * tx;\n    vx += q * (wy * tz - wz * ty);\n    vy += q * (wz * tx - wx * tz);\n    vz += q * (wx * ty - wy * tx);\n    x += vx * h;\n    y += vy * h;\n    z += vz * h;\n    T -= h;\n    const r2 = x * x + y * y + z * z;\n    const u = CT * x - ST * z, dz = ST * x + CT * z;\n    if (r2 \u003c RS * RS) {\n      // Into the sphere: a flash where it lands (dimmer on the far side),\n      // then a new particle.\n      const fw = dz > -2 ? 1 : 0.4;\n      splat(S.fx, CX + u, CY - y, 4 * fw);\n      for (let j = 0; j \u003c 4; j++) splat(S.fx, CX + u + (j \u003c 2 ? 2 * j - 1 : 0), CY - y + (j \u003c 2 ? 0 : 2 * j - 5), 1.5 * fw);\n      S.lost++;\n      inject(S, i);\n      return;\n    }\n    // Past the Størmer length, or past 1.6 times the outermost shell if that\n    // is further, the particle has left the trap; a new one takes its place.\n    if (r2 > esc * esc) {\n      S.esc++;\n      inject(S, i);\n      return;\n    }\n    if (dz \u003c 0 && u * u + y * y \u003c RS * RS) continue;\n    splat(A, CX + u, CY - y, h * (0.45 + 0.55 * cl(0.5 + dz / (1.6 * LMAX), 0, 1)));\n  }\n  S.tc[i] = min(T, 0);\n  S.rh[i] = rh;\n  S.x[i] = x;\n  S.y[i] = y;\n  S.z[i] = z;\n  S.vx[i] = vx;\n  S.vy[i] = vy;\n  S.vz[i] = vz;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const en = cl(kv[2], 0, 1), pitch = cl(kv[3], 0, 90);\n  // Energy: the field strength k sets the Størmer length sqrt(k) against\n  // which the outermost shell sits at sOf(Energy). Changing it changes every\n  // gyration at once, as a change of energy would.\n  S.en = en;\n  S.cst = LMAX / sOf(en);\n  S.k = S.cst * S.cst;\n  if (!S.started || abs(pitch - S.pitch) > 0.5) {\n    S.pitch = pitch;\n    if (!S.started) for (let i = 0; i \u003c NP; i++) inject(S, i);\n    else S.want.fill(1);\n    S.started = true;\n  }\n  // A new pitch reaches the particles four a frame, each put back on its\n  // shell with the new pitch angle.\n  for (let i = 0, m = 0; i \u003c NP && m \u003c 4; i++) if (S.want[i]) inject(S, i), m++;\n  const T = d * S.speed * RATE, f = exp(-d / 0.32), g = exp(-d / 0.25);\n  const tp = S.tp, tn = S.tn, fx = S.fx;\n  for (let i = 0; i \u003c N; i++) (tp[i] *= f), (tn[i] *= f), (fx[i] *= g);\n  for (let i = 0; i \u003c NP; i++) push(S, i, T);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.c, e = S.d, cp = hsv(0.13 + S.hue, 0.75, 1, [0, 0, 0]), cn = hsv(0.56 + S.hue, 0.8, 1, [0, 0, 0]);\n  hsv(0.69 + S.hue * 0.3, 0.55, 1, e);\n  const tp = S.tp, tn = S.tn, fx = S.fx, fl = S.fl;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, dx = x - CX, dy = y - CY, r2 = dx * dx + dy * dy;\n      const a = 1 - exp(-0.9 * tp[p]), b = 1 - exp(-0.9 * tn[p]), w = max(0, a + b - 1.1) * 0.6 + 0.9 * (1 - exp(-fx[p]));\n      let r = a * cp[0] + b * cn[0], gg = a * cp[1] + b * cn[1], bb = a * cp[2] + b * cn[2];\n      // Field lines underneath, and the sphere as a dark disc with a dim rim.\n      const fv = r2 \u003c RS * RS ? 0 : 0.16 * fl[p] * (1 - min(1, a + b));\n      const rim = abs(sqrt(r2) - RS + 0.3) \u003c 0.7 ? 0.14 : 0;\n      r += fv * e[0] + rim + w;\n      gg += fv * e[1] + rim + w;\n      bb += fv * e[2] + rim + w;\n      display.setPixel(x, y, min(255, r * 255) | 0, min(255, gg * 255) | 0, min(255, bb * 255) | 0);\n    }\n}\n","strange-eigenmode":"// ===== Patternflow pattern =====\n// Title:   Strange Eigenmode\n// Family:  sim\n// Idea:    A dye on a torus stirred by Pierrehumbert's alternating sine flow, the rows sliding sideways for half a period and the columns sliding up and down for the other half, with a little diffusion, and rescaled every frame so it never fades: the striated picture is the flow's slowest decaying Floquet mode, the strange eigenmode, so it comes back in exactly the same shape every period while its true contrast falls to 39% each time.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: strange eigenmodes (Raymond Pierrehumbert, 1994), in his alternating sine flow\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Stir=-1..1, Diffusion=0..1\n//\n// Knob 1: Hue. The colour of the dye. At 0 the positive half runs from violet where it is faint to pale aqua where it is strongest, and the negative half shows as dim indigo level lines; 0.25 turns it crimson to lilac, 0.5 olive through amber to rose, 0.75 teal through green to pale gold, and 1 is back at violet and aqua.\n// Knob 2: Speed. One period of the flow takes 6 / Speed seconds: 3 s at the opening 2, each half 1.5 s with the slide easing in and out and resting a fifth of a second at either end. At 0.2 a period takes 30 s and at 3 it takes 2 s; Speed only changes how fast the same flow plays.\n// Knob 3: Stir. The amplitude A of both sines in units of the torus, which the panel draws 64 LEDs wide and 128 tall, so a row slides up to 64 A LEDs and a column up to 128 A. At 0, A = 1.2 (77 and 154 LEDs): global chaos, the leading Floquet multiplier 0.39 well ahead of the next, 0.28, so one shape returns every period at 39% of its contrast, a decay rate of 0.95 a period. At -1, A = 0.45: islands of regular flow keep their dye, which leaves only by diffusion, and the pattern fades only 10% a period. At -0.5 (A = 0.82) and +0.5 (A = 1.4) the leading multipliers are a complex pair, 137 and 136 degrees round, and the pattern swings between shapes without repeating. At +1 (A = 1.6) the leading multiplier is negative, -0.41: the pattern returns as its own negative every period, bright where it was dark.\n// Knob 4: Diffusion. The diffusivity, 4 A times 30 to the power of the knob, in LED^2 a period: 5.9 at the opening 0.06, where the stripes are 2.9 LEDs across (rms over rms gradient). At 0.5 it is 26 (6 LEDs). At 1 it is 144 (12 LEDs): a few broad bands are left, and the decay rate rises to 1.6 a period. Any thinner than at 0 and the stripes would be finer than the LEDs.\n// Buttons: K1 tap pours fresh dye, a few random waves, which the flow stirs on screen until, after about a dozen periods, the same mode is back.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// Radix-2 FFT of n points. The forward transform takes its input in\n// bit-reversed order and the inverse leaves its output so, which the loads\n// and stores in shear do for free. Twiddles of the stage with half width h\n// sit at h - 1 .. 2h - 2.\nfunction plan(n) {\n  const bits = Math.round(log(n) / log(2)), rev = new Uint16Array(n), wr = new Float64Array(n), wi = new Float64Array(n);\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c bits; b++) r |= ((i >> b) & 1) \u003c\u003c (bits - 1 - b);\n    rev[i] = r;\n  }\n  for (let h = 1; h \u003c n; h \u003c\u003c= 1) for (let j = 0; j \u003c h; j++) (wr[h - 1 + j] = cos((PI * j) / h)), (wi[h - 1 + j] = -sin((PI * j) / h));\n  return { n, rev, wr, wi, re: new Float64Array(n), im: new Float64Array(n), d: new Float64Array(n) };\n}\nfunction fwd(P) {\n  const n = P.n, re = P.re, im = P.im, wr = P.wr, wi = P.wi;\n  for (let h = 1; h \u003c n; h \u003c\u003c= 1)\n    for (let j = 0, m = h \u003c\u003c 1; j \u003c h; j++) {\n      const cr = wr[h - 1 + j], ci = wi[h - 1 + j];\n      for (let a = j; a \u003c n; a += m) {\n        const b = a + h, tr = re[b] * cr - im[b] * ci, ti = re[b] * ci + im[b] * cr;\n        re[b] = re[a] - tr, im[b] = im[a] - ti;\n        re[a] += tr, im[a] += ti;\n      }\n    }\n}\nfunction inv(P) {\n  const n = P.n, re = P.re, im = P.im, wr = P.wr, wi = P.wi;\n  for (let h = n >> 1; h >= 1; h >>= 1)\n    for (let j = 0, m = h \u003c\u003c 1; j \u003c h; j++) {\n      const cr = wr[h - 1 + j], ci = -wi[h - 1 + j];\n      for (let a = j; a \u003c n; a += m) {\n        const b = a + h, xr = re[a] - re[b], xi = im[a] - im[b];\n        re[a] += re[b], im[a] += im[b];\n        re[b] = xr * cr - xi * ci, im[b] = xr * ci + xi * cr;\n      }\n    }\n}\nconst PX = plan(W), PY = plan(H);\n\n// Every line (a row when rows, else a column) moves along itself by sh[line]\n// LEDs, exactly, as a phase turn of each Fourier mode, and each mode is\n// damped by P.d, the diffusion along that axis over the step (with the 1/n\n// of the inverse folded in). Two real lines ride one complex FFT and are\n// parted again in Fourier space. The Nyquist mode is dropped.\nfunction shear(F, rows, sh) {\n  const P = rows ? PX : PY, n = P.n, lines = rows ? H : W, ls = rows ? W : 1, es = rows ? 1 : W;\n  const re = P.re, im = P.im, d = P.d, rev = P.rev, hn = n >> 1;\n  for (let l = 0; l \u003c lines; l += 2) {\n    const o1 = l * ls, o2 = o1 + ls;\n    for (let i = 0, q = 0; i \u003c n; i++, q += es) {\n      const r = rev[i];\n      re[r] = F[o1 + q], im[r] = F[o2 + q];\n    }\n    fwd(P);\n    const t1 = (-2 * PI * sh[l]) / n, t2 = (-2 * PI * sh[l + 1]) / n;\n    const c1 = cos(t1), s1 = sin(t1), c2 = cos(t2), s2 = sin(t2);\n    let e1r = 1, e1i = 0, e2r = 1, e2i = 0;\n    for (let k = 1; k \u003c hn; k++) {\n      let q = e1r * c1 - e1i * s1;\n      e1i = e1r * s1 + e1i * c1, e1r = q;\n      q = e2r * c2 - e2i * s2;\n      e2i = e2r * s2 + e2i * c2, e2r = q;\n      const m = n - k, zr = re[k], zi = im[k], wr = re[m], wi = im[m], dk = 0.5 * d[k];\n      const ar = zr + wr, ai = zi - wi, br = zi + wi, bi = wr - zr;\n      const a2r = (ar * e1r - ai * e1i) * dk, a2i = (ar * e1i + ai * e1r) * dk;\n      const b2r = (br * e2r - bi * e2i) * dk, b2i = (br * e2i + bi * e2r) * dk;\n      re[k] = a2r - b2i, im[k] = a2i + b2r;\n      re[m] = a2r + b2i, im[m] = b2r - a2i;\n    }\n    re[0] *= d[0], im[0] *= d[0];\n    re[hn] = im[hn] = 0;\n    inv(P);\n    for (let i = 0, q = 0; i \u003c n; i++, q += es) {\n      const r = rev[i];\n      F[o1 + q] = re[r], F[o2 + q] = im[r];\n    }\n  }\n}\n\n// Diffusion along one axis for tau periods at kappa LED^2 a period, as the\n// damping of each Fourier mode.\nfunction damp(P, kappa, tau) {\n  const n = P.n;\n  for (let k = 0; k \u003c n; k++) {\n    const w = (2 * PI * min(k, n - k)) / n;\n    P.d[k] = exp(-kappa * w * w * tau) / n;\n  }\n}\n\n// Diffusion across the lines while the variance v is small: three taps.\nconst TMP = new Float64Array(N);\nfunction blur(F, rows, v) {\n  const a = v / 2, b = 1 - v;\n  TMP.set(F);\n  if (rows)\n    for (let y = 0; y \u003c H; y++) {\n      const o = y * W, u = ((y + H - 1) % H) * W, w = ((y + 1) % H) * W;\n      for (let x = 0; x \u003c W; x++) F[o + x] = b * TMP[o + x] + a * (TMP[u + x] + TMP[w + x]);\n    }\n  else\n    for (let y = 0; y \u003c H; y++) {\n      const o = y * W;\n      for (let x = 0; x \u003c W; x++) F[o + x] = b * TMP[o + x] + a * (TMP[o + ((x + 63) & 63)] + TMP[o + ((x + 1) & 63)]);\n    }\n}\n\n// Remove the mean and scale to unit rms; returns the log of the rms before.\nfunction norm(F) {\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) m += F[i];\n  m /= N;\n  let q = 0;\n  for (let i = 0; i \u003c N; i++) q += (F[i] -= m) * F[i];\n  const r = sqrt(q / N) || 1e-30, g = 1 / r;\n  for (let i = 0; i \u003c N; i++) F[i] *= g;\n  return log(r);\n}\n\n// The torus is one unit wide and one tall, drawn 64 LEDs wide and 128\n// tall, so a shift of A moves a row by 64 A LEDs and a column by 128 A. The\n// phases of the two sines are fixed: the flow is periodic in time.\nconst P1 = 0.3, P2 = 1.9, SX = new Float64Array(H), SY = new Float64Array(W), ZERO = new Float64Array(H);\nfor (let y = 0; y \u003c H; y++) SX[y] = W * sin((2 * PI * y) / H + P1);\nfor (let x = 0; x \u003c W; x++) SY[x] = H * sin((2 * PI * x) / W + P2);\n\nfunction fresh(S) {\n  const F = S.F;\n  // A few random large waves to start from; the eigenmode forgets them.\n  F.fill(0);\n  for (let j = 0; j \u003c 6; j++) {\n    const kx = 1 + floor(Math.random() * 3), ky = 1 + floor(Math.random() * 5), a = Math.random() * 2 * PI, b = Math.random() * 2 * PI;\n    for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) F[y * W + x] += sin((2 * PI * kx * x) / W + a) * sin((2 * PI * ky * y) / H + b);\n  }\n  norm(F);\n  S.ph = 0, S.logsum = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, A: 1.2, kap: 6, ph: 0, logsum: 0, gamma: 0, warm: 10,\n    F: new Float64Array(N), sh: new Float64Array(H), c: [0, 0, 0],\n  });\n  fresh(S);\n}\n\n// One step of the flow: a share f of the half period's shear along one\n// axis, with tau periods of diffusion along both. The step is cut so that\n// no piece tilts a line by more than one LED for each LED across, and the\n// diffusion across the lines runs after each piece, as three taps or, when\n// that much would be too wide for three, as damping in Fourier space. The\n// log of what norm took away adds up over a period to minus its decay rate.\nfunction step(S, rows, f, tau) {\n  const tilt = abs(f) * S.A * (rows ? (2 * PI * W) / H : (2 * PI * H) / W), n = max(1, Math.ceil(tilt));\n  const prof = rows ? SX : SY, sh = S.sh, len = rows ? H : W, v = (2 * S.kap * tau) / n;\n  for (let i = 0; i \u003c len; i++) sh[i] = (f / n) * S.A * prof[i];\n  damp(rows ? PX : PY, S.kap, tau / n);\n  if (v > 0.8) damp(rows ? PY : PX, S.kap, tau / n);\n  for (let i = 0; i \u003c n; i++) {\n    shear(S.F, rows, sh);\n    if (v > 0.8) shear(S.F, !rows, ZERO);\n    else blur(S.F, rows, v);\n  }\n  S.logsum += norm(S.F);\n}\n\n// Within each half period the shear starts and stops smoothly and rests a\n// little at either end.\nconst ease = (u) => {\n  const t = cl((u - 0.15) / 0.7, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Advance the flow by dp of a period from phase ph.\nfunction advance(S, dp) {\n  while (dp > 1e-9) {\n    const inX = S.ph \u003c 0.5, end = inX ? 0.5 : 1, st = min(dp, end - S.ph);\n    const u0 = 2 * S.ph - (inX ? 0 : 1), f = ease(u0 + 2 * st) - ease(u0);\n    step(S, inX, f, st);\n    S.ph += st;\n    dp -= st;\n    if (S.ph >= 1 - 1e-9) {\n      S.ph = 0;\n      S.gamma = -S.logsum;\n      S.logsum = 0;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const st = cl(k[2], -1, 1);\n  S.A = 1.2 + st * (st \u003c 0 ? 0.75 : 0.4);\n  S.kap = 4 * S.A * 30 ** cl(k[3], 0, 1);\n  // K1 tap: fresh dye, stirred from here on screen.\n  if (input.btnPressed && input.btnPressed[0]) fresh(S), (S.warm = 0);\n  if (S.warm > 0) {\n    // At the start the flow runs ahead unseen, steady shears whole periods\n    // at a time, two periods before the first frame and one more in each\n    // of the next eight, so the panel opens on the mode itself.\n    const n = S.warm === 10 ? 2 : 1;\n    for (let i = 0; i \u003c 2 * n; i++) step(S, i % 2 === 0, 1, 0.5);\n    S.warm -= n;\n    S.logsum = 0;\n    if (!S.warm) {\n      // The equation is linear, so the mode and its negative are the same\n      // mode. Draw it with its long tail on the bright side.\n      let m3 = 0;\n      for (let i = 0; i \u003c N; i++) m3 += S.F[i] * S.F[i] * S.F[i];\n      if (m3 \u003c 0) for (let i = 0; i \u003c N; i++) S.F[i] = -S.F[i];\n    }\n  }\n  advance(S, (d * S.speed) / 6);\n}\n\n// A triangle wave of period 1, 0 at whole numbers and 1 halfway.\nconst tri = (u) => 1 - abs(2 * (u - floor(u)) - 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const F = S.F, c = S.c, h0 = 0.45 + S.hue, V0 = -0.05;\n  for (let y = 0; y \u003c H; y++) {\n    const o = y * W, u = ((y + H - 1) % H) * W, w = ((y + 1) % H) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const p = o + x, v = F[p];\n      // Relief: the field as a height lit from the upper left.\n      const gx = F[o + ((x + 1) & 63)] - F[o + ((x + 63) & 63)], gy = F[w + x] - F[u + x];\n      const g = -(gx + gy) * 0.6, sh = g / (1 + abs(g));\n      // Above a cut just under zero, about half the panel, the dye lights\n      // from violet to pale aqua; level lines every 0.35 shade it a little.\n      if (v > V0) {\n        const t = 1 - exp(-(v - V0) / 0.9), b = tri(v / 0.35);\n        hsv(h0 + 0.3 - 0.3 * t + 0.06 * sh - 0.03 * b, 0.9 - 0.5 * t - 0.15 * sh, 0.11 + (0.06 + 0.83 * t) * (0.78 + 0.3 * sh) * (0.9 + 0.1 * b), c);\n      } else {\n        // Below the cut, the level lines of the mode every 0.15, dim.\n        const t = exp((v - V0) / 1.2), b = tri(v / 0.15);\n        hsv(h0 + 0.32 - 0.12 * t + 0.05 * sh, 0.55 + 0.3 * b, min(0.09, (0.02 + 0.045 * t + 0.03 * b) * (1 + 0.3 * sh)), c);\n      }\n      display.setPixel(x, y, cl(c[0], 0, 255) | 0, cl(c[1], 0, 255) | 0, cl(c[2], 0, 255) | 0);\n    }\n  }\n}\n","ulam-sequence":"// ===== Patternflow pattern =====\n// Title:   Ulam Sequence\n// Family:  number\n// Idea:    The Ulam sequence counted live, each new term the least number that is a sum of two earlier terms in exactly one way, wound round a circle by the hidden frequency alpha that the code finds for itself: every term sits across the panel at the angle alpha times the term and lower down the larger it is, so the terms fill only the half of the circle where cos(alpha a) \u003c 0, in two humps, and leave the other half empty but for 2, 3, 47 and 69, while each new one drops into the pile below.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ulam sequence (Stanisław Ulam, 1964), with the hidden frequency Stefan Steinerberger found (2017)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Seed=0..5, Detune=-1..1\n//\n// Knob 1: Hue. The colour of the terms, with the ones off the pile in a hue a fifth of the wheel back: gold with pink at 0, green with yellow at 0.25, blue with sea green at 0.5, magenta with blue at 0.75.\n// Knob 2: Speed. New terms a second, 40 for each unit: 80 at the opening 2. At 0.2 there are 8 a second, at 3 there are 120. Each new term falls from the foot of the coil into its column of the pile in 0.4 s. After 16,000 terms (the last of U(1,2) is 213,514) the count rests 4 s and starts again from the first 600.\n// Knob 3: Seed. Which sequence: U(1,2) at 0, U(1,3) at 1, U(1,4) at 2, U(2,3) at 3, U(3,4) at 4 and U(2,5) at 5. The code finds each frequency itself as the alpha in (0, pi] where |sum of exp(i alpha a)| over the terms is largest, and finds it again each time the count doubles: 2.5714 for U(1,2) (Steinerberger gives 2.5714474995), 2.8335 for U(1,3), 0.5060 for U(1,4), 1.1650 for U(2,3), 2.2090 for U(3,4). U(2,5) has just two even terms, 2 and 12 (James Schmerl and Eugene Spiegel, 1994), so its frequency is pi and its pile is one spike. The terms off the pile are 2, 3, 47 and 69 for U(1,2), 4 and 98 for U(1,3), 1 and 10 for U(1,4), 5 for U(2,3), 3 and 11 for U(3,4).\n// Knob 4: Detune. Moves alpha off the found value: not at all within 0.1 of the middle (it opens at 0.06), then as the square of the rest, to 0.002 either way at the ends. The error in the angle grows with the term, so at 0.5 (0.0004 off) the band leans more and more towards the foot of the coil and winds into stripes that cross the empty half in pink; at 1 the pile is flat.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, PI, round } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The seeds K3 steps through.\nconst SEEDS = [[1, 2], [1, 3], [1, 4], [2, 3], [3, 4], [2, 5]];\n// Terms kept at most, and the counting array: C[m] is how many ways m is a\n// sum of two distinct terms so far, stopped at 2.\nconst NMAX = 16000, LIM = 1 \u003c\u003c 19, HEAD = 600;\n// Rows of the coil (the number line wound on the circle) and of the pile.\nconst CH = 86, PB = 34;\n\nfunction start(S, seed) {\n  const [p, q] = SEEDS[seed];\n  S.seed = seed;\n  S.C.fill(0);\n  S.T[0] = p, S.T[1] = q, S.n = 2;\n  S.C[p + q] = 1;\n  S.alpha = 0, S.fitN = 0, S.acc = 0, S.full = 0;\n  S.born.fill(-9);\n  while (S.n \u003c HEAD) next(S);\n  fit(S);\n}\n\n// The next Ulam term: the least m above the last term that is a sum of two\n// distinct earlier terms in exactly one way. Then its sums with every\n// earlier term are counted.\nfunction next(S) {\n  const T = S.T, C = S.C, n = S.n;\n  let m = T[n - 1] + 1;\n  while (m \u003c LIM >> 1 && C[m] !== 1) m++;\n  if (m >= LIM >> 1 || n >= NMAX) return false;\n  T[n] = m;\n  for (let j = 0; j \u003c n; j++) {\n    const s = m + T[j];\n    if (s \u003c LIM && C[s] \u003c 2) C[s]++;\n  }\n  S.n = n + 1;\n  return true;\n}\n\n// |sum of exp(i alpha a)|^2 over the first n terms.\nfunction power(T, n, a) {\n  let re = 0, im = 0;\n  for (let j = 0; j \u003c n; j++) (re += cos(a * T[j])), (im += sin(a * T[j]));\n  return re * re + im * im;\n}\n\n// The same at K points a0, a0 + step, ..., each term's phase turned on by a\n// fixed step from the last; returns the best point.\nconst CR = new Float64Array(NMAX), CI = new Float64Array(NMAX), WR = new Float64Array(NMAX), WI = new Float64Array(NMAX);\nfunction scan(T, n, a0, step, K) {\n  for (let j = 0; j \u003c n; j++) (CR[j] = cos(a0 * T[j])), (CI[j] = sin(a0 * T[j])), (WR[j] = cos(step * T[j])), (WI[j] = sin(step * T[j]));\n  let best = -1, at = a0;\n  for (let k = 0; k \u003c= K; k++) {\n    let re = 0, im = 0;\n    for (let j = 0; j \u003c n; j++) {\n      re += CR[j], im += CI[j];\n      const r = CR[j] * WR[j] - CI[j] * WI[j];\n      CI[j] = CR[j] * WI[j] + CI[j] * WR[j], CR[j] = r;\n    }\n    const p = re * re + im * im;\n    if (p > best) (best = p), (at = a0 + k * step);\n  }\n  return at;\n}\n\n// The hidden frequency: the alpha in (0, pi] where the terms' Fourier sum\n// is largest. The first time, a scan of the first 200 terms from 0.01 to pi\n// in steps of a fifth of the peak's width; each time the count doubles, a\n// scan of three old peak widths round the last value with all the terms.\n// Then the top of a parabola through the best point and its neighbours,\n// twice, the second time five times closer.\nfunction fit(S) {\n  const T = S.T, n = S.n;\n  let at, h;\n  if (!S.alpha) {\n    h = (0.2 * TAU) / T[199];\n    at = scan(T, 200, 0.01, h, Math.ceil((PI - 0.01) / h));\n  } else {\n    h = (0.2 * TAU) / T[n - 1];\n    const w = (1.5 * TAU) / T[S.fitN - 1];\n    at = scan(T, n, S.alpha - w, h, Math.ceil((2 * w) / h));\n  }\n  for (let i = 0; i \u003c 2; i++, h /= 5) {\n    const f0 = power(T, n, at - h), f1 = power(T, n, at), f2 = power(T, n, at + h), q = f0 - 2 * f1 + f2;\n    if (q \u003c 0) at += (cl((0.5 * (f0 - f2)) / q, -1, 1)) * h;\n  }\n  S.alpha = at;\n  S.fitN = n;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, seed: 0, det: 0, alpha: 0, fitN: 0, acc: 0, n: 0, full: 0, t: 0,\n    T: new Float64Array(NMAX), C: new Uint8Array(LIM), born: new Float64Array(NMAX),\n    G: new Float64Array(W * CH), R: new Float64Array(CH), P: new Float64Array(W), c: [0, 0, 0],\n  });\n  start(S, 0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const seed = cl(round(k[2]), 0, SEEDS.length - 1);\n  if (seed !== S.seed) start(S, seed);\n  // Detune: nothing within 0.1 of the middle, then up to 0.002 either way.\n  const u = cl(abs(k[3]) - 0.1, 0, 0.9) / 0.9;\n  S.det = (k[3] \u003c 0 ? -1 : 1) * 0.002 * u * u;\n  S.t += d;\n  // New terms, 40 a second for each unit of Speed.\n  S.acc += 40 * S.speed * d;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    if (!next(S)) {\n      S.full += d;\n      break;\n    }\n    S.born[S.n - 1] = S.t;\n  }\n  if (S.n >= 2 * S.fitN) fit(S);\n  if (S.full > 4) start(S, S.seed);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const T = S.T, n = S.n, G = S.G, R = S.R, P = S.P, c = S.c, al = S.alpha + S.det;\n  G.fill(0), R.fill(0), P.fill(0);\n  // Rows of the coil go as log(a + 16), from a = 1 at the top to the\n  // largest term at the bottom; columns are alpha a modulo 2 pi.\n  const l0 = log(17), sc = (CH - 1) / (log(T[n - 1] + 16) - l0);\n  let pm = 1;\n  for (let j = 0; j \u003c n; j++) {\n    const a = T[j], x = floor(((al * a) % TAU) * (W / TAU)) & 63, y = (log(a + 16) - l0) * sc, y0 = floor(y), f = y - y0;\n    G[y0 * W + x] += 1 - f, R[y0] += 1 - f;\n    if (y0 + 1 \u003c CH) (G[(y0 + 1) * W + x] += f), (R[y0 + 1] += f);\n    if (++P[x] > pm) pm = P[x];\n  }\n  const h0 = 0.12 + S.hue;\n  // A cell's light goes with its count against the row's share of terms\n  // for each of the 24 columns the band spans, so sparse rows near the top\n  // show single terms and dense rows the band's shape.\n  for (let y = 0; y \u003c CH; y++) {\n    const q = 1.2 / max(0.4, R[y] / 24);\n    for (let x = 0; x \u003c W; x++) {\n      const b = 1 - exp(-G[y * W + x] * q);\n      hsv(h0 + 0.05 * b, 0.75 - 0.3 * b, b, c);\n      display.setPixel(x, y, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n  }\n  // The terms with cos(alpha a) >= 0, on the empty half of the circle, in\n  // pink with a dim cross round each.\n  for (let j = 0; j \u003c n; j++) {\n    const a = T[j];\n    if (cos(al * a) \u003c 0) continue;\n    const x = floor(((al * a) % TAU) * (W / TAU)) & 63, y = min(CH - 1, round((log(a + 16) - l0) * sc));\n    hsv(h0 + 0.8, 0.7, 0.45, c);\n    for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) {\n      const yy = y + dy;\n      if (yy >= 0 && yy \u003c CH) display.setPixel((x + dx) & 63, yy, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n    hsv(h0 + 0.8, 0.5, 1, c);\n    display.setPixel(x, y, c[0] | 0, c[1] | 0, c[2] | 0);\n  }\n  // The pile: how many terms in each 64th of the circle, on a bottom row\n  // that marks the half where cos(alpha a) \u003c 0 apart from the other half.\n  for (let x = 0; x \u003c W; x++) {\n    const hgt = (P[x] / pm) * PB;\n    for (let z = 0; z \u003c PB; z++) {\n      const b = cl(hgt - z, 0, 1);\n      if (b \u003c= 0) break;\n      hsv(h0 + 0.03 * (z / PB), 0.85 - 0.4 * (z / PB), b * (0.62 + 0.38 * (z / PB)), c);\n      display.setPixel(x, H - 2 - z, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n    if (x >= 16 && x \u003c 48) hsv(h0 + 0.5, 0.6, 0.3, c);\n    else hsv(h0 + 0.8, 0.6, 0.3, c);\n    display.setPixel(x, H - 1, c[0] | 0, c[1] | 0, c[2] | 0);\n  }\n  // Each new term falls from the bottom of the coil into its column of\n  // the pile in 0.4 s.\n  for (let j = n - 1; j >= 2 && S.t - S.born[j] \u003c 0.4; j--) {\n    const a = T[j], x = floor(((al * a) % TAU) * (W / TAU)) & 63, u = (S.t - S.born[j]) / 0.4;\n    const top = H - 2 - (P[x] / pm) * PB, y = CH - 1 + (top - CH + 1) * u * u;\n    for (let i = 0; i \u003c 3; i++) {\n      const yy = round(y) - i;\n      if (yy \u003c CH || yy >= H) continue;\n      hsv(h0 + 0.02, 0.35 + 0.2 * i, 1 - 0.3 * i, c);\n      display.setPixel(x, yy, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n  }\n}\n","weaire-phelan":"// ===== Patternflow pattern =====\n// Title:   Weaire-Phelan\n// Family:  space\n// Idea:    A tall column of 48 foam cells turns slowly in depth, each the Voronoi cell of a site of the A15 lattice, so that together they are the flat-faced Weaire-Phelan foam of green-teal pentagonal dodecahedra and fourteen-faced cells with two gold hexagons each, and a knob lowers a line above which Kelvin's truncated octahedra of the same volume, with violet squares, take their place.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Weaire-Phelan structure (Denis Weaire and Robert Phelan, 1993), against Kelvin's truncated octahedra (William Thomson, Lord Kelvin, 1887)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Kelvin=0..1, Gap=0..1\n//\n// Knob 1: Hue. Turns every face colour round the wheel together. At 0 the pentagons of the fourteen-faced cells are blue-teal, those of the dodecahedra a greener teal, the hexagons gold and Kelvin's squares violet; at 0.5 the pentagons turn red and the hexagons blue.\n// Knob 2: Speed. How fast the column turns about its upright axis: at 2 once in 16 s, at 0.2 once in two and a half minutes, at 3 once in 10.5 s.\n// Knob 3: Kelvin. Lowers a line through the column. Below it the cells are Weaire and Phelan's, above it Kelvin's truncated octahedra with six squares and eight hexagons, each of 2,744 cubic LEDs, the mean of WP's two sizes (2,680 and 2,765). At 0 the column is all WP, at 0.5 its top half is Kelvin's, at 1 all of it. With flat faces the walls come to 5.2950 per cell of unit volume for WP and 5.3147 for Kelvin, 0.37% more.\n// Knob 4: Gap. Shrinks every cell about its own site, to half its size at 1, so the foam opens up. At 0 the walls meet and at 0.06 they part by a hairline; at 0.5 the inner stack of fourteen-faced cells shows through the gaps, and at 1 each cell stands apart and its faces can be counted.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5;\nconst { floor, min, max, abs, sin, cos, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The sites of one unit cube. A15 (the beta-tungsten structure): its Voronoi\n// cells are the flat-faced Weaire-Phelan foam. BCC: its Voronoi cells are\n// Kelvin's truncated octahedra.\nconst A15 = [[0, 0, 0], [0.5, 0.5, 0.5], [0.25, 0.5, 0], [0.75, 0.5, 0], [0, 0.25, 0.5], [0, 0.75, 0.5], [0.5, 0, 0.25], [0.5, 0, 0.75]];\nconst BCC = [[0, 0, 0], [0.5, 0.5, 0.5]];\n// The WP cube edge in LEDs. Kelvin's cube holds two cells to WP's eight, so\n// for the same volume per cell its edge is the WP edge over the cube root of 4.\nconst AW = 28, AK = AW / Math.cbrt(4);\n\nconst sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst crs = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n\n// The Voronoi cell of site i, relative to the site: a cube two cube edges\n// wide, cut by the bisecting plane of every site of the periodic lattice\n// within 1.5 cube edges, nearest first. Each cut keeps the part of every face\n// on the site's side and closes the hole with a new face, its corners sorted\n// by angle round their mean.\nfunction voronoi(sites, i) {\n  const c = sites[i], E = 1e-10;\n  let F = [];\n  for (let ax = 0; ax \u003c 3; ax++)\n    for (const sg of [-1, 1]) {\n      const u = (ax + 1) % 3, v = (ax + 2) % 3, q = [];\n      for (const [a, b] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) {\n        const p = [0, 0, 0];\n        p[ax] = sg;\n        p[u] = a * sg;\n        p[v] = b;\n        q.push(p);\n      }\n      F.push(q);\n    }\n  const nb = [];\n  for (const s of sites)\n    for (let x = -2; x \u003c= 2; x++)\n      for (let y = -2; y \u003c= 2; y++)\n        for (let z = -2; z \u003c= 2; z++) {\n          const d = [s[0] + x - c[0], s[1] + y - c[1], s[2] + z - c[2]], r2 = dot(d, d);\n          if (r2 > E && r2 \u003c 2.25) nb.push([d, r2]);\n        }\n  nb.sort((a, b) => a[1] - b[1]);\n  // A plane further than the farthest corner cannot cut, nor can any after it.\n  let far = 3;\n  for (const [d, r2] of nb) {\n    if (r2 > 4 * far) break;\n    const side = (p) => dot(p, d) - r2 / 2, out = [], cut = [];\n    for (const f of F) {\n      const q = [];\n      for (let m = 0; m \u003c f.length; m++) {\n        const A = f[m], B = f[(m + 1) % f.length], sa = side(A), sb = side(B);\n        if (sa \u003c= E) q.push(A);\n        if (abs(sa) \u003c= E) cut.push(A);\n        else if ((sa \u003c 0) !== (sb \u003c 0) && abs(sb) > E) {\n          const t = sa / (sa - sb), X = [A[0] + t * (B[0] - A[0]), A[1] + t * (B[1] - A[1]), A[2] + t * (B[2] - A[2])];\n          q.push(X);\n          cut.push(X);\n        }\n      }\n      if (q.length >= 3) out.push(q);\n    }\n    if (cut.length >= 3) {\n      const m = [0, 1, 2].map((k) => cut.reduce((s, p) => s + p[k], 0) / cut.length), e1 = sub(cut[0], m), e2 = crs(d, e1), pts = [];\n      for (const p of cut) if (!pts.some((o) => hypot(...sub(o[0], p)) \u003c 1e-7)) pts.push([p, Math.atan2(dot(sub(p, m), e2), dot(sub(p, m), e1))]);\n      pts.sort((a, b) => a[1] - b[1]);\n      if (pts.length >= 3) out.push(pts.map((o) => o[0]));\n    }\n    F = out;\n    far = 0;\n    for (const f of F) for (const p of f) far = max(far, dot(p, p));\n  }\n  // Corners shared between faces, and each face as a list of corner indices\n  // with its outward unit normal. The cell's volume is summed as pyramids on\n  // its faces with their apex at the site.\n  const V = [], faces = [];\n  const idx = (p) => {\n    for (let k = 0; k \u003c V.length; k++) if (hypot(...sub(V[k], p)) \u003c 1e-7) return k;\n    V.push(p);\n    return V.length - 1;\n  };\n  let vol = 0, area = 0;\n  for (const f of F) {\n    const ix = [];\n    for (const p of f) {\n      const k = idx(p);\n      if (ix[ix.length - 1] !== k && ix[0] !== k) ix.push(k);\n    }\n    let n = [0, 0, 0];\n    for (let m = 1; m + 1 \u003c ix.length; m++) n = n.map((v, t) => v + crs(sub(V[ix[m]], V[ix[0]]), sub(V[ix[m + 1]], V[ix[0]]))[t] / 2);\n    const ar = hypot(...n);\n    if (ix.length \u003c 3 || ar \u003c 1e-9) continue;\n    n = n.map((v) => v / ar);\n    if (dot(n, V[ix[0]]) \u003c 0) ix.reverse(), (n = n.map((v) => -v));\n    faces.push({ ix, n, nv: ix.length });\n    area += ar;\n    vol += (ar * dot(n, V[ix[0]])) / 3;\n  }\n  // Each edge once, with the two faces that meet there.\n  const edges = [], seen = new Map();\n  faces.forEach((f, j) => {\n    for (let m = 0; m \u003c f.nv; m++) {\n      const a = f.ix[m], b = f.ix[(m + 1) % f.nv], key = min(a, b) * 1000 + max(a, b);\n      if (seen.has(key)) edges[seen.get(key) + 3] = j;\n      else seen.set(key, edges.length), edges.push(a, b, j, j);\n    }\n  });\n  return { V, faces, edges, vol, area };\n}\n\nexport function setup(params) {\n  const S = (params.s = { hue: 0, speed: 2, kel: 0, gap: 0.06, th: 0.6, inst: [], cells: [], check: null });\n  // The base cells, eight of WP and two of Kelvin. S.check keeps what the\n  // theorem is about: each cell's volume and face sizes, and the mean surface\n  // of a cell scaled to unit volume, the number Kelvin's problem is quoted in\n  // (each wall then counts once for each of the two cells it parts).\n  const base = [A15, BCC].map((sites) => sites.map((_, i) => voronoi(sites, i)));\n  const ck = (S.check = {});\n  base.forEach((cells, k) => {\n    const v = cells.reduce((s, c) => s + c.vol, 0), a = cells.reduce((s, c) => s + c.area, 0), n = cells.length;\n    ck[k ? \"kelvin\" : \"wp\"] = { volumes: cells.map((c) => c.vol), faces: cells.map((c) => c.faces.map((f) => f.nv)), total: v, areaPerUnitVolume: a / n / (v / n) ** (2 / 3) };\n  });\n  // The column: every site within a radius of a vertical axis and a height\n  // of the middle, for each lattice. WP's axis runs up a stack of\n  // fourteen-faced cells joined by their hexagons; Kelvin's up a line of sites.\n  const pick = (sites, cells, a, ax, az, R, kind) => {\n    for (let i = 0; i \u003c sites.length; i++)\n      for (let x = -3; x \u003c= 3; x++)\n        for (let y = -6; y \u003c= 6; y++)\n          for (let z = -3; z \u003c= 3; z++) {\n            const s = [sites[i][0] + x - ax, sites[i][1] + y - 0.5, sites[i][2] + z - az];\n            if (hypot(s[0], s[2]) > R || abs(s[1]) * a > 48) continue;\n            const n = cells[i].V.length;\n            S.inst.push({ c: cells[i], kind, x: s[0] * a, y: s[1] * a, z: s[2] * a, a, on: false, fr: new Uint8Array(cells[i].faces.length), sx: new Float64Array(n), sy: new Float64Array(n), sz: new Float64Array(n) });\n          }\n  };\n  pick(A15, base[0], AW, 0, 0.5, 0.57, 0);\n  pick(BCC, base[1], AK, 0.25, 0.25, 0.8, 1);\n  S.PX = new Float64Array(16);\n  S.PY = new Float64Array(16);\n  S.PZ = new Float64Array(16);\n  S.zb = new Float32Array(N);\n  S.rgb = new Float32Array(N * 3);\n  S.col = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.kel = cl(k[2], 0, 1);\n  S.gap = cl(k[3], 0, 1);\n  S.th += d * S.speed * 0.2;\n}\n\n// The view: turned th about the vertical, then tipped EL toward the viewer\n// so the tops of the cells show, with a little perspective from DCAM LEDs.\n// A key light from the upper left and a weaker fill from the right.\nconst EL = 0.28, CE = cos(EL), SE = sin(EL), DCAM = 220;\n// Light kept in the shade and overall gain for each face colour (see draw);\n// hexagons keep more so their gold never sinks to brown.\nconst AMB = [0.14, 0.42, 0.22, 0.14], GAIN = [0.95, 1.05, 1, 0.95];\n\n// Fills a convex polygon of n screen corners row by row, the depth taken\n// from the plane through three of them; nearer pixels win.\nfunction poly(S, X, Y, Z, n, r, g, b) {\n  let y0 = 1e9, y1 = -1e9;\n  for (let m = 0; m \u003c n; m++) (y0 = min(y0, Y[m])), (y1 = max(y1, Y[m]));\n  const ux = X[1] - X[0], uy = Y[1] - Y[0], uz = Z[1] - Z[0], vx = X[2] - X[0], vy = Y[2] - Y[0], vz = Z[2] - Z[0], dn = ux * vy - uy * vx;\n  if (abs(dn) \u003c 1e-6) return;\n  const zx = (uz * vy - uy * vz) / dn, zy = (ux * vz - uz * vx) / dn, zb = S.zb, rgb = S.rgb;\n  for (let y = max(0, Math.ceil(y0)), ye = min(H - 1, floor(y1)); y \u003c= ye; y++) {\n    let xl = 1e9, xr = -1e9;\n    for (let m = 0; m \u003c n; m++) {\n      const k = m + 1 \u003c n ? m + 1 : 0, ya = Y[m], yb = Y[k];\n      if ((ya \u003c= y && yb >= y) || (yb \u003c= y && ya >= y)) {\n        const x = ya === yb ? X[m] : X[m] + ((y - ya) * (X[k] - X[m])) / (yb - ya);\n        xl = min(xl, x);\n        xr = max(xr, x);\n        if (ya === yb) xr = max(xr, X[k]), (xl = min(xl, X[k]));\n      }\n    }\n    for (let x = max(0, Math.ceil(xl)), xe = min(W - 1, floor(xr)); x \u003c= xe; x++) {\n      const p = y * W + x, z = Z[0] + zx * (x - X[0]) + zy * (y - Y[0]);\n      if (z \u003c= zb[p]) continue;\n      // Darker with depth, pixel by pixel, so a face turning away fades\n      // along its length.\n      const f = cl(0.72 + z / 55, 0.3, 1);\n      zb[p] = z;\n      rgb[p * 3] = r * f;\n      rgb[p * 3 + 1] = g * f;\n      rgb[p * 3 + 2] = b * f;\n    }\n  }\n}\n\nfunction line(S, ax, ay, az, bx, by, bz, lv) {\n  const n = Math.ceil(max(abs(bx - ax), abs(by - ay))) + 1, zb = S.zb, rgb = S.rgb;\n  for (let i = 0; i \u003c= n; i++) {\n    const t = i / n, x = Math.round(ax + t * (bx - ax)), y = Math.round(ay + t * (by - ay));\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const p = y * W + x;\n    if (az + t * (bz - az) \u003c zb[p] - 1.5) continue;\n    rgb[p * 3] = max(rgb[p * 3], lv);\n    rgb[p * 3 + 1] = max(rgb[p * 3 + 1], lv);\n    rgb[p * 3 + 2] = max(rgb[p * 3 + 2], lv);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const zb = S.zb, rgb = S.rgb, PX = S.PX, PY = S.PY, PZ = S.PZ;\n  zb.fill(-1e9);\n  rgb.fill(0);\n  const ct = cos(S.th), st = sin(S.th), sc = 1 - 0.5 * S.gap;\n  // Face colours: pentagons of the fourteen-faced cells, hexagons, squares\n  // and the pentagons of the dodecahedra, a little greener.\n  const col = S.col;\n  hsv(0.53 + S.hue, 0.75, 1, col[0]);\n  hsv(0.14 + S.hue, 0.6, 1, col[1]);\n  hsv(0.8 + S.hue, 0.6, 1, col[2]);\n  hsv(0.45 + S.hue, 0.65, 1, col[3]);\n  // The cut between the two structures, from above the top (all WP) at\n  // Kelvin 0 to below the bottom (all Kelvin) at 1.\n  const yc = 64 - 128 * S.kel, half = 8;\n  for (const it of S.inst) {\n    it.on = it.kind === 0 ? it.y \u003c yc - half : it.y > yc + half;\n    if (!it.on) continue;\n    const c = it.c, V = c.V, a = it.a * sc, sx = it.sx, sy = it.sy, sz = it.sz, fr = it.fr;\n    for (let k = 0; k \u003c V.length; k++) {\n      const x = it.x + a * V[k][0], y = it.y + a * V[k][1], z = it.z + a * V[k][2];\n      const xr = ct * x + st * z, zr = -st * x + ct * z, yr = CE * y - SE * zr, zz = SE * y + CE * zr, f = DCAM / (DCAM - zz);\n      sx[k] = CX + xr * f;\n      sy[k] = CY - yr * f;\n      sz[k] = zz;\n    }\n    c.faces.forEach((fc, j) => {\n      const n = fc.n, nx = ct * n[0] + st * n[2], nzr = -st * n[0] + ct * n[2], ny = CE * n[1] - SE * nzr, nz = SE * n[1] + CE * nzr;\n      // Back faces away (seen from the camera, DCAM in front); the rest lit\n      // from the upper left and darker with depth.\n      const i0 = fc.ix[0], px = (sx[i0] - CX) * (DCAM - sz[i0]) / DCAM, py = (CY - sy[i0]) * (DCAM - sz[i0]) / DCAM;\n      fr[j] = nx * -px + ny * -py + nz * (DCAM - sz[i0]) > 0 ? 1 : 0;\n      if (!fr[j]) return;\n      const t = fc.nv === 5 ? (c.faces.length === 12 ? 3 : 0) : fc.nv === 6 ? 1 : 2;\n      const lam = max(0, -0.45 * nx + 0.6 * ny + 0.66 * nz), fill = max(0, 0.6 * nx - 0.1 * ny + 0.79 * nz);\n      const sh = min(1, AMB[t] + (1 - AMB[t]) * (0.8 * lam * lam + 0.3 * fill)) * GAIN[t], cc = col[t];\n      for (let m = 0; m \u003c fc.nv; m++) (PX[m] = sx[fc.ix[m]]), (PY[m] = sy[fc.ix[m]]), (PZ[m] = sz[fc.ix[m]]);\n      poly(S, PX, PY, PZ, fc.nv, cc[0] * sh, cc[1] * sh, cc[2] * sh);\n    });\n  }\n  // Edges of the faces turned to the viewer, white, dimmer further back.\n  for (const it of S.inst) {\n    if (!it.on) continue;\n    const e = it.c.edges, sx = it.sx, sy = it.sy, sz = it.sz, fr = it.fr;\n    for (let m = 0; m \u003c e.length; m += 4) {\n      if (!fr[e[m + 2]] && !fr[e[m + 3]]) continue;\n      const a = e[m], b = e[m + 1];\n      line(S, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], cl(0.62 + (sz[a] + sz[b]) / 100, 0.35, 0.95));\n    }\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n","barycentric-subdivision":"// ===== Patternflow pattern =====\n// Title:   Barycentric Subdivision\n// Family:  fractal\n// Idea:    A triangle cut along its medians into six, and each of those again, fills the panel as a mosaic coloured by each piece's largest angle, and the camera dives child after child down one random line of descent, outlined in white three steps ahead and turning and scaling but never stretching, until the pieces are hot slivers and the walk starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: iterated barycentric subdivision, whose triangles flatten (Imre Bárány, Alan F. Beardon and T. Keith Carne, 1996; Persi Diaconis and Laurent Miclo, 2011), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=2..3, Steer=0..1\n//\n// Knob 1: Hue. Turns the whole angle scale round the wheel. At 0 a piece whose largest angle is 60 degrees is cyan, 90 azure, 120 blue, 150 violet, 170 magenta, 177 rose and 179 red-orange, and one within a third of a degree of flat is a pale amber.\n// Knob 2: Speed. At 2 the camera takes 2.2 seconds to dive from one triangle into the next, slowing as it arrives; at 0.2 ten times slower, at 3 half as fast again. When the current triangle's largest angle passes 179 degrees the picture fades and starts again from an equilateral triangle; with random steps that happens after 25 dives in the median, under a minute at 2.\n// Knob 3: Depth. How many levels below the current triangle the mosaic is cut. At 2 the current triangle shows as 36 pieces and the third level, 216, fades in as the camera closes on the next triangle, which then shows 36 of its own; at 3 it is 216 going to 1,296. A piece whose smallest height on the panel is under 3 LEDs is never cut, so the slivers stay whole and the finest level shows only inside the rounder pieces.\n// Knob 4: Steer. The chance at each step that the camera takes the roundest of the six children instead of a random one, from 0 at 0.1 to 1 at the top. Up to 0.1 every step is random as in the theorem, and after 40 steps two descents in three have a largest angle over 179 degrees. At 0.3, two steps in nine steered, it is one in twelve. From 0.4, one step in three, the shapes hold: the median largest angle stays near 115 degrees and the colours stay cool. At 1 every step takes the roundest child and the largest angle stays between 68 and 90 degrees.\n// Buttons: K1 tap starts again from an equilateral triangle.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, atan2, acos, abs, exp, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// A child is named by the order of the barycentric coordinates inside it:\n// child c holds the points whose largest coordinate is CI[c] and second CJ[c].\n// Its corners are the vertex CI, the midpoint of the side CI-CJ and the\n// centroid, in that order. With corners 0, 1 and z, child c has the shape\n// 2(1+z)/3, 2(1+z)/3z, (4-2z)/3, 2(z-2)/3(z-1), 2(2z-1)/3z, 2(1-2z)/3(1-z):\n// a fixed Moebius map of z, or of its mirror image for c = 1, 2 and 5.\nconst CI = [0, 0, 1, 1, 2, 2], CJ = [1, 2, 0, 2, 0, 1];\n// Triangles kept above the current one, for the mosaic round it.\nconst KEEP = 12;\n// Seconds per level at Speed 1.\nconst LEVEL = 4.4;\n// A line of descent ends when the current triangle's largest angle passes this.\nconst FLAT = 179;\n// A triangle whose smallest height on the panel is under LOD LEDs is not cut\n// further; up to twice that its children fade in.\nconst LOD = 3;\n// Margin in LEDs when a triangle is framed.\nconst MG = 1;\n// Angle scale: LUT entries from 60 to 180 degrees.\nconst NL = 512;\n\nfunction child(src, so, c, dst, d) {\n  const i = 2 * CI[c], j = 2 * CJ[c];\n  const xi = src[so + i], yi = src[so + i + 1];\n  const gx = (src[so] + src[so + 2] + src[so + 4]) / 3, gy = (src[so + 1] + src[so + 3] + src[so + 5]) / 3;\n  dst[d] = xi;\n  dst[d + 1] = yi;\n  dst[d + 2] = 0.5 * (xi + src[so + j]);\n  dst[d + 3] = 0.5 * (yi + src[so + j + 1]);\n  dst[d + 4] = gx;\n  dst[d + 5] = gy;\n}\n\n// Where a triangle sits on the colour scale, 0 to 1: half is its largest\n// angle from 60 to 180 degrees, half how far it is short of flat on a log\n// scale from 30 degrees down to 0.3, so 170, 177 and 179.5 look different.\nfunction heat(t, o) {\n  const a = bigAngle(t, o), d = 180 - a;\n  return cl(0.5 * ((a - 60) / 120) + 0.5 * cl((Math.log10(30) - Math.log10(d > 1e-9 ? d : 1e-9)) / 2, 0, 1), 0, 1);\n}\n\n// Largest angle of a triangle, in degrees.\nfunction bigAngle(t, o) {\n  const ax = t[o + 2] - t[o + 4], ay = t[o + 3] - t[o + 5];\n  const bx = t[o + 4] - t[o], by = t[o + 5] - t[o + 1];\n  const cx = t[o] - t[o + 2], cy = t[o + 1] - t[o + 3];\n  let m = ax * ax + ay * ay, p = bx * bx + by * by, q = cx * cx + cy * cy, w;\n  if (p > m) (w = m), (m = p), (p = w);\n  if (q > m) (w = m), (m = q), (q = w);\n  return (acos(cl((p + q - m) / (2 * sqrt(p * q) + 1e-300), -1, 1)) * 180) / PI;\n}\n\n// The similarity z -> a z + b that sets triangle t as large as it fits in the\n// panel, preferring small turns from the present view. Writes [ar, ai, br, bi].\nfunction frame(t, o, out) {\n  let best = -1, bs = 1, bt = 0, lx = 0, ly0 = 0, ll = 0;\n  for (let v = 0; v \u003c 6; v += 2) {\n    const w = (v + 2) % 6, dx = t[o + w] - t[o + v], dy = t[o + w + 1] - t[o + v + 1];\n    if (dx * dx + dy * dy > ll) (ll = dx * dx + dy * dy), (lx = dx), (ly0 = dy);\n  }\n  const tryAt = (th) => {\n    if (th > PI) th -= 2 * PI;\n    if (th \u003c= -PI) th += 2 * PI;\n    const c = cos(th), sn = sin(th);\n    let x0 = 1e300, x1 = -1e300, y0 = 1e300, y1 = -1e300;\n    for (let v = 0; v \u003c 6; v += 2) {\n      const x = t[o + v], y = t[o + v + 1], rx = c * x - sn * y, ry = sn * x + c * y;\n      if (rx \u003c x0) x0 = rx;\n      if (rx > x1) x1 = rx;\n      if (ry \u003c y0) y0 = ry;\n      if (ry > y1) y1 = ry;\n    }\n    const sc = min((W - 2 * MG) / (x1 - x0 + 1e-300), (H - 2 * MG) / (y1 - y0 + 1e-300));\n    // A long side stood upright scores a quarter more, so a sliver stands\n    // along the columns instead of the panel's diagonal.\n    const ly = sn * lx + c * ly0;\n    const score = sc * (1 - (0.3 * abs(th)) / PI) * (1 + 0.25 * (ly * ly / ll) ** 8);\n    if (score > best) (best = score), (bs = sc), (bt = th);\n  };\n  for (let n = -48; n \u003c 48; n++) tryAt((n * PI) / 48);\n  const t0 = bt;\n  for (let n = -16; n \u003c= 16; n++) tryAt(t0 + (n * PI) / 768);\n  const ar = bs * cos(bt), ai = bs * sin(bt);\n  let x0 = 1e300, x1 = -1e300, y0 = 1e300, y1 = -1e300;\n  for (let v = 0; v \u003c 6; v += 2) {\n    const x = t[o + v], y = t[o + v + 1], rx = ar * x - ai * y, ry = ai * x + ar * y;\n    if (rx \u003c x0) x0 = rx;\n    if (rx > x1) x1 = rx;\n    if (ry \u003c y0) y0 = ry;\n    if (ry > y1) y1 = ry;\n  }\n  out[0] = ar;\n  out[1] = ai;\n  out[2] = W / 2 - 0.5 * (x0 + x1);\n  out[3] = H / 2 - 0.5 * (y0 + y1);\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The colour scale: cyan for round pieces through blue, violet, magenta and\n// rose to a pale amber for flat ones.\nfunction palette(s) {\n  for (let n = 0; n \u003c NL; n++) {\n    const t = n / (NL - 1);\n    hsv(s.hue + 0.48 + 0.64 * t, 0.9 - 0.35 * t ** 6, 0.62 + 0.38 * t, s.lut, n * 3);\n  }\n  s.lutHue = s.hue;\n}\n\nexport function setup(params) {\n  const s = {\n    hue: 0, depth: 2, steer: 0,\n    // Stored triangles in world coordinates: 0 is the current one, j its j-th\n    // ancestor; path[j] is the child taken from j + 1 to j.\n    tri: new Float64Array((KEEP + 1) * 6), path: new Int8Array(KEEP + 1), nA: 1,\n    // The planned line of descent: plan[0] leads from the current triangle to\n    // the next, plan[1] and plan[2] on from there.\n    next: 0, plan: new Int8Array(3), dz: new Float64Array(4), u: 0, level: 0, ang: 60,\n    ow: new Float32Array(W * H), ot: new Float64Array(24),\n    gain: 1, fading: 0, lut: new Float64Array(NL * 3), lutHue: -1, tmp: new Float64Array(36),\n    // Drawing: one triangle per depth of the walk, the path as seen from the\n    // oldest kept triangle, and the frame.\n    P: new Float64Array(40 * 6), pc: new Int8Array(KEEP + 2), A: 0, tgt: 0, w: 0, spIn: 1, spOut: 1,\n    fb: new Float32Array(W * H * 3), mark: new Uint8Array(W * H),\n  };\n  params.s = s;\n  // The first update reads the knobs and then plans the first steps.\n  s.fresh = true;\n}\n\nfunction restart(s) {\n  // An equilateral triangle, turned at random, then framed.\n  const th = Math.random() * 2 * PI, t = s.tri;\n  for (let v = 0; v \u003c 3; v++) {\n    t[2 * v] = cos(th + (v * 2 * PI) / 3);\n    t[2 * v + 1] = sin(th + (v * 2 * PI) / 3);\n  }\n  frame(t, 0, s.dz);\n  apply(t, 0, s.dz);\n  s.nA = 1;\n  s.u = 0;\n  s.level = 0;\n  s.ang = 60;\n  const k = s.tmp;\n  for (let v = 0; v \u003c 6; v++) k[v] = t[v];\n  for (let m = 0; m \u003c 3; m++) {\n    s.plan[m] = pick(s, k, m * 6);\n    child(k, m * 6, s.plan[m], k, m * 6 + 6);\n  }\n  aim(s);\n}\n\nfunction apply(t, o, z) {\n  for (let v = o; v \u003c o + 6; v += 2) {\n    const x = t[v], y = t[v + 1];\n    t[v] = z[0] * x - z[1] * y + z[2];\n    t[v + 1] = z[1] * x + z[0] * y + z[3];\n  }\n}\n\n// Picks a child of triangle t: at random, or with chance Steer the roundest\n// one; between children of the same shape, the one the camera reaches with\n// the smallest turn.\nfunction pick(s, t, o) {\n  let c = floor(Math.random() * 6) % 6;\n  if (Math.random() \u003c s.steer) {\n    const k = s.ot, z = [0, 0, 0, 0];\n    let bv = 1e9, bt = 1e9;\n    for (let n = 0; n \u003c 6; n++) {\n      child(t, o, n, k, 0);\n      const a = bigAngle(k, 0);\n      frame(k, 0, z);\n      const turn = abs(atan2(z[1], z[0]));\n      if (a \u003c bv - 1e-6 || (a \u003c bv + 1e-6 && turn \u003c bt)) (bv = min(bv, a)), (bt = turn), (c = n);\n    }\n  }\n  return c;\n}\n\n// The similarity that frames the next triangle.\nfunction aim(s) {\n  s.next = s.plan[0];\n  child(s.tri, 0, s.next, s.tmp, 0);\n  frame(s.tmp, 0, s.dz);\n}\n\nfunction advance(s) {\n  const t = s.tri, z = s.dz;\n  for (let j = 0; j \u003c s.nA; j++) apply(t, j * 6, z);\n  const keep = min(s.nA, KEEP);\n  for (let j = keep; j > 0; j--) {\n    for (let v = 0; v \u003c 6; v++) t[j * 6 + v] = t[(j - 1) * 6 + v];\n    s.path[j] = s.path[j - 1];\n  }\n  child(t, 6, s.next, t, 0);\n  s.path[0] = s.next;\n  s.nA = keep + 1;\n  s.level++;\n  s.ang = bigAngle(t, 0);\n  if (s.ang > FLAT && !s.fading) s.fading = 1;\n  const k = s.tmp, pl = s.plan;\n  pl[0] = pl[1];\n  pl[1] = pl[2];\n  child(t, 0, pl[0], k, 0);\n  child(k, 0, pl[1], k, 6);\n  pl[2] = pick(s, k, 6);\n  aim(s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.depth = cl(k[2], 2, 3);\n  s.steer = cl((k[3] - 0.1) / 0.9, 0, 1);\n  if (s.fresh) {\n    s.fresh = false;\n    restart(s);\n  }\n  if (input.btnPressed && input.btnPressed[0] && !s.fading) s.fading = 2;\n  if (s.fading) {\n    // Fade out, start again, fade in.\n    s.gain -= d * (s.fading === 2 ? 4 : 1.5);\n    if (s.gain \u003c= 0) {\n      s.gain = 0;\n      s.fading = 0;\n      restart(s);\n    }\n  } else s.gain = min(1, s.gain + d * 1.5);\n  s.u += (d * sp) / LEVEL;\n  while (s.u >= 1) {\n    s.u -= 1;\n    advance(s);\n  }\n}\n\n// Fills one triangle's LEDs: the colour, darkened near the parent's sides\n// (heights hc2 and hj) at weight wl and near the child's own inner sides\n// (heights hc0, hc1) at weight wk.\nfunction raster(s, X0, Y0, X1, Y1, X2, Y2, r, g, b, hc0, hc1, hc2, hj, wl, wk) {\n  const ex = X1 - X0, ey = Y1 - Y0, fx = X2 - X0, fy = Y2 - Y0, dd = ex * fy - fx * ey;\n  if (!(abs(dd) > 1e-12)) return;\n  const a1 = fy / dd, b1 = -fx / dd, c1 = (fx * Y0 - fy * X0) / dd;\n  const a2 = -ey / dd, b2 = ex / dd, c2 = (ey * X0 - ex * Y0) / dd;\n  const a0 = -a1 - a2, b0 = -b1 - b2, c0 = 1 - c1 - c2;\n  const ya = max(0, Math.ceil(min(Y0, Y1, Y2) - 0.5)), yb = min(H - 1, floor(max(Y0, Y1, Y2) - 0.5));\n  const xa = max(0, Math.ceil(min(X0, X1, X2) - 0.5)), xb = min(W - 1, floor(max(X0, X1, X2) - 0.5));\n  const { fb, mark } = s;\n  for (let y = ya; y \u003c= yb; y++) {\n    const py = y + 0.5;\n    let lo = xa, hi = xb;\n    for (let e = 0; e \u003c 3; e++) {\n      const a = e === 0 ? a0 : e === 1 ? a1 : a2, bt = e === 0 ? b0 * py + c0 : e === 1 ? b1 * py + c1 : b2 * py + c2;\n      if (a > 1e-12) {\n        const x = Math.ceil(-bt / a - 0.5);\n        if (x > lo) lo = x;\n      } else if (a \u003c -1e-12) {\n        const x = floor(-bt / a - 0.5);\n        if (x \u003c hi) hi = x;\n      } else if (bt \u003c 0) hi = -1;\n    }\n    for (let x = lo; x \u003c= hi; x++) {\n      const px = x + 0.5, q1 = a1 * px + b1 * py + c1, q2 = a2 * px + b2 * py + c2, q0 = 1 - q1 - q2;\n      let dl = q2 * hc2, dk = q0 * hc0;\n      const dj = (0.5 * q1 + q2 / 3) * hj, d1 = q1 * hc1;\n      if (dj \u003c dl) dl = dj;\n      if (d1 \u003c dk) dk = d1;\n      const el = wl * (1 - cl((dl - 0.15) / 0.6, 0, 1)), ek = wk * (1 - cl((dk - 0.15) / 0.6, 0, 1));\n      const f = 1 - 0.8 * (el > ek ? el : ek), i = y * W + x;\n      fb[i * 3] = r * f;\n      fb[i * 3 + 1] = g * f;\n      fb[i * 3 + 2] = b * f;\n      mark[i] = 1;\n    }\n  }\n}\n\n// Draws the six children of the triangle at depth d, each in a mix of its\n// parent's colour and its own at weight w, with its inner sides at weight w.\nfunction emit(s, d, w, on, inT, A2, l0, l1, l2) {\n  const P = s.P, o = d * 6, q = o + 6, lut = s.lut;\n  let id = floor(heat(P, o) * (NL - 1)) * 3;\n  const nr = lut[id], ng = lut[id + 1], nb = lut[id + 2];\n  const s0 = sqrt(l0), s1 = sqrt(l1), s2 = sqrt(l2);\n  const wl = cl((A2 / (s0 + s1 + s2) - 0.3) / 0.9, 0, 1), ca = A2 / 6;\n  for (let c = 0; c \u003c 6; c++) {\n    child(P, o, c, P, q);\n    let r = nr, g = ng, b = nb;\n    if (w > 0) {\n      id = floor(heat(P, q) * (NL - 1)) * 3;\n      r += (lut[id] - nr) * w;\n      g += (lut[id + 1] - ng) * w;\n      b += (lut[id + 2] - nb) * w;\n    }\n    const X0 = P[q], Y0 = P[q + 1], X1 = P[q + 2], Y1 = P[q + 3], X2 = P[q + 4], Y2 = P[q + 5];\n    const k0 = Math.hypot(X1 - X2, Y1 - Y2), k1 = Math.hypot(X2 - X0, Y2 - Y0), k2 = Math.hypot(X0 - X1, Y0 - Y1);\n    const wk = w * cl((ca / (k0 + k1 + k2) - 0.3) / 0.9, 0, 1);\n    const sp = inT || (on && d === s.A && c === s.next) ? s.spIn : s.spOut;\n    const j = CJ[c], hj = A2 / (j === 0 ? s0 : j === 1 ? s1 : s2);\n    raster(s, X0, Y0, X1, Y1, X2, Y2, r * sp, g * sp, b * sp, ca / k0, ca / k1, ca / k2, hj, wl, wk);\n  }\n}\n\n// Walks the subdivision from the oldest kept triangle down to the mosaic's\n// level, skipping triangles off the panel.\nfunction walk(s, d, on, inT) {\n  const P = s.P, o = d * 6;\n  const x0 = P[o], y0 = P[o + 1], x1 = P[o + 2], y1 = P[o + 3], x2 = P[o + 4], y2 = P[o + 5];\n  if (max(x0, x1, x2) \u003c 0 || min(x0, x1, x2) > W || max(y0, y1, y2) \u003c 0 || min(y0, y1, y2) > H) return;\n  const A2 = abs((x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0));\n  const l0 = (x1 - x2) ** 2 + (y1 - y2) ** 2, l1 = (x2 - x0) ** 2 + (y2 - y0) ** 2, l2 = (x0 - x1) ** 2 + (y0 - y1) ** 2;\n  const open = (d \u003c s.tgt ? 1 : s.w) * cl((A2 / sqrt(max(l0, l1, l2)) - LOD) / LOD, 0, 1);\n  if (open >= 1 && d \u003c s.tgt) {\n    for (let c = 0; c \u003c 6; c++) {\n      child(P, o, c, P, o + 6);\n      const oc = on && d \u003c= s.A && c === s.pc[d];\n      walk(s, d + 1, oc, inT || (oc && d === s.A));\n    }\n  } else emit(s, d, open, on, inT, A2, l0, l1, l2);\n}\n\nfunction outline(ow, t, o, al) {\n  for (let e = 0; e \u003c 6; e += 2) {\n    const ax = t[o + e], ay = t[o + e + 1], bx = t[o + ((e + 2) % 6)], by = t[o + ((e + 3) % 6)];\n    const n = Math.ceil(Math.hypot(bx - ax, by - ay) * 2.5) + 1;\n    for (let i = 0; i \u003c= n; i++) {\n      const x = floor(ax + ((bx - ax) * i) / n), y = floor(ay + ((by - ay) * i) / n);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H && ow[y * W + x] \u003c al) ow[y * W + x] = al;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || s.fresh) return;\n  if (s.lutHue !== s.hue) palette(s);\n  const { tri, dz, P, fb, mark } = s;\n  // The camera: the spiral similarity from this triangle's frame to the next\n  // one, raised to the eased progress v, about its fixed point.\n  const u = s.u, v = u - (0.7 * sin(2 * PI * u)) / (2 * PI);\n  const ar = dz[0], ai = dz[1], den = (1 - ar) * (1 - ar) + ai * ai;\n  const qr = (dz[2] * (1 - ar) - dz[3] * ai) / den, qi = (dz[3] * (1 - ar) + dz[2] * ai) / den;\n  const ls = log(Math.hypot(ar, ai)) * v, th = atan2(ai, ar) * v;\n  const mr = exp(ls) * cos(th), mi = exp(ls) * sin(th);\n  const A = s.nA - 1;\n  for (let c = 0; c \u003c 6; c += 2) {\n    const x = tri[A * 6 + c] - qr, y = tri[A * 6 + c + 1] - qi;\n    P[c] = qr + mr * x - mi * y;\n    P[c + 1] = qi + mi * x + mr * y;\n  }\n  for (let d = 0; d \u003c A; d++) s.pc[d] = s.path[A - 1 - d];\n  s.pc[A] = s.next;\n  s.A = A;\n  // The mosaic's depth below the current triangle runs on with the dive, so\n  // the next level fades in as the camera closes in.\n  const e = s.depth + v, L = floor(e);\n  s.tgt = A + L;\n  s.w = e - L;\n  const { ow, ot, plan } = s;\n  for (let c = 0; c \u003c 6; c += 2) {\n    const x = tri[c] - qr, y = tri[c + 1] - qi;\n    ot[c] = qr + mr * x - mi * y;\n    ot[c + 1] = qi + mi * x + mr * y;\n  }\n  // Mid-dive the next triangle is lit and the rest dimmed, while the current\n  // triangle is wide enough on the panel to be cut.\n  const l0 = (ot[2] - ot[4]) ** 2 + (ot[3] - ot[5]) ** 2, l1 = (ot[4] - ot[0]) ** 2 + (ot[5] - ot[1]) ** 2, l2 = (ot[0] - ot[2]) ** 2 + (ot[1] - ot[3]) ** 2;\n  const tall = abs((ot[2] - ot[0]) * (ot[5] - ot[1]) - (ot[4] - ot[0]) * (ot[3] - ot[1])) / sqrt(max(l0, l1, l2));\n  const g = tall > 2 * LOD ? sin(PI * v) ** 2 : 0;\n  s.spIn = 1 + 0.15 * g;\n  s.spOut = 1 - 0.3 * g;\n  fb.fill(0);\n  mark.fill(0);\n  walk(s, 0, true, false);\n  // The planned line of descent in white: the next triangle and the two inside\n  // it, each outline coming up as the one before it is reached.\n  ow.fill(0);\n  for (let m = 0; m \u003c 3; m++) {\n    child(ot, m * 6, plan[m], ot, m * 6 + 6);\n    const x = m + 1 - v, al = x \u003c 1 ? 0.5 * x : x \u003c 2 ? 0.5 - 0.2 * (x - 1) : 0.3 * (3 - x);\n    if (al > 0.01) outline(ow, ot, m * 6 + 6, al);\n  }\n  // An LED whose centre fell exactly on a shared side takes its neighbour's colour.\n  const ex = P[2] - P[0], ey = P[3] - P[1], fx = P[4] - P[0], fy = P[5] - P[1], dd = ex * fy - fx * ey;\n  const gain = s.gain * 255;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let i = y * W + x;\n      if (!mark[i]) {\n        const px = x + 0.5 - P[0], py = y + 0.5 - P[1];\n        const b1 = (px * fy - py * fx) / dd, b2 = (ex * py - ey * px) / dd;\n        if (b1 \u003c 0 || b2 \u003c 0 || b1 + b2 > 1) {\n          display.setPixel(x, y, 0, 0, 0);\n          continue;\n        }\n        if (x > 0 && mark[i - 1]) i--;\n        else if (y > 0 && mark[i - W]) i -= W;\n        else if (x \u003c W - 1 && mark[i + 1]) i++;\n      }\n      const w = ow[y * W + x], f = 1 - w;\n      display.setPixel(x, y, (fb[i * 3] * f + w) * gain, (fb[i * 3 + 1] * f + w) * gain, (fb[i * 3 + 2] * f + w) * gain);\n    }\n}\n","belt-trick":"// ===== Patternflow pattern =====\n// Title:   Belt Trick\n// Family:  topology\n// Idea:    A cube in the middle of the panel, tied by ribbons to bars along the top and bottom edges, turns about one axis without stopping: after one full turn the ribbons are wound round it and no moving of the ribbons alone can free them, after the second they have swung round the cube and hang straight again, and a ring behind it fills once a turn, violet in the first and green in the second, so the two turns can be told apart.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dirac's string problem (Paul Dirac; M. H. A. Newman, 1942), the double cover of SO(3) by the unit quaternions, pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ribbons=2..8, Tilt=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the ribbons are amber on the front and cyan on the back, the cube's faces blue, violet and pink, and the ring violet in the first turn and green in the second.\n// Knob 2: Speed. At 2 the cube turns once in 4 seconds, so the ribbons come free every 8; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Ribbons. How many ribbons tie the cube, from 2, one belt up and one down, to 8, four each way. Fewer ribbons are wider. Neighbours also sit 4 apart in depth: over a whole loop no two ribbons come closer than 0.6 LEDs with 8 of them, 0.8 with 4 and 4.8 with 2.\n// Knob 4: Tilt. The spin axis. At 0 it stands upright and the cube turns like a plate on a waiter's hand, and after one turn the ribbons lie wound round it in the plane of the panel; at 1 it points at us, the cube turns like a wheel, and after one turn the ribbons are twisted round each other like a rope.\n// Buttons: K1 tap reverses the spin.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, ceil, sqrt, sin, cos, abs, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The cube's half side, the ball it turns in, the shell the ribbons move in,\n// and the wall the ribbons are tied to, just past the panel's top and bottom.\nconst HC = 8, RIN = HC * sqrt(3) + 1.2, ROUT = 30.5, YW = 67;\n// Rows of a ribbon inside the shell.\nconst NS = 110;\n// Camera: turned a little to the right and looking a little down.\nconst DIST = 170, YAW = 0.42, PITCH = 0.16, CX = 31.5, CY = 63.5;\nconst CYW = cos(YAW), SYW = sin(YAW), CP = cos(PITCH), SP = sin(PITCH);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [\n    i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p,\n    i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p,\n    i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p,\n  ];\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  params.s = {\n    t: 0, dir: 1, hue: 0, sp: 2, n: 2, tilt: 0.06,\n    zb: F(N), id: new Int16Array(N), col: F(N * 3),\n    // Mapped ribbon vertices (world) and their screen places.\n    wx: F(2 * NS + 8), wy: F(2 * NS + 8), wz: F(2 * NS + 8), sx: F(2 * NS + 8), sy: F(2 * NS + 8), sz: F(2 * NS + 8),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  s.sp = cl(k[1], 0.2, 3);\n  s.n = cl(Math.round(k[2]), 2, 8);\n  s.tilt = cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) s.dir = -s.dir;\n  // t runs 0..1 over the two turns, 720 degrees.\n  s.t += (s.dir * d * s.sp) / 16;\n  s.t -= floor(s.t);\n}\n\n// The homotopy. q(t) = cos(2 pi t) + sin(2 pi t) a is the cube's turn by\n// 720 degrees about the unit axis a, a loop in the unit quaternions. With\n// b = s pi / 2 and v a unit vector at right angles to a,\n//   H(s, t) = (cos^2 b + sin^2 b cos 2 pi t) + (sin b sin 2 pi t) a + (cos b sin b (1 - cos 2 pi t)) v.\n// For each s, t runs H round a circle in the 3-sphere that passes through 1\n// and touches the loop there; the circles shrink from the loop itself at\n// s = 1 to the point 1 at s = 0. H has length 1, H(0, t) = 1, H(1, t) = q(t)\n// and H(s, 0) = H(s, 1) = 1. At t = 1/2 it is a turn by 360 s degrees about\n// v: the ribbons wound once round the cube. s is read off the distance from\n// the cube's centre, 0 at the shell's outer sphere and 1 at its inner one,\n// so every sphere round the cube turns as one piece and nothing in space\n// ever passes through anything else.\nfunction shellTurn(x, y, z, ax, ay, az, vx, vy, vz, C, S, out, o) {\n  const r = sqrt(x * x + y * y + z * z);\n  let u = cl((ROUT - r) / (ROUT - RIN), 0, 1);\n  u = u * u * (3 - 2 * u);\n  const b = (u * PI) / 2, cb = cos(b), sb = sin(b);\n  const w = cb * cb + sb * sb * C, p = sb * S, q = cb * sb * (1 - C);\n  rot(w, p * ax + q * vx, p * ay + q * vy, p * az + q * vz, x, y, z, out, o);\n}\n\n// Turn (x, y, z) by the unit quaternion w + (i, j, k).\nfunction rot(w, i, j, k, x, y, z, out, o) {\n  const tx = 2 * (j * z - k * y), ty = 2 * (k * x - i * z), tz = 2 * (i * y - j * x);\n  out[o] = x + w * tx + (j * tz - k * ty);\n  out[o + 1] = y + w * ty + (k * tx - i * tz);\n  out[o + 2] = z + w * tz + (i * ty - j * tx);\n}\n\n// World to screen: the camera turns the world, then a soft perspective.\nfunction cam(x, y, z, out, o) {\n  const x1 = x * CYW - z * SYW, z1 = x * SYW + z * CYW;\n  const y2 = y * CP - z1 * SP, z2 = y * SP + z1 * CP;\n  const f = DIST / (DIST - z2);\n  out[o] = CX + x1 * f;\n  out[o + 1] = CY - y2 * f;\n  out[o + 2] = DIST - z2;\n}\n\nconst tmp = new Float32Array(3), hc = new Float32Array(3 * (NS + 3));\n// How much a normal faces the eye.\nconst toEye = (x, y, z) => y * SP + (x * SYW + z * CYW) * CP;\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { zb, id, col, wx, wy, wz, sx, sy, sz } = s;\n  zb.fill(1e9);\n  id.fill(0);\n  const al = ((1 - s.tilt) * PI) / 2;\n  const ax = 0, ay = sin(al), az = cos(al), vx = 0, vy = cos(al), vz = -sin(al);\n  const C = cos(TAU * s.t), S = sin(TAU * s.t);\n  const L = [0.42, 0.55, 0.72];\n  const h0 = s.hue;\n  const fr = hsv(h0 + 0.1, 0.85, 1), bk = hsv(h0 + 0.5, 0.75, 1);\n  const n = s.n, nt = ceil(n / 2);\n  let rib = 0;\n  for (let side = 0; side \u003c 2; side++) {\n    const k = side ? n - nt : nt, sg = side ? -1 : 1;\n    const spc = (1.75 * HC) / k, wdt = min(8.5, 0.5 * spc), spw = 46 / k;\n    for (let r = 0; r \u003c k; r++, rib++) {\n      // Neighbours sit 4 apart in depth as well, which keeps them about\n      // twice as far apart when they are wound round the cube.\n      const zs = k > 1 ? ((r + side) & 1 ? 2 : -2) : 0;\n      const off = r - (k - 1) / 2;\n      const Ax = off * spw, Ay = sg * YW, Bx = off * spc, By = sg * HC;\n      const dx = Bx - Ax, dy = By - Ay, len = sqrt(dx * dx + dy * dy);\n      // Across the ribbon, in the panel's plane.\n      const bx = (dy / len) * sg, by = (-dx / len) * sg;\n      // Where the centre line crosses the shell's spheres.\n      const uo = cross(Ax, Ay, dx, dy, sqrt((ROUT + 1) ** 2 - zs * zs)), ui = cross(Ax, Ay, dx, dy, sqrt((RIN - 0.5) ** 2 - zs * zs));\n      const rows = NS + 3;\n      for (let j = 0; j \u003c rows; j++) {\n        const u = j === 0 ? 0 : j === rows - 1 ? 1 : uo + ((ui - uo) * (j - 1)) / NS;\n        const cxp = Ax + dx * u, cyp = Ay + dy * u;\n        for (let e = 0; e \u003c 2; e++) {\n          const h = (e ? 0.5 : -0.5) * wdt, vi = j * 2 + e;\n          shellTurn(cxp + bx * h, cyp + by * h, zs, ax, ay, az, vx, vy, vz, C, S, tmp, 0);\n          wx[vi] = tmp[0];\n          wy[vi] = tmp[1];\n          wz[vi] = tmp[2];\n          cam(tmp[0], tmp[1], tmp[2], tmp, 0);\n          sx[vi] = tmp[0];\n          sy[vi] = tmp[1];\n          sz[vi] = tmp[2];\n        }\n      }\n      for (let j = 0; j \u003c rows - 1; j++) {\n        const a = j * 2, b = a + 1, c = a + 2, dd = a + 3;\n        // The face's normal in the world, for the light.\n        const ux = wx[c] - wx[a], uy = wy[c] - wy[a], uz = wz[c] - wz[a];\n        const qx = wx[b] - wx[a], qy = wy[b] - wy[a], qz = wz[b] - wz[a];\n        let nx = uy * qz - uz * qy, ny = uz * qx - ux * qz, nz = ux * qy - uy * qx;\n        const nl = 1 / (sqrt(nx * nx + ny * ny + nz * nz) + 1e-9);\n        nx *= nl;\n        ny *= nl;\n        nz *= nl;\n        // Which face is towards us: the sign of the quad's area on the screen.\n        const area = (sx[a] - sx[dd]) * (sy[b] - sy[c]) - (sx[b] - sx[c]) * (sy[a] - sy[dd]);\n        const front = area * sg \u003c 0;\n        tri(s, a, c, b, rib + 1, nx, ny, nz, front ? fr : bk, L);\n        tri(s, b, c, dd, rib + 1, nx, ny, nz, front ? fr : bk, L);\n        hc[j * 3] = s.lr * 0.8;\n        hc[j * 3 + 1] = s.lg * 0.8;\n        hc[j * 3 + 2] = s.lb * 0.8;\n      }\n      // The hems, drawn as lines, so a ribbon seen edge on stays a line.\n      for (let j = 0; j \u003c rows - 1; j++)\n        for (let e = 0; e \u003c 2; e++) {\n          const a = j * 2 + e, b = a + 2;\n          line(s, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], rib + 1, hc[j * 3], hc[j * 3 + 1], hc[j * 3 + 2]);\n        }\n    }\n  }\n  cube(s, ax, ay, az, C, S, L);\n  shade(s, display);\n}\n\n// The u where the line (Ax, Ay) + u (dx, dy) is at distance R from the centre.\nfunction cross(Ax, Ay, dx, dy, R) {\n  const a = dx * dx + dy * dy, b = 2 * (Ax * dx + Ay * dy), c = Ax * Ax + Ay * Ay - R * R;\n  const disc = b * b - 4 * a * c;\n  if (disc \u003c 0) return 1;\n  return cl((-b - sqrt(disc)) / (2 * a), 0, 1);\n}\n\nfunction tri(s, i0, i1, i2, idv, nx, ny, nz, c, L) {\n  const { sx, sy, sz } = s;\n  const x0 = sx[i0], y0 = sy[i0], x1 = sx[i1], y1 = sy[i1], x2 = sx[i2], y2 = sy[i2];\n  // Two-sided light: the normal is turned to face the eye.\n  const sgn = toEye(nx, ny, nz) >= 0 ? 1 : -1;\n  const ld = max(0, sgn * (nx * L[0] + ny * L[1] + nz * L[2]));\n  const lit = 0.6 + 0.4 * ld;\n  const r = c[0] * lit, g = c[1] * lit, b = c[2] * lit;\n  (s.lr = r), (s.lg = g), (s.lb = b);\n  fill(s, x0, y0, x1, y1, x2, y2, sz[i0], sz[i1], sz[i2], idv, r, g, b);\n}\n\nfunction line(s, x0, y0, z0, x1, y1, z1, idv, r, g, b) {\n  const { zb, id, col } = s;\n  const n = ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5) + 1;\n  for (let i = 0; i \u003c= n; i++) {\n    const u = i / n, x = floor(x0 + (x1 - x0) * u), y = floor(y0 + (y1 - y0) * u);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const q = y * W + x, d = z0 + (z1 - z0) * u - 0.9;\n    if (d \u003c zb[q]) {\n      zb[q] = d + 0.9;\n      id[q] = idv;\n      col[q * 3] = r;\n      col[q * 3 + 1] = g;\n      col[q * 3 + 2] = b;\n    }\n  }\n}\n\nfunction fill(s, x0, y0, x1, y1, x2, y2, z0, z1, z2, idv, r, g, b) {\n  const { zb, id, col } = s;\n  const den = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(den) \u003c 1e-9) return;\n  const inv = 1 / den;\n  const X0 = max(0, ceil(min(x0, x1, x2) - 0.5)), X1 = min(W - 1, floor(max(x0, x1, x2) - 0.5));\n  const Y0 = max(0, ceil(min(y0, y1, y2) - 0.5)), Y1 = min(H - 1, floor(max(y0, y1, y2) - 0.5));\n  for (let y = Y0; y \u003c= Y1; y++) {\n    const cy = y + 0.5 - y0;\n    for (let x = X0; x \u003c= X1; x++) {\n      const cx = x + 0.5 - x0;\n      const a = (cx * (y2 - y0) - cy * (x2 - x0)) * inv, bb = ((x1 - x0) * cy - (y1 - y0) * cx) * inv;\n      if (a \u003c -1e-6 || bb \u003c -1e-6 || a + bb > 1 + 1e-6) continue;\n      const d = z0 + (z1 - z0) * a + (z2 - z0) * bb, q = y * W + x;\n      if (d \u003c zb[q]) {\n        zb[q] = d;\n        id[q] = idv;\n        col[q * 3] = r;\n        col[q * 3 + 1] = g;\n        col[q * 3 + 2] = b;\n      }\n    }\n  }\n}\n\n// The cube: six faces, each its own colour, turned by q(t).\nconst FACES = [\n  [1, 0, 0, 0, 1, 0, 0, 0, 1], [-1, 0, 0, 0, 1, 0, 0, 0, -1],\n  [0, 1, 0, 0, 0, 1, 1, 0, 0], [0, -1, 0, 0, 0, -1, 1, 0, 0],\n  [0, 0, 1, 1, 0, 0, 0, 1, 0], [0, 0, -1, -1, 0, 0, 0, 1, 0],\n];\nconst cv = new Float32Array(12), cn = new Float32Array(3);\nfunction cube(s, ax, ay, az, C, S, L) {\n  const w = C, i = S * ax, j = S * ay, k = S * az;\n  for (let f = 0; f \u003c 6; f++) {\n    const F = FACES[f];\n    rot(w, i, j, k, F[0], F[1], F[2], cn, 0);\n    const vdot = toEye(cn[0], cn[1], cn[2]);\n    const ld = max(0, cn[0] * L[0] + cn[1] * L[1] + cn[2] * L[2]);\n    const c = hsv(s.hue + 0.62 + 0.13 * (f >> 1), f & 1 ? 0.4 : 0.8, 1);\n    const lit = 0.5 + 0.5 * ld;\n    for (let q = 0; q \u003c 4; q++) {\n      const e = q === 0 || q === 3 ? -1 : 1, g = q \u003c 2 ? -1 : 1;\n      const x = (F[0] + e * F[3] + g * F[6]) * HC, y = (F[1] + e * F[4] + g * F[7]) * HC, z = (F[2] + e * F[5] + g * F[8]) * HC;\n      rot(w, i, j, k, x, y, z, tmp, 0);\n      cam(tmp[0], tmp[1], tmp[2], cv, q * 3);\n    }\n    if (vdot \u003c -0.05) continue;\n    const r = c[0] * lit, gg = c[1] * lit, b = c[2] * lit;\n    fill(s, cv[0], cv[1], cv[3], cv[4], cv[6], cv[7], cv[2], cv[5], cv[8], 20 + f, r, gg, b);\n    fill(s, cv[0], cv[1], cv[6], cv[7], cv[9], cv[10], cv[2], cv[8], cv[11], 20 + f, r, gg, b);\n  }\n}\n\nfunction shade(s, display) {\n  const { id, col } = s;\n  const lap = s.t \u003c 0.5 ? 0 : 1, prog = (s.t * 2) % 1;\n  const ca = hsv(s.hue + 0.78, 0.65, 0.7), cb = hsv(s.hue + 0.36, 0.75, 0.7);\n  const cur = lap ? cb : ca, old = lap ? ca : cb;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3, p = id[q];\n      // The bars the ribbons are tied to, along the top and bottom edges,\n      // with a clamp where a ribbon goes under.\n      if (y \u003c 2 || y > H - 3) {\n        const edge = y === 1 || y === H - 2, tied = edge && id[y === 1 ? q + W : q - W] > 0 && id[y === 1 ? q + W : q - W] \u003c 20;\n        const v = tied ? 170 : edge ? 70 : 40;\n        display.setPixel(x, y, v * 0.85, v * 0.78, v);\n        continue;\n      }\n      if (p) {\n        // A seam where two ribbons or two faces meet.\n        const rp = x \u003c W - 1 ? id[q + 1] : p, dp = y \u003c H - 1 ? id[q + W] : p;\n        const k = (rp && rp !== p) || (dp && dp !== p) ? 150 : 255;\n        display.setPixel(x, y, min(255, col[o] * k), min(255, col[o + 1] * k), min(255, col[o + 2] * k));\n        continue;\n      }\n      // The dial behind the cube: one colour fills it in the first turn,\n      // the other in the second.\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      const ring = cl(1.6 - abs(r - ROUT - 0.6), 0, 1);\n      if (ring > 0) {\n        let a = atan2(dx, -dy) / TAU;\n        if (a \u003c 0) a += 1;\n        const c = a \u003c prog ? cur : old, m = a \u003c prog ? 1 : 0.4;\n        const tip = abs(a - prog) \u003c 0.012 || abs(a - prog) > 0.988 ? 1.6 : 1;\n        display.setPixel(x, y, c[0] * 255 * ring * m * tip, c[1] * 255 * ring * m * tip, c[2] * 255 * ring * m * tip);\n      } else display.setPixel(x, y, 4, 3, 10);\n    }\n}\n","catenoid-helicoid":"// ===== Patternflow pattern =====\n// Title:   Catenoid-Helicoid\n// Family:  space\n// Idea:    A helicoid stands up the panel and turns about its axis while it unwinds into a catenoid and winds up again the other way, a checkerboard painted on it in (u, v) keeping every square the same size and shape the whole time, because the bending stretches nothing.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the catenoid (Leonhard Euler, 1744) bent into the helicoid (Jean Baptiste Meusnier, 1776) without stretching (Edmond Bour, 1862), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Squares=12..36, Tilt=0..1\n//\n// Knob 1: Hue. Turns both faces round the wheel together: at 0 the face that becomes the catenoid's inside is cyan and the other violet, and the dark squares of each sink toward indigo. The line v = 0 stays warm white.\n// Knob 2: Speed. At 2 the surface takes 4 seconds to bend from the helicoid to the catenoid, lingering a little at each end, and turns once about its axis in 20 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Squares. How many checker squares go once round in u: 12 where it opens, where a square is about 9 LEDs on the line v = 0 and 16 at the free edge, and 36 at the top. The count is always even, so the checker closes up across the catenoid's seam.\n// Knob 4: Tilt. How far we look down on the surface: 12 degrees at 0, 15 where it opens, 60 at 1, and the view nods 24 degrees further down as the catenoid forms so we see into its mouth. The scale is set once per tilt from the tallest moment of the bending. It never zooms while the surface bends, so the squares keep their size on the panel too.\n// Buttons: K1 tap holds the bending where it is while the surface keeps turning; tap again to let it go on.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, round, sqrt, sin, cos, abs, pow, sinh, cosh, tanh, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The surface, for the bending angle th:\n//   x =  cos th sinh v sin u + sin th cosh v cos u\n//   y = -cos th sinh v cos u + sin th cosh v sin u\n//   z =  u cos th + v sin th\n// th = 0 is the helicoid, th = pi/2 the catenoid. Its first fundamental\n// form is cosh^2 v (du^2 + dv^2) for every th, so a square in (u, v)\n// stays a square, and its normal (cos u / cosh v, sin u / cosh v, -tanh v)\n// does not depend on th either.\nconst U = PI, V = 1.15;\nconst NU = 96, NV = 30, VU = NU + 1, VV = NV + 1, NPT = VU * VV;\nconst CAM = 12, CX = 31.5, CY = 63.5;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  const s = {\n    t: 0, b: 0, phi: 0.35, hold: false, hue: 0, squares: 12, tilt: 0.06, scaleTilt: -1, S: 18,\n    gu: F(NPT), gv: F(NPT), su: F(NPT), cu: F(NPT), sh: F(NPT), ch: F(NPT),\n    sx: F(NPT), sy: F(NPT), sd: F(NPT),\n    zb: F(N), pu: F(N), pv: F(N), side: new Int8Array(N), col: F(N * 3),\n    pal: F(12), palHue: -1,\n  };\n  for (let j = 0; j \u003c VV; j++)\n    for (let i = 0; i \u003c VU; i++) {\n      const k = j * VU + i, u = -U + (2 * U * i) / NU, v = -V + (2 * V * j) / NV;\n      s.gu[k] = u;\n      s.gv[k] = v;\n      s.su[k] = sin(u);\n      s.cu[k] = cos(u);\n      s.sh[k] = sinh(v);\n      s.ch[k] = cosh(v);\n    }\n  params.s = s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 12, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.squares = 2 * round(cl(k[2], 12, 36) / 2);\n  s.tilt = cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) s.hold = !s.hold;\n  s.t += d * sp;\n  s.phi += d * sp * 0.157;\n  if (!s.hold) s.b += d * sp * 0.125;\n}\n\n// The bending angle: a quarter turn of th per unit of b, slowed near the\n// helicoid and the catenoid so each end holds for a moment.\nfunction bend(b) {\n  const n = floor(b), f = b - n;\n  return (PI / 2) * (n + f - (0.7 * sin(TAU * f)) / TAU);\n}\n\n// The camera nods down as the catenoid forms, so we look into its mouth.\nconst look = (e0, st) => min(1.25, e0 + 0.42 * st * st);\n\n// One scale per tilt: the largest the surface ever gets on the panel over\n// the whole bending and every turn, so the picture never zooms.\nfunction fit(s, e0) {\n  let mu = 0, mx = 0;\n  for (let a = 0; a \u003c= 24; a++) {\n    const th = (PI / 2) * (a / 24), ct = cos(th), st = sin(th), e = look(e0, st), ce = cos(e), se = sin(e);\n    for (let r = 0; r \u003c 16; r++) {\n      const ph = (TAU * r) / 16, cp = cos(ph), spn = sin(ph);\n      for (let q = 0; q \u003c 48; q++) {\n        let u, v;\n        if (q \u003c 16) (u = q \u003c 8 ? -U : U), (v = -V + (2 * V * (q % 8)) / 7);\n        else (u = -U + (2 * U * (q - 16)) / 31), (v = q & 1 ? V : -V);\n        const x = ct * sinh(v) * sin(u) + st * cosh(v) * cos(u), y = -ct * sinh(v) * cos(u) + st * cosh(v) * sin(u), z = u * ct + v * st;\n        const xr = x * cp - y * spn, yr = x * spn + y * cp;\n        const dep = yr * ce - z * se, up = yr * se + z * ce, f = CAM / (CAM + dep);\n        mu = max(mu, abs(up * f));\n        mx = max(mx, abs(xr * f));\n      }\n    }\n  }\n  s.S = min(65 / mu, 33.5 / mx);\n  s.scaleTilt = s.tilt;\n}\n\nfunction palette(s) {\n  // Light and dark squares of the outer face, then of the inner face.\n  // A dark square is its light square at 0.4 over an indigo floor, so a\n  // warm face darkens toward plum rather than brown or olive.\n  hsv(s.hue + 0.52, 0.5, 1, s.pal, 0);\n  hsv(s.hue + 0.8, 0.45, 1, s.pal, 6);\n  for (const o of [0, 6]) {\n    s.pal[o + 3] = 0.4 * s.pal[o] + 0.1;\n    s.pal[o + 4] = 0.4 * s.pal[o + 1] + 0.03;\n    s.pal[o + 5] = 0.4 * s.pal[o + 2] + 0.28;\n  }\n  s.palHue = s.hue;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  if (s.palHue !== s.hue) palette(s);\n  const e0 = ((12 + 48 * s.tilt) * PI) / 180;\n  if (s.scaleTilt !== s.tilt) fit(s, e0);\n  const th = bend(s.b), ct = cos(th), st = sin(th), cp = cos(s.phi), spn = sin(s.phi), S = s.S;\n  const e = look(e0, st), ce = cos(e), se = sin(e);\n  const { gu, gv, su, cu, sh, ch, sx, sy, sd, zb, pu, pv, side, col, pal } = s;\n  for (let k = 0; k \u003c NPT; k++) {\n    const x = ct * sh[k] * su[k] + st * ch[k] * cu[k], y = -ct * sh[k] * cu[k] + st * ch[k] * su[k], z = gu[k] * ct + gv[k] * st;\n    const xr = x * cp - y * spn, yr = x * spn + y * cp;\n    const dep = yr * ce - z * se, up = yr * se + z * ce, f = (S * CAM) / (CAM + dep);\n    sx[k] = CX + f * xr;\n    sy[k] = CY - f * up;\n    sd[k] = dep;\n  }\n  zb.fill(1e9);\n  side.fill(0);\n  for (let j = 0; j \u003c NV; j++)\n    for (let i = 0; i \u003c NU; i++) {\n      const a = j * VU + i;\n      tri(s, a, a + 1, a + VU + 1);\n      tri(s, a, a + VU + 1, a + VU);\n    }\n  const n = s.squares, dl = TAU / n;\n  // Light from the upper left, in front: (screen x, depth, screen up).\n  const LX = -0.45, LD = -0.62, LU = 0.64, HD = LD - 1, HL = 1 / sqrt(LX * LX + LU * LU + HD * HD);\n  const lw = 0.62 / S;\n  for (let q = 0; q \u003c N; q++) {\n    const o = q * 3, sd0 = side[q];\n    if (!sd0) {\n      col[o] = col[o + 1] = col[o + 2] = 0;\n      continue;\n    }\n    const u = pu[q], v = pv[q], cv = cosh(v);\n    // The normal, the same for every th, turned with the surface.\n    const nx = cos(u) / cv, ny = sin(u) / cv, nz = -tanh(v);\n    let mx = nx * cp - ny * spn;\n    const nyr = nx * spn + ny * cp;\n    let md = nyr * ce - nz * se, mu = nyr * se + nz * ce;\n    if (md > 0) (mx = -mx), (md = -md), (mu = -mu);\n    const ld = max(0, mx * LX + md * LD + mu * LU), hh = max(0, (mx * LX + md * HD + mu * LU) * HL);\n    // Light falls off toward an indigo shade rather than toward black.\n    const spc = pow(hh, 24) * 0.45, lit = 0.2 + 0.8 * ld, sh0 = (1 - ld) * 0.16;\n    const par = (floor((u + U) / dl) + floor(v / dl)) & 1, c = (sd0 > 0 ? 0 : 6) + par * 3;\n    let r = pal[c] * lit + 0.3 * sh0 + spc, g = pal[c + 1] * lit + 0.1 * sh0 + spc, b = pal[c + 2] * lit + sh0 + spc;\n    // The line v = 0: the helicoid's axis and the catenoid's waist, the\n    // same length 2 pi all the way through the bending.\n    if (abs(v) \u003c lw) (r = 1 * (0.45 + 0.55 * lit)), (g = 0.86 * (0.45 + 0.55 * lit)), (b = 0.62 * (0.45 + 0.55 * lit));\n    col[o] = r;\n    col[o + 1] = g;\n    col[o + 2] = b;\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3;\n      if (side[q]) {\n        // Where one sheet passes in front of another, or the ribbon turns\n        // over at a fold, a darker LED keeps the two apart.\n        let k = 255;\n        const rq = x \u003c W - 1 ? q + 1 : q, dq = y \u003c H - 1 ? q + W : q;\n        if ((side[rq] && (side[rq] !== side[q] || abs(zb[rq] - zb[q]) > 0.4)) || (side[dq] && (side[dq] !== side[q] || abs(zb[dq] - zb[q]) > 0.4))) k = 120;\n        display.setPixel(x, y, min(255, col[o] * k), min(255, col[o + 1] * k), min(255, col[o + 2] * k));\n        continue;\n      }\n      // An empty LED on the outline takes a little of its lit neighbours.\n      let r = 0, g = 0, b = 0;\n      if (x > 0 && side[q - 1]) (r += col[o - 3]), (g += col[o - 2]), (b += col[o - 1]);\n      if (x \u003c W - 1 && side[q + 1]) (r += col[o + 3]), (g += col[o + 4]), (b += col[o + 5]);\n      if (y > 0 && side[q - W]) (r += col[o - W * 3]), (g += col[o - W * 3 + 1]), (b += col[o - W * 3 + 2]);\n      if (y \u003c H - 1 && side[q + W]) (r += col[o + W * 3]), (g += col[o + W * 3 + 1]), (b += col[o + W * 3 + 2]);\n      display.setPixel(x, y, r * 22, g * 22, b * 22);\n    }\n}\n\n// One triangle of the (u, v) grid into the depth buffer. Its winding on\n// the screen says which face of the surface we see there.\nfunction tri(s, i0, i1, i2) {\n  const { sx, sy, sd, gu, gv, zb, pu, pv, side } = s;\n  const x0 = sx[i0], y0 = sy[i0], x1 = sx[i1], y1 = sy[i1], x2 = sx[i2], y2 = sy[i2];\n  const den = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(den) \u003c 1e-9) return;\n  const inv = 1 / den, sg = den > 0 ? 1 : -1;\n  const X0 = max(0, Math.ceil(min(x0, x1, x2) - 0.5)), X1 = min(W - 1, floor(max(x0, x1, x2) - 0.5));\n  const Y0 = max(0, Math.ceil(min(y0, y1, y2) - 0.5)), Y1 = min(H - 1, floor(max(y0, y1, y2) - 0.5));\n  if (X0 > X1 || Y0 > Y1) return;\n  const z0 = sd[i0], dz1 = sd[i1] - z0, dz2 = sd[i2] - z0;\n  const u0 = gu[i0], du1 = gu[i1] - u0, du2 = gu[i2] - u0, v0 = gv[i0], dv1 = gv[i1] - v0, dv2 = gv[i2] - v0;\n  for (let y = Y0; y \u003c= Y1; y++) {\n    const cy = y + 0.5 - y0;\n    for (let x = X0; x \u003c= X1; x++) {\n      const cx = x + 0.5 - x0;\n      const a = (cx * (y2 - y0) - cy * (x2 - x0)) * inv, b = ((x1 - x0) * cy - (y1 - y0) * cx) * inv;\n      if (a \u003c -1e-6 || b \u003c -1e-6 || a + b > 1 + 1e-6) continue;\n      const dd = z0 + dz1 * a + dz2 * b, q = y * W + x;\n      if (dd \u003c zb[q]) (zb[q] = dd), (pu[q] = u0 + du1 * a + du2 * b), (pv[q] = v0 + dv1 * a + dv2 * b), (side[q] = sg);\n    }\n  }\n}\n","costas-array":"// ===== Patternflow pattern =====\n// Title:   Costas Array\n// Family:  rhythm\n// Idea:    A Costas array plays as a frequency-hopping rhythm in the top half while a ghost copy of it spirals out through the shifts in time and pitch, flashing where it lands on a dot, and the bottom half fills in one cell per shift with how many dots met: noughts and ones all the way out, and one spike of N at the centre.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Costas arrays (John P. Costas, 1965, published 1984), with the Welch and Lempel-Golomb constructions (Solomon W. Golomb, 1984), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Field=0..8, Rival=0..3\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the array's dots are sea green, the ghost copy rose, a single meeting in the map green and a crowd of them rose fading to white.\n// Knob 2: Speed. At 2 the playhead strikes 5.5 columns a second at order 10 and 10.5 at order 30. The ghost takes 1.2 (2N - 1) steps a second and stays one step on an empty shift, four on a meeting and up to seven on a crowd, so the order 10 map is full in 15 seconds and the order 30 map in 43. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Field. The finite field the arrays are built over, one of 11, 13, 16, 17, 19, 23, 29, 31 and 32 elements. A prime p gives Welch arrays of order p - 1 and Lempel-Golomb arrays of order p - 2; 16 and 32 give Lempel-Golomb arrays of order 14 and 30. The field of 11 opens on the Welch array of 2^i mod 11.\n// Knob 4: Rival. Swaps the array for a permutation that is not a Costas array and keeps the scan where it is. 0 is the Costas array and 1 a shuffle of the same order, whose map picks up a few twos and threes. 2 is the folded chirp i -> a*i mod N, a lattice of tall counts, and 3 the plain diagonal, one ridge that climbs to N - 1 beside the spike.\n// Buttons: K1 tap moves on to the next array of the field: the next construction, primitive root and one of the eight symmetries of the square. The pattern also moves on by itself a few seconds after a map is full.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst FIELDS = [11, 13, 16, 17, 19, 23, 29, 31, 32];\n// Hue of the array's dots at knob 0, and the ghost's hue past it.\nconst HUE0 = 0.42, GHOST = 0.5;\n// Seconds the full map stays before the next array, and the extra time the\n// ghost sits on the original at the start of a scan, both at Speed 2.\nconst HOLD = 5, REST = 0.9;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\n\n// GF(q) for a prime q or q = 16, 32. The elements are 0..q-1; exp and log\n// are taken to a generator g0, and the primitive elements are g0^e with e\n// prime to q - 1, sorted by value so the field of 11 starts with 2.\nfunction field(q) {\n  const two = (q & (q - 1)) === 0, poly = q === 16 ? 0x13 : 0x25;\n  const ex = new Int32Array(q - 1), lg = new Int32Array(q);\n  let g0 = 2;\n  for (;;) {\n    let v = 1, ok = true;\n    for (let i = 0; i \u003c q - 1; i++) {\n      ex[i] = v;\n      if (i > 0 && v === 1) { ok = false; break; }\n      if (two) { v \u003c\u003c= 1; if (v & q) v ^= poly; } else v = (v * g0) % q;\n    }\n    if (ok && v === 1) break;\n    g0++;\n  }\n  for (let i = 0; i \u003c q - 1; i++) lg[ex[i]] = i;\n  const prim = [];\n  for (let e = 1; e \u003c q - 1; e++) if (gcd(e, q - 1) === 1) prim.push(ex[e]);\n  prim.sort((a, b) => a - b);\n  // 1 - a: a subtraction mod q, or in characteristic 2 an XOR.\n  const oneMinus = (a) => (two ? 1 ^ a : (1 - a + q) % q);\n  return { q, two, ex, lg, prim, oneMinus };\n}\n\n// Welch: column i, row g^(i + c) mod p minus 1, order p - 1.\nfunction welch(F, g, c) {\n  const n = F.q - 1, e = F.lg[g], f = new Int32Array(n);\n  for (let i = 0; i \u003c n; i++) f[i] = F.ex[(e * (i + c)) % n] - 1;\n  return f;\n}\n\n// Lempel-Golomb: a dot at (i, j), 1 \u003c= i, j \u003c= q - 2, where a^i + b^j = 1.\n// a = b is Lempel's symmetric array.\nfunction lempelGolomb(F, a, b) {\n  const n = F.q - 2, m = F.q - 1, ea = F.lg[a], eb = F.lg[b], f = new Int32Array(n);\n  let inv = 1;\n  while ((eb * inv) % m !== 1) inv++;\n  for (let i = 1; i \u003c= n; i++) {\n    const v = F.oneMinus(F.ex[(ea * i) % m]);\n    f[i - 1] = ((F.lg[v] * inv) % m) - 1;\n  }\n  return f;\n}\n\n// The eight symmetries of the square: bit 0 transposes (the inverse\n// permutation), bit 1 mirrors the columns, bit 2 the rows.\nfunction symmetry(f, k) {\n  const n = f.length;\n  let g = Int32Array.from(f);\n  if (k & 1) for (let i = 0; i \u003c n; i++) g[f[i]] = i;\n  if (k & 2) g = g.map((_, i, a) => a[n - 1 - i]);\n  if (k & 4) g = g.map((v) => n - 1 - v);\n  return g;\n}\n\n// Array number k of a field: Welch and Lempel-Golomb in turn for a prime,\n// Lempel-Golomb alone for 16 and 32, the roots and symmetry moving on.\nfunction costas(F, k) {\n  const P = F.prim, R = P.length, h = floor(k / 2), sym = (3 * k) % 8;\n  let f;\n  if (F.two) f = lempelGolomb(F, P[k % R], P[(2 * k) % R]);\n  else if (k % 2 === 0) f = welch(F, P[h % R], (3 * h) % (F.q - 1));\n  else f = lempelGolomb(F, P[h % R], P[(2 * h) % R]);\n  return symmetry(f, sym);\n}\n\n// The coincidence count of every shift: C[dx, dy] is how many dots of the\n// copy shifted by (dx, dy) land on a dot. Index (N-1-dy)*M + dx+N-1.\nfunction counts(f) {\n  const n = f.length, M = 2 * n - 1, C = new Int16Array(M * M);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) C[(n - 1 - (f[j] - f[i])) * M + j - i + n - 1]++;\n  return C;\n}\n\n// A small seeded generator, so a shuffled rival is the same each time.\nfunction shuffle(n, seed) {\n  let a = seed >>> 0;\n  const rnd = () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = Math.imul(a ^ (a >>> 15), a | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n  for (;;) {\n    const f = Int32Array.from({ length: n }, (_, i) => i);\n    for (let i = n - 1; i > 0; i--) {\n      const j = floor(rnd() * (i + 1)), t = f[i];\n      f[i] = f[j];\n      f[j] = t;\n    }\n    // A shuffle that came out a Costas array by chance is drawn again.\n    const C = counts(f), M = 2 * n - 1, mid = (n - 1) * M + n - 1;\n    let worst = 0;\n    for (let d = 0; d \u003c C.length; d++) if (d !== mid) worst = max(worst, C[d]);\n    if (worst > 1) return f;\n  }\n}\n\nfunction rival(f, kind, seed) {\n  const n = f.length;\n  if (kind === 1) return shuffle(n, seed);\n  if (kind === 2) {\n    let a = max(2, round(n * 0.3));\n    while (gcd(a, n) !== 1) a++;\n    return Int32Array.from({ length: n }, (_, i) => (a * i) % n);\n  }\n  if (kind === 3) return Int32Array.from({ length: n }, (_, i) => i);\n  return f;\n}\n\n// The scan. A shift and its opposite meet the same dots, the copy's dot\n// and the array's dot trading places, so the ghost visits half of each\n// square ring round (0, 0), the right side and the top, and the opposite\n// cell of the map fills in with it. Odd rings go up the right side and left\n// along the top, even rings back the other way, so each step is to a\n// neighbouring shift.\nfunction spiral(n) {\n  const M = 2 * n - 1, L = (M * M + 1) / 2, sx = new Int8Array(L), sy = new Int8Array(L);\n  let m = 1;\n  const put = (x, y) => ((sx[m] = x), (sy[m++] = y));\n  for (let k = 1; k \u003c n; k++) {\n    if (k & 1) {\n      for (let y = -k + 1; y \u003c= k; y++) put(k, y);\n      for (let x = k - 1; x >= -k; x--) put(x, k);\n    } else {\n      for (let x = -k; x \u003c k; x++) put(x, k);\n      for (let y = k; y > -k; y--) put(k, y);\n    }\n  }\n  const ord = new Int32Array(M * M);\n  for (let i = 0; i \u003c L; i++) {\n    ord[(n - 1 - sy[i]) * M + sx[i] + n - 1] = i;\n    ord[(n - 1 + sy[i]) * M - sx[i] + n - 1] = i;\n  }\n  return { sx, sy, ord, L };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, sp: 2, fi: -1, kind: -1, k: 0, F: null,\n    base: null, f: null, n: 0, C: null, scan: null,\n    m: 0, w: 0, dur: 1, step: 1, clk: 0, rev: null, ph: 0, col: -1,\n    hit: null, str: null,\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(30), palHue: -1,\n  };\n}\n\nfunction build(s, fresh) {\n  const n = s.base.length;\n  s.f = rival(s.base, s.kind, s.F.q * 977 + s.k * 131 + 7);\n  s.C = counts(s.f);\n  if (!fresh && s.n === n) return;\n  s.n = n;\n  s.scan = spiral(n);\n  s.step = 1 / (1.2 * (2 * n - 1));\n  s.rev = new Float32Array((2 * n - 1) ** 2);\n  s.m = 0;\n  s.w = 0;\n  s.ph = 0;\n  s.col = -1;\n  s.hit = new Float32Array(n).fill(9);\n  s.str = new Float32Array(n).fill(9);\n  arrive(s, 0);\n}\n\nfunction next(s, k) {\n  s.k = k;\n  s.base = costas(s.F, k);\n  build(s, true);\n}\n\n// The ghost has landed on shift number m: every dot it covers flashes,\n// and it stays one step for nothing and four for a meeting, up to seven for\n// three or more, so the meetings are the scan's own rhythm.\nfunction arrive(s, m) {\n  const { f, n } = s, dx = s.scan.sx[m], dy = s.scan.sy[m];\n  let met = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const j = i + dx;\n    if (j >= 0 && j \u003c n && f[j] === f[i] + dy) (s.hit[j] = 0), met++;\n  }\n  s.rev[(n - 1 - dy) * (2 * n - 1) + dx + n - 1] = s.rev[(n - 1 + dy) * (2 * n - 1) - dx + n - 1] = s.clk;\n  s.dur = m ? s.step * (1 + 3 * min(met, 1) + max(0, min(met, 3) - 1) * 1.5) : REST + 4 * s.step;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.sp = cl(kv[1], 0.2, 3);\n  const fi = round(cl(kv[2], 0, 8)), kind = round(cl(kv[3], 0, 3));\n  if (fi !== s.fi) {\n    s.fi = fi;\n    s.F = field(FIELDS[fi]);\n    s.kind = kind;\n    next(s, 0);\n  } else if (kind !== s.kind) {\n    s.kind = kind;\n    build(s, false);\n  }\n  if (input.btnPressed && input.btnPressed[0]) next(s, s.k + 1);\n  const r = d * (s.sp / 2), n = s.n, total = s.scan.L;\n  for (let i = 0; i \u003c n; i++) (s.hit[i] += r), (s.str[i] += r);\n  s.clk += r;\n  s.w += r;\n  while (s.m \u003c total - 1 && s.w >= s.dur) (s.w -= s.dur), arrive(s, ++s.m);\n  if (s.m === total - 1 && s.w >= HOLD) return next(s, s.k + 1);\n  // The playhead: 5.5 columns a second at order 10, faster for the big\n  // orders so a bar stays under three seconds.\n  s.ph += r * (3 + n / 4);\n  const c = floor(s.ph) % n;\n  if (c !== s.col) (s.col = c), (s.str[c] = 0);\n}\n\nfunction palette(s) {\n  const P = s.pal, h = HUE0 + s.hue;\n  hsv(h, 0.85, 0.85, P, 0); // dot\n  hsv(h, 0.35, 1, P, 3); // struck dot\n  hsv(h, 0.7, 0.55, P, 6); // ring\n  hsv(h + GHOST, 0.75, 0.6, P, 9); // ghost\n  hsv(h, 0.8, 0.15, P, 12); // playhead band\n  hsv(h + 0.12, 0.9, 0.22, P, 15); // a nought in the map\n  hsv(h - 0.05, 0.7, 0.8, P, 18); // a one\n  hsv(h + GHOST, 0.8, 0.85, P, 21); // two or more\n  hsv(h + 0.1, 0.8, 0.1, P, 24); // lattice\n  hsv(h + GHOST, 0.4, 0.75, P, 27); // flash halo\n  s.palHue = s.hue;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.f) return;\n  if (s.palHue !== s.hue) palette(s);\n  const { buf: B, pal: P, f, n, C } = s;\n  B.fill(0);\n  const add = (x, y, o, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    B[p] += P[o] * a;\n    B[p + 1] += P[o + 1] * a;\n    B[p + 2] += P[o + 2] * a;\n  };\n  const white = (x, y, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    B[p] += a;\n    B[p + 1] += a;\n    B[p + 2] += a;\n  };\n\n  // Top: the array, column i is time step i, row f(i) the frequency, low\n  // frequencies at the bottom.\n  const c = floor(64 / n), d = c >= 5 ? c - 2 : c >= 3 ? c - 1 : c, e = (c - d) >> 1;\n  const ox = (W - c * n) >> 1, oy = (64 - c * n) >> 1, side = c * n;\n  const X = (i) => ox + i * c + e, Y = (r) => oy + (n - 1 - r) * c + e;\n  const block = (x0, y0, sz, fn) => {\n    for (let y = y0; y \u003c y0 + sz; y++) for (let x = x0; x \u003c x0 + sz; x++) fn(x, y);\n  };\n  if (c >= 4) for (let i = 0; i \u003c n; i++) for (let r = 0; r \u003c n; r++) add(X(i) + (d >> 1), Y(r) + (d >> 1), 24, 1);\n  // The playhead's column and the row of the note it is playing.\n  if (s.col >= 0) {\n    const yr = Y(f[s.col]) - e;\n    for (let y = oy; y \u003c oy + side; y++) for (let x = ox + s.col * c; x \u003c ox + s.col * c + c; x++) add(x, y, 12, 1);\n    for (let y = yr; y \u003c yr + c; y++) for (let x = ox; x \u003c ox + side; x++) add(x, y, 12, 1);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const a = s.str[i], x0 = X(i), y0 = Y(f[i]);\n    const k = a \u003c 0.6 ? exp(-a * 5) : 0;\n    block(x0, y0, d, (x, y) => (add(x, y, 0, 1 - k), add(x, y, 3, k)));\n    // A struck note rings out as a widening square.\n    if (a \u003c 0.45) {\n      const rr = (d >> 1) + 1 + floor(a * 14), cx = x0 + (d >> 1), cy = y0 + (d >> 1), al = (1 - a / 0.45) ** 2;\n      for (let t = -rr; t \u003c= rr; t++) {\n        for (const [x, y] of [[cx + t, cy - rr], [cx + t, cy + rr], [cx - rr, cy + t], [cx + rr, cy + t]])\n          if (x >= ox && x \u003c ox + side && y >= oy && y \u003c oy + side) add(x, y, 6, al);\n      }\n    }\n  }\n  // The ghost copy glides from shift m to shift m + 1.\n  const { sx, sy, ord, L: total } = s.scan, m = s.m;\n  // It rests, then glides in the last 0.8 of a plain step.\n  const g = m \u003c total - 1 ? cl((s.w - s.dur) / (0.8 * s.step) + 1, 0, 1) : 0, gg = g * g * (3 - 2 * g);\n  const mn = min(m + 1, total - 1), gdx = sx[m] + (sx[mn] - sx[m]) * gg, gdy = sy[m] + (sy[mn] - sy[m]) * gg;\n  const hollow = d >= 3;\n  // The sheet the ghost is printed on: faint where it overlaps the array,\n  // brighter along its edge.\n  const gx0 = ox + round(gdx * c), gy0 = oy - round(gdy * c);\n  for (let y = max(oy, gy0); y \u003c min(oy + side, gy0 + side); y++)\n    for (let x = max(ox, gx0); x \u003c min(ox + side, gx0 + side); x++) {\n      const edge = x === gx0 || x === gx0 + side - 1 || y === gy0 || y === gy0 + side - 1;\n      add(x, y, 9, edge ? 0.45 : 0.1);\n    }\n  for (let i = 0; i \u003c n; i++) {\n    const x0 = round(X(i) + gdx * c), y0 = round(Y(f[i]) - gdy * c);\n    block(x0, y0, d, (x, y) => {\n      if (x \u003c ox || x >= ox + side || y \u003c oy || y >= oy + side) return;\n      if (hollow && x > x0 && x \u003c x0 + d - 1 && y > y0 && y \u003c y0 + d - 1) return;\n      add(x, y, 9, hollow ? 1 : 0.7);\n    });\n  }\n  // Where the ghost met a dot.\n  for (let j = 0; j \u003c n; j++) {\n    const a = s.hit[j];\n    if (a > 0.5) continue;\n    const k = 1 - a / 0.5, x0 = X(j), y0 = Y(f[j]);\n    block(x0 - 1, y0 - 1, d + 2, (x, y) => {\n      const edge = x \u003c x0 || y \u003c y0 || x >= x0 + d || y >= y0 + d;\n      if (edge) add(x, y, 27, k);\n      else white(x, y, k * 0.8), add(x, y, 27, k * 0.6);\n    });\n  }\n\n  // Bottom: one cell per shift, dx across and dy up, filled as the scan\n  // reaches it.\n  const M = 2 * n - 1, sc = floor(64 / M), sd = sc >= 3 ? sc - 1 : 1;\n  const mx = (W - sc * M) >> 1, my = 64 + ((64 - sc * M) >> 1), mid = (n - 1) * M + n - 1;\n  const cur = (n - 1 - sy[m]) * M + sx[m] + n - 1;\n  for (let gy = 0; gy \u003c M; gy++)\n    for (let gx = 0; gx \u003c M; gx++) {\n      const q = gy * M + gx, o = ord[q], x0 = mx + gx * sc, y0 = my + gy * sc;\n      if (o > m) {\n        if (sc >= 2) add(x0, y0, 24, sc >= 3 ? 1.6 : 0.9);\n        continue;\n      }\n      const v = C[q], age = s.clk - s.rev[q];\n      const flash = age \u003c 0.35 ? (1 - age / 0.35) * 0.7 : 0;\n      block(x0, y0, sd, (x, y) => {\n        if (q === mid) return white(x, y, 1);\n        if (v === 0) add(x, y, 15, 1);\n        else if (v === 1) add(x, y, 18, 1);\n        else {\n          // Two or more: the ghost hue, whitening toward N - 1.\n          const t = (v - 2) / max(1, n - 3);\n          add(x, y, 21, 1 - 0.6 * t);\n          white(x, y, 0.6 * t);\n        }\n        if (flash) white(x, y, flash);\n      });\n    }\n  // The spike of N fills the gaps round its cell, and the scan has a cursor.\n  if (sc >= 3) {\n    const x0 = mx + (n - 1) * sc, y0 = my + (n - 1) * sc;\n    for (let t = -1; t \u003c= sd; t++) white(x0 + t, y0 - 1, 0.8), white(x0 + t, y0 + sd, 0.8), white(x0 - 1, y0 + t, 0.8), white(x0 + sd, y0 + t, 0.8);\n  }\n  // The opposite shift gets a fainter cursor of its own.\n  if (m \u003c total - 1)\n    for (const [q, a] of [[cur, 1], [M * M - 1 - cur, 0.45]]) {\n      const x0 = mx + (q % M) * sc, y0 = my + floor(q / M) * sc;\n      if (sd >= 2) for (let t = -1; t \u003c= sd; t++) white(x0 + t, y0 - 1, 0.55 * a), white(x0 + t, y0 + sd, 0.55 * a), white(x0 - 1, y0 + t, 0.55 * a), white(x0 + sd, y0 + t, 0.55 * a);\n      else white(x0, y0, 0.8 * a), white(x0 - 1, y0, 0.35 * a), white(x0 + 1, y0, 0.35 * a), white(x0, y0 - 1, 0.35 * a), white(x0, y0 + 1, 0.35 * a);\n    }\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, min(255, round(B[p] * 255)), min(255, round(B[p + 1] * 255)), min(255, round(B[p + 2] * 255)));\n}\n","elastica":"// ===== Patternflow pattern =====\n// Title:   Euler's Elastica\n// Family:  physics\n// Idea:    A thin elastic rod 120 LEDs long, pinned at both ends on its line of thrust, is slowly pushed and let go and sweeps Euler's family of bent shapes from the first slight bow through the arch and the drop where its ends meet to the loops where they pass each other, while a bead runs along it, a pendulum above swings with its arm always parallel to the rod at the bead, and the pendulum's orbit goes round its phase portrait below.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler's elastica (Leonhard Euler, 1744), after Jacob Bernoulli's elastic curve (1694), with Kirchhoff's kinetic analogy to the pendulum (Gustav Kirchhoff, 1859), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mode=1..4, Preload=0..1\n//\n// Knob 1: Hue. The rod is coloured by the direction it points, and the same colours mark the pendulum's swing and the orbit below. At 0 a straight rod is cyan, leaning one way it turns green and the other way violet; the knob turns all of it round the wheel, hurrying past orange and yellow.\n// Knob 2: Speed. At 2 one push and release takes 16 seconds and the bead runs the rod in 2.4; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Mode. How many half waves the rod buckles into, 1 to 4. At the same end slope mode n carries n squared times the load of mode 1, and its rod is n copies of the mode 1 shape at 1/n the size, each the mirror of the one before.\n// Knob 4: Preload. How far each release goes back. At 0 the rod comes back straight and buckles again to a side picked by chance; at 0.5 it never unbends past an end slope of 38 degrees, and at 1 it stays among the loops, 150 to 176 degrees.\n// Buttons: K1 tap holds the load where it is, so one shape stands still while the bead and the pendulum keep going; a second tap lets the load move again.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, ceil, round, abs, sqrt, sin, cos, asin, exp, PI } = Math;\nconst DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The rod is 120 LEDs long and drawn from 241 points half an LED apart.\nconst L = 120, M = 240;\n// The largest end slope, one push and release at Speed 2 in seconds, and the\n// bead's speed at Speed 2 in LEDs a second.\nconst AMAX = 176 * DEG, CYCLE = 16, BEAD = 50;\n// The rod's radius in each mode: thinner for the smaller loops of modes 3 and 4.\nconst RAD = [0, 2.7, 2.6, 2.2, 1.9];\n// The pendulum's pivot and arm, and the phase portrait's middle row, half\n// height and half width.\nconst PX = 31.5, PY = 20.5, PL = 16.5;\nconst PIN = [0.82, 0.82, 0.86];\nconst QY = 108.5, QH = 16, QW = 29.5;\n// Light from the upper left and in front, and the half vector for the shine.\nconst LX = -0.42, LY = -0.5, LZ = 0.757;\nconst HX = -0.229, HY = -0.272, HZ = 0.935;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The arithmetic-geometric mean of 1 and k' gives K(k), E(k) and the a_n, c_n\n// the Jacobi functions are built from (Abramowitz and Stegun 17.6).\nfunction agm(k, g) {\n  const a = g.a, c = g.c;\n  let b = sqrt(1 - k * k), n = 0, sum = 0.5 * k * k;\n  a[0] = 1;\n  c[0] = k;\n  while (n \u003c 15 && c[n] > 1e-15) {\n    const an = a[n];\n    a[n + 1] = (an + b) / 2;\n    c[n + 1] = (an - b) / 2;\n    b = sqrt(an * b);\n    n++;\n    sum += 2 ** (n - 1) * c[n] * c[n];\n  }\n  g.n = n;\n  g.K = PI / (2 * a[n]);\n  g.E = g.K * (1 - sum);\n}\n\n// sn u, cn u and Jacobi's epsilon E(u) = Z(u) + u E/K, by the descending\n// Landen sequence of amplitudes; Z(u) is the sum of c_n sin(phi_n).\nfunction jac(u, g, o) {\n  const { a, c, n, ph } = g;\n  ph[n] = 2 ** n * a[n] * u;\n  let z = 0;\n  for (let i = n; i >= 1; i--) {\n    z += c[i] * sin(ph[i]);\n    ph[i - 1] = (asin((c[i] / a[i]) * sin(ph[i])) + ph[i]) / 2;\n  }\n  o.sn = sin(ph[0]);\n  o.cn = cos(ph[0]);\n  o.e = z + (g.E / g.K) * u;\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  params.s = {\n    hue: 0, mode: 1, alo: 0, al: 0, ph: 0.07, side: 1, hold: false,\n    sb: 0, dir: 1,\n    g: { a: new Float64Array(17), c: new Float64Array(17), ph: new Float64Array(17), n: 0, K: PI / 2, E: PI / 2 },\n    j: { sn: 0, cn: 1, e: 0 },\n    cx: F(M + 1), cy: F(M + 1), sg: F(M + 1),\n    buf: F(N * 3), zs: F(N), zd: F(N), zo: F(N), col: F(3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  const btn = input.btnPressed || [];\n  S.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  S.mode = cl(round(k[2]), 1, 4);\n  const pre = cl(k[3], 0, 1);\n  S.alo = 150 * DEG * pre * pre;\n  if (btn[0]) S.hold = !S.hold;\n  if (!S.hold) {\n    const was = floor(S.ph);\n    S.ph += (d * sp) / (2 * CYCLE);\n    // Back at the bottom of a release with the rod straight, it buckles again\n    // to whichever side chance picks.\n    if (floor(S.ph) !== was && S.alo \u003c 1.2 * DEG) S.side = Math.random() \u003c 0.5 ? -1 : 1;\n  }\n  S.al = S.alo + (AMAX - S.alo) * (0.5 - 0.5 * cos(2 * PI * S.ph));\n  S.sb += d * sp * (BEAD / 2) * S.dir;\n  if (S.sb > L) (S.sb = 2 * L - S.sb), (S.dir = -1);\n  if (S.sb \u003c 0) (S.sb = -S.sb), (S.dir = 1);\n}\n\n// The colour of a rod pointing at screen angle a from straight up. The wheel\n// hurries from rose to lime, so dim orange and yellow, brown and olive on\n// this panel, hardly come up.\nfunction tint(S, a, out, o) {\n  let h = S.hue + 0.53 + (0.24 * a) / PI;\n  h -= floor(h);\n  const x = (h + 0.05 - floor(h + 0.05)) / 0.3;\n  if (x \u003c 1) h = 0.95 + 0.3 * (x - sin(2 * PI * x) / (2 * PI));\n  hsv(h, 0.8, 1, out, o);\n}\n\n// A point drawn between four LEDs, each channel kept at the brightest.\nfunction dot(buf, x, y, r, g, b) {\n  x -= 0.5;\n  y -= 0.5;\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = x0 + i, Y = y0 + j;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const w = (i ? fx : 1 - fx) * (j ? fy : 1 - fy), p = (Y * W + X) * 3;\n      buf[p] = max(buf[p], r * w);\n      buf[p + 1] = max(buf[p + 1], g * w);\n      buf[p + 2] = max(buf[p + 2], b * w);\n    }\n}\n\nfunction line(buf, ax, ay, bx, by, r, g, b) {\n  const m = max(1, ceil(Math.hypot(bx - ax, by - ay) * 2));\n  for (let i = 0; i \u003c= m; i++) dot(buf, ax + ((bx - ax) * i) / m, ay + ((by - ay) * i) / m, r, g, b);\n}\n\n// A shaded ball, written over what is there.\nfunction ball(buf, x, y, R, col) {\n  for (let Y = max(0, floor(y - R - 1)); Y \u003c= min(H - 1, ceil(y + R + 1)); Y++)\n    for (let X = max(0, floor(x - R - 1)); X \u003c= min(W - 1, ceil(x + R + 1)); X++) {\n      const dx = X + 0.5 - x, dy = Y + 0.5 - y, d2 = dx * dx + dy * dy, p = (Y * W + X) * 3;\n      if (d2 >= (R + 0.9) * (R + 0.9)) continue;\n      if (d2 >= R * R) {\n        buf[p] = buf[p + 1] = buf[p + 2] = 0;\n        continue;\n      }\n      const nz = sqrt(R * R - d2) / R, nx = dx / R, ny = dy / R;\n      const lam = max(0, nx * LX + ny * LY + nz * LZ), sh = max(0, nx * HX + ny * HY + nz * HZ) ** 24;\n      const v = 0.3 + 0.75 * lam;\n      buf[p] = col[0] * v + sh * 0.6;\n      buf[p + 1] = col[1] * v + sh * 0.6;\n      buf[p + 2] = col[2] * v + sh * 0.6;\n    }\n}\n\n// The rod's shape for end slope al in mode n, in closed form. With\n// k = sin(al/2) and sqrt(lambda) = 2nK/L, the tangent's angle theta from the\n// line of thrust has sin(theta/2) = k sn(u), u = sqrt(lambda) s + K, so\n// theta'' = -lambda sin(theta), the pendulum. Integrating cos and sin of theta:\n// x = (2/sqrt(lambda)) (E(u) - E(K)) - s along the line, y = -(2k/sqrt(lambda)) cn(u) off it.\nfunction shape(S) {\n  const { g, j, cx, cy, sg } = S, k = sin(S.al / 2), n = S.mode;\n  agm(k, g);\n  const r = (2 * n * g.K) / L;\n  jac(g.K, g, j);\n  const e0 = j.e;\n  let lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c= M; i++) {\n    const s = (L * i) / M;\n    jac(r * s + g.K, g, j);\n    cy[i] = (2 / r) * (j.e - e0) - s;\n    cx[i] = S.side * (-2 * k / r) * j.cn;\n    sg[i] = S.side * 2 * asin(cl(k * j.sn, -1, 1));\n    lo = min(lo, cx[i]);\n    hi = max(hi, cx[i]);\n  }\n  // The pins sit on the vertical centre line while the rod fits the panel.\n  // Mode 1 bows to one side only, up to 48.4 LEDs at an end slope of 114\n  // degrees, so there the line of thrust slides over with the pins on it\n  // until the bow clears the far edge. Nothing is scaled.\n  const m = RAD[n] + 1.6, D = cy[M], ox = cl(31.5, m - lo, W - m - hi);\n  for (let i = 0; i \u003c= M; i++) {\n    cx[i] += ox;\n    cy[i] = 63.5 + D / 2 - cy[i];\n  }\n  S.r = r;\n  S.k = k;\n  S.ox = ox;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  shape(S);\n  const { buf, zs, zd, zo, cx, cy, sg, g, j, col } = S, k = S.k;\n  buf.fill(0);\n  zs.fill(-1);\n\n  // The bead's angle and the pendulum's phase: going up the rod is forward\n  // time, coming back down is the same swing run on.\n  jac(S.r * S.sb + g.K, g, j);\n  const sb = S.side * 2 * asin(cl(k * j.sn, -1, 1));\n  const vb = S.side * k * j.cn * S.dir;\n  const ub = S.dir > 0 ? S.r * S.sb + g.K : 2 * g.K - (S.r * S.sb + g.K);\n\n  // The line of thrust between the pins, dotted.\n  const ya = cy[0], yb = cy[M];\n  for (let y = min(ya, yb) + 1; y \u003c max(ya, yb) - 1; y += 2) dot(buf, S.ox, y, 0.28, 0.28, 0.34);\n\n  // The pendulum, all of it behind the rod. Its arm hangs straight down when\n  // the rod at the bead points straight up. First a long exposure of the\n  // swing: the arm lingers where it turns, so the fan is brightest at its\n  // edges, by how slowly the pendulum passes each angle.\n  const pend = (a) => [PX - PL * sin(a), PY + PL * cos(a)];\n  for (let y = max(0, floor(PY - PL - 1)); y \u003c= ceil(PY + PL + 1); y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY, rr = Math.hypot(dx, dy);\n      if (rr > PL + 0.5 || rr \u003c 1.5) continue;\n      const a = Math.atan2(-dx, dy), sa = sin(abs(a) / 2);\n      if (sa >= k) continue;\n      const v = sqrt(1 - (sa * sa) / (k * k)), f = (round((0.07 + 0.2 * (1 - v) ** 2) * 16) / 16) * min(1, PL + 0.5 - rr);\n      tint(S, a, col, 0);\n      const o = (y * W + x) * 3;\n      buf[o] = col[0] * f;\n      buf[o + 1] = col[1] * f;\n      buf[o + 2] = col[2] * f;\n    }\n  // The bob's path from -al to al in the rod's colours, and the arm where it\n  // was over the bead's last 12 LEDs, fading.\n  for (let a = -S.al; a \u003c= S.al; a += 0.5 / PL) {\n    tint(S, a, col, 0);\n    const [x, y] = pend(a);\n    dot(buf, x, y, col[0] * 0.4, col[1] * 0.4, col[2] * 0.4);\n  }\n  for (let q = 12; q >= 1; q--) {\n    let s = S.sb - S.dir * q;\n    s = s \u003c 0 ? -s : s > L ? 2 * L - s : s;\n    jac(S.r * s + g.K, g, j);\n    const a = S.side * 2 * asin(cl(k * j.sn, -1, 1)), f = 0.34 * (1 - q / 13);\n    tint(S, a, col, 0);\n    const [x, y] = pend(a);\n    line(buf, PX, PY, x, y, col[0] * f, col[1] * f, col[2] * f);\n  }\n  const [bx, by] = pend(sb);\n  line(buf, PX, PY, bx, by, 0.62, 0.62, 0.68);\n  tint(S, sb, col, 0);\n  ball(buf, bx, by, 3.3, col);\n  ball(buf, PX, PY, 1.3, PIN);\n\n  // The phase portrait: the separatrix and the orbits of end slopes 30 to 150\n  // degrees, faint, and the orbit at this slope, brightest just behind the\n  // moving point. An orbit of slope b has sin(theta/2) = sin(b/2) sin(t) and\n  // theta' over twice sqrt(lambda) = sin(b/2) cos(t).\n  const qx = (a) => 31.5 - (QW * a) / PI, qy = (v) => QY - QH * v;\n  for (let a = -PI; a \u003c= PI; a += 0.02) {\n    const v = cos(a / 2);\n    tint(S, a, col, 0);\n    dot(buf, qx(a), qy(v), col[0] * 0.26, col[1] * 0.26, col[2] * 0.26);\n    dot(buf, qx(a), qy(-v), col[0] * 0.26, col[1] * 0.26, col[2] * 0.26);\n  }\n  for (let o = 1; o \u003c= 5; o++) {\n    const kb = sin((o * PI) / 12);\n    for (let t = 0; t \u003c 2 * PI; t += 0.03) {\n      const a = 2 * asin(kb * sin(t));\n      tint(S, a, col, 0);\n      dot(buf, qx(a), qy(kb * cos(t)), col[0] * 0.16, col[1] * 0.16, col[2] * 0.16);\n    }\n  }\n  const K4 = 4 * g.K, steps = 520;\n  for (let i = 0; i \u003c steps; i++) {\n    const u = (K4 * i) / steps;\n    jac(u, g, j);\n    const a = S.side * 2 * asin(cl(k * j.sn, -1, 1)), v = S.side * k * j.cn;\n    let b = (ub - u) / K4;\n    b -= floor(b);\n    const f = 0.42 + 0.58 * exp(-b * 7);\n    tint(S, a, col, 0);\n    dot(buf, qx(a), qy(v), col[0] * f, col[1] * f, col[2] * f);\n  }\n  tint(S, sb, col, 0);\n  ball(buf, qx(sb), qy(vb), 1.9, col);\n\n  // The rod. Each LED near it takes the nearest point of the strand on top:\n  // a strand more than one and a half rod widths further along lies over the\n  // earlier one, and its dark rim cuts the one below where the loops cross.\n  const R = RAD[S.mode], R1 = R + 1.1, same = 6 * R;\n  for (let i = 0; i \u003c M; i++) {\n    const ax = cx[i], ay = cy[i], dx = cx[i + 1] - ax, dy = cy[i + 1] - ay, l2 = dx * dx + dy * dy || 1e-9, ln = sqrt(l2);\n    const x0 = max(0, floor(min(ax, ax + dx) - R1)), x1 = min(W - 1, ceil(max(ax, ax + dx) + R1));\n    const y0 = max(0, floor(min(ay, ay + dy) - R1)), y1 = min(H - 1, ceil(max(ay, ay + dy) + R1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x + 0.5 - ax, py = y + 0.5 - ay, t = cl((px * dx + py * dy) / l2, 0, 1);\n        const qx2 = px - t * dx, qy2 = py - t * dy, d2 = qx2 * qx2 + qy2 * qy2;\n        if (d2 >= R1 * R1) continue;\n        const p = y * W + x, s = i + t, z = zs[p], dd = sqrt(d2);\n        if (z >= 0 && s \u003c= z + same && dd >= zd[p]) continue;\n        zs[p] = s;\n        zd[p] = dd;\n        zo[p] = (dx * qy2 - dy * qx2) / ln;\n      }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const s = zs[p];\n    if (s \u003c 0) continue;\n    const o = p * 3;\n    if (zd[p] >= R) {\n      buf[o] = buf[o + 1] = buf[o + 2] = 0;\n      continue;\n    }\n    const i = min(M - 1, floor(s)), f = s - i, a = sg[i] + (sg[i + 1] - sg[i]) * f;\n    // The tube's normal: across the rod in the panel, and out of it.\n    const u = zo[p] / R, w = sqrt(max(0, 1 - u * u)), nx = cos(a) * u, ny = sin(a) * u;\n    const lam = max(0, nx * LX + ny * LY + w * LZ), sh = max(0, nx * HX + ny * HY + w * HZ) ** 20;\n    tint(S, a, col, 0);\n    const sl = (s * L) / M, gb = exp(-(((sl - S.sb) / 1.7) ** 2)), tr = S.dir * (S.sb - sl);\n    const v = (0.3 + 0.75 * lam) * (1 + (tr > 0 ? 0.35 * exp(-tr / 9) : 0));\n    buf[o] = col[0] * v + sh * 0.55 + gb * 0.8;\n    buf[o + 1] = col[1] * v + sh * 0.55 + gb * 0.8;\n    buf[o + 2] = col[2] * v + sh * 0.55 + gb * 0.8;\n  }\n\n  // The pins, on top.\n  ball(buf, cx[0], cy[0], 2.2, PIN);\n  ball(buf, cx[M], cy[M], 2.2, PIN);\n\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    if (buf[o] + buf[o + 1] + buf[o + 2] \u003c 0.02) continue;\n    // Each channel in steps of 4 of 255.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] * 63.75) * 4), min(255, round(buf[o + 1] * 63.75) * 4), min(255, round(buf[o + 2] * 63.75) * 4));\n  }\n}\n","four-vertex":"// ===== Patternflow pattern =====\n// Title:   Four-Vertex Theorem\n// Family:  line\n// Idea:    A smooth closed curve slowly changes shape while its evolute, the path of its centres of curvature, turns inside it as a gold star with one cusp for each white vertex where the curvature is greatest or least, and the cusps are born and die in pairs but never number fewer than four.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: four-vertex theorem (Syamadas Mukhopadhyaya, 1909; Adolf Kneser, 1912), with the curve's evolute (Christiaan Huygens, 1673), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Terms=2..6, Bend=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the curve runs from azure where it is flattest through violet to magenta where it is sharpest. Its evolute is peach on the arcs that come from flat parts and pale gold on those from sharp parts, over a dark violet glow on the LEDs that four normals of the curve pass through. At 0.25 the curve runs violet through red to orange and the evolute is lime; at 0.5 orange to green with a pale azure evolute; at 0.75 green to blue with a pink one. The dark glow keeps off orange and yellow, which read brown and olive when dim.\n// Knob 2: Speed. At 2 each wave of the curve swells and fades every 5 to 10 seconds while it turns, and the vertex count changes about 30 times a minute. The osculating circle rolls once round the curve in 7 seconds; on each lap its radius swells to about 105 LEDs on the flattest stretch (62 to 455) and shrinks to about 17 at the sharpest end. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Terms. How many waves bend the curve's radius: at 2 one with 3 lobes and one with 4, and each step adds the next, up to 8 lobes at 6. All of them share one swing of curvature, so the higher ones hardly move the outline while they fold the evolute into small swallowtails. At 2 the curve has 4 vertices 13% of the time, 6 for 52% and 8 for 35%; at 6 it has 4 to 16, mostly 10 or 12, and the count changes 60 times a minute. Every count is even.\n// Knob 4: Bend. How far the waves may swing the curvature. Up to 0.06 the curve stays convex and the evolute a closed star. At Terms 2 the curve starts to dent from about 0.1, and at 1 it is dented 84% of the time (53% at Terms 6). The curvature passes through zero at the two ends of each dent and the evolute runs off the panel towards them; a small arc of it opens outside the curve, carrying the cusp of the dent's own vertex. Kneser's theorem covers these curves too, and the count still never falls below 4.\n// Buttons: K1 tap swells the next wave up for about two seconds, peaking half a second after the tap, so a burst of swallowtails opens on the evolute and closes again; at the opening the count rises from 6.4 on average to a peak of 9.6.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Samples round the curve, the lowest and highest waves (in lobes), and\n// how much taller than wide the curve stands before its waves bend it.\nconst M = 720, K0 = 3, KMAX = 8, ASP = 1.4;\n// The box the curve is scaled to fit, in LEDs.\nconst BOX_W = 60, BOX_H = 120;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const R = Math.random, K = KMAX + 1;\n  const nu = new Float64Array(K), a0 = new Float64Array(K), mu = new Float64Array(K), p0 = new Float64Array(K);\n  for (let k = K0; k \u003c= KMAX; k++) {\n    nu[k] = 0.5 + 0.4 * R();\n    a0[k] = TAU * R();\n    mu[k] = (k % 2 ? -1 : 1) * (0.05 + 0.08 * R()) * (3 / k);\n    p0[k] = TAU * R();\n  }\n  params.s = {\n    nu, a0, mu, p0, wgt: new Float64Array(K), amp: new Float64Array(K), ph: new Float64Array(K),\n    t: 0, u: 0, tap: 99, hue: 0, speed: 2, terms: 2, bend: 0.06, first: true,\n    // Per sample: the point, its curvature, its centre of curvature, the sign\n    // of the curvature's slope, and the arc length so far.\n    x: new Float64Array(M), y: new Float64Array(M), k: new Float64Array(M),\n    ex: new Float64Array(M), ey: new Float64Array(M), v: new Float64Array(M), arc: new Float64Array(M + 1),\n    sc: 1, ox: 32, oy: 64, kmin: 0, kmax: 1,\n    vert: [], prev: [], flash: [], osc: null, pt: new Float64Array(10),\n    dx: new Float64Array(M), dy: new Float64Array(M), ga: new Float64Array(M), gx: new Float64Array(M), gb: new Float64Array(M), run: new Int32Array(W + 1), cnt: new Uint8Array(N), q: new Float64Array(M),\n    // A running record: frames, how many had each vertex count, the least\n    // count seen, and frames where the curve was dented.\n    stat: { frames: 0, hist: {}, minCount: 99, concave: 0 },\n    rgb: new Float32Array(N * 3), col: new Float64Array(3),\n  };\n}\n\n// The curve in its own frame: r(phi) = 1 + sum c_k cos(k phi - p_k), drawn\n// as (r cos phi, ASP r sin phi), with r and its first three derivatives\n// summed exactly. Fills o with the point (0, 1), its centre of curvature\n// (2, 3), the curvature (4), a number with the sign of the curvature's\n// slope (5) and the velocity (6, 7), all in the curve's own units. With\n// cross = x'y'' - y'x'' and D = x'^2 + y'^2 the curvature is cross / D^1.5,\n// its slope has the sign of cross' D - 1.5 cross D', and the centre is the\n// point plus D / cross times the velocity turned a quarter.\nfunction at(S, phi, o) {\n  let r = 1, r1 = 0, r2 = 0, r3 = 0;\n  for (let k = K0; k \u003c= KMAX; k++) {\n    const a = S.amp[k];\n    if (a === 0) continue;\n    const q = k * phi - S.ph[k], c = a * cos(q), s = a * sin(q);\n    r += c;\n    r1 -= k * s;\n    r2 -= k * k * c;\n    r3 += k * k * k * s;\n  }\n  const cp = cos(phi), sp = sin(phi);\n  const x = r * cp, y = ASP * r * sp;\n  const x1 = r1 * cp - r * sp, y1 = ASP * (r1 * sp + r * cp);\n  const x2 = r2 * cp - 2 * r1 * sp - r * cp, y2 = ASP * (r2 * sp + 2 * r1 * cp - r * sp);\n  const cross = x1 * y2 - y1 * x2, D = x1 * x1 + y1 * y1;\n  const dcross = ASP * (2 * r * r1 + 3 * r1 * r2 - r * r3), dD = 2 * (x1 * x2 + y1 * y2);\n  o[0] = x;\n  o[1] = y;\n  const f = D / cross;\n  o[2] = x - f * y1;\n  o[3] = y + f * x1;\n  o[4] = cross / (D * sqrt(D));\n  o[5] = dcross * D - 1.5 * cross * dD;\n  o[6] = x1;\n  o[7] = y1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.terms = cl(floor(kv[2] + 0.5), 2, 6);\n  S.bend = cl(kv[3], 0, 1);\n  S.t += d * S.speed * 0.65;\n  const t = S.t;\n  // Each wave fades in or out over about a second when Terms moves.\n  let wsum = 0;\n  for (let k = K0; k \u003c= KMAX; k++) {\n    const target = k \u003c K0 + S.terms ? 1 : 0;\n    S.wgt[k] = S.first ? target : S.wgt[k] + (target - S.wgt[k]) * min(1, d * 2.5);\n    wsum += S.wgt[k];\n  }\n  // How far the waves together may swing the curvature, as a share of the\n  // circle's. The waves split it evenly, each scaled by 1 / (k^2 - 1) since\n  // a wave of k lobes swings the curvature k^2 - 1 times its own height.\n  // At 0.7 the curve stays convex; from about 0.86 (Bend 0.1) it dents.\n  const budget = 0.7 + 1.6 * S.bend;\n  if (input.btnPressed && input.btnPressed[0]) S.tap = 0;\n  S.tap += d;\n  // A tap swells the next wave up (or the top one when all are in). The\n  // swell peaks 0.5 seconds after the tap and is gone in about 3.\n  const kick = (S.tap / 0.5) * Math.exp(1 - S.tap / 0.5);\n  const kicked = min(KMAX, K0 + S.terms);\n  for (let k = K0; k \u003c= KMAX; k++) {\n    const e = 0.6 + 0.4 * sin(S.nu[k] * t + S.a0[k]);\n    S.amp[k] = (budget * (S.wgt[k] * e / wsum + (k === kicked ? 0.6 * kick : 0))) / (k * k - 1);\n    S.ph[k] = S.p0[k] + S.mu[k] * t;\n  }\n  // Sample, fit to the box, and find where the curvature's slope changes sign.\n  const o = S.pt, X = S.x, Y = S.y, K = S.k, EX = S.ex, EY = S.ey, V = S.v;\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9, kmin = 1e9, kmax = -1e9, concave = false;\n  // kmin is the least positive curvature.\n  for (let i = 0; i \u003c M; i++) {\n    at(S, (TAU * i) / M, o);\n    (X[i] = o[0]), (Y[i] = o[1]), (EX[i] = o[2]), (EY[i] = o[3]), (K[i] = o[4]), (V[i] = o[5]), (S.dx[i] = o[6]), (S.dy[i] = o[7]);\n    x0 = min(x0, o[0]), x1 = max(x1, o[0]), y0 = min(y0, o[1]), y1 = max(y1, o[1]);\n    kmax = max(kmax, o[4]);\n    if (o[4] \u003c= 0) concave = true;\n    else kmin = min(kmin, o[4]);\n  }\n  // The scale fits the curve to the box.\n  const fit = min(BOX_W / (x1 - x0), BOX_H / (y1 - y0));\n  S.sc = S.first ? fit : S.sc + (fit - S.sc) * min(1, d * 2);\n  const sc = S.sc;\n  // Centred on the curve's box.\n  S.ox = W / 2 - (sc * (x0 + x1)) / 2;\n  S.oy = H / 2 + (sc * (y0 + y1)) / 2;\n  S.kmin = kmin;\n  S.kmax = kmax;\n  // Arc length, for the osculating circle's even roll.\n  S.arc[0] = 0;\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M;\n    S.arc[i + 1] = S.arc[i] + Math.hypot(X[j] - X[i], Y[j] - Y[i]);\n  }\n  // Vertices: each sign change of the slope, placed by one secant step.\n  S.prev = S.vert;\n  const vert = [];\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M, a = V[i], b = V[j];\n    if ((a \u003c 0) !== (b \u003c 0)) {\n      const f = a / (a - b), phi = (TAU * (i + f)) / M;\n      at(S, phi, o);\n      vert.push({ phi, x: o[0], y: o[1], cx: o[2], cy: o[3], kap: o[4], max: a > 0 });\n    }\n  }\n  S.vert = vert;\n  // Vertices born or gone this frame start a flash, drawn as a ring.\n  if (!S.first) {\n    const near = (a, b) => a.max === b.max && angDist(a.phi, b.phi) \u003c 0.15;\n    if (vert.length !== S.prev.length) {\n      for (const v of vert) if (!S.prev.some((p) => near(p, v))) S.flash.push({ v, age: 0, born: true });\n      for (const p of S.prev) if (!vert.some((v) => near(p, v))) S.flash.push({ v: p, age: 0, born: false });\n    }\n  }\n  for (const f of S.flash) f.age += d;\n  S.flash = S.flash.filter((f) => f.age \u003c 0.8);\n  // The osculating circle rolls once round in 7 seconds at Speed 2.\n  S.u = (S.u + (d * S.speed) / 14) % 1;\n  const L = S.arc[M], goal = S.u * L;\n  let lo = 0, hi = M;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (S.arc[mid] \u003c= goal) lo = mid;\n    else hi = mid;\n  }\n  const f = (goal - S.arc[lo]) / (S.arc[lo + 1] - S.arc[lo] || 1);\n  at(S, (TAU * (lo + f)) / M, o);\n  S.osc = { x: o[0], y: o[1], cx: o[2], cy: o[3], kap: o[4] };\n  const st = S.stat;\n  st.frames++;\n  st.hist[vert.length] = (st.hist[vert.length] || 0) + 1;\n  st.minCount = min(st.minCount, vert.length);\n  if (concave) st.concave++;\n  S.first = false;\n}\n\nfunction angDist(a, b) {\n  const d = abs(a - b) % TAU;\n  return d > PI ? TAU - d : d;\n}\n\n// Drawing: lines are laid as points every third of an LED, each lighting\n// its four nearest LEDs by how close it falls, and an LED keeps the\n// brightest colour laid on it.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\n// A segment, cut to the panel first: a radius of curvature can run\n// thousands of LEDs off it.\nfunction line(S, xa, ya, xb, yb, c, a, gap) {\n  const dx = xb - xa, dy = yb - ya;\n  let t0 = 0, t1 = 1;\n  for (const [p, q] of [[-dx, xa + 1], [dx, W + 1 - xa], [-dy, ya + 1], [dy, H + 1 - ya]]) {\n    if (p === 0) {\n      if (q \u003c 0) return;\n    } else if (p \u003c 0) t0 = max(t0, q / p);\n    else t1 = min(t1, q / p);\n  }\n  if (t0 > t1) return;\n  const len = Math.hypot(dx, dy), n = Math.ceil(len * (t1 - t0) * 3) || 1;\n  for (let e = 0; e \u003c= n; e++) {\n    const u = t0 + ((t1 - t0) * e) / n;\n    if (gap && floor((u * len) / gap) % 2) continue;\n    plot(S, xa + dx * u, ya + dy * u, c, a);\n  }\n}\nfunction dot(S, x, y, c, a, rad) {\n  for (let yy = floor(y - rad); yy \u003c= floor(y + rad); yy++)\n    for (let xx = floor(x - rad); xx \u003c= floor(x + rad); xx++) {\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n      const dd = Math.hypot(xx + 0.5 - x, yy + 0.5 - y), w = cl(rad + 0.5 - dd, 0, 1) * a, p = (yy * W + xx) * 3;\n      if (w \u003c= 0) continue;\n      S.rgb[p] = max(S.rgb[p], c[0] * w);\n      S.rgb[p + 1] = max(S.rgb[p + 1], c[1] * w);\n      S.rgb[p + 2] = max(S.rgb[p + 2], c[2] * w);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, col, sc, ox, oy, x: X, y: Y, ex: EX, ey: EY, k: K } = S;\n  const px = (u) => ox + sc * u, py = (v) => oy - sc * v;\n  const h0 = S.hue + 0.55;\n  rgb.fill(0);\n  // How many normals of the curve pass through each LED: the sign changes\n  // round the curve of g(phi) = (curve - LED) . tangent. Along a row, the\n  // sign at one sample flips at a single column, so each pair of\n  // neighbouring samples disagrees on one run of columns (or outside it),\n  // added into the row's tally as a difference.\n  const DX = S.dx, DY = S.dy, A = S.ga, B = S.gb, T = S.gx, run = S.run, cnt = S.cnt;\n  for (let i = 0; i \u003c M; i++) A[i] = X[i] * DX[i] + Y[i] * DY[i];\n  for (let yy = 0; yy \u003c H; yy++) {\n    const my = (oy - yy - 0.5) / sc;\n    run.fill(0);\n    for (let i = 0; i \u003c M; i++) {\n      B[i] = A[i] - my * DY[i];\n      // The column (in LED units) where this sample's sign flips.\n      const tx = DX[i] || 1e-12;\n      T[i] = (B[i] / tx) * sc + ox - 0.5;\n    }\n    for (let i = 0; i \u003c M; i++) {\n      const j = i + 1 \u003c M ? i + 1 : 0;\n      let c1 = T[i], c2 = T[j];\n      if (c1 > c2) (c1 = T[j]), (c2 = T[i]);\n      const lo = cl(Math.ceil(c1), 0, W), hi = cl(floor(c2) + 1, 0, W);\n      if ((DX[i] || 1e-12) * (DX[j] || 1e-12) > 0) {\n        if (hi > lo) run[lo]++, run[hi]--;\n      } else {\n        run[0]++, run[W]--;\n        if (hi > lo) run[lo]--, run[hi]++;\n      }\n    }\n    for (let xx = 0, c = 0, p = yy * W; xx \u003c W; xx++, p++) {\n      c += run[xx];\n      cnt[p] = c;\n    }\n  }\n  // The dim fill keeps off the orange and yellow part of the wheel, which\n  // reads brown and olive when dark: its hue runs from green round to red.\n  const fills = [];\n  for (let c = 0; c \u003c 4; c++) {\n    const fh = h0 + 0.16 + 0.07 * c;\n    hsv(0.22 + 0.8 * (fh - floor(fh)), 0.75, 0.24 + 0.12 * c, col);\n    fills.push([col[0], col[1], col[2]]);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const c = cnt[p];\n    if (c \u003c= 2) continue;\n    const f = fills[min(3, (c - 4) >> 1)];\n    (rgb[o] = f[0]), (rgb[o + 1] = f[1]), (rgb[o + 2] = f[2]);\n  }\n  // Each sample's place between the flattest and the sharpest of the\n  // curve, on a log scale.\n  const lk0 = log(S.kmin), lk1 = log(S.kmax), Q = S.q;\n  for (let i = 0; i \u003c M; i++) Q[i] = K[i] > 0 ? cl((log(K[i]) - lk0) / (lk1 - lk0 || 1), 0, 1) : 0;\n  // The evolute, pale and opposite the curve on the wheel, a little nearer\n  // the curve's own hue where its arc comes from a sharp part, and broken\n  // where it runs off towards an inflection.\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M;\n    if (K[i] > 0 !== K[j] > 0) continue;\n    const xa = px(EX[i]), ya = py(EY[i]), xb = px(EX[j]), yb = py(EY[j]);\n    if (abs(xb - xa) + abs(yb - ya) > 24) continue;\n    hsv(h0 + 0.5 + 0.12 * Q[i], 0.5, 1, col);\n    line(S, xa, ya, xb, yb, col, 0.9);\n  }\n  // Each vertex joined to its cusp by a dotted radius.\n  const join = [0.5, 0.5, 0.55];\n  for (const v of S.vert) line(S, px(v.x), py(v.y), px(v.cx), py(v.cy), join, 0.45, 1);\n  // The osculating circle, in the colour of the curve where it touches.\n  const oc = S.osc;\n  if (oc && abs(oc.kap) > 1e-6) {\n    const R = sc / abs(oc.kap), cx = px(oc.cx), cy = py(oc.cy);\n    hsv(h0 + 0.35 * (oc.kap > 0 ? cl((log(oc.kap) - lk0) / (lk1 - lk0 || 1), 0, 1) : 0), 0.35, 0.8, col);\n    const n = Math.ceil(min(TAU, 300 / R) * R * 2.5);\n    const a0 = Math.atan2(py(oc.y) - cy, px(oc.x) - cx), span = min(PI, 150 / R);\n    for (let e = 0; e \u003c= n; e++) {\n      const a = a0 - span + (2 * span * e) / n;\n      plot(S, cx + R * cos(a), cy + R * sin(a), col, 0.7);\n    }\n  }\n  // The curve, coloured by curvature: flat parts at the base hue, the\n  // sharpest a third of the wheel on.\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M;\n    hsv(h0 + 0.35 * Q[i], 0.85, 1, col);\n    line(S, px(X[i]), py(Y[i]), px(X[j]), py(Y[j]), col, 1);\n  }\n  // Vertices on the curve, their cusps on the evolute.\n  const cusp = [1, 0.92, 0.8];\n  for (const v of S.vert) {\n    dot(S, px(v.x), py(v.y), [1, 1, 1], 1, 1.1);\n    dot(S, px(v.cx), py(v.cy), cusp, 1, 0.9);\n  }\n  if (oc) {\n    dot(S, px(oc.x), py(oc.y), [1, 1, 1], 1, 0.9);\n    dot(S, px(oc.cx), py(oc.cy), cusp, 1, 1);\n  }\n  const evo = [0.7, 0.7, 0.75];\n  // A ring opens where a vertex was born or died: at its cusp, or at the\n  // vertex itself when the cusp is off the panel.\n  for (const f of S.flash) {\n    let fx = px(f.v.cx), fy = py(f.v.cy);\n    if (fx \u003c 0 || fx >= W || fy \u003c 0 || fy >= H) (fx = px(f.v.x)), (fy = py(f.v.y));\n    const r = 1.5 + 6 * f.age, a = 1 - f.age / 0.8, n = 40;\n    for (let e = 0; e \u003c n; e++) plot(S, fx + r * cos((TAU * e) / n), fy + r * sin((TAU * e) / n), f.born ? [1, 1, 1] : evo, a);\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","gaussian-periods":"// ===== Patternflow pattern =====\n// Title:   Gaussian Periods\n// Family:  number\n// Idea:    Every residue k mod n lights one LED at its Gaussian period eta(k), a sum of d roots of unity, so eleven rotated deltoids stand as a sunburst of dots coloured by k mod 11; then every point slides to eta(u k), the burst comes apart, and the same set of points builds it again with the copies' colours traded.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Gaussian periods (Carl Friedrich Gauss, 1801), plotted as William Duke, Stephan Ramon Garcia and Bob Lutz plotted them (2015), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Figure=0..7, Unit=0..2\n//\n// Knob 1: Hue. Turns the colour classes round the wheel together. At 0 the class of k = 0 is cyan and the other classes step evenly round the wheel, ordered so that neighbouring spikes get neighbouring hues.\n// Knob 2: Speed. At 2 the figure rests 1 second and a rebuild takes 1.75 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Figure. Eight pairs (n, omega): eleven rotated deltoids (n = 11 * 991), seven (7 * 1201), four (4 * 1201), a deltoid and its negative (2 * 2719), deltoids scaled by 2 cos(2 pi j / 13) (13 * 1021), the five-cusp star of the prime 12011, a nine-point star (9 * 1093) and the deltoid lace of 7^4.\n// Knob 4: Unit. Which multiplier u the rebuilds use. At 0 a unit that carries points into other colour classes, at 1 one that keeps every class in place so each copy rebuilds itself, at 2 one that turns whole copies about the centre. A figure without copies uses u = -1 there, which folds it onto its mirror image.\n// Buttons: K1 tap goes to the next figure.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, cos, sin, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// [n, omega, colour kind, m, g, q, x zoom, hue step, three units u].\n// Colour kind 0 is k mod m, kind 1 is k mod m up to sign, kind 2 is the class\n// of k mod q among the units mod q, read off the m-th powers of the\n// primitive root g, with k = 0 mod q a class of its own. Each class is a\n// union of whole orbits k, k omega, k omega^2, ..., so every dot has one\n// colour. The hue step orders the classes so that neighbouring spikes get\n// neighbouring hues. The first unit carries points into other classes (on\n// the hexagram none can, so it is a second unit of the next kind), the\n// second keeps every class in place, the third turns whole copies about the\n// centre (u = 1 mod n / m) or, on a figure without copies, is u = -1.\nconst FIG = [\n  [10901, 9032, 0, 11, 0, 0, 1.2, 3, 882, 870, 992], // 11 * 991, omega = 1 mod 11: eleven rotated deltoids\n  [8407, 3032, 0, 7, 0, 0, 1.1, 6, 1363, 2689, 1202], // 7 * 1201: seven rotated deltoids\n  [4804, 4173, 0, 4, 0, 0, 1, 3, 679, 1921, 2403], // 4 * 1201: four rotated deltoids\n  [5438, 1453, 0, 2, 0, 0, 1, 1, 57, 819, 5437], // 2 * 2719: a deltoid and its negative\n  [13273, 3431, 1, 13, 0, 0, 1, 1, 87, 116, 13272], // 13 * 1021, omega = -1 mod 13: deltoids scaled by 2 cos(2 pi j / 13)\n  [12011, 2557, 2, 2, 2, 12011, 1, 1, 1819, 151, 12010], // prime, d = 5: the five-cusp star, by quadratic character\n  [9837, 151, 0, 3, 0, 0, 1, 1, 2960, 31, 3280], // 9 * 1093, omega of order 3 mod 9 too: a nine-point star\n  [2401, 1047, 2, 2, 3, 7, 1, 1, 38, 1086, 2400], // 7^4, d = 3: deltoid lace, by quadratic character of k mod 7\n];\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Build one figure: the orbits of omega on Z/n, eta for every k, the colour\n// of each orbit and the scale that fills the panel.\nfunction build(idx) {\n  const [n, w, kind, m, g, q, zx, hm, u0, u1, u2] = FIG[idx];\n  const pw = [1];\n  for (let x = w % n; x !== 1; x = (x * w) % n) pw.push(x);\n  const d = pw.length;\n  const C = new Float64Array(n), S = new Float64Array(n);\n  for (let k = 0; k \u003c n; k++) (C[k] = cos((TAU * k) / n)), (S[k] = sin((TAU * k) / n));\n  const er = new Float64Array(n), ei = new Float64Array(n);\n  for (let k = 0; k \u003c n; k++) {\n    let a = 0, b = 0;\n    for (let j = 0; j \u003c d; j++) {\n      const r = (k * pw[j]) % n;\n      a += C[r];\n      b += S[r];\n    }\n    er[k] = a;\n    ei[k] = b;\n  }\n  let lg = null;\n  if (kind === 2) {\n    lg = new Int32Array(q);\n    for (let e = 0, x = 1; e \u003c q - 1; e++, x = (x * g) % q) lg[x] = e % m;\n  }\n  const seen = new Uint8Array(n), rep = [];\n  for (let k = 0; k \u003c n; k++) {\n    if (seen[k]) continue;\n    for (let j = 0; j \u003c d; j++) seen[(k * pw[j]) % n] = 1;\n    rep.push(k);\n  }\n  const np = rep.length, ncls = kind === 0 ? m : kind === 1 ? (m >> 1) + 1 : m + 1;\n  const cls = new Int16Array(np), slot = new Float32Array(ncls);\n  for (let p = 0; p \u003c np; p++) {\n    const k = rep[p], r = k % m;\n    cls[p] = kind === 0 ? r : kind === 1 ? min(r, m - r) : k % q === 0 ? m : lg[k % q];\n  }\n  for (let c = 0; c \u003c ncls; c++) slot[c] = ((hm * c) % ncls) / ncls;\n  let r0 = 1e9, r1 = -1e9, i1 = 0;\n  for (let k = 0; k \u003c n; k++) (r0 = min(r0, er[k])), (r1 = max(r1, er[k])), (i1 = max(i1, abs(ei[k])));\n  // The imaginary axis runs across and the real axis up, each scaled to the\n  // panel, so a round figure stands twice as tall as it is wide and complex\n  // conjugation, eta(-k), is the left-right mirror. The eleven and the seven\n  // deltoids are drawn 1.2 and 1.1 times wider and lose the tips of their\n  // side spikes.\n  const sx = (31.2 * zx) / i1, sy = 126.4 / (r1 - r0), cr = (r0 + r1) / 2;\n  return {\n    idx, n, d, pw, er, ei, sx, sy, cr, ncls, slot, units: [u0, u1, u2],\n    cls, cur: Int32Array.from(rep), np, a: new Int32Array(np * d), dl: new Int32Array(np * d),\n  };\n}\n\nexport function setup(params) {\n  params.s = { f: build(0), fig: 0, knobFig: 0, t: 0, s: 0, moving: false, u: 0, hue: -1, palHue: -2, pal: [], grid: new Int16Array(W * H) };\n}\n\nconst TRAVEL = 3.5, REST = 2;\n\n// A rebuild: root j of point k, e(k omega^j / n), turns along the shorter\n// arc to e(u k omega^j / n), so the point ends exactly at eta(u k).\nfunction startRebuild(s, u) {\n  const { n, d, pw, cur, a, dl, np } = s.f;\n  for (let p = 0; p \u003c np; p++) {\n    const k = cur[p], v = (u * k) % n;\n    for (let j = 0; j \u003c d; j++) {\n      const x = (k * pw[j]) % n;\n      let e = ((v * pw[j]) % n) - x;\n      if (e > n / 2) e -= n;\n      else if (e \u003c= -n / 2) e += n;\n      a[p * d + j] = x;\n      dl[p * d + j] = e;\n    }\n  }\n  s.u = u;\n  s.moving = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06], step = cl(dt || 0, 0, 0.1);\n  const kf = cl(round(k[2]), 0, FIG.length - 1);\n  if (kf !== s.knobFig) (s.knobFig = kf), (s.fig = kf);\n  if (input.btnPressed && input.btnPressed[0]) s.fig = (s.fig + 1) % FIG.length;\n  if (s.fig !== s.f.idx) (s.f = build(s.fig)), (s.t = 0), (s.moving = false);\n  const f = s.f;\n  s.hue = cl(k[0], 0, 1);\n  s.t += step * cl(k[1], 0.2, 3);\n  if (!s.moving) {\n    s.s = 0;\n    if (s.t >= REST) (s.t -= REST), startRebuild(s, f.units[cl(round(k[3]), 0, 2)]);\n  }\n  if (s.moving) {\n    if (s.t >= TRAVEL) {\n      s.t -= TRAVEL;\n      s.moving = false;\n      s.s = 0;\n      for (let p = 0; p \u003c f.np; p++) f.cur[p] = (s.u * f.cur[p]) % f.n;\n    } else {\n      const x = s.t / TRAVEL;\n      s.s = x * x * (3 - 2 * x);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const f = s.f, { n, d, er, ei, sx, sy, cr, cls, cur, a, dl, np, ncls, slot } = f;\n  if (s.palHue !== s.hue || s.pal.length !== ncls) {\n    s.pal = [];\n    for (let c = 0; c \u003c ncls; c++) s.pal.push(hsv(s.hue + 0.5 + slot[c], 0.78, 255));\n    s.palHue = s.hue;\n  }\n  const grid = s.grid;\n  grid.fill(-1);\n  const t = s.s, moving = s.moving && t > 0;\n  for (let p = 0; p \u003c np; p++) {\n    let re = 0, im = 0;\n    if (!moving) (re = er[cur[p]]), (im = ei[cur[p]]);\n    else\n      for (let j = 0, o = p * d; j \u003c d; j++, o++) {\n        const ang = (TAU * (a[o] + t * dl[o])) / n;\n        re += cos(ang);\n        im += sin(ang);\n      }\n    const x = floor(31.5 + im * sx + 0.5), y = floor(63.5 - (re - cr) * sy + 0.5);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) grid[y * W + x] = cls[p];\n  }\n  const pal = s.pal;\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      const c = grid[q];\n      if (c \u003c 0) display.setPixel(x, y, 0, 0, 0);\n      else display.setPixel(x, y, pal[c][0], pal[c][1], pal[c][2]);\n    }\n}\n","leapfrogging-vortices":"// ===== Patternflow pattern =====\n// Title:   Leapfrogging Vortices\n// Family:  sim\n// Idea:    Two smoke rings travel up the panel one behind the other, seen in a slice through their axis as two pairs of dye spirals, and the rear ring keeps shrinking, darting through the front one and widening again while the front one swells, slows and falls behind.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: leapfrogging vortex rings (Hermann von Helmholtz, 1858), as two pairs of point vortices (Walter Gröbli, 1877; A. E. H. Love, 1894), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=3..8, Dye=0..1\n//\n// Knob 1: Hue. Turns both dyes round the wheel together: at 0 the ring that starts in front is emerald and the one behind it magenta.\n// Knob 2: Speed. At 2 a whole leapfrog, each ring passing through the other once, takes 7.9 seconds at the start ratio and the pair climbs 67 LEDs in it; at 0.2 ten times slower.\n// Knob 3: Ratio. How many times wider the big ring is than the small one at the moment the small one passes through it. At 3 the rings leapfrog every 7.9 seconds; at 5 every 41, drifting up to 53 LEDs apart between passes. Love's threshold is 1 / (3 - 2 sqrt 2) = 5.83. From about 5.6 the rings part further than the panel before they turn back, and above 5.83 the small ring darts through once and walks away for good; either way a fresh pair is launched.\n// Knob 4: Dye. How much dye fills the rings' bubbles of water: at the start the spirals in the cores and a thin wake; turned up, two full smoke rings and a long braided wake.\n// Buttons: K1 tap lays fresh dye on both rings.\n\n// Each ring is a pair of point vortices of circulation G in the plane\n// through the axis, one on each side, spinning opposite ways. A ring is the\n// same all round its axis, so only the right-hand vortex of each pair is\n// integrated and its mirror image across the axis carries -G. The slice is\n// four point vortices, and the motion is the one Gröbli and Love worked\n// out: when the small pair passes through the big one, if it is wider than\n// 3 - 2 sqrt 2 = 0.17157 of the big one the two keep leapfrogging, and if it\n// is narrower they part. The threshold is where the energy of the four\n// vortices at that moment equals the most that two pairs far apart can\n// have with the same impulse, so above it they can never get far apart.\n//\n// Checked in a separate run (G = 1, the big pair's half width 1, both\n// level at the start, RK4): at 0.17157 the pairs walked away, 2000 apart at\n// t = 1.3e6; at 0.1716 they came level again at t = 38545, at 0.172 at 2433,\n// at 0.175 at 297. Near the threshold that half period grows as\n// 1 / (ratio - 0.17157). Integrating all four vortices with no mirror\n// imposed and one nudged by 1e-9, the leapfrog broke its mirror symmetry at\n// every ratio up to 0.38 (at 0.3 by t = 62) and held from 0.385, as Acheson\n// (2000) found with 0.382. A ring that stays round cannot do that, hence the\n// mirror. With this file's integrator over 600 seconds at Speed 2 the energy\n// of the four vortices drifted by 2.6e-12 of itself and the impulse along the\n// axis by 3e-14, at every ratio from 3 to 5.5.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, sqrt, sin, cos, exp, abs, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = () => Math.random();\n// The big ring's half width when the small one is level with it, in LEDs;\n// circulation per vortex in LED^2 per second at Speed 2, divided by 2 pi;\n// the panel row the rings' middle is held on; dye particles per ring\n// (right half, drawn mirrored); the separation at which a pair is replaced.\nconst A = 22, GAM = 820, G = GAM / (2 * PI), ROW = 52, NPR = 2600, LIM = 104;\n// The vortex step, and the longest dye step, in seconds.\nconst HV = 0.004, HD = 0.018;\n// Dye brightness: density scale, and the share under which dye is only haze.\nconst S0 = 2.2, D0 = 0.06;\nconst JIT = new Uint8Array(N).map((_, p) => h32(p, 77) & 63);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nfunction h32(i, j) {\n  let h = (Math.imul(i, 374761393) + Math.imul(j, 668265263)) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return (h ^ (h >>> 16)) >>> 0;\n}\n\n// Velocity of the two right-hand vortices (x, y up) from the other three.\nconst K1 = new Float64Array(4), K2 = new Float64Array(4), K3 = new Float64Array(4), K4 = new Float64Array(4), TV = new Float64Array(4);\nfunction vvel(V, o) {\n  for (let k = 0; k \u003c 2; k++) {\n    const x = V[2 * k], y = V[2 * k + 1], j = 2 - 2 * k, xj = V[j], dy = y - V[j + 1];\n    const dx = x - xj, r1 = dx * dx + dy * dy, ex = x + xj, r2 = ex * ex + dy * dy;\n    o[2 * k] = G * (dy / r1 - dy / r2);\n    o[2 * k + 1] = G * (0.5 / x - dx / r1 + ex / r2);\n  }\n}\nfunction vstep(V, h) {\n  vvel(V, K1);\n  for (let i = 0; i \u003c 4; i++) TV[i] = V[i] + 0.5 * h * K1[i];\n  vvel(TV, K2);\n  for (let i = 0; i \u003c 4; i++) TV[i] = V[i] + 0.5 * h * K2[i];\n  vvel(TV, K3);\n  for (let i = 0; i \u003c 4; i++) TV[i] = V[i] + h * K3[i];\n  vvel(TV, K4);\n  for (let i = 0; i \u003c 4; i++) V[i] += (h / 6) * (K1[i] + 2 * K2[i] + 2 * K3[i] + K4[i]);\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  params.s = {\n    V: new Float64Array(4), V0: new Float64Array(4), Vm: new Float64Array(4),\n    yc: 0, ratio: -1, want: 3, wait: 0, go: 0, gain: 1,\n    hue: -1, dye: 0.06, d2: 4, nact: NPR,\n    px: F(2 * NPR), py: F(2 * NPR), age: F(2 * NPR), life: F(2 * NPR), pt: [0, 0], pp: [0, 0],\n    M: F(2 * N), M2: F(2 * N), DA: F(N), DB: F(N), col: F(6),\n  };\n}\n\n// Dye. Each ring has NL particles that are laid as straight lines across\n// its core, half of them every PULSE seconds, so each line lives two pulses\n// and winds into a spiral, the inside turning faster than the outside. The\n// rest fill the ring's bubble of water; what the rings shed of it trails\n// behind as the wake, and comes back into a bubble when it leaves the panel.\nconst NL = 360, CL = NL / 2, PULSE = 1.3;\nfunction line(S, k) {\n  const V = S.V, a = V[2 * k], R = 0.62 * a, th = rnd() * PI, c = cos(th), s = sin(th), par = (S.pp[k] ^= 1);\n  for (let m = 0; m \u003c CL; m++) {\n    const i = k * NPR + 2 * m + par, r = R * (((m + 0.5) / CL) * 2 - 1);\n    S.px[i] = abs(a + r * c);\n    S.py[i] = V[2 * k + 1] + r * s;\n    S.age[i] = 0;\n    S.life[i] = 2 * PULSE;\n  }\n}\nfunction bubble(S, i, spread) {\n  const k = i \u003c NPR ? 0 : 1, V = S.V, a = V[2 * k];\n  let x, y;\n  do (x = rnd()), (y = 2 * rnd() - 1);\n  while (x * x + y * y > 1);\n  S.px[i] = 1.5 * a * x;\n  S.py[i] = V[2 * k + 1] + 1.8 * a * y;\n  S.age[i] = spread ? -0.5 * rnd() : 0;\n  S.life[i] = 9 + 12 * rnd();\n}\n\n// A fresh pair: level with the small ring inside the big one, then run\n// backwards until the small one is furthest behind (or LIM / 2 behind, if\n// they would part for good), so it shrinks and darts through first.\nfunction launch(S, ratio) {\n  const V = S.V;\n  V[0] = A, V[1] = 0, V[2] = A / ratio, V[3] = 0;\n  let last = 0;\n  for (let t = 0; t \u003c 60; t += HV * 4) {\n    vstep(V, -HV * 4);\n    const sep = abs(V[1] - V[3]);\n    if (sep \u003c last || sep > LIM * 0.42) break;\n    last = sep;\n  }\n  const m = (V[1] + V[3]) / 2;\n  V[1] += S.yc - m, V[3] += S.yc - m;\n  S.ratio = ratio;\n  fresh(S);\n  // A second and a bit, so the first lines are already spirals.\n  for (let i = 0; i \u003c 70; i++) advance(S, HD);\n}\n\nfunction fresh(S) {\n  for (let k = 0; k \u003c 2; k++) {\n    S.pt[k] = PULSE * (0.5 + 0.5 * k);\n    S.age.fill(9, k * NPR, k * NPR + NL);\n    line(S, k);\n    for (let i = k * NPR + NL; i \u003c (k + 1) * NPR; i++) bubble(S, i, 1);\n  }\n}\n\n// Velocity of the water at (x, y), each core a disc of radius sqrt(d2)\n// turning as a solid body; outside it the same as a point vortex.\nlet U = 0, VY = 0;\nfunction flow(x, y, V, d2) {\n  let u = 0, v = 0;\n  for (let k = 0; k \u003c 4; k += 2) {\n    const xk = V[k], dy = y - V[k + 1], dx = x - xk, ex = x + xk;\n    let r = dx * dx + dy * dy;\n    if (r \u003c d2) r = d2;\n    let q = ex * ex + dy * dy;\n    if (q \u003c d2) q = d2;\n    u += dy / r - dy / q;\n    v += ex / q - dx / r;\n  }\n  U = G * u;\n  VY = G * v;\n}\n\nfunction advance(S, h) {\n  const { V, V0, Vm, px, py, age, life, nact, d2 } = S;\n  V0.set(V);\n  const n = Math.max(1, Math.round(h / 2 / HV)), hv = h / 2 / n;\n  for (let i = 0; i \u003c n; i++) vstep(V, hv);\n  Vm.set(V);\n  for (let i = 0; i \u003c n; i++) vstep(V, hv);\n  for (let k = 0; k \u003c 2; k++) if ((S.pt[k] -= h) \u003c= 0) (S.pt[k] += PULSE), line(S, k);\n  for (let i = 0; i \u003c 2 * NPR; i++) {\n    const j = i \u003c NPR ? i : i - NPR;\n    if (j >= nact) continue;\n    if (j >= NL && ((age[i] += h) > life[i] || py[i] \u003c S.yc + ROW - H - 3 || px[i] > 36)) {\n      bubble(S, i, 0);\n      continue;\n    }\n    if (j \u003c NL) age[i] += h;\n    const x = px[i], y = py[i];\n    flow(x, y, V0, d2);\n    const u1 = U, v1 = VY;\n    flow(x + 0.5 * h * u1, y + 0.5 * h * v1, Vm, d2);\n    const u2 = U, v2 = VY;\n    flow(x + 0.5 * h * u2, y + 0.5 * h * v2, Vm, d2);\n    const u3 = U, v3 = VY;\n    flow(x + h * u3, y + h * v3, V, d2);\n    px[i] = abs(x + (h / 6) * (u1 + 2 * u2 + 2 * u3 + U));\n    py[i] = y + (h / 6) * (v1 + 2 * v2 + 2 * v3 + VY);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3), want = cl(k[2], 3, 8);\n  S.dye = cl(k[3], 0, 1);\n  S.nact = NL + Math.round((NPR - NL) * (0.25 + 0.75 * S.dye));\n  if (S.ratio \u003c 0) launch(S, want), (S.want = want);\n  if (abs(want - S.want) > 0.01) (S.want = want), (S.wait = 0.3);\n  if (S.wait > 0 && (S.wait -= d) \u003c= 0 && !S.go) S.go = 0.5;\n  const p = input.btnPressed || [];\n  if (p[0]) fresh(S);\n  // Rings that have parted beyond the panel make way for a fresh pair.\n  if (!S.go && abs(S.V[1] - S.V[3]) > LIM) S.go = 0.5;\n  if (S.go) {\n    S.gain = S.go / 0.5;\n    if ((S.go -= d) \u003c= 0) (S.go = 0), launch(S, S.want), (S.gain = 0);\n  } else S.gain = min(1, S.gain + d / 0.5);\n  const h = (d * sp) / 2, n = Math.ceil(h / HD - 1e-9);\n  // Heights are kept within a few thousand LEDs of the start.\n  if (S.yc > 4096) {\n    (S.V[1] -= 4096), (S.V[3] -= 4096), (S.yc -= 4096);\n    for (let i = 0; i \u003c 2 * NPR; i++) S.py[i] -= 4096;\n    for (let i = 1; i \u003c 2 * N; i += 2) S.M[i] -= 4096;\n  }\n  const yc0 = S.yc;\n  if (!S.mset) {\n    S.mset = 1;\n    for (let j = 0; j \u003c H; j++) for (let i = 0; i \u003c W; i++) (S.M[2 * (j * W + i)] = i - 31.5), (S.M[2 * (j * W + i) + 1] = yc0 + ROW - j - 0.5);\n  }\n  for (let i = 0; i \u003c n; i++) advance(S, h / n);\n  S.yc = (S.V[1] + S.V[3]) / 2;\n  water(S, h, yc0);\n}\n\n// The water carries fine glitter that catches the light sheet, too faint to\n// light an LED. Each LED keeps the place its water came from (M), carried\n// back along the flow every frame, and shows the glitter of that place, so\n// still water slides down past the rings and the water they carry turns.\nfunction water(S, h, yc0) {\n  const { V, M, M2, d2 } = S;\n  for (let j = 0; j \u003c H; j++) {\n    const y = S.yc + ROW - j - 0.5;\n    for (let i = 32; i \u003c W; i++) {\n      const x = i - 31.5;\n      flow(x, y, V, d2);\n      for (let s = 0; s \u003c 2; s++) {\n        const X = s ? -x : x, u = s ? -U : U, xb = X - h * u, yb = y - h * VY;\n        const fx = xb + 31.5, fy = yc0 + ROW - yb - 0.5, o = 2 * (j * W + (s ? 63 - i : i));\n        if (fx \u003c 0 || fx > W - 1 || fy \u003c 0 || fy > H - 1) {\n          M2[o] = xb, M2[o + 1] = yb;\n          continue;\n        }\n        const ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy, q = 2 * (iy * W + ix), q2 = q + (ix \u003c W - 1 ? 2 : 0), q3 = q + (iy \u003c H - 1 ? 2 * W : 0), q4 = q3 + (ix \u003c W - 1 ? 2 : 0);\n        for (let c = 0; c \u003c 2; c++) M2[o + c] = (M[q + c] * (1 - ax) + M[q2 + c] * ax) * (1 - ay) + (M[q3 + c] * (1 - ax) + M[q4 + c] * ax) * ay;\n      }\n    }\n  }\n  S.M = M2, S.M2 = M;\n}\n\nfunction splat(D, x, y, w) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy);\n  if (ix \u003c -1 || ix >= W || iy \u003c -1 || iy >= H) return;\n  const ax = fx - ix, ay = fy - iy;\n  if (iy >= 0) {\n    if (ix >= 0) D[iy * W + ix] += w * (1 - ax) * (1 - ay);\n    if (ix \u003c W - 1) D[iy * W + ix + 1] += w * ax * (1 - ay);\n  }\n  if (iy \u003c H - 1) {\n    if (ix >= 0) D[(iy + 1) * W + ix] += w * (1 - ax) * ay;\n    if (ix \u003c W - 1) D[(iy + 1) * W + ix + 1] += w * ax * ay;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.ratio \u003c 0) return;\n  const { px, py, age, life, DA, DB, col, M, nact } = S;\n  hsv(S.hue + 0.4, 0.55, 1, col, 0);\n  hsv(S.hue + 0.86, 0.5, 1, col, 3);\n  DA.fill(0), DB.fill(0);\n  for (let i = 0; i \u003c 2 * NPR; i++) {\n    const j = i \u003c NPR ? i : i - NPR;\n    if (j >= nact) continue;\n    const a = age[i], w = (j \u003c NL ? min(1, a / 0.5, (life[i] - a) / 0.6) : 0.22 * min(1, a / 0.5, (life[i] - a) / 2)) * min(1, 0.5 + px[i]);\n    if (w \u003c= 0) continue;\n    const y = ROW + S.yc - py[i], D = i \u003c NPR ? DA : DB;\n    splat(D, 32 + px[i], y, w), splat(D, 32 - px[i], y, w);\n  }\n  const gain = S.gain, cA0 = col[0], cA1 = col[1], cA2 = col[2], cB0 = col[3], cB1 = col[4], cB2 = col[5];\n  for (let p = 0; p \u003c N; p++) {\n    // The glitter of the water this LED shows, never past 24, and a fixed\n    // flicker of a level or two per LED under it.\n    const g = h32(floor(M[2 * p] + 64), floor(M[2 * p + 1]) & 4095), q = JIT[p];\n    let r = (((g & 31) * 22) >> 5) + (q & 3), gg = ((((g >> 5) & 31) * 22) >> 5) + ((q >> 2) & 3), b = ((((g >> 10) & 31) * 22) >> 5) + ((q >> 4) & 3);\n    const a = DA[p], c = DB[p], s = a + c;\n    if (s > 0.01) {\n      const D = gain * (1 - exp(-s / S0)), u = a / s, c0 = cB0 + (cA0 - cB0) * u, c1 = cB1 + (cA1 - cB1) * u, c2 = cB2 + (cA2 - cB2) * u;\n      if (D \u003c D0) {\n        // Thin dye is a haze in the water that stays under the LEDs' threshold.\n        const t = (0.7 * D) / D0;\n        (r += (24 * c0 - r) * t), (gg += (24 * c1 - gg) * t), (b += (24 * c2 - b) * t);\n      } else {\n        const v = 28 + 227 * ((D - D0) / (1 - D0)) ** 0.45, e = 2.4;\n        (r = v * c0 + (r - 12) * e), (gg = v * c1 + (gg - 12) * e), (b = v * c2 + (b - 12) * e);\n      }\n    }\n    display.setPixel(p & 63, p >> 6, cl(r, 0, 255) | 0, cl(gg, 0, 255) | 0, cl(b, 0, 255) | 0);\n  }\n}\n","max-flow-min-cut":"// ===== Patternflow pattern =====\n// Title:   Max-Flow Min-Cut\n// Family:  algo\n// Idea:    A triangular network of pipes, the wide ones holding more, runs from a source bar along the bottom to a sink bar along the top; pulses climb it one shortest augmenting path at a time and fill the pipes cyan until the full ones turn gold, then the nodes the source can still reach fill in as a pool that stops at a jagged line, and the full pipes crossing that line flash while the sink bar splits into their capacities, which add up to exactly the flow that got through.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: max-flow min-cut theorem (Lester R. Ford Jr. and Delbert R. Fulkerson, 1956; Peter Elias, Amiel Feinstein and Claude Shannon, 1956), augmenting along shortest paths (Yefim Dinitz, 1970; Jack Edmonds and Richard Karp, 1972), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Columns=7..13, Grain=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the empty pipes are steel blue, flow is cyan, a full pipe is gold and the cut flashes between gold and pale pink. The dim colours, the empty pipes and the pool, lose their saturation between red and lime so they never go brown or olive.\n// Knob 2: Speed. At 2 a pulse climbs the panel in a second, the augmenting paths start one after another for five seconds, and a whole run from the first pulse to the next network takes eleven; at 0.2 ten times as long, at 3 two thirds as long.\n// Knob 3: Columns. The network is 7 to 13 nodes wide in a triangular lattice: 15 rows, 98 nodes and 251 pipes at 7, and 28 rows, 350 nodes and 970 pipes at 13. Turning it builds a new network.\n// Knob 4: Grain. How much of each pipe's capacity is its own random draw rather than the smooth terrain with its wavy band of thin pipes. Near 0 neighbouring pipes hold about the same and the cut follows the band; at 1 the capacities scatter pipe by pipe from 1 to 9, a quarter of them 9 and an eighth 1, and the cut wanders. Turning it drains the flow and runs the same network again on the new capacities.\n// Buttons: K1 tap draws new capacities now.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// 1 at the middle of the arc of the wheel from red through orange and\n// yellow to lime, 0 outside it.\nconst warm = (h) => ((h -= floor(h)), h \u003c 0.3 ? sin((PI * h) / 0.3) : 0);\n// Rows of nodes run from y = BOT up to y = TOP; the source bar is the two\n// bottom rows of LEDs and the sink bar the two top rows.\nconst TOP = 6, BOT = 121, SRC_Y = 126.5, SINK_Y = 0.5;\n// Pulse speed in LEDs per unit of time (Speed 2 runs two units a second).\nconst V = 70;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The lattice: rows of C and C - 1 nodes in turn, each node tied to its\n// neighbours in the row and to the two nearest in the rows above and below.\nfunction build(s, C) {\n  const sx = W / C, R = max(4, round((BOT - TOP) / (sx * 0.87)) + 1), sy = (BOT - TOP) / (R - 1);\n  const X = [], Y = [], rows = [];\n  for (let r = 0; r \u003c R; r++) {\n    const odd = r & 1, cnt = odd ? C - 1 : C, ids = [];\n    for (let i = 0; i \u003c cnt; i++) {\n      let x = 31.5 + sx * (i - (cnt - 1) / 2), y = BOT - r * sy;\n      if (r > 0 && r \u003c R - 1) y += (Math.random() - 0.5) * 0.34 * sy;\n      x += (Math.random() - 0.5) * 0.34 * sx;\n      ids.push(X.length);\n      X.push(cl(x, 0.5, 62.5));\n      Y.push(y);\n    }\n    rows.push(ids);\n  }\n  const eu = [], ev = [];\n  for (let r = 0; r \u003c R; r++) {\n    const a = rows[r];\n    for (let i = 0; i + 1 \u003c a.length; i++) eu.push(a[i]), ev.push(a[i + 1]);\n    if (r + 1 \u003c R) {\n      const b = rows[r + 1];\n      for (let i = 0; i \u003c a.length; i++)\n        for (const j of r & 1 ? [i, i + 1] : [i - 1, i]) if (j >= 0 && j \u003c b.length) eu.push(a[i]), ev.push(b[j]);\n    }\n  }\n  const n = X.length, m = eu.length;\n  const deg = new Int32Array(n + 1);\n  for (let k = 0; k \u003c m; k++) deg[eu[k] + 1]++, deg[ev[k] + 1]++;\n  for (let i = 0; i \u003c n; i++) deg[i + 1] += deg[i];\n  const adjE = new Int32Array(2 * m), fill = deg.slice(0, n);\n  for (let k = 0; k \u003c m; k++) (adjE[fill[eu[k]]++] = k), (adjE[fill[ev[k]]++] = k);\n  // Each pipe's samples, one per LED along its longer axis: the LED on that\n  // axis (sb), where the line crosses the other axis (sm), the step to the\n  // next LED across (ss), and the share of the way from eu to ev (tt).\n  const sb = [], sm = [], ss = [], tt = [], off = new Int32Array(m + 1);\n  for (let k = 0; k \u003c m; k++) {\n    const x1 = X[eu[k]], y1 = Y[eu[k]], dx = X[ev[k]] - x1, dy = Y[ev[k]] - y1, flat = abs(dx) >= abs(dy);\n    const steps = max(2, Math.ceil(max(abs(dx), abs(dy))));\n    for (let j = 1; j \u003c steps; j++) {\n      const t = j / steps, px = x1 + dx * t, py = y1 + dy * t;\n      sb.push(flat ? round(px) : round(py) * W);\n      sm.push(flat ? py : px);\n      ss.push(flat ? W : 1);\n      tt.push(t);\n    }\n    off[k + 1] = sb.length;\n  }\n  // The node nearest each LED, for the pool the source can reach.\n  const near = new Int16Array(N);\n  for (let p = 0; p \u003c N; p++) {\n    const px = p % W, py = (p / W) | 0;\n    let best = 1e9, bi = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const d = (X[i] - px) ** 2 + (Y[i] - py) ** 2;\n      if (d \u003c best) (best = d), (bi = i);\n    }\n    near[p] = bi;\n  }\n  const isBot = new Uint8Array(n), isTop = new Uint8Array(n);\n  for (const i of rows[0]) isBot[i] = 1;\n  for (const i of rows[R - 1]) isTop[i] = 1;\n  Object.assign(s, {\n    C, n, m, X: Float32Array.from(X), Y: Float32Array.from(Y), eu: Int32Array.from(eu), ev: Int32Array.from(ev),\n    deg, adjE, sb: Int32Array.from(sb), sm: Float32Array.from(sm), ss: Int32Array.from(ss), tt: Float32Array.from(tt), off, near,\n    bottom: Int32Array.from(rows[0]), isBot, isTop,\n    g: new Float32Array(m), e: new Float32Array(m), cap: new Int32Array(m), flow: new Int32Array(m), dcap: new Float32Array(m), dcap0: new Float32Array(m),\n    dflow: new Float32Array(m), dflow0: new Float32Array(m), inS: new Uint8Array(n), level: new Int32Array(n), vS: new Uint8Array(n), vLevel: new Int32Array(n),\n    dist: new Int32Array(n), prevE: new Int32Array(n), queue: new Int32Array(n), cut: new Uint8Array(m),\n  });\n}\n\n// Fresh random capacities. Each pipe gets a share g from a smooth terrain\n// of a few broad waves, cut by a wavy band of thin pipes somewhere across\n// the middle and thickened near the two bars, and a draw of its own, e.\nfunction drawField(s) {\n  const w = [];\n  for (let i = 0; i \u003c 3; i++) w.push([TAU * Math.random(), (0.03 + 0.07 * Math.random()) * (Math.random() \u003c 0.5 ? -1 : 1), 0.02 + 0.05 * Math.random()]);\n  const yc = 44 + 40 * Math.random(), A = 5 + 11 * Math.random(), fx = (TAU * (0.6 + Math.random())) / W, ph = TAU * Math.random(), bw = 7 + 5 * Math.random();\n  for (let k = 0; k \u003c s.m; k++) {\n    const x = (s.X[s.eu[k]] + s.X[s.ev[k]]) / 2, y = (s.Y[s.eu[k]] + s.Y[s.ev[k]]) / 2;\n    let f = 0;\n    for (const [a, ax, ay] of w) f += sin(a + ax * x + ay * y) / 3;\n    const band = Math.exp(-(((y - yc - A * sin(fx * x + ph)) / bw) ** 2)), bar = cl(1 - min(y - TOP, BOT - y) / 18, 0, 1);\n    s.g[k] = 0.6 + 0.3 * f - 0.5 * band + 0.3 * bar;\n    s.e[k] = Math.random() - 0.5;\n  }\n}\n\nfunction capacities(s, grain) {\n  const a = 0.25 + 1.1 * grain;\n  for (let k = 0; k \u003c s.m; k++) s.cap[k] = cl(round(1 + 8 * (s.g[k] + a * s.e[k])), 1, 9);\n}\n\n// Residual capacity of pipe k leaving node u.\nconst resid = (s, k, u) => (s.eu[k] === u ? s.cap[k] - s.flow[k] : s.cap[k] + s.flow[k]);\n\n// Breadth-first search from every bottom node at once over pipes with room\n// left. Returns the first top node reached, or -1 once the sink is cut off;\n// dist then marks the nodes the source still reaches.\nfunction bfs(s) {\n  const { dist, prevE, queue, bottom, adjE, deg, eu, ev, isTop } = s;\n  dist.fill(-1);\n  let h = 0, t = 0;\n  // The bottom nodes enter the queue in a new order each search.\n  for (const b of bottom) {\n    const j = floor(Math.random() * (t + 1));\n    queue[t++] = queue[j];\n    queue[j] = b;\n  }\n  for (let i = 0; i \u003c t; i++) (dist[queue[i]] = 0), (prevE[queue[i]] = -1);\n  while (h \u003c t) {\n    const u = queue[h++];\n    if (isTop[u]) return u;\n    for (let j = deg[u]; j \u003c deg[u + 1]; j++) {\n      const k = adjE[j], v = eu[k] === u ? ev[k] : eu[k];\n      if (dist[v] \u003c 0 && resid(s, k, u) > 0) (dist[v] = dist[u] + 1), (prevE[v] = k), (queue[t++] = v);\n    }\n  }\n  return -1;\n}\n\n// Edmonds-Karp: augment along a shortest path until none is left, keeping\n// every path for the pulses; then read the cut off the last search.\nfunction solve(s) {\n  const { eu, ev, adjE, deg, flow } = s;\n  flow.fill(0);\n  // Shuffle each node's pipes so ties between shortest paths fall anywhere.\n  for (let u = 0; u \u003c s.n; u++)\n    for (let j = deg[u + 1] - 1; j > deg[u]; j--) {\n      const r = deg[u] + floor(Math.random() * (j - deg[u] + 1)), x = adjE[j];\n      (adjE[j] = adjE[r]), (adjE[r] = x);\n    }\n  s.paths = [];\n  s.F = 0;\n  for (let top; (top = bfs(s)) >= 0; ) {\n    const nodes = [top], ks = [];\n    let d = 1e9;\n    for (let v = top; s.prevE[v] >= 0; ) {\n      const k = s.prevE[v], u = eu[k] === v ? ev[k] : eu[k];\n      d = min(d, resid(s, k, u));\n      ks.push(k);\n      nodes.push(u);\n      v = u;\n    }\n    nodes.reverse();\n    ks.reverse();\n    const sg = new Int8Array(ks.length);\n    ks.forEach((k, i) => {\n      sg[i] = eu[k] === nodes[i] ? 1 : -1;\n      flow[k] += sg[i] * d;\n    });\n    // The pulse's way: up from the source bar, along the path, into the sink bar.\n    const pts = [s.X[nodes[0]], SRC_Y];\n    for (const v of nodes) pts.push(s.X[v], s.Y[v]);\n    pts.push(s.X[top], SINK_Y);\n    const cum = new Float32Array(pts.length / 2);\n    for (let i = 1; i \u003c cum.length; i++) cum[i] = cum[i - 1] + Math.hypot(pts[2 * i] - pts[2 * i - 2], pts[2 * i + 1] - pts[2 * i - 1]);\n    s.paths.push({ pts, cum, ks, sg, d, j: 0 });\n    s.F += d;\n  }\n  // The last search found no top node: what it reached is the source's side.\n  let lv = 0;\n  for (let i = 0; i \u003c s.n; i++) (s.inS[i] = s.dist[i] >= 0 ? 1 : 0), (s.level[i] = s.dist[i]), (lv = max(lv, s.dist[i]));\n  s.maxLevel = lv;\n  s.cutCap = 0;\n  s.cutList = [];\n  for (let k = 0; k \u003c s.m; k++) {\n    s.cut[k] = s.inS[eu[k]] !== s.inS[ev[k]] ? 1 : 0;\n    if (s.cut[k]) (s.cutCap += s.cap[k]), s.cutList.push(k);\n  }\n  // Left to right, for the pieces of the sink bar.\n  s.cutList.sort((a, b) => s.X[eu[a]] + s.X[ev[a]] - s.X[eu[b]] - s.X[ev[b]]);\n  const P = s.paths.length;\n  s.gap = cl(10 / max(1, P), 0.15, 0.9);\n  s.paths.forEach((p, i) => (p.t0 = i * s.gap));\n  s.flowEnd = P ? (P - 1) * s.gap + s.paths[P - 1].cum[s.paths[P - 1].cum.length - 1] / V : 0;\n  s.arrived = 0;\n}\n\n// A new run: capacities from the current field, the flow drained from what\n// the panel shows over DRAIN units while the pipes take their new widths.\nconst DRAIN = 2, REVEAL = 2.5, HOLD = 5;\nfunction restart(s, fresh) {\n  if (fresh) drawField(s);\n  capacities(s, s.k4);\n  solve(s);\n  s.dcap0.set(s.dcap);\n  s.dflow0.set(s.dflow);\n  s.glow0 = s.glow;\n  s.phase = 1;\n  s.pt = 0;\n}\n\nexport function setup(params) {\n  // The network itself is built on the first update, from the knobs.\n  params.s = { C: 0, t: 0, hue: 0, k4: 0.06, glow: 0, glow0: 0, phase: 2, pt: 0, rgb: new Float32Array(N * 3), col: new Float32Array(15) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3);\n  s.hue = cl(k[0], 0, 1);\n  const C = round(cl(k[2], 7, 13)), k4 = cl(k[3], 0, 1);\n  if (C !== s.C) {\n    build(s, C);\n    s.k4 = k4;\n    drawField(s);\n    capacities(s, s.k4);\n    solve(s);\n    s.dcap.set(s.cap);\n    s.glow = 0;\n    s.phase = 2;\n    s.pt = 0;\n  } else if (abs(k4 - s.k4) > 0.004) {\n    s.k4 = k4;\n    restart(s, false);\n  }\n  if (input.btnPressed && input.btnPressed[0]) restart(s, true);\n  s.t += d;\n  s.pt += d;\n  if (s.phase === 1) {\n    // Drain: flow and pool fade, capacities ease to the new ones.\n    const e = cl(s.pt / DRAIN, 0, 1), q = e * e * (3 - 2 * e);\n    for (let i = 0; i \u003c s.m; i++) (s.dcap[i] = s.dcap0[i] + (s.cap[i] - s.dcap0[i]) * q), (s.dflow[i] = s.dflow0[i] * (1 - q));\n    s.glow = s.glow0 * (1 - q);\n    if (e >= 1) (s.phase = 2), (s.pt = 0), s.dflow.fill(0), s.dcap.set(s.cap);\n  } else if (s.phase === 2) {\n    // Augment: as a pulse's head passes the end of a pipe, the pipe takes its flow.\n    for (const p of s.paths) {\n      const dist = (s.pt - p.t0) * V;\n      while (p.j \u003c p.ks.length && dist >= p.cum[p.j + 2]) {\n        s.dflow[p.ks[p.j]] += p.sg[p.j] * p.d;\n        p.j++;\n      }\n      if (!p.done && dist >= p.cum[p.cum.length - 1]) (p.done = 1), (s.arrived += p.d);\n    }\n    // Every path is in: show the side the source still reaches, kept apart\n    // so the next run's search does not move the pool while it fades.\n    if (s.pt > s.flowEnd + 0.4) (s.phase = 3), (s.pt = 0), s.vS.set(s.inS), s.vLevel.set(s.level);\n  } else if (s.phase === 3) {\n    s.glow = 1;\n    if (s.pt > REVEAL + HOLD) restart(s, true);\n  }\n}\n\n// Brightest-wins write, so pipes meeting at a node do not pile up.\nfunction put(rgb, p, r, g, b) {\n  const o = p * 3;\n  if (r > rgb[o]) rgb[o] = r;\n  if (g > rgb[o + 1]) rgb[o + 1] = g;\n  if (b > rgb[o + 2]) rgb[o + 2] = b;\n}\nfunction add(rgb, x, y, r, g, b, w) {\n  const xi = round(x), yi = round(y);\n  if (xi \u003c 0 || xi >= W || yi \u003c 0 || yi >= H) return;\n  const o = (yi * W + xi) * 3;\n  rgb[o] += r * w;\n  rgb[o + 1] += g * w;\n  rgb[o + 2] += b * w;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.C) return;\n  const { rgb, col, n, m, eu, ev, sb, sm, ss, tt, off, dcap, dflow, near, vS, vLevel } = s;\n  rgb.fill(0);\n  const hb = s.hue + 0.5;\n  // The dim colours lose their saturation near orange and yellow, which\n  // read brown and olive on the panel when dim.\n  hsv(hb + 0.08, 0.45 * (1 - 0.85 * warm(hb + 0.08)), 1, col, 0); // empty pipe\n  hsv(hb, 0.8, 1, col, 3); // flow\n  hsv(hb + 0.62, 0.78, 1, col, 6); // full pipe\n  hsv(hb + 0.4, 0.45, 1, col, 9); // cut flash\n  hsv(hb, 0.8 * (1 - 0.8 * warm(hb)), 1, col, 12); // pool\n  // The pool: LEDs whose nearest node the source still reaches, rising by\n  // search level, with its rim (the cut line, a path in the dual) brighter.\n  const reveal = s.phase === 3 ? (s.pt / REVEAL) * (s.maxLevel + 2) : s.phase === 1 ? 1e9 : -1;\n  if (s.glow > 0.01 && reveal >= 0) {\n    for (let p = 0; p \u003c N; p++) {\n      const i = near[p];\n      if (!vS[i]) continue;\n      const a = cl(reveal - vLevel[i], 0, 1) * s.glow;\n      if (a \u003c= 0) continue;\n      const x = p % W, y = (p / W) | 0;\n      const rim = (y > 0 && !vS[near[p - W]]) || (x > 0 && !vS[near[p - 1]]) || (x \u003c W - 1 && !vS[near[p + 1]]);\n      const v = (rim ? 110 : 34) * a;\n      put(rgb, p, col[12] * v, col[13] * v, col[14] * v);\n    }\n  }\n  const hold = s.phase === 3 ? cl((s.pt - REVEAL) / 0.4, 0, 1) : 0;\n  const flash = 0.5 + 0.5 * sin(s.t * 7), wf = warm(hb);\n  for (let k = 0; k \u003c m; k++) {\n    const cap = max(dcap[k], 0.01), r = min(1, abs(dflow[k]) / cap), cf = cap / 9;\n    // A pipe's width and brightness both grow with its capacity.\n    let wd = 0.6 + cf;\n    const v0 = 0.1 + 0.36 * cf * sqrt(cf);\n    let cr = col[0] * v0, cg = col[1] * v0, cb = col[2] * v0;\n    if (r > 0.999) {\n      cr = col[6];\n      cg = col[7];\n      cb = col[8];\n      // Once the cut is found, full pipes off it go back to the flow colour.\n      if (!s.cut[k] && hold > 0) {\n        cr += (col[3] * 0.8 - cr) * hold;\n        cg += (col[4] * 0.8 - cg) * hold;\n        cb += (col[5] * 0.8 - cb) * hold;\n      } else if (hold > 0) {\n        const f = hold * flash;\n        cr += (col[9] - cr) * f;\n        cg += (col[10] - cg) * f;\n        cb += (col[11] - cb) * f;\n        wd += hold * (0.6 + 0.6 * flash);\n      }\n    } else if (r > 0) {\n      // Part full: brighter with its share, and lifted near yellow.\n      const v = 0.45 + 0.4 * r + 0.25 * (1 - r) * wf, a = 0.4 + 0.6 * r;\n      cr += (col[3] * v - cr) * a;\n      cg += (col[4] * v - cg) * a;\n      cb += (col[5] * v - cb) * a;\n    }\n    // Flow runs along the pipe as faint ripples from the side it comes from.\n    const dir = dflow[k] > 0 ? 1 : -1, wave = r > 0 && r \u003c 0.999 ? 0.25 : 0, hw = wd / 2;\n    const len = Math.hypot(s.X[ev[k]] - s.X[eu[k]], s.Y[ev[k]] - s.Y[eu[k]]);\n    for (let j = off[k]; j \u003c off[k + 1]; j++) {\n      const w0 = (1 - wave + wave * sin(TAU * ((dir * tt[j] * len) / 5 - s.t * 0.9))) * 255;\n      const c = sm[j], top = ss[j] === W ? H : W;\n      for (let i = max(0, Math.ceil(c - hw - 0.5)); i \u003c= min(top - 1, floor(c + hw + 0.5)); i++) {\n        const cover = min(i + 0.5, c + hw) - max(i - 0.5, c - hw);\n        if (cover > 0) put(rgb, sb[j] + i * ss[j], cr * cover * w0, cg * cover * w0, cb * cover * w0);\n      }\n    }\n  }\n  // Nodes.\n  for (let i = 0; i \u003c n; i++) {\n    const p = round(s.Y[i]) * W + round(s.X[i]);\n    const v = vS[i] && s.glow > 0 && reveal > vLevel[i] ? 200 : 120;\n    put(rgb, p, v * 0.9, v * 0.95, v);\n  }\n  // Pulses: a white head and a tail in the flow colour.\n  if (s.phase === 2)\n    for (const p of s.paths) {\n      const dist = (s.pt - p.t0) * V, L = p.cum[p.cum.length - 1];\n      if (dist \u003c 0 || dist > L + 12) continue;\n      let seg = 0;\n      for (let j = 0; j \u003c 14; j++) {\n        const dd = dist - j;\n        if (dd \u003c 0) break;\n        if (dd > L) continue;\n        while (seg + 1 \u003c p.cum.length - 1 && p.cum[seg + 1] \u003c dd) seg++;\n        while (seg > 0 && p.cum[seg] > dd) seg--;\n        const f = (dd - p.cum[seg]) / max(1e-6, p.cum[seg + 1] - p.cum[seg]);\n        const x = p.pts[2 * seg] + (p.pts[2 * seg + 2] - p.pts[2 * seg]) * f, y = p.pts[2 * seg + 1] + (p.pts[2 * seg + 3] - p.pts[2 * seg + 1]) * f;\n        if (j === 0) {\n          add(rgb, x, y, 255, 255, 255, 1);\n          for (const [ox, oy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) add(rgb, x + ox, y + oy, col[3], col[4], col[5], 140);\n        } else {\n          const w = (1 - j / 14) ** 2 * 230;\n          add(rgb, x, y, col[3], col[4], col[5], w);\n        }\n      }\n    }\n  // Source bar along the bottom, sink bar along the top. The sink bar lights\n  // from the middle out as the flow arrives; once the cut is found it splits\n  // into one piece per cut pipe, as wide as its share of the flow, and the\n  // pieces fill the bar exactly.\n  for (let x = 0; x \u003c W; x++) for (const y of [126, 127]) put(rgb, y * W + x, col[3] * 200, col[4] * 200, col[5] * 200);\n  const fill = s.phase === 2 ? s.arrived / max(1, s.F) : s.phase === 3 ? 1 : s.glow;\n  if (hold > 0) {\n    let x0 = 0;\n    s.cutList.forEach((k, i) => {\n      const x1 = x0 + (W * s.cap[k]) / s.F, c = i & 1 ? 6 : 9, a = i & 1 ? 0.9 : 0.55 + 0.45 * flash;\n      for (let x = round(x0); x \u003c round(x1); x++) for (const y of [0, 1]) put(rgb, y * W + x, col[c] * 230 * a, col[c + 1] * 230 * a, col[c + 2] * 230 * a);\n      x0 = x1;\n    });\n  } else\n    for (let x = 0; x \u003c W; x++) {\n      const v = abs(x - 31.5) \u003c fill * 32 ? 200 : 60;\n      for (const y of [0, 1]) put(rgb, y * W + x, col[3] * v, col[4] * v, col[5] * v);\n    }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, min(255, rgb[p * 3]), min(255, rgb[p * 3 + 1]), min(255, rgb[p * 3 + 2]));\n}\n","squared-rectangle":"// ===== Patternflow pattern =====\n// Title:   Squared Rectangle\n// Family:  cells\n// Idea:    A network of resistors between a top and a bottom pole is drawn the way Brooks, Smith, Stone and Tutte drew it, one tile per wire with the voltage drop for its height and the current for its width, so the tiles always fill one tall rectangle exactly while the conductances wander and stretch them, and every few seconds the conductances all come back to 1 and the tiling snaps into squares, with a new network now and then giving a new squared rectangle.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: squared rectangles from electrical networks (R. L. Brooks, C. A. B. Smith, A. H. Stone and W. T. Tutte, 1940), after Zbigniew Moroń's first squared rectangle (1925), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tiles=13..20, Wander=-1..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. A tile's colour comes from its size against the biggest and smallest tiles shown: at 0 the biggest is teal, the middling ones blue, violet and pink, and the smallest orange.\n// Knob 2: Speed. At 2 a cycle takes 8 seconds: the squares hold for 1.2, the conductances drift for 5.6, and the tiling snaps back into squares at the end of the eighth second with a flash on every seam. Every second cycle the network is rewired; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Tiles. How many wires the network has, so how many squares the snap shows, from 13 to 20. Rewiring keeps the count within one of the knob; at 16, 17 and 19 the first rectangle shown is perfect, every square a different size.\n// Knob 4: Wander. How far each conductance drifts from 1: within a factor of 1.4 at -1, 2 at the opening 0.06, and 4.5 at 1.\n// Buttons: K1 tap snaps the tiling into squares now.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, sin, sqrt, log, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\n\n// The network lives on a triangular lattice of 3 by 4 nodes, the top pole\n// above it wired to the first row and the bottom pole below wired to the\n// last. Positions only fix the order of the wires round each node, which\n// is all the drawing needs: the plane picture says which faces lie on\n// either side of a wire.\nconst CW = 3, RW = 4, NI = CW * RW, PS = NI, PT = NI + 1, NN = NI + 2;\nconst NX = [], NY = [];\nfor (let j = 0; j \u003c RW; j++) for (let i = 0; i \u003c CW; i++) NX.push(i + (j % 2) * 0.5), NY.push(-j * 0.866);\nNX.push(1.25, 1.25);\nNY.push(1.5, -(RW - 1) * 0.866 - 1.5);\nconst EU = [], EW = [];\nconst wire = (u, w) => (EU.push(u), EW.push(w));\nfor (let j = 0; j \u003c RW; j++)\n  for (let i = 0; i \u003c CW; i++) {\n    const p = j * CW + i, k = j % 2 ? i + 1 : i - 1;\n    if (i + 1 \u003c CW) wire(p, p + 1);\n    if (j + 1 \u003c RW) {\n      wire(p, p + CW);\n      if (k >= 0 && k \u003c CW) wire(p, (j + 1) * CW + k);\n    }\n  }\nfor (let i = 0; i \u003c CW; i++) wire(PS, i), wire((RW - 1) * CW + i, PT);\n// Wire NE is the battery, leaving the top pole upward and reaching the\n// bottom pole from below, round the outside.\nconst NE = EU.length;\n\n// Networks, one walk per Tiles setting from 13 to 20. Each is a set of\n// wires written as a bitmask in base 36, and two neighbours in a walk differ\n// by one or two wires. They were picked so that at conductance 1 no wire\n// carries zero current, the rectangle stands 1.75 to 2.35 times as tall as\n// it is wide and the smallest square is at least 4.5 LEDs. Walks 16, 17\n// and 19 open on perfect squared rectangles of orders 16, 17 and 19.\nconst WALKS = [\n  \"46p4dk 47xze0 47y2js 47y3ag 46qjoo 46qiy0 46npt4 46qiw8 46p548 46p554\",\n  \"46mus8 46pniw 46qyxk 46qzbk 464le8 46o9cg 46r0wg 46pmfk 46k060 46lemw\",\n  \"46pmfs 46pmcc 46k1ng 46musc 47vsyg 46o9co 46qzbs 464leg 46pnx4 46q0d4\",\n  \"6c9fh7 69sxp7 69sxln 6l1h5n 6l1h5m 6l02oq 6l2vtm 6jwqsa 6m3el6 6m3ehn\",\n  \"8k66kn 8hoa87 8hpop3 7xqhxr 808ea7 6catzj 6casf3 6c9dy7 69rj6n 69sxr2\",\n  \"5iz8d7 6cy0ij 6d287v 6dj317 6m9q8r 6ma2or 6jtkwr 6jxsm3 6juzkr 26jdsr\",\n  \"3syppz 3t02pj 3t02lz 3szwan 3t01tr 3t03en 3syou7 47y2wv 4cxvlq 4cxvlp\",\n  \"8glqwb 8gg4mz 8gg5f7 8gg5ff 8gg5fc 8gg3y0 7mhbso 4am77c 4am9ko 4am9kc\",\n].map((s) => s.split(\" \").map((w) => parseInt(w, 36)));\nconst has = (m, e) => floor(m / 2 ** e) % 2 === 1;\nconst apart = (a, b) => {\n  let d = 0;\n  for (let e = 0; e \u003c NE; e++) d += has(a, e) !== has(b, e);\n  return d;\n};\n\n// The plane structure of a set of wires: which nodes take part, and for\n// each wire the face on its left going from EU to EW (half 2e) and going\n// back (half 2e + 1). Faces are traced by turning clockwise at each node.\nfunction build(S, mask) {\n  const on = [];\n  for (let e = 0; e \u003c NE; e++) if (has(mask, e)) on.push(e);\n  const adj = [];\n  for (let u = 0; u \u003c NN; u++) adj.push([]);\n  for (const e of on) {\n    const u = EU[e], w = EW[e];\n    adj[u].push([atan2(NY[w] - NY[u], NX[w] - NX[u]), e, w]);\n    adj[w].push([atan2(NY[u] - NY[w], NX[u] - NX[w]), e, u]);\n  }\n  adj[PS].push([PI / 2, NE, PT]);\n  adj[PT].push([-PI / 2, NE, PS]);\n  for (const l of adj) l.sort((p, q) => p[0] - q[0]);\n  const half = (e, from) => 2 * e + (e === NE ? (from === PS ? 0 : 1) : from === EU[e] ? 0 : 1);\n  const face = new Int32Array(2 * NE + 2).fill(-1);\n  let nf = 0;\n  for (let u0 = 0; u0 \u003c NN; u0++)\n    for (const h0 of adj[u0]) {\n      if (face[half(h0[1], u0)] >= 0) continue;\n      let u = u0, h = h0;\n      while (face[half(h[1], u)] \u003c 0) {\n        face[half(h[1], u)] = nf;\n        const l = adj[h[2]];\n        let k = 0;\n        while (l[k][1] !== h[1]) k++;\n        u = h[2];\n        h = l[(k + l.length - 1) % l.length];\n      }\n      nf++;\n    }\n  // Unknown node potentials: the inner nodes some wire touches.\n  const idx = new Int32Array(NN).fill(-1);\n  let n = 0;\n  for (const e of on) for (const u of [EU[e], EW[e]]) if (u \u003c NI && idx[u] \u003c 0) idx[u] = n++;\n  // An order to fix the face potentials: across wire e the left face sits\n  // higher than the right by the current along it.\n  const known = new Uint8Array(nf), order = [];\n  known[face[2 * NE]] = 1;\n  for (let more = true; more; ) {\n    more = false;\n    for (const e of [...on, NE]) {\n      const a = face[2 * e], b = face[2 * e + 1];\n      if (known[a] && !known[b]) order.push([e, a, b, -1]), (known[b] = 1), (more = true);\n      else if (known[b] && !known[a]) order.push([e, b, a, 1]), (known[a] = 1), (more = true);\n    }\n  }\n  Object.assign(S, { on, face, nf, idx, n, order, phi: new Float64Array(nf) });\n}\n\n// Kirchhoff: solve for the node potentials with the top pole at 1 and the\n// bottom at 0, then lay every wire out as a tile.\nfunction solve(S) {\n  const { on, idx, n, c, v, cur, face, order, phi, tiles } = S;\n  const A = S.A;\n  for (let i = 0; i \u003c n; i++) A[i].fill(0, 0, n + 1);\n  for (const e of on) {\n    const g = c[e], u = EU[e], w = EW[e], iu = idx[u], iw = idx[w];\n    if (iu >= 0) {\n      A[iu][iu] += g;\n      if (iw >= 0) A[iu][iw] -= g;\n      else if (w === PS) A[iu][n] += g;\n    }\n    if (iw >= 0) {\n      A[iw][iw] += g;\n      if (iu >= 0) A[iw][iu] -= g;\n      else if (u === PS) A[iw][n] += g;\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    let p = i;\n    for (let k = i + 1; k \u003c n; k++) if (abs(A[k][i]) > abs(A[p][i])) p = k;\n    const t = A[i];\n    (A[i] = A[p]), (A[p] = t);\n    for (let k = i + 1; k \u003c n; k++) {\n      const f = A[k][i] / A[i][i];\n      if (f) for (let m = i; m \u003c= n; m++) A[k][m] -= f * A[i][m];\n    }\n  }\n  v.fill(0);\n  v[PS] = 1;\n  for (let i = n - 1; i >= 0; i--) {\n    let s = A[i][n];\n    for (let m = i + 1; m \u003c n; m++) s -= A[i][m] * S.x[m];\n    S.x[i] = s / A[i][i];\n  }\n  for (let u = 0; u \u003c NI; u++) if (idx[u] >= 0) v[u] = S.x[idx[u]];\n  let I = 0;\n  for (const e of on) {\n    cur[e] = c[e] * (v[EU[e]] - v[EW[e]]);\n    if (EU[e] === PS) I += cur[e];\n  }\n  cur[NE] = -I;\n  phi[face[2 * NE]] = 0;\n  for (const [e, a, b, s] of order) phi[b] = phi[a] + s * cur[e];\n  let lo = 0;\n  for (let f = 0; f \u003c S.nf; f++) lo = min(lo, phi[f]);\n  S.I = I;\n  tiles.length = 0;\n  for (const e of on) {\n    const a = phi[face[2 * e]] - lo, b = phi[face[2 * e + 1]] - lo, p = v[EU[e]], q = v[EW[e]];\n    tiles.push([e, min(a, b), max(a, b), 1 - max(p, q), 1 - min(p, q)]);\n  }\n}\n\n// Story seconds at Speed 2: squares hold, drift rises, drift, snap.\nconst HOLD = 1.2, RISE = 2.4, SETTLE = 6.8, CYCLE = 8, REWIRE = 3.4;\n\nexport function setup(params) {\n  const fq = [], ph = [];\n  for (let e = 0; e \u003c NE; e++) fq.push(0.35 + 0.5 * Math.random(), 0.8 + 0.7 * Math.random()), ph.push(6.3 * Math.random(), 6.3 * Math.random());\n  params.s = {\n    t: 0, tc: 0, cyc: 0, amp: 0, set0: SETTLE, setLen: CYCLE - SETTLE, setFrom: 1, flash: 1,\n    K: 0, walk: 0, step: 0, dir: 1, mask: 0, next: 0, ramp: -1, rate: 0,\n    hue: 0, speed: 2, wander: 0.06, fq, ph, drift: new Float64Array(NE + 1), c: new Float64Array(NE),\n    v: new Float64Array(NN), cur: new Float64Array(NE + 1), x: new Float64Array(NI), A: Array.from({ length: NI }, () => new Float64Array(NI + 1)),\n    tiles: [], I: 1, id: new Int16Array(W * H), stripe: new Float64Array(NE),\n  };\n}\n\nfunction rewire(S, to) {\n  S.next = to;\n  S.ramp = 0;\n  S.rate = 1 / 2.6;\n  build(S, S.mask | to);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 13, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wander = 0.7 * 2 ** (1.1 * cl(k[3], -1, 1));\n  const K = round(cl(k[2], 13, 20));\n  if (!S.K) {\n    S.K = K;\n    S.mask = WALKS[K - 13][0];\n    build(S, S.mask);\n  } else if (K !== S.K && S.ramp \u003c 0) {\n    // A new walk: go to its network nearest the one shown.\n    S.K = K;\n    const w = WALKS[K - 13];\n    let best = 0;\n    for (let i = 1; i \u003c w.length; i++) if (apart(w[i], S.mask) \u003c apart(w[best], S.mask)) best = i;\n    (S.step = best), (S.dir = best === w.length - 1 ? -1 : 1);\n    if (w[best] !== S.mask) rewire(S, w[best]);\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.flash *= exp(-d / 0.35);\n  const press = input.btnPressed && input.btnPressed[0];\n  if (press && S.tc > 0.15 && S.tc \u003c S.set0) {\n    // Snap now: settle from where the drift is in 0.4 seconds.\n    (S.setFrom = S.amp), (S.set0 = S.tc), (S.setLen = 0.4);\n    if (S.ramp >= 0) S.rate = max(S.rate, (1 - S.ramp) / 0.38);\n  }\n  S.tc += ds;\n  if (S.tc >= S.set0 + S.setLen) {\n    (S.tc = 0), S.cyc++, (S.flash = 1), (S.set0 = SETTLE), (S.setLen = CYCLE - SETTLE), (S.setFrom = 1);\n  }\n  const tc = S.tc;\n  S.amp = tc \u003c HOLD ? 0 : tc \u003c S.set0 ? (tc \u003c RISE ? sm((tc - HOLD) / (RISE - HOLD)) : 1) : S.setFrom * (1 - ((tc - S.set0) / S.setLen) ** 2);\n  // Every second cycle, one step along the walk.\n  if (S.ramp \u003c 0 && S.cyc % 2 === 1 && tc >= REWIRE && tc \u003c REWIRE + 0.5 && S.set0 === SETTLE) {\n    const w = WALKS[S.K - 13];\n    if (w.length > 1) {\n      if (S.step + S.dir \u003c 0 || S.step + S.dir >= w.length) S.dir = -S.dir;\n      S.step += S.dir;\n      rewire(S, w[S.step]);\n    }\n  }\n  if (S.ramp >= 0) {\n    S.ramp += ds * S.rate;\n    if (S.ramp >= 1) {\n      S.mask = S.next;\n      S.ramp = -1;\n      build(S, S.mask);\n    }\n  }\n  // Conductances: each wire drifts as exp(a n(t)), n a slow wave in -1..1.\n  const r = S.ramp \u003c 0 ? 1 : sm(S.ramp), a = S.amp * S.wander;\n  for (const e of S.on) {\n    const n = 0.6 * sin(S.fq[2 * e] * S.t + S.ph[2 * e]) + 0.4 * sin(S.fq[2 * e + 1] * S.t + S.ph[2 * e + 1]);\n    let g = a ? exp(a * n) : 1;\n    if (S.ramp >= 0) {\n      const was = has(S.mask, e), will = has(S.next, e);\n      if (was && !will) g *= 1 - r;\n      else if (will && !was) g *= r;\n    }\n    S.c[e] = max(g, 1e-9);\n    S.stripe[e] += ds * 9 * S.c[e];\n  }\n  solve(S);\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.tiles.length) return;\n  const { tiles, id, I } = S;\n  const sc = min(W / I, H), ox = (W - I * sc) / 2, oy = (H - sc) / 2;\n  id.fill(-1);\n  const col = [], top = [], q = [];\n  let qa = 1, qb = 0;\n  tiles.forEach((t, k) => {\n    const x0 = round(ox + t[1] * sc), x1 = round(ox + t[2] * sc), y0 = round(oy + t[3] * sc), y1 = round(oy + t[4] * sc);\n    for (let y = max(0, y0); y \u003c min(H, y1); y++) for (let x = max(0, x0); x \u003c min(W, x1); x++) id[y * W + x] = k;\n    // Size: the side of a square of the same area, against the width.\n    q.push(log(max(1e-6, sqrt((t[2] - t[1]) * (t[4] - t[3])) / I)));\n    if (x1 > x0 && y1 > y0) (qa = min(qa, q[k])), (qb = max(qb, q[k]));\n    top.push(y0 + S.stripe[t[0]]);\n  });\n  // Colour by size between the smallest and the biggest tile shown now.\n  tiles.forEach((t, k) => {\n    const u = cl((q[k] - qa) / max(0.3, qb - qa), 0, 1);\n    col.push(hsv(0.52 + S.hue + 0.55 * (1 - u), 0.85 - 0.1 * u, 0.62 + 0.38 * (1 - u)));\n  });\n  const fl = S.flash;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const k = id[p];\n      if (k \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const c = col[k];\n      // Seams on the left and top of each tile; the rectangle's own edge stays.\n      if ((x > 0 && id[p - 1] >= 0 && id[p - 1] !== k) || (y > 0 && id[p - W] >= 0 && id[p - W] !== k)) {\n        const b = 255 * fl;\n        display.setPixel(x, y, round(0.08 * 255 * c[0] * (1 - fl) + b * 0.9), round(0.08 * 255 * c[1] * (1 - fl) + b * 0.95), round(0.08 * 255 * c[2] * (1 - fl) + b));\n        continue;\n      }\n      // Faint bands run down each tile at a speed set by its conductance.\n      const ph = (((y - top[k]) % 9) + 9) % 9, m = ph \u003c 1 ? 0.8 : 1;\n      display.setPixel(x, y, round(255 * c[0] * m), round(255 * c[1] * m), round(255 * c[2] * m));\n    }\n}\n","anscombes-quartet":"// ===== Patternflow pattern =====\n// Title:   Anscombe's Quartet\n// Family:  data\n// Idea:    Anscombe's four scatter plots of eleven points stand stacked under one shared regression line, then fold into a single tall plot where their points split into a cloud of 264 that anneals from shape to shape while all five of its statistics stay the same to two decimals, so the line and the crosshair never move.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Anscombe's quartet (Francis Anscombe, 1973); same-stats annealing (Justin Matejka, George Fitzmaurice, 2017)\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Heat=0..1, Residuals=0..1\n//\n// Knob 1: Hue. Turns the four sets' colours round the wheel together: at 0 set I is sea green, II blue, III pink and IV yellow, and the cloud keeps each point's colour. The faint washes above and below the line stay on the cool side, teal over violet at 0 and magenta over green at 1.\n// Knob 2: Speed. At 2 the quartet stands 1 s and folds in 0.8 s, each of the eight shapes takes 3.6 s (the cloud settles in about 1.5 s, and the round ones turn a quarter radian a second), the cloud walks home in 3 s and the quartet stands 4 s: one round is 37.4 s. The annealer tries 20,000 nudges a second through the first second of a shape and 100,000 a second from the second second on. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Heat. The annealing temperature: the chance that a nudge taking a point away from its place is kept anyway, still only when the statistics hold. 0.2% at 0, with 5% that cools over the first second of each shape; 60% at 1, where the nudges are also 2.5 times longer and the shapes fray into a haze round their outlines while the numbers stay put.\n// Knob 4: Residuals. A stick from each point straight up or down to the line, in the point's colour, brightest at the point. Too faint to see below about 0.1; at 1 the sticks fill the space between the cloud and the line, and their squares add up to about the same total in every shape, since r and the spread of y are held.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, exp, cos, sin, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Anscombe's published sets (1973). The first three share x.\nconst AX = [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5];\nconst SETS = [\n  [AX, [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]],\n  [AX, [9.14, 8.14, 8.74, 8.77, 9.26, 8.1, 6.13, 3.1, 9.13, 7.26, 4.74]],\n  [AX, [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73]],\n  [[8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8], [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.5, 5.56, 7.91, 6.89]],\n];\n// What all four share: means 9 and 7.50, deviations 3.32 and 2.03,\n// correlation 0.816, and the line y = 3 + 0.5 x.\nconst MX = 9, MY = 7.5, SDX = sqrt(11), SDY = 2.0316, RHO = 0.8164;\n\n// Two views of the data. The quartet: four plots 32 rows tall, x from 3 to\n// 20 across the panel. The tall plot: one plot over all 128 rows, scaled so\n// that the outliers at x 19 and y 12.74 still land on the panel.\nconst QKX = 3.47, QX0 = 2 + 6 * QKX, QKY = 2.64;\nconst qY0 = (k) => 32 * k + 30 - (MY - 2.5) * QKY;\nconst KX = 3.4, KY = 12, X0 = 27, Y0 = 67;\n\n// Each of the 44 points splits into C copies for the cloud.\nconst C = 6, NP = 44, N = NP * C;\n\n// The cloud's shapes, drawn in a design square and then fitted so that their\n// own means and covariance are the cloud's: a shape can only be one the\n// statistics allow. Lines stay upright (\"L\") or level (\"U\") under the fit.\nfunction seg(o, a, b, c, d) {\n  const n = max(2, round(hypot(c - a, d - b) / 0.02));\n  for (let i = 0; i \u003c= n; i++) o.push([a + ((c - a) * i) / n, b + ((d - b) * i) / n]);\n}\nfunction circ(o, r) {\n  const n = max(8, round((2 * PI * r) / 0.02));\n  for (let i = 0; i \u003c n; i++) o.push([r * cos((2 * PI * i) / n), r * sin((2 * PI * i) / n)]);\n}\nfunction dot(o, a, b, n) {\n  for (let i = 0; i \u003c n; i++) o.push([a + 0.03 * cos(i), b + 0.03 * sin(i)]);\n}\nfunction star(o) {\n  const p = [];\n  for (let i = 0; i \u003c 10; i++) {\n    const a = -PI / 2 + (i * PI) / 5, r = i % 2 ? 0.45 : 1.1;\n    p.push([r * cos(a), r * sin(a)]);\n  }\n  for (let i = 0; i \u003c 10; i++) seg(o, p[i][0], p[i][1], p[(i + 1) % 10][0], p[(i + 1) % 10][1]);\n}\nfunction lattice(o) {\n  for (let b = -1.2; b \u003c= 1.21; b += 0.4) for (let a = -1.2; a \u003c= 1.21; a += 0.4) if (a * a + b * b \u003c 1.5) dot(o, a, b, 12);\n}\n// \"R\" shapes are round and carry no correlation of their own: they keep\n// their roundness on the panel and the statistics put a clump of points out\n// at each end of the line to carry r = 0.82, as Anscombe's outliers do.\n// \"L\" shapes are fitted whole: upright lines stay upright. \"U\": level stays level.\nconst SHAPES = [\n  [\"R\", circ1],\n  [\"L\", (o) => { for (const v of [-1.2, -0.4, 0.4, 1.2]) seg(o, -1.6, v, 1.6, v); }],\n  [\"R\", star],\n  [\"L\", (o) => { for (const u of [-1.5, -0.75, 0, 0.75, 1.5]) seg(o, u, -1.3, u, 1.3); }],\n  [\"R\", (o) => (circ(o, 1), circ(o, 0.5))],\n  [\"U\", (o) => { for (const v of [-1.5, -0.75, 0, 0.75, 1.5]) seg(o, -1.3, v, 1.3, v); }],\n  [\"R\", lattice],\n  [\"R\", (o) => (seg(o, -1, -1, 1, 1), seg(o, -1, 1, 1, -1))],\n];\nfunction circ1(o) {\n  circ(o, 1);\n}\n\n// Fit points to the cloud's means and covariance (sx, sy, sxy in LEDs).\nfunction fit(pts, ref, mode, sx, sy, sxy) {\n  let ma = 0, mb = 0, aa = 0, bb = 0, ab = 0;\n  for (const p of ref) (ma += p[0]), (mb += p[1]);\n  ma /= ref.length;\n  mb /= ref.length;\n  for (const p of ref) {\n    const a = p[0] - ma, b = p[1] - mb;\n    aa += a * a;\n    bb += b * b;\n    ab += a * b;\n  }\n  aa /= ref.length;\n  bb /= ref.length;\n  ab /= ref.length;\n  let M;\n  if (mode !== \"U\") {\n    // T times the inverse of S, both lower triangular: x depends on x alone.\n    const s11 = sqrt(aa), s21 = ab / s11, s22 = sqrt(bb - s21 * s21);\n    const t11 = sx, t21 = sxy / sx, t22 = sqrt(sy * sy - t21 * t21);\n    M = [t11 / s11, 0, t21 / s11 - (t22 * s21) / (s11 * s22), t22 / s22];\n  } else {\n    // Both upper triangular: y depends on y alone, so level lines stay level.\n    const s22 = sqrt(bb), s12 = ab / s22, s11 = sqrt(aa - s12 * s12);\n    const t22 = sy, t12 = sxy / sy, t11 = sqrt(sx * sx - t12 * t12);\n    M = [t11 / s11, t12 / s22 - (t11 * s12) / (s11 * s22), 0, t22 / s22];\n  }\n  return pts.map((p) => {\n    const a = p[0] - ma, b = p[1] - mb;\n    return [X0 + M[0] * a + M[1] * b, Y0 + M[2] * a + M[3] * b];\n  });\n}\n\n// Distance from each LED centre to the nearest point of a shape, filled a\n// few rows at a time so that no frame stalls on it.\nfunction fillRows(F, rows) {\n  const { f, xs, ys } = F, n = xs.length, end = min(H, F.row + rows);\n  for (let y = F.row; y \u003c end; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let best = 1e9;\n      const px = x + 0.5, py = y + 0.5;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = xs[i] - px, dy = ys[i] - py, d = dx * dx + dy * dy;\n        if (d \u003c best) best = d;\n      }\n      f[y * W + x] = sqrt(best);\n    }\n  F.row = end;\n}\nfunction look(f, x, y) {\n  const fx = cl(x - 0.5, 0, W - 1.001), fy = cl(y - 0.5, 0, H - 1.001);\n  const ix = floor(fx), iy = floor(fy), u = fx - ix, v = fy - iy, i = iy * W + ix;\n  return (f[i] * (1 - u) + f[i + 1] * u) * (1 - v) + (f[i + W] * (1 - u) + f[i + W + 1] * u) * v;\n}\n\nexport function setup(params) {\n  // The cloud: copy c of point j of set k, spread round the means by a hair\n  // so that its deviations divided by n - 1 are Anscombe's again.\n  let sxx = 0;\n  for (const [xs] of SETS) for (const x of xs) sxx += (x - MX) ** 2;\n  const grow = sqrt(((N - 1) * 11) / (C * sxx));\n  const hx = new Float64Array(N), hy = new Float64Array(N), set = new Uint8Array(N), idx = new Uint8Array(N);\n  for (let n = 0; n \u003c N; n++) {\n    const k = floor(n / (11 * C)), j = floor(n / C) % 11;\n    set[n] = k;\n    idx[n] = j;\n    const [xs, ys] = SETS[k];\n    hx[n] = X0 + KX * (xs[j] - MX) * grow;\n    hy[n] = Y0 - KY * (ys[j] - MY) * grow;\n  }\n  params.s = {\n    t: 0, hue: 0, speed: 2, heat: 0, res: 0.06, fade: 0,\n    hx, hy, set, idx, x: Float64Array.from(hx), y: Float64Array.from(hy), d: new Float64Array(N),\n    fields: [], pts: [], cores: [], cur: -1, bx: null, by: null, core: new Uint8Array(N), tx: new Float64Array(N), ty: new Float64Array(N), lock: null, stats: [0, 0, 0, 0, 0],\n    rgb: new Float32Array(W * H * 3), trail: new Float32Array(W * H * 3),\n  };\n}\n\n// Pixel sums of the cloud, and its statistics in Anscombe's units, rounded\n// to two decimals as whole hundredths.\nfunction sums(S) {\n  let a = 0, b = 0, aa = 0, bb = 0, ab = 0;\n  for (let n = 0; n \u003c N; n++) {\n    const x = S.x[n] - X0, y = S.y[n] - Y0;\n    a += x;\n    b += y;\n    aa += x * x;\n    bb += y * y;\n    ab += x * y;\n  }\n  return [a, b, aa, bb, ab];\n}\nfunction stats(a, b, aa, bb, ab, out) {\n  const vx = (aa - (a * a) / N) / (N - 1), vy = (bb - (b * b) / N) / (N - 1), c = (ab - (a * b) / N) / (N - 1);\n  out[0] = round(100 * (MX + a / N / KX));\n  out[1] = round(100 * (MY - b / N / KY));\n  out[2] = round((100 * sqrt(vx)) / KX);\n  out[3] = round((100 * sqrt(vy)) / KY);\n  out[4] = round((-100 * c) / sqrt(vx * vy));\n  return out;\n}\n\nfunction shapeField(S, k, rows = H) {\n  if (!S.fields[k]) {\n    // The shape's points carry the cloud's spread divided by n, so a cloud\n    // lying on it has Anscombe's spread divided by n - 1. Pixel rows run\n    // down, so the covariance turns negative.\n    const f = sqrt((N - 1) / N), sx = KX * SDX * f, sy = KY * SDY * f, sxy = -RHO * sx * sy;\n    const [mode, build] = SHAPES[k];\n    let raw = [];\n    build(raw);\n    const coreLen = raw.length;\n    if (mode === \"R\") {\n      // A fraction 2w of the points sits in the two clumps at (+-cx, -+cy):\n      // 2w cx cy carries the covariance, and what the clumps leave of the\n      // x and y spread, equal, is the round core's.\n      const w2 = 0.24, A = sx * sx, D = sy * sy, B = -sxy / w2, E = (D - A) / w2;\n      const cx = sqrt((-E + sqrt(E * E + 4 * B * B)) / 2), cy = B / cx;\n      let v = 0;\n      for (const p of raw) v += p[0] * p[0] + p[1] * p[1];\n      const lam = sqrt((A - w2 * cx * cx) / (1 - w2) / (v / raw.length / 2));\n      raw = raw.map((p) => [lam * p[0], lam * p[1]]);\n      const m = round(((raw.length * w2) / (1 - w2)) / 2);\n      for (const sg of [1, -1])\n        for (let i = 0; i \u003c m; i++) {\n          const a = i * 2.4, r = 2.2 * sqrt((i + 0.5) / m);\n          raw.push([sg * cx + r * cos(a), -sg * cy + r * sin(a)]);\n        }\n    }\n    // One place on the shape for each point, picked evenly along it. The fit\n    // is taken from these places, so a cloud sitting on them has the\n    // statistics exactly.\n    const spots = [], core = new Uint8Array(N);\n    for (let n = 0; n \u003c N; n++) {\n      const i = floor(((n + 0.5) * raw.length) / N);\n      spots.push(raw[i]);\n      core[n] = mode === \"R\" && i \u003c coreLen ? 1 : 0;\n    }\n    const pts = fit(raw, spots, mode, sx, sy, sxy);\n    S.pts[k] = fit(spots, spots, mode, sx, sy, sxy);\n    S.cores[k] = core;\n    const half = pts.filter((_, i) => i % 2 === 0);\n    S.fields[k] = { f: new Float32Array(W * H), xs: Float32Array.from(half, (p) => p[0]), ys: Float32Array.from(half, (p) => p[1]), row: 0 };\n  }\n  const F = S.fields[k];\n  if (F.row \u003c H) fillRows(F, rows);\n  return F.f;\n}\n\n// Hand the places out: start in any order, then swap pairs while a swap\n// shortens the paths.\nfunction assign(S, pts, core) {\n  const tx = S.tx, ty = S.ty, X = S.x, Y = S.y;\n  for (let n = 0; n \u003c N; n++) (tx[n] = pts[n][0]), (ty[n] = pts[n][1]);\n  const own = new Uint16Array(N).map((_, i) => i);\n  for (let t = 0; t \u003c 40000; t++) {\n    const a = floor(Math.random() * N), b = floor(Math.random() * N), oa = own[a], ob = own[b];\n    const xa = X[a], ya = Y[a], xb = X[b], yb = Y[b];\n    const keep = (xa - tx[oa]) ** 2 + (ya - ty[oa]) ** 2 + (xb - tx[ob]) ** 2 + (yb - ty[ob]) ** 2;\n    const swap = (xa - tx[ob]) ** 2 + (ya - ty[ob]) ** 2 + (xb - tx[oa]) ** 2 + (yb - ty[oa]) ** 2;\n    if (swap \u003c keep) (own[a] = ob), (own[b] = oa);\n  }\n  S.bx = Float64Array.from(own, (m) => tx[m]);\n  S.by = Float64Array.from(own, (m) => ty[m]);\n  S.core = Uint8Array.from(own, (m) => core[m]);\n  S.tx.set(S.bx);\n  S.ty.set(S.by);\n}\n\n// Matejka and Fitzmaurice: nudge one point, keep the nudge only if all five\n// statistics still round to the same two decimals, and prefer nudges that\n// bring the point nearer the target. A hot step takes a worse nudge too.\n// The target here is the shape's outline plus twice the distance to the\n// point's own place on it: the outline alone left a fifth of the points\n// stranded in a clump or on the wrong line, since only a hot step could\n// carry them across a gap.\nfunction anneal(S, tries, temp, f, rc, rs) {\n  let [a, b, aa, bb, ab] = sums(S);\n  const st = [0, 0, 0, 0, 0], L = S.lock, home = !f, step = 1.2 * (1 + 1.5 * S.heat);\n  const tx = home ? S.hx : S.tx, ty = home ? S.hy : S.ty, be = home ? 1 : BETA;\n  // A turning shape is looked up turned back, near its middle.\n  const at = (x, y) => {\n    const dx = x - X0, dy = y - Y0;\n    return rs && dx * dx + dy * dy \u003c 900 ? look(f, X0 + rc * dx + rs * dy, Y0 - rs * dx + rc * dy) : look(f, x, y);\n  };\n  const dist = (n, x, y) => (home ? 0 : at(x, y)) + be * sqrt((x - tx[n]) ** 2 + (y - ty[n]) ** 2);\n  for (let n = 0; n \u003c N; n++) S.d[n] = dist(n, S.x[n], S.y[n]);\n  for (let t = 0; t \u003c tries; t++) {\n    const n = floor(Math.random() * N);\n    const ox = S.x[n], oy = S.y[n];\n    const nx = ox + (Math.random() + Math.random() - 1) * step, ny = oy + (Math.random() + Math.random() - 1) * step;\n    if (nx \u003c 0 || nx >= W || ny \u003c 0 || ny >= H) continue;\n    const nd = dist(n, nx, ny);\n    if (nd >= S.d[n] && Math.random() >= temp) continue;\n    const x0 = ox - X0, y0 = oy - Y0, x1 = nx - X0, y1 = ny - Y0;\n    const a2 = a - x0 + x1, b2 = b - y0 + y1, aa2 = aa - x0 * x0 + x1 * x1, bb2 = bb - y0 * y0 + y1 * y1, ab2 = ab - x0 * y0 + x1 * y1;\n    stats(a2, b2, aa2, bb2, ab2, st);\n    if (st[0] !== L[0] || st[1] !== L[1] || st[2] !== L[2] || st[3] !== L[3] || st[4] !== L[4]) continue;\n    S.x[n] = nx;\n    S.y[n] = ny;\n    S.d[n] = nd;\n    a = a2;\n    b = b2;\n    aa = aa2;\n    bb = bb2;\n    ab = ab2;\n  }\n}\n\n// The story, in seconds at Speed 2: the quartet 1 s, folding into one plot\n// 0.8 s, eight shapes of 3.6 s, back home 3 s, unfolding 0.8 s, the quartet\n// 4 s. Nudges tried a second, the weight on a point's own place, the round\n// shapes' turn in radians a second, and the heat that cools at each shape.\nconst TR = 20000, BETA = 2, SPIN = 0.25, TEMP0 = 0.05, TAU = 1;\nconst QFIRST = 1, FOLD = 0.8, SHAPE = 3.6, NSH = 8, BACK = 3, QHOLD = 4;\nconst CYCLE = FOLD + NSH * SHAPE + BACK + FOLD + QHOLD;\nfunction phase(t) {\n  if (t \u003c QFIRST) return { q: 1, next: 0 };\n  let u = (t - QFIRST) % CYCLE;\n  const cyc = floor((t - QFIRST) / CYCLE);\n  if (u \u003c FOLD) return { fold: sm(u / FOLD), next: (cyc * NSH) % SHAPES.length };\n  u -= FOLD;\n  if (u \u003c NSH * SHAPE) return { shape: (cyc * NSH + floor(u / SHAPE)) % SHAPES.length, into: u % SHAPE };\n  u -= NSH * SHAPE;\n  const next = ((cyc + 1) * NSH) % SHAPES.length;\n  if (u \u003c BACK) return { back: u, next };\n  u -= BACK;\n  if (u \u003c FOLD) return { fold: 1 - sm(u / FOLD), next };\n  return { q: 1, next };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.heat = cl(k[2], 0, 1);\n  S.res = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  S.fade = exp(-g * 9);\n  const P = (S.P = phase(S.t));\n  if (!S.lock) S.lock = stats(...sums(S), [0, 0, 0, 0, 0]);\n  const into = P.shape !== undefined ? P.into : P.back !== undefined ? P.back : 0;\n  const rate = TR * (1 + 4 * sm(into - 1));\n  const tries = min(13000, round(g * rate));\n  // Work on the next shape's distances a few rows a frame.\n  shapeField(S, P.shape !== undefined ? (P.shape + 1) % SHAPES.length : P.next, 8);\n  if (P.shape !== undefined && P.shape !== S.cur) {\n    shapeField(S, P.shape);\n    assign(S, S.pts[P.shape], S.cores[P.shape]);\n    S.cur = P.shape;\n  }\n  if (P.shape === undefined) S.cur = -1;\n  if (P.shape !== undefined) {\n    // A round shape turns slowly about the means while it holds; turned\n    // whole, its spread and its zero correlation do not change.\n    const th = SPIN * P.into, rc = cos(th), rs = sin(th);\n    for (let n = 0; n \u003c N; n++)\n      if (S.core[n]) {\n        const dx = S.bx[n] - X0, dy = S.by[n] - Y0;\n        S.tx[n] = X0 + rc * dx - rs * dy;\n        S.ty[n] = Y0 + rs * dx + rc * dy;\n      }\n    anneal(S, tries, 0.002 + 0.6 * S.heat + TEMP0 * exp(-P.into / TAU), shapeField(S, P.shape), rc, rs);\n  }\n  else if (P.back !== undefined) anneal(S, tries, 0.002, null);\n  else for (let n = 0; n \u003c N; n++) (S.x[n] = S.hx[n]), (S.y[n] = S.hy[n]);\n  stats(...sums(S), S.stats);\n}\n\n// Where set k's data lands at fold s (0 the quartet, 1 the tall plot), and\n// the rows its plot may use.\nfunction view(k, s) {\n  return {\n    x0: QX0 + (X0 - QX0) * s, kx: QKX + (KX - QKX) * s,\n    y0: qY0(k) + (Y0 - qY0(k)) * s, ky: QKY + (KY - QKY) * s,\n    top: 32 * k * (1 - s), bot: 32 * (k + 1) + (H - 32 * (k + 1)) * s,\n  };\n}\n\n// Digits three LEDs wide and five tall, a row of bits each, top first.\nconst DIG = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7249, 0x7bef, 0x7bcf];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const P = S.P || { q: 1 }, rgb = S.rgb, tr = S.trail;\n  rgb.fill(0);\n  const add = (x, y, c, a) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a);\n    rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n    rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n  const s = P.q ? 0 : P.fold !== undefined ? P.fold : 1;\n  const cols = [0, 1, 2, 3].map((k) => hsv(0.42 + S.hue + 0.25 * k, 0.6, 1));\n  // The washes keep to the cool side of the wheel: dark yellow and orange\n  // read as olive and brown.\n  const upC = hsv(0.5 + 0.45 * S.hue, 0.8, 0.09), dnC = hsv(0.78 - 0.45 * S.hue, 0.7, 0.09);\n  const lineC = [1, 0.82, 0.55], meanC = [0.45, 0.5, 0.65], sdC = [0.22, 0.26, 0.4];\n  // The fixed things: one set of them per plot while there are four.\n  const views = s >= 1 ? [view(0, 1)] : [0, 1, 2, 3].map((k) => view(k, s));\n  views.forEach((v, k) => {\n    const inb = (y) => y >= v.top && y \u003c v.bot;\n    // The line splits each plot in two: a faint wash above it, where the\n    // residuals are positive, and another below, a little stronger inside\n    // one deviation of the means.\n    const bx = v.kx * SDX, by = v.ky * SDY;\n    for (let x = 0; x \u003c W; x++) {\n      const ly = v.y0 - v.ky * 0.5 * ((x + 0.5 - v.x0) / v.kx), inx = abs(x + 0.5 - v.x0) \u003c bx;\n      for (let y = Math.ceil(v.top); y \u003c v.bot; y++) add(x, y, y + 0.5 \u003c ly ? upC : dnC, inx && abs(y + 0.5 - v.y0) \u003c by ? 1.35 : 1);\n    }\n    if (s \u003c 1 && k > 0) for (let x = 0; x \u003c W; x++) add(x, v.top, sdC, 1 - s);\n    const sdx = v.kx * SDX, sdy = v.ky * SDY;\n    for (let y = Math.ceil(v.top); y \u003c v.bot; y++) {\n      if (y % 4 \u003c 2) add(v.x0, y, meanC, 1);\n      if (y % 3 === 0) (add(v.x0 - sdx, y, sdC, 1), add(v.x0 + sdx, y, sdC, 1));\n    }\n    for (let x = 0; x \u003c W; x++) {\n      if (inb(v.y0) && x % 4 \u003c 2) add(x, v.y0, meanC, 1);\n      if (x % 3 === 0) for (const yy of [v.y0 - sdy, v.y0 + sdy]) if (inb(yy)) add(x, yy, sdC, 1);\n    }\n  });\n  // The residuals: from each point straight down or up to the line.\n  const pos = new Float32Array(2 * N);\n  for (let n = 0; n \u003c N; n++) {\n    const k = S.set[n];\n    let px = S.x[n], py = S.y[n];\n    if (s \u003c 1) {\n      const v = view(k, s), [xs, ys] = SETS[k], j = S.idx[n];\n      const hx = (S.hx[n] - X0) / KX + MX, hy = MY - (S.hy[n] - Y0) / KY;\n      const dx = xs[j] + (hx - xs[j]) * s, dy = ys[j] + (hy - ys[j]) * s;\n      px = v.x0 + v.kx * (dx - MX);\n      py = v.y0 - v.ky * (dy - MY);\n    }\n    pos[2 * n] = px;\n    pos[2 * n + 1] = py;\n    if (S.res > 0.02) {\n      const v = s >= 1 ? views[0] : views[k];\n      const ly = v.y0 - v.ky * 0.5 * ((px - v.x0) / v.kx);\n      // Brightest at the point, under a third as bright where it meets the line.\n      const len = max(1, abs(py - ly));\n      for (let y = floor(min(ly, py)); y \u003c= floor(max(ly, py)); y++) add(px, y, cols[k], S.res * (0.3 + 0.7 * (1 - abs(y + 0.5 - py) / len)));\n    }\n  }\n  // The line y = 3 + 0.5 x, filled down each column so it stays unbroken.\n  views.forEach((v) => {\n    for (let x = 0; x \u003c W; x++) {\n      const ya = v.y0 - v.ky * 0.5 * ((x - v.x0) / v.kx), yb = v.y0 - v.ky * 0.5 * ((x + 1 - v.x0) / v.kx);\n      for (let y = floor(min(ya, yb)); y \u003c= floor(max(ya, yb)) && y \u003c H; y++) if (y + 0.5 >= v.top && y + 0.5 \u003c v.bot) add(x, y, lineC, 1);\n    }\n  });\n  // The five numbers the cloud keeps, top left of the tall plot, each in the\n  // colour of the lines it sets.\n  if (s > 0.5) {\n    const a = sm((s - 0.5) * 2), vals = S.stats, cc = [meanC, meanC, sdC, sdC, lineC];\n    for (let r = 0; r \u003c 5; r++) {\n      const v = vals[r], ds = [floor(v / 100), floor(v / 10) % 10, v % 10];\n      const c = r >= 2 && r \u003c 4 ? [0.4, 0.46, 0.7] : cc[r];\n      let x = 1;\n      for (let q = 0; q \u003c 3; q++) {\n        for (let b = 0; b \u003c 15; b++) if ((DIG[ds[q]] >> (14 - b)) & 1) add(x + (b % 3), 2 + 7 * r + floor(b / 3), c, a);\n        x += 4;\n        if (q === 0) (add(x, 6 + 7 * r, c, a), (x += 2));\n      }\n    }\n  }\n  // The points, over everything, leaving a short trail as they move.\n  const fd = S.fade;\n  for (let i = 0; i \u003c tr.length; i++) tr[i] *= fd;\n  for (let n = 0; n \u003c N; n++) {\n    const c = cols[S.set[n]], px = pos[2 * n], py = pos[2 * n + 1];\n    const big = s \u003c 0.5 ? 2 : 1;\n    for (let dy = 0; dy \u003c big; dy++)\n      for (let dx = 0; dx \u003c big; dx++) {\n        const x = floor(px - (big - 1) / 2 + dx), y = floor(py - (big - 1) / 2 + dy);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        tr[o] = c[0];\n        tr[o + 1] = c[1];\n        tr[o + 2] = c[2];\n      }\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const o = i * 3, t = max(tr[o], tr[o + 1], tr[o + 2]);\n    // A point covers what is under it; its fading trail only adds.\n    const r = t > 0.97 ? tr[o] : max(rgb[o], tr[o] * 0.6), g = t > 0.97 ? tr[o + 1] : max(rgb[o + 1], tr[o + 1] * 0.6), b = t > 0.97 ? tr[o + 2] : max(rgb[o + 2], tr[o + 2] * 0.6);\n    display.setPixel(i % W, floor(i / W), 4 * round(63.75 * cl(r, 0, 1)), 4 * round(63.75 * cl(g, 0, 1)), 4 * round(63.75 * cl(b, 0, 1)));\n  }\n}\n","banshee":"// ===== Patternflow pattern =====\n// Title:   Banshee\n// Family:  halloween\n// Idea:    A pale, see-through woman drifts in the night wind above a cottage with one lit window, her long hair and tattered robe streaming and whipping, and every 7 seconds she throws back her head and wails: rings of toxic green sound burst from her mouth and bend the night as they pass, the sky flashes green, the window panes rattle in their frame and the candle flame lies flat, the crows on the ridge scatter and the ground fog is blown back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Fury=0..1\n//\n// Knob 1: Hue. The colour of her light, of the rings and of the flash; the sky and the cottage with its window stay as they are. At 0 she is green-white and wails toxic green, at 0.25 blue-white with blue rings, at 0.5 lilac with magenta and at 0.75 peach with orange-red.\n// Knob 2: Speed. At 2 she wails every 7 s, the first time at 1.2 s: her head goes back over 0.5 s and the wail lasts 1.8 s, a ring leaving her mouth every 0.2 s; 0.7 s later she is quiet again. The rings travel 60 LEDs a second and reach the window about 1.2 s after they leave her; the crows are back on the ridge 4.5 to 5.5 s after they flew. At 0.2 everything, her drift and the flutter of her hair too, is ten times slower, at 3 half as fast again.\n// Knob 3: Wind. A wind from the left. At 0 a breeze of 4 LEDs a second, and her own drifting is what lifts her hair and hem; at 1 it blows 44 LEDs a second with gusts and her hair and robe stream out flat to the right. She hangs 8 LEDs further left against it, and the fog runs past four times as fast.\n// Knob 4: Fury. How hard she wails. At 0.06 the rings are thin and the sky glows faintly green round her; at 1 the rings are nearly twice as bright and more than twice as wide, they bend the scene further, and the flash floods the whole sky. The crows fly off faster and the flame lies flatter; the fog is blown back harder too.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  for (let i = 0; i \u003c 3; i++) {\n    const k = (5 - 2 * i + 6 * (h - floor(h))) % 6;\n    out[i] = v - v * s * max(0, min(k, 4 - k, 1));\n  }\n  return out;\n}\n// Channels in steps of 4 of 255.\nconst q4 = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\n// The roof's ridge and eaves, the ground, and where the fog starts.\nconst RIDGE = 70, EAVE = 86, GROUND = 119, FOG = 98;\n// The window: its left edge, top and pane size; the candle's wick sits in\n// the lower left pane.\nconst WX = 30, WY = 93, PS = 7, FX = 34.5, FY = 106;\n// Hair: strands, nodes and segment length in LEDs. Robe and sleeve tatters\n// the same.\nconst NH = 16, HN = 20, HL = 2.3, NR = 9, RN = 14, RL = 3.1, NT = 3, TN = 7, TL = 2.4;\n// The wail at Speed 2, in seconds: one every WP, the first at W0; the head\n// goes back over WA, she wails until WB and is quiet again by WC.\nconst WP = 7, W0 = 1.2, WA = 0.5, WB = 2.3, WC = 3.0;\n// Sound rings: speed in LEDs a second and the gap between them.\nconst RV = 60, RI = 0.2;\n// The crows' perches along the ridge.\nconst PERCH = [24, 32, 41, 49];\n\n// Every chain in one set of arrays: hair first, then robe, then tatters.\nconst CH = [];\n{\n  let o = 0;\n  for (let i = 0; i \u003c NH; i++) CH.push({ o, n: HN, L: HL * (0.85 + 0.3 * hash(i + 5)), g: 12, k: 0.07 + 0.1 * hash(i + 21), kind: 0, f: 0.7 + 0.6 * hash(i + 33) }), (o += HN);\n  for (let i = 0; i \u003c NR; i++) CH.push({ o, n: RN - (hash(i + 40) * 4) | 0, L: RL, g: 40, k: 0.04, kind: 1, f: 1 }), (o += RN);\n  for (let i = 0; i \u003c 2 * NT; i++) CH.push({ o, n: TN, L: TL * (0.8 + 0.4 * hash(i + 80)), g: 14, k: 0.1, kind: 2, f: 1 }), (o += TN);\n}\nconst NN = NH * HN + NR * RN + 2 * NT * TN;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, wind: 0, fury: 0.06, gust: 0,\n    hx: 32, hy: 30, tilt: 0, mouth: 0, arms: 0, blast: 0, flash: 0,\n    X: new Float32Array(NN), Y: new Float32Array(NN), PX: new Float32Array(NN), PY: new Float32Array(NN),\n    rx: new Float32Array(NN), ry: new Float32Array(NN), init: false,\n    rings: [], wailN: -1, ringT: 0,\n    rattle: 0, bend: 0, gutter: 0, fogX: 32, fogR: 0, fogP: 0,\n    crows: PERCH.map((x, i) => ({ hx: x, hy: RIDGE, x, y: RIDGE, vx: 0, vy: 0, st: 0, t: 0, ph: i * 1.7, face: i & 1 ? 1 : -1 })),\n    bg: new Float32Array(N * 3), sky: new Float32Array(N), buf: new Float32Array(N * 3),\n    ga: new Float32Array(N), gh: new Float32Array(N), ri: new Float32Array(N), rs: new Float64Array(400),\n    gc: [0, 0, 0], wc: [0, 0, 0],\n  };\n  scene(params.s);\n}\n\n// The still picture: sky, far hills, the cottage and the ground.\nfunction scene(S) {\n  const { bg, sky } = S;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r, g, b, s = 0;\n      // The roof: a hipped thatch from the left end to past the right edge.\n      const roofL = 14 + ((EAVE - y) / (EAVE - RIDGE)) * 8;\n      const hill = 84 + 3 * sin(x * 0.09 + 1) + 2 * sin(x * 0.23);\n      if (y >= RIDGE && y \u003c EAVE && x >= roofL) {\n        const n = hash(x * 3 + y * 131) * 0.5 + 0.5 * (0.5 + 0.5 * sin(x * 1.3 + y * 0.6));\n        r = 22 + 10 * n;\n        g = 14 + 6 * n;\n        b = 26 + 8 * n;\n        if (y === RIDGE) (r += 14), (g += 10), (b += 18);\n      } else if (y >= 60 && y \u003c RIDGE && x >= 53 && x \u003c= 58) {\n        // The chimney.\n        const n = hash(x + y * 17);\n        r = 24 + 8 * n;\n        g = 16 + 5 * n;\n        b = 26 + 6 * n;\n      } else if (y >= EAVE && y \u003c GROUND && x >= 16) {\n        // Stone wall: courses of rough stones with dark mortar.\n        const row = floor((y - EAVE) / 4), off = row & 1 ? 3 : 0, col = floor((x + off) / 6);\n        const mort = (y - EAVE) % 4 === 3 || (x + off) % 6 === 5;\n        const n = hash(row * 97 + col * 13);\n        r = mort ? 8 : 26 + 14 * n;\n        g = mort ? 6 : 20 + 10 * n;\n        b = mort ? 12 : 30 + 12 * n;\n        if (x === 16) (r *= 0.6), (g *= 0.6), (b *= 0.6);\n      } else if (y >= GROUND || (y >= hill && (x \u003c 16 || y >= EAVE))) {\n        // Moor: dark peat with tufts.\n        const n = hash(x * 7 + y * 61);\n        const d = y >= GROUND ? 1 : 0.7;\n        r = (10 + 8 * n) * d;\n        g = (12 + 9 * n) * d;\n        b = (16 + 6 * n) * d;\n      } else {\n        // Sky, near black overhead and violet towards the horizon, with stars.\n        const u = y / 84;\n        s = 1;\n        r = 4 + 54 * u * u;\n        g = 2 + 26 * u * u;\n        b = 12 + 80 * u * u;\n        if (y \u003c 56 && hash(p * 3 + 1) > 0.985) {\n          const v = 50 + 70 * hash(p);\n          (r += v), (g += v), (b += v * 1.1);\n        }\n      }\n      bg[p * 3] = r / 255;\n      bg[p * 3 + 1] = g / 255;\n      bg[p * 3 + 2] = b / 255;\n      sky[p] = s;\n    }\n  // The window's frame, dark wood round the four panes.\n  for (let y = WY - 1; y \u003c= WY + 2 * PS + 1; y++)\n    for (let x = WX - 1; x \u003c= WX + 2 * PS + 1; x++) {\n      const p = (y * W + x) * 3;\n      bg[p] = 0.07;\n      bg[p + 1] = 0.04;\n      bg[p + 2] = 0.05;\n    }\n}\n\n// Where each chain hangs from this step, from the head and the arms.\nfunction roots(S) {\n  const { hx, hy, tilt, arms, rx, ry } = S;\n  for (let c = 0; c \u003c CH.length; c++) {\n    const ch = CH[c];\n    let x, y;\n    if (ch.kind === 0) {\n      // Hair across the crown, from one temple over to the other.\n      const a = PI * (1.06 + (0.88 * c) / (NH - 1));\n      x = hx + 4.3 * cos(a);\n      y = hy - 0.6 - tilt + 5 * sin(a);\n    } else if (ch.kind === 1) {\n      // The robe across the shoulders.\n      const u = ((c - NH) / (NR - 1)) * 2 - 1;\n      x = hx + u * 5.6;\n      y = hy + 6.4 + 1.4 * u * u;\n    } else {\n      // Tatters along the forearms.\n      const j = c - NH - NR, side = j \u003c NT ? -1 : 1, f = ((j % NT) + 1) / NT;\n      const [ex, ey, wx, wy] = arm(S, side);\n      x = ex + (wx - ex) * f;\n      y = ey + (wy - ey) * f;\n    }\n    rx[c] = x;\n    ry[c] = y;\n  }\n}\n\n// An arm's elbow and wrist: hanging a little out at rest, flung up and out\n// when she wails.\nconst ARM = [0, 0, 0, 0];\nfunction arm(S, side) {\n  const a = 0.32 + 0.1 * sin(S.t * 1.3 + side) + 2.1 * S.arms, b = a + 0.45 - 0.75 * S.arms;\n  const sx = S.hx + side * 5, sy = S.hy + 7.5;\n  ARM[0] = sx + side * 8 * sin(a);\n  ARM[1] = sy + 8 * cos(a);\n  ARM[2] = ARM[0] + side * 7 * sin(b);\n  ARM[3] = ARM[1] + 7 * cos(b);\n  return ARM;\n}\n\n// One step of h for every chain: each node keeps its motion, is pulled\n// towards the wind's speed and by its own gravity, and the blast of the wail\n// pushes it away from her head; then each segment is set back to its length,\n// root first.\nfunction chains(S, h) {\n  const { X, Y, PX, PY, rx, ry, t, hx, hy } = S;\n  const wx0 = 4 + 40 * S.wind + S.gust, amp = 7 + 18 * S.wind, bl = S.blast * 45;\n  for (let c = 0; c \u003c CH.length; c++) {\n    const { o, n, L, g, k, f: fq } = CH[c];\n    X[o] = PX[o] = rx[c];\n    Y[o] = PY[o] = ry[c];\n    for (let i = 1; i \u003c n; i++) {\n      const j = o + i, f = i / n, vx = X[j] - PX[j], vy = Y[j] - PY[j];\n      let wx = wx0 + amp * f * sin(t * 2.9 * fq + i * 0.42 + c * 1.37), wy = amp * 0.8 * f * cos(t * 2.3 * fq + i * 0.5 + c * 0.9);\n      if (bl > 0) {\n        const dx = X[j] - hx, dy = Y[j] - hy, d = sqrt(dx * dx + dy * dy) + 2;\n        wx += bl * (0.5 + (0.6 * dx) / d);\n        wy += (bl * 0.3 * dy) / d;\n      }\n      PX[j] = X[j];\n      PY[j] = Y[j];\n      X[j] += vx * 0.98 + k * (wx * h - vx);\n      Y[j] += vy * 0.98 + k * (wy * h - vy) + g * h * h;\n    }\n    for (let i = 1; i \u003c n; i++) {\n      const j = o + i, dx = X[j] - X[j - 1], dy = Y[j] - Y[j - 1], d = sqrt(dx * dx + dy * dy) || 1;\n      X[j] = X[j - 1] + (dx * L) / d;\n      Y[j] = Y[j - 1] + (dy * L) / d;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.fury = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2, F = 0.55 + 0.45 * S.fury;\n  S.t += ds;\n  const t = S.t;\n  // Where she is in her wail.\n  const nw = floor((t - W0) / WP), w = t >= W0 ? t - W0 - nw * WP : -1;\n  const up = w \u003c 0 ? 0 : w \u003c WA ? sm(w / WA) : w \u003c WB ? 1 : w \u003c WC ? 1 - sm((w - WB) / (WC - WB)) : 0;\n  S.tilt = up;\n  S.arms = up;\n  S.mouth = w \u003c 0 ? 0.1 : w \u003c WA ? 0.1 + 0.9 * sm((w - 0.15) / (WA - 0.15)) : w \u003c WB ? 1 : w \u003c WC ? 1 - 0.9 * sm((w - WB) / 0.4) : 0.1;\n  S.blast = w >= WA && w \u003c WB ? F * (0.6 + 0.4 * sm((w - WA) / 0.3)) : 0;\n  // She drifts and bobs. When she wails she rises.\n  S.hx = 27 - 8 * S.wind + 10 * sin(0.23 * t + 0.4) + 4 * sin(0.57 * t);\n  S.hy = 30 + 4 * sin(0.31 * t) + 1.5 * sin(1.3 * t) - 4 * up;\n  S.gust = vn(t * 0.7, 3) * (4 + 16 * S.wind);\n  // A new wail: rings start leaving her mouth.\n  if (w >= WA && w \u003c WB) {\n    if (S.wailN !== nw) (S.wailN = nw), (S.ringT = 0), (S.fogX = S.hx), (S.fogR = 0);\n    S.ringT -= ds;\n    if (S.ringT \u003c= 0) {\n      S.ringT += RI;\n      S.rings.push({ x: S.hx, y: S.hy + 2.5 - S.tilt, t0: t, a: F });\n    }\n  }\n  S.flash = max(S.flash * exp(-6 * ds), (S.blast > 0) * (0.45 + 1.2 * S.fury) * (S.ringT > RI * 0.5 ? 1 : 0.7));\n  S.rattle *= exp(-3 * ds);\n  S.fogP = max(0, S.fogP - 0.22 * ds);\n  const mx = S.hx, my = S.hy + 2.5;\n  for (let i = S.rings.length - 1; i >= 0; i--) {\n    const R = S.rings[i], r = (t - R.t0) * RV, r0 = r - ds * RV;\n    if (r > 140) {\n      S.rings.splice(i, 1);\n      continue;\n    }\n    // What the ring front crossed this step.\n    const dw = sqrt((R.x - 38.5) ** 2 + (R.y - 101) ** 2);\n    if (r0 \u003c dw && r >= dw) S.rattle = max(S.rattle, R.a);\n    const fy = FOG + 8 - R.y;\n    if (r > fy) S.fogR = max(S.fogR, sqrt(r * r - fy * fy)), (S.fogP = max(S.fogP, R.a));\n    for (const c of S.crows) {\n      const dc = sqrt((R.x - c.x) ** 2 + (R.y - c.y) ** 2);\n      if (c.st === 0 && r0 \u003c dc && r >= dc) {\n        c.st = 1;\n        c.t = 0;\n        c.vx = (c.x \u003c R.x ? -1 : 1) * (16 + 14 * hash(c.hx + nw * 7)) * (0.6 + 0.6 * R.a);\n        c.vy = -(24 + 12 * hash(c.hx * 3 + nw));\n      }\n    }\n  }\n  // The candle flame lies over, away from her, while the wail lasts.\n  const flat = w >= WA && w \u003c WB + 0.3 && S.rattle > 0.05 ? 1 : 0;\n  const lean = (FX > mx ? 1 : -1) * 1.45 * F;\n  S.bend += ((flat ? lean : 0.12 * vn(t * 3, 9)) - S.bend) * min(1, 9 * ds);\n  S.gutter += ((flat ? 0.55 * F : 0) - S.gutter) * min(1, 5 * ds);\n  // Crows: off the ridge, away and back.\n  for (const c of S.crows) {\n    c.ph += ds * (c.st ? 40 : 1.3);\n    c.t += ds;\n    if (c.st === 1) {\n      c.vy += 8 * ds;\n      c.vx *= 1 - 0.3 * ds;\n      if (c.t > 2.2) c.st = 2;\n    } else if (c.st === 2) {\n      const dx = c.hx - c.x, dy = c.hy - c.y, dd = sqrt(dx * dx + dy * dy) || 1;\n      const sp = min(28, 3 + dd * 2);\n      c.vx += ((dx / dd) * sp - c.vx) * min(1, 2.5 * ds);\n      c.vy += ((dy / dd) * sp - c.vy) * min(1, 2.5 * ds);\n      if (dd \u003c 1.2) (c.st = 0), (c.x = c.hx), (c.y = c.hy), (c.vx = c.vy = 0), (c.face = c.hx \u003c mx ? 1 : -1);\n    }\n    if (c.st) (c.x += c.vx * ds), (c.y += c.vy * ds), (c.face = c.vx \u003c 0 ? -1 : 1);\n  }\n  // Hair and cloth, two steps a frame; the first frame lets them stream out.\n  if (!S.init) {\n    S.init = true;\n    roots(S);\n    for (let c = 0; c \u003c CH.length; c++)\n      for (let i = 0; i \u003c CH[c].n; i++) {\n        const j = CH[c].o + i;\n        S.X[j] = S.PX[j] = S.rx[c] + i * CH[c].L * 0.6;\n        S.Y[j] = S.PY[j] = S.ry[c] + i * CH[c].L * 0.8;\n      }\n    for (let i = 0; i \u003c 90; i++) chains(S, 1 / 60);\n  }\n  roots(S);\n  chains(S, ds / 2);\n  chains(S, ds / 2);\n}\n\n// Ghost light: an anti-aliased dot added into a buffer, a segment of them,\n// and filled shapes kept at the higher of what is there and a.\nfunction dot(g, x, y, a) {\n  x -= 0.5;\n  y -= 0.5;\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = ix + i, Y = iy + j;\n      if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) g[Y * W + X] += a * (i ? fx : 1 - fx) * (j ? fy : 1 - fy);\n    }\n}\nfunction seg(g, x0, y0, x1, y1, a0, a1) {\n  const n = max(1, Math.ceil(sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) * 1.6));\n  for (let i = 0; i \u003c n; i++) {\n    const f = i / n;\n    dot(g, x0 + (x1 - x0) * f, y0 + (y1 - y0) * f, (a0 + (a1 - a0) * f) * 0.62);\n  }\n}\nfunction tri(g, ax, ay, bx, by, cx, cy, a) {\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, floor(max(ax, bx, cx))), y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, floor(max(ay, by, cy)));\n  const ar = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(ar) \u003c 1e-6) return;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const u = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / ar, v = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / ar;\n      if (u >= 0 && v >= 0 && u + v \u003c= 1) {\n        const p = y * W + x;\n        if (g[p] \u003c a) g[p] = a;\n      }\n    }\n}\nfunction ell(g, cx, cy, rx, ry, a) {\n  for (let y = max(0, floor(cy - ry)); y \u003c= min(H - 1, floor(cy + ry)); y++)\n    for (let x = max(0, floor(cx - rx)); x \u003c= min(W - 1, floor(cx + rx)); x++) {\n      const u = (x + 0.5 - cx) / rx, v = (y + 0.5 - cy) / ry, q = u * u + v * v;\n      if (q \u003c 1) {\n        const p = y * W + x, b = a * min(1, (1 - q) * 3);\n        if (g[p] \u003c b) g[p] = b;\n      }\n    }\n}\n\n// Crow on a perch, facing left; flipped when it faces right.\nconst PERCHED = [\".##....\", \"####...\", \".#####.\", \"..#####\", \"...#.#.\"];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { bg, sky, buf, ga, gh, X, Y, gc, wc, t } = S;\n  const hue = 0.33 + S.hue;\n  hsv(hue, 0.85, 1, wc);\n  hsv(hue, 0.2, 1, gc);\n  const mx = S.hx, my = S.hy + 2.6 - 1.1 * S.tilt;\n  // Rings now: centre, radius and strength.\n  const rs = S.rs, ri = S.ri;\n  let nr = 0;\n  for (const R of S.rings) {\n    const r = (t - R.t0) * RV;\n    rs[nr * 4] = R.x;\n    rs[nr * 4 + 1] = R.y;\n    rs[nr * 4 + 2] = r;\n    rs[nr++ * 4 + 3] = R.a * (1 - r / 140);\n  }\n  ri.fill(0);\n  // The night, bent where a ring passes, and lit by the flash.\n  const fr = 40 + 40 * S.fury, rw = 0.9 + 1.4 * S.fury;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      let sx = x, sy = y;\n      for (let k = 0; k \u003c nr * 4; k += 4) {\n        const dx = x + 0.5 - rs[k], dy = y + 0.5 - rs[k + 1], d = sqrt(dx * dx + dy * dy) + 1e-3, e = d - rs[k + 2], a = rs[k + 3];\n        if (e > -4 && e \u003c 4) {\n          const o = 2.4 * a * (1 - abs(e) / 4) * (e \u003c 0 ? 1 : -0.5);\n          sx += (dx / d) * o;\n          sy += (dy / d) * o;\n          if (e > -rw && e \u003c rw) ri[p] += a * 0.75 * (1 - abs(e) / rw);\n        }\n      }\n      const q = (cl(round(sy), 0, H - 1) * W + cl(round(sx), 0, W - 1)) * 3;\n      const dm = sqrt((x - mx) ** 2 + (y - my) ** 2), fl = S.flash * (0.25 + 0.5 * sky[p]) * exp(-dm / fr);\n      buf[p * 3] = bg[q] + wc[0] * fl * 0.5;\n      buf[p * 3 + 1] = bg[q + 1] + wc[1] * fl * 0.5;\n      buf[p * 3 + 2] = bg[q + 2] + wc[2] * fl * 0.5;\n    }\n  win(S);\n  fog(S);\n  crows(S);\n  // The banshee.\n  ga.fill(0);\n  gh.fill(0);\n  for (let c = NH; c \u003c NH + NR - 1; c++) {\n    const A = CH[c], B = CH[c + 1], n = min(A.n, B.n);\n    for (let i = 0; i \u003c n - 1; i++) {\n      const a = 0.45 - (0.25 * i) / n, p = A.o + i, q = B.o + i;\n      tri(ga, X[p], Y[p], X[p + 1], Y[p + 1], X[q + 1], Y[q + 1], a);\n      tri(ga, X[p], Y[p], X[q + 1], Y[q + 1], X[q], Y[q], a);\n    }\n  }\n  for (let c = NH; c \u003c CH.length; c++) {\n    const { o, n, kind } = CH[c];\n    for (let i = 0; i \u003c n - 1; i++) seg(gh, X[o + i], Y[o + i], X[o + i + 1], Y[o + i + 1], kind === 1 ? 0.25 : 0.5, kind === 1 ? 0.2 : 0.2);\n  }\n  for (const side of [-1, 1]) {\n    const [ex, ey, wx, wy] = arm(S, side), sx = S.hx + side * 5, sy = S.hy + 7.5;\n    seg(gh, sx, sy, ex, ey, 0.9, 0.8);\n    seg(gh, ex, ey, wx, wy, 0.8, 0.7);\n    ell(ga, wx, wy, 1.1, 1.1, 0.9);\n  }\n  seg(gh, S.hx, S.hy + 3, S.hx, S.hy + 7, 0.9, 0.9);\n  ell(ga, S.hx, S.hy, 3.7, 4.7 * (1 - 0.12 * S.tilt), 0.95);\n  for (let c = 0; c \u003c NH; c++) {\n    const { o, n } = CH[c];\n    for (let i = 0; i \u003c n - 1; i++) seg(gh, X[o + i], Y[o + i], X[o + i + 1], Y[o + i + 1], 0.55 - (0.4 * i) / n, 0.55 - (0.4 * (i + 1)) / n);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const a = min(1, ga[p] + gh[p]);\n    if (a \u003c= 0) continue;\n    const k = 1 - 0.72 * a;\n    buf[p * 3] = buf[p * 3] * k + gc[0] * a * 0.92;\n    buf[p * 3 + 1] = buf[p * 3 + 1] * k + gc[1] * a * 0.92;\n    buf[p * 3 + 2] = buf[p * 3 + 2] * k + gc[2] * a * 0.92;\n  }\n  face(S, mx, my);\n  // The rings themselves, added on top.\n  for (let p = 0; p \u003c N; p++) {\n    const v = ri[p];\n    if (v > 0) (buf[p * 3] += wc[0] * v), (buf[p * 3 + 1] += wc[1] * v), (buf[p * 3 + 2] += wc[2] * v);\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), q4(buf[3 * p]), q4(buf[3 * p + 1]), q4(buf[3 * p + 2]));\n}\n\n// Eyes and the mouth: dark hollows with a glint, and a mouth that opens to a\n// long dark O glowing inside while she wails.\nfunction face(S, mx, my) {\n  const { buf, wc } = S;\n  const set = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    buf[p] = r;\n    buf[p + 1] = g;\n    buf[p + 2] = b;\n  };\n  const ey = floor(S.hy - 0.6 - 1.2 * S.tilt), gl = 0.3 + 0.7 * S.blast;\n  for (const side of [-1, 1]) {\n    const ex = floor(S.hx + side * 1.6);\n    set(ex, ey, wc[0] * gl, wc[1] * gl, wc[2] * gl);\n    set(ex, ey + 1, 0.04, 0.03, 0.08);\n  }\n  const rx = 0.5 + 1.1 * S.mouth, ry = 0.5 + 2.3 * S.mouth;\n  for (let y = floor(my - ry); y \u003c= floor(my + ry); y++)\n    for (let x = floor(mx - rx); x \u003c= floor(mx + rx); x++) {\n      const u = (x + 0.5 - mx) / rx, v = (y + 0.5 - my) / ry, q = u * u + v * v;\n      if (q \u003c 1) {\n        const g = S.blast * (1 - q) * 0.9;\n        set(x, y, 0.03 + wc[0] * g, 0.02 + wc[1] * g, 0.06 + wc[2] * g);\n      }\n    }\n}\n\n// The window: four panes lit warm by a candle on the sill, shaken loose in\n// their frame by a passing ring, the flame bending over.\nfunction win(S) {\n  const { buf, t } = S;\n  const fb = 1 - S.gutter, fl = 0.92 + 0.08 * vn(t * 9, 4);\n  const len = (4.2 + 0.6 * vn(t * 7, 2)) * (1 - 0.35 * S.gutter);\n  for (let pj = 0; pj \u003c 2; pj++)\n    for (let pi = 0; pi \u003c 2; pi++) {\n      const id = pj * 2 + pi, r = S.rattle;\n      const ox = r > 0.06 ? round(r * 1.4 * sin(t * 53 + id * 2.1)) : 0, oy = r > 0.06 ? round(r * 1.1 * cos(t * 47 + id * 1.3)) : 0;\n      const x0 = WX + pi * (PS + 1), y0 = WY + pj * (PS + 1);\n      for (let y = y0; y \u003c y0 + PS; y++)\n        for (let x = x0; x \u003c x0 + PS; x++) {\n          const p = (y * W + x) * 3, lx = x - ox, ly = y - oy;\n          if (lx \u003c x0 || lx >= x0 + PS || ly \u003c y0 || ly >= y0 + PS) {\n            buf[p] = 0.05;\n            buf[p + 1] = 0.03;\n            buf[p + 2] = 0.04;\n            continue;\n          }\n          const d = sqrt((lx + 0.5 - FX) ** 2 + (ly + 0.5 - FY + 2) ** 2), gw = exp(-d / 5) * fb * fl;\n          let R = 0.42 + 0.58 * gw, G = 0.2 + 0.52 * gw, B = 0.06 + 0.22 * gw;\n          // The candle, cream wax on the sill.\n          if (lx >= 34 && lx \u003c= 35 && ly > FY && ly \u003c= FY + 4) (R = 0.85), (G = 0.75), (B = 0.55);\n          buf[p] = R * fl;\n          buf[p + 1] = G * fl;\n          buf[p + 2] = B * fl;\n        }\n    }\n  // The flame: a tongue from the wick, bent by S.bend.\n  const r = S.rattle, ox = r > 0.06 ? round(r * 1.4 * sin(t * 53 + 4.2)) : 0, oy = r > 0.06 ? round(r * 1.1 * cos(t * 47 + 1.3)) : 0;\n  for (let i = 0; i \u003c= 8; i++) {\n    const f = i / 8, a = S.bend * f, px = FX + ox + sin(a) * len * f, py = FY + oy - cos(a) * len * f, wd = 1.3 * (1 - f) + 0.3;\n    for (let y = floor(py - wd); y \u003c= floor(py + wd); y++)\n      for (let x = floor(px - wd); x \u003c= floor(px + wd); x++) {\n        if (x \u003c WX + 0 || x >= WX + PS || y \u003c WY + PS + 1 || y >= WY + 2 * PS + 1) continue;\n        if ((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2 > wd * wd) continue;\n        const p = (y * W + x) * 3;\n        buf[p] = 1 * fb + 0.4 * (1 - fb);\n        buf[p + 1] = (0.95 - 0.45 * f) * fb + 0.2 * (1 - fb);\n        buf[p + 2] = (0.7 - 0.6 * f) * fb + 0.05;\n      }\n  }\n}\n\n// Ground fog drifting with the wind, blown out in a ring under her by the\n// wail and creeping back.\nfunction fog(S) {\n  const { buf, t } = S;\n  const sp = 3 + 9 * S.wind;\n  for (let y = FOG; y \u003c H; y++) {\n    const pr = sm((y - FOG) / 16);\n    for (let x = 0; x \u003c W; x++) {\n      let d = pr * (0.62 + 0.24 * vn(x * 0.11 - t * sp * 0.1 + y * 0.37, 11) + 0.18 * vn(x * 0.23 - t * sp * 0.07 - y * 0.21, 12));\n      if (S.fogP > 0) {\n        const dd = abs(x + 0.5 - S.fogX), e = (dd - S.fogR) / 3;\n        d *= dd \u003c S.fogR ? 1 - S.fogP * 0.92 * sm((S.fogR - dd) / 5) : 1;\n        d += pr * S.fogP * 0.6 * exp(-e * e);\n      }\n      const a = cl(d * 0.62, 0, 0.85), p = (y * W + x) * 3;\n      buf[p] = buf[p] * (1 - a) + 0.5 * a;\n      buf[p + 1] = buf[p + 1] * (1 - a) + 0.45 * a;\n      buf[p + 2] = buf[p + 2] * (1 - a) + 0.62 * a;\n    }\n  }\n}\n\nfunction crows(S) {\n  const { buf } = S;\n  const set = (x, y) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    buf[p] = 0.02;\n    buf[p + 1] = 0.01;\n    buf[p + 2] = 0.03;\n  };\n  for (const c of S.crows) {\n    const x = round(c.x), y = round(c.y);\n    if (c.st === 0) {\n      for (let j = 0; j \u003c 5; j++)\n        for (let i = 0; i \u003c 7; i++) if (PERCHED[j][c.face \u003c 0 ? i : 6 - i] === \"#\") set(x - 3 + i, y - 5 + j);\n    } else {\n      // In flight: a body, a head and two wings beating.\n      const f = sin(c.ph), tip = -3.2 * f, mid = -1.4 * f;\n      for (let i = -1; i \u003c= 1; i++) set(x + i, y);\n      set(x + 2 * c.face, y - 1);\n      set(x + c.face, y - 1);\n      set(x - 2 * c.face, y + 1);\n      for (const s of [-1, 1]) {\n        set(x + s * 2, round(y + mid * 0.6));\n        set(x + s * 3, round(y + mid));\n        set(x + s * 4, round(y + (mid + tip) * 0.5));\n        set(x + s * 5, round(y + tip));\n      }\n    }\n  }\n}\n","creaking-door":"// ===== Patternflow pattern =====\n// Title:   Creaking Door\n// Family:  halloween\n// Idea:    A door at the end of a purple-dark hallway creaks open in lurches and candlelight from the room behind spills out as a widening wedge across the floorboards and up the left wall, dust glittering in it, while the shadow of a long-fingered hand, or of someone in a pointed hat, reaches across the light from somewhere out of sight; then the door slams with a jolt that shakes the panel and brings dust down from the lintel, and in the dark two feet cross the line of light under the door before it begins again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Reach=0..1, Haze=0..1\n//\n// Knob 1: Hue. The colour of the light in the room. At 0 a candle's, deep red where it is faint and pale gold where it is strong, orange between. At 0.33 toxic green turning towards cyan where it is strong, at 0.67 blue turning violet. The hallway's purple stays.\n// Knob 2: Speed. At 2 a round lasts 10 to 11.5 seconds: the door lurches open over 3.4 to 4.8 s to between 54 and 69 degrees, the shadow comes 2.2 to 2.8 s in and stays 4 s, the door slams 6.2 to 7 s in, shut in 0.14 s, and the dark lasts 3.6 to 4.2 s. The first round starts with the door already ajar. At 1 everything takes twice as long, at 0.2 ten times.\n// Knob 3: Reach. How far the candle's light carries before it falls to half: 0.9 m (30 LEDs across at the door) at 0, 2.3 m at 1. At 0 the boards near the eye stay deep red and the hallway outside the wedge stays purple; at 1 the wedge burns orange down to the bottom of the panel and the left wall glows gold.\n// Knob 4: Haze. Dust in the air. At 0 the light shows only where it lands, with a few motes; at the opening 0.06 a faint glow over the wedge and 140 motes glittering in it; at 1 the beam stands in the air as a glowing wedge with the shadow cut through it.\n// Buttons: K1 tap slams the door while it is opening or open; while it is shut, a tap opens it again.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\n\n// World in metres: x to the right, y up, z away from the eye. The eye stands\n// EYE above the floor and ZC in front of the far wall (z = 0). F is the focal\n// length in LEDs, and the horizon sits on row CY.\nconst EYE = 1.2, ZC = 3, F = 100, CX = 32, CY = 42;\n// The hallway is 2 HW wide under a ceiling HC high. The doorway in the far\n// wall is 2 DW wide and DH high inside a trim TRIM wide, with a gap GAP\n// under the door.\nconst HW = 0.6, HC = 2.4, DW = 0.45, DH = 2, TRIM = 0.07, GAP = 0.02;\n// The room behind is 2 RW wide, RD deep and RH high. The candle stands in it\n// at (LX, LY, LZ), round the corner to the right where the eye cannot see it.\nconst RW = 1.4, RD = 2.6, RH = 2.5, LX = 0.75, LY = 0.85, LZ = 1.4;\n// Light strength, and its strength on the room's own walls.\nconst LI = 8, RI = 2;\n// Kinds of LED.\nconst CEIL = 0, WALL = 1, TRM = 2, LEFT = 3, RIGHT = 4, FLOOR = 5, DOOR = 6;\nconst NRM = [[0, -1, 0], [0, 0, -1], [0, 0, -1], [1, 0, 0], [-1, 0, 0], [0, 1, 0]];\n\nfunction setup0(S) {\n  const g = (S.geo = {\n    kind: new Uint8Array(N), P: new Float32Array(N * 3), amb: new Float32Array(N * 3), alb: new Float32Array(N),\n    d: new Float32Array(N * 2), R: new Float32Array(N * 3), rn: new Float32Array(N * 3), ramb: new Float32Array(N * 3), tz: new Float32Array(N),\n  });\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, dx = (x + 0.5 - CX) / F, dy = -(y + 0.5 - CY) / F;\n      // The nearest of the hallway's six faces along the ray from the eye.\n      let t = ZC, k = WALL;\n      if (dy \u003c 0 && -EYE / dy \u003c t) (t = -EYE / dy), (k = FLOOR);\n      if (dy > 0 && (HC - EYE) / dy \u003c t) (t = (HC - EYE) / dy), (k = CEIL);\n      if (dx \u003c 0 && -HW / dx \u003c t) (t = -HW / dx), (k = LEFT);\n      if (dx > 0 && HW / dx \u003c t) (t = HW / dx), (k = RIGHT);\n      const X = dx * t, Y = EYE + dy * t, Z = -ZC + t;\n      if (k === WALL && abs(X) \u003c DW && Y \u003c DH) k = DOOR;\n      else if (k === WALL && abs(X) \u003c DW + TRIM && Y \u003c DH + TRIM) k = TRM;\n      g.kind[p] = k;\n      g.P[p * 3] = X;\n      g.P[p * 3 + 1] = Y;\n      g.P[p * 3 + 2] = Z;\n      g.d[p * 2] = dx;\n      g.d[p * 2 + 1] = dy;\n      g.tz[p] = Z;\n      let r = 0, gg = 0, b = 0, a = 1;\n      if (k === FLOOR) {\n        // Boards 0.12 wide running away from the eye.\n        const bi = floor((X + 3) / 0.12), u = (X + 3) / 0.12 - bi;\n        const seam = u \u003c 0.14 ? 0.55 : 1, tone = 0.85 + 0.3 * hash(bi * 13);\n        r = 26 * seam * tone;\n        gg = 11 * seam * tone;\n        b = 30 * seam * tone;\n        a = 0.85 * seam * tone;\n      } else if (k === CEIL) (r = 14), (gg = 6), (b = 22), (a = 0.8);\n      else if (k === TRM) (r = 54), (gg = 30), (b = 58), (a = 1);\n      else {\n        // Wallpaper in stripes above the dado rail, panelling below it.\n        const u = k === WALL ? X : Z, st = 0.5 + 0.5 * cos(u * 2 * PI * 7), lo = Y \u003c 0.9, rail = abs(Y - 0.9) \u003c 0.03 || Y \u003c 0.1;\n        const f = rail ? 1.12 : lo ? 0.8 : 0.85 + 0.25 * st;\n        r = 36 * f;\n        gg = 14 * f;\n        b = 50 * f;\n        a = f;\n      }\n      g.amb[p * 3] = r;\n      g.amb[p * 3 + 1] = gg;\n      g.amb[p * 3 + 2] = b;\n      g.alb[p] = a;\n      if (k === DOOR) {\n        // Where the ray lands in the room if the door is not in the way.\n        let tr = 1e9, kk = 0;\n        const c = [[0, -1, 0], [0, 1, 0], [-1, 0, 0], [1, 0, 0], [0, 0, -1]];\n        const ts = [dy > 0 ? (RH - EYE) / dy : 1e9, dy \u003c 0 ? -EYE / dy : 1e9, dx > 0 ? RW / dx : 1e9, dx \u003c 0 ? -RW / dx : 1e9, ZC + RD];\n        for (let i = 0; i \u003c 5; i++) if (ts[i] > ZC && ts[i] \u003c tr) (tr = ts[i]), (kk = i);\n        const RX = dx * tr, RY = EYE + dy * tr, RZ = -ZC + tr;\n        g.R[p * 3] = RX;\n        g.R[p * 3 + 1] = RY;\n        g.R[p * 3 + 2] = RZ;\n        g.rn[p * 3] = c[kk][0];\n        g.rn[p * 3 + 1] = c[kk][1];\n        g.rn[p * 3 + 2] = c[kk][2];\n        // A picture on the back wall; plain plaster elsewhere.\n        const pic = kk === 4 && abs(RX + 0.1) \u003c 0.35 && abs(RY - 1.45) \u003c 0.3, fr = pic && (abs(RX + 0.1) > 0.29 || abs(RY - 1.45) > 0.24);\n        const f = fr ? 0.35 : pic ? 0.6 : kk === 1 ? 0.7 : 1;\n        g.ramb[p * 3] = 40 * f;\n        g.ramb[p * 3 + 1] = 18 * f;\n        g.ramb[p * 3 + 2] = 40 * f;\n      }\n    }\n}\n\n// The door turns by th about its hinge at the left jamb, into the room.\n// Does the segment from A to the candle cross it?\nfunction doorBlocks(S, ax, ay, az) {\n  const s = S.sn, c = S.cs, na = s * (ax + DW) - c * az, nb = s * (LX + DW) - c * LZ;\n  if ((na > 0) === (nb > 0)) return false;\n  const t = na / (na - nb), X = ax + (LX - ax) * t, Y = ay + (LY - ay) * t, Z = az + (LZ - az) * t, u = (X + DW) * c + Z * s;\n  return u >= 0 && u \u003c= 2 * DW && Y >= GAP && Y \u003c= DH;\n}\n\n// Light at P from the candle, 0 when something is in the way. Points in the\n// hallway see the candle only through the doorway, and there the shadow\n// mask (the hand, or the figure) can stand in it. A door ajar by less than\n// 0.03 rad counts as shut: the slit would light a dotted line.\nfunction vis(S, x, y, z) {\n  if (z \u003c 0) {\n    if (S.th \u003c 0.03) return 0;\n    const k = -z / (LZ - z), qx = x + (LX - x) * k, qy = y + (LY - y) * k;\n    if (abs(qx) >= DW || qy \u003c= 0 || qy >= DH) return 0;\n    if (doorBlocks(S, x, y, z)) return 0;\n    return 1 - mask(S, qx, qy);\n  }\n  return doorBlocks(S, x, y, z) ? 0 : 1;\n}\n\n// The shadow, kept as the shape it throws on the boards: a grid over the\n// hallway floor. A ray from the candle through the doorway is in shadow when\n// the floor it would reach is dark, so the haze shows the same shadow as the\n// floor does.\nconst MS = 0.02, MW = 60, MH = 80;\nfunction mask(S, qx, qy) {\n  if (qy >= LY * 0.99) return 0;\n  const m = LY / (LY - qy), i = floor((LX + (qx - LX) * m + HW) / MS), j = floor((LZ * (m - 1)) / MS);\n  return j \u003c MH && i >= 0 && i \u003c MW ? S.mk[j * MW + i] : 0;\n}\n// A round-ended stroke from (ax, az) to (bx, bz) on the floor, r wide. The\n// shapes are drawn upright and sheared along the light, which crosses the\n// boards leaning SH to the left for every metre it comes towards the eye.\nconst SH = 0.3;\nfunction capsule(S, ax, az, bx, bz, r) {\n  (ax += SH * az), (bx += SH * bz);\n  const M = S.mk, x0 = max(0, floor((min(ax, bx) - r - 0.03 + HW) / MS)), x1 = min(MW - 1, floor((max(ax, bx) + r + 0.03 + HW) / MS));\n  const y0 = max(0, floor((-max(az, bz) - r - 0.03) / MS)), y1 = min(MH - 1, floor((-min(az, bz) + r + 0.03) / MS));\n  const ex = bx - ax, ey = bz - az, ee = ex * ex + ey * ey || 1;\n  for (let j = y0; j \u003c= y1; j++)\n    for (let i = x0; i \u003c= x1; i++) {\n      const px = (i + 0.5) * MS - HW, py = -(j + 0.5) * MS, t = cl(((px - ax) * ex + (py - az) * ey) / ee, 0, 1);\n      const d = sqrt((px - ax - ex * t) ** 2 + (py - az - ey * t) ** 2), v = cl((r - d) / 0.03 + 0.5, 0, 1);\n      if (v > M[j * MW + i]) M[j * MW + i] = v;\n    }\n}\n// A long-fingered hand lying in the light: the wrist at (wx, wz), the\n// fingers reaching towards the eye, turned by a, curled by c.\nfunction hand(S, wx, wz, a, c) {\n  const ca = cos(a), sa = sin(a), P = (u, v) => [wx + u * ca + v * sa, wz - v * ca + u * sa];\n  capsule(S, ...P(0, -0.6), ...P(0, 0), 0.1);\n  capsule(S, ...P(-0.03, 0.03), ...P(0, 0.16), 0.15);\n  for (let f = 0; f \u003c 4; f++) {\n    let [px, pz] = P(-0.15 + f * 0.1, 0.24), an = -PI / 2 + a + (f - 1.5) * 0.12;\n    const len = [0.19, 0.24, 0.23, 0.17][f], wig = 0.12 * sin(S.t * 5 + f * 1.7) * (1 - c);\n    for (let seg = 0; seg \u003c 3; seg++) {\n      an += (c * (0.3 + 0.15 * seg) * (1.5 - f) * 0.5 + wig * (f \u003c 2 ? 1 : -1)) * 0.7;\n      const nx = px + cos(an) * len * (1 - 0.45 * c), nz = pz + sin(an) * len * (1 - 0.45 * c);\n      capsule(S, px, pz, nx, nz, 0.045 - seg * 0.009);\n      (px = nx), (pz = nz);\n    }\n  }\n  const t0 = P(0.17, 0.05), t1 = P(0.31, 0.19);\n  capsule(S, ...t0, ...t1, 0.045);\n  capsule(S, ...t1, ...P(0.35, 0.33), 0.035);\n}\n// Someone in a pointed hat crossing the room between the candle and the\n// door: a long shadow from the threshold, the legs walking, the hat nearest\n// the eye.\nfunction figure(S, x, walk) {\n  const l = 0.07 * sin(walk);\n  capsule(S, x - 0.05 - l, 0.15, x - 0.05, -0.36, 0.05);\n  capsule(S, x + 0.05 + l, 0.15, x + 0.05, -0.36, 0.05);\n  capsule(S, x, -0.38, x, -0.6, 0.13);\n  capsule(S, x - 0.06, -0.66, x + 0.06, -0.66, 0.11);\n  capsule(S, x, -0.76, x, -0.84, 0.085);\n  capsule(S, x - 0.17, -0.92, x + 0.17, -0.92, 0.035);\n  for (let i = 0; i \u003c 6; i++) capsule(S, x - 0.006 * i * i, -0.95 - 0.06 * i, x - 0.006 * (i + 1) * (i + 1), -1.01 - 0.06 * i, 0.08 - 0.013 * i);\n}\n\n// One round of the door. Times in seconds at Speed 2.\nfunction plan(S, first) {\n  const r = Math.random;\n  // Now and then the door gets only half way before it slams.\n  const part = !first && r() \u003c 0.3;\n  S.cy = {\n    t0: first ? 0.8 : 0, open0: 0.8, dur: part ? 2.4 : 3.4 + r() * 1.4, thMax: part ? 0.5 + r() * 0.15 : 0.95 + r() * 0.25, kind: S.round % 2,\n    steps: [0, 1, 2, 3, 4].map(() => r()).sort(), sh0: 2.2 + r() * 0.6, slam: part ? 4.6 + r() * 0.6 : 6.2 + r() * 0.8,\n  };\n  S.cy.end = S.cy.slam + 3.6 + r() * 0.6;\n  S.ct = S.cy.t0;\n  S.round++;\n}\n// The angle as the door creaks open: five lurches with sticking between.\nfunction creak(c, u) {\n  let a = 0;\n  for (let i = 0; i \u003c 5; i++) a += sm((u - c.steps[i] * 0.85) / 0.12) * 0.2;\n  return 0.12 + (c.thMax - 0.12) * (0.25 * u + 0.75 * a);\n}\n\nexport function setup(params) {\n  const S = (params.s = { t: 0, ct: 0, round: 0, hue: 0, speed: 2, reach: 0, haze: 0.06, th: 0.12, sn: 0, cs: 1, slamT: -9, shake: [0, 0], flick: 1, D0: -1, feet: -1, peep: true,\n    mk: new Float32Array(MW * MH), lf: new Float32Array(N), buf: new Float32Array(N * 3), hz: new Float32Array(32 * 64), motes: [], falls: [] });\n  setup0(S);\n  plan(S, true);\n  for (let i = 0; i \u003c 140; i++) S.motes.push({ x: (Math.random() * 2 - 1) * HW, y: Math.random() * HC, z: -Math.random() * 1.6, ph: Math.random() * 6.3, f: 0.5 + Math.random() });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.reach = cl(k[2], 0, 1);\n  S.haze = cl(k[3], 0, 1);\n  const ft = cl(dt || 0, 0, 0.1), st = (ft * S.speed) / 2, c = S.cy;\n  S.t += st;\n  S.ct += st;\n  if (input.btnPressed && input.btnPressed[0]) {\n    if (S.ct \u003c c.slam && S.ct > c.open0) c.slam = S.ct;\n    else if (S.ct > c.slam + 0.3) S.ct = c.end + 1;\n  }\n  if (S.ct > c.end) {\n    plan(S, false);\n    if (input.btnPressed && input.btnPressed[0]) S.ct = S.cy.open0;\n  }\n  const ct = S.ct, cc = S.cy;\n  // The door's angle.\n  let th = 0;\n  if (ct \u003c cc.open0) th = 0;\n  else if (ct \u003c cc.slam) th = creak(cc, cl((ct - cc.open0) / cc.dur, 0, 1));\n  else {\n    const e = ct - cc.slam, a0 = creak(cc, cl((cc.slam - cc.open0) / cc.dur, 0, 1));\n    th = e \u003c 0.14 ? a0 * (1 - (e / 0.14) ** 2) : 0.025 * exp(-(e - 0.14) * 9) * abs(sin((e - 0.14) * 30));\n    if (e >= 0.14 && S.slamT \u003c cc.slam) {\n      S.slamT = cc.slam;\n      for (let i = 0; i \u003c 28; i++) S.falls.push({ x: (Math.random() * 2 - 1) * (DW + TRIM), y: DH + TRIM + Math.random() * 0.05, z: -0.01 - Math.random() * 0.1, v: -Math.random() * 2.5, m: 0.2 + Math.random() * 0.45, a: 1.3 + Math.random(), w: Math.random() * 6 });\n    }\n  }\n  S.th = th;\n  S.sn = sin(th);\n  S.cs = cos(th);\n  // Shake after the slam.\n  const e = ct - cc.slam - 0.14;\n  if (e > 0 && e \u003c 0.8) {\n    const A = 3 * exp(-e * 3.5);\n    S.shake = [round(A * sin(e * 83)), round(0.6 * A * sin(e * 61 + 1))];\n  } else S.shake = [0, 0];\n  // After the slam two feet cross the light under the door, right to left,\n  // and a while later the keyhole goes dark: an eye on the other side.\n  S.feet = e > 1 && e \u003c 2.8 ? (e - 1) / 1.8 : -1;\n  S.peep = !(e > 3 && e \u003c 3.5);\n  // Candle flicker.\n  S.flick = 1 + 0.13 * vn(S.t * 9, 3) + 0.06 * vn(S.t * 23, 5);\n  // The shadow.\n  S.mk.fill(0);\n  const sh = ct - cc.sh0;\n  if (sh > 0 && sh \u003c 4) {\n    const u = sh / 4;\n    if (cc.kind === 0) {\n      const reach = sm(u / 0.4) - 1.5 * sm((u - 0.78) / 0.22);\n      hand(S, 0.05 + 0.08 * sin(sh * 0.9), 0.6 - 1.1 * reach, 0.12 * sin(sh * 1.3), 0.75 * sm((u - 0.45) / 0.2) - 0.75 * sm((u - 0.72) / 0.1));\n    } else figure(S, 0.75 - 1.3 * u, sh * 7);\n  }\n  // Dust falling from the lintel after the slam.\n  for (const f of S.falls) {\n    f.v = min(f.m, f.v + 1.5 * st);\n    f.y -= max(0, f.v) * st;\n    f.x += 0.04 * sin(S.t * 3 + f.w) * st;\n    f.z -= 0.03 * st;\n    f.a -= st * 0.45;\n  }\n  S.falls = S.falls.filter((f) => f.y > 0 && f.a > 0);\n  for (const m of S.motes) {\n    m.x += 0.03 * vn(S.t * 0.5 + m.ph * 10, 1) * st;\n    m.y += (0.02 * vn(S.t * 0.4 + m.ph * 7, 2) - 0.01) * st;\n    if (m.y \u003c 0) m.y += HC;\n    if (abs(m.x) > HW) m.x = -m.x * 0.98;\n  }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n// Warm light by amount: deep red when faint, orange, then pale gold, so it\n// never sinks to brown.\nconst RAMP = 256, RMAX = 2;\nfunction ramp(S) {\n  if (S.rh === S.hue) return;\n  S.rh = S.hue;\n  const T = (S.rt = S.rt || new Float32Array(RAMP * 3)), o = [0, 0, 0];\n  for (let j = 0; j \u003c RAMP; j++) {\n    const w = (j / (RAMP - 1)) * RMAX;\n    hsv(S.hue + 0.11 * min(1, w), 1 - 0.55 * cl(w - 0.9, 0, 1), pow(min(1, w * 1.6), 0.7), o);\n    T[j * 3] = o[0];\n    T[j * 3 + 1] = o[1];\n    T[j * 3 + 2] = o[2];\n  }\n}\n\n// 0 where a foot stands in the gap under the door, 1 elsewhere.\nfunction feet(S, x, d) {\n  if (S.feet \u003c 0) return 1;\n  const r = 0.05 + 0.3 * d;\n  const u = S.feet, step = u * 5, a = DW + 0.15 - (2 * DW + 0.3) * (floor(step) + sm((step % 1) * 2)) / 5;\n  const b = DW + 0.15 - (2 * DW + 0.3) * (floor(step + 0.5) + sm(((step + 0.5) % 1) * 2) - 0.5) / 5 + 0.13;\n  return abs(x - a) \u003c r || abs(x - b) \u003c r ? 0.08 : 1;\n}\n\n// Candle light at a point facing (nx, ny, nz); nx = 2 for a mote or a speck\n// of haze, which faces every way.\nfunction lightAt(S, x, y, z, nx, ny, nz) {\n  const lx = LX - x, ly = LY - y, lz = LZ - z, d2 = lx * lx + ly * ly + lz * lz, d = sqrt(d2), lam = nx === 2 ? 1 : (nx * lx + ny * ly + nz * lz) / d;\n  if (lam \u003c= 0) return 0;\n  return lam / (1 + d2 / (S.D * S.D));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const g = S.geo, T = S.rt, buf = S.buf, lf = S.lf, I = LI * S.flick;\n  S.D = 0.9 * pow(2.6, S.reach);\n  if (S.D0 !== S.D) {\n    S.D0 = S.D;\n    for (let p = 0; p \u003c N; p++) {\n      const k = g.kind[p];\n      if (k === DOOR) continue;\n      const n = NRM[k];\n      lf[p] = lightAt(S, g.P[p * 3], g.P[p * 3 + 1], g.P[p * 3 + 2], n[0], n[1], n[2]) * g.alb[p];\n    }\n  }\n  const s = S.sn, c = S.cs, shut = S.th \u003c 0.03;\n  // Haze: light scattered towards the eye along each ray, at half size.\n  const hz = S.hz, hk = 0.02 + 0.3 * S.haze * S.haze;\n  for (let j = 0; j \u003c 64; j++)\n    for (let i = 0; i \u003c 32; i++) {\n      const p = (j * 2) * W + i * 2, dx = g.d[p * 2], dy = g.d[p * 2 + 1], tz = min(0, g.tz[p]);\n      let a = 0;\n      if (!shut) {\n        const t0 = 1.2, t1 = tz + ZC, n = 8, h = (t1 - t0) / n;\n        for (let q = 0; q \u003c n; q++) {\n          const t = t0 + (q + 0.5) * h, x = dx * t, y = EYE + dy * t, z = -ZC + t;\n          if (z > -1.8) a += vis(S, x, y, z) * lightAt(S, x, y, z, 2, 0, 0) * h;\n        }\n      }\n      hz[j * 32 + i] = a * hk;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, k = g.kind[p];\n      let w = 0, ar = g.amb[p * 3], ag = g.amb[p * 3 + 1], ab = g.amb[p * 3 + 2];\n      if (k === DOOR) {\n        const dx = g.d[p * 2], dy = g.d[p * 2 + 1], nC = s * DW + c * ZC, nd = s * dx - c, t = -nC / nd;\n        let hit = false;\n        if (t > ZC - 1e-6 && t \u003c 1e8) {\n          const X = dx * t, Y = EYE + dy * t, Z = -ZC + t, u = (X + DW) * c + Z * s;\n          if (u >= 0 && u \u003c= 2 * DW && Y >= GAP && Y \u003c= DH && Z \u003c= g.R[p * 3 + 2]) {\n            hit = true;\n            // The door's face: stiles, rails and four sunk panels.\n            const pu = u / (2 * DW), pv = Y / DH, inP = pu > 0.13 && pu \u003c 0.87 && ((pv > 0.08 && pv \u003c 0.43) || (pv > 0.52 && pv \u003c 0.93)) && abs(pu - 0.5) > 0.04;\n            const edge = inP && (pu \u003c 0.16 || pu > 0.84 || abs(pu - 0.5) \u003c 0.07 || abs(pv - 0.08) \u003c 0.02 || abs(pv - 0.43) \u003c 0.02 || abs(pv - 0.52) \u003c 0.02 || abs(pv - 0.93) \u003c 0.02);\n            const knob = (pu - 0.88) ** 2 * 4 + (pv - 0.48) ** 2 \u003c 0.0004, key = shut && S.peep && abs(pu - 0.88) \u003c 0.012 && abs(pv - 0.44) \u003c 0.012;\n            const f = knob ? 1.8 : edge ? 0.55 : inP ? 1.12 : 1;\n            ar = 42 * f;\n            ag = 20 * f;\n            ab = 38 * f;\n            w = lightAt(S, X, Y, Z, s, 0, -c) * 0.7 * f;\n            if (key) w = 0.8 * S.flick;\n          }\n        }\n        if (!hit) {\n          const R = g.R, X = R[p * 3], Y = R[p * 3 + 1], Z = R[p * 3 + 2];\n          ar = g.ramb[p * 3];\n          ag = g.ramb[p * 3 + 1];\n          ab = g.ramb[p * 3 + 2];\n          w = shut ? 0 : (doorBlocks(S, X, Y, Z) ? 0.08 : (lightAt(S, X, Y, Z, g.rn[p * 3], g.rn[p * 3 + 1], g.rn[p * 3 + 2]) * RI) / LI) * (ar / 40);\n          if (Y \u003c GAP * 2 && shut) w = 0.9 * feet(S, X, 0);\n        }\n        w *= I;\n      } else if (lf[p] > 0) w = lf[p] * I * vis(S, g.P[p * 3], g.P[p * 3 + 1], g.P[p * 3 + 2]);\n      // Light leaking under a shut door onto the boards just in front.\n      if (k === FLOOR && shut && g.P[p * 3 + 2] > -0.3 && abs(g.P[p * 3]) \u003c DW + 0.1) {\n        const z = g.P[p * 3 + 2], e = 1 + z / 0.3;\n        w += 0.55 * S.flick * e * e * cl((DW + 0.1 - abs(g.P[p * 3])) / 0.1, 0, 1) * feet(S, g.P[p * 3], -z);\n      }\n      // The haze, laid back over the full panel between its four nearest.\n      const hy = cl((y - 0.5) / 2, 0, 62.999), hx = cl((x - 0.5) / 2, 0, 30.999), iy = floor(hy), ix = floor(hx), fy = hy - iy, fx = hx - ix, q = iy * 32 + ix;\n      w += (hz[q] * (1 - fx) * (1 - fy) + hz[q + 1] * fx * (1 - fy) + hz[q + 32] * (1 - fx) * fy + hz[q + 33] * fx * fy) * I;\n      const j = 3 * min(RAMP - 1, round((w / RMAX) * (RAMP - 1))), keep = max(0, 1 - 2 * w);\n      buf[p * 3] = ar * keep + T[j];\n      buf[p * 3 + 1] = ag * keep + T[j + 1];\n      buf[p * 3 + 2] = ab * keep + T[j + 2];\n    }\n  // Dust in the beam.\n  for (const m of shut ? [] : S.motes) {\n    const v = vis(S, m.x, m.y, m.z);\n    if (!v) continue;\n    const t = m.z + ZC, x = floor(CX + (F * m.x) / t), y = floor(CY - (F * (m.y - EYE)) / t);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const a = lightAt(S, m.x, m.y, m.z, 2, 0, 0) * I * (0.5 + 0.5 * sin(S.t * 6 * m.f + m.ph * 9)) * (0.5 + 2 * S.haze), p = (y * W + x) * 3;\n    buf[p] += 255 * a;\n    buf[p + 1] += 170 * a;\n    buf[p + 2] += 90 * a;\n  }\n  for (const f of S.falls) {\n    const t = f.z + ZC, x = floor(CX + (F * f.x) / t), y = floor(CY - (F * (f.y - EYE)) / t);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const p = (y * W + x) * 3, a = min(1, f.a) * (0.6 + 0.4 * sin(S.t * 7 + f.w * 5));\n    buf[p] += 90 * a;\n    buf[p + 1] += 78 * a;\n    buf[p + 2] += 110 * a;\n  }\n  const [ox, oy] = S.shake;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const sx = x - ox, sy = y - oy;\n      if (sx \u003c 0 || sx >= W || sy \u003c 0 || sy >= H) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const p = (sy * W + sx) * 3;\n      display.setPixel(x, y, min(252, round(buf[p] / 4) * 4), min(252, round(buf[p + 1] / 4) * 4), min(252, round(buf[p + 2] / 4) * 4));\n    }\n}\n","de-bruijn-sequence":"// ===== Patternflow pattern =====\n// Title:   de Bruijn Sequence\n// Family:  rhythm\n// Idea:    A binary de Bruijn sequence plays as a rhythm, a hit for each 1 and a rest for each 0, and each beat its window of the last k bits lights the one tile of a board of all 2^k words that it spells, so the board fills exactly once a cycle while the jumps from tile to tile trace a Hamiltonian cycle and the same words light one by one as the threads of the order k-1 de Bruijn graph below the tape.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: de Bruijn sequence (Nicolaas Govert de Bruijn, 1946)\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rule=0..2, Zoom=0..3\n//\n// Knob 1: Hue. Each word takes its colour from when it comes in the cycle, a sweep of three tenths of the wheel from the first word to the last: cyan through blue to violet at 0, violet to magenta and red at 0.25, red through yellow to green at 0.5, lime to cyan at 0.75.\n// Knob 2: Speed. Three bits a second for each unit: 6 at the opening 2, so the 64 words of order 6 take 10.7 s; 0.6 a second at 0.2 and 9 at 3.\n// Knob 3: Rule. Which sequence plays. At 0 a new one every cycle, drawn uniformly from all 67,108,864 of order 6 (2,048 of order 5, 16 of order 4, 2 of order 3): a random spanning tree of the order k-1 graph by Wilson's loop-erased walks, then the Eulerian circuit that leaves each vertex by its tree edge last (the BEST theorem). At 1 Martin's prefer-one rule (1934), the same every cycle, which runs down the right column and along the bottom row early on. At 2 a maximal shift register, x^k + x + 1 (x^5 + x^2 + 1 at order 5), which never makes the all-zero word: its 2^k - 1 beats, 63 at order 6, leave the top left tile dark and the first slot of the tape empty.\n// Knob 4: Zoom. The order k, 6 minus the knob rounded: 6 at 0 is 64 words on 8 by 8 tiles 8 LEDs apart, with 1 LED a bit on the tape; 5 at 1 gives 32 tiles 8 by 16; 4 at 2 gives 16 tiles of 16 by 16; 3 at 3 gives 8 tall tiles, and there Martin's rule plays 01110100, the light and heavy syllables of ya mā tā rā ja bhā na sa, the Sanskrit prosody mnemonic yamātārājabhānasalagāḥ.\n// Buttons: K1 tap ends the cycle now: the board flashes and fades and a new sequence starts from the all-zero word.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hsv = (h, s, v, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + (h - floor(h)) * 6) % 6;\n  o[c] = 255 * v * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\n// The board fills the top 64 rows; the tape and the loom share the rest.\nconst BY = 0, BH = 64, TY = 68, TH = 6, LY0 = 82, LY1 = 125;\n\n// A uniformly random binary de Bruijn sequence of order k, by the BEST\n// theorem: a random spanning arborescence of the order k-1 graph into the\n// all-zero vertex (Wilson's loop-erased walks), then the Eulerian circuit\n// that leaves every other vertex by its tree edge last.\nfunction randomSeq(k) {\n  const M = 1 \u003c\u003c (k - 1), m = M - 1, inT = new Uint8Array(M), nb = new Uint8Array(M);\n  inT[0] = 1;\n  for (let v = 1; v \u003c M; v++) {\n    let u = v;\n    while (!inT[u]) (nb[u] = Math.random() \u003c 0.5 ? 0 : 1), (u = ((u \u003c\u003c 1) | nb[u]) & m);\n    for (u = v; !inT[u]; u = ((u \u003c\u003c 1) | nb[u]) & m) inT[u] = 1;\n  }\n  const used = new Uint8Array(M), s = new Uint8Array(2 * M);\n  for (let i = 0, v = 0; i \u003c 2 * M; i++) {\n    const b = v === 0 ? used[v] : used[v] ? nb[v] : 1 - nb[v];\n    used[v]++;\n    s[i] = b;\n    v = ((v \u003c\u003c 1) | b) & m;\n  }\n  return s;\n}\n// Martin's rule (1934): from k zeros, append a 1 whenever the new word is\n// new, else a 0.\nfunction martin(k) {\n  const L = 1 \u003c\u003c k, mask = L - 1, seen = new Uint8Array(L), s = new Uint8Array(L);\n  seen[0] = 1;\n  for (let i = 1, w = 0; i \u003c L; i++) {\n    const b = seen[((w \u003c\u003c 1) | 1) & mask] ? 0 : 1;\n    w = ((w \u003c\u003c 1) | b) & mask;\n    seen[w] = 1;\n    s[i] = b;\n  }\n  return s;\n}\n// A maximal-length shift register, x^k + x^a + 1: every word but the\n// all-zero one, so slot 0 of the tape stays empty.\nconst TAP = [0, 0, 0, 1, 1, 2, 1];\nfunction lfsr(k) {\n  const L = 1 \u003c\u003c k, s = new Uint8Array(L), r = new Uint8Array(L + k);\n  r[k - 1] = 1;\n  for (let i = k; i \u003c L + k; i++) r[i] = r[i - k] ^ r[i - k + TAP[k]];\n  // Turn it so the run of k-1 zeros comes last; the missing zero is slot 0.\n  let z = 0;\n  for (let i = 0; i \u003c L - 1; i++) {\n    let ok = r[i] === 1;\n    for (let j = 1; j \u003c k && ok; j++) ok = r[(i - j + L - 1) % (L - 1)] === 0;\n    if (ok) z = i;\n  }\n  for (let i = 1; i \u003c L; i++) s[i] = r[(z + i - 1) % (L - 1)];\n  return s;\n}\n\nexport function setup(params) {\n  params.s = {\n    pos: 0, k: 0, rule: -1, hue: 0, start: 0, seq: null, word: null, old: null, oldAge: 9,\n    buf: new Float32Array(N * 3), c: [0, 0, 0],\n  };\n}\n\nfunction newCycle(S) {\n  const k = S.k;\n  S.seq = S.rule === 0 ? randomSeq(k) : S.rule === 1 ? martin(k) : lfsr(k);\n  const L = 1 \u003c\u003c k, w = new Int16Array(L);\n  for (let i = 0; i \u003c L; i++) {\n    let v = 0;\n    for (let j = k - 1; j >= 0; j--) v = (v \u003c\u003c 1) | S.seq[(i - j + L) % L];\n    w[i] = v;\n  }\n  S.word = w;\n  S.start = S.rule === 2 ? 1 : 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kn[0], 0, 1);\n  const rule = round(cl(kn[2], 0, 2)), k = 6 - round(cl(kn[3], 0, 3));\n  if (k !== S.k || rule !== S.rule) {\n    S.k = k;\n    S.rule = rule;\n    newCycle(S);\n    S.pos = S.start;\n    S.old = null;\n  }\n  // Bits a second: three for each unit of Speed.\n  const L = 1 \u003c\u003c S.k, rate = 3 * cl(kn[1], 0.2, 3);\n  S.pos += d * rate;\n  if (input.btnPressed && input.btnPressed[0]) S.pos = L;\n  if (S.pos >= L) {\n    // The cycle is complete: keep the full board to fade, draw the next.\n    S.old = { word: S.word, start: S.start };\n    S.oldAge = 0;\n    newCycle(S);\n    S.pos = S.start + (S.pos - floor(S.pos));\n  }\n  if (S.old) S.oldAge += d * rate;\n}\n\n// Cell of word w on the board: columns and rows of a 64x64 square.\nfunction cell(k, w) {\n  const cols = 1 \u003c\u003c ((k + 1) >> 1), rows = 1 \u003c\u003c (k >> 1), cw = W / cols, ch = BH / rows;\n  return [(w % cols) * cw, BY + floor(w / cols) * ch, cw, ch];\n}\nfunction add(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += r;\n  buf[o + 1] += g;\n  buf[o + 2] += b;\n}\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0), 1);\n  for (let i = 0; i \u003c= n; i++) add(buf, round(x0 + ((x1 - x0) * i) / n), round(y0 + ((y1 - y0) * i) / n), c[0] * a, c[1] * a, c[2] * a);\n}\nfunction rect(buf, x0, y0, w, h, r, g, b) {\n  for (let y = y0; y \u003c y0 + h; y++) for (let x = x0; x \u003c x0 + w; x++) add(buf, x, y, r, g, b);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.seq) return;\n  const buf = S.buf, k = S.k, L = 1 \u003c\u003c k, M = L >> 1, i = floor(S.pos), f = S.pos - i, c = S.c;\n  buf.fill(0);\n  // Colour of the n-th word of the cycle: a sweep along the wheel.\n  const col = (n, out) => hsv(S.hue + 0.5 + (0.3 * n) / L, 0.7, 1, out);\n  const hit = S.seq[i], beat = exp(-f * 5);\n  const ctr = (w) => {\n    const [x, y, cw, ch] = cell(k, w);\n    return [round(x + cw / 2 - 0.5), round(y + ch / 2 - 0.5)];\n  };\n  // The path so far, under the tiles: it shows only in the gaps.\n  for (let j = S.start + 1; j \u003c= i - 6; j++) {\n    col(j, c);\n    line(buf, ...ctr(S.word[j - 1]), ...ctr(S.word[j]), c, 0.22);\n  }\n  // The board: every word a tile, dim until its turn.\n  const step = new Int16Array(L).fill(-1), ostep = new Int16Array(L).fill(-1), O = S.old, fade = O ? max(0, 1 - S.oldAge / 4) : 0;\n  for (let j = S.start; j \u003c= i; j++) step[S.word[j]] = j;\n  if (fade > 0) for (let j = O.start; j \u003c L; j++) ostep[O.word[j]] = j;\n  for (let w = 0; w \u003c L; w++) {\n    const [x, y, cw, ch] = cell(k, w), j = step[w];\n    if (j \u003c 0) {\n      // Not yet this cycle: the last cycle's full board fading out, after a\n      // flash on the downbeat that completed it.\n      let r = 14, g = 16, b = 22;\n      if (fade > 0 && ostep[w] >= 0) {\n        col(ostep[w], c);\n        const a = 0.5 * fade, e = 160 * max(0, 1 - S.oldAge * 1.5);\n        (r = max(r, c[0] * a + e)), (g = max(g, c[1] * a + e)), (b = max(b, c[2] * a + e));\n      }\n      fill(buf, x + 1, y + 1, cw - 2, ch - 2, r, g, b);\n      continue;\n    }\n    col(j, c);\n    const now = j === i, a = now ? (hit ? 1 : 0.75) : 0.5, g = now ? (hit ? 220 : 70) * beat : 0;\n    fill(buf, x + 1, y + 1, cw - 2, ch - 2, c[0] * a + g, c[1] * a + g, c[2] * a + g);\n    // A hit rings the tile's edge.\n    if (now && hit) {\n      const r = (c[0] * 0.6 + 40) * beat, gg = (c[1] * 0.6 + 40) * beat, bb = (c[2] * 0.6 + 40) * beat;\n      rect(buf, x + 1, y, cw - 2, 1, r, gg, bb);\n      rect(buf, x + 1, y + ch - 1, cw - 2, 1, r, gg, bb);\n      rect(buf, x, y + 1, 1, ch - 2, r, gg, bb);\n      rect(buf, x + cw - 1, y + 1, 1, ch - 2, r, gg, bb);\n    }\n  }\n  // The last jumps on top, fading with age.\n  for (let j = max(S.start + 1, i - 6); j \u003c= i; j++) {\n    col(j, c);\n    line(buf, ...ctr(S.word[j - 1]), ...ctr(S.word[j]), c, 0.22 + 0.7 * exp(-(i - j + f) / 2));\n  }\n  // The tape: the whole cycle, one slot per bit, the window bracketed.\n  const sw = W / L, bw = max(1, floor(sw));\n  for (let j = S.start; j \u003c L; j++) {\n    const played = j \u003c= i, x = floor(j * sw);\n    col(j, c);\n    const a = S.seq[j] ? (played ? 0.95 : 0.3) : played ? 0.1 : 0.04;\n    rect(buf, x, TY, bw, TH, c[0] * a, c[1] * a, c[2] * a);\n  }\n  for (let q = 0; q \u003c k; q++) {\n    const j = (i - q + L) % L, x = floor(j * sw), g = 150 + 100 * beat * hit;\n    rect(buf, x, TY - 2, bw, 1, g, g, g);\n    rect(buf, x, TY + TH + 1, bw, 1, g, g, g);\n    if (q === 0 && hit) rect(buf, x, TY, bw, TH, 160 * beat, 160 * beat, 160 * beat);\n  }\n  // The loom: each word is a thread from its first k-1 bits, along the top,\n  // to its last k-1 bits along the bottom: the order k-1 de Bruijn graph.\n  const nx = (v) => (v + 0.5) * (W / M) - 0.5, th = max(1, round(12 / M));\n  if (fade > 0)\n    for (let j = O.start; j \u003c L; j++) {\n      col(j, c);\n      thread(buf, nx(O.word[j] >> 1), nx(O.word[j] & (M - 1)), c, 0.12 * fade, th);\n    }\n  for (let j = S.start; j \u003c= i; j++) {\n    const w = S.word[j], age = i - j + f;\n    col(j, c);\n    thread(buf, nx(w >> 1), nx(w & (M - 1)), c, j === i ? (hit ? 1 : 0.6) : 0.12 + 0.5 * exp(-age / 2.5), th);\n  }\n  for (let v = 0; v \u003c M; v++) {\n    rect(buf, round(nx(v)), LY0 - 2, 1, 1, 90, 90, 100);\n    rect(buf, round(nx(v)), LY1 + 2, 1, 1, 90, 90, 100);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\nfunction fill(buf, x0, y0, w, h, r, g, b) {\n  for (let y = y0; y \u003c y0 + h; y++)\n    for (let x = x0, o = (y * W + x) * 3; x \u003c x0 + w; x++, o += 3) (buf[o] = r), (buf[o + 1] = g), (buf[o + 2] = b);\n}\n// A thread of the loom: an S from top to bottom, eased at both ends, wider\n// when there are fewer of them.\nfunction thread(buf, x0, x1, c, a, th) {\n  const n = max(LY1 - LY0, abs(x1 - x0) * 2);\n  let px = -1, py = -1;\n  for (let s = 0; s \u003c= n; s++) {\n    const t = s / n, e = t * t * (3 - 2 * t), x = round(x0 + (x1 - x0) * e - (th - 1) / 2), y = round(LY0 + (LY1 - LY0) * t);\n    if (x === px && y === py) continue;\n    for (let q = 0; q \u003c th; q++) add(buf, x + q, y, c[0] * a, c[1] * a, c[2] * a);\n    (px = x), (py = y);\n  }\n}\n","force-chains":"// ===== Patternflow pattern =====\n// Title:   Force Chains\n// Family:  particle\n// Idea:    About 175 soft discs fill a tall box seen in white light between crossed circular polarisers and are squeezed in turn by a piston on top and by the side walls, and only the discs that carry the load light up in isochromatic fringes, grey, white, yellow, orange, red, violet and blue, along branching chains that swing from upright to sideways and find new paths as the push moves, while the discs between them stay dark.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: photoelastic force chains (Pierre Dantu, 1957; Trushant Majmudar and Robert Behringer, 2005), pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Analyser=0..1, Speed=0.2..3, Load=-1..1, Grain=0..1\n//\n// Knob 1: Analyser. Turns the analyser away from crossed, a quarter turn over the range. At 0 the field is dark: an unloaded disc is black and only the loaded ones light up; turning it shifts every fringe along the colour sequence, and at 1 the field is light: unloaded discs shine white and the chains show as dark and coloured bands.\n// Knob 2: Speed. At 2 a round takes 6 s: the piston presses hardest at 0 s while the walls ease off, and at 3 s the walls squeeze hardest while the piston eases to a fifth. In each squeeze one wall pushes three times as hard as the other, the left in one round and the right in the next, so the pile leans one way and then the other and the whole sequence takes 12 s. At 0.2 it is ten times slower, at 3 half as fast again; the discs always move at their own pace.\n// Knob 3: Load. The hardest push of the piston and of the walls, as a multiple of the weight of the pile spread over the floor: 1.5 at -1, 3 at 0 and 6 at 1. At -1 the chains are thin and grey-white with a little yellow; at 1 they thicken and the strongest discs low in the pile run through red and blue into the pale pinks and greens of high orders.\n// Knob 4: Grain. The size of the discs: at 0.06 they are 6.3 and 8.1 LEDs across, 175 of them; at 0.5 8.5 and 11, 95 of them; at 1 12 and 15.6, 48 discs whose fringes show the whole pattern of a disc squeezed at its contacts. A new size pours a new pile.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, PI, pow, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Gravity in LEDs a second squared, physics steps a frame, and the most\n// contacts one disc keeps.\nconst G = 50, SUB = 16, MC = 8;\n// Normal stiffness per unit of the weight pressure on the floor, tangential\n// stiffness as a share of it, the friction coefficient, the share of critical\n// damping a contact gets along its normal and the share of that along its\n// tangent, and the drag every disc feels, per second.\nconst KS = 150, KT = 0.4, MU = 0.5, ZETA = 0.35, TD = 0.2, DRAG = 2.5;\n// One round at Speed 2 in seconds. The piston and the two side walls are\n// heavy plates pushed with set pressures, as shares of the Load: the piston\n// from SY0 to SY1 and the walls from SX0 to SX1 and back. Each wall is NS\n// plates stacked up its height, like a membrane, so the squeeze does not all\n// land on the stiff bottom of the pile. A wall plate stops at WOUT LEDs\n// outside the panel's edge and WIN inside it. One wall pushes 1 + LEAN of\n// the set pressure and the other 1 - LEAN, the left in one round and the\n// right in the next, and the pile leans.\nconst T_R = 6, SY0 = 1, SY1 = 0.2, SX0 = 0.2, SX1 = 1, NS = 8, WOUT = 2, WIN = 3, PD = 30, LEAN = 0.5;\n// White-light fringe colours: retardation in nanometres per LUT step, the\n// steps, and the wavelength the fringe order is counted at.\nconst LS = 3, LN = 1024, L0 = 560;\n// Contact softening: the squared radius in LEDs over which a point load spreads.\nconst A2 = 0.25;\n// Fringes made by the weight pressure on the floor, and the LUT's gamma.\nconst FR = 0.09, GAM = 1.0;\n\n// CIE 1931 colour matching, as the piecewise Gaussian fit of Wyman, Sloan\n// and Shirley (2013).\nconst gp = (l, m, s1, s2) => {\n  const t = (l - m) / (l \u003c m ? s1 : s2);\n  return exp(-0.5 * t * t);\n};\nconst XB = (l) => 1.056 * gp(l, 599.8, 37.9, 31) + 0.362 * gp(l, 442, 16, 26.7) - 0.065 * gp(l, 501.1, 20.4, 26.2);\nconst YB = (l) => 0.821 * gp(l, 568.8, 46.9, 40.5) + 0.286 * gp(l, 530.9, 16.3, 31.1);\nconst ZB = (l) => 1.217 * gp(l, 437, 11.8, 36) + 0.681 * gp(l, 459, 26, 13.8);\n\n// The colour seen through a circular polariscope at each retardation, for an\n// analyser turned beta from crossed: each wavelength passes sin^2(pi R/l + beta).\nfunction buildLut(S, beta) {\n  const lut = S.lut, ws = [];\n  for (let l = 400; l \u003c= 700; l += 10) ws.push(l);\n  let wr = 0, wg = 0, wb = 0;\n  const rgb = (X, Y, Z) => [3.2406 * X - 1.5372 * Y - 0.4986 * Z, -0.9689 * X + 1.8758 * Y + 0.0415 * Z, 0.0557 * X - 0.204 * Y + 1.057 * Z];\n  {\n    let X = 0, Y = 0, Z = 0;\n    for (const l of ws) (X += XB(l)), (Y += YB(l)), (Z += ZB(l));\n    [wr, wg, wb] = rgb(X, Y, Z);\n  }\n  for (let i = 0; i \u003c LN; i++) {\n    const R = i * LS;\n    let X = 0, Y = 0, Z = 0;\n    for (const l of ws) {\n      const s = sin((PI * R) / l + beta), I = s * s;\n      X += I * XB(l);\n      Y += I * YB(l);\n      Z += I * ZB(l);\n    }\n    const c = rgb(X, Y, Z);\n    lut[i * 3] = pow(cl(c[0] / wr, 0, 1), GAM) * 255;\n    lut[i * 3 + 1] = pow(cl(c[1] / wg, 0, 1), GAM) * 255;\n    lut[i * 3 + 2] = pow(cl(c[2] / wb, 0, 1), GAM) * 255;\n  }\n  S.beta = beta;\n}\n\nconst NMAX = 400, WALL = 1000;\nexport function setup(params) {\n  const F = (k) => new Float64Array(NMAX * k);\n  params.s = {\n    u: 0, speed: 2, load: 3, grain: -1, beta: -1, n: 0, rm: 3, gen: 0,\n    x: F(1), y: F(1), vx: F(1), vy: F(1), w: F(1), r: F(1), m: F(1), fx: F(1), fy: F(1), tq: F(1),\n    nb: new Int32Array(NMAX * MC).fill(-1), xi: F(MC), sg: new Int32Array(NMAX * MC),\n    cn: new Uint8Array(NMAX), cux: new Float32Array(NMAX * MC), cuy: new Float32Array(NMAX * MC),\n    cfx: new Float32Array(NMAX * MC), cfy: new Float32Array(NMAX * MC),\n    head: new Int32Array(4096), next: new Int32Array(NMAX),\n    wi: new Float64Array(2 * NS), wv: new Float64Array(2 * NS), wf: new Float64Array(2 * NS), lean: 0, yp: 0, vp: 0, mp: 1, fp: 0, fw: 0,\n    k: 1, c: 0, kt: 1, mg: 1, gw: 1, gh: 1, cs: 8,\n    lut: new Float32Array(LN * 3), buf: new Uint8Array(NP * 3), cc: new Float64Array(MC * 4),\n  };\n}\n\n// Pours a new pile: half small discs and half large ones, 1.3 times wider, so\n// the packing stays disordered. The discs are dropped anywhere in the box at\n// a fifth of their size and grown while overlapping pairs are pushed apart,\n// then the pile settles under gravity and the piston.\nfunction pour(S, grain) {\n  S.grain = grain;\n  const rm = 3.6 * pow(2, grain - 0.06), rs = rm * 0.87, rl = rm * 1.13;\n  S.rm = rm;\n  const bw = W + 2 * WOUT, area = 0.82 * bw * (H + 2), n = min(NMAX, Math.round(area / (PI * (rs * rs + rl * rl) * 0.5)));\n  const top = H - (H * 0.82) / 0.78;\n  S.n = n;\n  let mg = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const r = i & 1 ? rs : rl;\n    S.r[i] = r;\n    S.m[i] = r * r;\n    S.x[i] = -WOUT + r + Math.random() * (bw - 2 * r);\n    S.y[i] = top + r + Math.random() * (H - top - 2 * r);\n    S.vx[i] = S.vy[i] = S.w[i] = 0;\n    mg += r * r * G;\n  }\n  S.nb.fill(-1);\n  S.mg = mg;\n  S.cs = 2 * rl + 0.01;\n  S.gw = floor((W + 8) / S.cs) + 1;\n  S.gh = floor((H + 200) / S.cs) + 1;\n  for (let it = 0; it \u003c 90; it++) grow(S, min(1, 0.2 + it / 50), top);\n  // Stiffness and damping scale with the weight pressure on the floor, so a\n  // contact squeezes the same share of a radius whatever the grain.\n  S.k = (KS * mg) / W;\n  S.kt = KT * S.k;\n  S.c = 2 * ZETA * sqrt(S.k * rm * rm * 0.5);\n  S.mp = (0.15 * mg) / G;\n  let ymin = H;\n  for (let i = 0; i \u003c n; i++) ymin = min(ymin, S.y[i] - S.r[i]);\n  S.yp = ymin;\n  S.vp = 0;\n  S.wi.fill(-WOUT);\n  S.wv.fill(0);\n  press(S, 0);\n  for (let i = 0; i \u003c 50 * SUB; i++) step(S, 1 / 30 / SUB, 8, false);\n}\n\n// One pass of growing: radii at share s of their size, every overlapping\n// pair pushed apart by its overlap, half each, and the walls pushing back.\nfunction grow(S, s, top) {\n  const { n, x, y, r, head, next } = S;\n  const cs = S.cs, gw = S.gw, gh = S.gh, off = 200;\n  head.fill(-1, 0, gw * gh);\n  for (let i = 0; i \u003c n; i++) {\n    const o = cl(floor((y[i] + off) / cs), 0, gh - 1) * gw + cl(floor((x[i] + 4) / cs), 0, gw - 1);\n    next[i] = head[o];\n    head[o] = i;\n  }\n  for (let gy = 0; gy \u003c gh; gy++)\n    for (let gx = 0; gx \u003c gw; gx++)\n      for (let i = head[gy * gw + gx]; i >= 0; i = next[i])\n        for (let dy = 0; dy \u003c= 1; dy++)\n          for (let dx = -1; dx \u003c= 1; dx++) {\n            if (dy === 0 && dx \u003c 0) continue;\n            const hx = gx + dx, hy = gy + dy;\n            if (hx \u003c 0 || hx >= gw || hy >= gh) continue;\n            for (let j = dy === 0 && dx === 0 ? next[i] : head[hy * gw + hx]; j >= 0; j = next[j]) {\n              const ddx = x[j] - x[i], ddy = y[j] - y[i], rr = (r[i] + r[j]) * s, d2 = ddx * ddx + ddy * ddy;\n              if (d2 >= rr * rr) continue;\n              const d = sqrt(d2) || 1e-6, p = (0.5 * (rr - d)) / d;\n              x[i] -= ddx * p;\n              y[i] -= ddy * p;\n              x[j] += ddx * p;\n              y[j] += ddy * p;\n            }\n          }\n  for (let i = 0; i \u003c n; i++) {\n    const ri = r[i] * s;\n    x[i] = cl(x[i], ri - WOUT, W + WOUT - ri);\n    y[i] = cl(y[i], top + ri, H - ri);\n  }\n}\n\n// The slot that holds the tangential spring between disc a and body id, made\n// if there is none and room for one.\nfunction slot(S, a, id) {\n  const nb = S.nb, b0 = a * MC;\n  let free = -1;\n  for (let o = b0; o \u003c b0 + MC; o++) {\n    if (nb[o] === id) return o;\n    if (nb[o] \u003c 0 && free \u003c 0) free = o;\n  }\n  if (free >= 0) (nb[free] = id), (S.xi[free] = 0);\n  return free;\n}\n\n// The tangential force on the second body of a contact that slid vt h along\n// its tangent, from the spring held in slot o: it slips past MU times fn.\nfunction fric(S, o, vt, fn, h, cd) {\n  if (o \u003c 0) return 0;\n  let xi = S.xi[o] + vt * h, ft = -S.kt * xi - TD * cd * vt;\n  const lim = MU * fn;\n  if (ft > lim) (ft = lim), (xi = -lim / S.kt);\n  else if (ft \u003c -lim) (ft = -lim), (xi = lim / S.kt);\n  S.xi[o] = xi;\n  S.sg[o] = S.gen;\n  return ft;\n}\n\n// Keeps a contact for drawing: the direction from the disc's centre to it\n// and the force on the disc there.\nfunction keepC(S, i, ux, uy, fx, fy) {\n  if (S.cn[i] >= MC) return;\n  const o = i * MC + S.cn[i]++;\n  S.cux[o] = ux;\n  S.cuy[o] = uy;\n  S.cfx[o] = fx;\n  S.cfy[o] = fy;\n}\n\n// One physics step of h seconds, after Cundall and Strack: touching discs\n// push apart with a spring and a damper along the line between them and hold\n// each other with a tangential spring that slips past Coulomb friction. The\n// walls and the floor do the same. The piston is a heavy lid pushed down\n// with force S.fp, and each wall plate is pushed in with S.fw.\nfunction step(S, h, drag, keep) {\n  const { n, x, y, vx, vy, w, r, m, fx, fy, tq, head, next, nb, sg, k, c } = S;\n  const cs = S.cs, gw = S.gw, gh = S.gh, off = 200, gen = ++S.gen, cd0 = c / (S.rm * 0.7071);\n  head.fill(-1, 0, gw * gh);\n  for (let i = 0; i \u003c n; i++) {\n    fx[i] = 0;\n    fy[i] = m[i] * G;\n    tq[i] = 0;\n    const o = cl(floor((y[i] + off) / cs), 0, gh - 1) * gw + cl(floor((x[i] + 4) / cs), 0, gw - 1);\n    next[i] = head[o];\n    head[o] = i;\n  }\n  if (keep) S.cn.fill(0);\n  for (let gy = 0; gy \u003c gh; gy++)\n    for (let gx = 0; gx \u003c gw; gx++)\n      for (let i = head[gy * gw + gx]; i >= 0; i = next[i])\n        for (let dy = 0; dy \u003c= 1; dy++)\n          for (let dx = -1; dx \u003c= 1; dx++) {\n            if (dy === 0 && dx \u003c 0) continue;\n            const hx = gx + dx, hy = gy + dy;\n            if (hx \u003c 0 || hx >= gw || hy >= gh) continue;\n            for (let j = dy === 0 && dx === 0 ? next[i] : head[hy * gw + hx]; j >= 0; j = next[j]) {\n              const a = i \u003c j ? i : j, b = i \u003c j ? j : i;\n              const ddx = x[b] - x[a], ddy = y[b] - y[a], rr = r[a] + r[b], d2 = ddx * ddx + ddy * ddy;\n              if (d2 >= rr * rr) continue;\n              const d = sqrt(d2) || 1e-6, nx = ddx / d, ny = ddy / d, ov = rr - d;\n              const rvx = vx[b] - vx[a], rvy = vy[b] - vy[a], vn = rvx * nx + rvy * ny;\n              const vt = -rvx * ny + rvy * nx - w[b] * r[b] - w[a] * r[a];\n              const cd = cd0 * sqrt((m[a] * m[b]) / (m[a] + m[b]));\n              const fs = k * ov, fn = max(0, fs - cd * vn), ft = fric(S, slot(S, a, b), vt, fn, h, cd);\n              const Fx = fn * nx - ft * ny, Fy = fn * ny + ft * nx;\n              fx[b] += Fx;\n              fy[b] += Fy;\n              fx[a] -= Fx;\n              fy[a] -= Fy;\n              tq[a] -= r[a] * ft;\n              tq[b] -= r[b] * ft;\n              if (keep) {\n                const Kx = fs * nx - ft * ny, Ky = fs * ny + ft * nx;\n                keepC(S, a, nx, ny, -Kx, -Ky);\n                keepC(S, b, -nx, -ny, Kx, Ky);\n              }\n            }\n          }\n  // Walls: m is the direction from the disc to the wall, the wall moves at\n  // (wx, wy).\n  let up = 0;\n  const yp = S.yp, wi = S.wi, wv = S.wv, wf = S.wf;\n  wf.fill(0);\n  const wall = (i, id, ov, mx, my, wx, wy) => {\n    const ri = r[i], cd = cd0 * sqrt(m[i]), rvx = vx[i] - wx, rvy = vy[i] - wy;\n    const vn = rvx * mx + rvy * my, vt = -rvx * my + rvy * mx + w[i] * ri;\n    const fs = k * ov, fn = max(0, fs + cd * vn), ft = fric(S, slot(S, i, id), vt, fn, h, cd);\n    fx[i] += -fn * mx - ft * my;\n    fy[i] += -fn * my + ft * mx;\n    tq[i] += ri * ft;\n    if (keep) keepC(S, i, mx, my, -fs * mx - ft * my, -fs * my + ft * mx);\n    return fn;\n  };\n  for (let i = 0; i \u003c n; i++) {\n    const ri = r[i];\n    const sl = cl(floor((y[i] * NS) / H), 0, NS - 1), sr = sl + NS;\n    let ov = ri - (x[i] - wi[sl]);\n    if (ov > 0) wf[sl] += wall(i, WALL, ov, -1, 0, wv[sl], 0);\n    ov = ri - (W - wi[sr] - x[i]);\n    if (ov > 0) wf[sr] += wall(i, WALL + 1, ov, 1, 0, -wv[sr], 0);\n    ov = ri - (H - y[i]);\n    if (ov > 0) wall(i, WALL + 2, ov, 0, 1, 0, 0);\n    ov = ri - (y[i] - yp);\n    if (ov > 0) up += wall(i, WALL + 3, ov, 0, -1, 0, S.vp);\n  }\n  // Springs whose contact broke this step are let go.\n  for (let o = 0, e = n * MC; o \u003c e; o++) if (nb[o] >= 0 && sg[o] !== gen) nb[o] = -1;\n  const dmp = 1 - drag * h;\n  for (let i = 0; i \u003c n; i++) {\n    vx[i] = (vx[i] + (fx[i] / m[i]) * h) * dmp;\n    vy[i] = (vy[i] + (fy[i] / m[i]) * h) * dmp;\n    w[i] = (w[i] + ((2 * tq[i]) / (m[i] * r[i] * r[i])) * h) * dmp;\n    x[i] += vx[i] * h;\n    y[i] += vy[i] * h;\n  }\n  const pd = 1 - PD * h;\n  S.vp = (S.vp + ((S.fp - up) / S.mp) * h) * pd;\n  S.yp += S.vp * h;\n  // The wall plates move inward at wv and halt at their stops. The top plate\n  // also holds the pile above the panel's top edge.\n  const mw = S.mp / NS;\n  for (let k = 0; k \u003c 2 * NS; k++) {\n    const f = S.fw * (k \u003c NS ? 1 + S.lean : 1 - S.lean) * (k % NS ? 1 : 1 - (yp * NS) / H);\n    wv[k] = (wv[k] + ((f - wf[k]) / mw) * h) * pd;\n    wi[k] += wv[k] * h;\n    if (wi[k] \u003c -WOUT) (wi[k] = -WOUT), (wv[k] = max(0, wv[k]));\n    if (wi[k] > WIN) (wi[k] = WIN), (wv[k] = min(0, wv[k]));\n  }\n}\n\n// The pushes at point q of the round, 0 with the piston pressing hardest and\n// 1 with the walls pressing hardest. A pressure of 1 is the weight of the\n// pile spread over the floor.\nfunction press(S, q) {\n  const p = (S.load * S.mg) / W;\n  S.fp = p * (SY0 + (SY1 - SY0) * q) * (W - S.wi[0] - S.wi[NS]);\n  S.fw = (p * (SX0 + (SX1 - SX0) * q) * H) / NS;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const beta = cl(kv[0], 0, 1) * PI * 0.5;\n  if (abs(beta - S.beta) > 0.004) buildLut(S, beta);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.load = 3 * pow(2, cl(kv[2], -1, 1));\n  const grain = cl(kv[3], 0, 1);\n  if (S.grain \u003c 0 || abs(grain - S.grain) > 0.03) pour(S, grain), (S.u = 0);\n  const h = 1 / 30 / SUB, steps = max(1, Math.round(d * 30 * SUB)), du = (d * S.speed) / 2 / steps;\n  for (let i = 0; i \u003c steps; i++) {\n    S.u = (S.u + du) % (2 * T_R);\n    // The round: the piston pressing hard with the walls easing off, then the\n    // walls squeezing while the piston eases, and back. The lean turns over\n    // once every two rounds.\n    press(S, 0.5 - 0.5 * cos((2 * PI * S.u) / T_R));\n    S.lean = LEAN * sin((PI * S.u) / T_R);\n    step(S, h, DRAG, i === steps - 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { n, x, y, r, cn, cux, cuy, cfx, cfy, lut, buf, cc } = S;\n  buf.fill(0);\n  // LUT steps per unit of stress: the weight pressure on the floor makes FR\n  // of a fringe.\n  const ks = (L0 * W * FR) / (S.mg * LS);\n  for (let i = 0; i \u003c n; i++) {\n    const R = r[i], cx = x[i], cy = y[i], nc = cn[i], R2 = R * R, Ri = (R - 0.7) * (R - 0.7);\n    for (let k = 0; k \u003c nc; k++) {\n      const o = i * MC + k;\n      cc[k * 4] = R * cux[o];\n      cc[k * 4 + 1] = R * cuy[o];\n      cc[k * 4 + 2] = cfx[o];\n      cc[k * 4 + 3] = cfy[o];\n    }\n    const x0 = max(0, floor(cx - R)), x1 = min(W - 1, floor(cx + R)), y0 = max(0, floor(cy - R)), y1 = min(H - 1, floor(cy + R));\n    for (let py = y0; py \u003c= y1; py++)\n      for (let px = x0; px \u003c= x1; px++) {\n        const ex0 = px + 0.5 - cx, ey0 = py + 0.5 - cy, q = ex0 * ex0 + ey0 * ey0;\n        if (q >= R2) continue;\n        let cr = 0, cg = 0, cb = 0;\n        for (let sub = 0; sub \u003c 4; sub++) {\n          const ex = ex0 + (sub & 1 ? 0.25 : -0.25), ey = ey0 + (sub & 2 ? 0.25 : -0.25);\n          let sxx = 0, syy = 0, sxy = 0;\n          for (let k = 0; k \u003c nc * 4; k += 4) {\n            const dx = ex - cc[k], dy = ey - cc[k + 1];\n            const r2 = dx * dx + dy * dy + A2, wgt = (cc[k + 2] * dx + cc[k + 3] * dy) / (r2 * r2);\n            sxx += wgt * dx * dx;\n            syy += wgt * dy * dy;\n            sxy += wgt * dx * dy;\n          }\n          const a = sxx - syy, ds = sqrt(a * a + 4 * sxy * sxy) * (2 / PI);\n          const li = min(LN - 1, (ds * ks) | 0) * 3;\n          cr += lut[li];\n          cg += lut[li + 1];\n          cb += lut[li + 2];\n        }\n        // Four samples a LED, and the rim darkened where the disc's edge bends\n        // the light away.\n        const f = (q > Ri ? 0.45 : 1) * 0.25, o = (py * W + px) * 3;\n        buf[o] = cr * f;\n        buf[o + 1] = cg * f;\n        buf[o + 2] = cb * f;\n      }\n  }\n  for (let p = 0, yy = 0; yy \u003c H; yy++)\n    for (let xx = 0; xx \u003c W; xx++, p += 3) display.setPixel(xx, yy, buf[p], buf[p + 1], buf[p + 2]);\n}\n","gaussian-free-field":"// ===== Patternflow pattern =====\n// Title:   Gaussian Free Field\n// Family:  noise\n// Idea:    The discrete Gaussian free field on the panel's 64 by 128 lattice, an amber land above zero and a dark violet sea below, its zero level lines drawn as white coastlines that close into nested loops, while every sine mode of the field wanders on its own and the whole map redraws itself within a second or two; with the boundary knob up, one white line climbs all 128 rows, the SLE(4) curve.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: discrete Gaussian free field, whose contour lines converge to SLE(4) (Oded Schramm and Scott Sheffield, 2009), pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Boundary=0..1, Grain=0..1\n//\n// Knob 1: Hue. The colour of the land. At 0 it rises from orange through amber to gold, a step at every height of 0.63 (the height gap, see Boundary); at 0.25 green, at 0.5 sky blue, at 0.75 pink, and back to orange at 1. The sea stays violet, leaning bluer or redder, and the coastlines stay white.\n// Knob 2: Speed. Each of the 8,192 sine modes wanders as its own Ornstein-Uhlenbeck process, smoothed in time, so at every instant the field has the free field's law. At 2 the largest mode forgets itself in 0.7 s and the finest, two LEDs from crest to crest, in 0.14 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Boundary. What lies outside the frame. At 0 the field is zero all round, and the coastlines are closed loops, nested, which tend to CLE(4). Turned up, the frame is held at +h on its left half and -h on its right, up to h = sqrt(pi/8) = 0.63 at 1: then exactly one coastline runs from the middle of the bottom edge to the middle of the top, the chordal SLE(4), and from 0.33 on it is drawn two LEDs wide while the other coastlines dim to pale amber.\n// Knob 4: Grain. The width of the Gaussian blur under the coastlines and bands, from 1.4 LEDs at 0 to 5 at 1, where the land breaks into a few smooth blobs; it opens at 1.6. The shading always shows the lattice field itself, lit from the upper left.\n\nconst W = 64, H = 128, N = W * H, HW = W / 2, HH = H / 2;\nconst { floor, min, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The height gap: with -LAM on one boundary arc and +LAM on the other the\n// zero line between them is SLE(4), for a field whose covariance is the\n// inverse of the lattice Laplacian.\nconst LAM = sqrt(PI / 8);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// Sine modes, orthonormal: SX[j * W + x] is mode j at column x and, the\n// matrix being symmetric, also mode x at column j. LA is the eigenvalue of\n// minus the lattice Laplacian for mode (j, k), stored at j * H + k.\nconst SX = new Float64Array(W * W), SY = new Float64Array(H * H), LA = new Float64Array(N);\nfor (let j = 0; j \u003c W; j++) for (let x = 0; x \u003c W; x++) SX[j * W + x] = sqrt(2 / (W + 1)) * sin((PI * (j + 1) * (x + 1)) / (W + 1));\nfor (let k = 0; k \u003c H; k++) for (let y = 0; y \u003c H; y++) SY[k * H + y] = sqrt(2 / (H + 1)) * sin((PI * (k + 1) * (y + 1)) / (H + 1));\nfor (let j = 0; j \u003c W; j++) for (let k = 0; k \u003c H; k++) LA[j * H + k] = 4 - 2 * cos((PI * (j + 1)) / (W + 1)) - 2 * cos((PI * (k + 1)) / (H + 1));\nconst LMIN = LA[0];\n// The field is drawn with a blur of a third of an LED, which leaves the lattice\n// as it is: AMP is each mode's standard deviation, 1 / sqrt(l), times the\n// square root of 1.5 that the filter in update takes away. TAU is each\n// mode's relaxation time as a share of the largest mode's.\nconst C0 = 0.05, AMP = new Float64Array(N), TAU = new Float64Array(N);\nfor (let i = 0; i \u003c N; i++) {\n  AMP[i] = (sqrt(1.5) * exp(-C0 * LA[i])) / sqrt(LA[i]);\n  TAU[i] = (LMIN / LA[i]) ** 0.2;\n}\n\n// Normal deviates from a table of 4096 quantiles of the unit normal, read\n// off its distribution function summed in steps of a thousandth and scaled\n// to unit variance: one draw of Math.random each.\nconst GT = new Float64Array(4096);\n{\n  let c = 0, i = 0, v = 0;\n  for (let z = -6; z \u003c 6 && i \u003c 4096; z += 0.001) {\n    const c2 = c + (exp(-((z + 0.0005) ** 2) / 2) * 0.001) / sqrt(2 * PI);\n    while (i \u003c 4096 && (i + 0.5) / 4096 \u003c= c2) GT[i++] = z + (0.001 * ((i + 0.5) / 4096 - c)) / (c2 - c);\n    c = c2;\n  }\n  for (i = 0; i \u003c 4096; i++) v += GT[i] * GT[i];\n  v = sqrt(v / 4096);\n  for (i = 0; i \u003c 4096; i++) GT[i] /= v;\n}\nconst gauss = () => GT[(Math.random() * 4096) | 0];\n\n// Modes B (j, k at B[j * H + k]) to the field F[y * W + x], one axis at a\n// time. Mode k is even or odd about the middle row as k + 1 is odd or even,\n// so each sum serves a row and its mirror; the same for columns.\nfunction synth(B, T, F) {\n  for (let j = 0; j \u003c W; j++) {\n    const b = j * H;\n    for (let y = 0; y \u003c HH; y++) {\n      const r = y * H;\n      let e = 0, o = 0;\n      for (let k = 0; k \u003c H; k += 2) {\n        e += B[b + k] * SY[r + k];\n        o += B[b + k + 1] * SY[r + k + 1];\n      }\n      T[y * W + j] = e + o;\n      T[(H - 1 - y) * W + j] = e - o;\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const t = y * W;\n    for (let x = 0; x \u003c HW; x++) {\n      const r = x * W;\n      let e = 0, o = 0;\n      for (let j = 0; j \u003c W; j += 2) {\n        e += SX[r + j] * T[t + j];\n        o += SX[r + j + 1] * T[t + j + 1];\n      }\n      F[t + x] = e + o;\n      F[t + W - 1 - x] = e - o;\n    }\n  }\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, bnd: 0, grain: 0.06, qd: -1,\n    z: new Float64Array(N), a: new Float64Array(N), Q: new Float64Array(N), R: new Float64Array(N), Z: new Float64Array(N),\n    B: new Float64Array(N), T: new Float64Array(N), F: new Float64Array(N), U: new Float64Array(N), G: new Float64Array(N), V: new Float64Array(N),\n    K: new Float64Array(24), P: new Float64Array(H + 40), side: new Int8Array(N), stack: new Int32Array(N), chord: new Uint8Array(N), c: [0, 0, 0],\n  });\n  for (let i = 0; i \u003c N; i++) S.z[i] = S.a[i] = gauss();\n  // The harmonic part for the Dobrushin boundary: +1 outside the left half\n  // of the frame and -1 outside the right half. Minus its Laplacian inside\n  // is what the edge LEDs see beyond the frame, so it is that source divided\n  // by each mode's eigenvalue. The sine matrices are symmetric, so synth run\n  // on the source laid out by column gives its modes laid out by row.\n  const f = S.B, m = S.F;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      if (x === 0) s += 1;\n      if (x === W - 1) s -= 1;\n      if (y === 0 || y === H - 1) s += x \u003c HW ? 1 : -1;\n      f[x * H + y] = s;\n    }\n  synth(f, S.T, m);\n  for (let j = 0; j \u003c W; j++) for (let k = 0; k \u003c H; k++) f[j * H + k] = m[k * W + j] / LA[j * H + k];\n  synth(f, S.T, S.U);\n}\n\n// The pixels joined to the left arc through LEDs above zero (side 1), and\n// those joined to the right arc through the rest (side 2): the zero line\n// between the two is the chordal one, from the middle of the bottom edge to\n// the middle of the top.\nfunction sides(S) {\n  const V = S.V, sd = S.side, st = S.stack;\n  sd.fill(0);\n  let n = 0;\n  const seed = (p, s) => {\n    if (!sd[p] && (s === 2 || V[p] > 0)) (sd[p] = s), (st[n++] = p);\n  };\n  const fill = (s) => {\n    while (n) {\n      const p = st[--n], x = p % W;\n      if (x > 0) seed(p - 1, s);\n      if (x \u003c W - 1) seed(p + 1, s);\n      if (p >= W) seed(p - W, s);\n      if (p \u003c N - W) seed(p + W, s);\n    }\n  };\n  for (let y = 0; y \u003c H; y++) seed(y * W, 1);\n  for (let x = 0; x \u003c HW; x++) seed(x, 1), seed(N - W + x, 1);\n  fill(1);\n  for (let y = 0; y \u003c H; y++) seed(y * W + W - 1, 2);\n  for (let x = HW; x \u003c W; x++) seed(x, 2), seed(N - W + x, 2);\n  fill(2);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.bnd = cl(k[2], 0, 1);\n  S.grain = cl(k[3], 0, 1);\n  // Each mode is an Ornstein-Uhlenbeck process seen through an exponential\n  // filter of half its time constant, which smooths its path in time; the\n  // filter takes its variance to 1 / 1.5, which AMP gives back, so at every\n  // instant the modes are independent normals and the field is the free\n  // field. The largest mode forgets itself in about 0.7 s at Speed 2.\n  const z = S.z, a = S.a, B = S.B, Q = S.Q, R = S.R, Z = S.Z;\n  const qd = (d * S.speed) / (0.7 * 2);\n  if (qd !== S.qd) {\n    S.qd = qd;\n    for (let i = 0; i \u003c N; i++) {\n      const q = exp(-qd / TAU[i]);\n      Q[i] = q;\n      Z[i] = sqrt(1 - q * q);\n      R[i] = q * q;\n    }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    z[i] = z[i] * Q[i] + Z[i] * gauss();\n    a[i] = a[i] * R[i] + z[i] * (1 - R[i]);\n    B[i] = a[i] * AMP[i];\n  }\n  synth(B, S.T, S.F);\n  // The field the level lines are drawn on: the same field blurred by a\n  // Gaussian of Grain's width, zero outside the panel as the boundary is.\n  const sg = 1.4 + 3.6 * S.grain, rad = min(20, Math.ceil(2.5 * sg)), K = S.K;\n  let ks = 0;\n  for (let i = 0; i \u003c= rad; i++) ks += (K[i] = exp((-i * i) / (2 * sg * sg))) * (i ? 2 : 1);\n  for (let i = 0; i \u003c= rad; i++) K[i] /= ks;\n  const F = S.F, G = S.G, V = S.V, U = S.U, P = S.P, g = S.bnd * LAM;\n  // Rows, then columns, each copied into a strip with 20 zeros either side.\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) P[20 + x] = F[y * W + x];\n    for (let x = 0; x \u003c W; x++) {\n      const c = 20 + x;\n      let s = K[0] * P[c];\n      for (let i = 1; i \u003c= rad; i++) s += K[i] * (P[c - i] + P[c + i]);\n      G[y * W + x] = s;\n    }\n  }\n  for (let x = 0; x \u003c W; x++) {\n    for (let y = 0; y \u003c H; y++) P[20 + y] = G[y * W + x];\n    for (let y = 0; y \u003c H; y++) {\n      const c = 20 + y, p = y * W + x;\n      let s = K[0] * P[c];\n      for (let i = 1; i \u003c= rad; i++) s += K[i] * (P[c - i] + P[c + i]);\n      V[p] = (s + g * U[p]) / LAM;\n    }\n  }\n  if (S.bnd > 0) sides(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const V = S.V, F = S.F, sd = S.side, c = S.c, hp = 0.07 + S.hue, hn = 0.7 + 0.06 * sin(2 * PI * S.hue);\n  const ch = S.bnd > 0 ? min(1, 3 * S.bnd) : 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, v = V[p], L = Math.round(v), e = v - L, ae = abs(e);\n      // On a level line: a neighbour lies across the nearest level and is no\n      // nearer to it. The chord is drawn two LEDs wide, on both sides.\n      let z = 0, q, n = -1;\n      if (x > 0 && ((q = V[p - 1] - L), q * e \u003c 0) && abs(q) >= ae) n = p - 1;\n      else if (x \u003c W - 1 && ((q = V[p + 1] - L), q * e \u003c 0) && abs(q) >= ae) n = p + 1;\n      else if (y > 0 && ((q = V[p - W] - L), q * e \u003c 0) && abs(q) >= ae) n = p - W;\n      else if (y \u003c H - 1 && ((q = V[p + W] - L), q * e \u003c 0) && abs(q) >= ae) n = p + W;\n      if (n >= 0) z = L === 0 ? 2 : 1;\n      if (ch) {\n        const o = 3 - sd[p];\n        if (o \u003c 3 && ((x > 0 && sd[p - 1] === o) || (x \u003c W - 1 && sd[p + 1] === o) || (y > 0 && sd[p - W] === o) || (y \u003c H - 1 && sd[p + W] === o))) z = 3;\n      }\n      // Relief: the fine field lit from the upper left.\n      const u = ((x > 0 ? F[p - 1] : 0) - (x \u003c W - 1 ? F[p + 1] : 0) + (y > 0 ? F[p - W] : 0) - (y \u003c H - 1 ? F[p + W] : 0)) * 0.8, sh = (0.35 * u) / (1 + abs(u));\n      const t = 1 - exp(-abs(v) / 1.5);\n      if (z === 3) hsv(hp + 0.1 + 0.03 * sh, 0.04 + 0.1 * abs(sh), 1, c);\n      else if (z === 2) hsv(hp + 0.05 + 0.04 * sh, 0.05 + 0.12 * abs(sh) + 0.35 * ch, 1 - 0.35 * ch, c);\n      else if (v > 0) {\n        // Above zero the brightest channel stays at full. Each band of\n        // height LAM steps the hue from amber toward gold and pales it; the\n        // relief turns hue and saturation a little inside the band.\n        const b = min(L - (e \u003c 0 ? 1 : 0), 3);\n        hsv(hp + 0.04 * b + 0.02 * (v - b) + 0.05 * sh - (z ? 0.025 : 0), 0.8 - 0.1 * b + 0.5 * sh, z ? 0.86 + 0.3 * sh : 1, c);\n      } else hsv(hn + 0.08 * t + 0.12 * sh, 0.85 - 0.3 * t, z ? 0.3 * (1 + sh) : (0.16 - 0.04 * t) * (1 + 1.8 * sh), c);\n      display.setPixel(x, y, min(255, c[0]) | 0, min(255, c[1]) | 0, min(255, c[2]) | 0);\n    }\n}\n","lost-head":"// ===== Patternflow pattern =====\n// Title:   Lost Head\n// Family:  halloween\n// Idea:    A headless skeleton scuttles along moonlit tombstones trying on the skulls that sit on them and puts each wrong one back with a shrug, until the right one clicks on and its sockets light toxic green; it dances a jig, then the head falls off and rolls away.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52, built on Skull Swap, pattern round 50\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tries=1..5, Size=0..1\n//\n// Knob 1: Hue. The night sky and the shaded side of the bones, round the cold side of the wheel from violet at 0 to teal at 1. The moon and the halo stay.\n// Knob 2: Speed. One beat a second for each unit. At the opening 2 the big skull is on the neck at 0.9 s and the right one clicks on at 7 s, after a 2 s walk; it rolls away at 10.8 s. Ten times slower at 0.2.\n// Knob 3: Tries. Wrong skulls before the right one, 1 to 5, in turn from too small, witch's hat, biter, pumpkin, too big. The first round ends on the big one, so at 1 it opens on the big one and at 5 on the small one.\n// Knob 4: Size. How wrong the wrong sizes are: the big skull is 1.1 times the right one at 0 and twice it at 1, sliding down over the hips; the small one goes from 0.8 to 0.4.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, acos, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\n// Up from a over ra beats, down from c over rc.\nconst win = (b, a, ra, c, rc) => ease((b - a) / ra) * (1 - ease((b - c) / rc));\nconst blend = (D, o, w) => Object.keys(o).forEach((key) => (D[key] = mix(D[key], o[key], w)));\nconst hsv = (h, s, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + h * 6) % 6;\n  o[c] = 255 * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\n// --- Skull Swap's bones, as distances in their own frames, y down.\nconst seg = (x, y, ax, ay, bx, by) => {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return sqrt((x - ax - dx * t) ** 2 + (y - ay - dy * t) ** 2);\n};\nconst ell = (x, y, cx, cy, rx, ry) => (sqrt(((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2) - 1) * min(rx, ry);\nconst box = (x, y, cx, cy, hx, hy, r) => {\n  const qx = abs(x - cx) - hx + r, qy = abs(y - cy) - hy + r;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n};\nfunction long(x, y, L, w, r) {\n  const e = L / 2 - r, q = 0.6 * r, ry = r * 0.9;\n  return min(seg(x, y, 0, -e, 0, e) - w, ell(x, y, -q, -e, r, ry), ell(x, y, q, -e, r, ry), ell(x, y, -q, e, r, ry), ell(x, y, q, e, r, ry));\n}\n// 0 long bone, 1 paired bones, 2 cage, 3 lumbar, 4 pelvis, 5 skull, 6 jaw,\n// 7 hand, 8 foot, 9 hat.\nconst RIBS = [[6.4, 2.4], [7.9, 6.6], [8.8, 10.8], [8.8, 15], [7.8, 19]];\nfunction shape(k, x, y, sg) {\n  switch (k) {\n    case 0:\n      return long(x, y, sg, 0.95 + 0.015 * sg, 1.5);\n    case 1: {\n      const e = sg / 2 - 1.1;\n      return min(seg(x, y, -1, -e, -1, e) - 0.8, seg(x, y, 1.1, -e, 1.1, e) - 0.6, box(x, y, 0, -e - 0.2, 2.3, 1.1, 1), box(x, y, 0, e + 0.2, 2.1, 1.1, 1));\n    }\n    case 2: {\n      let d = min(box(x, y, 0, -3.4, 1.5, 0.75, 0.5), box(x, y, 0, -1.4, 1.6, 0.75, 0.5));\n      d = min(d, seg(x, y, -1.4, 0.8, -9.6, -0.2) - 0.8, seg(x, y, 1.4, 0.8, 9.6, -0.2) - 0.8, seg(x, y, 0, 1, 0, 14) - 1.2);\n      for (let v = 15.5; v \u003c 24; v += 2.7) d = min(d, box(x, y, 0, v, 1.6, 0.9, 0.5));\n      for (const [rx, ry] of RIBS) {\n        const c = 3.6 / (rx * rx), ax = min(abs(x), rx), f = ry + c * ax * ax;\n        d = min(d, abs(x) \u003c= rx ? abs(y - f) / sqrt(1 + (2 * c * ax) ** 2) - 0.7 : sqrt((abs(x) - rx) ** 2 + (y - f) ** 2) - 0.7);\n      }\n      return d;\n    }\n    case 3: {\n      let d = 9;\n      for (let v = -4; v \u003c= 4.1; v += 2.7) d = min(d, box(x, y, 0, v, 1.9, 0.95, 0.5), box(x, y, 0, v, 3.1, 0.4, 0.3));\n      return d;\n    }\n    case 4: {\n      let d = max(abs(x) - (2.5 - 0.28 * (y + 5.5)), abs(y + 2.6) - 3);\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const dx = x - s * 5.3, dy = y + 3.6, c = 0.8, n = 0.6 * s;\n        d = min(d, ell(dx * c + dy * n, -dx * n + dy * c, 0, 0, 4.1, 2.9), abs(ell(x, y, s * 3.4, 2.4, 2.4, 1.9)) - 0.75, ell(x, y, s * 6.5, 0, 1.5, 1.5));\n      }\n      return d;\n    }\n    case 5:\n      return min(ell(x, y, 0, -10.6, 7, 7.3), ell(x, y, 0, -6.8, 6.4, 2.3), box(x, y, 0, -3.2, 4.4, 2.6, 1.4));\n    case 6: {\n      const hw = 4.3 - 0.4 * max(0, y);\n      return min(box(x, y, 0, 1.5, 4.3, 1.6, 0.8), max(abs(x) - hw, abs(y - 1.6) - 1.8));\n    }\n    case 7: {\n      let d = ell(x, y, 0, 1.4, 1.8, 1.4);\n      for (let i = 0; i \u003c 4; i++) d = min(d, seg(x, y, -1.2 + 0.8 * i, 2.2, -1.8 + 1.2 * i, 5.4) - 0.5);\n      return d;\n    }\n    case 8:\n      return min(ell(x, y, sg * 0.8, 1.6, 3.1, 1.4), ell(x, y, 0, 0.4, 1.4, 1));\n    default: {\n      const t = cl((-17.4 - y) / 10, 0, 1);\n      return min(ell(x, y, 0.4, -17, 8.4, 1.4), seg(x, y, 0, -17.4, 2.6, -27.4) - mix(4.6, 0.7, t), seg(x, y, 2.6, -27.4, 6, -28.6) - 0.7);\n    }\n  }\n}\n// 0 none, 1 dark, 2 socket, 3 shade, 4 pupil, 5 hat band.\nfunction hole(k, x, y) {\n  if (k === 5) {\n    if (((abs(x) - 2.9) / 2.2) ** 2 + ((y + 7.9) / 2.5) ** 2 \u003c 1) return ((abs(x) - 2.9) / 1.15) ** 2 + ((y + 7.7) / 1.3) ** 2 \u003c 1 ? 4 : 2;\n    const ny = y + 5.4;\n    if (ny >= 0 && ny \u003c 1.7 && abs(x) \u003c 0.3 + 0.5 * ny) return 1;\n    if (y > -2 && y \u003c -0.5 && abs(x * 0.8) \u003c 3.4) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 || y > -0.9 ? 1 : 0;\n  } else if (k === 6 && y \u003c 1.2 && y > -0.2 && abs(x) \u003c 3.8) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 ? 1 : 0;\n  else if (k === 4 && ((abs(x) - 4.6) / 2.3) ** 2 + ((y + 4.4 + 0.3 * abs(x)) / 1.3) ** 2 \u003c 1) return 3;\n  else if (k === 9 && y > -19.4 && y \u003c -17.6 && abs(x) \u003c 5.2) return 5;\n  return 0;\n}\n\nconst FEMUR = 22, TIBIA = 21, ARM = 15, FORE = 13, HIP = 6.5, FLOOR = 120, HIPY = FLOOR - 3 - FEMUR - TIBIA;\nconst two = (p) => [p, p];\nconst PIECES = [[8, -1, -3.9, 3.9, -1, 3.2], [8, 1, -3.9, 3.9, -1, 3.2], ...two([1, TIBIA, -2.4, 2.4, -11, 11]), ...two([0, FEMUR, -2.6, 2.6, -11.4, 11.4]), [4, 0, -11, 11, -9, 5.2], [3, 0, -3.6, 3.6, -5.3, 5.3], [2, 0, -10.6, 10.6, -4.5, 22.6], ...two([0, ARM, -2.6, 2.6, -7.9, 7.9]), ...two([1, FORE, -2.4, 2.4, -7, 7]), ...two([7, 0, -2.7, 2.7, -0.3, 6.1])];\nconst SKULL = [5, 0, -7.2, 7.2, -18.1, 0.6], JAW = [6, 0, -4.4, 4.4, -0.3, 3.5], CAP = [9, 0, -8.6, 7, -29.6, -15.4];\n\nconst at = (K, i, x, y, a) => {\n  K.x[i] = K.cx + K.sc * x;\n  K.y[i] = FLOOR + K.sc * (y - FLOOR);\n  K.a[i] = a;\n};\nconst ang = (dx, dy) => atan2(-dx, dy);\nconst bone = (K, i, ax, ay, bx, by) => at(K, i, (ax + bx) / 2, (ay + by) / 2, ang(bx - ax, by - ay));\nconst rot = (a, x, y) => [x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)];\nfunction limb(K, ax, ay, tx, ty, L1, L2, i1, i2, px, py) {\n  const dx = tx - ax, dy = ty - ay, d = cl(sqrt(dx * dx + dy * dy), 2, L1 + L2 - 0.01), b = atan2(dy, dx);\n  const al = acos(cl((L1 * L1 + d * d - L2 * L2) / (2 * L1 * d), -1, 1));\n  let kx = ax + L1 * cos(b + al), ky = ay + L1 * sin(b + al);\n  const mx = ax + L1 * cos(b - al), my = ay + L1 * sin(b - al);\n  if ((mx - px) ** 2 + (my - py) ** 2 \u003c (kx - px) ** 2 + (ky - py) ** 2) (kx = mx), (ky = my);\n  const n = sqrt((tx - kx) ** 2 + (ty - ky) ** 2) || 1, u = (tx - kx) / n, v = (ty - ky) / n;\n  bone(K, i1, ax, ay, kx, ky);\n  bone(K, i2, kx, ky, kx + L2 * u, ky + L2 * v);\n  return [kx + L2 * u, ky + L2 * v, u, v];\n}\nfunction torso(D, K) {\n  const rx = D.sway, ry = HIPY + D.bob, t = D.tilt, l = D.lean;\n  at(K, 6, rx, ry, t);\n  for (const s of [-1, 1]) {\n    const [hx, hy] = rot(t, s * HIP, 0), f = s \u003c 0 ? D.fl : D.fr, ax = rx + hx, ay = ry + hy;\n    const [ex, ey] = limb(K, ax, ay, s * (HIP + f[1]), FLOOR - 3 - f[0], FEMUR, TIBIA, 4 + (s > 0), 2 + (s > 0), ax + s * 60, ay + 20);\n    at(K, s > 0 ? 1 : 0, ex, ey, 0);\n  }\n  const [b0, b1] = rot(t, 0, -5), sx = rx + b0, sy = ry + b1, [c0, c1] = rot(l, 0, -10);\n  bone(K, 7, sx + c0, sy + c1, sx, sy);\n  const [d0, d1] = rot(l, 0, -24), tx = sx + c0 + d0, ty = sy + c1 + d1 - D.shr * 0.4;\n  at(K, 8, tx, ty, l);\n  const [n0, n1] = rot(l, 0, -4.4);\n  Object.assign(K, { tx, ty, nx: K.cx + K.sc * (tx + n0), ny: FLOOR + K.sc * (ty + n1 - FLOOR), na: l + D.head });\n}\nfunction arms(D, K) {\n  const l = D.lean;\n  for (const s of [-1, 1]) {\n    const [o0, o1] = rot(l, s * 10, 0.6 - D.shr), ax = K.tx + o0, ay = K.ty + o1, a1 = s \u003c 0 ? D.al : D.ar, a2 = s \u003c 0 ? D.bl : D.br;\n    const [u0, u1] = rot(l, s * sin(a1), cos(a1)), ex = ax + ARM * u0, ey = ay + ARM * u1;\n    const [v0, v1] = rot(l, s * sin(a1 + a2), cos(a1 + a2));\n    let wx = ex + FORE * v0, wy = ey + FORE * v1;\n    const h = K.hold[s > 0 ? 1 : 0];\n    if (h[0] > 0) (wx = mix(wx, (h[1] - K.cx) / K.sc, h[0])), (wy = mix(wy, FLOOR + (h[2] - FLOOR) / K.sc, h[0]));\n    const [hx, hy, u, v] = limb(K, ax, ay, wx, wy, ARM, FORE, 9 + (s > 0), 11 + (s > 0), ex, ey);\n    at(K, 13 + (s > 0), hx, hy, ang(u, v));\n  }\n}\nconst REST = { sway: 0, bob: 0, tilt: 0, lean: 0, head: 0, jaw: 0, shr: 0, al: 0.1, bl: 0.06, ar: 0.1, br: 0.06, fl: [0, 0], fr: [0, 0] };\n\n// --- the story. The camera follows the body at BX; the stone tried stands\n// at SX, its top at ST, the next GAP further on.\nconst SC = 0.85, BX = 20, SX = 40, ST = 82, SHW = 8, GAP = 48, WALK = 4, GROUND = 117, HS = GAP / SC / 8;\nconst BIG = 0, SMALL = 1, HAT = 2, BITER = 3, PUMPKIN = 4, RIGHT = 5;\nconst ORDER = [SMALL, HAT, BITER, PUMPKIN, BIG];\nconst DARK = [34, 20, 50], TOXIC = [96, 255, 64];\nconst EYE = [DARK, DARK, [255, 132, 8], [200, 70, 255], DARK, DARK];\n// Beats a wrong one stays on the neck, and when the shrug starts.\nconst GAG = [3.6, 3.6, 3.8, 0, 3.2, 0];\nconst shrugAt = (k) => (k === RIGHT ? 10.6 : k === BITER ? 4.4 : 3.4 + GAG[k]);\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, t: 0, b: 0, ph: 0, cam: 0, c0: 0, stones: [], queue: [],\n    light: [0, 0, 0], bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    K: { cx: BX, sc: SC, x: new Float64Array(15), y: new Float64Array(15), a: new Float64Array(15), D: { ...REST }, hold: [] },\n  };\n}\nfunction stone(S, j) {\n  if (j \u003c 0) return { j };\n  if (!S.queue.length) {\n    for (let i = 0; i \u003c S.tries; i++) S.queue.push(ORDER[(S.g + i) % 5]);\n    S.g += S.tries;\n    S.queue.push(RIGHT);\n  }\n  const kind = S.queue.shift(), sc = kind === BIG ? 1.1 + 0.9 * S.size : kind === SMALL ? 0.8 - 0.4 * S.size : kind === HAT ? 0.95 : 1;\n  return { j, kind, Hd: { kind, sc, eye: EYE[kind].slice(), hd: 0, jaw: 0, glow: 0 } };\n}\n// A skull on its stone; where a hand takes it, on top (s 0) or at a side.\nconst sit = (S, st, Hd) => Object.assign(Hd, { x: SX + st.j * GAP - S.cam, y: ST - (Hd.kind === PUMPKIN ? 1 : 3.5 * Hd.sc), a: 0, z: 0 });\nconst grip = (Hd, s) => {\n  const [p, q] = Hd.kind === PUMPKIN ? [0, -18] : rot(Hd.a, s * 8.6 * Hd.sc, (s ? -6 : -23) * Hd.sc);\n  return [Hd.x + p, Hd.y + q];\n};\nconst arc = (Hd, ax, ay, a0, bx, by, a1, f, h, z = 1) => Object.assign(Hd, { x: mix(ax, bx, f), y: mix(ay, by, f) - 4 * h * f * (1 - f), a: mix(a0, a1, f), z });\n// A sideways scuttle: one foot stays put as the other swings on ahead.\nfunction gait(D, u) {\n  const p = u / (2 * HS) - floor(u / (2 * HS)), q = (p % 0.5) * 2, w = q * HS, lift = 6 * sin(PI * q), o = sin(TAU * p);\n  D.fl = [p \u003c 0.5 ? 0 : lift, p \u003c 0.5 ? w : HS - w];\n  D.fr = [p \u003c 0.5 ? lift : 0, p \u003c 0.5 ? w : HS - w];\n  Object.assign(D, { bob: 2 - 1.6 * sin(PI * q), sway: (p \u003c 0.5 ? -1.2 : 1.2) * sin(PI * q), al: 0.45 + 0.25 * o, ar: 0.45 - 0.25 * o, bl: 0.5, br: 0.5 });\n}\n\n// The body for beat b of a try: crouch, rise with the skull, the gag, crouch\n// to put it back, shrug.\nfunction pose(D, k, b) {\n  const E = 1.8 + GAG[k], q = b - 1.8, big = k === BIG, w = sin(PI * b), o = sin(TAU * b);\n  let c = b \u003c 0.8 ? ease(b / 0.8) : 1 - ease(k === BITER ? (b - 0.95) / 0.3 : b - 0.8);\n  if (k \u003c BITER || k === PUMPKIN) c = max(c, b \u003c E + 1.2 ? ease((b - E - 0.4) / 0.6) : 1 - ease((b - E - 1.2) / 0.5));\n  D.bob += (big ? 7 : 3) * c;\n  D.lean += (big ? 0.2 : 0.12) * c;\n  // A hand on the hip while the other carries.\n  if (k > SMALL && k !== BITER) blend(D, { al: 0.5, bl: -1.6 }, 1 - ease((b - (k === RIGHT ? 2 : E + 1.8)) / 0.4));\n  if (big) {\n    // Blind: groping, staggering.\n    const g = win(q, 0.3, 0.4, GAG[k] - 0.5, 0.4);\n    blend(D, { al: 1.3 + 0.3 * o, ar: 1.3 - 0.3 * o, bl: 0.4, br: 0.4, sway: 3 * w, lean: D.lean + 0.1 * w }, g);\n    D[w > 0 ? \"fr\" : \"fl\"] = [5 * abs(w) * g, 2 * abs(w) * g];\n  }\n  // The hips work against the small one's wobble.\n  if (k === SMALL && b \u003c E) D.sway = -3 * sin(TAU * 1.25 * q) * cl(q / 1.5, 0, 1);\n  if (k === BITER) {\n    // Bitten: jump back, the free arm flapping.\n    const g = win(b, 1, 0.2, 3.4, 0.4);\n    D.lean -= 0.12 * g;\n    D.bob -= 3 * g * abs(sin(TAU * 1.25 * b));\n    blend(D, { al: 1.3 + 0.5 * sin(TAU * 2 * b), bl: 0.6 }, g);\n  }\n  if (k === RIGHT) {\n    // The jig: kicks to each side, hands on the hips.\n    const g = win(q, 0.5, 0.4, 6.4, 0.3), j = sin(PI * (b - floor(b))) ** 2 * g, s = floor(b) & 1 ? 1 : -1;\n    blend(D, { sway: -2 * s * j, bob: -2 * j, head: 0.2 * s * j, al: 0.5, ar: 0.5, bl: -1.6, br: -1.6 }, g);\n    D[s \u003c 0 ? \"fl\" : \"fr\"] = [12 * j, 7 * j];\n    blend(D, { al: 2.6, ar: 2.6, bl: 0.3, br: 0.3 }, win(b, 8.4, 0.15, 9, 0.4));\n  }\n  const s0 = shrugAt(k);\n  blend(D, { shr: 3.5, al: 0.3, ar: 0.3, bl: 2.5, br: 2.5 }, win(b, s0, 0.3, s0 + 0.9, 0.3));\n}\n\n// The skull being tried and the hands on it.\nfunction skull(S, K, st, b) {\n  const Hd = st.Hd, k = st.kind, E = 1.8 + GAG[k], q = b - 1.8, R = (s, w, x, y) => (K.hold[s] = [w, x, y]);\n  // Patting the neck where it was.\n  const pat = k === RIGHT ? win(b, 9.2, 0.3, 10.4, 0.3) : 0;\n  if (pat > 0) for (const s of [0, 1]) R(s, pat, K.nx + (2 * s - 1) * 5, K.ny - 3 + 3 * sin(TAU * 2 * b + s * PI));\n  if (!Hd) return;\n  // A hand on top; both at the sides of the big one.\n  const take = (w, two = k === BIG) => (two ? [0, 1].forEach((s) => R(s, w, ...grip(Hd, 2 * s - 1))) : R(1, w, ...grip(Hd, 0)));\n  sit(S, st, Hd);\n  const sx = Hd.x, sy = Hd.y;\n  if (k === BITER) {\n    Hd.jaw = b > 0.8 && b \u003c 1.05 ? 1.3 : 0.5 * max(0, sin(TAU * 3 * b));\n    if (b \u003c 1.05) take(ease(b / 0.6));\n    else if (b \u003c 3.3) {\n      // Clamped on the hand, shaken high.\n      Object.assign(Hd, { x: K.x[14], y: K.y[14] + 2, a: 0.35 * sin(TAU * 2.5 * b), jaw: 0, z: 2, fx: K.x[14] });\n      R(1, 1, BX + 13 + 5 * sin(TAU * 2.2 * b), 34 + 4 * sin(TAU * 4.4 * b));\n    } else if (b \u003c 4.1) {\n      // Flung back, turning once.\n      arc(Hd, Hd.fx ?? sx, 36, 0, sx, sy, -TAU, ease((b - 3.3) / 0.8), 8, 2);\n      R(1, 1 - ease((b - 3.3) / 0.5), SX - 6, 60);\n    }\n    return;\n  }\n  if (b \u003c 0.8) return take(ease(b / 0.6));\n  if (b \u003c 1.8) return arc(Hd, sx, sy, 0, K.nx, K.ny, K.na, ease(b - 0.8), 7), take(1);\n  const gag = (t) => {\n    Object.assign(Hd, { x: K.nx, y: K.ny, a: K.na, z: 1 });\n    if (k === BIG) {\n      // It drops down over the ribs.\n      const [p, r] = rot(K.na, 0, (6 + 18 * Hd.sc) * ease(t / 0.4) - 3 * sin(PI * cl((t - 0.4) / 0.3, 0, 1)));\n      (Hd.x += p), (Hd.y += r);\n    } else if (k === SMALL) {\n      // Wobbling ever wider, then tipping off.\n      const tip = ease((t - GAG[k] + 0.7) / 0.5);\n      Hd.a += 0.5 * sin(TAU * 1.25 * t) * cl(t / 1.5, 0, 1) * (1 - tip) + 1.4 * tip;\n      (Hd.x += 5 * tip), (Hd.y += 3 * tip);\n    } else if (k === HAT) Hd.hd = win(t, 0.3, 0.2, 1, 0.3) + (t > 2.1 && t \u003c GAG[k] ? ease((t - 2.1) / 0.2) : 0);\n  };\n  if (k === RIGHT) {\n    gag(min(q, 6.6));\n    Hd.glow = ease(q / 0.4);\n    Hd.flash = q \u003c 0.5 ? 1 - q / 0.5 : 0;\n    for (let c = 0; c \u003c 3; c++) Hd.eye[c] = mix(DARK[c], TOXIC[c], Hd.glow);\n    Hd.jaw = K.D.jaw;\n    if (q \u003c 0.3) take(1 - ease(q / 0.3));\n    if (b > 8.4) {\n      // Off it goes.\n      const f = min(1, b - 8.4);\n      arc(Hd, K.nx, K.ny, K.na, 3, GROUND - 3.5, -TAU, f, 14, 2);\n      if (f >= 1) (S.lost = { Hd, wx: 3 + S.cam, t: 0 }), (st.Hd = null);\n    }\n    return;\n  }\n  if (b \u003c E) {\n    gag(q);\n    if (k === PUMPKIN) R(1, win(q, 0.6, 0.3, 2.4, 0.3), Hd.x + 10 + 2.5 * abs(sin(TAU * 1.5 * q)), Hd.y - 7);\n    else if (k === HAT) R(1, win(q, 0.8, 0.2, 1.6, 0.3), Hd.x + 6.5 * Hd.sc, Hd.y + (10 * Hd.hd - 17) * Hd.sc);\n    else if (k === SMALL) {\n      // Hands up ready; the right one catches it.\n      for (const s of [0, 1]) R(s, ease((q - 0.3) / 0.4), K.nx + (2 * s - 1) * 11, K.ny - 8);\n      if (b > E - 0.5) R(1, 1, ...grip(Hd, 1));\n    } else if (q \u003c 0.3) take(1 - ease(q / 0.3));\n    return;\n  }\n  gag(E - 1.801);\n  if (b \u003c E + 0.4) return take(ease((b - E) / 0.4));\n  if (b \u003c E + 1.4) return arc(Hd, Hd.x, Hd.y, Hd.a, sx, sy, 0, ease(b - E - 0.4), 6), (Hd.hd = 0), take(1);\n  sit(S, st, Hd);\n  take(1 - ease((b - E - 1.4) / 0.4));\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1), hue = cl(kn[0], 0, 1);\n  if (hue !== S.hue) {\n    hsv(0.78 - 0.3 * (S.hue = hue), 0.62, S.light);\n    background(S);\n  }\n  (S.size = cl(kn[3], 0, 1)), (S.tries = round(cl(kn[2], 1, 5)));\n  if (!S.stones.length) (S.g = 5 - S.tries), (S.stones = [-1, 0, 1].map((j) => stone(S, j)));\n  const db = d * cl(kn[1], 0.2, 3);\n  (S.b += db), (S.t += d);\n  let st = S.stones[1];\n  if (!S.ph && S.b >= shrugAt(st.kind) + 1.2) (S.b -= shrugAt(st.kind) + 1.2), (S.ph = 1), (S.c0 = S.cam);\n  if (S.ph && S.b >= WALK) {\n    S.b -= WALK;\n    S.ph = 0;\n    S.cam = S.c0 + GAP;\n    S.stones = [S.stones[1], S.stones[2], stone(S, S.stones[2].j + 1)];\n    st = S.stones[1];\n  }\n  const K = S.K, D = Object.assign(K.D, REST, { fl: [0, 0], fr: [0, 0] });\n  K.hold = [[0], [0]];\n  if (S.ph) {\n    // Walking on: the camera glides one stone further.\n    S.cam = S.c0 + GAP * ease(S.b / WALK);\n    gait(D, (S.cam - S.c0) / SC);\n  } else pose(D, st.kind, S.b);\n  torso(D, K);\n  for (const x of S.stones) if (x.Hd && (x !== st || S.ph)) sit(S, x, x.Hd);\n  if (!S.ph) skull(S, K, st, S.b);\n  arms(D, K);\n  if (S.lost) {\n    // Rolling away about the middle of the cranium.\n    const L = S.lost, x = L.wx - S.cam - 9 * (L.t += db), a = -L.t, [p, r] = rot(a, 0, 10.6);\n    Object.assign(L.Hd, { x: x + p, y: GROUND - 14.1 + r, a, z: 2 });\n    if (x \u003c -24) S.lost = null;\n  }\n}\n\n// --- the graveyard, laid out per sky colour: the stepped sky and the moon\n// over a dark hill.\nconst MX = 46, MY = 20, MR = 12;\nconst put = (buf, o, r, g, b) => ((buf[o] = r), (buf[o + 1] = g), (buf[o + 2] = b));\nfunction background(S) {\n  const L = S.light;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = sqrt((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2), v = floor((0.14 + 0.5 * (y / GROUND) ** 1.6) * 20) / 20, e = q \u003c MR + 4 ? 60 : q \u003c MR + 9 ? 26 : 0;\n      const sp = q > MR - 1.5 || (x - MX + 3) ** 2 + (y - MY + 2) ** 2 \u003c 10 ? 24 : 0;\n      if (q \u003c MR) put(S.bg, (y * W + x) * 3, 255 - sp, 240 - sp, 204 - sp);\n      else if (y > 100 + 4 * sin(x * 0.09) + 2.5 * sin(x * 0.23 + 1.3)) put(S.bg, (y * W + x) * 3, L[0] * 0.16 + 8, L[1] * 0.16 + 6, L[2] * 0.16 + 12);\n      else put(S.bg, (y * W + x) * 3, L[0] * v + e, L[1] * v + e * 0.93, L[2] * v + e * 0.83);\n    }\n}\n// A tall headstone with a cut cross, rimmed by the moon.\nconst inStone = (dx, y) => abs(dx) \u003c SHW && y \u003c GROUND && (y >= ST + SHW || dx * dx + (y - ST - SHW) ** 2 \u003c SHW * SHW);\nfunction headstone(buf, cx) {\n  for (let y = ST - 1; y \u003c GROUND; y++)\n    for (let x = max(0, floor(cx - SHW)); x \u003c min(W, ceil(cx + SHW)); x++) {\n      const dx = x + 0.5 - cx, yy = y + 0.5;\n      if (!inStone(dx, yy)) continue;\n      const cut = (abs(dx) \u003c 1.1 && y > ST + 5 && y \u003c ST + 19) || (abs(dx) \u003c 4.2 && y >= ST + 9 && y \u003c ST + 11);\n      const v = !inStone(dx, yy - 1) || !inStone(dx + 1, yy) ? 1.6 : cut ? 0.45 : dx \u003c 3 - SHW ? 0.75 : 1;\n      put(buf, (y * W + x) * 3, 92 * v, 94 * v, 112 * v);\n    }\n}\n// Bone in three tones, the darkest tinted by the sky; the hat violet.\nconst BONE = [[255, 244, 220], [212, 202, 180], [96, 88, 84]];\nconst HATC = [[196, 120, 255], [140, 64, 210], [70, 26, 112]];\nconst FIELD = new Float32Array(48 * 48);\nfunction piece(S, pc, cx, cy, a, sc, Hd) {\n  const [k, sg, x0, x1, y0, y1] = pc, c = cos(a), s = sin(a);\n  let xa = 1e9, xb = -1e9, ya = 1e9, yb = -1e9;\n  for (const [u, v] of [[x0, y0], [x1, y0], [x0, y1], [x1, y1]]) {\n    const wx = cx + (u * c - v * s) * sc, wy = cy + (u * s + v * c) * sc;\n    (xa = min(xa, wx)), (xb = max(xb, wx)), (ya = min(ya, wy)), (yb = max(yb, wy));\n  }\n  xa = max(0, floor(xa) - 1);\n  xb = min(W - 1, ceil(xb) + 1);\n  ya = max(0, floor(ya) - 1);\n  yb = min(H - 1, ceil(yb) + 1);\n  if (xb \u003c xa || yb \u003c ya || xb - xa >= 48 || yb - ya >= 48) return;\n  const buf = S.buf, L = S.light, z = 1 / sc;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy;\n      FIELD[(y - ya) * 48 + x - xa] = shape(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z, sg) * sc;\n    }\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const f = (y - ya) * 48 + x - xa, d = FIELD[f], o = (y * W + x) * 3;\n      if (d > 0.1) {\n        if (d \u003c 1.1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, hl = hole(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z);\n      if (hl && hl !== 3) {\n        const e = hl === 1 ? [2, 0, 4] : hl === 5 ? [245, 134, 2] : Hd.eye, g = hl === 2 ? 0.34 : 1;\n        put(buf, o, e[0] * g + 10, e[1] * g + 6, e[2] * g + 14);\n        continue;\n      }\n      const up = y > ya ? FIELD[f - 48] : d + 1, dn = y \u003c yb ? FIELD[f + 48] : d + 1, n = (up - dn) / (abs(up - dn) + abs((x > xa ? FIELD[f - 1] : d) - (x \u003c xb ? FIELD[f + 1] : d)) + 0.01);\n      const t = hl === 3 || n \u003c= -0.3 ? 2 : n > 0.4 || (d > -0.6 && up > 0.1) ? 0 : 1, C = k === 9 ? HATC : BONE, w = t === 2 && k !== 9 ? 0.4 : 0;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = C[t][ch] + L[ch] * w;\n    }\n}\n// A jack-o'-lantern, the face flickering in three steps.\nfunction pumpkin(S, Hd) {\n  const buf = S.buf, cx = Hd.x, cy = Hd.y - 6, v = 0.6 + 0.2 * sin(S.t * 9) + 0.2 * sin(S.t * 23.7), fl = v > 0.82 ? 1 : v > 0.66 ? 0.84 : 0.7;\n  for (let y = max(0, floor(cy - 11)); y \u003c min(H, cy + 9); y++)\n    for (let x = max(0, floor(cx - 11)); x \u003c min(W, cx + 11); x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, o = (y * W + x) * 3, e = (dx / 9) ** 2 + (dy / 7) ** 2;\n      if (e \u003c 1) {\n        const rib = abs(abs(dx) - 4.2) \u003c 0.6 && e > 0.25, eye = dy > -4.2 && dy \u003c -0.8 && abs(abs(dx) - 3.6) \u003c 1.9 + (dy + 4.2) * 0.5, grin = dy > 1.1 && dy \u003c 3.9 - abs(dx) * 0.15 && abs(dx) \u003c 6 && !(abs(dx) % 3 \u003c 0.8 && dy \u003c 2.2);\n        if (eye || grin) put(buf, o, 255, 196 * fl + 30, 50 * fl);\n        else put(buf, o, rib ? 220 : 255, rib ? 84 : 118, rib ? 0 : 10);\n      } else if (e \u003c 1.35 && dy > -8) put(buf, o, buf[o] * 0.3, buf[o + 1] * 0.3, buf[o + 2] * 0.3);\n      if (abs(dx + 0.3) \u003c 1.2 && dy > -9.6 && dy \u003c -6.2) put(buf, o, 72, 150, 40);\n    }\n}\nfunction head(S, Hd) {\n  if (Hd.kind === PUMPKIN) return pumpkin(S, Hd);\n  // The right one's toxic halo, white on the click.\n  const [p, q] = rot(Hd.a, 0, -8), cx = Hd.x + p, cy = Hd.y + q, f = Hd.flash || 0;\n  for (let y = max(0, floor(cy - 15)); y \u003c min(H, cy + 15) && Hd.glow > 0; y++)\n    for (let x = max(0, floor(cx - 15)); x \u003c min(W, cx + 15); x++) {\n      const v = floor(max(0, 1 - sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2) / 15) * 4) / 4;\n      for (let ch = 0, o = (y * W + x) * 3; ch \u003c 3; ch++) S.buf[o + ch] += (TOXIC[ch] * Hd.glow * 0.8 + 255 * f) * v;\n    }\n  piece(S, SKULL, Hd.x, Hd.y, Hd.a, Hd.sc, Hd);\n  const [j0, j1] = rot(Hd.a, 0, (2.4 * Hd.jaw - 0.7) * Hd.sc), [h0, h1] = rot(Hd.a, 0, 10 * Hd.hd * Hd.sc);\n  piece(S, JAW, Hd.x + j0, Hd.y + j1, Hd.a, Hd.sc, Hd);\n  if (Hd.kind === HAT) piece(S, CAP, Hd.x + h0, Hd.y + h1, Hd.a, Hd.sc, Hd);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0 || !S.stones.length) return;\n  const buf = S.buf, K = S.K, cam = S.cam;\n  buf.set(S.bg);\n  // The ground, a lit edge and specks sliding with the camera.\n  for (let p = GROUND * W; p \u003c N; p++) {\n    const y = (p / W) | 0, e = y === GROUND ? 30 : (floor((p % W) + cam) * 7 + y * y * 3) % 11 ? 0 : 12;\n    put(buf, p * 3, 40 + e, 26 + e * 0.8, 48 + e);\n  }\n  const heads = (z) => [...S.stones.map((st) => st.Hd), S.lost?.Hd].forEach((Hd) => Hd && Hd.z === z && head(S, Hd));\n  // The stones stand in front of the path; the hands in front of what they hold.\n  for (let i = 0; i \u003c 13; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  for (const st of S.stones) headstone(buf, SX + st.j * GAP - cam);\n  heads(0);\n  heads(1);\n  for (let i = 13; i \u003c 15; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  heads(2);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","pumpkin-drop":"// ===== Patternflow pattern =====\n// Title:   Pumpkin Drop\n// Family:  halloween\n// Idea:    A lit jack-o'-lantern is wound up a wooden hoist under a cloudy purple night, swings at the top, is let go and falls all 128 rows with its flame streaking upward, then bursts on the ground, flinging shards and seeds over a splash of pulp while the candle tumbles out and sputters into a puff of smoke; the next pumpkin spins in from the right, lights up and goes up.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Flame=0..1, Speed=0.2..3, Wind=0..1, Size=0..1\n//\n// Knob 1: Flame. The colour of the candle and of what it lights: the carved face, the halo on the sky and the hoist, the streak as it falls and the flash of the burst. Gold at 0, toxic green at 0.25, blue at 0.5, magenta at 0.75. The pumpkin's skin stays orange.\n// Knob 2: Speed. At 2 a round takes about 10 s. The pumpkin is wound up from the ground in 2.2 s and swings for 1.6 s; the fall of 81 rows takes 1.04 s and ends at 156 LEDs a second; the burst lasts 2.4 s, the candle going out 1.3 to 1.6 s after the impact; the hook comes down in 0.9 s and the next pumpkin takes 1.8 s to come in and light. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Wind. How far the pumpkin swings at the top and how fast the clouds and the smoke drift right. At 0 nearly still air: a swing of 5 degrees either way and clouds at 2 LEDs a second. At 1 it swings 50 degrees and is let go at the end of a long arc, left and right in turn, while the top band of cloud runs at 18 LEDs a second. A big pumpkin swings less, so it stays on the panel.\n// Knob 4: Size. The pumpkin, 16 LEDs wide at 0 and 32 at 1, about 17 at the opening. A bigger one throws its light farther and bursts into more pieces: 25 shards at the opening and 48 at 1.\n// Buttons: K1 tap lets the hanging pumpkin go at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, asin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The ground's top row; the hoist's post, beam and pulley; the moon.\nconst GY = 119, PX = 38, PY = 13, MX = 52, MY = 34, MR = 7, CB = [20, 40, 62];\n// The rope's length from the pulley to the hook when the pumpkin hangs at\n// the top; the pumpkin's middle hangs its half height and 2 LEDs below.\nconst HOOK = 9;\n// Seconds of each part at Speed 2.\nconst T_HANG = 1.6, T_SMASH = 2.4, T_LOWER = 0.9, T_ROLL = 1.3, T_LIGHT = 0.5, T_HOIST = 2.2, SWING = 1.6;\nconst G = 150;\n// Light round a point, by squared distance in LEDs.\nconst RAD = new Float32Array(20480);\nfor (let i = 0; i \u003c RAD.length; i++) RAD[i] = exp(-sqrt(i) / 16);\n// Kinds of LED in the still picture and how much lantern light each takes.\nconst SKY = 0, WOOD = 1, EARTH = 2, MOON = 3, TAKE = [0.5, 0.75, 1, 0.1];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, gh: 0.11, speed: 2, wind: 0, size: 0.06, cx: [0, 31, 67], rx: 9, ry: 7,\n    ph: \"hoist\", e: 0, side: 1, lc: 0, th: 0, x: PX, y: 0, vy: 0, lit: 1, roll: 0,\n    hook: { l: 0, a: 0, w: 0 },\n    shards: [], seeds: [], smoke: [], splat: null, candle: null, flash: 0, fl: 1, fade: 1,\n    bg: new Float32Array(N * 3), kind: new Uint8Array(N), buf: new Float32Array(N * 3), c: [0, 0, 0], g: [0, 0, 0],\n    stars: [],\n  };\n  scene(params.s);\n}\n\n// The still picture: a violet sky paling to mauve at the horizon with the\n// moon in it, and the black hoist with a moonlit edge standing on the earth.\nfunction scene(S) {\n  const bg = S.bg, kd = S.kind, c = S.c;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3, u = y / GY;\n      hsv(0.74 + 0.08 * u, 0.72 - 0.12 * u, 0.3 + 0.2 * u * u, c);\n      const dm = sqrt((x - MX) ** 2 + (y - MY) ** 2);\n      const halo = 0.5 * exp(-max(0, dm - MR) / 7);\n      bg[o] = c[0] + 70 * halo;\n      bg[o + 1] = c[1] + 60 * halo;\n      bg[o + 2] = c[2] + 70 * halo;\n      if (dm \u003c MR + 0.5) {\n        // The moon, two grey seas on it set on a slant.\n        const sea = exp(-((x - MX + 2) ** 2 + (y - MY + 2) ** 2) / 5) + 0.8 * exp(-((x - MX - 3) ** 2 + (y - MY - 3) ** 2) / 4);\n        const a = cl(MR + 0.5 - dm, 0, 1), m = 1 - 0.18 * sea;\n        bg[o] += (238 * m - bg[o]) * a;\n        bg[o + 1] += (228 * m - bg[o + 1]) * a;\n        bg[o + 2] += (196 * m - bg[o + 2]) * a;\n        kd[p] = MOON;\n      }\n      if (y >= GY) {\n        // Earth, a little lighter in the top rows, with a speckle.\n        const k = 1 - (y - GY) * 0.05, n = 0.85 + 0.3 * ((x * 37 + y * 91) % 7) / 7;\n        bg[o] = 52 * k * n;\n        bg[o + 1] = 30 * k * n;\n        bg[o + 2] = 60 * k * n;\n        kd[p] = EARTH;\n      }\n    }\n  // Grass tufts standing on the ground line, black against the sky.\n  for (let x = 0; x \u003c W; x++) {\n    const hgt = 1 + ((x * 7 + 3) % 5 === 0 ? 2 : (x * 13) % 3 === 0 ? 1 : 0);\n    for (let j = 1; j \u003c= hgt; j++) wood(S, x, GY - j, 0.4);\n  }\n  // The post and the beam with its brace, each with a moonlit edge.\n  for (let y = 8; y \u003c GY; y++) for (let x = 4; x \u003c= 6; x++) wood(S, x, y, x === 6 ? 1 : 0);\n  for (let x = 2; x \u003c= 44; x++) for (let y = 8; y \u003c= 10; y++) wood(S, x, y, y === 8 ? 1 : 0);\n  for (let i = 0; i \u003c= 16; i++) for (let j = 0; j \u003c 2; j++) wood(S, 6 + i, 25 - i + j, j);\n  // The rope down the post to the winch.\n  for (let y = 11; y \u003c 97; y++) rope(bg, 8, y, 0.8);\n  for (let i = 0; i \u003c 26; i++) S.stars.push({ x: floor(rnd(0, W)), y: floor(rnd(0, 70)), ph: rnd(0, 7), f: rnd(1, 3), b: rnd(0.4, 1) });\n}\n\nfunction wood(S, x, y, edge) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x, o = p * 3;\n  S.bg[o] = 16 + 44 * edge;\n  S.bg[o + 1] = 8 + 30 * edge;\n  S.bg[o + 2] = 24 + 54 * edge;\n  S.kind[p] = WOOD;\n}\n\nfunction rope(buf, x, y, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (176 - buf[o]) * a;\n  buf[o + 1] += (140 - buf[o + 1]) * a;\n  buf[o + 2] += (96 - buf[o + 2]) * a;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.gh = 0.11 + cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.size = cl(k[3], 0, 1);\n  // A pie pumpkin 16 LEDs wide at 0, 32 at 1.\n  S.rx = 8 + 8 * S.size;\n  S.ry = 0.78 * S.rx;\n  const ds = (d * S.speed) / 2, hk = S.hook, RY = S.ry;\n  const TOP = HOOK + 2 + RY, LOW = GY - RY - 1 - PY;\n  // The swing, kept small enough that a big pumpkin stays on the panel.\n  const A = min(0.08 + 0.8 * S.wind, asin(min(1, (W - S.rx - 2 - PX) / TOP)));\n  S.t += ds;\n  S.e += ds;\n  // Three bands of cloud drift right, the lower ones slower.\n  for (let i = 0; i \u003c 3; i++) S.cx[i] += (2 + 16 * S.wind) * (1 - 0.25 * i) * ds;\n  // The candle flickers on three beats.\n  S.fl = 0.8 + 0.1 * sin(S.t * 23) + 0.06 * sin(S.t * 41 + 1) + 0.05 * sin(S.t * 7.3);\n  if (input.btnPressed && input.btnPressed[0] && S.ph === \"hang\") S.e = T_HANG;\n  if (S.ph === \"hoist\" || S.ph === \"hang\") {\n    // A pendulum from the pulley. While it is wound up the swing builds, and\n    // it is let go at the end of its swing, where it stands still.\n    const p = S.ph === \"hoist\" ? sm(S.e / T_HOIST) : 1;\n    const tt = S.ph === \"hoist\" ? S.e - T_HOIST : S.e;\n    S.lc = S.ph === \"hoist\" ? LOW + (TOP - LOW) * p : TOP;\n    S.th = S.side * A * p * cos((2 * PI * tt) / SWING);\n    S.x = PX + S.lc * sin(S.th);\n    S.y = PY + S.lc * cos(S.th);\n    hk.l = S.lc - RY - 2;\n    hk.a = S.th;\n    if (S.ph === \"hoist\" && S.e >= T_HOIST) (S.ph = \"hang\"), (S.e = 0);\n    else if (S.ph === \"hang\" && S.e >= T_HANG) {\n      S.ph = \"fall\";\n      S.e = 0;\n      S.vy = 0;\n      hk.w = 0;\n    }\n  } else if (S.ph === \"fall\") {\n    S.vy += G * ds;\n    S.y += S.vy * ds;\n    S.th *= exp(-1.5 * ds);\n    if (S.y + RY >= GY - 0.5) smash(S);\n  } else if (S.ph === \"smash\") {\n    if (S.e >= T_SMASH) (S.ph = \"lower\"), (S.e = 0);\n  } else if (S.ph === \"lower\") {\n    // The hook is let down to the ground while the mess fades.\n    const p = sm(S.e / T_LOWER);\n    hk.l = HOOK + (LOW - TOP) * p;\n    S.fade = 1 - p;\n    if (S.e >= T_LOWER) {\n      S.ph = \"roll\";\n      S.e = 0;\n      S.shards.length = S.seeds.length = 0;\n      S.splat = null;\n      S.fade = 1;\n      S.lit = 0;\n    }\n  } else if (S.ph === \"roll\") {\n    // The next pumpkin spins in from the right and turns its face to us.\n    const p = S.e / T_ROLL, q = 1 - (1 - p) * (1 - p);\n    S.x = PX + 36 * (1 - q);\n    S.y = PY + LOW;\n    S.roll = (S.x - PX) / S.rx;\n    S.th = 0;\n    if (S.e >= T_ROLL) (S.ph = \"light\"), (S.e = 0), (S.roll = 0);\n  } else if (S.ph === \"light\") {\n    S.lit = S.e \u003c 0.12 ? 1.6 * (S.e / 0.12) : 1 + 0.6 * exp(-(S.e - 0.12) * 8);\n    if (S.e >= T_LIGHT) {\n      S.ph = \"hoist\";\n      S.e = 0;\n      S.lit = 1;\n      S.side = -S.side;\n    }\n  }\n  // The empty hook swings back under the pulley.\n  if (S.ph !== \"hoist\" && S.ph !== \"hang\") {\n    hk.w += (-30 * hk.a - 2.2 * hk.w) * ds;\n    hk.a += hk.w * ds;\n  }\n  physics(S, ds);\n}\n\n// The pumpkin hits the ground and everything in it is thrown out at once.\nfunction smash(S) {\n  const RX = S.rx, RY = S.ry, b = S.size;\n  S.ph = \"smash\";\n  S.e = 0;\n  S.y = GY - RY - 0.5;\n  S.flash = 1;\n  const n = round(3 * RX), x0 = cl(S.x, 6, W - 7);\n  S.x = x0;\n  for (let i = 0; i \u003c n; i++) {\n    const a = rnd(-PI + 0.25, -0.25), sp = rnd(40, 95) * (0.9 + 0.4 * b), r = rnd(1.3, 3) * RX / 9;\n    S.shards.push({ x: x0 + rnd(-RX, RX) * 0.8, y: S.y + rnd(-RY, RY) * 0.6, vx: cos(a) * sp * 0.8, vy: sin(a) * sp, a: rnd(0, 7), w: rnd(-12, 12), r, k: Math.random() \u003c 0.3 ? 1 : 0, rest: 0 });\n  }\n  for (let i = 0; i \u003c 14 + 26 * b; i++) {\n    const a = rnd(-PI * 0.95, -PI * 0.05), sp = rnd(30, 85) * (0.8 + 0.5 * b);\n    S.seeds.push({ x: x0 + rnd(-4, 4), y: S.y, vx: cos(a) * sp, vy: sin(a) * sp, rest: 0, p: Math.random() \u003c 0.35 });\n  }\n  S.splat = { x: x0, w: 0, s: 6 + 8 * b + 4 * Math.random() };\n  const dir = Math.random() \u003c 0.5 ? -1 : 1;\n  S.candle = { x: x0, y: S.y, vx: dir * rnd(16, 26), vy: -rnd(55, 70), a: 0, w: dir * rnd(8, 14), f: 1, out: rnd(1.3, 1.6), t: 0, puff: false };\n}\n\nfunction physics(S, ds) {\n  S.flash *= exp(-ds * 9);\n  for (const s of S.shards) {\n    if (s.rest) continue;\n    s.vy += G * ds;\n    s.x += s.vx * ds;\n    s.y += s.vy * ds;\n    s.a += s.w * ds;\n    if (s.x \u003c 0.5 || s.x > W - 1.5) (s.vx = -0.5 * s.vx), (s.x = cl(s.x, 0.5, W - 1.5));\n    if (s.y > GY - 0.5 && s.vy > 0) {\n      s.y = GY - 0.5;\n      s.vy *= -0.42;\n      s.vx *= 0.55;\n      s.w *= 0.5;\n      if (abs(s.vy) \u003c 12) (s.rest = 1), (s.y = GY - 0.5 + rnd(0, 1.2));\n    }\n  }\n  for (const s of S.seeds) {\n    if (s.rest) continue;\n    s.vy += G * ds;\n    s.x += s.vx * ds;\n    s.y += s.vy * ds;\n    if (s.y > GY && s.vy > 0) {\n      s.y = GY;\n      s.vy *= -0.45;\n      s.vx *= 0.6;\n      if (abs(s.vy) \u003c 10) (s.rest = 1), (s.y = GY + floor(rnd(0, 3)));\n    }\n  }\n  if (S.splat) S.splat.w = min(1, S.splat.w + ds * 6);\n  const cd = S.candle;\n  if (cd) {\n    cd.t += ds;\n    cd.vy += G * ds;\n    cd.x += cd.vx * ds;\n    cd.y += cd.vy * ds;\n    cd.a += cd.w * ds;\n    if (cd.x \u003c 2 || cd.x > W - 3) (cd.vx = -0.6 * cd.vx), (cd.x = cl(cd.x, 2, W - 3));\n    if (cd.y > GY - 1 && cd.vy > 0) {\n      // On the ground it lies down and rolls to a stop.\n      cd.y = GY - 1;\n      cd.vy *= -0.3;\n      cd.vx *= 0.7;\n      cd.w = 0;\n      cd.a += (PI / 2 - (cd.a % PI)) * 0.4;\n      if (abs(cd.vy) \u003c 8) cd.vy = 0;\n    }\n    if (cd.vy === 0) cd.vx *= exp(-4 * ds);\n    // It sputters: the flame gutters and goes out.\n    const left = cd.out - cd.t;\n    cd.f = left > 0 ? cl(left / cd.out + 0.3, 0, 1) * (left \u003c 0.6 ? (sin(cd.t * 61) > 0.1 ? 1 : 0.25) : 1) : 0;\n    if (left \u003c= 0 && !cd.puff) {\n      cd.puff = true;\n      const w = wick(cd);\n      for (let i = 0; i \u003c 22; i++) S.smoke.push({ x: w[0] + rnd(-0.5, 0.5), y: w[1] - rnd(0, 2), vx: rnd(-5, 5), vy: -rnd(10, 26), r: rnd(0.8, 1.4), t: 0, life: rnd(1.8, 2.8) });\n    }\n    if (S.ph === \"roll\") S.candle = null;\n  }\n  let n = 0;\n  for (const m of S.smoke) {\n    m.t += ds;\n    m.x += (m.vx + 3 * sin(m.t * 3 + m.life * 5) + 12 * S.wind * min(1, m.t)) * ds;\n    m.y += m.vy * ds;\n    m.vy *= exp(-0.6 * ds);\n    m.r = min(3.6, m.r + ds * 1.6);\n    if (m.t \u003c m.life) S.smoke[n++] = m;\n  }\n  S.smoke.length = n;\n}\n\n// Where the candle's wick is: the top of the stick, which tumbles.\nfunction wick(cd) {\n  return [cd.x + 2.5 * sin(cd.a), cd.y - 2.5 * cos(cd.a)];\n}\n\n// Add a colour at a pixel by alpha.\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\n// One LED of the pumpkin at local (u, v) from its middle, turned by its\n// spin: false outside it. Ribs are meridians, so they crowd at the edges;\n// the face is painted on the front and turns away as it spins.\nfunction pumpkinAt(S, u, v, out) {\n  const RX = S.rx, RY = S.ry, k = 9 / RX, vv = v / RY;\n  if (vv \u003c -1 || vv > 1) return false;\n  const half = RX * sqrt(1 - vv * vv) * (vv \u003c 0 ? 1 : 1 - 0.08 * vv);\n  if (abs(u) > half + 0.35) return false;\n  // A dip at the top round the stem.\n  if (vv \u003c -0.8 && abs(u) \u003c 2 && v \u003c -RY + 0.9) return false;\n  const n = cl(u / max(half, 0.5), -1, 1), lon = asin(n) - S.roll;\n  const rib = abs(((lon / 0.628 + 50.5) % 1) - 0.5) \u003c 0.13;\n  const nz = sqrt(max(0, 1 - n * n)) * sqrt(max(0, 1 - vv * vv));\n  const lightv = 0.82 + 0.18 * cl(0.3 * n - 0.5 * vv + 0.5 * nz, 0, 1);\n  const glow = S.lit * S.fl;\n  let hole = false;\n  if (cos(lon) > 0.2) hole = face(9 * sin(lon), v * k);\n  if (hole) {\n    if (glow > 0.05) {\n      hsv(S.gh + 0.03, 0.62 - 0.4 * cl(glow - 0.7, 0, 1), min(1, 0.5 + 0.5 * glow), out);\n    } else (out[0] = 46), (out[1] = 16), (out[2] = 6);\n    return true;\n  }\n  // Skin: bright saturated orange, the ribs a redder line.\n  hsv(rib ? 0.05 : 0.07, 1, lightv * (rib ? 0.86 : 0.97), out);\n  return true;\n}\n\n// The carving, in LEDs from the middle of a pumpkin 18 wide: triangle eyes\n// over a small nose, then a grin with two teeth above and one below.\nfunction face(u, v) {\n  const au = abs(u);\n  if (v >= -4 && v \u003c= -1.5) {\n    const w = (v + 4.3) * 0.75;\n    if (abs(au - 4.2) \u003c w) return true;\n  }\n  if (v >= -0.5 && v \u003c= 0.6 && au \u003c 0.6 + (v + 0.5) * 0.9) return true;\n  if (v > 1.5 && v \u003c 4.5) {\n    const top = 2.5 - 0.035 * au * au, bot = 4.2 - 0.05 * au * au;\n    if (au \u003c 6.4 && v > top && v \u003c bot) {\n      if (v \u003c top + 1.2 && (abs(u + 2.5) \u003c 0.6 || abs(u - 2.5) \u003c 0.6)) return false;\n      if (v > bot - 1.1 && au \u003c 0.6) return false;\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const bg = S.bg, buf = S.buf, kd = S.kind, gc = hsv(S.gh, 0.85, 1, S.g), c = S.c, hk = S.hook;\n  // Lantern light: from the pumpkin while it is whole and lit, then from the\n  // candle out on the ground; the burst adds a flash.\n  const whole = S.ph !== \"smash\" && S.ph !== \"lower\";\n  const L1 = whole ? (0.9 + 0.5 * S.size) * S.lit * S.fl : 0, q1 = (8.5 / S.rx) ** 2, cd = S.candle, RX = S.rx, RY = S.ry;\n  const L2 = cd ? 0.7 * cd.f * S.fl : 0, wk = cd ? wick(cd) : [0, 0];\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3;\n      let l = 0;\n      if (L1 > 0) l += L1 * RAD[min(20479, round(((x - S.x) ** 2 + (y - S.y) ** 2) * q1))];\n      if (L2 > 0) l += L2 * RAD[min(20479, round((x - wk[0]) ** 2 + (y - wk[1]) ** 2 * 1.5))];\n      if (S.flash > 0.01) l += 1.6 * S.flash * RAD[min(20479, round(((x - S.x) ** 2 + (y - GY) ** 2) * 0.4))];\n      const t = l * TAKE[kd[p]];\n      let r = bg[o], g = bg[o + 1], b = bg[o + 2];\n      if (y > 6 && y \u003c 78 && kd[p] !== WOOD) {\n        // Cloud: wisps of value noise in three wavy bands, lilac grey.\n        let a = 0;\n        for (let i = 0; i \u003c 3; i++) {\n          const dy = (y - CB[i] - 3 * vn((x - S.cx[i]) * 0.03, i * 31)) / (3.5 + 1.5 * i);\n          if (dy * dy > 4) continue;\n          const u = x - S.cx[i], n = vn(u * 0.045 + y * 0.02, i * 101) + 0.6 * vn(u * 0.12 - y * 0.05, i * 101 + 7) + 0.3 * vn(u * 0.25 + y * 0.1, i * 101 + 13);\n          a += cl((n - 0.05) * 2.2, 0, 1) * exp(-dy * dy) * 0.75;\n        }\n        if (a > 0) {\n          a = min(0.8, a);\n          r += (142 - r) * a;\n          g += (116 - g) * a;\n          b += (178 - b) * a;\n        }\n      }\n      buf[o] = r + gc[0] * t;\n      buf[o + 1] = g + gc[1] * t;\n      buf[o + 2] = b + gc[2] * t;\n    }\n  // Stars twinkle.\n  for (const s of S.stars) {\n    const b = s.b * (0.55 + 0.45 * sin(S.t * s.f + s.ph));\n    put(buf, s.x, s.y, 235, 220, 255, 0.85 * b);\n  }\n  // The winch on the post turns as the rope runs.\n  const wa = hk.l / 3;\n  for (let i = 0; i \u003c 24; i++) {\n    const a = (i / 24) * 2 * PI;\n    put(buf, 9 + 3.5 * cos(a), 100 + 3.5 * sin(a), 120, 90, 60, 1);\n  }\n  for (let i = 0; i \u003c 4; i++) {\n    const a = wa + (i * PI) / 2;\n    for (let r = 0; r \u003c= 3; r++) put(buf, 9 + r * cos(a), 100 + r * sin(a), 150, 112, 70, 1);\n  }\n  // The pulley under the beam.\n  for (let i = 0; i \u003c 16; i++) {\n    const a = (i / 16) * 2 * PI;\n    put(buf, PX + 2.2 * cos(a), PY + 2.2 * sin(a), 120, 110, 130, 1);\n  }\n  put(buf, PX, PY, 200, 190, 210, 1);\n  // The rope and the hook: on the pumpkin while it hangs, empty after.\n  const ha = hk.a, hl = hk.l;\n  for (let i = 2; i \u003c= hl; i += 0.7) rope(buf, PX + i * sin(ha), PY + i * cos(ha), 0.9);\n  const hx = PX + hl * sin(ha), hy = PY + hl * cos(ha);\n  put(buf, hx, hy + 1, 170, 170, 190, 1);\n  put(buf, hx + 1, hy + 2, 170, 170, 190, 1);\n  put(buf, hx, hy + 2.6, 140, 140, 160, 1);\n  // The pumpkin, turned by its swing.\n  if (whole) {\n    const cs = cos(S.th), sn = sin(S.th);\n    // The flame streaks up out of it as it falls.\n    if (S.ph === \"fall\") {\n      const len = min(20, S.vy / 6);\n      for (let j = 0; j \u003c len; j++) {\n        const f = 1 - j / len;\n        hsv(S.gh + 0.04 - 0.08 * (1 - f), 0.1 + 0.8 * (1 - f), 1, c);\n        put(buf, S.x, S.y - RY - 1 - j, c[0], c[1], c[2], S.fl * min(1, 1.5 * f));\n        hsv(S.gh - 0.03, 0.85, 1, c);\n        for (let i = -1; i \u003c= 1; i += 2) if (j \u003c len * 0.7) put(buf, S.x + i, S.y - RY - 1 - j, c[0], c[1], c[2], 0.75 * f * S.fl);\n      }\n    }\n    for (let dy = -ceil(RY) - 3; dy \u003c= RY + 1; dy++)\n      for (let dx = -ceil(RX) - 2; dx \u003c= RX + 2; dx++) {\n        const u = dx * cs + dy * sn, v = -dx * sn + dy * cs;\n        if (pumpkinAt(S, u, v, c)) put(buf, S.x + dx, S.y + dy, c[0], c[1], c[2], 1);\n        else if (v \u003c -RY + 1 && v > -RY - 2.5 && abs(u) \u003c 1.1) put(buf, S.x + dx, S.y + dy, 70, 120, 40, 1);\n      }\n  }\n  // The burst: pulp splashed on the ground, with the shards and seeds over it.\n  const fa = S.fade;\n  if (S.splat) {\n    const sp = S.splat;\n    for (let i = -sp.s - 3; i \u003c= sp.s + 3; i++) {\n      const w = sp.s * sp.w, r = abs(i) / max(1, w), j = (i * 7919 + 13) % 5;\n      if (r > 1) continue;\n      const hgt = 1 + (r \u003c 0.6 ? 1 : 0) + (j === 0 ? 1 : 0);\n      for (let k = 0; k \u003c hgt; k++) put(buf, sp.x + i, GY - k + (k ? 0 : 0), 255, 150 + 20 * j, 30, fa * (1 - 0.3 * k));\n    }\n  }\n  for (const s of S.shards) {\n    const ca = cos(s.a), sa = sin(s.a), r = s.r;\n    for (let dy = -3; dy \u003c= 3; dy++)\n      for (let dx = -3; dx \u003c= 3; dx++) {\n        // A rough triangle of skin, or of yellow flesh.\n        const u = dx * ca + dy * sa, v = -dx * sa + dy * ca;\n        if (v \u003c -r * 0.5 || v > r * 0.6 || abs(u) > r - (v + r * 0.5) * 0.9) continue;\n        if (s.k) put(buf, s.x + dx, s.y + dy, 255, 196, 60, fa);\n        else put(buf, s.x + dx, s.y + dy, 255, v \u003c 0 ? 112 : 96, 0, fa);\n      }\n  }\n  for (const s of S.seeds) {\n    put(buf, s.x, s.y, 250, 238, 190, fa);\n    if (s.p && !s.rest) put(buf, s.x - s.vx * 0.02, s.y - s.vy * 0.02, 255, 170, 40, fa * 0.8);\n  }\n  if (cd) {\n    // The candle, a stub of wax two LEDs thick, and its flame, which stands\n    // up whichever way the stub lies.\n    const ca = cos(cd.a), sa = sin(cd.a);\n    for (let j = -2; j \u003c= 2; j += 0.5)\n      for (let i = 0; i \u003c= 1; i++) put(buf, cd.x + j * sa + i * ca, cd.y - j * ca + i * sa, 240, 232, 212, fa);\n    if (cd.f > 0.02) {\n      const w = wick(cd), fl = cd.f * S.fl;\n      hsv(S.gh + 0.04, 0.15, 1, c);\n      put(buf, w[0], w[1] - 1, c[0], c[1], c[2], min(1, fl * 1.4));\n      put(buf, w[0] + 1, w[1] - 1, c[0], c[1], c[2], min(1, fl * 0.8));\n      hsv(S.gh, 0.8, 1, c);\n      put(buf, w[0], w[1] - 2, c[0], c[1], c[2], min(1, fl * 1.2));\n      put(buf, w[0] + 1, w[1] - 2, c[0], c[1], c[2], fl * 0.6);\n      if (fl > 0.5) put(buf, w[0] + 0.5 + 0.6 * sin(S.t * 13), w[1] - 3, c[0], c[1], c[2], fl - 0.3);\n    }\n  }\n  for (const m of S.smoke) {\n    const a = 0.5 * (1 - m.t / m.life) * min(1, m.t * 8);\n    const r = m.r;\n    for (let dy = -4; dy \u003c= 4; dy++)\n      for (let dx = -4; dx \u003c= 4; dx++) {\n        const q = dx * dx + dy * dy;\n        if (q \u003c= r * r + 0.3) put(buf, m.x + dx, m.y + dy, 180, 170, 196, a * (1 - q / (r * r + 1.5)));\n      }\n  }\n  // Out in steps of four.\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, min(255, ((buf[o] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 1] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 2] + 2) >> 2) \u003c\u003c 2));\n}\n","specimen-shelf":"// ===== Patternflow pattern =====\n// Title:   Specimen Shelf\n// Family:  halloween\n// Idea:    Three specimen jars on two shelves, toxic green and amber above and violet below, each hold a floating eyeball; one turns to stare out at you, the others glance at it and turn one after another, then all of them look away together, roll up in a blink and drift apart, while bubbles rise and a knock on a shelf sets the fluid sloshing and glowing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Knock=0..1\n//\n// Knob 1: Hue. Turns the three fluids round the wheel together, each iris with its fluid: at 0 toxic green with a magenta iris and amber with a blue iris on the top shelf, violet with a gold iris below. At 0.33 they are blue, green and amber, at 0.67 red, violet and teal. The whites, veins, nerves, lids, cork and shelves stay as they are.\n// Knob 2: Speed. At 2 one round of the story takes 12 s: the first eye turns to stare 0.6 s in, the second glances at it at 1.3 s and stares at 1.8, the third glances at 2.1 and stares at 2.6; they stare until 4.4, look away together until 5.3, blink and drift from 5.7. Each round a different eye starts. A small bubble rises through its jar in about 3 s. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Bubbles. At 0 four bubbles a second across the three jars, a third of them rings; at 0.5 about 18 a second; at 1 sixty a second, four in five of them rings up to 5 LEDs across in the small jars and 7 in the big one.\n// Knob 4: Knock. How often something knocks a shelf, and how hard. At 0 the first knock comes 6.6 s in and then one every 12 s; at 0.06, 6.3 s in and every 11.4 s; at 1, 1.5 s in and every 1.8 s, twice as hard. Each knock hits the other shelf from the last: the board jolts 2 LEDs sideways, dust falls from under it or jumps off it, the fluid tilts 3 rows at the glass (6 at 1) and sloshes for about 2 s, glowing brighter while it settles, a burst of bubbles shakes loose, and every eye that is not staring turns toward the knock.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, acos, exp, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The two shelves: the top of each board and the row its front ends.\nconst SHELF = [[56, 61], [119, 127]];\n// The three jars. Rows: lid (or cork), neck, shoulder, body, rounded bottom,\n// thick base. Half-widths inside the glass. surf is the fluid's resting\n// row, ex/ey/er the eye's rest and radius, hue the fluid's colour, iris the\n// eye's, lum how bright the fluid is away from the light.\nconst JARS = [\n  { cx: 16, lid: [5, 10], lidW: 11.5, cork: 0, neck: [11, 13], neckW: 9, sh: [14, 18], w: 12, bot: [50, 54], base: 55, shelf: 0,\n    surf: 19, ex: 16, ey: 36, er: 7, hue: 0.29, iris: 0.83, irisS: 0.8, lum: 0.08 },\n  { cx: 48, lid: [4, 9], lidW: 5.5, cork: 1, neck: [10, 17], neckW: 5, sh: [18, 28], w: 12.5, bot: [49, 54], base: 55, shelf: 0,\n    surf: 24, ex: 48, ey: 40, er: 7, hue: 0.09, iris: 0.6, irisS: 0.8, lum: 0.2 },\n  { cx: 32, lid: [63, 69], lidW: 22.5, cork: 0, neck: [70, 72], neckW: 18, sh: [73, 79], w: 23, bot: [111, 117], base: 118, shelf: 1,\n    surf: 81, ex: 32, ey: 98, er: 11, hue: 0.78, iris: 0.12, irisS: 0.72, lum: 0.07, gold: 1 },\n];\nfunction halfIn(J, y) {\n  if (y \u003c J.neck[0] || y >= J.bot[1]) return -1;\n  if (y \u003c J.sh[0]) return J.neckW;\n  if (y \u003c J.sh[1]) {\n    const u = (J.sh[1] - y) / (J.sh[1] - J.sh[0]);\n    return J.neckW + (J.w - J.neckW) * sqrt(1 - u * u);\n  }\n  if (y \u003c J.bot[0]) return J.w;\n  const u = (y - J.bot[0]) / (J.bot[1] - J.bot[0]);\n  return J.w - (J.w * 0.25) * (1 - sqrt(1 - u * u));\n}\n\n// Veins on the white, laid out in the eye's own angles (th from the gaze\n// axis, ph round it) so they turn with it; tabled once, ph against th.\nconst VEINS = [], VT = 65;\nfor (let k = 0; k \u003c 7; k++) {\n  const ph0 = (k * TAU) / 7 + 0.35 * sin(k * 2.3), a = 0.22 + 0.08 * sin(k * 1.7), f = 3 + (k % 3), p = k * 1.3;\n  const tab = new Float32Array(VT);\n  for (let j = 0; j \u003c VT; j++) {\n    const th = (j * PI) / (VT - 1);\n    tab[j] = ph0 + a * sin(f * th + p) + 0.1 * sin(9 * th + 2 * p);\n  }\n  VEINS.push({ tab, end: 0.8 + 0.1 * ((k * 5) % 3) });\n}\nconst IRIS = 0.62;\n// The fluid's glow round an eye, falling off by e every 5 LEDs, tabled.\nconst EXP5 = Float32Array.from({ length: 64 }, (_, i) => exp(-i / 20));\n\nexport function setup(params) {\n  // Per LED: which jar (0 none, else 1 + index) and what part of it.\n  // 1 fluid side of the glass, 2 glass wall, 3 thick base, 4 lid, 5 cork,\n  // 6 shelf top, 7 shelf front, 0 the wall behind.\n  const reg = new Uint8Array(N), jar = new Uint8Array(N), glow = new Float32Array(N);\n  JARS.forEach((J, j) => {\n    J.hw = new Float32Array(H);\n    for (let y = 0; y \u003c H; y++) J.hw[y] = halfIn(J, y);\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const i = y * W + x, dx = abs(x + 0.5 - J.cx), hw = J.hw[y];\n        let r = 0;\n        if (y >= J.lid[0] && y \u003c= J.lid[1]) {\n          const lw = J.cork ? J.lidW - 0.15 * (y - J.lid[0]) : y === J.lid[0] ? J.lidW - 1.5 : y === J.lid[0] + 1 ? J.lidW - 0.5 : J.lidW;\n          if (dx \u003c lw) r = J.cork ? 5 : 4;\n        } else if (hw > 0 && dx \u003c hw) r = 1;\n        else if (hw > 0 && dx \u003c hw + 1.3) r = 2;\n        else if (y >= J.bot[1] && y \u003c= J.base && dx \u003c J.w * 0.8 + 1) r = 3;\n        if (r) (reg[i] = r), (jar[i] = j + 1);\n        // How much of this jar's glow reaches the wall here.\n        const top = J.lid[0], bot = J.base;\n        const ddx = max(0, dx - (hw > 0 ? hw + 1 : J.w)), ddy = y \u003c top ? top - y : y > bot ? y - bot : 0;\n        const gw = exp(-hypot(ddx, ddy) / 5);\n        if (!r && !reg[i] && gw > glow[i]) (glow[i] = gw), (jar[i] = j + 1);\n      }\n  });\n  SHELF.forEach(([a, b]) => {\n    for (let y = a; y \u003c= b; y++) for (let x = 0; x \u003c W; x++) reg[y * W + x] = y \u003c a + 2 ? 6 : 7;\n  });\n  params.s = {\n    t: 0, hue: 0, speed: 2, bub: 0, knockK: 0.06,\n    reg, jar, glow,\n    eyes: JARS.map((J, j) => ({\n      yaw: 0.6 - 0.6 * j, pitch: 0.2, roll: 0, tyaw: 0.6, tpitch: 0.2, next: 0.5 + 0.7 * j, rate: 2,\n      stare: 0, dil: 0, ox: 0, oy: 0, vx: 0, vy: 0, ph: j * 2.1,\n    })),\n    slosh: JARS.map(() => ({ a: 0, v: 0, ag: 0 })),\n    bubbles: [], acc: 0, pops: [], dust: [], kSide: 1, cyc: -1, look: [0, 0],\n    knockAt: 0, kAge: 9, kShelf: 0,\n    rgb: new Float32Array(N * 3), nerve: new Float32Array(N),\n  };\n}\n\n// The story, in seconds at Speed 2, one round of 12 s: one eye turns to\n// stare out at 0.6; the next glances at it at 1.3 and stares at 1.8; the\n// last glances at 2.1 and stares at 2.6; at 4.4 all three look away to the\n// same place, at 5.3 they roll up and back down together, a blink, and from\n// 5.7 each drifts on its own.\nconst ROUND = 12;\nfunction story(S, e, j, tc, order) {\n  const pos = order.indexOf(j), st = [0.6, 1.8, 2.6][pos], gl = [9, 1.3, 2.1][pos];\n  if (tc >= 5.3 && tc \u003c 5.7) return { yaw: 0, pitch: -1.75, rate: 16, stare: 0 };\n  if (tc >= 4.4 && tc \u003c 5.3) return { yaw: S.look[0], pitch: S.look[1], rate: 11, stare: 0 };\n  if (tc >= st && tc \u003c 4.4) return { yaw: 0, pitch: 0, rate: 6, stare: 1 };\n  if (tc >= gl && tc \u003c st) {\n    // Glance at whichever has already turned.\n    const L = JARS[order[0]], J = JARS[j];\n    const dx = L.ex - J.ex, dy = L.ey - J.ey;\n    return { yaw: atan2(dx, 10), pitch: cl(atan2(dy, hypot(dx, 10)), -1, 1), rate: 9, stare: 0 };\n  }\n  return null;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.bub = cl(k[2], 0, 1);\n  S.knockK = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  const cyc = floor(S.t / ROUND), tc = S.t - cyc * ROUND;\n  if (cyc !== S.cyc) {\n    S.cyc = cyc;\n    // Who starts this round, and where all three look together.\n    const o = [[2, 0, 1], [1, 2, 0], [0, 1, 2]][cyc % 3];\n    S.order = o;\n    const looks = [[-1.1, -0.5], [1.1, 0.3], [0.2, 0.9], [-0.9, 0.6]];\n    S.look = looks[cyc % 4];\n  }\n  // Knocks: the first 6.6 s in at 0, 1.5 s in at 1; then every 12 s at 0\n  // and every 1.8 s at 1. Each hits the other shelf from the last.\n  S.knockAt += g;\n  const first = mix(6.6, 1.5, S.knockK), every = mix(12, 1.8, S.knockK);\n  if (S.knockAt >= (S.knocks ? every : first)) {\n    S.knockAt = 0;\n    S.knocks = (S.knocks || 0) + 1;\n    S.kAge = 0;\n    S.kShelf = S.knocks % 2;\n    const hard = 0.6 + 0.6 * S.knockK, side = S.knocks % 3 === 1 ? -1 : 1;\n    S.kSide = side;\n    JARS.forEach((J, j) => {\n      const near = J.shelf === S.kShelf ? 1 : 0.35;\n      S.slosh[j].v += side * hard * near * 20;\n      S.slosh[j].ag = min(1.5, S.slosh[j].ag + hard * near);\n      const e = S.eyes[j];\n      e.vx += side * hard * near * 22;\n      e.vy -= hard * near * 16;\n    });\n    // Dust shaken off the board: down from under the top shelf, up off the\n    // bottom one.\n    for (let n = 0; n \u003c 14 + 10 * S.knockK; n++) {\n      const top = S.kShelf === 0;\n      S.dust.push({ x: Math.random() * W, y: top ? SHELF[0][1] + 1 : SHELF[1][0] - 1, vx: (Math.random() - 0.5) * 6, vy: top ? 2 + 6 * Math.random() : -8 - 10 * Math.random(), life: 1.2 + Math.random() });\n    }\n    // A rush of bubbles shaken loose.\n    for (let n = 0; n \u003c 10 + 14 * S.knockK; n++) spawn(S, floor(Math.random() * 3), true);\n  }\n  S.kAge += g;\n  for (const m of S.dust) {\n    m.vy += 14 * g;\n    m.x += m.vx * g;\n    m.y += m.vy * g;\n    m.life -= g;\n  }\n  S.dust = S.dust.filter((m) => m.life > 0 && m.y \u003c H);\n  JARS.forEach((J, j) => {\n    // The fluid's tilt, a damped swing of about 1.4 a second.\n    const sl = S.slosh[j];\n    sl.v += (-80 * sl.a - 2.2 * sl.v) * g;\n    sl.a += sl.v * g;\n    // Shaken, the fluid lights up, and settles back in about a second.\n    sl.ag *= exp(-g * 1.1);\n    const e = S.eyes[j];\n    let tg = story(S, e, j, tc, S.order);\n    if (!tg && S.kAge \u003c 1) {\n      // A knock: every idle eye looks round at it.\n      const up = JARS[j].shelf > S.kShelf ? -0.6 : JARS[j].shelf \u003c S.kShelf ? 0.6 : 0.15;\n      tg = { yaw: S.kSide * 1, pitch: up, rate: 10, stare: 0 };\n      e.next = min(e.next, 1.2);\n    }\n    if (!tg) {\n      // Drifting: somewhere new to look every 1.5 to 3.5 s.\n      e.next -= g;\n      if (e.next \u003c= 0) {\n        e.next = 1.5 + 2 * Math.random();\n        e.tyaw = (Math.random() * 2 - 1) * (Math.random() \u003c 0.15 ? 1.9 : 0.9);\n        e.tpitch = (Math.random() * 2 - 1) * 0.6;\n      }\n      tg = { yaw: e.tyaw, pitch: e.tpitch, rate: 2, stare: 0 };\n    } else (e.tyaw = tg.yaw), (e.tpitch = tg.pitch);\n    const r = min(1, g * tg.rate);\n    e.yaw += wrap(tg.yaw - e.yaw) * r;\n    e.pitch += (tg.pitch - e.pitch) * r;\n    e.roll = 0.3 * sin(S.t * 0.23 + j) + 0.12 * sin(S.t * 0.61 + 2 * j);\n    e.stare += (tg.stare - e.stare) * min(1, g * (tg.stare ? 4 : 2.5));\n    e.dil += ((tg.stare && e.stare > 0.6 ? 1 : 0) - e.dil) * min(1, g * 2.4);\n    // A knock throws the eye; a spring brings it back.\n    e.vx += (-30 * e.ox - 3 * e.vx) * g;\n    e.vy += (-30 * e.oy - 3 * e.vy) * g;\n    e.ox += e.vx * g;\n    e.oy += e.vy * g;\n  });\n  // Bubbles: a few a second from each jar at 0, a fizz at 1.\n  S.acc += g * mix(4, 60, S.bub * S.bub);\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    spawn(S, floor(Math.random() * 3), false);\n  }\n  for (const b of S.bubbles) {\n    const J = JARS[b.j];\n    b.v = min(b.v + g * 30, 7 + 6 * b.r);\n    b.y -= b.v * g;\n    b.x += 2.5 * sin(b.ph + b.y * 0.3) * g;\n    b.x = cl(b.x, J.cx - J.hw[cl(round(b.y), 0, H - 1)] + 1, J.cx + J.hw[cl(round(b.y), 0, H - 1)] - 1);\n    if (b.y \u003c surfAt(S, b.j, b.x) + 0.5) {\n      b.dead = 1;\n      S.pops.push({ x: b.x, j: b.j, life: 0.25 });\n    }\n  }\n  S.bubbles = S.bubbles.filter((b) => !b.dead);\n  for (const p of S.pops) p.life -= g;\n  S.pops = S.pops.filter((p) => p.life > 0);\n}\nfunction spawn(S, j, shaken) {\n  const J = JARS[j];\n  const x = J.cx + (Math.random() * 2 - 1) * J.w * 0.7;\n  const y = shaken ? J.surf + 6 + Math.random() * (J.bot[0] - J.surf - 6) : J.bot[0] + 1;\n  const r = Math.random() \u003c 0.3 + 0.5 * S.bub ? 1.1 + Math.random() * (0.5 + 1.2 * S.bub) * (J.er / 7) : 0.5;\n  S.bubbles.push({ j, x, y, z: Math.random() * 2 - 1, r, v: shaken ? 4 : 1, ph: TAU * Math.random() });\n}\n// The fluid's surface row at x, tilted by the slosh and rippled.\nfunction surfAt(S, j, x) {\n  const J = JARS[j], t = S.t, a = S.slosh[j].a;\n  return J.surf + (a * (x - J.cx)) / J.w * 2.2 + 0.5 * sin(0.4 * x + 1.9 * t + j) + 0.35 * sin(0.7 * x - 2.6 * t) * (1 + 2 * abs(a));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, reg, jar, glow, nerve } = S, t = S.t;\n  const fls = JARS.map((J) => hsv(J.hue + S.hue, 0.92, 1));\n  const irs = JARS.map((J) => hsv(J.iris + S.hue, J.irisS, 1));\n  // Each eye this frame: where it sits and which way it faces.\n  const E = JARS.map((J, j) => {\n    const e = S.eyes[j], bob = 1 - 0.6 * e.stare, s2 = J.er / 11;\n    const ex = J.ex + (3 * sin(t * 0.45 + 1 + j * 2) * bob) * s2 + e.ox;\n    const ey = J.ey + (5 * sin(t * 0.9 + j * 1.7) + 1.2 * sin(t * 2.1 + j)) * bob * s2 + e.oy;\n    const er = J.er * (1 + 0.15 * e.stare);\n    const ca = cos(e.yaw), sa = sin(e.yaw), cb = cos(e.pitch), sb = sin(e.pitch);\n    const f = [sa * cb, sb, ca * cb];\n    const r0 = [ca, 0, -sa], u0 = [-sa * sb, cb, -ca * sb];\n    const cr = cos(e.roll), sr = sin(e.roll);\n    const rx = [r0[0] * cr + u0[0] * sr, r0[1] * cr + u0[1] * sr, r0[2] * cr + u0[2] * sr];\n    const ux = [u0[0] * cr - r0[0] * sr, u0[1] * cr - r0[1] * sr, u0[2] * cr - r0[2] * sr];\n    return { ex, ey, er, f, rx, ux, pupil: mix(0.36, 0.72, e.dil), front: f[2] \u003c 0, stare: e.stare };\n  });\n  // The optic nerves: a pink cord from the back of each eye, hanging and\n  // waving in the fluid.\n  nerve.fill(0);\n  E.forEach((v, j) => {\n    let bx = -v.f[0], by = -v.f[1];\n    const bl = hypot(bx, by);\n    let dx = bl > 0.05 ? bx / bl : 0, dy = bl > 0.05 ? by / bl : 1;\n    let x = v.ex + v.er * bx, y = v.ey + v.er * by;\n    const sc = v.er / 11;\n    for (let s = 0; s \u003c 11; s++) {\n      const rad = (2.2 - 0.1 * s) * max(0.7, sc);\n      for (let yy = floor(y - rad); yy \u003c= y + rad; yy++)\n        for (let xx = floor(x - rad); xx \u003c= x + rad; xx++) {\n          if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || jar[yy * W + xx] !== j + 1) continue;\n          const dd = sqrt((xx + 0.5 - x) ** 2 + (yy + 0.5 - y) ** 2);\n          if (dd \u003c rad) nerve[yy * W + xx] = max(nerve[yy * W + xx], dd \u003c rad - 1 ? 1 : 0.6);\n        }\n      const a = atan2(dy, dx), wave = 0.32 * sin(t * 1.6 - s * 0.45 + j);\n      const na = a + 0.12 * wrap(PI / 2 - a) + wave * 0.35;\n      dx = cos(na);\n      dy = sin(na);\n      x += 2 * sc * dx;\n      y += 2 * sc * dy;\n    }\n  });\n\n  // The light rippling through the fluid: three wavy bands, lit where their\n  // sum crosses zero. Each band's inner wave is worked out once a frame.\n  const cs = S.cs || (S.cs = new Float32Array(2 * W + 2 * H));\n  for (let y = 0; y \u003c H; y++) cs[y] = 0.9 * sin(y * 0.15 + t * 0.9);\n  for (let x = 0; x \u003c W; x++) cs[H + x] = 0.9 * sin(x * 0.19 - t * 0.6);\n  for (let i = 0; i \u003c W + H; i++) cs[H + W + i] = 0.7 * sin((i - H) * 0.12 + t * 0.9);\n  const sc = S.sc || (S.sc = new Float32Array(3 * W));\n  for (let j = 0; j \u003c 3; j++) for (let x = 0; x \u003c W; x++) sc[j * W + x] = surfAt(S, j, x + 0.5);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, rg = reg[i], jj = jar[i] - 1, px = x + 0.5, py = y + 0.5;\n      let r = 0.035, gg = 0.012, b = 0.06;\n      const J = JARS[jj], fl = fls[jj];\n      if (rg === 1) {\n        const sy = sc[jj * W + x] - (abs(px - J.cx) > J.hw[y] - 1.5 ? 1 : 0);\n        if (py \u003c sy - 0.5) {\n          r = 0.03 + 0.06 * fl[0];\n          gg = 0.02 + 0.08 * fl[1];\n          b = 0.06 + 0.06 * fl[2];\n        } else {\n          const v = E[jj], cyl = 1 - ((px - J.cx) / J.hw[y]) ** 2;\n          const a1 = x * 0.27 + cs[y] + t * 0.75 + jj;\n          const a2 = y * 0.2 + cs[H + x] - t * 1.1;\n          const a3 = (x + y) * 0.15 + cs[H + W + x - y + H];\n          const cv = abs(sin(a1) + sin(a2) + sin(a3));\n          const caus = cv \u003c 0.3 ? 1 - cv / 0.3 : 0;\n          const de = sqrt((px - v.ex) ** 2 + (py - v.ey) ** 2) - v.er;\n          const flare = 1 + 0.6 * v.stare + 1.4 * S.slosh[jj].ag;\n          let L = (J.lum + 0.2 * cyl * cyl) * flare + caus * (0.3 + 0.4 * cyl) + (de > 0 && de \u003c 16 ? 0.1 * (0.6 + 1.6 * v.stare) * EXP5[floor(de * 4)] : 0);\n          if (py \u003c sy + 0.5) L = 0.95;\n          L = q(L, 14);\n          r = fl[0] * L;\n          gg = fl[1] * L;\n          b = fl[2] * L;\n        }\n      } else if (rg === 2) {\n        r = 0.14 + 0.22 * fl[0];\n        gg = 0.16 + 0.24 * fl[1];\n        b = 0.2 + 0.22 * fl[2];\n      } else if (rg === 3) {\n        r = fl[0] * 0.45;\n        gg = fl[1] * 0.45;\n        b = fl[2] * 0.45;\n      } else if (rg === 4) {\n        // Pewter lid, ridged, with a bright band.\n        const dx = abs(px - J.cx), rnd = 0.6 + 0.4 * sqrt(max(0, 1 - (dx / J.lidW) ** 2));\n        const ridge = (y - J.lid[0]) % 2 === 0 ? 1.25 : 0.8;\n        const spec = abs(px - (J.cx - J.lidW * 0.5)) \u003c 1.2 ? 2.6 : 1;\n        const vv = ridge * spec * rnd * (y === J.lid[1] ? 0.6 : 1);\n        r = 0.17 * vv;\n        gg = 0.13 * vv;\n        b = 0.25 * vv;\n        if (y === J.lid[0]) (r = 0.42), (gg = 0.36), (b = 0.52);\n      } else if (rg === 5) {\n        // The cork, grainy and lit from the left.\n        const dx = px - J.cx, grain = ((x * 7 + y * 13) % 5) / 5;\n        const vv = (0.75 - 0.05 * dx) * (0.85 + 0.25 * grain) * (y === J.lid[0] ? 1.2 : 1);\n        r = 0.62 * vv;\n        gg = 0.36 * vv;\n        b = 0.24 * vv;\n      } else if (rg === 6) {\n        // The shelf top: the jars' glow pools under them.\n        let pr = 0, pg = 0, pb = 0;\n        JARS.forEach((K, k) => {\n          if (SHELF[K.shelf][0] !== y && SHELF[K.shelf][0] + 1 !== y) return;\n          const pool = exp(-abs(px - K.cx) / (K.w * 0.7)), f2 = fls[k];\n          pr += 0.45 * pool * f2[0];\n          pg += 0.45 * pool * f2[1];\n          pb += 0.45 * pool * f2[2];\n        });\n        r = 0.2 + pr;\n        gg = 0.1 + pg;\n        b = 0.28 + pb;\n      } else if (rg === 7) {\n        const edge = y === SHELF[0][0] + 2 || y === SHELF[1][0] + 2;\n        r = edge ? 0.26 : 0.1;\n        gg = edge ? 0.15 : 0.04;\n        b = edge ? 0.36 : 0.16;\n      } else if (jj >= 0) {\n        const gw = 0.1 * glow[i] * (1 + 0.8 * E[jj].stare);\n        r += gw * fl[0];\n        gg += gw * fl[1];\n        b += gw * fl[2];\n      }\n      if (rg === 1) {\n        const v = E[jj], u = (px - v.ex) / v.er, w = (py - v.ey) / v.er, d2 = u * u + w * w, nv = nerve[i];\n        if (nv && (v.front || d2 >= 1)) {\n          r = 0.9 * nv;\n          gg = 0.32 * nv;\n          b = 0.42 * nv;\n        } else if (d2 \u003c 1) {\n          const f = v.f, rx = v.rx, ux = v.ux, iris = irs[jj];\n          const nz = sqrt(1 - d2), cosA = u * f[0] + w * f[1] + nz * f[2];\n          const th = acos(cl(cosA, -1, 1)), sh = 0.55 + 0.45 * nz;\n          if (th \u003c IRIS * v.pupil) (r = 0), (gg = 0), (b = 0);\n          else if (th \u003c IRIS) {\n            const tt = th / IRIS;\n            const ph = atan2(u * ux[0] + w * ux[1] + nz * ux[2], u * rx[0] + w * rx[1] + nz * rx[2]);\n            // Never below 0.6 of full, and the gold one near full, so that\n            // it stays gold and does not turn olive.\n            const streak = 0.8 + 0.2 * sin(ph * 13 + 3 * sin(ph * 4));\n            let vv = tt > 0.86 ? 0.05 : streak * (tt \u003c v.pupil + 0.12 ? 1 : 0.88) * (0.85 + 0.15 * sh);\n            if (J.gold && vv > 0.1) vv = 0.9 + 0.1 * streak;\n            r = iris[0] * vv;\n            gg = iris[1] * vv;\n            b = iris[2] * vv;\n          } else {\n            const rim = (1 - nz) * (1 - nz);\n            r = mix(1, fl[0], 0.7 * rim) * sh;\n            gg = mix(0.97, fl[1], 0.7 * rim) * sh;\n            b = mix(0.95, fl[2], 0.7 * rim) * sh;\n            const ph = atan2(u * ux[0] + w * ux[1] + nz * ux[2], u * rx[0] + w * rx[1] + nz * rx[2]);\n            const st = sin(th) * v.er, jt = round((th / PI) * (VT - 1)), wd = 0.4 + 0.3 * (th / PI);\n            for (const vn of VEINS)\n              if (th >= vn.end && abs(wrap(ph - vn.tab[jt])) * st \u003c wd) {\n                r = 0.8 * sh;\n                gg = 0.02 * sh;\n                b = 0.06 * sh;\n                break;\n              }\n          }\n          if ((u + 0.38) ** 2 + (w + 0.42) ** 2 \u003c 0.03) (r = 1), (gg = 1), (b = 1);\n        }\n      }\n      // The glass catches the light down its left side.\n      if ((rg === 1 || rg === 2) && abs(px - (J.cx - J.hw[y] - 0.2)) \u003c 0.8 && y > J.sh[1] && y \u003c J.bot[0]) {\n        r += 0.22;\n        gg += 0.22;\n        b += 0.22;\n      }\n      const o = i * 3;\n      rgb[o] = r;\n      rgb[o + 1] = gg;\n      rgb[o + 2] = b;\n    }\n  // Bubbles: a bright point, or a ring for the bigger ones; those behind the\n  // eye are hidden by it.\n  for (const bb of S.bubbles) {\n    const R = bb.r, v = E[bb.j], fl = fls[bb.j], x0 = floor(bb.x - R - 1), y0 = floor(bb.y - R - 1);\n    for (let y = y0; y \u003c= y0 + 2 * R + 2; y++)\n      for (let x = x0; x \u003c= x0 + 2 * R + 2; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || reg[y * W + x] !== 1 || jar[y * W + x] !== bb.j + 1) continue;\n        if (bb.z \u003c 0 && (x + 0.5 - v.ex) ** 2 + (y + 0.5 - v.ey) ** 2 \u003c v.er * v.er) continue;\n        const dd = sqrt((x + 0.5 - bb.x) ** 2 + (y + 0.5 - bb.y) ** 2);\n        if (R \u003c 1 ? dd \u003c 0.75 : abs(dd - R) \u003c 0.55) {\n          const o = (y * W + x) * 3;\n          rgb[o] = mix(fl[0], 1, 0.6);\n          rgb[o + 1] = mix(fl[1], 1, 0.6);\n          rgb[o + 2] = mix(fl[2], 1, 0.6);\n        }\n      }\n  }\n  // A popped bubble flicks two drops off the surface.\n  for (const p of S.pops) {\n    const fl = fls[p.j];\n    for (const dx of [-1, 1]) {\n      const x = floor(p.x + dx * (1.5 - p.life * 2)), y = floor(surfAt(S, p.j, p.x) - 2 - (p.life \u003c 0.12 ? 1 : 0));\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || reg[y * W + x] !== 1) continue;\n      const o = (y * W + x) * 3;\n      rgb[o] = mix(fl[0], 1, 0.5);\n      rgb[o + 1] = mix(fl[1], 1, 0.5);\n      rgb[o + 2] = mix(fl[2], 1, 0.5);\n    }\n  }\n  for (const m of S.dust) {\n    const x = floor(m.x), y = floor(m.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3, a = 0.5 * min(1, m.life);\n    rgb[o] = max(rgb[o], 0.75 * a);\n    rgb[o + 1] = max(rgb[o + 1], 0.62 * a);\n    rgb[o + 2] = max(rgb[o + 2], 0.8 * a);\n  }\n  // A knock jolts its shelf sideways for a moment.\n  const jolt = S.kAge \u003c 0.5 ? round(2.2 * sin(S.kAge * 40) * exp(-S.kAge / 0.18)) : 0;\n  const j0 = S.kShelf ? 62 : 0, j1 = S.kShelf ? H : 62;\n  for (let i = 0; i \u003c N; i++) {\n    const x = i % W, y = floor(i / W);\n    const sx = jolt && y >= j0 && y \u003c j1 ? cl(x - jolt, 0, W - 1) : x, o = (y * W + sx) * 3;\n    display.setPixel(x, y, 4 * round(63.75 * cl(rgb[o], 0, 1)), 4 * round(63.75 * cl(rgb[o + 1], 0, 1)), 4 * round(63.75 * cl(rgb[o + 2], 0, 1)));\n  }\n}\n","zonal-jets":"// ===== Patternflow pattern =====\n// Title:   Zonal Jets\n// Family:  wave\n// Idea:    Two-dimensional turbulence stirred in small eddies on a beta plane, solved on the panel's own 64x128 grid, gathers its energy into east-west jets stacked up the panel, eastward flow red to pale amber and westward violet to sky blue, while the stream lines drawn over them close into cat's eyes between the jets and slide west as Rossby waves, three times faster than the jets carry the water east; beta sets how many jets stand, through the Rhines scale.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: beta-plane zonal jets and the Rhines scale (Peter Rhines, 1975), Rossby waves (Carl-Gustaf Rossby, 1939), pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beta=-1..1, Stir=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together. At 0 eastward flow runs from red through orange to pale amber and westward flow from violet through blue to pale sky blue, dark where the water is still. At 0.33 the eastward flow is green and the westward crimson to pink; at 0.67 blue and lime.\n// Knob 2: Speed. Flow time per second. At 2 the jet cores carry the water east at about 7 LEDs a second, and the pattern of stream lines on them slides west at about 20. At 1 half as fast, at 0.2 a tenth. Above 2 a frame may take a third step; when the flow is too fast for the steps a frame may take, it runs slower instead.\n// Knob 3: Beta. How fast the Coriolis parameter grows northward, 9 at 0, from 2.5 at -1 to 32 at 1. At -1 two eastward jets stand on the panel, now and then three, with big eddies between them; at 0 three or four; at 1 four to six narrow ones, and the stream lines slide west at about 48 LEDs a second. Turning it by more than 0.2 starts a fresh run at the new beta.\n// Knob 4: Stir. How hard the small eddies that feed the jets are stirred, at a wavelength of 6.4 LEDs, by a factor of 12 from one end to the other. At 0 and at the opening 0.06 the jets run smooth between round eddies; at 1 the bands fill with grainy small eddies and the jets fray.\n// Buttons: K1 tap starts a fresh run.\n\nconst W = 64, H = 128;\nconst { floor, min, max, exp, sqrt, abs, cos, sin, PI, log2, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The panel is a periodic box 2 pi wide and 4 pi tall, x to the east and y to\n// the north (up the panel), solved pseudo-spectrally the way Inverse Cascade\n// solves it, with Orszag's two-thirds rule and third-order Adams-Bashforth\n// steps of changing length. The vorticity q obeys\n//   dq/dt + J(psi, q) + beta dpsi/dx = stirring - MU q - NU (k / kmax)^8 q\n// The beta term is linear like the friction, so it goes into the integrating\n// factor with them: each mode turns round by beta kx / k^2 per unit time,\n// the westward drift of a Rossby wave.\n// Flow time per panel second at Speed 2, and the Courant number each step\n// keeps to (with |u| + |v|). At 1.0 the smallest modes flare up now and\n// then; at 0.9 they do not.\nconst RATE = 0.7, CFL = 0.9;\n// Hyperviscosity at the cut-off wavenumber, per unit time. At 12 the\n// enstrophy piled up near the cut-off in bursts, patches of ripples three\n// LEDs long; at 80 it drains away.\nconst NU = 80;\n// White-in-time stirring on a ring of wavenumbers KF +- 1, a wavelength of\n// 6.4 LEDs, injecting energy EPS per unit time at Stir 0.06; the knob scales\n// it by STR per unit of knob. Linear drag MU.\nconst KF = 10, EPS = 0.003, STR = 12, MU = 0.003;\n// beta at Beta 0, and the factor one unit of the knob multiplies it by.\nconst BM = 9, BR = 3.6;\n// A run starts from noise round wavenumber K0 with energy E0 on a grid half\n// as fine (32 x 64, stirred at KF0). It runs there for PRE units of flow\n// time before the first frame and is then carried over mode for mode to the\n// panel grid, so the jets already stand when the panel lights.\nconst KF0 = 7, K0 = 5, E0 = 1, PRE = 15;\n// The colour is the zonal velocity u with only AL of its departure from the\n// row's mean, so the eddies tint the bands without breaking them; UN of its\n// largest size reaches full colour.\nconst AL = 0.4, UN = 0.7, LUT = 512;\n// Stream lines: BANDS per largest size of psi, cut DEP deep with a cos^LP\n// profile so they stay thin.\nconst BANDS = 4, DEP = 0.6, LP = 3;\n// The hue of the strongest eastward flow at Hue 0 and how far the weak flow\n// turns from it; the brightness floor and curve.\nconst HE = 0.12, HS = 0.15, V0 = 0.25, GAM = 0.5;\n// Crossfade into a fresh run, panel seconds.\nconst FADE = 0.6;\n\n// ---- radix-2 FFT, in place on (re, im) at off, off + st, off + 2 st, ...\nfunction plan(n) {\n  const lg = log2(n), rev = new Uint16Array(n), c = new Float64Array(n >> 1), s = new Float64Array(n >> 1);\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c lg; b++) r |= ((i >> b) & 1) \u003c\u003c (lg - 1 - b);\n    rev[i] = r;\n  }\n  for (let i = 0; i \u003c n >> 1; i++) (c[i] = cos((2 * PI * i) / n)), (s[i] = sin((2 * PI * i) / n));\n  return { n, rev, c, s, br: new Float64Array(n), bi: new Float64Array(n) };\n}\nfunction fft1(P, re, im, off, st, sign) {\n  const { n, rev, c, s, br, bi } = P;\n  for (let i = 0; i \u003c n; i++) {\n    const j = off + rev[i] * st;\n    br[i] = re[j];\n    bi[i] = im[j];\n  }\n  for (let size = 2; size \u003c= n; size \u003c\u003c= 1) {\n    const half = size >> 1, step = n / size;\n    for (let a0 = 0; a0 \u003c n; a0 += size)\n      for (let k = 0, t = 0; k \u003c half; k++, t += step) {\n        const wr = c[t], wi = sign * s[t], a = a0 + k, b = a + half;\n        const xr = br[b] * wr - bi[b] * wi, xi = br[b] * wi + bi[b] * wr;\n        br[b] = br[a] - xr;\n        bi[b] = bi[a] - xi;\n        br[a] += xr;\n        bi[a] += xi;\n      }\n  }\n  for (let i = 0; i \u003c n; i++) (re[off + i * st] = br[i]), (im[off + i * st] = bi[i]);\n}\n// The y transforms run only on the columns that survive the cut.\nfunction fft2(G, re, im, sign) {\n  const { w, h, cols, px, py } = G;\n  if (sign \u003c 0) for (let y = 0; y \u003c h; y++) fft1(px, re, im, y * w, 1, sign);\n  for (let t = 0; t \u003c cols.length; t++) fft1(py, re, im, cols[t], w, sign);\n  if (sign > 0) for (let y = 0; y \u003c h; y++) fft1(px, re, im, y * w, 1, sign);\n}\n\n// One grid over the box, w x h, stirred at kf.\nfunction grid(w, h, kf) {\n  const n = w * h, kxc = floor(w / 3), kyc = floor(h / 3), F = () => new Float64Array(n);\n  const G = {\n    w, h, n, dx: (2 * PI) / w, px: plan(w), py: plan(h), cols: [],\n    kx: F(), ky: F(), k2: F(), ik2: F(), lin: F(), neg: new Int32Array(n), idx: new Int32Array(n),\n    wr: F(), wi: F(), nr: F(), ni: F(), p1r: F(), p1i: F(), p2r: F(), p2i: F(), ar: F(), ai: F(), br: F(), bi: F(), ug: F(),\n    h1: 0, h2: 0, vmax: 0.4, vs: 0.4, um: 0, Ec: new Map(),\n  };\n  for (let x = 0; x \u003c w; x++) if ((x \u003c w / 2 ? x : w - x) \u003c= kxc) G.cols.push(x);\n  const keep = [], forced = [];\n  for (let y = 0; y \u003c h; y++)\n    for (let x = 0; x \u003c w; x++) {\n      const i = y * w + x, jx = x \u003c w / 2 ? x : x - w, jy = y \u003c h / 2 ? y : y - h, k2 = jx * jx + (jy * jy) / 4;\n      G.kx[i] = jx;\n      G.ky[i] = jy / 2;\n      G.k2[i] = k2;\n      G.ik2[i] = k2 > 0 ? 1 / k2 : 0;\n      G.neg[i] = ((h - y) % h) * w + ((w - x) % w);\n      // where the same mode sits on the panel grid\n      G.idx[i] = ((jy + H) % H) * W + ((jx + W) % W);\n      const q = k2 / (kxc * kxc);\n      G.lin[i] = q * q * q * q;\n      if (abs(jx) > kxc || abs(jy) > kyc) continue;\n      keep.push(i);\n      if (abs(sqrt(k2) - kf) \u003c= 1 && (jx > 0 || (jx === 0 && jy > 0))) forced.push(i);\n    }\n  G.keep = Int32Array.from(keep);\n  G.forced = Int32Array.from(forced);\n  // A kick of +-A sqrt(h) to both parts of each forced pair adds 4 A^2 h / 3\n  // to the sum of |q^|^2, an energy of EPS h at wavenumber kf.\n  G.famp = n * sqrt((3 * EPS * kf * kf) / (2 * forced.length));\n  return G;\n}\n\n// -div(u q) for the spectrum (sr, si), into (or, oi), dealiased. One inverse\n// transform brings q and psi to the grid together as q + i psi, the velocity\n// comes from fourth-order differences of psi, and one forward transform takes\n// u q + i v q back. Leaves q, psi and u on the grid in br, bi, ug.\nfunction tendency(G, sr, si, or, oi) {\n  const { w, h, n, kx, ky, ik2, keep, neg, ar, ai, br: om, bi: ps, ug } = G, nk = keep.length, mw = w - 1, mh = h - 1;\n  om.fill(0);\n  ps.fill(0);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], r = sr[i] / n, m = si[i] / n, q = ik2[i];\n    om[i] = r + q * m;\n    ps[i] = m - q * r;\n  }\n  fft2(G, om, ps, 1);\n  const c = 1 / (12 * G.dx);\n  let vmax = 0, um = 0;\n  for (let y = 0; y \u003c h; y++) {\n    const o = y * w, u1 = ((y + 1) & mh) * w, d1 = ((y - 1) & mh) * w, u2 = ((y + 2) & mh) * w, d2 = ((y - 2) & mh) * w;\n    for (let x = 0; x \u003c w; x++) {\n      const r1 = (x + 1) & mw, l1 = (x - 1) & mw, r2 = (x + 2) & mw, l2 = (x - 2) & mw;\n      const u = -c * (8 * (ps[u1 + x] - ps[d1 + x]) - (ps[u2 + x] - ps[d2 + x]));\n      const v = c * (8 * (ps[o + r1] - ps[o + l1]) - (ps[o + r2] - ps[o + l2]));\n      const q = om[o + x];\n      ug[o + x] = u;\n      ar[o + x] = u * q;\n      ai[o + x] = v * q;\n      const sp = abs(u) + abs(v);\n      if (sp > vmax) vmax = sp;\n    }\n  }\n  fft2(G, ar, ai, -1);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], j = neg[i], cr = ar[i], ci = ai[i], dr = ar[j], di = ai[j], a = kx[i], b = ky[i];\n    or[i] = 0.5 * (a * (ci - di) - b * (cr - dr));\n    oi[i] = -0.5 * (a * (cr + dr) + b * (ci + di));\n  }\n  return vmax;\n}\n\n// One AB3 step of length h with the linear terms in a complex integrating\n// factor (kept for a few step lengths at a time), then the stirring kick.\nfunction step(G, S, h) {\n  const { wr, wi, nr, ni, p1r, p1i, p2r, p2i, lin, kx, ik2, keep } = G, nk = keep.length;\n  G.vmax = tendency(G, wr, wi, nr, ni);\n  const key = h * 1e6 + S.beta;\n  let E = G.Ec.get(key);\n  if (!E) {\n    if (G.Ec.size > 8) G.Ec.clear();\n    E = new Float64Array(2 * G.n);\n    for (let t = 0; t \u003c nk; t++) {\n      const i = keep[t], d = exp(-h * (NU * lin[i] + MU)), th = h * S.beta * kx[i] * ik2[i];\n      E[2 * i] = d * cos(th);\n      E[2 * i + 1] = d * sin(th);\n    }\n    G.Ec.set(key, E);\n  }\n  const h1 = G.h1, h2 = G.h2;\n  let c0 = h, c1 = 0, c2 = 0;\n  if (h1 && h2) {\n    const a = (h * h * h) / 3, b = (h * h) / 2;\n    c0 = (a + (2 * h1 + h2) * b + h1 * (h1 + h2) * h) / (h1 * (h1 + h2));\n    c1 = -(a + (h1 + h2) * b) / (h1 * h2);\n    c2 = (a + h1 * b) / ((h1 + h2) * h2);\n  } else if (h1) (c0 = h * (1 + h / (2 * h1))), (c1 = -(h * h) / (2 * h1));\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], er = E[2 * i], ei = E[2 * i + 1];\n    const xr = wr[i] + c0 * nr[i] + c1 * p1r[i] + c2 * p2r[i], xi = wi[i] + c0 * ni[i] + c1 * p1i[i] + c2 * p2i[i];\n    wr[i] = er * xr - ei * xi;\n    wi[i] = er * xi + ei * xr;\n    let ar = p1r[i], ai = p1i[i];\n    p2r[i] = er * ar - ei * ai;\n    p2i[i] = er * ai + ei * ar;\n    ar = nr[i];\n    ai = ni[i];\n    p1r[i] = er * ar - ei * ai;\n    p1i[i] = er * ai + ei * ar;\n  }\n  const A = G.famp * sqrt(h * S.stir), F = G.forced, NG = G.neg;\n  for (let t = 0; t \u003c F.length; t++) {\n    const i = F[t], j = NG[i], a = (Math.random() * 2 - 1) * A, b = (Math.random() * 2 - 1) * A;\n    wr[i] += a;\n    wi[i] += b;\n    wr[j] += a;\n    wi[j] -= b;\n  }\n  G.h2 = h1;\n  G.h1 = h;\n}\n\n// The step: n steps from a ladder 16 to an octave, as long as the Courant\n// number allows, so the integrating factors come back.\nfunction ladder(G, adv, most) {\n  G.vs = max(G.vmax, G.vs * 0.98);\n  const hmax = (CFL * G.dx) / max(1e-6, G.vs), n = min(most, Math.ceil(adv / hmax));\n  return [n, pow(2, floor(16 * log2(min(adv / n, hmax))) / 16)];\n}\n\n// A fresh run: noise round K0 on the coarse grid, spun up, carried over.\nfunction start(S) {\n  const C = S.G0, G = S.G, { wr, wi, k2, keep, n } = C;\n  wr.fill(0);\n  wi.fill(0);\n  for (let i = 0; i \u003c n; i++) wr[i] = Math.random() * 2 - 1;\n  fft2(C, wr, wi, -1);\n  const on = new Uint8Array(n);\n  for (let t = 0; t \u003c keep.length; t++) on[keep[t]] = 1;\n  let e = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const q = k2[i] / (K0 * K0), a = on[i] && k2[i] > 0 ? q * exp(-q) : 0;\n    wr[i] *= a;\n    wi[i] *= a;\n    if (k2[i] > 0) e += (wr[i] * wr[i] + wi[i] * wi[i]) / k2[i];\n  }\n  const g = sqrt(E0 / ((0.5 * e) / (n * n)));\n  for (let i = 0; i \u003c n; i++) (wr[i] *= g), (wi[i] *= g);\n  C.h1 = C.h2 = 0;\n  for (let t = 0; t \u003c PRE; ) {\n    const [, h] = ladder(C, 1, 1);\n    step(C, S, h);\n    t += h;\n  }\n  const s = G.n / n;\n  G.wr.fill(0);\n  G.wi.fill(0);\n  for (let t = 0; t \u003c keep.length; t++) {\n    const i = keep[t], j = C.idx[i];\n    G.wr[j] = wr[i] * s;\n    G.wi[j] = wi[i] * s;\n  }\n  G.h1 = G.h2 = 0;\n  G.vs = C.vs;\n  G.vmax = C.vmax;\n  tendency(G, G.wr, G.wi, G.nr, G.ni);\n  S.b0 = S.k3;\n  S.runs++;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, k3: 0, b0: 0, beta: BM, stir: 1, runs: 0, fade: 0, usc: 0, psc: 0, palHue: -1,\n    G: grid(W, H, KF), G0: grid(W / 2, H / 2, KF0), zm: new Float64Array(H),\n    pal: new Float32Array(2 * LUT * 3), lines: new Float32Array(256), old: new Uint8Array(W * H * 3), cur: new Uint8Array(W * H * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, G = S.G, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.k3 = cl(k[2], -1, 1);\n  S.beta = BM * pow(BR, S.k3);\n  S.stir = pow(STR, cl(k[3], 0, 1) - 0.06);\n  const ft = cl(dt || 0, 0, 0.1);\n  if (!S.runs) start(S);\n  else if ((input.btnPressed && input.btnPressed[0]) || abs(S.k3 - S.b0) > 0.2) {\n    S.old.set(S.cur);\n    S.fade = 1;\n    start(S);\n  }\n  S.fade = max(0, S.fade - ft / FADE);\n  const adv = (ft * S.speed * RATE) / 2;\n  if (adv \u003c= 0) return;\n  const [n, h] = ladder(G, adv, S.speed > 2 ? 3 : 2);\n  for (let j = 0; j \u003c n; j++) step(G, S, h);\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Zonal velocity to colour: the upper half of the table is eastward flow,\n// red through orange to pale amber, the lower half westward, violet through\n// blue to pale sky blue, both dark where the flow is still.\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  const T = S.pal, c = [0, 0, 0];\n  for (let j = 0; j \u003c 2 * LUT; j++) {\n    const east = j >= LUT, a = east ? (j - LUT) / (LUT - 1) : (LUT - 1 - j) / (LUT - 1);\n    hsv(S.hue + (east ? HE : HE + 0.42) + (east ? -HS : HS) * pow(1 - a, 1.2), 1 - 0.5 * a * a * a, 1, c);\n    const v = 255 * (V0 + (1 - V0) * pow(a, GAM));\n    T[j * 3] = v * c[0];\n    T[j * 3 + 1] = v * c[1];\n    T[j * 3 + 2] = v * c[2];\n  }\n  for (let j = 0; j \u003c 256; j++) S.lines[j] = 1 - DEP * pow(0.5 + 0.5 * cos((2 * PI * j) / 256), LP);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.runs) return;\n  palette(S);\n  const G = S.G, { ug, bi: ps } = G, { pal: T, lines: L, zm, cur, old } = S;\n  let pm = 0, um = 0;\n  for (let y = 0; y \u003c H; y++) {\n    let a = 0;\n    for (let x = 0, o = y * W; x \u003c W; x++) {\n      a += ug[o + x];\n      if (abs(ps[o + x]) > pm) pm = abs(ps[o + x]);\n    }\n    zm[y] = a / W;\n  }\n  // The scales follow the flow slowly, so a strong eddy does not flash.\n  S.psc = S.psc ? S.psc + (pm - S.psc) * 0.05 : pm;\n  if (!S.usc) for (let i = 0; i \u003c G.n; i++) S.usc = max(S.usc, abs(zm[i >> 6] + AL * (ug[i] - zm[i >> 6])));\n  const iu = (LUT - 1) / max(1e-6, S.usc * UN), ip = (256 * BANDS) / max(1e-6, S.psc), f = S.fade, g = 1 - f;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, u = zm[y] + AL * (ug[i] - zm[y]), j = 3 * (LUT + cl(round(u * iu), -LUT, LUT - 1)), l = L[(ps[i] * ip + 1e6) & 255], o = 3 * ((H - 1 - y) * W + x);\n      if (abs(u) > um) um = abs(u);\n      cur[o] = T[j] * l;\n      cur[o + 1] = T[j + 1] * l;\n      cur[o + 2] = T[j + 2] * l;\n    }\n  S.usc = S.usc ? S.usc + (um - S.usc) * 0.05 : um;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) {\n      if (f > 0) display.setPixel(x, y, cur[o] * g + old[o] * f, cur[o + 1] * g + old[o + 1] * f, cur[o + 2] * g + old[o + 2] * f);\n      else display.setPixel(x, y, cur[o], cur[o + 1], cur[o + 2]);\n    }\n}\n","bat-form":"// ===== Patternflow pattern =====\n// Title:   Bat Form\n// Family:  halloween\n// Idea:    In the tall pointed window of a dark tower room a vampire stands black against a crimson and orange dusk, raises his arms so his cape spreads into a wide sail, shrinks as the cape's hem breaks into the scallops of a bat's wings, flies a loop out into the sky and back to the sill, and grows into the vampire again and folds his cape, while far bats circle over the hills.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cape=-1..1, Flock=0..1\n//\n// Knob 1: Hue. The dusk: overhead it stays purple, and the glow over the hills walks back round the wheel from gold at 0 through red at 0.15, magenta at 0.3, violet at 0.45 and blue at 0.6 to teal at 0.8 and lime green at 1. The vampire stays black, his eyes red and his cape's lining dark crimson.\n// Knob 2: Speed. At 2 one change takes 10 seconds: his arms rise from 0.25 s and the cape is wide by 1.15 s, he shrinks into the bat from 2 to 3.7 s, the bat beats its wings four to five times a second, flies its loop from 3.4 to 7.6 s and lands, he is a man again by 8.9 s and has folded the cape by 9.7 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Cape. How far the cape opens, and with it the bat's wings: at -1 the open cape is 25 LEDs across and the wings 25; at 0, where it opens, 43 and 45; at 1 the cape is 62 across, spilling over the jambs, and the wings span the panel.\n// Knob 4: Flock. How many far bats circle high in the sky and low over the hills, hazed a little toward the sky so the vampire stays the blackest thing: none at 0, 7 at 0.06 where it opens, 60 at 0.5 and a swarm of 120 at 1.\n// Buttons: K1 tap while he stands starts the change now; tapped while he folds his cape, he opens it again.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst lerp = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The window: an equilateral pointed arch over straight jambs, its sill a\n// ledge across the room. The vampire's chest stands at PX, PY.\nconst WX0 = 7, WX1 = 57, SPRING = 50, SILL = 104, SPAN = WX1 - WX0, TOP = SPRING - SPAN * 0.866;\nconst G0 = 1.15, PX = 32, PY = SILL - 30 * G0;\nconst inWindow = (x, y) => y \u003c= SILL && x >= WX0 && x \u003c= WX1 && (y >= SPRING || (Math.hypot(x - WX1, y - SPRING) \u003c= SPAN && Math.hypot(x - WX0, y - SPRING) \u003c= SPAN));\n// The dusk from the top of the window to the hills: height, how far the\n// hue has gone from the purple overhead toward the hue over the hills,\n// saturation and value.\nconst DUSK = [[0, 0, 0.85, 0.36], [0.3, 0.24, 0.85, 0.52], [0.55, 0.52, 0.85, 0.7], [0.78, 0.76, 0.9, 0.95], [0.9, 0.91, 0.85, 1], [1, 1, 0.7, 1]];\n// The far hills: their top per column.\nconst HILL = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) HILL[x] = 99.5 + 1.6 * sin(x * 0.11 + 1) + 1.2 * sin(x * 0.31) + 0.6 * sin(x * 0.9);\n// Two dead trees on the hills as line segments [x0, y0, x1, y1].\nconst TREES = [];\nfor (const [bx, h, s] of [[13, 12, 1], [51, 9, -1]]) {\n  const by = HILL[bx];\n  TREES.push([bx, by, bx + 0.5 * s, by - h], [bx + 0.3 * s, by - 0.55 * h, bx + 3.5 * s, by - 0.85 * h], [bx + 0.4 * s, by - 0.75 * h, bx - 2.5 * s, by - h - 1], [bx + 2 * s, by - 0.7 * h, bx + 3 * s, by - 0.6 * h - 3]);\n}\n\n// Three poses of the right half of the figure, in LEDs, feet at (0, 0) and\n// up negative; the left half mirrors it. head: centre and radius. collar:\n// inner and outer foot and the tip; it rises into the bat's ear. sh, waist,\n// hip, foot: the body's side. arm: shoulder, elbow, wrist. tips: the cape's\n// hem, which becomes the trailing edge of the wing, and att where the\n// membrane meets the body; dep is how deep the scallops between them are.\nconst CLOSED = {\n  head: [0, -40.5, 3.6], collar: [2.4, -36.6, 6.2, -35.4, 7.4, -46.5],\n  sh: [5.6, -35.4], waist: [4, -22], hip: [4.2, -19.5], foot: [2.6, 0],\n  arm: [5.4, -35.4, 7.2, -26, 8.4, -16], tips: [11.2, -1.6, 8.2, -1, 5.2, -0.8, 2.6, -0.8], att: [0.4, -0.8], dep: 0.12,\n};\nconst SPREAD = {\n  head: [0, -40.5, 3.6], collar: [2.4, -36.6, 6.2, -35.4, 7.4, -46.5],\n  sh: [5.6, -35.4], waist: [4, -22], hip: [4.2, -19.5], foot: [3.4, 0],\n  arm: [5.6, -35.4, 12.5, -40.5, 18.5, -45.5], tips: [20.5, -24, 16.5, -10.5, 11, -4.5, 5.6, -2], att: [1.6, -2.4], dep: 0.22,\n};\nconst BAT = {\n  head: [0, -33.6, 2.6], collar: [0.5, -35.4, 2.6, -34.3, 2.6, -39.8],\n  sh: [2.3, -31.3], waist: [1.9, -27.5], hip: [1.5, -25.8], foot: [1, -23],\n  arm: [2.3, -31.3, 8.5, -35.6, 14.5, -37], tips: [27, -30.5, 21.5, -26.6, 15, -25.2, 8.5, -26.6], att: [2.3, -27], dep: 0.5,\n};\nconst mixPose = (A, B, t, o) => {\n  for (const k in A) o[k] = typeof A[k] === \"number\" ? lerp(A[k], B[k], t) : A[k].map((v, i) => lerp(v, B[k][i], t));\n  return o;\n};\n\n// Small bats far over the hills: orbit centre, radii, speed and phase,\n// half span and wing beat.\nconst FLOCK = [];\nfor (let i = 0; i \u003c 120; i++) {\n  const r = (k) => hash(i * 7 + k);\n  // Most fly high, where the cape never covers them; each orbit fits the\n  // arch at its height.\n  const cy = r(11) \u003c 0.7 ? 14 + 44 * r(2) : 60 + 32 * r(2), half = (cy >= SPRING ? SPAN : sqrt(SPAN * SPAN - (cy - SPRING) ** 2)) - SPAN / 2 - 3;\n  const rx = min(half * 0.6, 3 + 9 * r(3));\n  FLOCK.push({ cx: 32 + (2 * r(1) - 1) * max(0, half - rx), cy, rx, ry: 2 + 4 * r(4), w: (r(5) \u003c 0.5 ? -1 : 1) * (0.5 + 0.8 * r(6)), ph: TAU * r(7), s: 3 + 4.4 * r(8) ** 2, f: 9 + 6 * r(9), fp: TAU * r(10) });\n}\n\n// A small bat's right half, half span 1, from the top of the head round to\n// the middle of its belly: x, y and how far the beat lifts the point.\nconst MINI = [0, -0.36, 0, 0.1, -0.4, 0, 0.16, -0.66, 0, 0.24, -0.34, 0, 0.5, -0.5, 1, 1, -0.3, 1.4, 0.84, -0.04, 1.1, 0.7, 0.04, 0.9, 0.6, -0.06, 0.8, 0.44, 0.12, 0.6, 0.34, 0, 0.4, 0.2, 0.18, 0.2, 0.1, 0.32, 0, 0, 0.34, 0];\n\n// One change in story seconds at Speed 2.\nconst CYCLE = 10;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, clock: 0, hue: 0, speed: 2, cape: 0, flock: 0.06, key: \"\", btn: false, flap: 0, spread: 0, m: 0, lift: 0, fly: 0, beat: 0,\n    base: new Float32Array(N * 3), buf: new Float32Array(N * 3), win: new Uint8Array(N), covB: new Float32Array(N), covM: new Float32Array(N),\n    pose: {}, pts: new Float64Array(64), xs: [], col: new Float32Array(3),\n  };\n}\n\n// The room, the window and the dusk, kept until Hue moves.\nfunction background(S) {\n  const { base, win } = S, c = S.col, hue = S.hue;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), cx = x + 0.5, cy = y + 0.5;\n    win[p] = inWindow(cx, cy) ? 1 : 0;\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), cx = x + 0.5, cy = y + 0.5, o = 3 * p;\n    if (win[p]) {\n      sky(hue, (cy - TOP) / (SILL - TOP), c);\n      let [r, g, b] = c;\n      // The jamb: a band just inside the opening where the stone is lit.\n      let edge = 9;\n      for (let dy = -2; dy \u003c= 2; dy++)\n        for (let dx = -2; dx \u003c= 2; dx++) {\n          const xx = x + dx, yy = y + dy;\n          if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || !win[yy * W + xx]) edge = min(edge, max(abs(dx), abs(dy)));\n        }\n      if (edge \u003c= 2 && cy \u003c SILL - 0.5) {\n        const k = edge === 1 ? 0.42 : 0.62;\n        (r = r * k + 0.04), (g = g * k + 0.02), (b = b * k + 0.06);\n      }\n      // The hills and their trees, dark against the glow.\n      if (cy > HILL[x]) [r, g, b] = cy - HILL[x] \u003c 1 ? [r * 0.35, g * 0.25, b * 0.4] : [0.05, 0.02, 0.07];\n      base[o] = r;\n      base[o + 1] = g;\n      base[o + 2] = b;\n    } else {\n      // The room: dark stone in courses, warmed near the window, the sill's\n      // top edge lit.\n      const near = max(0, 1 - distWin(cx, cy) / 14);\n      const course = (y % 6 === 5) || ((x + (floor(y / 6) % 2) * 5) % 10 === 0) ? 0.55 : 1;\n      sky(hue, 0.55, c);\n      let k = (0.06 + 0.16 * near * near) * course;\n      let r = 0.05 * course + c[0] * k, g = 0.02 * course + c[1] * k, b = 0.08 * course + c[2] * k;\n      if (y >= SILL && y \u003c SILL + 6 && x >= WX0 - 3 && x \u003c= WX1 + 3) {\n        sky(hue, 0.95, c);\n        const top = y === SILL ? 0.75 : y === SILL + 1 ? 0.3 : y \u003c SILL + 4 ? 0.12 : 0.07;\n        (r = c[0] * top + 0.03), (g = c[1] * top + 0.01), (b = c[2] * top + 0.05);\n      }\n      base[o] = r;\n      base[o + 1] = g;\n      base[o + 2] = b;\n    }\n  }\n  for (const [x0, y0, x1, y1] of TREES) {\n    const n = ceil(max(abs(x1 - x0), abs(y1 - y0)) * 2);\n    for (let i = 0; i \u003c= n; i++) {\n      const x = floor(lerp(x0, x1, i / n)), y = floor(lerp(y0, y1, i / n)), o = 3 * (y * W + x);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) base.set([0.05, 0.02, 0.07], o);\n    }\n  }\n}\n// Rough distance from (x, y) to the window opening.\nfunction distWin(x, y) {\n  if (y > SILL) return Math.hypot(max(0, WX0 - x, x - WX1), y - SILL);\n  if (y >= SPRING) return max(0, WX0 - x, x - WX1);\n  return max(0, Math.hypot(x - (x \u003c 32 ? WX1 : WX0), y - SPRING) - SPAN, WX0 - x, x - WX1);\n}\nfunction sky(hue, t, out) {\n  t = cl(t, 0, 1);\n  let i = 0;\n  while (i \u003c DUSK.length - 2 && t > DUSK[i + 1][0]) i++;\n  const A = DUSK[i], B = DUSK[i + 1], u = (t - A[0]) / (B[0] - A[0]);\n  // Over the hills gold at Hue 0, walking back through red, magenta,\n  // violet and blue to green at 1; overhead always purple, so the dim top\n  // never turns brown.\n  const low = 1.12 - 0.85 * hue;\n  hsv(0.79 + (low - 0.79) * lerp(A[1], B[1], u), lerp(A[2], B[2], u), lerp(A[3], B[3], u), out, 0);\n}\n\n// Coverage of a polygon added into cov: four sub-rows per LED, the span\n// ends shared out by area, nonzero winding.\nfunction fill(S, cov, P, n) {\n  let y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c n; i++) (y0 = min(y0, P[2 * i + 1])), (y1 = max(y1, P[2 * i + 1]));\n  const s0 = max(0, floor(y0 * 4)), s1 = min(4 * H - 1, ceil(y1 * 4)), xs = S.xs;\n  for (let sy = s0; sy \u003c= s1; sy++) {\n    const y = (sy + 0.5) / 4, row = floor(y) * W;\n    xs.length = 0;\n    for (let i = 0, j = n - 1; i \u003c n; j = i++) {\n      const ay = P[2 * j + 1], by = P[2 * i + 1];\n      if (ay \u003c= y !== by \u003c= y) {\n        const ax = P[2 * j], bx = P[2 * i];\n        xs.push(ax + ((y - ay) / (by - ay)) * (bx - ax), by > ay ? 1 : -1);\n      }\n    }\n    // Sort the crossings by x (a few, so insertion sort).\n    for (let i = 2; i \u003c xs.length; i += 2) {\n      const vx = xs[i], vd = xs[i + 1];\n      let j = i - 2;\n      while (j >= 0 && xs[j] > vx) (xs[j + 2] = xs[j]), (xs[j + 3] = xs[j + 1]), (j -= 2);\n      xs[j + 2] = vx;\n      xs[j + 3] = vd;\n    }\n    let wind = 0, from = 0;\n    for (let i = 0; i \u003c xs.length; i += 2) {\n      const before = wind;\n      wind += xs[i + 1];\n      if (before === 0) from = xs[i];\n      else if (wind === 0) span(cov, row, from, xs[i], 0.25);\n    }\n  }\n}\nfunction span(cov, row, xa, xb, w) {\n  xa = max(xa, 0);\n  xb = min(xb, W);\n  if (xb \u003c= xa) return;\n  const ia = floor(xa), ib = floor(xb);\n  if (ia === ib) {\n    cov[row + ia] += (xb - xa) * w;\n    return;\n  }\n  cov[row + ia] += (ia + 1 - xa) * w;\n  for (let x = ia + 1; x \u003c ib; x++) cov[row + x] += w;\n  if (ib \u003c W) cov[row + ib] += (xb - ib) * w;\n}\n\n// Where the story is at story time t: the spread s (0 cape closed, 1 arms\n// up and the cape wide), the change m (0 man, 1 bat), the flight f along its\n// loop, the lift off the sill and the wing beat's strength.\nfunction story(S) {\n  const t = S.t;\n  S.spread = t \u003c 5 ? ease((t - 0.25) / 0.9) : 1 - ease((t - 8.9) / 0.8);\n  S.m = t \u003c 5 ? ease((t - 2) / 1.7) : 1 - ease((t - 7.8) / 1.1);\n  S.lift = ease((t - 2.9) / 0.8) - ease((t - 7.6) / 0.5);\n  S.fly = ease((t - 3.4) / 4.2);\n  S.beat = ease((t - 2.3) / 0.8) * (1 - ease((t - 8) / 0.7));\n}\n\n// The figure's outline for the current story, into covB (body) and covM\n// (cape and wings), and the eyes.\nfunction figure(S) {\n  const wC = 0.92 + 0.4 * S.cape, m = S.m, mb = ease((m - 0.15) / 0.85), mw = ease(m / 0.85);\n  const A = mixPose(CLOSED, SPREAD, S.spread, S.pa || (S.pa = {}));\n  // The arm swings up through its angles, keeping its length, so the cape\n  // opens like a wing instead of being pulled flat.\n  const c0 = CLOSED.arm, c1 = SPREAD.arm, ang = (q, i) => Math.atan2(q[i + 3] - q[i + 1], q[i + 2] - q[i]), len = (q, i) => Math.hypot(q[i + 2] - q[i], q[i + 3] - q[i + 1]);\n  for (let i = 0; i \u003c 4; i += 2) {\n    const th = lerp(ang(c0, i), ang(c1, i), S.spread), l = lerp(len(c0, i), len(c1, i), S.spread);\n    A.arm[i + 2] = A.arm[i] + l * cos(th);\n    A.arm[i + 3] = A.arm[i + 1] + l * sin(th);\n  }\n  const Pz = mixPose(A, BAT, mw, S.pose);\n  // The body changes a little behind the wings.\n  for (const k of [\"head\", \"sh\", \"waist\", \"hip\", \"foot\"]) Pz[k] = A[k].map((v, i) => lerp(v, BAT[k][i], mb));\n  // Cape: the arms and hem reach wider with the knob, more so once spread.\n  const wx = lerp(1 + 0.6 * (wC - 1), wC, max(S.spread, m));\n  // Where the chest is, how big the figure is and how it leans.\n  const f = S.fly, a = TAU * f, depth = 1 - 0.6 * sin(PI * f) ** 2;\n  const g = G0 * lerp(1, 0.78, mb) * depth, cx = PX + 13 * sin(a), cy = PY - 4 * S.lift - 22 * (1 - cos(a)), bank = 0.32 * sin(a) * sin(PI * f);\n  // Out past the window the wall hides what strays beyond the opening.\n  S.clip = depth \u003c 0.97;\n  const flap = S.beat * 0.55 * sin(S.flap), cb = cos(bank), sb = sin(bank);\n  const pt = (x, y, side) => {\n    // local (feet at 0, chest at -30) to the panel.\n    const lx = side * x, ly = y + 30;\n    return [cx + g * (cb * lx - sb * ly), cy + g * (sb * lx + cb * ly)];\n  };\n  const P = S.pts;\n  S.box = [99, -99, 999, -99];\n  const poly = (cov, list) => {\n    for (let i = 0; i \u003c list.length; i++) {\n      P[2 * i] = list[i][0];\n      P[2 * i + 1] = list[i][1];\n      S.box[0] = min(S.box[0], list[i][0]);\n      S.box[1] = max(S.box[1], list[i][0]);\n      S.box[2] = min(S.box[2], list[i][1]);\n      S.box[3] = max(S.box[3], list[i][1]);\n    }\n    fill(S, cov, P, list.length);\n  };\n  for (const side of [1, -1]) {\n    // Wing: arm then hem, turned about the shoulder by the beat.\n    const [sx, sy] = Pz.sh, ca = cos(flap), sa = sin(flap);\n    const rot = (x, y, ch = 1) => {\n      const dx = x * wx - sx, dy = (y - sy) * ch;\n      return [sx + ca * dx + sa * dy, sy - sa * dx + ca * dy];\n    };\n    // The arms lift the sail higher as well as wider with the knob.\n    const up = lerp(1, 1 + 0.22 * S.cape, max(S.spread, m));\n    const ar = Pz.arm, el = rot(ar[2], ar[3], up), wr = rot(ar[4], ar[5], up);\n    const T = [];\n    // The hem stirs in the draught from the window while the cape is wide.\n    const stir = 0.9 * S.spread * (1 - mw);\n    const ch = lerp(1, 1 + 0.2 * S.cape, mw);\n    for (let i = 0; i \u003c 4; i++) T.push(rot(Pz.tips[2 * i] + stir * sin(S.clock * 2.3 + i * 1.7 + side), Pz.tips[2 * i + 1] + stir * 0.6 * sin(S.clock * 1.9 + i * 2.3), ch));\n    T.push(Pz.att);\n    const out = [[sx, sy - 1.2], el, wr, T[0]];\n    for (let i = 0; i \u003c 4; i++) {\n      // A scallop from tip i to i + 1, bowed toward the shoulder.\n      const [x0, y0] = T[i], [x1, y1] = T[i + 1], mx = (x0 + x1) / 2, my = (y0 + y1) / 2, L = Math.hypot(x1 - x0, y1 - y0);\n      const ux = sx - mx, uy = sy - my, ul = Math.hypot(ux, uy) || 1, d = Pz.dep * L;\n      const qx = mx + (ux / ul) * d, qy = my + (uy / ul) * d;\n      for (let k = 1; k \u003c= 4; k++) {\n        const u = k / 4, v = 1 - u;\n        out.push([v * v * x0 + 2 * u * v * qx + u * u * x1, v * v * y0 + 2 * u * v * qy + u * u * y1]);\n      }\n    }\n    poly(S.covM, out.map(([x, y]) => pt(x, y, side)));\n    // Arm bones over the membrane.\n    const arm = (a0, a1, r0, r1) => {\n      const dx = a1[0] - a0[0], dy = a1[1] - a0[1], l = Math.hypot(dx, dy) || 1, nx = -dy / l, ny = dx / l;\n      poly(S.covB, [[a0[0] + nx * r0, a0[1] + ny * r0], [a1[0] + nx * r1, a1[1] + ny * r1], [a1[0] - nx * r1, a1[1] - ny * r1], [a0[0] - nx * r0, a0[1] - ny * r0]].map(([x, y]) => pt(x, y, side)));\n    };\n    const thick = lerp(1.3, 0.75, mw);\n    arm([sx, sy], el, thick * 1.2, thick);\n    arm(el, wr, thick, thick * 0.8);\n    // Collar, rising into the ear.\n    const c = Pz.collar;\n    poly(S.covB, [[c[0], c[1]], [c[2], c[3]], [c[4], c[5]]].map(([x, y]) => pt(x, y, side)));\n    // Body side: neck, shoulder, waist, hip, leg to the foot, and the\n    // middle line back up.\n    const hd = Pz.head, nk = hd[1] + hd[2] * 0.7;\n    poly(S.covB, [[0, nk], [hd[2] * 0.45, nk], [Pz.sh[0], Pz.sh[1]], [Pz.waist[0], Pz.waist[1]], [Pz.hip[0], Pz.hip[1]], [Pz.foot[0] + 0.9, Pz.foot[1]], [Pz.foot[0] - 1.6 * (1 - mb) - 0.3, Pz.foot[1]], [0.4, Pz.hip[1] + 1.5 * (1 - mb)], [0, Pz.hip[1] + 1.5 * (1 - mb)]].map(([x, y]) => pt(x, y, side)));\n  }\n  // Head.\n  const hd = Pz.head, circ = [];\n  for (let i = 0; i \u003c 14; i++) circ.push(pt(hd[0] + hd[2] * cos((TAU * i) / 14), hd[1] + hd[2] * sin((TAU * i) / 14), 1));\n  poly(S.covB, circ);\n  // Eyes, while it faces the room.\n  const away = sin(PI * f) > 0.35;\n  S.eyes = away ? null : [pt(hd[2] * 0.36, hd[1] - 0.2, 1), pt(hd[2] * 0.36, hd[1] - 0.2, -1)];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.cape = cl(k[2], -1, 1);\n  S.flock = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  // A tap while he stands starts the change. While he folds the cape he\n  // opens it again from the same width: the fold is the spread run\n  // backwards, so the time that matches is a mirror image.\n  if (btn && !S.btn) {\n    if (S.t \u003c 0.25) S.t = 0.25;\n    else if (S.t >= 8.9) S.t = 0.25 + 0.9 * (1 - cl((S.t - 8.9) / 0.8, 0, 1));\n  }\n  S.btn = btn;\n  S.t = (S.t + ds) % CYCLE;\n  S.clock += ds;\n  S.flap += ds * TAU * (4.2 + 1.2 * S.beat * (1 - S.fly));\n  story(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.hue.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    background(S);\n  }\n  const { base, buf, win, covB, covM } = S;\n  buf.set(base);\n  // Thin clouds drifting across the dusk.\n  for (let y = floor(TOP); y \u003c 92; y++)\n    for (let x = WX0; x \u003c= WX1; x++) {\n      const p = y * W + x;\n      if (!win[p]) continue;\n      let c = 0;\n      for (let i = 0; i \u003c 3; i++) {\n        const yc = 24 + 21 * i + 2 * sin(x * 0.08 + i * 2 + S.clock * 0.1), dy = (y - yc) / (1.2 + 0.6 * i);\n        const patch = 0.5 + 0.5 * sin((x + S.clock * (1.2 + 0.4 * i)) * (0.13 + 0.03 * i) + i * 4);\n        c += exp(-dy * dy) * patch;\n      }\n      if (c > 0.02) {\n        const o = 3 * p, k = 1 - 0.45 * min(1, c);\n        buf[o] *= k;\n        buf[o + 1] *= k;\n        buf[o + 2] *= k * 0.95 + 0.05 * c;\n      }\n    }\n  // Small bats against the sky, seen only through the window: a filled\n  // outline each, the wings lifted and dropped by the beat.\n  const nb = round(120 * S.flock), sb = S.covM, P = S.pts;\n  sb.fill(0);\n  for (let i = 0; i \u003c nb; i++) {\n    // Each flutters off its orbit in small jerks, as bats do.\n    const b = FLOCK[i], a = b.ph + b.w * S.clock * 0.9, c = S.clock * b.f * 0.37 + b.fp;\n    const x = b.cx + b.rx * cos(a) + 1.2 * sin(c) * sin(2.3 * c), y = b.cy + b.ry * sin(a) + 1.4 * sin(1.7 * c + 1) * sin(0.9 * c);\n    const lift = -0.5 * sin(b.f * S.clock + b.fp);\n    let n = 0;\n    for (const sd of [1, -1])\n      for (let j = 0; j \u003c MINI.length; j += 3) {\n        const k = sd > 0 ? j : MINI.length - 3 - j, lx = MINI[k], ly = MINI[k + 1] + MINI[k + 2] * lift;\n        P[2 * n] = x + sd * lx * b.s;\n        P[2 * n + 1] = y + ly * b.s;\n        n++;\n      }\n    fill(S, sb, P, n);\n  }\n  if (nb)\n    for (let p = 0; p \u003c N; p++) {\n      const a = min(1, sb[p]);\n      if (a \u003c= 0 || !win[p]) continue;\n      // Hazed a little toward the sky, so they stay apart from the black\n      // figure in front of them.\n      const o = 3 * p;\n      buf[o] += (0.2 * base[o] + 0.01 - buf[o]) * a;\n      buf[o + 1] += (0.2 * base[o + 1] - buf[o + 1]) * a;\n      buf[o + 2] += (0.2 * base[o + 2] + 0.02 - buf[o + 2]) * a;\n    }\n  // The vampire or the bat.\n  covB.fill(0);\n  covM.fill(0);\n  figure(S);\n  const bx0 = max(0, floor(S.box[0]) - 1), bx1 = min(W - 1, ceil(S.box[1]) + 1), by0 = max(0, floor(S.box[2]) - 1), by1 = min(H - 1, ceil(S.box[3]) + 1);\n  // The cape's lining shows dark crimson while it is spread, and goes as it\n  // becomes a wing.\n  const lin = 0.16 * S.spread * (1 - ease(S.m / 0.6)), lining = [lin, lin * 0.05, lin * 0.12];\n  for (let y = by0; y \u003c= by1; y++)\n    for (let x = bx0; x \u003c= bx1; x++) {\n      const p = y * W + x, cb = min(1, covB[p]), cm = min(1, covM[p]), a = max(cb, cm);\n      if (a \u003c= 0 || (S.clip && !win[p])) continue;\n      const o = 3 * p, fr = 0.02 * (1 - cb) + 0.015, fg = 0.008, fbl = 0.03;\n      const lr = lining[0] * (1 - cb), lg = lining[1] * (1 - cb), lb = lining[2] * (1 - cb);\n      buf[o] += (fr + lr - buf[o]) * a;\n      buf[o + 1] += (fg + lg - buf[o + 1]) * a;\n      buf[o + 2] += (fbl + lb - buf[o + 2]) * a;\n    }\n  if (S.eyes) {\n    const glow = 0.6 + 0.4 * sin(S.clock * 3);\n    for (const [ex, ey] of S.eyes) {\n      const x = floor(ex), y = floor(ey);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = 3 * (y * W + x);\n      buf[o] = glow;\n      buf[o + 1] = 0.05 * glow;\n      buf[o + 2] = 0.04 * glow;\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      display.setPixel(x, y, round(cl(buf[o], 0, 1) * 255), round(cl(buf[o + 1], 0, 1) * 255), round(cl(buf[o + 2], 0, 1) * 255));\n    }\n}\n","calabi-yau":"// ===== Patternflow pattern =====\n// Title:   Calabi-Yau Quintic\n// Family:  space\n// Idea:    The complex curve z1^5 + z2^5 = 1, a slice of the quintic Calabi-Yau, built from Andrew Hanson's 25 patches and projected into space, turns slowly on black with each patch in its own colour, so the seams show where the patches join and where five of them fan in to one point.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Calabi-Yau manifolds (Eugenio Calabi, 1954; Shing-Tung Yau, 1977), the Fermat quintic slice drawn after Andrew J. Hanson (1994), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Angle=-45..45, Spread=0..1\n//\n// Knob 1: Hue. Turns every patch round the wheel together. A patch takes its hue from k1, the fifth root of unity in front of z1, and a small shift from k2: at 0 the five k1 families are cyan, violet, rose, orange and green.\n// Knob 2: Speed. At 2 the surface turns once about its upright axis in 24 seconds and nods 18 degrees up and down every 16; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Angle. The projection angle alpha, in degrees from Hanson's 45. The upright axis shows cos(alpha) Im z1 + sin(alpha) Im z2, so at -45 it is Im z1 alone and at 45 Im z2 alone, and the whole surface reshapes as the knob turns.\n// Knob 4: Spread. An exploded view: each patch moves out from the centre along the line to its own middle, stretched 1.8 times up and down and 0.8 times across so the pieces use the panel's height. Whole at 0.06, 25 separate pieces at 1.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, sqrt, sin, cos, atan2, hypot, abs, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Grid of one patch: NU steps across x in [-A, A], NV across y in [0, pi/2].\nconst NU = 24, NV = 12, VU = NU + 1, VV = NV + 1, PV = VU * VV, NP = 25 * PV, A = 1.1;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Hanson's patch (k1, k2) at z = x + iy:\n// z1 = e^(2 pi i k1/5) cosh(z)^(2/5), z2 = e^(2 pi i k2/5) (-i sinh z)^(2/5),\n// principal branches, so z1^5 + z2^5 = cosh^2 z - sinh^2 z = 1.\nfunction point(k1, k2, x, y, out, o) {\n  const cr = Math.cosh(x) * cos(y), ci = Math.sinh(x) * sin(y);\n  const sr = Math.sinh(x) * cos(y), si = Math.cosh(x) * sin(y);\n  // -i sinh z\n  const mr = si, mi = -sr;\n  const r1 = pow(hypot(cr, ci), 0.4), a1 = 0.4 * atan2(ci, cr) + (TAU * k1) / 5;\n  const r2 = pow(hypot(mr, mi), 0.4), a2 = 0.4 * atan2(mi, mr) + (TAU * k2) / 5;\n  out[o] = r1 * cos(a1);\n  out[o + 1] = r1 * sin(a1);\n  out[o + 2] = r2 * cos(a2);\n  out[o + 3] = r2 * sin(a2);\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  const s = {\n    t: 0, yaw: 0.6, hue: 0, alpha: PI / 4, spread: 0.06,\n    // Re z1, Im z1, Re z2, Im z2 for every grid point of every patch.\n    z: F(NP * 4), cen: F(25 * 4),\n    px: F(NP), py: F(NP), pz: F(NP), sx: F(NP), sy: F(NP), nx: F(NP), ny: F(NP), nz: F(NP),\n    zb: F(N), id: new Int16Array(N), wa: F(N), wb: F(N), tv: new Int32Array(N), col: F(N * 3),\n    pal: F(25 * 3), palHue: -1,\n  };\n  // The grid crowds toward x = 0 and toward both ends of y, where the\n  // patches meet at the points z2 = 0 and z1 = 0 and the 2/5 power stretches them.\n  const gx = F(VU), gy = F(VV);\n  for (let i = 0; i \u003c VU; i++) {\n    const u = (2 * i) / NU - 1;\n    gx[i] = A * Math.sign(u) * pow(abs(u), 1.7);\n  }\n  for (let j = 0; j \u003c VV; j++) gy[j] = (PI / 4) * (1 - cos((PI * j) / NV));\n  for (let p = 0; p \u003c 25; p++) {\n    const k1 = (p / 5) | 0, k2 = p % 5;\n    for (let j = 0; j \u003c VV; j++)\n      for (let i = 0; i \u003c VU; i++) {\n        const v = p * PV + j * VU + i;\n        point(k1, k2, gx[i], gy[j], s.z, v * 4);\n        for (let c = 0; c \u003c 4; c++) s.cen[p * 4 + c] += s.z[v * 4 + c] / PV;\n      }\n  }\n  params.s = s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.alpha = ((45 + cl(k[2], -45, 45)) * PI) / 180;\n  s.spread = cl(k[3], 0, 1);\n  s.t += d * sp;\n  s.yaw += d * sp * 0.13;\n}\n\nfunction palette(s) {\n  for (let p = 0; p \u003c 25; p++) {\n    const k1 = (p / 5) | 0, k2 = p % 5;\n    hsv(s.hue + 0.5 + 0.2 * k1 + 0.035 * (k2 - 2), 0.62 + 0.07 * k2, 1, s.pal, p * 3);\n  }\n  s.palHue = s.hue;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  if (s.palHue !== s.hue) palette(s);\n  const { z, cen, px, py, pz, sx, sy, nx, ny, nz, zb, id, wa, wb, tv, col, pal } = s;\n  const ca = cos(s.alpha), sa = sin(s.alpha);\n  // The turn about the upright (projected) axis and a slow nod.\n  const cy = cos(s.yaw), sy0 = sin(s.yaw), el = 0.32 * sin(s.t * 0.19), ce = cos(el), se = sin(el);\n  const sc = 19.5 / (1 + 0.25 * s.spread), CX = 31.5, CY = 64, CAM = 8;\n  const sp = s.spread;\n  for (let p = 0; p \u003c 25; p++) {\n    // The patch's own middle, turned like the rest; the exploded view moves\n    // the patch out along it, 1.8 times as far up and down and 0.8 across.\n    const X = cen[p * 4] * sp, Y = cen[p * 4 + 2] * sp, Z = (ca * cen[p * 4 + 1] + sa * cen[p * 4 + 3]) * sp;\n    const xr = X * cy - Y * sy0, yr = X * sy0 + Y * cy;\n    const ox = xr * 0.8, oz = (yr * se + Z * ce) * 1.8, oy = yr * ce - Z * se;\n    for (let v = p * PV, e = v + PV; v \u003c e; v++) {\n      const X = z[v * 4], Y = z[v * 4 + 2], Z = ca * z[v * 4 + 1] + sa * z[v * 4 + 3];\n      // Yaw about the upright axis, then the nod about the screen's x axis.\n      const xr = X * cy - Y * sy0, yr = X * sy0 + Y * cy;\n      const yy = yr * ce - Z * se + oy, zz = yr * se + Z * ce + oz, xx = xr + ox;\n      px[v] = xx;\n      py[v] = zz;\n      pz[v] = yy;\n      const f = (sc * CAM) / (CAM + yy);\n      sx[v] = CX + f * xx;\n      sy[v] = CY - f * zz;\n    }\n  }\n  // Normals from the grid's neighbours.\n  for (let p = 0; p \u003c 25; p++)\n    for (let j = 0; j \u003c VV; j++)\n      for (let i = 0; i \u003c VU; i++) {\n        const v = p * PV + j * VU + i;\n        const a = i > 0 ? v - 1 : v, b = i \u003c NU ? v + 1 : v, c = j > 0 ? v - VU : v, e = j \u003c NV ? v + VU : v;\n        const ux = px[b] - px[a], uy = py[b] - py[a], uz = pz[b] - pz[a];\n        const wx = px[e] - px[c], wy = py[e] - py[c], wz = pz[e] - pz[c];\n        const qx = uy * wz - uz * wy, qy = uz * wx - ux * wz, qz = ux * wy - uy * wx;\n        const l = 1 / (sqrt(qx * qx + qy * qy + qz * qz) + 1e-12);\n        nx[v] = qx * l;\n        ny[v] = qy * l;\n        nz[v] = qz * l;\n      }\n  zb.fill(1e9);\n  id.fill(-1);\n  for (let p = 0; p \u003c 25; p++)\n    for (let j = 0; j \u003c NV; j++)\n      for (let i = 0; i \u003c NU; i++) {\n        const v = p * PV + j * VU + i;\n        tri(s, v, v + 1, v + VU + 1, p);\n        tri(s, v, v + VU + 1, v + VU, p);\n      }\n  // Shade into col.\n  const LX = -0.5, LY = 0.6, LZ = -0.62, HZ = LZ - 1, HL = 1 / sqrt(LX * LX + LY * LY + HZ * HZ);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, p = id[q], o = q * 3;\n      if (p \u003c 0) {\n        col[o] = col[o + 1] = col[o + 2] = 0;\n        continue;\n      }\n      const t0 = tv[q], a = wa[q], b = wb[q], c = 1 - a - b;\n      const v0 = t0 & 0x3fff, v1 = v0 + ((t0 >> 14) & 0xff), v2 = v0 + ((t0 >> 22) & 0xff);\n      let mx = nx[v0] * c + nx[v1] * a + nx[v2] * b, my = ny[v0] * c + ny[v1] * a + ny[v2] * b, mz = nz[v0] * c + nz[v1] * a + nz[v2] * b;\n      const l = 1 / (sqrt(mx * mx + my * my + mz * mz) + 1e-12);\n      mx *= l;\n      my *= l;\n      mz *= l;\n      // Two-sided: the eye looks along +depth, so a normal is turned to face it.\n      if (mz > 0) (mx = -mx), (my = -my), (mz = -mz);\n      const ld = max(0, mx * LX + my * LY + mz * LZ), hh = max(0, (mx * LX + my * LY + mz * HZ) * HL);\n      const spc = pow(hh, 30) * 0.5;\n      // The far side dims a quarter; light falls off toward an indigo shade\n      // rather than toward black, so a turned-away yellow reads violet, not olive.\n      const fog = 1 - 0.25 * cl((zb[q] + 1.6) / 3.2, 0, 1), lit = (0.1 + 0.9 * ld) * fog, sh = (1 - ld) * 0.22 * fog;\n      const r = pal[p * 3] * lit + 0.35 * sh + spc, g = pal[p * 3 + 1] * lit + 0.12 * sh + spc, bb = pal[p * 3 + 2] * lit + sh + spc;\n      // Seams: an LED beside another patch, joined to it or passing in front, is dimmed.\n      const rp = x \u003c W - 1 ? id[q + 1] : p, dp = y \u003c H - 1 ? id[q + W] : p;\n      const k = (rp >= 0 && rp !== p) || (dp >= 0 && dp !== p) ? 127 : 255;\n      col[o] = min(255, r * k);\n      col[o + 1] = min(255, g * k);\n      col[o + 2] = min(255, bb * k);\n    }\n  // An empty LED on the outline takes a third of its lit neighbours'\n  // light, which softens the stairs of the edge against black.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3;\n      if (id[q] >= 0) {\n        display.setPixel(x, y, col[o], col[o + 1], col[o + 2]);\n        continue;\n      }\n      let r = 0, g = 0, b = 0;\n      for (const n of [x > 0 ? q - 1 : -1, x \u003c W - 1 ? q + 1 : -1, y > 0 ? q - W : -1, y \u003c H - 1 ? q + W : -1])\n        if (n >= 0 && id[n] >= 0) (r += col[n * 3]), (g += col[n * 3 + 1]), (b += col[n * 3 + 2]);\n      display.setPixel(x, y, r * 0.09, g * 0.09, b * 0.09);\n    }\n}\n\n// One triangle into the depth buffer, keeping the barycentric weights of\n// the nearest surface at each LED centre.\nfunction tri(s, i0, i1, i2, p) {\n  const { sx, sy, pz, zb, id, wa, wb, tv } = s;\n  const x0 = sx[i0], y0 = sy[i0], x1 = sx[i1], y1 = sy[i1], x2 = sx[i2], y2 = sy[i2];\n  const den = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(den) \u003c 1e-9) return;\n  const inv = 1 / den;\n  let xa = min(x0, x1, x2), xb = max(x0, x1, x2), ya = min(y0, y1, y2), yb = max(y0, y1, y2);\n  const X0 = max(0, Math.ceil(xa - 0.5)), X1 = min(W - 1, floor(xb - 0.5)), Y0 = max(0, Math.ceil(ya - 0.5)), Y1 = min(H - 1, floor(yb - 0.5));\n  if (X0 > X1 || Y0 > Y1) return;\n  const z0 = pz[i0], z1 = pz[i1], z2 = pz[i2];\n  const pack = i0 | ((i1 - i0) \u003c\u003c 14) | ((i2 - i0) \u003c\u003c 22);\n  for (let y = Y0; y \u003c= Y1; y++) {\n    const cy = y + 0.5 - y0;\n    for (let x = X0; x \u003c= X1; x++) {\n      const cx = x + 0.5 - x0;\n      const a = (cx * (y2 - y0) - cy * (x2 - x0)) * inv, b = ((x1 - x0) * cy - (y1 - y0) * cx) * inv;\n      if (a \u003c -1e-6 || b \u003c -1e-6 || a + b > 1 + 1e-6) continue;\n      const d = z0 + (z1 - z0) * a + (z2 - z0) * b, q = y * W + x;\n      if (d \u003c zb[q]) (zb[q] = d), (id[q] = p), (wa[q] = a), (wb[q] = b), (tv[q] = pack);\n    }\n  }\n}\n","grimoire":"// ===== Patternflow pattern =====\n// Title:   Grimoire\n// Family:  halloween\n// Idea:    A spellbook lies open on a lectern in a dark tower room beside a flickering candle, and a ghostly draft turns its pages by itself, each sheet lifting and curling over, catching the candle light before it lands; on every new spread a toxic-green sigil draws itself stroke by stroke, then its glyphs peel off the page one by one and rise up the dark as green sparks and wisps that fade near the top.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Glow=0..1\n//\n// Knob 1: Hue. The colour of the magic, round the whole wheel: toxic green at 0, sky blue at 0.25, violet at 0.5, ember orange at 0.75 and green again at 1. The dark of the room moves from purple at 0 through indigo to deep teal at 1. The candle and the paper stay warm.\n// Knob 2: Speed. At 2 the first page lifts at 0.5 s, a slow page takes 1.6 seconds to cross, a sigil draws in 1.4 seconds and burns for 2.6 while its glyphs rise; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Wind. At 0 one slow page turns every 7.8 seconds and the candle stands nearly straight; at 1 the draft riffles seven pages over in 1.1 seconds every 5.9 seconds and lifts the free edge of the next page while it waits. The flame leans and gutters with the draft, and the rising glyphs drift right.\n// Knob 4: Glow. How bright the sigil burns: at 0 a thin line and a dim green light on the pages, at the opening 0.06 a little more. At 1 the sigil blazes and lights the room green, throwing four times the sparks, and every rising glyph trails a thick wisp.\n// Buttons: K1 tap sends a gust that riffles pages now.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The book in its own frame: x across the spread from the gutter (a page\n// is PW wide), y down the page from its middle (PH tall), z up off the\n// paper. The lectern tilts it toward us; the eye looks down at it.\nconst GX = 32, YC = 87, PW = 27, PH = 44, CA = cos(0.92), SA = sin(0.92);\n// The rise of the paper out of the gutter.\nconst zp = (x) => 2.4 * (1 - (1 - min(1, abs(x) / 12)) ** 2);\n// Book frame to the panel, with a little perspective: the near edge is wider.\nfunction proj(x, y, z, out) {\n  const k = 1 + 0.005 * (y * SA + z * CA);\n  // Seen a little from the right, so a standing sheet is not edge on.\n  out[0] = GX + (x + 0.3 * z) * k;\n  out[1] = YC + (y * CA - z * SA) * k;\n  out[2] = y * SA + z * CA;\n}\n// The candle: its flame on the panel and in the book frame.\nconst FX = 9, FY = 53, CANDLE = [-25, -27, 22];\n// The sigil hovers flat at ZS over the paper; its middle on the panel.\nconst ZS = 3, SGX = GX + 0.3 * ZS, SGY = YC - ZS * SA;\n\n// Light from the candle on a surface with normal n at book point p.\nfunction lambert(px, py, pz, nx, ny, nz) {\n  let lx = CANDLE[0] - px, ly = CANDLE[1] - py, lz = CANDLE[2] - pz;\n  const d = sqrt(lx * lx + ly * ly + lz * lz);\n  return max(0, (lx * nx + ly * ny + lz * nz) / d) / (1 + (d * d) / 2500);\n}\n\n// Ink on a page: lines of words with margins, laid out by the page's\n// number. u runs from the gutter out, v down the page, both 0..1.\nfunction ink(page, u, v) {\n  if (u \u003c 0.12 || u > 0.9 || v \u003c 0.08 || v > 0.93) return 0;\n  const yy = v * PH, line = floor(yy / 3.4);\n  if (yy - line * 3.4 > 1.3) return 0;\n  const sd = page * 131 + line * 17, xx = u * PW;\n  // A short last line now and then, and a blank line between paragraphs.\n  if (hash(sd) \u003c 0.12 || xx > PW * (0.9 - (hash(sd + 1) \u003c 0.25 ? 0.5 * hash(sd + 2) : 0))) return 0;\n  const word = floor(xx / 3.2 + hash(sd + 3) * 3);\n  return (xx / 3.2 + hash(sd + 3) * 3) % 1 \u003c 0.78 - 0.25 * hash(sd + word) ? 1 : 0;\n}\nconst PAPER = [1, 0.82, 0.56], INKC = [0.5, 0.31, 0.22];\n\n// Where every LED of the lying spread is on the paper, found once by\n// scattering fine samples: page x and y, how much of the LED is paper, and\n// the candle light on it.\nconst SPX = new Float32Array(N), SPY = new Float32Array(N), SPC = new Float32Array(N), SPL = new Float32Array(N);\n{\n  const o = [0, 0, 0], n = new Float32Array(N);\n  for (let x = -PW + 0.15; x \u003c PW; x += 0.3)\n    for (let y = -PH / 2 + 0.15; y \u003c PH / 2; y += 0.3) {\n      proj(x, y, zp(x), o);\n      const p = floor(o[1]) * W + floor(o[0]);\n      SPX[p] += x;\n      SPY[p] += y;\n      n[p]++;\n    }\n  for (let p = 0; p \u003c N; p++)\n    if (n[p]) {\n      (SPX[p] /= n[p]), (SPY[p] /= n[p]);\n      SPC[p] = min(1, n[p] / 9);\n      const x = SPX[p], s = (zp(x + 0.1) - zp(x - 0.1)) / 0.2, l = sqrt(1 + s * s);\n      // Darker into the gutter, where the paper turns away and down.\n      SPL[p] = lambert(x, SPY[p], zp(x), -s / l, 0, 1 / l) * (0.55 + 0.45 * min(1, abs(x) / 5));\n    }\n}\n\n// The room, the lectern, the book's cover and the candle's wax, as an\n// unlit colour and how much candle light each LED takes, built per Hue.\nconst WALL = 0, WOOD = 1, COVER = 2, WAX = 3, EDGE = 4;\nconst KIND = new Uint8Array(N), CLF = new Float32Array(N), GLF = new Float32Array(N);\n{\n  const o = [0, 0, 0], cov = new Uint8Array(N);\n  // The cover: the pages' outline grown by 1.6 and pushed 2 down.\n  for (let x = -PW - 1.6; x \u003c PW + 1.6; x += 0.3)\n    for (let y = -PH / 2 - 1.6; y \u003c PH / 2 + 1.6; y += 0.3) {\n      proj(x, y, -1.2, o);\n      cov[floor(o[1]) * W + floor(o[0])] = 1;\n    }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), dx = x + 0.5 - FX, dy = y + 0.5 - FY;\n    let k = WALL;\n    // The lectern: the slanted board under the book, its front edge, a\n    // turned post and a foot.\n    const post = abs(x + 0.5 - GX) \u003c 4.5 - 1.6 * sin(((y - 104) / 6) * PI) ** 2 && y >= 104;\n    if ((y >= 98 && y \u003c 104 && abs(x + 0.5 - GX) \u003c 29 - (y - 98) * 0.5) || post || (y >= 121 && abs(x + 0.5 - GX) \u003c 16 - (y - 121) * 0.3)) k = WOOD;\n    if (y === 103 && k === WOOD) k = EDGE;\n    if (cov[p] || SPC[p] > 0) k = COVER;\n    // The candle stands behind the book's top left corner.\n    if (abs(x + 0.5 - FX) \u003c 1.8 && y >= FY + 4 && y \u003c 74 && !cov[p] && !SPC[p]) k = WAX;\n    KIND[p] = k;\n    const r = sqrt(dx * dx + dy * dy);\n    CLF[p] = k === WAX ? 0.9 - (y - FY - 4) * 0.035 : 1 / (1 + (r * r) / (k === WALL ? 200 : 380)) * (k === WOOD && x \u003c GX ? 1.3 : 1);\n    // The sigil's light: strong on the spread, rising up the wall above it.\n    const gx = (x + 0.5 - SGX) / 34, gy = (y + 0.5 - SGY) / (y \u003c SGY ? 46 : 18);\n    GLF[p] = exp(-(gx * gx + gy * gy) * 2);\n  }\n}\nfunction scene(S) {\n  const room = hsv(0.78 - 0.3 * S.hue, 0.7, 1), A = S.amb, L = S.lit;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), k = KIND[p];\n    let a, l;\n    if (k === WALL) {\n      // Rough stone blocks of uneven length, the dark gathering toward the top.\n      const row = floor(y / 7);\n      let bx = -floor(hash(row) * 9), i = 0;\n      while (bx + 7 + floor(hash(row * 31 + i) * 7) \u003c= x) bx += 7 + floor(hash(row * 31 + i++) * 7);\n      const mortar = y % 7 === 0 || x === bx, v = (mortar ? 0.55 : 0.8 + 0.2 * hash(row * 53 + i)) * (0.6 + 0.4 * min(1, y / 80));\n      a = room.map((c) => c * 0.19 * v);\n      l = [(0.72 + 0.1 * room[0]) * v, (0.42 + 0.1 * room[1]) * v, (0.24 + 0.1 * room[2]) * v];\n    } else if (k === WOOD || k === EDGE) {\n      const grain = 0.85 + 0.15 * sin(x * 0.7 + y * 0.2);\n      a = [0.09 * grain, 0.035, 0.08 * grain];\n      l = k === EDGE ? [0.85, 0.5, 0.25] : [0.5 * grain, 0.24 * grain, 0.14];\n    } else if (k === COVER) {\n      a = [0.09, 0.02, 0.1];\n      l = [0.42, 0.14, 0.2];\n    } else {\n      a = [0.12, 0.1, 0.08];\n      l = [1, 0.85, 0.6];\n    }\n    for (let c = 0; c \u003c 3; c++) (A[3 * p + c] = a[c]), (L[3 * p + c] = l[c] * CLF[p]);\n  }\n}\n\n// Tiny invented glyphs, 3x3, row by row from the top left.\nconst GLYPH = [0b111010010, 0b101010101, 0b110011001, 0b010101010, 0b111101001, 0b100111001, 0b011100011, 0b101111101, 0b110010011, 0b001010111, 0b010111100, 0b111001110];\n\n// A new sigil: an outer ring, a ring of glyphs, an inner ring, a polygon or\n// star in it and a small eye in the middle, as strokes in book coordinates\n// drawn in that order. Each stroke is a list of points; glyphs are points.\nfunction sigil(seed) {\n  const r = (i) => hash(seed * 97 + i), circle = (R, a0) => {\n    const pts = [];\n    for (let i = 0; i \u003c= 64; i++) pts.push([R * cos(a0 + (TAU * i) / 64), R * sin(a0 + (TAU * i) / 64)]);\n    return pts;\n  };\n  const a0 = r(1) * TAU, forms = [[3, 1], [4, 1], [7, 2], [7, 3], [8, 3], [5, 1], [6, 1], [9, 4]], [n, m] = forms[floor(r(2) * 8)];\n  const star = [];\n  for (let i = 0; i \u003c= n; i++) star.push([12.5 * cos(a0 + (TAU * i * m) / n), 12.5 * sin(a0 + (TAU * i * m) / n)]);\n  const ng = 8 + floor(r(3) * 4), glyphs = [];\n  for (let i = 0; i \u003c ng; i++) glyphs.push({ x: 16.5 * cos(a0 + (TAU * i) / ng), y: 16.5 * sin(a0 + (TAU * i) / ng), g: floor(r(10 + i) * GLYPH.length), gone: false });\n  const strokes = [circle(20.5, a0), null, circle(13.5, a0 + PI), star, circle(3, 0)];\n  // Lengths, so the pen can run along them at one speed; the glyph ring\n  // counts as one more stroke, a glyph every 4 units.\n  const len = strokes.map((s) => {\n    if (!s) return ng * 4;\n    let l = 0;\n    for (let i = 1; i \u003c s.length; i++) l += Math.hypot(s[i][0] - s[i - 1][0], s[i][1] - s[i - 1][1]);\n    return l;\n  });\n  return { strokes, glyphs, len, total: len.reduce((a, b) => a + b, 0) };\n}\n\nexport function setup(params) {\n  params.s = {\n    fresh: true, t: 0, hue: 0, speed: 2, wind: 0, glow: 0.06, key: \"\", prevBtn: false,\n    phase: \"turn\", pt: -0.5, pages: [], page: 0, leftPage: -1, sg: sigil(1), sgA: 0, draw: 1, flick: 1, lean: 0,\n    risers: [], sparks: [], amb: new Float32Array(N * 3), lit: new Float32Array(N * 3),\n    buf: new Float32Array(N * 3), zb: new Float32Array(N), mg: new Float32Array(N), ws: new Float32Array(N), o: [0, 0, 0],\n  };\n}\n\n// The pages that turn at once: one slow sheet in a calm, a riffle in a gale.\nfunction startTurn(S, gust) {\n  const w = gust ? max(S.wind, 0.6) : S.wind, n = 1 + round(6 * w * w), dur = 1.6 - 1.1 * w, gap = dur * (0.32 - 0.12 * w);\n  S.pages = [];\n  for (let i = 0; i \u003c n; i++) S.pages.push({ start: i * gap, dur, num: S.page + i });\n  S.page += n;\n  S.phase = \"turn\";\n  S.pt = 0;\n}\n\n// A glyph leaves the page and rises.\nfunction rise(S, x, y, g) {\n  S.risers.push({ x, y, vx: (Math.random() - 0.5) * 4, vy: -11 - 7 * Math.random(), g, age: 0, ph: Math.random() * TAU });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.glow = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  if (S.fresh) {\n    // The night is already going: the last sigil's glyphs are on their way\n    // up and its light is dying on the page.\n    S.fresh = false;\n    for (let i = 0, n = 7 + round(5 * S.glow); i \u003c n; i++) {\n      rise(S, SGX + (Math.random() - 0.5) * 34, SGY - 4 - Math.random() * 8, floor(Math.random() * GLYPH.length));\n      const r = S.risers[i], a = 0.4 + 2.6 * Math.random();\n      for (let s = 0; s \u003c a; s += 0.05) step(S, r, 0.05);\n    }\n    S.sgA = 1;\n    for (const g of S.sg.glyphs) g.gone = true;\n    S.pages = [{ start: 0, dur: 1.6 - 1.1 * S.wind, num: 0 }];\n    S.page = 1;\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.prevBtn && !(S.phase === \"turn\" && S.pt \u003c 0.3)) {\n    for (const g of S.sg.glyphs) if (!g.gone && S.phase !== \"turn\") (g.gone = true), rise(S, ...glyphAt(S, g));\n    startTurn(S, true);\n  }\n  S.prevBtn = btn;\n  S.pt += ds;\n  // The story: turn the pages, draw the sigil, burn it and let it fade, rest, then turn again.\n  if (S.phase === \"turn\") {\n    S.sgA = max(0, S.sgA - ds * 1.3);\n    for (const p of S.pages) if (S.pt > p.start + p.dur) S.leftPage = max(S.leftPage, p.num * 2 + 1);\n    if (S.pages.every((p) => S.pt > p.start + p.dur)) (S.phase = \"draw\"), (S.pt = 0), (S.draw = 0), (S.sg = sigil(S.page * 7 + 3)), (S.sgA = 1), (S.pages = []);\n  } else if (S.phase === \"draw\") {\n    S.draw = min(1, S.pt / 1.4);\n    if (S.pt > 1.4) (S.phase = \"burn\"), (S.pt = 0);\n  } else if (S.phase === \"burn\") {\n    // The glyphs peel off one by one round the ring.\n    const gs = S.sg.glyphs;\n    gs.forEach((g, i) => {\n      if (!g.gone && S.pt > 0.3 + (2 * i) / gs.length) (g.gone = true), rise(S, ...glyphAt(S, g));\n    });\n    if (S.pt > 2.6) (S.phase = \"fade\"), (S.pt = 0);\n  } else if (S.phase === \"fade\") {\n    S.sgA = 1 - S.pt / 0.6;\n    if (S.pt > 0.6) (S.phase = \"rest\"), (S.pt = 0), (S.sgA = 0);\n  } else if (S.pt > 1.6 - 1.4 * S.wind) startTurn(S, false);\n  // Sparks fly off a burning sigil and off the pen.\n  const burning = S.phase === \"burn\" ? 1 : S.phase === \"draw\" ? 0.5 : 0;\n  const want = burning * ds * (10 + 30 * S.glow);\n  for (let i = 0, n = floor(want) + (Math.random() \u003c want % 1 ? 1 : 0); i \u003c n; i++) {\n    const a = Math.random() * TAU, r = Math.random() \u003c 0.5 ? 20.5 : 13.5;\n    proj(r * cos(a), r * sin(a), ZS, S.o);\n    S.sparks.push({ x: S.o[0], y: S.o[1], vx: (Math.random() - 0.5) * 6, vy: -18 - 14 * Math.random(), age: 0, life: 0.6 + Math.random() });\n  }\n  for (const r of S.risers) step(S, r, ds);\n  S.risers = S.risers.filter((r) => r.y > -4);\n  for (const s of S.sparks) (s.x += (s.vx + 10 * S.wind) * ds), (s.y += s.vy * ds), (s.age += ds);\n  S.sparks = S.sparks.filter((s) => s.age \u003c s.life);\n  // The flame: flicker and the draft's lean.\n  // The draft bows the flame and makes it gutter.\n  S.flick = 0.84 - 0.24 * S.wind + (0.08 + 0.12 * S.wind) * sin(S.t * 13) + 0.06 * sin(S.t * 31 + 1) + 0.05 * (Math.random() - 0.5);\n  S.lean = S.wind * (1.6 + 0.8 * sin(S.t * 3.1)) + 0.4 * sin(S.t * 2.3);\n  // The wisps fade.\n  const f = exp(-ds / 0.55);\n  for (let p = 0; p \u003c N; p++) S.ws[p] *= f;\n}\n\n// A rising glyph: up with a sway, drifting with the wind, leaving a wisp.\nfunction step(S, r, ds) {\n  r.age += ds;\n  r.vy *= 1 - 0.15 * ds;\n  r.x += (r.vx + 5 * sin(r.age * 2.2 + r.ph) + 12 * S.wind) * ds;\n  r.y += r.vy * ds;\n  const x = floor(r.x), y = floor(r.y) + 2;\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) S.ws[y * W + x] = min(1.4, S.ws[y * W + x] + (0.25 + 0.5 * S.glow) * ds * 8);\n}\n\n// Where a glyph of the sigil sits on the panel, and which it is.\nfunction glyphAt(S, g) {\n  proj(g.x, g.y, ZS, S.o);\n  return [S.o[0], S.o[1], g.g];\n}\n\n// One turning sheet as fine samples: its section bends from the gutter\n// (angle th0) to the free edge (th1), lifting off the right-hand pile and\n// landing on the left. The face toward us shows text and takes the candle\n// light; a glint runs across it as it faces the flame.\nfunction sheet(S, pg, u) {\n  const { buf, zb, o } = S;\n  const th0 = PI * ease(u), bend = 0.8 * sin(TAU * u) + 0.25 * S.wind * sin(S.t * 9) * sin(PI * u);\n  const th1 = cl(th0 + bend, 0.03, PI - 0.03), lift = 1 - sin(PI * u);\n  let x = 0, z = 0;\n  const NS = 54, ds = PW / NS;\n  for (let i = 0; i \u003c NS; i++) {\n    const s = (i + 0.5) / NS, th = th0 + (th1 - th0) * s ** 1.6, c = cos(th), sn = sin(th);\n    x += c * ds;\n    z += sn * ds;\n    const zz = z + zp(x) * lift + 0.3, front = th \u003c PI / 2;\n    // Normal of the face we see, and its light.\n    const nx = front ? -sn : sn, nz = front ? c : -c;\n    const li = lambert(x, 0, zz, nx, 0, nz), glint = li > 0 ? max(0, nx * -0.55 + nz * 0.83) ** 24 : 0;\n    const lv = 0.38 + 1.6 * li * S.flick;\n    const side = front ? pg.num * 2 : pg.num * 2 + 1, uu = s;\n    for (let y = -PH / 2 + 0.25; y \u003c PH / 2; y += 0.5) {\n      proj(x, y, zz, o);\n      const px = floor(o[0]), py = floor(o[1]);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px;\n      if (o[2] \u003c zb[p]) continue;\n      zb[p] = o[2];\n      const k = ink(side, uu, (y + PH / 2) / PH), edge = s > 0.97 || abs(y) > PH / 2 - 0.6 ? 0.8 : 1;\n      for (let ch = 0; ch \u003c 3; ch++) buf[3 * p + ch] = (k ? INKC[ch] : PAPER[ch]) * min(1.15, lv) * edge + glint * 0.45;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.hue.toFixed(3);\n  if (key !== S.key) (S.key = key), scene(S);\n  const { buf, amb, lit, mg, ws, zb, sg, o } = S, fl = S.flick, mc = hsv(0.3 + S.hue, 0.8, 1);\n  const burn = S.sgA * (S.phase === \"burn\" ? 1 + 0.25 * sin(S.t * 17) : S.phase === \"draw\" ? 0.6 + 0.4 * S.draw : 0.8);\n  const gl = burn * (0.08 + 0.92 * S.glow);\n  // Room, lectern, cover and candle wax, lit by the flame and the sigil.\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3)\n    for (let c = 0; c \u003c 3; c++) buf[q + c] = amb[q + c] + lit[q + c] * fl + mc[c] * GLF[p] * gl * 0.8;\n  // The lying spread: the left page shows the back of the last sheet that\n  // turned, the right one the next sheet.\n  const left = S.leftPage, right = S.page * 2;\n  for (let p = 0; p \u003c N; p++) {\n    const cv = SPC[p];\n    if (!cv) continue;\n    const x = SPX[p], pg = x \u003c 0 ? left : right;\n    const k = ink(pg, abs(x) / PW, (SPY[p] + PH / 2) / PH), lv = 0.22 + 1.7 * SPL[p] * fl, q = 3 * p;\n    for (let c = 0; c \u003c 3; c++) {\n      const v = (k ? INKC[c] : PAPER[c]) * lv + mc[c] * GLF[p] * gl * 0.6;\n      buf[q + c] += (v - buf[q + c]) * cv;\n    }\n  }\n  // The next sheet flutters in the draft, under the hovering sigil.\n  zb.fill(-1e9);\n  if (S.wind > 0.05 && S.phase !== \"turn\") sheet(S, { num: S.page }, 0.05 * S.wind * (0.7 + 0.3 * sin(S.t * 7) * sin(S.t * 2.9)));\n  // The sigil: strokes up to where the pen is, each LED a bright line with a glow.\n  mg.fill(0);\n  if (S.sgA > 0) {\n    let budget = (S.phase === \"draw\" ? S.draw : 1) * sg.total, pen = null;\n    sg.strokes.forEach((st, si) => {\n      if (budget \u003c= 0) return;\n      if (!st) {\n        sg.glyphs.forEach((g, i) => {\n          if (budget > i * 4 && !g.gone) {\n            const [gx, gy, gi] = glyphAt(S, g);\n            for (let b = 0; b \u003c 9; b++) if ((GLYPH[gi] >> (8 - b)) & 1) put(mg, floor(gx) - 1 + (b % 3), floor(gy) - 1 + floor(b / 3), 1);\n          }\n        });\n        budget -= sg.len[si];\n        return;\n      }\n      let l = 0;\n      for (let i = 1; i \u003c st.length && l \u003c budget; i++) {\n        const [ax, ay] = st[i - 1], [bx, by] = st[i], sl = Math.hypot(bx - ax, by - ay);\n        for (let f = 0; f \u003c sl && l + f \u003c budget; f += 0.45) {\n          const x = ax + ((bx - ax) * f) / sl, y = ay + ((by - ay) * f) / sl;\n          proj(x, y, ZS, o);\n          put(mg, floor(o[0]), floor(o[1]), 1);\n          pen = [o[0], o[1]];\n        }\n        l += sl;\n      }\n      budget -= sg.len[si];\n    });\n    const a = S.sgA * (0.55 + 0.45 * S.glow), core = [0.3 + 0.7 * mc[0], 0.3 + 0.7 * mc[1], 0.3 + 0.7 * mc[2]];\n    for (let y = 60; y \u003c 104; y++)\n      for (let x = 1; x \u003c W - 1; x++) {\n        const p = y * W + x, m = mg[p], h = (mg[p - 1] + mg[p + 1] + mg[p - W] + mg[p + W]) * 0.25 + (mg[p - W - 1] + mg[p - W + 1] + mg[p + W - 1] + mg[p + W + 1]) * 0.12;\n        if (!m && !h) continue;\n        for (let c = 0; c \u003c 3; c++) {\n          const q = 3 * p + c;\n          buf[q] = m ? buf[q] + (core[c] * min(1, burn + 0.2) - buf[q]) * min(1, a * 1.6) : buf[q] + mc[c] * h * a * 0.6;\n        }\n      }\n    // The pen: a white-hot point where the line is being drawn.\n    if (pen && S.phase === \"draw\") glow(buf, pen[0], pen[1], [1, 1, 0.9], 1.8, 1);\n  }\n  // Turning sheets, over the spread and its sigil.\n  zb.fill(-1e9);\n  for (const pg of S.pages) {\n    const u = (S.pt - pg.start) / pg.dur;\n    if (u > 0 && u \u003c 1) sheet(S, pg, u);\n  }\n  // The candle flame, leaning with the draft, and its halo.\n  const lean = S.lean, fh = 6 + 1.2 * sin(S.t * 9) + 0.6 * (fl - 0.82) * 5;\n  for (let y = floor(FY - fh - 1); y \u003c= FY + 4; y++)\n    for (let x = FX - 5; x \u003c= FX + 5; x++) {\n      const v = (FY + 3.5 - (y + 0.5)) / (fh + 3.5);\n      if (v \u003c 0 || v > 1 || x \u003c 0) continue;\n      const cx = FX + lean * v * v, wdt = 1.9 * sin(PI * (0.15 + 0.85 * v) ** 0.8) * (1 - v * 0.6), dx = abs(x + 0.5 - cx);\n      if (dx > wdt + 0.5) continue;\n      const a = cl(wdt + 0.5 - dx, 0, 1), hot = 1 - v, q = 3 * (y * W + x), col = [1, 0.45 + 0.5 * hot, 0.1 + 0.6 * hot * hot];\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += (col[c] * fl * 1.15 - buf[q + c]) * a;\n    }\n  glow(buf, FX + lean * 0.5, FY - 2, [1, 0.5, 0.15], 9, 0.28 * fl);\n  // Wisps, rising glyphs and sparks in the colour of the magic.\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    const w = ws[p];\n    if (w > 0.01) {\n      const a = min(1, w) * (0.3 + 0.3 * S.glow) * min(1, floor(p / W) / 30);\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += mc[c] * a;\n    }\n  }\n  for (const r of S.risers) {\n    const a = min(1, r.age / 0.2) * cl((r.y - 4) / 34, 0, 1), x0 = floor(r.x) - 1, y0 = floor(r.y) - 1, gb = GLYPH[r.g];\n    for (let b = 0; b \u003c 9; b++) {\n      const x = x0 + (b % 3), y = y0 + floor(b / 3);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = 3 * (y * W + x), on = (gb >> (8 - b)) & 1 ? a : a * 0.25;\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += ((0.35 + 0.65 * mc[c]) * 1.1 - buf[q + c]) * on;\n    }\n  }\n  for (const s of S.sparks) {\n    const x = floor(s.x), y = floor(s.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const a = (1 - s.age / s.life) * (0.6 + 0.4 * sin(s.age * 40)), q = 3 * (y * W + x);\n    for (let c = 0; c \u003c 3; c++) buf[q + c] += (0.5 + 0.5 * mc[c]) * a;\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, min(255, round(buf[q] * 255)), min(255, round(buf[q + 1] * 255)), min(255, round(buf[q + 2] * 255)));\n}\n\nfunction put(mg, x, y, v) {\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) mg[y * W + x] = v;\n}\n// A round soft light added at (x, y).\nfunction glow(buf, gx, gy, col, r, a) {\n  for (let y = max(0, floor(gy - 2 * r)); y \u003c min(H, gy + 2 * r); y++)\n    for (let x = max(0, floor(gx - 2 * r)); x \u003c min(W, gx + 2 * r); x++) {\n      const dx = x + 0.5 - gx, dy = y + 0.5 - gy, f = a * exp(-(dx * dx + dy * dy) / (r * r)), q = 3 * (y * W + x);\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += col[c] * f;\n    }\n}\n","hat-monotile":"// ===== Patternflow pattern =====\n// Title:   Hat Monotile\n// Family:  cells\n// Idea:    The panel fills with copies of one 13-sided tile, the hat, cluster by cluster in the order its metatile substitution nests them, coloured by the metatile each hat belongs to with the rare mirrored hats in orange, and while the window drifts across a patch of 7,921 hats that never repeats, waves of colour regroup the same hats into the bigger clusters of the next two levels.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hat, an aperiodic monotile (David Smith, Joseph Samuel Myers, Craig S. Kaplan and Chaim Goodman-Strauss, 2023), built by its H/T/P/F metatile substitution as in Kaplan's hatviz (reimplemented), with the paper's continuous family Tile(a, b), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=9..16, Shape=-1..1\n//\n// Knob 1: Hue. Turns the five label colours round the wheel together. At 0 the H hats are blue, the mirrored H1 hats orange, T yellow, P magenta and F green.\n// Knob 2: Speed. At 2 the panel fills in 1.6 seconds and the window drifts 2.5 LEDs a second. A cycle takes 36 seconds: the colours regroup at 11 and 17 seconds and fall back at 23, and from 34.4 the panel clears to build again at 36; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Size. How many LEDs across one hat is, from 9 to 16. At 9 about 220 hats share the panel, at 16 about 70.\n// Knob 4: Shape. Re-measures every edge of the same tiling with two lengths, a for the edges along the hexagon sides and b for the others, as Tile(a, b) of the paper: at -1 the comet Tile(1, 0), at -0.5 the turtle Tile(sqrt 3, 1), at -0.25 Tile(1, 1), from 0 to 0.12 the hat Tile(1, sqrt 3) itself, at 1 the chevron Tile(0, 1).\n// Buttons: K1 tap clears the panel cluster by cluster and builds it again.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, min, max, round, sin, cos, atan2, sqrt, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\n\n// The substitution. This is Craig Kaplan's hatviz construction, rewritten:\n// four metatiles H, T, P and F, each a polygon holding hats (H four, one of\n// them mirrored, T one, P and F two), are glued into a patch by a fixed list\n// of rules and the patch is cut into the four metatiles of the next level.\n// Transforms are affine maps [a, b, c, d, e, f]: x' = a x + b y + c, y' = d x + e y + f.\nconst R3 = sqrt(3) / 2;\nconst pt = (x, y) => ({ x, y });\nconst hexPt = (x, y) => pt(x + 0.5 * y, R3 * y);\nconst ID = [1, 0, 0, 0, 1, 0];\nconst mul = (A, B) => [A[0] * B[0] + A[1] * B[3], A[0] * B[1] + A[1] * B[4], A[0] * B[2] + A[1] * B[5] + A[2], A[3] * B[0] + A[4] * B[3], A[3] * B[1] + A[4] * B[4], A[3] * B[2] + A[4] * B[5] + A[5]];\nfunction inv(T) {\n  const d = T[0] * T[4] - T[1] * T[3];\n  return [T[4] / d, -T[1] / d, (T[1] * T[5] - T[2] * T[4]) / d, -T[3] / d, T[0] / d, (T[2] * T[3] - T[0] * T[5]) / d];\n}\nconst add = (p, q) => pt(p.x + q.x, p.y + q.y), sub = (p, q) => pt(p.x - q.x, p.y - q.y);\nconst move = (x, y) => [1, 0, x, 0, 1, y];\nconst turnAbout = (p, a) => mul(move(p.x, p.y), mul([cos(a), -sin(a), 0, sin(a), cos(a), 0], move(-p.x, -p.y)));\nconst apply = (M, p) => pt(M[0] * p.x + M[1] * p.y + M[2], M[3] * p.x + M[4] * p.y + M[5]);\n// The similarity taking segment p1 q1 onto segment p2 q2.\nconst seg = (p, q) => [q.x - p.x, p.y - q.y, p.x, q.y - p.y, q.x - p.x, p.y];\nconst match = (p1, q1, p2, q2) => mul(seg(p2, q2), inv(seg(p1, q1)));\nfunction cross(p1, q1, p2, q2) {\n  const d = (q2.y - p2.y) * (q1.x - p1.x) - (q2.x - p2.x) * (q1.y - p1.y);\n  const u = ((q2.x - p2.x) * (p1.y - p2.y) - (q2.y - p2.y) * (p1.x - p2.x)) / d;\n  return pt(p1.x + u * (q1.x - p1.x), p1.y + u * (q1.y - p1.y));\n}\n// The hat on the triangular lattice, eight kites of a hexagon grid. The\n// midpoint of its one long edge is kept as a vertex, so the outline has 14\n// corners and every edge is one of two kinds.\nconst HAT = [[0, 0], [-1, -1], [0, -2], [1, -2], [2, -2], [2, -1], [4, -2], [5, -1], [4, 0], [3, 0], [2, 2], [0, 3], [0, 2], [-1, 2]].map(([a, b]) => hexPt(a, b));\nconst NV = 14;\n// Edge kind: 0 for a unit edge along a hexagon side (length a), 1 for a\n// sqrt 3 edge from a hexagon's centre to the middle of a side (length b).\nconst KIND = HAT.map((p, i) => (abs1(sub(HAT[(i + 1) % NV], p)) \u003c 1.01 ? 0 : 1));\nfunction abs1(p) {\n  return sqrt(p.x * p.x + p.y * p.y);\n}\n// Hat labels: 0 H, 1 H1 (the mirrored one), 2 T, 3 P, 4 F.\nconst hat = (label) => ({ hat: true, label });\nconst meta = (shape, label) => ({ shape, label, kids: [] });\nconst kid = (m, T, g) => m.kids.push({ T, g });\nconst at = (m, n, i) => apply(m.kids[n].T, m.kids[n].g.shape[i]);\nfunction recentre(m) {\n  let cx = 0, cy = 0;\n  for (const p of m.shape) (cx += p.x), (cy += p.y);\n  (cx /= m.shape.length), (cy /= m.shape.length);\n  m.shape = m.shape.map((p) => pt(p.x - cx, p.y - cy));\n  for (const k of m.kids) k.T = mul(move(-cx, -cy), k.T);\n}\nfunction first() {\n  const Ho = [pt(0, 0), pt(4, 0), pt(4.5, R3), pt(2.5, 5 * R3), pt(1.5, 5 * R3), pt(-0.5, R3)];\n  const h = meta(Ho, 0), t = meta([pt(0, 0), pt(3, 0), pt(1.5, 3 * R3)], 2);\n  const p = meta([pt(0, 0), pt(4, 0), pt(3, 2 * R3), pt(-1, 2 * R3)], 3);\n  const f = meta([pt(0, 0), pt(3, 0), pt(3.5, R3), pt(3, 2 * R3), pt(-1, 2 * R3)], 4);\n  // The hat outline without the long edge's midpoint, as hatviz indexes it.\n  const o = HAT.filter((_, i) => i !== 3);\n  kid(h, match(o[5], o[7], Ho[5], Ho[0]), hat(0));\n  kid(h, match(o[9], o[11], Ho[1], Ho[2]), hat(0));\n  kid(h, match(o[5], o[7], Ho[3], Ho[4]), hat(0));\n  kid(h, mul(move(2.5, R3), mul([-0.5, -R3, 0, R3, -0.5, 0], [0.5, 0, 0, 0, -0.5, 0])), hat(1));\n  kid(t, [0.5, 0, 0.5, 0, 0.5, R3], hat(2));\n  for (const [m, l] of [[p, 3], [f, 4]]) {\n    kid(m, [0.5, 0, 1.5, 0, 0.5, R3], hat(l));\n    kid(m, mul(move(0, 2 * R3), mul([0.5, R3, 0, -R3, 0.5, 0], [0.5, 0, 0, 0, 0.5, 0])), hat(l));\n  }\n  return [h, t, p, f];\n}\n// The patch rules: [shape] for the first, [child, edge, shape, its edge] to\n// glue a new metatile to one edge of a child, or [child, corner, child,\n// corner, shape, its edge] to glue it between corners of two children.\nconst RULES = [[\"H\"], [0, 0, \"P\", 2], [1, 0, \"H\", 2], [2, 0, \"P\", 2], [3, 0, \"H\", 2], [4, 4, \"P\", 2], [0, 4, \"F\", 3], [2, 4, \"F\", 3], [4, 1, 3, 2, \"F\", 0], [8, 3, \"H\", 0], [9, 2, \"P\", 0], [10, 2, \"H\", 0], [11, 4, \"P\", 2], [12, 0, \"H\", 2], [13, 0, \"F\", 3], [14, 2, \"F\", 1], [15, 3, \"H\", 4], [8, 2, \"F\", 1], [17, 3, \"H\", 0], [18, 2, \"P\", 0], [19, 2, \"H\", 2], [20, 4, \"F\", 3], [20, 0, \"P\", 2], [22, 0, \"H\", 2], [23, 4, \"F\", 3], [23, 0, \"F\", 3], [16, 0, \"P\", 2], [9, 4, 0, 2, \"T\", 2], [4, 0, \"F\", 3]];\nfunction patch([h, t, p, f]) {\n  const out = meta([], -1), S = { H: h, T: t, P: p, F: f };\n  for (const r of RULES) {\n    if (r.length === 1) kid(out, ID, S[r[0]]);\n    else if (r.length === 4) {\n      const c = out.kids[r[0]], poly = c.g.shape, g = S[r[2]], n = g.shape.length;\n      kid(out, match(g.shape[r[3]], g.shape[(r[3] + 1) % n], apply(c.T, poly[(r[1] + 1) % poly.length]), apply(c.T, poly[r[1]])), g);\n    } else {\n      const g = S[r[4]], n = g.shape.length;\n      kid(out, match(g.shape[r[5]], g.shape[(r[5] + 1) % n], at(out, r[2], r[3]), at(out, r[0], r[1])), g);\n    }\n  }\n  return out;\n}\nfunction next(P) {\n  const b1 = at(P, 8, 2), b2 = at(P, 21, 2), rb = apply(turnAbout(b1, (-2 * PI) / 3), b2);\n  const p72 = at(P, 7, 2), p252 = at(P, 25, 2), llc = cross(b1, rb, at(P, 6, 2), p72);\n  let w = apply(turnAbout(pt(0, 0), -PI / 3), sub(at(P, 6, 2), llc));\n  const nH = [llc, b1, add(b1, w), at(P, 14, 2)];\n  w = apply(turnAbout(pt(0, 0), -PI / 3), w);\n  nH.push(sub(nH[3], w), at(P, 6, 2));\n  const take = (m, list) => (list.forEach((i) => kid(m, P.kids[i].T, P.kids[i].g)), m);\n  const h = take(meta(nH, 0), [0, 9, 16, 27, 26, 6, 1, 8, 10, 15]);\n  const p = take(meta([p72, add(p72, sub(b1, llc)), b1, llc], 3), [7, 2, 3, 4, 28]);\n  const f = take(meta([b2, at(P, 24, 2), at(P, 25, 0), p252, add(p252, sub(llc, b1))], 4), [21, 20, 22, 23, 24, 25]);\n  const A = nH[2], B = add(nH[1], sub(nH[4], nH[5]));\n  const t = take(meta([B, apply(turnAbout(B, -PI / 3), A), A], 2), [11]);\n  for (const m of [h, t, p, f]) recentre(m);\n  return [h, t, p, f];\n}\n\n// Four substitutions: an H metatile of 7,921 hats, 1,009 of them mirrored.\n// Each hat keeps its label and its turn (0..5, sixty degrees each), with the\n// index and label of the cluster holding it at levels 0 to 3 (level 0 is the\n// metatile of one to four hats, level 3 a cluster of up to 1,156). The order\n// of the list is the order the substitution nests them.\nconst LEVELS = 4;\nconst TILING = (() => {\n  let m = first();\n  for (let i = 0; i \u003c LEVELS; i++) m = next(patch(m));\n  const list = [];\n  let serial = 0;\n  const walk = (g, T, ids, labs) => {\n    if (g.hat) return list.push({ T, label: g.label, ids: ids.slice(), labs: labs.slice() });\n    ids.push(serial++);\n    labs.push(g.label);\n    for (const k of g.kids) walk(k.g, mul(T, k.T), ids, labs);\n    ids.pop();\n    labs.pop();\n  };\n  walk(m[0], ID, [], []);\n  const n = list.length;\n  const label = new Uint8Array(n), turn = new Uint8Array(n), cid = new Int32Array(n * 4), clab = new Uint8Array(n * 4);\n  const vx = new Float64Array(n * NV), vy = new Float64Array(n * NV);\n  list.forEach((h, k) => {\n    label[k] = h.label;\n    turn[k] = (round(atan2(h.T[3], h.T[0]) / (PI / 3)) + 6) % 6;\n    // ids run from the top (level 4) down to level 0.\n    for (let l = 0; l \u003c 4; l++) (cid[k * 4 + l] = h.ids[LEVELS - l]), (clab[k * 4 + l] = h.labs[LEVELS - l]);\n    HAT.forEach((p, i) => {\n      const q = apply(h.T, p);\n      (vx[k * NV + i] = q.x), (vy[k * NV + i] = q.y);\n    });\n  });\n  // Lift every corner into two parts, the sum of the a edges and the sum of\n  // the b edges along a path to it from one fixed corner. An a edge always\n  // meets an a edge, so the lift does not depend on the path, and a * A +\n  // b * B is the same tiling made of Tile(a, b).\n  // Corners are keyed by their lattice place relative to the first corner.\n  const key = (x, y) => (round((x - vx[0]) * 4) + 4096) * 16384 + round((y - vy[0]) / (R3 / 2)) + 4096;\n  const share = new Map();\n  for (let i = 0; i \u003c n * NV; i++) {\n    const kk = key(vx[i], vy[i]);\n    const l = share.get(kk);\n    l ? l.push(i) : share.set(kk, [i]);\n  }\n  const LA = new Float32Array(n * NV * 4), known = new Map(), seen = new Uint8Array(n), stack = [0];\n  known.set(key(vx[0], vy[0]), [0, 0, 0, 0]);\n  seen[0] = 1;\n  while (stack.length) {\n    const k = stack.pop();\n    let i0 = 0;\n    while (!known.has(key(vx[k * NV + i0], vy[k * NV + i0]))) i0++;\n    let [ax, ay, bx, by] = known.get(key(vx[k * NV + i0], vy[k * NV + i0]));\n    for (let s = 0; s \u003c NV; s++) {\n      const i = (i0 + s) % NV, j = (i + 1) % NV, o = k * NV + i, kk = key(vx[o], vy[o]);\n      if (!known.has(kk)) known.set(kk, [ax, ay, bx, by]);\n      LA.set([ax, ay, bx, by], o * 4);\n      for (const r of share.get(kk)) {\n        const h = (r / NV) | 0;\n        if (!seen[h]) (seen[h] = 1), stack.push(h);\n      }\n      const dx = vx[k * NV + j] - vx[o], dy = vy[k * NV + j] - vy[o];\n      if (KIND[i]) (bx += dx), (by += dy);\n      else (ax += dx), (ay += dy);\n    }\n  }\n  // Over the whole patch the a part grows as a fixed similarity MA of the\n  // position (a least-squares fit), the b part as I - MA. Dividing by the mix\n  // keeps any Tile(a, b) the hat's size and lined up with the hat tiling.\n  let a11 = 0, a12 = 0, a21 = 0, a22 = 0, xx = 0, xy = 0, yy = 0;\n  for (let i = 0; i \u003c n * NV; i++) {\n    const px = vx[i] - vx[0], py = vy[i] - vy[0], A = LA[i * 4], B = LA[i * 4 + 1];\n    (a11 += A * px), (a12 += A * py), (a21 += B * px), (a22 += B * py), (xx += px * px), (xy += px * py), (yy += py * py);\n  }\n  const d = xx * yy - xy * xy;\n  const MA = [(a11 * yy - a12 * xy) / d, (a12 * xx - a11 * xy) / d, (a21 * yy - a22 * xy) / d, (a22 * xx - a21 * xy) / d];\n  // The patch's middle in lift coordinates: the top metatile is centred on 0.\n  return { n, label, turn, cid, clab, LA, MA, cx: -vx[0], cy: -vy[0] };\n})();\nconst NH = TILING.n;\n\n// Size of a hat across, in lattice units: the hats sit at half scale.\nconst ACROSS = 2.75;\n// Story seconds at Speed 2 for the build and the cycle. WAVES says when the\n// colours regroup and to which level; a wave and a clearing take WAVE and\n// CLEAR seconds, and the window drifts DRIFT LEDs a second.\nconst BUILD = 1.6, CYCLE = 36, WAVES = [[11, 1], [17, 2], [23, 0]], WAVE = 1.6, CLEAR = 1.2, DRIFT = 2.5;\n// Hue of each label at Hue 0: H blue, H1 orange, T yellow, P magenta, F green.\nconst HUES = [0.6, 0.075, 0.15, 0.84, 0.36];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    fresh: true, t: 0, hue: 0, speed: 2, size: 9, shape: 0.06, shapeKey: NaN,\n    PX: new Float32Array(NH * NV), PY: new Float32Array(NH * NV), CX: new Float32Array(NH), CY: new Float32Array(NH),\n    born: new Float32Array(NH), gone: new Float32Array(NH).fill(1e9), flip: new Float32Array(NH).fill(-10), from: 0, to: 0,\n    cycle: 0, waveAt: 0, clearAt: 1e9, arc: 0, ox: 0, oy: 0, u: 1,\n    id: new Int32Array(NP), col: new Float32Array(NH * 3), lv: new Uint8Array(NH), vis: new Int32Array(NH), nvis: 0, xs: new Float64Array(32),\n  };\n}\n\n// Shape knob to the angle of (a, b): comet at 0 degrees, turtle 30, Tile(1, 1) 45, hat 60, chevron 90.\nconst angle = (k) => (k \u003c 0 ? 60 + 60 * k : k \u003c 0.12 ? 60 : 60 + (30 * (k - 0.12)) / 0.88);\n\nfunction reshape(S) {\n  const th = (angle(S.shape) * PI) / 180, wa = cos(th), wb = sin(th) / sqrt(3), { LA, MA } = TILING;\n  const L = [wa * MA[0] + wb * (1 - MA[0]), wa * MA[1] - wb * MA[1], wa * MA[2] - wb * MA[2], wa * MA[3] + wb * (1 - MA[3])];\n  const d = L[0] * L[3] - L[1] * L[2], i0 = L[3] / d, i1 = -L[1] / d, i2 = -L[2] / d, i3 = L[0] / d;\n  const { PX, PY, CX, CY } = S;\n  for (let k = 0; k \u003c NH; k++) {\n    let sx = 0, sy = 0;\n    for (let i = k * NV; i \u003c (k + 1) * NV; i++) {\n      const x = wa * LA[4 * i] + wb * LA[4 * i + 2], y = wa * LA[4 * i + 1] + wb * LA[4 * i + 3];\n      sx += PX[i] = i0 * x + i1 * y;\n      sy += PY[i] = i2 * x + i3 * y;\n    }\n    CX[k] = sx / NV;\n    CY[k] = sy / NV;\n  }\n}\n\n// The hats whose middles are on the panel now, in nesting order.\nfunction onPanel(S) {\n  const { CX, CY, u, ox, oy, vis } = S, r = 2 * u + 2;\n  let n = 0;\n  for (let k = 0; k \u003c NH; k++) {\n    const x = CX[k] * u + ox, y = CY[k] * u + oy;\n    if (x > -r && x \u003c W + r && y > -r && y \u003c H + r) vis[n++] = k;\n  }\n  return n;\n}\n\n// Each hat on the panel gets a time in nesting order across span seconds.\nfunction stagger(S, out, t0, span, rest) {\n  const n = onPanel(S);\n  out.fill(t0 + rest);\n  for (let i = 0; i \u003c n; i++) out[S.vis[i]] = t0 + (span * i) / max(1, n - 1);\n}\n\n// The window: a slow loop round the middle of the patch, kept inside it.\nfunction view(S) {\n  S.u = S.size / ACROSS;\n  const R = cl(64 - 74 / S.u, 6, 40), a = S.arc / R + 2;\n  S.ox = round(W / 2 - (TILING.cx + R * cos(a)) * S.u);\n  S.oy = round(H / 2 - (TILING.cy + 0.8 * R * sin(a)) * S.u);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.size = cl(k[2], 9, 16);\n  S.shape = cl(k[3], -1, 1);\n  if (S.shape !== S.shapeKey) (S.shapeKey = S.shape), reshape(S);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.arc += (DRIFT * ds) / (S.size / ACROSS);\n  view(S);\n  if (S.fresh) {\n    S.fresh = false;\n    stagger(S, S.born, 0, BUILD, BUILD);\n  }\n  const press = input.btnPressed && input.btnPressed[0];\n  const c = S.t - S.cycle;\n  if ((press && S.clearAt > S.t + CLEAR) || (c > CYCLE - CLEAR - 0.4 && S.clearAt > 1e8)) {\n    // Clear in nesting order, then build again where the window is then.\n    S.clearAt = S.t;\n    stagger(S, S.gone, S.t, CLEAR, CLEAR);\n  }\n  if (S.t > S.clearAt + CLEAR + 0.4) {\n    S.cycle = S.t;\n    S.clearAt = 1e9;\n    S.gone.fill(1e9);\n    S.from = S.to = 0;\n    S.waveAt = 0;\n    stagger(S, S.born, S.t, BUILD, BUILD);\n  }\n  for (const [w, v] of WAVES)\n    if (c >= w && S.waveAt \u003c w) {\n      S.waveAt = w;\n      S.from = S.to;\n      S.to = v;\n      stagger(S, S.flip, S.t, WAVE, WAVE);\n    }\n}\n\n// The label a hat shows in a view: its own, or that of the cluster of level\n// 1 or 2 holding it. The mirrored hats keep their own colour in every view.\nconst shown = (k, v) => (v === 0 || TILING.label[k] === 1 ? TILING.label[k] : TILING.clab[k * 4 + v]);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { id, col, lv, PX, PY, u, ox, oy, xs, born, gone, flip, t } = S, cid = TILING.cid;\n  id.fill(-1);\n  const n = onPanel(S), rgb = [0, 0, 0];\n  for (let i = 0; i \u003c n; i++) {\n    const k = S.vis[i];\n    // Fill the hat's 14-gon, LED centres inside it.\n    let y0 = 1e9, y1 = -1e9;\n    for (let j = k * NV; j \u003c (k + 1) * NV; j++) (y0 = min(y0, PY[j])), (y1 = max(y1, PY[j]));\n    const r0 = max(0, ceil(y0 * u + oy - 0.5)), r1 = min(H - 1, ceil(y1 * u + oy - 0.5) - 1);\n    for (let r = r0; r \u003c= r1; r++) {\n      const py = r + 0.5;\n      let m = 0;\n      for (let a = k * NV + NV - 1, b = k * NV; b \u003c (k + 1) * NV; a = b++) {\n        const ya = PY[a] * u + oy, yb = PY[b] * u + oy;\n        if (ya \u003c= py !== yb \u003c= py) {\n          const xa = PX[a] * u + ox;\n          let x = xa + ((py - ya) * (PX[b] * u + ox - xa)) / (yb - ya), q = m++;\n          while (q > 0 && xs[q - 1] > x) (xs[q] = xs[q - 1]), q--;\n          xs[q] = x;\n        }\n      }\n      for (let q = 0; q + 1 \u003c m; q += 2) {\n        const xa = max(0, ceil(xs[q] - 0.5)), xb = min(W - 1, ceil(xs[q + 1] - 0.5) - 1);\n        for (let x = xa; x \u003c= xb; x++) id[r * W + x] = k;\n      }\n    }\n    // Its colour: the label's hue, one of six close shades for its turn,\n    // a white flash as it arrives or changes colour, dark before and after.\n    const tn = TILING.turn[k], age = t - born[k], fl = t - flip[k];\n    const v = (lv[k] = fl >= 0 ? S.to : S.from);\n    hsv(HUES[shown(k, v)] + S.hue + 0.012 * (tn - 2.5), 0.92 - 0.045 * tn, 1 - 0.02 * tn, rgb, 0);\n    const glow = max(age >= 0 ? exp(-age / 0.18) : 0, fl >= 0 ? 0.7 * exp(-fl / 0.25) : 0);\n    const on = age \u003c 0 ? 0 : (1 - ease((t - gone[k]) / 0.3)) * min(1, 0.75 + age / 0.12);\n    for (let c = 0; c \u003c 3; c++) col[k * 3 + c] = on * (rgb[c] + (1 - rgb[c]) * glow);\n  }\n  // A hat that differs from the LED to its right or below loses that LED to\n  // a dark seam, one LED wide. While a view of level 1 or 2 shows, a seam\n  // inside one cluster keeps a third of the colour, so the clusters read as\n  // pieces with black between them.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const k = id[p];\n      if (k \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const kr = x \u003c W - 1 ? id[p + 1] : k, kd = y \u003c H - 1 ? id[p + W] : k, L = lv[k];\n      let f = 1;\n      if (kr !== k || kd !== k) {\n        const same = (q) => q === k || (L > 0 && q >= 0 && lv[q] === L && cid[q * 4 + L] === cid[k * 4 + L]);\n        f = same(kr) && same(kd) ? 0.3 : 0;\n      }\n      display.setPixel(x, y, round(col[k * 3] * 255 * f), round(col[k * 3 + 1] * 255 * f), round(col[k * 3 + 2] * 255 * f));\n    }\n}\n","jack-in-the-box":"// ===== Patternflow pattern =====\n// Title:   Jack-in-the-Box\n// Family:  halloween\n// Idea:    A purple tin box with orange harlequin diamonds sits on the floor while its crank turns by itself and the box shivers at every turn, until the lid bursts open and a grinning jack-o'-lantern on a long coiled spring shoots up the panel, overshoots and bobs on the stretching and bunching coil, swaying side to side, then slowly sinks back in, the lid slams and the crank turns again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spring=0..1, Wobble=0..1\n//\n// Knob 1: Hue. The tin and the candle in the head. The tin runs from purple at 0 through blue and teal to poison green at 1, its diamonds always orange; the candle from orange at 0 through lime at 0.25, sea green at 0.5 and blue at 0.75 to violet at 1, lighting the carving, the glow round the head and the inside of the box. The pumpkin's skin and the spring stay as they are.\n// Knob 2: Speed. At 2 the lid bursts at 0.85 seconds, the head bobs for 3.6 seconds, sinks back in 1.6, the lid slams and the crank turns for 1.4 seconds before the next pop, so a pop comes every 7 seconds; the crank turns 1.3 times a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Spring. Its stiffness. At 0 a soft spring: the head rests 40 LEDs above the box, overshoots to 66 and bounces deep and slow, 0.9 bounces a second; at 1 a stiff one: the head rides 56 LEDs up and buzzes 4.5 times a second in a tight shiver that dies away.\n// Knob 4: Wobble. How far the spring and the head sway. The pop throws the head to one side and it swings back and forth every 2.4 seconds, the head tilting with the top of the spring and rocking on its neck: at 0 about 2 LEDs either way, at the opening 0.06 about 3, at 1 a throw of 20 LEDs that settles to 12 either way.\n// Buttons: K1 tap pops it now; with the head already out it gives the head another shove up.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The box in an oblique view: the front face from column 10 to 46 and row\n// 93 to 121, and one unit of depth going 0.4 right and 0.22 up, so the top\n// and the right side show. The box is 24 deep.\nconst X0 = 10, X1 = 46, Y0 = 93, Y1 = 121, DEP = 24, DX = 0.4 * DEP, DY = 0.22 * DEP, FLOOR = 122;\n// The spring stands on the middle of the top; L is how far it reaches up\n// from there to the bottom of the head's collar. Shut in, the head sits at\n// L = -27, its stem below the box's front edge.\nconst BX = (X0 + X1) / 2 + DX / 2, BY = Y0 - DY / 2, INSIDE = -27, LMAX = 68;\n// The head: a pumpkin RX by RY, the collar under it, and the coil.\nconst RX = 12, RY = 10, NECK = 2.5, COILS = 8, CR = 5.5;\n// The story at Speed 2, in seconds after a pop: bob, sink, slam; then the\n// box stays shut and cranks for SHUT before the next pop. The first pop\n// comes at FIRST.\nconst BOB = 3.6, SINK = 1.6, SLAM = 0.35, SHUT = 1.4, FIRST = 0.85, CYCLE = BOB + SINK + SLAM + SHUT;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, stiff: 0, wob: 0.06,\n    // Spring length and speed; time since the pop (negative while shut);\n    // the lid's angle and speed; the crank's angle, the jolt it gives the\n    // box and the trembling before a pop; which side the pop throws the\n    // head; the candle's flicker.\n    L: INSIDE, v: 0, since: -FIRST, lid: 0, lidV: 0, crank: 0, jolt: 0, tremble: 0, side: 1, flick: 1,\n    buf: new Float32Array(N * 3), key: \"\", pal: null,\n  };\n}\n\n// Where the spring wants to rest and how it moves, by stiffness s: the\n// angular frequency, the rest length and the damping, light for small\n// motions and heavy for fast ones, so the pop cannot fly off the panel.\nfunction springOf(s) {\n  return { w: TAU * 0.9 * 5 ** s, le: 40 + 16 * s, z: 0.05 - 0.04 * s, c2: 0.012 + 0.02 * s };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.stiff = cl(k[2], 0, 1);\n  S.wob = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // A tap: pop now if shut or on the way down, or shove the head up.\n  if (input.btnPressed && input.btnPressed[0]) {\n    if (S.since \u003c 0 || S.since > BOB) pop(S);\n    else S.v += 160;\n  }\n  // The clock of one cycle: negative while the box waits for its first pop,\n  // 0 at a pop, and round again to the next pop at CYCLE.\n  const before = S.since;\n  S.since += ds;\n  if ((before \u003c 0 && S.since >= 0) || S.since >= CYCLE) pop(S);\n  const sp = springOf(S.stiff), a = S.since;\n  // The rest length: up while it bobs, drawn down into the box as it sinks.\n  const out = a >= 0 && a \u003c BOB + SINK;\n  const le = a \u003c 0 ? INSIDE : a \u003c BOB ? sp.le : a \u003c BOB + SINK ? sp.le + (INSIDE - 2 - sp.le) * ease((a - BOB) / SINK) : INSIDE;\n  // The spring, in eight steps a frame: L'' = -w^2 (L - le) - 2 z w L' - c2 |L'| L'.\n  if (out || S.L > INSIDE + 0.5 || abs(S.v) > 1) {\n    const n = 8, h = ds / n;\n    for (let i = 0; i \u003c n; i++) {\n      let acc = -sp.w * sp.w * (S.L - le) - 2 * sp.z * sp.w * S.v - sp.c2 * abs(S.v) * S.v;\n      // The coil cannot stretch past LMAX: it pulls back hard there.\n      if (S.L > LMAX) acc -= 900 * (S.L - LMAX) + 25 * max(0, S.v);\n      S.v += acc * h;\n      S.L += S.v * h;\n    }\n    // Shut in the box, it stops at the bottom.\n    if (!out && S.L \u003c INSIDE) (S.L = INSIDE), (S.v = 0);\n    // Going down it stops on the bottom of the box.\n    if (S.L \u003c INSIDE - 2) (S.L = INSIDE - 2), (S.v = max(0, S.v));\n  }\n  // The lid: flung open at the pop to lean back past upright, then shut as\n  // the head goes down, with a small bounce each time.\n  const goal = a >= 0 && a \u003c BOB + SINK ? 1.95 : 0;\n  const lk = goal ? 260 : 380, lz = goal ? 16 : 14;\n  S.lidV += (-lk * (S.lid - goal) - lz * S.lidV) * ds;\n  if (a >= BOB + SINK - 0.05 && S.L > INSIDE + 6) S.lidV = max(S.lidV, 0);\n  S.lid += S.lidV * ds;\n  if (S.lid \u003c 0) (S.lid = 0), (S.lidV = -0.35 * S.lidV);\n  // While shut the crank turns 1.3 times a second and jolts the box at every\n  // turn; in the last 0.4 seconds before a pop the box trembles and the lid\n  // rattles.\n  const shut = a \u003c 0 || a >= BOB + SINK + SLAM;\n  if (shut) {\n    const c0 = S.crank;\n    S.crank += TAU * 1.3 * ds;\n    if (floor(S.crank / TAU) !== floor(c0 / TAU)) S.jolt = 1;\n  }\n  S.jolt = max(0, S.jolt - ds / 0.09);\n  const toPop = a \u003c 0 ? -a : a >= BOB + SINK + SLAM ? CYCLE - a : 9;\n  S.tremble = toPop \u003c 0.4 ? 1 - toPop / 0.4 : 0;\n  S.flick += (0.8 + 0.2 * Math.random() - S.flick) * min(1, ds * 12);\n}\n\nfunction pop(S) {\n  S.since = 0;\n  S.L = max(S.L, INSIDE);\n  S.v = max(S.v, 0);\n  S.side = Math.random() \u003c 0.5 ? -1 : 1;\n  S.lidV = max(S.lidV, 14);\n}\n\n// Colours that only change with Hue.\nfunction palette(S) {\n  const key = S.hue.toFixed(3);\n  if (S.key === key) return;\n  S.key = key;\n  // The tin runs from purple through blue and teal to poison green; the\n  // diamonds stay orange. The candle in the head runs from orange through\n  // yellow and green to blue and violet.\n  const h = 0.78 - 0.45 * S.hue, hd = 0.075, hc = 0.09 + 0.66 * S.hue;\n  S.pal = {\n    front: hsv(h, 0.78, 0.58), side: hsv(h, 0.8, 0.36), top: hsv(h, 0.7, 0.72), lining: hsv(h, 0.75, 0.22), inner: hsv(h, 0.8, 0.07),\n    dia: hsv(hd, 0.92, 1), diaSide: hsv(hd - 0.01, 0.9, 0.8), diaTop: hsv(hd, 0.85, 0.9), floor: hsv(h, 0.6, 0.12),\n    halo: hsv(hc, 0.92, 1), cut: hsv(hc, 0.85, 1), core: hsv(hc + 0.03, 0.55, 1),\n  };\n}\n\n// The head's place and tilt from the spring: the coil leaves the box\n// straight up and bends toward the head, a quadratic curve from its foot at\n// (BX, BY) through (BX, BY - 0.55 L) to the collar.\nfunction headOf(S) {\n  // The pop throws the head to one side; it swings back and forth every\n  // 2.4 seconds, wide at first and settling to a steady sway.\n  const a = max(0, S.since), L = S.L, amp = 0.1 + 0.9 * S.wob, reach = cl(L / 40, 0, 1);\n  const X = cl(amp * reach * S.side * (12 + 12 * exp(-a / 2.5)) * sin(TAU * 0.42 * a + 0.36), -20, 20);\n  // The head tilts with the spring's end and rocks on its neck besides.\n  const hx = BX + X, hy = BY - L, tilt = 0.85 * atan2(X, max(8, 0.45 * L)) + amp * reach * 0.3 * sin(TAU * 0.9 * a);\n  return { hx, hy, tilt, cx: hx + (RY + NECK) * sin(tilt), cy: hy - (RY + NECK) * cos(tilt) };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const P = S.pal, buf = S.buf;\n  // The box's jolt and trembling, in whole LEDs.\n  const jy = S.jolt > 0.5 ? -1 : 0, jx = S.tremble > 0 && floor(S.t * 30) % 2 ? (S.tremble > 0.5 ? 1 : 0) : 0;\n  const ox = X0 + jx, oy = Y0 + jy;\n  const head = headOf(S), glow = cl((S.L - INSIDE) / 20, 0, 1) * S.flick;\n  const set = (p, c, a) => {\n    const o = 3 * p;\n    buf[o] = c[0] * a;\n    buf[o + 1] = c[1] * a;\n    buf[o + 2] = c[2] * a;\n  };\n  // Night: black above, a floor in the tin's colour, the candle's glow\n  // around the head.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      let r = 0, g = 0, b = 0;\n      if (y >= FLOOR) {\n        const f = 0.8 + 0.2 * ((y - FLOOR) / (H - FLOOR));\n        (r = P.floor[0] * f), (g = P.floor[1] * f), (b = P.floor[2] * f);\n      }\n      const dx = x + 0.5 - head.cx, dy = (y + 0.5 - head.cy) * 0.85, d2 = dx * dx + dy * dy;\n      if (d2 \u003c 900 && glow > 0) {\n        const q = (1 - sqrt(d2) / 30) ** 2 * 0.42 * glow;\n        r += q * P.halo[0];\n        g += q * P.halo[1];\n        b += q * P.halo[2];\n      }\n      buf[o] = r;\n      buf[o + 1] = g;\n      buf[o + 2] = b;\n    }\n  // The lid on its hinge along the back edge of the top: lid angle 0 lies\n  // shut, past 0.22 radians it shows its lining. Open wide it stands behind\n  // the spring; nearly shut it lies over everything.\n  const lidQuad = () => {\n    const ph = S.lid + 0.1 * S.tremble * abs(sin(S.t * 47)), fx = -DX * cos(ph), fy = DY * cos(ph) - DEP * sin(ph), hx0 = ox + DX, hy = oy - DY;\n    const y0 = floor(min(hy, hy + fy)), y1 = floor(max(hy, hy + fy)), outer = fy > 0;\n    for (let y = max(0, y0); y \u003c= min(H - 1, y1 + 1); y++) {\n      const t = fy === 0 ? 0 : cl((y + 0.5 - hy) / fy, 0, 1);\n      if (abs(fy) > 0.5 && ((y + 0.5 - hy) / fy \u003c -0.02 || (y + 0.5 - hy) / fy > 1.02)) continue;\n      const xa = hx0 + fx * t;\n      for (let x = max(0, floor(xa)); x \u003c min(W, xa + (X1 - X0)); x++) {\n        const u = x + 0.5 - xa, side = u \u003c 1 || u > X1 - X0 - 1, rim = side || t > 0.85 || t \u003c 0.12;\n        let c = outer ? (rim ? [0.95, 0.75, 0.3] : P.top) : side || t > 0.9 ? [0.62, 0.46, 0.18] : P.lining;\n        if (outer && !rim && diamond(u - 7, (1 - t) * DEP - 6)) c = P.diaTop;\n        // The lining darkens toward the free edge and takes the head's glow.\n        set(y * W + x, c, outer || side || t > 0.9 ? 1 : 1.25 - 0.55 * t + 0.6 * glow * (1 - t));\n      }\n    }\n  };\n  if (S.lid > 0.9) lidQuad();\n  // The top: the open mouth of the box, dark, lit orange by the head inside.\n  for (let y = floor(oy - DY); y \u003c oy; y++) {\n    const t = (oy - (y + 0.5)) / DY, xa = ox + DX * t;\n    for (let x = floor(xa); x \u003c xa + (X1 - X0); x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const c = P.inner, a = 1 + 4 * glow * (1 - t);\n      set(y * W + x, [c[0] * a + 0.25 * glow * P.halo[0], c[1] * a + 0.25 * glow * P.halo[1], c[2] * a + 0.25 * glow * P.halo[2]], 1);\n    }\n  }\n  // The spring: a helix about the curve, back half first, steel bright in front.\n  const L = S.L, hx = head.hx, hy = head.hy, bx = BX + jx, by = BY + jy;\n  if (L > -2) {\n    const steps = COILS * 40;\n    for (let pass = 0; pass \u003c 2; pass++)\n      for (let i = 0; i \u003c= steps; i++) {\n        const s = i / steps, ph = TAU * COILS * s + 0.6, z = sin(ph);\n        if ((z > 0) !== (pass === 1)) continue;\n        // Bezier point and tangent.\n        const m1x = bx, m1y = by - 0.55 * L, u = 1 - s;\n        const px = u * u * bx + 2 * u * s * m1x + s * s * hx, py = u * u * by + 2 * u * s * m1y + s * s * hy;\n        let tx = 2 * u * (m1x - bx) + 2 * s * (hx - m1x), ty = 2 * u * (m1y - by) + 2 * s * (hy - m1y);\n        const tl = sqrt(tx * tx + ty * ty) || 1;\n        (tx /= tl), (ty /= tl);\n        const r = CR * (s \u003c 0.04 ? 0.6 + 10 * s : 1), x = floor(px - ty * r * cos(ph) + 0.5), y = floor(py + tx * r * cos(ph) + 0.5);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= oy + Y1 - Y0) continue;\n        const lit = pass ? 0.55 + 0.45 * z : 0.22 + 0.1 * (1 + z), shine = pass && z > 0.85 ? 0.25 : 0;\n        set(y * W + x, [0.78 * lit + shine + 0.15 * glow * lit, 0.8 * lit + shine + 0.05 * glow * lit, 0.9 * lit + shine], 1);\n      }\n  }\n  // The head: a ribbed pumpkin with a carved grin glowing from inside, a\n  // green collar of points under it and a stem on top, all tilted with the\n  // spring's end.\n  {\n    const ct = cos(head.tilt), st = sin(head.tilt), cx = head.cx, cy = head.cy, fl = S.flick;\n    for (let y = max(0, floor(cy - 15)); y \u003c min(oy + Y1 - Y0, cy + 16); y++)\n      for (let x = max(0, floor(cx - 15)); x \u003c min(W, cx + 16); x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, u = dx * ct + dy * st, v = -dx * st + dy * ct;\n        const p = y * W + x;\n        // The collar: a ring of points below the head.\n        if (v > RY - 2 && v \u003c RY + NECK + 2.2 && abs(u) \u003c 9) {\n          const tip = RY + NECK + 2.2 - 2.2 * abs(sin((u * PI) / 3));\n          if (v \u003c tip) {\n            set(p, (floor((u + 9) / 3) & 1) ? [0.35, 1, 0.1] : [0.6, 0.15, 0.85], 0.9);\n            continue;\n          }\n        }\n        // The stem.\n        if (v \u003c -RY + 1.5 && v > -RY - 3.2 && abs(u - 0.4 - 0.35 * (v + RY)) \u003c 1.4) {\n          set(p, [0.25, 0.55, 0.12], 1);\n          continue;\n        }\n        // The pumpkin: an ellipse with lobes.\n        const ang = atan2(v, u), e = (u / RX) ** 2 + (v / RY) ** 2, lobe = 1 - 0.05 * abs(sin(ang * 3));\n        if (e > lobe * lobe) continue;\n        const face = carved(u, v);\n        // The cut wall shows as a dark line along the top of each hole.\n        if (!face && carved(u, v + 1)) {\n          set(p, [0.5, 0.17, 0.02], 1);\n          continue;\n        }\n        if (face) {\n          // The candle inside: pale at the core, its full colour at the cut.\n          set(p, face === 2 ? P.cut : P.core, face === 2 ? 0.8 * fl : fl);\n          continue;\n        }\n        // Skin: ribs along the meridians, lit from the upper left, a darker\n        // rind at the edge so the head stands off its own glow.\n        const mer = u / RX / sqrt(max(0.05, 1 - (v / RY) ** 2)), rib = abs(sin(mer * PI * 2.2)) \u003c 0.22 ? 0.84 : 1;\n        const light = (0.82 + 0.18 * cl(-(u + v) / RX, -1, 1)) * (e > 0.8 * lobe * lobe ? 0.78 : 1);\n        set(p, [light * rib, 0.44 * light * rib, 0.04], 1);\n      }\n  }\n  // The box's front and right side, over whatever is inside it.\n  for (let y = max(0, floor(oy - DY)); y \u003c= oy + (Y1 - Y0); y++)\n    for (let x = ox; x \u003c min(W, ox + (X1 - X0) + DX + 1); x++) {\n      const p = y * W + x, u = x + 0.5 - ox, v = y + 0.5 - oy;\n      if (u \u003c X1 - X0) {\n        if (v \u003c 0 || v > Y1 - Y0) continue;\n        // Gold rims top and bottom, purple tin with orange diamonds between.\n        if (v \u003c 2 || v > Y1 - Y0 - 2) {\n          set(p, [0.95, 0.72, 0.25], v \u003c 1 || v > Y1 - Y0 - 1 ? 1 : 0.75);\n          continue;\n        }\n        // Diamonds on a harlequin lattice, three across and two down, each\n        // 10 LEDs from point to point, the purple showing between.\n        const di = diamond(u - 7, v - 2);\n        const edge = u \u003c 1 ? 1.3 : u > X1 - X0 - 1 ? 0.75 : 1;\n        set(p, di ? P.dia : P.front, edge);\n      } else {\n        const t = (u - (X1 - X0)) / DX;\n        if (t > 1) continue;\n        const vv = v + DY * t;\n        if (vv \u003c 0 || vv > Y1 - Y0) continue;\n        if (vv \u003c 2 || vv > Y1 - Y0 - 2) {\n          set(p, [0.6, 0.45, 0.15], 1);\n          continue;\n        }\n        set(p, diamond(t * DEP - 6, vv - 2) ? P.diaSide : P.side, 1);\n      }\n    }\n  // The crank on the side: a brass hub, an arm turning in the side's plane\n  // and a red knob sticking out of it.\n  {\n    const hubX = ox + (X1 - X0) + DX / 2 + 1, hubY = oy + (Y1 - Y0) / 2 - DY / 2, c = S.crank;\n    const ex = hubX + 1.5 + 7 * cos(c) * 0.4, ey = hubY - 7 * cos(c) * 0.22 + 7 * sin(c);\n    const dot = (x, y, col, a = 1) => {\n      x = floor(x);\n      y = floor(y);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) set(y * W + x, col, a);\n    };\n    for (let i = 0; i \u003c= 10; i++) dot(hubX + (1.5 * i) / 10 + ((ex - hubX - 1.5) * i) / 10, hubY + ((ey - hubY) * i) / 10, [0.95, 0.75, 0.3]);\n    dot(hubX, hubY, [1, 0.9, 0.55]);\n    dot(hubX + 1, hubY, [0.9, 0.7, 0.3]);\n    for (let i = 1; i \u003c= 3; i++) dot(ex + i, ey, [0.8, 0.6, 0.25]);\n    for (const [kx, ky] of [[4, 0], [5, 0], [4, -1], [5, -1], [6, 0], [4, 1], [5, 1]]) dot(ex + kx, ey + ky, [1, 0.25, 0.12], kx === 6 ? 0.8 : 1);\n  }\n  if (S.lid \u003c= 0.9) lidQuad();\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) display.setPixel(x, y, round(min(1, buf[3 * p]) * 255), round(min(1, buf[3 * p + 1]) * 255), round(min(1, buf[3 * p + 2]) * 255));\n}\n\n// Whether (a, b), in LEDs along and across a face of the tin, falls in one\n// of its diamonds: every other cell of a lattice of 12 by 12 diamonds holds\n// one, 10 from point to point, centred on a = 0 and b = 6.\nfunction diamond(a, b) {\n  const qa = a / 12 + b / 12, qb = a / 12 - b / 12, fa = qa - floor(qa), fb = qb - floor(qb);\n  return (floor(qa) + floor(qb)) & 1 && max(abs(fa - 0.5), abs(fb - 0.5)) \u003c 0.42;\n}\n\n// The carving at (u, v) in the head's frame: 0 skin, 1 the open cut, 2 its\n// lit rim. Two eyes pointing up, a small nose and a wide grin curving up at\n// the corners, with a tooth hanging from the top and one standing below.\nfunction carved(u, v) {\n  const au = abs(u);\n  // Eyes: triangles 7 wide at v = -0.5 up to a point at v = -6, centred at |u| = 5.\n  if (v \u003c -0.5 && v > -6) {\n    const half = (3.5 * (v + 6)) / 5.5, e = abs(au - 5);\n    if (e \u003c half) return v > -1.5 || e > half - 1 ? 2 : 1;\n  }\n  // Nose: a small triangle.\n  if (v > 0.3 && v \u003c 2.6 && au \u003c (v - 0.3) * 0.8 + 0.2) return 2;\n  // Grin: between two curves meeting at |u| = 9.5, v = 3.2.\n  const q = 1 - (au / 9.5) ** 2;\n  if (q > 0) {\n    const top = 3.2 + 1.3 * q, bot = 3.2 + 4.6 * q;\n    if (v > top && v \u003c bot) {\n      if ((abs(u + 2.6) \u003c 1.2 && v \u003c top + 1.6) || (abs(u - 3) \u003c 1.2 && v > bot - 1.6)) return 0;\n      return v > bot - 1 ? 2 : 1;\n    }\n  }\n  return 0;\n}\n","persistence-barcode":"// ===== Patternflow pattern =====\n// Title:   Persistence Barcode\n// Family:  topology\n// Idea:    Disks grow round points scattered about a ring until they swallow it while the Delaunay edges and triangles they reach join in, and below them the barcode of that growth, reduced exactly over Z/2, lights up behind a sweeping line: short pale teal bars for points whose disks merge and one long orange bar for the ring's hole, whose loop and shrinking rim glow the same orange until the hole closes.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: persistent homology (Herbert Edelsbrunner, David Letscher and Afra Zomorodian, 2002) of the alpha complex of the points (alpha shapes, Herbert Edelsbrunner, David Kirkpatrick and Raimund Seidel, 1983), drawn as a barcode (Afra Zomorodian and Gunnar Carlsson, 2005), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Rings=1..3\n//\n// Knob 1: Hue. Turns the loops' colours round the wheel while the disks swing between violet and green and the merging bars between pale teal and pale violet, so nothing dim goes brown. At 0 violet disks, teal bars and an orange loop (the second and third rings pink and yellow); at 0.25 green loops on teal disks; at 0.5 blue loops on green disks; at 0.75 magenta loops.\n// Knob 2: Speed. At 2 the disks grow from nothing to 1.12 times the radius that closes the last hole in 7 seconds, the whole barcode holds for 1.5 s and a fresh sample comes at 9 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Noise. How far the points scatter from their circles: a twentieth of the radius at 0, where one ring's bar spans about three quarters of the ruler with one or two short bars beside it; a third at 1, where the ring frays into clusters and its bar spans under half among some 28 short ones. Turning it slides the same points, and the barcode is computed again at once.\n// Knob 4: Rings. One, two or three circles sharing 40, 38 or 36 points, so that many long bars stand in the barcode, orange, pink and yellow, each loop drawn in its bar's colour.\n// Buttons: K1 tap draws a fresh sample now.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The cloud is the square of rows 0..63; the barcode starts at row BT, and\n// the bottom row is its ruler of r.\nconst CH = 64, BT = 68;\n// The rings for one, two and three circles, [cx, cy, R] in LEDs, and how\n// many points they share.\nconst LAYOUT = [\n  { n: 40, rings: [[31.5, 31.5, 24]] },\n  { n: 38, rings: [[21, 21, 15.5], [45, 45, 11]] },\n  { n: 36, rings: [[15, 15, 10.5], [33, 33, 9], [50.5, 50.5, 8.5]] },\n];\nconst MAXN = 40;\n// Story seconds at Speed 2: the disks grow, the full barcode holds, the\n// picture fades and the next sample begins.\nconst GROW = 7, HOLD = 1.5, FADE = 0.5, CYCLE = GROW + HOLD + FADE;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, noise: 0, rings: 1, key: \"\", seed: 0, first: true, btn: false,\n    rnd: null, n: 0, X: new Float64Array(MAXN), Y: new Float64Array(MAXN), K: null,\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(8 * 3),\n  };\n  fresh(params.s);\n}\n\n// A new sample's randomness: each point's place along its circle and its\n// standard normal offset from it, and each ring's turn, size and shift.\nfunction fresh(S) {\n  const R = Math.random, gauss = () => cl(sqrt(-2 * log(1 - R())) * cos(TAU * R()), -2.6, 2.6);\n  S.rnd = {\n    ja: Array.from({ length: MAXN }, () => R() - 0.5),\n    z: Array.from({ length: MAXN }, gauss),\n    ring: Array.from({ length: 3 }, () => [TAU * R(), 1 + 0.08 * (R() - 0.5), 2 * (R() - 0.5), 2 * (R() - 0.5)]),\n    sym: floor(8 * R()),\n  };\n  S.seed++;\n  S.key = \"\";\n}\n\n// The points for the current knobs from the sample's randomness, so turning\n// Noise slides them instead of drawing new ones.\nfunction place(S) {\n  const L = LAYOUT[S.rings - 1], rr = S.rnd, sig = 0.05 + 0.28 * S.noise;\n  const tot = L.rings.reduce((a, g) => a + g[2], 0);\n  let i = 0;\n  L.rings.forEach((g, k) => {\n    const m = k === L.rings.length - 1 ? L.n - i : round((L.n * g[2]) / tot), [ph, sz, sx, sy] = rr.ring[k];\n    for (let j = 0; j \u003c m; j++, i++) {\n      const th = ph + (TAU * (j + 0.7 * rr.ja[i])) / m, rad = g[2] * sz * (1 + sig * rr.z[i]);\n      let u = g[0] + sx + rad * cos(th) - 31.5, v = g[1] + sy + rad * sin(th) - 31.5;\n      if (rr.sym & 1) u = -u;\n      if (rr.sym & 2) v = -v;\n      if (rr.sym & 4) [u, v] = [v, u];\n      // Points pushed against the edge are nudged apart, so two never meet.\n      S.X[i] = cl(31.5 + u, 1, 62.5) + 0.001 * i;\n      S.Y[i] = cl(31.5 + v, 1, CH - 1.5) + 0.0007 * i;\n    }\n  });\n  S.n = L.n;\n}\n\n// The alpha complex of the points and its persistence. Delaunay triangles\n// are the triples whose circumcircle holds no other point, and a triangle\n// enters when the disks reach its circumradius. An edge enters at half its\n// length, except when a triangle on one side has an obtuse angle facing it\n// (its third point lies inside the circle on the edge); then the edge enters\n// with that triangle. At radius r this complex has the shape of the union of\n// the disks, so the barcode is the barcode of the picture.\n// H0 comes from joining components in order; H1 from reducing the\n// triangles' boundary columns over Z/2, each surviving column's lowest edge\n// giving birth to the hole the triangle kills. The reduced column is that\n// hole's loop and the triangles summed into it are what fills it.\nfunction persistence(X, Y, n) {\n  const T = [];\n  for (let a = 0; a \u003c n; a++)\n    for (let b = a + 1; b \u003c n; b++)\n      for (let c = b + 1; c \u003c n; c++) {\n        const ax = X[a], ay = Y[a], bx = X[b] - ax, by = Y[b] - ay, cx = X[c] - ax, cy = Y[c] - ay;\n        const d = 2 * (bx * cy - by * cx);\n        if (abs(d) \u003c 1e-9) continue;\n        const b2 = bx * bx + by * by, c2 = cx * cx + cy * cy, ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d;\n        const R2 = ux * ux + uy * uy, ox = ax + ux, oy = ay + uy;\n        let ok = true;\n        for (let e = 0; e \u003c n && ok; e++) {\n          if (e === a || e === b || e === c) continue;\n          const dx = X[e] - ox, dy = Y[e] - oy;\n          if (dx * dx + dy * dy \u003c R2 * (1 - 1e-9)) ok = false;\n        }\n        if (ok) T.push({ v: [a, b, c], x: ox, y: oy, R: sqrt(R2), e: [] });\n      }\n  const emap = new Map(), E = [];\n  T.forEach((t) => {\n    const [a, b, c] = t.v;\n    for (const [p, q, o] of [[a, b, c], [a, c, b], [b, c, a]]) {\n      const k = p * 64 + q;\n      let e = emap.get(k);\n      if (!e) {\n        e = { a: p, b: q, v: 0.5 * Math.hypot(X[q] - X[p], Y[q] - Y[p]), att: null, o: 0 };\n        emap.set(k, e);\n        E.push(e);\n      }\n      t.e.push(e);\n      if ((X[p] - X[o]) * (X[q] - X[o]) + (Y[p] - Y[o]) * (Y[q] - Y[o]) \u003c 0) e.att = t;\n    }\n  });\n  for (const e of E) if (e.att) e.v = e.att.R;\n  E.sort((p, q) => p.v - q.v);\n  E.forEach((e, i) => (e.o = i));\n  T.sort((p, q) => p.R - q.R);\n  T.forEach((t, i) => (t.o = i));\n  // H0: every point is born at 0; joining two components kills one.\n  const up = Array.from({ length: n }, (_, i) => i), find = (i) => (up[i] === i ? i : (up[i] = find(up[i])));\n  const h0 = [];\n  for (const e of E) {\n    const ra = find(e.a), rb = find(e.b);\n    if (ra !== rb) {\n      up[ra] = rb;\n      h0.push(e.v);\n    }\n  }\n  while (h0.length \u003c n) h0.push(Infinity);\n  // H1: column reduction.\n  const nw = (E.length + 31) >> 5, tw = (T.length + 31) >> 5, owner = new Int32Array(E.length).fill(-1);\n  const cols = [], vs = [], h1 = [];\n  const top = (c) => {\n    for (let w = nw - 1; w >= 0; w--) if (c[w]) return 32 * w + 31 - Math.clz32(c[w]);\n    return -1;\n  };\n  const bits = (c, w) => {\n    const out = [];\n    for (let i = 0; i \u003c 32 * w; i++) if (c[i >> 5] & (1 \u003c\u003c (i & 31))) out.push(i);\n    return out;\n  };\n  let zero = 0;\n  T.forEach((t, j) => {\n    const col = new Uint32Array(nw), vv = new Uint32Array(tw);\n    for (const e of t.e) col[e.o >> 5] ^= 1 \u003c\u003c (e.o & 31);\n    vv[j >> 5] |= 1 \u003c\u003c (j & 31);\n    let low = top(col);\n    while (low >= 0 && owner[low] >= 0) {\n      const k = owner[low];\n      for (let w = 0; w \u003c nw; w++) col[w] ^= cols[k][w];\n      for (let w = 0; w \u003c tw; w++) vv[w] ^= vs[k][w];\n      low = top(col);\n    }\n    cols.push(col);\n    vs.push(vv);\n    if (low \u003c 0) return;\n    owner[low] = j;\n    const b = E[low].v, d = t.R;\n    if (d - b > 1e-9) h1.push({ b, d, cyc: bits(col, nw), reg: bits(vv, tw) });\n    else zero++;\n  });\n  let essential = 0;\n  E.forEach((e, i) => {\n    if (owner[i] \u003c 0) essential++;\n  });\n  // Edges that joined components are never pivots, so essential counts the\n  // n - 1 of them plus any loop that never closed (none in a triangulated\n  // disk). zero counts loops filled at the radius they closed.\n  return { T, E, h0, h1, zero, essential: essential - (n - 1) };\n}\n\n// Rebuild the complex, the per-LED maps of the cloud and the barcode's rows.\nfunction build(S) {\n  place(S);\n  const { X, Y, n } = S, K = (S.K = persistence(X, Y, n));\n  const { T, h0, h1 } = K;\n  let far = 0;\n  for (const d of h0) if (d \u003c Infinity) far = max(far, d);\n  for (const c of h1) far = max(far, c.d);\n  K.rMax = max(8, far * 1.12);\n  // Each loop's colour: the three most persistent loops, when they are\n  // long enough to be the rings' holes, get a colour each, the rest one more.\n  const ranked = [...h1].sort((p, q) => q.d - q.b - (p.d - p.b)), top = ranked.length ? ranked[0].d - ranked[0].b : 0;\n  ranked.forEach((c, i) => (c.col = i \u003c 3 && c.d - c.b > 0.3 * top ? i : 3));\n  // Nearest point and containing triangle for every LED of the cloud.\n  const P = CH * W;\n  K.dm = new Float32Array(P);\n  K.tri = new Int16Array(P).fill(-1);\n  for (let p = 0; p \u003c P; p++) {\n    const x = (p % W) + 0.5, y = floor(p / W) + 0.5;\n    let d = 1e9;\n    for (let i = 0; i \u003c n; i++) d = min(d, (X[i] - x) ** 2 + (Y[i] - y) ** 2);\n    K.dm[p] = sqrt(d);\n  }\n  for (const t of T) {\n    const [a, b, c] = t.v, x0 = max(0, floor(min(X[a], X[b], X[c]))), x1 = min(W - 1, floor(max(X[a], X[b], X[c])));\n    const y0 = max(0, floor(min(Y[a], Y[b], Y[c]))), y1 = min(CH - 1, floor(max(Y[a], Y[b], Y[c])));\n    const s = (X[b] - X[a]) * (Y[c] - Y[a]) - (Y[b] - Y[a]) * (X[c] - X[a]);\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x + 0.5, py = y + 0.5;\n        const w0 = ((X[b] - px) * (Y[c] - py) - (Y[b] - py) * (X[c] - px)) * s;\n        const w1 = ((X[c] - px) * (Y[a] - py) - (Y[c] - py) * (X[a] - px)) * s;\n        const w2 = ((X[a] - px) * (Y[b] - py) - (Y[a] - py) * (X[b] - px)) * s;\n        if (w0 >= 0 && w1 >= 0 && w2 >= 0) K.tri[y * W + x] = t.o;\n      }\n  }\n  // Which loops each triangle lies inside, the soonest to close first.\n  K.own = T.map(() => []);\n  [...h1].sort((p, q) => p.d - q.d).forEach((c) => c.reg.forEach((j) => K.own[j].push(c)));\n  // Barcode rows: H0 from the longest down, then H1 by birth. The rings'\n  // bars come first, as thick as the room allows up to 4 rows. The short\n  // bars then take one row each from what is left, longest first; those\n  // that do not fit are left out. A dark row stands between bars.\n  const room = H - 2 - (BT + n + 3), long = ranked.filter((c) => c.col \u003c 3);\n  let th = 4;\n  while (th > 1 && long.length * (th + 1) > room + 1) th--;\n  let left = room + 1 - long.length * (th + 1);\n  const shown = [...long];\n  for (const c of ranked) if (c.col === 3 && left >= 2) shown.push(c), (left -= 2);\n  shown.sort((p, q) => p.b - q.b);\n  K.rows = [];\n  [...h0].sort((p, q) => q - p).forEach((d, i) => K.rows.push({ y: BT + i, b: 0, d, col: -1, h: 1 }));\n  let y = BT + n + 3;\n  for (const c of shown) {\n    const h = c.col \u003c 3 ? th : 1;\n    K.rows.push({ y, b: c.b, d: c.d, col: c.col, h });\n    y += h + 1;\n  }\n}\n\nfunction plot(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= CH) return;\n  const o = 3 * (y * W + x);\n  buf[o] = max(buf[o], c[0] * a);\n  buf[o + 1] = max(buf[o + 1], c[1] * a);\n  buf[o + 2] = max(buf[o + 2], c[2] * a);\n}\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n  for (let i = 0; i \u003c= n; i++) plot(buf, floor(x0 + ((x1 - x0) * i) / n), floor(y0 + ((y1 - y0) * i) / n), c, a);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.noise = cl(k[2], 0, 1);\n  S.rings = round(cl(k[3], 1, 3));\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn) {\n    fresh(S);\n    S.t = 0;\n    S.first = false;\n  }\n  S.btn = btn;\n  S.t += (d * S.speed) / 2;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    S.first = false;\n    fresh(S);\n  }\n  const key = `${S.seed} ${S.rings} ${S.noise.toFixed(2)}`;\n  if (key !== S.key) {\n    S.key = key;\n    build(S);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.K) return;\n  const K = S.K, buf = S.buf, pal = S.pal, X = S.X, Y = S.Y;\n  const r = K.rMax * cl(S.t / GROW, 0, 1);\n  const fade = cl((CYCLE - S.t) / FADE, 0, 1) * (S.first ? 1 : cl(S.t / 0.3, 0, 1));\n  // Palette: 0..3 the loops, 4 merging (H0), 5 disks, 6 triangles, 7\n  // points. The dim colours stay in the cool half of the wheel and the\n  // merging colour is pale, so neither goes brown; only the bright loop\n  // colours turn the whole way round.\n  const u = S.hue, sw = sin(PI * u) ** 2, cool = 0.72 - 0.38 * sw, pale = 0.52 + 0.3 * sw;\n  hsv(u + 0.07, 0.92, 1, pal, 0);\n  hsv(u + 0.9, 0.72, 1, pal, 3);\n  hsv(u + 0.15, 0.85, 1, pal, 6);\n  hsv(u + 0.98, 0.4, 0.85, pal, 9);\n  hsv(pale, 0.55, 0.95, pal, 12);\n  hsv(cool, 0.7, 1, pal, 15);\n  hsv(cool - 0.05, 0.55, 1, pal, 18);\n  hsv(pale, 0.12, 1, pal, 21);\n  const C = (i) => [pal[3 * i], pal[3 * i + 1], pal[3 * i + 2]];\n  const cLoop = [C(0), C(1), C(2), C(3)], cH0 = C(4), cDisk = C(5), cTri = C(6), cPt = C(7);\n  buf.fill(0);\n  // The union of disks with its scalloped edge, the triangles in it, each\n  // open hole lined with its loop's colour, and the hole that just closed\n  // flashing.\n  const flashR = 0.06 * K.rMax;\n  for (let p = 0, P = CH * W; p \u003c P; p++) {\n    const dm = K.dm[p], t = K.tri[p], o = 3 * p;\n    let a = 0;\n    if (dm \u003c= r + 0.5) a = 0.17 * cl(r + 0.5 - dm, 0, 1) + (r - dm \u003c 1.2 && r > 0.8 ? 0.2 : 0);\n    let rr = cDisk[0] * a, gg = cDisk[1] * a, bb = cDisk[2] * a;\n    if (t >= 0) {\n      if (K.T[t].R \u003c= r) (rr += cTri[0] * 0.12), (gg += cTri[1] * 0.12), (bb += cTri[2] * 0.12);\n      for (const cy of K.own[t]) {\n        if (cy.b \u003c= r && r \u003c cy.d) {\n          const e = dm - r;\n          if (e > 0) {\n            const L = cLoop[cy.col], q = e \u003c 1 ? 0.9 : e \u003c 2 ? 0.38 : 0;\n            (rr = L[0] * q), (gg = L[1] * q), (bb = L[2] * q);\n          }\n          break;\n        }\n        if (r >= cy.d && r - cy.d \u003c flashR) {\n          const L = cLoop[cy.col], q = 0.7 * (1 - (r - cy.d) / flashR);\n          (rr += L[0] * q), (gg += L[1] * q), (bb += L[2] * q);\n          break;\n        }\n      }\n    }\n    buf[o] = rr;\n    buf[o + 1] = gg;\n    buf[o + 2] = bb;\n  }\n  // Edges that have entered, bright as they arrive and dimmer after.\n  for (const e of K.E) {\n    if (e.v > r) break;\n    const a = 0.32 + 0.5 * Math.exp(-(r - e.v) / (0.05 * K.rMax));\n    line(buf, X[e.a], Y[e.a], X[e.b], Y[e.b], cH0, a);\n  }\n  // The loops that are alive, each in its bar's colour.\n  for (const c of K.h1)\n    if (c.b \u003c= r && r \u003c c.d) for (const i of c.cyc) line(buf, X[K.E[i].a], Y[K.E[i].a], X[K.E[i].b], Y[K.E[i].b], cLoop[c.col], 1);\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = floor(X[i]), y = floor(Y[i]);\n    plot(buf, x, y, cPt, 1);\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) plot(buf, x + dx, y + dy, cPt, 0.3);\n  }\n  // The ruler: a tick every 4 LEDs of radius, the sweep's place bright.\n  const span = W - 2, col = (v) => 1 + round((min(v, K.rMax) / K.rMax) * span), xs = col(r);\n  const set = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = 3 * (y * W + x);\n    buf[o] = max(buf[o], c[0] * a);\n    buf[o + 1] = max(buf[o + 1], c[1] * a);\n    buf[o + 2] = max(buf[o + 2], c[2] * a);\n  };\n  for (let v = 0; v \u003c= K.rMax; v += 4) set(col(v), H - 1, cPt, 0.35);\n  for (let x = 0; x \u003c W; x += 2) set(x, BT - 2, cH0, 0.2);\n  set(xs, H - 1, cPt, 1);\n  // Bars: solid up to the sweep, brightest while alive; dotted beyond it,\n  // where the sweep has yet to go. The sweep line runs down between them\n  // to the ruler on the bottom row.\n  for (let y = BT - 1; y \u003c H - 1; y++) set(xs, y, cPt, 0.2);\n  for (const row of K.rows) {\n    const c = row.col \u003c 0 ? cH0 : cLoop[row.col], x0 = col(row.b), x1 = max(x0, row.d === Infinity ? W - 1 : col(row.d) - 1);\n    const alive = row.b \u003c= r && r \u003c row.d, h = row.h;\n    for (let j = 0; j \u003c h; j++) {\n      const y = row.y + j, rim = j === 0 || j === h - 1;\n      for (let x = x0; x \u003c= x1; x++) {\n        if (x \u003c= xs) set(x, y, c, alive ? 1 : row.col \u003c 0 ? 0.62 : 0.8);\n        else if ((rim && (x - x0) % 2 === 0) || x === x1) set(x, y, c, 0.4);\n      }\n      if (alive) set(xs, y, cPt, 1);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      display.setPixel(x, y, round(cl(buf[o] * fade, 0, 1) * 255), round(cl(buf[o + 1] * fade, 0, 1) * 255), round(cl(buf[o + 2] * fade, 0, 1) * 255));\n    }\n}\n","phantom-jam":"// ===== Patternflow pattern =====\n// Title:   Phantom Jam\n// Family:  sim\n// Idea:    Cars run round a tall ring road at the panel's edge, each driver easing toward the speed its gap allows, and with no crash or roadworks a stop-and-go jam forms and creeps backward round the ring while every car keeps going forward, as the space-time diagram inside the track shows with car lines slanting one way and red jam stripes the other.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the optimal velocity model of traffic (Masako Bando, Katsuya Hasebe, Akihiro Nakayama, Akihiro Shibata and Yuki Sugiyama, 1995) and the circuit experiment of Yuki Sugiyama and seven others (2008), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cars=22..44, Sensitivity=0.5..2.5\n//\n// Knob 1: Hue. The colour of free flow, on the moving cars and their lines: cyan green at 0, blue at 0.5, violet at 1. Stopped cars and the jam stripes stay brake red, with amber for the speeds between. One car stays white so its line can be followed through the jams.\n// Knob 2: Speed. At 2 a car at full speed laps the ring in 5 seconds, or 11 at the even spacing of 22 cars, and the diagram takes 10 new rows a second, so it holds the last 11.6 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Cars. How many cars share the ring, from 22, the number in Sugiyama's circuit, to 44. Turning it lets a car join at the widest gap or leave from the tightest, which is a kink of its own. More cars mean shorter gaps and slower flow: at 44 the ring crawls in amber between red queues.\n// Knob 4: Sensitivity. How hard each driver chases the speed its gap allows, the model's a. Uniform flow is unstable when a is below twice the slope of the speed law at its gap. At 0.5 every number of cars jams hard and the queues stand still. At 1.5 only 22 to 29 cars are unstable, and a wave takes about a minute to grow. From 2 on every kink heals and the lines run parallel.\n// Buttons: K1 tap makes the driver nearest the start line, the white tick at the bottom of the track, brake to a stop.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, tanh, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The model. Ring length in model units, the headway where the speed law is\n// steepest, and the speed law V(h) = tanh(h - C) + tanh(C), which runs from\n// 0 at h = 0 to VMAX for long gaps. Uniform flow at headway h is unstable\n// when a \u003c 2 V'(h) = 2 / cosh(h - C)^2.\nconst L = 39, C = 1.87, VMAX = 2 * tanh(C);\nconst V = (h) => tanh(h - C) + tanh(C);\n// Fixed physics step, the smallest bumper-to-bumper headway (a car is 0.35\n// units long), and the model time between two rows of the diagram.\nconst DT = 0.05, HMIN = 0.47, ROW = 0.4;\n\n// The track's centre line: straights at x = 3 and x = 61 from y = 14 to\n// y = 114, joined by half ellipses 29 LEDs across and 11 deep. Arc length s\n// starts at the bottom middle and runs right along the bottom, up the right\n// straight, over the top and down the left.\nconst CX = 32, XL = 3, XR = 61, YT = 14, YB = 114, RX = 29, RY = 11;\nconst PT = [];\n{\n  const n = 400;\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((PI / 2) * i) / n;\n    PT.push([CX + RX * sin(a), YB + RY * cos(a)]);\n  }\n  for (let i = 1; i \u003c= n; i++) PT.push([XR, YB - ((YB - YT) * i) / n]);\n  for (let i = 1; i \u003c= 2 * n; i++) {\n    const a = (PI * i) / (2 * n);\n    PT.push([CX + RX * cos(a), YT - RY * sin(a)]);\n  }\n  for (let i = 1; i \u003c= n; i++) PT.push([XL, YT + ((YB - YT) * i) / n]);\n  for (let i = 1; i \u003c= n; i++) {\n    const a = ((PI / 2) * i) / n;\n    PT.push([CX - RX * cos(a), YB + RY * sin(a)]);\n  }\n  let s = 0;\n  PT[0].push(0);\n  for (let i = 1; i \u003c PT.length; i++) PT[i].push((s += Math.hypot(PT[i][0] - PT[i - 1][0], PT[i][1] - PT[i - 1][1])));\n}\nconst LT = PT[PT.length - 1][2], NB = ceil(LT);\n// Where s is on the panel, every half LED of arc.\nconst SX = new Float32Array(2 * NB + 2), SY = new Float32Array(2 * NB + 2);\nfor (let i = 0, j = 0; i \u003c SX.length; i++) {\n  const s = (i / 2) % LT;\n  if (s \u003c PT[j][2]) j = 0;\n  while (j \u003c PT.length - 2 && PT[j + 1][2] \u003c s) j++;\n  const a = PT[j], b = PT[j + 1], u = (s - a[2]) / (b[2] - a[2] || 1);\n  SX[i] = a[0] + (b[0] - a[0]) * u;\n  SY[i] = a[1] + (b[1] - a[1]) * u;\n}\n\n// Every LED's arc length and its distance from the centre line (negative\n// inside), then its part: 0 dark, 1 outer kerb, 2 lane, 3 inner kerb, 4 the\n// gap, 5 the diagram.\nconst TS = new Float32Array(N), KIND = new Uint8Array(N);\n// The diagram: 52 columns for the ring unrolled, 116 rows of time.\nconst DX0 = 6, DY0 = 6, DCOL = 52, DROWS = 116;\nconst DIAG = [];\n{\n  const sR = PT[400][2], sL = PT[1600][2];\n  const cap = PT.filter((q) => q[1] \u003c YT || q[1] > YB);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, px = x + 0.5, py = y + 0.5;\n      let d, s;\n      if (py >= YT && py \u003c= YB) {\n        const dl = px - XL, dr = XR - px;\n        if (dl \u003c dr) (d = -dl), (s = sL + (py - YT));\n        else (d = -dr), (s = sR + (YB - py));\n      } else {\n        let best = 1e9, q = cap[0];\n        for (const c of cap) {\n          const e = (c[0] - px) ** 2 + (c[1] - py) ** 2;\n          if (e \u003c best) (best = e), (q = c);\n        }\n        const ey = py \u003c YT ? YT : YB, inside = ((px - CX) / RX) ** 2 + ((py - ey) / RY) ** 2 \u003c 1;\n        d = inside ? -sqrt(best) : sqrt(best);\n        s = q[2];\n      }\n      TS[p] = s;\n      const k = d > 2 ? 0 : d > 1 ? 1 : d > -1 ? 2 : d > -2 ? 3 : d > -3 ? 4 : 5;\n      KIND[p] = k;\n      if (k === 5) DIAG.push(p, x - DX0, y - DY0);\n    }\n}\n// Lane LEDs by whole LED of arc, for drawing cars.\nconst LANE = Array.from({ length: NB }, () => []);\nfor (let p = 0; p \u003c N; p++) if (KIND[p] === 2) LANE[floor(TS[p]) % NB].push(p);\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, speed: 2, n: 0, a: 0.5, clock: 0, head: 0, cars: [],\n    lineA: new Float32Array(DROWS * DCOL), lineF: new Float32Array(DROWS * DCOL), field: new Float32Array(DROWS * DCOL),\n    lut: new Float32Array(66 * 6), buf: new Float32Array(N * 3), ready: false,\n  };\n}\n\n// The colour of a speed, f = v / VMAX: brake red when stopped, amber at an\n// eighth of top speed, the free-flow colour from a third of it.\nfunction speedColour(f, mov) {\n  if (f \u003c 0.12) {\n    const u = sm((f - 0.03) / 0.09);\n    return [1, 0.06 + 0.44 * u, 0.03 * (1 - u)];\n  }\n  const u = sm((f - 0.12) / 0.23), c = [1 + (mov[0] - 1) * u, 0.5 + (mov[1] - 0.5) * u, mov[2] * u], m = max(c[0], c[1], c[2]);\n  return [c[0] / m, c[1] / m, c[2] / m];\n}\n\n// One physics step of every driver: dv/dt = a (V(h) - v), with a little\n// jitter in each driver's foot. A braking driver aims for 0 instead.\nfunction step(S) {\n  const cars = S.cars, n = cars.length;\n  for (let i = 0; i \u003c n; i++) {\n    const c = cars[i], h = (cars[(i + 1) % n].x - c.x + L) % L || L;\n    let acc = S.a * (V(h) - c.v);\n    if (c.brake > 0) {\n      acc = -2.5 * c.v;\n      c.brake -= DT;\n    }\n    c.acc = acc + 0.06 * (Math.random() - 0.5);\n  }\n  for (const c of cars) {\n    c.v = max(0, c.v + c.acc * DT);\n    c.x = (c.x + c.v * DT) % L;\n  }\n  // No one drives into the car ahead.\n  for (let i = 0; i \u003c n; i++) {\n    const c = cars[i], f = cars[(i + 1) % n], h = (f.x - c.x + L) % L;\n    if (n > 1 && h \u003c HMIN) {\n      c.x = (f.x - HMIN + L) % L;\n      c.v = min(c.v, f.v);\n    }\n  }\n  if ((S.clock += DT) >= ROW - 1e-9) {\n    S.clock -= ROW;\n    record(S);\n  }\n}\n\n// A new top row of the diagram: each car's stretch since the last row as a\n// line one column wide, coloured by its speed, over the speed field between\n// the cars, which shows dark red where the traffic stands.\nfunction record(S) {\n  const cars = S.cars, n = cars.length;\n  S.head = (S.head + 1) % DROWS;\n  const o = S.head * DCOL, A = S.lineA, F = S.lineF, G = S.field;\n  A.fill(0, o, o + DCOL);\n  G.fill(1, o, o + DCOL);\n  for (const c of cars) {\n    const c1 = (c.x / L) * DCOL;\n    let c0 = c.pc \u003c 0 ? c1 : c.pc;\n    if (c0 > c1 + DCOL / 2) c0 -= DCOL;\n    const lo = min(c1 - 0.5, c0 + 0.5), hi = c1 + 0.5, f = c.tr ? 2 : c.v / VMAX;\n    for (let j = floor(lo); j \u003c= floor(hi); j++) {\n      const cov = min(hi, j + 1) - max(lo, j), jj = (j + DCOL) % DCOL;\n      if (cov > A[o + jj] || (c.tr && cov > 0.3)) (A[o + jj] = cov), (F[o + jj] = f);\n    }\n    c.pc = c1;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const c = cars[i], d = cars[(i + 1) % n], x0 = (c.x / L) * DCOL;\n    let x1 = (d.x / L) * DCOL;\n    if (x1 \u003c= x0) x1 += DCOL;\n    const f0 = c.v / VMAX, f1 = d.v / VMAX;\n    for (let j = ceil(x0 - 0.5); j \u003c= floor(x1 - 0.5); j++) {\n      const u = (j + 0.5 - x0) / (x1 - x0 || 1);\n      G[o + (j % DCOL)] = f0 + (f1 - f0) * u;\n    }\n  }\n}\n\n// Cars evenly spaced at the equilibrium speed, then the diagram's whole\n// height of history run at once, one driver lifting off a little at the\n// start of it.\nfunction begin(S) {\n  const n = S.n, h0 = L / n, v0 = V(h0);\n  S.cars = [];\n  for (let i = 0; i \u003c n; i++) S.cars.push({ x: i * h0, v: v0, acc: 0, brake: 0, pc: -1 });\n  S.cars[0].v = v0 * 0.6;\n  S.cars[0].tr = true;\n  S.lineA.fill(0);\n  S.field.fill(1);\n  S.clock = 0;\n  const steps = round((DROWS * ROW) / DT);\n  for (let i = 0; i \u003c steps; i++) step(S);\n}\n\n// K3 moved: one car joins in the widest gap or leaves the tightest.\nfunction retune(S) {\n  const cars = S.cars, n = cars.length;\n  let best = -1, at = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const h = (cars[(i + 1) % n].x - cars[i].x + L) % L;\n    if (S.n > n ? h > best : best \u003c 0 || h \u003c best) (best = h), (at = i);\n  }\n  if (S.n > n) {\n    const a = cars[at], b = cars[(at + 1) % n];\n    cars.splice(at + 1, 0, { x: (a.x + best / 2) % L, v: (a.v + b.v) / 2, acc: 0, brake: 0, pc: -1 });\n  } else {\n    if (cars[at].tr) cars[(at + 1) % n].tr = true;\n    cars.splice(at, 1);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.a = cl(k[3], 0.5, 2.5);\n  S.n = round(cl(k[2], 22, 44));\n  if (!S.ready) {\n    S.ready = true;\n    begin(S);\n  } else if (S.n !== S.cars.length) retune(S);\n  if (input.btnPressed && input.btnPressed[0]) {\n    let best = 1e9, who = S.cars[0];\n    for (const c of S.cars) {\n      const e = min(c.x, L - c.x);\n      if (e \u003c best) (best = e), (who = c);\n    }\n    who.brake = 2;\n  }\n  S.acc = (S.acc || 0) + d * S.speed * 2;\n  while (S.acc >= DT) {\n    S.acc -= DT;\n    step(S);\n  }\n  // Hue: free flow from cyan green round to violet.\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    S.mov = hsv(0.42 + 0.4 * hue, 0.85, 1);\n    // Lines: stopped cars bright, free ones dimmer, so the jams stand out\n    // of the hatching; the last entry is the one white car. Under them the\n    // speed field, dark red where the traffic stands.\n    for (let i = 0; i \u003c= 65; i++) {\n      const f = i / 64, c = i > 64 ? [1, 1, 1] : speedColour(f, S.mov), b = i > 64 ? 1 : 0.95 - 0.45 * sm((f - 0.05) / 0.3), o = 6 * i, jam = 0.22 * sm(1 - f / 0.12);\n      S.lut[o] = c[0] * b;\n      S.lut[o + 1] = c[1] * b;\n      S.lut[o + 2] = c[2] * b;\n      S.lut[o + 3] = jam;\n      S.lut[o + 4] = jam * 0.08;\n      S.lut[o + 5] = jam * 0.12;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const buf = S.buf, lut = S.lut, mov = S.mov;\n  buf.fill(0);\n  // The diagram, newest row at the top.\n  const A = S.lineA, F = S.lineF, G = S.field;\n  for (let i = 0; i \u003c DIAG.length; i += 3) {\n    const p = DIAG[i], r = (S.head - DIAG[i + 2] + DROWS) % DROWS, o = r * DCOL + DIAG[i + 1];\n    const g = 6 * round(cl(G[o], 0, 1) * 64), a = A[o] * (0.9 - (0.5 * DIAG[i + 2]) / DROWS), l = 6 * (F[o] > 1.5 ? 65 : round(cl(F[o], 0, 1) * 64)), q = 3 * p;\n    buf[q] = lut[g + 3] + lut[l] * a;\n    buf[q + 1] = lut[g + 4] + lut[l + 1] * a;\n    buf[q + 2] = lut[g + 5] + lut[l + 2] * a;\n  }\n  // The road: dim kerbs tinted by the free-flow colour, dark lane, a white\n  // start line at the bottom middle.\n  const kerb = [0.12 + 0.08 * mov[0], 0.12 + 0.08 * mov[1], 0.12 + 0.08 * mov[2]];\n  for (let p = 0; p \u003c N; p++) {\n    const k = KIND[p], q = 3 * p;\n    if (k === 1 || k === 3) (buf[q] = kerb[0]), (buf[q + 1] = kerb[1]), (buf[q + 2] = kerb[2]);\n    else if (k === 2) {\n      const sl = TS[p] \u003c 1 || TS[p] > LT - 1;\n      buf[q] = sl ? 0.5 : 0.04;\n      buf[q + 1] = sl ? 0.5 : 0.04;\n      buf[q + 2] = sl ? 0.5 : 0.05;\n    }\n  }\n  // Brake lights glow on the road round each braking car's tail.\n  for (const c of S.cars) {\n    if (c.acc > -0.12 && c.v > 0.08) continue;\n    const s = (c.x / L) * LT, gx = SX[round(2 * s) % SX.length], gy = SY[round(2 * s) % SY.length];\n    const amp = c.v \u003c 0.08 ? 0.35 : 0.5;\n    for (let y = floor(gy - 4); y \u003c= ceil(gy + 4); y++)\n      for (let x = floor(gx - 4); x \u003c= ceil(gx + 4); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const r = Math.hypot(x + 0.5 - gx, y + 0.5 - gy);\n        if (r > 4) continue;\n        const w = amp * (1 - r / 4) ** 2, q = 3 * (y * W + x);\n        buf[q] += w;\n        buf[q + 1] += w * 0.06;\n        buf[q + 2] += w * 0.04;\n      }\n  }\n  // The cars: dashes three LEDs long, coloured by speed, tail lit red when braking.\n  for (const c of S.cars) {\n    const sr = (c.x / L) * LT, col = c.tr ? [1, 1, 1] : speedColour(c.v / VMAX, mov), braking = c.acc \u003c -0.12 || c.v \u003c 0.08;\n    for (let b = floor(sr) - 1; b \u003c= floor(sr) + 4; b++) {\n      for (const p of LANE[((b % NB) + NB) % NB]) {\n        let u = TS[p] - sr;\n        if (u \u003c -LT / 2) u += LT;\n        if (u > LT / 2) u -= LT;\n        const cov = min(u + 0.5, 3) - max(u - 0.5, 0);\n        if (cov \u003c= 0) continue;\n        const q = 3 * p, w = min(1, cov);\n        const tail = braking && u \u003c 1, front = u > 2;\n        const r = tail ? 1 : front ? 0.6 + 0.4 * col[0] : col[0], g = tail ? 0.05 : front ? 0.6 + 0.4 * col[1] : col[1], bl = tail ? 0.03 : front ? 0.6 + 0.4 * col[2] : col[2];\n        buf[q] += (r - buf[q]) * w;\n        buf[q + 1] += (g - buf[q + 1]) * w;\n        buf[q + 2] += (bl - buf[q + 2]) * w;\n      }\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const q = 3 * p;\n      display.setPixel(x, y, round(cl(buf[q], 0, 1) * 255), round(cl(buf[q + 1], 0, 1) * 255), round(cl(buf[q + 2], 0, 1) * 255));\n    }\n}\n","sato-tate":"// ===== Patternflow pattern =====\n// Title:   Sato-Tate\n// Family:  number\n// Idea:    Primes rain down the panel, each dropping at the column of a_p / (2 sqrt p) for an elliptic curve counted exactly mod p, and pile into a histogram that fills the faint semicircle (2/pi) sqrt(1 - x^2) layer by layer, each new layer as many primes as all the layers under it, while a curve with complex multiplication sends half its primes down the middle and heaps the rest against the walls.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sato-Tate conjecture (Mikio Sato and John Tate, 1963), proved for elliptic curves without complex multiplication (Laurent Clozel, Michael Harris, Nicholas Shepherd-Barron and Richard Taylor, 2008-2011), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Curve=0..1, Bins=-1..1\n//\n// Knob 1: Hue. Turns the layers round the wheel. At 0 the first layer of primes is cyan and each later one a step further round, through azure and blue to violet and rose at the top of the full pile; at 0.5 the first is red and the later ones orange, yellow, lime and green. The outline stays a pale cream.\n// Knob 2: Speed. At 2 the first drop lands at 0.9 seconds, the first 512 primes fill the dome by 2.6, the next four layers take 2.9, 4.5, 8.2 and 24 seconds, the last reaching p = 84,053, and after a 2.5 second hold the pile sinks and the count starts again from p = 3. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Curve. Three curves in steps. Below 1/3 the curve 37a, y^2 + y = x^3 - x, with no complex multiplication, whose primes fill the semicircle; from 1/3 y^2 = x^3 - x, where every p = 3 mod 4 has a_p = 0 and falls down the middle, and the rest follow 1/(pi sqrt(1 - x^2)) up the two walls; from 2/3 y^2 = x^3 + 1, the same for p = 2 mod 3. A new curve starts the count again.\n// Knob 4: Bins. How the 63 columns of the plot are grouped: at -1 seven bins 9 LEDs wide, at -0.5 nine bins of 7, from -0.2 (so at the opening 0.06) 21 bins of 3, and from 0.6 every column its own bin. The counts are kept per column, so the bars regroup at once.\n// Buttons: K1 tap lets the pile sink now and starts the count again from p = 3.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sqrt, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The plot: x = a_p / (2 sqrt p) in [-1, 1] over columns 0..62, x = c/31 - 1,\n// so x = 0 is column 31 and every bin count that divides 63 has a middle bin.\n// The end columns hold half the width of the others.\nconst COLS = 63, MID = 31;\nconst WIDTH = new Float32Array(COLS).fill(1 / 31);\nWIDTH[0] = WIDTH[COLS - 1] = 0.5 / 31;\n// Rows: the readout on rows 1..5, the rain from row 7, the pile standing on\n// row 127. A density of 2/pi, the top of the semicircle, stands 50 rows tall;\n// no bar stands above 72.\nconst TOP = 7, BASE = 127, HS = 50 / (2 / PI), HMAX = 72;\n// Drops in rows and story seconds: they leave at V0 and gain G a second.\nconst V0 = 55, G = 170;\n\n// The three curves, each as the cubic f with y^2 = f(x) (after completing the\n// square, so 37a's y^2 + y = x^3 - x is (2y + 1)^2 = 4x^3 - 4x + 1), with the\n// odd primes of bad reduction to skip, and its law: 0 the semicircle, 1 half\n// the mass at 0 and half on 1/(pi sqrt(1 - x^2)).\nconst CURVES = [\n  { f: [4, 0, -4, 1], bad: 37, cm: 0 },\n  { f: [1, 0, -1, 0], bad: 0, cm: 1 },\n  { f: [1, 0, 0, 1], bad: 3, cm: 1 },\n];\n// The density of each law at x, without the point mass.\nconst law = (cm, x) => (cm ? 1 / (2 * PI * sqrt(max(1e-6, 1 - x * x))) : (2 / PI) * sqrt(max(0, 1 - x * x)));\n\n// The odd primes below 86,000, by a sieve: 8,400 of them, enough for the\n// 8,192 a run counts on every curve.\nconst PMAX = 86000;\nconst PRIMES = (() => {\n  const comp = new Uint8Array(PMAX), out = [];\n  for (let i = 3; i \u003c PMAX; i += 2) {\n    if (comp[i]) continue;\n    out.push(i);\n    for (let j = i * i; j \u003c PMAX; j += 2 * i) comp[j] = 1;\n  }\n  return Int32Array.from(out);\n})();\n\n// a_p = p + 1 - #E(F_p) = -(sum over x of the Legendre symbol (f(x) | p)),\n// exactly: a table of the squares mod p, then f(x) walked by its finite\n// differences, so the loop over x adds and never multiplies.\nconst CHI = new Int8Array(PMAX);\nfunction ap(p, c) {\n  CHI.fill(-1, 0, p);\n  CHI[0] = 0;\n  for (let i = 1, sq = 0, n = (p - 1) >> 1; i \u003c= n; i++) {\n    sq += 2 * i - 1;\n    if (sq >= p) sq -= p;\n    CHI[sq] = 1;\n  }\n  const m = (v) => ((v % p) + p) % p;\n  let f = m(c[3]), d1 = m(c[0] + c[1] + c[2]), d2 = m(6 * c[0] + 2 * c[1]), s = 0;\n  const d3 = m(6 * c[0]);\n  for (let x = 0; x \u003c p; x++) {\n    s += CHI[f];\n    f = f + d1 - p;\n    f += (f >> 31) & p;\n    d1 = d1 + d2 - p;\n    d1 += (d1 >> 31) & p;\n    d2 = d2 + d3 - p;\n    d2 += (d2 >> 31) & p;\n  }\n  return -s;\n}\n\n// Layers: the first 512 primes, then each layer as many as all before it.\n// The pile is drawn so the layers so far fill the outline, and when a layer\n// is in, the scale halves for the next.\nconst TARGET = [512, 1024, 2048, 4096, 8192], LAYERS = TARGET.length, LAST = TARGET[LAYERS - 1];\nconst layerOf = (i) => {\n  let k = 0;\n  while (i >= TARGET[k]) k++;\n  return k;\n};\n// How many primes have left the top by story time t of a run, piecewise linear.\nconst KNOTS = [[0, 0], [1.9, 512], [4.8, 1024], [9.3, 2048], [17.5, 4096], [41.5, LAST]];\nfunction countAt(t) {\n  for (let i = 1; i \u003c KNOTS.length; i++) {\n    const [t0, n0] = KNOTS[i - 1], [t1, n1] = KNOTS[i];\n    if (t \u003c t1) return n0 + ((n1 - n0) * max(0, t - t0)) / (t1 - t0);\n  }\n  return LAST;\n}\nfunction timeOf(n) {\n  for (let i = 1; i \u003c KNOTS.length; i++) {\n    const [t0, n0] = KNOTS[i - 1], [t1, n1] = KNOTS[i];\n    if (n \u003c n1) return t0 + ((t1 - t0) * (n - n0)) / (n1 - n0);\n  }\n  return KNOTS[KNOTS.length - 1][0];\n}\n// Bins on Knob 4: 7, 9, 21 or 63 bins, 9, 7, 3 or 1 columns wide.\nconst binWidth = (k) => (k \u003c -0.6 ? 9 : k \u003c -0.2 ? 7 : k \u003c 0.6 ? 3 : 1);\n\n// Digits 3 x 5 for the readout, a bit per LED from the top left, then a\n// minus sign, a p and an a.\nconst FONT = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7292, 0x7bef, 0x7bcf, 0x01c0, 0x7be4, 0x076b];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, bw: 3, curve: -1, t: 0, pi: 0, spawned: 0, landed: 0, sc: 1 / TARGET[0], done: -1, sink: -1,\n    lastP: 0, lastA: 0, shown: [0, 0], shownAt: -1,\n    cnt: new Float32Array(LAYERS * COLS), flash: new Float32Array(COLS), drops: [],\n    height: new Float32Array(COLS), binOf: new Int16Array(COLS), buf: new Float32Array(N * 3), pal: [],\n  };\n  begin(params.s, 0);\n}\n\n// A fresh run on curve k: an empty pile, the primes from 3.\nfunction begin(S, k) {\n  S.curve = k;\n  S.t = 0;\n  S.pi = 0;\n  S.spawned = 0;\n  S.landed = 0;\n  S.sc = 1 / TARGET[0];\n  S.done = -1;\n  S.sink = -1;\n  S.cnt.fill(0);\n  S.flash.fill(0);\n  S.drops.length = 0;\n  S.shownAt = -1;\n}\n\n// Each bar's height in rows, per column, from the counts and the scale.\nfunction heights(S) {\n  const w = S.bw, nb = COLS / w, cnt = S.cnt, h = S.height;\n  for (let b = 0; b \u003c nb; b++) {\n    let n = 0, dx = 0;\n    for (let c = b * w; c \u003c b * w + w; c++) {\n      dx += WIDTH[c];\n      for (let L = 0; L \u003c LAYERS; L++) n += cnt[L * COLS + c];\n    }\n    const v = (n * S.sc * HS) / dx;\n    for (let c = b * w; c \u003c b * w + w; c++) (h[c] = v), (S.binOf[c] = b);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.bw = binWidth(cl(k[3], -1, 1));\n  const curve = min(2, floor(cl(k[2], 0, 1) * 3));\n  if (curve !== S.curve) begin(S, curve);\n  if (input.btnPressed && input.btnPressed[0] && S.sink \u003c 0) S.sink = S.t;\n  const ds = (d * S.speed) / 2, C = CURVES[S.curve];\n  S.t += ds;\n  // New primes leave the top on the schedule, at most 60 a frame.\n  if (S.sink \u003c 0) {\n    const want = min(LAST, floor(countAt(S.t)));\n    for (let n = 0; S.spawned \u003c want && n \u003c 60; n++) {\n      let p = PRIMES[S.pi++];\n      if (p === C.bad) p = PRIMES[S.pi++];\n      const a = ap(p, C.f), x = a / (2 * sqrt(p));\n      S.drops.push({ c: round((x + 1) * MID), t0: timeOf(S.spawned), L: layerOf(S.spawned) });\n      S.spawned++;\n      S.lastP = p;\n      S.lastA = a;\n    }\n  }\n  // The readout keeps each prime for a sixth of a second.\n  if (S.t - S.shownAt > 1 / 6 && S.lastP) (S.shown = [S.lastP, S.lastA]), (S.shownAt = S.t);\n  // The scale: the layers landed so far fill the outline.\n  let e = 0;\n  while (e \u003c LAYERS - 1 && S.landed >= TARGET[e]) e++;\n  S.sc += (1 / TARGET[e] - S.sc) * (1 - exp(-ds / 0.18));\n  heights(S);\n  // Drops fall and land on their bar.\n  const keep = [];\n  for (const D of S.drops) {\n    const s = S.t - D.t0;\n    D.y = TOP + V0 * s + 0.5 * G * s * s;\n    D.v = V0 + G * s;\n    const floorY = S.sink >= 0 ? H + 12 : BASE + 1 - min(HMAX, S.height[D.c]);\n    if (D.y >= floorY) {\n      if (S.sink \u003c 0) {\n        S.cnt[D.L * COLS + D.c]++;\n        S.landed++;\n        S.flash[D.c] = 1;\n      }\n      continue;\n    }\n    keep.push(D);\n  }\n  S.drops = keep;\n  for (let c = 0; c \u003c COLS; c++) S.flash[c] *= exp(-ds / 0.12);\n  // A full run holds for 2.5 seconds, then the pile sinks in 1.5 and the\n  // count starts again.\n  if (S.landed >= LAST && S.done \u003c 0) S.done = S.t;\n  if (S.done >= 0 && S.sink \u003c 0 && S.t > S.done + 2.5) S.sink = S.t;\n  if (S.sink >= 0 && S.t > S.sink + 1.5) begin(S, S.curve);\n}\n\n// Layer colours round the wheel: at Hue 0 the first layer cyan, then azure,\n// blue, violet and rose for the later ones.\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  S.pal = [];\n  for (let L = 0; L \u003c LAYERS; L++) S.pal.push(hsv(0.5 + S.hue + 0.09 * L, 0.82, 1));\n}\n\nfunction glyph(buf, g, x0, y0, c, a) {\n  for (let j = 0; j \u003c 15; j++) {\n    if (!((g >> (14 - j)) & 1)) continue;\n    const x = x0 + (j % 3), y = y0 + floor(j / 3);\n    if (x \u003c 0 || x >= W) continue;\n    const o = 3 * (y * W + x);\n    for (let i = 0; i \u003c 3; i++) buf[o + i] = c[i] * a;\n  }\n}\n// A number in 3 x 5 digits ending at column x1 (right aligned), or starting at x0.\nfunction number(buf, v, x, y, right, c) {\n  const s = String(abs(v)), n = s.length + (v \u003c 0 ? 1 : 0);\n  let px = right ? x - 4 * n + 1 : x;\n  if (v \u003c 0) glyph(buf, FONT[10], px, y, c, 1), (px += 4);\n  for (const ch of s) glyph(buf, FONT[ch.charCodeAt(0) - 48], px, y, c, 1), (px += 4);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const buf = S.buf, pal = S.pal, cnt = S.cnt, w = S.bw, cm = CURVES[S.curve].cm;\n  buf.fill(0);\n  const sink = S.sink >= 0 ? (HMAX + 4) * ease((S.t - S.sink) / 1.5) : 0;\n  // The pile: each column's bar in its layers, oldest at the bottom; a bar\n  // too tall for the panel keeps its layers in proportion under the ceiling.\n  // Every other bin is a shade darker so the bins read apart.\n  const cum = new Float32Array(LAYERS);\n  for (let c = 0; c \u003c COLS; c++) {\n    const b = S.binOf[c], h0 = S.height[c];\n    if (h0 \u003c= 0.02) continue;\n    let tot = 0;\n    for (let L = 0; L \u003c LAYERS; L++) {\n      let n = 0;\n      for (let cc = b * w; cc \u003c b * w + w; cc++) n += cnt[L * COLS + cc];\n      tot += n;\n      cum[L] = tot;\n    }\n    const h = min(h0, HMAX), k = h / tot, shade = w > 1 && b % 2 ? 0.8 : 1;\n    const top = floor(h - 1e-4), lift = h0 > HMAX ? 0.75 : 0.25 + 0.6 * S.flash[c];\n    for (let r = 0, L = 0; r \u003c= top; r++) {\n      const y = BASE - r + round(sink);\n      if (y \u003c 0 || y >= H) continue;\n      while (L \u003c LAYERS - 1 && cum[L] * k \u003c= r + 0.5) L++;\n      const col = pal[L], a = (r \u003c top ? 1 : h - r) * shade, o = 3 * (y * W + c);\n      const wt = r === top ? lift : 0;\n      for (let i = 0; i \u003c 3; i++) buf[o + i] = (col[i] * (1 - wt) + wt) * a;\n    }\n  }\n  // The outline of the law in pale cream, brighter where it crosses a bar.\n  // A curve with complex multiplication also gets a dotted line up the middle\n  // for the half of its primes that sits at x = 0.\n  const line = [1, 0.86, 0.62];\n  let prev = -1;\n  for (let c = 0; c \u003c COLS; c++) {\n    const y = round(BASE + 1 - min(HMAX + 2, HS * law(cm, c / MID - 1))) + round(sink);\n    const y0 = prev \u003c 0 ? y : prev \u003c y ? prev + 1 : y, y1 = prev \u003c 0 ? y : prev > y ? prev - 1 : y;\n    for (let yy = min(y0, y1); yy \u003c= max(y0, y1); yy++) {\n      if (yy \u003c TOP || yy >= H) continue;\n      const o = 3 * (yy * W + c), inside = buf[o] + buf[o + 1] + buf[o + 2] > 0.3;\n      for (let i = 0; i \u003c 3; i++) buf[o + i] = inside ? buf[o + i] * 0.45 + line[i] * 0.55 : line[i] * 0.34;\n    }\n    prev = y;\n  }\n  if (cm)\n    for (let y = BASE + 1 - HMAX - 2 + round(sink); y \u003c= BASE; y += 3) {\n      if (y \u003c TOP || y >= H) continue;\n      const o = 3 * (y * W + MID);\n      if (buf[o] + buf[o + 1] + buf[o + 2] \u003c 0.3) for (let i = 0; i \u003c 3; i++) buf[o + i] = line[i] * 0.34;\n    }\n  // Drops: a bright head and a short tail, in the colour of their layer.\n  for (const D of S.drops) {\n    if (D.y === undefined) continue;\n    const col = pal[D.L], tail = min(7, 2 + D.v * 0.03), hy = floor(D.y);\n    for (let j = 0; j \u003c= tail; j++) {\n      const y = hy - j;\n      if (y \u003c TOP || y >= H) continue;\n      const a = j === 0 ? 1 : 0.85 * (1 - j / (tail + 1)) ** 1.5, wt = j === 0 ? 0.55 : j === 1 ? 0.2 : 0, o = 3 * (y * W + D.c);\n      for (let i = 0; i \u003c 3; i++) buf[o + i] = max(buf[o + i], (col[i] * (1 - wt) + wt) * a);\n    }\n  }\n  // The readout: the newest prime at the left, its a_p at the right.\n  if (S.shown[0]) {\n    const grey = [0.62, 0.62, 0.62], lab = pal[layerOf(min(LAST - 1, S.spawned))];\n    glyph(buf, FONT[11], 1, 1, lab, 1);\n    number(buf, S.shown[0], 6, 1, false, grey);\n    glyph(buf, FONT[12], 62 - 4 * (String(abs(S.shown[1])).length + (S.shown[1] \u003c 0 ? 1 : 0)) - 4, 1, lab, 1);\n    number(buf, S.shown[1], 62, 1, true, grey);\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) display.setPixel(x, y, round(min(1, buf[3 * p]) * 255), round(min(1, buf[3 * p + 1]) * 255), round(min(1, buf[3 * p + 2]) * 255));\n}\n","tower-stair":"// ===== Patternflow pattern =====\n// Title:   Tower Stair\n// Family:  halloween\n// Idea:    A hooded climber carries a candle up the spiral stair of a round stone tower cut open to show its inside, the flame lighting the curved wall and throwing his huge shadow round it as he winds up past slit windows full of purple night, until a draft at the top blows the candle out and two green eyes look in at the window in the dark; then the candle is lit again at the foot of the stair.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Turns=3..8, Reach=-1..1\n//\n// Knob 1: Hue. The moonlight on the stone and the night in the windows, through the cold colours: purple at 0, indigo at 0.3, blue at 0.6, green at 1. The flame stays orange and the eyes green.\n// Knob 2: Speed. At 2 the climb from the foot to the top takes 10 seconds with 3 turns and 16 with 8, then the draft and the dark take 2.8 seconds before a match is struck at the foot again; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Turns. How many times the stair winds round in the panel's height, from 3 to 8, and the whole tower is rebuilt at once. At 3 a turn has 15 steps and the climber stands 21 LEDs tall; at 8 the stair is a tight coil of 7 steps a turn and he is 7 LEDs tall.\n// Knob 4: Reach. How far the candle light carries before it falls to half: 14 LEDs at -1, a small warm pool round the climber; 29 at the opening 0.06; 56 at 1, so the wall across the well lights up and the shadow stands out on it.\n// Buttons: K1 tap blows the candle out where it is.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\nconst ang = (x, z) => {\n  const a = atan2(x, z);\n  return a \u003c 0 ? a + TAU : a;\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The tower in LEDs: its axis at x = 32, the wall's inside radius, the\n// treads' inner edge and the line the climber walks. The view looks down a\n// little, so a point nearer by z sits K lower: screen y = YB - Y + K z.\n// Angles a run from the front (z toward us) round to the right.\nconst RW = 30, RIN = 16, WALK = 23, K = 0.4, YB = 115;\n// Surfaces: wall, tread top, riser, tread end, inner edge, floor, the cut wall.\nconst WALL = 1, TOP = 2, RISE = 3, END = 4, EDGE = 5, FLOOR = 6, CUT = 7;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, turns: 0, hue: -1, speed: 2, reach: 29, phase: 0, u: 0.05, tp: 0, flare: 0.5, flick: 1,\n    kind: new Uint8Array(N), pos: new Float32Array(N * 3), nrm: new Float32Array(N * 3), alb: new Float32Array(N), amb: new Float32Array(N),\n    eh: new Float32Array(N), win: new Float32Array(N), buf: new Float32Array(N * 3), fz: new Float32Array(N), fl: new Float32Array(N), wins: [],\n  };\n}\n\n// The tower for this many turns. The stair is a solid helix of steps: step\n// j rises rise * j and a slab th thick sits under each tread. Every LED's\n// first surface along its view line is found once, stepping back from the\n// front, with its place, its facing, its stone and its share of moonlight.\nfunction build(S) {\n  const T = S.turns, pitch = 118 / T, st = cl(round(pitch / 2.6), 7, 16), rise = pitch / st, ds = TAU / st, th = rise + 1.5;\n  Object.assign(S, { pitch, rise, th, ds });\n  const { kind, pos, nrm, alb, amb, eh, win } = S;\n  // Two slit windows a turn at the back, half way up the corridor.\n  const wins = [];\n  for (let n = 0; n \u003c= T; n++)\n    for (const f of [0.38, 0.62]) {\n      const a = f * TAU, y = pitch * (n + f) + th + 0.45 * (pitch - th), hh = cl(0.15 * pitch, 3, 6.5), sy = YB - y + K * RW * cos(a);\n      if (sy > hh + 3 && sy \u003c H - 20) wins.push({ a, y, hh, sx: 32 + RW * sin(a), sy, n: 0 });\n    }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const wx = x + 0.5 - 32, c = YB - (y + 0.5);\n      let k = 0, Y = c, z = 0, nx = 0, ny = 0, nz = 1, e = 0, j = 0, aa = 0;\n      win[p] = 0;\n      if (abs(wx) >= RW) k = CUT;\n      else {\n        const zw = sqrt(RW * RW - wx * wx);\n        let pj = -1, well = false;\n        for (z = zw; z > -zw; z -= 0.25) {\n          Y = c + K * z;\n          if (Y \u003c 0) {\n            (z = -c / K), (Y = 0), (k = FLOOR), (nz = 0), (ny = 1);\n            break;\n          }\n          const r2 = wx * wx + z * z;\n          if (r2 \u003c RIN * RIN) {\n            (well = true), (pj = -1);\n            continue;\n          }\n          aa = ang(wx, z);\n          j = floor(aa / ds);\n          const m = floor((Y - rise * j) / pitch), base = rise * j + pitch * m;\n          if (m >= 0 && Y - base \u003c th) {\n            const r = sqrt(r2);\n            if (z === zw) (k = END), (nx = wx / r), (ny = 0), (nz = z / r);\n            else if (well) (k = EDGE), (nx = -wx / r), (ny = 0), (nz = -z / r);\n            else if (pj >= 0 && pj !== j) (k = RISE), (nx = -cos(aa)), (ny = 0), (nz = sin(aa));\n            else (k = TOP), (ny = 1), (nz = 0);\n            e = Y - base - th;\n            j += st * m;\n            break;\n          }\n          (pj = j), (well = false);\n        }\n        if (!k) {\n          (z = -zw), (Y = c + K * z), (k = WALL), (nx = -wx / RW), (ny = 0), (nz = zw / RW);\n          aa = ang(wx, z);\n          e = (((Y - rise * floor(aa / ds) - th) % pitch) + pitch) % pitch;\n          for (let i = 0; i \u003c wins.length; i++) {\n            const w = wins[i], da = RW * wrap(aa - w.a), dy = Y - w.y;\n            if (abs(dy) \u003c w.hh + 2 && abs(da) \u003c 3.6 - (0.4 * abs(dy)) / w.hh) win[p] = -1;\n            if (abs(dy) \u003c w.hh - (abs(da) > 1 ? 0.8 : 0) && abs(da) \u003c 1.6) {\n              // Where a sliver of moon would be: a crescent opening left.\n              const my = abs(dy - 0.3 * w.hh), moon = (da > 0.5 && my \u003c 1.6) || (da > -0.5 && da \u003c= 0.5 && abs(my - 2) \u003c 0.6);\n              win[p] = 0.5 + 0.5 * cl((dy + w.hh) / (2 * w.hh), 0, 1) + (moon ? 10 : 0);\n              // A slit LED is never lit, so it keeps its window's number here.\n              w.n++;\n              e = i;\n            }\n          }\n        }\n      }\n      kind[p] = k;\n      pos.set([wx, Y, z], 3 * p);\n      nrm.set([nx, ny, nz], 3 * p);\n      eh[p] = e;\n      // Stone: wall courses 4 LEDs high with blocks 7 long, mortar darker;\n      // each step its own stone; flags on the floor.\n      let al = 1;\n      if (k === WALL || k === CUT) {\n        const s = k === CUT ? (wx > 0 ? 16 : 2) : RW * aa, row = floor(Y / 4), off = s + (row & 1) * 3.5, blk = floor(off / 7);\n        al = Y - 4 * row \u003c 0.9 || off - 7 * blk \u003c 0.9 ? 0.62 : 0.85 + 0.3 * hash(row * 131 + blk);\n      } else if (k === FLOOR) al = abs(wx % 8) \u003c 0.7 || abs(z % 6) \u003c 0.6 ? 0.6 : 0.9 + 0.2 * hash(floor(wx / 8) * 7 + floor(z / 6));\n      else al = 0.85 + 0.3 * hash(j * 17 + 3) - (k === TOP && aa - ds * floor(aa / ds) > ds - 0.06 ? 0.25 : 0);\n      alb[p] = al;\n      // Moonlight: tread tops brightest and the steps in front more than\n      // those behind, risers and the wall darker, a window's splay in shadow.\n      const front = 0.75 + 0.25 * (z / RW);\n      amb[p] = win[p] \u003c 0 ? 0.5 : k === TOP ? 1.9 * front : k === END ? 1.3 : k === EDGE ? 1.15 : k === RISE ? 0.9 * front : k === FLOOR ? 0.9 : k === CUT ? 1.2 : 0.8;\n    }\n  // The windows the stair leaves in sight, highest first: the eyes come to\n  // the top one, the moon shows in the next.\n  const seen = wins.filter((w) => w.n > 5).sort((u, v) => v.y - u.y), moon = wins.indexOf(seen[1]);\n  for (let p = 0; p \u003c N; p++) if (win[p] >= 10) win[p] = eh[p] === moon ? 3 : win[p] - 10;\n  S.wins = seen;\n}\n\n// Is the way from the candle to this point clear of the stair? The stair\n// is solid, so on the candle's side of the well a point is lit only inside\n// the candle's own turn of the corridor; across the well the light must\n// also clear the treads at both ends of its path. e is the point's height\n// above the tread under it.\nfunction clear(S, C, px, pY, pz, e) {\n  const dx = px - C[0], dz = pz - C[2], L2 = dx * dx + dz * dz || 1e-6, D = sqrt(L2), room = S.pitch - S.th;\n  const b = -(C[0] * dx + C[2] * dz) / L2, t = cl(b, 0, 1), mx = C[0] + t * dx, mz = C[2] + t * dz;\n  if (mx * mx + mz * mz >= RIN * RIN) {\n    const f = pY - C[4] - (S.pitch * wrap(ang(px, pz) - C[3])) / TAU;\n    return f > -0.7 && f \u003c room + 0.3;\n  }\n  const s = (pY - C[1]) / D, cc = C[0] * C[0] + C[2] * C[2] - RIN * RIN, disc = sqrt(max(0, b * b - cc / L2));\n  const h1 = C[1] - C[4] + s * (b - disc) * D, h2 = e - s * (1 - b - disc) * D;\n  return h1 > 0 && h1 \u003c room && h2 > -0.7 && h2 \u003c room + 0.3;\n}\n\n// Shortest distance between segments PQ and AB, squared; segT keeps where\n// along AB it falls, for a tapered capsule's radius there.\nlet segT = 0;\nfunction segDist2(px, py, pz, qx, qy, qz, ax, ay, az, bx, by, bz) {\n  const d1x = qx - px, d1y = qy - py, d1z = qz - pz, d2x = bx - ax, d2y = by - ay, d2z = bz - az, rx = px - ax, ry = py - ay, rz = pz - az;\n  const a = d1x * d1x + d1y * d1y + d1z * d1z, e = d2x * d2x + d2y * d2y + d2z * d2z || 1e-6, f = d2x * rx + d2y * ry + d2z * rz;\n  const c = d1x * rx + d1y * ry + d1z * rz, bd = d1x * d2x + d1y * d2y + d1z * d2z, den = a * e - bd * bd;\n  let s = den > 1e-9 ? cl((bd * f - c * e) / den, 0, 1) : 0, t = (bd * s + f) / e;\n  if (t \u003c 0) (t = 0), (s = cl(-c / a, 0, 1));\n  else if (t > 1) (t = 1), (s = cl((bd - c) / a, 0, 1));\n  const ux = px + d1x * s - ax - d2x * t, uy = py + d1y * s - ay - d2y * t, uz = pz + d1z * s - az - d2z * t;\n  segT = t;\n  return ux * ux + uy * uy + uz * uz;\n}\n\n// The climber at progress u along the stair: tapered capsules [ax, ay, az,\n// bx, by, bz, ra, rb] in the tower's frame (x right, Y up, z toward us), and\n// the flame C = [x, Y, z, angle, height of the tread under it].\nfunction climber(S) {\n  const pitch = S.pitch, hgt = 0.6 * (pitch - S.th);\n  const a0 = 0.25, a1 = (TAU * (108 - 1.05 * hgt - S.th)) / pitch, a = a0 + (a1 - a0) * S.u;\n  const walk = (a * WALK) / (0.2 * hgt), fy = (pitch * a) / TAU - 0.5 * S.rise + S.th + 0.04 * hgt * abs(sin(walk));\n  const sa = sin(a), ca = cos(a);\n  // Local axes: forward along the stair, out toward the wall, up.\n  const at = (f, o, u) => [(WALK + o * hgt) * sa + f * hgt * ca, fy + u * hgt, (WALK + o * hgt) * ca - f * hgt * sa];\n  const caps = [];\n  const cap = (p, q, ra, rb) => caps.push([...p, ...q, ra * hgt, rb * hgt]);\n  const sw = 0.03 * sin(walk);\n  // A cloak that widens to the hem, square shoulders, a hood with a point.\n  cap(at(-0.03, 0, 0.1), at(0.01, 0, 0.58), 0.21, 0.11);\n  cap(at(0.02, 0.07, 0.68), at(0.02, -0.07, 0.68), 0.09, 0.09);\n  cap(at(0.06, 0, 0.84), at(0.07, 0, 0.85), 0.1, 0.1);\n  cap(at(0.03, 0, 0.88), at(-0.09, 0, 1.06), 0.08, 0.012);\n  // The arm reaches forward and in, holding the candle over the well side.\n  const hand = at(0.2 + sw, -0.22, 0.64);\n  cap(at(0.03, -0.08, 0.7), hand, 0.045, 0.035);\n  const C = [hand[0], hand[1] + 0.1 * hgt + 1.5, hand[2], 0, 0];\n  C[3] = ang(C[0], C[2]);\n  C[4] = fy + (pitch * wrap(C[3] - a)) / TAU;\n  let mx = 0, my = 0, mz = 0;\n  for (const c of caps) (mx += c[0] + c[3]), (my += c[1] + c[4]), (mz += c[2] + c[5]);\n  S.P = { a, hgt, caps, hand, C, mid: [mx / 10, my / 10, mz / 10], rad: 0.78 * hgt };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.reach = 28 * 2 ** cl(k[3], -1, 1);\n  const T = round(cl(k[2], 3, 8));\n  if (T !== S.turns) {\n    S.turns = T;\n    build(S);\n  }\n  const ds = (d * S.speed) / 2, D = 10 * sqrt(T / 3);\n  S.t += ds;\n  S.tp += ds;\n  S.flare = max(0, S.flare - ds);\n  if (input.btnPressed && input.btnPressed[0] && S.phase === 0) (S.phase = 1), (S.tp = 0.25);\n  // 0 climbing, 1 a draft bends the flame, 2 dark with eyes at the window.\n  if (S.phase === 0) {\n    S.u = min(1, S.u + ds / D);\n    if (S.u >= 1) (S.phase = 1), (S.tp = 0);\n  } else if (S.phase === 1 && S.tp > 0.6) (S.phase = 2), (S.tp = 0);\n  else if (S.phase === 2 && S.tp > 2.2) (S.phase = 0), (S.tp = 0), (S.u = 0), (S.flare = 0.5);\n  const fl = 0.9 + 0.06 * sin(S.t * 23) + 0.04 * sin(S.t * 37 + 1);\n  S.flick = S.phase === 0 ? fl : S.phase === 1 ? fl * (1 - sm(S.tp / 0.6)) * (0.6 + 0.4 * sin(S.t * 61)) : 0;\n  climber(S);\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    S.tint = hsv(0.76 - 0.36 * hue, 0.68, 1);\n    S.sky = hsv(0.76 - 0.36 * hue, 0.75, 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const { kind, pos, nrm, alb, amb, eh, win, buf, fz, fl, P, tint, sky } = S;\n  const C = P.C, lit = S.flick, R = S.reach, cut = 3 * R, caps = P.caps, LC = [1, 0.55, 0.2];\n  for (let p = 0; p \u003c N; p++) {\n    const q = 3 * p, w = win[p];\n    if (w > 0) {\n      // The night through a slit, deeper at the top, and a sliver of moon.\n      const v = w > 2 ? 1 : 0.2 + 0.5 * w;\n      buf[q] = w > 2 ? 0.95 : sky[0] * v;\n      buf[q + 1] = w > 2 ? 0.9 : sky[1] * v;\n      buf[q + 2] = w > 2 ? 0.7 : sky[2] * v;\n      continue;\n    }\n    const k = kind[p], a = alb[p] * amb[p] * 0.2;\n    let r = tint[0] * a, g = tint[1] * a, b = tint[2] * a;\n    if (lit > 0.01) {\n      const px = pos[q], py = pos[q + 1], pz = pos[q + 2], lx = C[0] - px, ly = C[1] - py, lz = C[2] - pz, dd = sqrt(lx * lx + ly * ly + lz * lz) || 1;\n      if (dd \u003c cut) {\n        const ln = (nrm[q] * lx + nrm[q + 1] * ly + nrm[q + 2] * lz) / dd;\n        let li = (sm((cut - dd) / R) * (0.2 + 0.8 * max(0, ln))) / (1 + (dd / R) ** 2);\n        if (ln \u003c -0.3) li = 0;\n        if (li > 0.004 && k !== CUT && !clear(S, C, px, py, pz, eh[p])) li = 0;\n        if (li > 0.004) {\n          // The climber's shadow: does the way to the flame pass through him?\n          const mx = P.mid[0] - px, my = P.mid[1] - py, mz = P.mid[2] - pz, tt = cl((mx * lx + my * ly + mz * lz) / (dd * dd), 0, 1);\n          const ex = mx - lx * tt, ey = my - ly * tt, ez = mz - lz * tt;\n          if (ex * ex + ey * ey + ez * ez \u003c P.rad * P.rad)\n            for (const c of caps) {\n              const d2 = segDist2(px, py, pz, C[0], C[1], C[2], c[0], c[1], c[2], c[3], c[4], c[5]), rr = c[6] + (c[7] - c[6]) * segT;\n              if (d2 \u003c rr * rr) li = 0;\n            }\n        }\n        li *= lit * 1.5 * alb[p];\n        r += LC[0] * li;\n        g += LC[1] * li;\n        b += LC[2] * li;\n      }\n    }\n    if (w \u003c 0) (r *= 0.55), (g *= 0.55), (b *= 0.55);\n    buf[q] = r;\n    buf[q + 1] = g;\n    buf[q + 2] = b;\n  }\n  // The climber: a dark cloak, the side toward the flame lit warm.\n  fz.fill(-99);\n  for (const c of caps) {\n    const sx0 = 32 + c[0], sy0 = YB - c[1] + K * c[2], sx1 = 32 + c[3], sy1 = YB - c[4] + K * c[5], ra = c[6], rb = c[7], rr = max(ra, rb);\n    const ex = sx1 - sx0, ey = sy1 - sy0, e2 = ex * ex + ey * ey || 1e-6;\n    for (let y = max(0, floor(min(sy0, sy1) - rr)); y \u003c= min(H - 1, ceil(max(sy0, sy1) + rr)); y++)\n      for (let x = max(0, floor(min(sx0, sx1) - rr)); x \u003c= min(W - 1, ceil(max(sx0, sx1) + rr)); x++) {\n        const qx = x + 0.5 - sx0, qy = y + 0.5 - sy0, u = cl((qx * ex + qy * ey) / e2, 0, 1), hx = qx - u * ex, hy = qy - u * ey, h2 = hx * hx + hy * hy, ru = ra + (rb - ra) * u;\n        if (h2 > ru * ru) continue;\n        const p = y * W + x, hz = sqrt(ru * ru - h2), zz = c[2] + (c[5] - c[2]) * u + hz;\n        if (zz \u003c pos[3 * p + 2] - 1 || zz \u003c fz[p]) continue;\n        fz[p] = zz;\n        const wxp = c[0] + (c[3] - c[0]) * u + hx, wyp = c[1] + (c[4] - c[1]) * u - hy;\n        const lx = C[0] - wxp, ly = C[1] - wyp, lz = C[2] - zz, dd = sqrt(lx * lx + ly * ly + lz * lz) || 1;\n        fl[p] = max(0, (hx * lx - hy * ly + hz * lz) / (ru * dd)) / (1 + (dd / R) ** 2);\n      }\n  }\n  for (let p = 0; p \u003c N; p++)\n    if (fz[p] > -99) {\n      const q = 3 * p, v = fl[p] * lit;\n      buf[q] = 0.035 + 1.1 * v;\n      buf[q + 1] = 0.02 + 0.55 * v;\n      buf[q + 2] = 0.05 + 0.2 * v;\n    }\n  // The hand, the candle and its flame, hidden where the climber is in\n  // front of them, and a halo round the flame either way.\n  const sx = (v) => 32 + v[0], sy = (v) => YB - v[1] + K * v[2], hx = sx(P.hand), hy = sy(P.hand), fx = sx(C), fy = sy(C), front = C[2] + 1;\n  const put = (x, y, r, g, b) => {\n    (x = floor(x)), (y = floor(y));\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = y * W + x, q = 3 * p;\n    if (fz[p] > front || pos[3 * p + 2] > front + 0.5) return;\n    buf[q] = r;\n    buf[q + 1] = g;\n    buf[q + 2] = b;\n  };\n  const glow = (cx, cy, rad, amp, col) => {\n    for (let y = max(0, floor(cy - rad)); y \u003c= min(H - 1, ceil(cy + rad)); y++)\n      for (let x = max(0, floor(cx - rad)); x \u003c= min(W - 1, ceil(cx + rad)); x++) {\n        const dd = Math.hypot(x + 0.5 - cx, y + 0.5 - cy);\n        if (dd > rad) continue;\n        const v = amp * (1 - dd / rad) ** 2, q = 3 * (y * W + x);\n        buf[q] += col[0] * v;\n        buf[q + 1] += col[1] * v;\n        buf[q + 2] += col[2] * v;\n      }\n  };\n  if (S.phase \u003c 2) {\n    const sk = 0.25 + 0.6 * lit;\n    put(hx, hy, sk, 0.6 * sk, 0.42 * sk);\n    put(hx + (fx > hx ? -1 : 1), hy, 0.8 * sk, 0.48 * sk, 0.33 * sk);\n    for (let y = floor(hy) - 1; y > floor(fy); y--) put(fx, y, 0.75, 0.7, 0.6);\n  }\n  if (lit > 0.01) {\n    glow(fx, fy - 0.5, 8, 0.5 * lit, LC);\n    const sway = S.phase === 1 ? 1.4 * sin(S.t * 30) : 0.4 * sin(S.t * 11);\n    put(fx, fy, 1, 0.95 * lit, 0.6 * lit);\n    put(fx + sway * 0.5, fy - 1, 1, 0.75 * lit, 0.25 * lit);\n    put(fx + sway, fy - 2, 0.9 * lit, 0.4 * lit, 0.05);\n  } else if (S.phase === 2 && S.tp \u003c 1)\n    // A thread of smoke from the wick.\n    for (let i = 0; i \u003c 6; i++) put(fx + 1.2 * sin(S.tp * 6 + i), fy - 1 - i - 4 * S.tp, 0.3 * (1 - S.tp), 0.28 * (1 - S.tp), 0.3 * (1 - S.tp));\n  // The match struck at the foot of the stair before each climb.\n  if (S.flare > 0) glow(fx, fy - 1, 3 + 8 * (0.5 - S.flare), 2 * S.flare, [1, 0.85, 0.55]);\n  // Two green eyes at the top window while it is dark.\n  if (S.phase === 2 && S.tp > 0.3 && S.tp \u003c 2 && S.wins.length) {\n    const w = S.wins[0];\n    const e = sm((S.tp - 0.3) / 0.3) * (1 - sm((S.tp - 1.7) / 0.3)) * (abs(S.tp - 1.15) \u003c 0.07 ? 0.1 : 1);\n    glow(w.sx, w.sy - 1, 6, 0.2 * e, [0.3, 1, 0.3]);\n    // A pale face fills the slit behind them.\n    for (let y = floor(w.sy - 3); y \u003c= w.sy + 2; y++)\n      for (let x = floor(w.sx - 1.5); x \u003c= w.sx + 1; x++) {\n        const q = 3 * (y * W + x);\n        if (y >= 0 && x >= 0 && x \u003c W) (buf[q] += 0.14 * e), (buf[q + 1] += 0.17 * e), (buf[q + 2] += 0.14 * e);\n      }\n    for (const dx of [-1, 1]) {\n      const x = floor(w.sx + dx), y = floor(w.sy - 1), q = 3 * (y * W + x);\n      if (x >= 0 && x \u003c W && y >= 0) (buf[q] = 0.3 * e), (buf[q + 1] = e), (buf[q + 2] = 0.2 * e);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const q = 3 * p;\n      display.setPixel(x, y, round(cl(buf[q], 0, 1) * 255), round(cl(buf[q + 1], 0, 1) * 255), round(cl(buf[q + 2], 0, 1) * 255));\n    }\n}\n","zombie-shamble":"// ===== Patternflow pattern =====\n// Title:   Zombie Shamble\n// Family:  halloween\n// Idea:    A horde of zombies shambles toward you down a foggy country lane at night, black figures rim-lit by a sickly green glow behind the horizon with their arms reaching and heads lolling, small in the far fog and growing until the nearest fill the panel and come apart in the mist.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Horde=5..18, Fog=0..1\n//\n// Knob 1: Hue. The glow, the fog and the green of the rims and eyes together: toxic green at 0, sea green at 0.25, sky blue at 0.5, blue violet at 0.75 and magenta at 1, while the sky leans from purple to indigo and back.\n// Knob 2: Speed. At 2 each zombie closes a tenth of its distance a second, so it grows on the panel at one steady rate, at a little under two steps a second; the nearest, 1.95 m off at the start, begins to come apart in the fog two seconds later and is gone by about six. At 0.2 ten times slower with short shuffling steps, at 3 half as fast again with longer strides and harder lurches. The fog drifts on the same clock.\n// Knob 3: Horde. How many walk at once, 5 to 18. They open spread from 2 m to 26 m, nearest first, a bigger horde as a wider wall of near ones, and each count puts its nearest zombie in a different place. Three in five drag a leg, and two in five have eyes that glow.\n// Knob 4: Fog. How deep and thick the ground fog lies: at 0 a mist 0.3 m deep that hides the far lane and the feet of the far zombies, at 1 a bank 1.35 m deep and nearly six times as thick that swallows them to the chest.\n// Buttons: K1 tap snaps every head upright to look at you, face turned to the eye and eyes lit green, for about two and a half seconds.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Value noise on a 256 x 256 lattice.\nconst NT = new Float32Array(65536);\nfor (let i = 0; i \u003c 65536; i++) NT[i] = hash(i * 7 + 3);\nfunction vn(x, y) {\n  const xi = floor(x), yi = floor(y);\n  let fx = x - xi, fy = y - yi;\n  fx = fx * fx * (3 - 2 * fx);\n  fy = fy * fy * (3 - 2 * fy);\n  const x0 = xi & 255, x1 = (xi + 1) & 255, y0 = (yi & 255) \u003c\u003c 8, y1 = ((yi + 1) & 255) \u003c\u003c 8;\n  const a = NT[y0 + x0], b = NT[y0 + x1], c = NT[y1 + x0], d = NT[y1 + x1];\n  return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;\n}\n\n// The eye: horizon row, vanishing column, LEDs per metre at one metre and\n// eye height in metres. A point x metres to the side, h up and z ahead\n// lands at column VX + F x / z and row YH + F (HC - h) / z.\nconst YH = 32, VX = 32, F = 100, HC = 1.45;\n// The glow behind the horizon stands a little right of the lane.\nconst GX = 36;\n// Half the lane's width; how far off zombies appear, where they are gone\n// and where they start to come apart in the fog; the most there can be.\nconst ROAD = 1.1, ZMAX = 26, ZOUT = 1.05, ZFADE = 1.6, MAXZ = 18;\n// Each zombie keeps to its line x of the lane until about ZC metres out,\n// then bears in on the eye, so from there on it holds its column and only\n// grows.\nconst ZC = 5, column = (Z) => VX + (F * Z.x) / sqrt(Z.z * Z.z + ZC * ZC);\n\n// The glow's reach on the panel, the same every frame.\nconst GL = new Float32Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - GX, dy = y + 0.5 - YH;\n    GL[y * W + x] = exp(-(dx * dx) / 900 - (dy * dy) / 110) * 0.8 + exp(-(dx * dx) / 3000 - (dy * dy) / 700) * 0.35;\n  }\n\n// ---- Scenery: dead trees, a fence and a far treeline, drawn once as\n// coverage with the depth of what covers each LED.\nfunction capsuleInto(A, Z, x0, y0, x1, y1, r0, r1, z0, z1) {\n  const ex = x1 - x0, ey = y1 - y0, ll = ex * ex + ey * ey || 1e-9, R = max(r0, r1) + 1;\n  const X0 = max(0, floor(min(x0, x1) - R)), X1 = min(W - 1, floor(max(x0, x1) + R));\n  const Y0 = max(0, floor(min(y0, y1) - R)), Y1 = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = Y0; y \u003c= Y1; y++)\n    for (let x = X0; x \u003c= X1; x++) {\n      let c = 0, uu = 0;\n      for (let j = 0; j \u003c 3; j++)\n        for (let i = 0; i \u003c 3; i++) {\n          const px = x + (i + 0.5) / 3 - x0, py = y + (j + 0.5) / 3 - y0, u = cl((px * ex + py * ey) / ll, 0, 1);\n          const dx = px - u * ex, dy = py - u * ey;\n          if (dx * dx + dy * dy \u003c= (r0 + (r1 - r0) * u) ** 2) c++, (uu = u);\n        }\n      if (!c) continue;\n      const q = y * W + x, zz = z0 + (z1 - z0) * uu;\n      A[q] = max(A[q], c / 9);\n      if (zz \u003c Z[q]) Z[q] = zz;\n    }\n}\n// A crooked limb in the tree's own plane, in metres: from (x, h) at angle a\n// from upright, len long, radius r, walked in short kinked steps that give\n// off side limbs, mostly toward the lane (side tow).\nfunction limb(A, Z, bx, z, x, h, a, len, r, depth, seed, tow) {\n  const s = F / z, n = max(2, round(len / 0.4));\n  for (let i = 0; i \u003c n; i++) {\n    const k = seed * 13 + i * 7, l = len / n, r0 = r * (1 - (0.5 * i) / n), r1 = r * (1 - (0.5 * (i + 1)) / n);\n    a += (hash(k) - 0.5) * 0.9;\n    const x2 = x + l * sin(a), h2 = h + l * cos(a);\n    capsuleInto(A, Z, VX + s * (bx + x), YH + s * (HC - h), VX + s * (bx + x2), YH + s * (HC - h2), max(0.3, r0 * s), max(0.28, r1 * s), z, z);\n    if (depth > 0 && i > 0 && hash(k + 1) \u003c 0.55) {\n      const side = hash(k + 2) \u003c 0.65 ? tow : -tow;\n      limb(A, Z, bx, z, x2, h2, a + side * (0.6 + 0.6 * hash(k + 3)), (len - i * l) * (0.45 + 0.35 * hash(k + 4)), r1 * 0.6, depth - 1, k + 5, tow);\n    }\n    (x = x2), (h = h2);\n  }\n}\nfunction blur(A) {\n  const T = new Float32Array(N);\n  for (let q = 0; q \u003c N; q++) {\n    const x = q % W;\n    T[q] = (2 * A[q] + A[x > 0 ? q - 1 : q] + A[x \u003c W - 1 ? q + 1 : q]) / 4;\n  }\n  for (let q = 0; q \u003c N; q++) A[q] = (2 * T[q] + T[q >= W ? q - W : q] + T[q \u003c N - W ? q + W : q]) / 4;\n}\nfunction scenery() {\n  const A = new Float32Array(N), Z = new Float32Array(N).fill(1e9);\n  // Trees: side, distance, lean, height, seed.\n  const trees = [[-2.3, 8.5, 0.15, 4.2, 1], [2.5, 11, -0.12, 4.4, 2], [-2.6, 16, 0.1, 4.6, 3], [2.9, 23, -0.1, 4.2, 4], [-3.1, 33, 0.05, 4.8, 5], [3.4, 48, -0.1, 4.5, 6]];\n  for (const [bx, z, lean, ht, sd] of trees) {\n    const s = F / z, tow = bx \u003c 0 ? 1 : -1;\n    // Root flare, then the trunk and its crown.\n    capsuleInto(A, Z, VX + s * (bx - 0.25), YH + s * HC, VX + s * bx, YH + s * (HC - 0.45), 0.18 * s, 0.17 * s, z, z);\n    capsuleInto(A, Z, VX + s * (bx + 0.25), YH + s * HC, VX + s * bx, YH + s * (HC - 0.45), 0.14 * s, 0.17 * s, z, z);\n    limb(A, Z, bx, z, 0, 0.3, lean, ht, 0.13, 3, sd * 31, tow);\n  }\n  // The fence on the left: posts every 2.6 m, two rails, one post leaning\n  // and one rail fallen.\n  for (let i = 0; i \u003c 14; i++) {\n    const z = 4.4 + 2.6 * i, s = F / z, x = -2.2, lean = i === 2 ? 0.25 : (hash(i + 40) - 0.5) * 0.1;\n    capsuleInto(A, Z, VX + s * x, YH + s * HC, VX + s * (x + lean), YH + s * (HC - 1.15), 0.06 * s, 0.05 * s, z, z);\n    if (i === 13) break;\n    const z2 = z + 2.6, s2 = F / z2;\n    for (const [h, k] of [[0.5, 0], [0.95, 1]]) {\n      const drop = i === 4 && k === 1 ? 0.7 : 0;\n      capsuleInto(A, Z, VX + s * x, YH + s * (HC - h), VX + s2 * x, YH + s2 * (HC - h + drop), 0.025 * s, 0.025 * s2, z, z2);\n    }\n  }\n  // A far treeline on the horizon.\n  for (let x = 0; x \u003c W; x++) {\n    const ht = 1.5 + 2.2 * vn(x / 5, 7) + 1.6 * max(0, vn(x / 2.3, 11) - 0.55);\n    for (let y = YH - 6; y \u003c YH + 1; y++) {\n      const c = cl(ht - (YH + 0.5 - y), 0, 1), q = y * W + x;\n      if (c > A[q]) (A[q] = c), (Z[q] = 60);\n    }\n  }\n  blur(A);\n  return { A, Z };\n}\n\n// Where the opening zombies stand across the panel, nearest first, so a\n// bigger horde opens as a wider wall of them.\nconst COLS = [-0.45, 0.5, -0.92, 0.95, 0.08, -0.7, 0.75, -0.2, 0.3, -1, 1, -0.55, 0.6, -0.1, 0.15, -0.85, 0.85, -0.35];\n\nexport function setup(params) {\n  const zs = [];\n  for (let i = 0; i \u003c MAXZ; i++) zs.push({ z: 0, seed: i * 17 + 5 });\n  const sc = scenery(), A = (n) => new Float32Array(n);\n  params.s = {\n    t: 0, gait: 1, hue: 0, fog: 0.06, count: 5, look: 0, lookT: 0, started: false, zs, sA: sc.A, sZ: sc.Z,\n    col: A(N * 3), base: A(N * 3), fogC: A(N * 3), fc: A(N * 3), nb: A(33 * 65), bg: A(N), nz: A(N), dist: A(N), R: A(65), caps: A(20 * 6),\n    sky: [0, 0, 0], glow: [0, 0, 0], fogHue: [0, 0, 0], palHue: -1,\n  };\n}\n\nfunction spawn(Z, z, x) {\n  Z.seed += 101;\n  const r = (j) => hash(Z.seed * 3 + j);\n  Z.z = z || ZMAX - 4 * r(0);\n  // x: the column to stand in now, or none for a line drawn at random.\n  Z.x = x === undefined ? (r(1) - 0.5) * 2.6 : ((x - VX) * sqrt(Z.z * Z.z + ZC * ZC)) / F;\n  Z.ph = r(2);\n  Z.rate = 0.75 + 0.35 * r(3);\n  // Which leg drags (-1 left, 1 right, 0 neither), how the arms go, which\n  // way the head hangs and how far.\n  Z.drag = r(4) \u003c 0.6 ? (r(5) \u003c 0.5 ? -1 : 1) : 0;\n  Z.arms = floor(r(6) * 3);\n  Z.loll = (r(7) \u003c 0.5 ? -1 : 1) * (0.3 + 0.35 * r(8));\n  Z.size = 0.92 + 0.2 * r(9);\n  Z.eyes = r(10) \u003c 0.4;\n  Z.raiseL = (r(11) - 0.4) * 0.18;\n  Z.raiseR = (r(12) - 0.4) * 0.18;\n  // Half turned one way or the other, and stooped.\n  Z.yaw = (r(13) \u003c 0.5 ? -1 : 1) * (0.45 + 0.4 * r(14));\n  Z.stoop = 0.12 + 0.2 * r(15);\n  Z.fade = z ? 1 : 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.count = round(cl(k[2], 5, MAXZ));\n  s.fog = cl(k[3], 0, 1);\n  if (!s.started) {\n    // The opening horde, nearest first: one already close, the rest spread\n    // evenly in the log of distance, which is how walking at a speed in\n    // proportion to distance spreads them.\n    for (let i = 0; i \u003c s.count; i++) spawn(s.zs[i], 1.95 * (ZMAX / 1.95) ** ((i + 0.6 * hash(i + 9) * (i > 0)) / s.count), VX + (i ? 26 * COLS[i] : 13 * sin(s.count * 2.4)));\n    s.started = true;\n  }\n  const dd = (d * sp) / 2;\n  s.t += dd;\n  // A faster walk takes longer strides and lurches harder.\n  s.gait = 0.5 + 0.25 * sp;\n  const b = input.btnPressed || [];\n  if (b[0]) s.lookT = 3;\n  s.lookT = max(0, s.lookT - d);\n  s.look = cl(s.look + (s.lookT > 0.6 ? d / 0.12 : -d / 0.8), 0, 1);\n  for (let i = 0; i \u003c MAXZ; i++) {\n    const Z = s.zs[i];\n    if (i \u003c s.count && !Z.z) spawn(Z, 0);\n    if (!Z.z) continue;\n    // They come on at a tenth of their distance a second at Speed 2, so\n    // each grows on the panel at the same steady rate and the near ones\n    // linger; slower again while a dragged leg comes through.\n    const u = (Z.ph + Z.rate * s.t) % 1;\n    Z.z -= dd * 0.1 * Z.z * (Z.drag ? 0.6 + 0.8 * abs(sin(TAU * u)) : 1);\n    Z.fade = i \u003c s.count ? min(1, Z.fade + d * 0.5) : Z.fade - d;\n    if (Z.z \u003c ZOUT || Z.fade \u003c 0) i \u003c s.count ? spawn(Z, 0) : (Z.z = 0);\n  }\n}\n\n// The colours, and everything on the panel that only they change: the sky\n// and the lane before fog, and the fog's own light at each LED.\nfunction palette(s) {\n  const h = s.hue, { sky, glow, fogHue, base, fogC } = s;\n  // At 0 a toxic green glow under a purple sky; the glow turns through\n  // cyan and blue to magenta and the sky leans toward indigo on the way.\n  hsv(0.3 + 0.52 * h, 0.85, 1, glow);\n  hsv(0.78 - 0.14 * sin(PI * h), 0.82, 1, sky);\n  hsv(0.32 + 0.52 * h, 0.55, 1, fogHue);\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5, dy = yc - YH;\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3, gl = GL[q], dx = x + 0.5 - GX;\n      let v, sh;\n      if (dy \u003c 0) {\n        const u = yc / YH;\n        (v = 0.19 + 0.16 * u * u), (sh = gl);\n      } else {\n        // A wet lane between dark fields, mirroring the glow, brightest far\n        // off where the eye meets it at a graze: two wheel ruts full of water\n        // and a dark strip of grass between them.\n        const z = (F * HC) / dy, ax = abs(((x + 0.5 - VX) * z) / F);\n        const road = (1 - sm(ROAD - 0.12, ROAD + 0.12, ax)) * (0.45 + 0.55 * sm(0.12, 0.3, ax)), rut = exp(-(((ax - 0.55) / 0.16) ** 2));\n        v = 0.05 + 0.05 * road;\n        sh = road * (0.7 + 0.5 * rut) * (0.12 + 0.4 * exp(-dy / 26) + 0.25 * exp(-(dx * dx) / (60 + 4 * dy)));\n      }\n      const fl = 0.42 + 0.65 * gl;\n      for (let c = 0; c \u003c 3; c++) {\n        base[o + c] = (sky[c] * v + glow[c] * sh) * 255;\n        fogC[o + c] = fogHue[c] * 255 * fl;\n      }\n    }\n  }\n  s.palHue = h;\n}\n\n// The fog's density at height h: thick at the ground and gone above a soft\n// top that the Fog knob raises from 0.3 m to the chest. R is its integral\n// up from the ground, in 64 steps to 2.4 m.\nfunction fogTable(s) {\n  const top = 0.3 + 1.05 * s.fog, rho = 0.55 + 2.6 * s.fog, R = s.R;\n  let acc = 0;\n  R[0] = 0;\n  for (let i = 1; i \u003c= 64; i++) {\n    acc += (rho * (1 - sm(top * 0.45, top * 1.15, ((i - 0.5) / 64) * 2.4)) * 2.4) / 64;\n    R[i] = acc;\n  }\n}\nconst Rat = (R, h) => {\n  const u = cl((h / 2.4) * 64, 0, 64), i = min(63, floor(u));\n  return R[i] + (R[i + 1] - R[i]) * (u - i);\n};\n// Optical depth from the eye to a point z ahead at height h: z times the\n// mean density between the two heights.\nfunction tau(R, z, h) {\n  const dh = HC - h;\n  if (abs(dh) \u003c 0.02) return (z * (Rat(R, HC + 0.02) - Rat(R, HC - 0.02))) / 0.04;\n  return (z * (Rat(R, HC) - Rat(R, h))) / dh;\n}\n\n// One zombie's pose as capsules in LEDs, [x0, y0, x1, y1, r0, r1] each.\n// The body is built in metres, feet at 0, x to its right, y up and z\n// forward toward the eye, then turned by its yaw: a zombie half turned\n// shows both its reaching arms off to one side.\nfunction pose(s, Z, out) {\n  const z = Z.z, sc = (F / z) * Z.size, X = (Z.X = column(Z)), Y = YH + (F * HC) / z;\n  const u = (Z.ph + Z.rate * s.t) % 1, w = TAU * u, cy = cos(Z.yaw), sy = sin(Z.yaw), G = s.gait;\n  // The lurch: the trunk rolls over the planted leg, more so onto the good\n  // one when the other drags; it stoops forward by Z.stoop.\n  const roll = G * (0.08 * sin(w + 0.6) + (Z.drag ? 0.08 * Z.drag * max(0, sin(w * -Z.drag)) : 0)), cr = cos(roll), sr = sin(roll);\n  const hipY = 0.92 - 0.035 * abs(cos(w)), hx = 0.04 * sin(w), cs = cos(Z.stoop), ss = sin(Z.stoop);\n  let n = 0;\n  const q = [0, 0, 0, 0];\n  // A point of the upper body: stoop about the hips, then roll.\n  const up = (x, y, f) => {\n    const y1 = y * cs, z1 = y * ss + f;\n    return [hx + x * cr + y1 * sr, hipY + y1 * cr - x * sr, z1];\n  };\n  const P = (a, b, r0, r1) => {\n    out[n++] = X + (a[0] * cy + a[2] * sy) * sc;\n    out[n++] = Y - a[1] * sc;\n    out[n++] = X + (b[0] * cy + b[2] * sy) * sc;\n    out[n++] = Y - b[1] * sc;\n    out[n++] = r0 * sc;\n    out[n++] = r1 * sc;\n  };\n  for (const side of [-1, 1]) {\n    // Each leg swings forward in its half of the cycle; a dragged leg\n    // barely lifts and trails behind.\n    const dragged = Z.drag === side, ph = side \u003c 0 ? w : w + PI, l = max(0, sin(ph)) * (dragged ? 0.15 : G);\n    const fz = (dragged ? 0.08 : 0.24 * G) * cos(ph - PI / 2) - (dragged ? 0.12 : 0), fy = 0.05 + 0.13 * l;\n    const hip = [hx + side * 0.1, hipY, 0], knee = [hx + side * 0.115, 0.5 + 0.06 * l, fz * 0.5 + 0.1 * l], foot = [side * 0.13, fy, fz];\n    P(hip, knee, 0.09, 0.066);\n    P(knee, foot, 0.066, 0.05);\n    P(foot, [foot[0], foot[1] - 0.02, foot[2] + 0.1], 0.055, 0.05);\n  }\n  const neck = up(0, 0.5, 0), chest = up(0, 0.28, 0), sl = up(-0.17, 0.44, 0), sr2 = up(0.17, 0.44, 0);\n  P(up(0, 0.04, 0), chest, 0.15, 0.18);\n  P(chest, up(0, 0.44, 0), 0.18, 0.13);\n  P(sl, sr2, 0.08, 0.08);\n  // Rags of a shirt hanging below the waist.\n  for (const [a, b, c] of [[-0.13, -0.17, 0.13], [0.02, 0.05, 0.11], [0.12, 0.15, 0.09]]) P(up(a, 0.06, 0), up(b, -c, 0), 0.05, 0.022);\n  for (const side of [-1, 1]) {\n    // Arms reach forward at shoulder height with the hands hanging limp;\n    // some carry one arm dead at the side.\n    const sh = side \u003c 0 ? sl : sr2, bob = 0.035 * G * sin(w + side * 1.3), raise = side \u003c 0 ? Z.raiseL : Z.raiseR;\n    if (Z.arms === 2 && side > 0) {\n      const el = [sh[0] + 0.05, sh[1] - 0.3, sh[2] + 0.03], wr = [sh[0] + 0.07, sh[1] - 0.56, sh[2] + 0.06];\n      P(sh, el, 0.065, 0.05);\n      P(el, wr, 0.05, 0.04);\n      P(wr, [wr[0] + 0.01, wr[1] - 0.1, wr[2]], 0.042, 0.03);\n    } else {\n      const el = [sh[0] + side * 0.09, sh[1] - 0.04 + raise + bob, sh[2] + 0.27], wr = [el[0] + side * 0.07, el[1] + 0.02 + raise * 0.5 + bob, el[2] + 0.25];\n      P(sh, el, 0.07, 0.056);\n      P(el, wr, 0.056, 0.042);\n      P(wr, [wr[0], wr[1] - 0.13, wr[2] + 0.05], 0.046, 0.028);\n    }\n  }\n  // The head hangs to one side and swings with the step, unless it has\n  // snapped up to look; its jaw hangs open below it.\n  const la = (Z.loll + 0.2 * sin(w + 1.3)) * (1 - s.look) + roll, nk = [neck[0], neck[1] - 0.06, neck[2]];\n  const hc = [neck[0] + 0.13 * sin(la), neck[1] + 0.13 * cos(la), neck[2] + 0.04];\n  P(nk, hc, 0.065, 0.055);\n  P(hc, [hc[0] - 0.06 * sin(la), hc[1] - 0.06 * cos(la), hc[2] + 0.02], 0.11, 0.085);\n  return n;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  if (s.palHue !== s.hue) palette(s);\n  fogTable(s);\n  const { col, base, bg, fogC, fc, nz, nb, dist, R, sA, sZ, glow, caps } = s, t = s.t;\n  // The fog's billows, on every other LED each way: they drift across and\n  // the bank breathes slowly.\n  for (let j = 0; j \u003c= H / 2; j++)\n    for (let i = 0; i \u003c= W / 2; i++) {\n      const x = 2 * i, yc = 2 * j + 0.5;\n      nb[j * 33 + i] = 0.6 + 0.8 * vn((x + 9 * t) / 13, yc / 5 + 0.3 * t) * (0.6 + 0.4 * vn((x - 4 * t) / 9, yc / 4 + 50));\n    }\n  // The sky, the lane under its fog, and the scenery, fogged at its depth.\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5, dy = yc - YH, tg = dy > 0 ? tau(R, (F * HC) / dy, 0) : 0, j = y >> 1, fy = (y & 1) * 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3, i = j * 33 + (x >> 1), fx = (x & 1) * 0.5;\n      const n0 = nb[i] + (nb[i + 1] - nb[i]) * fx, n1 = nb[i + 33] + (nb[i + 34] - nb[i + 33]) * fx, n = n0 + (n1 - n0) * fy, L = 0.45 + 0.55 * n;\n      nz[q] = n;\n      // The billows catch the light unevenly too.\n      (fc[o] = fogC[o] * L), (fc[o + 1] = fogC[o + 1] * L), (fc[o + 2] = fogC[o + 2] * L);\n      let r = base[o], g = base[o + 1], b = base[o + 2];\n      if (tg > 0) {\n        const f = 1 - exp(-tg * n);\n        r += (fc[o] - r) * f;\n        g += (fc[o + 1] - g) * f;\n        b += (fc[o + 2] - b) * f;\n      }\n      const a = sA[q];\n      if (a > 0) {\n        const z = sZ[q], gl = GL[q], f = 1 - exp(-tau(R, z, HC - (dy * z) / F) * n) * (z > 50 ? 0.45 : 1);\n        const tr = 10 + glow[0] * 40 * gl, tgr = 6 + glow[1] * 40 * gl, tb = 14 + glow[2] * 40 * gl;\n        r += (tr + (fc[o] - tr) * f - r) * a;\n        g += (tgr + (fc[o + 1] - tgr) * f - g) * a;\n        b += (tb + (fc[o + 2] - tb) * f - b) * a;\n      }\n      col[o] = r;\n      col[o + 1] = g;\n      col[o + 2] = b;\n      bg[q] = max(r, g, b);\n    }\n  }\n  // Zombies, far to near, each as a soft distance field of its capsules.\n  const order = s.zs.filter((Z) => Z.z > 0).sort((a, b) => b.z - a.z);\n  for (const Z of order) {\n    const nc = pose(s, Z, caps), z = Z.z, scl = (F / z) * Z.size, fw = cl(0.6 + scl / 50, 0.8, 1.45);\n    let X0 = W, X1 = -1, Y0 = H, Y1 = -1;\n    for (let c = 0; c \u003c nc; c += 6) {\n      const r = max(caps[c + 4], caps[c + 5]) + fw + 1;\n      X0 = min(X0, caps[c] - r, caps[c + 2] - r);\n      X1 = max(X1, caps[c] + r, caps[c + 2] + r);\n      Y0 = min(Y0, caps[c + 1] - r, caps[c + 3] - r);\n      Y1 = max(Y1, caps[c + 1] + r, caps[c + 3] + r);\n    }\n    (X0 = max(0, floor(X0))), (X1 = min(W - 1, floor(X1))), (Y0 = max(0, floor(Y0))), (Y1 = min(H - 1, floor(Y1)));\n    if (X0 > X1 || Y0 > Y1) continue;\n    for (let y = Y0; y \u003c= Y1; y++) dist.fill(1e9, y * W + X0, y * W + X1 + 1);\n    for (let c = 0; c \u003c nc; c += 6) {\n      const x0 = caps[c], y0 = caps[c + 1], x1 = caps[c + 2], y1 = caps[c + 3], r0 = caps[c + 4], r1 = caps[c + 5];\n      const ex = x1 - x0, ey = y1 - y0, ll = ex * ex + ey * ey || 1e-9, R2 = max(r0, r1) + fw + 1;\n      const xa = max(X0, floor(min(x0, x1) - R2)), xb = min(X1, floor(max(x0, x1) + R2)), ya = max(Y0, floor(min(y0, y1) - R2)), yb = min(Y1, floor(max(y0, y1) + R2));\n      for (let y = ya; y \u003c= yb; y++)\n        for (let x = xa, q = y * W + xa; x \u003c= xb; x++, q++) {\n          const px = x + 0.5 - x0, py = y + 0.5 - y0, u = cl((px * ex + py * ey) / ll, 0, 1), dx = px - u * ex, dy = py - u * ey;\n          const rr = r0 + (r1 - r0) * u, d2 = dx * dx + dy * dy, far = rr + fw;\n          if (d2 > far * far) continue;\n          const dd = sqrt(d2) - rr;\n          if (dd \u003c dist[q]) dist[q] = dd;\n        }\n    }\n    // Black with a rim of the glow behind it, as bright as what it stands\n    // against, then fogged by the air between.\n    const fade = Z.fade * sm(ZOUT, ZFADE, z);\n    for (let y = Y0; y \u003c= Y1; y++) {\n      const h = HC - ((y + 0.5 - YH) * z) / F, th = tau(R, z, h);\n      for (let x = X0, q = y * W + X0; x \u003c= X1; x++, q++) {\n        const dd = dist[q];\n        if (dd > fw) continue;\n        // A fading zombie comes apart where the fog billows thickest first.\n        let a = sm(fw, -fw, dd) * (fade > 0.99 ? 1 : sm(0, 0.35, fade * 1.4 - 0.5 * (nz[q] - 0.6)));\n        if (sZ[q] \u003c z) a *= 1 - sA[q];\n        if (a \u003c= 0) continue;\n        const o = q * 3, rim = dd \u003c -6 ? 0 : exp(min(0, dd) / 1.4) * min(1, bg[q] / 150) * 0.85, f = 1 - exp(-th * nz[q]) * (0.6 + 0.4 * fade);\n        const r = 18 + glow[0] * 200 * rim, g = 9 + glow[1] * 200 * rim, b = 32 + glow[2] * 200 * rim;\n        col[o] += (r + (fc[o] - r) * f - col[o]) * a;\n        col[o + 1] += (g + (fc[o + 1] - g) * f - col[o + 1]) * a;\n        col[o + 2] += (b + (fc[o + 2] - b) * f - col[o + 2]) * a;\n      }\n    }\n    // Eyes: some always, every one while the heads are up.\n    const eo = (Z.eyes ? 0.7 : 0) + s.look * 0.6;\n    if (eo > 0 && scl > 9) {\n      // On the face, which turns to the eye as the head comes up.\n      const yw = Z.yaw * (1 - s.look), hx = (caps[nc - 6] - Z.X) / scl + 0.08 * sin(yw), ey = caps[nc - 5] + 0.01 * scl;\n      const e = min(1, eo) * exp(-tau(R, z, 1.62)) * fade;\n      for (const side of [-1, 1]) glowDot(col, Z.X + (hx + side * 0.045 * cos(yw)) * scl, ey, max(0.5, 0.022 * scl), glow, e);\n    }\n  }\n  grain(display, col, nz);\n}\n\nfunction glowDot(col, cx, cy, r, c, e) {\n  for (let y = max(0, floor(cy - 4)); y \u003c= min(H - 1, floor(cy + 4)); y++)\n    for (let x = max(0, floor(cx - 4)); x \u003c= min(W - 1, floor(cx + 4)); x++) {\n      const d2 = (x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2, k = e * (exp(-d2 / (r * r)) + 0.35 * exp(-d2 / (5 * r * r))), o = (y * W + x) * 3;\n      col[o] += (120 + c[0] * 135) * k;\n      col[o + 1] += (120 + c[1] * 135) * k;\n      col[o + 2] += (120 + c[2] * 135) * k;\n    }\n}\n\n// Grain: a fine checker half a step above and below each LED's level, the\n// mist's droplets, as strong as the picture around it allows so it never\n// makes a step of more than 40 levels, and a little stronger where the fog\n// billows thick.\nconst lv = new Float32Array(N);\nfunction grain(display, col, nz) {\n  for (let q = 0; q \u003c N; q++) lv[q] = min(255, max(col[q * 3], col[q * 3 + 1], col[q * 3 + 2]));\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, m = lv[q], o = q * 3;\n      let g = 0;\n      if (x > 0) g = max(g, abs(m - lv[q - 1]));\n      if (x \u003c W - 1) g = max(g, abs(m - lv[q + 1]));\n      if (y > 0) g = max(g, abs(m - lv[q - W]));\n      if (y \u003c H - 1) g = max(g, abs(m - lv[q + W]));\n      const amp = max(0, min(19.5 * (0.8 + 0.15 * nz[q]), 0.45 * m, 0.45 * (255 - m), (39 - g) / 2));\n      const f = m > 0.5 ? (m + ((x + y) & 1 ? amp : -amp)) / m : 1;\n      display.setPixel(x, y, min(255, round(col[o] * f)), min(255, round(col[o + 1] * f)), min(255, round(col[o + 2] * f)));\n    }\n}\n","bak-sneppen":"// ===== Patternflow pattern =====\n// Title:   Bak-Sneppen\n// Family:  data\n// Idea:    Sixty-four species stand on a ring as bars of fitness, and every step the least fit one and its two neighbours are redrawn at random, so the floor of the bars climbs by itself to a threshold near two thirds while fresh colours break out in avalanches around the hopping minimum.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Bak-Sneppen model of evolution (Per Bak and Kim Sneppen, 1993), with its random-neighbour version (Henrik Flyvbjerg, Kim Sneppen and Per Bak, 1993), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Random=0..1, Memory=0..1\n//\n// Knob 1: Hue. Turns the colours of age round the wheel together. At 0 a bar just redrawn is pale gold, then orange, rose and violet as it waits, and a bar left alone for long is deep blue; the gap line and the marked minimum are aqua. At 0.25 fresh bars are lime and old ones crimson; at 0.5 fresh is aqua and old is gold; at 0.75 fresh is pink and old is green.\n// Knob 2: Speed. Steps of the model a second, 25 times the knob, so 50 at 2. Each fresh start first runs a climb: 6,000 steps in 1.8 s, slow at first and faster and faster, so the gap line rises evenly from the bottom to 0.645 on average; then the model walks at the knob's pace for 40 s and the bars are thrown again. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Random. The chance that each of the two neighbours redrawn with the minimum is a species picked anywhere on the ring instead of the one beside it. At 0 the classic ring: the floor settles at 0.62 for 64 species, just under the 0.667 tick of the infinite ring, and avalanches stay local. At 0.25 the floor drops to 0.42, at 0.5 to 0.37, and at 1, the random-neighbour model, to 0.35, just over the 1/3 tick, and fresh bars flicker all over the ring.\n// Knob 4: Memory. How many steps a bar takes to turn from fresh to old, on a log scale of its age: 150 steps at 0, 184 at the opening 0.06, 820 at 0.5 and 4,500 at 1. Short memory shows only the avalanche of the last second or two as a bright patch on a blue block; long memory paints each bar by how long ago it was touched, so old avalanches stay as bands of rose and violet.\n// Buttons: K1 tap throws all 64 bars again from a uniform start and the climb runs anew.\n\nconst W = 64, H = 128, N = 64;\nconst { floor, round, min, max, abs, log, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The climb: CMAX steps in TC seconds at Speed 2, the step count growing as\n// CMAX^u, so the gap, which rises about 0.05 for every doubling of the steps,\n// rises evenly. Then RATE * Speed steps a second for CYCLE seconds at Speed 2.\nconst CMAX = 6000, TC = 1.8, RATE = 25, CYCLE = 40;\n// The threshold of the infinite ring (Paczuski, Maslov and Bak, 1996) and of\n// the random-neighbour model (Flyvbjerg, Sneppen and Bak, 1993).\nconst FC = 0.66702, FMF = 1 / 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, rnd: 0, mem: 0.06,\n    f: new Float32Array(N), born: new Float64Array(N), step: 0, m: 0, G: 0,\n    ph: \"climb\", pt: 0, acc: 0,\n    // 64 colours of age, plus the gap line, its dim twin, the ticks and the\n    // marked minimum.\n    pal: new Float32Array(70 * 3), palKey: \"\",\n  };\n  throwBars(params.s);\n}\n\n// A uniform start: every species gets a fitness drawn at random and counts\n// as old, so the bars the climb redraws stand out from the first step.\nfunction throwBars(S) {\n  for (let i = 0; i \u003c N; i++) (S.f[i] = Math.random()), (S.born[i] = -1e9);\n  S.step = 0;\n  S.G = 0;\n  S.ph = \"climb\";\n  S.pt = 0;\n  S.acc = 0;\n  S.m = argmin(S.f);\n}\n\nfunction argmin(f) {\n  let m = 0;\n  for (let i = 1; i \u003c N; i++) if (f[i] \u003c f[m]) m = i;\n  return m;\n}\n\n// One step of the model: the least fit species and two others get new\n// fitnesses, and the gap, the largest minimum seen since the start, may rise.\nfunction step(S) {\n  const f = S.f, m = S.m;\n  if (f[m] > S.G) S.G = f[m];\n  S.step++;\n  const a = Math.random() \u003c S.rnd ? floor(Math.random() * N) : (m + N - 1) % N;\n  const b = Math.random() \u003c S.rnd ? floor(Math.random() * N) : (m + 1) % N;\n  for (const i of [m, a, b]) (f[i] = Math.random()), (S.born[i] = S.step);\n  S.m = argmin(f);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.rnd = cl(k[2], 0, 1);\n  S.mem = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1), v = S.speed / 2;\n  if (input.btnPressed && input.btnPressed[0]) throwBars(S);\n  S.pt += d * v;\n  if (S.ph === \"climb\") {\n    const u = min(1, S.pt / TC), target = round(pow(CMAX, u)) - 1;\n    while (S.step \u003c target) step(S);\n    if (u >= 1) (S.ph = \"walk\"), (S.pt = 0);\n  } else {\n    S.acc += d * RATE * S.speed;\n    while (S.acc >= 1) step(S), (S.acc -= 1);\n    if (S.pt > CYCLE) throwBars(S);\n  }\n}\n\n// Colours of age: index 0 is a bar redrawn this step, 63 a bar older than\n// the memory. Then 64 the gap line, 65 the line's dim twin over the dark,\n// 66 the threshold ticks, 67 the marked minimum, 68 the pointer above it.\nfunction palette(S) {\n  const key = S.hue + \":\" + S.mem;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const P = S.pal, h = S.hue + 0.14;\n  for (let i = 0; i \u003c 64; i++) {\n    const u = i / 63;\n    // Warm white, gold, orange, rose and violet to deep blue; the value\n    // stays above 0.55, and old ages near orange and yellow stay brighter\n    // still, so no age turns brown or olive whatever the hue.\n    const hh = h - 0.48 * pow(u, 0.8), dw = abs(hh - floor(hh) - 0.11), warm = max(0, 1 - min(dw, 1 - dw) / 0.14);\n    hsv(hh, 0.4 + 0.48 * min(1, u * 3), min(1, (1 - 0.45 * u) * (1 + 0.55 * warm * u)), P, i * 3);\n  }\n  hsv(h + 0.38, 0.3, 1, P, 64 * 3);\n  hsv(h + 0.38, 0.45, 0.6, P, 65 * 3);\n  hsv(h, 0.05, 1, P, 66 * 3);\n  hsv(h + 0.38, 0.55, 1, P, 67 * 3);\n  hsv(h + 0.38, 0.6, 0.45, P, 68 * 3);\n}\n\nconst row = (f) => cl(round(H - f * H), 0, H - 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const P = S.pal, f = S.f, born = S.born, step = S.step;\n  // Ages on a log scale up to the memory, 150 to 4,500 steps.\n  const M = 150 * pow(30, S.mem), lm = log(1 + M);\n  const yG = S.G > 0 ? row(S.G) : -1, y1 = row(FC), y2 = row(FMF);\n  for (let x = 0; x \u003c W; x++) {\n    const top = row(f[x]), mark = x === S.m;\n    const c = min(63, round((63 * log(1 + step - born[x])) / lm)) * 3;\n    // Every other bar a shade darker, so 64 bars read as 64 and not a block.\n    const sh = x & 1 ? 0.86 : 1;\n    for (let y = 0; y \u003c H; y++) {\n      let o = -1, s = 1;\n      if (y >= top) {\n        o = mark ? 67 * 3 : c;\n        s = y === top ? 1.12 : sh;\n      } else if (mark) o = 68 * 3;\n      if (y === yG) o = y >= top ? 64 * 3 : 65 * 3;\n      if ((y === y1 || y === y2) && (x \u003c 3 || x > W - 4)) o = 66 * 3;\n      if (o \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      // Channels in steps of 4 of 255: too fine to see, and a frame packs smaller.\n      display.setPixel(x, y, min(255, round((P[o] * s) / 4) * 4), min(255, round((P[o + 1] * s) / 4) * 4), min(255, round((P[o + 2] * s) / 4) * 4));\n    }\n  }\n}\n","diffusion-front":"// ===== Patternflow pattern =====\n// Title:   Diffusion Front\n// Family:  fractal\n// Idea:    Every LED is a lattice site with a fixed random number and is occupied while that number is below the concentration of a dye diffusing up from the bottom row, erfc(h / 2 sqrt(Dt)); the occupied sites joined to the source glow pale cyan to deep blue with the concentration, a site that has just joined flashes white, islands not joined glow violet, and the cluster's outer boundary, the diffusion front, is drawn gold: a fractal hull that climbs as the square root of time and sits where the concentration is 0.5927, the percolation threshold, until the source shuts, the cluster is cut from it, the dye drains out and a fresh lattice starts.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: diffusion fronts and gradient percolation (Bernard Sapoval, Michel Rosso and Jean-François Gouyet, 1985), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hop=0..1, Islands=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the cluster runs from pale cyan at the front to deep blue at the source, the front is gold and the islands violet; at 0.25 the cluster runs from grey violet to magenta, the front is mint and the islands brick red; at 0.5 the cluster runs from brown to amber, the front is pale blue and the islands olive; at 0.75 the cluster is green, the front pink and the islands teal.\n// Knob 2: Speed. At 2 the front is 28 rows up after a quarter of a second, 55 after one second, 78 after two and 121 after 4.8, as the square root of time; it holds half a second, the source shuts and the dye drains for a second, so a run lasts 6.3 seconds. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Hop. How often each site draws a new random number. At 0 the lattice is frozen, the gradient percolation of one fixed lattice, and the front only climbs; at 0.5 each site draws again once a second on average and at 1 twice, so the occupied sites flicker like hopping particles, islands join the cluster and fall away, and the front shivers as it climbs.\n// Knob 4: Islands. How bright the occupied sites that are not joined to the source glow. At 0 they are dark and only the cluster joined to the source shows; at the opening 0.06 they glow violet at 113 of 255, at 0.25 at 196 and at 1 at 237, nearly as bright as the front.\n// Buttons: K1 tap starts a fresh lattice.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, exp, sqrt, abs, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// erfc(x) to 1.2e-7 (Numerical Recipes' Chebyshev fit).\nfunction erfc(x) {\n  const z = abs(x), t = 1 / (1 + 0.5 * z);\n  const r = t * exp(-z * z - 1.26551223 + t * (1.00002368 + t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * (-0.82215223 + t * 0.17087277)))))))));\n  return x >= 0 ? r : 2 - r;\n}\n\n// The front sits where p = 0.5927, at h = 0.3778 L with L = 2 sqrt(D t).\n// A run grows L from L0 to L1 in GROW seconds (at Speed 2) with L^2 growing\n// evenly in time, holds, shuts the source and drains for DRAIN seconds, then\n// starts again on a fresh lattice.\nconst L1 = 320, L0 = 10, GROW = 4.8, HOLD = 0.5, DRAIN = 1.0, PC = 0.5927;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, hop: 0, isl: 0.06, c: 0, L: L0, runs: 0,\n    u: new Float32Array(N), occ: new Uint8Array(N), A: new Uint8Array(N), B: new Uint8Array(N), hull: new Uint8Array(N),\n    join: new Float32Array(N), q: new Int32Array(N), p: new Float64Array(H), glow: new Float32Array(N * 3), ease: 1,\n    // Front sites and their mean height in rows, kept for checking the\n    // front against the threshold.\n    nHull: 0, hf: 0,\n  };\n  fresh(params.s);\n}\n\nfunction fresh(S) {\n  for (let i = 0; i \u003c N; i++) S.u[i] = Math.random();\n  S.join.fill(-1);\n  S.c = 0;\n  S.runs++;\n}\n\n// Occupancy from p(h), the cluster joined to the source row (4-neighbour),\n// the empty sites joined to the open top (8-neighbour), and the hull: the\n// cluster's sites that touch that open emptiness.\nfunction percolate(S) {\n  const { u, occ, A, B, hull, q, p } = S;\n  for (let y = 0; y \u003c H; y++) {\n    const py = p[y], o = y * W;\n    for (let x = 0; x \u003c W; x++) occ[o + x] = u[o + x] \u003c py ? 1 : 0;\n  }\n  A.fill(0);\n  let t = 0;\n  for (let x = 0, o = (H - 1) * W; x \u003c W; x++) if (occ[o + x]) (A[o + x] = 1), (q[t++] = o + x);\n  for (let k = 0; k \u003c t; k++) {\n    const i = q[k], x = i % W;\n    if (x > 0 && occ[i - 1] && !A[i - 1]) (A[i - 1] = 1), (q[t++] = i - 1);\n    if (x \u003c W - 1 && occ[i + 1] && !A[i + 1]) (A[i + 1] = 1), (q[t++] = i + 1);\n    if (i >= W && occ[i - W] && !A[i - W]) (A[i - W] = 1), (q[t++] = i - W);\n    if (i + W \u003c N && occ[i + W] && !A[i + W]) (A[i + W] = 1), (q[t++] = i + W);\n  }\n  B.fill(0);\n  t = 0;\n  for (let x = 0; x \u003c W; x++) if (!occ[x]) (B[x] = 1), (q[t++] = x);\n  for (let k = 0; k \u003c t; k++) {\n    const i = q[k], x = i % W, y = (i - x) / W;\n    for (let dy = -1; dy \u003c= 1; dy++) {\n      const yy = y + dy;\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        const xx = x + dx;\n        if (xx \u003c 0 || xx >= W) continue;\n        const j = yy * W + xx;\n        if (!occ[j] && !B[j]) (B[j] = 1), (q[t++] = j);\n      }\n    }\n  }\n  let nh = 0, sh = 0;\n  for (let i = 0; i \u003c N; i++) {\n    let f = 0;\n    if (A[i]) {\n      const x = i % W;\n      f = i \u003c W || (x > 0 && B[i - 1]) || (x \u003c W - 1 && B[i + 1]) || B[i - W] || (i + W \u003c N && B[i + W]) ? 1 : 0;\n      if (f) (nh++), (sh += H - 1 - (i - x) / W);\n    }\n    hull[i] = f;\n  }\n  S.nHull = nh;\n  S.hf = nh ? sh / nh : 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.hop = cl(k[2], 0, 1);\n  S.isl = cl(k[3], 0, 1);\n  const d = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.ease = 1 - exp(-d / 0.08);\n  if (input.btnPressed && input.btnPressed[0]) fresh(S);\n  S.c += d;\n  if (S.c > GROW + HOLD + DRAIN) fresh(S);\n  // L^2 = 4 D t grows evenly; once the source shuts at GROW + HOLD, the\n  // profile is the same erfc less one started at the moment of shutting\n  // (the source row held at zero from then on), so the source row empties\n  // at once and the rest drains out through it.\n  const K = (L1 * L1 - L0 * L0) / GROW, ts = GROW + HOLD;\n  S.L = sqrt(L0 * L0 + K * S.c);\n  const Ls = S.c > ts ? sqrt(K * (S.c - ts)) : 0;\n  for (let y = 0; y \u003c H; y++) {\n    const h = H - 1 - y;\n    S.p[y] = erfc(h / S.L) - (Ls > 0 ? erfc(h / Ls) : 0);\n  }\n  // Hop: each site draws a new random number at this rate a second.\n  if (S.hop > 0) {\n    const r = 1 - exp(-2 * S.hop * d);\n    for (let i = 0; i \u003c N; i++) if (Math.random() \u003c r) S.u[i] = Math.random();\n  }\n  percolate(S);\n  const { A, join } = S;\n  for (let i = 0; i \u003c N; i++) {\n    if (A[i]) {\n      if (join[i] \u003c 0) join[i] = S.c;\n    } else join[i] = -1;\n  }\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { occ, A, hull, join, p, glow } = S;\n  const hu = S.hue;\n  const front = hsv(hu + 0.12, 0.35, 1), flash = hsv(hu + 0.5, 0.05, 1), isl = hsv(hu + 0.78, 0.7, 1);\n  const il = (255 * S.isl) / (S.isl + 0.075);\n  for (let y = 0; y \u003c H; y++) {\n    // The cluster is lit by the concentration where it stands: dim at the\n    // front, where p is near the threshold, bright near the source.\n    const sy = pow(cl((p[y] - PC) / (1 - PC), 0, 1), 0.8), lv = 255 * (0.45 + 0.55 * sy);\n    const c = hsv(hu + 0.5 + 0.12 * sy, 0.4 + 0.5 * sy, 1);\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let r = 0, g = 0, b = 0;\n      if (hull[i]) (r = 255 * front[0]), (g = 255 * front[1]), (b = 255 * front[2]);\n      else if (A[i]) {\n        // A site that has just joined flashes pale and settles in half a second.\n        const a = cl((S.c - join[i]) / 0.5, 0, 1), v = 255 * (1 - a), w = lv * a;\n        r = flash[0] * v + c[0] * w;\n        g = flash[1] * v + c[1] * w;\n        b = flash[2] * v + c[2] * w;\n      } else if (occ[i]) (r = il * isl[0]), (g = il * isl[1]), (b = il * isl[2]);\n      // Each LED eases towards its colour in about a tenth of a second, so a\n      // cluster cut from the source sinks to island colour instead of\n      // switching.\n      const o = i * 3, e = S.ease;\n      glow[o] += (r - glow[o]) * e;\n      glow[o + 1] += (g - glow[o + 1]) * e;\n      glow[o + 2] += (b - glow[o + 2]) * e;\n      display.setPixel(x, y, glow[o], glow[o + 1], glow[o + 2]);\n    }\n  }\n}\n","in-the-flash":"// ===== Patternflow pattern =====\n// Title:   In the Flash\n// Family:  halloween\n// Idea:    A rainy field at night stays almost dark, rain and a faint horizon, until lightning lights it violet-white for a moment and shows a tall thin figure standing in the grass, a little closer at every flash and never once seen moving, until a flash shows its head right in front of you and two glowing eyes stay behind in the dark; the next flash shows an empty field, and then it stands far off again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Approach=3..8\n//\n// Knob 1: Hue. The tint of the flash and the colour of the eyes, turned together: at 0 a violet-white flash and toxic green eyes; at 0.25 a pink-white flash and blue eyes; at 0.5 a pale yellow-green flash and magenta eyes; at 0.75 a pale cyan flash and orange eyes. The dark sky between flashes stays deep violet.\n// Knob 2: Speed. How often the lightning comes. At 2 the figure takes 6.4 s to come from far off to right in front, split evenly between its steps, each gap 0.85 to 1.15 times its share, and the eyes stay at least 2.3 s; at 0.2 the gaps are ten times as long, at 3 two thirds as long, but never shorter than half a second. A flash itself always lights the field for about two thirds of a second: a bright stroke, and a weaker one 0.2 s later. The first comes 0.5 s in at Speed 2.\n// Knob 3: Rain. At 0 about 200 drops in the air, at 1 about 900, each a streak slanting left, dim in the dark and lit with the flash's tint when it comes.\n// Knob 4: Approach. How many flashes it takes to come from far off to right in front: at 3 it stands 18 LEDs tall on the horizon, then 38, then 82 with its feet at the bottom; at 8 it comes in eight smaller steps, so the lightning comes more often. Then one flash for the face and one for the empty field.\n// Buttons: K1 tap brings the next flash at once.\n\nconst W = 64, H = 128, N = W * H, HZ = 70;\nconst { floor, round, min, max, abs, sqrt, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n// Value noise on a lattice, in two dimensions.\nconst vn2 = (x, y, sd) => {\n  const i = floor(x), j = floor(y), u = sm(x - i), v = sm(y - j);\n  const a = hash(i * 7919 + j * 104729 + sd), b = hash((i + 1) * 7919 + j * 104729 + sd);\n  const c = hash(i * 7919 + (j + 1) * 104729 + sd), d = hash((i + 1) * 7919 + (j + 1) * 104729 + sd);\n  return a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// Seen from eye height 1.6 m with 60 LEDs to the metre at one metre off, the\n// horizon on row HZ. The figure is 2.4 m tall and comes from 8 m to 1.75 m.\nconst FOC = 60, EYE = 1.6, TALL = 2.4, ZFAR = 8, ZNEAR = 1.75;\n// Seconds at Speed 2 for the whole approach, and the least the eyes stay.\nconst TAPP = 6.4, TEYES = 2.3;\nconst MAXD = 900;\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, rain: 0, steps: 3,\n    next: 0.5, ft: 9, k: 0, n: 0, cyc: 0, x0: 24, fig: null, face: false, eyes: -1,\n    bolt: new Int16Array(800), nb: 0, bx: 32,\n    drops: new Float32Array(MAXD * 3), base: new Float32Array(N * 3), lit: new Float32Array(N), fm: new Uint8Array(N), buf: new Float32Array(N * 3),\n    fc: [0, 0, 0], ec: [0, 0, 0], colF: new Float32Array(W),\n  });\n  scene(S);\n  for (let i = 0; i \u003c MAXD; i++) {\n    S.drops[i * 3] = Math.random() * 80;\n    S.drops[i * 3 + 1] = Math.random() * H;\n    S.drops[i * 3 + 2] = Math.random();\n  }\n}\n\n// The still scene: its dark colours and how much of the flash each LED gives\n// back. Clouds in the sky, wet grass below, and a lone tree and a fence line\n// that stay black.\nfunction scene(S) {\n  const { base, lit } = S;\n  const tree = new Uint8Array(N);\n  // A bare tree on the horizon: a trunk and branches that fork twice.\n  const limb = (x, y, a, len, w, d) => {\n    for (let s = 0; s \u003c len; s += 0.5) {\n      const px = x + Math.sin(a) * s, py = y - Math.cos(a) * s;\n      for (let i = -floor(w / 2); i \u003c= floor((w - 1) / 2); i++) {\n        const xx = round(px) + i, yy = round(py);\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tree[yy * W + xx] = 1;\n      }\n    }\n    if (d \u003c 3) {\n      const ex = x + Math.sin(a) * len, ey = y - Math.cos(a) * len;\n      limb(ex, ey, a - 0.45 - 0.3 * hash(d * 7 + len), len * 0.68, max(1, w - 1), d + 1);\n      limb(ex, ey, a + 0.5 + 0.25 * hash(d * 13 + len), len * 0.62, max(1, w - 1), d + 1);\n    }\n  };\n  limb(10, HZ + 1, 0.05, 9, 2, 0);\n  // Fence posts along the right, 1.9 m off, every 1.9 m, with two wires.\n  const posts = [];\n  for (let i = 0; i \u003c 16; i++) {\n    const z = 3.4 + 1.9 * i, x = 32 + (FOC * 1.9) / z, yb = HZ + (FOC * EYE) / z, h = (FOC * 1.15) / z;\n    posts.push([x, yb, h]);\n    for (let y = round(yb - h); y \u003c= round(yb); y++)\n      for (let xx = floor(x - max(0.5, 5 / z)); xx \u003c= floor(x + max(0.5, 5 / z) - 0.01); xx++) if (xx >= 0 && xx \u003c W && y \u003c H) tree[y * W + xx] = 1;\n  }\n  for (let i = 0; i + 1 \u003c posts.length; i++)\n    for (const f of [0.9, 0.5]) {\n      const [x1, y1, h1] = posts[i], [x2, y2, h2] = posts[i + 1];\n      for (let s = 0; s \u003c= 1; s += 0.05) {\n        const xx = round(x1 + (x2 - x1) * s), yy = round(y1 - h1 * f + (y2 - h2 * f - y1 + h1 * f) * s);\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tree[yy * W + xx] = 1;\n      }\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3;\n      if (tree[p]) {\n        (base[o] = 3), (base[o + 1] = 2), (base[o + 2] = 6), (lit[p] = 0);\n        continue;\n      }\n      if (y \u003c HZ) {\n        // Clouds: two scales of noise, in five steps, heavier low down.\n        const c = floor(cl(0.65 * vn2(x / 14, y / 7, 3) + 0.35 * vn2(x / 5, y / 3, 9) - 0.15 + y / 260, 0, 1) * 5) / 5;\n        const g = y > HZ - 9 ? ((y - HZ + 9) / 9) ** 2 : 0;\n        base[o] = 12 + 9 * c + 30 * g;\n        base[o + 1] = 8 + 6 * c + 22 * g;\n        base[o + 2] = 22 + 14 * c + 40 * g;\n        lit[p] = 0.22 + 0.45 * c;\n      } else {\n        // The field: rows of wet grass closing up toward the horizon.\n        const d = (y - HZ + 1) / (H - HZ), gr = floor(vn2(x / (2 + 3 * d), (y - HZ) / (1 + 2 * d), 21) * 3) / 3;\n        base[o] = 5;\n        base[o + 1] = 6;\n        base[o + 2] = 10;\n        lit[p] = (0.16 + 0.14 * gr) * (y \u003c HZ + 3 ? 1.5 : 1);\n      }\n    }\n}\n\n// The figure, standing: rows of spans from the top of its head (v = 0) to\n// its feet (v = 1), into the mask fm, centred on an LED so that it stays\n// symmetric when small. A small head on a long neck, narrow shoulders, a\n// thin trunk, long legs, and long arms that hang off the shoulders and\n// spread a little to hands below the knee. A lean of the head and how far\n// the arms stand off change from flash to flash.\nfunction stand(S, cx, top, h, tilt, spread) {\n  const fm = S.fm;\n  fm.fill(0);\n  cx = floor(cx) + 0.5;\n  const span = (y, c, hw) => {\n    for (let x = max(0, floor(cx + c - hw)); x \u003c= min(W - 1, floor(cx + c + hw)); x++) if (abs(x + 0.5 - cx - c) \u003c= hw + 0.02) fm[y * W + x] = 1;\n  };\n  const tw0 = max(0.5, 0.05 * h), aw0 = max(0.5, 0.017 * h), sh = tw0 + aw0 + 1.05, lc = max(1, 0.036 * h), lw = max(0.5, 0.022 * h);\n  for (let y = max(0, floor(top)); y \u003c min(H, top + h + 1); y++) {\n    const v = (y + 0.5 - top) / h;\n    if (v \u003c 0 || v > 1.01) continue;\n    if (v \u003c 0.095) {\n      const q = (v - 0.05) / 0.05;\n      span(y, round(tilt * 0.02 * h * (1 - v * 10)), max(1, 0.042 * h * sqrt(max(0, 1 - q * q))));\n    } else if (v \u003c 0.13) span(y, 0, max(0.5, 0.013 * h));\n    // Narrow shoulders, joining the arms to the trunk.\n    else if (v \u003c 0.13 + max(0.035, 1.1 / h)) span(y, 0, sh + 0.6);\n    else {\n      if (v \u003c 0.53) span(y, 0, max(0.5, tw0 * (1 - 0.25 * (v - 0.13))));\n      // The arms spread a little as they hang; the hands are thinner, with\n      // a finger turned out.\n      if (v \u003c 0.84) {\n        const s = (v - 0.13) / 0.71, hand = v > 0.76, aw = hand ? max(0.5, aw0 * 0.6) : aw0;\n        for (const sg of [-1, 1]) {\n          const c = sh + (max(1.6, 0.05 * h) + spread * (sg > 0 ? 1 : 0.5) * 0.04 * h) * s;\n          span(y, sg * c, aw);\n          if (hand && h > 40 && v > 0.79) span(y, sg * (c + 1 + (v - 0.79) * h * 0.5), 0.5);\n        }\n      }\n      if (v >= 0.5) {\n        span(y, -lc, lw);\n        span(y, lc, lw);\n        if (v > 0.985 && h > 30) (span(y, -lc - lw, lw), span(y, lc + lw, lw));\n      }\n    }\n  }\n}\n\n// Right in front: a head from row 13 to row 66, leaning a little, on a thin\n// neck, and narrow shoulders falling away to the edges.\nconst TILT = -0.12, EYEY = 38;\nfunction close(S) {\n  const fm = S.fm;\n  fm.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const dy = (y - 39.5) / 26.5, rx = 19 * (dy > 0 ? 1 - 0.3 * dy * dy : 1), head = abs(dy) \u003c 1 ? rx * sqrt(1 - dy * dy) : 0, hx = 32 + (y - EYEY) * TILT;\n    const neck = y > 60 ? 6.5 : 0, sh = y > 82 ? 6.5 + (y - 82) * 1.6 : 0;\n    for (let x = 0; x \u003c W; x++) if (abs(x + 0.5 - hx) \u003c= head || abs(x + 0.5 - 32) \u003c= max(neck, sh)) fm[y * W + x] = 1;\n  }\n}\n\n// A flash: what it shows, the bolt, and when the next one comes.\nfunction flash(S) {\n  const n = S.steps, k = S.k;\n  S.ft = 0;\n  S.face = false;\n  S.fig = null;\n  if (k \u003c n) {\n    if (k === 0) (S.cyc++), (S.x0 = 15 + 14 * hash(S.cyc * 31));\n    const p = n > 1 ? k / (n - 1) : 1, z = ZFAR * pow(ZNEAR / ZFAR, p), h = (FOC * TALL) / z, feet = HZ + (FOC * EYE) / z;\n    const sd = S.cyc * 17 + k;\n    S.fig = 1;\n    stand(S, S.x0 + (32 - S.x0) * p, feet - h, h, hash(sd) * 2 - 1, hash(sd + 5));\n  } else if (k === n) (S.face = true), close(S), (S.eyes = 0);\n  else S.fm.fill(0);\n  // A bolt: a jagged walk down from the top with two forks, ending low in the\n  // clouds or at the horizon.\n  let x = (S.bx = 6 + 52 * Math.random()), nb = 0;\n  const yEnd = Math.random() \u003c 0.6 ? HZ - 1 : 34 + 24 * Math.random();\n  const walk = (x, y, y1, dir, lim) => {\n    while (y \u003c y1 && nb \u003c lim) {\n      const ny = y + 2 + floor(Math.random() * 4), nx = x + dir * (Math.random() * 2.5) + (Math.random() - 0.5) * 5;\n      for (let s = 0; s \u003c 1; s += 0.2) if (nb \u003c lim) (S.bolt[2 * nb] = round(x + (nx - x) * s)), (S.bolt[2 * nb + 1] = round(y + (ny - y) * s)), nb++;\n      (x = nx), (y = ny);\n      if (dir === 0 && Math.random() \u003c 0.12 && y \u003c y1 - 12) {\n        const keep = [x, y];\n        walk(x, y, y + 10 + 14 * Math.random(), Math.random() \u003c 0.5 ? -1.6 : 1.6, min(400, nb + 60));\n        [x, y] = keep;\n      }\n    }\n  };\n  walk(x, 0, yEnd, 0, 400);\n  S.nb = nb;\n  // The next flash.\n  const d = TAPP / n, j = 0.85 + 0.3 * hash(S.n++ * 13 + 7);\n  // Never more than two flashes a second, whatever the knobs.\n  S.next = S.t + max(0.26 * S.speed, (k === n ? max(d, TEYES) : d) * j);\n  S.k = k + 1 > n + 1 ? 0 : k + 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 0, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kn[0], 0, 1);\n  S.speed = cl(kn[1], 0.2, 3);\n  S.rain = cl(kn[2], 0, 1);\n  S.steps = round(cl(kn[3], 3, 8));\n  if (S.k > S.steps + 1) S.k = 0;\n  S.t += (d * S.speed) / 2;\n  S.ft += d;\n  if (S.eyes >= 0) S.eyes += (d * S.speed) / 2;\n  if (S.t >= S.next || (input.btnPressed && input.btnPressed[0] && S.ft > 0.6)) flash(S);\n  // Rain falls 105 LEDs a second, slanting left.\n  const dr = S.drops, cnt = 200 + floor(700 * S.rain);\n  for (let i = 0; i \u003c cnt; i++) {\n    const o = i * 3, v = 80 + 50 * dr[o + 2];\n    dr[o + 1] += v * d;\n    dr[o] -= 0.22 * v * d;\n    if (dr[o + 1] > H + 4) (dr[o + 1] -= H + 8), (dr[o] = Math.random() * 80);\n  }\n}\n\n// How bright the flash is, s seconds after it starts: a stroke, and a second\n// weaker one 0.2 s later.\nconst env = (s) => {\n  const f = s \u003c 0 ? 0 : max(exp(-s / 0.2), 0.62 * sm((s - 0.17) / 0.05) * exp(-max(0, s - 0.22) / 0.24));\n  return f \u003c 0.02 ? 0 : f;\n};\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { buf, base, lit, fm, colF } = S, F = env(S.ft), fc = hsv(0.76 + S.hue, 0.45, 1, S.fc), ec = hsv(0.3 + S.hue, 0.8, 1, S.ec);\n  // The sky is brightest round the bolt.\n  for (let x = 0; x \u003c W; x++) colF[x] = F * (0.85 + 0.75 * exp(-abs(x - S.bx) / 12));\n  // The figure is black against the flash and gone into the dark between.\n  const hide = 1 - min(1, F * 6);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    if (fm[p]) {\n      buf[o] = base[o] * hide;\n      buf[o + 1] = base[o + 1] * hide;\n      buf[o + 2] = base[o + 2] * hide;\n      continue;\n    }\n    const l = lit[p] * colF[p & 63];\n    buf[o] = base[o] + fc[0] * l;\n    buf[o + 1] = base[o + 1] + fc[1] * l;\n    buf[o + 2] = base[o + 2] + fc[2] * l;\n  }\n  // The bolt, white with a glow of the flash's tint, while the strokes last.\n  if (F > 0.3) {\n    const a = min(1, (F - 0.3) * 2.5);\n    for (let i = 0; i \u003c S.nb; i++) {\n      const x = S.bolt[2 * i], y = S.bolt[2 * i + 1];\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= HZ || fm[y * W + x]) continue;\n      for (const dx of [-1, 1]) if (x + dx >= 0 && x + dx \u003c W && !fm[y * W + x + dx]) add(buf, (y * W + x + dx) * 3, fc, 0.5 * a);\n      const o = (y * W + x) * 3;\n      buf[o] += (255 - buf[o]) * a;\n      buf[o + 1] += (255 - buf[o + 1]) * a;\n      buf[o + 2] += (255 - buf[o + 2]) * a;\n    }\n  }\n  // Rain: dim streaks in the dark, near white in the flash. Two depths.\n  const dr = S.drops, cnt = 200 + floor(700 * S.rain);\n  for (let i = 0; i \u003c cnt; i++) {\n    const o = i * 3, near = dr[o + 2] > 0.6, len = near ? 4 : 2, br = near ? 1 : 0.6;\n    const r = (30 + 0.9 * fc[0] * F) * br, g = (34 + 0.9 * fc[1] * F) * br, b = (50 + 0.9 * fc[2] * F) * br;\n    for (let j = 0; j \u003c len; j++) {\n      const x = round(dr[o] + 0.22 * j), y = round(dr[o + 1] - j);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = (y * W + x) * 3, f = (1 - j / (len + 1)) * (fm[y * W + x] ? 0.35 + 0.65 * hide : 1);\n      buf[q] = max(buf[q], r * f);\n      buf[q + 1] = max(buf[q + 1], g * f);\n      buf[q + 2] = max(buf[q + 2], b * f);\n    }\n  }\n  // The eyes, right in front, glowing on after the flash, blinking once.\n  if (S.face && S.eyes >= 0) {\n    const e = S.eyes, open = e \u003c 0.08 ? e / 0.08 : abs(e - 1.1) \u003c 0.08 ? 0.15 : e > TEYES - 0.3 ? max(0, (TEYES - e) / 0.3) : 1;\n    if (open > 0)\n      for (const cx of [24.5, 40.5])\n        for (let dy = -3; dy \u003c= 3; dy++)\n          for (let dx = -6; dx \u003c= 6; dx++) {\n            // Round, with a slit, the outer corners lifted a little.\n            const side = cx \u003c 32 ? -1 : 1, y = EYEY + dy, x = floor(cx + dx), u = x + 0.5 - cx, lift = u * side > 1.5 ? 0.6 : 0;\n            const r = (u / 3.3) ** 2 + ((dy + lift) / (2.4 * open + 0.3)) ** 2;\n            if (r > 1.9) continue;\n            const o = (y * W + x) * 3;\n            if (r \u003c= 1) add(buf, o, abs(u) \u003c 0.6 && open > 0.5 ? [10, 10, 10] : r \u003c 0.3 ? [255, 255, 235] : ec, 1);\n            else add(buf, o, ec, 0.3 * open);\n          }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3)\n    display.setPixel(p & 63, p >> 6, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n}\n\nfunction add(buf, o, c, a) {\n  buf[o] += (c[0] - buf[o]) * a;\n  buf[o + 1] += (c[1] - buf[o + 1]) * a;\n  buf[o + 2] += (c[2] - buf[o + 2]) * a;\n}\n","inverse-cascade":"// ===== Patternflow pattern =====\n// Title:   Inverse Cascade\n// Family:  noise\n// Idea:    Two-dimensional turbulence solved on the panel's own 64x128 grid: a field of small random eddies gathers within two seconds into round vortices, red-to-amber ones turning one way and indigo-to-sky-blue ones the other, each ringed by contour bands of its vorticity, and same-sign vortices orbit, wrap each other in thin spiral filaments and merge into fewer and larger ones, carrying the energy up to the large scales while the enstrophy drains away down the filaments, until the energy fills the box and a fresh field of small eddies starts the cascade again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: inverse energy cascade of two-dimensional turbulence (Robert Kraichnan, 1967; George Batchelor, 1969), coherent vortices of decaying two-dimensional turbulence (James McWilliams, 1984), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=-1..1, Viscosity=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together, always half a turn apart. At 0 vorticity of one sign runs from deep crimson through red to amber and the white of a vortex core, and of the other from indigo through blue to sky blue and white; on the panel the warm vortices turn clockwise and the cool ones anticlockwise. At 0.25 lime and magenta, at 0.5 olive and cyan, at 0.75 green and violet. The stream function tints each side a little towards one end or the other of its own range.\n// Knob 2: Speed. Flow time per second. At 2 the eddies gather into round vortices in about 2 seconds; some 60 vortices at 2 seconds are 12 at 8, and a run ends with 6 or 7 after 13 to 22 seconds. At 1 half as fast, at 0.2 a tenth. Above 2 a frame may take a third step, and at 3 a run lasts about 8 seconds. When the flow is too fast for the steps a frame may take, it runs slower instead.\n// Knob 3: Scale. The size of the eddies a run starts from: the noise is filtered round wavenumber 5 at 0, a wavelength of 13 LEDs, round 8.7 at -1 (7 LEDs) and 2.9 at 1 (22 LEDs). At -1 a run lasts about 10 seconds; the big eddies at 1 carry so much energy that the step limit slows them, and a run lasts about 28. Turning it by more than 0.15 starts a fresh run at the new size.\n// Knob 4: Viscosity. The hyperviscosity that takes the enstrophy out at the bottom of its cascade, doubling with every fifth of the knob. At the opening 0.06 a filament two LEDs wide lasts about a tenth of a second and wider ones survive, so the vortices trail long spiral arms; at 1 it is 26 times stronger, filaments up to three LEDs wide dissolve as fast, and the vortices sit in smoother, emptier water.\n// Buttons: K1 tap starts a fresh run of small eddies.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, exp, sqrt, abs, cos, sin, PI, log2, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The panel is a periodic box 2 pi wide and 4 pi tall, one grid step 2 pi / 64\n// either way, so kx runs over the integers and ky over the half-integers.\n// Modes with |kx| or |ky| above 21 are dropped after every product\n// (Orszag's two-thirds rule).\nconst KXC = 21, KYC = 42, DX = (2 * PI) / W;\n// Flow time per panel second at Speed 2, and the Courant number each step\n// keeps to (with |u| + |v|). A frame takes at most two steps up to Speed 2\n// and three above it; when the flow is faster than that allows, it runs\n// slower instead.\nconst RATE = 7.5, CFL = 0.8;\n// Hyperviscosity nu (k / 21)^8: nu at Viscosity 0, doubling with every fifth\n// of the knob.\nconst NU = 12;\n// A run ends when the energy-weighted wavenumber has fallen to this share of\n// the one it started from (but not below 1, the box), or after this much\n// flow time.\nconst KEND = 0.28, RUN = 240;\n// Crossfade into a fresh field, panel seconds.\nconst FADE = 0.7;\n// Colour: the hue of strong warm vorticity at Hue 0; contour bands per unit\n// of the display scale and how deep they cut (reaching full depth above a\n// sixth of the scale); the brightness curve; the share of the largest |w| that\n// shows at full scale; and how far round the wheel the stream function tints.\nconst WARM = 0.09, BANDS = 4, BDEP = 0.4, GAM = 0.4, NORM = 0.7, TINT = 0.08, LUT = 1024;\n\n// ---- radix-2 FFT, in place on (re, im) at off, off + st, off + 2 st, ...\nfunction plan(n) {\n  const lg = log2(n), rev = new Uint16Array(n), c = new Float64Array(n >> 1), s = new Float64Array(n >> 1);\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c lg; b++) r |= ((i >> b) & 1) \u003c\u003c (lg - 1 - b);\n    rev[i] = r;\n  }\n  for (let i = 0; i \u003c n >> 1; i++) (c[i] = cos((2 * PI * i) / n)), (s[i] = sin((2 * PI * i) / n));\n  return { n, rev, c, s, br: new Float64Array(n), bi: new Float64Array(n) };\n}\nfunction fft1(P, re, im, off, st, sign) {\n  const { n, rev, c, s, br, bi } = P;\n  for (let i = 0; i \u003c n; i++) {\n    const j = off + rev[i] * st;\n    br[i] = re[j];\n    bi[i] = im[j];\n  }\n  for (let size = 2; size \u003c= n; size \u003c\u003c= 1) {\n    const half = size >> 1, step = n / size;\n    for (let a0 = 0; a0 \u003c n; a0 += size)\n      for (let k = 0, t = 0; k \u003c half; k++, t += step) {\n        const wr = c[t], wi = sign * s[t], a = a0 + k, b = a + half;\n        const xr = br[b] * wr - bi[b] * wi, xi = br[b] * wi + bi[b] * wr;\n        br[b] = br[a] - xr;\n        bi[b] = bi[a] - xi;\n        br[a] += xr;\n        bi[a] += xi;\n      }\n  }\n  for (let i = 0; i \u003c n; i++) (re[off + i * st] = br[i]), (im[off + i * st] = bi[i]);\n}\n// Only the 43 columns with |kx| \u003c= 21 can be non-zero, so the y transforms\n// run on those alone: after the x transforms going forward (sign -1), before\n// them going back (sign +1). Neither direction divides by N.\nconst COLS = [];\nfor (let x = 0; x \u003c W; x++) if ((x \u003c W / 2 ? x : W - x) \u003c= KXC) COLS.push(x);\nfunction fft2(S, re, im, sign) {\n  if (sign \u003c 0) for (let y = 0; y \u003c H; y++) fft1(S.px, re, im, y * W, 1, sign);\n  for (let t = 0; t \u003c COLS.length; t++) fft1(S.py, re, im, COLS[t], W, sign);\n  if (sign > 0) for (let y = 0; y \u003c H; y++) fft1(S.px, re, im, y * W, 1, sign);\n}\n\n// The vorticity equation dw/dt = -div(u w) for the spectrum (sr, si), into\n// (or, oi), dealiased. One inverse transform brings w and the stream function\n// psi (psi^ = -w^ / k^2) to the grid together, as w + i psi; the velocity\n// u = -dpsi/dy, v = dpsi/dx comes from fourth-order differences of psi; one\n// forward transform takes u w + i v w back, and the two products are pulled\n// apart with the conjugate mode. Leaves w and psi on the grid in br, bi\n// (and their largest sizes in wm, pm) and returns the largest |u| + |v|.\nfunction tendency(S, sr, si, or, oi) {\n  const { kx, ky, ik2, keep, neg, ar, ai, br: om, bi: ps } = S, nk = keep.length;\n  om.fill(0);\n  ps.fill(0);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], r = sr[i] / N, m = si[i] / N, q = ik2[i];\n    om[i] = r + q * m;\n    ps[i] = m - q * r;\n  }\n  fft2(S, om, ps, 1);\n  const c = 1 / (12 * DX);\n  let vmax = 0, wm = 0, pm = 0;\n  for (let y = 0; y \u003c H; y++) {\n    const o = y * W, u1 = ((y + 1) & (H - 1)) * W, d1 = ((y - 1) & (H - 1)) * W, u2 = ((y + 2) & (H - 1)) * W, d2 = ((y - 2) & (H - 1)) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const r1 = (x + 1) & (W - 1), l1 = (x - 1) & (W - 1), r2 = (x + 2) & (W - 1), l2 = (x - 2) & (W - 1);\n      const u = -c * (8 * (ps[u1 + x] - ps[d1 + x]) - (ps[u2 + x] - ps[d2 + x]));\n      const v = c * (8 * (ps[o + r1] - ps[o + l1]) - (ps[o + r2] - ps[o + l2]));\n      const w = om[o + x], p = ps[o + x];\n      ar[o + x] = u * w;\n      ai[o + x] = v * w;\n      const sp = abs(u) + abs(v);\n      if (sp > vmax) vmax = sp;\n      if (w > wm) wm = w;\n      else if (-w > wm) wm = -w;\n      if (p > pm) pm = p;\n      else if (-p > pm) pm = -p;\n    }\n  }\n  S.wm = wm;\n  S.pm = pm;\n  fft2(S, ar, ai, -1);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], j = neg[i], cr = ar[i], ci = ai[i], dr = ar[j], di = ai[j], a = kx[i], b = ky[i];\n    or[i] = 0.5 * (a * (ci - di) - b * (cr - dr));\n    oi[i] = -0.5 * (a * (cr + dr) + b * (ci + di));\n  }\n  return vmax;\n}\n\n// One third-order Adams-Bashforth step of length h with the viscous decay\n// folded in exactly (integrating factor). The two previous tendencies, each\n// already decayed to the present, wait in (p1r, p1i) and (p2r, p2i); the\n// coefficients come from integrating the quadratic through the last three\n// tendencies, so the step may change length. A fresh run starts with an\n// Euler step and a second-order one.\nfunction step(S, h) {\n  const { wr, wi, nr, ni, p1r, p1i, p2r, p2i, lin } = S;\n  S.vmax = tendency(S, wr, wi, nr, ni);\n  // The decay factors for each step length on the ladder are kept, a few\n  // at a time, so a step that comes back costs no exponentials.\n  const key = h * S.nu;\n  let E = S.Ec.get(key);\n  if (!E) {\n    if (S.Ec.size > 8) S.Ec.clear();\n    E = new Float64Array(N);\n    for (let i = 0; i \u003c N; i++) E[i] = exp(-key * lin[i]);\n    S.Ec.set(key, E);\n  }\n  const h1 = S.h1, h2 = S.h2;\n  let c0 = h, c1 = 0, c2 = 0;\n  if (h1 && h2) {\n    const a = (h * h * h) / 3, b = (h * h) / 2;\n    c0 = (a + (2 * h1 + h2) * b + h1 * (h1 + h2) * h) / (h1 * (h1 + h2));\n    c1 = -(a + (h1 + h2) * b) / (h1 * h2);\n    c2 = (a + h1 * b) / ((h1 + h2) * h2);\n  } else if (h1) (c0 = h * (1 + h / (2 * h1))), (c1 = -(h * h) / (2 * h1));\n  for (let t = 0, keep = S.keep, nk = keep.length; t \u003c nk; t++) {\n    const i = keep[t], e = E[i];\n    wr[i] = e * (wr[i] + c0 * nr[i] + c1 * p1r[i] + c2 * p2r[i]);\n    wi[i] = e * (wi[i] + c0 * ni[i] + c1 * p1i[i] + c2 * p2i[i]);\n    p2r[i] = e * p1r[i];\n    p2i[i] = e * p1i[i];\n    p1r[i] = e * nr[i];\n    p1i[i] = e * ni[i];\n  }\n  S.h2 = h1;\n  S.h1 = h;\n}\n\n// A fresh field: white noise filtered to a band round k0, scaled to an rms\n// vorticity of 1.\nfunction seed(S) {\n  const { wr, wi, k2, mask } = S, k0 = S.k0;\n  for (let i = 0; i \u003c N; i++) (wr[i] = Math.random() * 2 - 1), (wi[i] = 0);\n  fft2(S, wr, wi, -1);\n  let z = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const q = k2[i] / (k0 * k0), a = mask[i] && k2[i] > 0 ? q * exp(-q) : 0;\n    wr[i] *= a;\n    wi[i] *= a;\n    z += wr[i] * wr[i] + wi[i] * wi[i];\n  }\n  const g = N / sqrt(z);\n  for (let i = 0; i \u003c N; i++) (wr[i] *= g), (wi[i] *= g);\n  S.age = 0;\n  S.h1 = S.h2 = 0;\n  S.sk = S.scale;\n  S.runs++;\n}\n\n// The energy-weighted mean wavenumber: sum k |w^|^2 / k^2 over sum |w^|^2 / k^2.\nfunction kmean(S) {\n  const { wr, wi, ik2, kk, keep } = S;\n  let e = 0, ek = 0;\n  for (let t = 0; t \u003c keep.length; t++) {\n    const i = keep[t], a = (wr[i] * wr[i] + wi[i] * wi[i]) * ik2[i];\n    e += a;\n    ek += a * kk[i];\n  }\n  return e > 0 ? ek / e : 0;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Four tables from |w| / scale to colour, two for each sign of spin, at two\n// hues the stream function blends between. Weak vorticity is deep crimson on\n// one side and indigo on the other, so it does not sink to brown and navy;\n// strong vorticity climbs to amber and to sky blue, and the cores to white.\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  const c = [0, 0, 0];\n  for (let s = 0; s \u003c 4; s++) {\n    const T = S.pals[s], neg = s & 1, h0 = S.hue + (neg ? WARM + 0.47 : WARM) + ((s & 2 ? 1 : -1) * TINT) / 2;\n    for (let j = 0; j \u003c LUT; j++) {\n      const a = j / (LUT - 1), d = BDEP * cl(a / 0.15, 0, 1);\n      const b = pow(a, GAM) * (1 - d + d * cos(2 * PI * BANDS * a));\n      hsv(h0 + (neg ? 0.15 : -0.11) * (1 - a), 1 - 0.55 * a * a, 1, c, 0);\n      T[j * 3] = 255 * b * c[0];\n      T[j * 3 + 1] = 255 * b * c[1];\n      T[j * 3 + 2] = 255 * b * c[2];\n    }\n  }\n}\n\nexport function setup(params) {\n  const F = () => new Float64Array(N);\n  const S = (params.s = {\n    hue: 0, speed: 2, scale: 0, visc: 0.06, nu: NU, k0: 5, sk: 0, t: 0, age: 0, runs: 0, h1: 0, h2: 0, fade: 0, vmax: 0.4, vs: 0.4, km: 0,\n    px: plan(W), py: plan(H),\n    kx: F(), ky: F(), k2: F(), kk: F(), ik2: F(), lin: F(), mask: new Uint8Array(N), neg: new Int32Array(N),\n    wr: F(), wi: F(), nr: F(), ni: F(), p1r: F(), p1i: F(), p2r: F(), p2i: F(), ar: F(), ai: F(), br: F(), bi: F(),\n    wm: 0, pm: 0, Ec: new Map(),\n    pals: [0, 1, 2, 3].map(() => new Float32Array(LUT * 3)), palHue: -1,\n    old: new Uint8Array(N * 3), cur: new Uint8Array(N * 3), wsc: 0, psc: 0,\n  });\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, jx = x \u003c W / 2 ? x : x - W, jy = y \u003c H / 2 ? y : y - H;\n      S.kx[i] = jx;\n      S.ky[i] = jy / 2;\n      S.k2[i] = jx * jx + (jy * jy) / 4;\n      S.kk[i] = sqrt(S.k2[i]);\n      S.ik2[i] = S.k2[i] > 0 ? 1 / S.k2[i] : 0;\n      S.mask[i] = abs(jx) \u003c= KXC && abs(jy) \u003c= KYC ? 1 : 0;\n      S.neg[i] = ((H - y) % H) * W + ((W - x) % W);\n      const q = S.k2[i] / (KXC * KXC);\n      S.lin[i] = q * q * q * q;\n    }\n  // The modes inside the two-thirds cut, the only ones that are ever\n  // non-zero: the spectral loops run over these 3,655 alone.\n  const keep = [];\n  for (let i = 0; i \u003c N; i++) if (S.mask[i]) keep.push(i);\n  S.keep = Int32Array.from(keep);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.scale = cl(k[2], -1, 1);\n  S.visc = cl(k[3], 0, 1);\n  S.nu = NU * pow(2, 5 * S.visc);\n  S.k0 = 5 * pow(2, -0.8 * S.scale);\n  const ft = cl(dt || 0, 0, 0.1);\n  if (!S.runs) seed(S);\n  else if ((input.btnPressed && input.btnPressed[0]) || abs(S.scale - S.sk) > 0.15 || S.age > RUN || (S.age > 20 && (S.km = (S.km + 1) % 8) === 0 && kmean(S) \u003c max(1, KEND * S.k0))) {\n    S.old.set(S.cur);\n    S.fade = 1;\n    seed(S);\n  }\n  S.fade = max(0, S.fade - ft / FADE);\n  let adv = (ft * S.speed * RATE) / 2;\n  if (adv \u003c= 0) return;\n  // The speed limit holds the highest speed seen and lets it go slowly, so\n  // the step length changes smoothly from frame to frame.\n  S.vs = max(S.vmax, S.vs * 0.98);\n  const hmax = (CFL * DX) / max(1e-6, S.vs);\n  const n = min(S.speed > 2 ? 3 : 2, Math.ceil(adv / hmax));\n  // Steps come from a ladder 16 to an octave, so the decay factors are\n  // worked out again only when the step moves up or down a rung.\n  const h = pow(2, floor(16 * log2(min(adv / n, hmax))) / 16);\n  adv = n * h;\n  for (let j = 0; j \u003c n; j++) step(S, h);\n  S.t += adv;\n  S.age += adv;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.runs) return;\n  palette(S);\n  const { br: om, bi: ps, pals, cur, old } = S, m = S.wm, mp = S.pm;\n  // The scales follow the field slowly, so a merger does not flash.\n  S.wsc = S.wsc ? S.wsc + (m - S.wsc) * 0.05 : m;\n  S.psc = S.psc ? S.psc + (mp - S.psc) * 0.05 : mp;\n  const sc = (LUT - 1) / max(1e-6, S.wsc * NORM), tp = 0.5 / max(1e-9, S.psc);\n  const f = S.fade, g = 1 - f;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, w = om[i], j = min(LUT - 1, round(abs(w) * sc)) * 3, s = w > 0 ? 0 : 1, A = pals[s], B = pals[s + 2], o = i * 3;\n      const t = cl(0.5 + ps[i] * tp, 0, 1), u = 1 - t;\n      cur[o] = A[j] * u + B[j] * t;\n      cur[o + 1] = A[j + 1] * u + B[j + 1] * t;\n      cur[o + 2] = A[j + 2] * u + B[j + 2] * t;\n      if (f > 0) display.setPixel(x, y, cur[o] * g + old[o] * f, cur[o + 1] * g + old[o + 1] * f, cur[o + 2] * g + old[o + 2] * f);\n      else display.setPixel(x, y, cur[o], cur[o + 1], cur[o + 2]);\n    }\n}\n","motility-clusters":"// ===== Patternflow pattern =====\n// Title:   Motility Clusters\n// Family:  particle\n// Idea:    About 1,400 self-propelled discs swim round the periodic panel, each along its own slowly wandering heading and touching the others only to be pushed apart, and above a persistence threshold they jam into pale packed clusters edged by discs that face inward, coloured round the wheel by heading, while a faint gas of free swimmers runs between them and the clusters merge.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: motility-induced phase separation of active Brownian particles (Yaouen Fily and M. Cristina Marchetti, 2012; Michael Cates and Julien Tailleur, 2015), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pe=-1..1, Packing=0.55..0.72\n//\n// Knob 1: Hue. Turns the heading wheel and the tint of the packed discs together. At 0 a disc swimming down is red, down-left yellow, up-left green, up cyan, up-right blue and down-right magenta, so a cluster's edge, where the discs face inward, runs pink-red along its top, cyan along its bottom, violet on its left and yellow-green on its right; packed discs are pale lavender. At 0.25 the tint is pale cyan, at 0.5 pale lime and at 0.75 pale pink.\n// Knob 2: Speed. At 2 the discs swim 20 LEDs, ten diameters, a second, at 0.2 a tenth of that and at 3 half as fast again; the turning and the clustering keep pace. The head start before the first frame is always 4 seconds of swimming.\n// Knob 3: Pe. The Peclet number v0 / (sigma Dr), the distance in diameters a disc swims before its heading forgets itself, 40 times 8 to the knob. At -1 (Pe 5, a heading lasts half a second at Speed 2) the discs stay a gas of brief clumps, the largest holding a tenth of them; at -0.5 (Pe 14) two fifths; at 0 (Pe 40, four seconds) two thirds after ten seconds, with a third already in one cluster 2.5 s in; at 1 (Pe 320) four fifths.\n// Knob 4: Packing. The share of the panel the discs would cover laid flat: 0.55 at the start (1,434 discs), where clusters sit in a gas, to 0.72 (1,877 discs), where the packed phase fills most of the panel and the gas lives in dark bubbles. New discs drop in at random places and taken ones leave from random places.\n// Buttons: K1 tap scatters every disc into a fresh uniform gas, and the clusters gather again over the next few seconds.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, round, PI, pow, exp } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Disc diameter in LEDs. The neighbour grid is 32 by 64 cells one diameter\n// wide, so two discs that overlap are in the same or neighbouring cells.\nconst SIG = 2, S2 = SIG * SIG, GX = 32, GY = 64, NC = GX * GY, CW = W / GX, LIST2 = (SIG + 0.25) ** 2;\n// Swim speed in LEDs a second at Speed 2 (ten diameters a second), the step,\n// and how many passes push overlapping pairs apart in each step.\nconst V0 = 20, HS = 1 / 80, SWEEPS = 6;\n// Most discs the Packing knob can ask for, room for the pair list, and the\n// head start: seconds of swimming run before the first frame, so the panel\n// opens on clusters already gathering out of the gas.\nconst NMAX = 1900, PMAX = NMAX * 8, PRE = 4;\n// Drawing: the squared radius of a disc's splash of light in LEDs, how pale\n// the packed discs' tint is, the light of a packed disc and of a lone one,\n// and where the heading wheel starts.\nconst KR = 2.2, TS = 0.25, LC = 0.92, L0 = 0.3, HUE0 = 0.25;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, pe: 40, phi: 0.55, n: 0, t: 0, acc: 0, pre: false,\n    x: new Float64Array(NMAX), y: new Float64Array(NMAX), c: new Float64Array(NMAX), s: new Float64Array(NMAX),\n    cr: new Float32Array(NMAX), ex: new Float32Array(NMAX), ey: new Float32Array(NMAX),\n    x2: new Float64Array(NMAX), y2: new Float64Array(NMAX), c2: new Float64Array(NMAX), s2: new Float64Array(NMAX),\n    cr2: new Float32Array(NMAX), ex2: new Float32Array(NMAX), ey2: new Float32Array(NMAX),\n    kn: new Float32Array(NMAX), kx: new Float32Array(NMAX), ky: new Float32Array(NMAX),\n    pl: new Int32Array(PMAX), m: 0, cell: new Int32Array(NMAX), cnt: new Int32Array(NC + 1), fill: new Int32Array(NC),\n    bw: new Float32Array(NP), br: new Float32Array(NP), bg: new Float32Array(NP), bb: new Float32Array(NP),\n  };\n}\n\n// A uniform gas: discs dropped anywhere, headings anywhere.\nfunction place(S, n) {\n  for (let i = S.n; i \u003c n; i++) {\n    S.x[i] = Math.random() * W;\n    S.y[i] = Math.random() * H;\n    const a = Math.random() * TAU;\n    S.c[i] = Math.cos(a);\n    S.s[i] = Math.sin(a);\n    S.cr[i] = S.ex[i] = S.ey[i] = 0;\n  }\n  S.n = n;\n}\n\n// Takes discs away at random until n are left. The arrays are in grid order,\n// so cutting the tail would empty the bottom of the panel.\nfunction drop(S, n) {\n  const { x, y, c, s, cr, ex, ey } = S;\n  while (S.n > n) {\n    const i = floor(Math.random() * S.n), j = --S.n;\n    x[i] = x[j];\n    y[i] = y[j];\n    c[i] = c[j];\n    s[i] = s[j];\n    cr[i] = cr[j];\n    ex[i] = ex[j];\n    ey[i] = ey[j];\n  }\n}\n\n// Sorts the discs by grid cell, moving every per-disc array along, so the\n// pushes below walk memory in order. cnt holds where each cell starts.\nfunction sort(S) {\n  const { cell, cnt, fill, n } = S;\n  const { x, y, c, s, cr, ex, ey } = S;\n  cnt.fill(0);\n  for (let i = 0; i \u003c n; i++) {\n    const k = floor(x[i] / CW) + GX * floor(y[i] / CW);\n    cell[i] = k;\n    cnt[k + 1]++;\n  }\n  for (let k = 0; k \u003c NC; k++) cnt[k + 1] += cnt[k];\n  fill.set(cnt.subarray(0, NC));\n  const X = S.x2, Y = S.y2, C = S.c2, Sn = S.s2, R = S.cr2, EX = S.ex2, EY = S.ey2;\n  for (let i = 0; i \u003c n; i++) {\n    const o = fill[cell[i]]++;\n    X[o] = x[i];\n    Y[o] = y[i];\n    C[o] = c[i];\n    Sn[o] = s[i];\n    R[o] = cr[i];\n    EX[o] = ex[i];\n    EY[o] = ey[i];\n  }\n  S.x2 = x, S.y2 = y, S.c2 = c, S.s2 = s, S.cr2 = cr, S.ex2 = ex, S.ey2 = ey;\n  S.x = X, S.y = Y, S.c = C, S.s = Sn, S.cr = R, S.ex = EX, S.ey = EY;\n}\n\n// One step of h seconds: every disc swims V0 h along its heading, the\n// heading turns by rotational diffusion dr, then overlapping pairs are pushed\n// apart along the line between them, half the overlap each, the overdamped\n// limit of a stiff short-range spring. Nothing attracts.\nfunction step(S, h, dr) {\n  swim(S, S.n, sqrt(6 * dr * h), V0 * h);\n  sort(S);\n  const m = (S.m = pushGrid(S.x, S.y, S.cnt, S.pl));\n  for (let sw = 1; sw \u003c SWEEPS; sw++) pushList(S.x, S.y, S.pl, m);\n  wrap(S.x, S.y, S.n);\n}\n\nfunction swim(S, n, amp, d) {\n  const { x, y, c, s } = S;\n  for (let i = 0; i \u003c n; i++) {\n    const xi = x[i] + d * c[i], yi = y[i] + d * s[i];\n    x[i] = xi \u003c 0 ? xi + W : xi >= W ? xi - W : xi;\n    y[i] = yi \u003c 0 ? yi + H : yi >= H ? yi - H : yi;\n    const e = amp * (2 * Math.random() - 1), ci = c[i], si = s[i], q = 1 - 0.5 * e * e;\n    c[i] = ci * q - si * e;\n    s[i] = si * q + ci * e;\n  }\n}\n\n// The first pass searches the grid and pushes. It also lists every pair\n// closer than SIG + 0.25, and the later passes push only those. Returns the\n// list's length.\nfunction pushGrid(x, y, cnt, pl) {\n  let m = 0;\n  for (let cy = 0; cy \u003c GY; cy++) {\n    const dn = (cy + 1 === GY ? 0 : cy + 1) * GX, r0 = cy * GX;\n    for (let cx = 0; cx \u003c GX; cx++) {\n      const k0 = r0 + cx, a0 = cnt[k0], a1 = cnt[k0 + 1];\n      if (a0 === a1) continue;\n      const xr = cx + 1 === GX ? 0 : cx + 1, xl = cx === 0 ? GX - 1 : cx - 1;\n      for (let q = 0; q \u003c 5; q++) {\n        const k = q === 0 ? k0 : q === 1 ? r0 + xr : q === 2 ? dn + xl : q === 3 ? dn + cx : dn + xr;\n        const b0 = cnt[k], b1 = cnt[k + 1];\n        for (let i = a0; i \u003c a1; i++)\n          for (let j = q === 0 ? i + 1 : b0; j \u003c b1; j++) {\n            const dx = near(x[j] - x[i], W), dy = near(y[j] - y[i], H), r2 = dx * dx + dy * dy;\n            if (r2 >= LIST2) continue;\n            if (m \u003c PMAX) (pl[m++] = i), (pl[m++] = j);\n            if (r2 \u003c S2 && r2 > 0) push(x, y, i, j, dx, dy, r2);\n          }\n      }\n    }\n  }\n  return m;\n}\n\nfunction pushList(x, y, pl, m) {\n  for (let p = 0; p \u003c m; p += 2) {\n    const i = pl[p], j = pl[p + 1];\n    const dx = near(x[j] - x[i], W), dy = near(y[j] - y[i], H), r2 = dx * dx + dy * dy;\n    if (r2 \u003c S2 && r2 > 0) push(x, y, i, j, dx, dy, r2);\n  }\n}\n\n// The shortest way round the periodic panel.\nconst near = (d, L) => (d > L / 2 ? d - L : d \u003c -L / 2 ? d + L : d);\n\nfunction push(x, y, i, j, dx, dy, r2) {\n  const r = sqrt(r2), f = (0.5 * (SIG - r)) / r;\n  x[i] -= f * dx;\n  y[i] -= f * dy;\n  x[j] += f * dx;\n  y[j] += f * dy;\n}\n\nfunction wrap(x, y, n) {\n  for (let i = 0; i \u003c n; i++) {\n    x[i] = x[i] \u003c 0 ? x[i] + W : x[i] >= W ? x[i] - W : x[i];\n    y[i] = y[i] \u003c 0 ? y[i] + H : y[i] >= H ? y[i] - H : y[i];\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.55];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.pe = 40 * pow(8, cl(k[2], -1, 1));\n  S.phi = cl(k[3], 0.55, 0.72);\n  if (input.btnPressed && input.btnPressed[0]) S.n = 0;\n  const want = min(NMAX, round((S.phi * NP) / (PI * S2 * 0.25)));\n  if (want > S.n) place(S, want);\n  else if (want \u003c S.n) drop(S, want);\n  // Pe = V0 / (SIG Dr), the persistence length in diameters.\n  const dr = V0 / (SIG * S.pe);\n  let run = cl(dt || 0, 0, 0.1) * (S.speed / 2);\n  if (!S.pre) {\n    S.pre = true;\n    run += PRE;\n  }\n  S.acc += run;\n  let ran = 0;\n  while (S.acc >= HS) {\n    step(S, HS, dr);\n    S.acc -= HS;\n    S.t += HS;\n    ran += HS;\n  }\n  if (ran > 0) touch(S, 1 - exp(-ran * 8));\n}\n\n// Each disc's neighbours from the last step's pair list: how many touch it\n// and the sum of the directions to them, eased so the light does not\n// flicker with every knock. A disc packed all round has many neighbours and\n// a short sum; a disc at the edge of a cluster has them all on one side.\nfunction touch(S, k) {\n  const { x, y, pl, m, kn, kx, ky, cr, ex, ey, n } = S;\n  kn.fill(0, 0, n);\n  kx.fill(0, 0, n);\n  ky.fill(0, 0, n);\n  for (let p = 0; p \u003c m; p += 2) {\n    const i = pl[p], j = pl[p + 1];\n    const dx = near(x[j] - x[i], W), dy = near(y[j] - y[i], H), r = sqrt(dx * dx + dy * dy) + 1e-9;\n    kn[i]++;\n    kn[j]++;\n    kx[i] += dx / r;\n    ky[i] += dy / r;\n    kx[j] -= dx / r;\n    ky[j] -= dy / r;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    cr[i] += (kn[i] - cr[i]) * k;\n    ex[i] += (kx[i] - ex[i]) * k;\n    ey[i] += (ky[i] - ey[i]) * k;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { x, y, c, s, cr, ex, ey, bw, br, bg, bb, n } = S;\n  bw.fill(0);\n  br.fill(0);\n  bg.fill(0);\n  bb.fill(0);\n  // The colour wheel by heading: each channel is full for discs swimming\n  // within 60 degrees of its own direction and dark beyond 120, a third of a\n  // turn apart. Discs packed all round fade to one pale tint.\n  const h0 = (S.hue + HUE0) * TAU;\n  const ar = Math.cos(h0), as = Math.sin(h0), ag = Math.cos(h0 + TAU / 3), gs = Math.sin(h0 + TAU / 3), ab = Math.cos(h0 - TAU / 3), bs = Math.sin(h0 - TAU / 3);\n  const tr = 1 - TS + TS * cl(0.5 + ar, 0, 1), tg = 1 - TS + TS * cl(0.5 + ag, 0, 1), tb = 1 - TS + TS * cl(0.5 + ab, 0, 1);\n  for (let i = 0; i \u003c n; i++) {\n    const k = cr[i], e = sqrt(ex[i] * ex[i] + ey[i] * ey[i]) / max(k, 1), ci = c[i], si = s[i];\n    const lum = L0 + (LC - L0) * cl((k - 0.5) / 3.5, 0, 1), u = cl((k - 3) / 2, 0, 1) * cl(1 - 1.6 * e, 0, 1), v = 1 - u;\n    const r = lum * (v * cl(0.5 + ci * ar + si * as, 0, 1) + u * tr);\n    const g = lum * (v * cl(0.5 + ci * ag + si * gs, 0, 1) + u * tg);\n    const b = lum * (v * cl(0.5 + ci * ab + si * bs, 0, 1) + u * tb);\n    const px = x[i], py = y[i], ix = floor(px), iy = floor(py);\n    for (let yy = iy - 1; yy \u003c= iy + 1; yy++)\n      for (let xx = ix - 1; xx \u003c= ix + 1; xx++) {\n        const dx = xx + 0.5 - px, dy = yy + 0.5 - py, w = 1 - (dx * dx + dy * dy) / KR;\n        if (w \u003c= 0) continue;\n        const o = ((yy + H) & 127) * W + ((xx + W) & 63);\n        bw[o] += w;\n        br[o] += w * r;\n        bg[o] += w * g;\n        bb[o] += w * b;\n      }\n  }\n  for (let p = 0, yy = 0; yy \u003c H; yy++)\n    for (let xx = 0; xx \u003c W; xx++, p++) {\n      const w = bw[p], f = w > 1 ? 1 / w : 1;\n      display.setPixel(xx, yy, q4(br[p] * f), q4(bg[p] * f), q4(bb[p] * f));\n    }\n}\n\n// Channels in steps of 4 of 255, from 0..1.\nconst q4 = (v) => ((v * 63 + 0.5) | 0) \u003c\u003c 2;\n\n","murmuration":"// ===== Patternflow pattern =====\n// Title:   Murmuration\n// Family:  halloween\n// Idea:    Over a black treeline at sundown a murmuration of crows swirls and folds against a sky running from violet to hot orange, then every bird sweeps to its place in a giant skull whose eye sockets, nose and the gaps between its teeth let the sky through, the skull holds and looks about with glinting eyes and a chattering jaw, and bursts back into the flock.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Flock=0..1, Shape=0..1\n//\n// Knob 1: Hue. Turns the sunset round the wheel. At 0 violet overhead through hot pink and orange to a yellow glow round a low sun; at 0.25 brick red overhead through gold to lime; at 0.5 green to cyan; at 0.75 sky blue through violet to pink. The crows stay black, the sun cream and the glints in the eyes toxic green.\n// Knob 2: Speed. At 2 the flock swirls 1.4 s before the first call, the birds take 1.9 s to sweep into the shape, the shape holds 1.5 s, the burst takes 1.6 s, and the flock swirls 5 s before the next call, a call every 10 s. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Flock. How many crows: 500 at 0, 750 at 0.25, 1,000 at 0.5 and 1,500 at 1. A small flock is a cloud of specks that darkens to a band when it turns edge on, and fills the skull with each bird's wings spread over five LEDs; a large one folds into black sheets and holds one LED and a bit more of the skull per bird, 1.7 at 1,500.\n// Knob 4: Shape. What the flock forms. Up to 0.25 a skull 54 LEDs wide and 72 tall whose jaw drops twice and whose eyes glint and look left and right; to 0.5 a bat 62 LEDs across that beats its wings with glinting eyes; to 0.75 a crescent moon 54 LEDs tall that rocks; above 0.75 the three in turn.\n// Buttons: K1 tap calls the flock into its shape at once.\n\nconst W = 64, H = 128, N = W * H, MAXB = 1500;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Seconds at Speed 2: the first swirl, later swirls, the sweep into the\n// shape, the hold and the burst.\nconst T0 = 1.4, TS = 5, TG = 1.9, TH = 1.5, TB = 1.6;\n\n// The shapes, tested at LED centres; u is across from the middle column.\nconst SKULL = 0, BAT = 1, MOON = 2;\nconst CENTRE = [[32, 57], [32, 50], [32, 55]];\nfunction skull(u, y) {\n  const au = abs(u);\n  let inside = (u / 27) ** 2 + ((y - 47) / 26) ** 2 \u003c 1 && y \u003c 66;\n  // Cheekbones, then the upper jaw, then the chin.\n  if (y >= 54 && y \u003c 80 && au \u003c 23.5 - max(0, y - 66) * 0.4) inside = true;\n  if (y >= 80 && y \u003c 93 && au \u003c 16 - max(0, y - 87) * 1.1) inside = true;\n  if (!inside) return false;\n  // Eye sockets, flattened under the brow and sloping to the nose.\n  const du = au - 11.5;\n  if ((du / 8.5) ** 2 + ((y - 57.5) / 7.5) ** 2 \u003c 1 && y > 50 + 0.18 * (au - 3)) return false;\n  // The nose, an upturned heart.\n  if (y >= 66 && y \u003c 75 && au \u003c (y - 66) * 0.45 + 0.6 && !(y > 72 && au \u003c 0.6)) return false;\n  // The mouth line and the gaps between the teeth.\n  if (y >= 82 && y \u003c 83 && au \u003c 14) return false;\n  if (y >= 78 && y \u003c 87 && au \u003c 12 && floor(u + 12) % 4 === 0) return false;\n  return true;\n}\nfunction bat(u, y) {\n  const s = abs(u);\n  if ((u / 5) ** 2 + ((y - 54) / 9.5) ** 2 \u003c 1) return true;\n  if ((u / 5.2) ** 2 + ((y - 44) / 5) ** 2 \u003c 1) return true;\n  if (y >= 35 && y \u003c 42 && abs(s - 3) \u003c (y - 35) * 0.35) return true;\n  if (s \u003c 4 || s > 31) return false;\n  // The arm rises from the shoulder to the wing tip; the trailing edge hangs\n  // from four finger tips in scallops.\n  const top = s \u003c 26 ? 48 - 13 * sin((((s - 4) / 22) * PI) / 2) : 35 + (s - 26) * 0.7;\n  const f = (s - 4) / 9, k = min(2, floor(f)), fr = f - k;\n  const tips = [66, 59, 51, 40];\n  const bottom = tips[k] + (tips[k + 1] - tips[k]) * fr - 5.5 * sin(PI * fr);\n  return y > top && y \u003c bottom;\n}\nfunction moon(u, y) {\n  return u * u + (y - 55) ** 2 \u003c 27 * 27 && (u - 11) ** 2 + (y - 46) ** 2 > 23 * 23;\n}\nconst SHAPES = [skull, bat, moon];\n\n// Ordered-dither rank of an LED, so the first n cells of a shape taken in\n// this order are spread evenly over it.\nfunction bayer(x, y) {\n  let v = 0;\n  for (let b = 0; b \u003c 3; b++) {\n    const xb = (x >> b) & 1, yb = (y >> b) & 1;\n    v |= (((xb ^ yb) \u003c\u003c 1) | yb) \u003c\u003c (2 * (2 - b));\n  }\n  return v;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: -1, speed: 2, flock: 0, shapeK: 0.06, nb: 500,\n    t: 0, ph: \"swirl\", pt: 0, tswirl: T0, shape: SKULL, turn: 0,\n    // Per bird: place in the flock's sheet, depth, start delay, arc, burst\n    // direction and speed, flap phase.\n    a: new Float32Array(MAXB), b: new Float32Array(MAXB), w: new Float32Array(MAXB),\n    dl: new Float32Array(MAXB), arc: new Float32Array(MAXB), bd: new Float32Array(MAXB), bv: new Float32Array(MAXB),\n    // Slot: where it sits in the shape, and the LED it was cut from.\n    tx: new Float32Array(MAXB), ty: new Float32Array(MAXB), tc: new Int32Array(MAXB).fill(-1),\n    px: new Float32Array(MAXB), py: new Float32Array(MAXB), c: new Float32Array(MAXB),\n    order: new Int32Array(MAXB), key: new Float32Array(MAXB),\n    masks: SHAPES.map((fn) => {\n      const m = new Uint8Array(N);\n      for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) m[y * W + x] = fn(x + 0.5 - 32, y + 0.5) ? 1 : 0;\n      return m;\n    }),\n    ranked: [], disc: [], dark: new Float32Array(N), bg: new Float32Array(N * 3), glint: 0, look: 0,\n  });\n  for (let i = 0; i \u003c MAXB; i++) {\n    const r = sqrt(Math.random()), th = Math.random() * 2 * PI;\n    S.a[i] = r * cos(th);\n    S.b[i] = r * sin(th);\n    S.w[i] = (Math.random() - 0.5) * 6;\n    S.dl[i] = Math.random();\n    S.arc[i] = (Math.random() - 0.5) * 2;\n    S.bd[i] = (Math.random() - 0.5) * 1.6;\n    S.bv[i] = 30 + Math.random() * 45;\n  }\n  // Cells of each shape in dither order.\n  S.ranked = S.masks.map((m) => {\n    const cells = [];\n    for (let p = 0; p \u003c N; p++) if (m[p]) cells.push(p);\n    const r = cells.map((p) => bayer(p % W & 7, floor(p / W) & 7) + hash(p) * 0.99);\n    return cells.map((p, i) => [r[i], p]).sort((x, y) => x[0] - y[0]).map((e) => e[1]);\n  });\n  scenery(S);\n}\n\n// Where bird i flies in the flock at time t: a sheet of birds, bent by a\n// travelling fold, turned in depth and seen from the side, so it thins out\n// when it faces us and darkens to a band when it turns edge on.\nfunction sheet(S, i, t, out) {\n  const al = 0.21 * t, ca = cos(al), sa = sin(al);\n  let a = S.a[i] * ca - S.b[i] * sa;\n  const b = S.a[i] * sa + S.b[i] * ca;\n  a += 0.16 * sin(3.1 * b - 1.9 * t);\n  const X = a * (24 + 5 * sin(0.53 * t)), Y = b * (18 + 5 * sin(0.47 * t + 2));\n  const Z = 11 * sin(2.3 * a + 1.4 * t + b) + S.w[i];\n  const th = 1.15 * sin(0.37 * t) + 0.35 * sin(0.93 * t + 1), ph = 0.8 * sin(0.29 * t + 1);\n  const x3 = X * cos(th) + Z * sin(th), z3 = Z * cos(th) - X * sin(th);\n  out[0] = 33 + 9 * sin(0.5 * t + 0.6) + x3;\n  out[1] = 47 + 17 * sin(0.37 * t + 0.5) + Y * cos(ph) + z3 * sin(ph);\n}\n\n// Hand each bird a slot: birds and slots both taken round in angle, so the\n// flock pours into the shape from the side it is on.\nfunction call(S) {\n  const n = S.nb, sh = S.shape, cells = S.ranked[sh], [cx, cy] = CENTRE[sh], o = [0, 0];\n  const slots = [];\n  for (let k = 0; k \u003c n; k++) {\n    const p = cells[k % cells.length], x = (p % W) + 0.5, y = floor(p / W) + 0.5;\n    slots.push([atan2(y - cy, x - cx), x, y, p]);\n  }\n  slots.sort((p, q) => p[0] - q[0]);\n  let mx = 0, my = 0;\n  for (let i = 0; i \u003c n; i++) sheet(S, i, S.t, o), (S.px[i] = o[0]), (S.py[i] = o[1]), (mx += o[0]), (my += o[1]);\n  (mx /= n), (my /= n);\n  const ord = Array.from({ length: n }, (_, i) => i);\n  for (let i = 0; i \u003c n; i++) S.key[i] = atan2(S.py[i] - my, S.px[i] - mx);\n  ord.sort((p, q) => S.key[p] - S.key[q]);\n  for (let k = 0; k \u003c n; k++) {\n    const i = ord[k], s = slots[k];\n    (S.tx[i] = s[1]), (S.ty[i] = s[2]), (S.tc[i] = s[3]);\n  }\n  for (let i = n; i \u003c MAXB; i++) S.tc[i] = -1;\n  // Each bird's wings spread to cover the LEDs between slots.\n  const rho = 0.9 * sqrt(cells.length / n) + 0.5;\n  S.disc = [];\n  const R = Math.ceil(rho);\n  for (let dy = -R; dy \u003c= R; dy++) for (let dx = -R; dx \u003c= R; dx++) if (dx * dx + dy * dy \u003c= rho * rho) S.disc.push(dx, dy);\n}\n\n// How the shape moves while it holds: the skull's jaw drops twice, the bat\n// beats its wings, the moon rocks.\nfunction holdMove(S, x, y, out) {\n  const h = S.ph === \"hold\" ? S.pt : 0;\n  (out[0] = x), (out[1] = y);\n  if (S.shape === SKULL) {\n    if (y > 82) out[1] += 3.5 * abs(sin(PI * cl((h - 0.35) / 0.4, 0, 2)));\n  } else if (S.shape === BAT) {\n    const s = abs(x - 32);\n    out[1] += (s > 4 ? ((s - 4) / 27) ** 1.3 : 0) * 9 * sin(h * 2 * PI * 1.4);\n  } else {\n    const an = 0.16 * sin(h * 2 * PI * 0.8), dx = x - 32, dy = y - 55;\n    out[0] = 32 + dx * cos(an) - dy * sin(an);\n    out[1] = 55 + dx * sin(an) + dy * cos(an);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) (S.hue = hue), scenery(S);\n  S.speed = cl(k[1], 0.2, 3);\n  S.flock = cl(k[2], 0, 1);\n  S.shapeK = cl(k[3], 0, 1);\n  S.nb = round(500 + 1000 * S.flock);\n  const d = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += d;\n  S.pt += d;\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (S.ph === \"swirl\" && (S.pt > S.tswirl || tap)) {\n    const q = S.shapeK;\n    S.shape = q \u003c 0.25 ? SKULL : q \u003c 0.5 ? BAT : q \u003c 0.75 ? MOON : S.turn++ % 3;\n    call(S);\n    (S.ph = \"gather\"), (S.pt = 0);\n  } else if (S.ph === \"gather\" && S.pt > TG) (S.ph = \"hold\"), (S.pt = 0);\n  else if (S.ph === \"hold\" && S.pt > TH) (S.ph = \"burst\"), (S.pt = 0);\n  else if (S.ph === \"burst\" && S.pt > TB) (S.ph = \"swirl\"), (S.pt = 0), (S.tswirl = TS);\n  // Eye glints and where they look, for the skull and the bat.\n  const h = S.ph === \"hold\" ? S.pt : -1;\n  S.glint = h \u003c 0 ? 0 : sm(h / 0.25) * sm((TH - h) / 0.3);\n  S.look = h \u003c 0 ? 0 : 2.5 * sin(h * 2 * PI * 0.75);\n  // Bird positions and how close each is to its slot.\n  const o = [0, 0], m = [0, 0], g = S.pt, ph = S.ph;\n  for (let i = 0; i \u003c S.nb; i++) {\n    sheet(S, i, S.t, o);\n    let x = o[0], y = o[1], c = 0;\n    if (S.tc[i] >= 0 && ph !== \"swirl\") {\n      holdMove(S, S.tx[i], S.ty[i], m);\n      if (ph === \"gather\") {\n        const e = sm(cl((g - 0.6 * S.dl[i]) / (TG - 0.65), 0, 1)), dx = m[0] - x, dy = m[1] - y;\n        // A swoop off the straight line, widest halfway.\n        const sw = sin(PI * e) * S.arc[i] * 0.35;\n        x += dx * e - dy * sw;\n        y += dy * e + dx * sw;\n        c = sm((e - 0.88) / 0.12);\n      } else if (ph === \"hold\") (x = m[0]), (y = m[1]), (c = 1);\n      else {\n        // Out from the middle of the shape, slowing, then back into the sheet.\n        const [cx, cy] = CENTRE[S.shape], an = atan2(m[1] - cy, m[0] - cx) + S.bd[i];\n        const r = (S.bv[i] * (1 - exp(-g * 3.2))) / 3.2, f = sm((g - 0.35) / (TB - 0.35));\n        x = (m[0] + cos(an) * r) * (1 - f) + x * f;\n        y = (m[1] + sin(an) * r - 6 * g * g) * (1 - f) + y * f;\n        c = 1 - sm(g / 0.12);\n      }\n    }\n    (S.px[i] = x), (S.py[i] = y), (S.c[i] = c);\n  }\n}\n\n// The sky, the sun on the horizon, the treeline and the field, redrawn when\n// the hue turns.\nconst STOPS = [[0, 0.77, 0.66, 0.8], [34, 0.88, 0.62, 0.92], [62, 0.98, 0.7, 1], [86, 1.06, 0.8, 1], [102, 1.12, 0.55, 1]];\nfunction treeTop(x) {\n  return 101 + 2 * sin(x / 6.3 + 1) + 1.5 * sin(x / 2.7) - 5 * max(0, sin(x / 4.1 + 2)) ** 6 - 3 * max(0, sin(x / 2.2)) ** 8;\n}\n// A dead tree on each side: trunk and branches as segments [x0, y0, x1, y1, width].\nconst TREES = [\n  [5, 104, 7, 66, 2.2], [7, 66, 4, 56, 1.2], [6.5, 76, 14, 66, 1.2], [14, 66, 19, 64, 0.8], [5.5, 84, 0, 76, 1.2], [6, 70, 9, 58, 0.9],\n  [58, 104, 57, 80, 1.8], [57, 80, 61, 72, 1], [57, 88, 50, 80, 1], [50, 80, 47, 81, 0.7], [57.5, 84, 64, 82, 0.8],\n];\nfunction scenery(S) {\n  const bg = S.bg, c = [0, 0, 0], hu = S.hue \u003c 0 ? 0 : S.hue;\n  for (let y = 0; y \u003c H; y++) {\n    let k = 0;\n    while (k \u003c STOPS.length - 2 && y > STOPS[k + 1][0]) k++;\n    const A = STOPS[k], B = STOPS[k + 1], f = cl((y - A[0]) / (B[0] - A[0]), 0, 1);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      hsv(A[1] + (B[1] - A[1]) * f + hu, A[2] + (B[2] - A[2]) * f, A[3] + (B[3] - A[3]) * f, c, 0);\n      // The sun, low and half sunk, with two steps of glow round it.\n      const r = sqrt((x + 0.5 - 40) ** 2 + (y + 0.5 - 104) ** 2);\n      const sun = r \u003c 12 ? 1 : r \u003c 15 ? 0.55 : r \u003c 19 ? 0.25 : 0;\n      if (sun) for (let j = 0; j \u003c 3; j++) c[j] += (255 * [1, 0.95, 0.75][j] - c[j]) * sun;\n      let dark = y >= treeTop(x);\n      for (const [x0, y0, x1, y1, w] of TREES) {\n        const vx = x1 - x0, vy = y1 - y0, t = cl(((x + 0.5 - x0) * vx + (y + 0.5 - y0) * vy) / (vx * vx + vy * vy), 0, 1);\n        if ((x + 0.5 - x0 - vx * t) ** 2 + (y + 0.5 - y0 - vy * t) ** 2 \u003c (w * (1 - 0.3 * t)) ** 2) dark = true;\n      }\n      if (dark) {\n        // The field below the trees, a dark plum with furrows.\n        const fy = y - 108, fu = fy > 0 ? (x - 32) / (fy + 6) : 0;\n        const v = fy > 0 ? (abs(fu * 3 - round(fu * 3)) \u003c 0.12 ? 0.2 : 0.14) * min(1, fy / 10) : 0;\n        hsv(0.8 + hu, 0.6, v, c, 0);\n      }\n      for (let j = 0; j \u003c 3; j++) bg[p * 3 + j] = c[j];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const D = S.dark, bg = S.bg, disc = S.disc;\n  D.fill(0);\n  for (let i = 0; i \u003c S.nb; i++) {\n    const x = S.px[i], y = S.py[i], c = S.c[i];\n    const xi = floor(x), yi = floor(y);\n    if (c \u003c 1 && xi >= 0 && xi \u003c W && yi >= 0 && yi \u003c H) {\n      // A banking wave runs through the flock: where it passes, the birds\n      // show their spread wings and the cloud darkens in a moving band.\n      const bank = sin(2.4 * S.a[i] + 1.3 * S.b[i] - 2.6 * S.t), wing = bank > 0.55 ? 0.75 * (1 - c) : 0;\n      D[yi * W + xi] += (0.62 + 0.3 * bank * bank) * (1 - c);\n      if (wing && xi + 1 \u003c W) D[yi * W + xi + 1] += wing;\n    }\n    if (c > 0) {\n      // Wings spread over the slot's share of the shape, cut to the shape so\n      // the holes stay sharp.\n      const m = S.masks[S.shape], tc = S.tc[i], tx = tc % W, ty = floor(tc / W);\n      for (let j = 0; j \u003c disc.length; j += 2) {\n        const dx = disc[j], dy = disc[j + 1], X = xi + dx, Y = yi + dy, sx = tx + dx, sy = ty + dy;\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H || sx \u003c 0 || sx >= W || sy \u003c 0 || sy >= H || !m[sy * W + sx]) continue;\n        D[Y * W + X] += c;\n      }\n    }\n  }\n  // Glints: two toxic green points in the skull's sockets or the bat's eyes.\n  const gl = S.glint, eyes = gl > 0 && S.shape !== MOON ? (S.shape === SKULL ? [[20.5 + S.look, 58], [43.5 + S.look, 58]] : [[30 + S.look * 0.3, 44], [34 + S.look * 0.3, 44]]) : [];\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, k = 1 - min(1, D[p]);\n      let r = bg[p * 3] * k, g = bg[p * 3 + 1] * k, b = bg[p * 3 + 2] * k;\n      for (const [ex, ey] of eyes) {\n        const q = abs(x + 0.5 - ex) + abs(y + 0.5 - ey), a = gl * (q \u003c 1.1 ? 1 : q \u003c 2.1 ? 0.75 : q \u003c 3.1 ? 0.3 : 0);\n        if (a) (r += (150 + 105 * (q \u003c 1.1) - r) * a), (g += (255 - g) * a), (b += (60 + 170 * (q \u003c 1.1) - b) * a);\n      }\n      // Channels in steps of 4 of 255: too fine to see, and a frame packs smaller.\n      display.setPixel(x, y, min(255, round(r / 4) * 4), min(255, round(g / 4) * 4), min(255, round(b / 4) * 4));\n    }\n}\n","old-well":"// ===== Patternflow pattern =====\n// Title:   Old Well\n// Family:  halloween\n// Idea:    A cut-away stone well under the moon lowers its bucket to the black water, which glows sickly green as two pale eyes open beneath and a pale hand yanks the bucket under, the rope whipping and the windlass spinning, until it is wound back up brimming, sometimes with the hand still on its rim.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Moon=0..1, Fog=0..1\n//\n// Knob 1: Hue. The colour of the glow in the water, of the light it throws up the shaft and of what comes up in the bucket: sickly green at 0, cyan at 0.25, violet at 0.5, orange at 0.75. The sky, the stones and the moonlight stay as they are.\n// Knob 2: Speed. At 2 the bucket goes down at 18 LEDs a second and is wound up at 26, and one round takes about 12.5 s: down 3.6 s, the water and the hand 3.8 s, a 0.5 s calm, up 3.8 s and 0.9 s hanging at the top. At 0.2 everything is ten times slower, at 3 half as fast again. The first round starts with the bucket already low, so it touches the water 0.5 s in and is pulled under at 1.8 s.\n// Knob 3: Moon. Where the moon stands. At 0 high on the left: its light falls into the shaft slanting right and thins all the way down to the water. At 0.25 it falls straight; at 0.5 the moon peeks over the ridge and the light leans left; at 1 it hangs low on the right and lights only the upper left of the shaft.\n// Knob 4: Fog. A mist over the water, added as light, moonlit and tinted by the glow. At 0 none; at 0.06 a thin layer over the water; at 0.5 it fills the bottom half of the shaft; at 1 it rises 70 rows, to the mouth of the well.\n// Buttons: K1 tap lets go of the crank while the bucket is going down or hanging at the top: it falls to the water at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The shaft's inside runs from column SX0 to SX1; its stone walls, seen cut\n// through, are the eight columns either side, and earth lies beyond them.\nconst SX0 = 13, SX1 = 50;\n// The parapet's top, the ground and the water.\nconst PY = 32, GY = 40, WS = 104;\n// The little roof: its ridge and its eaves.\nconst AY = 5, EY = 15;\n// The windlass wheel, seen end on, and the column the rope hangs down.\nconst CX = 26, CY = 22, RX = 31;\n// The bucket's rim at the top and floating on the water.\nconst TOPB = 33, BOTB = 97;\n// Seconds into the event at Speed 2: the glow is up, the hand has risen, it\n// has a grip, the yank, the glow starts to fade, and it is all over.\nconst E_GLOW = 0.35, E_HAND0 = 0.5, E_HAND1 = 1.0, E_GRIP = 1.15, E_YANK = 1.3, E_FADE = 2.5, E_END = 3.8;\n// Kinds of LED in the still picture.\nconst SKY = 0, ROOF = 1, GABLE = 2, WOOD = 3, BACK = 4, SECT = 5, SOIL = 6, GRASS = 7, WATER = 8;\nconst MOONC = [175, 185, 225], TINT = [0.95, 0.9, 1.12];\n// The bucket's iron hoops, its rim and its two shades of stave.\nconst HOOP = [70, 70, 86], RIM = [214, 150, 84], STAVE = [[160, 98, 48], [186, 116, 58]];\n// The glow's light, falling off up the shaft from the water.\nconst UP = new Float32Array(128);\nfor (let i = 0; i \u003c 128; i++) UP[i] = exp(-i / 16);\n// Light round a point, by squared distance in LEDs.\nconst RAD = new Float32Array(4096);\nfor (let i = 0; i \u003c 4096; i++) RAD[i] = exp(-sqrt(i) / 7);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, moon: -1, fog: 0.06, s: 0.3,\n    ph: \"lower\", e: 0, by: 88, v: 0, cyc: 0, cling: false,\n    th: 0, ex: 0, sv: 0, wa: 0, wp: 0,\n    hand: { on: false, x: 22, y: 140, c: 0, v: 0, fall: false },\n    eo: 0, g: 0, cg: 0,\n    bits: [], bubbles: [], ripples: [], dripT: 0, bubT: 0,\n    kind: new Uint8Array(N), alb: new Float32Array(N), bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    gc: [0, 0, 0], off: new Float32Array(W),\n  };\n  geometry(params.s);\n}\n\n// The still shapes: roof, posts, walls, earth and water, and how much light\n// each stone gives back.\nfunction geometry(S) {\n  const { kind, alb } = S;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, ry = AY + ((EY - AY) * abs(x + 0.5 - 32)) / 26;\n      let k = SKY, a = 0;\n      if (x >= 6 && x \u003c= 57 && y >= ry && y \u003c ry + 3) (k = ROOF), (a = y \u003c ry + 1 ? 1 : (x + (floor(y - ry) & 1) * 2) % 4 === 0 ? 0.45 : 0.7);\n      else if (x >= 9 && x \u003c= 54 && y >= ry + 3 && y \u003c= EY) (k = GABLE), (a = x % 4 === 0 ? 0.4 : 1);\n      else if ((x >= 7 && x \u003c= 56 && (y === EY + 1 || y === EY + 2)) || ((x === 9 || x === 10 || x === 53 || x === 54) && y > EY && y \u003c PY - 1) || (x > 10 && x \u003c 53 && (y === 21 || y === 22)))\n        (k = WOOD), (a = x === 9 || x === 53 || y === EY + 1 || y === 21 ? 1.3 : 1);\n      else if ((y === PY - 1 && ((x >= 4 && x \u003c= 13) || (x >= 50 && x \u003c= 59))) || (y >= PY && ((x >= 5 && x \u003c SX0) || (x > SX1 && x \u003c= 58)))) {\n        // Cut stone: the same courses as the wall behind, one joint per course.\n        k = SECT;\n        const c = floor((y - PY + 6) / 6), r = (y - PY + 6) % 6, side = x \u003c 32 ? 0 : 1, j = (x - (side ? 51 : 5) + (c % 2) * 4) % 8;\n        a = y === PY - 1 ? 1.5 : r === 5 || j === 7 ? 0.3 : 0.78 + 0.22 * floor(hash(c * 31 + side * 7 + (j > 3 ? 1 : 0)) * 3) / 2;\n      } else if (y >= PY && x >= SX0 && x \u003c= SX1) {\n        if (y >= WS) k = WATER;\n        else {\n          // The back wall, in courses six rows high with staggered joints.\n          k = BACK;\n          const c = floor((y - PY) / 6), r = (y - PY) % 6, w = 7 + (c % 3), xx = x - SX0 + (c % 2) * 4 + floor(hash(c * 7 + 1) * 3), si = floor(xx / w);\n          a = r === 5 || xx % w === w - 1 ? 0.3 : 0.5 + 0.14 * floor(hash(c * 131 + si * 17) * 4) + (r === 0 ? 0.1 : 0) - (hash(p) \u003c 0.12 ? 0.12 : 0);\n        }\n      } else if (y > GY) (k = SOIL), (a = hash(p * 3 + 1) \u003c 0.05 ? 1.6 : 1);\n      else if (y >= GY - 2 && (y === GY || hash(x * 5 + y) \u003c 0.45 + (y - GY) * 0.2)) (k = GRASS), (a = 1);\n      kind[p] = k;\n      alb[p] = a;\n    }\n}\n\n// The beam of moonlight in the shaft at (x, y): 0 in the shadow of the lip,\n// 1 inside, with a soft edge.\nfunction beam(s, x, y) {\n  const d = y - PY, L = SX0 + max(0, s) * d, R = SX1 + 1 + min(0, s) * d;\n  return cl(min(x + 0.5 - L, R - x - 0.5) / 1.5 + 0.5, 0, 1);\n}\n\n// The still picture for one place of the moon: sky, moon, roof, the lit and\n// shaded stones, the dust in the moonbeam and the dark water.\nfunction build(S) {\n  const u = S.moon, bg = S.bg, kind = S.kind, alb = S.alb;\n  const mx = 9 + 46 * u, my = 8 + 14 * u * u - 6 * sin(PI * u), s = (S.s = 0.3 - 1.2 * u);\n  for (let y = 0; y \u003c H; y++) {\n    const f = floor(min(1, y / 40) * 6) / 6, I = exp(-max(0, y - PY) / 36), amb = 5 + 21 * exp(-max(0, y - PY) / 50);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3, k = kind[p];\n      let r = 0, g = 0, b = 0;\n      if (k === SKY) {\n        r = 30 + 14 * f;\n        g = 20 + 16 * f;\n        b = 64 + 24 * f;\n        const dx = x + 0.5 - mx, dy = y + 0.5 - my, dd = sqrt(dx * dx + dy * dy);\n        if (dd \u003c 5.3) {\n          const sea = (dx - 1.3) ** 2 + (dy + 1.2) ** 2 \u003c 3.6 || (dx + 1.9) ** 2 + (dy - 1.8) ** 2 \u003c 1.5;\n          (r = sea ? 196 : 238), (g = sea ? 194 : 234), (b = sea ? 190 : 214);\n        } else {\n          const hl = dd \u003c 7.5 ? 0.3 : dd \u003c 10.5 ? 0.16 : dd \u003c 15 ? 0.07 : 0;\n          (r += MOONC[0] * hl), (g += MOONC[1] * hl), (b += MOONC[2] * hl);\n          if (hl === 0 && y \u003c 30 && hash(p * 13 + 1) \u003c 0.012) r = g = b = 90 + 80 * hash(p);\n        }\n      } else if (k === ROOF) (r = 70 * alb[p]), (g = 50 * alb[p]), (b = 66 * alb[p]);\n      else if (k === GABLE) (r = 40 * alb[p]), (g = 26 * alb[p]), (b = 30 * alb[p]);\n      else if (k === WOOD) (r = 104 * alb[p]), (g = 66 * alb[p]), (b = 42 * alb[p]);\n      else if (k === GRASS) (r = 34), (g = 66), (b = 50);\n      else if (k === SOIL) (r = alb[p] * 30), (g = alb[p] * 19), (b = alb[p] * 26);\n      else if (k === SECT) {\n        const l = 62 - 22 * max(0, y - PY) / 96;\n        (r = alb[p] * l * TINT[0]), (g = alb[p] * l * TINT[1]), (b = alb[p] * l * TINT[2]);\n      } else if (k === BACK) {\n        // A stone gives back the dim light of the night and the moonbeam;\n        // the dust in the beam glows whatever is behind it.\n        const m = I * beam(s, x, y);\n        r = alb[p] * (TINT[0] * amb + MOONC[0] * 0.5 * m) + MOONC[0] * 0.2 * m;\n        g = alb[p] * (TINT[1] * amb + MOONC[1] * 0.5 * m) + MOONC[1] * 0.2 * m;\n        b = alb[p] * (TINT[2] * amb + MOONC[2] * 0.5 * m) + MOONC[2] * 0.2 * m;\n      } else if (k === WATER) {\n        // Black water; a faint broken copy of the moonbeam just under the top.\n        const dy = y - WS, m = dy \u003c 6 && (x + dy) % 3 !== 0 ? 0.3 * exp(-1.5) * beam(s, x, WS) * (1 - dy / 6) : 0;\n        (r = 3 + MOONC[0] * m), (g = 5 + MOONC[1] * m), (b = 10 + MOONC[2] * m);\n      }\n      bg[o] = r;\n      bg[o + 1] = g;\n      bg[o + 2] = b;\n    }\n  }\n}\n\nfunction touch(S, hard) {\n  S.ph = \"event\";\n  S.e = 0;\n  S.by = BOTB;\n  S.cyc++;\n  S.ripples.push({ x: RX, t: 0, a: hard ? 2 : 1.2 });\n  for (let i = 0; i \u003c (hard ? 14 : 6); i++) S.bits.push({ x: RX - 6 + Math.random() * 12, y: WS - 1, vx: (Math.random() - 0.5) * 18, vy: -14 - Math.random() * (hard ? 34 : 16), gl: 0 });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.fog = cl(k[3], 0, 1);\n  const m = cl(k[2], 0, 1);\n  if (abs(m - S.moon) > 0.003) (S.moon = m), build(S);\n  const ds = (d * S.speed) / 2, hd = S.hand;\n  S.t += ds;\n  S.e += ds;\n  if (input.btnPressed && input.btnPressed[0] && (S.ph === \"lower\" || S.ph === \"top\")) (S.ph = \"drop\"), (S.v = 18);\n  if (S.ph === \"lower\") {\n    S.by += 18 * ds;\n    if (S.by >= BOTB) touch(S, false);\n  } else if (S.ph === \"drop\") {\n    S.v += 160 * ds;\n    S.by += S.v * ds;\n    if (S.by >= BOTB) touch(S, true);\n  } else if (S.ph === \"event\") {\n    const e = S.e;\n    if (e \u003c E_YANK) S.by = BOTB + 1.3 * sin(e * 8) * exp(-e * 2.5);\n    else {\n      const y = (e - E_YANK) / 0.3;\n      S.by = min(190, BOTB + (y \u003c 1 ? 34 * y * y : 34 + 40 * (y - 1)));\n      if (e - ds \u003c E_YANK) {\n        // The yank: a splash, a big ring, the rope whips and the wheel runs free.\n        S.ripples.push({ x: RX, t: 0, a: 2.4 });\n        for (let i = 0; i \u003c 18; i++) S.bits.push({ x: RX - 7 + Math.random() * 14, y: WS - 1, vx: (Math.random() - 0.5) * 30, vy: -22 - Math.random() * 40, gl: 0 });\n        S.wa = 6;\n        S.sv = 16;\n      }\n    }\n    S.g = e \u003c E_FADE ? sm(e / E_GLOW) * (0.92 + 0.08 * vn(S.t * 7, 3)) : 1 - sm((e - E_FADE) / (E_END - E_FADE));\n    S.eo = e \u003c 0.25 ? 0 : e \u003c 2.8 ? sm((e - 0.25) / 0.2) * (abs(e - 1.9) \u003c 0.07 ? 0.2 : 1) : 1 - sm((e - 2.8) / 0.25);\n    // The hand rises beside the bucket, takes the rim and goes under with it.\n    hd.on = e > E_HAND0 && S.by \u003c 150;\n    hd.fall = false;\n    hd.x = 22;\n    hd.y = e \u003c E_HAND1 ? 134 - (134 - BOTB - 6) * (1 - (1 - (e - E_HAND0) / (E_HAND1 - E_HAND0)) ** 2) : S.by + 6;\n    hd.c = sm((e - E_HAND1) / (E_GRIP - E_HAND1));\n    if (e > 1.4 && e \u003c 3.3 && (S.bubT += ds * 10) >= 1) {\n      S.bubT--;\n      S.bubbles.push({ x: RX + (Math.random() - 0.5) * 12, y: 128, v: 10 + Math.random() * 9, sd: floor(Math.random() * 999) });\n    }\n    if (e > E_END) (S.ph = \"calm\"), (S.e = 0), (S.g = 0), (S.eo = 0);\n  } else if (S.ph === \"calm\") {\n    if (S.e > 0.5) {\n      S.ph = \"raise\";\n      S.by = 132;\n      // Every other round the hand comes up still holding the rim.\n      S.cling = S.cyc % 2 === 1;\n      hd.on = S.cling;\n      hd.c = 1;\n      hd.fall = false;\n    }\n  } else if (S.ph === \"raise\") {\n    S.by -= 26 * ds;\n    if (hd.on && !hd.fall) {\n      hd.y = S.by + 6;\n      if (S.by \u003c 62) (hd.fall = true), (hd.v = 0);\n    }\n    if (S.by \u003c= TOPB) (S.by = TOPB), (S.ph = \"top\"), (S.e = 0);\n  } else if (S.ph === \"top\" && S.e > 0.9) (S.ph = \"lower\"), (S.e = 0);\n  // A hand that lets go drops back down the shaft, opening as it falls.\n  if (hd.fall) {\n    hd.v += 150 * ds;\n    hd.y += hd.v * ds;\n    hd.c = max(0, hd.c - ds * 3);\n    if (hd.y > WS + 12) {\n      hd.fall = hd.on = false;\n      S.ripples.push({ x: hd.x + 2, t: 0, a: 1.6 });\n      for (let i = 0; i \u003c 8; i++) S.bits.push({ x: hd.x + Math.random() * 5, y: WS - 1, vx: (Math.random() - 0.5) * 16, vy: -12 - Math.random() * 22, gl: 0 });\n    }\n  }\n  if (S.ph === \"raise\" || S.ph === \"top\" || S.ph === \"lower\") hd.on = hd.on && S.ph === \"raise\";\n  // What the bucket brings up glows and drips, less the higher it gets.\n  S.cg = S.ph === \"raise\" || S.ph === \"top\" ? (S.by \u003c WS - 9 ? exp(-(WS - 9 - S.by) / 40) : 1) : 0;\n  if (S.cg > 0.15 && S.by \u003c WS - 9 && (S.dripT += ds * 12 * S.cg) >= 1) {\n    S.dripT--;\n    S.bits.push({ x: RX - 5 + floor(Math.random() * 10), y: S.by + 10, vx: 0, vy: 0, gl: 1 });\n  }\n  // The rope's length turns the wheel; after the yank it also runs free a while.\n  S.ex += S.sv * ds;\n  S.sv *= exp(-1.4 * ds);\n  S.th = -(S.by - 5 - CY) / 5 + S.ex;\n  S.wa *= exp(-2.4 * ds);\n  S.wp += 24 * ds;\n  // Flying water falls back; drips fall; bubbles rise and break the surface.\n  let n = 0;\n  for (const b of S.bits) {\n    b.vy += 170 * ds;\n    b.x += b.vx * ds;\n    b.y += b.vy * ds;\n    if (b.y > WS && b.vy > 0) {\n      if (b.gl) S.ripples.push({ x: b.x, t: 0, a: 0.5 });\n    } else S.bits[n++] = b;\n  }\n  S.bits.length = n;\n  n = 0;\n  for (const b of S.bubbles) {\n    b.y -= b.v * ds;\n    if (b.y \u003c= WS + 1) S.ripples.push({ x: b.x, t: 0, a: 0.6 });\n    else S.bubbles[n++] = b;\n  }\n  S.bubbles.length = n;\n  n = 0;\n  for (const r of S.ripples) if ((r.t += ds) \u003c 2.2) S.ripples[n++] = r;\n  S.ripples.length = n;\n  if (S.ripples.length > 24) S.ripples.splice(0, S.ripples.length - 24);\n}\n\n// Add a colour at a pixel, by alpha.\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\n// Something solid at (x, y): under the water it takes the glow's colour and\n// darkens.\nfunction solid(S, x, y, r, g, b) {\n  if (y > WS + S.off[cl(round(x), 0, W - 1)]) {\n    const gc = S.gc, k = 0.3 * S.g;\n    r = r * 0.55 + gc[0] * k;\n    g = g * 0.55 + gc[1] * k;\n    b = b * 0.55 + gc[2] * k;\n  }\n  put(S.buf, x, y, r, g, b, 1);\n}\n\n// The hand, wrist at (x, y): a long forearm from below, a palm, three long\n// fingers and a thumb. c is the grip: 0 spread upward, 1 hooked over to the\n// right, onto the bucket's rim.\nfunction hand(S, x, y, c) {\n  const P = [205, 222, 200];\n  for (let j = 0; j \u003c 40; j++) {\n    const yy = y + 1 + j, xx = x - 1 - j * 0.12;\n    for (let i = -1; i \u003c= 1; i++) solid(S, xx + i, yy, P[0] * 0.86, P[1] * 0.86, P[2] * 0.86);\n  }\n  for (let j = 0; j \u003c 3; j++) for (let i = -2; i \u003c= 2; i++) solid(S, x + i, y - j, P[0], P[1], P[2]);\n  for (let f = 0; f \u003c 3; f++) {\n    const bx = x - 2 + 2 * f, sp = (f - 1) * (1 - c);\n    for (let j = 0; j \u003c 4 + (f === 1 ? 1 : 0); j++) solid(S, bx + round(sp * j * 0.3), y - 3 - j, P[0], P[1], P[2]);\n    const jx = bx + round(sp * 1.4), jy = y - 7 - (f === 1 ? 1 : 0);\n    // The last joint: up when open, over and down when it grips.\n    solid(S, jx + round(c), jy - round(1 - c), P[0], P[1], P[2]);\n    solid(S, jx + round(2 * c), jy - round(2 * (1 - c)) + round(c), P[0] * 0.9, P[1] * 0.9, P[2] * 0.9);\n  }\n  solid(S, x - 3, y - 2, P[0], P[1], P[2]);\n  solid(S, x - 4, y - 3, P[0], P[1], P[2]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.moon \u003c 0) return;\n  const { buf, alb, kind, off } = S, t = S.t, g = S.g, cg = S.cg, by = S.by, s = S.s;\n  const gc = hsv(0.3 + S.hue, 0.85, 1, S.gc);\n  buf.set(S.bg);\n  // The water's surface, rings running out from where things went in.\n  for (let x = 0; x \u003c W; x++) {\n    let v = 0;\n    for (const r of S.ripples) {\n      const dx = abs(x + 0.5 - r.x), front = 18 * r.t;\n      if (dx \u003c front) v += r.a * exp(-1.6 * r.t) * sin(0.9 * (dx - front)) * min(1, (front - dx) / 3);\n    }\n    off[x] = cl(round(v), -3, 3);\n  }\n  // The glow, and what the bucket brings up, light the stones and the air.\n  if (g > 0.01 || cg > 0.01) {\n    for (let y = PY; y \u003c WS; y++) {\n      const fw = g * UP[WS - y];\n      for (let x = SX0 - 1; x \u003c= SX1 + 1; x++) {\n        let f = fw;\n        if (cg > 0.01) {\n          const dx = x - RX, dy = y - by - 4;\n          f += 0.8 * cg * RAD[min(4095, (dx * dx + dy * dy) | 0)];\n        }\n        if (f \u003c 0.012) continue;\n        const p = y * W + x, o = p * 3, a = alb[p] * 0.72 + (kind[p] === BACK ? 0.3 : 0);\n        buf[o] += gc[0] * f * a;\n        buf[o + 1] += gc[1] * f * a;\n        buf[o + 2] += gc[2] * f * a;\n      }\n    }\n  }\n  // The water: black, or lit from below in slow swirls with a brighter\n  // heart round the eyes.\n  for (let y = WS; y \u003c H; y++)\n    for (let x = SX0; x \u003c= SX1; x++) {\n      const o = (y * W + x) * 3;\n      if (y \u003c WS + off[x]) {\n        // A trough: the stones and air above show through.\n        const q = ((y - 1) * W + x) * 3;\n        (buf[o] = buf[q]), (buf[o + 1] = buf[q + 1]), (buf[o + 2] = buf[q + 2]);\n        continue;\n      }\n      if (g \u003c 0.01) continue;\n      const n = vn(x * 0.21 + 1.6 * vn(y * 0.17 - t * 0.6, 3) + t * 0.5, 11 + (y >> 2)), ex = x - RX, ey = y - 117;\n      const f = g * (0.12 + 0.1 * floor(n * 3 + 1.5) / 2 + 0.6 * RAD[min(4095, round((ex * ex * 0.4 + ey * ey) * 1.36))] + (y - WS \u003c 2 ? 0.2 : 0));\n      buf[o] += gc[0] * f;\n      buf[o + 1] += gc[1] * f;\n      buf[o + 2] += gc[2] * f;\n    }\n  // Mist over the water, added as light.\n  if (S.fog > 0) {\n    const top = WS - 4 - 66 * S.fog, a0 = 0.16 + 0.42 * S.fog, mk = 0.7 * g;\n    const mr = 150 + (gc[0] - 150) * mk, mg = 150 + (gc[1] - 150) * mk, mb = 186 + (gc[2] - 186) * mk;\n    for (let y = max(PY, floor(top)); y \u003c WS + 3; y++) {\n      const ramp = sm((y - top) / 12);\n      for (let x = SX0; x \u003c= SX1; x++) {\n        const nn = 0.55 + 0.45 * vn(x * 0.13 - t * 0.7 + y * 0.04, 17 + (y >> 3)) + 0.3 * vn(x * 0.31 + t * 1.1, 29 + (y >> 2));\n        const a = floor(a0 * ramp * cl(nn, 0, 1) * 10) / 10;\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        buf[o] += mr * a;\n        buf[o + 1] += mg * a;\n        buf[o + 2] += mb * a;\n      }\n    }\n  }\n  // Eyes under the water, pale, with dark slits.\n  if (S.eo > 0.02)\n    for (const ex of [RX - 6, RX + 4]) {\n      const ey = 116, wide = S.eo > 0.45;\n      for (let i = 0; i \u003c 5; i++) {\n        const pup = i === 2, r = pup ? 20 : 228 + gc[0] * 0.1, gg = pup ? 30 : 240, b = pup ? 20 : 222;\n        put(buf, ex + i, ey, r, gg, b, min(1, S.eo * 2));\n        if (wide && i > 0 && i \u003c 4) {\n          put(buf, ex + i, ey - 1, r, gg, b, 1);\n          put(buf, ex + i, ey + 1, r, gg, b, 1);\n        }\n      }\n    }\n  // The rope, whipping after the yank.\n  const end = min(H - 1, by - 5), ry = PY;\n  for (let y = CY; y \u003c= end; y++) {\n    const x = RX + S.wa * sin(0.32 * y - S.wp) * ((y - CY) / 90);\n    const l = y \u003c ry ? 0.95 : 0.5 + 0.5 * exp(-(y - ry) / 48) * (0.5 + 0.5 * beam(s, round(x), y));\n    solid(S, x, y, 200 * l, 176 * l, 122 * l);\n  }\n  // The windlass wheel: rim, four spokes, the hub and the crank.\n  const th = S.th;\n  for (let a = 0; a \u003c 2 * PI; a += 0.2) put(buf, CX + 5 * cos(a), CY + 5 * sin(a), 140, 92, 54, 1);\n  for (let q = 0; q \u003c 4; q++) {\n    const a = th + (q * PI) / 2;\n    for (let r = 1; r \u003c 5; r++) put(buf, CX + r * cos(a), CY + r * sin(a), 118, 76, 44, 1);\n  }\n  const ca = th + PI / 4;\n  for (let r = 1; r \u003c= 7; r++) put(buf, CX + r * cos(ca), CY + r * sin(ca), 90, 90, 104, 1);\n  put(buf, CX + 7.6 * cos(ca), CY + 7.6 * sin(ca), 170, 120, 70, 1);\n  put(buf, CX, CY, 60, 60, 72, 1);\n  // The bucket: staves, two iron hoops, its bail, lit less the deeper it hangs.\n  if (by - 6 \u003c H) {\n    const lit = by \u003c PY ? 1 : 0.45 + 0.55 * exp(-(by - PY) / 45) * (0.55 + 0.45 * beam(s, RX, round(by))), gl = g * UP[cl(round(WS - by - 5), 0, 127)] * 0.22;\n    for (let r = 0; r \u003c 10; r++) {\n      const xl = RX - 6 + round(r / 9), xr = RX + 5 - round(r / 9);\n      for (let x = xl; x \u003c= xr; x++) {\n        const hoop = r === 2 || r === 7, edge = x === xl || x === xr, rim = r === 0;\n        const c = hoop ? HOOP : rim ? RIM : STAVE[x & 1];\n        const e = edge && !hoop ? 0.7 : 1;\n        solid(S, x, by + r, (c[0] * lit + gc[0] * gl) * e, (c[1] * lit + gc[1] * gl) * e, (c[2] * lit + gc[2] * gl) * e);\n      }\n    }\n    for (let x = RX - 6; x \u003c= RX + 5; x++) solid(S, x, by - 5 * (1 - ((x - RX + 0.5) / 6) ** 2), 120 * lit, 120 * lit, 136 * lit);\n    // Brimming with the glowing water it brought up.\n    if (cg > 0.05) for (let x = RX - 5; x \u003c= RX + 4; x++) put(buf, x, by - 1, gc[0], gc[1], gc[2], min(1, cg * 1.4));\n  }\n  // The hand, rising, gripping, clinging or falling.\n  const hd = S.hand;\n  if (hd.on) hand(S, hd.x, hd.y, hd.c);\n  // Bubbles, flying water and green drips.\n  for (const b of S.bubbles) {\n    const x = b.x + 1.2 * sin(b.y * 0.5 + b.sd);\n    put(buf, x, b.y, 220, 255, 230, 0.8);\n    if (b.sd % 3 === 0) put(buf, x + 1, b.y, 200, 240, 210, 0.5);\n  }\n  for (const b of S.bits)\n    if (b.gl) put(buf, b.x, b.y, gc[0], gc[1], gc[2], 0.9);\n    else put(buf, b.x, b.y, 170 + gc[0] * 0.3 * g, 190 + gc[1] * 0.25 * g, 200, 0.85);\n  // The surface line: moonlit where the beam reaches it, bright with the glow.\n  for (let x = SX0; x \u003c= SX1; x++) {\n    const m = beam(s, x, WS) * 0.25, y = WS + off[x], crest = off[x] \u003c 0 ? 1.4 : 1;\n    put(buf, x, y, (40 + MOONC[0] * m + gc[0] * g * 0.6) * crest, (44 + MOONC[1] * m + gc[1] * g * 0.6) * crest, (60 + MOONC[2] * m + gc[2] * g * 0.6) * crest, 1);\n  }\n  // Out in steps of four.\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, min(255, ((buf[o] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 1] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 2] + 2) >> 2) \u003c\u003c 2));\n}\n","paper-lantern-ghost":"// ===== Patternflow pattern =====\n// Title:   Paper Lantern Ghost\n// Family:  halloween\n// Idea:    On a rainy purple night a ribbed paper lantern swings from an eave until one big eye opens on it and its seam tears into a wide grin with a long red tongue lolling out, while below a one-eyed paper umbrella hops on its single leg back and forth across the wet ground, tongue out, splashing the puddles that carry the lantern's light.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Hop=0..1\n//\n// Knob 1: Hue. The lantern's light: the paper, its halo, the rain it lights and its reflection in the puddles. Orange at 0, green at 0.25, sky blue at 0.5, magenta at 0.75; the umbrella stays toxic green and the tongues red.\n// Knob 2: Speed. Everything's clock, rain included. At the opening 2 the eye opens at 0.8 s, the grin tears open at 1.2 s, the tongue is out by 2.4 s, the eye blinks at 4.6 s and the face closes back into a plain lantern at 7.4 s before it starts again at 9 s; the umbrella hops every 0.6 s. At 0.2 ten times slower, at 3 half again as fast.\n// Knob 3: Rain. At 0 a steady rain of 90 short streaks falling nearly straight; at 1 a downpour of 420 longer ones driven slantwise by the wind. Each drop that lands rings a puddle or splashes the stones.\n// Knob 4: Hop. How high and far the umbrella hops: 10 LEDs up and 8 along at 0, a little more at the opening 0.06, 46 up and 18 along at 1, high enough to reach the lantern's tongue, each hop longer in the air.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hsv = (h, s, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + (h - floor(h)) * 6) % 6;\n  o[c] = 255 * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\nconst PX = 32, PY = 9, LC = 27, GROUND = 110, FOOT = 117;\n// Puddles on the stones: [x, y, half width, half height].\nconst PUDDLES = [[13, 116, 11, 2.6], [46, 120.5, 13, 3], [24, 125.5, 9, 1.8]];\nconst inPuddle = (x, y) => PUDDLES.some(([a, b, c, d]) => ((x - a) / c) ** 2 + ((y - b) / d) ** 2 \u003c 1);\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, t: 0, ph: 0, th: 0, wind: 0, L: [0, 0, 0], paper: [0, 0, 0],\n    bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    // The tongue: a hanging chain, each point with where it was last frame.\n    tg: Array.from({ length: 8 }, () => [PX, PY + LC + 8, PX, PY + LC + 8]),\n    // The umbrella: where it took off and where it lands, the way it faces,\n    // and how far through the hop it is.\n    U: { x0: 12, x1: 21, dir: 1, p: 0.1, x: 12, y: 0, tilt: 0, sq: 1, leg: 13 },\n    drops: [], rings: [], bits: [],\n    face: { eye: 0, mouth: 0, tongue: 0 },\n  };\n  background(params.s);\n}\n\n// A new drop, upwind far enough that the wind carries some to every column.\nfunction drop(top, wind) {\n  return { x: Math.random() * (66 + wind * 140) - wind * 140, y: top ? Math.random() * -30 : Math.random() * FOOT, v: 95 + Math.random() * 40, fy: GROUND + Math.random() * 17, len: 3 + floor(Math.random() * 3 + wind * 8) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const hue = cl(k[0], 0, 1), rain = cl(k[2], 0, 1), hop = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1) * (cl(k[1], 0.2, 3) / 2);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    hsv(0.075 + hue, 0.78, S.L);\n    // The paper glows paler than the light it gives.\n    for (let c = 0; c \u003c 3; c++) S.paper[c] = mix(S.L[c], [255, 246, 214][c], 0.5);\n  }\n  S.t += d;\n  // The face, on a 9 s loop: the eye opens, the seam tears into a grin, the\n  // tongue lolls out; a blink; then it all closes up again.\n  const tau = S.t % 9, F = S.face;\n  F.eye = ease((tau - 0.8) / 0.3) * (1 - ease((tau - 7.9) / 0.3)) * (1 - sin(PI * cl((tau - 4.6) / 0.25, 0, 1)));\n  F.mouth = ease((tau - 1.2) / 0.5) * (1 - ease((tau - 7.4) / 0.5));\n  F.tongue = 25 * ease((tau - 1.5) / 0.9) * (1 - ease((tau - 6.9) / 0.6));\n  // The swing: wider while the face is open.\n  S.ph += d * 1.8;\n  S.th = (0.15 + 0.1 * F.mouth) * sin(S.ph) + 0.04 * sin(S.ph * 1.7 + 1);\n  // The tongue hangs from the lower lip and swings behind the lantern.\n  const [ax, ay] = toWorld(S.th, 0.5, LC + 6 + 4 * F.mouth), seg = F.tongue / 7, g = 140 * d * d;\n  S.tg[0] = [ax, ay, ax, ay];\n  for (let i = 1; i \u003c 8; i++) {\n    const p = S.tg[i], vx = (p[0] - p[2]) * 0.94, vy = (p[1] - p[3]) * 0.94;\n    (p[2] = p[0]), (p[3] = p[1]);\n    (p[0] += vx), (p[1] += vy + g);\n  }\n  for (let n = 0; n \u003c 3; n++)\n    for (let i = 1; i \u003c 8; i++) {\n      const a = S.tg[i - 1], b = S.tg[i], dx = b[0] - a[0], dy = b[1] - a[1], l = sqrt(dx * dx + dy * dy) || 1;\n      (b[0] = a[0] + (dx / l) * seg), (b[1] = a[1] + (dy / l) * seg);\n    }\n  // The umbrella: crouch, a parabola from one landing to the next, a squash\n  // on landing; it turns round at either side.\n  const U = S.U, P = 0.55 + 0.45 * hop, hh = 10 + 36 * hop, step = 8 + 10 * hop, was = U.p;\n  U.p += d / P;\n  if (U.p >= 1) {\n    U.p -= 1;\n    U.x0 = U.x1;\n    if (U.x0 + U.dir * step > 54 || U.x0 + U.dir * step \u003c 10) U.dir = -U.dir;\n    U.x1 = U.x0 + U.dir * step;\n  }\n  const a = cl((U.p - 0.2) / 0.65, 0, 1), cr = U.p \u003c 0.2 ? sin((PI * U.p) / 0.2) : U.p > 0.85 ? sin((PI * (U.p - 0.85)) / 0.15) : 0;\n  U.x = mix(U.x0, U.x1, a);\n  U.y = -hh * 4 * a * (1 - a);\n  U.tilt = 0.16 * U.dir * sin(PI * a);\n  U.sq = 1 - 0.16 * cr + 0.06 * sin(PI * a);\n  U.leg = 13 - 5 * cr;\n  if (was \u003c 0.85 && U.p >= 0.85) {\n    // Landing: a ring in the puddle and a spray of drops.\n    S.rings.push([U.x, FOOT, 0, 1.6]);\n    for (let i = 0; i \u003c 12; i++) S.bits.push([U.x + (Math.random() - 0.5) * 8, FOOT - 1, (Math.random() - 0.5) * 50, -25 - Math.random() * 35, 0]);\n  }\n  // Rain, its rings in the puddles and splashes on the stones.\n  const want = round(90 + 330 * rain), wind = (S.wind = 0.08 + 0.32 * rain);\n  while (S.drops.length \u003c want) S.drops.push(drop(false, wind));\n  if (S.drops.length > want) S.drops.length = want;\n  for (const r of S.drops) {\n    r.y += r.v * d;\n    r.x += r.v * d * wind;\n    if (r.y > r.fy) {\n      if (inPuddle(r.x, r.fy)) S.rings.length \u003c 60 && S.rings.push([r.x, r.fy, 0, 1]);\n      else if (S.bits.length \u003c 120) S.bits.push([r.x, r.fy, (Math.random() - 0.5) * 20, -18, 0.25]);\n      Object.assign(r, drop(true, wind));\n    }\n  }\n  S.rings = S.rings.filter((r) => (r[2] += d) \u003c 0.45 * r[3]);\n  S.bits = S.bits.filter((b) => {\n    b[0] += b[2] * d;\n    b[1] += b[3] * d;\n    b[3] += 160 * d;\n    return (b[4] += d) \u003c 0.55 && b[1] \u003c FOOT + 2;\n  });\n}\nconst toWorld = (th, x, y) => [PX + x * cos(th) - y * sin(th), PY + x * sin(th) + y * cos(th)];\n\n// --- the night, laid out once: the eave of a roof along the top with a row\n// of round tile ends, a purple sky stepping lighter downward, a bamboo fence,\n// wet paving with three puddles.\nfunction background(S) {\n  const bg = S.bg;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, v = floor(cl((y - 8) / 84, 0, 1) * 12) / 12;\n      let r = 34 + 60 * v, g = 20 + 40 * v, b = 62 + 76 * v;\n      const te = (((x + 3) % 6) - 2.5) ** 2 + (y - 2.5) ** 2;\n      if (y \u003c 8) {\n        // Round tile ends along the roof's edge over a dark beam.\n        const rim = (y \u003c 4 && te > 3 && te \u003c 7.5) || y === 7;\n        (r = rim ? 76 : 20), (g = rim ? 52 : 12), (b = rim ? 96 : 28);\n      } else if (y >= 88 && y \u003c GROUND) {\n        // Slats of split bamboo, two bindings across.\n        const slat = x % 3 !== 2 || y \u003c 90, bind = abs(y - 93) \u003c 1 || abs(y - 104) \u003c 1;\n        if (slat || bind) (r = bind ? 46 : 16), (g = bind ? 30 : 10), (b = bind ? 52 : 24);\n        if (y === 88 && slat) (r = 70), (g = 50), (b = 90);\n      } else if (y >= GROUND) {\n        const joint = (y - GROUND) % 6 === 5 || (x + (floor((y - GROUND) / 6) & 1) * 5) % 10 === 0;\n        (r = joint ? 16 : 34), (g = joint ? 10 : 22), (b = joint ? 24 : 46);\n        if (inPuddle(x + 0.5, y + 0.5)) (r = 62), (g = 44), (b = 104);\n      }\n      bg[o] = r;\n      bg[o + 1] = g;\n      bg[o + 2] = b;\n    }\n}\n\nconst put = (buf, o, c) => {\n  buf[o] = c[0];\n  buf[o + 1] = c[1];\n  buf[o + 2] = c[2];\n};\nconst addc = (buf, o, c, a) => {\n  buf[o] += c[0] * a;\n  buf[o + 1] += c[1] * a;\n  buf[o + 2] += c[2] * a;\n};\nconst RAIN = [110, 100, 170], BLACK = [18, 8, 22], WHITE = [255, 250, 236], GULLET = [70, 0, 22], TONGUE = [244, 62, 96], GROOVE = [186, 26, 66];\nconst GREEN = [120, 236, 44], GREEN2 = [74, 178, 26], RIB = [30, 80, 20], SKIN = [244, 208, 172];\n\n// The lantern in its own frame, hung from the hook: a barrel of paper 26\n// wide between two black lacquered caps, ribbed every 3.3 LEDs.\nfunction lantern(S, buf) {\n  const F = S.face, th = S.th, c = cos(th), s = sin(th), L = S.L, Pp = S.paper;\n  // Where the eye looks: at the umbrella.\n  const [cx, cy] = toWorld(th, 0, LC), ux = S.U.x - cx, uy = FOOT - 20 + S.U.y - cy, ul = sqrt(ux * ux + uy * uy) || 1;\n  const lx0 = ((ux * c + uy * s) / ul) * 2.4, ly0 = ((-ux * s + uy * c) / ul) * 1.8;\n  for (let y = PY; y \u003c PY + 54; y++)\n    for (let x = 6; x \u003c 58; x++) {\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY, bx = dx * c + dy * s, by = -dx * s + dy * c - LC, o = (y * W + x) * 3;\n      if (by \u003c -19.5) {\n        if ((abs(bx) \u003c 0.6 && by > -LC) || (abs(bx) \u003c 2.4 && by > -22)) put(buf, o, BLACK);\n        continue;\n      }\n      if (abs(by) > 16.5) {\n        if (abs(bx) \u003c (by \u003c 0 ? 7.5 : 8.5) && abs(by) \u003c 20) put(buf, o, abs(by) \u003c 17.6 ? [90, 66, 100] : BLACK);\n        continue;\n      }\n      const hw = 13 * sqrt(1 - (by / 19.5) ** 2);\n      if (abs(bx) > hw) continue;\n      // The eye, its lids and the pupil looking at the umbrella.\n      const ey = (bx - 2) ** 2 / 36 + (by + 5) ** 2 / (25 * F.eye * F.eye + 0.01);\n      if (F.eye > 0.04 && ey \u003c 1.45) {\n        put(buf, o, ey > 1 ? BLACK : (bx - 2 - lx0) ** 2 + (by + 5 - ly0 * F.eye) ** 2 \u003c 6.8 ? ((bx - 2.7 - lx0) ** 2 + (by + 5.8 - ly0) ** 2 \u003c 0.7 ? WHITE : BLACK) : WHITE);\n        continue;\n      }\n      // The grin: the seam at row 6 tears open, corners curling up, the\n      // torn edges ragged.\n      const q = bx / 11.5, m = F.mouth, rag = 0.5 * sin(bx * 2.7) * m;\n      const top = 6 - m * (1.6 * (1 - q * q) + 3.2 * q ** 4) + rag, bot = 6 + m * (8.5 * (1 - q * q) - 3.2 * q ** 4) + rag;\n      if (abs(q) \u003c 1 && by > top - 0.45 && by \u003c bot + 0.45) {\n        put(buf, o, m \u003c 0.05 || by \u003c top + 0.35 || by > bot - 0.35 ? [150, 40, 30] : GULLET);\n        continue;\n      }\n      // Paper: palest in the middle, the light's own colour at the sides,\n      // ribs a little darker, bowed with the barrel.\n      const e = (bx / hw) ** 2, rb = (by + 16.5 + 0.9 * e) % 3.3 \u003c 0.8;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = mix(Pp[ch], L[ch], e) * (rb ? 0.78 : 1);\n    }\n}\n\n// The tongue: a capsule along the chain, thinning to a round tip, a groove\n// down the middle, outlined dark.\nfunction tongue(S, buf) {\n  const T = S.tg, F = S.face;\n  if (F.tongue \u003c 1) return;\n  let xa = 64, xb = 0, ya = 128, yb = 0;\n  for (const p of T) (xa = min(xa, p[0])), (xb = max(xb, p[0])), (ya = min(ya, p[1])), (yb = max(yb, p[1]));\n  for (let y = max(0, floor(ya - 4)); y \u003c min(H, yb + 5); y++)\n    for (let x = max(0, floor(xa - 4)); x \u003c min(W, xb + 5); x++) {\n      let dm = 9, cm = 9;\n      for (let i = 1; i \u003c 8; i++) {\n        const [ax, ay] = T[i - 1], [bx, by] = T[i], vx = bx - ax, vy = by - ay, l2 = vx * vx + vy * vy || 1;\n        const t = cl(((x + 0.5 - ax) * vx + (y + 0.5 - ay) * vy) / l2, 0, 1), dd = sqrt((x + 0.5 - ax - vx * t) ** 2 + (y + 0.5 - ay - vy * t) ** 2);\n        const r = i === 7 ? 2.6 : 2.7 - 0.08 * i;\n        if (dd - r \u003c dm) (dm = dd - r), (cm = dd);\n      }\n      const o = (y * W + x) * 3;\n      if (dm \u003c 0) put(buf, o, cm \u003c 0.55 && y > T[1][1] ? GROOVE : TONGUE);\n      else if (dm \u003c 1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n    }\n}\n\n// The umbrella in its own frame, origin where the leg meets the canopy, y\n// down: a bell of oiled paper 26 wide and 28 tall on five ribs, scalloped\n// between the ribs at the rim, one eye, a tongue, one leg on a clog.\nfunction canopy(x, y) {\n  if (y \u003c -28 || y > 1.4 * abs(sin((PI * x) / 6.5))) return 0;\n  const s = -y / 28;\n  return abs(x) \u003c (y \u003c 0 ? 13 * sqrt(1 - s) * (1 - 0.15 * s) : 13) ? 1 : 0;\n}\nfunction umbrella(S, buf) {\n  const U = S.U, c = cos(U.tilt), s = sin(U.tilt), ox = U.x, oy = FOOT - 3.3 - U.leg + U.y, f = U.dir, z = 1 / U.sq;\n  for (let y = max(0, floor(oy - 34 * U.sq)); y \u003c min(H, oy + U.leg + 5); y++)\n    for (let x = max(0, floor(ox - 17)); x \u003c min(W, ox + 18); x++) {\n      const dx = x + 0.5 - ox, dy = y + 0.5 - oy, lx = dx * c + dy * s, ly = -dx * s + dy * c, cy = ly * z, o = (y * W + x) * 3;\n      // The tongue, out of the mouth under the eye and down over the rim,\n      // flapping with the hop.\n      const tl = (cy + 8.5) / 13.5, tx = f * (0.6 + (1.5 + 2.5 * sin(PI * U.p)) * tl);\n      if (tl > 0 && tl \u003c 1 && abs(lx - tx) \u003c 1.9 - 0.4 * tl) {\n        put(buf, o, abs(lx - tx) \u003c 0.45 && tl > 0.2 ? GROOVE : TONGUE);\n        continue;\n      }\n      if (canopy(lx, cy)) {\n        const hw = cy \u003c 0 ? 13 * sqrt(1 + cy / 28) * (1 + (0.15 * cy) / 28) : 13, u = lx / hw;\n        const ey = (lx - f) ** 2 / 20 + (cy + 15) ** 2 / 16;\n        if (ey \u003c 1.4) {\n          // The eye looks the way it is going.\n          put(buf, o, ey > 1 ? BLACK : (lx - 2 * f) ** 2 + (cy + 15.5) ** 2 \u003c 3.6 ? BLACK : WHITE);\n        } else if (abs(lx - f * 0.6) \u003c 3 && abs(cy + 8.6) \u003c 1) put(buf, o, GULLET);\n        else if (cy \u003c -26.5) put(buf, o, BLACK);\n        else {\n          const rib = abs(u * 2 - round(u * 2)) * hw \u003c 0.55, side = floor((u + 1) * 2) & 1;\n          put(buf, o, rib ? RIB : side ? GREEN2 : GREEN);\n          if (cy > -1.5) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.62;\n        }\n        continue;\n      }\n      if (canopy(lx + 0.9, cy) || canopy(lx - 0.9, cy) || canopy(lx, cy + 0.9) || canopy(lx, cy - 0.9)) {\n        for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      // The tip.\n      if (lx * lx + (cy + 29.6) ** 2 \u003c 2.6) {\n        put(buf, o, BLACK);\n        continue;\n      }\n      // The leg, its knee bending forward in a crouch, and the clog.\n      const kx = f * (13 - U.leg) * 0.9, kl = U.leg / 2, legd = ly \u003c kl ? abs(lx - kx * (ly / kl)) : abs(lx - kx * (1 - (ly - kl) / kl));\n      if (ly > 0 && ly \u003c U.leg && legd \u003c 1.15) put(buf, o, SKIN);\n      else if (ly >= U.leg && ly \u003c U.leg + 1.4 && abs(lx) \u003c 3.8) put(buf, o, [150, 30, 40]);\n      else if (ly >= U.leg + 1.4 && ly \u003c U.leg + 3.3 && abs(abs(lx) - 2.3) \u003c 0.8) put(buf, o, [92, 56, 40]);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0) return;\n  const buf = S.buf, L = S.L;\n  buf.set(S.bg);\n  const [cx, cy] = toWorld(S.th, 0, LC);\n  // The halo around the lantern in three steps, and its light under the eave.\n  for (let y = 0; y \u003c GROUND; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const r = sqrt((x + 0.5 - cx) ** 2 + ((y + 0.5 - cy) * 0.8) ** 2), a = r \u003c 22 ? 0.3 : r \u003c 30 ? 0.17 : r \u003c 40 ? 0.07 : 0;\n      if (a) addc(buf, (y * W + x) * 3, L, a * (y \u003c 9 ? 1.6 : 1));\n    }\n  // The puddles hold the lantern upside down, broken up by ripples, and the\n  // wet stones catch its light where it falls.\n  for (let y = GROUND; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, wob = sin(y * 2.1 + S.t * 5) * 1.2;\n      if (inPuddle(x + 0.5, y + 0.5)) {\n        const w = abs(x + 0.5 + wob - cx);\n        if (w \u003c 11) addc(buf, o, S.paper, w \u003c 6 ? 0.8 : 0.45);\n      } else if (abs(x + 0.5 - cx) \u003c 11 - (y - GROUND) * 0.3 && (y - GROUND) % 6 === 0) addc(buf, o, L, 0.75);\n    }\n  for (const [x, y, t, big] of S.rings) {\n    const rr = 1 + (t / 0.45 / big) * 4.5 * big, a = 0.6 * (1 - t / 0.45 / big);\n    for (let i = 0; i \u003c 20; i++) {\n      const px = round(x + rr * cos((i * TAU) / 20)), py = round(y + rr * 0.32 * sin((i * TAU) / 20));\n      if (px >= 0 && px \u003c W && py \u003c H && inPuddle(px + 0.5, py + 0.5)) addc(buf, (py * W + px) * 3, [190, 180, 230], a);\n    }\n  }\n  lantern(S, buf);\n  // The tongue swings in front of the lantern's lower half and below it.\n  tongue(S, buf);\n  umbrella(S, buf);\n  // Rain: pale lilac streaks, lit the lantern's colour near it.\n  const wind = S.wind;\n  for (const r of S.drops) {\n    const dl = sqrt((r.x - cx) ** 2 + ((r.y - cy) * 0.8) ** 2), lit = dl \u003c 20 ? 0.85 : dl \u003c 32 ? 0.5 : dl \u003c 46 ? 0.22 : 0;\n    for (let i = 0; i \u003c r.len; i++) {\n      const x = round(r.x - wind * i), y = round(r.y - i);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3, a = 1 - i / r.len;\n      // Lit drops lose the lilac, so they read orange rather than peach.\n      addc(buf, o, RAIN, 0.55 * a * (1 - lit));\n      if (lit) addc(buf, o, L, lit * a);\n    }\n  }\n  for (const [x, y, , , t] of S.bits) {\n    const px = round(x), py = round(y);\n    if (px >= 0 && px \u003c W && py >= 0 && py \u003c H) addc(buf, (py * W + px) * 3, [170, 160, 220], 1 - t / 0.55);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","risset-rhythm":"// ===== Patternflow pattern =====\n// Title:   Risset Rhythm\n// Family:  rhythm\n// Idea:    A binary ruler, its ticks longer the coarser their level, lies across five octaves of tempo and zooms out by two every four seconds towards a point just under the panel, so each lane of ticks strikes the playhead ever faster while the lanes slide towards the fast side under a fixed bell of light, and after each doubling the picture is exactly where it began.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Risset's eternal accelerando (Jean-Claude Risset, 1970s), the rhythmic twin of Shepard tones (Roger Shepard, 1964), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=-1..1, Ratio=2..4\n//\n// Knob 1: Hue. Turns the colours across the panel together; the strikes stay white. At 0 the slow lanes on the left are green, the middle azure and the fast lanes on the right violet; at 0.25 blue, magenta and red; at 0.5 violet, orange and yellow-green; at 0.75 yellow, green and teal.\n// Knob 2: Speed. Every tempo doubles in 8 / Speed seconds: 4 at 2, 40 at 0.2 and 2.7 at 3. At 2 the ticks cross the playhead at 11 rows a second, and a lane strikes 0.23 times a second at the left edge, 1.3 at the middle and 7 at the right edge, each lane twice as often one doubling later, by which time it has slid one lane to the right.\n// Knob 3: Spread. The width of the bell of light in octaves of tempo, 1.4 times 2 to the knob. At 0 the edge lanes glow at a fifth of the middle; at -1 (0.7 octaves) one lane carries the light and the edges are dark; at 1 (2.8 octaves) the edges keep two thirds and the hand-over from fast to slow shows plainly.\n// Knob 4: Ratio. The tempo ratio between neighbouring layers, rounded to 2, 3 or 4: a binary, ternary or base-four ruler. Its lanes are 12.8, 20.3 and 25.6 LEDs wide, a doubling of tempo always being 12.8, and the picture repeats after one ratio's worth of tempo, every 4, 6.3 and 8 seconds at Speed 2.\n// Buttons: K1 tap turns the accelerando into a ritardando and back: the zoom runs the other way, the ticks rise through the playhead, the lanes slide towards the slow side and every tempo halves in the time it took to double.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, min, max, exp, pow, log2, round, LN2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Across the panel runs log tempo: OCT LEDs to an octave, five octaves from\n// the slowest layer on the left to the fastest on the right. The loudness\n// bell is centred BELL octaves in from the left.\nconst OCT = W / 5, BELL = 2.4;\n// The ruler's zero, the point the zoom closes on, sits 8 rows below the\n// bottom edge; the playhead is row PLAY. The layer at the left edge has its\n// ticks SP0 rows apart.\nconst Y0 = H + 8, PLAY = 72, SP0 = 48;\n// Seconds for every tempo to double at Speed 2, and how long a hit glows.\nconst T2 = 4, GLOW = 0.12;\n// The light of a played tick against one to come, the rows the white of a\n// tick crossing the playhead takes to fade, the halo of a hit and its reach\n// in rows, and the faint light of every other lane.\nconst PAST = 0.6, FLASH = 3, HALO = 0.45, HR = 12, LANE = 0.12;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, dir: 1, hue: 0, speed: 2, spread: 1.4, r: 2,\n    buf: new Float32Array(NP * 3), bell: new Float32Array(W), cr: new Float32Array(W), cg: new Float32Array(W), cb: new Float32Array(W),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 2];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.spread = 1.4 * pow(2, cl(k[2], -1, 1));\n  S.r = round(cl(k[3], 2, 4));\n  if (input.btnPressed && input.btnPressed[0]) S.dir = -S.dir;\n  // t counts doublings: every tempo is 2^t times what it was at the start.\n  S.t += (S.dir * cl(dt || 0, 0, 0.1) * S.speed) / (2 * T2);\n}\n\nfunction hsv(h, s, v, o, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0][o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1][o] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2][o] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { buf, bell, cr, cg, cb } = S;\n  buf.fill(0);\n  // The bell is fixed in log tempo: each column's loudness, and its colour.\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5) / OCT - BELL;\n    bell[x] = exp((-u * u) / (2 * S.spread * S.spread));\n    hsv(S.hue + 0.3 + (0.55 * x) / W, 0.8, 1, x, [cr, cg, cb]);\n  }\n  // One period of the picture is log2(r) doublings: then every layer has\n  // become the next one.\n  const r = S.r, per = log2(r), lw = OCT * per;\n  const z = S.t / per, n = floor(z), p = z - n;\n  // Real seconds per doubling at this speed, for the glow of a hit.\n  const Td = (2 * T2) / S.speed;\n  // Bars just past the playhead burn white, fading over FLASH rows.\n  const sgn = S.dir > 0 ? 1 : -1;\n  for (let j = -2; (j + p) * lw \u003c W; j++) {\n    const x0 = max(0, floor((j + p) * lw + 0.5)), x1 = min(W, floor((j + 1 + p) * lw + 0.5));\n    if (x1 \u003c= x0) continue;\n    const sp = SP0 * pow(r, -(j + p)), th = cl(sp / 4, 0.6, 2.2);\n    // Ticks: every multiple of sp above the ruler's zero.\n    const m0 = max(0, ceil((Y0 - H - 2) / sp)), m1 = floor((Y0 + 2) / sp);\n    if (sp >= 1.2) {\n      for (let m = m0; m \u003c= m1; m++) {\n        // Played ticks, past the playhead, are dimmer than the ones to come.\n        const y = Y0 - m * sp, d = sgn * (y - PLAY);\n        bar(buf, y, th, x0, x1, d > 0 ? PAST : 1, d > -0.5 ? exp(-max(0, d) / FLASH) : 0, bell, cr, cg, cb);\n      }\n    } else {\n      for (let y = 0; y \u003c H; y++) line(buf, y, x0, x1, min(1, 0.8 / sp) * (sgn * (y - PLAY) > 0 ? PAST : 1), 0, bell, cr, cg, cb);\n    }\n    // A hit: the playhead stands phi tick spacings above zero, so the layer\n    // strikes whenever phi passes a whole number, phi ln2 times a doubling.\n    const phi = (Y0 - PLAY) / sp, fr = phi - floor(phi);\n    const age = ((S.dir > 0 ? fr : 1 - fr) * Td) / (phi * LN2);\n    const g = exp(-age / GLOW);\n    for (let dy = -HR; dy \u003c= HR; dy++) {\n      const f = 1 - Math.abs(dy) / (HR + 1);\n      line(buf, PLAY + dy, x0, x1, HALO * g * f * f, 0.3 * HALO * g * f * f * f, bell, cr, cg, cb);\n    }\n  }\n  // Each lane is faintly lit, with a dark seam at its edges, so the lanes\n  // show sliding towards the fast side.\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5) / lw - p, e = (u - floor(u)) * lw, v = LANE * min(1, e / 1.5, (lw - e) / 1.5);\n    for (let y = 0; y \u003c H; y++) line(buf, y, x, x + 1, v, 0, bell, cr, cg, cb);\n  }\n  // The playhead.\n  for (let x = 0, o = 3 * PLAY * W; x \u003c W; x++, o += 3) (buf[o] += 0.16), (buf[o + 1] += 0.16), (buf[o + 2] += 0.16);\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      display.setPixel(x, y, q4(buf[o]), q4(buf[o + 1]), q4(buf[o + 2]));\n    }\n}\n\n// A bar th rows thick centred on row y, spread over the rows it covers.\nfunction bar(buf, y, th, x0, x1, v, w, bell, cr, cg, cb) {\n  const top = y - th / 2, bot = y + th / 2;\n  for (let a = floor(top); a \u003c bot; a++) {\n    const c = min(bot, a + 1) - max(top, a);\n    if (c > 0) line(buf, a, x0, x1, v * c, w * c, bell, cr, cg, cb);\n  }\n}\n\n// Adds colour v and white w along row y from x0 to x1, each column weighted\n// by the bell.\nfunction line(buf, y, x0, x1, v, w, bell, cr, cg, cb) {\n  if (y \u003c 0 || y >= H) return;\n  for (let x = x0, o = 3 * (y * W + x0); x \u003c x1; x++, o += 3) {\n    const b = bell[x], c = v * b, e = w * b;\n    buf[o] += c * cr[x] + e;\n    buf[o + 1] += c * cg[x] + e;\n    buf[o + 2] += c * cb[x] + e;\n  }\n}\n\n// Channels in steps of 4 of 255, from 0..1.\nconst q4 = (v) => (v >= 1 ? 252 : ((v * 63 + 0.5) | 0) \u003c\u003c 2);\n","skull-swap":"// ===== Patternflow pattern =====\n// Title:   Skull Swap\n// Family:  halloween\n// Idea:    Two skeletons dance side by side in a moonlit graveyard, then each lifts off its own skull and they toss them across on crossing arcs past the moon, catch them on the wrong necks, wobble, turn their glowing sockets on each other, shrug, and toss them back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50, built on Bone Pile, pattern round 48\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Toss=0..1, Dance=2..8\n//\n// Knob 1: Hue. The night sky and the shade side of the bones, through the cold half of the wheel only: violet at 0, blue at 0.25, cyan at 0.5, sea green at 0.75, toxic green at 1. The moon stays cream, the pumpkin orange, one skull's eyes green and the other's orange.\n// Knob 2: Speed. The tempo, 50 beats a minute for each unit. At the opening 100 the skulls leave the hands at 1.6 s, land on the wrong necks at 2.1 s, the two look at each other at 2.8 s, shrug at 3.6 s and throw back at 4.9 s. At 0.2 ten times slower; 150 at 3.\n// Knob 3: Toss. How high the skulls fly and how often they spin. At 0 the higher arc crosses the moon and each skull turns once; at 0.5 it brushes the top edge and they turn twice; at 1 it leaves the panel for a moment, they turn three times and the throwers hop.\n// Knob 4: Dance. Beats danced between swaps, 2 to 8. Each round they dance the next of three dances: a sway with both arms up, kicks to the side with hands on hips, a bounce at the knees pumping the forearms in turn.\n// Buttons: K1 tap ends the dance and starts the throw at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, acos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hsv = (h, s, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + h * 6) % 6;\n  o[c] = 255 * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\n// --- shapes in their own frames, y down, as distances (negative inside).\nconst seg = (x, y, ax, ay, bx, by) => {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return sqrt((x - ax - dx * t) ** 2 + (y - ay - dy * t) ** 2);\n};\nconst ell = (x, y, cx, cy, rx, ry) => (sqrt(((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2) - 1) * min(rx, ry);\nconst box = (x, y, cx, cy, hx, hy, r) => {\n  const qx = abs(x - cx) - hx + r, qy = abs(y - cy) - hy + r;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n};\nfunction long(x, y, L, w, r) {\n  const e = L / 2 - r, q = 0.6 * r, ry = r * 0.9;\n  return min(seg(x, y, 0, -e, 0, e) - w, ell(x, y, -q, -e, r, ry), ell(x, y, q, -e, r, ry), ell(x, y, -q, e, r, ry), ell(x, y, q, e, r, ry));\n}\n// Kinds: 0 long bone, 1 paired bones, 2 cage and neck, 3 lumbar, 4 pelvis,\n// 5 skull, 6 jaw, 7 hand, 8 foot, 9 hat. The cage is narrower than Bone Pile's.\nconst RIBS = [[6.4, 2.4], [7.9, 6.6], [8.8, 10.8], [8.8, 15], [7.8, 19]];\nfunction shape(k, x, y, sg) {\n  switch (k) {\n    case 0:\n      return long(x, y, sg, 0.95 + 0.015 * sg, 1.5);\n    case 1: {\n      const e = sg / 2 - 1.1;\n      return min(seg(x, y, -1, -e, -1, e) - 0.8, seg(x, y, 1.1, -e, 1.1, e) - 0.6, box(x, y, 0, -e - 0.2, 2.3, 1.1, 1), box(x, y, 0, e + 0.2, 2.1, 1.1, 1));\n    }\n    case 2: {\n      let d = min(box(x, y, 0, -3.4, 1.5, 0.75, 0.5), box(x, y, 0, -1.4, 1.6, 0.75, 0.5));\n      d = min(d, seg(x, y, -1.4, 0.8, -9.6, -0.2) - 0.8, seg(x, y, 1.4, 0.8, 9.6, -0.2) - 0.8, seg(x, y, 0, 1, 0, 14) - 1.2);\n      for (let v = 15.5; v \u003c 24; v += 2.7) d = min(d, box(x, y, 0, v, 1.6, 0.9, 0.5));\n      for (const [rx, ry] of RIBS) {\n        const c = 3.6 / (rx * rx), ax = min(abs(x), rx), f = ry + c * ax * ax;\n        d = min(d, abs(x) \u003c= rx ? abs(y - f) / sqrt(1 + (2 * c * ax) ** 2) - 0.7 : sqrt((abs(x) - rx) ** 2 + (y - f) ** 2) - 0.7);\n      }\n      return d;\n    }\n    case 3: {\n      let d = 9;\n      for (let v = -4; v \u003c= 4.1; v += 2.7) d = min(d, box(x, y, 0, v, 1.9, 0.95, 0.5), box(x, y, 0, v, 3.1, 0.4, 0.3));\n      return d;\n    }\n    case 4: {\n      let d = max(abs(x) - (2.5 - 0.28 * (y + 5.5)), abs(y + 2.6) - 3);\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const dx = x - s * 5.3, dy = y + 3.6, c = 0.8, n = 0.6 * s;\n        d = min(d, ell(dx * c + dy * n, -dx * n + dy * c, 0, 0, 4.1, 2.9), abs(ell(x, y, s * 3.4, 2.4, 2.4, 1.9)) - 0.75, ell(x, y, s * 6.5, 0, 1.5, 1.5));\n      }\n      return d;\n    }\n    case 5:\n      return min(ell(x, y, 0, -10.6, 7, 7.3), ell(x, y, 0, -6.8, 6.4, 2.3), box(x, y, 0, -3.2, 4.4, 2.6, 1.4));\n    case 6: {\n      const hw = 4.3 - 0.4 * max(0, y);\n      return min(box(x, y, 0, 1.5, 4.3, 1.6, 0.8), max(abs(x) - hw, abs(y - 1.6) - 1.8));\n    }\n    case 7: {\n      let d = ell(x, y, 0, 1.4, 1.8, 1.4);\n      for (let i = 0; i \u003c 4; i++) d = min(d, seg(x, y, -1.2 + 0.8 * i, 2.2, -1.8 + 1.2 * i, 5.4) - 0.5);\n      return d;\n    }\n    case 8:\n      return min(ell(x, y, sg * 0.8, 1.6, 3.1, 1.4), ell(x, y, 0, 0.4, 1.4, 1));\n    default: {\n      // A witch's hat: brim, tapering cone, bent tip.\n      const t = cl((-17.4 - y) / 10, 0, 1);\n      return min(ell(x, y, 0.4, -17, 8.4, 1.4), seg(x, y, 0, -17.4, 2.6, -27.4) - mix(4.6, 0.7, t), seg(x, y, 2.6, -27.4, 6, -28.6) - 0.7);\n    }\n  }\n}\n// 0 none, 1 dark, 2 socket, 3 shade, 4 pupil, 5 hat band; the face slides\n// sideways as the head turns, the pupils further.\nfunction hole(k, x, y, Hd) {\n  if (k === 5) {\n    const p = Hd.pitch * 3, xs = x - Hd.yaw * 1.7;\n    if (((abs(xs) - 2.9) / 2.2) ** 2 + ((y + 7.9 - p) / 2.5) ** 2 \u003c 1) return ((abs(xs) - 2.9 - Hd.yaw * Math.sign(xs) * 0.9) / 1.15) ** 2 + ((y + 7.7 - p) / 1.3) ** 2 \u003c 1 ? 4 : 2;\n    const ny = y + 5.4 - p;\n    if (ny >= 0 && ny \u003c 1.7 && abs(xs) \u003c 0.3 + 0.5 * ny) return 1;\n    if (y > -2 + p * 0.5 && y \u003c -0.5 && abs(xs * 0.8) \u003c 3.4) return (xs + 4) / 1.45 - floor((xs + 4) / 1.45) \u003c 0.3 || y > -0.9 ? 1 : 0;\n  } else if (k === 6 && y \u003c 1.2 && y > -0.2 && abs(x) \u003c 3.8) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 ? 1 : 0;\n  else if (k === 4 && ((abs(x) - 4.6) / 2.3) ** 2 + ((y + 4.4 + 0.3 * abs(x)) / 1.3) ** 2 \u003c 1) return 3;\n  else if (k === 9 && y > -19.4 && y \u003c -17.6 && abs(x) \u003c 5.2) return 5;\n  return 0;\n}\n\n// Body pieces back to front, [kind, length, bounds]; the hands are drawn\n// after the heads, to hold one from in front.\nconst FEMUR = 22, TIBIA = 21, ARM = 15, FORE = 13, HIP = 6.5, FLOOR = 120, HIPY = FLOOR - 3 - FEMUR - TIBIA;\nconst two = (p) => [p, p];\nconst PIECES = [[8, -1, -3.9, 3.9, -1, 3.2], [8, 1, -3.9, 3.9, -1, 3.2], ...two([1, TIBIA, -2.4, 2.4, -11, 11]), ...two([0, FEMUR, -2.6, 2.6, -11.4, 11.4]), [4, 0, -11, 11, -9, 5.2], [3, 0, -3.6, 3.6, -5.3, 5.3], [2, 0, -10.6, 10.6, -4.5, 22.6], ...two([0, ARM, -2.6, 2.6, -7.9, 7.9]), ...two([1, FORE, -2.4, 2.4, -7, 7]), ...two([7, 0, -2.7, 2.7, -0.3, 6.1])];\nconst SKULL = [5, 0, -7.2, 7.2, -18.1, 0.6], JAW = [6, 0, -4.4, 4.4, -0.3, 3.5], HAT = [9, 0, -8.6, 7, -29.6, -15.4];\n\n// --- the body, posed in Bone Pile's frame (floor 120, x = 0, full size)\n// and placed on the panel at its own scale.\nconst at = (K, i, x, y, a) => {\n  K.x[i] = K.cx + K.sc * x;\n  K.y[i] = FLOOR + K.sc * (y - FLOOR);\n  K.a[i] = a;\n};\nconst ang = (dx, dy) => atan2(-dx, dy);\nconst bone = (K, i, ax, ay, bx, by) => at(K, i, (ax + bx) / 2, (ay + by) / 2, ang(bx - ax, by - ay));\nconst rot = (a, x, y) => [x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)];\n// Two-bone reach; of the two joints that work, the one nearer (px, py).\nfunction limb(K, ax, ay, tx, ty, L1, L2, i1, i2, px, py) {\n  const dx = tx - ax, dy = ty - ay, d = cl(sqrt(dx * dx + dy * dy), 2, L1 + L2 - 0.01), b = atan2(dy, dx);\n  const al = acos(cl((L1 * L1 + d * d - L2 * L2) / (2 * L1 * d), -1, 1));\n  let kx = ax + L1 * cos(b + al), ky = ay + L1 * sin(b + al);\n  const mx = ax + L1 * cos(b - al), my = ay + L1 * sin(b - al);\n  if ((mx - px) ** 2 + (my - py) ** 2 \u003c (kx - px) ** 2 + (ky - py) ** 2) (kx = mx), (ky = my);\n  const n = sqrt((tx - kx) ** 2 + (ty - ky) ** 2) || 1, u = (tx - kx) / n, v = (ty - ky) / n;\n  bone(K, i1, ax, ay, kx, ky);\n  bone(K, i2, kx, ky, kx + L2 * u, ky + L2 * v);\n  return [kx + L2 * u, ky + L2 * v, u, v];\n}\n// Legs, spine and cage; leaves the neck on the panel in K.nx, K.ny, K.na.\nfunction torso(D, K) {\n  const rx = D.sway, ry = HIPY + D.bob, t = D.tilt, l = D.lean;\n  at(K, 6, rx, ry, t);\n  for (const s of [-1, 1]) {\n    const [hx, hy] = rot(t, s * HIP, 0), f = s \u003c 0 ? D.fl : D.fr, ax = rx + hx, ay = ry + hy;\n    const [ex, ey] = limb(K, ax, ay, s * (HIP + f[1]), FLOOR - 3 - f[0], FEMUR, TIBIA, 4 + (s > 0), 2 + (s > 0), ax + s * 60, ay + 20);\n    at(K, s > 0 ? 1 : 0, ex, ey, 0);\n  }\n  const [b0, b1] = rot(t, 0, -5), sx = rx + b0, sy = ry + b1, [c0, c1] = rot(l, 0, -10);\n  bone(K, 7, sx + c0, sy + c1, sx, sy);\n  const [d0, d1] = rot(l, 0, -24), tx = sx + c0 + d0, ty = sy + c1 + d1 - D.shr * 0.4;\n  at(K, 8, tx, ty, l);\n  const [n0, n1] = rot(l, 0, -4.4);\n  Object.assign(K, { tx, ty, nx: K.cx + K.sc * (tx + n0), ny: FLOOR + K.sc * (ty + n1 - FLOOR), na: l + D.head });\n}\n// Arms from the dance angles, each hand pulled toward its K.hold target.\nfunction arms(D, K) {\n  const l = D.lean;\n  for (const s of [-1, 1]) {\n    const [o0, o1] = rot(l, s * 10, 0.6 - D.shr), ax = K.tx + o0, ay = K.ty + o1, a1 = s \u003c 0 ? D.al : D.ar, a2 = s \u003c 0 ? D.bl : D.br;\n    const [u0, u1] = rot(l, s * sin(a1), cos(a1)), ex = ax + ARM * u0, ey = ay + ARM * u1;\n    const [v0, v1] = rot(l, s * sin(a1 + a2), cos(a1 + a2));\n    let wx = ex + FORE * v0, wy = ey + FORE * v1;\n    const h = K.hold[s > 0 ? 1 : 0];\n    if (h[0] > 0) (wx = mix(wx, (h[1] - K.cx) / K.sc, h[0])), (wy = mix(wy, FLOOR + (h[2] - FLOOR) / K.sc, h[0]));\n    const [hx, hy, u, v] = limb(K, ax, ay, wx, wy, ARM, FORE, 9 + (s > 0), 11 + (s > 0), ex, ey);\n    at(K, 13 + (s > 0), hx, hy, ang(u, v));\n  }\n}\n\nconst REST = { sway: 0, bob: 0, tilt: 0, lean: 0, head: 0, pitch: 0, jaw: 0, shr: 0, al: 0.1, bl: 0.06, ar: 0.1, br: 0.06, fl: [0, 0], fr: [0, 0] };\nconst clack = (b) => max(0, sin(TAU * b)) ** 2;\nfunction dance(m, b, D) {\n  Object.assign(D, REST, { fl: [0, 0], fr: [0, 0], jaw: clack(b) });\n  const w = sin(PI * b), s2 = sin((PI * b) / 2);\n  if (m === 0) {\n    // Sway: hips side to side over four beats, both arms up waving.\n    Object.assign(D, { sway: 3 * s2, tilt: 0.1 * s2, lean: -0.08 * s2, head: -0.18 * s2, al: 2.75 + 0.18 * w, ar: 2.75 - 0.18 * w, bl: 0.25 + 0.25 * w, br: 0.25 - 0.25 * w });\n  } else if (m === 1) {\n    // Kicks: a foot out to the side each beat, hands on the hips.\n    const k = sin(PI * (b - floor(b))) ** 2, s = floor(b) & 1 ? 1 : -1;\n    D[s \u003c 0 ? \"fl\" : \"fr\"] = [8 * k, 4 * k];\n    Object.assign(D, { sway: -s * 1.2 * k, head: s * 0.16 * k, al: 0.5, ar: 0.5, bl: -1.6, br: -1.6 });\n  } else {\n    // Bounce: a dip at the knees on every beat, elbows at the sides and the\n    // forearms pumping up in turn.\n    const e = 0.5 - 0.5 * cos(PI * b);\n    Object.assign(D, { bob: 1.4 - 1.4 * cos(TAU * b), sway: 1.5 * w, head: 0.16 * w, al: 0.3, bl: 0.2 + 2.3 * e, ar: 0.3, br: 2.5 - 2.3 * e });\n  }\n}\n// The right-hand skeleton dances the mirror image.\nfunction mirror(D) {\n  [D.al, D.ar, D.bl, D.br, D.fl, D.fr] = [D.ar, D.al, D.br, D.bl, D.fr, D.fl];\n  for (const key of [\"sway\", \"tilt\", \"lean\", \"head\"]) D[key] = -D[key];\n}\n\n// The story of one round in beats from its start: dance, lift, fly, land on\n// the wrong neck, look, shrug, lift, fly back, land home and nod.\nconst LIFT = 0.6;\nfunction times(S) {\n  const t0 = S.d, t1 = t0 + LIFT, t2 = t1 + S.T, t3 = t2 + 1.2, t4 = t3 + 1.3, t5 = t4 + 1.6;\n  return [t0, t1, t2, t3, t4, t5, t5 + LIFT, t5 + LIFT + S.T, t5 + LIFT + S.T + 1.6];\n}\n\nexport function setup(params) {\n  const body = (cx, sc) => ({ cx, sc, x: new Float64Array(15), y: new Float64Array(15), a: new Float64Array(15), D: { ...REST } });\n  params.s = {\n    hue: -1, beat: 0, t: 0, start: 0, moves: 0, d: 2, T: 1,\n    light: [0, 0, 0], bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    // The green-eyed skull belongs to the tall skeleton on the left, the\n    // orange-eyed one in the hat to the short one on the right.\n    K: [body(16, 0.8), body(48, 0.68)],\n    hd: [{ sc: 1, eye: [96, 255, 64], hat: 0 }, { sc: 0.86, eye: [255, 132, 8], hat: 1 }],\n  };\n}\n\n// Where a skull's hands go: either side of its cranium.\nconst sides = (Hd, s) => {\n  const [p, q] = rot(Hd.a, s * 8.6 * Hd.sc, -6 * Hd.sc);\n  return [Hd.x + p, Hd.y + q];\n};\nconst onNeck = (Hd, K, lift) => {\n  const [p, q] = rot(K.na, 0, -7 * lift);\n  Object.assign(Hd, { x: K.nx + p, y: K.ny + q, a: K.na + K.wob, yaw: K.yaw, jaw: K.D.jaw, pitch: K.D.pitch, fly: 0 });\n};\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    hsv(0.78 - 0.47 * hue, 0.62, S.light);\n    background(S);\n  }\n  const toss = cl(k[2], 0, 1), every = round(cl(k[3], 2, 8));\n  S.beat += (d * 50 * cl(k[1], 0.2, 3)) / 60;\n  S.t += d;\n  let u = S.beat - S.start;\n  if (u \u003c S.d) S.d = every;\n  if (input.btnPressed && input.btnPressed[0] && u \u003c S.d) (S.start = S.beat - S.d), (u = S.d);\n  let T = times(S);\n  if (u >= T[8]) {\n    S.start += T[8];\n    u -= T[8];\n    S.moves++;\n    S.d = every;\n  }\n  T = times(S);\n  // The arc is settled while no skull is in the air.\n  if (!((u >= T[1] && u \u003c T[2]) || (u >= T[6] && u \u003c T[7]))) {\n    S.h = 13 + 24 * toss;\n    S.T = 0.26 * sqrt(S.h);\n    S.turns = 1 + floor(toss * 2.99);\n    S.hop = toss;\n    T = times(S);\n  }\n  const [t0, t1, t2, t3, t4, t5, t6, t7] = T, m = S.moves % 3;\n  // Bodies: the dance, eased in and out, then the story.\n  S.K.forEach((K, i) => {\n    const D = K.D, dir = i ? -1 : 1;\n    dance(m, S.beat, D);\n    if (i) mirror(D);\n    const w = ease(u / 0.5) * (1 - ease((u - t0) / 0.4));\n    for (const key in REST) if (typeof REST[key] === \"number\") D[key] = mix(REST[key], D[key], w);\n    for (const f of [\"fl\", \"fr\"]) D[f] = D[f].map((v) => v * w);\n    K.wob = K.lift = 0;\n    for (const [ts, back] of [[t0, 0], [t5, 1]]) {\n      const q = u - ts;\n      if (q \u003c 0 || q > LIFT + S.T + 1.6) continue;\n      if (q \u003c LIFT) {\n        // Crouch with the skull lifted off the neck.\n        K.lift = ease((q / LIFT - 0.35) / 0.65);\n        D.bob += K.lift * (4 + 4 * S.hop);\n      } else if (q \u003c LIFT + S.T) {\n        // A hop on the throw, more for a high one.\n        const f = (q - LIFT) / S.T;\n        D.bob -= (2 + 7 * S.hop) * sin(PI * cl(f * 2.5, 0, 1));\n      } else {\n        // Landed: the knees give, more under the big skull; the head wobbles.\n        const v = q - LIFT - S.T, big = (i === 1) !== !!back ? 1.5 : 1;\n        D.bob += 5 * big * exp(-4 * v) * sin(min(PI, v * 9));\n        K.wob = (back ? 0.22 : 0.5) * big * exp(-2.4 * v) * sin(TAU * 2.2 * v) * dir;\n      }\n    }\n    // Look: the sockets turn on the other one; the jaw drops.\n    const lk = ease((u - t3) / 0.25) * (1 - ease((u - t4 + 0.1) / 0.3));\n    K.yaw = dir * lk;\n    D.lean += 0.07 * lk * dir;\n    D.jaw = max(D.jaw, 0.9 * lk * ease((u - t3 - 0.45) / 0.15));\n    // Shrug: shoulders up, elbows out, hands up and open, head on one side.\n    const sh = ease((u - t4) / 0.3) * (1 - ease((u - t5 + 0.45) / 0.35));\n    if (sh > 0) Object.assign(D, { shr: 3.5 * sh, al: mix(D.al, 0.3, sh), ar: mix(D.ar, 0.3, sh), bl: mix(D.bl, 2.5, sh), br: mix(D.br, 2.5, sh), head: D.head + 0.32 * sh * dir, jaw: max(D.jaw, 0.5 * sh) });\n    // Home again: a nod.\n    const n = (u - t7 - 0.8) / 0.6;\n    D.pitch = n > 0 && n \u003c 1 ? sin(PI * n) : 0;\n    torso(D, K);\n  });\n  // Skulls: on a neck, lifted, or flying neck to neck, the left one higher.\n  const A = S.K[0];\n  S.hd.forEach((Hd, i) => {\n    const own = S.K[i], other = S.K[1 - i];\n    let from = null, to = null, f = 0;\n    if (u \u003c t1) onNeck(Hd, own, own.lift);\n    else if (u \u003c t2) (from = own), (to = other), (f = (u - t1) / S.T);\n    else if (u \u003c t6) onNeck(Hd, other, other.lift);\n    else if (u \u003c t7) (from = other), (to = own), (f = (u - t6) / S.T);\n    else onNeck(Hd, own, 0);\n    if (from) {\n      // The arc is the cranium's middle, and the skull spins about it.\n      const pv = -9.5 * Hd.sc, h = S.h + (from === A ? 12 : 0), a = mix(from.na, to.na, f) + (from === A ? 1 : -1) * S.turns * TAU * f;\n      const [p, q] = rot(from.na, 0, pv - 7), [r, s] = rot(to.na, 0, pv), [e, g] = rot(a, 0, pv);\n      Object.assign(Hd, { x: mix(from.nx + p, to.nx + r, f) - e, y: mix(from.ny + q, to.ny + s, f) - 4 * h * f * (1 - f) - g, a, yaw: 0, jaw: 0.8, pitch: 0, fly: 1 });\n    }\n  });\n  // Hands: onto the skull, after it on the throw, up to catch, then down.\n  S.K.forEach((K, i) => {\n    K.hold = [[0], [0]];\n    const dir = i ? -1 : 1;\n    for (const [ts, back] of [[t0, 0], [t5, 1]]) {\n      const q = u - ts, f = (q - LIFT) / S.T, mine = S.hd[back ? 1 - i : i], theirs = S.hd[back ? i : 1 - i];\n      if (q \u003c 0 || f > 1 + 0.8 / S.T) continue;\n      for (const s of [0, 1]) {\n        const sd = 2 * s - 1;\n        if (f \u003c 0) K.hold[s] = [ease(q / LIFT / 0.45), ...sides(mine, sd)];\n        else if (f \u003c 1) {\n          const c = ease((f - 0.3) / 0.45), [x, y] = sides({ x: K.nx, y: K.ny, a: K.na, sc: theirs.sc }, sd);\n          K.hold[s] = [1, mix(K.nx + dir * 9 + sd * 3, x, c), mix(K.ny - 18, y, c)];\n        } else K.hold[s] = [1 - ease((q - LIFT - S.T - 0.2) / 0.5), ...sides(theirs, sd)];\n      }\n    }\n    arms(K.D, K);\n  });\n}\n\n// --- the graveyard, laid out per sky colour: a stepped sky, the moon and two\n// halo rings, black stones rimmed by the moon, the ground.\nconst MX = 32, MY = 21, MR = 13, GROUND = 117;\nconst CRATERS = [[-4, -4, 3.2], [4, 1, 2.6], [-2, 6, 2.2], [6, -6, 1.6], [-7, 2, 1.4]];\nconst STONES = [[5, 101, 5.5], [24, 108, 3.6], [41, 107, 3.8], [59, 99, 5.5]];\nfunction grave(x, y) {\n  let d = abs(x - 32) \u003c 1.6 && y > 86 && y \u003c GROUND ? 0 : abs(x - 32) \u003c 6 && y > 92 && y \u003c 95.5 ? 0 : 1;\n  for (const [sx, top, hw] of STONES) if (abs(x - sx) \u003c hw && y \u003c GROUND && (y > top + hw || (x - sx) ** 2 + (y - top - hw) ** 2 \u003c hw * hw)) d = 0;\n  return d === 0;\n}\nfunction background(S) {\n  const bg = S.bg, L = S.light;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, q = sqrt((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2);\n      let r, g, b;\n      if (y \u003c GROUND) {\n        const v = floor((0.14 + 0.52 * (y / GROUND) ** 1.6) * 20) / 20;\n        (r = L[0] * v), (g = L[1] * v), (b = L[2] * v);\n        if (q \u003c MR) {\n          const sp = CRATERS.some(([a, b, c]) => (x + 0.5 - MX - a) ** 2 + (y + 0.5 - MY - b) ** 2 \u003c c * c) ? 26 : 0;\n          (r = 255 - sp), (g = 240 - sp), (b = 204 - sp);\n        } else if (q \u003c MR + 4) (r += 60), (g += 56), (b += 50);\n        else if (q \u003c MR + 9) (r += 26), (g += 24), (b += 22);\n        if (grave(x, y)) {\n          // Black stone, rimmed on top where the moon catches it.\n          const rim = !grave(x, y - 1);\n          (r = rim ? 120 : 14), (g = rim ? 110 : 8), (b = rim ? 132 : 22);\n        }\n      } else {\n        const e = y === GROUND ? 1 : 0, sp = (x * 7 + y * y * 3) % 11 ? 0 : 10;\n        (r = 40 + 30 * e + sp), (g = 26 + 22 * e + sp), (b = 48 + 30 * e + sp);\n      }\n      bg[o] = r;\n      bg[o + 1] = g;\n      bg[o + 2] = b;\n    }\n}\n\n// Ivory, grey, and shade tinted by the sky; the hat violet.\nconst PG = [255, 120, 20], BONE = [[255, 244, 220], [212, 202, 180], [96, 88, 84]];\nconst HATC = [[196, 120, 255], [140, 64, 210], [70, 26, 112]];\nconst FIELD = new Float32Array(48 * 48);\nfunction piece(S, pc, cx, cy, a, sc, Hd) {\n  const [k, sg, x0, x1, y0, y1] = pc, c = cos(a), s = sin(a);\n  let xa = 1e9, xb = -1e9, ya = 1e9, yb = -1e9;\n  for (const [u, v] of [[x0, y0], [x1, y0], [x0, y1], [x1, y1]]) {\n    const wx = cx + (u * c - v * s) * sc, wy = cy + (u * s + v * c) * sc;\n    (xa = min(xa, wx)), (xb = max(xb, wx)), (ya = min(ya, wy)), (yb = max(yb, wy));\n  }\n  xa = max(0, floor(xa) - 1);\n  xb = min(W - 1, ceil(xb) + 1);\n  ya = max(0, floor(ya) - 1);\n  yb = min(H - 1, ceil(yb) + 1);\n  if (xb \u003c xa || yb \u003c ya || xb - xa >= 48 || yb - ya >= 48) return;\n  const buf = S.buf, L = S.light, z = 1 / sc;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy;\n      FIELD[(y - ya) * 48 + x - xa] = shape(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z, sg) * sc;\n    }\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const f = (y - ya) * 48 + x - xa, d = FIELD[f], o = (y * W + x) * 3;\n      if (d > 0.1) {\n        if (d \u003c 1.1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, hl = hole(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z, Hd);\n      if (hl && hl !== 3) {\n        // Dark holes, the glowing sockets and pupils, the hat's band.\n        const e = hl === 1 ? [2, 0, 4] : hl === 5 ? [245, 134, 2] : Hd.eye, g = hl === 2 ? 0.34 : 1;\n        put(buf, o, e[0] * g + 10, e[1] * g + 6, e[2] * g + 14);\n        continue;\n      }\n      // The slope of the field: where it climbs upward the piece faces the moon.\n      const up = y > ya ? FIELD[f - 48] : d + 1, dn = y \u003c yb ? FIELD[f + 48] : d + 1, n = (up - dn) / (abs(up - dn) + abs((x > xa ? FIELD[f - 1] : d) - (x \u003c xb ? FIELD[f + 1] : d)) + 0.01);\n      const t = hl === 3 || n \u003c= -0.3 ? 2 : n > 0.4 || (d > -0.6 && up > 0.1) ? 0 : 1, C = k === 9 ? HATC : BONE, w = t === 2 && k !== 9 ? 0.4 : 0;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = C[t][ch] + L[ch] * w;\n    }\n}\nconst put = (buf, o, r, g, b) => {\n  buf[o] = r;\n  buf[o + 1] = g;\n  buf[o + 2] = b;\n};\nfunction head(S, Hd) {\n  piece(S, SKULL, Hd.x, Hd.y, Hd.a, Hd.sc, Hd);\n  const [j0, j1] = rot(Hd.a, 0, (-0.7 + 2.4 * Hd.jaw + Hd.pitch * 0.6) * Hd.sc);\n  piece(S, JAW, Hd.x + j0, Hd.y + j1 + Hd.pitch * 2.5 * Hd.sc, Hd.a, Hd.sc, Hd);\n  if (Hd.hat) piece(S, HAT, Hd.x, Hd.y + Hd.pitch * 2 * Hd.sc, Hd.a, Hd.sc, Hd);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0) return;\n  const buf = S.buf;\n  buf.set(S.bg);\n  // The jack-o'-lantern: glow rings on the ground, a face in three steps.\n  const v = 0.6 + 0.2 * sin(S.t * 9) + 0.2 * sin(S.t * 23.7), fl = v > 0.82 ? 1 : v > 0.66 ? 0.84 : 0.7;\n  for (let y = 104; y \u003c H; y++)\n    for (let x = 14; x \u003c 50; x++) {\n      const q = sqrt(((x + 0.5 - 32) / 1.6) ** 2 + (y + 0.5 - 121) ** 2), gl = (q \u003c 9 ? 0.3 : q \u003c 13 ? 0.18 : q \u003c 17 ? 0.08 : 0) * fl;\n      for (let ch = 0, o = (y * W + x) * 3; ch \u003c 3; ch++) buf[o + ch] += PG[ch] * gl;\n    }\n  // Shadows of the two skeletons cast forward onto the ground.\n  for (const K of S.K)\n    for (let y = GROUND + 1; y \u003c GROUND + 6; y++)\n      for (let x = 0; x \u003c W; x++) if (abs(x + 0.5 - K.x[6]) \u003c (12 - (y - GROUND) * 1.2) * K.sc) for (let ch = 0; ch \u003c 3; ch++) buf[(y * W + x) * 3 + ch] *= 0.5;\n  for (let y = 114; y \u003c 127; y++)\n    for (let x = 24; x \u003c 41; x++) {\n      const dx = x + 0.5 - 32, dy = y + 0.5 - 121.2, o = (y * W + x) * 3;\n      const e = (dx / 7.4) ** 2 + (dy / 5) ** 2;\n      if (e \u003c 1) {\n        const rib = abs(abs(dx) - 3.4) \u003c 0.6 && e > 0.25, eye = dy > -3 && dy \u003c -0.6 && abs(abs(dx) - 3) \u003c 1.6 + (dy + 3) * 0.5, grin = dy > 0.8 && dy \u003c 2.8 - abs(dx) * 0.15 && abs(dx) \u003c 5 && !(abs(dx) % 2.5 \u003c 0.7 && dy \u003c 1.6);\n        if (eye || grin) put(buf, o, 255, 196 * fl + 30, 50 * fl);\n        else put(buf, o, rib ? 220 : 255, rib ? 84 : 118, rib ? 0 : 10);\n      } else if (e \u003c 1.35 && dy > -6) put(buf, o, buf[o] * 0.3, buf[o + 1] * 0.3, buf[o + 2] * 0.3);\n      if (abs(dx + 0.3) \u003c 1 && dy > -7.4 && dy \u003c -4.6) put(buf, o, 72, 150, 40);\n    }\n  // Bodies, skulls on necks, hands, skulls in the air.\n  for (const K of S.K) for (let i = 0; i \u003c 13; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  for (const Hd of S.hd) if (!Hd.fly) head(S, Hd);\n  for (const K of S.K) for (let i = 13; i \u003c 15; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  for (const Hd of S.hd) if (Hd.fly) head(S, Hd);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","curlicue":"// ===== Patternflow pattern =====\n// Title:   Curlicue\n// Family:  number\n// Idea:    The partial sums of the theta sum over -N \u003c= n \u003c= N, one unit step per n with step n turned by pi n^2 x, grow out from the middle of the panel in both directions into a lace of separate LEDs while the view zooms out for ever, and every level of the zoom brings the same curls back, because N steps of x trace the shape of N x steps of -1/x, turned 45 degrees and drawn 1/sqrt(x) times larger.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: curlicues and their renormalisation (Michael Berry and Jonathan Goldberg, 1988), approximate functional equation of the theta sum (G. H. Hardy and J. E. Littlewood, 1914), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Number=0..1, Steps=0..1\n//\n// Knob 1: Hue. Turns the colours of the path round the wheel. At 0 the oldest steps, in the middle, are deep blue, turning to cyan toward the two ends, where the newest steps are white; at 0.5 the old steps are yellow and the new ones red.\n// Knob 2: Speed. How fast the view zooms out. At 2 the picture shrinks to half its size every 4 seconds while the two ends add steps to keep the panel filled, and the first growth from one step to the full lace takes 1.2 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Number. Which x the sum is for, in five steps: at 0 the square root of 3, at 0.25 the golden ratio, at 0.5 the square root of 2, at 0.75 sqrt 26 - 5 = 1/(10 + 1/(10 + ...)), at 1 sqrt 101 - 10 = 1/(20 + 1/(20 + ...)). The first three grow a lace with hooked arms; the last two sit close to 1/10 and 1/20, so their paths run straight between curls and the curls read as Euler spirals. Each chain of renormalised numbers comes round after one or two levels, so the zoom never ends and never changes its kind.\n// Knob 4: Steps. How many steps each half of the path holds when a level begins. At 0.06 about 2,000, so the path is a lace of single LEDs; at 1 about 120, each step a dotted stroke several LEDs long, so the curls read as lines.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, sin, cos, log, exp, atan2, hypot, min, max, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The box the path is fitted into, and the most LEDs one step may span.\nconst BW = 62, BH = 126, SMAX = 9;\n// Story seconds at Speed 2: the size halves every ZOOM seconds; the first\n// growth from 1 step to the level's start takes INTRO seconds.\nconst ZOOM = 4, INTRO = 1.2;\n// Most partial sums a level may hold.\nconst CAP = 100000;\n\n// The five numbers on the knob, each a quadratic irrational, so its chain\n// of renormalised numbers comes round again after one or two levels:\n// the square root of 3 (2 - sqrt 3 = 0.268, which renormalises to itself),\n// the golden ratio (0.382 and 0.618 in turn), the square root of 2 (0.586\n// and 0.293), sqrt 26 - 5 = 1/(10 + 1/(10 + ...)) and sqrt 101 - 10 =\n// 1/(20 + 1/(20 + ...)), each its own mirror image one level down. The last\n// two sit close to 1/10 and 1/20, so their paths run straight for a while\n// between curls.\nconst STOPS = [sqrt(3), (1 + sqrt(5)) / 2, sqrt(2), sqrt(26) - 5, sqrt(101) - 10];\nconst mod2 = (v) => v - 2 * floor(v / 2);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), u = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? u : p, i === 1 || i === 2 ? v : i === 0 ? u : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? u : i === 5 ? q : p];\n}\n// Colour bands by age, from the middle out; the last one is the white ends.\nconst BANDS = 10;\n\n// Start the chain at the knob's number: x mod 2, folded into (0, 1]. A\n// number above 1 is drawn as the mirror image of 2 - x, the same sum conjugated.\nfunction begin(S, num) {\n  let x = mod2(STOPS[round(num * 4)]);\n  S.mirror = x > 1;\n  if (S.mirror) x = 2 - x;\n  S.xh = x;\n  S.orbit = [x];\n  S.filled = 0;\n  S.num = num;\n}\n\n// The partial sums S_k = sum of e^(i pi n^2 x) over 0 \u003c= n \u003c k, added as the\n// ends reach them. The path over -N..N is S_k - 1/2 and its negative.\nfunction fill(S, n) {\n  const re = S.re, im = S.im, x = S.xh;\n  n = min(n, CAP);\n  if (!S.filled) (re[0] = 0), (im[0] = 0);\n  let a = re[S.filled], b = im[S.filled];\n  for (let k = S.filled; k \u003c n; k++) {\n    const ph = PI * ((k * k * x) % 2);\n    a += cos(ph);\n    b += sin(ph);\n    re[k + 1] = a;\n    im[k + 1] = b;\n  }\n  S.filled = max(S.filled, n);\n}\n\n// One level deeper. Hardy and Littlewood: for 0 \u003c x \u003c= 1,\n//   S_n(x) = e^(i pi/4) x^(-1/2) S_(floor(n x) + 1)(-1/x) + O(x^(-1/2)),\n// and -1/x mod 2 folds into (0, 1] as y or as the mirror of 2 - y. So the n\n// steps on the panel are swapped for floor(n x) + 1 steps of the new number,\n// and the view is carried through the same turn and scale, so nothing moves.\nfunction deeper(S) {\n  const x = S.xh, N = S.N;\n  let y = mod2(-1 / x), flip = false;\n  if (y > 1) (y = 2 - y), (flip = true);\n  // A number that has come round before is set back to its first value, so\n  // rounding does not build up level after level and the chain repeats exactly.\n  for (const o of S.orbit) if (abs(y - o) \u003c 1e-9) y = o;\n  if (!S.orbit.includes(y)) S.orbit.push(y);\n  const oldRe = S.re, oldIm = S.im, n0 = min(floor(N), S.filled);\n  S.re = S.re2;\n  S.im = S.im2;\n  S.re2 = oldRe;\n  S.im2 = oldIm;\n  S.xh = y;\n  S.filled = 0;\n  fill(S, floor(N * x) + 2);\n  // The check: how far the old half path lies from the new one carried\n  // through the similarity, after the mean offset, against the path's size.\n  const ar = cos(PI / 4) / sqrt(x), ai = sin(PI / 4) / sqrt(x), sg = flip ? -1 : 1, stride = max(1, floor(n0 / 1500));\n  let dr = 0, di = 0, c = 0, gap = 0, size = 1;\n  for (let pass = 0; pass \u003c 2; pass++)\n    for (let n = 1; n \u003c= n0; n += stride) {\n      const m = floor(n * x) + 1, qr = S.re[m] - 0.5, qi = sg * S.im[m];\n      const u = oldRe[n] - 0.5 - (ar * qr - ai * qi), v = oldIm[n] - (ai * qr + ar * qi);\n      if (pass === 0) (dr += u), (di += v), c++;\n      else (gap = max(gap, hypot(u - dr, v - di))), (size = max(size, hypot(oldRe[n] - 0.5, oldIm[n])));\n      if (pass === 0 && n + stride > n0) (dr /= c), (di /= c);\n    }\n  S.gap = max(S.gap, gap / size);\n  S.offset = max(S.offset, hypot(dr, di));\n  S.levels++;\n  // Carry the view: screen = alpha w + centre, w the half path or its mirror.\n  const Ai = S.mirror ? -ai : ai;\n  for (const v of [S.view, S.goal]) [v.ar, v.ai] = [v.ar * ar - v.ai * Ai, v.ar * Ai + v.ai * ar];\n  S.mirror = S.mirror !== flip;\n  S.N = N * x;\n  S.L = log(S.N);\n}\n\n// Where the view wants to be: the long axis upright, the whole path in the\n// box. The path is symmetric about the middle of step 0, so that point is\n// always the middle of the panel and a half turn changes nothing.\nfunction aim(S) {\n  const n = min(floor(S.N), S.filled), re = S.re, im = S.im, sg = S.mirror ? -1 : 1, G = S.goal;\n  const stride = max(1, floor(n / 3000));\n  let sxx = 0, syy = 0, sxy = 0;\n  for (let i = 1; i \u003c= n; i += stride) {\n    const u = re[i] - 0.5, v = sg * im[i];\n    sxx += u * u;\n    syy += v * v;\n    sxy += u * v;\n  }\n  let ang = atan2(G.ai, G.ar);\n  const spread = sxx + syy, aniso = spread > 0 ? hypot(sxx - syy, 2 * sxy) / spread : 0;\n  if (aniso > 0.12 || n \u003c 40) {\n    const a = PI / 2 - 0.5 * atan2(2 * sxy, sxx - syy), da = a - ang;\n    ang += da - PI * round(da / PI);\n  }\n  const ca = cos(ang), sa = sin(ang);\n  let mu = 1e-6, mv = 1e-6;\n  for (let i = 1; i \u003c= n; i++) {\n    const u = re[i] - 0.5, v = sg * im[i];\n    mu = max(mu, abs(ca * u - sa * v));\n    mv = max(mv, abs(sa * u + ca * v));\n  }\n  const s = min(BW / (2 * mu), BH / (2 * mv), SMAX);\n  G.ar = s * ca;\n  G.ai = s * sa;\n}\n\nexport function setup(params) {\n  const S = {\n    re: new Float64Array(CAP + 2), im: new Float64Array(CAP + 2), re2: new Float64Array(CAP + 2), im2: new Float64Array(CAP + 2),\n    view: { ar: SMAX - 0.5, ai: 0.5 }, goal: { ar: SMAX - 0.5, ai: 0.5 },\n    hue: 0.5, speed: 1.5, n1: 2000.5, N: 1, L: 0, levels: 0, gap: 0, offset: 0, xh: 0.5, num: 0.5, mirror: false, filled: 0, orbit: [],\n    pal: new Uint8Array((BANDS + 2) * 3), idx: new Uint8Array(W * H), palHue: -1,\n  };\n  begin(S, 0);\n  params.s = S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // 2,400 steps a half at 0, about 2,000 at 0.06, 120 at 1.\n  S.n1 = 2400 * 0.05 ** cl(k[3], 0, 1);\n  const num = cl(k[2], 0, 1);\n  // A new number: the same number of steps of it, from its first level.\n  if (abs(num - S.num) > 1e-9) begin(S, num);\n  // Below the level's start the path grows fast, from 1 step to n1 in\n  // INTRO seconds; from there the zoom runs at its steady pace.\n  const g = (d * S.speed) / 2, ln1 = log(S.n1);\n  S.L = S.L \u003c ln1 ? min(ln1, S.L + (g * ln1) / INTRO) : S.L + (g * 2 * Math.LN2) / ZOOM;\n  S.N = exp(S.L);\n  // A chain that has not come round in 16 levels starts over.\n  if (S.orbit.length > 16) begin(S, S.num);\n  for (let guard = 0; guard \u003c 8 && S.N >= min(S.n1 / S.xh, CAP); guard++) deeper(S);\n  fill(S, floor(S.N) + 1);\n  aim(S);\n  // Ease the view toward its aim in angle and size; shrink fast, so the\n  // ends never leave the box, and grow slowly.\n  const V = S.view, G = S.goal;\n  const la = log(hypot(V.ar, V.ai)), lg = log(hypot(G.ar, G.ai)), es = 1 - exp(-d / (lg \u003c la ? 0.05 : 0.5));\n  const aa = atan2(V.ai, V.ar), ag = atan2(G.ai, G.ar), da = ag - aa, ea = 1 - exp(-d / 0.6);\n  const a = aa + (da - PI * round(da / PI)) * ea, ca = cos(a), sa = sin(a);\n  // While the angle is still turning, the size the aim chose may not fit\n  // the angle the view stands at: shrink to fit that too.\n  const n = min(floor(S.N), S.filled), sg = S.mirror ? -1 : 1;\n  let mu = 1e-6, mv = 1e-6;\n  for (let i = 1; i \u003c= n; i++) {\n    const u = S.re[i] - 0.5, v = sg * S.im[i];\n    mu = max(mu, abs(ca * u - sa * v));\n    mv = max(mv, abs(sa * u + ca * v));\n  }\n  const r = min(exp(la + (lg - la) * es), BW / (2 * mu), BH / (2 * mv));\n  V.ar = r * ca;\n  V.ai = r * sa;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const pal = S.pal, idx = S.idx;\n  if (S.palHue !== S.hue) {\n    S.palHue = S.hue;\n    // Deep blue for the oldest steps, turning to cyan for the newest. Every\n    // colour has a channel at 255, so the old blue reads dim on the panel\n    // while each LED of the lace stands at full level.\n    for (let b = 0; b \u003c BANDS; b++) {\n      const q = b / (BANDS - 1), c = hsv(0.66 - 0.18 * q + S.hue, 1 - 0.25 * q, 1);\n      for (let j = 0; j \u003c 3; j++) pal[(b + 1) * 3 + j] = round(255 * c[j]);\n    }\n    for (let j = 0; j \u003c 3; j++) pal[(BANDS + 1) * 3 + j] = 255;\n  }\n  idx.fill(0);\n  const n = min(floor(S.N), S.filled), re = S.re, im = S.im, sg = S.mirror ? -1 : 1;\n  const ar = S.view.ar, ai = S.view.ai, step = hypot(ar, ai), head = n - max(2, floor(n * 0.012));\n  const put = (X, Y, c) => {\n    // The nearest LED of one checkerboard colour, so lit LEDs never touch\n    // side to side and each step stands as its own point.\n    const a = round((X + Y - 1) / 2), b = round((X - Y) / 2), u = a + b, v = a - b;\n    if (u >= 0 && u \u003c W && v >= 0 && v \u003c H) idx[v * W + u] = c;\n    // The newer half of the path is drawn with a nib two LEDs long on the\n    // diagonal, so the young curls stand bolder than the old lace inside.\n    if (c > BANDS / 2 && u + 1 \u003c W && v + 1 \u003c H && u >= -1 && v >= -1) idx[(v + 1) * W + u + 1] = c;\n  };\n  let px = -ar * 0.5, py = -ai * 0.5;\n  for (let i = 1; i \u003c= n; i++) {\n    const u = re[i] - 0.5, v = sg * im[i], X = ar * u - ai * v, Y = ai * u + ar * v;\n    const c = i > head ? BANDS + 1 : 1 + floor((i / (n + 1)) * BANDS);\n    // Long steps, while the path is young or the Steps knob is high, are\n    // drawn as dotted strokes.\n    if (step > 1.6) {\n      const k = Math.ceil(step / 0.8);\n      for (let j = 1; j \u003c k; j++) {\n        const sx = px + ((X - px) * j) / k, sy = py + ((Y - py) * j) / k;\n        put(32 + sx, 64 + sy, c);\n        put(32 - sx, 64 - sy, c);\n      }\n    }\n    put(32 + X, 64 + Y, c);\n    put(32 - X, 64 - Y, c);\n    px = X;\n    py = Y;\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const o = idx[i] * 3;\n    display.setPixel(i % W, floor(i / W), pal[o], pal[o + 1], pal[o + 2]);\n  }\n}\n","durer-unfolding":"// ===== Patternflow pattern =====\n// Title:   Dürer's Unfolding\n// Family:  space\n// Idea:    A convex solid, its faces hatched like an engraving, lies flat as one net up the panel, folds shut hinge by hinge along a spanning tree of its edges, turns in the dark, shrinks away and comes back as the next solid, which turns and unfolds along its own tree into a new net that never overlaps itself.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dürer's unfolding problem (Albrecht Dürer, 1525; Geoffrey Shephard, 1975), edge unfoldings of the Platonic solids never overlap (Takashi Horiyama and Wataru Shoji, 2011), uniform spanning trees by loop-erased random walk (David Wilson, 1996), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Solid=0..5, Tree=0..1\n//\n// Knob 1: Hue. Each face is coloured by how many hinges lie between it and the root face the net is folded round: at 0 the root is azure and the faces furthest out pink, through blue and violet; turning it carries that third of the wheel round together, so at 0.5 the root is red orange and the far faces green. A face that comes round to orange or yellow keeps at least 0.8 of full value, so it never dims to brown. The plain backs of the faces, seen while the net folds, are a dim grey of the face's own colour, cross-hatched.\n// Knob 2: Speed. At 2 one solid's story takes 10.6 seconds: it grows out of a point in 0.4, turns for 0.9, unfolds hinge by hinge in 3, lies flat swaying for 2.4, folds shut in 2.6, turns for 0.9 and shrinks away in 0.4. A fresh start opens with the last hinges opening and folds at 3.4 seconds. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Solid. Which solid the round starts from, and the five after it follow in turn: 0 cube (6 squares, edges 26 LEDs long), 1 octahedron (8 triangles, 36), 2 dodecahedron (12 pentagons, 15), 3 icosahedron (20 triangles, 23), 4 truncated octahedron (8 hexagons and 6 squares, 13), 5 cuboctahedron (8 triangles and 6 squares, 21). Each net is scaled to fill a 60 by 124 LED box, so the edge length depends on the solid and the tree.\n// Knob 4: Tree. Which spanning tree of hinges the solid unfolds along, out of 8 different nets kept for each solid from 160 uniform random spanning trees: at 0 the net that fills the most of the box (the cube's covers 51% of the panel), at 1 the eighth (the cube's covers 32%). Every later round of the six solids takes the next tree.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, acos, atan2, hypot, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// How near a hue is to orange and yellow, 0 to 1.\nconst warm = (h) => max(0, 1 - abs(h - floor(h) - 0.11) / 0.13);\nconst sub = (p, q) => [p[0] - q[0], p[1] - q[1], p[2] - q[2]];\nconst dot = (p, q) => p[0] * q[0] + p[1] * q[1] + p[2] * q[2];\nconst crs = (p, q) => [p[1] * q[2] - p[2] * q[1], p[2] * q[0] - p[0] * q[2], p[0] * q[1] - p[1] * q[0]];\nconst nrm = (p) => {\n  const l = hypot(p[0], p[1], p[2]) || 1;\n  return [p[0] / l, p[1] / l, p[2] / l];\n};\n\n// The solids as vertex sets: every signed permutation of a triple, or only\n// the cyclic ones.\nfunction signed(b, all) {\n  const out = [], seen = new Set();\n  const ps = all ? [[0, 1, 2], [1, 2, 0], [2, 0, 1], [0, 2, 1], [2, 1, 0], [1, 0, 2]] : [[0, 1, 2], [1, 2, 0], [2, 0, 1]];\n  for (const p of ps)\n    for (let s = 0; s \u003c 8; s++) {\n      const v = p.map((i, k) => ((s >> k) & 1 ? -b[i] : b[i]) + 0);\n      const key = v.map((x) => x.toFixed(4)).join();\n      if (!seen.has(key)) seen.add(key), out.push(v);\n    }\n  return out;\n}\nconst PHI = (1 + sqrt(5)) / 2;\nconst SOLIDS = [\n  () => signed([1, 1, 1], 1),\n  () => signed([1, 0, 0], 1),\n  () => signed([1, 1, 1], 1).concat(signed([0, 1 / PHI, PHI], 0)),\n  () => signed([0, 1, PHI], 0),\n  () => signed([0, 1, 2], 1),\n  () => signed([1, 1, 0], 1),\n];\n\n// The faces of the hull: every plane through three vertices with all the\n// others on one side, its vertices ordered counter-clockwise from outside.\nfunction hull(V) {\n  const F = [], seen = new Set(), n = V.length;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++)\n      for (let k = j + 1; k \u003c n; k++) {\n        let c = crs(sub(V[j], V[i]), sub(V[k], V[i]));\n        if (hypot(c[0], c[1], c[2]) \u003c 1e-9) continue;\n        c = nrm(c);\n        const d = dot(c, V[i]), on = [];\n        let pos = 0, neg = 0;\n        for (let m = 0; m \u003c n; m++) {\n          const s = dot(c, V[m]) - d;\n          if (s > 1e-6) pos++;\n          else if (s \u003c -1e-6) neg++;\n          else on.push(m);\n        }\n        if (pos && neg) continue;\n        if (pos) c = [-c[0], -c[1], -c[2]];\n        const key = on.join();\n        if (seen.has(key)) continue;\n        seen.add(key);\n        const ce = [0, 1, 2].map((a) => on.reduce((s, m) => s + V[m][a], 0) / on.length);\n        const e1 = nrm(sub(V[on[0]], ce)), e2 = crs(c, e1);\n        const ang = (m) => {\n          const p = sub(V[m], ce);\n          return atan2(dot(p, e2), dot(p, e1));\n        };\n        on.sort((a, b) => ang(a) - ang(b));\n        F.push({ v: on, n: c, c: ce });\n      }\n  return F;\n}\n\n// A uniform random spanning tree of the face graph, by loop-erased random\n// walks (Wilson's algorithm): parent of each face, -1 at the root.\nfunction wilson(adj) {\n  const n = adj.length, inT = new Uint8Array(n), nx = new Int32Array(n).fill(-1);\n  inT[0] = 1;\n  for (let i = 1; i \u003c n; i++) {\n    let u = i;\n    while (!inT[u]) u = nx[u] = adj[u][floor(Math.random() * adj[u].length)];\n    for (u = i; !inT[u]; u = nx[u]) inT[u] = 1;\n  }\n  nx[0] = -1;\n  return nx;\n}\n\n// Lay a tree out flat. From the root outward, each face is turned about its\n// hinge into its parent's plane, on the far side of the hinge. Returns each\n// face's polygon in the root's plane, the BFS order, parents and depths.\nfunction layout(V, F, adj, par, root) {\n  const n = F.length, kids = F.map(() => []);\n  for (let f = 0; f \u003c n; f++) if (par[f] >= 0) kids[par[f]].push(f), kids[f].push(par[f]);\n  const P = new Int32Array(n).fill(-2), dep = new Int32Array(n), order = [root];\n  P[root] = -1;\n  for (let q = 0; q \u003c order.length; q++)\n    for (const g of kids[order[q]]) if (P[g] === -2) (P[g] = order[q]), (dep[g] = dep[order[q]] + 1), order.push(g);\n  const pos = new Array(n), f0 = F[root], e1 = nrm(sub(V[f0.v[0]], f0.c)), e2 = crs(f0.n, e1);\n  pos[root] = f0.v.map((m) => {\n    const p = sub(V[m], f0.c);\n    return [dot(p, e1), dot(p, e2)];\n  });\n  for (const f of order.slice(1)) {\n    const p = P[f], pf = F[p], ff = F[f], [a, b] = ff.v.filter((m) => pf.v.includes(m));\n    const pa = pos[p][pf.v.indexOf(a)], pb = pos[p][pf.v.indexOf(b)], ux = pb[0] - pa[0], uy = pb[1] - pa[1], ul = hypot(ux, uy);\n    let wx = -uy / ul, wy = ux / ul, cx = 0, cy = 0;\n    for (const q of pos[p]) (cx += q[0]), (cy += q[1]);\n    if ((cx / pos[p].length - pa[0]) * wx + (cy / pos[p].length - pa[1]) * wy > 0) (wx = -wx), (wy = -wy);\n    const u = nrm(sub(V[b], V[a])), r = sub(ff.c, V[a]), t = dot(r, u), w = nrm([r[0] - t * u[0], r[1] - t * u[1], r[2] - t * u[2]]);\n    pos[f] = ff.v.map((m) => {\n      const q = sub(V[m], V[a]), s = dot(q, u), h = dot(q, w);\n      return [pa[0] + (s * ux) / ul + h * wx, pa[1] + (s * uy) / ul + h * wy];\n    });\n  }\n  return { pos, order, P, dep, e1, e2 };\n}\n\n// The turn of the net and the LEDs per unit that fit it into the box: K\n// turns tried over half a circle, then a finer look round the best.\nconst BOXW = 60, BOXH = 124;\nfunction fitNet(pos, K = 48) {\n  let best = { s: 0 };\n  const tryA = (a) => {\n    const c = cos(a), s = sin(a);\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (const poly of pos)\n      for (const [x, y] of poly) {\n        const X = c * x - s * y, Y = s * x + c * y;\n        (x0 = min(x0, X)), (x1 = max(x1, X)), (y0 = min(y0, Y)), (y1 = max(y1, Y));\n      }\n    const sc = min(BOXW / (x1 - x0), BOXH / (y1 - y0));\n    if (sc > best.s) best = { s: sc, a, cx: (x0 + x1) / 2, cy: (y0 + y1) / 2 };\n  };\n  for (let k = 0; k \u003c K; k++) tryA((k / K) * PI);\n  const a0 = best.a;\n  for (let k = -6; k \u003c= 6; k++) tryA(a0 + (k / 6) * (PI / K));\n  return best;\n}\n\n// Two convex polygons of the net overlap when no edge of either separates\n// them by less than a hair: neighbours along a hinge only touch. Run on\n// 20,000 uniform random trees of each of the six solids it found no net\n// that overlaps, as Horiyama and Shoji proved for the Platonic ones; on the\n// truncated icosahedron it finds about one in a hundred (47 and 51 of\n// 5,000 in two runs), so it does see an overlap where there is one.\n// The corners round each solid vertex in those nets leave gaps that add up\n// to 720 degrees, Descartes' total defect, within 8e-13 degrees.\nfunction overlap(A, B) {\n  for (const poly of [A, B])\n    for (let i = 0; i \u003c poly.length; i++) {\n      const p = poly[i], q = poly[(i + 1) % poly.length], ax = q[1] - p[1], ay = p[0] - q[0];\n      let a0 = 1e9, a1 = -1e9, b0 = 1e9, b1 = -1e9;\n      for (const v of A) (a0 = min(a0, v[0] * ax + v[1] * ay)), (a1 = max(a1, v[0] * ax + v[1] * ay));\n      for (const v of B) (b0 = min(b0, v[0] * ax + v[1] * ay)), (b1 = max(b1, v[0] * ax + v[1] * ay));\n      if (min(a1, b1) - max(a0, b0) \u003c 1e-6 * hypot(ax, ay)) return false;\n    }\n  return true;\n}\n\n// Trees tried per solid and kept per solid.\nconst TRIES = 160, KEEP = 8;\nfunction buildSolid(S, k) {\n  const V = SOLIDS[k](), F = hull(V), n = F.length, em = new Map();\n  F.forEach((f, fi) =>\n    f.v.forEach((a, j) => {\n      const b = f.v[(j + 1) % f.v.length], key = min(a, b) * 64 + max(a, b);\n      if (!em.has(key)) em.set(key, []);\n      em.get(key).push(fi);\n    }),\n  );\n  const adj = F.map(() => []);\n  for (const [p, q] of em.values()) adj[p].push(q), adj[q].push(p);\n  let area = 0;\n  for (const f of F)\n    for (let j = 1; j + 1 \u003c f.v.length; j++) {\n      const c = crs(sub(V[f.v[j]], V[f.v[0]]), sub(V[f.v[j + 1]], V[f.v[0]]));\n      area += hypot(c[0], c[1], c[2]) / 2;\n    }\n  // Sample trees, drop nets already seen (same face-centre distances from\n  // the middle), rank the rest by how much of the box a rough fit fills,\n  // and keep the best that do not overlap.\n  const cand = [], sigs = new Set();\n  for (let t = 0; t \u003c TRIES; t++) {\n    const par = wilson(adj), L = layout(V, F, adj, par, 0), fit = fitNet(L.pos, 12);\n    const cs = L.pos.map((p) => [p.reduce((s, q) => s + q[0], 0) / p.length, p.reduce((s, q) => s + q[1], 0) / p.length]);\n    const gx = cs.reduce((s, q) => s + q[0], 0) / n, gy = cs.reduce((s, q) => s + q[1], 0) / n;\n    const sig = cs.map((q) => hypot(q[0] - gx, q[1] - gy).toFixed(3)).sort().join();\n    if (sigs.has(sig)) continue;\n    sigs.add(sig);\n    cand.push({ par, L, cov: (area * fit.s * fit.s) / N });\n  }\n  cand.sort((a, b) => b.cov - a.cov);\n  const trees = [];\n  for (const c of cand) {\n    if (trees.length === KEEP) break;\n    let bad = false;\n    for (let i = 0; i \u003c n && !bad; i++) for (let j = i + 1; j \u003c n && !bad; j++) bad = overlap(c.L.pos[i], c.L.pos[j]);\n    S.tested++;\n    if (bad) {\n      S.overlaps++;\n      continue;\n    }\n    c.fit = fitNet(c.L.pos);\n    c.cov = (area * c.fit.s * c.fit.s) / N;\n    trees.push(makeTree(V, F, adj, c));\n  }\n  trees.sort((a, b) => b.cov - a.cov);\n  return { V, F, n, trees };\n}\n\n// A kept tree, rooted at the face nearest the middle of its net, with what\n// the fold needs: each face's hinge, the angle that lays it flat, and the\n// turn from solid to screen that stands the net up the panel.\nfunction makeTree(V, F, adj, c) {\n  const n = F.length, { fit } = c;\n  let root = 0, bd = 1e9;\n  const ca = cos(fit.a), sa = sin(fit.a);\n  c.L.pos.forEach((p, f) => {\n    let x = 0, y = 0;\n    for (const q of p) (x += q[0] / p.length), (y += q[1] / p.length);\n    const d = hypot(ca * x - sa * y - fit.cx, sa * x + ca * y - fit.cy);\n    if (d \u003c bd) (bd = d), (root = f);\n  });\n  const L = layout(V, F, adj, c.par, root), f2 = fitNet(L.pos), s = f2.s, c2 = cos(f2.a), s2 = sin(f2.a);\n  const f0 = F[root];\n  // Solid to screen: x and y along the net's turned frame, z out of the root face.\n  const Q = [0, 1, 2].map((r) => [0, 1, 2].map((k) => s * (r === 0 ? c2 * L.e1[k] - s2 * L.e2[k] : r === 1 ? s2 * L.e1[k] + c2 * L.e2[k] : f0.n[k])));\n  const o = Q.map((row, r) => -dot(row, f0.c) - (r === 0 ? f2.cx * s : r === 1 ? f2.cy * s : 0));\n  const ax = [], an = [], phi = new Float64Array(n), hv = [];\n  let maxD = 0;\n  for (let f = 0; f \u003c n; f++) {\n    maxD = max(maxD, L.dep[f]);\n    const ff = F[f];\n    let a, b;\n    if (f === root) (a = ff.v[0]), (b = ff.v[1]);\n    else [a, b] = ff.v.filter((m) => F[L.P[f]].v.includes(m));\n    const u = nrm(sub(V[b], V[a]));\n    ax[f] = [V[a], u];\n    if (f !== root) {\n      const np = F[L.P[f]].n, th = acos(cl(dot(ff.n, np), -1, 1)), r = rot(u, th), m = mul(r, ff.n);\n      phi[f] = dot(m, np) > 0.999 ? th : -th;\n    }\n    // The hatching is laid on each face from its hinge: each corner's\n    // distance from the hinge and along it, in LEDs (kept positive).\n    hv[f] = ff.v.map((m) => {\n      const q = sub(V[m], V[a]), t = dot(q, u);\n      return [s * hypot(q[0] - t * u[0], q[1] - t * u[1], q[2] - t * u[2]), s * t + 64];\n    });\n    an[f] = ff.n;\n  }\n  // Shut, the solid is brought nearer until it is 58 LEDs across.\n  const rc = max(...V.map((v) => hypot(v[0], v[1], v[2])));\n  return { root, order: L.order, P: L.P, dep: L.dep, maxD, Q, o, ax, an, phi, hv, s, cov: c.cov, pos: L.pos, zoom: min(1.8, 29 / (rc * s)) };\n}\n\n// Rotation matrices, row-major 3x3 as nested arrays.\nfunction rot(u, th) {\n  const c = cos(th), s = sin(th), t = 1 - c, [x, y, z] = u;\n  return [\n    [c + t * x * x, t * x * y - s * z, t * x * z + s * y],\n    [t * x * y + s * z, c + t * y * y, t * y * z - s * x],\n    [t * x * z - s * y, t * y * z + s * x, c + t * z * z],\n  ];\n}\nconst mul = (m, v) => [dot(m[0], v), dot(m[1], v), dot(m[2], v)];\nconst mm = (a, b) => a.map((row) => [0, 1, 2].map((k) => row[0] * b[0][k] + row[1] * b[1][k] + row[2] * b[2][k]));\n\n// The story of one solid, in seconds at Speed 2: grow out of a point, turn,\n// unfold, lie flat, fold, turn, shrink away. A fresh start opens on the net.\nconst GROW = 0.4, TURN = 0.9, UNF = 3, HOLD = 2.4, FOLD = 2.6, SHR = 0.4;\nconst CYC = GROW + TURN + UNF + HOLD + FOLD + TURN + SHR;\nconst T0 = GROW + TURN + UNF + HOLD - 3.4;\n// Each hinge swings over this share of the unfolding, the last starting at its end.\nconst SWING = 0.4;\n// The camera's distance in LEDs, the light (a unit vector toward it), and\n// the hatching: lines 1 LED wide at 45 degrees to each face's hinge, every\n// 2.1 LEDs, at HD of the face's colour, crossed at right angles where a face\n// turns from the light and on the plain backs. The map places this pattern\n// by the hatching: with no lines the window read detail 0.039; lines every\n// 2.8 LEDs along the hinge at 0.4 gave 0.071, and at 45 degrees with the net\n// held longer 0.122. Drift comes from the dark moment between two solids, so\n// it is the flat net's mean level: 0.351 at HD 0.4, 0.365 at 0.46.\nconst CAM = 170, LIGHT = nrm([-0.35, 0.45, 0.82]), HP = 3, HD = 0.46;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0.5, speed: 2, solidK: 0.5, treeK: 0.06, tau: T0,\n    solids: [], tested: 0, overlaps: 0,\n    zb: new Float32Array(N), id: new Int16Array(N), hb: new Float32Array(N), hc: new Float32Array(N),\n    cur: null, tr: null,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.solidK = cl(k[2], 0, 5);\n  S.treeK = cl(k[3], 0, 1);\n  S.tau += (d * S.speed) / 2;\n  const cyc = floor(S.tau / CYC), t = S.tau - cyc * CYC;\n  const si = (floor(S.solidK + 0.5) + cyc) % 6;\n  if (!S.solids[si]) S.solids[si] = buildSolid(S, si);\n  const sol = S.solids[si], tr = sol.trees[(min(KEEP - 1, floor(S.treeK * KEEP)) + floor(cyc / 6)) % sol.trees.length];\n  S.cur = sol;\n  S.tr = tr;\n  // How open the net is, 0 shut to 1 flat, its scale, and the turn.\n  let open = 0, g = 1;\n  const t1 = GROW + TURN, t2 = t1 + UNF, t3 = t2 + HOLD, t4 = t3 + FOLD, t5 = t4 + TURN;\n  if (t \u003c GROW) g = ease(t / GROW);\n  else if (t \u003c t1) open = 0;\n  else if (t \u003c t2) open = (t - t1) / UNF;\n  else if (t \u003c t3) open = 1;\n  else if (t \u003c t4) open = 1 - (t - t3) / FOLD;\n  else if (t >= t5) g = 1 - ease((t - t5) / SHR);\n  // The turn slows to rest as the net opens and picks up as it shuts.\n  const inEnd = t1 + 0.6 * UNF, outStart = t3 + 0.4 * FOLD;\n  let th = 0;\n  if (t \u003c inEnd) th = 5.6 * (1 - t / inEnd) ** 2;\n  else if (t > outStart) th = -5.6 * ((t - outStart) / (CYC - outStart)) ** 2;\n  S.turn = rot(nrm([0.45 * sin(cyc * 2.3), 1, 0.45 * cos(cyc * 2.3)]), th);\n  // Lying flat, the net sways a little about the panel's long axis.\n  if (t >= t2 && t \u003c t3) S.turn = rot([0, 1, 0], 0.2 * sin((PI * (t - t2)) / HOLD) * sin((2 * PI * (t - t2)) / HOLD));\n  S.g = g;\n  // Each hinge in BFS order swings in its own window of the unfolding.\n  const n = sol.n, nh = n - 1, ang = new Float64Array(n);\n  let sum = 0, tot = 0;\n  for (let q = 1; q \u003c n; q++) {\n    const f = tr.order[q], st = nh > 1 ? ((q - 1) / (nh - 1)) * (1 - SWING) : 0, o = ease((open - st) / SWING);\n    ang[f] = o * tr.phi[f];\n    sum += o * abs(tr.phi[f]);\n    tot += abs(tr.phi[f]);\n  }\n  S.ang = ang;\n  S.shut = 1 - sum / tot;\n  // Shut, it is seen from a little above, so a turn always shows its top.\n  S.turn = mm(rot([1, 0, 0], 0.42 * S.shut), S.turn);\n}\n\n// Fill one screen triangle, nearest wins: q is 1 over depth, and the two\n// hatching coordinates are carried perspective-correct as h q.\nfunction tri(S, A, B, C, f) {\n  const area = (B[0] - A[0]) * (C[1] - A[1]) - (B[1] - A[1]) * (C[0] - A[0]);\n  if (abs(area) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(A[0], B[0], C[0]))), x1 = min(W - 1, floor(max(A[0], B[0], C[0])));\n  const y0 = max(0, floor(min(A[1], B[1], C[1]))), y1 = min(H - 1, floor(max(A[1], B[1], C[1])));\n  const { zb, id, hb, hc } = S;\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const w0 = ((B[0] - px) * (C[1] - py) - (B[1] - py) * (C[0] - px)) / area, w1 = ((C[0] - px) * (A[1] - py) - (C[1] - py) * (A[0] - px)) / area, w2 = 1 - w0 - w1;\n      if (w0 \u003c 0 || w1 \u003c 0 || w2 \u003c 0) continue;\n      const q = w0 * A[2] + w1 * B[2] + w2 * C[2], i = y * W + x;\n      if (q \u003c= zb[i]) continue;\n      zb[i] = q;\n      id[i] = f;\n      hb[i] = (w0 * A[3] * A[2] + w1 * B[3] * B[2] + w2 * C[3] * C[2]) / q;\n      hc[i] = (w0 * A[4] * A[2] + w1 * B[4] * B[2] + w2 * C[4] * C[2]) / q;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.tr) return;\n  const { cur: sol, tr, zb, id, hb, hc, ang, turn: R, g } = S;\n  const { V, F, n } = sol, { Q, o, order, P, ax, an, hv } = tr;\n  zb.fill(0);\n  id.fill(-1);\n  // Each face's motion from the shut solid: its parent's, then its own\n  // swing about its hinge, in BFS order from the root.\n  const MR = new Array(n), MT = new Array(n), col = new Array(n), side = new Int8Array(n), cross = new Uint8Array(n);\n  const sh = S.shut, cxv = o[0] * sh, cyv = o[1] * sh, czv = o[2] * sh, gz = g * (1 + (tr.zoom - 1) * sh);\n  for (const f of order) {\n    if (f === tr.root) (MR[f] = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]), (MT[f] = [0, 0, 0]);\n    else {\n      const p = P[f], [a, u] = ax[f], r = rot(u, ang[f]), ra = mul(r, a), pr = MR[p];\n      MR[f] = mm(pr, r);\n      const v = mul(pr, sub(a, ra));\n      MT[f] = [v[0] + MT[p][0], v[1] + MT[p][1], v[2] + MT[p][2]];\n    }\n    // Corners to the screen: solid, fold, stand up, centre, turn, scale, project.\n    const ff = F[f], pts = [];\n    for (let j = 0; j \u003c ff.v.length; j++) {\n      const p0 = mul(MR[f], V[ff.v[j]]), p1 = [p0[0] + MT[f][0], p0[1] + MT[f][1], p0[2] + MT[f][2]];\n      const v = [dot(Q[0], p1) + o[0] - cxv, dot(Q[1], p1) + o[1] - cyv, dot(Q[2], p1) + o[2] - czv], w = mul(R, v);\n      const q = 1 / (CAM - gz * w[2]);\n      pts.push([32 + CAM * gz * w[0] * q, 64 - CAM * gz * w[1] * q, q, hv[f][j][0], hv[f][j][1]]);\n    }\n    let a2 = 0;\n    for (let j = 0; j \u003c pts.length; j++) {\n      const p = pts[j], q = pts[(j + 1) % pts.length];\n      a2 += p[0] * q[1] - q[0] * p[1];\n    }\n    side[f] = a2 \u003c 0 ? 1 : 0;\n    for (let j = 1; j + 1 \u003c pts.length; j++) tri(S, pts[0], pts[j], pts[j + 1], f);\n    // Light on the face, in five steps.\n    const nn = mul(R, mul(Q, mul(MR[f], an[f]))), nl = hypot(nn[0], nn[1], nn[2]);\n    const lit = round(cl(0.3 + 0.85 * (dot(nn, LIGHT) / nl) * (side[f] ? 1 : -1), 0.3, 1) * 5) / 5;\n    const hue = 0.55 + S.hue + (0.32 * tr.dep[f]) / max(1, tr.maxD), wm = warm(hue);\n    col[f] = side[f] ? hsv(hue, 0.72, max(lit, 0.4 + 0.4 * wm)) : hsv(hue, 0.2, 0.4);\n    cross[f] = !side[f] || lit \u003c 0.8 ? 1 : 0;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const f = id[i], x = i % W, y = (i - x) / W;\n    let r = 0, gg = 0, b = 0;\n    if (f >= 0) {\n      const c = col[f], fr = x + 1 \u003c W ? id[i + 1] : -1, fd = y + 1 \u003c H ? id[i + W] : -1;\n      // An LED whose right or lower neighbour is another face is a dark seam.\n      let m = 1;\n      if ((fr >= 0 && fr !== f) || (fd >= 0 && fd !== f)) m = 0.08;\n      else if ((hb[i] + hc[i]) % HP \u003c 1.41 || (cross[f] && (hb[i] - hc[i] + 999) % HP \u003c 1.41)) m = HD;\n      (r = c[0] * m), (gg = c[1] * m), (b = c[2] * m);\n    }\n    display.setPixel(x, y, (255 * r) | 0, (255 * gg) | 0, (255 * b) | 0);\n  }\n}\n","gargoyle":"// ===== Patternflow pattern =====\n// Title:   Gargoyle\n// Family:  halloween\n// Idea:    A stone gargoyle juts from a cathedral ledge into a night storm, rain slanting across bruised purple clouds, and pours the gutter's water from its open jaws in a long arc that falls the whole height of the panel into a splashing puddle; every few seconds lightning flashes behind the spires, throws the stone into black silhouette with a bright rim, and leaves the gargoyle's eyes glowing poison green.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Lightning=0..1\n//\n// Knob 1: Hue. The storm's tint, kept to the cool side so the dark sky never reads brown: bruised violet at 0, blue at 0.25, teal at 0.5, sea green at 0.75 and a sickly green at 1. The stone takes a little of it; the water, the stained glass and the green eyes stay as they are.\n// Knob 2: Speed. At 2 a parcel of water takes 1.2 seconds from the jaws to the puddle and a raindrop crosses the panel in 0.8; at 0.2 the water hangs ten times slower, at 3 it falls half as fast again. The clouds scud on the same clock, and the gaps between strikes stretch up to 1.6 times at 0.2 and shrink by a fifth at 3. A flash always lasts the same half second.\n// Knob 3: Rain. At 0 a steady rain of 90 drops and a stream three LEDs thick that frays into drops on the way down; at 1 a downpour of 280 drops slanting harder, and a gush four LEDs thick at the jaws, thrown 5 LEDs further, that frays to eight and splashes twice as high.\n// Knob 4: Lightning. The first strike always comes 1.5 seconds after the start. Then at 0 one every 4.5 seconds on average, a bolt with at most one branch; at the opening 0.06 one every 4.3; at 1 one every 0.9 seconds, brighter, with up to five branches and a third return stroke. Each strike leaves the eyes glowing green for about 2.5 seconds.\n// Buttons: any button calls a strike at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst q20 = (v) => floor(v * 20) / 20;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// A fixed generator for the stonework, so the cathedral never changes;\n// Math.random is left for the weather.\nfunction prng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n// Smooth value noise on a 16 x 16 lattice that wraps, for the clouds.\nconst LAT = new Float32Array(256);\n{\n  const r = prng(11);\n  for (let i = 0; i \u003c 256; i++) LAT[i] = r();\n}\nfunction noise(x, y) {\n  const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi, u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);\n  const a = LAT[(yi & 15) * 16 + (xi & 15)], b = LAT[(yi & 15) * 16 + ((xi + 1) & 15)];\n  const c = LAT[((yi + 1) & 15) * 16 + (xi & 15)], d = LAT[((yi + 1) & 15) * 16 + ((xi + 1) & 15)];\n  return mix(mix(a, b, u), mix(c, d, u), v);\n}\n\n// What each LED is: sky, the far tower, a near pinnacle, the near wall and\n// ledge, the gargoyle, its open mouth, the street, the puddle, stained glass.\nconst SKY = 0, FAR = 1, PIN = 2, WALL = 3, GARG = 4, MOUTH = 5, STREET = 6, POOL = 7, GLASS = 8;\n// The water leaves the jaws here; the street's top row; the puddle.\nconst MX = 34.5, MY = 25, GROUND = 120, PX = 51, PY = 123.5, PRX = 13, PRY = 3.6;\n// The eye, two LEDs on the head.\nconst EYE = [20 * W + 29, 20 * W + 30];\n// Water: gravity and the jet's speed out of the jaws at Speed 2, in LEDs.\nconst G = 150, VX = 14, VY = -6, WIND = 3;\n// Raindrops on the panel at Rain 0 and at 1, and their fall in LEDs a second.\nconst RAIN0 = 90, RAIN1 = 280, FALL = 165;\n// Where a new drop starts: far enough left that its slant brings it in.\nconst spawnX = (vx) => -((vx / FALL) * H) + (W + (vx / FALL) * H) * Math.random();\n\nconst inEl = (x, y, cx, cy, rx, ry) => ((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2 \u003c 1;\nfunction inCap(x, y, ax, ay, bx, by, r) {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return hypot(x - ax - t * dx, y - ay - t * dy) \u003c r;\n}\nfunction inPoly(x, y, P) {\n  let c = false;\n  for (let i = 0, j = P.length - 2; i \u003c P.length; j = i, i += 2)\n    if (P[i + 1] > y !== P[j + 1] > y && x \u003c ((P[j] - P[i]) * (y - P[i + 1])) / (P[j + 1] - P[i + 1]) + P[i]) c = !c;\n  return c;\n}\n// The gargoyle, crouched on the ledge facing right: haunch, back, chest,\n// neck, head, snout and jaw, horn and ear, legs, and a folded bat wing.\nconst WING = [17, 24.5, 14, 19, 10.5, 13.5, 10, 18, 6.8, 14.5, 6, 19.5, 2.6, 17.5, 3.4, 24, 8, 27.5];\nfunction gargoyle(x, y) {\n  if (inPoly(x, y, [27.4, 24.3, 34.8, 23.7, 34.3, 26.1, 27.6, 25.7])) return MOUTH;\n  const body =\n    inEl(x, y, 9, 31.5, 7.5, 6.5) || inCap(x, y, 9, 28, 20, 26.5, 5) || inEl(x, y, 21, 29.5, 4, 5) ||\n    inCap(x, y, 22, 26, 26.5, 22.5, 3.3) || inEl(x, y, 28, 21.5, 4.2, 3.6) || inCap(x, y, 29, 21.6, 34.2, 22.6, 1.7) ||\n    inCap(x, y, 27.5, 26.4, 32.8, 27.2, 1.2) || inPoly(x, y, [25.2, 19.5, 27.6, 18.6, 22, 11.5]) || inPoly(x, y, [29, 18.8, 31, 19.2, 31.6, 14.6]) ||\n    inCap(x, y, 21.5, 32, 22.5, 37, 2.1) || inEl(x, y, 23.6, 37.4, 2.7, 1.3) || inCap(x, y, 5.5, 33, 7.5, 37.2, 2.4) ||\n    inEl(x, y, 9.2, 37.6, 3, 1) || inPoly(x, y, WING);\n  return body ? GARG : -1;\n}\n\nexport function setup(params) {\n  const kind = new Uint8Array(N), tone = new Float32Array(N), rnd = prng(5);\n  const blk = new Float32Array(64);\n  for (let i = 0; i \u003c 64; i++) blk[i] = 0.42 + 0.16 * rnd();\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, cx = x + 0.5, cy = y + 0.5;\n      let k = SKY, t = 0;\n      // The far tower: a spire with crockets every 8 rows on a square tower,\n      // corner pinnacles where they meet.\n      const ax = abs(cx - 52);\n      if (y >= 72 && ax \u003c= 6.5) k = FAR;\n      else if (y >= 12 && y \u003c 72 && ax \u003c= 0.6 + (5.4 * (y - 12)) / 60 + ((y - 12) % 8 \u003c 2 ? 1 : 0)) k = FAR;\n      else if (y >= 62 && y \u003c 72 && (abs(cx - 45.5) \u003c= ((y - 62) * 1.2) / 10 || abs(cx - 58.5) \u003c= ((y - 62) * 1.2) / 10)) k = FAR;\n      // Two near pinnacles on the parapet, then the parapet, the ledge\n      // and the wall with its blocks.\n      for (const [px, tip, hw] of [[4.5, 1, 4.2], [20, 4, 3.2]]) {\n        if (y >= tip && y \u003c 30) {\n          const u = y - tip, w = u \u003c 3 ? (u === 1 ? 1.4 : 0.6) : 0.5 + (hw * (u - 3)) / (27 - tip) + (u % 5 === 3 ? 1 : 0);\n          if (abs(cx - px) \u003c= w) (k = PIN), (t = cx \u003c px ? 0.66 : 0.42);\n        }\n      }\n      if (y >= 30 && y \u003c 38 && x \u003c= 22) (k = WALL), (t = y >= 32 && y \u003c= 35 && x % 5 >= 2 && x % 5 \u003c= 3 ? 0.08 : 0.5);\n      if (y >= 38 && y \u003c 42 && x \u003c= 24) (k = WALL), (t = [0.85, 0.62, 0.45, 0.25][y - 38]);\n      if (y >= 42 && y \u003c GROUND && x \u003c= 14) {\n        k = WALL;\n        const row = floor((y - 42) / 6), bx = x + (row & 1 ? 4 : 0);\n        t = (y - 42) % 6 === 5 || bx % 8 === 7 ? 0.22 : blk[(row * 3 + floor(bx / 8)) & 63];\n        if (x === 14) t *= 0.6;\n        // A lancet window with a pointed head and diamond leading.\n        const wy = y - 58, hwin = wy \u003c 0 ? -1 : wy \u003c 6 ? 3 * sqrt(1 - ((6 - wy) / 6.5) ** 2) - 0.3 : 3;\n        if (y \u003c= 92 && abs(cx - 7.5) \u003c= hwin) (k = GLASS), (t = (x + y) % 4 === 0 || (x - y + 400) % 4 === 0 ? 0 : 1 + ((floor((x + y) / 4) + floor((x - y + 400) / 4)) % 3));\n        else if (y \u003c= 93 && abs(cx - 7.5) \u003c= hwin + 1.2 && wy >= -1) t = 0.75;\n      }\n      // Cobbles in rows two LEDs deep, wider toward us, each row offset by\n      // half a stone, the top of each stone wet and lighter.\n      if (y >= GROUND) {\n        const row = (y - GROUND) >> 1, sw = 3 + (row >> 1), sx = x + (row & 1 ? sw >> 1 : 0);\n        k = STREET;\n        t = sx % sw === 0 ? 0.06 : (y - GROUND) & 1 ? 0.16 : 0.27 + 0.08 * ((floor(sx / sw) * 5 + row) % 3 === 0);\n      }\n      if (y >= GROUND && inEl(cx, cy, PX, PY, PRX, PRY)) k = POOL;\n      const g = gargoyle(cx, cy);\n      if (g >= 0) k = g;\n      (kind[p] = k), (tone[p] = t);\n    }\n  // The gargoyle's stone shaded by how deep each LED lies inside it (a\n  // chamfer distance) and which way the edge faces: lit from the upper left\n  // in four steps; the wing ribs and the mouth dark, teeth pale.\n  const d = new Float32Array(N);\n  for (let p = 0; p \u003c N; p++) d[p] = kind[p] === GARG || kind[p] === MOUTH ? 99 : 0;\n  for (let y = 1; y \u003c H - 1; y++) for (let x = 1; x \u003c W - 1; x++) { const p = y * W + x; d[p] = min(d[p], d[p - 1] + 1, d[p - W] + 1, d[p - W - 1] + 1.4, d[p - W + 1] + 1.4); }\n  for (let y = H - 2; y > 0; y--) for (let x = W - 2; x > 0; x--) { const p = y * W + x; d[p] = min(d[p], d[p + 1] + 1, d[p + W] + 1, d[p + W + 1] + 1.4, d[p + W - 1] + 1.4); }\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (kind[p] !== GARG) continue;\n      const gx = min(d[p + 1], 4) - min(d[p - 1], 4), gy = min(d[p + W], 4) - min(d[p - W], 4), gl = hypot(gx, gy) || 1;\n      const face = d[p] \u003c 3.5 ? (0.55 * gx + 0.8 * gy) / gl : 0, lit = 0.6 + 0.4 * face * (1 - min(d[p], 3) / 4);\n      tone[p] = [0.32, 0.48, 0.64, 0.82][cl(floor(lit * 4 - 0.6), 0, 3)];\n    }\n  const rib = (ax, ay, bx, by) => {\n    for (let s = 0; s \u003c= 20; s++) {\n      const p = floor(mix(ay, by, s / 20)) * W + floor(mix(ax, bx, s / 20));\n      if (kind[p] === GARG) tone[p] = 0.2;\n    }\n  };\n  rib(16, 24, 10.5, 14.5), rib(15.5, 24.5, 7, 15.5), rib(15, 25, 3, 18.5);\n  for (let x = 28; x \u003c= 34; x += 2) {\n    if (kind[24 * W + x] === MOUTH) (tone[24 * W + x] = 1), (kind[24 * W + x] = GARG);\n    if (kind[25 * W + x + 1] === MOUTH) (tone[25 * W + x + 1] = 1), (kind[25 * W + x + 1] = GARG);\n  }\n  for (const p of EYE) tone[p] = 0.06;\n  tone[19 * W + 29] = tone[19 * W + 30] = 0.9;\n  // The trough along the gargoyle's back that carries the gutter's water to\n  // its jaws: the top LED of its stone in each column from the wing to the head.\n  const trough = [];\n  for (let x = 17; x \u003c= 26; x++)\n    for (let y = 14; y \u003c 40; y++)\n      if (inCap(x + 0.5, y + 0.5, 9, 28, 20, 26.5, 5) || inCap(x + 0.5, y + 0.5, 22, 26, 26.5, 22.5, 3.3)) {\n        if (kind[y * W + x] === GARG) trough.push(y * W + x);\n        break;\n      }\n  // The puddle's far edge, where it meets the cobbles, catches the light.\n  for (let p = W; p \u003c N; p++) if (kind[p] === POOL && kind[p - W] !== POOL) tone[p] = 1;\n  // Stone that touches the sky catches the flash behind it.\n  const rim = new Uint8Array(N);\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, k = kind[p];\n      if (k === SKY || k >= STREET) continue;\n      if (kind[p - W] === SKY || kind[p + 1] === SKY || kind[p - 1] === SKY) rim[p] = 1;\n    }\n  params.s = {\n    kind, tone, rim, trough,\n    hue: 0, speed: 2, rain: 0, bolt: 0.06, t: 0, clock: 0, flow: 0,\n    landX: 50, strikeAt: -9, next: 1.5, strokes: [0], boltMask: new Float32Array(N), boltX: 40, amp: 0.6, eye: 0,\n    jet: new Float32Array(1200 * 4), nj: 0, emit: 0,\n    drops: new Float32Array(RAIN1 * 3), spl: new Float32Array(300 * 4), ns: 0,\n    rip: new Float32Array(48 * 3), nr: 0, ripAt: 0,\n    rgb: new Float32Array(N * 3), pal: new Float32Array(21 * 11 * 3), palH: -1, near: new Float32Array(W),\n  };\n  const S = params.s;\n  for (let i = 0; i \u003c RAIN1; i++) (S.drops[i * 3] = spawnX(28)), (S.drops[i * 3 + 1] = -8 + 136 * Math.random()), (S.drops[i * 3 + 2] = 0.8 + 0.4 * Math.random());\n  // The stream is already falling when the picture opens.\n  for (let i = 0; i \u003c 45; i++) water(S, 1 / 30);\n}\n\n// A new bolt: a jagged channel from above the panel down behind the far\n// tower or the wall, with branches; drawn into a mask the sky reads.\nfunction strike(S) {\n  const m = S.boltMask, n = 1 + floor(4 * S.bolt);\n  m.fill(0);\n  let x = 22 + 40 * Math.random(), y = -2;\n  S.boltX = x;\n  const end = 70 + 35 * Math.random(), lean = (Math.random() - 0.5) * 1.2;\n  const put = (px, py, v) => {\n    for (let dy = -1; dy \u003c= 1; dy++)\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        const xx = floor(px) + dx, yy = floor(py) + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const w = dx || dy ? v * 0.3 : v;\n        if (m[yy * W + xx] \u003c w) m[yy * W + xx] = w;\n      }\n  };\n  const seg = (x0, y0, x1, y1, v) => {\n    const s = ceil1(max(abs(x1 - x0), abs(y1 - y0)));\n    for (let i = 0; i \u003c= s; i++) put(mix(x0, x1, i / s), mix(y0, y1, i / s), v);\n  };\n  const forks = [];\n  while (y \u003c end) {\n    const nx = x + lean + (Math.random() - 0.5) * 5, ny = y + 2 + 3 * Math.random();\n    seg(x, y, nx, ny, 1);\n    if (forks.length \u003c n && Math.random() \u003c 0.12) forks.push([nx, ny, Math.random() \u003c 0.5 ? -1 : 1]);\n    (x = nx), (y = ny);\n  }\n  for (const [fx, fy, sg] of forks) {\n    let bx = fx, by = fy;\n    const len = 6 + floor(10 * Math.random());\n    for (let i = 0; i \u003c len; i++) {\n      const nx = bx + sg * (1 + 2 * Math.random()), ny = by + 1.5 + 2 * Math.random();\n      seg(bx, by, nx, ny, 0.6);\n      (bx = nx), (by = ny);\n    }\n  }\n  S.strokes = S.bolt > 0.5 ? [0, 0.16, 0.31] : [0, 0.16];\n  S.amp = 0.72 + 0.28 * S.bolt;\n  S.strikeAt = S.t;\n}\nconst ceil1 = (v) => Math.max(1, Math.ceil(v));\n\n// The water for h seconds of the story: parcels leave the jaws, fall under\n// gravity with a little wind and land in the puddle, throwing up splashes\n// and rings; the rain falls and rings the puddle too.\nfunction water(S, h) {\n  const jet = S.jet, rain = S.rain;\n  S.emit += h * (190 + 170 * rain);\n  while (S.emit >= 1 && S.nj \u003c 1200) {\n    S.emit--;\n    const o = S.nj++ * 4, gs = () => Math.random() + Math.random() - 1;\n    jet[o] = MX + 2 * Math.random() - 1;\n    jet[o + 1] = MY + (Math.random() - 0.5) * (2.2 + 2.2 * rain);\n    jet[o + 2] = VX * (1 + 0.3 * rain) + gs() * (2.2 + 1.6 * rain);\n    jet[o + 3] = VY + gs() * (1.2 + rain);\n  }\n  for (let i = 0; i \u003c S.nj; i++) {\n    const o = i * 4;\n    jet[o + 3] += G * h;\n    jet[o + 2] += WIND * h;\n    jet[o] += jet[o + 2] * h;\n    jet[o + 1] += jet[o + 3] * h;\n    const x = jet[o], y = jet[o + 1];\n    if (y >= GROUND + 1 || x > W + 4) {\n      if (inEl(x, y, PX, PY, PRX, PRY)) {\n        S.landX = mix(S.landX, x, 0.05);\n        const n = Math.random() \u003c 0.5 + 0.4 * rain ? 1 + floor(Math.random() * 2) : 0;\n        for (let k = 0; k \u003c n && S.ns \u003c 300; k++) {\n          const s = S.ns++ * 4;\n          (S.spl[s] = x), (S.spl[s + 1] = GROUND + 1), (S.spl[s + 2] = (Math.random() - 0.5) * 50), (S.spl[s + 3] = -(25 + 45 * Math.random()) * (1 + rain));\n        }\n        if (S.t >= S.ripAt) (S.ripAt = S.t + 0.12), ring(S, x, y);\n      }\n      // Removed by moving the last parcel into its slot.\n      S.nj--;\n      for (let k = 0; k \u003c 4; k++) jet[o + k] = jet[S.nj * 4 + k];\n      i--;\n    }\n  }\n  for (let i = 0; i \u003c S.ns; i++) {\n    const o = i * 4, sp = S.spl;\n    sp[o + 3] += G * h;\n    sp[o] += sp[o + 2] * h;\n    sp[o + 1] += sp[o + 3] * h;\n    if (sp[o + 1] > GROUND + 2) {\n      S.ns--;\n      for (let k = 0; k \u003c 4; k++) sp[o + k] = sp[S.ns * 4 + k];\n      i--;\n    }\n  }\n  const dr = S.drops, live = RAIN0 + floor((RAIN1 - RAIN0) * rain), vx = 28 + 34 * rain;\n  for (let i = 0; i \u003c RAIN1; i++) {\n    const o = i * 3;\n    dr[o] += vx * h * dr[o + 2];\n    dr[o + 1] += FALL * h * dr[o + 2];\n    if (dr[o + 1] > GROUND + 1 + 7 * ((i * 0.37) % 1)) {\n      if (i \u003c live && inEl(dr[o], dr[o + 1], PX, PY, PRX, PRY) && Math.random() \u003c 0.5) ring(S, dr[o], dr[o + 1]);\n      (dr[o] = spawnX(vx)), (dr[o + 1] = -6 - 6 * Math.random()), (dr[o + 2] = 0.8 + 0.4 * Math.random());\n    }\n  }\n  for (let i = 0; i \u003c S.nr; i++) {\n    S.rip[i * 3 + 2] += h;\n    if (S.rip[i * 3 + 2] > 0.55) {\n      S.nr--;\n      for (let k = 0; k \u003c 3; k++) S.rip[i * 3 + k] = S.rip[S.nr * 3 + k];\n      i--;\n    }\n  }\n}\nfunction ring(S, x, y) {\n  if (S.nr >= 48) return;\n  const o = S.nr++ * 3;\n  (S.rip[o] = x), (S.rip[o + 1] = y), (S.rip[o + 2] = 0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.rain = cl(k[2], 0, 1);\n  S.bolt = cl(k[3], 0, 1);\n  const h = (d * S.speed) / 2;\n  S.t += d;\n  S.clock += h;\n  S.flow += h;\n  water(S, h);\n  // Strikes: the first at 1.5 s, then gaps round the Lightning knob's mean.\n  if (S.t >= S.next || (input.btnPressed && input.btnPressed.some(Boolean))) {\n    strike(S);\n    S.next = S.t + mix(4.5, 0.9, S.bolt) * (0.7 + 0.6 * Math.random()) * min(2.5, 2 / S.speed) ** 0.5;\n  }\n  // The eyes kindle a quarter second after each strike and stay lit until two seconds after it, then fade.\n  const e = S.t - S.strikeAt;\n  S.eye = e \u003c 0.25 ? max(0, S.eye - d) : e \u003c 0.45 ? max(S.eye, sm(0.25, 0.45, e)) : e \u003c 2 ? 1 : 1 - sm(2, 3, e);\n}\n\n// How bright the strike is t seconds after it began: a spike for each return\n// stroke and an afterglow; and how strongly the channel itself shows.\nfunction flashAt(S, t) {\n  if (t \u003c 0 || t > 2) return [0, 0];\n  let spike = 0, chan = 0;\n  for (const s of S.strokes)\n    if (t >= s) (spike = max(spike, exp(-(t - s) / 0.05))), (chan = max(chan, exp(-(t - s) / 0.1)));\n  return [min(1, 0.7 * spike + 0.3 * exp(-t / 0.4)) * S.amp, chan];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { kind, tone, rim, rgb } = S;\n  const [flash, chan] = flashAt(S, S.t - S.strikeAt), fq = q20(flash);\n  const skyH = 0.78 - 0.45 * S.hue, lite = hsv(skyH, 0.28, 0.86), stone = hsv(skyH - 0.04, 0.16, 0.62);\n  const dark = 1 - min(1, flash * 2.4), far = hsv(skyH, 0.55, 0.1);\n  const glass = [[0.04, 0.02, 0.05], [1, 0.74, 0.16], [0.86, 0.1, 0.2], [0.36, 0.3, 0.95]];\n  const flick = 0.62 + 0.08 * floor(3 * noise(S.clock * 3, 4.5));\n  // The sky's colours for this hue by brightness step and cloud step, and\n  // how much of the flash each column gets from the bolt's place.\n  const pal = S.pal, near = S.near;\n  if (S.palH !== skyH) {\n    S.palH = skyH;\n    for (let vi = 0; vi \u003c= 20; vi++) for (let ci = 0; ci \u003c= 10; ci++) pal.set(hsv(skyH + 0.003 * ci, 0.72 - 0.03 * ci, vi / 20), (vi * 11 + ci) * 3);\n  }\n  for (let x = 0; x \u003c W; x++) near[x] = 0.55 + 0.45 * exp(-((x - S.boltX) ** 2) / 500);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3, k = kind[p];\n      let r, g, b;\n      if (k === SKY || k === POOL) {\n        // Bruised clouds drifting right, in 1/20 steps, lighter toward the\n        // street; the puddle shows the sky over it, darker.\n        const yy = k === POOL ? 2 * GROUND - y - 30 : y;\n        const c1 = noise(x / 17 + S.clock * 0.3, yy / 11 + 1 + S.clock * 0.04), c2 = noise(x / 8 + S.clock * 0.55 + 5, yy / 6);\n        const ci = floor(cl((0.7 * c1 + 0.3 * c2 - 0.32) * 1.8, 0, 0.99) * 10), cq = ci / 10;\n        const vi = floor((0.15 + 0.13 * (yy / H) + 0.22 * cq * cq) * (k === POOL ? 15 : 20)), po = (vi * 11 + ci) * 3;\n        const f = q20(fq * near[x] * (0.8 + 0.3 * cq)) * (k === POOL ? 0.6 : 1);\n        (r = mix(pal[po], lite[0], f)), (g = mix(pal[po + 1], lite[1], f)), (b = mix(pal[po + 2], lite[2], f));\n        const bl = k === SKY ? S.boltMask[p] * chan : 0;\n        if (bl > 0.05) (r = mix(r, 1, bl)), (g = mix(g, 1, bl)), (b = mix(b, 1, bl));\n        // In the puddle: the lit far edge, and the falling stream mirrored\n        // under the place it lands.\n        if (k === POOL) {\n          const e = tone[p] ? 0.4 : abs(x + 0.5 - S.landX) \u003c 1.6 ? 0.3 : 0;\n          if (e) (r = mix(r, 0.7, e)), (g = mix(g, 0.86, e)), (b = mix(b, 1, e));\n        }\n      } else if (k === FAR) {\n        (r = far[0] * dark), (g = far[1] * dark), (b = far[2] * dark);\n        if (rim[p]) (r += lite[0] * fq * 0.7), (g += lite[1] * fq * 0.7), (b += lite[2] * fq * 0.7);\n      } else if (k === GLASS) {\n        const c = glass[tone[p]], v = flick;\n        (r = c[0] * v), (g = c[1] * v), (b = c[2] * v);\n      } else if (k === STREET) {\n        const v = tone[p] * (1 + fq);\n        (r = stone[0] * v), (g = stone[1] * v), (b = stone[2] * v);\n      } else {\n        // Stone: lit dimly by the storm, black against the flash, its edges\n        // catching the light behind it.\n        const v = k === MOUTH ? 0.04 : tone[p] * (k === PIN ? 0.8 : 1), dk = k === PIN ? dark : mix(dark, 1, 0.25);\n        (r = stone[0] * v * dk), (g = stone[1] * v * dk), (b = stone[2] * v * dk);\n        if (rim[p]) (r += lite[0] * fq), (g += lite[1] * fq), (b += lite[2] * fq);\n      }\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n  const add = (x, y, c, v) => {\n    x = floor(x), y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    (rgb[o] = max(rgb[o], c[0] * v)), (rgb[o + 1] = max(rgb[o + 1], c[1] * v)), (rgb[o + 2] = max(rgb[o + 2], c[2] * v));\n  };\n  // The trough on its back: water glinting as it runs to the jaws.\n  const wat = [0.66, 0.86, 1];\n  S.trough.forEach((p, i) => add(p % W, floor(p / W), wat, (i - S.flow * 14) % 5 \u003c -3.5 || (i - S.flow * 14) % 5 > 3.5 ? 0.85 : 0.42));\n  // The puddle's rings, flattened by the angle we see it at.\n  for (let i = 0; i \u003c S.nr; i++) {\n    const cx = S.rip[i * 3], cy = S.rip[i * 3 + 1], a = S.rip[i * 3 + 2], rr = 1 + a * 14, v = 0.6 - 0.15 * floor(a * 6);\n    for (let s = 0; s \u003c 24; s++) {\n      const x = cx + rr * cos((s * PI) / 12), y = cy + 0.3 * rr * sin((s * PI) / 12);\n      if (inEl(x, y, PX, PY, PRX, PRY)) add(x, y, lite, v);\n    }\n  }\n  // The stream: each parcel a streak over the way it came in the last frame,\n  // or at slow speeds over the way it comes in a frame at Speed 1.2, so the\n  // slowed stream still reads as water and not as beads.\n  const step = (1 / 30) * (max(1.2, S.speed) / 2), wc = [mix(0.72, 1, fq), mix(0.88, 1, fq), 1];\n  for (let i = 0; i \u003c S.nj; i++) {\n    const o = i * 4, x = S.jet[o], y = S.jet[o + 1], vx = S.jet[o + 2], vy = S.jet[o + 3];\n    const n = ceil1(abs(vy * step));\n    for (let s = 0; s \u003c n; s++) add(x - (vx * step * s) / n, y - (vy * step * s) / n, wc, s ? 0.7 : 0.92);\n  }\n  for (let i = 0; i \u003c S.ns; i++) add(S.spl[i * 4], S.spl[i * 4 + 1], wc, 0.8);\n  // Rain in front of it all, a bright head and a fainter tail along its slant.\n  const live = RAIN0 + floor((RAIN1 - RAIN0) * S.rain), vx = 28 + 34 * S.rain, rc = hsv(skyH, 0.22, 1), len = 4 + floor(S.speed / 1.5);\n  for (let i = 0; i \u003c live; i++) {\n    const o = i * 3, x = S.drops[o], y = S.drops[o + 1];\n    for (let s = 0; s \u003c len; s++) add(x - (vx / FALL) * s, y - s, rc, (s ? 0.34 : 0.55) + 0.3 * fq);\n  }\n  // The eyes, poison green, with a stepped glow round them.\n  if (S.eye > 0) {\n    const e = q20(S.eye), gc = [0.42, 1, 0.12];\n    for (let dy = -2; dy \u003c= 2; dy++)\n      for (let dx = -2; dx \u003c= 3; dx++) {\n        const r2 = hypot(dx - 0.5, dy), v = r2 \u003c 0.9 ? 1 : r2 \u003c 1.8 ? 0.4 : r2 \u003c 2.6 ? 0.18 : 0;\n        if (v) add(29 + dx, 20 + dy, gc, v * e);\n      }\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","kempe-chains":"// ===== Patternflow pattern =====\n// Title:   Kempe Chains\n// Family:  cells\n// Idea:    A map of drifting countries is kept four-coloured as their borders change: when a new border puts two neighbours in one colour, the country takes a free colour if one is left, and if all four surround it a Kempe chain of two colours lights up, shows its links from capital to capital and swaps its colours to free one.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kempe chains (Alfred Kempe, 1879; the gap found by Percy Heawood, 1890), four colour theorem (Kenneth Appel and Wolfgang Haken, 1976), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Countries=15..40, Sizes=0..1\n//\n// Knob 1: Hue. Turns the four colours round the wheel together, a quarter apart: at 0 orange, green, azure and pink. At 0.25 each has moved on to the next, so every country wears another of the same four; at 0.5 orange and azure trade places, and so do green and pink.\n// Knob 2: Speed. How fast the stirring carries the countries. At 2 a capital moves at up to 14 LEDs a second, and with 15 countries a new border appears 2 to 3 times a second, a quarter to a third of them between two countries of one colour; at 0.2 everything drifts ten times slower, at 3 half as fast again. A repair shows in the same time at any Speed: 0.2 s of glow, 0.5 s of cross-fade, 0.3 s to cool.\n// Knob 3: Countries. How many countries share the panel, from 15 (each about 23 LEDs across) to 40 (about 14). With 15 there is a repair every 1.2 to 2 seconds and half of them or more need a chain; with 40 five or six a second, three in four with a chain.\n// Knob 4: Sizes. At 0 every capital has the same weight and the map is a Voronoi diagram, its largest country under twice the area of its smallest. Turning it up makes it a power diagram whose weights spread: at 1 the largest is 8 times the smallest with 15 countries and 18 times with 40, and a big country can border eight or nine others.\n\nconst W = 64, H = 128, N = W * H, M = 40;\nconst { floor, min, max, abs, sqrt, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A repair as the panel shows it, in seconds whatever the Speed: the\n// countries it touches glow, cross-fade to their new colours and cool.\nconst RISE = 0.2, CROSS = 0.5, FALL = 0.3, LIFE = RISE + CROSS + FALL;\n// Where four countries nearly meet at a point, the LED grid lets the border\n// between one pair and the border between the other flicker for a few\n// frames. A border counts for this long (in drift seconds) after it was last\n// seen, so the colouring is kept proper for both and a repair is not undone\n// by the next frame.\nconst HOLD = 0.4;\n// A capital's own wandering speed and the stirring's strength, in LEDs per\n// drift second.\nconst V0 = 2, FLOW = 10;\n\nexport function setup(params) {\n  const f = () => new Float32Array(M);\n  params.s = {\n    t: 0, clock: 0, n: 0, hue: 0, speed: 2, sizes: 0.06, started: false, plan: 0,\n    x: f(), y: f(), vx: f(), vy: f(), th: f(), om: f(), u: f(), w: f(), r: f(),\n    own: new Uint8Array(N), col: new Uint8Array(M).fill(255),\n    // seen: drift time each pair last shared a border; cur: sharing one this frame; act: counts for the colouring.\n    seen: new Float32Array(M * M).fill(-1e9), cur: new Uint8Array(M * M), act: new Uint8Array(M * M),\n    area: f(), cx: f(), cy: f(), dy2: f(),\n    // The colour each country fades from, how far into its repair it is, and how hard it glows.\n    from: new Float32Array(M * 3), age: new Float32Array(M).fill(LIFE), gl: f(),\n    pal: new Float32Array(12), fl: [0, 0], disp: new Float32Array(M * 3), ov: new Float32Array(N),\n    mark: new Uint8Array(M), queue: new Int16Array(M),\n    // Events still showing: chain links between capitals and the new border that started it.\n    ev: [],\n    stats: { frames: 0, proper: 0, repairs: 0, free: 0, swap1: 0, swap2: 0, local: 0, failed: 0, forget: 0, firstSwap: -1, chainSizes: 0 },\n  };\n}\n\nfunction addSeed(S, i) {\n  S.x[i] = 2 + Math.random() * (W - 4);\n  S.y[i] = 2 + Math.random() * (H - 4);\n  S.vx[i] = S.vy[i] = 0;\n  S.th[i] = Math.random() * TAU;\n  S.om[i] = 0.6 + 0.8 * Math.random();\n  S.u[i] = Math.random() * 2 - 1;\n  S.col[i] = 255;\n  S.age[i] = 0;\n  S.gl[i] = 0.3;\n  S.from.fill(0.08, 3 * i, 3 * i + 3);\n  for (let j = 0; j \u003c M; j++) S.seen[i * M + j] = S.seen[j * M + i] = -1e9;\n}\n\n// The stirring: a stream function of four box modes whose strengths rise\n// and fall out of step, so the map is sheared one way and then another and\n// neighbours keep changing. A box mode never flows through the frame.\nconst MODES = [[1, 2, 0.21, 0], [2, 3, 0.17, 2.1], [1, 3, 0.13, 4.2], [2, 1, 0.11, 1.3]];\nfunction flow(t, x, y, out) {\n  let u = 0, v = 0;\n  for (const [a, b, f, ph] of MODES) {\n    const A = FLOW * cos(TAU * f * t + ph), ka = (PI * a) / W, kb = (PI * b) / H, k = 1 / max(ka, kb);\n    u += A * k * kb * sin(ka * x) * cos(kb * y);\n    v -= A * k * ka * cos(ka * x) * sin(kb * y);\n  }\n  out[0] = u;\n  out[1] = v;\n}\n\n// Each capital wanders on a turning heading and is pushed off the others and\n// the frame by its size. A capital's size r is half the distance it keeps to\n// a neighbour; its power weight is r squared, so the border between two\n// touching countries falls where their two sizes meet.\nfunction move(S, ds, wander) {\n  const n = S.n, A = N / n, { x, y, vx, vy, th, om, u, w, r } = S;\n  for (let i = 0; i \u003c n; i++) {\n    const g = 1 + 0.82 * u[i] * S.sizes;\n    r[i] = 0.58 * sqrt(A * g);\n    w[i] = 0.3364 * A * (g - 1);\n  }\n  if (ds \u003c= 0) return;\n  for (let i = 0; i \u003c n; i++) {\n    let fx = 0, fy = 0;\n    if (wander) {\n      // The heading turns on two slow waves of the capital's own, so the\n      // whole drift follows from where things are: the opening can look ahead.\n      const a = th[i] + 1.6 * sin(0.53 * S.t * om[i] + 5 * th[i]) + 0.9 * sin(1.31 * S.t + 3 * om[i]);\n      fx = V0 * cos(a);\n      fy = V0 * sin(a);\n      flow(S.t, x[i], y[i], S.fl);\n      fx += S.fl[0];\n      fy += S.fl[1];\n    }\n    for (let j = 0; j \u003c n; j++) {\n      if (j === i) continue;\n      const dx = x[i] - x[j], dy = y[i] - y[j], d = sqrt(dx * dx + dy * dy) + 1e-6, rr = r[i] + r[j];\n      if (d \u003c rr) {\n        const k = (3.5 * (rr - d)) / d;\n        fx += dx * k;\n        fy += dy * k;\n      }\n    }\n    const m = 0.7 * r[i];\n    if (x[i] \u003c m) fx += 3.5 * (m - x[i]);\n    if (x[i] > W - m) fx -= 3.5 * (x[i] - W + m);\n    if (y[i] \u003c m) fy += 3.5 * (m - y[i]);\n    if (y[i] > H - m) fy -= 3.5 * (y[i] - H + m);\n    const e = min(1, ds * 2.5);\n    vx[i] += (fx - vx[i]) * e;\n    vy[i] += (fy - vy[i]) * e;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    x[i] = cl(x[i] + vx[i] * ds, 0.5, W - 0.5);\n    y[i] = cl(y[i] + vy[i] * ds, 0.5, H - 0.5);\n  }\n}\n\n// The map: every LED belongs to the capital of least power distance\n// |p - c|^2 - w. Two countries share a border when two LEDs side by side\n// (not only corner to corner) belong to them.\nfunction map(S) {\n  const n = S.n, { x, y, w, own, cur, seen, act, area, cx, cy, dy2 } = S;\n  for (let y0 = 0, p = 0; y0 \u003c H; y0++) {\n    const py = y0 + 0.5;\n    for (let i = 0; i \u003c n; i++) dy2[i] = (py - y[i]) * (py - y[i]) - w[i];\n    for (let x0 = 0; x0 \u003c W; x0++, p++) {\n      const px = x0 + 0.5;\n      let best = 1e9, bi = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = px - x[i], v = dx * dx + dy2[i];\n        if (v \u003c best) (best = v), (bi = i);\n      }\n      own[p] = bi;\n    }\n  }\n  cur.fill(0);\n  area.fill(0);\n  cx.fill(0);\n  cy.fill(0);\n  for (let y0 = 0, p = 0; y0 \u003c H; y0++)\n    for (let x0 = 0; x0 \u003c W; x0++, p++) {\n      const o = own[p];\n      area[o]++;\n      cx[o] += x0 + 0.5;\n      cy[o] += y0 + 0.5;\n      if (x0 \u003c W - 1 && own[p + 1] !== o) cur[o * M + own[p + 1]] = cur[own[p + 1] * M + o] = 1;\n      if (y0 \u003c H - 1 && own[p + W] !== o) cur[o * M + own[p + W]] = cur[own[p + W] * M + o] = 1;\n    }\n  for (let i = 0; i \u003c n; i++) {\n    if (area[i]) (cx[i] /= area[i]), (cy[i] /= area[i]);\n    else (cx[i] = x[i]), (cy[i] = y[i]);\n  }\n  act.fill(0);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) {\n      const k = i * M + j;\n      if (cur[k]) seen[k] = S.t;\n      if (i !== j && S.t - seen[k] \u003c HOLD) act[k] = 1;\n    }\n}\n\n// Colours used round country v, as four bits (uncoloured neighbours ignored).\nfunction used(S, v) {\n  let m = 0;\n  for (let j = 0; j \u003c S.n; j++) if (S.act[v * M + j] && S.col[j] \u003c 4) m |= 1 \u003c\u003c S.col[j];\n  return m;\n}\n\n// The Kempe chain(s): every country reachable from the starts through\n// countries coloured a or b, never through v. Marks them in S.mark and\n// returns their indices.\nfunction chain(S, v, starts, a, b) {\n  const { mark, queue, col, act, n } = S;\n  mark.fill(0);\n  let h = 0, t = 0;\n  for (const s of starts) if (!mark[s]) (mark[s] = 1), (queue[t++] = s);\n  while (h \u003c t) {\n    const i = queue[h++];\n    for (let j = 0; j \u003c n; j++)\n      if (j !== v && !mark[j] && act[i * M + j] && (col[j] === a || col[j] === b)) (mark[j] = 1), (queue[t++] = j);\n  }\n  return Array.from(queue.subarray(0, t));\n}\n\nconst nbOf = (S, v, c) => {\n  const out = [];\n  for (let j = 0; j \u003c S.n; j++) if (S.act[v * M + j] && S.col[j] === c) out.push(j);\n  return out;\n};\n\n// One swap: for some pair of colours (a, b), the a/b chains through v's\n// a-coloured neighbours reach none of its b-coloured ones, so swapping a and b\n// on them leaves no a round v. Of the swaps that work, the one shown is the\n// longest chain of up to five countries, then the shortest longer one; a\n// chain of one country only when nothing else works.\nfunction single(S, xs) {\n  let best = null, score = 1e9;\n  for (const v of xs)\n    for (let a = 0; a \u003c 4; a++) {\n      const starts = nbOf(S, v, a);\n      if (!starts.length) continue;\n      for (let b = 0; b \u003c 4; b++) {\n        if (b === a) continue;\n        const comp = chain(S, v, starts, a, b);\n        let ok = true;\n        for (let j = 0; j \u003c S.n && ok; j++) if (S.mark[j] && S.col[j] === b && S.act[v * M + j]) ok = false;\n        if (!ok) continue;\n        const L = comp.length, sc = L === 1 ? 100 : L \u003c= 5 ? 10 - L : 10 + L;\n        if (sc \u003c score) (score = sc), (best = { v, a, b, comp });\n      }\n    }\n  return best;\n}\n\nfunction swap(S, comp, a, b) {\n  for (const i of comp) S.col[i] = S.col[i] === a ? b : a;\n}\n\n// The colour a country shows now, part way through its repair.\nfunction shown(S, i, out, o) {\n  const e = ease((S.age[i] - RISE) / CROSS), c = S.col[i] \u003c 4 ? S.col[i] : 0, p = S.pal;\n  for (let k = 0; k \u003c 3; k++) out[o + k] = S.from[3 * i + k] + (p[3 * c + k] - S.from[3 * i + k]) * e;\n}\n\n// Give i the colour c; on screen it glows by g and fades over from what it shows now.\nfunction paint(S, i, c, show, g) {\n  if (show) {\n    shown(S, i, S.from, 3 * i);\n    S.gl[i] = max(g, S.age[i] \u003c LIFE ? S.gl[i] * 0.5 : 0);\n    S.age[i] = 0;\n  }\n  S.col[i] = c;\n  if (!show) {\n    S.age[i] = LIFE;\n    S.gl[i] = 0;\n  }\n}\n\nfunction event(S, comp, v, a, b, show) {\n  if (!show) return;\n  // Links between capitals along the chain, and from v to the chain.\n  const links = [];\n  const inC = new Uint8Array(M);\n  for (const i of comp) inC[i] = 1;\n  for (const i of comp) for (const j of comp) if (i \u003c j && S.act[i * M + j]) links.push(i, j);\n  for (const j of comp) if (S.act[v * M + j]) links.push(v, j);\n  S.ev.push({ links, age: 0, a, b });\n}\n\n// Repair the conflict on the border u-v (u -1: v is a new, uncoloured country).\nfunction repair(S, u, v, show, last) {\n  const st = S.stats, xs = u \u003c 0 ? [v] : [v, u];\n  if (show) st.repairs++;\n  // A free colour.\n  for (const x of xs) {\n    const m = used(S, x);\n    if (m !== 15) {\n      const free = [];\n      for (let c = 0; c \u003c 4; c++) if (!(m & (1 \u003c\u003c c))) free.push(c);\n      paint(S, x, free[floor(Math.random() * free.length)], show, 0.28);\n      if (show) st.free++, S.ev.push({ links: [], age: 0, a: u, b: v });\n      return true;\n    }\n  }\n  // One Kempe swap.\n  let k = single(S, xs);\n  if (k) {\n    for (const i of k.comp) paint(S, i, S.col[i] === k.a ? k.b : k.a, show, 0.6);\n    paint(S, k.v, k.a, show, 0.6);\n    if (show) {\n      st.swap1++;\n      st.chainSizes += k.comp.length;\n      if (st.firstSwap \u003c 0) st.firstSwap = S.clock;\n      event(S, k.comp, k.v, u, v, true);\n    }\n    return true;\n  }\n  // Two swaps, as Kempe argued for a country of five neighbours: the first\n  // swap on any a/b chain through a neighbour, then one swap that works.\n  for (const x of xs)\n    for (let a = 0; a \u003c 4; a++)\n      for (let b = 0; b \u003c 4; b++) {\n        if (a === b) continue;\n        for (const w of nbOf(S, x, a)) {\n          const c1 = chain(S, x, [w], a, b);\n          swap(S, c1, a, b);\n          k = single(S, [x]);\n          if (k) {\n            swap(S, c1, a, b);\n            for (const i of c1) paint(S, i, S.col[i] === a ? b : a, show, 0.6);\n            for (const i of k.comp) paint(S, i, S.col[i] === k.a ? k.b : k.a, show, 0.6);\n            paint(S, x, k.a, show, 0.6);\n            if (show) {\n              st.swap2++;\n              if (st.firstSwap \u003c 0) st.firstSwap = S.clock;\n              event(S, c1.concat(k.comp), x, u, v, true);\n            }\n            return true;\n          }\n          swap(S, c1, a, b);\n        }\n      }\n  // Neither worked (Heawood's case or worse). While remembered borders are in\n  // the graph, the caller forgets them and asks again; on the map as it is, a\n  // short local search: each step takes a country in conflict and gives it\n  // the colour fewest of its neighbours have.\n  if (!last) {\n    if (show) st.repairs--;\n    return false;\n  }\n  if (show) st.local++;\n  const n = S.n, col = S.col.slice(0, n);\n  for (let step = 0; step \u003c 4000; step++) {\n    const bad = [];\n    for (let i = 0; i \u003c n; i++) {\n      if (S.area[i] === 0 && col[i] \u003c 4) continue;\n      if (col[i] > 3) {\n        bad.push(i);\n        continue;\n      }\n      for (let j = 0; j \u003c n; j++) if (S.act[i * M + j] && col[j] === col[i]) {\n        bad.push(i);\n        break;\n      }\n    }\n    if (!bad.length) {\n      for (let i = 0; i \u003c n; i++) if (col[i] !== S.col[i]) paint(S, i, col[i], show, 0.6);\n      return true;\n    }\n    const i = bad[floor(Math.random() * bad.length)], cnt = [0, 0, 0, 0];\n    for (let j = 0; j \u003c n; j++) if (S.act[i * M + j] && col[j] \u003c 4) cnt[col[j]]++;\n    let bc = 0;\n    if (Math.random() \u003c 0.15) bc = floor(Math.random() * 4);\n    else for (let c = 1; c \u003c 4; c++) if (cnt[c] \u003c cnt[bc] || (cnt[c] === cnt[bc] && Math.random() \u003c 0.5)) bc = c;\n    col[i] = bc;\n  }\n  if (show) st.failed++;\n  return false;\n}\n\nfunction repairAll(S, show) {\n  const n = S.n, col = S.col, act = S.act;\n  for (let guard = 0, forgot = false; guard \u003c 120; guard++) {\n    let u = -1, v = -1;\n    for (let i = 0; i \u003c n && v \u003c 0; i++) if (col[i] > 3 && S.area[i] > 0) v = i;\n    for (let i = 0; i \u003c n && v \u003c 0; i++)\n      for (let j = i + 1; j \u003c n; j++)\n        if (act[i * M + j] && col[i] === col[j]) {\n          // Recolour the smaller of the two first.\n          [u, v] = S.area[i] \u003c S.area[j] ? [j, i] : [i, j];\n          break;\n        }\n    if (v \u003c 0) return;\n    let mem = false;\n    for (let k = 0; k \u003c M * M && !mem; k++) if (act[k] && !S.cur[k]) mem = true;\n    if (repair(S, u, v, show, forgot || !mem)) continue;\n    // Kempe's moves found nothing on the graph with the remembered borders in\n    // it, which need not be planar: two countries touched a moment ago that\n    // no longer do, and the map has closed round them. Forget every border\n    // not on the map now and repair again on the map as it is.\n    if (forgot) return;\n    forgot = true;\n    if (show) S.stats.forget++;\n    for (let k = 0; k \u003c M * M; k++) if (!S.cur[k]) (S.seen[k] = -1e9), (act[k] = 0);\n  }\n}\n\n// The opening. The drift is worked out 1.9 drift seconds ahead, and the first\n// colouring is chosen so that one of the first six borders to appear after\n// 0.6 s joins two countries of one colour, each already ringed by the other\n// three colours: no free colour is left for either, so the first repair needs\n// a chain. Borders that appear before it get proper colours from the start.\n// If no such colouring turns up, the first new border at least joins one\n// colour, and if there is none the map is coloured plainly.\nfunction opening(S, ds) {\n  const n = S.n, keep = [S.x, S.y, S.vx, S.vy].map((a) => a.slice()), t0 = S.t, G0 = S.cur.slice();\n  const pre = S.cur.slice(), first = new Float32Array(M * M).fill(-1), acts = [];\n  for (let k = 1; S.t \u003c t0 + 1.9; k++) {\n    move(S, ds, true);\n    S.t += ds;\n    map(S);\n    acts.push(S.act.slice());\n    for (let i = 0; i \u003c n; i++)\n      for (let j = i + 1; j \u003c n; j++) if (S.cur[i * M + j] && !G0[i * M + j] && first[i * M + j] \u003c 0) first[i * M + j] = S.t - t0;\n  }\n  [S.x, S.y, S.vx, S.vy].forEach((a, i) => a.set(keep[i]));\n  S.t = t0;\n  S.seen.fill(-1e9);\n  map(S);\n  const cands = [];\n  for (let k = 0; k \u003c M * M; k++) if (first[k] >= 0.6) cands.push(k);\n  cands.sort((a, b) => first[a] - first[b]);\n  for (const k of cands.slice(0, 6)) {\n    const c = floor(k / M), d = k % M, step = round(first[k] / ds) - 1, Gt = acts[min(acts.length - 1, step)];\n    // Every border seen before this one must be proper from the start.\n    pre.set(G0);\n    for (let q = 0; q \u003c M * M; q++) if (first[q] >= 0 && first[q] \u003c first[k]) pre[q] = pre[(q % M) * M + floor(q / M)] = 1;\n    for (let tries = 0; tries \u003c 40; tries++) {\n      if (!colourWith(S, pre, c, d)) break;\n      let ok = true;\n      for (const x of [c, d]) {\n        let m = 0;\n        for (let j = 0; j \u003c n; j++) if (j !== c && j !== d && Gt[x * M + j]) m |= 1 \u003c\u003c S.col[j];\n        if ((m | (1 \u003c\u003c S.col[c])) !== 15) ok = false;\n      }\n      if (ok) return first[k];\n    }\n  }\n  // No such pair: at least let the first new border join one colour.\n  if (cands.length && colourWith(S, G0, floor(cands[0] / M), cands[0] % M)) return -first[cands[0]];\n  S.col.fill(255);\n  return 0;\n}\n\n// A random proper colouring of the graph g with c and d given one colour, by\n// backtracking over the countries in random order, most neighbours first.\nfunction colourWith(S, g, c, d) {\n  const n = S.n, col = S.col, order = [];\n  for (let i = 0; i \u003c n; i++) if (i !== d) order.push(i);\n  const dg = new Float32Array(M);\n  for (const i of order) {\n    for (let j = 0; j \u003c n; j++) dg[i] += g[i * M + j] + (i === c ? g[d * M + j] : 0);\n    dg[i] += Math.random();\n  }\n  order.sort((a, b) => dg[b] - dg[a]);\n  col.fill(255);\n  let budget = 5000;\n  const fits = (i, k) => {\n    for (let j = 0; j \u003c n; j++) if (col[j] === k && (g[i * M + j] || (i === c && g[d * M + j]))) return false;\n    return true;\n  };\n  const go = (q) => {\n    if (q === order.length) return true;\n    if (--budget \u003c 0) return false;\n    const i = order[q], o = floor(Math.random() * 4);\n    for (let e = 0; e \u003c 4; e++) {\n      const k = (o + e) % 4;\n      if (!fits(i, k)) continue;\n      col[i] = k;\n      if (i === c) col[d] = k;\n      if (go(q + 1)) return true;\n    }\n    col[i] = 255;\n    if (i === c) col[d] = 255;\n    return false;\n  };\n  return go(0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 15, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.sizes = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 15, 40)), ds = (d * S.speed) / 2;\n  S.clock += d;\n  for (let c = 0; c \u003c 4; c++) hsv(S.hue + 0.075 + c / 4, 0.72, 0.92, S.pal, 3 * c);\n  if (!S.started) {\n    S.started = true;\n    S.n = n;\n    for (let i = 0; i \u003c n; i++) addSeed(S, i);\n    // Spread the capitals out before the first frame.\n    for (let i = 0; i \u003c 25; i++) move(S, 0.05, false);\n    move(S, 0, true);\n    map(S);\n    S.plan = opening(S, (S.speed / 2) / 30);\n    repairAll(S, false);\n  } else {\n    if (n > S.n) for (let i = S.n; i \u003c n; i++) addSeed(S, i);\n    S.n = n;\n    move(S, ds, true);\n    S.t += ds;\n    map(S);\n    repairAll(S, true);\n  }\n  // Count the frames whose map, as it is drawn, is properly four-coloured.\n  const st = S.stats;\n  let ok = true;\n  for (let i = 0; i \u003c S.n && ok; i++) {\n    if (S.area[i] > 0 && S.col[i] > 3) ok = false;\n    for (let j = i + 1; j \u003c S.n; j++) if (S.cur[i * M + j] && S.col[i] === S.col[j]) ok = false;\n  }\n  st.frames++;\n  if (ok) st.proper++;\n  for (let i = 0; i \u003c M; i++) S.age[i] = min(LIFE, S.age[i] + d);\n  for (const e of S.ev) e.age += d;\n  S.ev = S.ev.filter((e) => e.age \u003c LIFE);\n}\n\n// A glow envelope over a repair's life: up in RISE, held, down in FALL.\nconst env = (a) => (a \u003c RISE ? a / RISE : a > LIFE - FALL ? max(0, (LIFE - a) / FALL) : 1);\n// Channels in steps of 4 of 255, so flat countries stay flat.\nconst q = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\nfunction line(ov, x0, y0, x1, y1, a) {\n  const steps = max(1, round(max(abs(x1 - x0), abs(y1 - y0))));\n  for (let s = 0; s \u003c= steps; s++) {\n    const px = floor(x0 + ((x1 - x0) * s) / steps), py = floor(y0 + ((y1 - y0) * s) / steps);\n    if (px >= 0 && px \u003c W && py >= 0 && py \u003c H) ov[py * W + px] = max(ov[py * W + px], a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { own, disp, ov, cx, cy, gl, age } = S;\n  for (let i = 0; i \u003c S.n; i++) shown(S, i, disp, 3 * i);\n  ov.fill(0);\n  // The new border that started each repair flashes white; the chain's links run capital to capital.\n  const flash = new Float32Array(M * M);\n  for (const e of S.ev) {\n    const a = env(e.age);\n    if (e.a >= 0 && e.b >= 0) flash[e.a * M + e.b] = flash[e.b * M + e.a] = max(flash[e.a * M + e.b], a);\n    const L = e.links;\n    for (let i = 0; i \u003c L.length; i += 2) {\n      line(ov, cx[L[i]], cy[L[i]], cx[L[i + 1]], cy[L[i + 1]], a * 0.85);\n      for (const j of [L[i], L[i + 1]])\n        for (let dy = -1; dy \u003c= 0; dy++)\n          for (let dx = -1; dx \u003c= 0; dx++) {\n            const px = floor(cx[j]) + dx, py = floor(cy[j]) + dy;\n            if (px >= 0 && px \u003c W && py >= 0 && py \u003c H) ov[py * W + px] = max(ov[py * W + px], a);\n          }\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = own[p], r = x \u003c W - 1 ? own[p + 1] : o, b = y \u003c H - 1 ? own[p + W] : o;\n      let R, G, B;\n      if (r !== o || b !== o) {\n        // A dark border LED, white while its border is the new one.\n        const f = max(r !== o ? flash[o * M + r] : 0, b !== o ? flash[o * M + b] : 0);\n        R = G = B = f;\n        R += 0.07 * (1 - f);\n        G += 0.05 * (1 - f);\n        B += 0.09 * (1 - f);\n      } else {\n        const g = gl[o] * env(age[o]);\n        R = disp[3 * o] + (1 - disp[3 * o]) * g;\n        G = disp[3 * o + 1] + (1 - disp[3 * o + 1]) * g;\n        B = disp[3 * o + 2] + (1 - disp[3 * o + 2]) * g;\n      }\n      const v = ov[p];\n      if (v > 0) {\n        R += (1 - R) * v;\n        G += (1 - G) * v;\n        B += (1 - B) * v;\n      }\n      display.setPixel(x, y, q(R), q(G), q(B));\n    }\n}\n","music-box":"// ===== Patternflow pattern =====\n// Title:   Music Box\n// Family:  halloween\n// Idea:    A haunted music box on a velvet shelf: its brass cylinder turns and each pin plucks a steel tooth that flashes and rings, a skeleton ballerina in a tutu pirouettes on the spindle under a cone of moonlight, then the spring runs down, the melody drags to a stop with her facing us, a cloud covers the moon and her eye sockets glow green, until an unseen hand spins the key and it plays again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Velvet=0..1, Speed=0.2..3, Tune=0..1, Wind=0..1\n//\n// Knob 1: Velvet. The colour of the velvet on the box, the lining behind the cylinder and the shelf, through the cold hues only so it never turns brown: purple at 0, blue at 0.33, teal at 0.67, poison green at 1. The brass, the steel, the bones and the moonlight stay as they are.\n// Knob 2: Speed. At 2 the waltz plays a beat every 0.42 seconds and the ballerina turns once a bar; at Wind 0.06 a wind plays 4.8 seconds at full tempo and then runs down over 1.2 to 4.2, as long as it takes her to stop facing us; the eyes glow for 2.2 and the key spins for 1.5. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Tune. Which of three A minor melodies is on the box, each on its own cylinder with its own dance: below 1/3 a waltz with an oom-pah-pah bass on brass, the ballerina in lilac with her arms rounded overhead; from 1/3 a slow lullaby on nickel silver, a pale blue tutu and the arms open wide; from 2/3 a brisk minuet on blackened steel, a black tutu edged in orange and the arms low in front. She turns once a bar of each tune's tempo.\n// Knob 4: Wind. How far the key is wound, so how long the box plays at full tempo before it runs down: 0.8 seconds at 0, 4.8 at 0.06, 9 at 0.25, 17.2 at 1.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The box, front on: its top from row 60 to the brass front edge at 66,\n// the velvet front to 115, the shelf below. A glass window shows the\n// cylinder (rows 71 to 87) and the comb whose 13 teeth hang from row 88.\nconst TOP = 60, RIM = 66, BOT = 115, BX0 = 2, BX1 = 57;\nconst WX0 = 6, WX1 = 53, WY0 = 69, WY1 = 106;\nconst CX0 = 9, CX1 = 50, CY = 79, CR = 8;\nconst TEETH = 13, TX = 11, TIP = 88, PLATE = 103;\nconst toothLen = (i) => round(15 - 0.55 * i);\n// The spindle and the ballerina's toe, the key on the box's right side.\nconst SPX = 30, TOE = 58, KX = 60, KY = 92;\n// The run-down's share of a wind, the glow and the winding, in seconds.\nconst SLOW = 1.8, GLOW = 2.2, WIND = 1.5;\n// The cloud's puffs: offset across, offset down, radius.\nconst PUFFS = [[-13, 4, 4.5], [-7, 2, 6.5], [0, 0, 8], [7.5, 2, 6.5], [13, 5, 4.5]], CLOUD = [0.13, 0.1, 0.2], CLOUD_RIM = [0.36, 0.33, 0.5];\n// A cylinder for each tune, five shades and its pins: brass with steel pins,\n// nickel silver with brass ones, blackened steel with silver ones.\nconst METALS = [\n  [[[0.76, 0.48, 0.08], [0.88, 0.6, 0.12], [0.96, 0.72, 0.2], [1, 0.84, 0.36], [1, 0.93, 0.62]], [1, 0.97, 0.86]],\n  [[[0.42, 0.45, 0.52], [0.58, 0.62, 0.7], [0.72, 0.76, 0.84], [0.86, 0.9, 0.96], [0.97, 0.98, 1]], [1, 0.78, 0.25]],\n  [[[0.1, 0.1, 0.14], [0.17, 0.17, 0.23], [0.25, 0.26, 0.33], [0.36, 0.37, 0.46], [0.55, 0.56, 0.66]], [0.95, 0.96, 1]],\n];\n// And a tutu for each: lilac tulle, pale ghostly blue, black edged in orange.\nconst TUTUS = [\n  [[0.55, 0.4, 0.7], [0.78, 0.62, 0.9], [0.95, 0.85, 1]],\n  [[0.5, 0.62, 0.75], [0.72, 0.84, 0.95], [0.93, 0.98, 1]],\n  [[0.1, 0.06, 0.12], [0.24, 0.16, 0.28], [1, 0.55, 0.1]],\n];\n\n// The comb, low to high: A3 B3 C4 D4 E4 F4 G#4 A4 B4 C5 D5 E5 F5, A minor\n// with the raised seventh. Each tune is 8 bars of 3 beats, one turn of the\n// cylinder, written as [beat, tooth] pins, and its beat in story seconds.\nconst TUNES = [\n  // Waltz: bass on the bar, a chord tone on beats 2 and 3, the tune on top.\n  {\n    beat: 0.42,\n    bass: [[0, 4, 4], [1, 3, 3], [1, 3, 3], [0, 4, 4], [3, 5, 5], [0, 4, 4], [1, 3, 3], [0, 4, 4]],\n    tune: [[0, 11], [2, 9], [3, 8], [4, 9], [5, 8], [6, 6], [8, 4], [9, 7], [12, 12], [14, 10], [15, 9], [16, 10], [17, 9], [18, 8], [19, 6], [20, 8], [21, 7]],\n  },\n  // Lullaby: slow, the bass and one tone a bar, the tune in long notes.\n  {\n    beat: 0.55,\n    bass: [[0, 2, -1], [1, 3, -1], [0, 4, -1], [3, 5, -1], [3, 5, -1], [0, 2, -1], [1, 3, -1], [0, 4, -1]],\n    tune: [[0, 7], [2, 9], [3, 8], [5, 6], [6, 7], [8, 4], [9, 5], [12, 10], [14, 12], [15, 11], [17, 9], [18, 8], [20, 6], [21, 7]],\n  },\n  // Minuet: brisk, a note on every beat.\n  {\n    beat: 0.32,\n    bass: [[0, -1, -1], [3, -1, -1], [0, -1, -1], [1, -1, -1], [3, -1, -1], [0, -1, -1], [1, -1, -1], [0, -1, -1]],\n    tune: [7, 9, 11, 10, 9, 8, 9, 7, 4, 6, 8, 11, 12, 11, 10, 9, 8, 7, 8, 6, 4, 7, -1, 11].map((t, b) => [b, t]).filter((q) => q[1] >= 0),\n  },\n];\n// Every pin of a tune, sorted by beat.\nconst PINS = TUNES.map((T) => {\n  const p = T.tune.slice();\n  T.bass.forEach(([b, c1, c2], bar) => {\n    p.push([bar * 3, b]);\n    if (c1 >= 0) p.push([bar * 3 + 1, c1]);\n    if (c2 >= 0) p.push([bar * 3 + 2, c2]);\n  });\n  return p.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n});\n\n// The ballerina in her own frame, y up from the toe, z toward us when she\n// faces us: standing leg en pointe, the other drawn up in retire with its\n// knee turned out, arms rounded overhead. One unit is SC LEDs.\nconst J = {\n  toe: [0, 0, 0], ank: [-0.1, 2.5, 0], kn: [-0.5, 9.5, 0], hipS: [-1.2, 16.6, 0],\n  hipW: [1.2, 16.6, 0], knW: [6.8, 12.6, 1.4], ftW: [-0.1, 10.2, 1.1],\n  waist: [0, 18.2, 0], chest: [0, 26, 0], neck: [0, 29.4, 0], head: [0, 33, 0.2],\n  shL: [-3.6, 27, 0], shR: [3.6, 27, 0], elL: [-6.4, 31.8, 0.9], elR: [6.4, 31.8, 0.9], haL: [-1.4, 38.2, 1.1], haR: [1.4, 38.2, 1.1],\n};\n// The other two dances: the lullaby's attitude, the leg lifted behind and\n// the arms open to the sides; the minuet's arms rounded low in front.\nconst POSES = [\n  {},\n  { knW: [2.4, 16.4, -7.2], ftW: [3.6, 20.6, -11.4], elL: [-8.2, 28.4, 0.6], elR: [8.2, 28.4, 0.6], haL: [-12.6, 29.8, 0], haR: [12.6, 29.8, 0] },\n  { elL: [-5.6, 23.6, 2.6], elR: [5.6, 23.6, 2.6], haL: [-1.6, 21.6, 4.6], haR: [1.6, 21.6, 4.6] },\n];\nconst SC = 1.3, ELEV = 0.28, CE = cos(ELEV), SE = sin(ELEV), HEAD_R = 3.5, TUTU_Y = 17.6, TUTU_R = 9.5;\nconst RIBS = [[20.8, 2.3], [22.4, 2.9], [24, 3.1], [25.6, 2.9]];\n\n// The cloud's shape, 40 by 12 about its middle: 1 inside a puff, 2 on a\n// lower rim not covered by another puff.\nfunction cloudMask() {\n  const m = new Uint8Array(40 * 12);\n  for (let y = 0; y \u003c 12; y++)\n    for (let j = 0; j \u003c 40; j++) {\n      let inside = false, deep = false;\n      for (const [dx, dy, r] of PUFFS) {\n        const d = Math.hypot(j + 0.5 - 20 - dx, y + 0.5 - dy);\n        if (d \u003c r) (inside = true), (deep = deep || d \u003c r - 1.2);\n      }\n      if (inside) m[y * 40 + j] = !deep && y > 3 ? 2 : 1;\n    }\n  return m;\n}\n\n// The tutu's LEDs: for each, where it meets each of the three layers of the\n// disc, as a radius and an angle in the room; turning her only adds phi.\nfunction tutuMap() {\n  const out = [], yc = floor(TOE + 0.5 - SC * TUTU_Y * CE), RM = TUTU_R + 0.7;\n  for (let y = yc - 6; y \u003c= yc + 6; y++)\n    for (let x = SPX - 14; x \u003c= SPX + 15; x++) {\n      const xr = (x + 0.5 - SPX - 0.5) / SC, layers = [];\n      for (const h of [TUTU_Y - 0.7, TUTU_Y, TUTU_Y + 0.7]) {\n        const zr = ((y + 0.5 - TOE - 0.5) / SC + h * CE) / SE, r = Math.hypot(xr, zr);\n        if (r \u003c RM) layers.push(r, atan2(zr, xr));\n      }\n      if (layers.length) out.push([x, y, layers]);\n    }\n  return out;\n}\n\nexport function setup(params) {\n  const motes = [];\n  for (let i = 0; i \u003c 18; i++) motes.push([Math.random(), Math.random() * 58, 1.5 + 2.5 * Math.random(), Math.random() * TAU]);\n  params.s = {\n    rgb: new Float32Array(N * 3), cloudMask: cloudMask(), tutu: tutuMap(), motes, started: false,\n    hue: 0.5, speed: 1.5, tuneI: 0, wind: 0.06, t: 0.5,\n    phase: \"play\", ph: 0.5, tau: 4.5, beat: 0.5, phi: 0.5, phiA: 0.5, D: 1.5,\n    key: 0.5, amp: 0.5, cloud: 0.5, ring: new Float32Array(TEETH), wave: new Float32Array(TEETH), spark: new Float32Array(TEETH), eyes: 0.5,\n  };\n}\n\n// Seconds of play a wind gives, the run-down included.\nconst runFor = (w) => 2.6 + 16.4 * sqrt(w);\n// Full tempo while playing; in the run-down it falls as (left / D)^0.8.\nconst tempo = (S) => (S.phase === \"play\" ? 1 : S.phase === \"slow\" ? (max(0, S.D - S.ph) / S.D) ** 0.8 : 0);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tuneI = min(2, floor(cl(k[2], 0, 1) * 3));\n  S.wind = cl(k[3], 0, 1);\n  const T = TUNES[S.tuneI], pins = PINS[S.tuneI], g = (d * S.speed) / 2;\n  if (!S.started) {\n    // The first pin plucks a quarter second in, the ballerina already turning.\n    S.started = true;\n    S.tau = runFor(S.wind) - SLOW;\n    S.beat = 24 - 0.25 / T.beat;\n    S.phi = 0;\n    S.ph = 0;\n    S.t = 0;\n  }\n  S.t += g;\n  S.ph += g;\n  const f = tempo(S), om = TAU / (3 * T.beat);\n  if (S.phase === \"play\" || S.phase === \"slow\") {\n    // The cylinder: beats go by at the tempo, and every pin passed plucks.\n    const b0 = S.beat, b1 = b0 + (g * f) / T.beat;\n    for (const [b, tooth] of pins) {\n      const at = b \u003c b0 ? b + 24 : b;\n      if (at > b0 && at \u003c= b1) (S.ring[tooth] = 1), (S.spark[tooth] = 1);\n    }\n    S.beat = b1 >= 24 ? b1 - 24 : b1;\n    S.key += 0.6 * f * g;\n  }\n  if (S.phase === \"play\") {\n    S.phi += om * g;\n    S.tau -= g;\n    if (S.tau \u003c= 0) {\n      // The run-down: she turns om D / 1.8 more as the tempo falls to 0 over\n      // D seconds, so D is chosen to end that on a whole turn, facing us,\n      // and at least 1.2 seconds long.\n      const k = Math.ceil((S.phi + (1.2 * om) / 1.8) / TAU);\n      (S.phase = \"slow\"), (S.ph = 0), (S.phiA = S.phi), (S.D = (1.8 * (TAU * k - S.phi)) / om);\n    }\n  } else if (S.phase === \"slow\") {\n    const u = min(S.ph, S.D);\n    S.phi = S.phiA + ((om * S.D) / 1.8) * (1 - ((S.D - u) / S.D) ** 1.8);\n    if (S.ph >= S.D) (S.phi = 0), (S.phase = \"glow\"), (S.ph = 0);\n  } else if (S.phase === \"glow\" && S.ph >= GLOW) (S.phase = \"wind\"), (S.ph = 0);\n  else if (S.phase === \"wind\") {\n    // Two and a half turns of the key, eased in and out.\n    S.key += ((2.5 * TAU) / WIND) * 2 * (1 - abs(2 * (S.ph / WIND) - 1)) * g;\n    if (S.ph >= WIND) (S.phase = \"play\"), (S.ph = 0), (S.tau = runFor(S.wind) - SLOW);\n  }\n  // Teeth ring and fade; the ripple along a tooth runs at its pitch, and\n  // drags lower as the tempo falls, so the box goes flat as it stops.\n  for (let i = 0; i \u003c TEETH; i++) {\n    S.ring[i] *= exp(-g / 0.5);\n    S.spark[i] *= exp(-g / 0.07);\n    S.wave[i] += g * (14 + 2.2 * i) * (0.35 + 0.65 * f);\n  }\n  // The moonlight swells a little with each note.\n  let amp = 0;\n  for (let i = 0; i \u003c TEETH; i++) amp = max(amp, S.ring[i]);\n  S.amp = amp * f;\n  const eyeT = S.phase === \"glow\" ? smooth(S.ph / 0.6) : S.phase === \"wind\" ? 1 - smooth(S.ph / 0.7) : 0;\n  S.eyes = eyeT * (0.82 + 0.18 * sin(S.t * 23) * sin(S.t * 7.7));\n  // A cloud over the moon: it slides off as the box first plays, drifts back\n  // as the spring runs down, covers the moon while the eyes glow and slides\n  // off again while the key turns.\n  const run = S.phase === \"play\" || S.phase === \"slow\" ? 1 - f : S.phase === \"glow\" ? 1 : 1 - smooth(S.ph / WIND);\n  S.cloud = max(run, 1 - smooth(S.t / 1.2));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const rgb = S.rgb;\n  const put = (x, y, c, a = 1) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    if (a >= 1) (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n    else (rgb[o] = mix(rgb[o], c[0], a)), (rgb[o + 1] = mix(rgb[o + 1], c[1], a)), (rgb[o + 2] = mix(rgb[o + 2], c[2], a));\n  };\n  const line = (x0, y0, x1, y1, c) => {\n    const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n    for (let j = 0; j \u003c= n; j++) put(x0 + ((x1 - x0) * j) / n, y0 + ((y1 - y0) * j) / n, c);\n  };\n  // The moonlight: a quarter of itself behind the cloud, swelling a little\n  // on each note while the moon is clear.\n  const cv = S.cloud, dim = 1 - 0.75 * cv + 0.15 * S.amp * (1 - cv);\n  // The velvet's shades this frame: the front's sheen, the moonlit top, the\n  // shelf and the lining.\n  const vel = (v, sat = 0.78) => hsv(0.78 - 0.45 * S.hue, sat, v);\n  const sheen = [0, 1, 2, 3].map((k) => vel(0.42 + (0.16 * k) / 3));\n  const topC = [vel(0.82 * dim, 0.55), vel(0.62 * dim), vel(0.45)], shelfC = [vel(0.3, 0.7), vel(0.5, 0.7), vel(0.22, 0.7)], lining = vel(0.16, 0.85);\n\n  // A run of one colour along a row, written straight into the frame.\n  const span = (y, x0, x1, c) => {\n    x0 = max(0, x0);\n    x1 = min(W - 1, x1);\n    for (let o = (y * W + x0) * 3, e = (y * W + x1) * 3; o \u003c= e; o += 3) (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n  };\n  // The room: near-black violet, the moon peeking in at the top and its\n  // cone in three bands.\n  const room = [0.035, 0.012, 0.06], cone = [0.17, 0.25, 0.34].map((a) => [0.55 * a * dim + 0.03, 0.55 * a * dim + 0.01, 0.85 * a * dim + 0.05]);\n  for (let y = 0; y \u003c H; y++) span(y, 0, W - 1, room);\n  for (let y = 0; y \u003c TOP; y++) {\n    const hw = 8 + 0.3 * y;\n    for (let b = 0; b \u003c 3; b++) {\n      const e = [1, 0.75, 0.45][b] * hw;\n      span(y, Math.ceil(SPX - e - 0.5), floor(SPX + e - 0.5), cone[b]);\n    }\n  }\n  for (let y = 0; y \u003c 8; y++)\n    for (let x = SPX - 10; x \u003c= SPX + 10; x++) {\n      const mx = x + 0.5 - SPX, my = y + 0.5 + 3, mr = mx * mx + my * my;\n      if (mr >= 100) continue;\n      const crater = (mx + 3) ** 2 + (my - 3) ** 2 \u003c 6 || (mx - 4) ** 2 + (my - 5) ** 2 \u003c 3, c = crater ? 0.78 : mr > 80 ? 0.86 : 0.95;\n      put(x, y, [c, c, c + 0.05]);\n    }\n  // The cloud: dark puffs with a rim lit by the moon behind them.\n  const cx = round(SPX + 52 * (1 - smooth(cv)));\n  for (let y = 0; y \u003c 12; y++)\n    for (let j = 0; j \u003c 40; j++) {\n      const m = S.cloudMask[y * 40 + j];\n      if (m) put(cx - 20 + j, y, m === 2 ? CLOUD_RIM : CLOUD);\n    }\n  // Dust in the beam, drifting down and twinkling.\n  for (const m of S.motes) {\n    const y = (m[1] + S.t * m[2]) % 58, hw = 8 + 0.3 * y, x = SPX + (m[0] * 2 - 1) * hw * 0.85;\n    const a = (0.35 + 0.35 * sin(S.t * 3 + m[3])) * dim;\n    if (a > 0.2) put(x, y + 10, [0.6 + a * 0.4, 0.6 + a * 0.4, 0.75 + a * 0.25], 0.6);\n  }\n\n  // The box top, in perspective, lit in a pool round the spindle.\n  for (let y = TOP; y \u003c RIM; y++) {\n    const inset = (RIM - 1 - y) * 0.6;\n    for (let x = floor(BX0 + inset); x \u003c= BX1 - inset; x++) {\n      const px = (x + 0.5 - SPX) / 22, py = (y + 0.5 - 62.5) / 3.2, pool = px * px + py * py;\n      put(x, y, topC[pool \u003c 0.35 ? 0 : pool \u003c 1 ? 1 : 2]);\n    }\n  }\n  const brass = METALS[0][0];\n  line(BX0, RIM, BX1, RIM, brass[3]);\n  // The front: velvet with a sheen in four steps, brass trim at the edges.\n  for (let x = BX0; x \u003c= BX1; x++) {\n    const c = sheen[min(3, floor(4 * (0.5 + 0.5 * cos((x - 14) / 9))))];\n    for (let y = RIM + 1; y \u003c= BOT; y++) put(x, y, c);\n  }\n  line(BX0, RIM + 1, BX0, BOT, brass[2]);\n  line(BX1, RIM + 1, BX1, BOT, brass[1]);\n  line(BX0, BOT, BX1, BOT, brass[1]);\n  // The shelf.\n  for (let y = BOT + 1; y \u003c H; y++) span(y, 0, W - 1, shelfC[y \u003c BOT + 4 ? 0 : y === BOT + 4 ? 1 : 2]);\n  // The window: dark lining, brass frame.\n  for (let y = WY0 + 1; y \u003c WY1; y++) span(y, WX0 + 1, WX1 - 1, lining);\n  line(WX0, WY0, WX1, WY0, brass[3]);\n  line(WX0, WY1, WX1, WY1, brass[1]);\n  line(WX0, WY0, WX0, WY1, brass[2]);\n  line(WX1, WY0, WX1, WY1, brass[1]);\n\n  // The cylinder, shaded in five steps from its highlight above the middle.\n  const [metal, pinC] = METALS[S.tuneI];\n  for (let y = CY - CR; y \u003c= CY + CR - 1; y++) {\n    const v = (y + 0.5 - CY) / CR, lv = v \u003c -0.82 ? 1 : v \u003c -0.5 ? 3 : v \u003c -0.2 ? 4 : v \u003c 0.45 ? 2 : v \u003c 0.8 ? 1 : 0;\n    span(y, CX0, CX1, metal[lv]);\n    put(CX0 - 2, y, brass[max(0, lv - 1)]);\n    put(CX0 - 1, y, brass[max(0, lv - 1)]);\n    put(CX1 + 1, y, brass[max(0, lv - 1)]);\n    // A gear on the right end, its teeth running with the cylinder.\n    const gt = floor(y + S.beat * 3) % 2 === 0;\n    put(CX1 + 2, y, brass[gt ? 3 : 1]);\n  }\n  // The pins: from the top edge, coming round from behind, down to the\n  // bottom edge, where each one plucks its tooth.\n  const pins = PINS[S.tuneI], silver = pinC, shadow = metal[0];\n  for (const [b, tooth] of pins) {\n    let a = b - S.beat;\n    if (a \u003c 0) a += 24;\n    if (a > 12) continue;\n    const y = CY + CR * cos((PI * a) / 12) - 0.5, x = TX + 3 * tooth;\n    if (a > 0.6 && a \u003c 11.4) (put(x, y + 1, shadow), put(x + 1, y + 1, shadow));\n    const c = S.spark[tooth] > 0.3 && a \u003c 0.6 ? [1, 1, 1] : silver;\n    put(x, y, c);\n    put(x + 1, y, c);\n  }\n  // The comb: a steel plate under slanted roots, a tooth for each note.\n  const steel = [0.5, 0.56, 0.7], steelHi = [0.72, 0.78, 0.9], plate = [0.3, 0.33, 0.45], bright = [0.88, 0.97, 1];\n  const glowC = [0.3, 0.55, 0.85], white = [1, 1, 1];\n  for (let i = 0; i \u003c TEETH; i++) {\n    const x = TX + 3 * i, root = TIP + toothLen(i);\n    for (let y = root; y \u003c= PLATE; y++) for (let dx = -1; dx \u003c= 2; dx++) put(x + dx, y, plate);\n    // A ringing tooth flashes, bright and half bright bands running down it.\n    const r = S.ring[i], hq = floor(r * 3) / 3;\n    const tone = (c, a) => (a > 0.05 ? [mix(c[0], bright[0], a), mix(c[1], bright[1], a), mix(c[2], bright[2], a)] : c);\n    const hiA = tone(steelHi, r), hiB = tone(steelHi, r / 2), loA = tone(steel, r), loB = tone(steel, r / 2);\n    for (let y = TIP; y \u003c root; y++) {\n      const band = sin((y - TIP) * 1.3 - S.wave[i]) > 0;\n      put(x, y, band ? hiA : hiB);\n      put(x + 1, y, band ? loA : loB);\n      // The ringing glows into the gaps either side, in three steps.\n      if (hq > 0) (put(x - 1, y, glowC, hq * 0.8), put(x + 2, y, glowC, hq * 0.8));\n    }\n    if (S.spark[i] > 0.3) put(x, TIP, white), put(x + 1, TIP, white);\n  }\n  for (const sx of [TX + 4, TX + 31]) put(sx, PLATE - 1, brass[4]);\n\n  // The key on the right side: a brass shaft and two wings turning about it,\n  // seen edge on, so they swing between full height and a sliver.\n  line(BX1 + 1, KY, KX, KY, brass[2]);\n  const kc = cos(S.key), ks = abs(sin(S.key));\n  for (const sg of [-1, 1]) {\n    const ext = 5.5 * kc * sg, n = Math.ceil(abs(ext));\n    for (let j = 1; j \u003c= n; j++) {\n      const u = j / (n + 0.5), hw = 1.6 * sin(PI * (0.25 + 0.75 * u));\n      for (let dx = -1; dx \u003c= 1; dx++) if (abs(dx) \u003c= hw) put(KX + 1 + dx, KY - Math.sign(ext) * j, brass[ks > 0.7 ? 2 : abs(kc) > 0.7 ? 4 : 3]);\n    }\n  }\n  put(KX + 1, KY, brass[4]);\n  // While it winds, a pale green glow where a hand would be.\n  if (S.phase === \"wind\") {\n    const a = 0.45 * sin((PI * S.ph) / WIND);\n    for (let y = KY - 7; y \u003c= KY + 7; y++)\n      for (let x = KX - 2; x \u003c W; x++) {\n        const e = ((x - KX - 1) / 3.5) ** 2 + ((y - KY) / 7.5) ** 2;\n        if (e \u003c 1) put(x, y, [0.35, 0.95, 0.45], a * (e \u003c 0.4 ? 0.6 : 0.3));\n      }\n  }\n\n  // The spindle and the ballerina.\n  line(SPX, TOE + 1, SPX, 62, brass[3]);\n  dancer(S, put, line);\n\n  const q = (v) => (v >= 1 ? 255 : v \u003c= 0 ? 0 : (v * 255) | 0);\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, q(rgb[o]), q(rgb[o + 1]), q(rgb[o + 2]));\n}\n\n// The skeleton ballerina, turned by phi about her standing toe and seen a\n// little from above: legs first, then the tutu, then the upper body and the\n// skull from back to front.\nfunction dancer(S, put, line) {\n  const phi = S.phi, c = cos(phi), s = sin(phi), Q = { ...J, ...POSES[S.tuneI] };\n  const P = (p) => {\n    const x = p[0] * c + p[2] * s, z = -p[0] * s + p[2] * c;\n    return [SPX + 0.5 + SC * x, TOE + 0.5 - SC * (p[1] * CE - z * SE), z];\n  };\n  // Lit by the moon: half as bright while the cloud covers it.\n  const L = 1 - 0.5 * S.cloud, lit = (c) => [c[0] * L, c[1] * L, c[2] * L];\n  const bone = lit([0.96, 0.93, 0.84]), boneLo = lit([0.7, 0.66, 0.62]), pink = lit([1, 0.62, 0.75]);\n  // A bone; a wide one is two LEDs thick, doubled across its length.\n  const seg = (a, b, col, wide) => {\n    const A = P(a), B = P(b);\n    line(A[0], A[1], B[0], B[1], col);\n    if (wide) abs(B[0] - A[0]) \u003c abs(B[1] - A[1]) ? line(A[0] + 1, A[1], B[0] + 1, B[1], col) : line(A[0], A[1] + 1, B[0], B[1] + 1, col);\n  };\n  // Legs: the back one first.\n  const legS = [[Q.toe, Q.ank, pink], [Q.ank, Q.kn, bone], [Q.kn, Q.hipS, bone]];\n  const legW = [[Q.hipW, Q.knW, bone], [Q.knW, Q.ftW, bone]];\n  const zW = P(Q.knW)[2];\n  for (const L of zW \u003c 0 ? [legW, legS] : [legS, legW]) for (const [a, b, col] of L) seg(a, b, col, true);\n  const kn = P(Q.kn), kw = P(Q.knW);\n  put(kn[0], kn[1], boneLo);\n  put(kw[0], kw[1], boneLo);\n  // The tutu: three layers of a scalloped disc, pleats turning with her.\n  const [lilacLo, lilac, edge] = TUTUS[S.tuneI].map(lit);\n  for (const [x, y, layers] of S.tutu) {\n    let hit = -1;\n    for (let j = 0; j \u003c layers.length; j += 2) {\n      const beta = layers[j + 1] + phi, R = TUTU_R + 0.7 * cos(12 * beta);\n      if (layers[j] \u003c R) hit = max(hit, layers[j] > R - 1.2 ? 2 : (floor(((beta + PI) / TAU) * 16) % 2 + 2) % 2);\n    }\n    if (hit >= 0) put(x, y, hit === 2 ? edge : hit === 1 ? lilac : lilacLo);\n  }\n  // The upper body, sorted back to front.\n  const ribs = RIBS.map(([y, w]) => {\n    const pts = [];\n    for (let j = 0; j \u003c= 6; j++) {\n      const a = -PI / 2 + (PI * j) / 6;\n      pts.push([w * sin(a), y - 0.4 * cos(a), 0.7 * w * cos(a)]);\n    }\n    return pts;\n  });\n  const parts = [\n    { z: P(Q.chest)[2] - 0.2, draw: () => (seg(Q.waist, Q.chest, boneLo, true), seg(Q.chest, Q.neck, bone)) },\n    ...ribs.map((pts) => ({ z: P(pts[3])[2], draw: () => { for (let j = 0; j \u003c 6; j++) seg(pts[j], pts[j + 1], bone); } })),\n    { z: P(Q.neck)[2], draw: () => (seg(Q.shL, Q.neck, bone), seg(Q.neck, Q.shR, bone)) },\n    { z: P(Q.elL)[2], draw: () => (seg(Q.shL, Q.elL, bone, true), seg(Q.elL, Q.haL, bone)) },\n    { z: P(Q.elR)[2], draw: () => (seg(Q.shR, Q.elR, bone, true), seg(Q.elR, Q.haR, bone)) },\n    { z: 0.1, draw: () => skull(S, P, put, c, s) },\n  ].sort((a, b) => a.z - b.z);\n  for (const p of parts) p.draw();\n}\n\n// The skull: a round cranium and a narrower jaw, top lit by the moon; the\n// sockets, nose and teeth sit on its face and slide round as she turns.\nfunction skull(S, P, put, c, s) {\n  const H0 = P(J.head), r = HEAD_R * SC, L = 1 - 0.5 * S.cloud, dark = [0.06, 0.02, 0.09];\n  const bone = [0.96 * L, 0.93 * L, 0.84 * L], boneLo = [0.74 * L, 0.7 * L, 0.66 * L];\n  for (let y = floor(H0[1] - r - 1); y \u003c= H0[1] + r + 2; y++)\n    for (let x = floor(H0[0] - r - 1); x \u003c= H0[0] + r + 1; x++) {\n      const dx = x + 0.5 - H0[0], dy = y + 0.5 - H0[1];\n      const cran = dx * dx + dy * dy \u003c r * r, jaw = dy > 0 && dy \u003c r + 1.8 && abs(dx) \u003c r * 0.62;\n      if (cran || jaw) put(x, y, dy > r * 0.35 ? boneLo : bone);\n    }\n  // Face features in the head's frame: eyes, nose, the line of teeth.\n  const face = (fx, fy) => {\n    const p = [J.head[0] + fx, J.head[1] + fy, J.head[2] + sqrt(max(0, HEAD_R * HEAD_R - fx * fx - fy * fy * 0.6))];\n    const q = P(p);\n    return [q[0], q[1], -p[0] * s + p[2] * c];\n  };\n  const g = S.eyes, glow = [0.4, 1, 0.35], halo = [0.15, 0.6, 0.18];\n  for (const ex of [-1.3, 1.3]) {\n    const e = face(ex, 0.5);\n    if (e[2] \u003c 0.8) continue;\n    const wide = e[2] > 2.2 ? 2 : 1;\n    if (g > 0.05) for (let dy = -1; dy \u003c= 2; dy++) for (let dx = -1; dx \u003c= wide; dx++) put(e[0] + dx, e[1] + dy, halo, g * 0.55);\n    for (let dy = 0; dy \u003c= 1; dy++) for (let dx = 0; dx \u003c wide; dx++) put(e[0] + dx, e[1] + dy, g > 0.05 ? [mix(dark[0], glow[0], g), mix(dark[1], glow[1], g), mix(dark[2], glow[2], g)] : dark);\n  }\n  const n = face(0, -1.1);\n  if (n[2] > 0.8) put(n[0], n[1], dark);\n  for (const tx of [-1.2, 0, 1.2]) {\n    const t = face(tx, -2.6);\n    if (t[2] > 0.6) put(t[0], t[1], boneLo);\n  }\n}\n","party-lights":"// ===== Patternflow pattern =====\n// Title:   Party Lights\n// Family:  halloween\n// Idea:    Strings of big orange, purple, poison green and bone white bulbs sag across a dark porch wall at different heights down the panel, running a chase, a sparkle, a slow breath and a flash on the beat in turn, while gusts swing the strings like pendulums and a garland of black paper bats twists on its threads between the bulbs.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Warmth=-1..1, Speed=0.2..3, Strands=3..7, Gust=0..1\n//\n// Knob 1: Warmth. At 0 the bulbs are orange, purple, poison green and bone white in turn along each string; at 1 red orange, rose, amber and candle white, and the wall paint takes their light a little warmer; at -1 magenta, blue violet, aqua green and ice white on a colder wall. A dimmed bulb sinks to deep red, plum, dark green or lavender grey, never brown.\n// Knob 2: Speed. At 2 each program runs 4 seconds, in turn: a chase (one bulb in three lit, stepping 6 times a second, each string the other way), a sparkle (every bulb at two thirds, each flaring on its own 0.7 to 1.6 times a second), a breath (a 2.4 second swell rolling down the strings) and the beat (every bulb flashing together at 120 a minute, every fourth flash held twice as long). Gusts come every 5 seconds, the first at 1.7. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Strands. How many strings hang down the panel, 3 to 7, each slung from edge to edge with one end a few rows higher than the other: 3 sag 22 rows each, 7 sag 9 rows and fill the panel, and every string carries 6 bulbs 10 LEDs apart. The paper bats always hang from the second string.\n// Knob 4: Gust. The wind swings each string out of the wall like a pendulum, so it lifts, its low point slides sideways and the lower strings swing a little slower. At 0 the strings hang still; at 0.06 a breeze swings them up to 0.5 radians, lifting the sag by an eighth and sliding the low point 5 LEDs; at 1 each gust swings them past a radian, lifting them to a third of their sag and sliding the low point 11 LEDs, while the bulbs knock about and the bats spin on their threads.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, atan, tanh, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\nconst fr = (x) => x - floor(x);\n\n// The four bulbs, each lit and dimmed, at Warmth -1, 0 and 1. Dimmed, the\n// warm ones sink to red rather than brown.\nconst PAL = [\n  // orange\n  [[[0.95, 0.2, 0.9], [0.5, 0.04, 0.55]], [[1, 0.46, 0.02], [0.78, 0.1, 0.02]], [[1, 0.22, 0.02], [0.72, 0.04, 0.02]]],\n  // purple\n  [[[0.35, 0.3, 1], [0.14, 0.1, 0.7]], [[0.7, 0.2, 1], [0.42, 0.08, 0.72]], [[1, 0.12, 0.5], [0.68, 0.03, 0.3]]],\n  // poison green\n  [[[0.15, 1, 0.6], [0.03, 0.55, 0.3]], [[0.45, 1, 0.08], [0.12, 0.58, 0.04]], [[1, 0.72, 0.05], [0.75, 0.16, 0.02]]],\n  // bone white\n  [[[0.75, 0.9, 1], [0.35, 0.42, 0.62]], [[1, 0.95, 0.8], [0.55, 0.45, 0.62]], [[1, 0.82, 0.5], [0.72, 0.36, 0.2]]],\n];\n// A glass bulb hanging from its socket: half its width and length in LEDs,\n// and how far below the socket its middle hangs.\nconst BRX = 2.1, BRY = 3, BDY = 3.6;\n// A paper bat, 9 wide and 5 tall, its middle column at 4: ears, head,\n// wings with raised tips and a scalloped hem.\nconst BAT = [\"#..#.#..#\", \"##.###.##\", \"#########\", \".#######.\", \"..#.#.#..\"];\n// The light's rings round a bulb, radius in LEDs and share of the bulb's colour.\nconst RING = [[3.2, 0.45], [5.6, 0.3], [9, 0.2], [13, 0.1]];\n// The same as squared radii and the share inside each.\nconst RR = RING.map(([r]) => r * r), RS = RING.map((_, k) => RING.slice(k).reduce((s, q) => s + q[1], 0));\n// The programs, each this many story seconds; a chase steps this many times\n// a second; the beat is this long.\nconst PROG = 4, STEP = 6, BEAT = 0.5;\n// Gusts come every GUSTS seconds, the first at G0.\nconst GUSTS = 5, G0 = 2.2;\n\nexport function setup(params) {\n  // Each bulb's sparkle rate and phase, so they twinkle out of step.\n  const spark = [];\n  for (let i = 0; i \u003c 7 * 9; i++) spark.push([0.7 + 0.9 * Math.random(), Math.random()]);\n  params.s = {\n    warmth: 0.5, speed: 2, strands: 3, gust: 0.06, pt: 0.5,\n    phi: new Float64Array(7), dphi: new Float64Array(7), wind: 0.5, spark,\n    yw: new Float32Array(7 * W), light: new Float32Array(N * 3), rgb: new Float32Array(N * 3),\n    bulbs: [],\n  };\n}\n\n// Where a strand hangs. i of n, its anchors at the panel's edges, its sag,\n// and the lowest point pushed sideways and lifted as it swings out of the\n// wall by phi, seen through a soft limit so it never swings past 75 degrees.\nfunction strandY(S, i, n, x) {\n  const D = (H - 22) / n, yl = 5 + i * D + (i % 2 ? 5 : 0), yr = yl + (i % 2 ? -6 : 5), sag = 0.62 * D;\n  const ph = 1.3 * tanh(S.phi[i] / 1.3), u = (x + 0.5) / W, u0 = 0.5 + 0.18 * sin(ph), sg = sag * cos(ph);\n  const v = u \u003c u0 ? (u - u0) / u0 : (u - u0) / (1 - u0);\n  return mix(yl, yr, u) + sg * (1 - v * v);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.warmth = cl(k[0], -1, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.strands = round(cl(k[2], 3, 7));\n  S.gust = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.pt += ds;\n  // The wind: a breeze and a gust every few seconds, each a swell of about\n  // a second and a half.\n  const t = S.pt, gt = t - G0, gk = floor(gt / GUSTS + 0.5), dg = gt - gk * GUSTS;\n  S.wind = sqrt(S.gust) * (0.35 + 1.1 * exp(-((dg / 0.75) ** 2)) * (gk % 2 ? 0.75 : 1));\n  // Each strand swings out of the wall like a pendulum, the lower and\n  // longer ones slower, pushed by the wind and slowly damped.\n  for (let i = 0; i \u003c 7; i++) {\n    const w = TAU / (1.5 + 0.12 * i), steps = 3;\n    for (let s = 0; s \u003c steps; s++) {\n      const h = ds / steps, a = -w * w * S.phi[i] - 0.5 * w * S.dphi[i] + w * w * 1.1 * S.wind * (1 + 0.15 * sin(i * 1.7));\n      S.dphi[i] += a * h;\n      S.phi[i] = cl(S.phi[i] + S.dphi[i] * h, -3, 3);\n    }\n  }\n  const n = S.strands;\n  for (let i = 0; i \u003c n; i++) for (let x = 0; x \u003c W; x++) S.yw[i * W + x] = strandY(S, i, n, x);\n  // The program and how far into it: chase, sparkle, breath, beat, with a\n  // short cross-fade from the one before.\n  const pn = floor(t / PROG), pf = t - pn * PROG, p = pn % 4, q = (pn + 3) % 4, xf = pn > 0 ? ease(pf / 0.4) : 1;\n  const level = (pr, i, j) => {\n    if (pr === 0) {\n      // Chase: one bulb in three lit, stepping along, each strand the other way.\n      const st = floor(t * STEP);\n      return ((((i % 2 ? j : -j) + st + i) % 3) + 3) % 3 === 0 ? 1 : 0.25;\n    }\n    if (pr === 1) {\n      // Sparkle: every bulb two thirds lit, each flaring at its own times.\n      const [r, o] = S.spark[(i * 9 + j) % S.spark.length], f = fr(t * r + o);\n      return 0.68 + 0.32 * max(0, 1 - f * 5) ** 2;\n    }\n    if (pr === 2) return 0.4 + 0.6 * (0.5 + 0.5 * sin(TAU * (t / 2.4 - i * 0.11 - j * 0.03)));\n    // Beat: all strings flash together and hold, every fourth beat longer.\n    const b = floor(t / BEAT), f = t - b * BEAT - (b % 4 ? 0.1 : 0.22);\n    return f \u003c 0 ? 1 : 0.35 + 0.65 * exp(-f / 0.12);\n  };\n  // The bulbs: every 10 LEDs along each strand, the kinds in turn, each\n  // hanging off the wire tilted by its slope and knocked about by the wind.\n  S.bulbs.length = 0;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c 7; j++) {\n      const x = (i % 2 ? 7 : 2) + 10 * j;\n      if (x > W - 3) continue;\n      const xi = min(W - 1, x), y = S.yw[i * W + xi], sl = S.yw[i * W + min(W - 1, xi + 1)] - S.yw[i * W + max(0, xi - 1)];\n      const tilt = 0.6 * atan(sl / 2) + S.wind * 0.35 * sin(S.pt * (5 + j * 0.7) + i * 2 + j);\n      const lv = mix(level(q, i, j), level(p, i, j), xf);\n      S.bulbs.push({ x, y, tilt, kind: (j + i) % 4, lv });\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.bulbs.length) return;\n  const { light: L, rgb, bulbs, yw } = S, n = S.strands, wm = S.warmth;\n  // The bulbs' colours at this warmth, lit and dimmed.\n  const col = PAL.map((k) => [0, 1].map((m) => [0, 1, 2].map((c) => (wm \u003c 0 ? mix(k[1][m][c], k[0][m][c], -wm) : mix(k[1][m][c], k[2][m][c], wm)))));\n  const bulbCol = (b) => [0, 1, 2].map((c) => mix(col[b.kind][1][c], col[b.kind][0][c], cl((b.lv - 0.35) / 0.65, 0, 1)));\n  // The light on the wall: stepped rings round each bulb, by its brightness.\n  L.fill(0);\n  for (const b of bulbs) {\n    const c = col[b.kind][0], cx = b.x + 0.5 + BDY * sin(b.tilt), cy = b.y + BDY * cos(b.tilt), a = b.lv;\n    const R = RING[RING.length - 1][0];\n    for (let y = max(0, floor(cy - R)); y \u003c= min(H - 1, floor(cy + R)); y++)\n      for (let x = max(0, floor(cx - R)); x \u003c= min(W - 1, floor(cx + R)); x++) {\n        const r2 = (x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2;\n        if (r2 >= RR[3]) continue;\n        const s = r2 \u003c RR[0] ? RS[0] : r2 \u003c RR[1] ? RS[1] : r2 \u003c RR[2] ? RS[2] : RS[3];\n        const o = (y * W + x) * 3;\n        (L[o] += c[0] * s * a), (L[o + 1] += c[1] * s * a), (L[o + 2] += c[2] * s * a);\n      }\n  }\n  // The porch wall: clapboards 6 rows tall, each with a shadowed lower edge,\n  // dark violet and lit by the bulbs, its paint a little warmer or colder\n  // with the bulbs.\n  const ar = 0.85 + 0.15 * wm, ab = 0.85 - 0.15 * wm;\n  for (let y = 0; y \u003c H; y++) {\n    const edge = y % 6 === 5, alb = edge ? 0.53 : 1, br = edge ? 0.5 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] = 0.04 * br + alb * ar * min(1, L[o]);\n      rgb[o + 1] = 0.025 * br + alb * 0.85 * min(1, L[o + 1]);\n      rgb[o + 2] = 0.075 * br + alb * ab * min(1, L[o + 2]);\n    }\n  }\n  const put = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n  };\n  // The wires, dark green, lit where the bulbs are near.\n  for (let i = 0; i \u003c n; i++) {\n    let py = round(yw[i * W]);\n    for (let x = 0; x \u003c W; x++) {\n      const y = round(yw[i * W + x]);\n      for (let yy = min(py, y); yy \u003c= max(py, y); yy++) {\n        const o = (yy * W + x) * 3;\n        if (yy >= 0 && yy \u003c H) put(x, yy, 0.06 + 0.5 * min(1, L[o]), 0.12 + 0.5 * min(1, L[o + 1]), 0.05 + 0.5 * min(1, L[o + 2]));\n      }\n      py = y;\n    }\n  }\n  // The garland of paper bats on the second strand, one between each pair\n  // of bulbs on a thread 8 LEDs long, so they hang in the glow below the\n  // bulbs, each twisting on its thread.\n  const gi = 1, off = gi % 2 ? 7 : 2;\n  for (let j = 0; j \u003c 6; j++) {\n    const x0 = off + 5 + 10 * j;\n    if (x0 > W - 3) continue;\n    const yt = round(yw[gi * W + x0]), tw = S.pt * (1.3 + 0.37 * j) + j * 1.9, amp = 0.35 + 2.2 * S.wind;\n    const sw = cos(amp * sin(tw) + 0.25 * j), wid = max(0.12, abs(sw));\n    for (let yy = yt + 1; yy \u003c= yt + 8; yy++) put(x0, yy, 0.16, 0.13, 0.18);\n    const by = yt + 9, flap = sin(S.pt * 9 + j) > 0.6 ? 1 : 0;\n    for (let r = 0; r \u003c BAT.length; r++)\n      for (let cxx = 0; cxx \u003c 9; cxx++) {\n        if (BAT[r][cxx] !== \"#\") continue;\n        const dx = (cxx - 4) * wid, x = round(x0 + dx), y = by + r - (flap && abs(cxx - 4) > 2 && r \u003c 3 ? 1 : 0);\n        // A bat turned past a quarter shows its plain back, which takes a\n        // little more of the bulbs' light.\n        if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) {\n          const o = (y * W + x) * 3, lit = sw \u003c 0 ? 0.25 : 0.1;\n          put(x, y, 0.015 + lit * min(1, L[o]), 0.01 + lit * min(1, L[o + 1]), 0.02 + lit * min(1, L[o + 2]));\n        }\n      }\n  }\n  // The bulbs: a dark socket on the wire, then the glass, lit in its own\n  // colour with a paler fleck where it is brightest.\n  for (const b of bulbs) {\n    const c = bulbCol(b), s = sin(b.tilt), co = cos(b.tilt), bx = b.x + 0.5, by = b.y + 0.5;\n    for (let dx = -1; dx \u003c= 1; dx++) put(floor(bx + dx * co), floor(by + 0.5 - dx * s), 0.1, 0.13, 0.08);\n    const mx = bx + BDY * s, my = by + BDY * co, hot = cl((b.lv - 0.6) / 0.4, 0, 1) * 0.45;\n    for (let y = floor(my - 4); y \u003c= my + 4; y++)\n      for (let x = floor(mx - 4); x \u003c= mx + 4; x++) {\n        const px = x + 0.5 - mx, py = y + 0.5 - my, u = (px * co - py * s) / BRX, v = (px * s + py * co) / BRY, e = u * u + v * v;\n        if (e > 1) continue;\n        // The glass glows paler toward its middle, and a fleck shines up and left.\n        const m = e \u003c 0.3 ? hot : 0, fl = b.lv > 0.6 && u \u003c -0.2 && u > -0.75 && v \u003c -0.15 && v > -0.6 ? 0.55 : 0;\n        put(x, y, mix(c[0], 1, max(m, fl)), mix(c[1], 1, max(m, fl)), mix(c[2], 1, max(m, fl)));\n      }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n  }\n}\n","pit-pendulum":"// ===== Patternflow pattern =====\n// Title:   Pit and Pendulum\n// Family:  halloween\n// Idea:    A torchlit stone dungeon seen from the front: from a winch in the dark vault a long rod swings a huge steel crescent across the panel, its edge glinting and its shadows sweeping the wall, sinking a few LEDs with every pass toward an empty stone slab where rats gather; a hand above the slab the torches gutter, the blade stops, and the chain hauls it back up into the dark to start again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, after Edgar Allan Poe's story The Pit and the Pendulum (1842), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Descent=3..12, Torch=0..1\n//\n// Knob 1: Hue. The torch fire and the light it throws on the stone, in rings that turn toward violet as they dim: at 0 orange flames lighting the wall gold, orange, red and rose; at 0.1 red; at 0.25 magenta; at 0.4 violet; at 0.55 blue; at 0.75 cyan; at 1 green witch fire. Yellow is left out, because its dim rings turn olive. The slab and the steel stay pale.\n// Knob 2: Speed. At 2 the pendulum swings there and back in 2.3 s at the top of its run and 3.2 s just above the slab, as a real pendulum slows when it lengthens, and a whole descent with its haul back up takes 25 s at Descent 3. At 0.2 everything, flames too, runs ten times slower; at 3 half as fast again.\n// Knob 3: Descent. LEDs the blade sinks with each pass: at 3 it comes down from the middle of the panel to a hand above the slab in 14 passes, 18 seconds at Speed 2, while the rats on the slab grow from two to seven; at 12 it takes 4 passes and under 5 seconds.\n// Knob 4: Torch. How far the torchlight reaches: at 0.06 each torch lights the wall 66 LEDs round it in five steps, gold by the flame and rose at the edge, and the floor and the corners stay dark; at 1 the light reaches 100 LEDs and fills the dungeon.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => t * t * (3 - 2 * t);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The room: the vault's arch drops from row 12 at the middle to row 23 at\n// the sides, the wall meets the floor at row 104, and the slab's top face\n// runs rows 95 to 98 and its front 99 to 113, from column 9 to 54.\nconst FLOOR = 104, SLAB_X0 = 9, SLAB_X1 = 54, SLAB_TOP = 95, SLAB_FRONT = 99, SLAB_BOT = 113;\nconst archY = (x) => 12 + 20 * (1 - sqrt(max(0, 1 - ((x + 0.5 - 32) / 36) ** 2)));\n// The pendulum: the winch in the vault, the rod's length to the blade at\n// the start of a descent, at its end (the blade's edge a hand above the\n// slab) and hauled up; the rigid rod under the chain; how far the blade\n// reaches sideways at the end of a swing; the period at length 40.\nconst PX = 32, PY = 8, L_START = 34, L_END = 74, L_TOP = 10, ROD = 24, REACH = 22, T40 = 2.4;\n// The blade, a crescent hung by its middle with its horns up: inside the\n// outer circle and outside the inner one, both centred on the rod's line,\n// in LEDs with v down the rod from its end. Its edge is 7.8 below the\n// rod's end and its horns 20.8 to either side, 9.1 above it.\nconst OC = -13.46, OR = 21.26, IC = -28.33, IR = 28.33;\n// Two torches on the walls and the shadow's spread from each onto the wall.\nconst TX = [8, 56], TY = 52, SPREAD = 2.4;\n// The story at Speed 2: the torches gutter and the swing dies, the chain\n// hauls the blade into the dark, the torches catch again, it is let down.\nconst GUTTER = 1.4, HAUL = 3, RELIGHT = 0.7, LOWER = 1.5;\n\n// The rat, facing right, feet on the bottom row: # body, e eye.\nconst RAT = [\"     ##   \", \"  #####e# \", \" #######  \", \"## #   #  \"];\n\nexport function setup(params) {\n  // What each LED of the room is: 0 the dark vault, 1 the arch's stones,\n  // 2 and 3 the wall's blocks in two tones, 4 the mortar, 5 the floor's\n  // flags, 6 their joints.\n  const cls = new Uint8Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, ay = archY(x);\n      if (y \u003c ay) cls[i] = 0;\n      else if (y \u003c ay + 4) cls[i] = abs((x + 0.5 - 32) % 7) \u003c 0.6 ? 4 : 1;\n      else if (y \u003c FLOOR) {\n        const row = floor((y - 10) / 7), off = row % 2 ? 6 : 0, bx = floor((x + off) / 12);\n        const mortar = (y - 10) % 7 === 0 || (x + off) % 12 === 0;\n        cls[i] = mortar ? 4 : ((row * 7 + bx * 13) % 5) \u003c 2 ? 3 : 2;\n      } else {\n        const fy = y - FLOOR, band = fy === 0 || fy === 4 || fy === 9 || fy === 15 || fy === 22;\n        const k = ((x + 0.5 - 32) / (y - 70)) / 0.32, joint = abs(k - Math.round(k)) * (y - 70) * 0.32 \u003c 0.55;\n        cls[i] = band || joint ? 6 : 5;\n      }\n    }\n  const R = Math.random;\n  params.s = {\n    cls, rgb: new Float32Array(N * 3), pal: new Float64Array(8 * 3),\n    hue: 0.5, speed: 1.5, descent: 3.5, torch: 0.06, rt: 0.5, flick: new Float64Array(2),\n    // The story: phase, time in it, rod length, swing phase and how much\n    // of the swing is left, the torches' strength, the winch's turn.\n    phase: \"swing\", pt: 0.5, len: L_START + 2.5, phi: 0.35, amp: 0.5, fire: 0.5, wheel: 0.5, th: 0.5,\n    ax: 32.5, ay: 40.5,\n    // Two rats on the slab already, the rest come as the blade sinks.\n    rats: [\n      { side: 0, s: 52.5, to: 52.5, wait: 1.5, face: 1, wig: R() * TAU },\n      { side: 1, s: 58.5, to: 58.5, wait: 2.5, face: -1, wig: R() * TAU },\n    ],\n    spawn: 0.5,\n  };\n}\n\n// The rats' track from either side: in along the floor, up the end of the\n// slab, and along its top toward the middle. s counts LEDs from off-panel.\nconst TRACK = [[-10, 124], [7, 124], [10, 98], [31, 98]];\nconst SEG = TRACK.slice(1).map((p, k) => hypot(p[0] - TRACK[k][0], p[1] - TRACK[k][1]));\nconst TRACK_LEN = SEG.reduce((a, b) => a + b, 0), ON_SLAB = SEG[0] + SEG[1];\nfunction ratAt(r) {\n  let s = cl(r.s, 0, TRACK_LEN), k = 0;\n  while (k \u003c 2 && s > SEG[k]) (s -= SEG[k]), k++;\n  const a = TRACK[k], b = TRACK[k + 1], u = cl(s / SEG[k], 0, 1), x = a[0] + (b[0] - a[0]) * u;\n  return [r.side ? 63 - x : x, a[1] + (b[1] - a[1]) * u];\n}\n\nfunction rats(S, d, want) {\n  const R = Math.random;\n  S.spawn -= d;\n  const staying = S.rats.filter((r) => r.to > 0);\n  if (staying.length \u003c want && S.spawn \u003c= 0) {\n    S.rats.push({ side: R() \u003c 0.5 ? 0 : 1, s: 0, to: ON_SLAB + 3 + R() * (TRACK_LEN - ON_SLAB - 4), wait: 1 + R() * 2, face: 1, wig: R() * TAU });\n    S.spawn = 0.35 + 0.3 * R();\n  } else if (staying.length > want) staying[staying.length - 1].to = -2;\n  for (const r of S.rats) {\n    const gap = r.to - r.s;\n    if (abs(gap) > 0.3) {\n      // A rat runs at 16 LEDs a second, faster when it flees.\n      const v = (r.to \u003c 0 ? 30 : 16) * d;\n      r.s += cl(gap, -v, v);\n      r.face = (gap > 0 ? 1 : -1) * (r.side ? -1 : 1);\n    } else if ((r.wait -= d) \u003c= 0 && r.to > 0) {\n      // Now and then a rat shuffles along the slab.\n      r.to = cl(r.s + (R() - 0.5) * 12, ON_SLAB + 3, TRACK_LEN - 1);\n      r.wait = 1.2 + 2.5 * R();\n    }\n    r.wig += d * 9;\n  }\n  S.rats = S.rats.filter((r) => r.to > 0 || r.s > 0.5);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.descent = cl(k[2], 3, 12);\n  S.torch = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.rt += g;\n  S.pt += g;\n  // Each torch's light breathes and now and then jumps, on the story's clock.\n  for (let t = 0; t \u003c 2; t++) {\n    const c = S.rt * 1.7 + t * 2.3;\n    S.flick[t] = 0.88 + 0.07 * sin(c * 3.1) * sin(c * 1.3 + 1) + 0.05 * sin(c * 7.7 + t);\n  }\n  // A real pendulum: the swing's rate falls as the square root of its length.\n  const w = (TAU / T40) * sqrt(40 / S.len);\n  let want = 2;\n  if (S.phase === \"swing\") {\n    S.phi += w * g;\n    // Each pass, half a swing, lowers it Descent LEDs.\n    S.len += (S.descent * w * g) / PI;\n    S.amp = 1;\n    S.fire = 1;\n    want = 2 + Math.round((5 * (S.len - L_START)) / (L_END - L_START));\n    if (S.len >= L_END) (S.len = L_END), (S.phase = \"gutter\"), (S.pt = 0);\n  } else if (S.phase === \"gutter\") {\n    // The flames sink and sputter, and the swing dies to a stop over the slab.\n    const u = cl(S.pt / GUTTER, 0, 1);\n    S.phi += w * g;\n    S.amp = 1 - ease(u);\n    S.fire = 1 - 0.72 * ease(cl(u * 1.6, 0, 1));\n    want = 7;\n    if (u >= 1) (S.phase = \"haul\"), (S.pt = 0);\n  } else if (S.phase === \"haul\") {\n    const u = cl(S.pt / HAUL, 0, 1), was = S.len;\n    S.len = L_END + (L_TOP - L_END) * ease(u);\n    S.wheel += (was - S.len) / 5;\n    S.amp = 0;\n    S.fire = 0.28;\n    want = 0;\n    if (u >= 1) (S.phase = \"relight\"), (S.pt = 0);\n  } else if (S.phase === \"relight\") {\n    const u = cl(S.pt / RELIGHT, 0, 1);\n    S.fire = 0.28 + 0.72 * ease(u) + 0.25 * sin(PI * u);\n    want = 0;\n    if (u >= 1) (S.phase = \"lower\"), (S.pt = 0), (S.phi = 0);\n  } else {\n    // Let down to the middle of the panel, swinging again as it goes.\n    const u = cl(S.pt / LOWER, 0, 1), was = S.len;\n    S.len = L_TOP + (L_START - L_TOP) * ease(u);\n    S.wheel += (was - S.len) / 5;\n    S.phi += w * g;\n    S.amp = ease(u);\n    S.fire = 1;\n    want = 1;\n    if (u >= 1) (S.phase = \"swing\"), (S.pt = 0);\n  }\n  if (S.phase === \"swing\") S.wheel -= (S.descent * w * g) / PI / 5;\n  // The swing: the blade reaches REACH LEDs to either side at full swing.\n  S.th = S.amp * asin(min(1, REACH / S.len)) * sin(S.phi);\n  S.ax = PX + S.len * sin(S.th);\n  S.ay = PY + S.len * cos(S.th);\n  rats(S, d, want);\n}\n\n// Is (x, y) on the blade? Only the blade casts a shadow: the rod's, a thin\n// line across the whole wall, read as a second rope.\nfunction onBlade(S, x, y) {\n  const ex = sin(S.th), ey = cos(S.th), bx = x - S.ax, by = y - S.ay, u = bx * ey - by * ex, v = bx * ex + by * ey;\n  if (v > 8 || v \u003c -10 || abs(u) > 21) return false;\n  return u * u + (v - OC) ** 2 \u003c OR * OR && u * u + (v - IC) ** 2 > IR * IR;\n}\n\n// The frame's colours: the stone in six steps of torchlight, from unlit\n// through rings that turn from the fire's own hue toward violet as they\n// dim (gold, orange, red, rose for orange fire), so no ring goes brown.\n// Hue turns the fire from orange the long way round to green, past red,\n// violet and blue, and never through yellow, whose dim rings go olive.\nfunction palette(S) {\n  const P = S.pal, h = 0.075 - 0.775 * S.hue;\n  // The short way round the wheel from the fire's hue to violet.\n  let to = 0.76 - h;\n  to -= Math.round(to);\n  const ring = (f, s, v, o) => hsv(h + to * f, s, v, P, o * 3);\n  (P[0] = 0.04), (P[1] = 0.03), (P[2] = 0.07);\n  ring(0.75, 0.75, 0.2, 1);\n  ring(0.5, 0.85, 0.32, 2);\n  ring(0.25, 0.9, 0.48, 3);\n  ring(0.05, 0.88, 0.7, 4);\n  hsv(h + 0.03, 0.6, 0.92, P, 15);\n  // The flame's own colours: its hue at full and a pale core.\n  hsv(h, 0.9, 1, P, 18);\n  hsv(h + 0.05, 0.35, 1, P, 21);\n}\n\nfunction room(S, R) {\n  const { rgb, cls, pal: P } = S, LY = TY - 4, R2 = R * R;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, c = cls[i], o = i * 3;\n      if (c === 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n      let f = 0;\n      for (let t = 0; t \u003c 2; t++) {\n        const dx = x + 0.5 - TX[t], dy = y + 0.5 - LY, dd = dx * dx + dy * dy;\n        if (dd >= R2) continue;\n        // In the blade's shadow: the line back to the torch, cut at the\n        // pendulum's depth, meets the blade.\n        if (onBlade(S, TX[t] + dx / SPREAD, LY + dy / SPREAD)) continue;\n        f += (1 - sqrt(dd) / R) * S.flick[t];\n      }\n      let lv = min(5, floor(min(1, f * S.fire) * 6));\n      // Mortar and floor joints a step darker, the darker blocks a little.\n      if (c === 4 || c === 6) lv = max(0, lv - 1);\n      const dim = c === 3 ? 0.82 : c === 5 ? 0.9 : 1;\n      (rgb[o] = P[lv * 3] * dim), (rgb[o + 1] = P[lv * 3 + 1] * dim), (rgb[o + 2] = P[lv * 3 + 2] * dim);\n    }\n}\n\nfunction put(rgb, x, y, r, g, b) {\n  x = floor(x);\n  y = floor(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n}\nfunction add(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (rgb[o] += r), (rgb[o + 1] += g), (rgb[o + 2] += b);\n}\n\n// The torches: an iron bracket, a flame that leans and leaps, and round it\n// three steps of glow in the air.\nfunction torches(S) {\n  const { rgb, pal: P } = S, t = S.rt, fire = S.fire;\n  for (let k = 0; k \u003c 2; k++) {\n    const x0 = TX[k], fl = 0.75 + 0.25 * sin(t * 9.1 + k * 2) * sin(t * 4.3 + k), hgt = (6 + 3 * fl) * (0.4 + 0.6 * fire), lean = 0.8 * sin(t * 2.7 + k * 1.3);\n    for (let y = TY - 16; y \u003c= TY + 10; y++)\n      for (let x = x0 - 12; x \u003c= x0 + 12; x++) {\n        const dd = hypot(x + 0.5 - x0, y + 0.5 - (TY - 4)) / ((0.6 + 0.4 * fire) * S.flick[k]), a = dd \u003c 5 ? 0.42 : dd \u003c 8 ? 0.26 : dd \u003c 11 ? 0.13 : 0;\n        if (a > 0) add(rgb, x, y, P[18] * a * fire, P[19] * a * fire, P[20] * a * fire);\n      }\n    // The bracket and the torch's handle.\n    for (let y = TY; y \u003c= TY + 7; y++) put(rgb, x0, y, 0.22, 0.14, 0.1), put(rgb, x0 - 1, y, 0.3, 0.2, 0.13);\n    for (let x = x0 - 3; x \u003c= x0 + 3; x++) put(rgb, x, TY + 7, 0.28, 0.26, 0.3);\n    for (let y = 0; y \u003c hgt; y++) {\n      const q = y / hgt, wd = (q \u003c 0.35 ? 2.4 : 2.4 * (1 - (q - 0.35) / 0.65)) + 0.2, cx = x0 + lean * q * q;\n      for (let x = floor(cx - wd); x \u003c= cx + wd; x++) {\n        const core = abs(x + 0.5 - cx) \u003c wd * 0.45 && q \u003c 0.6;\n        const c = core ? 21 : 18;\n        put(rgb, x, TY - 1 - y, P[c], P[c + 1], P[c + 2]);\n      }\n    }\n  }\n}\n\n// The slab: a pale top face, its front in two steps, the torchlight on both.\nfunction slab(S, R) {\n  const { rgb, pal: P } = S, LY = TY - 4;\n  for (let y = SLAB_TOP; y \u003c= SLAB_BOT; y++)\n    for (let x = SLAB_X0; x \u003c= SLAB_X1; x++) {\n      const top = y \u003c SLAB_FRONT, edge = x === SLAB_X0 || x === SLAB_X1 || y === SLAB_FRONT;\n      let f = 0;\n      for (let t = 0; t \u003c 2; t++) f += max(0, 1 - hypot(x + 0.5 - TX[t], y + 0.5 - LY) / (R * 1.25));\n      const lv = min(4, floor(min(1, f * S.fire) * 6)), base = top ? 0.42 : y > SLAB_BOT - 3 ? 0.17 : 0.26, a = top ? 0.5 : 0.35;\n      const o = (y * W + x) * 3, e = edge ? 0.8 : 1;\n      (rgb[o] = (base + P[lv * 3] * a) * e), (rgb[o + 1] = (base * 0.94 + P[lv * 3 + 1] * a) * e), (rgb[o + 2] = (base * 1.08 + P[lv * 3 + 2] * a) * e);\n    }\n}\n\nfunction drawRats(S) {\n  const { rgb } = S;\n  for (const r of S.rats) {\n    const [x0, y0] = ratAt(r), sit = abs(r.to - r.s) \u003c 0.3, bob = sit ? (sin(r.wig) > 0.6 ? -1 : 0) : floor(r.wig) % 2 ? -1 : 0;\n    for (let ry = 0; ry \u003c 4; ry++)\n      for (let rx = 0; rx \u003c 10; rx++) {\n        const ch = RAT[ry][rx];\n        if (ch === \" \") continue;\n        const x = x0 + (r.face > 0 ? rx - 5 : 4 - rx), y = y0 - 3 + ry + (ry \u003c 2 ? bob : 0);\n        // The eye catches the torchlight, and burns red while the torches gutter.\n        if (ch === \"e\") put(rgb, x, y, 1, S.fire \u003c 0.6 ? 0.1 : 0.35, 0.2);\n        else {\n          // Black fur, the ears and back caught by the torches.\n          const rim = (ry === 0 || (ry === 1 && RAT[0][rx] === \" \")) * S.fire;\n          put(rgb, x, y, 0.07 + 0.26 * rim, 0.05 + 0.15 * rim, 0.07 + 0.14 * rim);\n        }\n      }\n    // The tail, a curl along the stone.\n    for (let q = 1; q \u003c= 5; q++) put(rgb, x0 + (r.face > 0 ? -5 - q : 4 + q), y0 + (q > 3 ? -1 : 0), 0.13, 0.08, 0.1);\n  }\n}\n\nfunction pendulum(S) {\n  const { rgb, pal: P } = S, ex = sin(S.th), ey = cos(S.th), lit = 0.45 + 0.55 * S.fire;\n  // The winch in the vault: a drum that turns as the chain pays out, its\n  // rim and four spokes.\n  for (let y = PY - 6; y \u003c= PY + 6; y++)\n    for (let x = PX - 6; x \u003c= PX + 6; x++) {\n      const r = hypot(x + 0.5 - PX, y + 0.5 - PY);\n      if (r \u003c 5.8) put(rgb, x, y, (r > 4.6 ? 0.36 : 0.15) * lit, (r > 4.6 ? 0.32 : 0.13) * lit, (r > 4.6 ? 0.37 : 0.17) * lit);\n    }\n  for (let s = 0; s \u003c 4; s++) {\n    const t = S.wheel + (s * PI) / 2;\n    for (let q = 1; q \u003c 5; q++) put(rgb, PX + q * cos(t), PY + q * sin(t), 0.3 * lit, 0.27 * lit, 0.31 * lit);\n  }\n  // The chain from the winch, its links moving with it, then the iron rod.\n  for (let q = 0; q \u003c= S.len * 2; q++) {\n    const a = q / 2, x = PX + a * ex, y = PY + a * ey;\n    if (a \u003c S.len - ROD) {\n      // Links lying flat and edge on by turns, each 4 LEDs.\n      let link = (a + S.wheel * 5) % 4;\n      if (link \u003c 0) link += 4;\n      const b = link \u003c 2.5 ? 0.58 : 0.22, b2 = link \u003c 2.5 ? 0.24 : 0.46;\n      put(rgb, x, y, b * lit, b * 0.94 * lit, b * 0.9 * lit);\n      put(rgb, x + ey, y - ex, b2 * lit, b2 * 0.94 * lit, b2 * 0.92 * lit);\n    } else {\n      put(rgb, x, y, 0.62 * lit, 0.58 * lit, 0.58 * lit);\n      put(rgb, x + ey, y - ex, 0.3 * lit, 0.27 * lit, 0.32 * lit);\n    }\n  }\n  // The blade: dark steel inside, brighter toward the edge, the edge itself\n  // near white, and a glint that runs along it and flares as it passes the bottom.\n  const gl = sin(S.phi) * S.amp, flare = S.amp * max(0, 1 - abs(cos(S.phi)) * 4);\n  // Hauled up into the vault the blade leaves the torchlight.\n  const bl = lit * cl((S.ay - 8) / 30, 0.3, 1);\n  for (let y = floor(S.ay - 22); y \u003c= S.ay + 22; y++)\n    for (let x = floor(S.ax - 22); x \u003c= S.ax + 22; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const bx = x + 0.5 - S.ax, by = y + 0.5 - S.ay, u = bx * ey - by * ex, v = bx * ex + by * ey;\n      const dOut = OR - sqrt(u * u + (v - OC) ** 2), dIn = sqrt(u * u + (v - IC) ** 2) - IR;\n      if (dOut \u003c= 0 || dIn \u003c= 0) continue;\n      const hot = abs(u + gl * 16) \u003c 2.6 && dOut \u003c 1.5;\n      const st = dOut \u003c 1.1 ? (hot ? 1 : 0.92) : dOut \u003c 2.4 ? 0.62 : 0.4;\n      const tint = dOut \u003c 1.1 ? 0.08 : 0.2;\n      const o = (y * W + x) * 3;\n      (rgb[o] = (st * (1 - tint) + P[12] * tint) * bl), (rgb[o + 1] = (st * 0.98 * (1 - tint) + P[13] * tint) * bl), (rgb[o + 2] = (st * 1.04 * (1 - tint) + P[14] * tint) * bl);\n    }\n  if (flare > 0.05) {\n    // A four-pointed star of light on the edge, under the rod.\n    const sx = S.ax + ex * 7.5, sy = S.ay + ey * 7.5, n = 2 + floor(5 * flare);\n    for (let q = -n; q \u003c= n; q++) {\n      const a = 1 - abs(q) / (n + 1);\n      put(rgb, sx + q, sy, 1, 1, 0.9 * a + 0.1);\n      put(rgb, sx, sy + q, 1, 1, 0.9 * a + 0.1);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, R = 64 + 36 * S.torch;\n  palette(S);\n  room(S, R);\n  torches(S);\n  slab(S, R);\n  drawRats(S);\n  pendulum(S);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","square-peg":"// ===== Patternflow pattern =====\n// Title:   Square Peg\n// Family:  topology\n// Idea:    A closed curve wobbles and twists its lobes into curling arms without ever crossing itself, and every frame all the squares with their four corners on it are found afresh and drawn as bright outlines over its dim inside, born and dying in pairs as it changes while their count stays odd.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: inscribed square problem (Otto Toeplitz, 1911), solved for smooth curves (Lev Schnirelmann, 1929); inscribed rectangles of every aspect ratio (Joshua Greene and Andrew Lobb, 2020), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=1..3, Wobble=0..1\n//\n// Knob 1: Hue. Moves the whole palette along a strip of the wheel from green through cyan, blue and violet to rose, leaving out red, orange and yellow, which go brown and olive when dim: at 0 the curve's inside is deep blue and its squares green, violet and rose; at 0.28 the inside is rose and the squares green to violet; at 0.78 the inside is green and the squares cyan to rose; at 1 blue again.\n// Knob 2: Speed. At 2 each lobe swells and shrinks every 13 to 25 seconds while it turns, and the twist swings from one side to the other and back in 33 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Ratio. The aspect ratio of the rectangles sought: at 1 squares, at 2 rectangles twice as long as they are wide, at 3 three times. Each square at 1 becomes two rectangles as the ratio leaves it, so away from 1 the count is even in more than nine frames of ten.\n// Knob 4: Wobble. How far the curve folds: at 0.06 its lobes reach 0.41 of the mean radius in and out and the twist turns its outermost points up to 2.5 radians past its innermost, and one to five squares stand on it; at 1 the lobes reach 0.5 and the twist 3.6 radians, the arms curl over the valleys between them, and up to 23 squares stand at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Every colour comes off a strip of the wheel that skips red, orange and\n// yellow, which turn brown and olive when dim: u from 0 to 1 runs green,\n// cyan, blue, violet, magenta to rose.\nconst wheel = (u) => 0.34 + 0.63 * u;\n\n// The curve. In its own plane it is star-shaped, r0(th) = 1 + four Fourier\n// lobes; then a twist turns each point by tau * rho^2 about the centre, a\n// smooth map of the plane onto itself with a smooth inverse, so the image\n// is still a simple closed curve however far it curls; then it is\n// stretched to stand 2:1 on the panel. Its implicit function, phi(x) =\n// rho - r0(angle - tau * rho^2) after undoing the stretch, is zero exactly\n// on the curve and negative inside, and angle - tau * rho^2 of a point on\n// the curve is its parameter.\nconst MODES = [2, 3, 4, 5], WEIGHT = [0.22, 0.36, 0.26, 0.16];\nconst CX = 32, CY = 64, HALF_W = 29.5, HALF_H = 61.5;\n// Curve samples for the search and for drawing, and the r0 table.\nconst M = 128, MD = 480, TAB = 1024;\n// The search drops candidate pairs this close along the curve (the trivial\n// squares of side 0) and solutions with a side under MIN_SIDE LEDs.\nconst NEAR = 2, MIN_SIDE = 3;\n// Seconds a square born or dying flashes; frames a square may go unfound\n// before it counts as dead.\nconst FLASH = 0.6, MISS = 2;\n\nexport function setup(params) {\n  const R = Math.random;\n  params.s = {\n    // Each lobe: rate and phase of its swell, rate and start of its turn.\n    nu: MODES.map(() => 0.25 + 0.25 * R()), c0: MODES.map(() => TAU * R()),\n    mu: MODES.map((k, i) => (i % 2 ? -1 : 1) * (0.08 + 0.12 * R()) * (3 / k)), p0: MODES.map(() => TAU * R()),\n    amp: new Float64Array(4), ph: new Float64Array(4), ac: new Float64Array(4), as: new Float64Array(4),\n    t: 0.5, hue: 0.5, speed: 1.5, ratio: 1.5, wob: 0.06, tau: 0.5, sx: 20.5, sy: 40.5,\n    tab: new Float64Array(TAB + 1), phi: new Float32Array(N), ring: new Uint8Array(N),\n    px: new Float64Array(M), py: new Float64Array(M), f1: new Float32Array(M * M), f2: new Float32Array(M * M), done: new Uint8Array(M * M),\n    sq: [], ghosts: [], next: 0, first: true, gp: new Float64Array(4), gq: new Float64Array(4),\n    // What the search found: frames searched at ratio 1, frames with a\n    // square, frames with an odd count, the largest corner residual in\n    // LEDs, and how many frames had each count.\n    stat: { frames: 0, found: 0, odd: 0, res: 0, hist: {} },\n    rgb: new Float32Array(N * 3), col: new Float64Array(3), pal: new Float64Array(24),\n  };\n}\n\n// r0 exactly, for the solver and the drawn line; the table, for the field.\n// The lobes are cos(k th - ph) for k = 2..5, built from cos th and sin th\n// by the multiple-angle recurrence, with a * cos ph and a * sin ph kept per\n// frame. The slope dr0/dth is left in RD.\nlet RD = 0;\nfunction r0(S, th) {\n  const c1 = cos(th), s1 = sin(th), ac = S.ac, as = S.as;\n  let ck = c1 * c1 - s1 * s1, sk = 2 * s1 * c1, r = 1 + ac[0] * ck + as[0] * sk, dr = 2 * (as[0] * ck - ac[0] * sk);\n  for (let m = 1; m \u003c 4; m++) {\n    const c = ck * c1 - sk * s1;\n    sk = sk * c1 + ck * s1;\n    ck = c;\n    r += ac[m] * ck + as[m] * sk;\n    dr += (m + 2) * (as[m] * ck - ac[m] * sk);\n  }\n  RD = dr;\n  return r;\n}\n// The curve's point at parameter s and its velocity, in LEDs.\nfunction gamma(S, s, out) {\n  const r = r0(S, s), dr = RD, a = s + S.tau * r * r, da = 1 + 2 * S.tau * r * dr, ca = cos(a), sa = sin(a);\n  out[0] = CX + S.sx * r * ca;\n  out[1] = CY + S.sy * r * sa;\n  out[2] = S.sx * (dr * ca - r * sa * da);\n  out[3] = S.sy * (dr * sa + r * ca * da);\n}\n// The field and its slope per LED.\nfunction phiAt(S, x, y, g) {\n  const X = (x - CX) / S.sx, Y = (y - CY) / S.sy, rr = X * X + Y * Y, rho = sqrt(rr);\n  const f = rho - r0(S, atan2(Y, X) - S.tau * rr), dr = RD;\n  if (g) {\n    g[0] = (X / rho - dr * (-Y / rr - 2 * S.tau * X)) / S.sx;\n    g[1] = (Y / rho - dr * (X / rr - 2 * S.tau * Y)) / S.sy;\n  }\n  return f;\n}\n// atan2 to within 1e-5 rad, for the per-LED field only; the solver uses\n// the exact one.\nfunction fatan2(y, x) {\n  const ax = abs(x), ay = abs(y), a = min(ax, ay) / (max(ax, ay) || 1), q = a * a;\n  let r = ((-0.0464964749 * q + 0.15931422) * q - 0.327622764) * q * a + a;\n  if (ay > ax) r = 1.57079637 - r;\n  if (x \u003c 0) r = 3.14159274 - r;\n  return y \u003c 0 ? -r : r;\n}\nfunction paramOf(S, x, y) {\n  const X = (x - CX) / S.sx, Y = (y - CY) / S.sy, a = atan2(Y, X) - S.tau * (X * X + Y * Y);\n  return a - floor(a / TAU) * TAU;\n}\n\n// The rectangle on side p(s) -> q(t), its other side Ratio times as long:\n// corners in o[0..7], the field at the two far corners in o[8], o[9] (both\n// zero is a rectangle), and their slopes in s and t in o[10..13].\nconst GR = new Float64Array(2), GU = new Float64Array(2);\nfunction corners(S, s, t, o) {\n  const P = S.gp, Q = S.gq, k = S.ratio;\n  gamma(S, s, P);\n  gamma(S, t, Q);\n  const jx = -(Q[1] - P[1]) * k, jy = (Q[0] - P[0]) * k;\n  (o[0] = P[0]), (o[1] = P[1]), (o[2] = Q[0]), (o[3] = Q[1]);\n  (o[4] = Q[0] + jx), (o[5] = Q[1] + jy), (o[6] = P[0] + jx), (o[7] = P[1] + jy);\n  o[8] = phiAt(S, o[4], o[5], GR);\n  o[9] = phiAt(S, o[6], o[7], GU);\n  // r = q + kJ(q - p) and u = p + kJ(q - p), J the quarter turn.\n  o[10] = GR[0] * k * P[3] - GR[1] * k * P[2];\n  o[11] = GR[0] * (Q[2] - k * Q[3]) + GR[1] * (Q[3] + k * Q[2]);\n  o[12] = GU[0] * (P[2] + k * P[3]) + GU[1] * (P[3] - k * P[2]);\n  o[13] = -GU[0] * k * Q[3] + GU[1] * k * Q[2];\n}\n\n// Newton's method on (s, t) from a cell of the search grid.\nconst V = new Float64Array(14);\nfunction solve(S, s, t) {\n  for (let it = 0; it \u003c 14; it++) {\n    corners(S, s, t, V);\n    if (abs(V[8]) + abs(V[9]) \u003c 1e-13) return true;\n    // Near the diagonal s = t every corner falls on p, the square of side 0,\n    // and a start drawn toward it is given up.\n    if (it >= 2 && abs(V[2] - V[0]) + abs(V[3] - V[1]) \u003c MIN_SIDE / 2) return false;\n    const a = V[10], b = V[11], c = V[12], d = V[13], det = a * d - b * c;\n    if (!det) return false;\n    let ds = (d * V[8] - b * V[9]) / det, dt = (a * V[9] - c * V[8]) / det;\n    const step = max(abs(ds), abs(dt));\n    if (step > 0.06) (ds *= 0.06 / step), (dt *= 0.06 / step);\n    s -= ds;\n    t -= dt;\n  }\n  return false;\n}\n\nfunction search(S) {\n  const { px, py, f1, f2, done, phi: F } = S, k = S.ratio;\n  for (let i = 0; i \u003c M; i++) {\n    gamma(S, (TAU * i) / M, S.gp);\n    (px[i] = S.gp[0]), (py[i] = S.gp[1]);\n  }\n  // The field at each far corner, read between LED centres; off the panel\n  // is outside.\n  for (let i = 0; i \u003c M; i++) {\n    const xi = px[i], yi = py[i];\n    for (let j = 0; j \u003c M; j++) {\n      const jx = -(py[j] - yi) * k, jy = (px[j] - xi) * k, o = i * M + j;\n      for (let c = 0; c \u003c 2; c++) {\n        const x = (c ? xi : px[j]) + jx - 0.5, y = (c ? yi : py[j]) + jy - 0.5;\n        let f = 0.5;\n        if (x > -0.5 && x \u003c W - 0.5 && y > -0.5 && y \u003c H - 0.5) {\n          const gx = x \u003c 0 ? 0 : x > W - 1.001 ? W - 1.001 : x, gy = y \u003c 0 ? 0 : y > H - 1.001 ? H - 1.001 : y;\n          const ix = gx | 0, iy = gy | 0, fx = gx - ix, fy = gy - iy, n = iy * W + ix;\n          f = (F[n] + (F[n + 1] - F[n]) * fx) * (1 - fy) + (F[n + W] + (F[n + W + 1] - F[n + W]) * fx) * fy;\n        }\n        if (c) f2[o] = f;\n        else f1[o] = f;\n      }\n    }\n  }\n  done.fill(0);\n  // A cell where both far corners cross the curve may hold a solution.\n  // Newton starts where the two fields, each taken as a plane through the\n  // cell, cross, kept to within a cell of it. Each rectangle turns up once\n  // per side that can be p -> q, four for a square and two otherwise, so\n  // once one is found the cells of the others are done.\n  const found = [], sqr = abs(k - 1) \u003c 1e-9, period = sqr ? PI / 2 : PI;\n  const mark = (a, b) => (done[floor((a / TAU) * M) * M + floor((b / TAU) * M)] = 1);\n  for (let i = 0; i \u003c M; i++) {\n    const i1 = (i + 1) % M;\n    for (let j = 0; j \u003c M; j++) {\n      const gap = abs(i - j), a = i * M + j;\n      if (min(gap, M - gap) \u003c= NEAR || done[a]) continue;\n      const j1 = (j + 1) % M, b = i * M + j1, c = i1 * M + j, d = i1 * M + j1;\n      const A1 = f1[a], B1 = f1[b], C1 = f1[c], D1 = f1[d], A2 = f2[a], B2 = f2[b], C2 = f2[c], D2 = f2[d];\n      if ((A1 > 0) === (B1 > 0) && (A1 > 0) === (C1 > 0) && (A1 > 0) === (D1 > 0)) continue;\n      if ((A2 > 0) === (B2 > 0) && (A2 > 0) === (C2 > 0) && (A2 > 0) === (D2 > 0)) continue;\n      const m1 = (A1 + B1 + C1 + D1) / 4, u1 = (C1 + D1 - A1 - B1) / 2, w1 = (B1 + D1 - A1 - C1) / 2;\n      const m2 = (A2 + B2 + C2 + D2) / 4, u2 = (C2 + D2 - A2 - B2) / 2, w2 = (B2 + D2 - A2 - C2) / 2, det = u1 * w2 - w1 * u2;\n      if (!det) continue;\n      const di = cl((-m1 * w2 + w1 * m2) / det, -1, 1), dj = cl((-u1 * m2 + m1 * u2) / det, -1, 1);\n      if (!solve(S, (TAU * (i + 0.5 + di)) / M, (TAU * (j + 0.5 + dj)) / M)) continue;\n      const len = hypot(V[2] - V[0], V[3] - V[1]);\n      if (len \u003c MIN_SIDE) continue;\n      const v = Array.from(V.subarray(0, 8)), ps = [0, 1, 2, 3].map((q) => paramOf(S, v[2 * q], v[2 * q + 1]));\n      for (let q = 0; q \u003c 4; q += sqr ? 1 : 2) mark(ps[q], ps[(q + 1) % 4]);\n      const cx = (v[0] + v[2] + v[4] + v[6]) / 4, cy = (v[1] + v[3] + v[5] + v[7]) / 4;\n      let ang = atan2(v[3] - v[1], v[2] - v[0]) % period;\n      if (ang \u003c 0) ang += period;\n      let dup = false;\n      for (const f of found) {\n        let da = abs(f.ang - ang);\n        da = min(da, period - da);\n        if (abs(f.cx - cx) \u003c 0.05 && abs(f.cy - cy) \u003c 0.05 && abs(f.len - len) \u003c 0.05 && da \u003c 0.005) dup = true;\n      }\n      if (!dup) found.push({ cx, cy, len, ang, v });\n    }\n  }\n  return found;\n}\n\n// Each square found takes the id and age of the nearest one last frame;\n// the rest are born. One unfound for more than MISS frames dies.\nfunction track(S, found, dt) {\n  const old = S.sq, used = new Uint8Array(old.length), next = [];\n  for (const f of found) {\n    let best = -1, bc = 4;\n    old.forEach((o, i) => {\n      if (used[i]) return;\n      const c = hypot(o.cx - f.cx, o.cy - f.cy) + abs(o.len - f.len);\n      if (c \u003c bc) (bc = c), (best = i);\n    });\n    if (best >= 0) (used[best] = 1), (f.id = old[best].id), (f.age = old[best].age + dt);\n    else (f.id = S.next++), (f.age = S.first ? 9 : 0);\n    f.miss = 0;\n    next.push(f);\n  }\n  old.forEach((o, i) => {\n    if (used[i]) return;\n    if (++o.miss > MISS) S.ghosts.push({ v: o.v, life: FLASH });\n    else (o.age += dt), next.push(o);\n  });\n  for (const g of S.ghosts) g.life -= dt;\n  S.ghosts = S.ghosts.filter((g) => g.life > 0);\n  S.sq = next;\n  S.first = false;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.ratio = cl(kv[2], 1, 3);\n  S.wob = cl(kv[3], 0, 1);\n  S.t += (d * S.speed) / 2;\n  const t = S.t, A = 0.4 + 0.1 * S.wob;\n  for (let m = 0; m \u003c 4; m++) {\n    S.amp[m] = A * WEIGHT[m] * (0.7 + 0.3 * sin(S.nu[m] * t + S.c0[m]));\n    S.ph[m] = S.p0[m] + S.mu[m] * t;\n    (S.ac[m] = S.amp[m] * cos(S.ph[m])), (S.as[m] = S.amp[m] * sin(S.ph[m]));\n  }\n  let rmax = 0;\n  for (let i = 0; i \u003c= TAB; i++) rmax = max(rmax, (S.tab[i] = r0(S, (TAU * i) / TAB)));\n  // The twist turns a point at radius 1 + A this far past one at 1 - A,\n  // swinging from one side to the other; and the curve is scaled to just fit.\n  S.tau = ((2.4 + 1.2 * S.wob) * sin(0.19 * t + 1.1)) / (4 * A);\n  (S.sx = HALF_W / rmax), (S.sy = HALF_H / rmax);\n  const F = S.phi, tab = S.tab;\n  for (let y = 0; y \u003c H; y++) {\n    const Y = (y + 0.5 - CY) / S.sy;\n    for (let x = 0; x \u003c W; x++) {\n      const X = (x + 0.5 - CX) / S.sx, rho2 = X * X + Y * Y;\n      let u = ((fatan2(Y, X) - S.tau * rho2) / TAU) * TAB;\n      u -= floor(u / TAB) * TAB;\n      const iu = u | 0;\n      F[y * W + x] = sqrt(rho2) - (tab[iu] + (tab[iu + 1] - tab[iu]) * (u - iu));\n    }\n  }\n  const found = search(S);\n  if (S.ratio === 1) {\n    const st = S.stat;\n    st.frames++;\n    if (found.length) st.found++;\n    if (found.length % 2) st.odd++;\n    st.hist[found.length] = (st.hist[found.length] || 0) + 1;\n    for (const f of found)\n      for (let c = 0; c \u003c 4; c++) {\n        // A corner's distance from the curve in LEDs: the field over its slope.\n        const e = abs(phiAt(S, f.v[2 * c], f.v[2 * c + 1], GR));\n        st.res = max(st.res, e / hypot(GR[0], GR[1]));\n      }\n  }\n  track(S, found, d);\n}\n\n// The inside: blue at Hue 0, along the strip to rose at 0.28, back down\n// to green at 0.78 and up to blue again at 1. A square's own colour: its id\n// picks a place on the rest of the strip, at least a quarter of it away\n// from the inside's.\nconst U0 = 0.444;\nconst insideAt = (S) => {\n  const f = (U0 + 2 * S.hue) % 2;\n  return f > 1 ? 2 - f : f;\n};\nfunction squareHue(S, id) {\n  const p = insideAt(S), lo = max(0, p - 0.25), x = ((id * 0.618034) % 1) * (lo + max(0, 0.75 - p));\n  return wheel(x \u003c lo ? x : x - lo + p + 0.25);\n}\n\nfunction line(rgb, x0, y0, x1, y1, r, g, b) {\n  const n = max(1, Math.ceil(hypot(x1 - x0, y1 - y0) * 2));\n  for (let q = 0; q \u003c= n; q++) {\n    const x = floor(x0 + ((x1 - x0) * q) / n), y = floor(y0 + ((y1 - y0) * q) / n);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3;\n    (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n  }\n}\n\n// The square's inside in its own colour, except on the curve's line.\nfunction fill(S, v, r, g, b) {\n  const { rgb, ring } = S, xs = [v[0], v[2], v[4], v[6]], ys = [v[1], v[3], v[5], v[7]];\n  const x0 = max(0, floor(min(...xs))), x1 = min(W - 1, floor(max(...xs))), y0 = max(0, floor(min(...ys))), y1 = min(H - 1, floor(max(...ys)));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let pos = 0, neg = 0;\n      for (let c = 0; c \u003c 4; c++) {\n        const ax = xs[c], ay = ys[c], cr = (xs[(c + 1) % 4] - ax) * (py - ay) - (ys[(c + 1) % 4] - ay) * (px - ax);\n        if (cr > 0) pos++;\n        else neg++;\n      }\n      const i = y * W + x;\n      if ((pos && neg) || ring[i] === 3) continue;\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, ring, phi, col } = S, hb = wheel(insideAt(S));\n  // The line: the curve sampled finely, so a fold thinner than an LED still\n  // draws both its sides. Then two rings round it.\n  ring.fill(0);\n  let a = [], b = [], x0 = 0, y0 = 0;\n  for (let q = 0; q \u003c= MD; q++) {\n    gamma(S, (TAU * q) / MD, S.gp);\n    const x1 = S.gp[0], y1 = S.gp[1], n = q ? Math.ceil(2 * max(abs(x1 - x0), abs(y1 - y0))) : 0;\n    for (let e = 0; e \u003c= n; e++) {\n      const x = floor(x1 + ((x0 - x1) * e) / (n || 1)), y = floor(y1 + ((y0 - y1) * e) / (n || 1)), i = y * W + x;\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H && !ring[i]) (ring[i] = 3), a.push(i);\n    }\n    (x0 = x1), (y0 = y1);\n  }\n  for (let lv = 2; lv > 0; lv--) {\n    for (const i of a) {\n      const x = i % W;\n      if (x > 0 && !ring[i - 1]) (ring[i - 1] = lv), b.push(i - 1);\n      if (x \u003c W - 1 && !ring[i + 1]) (ring[i + 1] = lv), b.push(i + 1);\n      if (i >= W && !ring[i - W]) (ring[i - W] = lv), b.push(i - W);\n      if (i \u003c N - W && !ring[i + W]) (ring[i + W] = lv), b.push(i + W);\n    }\n    (a = b), (b = []);\n  }\n  // Inside dim and flat with a brighter band along the line; outside black\n  // with a two-step halo. Five colours, no gradient. pal holds them by\n  // ring outside (0..3) and then ring inside (4..7).\n  const pal = S.pal, lv = [[0, 0, 0], [hb, 0.85, 0.2], [hb, 0.75, 0.42], [hb + 0.03, 0.35, 1], [hb, 0.85, 0.2], [hb, 0.8, 0.3], [hb, 0.75, 0.36], [hb + 0.03, 0.35, 1]];\n  for (let c = 0; c \u003c 8; c++) hsv(lv[c][0], lv[c][1], lv[c][2], pal, c * 3);\n  for (let i = 0, o = 0; i \u003c N; i++, o += 3) {\n    const c = (ring[i] + (phi[i] \u003c 0 ? 4 : 0)) * 3;\n    (rgb[o] = pal[c]), (rgb[o + 1] = pal[c + 1]), (rgb[o + 2] = pal[c + 2]);\n  }\n  // Squares, largest first so small ones show on top: the inside in the\n  // square's colour, then the outline, then the corners.\n  const list = S.sq.slice().sort((a, b) => b.len - a.len);\n  for (const f of list) {\n    const h = squareHue(S, f.id);\n    hsv(h, 0.8, 0.42, col, 0);\n    fill(S, f.v, col[0], col[1], col[2]);\n  }\n  for (const f of list) {\n    // Newborn squares flash white and settle into their colour.\n    const v = f.v, wh = f.age \u003c FLASH ? 1 - f.age / FLASH : 0;\n    hsv(squareHue(S, f.id), 0.6 * (1 - wh), 1, col, 0);\n    for (let c = 0; c \u003c 4; c++) line(rgb, v[2 * c], v[2 * c + 1], v[(2 * c + 2) % 8], v[(2 * c + 3) % 8], col[0], col[1], col[2]);\n    for (let c = 0; c \u003c 4; c++) {\n      const x = floor(v[2 * c]), y = floor(v[2 * c + 1]);\n      for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) {\n        const X = x + dx, Y = y + dy;\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const o = (Y * W + X) * 3, core = dx === 0 && dy === 0;\n        (rgb[o] = core ? 1 : col[0]), (rgb[o + 1] = core ? 1 : col[1]), (rgb[o + 2] = core ? 1 : col[2]);\n      }\n    }\n  }\n  // A square that died flashes white where it last stood, then goes.\n  for (const g of S.ghosts) {\n    const a = floor((g.life / FLASH) * 4) / 4 + 0.25;\n    for (let c = 0; c \u003c 4; c++) line(rgb, g.v[2 * c], g.v[2 * c + 1], g.v[(2 * c + 2) % 8], g.v[(2 * c + 3) % 8], a, a, a);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","tennis-racket":"// ===== Patternflow pattern =====\n// Title:   Tennis Racket\n// Family:  sim\n// Idea:    A T-handle spinning about its middle axis turns itself over by half a turn again and again while its angular momentum stays fixed and upright, and below it the momentum seen from the handle runs round the momentum sphere along the polhodes, past the separatrix that joins the two ends of the middle axis.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the tennis racket theorem: Euler's equations of a free rigid body (Leonhard Euler, 1765) and their polhodes (Louis Poinsot, 1834), seen in a wing nut by Vladimir Dzhanibekov on Salyut 7 (1985), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Axis=-1..1, Nudge=0..1\n//\n// Knob 1: Hue. Turns the three colours round the wheel together: at 0 the crossbar and the polhodes round its axis are azure, the stem, its tip and the momentum's trail amber, and the polhodes round the third axis violet; at 0.5 they are orange, blue and green. Orange and yellow are kept bright so they never dim to brown.\n// Knob 2: Speed. At 2 the handle spins at 4 radians a second, so the first flip comes at 2.3 seconds and the next ones every 3.9 seconds. At 0.2 time runs ten times slower, at 3 half as fast again.\n// Knob 3: Axis. Which principal axis the throw starts near: at 0 the middle one, the stem, and the handle flips; at -1 the smallest, the crossbar, and at 1 the largest, the normal to the T, where it only wobbles round a small polhode. Between them it starts on a wider polhode and rolls over steadily instead of flipping: once every 1.5 seconds at 0.5 and every 1.0 at -0.5. A new setting throws again 0.3 seconds after the knob stops.\n// Knob 4: Nudge. How far off that axis the throw starts: 0.072 radians at the opening 0.06, 1.2 radians at 1. At 0 it spins exactly about the middle axis and never flips. The time between flips grows like log(1 / nudge): 5.1, 3.9, 2.6 and 2.0 seconds at nudges of 0.017, 0.06, 0.25 and 0.5, and each e-fold smaller nudge adds 0.93 seconds.\n// Buttons: any button throws again with the knobs as they are.\n\nconst W = 64, H = 128, N = W * H, HALF = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// How near a hue is to orange and yellow, 0 to 1.\nconst warm = (h) => max(0, 1 - abs(h - floor(h) - 0.11) / 0.13);\nconst nrm = (p) => {\n  const l = hypot(p[0], p[1], p[2]) || 1;\n  return [p[0] / l, p[1] / l, p[2] / l];\n};\n\n// The T-handle as two boxes of one density, centre and half sizes: the\n// crossbar along the body's x axis and the stem along y, both centred on\n// x = z = 0, so x, y and z through the centre of mass are its principal axes.\n// Worked out in setup, per unit mass, the moments are 0.160, 0.306 and\n// 0.448: the crossbar's axis is the smallest, the stem's the middle, the\n// normal to the T the largest, in the ratio 1 : 1.917 : 2.807.\nconst BOXES = [\n  [0, 0, 0, 1.1, 0.17, 0.17],\n  [0, 0.76, 0, 0.14, 0.59, 0.14],\n];\n// Spin about the middle axis at Speed 2, radians a second.\nconst OMEGA = 4;\n// Nudge 1 starts the throw this many radians off the axis.\nconst NUDGE = 1.2;\n// The nudge leans the start toward this body direction (made perpendicular\n// to the start axis), 16 degrees off the separatrix, so it never starts on it.\nconst LEAN = [0.35, 0, 0.94];\n// The camera over the handle: distance, LEDs per unit at the centre, the\n// angle it looks down at, and the screen row of the centre of mass.\nconst CAMD = 11, FOC = 11 * 25, ELEV = 0.36, CY0 = 31;\n// The light, a unit vector toward it in the space frame.\nconst LIGHT = nrm([-0.45, 0.75, 0.55]);\n// The momentum sphere below: centre and radius in LEDs, and the direction\n// it is seen from, in the handle's own frame.\nconst SX = 31.5, SY = 96.5, SR = 28;\nconst VIEW = nrm([0.3, 0.3, 0.9]);\n// Frames of trail kept: the momentum's on the sphere, the stem tip's above.\nconst TRAIL = 150, TIP = 40;\n\nexport function setup(params) {\n  // Moments of inertia from the boxes, about the centre of mass.\n  let M = 0, cy = 0;\n  for (const b of BOXES) (M += b[3] * b[4] * b[5]), (cy += b[3] * b[4] * b[5] * b[1]);\n  cy /= M;\n  const I = [0, 0, 0];\n  for (const b of BOXES) {\n    const m = b[3] * b[4] * b[5], x = 2 * b[3], y = 2 * b[4], z = 2 * b[5], d = b[1] - cy;\n    I[0] += (m * (y * y + z * z)) / 12 + m * d * d;\n    I[1] += (m * (x * x + z * z)) / 12;\n    I[2] += (m * (x * x + y * y)) / 12 + m * d * d;\n  }\n  for (let k = 0; k \u003c 3; k++) I[k] /= M;\n  // The boxes' faces round the centre of mass, each as four corners, its\n  // outward normal and which box it is on; face 1 of box 1 is the stem's tip.\n  const faces = [];\n  BOXES.forEach((b, bi) => {\n    for (let ax = 0; ax \u003c 3; ax++)\n      for (const sg of [1, -1]) {\n        const u = (ax + 1) % 3, v = (ax + 2) % 3, h = [b[3], b[4], b[5]], c = [b[0], b[1] - cy, b[2]];\n        const pts = [[-1, -1], [1, -1], [1, 1], [-1, 1]].map(([pu, pv]) => {\n          const p = c.slice();\n          (p[ax] += sg * h[ax]), (p[u] += pu * h[u]), (p[v] += pv * h[v]);\n          return p;\n        });\n        if (sg \u003c 0) pts.reverse();\n        const n = [0, 0, 0];\n        n[ax] = sg;\n        faces.push({ pts, n, part: bi === 1 && ax === 1 && sg > 0 ? 2 : bi });\n      }\n  });\n  // The sphere's look, fixed because the handle's frame is: for every LED of\n  // the disc, the point of the sphere in front and the one behind, which of\n  // the four regions the separatrices cut it into each lies in, and which of\n  // three polhodes per region it lies past. The polhodes are curves of\n  // constant energy e = L1^2 / I1 + L2^2 / I2 + L3^2 / I3 on |L| = 1;\n  // rho runs from 0 at a region's pole to 1 at its separatrix.\n  const B = VIEW, U = nrm([-B[1] * B[0], 1 - B[1] * B[1], -B[1] * B[2]]);\n  const R = [U[1] * B[2] - U[2] * B[1], U[2] * B[0] - U[0] * B[2], U[0] * B[1] - U[1] * B[0]];\n  const iI = I.map((v) => 1 / v), eS = iI[1];\n  const code = (p) => {\n    const e = p[0] * p[0] * iI[0] + p[1] * p[1] * iI[1] + p[2] * p[2] * iI[2];\n    const s = e > eS ? (e - eS) / (iI[0] - eS) : (eS - e) / (eS - iI[2]);\n    const reg = e > eS ? (p[0] > 0 ? 0 : 1) : p[2] > 0 ? 2 : 3;\n    return reg * 4 + floor(sqrt(cl(1 - s, 0, 0.9999)) * 4);\n  };\n  const front = new Int16Array(W * HALF).fill(-1), back = new Int16Array(W * HALF).fill(-1);\n  const eF = new Float32Array(W * HALF), eB = new Float32Array(W * HALF);\n  const en = (p) => p[0] * p[0] * iI[0] + p[1] * p[1] * iI[1] + p[2] * p[2] * iI[2];\n  for (let y = 0; y \u003c HALF; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = (x + 0.5 - SX) / SR, py = (SY - (y + HALF + 0.5)) / SR, r2 = px * px + py * py;\n      if (r2 >= 1) continue;\n      const pz = sqrt(1 - r2), i = y * W + x;\n      const at = (z) => [px * R[0] + py * U[0] + z * B[0], px * R[1] + py * U[1] + z * B[1], px * R[2] + py * U[2] + z * B[2]];\n      const pf = at(pz), pb = at(-pz);\n      (front[i] = code(pf)), (back[i] = code(pb)), (eF[i] = en(pf)), (eB[i] = en(pb));\n    }\n  // Classes: 1 and 2 the front fill round the e1 and e3 poles, 4 the\n  // separatrix behind, 5 and 6 a polhode in front round e1 and e3, 7 the\n  // separatrix in front, 8 the rim. A line is where the code changes to a\n  // neighbour; a change of region is the separatrix. The polhodes behind\n  // (class 3) are left out: drawn, they crowded the ones in front.\n  const cls = new Uint8Array(W * HALF);\n  const edge = (A, i, x, y) => {\n    let c = 0;\n    for (const j of [x + 1 \u003c W ? i + 1 : -1, y + 1 \u003c HALF ? i + W : -1, x > 0 ? i - 1 : -1, y > 0 ? i - W : -1]) {\n      if (j \u003c 0 || A[j] \u003c 0 || A[j] === A[i]) continue;\n      if (A[j] >> 2 !== A[i] >> 2) c = 2;\n      else if ((A[j] & 3) > (A[i] & 3)) c = max(c, 1);\n    }\n    return c;\n  };\n  for (let y = 0; y \u003c HALF; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (front[i] \u003c 0) continue;\n      const rim = (x > 0 && front[i - 1] \u003c 0) || (x \u003c W - 1 && front[i + 1] \u003c 0) || (y > 0 && front[i - W] \u003c 0) || (y \u003c HALF - 1 && front[i + W] \u003c 0);\n      const ef = edge(front, i, x, y), eb = edge(back, i, x, y), reg = front[i] >> 2;\n      cls[i] = rim ? 8 : ef === 2 ? 7 : ef === 1 ? (reg \u003c 2 ? 5 : 6) : eb === 2 ? 4 : reg \u003c 2 ? 1 : 2;\n    }\n  params.s = {\n    I, iI, faces, cls, R, U, B, tipY: 1.35 - cy, front, back, eF, eB, cap: new Uint8Array(W * HALF),\n    hue: 0, speed: 2, axis: 0, nudge: 0.06, a0: 0, n0: 0.06, pend: 0, t: 0, flips: 0,\n    L: new Float64Array(3), q: new Float64Array(4), m: new Float64Array(9),\n    trail: new Float32Array(TRAIL * 3), tn: 0, tip: new Float32Array(TIP * 9), pn: 0,\n    zb: new Float32Array(W * HALF), rgb: new Float32Array(N * 3),\n  };\n  launch(params.s, 0, 0.06);\n}\n\n// A throw: |L| set so the handle would spin about the middle axis at OMEGA,\n// the start direction moved from the middle axis toward e1 (Axis -1) or e3\n// (Axis 1), then tipped by the nudge; the orientation is the least turn that\n// sets that direction upright, so the angular momentum points straight up.\nfunction launch(S, axis, nudge) {\n  const t = (axis * PI) / 2, c0 = [max(0, -sin(t)), cos(t), max(0, sin(t))];\n  let d = LEAN.map((v, k) => v - (LEAN[0] * c0[0] + LEAN[1] * c0[1] + LEAN[2] * c0[2]) * c0[k]);\n  if (hypot(d[0], d[1], d[2]) \u003c 1e-6) d = [1, 0, 0];\n  d = nrm(d);\n  const a = nudge * NUDGE, l = nrm(c0.map((v, k) => v * cos(a) + d[k] * sin(a))), Lm = OMEGA * S.I[1];\n  for (let k = 0; k \u003c 3; k++) S.L[k] = l[k] * Lm;\n  // The least turn taking l to (0, 1, 0): about l x up, by the angle between.\n  const ax = [-l[2], 0, l[0]], s = hypot(ax[0], ax[2]), ang = Math.atan2(s, l[1]);\n  if (s \u003c 1e-9) (S.q[0] = 1), (S.q[1] = S.q[2] = S.q[3] = 0);\n  else (S.q[0] = cos(ang / 2)), (S.q[1] = (sin(ang / 2) * ax[0]) / s), (S.q[2] = 0), (S.q[3] = (sin(ang / 2) * ax[2]) / s);\n  (S.a0 = axis), (S.n0 = nudge), (S.tn = 0), (S.pn = 0), (S.pend = 0), (S.flips = 0);\n  // The polhode this throw rides: its energy is fixed, so it is fixed too.\n  // The cap it bounds round its pole is tinted (1), the curve drawn in front\n  // (2) and behind (3). The region code names the pole: 0 and 1 are +e1 and\n  // -e1, 2 and 3 are +e3 and -e3.\n  const iI = S.iI, e = l[0] * l[0] * iI[0] + l[1] * l[1] * iI[1] + l[2] * l[2] * iI[2], eS = iI[1];\n  const reg = e > eS ? (l[0] > 0 ? 0 : 1) : l[2] > 0 ? 2 : 3, sg = e > eS ? 1 : -1;\n  const { front, back, eF, eB, cap } = S;\n  const inF = (i) => front[i] >= 0 && front[i] >> 2 === reg && sg * (eF[i] - e) > 0;\n  const inB = (i) => back[i] >= 0 && back[i] >> 2 === reg && sg * (eB[i] - e) > 0;\n  cap.fill(0);\n  for (let y = 0; y \u003c HALF; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (front[i] \u003c 0) continue;\n      const nb = [x + 1 \u003c W ? i + 1 : -1, y + 1 \u003c HALF ? i + W : -1, x > 0 ? i - 1 : -1, y > 0 ? i - W : -1];\n      const f = inF(i), b = inB(i);\n      if (f && nb.some((j) => j >= 0 && front[j] >= 0 && !inF(j))) cap[i] = 2;\n      else if (f) cap[i] = 1;\n      else if (b && nb.some((j) => j >= 0 && back[j] >= 0 && !inB(j))) cap[i] = 3;\n    }\n}\n\n// Euler's equations dL/dt = L x w with w = L / I in the handle's frame, and\n// the orientation dq/dt = q (0, w) / 2, stepped together by RK4.\nfunction deriv(S, s, o) {\n  const iI = S.iI, wx = s[0] * iI[0], wy = s[1] * iI[1], wz = s[2] * iI[2], w = s[3], x = s[4], y = s[5], z = s[6];\n  o[0] = s[1] * wz - s[2] * wy;\n  o[1] = s[2] * wx - s[0] * wz;\n  o[2] = s[0] * wy - s[1] * wx;\n  o[3] = -0.5 * (x * wx + y * wy + z * wz);\n  o[4] = 0.5 * (w * wx + y * wz - z * wy);\n  o[5] = 0.5 * (w * wy + z * wx - x * wz);\n  o[6] = 0.5 * (w * wz + x * wy - y * wx);\n}\nconst ST = new Float64Array(7), K1 = new Float64Array(7), K2 = new Float64Array(7), K3 = new Float64Array(7), K4 = new Float64Array(7), TMP = new Float64Array(7);\nfunction step(S, h) {\n  for (let k = 0; k \u003c 3; k++) ST[k] = S.L[k];\n  for (let k = 0; k \u003c 4; k++) ST[3 + k] = S.q[k];\n  deriv(S, ST, K1);\n  for (let k = 0; k \u003c 7; k++) TMP[k] = ST[k] + 0.5 * h * K1[k];\n  deriv(S, TMP, K2);\n  for (let k = 0; k \u003c 7; k++) TMP[k] = ST[k] + 0.5 * h * K2[k];\n  deriv(S, TMP, K3);\n  for (let k = 0; k \u003c 7; k++) TMP[k] = ST[k] + h * K3[k];\n  deriv(S, TMP, K4);\n  for (let k = 0; k \u003c 7; k++) ST[k] += (h / 6) * (K1[k] + 2 * K2[k] + 2 * K3[k] + K4[k]);\n  for (let k = 0; k \u003c 3; k++) S.L[k] = ST[k];\n  // Only the quaternion is renormalised; L is left as RK4 leaves it.\n  const l = hypot(ST[3], ST[4], ST[5], ST[6]);\n  for (let k = 0; k \u003c 4; k++) S.q[k] = ST[3 + k] / l;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.axis = cl(k[2], -1, 1);\n  S.nudge = cl(k[3], 0, 1);\n  // A turned Axis or Nudge throws again once the knob has rested 0.3 s; the\n  // first frame throws at once with the knobs it is handed.\n  if (S.t === 0 && (S.axis !== S.a0 || S.nudge !== S.n0)) launch(S, S.axis, S.nudge);\n  else if (abs(S.axis - S.a0) > 1e-4 || abs(S.nudge - S.n0) > 1e-4) {\n    if (S.pend \u003c= 0) S.pend = 0.3;\n    if (abs(S.axis - (S.ax1 ?? S.axis)) > 1e-4 || abs(S.nudge - (S.nu1 ?? S.nudge)) > 1e-4) S.pend = 0.3;\n    S.pend -= d;\n    if (S.pend \u003c= 0) launch(S, S.axis, S.nudge);\n  }\n  (S.ax1 = S.axis), (S.nu1 = S.nudge);\n  if (input.btnPressed && input.btnPressed.some(Boolean)) launch(S, S.axis, S.nudge);\n  // Speed 2 is real time; steps of at most 1/240 s of the handle's time.\n  const span = (d * S.speed) / 2, n = max(1, ceil(span * 240));\n  const was = S.L[1];\n  for (let i = 0; i \u003c n; i++) step(S, span / n);\n  if (was > 0 !== S.L[1] > 0) S.flips++;\n  S.t += d;\n  const q = S.q, m = S.m, w = q[0], x = q[1], y = q[2], z = q[3];\n  m[0] = 1 - 2 * (y * y + z * z), m[1] = 2 * (x * y - w * z), m[2] = 2 * (x * z + w * y);\n  m[3] = 2 * (x * y + w * z), m[4] = 1 - 2 * (x * x + z * z), m[5] = 2 * (y * z - w * x);\n  m[6] = 2 * (x * z - w * y), m[7] = 2 * (y * z + w * x), m[8] = 1 - 2 * (x * x + y * y);\n  // The trails: the momentum's direction in the handle's frame, and where\n  // the stem's tip is in space.\n  const Lm = hypot(S.L[0], S.L[1], S.L[2]) || 1, o = (S.tn % TRAIL) * 3;\n  for (let j = 0; j \u003c 3; j++) S.trail[o + j] = S.L[j] / Lm;\n  S.tn++;\n  const ty = S.tipY, p = (S.pn % TIP) * 9;\n  for (let j = 0; j \u003c 3; j++) {\n    S.tip[p + j] = m[j * 3 + 1] * ty;\n    S.tip[p + 3 + j] = m[j * 3] * 1.1 - m[j * 3 + 1] * (1.35 - ty);\n    S.tip[p + 6 + j] = -m[j * 3] * 1.1 - m[j * 3 + 1] * (1.35 - ty);\n  }\n  S.pn++;\n}\n\n// World (centre of mass at the origin, y up, z toward the camera) to the\n// screen: [x, y, 1 / depth].\nconst CE = cos(ELEV), SE = sin(ELEV);\nfunction proj(p, out, o) {\n  const vx = p[0], vy = p[1] - CAMD * SE, vz = p[2] - CAMD * CE;\n  const zc = -(vy * SE + vz * CE), ux = vx, uy = vy * CE - vz * SE;\n  out[o] = 32 + (FOC * ux) / zc;\n  out[o + 1] = CY0 - (FOC * uy) / zc;\n  out[o + 2] = 1 / zc;\n}\n\nfunction tri(S, ax, ay, az, bx, by, bz, cx, cy, cz, r, g, b) {\n  const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(area) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(HALF - 2, ceil(max(ay, by, cy)));\n  const zb = S.zb, rgb = S.rgb;\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const w0 = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / area, w1 = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / area, w2 = 1 - w0 - w1;\n      if (w0 \u003c 0 || w1 \u003c 0 || w2 \u003c 0) continue;\n      const iz = w0 * az + w1 * bz + w2 * cz, i = y * W + x;\n      if (iz \u003c= zb[i]) continue;\n      zb[i] = iz;\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n  }\n}\n\n// A line of LEDs from a to b in colour c times v, kept off LEDs the handle\n// covers when depth is given.\nfunction line(S, ax, ay, bx, by, c, v, y0, y1) {\n  const steps = ceil(max(abs(bx - ax), abs(by - ay))) + 1, rgb = S.rgb;\n  for (let s = 0; s \u003c= steps; s++) {\n    const t = s / steps, x = floor(mix(ax, bx, t)), y = floor(mix(ay, by, t));\n    if (x \u003c 0 || x >= W || y \u003c y0 || y > y1) continue;\n    const i = y * W + x;\n    if (y \u003c HALF && S.zb[i] > 0) continue;\n    (rgb[i * 3] = max(rgb[i * 3], c[0] * v)), (rgb[i * 3 + 1] = max(rgb[i * 3 + 1], c[1] * v)), (rgb[i * 3 + 2] = max(rgb[i * 3 + 2], c[2] * v));\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { m, zb, rgb, faces, cls } = S;\n  // The three colours: A the crossbar and the e1 polhodes, B the stem, its\n  // tip and the momentum, C the e3 polhodes. Warm ones are lifted.\n  const hA = 0.58 + S.hue, hB = 0.09 + S.hue, hC = 0.79 + S.hue;\n  const cA = hsv(hA, 0.8, 1), cB = hsv(hB, 0.82, 1), cC = hsv(hC, 0.62, 1), wB = warm(hB), wA = warm(hA), wC = warm(hC);\n  const tipC = hsv(hB, 0.35, 1);\n  rgb.fill(0);\n  zb.fill(0);\n  // The handle: each face that looks toward the camera, flat shaded.\n  const wp = [0, 0, 0], sp = new Float64Array(12);\n  for (const f of faces) {\n    const n = f.n, nx = m[0] * n[0] + m[1] * n[1] + m[2] * n[2], ny = m[3] * n[0] + m[4] * n[1] + m[5] * n[2], nz = m[6] * n[0] + m[7] * n[1] + m[8] * n[2];\n    const p0 = f.pts[0], cx = m[0] * p0[0] + m[1] * p0[1] + m[2] * p0[2], cy = m[3] * p0[0] + m[4] * p0[1] + m[5] * p0[2], cz = m[6] * p0[0] + m[7] * p0[1] + m[8] * p0[2];\n    if (nx * cx + ny * (cy - CAMD * SE) + nz * (cz - CAMD * CE) >= 0) continue;\n    for (let j = 0; j \u003c 4; j++) {\n      const p = f.pts[j];\n      wp[0] = m[0] * p[0] + m[1] * p[1] + m[2] * p[2];\n      wp[1] = m[3] * p[0] + m[4] * p[1] + m[5] * p[2];\n      wp[2] = m[6] * p[0] + m[7] * p[1] + m[8] * p[2];\n      proj(wp, sp, j * 3);\n    }\n    const lit = max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]), wm = f.part === 0 ? wA : wB;\n    const sh = floor((0.3 + 0.45 * wm + (0.7 - 0.45 * wm) * lit) * 10) / 10, col = f.part === 0 ? cA : f.part === 1 ? cB : tipC;\n    tri(S, sp[0], sp[1], sp[2], sp[3], sp[4], sp[5], sp[6], sp[7], sp[8], col[0] * sh, col[1] * sh, col[2] * sh);\n    tri(S, sp[0], sp[1], sp[2], sp[6], sp[7], sp[8], sp[9], sp[10], sp[11], col[0] * sh, col[1] * sh, col[2] * sh);\n  }\n  // The angular momentum, fixed and upright: a dim line through the centre\n  // of mass with an arrowhead at the top, where the handle does not cover it.\n  const grey = [0.5, 0.5, 0.56];\n  line(S, 32, 61, 32, 1, grey, 0.42, 0, HALF - 2);\n  line(S, 32, 1, 28, 5, grey, 0.42, 0, HALF - 2), line(S, 32, 1, 36, 5, grey, 0.42, 0, HALF - 2);\n  // The stem tip's path over the last 1.3 s and the crossbar ends' over the\n  // last 0.3 s, older steps dimmer.\n  const a = new Float64Array(3), b2 = new Float64Array(3);\n  for (let j = 1; j \u003c min(S.pn, TIP); j++)\n    for (let e = 0; e \u003c 3; e++) {\n      if (e && j > 10) break;\n      const i0 = ((S.pn - j) % TIP) * 9 + e * 3, i1 = ((S.pn - j - 1) % TIP) * 9 + e * 3;\n      const v = e ? 0.15 + 0.45 * floor((1 - j / 10) * 4) / 4 : 0.2 + 0.6 * floor((1 - j / TIP) * 5) / 5;\n      proj(S.tip.subarray(i0, i0 + 3), a, 0);\n      proj(S.tip.subarray(i1, i1 + 3), b2, 0);\n      line(S, a[0], a[1], b2[0], b2[1], e ? cA : cB, v, 0, HALF - 2);\n    }\n  // The momentum sphere, its classes coloured for this hue.\n  const lift = (c, v, w) => [c[0] * v * (1 + 0.5 * w), c[1] * v * (1 + 0.5 * w), c[2] * v * (1 + 0.5 * w)];\n  const pal = [\n    [0, 0, 0], lift(cA, 0.17, wA), lift(cC, 0.17, wC), [0.27, 0.27, 0.32], [0.48, 0.48, 0.54],\n    lift(cA, 0.62, wA), lift(cC, 0.62, wC), [0.7, 0.7, 0.76], [0.34, 0.34, 0.4],\n  ];\n  const capA = lift(cA, 0.3, wA), capC = lift(cC, 0.3, wC), orb = lift(cB, 0.5, 0), orbB = lift(cB, 0.27, 0), cap = S.cap;\n  for (let i = 0; i \u003c W * HALF; i++) {\n    const k = cls[i], o = (i + W * HALF) * 3, f = cap[i];\n    let c = pal[k];\n    if (f === 2 && k !== 8) c = orb;\n    else if (f === 1 && k \u003c 3) c = k === 1 ? capA : capC;\n    else if (f === 3 && k \u003c 3) c = orbB;\n    (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n  }\n  // The two ends of the middle axis, where the separatrices cross, ringed in\n  // the stem's colour.\n  const { R, U, B } = S, scr = (p) => [SX + SR * (p[0] * R[0] + p[1] * R[1] + p[2] * R[2]), SY - SR * (p[0] * U[0] + p[1] * U[1] + p[2] * U[2]), p[0] * B[0] + p[1] * B[1] + p[2] * B[2]];\n  for (const sg of [1, -1]) {\n    const [x, y, z] = scr([0, sg, 0]), v = z > 0 ? 0.9 : 0.5;\n    for (const [dx, dy] of [[-2, 0], [2, 0], [0, -2], [0, 2], [-1, -1], [1, -1], [-1, 1], [1, 1]]) line(S, x + dx, y + dy, x + dx, y + dy, cB, v, HALF, H - 1);\n  }\n  // The momentum's trail in the handle's frame over the last 5 s: in front\n  // of the sphere bright, behind it dimmer, older steps dimmer still.\n  const cnt = min(S.tn, TRAIL), tr = S.trail;\n  for (let j = 1; j \u003c cnt; j++) {\n    const i0 = ((S.tn - j) % TRAIL) * 3, i1 = ((S.tn - j - 1) % TRAIL) * 3;\n    const p = scr([tr[i0], tr[i0 + 1], tr[i0 + 2]]), q = scr([tr[i1], tr[i1 + 1], tr[i1 + 2]]);\n    const v = (0.3 + 0.7 * floor((1 - j / TRAIL) * 5) / 5) * (p[2] + q[2] > 0 ? 1 : 0.45) * (1 + 0.3 * wB);\n    line(S, p[0], p[1], q[0], q[1], cB, v, HALF, H - 1);\n    line(S, p[0] + 1, p[1], q[0] + 1, q[1], cB, v * 0.8, HALF, H - 1);\n  }\n  // The momentum now: a bright dot, white at the centre.\n  const nowI = ((S.tn - 1 + TRAIL) % TRAIL) * 3, now = scr([tr[nowI], tr[nowI + 1], tr[nowI + 2]]);\n  for (let dy = -2; dy \u003c= 2; dy++)\n    for (let dx = -2; dx \u003c= 2; dx++) {\n      const x = floor(now[0]) + dx, y = floor(now[1]) + dy, r = abs(dx) + abs(dy);\n      if (r > 2 || x \u003c 0 || x >= W || y \u003c HALF || y >= H) continue;\n      const o = (y * W + x) * 3, c = r === 0 ? [1, 1, 1] : r === 1 ? tipC : cB;\n      (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n    }\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","werewolf":"// ===== Patternflow pattern =====\n// Title:   Werewolf\n// Family:  halloween\n// Idea:    Clouds slide off a huge full moon and the black figure of a man standing on a rock in front of it bends forward with his back arching, his arms stretching down into forelegs and his face into a muzzle, until a wolf with pricked ears stands there and howls rings into the night; then the clouds come back over the moon and the wolf shrinks into the man again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Moon=-1..1\n//\n// Knob 1: Hue. The night sky and the clouds, through the cold colours only: at 0 purple, at 0.25 indigo, at 0.5 deep sea blue, at 0.75 teal and at 1 poison green. The moon stays pale gold.\n// Knob 2: Speed. At 2 one night takes 15 seconds: the bank of clouds is past the man by 2 s, the change runs from 0.4 s to 4.4 s, the wolf raises its head at 5 s and howls from 5.5 s to 8.6 s with a ring every 0.3 s, the clouds are back over the moon by 12 s and the wolf is a man again by 13.5 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Clouds. At 0 four thin clouds veil the moon, letting about half its light through, and two wisps cross the high sky; at 1 the four are heavy, three more trail behind them across the moon until 4 s into the night, and six thick wisps fill the high sky.\n// Knob 4: Moon. Its radius: 22 LEDs at -1, 27 at the opening 0.06 and 32 at 1, where it fills the panel's width.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, acos, round, PI } = Math;\nconst hypot = (x, y) => sqrt(x * x + y * y);\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst lerp = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// Channels in steps of 4 of 255: flat areas stay flat for the panel.\nconst q4 = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\n// Signed distances in LEDs, negative inside.\nconst circle = (px, py, cx, cy, r) => hypot(px - cx, py - cy) - r;\nfunction capsule(px, py, ax, ay, bx, by, ra, rb) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey || 1), 0, 1);\n  return hypot(qx - u * ex, qy - u * ey) - (ra + (rb - ra) * u);\n}\nconst smin = (a, b, k) => {\n  const h = cl(0.5 + (0.5 * (b - a)) / k, 0, 1);\n  return b + (a - b) * h - k * h * (1 - h);\n};\n\n// The moon, the ground line the figure stands on, and one night in story seconds.\nconst MX = 32, MY = 74, G = 104, NIGHT = 15;\nconst MOON = [1, 0.9, 0.6];\n// The rock's top edge per column, flat under the figure and falling away in\n// steps at both ends, and the far hills, hidden behind the rock in the middle.\nconst CREST = new Float32Array(W), RIDGE = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) {\n  const l = max(0, 14 - x), r = max(0, x - 50);\n  // Boulders at both ends of the top, clear of where the feet go.\n  const knob = -2.2 * max(0, 1 - abs(x - 14.5) / 3) - 1.6 * max(0, 1 - abs(x - 50) / 2.5);\n  CREST[x] = G + knob + 0.95 * l + 1.15 * r + min(1, (l + r) / 3) * (2.2 * abs(sin(x * 0.75)) + 0.8 * sin(x * 2.1));\n  RIDGE[x] = 96 + 9 * cos((PI * (x - 32)) / 64) ** 2 + 1.3 * sin(x * 0.37) + 0.6 * sin(x * 1.3);\n}\n// Seas on the moon as [dx, dy, rx, ry] in units of its radius.\nconst SEAS = [[-0.3, -0.3, 0.22, 0.18], [0.27, -0.4, 0.18, 0.15], [0.36, 0.1, 0.22, 0.22], [-0.42, 0.22, 0.18, 0.22], [0.04, 0.45, 0.22, 0.14]];\n// Stars: LED and twinkle phase, in the high sky.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 24; i++) {\n  const x = floor(hash(3 * i + 1) * W), y = floor(2 + hash(3 * i + 2) * 40);\n  STARS.push([y * W + x, hash(3 * i + 3) * TAU]);\n}\n// The bank of clouds that covers and uncovers the moon, [dx, dy, half length,\n// thickness] about the moon's centre, most important first; and the wisps of\n// the high sky, [row, start, half length, thickness]. Each is a row of puffs\n// with a flat foot. The first four always come; the other three trail to the\n// right, so on a cloudy night they are still crossing the moon while the\n// change begins.\nconst BANK = [[-4, -9, 22, 9], [9, 10, 22, 8], [-12, 27, 18, 7], [10, -28, 17, 6], [46, -16, 18, 8], [58, 6, 20, 9], [70, 24, 20, 8]];\nconst WISPS = [[14, 0.1, 16, 3.5], [31, 0.55, 19, 4], [6, 0.8, 12, 3], [41, 0.3, 14, 3.5], [23, 0.95, 17, 3], [49, 0.7, 12, 3]];\n[...BANK, ...WISPS].forEach((C, j) => {\n  const L = C[2], T = C[3], n = 1 + Math.ceil((2 * L) / (0.8 * T));\n  C.puffs = [];\n  for (let i = 0; i \u003c n; i++) {\n    const e = (2 * i) / (n - 1) - 1, r = T * (0.7 + 0.55 * hash(j * 31 + i)) * (1 - 0.45 * e * e);\n    C.puffs.push([L * e, 0.35 * T - 0.55 * r, r]);\n  }\n});\n\n// A cloud's distance field: its puffs blended, its foot cut flat.\nfunction puff(C, px, py, th) {\n  let d = 99;\n  for (const [ux, uy, ur] of C.puffs) d = smin(d, hypot(px - ux, py - uy * th) - ur * th, 0.5 * C[3]);\n  return max(d, py - C[3] * 0.45 * th);\n}\n\n// A cloud's shape at thickness th as a mask over its box, its centre on an\n// LED: 1 edge, 2 body, plus 4 along the lit top.\nfunction shape(C, th) {\n  const L = C[2], T = C[3], ox = -ceil(L + T) - 1, oy = -ceil(2 * T * th) - 1, w = 1 - 2 * ox, h = 2 - oy + ceil(T);\n  const m = new Uint8Array(w * h);\n  for (let j = 0; j \u003c h; j++)\n    for (let i = 0; i \u003c w; i++) {\n      const px = ox + i + 0.5, py = oy + j + 0.5, d = puff(C, px, py, th);\n      if (d \u003c= 0) m[j * w + i] = (d > -1.2 ? 1 : 2) | (puff(C, px, py - 1.3, th) > 0 ? 4 : 0);\n    }\n  C.mask = { th, ox, oy, w, h, m };\n}\n\n// Two poses for the one skeleton, facing right: a man standing and a wolf on\n// four legs. Points are LEDs on the panel, angles in radians (0 right, pi/2\n// down), radii in LEDs. The legs are placed by where the feet go, so the\n// change keeps them on the rock. hip: where it is; spine: the back's angle\n// and length; rad: the body's radius at hip, middle and shoulder; head: angle\n// and distance from the shoulder; arm: where the arm leaves the shoulder;\n// up, fore: arm bones; wrists and hand: where the hands go and the hand\n// itself; toes and foot: where the toes go and the foot back to the ankle.\nconst MAN = {\n  hip: [31.5, 80.5], spine: -1.5, len: 18, rad: [3.4, 3.3, 3.9], chest: 0,\n  head: [-1.38, 7.8], face: 0.05, neck: [1.6, 1.6],\n  arm: [0.3, 1.5], up: 9.5, fore: 8.5, wrists: [[2.6, 16.6], [-2.4, 16.2]], hand: [[0.7, 3.2], [-0.3, 3.2]], ar: [1.6, 1.25, 1],\n  thigh: 12, shin: 11.5, toes: [[36.5, G], [33, G]], foot: [[4.3, 1.4], [4.3, 1.4]], lr: [2.4, 1.7, 1.15],\n};\nconst WOLF = {\n  hip: [21, 82.5], spine: -0.07, len: 21, rad: [4.2, 4.4, 5.4], chest: 4.8,\n  head: [-0.8, 10.5], face: 0.15, neck: [3.9, 2.7],\n  arm: [1.5, 2.5], up: 9, fore: 10, wrists: [[46.5, 101], [40.5, 101]], hand: [[1.6, 2.8], [1.6, 2.8]], ar: [2.2, 1.35, 1.05],\n  thigh: 9.5, shin: 9, toes: [[25.5, G], [18.5, G]], foot: [[2.5, 6.6], [2.5, 6.6]], lr: [3.2, 1.6, 1.05],\n};\n\n// Two-bone reach from (ax, ay) toward (tx, ty); bend 1 puts the middle joint\n// on the clockwise side. Writes joint and end into out.\nfunction reach(ax, ay, tx, ty, l1, l2, bend, out) {\n  const dx = tx - ax, dy = ty - ay, d = cl(hypot(dx, dy), abs(l1 - l2) + 0.01, l1 + l2 - 0.01), a = atan2(dy, dx);\n  const th = acos(cl((l1 * l1 + d * d - l2 * l2) / (2 * l1 * d), -1, 1)), a1 = a + bend * th;\n  out[0] = ax + l1 * cos(a1);\n  out[1] = ay + l1 * sin(a1);\n  const b = atan2(ty - out[1], tx - out[0]);\n  out[2] = out[0] + l2 * cos(b);\n  out[3] = out[1] + l2 * sin(b);\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, clouds: 0, moon: 0.06, key: \"\", m: 0, lift: 0, bankX: 0, howling: false, night: 0,\n    rings: [], ringClock: 0, P: null,\n    base: new Float32Array(N * 3), mc: new Float32Array(N), nm: new Float32Array(N), buf: new Float32Array(N * 3), sil: new Float32Array(N), ra: new Float32Array(N), info: { u: 0, v: 0 },\n  };\n}\n\n// Where the story is at story time t of the night: the change m (0 man, 1\n// wolf), the howl's lift and the bank's offset from the moon.\nfunction story(S) {\n  const t = S.t % NIGHT;\n  S.m = t \u003c 10.5 ? ease((t - 0.4) / 4) : 1 - ease((t - 10.5) / 3);\n  S.lift = ease((t - 5) / 0.6) - ease((t - 8.6) / 0.6);\n  S.bankX = t \u003c 9 ? -130 * ease(t / 5) : 130 * (1 - ease((t - 9) / 3));\n  S.howling = t > 5.5 && t \u003c 8.6;\n  S.night = t;\n}\n\n// The skeleton at the change m, each part on its own schedule: the back bends\n// first and arches most half way, the arms and legs follow, then the face,\n// and last the ears, tail and fur.\nfunction pose(S) {\n  const m = S.m, l = S.lift, sp = ease(m / 0.6), fl = ease((m - 0.12) / 0.6), hl = ease((m - 0.2) / 0.6);\n  const hd = ease((m - 0.3) / 0.5), late = ease((m - 0.5) / 0.45), bulk = ease((m - 0.1) / 0.7);\n  // A shudder while it changes.\n  const sh = sin(PI * m) * sin(S.t * 23) * 0.05, A = MAN, B = WOLF;\n  const P = (S.P = S.P || { leg: [[0, 0, 0, 0], [0, 0, 0, 0]], arm: [[0, 0, 0, 0], [0, 0, 0, 0]], ft: [[0, 0], [0, 0]], hn: [[0, 0], [0, 0]], tail: new Float32Array(10) });\n  P.hd = hd;\n  P.late = late;\n  P.fur = ease((m - 0.35) / 0.6);\n  P.bulk = bulk;\n  const hx = lerp(A.hip[0], B.hip[0], sp), hy = lerp(A.hip[1], B.hip[1], hl) - 1.2 * l;\n  const sa = lerp(A.spine, B.spine, sp) + sh - 0.12 * l, ln = lerp(A.len, B.len, sp);\n  const arch = 4.5 * sin(PI * cl(m / 0.85, 0, 1)) + 1.2 * bulk;\n  P.hip = [hx, hy];\n  P.sh = [hx + ln * cos(sa), hy + ln * sin(sa)];\n  // The middle of the back bulges away from the belly: behind him while he\n  // stands, up once the back is level.\n  P.mid = [hx + 0.5 * ln * cos(sa) + arch * sin(sa), hy + 0.5 * ln * sin(sa) - arch * cos(sa)];\n  P.rad = A.rad.map((r, i) => lerp(r, B.rad[i], bulk));\n  P.chest = lerp(A.chest, B.chest, bulk);\n  // The head: up and back in the howl, thrown back once in the middle of the change.\n  const throwBack = 0.5 * sin(PI * cl((m - 0.25) / 0.5, 0, 1));\n  const ha = lerp(A.head[0], B.head[0], hd) - 0.5 * l - throwBack, hl2 = lerp(A.head[1], B.head[1], hd);\n  P.head = [P.sh[0] + hl2 * cos(ha), P.sh[1] + hl2 * sin(ha)];\n  P.face = lerp(A.face, B.face, hd) - 1.25 * l - 0.9 * throwBack;\n  P.neck = A.neck.map((r, i) => lerp(r, B.neck[i], bulk));\n  P.jaw = 0.35 * ease((S.night - 5.4) / 0.3) * (1 - ease((S.night - 8.5) / 0.3)) + 0.25 * throwBack;\n  // Arms to forelegs: the wrists go from beside the thighs to the rock ahead.\n  const ax = P.sh[0] + lerp(A.arm[0], B.arm[0], fl), ay = P.sh[1] + lerp(A.arm[1], B.arm[1], fl) - 1.5 * l;\n  P.ar = A.ar.map((r, i) => lerp(r, B.ar[i], fl));\n  for (let k = 0; k \u003c 2; k++) {\n    const wa = A.wrists[k], wb = B.wrists[k];\n    const tx = lerp(P.sh[0] + wa[0], wb[0], fl), ty = lerp(P.sh[1] + wa[1], wb[1], fl) + sh * 20 * (k ? -1 : 1);\n    reach(ax, ay, tx, ty, lerp(A.up, B.up, fl), lerp(A.fore, B.fore, fl), 1, P.arm[k]);\n    const hv = A.hand[k], wv = B.hand[k];\n    P.hn[k] = [P.arm[k][2] + lerp(hv[0], wv[0], fl), P.arm[k][3] + lerp(hv[1], wv[1], fl)];\n  }\n  P.root = [ax, ay];\n  // Legs: the man's foot becomes the wolf's long hind foot, the heel rising to a hock.\n  P.lr = A.lr.map((r, i) => lerp(r, B.lr[i], hl));\n  for (let k = 0; k \u003c 2; k++) {\n    const ta = A.toes[k], tb = B.toes[k], fa = A.foot[k], fb = B.foot[k];\n    const tx = lerp(ta[0], tb[0], hl), fx = lerp(fa[0], fb[0], hl), fy = lerp(fa[1], fb[1], hl);\n    P.ft[k] = [tx, G];\n    reach(hx, hy + 1, tx - fx, G - fy, lerp(A.thigh, B.thigh, hl), lerp(A.shin, B.shin, hl), -1, P.leg[k]);\n  }\n  // The box the figure lies in: every joint, the muzzle's tip and the ears.\n  const fc = cos(P.face), fs = sin(P.face), pts = [P.hip, P.mid, P.sh, P.head, P.root, ...P.hn, ...P.ft, [P.head[0] + 10 * fc, P.head[1] + 10 * fs], [P.head[0] + 7 * fs, P.head[1] - 7 * fc]];\n  for (const a of [...P.arm, ...P.leg]) pts.push([a[0], a[1]], [a[2], a[3]]);\n  let x0 = 99, x1 = -99, y0 = 999, y1 = -99;\n  for (const [x, y] of pts) (x0 = min(x0, x)), (x1 = max(x1, x)), (y0 = min(y0, y)), (y1 = max(y1, y));\n  P.box = [x0 - 6, x1 + 6, y0 - 6, y1 + 3];\n  // The tail grows from the rump and hangs, swaying.\n  const T = P.tail;\n  let x = hx - 2.5 * sp, y = hy - 1, a = 2.45;\n  T[0] = x;\n  T[1] = y;\n  for (let i = 1; i \u003c 5; i++) {\n    a -= 0.12 + 0.05 * sin(S.t * 2.1 + i);\n    x += 4.2 * late * cos(a);\n    y += 4.2 * late * sin(a);\n    T[2 * i] = x;\n    T[2 * i + 1] = y;\n    P.box[0] = min(P.box[0], x - 4);\n  }\n}\n\n// The body as a list of tapered capsules, 11 numbers each: two ends, two\n// radii, how softly it joins what came before (0 a hard union), and a box\n// beyond which it cannot change the field where it matters, within 3 LEDs of\n// the edge.\nconst PART = 11, MAXP = 24;\nfunction parts(S) {\n  const P = S.P, L = (S.parts = S.parts || new Float32Array(PART * MAXP));\n  let n = 0;\n  const add = (ax, ay, bx, by, ra, rb, k) => {\n    const o = PART * n++, r = max(ra, rb) + 3 + k;\n    L.set([ax, ay, bx, by, ra, rb, k, min(ax, bx) - r, max(ax, bx) + r, min(ay, by) - r, max(ay, by) + r], o);\n  };\n  const [rh, rm, rs] = P.rad;\n  add(P.hip[0], P.hip[1], P.mid[0], P.mid[1], rh, rm, 0);\n  add(P.mid[0], P.mid[1], P.sh[0], P.sh[1], rm, rs, 2);\n  if (P.chest > 0.1) add(P.sh[0] + 1.5, P.sh[1] + 2.6, P.sh[0] + 1.5, P.sh[1] + 2.6, P.chest, P.chest, 2);\n  add(P.sh[0], P.sh[1], P.head[0], P.head[1], P.neck[0], P.neck[1], 1.5);\n  for (let k = 0; k \u003c 2; k++) {\n    const a = P.arm[k], r = P.ar;\n    add(P.root[0] - k * 1.5, P.root[1], a[0], a[1], r[0] + P.bulk * 0.8, r[1], 1.2);\n    add(a[0], a[1], a[2], a[3], r[1], r[2], 0);\n    add(a[2], a[3], P.hn[k][0], P.hn[k][1], r[2], 0.8 + 0.2 * P.late, 0);\n  }\n  for (let k = 0; k \u003c 2; k++) {\n    const g = P.leg[k], r = P.lr;\n    add(P.hip[0] - k, P.hip[1] + 1, g[0], g[1], r[0] + P.bulk, r[1], 1.5);\n    add(g[0], g[1], g[2], g[3], r[1], r[2], 0);\n    add(g[2], g[3], P.ft[k][0], P.ft[k][1] - 0.6, r[2], 0.9, 0);\n  }\n  if (P.late > 0.02) {\n    const T = P.tail, f = (i) => 1.2 + 1.3 * P.late * sin((PI * (i + 0.6)) / 4.6);\n    for (let i = 0; i \u003c 4; i++) add(T[2 * i], T[2 * i + 1], T[2 * i + 2], T[2 * i + 3], f(i), f(i + 1), 1);\n  }\n  S.np = n;\n  P.fc = cos(P.face);\n  P.fs = sin(P.face);\n  P.jc = cos(P.jaw);\n  P.js = sin(P.jaw);\n}\n\n// The figure's distance field at (px, py).\nfunction figure(S, px, py) {\n  const P = S.P, info = S.info, L = S.parts;\n  let d = 99;\n  for (let i = 0, o = 0; i \u003c S.np; i++, o += PART) {\n    if (px \u003c L[o + 7] || px > L[o + 8] || py \u003c L[o + 9] || py > L[o + 10]) continue;\n    const c = capsule(px, py, L[o], L[o + 1], L[o + 2], L[o + 3], L[o + 4], L[o + 5]), k = L[o + 6];\n    d = k > 0 && d \u003c 50 ? smin(d, c, k) : min(d, c);\n  }\n  // The head in its own frame (u along the face, v down): the man's head and\n  // the wolf's head blended as distance fields, so the muzzle grows out of the\n  // face and the ears rise out of the skull.\n  const qx = px - P.head[0], qy = py - P.head[1], u = qx * P.fc + qy * P.fs, v = -qx * P.fs + qy * P.fc;\n  info.u = u;\n  info.v = v;\n  if (u > -9 && u \u003c 14 && v > -12 && v \u003c 8) {\n    const man = min(circle(u, v, 0, -0.3, 3.5), capsule(u, v, 2.4, 0.6, 3.9, 1.2, 1, 0.7), capsule(u, v, 0.5, 2.2, 2.6, 2.8, 1.4, 0.9));\n    let wolf = smin(circle(u, v, -0.5, -0.4, 3.4), capsule(u, v, 1.5, -0.6, 9, 0.5, 2.3, 1.15), 1.2);\n    const ju = 1.5 + (u - 1.5) * P.jc + (v - 1.6) * P.js, jv = 1.6 - (u - 1.5) * P.js + (v - 1.6) * P.jc;\n    wolf = smin(wolf, capsule(ju, jv, 1.5, 1.6, 8, 1.8, 1.5, 0.75), 0.8);\n    // Ears grow out of the skull late in the change, laid back in the howl.\n    const e = P.late, back = (0.9 + 0.4 * S.lift) * e, up = 6.4 * e;\n    wolf = min(wolf, capsule(u, v, -2, -1.6, -2 - back, -1.6 - up, 1.5, 0.15), capsule(u, v, 0.1, -1.6, 0.1 - back, -1.6 - up, 1.5, 0.15));\n    d = min(d, man + (wolf - man) * P.hd);\n  }\n  // Fur: a ragged edge that grows with the change.\n  if (P.fur > 0 && d > -2 && d \u003c 2) d -= P.fur * 0.8 * max(0, sin(px * 1.9 + py * 0.8) * sin(py * 1.7 - px * 0.6) + 0.2);\n  return d;\n}\n\n// Sky, moon, glow, ridge and rock, kept until Hue or Moon move. mc is 1 where\n// the moon shows, for the rim light and the rings; nm is how near the moon an\n// LED is (1 on it, 0 from 14 LEDs off), for lighting the clouds.\nfunction background(S, R) {\n  const { base, mc, nm } = S, sky = 0.76 - 0.42 * S.hue, halo = hsv(sky, 0.85, 1);\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = hypot(dx, dy);\n    const t = round(12 * cl(y / G, 0, 1) ** 1.3) / 12;\n    let [cr, cg, cb] = hsv(sky, 0.78, 0.05 + 0.36 * t);\n    // The halo: half moonlight, half the sky's own colour at full strength.\n    const gl = r > R ? round((0.42 * Math.exp(-(r - R) / 5) + 0.12 * Math.exp(-(r - R) / 18)) * 20) / 20 : 0;\n    cr += (MOON[0] + halo[0]) * gl * 0.4;\n    cg += (MOON[1] + halo[1]) * gl * 0.35;\n    cb += (MOON[2] + halo[2]) * gl * 0.35;\n    let moon = 0;\n    if (r \u003c R) {\n      let e = 9;\n      for (const [sx, sy, rx, ry] of SEAS) e = min(e, ((dx / R - sx) / rx) ** 2 + ((dy / R - sy) / ry) ** 2 + 0.2 * sin(dx * 0.9 + dy));\n      const k = e \u003c 1 ? 0.84 : e \u003c 1.5 ? 0.92 : 1;\n      [cr, cg, cb] = [MOON[0] * k, MOON[1] * k, MOON[2] * k];\n      moon = 1;\n    }\n    // The far ridge across the moon's foot, then the rock, its top moonlit.\n    if (y + 0.5 > RIDGE[x]) {\n      [cr, cg, cb] = hsv(sky, 0.7, y + 0.5 - RIDGE[x] \u003c 1.2 ? 0.2 : 0.12);\n      moon = 0;\n    }\n    if (y + 0.5 > CREST[x]) {\n      // Black rock, its top edge moonlit, split by three long cracks.\n      const top = y + 0.5 - CREST[x] \u003c 1.3, dy = y + 0.5 - G;\n      let crack = false;\n      for (const c of [19, 34, 47]) if (abs(x + 0.5 - c + 0.55 * dy - 2 * sin(dy * 0.3)) \u003c 0.5 && dy > 2 && dy \u003c 20) crack = true;\n      const flat = CREST[x] - G \u003c 1.5;\n      [cr, cg, cb] = top ? (flat ? [0.42, 0.37, 0.3] : [0.16, 0.13, 0.15]) : crack ? [0.09, 0.07, 0.11] : [0.025, 0.015, 0.04];\n      moon = 0;\n    }\n    mc[p] = moon;\n    nm[p] = moon ? 1 : y + 0.5 > RIDGE[x] ? 0 : round(cl(1 - (r - R) / 14, 0, 1) * 4) / 4;\n    base[3 * p] = cr;\n    base[3 * p + 1] = cg;\n    base[3 * p + 2] = cb;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.clouds = cl(k[2], 0, 1);\n  S.moon = cl(k[3], -1, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  story(S);\n  pose(S);\n  parts(S);\n  // Rings leave the nose every 0.3 s while it holds the note, and spread.\n  if (S.howling && (S.ringClock -= ds) \u003c= 0) {\n    S.ringClock = 0.3;\n    const P = S.P, ca = cos(P.face), sa = sin(P.face);\n    S.rings.push({ x: P.head[0] + 9.5 * ca - 0.5 * sa, y: P.head[1] + 9.5 * sa + 0.5 * ca, a: P.face, r: 1 });\n  }\n  for (const r of S.rings) r.r += 20 * ds;\n  S.rings = S.rings.filter((r) => r.r \u003c 56);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const R = 27 + 5 * S.moon, key = `${S.hue.toFixed(3)} ${R.toFixed(2)}`;\n  if (key !== S.key) {\n    S.key = key;\n    background(S, R);\n  }\n  const { base, mc, nm, buf, sil } = S, sky = 0.76 - 0.42 * S.hue;\n  buf.set(base);\n  // Stars twinkle in the high sky.\n  for (const [p, ph] of STARS) {\n    const v = 0.35 + 0.3 * sin(S.t * 2.3 + ph);\n    if (buf[3 * p + 2] \u003c 0.3) buf.fill(v, 3 * p, 3 * p + 3);\n  }\n  // Clouds: dark bodies that let some of the moon through, their edges lit\n  // where they cross it or pass near it.\n  const nb = 4 + round(3 * S.clouds), nw = 2 + round(4 * S.clouds), op = 0.55 + 0.37 * S.clouds;\n  const body = hsv(sky, 0.35, 0.27), lit = [0.72, 0.66, 0.54];\n  const cloud = (C, cx, cy, a, th) => {\n    if (!C.mask || C.mask.th !== th) shape(C, th);\n    const { ox, oy, w, h, m } = C.mask, x0 = round(cx) + ox, y0 = round(cy) + oy;\n    if (x0 >= W || x0 + w \u003c= 0) return;\n    for (let j = 0; j \u003c h; j++) {\n      const y = y0 + j;\n      if (y \u003c 0 || y > G) continue;\n      for (let i = 0; i \u003c w; i++) {\n        const x = x0 + i, k = m[j * w + i];\n        if (!k || x \u003c 0 || x >= W) continue;\n        const p = y * W + x, o = 3 * p, near = nm[p], rim = k & 4 ? 0.25 + 0.6 * near : 0, al = k & 1 ? a * 0.75 : a;\n        for (let c = 0; c \u003c 3; c++) buf[o + c] += (body[c] + 0.12 * near + (lit[c] - body[c]) * rim - buf[o + c]) * al;\n      }\n    }\n  };\n  const tb = round((0.8 + 0.45 * S.clouds) * 20) / 20, tw = round((0.7 + 1.1 * S.clouds) * 20) / 20;\n  for (let i = 0; i \u003c nb; i++) cloud(BANK[i], MX + BANK[i][0] + S.bankX, MY + BANK[i][1], op, tb);\n  for (let i = 0; i \u003c nw; i++) {\n    const C = WISPS[i], span = W + 2 * C[2] + 24, x = (((C[1] * span - S.t * (2.5 + i * 0.4)) % span) + span) % span - C[2] - 12;\n    cloud(C, x, C[0], op * 0.8, tw);\n  }\n  // Rings of the howl: arcs about the muzzle's line, pale on the sky and a\n  // cool shadow on the moon, fading as they spread.\n  const ra = S.ra, hit = [];\n  for (const g of S.rings) {\n    const fade = 1 - g.r / 56;\n    for (const rad of [g.r - 0.4, g.r + 0.4]) {\n      const n = ceil(3 * rad) + 2;\n      for (let i = 0; i \u003c n; i++) {\n        const th = -0.75 + (1.5 * i) / (n - 1), x = floor(g.x + rad * cos(g.a + th)), y = floor(g.y + rad * sin(g.a + th));\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const p = y * W + x, a = fade * (1 - abs(th) / 0.75) * 0.9;\n        if (!ra[p]) hit.push(p);\n        ra[p] = max(ra[p], a);\n      }\n    }\n  }\n  for (const p of hit) {\n    const o = 3 * p, a = ra[p], on = mc[p] > 0;\n    buf[o] += ((on ? 0.42 : 0.6) - buf[o]) * a;\n    buf[o + 1] += ((on ? 0.66 : 1) - buf[o + 1]) * a;\n    buf[o + 2] += ((on ? 0.5 : 0.7) - buf[o + 2]) * a;\n    ra[p] = 0;\n  }\n  // The figure, black. Its edge takes a rim of moonlight one LED wide, but\n  // only where the figure is thicker than that, so a thin leg stays black.\n  const P = S.P, bx0 = max(1, floor(P.box[0])), bx1 = min(W - 1, ceil(P.box[1])), by0 = max(1, floor(P.box[2])), by1 = min(G + 1, ceil(P.box[3]));\n  let eyeP = -1, eyeU = 9;\n  sil.fill(1);\n  for (let y = by0; y \u003c by1; y++)\n    for (let x = bx0; x \u003c bx1; x++) {\n      const p = y * W + x, dd = (sil[p] = figure(S, x + 0.5, y + 0.5));\n      // The eye: the LED nearest its place in the head's frame.\n      const eu = S.info.u - 1.3, ev = S.info.v + 1.1, e2 = eu * eu + ev * ev;\n      if (dd \u003c -0.6 && e2 \u003c eyeU) (eyeU = e2), (eyeP = p);\n    }\n  for (let y = by0; y \u003c by1; y++)\n    for (let x = bx0; x \u003c bx1; x++) {\n      const p = y * W + x, dd = sil[p];\n      if (dd >= 0) continue;\n      const deep = min(sil[p - 1], sil[p + 1], sil[p - W], sil[p + W]) \u003c -1.3;\n      const o = 3 * p, rim = dd > -1 && deep ? (mc[p] > 0 ? 0.42 : 0.3) : 0;\n      buf[o] = 0.02 + MOON[0] * rim;\n      buf[o + 1] = 0.012 + MOON[1] * rim;\n      buf[o + 2] = 0.03 + MOON[2] * rim;\n    }\n  // The eye kindles amber as the face changes.\n  if (eyeP >= 0 && P.hd > 0.15) {\n    const e = ease((P.hd - 0.15) / 0.4);\n    buf[3 * eyeP] = e;\n    buf[3 * eyeP + 1] = 0.72 * e;\n    buf[3 * eyeP + 2] = 0.1 * e;\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) display.setPixel(x, y, q4(buf[3 * p]), q4(buf[3 * p + 1]), q4(buf[3 * p + 2]));\n}\n","barn-owl":"// ===== Patternflow pattern =====\n// Title:   Barn Owl\n// Family:  halloween\n// Idea:    A gnarled dead tree stands the full height of a purple night, roots in the grass and bare branches across a big full moon, where a pale barn owl swivels its heart-shaped face far round and back and blinks, then drops off and swoops down the whole panel with big wingbeats to grab a mouse in the grass or miss it, then beats back up as dead leaves fall.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hunger=0..1, Wind=0..1\n//\n// Knob 1: Hue. The sky's colour; moon, owl, tree and leaves stay. At 0 a violet night, at 0.25 a deep red one, at 0.5 a dark olive green one and at 0.75 a dark teal one, each a little paler towards the grass.\n// Knob 2: Speed. At 2 the swoop from branch to grass takes 1.4 s, the owl stands over its catch 0.55 s and the climb back takes 2.3 s at three wingbeats a second; a leaf falls from the branches to the grass in 6 to 10 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Hunger. How long the owl sits between hunts at Speed 2: 6 s at 0, 4 s at half and 1.5 s at 1, give or take 15%, the first hunt at 2.4 s, 1.6 s and 0.7 s. It goes for the further mouse and catches two in three; a caught one hangs from its talons and is swallowed on the branch 2 s later.\n// Knob 4: Wind. At 0.06 the crown stirs by a LED, a tenth of the sky up top is cloud drifting right at 5 LEDs a second and a leaf comes off about every 2 s; at 0.5 the crown sways up to 5 LEDs, a quarter is cloud at 15 a second and a leaf comes off each second; at 1 the crown sways up to 10 LEDs, two fifths is cloud racing over the moon at 25 a second and the leaves blow sideways at 22.\n// Buttons: K1 tap sends the owl down now, if it is on its branch.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The moon, behind the upper branches on the right.\nconst MX = 43, MY = 26, MR = 17;\nconst groundY = (x) => 121 + round(1.2 * sin(x / 6 + 0.5) + 0.7 * sin(x / 2.3));\n\n// The tree: limbs as [parent limb, point on it, x, y, half width for each\n// point]. The trunk kinks up the left third; the owl sits on limb 2.\nconst LIMBS = [\n  [-1, 0, [14, 128, 5.6, 14, 121, 4.6, 16, 112, 3.9, 13, 101, 3.6, 17, 90, 3.3, 15, 79, 3.1, 19, 68, 2.8, 18, 58, 2.5, 21, 49, 2.2, 20, 39, 1.9, 24, 29, 1.6, 23, 19, 1.2, 26, 9, 0.8, 25, 3, 0.5]],\n  [0, 1, [14, 121, 3, 8, 123, 2.2, 3, 126, 1.5, 0, 128, 1.2]],\n  [0, 8, [21, 49, 1.8, 28, 47, 1.6, 35, 47, 1.3, 42, 45, 1, 48, 42, 0.7, 52, 37, 0.5]],\n  [0, 1, [15, 121, 2.8, 22, 124, 2, 28, 127, 1.3]],\n  [0, 9, [20, 40, 1.4, 27, 34, 1.2, 34, 31, 1, 41, 26, 0.8, 47, 24, 0.6, 54, 19, 0.5]],\n  [0, 11, [23, 21, 1, 28, 15, 0.8, 33, 12, 0.6, 37, 6, 0.5]],\n  [0, 7, [18, 60, 1.5, 11, 55, 1.2, 6, 50, 0.9, 3, 43, 0.6, 1, 38, 0.5]],\n  [0, 10, [24, 31, 1.2, 17, 26, 0.9, 11, 21, 0.7, 7, 14, 0.5]],\n  [0, 5, [15, 80, 1.6, 9, 75, 1.1, 5, 69, 0.7]],\n  [4, 2, [34, 31, 0.7, 37, 37, 0.5, 41, 39, 0.5]],\n  [4, 3, [41, 26, 0.6, 45, 31, 0.5, 49, 32, 0.4]],\n  [2, 3, [42, 45, 0.6, 46, 50, 0.5, 49, 51, 0.4]],\n  [5, 1, [28, 15, 0.6, 31, 7, 0.5, 30, 2, 0.4]],\n  [7, 2, [11, 21, 0.6, 14, 15, 0.5, 13, 9, 0.4]],\n  [6, 2, [6, 50, 0.6, 1, 52, 0.4]],\n  [4, 4, [47, 24, 0.5, 52, 27, 0.4, 57, 26, 0.4]],\n  [0, 12, [26, 9, 0.6, 30, 4, 0.4]],\n  [8, 1, [9, 75, 0.7, 4, 78, 0.5, 1, 77, 0.4]],\n];\n// Each point's distance up the tree from the root, for the sway.\nconst TREE = LIMBS.map(([par, at, P]) => ({ par, at, P, n: P.length / 3, s: new Float32Array(P.length / 3) }));\nfor (const L of TREE) {\n  if (L.par >= 0) L.s[0] = TREE[L.par].s[L.at];\n  for (let i = 1; i \u003c L.n; i++) L.s[i] = L.s[i - 1] + Math.hypot(L.P[i * 3] - L.P[i * 3 - 3], L.P[i * 3 + 1] - L.P[i * 3 - 2]);\n}\n// The perch: on limb 2 between its second and third points.\nconst PERCH = [2, 1, 0.55];\n\n// The moon's tone (limb, sea, bright) and its glow in rings.\nconst MOONT = new Uint8Array(N), GLOW = new Float32Array(N);\nconst SEAS = [[-6, -5, 5, 4], [5, -2, 4, 5], [-2, 6, 6, 3], [7, 8, 3, 3]];\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR) {\n    const sea = SEAS.some(([cx, cy, rx, ry]) => ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 \u003c 1);\n    MOONT[p] = r > MR - 1.2 ? 1 : sea ? 2 : 3;\n  } else GLOW[p] = r \u003c MR + 3 ? 0.26 : r \u003c MR + 7 ? 0.15 : r \u003c MR + 13 ? 0.08 : r \u003c MR + 22 ? 0.035 : 0;\n}\nconst MOONC = [0, [240, 196, 120], [255, 238, 196], [255, 222, 150]];\n// Clouds: a noise sheet that wraps round, slid along by the wind; CQ is it\n// sorted, so a cover maps straight to a threshold.\nconst CW = 128, CH = 24, CN = new Float32Array(CW * CH);\nfor (let p = 0; p \u003c CW * CH; p++)\n  for (const [c, a] of [[8, 0.6], [4, 0.3], [2, 0.15]]) {\n    const n = CW / c, u = (p % CW) / c, w = floor(p / CW) / (c / 2), iu = floor(u), iw = floor(w), su = sm(u - iu), sw = sm(w - iw);\n    const hh = (x, y) => hash((((x % n) + n) % n) * 131 + y * 977 + c * 7);\n    CN[p] += a * ((hh(iu, iw) * (1 - su) + hh(iu + 1, iw) * su) * (1 - sw) + (hh(iu, iw + 1) * (1 - su) + hh(iu + 1, iw + 1) * su) * sw);\n  }\nconst CQ = Float32Array.from(CN).sort();\nconst STARS = [];\nfor (let k = 0, x, y; STARS.length \u003c 26; k++) if (((x = floor(hash(k * 3 + 1) * W)) - MX) ** 2 + ((y = floor(hash(k * 3 + 2) * 84)) - MY) ** 2 > 625) STARS.push([x, y, hash(k * 3 + 3) * TAU]);\n\nconst CREAM = [250, 240, 220], BUFF = [238, 176, 96], GOLD = [242, 196, 128], FACE = [255, 252, 246], RIM = [222, 140, 76];\nconst DOT = [196, 160, 136], EYE = [18, 6, 12], LID = [214, 168, 140], BEAK = [236, 198, 168], LEG = [214, 180, 168], LINE = [26, 10, 34];\nconst LEAFC = [[255, 148, 36], [255, 196, 64], [250, 108, 40]], GRASS = [70, 150, 64], BLADE = [34, 86, 44], EARTH = [14, 10, 18];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, cloud: 282, begun: false, mice: [], leaves: [], leafT: 0.3,\n    mode: 0, mt: 0, ox: 0, oy: 0, tilt: 0, spread: 0, flap: 0, talons: 0, face: 0, blink: 0, carry: 0, eat: 0, look: [], lt: 0,\n    sky: new Float32Array(H * 3), skyKey: -1, buf: new Float32Array(N * 3), tm: new Uint8Array(N), ob: new Float32Array(48 * 48 * 3), om: new Uint8Array(48 * 48),\n  };\n}\n\n// Limb k at point i and a share f on, swayed: tips most, a wave up the tree.\nfunction limbAt(S, k, i, f, out) {\n  const L = TREE[k], P = L.P, j = min(i + 1, L.n - 1);\n  const x = P[i * 3] + (P[j * 3] - P[i * 3]) * f, y = P[i * 3 + 1] + (P[j * 3 + 1] - P[i * 3 + 1]) * f, s = L.s[i] + (L.s[j] - L.s[i]) * f;\n  const a = ((s * s) / 12000) * (0.3 + 5.7 * S.wind);\n  const g = sin(S.t * 1.7 - s * 0.035) + 0.45 * sin(S.t * 4.1 + s * 0.11 + k);\n  out[0] = x + a * g;\n  out[1] = y + a * g * 0.25 * (x \u003c 20 ? -1 : 1) * 0.5;\n  return out;\n}\n\nconst tmp = [0, 0], tmp2 = [0, 0];\nfunction perch(S) {\n  limbAt(S, PERCH[0], PERCH[1], PERCH[2], tmp);\n  return [tmp[0], tmp[1] - 1.2];\n}\n\nconst mouse = (x) => ({ x, tx: x, y: 0, wait: rnd(0.2, 1.2), dir: 1, hide: 0, run: 0, flee: 0 });\nconst leaf = (x, y, c) => ({ x, y, c, ph: rnd(0, TAU), w: rnd(2.5, 4.5), vy: rnd(10, 15) });\n\n// A cubic Bézier through four points.\nconst bez = (p, t, k) => {\n  const u = 1 - t;\n  return u * u * u * p[k] + 3 * u * u * t * p[2 + k] + 3 * u * t * t * p[4 + k] + t * t * t * p[6 + k];\n};\n\nfunction startHunt(S) {\n  const live = S.mice.filter((m) => m.hide \u003c= 0 && !m.flee);\n  if (!live.length) return false;\n  const [px, py] = perch(S);\n  let m = live[0];\n  for (const q of live) if (abs(q.x - px) > abs(m.x - px)) m = q;\n  Object.assign(S, { prey: m, catchIt: Math.random() \u003c 0.67, mode: 1, mt: 0, px, py });\n  return true;\n}\n\n// The path down: off the branch, out wide on the side away from the mouse,\n// and in low over the grass to it.\nfunction swoopPath(S) {\n  const m = S.prey, ex = cl(m.x + m.dir * 6, 8, 56), ey = groundY(round(ex)) - 8, side = ex > S.ox ? -1 : 1;\n  S.path = [S.ox, S.oy, S.ox + side * 26, S.oy + 34, ex - side * 30, ey - 26, ex, ey];\n}\n\nfunction climbPath(S) {\n  const [px, py] = perch(S), side = S.ox \u003c 32 ? 1 : -1;\n  S.path = [S.ox, S.oy, S.ox + side * 22, S.oy - 40, px + side * 30, py + 30, px, py - 10];\n}\n\nconst T_DROP = 0.35, T_SWOOP = 1.4, T_STRIKE = 0.55, T_CLIMB = 2.3, T_LAND = 0.5;\n\nfunction owl(S, ds) {\n  S.mt += ds;\n  const [px, py] = perch(S);\n  const bx = S.ox, by = S.oy;\n  if (S.mode === 0) {\n    // On the branch: feet on the limb, the head looking about.\n    Object.assign(S, { ox: px, oy: py - 9, spread: max(0, S.spread - ds * 3), talons: 0, flap: 0, tilt: S.tilt * 0.8 });\n    if (S.carry && (S.eat += ds) > 2.2) (S.carry = 0), (S.eat = 0);\n    // The head: a turn far round to one side, back, a glance the other way.\n    S.lt += ds;\n    if (!S.look.length || S.lt > S.look[S.look.length - 1][0]) {\n      const far = rnd(0.5, 1) \u003c 0.5 ? -1 : 1;\n      S.look = [[0, S.face], [0.5, far * rnd(1.8, 2.6)], [1.6, far * rnd(1.8, 2.6)], [2.2, 0], [2.9, 0], [3.3, -far * rnd(0.6, 1.1)], [3.9, -far * 0.8], [4.3, 0], [5.4, 0]];\n      S.lt = 0;\n    }\n    let k = 1;\n    while (k \u003c S.look.length - 1 && S.look[k][0] \u003c S.lt) k++;\n    const [t0, a0] = S.look[k - 1], [t1, a1] = S.look[k];\n    S.face = a0 + (a1 - a0) * sm((S.lt - t0) / max(1e-6, t1 - t0));\n    S.blink = (S.lt % 2.7) > 2.55 ? 1 : 0;\n    if ((S.wait -= ds) \u003c 0 && !S.carry && !startHunt(S)) S.wait = 1;\n    return;\n  }\n  S.blink = 0;\n  S.face *= exp(-ds * 10);\n  const t = S.mt;\n  if (S.mode === 1) {\n    // Off the branch: the wings open as it falls.\n    const f = t / T_DROP;\n    Object.assign(S, { spread: sm(f * 1.4), flap: 0.8 - 0.6 * f, ox: S.px + 3 * f, oy: S.py - 9 + 6 * f * f });\n    if (t >= T_DROP) (S.mode = 2), (S.mt = 0), swoopPath(S);\n  } else if (S.mode === 2) {\n    // The swoop: two beats, then a long glide; the end follows the mouse.\n    const f = min(1, t / T_SWOOP), u = f * f * (3 - 2 * f) * 0.6 + f * 0.4, m = S.prey;\n    S.path[6] += (cl(m.x, 6, 58) - S.path[6]) * min(1, ds * 3);\n    Object.assign(S, { ox: bez(S.path, u, 0), oy: bez(S.path, u, 1), spread: 1, talons: sm((f - 0.7) / 0.3) });\n    S.flap = t \u003c 0.75 ? 0.15 + 0.7 * sin(TAU * 2.6 * t) : 0.1 + 0.25 * sm((f - 0.8) / 0.2);\n    if (f >= 1) {\n      (S.mode = 3), (S.mt = 0);\n      if (S.catchIt && abs(m.x - S.ox) \u003c 6 && !m.flee) (S.carry = 1), (m.hide = rnd(3, 6)), (m.x = rnd(0, 1) \u003c 0.5 ? -4 : 68);\n      else (m.flee = 1), (m.dir = m.x \u003c S.ox ? -1 : 1);\n    }\n  } else if (S.mode === 3) {\n    // On the grass: wings held high over the catch, a beat, and off.\n    Object.assign(S, { spread: 1, talons: 1, flap: 0.95 - 0.4 * sin(PI * cl(t / T_STRIKE, 0, 1)), oy: S.oy + sin(t * 9) * ds * 3 });\n    if (t >= T_STRIKE) (S.mode = 4), (S.mt = 0), climbPath(S);\n  } else if (S.mode === 4) {\n    // The climb back up: hard wingbeats, three a second.\n    const f = min(1, t / T_CLIMB), u = f * f * (3 - 2 * f);\n    (S.path[6] = px), (S.path[7] = py - 10);\n    Object.assign(S, { ox: bez(S.path, u, 0), oy: bez(S.path, u, 1), spread: 1, flap: 0.2 + 0.75 * sin(TAU * 3 * t), talons: S.carry ? 1 : max(0, 1 - t * 3) });\n    if (f >= 1) (S.mode = 5), (S.mt = 0);\n  } else {\n    // Landing: a flare and the wings fold.\n    const f = min(1, t / T_LAND);\n    Object.assign(S, { ox: px, oy: py - 10 + f, flap: 0.9, spread: 1 - sm(f), talons: S.carry ? 1 - f : 0 });\n    if (f >= 1) (S.mode = 0), (S.mt = 0), (S.wait = waitOf(S)), (S.look = []), (S.eat = 0);\n  }\n  const vx = (S.ox - bx) / max(1e-4, ds);\n  S.tilt += (cl(vx * 0.012, -0.45, 0.45) - S.tilt) * min(1, ds * 6);\n}\n\nconst waitOf = (S) => 6 - 4.5 * S.hunger * (1 - 0.25 * (1 - S.hunger)) * rnd(0.85, 1.15);\n\nfunction mice(S, ds) {\n  for (const m of S.mice) {\n    m.y = groundY(cl(round(m.x), 0, W - 1)) - 1;\n    if (m.hide > 0) {\n      if ((m.hide -= ds) \u003c= 0) Object.assign(m, { x: rnd(0, 1) \u003c 0.5 ? -3 : 67, tx: rnd(12, 52), flee: 0, wait: 0 });\n    } else if (m.flee) {\n      (m.x += m.dir * 60 * ds), (m.run += ds * 14);\n      if (m.x \u003c -6 || m.x > 70) (m.hide = rnd(1.5, 3)), (m.flee = 0);\n    } else if (m === S.prey && S.mode === 2) {\n      // A last dash as the owl comes in.\n      (m.x += m.dir * 18 * ds), (m.run += ds * 12);\n      if (m.x \u003c 6 || m.x > 58) m.dir = -m.dir;\n    } else if ((m.wait -= ds) \u003c 0) {\n      const d = m.tx - m.x;\n      m.dir = d \u003c 0 ? -1 : 1;\n      (m.x += m.dir * min(abs(d), 26 * ds)), (m.run += ds * 12);\n      if (abs(d) \u003c 0.5) (m.wait = rnd(0.3, 1.6)), (m.tx = cl(m.x + rnd(-24, 24), 6, 58));\n    }\n  }\n}\n\nfunction leaves(S, ds) {\n  S.leafT -= ds * (0.4 + 1.6 * S.wind);\n  if (S.leafT \u003c 0 && S.leaves.length \u003c 4 + floor(6 * S.wind)) {\n    S.leafT += rnd(0.6, 1.4);\n    const k = [2, 4, 5, 6, 7, 9, 10, 11, 13, 15][floor(rnd(0, 10))], L = TREE[k];\n    limbAt(S, k, floor(rnd(1, L.n - 1)), rnd(0, 1), tmp2);\n    S.leaves.push(leaf(tmp2[0], tmp2[1], floor(rnd(0, 3))));\n  }\n  S.leaves = S.leaves.filter((l) => {\n    l.ph += ds * l.w;\n    l.x += (S.wind * 22 + 7 * sin(l.ph)) * ds;\n    l.y += l.vy * (0.65 + 0.35 * abs(cos(l.ph))) * ds;\n    return l.y \u003c groundY(cl(round(l.x), 0, W - 1)) && l.x > -4 && l.x \u003c 68;\n  });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.hunger, S.wind] = [cl(k[0], 0, 1), cl(k[1], 0.2, 3), cl(k[2], 0, 1), cl(k[3], 0, 1)];\n  const ds = (d * S.speed) / 2;\n  if (!S.begun) {\n    S.begun = true;\n    S.mice = [mouse(14), mouse(46)];\n    S.wait = 2.4 - 1.7 * S.hunger;\n    // A few leaves already on their way down.\n    for (let i = 0; i \u003c 3; i++) S.leaves.push(leaf(rnd(8, 56), rnd(20, 110), i));\n  }\n  S.t += ds;\n  S.cloud += ds * (4 + 21 * S.wind);\n  if (input.btnPressed && input.btnPressed[0] && S.mode === 0) (S.carry = 0), startHunt(S);\n  owl(S, ds);\n  mice(S, ds);\n  leaves(S, ds);\n}\n\n// The sky by row, in ten flat steps: deep overhead, paler low down.\nfunction skyRows(S) {\n  if (S.skyKey === S.hue) return;\n  S.skyKey = S.hue;\n  for (let y = 0, t; y \u003c H; y++) (t = floor((y / H) * 10) / 9), S.sky.set(hsv(0.76 + S.hue + 0.03 * t, 0.84 - 0.2 * t, 0.2 + 0.2 * t, [0, 0, 0]), 3 * y);\n}\n\nfunction put(buf, x, y, c, f = 1) {\n  (x = round(x)), (y = round(y));\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (buf[o] = c[0] * f), (buf[o + 1] = c[1] * f), (buf[o + 2] = c[2] * f);\n}\n\n// The owl, drawn in its own frame: u across, v down its body, origin at\n// the middle of the body, turned by its tilt.\nfunction owlPixel(S, u, v) {\n  const sp = S.spread, hx = u, hy = v + 6.4;\n  // The head: square on, the face is a white heart with a tan rim; turned,\n  // it narrows and slides aside, and past a right angle the back shows.\n  if ((hx / 5.4) ** 2 + (hy / 4.9) ** 2 \u003c 1) {\n    const c = cos(S.face), fu = sin(S.face) * 3.8, sx = max(0.2, c);\n    if (c > -0.05) {\n      const uf = (u - fu) / sx, vf = v + 5.9;\n      const heart = (d) => (uf - 2) ** 2 + (vf + 1.1) ** 2 \u003c (2.6 + d) ** 2 || (uf + 2) ** 2 + (vf + 1.1) ** 2 \u003c (2.6 + d) ** 2 || (vf > -1.1 && vf \u003c 3.8 + d && abs(uf) \u003c ((3.8 + d - vf) * 4.6) / 4.9);\n      if (heart(0)) {\n        for (const e of [-1, 1]) if ((u - fu - e * 1.9 * sx) ** 2 + (v + 5.9) ** 2 \u003c 0.7) return S.blink ? LID : EYE;\n        if ((u - fu) ** 2 + (v + 4.1) ** 2 \u003c 0.55) return BEAK;\n        return FACE;\n      }\n      if (heart(0.9 / sx)) return RIM;\n    }\n    // A darker collar, and turned away a ruff, so the head reads as a head.\n    const e = (hx / 5.4) ** 2 + (hy / 4.9) ** 2;\n    if (e > 0.72 && (hy > 1.5 || c \u003c 0)) return DOT;\n    return hash(round(u * 3) * 31 + round(v * 3) * 7) \u003c 0.16 ? DOT : GOLD;\n  }\n  // Turned side on, the beak shows past the edge of the head.\n  if (abs(sin(S.face)) > 0.85 && cos(S.face) > -0.3 && abs(v + 4.6) \u003c 0.6 && abs(u - sin(S.face) * 5.6) \u003c 0.7) return BEAK;\n  // The body, an egg wider below: a cream breast between folded buff wings.\n  const ry = 6.4 - 0.8 * sp, cy = 2.2 - 0.4 * sp, rx = (5.4 - 1.4 * sp) * (1 + 0.1 * cl((v - cy) / ry, -1, 1));\n  if ((u / rx) ** 2 + ((v - cy) / ry) ** 2 \u003c 1) {\n    const breast = abs(u) \u003c 2.7 - 0.5 * sp + (0.8 * (v - cy)) / ry;\n    if (breast) return hash(round(u * 2) * 13 + round(v * 2) * 5) \u003c 0.08 ? DOT : CREAM;\n    return hash(round(u * 2) * 17 + round(v * 2) * 3) \u003c 0.22 ? DOT : BUFF;\n  }\n  if (sp \u003c 0.3 && v > 8.2 && v \u003c 10.4 && abs(u) \u003c (10.4 - v) * 0.9) return DOT;\n  // Legs and talons, reaching down when it strikes or carries.\n  if (S.talons > 0.05) for (const e of [-1, 1]) if (abs(u - e * 1.5) \u003c 0.6 && v > 5 && v \u003c 5.5 + 4.5 * S.talons) return LEG;\n  // The wings: a buff leading edge, cream behind, dark bars near the tip.\n  if (sp > 0.02)\n    for (const e of [-1, 1]) {\n      const sx = e * 2.6, sy = -1.6, L = 13 * sp, a = S.flap, tx = sx + e * L * cos(a), ty = sy - L * sin(a) * 0.9;\n      const ax = tx - sx, ay = ty - sy, l2 = ax * ax + ay * ay;\n      if (l2 \u003c 1) continue;\n      const t = ((u - sx) * ax + (v - sy) * ay) / l2;\n      if (t \u003c -0.05 || t > 1.04) continue;\n      const qx = u - (sx + ax * t), qy = v - (sy + ay * t), il = 1 / sqrt(l2);\n      // The trailing side is the one away from the head.\n      let nx = -ay * il, ny = ax * il;\n      if (ny \u003c 0) (nx = -nx), (ny = -ny);\n      const dn = qx * nx + qy * ny, tc = cl(t, 0, 1), ch = 1.1 + 4.2 * sqrt(max(0, 1 - tc * tc)) * (1 - 0.25 * tc);\n      if (dn \u003c -0.9 || dn > ch) continue;\n      if (tc > 0.7 && (tc * 12) % 1 \u003c 0.3 && dn > 0.6) return DOT;\n      return dn \u003c 0.7 ? BUFF : dn \u003c ch * 0.55 ? GOLD : CREAM;\n    }\n  return null;\n}\n\nfunction drawOwl(S, buf) {\n  const { ob, om } = S, cx = round(S.ox), cy = round(S.oy), ct = cos(S.tilt), st = sin(S.tilt);\n  om.fill(0);\n  for (let j = 0; j \u003c 48; j++)\n    for (let i = 0; i \u003c 48; i++) {\n      const dx = i - 24 + 0.5 + cx - S.ox, dy = j - 24 + 0.5 + cy - S.oy;\n      const c = owlPixel(S, dx * ct + dy * st, -dx * st + dy * ct);\n      if (!c) continue;\n      const o = j * 48 + i;\n      om[o] = 1;\n      (ob[o * 3] = c[0]), (ob[o * 3 + 1] = c[1]), (ob[o * 3 + 2] = c[2]);\n    }\n  for (let j = 0; j \u003c 48; j++)\n    for (let i = 0; i \u003c 48; i++) {\n      const x = cx - 24 + i, y = cy - 24 + j;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = j * 48 + i, p = (y * W + x) * 3;\n      if (om[o]) (buf[p] = ob[o * 3]), (buf[p + 1] = ob[o * 3 + 1]), (buf[p + 2] = ob[o * 3 + 2]);\n      // A dark line round it, so a pale owl stands off a pale moon.\n      else if ((i > 0 && om[o - 1]) || (i \u003c 47 && om[o + 1]) || (j > 0 && om[o - 48]) || (j \u003c 47 && om[o + 48])) (buf[p] = LINE[0]), (buf[p + 1] = LINE[1]), (buf[p + 2] = LINE[2]);\n    }\n}\n\n// A mouse, five LEDs long with an ear, an eye and a tail, legs going.\nconst MOUSE = [204, 186, 172], TAIL = [226, 160, 168];\nfunction drawMouse(buf, x, y, dir, run) {\n  for (let i = -2; i \u003c= 2; i++) put(buf, x + dir * i, y, MOUSE);\n  for (let i = -1; i \u003c= 1; i++) put(buf, x + dir * i, y - 1, MOUSE);\n  put(buf, x + dir * 3, y, MOUSE, 0.85);\n  put(buf, x + dir * 1, y - 2, TAIL);\n  put(buf, x + dir * 2, y - 1, EYE);\n  for (let i = 0; i \u003c 4; i++) put(buf, x - dir * (3 + i), y + (i > 1 ? -1 : 0), TAIL, 0.85);\n  put(buf, x + (floor(run) % 2 ? -1 : 1), y + 1, MOUSE, 0.7);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  skyRows(S);\n  const { buf, sky, tm } = S;\n  const cover = 0.08 + 0.3 * S.wind, thr = CQ[floor((1 - cover) * (CQ.length - 1))], off = S.cloud;\n  // Sky, stars, moon and clouds.\n  for (let y = 0; y \u003c H; y++) {\n    const fy = y / 3.2, j0 = floor(fy) % CH, j1 = (j0 + 1) % CH, ty = fy - floor(fy);\n    const band = y > 60 ? (y - 60) * 0.012 : 0;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p, mt = MOONT[p], gl = GLOW[p];\n      let R = sky[3 * y], G = sky[3 * y + 1], B = sky[3 * y + 2];\n      if (mt) {\n        const c = MOONC[mt];\n        (R = c[0]), (G = c[1]), (B = c[2]);\n      } else if (gl) (R += 255 * gl), (G += 210 * gl), (B += 140 * gl);\n      if (y \u003c 90) {\n        const fx = (x - off) * 0.3, i0 = floor(fx), tx = fx - i0, a0 = ((i0 % CW) + CW) % CW, a1 = (a0 + 1) % CW;\n        const n = (CN[j0 * CW + a0] * (1 - tx) + CN[j0 * CW + a1] * tx) * (1 - ty) + (CN[j1 * CW + a0] * (1 - tx) + CN[j1 * CW + a1] * tx) * ty;\n        const e = n - band - thr;\n        if (e > 0) {\n          const lit = min(1, (mt ? 1 : gl * 3.2) + 0.15);\n          if (e \u003c 0.02) (R = 70 + 150 * lit), (G = 40 + 130 * lit), (B = 92 + 80 * lit);\n          else if (e \u003c 0.06) (R = 50 + 60 * lit), (G = 26 + 50 * lit), (B = 70 + 34 * lit);\n          else (R = 36 + 20 * lit), (G = 16 + 14 * lit), (B = 52 + 12 * lit);\n        }\n      }\n      (buf[o] = R), (buf[o + 1] = G), (buf[o + 2] = B);\n    }\n  }\n  for (const [x, y, ph] of STARS) {\n    const tw = 0.5 + 0.5 * sin(S.t * 3 + ph * 5), o = (y * W + x) * 3;\n    if (buf[o + 2] \u003c 120 && tw > 0.3) (buf[o] += 120 * tw), (buf[o + 1] += 110 * tw), (buf[o + 2] += 130 * tw);\n  }\n  // Leaves behind the tree.\n  drawLeaves(S, buf, 0);\n  // The tree: each limb a run of round-ended strokes, swayed.\n  tm.fill(0);\n  for (let k = 0; k \u003c TREE.length; k++) {\n    const L = TREE[k];\n    let ax = 0, ay = 0, aw = 0;\n    for (let i = 0; i \u003c L.n; i++) {\n      limbAt(S, k, i, 0, tmp);\n      const bx = tmp[0], by = tmp[1], bw = L.P[i * 3 + 2];\n      if (i) {\n        const x0 = max(0, floor(min(ax, bx) - 5)), x1 = min(W - 1, ceil(max(ax, bx) + 5)), y0 = max(0, floor(min(ay, by) - 5)), y1 = min(H - 1, ceil(max(ay, by) + 5));\n        const dx = bx - ax, dy = by - ay, l2 = dx * dx + dy * dy || 1;\n        for (let y = y0; y \u003c= y1; y++)\n          for (let x = x0; x \u003c= x1; x++) {\n            const px = x + 0.5 - ax, py = y + 0.5 - ay, t = cl((px * dx + py * dy) / l2, 0, 1), w = aw + (bw - aw) * t;\n            if ((px - dx * t) ** 2 + (py - dy * t) ** 2 \u003c w * w + 0.15) tm[y * W + x] = 1;\n          }\n      }\n      (ax = bx), (ay = by), (aw = bw);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (!tm[p]) continue;\n      const o = p * 3;\n      // Bark is black; an edge that faces the moon catches its light.\n      const right = x \u003c W - 1 && !tm[p + 1], top = y > 0 && !tm[p - W];\n      const towards = (MX - x) * (right ? 1 : 0) + (MY - y) * (top ? -1 : 0);\n      if ((right || top) && towards > 0) {\n        const f = min(1, 0.45 + GLOW[p] * 2.5 + (MOONT[p] ? 0.6 : 0));\n        (buf[o] = 92 * f), (buf[o + 1] = 58 * f), (buf[o + 2] = 120 * f);\n      } else (buf[o] = 8), (buf[o + 1] = 3), (buf[o + 2] = 12);\n    }\n  // The ground, where the roots go in, and the grass in front of the mice.\n  for (let x = 0; x \u003c W; x++) {\n    const g = groundY(x), h = 2 + floor(hash(x * 7 + 3) * 5), lean = (S.wind * 2.2 + 0.6 * sin(S.t * 2.3 + x * 0.4) * (0.3 + S.wind)) * 0.5;\n    for (let y = g; y \u003c H; y++) if (!tm[y * W + x] || y >= g + 2) put(buf, x, y, EARTH);\n    for (let i = 1; i \u003c= h; i++) {\n      if (hash(x * 13 + i) \u003c 0.4 && i \u003c h - 1) continue;\n      put(buf, x + lean * (i / h) * 2, g - i, i === h ? GRASS : BLADE);\n    }\n  }\n  for (const m of S.mice) if (m.hide \u003c= 0) drawMouse(buf, m.x, m.y, m.dir, m.run);\n  // The owl, and the mouse it carries.\n  drawOwl(S, buf);\n  if (S.carry) {\n    if (S.mode !== 0 || S.eat \u003c 1.3) drawMouse(buf, S.ox, S.oy + 5 + 4.5 * S.talons + 1, 1, 0);\n    else if (S.eat \u003c 2.2) for (let i = 0; i \u003c 3; i++) put(buf, S.ox + 0.5, S.oy - 3 + i, TAIL);\n  }\n  drawLeaves(S, buf, 1);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    // Channels in steps of 4 of 255, too fine to see.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n  }\n}\n\n// Leaves: three LEDs that turn over as they fall, half behind the tree.\nfunction drawLeaves(S, buf, front) {\n  S.leaves.forEach((l, i) => {\n    if ((i & 1) !== front) return;\n    const c = LEAFC[l.c], k = floor((((l.ph % TAU) + TAU) % TAU) / (PI / 2)), f = 0.8 + 0.2 * abs(sin(l.ph));\n    const [dx, dy] = [[1, 0], [1, 1], [0, 1], [-1, 1]][k];\n    put(buf, l.x, l.y, c, f);\n    put(buf, l.x + dx, l.y + dy, c, f * 0.9);\n    put(buf, l.x - dx, l.y - dy, c, f * 0.8);\n  });\n}\n","bone-pile":"// ===== Patternflow pattern =====\n// Title:   Bone Pile\n// Family:  halloween\n// Idea:    A skeleton dances in a violet spotlight in a stone crypt until, on a beat, every bone lets go and the whole frame crashes into a heap on the flagstones, lies still while the skull's eyes kindle, then the bones fly up one at a time on arcs from the feet upward and snap back into place, the skull last, landing with a nod before the dance goes on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dance=4..32, Fog=0..1\n//\n// Knob 1: Hue. The spotlight and all it tints: the wall in the beam, the pool on the flagstones, the dust, the bones' shadow side, the fog and the kindled eyes. Violet at 0, red at 0.24, lime at 0.5, cyan at 0.75; the bones stay ivory, the candles orange.\n// Knob 2: Speed. The tempo, 50 beats a minute for each unit, and the rest keeps time with it. At the opening 2, 100: every bone is down 0.5 s after the beat that drops it, the eyes kindle at 1 s, the pieces fly back one every 0.18 s from 1.5 s and the skull lands at 4.7 s and nods. At 0.2 all ten times slower; 150 at 3.\n// Knob 3: Dance. Beats danced between collapses: 4 at the start, so the first fall comes 2.4 s in and the next 2.8 s after the nod at 7.4 s; 11 at a quarter, 18 at half, 32 at the end, 19 s at 100 a minute. Each time it gets up it dances the next of three dances: a sway with both arms up, kicks to each side with hands on hips, a bounce with the arms pumping in turn.\n// Knob 4: Fog. Ground fog drifting in two layers, thickening over its top 16 rows. None at 0; at the opening 0.06 a wisp from row 115; at 0.5 from row 93, burying half the heap; at 1 from row 68, up to the standing skeleton's hips.\n// Buttons: K1 tap brings the skeleton down at once, mid-dance or half rebuilt.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// --- shapes, each in its own frame with y down, as a distance (negative\n// inside). A hole function marks dark sockets and gaps inside a bone.\nconst seg = (x, y, ax, ay, bx, by) => {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return sqrt((x - ax - dx * t) ** 2 + (y - ay - dy * t) ** 2);\n};\nconst ell = (x, y, cx, cy, rx, ry) => (sqrt(((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2) - 1) * min(rx, ry);\nconst box = (x, y, cx, cy, hx, hy, r) => {\n  const qx = abs(x - cx) - hx + r, qy = abs(y - cy) - hy + r;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n};\n// Kinds: 0 long bone, 1 paired long bones (forearm, shin), 2 rib cage with\n// collarbones and neck, 3 lumbar spine, 4 pelvis, 5 skull, 6 jaw, 7 hand,\n// 8 foot. A long bone is centred on its origin along y, L long.\nfunction long(x, y, L, w, r) {\n  const e = L / 2 - r, q = 0.6 * r, ry = r * 0.9;\n  return min(seg(x, y, 0, -e, 0, e) - w, ell(x, y, -q, -e, r, ry), ell(x, y, q, -e, r, ry), ell(x, y, -q, e, r, ry), ell(x, y, q, e, r, ry));\n}\nconst RIBS = [[7.6, 2.4], [9.4, 6.6], [10.4, 10.8], [10.4, 15], [9.2, 19]];\nfunction shape(k, x, y, sg) {\n  switch (k) {\n    case 0:\n      return long(x, y, sg, 0.85 + 0.015 * sg, 1.45);\n    case 1: {\n      const e = sg / 2 - 1.1;\n      return min(seg(x, y, -1, -e, -1, e) - 0.75, seg(x, y, 1.1, -e, 1.1, e) - 0.55, box(x, y, 0, -e - 0.2, 2.3, 1.1, 1), box(x, y, 0, e + 0.2, 2.1, 1.1, 1));\n    }\n    case 2: {\n      // Origin at the top of the breastbone; the neck rises above it.\n      let d = min(box(x, y, 0, -3.4, 1.5, 0.75, 0.5), box(x, y, 0, -1.4, 1.6, 0.75, 0.5));\n      d = min(d, seg(x, y, -1.4, 0.8, -11.4, -0.2) - 0.75, seg(x, y, 1.4, 0.8, 11.4, -0.2) - 0.75, seg(x, y, 0, 1, 0, 14) - 1.15);\n      for (let v = 15.5; v \u003c 24; v += 2.7) d = min(d, box(x, y, 0, v, 1.6, 0.9, 0.5));\n      for (const [rx, ry] of RIBS) {\n        const c = 3.6 / (rx * rx), ax = min(abs(x), rx), f = ry + c * ax * ax;\n        d = min(d, abs(x) \u003c= rx ? abs(y - f) / sqrt(1 + (2 * c * ax) ** 2) - 0.62 : sqrt((abs(x) - rx) ** 2 + (y - f) ** 2) - 0.62);\n      }\n      return d;\n    }\n    case 3: {\n      let d = 9;\n      for (let v = -4; v \u003c= 4.1; v += 2.7) d = min(d, box(x, y, 0, v, 1.9, 0.95, 0.5), box(x, y, 0, v, 3.1, 0.35, 0.3));\n      return d;\n    }\n    case 4: {\n      // Origin between the hip sockets: two wings tipped outward, the sacrum\n      // narrowing down between them, and two rings round the holes of the\n      // lower pelvis.\n      let d = max(abs(x) - (2.5 - 0.28 * (y + 5.5)), abs(y + 2.6) - 3);\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const dx = x - s * 5.3, dy = y + 3.6, c = 0.8, n = 0.6 * s;\n        d = min(d, ell(dx * c + dy * n, -dx * n + dy * c, 0, 0, 4.1, 2.9), abs(ell(x, y, s * 3.4, 2.4, 2.4, 1.9)) - 0.75, ell(x, y, s * 6.5, 0, 1.5, 1.5));\n      }\n      return d;\n    }\n    case 5:\n      // Origin at the top of the neck; the skull rises above it.\n      return min(ell(x, y, 0, -10.6, 7, 7.3), ell(x, y, 0, -6.8, 6.4, 2.3), box(x, y, 0, -3.2, 4.4, 2.6, 1.4));\n    case 6: {\n      const hw = 4.3 - 0.4 * max(0, y);\n      return min(box(x, y, 0, 1.5, 4.3, 1.6, 0.8), max(abs(x) - hw, abs(y - 1.6) - 1.8));\n    }\n    case 7: {\n      let d = ell(x, y, 0, 1.4, 1.7, 1.3);\n      for (let i = 0; i \u003c 4; i++) d = min(d, seg(x, y, -1.2 + 0.8 * i, 2.2, -1.8 + 1.2 * i, 5.4) - 0.42);\n      return d;\n    }\n    default:\n      return min(ell(x, y, sg * 0.8, 1.6, 3.1, 1.4), ell(x, y, 0, 0.4, 1.4, 1));\n  }\n}\n// 0 none, 1 dark, 2 an eye socket, 3 in shade.\nfunction hole(k, x, y, P) {\n  if (k === 5) {\n    const p = P.pitch * 3;\n    if (((abs(x) - 2.9) / 2.1) ** 2 + ((y + 7.9 - p) / 2.4) ** 2 \u003c 1) return 2;\n    const ny = y + 5.6 - p;\n    if (ny >= 0 && ny \u003c 1.7 && abs(x) \u003c 0.3 + 0.5 * ny) return 1;\n    if (y > -2 + p * 0.5 && y \u003c -0.5 && abs(x) \u003c 4) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 || y > -0.9 ? 1 : 0;\n  } else if (k === 6 && y \u003c 1.2 && y > -0.2 && abs(x) \u003c 3.8) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 ? 1 : 0;\n  // The hollow of each pelvic wing, in shade.\n  else if (k === 4 && ((abs(x) - 4.6) / 2.3) ** 2 + ((y + 4.4 + 0.3 * abs(x)) / 1.3) ** 2 \u003c 1) return 3;\n  return 0;\n}\n\n// The pieces, back to front. [kind, length or side, the bounds of the shape\n// in its own frame].\nconst PIECES = [\n  [8, -1, -3.9, 3.9, -1, 3.2], [8, 1, -3.9, 3.9, -1, 3.2],\n  [1, 24, -2.4, 2.4, -12.4, 12.4], [1, 24, -2.4, 2.4, -12.4, 12.4],\n  [0, 26, -2.5, 2.5, -13.3, 13.3], [0, 26, -2.5, 2.5, -13.3, 13.3],\n  [4, 0, -11, 11, -9, 5.2], [3, 0, -3.5, 3.5, -5.3, 5.3], [2, 0, -12.2, 12.2, -4.5, 22.6],\n  [0, 19, -2.2, 2.2, -9.8, 9.8], [0, 19, -2.2, 2.2, -9.8, 9.8],\n  [1, 17, -2.4, 2.4, -8.9, 8.9], [1, 17, -2.4, 2.4, -8.9, 8.9],\n  [7, 0, -2.6, 2.6, -0.2, 6], [7, 0, -2.6, 2.6, -0.2, 6],\n  [6, 0, -4.4, 4.4, -0.3, 3.5], [5, 0, -7.2, 7.2, -18.1, 0.6],\n];\nconst NB = PIECES.length, SKULL = 16, JAW = 15;\nconst FLOOR = 120, CX = 32, HIPY = 67, HIP = 7, FEMUR = 26, TIBIA = 24, ARM = 19, FORE = 17;\n\n// --- the body: a pose to where each piece sits, [x, y, angle] with the\n// angle turning the piece's own y onto the bone.\nconst at = (P, i, x, y, a) => {\n  P.x[i] = x;\n  P.y[i] = y;\n  P.a[i] = a;\n};\nconst ang = (dx, dy) => atan2(-dx, dy);\nfunction bone(P, i, ax, ay, bx, by) {\n  at(P, i, (ax + bx) / 2, (ay + by) / 2, ang(bx - ax, by - ay));\n}\n// Two-bone reach with the knee bent outward.\nfunction leg(P, s, hx, hy, fx, fy) {\n  const dx = fx - hx, dy = fy - hy, d = cl(sqrt(dx * dx + dy * dy), 3, FEMUR + TIBIA - 0.01);\n  const al = Math.acos(cl((FEMUR * FEMUR + d * d - TIBIA * TIBIA) / (2 * FEMUR * d), -1, 1)), b = atan2(dy, dx) - s * al;\n  const kx = hx + FEMUR * cos(b), ky = hy + FEMUR * sin(b), u = (fx - kx) / sqrt((fx - kx) ** 2 + (fy - ky) ** 2), v = (fy - ky) / sqrt((fx - kx) ** 2 + (fy - ky) ** 2);\n  bone(P, 4 + (s > 0), hx, hy, kx, ky);\n  const ex = kx + TIBIA * u, ey = ky + TIBIA * v;\n  bone(P, 2 + (s > 0), kx, ky, ex, ey);\n  at(P, s > 0 ? 1 : 0, ex, ey, 0);\n}\nconst rot = (a, x, y) => [x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)];\n// Pose numbers: sway, bob, pelvis tilt, torso lean, head roll, nod, jaw,\n// each arm's lift from hanging and elbow bend, each foot's lift and step.\nfunction rig(D, P) {\n  const rx = CX + D.sway, ry = HIPY + D.bob, t = D.tilt, l = D.lean;\n  at(P, 6, rx, ry, t);\n  for (const s of [-1, 1]) {\n    const [hx, hy] = rot(t, s * HIP, 0), f = s \u003c 0 ? D.fl : D.fr;\n    leg(P, s, rx + hx, ry + hy, CX + s * (HIP + f[1]), FLOOR - 3 - f[0]);\n  }\n  const [b0, b1] = rot(t, 0, -5), sx = rx + b0, sy = ry + b1, [c0, c1] = rot(l, 0, -10);\n  bone(P, 7, sx + c0, sy + c1, sx, sy);\n  const [d0, d1] = rot(l, 0, -24), tx = sx + c0 + d0, ty = sy + c1 + d1;\n  at(P, 8, tx, ty, l);\n  for (const s of [-1, 1]) {\n    const [o0, o1] = rot(l, s * 12, 0.4), ax = tx + o0, ay = ty + o1, a1 = s \u003c 0 ? D.al : D.ar, a2 = s \u003c 0 ? D.bl : D.br;\n    const [u0, u1] = rot(l, s * sin(a1), cos(a1)), ex = ax + ARM * u0, ey = ay + ARM * u1;\n    const [v0, v1] = rot(l, s * sin(a1 + a2), cos(a1 + a2)), wx = ex + FORE * v0, wy = ey + FORE * v1;\n    bone(P, 9 + (s > 0), ax, ay, ex, ey);\n    bone(P, 11 + (s > 0), ex, ey, wx, wy);\n    at(P, 13 + (s > 0), wx, wy, ang(v0, v1));\n  }\n  const [n0, n1] = rot(l, 0, -4.4), hd = l + D.head, nx = tx + n0, ny = ty + n1;\n  at(P, SKULL, nx, ny, hd);\n  const [j0, j1] = rot(hd, 0, -0.7 + 2.2 * D.jaw + D.pitch * 0.6);\n  at(P, JAW, nx + j0, ny + j1, hd);\n  P.pitch = D.pitch;\n}\n\nconst REST = { sway: 0, bob: 0, tilt: 0, lean: 0, head: 0, pitch: 0, jaw: 0, al: 0.12, bl: 0.08, ar: 0.12, br: 0.08, fl: [0, 0], fr: [0, 0] };\nconst clack = (b) => max(0, sin(TAU * b)) ** 2;\n// Three dances, each a function of the beat.\nfunction dance(m, b, D) {\n  Object.assign(D, REST, { fl: [0, 0], fr: [0, 0], jaw: clack(b) });\n  if (m === 0) {\n    // Sway: hips side to side over four beats, both arms up waving.\n    const s = sin((PI * b) / 2), w = sin(PI * b);\n    Object.assign(D, { sway: 3 * s, tilt: 0.1 * s, lean: -0.08 * s, head: -0.16 * s, al: 2.5 + 0.18 * w, ar: 2.5 - 0.18 * w, bl: 0.3 + 0.25 * w, br: 0.3 + 0.25 * w });\n  } else if (m === 1) {\n    // Kicks: a foot out to the side each beat, hands on the hips.\n    const k = sin(PI * (b - floor(b))) ** 2, s = floor(b) & 1 ? 1 : -1;\n    D[s \u003c 0 ? \"fl\" : \"fr\"] = [7 * k, 5 * k];\n    Object.assign(D, { sway: -s * 1.2 * k, head: s * 0.12 * k, al: 0.75, ar: 0.75, bl: -1.45, br: -1.45 });\n  } else {\n    // Bounce: a dip at the knees on every beat, the arms pumping up in turn\n    // over two beats.\n    const e = 0.5 - 0.5 * cos(PI * b), w = sin(PI * b);\n    Object.assign(D, { bob: 0.6 - 0.6 * cos(TAU * b), sway: 1.5 * w, head: 0.14 * w, al: 0.5 + 1.2 * e, bl: 0.3 + 0.6 * e, ar: 1.7 - 1.2 * e, br: 0.9 - 0.6 * e });\n  }\n}\n\n// The heap, as [x, y, angle] for each piece with the floor at 120: shins\n// and feet flat, thighs crossed, arms on top, the cage on its side, the\n// pelvis tipped up against it and the skull on the crown, jaw beside it.\nconst HEAP = [\n  [-25, 117.5, 0.2], [24, 117.5, -0.3], [-14, 116.4, 1.62], [13, 116.4, 1.5], [-4, 115.6, 1.32], [6, 115.6, 1.86],\n  [-9, 108.5, 0.55], [12, 111.5, 1.9], [4, 104.5, -1.32], [-15, 112, 1.1], [17, 112.8, 2.1], [-20, 113.5, 1.9], [21, 114.8, 1.3],\n  [-27, 116.2, 2.4], [28, 116.4, -2.2], [15, 106.5, 0.45], [-2, 99.5, 0.3],\n];\nconst BEAM = (x, y) => {\n  // The spotlight's cone from above the panel, 18 LEDs across at the top\n  // and 56 at the floor.\n  const hw = 9 + y * 0.16, d = abs(x + 0.5 - CX) / hw;\n  return d \u003c 0.8 ? 1 : d \u003c 1 ? 0.78 : d \u003c 1.12 ? 0.4 : 0;\n};\n\nconst pose = () => ({ x: new Float64Array(NB), y: new Float64Array(NB), a: new Float64Array(NB), pitch: 0 });\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, bpm: 100, every: 4, fog: 0.06, beat: 0, t: 0,\n    phase: 0, start: 0, base: 0, moves: 0,\n    D: Object.assign({}, REST), Q: pose(), R: pose(),\n    fall: [], heap: [], eye: 0, snap: [], light: [0, 0, 0],\n    bg: new Float32Array(N * 3), buf: new Float32Array(N * 3), low: new Int16Array(W),\n    dust: Array.from({ length: 30 }, () => [CX + (Math.random() - 0.5) * 36, Math.random() * 120, Math.random() * TAU, 2 + Math.random() * 3]),\n  };\n  rig(REST, params.s.R);\n}\n\n// Everything comes down: each piece from where it is now, flung up a little,\n// falls onto its place in the heap and bounces once.\nfunction collapse(S) {\n  if (S.phase === 0 || !S.heap.length) {\n    const m = Math.random() \u003c 0.5 ? -1 : 1;\n    S.heap = HEAP.map(([x, y, a]) => [CX + m * x + (Math.random() - 0.5) * 2, y, m * a + (Math.random() - 0.5) * 0.3]);\n  }\n  S.fall = S.heap.map(([hx, hy, ha], i) => {\n    const x0 = S.Q.x[i], y0 = S.Q.y[i], a0 = S.Q.a[i], v = 4 + Math.random() * 10, g = 520;\n    const T = (v + sqrt(v * v + 2 * g * max(0, hy - y0))) / g;\n    let da = ha - a0;\n    da -= TAU * round(da / TAU);\n    return { x0, y0, a0, hx, hy, da, v, g, T };\n  });\n  S.Q.pitch = 0;\n  S.phase = 1;\n  S.start = S.beat;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.bpm = 50 * cl(k[1], 0.2, 3);\n  S.every = round(cl(k[2], 4, 32));\n  S.fog = cl(k[3], 0, 1);\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    hsv(0.76 + hue, 0.62, 1, S.light);\n    background(S);\n  }\n  const db = (d * S.bpm) / 60;\n  S.beat += db;\n  S.t += d;\n  const B = S.beat, Q = S.Q, D = S.D;\n  if (input.btnPressed && input.btnPressed[0] && S.phase !== 1) collapse(S);\n  S.snap = S.snap.filter((s) => (s[2] -= d) > 0);\n  if (S.phase === 0) {\n    // Dancing, eased in from standing after the skeleton gets up.\n    if (B >= S.base + S.every) {\n      collapse(S);\n    } else {\n      dance(S.moves % 3, B, D);\n      const w = cl((B - S.start) / 0.6, 0, 1), s = w * w * (3 - 2 * w);\n      for (const key in REST) if (typeof REST[key] === \"number\") D[key] = mix(REST[key], D[key], s);\n      for (const f of [\"fl\", \"fr\"]) D[f] = [D[f][0] * s, D[f][1] * s];\n      rig(D, Q);\n      S.eye = max(0, S.eye - db * 0.8);\n    }\n  }\n  if (S.phase === 1) {\n    const u = B - S.start;\n    S.fall.forEach((f, i) => {\n      const t = min(u, f.T), r = t / f.T, b = u - f.T;\n      Q.x[i] = mix(f.x0, f.hx, r);\n      Q.y[i] = min(f.hy, f.y0 - f.v * t + 0.5 * f.g * t * t);\n      Q.a[i] = f.a0 + f.da * r;\n      if (b > 0 && b \u003c 0.3) Q.y[i] -= 2 * sin((PI * b) / 0.3) * (1 - b / 0.3);\n    });\n    // The heap lies still, then the skull's eyes kindle.\n    S.eye = cl((u - 1.6) / 0.8, 0, 1);\n    if (u > 2.5) {\n      S.phase = 2;\n      S.start = B;\n    }\n  }\n  if (S.phase === 2) {\n    // One piece every 0.3 beats from the feet up, each on an arc 0.45 beats\n    // long; the jaw and the skull go together, last, in 0.8 beats.\n    const u = B - S.start, R = S.R;\n    for (let i = 0; i \u003c NB; i++) {\n      const slot = min(i, JAW), t0 = slot * 0.3, len = slot === JAW ? 0.8 : 0.45, r = (u - t0) / len, [hx, hy, ha] = S.heap[i];\n      if (r \u003c= 0) at(Q, i, hx, hy, ha);\n      else if (r >= 1) {\n        at(Q, i, R.x[i], R.y[i], R.a[i]);\n        if (r - db / len \u003c 1) S.snap.push([R.x[i], R.y[i] - (i === SKULL ? 2 : 0), 0.12]);\n      } else {\n        let da = R.a[i] - ha;\n        da -= TAU * round(da / TAU);\n        const lift = 10 + 0.15 * (hy - R.y[i]), e = 1 - (1 - r) * (1 - r);\n        at(Q, i, mix(hx, R.x[i], r), mix(hy, R.y[i], e) - lift * sin(PI * r) * (1 - r * 0.3), ha + da * e);\n      }\n    }\n    // The nod: the skull dips its face and the jaw shuts, 0.6 beats.\n    const n = (u - JAW * 0.3 - 0.8) / 0.6;\n    Q.pitch = n > 0 && n \u003c 1 ? sin(PI * n) : 0;\n    if (n > 0) {\n      Q.y[SKULL] += 2.5 * Q.pitch;\n      Q.y[JAW] += 3.2 * Q.pitch;\n    }\n    if (n >= 1) {\n      S.phase = 0;\n      S.start = B;\n      S.base = ceil(B);\n      S.moves++;\n    }\n  }\n  for (const m of S.dust) {\n    m[1] += d * m[3];\n    m[0] += d * 1.5 * sin(S.t * 0.7 + m[2]);\n    if (m[1] > FLOOR) (m[1] = 0), (m[0] = CX + (Math.random() - 0.5) * 34);\n  }\n}\n\n// The crypt, laid out once for each light colour: stone blocks with dark\n// mortar, the beam on the wall, a pool on the flagstones, two candle niches.\nconst NICHES = [8, 56], NY = 78;\nfunction background(S) {\n  const bg = S.bg, L = S.light;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let r, g, b, lit;\n      if (y \u003c FLOOR) {\n        const row = floor(y / 7), off = row & 1 ? 6 : 0, col = floor((x + off) / 12);\n        const mortar = y % 7 === 6 || (x + off) % 12 === 11, v = hash(row * 31 + col * 7) * 10;\n        (r = mortar ? 10 : 26 + v), (g = mortar ? 6 : 19 + v * 0.7), (b = mortar ? 16 : 36 + v);\n        lit = BEAM(x, y) * (mortar ? 0.12 : 0.24);\n        for (const nx of NICHES)\n          if (abs(x + 0.5 - nx) \u003c 3.5 && y > NY - 8 && y \u003c NY + 4 && (y > NY - 5 || (x + 0.5 - nx) ** 2 + (y - NY + 5) ** 2 \u003c 12)) (r = 8), (g = 4), (b = 12), (lit = 0);\n      } else {\n        // Flagstones, and the pool where the beam lands.\n        const seam = y === FLOOR + 3 || (x + (y > FLOOR + 3 ? 5 : 0)) % 14 === 0;\n        (r = seam ? 12 : 30), (g = seam ? 8 : 22), (b = seam ? 18 : 36);\n        if (y === FLOOR) (r = 60), (g = 48), (b = 70);\n        const q = ((x + 0.5 - CX) / 30) ** 2 + ((y - FLOOR - 3) / 6) ** 2;\n        lit = (q \u003c 0.45 ? 0.62 : q \u003c 1 ? 0.42 : q \u003c 1.5 ? 0.18 : 0) * (seam ? 0.5 : 1);\n      }\n      bg[o] = r + L[0] * lit;\n      bg[o + 1] = g + L[1] * lit;\n      bg[o + 2] = b + L[2] * lit;\n    }\n}\n\n// Ivory in the light, a warmer grey across, the shade tinted by the beam.\nconst BONE = [[255, 244, 220], [212, 202, 180], [96, 88, 80]];\nconst put = (buf, o, r, g, b) => {\n  buf[o] = r;\n  buf[o + 1] = g;\n  buf[o + 2] = b;\n};\n// One piece onto the buffer: its distance field over its bounds, lit from\n// above by the field's slope, outlined dark where it passes over anything.\nconst FIELD = new Float32Array(48 * 48);\nfunction piece(S, i, P) {\n  const [k, sg, x0, x1, y0, y1] = PIECES[i], cx = P.x[i], cy = P.y[i], a = P.a[i], c = cos(a), s = sin(a);\n  let xa = 1e9, xb = -1e9, ya = 1e9, yb = -1e9;\n  for (const [u, v] of [[x0, y0], [x1, y0], [x0, y1], [x1, y1]]) {\n    const wx = cx + u * c - v * s, wy = cy + u * s + v * c;\n    (xa = min(xa, wx)), (xb = max(xb, wx)), (ya = min(ya, wy)), (yb = max(yb, wy));\n  }\n  xa = max(0, floor(xa) - 1);\n  xb = min(W - 1, ceil(xb) + 1);\n  ya = max(0, floor(ya) - 1);\n  yb = min(H - 1, ceil(yb) + 1);\n  const buf = S.buf, L = S.light;\n  if (xb \u003c xa || yb \u003c ya || xb - xa >= 48 || yb - ya >= 48) return;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy;\n      FIELD[(y - ya) * 48 + x - xa] = shape(k, dx * c + dy * s, -dx * s + dy * c, sg);\n    }\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const f = (y - ya) * 48 + x - xa, d = FIELD[f], o = (y * W + x) * 3;\n      if (d > 0.1) {\n        if (d \u003c 1.1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      if (y > 60 && y > S.low[x]) S.low[x] = y;\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, hl = hole(k, dx * c + dy * s, -dx * s + dy * c, P);\n      if (hl === 1 || hl === 2) {\n        const e = hl === 2 ? S.eye * (0.75 + 0.25 * sin(S.t * 9 + i)) : 0;\n        put(buf, o, 12 + L[0] * e, 6 + L[1] * e, 18 + L[2] * e);\n        continue;\n      }\n      // The slope of the field: where it climbs upward the bone faces the light.\n      const up = y > ya ? FIELD[f - 48] : d + 1, dn = y \u003c yb ? FIELD[f + 48] : d + 1, n = (up - dn) / (abs(up - dn) + abs((x > xa ? FIELD[f - 1] : d) - (x \u003c xb ? FIELD[f + 1] : d)) + 0.01);\n      const t = hl === 3 || n \u003c= -0.3 ? 2 : n > 0.4 || (d > -0.6 && up > 0.1) ? 0 : 1, beam = 0.72 + 0.28 * BEAM(x, y), w = t === 2 ? 0.36 : 0;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = (BONE[t][ch] + L[ch] * w) * beam;\n    }\n}\n\nfunction add(buf, x, y, r, g, b) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += r;\n  buf[o + 1] += g;\n  buf[o + 2] += b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0) return;\n  const buf = S.buf, L = S.light, low = S.low;\n  buf.set(S.bg);\n  // Candles in the niches: a flame that flickers in three steps and a glow.\n  NICHES.forEach((nx, j) => {\n    const v = 0.55 + 0.3 * vn(S.t * 3, j * 9) + 0.15 * vn(S.t * 11, j * 9 + 4), f = v > 0.72 ? 1 : v > 0.55 ? 0.82 : 0.66;\n    for (let y = NY - 12; y \u003c NY + 8; y++)\n      for (let x = nx - 8; x \u003c nx + 8; x++) {\n        const q = sqrt((x + 0.5 - nx) ** 2 + (y + 0.5 - NY + 2) ** 2), gl = (q \u003c 3.5 ? 0.24 : q \u003c 5.5 ? 0.14 : q \u003c 8 ? 0.06 : 0) * f;\n        if (gl) add(buf, x, y, 255 * gl, 140 * gl, 40 * gl);\n      }\n    for (let y = NY; y \u003c NY + 4; y++) put(buf, (y * W + nx - 1) * 3, 196, 184, 160), put(buf, (y * W + nx) * 3, 196, 184, 160);\n    const sw = round(vn(S.t * 5, j) * 2 - 1);\n    for (let i = 0; i \u003c (f > 0.9 ? 4 : 3); i++) {\n      const o = ((NY - 1 - i) * W + nx - 1 + (i > 1 ? sw : 0)) * 3, g = i ? 150 + 30 * f : 236, b = i ? 30 : 140;\n      put(buf, o, 255, g, b);\n      if (i \u003c 2) put(buf, o + 3, 255, g * 0.92, b);\n    }\n  });\n  // Dust drifting down the beam.\n  for (const [x, y, p] of S.dust) {\n    const tw = 0.45 + 0.35 * sin(S.t * 2.3 + p * 5);\n    if (BEAM(x, y) > 0.5) add(buf, x, y, (L[0] * 0.5 + 60) * tw, (L[1] * 0.5 + 60) * tw, (L[2] * 0.5 + 60) * tw);\n  }\n  // Bones; a shadow on the floor under whatever stands or lies over it.\n  low.fill(0);\n  // Pieces in the air go in front of the rest.\n  const u = S.beat - S.start, air = (i) => S.phase === 2 && u > min(i, JAW) * 0.3 && u \u003c min(i, JAW) * 0.3 + 0.9;\n  for (let pass = 0; pass \u003c 2; pass++) for (let i = 0; i \u003c NB; i++) if (air(i) === !!pass) piece(S, i, S.Q);\n  for (let x = 0; x \u003c W; x++)\n    if (low[x] > 0) {\n      const sh = low[x] > FLOOR - 8 ? 0.45 : 0.65;\n      for (let y = low[x] + 1; y \u003c min(H, FLOOR + 5); y++) if (y >= FLOOR) for (let ch = 0; ch \u003c 3; ch++) buf[(y * W + x) * 3 + ch] *= sh;\n    }\n  for (const [x, y, t] of S.snap) for (const [i, j] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) add(buf, x + i, y + j, 200 * t * 8, 190 * t * 8, 170 * t * 8);\n  // Ground fog: two drifting noises, deeper toward the floor, in steps of an eighth.\n  const fog = S.fog, top = 118 - 50 * fog;\n  for (let y = max(0, floor(top)); y \u003c H && fog > 0; y++) {\n    const depth = cl((y - top) / 16, 0, 1) * (0.25 + 0.5 * fog);\n    for (let x = 0; x \u003c W; x++) {\n      const n = 0.6 * vn(x * 0.09 + S.t * 0.35 + y * 0.03, 3 + (y >> 3)) + 0.4 * vn(x * 0.21 - S.t * 0.5, 17 + (y >> 2));\n      const al = floor(depth * (0.35 + 0.9 * n) * 8) / 8;\n      if (al \u003c= 0) continue;\n      const o = (y * W + x) * 3, a = min(0.85, al);\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = mix(buf[o + ch], 70 + L[ch] * 0.32, a);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","chebyshev-bias":"// ===== Patternflow pattern =====\n// Title:   Chebyshev's Bias\n// Family:  number\n// Idea:    The panel's height is the number line from 32 at the bottom to 2^21 at the top on a log scale and its 64 columns are 64 prime races counted by the pattern's own sieve; a white front climbs and paints each LED blue where the side Chebyshev expected leads, brighter the larger its lead in Rubinstein and Sarnak's units, and orange where the other side leads, so the field fills with the bias and the rare orange specks stand out, the first for 1 mod 4 over 3 mod 4 at 26,861, each long-awaited one sending a ring across the panel as the front passes it.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Chebyshev's bias (Pafnuty Chebyshev, 1853), with Rubinstein and Sarnak's logarithmic density (1994), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Races=0..2, Margin=0..1\n//\n// Knob 1: Hue. Turns the three colours round the wheel together. At 0 the leading side is blue, the specks where the other side leads orange and the close calls violet; at 0.25 magenta, green and orange; at 0.5 orange, azure and green, the orange paled so the weak leads do not read brown; at 0.75 green, magenta and azure.\n// Knob 2: Speed. The front climbs 6.4 rows a second for each unit, 12.8 at 2, so x doubles every 0.63 s: it passes 26,861 at 6.1 s and 616,841 at 8.9 s and reaches 2^21 at 10 s, the field holds 2.5 s and dims back to the ghost of itself over 1.2 s, and the front starts again from 32. At 0.2 all ten times slower, a climb of 100 s; at 3 a climb of 6.7 s.\n// Knob 3: Races. Which 64 races, the columns ordered by the mean lead the theory expects, largest at the left. At 0 the quadratic non-residues against the residues for every modulus from 3 to 66, each side averaged over its classes: first the five where 1 has eight square roots (24, 40, 48, 56, 60), brightest and never led by the other side, then the 24 with four, of which only 7 are ever led, then the 35 with two, from 3 and 4 on, where the orange gathers and 43 has the other side ahead on 42% of the line. At 1 the class -1 against the class 1 for the same moduli: where -1 is not a square it leans like the race at 0, and the 15 moduli at the right where it is one (5, 10, 13, 17, 25 and on) are fair races, barcodes of blue and orange. At 2 non-residues against residues for the 64 odd primes from 3 to 313 in order: the orange thickens as the modulus grows, in 16% of the rows of the first sixteen columns and a third of those of the last thirty-two. A new choice is counted in under a second.\n// Knob 4: Margin. How near a tie a lead must come to show as a close call in violet, in Rubinstein and Sarnak's units where the mod 4 lead averages 1: 0 at 0, 0.12 at the opening 0.06, 0.5 at a quarter, 1 at half, where most of the races with two square roots of 1 have turned violet, and 2 at 1, where only the five with eight keep much blue.\n// Buttons: K1 tap starts the climb again from 32.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, log, exp, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The number line: row r from the bottom covers x in [B[r], B[r + 1]), eight\n// rows to each doubling, from 32 to 32 * 2^16 = 2^21 = 2,097,152.\nconst RPD = 8, X0 = 32, X1 = 1 \u003c\u003c 21;\nconst B = new Float64Array(H + 1);\nfor (let r = 0; r \u003c= H; r++) B[r] = round(X0 * 2 ** (r / RPD));\n// Rubinstein and Sarnak's normaliser log x / sqrt x at each row's middle.\nconst NRM = new Float64Array(H);\nfor (let r = 0; r \u003c H; r++) {\n  const xm = X0 * 2 ** ((r + 0.5) / RPD);\n  NRM[r] = log(xm) / sqrt(xm);\n}\n\n// The pattern's own sieve of Eratosthenes up to 2^21, once, on the odd\n// numbers only: SV[k] marks 2k + 1 composite. 155,611 primes.\nconst SV = new Uint8Array((X1 >> 1) + 1);\nfor (let i = 3; i * i \u003c= X1; i += 2) if (!SV[i >> 1]) for (let j = (i * i) >> 1; j \u003c= X1 >> 1; j += i) SV[j] = 1;\nconst PT = new Int32Array(160000);\nlet NP = 1;\nPT[0] = 2;\nfor (let k = 1; 2 * k + 1 \u003c X1; k++) if (!SV[k]) PT[NP++] = 2 * k + 1;\nconst PR = PT.subarray(0, NP);\n\nconst gcd = (a, b) => {\n  while (b) [a, b] = [b, a % b];\n  return a;\n};\n// A race mod q: a weight for each class, plus for the side expected to lead\n// and minus for the other, so D = sum of weights over primes \u003c= x is the\n// race. K turns D into the lead L = K D log x / sqrt x, scaled so that L\n// averages s / 2 when s is the number of square roots of 1 mod q: 1 for\n// 3 mod 4 against 1 mod 4, as in Rubinstein and Sarnak.\nfunction raceNR(q) {\n  const T = new Int32Array(q), sq = new Uint8Array(q);\n  let phi = 0, nr = 0, s = 0;\n  for (let a = 1; a \u003c q; a++)\n    if (gcd(a, q) === 1) {\n      phi++;\n      sq[(a * a) % q] = 1;\n      if ((a * a) % q === 1) s++;\n    }\n  for (let a = 1; a \u003c q; a++) if (gcd(a, q) === 1 && sq[a]) nr++;\n  const nn = phi - nr;\n  // Weights |R| for a non-residue, -|N| for a residue: the race of the two\n  // sides' averages per class.\n  for (let a = 1; a \u003c q; a++) if (gcd(a, q) === 1) T[a] = sq[a] ? -nn : nr;\n  return { q, T, K: phi / (2 * nn * nr), s, mean: s / 2 };\n}\n// The class q - 1 (that is -1) against the class 1: biased like the race\n// above when -1 is not a square mod q, fair when it is.\nfunction racePair(q) {\n  const T = new Int32Array(q), r = raceNR(q);\n  let phi = 0;\n  for (let a = 1; a \u003c q; a++) if (gcd(a, q) === 1) phi++;\n  T[q - 1] = 1;\n  T[1] = -1;\n  return { q, T, K: phi / 2, s: r.s, mean: r.T[q - 1] > 0 ? r.s / 2 : 0 };\n}\n// Columns left to right by the mean lead the theory expects, largest\n// first, then by modulus.\nconst order = (a, b) => b.mean - a.mean || a.q - b.q;\nconst ODD = [];\nfor (let k = 1; ODD.length \u003c W; k++) ODD.push(PR[k]);\nconst FAMS = [\n  Array.from({ length: W }, (_, c) => raceNR(c + 3)).sort(order),\n  Array.from({ length: W }, (_, c) => racePair(c + 3)).sort(order),\n  ODD.map(raceNR),\n];\n\n// Hues at knob 0: the leading side blue, the other side's specks orange,\n// close calls violet.\nconst HUE_LEAD = 0.6, HUE_SPECK = 0.085, HUE_CLOSE = 0.8;\n// Front speed in rows a second for each unit of Speed; the hold at the top\n// and the fade back to the ghost, in seconds at Speed 2. Above the front the\n// last count shows at GHOST of its brightness.\nconst RATE = 6.4, HOLD = 2.5, FADE = 1.2, GHOST = 0.3;\n// Primes the count takes each frame: 26 frames for the whole count.\nconst STEPS = 6000;\n// A ring goes out when the other side takes the lead after the expected\n// side has held it for RING rows, x grown 16 times over.\nconst RING = 32;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// One count of a family's 64 races from 2 to 2^21. Per LED, row-major from\n// the bottom row: the share of the row's x where the other side led, the\n// share tied, the mean lead and the least lead; and every time the other\n// side took the lead, with how many rows the expected side had held it.\n// The classes' weights sit in one table, column c's from OFF[c].\nfunction newCount(f) {\n  const races = FAMS[f], OFF = new Int32Array(W);\n  let n = 0;\n  for (let c = 0; c \u003c W; c++) (OFF[c] = n), (n += races[c].q);\n  const TT = new Int32Array(n);\n  for (let c = 0; c \u003c W; c++) TT.set(races[c].T, OFF[c]);\n  const C = {\n    Q: Int32Array.from(races, (r) => r.q), KK: Float64Array.from(races, (r) => r.K), OFF, TT,\n    D: new Int32Array(W), pos: X0, pi: 0, row: 0,\n    neg: new Float64Array(W), tie: new Float64Array(W), sum: new Float64Array(W), mn: new Int32Array(W),\n    lastNeg: new Int16Array(W).fill(-1),\n    NEG: new Float32Array(W * H), TIE: new Float32Array(W * H), ML: new Float32Array(W * H), MINL: new Float32Array(W * H),\n    ev: [],\n  };\n  // The primes below 32 are in before the first row opens.\n  for (; PR[C.pi] \u003c X0; C.pi++) for (let c = 0; c \u003c W; c++) C.D[c] += TT[OFF[c] + (PR[C.pi] % C.Q[c])];\n  openRow(C);\n  return C;\n}\n\nfunction openRow(C) {\n  C.neg.fill(0);\n  C.tie.fill(0);\n  C.sum.fill(0);\n  C.mn.set(C.D);\n}\n\n// Between two primes the race stands still, so each stretch to the next\n// prime or row boundary is added to the row's tallies whole.\nfunction tally(C, len) {\n  const { D, neg, tie, sum } = C;\n  for (let c = 0; c \u003c W; c++) {\n    const d = D[c];\n    if (d \u003c 0) neg[c] += len;\n    else if (d === 0) tie[c] += len;\n    sum[c] += d * len;\n  }\n}\n\nfunction closeRow(C) {\n  const r = C.row, len = B[r + 1] - B[r];\n  for (let c = 0, o = r * W; c \u003c W; c++, o++) {\n    const k = C.KK[c] * NRM[r];\n    C.NEG[o] = C.neg[c] / len;\n    C.TIE[o] = C.tie[c] / len;\n    C.ML[o] = (k * C.sum[c]) / len;\n    C.MINL[o] = k * C.mn[c];\n    if (C.neg[c] > 0) C.lastNeg[c] = r;\n  }\n  C.row++;\n  openRow(C);\n}\n\n// Runs the count on by at most n primes: the whole count is 155,611\n// primes and 128 rows, about 10 million small steps for the 64 races.\nfunction step(C, n) {\n  const { D, Q, OFF, TT, neg, tie, sum, mn } = C;\n  while (C.row \u003c H && n-- > 0) {\n    const p = C.pi \u003c NP ? PR[C.pi] : X1 + 1, b = B[C.row + 1];\n    // A prime on a row boundary belongs to the row above.\n    if (b \u003c= p) {\n      tally(C, b - C.pos);\n      C.pos = b;\n      closeRow(C);\n      continue;\n    }\n    const len = p - C.pos;\n    for (let c = 0; c \u003c W; c++) {\n      const d = D[c];\n      if (d \u003c 0) neg[c] += len;\n      else if (d === 0) tie[c] += len;\n      sum[c] += d * len;\n      const w = TT[OFF[c] + (p % Q[c])];\n      if (!w) continue;\n      const e = d + w;\n      D[c] = e;\n      if (e \u003c mn[c]) mn[c] = e;\n      if (d >= 0 && e \u003c 0) {\n        C.ev.push({ c, x: p, run: C.row - C.lastNeg[c] });\n        C.lastNeg[c] = C.row;\n      }\n    }\n    C.pos = p;\n    C.pi++;\n  }\n}\n\n// The front's height for x, in rows from the bottom.\nconst rowOf = (x) => RPD * Math.log2(x / X0);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, fam: -1, margin: 0.12, cnt: [null, null, null], C: null,\n    F: 0, phase: 0, timer: 0, alpha: 1, t: 0, next: 0, skip: 0,\n    bursts: [], buf: new Float32Array(W * H * 3), col: new Float32Array(12), lut: new Float32Array(99),\n  };\n}\n\nfunction replay(S) {\n  S.F = 0;\n  S.skip = 0;\n  S.phase = 0;\n  S.alpha = 1;\n  S.next = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.margin = 2 * cl(kv[3], 0, 1);\n  const f = round(cl(kv[2], 0, 2));\n  if (f !== S.fam) {\n    // Each family is counted once, the first time it is asked for.\n    S.fam = f;\n    S.C = S.cnt[f] || (S.cnt[f] = newCount(f));\n    S.bursts.length = 0;\n    S.next = 0;\n    // A count already done has its lead changes below the front passed;\n    // a new one finds them as it goes, and they pass without a ring.\n    while (S.next \u003c S.C.ev.length && rowOf(S.C.ev[S.next].x) \u003c S.F) S.next++;\n    S.skip = S.F;\n  }\n  // The count runs ahead of the front, done in under a second.\n  step(S.C, STEPS);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  if (input.btnPressed && input.btnPressed[0]) replay(S);\n  if (S.phase === 0) {\n    S.F = min(H, S.F + d * RATE * S.speed);\n    // The lead changes the front has just passed.\n    const ev = S.C.ev;\n    while (S.next \u003c ev.length && rowOf(ev[S.next].x) \u003c S.F) {\n      const e = ev[S.next++];\n      // A flip back and forth inside one lead change is not a new one.\n      if (e.run \u003c 3 || (e.run \u003c RING && S.bursts.length > 12) || rowOf(e.x) \u003c S.skip) continue;\n      S.bursts.push({ c: e.c, r: floor(rowOf(e.x)), t: 0, run: e.run });\n    }\n    if (S.F >= H) (S.phase = 1), (S.timer = HOLD);\n  } else if (S.phase === 1) {\n    if ((S.timer -= ds) \u003c 0) (S.phase = 2), (S.timer = FADE);\n  } else {\n    S.timer -= ds;\n    S.alpha = max(0, S.timer / FADE);\n    if (S.timer \u003c 0) replay(S);\n  }\n  for (const b of S.bursts) b.t += ds;\n  S.bursts = S.bursts.filter((b) => b.t \u003c 1.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.C) return;\n  const buf = S.buf, K = S.col, Cn = S.C, m = S.margin, F = S.F;\n  buf.fill(0);\n  hsv(HUE_SPECK + S.hue, 0.78, 1, K, 0);\n  hsv(HUE_CLOSE + S.hue, 0.55, 0.78, K, 3);\n  // The lead side in 33 steps of u = 1 - exp(-L / 1.6), brighter and paler\n  // the larger the mean lead L. Turned to orange or yellow it starts paler\n  // and brighter, or the weak leads would read brown.\n  const lut = S.lut, hl = HUE_LEAD + S.hue, wf = max(0, cos(2 * PI * (hl - 0.1))) ** 3;\n  for (let i = 0; i \u003c= 32; i++) {\n    const u = i / 32;\n    hsv(hl, 0.92 - 0.3 * u * u - 0.45 * wf, 0.2 + 0.55 * wf + (0.68 - 0.4 * wf) * u, lut, i * 3);\n  }\n  for (let r = 0; r \u003c Cn.row; r++) {\n    const y = H - 1 - r;\n    // Painted below the front, the ghost above it; freshly painted rows\n    // glow white for a moment under the front.\n    const lit = r \u003c F ? GHOST + (1 - GHOST) * S.alpha : GHOST;\n    const gl = S.phase === 0 && r \u003c F ? exp(-(F - r - 1) / 1.6) * 0.55 : 0;\n    for (let c = 0; c \u003c W; c++) {\n      const o = r * W + c, q = (y * W + c) * 3;\n      let R, G, Bl;\n      if (Cn.NEG[o] > 0) {\n        // The other side led here: a speck that never dims below 0.8.\n        const v = (0.8 + 0.2 * sqrt(Cn.NEG[o])) * (0.88 + 0.12 * sin(S.t * 3 + c * 1.7 + r * 0.9));\n        (R = K[0] * v), (G = K[1] * v), (Bl = K[2] * v);\n      } else if (Cn.TIE[o] >= 1) {\n        // Tied all along the row: neither leads.\n        (R = 0.24), (G = 0.24), (Bl = 0.28);\n      } else if (Cn.MINL[o] \u003c m) {\n        (R = K[3]), (G = K[4]), (Bl = K[5]);\n      } else {\n        const i = round(32 * (1 - exp(-max(0, Cn.ML[o]) / 1.6))) * 3;\n        (R = lut[i]), (G = lut[i + 1]), (Bl = lut[i + 2]);\n      }\n      if (gl > 0.01) (R += (1 - R) * gl), (G += (1 - G) * gl), (Bl += (1 - Bl) * gl);\n      buf[q] = R * lit;\n      buf[q + 1] = G * lit;\n      buf[q + 2] = Bl * lit;\n    }\n  }\n  // The front: a white row tinted by who leads there.\n  if (S.phase === 0 && F \u003c H) {\n    const r = floor(F), y = H - 1 - r;\n    hsv(HUE_LEAD + S.hue, 0.5, 1, K, 9);\n    for (let c = 0; c \u003c W; c++) {\n      const q = (y * W + c) * 3, k = Cn.NEG[r * W + c] > 0 ? 0 : 9;\n      buf[q] = 0.5 + 0.5 * K[k];\n      buf[q + 1] = 0.5 + 0.5 * K[k + 1];\n      buf[q + 2] = 0.5 + 0.5 * K[k + 2];\n    }\n  }\n  // Each new lead change flashes white; a long-awaited one sends out a ring\n  // in the specks' colour, the wider the longer the wait.\n  for (const b of S.bursts) {\n    const cx = b.c + 0.5, cy = H - 1 - b.r + 0.5;\n    if (b.t \u003c 0.35) {\n      const q = ((H - 1 - b.r) * W + b.c) * 3;\n      buf[q] = buf[q + 1] = buf[q + 2] = 1;\n    }\n    if (b.run \u003c RING) continue;\n    const big = min(1, (b.run - RING + 8) / 40), rad = 1 + b.t * (6 + 12 * big), f = (0.4 + 0.6 * big) * (1 - b.t / 1.6);\n    const y0 = max(0, floor(cy - rad - 1)), y1 = min(H - 1, floor(cy + rad + 1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = max(0, floor(cx - rad - 1)); x \u003c= min(W - 1, floor(cx + rad + 1)); x++) {\n        const dd = abs(sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2) - rad);\n        if (dd >= 1.2) continue;\n        const q = (y * W + x) * 3, w = f * (1 - dd / 1.2);\n        buf[q] += (K[0] - buf[q]) * w;\n        buf[q + 1] += (K[1] - buf[q + 1]) * w;\n        buf[q + 2] += (K[2] - buf[q + 2]) * w;\n      }\n  }\n  for (let p = 0, q = 0; p \u003c W * H; p++, q += 3) {\n    const r = buf[q], g = buf[q + 1], b = buf[q + 2];\n    if (r + g + b \u003c 0.02) continue;\n    // Each channel in steps of 4 of 255.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(r * 63.75) * 4), min(255, round(g * 63.75) * 4), min(255, round(b * 63.75) * 4));\n  }\n}\n","double-gyre":"// ===== Patternflow pattern =====\n// Title:   Double Gyre\n// Family:  noise\n// Idea:    Two counter-rotating cells of fluid stand one above the other while the line between them sways up and down, and each LED lights by how hard the fluid round it is torn apart over the next twenty units of flow time in amber and over the last twenty in azure, so the thin ridges that fluid never crosses wind round both cells, fold into tongues across the middle and stand the picture on its head every half turn of the forcing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lagrangian coherent structures as ridges of the finite-time Lyapunov exponent in the double gyre (Shawn Shadden, Francois Lekien and Jerrold Marsden, 2005), drawn by composing short flow maps (Steven Brunton and Clarence Rowley, 2010), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Horizon=-1..1, Epsilon=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together, half a wheel apart. At 0 the forward ridges, which push fluid apart, are amber and the backward ones, which draw it together, azure. Where they cross they add to white. At 0.25 green and magenta, at 0.5 azure and amber, at 0.75 magenta and green.\n// Knob 2: Speed. The starting time of the fields moves half a unit of flow time a second for each unit: 1 at the opening 2, so the forcing goes round once in 10 s and the picture stands on its head every 5 s; 0.1 at 0.2, a period in 100 s, and 1.5 at 3, a period in 6.7 s.\n// Knob 3: Horizon. How long the fluid is followed, 20 units of flow time times 2 to the knob, to the nearest 2: 10 at -1, one period of the forcing, a few soft ridges round the cells and one across the middle; 14 at -0.5; 20 at the opening 0, two periods, the ridges folded into bundles of thin lines; 28 at 0.5 and 40 at 1, where the folds crowd closer than an LED and the chaotic sea round the cells turns to grain round two dark islands.\n// Knob 4: Epsilon. How far the line between the cells sways, epsilon = 0.5 ln(1 + 1000 k) / ln 1001: 0 at 0, steady cells, where at a horizon of 10 the only ridges are the dividing line and the walls, white with the forward and backward ones lying on each other, and longer horizons add rings of shear round each cell; 0.17 at 0.01; 0.30 at the opening 0.06, where the line swings 18 LEDs either way of the middle; 0.40 at a quarter, 0.45 at half and 0.50 at 1, 26 LEDs either way.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sqrt, log, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The flow, on [0,2] x [0,1]: psi = A sin(pi f) sin(pi y), with\n// f = a x^2 + b x, a = eps sin(OM t), b = 1 - 2a. The panel stands the\n// box up: row py is x = (py + 0.5) / 64, column px is y = (px + 0.5) / 64.\nconst A = 0.1, OM = (2 * PI) / 10, PER = 10, PA = PI * A;\n// sin(pi u) from a table over one turn, for u above -4.\nconst TN = 2048, TH = TN / 2, ST = new Float64Array(TN + 1);\nfor (let i = 0; i \u003c= TN; i++) ST[i] = sin((2 * PI * i) / TN);\nconst sinpi = (u) => {\n  const w = (u + 4) * TH, i = w | 0, j = i & (TN - 1);\n  return ST[j] + (ST[j + 1] - ST[j]) * (w - i);\n};\n\n// The velocity at (x, y) when a = s, into VU, VV.\nlet VU = 0, VV = 0;\nfunction vel(x, y, s) {\n  const b = 1 - 2 * s, f = s * x * x + b * x, sy = sinpi(y), cy = sinpi(y + 0.5);\n  VU = -PA * sinpi(f) * cy;\n  VV = PA * sinpi(f + 0.5) * sy * (2 * s * x + b);\n}\n\n// Short flow maps on a grid of nodes 1/64 apart, Brunton and Rowley's way:\n// a drop is carried by looking up where the node grid round it goes, and\n// a long flight is a chain of lookups. The quarter-unit maps that start at\n// each of the 40 quarter units of a period are one RK4 step each; maps of\n// a half, one and two units are each two of the level below.\nconst G = 0.25, NP = PER / G, NX = 129, NY = 65, NN = NX * NY, STEP = 8;\nfunction buildMaps(eps) {\n  let lv = [];\n  for (let k = 0; k \u003c NP / 2; k++) {\n    const m = new Float32Array(NN * 2), t = k * G;\n    const s0 = eps * sin(OM * t), s1 = eps * sin(OM * (t + G / 2)), s2 = eps * sin(OM * (t + G));\n    for (let n = 0, j = 0; j \u003c NX; j++)\n      for (let i = 0; i \u003c NY; i++, n += 2) {\n        const x = j / 64, y = i / 64;\n        vel(x, y, s0);\n        const k1u = VU, k1v = VV;\n        vel(x + 0.5 * G * k1u, y + 0.5 * G * k1v, s1);\n        const k2u = VU, k2v = VV;\n        vel(x + 0.5 * G * k2u, y + 0.5 * G * k2v, s1);\n        const k3u = VU, k3v = VV;\n        vel(x + G * k3u, y + G * k3v, s2);\n        m[n] = cl(x + (G / 6) * (k1u + 2 * k2u + 2 * k3u + VU), 0, 2);\n        m[n + 1] = cl(y + (G / 6) * (k1v + 2 * k2v + 2 * k3v + VV), 0, 1);\n      }\n    lv.push(m);\n  }\n  // Half a period on, the flow is the same turned upside down: psi(2 - x,\n  // y, t + 5) = -psi(x, y, t). So the maps of the second half are those of\n  // the first mirrored, node for node, at every length.\n  const mirror = () => {\n    for (let k = 0; k \u003c NP / 2; k++) {\n      const a = lv[k], m = new Float32Array(NN * 2);\n      for (let j = 0; j \u003c NX; j++)\n        for (let i = 0; i \u003c NY; i++) {\n          const n = (j * NY + i) * 2, q = ((NX - 1 - j) * NY + i) * 2;\n          m[n] = 2 - a[q];\n          m[n + 1] = a[q + 1];\n        }\n      lv[k + NP / 2] = m;\n    }\n  };\n  mirror();\n  // Doubling: a map of 2L is the map of L from where the first L ends.\n  for (let L = 1; L \u003c STEP; L *= 2) {\n    const up = [];\n    for (let k = 0; k \u003c NP / 2; k++) {\n      const a = lv[k], m = new Float32Array(NN * 2);\n      chain(a, lv[(k + L) % NP], m, NN);\n      up.push(m);\n    }\n    lv = up;\n    mirror();\n  }\n  return lv;\n}\n// Bilinear lookup of map b at each point of a, into out.\nfunction chain(a, b, out, n2) {\n  for (let n = 0; n \u003c n2 * 2; n += 2) {\n    let u = a[n] * 64, v = a[n + 1] * 64;\n    if (u > 127.9999) u = 127.9999;\n    if (v > 63.9999) v = 63.9999;\n    const j = u | 0, i = v | 0, fu = u - j, fv = v - i, q = (j * NY + i) * 2, e = q + 2 * NY;\n    const x0 = b[q] + (b[q + 2] - b[q]) * fv, x1 = b[e] + (b[e + 2] - b[e]) * fv;\n    const y0 = b[q + 1] + (b[q + 3] - b[q + 1]) * fv, y1 = b[e + 1] + (b[e + 3] - b[e + 1]) * fv;\n    out[n] = x0 + (x1 - x0) * fu;\n    out[n + 1] = y0 + (y1 - y0) * fu;\n  }\n}\n\n// The forward field for the node time k G: each LED's drop carried T units\n// on through a chain of two-unit maps, rows r0..r1 of it.\nfunction carry(S, J, r0, r1) {\n  const { X, Y } = J, nm = S.T / 2;\n  // Every drop of the band goes through the same maps in the same order, so\n  // the band is carried map by map.\n  for (let p = r0 * W; p \u003c r1 * W; p++) {\n    X[p] = (floor(p / W) + 0.5) / 64;\n    Y[p] = ((p % W) + 0.5) / 64;\n  }\n  for (let q = 0, k = J.k; q \u003c nm; q++, k = (k + STEP) % NP) {\n    const b = S.maps[k];\n    for (let p = r0 * W; p \u003c r1 * W; p++) {\n      let u = X[p] * 64, v = Y[p] * 64;\n      if (u > 127.9999) u = 127.9999;\n      if (v > 63.9999) v = 63.9999;\n      const j = u | 0, i = v | 0, fu = u - j, fv = v - i, n = (j * NY + i) * 2, e = n + 2 * NY;\n      const x0 = b[n] + (b[n + 2] - b[n]) * fv, x1 = b[e] + (b[e + 2] - b[e]) * fv;\n      const y0 = b[n + 1] + (b[n + 3] - b[n + 1]) * fv, y1 = b[e + 1] + (b[e + 3] - b[e + 1]) * fv;\n      X[p] = x0 + (x1 - x0) * fu;\n      Y[p] = y0 + (y1 - y0) * fu;\n    }\n  }\n}\n\n// From the flow map to the picture: the log of the largest stretch of the\n// Cauchy-Green tensor by central differences (sigma is this over T), then\n// each LED pushed away from the mean of the nine round it, so thin ridges\n// stand out of the broad glow round them.\nconst SHARP = 5;\nfunction finish(J) {\n  const { X, Y, L } = J, d = 1 / 64, out = new Float32Array(N);\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, u = py > 0 ? p - W : p, dn = py \u003c H - 1 ? p + W : p, l = px > 0 ? p - 1 : p, r = px \u003c W - 1 ? p + 1 : p;\n      const hx = ((dn - u) / W) * d, hy = (r - l) * d;\n      const a = (X[dn] - X[u]) / hx, b = (X[r] - X[l]) / hy, c = (Y[dn] - Y[u]) / hx, e = (Y[r] - Y[l]) / hy;\n      const c11 = a * a + c * c, c12 = a * b + c * e, c22 = b * b + e * e, m = 0.5 * (c11 + c22);\n      L[p] = 0.5 * log(max(1e-9, m + sqrt(max(0, m * m - (c11 * c22 - c12 * c12)))));\n    }\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      let s = 0, n = 0;\n      for (let j = max(0, py - 1); j \u003c= min(H - 1, py + 1); j++)\n        for (let i = max(0, px - 1); i \u003c= min(W - 1, px + 1); i++) (s += L[j * W + i]), n++;\n      const p = py * W + px;\n      out[p] = L[p] + SHARP * (L[p] - s / n);\n    }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 1, T: 20, eps: -1, t0: 0, maps: null,\n    // The sharpened log stretch at each node time of the period, worked out\n    // once for each epsilon and horizon, and the one being worked on.\n    field: [], job: null, cf: [0, 0, 0], cb: [0, 0, 0],\n    X: new Float32Array(N), Y: new Float32Array(N), L: new Float32Array(N),\n  };\n}\n\nconst node = (n) => ((n % NP) + NP) % NP;\n\n// Finishes any field the picture needs this frame, then works up to rows\n// rows on the ones it will need next.\nfunction work(S, rows) {\n  const n = floor(S.t0 / G), need = [n, n + 1, -n - 1, -n, n + 2, -n - 2, n + 3, -n - 3].map(node);\n  for (let q = 0; q \u003c need.length; q++) {\n    const k = need[q];\n    if (S.field[k]) continue;\n    if (q >= 4 && rows \u003c= 0) return;\n    if (!S.job || S.job.k !== k) S.job = { k, row: 0, X: S.X, Y: S.Y, L: S.L };\n    const J = S.job, r1 = q \u003c 4 ? H : min(H, J.row + rows);\n    carry(S, J, J.row, r1);\n    rows -= r1 - J.row;\n    J.row = r1;\n    if (r1 === H) {\n      S.field[k] = finish(J);\n      S.job = null;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.rate = 0.5 * cl(k[1], 0.2, 3);\n  const T = 2 * round(10 * 2 ** cl(k[2], -1, 1));\n  const eps = round(500 * ((0.5 * log(1 + 1000 * cl(k[3], 0, 1))) / log(1001))) / 500;\n  if (eps !== S.eps) {\n    S.eps = eps;\n    S.maps = buildMaps(eps);\n    S.field = [];\n    S.job = null;\n  }\n  if (T !== S.T) {\n    S.T = T;\n    S.field = [];\n    S.job = null;\n  }\n  S.t0 = (S.t0 + d * S.rate) % PER;\n  // Two fields for each quarter unit the start time moves, a little ahead.\n  work(S, Math.ceil(((2.4 * H * d * S.rate) / G) * (S.T / 20)) + 8);\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// An LED lights from a stretch of e^2.4 = 11 times to full at e^3.6 = 37.\nconst STRETCH = 2.4, SPAN = 1.2;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.maps) return;\n  const cf = S.cf, cb = S.cb, n = floor(S.t0 / G), w = S.t0 / G - n;\n  // Running time backward is the same flow turned half round: the fluid\n  // carried back from t0 lands where fluid carried on from -t0 lands, with\n  // the panel turned 180 degrees (psi(x, y, -t) = psi(x, y, t + 5) and\n  // psi(x, 1 - y, t) = psi(x, y, t)). So the backward field at t0 is the\n  // forward field at -t0 upside down and back to front.\n  const f0 = S.field[node(n)], f1 = S.field[node(n + 1)], b0 = S.field[node(-n)], b1 = S.field[node(-n - 1)];\n  if (!f0 || !f1 || !b0 || !b1) return;\n  hsv(0.1 + S.hue, 0.86, 1, cf);\n  hsv(0.6 + S.hue, 0.8, 1, cb);\n  for (let py = 0, p = 0; py \u003c H; py++) {\n    for (let px = 0; px \u003c W; px++, p++) {\n      const q = N - 1 - p;\n      const vf = cl((f0[p] + (f1[p] - f0[p]) * w - STRETCH) / SPAN, 0, 1);\n      const vb = cl((b0[q] + (b1[q] - b0[q]) * w - STRETCH) / SPAN, 0, 1);\n      if (vf + vb \u003c 0.02) continue;\n      // Steps of 4 of 255.\n      const r = min(255, cf[0] * vf + cb[0] * vb), g = min(255, cf[1] * vf + cb[1] * vb), b = min(255, cf[2] * vf + cb[2] * vb);\n      display.setPixel(px, py, (r >> 2) \u003c\u003c 2, (g >> 2) \u003c\u003c 2, (b >> 2) \u003c\u003c 2);\n    }\n  }\n}\n","flashing-ratchet":"// ===== Patternflow pattern =====\n// Title:   Flashing Ratchet\n// Family:  sim\n// Idea:    Three thousand Brownian particles drift in a sawtooth potential of eight teeth stacked up the panel that switches on and off, bunching into glowing lines under each steep ridge while it is on and spreading into fog while it is off, and because each well's minimum sits 3.2 LEDs below its near ridge and 12.8 above its far one, more of every blob lands a well higher when the potential comes back, so a gold-marked cloud climbs against a downward load that would drag it down with the potential held on or held off.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Flashing ratchet (Armand Ajdari and Jacques Prost, 1992), Parrondo's paradox (Juan Parrondo, 1996), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Period=0.8..3.2, Load=0.25..1.5\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a sky blue cloud, a gold marked cloud with gold marks on the edges, and violet ridges; at 0.25 violet, green and red; at 0.5 orange, blue and lime; at 0.75 green, pink and cyan.\n// Knob 2: Speed. Model time runs at Speed / 2 of real time. At 2 the opening flash lasts 0.8 s and the marked cloud climbs 2 LEDs a second; at 0.2 everything is ten times slower and at 3 half as fast again.\n// Knob 3: Period. One off-and-on cycle in seconds of model time, off for the first 40% and on for the rest. At 0.8 a blob spreads 5.7 LEDs (one standard deviation) before the wells come back and the marked cloud climbs 0.127 teeth a second at the opening load; at 1.6 it climbs 0.058, and at 3.2 the blobs spread 11.3 LEDs, most of a tooth, the climb falls to 0.0125 and from half the stall load up the load wins.\n// Knob 4: Load. The steady downward force, as a share of the load that stalls the flashing at the 0.8 s period, 5.15 LEDs a second of free fall. At the opening 0.25 the flashing climbs 0.127 teeth a second while the potential held on loses 0.0022 and held off 0.081; at 0.75 it climbs 0.043, at 1 it stands still, and at 1.5 (7.7 LEDs a second) the flashing too goes down, 0.089 teeth a second.\n// Buttons: K1 tap steps through the three games: flashing, the potential held on, the potential held off, and back to flashing. Held on, the marked cloud stays in its lines; held off, it sinks with the load.\n//\n// Checked with this file's own update() over 300 s of model time for each\n// game and load, 3000 particles, the period at 0.8 s and the load clamp\n// opened down to 0. Mean velocity in teeth a second, up positive, with one\n// standard error in the last digit in brackets:\n//   load    flashing          held on            held off\n//   0       +0.1681 (5)       +0.0001 (1)        -0.0011 (7)\n//   0.25    +0.1270 (5)       -0.0022 (1)        -0.0811 (7)\n//   0.5     +0.0851 (5)       -0.0048 (1)        -0.1613 (6)\n//   0.75    +0.0425 (5)       -0.0078 (1)        -0.2412 (7)\n//   1       +0.0002 (5)       -0.0117 (1)        -0.3219 (7)\n//   1.5     -0.0893 (5)       -0.0216 (2)        -0.4827 (7)\n// So from load 0 to 1 both games lose and switching between them wins:\n// Parrondo's paradox. Held off, the speed is the load's own F / 16 to\n// within the error; held on, particles leave a well only by crossing a\n// ridge 7.5 D high, which the load lowers on the down side. With no load\n// the held potential makes no current, as it must in equilibrium.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The sawtooth: 8 teeth of L = 16 LEDs up the panel. Measured down the\n// panel from a minimum, V rises gently for (1 - A) L = 12.8 LEDs to V0,\n// then falls steeply over A L = 3.2 LEDs to the next minimum. So the\n// steep side of every well faces up, and the near maximum is 3.2 LEDs\n// above a particle sitting in it, the far one 12.8 below.\nconst L = 16, A = 0.2, NT = H / L;\n// Diffusion D in LED^2 per second of model time, the well depth V0 = 7.5 D\n// (in units where the mobility is 1, so a force is the speed it gives).\nconst D = 50, V0 = 7.5 * D;\nconst FG = V0 / ((1 - A) * L), FS = V0 / (A * L);\n// Off for this share of each period, on for the rest.\nconst OFF = 0.4;\n// The stall load at the shortest period, measured with this code (LED/s).\nconst FSTALL = 5.15;\n// Steps while the potential is on: at most HMAX of model time, so the steep\n// side's push in one step stays under a tenth of its width.\nconst HMAX = 1 / 480;\nconst NP = 3000;\n// Pulse labelling: every particle in one well is marked and lit, and the\n// marked cloud is followed until its spread passes 3 teeth, it has moved 5\n// or 36 s have gone by; then it fades over FADE s and another well is\n// marked, the bottom one if the last cloud went up and the top one if it\n// fell. The marks on the edges are the cloud's start and its mean now.\nconst SPREAD = 3 * L, TRAVEL = 5 * L, TMAX = 36, FADE = 1.5;\n\n// A table of normal deviates, each with its negative so the noise has no\n// skew, scaled to variance 1 exactly. A table of 4096 plain draws had\n// enough skew to make the held potential lift particles: 1890 teeth up\n// against 1413 down in 200 s.\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return (((h ^ (h >>> 16)) >>> 0) + 0.5) / 4294967296;\n};\nconst NG = 4096, G = new Float32Array(NG);\n{\n  let v = 0;\n  for (let i = 0; i \u003c NG; i += 2) {\n    G[i] = sqrt(-2 * log(hash(i))) * cos(2 * PI * hash(i + 77777));\n    G[i + 1] = -G[i];\n    v += 2 * G[i] * G[i];\n  }\n  v = sqrt(v / NG);\n  for (let i = 0; i \u003c NG; i++) G[i] /= v;\n}\nconst gn = () => G[(Math.random() * NG) | 0];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const X = new Float32Array(NP), Y = new Float32Array(NP);\n  // The start: bunched in the wells as if the potential had been on, each\n  // line with its thermal tail on the gentle side below it.\n  for (let i = 0; i \u003c NP; i++) {\n    X[i] = Math.random() * W;\n    Y[i] = (floor(Math.random() * NT) * L - log(1 - Math.random()) * (D / FG) + H) % H;\n  }\n  params.s = {\n    X, Y, M: new Uint8Array(NP), LAP: new Int16Array(NP), rng: (Math.random() * 4294967295) | 1, t: 0, ph: 0, hold: 0, on: true,\n    hue: 0, speed: 2, per: 0.8, load: 0.25,\n    age: 0, y0: 0, mean: 0, sd: 0, old: 0,\n    da: new Float32Array(N), db: new Float32Array(N), tmp: new Float32Array(N),\n    col: new Float32Array(9),\n  };\n  mark(params.s, NT - 1);\n}\n\n// Marks every particle in the basin of well k, the stretch from the\n// maximum A L above its minimum to the one (1 - A) L below; the cloud\n// marked before fades.\nfunction mark(S, k) {\n  const { Y, M, LAP } = S, lo = k * L - A * L, hi = k * L + (1 - A) * L;\n  let m = 0, n = 0;\n  for (let i = 0; i \u003c NP; i++) {\n    M[i] = M[i] === 1 ? 2 : M[i];\n    LAP[i] = 0;\n    let y = Y[i];\n    if (y >= hi) y -= H;\n    if (y >= lo && y \u003c hi) {\n      M[i] = 1;\n      m += y;\n      n++;\n    }\n  }\n  S.old = M.some((v) => v === 2) ? 1 : 0;\n  S.age = 0;\n  S.y0 = n ? m / n : k * L;\n  S.mean = S.sd = 0;\n}\n\n// Moves every particle through tau of model time with the potential off:\n// free diffusion plus the load, one exact Gaussian step.\nfunction stepOff(S, tau, F) {\n  const { X, Y } = S, a = sqrt(2 * D * tau), dy = F * tau;\n  for (let i = 0; i \u003c NP; i++) {\n    Y[i] += dy + a * gn();\n    X[i] += a * gn();\n  }\n}\n\n// The same with the potential on, in steps of at most HMAX along the height.\n// Each step is an Euler-Maruyama proposal; one that stays on the same\n// straight piece of V is exact and taken, one that crosses a corner is put\n// to the Metropolis test with the Boltzmann weight of V - F y. So while the\n// potential is held, the steps keep that weight exactly and cannot make a\n// current of their own. Plain Euler steps of this size pushed particles over\n// the steep side more often than back: with the potential held on and no\n// load, 3148 teeth climbed against 2151 fallen in 400 s; with the test,\n// 2430 against 2359.\nfunction stepOn(S, tau, F) {\n  const { X, Y } = S, n = ceil(tau / HMAX - 1e-9), h = tau / n, a = sqrt(2 * D * h), ax = sqrt(2 * D * tau);\n  const up = (F - FG) * h, dn = (F + FS) * h, edge = 1 - A, i4 = 1 / (4 * D * h);\n  let r = S.rng;\n  for (let i = 0; i \u003c NP; i++) {\n    let y = Y[i], k = floor(y / L), g = y / L - k \u003c edge, f = g ? up : dn;\n    for (let j = 0; j \u003c n; j++) {\n      r ^= r \u003c\u003c 13;\n      r ^= r >>> 17;\n      r ^= r \u003c\u003c 5;\n      const yp = y + f + a * G[r & 4095], up2 = yp / L, k2 = floor(up2), s2 = up2 - k2, g2 = s2 \u003c edge;\n      if (k2 === k && g2 === g) {\n        y = yp;\n        continue;\n      }\n      // Across a corner: V at both ends, in units of V0, and the test.\n      const s1 = y / L - k, v1 = g ? s1 / edge : (1 - s1) / A, v2 = g2 ? s2 / edge : (1 - s2) / A, f2 = g2 ? up : dn;\n      const d = yp - y, la = (-(v2 - v1) * V0 + F * d) / D + ((d - f) ** 2 - (d + f2) ** 2) * i4;\n      r ^= r \u003c\u003c 13;\n      r ^= r >>> 17;\n      r ^= r \u003c\u003c 5;\n      if (la >= 0 || (r >>> 0) / 4294967296 \u003c exp(la)) {\n        y = yp;\n        k = k2;\n        g = g2;\n        f = f2;\n      }\n    }\n    Y[i] = y;\n    X[i] += ax * gn();\n  }\n  S.rng = r;\n}\n\n// Wraps the height, counting laps so the marked cloud can be followed\n// unwrapped, reflects the sides, and measures the marked cloud: its mean\n// displacement and its spread, in LEDs, down positive.\nfunction edges(S) {\n  const { X, Y, M, LAP } = S;\n  let n = 0, m = 0, m2 = 0;\n  for (let i = 0; i \u003c NP; i++) {\n    let y = Y[i];\n    if (y \u003c 0 || y >= H) {\n      const q = floor(y / H);\n      y -= q * H;\n      LAP[i] += q;\n    }\n    Y[i] = y;\n    let x = X[i];\n    if (x \u003c 0) x = -x;\n    if (x >= W) x = 2 * W - x - 1e-3;\n    X[i] = cl(x, 0, W - 1e-3);\n    if (M[i] === 1) {\n      const u = y + LAP[i] * H;\n      n++;\n      m += u;\n      m2 += u * u;\n    }\n  }\n  if (n) {\n    m /= n;\n    S.mean = m - S.y0;\n    S.sd = sqrt(max(0, m2 / n - m * m));\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.8, 0.25];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.per = cl(k[2], 0.8, 3.2);\n  S.load = cl(k[3], 0.25, 1.5);\n  // K1 tap: flashing, then held on, then held off, then flashing again.\n  if (input.btnPressed && input.btnPressed[0]) S.hold = (S.hold + 1) % 3;\n  const F = S.load * FSTALL;\n  let rem = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += rem;\n  S.age += rem;\n  if (S.old) {\n    S.old -= rem / FADE;\n    if (S.old \u003c= 0) {\n      S.old = 0;\n      for (let i = 0; i \u003c NP; i++) if (S.M[i] === 2) S.M[i] = 0;\n    }\n  }\n  while (rem > 1e-9) {\n    let on, piece;\n    if (S.hold) {\n      on = S.hold === 1;\n      piece = rem;\n    } else {\n      // The period starts with the potential off.\n      const cut = OFF * S.per;\n      on = S.ph >= cut;\n      piece = min(rem, (on ? S.per : cut) - S.ph);\n      S.ph += piece;\n      if (S.ph >= S.per - 1e-9) S.ph = 0;\n    }\n    if (on) stepOn(S, piece, F);\n    else stepOff(S, piece, F);\n    rem -= piece;\n  }\n  S.on = S.hold ? S.hold === 1 : S.ph >= OFF * S.per;\n  edges(S);\n  if (S.sd > SPREAD || abs(S.mean) > TRAVEL || S.age > TMAX) mark(S, S.mean > 0 ? 1 : NT - 1);\n}\n\n// 1 - exp(-n) in steps of 1/128 of n, the light of n particles' worth.\nconst NTONE = 1280, TONE = new Float32Array(NTONE);\nfor (let i = 0; i \u003c NTONE; i++) TONE[i] = 1 - exp(-i / 128);\n\n// Separable blur [1 4 6 4 1] / 16, wrapping in height, clamped at the sides.\nfunction blur(src, tmp) {\n  for (let y = 0; y \u003c H; y++) {\n    const r = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      const a = src[r + max(0, x - 2)], b = src[r + max(0, x - 1)], c = src[r + x], d = src[r + min(W - 1, x + 1)], e = src[r + min(W - 1, x + 2)];\n      tmp[r + x] = (a + e + 4 * (b + d) + 6 * c) / 16;\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const r0 = ((y + H - 2) % H) * W, r1 = ((y + H - 1) % H) * W, r2 = y * W, r3 = ((y + 1) % H) * W, r4 = ((y + 2) % H) * W;\n    for (let x = 0; x \u003c W; x++) src[r2 + x] = (tmp[r0 + x] + tmp[r4 + x] + 4 * (tmp[r1 + x] + tmp[r3 + x]) + 6 * tmp[r2 + x]) / 16;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { X, Y, M, da, db, tmp, col } = S;\n  da.fill(0);\n  db.fill(0);\n  // Each particle shared out over the four LEDs round it: the marked cloud\n  // into its own grid, a fading one into both.\n  for (let i = 0; i \u003c NP; i++) {\n    const x = X[i] - 0.5, y = Y[i] - 0.5, x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n    const xa = max(0, x0), xb = min(W - 1, x0 + 1), ya = ((y0 % H) + H) % H, yb = (ya + 1) % H;\n    const w00 = (1 - fx) * (1 - fy), w10 = fx * (1 - fy), w01 = (1 - fx) * fy, w11 = fx * fy;\n    const m = M[i], wb = m === 1 ? 1 : m === 2 ? S.old : 0, wa = 1 - wb;\n    if (wa > 0) {\n      da[ya * W + xa] += w00 * wa;\n      da[ya * W + xb] += w10 * wa;\n      da[yb * W + xa] += w01 * wa;\n      da[yb * W + xb] += w11 * wa;\n    }\n    if (wb > 0) {\n      db[ya * W + xa] += w00 * wb;\n      db[ya * W + xb] += w10 * wb;\n      db[yb * W + xa] += w01 * wb;\n      db[yb * W + xb] += w11 * wb;\n    }\n  }\n  blur(da, tmp);\n  blur(db, tmp);\n  // Colours: the cloud, the marked cloud and the field.\n  hsv(0.55 + S.hue, 0.7, 0.78, col, 0);\n  hsv(0.11 + S.hue, 0.75, 1, col, 3);\n  hsv(0.76 + S.hue, 0.7, 1, col, 6);\n  const GA = 1, GB = 2, FIELD = 0.3;\n  for (let y = 0; y \u003c H; y++) {\n    // V at this row, 0 at a minimum and 1 at a maximum.\n    let f = 0;\n    if (S.on) {\n      const u = (y + 0.5) / L, s = u - floor(u);\n      const v = s \u003c 1 - A ? s / (1 - A) : (1 - s) / A;\n      f = FIELD * v * v;\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, a = TONE[min(NTONE - 1, (da[p] * GA * 128) | 0)], b = TONE[min(NTONE - 1, (db[p] * GB * 128) | 0)], o = 1 - b;\n      const r = col[6] * f * o + a * col[0] * o + b * col[3];\n      const g = col[7] * f * o + a * col[1] * o + b * col[4];\n      const bl = col[8] * f * o + a * col[2] * o + b * col[5];\n      if (r + g + bl \u003c 0.01) continue;\n      // Each channel in steps of 4 of 255.\n      display.setPixel(x, y, min(255, round(r * 63.75) * 4), min(255, round(g * 63.75) * 4), min(255, round(bl * 63.75) * 4));\n    }\n  }\n  // Marks on both edges: where the marked cloud started, dim, and the\n  // height of its mean now, which climbs while the flashing wins.\n  tick(display, S.y0, 3, 0.4, col);\n  tick(display, S.y0 + S.mean, 4, 1, col);\n}\n\n// A short bar on each edge at height y, shared between two rows.\nfunction tick(display, y, len, v, col) {\n  y = y - 0.5 - floor((y - 0.5) / H) * H;\n  const y0 = floor(y), fy = y - y0;\n  for (const [row, w] of [[y0, 1 - fy], [(y0 + 1) % H, fy]]) {\n    const c = v * min(1, w * 1.6);\n    if (c \u003c 0.08) continue;\n    for (let i = 0; i \u003c len; i++)\n      for (const x of [i, W - 1 - i]) display.setPixel(x, row, round(col[3] * c * 63.75) * 4, round(col[4] * c * 63.75) * 4, round(col[5] * c * 63.75) * 4);\n  }\n}\n","fractal-percolation":"// ===== Patternflow pattern =====\n// Title:   Fractal Percolation\n// Family:  fractal\n// Idea:    Two stacked squares split into quarters again and again down to single LEDs, each quarter kept with chance p and the rest going dark, then a front climbs from the bottom row through the kept LEDs, the cluster that reaches the top row lights mint while the rest stays dim, and the view zooms into a kept pair of squares that grows to fill the panel and splits once more.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fractal percolation (Benoit Mandelbrot, 1974), with the crossing transition of Chayes, Chayes and Durrett (1988), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Keep=0.88..0.99, Levels=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the kept LEDs are steel blue, the front is white over a pale blue trail, the crossing cluster is mint and the holes are dark plum; at 0.25 the kept LEDs are purple, the crossing cluster blue and the holes olive; at 0.5 tan, pink and green; at 0.75 green, yellow and navy.\n// Knob 2: Speed. At 2 a level splits every 0.45 s, so a build from two squares to single LEDs takes 2.7 s and the first front sets off 3 s in; the front climbs 110 LEDs of path a second (1.2 s to the top row on average), a crossing cluster stays lit 1.4 s and a zoom takes 1.4 s, and after four zooms the holes close and a fresh build begins, about every 23 s. At 0.2 everything is ten times slower; at 3 half as fast again, a fresh build every 16 s.\n// Knob 3: Keep. The chance p that each quarter is kept at every split. At the opening 0.88 the front reaches the top row in about half the tests and 47% of the LEDs are kept; at 0.90 in seven of ten, with 53% kept; at 0.93 in nine of ten, with 65% kept; at 0.99 every time, with 94% kept. The kept set is a random Cantor set of dimension log(4p)/log 2, 1.82 at 0.88 and 1.99 at 0.99.\n// Knob 4: Levels. How brightly each hole keeps the colour of the level that cut it, magenta for the 32-LED holes and a step on towards blue-violet for each smaller size. At 0 every hole is black and only the set shows; at the opening 0.06 the 32-LED holes glow at 35/255 and the single-LED ones at 16, so the big holes read as dark plum squares; at 0.25 at 71 and 32, and at 1 at 142 and 65, a mosaic of squares inside squares.\n// Buttons: K1 tap closes the holes back into two whole squares and carves a fresh set.\n\nconst W = 64, H = 128, N = W * H, DEPTH = 6;\nconst { floor, min, max, exp, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Seconds at Speed 2: one level's split, the fade of a cut square, the time\n// a crossing (or its absence) stays lit, and one zoom by two.\nconst STEP = 0.45, FADE = 0.35, SEAM = 0.4, HOLD = 1.4, MISS = 0.7, ZOOM = 1.4, HEAL = 0.09;\n// The front climbs this many LEDs of path a second, and four zooms follow a\n// build before a fresh one.\nconst CLIMB = 110, ZMAX = 4;\n\n// Carves levels a..b into cut on a grid w wide and h tall made of w-by-w\n// squares: at level k every square of side w >> k that no earlier level has\n// cut is cut whole with chance 1 - p. cut holds the level that removed each\n// LED's square, or 0 while it is kept.\nfunction carve(cut, w, h, a, b, p) {\n  for (let k = a; k \u003c= b; k++) {\n    const s = w >> k;\n    for (let y = 0; y \u003c h; y += s)\n      for (let x = 0; x \u003c w; x += s) {\n        const o = y * w + x;\n        if (cut[o] || Math.random() \u003c p) continue;\n        for (let j = 0; j \u003c s; j++) cut.fill(k, o + j * w, o + j * w + s);\n      }\n  }\n}\n\n// Path length from the bottom row through kept LEDs that share an edge, into\n// dist (-1 where the bottom row cannot be reached). Returns the shortest path\n// to the top row, or -1 when no kept path crosses.\nfunction reach(cut, w, h, dist, q) {\n  dist.fill(-1);\n  let t = 0, top = -1;\n  for (let x = 0, o = (h - 1) * w; x \u003c w; x++) if (!cut[o + x]) (dist[o + x] = 0), (q[t++] = o + x);\n  for (let i = 0; i \u003c t; i++) {\n    const p = q[i], d = dist[p] + 1, x = p % w;\n    if (p \u003c w && top \u003c 0) top = d - 1;\n    if (x > 0 && !cut[p - 1] && dist[p - 1] \u003c 0) (dist[p - 1] = d), (q[t++] = p - 1);\n    if (x \u003c w - 1 && !cut[p + 1] && dist[p + 1] \u003c 0) (dist[p + 1] = d), (q[t++] = p + 1);\n    if (p >= w && !cut[p - w] && dist[p - w] \u003c 0) (dist[p - w] = d), (q[t++] = p - w);\n    if (p + w \u003c w * h && !cut[p + w] && dist[p + w] \u003c 0) (dist[p + w] = d), (q[t++] = p + w);\n  }\n  return top;\n}\n\n// The crossing cluster: every LED reached from the bottom row that also\n// connects to the top row, marked 1 in mark. Returns how many there are.\nfunction spanning(w, h, dist, mark, q) {\n  mark.fill(0);\n  let t = 0;\n  for (let x = 0; x \u003c w; x++) if (dist[x] >= 0) (mark[x] = 1), (q[t++] = x);\n  for (let i = 0; i \u003c t; i++) {\n    const p = q[i], x = p % w;\n    for (const n of [x > 0 ? p - 1 : -1, x \u003c w - 1 ? p + 1 : -1, p - w, p + w \u003c w * h ? p + w : -1])\n      if (n >= 0 && dist[n] >= 0 && !mark[n]) (mark[n] = 1), (q[t++] = n);\n  }\n  return t;\n}\n\n// Zoom targets: a column of the level-1 grid (32 LEDs wide) and a pair of\n// its rows, so 32 by 64 LEDs, the panel's shape at half its size. Only pairs\n// whose two squares survived level 1 can be chosen, and the choice looks at\n// nothing else, so the view after a zoom is a fresh sample of the\n// construction one level down.\nfunction target(cut) {\n  const ok = [];\n  for (let c = 0; c \u003c 2; c++)\n    for (let r = 0; r \u003c 3; r++) if (cut[r * 32 * W + c * 32] !== 1 && cut[(r + 1) * 32 * W + c * 32] !== 1) ok.push([c * 32, r * 32]);\n  return ok.length ? ok[floor(Math.random() * ok.length)] : null;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, p: 0.88, lev: 0.06, t: 0,\n    ph: \"build\", pt: 0, L: 0, maxd: 0, revT: new Float64Array(DEPTH + 1).fill(-9), R: 0, top: -1, crossed: false, zooms: 0, tgt: null, zs: 1,\n    cut: new Uint8Array(N), dist: new Int32Array(N), mark: new Uint8Array(N), q: new Int32Array(N),\n    lit: new Float32Array(N), glow: new Float32Array(N),\n    tmp: new Uint8Array(N), tmpF: new Float32Array(N), tmpL: new Float32Array(N),\n    pal: new Float32Array(32 * 3), palKey: \"\",\n    // Fronts sent and crossings found, kept for checking the rates above.\n    tests: 0, hits: 0,\n  };\n  fresh(params.s);\n}\n\nfunction fresh(S) {\n  S.cut.fill(0);\n  S.ph = \"build\";\n  S.pt = 0;\n  S.L = 0;\n  S.revT.fill(-9);\n  S.zooms = 0;\n  S.R = 0;\n  S.crossed = false;\n}\n\n// After a zoom: every LED of the chosen pair becomes a 2-by-2 block and each\n// level moves up one; the build then carves the single LEDs anew.\nfunction settle(S) {\n  const [ox, oy] = S.tgt, { cut, lit, glow, tmp, tmpF, tmpL } = S;\n  tmp.set(cut);\n  tmpF.set(lit);\n  tmpL.set(glow);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = (oy + (y >> 1)) * W + ox + (x >> 1), c = tmp[o];\n      cut[p] = c > 1 ? c - 1 : 0;\n      lit[p] = tmpF[o];\n      glow[p] = tmpL[o];\n    }\n  for (let k = 1; k \u003c DEPTH; k++) S.revT[k] = -9;\n  S.L = DEPTH - 1;\n  S.ph = \"build\";\n  S.pt = STEP * (DEPTH - 1) + 0.2;\n  S.zooms++;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.88, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.p = cl(k[2], 0.88, 0.99);\n  S.lev = cl(k[3], 0, 1);\n  const d = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += d;\n  S.pt += d;\n  if (input.btnPressed && input.btnPressed[0] && S.ph !== \"heal\") (S.ph = \"heal\"), (S.pt = 0), (S.crossed = false);\n  if (S.ph === \"build\") {\n    // Level L + 1 splits every STEP; the front sets off 0.3 s after the last.\n    const L = min(DEPTH, floor(S.pt / STEP));\n    // Each level is carved as it splits, so turning Keep acts on the next.\n    while (S.L \u003c L) {\n      S.L++;\n      carve(S.cut, W, H, S.L, S.L, S.p);\n      S.revT[S.L] = S.t;\n    }\n    if (S.L === DEPTH && S.pt > STEP * DEPTH + 0.3) {\n      S.top = reach(S.cut, W, H, S.dist, S.q);\n      // The longest path, for when nothing crosses.\n      let m = 0;\n      for (let p = 0; p \u003c N; p++) if (S.dist[p] > m) m = S.dist[p];\n      S.maxd = m;\n      S.ph = \"burn\";\n      S.pt = 0;\n      S.R = 0;\n      S.crossed = false;\n    }\n  } else if (S.ph === \"burn\") {\n    S.R += CLIMB * d;\n    if (S.top >= 0 && S.R >= S.top) {\n      spanning(W, H, S.dist, S.mark, S.q);\n      S.crossed = true;\n      S.ph = \"hold\";\n      S.pt = 0;\n      S.tests++;\n      S.hits++;\n    } else if (S.top \u003c 0 && S.R > S.maxd + 8) {\n      // The front has run out of path: no crossing this time.\n      S.ph = \"hold\";\n      S.pt = HOLD - MISS;\n      S.tests++;\n    }\n  } else if (S.ph === \"hold\") {\n    if (S.pt > HOLD) {\n      S.tgt = S.zooms \u003c ZMAX ? target(S.cut) : null;\n      S.ph = S.tgt ? \"zoom\" : \"heal\";\n      S.pt = 0;\n    }\n  } else if (S.ph === \"zoom\") {\n    const u = cl(S.pt / ZOOM, 0, 1);\n    // Eased in and out, scaled exponentially so it looks like a steady fall.\n    S.zs = pow(2, u * u * (3 - 2 * u));\n    if (S.pt >= ZOOM) {\n      S.zs = 1;\n      S.crossed = false;\n      settle(S);\n    }\n  } else if (S.ph === \"heal\") {\n    // The holes close from the smallest up, then a fresh set is carved.\n    S.crossed = false;\n    const L = DEPTH - floor(S.pt / HEAL);\n    if (L \u003c S.L) S.L = max(0, L);\n    if (S.pt > HEAL * (DEPTH + 1) + 0.25) fresh(S);\n  }\n  // Light: the front and its trail brighten the kept LEDs it has reached;\n  // once it crosses, the crossing cluster turns to the accent and the rest\n  // falls back.\n  const burning = S.ph === \"burn\" || S.ph === \"hold\", kf = 1 - exp(-d * 7), kg = 1 - exp(-d * 4);\n  const { dist, lit, glow, mark } = S;\n  for (let p = 0; p \u003c N; p++) {\n    let tl = 0, tg = 0;\n    if (burning && dist[p] >= 0 && dist[p] \u003c= S.R) {\n      if (S.crossed) tg = mark[p];\n      else tl = 0.55;\n    }\n    lit[p] += (tl - lit[p]) * kf;\n    if (S.ph !== \"zoom\") glow[p] += (tg - glow[p]) * (tg > glow[p] ? kf * 1.5 : kg);\n  }\n}\n\n// Colours: 0 kept, 1 lit trail, 2 crossing, 3 front, 4 cut flash, 8 + k the\n// hole of level k.\nfunction palette(S) {\n  const key = S.hue + \":\" + S.lev;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const h = S.hue + 0.6, P = S.pal;\n  hsv(h, 0.5, 0.5, P, 0);\n  hsv(h, 0.35, 0.9, P, 3);\n  hsv(h + 0.82, 0.62, 0.9, P, 6);\n  hsv(h + 0.82, 0.1, 1, P, 9);\n  hsv(h, 0.2, 1, P, 12);\n  for (let k = 1; k \u003c= DEPTH; k++) {\n    // Each level its own hue, 0.055 of the wheel on from the last; the\n    // larger the hole, the brighter its glow.\n    const v = 0.55 * pow(S.lev, 0.5) * (1.12 - 0.11 * k);\n    hsv(h + 0.33 - 0.055 * (k - 1), 0.7, v, P, (8 + k) * 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const { cut, lit, glow, dist, pal: P, revT } = S;\n  const zoom = S.ph === \"zoom\", s = S.zs, fx = zoom ? S.tgt[0] * 2 : 0, fy = zoom ? S.tgt[1] * 2 : 0;\n  const front = S.ph === \"burn\";\n  // While a level splits, the edges of its new squares show as dark seams\n  // for a moment; before the first split, the edge between the two squares.\n  const L = S.L, age = L ? S.t - revT[L] : 0, ss = 64 >> (L ? L : 0);\n  const seam = S.ph === \"build\" && L \u003c= 3 && age \u003c SEAM ? 0.35 + 0.65 * (L ? age / SEAM : 0) : 0;\n  for (let y = 0; y \u003c H; y++) {\n    const sy = zoom ? floor(fy + (y + 0.5 - fy) / s) : y;\n    for (let x = 0; x \u003c W; x++) {\n      const sx = zoom ? floor(fx + (x + 0.5 - fx) / s) : x;\n      if (sx \u003c 0 || sx >= W || sy \u003c 0 || sy >= H) continue;\n      const p = sy * W + sx, c = cut[p];\n      let r, g, b;\n      if (c && c \u003c= S.L) {\n        // A cut square: a flash, then the glow of its level.\n        const a = min(1, (S.t - revT[c]) / FADE), o = (8 + c) * 3;\n        const f = (1 - a) * (1 - a);\n        r = P[o] + (P[12] - P[o]) * f;\n        g = P[o + 1] + (P[13] - P[o + 1]) * f;\n        b = P[o + 2] + (P[14] - P[o + 2]) * f;\n      } else {\n        const l = lit[p], gg = glow[p];\n        r = P[0] + (P[3] - P[0]) * l;\n        g = P[1] + (P[4] - P[1]) * l;\n        b = P[2] + (P[5] - P[2]) * l;\n        r += (P[6] - r) * gg;\n        g += (P[7] - g) * gg;\n        b += (P[8] - b) * gg;\n        if (front && dist[p] >= 0 && dist[p] \u003c= S.R && S.R - dist[p] \u003c 5) {\n          const f = 1 - (S.R - dist[p]) / 5;\n          r += (P[9] - r) * f;\n          g += (P[10] - g) * f;\n          b += (P[11] - b) * f;\n        }\n      }\n      if (seam && !(c && c \u003c= S.L) && (sx % ss === 0 || sy % ss === 0)) (r *= seam), (g *= seam), (b *= seam);\n      // Channels in steps of 4 of 255: too fine to see, and a frame packs smaller.\n      display.setPixel(x, y, min(255, round(r / 4) * 4), min(255, round(g / 4) * 4), min(255, round(b / 4) * 4));\n    }\n  }\n}\n","grim-reaper":"// ===== Patternflow pattern =====\n// Title:   Grim Reaper\n// Family:  halloween\n// Idea:    A hooded reaper in a tattered black robe drifts across a hillside graveyard in front of a huge pale moon and a sickly green horizon, two toxic green points burning in its hood and shreds of its ragged hem streaming behind, swinging a long scythe over its head in a wide arc whose blade glints, while the grave candles gutter and go out as it passes over them and light again behind it.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Graves=6..30, Fog=0..1\n//\n// Knob 1: Hue. The glow at the horizon, the moon's tint and the eyes; the sky overhead stays deep purple and the candles gold. At 0 a sickly green horizon, a pale yellow moon and toxic green eyes; at 0.25 a teal horizon, a mint moon and sky blue eyes; at 0.5 violet, lavender and magenta; at 0.75 a red horizon, a pink moon and orange eyes.\n// Knob 2: Speed. At 2 a pass takes 10 s: in from the right in 1.8 s, 5.7 s drifting 18 LEDs across the moon while it sways 5 LEDs either way and bobs 6 up and down every 2.9 s, and out to the left in 2.5 s. The scythe swings every 3.2 s (wound back in 0.55 s, the stroke in 0.32 s, held 0.3 s, brought back in 1.2 s), and a candle lights again 0.6 to 1.8 s after the robe has passed it. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Graves. How many graves, six to a row, each with a candle at its foot. At 6 one row stands along the bottom and the robe is all against the sky; at 12 a second row stands 9 LEDs higher on a hill, at 18, 24 and 30 a third, fourth and fifth, each a sixth smaller, until the hill's crest reaches row 82 and the candles climb it.\n// Knob 4: Fog. A lilac fog rolling to the right at 8 to 11 LEDs a second. At 0 none; at 0.06 a thin haze over the bottom 22 rows, at most a fifth thick; at 0.5 it reaches row 88 and 0.38 thick; at 1 row 68, over the hem and the lower robe, 0.58 thick.\n// Buttons: K1 tap swings the scythe at once, from rest or while it is being brought back.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// A huge moon high in the middle; the horizon glows low down.\nconst MX = 31, MY = 45, MR = 30;\n// Headstones, each [width, height] near: a round-topped slab, a cross, a\n// broken slab, an obelisk and a slab with its corners cut.\nconst KINDS = [[11, 18], [9, 21], [11, 15], [7, 24], [12, 16]];\nfunction solid(kind, i, j, w, h) {\n  const c = (w - 1) / 2, dx = abs(i - c);\n  if (kind === 0) return j >= w / 2 || (i + 0.5 - w / 2) ** 2 + (w / 2 - j - 0.5) ** 2 \u003c= (w / 2) ** 2;\n  if (kind === 1) return dx \u003c= 1 || (j >= 3 && j \u003c= 4) || (j >= h - 2 && dx \u003c= 2.5);\n  if (kind === 2) return j >= (h * 0.35 * i) / w + (abs(i - c * 0.8) \u003c 1 ? 2 : 0);\n  if (kind === 3) return j >= h - 2 || dx \u003c= (j \u003c 3 ? j * 0.5 : 0.8 + (1.2 * j) / h);\n  return j > 0 || dx \u003c c - 0.5;\n}\n\n// The reaper, in its own frame: u across (negative is forward, the way it\n// drifts), v down from its shoulders, both in LEDs.\n// The scythe: the hand holds the snath LO below and UP above the grip; the\n// blade, BL long, leaves the top at right angles and curls back down.\nconst UP = 27, LO = 12, BL = 19, CURL = 0.3;\n// Swing angles of the snath from straight up, forward positive: at rest,\n// wound back over the shoulder, and at the end of the stroke, low in front.\nconst REST = 0.18, BACK = -0.62, END = 3.0;\n// Seconds at Speed 2: wind back, the stroke, the hold, the return, and the\n// rest before the next swing.\nconst TW = 0.55, TS = 0.32, TF = 0.3, TR = 1.2, TREST = 0.8;\n// One pass across the panel, in seconds at Speed 2.\nconst PASS = 10;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, ng: 0, fog: 0.06,\n    pass: 0.1, bx: 60, by: 50,\n    sw: \"rest\", st: TREST - 1.1, from: REST, phi: REST, glint: -1, glintT: 2,\n    candles: [], smoke: [], shreds: [], shredT: 0,\n    scene: new Uint8Array(N), bg: new Float32Array(N * 3), bgKey: -1, buf: new Float32Array(N * 3), mask: new Uint8Array(N),\n    c: [0, 0, 0], e: [0, 0, 0], fn: new Float32Array(2 * W), stamps: {},\n  };\n}\n\n// The graveyard climbs a hill, six graves to a row: the first row stands at\n// the foot, each further row 9 to 10 LEDs higher and a sixth smaller, and the\n// hill rises behind the last row, so more graves cover more of the glowing\n// horizon. Each grave has a candle at its foot.\nconst PER = 6, rowBase = (r) => 124 - 9 * r - (r > 1 ? r - 1 : 0), rowScale = (r) => 1 - 0.17 * r;\n// Scene codes: 0 sky, 1 hill, 2 its moonlit crest, 10 + r a stone of row r,\n// 20 + r its moonlit top.\nfunction graveyard(S, n) {\n  const sc = S.scene, R = ceil(n / PER);\n  sc.fill(0);\n  for (let x = 0; x \u003c W; x++) {\n    const top = rowBase(R - 1) - 3 + round(1.3 * sin(x / 9 + 0.7) + 0.6 * sin(x / 4.1));\n    for (let y = top; y \u003c H; y++) sc[y * W + x] = y === top ? 2 : 1;\n  }\n  const old = S.candles;\n  S.candles = [];\n  for (let r = R - 1; r >= 0; r--) {\n    const m = min(PER, n - r * PER), sz = rowScale(r);\n    for (let j = 0; j \u003c m; j++) {\n      const i = r * PER + j, kind = floor(hash(i * 17 + 3) * KINDS.length), w = max(3, round(KINDS[kind][0] * sz)), h = max(4, round(KINDS[kind][1] * sz));\n      const cx = (round(((j + 0.5 + (r % 2) * 0.5) * 64) / PER + (hash(i * 5 + 1) - 0.5) * 5) + W) % W, x0 = cx - (w >> 1);\n      const base = rowBase(r) + round(1.3 * sin(cx / 9 + 0.7));\n      for (let jj = 0; jj \u003c h; jj++)\n        for (let k = 0; k \u003c w; k++) {\n          const x = x0 + k, y = base - h + jj + 1;\n          if (x >= 0 && x \u003c W && y \u003c H && solid(kind, (k * KINDS[kind][0]) / w, (jj * KINDS[kind][1]) / h, KINDS[kind][0], KINDS[kind][1])) sc[y * W + x] = 10 + r;\n        }\n      const x = cl(cx + (hash(i * 11 + 7) \u003c 0.5 ? -(w >> 1) - 1 : (w >> 1) + 1), 1, W - 2);\n      const prev = old.find((c) => c.x === x && c.y === base);\n      S.candles.push(prev || { x, y: base, f: 1, out: false, wait: 0, sd: i * 97 + 5, h: max(1, round((3 + floor(hash(i * 7) * 2)) * sz)), sz });\n    }\n  }\n  for (let p = N - 1; p >= W; p--) if (sc[p] >= 10 && sc[p] \u003c 20 && sc[p - W] !== sc[p]) sc[p] += 10;\n  S.ng = n;\n}\n\n// Where the reaper is along a pass: in from the right, a slow drift across\n// the moon, and out to the left.\nfunction passX(a) {\n  if (a \u003c 0.18) return 104 - 54 * (1 - (1 - a / 0.18) ** 2);\n  if (a \u003c 0.75) return 50 - 18 * ((a - 0.18) / 0.57);\n  const b = (a - 0.75) / 0.25;\n  return 32 - 62 * b * b - 16 * b;\n}\n\nfunction swing(S, ds, tap) {\n  S.st += ds;\n  if (tap && (S.sw === \"rest\" || S.sw === \"back\")) (S.sw = \"wind\"), (S.st = 0), (S.from = S.phi);\n  if (S.sw === \"rest\") {\n    S.phi = REST + 0.25 * sin(S.st * 2.6);\n    if (S.st > TREST) (S.sw = \"wind\"), (S.st = 0), (S.from = S.phi);\n  } else if (S.sw === \"wind\") {\n    S.phi = S.from + (BACK - S.from) * sm(S.st / TW);\n    if (S.st > TW) (S.sw = \"strike\"), (S.st = 0), (S.glint = 0);\n  } else if (S.sw === \"strike\") {\n    const u = cl(S.st / TS, 0, 1);\n    S.phi = BACK + (END - BACK) * (u * u * (2 - u));\n    if (S.st > TS) (S.sw = \"follow\"), (S.st = 0);\n  } else if (S.sw === \"follow\") {\n    S.phi = END + 0.06 * sin(S.st * 20) * exp(-S.st * 8);\n    if (S.st > TF) (S.sw = \"back\"), (S.st = 0);\n  } else {\n    S.phi = END + (REST - END) * sm(S.st / TR);\n    if (S.st > TR) (S.sw = \"rest\"), (S.st = 0);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.fog = cl(k[3], 0, 1);\n  const ng = round(cl(k[2], 6, 30));\n  if (ng !== S.ng) graveyard(S, ng);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.pass += ds / PASS;\n  if (S.pass >= 1) S.pass -= 1;\n  // A sway and a bob on top of the drift: it never hangs still.\n  S.bx = passX(S.pass) + 5 * sin(S.t * 1.9);\n  S.by = 46 + 6 * sin(S.t * 2.2);\n  swing(S, ds, input.btnPressed && input.btnPressed[0]);\n  // A glint runs along the blade with every stroke, and now and then the\n  // moon catches it at rest.\n  if (S.glint >= 0) {\n    S.glint += ds / 0.45;\n    if (S.glint > 1.3) S.glint = -1;\n  } else if ((S.glintT -= ds) \u003c 0) (S.glint = 0), (S.glintT = 2.5 + 2 * hash(floor(S.t * 10)));\n  // Candles: a flame gutters as the hem comes near, goes out under the\n  // robe and lights again a moment after the reaper has passed.\n  for (const c of S.candles) {\n    const rel = c.x - S.bx;\n    if (!c.out) {\n      const tf = rel \u003c -26 || rel > 20 ? 1 : rel \u003c -14 ? (-14 - rel) / 12 : 0;\n      c.f += (tf - c.f) * min(1, ds * (tf \u003c c.f ? 5 : 2));\n      if (c.f \u003c 0.12) {\n        c.out = true;\n        c.f = 0;\n        c.wait = 0.6 + 1.2 * hash(c.sd + floor(S.t));\n        for (let i = 0; i \u003c 3; i++) S.smoke.push({ x: c.x, y: c.y - c.h - i, a: -0.15 * i, sd: c.sd + i });\n      }\n    } else if (rel > 18 || rel \u003c -44) {\n      if ((c.wait -= ds) \u003c 0) (c.out = false), (c.f = 1.7);\n    }\n    if (c.f > 1) c.f = max(1, c.f - ds * 2.5);\n  }\n  // Shreds of the hem tear off and blow away behind it.\n  for (let n = S.shredT + ds * 22; n >= 1; n--) {\n    const v = 44 + Math.random() * 14;\n    S.shreds.push({ x: S.bx + 15 + (v - 44) * 0.6 + Math.random() * 4, y: S.by + v, vx: 9 + Math.random() * 9, vy: -3 + Math.random() * 4, a: 0 });\n  }\n  S.shredT = (S.shredT + ds * 22) % 1;\n  let kept = 0;\n  for (const m of S.shreds) {\n    m.a += ds;\n    m.x += m.vx * ds;\n    m.y += m.vy * ds;\n    if (m.a \u003c 1.1 && m.x \u003c W + 2) S.shreds[kept++] = m;\n  }\n  S.shreds.length = kept;\n  // Smoke from a flame that went out rises and drifts off.\n  kept = 0;\n  for (const m of S.smoke) {\n    m.a += ds;\n    m.y -= ds * 7;\n    m.x += ds * (2 + 3 * vn(S.t + m.sd, m.sd));\n    if (m.a \u003c 1.6) S.smoke[kept++] = m;\n  }\n  S.smoke.length = kept;\n}\n\n// Sky, moon and horizon for one hue, in flat steps: deep purple overhead,\n// turning the short way round the wheel to the glow at the horizon, sickly\n// green at Hue 0. The moon is pale, with a hint of the glow.\nfunction background(S) {\n  if (S.bgKey === S.hue) return;\n  S.bgKey = S.hue;\n  const bg = S.bg, gh = 0.27 + S.hue, sky = [0, 0, 0], moon = hsv(gh - 0.1, 0.16, 0.95, [0, 0, 0]), sea = hsv(gh - 0.05, 0.2, 0.8, [0, 0, 0]);\n  let dh = gh - 0.76;\n  dh -= Math.round(dh);\n  for (let y = 0; y \u003c H; y++) {\n    const f = y \u003c 40 ? 0 : floor(min(1, pow((y - 40) / 74, 0.85)) * 11) / 11;\n    hsv(0.76 + dh * f, 0.62 + 0.04 * f, 0.2 + 0.46 * f, sky);\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n      for (let c = 0; c \u003c 3; c++) bg[o + c] = sky[c];\n      if (r \u003c MR) {\n        const s = vn(x * 0.3 + 3, 11) + vn(y * 0.27 + 7, 23) + 0.6 * vn((x + y) * 0.21, 5) > 0.75;\n        const t = r > MR - 1.2 ? 0.88 : 1;\n        for (let c = 0; c \u003c 3; c++) bg[o + c] = (s ? sea[c] : moon[c]) * t;\n      } else {\n        const g = r \u003c MR + 3 ? 0.2 : r \u003c MR + 7 ? 0.11 : r \u003c MR + 13 ? 0.05 : 0;\n        for (let c = 0; c \u003c 3; c++) bg[o + c] += moon[c] * g;\n      }\n    }\n  }\n}\n\n// The robe's spans on one row, in the reaper's frame, into SP as pairs;\n// returns how many. The hood's dark opening is FACE.\nconst SP = new Float32Array(32), FACE = [0, 0];\nfunction spans(v, t) {\n  FACE[0] = FACE[1] = 0;\n  if (v \u003c -22 || v > 64) return 0;\n  if (v \u003c -4) {\n    // The hood, its peak leaning back, and the opening in front.\n    const top = v \u003c -12 ? pow((v + 22) / 10, 0.7) : 1, cu = 1 + max(0, -12 - v) * 0.5, hw = 7.4 * top + (v > -8 ? (v + 8) * 0.6 : 0);\n    const fv = 1 - ((v + 10.5) / 4.6) ** 2;\n    if (fv > 0) (FACE[0] = -3 - 3.3 * sqrt(fv)), (FACE[1] = -3 + 3.3 * sqrt(fv));\n    SP[0] = cu - hw;\n    SP[1] = cu + hw;\n    return 1;\n  }\n  if (v \u003c 12) {\n    const hw = v \u003c 2 ? 8.5 + (v + 4) * 0.5 : 11.5 + (v - 2) * 0.05;\n    SP[0] = 1.5 - hw;\n    SP[1] = 1.5 + hw;\n    return 1;\n  }\n  // The skirt widens and leans back, its back edge rippling.\n  const cu = 1.5 + (v - 12) * 0.1, hw = 12 + (v - 12) * 0.12;\n  const back = (w) => cu + hw + (1.5 + 3 * ((w - 12) / 32)) * sin(w * 0.3 - t * 6.5);\n  if (v \u003c 44) {\n    SP[0] = cu - hw + 2 * sin(v * 0.25 - t * 5.5);\n    SP[1] = back(v);\n    return 1;\n  }\n  // Below the hem, eight tattered strips stream back and flutter.\n  const L = cu - hw + 2 * sin(44 * 0.25 - t * 5.5), R = back(44), wd = (R - L) / 8;\n  let n = 0;\n  for (let i = 0; i \u003c 8; i++) {\n    const len = 8 + 13 * hash(i * 13 + 1) + 3 * sin(t * 2.4 + i * 2.3), s = (v - 44) / len;\n    if (s > 1) continue;\n    const du = (v - 44) * 0.5 + sin(t * 9 + i * 1.9 - (v - 44) * 0.4) * 3.6 * s, c = L + (i + 0.5) * wd + du, w = wd * 0.62 * (1 - s) + 0.3;\n    SP[2 * n] = c - w;\n    SP[2 * n + 1] = c + w;\n    n++;\n  }\n  return n;\n}\n\n// A tapered capsule from (ax, ay) to (bx, by) into the mask, radius ra to rb.\nfunction capsule(mask, ox, oy, ax, ay, bx, by, ra, rb) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const x0 = max(0, floor(ox + min(ax, bx) - ra)), x1 = min(W - 1, ceil(ox + max(ax, bx) + ra)), y0 = max(0, floor(oy + min(ay, by) - ra)), y1 = min(H - 1, ceil(oy + max(ay, by) + ra));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5 - ox - ax, py = y + 0.5 - oy - ay, s = cl((px * dx + py * dy) / l, 0, 1);\n      if ((px - dx * s) ** 2 + (py - dy * s) ** 2 \u003c (ra + (rb - ra) * s) ** 2 && !mask[y * W + x]) mask[y * W + x] = 1;\n    }\n}\n\n// Neighbour steps, a point on the blade, and where along the blade the sweep runs.\nconst NB4 = [1, 0, -1, 0, 0, 1, 0, -1], BP = [0, 0], ALONG = [0.55, 0.8, 1];\n\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ng) return;\n  background(S);\n  const { buf, mask, bg, scene } = S, t = S.t, hs = S.hue;\n  buf.set(bg);\n  // The hill, dark, with its crest lit by the moon.\n  for (let p = 0; p \u003c N; p++) {\n    const m = scene[p];\n    if (!m) continue;\n    const o = p * 3;\n    if (m === 1) (buf[o] = 10), (buf[o + 1] = 7), (buf[o + 2] = 15);\n    else if (m === 2) (buf[o] = 50), (buf[o + 1] = 58), (buf[o + 2] = 60);\n    else {\n      // Stones: grey faces in the moonlight, dimmer row by row up the hill.\n      const f = 1 - 0.13 * (m % 10), lit = m >= 20 ? 2.05 : 1;\n      buf[o] = 44 * f * lit;\n      buf[o + 1] = 40 * f * lit;\n      buf[o + 2] = 58 * f * lit;\n    }\n  }\n  // Candles: a wax stub and a flame that leans and flickers, smaller up the hill.\n  for (const c of S.candles) {\n    for (let j = 0; j \u003c c.h; j++) put(buf, c.x, c.y - j, 196, 184, 160, 1);\n    if (c.out || c.f \u003c= 0.02) continue;\n    const fl = 0.75 + 0.25 * vn(t * 9 + c.sd, c.sd), gut = c.f \u003c 1 ? 1 + 2.5 * (1 - c.f) * vn(t * 23, c.sd + 3) : 0;\n    const f = c.f * fl, top = c.y - c.h, R = 7.5 * c.sz;\n    const ht = max(1, round((1 + 2.4 * f) * c.sz)), lean = round(gut + 0.3 * vn(t * 2, c.sd + 9));\n    // A warm light on whatever stands round it.\n    let st = S.stamps[c.sz];\n    if (!st) {\n      st = S.stamps[c.sz] = [];\n      for (let j = -floor(R); j \u003c= R; j++)\n        for (let i = -floor(R); i \u003c= R; i++) {\n          const r = sqrt(i * i + j * j * 1.4) / c.sz;\n          if (r \u003c 7.5) st.push(i, j, r \u003c 3 ? 0.3 : r \u003c 5.5 ? 0.17 : 0.08);\n        }\n    }\n    for (let q = 0; q \u003c st.length; q += 3) put(buf, c.x + st[q], top - 1 + st[q + 1], 255, 214, 120, f * st[q + 2]);\n    for (let j = 0; j \u003c ht; j++) {\n      const e = j / ht, x = c.x + round(lean * e);\n      if (j === 0) put(buf, x, top - j, 255, 244, 190, min(1, f + 0.3));\n      else put(buf, x, top - j, 255, 186 - 60 * e, 50, min(1, f));\n    }\n    if (c.f > 1.05) put(buf, c.x, top - ht, 255, 255, 230, 1);\n  }\n  for (const m of S.smoke) if (m.a >= 0) put(buf, m.x, m.y, 110, 104, 120, 0.6 * (1 - m.a / 1.6));\n\n  // The reaper: its robe by rows, then the arm and the sleeve hanging under it.\n  const bx = S.bx, by = S.by, phi = S.phi, ux = -sin(phi), uy = -cos(phi);\n  // The hand goes forward and down with the stroke and up for the wind-up.\n  const sg = (phi - REST) / (END - REST), gx = -12 - 4 * max(0, sg) + 3 * min(0, sg), gy = 8 + 4 * max(0, sg) + 6 * min(0, sg);\n  const y0 = max(0, floor(by - 23)), y1 = min(H - 1, floor(by + 66));\n  mask.fill(0, y0 * W, (y1 + 1) * W);\n  for (let y = y0; y \u003c= y1; y++) {\n    const n = spans(y + 0.5 - by, t);\n    for (let i = 0; i \u003c n; i++)\n      for (let x = max(0, ceil(bx + SP[2 * i] - 0.5)); x \u003c= min(W - 1, floor(bx + SP[2 * i + 1] - 0.5)); x++) mask[y * W + x] = 1;\n    if (FACE[1] > FACE[0])\n      for (let x = max(0, ceil(bx + FACE[0] - 0.5)); x \u003c= min(W - 1, floor(bx + FACE[1] - 0.5)); x++) mask[y * W + x] = 2;\n  }\n  capsule(mask, bx, by, -2, -1, gx + 1.5, gy - 0.5, 3.3, 2.5);\n  capsule(mask, bx, by, (gx - 2) * 0.55 + 1, gy * 0.55 + 1, gx + 3, gy + 6, 2.6, 1.2);\n  const robeC = [22, 15, 32], x0 = max(0, floor(bx - 24)), x1 = min(W - 1, ceil(bx + 36));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const p = y * W + x, m = mask[p];\n      if (!m) continue;\n      const o = p * 3;\n      if (m === 2) {\n        buf[o] = buf[o + 1] = buf[o + 2] = 0;\n        continue;\n      }\n      // Cloth, with a rim of the light behind it along its outline.\n      const edge = (x > 0 && !mask[p - 1]) || (x \u003c W - 1 && !mask[p + 1]) || (y > 0 && !mask[p - W]) || (y \u003c H - 1 && !mask[p + W]);\n      const a = edge ? 0.3 : 0;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = robeC[c] + (bg[o + c] - robeC[c]) * a;\n    }\n  // Shreds of cloth blowing off the hem, two LEDs wide, then one, then gone.\n  for (const m of S.shreds) {\n    const a = m.a \u003c 0.7 ? 0.9 : 0.9 * (1 - (m.a - 0.7) / 0.4);\n    put(buf, m.x - 0.5, m.y - 0.5, 22, 15, 32, a);\n    if (m.a \u003c 0.5) put(buf, m.x + 0.5, m.y - 0.5, 22, 15, 32, a);\n    if (m.a \u003c 0.25) put(buf, m.x - 0.5, m.y + 0.5, 22, 15, 32, a);\n  }\n  // The snath, dark wood.\n  const hx = bx + gx, hy = by + gy, tx = hx + ux * UP, ty = hy + uy * UP;\n  for (let s = -LO; s \u003c= UP; s += 0.4) put(buf, hx + ux * s - 0.5, hy + uy * s - 0.5, 34, 22, 16, 1);\n  // The blade: steel along its back, a bright edge on the inside of the curve.\n  const nx = cos(phi), ny = -sin(phi);\n  // A point s along the blade, f LEDs in from its back, into BP.\n  const bladeAt = (s, f) => {\n    BP[0] = tx + nx * BL * s - ux * CURL * BL * s * s - ux * f;\n    BP[1] = ty + ny * BL * s - uy * CURL * BL * s * s - uy * f;\n  };\n  for (let s = 0; s \u003c= 1; s += 0.025) {\n    bladeAt(s, 0);\n    put(buf, BP[0] - 0.5, BP[1] - 0.5, 120, 128, 146, 1);\n    if (s \u003c 0.88) {\n      bladeAt(s, 1);\n      put(buf, BP[0] - 0.5, BP[1] - 0.5, 196, 210, 228, 1);\n    }\n  }\n  // A sweep of pale light behind the outer half of the blade during the stroke.\n  if (S.sw === \"strike\" || (S.sw === \"follow\" && S.st \u003c 0.12)) {\n    const span = S.sw === \"strike\" ? min(1.6, (S.phi - BACK) * 0.9) : 1.2 * (1 - S.st / 0.12);\n    for (let a = 0.04; a \u003c span; a += 0.025) {\n      const q = phi - a, qx = -sin(q), qy = -cos(q), mx = cos(q), my = -sin(q);\n      for (const b of ALONG) {\n        const ex = hx + qx * UP + mx * BL * b - qx * CURL * BL * b * b, ey = hy + qy * UP + my * BL * b - qy * CURL * BL * b * b;\n        put(buf, ex - 0.5, ey - 0.5, 210, 255, 220, 0.6 * (1 - a / span));\n      }\n    }\n  }\n  // The glint, running along the edge, with a small star at its brightest.\n  if (S.glint >= 0 && S.glint \u003c= 1) {\n    bladeAt(S.glint, 1);\n    const gx2 = BP[0] - 0.5, gy2 = BP[1] - 0.5, b = sin(S.glint * PI);\n    put(buf, gx2, gy2, 255, 255, 255, 1);\n    for (let k = 0; k \u003c 8; k += 2) put(buf, gx2 + NB4[k], gy2 + NB4[k + 1], 255, 255, 255, 0.7 * b);\n    if (b > 0.8) for (let k = 0; k \u003c 8; k += 2) put(buf, gx2 + 2 * NB4[k], gy2 + 2 * NB4[k + 1], 255, 255, 255, 0.5);\n  }\n  // The bony hand on the snath.\n  put(buf, hx - 0.5, hy - 0.5, 206, 196, 172, 1);\n  put(buf, hx - 1.5, hy - 0.5, 176, 166, 146, 1);\n  put(buf, hx - 0.5, hy + 0.5, 176, 166, 146, 1);\n  // Two points of toxic green in the hood, flaring with the stroke.\n  const eye = hsv(0.3 + hs, 0.7, 1, S.e), flare = S.sw === \"strike\" || S.sw === \"follow\" ? 1 : 0.75 + 0.25 * vn(t * 6, 3);\n  for (const ex of [-4.6, -1.5]) {\n    const x = bx + ex, y = by - 10.5;\n    put(buf, x - 0.5, y - 0.5, eye[0], eye[1], eye[2], flare);\n    for (let k = 0; k \u003c 8; k += 2) put(buf, x - 0.5 + NB4[k], y - 0.5 + NB4[k + 1], eye[0], eye[1], eye[2], 0.28 * flare);\n  }\n\n  // Fog over the ground, rolling slowly to the right: one noise across the\n  // panel and another for each band of eight rows.\n  if (S.fog > 0) {\n    const fc = hsv(0.76 + hs, 0.22, 0.6, S.c), topY = 108 - 40 * S.fog, a0 = 0.18 + 0.4 * S.fog, FN = S.fn;\n    for (let x = 0; x \u003c W; x++) FN[x] = vn(x * 0.08 - t * 0.9, 41);\n    for (let y = max(0, floor(topY)); y \u003c H; y++) {\n      const ramp = min(1, (y - topY) / 14), band = y >> 3;\n      if ((y & 7) === 0 || y === floor(topY)) for (let x = 0; x \u003c W; x++) FN[W + x] = 0.6 * vn(x * 0.19 - t * 1.6, 43 + band);\n      for (let x = 0; x \u003c W; x++) {\n        const a = a0 * ramp * cl(0.55 + 0.5 * (FN[x] + FN[W + x]), 0, 1);\n        if (a \u003c 0.03) continue;\n        const o = (y * W + x) * 3, q = round(a * 8) / 8;\n        for (let c = 0; c \u003c 3; c++) buf[o + c] += (fc[c] - buf[o + c]) * q;\n      }\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n}\n","headless-rider":"// ===== Patternflow pattern =====\n// Title:   Headless Rider\n// Family:  halloween\n// Idea:    A headless horseman gallops across a huge low moon in black silhouette, the horse gathering and reaching through a four-beat gallop that kicks dust and sparks off the road, cape streaming and a burning jack-o'-lantern held high, while trees, gravestones and a fence slide past, and now and then he hurls the pumpkin in a flaming arc that bursts on the road ahead.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Woods=0..1, Mist=0..1\n//\n// Knob 1: Hue. Tints the sky, the far hills and the mist; moon, pumpkin and fire keep their colours. At 0 a violet night, mauve at the horizon; at 0.25 blood red, at 0.5 a sickly olive, at 0.75 teal, at 0.9 deep blue.\n// Knob 2: Speed. At 2 the horse takes 1.3 strides a second, the road runs past at 44 LEDs a second, the trees at 13 and the hills at 4, and he throws every 9 s, the first at 3.2 s, the pumpkin 3 s in the air; at 0.2 all ten times slower, at 3 half as fast again.\n// Knob 3: Woods. How many of the 14-LED slots along the horizon hold a tree: one in five at 0, a tree about every 5 s at Speed 2 with gravestones between; more than half at 0.5; nearly all at 1, a wood the moon shows through in pieces.\n// Knob 4: Mist. At 0 none, at 0.06 thin wisps on the horizon, at 0.5 a moonlit bank on the road round the hooves drifting back faster than the road, at 1 up to the horse's belly so the legs gallop half seen.\n// Buttons: K1 tap throws the pumpkin at once, or lights a new one if his hand is empty.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The stage, top to bottom: sky and moon, the horizon the trees stand on,\n// the road the hooves strike at GY, the verge with the near fence.\nconst HZ = 99, RD0 = 100, RD1 = 108, GY = 104;\nconst MX = 26, MY = 70, MR = 24;\n// The moon's tone (1 limb, 2 sea, 3 bright) and its glow in stepped rings.\nconst MOONT = new Uint8Array(N), GLOW = new Float32Array(N);\nconst SEAS = [[-7, -6, 6, 5], [5, -9, 5, 4], [-3, 6, 8, 4], [9, 5, 4, 5]];\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR) MOONT[p] = r > MR - 1.2 ? 1 : SEAS.some(([cx, cy, rx, ry]) => ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 \u003c 1) ? 2 : 3;\n  else GLOW[p] = r \u003c MR + 3 ? 0.3 : r \u003c MR + 8 ? 0.17 : r \u003c MR + 15 ? 0.08 : r \u003c MR + 26 ? 0.035 : 0;\n}\nconst MOONC = [0, [232, 216, 180], [228, 216, 188], [252, 240, 204]];\nconst STARS = [];\nfor (let i = 0; i \u003c 400 && STARS.length \u003c 26; i++) {\n  const x = floor(hash(i * 3 + 1) * W), y = floor(hash(i * 3 + 2) * 62);\n  if (GLOW[y * W + x] === 0 && !MOONT[y * W + x]) STARS.push([x, y, hash(i * 3 + 3) * TAU]);\n}\n\n// A seeded sequence for the scenery, so it is the same every time.\nlet sd = 48;\nconst rng = () => hash(sd++ * 31);\n// Fills a capsule, radius r0 at one end and r1 at the other, into a mask.\nfunction stamp(m, mw, mh, x0, y0, r0, x1, y1, r1, code) {\n  const xa = max(0, floor(min(x0 - r0, x1 - r1))), xb = min(mw - 1, ceil(max(x0 + r0, x1 + r1)));\n  const ya = max(0, floor(min(y0 - r0, y1 - r1))), yb = min(mh - 1, ceil(max(y0 + r0, y1 + r1)));\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy || 1e-9;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / l2, 0, 1);\n      const ex = px - dx * t, ey = py - dy * t, r = r0 + (r1 - r0) * t;\n      if (ex * ex + ey * ey \u003c= r * r && m[y * mw + x] \u003c code) m[y * mw + x] = code;\n    }\n}\n// Bare trees: a crooked trunk forking four times into twigs.\nconst TW = 44, TH = 96, NT = 6, TREES = [];\nfunction limb(m, x, y, a, len, w, depth) {\n  for (let i = 0, n = max(2, ceil(len / 2)); i \u003c n; i++) {\n    a += (rng() - 0.5) * 0.4;\n    const nx = x + 2 * sin(a), ny = y - 2 * cos(a), r = max(0.45, w * (1 - (0.35 * i) / n));\n    stamp(m, TW, TH, x, y, r, nx, ny, r, 1);\n    (x = nx), (y = ny);\n  }\n  if (depth \u003c= 0) return;\n  const k = depth > 2 ? 2 : 2 + (rng() \u003c 0.5 ? 1 : 0);\n  for (let j = 0; j \u003c k; j++) limb(m, x, y, a + (j - (k - 1) / 2) * (0.55 + rng() * 0.5) + (rng() - 0.5) * 0.3, len * (0.55 + rng() * 0.25), w * 0.62, depth - 1);\n}\n// Each kept as the list of its lit LEDs, column then row.\nfor (let i = 0; i \u003c NT; i++) {\n  const m = new Uint8Array(TW * TH), l = [];\n  limb(m, TW / 2, TH - 1, (rng() - 0.5) * 0.25, (54 + rng() * 34) * 0.36, 2.2 + rng() * 0.6, 4);\n  m.forEach((v, p) => v && l.push(p % TW, floor(p / TW)));\n  TREES.push(Int16Array.from(l));\n}\nconst TREEC = [26, 10, 36], FARLEG = [30, 12, 40];\n// The road's crown, ruts and dust; the verge's tufts and soil.\nconst GROUND = [92, 78, 108, 44, 34, 58, 66, 54, 82, 46, 30, 60, 24, 12, 34, 16, 8, 24];\nconst STONES = [[\".xxx.\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\"], [\"..x..\", \"xxxxx\", \"..x..\", \"..x..\", \"..x..\", \"..x..\"], [\".xx.\", \"xxxx\", \"xxxx\", \"xxxx\", \"xxxx\"]];\n// Mist: a sheet of value noise, long bands across short ones.\nconst FW = 256, FH = 32, FN = new Float32Array(FW * FH);\nfor (let p = 0; p \u003c FW * FH; p++) FN[p] = 0.5 + 0.32 * vn((p % FW) / 14 + (p >> 10) * 0.3, p >> 10) + 0.18 * vn((p % FW) / 5, (p >> 8) + 99);\n\n// The gallop. A hoof is down for DUTY of a stride, landing REACH LEDs ahead\n// of its leg's top joint and leaving BACK behind, so the road runs back\n// (REACH + BACK) / DUTY = 34 LEDs a stride and a planted hoof never slides.\n// A transverse gallop's four beats: near hind, far hind, near fore, far\n// fore, then all four off the ground, gathered under the belly.\n// [joint x, joint y in the body, landing phase, far, fore]\nconst DUTY = 0.38, REACH = 7, BACK = 6, STRIDE = (REACH + BACK) / DUTY, L1 = 11, L2 = 14, RATE = 1.3;\nconst LEGS = [[-10, 2.5, 0, 0, 0], [-10, 2.5, 0.11, 1, 0], [10, 3, 0.38, 0, 1], [10, 3, 0.49, 1, 1]];\nconst BX = 29, BY = 76, PK = 4.6;\n// The throwing arm [shoulder, elbow], radians from straight up, forward\n// positive: held high, cocked back, the release, hanging empty.\nconst HOLD = [0.35, 0.1], COCK = [-0.85, -0.5], LET = [1.05, 0.15], REST = [2.3, -0.5];\n// Times in seconds at Speed 2.\nconst THROW_EVERY = 9, FIRST = 3.2, T_COCK = 0.35, T_SWING = 0.15, T_RELIGHT = 1.5, T_GROW = 0.55;\n// Particles, six numbers each (x, y, vx, vy, life left, life) and a kind:\n// 0 flame, 1 spark, 2 dust.\nconst MAXP = 600;\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, hue0: -2, speed: 2, woods: 0, mist: 0.06, t: 0, ph: 0, g: 0, bob: 0, pitch: 0, neck: 0, eye: [0, 0],\n    state: 0, st: 0, next: FIRST, pk: 1, arm: HOLD.slice(), arm0: HOLD.slice(), fly: null, fires: [],\n    A: new Float32Array(MAXP * 6), K: new Uint8Array(MAXP), np: 0,\n    buf: new Float32Array(N * 3), mask: new Uint8Array(N), bg: new Float32Array(N * 3), far: [0, 0, 0], fog: [0, 0, 0], c: [0, 0, 0],\n  };\n}\n\nfunction spawn(S, x, y, vx, vy, life, kind) {\n  if (S.np >= MAXP) return;\n  S.A.set([x, y, vx, vy, life, life], S.np * 6);\n  S.K[S.np++] = kind;\n}\n\n// A point of the horse's body on the panel, bobbing and pitching about\n// the middle of the barrel.\nfunction bodyPt(S, x, y, out, o) {\n  const c = cos(S.pitch), s = sin(S.pitch);\n  out[o] = BX + x * c - y * s;\n  out[o + 1] = BY + S.bob + x * s + y * c;\n}\nconst P = new Float32Array(4), HAND = new Float32Array(6), F = new Float32Array(2);\n\n// Shoulder, elbow and hand of the throwing arm.\nfunction hand(S) {\n  bodyPt(S, 4, -20, HAND, 0);\n  const a = S.arm[0] + S.pitch * 0.5, b = a + S.arm[1];\n  HAND[2] = HAND[0] + 7.5 * sin(a);\n  HAND[3] = HAND[1] - 7.5 * cos(a);\n  HAND[4] = HAND[2] + 7.5 * sin(b);\n  HAND[5] = HAND[3] - 7.5 * cos(b);\n}\n\n// A hoof at phase u after it landed, from its leg's top joint (jx, jy).\nfunction foot(u, fore, jx) {\n  if (u \u003c DUTY) (F[0] = jx + REACH - (REACH + BACK) * (u / DUTY)), (F[1] = GY);\n  else {\n    const s = (u - DUTY) / (1 - DUTY);\n    F[0] = jx - BACK + (REACH + BACK) * (0.5 - 0.5 * cos(PI * s));\n    // A foreleg folds its hoof up towards the elbow, a hind leg less.\n    F[1] = GY - (fore ? 13 : 9) * sin(PI * s) ** 0.8;\n  }\n}\n\nconst ease = (a, b, t) => a + (b - a) * (t * t * (3 - 2 * t));\nconst toward = (S, to, t) => (S.arm = [ease(S.arm0[0], to[0], t), ease(S.arm0[1], to[1], t)]);\nconst go = (S, st) => ((S.state = st), (S.st = 0), (S.arm0 = S.arm.slice()));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.woods, S.mist] = [cl(k[0], 0, 1), cl(k[1], 0.2, 3), cl(k[2], 0, 1), cl(k[3], 0, 1)];\n  const ds = (d * S.speed) / 2, V = STRIDE * RATE, ph0 = S.ph;\n  S.t += ds;\n  S.ph += ds * RATE;\n  S.g = S.ph * STRIDE;\n  // The body: lowest mid-stance, highest in the gathered moment, nose up as\n  // the hind legs land and down as the fore legs take the weight.\n  const a = TAU * S.ph;\n  S.bob = 1.2 * cos(a - TAU * 0.45);\n  S.pitch = -0.055 * cos(a - TAU * 0.1);\n  S.neck = 0.13 * cos(a - TAU * 0.62);\n  // A hoof landing kicks up dust, and now and then sparks off a stone.\n  for (const [jx, jy, off] of LEGS) {\n    if (floor(ph0 - off) === floor(S.ph - off)) continue;\n    bodyPt(S, jx, jy, P, 0);\n    foot(0, 0, P[0]);\n    for (let i = 0; i \u003c 3; i++) spawn(S, F[0] + rnd(-1, 1), GY + rnd(-1, 1), -V * rnd(0.8, 1), -rnd(4, 14), rnd(0.5, 0.9), 2);\n    if (Math.random() \u003c 0.4) for (let i = 0; i \u003c 3; i++) spawn(S, F[0], GY - 1, -V + rnd(-20, 25), -rnd(20, 48), rnd(0.25, 0.5), 1);\n  }\n  // The pumpkin: held, cocked back, swung, let go; the hand hangs empty,\n  // rises, and a new one catches light in it.\n  const tap = input.btnPressed && input.btnPressed[0];\n  S.st += ds;\n  if (S.state === 0) {\n    if ((S.next -= ds) \u003c= 0 || tap) go(S, 1);\n  } else if (S.state === 1) {\n    toward(S, COCK, min(1, S.st / T_COCK));\n    if (S.st >= T_COCK) go(S, 2);\n  } else if (S.state === 2) {\n    toward(S, LET, min(1, S.st / T_SWING));\n    if (S.st >= T_SWING) {\n      hand(S);\n      // Up and a little ahead: the top of the arc near the top of the panel,\n      // down on the road just ahead of the horse 3 s later.\n      S.fly = { x: HAND[4] + 0.5, y: HAND[5] - PK, vx: 6.5, vy: -58, spin: 0 };\n      S.pk = 0;\n      go(S, 3);\n    }\n  } else if (S.state === 3) {\n    toward(S, REST, min(1, S.st / 0.45));\n    if (S.st > T_RELIGHT || tap) go(S, 4);\n  } else {\n    toward(S, HOLD, min(1, S.st / 0.4));\n    S.pk = cl((S.st - 0.3) / T_GROW, 0, 1);\n    if (S.st > 0.3 + T_GROW) (S.state = 0), (S.next = THROW_EVERY);\n  }\n  // Flames stream back off the pumpkin in the rush of air.\n  const drift = -0.45 * V - 12;\n  if (S.pk > 0 || S.state === 4) {\n    hand(S);\n    const r = PK * S.pk;\n    for (let i = 0; i \u003c 1 + S.pk * 3; i++) spawn(S, HAND[4] + rnd(-r, r) * 0.6, HAND[5] - 2 * r + rnd(-1, 1), drift * rnd(0.6, 1.1), -rnd(11, 23), rnd(0.15, 0.32), 0);\n  }\n  if (S.fly) {\n    const f = S.fly;\n    f.vy += 52 * ds;\n    f.x += f.vx * ds;\n    f.y += f.vy * ds;\n    f.spin += ds * 5;\n    for (let i = 0; i \u003c 4; i++) spawn(S, f.x + rnd(-2, 2), f.y + rnd(-2, 2), drift * rnd(0.7, 1.2) - V * 0.3, rnd(-14, 4), rnd(0.25, 0.55), 0);\n    if (f.y >= GY - 3) {\n      // It bursts on the road, which carries the fire back past the horse.\n      S.fires.push({ x: f.x, t: 0 });\n      for (let i = 0; i \u003c 18; i++) spawn(S, f.x, GY - 2, -V + rnd(-40, 40), -rnd(15, 60), rnd(0.4, 0.9), 1);\n      S.fly = null;\n    }\n  }\n  S.fires = S.fires.filter((fi) => {\n    fi.x -= V * ds;\n    fi.t += ds;\n    if (fi.t \u003c 1.6) for (let i = 0; i \u003c 3; i++) spawn(S, fi.x + rnd(-3, 3), GY - 1, -V + drift * 0.3, -rnd(15, 35), rnd(0.2, 0.45), 0);\n    return fi.x > -10;\n  });\n  // Particles: flames rise and thin, sparks fall and bounce, dust settles.\n  const A = S.A;\n  let j = 0;\n  for (let i = 0; i \u003c S.np; i++) {\n    const o = i * 6, kind = S.K[i];\n    if ((A[o + 4] -= ds) \u003c= 0) continue;\n    if (kind === 1) A[o + 3] += 140 * ds;\n    else if (kind === 2) A[o + 3] *= 1 - ds * 2;\n    A[o] += A[o + 2] * ds;\n    A[o + 1] += A[o + 3] * ds;\n    if (kind === 1 && A[o + 1] > GY + 1) (A[o + 1] = GY + 1), (A[o + 3] *= -0.3), (A[o + 2] = -V);\n    if (A[o] \u003c -4 || A[o] > W + 6 || A[o + 1] \u003c -4) continue;\n    if (j !== i) A.copyWithin(j * 6, o, o + 6), (S.K[j] = kind);\n    j++;\n  }\n  S.np = j;\n}\n\n// The sky with the moon and its glow, the far hills and the mist for a\n// hue, once each time it changes.\nfunction palette(S) {\n  const h = 0.75 + S.hue, c = S.c;\n  for (let p = 0; p \u003c (HZ + 1) * W; p++) {\n    const y = floor(p / W), t = min(1, floor((y / HZ) * 10) / 9), gl = GLOW[p];\n    if (MOONT[p]) S.bg.set(MOONC[MOONT[p]], p * 3);\n    else hsv(h - 0.04 * t, 0.8 - 0.25 * t, 0.12 + 0.3 * t, c), S.bg.set([c[0] + 240 * gl, c[1] + 220 * gl, c[2] + 190 * gl], p * 3);\n  }\n  hsv(h - 0.02, 0.55, 0.26, S.far);\n  hsv(h - 0.05, 0.3, 0.8, S.fog);\n}\n\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\n// Horse and rider into the mask: 2 black, 1 the far legs, a shade lighter.\nfunction figure(S, m) {\n  m.fill(0);\n  const cap = (x0, y0, r0, x1, y1, r1, code = 2) => stamp(m, W, H, x0, y0, r0, x1, y1, r1, code);\n  const bc = (x0, y0, r0, x1, y1, r1) => {\n    bodyPt(S, x0, y0, P, 0);\n    bodyPt(S, x1, y1, P, 2);\n    cap(P[0], P[1], r0, P[2], P[3], r1);\n  };\n  // Legs, far ones first, two bones each: forearm and cannon in front, the\n  // knee bending forward; gaskin and cannon behind, the hock bending back.\n  for (const [jx, jy, off, far, fore] of LEGS) {\n    bodyPt(S, jx, jy, P, 0);\n    const x0 = P[0], y0 = P[1];\n    foot(S.ph - off - floor(S.ph - off), fore, x0);\n    let dx = F[0] - x0, dy = F[1] - y0;\n    const dd = sqrt(dx * dx + dy * dy), dm = min(L1 + L2 - 0.05, max(abs(L1 - L2) + 0.5, dd));\n    (dx /= dd), (dy /= dd);\n    const fx = x0 + dx * dm, fy = y0 + dy * dm, ca = (L1 * L1 + dm * dm - L2 * L2) / (2 * L1 * dm), sa = sqrt(max(0, 1 - ca * ca)), sg = fore ? -1 : 1;\n    const kx = x0 + L1 * (dx * ca - sg * dy * sa), ky = y0 + L1 * (dy * ca + sg * dx * sa), code = far ? 1 : 2;\n    cap(x0, y0, fore ? 2.6 : 3.2, kx, ky, 1.4, code);\n    cap(kx, ky, 1.2, fx, fy, 0.9, code);\n    cap(fx, fy - 0.5, 1.3, fx + 0.8, fy, 1.2, code);\n  }\n  // The tail streaming back.\n  let tx = -14, ty = -4;\n  for (let i = 1; i \u003c= 6; i++) {\n    const nx = -14 - 2.3 * i, ny = -4 + 0.75 * i + sin(S.t * 9 - i * 0.9) * i * 0.2;\n    bc(tx, ty, 2.4 - 0.25 * i, nx, ny, 2.2 - 0.25 * i);\n    (tx = nx), (ty = ny);\n  }\n  // Barrel, chest, quarters and withers.\n  bc(-9, -0.5, 6, 8, 0, 6);\n  bc(10, -1, 6.2, 10, -1, 6.2);\n  bc(-10, -2, 6.6, -10, -2, 6.6);\n  bc(6, -6, 2.6, 8, -6, 2.6);\n  // Neck and head nod with the stride; the mane flies back.\n  const nc = cos(S.neck), ns = sin(S.neck), nk = (x, y) => [11 + (x - 11) * nc - (y + 2) * ns, -2 + (x - 11) * ns + (y + 2) * nc];\n  const [n1x, n1y] = nk(18, -12), [h1x, h1y] = nk(25, -5), [e1x, e1y] = nk(17, -16);\n  S.eye = nk(20, -10.5);\n  bc(11, -2, 5, n1x, n1y, 3);\n  bc(n1x, n1y, 2.9, h1x, h1y, 1.7);\n  bc(n1x - 0.5, n1y - 1, 0.8, e1x, e1y, 0.5);\n  for (let i = 0; i \u003c 5; i++) {\n    const [mx, my] = nk(11.5 + i * 1.4, -6.5 - i * 1.4);\n    bc(mx, my, 0.7, mx - 3.5, my + 0.5 + sin(S.t * 11 + i) * 0.8, 0.4);\n  }\n  // The rider: seat, a torso leaning into the gallop, broad shoulders, no head.\n  bc(-1, -8, 3.3, 3, -20, 3.8);\n  bc(0, -20.5, 2.5, 5.5, -20, 2.3);\n  bc(2, -22.8, 1.1, 3.6, -22.6, 1.1);\n  bc(-1, -7, 2.2, 5, -3, 1.8);\n  bc(5, -3, 1.4, 4.2, 4, 1.2);\n  bc(4.2, 4, 1.4, 6, 4.4, 1.1);\n  // The rein arm, and the reins to the bit.\n  bc(4, -19, 1.5, 7.5, -13, 1.3);\n  bc(7.5, -13, 1.3, 11.5, -10.5, 1.1);\n  bodyPt(S, 11.5, -10.5, P, 0);\n  bodyPt(S, h1x - 1, h1y + 0.5, P, 2);\n  cap(P[0], P[1], 0.45, P[2], P[3], 0.45);\n  hand(S);\n  cap(HAND[0], HAND[1], 1.6, HAND[2], HAND[3], 1.3);\n  cap(HAND[2], HAND[3], 1.3, HAND[4], HAND[5], 1.1);\n  // The cape, from the shoulders back on the wind, rippling, ragged at the hem.\n  bodyPt(S, 2, -20, P, 0);\n  const ax = P[0], ay = P[1], len = 27;\n  for (let x = floor(ax); x >= max(0, ax - len); x--) {\n    const t = (ax - x) / len, cy = ay + 4.5 * t * t + 1.5 * t + sin(TAU * (t * 1.2 - S.t * 1.7)) * 2.1 * t;\n    let hw = 1.3 + 5 * t;\n    if (t > 0.8) hw -= hash(x * 7 + floor(S.t * 6)) * 15 * (t - 0.8);\n    for (let y = max(0, round(cy - hw)); y \u003c= min(H - 1, round(cy + hw * 0.9)); y++) m[y * W + x] = 2;\n  }\n}\n\nconst RIBS = [[255, 168, 40], [255, 128, 16], [226, 92, 8]];\nfunction pumpkin(S, buf, cx, cy, k, sp) {\n  const r = PK * k;\n  if (r \u003c 0.6) return;\n  const fl = 0.78 + 0.22 * (0.5 + 0.5 * vn(S.t * 11, 3)) * (0.7 + 0.3 * vn(S.t * 3, 9));\n  // A glow round it, in steps.\n  for (let y = floor(cy - r - 9); y \u003c= cy + r + 9; y++)\n    for (let x = floor(cx - r - 9); x \u003c= cx + r + 9; x++) {\n      const e = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2) - r;\n      if (e > 0 && e \u003c 9) put(buf, x, y, 255, 120, 20, (e \u003c 2 ? 0.34 : e \u003c 5 ? 0.18 : 0.07) * fl);\n    }\n  for (let y = floor(cy - r - 1); y \u003c= cy + r; y++)\n    for (let x = floor(cx - r * 1.15 - 1); x \u003c= cx + r * 1.15; x++) {\n      const u = (x + 0.5 - cx) / (r * 1.15), v = (y + 0.5 - cy) / r;\n      if (u * u + v * v > 1) continue;\n      // Ribs in three bright tones, and the carved face lit from inside.\n      const rib = abs(sin((u + sp) * 4.2)), fu = u / 0.9;\n      const eye = v > -0.5 && v \u003c -0.05 && abs(abs(fu) - 0.42) \u003c (0.3 * (v + 0.55)) / 0.5;\n      const mouth = v > 0.2 && v \u003c 0.62 && abs(fu) \u003c 0.62 - (v - 0.2) * 0.5 && !(v \u003c 0.4 && abs(fu) > 0.1 && abs(fu) \u003c 0.3);\n      if (k > 0.7 && (eye || mouth)) put(buf, x, y, 255 * fl, 236 * fl, 120 * fl, 1);\n      else {\n        const c = RIBS[rib > 0.75 ? 0 : rib > 0.3 ? 1 : 2];\n        put(buf, x, y, c[0], c[1], c[2], 1);\n      }\n    }\n  put(buf, cx - 0.5, cy - r - 1, 60, 170, 40, 1);\n}\n\n// Mist from row y0 to y1, drifting by sp: at most `a` of it, thickest at\n// row yc and thinning over wd rows either side.\nfunction mist(S, buf, y0, y1, yc, wd, a, sp, row) {\n  const fog = S.fog;\n  for (let y = max(0, y0); y \u003c min(H, y1); y++) {\n    const band = exp(-(((y - yc) / wd) ** 2)), fj = (y + row) % FH;\n    for (let x = 0; x \u003c W; x++) {\n      const n = FN[fj * FW + (((floor((x + sp) * 0.5) % FW) + FW) % FW)], v = band * cl((n - 0.2) * 1.8, 0, 1) * a;\n      if (v > 0.03) put(buf, x, y, fog[0], fog[1], fog[2], round(v * 12) / 12);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.hue !== S.hue0) (S.hue0 = S.hue), palette(S);\n  const buf = S.buf, far = S.far, g = S.g, A = S.A;\n  buf.set(S.bg);\n  for (const [x, y, ph] of STARS) {\n    const v = sin(S.t * 2.3 + ph) > 0.2 ? 200 : 110;\n    put(buf, x, y, v, v, v + 30, 1);\n  }\n  // Far hills, slow, with a ragged line of tiny trees.\n  for (let x = 0; x \u003c W; x++) {\n    const wx = x + g * 0.1, top = HZ - 5 - 3 * vn(wx / 17, 11) - 1.5 * vn(wx / 6, 12) - (hash(floor(wx / 3) * 5 + 1) \u003c 0.25 ? 3 : 0);\n    for (let y = round(top); y \u003c= HZ; y++) put(buf, x, y, far[0], far[1], far[2], 1);\n  }\n  // Trees and gravestones on the horizon, in slots of 14 LEDs.\n  const mo = g * 0.3, pT = 0.2 + 0.72 * S.woods;\n  for (let sl = floor((mo - TW) / 14); sl \u003c= floor((mo + W + TW) / 14); sl++) {\n    const sx = sl * 14 - mo + hash(sl * 3 + 3) * 6;\n    if (hash(sl * 3 + 1) \u003c pT) {\n      const l = TREES[floor(hash(sl * 3 + 2) * NT)], flip = hash(sl * 3 + 4) \u003c 0.5, x0 = round(sx - TW / 2);\n      for (let i = 0; i \u003c l.length; i += 2) {\n        const x = x0 + (flip ? TW - 1 - l[i] : l[i]), y = HZ + 1 - TH + l[i + 1];\n        if (x >= 0 && x \u003c W && y >= 0) buf.set(TREEC, (y * W + x) * 3);\n      }\n    } else if (hash(sl * 5 + 7) \u003c 0.55) {\n      const st = STONES[floor(hash(sl * 5 + 8) * 3)];\n      for (let j = 0; j \u003c st.length; j++)\n        for (let i = 0; i \u003c st[j].length; i++) if (st[j][i] === \"x\") put(buf, sx + i, HZ - st.length + 1 + j, j ? 52 : 104, j ? 42 : 92, j ? 68 : 124, 1);\n    }\n  }\n  // The road, its ruts running back, and the dark verge with grass tufts.\n  for (let y = RD0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const gx = floor(x + g * 1.15), o = (y * W + x) * 3;\n      const k = 3 * (y \u003c RD1 ? (y === RD0 ? 0 : (y === 102 || y === 105) && hash(floor(x + g) * 3 + y) \u003c 0.35 ? 1 : 2) : hash(gx * 13) \u003c 0.3 && y - RD1 \u003c 1 + floor(hash(gx * 7) * 4) ? 3 : y \u003c 116 ? 4 : 5);\n      (buf[o] = GROUND[k]), (buf[o + 1] = GROUND[k + 1]), (buf[o + 2] = GROUND[k + 2]);\n    }\n  // Wisps along the horizon, a little thicker with the mist.\n  mist(S, buf, 84, RD1, 99, 7, 0.25 + 0.45 * S.mist, g * 0.6, 0);\n  // Dust behind the figure.\n  for (let i = 0; i \u003c S.np; i++) if (S.K[i] === 2) put(buf, A[i * 6], A[i * 6 + 1], 140, 124, 160, (A[i * 6 + 4] / A[i * 6 + 5]) * 0.75);\n  // Horse and rider: black, rimmed with moonlight where they meet the moon.\n  const m = S.mask;\n  figure(S, m);\n  for (let p = 0; p \u003c N; p++) {\n    const c = m[p], o = p * 3;\n    if (!c) continue;\n    if (c === 1) {\n      buf.set(FARLEG, o);\n      continue;\n    }\n    // The brightest open neighbour lights the rim, if it is moonlight.\n    let q = -1, best = 300;\n    for (let s = 0; s \u003c 4; s++) {\n      const n = s === 0 ? p - 1 : s === 1 ? p + 1 : s === 2 ? p - W : p + W;\n      if (n >= 0 && n \u003c N && !m[n] && buf[n * 3] + buf[n * 3 + 1] > best) (best = buf[n * 3] + buf[n * 3 + 1]), (q = n * 3);\n    }\n    if (q \u003c 0) (buf[o] = 3), (buf[o + 1] = 1), (buf[o + 2] = 6);\n    else (buf[o] = buf[q] * 0.42), (buf[o + 1] = buf[q + 1] * 0.42), (buf[o + 2] = buf[q + 2] * 0.42);\n  }\n  // The horse's eye, a coal.\n  bodyPt(S, S.eye[0], S.eye[1], P, 0);\n  put(buf, P[0] - 0.5, P[1] - 0.5, 255, 110, 30, 1);\n  // The pumpkin in his hand, or in flight.\n  if (S.pk > 0) {\n    hand(S);\n    pumpkin(S, buf, HAND[4] + 0.5, HAND[5] - PK * S.pk + 0.5, S.pk, 0);\n  }\n  if (S.fly) pumpkin(S, buf, S.fly.x, S.fly.y, 1, S.fly.spin);\n  // Flames yellow to orange to red, sparks white-gold.\n  for (let i = 0; i \u003c S.np; i++) {\n    const o = i * 6, a = 1 - A[o + 4] / A[o + 5], kind = S.K[i];\n    if (kind === 0) {\n      if (a \u003c 0.3) put(buf, A[o], A[o + 1], 255, 236, 130, 1);\n      else if (a \u003c 0.65) put(buf, A[o], A[o + 1], 255, 146, 24, 1);\n      else put(buf, A[o], A[o + 1], 236, 64, 18, 1.4 - a);\n    } else if (kind === 1) put(buf, A[o], A[o + 1], 255, 226, 150, 1);\n  }\n  // Mist in front: up to the knees at half, the belly at 1, drifting back\n  // faster than the road.\n  if (S.mist > 0.1) mist(S, buf, 70, H, GY + 12 - 18 * S.mist, 5 + 12 * S.mist, 0.35 + 0.65 * S.mist, g * 1.3 + S.t * 8, 11);\n  // The near fence, fastest of all, moonlit on its left.\n  for (let x = 0; x \u003c W; x++) {\n    const px = (((x + g * 1.15) % 40) + 40) % 40;\n    if (px \u003c 3) for (let y = 109; y \u003c H; y++) put(buf, x, y, px \u003c 1 ? 92 : 54, px \u003c 1 ? 84 : 46, px \u003c 1 ? 110 : 68, 1);\n    else for (const y of [112, 119]) put(buf, x, y, 84, 74, 100, 1);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n}\n","mobius-energy":"// ===== Patternflow pattern =====\n// Title:   Möbius Energy\n// Family:  topology\n// Idea:    A knotted tube, crumpled by wringing the space around it, relaxes under the gradient flow of the Möbius energy, which blows up where strands approach, so it untangles only as far as its knot type allows: an unknot opens into a circle, a trefoil into its three-lobed shape, and a trace below logs the energy falling.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Möbius energy of knots (Jun O'Hara, 1991; Michael Freedman, Zheng-Xu He and Zhenghan Wang, 1994), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knot=0..4, Crumple=0..1\n//\n// Knob 1: Hue. The colour that walks along the tube. At 0 it runs from cyan through blue to violet and back round the loop; at 0.25 from violet through pink to orange, at 0.5 from red through yellow to green, at 0.75 from yellow-green to sky blue.\n// Knob 2: Speed. At 2 the flow takes 50 steps a second; a crumpled trefoil opens in 7 to 11 s, the unknot in 5 to 8 s, the others in 9 to 30 s, then the knot holds 2 s and crumples over 2.5 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Knot. 0 the trefoil 3_1, 1 the figure-eight 4_1, 2 the cinquefoil 5_1, 3 the three-twist knot 5_2, 4 the unknot. Turning it starts the new knot crumpled.\n// Knob 4: Crumple. How hard space is deformed before each relaxation: a stretch along one axis, a wring about it and two twists about axes through the knot. At 0.06 the stretch is 1.8 times, the wring 3.9 rad each way and the twists 3.2 rad; at 0.5 2.6 times, 6 and 5 rad; at 1 3.4 times, 8.4 and 7 rad. It stops if two strands come within half a bead spacing.\n// Buttons: K1 tap crumples the knot again now.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// A closed polygon of NB beads x_i. With l_i the mean of the two edges at\n// bead i and D(i, j) the shorter way round from i to j,\n//   E = sum over i != j of (1 / |x_i - x_j|^2 - 1 / D(i, j)^2) l_i l_j,\n// O'Hara's integral on the beads: blind to size, 4 on a round circle, its\n// least value (Freedman, He and Wang). The flow keeps each edge's length, so\n// l_i and D stay put and a step follows the exact gradient. Added: a barrier\n// between edges nearer than the mean edge, which beads cannot see cross, and\n// bending stiffness, as E is blind to inversions of space too and lets a\n// relaxed knot drift. A step is kept only if the sum went down.\nconst NB = 120, N3 = NB * 3;\n// The (2,3) and (2,5) torus knots, the figure-eight, the Lissajous knot 5_2\n// (frequencies 3, 2, 7, phases 0.7, 0.2, 0) and a bent circle.\nconst tor = (p, q, r) => (t) => [(2 + cos(q * t)) * cos(p * t), (2 + cos(q * t)) * sin(p * t), sin(r * t)];\nconst KNOTS = [tor(2, 3, 3), tor(3, 2, 4), tor(2, 5, 5), (t) => [cos(3 * t + 0.7), cos(2 * t + 0.2), cos(7 * t)], (t) => [cos(t), sin(t), 0.25 * sin(2 * t)]];\n// LEDs a unit and the tube's radius for each knot.\nconst ZOOM = [28, 22, 24, 15, 27], TUBE = [2.6, 2.3, 2.1, 1.8, 2.7];\n// Steps a second at Speed 2, a bead's largest move in one, crumple and hold s.\nconst SPS = 50, VCAP = 0.0055, CRT = 2.5, HOLD = 2;\n// Barrier weight; bending, BEND L times the integral of curvature squared\n// (7.9 on a circle: weaker, 4_1 and 5_2 pull a clasp tight by a big loop,\n// which E alone prices the same); the stretch at Crumple 0.\nconst BAR = 2, BEND = 0.2, STR = 1.7;\n// The knot's middle row; the trace's rows.\nconst KY = 50, TY0 = 100, TY1 = 124, TN = 64;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Fourier tables along the curve; mode k is smoothed by k^-2.5.\nconst KM = 32, CS = new Float64Array(NB * (KM + 1)), SN = new Float64Array(NB * (KM + 1)), PK = new Float64Array(KM + 1);\nfor (let k = 1; k \u003c= KM; k++) {\n  for (let i = 0; i \u003c NB; i++) (CS[k * NB + i] = cos((TAU * k * i) / NB)), (SN[k * NB + i] = sin((TAU * k * i) / NB));\n  PK[k] = 2 / (k * k * sqrt(k));\n}\n\nfunction centre(X) {\n  let a = 0, b = 0, c = 0;\n  for (let i = 0; i \u003c N3; i += 3) (a += X[i]), (b += X[i + 1]), (c += X[i + 2]);\n  (a /= NB), (b /= NB), (c /= NB);\n  for (let i = 0; i \u003c N3; i += 3) (X[i] -= a), (X[i + 1] -= b), (X[i + 2] -= c);\n}\n\n// Edge lengths into LE, running sums into CUM; returns the length.\nconst LE = new Float64Array(NB), CUM = new Float64Array(NB + 1);\nfunction lengths(X) {\n  for (let i = 0; i \u003c NB; i++) {\n    const o = i * 3, q = ((i + 1) % NB) * 3;\n    LE[i] = sqrt((X[q] - X[o]) ** 2 + (X[q + 1] - X[o + 1]) ** 2 + (X[q + 2] - X[o + 2]) ** 2);\n    CUM[i + 1] = CUM[i] + LE[i];\n  }\n  return CUM[NB];\n}\n\n// Knot k's beads, evened along it, centred, the furthest one unit out.\nfunction nice(k, X, Y) {\n  for (let i = 0; i \u003c NB; i++) X.set(KNOTS[k]((TAU * i) / NB), i * 3);\n  for (let g = 0; g \u003c 6; g++) resample(X, Y), X.set(Y);\n  centre(X);\n  let r = 0;\n  for (let i = 0; i \u003c N3; i += 3) r = max(r, X[i] ** 2 + X[i + 1] ** 2 + X[i + 2] ** 2);\n  for (let i = 0; i \u003c N3; i++) X[i] /= sqrt(r);\n}\n\n// Edges i and j: their distance, and in SD where along each the closest\n// points lie and the vector between them.\nconst SD = new Float64Array(5);\nfunction segd(X, i, j) {\n  const p = i * 3, pe = ((i + 1) % NB) * 3, r = j * 3, re = ((j + 1) % NB) * 3;\n  const d1x = X[pe] - X[p], d1y = X[pe + 1] - X[p + 1], d1z = X[pe + 2] - X[p + 2];\n  const d2x = X[re] - X[r], d2y = X[re + 1] - X[r + 1], d2z = X[re + 2] - X[r + 2];\n  const rx = X[p] - X[r], ry = X[p + 1] - X[r + 1], rz = X[p + 2] - X[r + 2];\n  const a = d1x * d1x + d1y * d1y + d1z * d1z, e = d2x * d2x + d2y * d2y + d2z * d2z, f = d2x * rx + d2y * ry + d2z * rz;\n  const c = d1x * rx + d1y * ry + d1z * rz, b = d1x * d2x + d1y * d2y + d1z * d2z, den = a * e - b * b;\n  let s = den > 1e-18 ? cl((b * f - c * e) / den, 0, 1) : 0, t = (b * s + f) / e;\n  if (t \u003c 0) (t = 0), (s = cl(-c / a, 0, 1));\n  else if (t > 1) (t = 1), (s = cl((b - c) / a, 0, 1));\n  const wx = rx + d1x * s - d2x * t, wy = ry + d1y * s - d2y * t, wz = rz + d1z * s - d2z * t;\n  (SD[0] = s), (SD[1] = t), (SD[2] = wx), (SD[3] = wy), (SD[4] = wz);\n  return sqrt(wx * wx + wy * wy + wz * wz);\n}\n\n// E, plus BAR (h / d - 1)^2 for edges sharing no bead d \u003c h apart (h the\n// mean edge), plus BEND L sum 2 (1 - cos a_i) / l_i over the turns a_i; with\n// G, the gradient for fixed edge lengths. DM is left the least distance\n// between edges sharing no bead, or h if that is more: beads further apart\n// than two longest edges and h have edges more than h apart.\nlet DM = 0;\nconst dmin = (X) => (energy(X, null), DM);\nfunction energy(X, G) {\n  const L = lengths(X), h = L / NB, near = (2 * max(...LE) + h) ** 2;\n  if (G) G.fill(0);\n  let E = 0, B = 0;\n  DM = h;\n  for (let i = 0; i \u003c NB; i++) {\n    const wi = (LE[(i + NB - 1) % NB] + LE[i]) / 2, xi = X[i * 3], yi = X[i * 3 + 1], zi = X[i * 3 + 2];\n    for (let j = i + 1; j \u003c NB; j++) {\n      const dx = xi - X[j * 3], dy = yi - X[j * 3 + 1], dz = zi - X[j * 3 + 2], r2 = dx * dx + dy * dy + dz * dz, wj = (LE[j - 1] + LE[j]) / 2;\n      let a = CUM[j] - CUM[i];\n      if (a > L - a) a = L - a;\n      E += (1 / r2 - 1 / (a * a)) * wi * wj;\n      if (j === i + 1 || (i === 0 && j === NB - 1)) continue;\n      if (G) {\n        const f = (-4 * wi * wj) / (r2 * r2);\n        (G[i * 3] += f * dx), (G[i * 3 + 1] += f * dy), (G[i * 3 + 2] += f * dz);\n        (G[j * 3] -= f * dx), (G[j * 3 + 1] -= f * dy), (G[j * 3 + 2] -= f * dz);\n      }\n      if (r2 > near) continue;\n      const d = segd(X, i, j);\n      if (d \u003c DM) DM = d;\n      if (d >= h) continue;\n      B += BAR * (h / d - 1) ** 2;\n      if (!G) continue;\n      const f = (-2 * BAR * (h / d - 1) * h) / (d * d * d), s = SD[0], t = SD[1], i1 = ((i + 1) % NB) * 3, j1 = ((j + 1) % NB) * 3;\n      for (let c = 0; c \u003c 3; c++) {\n        const w = f * SD[2 + c];\n        (G[i * 3 + c] += w * (1 - s)), (G[i1 + c] += w * s), (G[j * 3 + c] -= w * (1 - t)), (G[j1 + c] -= w * t);\n      }\n    }\n  }\n  for (let i = 0; i \u003c NB; i++) {\n    const i0 = (i + NB - 1) % NB, a = i0 * 3, o = i * 3, q = ((i + 1) % NB) * 3;\n    const l0 = LE[i0], l1 = LE[i], k = (BEND * L * 2) / (l0 + l1), u = 1 / (l0 * l1);\n    let dot = 0;\n    for (let c = 0; c \u003c 3; c++) dot += (X[o + c] - X[a + c]) * (X[q + c] - X[o + c]);\n    B += k * 2 * (1 - dot * u);\n    if (G)\n      for (let c = 0; c \u003c 3; c++) {\n        const p = X[o + c] - X[a + c], n = X[q + c] - X[o + c], g = -2 * k * u;\n        (G[a + c] -= g * n), (G[o + c] += g * (n - p)), (G[q + c] += g * p);\n      }\n  }\n  return 2 * E + B;\n}\n\n// Projects a motion V onto those keeping every edge's length: V less\n// J^T (J J^T)^-1 J V, J J^T cyclic tridiagonal, solved by Sherman-Morrison.\nconst UE = new Float64Array(N3), TA = new Float64Array(NB), TB = new Float64Array(NB), TR = new Float64Array(NB);\nconst TY = new Float64Array(NB), TZ = new Float64Array(NB), TW = new Float64Array(NB), TU = new Float64Array(NB);\nfunction thomas(d, o, r, x) {\n  TW[0] = d[0];\n  x[0] = r[0];\n  for (let i = 1, m; i \u003c NB; i++) (m = o[i - 1] / TW[i - 1]), (TW[i] = d[i] - m * o[i - 1]), (x[i] = r[i] - m * x[i - 1]);\n  x[NB - 1] /= TW[NB - 1];\n  for (let i = NB - 2; i >= 0; i--) x[i] = (x[i] - o[i] * x[i + 1]) / TW[i];\n}\nfunction tangent(X, V) {\n  for (let e = 0; e \u003c NB; e++) for (let c = 0, q = ((e + 1) % NB) * 3; c \u003c 3; c++) UE[e * 3 + c] = X[q + c] - X[e * 3 + c];\n  for (let e = 0; e \u003c NB; e++) {\n    const o = e * 3, q = ((e + 1) % NB) * 3;\n    TA[e] = 2 * (UE[o] ** 2 + UE[o + 1] ** 2 + UE[o + 2] ** 2);\n    TB[e] = -(UE[o] * UE[q] + UE[o + 1] * UE[q + 1] + UE[o + 2] * UE[q + 2]);\n    TR[e] = UE[o] * (V[q] - V[o]) + UE[o + 1] * (V[q + 1] - V[o + 1]) + UE[o + 2] * (V[q + 2] - V[o + 2]);\n  }\n  const g = -TA[0], bn = TB[NB - 1];\n  (TA[0] -= g), (TA[NB - 1] -= (bn * bn) / g), TU.fill(0), (TU[0] = g), (TU[NB - 1] = bn);\n  thomas(TA, TB, TR, TY);\n  thomas(TA, TB, TU, TZ);\n  const k = (TY[0] + (bn * TY[NB - 1]) / g) / (1 + TZ[0] + (bn * TZ[NB - 1]) / g);\n  for (let e = 0; e \u003c NB; e++) TY[e] -= k * TZ[e];\n  for (let i = 0; i \u003c NB; i++) {\n    const e0 = (i + NB - 1) % NB;\n    for (let c = 0; c \u003c 3; c++) V[i * 3 + c] -= TY[e0] * UE[e0 * 3 + c] - TY[i] * UE[i * 3 + c];\n  }\n}\n\n// Smooths G into D: modes up to 32 (the rest are under 1/5000), so long\n// bends move as fast as short ones (E's order is 3). Projected before and\n// after, the step still goes downhill.\nconst FA = new Float64Array(KM + 1), FB = new Float64Array(KM + 1);\nfunction smooth(G, D) {\n  D.fill(0);\n  for (let c = 0; c \u003c 3; c++) {\n    for (let k = 1; k \u003c= KM; k++) {\n      let a = 0, b = 0;\n      for (let i = 0, o = k * NB; i \u003c NB; i++) (a += G[i * 3 + c] * CS[o + i]), (b += G[i * 3 + c] * SN[o + i]);\n      (FA[k] = a * PK[k]), (FB[k] = b * PK[k]);\n    }\n    for (let k = 1; k \u003c= KM; k++) for (let i = 0, o = k * NB; i \u003c NB; i++) D[i * 3 + c] += FA[k] * CS[o + i] + FB[k] * SN[o + i];\n  }\n}\n\n// Puts each edge e back to length ell[e], to 1e-8.\nfunction edges(X, ell) {\n  for (let s = 0, worst = 1; s \u003c 40 && worst > 1e-8; s++) {\n    worst = 0;\n    for (let n = 0; n \u003c NB; n++) {\n      const i = s & 1 ? NB - 1 - n : n, o = i * 3, q = ((i + 1) % NB) * 3, h = ell[i];\n      const dx = X[q] - X[o], dy = X[q + 1] - X[o + 1], dz = X[q + 2] - X[o + 2], l = sqrt(dx * dx + dy * dy + dz * dz), f = (0.5 * (l - h)) / l;\n      worst = max(worst, abs(l - h) / h);\n      (X[o] += f * dx), (X[o + 1] += f * dy), (X[o + 2] += f * dz);\n      (X[q] -= f * dx), (X[q + 1] -= f * dy), (X[q + 2] -= f * dz);\n    }\n  }\n}\n\n// The rule that keeps the knot: beads move in straight lines from X to Y by\n// at most dm / 4, dm the least edge distance in X. No point of an edge moves\n// more than its beads, so edges sharing no bead stay dm / 2 apart all the\n// way: no strand passes through another. Returns the share of the move\n// allowed; with cut, Y is held to it.\nfunction guard(X, Y, cut, dm) {\n  let d = 0;\n  for (let i = 0; i \u003c N3; i += 3) d = max(d, (Y[i] - X[i]) ** 2 + (Y[i + 1] - X[i + 1]) ** 2 + (Y[i + 2] - X[i + 2]) ** 2);\n  d = sqrt(d);\n  if (d \u003c= 0.25 * dm) return 1;\n  const f = (0.25 * dm) / d;\n  if (cut) for (let i = 0; i \u003c N3; i++) Y[i] = X[i] + (Y[i] - X[i]) * f;\n  return f;\n}\n\n// Slides the beads along the polygon to even spacing, into Y.\nfunction resample(X, Y) {\n  const L = lengths(X), h = L / NB;\n  let s0 = 0;\n  for (let b = 0; b \u003c NB; b++) s0 += CUM[b] - b * h;\n  s0 /= NB;\n  for (let b = 0, lo = 0; b \u003c NB; b++) {\n    const s = (((s0 + b * h) % L) + L) % L;\n    if (s \u003c CUM[lo]) lo = 0;\n    while (lo \u003c NB - 1 && CUM[lo + 1] \u003c= s) lo++;\n    const u = (s - CUM[lo]) / LE[lo], o = lo * 3, q = ((lo + 1) % NB) * 3;\n    for (let c = 0; c \u003c 3; c++) Y[b * 3 + c] = X[o + c] + (X[q + c] - X[o + c]) * u;\n  }\n}\n\n// Evens the beads, guarded, until two edges would come within half an edge.\nfunction even(S, rounds, dX = dmin(S.X)) {\n  const X = S.X, Y = S.Y;\n  for (let g = 0; g \u003c rounds; g++) {\n    resample(X, Y);\n    guard(X, Y, true, dX);\n    const dY = dmin(Y);\n    if (dY \u003c (0.5 * lengths(Y)) / NB) break;\n    X.set(Y);\n    centre(X);\n    dX = dY;\n  }\n  return dX;\n}\n\n// The crumple: a stretch along an axis (volume kept), a wring about it and\n// two twists about axes through beads. A twist turns points round its axis\n// by an angle set by their distance from it and height along it, so the\n// turn back undoes it: all are diffeomorphisms of R^3, the knot stays.\nconst dir = () => {\n  const u = rnd(-1, 1), a = rnd(0, TAU), s = sqrt(1 - u * u);\n  return [s * cos(a), s * sin(a), u];\n};\nfunction newTwists(S) {\n  const X = S.X, A = 3 + 4 * S.crumple, sg = () => (Math.random() \u003c 0.5 ? -1 : 1);\n  let rg = 0;\n  for (let i = 0; i \u003c N3; i++) rg += X[i] * X[i];\n  rg = sqrt(rg / NB);\n  const a = dir();\n  S.st = { a, k: log(STR * (1 + S.crumple)) };\n  // The wring turns each slice across the axis whole, -A to A along it.\n  S.tw = [{ c: [0, 0, 0], a, sr: 2 * rg, sz: 0.8 * rg, A: 1.2 * A * sg(), w: 1 }];\n  for (let k = 0; k \u003c 2; k++) {\n    const b = floor(rnd(0, NB)) * 3;\n    S.tw.push({ c: [X[b], X[b + 1], X[b + 2]], a: dir(), sr: rnd(0.4, 0.6) * rg, sz: rnd(0.5, 0.8) * rg, A: A * rnd(0.85, 1.15) * sg(), w: 0 });\n  }\n}\n\nfunction twist(S, X, Y, f) {\n  Y.set(X);\n  const sa = S.st.a, g = exp(S.st.k * f), q = 1 / sqrt(g);\n  for (let i = 0; i \u003c N3; i += 3) {\n    const z = Y[i] * sa[0] + Y[i + 1] * sa[1] + Y[i + 2] * sa[2];\n    for (let c = 0; c \u003c 3; c++) Y[i + c] = Y[i + c] * q + z * (g - q) * sa[c];\n  }\n  for (const T of S.tw) {\n    const [cx, cy, cz] = T.c, [ax, ay, az] = T.a, ir = 1 / (T.sr * T.sr), iz = 1 / T.sz;\n    for (let i = 0; i \u003c N3; i += 3) {\n      const rx = Y[i] - cx, ry = Y[i + 1] - cy, rz = Y[i + 2] - cz, z = rx * ax + ry * ay + rz * az;\n      const qx = rx - z * ax, qy = ry - z * ay, qz = rz - z * az, zz = z * iz;\n      const th = f * T.A * exp(-(qx * qx + qy * qy + qz * qz) * ir) * (T.w ? Math.tanh(zz) : exp(-zz * zz)), c = cos(th), s = sin(th);\n      Y[i] = cx + z * ax + qx * c + (ay * qz - az * qy) * s;\n      Y[i + 1] = cy + z * ay + qy * c + (az * qx - ax * qz) * s;\n      Y[i + 2] = cz + z * az + qz * c + (ax * qy - ay * qx) * s;\n    }\n  }\n}\n\n// Crumples on from share a to b in guarded pieces, evening after each;\n// stops if two edges would come within half an edge. Returns where it got.\nfunction crumpleTo(S, a, b) {\n  const X = S.X, Y = S.Y;\n  let sub = b - a, dX = dmin(X);\n  for (let n = 0; a \u003c b - 1e-9 && n \u003c 200; n++) {\n    const f = min(sub, b - a);\n    twist(S, X, Y, sm(a + f) - sm(a));\n    const g = guard(X, Y, false, dX);\n    if (g \u003c 1) {\n      sub = f * g * 0.8;\n      continue;\n    }\n    const dY = dmin(Y);\n    if (dY \u003c (0.5 * lengths(Y)) / NB) return 1;\n    X.set(Y);\n    dX = even(S, 1, dY);\n    a += f;\n    sub = f * 1.5;\n  }\n  return a > 1 - 1e-6 ? 1 : a;\n}\n\nfunction begin(S) {\n  nice(S.knot, S.X, S.Y);\n  S.L0 = lengths(S.X);\n  newTwists(S);\n  crumpleTo(S, 0, 1);\n  relax(S);\n  frame(S, 1);\n}\n\n// The flow starts at the first length (the zoom undoes it), edges fixed.\nfunction relax(S) {\n  const f = S.L0 / lengths(S.X);\n  for (let i = 0; i \u003c N3; i++) S.X[i] *= f;\n  centre(S.X);\n  lengths(S.X);\n  S.ell.set(LE);\n  S.phase = S.t = S.tc = 0;\n  S.E = S.Ec = energy(S.X, null);\n  S.tau = 1e-5;\n}\n\n// One step: gradient, projected, smoothed, projected; cut to the guard,\n// halved until the energy falls, kept only then.\nfunction step(S) {\n  const { X, Y, G, D } = S;\n  energy(X, G);\n  const dm = DM;\n  tangent(X, G);\n  smooth(G, D);\n  tangent(X, D);\n  let m = 0;\n  for (let i = 0; i \u003c N3; i += 3) m = max(m, D[i] * D[i] + D[i + 1] * D[i + 1] + D[i + 2] * D[i + 2]);\n  let k = min(S.tau, VCAP / (sqrt(m) + 1e-30));\n  for (let tries = 0; tries \u003c 12; tries++) {\n    for (let i = 0; i \u003c N3; i++) Y[i] = X[i] - k * D[i];\n    edges(Y, S.ell);\n    centre(Y);\n    const g = guard(X, Y, false, dm);\n    if (g \u003c 1) {\n      k *= g * 0.9;\n      continue;\n    }\n    const E = energy(Y, null);\n    if (E \u003c S.E) {\n      X.set(Y);\n      S.E = E;\n      S.tau = k * 1.3;\n      return;\n    }\n    k *= 0.5;\n  }\n  S.tau = max(k, 1e-12);\n}\n\n// A smoothed view along the thinnest axis, the longest up the panel, by\n// power steps on C and tr - C.\nfunction frame(S, d) {\n  const X = S.X, C = [0, 0, 0, 0, 0, 0, 0, 0, 0];\n  for (let i = 0; i \u003c N3; i += 3) for (let a = 0; a \u003c 3; a++) for (let b = 0; b \u003c 3; b++) C[a * 3 + b] += X[i + a] * X[i + b];\n  const tr = C[0] + C[4] + C[8], dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2], unit = (w) => w.map((x) => x / (Math.hypot(...w) || 1));\n  const it = (v, sh) => {\n    for (let k = 0; k \u003c 3; k++) v = unit([0, 1, 2].map((a) => sh * v[a] + (sh ? -1 : 1) * (C[a * 3] * v[0] + C[a * 3 + 1] * v[1] + C[a * 3 + 2] * v[2])));\n    return v;\n  };\n  const k = min(1, d * 1.2), pull = (e, v) => unit(e.map((x, a) => x + (v[a] * (dot(e, v) \u003c 0 ? -1 : 1) - x) * k));\n  const e3 = pull(S.e3, it(S.e3, tr)), e2 = pull(S.e2, it(S.e2, 0)), p = dot(e2, e3);\n  S.e3 = e3;\n  S.e2 = unit(e2.map((x, a) => x - p * e3[a]));\n  S.e1 = [S.e2[1] * e3[2] - S.e2[2] * e3[1], S.e2[2] * e3[0] - S.e2[0] * e3[2], S.e2[0] * e3[1] - S.e2[1] * e3[0]];\n}\n\nexport function setup(params) {\n  params.s = {\n    knot: -1, phase: 0, t: 0, acc: 0, rock: 0, cr: 0,\n    X: new Float64Array(N3), Y: new Float64Array(N3), G: new Float64Array(N3), D: new Float64Array(N3), ell: new Float64Array(NB),\n    hist: new Float32Array(TN).fill(NaN), ht: 0,\n    e1: [1, 0, 0], e2: [0, 1, 0], e3: [0, 0, 1],\n    zb: new Float32Array(N), buf: new Float32Array(N * 3), col: new Float32Array(NB * 3), scr: new Float32Array(NB * 4),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.crumple] = [cl(kv[0], 0, 1), cl(kv[1], 0.2, 3), cl(kv[3], 0, 1)];\n  const knot = round(cl(kv[2], 0, 4));\n  if (knot !== S.knot) {\n    S.knot = knot;\n    S.hist.fill(NaN);\n    begin(S);\n  }\n  const ds = (d * S.speed) / 2;\n  S.rock += ds;\n  if (input.btnPressed && input.btnPressed[0] && S.phase !== 2) (S.phase = 2), (S.cr = 0), newTwists(S);\n  S.t += ds;\n  if (S.phase === 0) {\n    S.acc += ds * SPS;\n    for (; S.acc >= 1; S.acc--) step(S);\n    // Relaxed once half a second takes less than 0.05% off the energy.\n    if ((S.tc += ds) >= 0.5) {\n      if (S.Ec - S.E \u003c 0.0005 * S.E && S.t > 3) (S.phase = 1), (S.t = 0);\n      S.Ec = S.E;\n      S.tc = 0;\n    }\n    if (S.t > 40) (S.phase = 1), (S.t = 0);\n  } else if (S.phase === 1) {\n    // While it holds, the beads are spaced out evenly again.\n    even(S, 2);\n    S.E = energy(S.X, null);\n    if (S.t > HOLD) (S.phase = 2), (S.cr = 0), newTwists(S);\n  } else {\n    S.cr = crumpleTo(S, S.cr, min(1, S.cr + ds / CRT));\n    S.E = energy(S.X, null);\n    if (S.cr >= 1) relax(S);\n  }\n  frame(S, ds);\n  // A trace sample every quarter second.\n  if ((S.ht += ds) >= 0.25) {\n    (S.ht -= 0.25), S.hist.copyWithin(0, 1), (S.hist[TN - 1] = log(S.E));\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.knot \u003c 0) return;\n  const { zb, buf, col, scr, X, e1, e2, e3 } = S;\n  zb.fill(1e9), buf.fill(0);\n  // The view rocks 0.6 rad and nods 0.3.\n  const ra = 0.6 * sin((TAU * S.rock) / 13), rb = 0.3 * sin((TAU * S.rock) / 9.1), ca = cos(ra), sa = sin(ra), cb = cos(rb), sb = sin(rb);\n  const zoom = ZOOM[S.knot] * (S.L0 / lengths(X)), tr = TUBE[S.knot], CAM = 5;\n  for (let i = 0; i \u003c NB; i++) {\n    const o = i * 3, x = X[o], y = X[o + 1], z = X[o + 2];\n    let u = e1[0] * x + e1[1] * y + e1[2] * z, v = e2[0] * x + e2[1] * y + e2[2] * z, w = e3[0] * x + e3[1] * y + e3[2] * z;\n    [u, w] = [u * ca + w * sa, -u * sa + w * ca];\n    [v, w] = [v * cb + w * sb, -v * sb + w * cb];\n    const p = CAM / (CAM + w);\n    (scr[i * 4] = 31.5 + u * zoom * p), (scr[i * 4 + 1] = KY - v * zoom * p), (scr[i * 4 + 2] = w * zoom), (scr[i * 4 + 3] = tr * p);\n    // The hue walks a third of the wheel along the curve and back.\n    hsv(0.5 + S.hue + 0.34 * (0.5 - 0.5 * cos((TAU * i) / NB)), 0.8, 1, col, o);\n  }\n  // Light from the upper left and in front, and the half vector for the shine.\n  const lx = -0.451, ly = -0.551, lz = -0.702, hx = -0.245, hy = -0.299, hz = -0.922;\n  for (let i = 0; i \u003c NB; i++) {\n    const a = i * 4, b = ((i + 1) % NB) * 4, ax = scr[a], ay = scr[a + 1], az = scr[a + 2], bx = scr[b], by = scr[b + 1], bz = scr[b + 2];\n    let tx = bx - ax, ty = by - ay, tz = bz - az;\n    const tl = sqrt(tx * tx + ty * ty + tz * tz) || 1, m = max(1, ceil(Math.hypot(bx - ax, by - ay) / 0.7)), ci = i * 3, cj = ((i + 1) % NB) * 3;\n    (tx /= tl), (ty /= tl), (tz /= tl);\n    for (let q = 0; q \u003c m; q++) {\n      const f = q / m, sx = ax + (bx - ax) * f, sy = ay + (by - ay) * f, sz = az + (bz - az) * f, rp = scr[a + 3] + (scr[b + 3] - scr[a + 3]) * f;\n      const cr = col[ci] + (col[cj] - col[ci]) * f, cg = col[ci + 1] + (col[cj + 1] - col[ci + 1]) * f, cbl = col[ci + 2] + (col[cj + 2] - col[ci + 2]) * f;\n      // Nearer is brighter: the back of the knot at about 60%.\n      const fog = 0.8 - 0.2 * cl(sz / 30, -1, 1);\n      const R = rp + 1, x0 = max(0, floor(sx - R)), x1 = min(W - 1, ceil(sx + R)), y0 = max(0, floor(sy - R)), y1 = min(H - 1, ceil(sy + R));\n      for (let y = y0; y \u003c= y1; y++)\n        for (let x = x0; x \u003c= x1; x++) {\n          const nx = x + 0.5 - sx, ny = y + 0.5 - sy, d2 = nx * nx + ny * ny, p = y * W + x;\n          if (d2 >= R * R) continue;\n          if (d2 >= rp * rp) {\n            // A dark rim a little behind: it cuts the gap in a strand below.\n            const z = sz + rp * 0.9;\n            if (z \u003c zb[p]) (zb[p] = z), (buf[p * 3] = buf[p * 3 + 1] = buf[p * 3 + 2] = 0);\n            continue;\n          }\n          const nz = sqrt(rp * rp - d2), z = sz - nz;\n          if (z >= zb[p]) continue;\n          zb[p] = z;\n          // The sphere's normal less its part along the tube.\n          let Nx = nx / rp, Ny = ny / rp, Nz = -nz / rp;\n          const dn = Nx * tx + Ny * ty + Nz * tz;\n          (Nx -= dn * tx), (Ny -= dn * ty), (Nz -= dn * tz);\n          const nl = sqrt(Nx * Nx + Ny * Ny + Nz * Nz) || 1;\n          const lam = max(0, (Nx * lx + Ny * ly + Nz * lz) / nl), sp = max(0, (Nx * hx + Ny * hy + Nz * hz) / nl) ** 18, v = fog * (0.3 + 0.75 * lam);\n          (buf[p * 3] = cr * v + sp * 0.7), (buf[p * 3 + 1] = cg * v + sp * 0.7), (buf[p * 3 + 2] = cbl * v + sp * 0.7);\n        }\n    }\n  }\n  // The trace: log E over the last 16 s, a line over a faint fill.\n  let lo = 1e9, hi = -1e9, py = -1;\n  for (let i = 0; i \u003c TN; i++) if (S.hist[i] === S.hist[i]) (lo = min(lo, S.hist[i])), (hi = max(hi, S.hist[i]));\n  if (hi - lo \u003c 0.4) hi = lo + 0.4;\n  const tc = col.subarray(90, 93);\n  for (let i = 0; i \u003c TN; i++) {\n    const v = S.hist[i];\n    if (v !== v) continue;\n    const y = round(TY1 - ((v - lo) / (hi - lo)) * (TY1 - TY0)), ya = py \u003c 0 ? y : min(y, py + 1), yb = py \u003c 0 ? y : max(y, py - 1);\n    for (let yy = min(ya, y); yy \u003c= TY1; yy++) {\n      const p = yy * W + i, f = yy \u003c= max(yb, y) ? (i === TN - 1 ? 1 : 0.6) : 0.16;\n      if (zb[p] \u003c 1e9) continue;\n      (buf[p * 3] = tc[0] * f), (buf[p * 3 + 1] = tc[1] * f), (buf[p * 3 + 2] = tc[2] * f);\n    }\n    py = y;\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    if (buf[o] + buf[o + 1] + buf[o + 2] \u003c 0.02) continue;\n    // Each channel in steps of 4 of 255.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] * 63.75) * 4), min(255, round(buf[o + 1] * 63.75) * 4), min(255, round(buf[o + 2] * 63.75) * 4));\n  }\n}\n","trick-or-treat":"// ===== Patternflow pattern =====\n// Title:   Trick or Treat\n// Family:  halloween\n// Idea:    A narrow street on Halloween night runs up the panel to a vanishing point under a purple sky, and three small trick-or-treaters, a bedsheet ghost, a witch and a cat, walk up it away from us sweeping torch beams over the pavement and swinging pumpkin buckets, stop where a door opens a wedge of yellow light for candy, and walk on into the distance as the next group comes in, with bats over the roofs and leaves blowing through the mist.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lights=0.5..1, Wind=0..1\n//\n// Knob 1: Hue. Tints the night, sky, walls, roofs and road together, while lamps, pumpkins and costumes keep their colours: at 0 a violet sky over plum walls, at 0.25 a blood red night, at 0.5 a toxic green one, at 0.75 deep teal.\n// Knob 2: Speed. At 2 the children walk about 1.5 m a second, wait 2.2 s at each door and sweep their torches across and back in 1.2 s, and a new group comes in every 9 to 12 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Lights. The share of houses with their lights on, half at the start and all at 1. A lit house has lit windows (lamps, jack-o'-lanterns, a flickering television), a porch lamp and pumpkins on the step, and only lit houses open their doors to the children.\n// Knob 4: Wind. At the start 43 leaves skitter across the street and the mist drifts at 0.7 m a second; at 0.5 there are 135 leaves, at 1 there are 240, blowing across at about 5.6 m a second and up to 3.7 m high, and the mist runs at 4.3 m a second.\n// Buttons: K1 tap opens the door of a lit house up the street for 3 s.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u;\n};\n// Smooth noise on a 32 x 32 wrapping grid, for the mist.\nconst NT = new Float32Array(1024).map((_, i) => hash(i * 7 + 11));\nconst vn2 = (x, y) => {\n  const i = floor(x), j = floor(y), u = x - i, v = y - j, a = (j & 31) * 32, b = ((j + 1) & 31) * 32, i0 = i & 31, i1 = (i + 1) & 31;\n  const su = u * u * (3 - 2 * u), sv = v * v * (3 - 2 * v);\n  return (NT[a + i0] * (1 - su) + NT[a + i1] * su) * (1 - sv) + (NT[b + i0] * (1 - su) + NT[b + i1] * su) * sv;\n};\nconst hsv = (h, s, v) => [5, 3, 1].map((n) => {\n  const k = (n + (h - floor(h)) * 6) % 6;\n  return 255 * v * (1 - s * max(0, min(k, 4 - k, 1)));\n});\nconst put = (b, o, r, g, bl) => ((b[o] = r), (b[o + 1] = g), (b[o + 2] = bl));\nconst add = (b, o, r, g, bl) => ((b[o] += r), (b[o + 1] += g), (b[o + 2] += bl));\n\n// One-point perspective. The lane is 2 units wide between the house fronts\n// (about 3.2 m), the eye HC above it and the eaves HE, a little higher, so\n// the roof lines climb from the vanishing point (32, YH) to the top corners.\n// A point x across, h up and z deep lands at (32 + R s x, YH + R s (HC - h))\n// with s = ZN / z: the ground at depth z is row YH + G s.\nconst YH = 22, G = 127.5 - YH, R = 30, HC = G / R, ZN = 3, HE = HC + 0.9;\n// Roof pitch, run from the eave to the ridge, and the houses' depth.\nconst PITCH = 1.1, RUN = 1.3, DEPTH = 2 * RUN;\nconst sOf = (z) => ZN / z;\n\n// Houses along each side: [side, z0, z1, door z].\nconst HOUSES = [];\nfor (const side of [-1, 1])\n  for (let z = 1 + hash(side + 5) * 1.5, k = 0; z \u003c 80; k++) {\n    const len = 3 + 1.6 * hash(k * 31 + side * 7 + 1);\n    HOUSES.push([side, z, z + len, z + 0.7 + (len - 1.4) * hash(k * 17 + side * 3 + 2)]);\n    z += len + 0.5 + 1.1 * hash(k * 13 + side * 11 + 3);\n  }\nconst houseAt = (side, z) => HOUSES.findIndex((h) => h[0] === side && z >= h[1] && z \u003c h[2]);\n// Three floors of windows, by height.\nconst FLOORS = [[0.55, 1.3], [1.95, 2.75], [3.3, 4.0]];\n\n// What each LED sees, worked out once by casting its ray at the ground, the\n// two rows of house fronts, their roofs and the end walls facing us; the\n// nearest hit wins. A window's id is its house, floor and slot.\nconst SKY = 0, GROUND = 1, WALL = 2, WIN = 3, DOOR = 4, END = 5, ROOF = 6;\nconst MAT = new Uint8Array(N), REF = new Int16Array(N), ZB = new Float32Array(N), XB = new Float32Array(N), HB = new Float32Array(N);\nfor (let p = 0; p \u003c N; p++) {\n  const q = ((p % W) + 0.5 - 32) / R, e = (floor(p / W) + 0.5 - YH) / R, side = q \u003c 0 ? -1 : 1, aq = abs(q);\n  let best = 0, m = SKY, ref = -1, zz = 0, xx = 0, hh = 0, s;\n  // The ground, unless a house stands on that spot.\n  if (e > 0 && (abs(q / (s = e / HC)) \u003c= 1 || !(abs(q / s) \u003c= 1 + DEPTH && houseAt(side, ZN / s) >= 0))) [best, m, zz, xx] = [s, GROUND, ZN / s, q / s];\n  // The house front on this side, then the near slope of a roof.\n  let i = houseAt(side, ZN / aq), h = HC - e / aq;\n  if (i >= 0 && h >= 0 && h \u003c= HE && aq > best) [best, m, ref, zz, hh] = [aq, WALL, i, ZN / aq, h];\n  s = (-e - PITCH * aq) / (HE - HC - PITCH);\n  if (s > best && (i = houseAt(side, ZN / s)) >= 0 && aq / s >= 1 && aq / s \u003c= 1 + RUN) [best, m, ref, zz] = [s, ROOF, i, ZN / s];\n  // End walls facing us, with their gables.\n  HOUSES.forEach(([sd, z0], i) => {\n    const s = sOf(z0), d = aq / s - 1, h = HC - e / s;\n    if (sd === side && s > best && d >= 0 && d \u003c= DEPTH && h >= 0 && h \u003c= HE + PITCH * min(d, DEPTH - d)) [best, m, ref, zz, xx, hh] = [s, END, i, z0, d, h];\n  });\n  if (m === WALL) {\n    const [, z0, z1, zd] = HOUSES[ref], f = FLOORS.findIndex(([a, b]) => hh > a && hh \u003c b), c = f ? (zz - z0 - 0.75) / 1.25 : (zz - zd) / 1.25, k = round(c);\n    if (abs(zz - zd) \u003c 0.3 && hh \u003c 1.35) m = DOOR;\n    else if (f >= 0 && abs(c - k) \u003c 0.24 && (f || k) && zz > z0 + 0.3 && zz \u003c z1 - 0.3) [m, ref] = [WIN, ref * 32 + f * 5 + ((k + 5) % 5)];\n  }\n  [MAT[p], REF[p], ZB[p], XB[p], HB[p]] = [m, ref, zz, xx, hh];\n}\n// Fixed shading: a wall's tone, each house a little different and darker\n// far off, a window's fade, each door's porch lamp on the wall, the stars.\nconst TONE = new Float32Array(N), LAMP = new Float32Array(N), STAR = new Uint8Array(N), WIDS = new Set(), GL = [], WL = [];\nfor (let p = 0; p \u003c N; p++) {\n  const m = MAT[p], fog = min(1, 7 / ZB[p]);\n  if (m === WALL || m === END) TONE[p] = (0.85 + 0.3 * hash(REF[p] * 7 + 2)) * (0.5 + 0.5 * fog);\n  if (m === WALL) {\n    const dz = ZB[p] - HOUSES[REF[p]][3] - 0.42, dh = HB[p] - 1.6;\n    LAMP[p] = abs(dz) \u003c 0.09 && abs(dh) \u003c 0.12 ? 3 : exp(-(dz * dz + dh * dh) / 0.35) * 0.9;\n  }\n  if (m === WIN) (TONE[p] = 0.15 + 0.85 * fog * fog), WIDS.add(REF[p]);\n  STAR[p] = m === SKY && hash(p * 3 + 1) \u003c 0.015;\n  // The ground and the walls, the only LEDs the lights walk.\n  if (m === GROUND) GL.push(p);\n  else if (m !== SKY && m !== ROOF) WL.push(p);\n}\n// The walls in order of depth, and where each quarter unit of depth starts.\nWL.sort((a, b) => ZB[a] - ZB[b]);\nconst WZ = new Int32Array(330);\nfor (let i = 0, j = 0; i \u003c 330; i++) {\n  while (j \u003c WL.length && ZB[WL[j]] \u003c i / 4) j++;\n  WZ[i] = j;\n}\nconst wallFrom = (z) => WZ[min(329, floor(z * 4))];\n// Where each row starts among the ground LEDs, and those between two depths.\nconst GROW = new Int32Array(H + 1);\nfor (let y = 0, j = 0; y \u003c= H; y++) {\n  while (j \u003c GL.length && GL[j] \u003c y * W) j++;\n  GROW[y] = j;\n}\nconst rowsFor = (za, zb) => [GROW[cl(floor(YH + (G * ZN) / zb), 0, H)], GROW[cl(floor(YH + (G * ZN) / max(za, 0.1)) + 2, 0, H)]];\n\n// A house is lit while its rank is under Lights, and only lit houses open\n// their doors to the children.\nconst RANK = HOUSES.map((h, i) => hash(i * 29 + 185));\n// Jack-o'-lanterns on the step at each door, one or two: [x, z, seed, house].\nconst PUMPKINS = [];\nHOUSES.forEach(([side, , , zd], i) => {\n  PUMPKINS.push([side * 0.84, zd - 0.42, i * 2, i]);\n  if (hash(i * 5 + 9) \u003c 0.5) PUMPKINS.push([side * 0.86, zd + 0.42, i * 2 + 1, i]);\n});\n// Their glow on the ground and the porch lamps', laid down once with whose\n// light it is, for the flicker and for Lights.\nconst PG = new Float32Array(N), PS = new Int16Array(N), LG = new Float32Array(N), LS = new Int16Array(N);\nfor (const p of GL) {\n  PUMPKINS.forEach(([px, pz], i) => {\n    const r2 = (XB[p] - px) ** 2 + (ZB[p] - pz) ** 2, f = r2 \u003c 0.4 ? (1 - r2 / 0.4) * 0.6 : 0;\n    if (f > PG[p]) (PG[p] = f), (PS[p] = i);\n  });\n  HOUSES.forEach(([side, , , zd], i) => {\n    const r2 = (XB[p] - side) ** 2 * 0.6 + (ZB[p] - zd - 0.4) ** 2, f = r2 \u003c 1.1 ? (1 - r2 / 1.1) ** 2 * 0.42 : 0;\n    if (f > LG[p]) (LG[p] = f), (LS[p] = i);\n  });\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, mx: 0, hue: 0, speed: 2, lights: 0.5, wind: 0.06, begun: false, groups: [], leaves: [], tap: -1, tapT: 0,\n    open: new Float32Array(HOUSES.length), rgb: new Float32Array(N * 3), lit: new Float32Array(N * 3), wc: new Float32Array(96 * HOUSES.length), hueKey: -1,\n  };\n}\n\n// A group of three, a bedsheet ghost, a little witch and a cat, walking\n// together from one lit door to the next, zigzagging up the street.\nconst SLOTS = [[-0.34, 0.1], [0, -0.05], [0.34, 0.18]];\nconst newGroup = (z) => ({\n  x: 0, z, tx: 0, tz: z, wait: 0, door: -1, side: -1, done: false,\n  kids: SLOTS.map(([x, dz], type) => ({ type, x, z: z + dz, ph: Math.random() * TAU, sw: Math.random() * TAU, candy: 0 })),\n});\n// The next lit door at least 1.6 ahead of z on one side, and its depth.\nfunction nextDoor(S, side, z) {\n  let best = -1;\n  HOUSES.forEach(([sd, , , zd], i) => {\n    if (sd === side && RANK[i] \u003c S.lights && zd > z + 1.6 && (best \u003c 0 || zd \u003c HOUSES[best][3])) best = i;\n  });\n  return best;\n}\nconst doorZ = (i) => (i \u003c 0 ? 1e9 : HOUSES[i][3]);\n\nfunction steer(S, g) {\n  if (g.z > 15 || g.done) return Object.assign(g, { done: true, door: -1, tx: 0, tz: 200 });\n  g.door = nextDoor(S, g.side, g.z);\n  // A dark stretch on this side: cross over, or walk on.\n  if (doorZ(g.door) > g.z + 6) g.door = nextDoor(S, (g.side = -g.side), g.z);\n  if (doorZ(g.door) > g.z + 6) Object.assign(g, { door: -1, tx: 0, tz: g.z + 3 });\n  // They wait on the path just short of the door, so it shows past them.\n  else Object.assign(g, { tx: g.side * 0.3, tz: doorZ(g.door) - 0.55 });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.5, 0.06], ds = (cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3)) / 2;\n  [S.hue, S.lights, S.wind] = [cl(k[0], 0, 1), cl(k[2], 0.5, 1), cl(k[3], 0, 1)];\n  S.t += ds;\n  const gust = 0.5 + vn(S.t * 0.4, 9);\n  S.mx += ds * (0.3 + 2.4 * S.wind) * gust;\n  if (!S.begun) {\n    S.begun = true;\n    // One group already far up the street, one halfway, one just come in.\n    const far = newGroup(16), mid = newGroup(9.2), near = newGroup(2.7);\n    far.done = true;\n    near.side = doorZ(nextDoor(S, -1, 2.7)) \u003c doorZ(nextDoor(S, 1, 2.7)) ? -1 : 1;\n    for (const g of [far, mid, near]) steer(S, g), S.groups.push(g);\n  }\n  // A new group comes in from the bottom once the last is far enough on.\n  const last = S.groups[S.groups.length - 1];\n  if (!last || last.z > 9) {\n    const g = newGroup(2.4);\n    steer(S, g);\n    S.groups.push(g);\n  }\n  if (input.btnPressed && input.btnPressed[0]) {\n    const c = HOUSES.map((h, i) => i).filter((i) => HOUSES[i][3] > 4 && HOUSES[i][3] \u003c 14 && RANK[i] \u003c S.lights);\n    S.tap = c[floor(Math.random() * c.length)];\n    S.tapT = 3;\n  }\n  const want = new Float32Array(HOUSES.length);\n  if ((S.tapT -= ds) > 0) want[S.tap] = 1;\n  for (const g of S.groups) {\n    if (g.wait > 0) {\n      want[g.door] = 1;\n      if ((g.wait -= ds) \u003c= 0) {\n        for (const kd of g.kids) kd.candy++;\n        g.side = -g.side;\n        steer(S, g);\n      }\n    } else {\n      // 0.95 lane widths a second at Speed 2; the door opens as they come.\n      const dx = g.tx - g.x, dz = g.tz - g.z, l = sqrt(dx * dx + dz * dz), st = 0.95 * ds;\n      if (l \u003c= st) {\n        [g.x, g.z] = [g.tx, g.tz];\n        if (g.door >= 0) g.wait = 2.2;\n        else steer(S, g);\n      } else (g.x += (dx / l) * st), (g.z += (dz / l) * st);\n      if (g.door >= 0 && l \u003c 0.5) want[g.door] = 1;\n    }\n    const walk = g.wait \u003c= 0, f = min(1, ds * 4);\n    g.kids.forEach((kd, i) => {\n      // Each child trails its place in the group a little.\n      kd.x += (g.x + SLOTS[i][0] * (walk ? 1 : 0.8) - kd.x) * f;\n      kd.z += (g.z + SLOTS[i][1] - kd.z) * f;\n      if (walk) kd.ph += ds * TAU * 1.9;\n      kd.sw += ds * (walk ? 2.3 : 0.9);\n      [kd.walk, kd.side] = [walk, g.side];\n    });\n  }\n  S.groups = S.groups.filter((g) => g.z \u003c 40);\n  for (let i = 0; i \u003c HOUSES.length; i++) S.open[i] += (want[i] - S.open[i]) * min(1, ds * (want[i] ? 5 : 2));\n  // Leaves blown across the street, tumbling; more, faster and higher with wind.\n  const n = round(30 + 210 * S.wind);\n  while (S.leaves.length \u003c n) S.leaves.push(leaf(Math.random() * 2 - 1));\n  S.leaves.length = n;\n  for (const lf of S.leaves) {\n    lf.x += ds * (0.3 + 3.2 * S.wind) * lf.sp * gust;\n    lf.ph += ds * (7 + 10 * S.wind) * lf.sp;\n    lf.h = abs(sin(lf.ph * 0.4)) * (0.06 + 1.6 * S.wind) * lf.sp;\n    if (lf.x > 1) Object.assign(lf, leaf(-1));\n  }\n}\nconst leaf = (x) => ({ x, z: 2.4 + Math.random() * Math.random() * 11, h: 0, ph: Math.random() * TAU, c: floor(Math.random() * 3), sp: 0.6 + 0.8 * Math.random() });\n\n// Bats over the roofs, each on its own path through the sky, beating its\n// wings 6 to 9 times a second; every third is nearer and twice the size.\nconst BATW = [[\"x...x\", \".xxx.\", \"..x..\"], [\"xxxxx\", \".xxx.\"], [\".xxx.\", \"x.x.x\"]];\nfunction drawBats(buf, t) {\n  for (let i = 0; i \u003c 9; i++) {\n    const x = round(32 + 26 * (vn(t * 0.35 + i * 3.1, i * 5 + 1) * 2 - 1)), y = round(3 + 20 * vn(t * 0.3 + i * 1.7, i * 5 + 2));\n    const w = BATW[floor((t * (6 + i * 0.7) + i * 0.37) * 3) % 3], z = i % 3 ? 1 : 2;\n    for (let j = 0; j \u003c w.length * z; j++)\n      for (let k = 0; k \u003c 5 * z; k++) {\n        const px = x - 2 * z + k;\n        if (w[(j / z) | 0][(k / z) | 0] === \"x\" && px >= 0 && px \u003c W) put(buf, ((y + j) * W + px) * 3, 10, 4, 16);\n      }\n  }\n}\n\n// Costumes seen from behind, in units of the child's height: u across, v up\n// from the feet. Each returns a colour or null.\nconst WHITE = [236, 232, 255], SHADE = [176, 170, 214], SHOE = [40, 30, 50], SOCK = [255, 150, 30];\nconst HAT = [24, 14, 36], BAND = [170, 70, 240], CAPE = [112, 44, 168], HAIR = [120, 230, 60], BROOM = [150, 104, 60], STRAW = [236, 196, 90];\nconst CAT = [30, 24, 40], RIM = [110, 92, 146], BUCKET = [255, 136, 16], CANDY = [255, 70, 190];\nfunction costume(type, u, v, ph, sw) {\n  if (v \u003c 0.09 && abs(abs(u) - 0.07) \u003c 0.05 && v >= 0.04 * max(0, u \u003c 0 ? sin(ph) : -sin(ph))) return type === 1 ? (floor(v * 50) & 1 ? SOCK : HAT) : SHOE;\n  if (type === 0) {\n    // The sheet: a round top, wider to a hem that ripples as they walk.\n    if (v \u003c 0.08 + 0.03 * sin(u * 34 + ph * 2) || v > 0.95) return null;\n    const half = v > 0.72 ? sqrt(max(0, 0.042 - (v - 0.72) ** 2)) : 0.205 + 0.1 * (0.72 - v);\n    return abs(u) > half ? null : u > half - 0.07 ? SHADE : WHITE;\n  }\n  if (type === 1) {\n    // The witch: a bent hat with band and brim, green hair, a broom.\n    const t = (v - 0.81) / 0.33, a = 0.13 * ((0.64 - v) / 0.55), bu = u + 0.3 - 0.55 * (v - 0.1);\n    if (t >= 0 && t \u003c= 1 && abs(u - 0.07 * t * t) \u003c 0.13 * (1 - t)) return t \u003c 0.12 ? BAND : HAT;\n    if (v >= 0.76 && v \u003c 0.81 && abs(u) \u003c 0.25) return HAT;\n    if ((u * u) / 0.012 + (v - 0.69) ** 2 / 0.009 \u003c 1) return HAIR;\n    if (v >= 0.09 && v \u003c 0.64 && abs(u) \u003c 0.12 + a) return abs(u) > 0.09 + a ? RIM : CAPE;\n    if (v > 0.22 && v \u003c 0.98 && abs(bu) \u003c 0.03) return BROOM;\n    return v >= 0.04 && v \u003c= 0.22 && abs(bu) \u003c 0.02 + 0.5 * (0.22 - v) ? STRAW : null;\n  }\n  // The cat: a black suit, round head, two ears and a tail that sways.\n  if (u > 0.06 && u \u003c 0.38 && v > 0.17 && v \u003c 0.69)\n    for (let i = 0; i \u003c= 12; i++) {\n      const a = i / 12;\n      if ((u - 0.12 - 0.17 * a - 0.04 * sin(a * 3 + sw)) ** 2 + (v - 0.22 - 0.42 * a * a) ** 2 \u003c 0.0011) return RIM;\n    }\n  const ear = v >= 0.84 && v \u003c 0.99 && abs(abs(u) - 0.085) \u003c 0.055 * ((0.99 - v) / 0.15);\n  return u * u + (v - 0.76) ** 2 \u003c 0.018 || ear || (v >= 0.09 && v \u003c 0.68 && abs(u) \u003c 0.135 + 0.03 * sin(v * 5)) ? CAT : null;\n}\n\nfunction drawKid(buf, kd) {\n  const s = sOf(kd.z), hp = 0.92 * R * s, xs = 32 + kd.x * R * s, ys = YH + G * s, bob = kd.walk ? 0.025 * abs(sin(kd.ph)) : 0;\n  // The pumpkin bucket swings from one hand, the cat's left and the others' right.\n  const ba = kd.walk ? 0.45 * sin(kd.ph) : 0.15 * sin(kd.sw * 3), bcx = (kd.type === 2 ? -0.25 : 0.25) + 0.12 * sin(ba), bcy = 0.42 - 0.12 * cos(ba);\n  for (let y = max(0, floor(ys - 1.18 * hp)); y \u003c= min(H - 1, floor(ys)); y++)\n    for (let x = max(0, floor(xs - 0.5 * hp)); x \u003c= min(W - 1, floor(xs + 0.5 * hp)); x++) {\n      const u = (x + 0.5 - xs) / hp, v = (ys - y - 0.5) / hp - bob, o = (y * W + x) * 3;\n      let c = (u - bcx) ** 2 + (v - bcy) ** 2 \u003c 0.0064 ? (kd.candy && v > bcy + 0.03 ? CANDY : BUCKET) : costume(kd.type, u, v, kd.ph, kd.sw);\n      if (!c) continue;\n      // Black cloth gets a moonlit outline, or it vanishes on the street.\n      if (c === CAT || c === HAT) {\n        const e = 1 / hp, out = (du, dv) => !costume(kd.type, u + du, v + dv, kd.ph, kd.sw);\n        if (out(e, 0) || out(-e, 0) || out(0, e)) c = RIM;\n      }\n      put(buf, o, c[0], c[1], c[2]);\n    }\n}\n\nfunction drawPumpkin(buf, [px, pz, sd], t) {\n  const s = sOf(pz), w = 0.17 * R * s, xs = 32 + px * R * s, ys = YH + G * s, fl = 0.72 + 0.28 * vn(t * 9, sd);\n  for (let y = max(0, floor(ys - 1.9 * w)); y \u003c= min(H - 1, floor(ys)); y++)\n    for (let x = max(0, floor(xs - w - 1)); x \u003c= min(W - 1, floor(xs + w + 1)); x++) {\n      const u = (x + 0.5 - xs) / w, v = (ys - y - 0.5) / w, o = (y * W + x) * 3;\n      if (u * u + (v - 0.78) ** 2 / 0.6 \u003c 1) {\n        // Ribbed bright orange; from 5 LEDs across, two eyes and a grin.\n        const face = w > 2.4 && ((abs(abs(u) - 0.38) \u003c 0.17 && v > 0.95 && v \u003c 1.25) || (abs(u) \u003c 0.55 && v > 0.42 && v \u003c 0.62 && abs(u * 4) % 1 \u003c 0.75));\n        if (face) put(buf, o, 255, 236 * fl, 120 * fl);\n        else put(buf, o, 255 * fl, (abs(u) % 0.5 \u003c 0.12 ? 108 : 140) * fl, 12);\n      } else if (abs(u) \u003c 0.14 && v >= 1.4 && v \u003c 1.75) put(buf, o, 90, 120, 30);\n    }\n}\n\n// A dead leaf, catching the light as it tumbles.\nconst LEAF = [[240, 124, 30], [230, 176, 50], [214, 76, 34]];\nfunction drawLeaf(buf, lf, wind) {\n  const s = sOf(lf.z), xs = floor(32 + lf.x * R * s), ys = floor(YH + G * s - lf.h * R * s), sz = max(1, round((0.11 + 0.04 * wind) * R * s));\n  const c = LEAF[lf.c], f = 0.55 + 0.4 * abs(sin(lf.ph * 2)), th = max(1, round(sz * 0.6 * abs(cos(lf.ph))));\n  for (let j = 0; j \u003c th; j++)\n    for (let i = 0; i \u003c sz; i++) if (xs + i >= 0 && xs + i \u003c W && ys - j >= 0 && ys - j \u003c H) put(buf, ((ys - j) * W + xs + i) * 3, c[0] * f, c[1] * f, c[2] * f);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const { rgb, lit, open, wc } = S, t = S.t, on = (i) => RANK[i] \u003c S.lights;\n  // A stepped sky, lighter towards the vanishing point, walls, roofs, road.\n  if (S.hueKey !== S.hue) {\n    const h = 0.76 + (S.hueKey = S.hue);\n    S.sky = Array.from({ length: YH + 1 }, (_, y) => hsv(h + 0.01, 0.75 - floor((y / YH) * 6) / 24, 0.3 + (floor((y / YH) * 6) / 6) * 0.42));\n    [S.wall, S.end, S.roof] = [hsv(h, 0.55, 0.19), hsv(h, 0.5, 0.29), hsv(h, 0.5, 0.06)];\n    S.road = [hsv(h - 0.06, 0.45, 0.14), hsv(h - 0.04, 0.4, 0.2), hsv(h - 0.04, 0.35, 0.3), hsv(h - 0.31, 0.3, 0.07)];\n  }\n  lit.fill(0);\n  // Torch beams: the ghost and the cat wave a cone of light from the hand,\n  // mostly over the street ahead, now and then up the house fronts.\n  for (const g of S.groups)\n    for (const kd of g.kids) {\n      if (kd.type === 1 || kd.z > 14) continue;\n      const ang = (kd.walk ? 0 : kd.side * 0.7) + 0.7 * sin(kd.sw * 2.2 + kd.type * 2) + 0.22 * sin(kd.sw * 5.1 + kd.type);\n      const pit = -0.19 + 0.36 * max(0, sin(kd.sw * 1.1 + kd.type * 1.3)) ** 2, dx = sin(ang) * cos(pit), dy = sin(pit), dz = cos(ang) * cos(pit);\n      const cone = (p, wx, wy, wz) => {\n        const f = wx * dx + wy * dy + wz * dz, r = sqrt(max(0, wx * wx + wy * wy + wz * wz - f * f)) / f;\n        if (f \u003c 0.3 || f > 5 || r > 0.24) return;\n        const v = (r \u003c 0.12 ? 1 : 0.55) * min(1, (0.24 - r) * 25) * min(1, (f - 0.3) * 2) * min(1, 2.6 / (f + 0.5));\n        add(lit, p * 3, 255 * v, 236 * v, 190 * v);\n      };\n      const [j0, j1] = rowsFor(kd.z + 0.3, kd.z + 5);\n      for (let j = j0; j \u003c j1; j++) cone(GL[j], XB[GL[j]] - kd.x, -0.4, ZB[GL[j]] - kd.z);\n      for (let j = wallFrom(kd.z + 0.2), j2 = wallFrom(kd.z + 5.2); j \u003c j2; j++) {\n        const p = WL[j], side = (p & 63) \u003c 32 ? -1 : 1;\n        cone(p, (MAT[p] === END ? side * (1 + XB[p]) : side) - kd.x, HB[p] - 0.4, ZB[p] - kd.z);\n      }\n    }\n  // Open doors throw a wedge of yellow light across the street.\n  HOUSES.forEach(([side, , , zd], i) => {\n    if (open[i] \u003c 0.02) return;\n    const [j0, j1] = rowsFor(zd - 1.4, zd + 1.4);\n    for (let j = j0; j \u003c j1; j++) {\n      const p = GL[j], dd = 1 - XB[p] * side, w = 0.28 + 0.4 * dd, dz = abs(ZB[p] - zd);\n      if (dd \u003c 0 || dd > 1.9 || dz > w) continue;\n      const f = open[i] * (1 - dd / 2.1) * min(1, (w - dz) * 8) * 1.2;\n      add(lit, p * 3, 255 * f, 196 * f, 70 * f);\n    }\n  });\n  // This frame's flicker of each pumpkin and colour of each window: a lamp,\n  // a guttering jack-o'-lantern, or a television cutting from shot to shot.\n  const PF = PUMPKINS.map(([, , , i], k) => (on(i) ? 0.3 + 0.7 * vn(t * 11, k) : 0));\n  for (const id of WIDS) {\n    let c = [S.wall[0] * 0.6, S.wall[1] * 0.6, S.wall[2] * 0.6], f;\n    if (on(id >> 5) && hash(id * 3 + 7) \u003c= 0.3 + 0.7 * S.lights) {\n      if (hash(id * 11 + 3) \u003c 0.25) (f = 0.35 + 0.65 * hash(floor(t * 5 + hash(id)) * 31 + id)), (c = [140 * f, 166 * f, 255 * f]);\n      else if (hash(id * 5 + 1) \u003c 0.3) (f = 0.5 + 0.5 * vn(t * 9, id)), (c = [255 * f, 132 * f, 20 * f]);\n      else (f = 0.85 + 0.15 * vn(t * 1.5, id)), (c = [255 * f, 200 * f, 96 * f]);\n    }\n    put(wc, id * 3, c[0], c[1], c[2]);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const m = MAT[p];\n    if (m === SKY) {\n      const c = S.sky[min(YH, (p / W) | 0)], st = STAR[p] ? 0.3 + 0.7 * vn(t * 3, p) : 0;\n      put(rgb, o, c[0] + 160 * st, c[1] + 150 * st, c[2] + 170 * st);\n    } else if (m === GROUND) {\n      // Road, curb, pavement and dark yards, the pumpkins' and porch lamps'\n      // light, and a low mist drifting with the wind, glowing where lit.\n      const z = ZB[p], ax = abs(XB[p]), pg = PG[p] * PF[PS[p]], lg = on(LS[p]) ? LG[p] : 0, base = S.road[ax > 1 ? 3 : ax > 0.8 ? 1 : ax > 0.74 ? 2 : 0], fg = min(1, 2.4 / z);\n      const mn = 0.65 * vn2((XB[p] - S.mx) * 1.6, z * 0.7 + t * 0.05) + 0.35 * vn2((XB[p] - S.mx * 1.4) * 3.3 + 7, z * 1.5), mi = cl((mn - 0.42) * 2.2, 0, 1) * min(1, 3.5 / z) * (ax > 1 ? 0.3 : 0.7);\n      const R0 = base[0] * fg + 255 * pg + 250 * lg, G0 = base[1] * fg + 118 * pg + 190 * lg, B0 = base[2] * fg + 20 * pg + 110 * lg, k = 0.4 * mi;\n      put(rgb, o, R0 + lit[o] * (0.8 + k) + (52 + R0 * 0.5) * mi, G0 + lit[o + 1] * (0.78 + k) + (44 + G0 * 0.5) * mi, B0 + lit[o + 2] * (0.88 + k) + (78 + B0 * 0.3) * mi);\n    } else if (m === WALL || m === END) {\n      const c = m === END ? S.end : S.wall, tone = TONE[p], r = on(REF[p]) ? LAMP[p] : 0;\n      put(rgb, o, c[0] * tone + 255 * r + lit[o] * 0.42, c[1] * tone + 196 * r + lit[o + 1] * 0.36, c[2] * tone + 110 * r + lit[o + 2] * 0.26);\n    } else if (m === ROOF) put(rgb, o, S.roof[0], S.roof[1], S.roof[2]);\n    else if (m === DOOR) put(rgb, o, 44 + 211 * open[REF[p]], 28 + 198 * open[REF[p]], 38 + 92 * open[REF[p]]);\n    else put(rgb, o, wc[REF[p] * 3] * TONE[p], wc[REF[p] * 3 + 1] * TONE[p], wc[REF[p] * 3 + 2] * TONE[p]);\n  }\n  drawBats(rgb, t);\n  // Pumpkins, children and leaves, far to near.\n  const sp = [];\n  for (const pk of PUMPKINS) if (pk[1] > 2.6 && pk[1] \u003c 22 && on(pk[3])) sp.push([pk[1], 0, pk]);\n  for (const g of S.groups) for (const kd of g.kids) sp.push([kd.z, 1, kd]);\n  for (const lf of S.leaves) sp.push([lf.z, 2, lf]);\n  sp.sort((a, b) => b[0] - a[0]);\n  for (const [, kind, obj] of sp) kind ? (kind === 1 ? drawKid(rgb, obj) : drawLeaf(rgb, obj, S.wind)) : drawPumpkin(rgb, obj, t);\n  // Each channel in steps of 4 of 255.\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, rgb[o]) & 252, min(255, rgb[o + 1]) & 252, min(255, rgb[o + 2]) & 252);\n}\n","conways-soldiers":"// ===== Patternflow pattern =====\n// Title:   Conway's Soldiers\n// Family:  algo\n// Idea:    Gold soldiers below a white line leapfrog each other across it, each jumped soldier blinking off the board, until the last one lands 1, 2, 3 and then 4 rows past the line with the fewest that can do it (2, 4, 8 and 20); each soldier carries a violet disc of light whose area is its Conway weight, the discs merge as they jump and the last soldier's disc exactly fills the ring of weight 1, and then an endless army floods the board and its gathered light still cannot fill the ring round the marked square on row 5.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Conway's soldiers (John Horton Conway, 1961), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Row=0..5, Glow=0..1\n//\n// Knob 1: Hue. Turns the soldiers round the wheel from gold at 0 through green at 0.25, pale blue at 0.5 and magenta at 0.75; the light of the weights swings through the cold hues only, violet at 0, pink at 0.25, violet at 0.5 and cyan at 0.75, so it never goes a muddy orange. The square on row 5 is pink-red at 0.\n// Knob 2: Speed. At 2 a jump takes half a second: the 20 soldiers of row 4 line up in 1.4 seconds and make their 19 jumps in 9.5, and the round of all five campaigns takes 39 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Row. At 0 the campaigns come in turn: row 4 first on squares of 7 LEDs, then the endless army that tries for row 5, then rows 1, 2 and 3 on squares of 11. At 1 to 4 that row's campaign plays over and over (2, 4, 8 or 20 soldiers); at 5 the endless army floods the board again and again.\n// Knob 4: Glow. How far the weights glow on the empty board round the target: at 0 a violet diamond about four squares across each way, with bands running in towards the target; at 1 every square on the panel shows its weight, each 0.618 of its neighbour one step nearer.\n\nconst W = 64, H = 128, CX = 32;\nconst { floor, min, max, abs, round, sin, sqrt, PI, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (t) => t * t * (3 - 2 * t);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Conway's weight: a square at taxicab distance d from the target weighs\n// X^d with X = (sqrt 5 - 1) / 2 = 1/phi, so X + X^2 = 1. A jump straight\n// at the target keeps the weight (X^(d+2) + X^(d+1) = X^d), any other jump\n// loses some, so an army that ends with a soldier on the target must start\n// at weight 1 or more. For row 5 the whole half-plane below the line\n// weighs exactly 1 (the columns sum to phi^3, the rows to X^3), so every\n// finite army falls short.\nconst X = (sqrt(5) - 1) / 2;\n// The line is the gap between row 0 and row 1, pixel row 76. A square of\n// side s has its rows at y = LINE - s r .. LINE - s (r - 1).\nconst LINE = 76.5;\n// The board kept: columns -6..6, rows -10..8.\nconst C0 = 6, R0 = 10, NC = 13, NR = 19;\nconst key = (c, r) => (c + C0) + (r + R0) * NC;\n\n// The four campaigns, each the fewest soldiers that can reach its row, as\n// starting squares [column, row] (row 0 is just below the line) and jumps\n// [from column, from row, to column, to row]. Found offline by a search that\n// kept only armies of weight 1 or more and pruned any jump that would drop\n// the weight under 1; for rows 1 to 3 the armies are the column, the T and\n// the cross, and the 20 of row 4 came out with 19 jumps, all of them\n// straight at the target, so each army here weighs exactly 1 from the\n// first jump to the last. Rows 1 to 3 stand on squares of 11 LEDs, row 4\n// and the endless army on squares of 7.\nconst CAMP = [\n  null,\n  { s: 11, start: [[0, 0], [0, -1]], moves: [[0, -1, 0, 1]] },\n  { s: 11, start: [[-2, 0], [-1, 0], [0, 0], [0, -1]], moves: [[0, -1, 0, 1], [-2, 0, 0, 0], [0, 0, 0, 2]] },\n  {\n    s: 11,\n    start: [[-2, 0], [-1, 0], [0, 0], [1, 0], [2, 0], [0, -1], [0, -2], [0, -3]],\n    moves: [[0, -1, 0, 1], [-2, 0, 0, 0], [0, 0, 0, 2], [2, 0, 0, 0], [0, -3, 0, -1], [0, -1, 0, 1], [0, 1, 0, 3]],\n  },\n  {\n    s: 7,\n    start: [[-4, 0], [-3, 0], [-2, 0], [-1, 0], [0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [-3, -1], [-2, -1], [-1, -1], [0, -1], [1, -1], [-2, -2], [-1, -2], [0, -2], [1, -2], [-2, -3], [0, -3]],\n    moves: [\n      [-2, -1, -2, 1], [-1, -1, -1, 1], [-2, 1, 0, 1], [0, 0, 0, 2], [-4, 0, -2, 0], [2, 0, 0, 0], [0, -1, 0, 1], [0, 1, 0, 3],\n      [1, -2, 1, 0], [4, 0, 2, 0], [2, 0, 0, 0], [-2, -3, -2, -1], [-3, -1, -1, -1], [-1, -2, -1, 0], [0, -3, 0, -1], [0, -1, 0, 1],\n      [-2, 0, 0, 0], [0, 0, 0, 2], [0, 2, 0, 4],\n    ],\n  },\n  // Row 5: the endless army, a whole row at a time.\n  { s: 7 },\n];\n// Story seconds (one a second at Speed 2): a jump, the part of it in the\n// air, the soldiers' line-up, the wait before the first jump, the win, the\n// fade, and for the endless army one row every FLOOD.\nconst STEP = 0.5, FLY = 0.36, LINEUP = 1.4, WAIT = 0.4, WIN = 1.6, FADE = 0.6, FLOOD = 0.3, ROWS5 = 8, HOLD5 = 2;\n// Soldier radius in squares, and the order campaigns come in at Row 0.\nconst RAD = 0.42, ORDER = [4, 5, 1, 2, 3];\n// The radius, in squares, of the light disc of weight 1.\nconst HALO = 2.4;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, row: 0, glowK: 0.06,\n    camp: 4, ci: 0, phase: \"lineup\", pt: 0,\n    s: 7, sFrom: 7, sTo: 7, T: 4, Tfrom: 4, Tto: 4, zoomT: 0.6,\n    occ: new Uint8Array(NC * NR), amp: new Float32Array(NC * NR), fl: new Float32Array(NC * NR),\n    order: [], rec: 0, mi: 0, fly: null, gauge: 0, rows5: 0, t: 0, flow: 0,\n  };\n  enter(params.s, 4, true);\n}\n\nconst weight = (c, r, n) => pow(X, abs(c) + abs(r - n));\n\nfunction enter(S, camp, now) {\n  S.camp = camp;\n  const C = CAMP[camp];\n  S.occ.fill(0);\n  S.amp.fill(0);\n  S.fl.fill(0);\n  S.fly = null;\n  S.mi = 0;\n  S.rec = 0;\n  S.rows5 = 0;\n  S.sFrom = S.s;\n  S.sTo = C.s;\n  S.Tfrom = S.T;\n  S.Tto = camp;\n  S.zoomT = abs(S.sTo - S.sFrom) > 0.01 ? 1.0 : abs(S.Tto - S.Tfrom) > 0.01 ? 0.7 : 0.4;\n  S.phase = now ? (camp === 5 ? \"flood\" : \"lineup\") : \"zoom\";\n  if (now) (S.s = S.sTo), (S.T = S.Tto);\n  S.pt = 0;\n  // The line-up: nearest the line first, from the middle out.\n  if (C.start) S.order = C.start.slice().sort((a, b) => b[1] - a[1] || abs(a[0]) - abs(b[0]) || a[0] - b[0]);\n}\n\nfunction next(S) {\n  if (S.row > 0) enter(S, S.row, false);\n  else {\n    S.ci = (S.ci + 1) % ORDER.length;\n    enter(S, ORDER[S.ci], false);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.glowK = cl(k[3], 0, 1);\n  const row = cl(round(k[2]), 0, 5);\n  if (row !== S.row) {\n    S.row = row;\n    if (row > 0) enter(S, row, true);\n    else (S.ci = 0), enter(S, 4, true);\n  }\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  S.pt += g;\n  S.flow += g * 0.7;\n  const C = CAMP[S.camp], { occ, amp, fl } = S;\n  // Soldiers grow in over 0.15 s, the jumped and the faded shrink away, and\n  // white flashes die down.\n  for (let i = 0; i \u003c occ.length; i++) {\n    if (occ[i]) amp[i] = min(1, amp[i] + g / 0.15);\n    else if (amp[i] > 0) amp[i] = max(0, amp[i] - g / 0.22);\n    if (fl[i] > 0) fl[i] = max(0, fl[i] - g / 0.35);\n  }\n  if (S.phase === \"zoom\") {\n    const u = ss(cl(S.pt / S.zoomT, 0, 1));\n    S.s = S.sFrom + (S.sTo - S.sFrom) * u;\n    S.T = S.Tfrom + (S.Tto - S.Tfrom) * u;\n    if (S.pt >= S.zoomT) (S.phase = S.camp === 5 ? \"flood\" : \"lineup\"), (S.pt = 0), (S.s = S.sTo), (S.T = S.Tto);\n  } else if (S.phase === \"lineup\") {\n    const iv = min(0.25, LINEUP / S.order.length);\n    while (S.rec \u003c S.order.length && S.pt >= S.rec * iv) {\n      const [c, r] = S.order[S.rec++], i = key(c, r);\n      occ[i] = 1;\n      fl[i] = 0.8;\n    }\n    if (S.rec >= S.order.length && S.pt >= S.order.length * iv + WAIT) (S.phase = \"jump\"), (S.pt = 0), (S.mi = 0);\n  } else if (S.phase === \"jump\") {\n    const m = C.moves[S.mi], p = S.pt / FLY;\n    if (!S.fly) {\n      // Lift off: the soldier leaves its square and is in the air.\n      const ia = key(m[0], m[1]);\n      occ[ia] = 0;\n      amp[ia] = 0;\n      S.fly = { x0: m[0], y0: m[1], x1: m[2], y1: m[3], bx: (m[0] + m[2]) / 2, by: (m[1] + m[3]) / 2, over: false };\n    }\n    if (!S.fly.over && p >= 0.5) {\n      // Over the top: the jumped soldier blinks white and goes.\n      const ib = key(S.fly.bx, S.fly.by);\n      occ[ib] = 0;\n      fl[ib] = 1;\n      S.fly.over = true;\n    }\n    if (p >= 1 && !S.fly.landed) {\n      const ic = key(S.fly.x1, S.fly.y1);\n      occ[ic] = 1;\n      amp[ic] = 1;\n      fl[ic] = 0.55;\n      S.fly.landed = true;\n    }\n    if (S.pt >= STEP) {\n      S.fly = null;\n      S.mi++;\n      S.pt -= STEP;\n      if (S.mi >= C.moves.length) S.phase = \"win\";\n    }\n  } else if (S.phase === \"win\") {\n    if (S.pt >= WIN) (S.phase = \"fade\"), (S.pt = 0);\n  } else if (S.phase === \"flood\") {\n    // A whole row of the endless army at a time, from the line down to the\n    // bottom of the panel. Each row counts as the whole infinite row.\n    const want = min(ROWS5, floor(S.pt / FLOOD) + 1);\n    while (S.rows5 \u003c want) {\n      const r = -S.rows5;\n      if (r >= -R0) for (let c = -C0; c \u003c= C0; c++) (occ[key(c, r)] = 1), (fl[key(c, r)] = 0.5);\n      S.rows5++;\n    }\n    if (S.pt >= ROWS5 * FLOOD + HOLD5) (S.phase = \"fade\"), (S.pt = 0);\n  } else if (S.phase === \"fade\") {\n    const f = 1 - cl(S.pt / FADE, 0, 1);\n    for (let i = 0; i \u003c occ.length; i++) if (occ[i]) amp[i] = min(amp[i], f);\n    if (S.pt >= FADE) next(S);\n  }\n  // The gauge on the line: the army's weight against its target, 1 filling\n  // the line. The soldier in the air carries its own weight and, once it is\n  // over, the jumped one's too, so a straight jump never moves the gauge.\n  let wsum = 0;\n  if (S.camp === 5) wsum = 1 - pow(X, S.rows5);\n  else {\n    const n = S.camp;\n    for (let r = -R0; r \u003c NR - R0; r++)\n      for (let c = -C0; c \u003c= C0; c++) {\n        const i = key(c, r);\n        if (occ[i]) wsum += amp[i] * weight(c, r, n);\n      }\n    if (S.fly && !S.fly.landed) wsum += weight(S.fly.x0, S.fly.y0, n) + (S.fly.over ? weight(S.fly.bx, S.fly.by, n) : 0);\n  }\n  if (S.phase === \"fade\") wsum = min(wsum, 1 - cl(S.pt / FADE, 0, 1));\n  S.gauge += (wsum - S.gauge) * min(1, g * 10);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const s = S.s, T = S.T, n = S.camp, { occ, amp, fl } = S;\n  // The glow keeps to the cold hues; where the soldiers' hue comes near it\n  // (Hue about 0.5 to 0.6) the soldiers pale towards white to stand apart.\n  const hs = 0.12 + S.hue, hg = 0.725 + 0.225 * sin(2 * PI * S.hue);\n  const near = cl(1 - abs(((hs - hg + 1.5) % 1) - 0.5) / 0.2, 0, 1);\n  const sol = hsv(hs, 0.85 - 0.55 * near, 1);\n  const glowC = hsv(hg, 0.72, 1);\n  const mark = hsv(0.95 + S.hue, 0.8, 1);\n  // How far the weights glow: the square at distance d shows X^(gam d).\n  const gam = 0.82 - 0.62 * S.glowK, amp0 = 0.62;\n  const xg = pow(X, gam);\n  // The row-5 square blinks while the endless army stands.\n  const blink5 = n === 5 && S.phase !== \"zoom\" ? 0.55 + 0.45 * sin(S.t * 9) : 1;\n  // The target ring brightens on the win.\n  const winK = S.phase === \"win\" ? 0.5 + 0.5 * sin(S.pt * 14) : 0;\n  const half = s / 2 - 0.7;\n  const fly = S.fly && !S.fly.landed ? S.fly : null;\n  let fx = 0, fy = 0, fr2 = 0;\n  if (fly) {\n    const p = ss(cl(S.pt / FLY, 0, 1));\n    fx = fly.x0 + (fly.x1 - fly.x0) * p;\n    fy = fly.y0 + (fly.y1 - fly.y0) * p;\n    // The hop: the soldier swells as it rises towards us and shrinks as it lands.\n    const rr = RAD * (1 + 0.38 * sin(PI * p));\n    fr2 = rr * rr;\n  }\n  const gw = S.gauge * 32;\n  // Each soldier's weight as light: a disc whose area is its weight, so the\n  // light on the board is the army's weight. When a soldier jumps straight\n  // at the target its disc swallows the jumped one's and the light stays\n  // the same; the last soldier on the target holds a disc of weight 1, the\n  // size of the ring drawn round it.\n  const halos = [];\n  if (n === 5) {\n    // The endless army stands too close for its discs to show: its light is\n    // gathered on the target instead, a disc of area 1 - X^k after k whole\n    // rows, which creeps towards the ring and never fills it.\n    if (S.phase !== \"zoom\") halos.push(0, 5, HALO * HALO * S.gauge);\n  } else {\n    for (let r = -R0; r \u003c NR - R0; r++)\n      for (let c = -C0; c \u003c= C0; c++) {\n        const i = key(c, r);\n        if (!occ[i] || amp[i] \u003c= 0) continue;\n        const w = weight(c, r, n) * amp[i];\n        if (w > 0.02) halos.push(c, r, HALO * HALO * w);\n      }\n    if (fly) halos.push(fx, fy, HALO * HALO * (weight(fly.x0, fly.y0, n) + (fly.over ? weight(fly.bx, fly.by, n) : 0)));\n  }\n  const nh = halos.length;\n  const ringR = HALO, ringK = n === 5 ? blink5 : 0.4;\n  for (let y = 0; y \u003c H; y++) {\n    const v = (LINE - (y + 0.5)) / s + 0.5, r = round(v), fv = v - r;\n    for (let x = 0; x \u003c W; x++) {\n      const u = (x + 0.5 - CX) / s, c = round(u), fu = u - c;\n      let R = 0.012, G = 0.01, B = 0.03;\n      const ox = abs(fu) * s, oy = abs(fv) * s;\n      if (y === 76) {\n        // The line, dim, lit from the middle out by the army's weight.\n        const dx = abs(x + 0.5 - CX);\n        R = G = B = 0.24;\n        if (dx \u003c gw) (R = 0.55 + 0.45 * sol[0]), (G = 0.55 + 0.45 * sol[1]), (B = 0.55 + 0.45 * sol[2]);\n        else if (n === 5 && S.phase !== \"zoom\" && dx > min(30, gw)) (R = mark[0] * blink5), (G = mark[1] * blink5), (B = mark[2] * blink5);\n      } else if (ox \u003c half && oy \u003c half) {\n        // A square of the board, lit by its weight against the target row.\n        // Bands run in along the rings of equal distance towards the\n        // target, two squares apart.\n        const dist = abs(c) + abs(r - T);\n        const gl = amp0 * pow(xg, dist) * (0.62 + 0.38 * sin(2 * PI * (dist / 2 + S.flow))) + (r \u003c= 0 ? 0.088 : 0.035);\n        R = glowC[0] * gl;\n        G = glowC[1] * gl;\n        B = glowC[2] * gl;\n        if (c === 0 && r === 5) {\n          // The square no army reaches: a red ring and a cross.\n          if (ox > half - 1 || oy > half - 1 || abs(ox - oy) \u003c 0.6) (R = mark[0] * blink5), (G = mark[1] * blink5), (B = mark[2] * blink5);\n        } else if (c === 0 && r === n && n \u003c 5 && !(amp[key(0, n)] > 0) && (ox > half - 1 || oy > half - 1)) {\n          const k = 0.55 + 0.45 * winK;\n          R = max(R, k * (0.6 + 0.4 * sol[0]));\n          G = max(G, k * (0.6 + 0.4 * sol[1]));\n          B = max(B, k * (0.6 + 0.4 * sol[2]));\n        }\n        if (c >= -C0 && c \u003c= C0 && r >= -R0 && r \u003c NR - R0) {\n          const i = key(c, r), a = amp[i];\n          if (a > 0) {\n            const rad = RAD * a * (n \u003c 5 && S.phase === \"win\" && c === 0 && r === n ? 1 + 0.12 * winK : 1);\n            if (fu * fu + fv * fv \u003c rad * rad) {\n              const w = fl[i];\n              R = sol[0] + (1 - sol[0]) * w;\n              G = sol[1] + (1 - sol[1]) * w;\n              B = sol[2] + (1 - sol[2]) * w;\n            }\n          }\n        }\n      }\n      // The halos add up where they overlap.\n      let hl = 0;\n      for (let h = 0; h \u003c nh; h += 3) {\n        const du = u - halos[h], dv = v - halos[h + 1];\n        if (du * du + dv * dv \u003c halos[h + 2]) hl += 0.3;\n      }\n      // The ring of weight 1 round the target: what the army has to fill.\n      const tu = u, tv = v - n, td = sqrt(tu * tu + tv * tv) * s;\n      if (abs(td - ringR * s) \u003c 0.55 && !(R > 0.5 && G > 0.3)) {\n        const k = n === 5 ? ringK : 0.4;\n        R = max(R, (n === 5 ? mark[0] : 0.8) * k);\n        G = max(G, (n === 5 ? mark[1] : 0.8) * k);\n        B = max(B, (n === 5 ? mark[2] : 0.85) * k);\n      }\n      if (hl > 0 && !(G > 0.3 && R > 0.5 && fu * fu + fv * fv \u003c RAD * RAD)) {\n        R += glowC[0] * hl;\n        G += glowC[1] * hl;\n        B += glowC[2] * hl;\n      }\n      if (fly) {\n        const du = u - fx, dv = v - fy;\n        if (du * du + dv * dv \u003c fr2) (R = 0.6 + 0.4 * sol[0]), (G = 0.6 + 0.4 * sol[1]), (B = 0.6 + 0.4 * sol[2]);\n      }\n      display.setPixel(x, y, round(255 * cl(R, 0, 1)), round(255 * cl(G, 0, 1)), round(255 * cl(B, 0, 1)));\n    }\n  }\n}\n","koebe-packing":"// ===== Patternflow pattern =====\n// Title:   Koebe Packing\n// Family:  cells\n// Idea:    A tall rectangle of discs, each touching exactly its neighbours in a triangulation drawn as spokes through the kissing points, re-solves itself every time an edge of the triangulation flips or a vertex is born or removed, so the discs swell and shrink into the one packing the new graph allows.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: circle packing theorem (Paul Koebe, 1936; E. M. Andreev, 1970; William Thurston, 1980s), computed by the iteration of Charles Collins and Kenneth Stephenson (2003), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Circles=22..56, Graph=0..1\n//\n// Knob 1: Hue. Turns the colours of the degrees round the wheel: at 0 the small discs of degree 4 are pink, 5 amber, 6 cyan, 7 blue and the big ones of degree 8 violet; at 0.5 the same five are green, blue, red, amber and lime.\n// Knob 2: Speed. At 2 the triangulation changes every 1.2 seconds and the discs take about a second to settle into the new packing; at 0.2 a change comes every 12 seconds, at 3 every 0.8.\n// Knob 3: Circles. About how many discs the packing holds, 22 to 56 (a birth or a removal moves it by one or two for a while); the rim of the rectangle grows with them, 14 boundary discs up to 24, 20 up to 40, 26 above. Turning it grows a new triangulation from points.\n// Knob 4: Graph. At 0 the discs are solid and the triangulation shows as dark spokes from each centre to the points where it kisses its neighbours; toward 1 the discs empty to rings and the spokes turn white, so the triangulation itself is the picture.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, atan2, round, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Hue of each degree, added to Hue + 0.9 so that 0 opens on pink, not red.\n// A boundary disc counts as the degree its angle would have inside: faces\n// times 2 pi over its target angle, so a side disc with three faces is a 6.\nconst DEG_HUE = [0, 0, 0, 0, 0, 0.21, 0.6, 0.73, 0.86];\n// Interior degree limits for an ordinary flip; a disc being born or removed\n// may sit at 3 for a while.\nconst DMIN = 4, DMAX = 8;\n// One change in this many story seconds (one a second at Speed 2).\nconst EVERY = 1.2;\n// How freely a flip may push degrees away from 6.\nconst TEMP = 4;\n\n// --- the triangulation ---\n// Each vertex keeps its flower: the neighbours in counterclockwise order,\n// closed for an interior vertex, open for a boundary vertex (from the next\n// boundary vertex round to the previous one). kind is 0 inside, 1 on a side\n// of the rectangle, 2 at a corner. Target angle sums: 2 pi inside, pi along\n// a side (the centres line up), pi/2 at a corner.\n\nfunction faces(S, v) {\n  return S.kind[v] ? S.fl[v].length - 1 : S.fl[v].length;\n}\nfunction target(S, v) {\n  return S.kind[v] === 0 ? TAU : S.kind[v] === 1 ? PI : PI / 2;\n}\nfunction effDeg(S, v, df = 0) {\n  return round(((faces(S, v) + df) * TAU) / target(S, v));\n}\nfunction hasNb(S, a, b) {\n  return S.fl[a].indexOf(b) >= 0;\n}\n// Two boundary vertices may be joined across the inside only when they are\n// the two neighbours of one corner (the edge cuts that corner off); joined\n// anywhere else they would have to touch through the line of discs between.\nfunction cornerCut(S, a, b) {\n  if (!S.kind[a] || !S.kind[b]) return true;\n  const B = S.B, d = (S.bi[b] - S.bi[a] + B) % B;\n  if (d === 2) return S.kind[S.ring[(S.bi[a] + 1) % B]] === 2;\n  if (d === B - 2) return S.kind[S.ring[(S.bi[b] + 1) % B]] === 2;\n  return false;\n}\n// Can vertex v lose a face, or gain one? A side disc keeps two to four\n// faces, a corner disc one or two.\nfunction canLose(S, v, focus) {\n  const f = faces(S, v);\n  if (S.kind[v] === 0) return f - 1 >= (v === focus ? 3 : DMIN);\n  return f - 1 >= (S.kind[v] === 2 ? 1 : 2);\n}\nfunction canGain(S, v) {\n  const f = faces(S, v);\n  if (S.kind[v] === 0) return f + 1 \u003c= DMAX;\n  return f + 1 \u003c= (S.kind[v] === 2 ? 2 : 4);\n}\n\n// The edge uv with its two triangles (u, v, a) and (u, b, v), both\n// counterclockwise, or null when uv lies on the boundary.\nfunction quad(S, u, v) {\n  const fu = S.fl[u], i = fu.indexOf(v), n = fu.length;\n  if (i \u003c 0) return null;\n  if (S.kind[u]) {\n    if (i === 0 || i === n - 1) return null;\n    return [fu[i + 1], fu[i - 1]];\n  }\n  return [fu[(i + 1) % n], fu[(i - 1 + n) % n]];\n}\n\nfunction canFlip(S, u, v, focus) {\n  const q = quad(S, u, v);\n  if (!q) return null;\n  const [a, b] = q;\n  if (a === b || hasNb(S, a, b) || !cornerCut(S, a, b)) return null;\n  if (!canLose(S, u, focus) || !canLose(S, v, focus) || !canGain(S, a) || !canGain(S, b)) return null;\n  return q;\n}\n\n// Flip uv to ab: the quadrilateral u, b, v, a keeps its four sides and\n// swaps its diagonal.\nfunction flip(S, u, v, a, b) {\n  const rm = (x, y) => S.fl[x].splice(S.fl[x].indexOf(y), 1);\n  const ins = (x, after, y) => S.fl[x].splice(S.fl[x].indexOf(after) + 1, 0, y);\n  rm(u, v);\n  rm(v, u);\n  ins(a, u, b);\n  ins(b, v, a);\n  S.flash.push({ a, b, t: 0 });\n}\n\nfunction newId(S) {\n  for (let i = 0; i \u003c S.kind.length; i++) if (!S.alive[i] && S.dr[i] \u003c= 0) return i;\n  S.kind.push(0), S.fl.push([]), S.alive.push(0), S.bi.push(-1);\n  for (const k of [\"R\", \"x\", \"y\", \"dx\", \"dy\", \"dr\", \"hu\"]) S[k].push(0);\n  return S.kind.length - 1;\n}\n\n// A new vertex in triangle (u, v, w), counterclockwise: it starts with\n// degree 3, the small circle in the gap between three that touch.\nfunction insert(S, u, v, w) {\n  const x = newId(S);\n  S.kind[x] = 0;\n  S.alive[x] = 1;\n  S.fl[x] = [u, v, w];\n  const ins = (p, after, y) => S.fl[p].splice(S.fl[p].indexOf(after) + 1, 0, y);\n  ins(u, v, x);\n  ins(v, w, x);\n  ins(w, u, x);\n  S.R[x] = 0.15 * min(S.R[u], S.R[v], S.R[w]);\n  // Born at the gap between the three, with no size yet.\n  S.dx[x] = (S.dx[u] + S.dx[v] + S.dx[w]) / 3;\n  S.dy[x] = (S.dy[u] + S.dy[v] + S.dy[w]) / 3;\n  S.dr[x] = 0;\n  S.born = x;\n  for (const p of [u, v, w]) S.flash.push({ a: x, b: p, t: 0 });\n  return x;\n}\n\n// Remove an interior vertex of degree 3: its three triangles become one.\nfunction remove(S, x) {\n  for (const p of S.fl[x]) S.fl[p].splice(S.fl[p].indexOf(x), 1);\n  S.fl[x] = [];\n  S.alive[x] = 0;\n}\n\n// The starting triangulation: a grid of c by 2c vertices, each square cut\n// by a random diagonal, its outer ring the boundary with corners at the\n// grid's corners; then interior vertices put into random triangles or taken\n// out until there are n, and a few hundred random flips to forget the grid.\nfunction build(S, n, grow) {\n  const c = max(3, round(sqrt(n / 2))), r = 2 * c;\n  Object.assign(S, { kind: [], fl: [], alive: [], bi: [], R: [], x: [], y: [], dx: [], dy: [], dr: [], hu: [], flash: [], focus: -1, mode: 0, born: -1 });\n  const id = (i, j) => j * c + i, adj = [];\n  for (let k = 0; k \u003c c * r; k++) newId(S), (S.alive[k] = 1), (adj[k] = new Set());\n  const link = (p, q) => (adj[p].add(q), adj[q].add(p));\n  for (let j = 0; j \u003c r; j++)\n    for (let i = 0; i \u003c c; i++) {\n      if (i + 1 \u003c c) link(id(i, j), id(i + 1, j));\n      if (j + 1 \u003c r) link(id(i, j), id(i, j + 1));\n      if (i + 1 \u003c c && j + 1 \u003c r) Math.random() \u003c 0.5 ? link(id(i, j), id(i + 1, j + 1)) : link(id(i + 1, j), id(i, j + 1));\n    }\n  // The boundary ring, counterclockwise (with y up): along the bottom,\n  // up the right, back along the top, down the left.\n  const ring = [];\n  for (let i = 0; i \u003c c - 1; i++) ring.push(id(i, 0));\n  for (let j = 0; j \u003c r - 1; j++) ring.push(id(c - 1, j));\n  for (let i = c - 1; i > 0; i--) ring.push(id(i, r - 1));\n  for (let j = r - 1; j > 0; j--) ring.push(id(0, j));\n  S.ring = ring;\n  S.B = ring.length;\n  S.corners = [id(0, 0), id(c - 1, 0), id(c - 1, r - 1), id(0, r - 1)];\n  ring.forEach((v, k) => ((S.kind[v] = 1), (S.bi[v] = k)));\n  for (const v of S.corners) S.kind[v] = 2;\n  // Flowers by angle round each grid point; a boundary flower starts just\n  // after the widest gap, which is the outside.\n  for (let k = 0; k \u003c c * r; k++) {\n    const i = k % c, j = floor(k / c);\n    const nb = [...adj[k]].map((q) => [atan2(floor(q / c) - j, (q % c) - i), q]).sort((p, q) => p[0] - q[0]);\n    let start = 0;\n    if (S.kind[k]) {\n      let gap = -1;\n      for (let m = 0; m \u003c nb.length; m++) {\n        const g = (nb[m][0] - nb[(m - 1 + nb.length) % nb.length][0] + TAU) % TAU || TAU;\n        if (g > gap) (gap = g), (start = m);\n      }\n    }\n    S.fl[k] = nb.map((_, m) => nb[(start + m) % nb.length][1]);\n    S.alive[k] = 1;\n    S.R[k] = 1;\n  }\n  // Each new vertex is followed by flips, which spread the degrees and free\n  // room for the next one.\n  for (let tries = 0; tries \u003c 400 && count(S) !== n; tries++) {\n    const t = triangles(S).filter((p) => p.every((q) => canGain(S, q)));\n    if (count(S) > n) drop(S);\n    else if (t.length) insert(S, ...t[floor(Math.random() * t.length)]);\n    for (let k = 0; k \u003c 20; k++) randomFlip(S, TEMP);\n  }\n  S.born = -1;\n  for (let k = 0; k \u003c 300; k++) randomFlip(S, TEMP);\n  S.flash = [];\n  for (let k = 0; k \u003c 600; k++) sweep(S);\n  layout(S);\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    S.dx[v] = S.x[v];\n    S.dy[v] = S.y[v];\n    S.dr[v] = S.alive[v] && !grow ? S.tr[v] : 0;\n    S.hu[v] = hueOf(S, v);\n  }\n}\n\n// Take one interior vertex out: flip its edges away until it has three,\n// then remove it.\nfunction drop(S) {\n  const vs = [];\n  for (let v = 0; v \u003c S.kind.length; v++) if (S.alive[v] && !S.kind[v]) vs.push(v);\n  vs.sort((p, q) => S.fl[p].length - S.fl[q].length);\n  for (const x of vs.slice(0, 6)) {\n    S.focus = x;\n    for (let k = 0; k \u003c 12 && S.fl[x].length > 3; k++) {\n      const opts = S.fl[x].filter((p) => canFlip(S, x, p, x));\n      if (!opts.length) break;\n      const p = opts[floor(Math.random() * opts.length)], q = canFlip(S, x, p, x);\n      flip(S, x, p, q[0], q[1]);\n    }\n    if (S.fl[x].length === 3 && S.fl[x].every((p) => canLose(S, p, -1))) {\n      remove(S, x);\n      break;\n    }\n  }\n  S.focus = -1;\n}\n\nfunction count(S) {\n  let n = 0;\n  for (let v = 0; v \u003c S.kind.length; v++) n += S.alive[v];\n  return n;\n}\n\n// Every triangle once, counterclockwise.\nfunction triangles(S) {\n  const out = [];\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (!S.alive[v]) continue;\n    const f = S.fl[v], n = f.length, m = S.kind[v] ? n - 1 : n;\n    for (let i = 0; i \u003c m; i++) {\n      const a = f[i], b = f[(i + 1) % n];\n      if (v \u003c a && v \u003c b) out.push([v, a, b]);\n    }\n  }\n  return out;\n}\n\n// Interior degrees like to stay near 6: a flip that moves them away is\n// taken less often, so the packing keeps a mix of sizes without running to\n// one huge disc.\nfunction energy(S, vs, d) {\n  let e = 0;\n  vs.forEach((v, k) => {\n    const g = effDeg(S, v, d[k]);\n    e += (g - 6) * (g - 6);\n  });\n  return e;\n}\n\nfunction randomFlip(S, temp) {\n  for (let tries = 0; tries \u003c 40; tries++) {\n    const u = floor(Math.random() * S.kind.length);\n    if (!S.alive[u] || u === S.focus) continue;\n    const f = S.fl[u], v = f[floor(Math.random() * f.length)];\n    if (v === S.focus) continue;\n    const q = canFlip(S, u, v, -1);\n    if (!q) continue;\n    const vs = [u, v, q[0], q[1]], dE = energy(S, vs, [-1, -1, 1, 1]) - energy(S, vs, [0, 0, 0, 0]);\n    if (dE > 0 && Math.random() > exp(-dE / temp)) continue;\n    flip(S, u, v, q[0], q[1]);\n    return true;\n  }\n  return false;\n}\n\n// One change of the triangulation. A disc being born keeps growing by\n// flips of the edges across from it until it has degree 5 or 6; a disc\n// being removed loses an edge a change until it is down to three, then goes.\nfunction change(S) {\n  const x = S.focus;\n  if (x >= 0 && S.mode === 1) {\n    // Grow: flip an edge ab of x's link to the vertex c across it.\n    const f = S.fl[x], n = f.length, opts = [];\n    for (let i = 0; i \u003c n; i++) {\n      const a = f[i], b = f[(i + 1) % n], q = canFlip(S, a, b, x);\n      if (q && (q[0] === x || q[1] === x)) opts.push([a, b, q]);\n    }\n    if (opts.length && n \u003c S.goal) {\n      const [a, b, q] = opts[floor(Math.random() * opts.length)];\n      flip(S, a, b, q[0], q[1]);\n      if (S.fl[x].length >= S.goal) S.focus = -1;\n      return;\n    }\n    S.focus = -1;\n  } else if (x >= 0 && S.mode === 2) {\n    // Shrink: flip one of x's own edges away.\n    if (S.fl[x].length \u003c= 3) {\n      if (S.fl[x].every((p) => canLose(S, p, -1))) remove(S, x);\n      S.focus = -1;\n      return;\n    }\n    const opts = S.fl[x].filter((p) => canFlip(S, x, p, x));\n    if (opts.length) {\n      const p = opts[floor(Math.random() * opts.length)], q = canFlip(S, x, p, x);\n      flip(S, x, p, q[0], q[1]);\n      return;\n    }\n    S.focus = -1;\n  }\n  const n = count(S), r = Math.random();\n  if (r \u003c 0.22 && n \u003c= S.n) {\n    // Born in the biggest gap: the triangle with the largest circles.\n    let best = null, bs = -1;\n    for (const t of triangles(S)) {\n      if (!t.every((p) => canGain(S, p))) continue;\n      const s = min(S.R[t[0]], S.R[t[1]], S.R[t[2]]) * (0.8 + 0.4 * Math.random());\n      if (s > bs) (bs = s), (best = t);\n    }\n    if (best) {\n      S.focus = insert(S, ...best);\n      S.mode = 1;\n      S.goal = 5 + (Math.random() \u003c 0.5 ? 1 : 0);\n      return;\n    }\n  } else if (r \u003c 0.44 && n >= S.n) {\n    // Removed: an interior disc of low degree, not one just born.\n    const vs = [];\n    for (let v = 0; v \u003c S.kind.length; v++) if (S.alive[v] && !S.kind[v] && v !== S.born) vs.push(v);\n    vs.sort((p, q) => S.fl[p].length - S.fl[q].length);\n    if (vs.length) {\n      S.focus = vs[floor(Math.random() * min(3, vs.length))];\n      S.mode = 2;\n      change(S);\n      return;\n    }\n  }\n  randomFlip(S, TEMP);\n}\n\n// --- the packing ---\n// The angle at v in the triangle of three mutually tangent circles with\n// radii r, a, b: sides r + a, r + b, a + b, and by the half-angle form of\n// the law of cosines sin^2(theta / 2) = ab / ((r + a)(r + b)).\nconst ang = (r, a, b) => 2 * asin(sqrt((a * b) / ((r + a) * (r + b))));\n\n// One sweep of Collins and Stephenson: each vertex is given the radius its\n// angle sum would need if its k neighbours were all one size (the uniform\n// neighbour model): beta = sin(sum / 2k) gives that size, delta =\n// sin(target / 2k) the radius that meets the target with it. Every target\n// is an angle, so the packing is free in scale; the mean radius is held at 1.\nfunction sweep(S) {\n  const R = S.R;\n  let sum = 0, n = 0, err = 0;\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (!S.alive[v]) continue;\n    const f = S.fl[v], m = f.length, k = S.kind[v] ? m - 1 : m, r = R[v];\n    let th = 0;\n    for (let i = 0; i \u003c k; i++) th += ang(r, R[f[i]], R[f[(i + 1) % m]]);\n    const T = target(S, v);\n    err = max(err, abs(th - T));\n    const beta = min(0.99999, sin(th / (2 * k))), delta = sin(T / (2 * k));\n    R[v] = ((beta * r) / (1 - beta)) * ((1 - delta) / delta);\n    sum += R[v];\n    n++;\n  }\n  for (let v = 0; v \u003c S.kind.length; v++) if (S.alive[v]) R[v] *= n / sum;\n  return err;\n}\n\n// Lay the circles out from one placed triangle: each placed vertex places\n// the rest of its flower by the angles round it, counterclockwise from a\n// placed neighbour (and clockwise too on the boundary). Then turn the\n// rectangle upright from its first corner to its second and fit it to the\n// panel.\nfunction layout(S) {\n  const nV = S.kind.length, R = S.R, X = new Float64Array(nV), Y = new Float64Array(nV), done = new Uint8Array(nV);\n  let v0 = 0;\n  while (!S.alive[v0]) v0++;\n  const v1 = S.fl[v0][0];\n  done[v0] = done[v1] = 1;\n  X[v1] = R[v0] + R[v1];\n  const queue = [v0, v1];\n  while (queue.length) {\n    const v = queue.shift(), f = S.fl[v], m = f.length;\n    let i0 = -1;\n    for (let i = 0; i \u003c m; i++) if (done[f[i]]) (i0 = i), (i = m);\n    if (i0 \u003c 0) continue;\n    const step = (dir) => {\n      let prev = f[i0], i = i0;\n      for (let s = 1; s \u003c m; s++) {\n        const j = S.kind[v] ? i + dir : (i + dir + m) % m;\n        if (j \u003c 0 || j >= m) break;\n        const u = f[j];\n        if (!done[u]) {\n          const a = atan2(Y[prev] - Y[v], X[prev] - X[v]) + dir * ang(R[v], R[prev], R[u]), d = R[v] + R[u];\n          X[u] = X[v] + d * cos(a);\n          Y[u] = Y[v] + d * sin(a);\n          done[u] = 1;\n          queue.push(u);\n        }\n        prev = u;\n        i = j;\n      }\n    };\n    step(1);\n    if (S.kind[v]) step(-1);\n  }\n  const [k0, k1] = S.corners, rot = -atan2(Y[k1] - Y[k0], X[k1] - X[k0]), cr = cos(rot), sr = sin(rot);\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let v = 0; v \u003c nV; v++) {\n    if (!S.alive[v]) continue;\n    const x = X[v] * cr - Y[v] * sr, y = X[v] * sr + Y[v] * cr;\n    (X[v] = x), (Y[v] = y);\n    x0 = min(x0, x - R[v]), x1 = max(x1, x + R[v]), y0 = min(y0, y - R[v]), y1 = max(y1, y + R[v]);\n  }\n  const sc = min((W - 1) / (x1 - x0), (H - 1) / (y1 - y0)), ox = (W - sc * (x1 - x0)) / 2, oy = (H - sc * (y1 - y0)) / 2;\n  S.tr = S.tr && S.tr.length === nV ? S.tr : new Float64Array(nV);\n  for (let v = 0; v \u003c nV; v++) {\n    if (!S.alive[v]) continue;\n    S.x[v] = ox + (X[v] - x0) * sc;\n    // Panel rows run down, so y up becomes the row counted from the bottom.\n    S.y[v] = H - (oy + (Y[v] - y0) * sc);\n    S.tr[v] = R[v] * sc;\n  }\n}\n\nfunction hueOf(S, v) {\n  return 0.9 + S.hue + DEG_HUE[cl(effDeg(S, v), 4, 8)];\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, graph: 0.06, n: 0, clock: 0, buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 22, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  S.graph = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 22, 56));\n  if (n !== S.n) {\n    // A new count grows a new packing from points; the first one opens\n    // already grown.\n    build(S, n, S.n > 0);\n    S.n = n;\n    // The first change comes soon after the start.\n    S.clock = EVERY * 0.6;\n  }\n  const g = (d * S.speed) / 2;\n  S.clock += g;\n  if (S.clock >= EVERY) {\n    S.clock -= EVERY;\n    change(S);\n  }\n  for (let i = 0; i \u003c 25; i++) sweep(S);\n  layout(S);\n  // The drawn discs ease toward the packing, about a second to settle at\n  // Speed 2; a removed disc shrinks to nothing where it was.\n  const e = 1 - exp(-g * 2.6);\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (S.alive[v]) {\n      S.dx[v] += (S.x[v] - S.dx[v]) * e;\n      S.dy[v] += (S.y[v] - S.dy[v]) * e;\n      S.dr[v] += (S.tr[v] - S.dr[v]) * e;\n      // The colour turns the short way round the wheel, so it stays bright\n      // on the way instead of passing through grey.\n      const dh = hueOf(S, v) - S.hu[v];\n      S.hu[v] += (dh - round(dh)) * e;\n    } else if (S.dr[v] > 0) {\n      S.dr[v] -= S.dr[v] * e + g * 0.5;\n      if (S.dr[v] \u003c 0.3) S.dr[v] = 0;\n    }\n  }\n  for (const f of S.flash) f.t += g;\n  S.flash = S.flash.filter((f) => f.t \u003c 1.4 && S.alive[f.a] && S.alive[f.b]);\n}\n\nfunction line(buf, x0, y0, x1, y1, fn) {\n  const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n  for (let i = 0; i \u003c= n; i++) {\n    const t = n ? i / n : 0, x = floor(mix(x0, x1, t) + 0.5), y = floor(mix(y0, y1, t) + 0.5);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) fn((y * W + x) * 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.kind) return;\n  const buf = S.buf, gk = S.graph;\n  buf.fill(0);\n  const fill = 1 - 0.82 * gk;\n  // Discs: a solid inside (dimmed toward Graph 1), a full-bright rim one LED\n  // wide, and half an LED of black at the edge so two discs part everywhere\n  // but where they kiss.\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    const r = S.dr[v];\n    if (r \u003c 0.6) continue;\n    const cx = S.dx[v], cy = S.dy[v], ro = r - 0.45, ri = r - 1.55, c3 = hsv(S.hu[v], 0.9, 1);\n    const xa = max(0, floor(cx - r)), xb = min(W - 1, floor(cx + r)), ya = max(0, floor(cy - r)), yb = min(H - 1, floor(cy + r));\n    for (let y = ya; y \u003c= yb; y++)\n      for (let x = xa; x \u003c= xb; x++) {\n        const dd = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2);\n        if (dd >= ro) continue;\n        const b = dd > ri ? 1 : fill, o = (y * W + x) * 3;\n        buf[o] = c3[0] * b;\n        buf[o + 1] = c3[1] * b;\n        buf[o + 2] = c3[2] * b;\n      }\n  }\n  // The triangulation: each edge from centre to centre through the point\n  // where the two discs touch. Dark on a solid disc, white on a ring.\n  const dark = 0.3 * (1 - gk), wt = 0.85 * gk;\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (!S.alive[v]) continue;\n    for (const u of S.fl[v]) {\n      if (u \u003c v && S.alive[u]) continue;\n      line(buf, S.dx[v], S.dy[v], S.dx[u], S.dy[u], (o) => {\n        buf[o] = buf[o] * dark + wt;\n        buf[o + 1] = buf[o + 1] * dark + wt;\n        buf[o + 2] = buf[o + 2] * dark + wt;\n      });\n    }\n  }\n  // A new edge flashes white for a second as the two discs come to touch.\n  for (const f of S.flash) {\n    const a = cl(1.4 - f.t, 0, 1);\n    line(buf, S.dx[f.a], S.dy[f.a], S.dx[f.b], S.dy[f.b], (o) => {\n      buf[o] = mix(buf[o], 1, a);\n      buf[o + 1] = mix(buf[o + 1], 1, a);\n      buf[o + 2] = mix(buf[o + 2], 1, a);\n    });\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(255 * min(1, buf[o])), round(255 * min(1, buf[o + 1])), round(255 * min(1, buf[o + 2])));\n}\n","lonely-runner":"// ===== Patternflow pattern =====\n// Title:   Lonely Runner\n// Family:  rhythm\n// Idea:    Runners at distinct whole-number speeds climb side by side round a track that is the panel's 128 rows wrapped top to bottom, each a bold bar in its own lane carrying a zone of 128/k rows either way, and whenever no other runner is inside its zone the runner is lonely, so its zone lights up and its bar burns white; with speeds 1 to k they all go lonely together, equally spaced round the track, and with scattered speeds the flares come one by one at odd times.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the lonely runner conjecture (Jörg M. Wills, 1967; Thomas Cusick, 1973), proven for up to seven runners by Javier Barajas and Oriol Serra (2008), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Runners=3..8, Scatter=0..1\n//\n// Knob 1: Hue. Turns the runners' colours round the wheel together: at 0 three runners are cyan, magenta and yellow; at 0.25 violet, orange and green; at 0.5 red, green and blue. With more runners the colours sit closer together round the same wheel.\n// Knob 2: Speed. At 2 the fastest runner laps in 1.8 seconds; with speeds 1, 2 and 3 the slowest laps in 5.4, and then all three are back on the line together and the race goes round again. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Runners. How many run, 3 to 8, each in its own lane, and the zone shrinks to 128/k rows either way: 43 rows with three, 16 with eight. Turning it starts a new race from the line at the bottom. With eight at speeds 1 to 8 the first lonely moment is a staircase of all eight bars, 1.8 seconds in.\n// Knob 4: Scatter. Below 0.2 the speeds are 1, 2, ... k, the case where all the runners go lonely together. In four steps up to 1 they become k different whole numbers drawn from 1 to k+3, k+6, k+9 and k+12, and the lonely moments break apart into single flares, some held for a second or more. Each step starts a new race.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The fastest runner's lap, in story seconds (one a second at Speed 2). The\n// slowest runner's lap is the whole race, since every speed is a whole\n// number: at its end all of them are back on the line together.\nconst LAP_FAST = 1.8;\n// A runner's bar, in rows, and the row its middle starts on: the bars stand\n// on the bottom edge at the start.\nconst BAR = 14, START = H - BAR / 2;\n// Lonely means no other runner nearer than 1/k of a lap, either way round.\n// With speeds 1..k the nearest neighbours reach exactly 1/k for a single\n// instant, which no frame would ever land on, so the check runs at 24\n// moments inside each frame and allows half an LED row (1/256 of a lap).\nconst SUB = 24, TOL = 1 / 256;\n// How long a flare takes to fade after the runner stops being lonely.\nconst FADE = 0.35;\n// The tail behind a bar is this many story seconds of its running.\nconst TAIL = 0.25;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, k: 0, level: -1,\n    v: [], pos: new Float32Array(8), flare: new Float32Array(8), lonely: new Uint8Array(8),\n    lane: new Int8Array(W), shade: new Float32Array(W), col: [], colHue: NaN, colK: 0,\n  };\n}\n\n// A small fixed hash, so each Scatter step draws the same speeds every time.\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The speeds for k runners at Scatter step L: 1..k at step 0, otherwise k\n// distinct whole numbers from 1..k+3L, shuffled by a fixed seed and sorted\n// so the slowest runs in the left lane.\nfunction speeds(k, L) {\n  const pool = [];\n  for (let i = 1; i \u003c= k + 3 * L; i++) pool.push(i);\n  if (L > 0)\n    for (let i = pool.length - 1; i > 0; i--) {\n      const j = floor(hash(k * 101 + L * 7 + i * 13) * (i + 1));\n      const tmp = pool[i];\n      pool[i] = pool[j];\n      pool[j] = tmp;\n    }\n  return pool.slice(0, k).sort((a, b) => a - b);\n}\n\n// A new race: lanes for k runners with a dark LED between them, and every\n// runner back on the line.\nfunction restart(S, k, L) {\n  S.k = k;\n  S.level = L;\n  S.v = speeds(k, L);\n  S.t = 0;\n  S.flare.fill(0);\n  for (let x = 0; x \u003c W; x++) {\n    const j = floor((x * k) / W);\n    const edge = round(((j + 1) * W) / k) - 1;\n    S.lane[x] = x === edge && j \u003c k - 1 ? -1 : j;\n    const x0 = round((j * W) / k), u = (x - x0 + 0.5) / (edge - x0 + 1);\n    S.shade[x] = 0.62 + 0.38 * (1 - (2 * u - 0.7) ** 2 / 1.69);\n  }\n}\n\n// Nearest distance from runner i to any other, as a share of a lap, for\n// the race at story time t.\nfunction nearest(S, i, t, P) {\n  const pi = (S.v[i] * t) / P;\n  let d = 1;\n  for (let j = 0; j \u003c S.k; j++) {\n    if (j === i) continue;\n    let g = pi - (S.v[j] * t) / P;\n    g -= floor(g);\n    d = min(d, g, 1 - g);\n  }\n  return d;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const k = cl(round(kv[2]), 3, 8), L = min(4, floor(cl(kv[3], 0, 1) * 5));\n  if (k !== S.k || L !== S.level) restart(S, k, L);\n  const g = (d * S.speed) / 2, P = LAP_FAST * S.v[k - 1], t0 = S.t;\n  S.t += g;\n  const need = 1 / k - TOL;\n  for (let i = 0; i \u003c k; i++) {\n    let lonely = 0;\n    for (let s = 1; s \u003c= SUB && !lonely; s++) if (nearest(S, i, t0 + (g * s) / SUB, P) >= need) lonely = 1;\n    S.lonely[i] = lonely;\n    S.flare[i] = lonely ? 1 : S.flare[i] * exp(-g / FADE);\n    const p = (S.v[i] * S.t) / P;\n    S.pos[i] = p - floor(p);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.k) return;\n  const k = S.k;\n  if (S.colHue !== S.hue || S.colK !== k) {\n    S.col = [];\n    for (let i = 0; i \u003c k; i++) S.col.push(hsv(0.5 + S.hue + i / k, 0.9, 1));\n    S.colHue = S.hue;\n    S.colK = k;\n  }\n  const R = H / k, half = BAR / 2;\n  // Each runner's middle row; it climbs, so the row falls as the lap goes on.\n  const c = [];\n  for (let i = 0; i \u003c k; i++) c.push(START - S.pos[i] * H);\n  for (let y = 0; y \u003c H; y++) {\n    // Signed distance in rows from each runner, the short way round.\n    const dy = [];\n    for (let i = 0; i \u003c k; i++) {\n      let e = y + 0.5 - c[i];\n      e -= H * floor(e / H + 0.5);\n      dy.push(e);\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const ln = S.lane[x];\n      let r = 0, gg = 0, b = 0;\n      for (let i = 0; i \u003c k; i++) {\n        const e = dy[i], a = abs(e), cc = S.col[i], f = S.flare[i];\n        let v = 0;\n        if (ln === i) {\n          // The runner's own lane. Its zone shows faintly; while the runner\n          // is lonely it lights up, brightest at the runner, its two edges\n          // 128/k rows away drawn as lines. With speeds 1..k those edges\n          // land exactly on the neighbours' lines: the case is tight.\n          if (a \u003c R) {\n            v = 0.1;\n            if (f > 0.02) v = max(v, f * (a > R - 1 ? 0.9 : 0.15 + 0.5 * (1 - a / R) ** 1.5));\n          }\n          // A tail below the bar, as long as a quarter second of its running.\n          const tail = TAIL * S.v[i] * (H / (LAP_FAST * S.v[k - 1]));\n          if (e > half && e \u003c half + tail) v = max(v, 0.7 * (1 - (e - half) / tail) ** 2);\n          if (a \u003c half) v = 1;\n          else if (a \u003c half + 1) v = max(v, 1 - (a - half));\n          // Lit from the left, so a lane reads as a rounded rod.\n          v *= S.shade[x];\n        } else if (a \u003c 0.5) {\n          // Every runner draws a line across the other lanes at its middle,\n          // so in each lane you can see who is inside that runner's zone.\n          v = 0.55;\n        }\n        // A lonely runner's bar burns white-hot for a beat.\n        const w = ln === i && a \u003c half + 1 ? 0.55 * f * v : 0;\n        r += cc[0] * v + w;\n        gg += cc[1] * v + w;\n        b += cc[2] * v + w;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, gg)), round(255 * min(1, b)));\n    }\n  }\n}\n","oloid":"// ===== Patternflow pattern =====\n// Title:   Oloid\n// Family:  space\n// Idea:    An oloid, the hull of two circles each through the other's centre, rolls toward you down a dark floor in its swaying wobble, touching the floor along one straight ruling at a time, and leaves behind it the print of its own surface unrolled flat: the half round each circle in its own colour, the two locked together in a serpentine track that recedes up the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the oloid (Paul Schatz, 1929), rolled on its development as Hans Dirnböck and Hellmuth Stachel unrolled it (1997), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Fade=0..1\n//\n// Knob 1: Hue. Turns both halves round the wheel together, 0.38 of a turn apart: at 0 the half round one circle is azure and the half round the other pink; at 0.15 violet and orange; at 0.45 red and green; at 0.6 yellow and cyan; at 0.8 green and violet. Orange and yellow are printed brighter so they never dim to brown.\n// Knob 2: Speed. At 2 the oloid rolls its whole surface over the floor once in 5 seconds, coming 4.8 circle radii toward you and swaying 0.28 radii either way twice on the way. At 0.2 it rolls ten times slower, at 3 half as fast again.\n// Knob 3: Tilt. The camera's angle over the floor: at 0 it looks down at 53 degrees from in front, and the top of the panel is the floor five rolls back, where the track has narrowed to a third of its width; at 1 it looks straight down, the oloid tumbles at the foot of the panel and the track is a flat band of two serpents locked together.\n// Knob 4: Fade. How long the print stays on the floor: at 0.06 it loses only a third of its brightness over five rolls and so runs up to the top of the panel, dimmed a little more by distance; at 0.5 it is down to a third two rolls back; at 1 it fades within half a roll, a short tongue of print behind the oloid.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, acos, exp, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// How near a hue is to orange and yellow, 0 to 1.\nconst warm = (h) => max(0, 1 - abs(h - floor(h) - 0.11) / 0.13);\nconst sub = (p, q) => [p[0] - q[0], p[1] - q[1], p[2] - q[2]];\nconst dot = (p, q) => p[0] * q[0] + p[1] * q[1] + p[2] * q[2];\nconst crs = (p, q) => [p[1] * q[2] - p[2] * q[1], p[2] * q[0] - p[0] * q[2], p[0] * q[1] - p[1] * q[0]];\nconst nrm = (p) => {\n  const l = hypot(p[0], p[1], p[2]) || 1;\n  return [p[0] / l, p[1] / l, p[2] / l];\n};\n\n// The two circles, radius 1. A lies in the xy-plane round the origin and B\n// in the xz-plane round (1, 0, 0), so each passes through the other's\n// centre. Both angles count from the point farthest from the other circle.\nconst cA = (a) => [-cos(a), sin(a), 0];\nconst cB = (b) => [1 + cos(b), 0, sin(b)];\n// A(a) and B(b) span a ruling of the hull when the tangent plane at A(a)\n// also touches B at B(b). With d = B - A and the two tangents, that is\n// det(tA, tB, d) = 0, which works out to cos a + cos b + cos a cos b = 0:\n// for |b| up to 2 pi / 3 it gives one |a| up to 2 pi / 3, and the four\n// signs are the four quarters of the surface. Every ruling is sqrt 3 long.\nconst partner = (u) => acos(cl(-cos(u) / (1 + cos(u)), -1, 1));\n// The closed loop of rulings, s from 0 to 8. Each eighth steps the angle\n// that moves fastest there, so the fans round the ends of the arcs, where\n// one end of the ruling barely moves, are spaced as finely as the rest.\nfunction ruling(s) {\n  const sg = s >= 4 ? -1 : 1;\n  if (s >= 4) s -= 4;\n  let a, b;\n  if (s \u003c 1) (a = (PI / 2) * s), (b = partner(a));\n  else if (s \u003c 2) (b = (PI / 2) * (2 - s)), (a = partner(b));\n  else if (s \u003c 3) (b = (-PI / 2) * (s - 2)), (a = partner(b));\n  else (a = (PI / 2) * (4 - s)), (b = -partner(a));\n  return [sg * a, sg * b];\n}\n\n// Rulings per eighth of the loop for the roll, and every RS-th of them is\n// an edge of the mesh drawn.\nconst M = 24, R = 8 * M, RS = 2, RM = R / RS;\n// The centroid, by the symmetry that swaps the circles.\nconst CEN = [0.5, 0, 0];\n// The camera: distance from the oloid, focal length in LEDs, and the row the\n// oloid sits on, low so the track has room above it.\nconst CAMD = 7.4, FOC = 118, CY0 = 98;\n// The light, a unit vector toward it: above, to the left, from the camera's side.\nconst LIGHT = nrm([-0.5, -0.55, 0.75]);\n// The print on the floor is kept on a grid of CS radii over one roll.\nconst CS = 0.04, GX0 = -0.3, GNX = 96;\n// One roll of the whole surface, in seconds at Speed 2.\nconst ROLL = 5;\n\nexport function setup(params) {\n  // The rulings, their outward normals, and the development: unroll the\n  // strip between neighbouring rulings into the plane, two triangles at a\n  // time with every edge length kept, each new point on the side of the old\n  // edge it lies on in space (the normal points down into the floor, so the\n  // turn flips).\n  const rA = [], rB = [], rn = [], a2 = [], b2 = [];\n  for (let i = 0; i \u003c= R; i++) {\n    const [a, b] = ruling((i / M) % 8), A = cA(a), B = cB(b), d = sub(B, A);\n    // The tangents can be parallel (at a = b = pi / 2), so the normal comes\n    // from the ruling and whichever tangent is further from it.\n    const c1 = crs(d, [sin(a), cos(a), 0]), c2 = crs(d, [-sin(b), 0, cos(b)]);\n    let n = nrm(dot(c1, c1) > dot(c2, c2) ? c1 : c2);\n    if (dot(n, sub([(A[0] + B[0]) / 2, A[1] / 2, B[2] / 2], CEN)) \u003c 0) n = [-n[0], -n[1], -n[2]];\n    rA.push(A), rB.push(B), rn.push(n);\n  }\n  const place = (o, d1, p, d2, sg) => {\n    const dx = p[0] - o[0], dy = p[1] - o[1], D = hypot(dx, dy), x = (d1 * d1 - d2 * d2 + D * D) / (2 * D), h = sqrt(max(0, d1 * d1 - x * x));\n    return [o[0] + (x * dx + sg * h * dy) / D, o[1] + (x * dy - sg * h * dx) / D];\n  };\n  const turn = (o, p, q, n) => (dot(crs(sub(p, o), sub(q, o)), n) \u003c 0 ? -1 : 1);\n  const len = (p, q) => hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);\n  a2.push([0, 0]), b2.push([sqrt(3), 0]);\n  for (let i = 0; i \u003c R; i++) {\n    const n = rn[i].map((v, k) => v + rn[i + 1][k]);\n    const b = place(a2[i], len(rB[i + 1], rA[i]), b2[i], len(rB[i + 1], rB[i]), turn(rA[i], rB[i], rB[i + 1], n));\n    b2.push(b);\n    a2.push(place(a2[i], len(rA[i + 1], rA[i]), b, len(rA[i + 1], rB[i + 1]), turn(rA[i], rB[i + 1], rA[i + 1], n)));\n  }\n  // One roll moves the print on by T: 4.836 radii straight down -y, with no\n  // turn (checked: under 1e-7 degrees), so the oloid rolls in a straight line.\n  const T = [a2[R][0] - a2[0][0], a2[R][1] - a2[0][1]];\n  // The pose with ruling i on the floor: the ruling laid on its developed\n  // place, the tangent plane along it on the floor, as a rotation (a\n  // quaternion) and where the centroid lands.\n  const q = new Float64Array((R + 1) * 4), cw = new Float64Array((R + 1) * 3), cum = new Float64Array(R + 1);\n  for (let i = 0; i \u003c= R; i++) {\n    const e1 = nrm(sub(rB[i], rA[i])), e3 = rn[i], e2 = crs(e3, e1);\n    const f = nrm([b2[i][0] - a2[i][0], b2[i][1] - a2[i][1], 0]), g1 = f, g2 = [f[1], -f[0], 0], g3 = [0, 0, -1];\n    const m = [0, 1, 2].map((r) => [0, 1, 2].map((c) => g1[r] * e1[c] + g2[r] * e2[c] + g3[r] * e3[c]));\n    const o = i * 4, tr = m[0][0] + m[1][1] + m[2][2];\n    if (tr > 0) {\n      const s = 2 * sqrt(tr + 1);\n      (q[o] = s / 4), (q[o + 1] = (m[2][1] - m[1][2]) / s), (q[o + 2] = (m[0][2] - m[2][0]) / s), (q[o + 3] = (m[1][0] - m[0][1]) / s);\n    } else {\n      const k = m[0][0] > m[1][1] && m[0][0] > m[2][2] ? 0 : m[1][1] > m[2][2] ? 1 : 2, k1 = (k + 1) % 3, k2 = (k + 2) % 3;\n      const s = 2 * sqrt(1 + m[k][k] - m[k1][k1] - m[k2][k2]);\n      q[o] = (m[k2][k1] - m[k1][k2]) / s;\n      q[o + 1 + k] = s / 4;\n      q[o + 1 + k1] = (m[k1][k] + m[k][k1]) / s;\n      q[o + 1 + k2] = (m[k2][k] + m[k][k2]) / s;\n    }\n    if (i > 0 && q[o] * q[o - 4] + q[o + 1] * q[o - 3] + q[o + 2] * q[o - 2] + q[o + 3] * q[o - 1] \u003c 0) for (let j = 0; j \u003c 4; j++) q[o + j] = -q[o + j];\n    const c = sub(CEN, rA[i]);\n    for (let r = 0; r \u003c 3; r++) cw[i * 3 + r] = m[r][0] * c[0] + m[r][1] * c[1] + m[r][2] * c[2] + (r \u003c 2 ? a2[i][r] : 0);\n    // The roll is timed by the centroid's path: it moves at an even speed.\n    if (i > 0) cum[i] = cum[i - 1] + hypot(cw[i * 3] - cw[i * 3 - 3], cw[i * 3 + 1] - cw[i * 3 - 2], cw[i * 3 + 2] - cw[i * 3 - 1]);\n  }\n  let xmid = 0;\n  for (let i = 0; i \u003c R; i++) xmid += cw[i * 3] / R;\n  // The mesh: each drawn ruling as A, its midpoint and B, so each strip is\n  // a quad on the A half and a quad on the B half; the normal is the same\n  // all along a ruling, as on any developable surface.\n  const mesh = new Float64Array((RM + 1) * 9), mn = new Float64Array(RM * 3);\n  for (let j = 0; j \u003c= RM; j++) {\n    const A = rA[j * RS], B = rB[j * RS];\n    for (let k = 0; k \u003c 3; k++) (mesh[j * 9 + k] = A[k]), (mesh[j * 9 + 3 + k] = (A[k] + B[k]) / 2), (mesh[j * 9 + 6 + k] = B[k]);\n    if (j \u003c RM) {\n      const n = nrm(rn[j * RS].map((v, k) => v + rn[j * RS + RS][k]));\n      for (let k = 0; k \u003c 3; k++) mn[j * 3 + k] = n[k];\n    }\n  }\n  // The rims: the two arcs of 240 degrees that are edges of the hull.\n  const ARC = 48, arcs = new Float64Array(2 * (ARC + 1) * 3);\n  for (let c = 0; c \u003c 2; c++)\n    for (let j = 0; j \u003c= ARC; j++) {\n      const p = (c ? cB : cA)(((j / ARC) * 2 - 1) * ((2 * PI) / 3));\n      for (let k = 0; k \u003c 3; k++) arcs[(c * (ARC + 1) + j) * 3 + k] = p[k];\n    }\n  // The print of one roll on the floor grid: strip i's A half codes 2i,\n  // its B half 2i + 1. A strip that pokes past either end of the roll is\n  // filed at the other end, marked as from the roll before or after.\n  const P = -T[1], GNY = ceil(P / CS), grid = new Int16Array(GNX * GNY).fill(-1), wrap = new Int8Array(GNX * GNY);\n  const fill = (pts, code) => {\n    const xs = pts.map((p) => p[0]), ys = pts.map((p) => -p[1]);\n    const x0 = floor((min(...xs) - GX0) / CS), x1 = ceil((max(...xs) - GX0) / CS), y0 = floor(min(...ys) / CS), y1 = ceil(max(...ys) / CS);\n    for (let gy = y0; gy \u003c= y1; gy++)\n      for (let gx = max(0, x0); gx \u003c= min(GNX - 1, x1); gx++) {\n        const px = GX0 + (gx + 0.5) * CS, py = -(gy + 0.5) * CS;\n        let inside = true, sgn = 0;\n        for (let k = 0; k \u003c pts.length && inside; k++) {\n          const p = pts[k], o = pts[(k + 1) % pts.length], c = (o[0] - p[0]) * (py - p[1]) - (o[1] - p[1]) * (px - p[0]);\n          if (abs(c) \u003c 1e-12) continue;\n          if (sgn === 0) sgn = c > 0 ? 1 : -1;\n          else if ((c > 0 ? 1 : -1) !== sgn) inside = false;\n        }\n        if (!inside) continue;\n        const w = gy \u003c 0 ? 1 : gy >= GNY ? -1 : 0, row = gy + w * GNY;\n        grid[row * GNX + gx] = code;\n        wrap[row * GNX + gx] = w;\n      }\n  };\n  for (let i = 0; i \u003c R; i++) {\n    const m0 = [(a2[i][0] + b2[i][0]) / 2, (a2[i][1] + b2[i][1]) / 2], m1 = [(a2[i + 1][0] + b2[i + 1][0]) / 2, (a2[i + 1][1] + b2[i + 1][1]) / 2];\n    fill([a2[i], m0, m1, a2[i + 1]], 2 * i);\n    fill([m0, b2[i], b2[i + 1], m1], 2 * i + 1);\n  }\n  params.s = {\n    hue: 0, speed: 2, tilt: 0, fade: 0.06, dist: 0, U: 0,\n    q, cw, cum, T, P, GNY, grid, wrap, xmid, mesh, mn, arcs, ARC,\n    rot: new Float64Array(9), pos: new Float64Array(3), cam: new Float64Array(12),\n    vw: new Float64Array((RM + 1) * 9), vs: new Float64Array((RM + 1) * 9), aw: new Float64Array(arcs.length),\n    zb: new Float32Array(N), rgb: new Float32Array(N * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tilt = cl(k[2], 0, 1);\n  S.fade = cl(k[3], 0, 1);\n  const Lc = S.cum[R];\n  S.dist += ((d * S.speed) / 2) * (Lc / ROLL);\n  // Where the roll is: ruling i and the fraction f on to the next, found by\n  // the centroid's path length within this roll.\n  const kc = floor(S.dist / Lc), u = S.dist - kc * Lc, cum = S.cum;\n  let lo = 0, hi = R;\n  while (hi - lo > 1) {\n    const m = (lo + hi) >> 1;\n    if (cum[m] \u003c= u) lo = m;\n    else hi = m;\n  }\n  const f = cl((u - cum[lo]) / (cum[lo + 1] - cum[lo] || 1), 0, 1);\n  S.U = kc * R + lo + f;\n  // The pose between rulings lo and lo + 1: the rotations blended and\n  // renormalised, the centroid moved along, and kc rolls added on.\n  const q = S.q, o = lo * 4;\n  let w = mix(q[o], q[o + 4], f), x = mix(q[o + 1], q[o + 5], f), y = mix(q[o + 2], q[o + 6], f), z = mix(q[o + 3], q[o + 7], f);\n  const l = hypot(w, x, y, z);\n  (w /= l), (x /= l), (y /= l), (z /= l);\n  const m = S.rot;\n  m[0] = 1 - 2 * (y * y + z * z), m[1] = 2 * (x * y - w * z), m[2] = 2 * (x * z + w * y);\n  m[3] = 2 * (x * y + w * z), m[4] = 1 - 2 * (x * x + z * z), m[5] = 2 * (y * z - w * x);\n  m[6] = 2 * (x * z - w * y), m[7] = 2 * (y * z + w * x), m[8] = 1 - 2 * (x * x + y * y);\n  const cw = S.cw;\n  for (let r = 0; r \u003c 3; r++) {\n    const c = mix(cw[lo * 3 + r], cw[lo * 3 + 3 + r], f) + (r \u003c 2 ? kc * S.T[r] : 0);\n    S.pos[r] = c - (m[r * 3] * CEN[0] + m[r * 3 + 1] * CEN[1] + m[r * 3 + 2] * CEN[2]);\n  }\n  // The camera follows the centroid down the track and keeps to the middle\n  // of its sway, so the sway shows; it sits in front, looking back up the\n  // track, from 53 degrees over the floor at Tilt 0 to straight down at 1.\n  const pitch = mix(0.92, PI / 2 - 1e-4, S.tilt), cy = mix(cw[lo * 3 + 1], cw[lo * 3 + 4], f) + kc * S.T[1];\n  const C = S.cam;\n  C[0] = S.xmid;\n  C[1] = cy - CAMD * cos(pitch);\n  C[2] = 0.6 + CAMD * sin(pitch);\n  // Forward, right and up.\n  (C[3] = 0), (C[4] = cos(pitch)), (C[5] = -sin(pitch));\n  (C[6] = 1), (C[7] = 0), (C[8] = 0);\n  (C[9] = 0), (C[10] = sin(pitch)), (C[11] = cos(pitch));\n}\n\n// Fill a screen triangle into the depth buffer, nearest wins: iz is 1 over\n// the depth, interpolated across the screen as it is linear there.\nfunction tri(S, ax, ay, az, bx, by, bz, cx, cy, cz, r, g, b) {\n  const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(area) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, ceil(max(ay, by, cy)));\n  const zb = S.zb, rgb = S.rgb;\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const w0 = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / area, w1 = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / area, w2 = 1 - w0 - w1;\n      if (w0 \u003c 0 || w1 \u003c 0 || w2 \u003c 0) continue;\n      const iz = w0 * az + w1 * bz + w2 * cz, i = y * W + x;\n      if (iz \u003c= zb[i]) continue;\n      zb[i] = iz;\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rot: m, pos, cam: C, zb, rgb, grid, wrap, GNY, P } = S;\n  // The two halves' colours. Orange and yellow dimmed read brown and olive,\n  // so a half that comes round to them is printed brighter and shaded less deep.\n  const hA = 0.56 + S.hue, hB = 0.94 + S.hue, wA = warm(hA), wB = warm(hB);\n  const colA = hsv(hA, 0.78, 1), colB = hsv(hB, 0.72, 1);\n  const pvA = 0.62 + 0.3 * wA, pvB = 0.62 + 0.3 * wB, loA = 0.3 + 0.25 * wA, loB = 0.3 + 0.25 * wB;\n  // World to screen: [x, y, 1 / depth].\n  const proj = (wx, wy, wz, out, o) => {\n    const vx = wx - C[0], vy = wy - C[1], vz = wz - C[2], zc = vx * C[3] + vy * C[4] + vz * C[5];\n    out[o] = 32 + (FOC * (vx * C[6] + vy * C[7] + vz * C[8])) / zc;\n    out[o + 1] = CY0 - (FOC * (vx * C[9] + vy * C[10] + vz * C[11])) / zc;\n    out[o + 2] = 1 / zc;\n  };\n  const toWorld = (src, so, out, o) => {\n    const x = src[so], y = src[so + 1], z = src[so + 2];\n    out[o] = m[0] * x + m[1] * y + m[2] * z + pos[0];\n    out[o + 1] = m[3] * x + m[4] * y + m[5] * z + pos[1];\n    out[o + 2] = m[6] * x + m[7] * y + m[8] * z + pos[2];\n  };\n  // The floor, ray by ray: where each LED's ray meets it, and what of the\n  // print lies there. A strip of roll kc was printed when the roll passed\n  // it, so its age is how many rulings ago that was.\n  const fade = R * 0.25 * 60 ** (1 - S.fade);\n  for (let py = 0; py \u003c H; py++) {\n    const vy = (CY0 - py - 0.5) / FOC;\n    for (let px = 0; px \u003c W; px++) {\n      const i = py * W + px, vx = (px + 0.5 - 32) / FOC;\n      zb[i] = 0;\n      const dx = C[3] + vx * C[6] + vy * C[9], dy = C[4] + vx * C[7] + vy * C[10], dz = C[5] + vx * C[8] + vy * C[11];\n      let r = 0.025, g = 0.012, b = 0.06;\n      if (dz \u003c 0) {\n        const t = -C[2] / dz, fx = C[0] + t * dx, fy = C[1] + t * dy;\n        const yy = -fy, kc = floor(yy / P), gy = floor((yy - kc * P) / CS), gx = floor((fx - GX0) / CS);\n        if (gx >= 0 && gx \u003c GNX && gy >= 0 && gy \u003c GNY) {\n          const c = grid[gy * GNX + gx];\n          if (c >= 0) {\n            const age = S.U - ((kc + wrap[gy * GNX + gx]) * R + (c >> 1) + 0.5);\n            if (age > 0) {\n              const v = (c & 1 ? pvB : pvA) * exp(-age / fade) * cl(1.25 - t / 40, 0.25, 1), col = c & 1 ? colB : colA;\n              (r += col[0] * v), (g += col[1] * v), (b += col[2] * v);\n            }\n          }\n        }\n      }\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n  }\n  // The body: every mesh point to the world and the screen, then each quad\n  // facing the camera as two triangles, shaded by its ruling's normal.\n  const { mesh, mn, vw, vs } = S;\n  for (let j = 0; j \u003c (RM + 1) * 3; j++) {\n    toWorld(mesh, j * 3, vw, j * 3);\n    proj(vw[j * 3], vw[j * 3 + 1], vw[j * 3 + 2], vs, j * 3);\n  }\n  for (let j = 0; j \u003c RM; j++) {\n    const nx = m[0] * mn[j * 3] + m[1] * mn[j * 3 + 1] + m[2] * mn[j * 3 + 2];\n    const ny = m[3] * mn[j * 3] + m[4] * mn[j * 3 + 1] + m[5] * mn[j * 3 + 2];\n    const nz = m[6] * mn[j * 3] + m[7] * mn[j * 3 + 1] + m[8] * mn[j * 3 + 2];\n    const o = j * 9 + 3;\n    if (nx * (vw[o] - C[0]) + ny * (vw[o + 1] - C[1]) + nz * (vw[o + 2] - C[2]) > 0.02) continue;\n    const lit = max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]);\n    for (let h = 0; h \u003c 2; h++) {\n      const col = h ? colB : colA, lo = h ? loB : loA, sh = lo + (1 - lo) * lit, p = j * 9 + h * 3, q = p + 9;\n      tri(S, vs[p], vs[p + 1], vs[p + 2], vs[p + 3], vs[p + 4], vs[p + 5], vs[q + 3], vs[q + 4], vs[q + 5], col[0] * sh, col[1] * sh, col[2] * sh);\n      tri(S, vs[p], vs[p + 1], vs[p + 2], vs[q + 3], vs[q + 4], vs[q + 5], vs[q], vs[q + 1], vs[q + 2], col[0] * sh, col[1] * sh, col[2] * sh);\n    }\n  }\n  // The rims, the two circles' arcs, drawn where nothing nearer hides them.\n  const { arcs, aw, ARC } = S;\n  for (let j = 0; j \u003c arcs.length / 3; j++) toWorld(arcs, j * 3, aw, j * 3);\n  const a = [0, 0, 0], bq = [0, 0, 0];\n  for (let c = 0; c \u003c 2; c++) {\n    const col = c ? colB : colA;\n    for (let j = 0; j \u003c ARC; j++) {\n      const o = (c * (ARC + 1) + j) * 3;\n      proj(aw[o], aw[o + 1], aw[o + 2], a, 0);\n      proj(aw[o + 3], aw[o + 4], aw[o + 5], bq, 0);\n      const steps = ceil(max(abs(bq[0] - a[0]), abs(bq[1] - a[1])) * 2) + 1;\n      for (let s = 0; s \u003c= steps; s++) {\n        const t = s / steps, x = floor(mix(a[0], bq[0], t)), y = floor(mix(a[1], bq[1], t));\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const i = y * W + x, iz = mix(a[2], bq[2], t);\n        if (iz \u003c zb[i] * 0.985) continue;\n        (rgb[i * 3] = 0.55 + 0.45 * col[0]), (rgb[i * 3 + 1] = 0.55 + 0.45 * col[1]), (rgb[i * 3 + 2] = 0.55 + 0.45 * col[2]);\n      }\n    }\n  }\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","pumpkin-carving":"// ===== Patternflow pattern =====\n// Title:   Pumpkin Carving\n// Family:  halloween\n// Idea:    A big orange pumpkin on a dark table at night: a glinting knife saws out two eyes, a nose and a jagged grin piece by piece, each pushed in to drop into the dark inside; a match flares, the candle catches and the face burns gold and flickers, its light spilling over the table, then it gutters out and the pumpkin turns to bring round fresh skin for a different face.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Warmth=-1..1, Speed=0.2..3, Fierce=0..1, Spill=0..1\n//\n// Knob 1: Warmth. The pumpkin and its candlelight together: at 0 a bright orange pumpkin burning gold; at -1 a red one burning orange; at 1 a golden yellow one, which the candle turns orange round a pale yellow face. The night and the stem stay as they are.\n// Knob 2: Speed. At 2 a calm face takes about 13 seconds: 6 to carve, 0.9 for the match, 3.5 burning, 0.9 to gutter out and 1.8 to turn; a fierce face's long grin adds 2 more to the carving. At 0.2 the story runs ten times slower, at 3 half as fast again; the flame flickers at its own pace.\n// Knob 3: Fierce. The faces the knife chooses, each one new: at 0 upright triangle eyes and a smile with two or three square teeth; at 1 bigger eyes slanted down to the nose and a wider, deeper grin with seven or eight pointed teeth above and fangs standing up between them, which appear past 0.3.\n// Knob 4: Spill. How far the candlelight carries: at 0.06 a pool of gold, orange and crimson rings 38 LEDs either side and 16 rows down the table, and a crimson rim three LEDs round the pumpkin; at 1 the pool covers the table and the glow reaches 18 to 20 LEDs into the night.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, hypot, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (t) => t * t * (3 - 2 * t);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The pumpkin, a spheroid with ten ribs: centre, half-width, half-height;\n// the table's back edge; the candle flame's x, seen only through the holes.\nconst CX = 32, CY = 68, PA = 29.5, PB = 26, RIBS = 10, TABLE = 88, FX = 32;\n// The moon's light on the skin, a unit vector toward it: upper left, in front.\nconst LX = -0.5, LY = -0.62, LZ = 0.6;\n// Where the pumpkin stands on the table.\nconst BASE = CY + PB;\n// The story in seconds at Speed 2: the knife moves to a piece, saws round it\n// at KNIFE LEDs a second and pushes it in; match, burn, gutter, half turn.\nconst TRAVEL = 0.22, KNIFE = 60, PUSH = 0.45, MATCH = 0.9, BURN = 3.5, OUT = 0.9, TURN = 1.8, REST = 0.3;\n// Across a rib, groove to groove in 256 steps: its bulge and the lean of its normal.\nconst RIB_B = new Float32Array(256), RIB_L = new Float32Array(256);\nfor (let i = 0; i \u003c 256; i++) (RIB_B[i] = sin((PI * (i + 0.5)) / 256)), (RIB_L[i] = -0.55 * cos((PI * (i + 0.5)) / 256));\n// The knife: blade and handle in LEDs, pointing up and right as a right hand holds it.\nconst BLADE = 15, HANDLE = 10, KDX = 0.55, KDY = -0.835;\nconst BOLSTER = [1, 0.95, 0.7, 1, 0.95, 0.7, 1, 0.95, 0.7], HANDLE_C = [0.5, 0.3, 0.62, 0.32, 0.12, 0.42, 0.18, 0.06, 0.26];\n\n// A new face in head-on panel LEDs: left eye, right eye, nose, mouth, each a\n// polygon the knife saws round in turn. Fierce scowls the eyes and deepens and\n// multiplies the teeth; the rest is chance, so no two faces are the same.\nfunction makeFace(fierce) {\n  const R = Math.random, f = fierce, pieces = [];\n  const ex = 10 + 2.5 * R(), ey = CY - 9 - 2 * R(), bw = 9 + 3 * R() + 3 * f, eh = 7 + 3 * R() + 2 * f, ap = (R() - 0.5) * 3;\n  for (const sd of [-1, 1]) {\n    // q runs from the outer corner to the nose. Calm, the triangle stands on\n    // its base; fierce, its top runs down to the inner corner.\n    const calm = [[-bw / 2, eh / 2], [bw / 2, eh / 2], [ap, -eh / 2]];\n    const mad = [[-bw / 2, eh / 2 + 0.5], [bw / 2 + 2, eh / 2 - 1.5], [-bw / 2 + 1, -eh / 2 - 1.5]];\n    pieces.push(calm.map(([q, y], i) => [CX + sd * ex - sd * mix(q, mad[i][0], f), ey + mix(y, mad[i][1], f)]));\n  }\n  const nw = 5 + 2 * R(), nh = 4.5 + 2 * R(), up = R() > 0.25 + 0.4 * f ? 1 : -1;\n  pieces.push([[CX - nw / 2, CY + 1 + (up * nh) / 2], [CX + nw / 2, CY + 1 + (up * nh) / 2], [CX, CY + 1 - (up * nh) / 2]]);\n  // The mouth: a smile between two curves, its top edge sawn into teeth,\n  // square at Fierce 0 and pointed at 1, and past 0.3 its bottom into fangs.\n  const mw = 15 + 4 * R() + 4 * f, y0 = CY + 8 + R(), ct = 3 + 2.5 * R(), th0 = 3.5, cb = ct + 5 + 2 * R() + 4 * f;\n  const nt = round(2 + 5 * f + R() * 1.4), nb = f > 0.3 ? max(1, nt - 1) : 0, sharp = 0.12 + 0.38 * f;\n  const top = (u) => y0 + ct * (1 - u * u), bot = (u) => y0 + th0 + cb * (1 - u * u);\n  const edge = (n, yf, dep, dir) => {\n    const pts = [], S = 2 * n + 1, nq = max(2, Math.ceil(10 / S));\n    for (let j = 0; j \u003c S; j++) {\n      const u0 = -1 + (2 * j) / S, u1 = -1 + (2 * (j + 1)) / S;\n      if (j % 2 === 0) for (let q = 0; q \u003c nq; q++) {\n        const u = u0 + ((u1 - u0) * q) / nq;\n        pts.push([CX + mw * u, yf(u)]);\n      }\n      else {\n        const ua = mix(u0, u1, sharp), ub = mix(u1, u0, sharp);\n        pts.push([CX + mw * u0, yf(u0)], [CX + mw * ua, yf(ua) + dir * dep(ua)]);\n        if (ub > ua + 1e-6) pts.push([CX + mw * ub, yf(ub) + dir * dep(ub)]);\n      }\n    }\n    pts.push([CX + mw, yf(1)]);\n    return pts;\n  };\n  const gap = (u) => bot(u) - top(u), deepT = 0.45 + 0.1 * f, deepB = 0.3 * f;\n  const mouth = edge(nt, top, (u) => deepT * gap(u), 1).concat(edge(nb, bot, (u) => deepB * gap(u), -1).reverse());\n  pieces.push(mouth);\n  return pieces.map((pts) => {\n    let len = 0;\n    const cum = [0];\n    for (let i = 0; i \u003c pts.length; i++) {\n      const a = pts[i], b = pts[(i + 1) % pts.length];\n      len += hypot(b[0] - a[0], b[1] - a[1]);\n      cum.push(len);\n    }\n    let cx = 0, cy = 0;\n    for (const p of pts) (cx += p[0] / pts.length), (cy += p[1] / pts.length);\n    return { pts, cum, len, cx, cy, state: 0, t: 0.5 };\n  });\n}\n\n// Which piece covers each LED of the head-on face, 1 to 4, 0 for skin.\n// The candle stands so its flame rises from just inside the top of the mouth.\nfunction maskFace(S) {\n  const m = S.mask;\n  m.fill(0);\n  S.face.forEach((pc, k) => {\n    const xs = pc.pts.map((p) => p[0]), ys = pc.pts.map((p) => p[1]);\n    for (let y = max(0, floor(min(...ys))); y \u003c= min(H - 1, floor(max(...ys))); y++)\n      for (let x = max(0, floor(min(...xs))); x \u003c= min(W - 1, floor(max(...xs))); x++) {\n        const px = x + 0.5, py = y + 0.5;\n        let inside = false;\n        for (let i = 0, j = pc.pts.length - 1; i \u003c pc.pts.length; j = i++) {\n          const [xi, yi] = pc.pts[i], [xj, yj] = pc.pts[j];\n          if (yi > py !== yj > py && px \u003c ((xj - xi) * (py - yi)) / (yj - yi) + xi) inside = !inside;\n        }\n        if (inside) m[y * W + x] = k + 1;\n      }\n  });\n  let top = H;\n  for (let i = 0; i \u003c N; i++) if (m[i] === 4) top = min(top, floor(i / W));\n  S.fy = top + 3;\n}\n\nexport function setup(params) {\n  // A few stars in the sky, each with its own twinkle.\n  const stars = [];\n  for (let i = 0; i \u003c 16; i++) stars.push([floor(Math.random() * W), floor(Math.random() * 40), Math.random() * TAU]);\n  // The pumpkin's fixed geometry per LED: longitude at no turn (-10 off the\n  // pumpkin), its cosine and sine, and the spheroid's normal.\n  const geo = new Float32Array(N).fill(-10), cth = new Float32Array(N), sth = new Float32Array(N);\n  const gnx = new Float32Array(N), gny = new Float32Array(N), gnz = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++) {\n    const v = (y + 0.5 - CY) / PB, c = sqrt(max(0, 1 - v * v)), rw = PA * c;\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - CX, i = y * W + x;\n      if (abs(dx) >= rw) continue;\n      const u = dx / rw, th = asin(u);\n      (geo[i] = th), (cth[i] = cos(th)), (sth[i] = u);\n      (gnx[i] = u * c), (gny[i] = v * 0.9), (gnz[i] = sqrt(max(0, 1 - u * u)) * c);\n    }\n  }\n  params.s = {\n    geo, cth, sth, gnx, gny, gnz,\n    // Numbers that change every frame start as fractions, so the engine\n    // keeps them as floats from the start and does not recompile.\n    warmth: 0.5, speed: 1.5, fierce: 0.5, spill: 0.06, rt: 0.5, made: false,\n    face: null, mask: new Uint8Array(N), stars, fy: 80.5,\n    // The story: phase, time in it, the piece being cut and how far round.\n    phase: \"cut\", pt: 0.5, piece: 3, sub: \"trace\", cut: 0.5, from: [CX + 0.5, CY + 0.5],\n    turned: 0.5, phi: 0.5, light: 0.5, flare: 0.5, mx: 0.5, my: 0.5, glow: 0.5, sway: 0.5,\n    rgb: new Float32Array(N * 3), pal: new Float64Array(36), lit: new Float32Array(N), skin: new Uint8Array(N),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.warmth = cl(k[0], -1, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.fierce = cl(k[2], 0, 1);\n  S.spill = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.rt += d;\n  if (!S.made) {\n    // The first face opens with the knife part way round the mouth.\n    S.made = true;\n    S.face = makeFace(S.fierce);\n    maskFace(S);\n    for (let i = 0; i \u003c 3; i++) S.face[i].state = 3;\n    S.face[3].state = 1;\n    S.cut = S.face[3].len * 0.45;\n  }\n  // The flame: a breath, a shiver, now and then a short gust; it leans with them.\n  const t = S.rt, gust = max(0, sin(t * 1.9 + 2 * sin(t * 0.7))) ** 6;\n  S.glow = cl(1 - 0.14 * (0.5 + 0.5 * sin(t * 11.3) * sin(t * 4.1 + 1)) - 0.05 * sin(t * 23.7) - 0.2 * gust, 0.25, 1.05);\n  S.sway = 0.5 * (0.6 * sin(t * 2.3) + 0.4 * sin(t * 5.1 + 0.4)) + 0.8 * gust * sin(t * 0.9);\n  S.pt += g;\n  const pc = S.face[S.piece];\n  if (S.phase === \"cut\") {\n    if (S.sub === \"travel\") {\n      if (S.pt >= TRAVEL) (S.sub = \"trace\"), (S.pt = 0), (pc.state = 1), (S.cut = 0);\n    } else if (S.sub === \"trace\") {\n      S.cut += g * KNIFE;\n      if (S.cut >= pc.len) (S.sub = \"push\"), (S.pt = 0), (pc.state = 2), (pc.t = 0);\n    } else {\n      pc.t = cl(S.pt / PUSH, 0, 1);\n      if (S.pt >= PUSH) {\n        pc.state = 3;\n        S.from = pc.pts[0];\n        S.pt = 0;\n        if (S.piece \u003c 3) (S.piece++), (S.sub = \"travel\");\n        else S.phase = \"match\";\n      }\n    }\n  } else if (S.phase === \"match\" && S.pt >= MATCH) (S.phase = \"burn\"), (S.pt = 0);\n  else if (S.phase === \"burn\" && S.pt >= BURN) (S.phase = \"out\"), (S.pt = 0);\n  else if (S.phase === \"out\" && S.pt >= OUT) (S.phase = \"turn\"), (S.pt = 0);\n  else if (S.phase === \"turn\" && S.pt >= TURN) {\n    // Fresh skin faces us now; the ribs repeat every half turn.\n    (S.phase = \"rest\"), (S.pt = 0), (S.phi = 0), (S.turned += PI);\n    S.face = makeFace(S.fierce);\n    maskFace(S);\n  } else if (S.phase === \"rest\" && S.pt >= REST) (S.phase = \"cut\"), (S.pt = 0), (S.piece = 0), (S.sub = \"travel\"), (S.from = [CX + 22.5, CY - 30.5]);\n  S.phi = S.phase === \"turn\" ? PI * ease(cl(S.pt / TURN, 0, 1)) : 0;\n  // How lit the inside is: the match flares and sinks to a small flame, the\n  // candle catches with a flash and burns, then gutters out.\n  S.flare = 0;\n  if (S.phase === \"match\") {\n    const u = S.pt / MATCH;\n    S.flare = u \u003c 0.15 ? u / 0.15 : u \u003c 0.5 ? 1 - ((u - 0.15) / 0.35) * 0.7 : 0.3;\n    S.light = u \u003c 0.45 ? 0 : u \u003c 0.55 ? 0.3 : 0.3 + 0.7 * ease((u - 0.55) / 0.45) + 0.4 * max(0, 1 - abs(u - 0.75) / 0.1);\n    // Struck in the dark right of the stem, put in through the mouth.\n    const v = ease(cl((u - 0.2) / 0.3, 0, 1));\n    S.mx = mix(50, FX + 2, v);\n    S.my = mix(34, S.fy - 1, v * v);\n  } else if (S.phase === \"burn\") S.light = 1;\n  else if (S.phase === \"out\") {\n    const u = S.pt / OUT;\n    S.light = (1 - u) * (1 - u) * (0.7 + 0.3 * sin(S.pt * 40));\n  } else S.light = 0;\n}\n\n// The frame's colours in S.pal, three floats each: skin lit, shaded, in the\n// grooves and sunk while the candle burns, all saturated (a dim orange reads\n// brown); cut flesh; deep orange, gold, white-hot and crimson light; and, by\n// how bright the flame burns, the light itself and its pool's inner rings.\nconst HI = 0, LO = 3, GROOVE = 6, SUNK = 9, FLESH = 12, DEEP = 15, GOLD = 18, HOT = 21, CRIM = 24, GLOW = 27, POOL0 = 30, POOL1 = 33;\nconst RED = [0.88, 0.08, 0.02];\nfunction hsvTo(P, o, h, s, v) {\n  const c = hsv(h, s, v);\n  (P[o] = c[0]), (P[o + 1] = c[1]), (P[o + 2] = c[2]);\n}\nfunction palette(S, dim) {\n  // Warmth runs the pumpkin from red through orange to golden yellow. Lit\n  // from inside, a yellow skin would pale to the face's own colour, so it\n  // sinks toward orange instead.\n  const P = S.pal, hp = 0.075 + 0.075 * S.warmth, wy = cl((hp - 0.09) / 0.06, 0, 1);\n  hsvTo(P, HI, hp + 0.015, 0.88, 1);\n  hsvTo(P, LO, hp - 0.02, 1, 0.88);\n  hsvTo(P, GROOVE, hp - 0.04, 1, 0.74);\n  hsvTo(P, SUNK, hp - 0.035 - 0.06 * wy, 1, 0.84);\n  hsvTo(P, FLESH, min(hp + 0.06, 0.15), 0.5, 0.95);\n  hsvTo(P, DEEP, hp - 0.01, 1, 1);\n  hsvTo(P, GOLD, min(hp + 0.06, 0.15), 0.88 - 0.25 * wy, 1);\n  hsvTo(P, HOT, min(hp + 0.1, 0.16), 0.28 - 0.1 * wy, 1);\n  hsvTo(P, CRIM, hp - 0.07, 0.88, 0.95);\n  // Gold at full, deep orange at half, ember red as it gutters, so a dim\n  // flame turns red, not brown.\n  for (let c = 0; c \u003c 3; c++) {\n    P[GLOW + c] = dim \u003c 0.5 ? mix(RED[c], P[DEEP + c], dim * 2) : mix(P[DEEP + c], P[GOLD + c], dim * 2 - 1);\n    P[POOL0 + c] = mix(P[CRIM + c], P[GOLD + c], dim);\n    P[POOL1 + c] = mix(P[CRIM + c], P[DEEP + c], dim);\n  }\n}\n\n// The night: violet sky in bands, the table with the pumpkin's shadow, and\n// while the candle burns its glow in the air and its pool on the table.\nfunction night(S, L) {\n  const P = S.pal, rgb = S.rgb, sp = S.spill, lamp = min(1, L);\n  const poolX = 36 + 30 * sp, poolY = 15 + 22 * sp, halo = 0.06 + 0.62 * sp, breathe = 0.72 + 0.3 * L;\n  for (let y = 0; y \u003c H; y++) {\n    const band = floor((y / TABLE) * 9) / 8, v = (y + 0.5 - CY) / PB;\n    const sky = y \u003c TABLE, front = y >= TABLE + 14;\n    const b2 = band * band, r0 = sky ? 0.02 + 0.2 * b2 : front ? 0.15 : 0.12, g0 = sky ? 0.004 + 0.05 * b2 : front ? 0.065 : 0.05, b0 = sky ? 0.05 + 0.27 * b2 : front ? 0.22 : 0.19;\n    const haloRow = L > 0 && sky && v > -1 - halo && v \u003c 1 + halo, poolRow = L > 0 && y > BASE - 1, shadeRow = !sky && y > BASE - 5 && y \u003c BASE + 5;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let r = r0, g = g0, b = b0;\n      if (haloRow) {\n        // Three rings of crimson round the pumpkin.\n        const hx = (x + 0.5 - CX) / PA, e = (sqrt(hx * hx + v * v) - 1) / halo;\n        if (e > 0 && e \u003c 1) {\n          const a = (e \u003c 0.35 ? 0.55 : e \u003c 0.7 ? 0.36 : 0.2) * lamp, c = e \u003c 0.35 ? POOL1 : CRIM;\n          (r = mix(r, P[c], a)), (g = mix(g, P[c + 1], a)), (b = mix(b, P[c + 2], a));\n        }\n      }\n      if (shadeRow) {\n        const sx = (x + 0.5 - CX - 3) / 31, sy = (y + 0.5 - BASE) / 4.5;\n        if (sx * sx + sy * sy \u003c 1) (r *= 0.4), (g *= 0.4), (b *= 0.45);\n      }\n      if (poolRow) {\n        // Gold, then orange, then crimson, all sinking to crimson as the\n        // flame dips, and the pool breathes with it.\n        const px = (x + 0.5 - CX) / poolX, py = (y + 0.5 - BASE - 1) / poolY, dd = sqrt(px * px + py * py) / breathe;\n        if (dd \u003c 1) {\n          const c = dd \u003c 0.42 ? POOL0 : dd \u003c 0.7 ? POOL1 : CRIM, a = (dd \u003c 0.42 ? 0.88 : dd \u003c 0.7 ? 0.66 : 0.45) * (0.4 + 0.6 * lamp);\n          (r = mix(r, P[c], a)), (g = mix(g, P[c + 1], a)), (b = mix(b, P[c + 2], a));\n        }\n      }\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n  }\n}\n\n// The skin: its longitude, turned with the body, sets the ribs, whose sides\n// lean the normal so the moon lights one. Five steps of light, three of groove.\nfunction skinAt(S, i, rot, warm) {\n  const P = S.pal, rgb = S.rgb, o = i * 3;\n  const gq = (((S.geo[i] - rot) * RIBS) / TAU) % 1, ri = floor((gq \u003c 0 ? gq + 1 : gq) * 256) & 255, bulge = RIB_B[ri], lean = RIB_L[ri];\n  const nx = S.gnx[i] + lean * S.cth[i], ny = S.gny[i], nz = S.gnz[i] - lean * S.sth[i];\n  const lam = floor(cl((nx * LX + ny * LY + nz * LZ) / (sqrt(nx * nx + ny * ny + nz * nz) || 1), 0, 0.999) * 5) / 4;\n  const gw = bulge \u003c 0.25 ? 0 : bulge \u003c 0.6 ? 0.55 : 1;\n  for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(mix(P[GROOVE + c], mix(P[LO + c], P[HI + c], lam), gw), P[SUNK + c], warm);\n}\n\n// A hole, or a piece on its way in. k is the piece, (fx, y) the LED in\n// head-on coordinates. Returns false where the pushed piece still covers it.\nfunction holeAt(S, i, k, fx, y, v, L, dim) {\n  const P = S.pal, rgb = S.rgb, mask = S.mask, pc = S.face[k - 1], o = i * 3;\n  if (pc.state === 2) {\n    // Pushed in: at once a dark gap opens round the piece, then it shrinks\n    // and sinks inside its hole, darkening as it goes.\n    const p = pc.t, sc = 0.9 - 0.3 * p, qx = floor(pc.cx + (fx + 0.5 - pc.cx) / sc), qy = floor(pc.cy + (y + 0.5 - pc.cy - 0.5 - 4 * p * p) / sc);\n    if (qx >= 0 && qx \u003c W && qy >= 0 && qy \u003c H && mask[qy * W + qx] === k) {\n      const d = 0.35 + 0.65 * p;\n      (rgb[o] = mix(rgb[o], P[GROOVE], d)), (rgb[o + 1] = mix(rgb[o + 1], P[GROOVE + 1], d) * (1 - 0.5 * p)), (rgb[o + 2] *= 1 - d);\n      return false;\n    }\n  }\n  // The wall of the cut shows on the side away from the middle.\n  const wx = floor(fx + 0.5 + ((fx + 0.5 - CX) / PA) * 2.6), wy = floor(y + 0.5 + v * 2.2);\n  if (wx \u003c 0 || wx >= W || wy \u003c 0 || wy >= H || mask[wy * W + wx] !== k) {\n    const a = mix(0.9, 1, cl(S.light, 0, 1));\n    for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(P[FLESH + c], P[HOT + c], dim) * a;\n    return true;\n  }\n  // Inside: dark, or the far wall candlelit, gold to white-hot by the flame,\n  // brighter than the skin so the face reads as burning.\n  const flameX = FX + S.sway, ex = fx + 0.5 - flameX, ey = (y + 0.5 - S.fy) * 0.8;\n  const near = floor(cl(1 - sqrt(ex * ex + ey * ey) / 24, 0, 0.999) * 4) / 3;\n  const a = (0.55 + 0.45 * min(1, L)) * cl(S.light * 4, 0, 1), hn = near * 0.75 * dim;\n  (rgb[o] = 0.03 + mix(P[GLOW], P[HOT], hn) * a), (rgb[o + 1] = 0.01 + mix(P[GLOW + 1], P[HOT + 1], hn) * a), (rgb[o + 2] = 0.04 + mix(P[GLOW + 2], P[HOT + 2], hn) * a);\n  S.lit[i] = a;\n  // The flame itself, through whichever hole it lies behind.\n  const flameH = 6 + 1.5 * S.glow, fy = S.fy - (y + 0.5), fxo = ex - S.sway * 0.4 * (fy / flameH);\n  if (S.light > 0.12 && fy > -1 && fy \u003c flameH) {\n    const q = fy / flameH, w = q \u003c 0.3 ? 2.2 * sqrt(q / 0.3) : 2.2 * (1 - (q - 0.3) / 0.7) ** 0.8;\n    if (fxo > -w - 0.2 && fxo \u003c w + 0.2) {\n      const core = fxo > -w * 0.5 && fxo \u003c w * 0.5 && q \u003c 0.65;\n      (rgb[o] = 1), (rgb[o + 1] = core ? 0.97 : 0.75), (rgb[o + 2] = core ? 0.8 : 0.2);\n    }\n  }\n  return true;\n}\n\n// The pumpkin: skin, and the face carried round with the turn.\nfunction pumpkin(S, L, dim) {\n  const { skin, mask, face, geo } = S, rot = S.turned + S.phi, fl = S.phi;\n  // While the candle burns the skin sinks to a saturated red-orange round the face.\n  const warm = 0.5 * cl(L, 0, 1);\n  for (let y = CY - PB; y \u003c CY + PB; y++) {\n    const v = (y + 0.5 - CY) / PB, rw = PA * sqrt(max(0, 1 - v * v));\n    for (let x = max(0, floor(CX - rw)); x \u003c= min(W - 1, floor(CX + rw)); x++) {\n      const i = y * W + x, th = geo[i];\n      if (th \u003c -9) continue;\n      skinAt(S, i, rot, warm);\n      skin[i] = 1;\n      const thr = th - fl;\n      if (thr \u003c= -PI / 2 || thr >= PI / 2) continue;\n      const fx = fl === 0 ? x : floor(CX + rw * sin(thr)), k = fx >= 0 && fx \u003c W ? mask[y * W + fx] : 0;\n      if (k && face[k - 1].state >= 2 && holeAt(S, i, k, fx, y, v, L, dim)) skin[i] = 0;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.face) return;\n  const { rgb, lit, skin, face, pal: P } = S;\n  const L = S.light * S.glow, dim = cl((L - 0.3) / 0.5, 0, 1), rot = S.turned + S.phi;\n  palette(S, dim);\n  lit.fill(0);\n  skin.fill(0);\n  night(S, L);\n  pumpkin(S, L, dim);\n  // Light from the holes blooms gold onto the skin two LEDs round them.\n  if (L > 0.02)\n    for (let i = (CY - PB) * W; i \u003c (CY + PB) * W; i++) {\n      if (!skin[i]) continue;\n      const n1 = max(lit[i - 1], lit[i + 1], lit[i - W], lit[i + W]), n2 = max(lit[i - 2], lit[i + 2], lit[i - 2 * W], lit[i + 2 * W]);\n      const a = n1 > 0 ? 0.67 * min(1, n1 * 1.2) : 0.33 * min(1, n2 * 1.2);\n      if (a > 0) for (let c = 0; c \u003c 3; c++) rgb[i * 3 + c] = mix(rgb[i * 3 + c], P[GOLD + c], a);\n    }\n  // The stem: a thick green hook from the dimple on top, its lean turning\n  // with the pumpkin.\n  const lean = 5 * sin(0.9 + rot), sx0 = CX + 0.5, sy0 = CY - PB + 3;\n  for (let s = 0; s \u003c= 24; s++) {\n    const q = s / 24, px = sx0 + lean * q * q, py = sy0 - 12 * q, rr = 2.6 - 1.1 * q;\n    for (let y = floor(py - rr); y \u003c= py + rr; y++)\n      for (let x = floor(px - rr); x \u003c= px + rr; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || (x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2 > rr * rr) continue;\n        const o = (y * W + x) * 3, hi = x + 0.5 \u003c px - 0.4;\n        (rgb[o] = hi ? 0.45 : 0.22), (rgb[o + 1] = hi ? 0.95 : 0.72), (rgb[o + 2] = hi ? 0.25 : 0.12);\n      }\n  }\n  // The stars, twinkling.\n  for (const [x, y, ph] of S.stars) {\n    const o = (y * W + x) * 3, a = 0.35 + 0.3 * sin(S.rt * 1.7 + ph);\n    if (!skin[y * W + x]) (rgb[o] = max(rgb[o], a)), (rgb[o + 1] = max(rgb[o + 1], a * 0.9)), (rgb[o + 2] = max(rgb[o + 2], a));\n  }\n  const put = (x, y, r, g, b) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n  };\n  if (S.phase === \"cut\") {\n    const pc = face[S.piece];\n    // The cut so far, a pale line of fresh flesh, ends where the blade is in.\n    let tip = [pc.cx + 1, pc.cy];\n    if (S.sub === \"travel\") {\n      const u = ease(cl(S.pt / TRAVEL, 0, 1)), to = pc.pts[0];\n      tip = [mix(S.from[0], to[0], u), mix(S.from[1], to[1], u)];\n    } else if (pc.state === 1)\n      for (let j = 0; j \u003c pc.pts.length && pc.cum[j] \u003c S.cut; j++) {\n        const a = pc.pts[j], b = pc.pts[(j + 1) % pc.pts.length], l = pc.cum[j + 1] - pc.cum[j] || 1, e = min(1, (S.cut - pc.cum[j]) / l);\n        for (let q = 0; q \u003c= e * l * 2; q++) put(mix(a[0], b[0], q / (2 * l)), mix(a[1], b[1], q / (2 * l)), P[FLESH], P[FLESH + 1], P[FLESH + 2]);\n        tip = [mix(a[0], b[0], e), mix(a[1], b[1], e)];\n      }\n    // The knife saws up and down its own length.\n    const saw = S.sub === \"trace\" ? 1.6 * sin(S.rt * 31) : 0;\n    const bl = BLADE + saw, sparkle = (S.rt * 1.3) % 1;\n    for (let s = 0; s \u003c= (bl + HANDLE) * 2; s++) {\n      const a = s / 2, x = tip[0] + KDX * a, y = tip[1] + KDY * a;\n      if (a \u003c= bl) {\n        // Silver, the edge brightest; the glint runs up it.\n        const gl = max(0, 1 - abs(a - sparkle * bl) / 2.5);\n        put(x, y, 0.78 + 0.22 * gl, 0.82 + 0.18 * gl, 0.92 + 0.08 * gl);\n        put(x + 1, y, 0.5 + 0.4 * gl, 0.54 + 0.4 * gl, 0.66 + 0.3 * gl);\n      } else {\n        // A brass bolster, then a violet handle lit on its left.\n        const c = a \u003c bl + 1 ? BOLSTER : HANDLE_C;\n        for (let j = 0; j \u003c 3; j++) put(x + j - 1, y, c[j * 3], c[j * 3 + 1], c[j * 3 + 2]);\n      }\n    }\n  }\n  if (S.phase === \"match\" && S.flare > 0) {\n    // The match: a pale stick, a white burst with rays as it is struck,\n    // then its own small flame above the head.\n    const f = S.flare, x0 = S.mx, y0 = S.my;\n    for (let j = 1; j \u003c= 6; j++) put(x0 + 0.55 * j, y0 + 0.85 * j, 0.95, 0.86, 0.62);\n    const reach = 3 + 7 * f, core = 1.2 + 2.6 * f;\n    for (let y = floor(y0 - reach); y \u003c= y0 + reach; y++)\n      for (let x = floor(x0 - reach); x \u003c= x0 + reach; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const ddx = x + 0.5 - x0, ddy = y + 0.5 - y0, dd = sqrt(ddx * ddx + ddy * ddy);\n        const ray = (abs(ddx) \u003c 0.6 || abs(ddy) \u003c 0.6 ? 1 : abs(abs(ddx) - abs(ddy)) \u003c 0.7 ? 0.65 : 0) * max(0, 1 - dd / reach);\n        const a = min(1, max(ray * f * 1.3, dd \u003c core ? 1 : 0));\n        if (a \u003c= 0.05) continue;\n        const o = (y * W + x) * 3;\n        (rgb[o] = mix(rgb[o], 1, a)), (rgb[o + 1] = mix(rgb[o + 1], dd \u003c core * 0.6 ? 1 : 0.9, a)), (rgb[o + 2] = mix(rgb[o + 2], dd \u003c core * 0.6 ? 0.9 : 0.45, a));\n      }\n    for (let j = 1; j \u003c= 4; j++) {\n      const w = j \u003c 3 ? 1 : 0;\n      for (let dx = -w; dx \u003c= w; dx++) put(x0 + dx, y0 - j, 1, j \u003c 2 ? 1 : 0.8, j \u003c 2 ? 0.8 : 0.25);\n    }\n  }\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","pumpkin-vine":"// ===== Patternflow pattern =====\n// Title:   Pumpkin Vine\n// Family:  halloween\n// Idea:    Under a violet night sky and a pale moon a pumpkin vine climbs from the hill at the bottom of the panel to near the top, its stem winding up as broad five-lobed leaves unfold at every joint and tendrils coil out beside them, small orange pumpkins swell at the joints and light one by one from the bottom as jack-o'-lanterns with glowing carved faces, each one lifting the night a little, and when the whole vine has stood lit for a few seconds its leaves wither to a dead violet, sink into the dark, and a new vine starts from the ground.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Spell=0..1, Speed=0.2..3, Vines=1..3, Curl=0..1\n//\n// Knob 1: Spell. At 0 an ordinary pumpkin patch under a violet night: leaf-green leaves, candle-yellow faces and an orange glow. Turning it bewitches the vine: by 0.5 the leaves are teal, the faces lime and the night dark slate; at 1 the leaves are violet with toxic green veins, the lanterns burn green and the night is a sickly green. The pumpkins stay orange.\n// Knob 2: Speed. At 2 one vine takes 13 seconds: it starts climbing at 0.45, reaches its full height at 6.45, the four lanterns catch at about 3.9, 5.3, 6.0 and 7.4, it stands lit until 11, withers in 1.5 and the ground rests half a second. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Vines. One vine leans away from the moon with four pumpkins. Two share the width with leaves a fifth smaller and three pumpkins each, three with leaves a third smaller and two each, the one under the moon stopping lower. Turning it lays the vines out again at the same stage of growth.\n// Knob 4: Curl. How hard the stem winds, how flat the leaves spread and how far the tendrils coil: at 0.06 the stem sways gently, the leaves stand half upright and each tendril makes one turn; at 1 the stem swings in wide S-bends, the leaves spread flat out and the tendrils are springs of two and a half turns.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, asin, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sstep = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// One vine, in story seconds (one a second at Speed 2): the stem starts at\n// T0 and reaches the top GROW later; the vine stands until HOLD_END,\n// withers in WITHER and the ground rests until CYCLE.\nconst T0 = 0.45, GROW = 6, HOLD_END = 11, WITHER = 1.5, CYCLE = 13;\n// A leaf unfolds in LEAF_T after the tip passes its joint, a pumpkin swells\n// in PUMP_T, a tendril coils out in TEND_T, a lantern catches in LIGHT_T.\nconst LEAF_T = 1.2, PUMP_T = 1.4, TEND_T = 1.3, LIGHT_T = 0.5;\n// Each LED a part of the vine covers fades in over this long.\nconst RAMP = 0.15;\n// How much brighter the night is once every lantern is lit.\nconst SKY_GLOW = 0.33;\n// The stem stops this far below the top edge; joints come every GAP LEDs of\n// stem; a leaf's radius at the bottom joint.\nconst TOP_Y = 22, GAP = 13, LEAF_R = 15.5;\n// The moon, top right.\nconst MX = 52, MY = 11, MR = 7.5;\n// A pumpkin's half-width and half-height at full size.\nconst PRX = 8, PRY = 6.5;\n// Up to this many parts of the vine are kept per LED, newest on top.\nconst EV = 4;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, spell: 0, speed: 2, vines: 0, curl: -1,\n    bg: new Float32Array(N * 3), bgSpell: NaN,\n    evN: new Uint8Array(N), evT: new Float32Array(N * EV), evA: new Float32Array(N * EV), evK: new Uint8Array(N * EV),\n    tmpT: new Float32Array(N), tmpA: new Float32Array(N), tmpK: new Uint8Array(N), tmpD: new Float32Array(N), touched: [],\n    rgb: new Float32Array(N * 3), lv: new Float32Array(N), pm: new Uint8Array(N), pal: null, palSpell: NaN,\n    pumpkins: [], stars: [], seed: 0, rng: null,\n  };\n}\n\n// The palette for a Spell setting. Parts of the vine store only a kind, so\n// turning Spell recolours a vine that has already grown.\n// Kinds: 1 stem, 2 stem highlight, 3 leaf lit half, 4 leaf shaded half,\n// 5 vein, 6 leaf rim, 7 tendril, and 8, 9 and 11 the lit half, shaded half\n// and rim of every other leaf, a yellower green.\nfunction palette(sp) {\n  const lh = 0.3 + 0.47 * sp;\n  return {\n    1: hsv(0.27 + 0.05 * sp, 0.78, 0.8),\n    2: hsv(0.24 + 0.06 * sp, 0.6, 0.95),\n    3: hsv(lh, 0.86, 0.94),\n    4: hsv(lh + 0.02, 0.9, 0.86),\n    5: hsv(0.22 + 0.08 * sp, 0.62 + 0.2 * sp, 0.97),\n    6: hsv(lh + 0.03, 0.92, 0.7),\n    7: hsv(0.2 + 0.08 * sp, 0.6, 0.92),\n    8: hsv(lh - 0.07, 0.88, 0.96),\n    9: hsv(lh - 0.06, 0.9, 0.88),\n    11: hsv(lh - 0.05, 0.92, 0.72),\n    fire: hsv(0.14 + 0.17 * sp, 0.62, 1),\n    halo: hsv(0.07 + 0.24 * sp, 0.95, 1),\n  };\n}\n\n// The night: a violet sky darker towards the ground, a few still stars, the\n// moon with two faint seas and a soft ring, and a low dark hill.\nfunction sky(S) {\n  const bg = S.bg, sp = S.spell;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3, u = y / H;\n      // Spell turns the violet night to a sickly green one.\n      let r = mix(mix(0.12, 0.035, u), mix(0.02, 0.008, u), sp), g = mix(mix(0.03, 0.008, u), mix(0.17, 0.06, u), sp), b = mix(mix(0.22, 0.075, u), mix(0.09, 0.03, u), sp);\n      const d = hypot(x + 0.5 - MX, y + 0.5 - MY);\n      if (d \u003c MR) {\n        const sea = hypot(x - MX + 2.5, y - MY + 1.5) \u003c 2.6 || hypot(x - MX - 1.5, y - MY - 3) \u003c 2 ? 0.86 : 1;\n        r = 1 * sea;\n        g = mix(0.95, 1, sp) * sea;\n        b = mix(0.76, 0.7, sp) * sea;\n      } else if (d \u003c MR + 6) {\n        const k = ((MR + 6 - d) / 6) ** 2 * 0.35;\n        r += k * 0.9;\n        g += k * 0.8;\n        b += k * 0.7;\n      }\n      // The hill the vine grows out of.\n      const hill = H - 5 + 3 * cos((x - 30) / 14);\n      if (y + 0.5 > hill) (r = 0.18), (g = 0.05), (b = 0.27);\n      if (abs(y + 0.5 - hill) \u003c 0.6) (r = 0.32), (g = 0.12), (b = 0.42);\n      bg[i] = r;\n      bg[i + 1] = g;\n      bg[i + 2] = b;\n    }\n  for (const [x, y, v] of S.stars) {\n    const i = (y * W + x) * 3;\n    bg[i] = max(bg[i], 0.8 * v);\n    bg[i + 1] = max(bg[i + 1], 0.75 * v);\n    bg[i + 2] = max(bg[i + 2], v);\n  }\n  S.bgSpell = sp;\n}\n\n// Building a vine: each part is stamped into a scratch layer first (an\n// arrival time, a coverage and a kind per LED), then the layer goes on top\n// of the parts already there.\nfunction stamp(S, x, y, te, a, kind, d) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = y * W + x;\n  if (S.tmpA[p] === 0) (S.touched.push(p), (S.tmpT[p] = te), (S.tmpD[p] = 1e9));\n  S.tmpT[p] = min(S.tmpT[p], te);\n  S.tmpA[p] = max(S.tmpA[p], a);\n  if (d \u003c S.tmpD[p]) (S.tmpD[p] = d), (S.tmpK[p] = kind);\n}\nfunction flush(S) {\n  for (const p of S.touched) {\n    let n = S.evN[p];\n    if (n === EV) {\n      // Full: the oldest part is under three others; drop it.\n      for (let j = 1; j \u003c EV; j++) {\n        S.evT[p * EV + j - 1] = S.evT[p * EV + j];\n        S.evA[p * EV + j - 1] = S.evA[p * EV + j];\n        S.evK[p * EV + j - 1] = S.evK[p * EV + j];\n      }\n      n--;\n    }\n    // Kept in order of arrival, so the one that comes last is drawn on top.\n    let j = n;\n    while (j > 0 && S.evT[p * EV + j - 1] > S.tmpT[p]) {\n      S.evT[p * EV + j] = S.evT[p * EV + j - 1];\n      S.evA[p * EV + j] = S.evA[p * EV + j - 1];\n      S.evK[p * EV + j] = S.evK[p * EV + j - 1];\n      j--;\n    }\n    S.evT[p * EV + j] = S.tmpT[p];\n    S.evA[p * EV + j] = S.tmpA[p];\n    S.evK[p * EV + j] = S.tmpK[p];\n    S.evN[p] = n + 1;\n    S.tmpA[p] = 0;\n  }\n  S.touched.length = 0;\n}\n\n// A round brush along a polyline of [x, y, time] points, or [x, y, time,\n// radius] where it tapers.\nfunction brush(S, pts, rad, kindAt) {\n  for (const [px, py, te, rr] of pts) {\n    const r = rr === undefined ? rad : rr;\n    for (let y = floor(py - r - 1); y \u003c= py + r + 1; y++)\n      for (let x = floor(px - r - 1); x \u003c= px + r + 1; x++) {\n        const d = hypot(x + 0.5 - px, y + 0.5 - py);\n        stamp(S, x, y, te, cl(r + 0.5 - d, 0, 1), kindAt(d / r), d);\n      }\n  }\n}\n\n// The inverse of smoothstep: the share of the way through an eased\n// unfolding at which it has reached u.\nconst unease = (u) => 0.5 - sin(asin(cl(1 - 2 * u, -1, 1)) / 3);\n\n// One vine from the ground at x0, leaning towards lean as it climbs and\n// stopping at row top; it starts at t0, its leaves are scaled by lr and it\n// carries np pumpkins.\nfunction vine(S, x0, lean, top, t0, lr, np) {\n  const R = S.rng, curl = S.curl;\n  // The stem: steered by a heading that swings from side to side, pulled\n  // back towards the line it leans along.\n  const pts = [], amp = 0.365 + 0.95 * (curl - 0.06), lam = 46 + 10 * R(), ph = TAU * R();\n  let x = x0, y = H + 1, s = 0;\n  while (y > top) {\n    const xc = mix(x0, lean, cl((H - y) / H, 0, 1)), th = amp * sin((TAU * s) / lam + ph) - 0.035 * (x - xc);\n    x += 0.5 * sin(th);\n    y -= 0.5 * cos(th);\n    s += 0.5;\n    pts.push([x, y, s]);\n  }\n  const len = s, tipAt = (ss) => t0 + (GROW * ss) / len;\n  brush(S, pts.map(([px, py, ss]) => [px, py, tipAt(ss), (2.2 - (1.1 * ss) / len) * (0.6 + 0.4 * lr)]), 0, (u) => (u \u003c 0.45 ? 2 : 1));\n  flush(S);\n  // The joints, alternating sides.\n  const nodes = [];\n  let side = R() \u003c 0.5 ? -1 : 1;\n  for (let sn = 9; sn \u003c len - 8; sn += GAP) {\n    const pt = pts[min(pts.length - 1, round(sn / 0.5))];\n    nodes.push({ s: sn, x: pt[0], y: pt[1], side, t: tipAt(sn) + 0.15 });\n    side = -side;\n  }\n  // Pumpkins at evenly spread joints from the second to the one below the\n  // top.\n  const last = max(1, nodes.length - 2), pick = new Set();\n  for (let j = 0; j \u003c np; j++) pick.add(round(1 + (j * (last - 1)) / max(1, np - 1)));\n  const prx = PRX * (0.7 + 0.3 * lr);\n  nodes.forEach((nd, j) => {\n    // The leaf: a petiole out and up, then a five-lobed blade that unfolds\n    // from its stalk outwards, the middle lobe first. Curl spreads the\n    // leaves from half upright to flat out.\n    const rad = LEAF_R * lr * (1.08 - (0.32 * nd.s) / len), pl = (3.5 + 1.5 * R()) * lr;\n    let a = nd.side * (0.75 + (curl - 0.06) + 0.25 * R());\n    // A leaf that would cover the moon grows on the other side instead.\n    if (hypot(nd.x + sin(a) * (pl + 0.62 * rad) - MX, nd.y - cos(a) * (pl + 0.62 * rad) - MY) \u003c rad + MR + 2) (a = -a), (nd.side = -nd.side);\n    const dx = sin(a), dy = -cos(a);\n    const bx = nd.x + dx * pl, by = nd.y + dy * pl, cx = bx + dx * 0.62 * rad, cy = by + dy * 0.62 * rad;\n    const stalk = [], alt = j % 2 ? 5 : 0;\n    for (let l = 0; l \u003c= pl; l += 0.5) stalk.push([nd.x + dx * l, nd.y + dy * l, nd.t + 0.15 * LEAF_T * (l / pl)]);\n    brush(S, stalk, 0.9, () => 1);\n    for (let yy = floor(cy - rad - 2); yy \u003c= cy + rad + 2; yy++)\n      for (let xx = floor(cx - rad - 2); xx \u003c= cx + rad + 2; xx++) {\n        const ex = xx + 0.5 - cx, ey = yy + 0.5 - cy, rho = hypot(ex, ey);\n        const phi = atan2(ex * dy - ey * dx, ex * dx + ey * dy);\n        const edge = rad * (0.62 + 0.38 * abs(cos(2.5 * phi)) ** 0.55);\n        const cov = cl(edge - rho + 0.5, 0, 1);\n        if (cov \u003c= 0) continue;\n        // Veins run from the stalk to the three upper lobe tips.\n        const fx = xx + 0.5 - bx, fy = yy + 0.5 - by, fr = hypot(fx, fy);\n        const psi = atan2(fx * dy - fy * dx, fx * dx + fy * dy);\n        let vein = 9;\n        for (const la of [0, 0.4 * PI, -0.4 * PI]) {\n          const lx = cx + rad * (cos(la) * dx + sin(la) * dy) - bx, ly = cy + rad * (cos(la) * dy - sin(la) * dx) - by;\n          const ll = hypot(lx, ly), t2 = cl((fx * lx + fy * ly) / (ll * ll), 0, 1);\n          vein = min(vein, hypot(fx - t2 * lx, fy - t2 * ly));\n        }\n        // Every other leaf is a yellower green, so neighbours stand apart.\n        const kind = edge - rho \u003c 1.1 ? 6 + alt : vein \u003c 0.55 ? 5 : (phi * nd.side > 0 ? 3 : 4) + alt;\n        const u = cl((0.72 * fr) / (1.62 * rad) + (0.28 * abs(psi)) / PI, 0, 1);\n        stamp(S, xx, yy, nd.t + LEAF_T * (0.15 + 0.85 * unease(u)), cov, kind, 0);\n      }\n    flush(S);\n    if (pick.has(j)) {\n      // A pumpkin hangs on the side away from the leaf; the lowest sits on\n      // the hill.\n      const px = cl(nd.x - nd.side * (prx * 0.75 + 1.5), prx + 0.5, W - prx - 0.5);\n      S.pumpkins.push({ x: px, top: min(nd.y + 1, H - 6 - 2 * PRY * (0.7 + 0.3 * lr)), t: nd.t + 0.45, sc: 0.7 + 0.3 * lr });\n    } else {\n      // A tendril: an Euler spiral, its curvature growing along it, so it\n      // runs out straight and winds into a tight coil.\n      const turns = mix(1, 2.5, curl), tl = mix(10, 17, curl) * lr, a0 = -nd.side * (1.1 + 0.3 * R()), c0 = 0.04;\n      const cb = (TAU * turns - c0 * tl) / (tl * tl), spin = -nd.side;\n      const tp = [];\n      let qx = nd.x, qy = nd.y, l = 0;\n      while (l \u003c tl) {\n        const hd = a0 + spin * (c0 * l + cb * l * l);\n        qx += 0.3 * sin(hd);\n        qy -= 0.3 * cos(hd);\n        l += 0.3;\n        tp.push([qx, qy, nd.t + 0.3 + TEND_T * (l / tl)]);\n      }\n      brush(S, tp, 0.55, () => 7);\n      flush(S);\n    }\n  });\n}\n\n// Lay out the vines: one leans away from the moon; two or three share the\n// width with smaller leaves, starting 0.15 seconds apart.\nconst LAYOUT = {\n  1: [[0, 20, TOP_Y]],\n  2: [[17, 15, TOP_Y], [45, 38, TOP_Y + 10]],\n  3: [[11, 10, TOP_Y], [32, 28, TOP_Y + 4], [53, 44, TOP_Y + 16]],\n};\n// A small seeded generator: a vine keeps its seed until the next one\n// starts, so turning Curl or Vines bends the same vine instead of drawing\n// a new one at every step of the knob.\nfunction rng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = Math.imul(a ^ (a >>> 15), a | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nfunction build(S) {\n  S.rng = rng(S.seed);\n  S.evN.fill(0);\n  S.lv.fill(0);\n  S.pm.fill(0);\n  S.pumpkins = [];\n  const nv = S.vines, lr = [0, 1, 0.8, 0.68][nv], np = [0, 4, 3, 2][nv];\n  LAYOUT[nv].forEach(([x0, lean, top], v) => vine(S, x0 || 30 + 8 * S.rng(), lean, top, T0 + 0.15 * v, lr, np));\n  // The lanterns catch one by one in the order their pumpkins swelled.\n  S.pumpkins.sort((a, b) => a.t - b.t);\n  let light = 0;\n  for (const P of S.pumpkins) P.light = light = max(P.t + PUMP_T + 0.25, light + 0.55);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.spell = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  const nv = cl(round(k[2]), 1, 3), curl = cl(k[3], 0, 1);\n  if (S.stars.length === 0) {\n    for (let i = 0; i \u003c 22; i++) S.stars.push([floor(Math.random() * W), floor(Math.random() * 70), 0.25 + 0.3 * Math.random()]);\n    S.seed = floor(Math.random() * 4294967296);\n  }\n  if (nv !== S.vines || abs(curl - S.curl) > 0.004) {\n    S.vines = nv;\n    S.curl = curl;\n    build(S);\n  }\n  S.t += (d * S.speed) / 2;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    S.seed = floor(Math.random() * 4294967296);\n    build(S);\n  }\n}\n\n// A pumpkin at swell sw (0 to 1) hanging from (x, top), carved face lit by\n// f; writes into rgb over whatever is there and marks its LEDs in pm, so\n// the withering knows them.\nfunction pumpkin(S, P, sw, f, rgb) {\n  const rx = PRX * P.sc * sw, ry = PRY * P.sc * sw, cx = P.x, cy = P.top + 1 + ry, fire = S.pal.fire, stem = S.pal[1];\n  for (let y = floor(cy - ry - 3); y \u003c= cy + ry + 1; y++)\n    for (let x = floor(cx - rx - 1); x \u003c= cx + rx + 1; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const u = (x + 0.5 - cx) / rx, v = (y + 0.5 - cy) / ry, rr = sqrt(u * u + v * v);\n      const i = (y * W + x) * 3;\n      // The stalk, a green stub on top.\n      if (y + 0.5 \u003c cy - ry + 1 && y + 0.5 > cy - ry - 2.5 && abs(x + 0.5 - cx - 0.4) \u003c 1.1) {\n        rgb[i] = stem[0];\n        rgb[i + 1] = stem[1];\n        rgb[i + 2] = stem[2];\n        S.pm[y * W + x] = 1;\n        continue;\n      }\n      const a = cl((1 - rr) * rx + 0.5, 0, 1);\n      if (a \u003c= 0) continue;\n      // Every part of a pumpkin keeps red at full, so as it swells no LED\n      // under it gets dimmer: ribs are a deeper orange, the shine a yellower one.\n      const w = u / sqrt(max(0.05, 1 - v * v)), rib = abs(abs(w) - 0.5) \u003c 0.12 || abs(w) \u003c 0.06;\n      let g = rib ? 0.3 : 0.5;\n      if (u \u003c -0.15 && v \u003c -0.2 && u * u + v * v > 0.25 && u * u + v * v \u003c 0.6) g = 0.68;\n      let r = 1, b = 0;\n      if (f > 0) {\n        // The carved face: two triangle eyes, a nose and a jagged grin.\n        const eye = v \u003c= -0.06 && v >= -0.5 + abs(abs(u) - 0.4) * 1.9 && abs(u) \u003c 0.7;\n        const nose = v \u003c= 0.18 && v >= -0.02 + abs(u) * 1.8;\n        const top = 0.3 + 0.08 * u * u, bot = 0.62 - 0.18 * u * u;\n        let mouth = abs(u) \u003c 0.66 && v >= top && v \u003c= bot;\n        if (mouth && ((u > -0.32 && u \u003c -0.14 && v \u003c top + 0.15) || (u > 0.14 && u \u003c 0.32 && v > bot - 0.15))) mouth = false;\n        if (eye || nose || mouth) (g = mix(g, fire[1], f)), (b = fire[2] * f), (r = mix(1, max(fire[0], 0.85), f));\n      }\n      rgb[i] = mix(rgb[i], r, a);\n      rgb[i + 1] = mix(rgb[i + 1], g, a);\n      rgb[i + 2] = mix(rgb[i + 2], b, a);\n      S.pm[y * W + x] = 1;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.pumpkins) return;\n  if (S.bgSpell !== S.spell) sky(S);\n  if (S.palSpell !== S.spell) (S.pal = palette(S.spell)), (S.palSpell = S.spell), S.lv.fill(0);\n  const t = S.t, rgb = S.rgb, bg = S.bg, pal = S.pal;\n  const wi = t > HOLD_END ? sstep((t - HOLD_END) / WITHER) : 0;\n  // Each lantern that catches lifts the whole night a step, from deep\n  // violet towards a warmer, lighter one.\n  let glow = 0;\n  for (const P of S.pumpkins) glow += cl((t - P.light) / LIGHT_T, 0, 1);\n  glow = (glow / max(1, S.pumpkins.length)) * (1 - cl(wi * 2, 0, 1));\n  const sg = 1 + SKY_GLOW * glow, warm = 0.025 * glow;\n  for (let p = 0; p \u003c N; p++) {\n    const i = p * 3;\n    let r = bg[i] * sg + warm, g = bg[i + 1] * sg, b = bg[i + 2] * sg;\n    for (let j = 0; j \u003c S.evN[p]; j++) {\n      const q = p * EV + j, a = S.evA[q] * cl((t - S.evT[q]) / RAMP, 0, 1);\n      if (a \u003c= 0) break;\n      const c = pal[S.evK[q]];\n      r = mix(r, c[0], a);\n      g = mix(g, c[1], a);\n      b = mix(b, c[2], a);\n    }\n    rgb[i] = r;\n    rgb[i + 1] = g;\n    rgb[i + 2] = b;\n  }\n  // Pumpkins swell, then light one by one; each lit lantern throws a warm\n  // glow on the leaves and the sky round it.\n  const lit = [];\n  for (const P of S.pumpkins) {\n    const sw = sstep((t - P.t) / PUMP_T);\n    if (sw \u003c= 0) continue;\n    const f = cl((t - P.light) / LIGHT_T, 0, 1) * (1 - cl(wi * 2, 0, 1));\n    pumpkin(S, P, 0.25 + 0.75 * (1 - (1 - sw) ** 2), f, rgb);\n    if (f > 0) lit.push([P.x, P.top + 1 + PRY * P.sc, f, P.sc]);\n  }\n  const halo = pal.halo, HR = 22;\n  for (const [hx, hy, f, sc] of lit)\n    for (let y = max(0, floor(hy - HR)); y \u003c= min(H - 1, hy + HR); y++)\n      for (let x = max(0, floor(hx - HR)); x \u003c= min(W - 1, hx + HR); x++) {\n        const dd = hypot((x + 0.5 - hx) / (PRX * sc), (y + 0.5 - hy) / (PRY * sc));\n        if (dd \u003c 1.05) continue;\n        const k = 0.45 * f * (1 - min(1, hypot(x + 0.5 - hx, y + 0.5 - hy) / HR)) ** 2, i = (y * W + x) * 3;\n        rgb[i] += halo[0] * k;\n        rgb[i + 1] += halo[1] * k;\n        rgb[i + 2] += halo[2] * k;\n      }\n  for (let p = 0; p \u003c N; p++) {\n    const i = p * 3;\n    let r = min(1, rgb[i]), g = min(1, rgb[i + 1]), b = min(1, rgb[i + 2]);\n    if (wi > 0) {\n      // Withering: the vine dulls to a dead violet and sinks into the night.\n      // The sky only loses the lanterns' glow.\n      const L = max(r, g, b) * 0.6, w2 = S.evN[p] || S.pm[p] ? cl(wi * 1.6, 0, 1) : 0, w3 = sstep((wi - 0.35) / 0.65);\n      r = mix(mix(r, L * 0.62, w2), bg[i], w3);\n      g = mix(mix(g, L * 0.18, w2), bg[i + 1], w3);\n      b = mix(mix(b, L, w2), bg[i + 2], w3);\n    } else {\n      // While the vine grows no LED ever gets dimmer: a part that arrives\n      // darker than what it covers is lifted to the level that was there.\n      const L = max(r, g, b);\n      if (L \u003c S.lv[p] && L > 0) {\n        const k = S.lv[p] / L;\n        (r = min(1, r * k)), (g = min(1, g * k)), (b = min(1, b * k));\n      } else S.lv[p] = L;\n    }\n    display.setPixel(p % W, floor(p / W), round(255 * r), round(255 * g), round(255 * b));\n  }\n}\n","specimen-jar":"// ===== Patternflow pattern =====\n// Title:   Specimen Jar\n// Family:  halloween\n// Idea:    A glass specimen jar on a dark violet shelf, full of glowing toxic-green fluid with light rippling through it, holds a bloodshot eyeball with a violet iris that bobs and turns as it floats, trailing its pink nerve, its gaze wandering round the jar until it swings round to stare straight out, swims up to the glass and opens its pupil wide while the fluid glows up, and bubbles rise past it to pop at the surface.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Stare=0..1\n//\n// Knob 1: Hue. Turns the fluid from toxic green at 0 through teal at 0.3 and deep blue at 0.6 to magenta at 1, never round through orange, which glows brown this dim. The iris always takes the opposite colour: violet at 0, red at 0.3, gold at 0.6, green at 1. The eye's white, its veins, the lid and the shelf stay as they are.\n// Knob 2: Speed. At 2 the eye bobs through 16 rows every 7 seconds, a small bubble takes about 6 seconds to rise and a big one 4, and the light ripples drift a few LEDs a second. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Bubbles. At 0 a trickle of 4 bubbles a second from three spots on the bottom, a third of them rings 2 to 4 LEDs across and the rest single sparks; at 0.5 about 15 a second; at 1 a fizz of 46 a second from all over the bottom, most of them rings up to 6 LEDs across.\n// Knob 4: Stare. How often the eye turns to stare straight out at you: every 14 seconds at 0, every 13.4 at 0.06 (the first time 4 seconds in), every 3.6 at 1, where it hardly looks away. Each stare lasts about 3 seconds: the eye swings round to face out, swims up to the glass a fifth bigger, its pupil opens from a third of the iris to most of it, and the fluid glows up round it.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, acos, exp, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The jar, row by row: the lid, the neck, the shoulder curving out, the body\n// 50 LEDs across inside, the rounded bottom, and the shelf it stands on.\nconst CX = 32;\nconst LID0 = 9, LID1 = 20, NECK0 = 21, SH0 = 25, SH1 = 31, BOT0 = 106, BOT1 = 112, SHELF = 114;\n// The fluid's surface, a few rows below the shoulder.\nconst SURF = 34;\nfunction halfIn(y) {\n  if (y \u003c NECK0 || y >= BOT1) return -1;\n  if (y \u003c SH0) return 19.5;\n  if (y \u003c SH1) return 19.5 + 5.5 * sqrt(1 - ((SH1 - y) / (SH1 - SH0)) ** 2);\n  if (y \u003c BOT0) return 25;\n  const u = (y - BOT0) / (BOT1 - BOT0);\n  return 25 - 5 * (1 - sqrt(1 - u * u));\n}\n\n// The eye's size, and its iris and pupil as angles from the gaze axis.\nconst ER = 14.5, IRIS = 0.62;\n// Veins on the white: eight from the back of the eye towards the iris, each\n// with one branch, laid out in the eye's own angles (th from the gaze axis,\n// ph round it) so they turn with it. Each is tabled once, ph against th.\nconst VEINS = [], VT = 129;\nfor (let k = 0; k \u003c 8; k++) {\n  const ph0 = (k * TAU) / 8 + 0.35 * sin(k * 2.3), a = 0.22 + 0.08 * sin(k * 1.7), f = 3 + (k % 3), p = k * 1.3;\n  const tab = new Float32Array(VT);\n  for (let j = 0; j \u003c VT; j++) {\n    const th = (j * PI) / (VT - 1);\n    tab[j] = ph0 + a * sin(f * th + p) + 0.1 * sin(9 * th + 2 * p);\n  }\n  VEINS.push({ tab, end: 0.74 + 0.1 * ((k * 5) % 3), br: 1.3 + 0.25 * ((k * 3) % 4), bd: k % 2 ? 1 : -1 });\n}\n\nexport function setup(params) {\n  const reg = new Uint8Array(N), hw = new Float32Array(H);\n  for (let y = 0; y \u003c H; y++) hw[y] = halfIn(y);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, dx = abs(x + 0.5 - CX);\n      // 1 inside the glass, 2 the glass wall, 3 the thick base, 4 the lid,\n      // 5 the shelf top, 6 the shelf front, 0 the wall behind.\n      if (y >= LID0 && y \u003c= LID1) {\n        const r = y === LID0 ? 20.5 : y === LID0 + 1 ? 22 : 23;\n        if (dx \u003c r) reg[i] = 4;\n      } else if (hw[y] > 0 && dx \u003c hw[y]) reg[i] = 1;\n      else if (hw[y] > 0 && dx \u003c hw[y] + 1.3) reg[i] = 2;\n      else if (y >= BOT1 && y \u003c SHELF && dx \u003c 23) reg[i] = 3;\n      if (y >= SHELF && y \u003c SHELF + 2) reg[i] = 5;\n      else if (y >= SHELF + 2 && y \u003c SHELF + 9) reg[i] = 6;\n    }\n  params.s = {\n    t: 0, hue: 0, speed: 2, bub: 0, stareK: 0.06,\n    reg, hw,\n    // Where the eye looks and where it is headed, the stare's phase, how far\n    // it has turned to stare and how wide the pupil is.\n    yaw: 0.7, pitch: 0.2, roll: 0, tyaw: 0.7, tpitch: 0.2, next: 1.2,\n    sp: 0.7, stare: 0, dil: 0,\n    bubbles: [], acc: 0, pops: [],\n    rgb: new Float32Array(N * 3), nerve: new Float32Array(N), cs: new Float32Array(2 * W + H),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.bub = cl(k[2], 0, 1);\n  S.stareK = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  // The stare comes round every 14 seconds at 0 and every 3.6 at 1; for 3.1\n  // seconds of each round the eye turns to look straight out of the jar.\n  const period = mix(14, 3.6, S.stareK);\n  S.sp += g / period;\n  const into = (S.sp - floor(S.sp)) * period;\n  const staring = into \u003c 3.1;\n  S.stare += ((staring ? 1 : 0) - S.stare) * min(1, g * (staring ? 3.5 : 2));\n  S.dil += ((staring && into > 0.5 ? 1 : 0) - S.dil) * min(1, g * 2.2);\n  // Wandering: somewhere new to look every 1.5 to 3.5 seconds, a quarter of\n  // the time far round to the side, so the back of the eye and its nerve\n  // turn into view.\n  S.next -= g;\n  if (S.next \u003c= 0) {\n    S.next = 1.5 + 2 * Math.random();\n    S.tyaw = (Math.random() * 2 - 1) * (Math.random() \u003c 0.25 ? 2.3 : 1.1);\n    S.tpitch = (Math.random() * 2 - 1) * 0.6;\n  }\n  const ty = mix(S.tyaw, 0, S.stare), tp = mix(S.tpitch, 0, S.stare);\n  const rate = min(1, g * (1.2 + 3 * S.stare));\n  S.yaw += (ty - S.yaw) * rate;\n  S.pitch += (tp - S.pitch) * rate;\n  S.roll = 0.35 * sin(S.t * 0.23) + 0.15 * sin(S.t * 0.61);\n  // Bubbles: a trickle from three vents at 0, a fizz from all over the\n  // bottom at 1, more of them big.\n  S.acc += g * mix(4, 46, S.bub * S.bub);\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    const vent = Math.random() \u003c 0.85 - 0.6 * S.bub;\n    const x = vent ? CX + [-14, 3, 15][floor(Math.random() * 3)] + Math.random() * 2 - 1 : CX + (Math.random() * 2 - 1) * 22;\n    const r = Math.random() \u003c 0.3 + 0.4 * S.bub ? 1.1 + Math.random() * (0.9 + S.bub) : 0.5;\n    S.bubbles.push({ x, y: BOT1 - 1, z: Math.random() * 2 - 1, r, v: 2, ph: TAU * Math.random() });\n  }\n  for (const b of S.bubbles) {\n    b.v = min(b.v + g * 30, 9 + 7 * b.r);\n    b.y -= b.v * g;\n    // A zigzag of about one LED either side as it climbs.\n    b.x += 3 * sin(b.ph + b.y * 0.25) * g;\n    if (b.y \u003c SURF + 0.5) {\n      b.dead = 1;\n      S.pops.push({ x: b.x, life: 0.25 });\n    }\n  }\n  S.bubbles = S.bubbles.filter((b) => !b.dead);\n  for (const p of S.pops) p.life -= g;\n  S.pops = S.pops.filter((p) => p.life > 0);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, reg, hw, nerve, cs } = S, t = S.t;\n  const fl = hsv(0.29 + 0.63 * S.hue, 0.92, 1);\n  const iris = hsv(0.79 + 0.63 * S.hue, 0.8, 1);\n  // The eye: bobbing, swaying, swimming up to the glass when it stares.\n  const bobA = 1 - 0.6 * S.stare;\n  const ex = CX + 4 * sin(t * 0.45 + 1) * bobA;\n  const ey = 70 + (8 * sin(t * 0.9) + 1.5 * sin(t * 2.1)) * bobA;\n  const er = ER * (1 + 0.2 * S.stare);\n  const ca = cos(S.yaw), sa = sin(S.yaw), cb = cos(S.pitch), sb = sin(S.pitch);\n  const f = [sa * cb, sb, ca * cb];\n  // Two axes across the gaze, turned by the roll, for the angle round it.\n  const r0 = [ca, 0, -sa], u0 = [-sa * sb, cb, -ca * sb];\n  const cr = cos(S.roll), sr = sin(S.roll);\n  const rx = [r0[0] * cr + u0[0] * sr, r0[1] * cr + u0[1] * sr, r0[2] * cr + u0[2] * sr];\n  const ux = [u0[0] * cr - r0[0] * sr, u0[1] * cr - r0[1] * sr, u0[2] * cr - r0[2] * sr];\n  const pupil = mix(0.36, 0.7, S.dil);\n\n  // The optic nerve, a pink cord trailing from the back of the eye, waving\n  // in the fluid. Behind the eye while it looks out, in front of it when it\n  // looks away.\n  nerve.fill(0);\n  const front = f[2] \u003c 0;\n  {\n    let bx = -f[0], by = -f[1];\n    const bl = hypot(bx, by);\n    let dx = bl > 0.05 ? bx / bl : 0, dy = bl > 0.05 ? by / bl : 1;\n    let x = ex + er * bx, y = ey + er * by;\n    for (let s = 0; s \u003c 13; s++) {\n      const rad = 2.3 - 0.09 * s;\n      for (let yy = floor(y - rad); yy \u003c= y + rad; yy++)\n        for (let xx = floor(x - rad); xx \u003c= x + rad; xx++) {\n          if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n          const dd = hypot(xx + 0.5 - x, yy + 0.5 - y);\n          if (dd \u003c rad) nerve[yy * W + xx] = max(nerve[yy * W + xx], dd \u003c rad - 1 ? 1 : 0.6);\n        }\n      // Each step bends towards hanging down and waves with the fluid.\n      const a = atan2(dy, dx), down = PI / 2, wave = 0.32 * sin(t * 1.6 - s * 0.45);\n      const na = a + 0.12 * wrap(down - a) + wave * 0.35;\n      dx = cos(na);\n      dy = sin(na);\n      x += 2 * dx;\n      y += 2 * dy;\n    }\n  }\n\n  // The caustics: three wavy bands, light where their sum crosses zero.\n  // Their inner waves are kept per row, per column and per diagonal.\n  for (let i = 0; i \u003c W + H; i++) cs[i] = 0.7 * sin((i - H) * 0.1 + t * 0.9);\n  for (let x = 0; x \u003c W; x++) cs[W + H + x] = 0.9 * sin(x * 0.15 - t * 0.6);\n  const glowE = 0.1 * (0.6 + 1.4 * S.stare), flare = 1 + 0.5 * S.stare;\n  const gx = CX - 18.5, gy = 37 + ((t * 11) % 130);\n\n  for (let y = 0; y \u003c H; y++) {\n    const rowW = 0.9 * sin(y * 0.13 + t * 0.9);\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, rg = reg[i], px = x + 0.5, py = y + 0.5;\n      let r = 0.035, gg = 0.012, b = 0.06;\n      if (rg === 1) {\n        // The fluid's surface waves, and climbs a row at the glass.\n        const sy = SURF + 0.6 * sin(0.35 * x + 1.9 * t) + 0.4 * sin(0.6 * x - 2.7 * t) - (abs(px - CX) > hw[y] - 2 ? 1 : 0);\n        if (py \u003c sy - 0.5) {\n          // Air above the fluid, faintly lit from below.\n          r = 0.03 + 0.06 * fl[0];\n          gg = 0.02 + 0.08 * fl[1];\n          b = 0.06 + 0.06 * fl[2];\n        } else {\n          const cyl = 1 - ((px - CX) / hw[y]) ** 2;\n          const a1 = x * 0.21 + rowW + t * 0.75;\n          const a2 = y * 0.17 + cs[W + H + x] - t * 1.1;\n          const a3 = (x + y) * 0.12 + cs[x - y + H];\n          const cv = abs(sin(a1) + sin(a2) + sin(a3));\n          const caus = cv \u003c 0.3 ? 1 - cv / 0.3 : 0;\n          const de = sqrt((px - ex) ** 2 + (py - ey) ** 2) - er;\n          let L = (0.07 + 0.2 * cyl * cyl) * flare + caus * (0.3 + 0.45 * cyl) + (de > 0 && de \u003c 24 ? glowE * exp(-de / 6) : 0);\n          if (py \u003c sy + 0.5) L = 0.95;\n          L = q(L, 14);\n          r = fl[0] * L;\n          gg = fl[1] * L;\n          b = fl[2] * L;\n        }\n      } else if (rg === 2) {\n        r = 0.16 + 0.22 * fl[0];\n        gg = 0.18 + 0.26 * fl[1];\n        b = 0.22 + 0.22 * fl[2];\n      } else if (rg === 3) {\n        r = fl[0] * 0.5;\n        gg = fl[1] * 0.5;\n        b = fl[2] * 0.5;\n      } else if (rg === 4) {\n        // Pewter lid: ridges, round shading, a bright band and a faint one.\n        const dx = abs(px - CX), round_ = 0.6 + 0.4 * sqrt(max(0, 1 - (dx / 23) ** 2));\n        const ridge = (y - LID0) % 2 === 0 ? 1.25 : 0.8;\n        const spec = abs(px - (CX - 12)) \u003c 1.5 ? 2.8 : abs(px - (CX + 9)) \u003c 1 ? 1.6 : 1;\n        const v = ridge * spec * round_ * (y === LID1 ? 0.6 : 1);\n        r = 0.17 * v;\n        gg = 0.13 * v;\n        b = 0.25 * v;\n        if (y === LID0) (r = 0.42), (gg = 0.36), (b = 0.52);\n      } else if (rg === 5) {\n        const pool = exp(-abs(px - CX) / 16);\n        r = 0.2 + 0.45 * pool * fl[0];\n        gg = 0.1 + 0.45 * pool * fl[1];\n        b = 0.28 + 0.45 * pool * fl[2];\n      } else if (rg === 6) {\n        const edge = y === SHELF + 2;\n        r = edge ? 0.26 : 0.1;\n        gg = edge ? 0.15 : 0.04;\n        b = edge ? 0.36 : 0.16;\n      } else if (y \u003c SHELF) {\n        // The wall behind: violet dark, with the fluid's glow round the jar.\n        const hwy = hw[cl(y, NECK0, BOT1 - 1)];\n        const dxo = max(0, abs(px - CX) - (hwy > 0 ? hwy : 22));\n        const glow = 0.1 * exp(-dxo / 5) * (y > SURF ? 1 : 0.4);\n        r += glow * fl[0];\n        gg += glow * fl[1];\n        b += glow * fl[2];\n      }\n      if (rg === 1) {\n        const u = (px - ex) / er, v = (py - ey) / er, d2 = u * u + v * v;\n        const nv = nerve[i];\n        if (nv && (front || d2 >= 1)) {\n          r = 0.9 * nv;\n          gg = 0.32 * nv;\n          b = 0.42 * nv;\n        } else if (d2 \u003c 1) {\n          const nz = sqrt(1 - d2), cosA = u * f[0] + v * f[1] + nz * f[2];\n          const th = acos(cl(cosA, -1, 1));\n          // Lit by the fluid all round, brightest where it faces out.\n          const sh = 0.55 + 0.45 * nz;\n          if (th \u003c IRIS * pupil) (r = 0), (gg = 0), (b = 0);\n          else if (th \u003c IRIS) {\n            const tt = th / IRIS;\n            const ph = atan2(u * ux[0] + v * ux[1] + nz * ux[2], u * rx[0] + v * rx[1] + nz * rx[2]);\n            // Fibres round the pupil, a pale ring at its edge, a near-black\n            // ring at the rim. The iris never goes below 0.6 of full, so a\n            // gold one stays gold and does not turn olive.\n            const streak = 0.8 + 0.2 * sin(ph * 15 + 3 * sin(ph * 4));\n            const vv = tt > 0.86 ? 0.05 : streak * (tt \u003c pupil + 0.12 ? 1 : 0.85) * (0.75 + 0.25 * sh);\n            r = iris[0] * vv;\n            gg = iris[1] * vv;\n            b = iris[2] * vv;\n          } else {\n            const rim = (1 - nz) * (1 - nz);\n            r = mix(1, fl[0], 0.7 * rim) * sh;\n            gg = mix(0.97, fl[1], 0.7 * rim) * sh;\n            b = mix(0.95, fl[2], 0.7 * rim) * sh;\n            const ph = atan2(u * ux[0] + v * ux[1] + nz * ux[2], u * rx[0] + v * rx[1] + nz * rx[2]);\n            const st = sin(th) * er, j = round((th / PI) * (VT - 1)), w = 0.45 + 0.35 * (th / PI);\n            for (const vn of VEINS) {\n              if (th \u003c vn.end) continue;\n              const vp = vn.tab[j];\n              if (abs(wrap(ph - vp)) * st \u003c w || (th \u003c vn.br && th > vn.end + 0.1 && abs(wrap(ph - vp - vn.bd * 0.9 * (vn.br - th))) * st \u003c w * 0.8)) {\n                r = 0.8 * sh;\n                gg = 0.02 * sh;\n                b = 0.06 * sh;\n                break;\n              }\n            }\n          }\n          // The wet glint.\n          if ((u + 0.38) ** 2 + (v + 0.42) ** 2 \u003c 0.018) (r = 1), (gg = 1), (b = 1);\n        }\n      }\n      // The glass catches the light: a streak down its left side with a glint\n      // sliding down it, a fainter one on the right.\n      if ((rg === 1 || rg === 2) && y > 36 && y \u003c 104) {\n        let hl = 0;\n        if (abs(px - gx) \u003c 1) hl = abs(py - gy) \u003c 3 ? 0.7 : 0.26;\n        else if (abs(px - (CX + 21.5)) \u003c 0.6 && y > 42 && y \u003c 98) hl = 0.16;\n        r += hl;\n        gg += hl;\n        b += hl;\n      }\n      const o = i * 3;\n      rgb[o] = r;\n      rgb[o + 1] = gg;\n      rgb[o + 2] = b;\n    }\n  }\n  // Bubbles: a bright point, or a ring for the bigger ones; those behind the\n  // eye are hidden by it.\n  for (const bb of S.bubbles) {\n    const R = bb.r, x0 = floor(bb.x - R - 1), y0 = floor(bb.y - R - 1);\n    for (let y = y0; y \u003c= y0 + 2 * R + 2; y++)\n      for (let x = x0; x \u003c= x0 + 2 * R + 2; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || reg[y * W + x] !== 1) continue;\n        if (bb.z \u003c 0 && (x + 0.5 - ex) ** 2 + (y + 0.5 - ey) ** 2 \u003c er * er) continue;\n        const dd = hypot(x + 0.5 - bb.x, y + 0.5 - bb.y);\n        if (R \u003c 1 ? dd \u003c 0.75 : abs(dd - R) \u003c 0.55) {\n          const o = (y * W + x) * 3;\n          rgb[o] = mix(fl[0], 1, 0.6);\n          rgb[o + 1] = mix(fl[1], 1, 0.6);\n          rgb[o + 2] = mix(fl[2], 1, 0.6);\n        }\n      }\n  }\n  // A popped bubble flicks two drops off the surface.\n  for (const p of S.pops) {\n    const y = SURF - 2 - (p.life \u003c 0.12 ? 1 : 0);\n    for (const dx of [-1, 1]) {\n      const x = floor(p.x + dx * (1.5 - p.life * 2));\n      if (x \u003c 0 || x >= W || reg[y * W + x] !== 1) continue;\n      const o = (y * W + x) * 3;\n      rgb[o] = mix(fl[0], 1, 0.5);\n      rgb[o + 1] = mix(fl[1], 1, 0.5);\n      rgb[o + 2] = mix(fl[2], 1, 0.5);\n    }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, floor(i / W), round(255 * cl(rgb[o], 0, 1)), round(255 * cl(rgb[o + 1], 0, 1)), round(255 * cl(rgb[o + 2], 0, 1)));\n  }\n}\n","swarmalators":"// ===== Patternflow pattern =====\n// Title:   Swarmalators\n// Family:  particle\n// Idea:    Two swarms of 150 swarmalators stacked down the panel, each a hard dot coloured by its phase that is pulled towards dots of a like colour and kept off by all of them, settle into rainbow rings whose colour runs once round, and as the phase coupling swings slowly up and down the rings squeeze into ovals, splinter and churn, the lower swarm always a step further along the coupling, where its dots circulate round the ring.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Swarmalators (Kevin O'Keeffe, Hyunsuk Hong and Steven Strogatz, 2017), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Coupling=-1..0.5, Tour=0..1\n//\n// Knob 1: Hue. Turns every dot's colour round the wheel together. Each ring always carries the whole wheel, so the knob turns which colour sits where: at 0 the top ring starts red on its right, cyan on its left, blue and magenta on top and yellow and green below; at 0.5 the two halves swap. A swarm that has synchronised is one solid disc: with Coupling at 0.5 the top one goes red at Hue 0 and cyan at 0.5.\n// Knob 2: Speed. At 2 the equations run 4 of their time units a second, so a dot circulating in the bottom ring moves about 11 LEDs a second, and the coupling swing takes 24 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Coupling. The phase coupling K of the top swarm; the bottom swarm's is always 0.75 lower. At 0 the top is the static phase wave, a still rainbow ring, and the bottom the active phase wave, its dots circulating and jostling round a looser ring. At 0.5 the top synchronises within 8 seconds, folding its ring into one solid disc of a single colour 23 LEDs across, while the bottom stiffens into a clean still ring. At -1 the top churns at the edge of disorder and the bottom is static async, a disc of confetti.\n// Knob 4: Tour. How far K swings, slowly, about where Coupling puts it: plus and minus the square root of Tour, once every 24 seconds at Speed 2. At 0 there is no swing and only a faint spread of natural frequencies keeps the still ring creeping; at 0.06 K swings by 0.25, so the top ring squeezes into an oval towards sync for 12 seconds and splinters for 12; at 1 K swings by 1: every lap the top ring folds into a one-colour disc, breaks into confetti and opens back into a ring, and the bottom runs from a still ring through its circulating one to confetti and back.\n\nconst W = 64, H = 128;\nconst { floor, sqrt, sin, cos, PI, round, ceil, max } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The swarm is round and the panel is twice as tall as it is wide, so it\n// carries two swarms, one in each 64 by 64 half, each the model untouched.\n// 150 dots a swarm, one unit of the equations is 18.5 LEDs (the widest\n// state, the static phase wave, reaches 1.53 units, 28 LEDs, from its\n// centre), and a dot is a hard disc of radius 1.76 LEDs, about 10 LEDs.\n// At 120 dots of radius 1.6 the panel lit 22% and its colourfulness was\n// 0.49; this size lights 29% and reaches 0.57.\nconst N = 150, SC = 18.5, R2 = 3.1;\n// The bottom swarm's coupling sits this far below the top's, so the two show\n// neighbouring states; the slow swing of K has this period in story seconds;\n// and the natural frequencies are spread evenly over plus and minus this.\nconst GAP = 0.75, PERIOD = 24, SIG = 0.02;\n\n// The hue scale lingers on the six pure colours and hurries through the\n// in-between ones, so a ring reads as six bands of red, yellow, green, cyan,\n// blue and magenta, each dot at 255 in its strongest channel. Applied twice:\n// once still showed orange and azure arcs that the panel draws dull.\nconst ux = (h) => h - sin(6 * TAU * h) / (6 * TAU);\n\n// A swarm: positions, phases, natural frequencies. The top one starts as the\n// static phase wave it is about to be, phase equal to angle round a ring; the\n// bottom starts as the paper does, phases at random in a disc.\nfunction swarm(cy, ring) {\n  const x = new Float32Array(N), y = new Float32Array(N), th = new Float32Array(N), om = new Float32Array(N);\n  for (let i = 0; i \u003c N; i++) {\n    const a = (TAU * (i + Math.random())) / N, r = ring ? 0.65 + 0.85 * Math.random() : 1.2 * sqrt(Math.random());\n    const b = ring ? a : TAU * Math.random();\n    x[i] = r * cos(b);\n    y[i] = r * sin(b);\n    th[i] = a;\n    om[i] = SIG * ((2 * (i + 0.5)) / N - 1);\n  }\n  for (let i = N - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = om[i];\n    om[i] = om[j];\n    om[j] = t;\n  }\n  return { cy, x, y, th, om, vx: new Float32Array(N), vy: new Float32Array(N), w: new Float32Array(N), c: new Float32Array(N), s: new Float32Array(N), K: 0 };\n}\n\n// One Euler step of the swarmalator equations with A = B = J = 1:\n//   dx_i/dt = 1/N sum_j [ (x_j - x_i)/|x_j - x_i| (1 + cos(th_j - th_i)) - (x_j - x_i)/|x_j - x_i|^2 ]\n//   dth_i/dt = om_i + K/N sum_j sin(th_j - th_i)/|x_j - x_i|\n// Each pair is visited once and its pull handed to both dots with opposite\n// signs, so the swarm's centre never moves. cos and sin of the phase\n// difference come from each dot's own cos and sin, with no trigonometry in\n// the pair loop. A frame at Speed 2 is two steps of each swarm, 11175 pairs\n// a step, and with the drawing it takes under 2 ms.\nfunction step(sw, K, dt) {\n  const { x, y, th, om, vx, vy, w, c, s } = sw;\n  for (let i = 0; i \u003c N; i++) {\n    c[i] = cos(th[i]);\n    s[i] = sin(th[i]);\n    vx[i] = vy[i] = w[i] = 0;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const xi = x[i], yi = y[i], ci = c[i], si = s[i];\n    let ax = 0, ay = 0, aw = 0;\n    for (let j = i + 1; j \u003c N; j++) {\n      const dx = x[j] - xi, dy = y[j] - yi, d2 = dx * dx + dy * dy + 1e-6, inv = 1 / sqrt(d2);\n      const cd = c[j] * ci + s[j] * si, sd = s[j] * ci - c[j] * si;\n      // Attraction of constant strength 1 + cos, stronger between like\n      // phases and gone between opposite ones; repulsion falling as 1/r.\n      const f = (1 + cd) * inv - 1 / d2;\n      const fx = f * dx, fy = f * dy;\n      ax += fx;\n      ay += fy;\n      vx[j] -= fx;\n      vy[j] -= fy;\n      const pw = sd * inv;\n      aw += pw;\n      w[j] -= pw;\n    }\n    vx[i] += ax;\n    vy[i] += ay;\n    w[i] += aw;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    x[i] += (dt * vx[i]) / N;\n    y[i] += (dt * vy[i]) / N;\n    const t = th[i] + dt * (om[i] + (K * w[i]) / N);\n    th[i] = t - TAU * floor(t / TAU);\n  }\n}\n\nexport function setup(params) {\n  const top = swarm(32, true), bot = swarm(96, false);\n  // Thirty time units at K = -0.75 before the first frame: from its random\n  // disc the bottom swarm has found the active phase wave by then.\n  for (let q = 0; q \u003c 300; q++) step(bot, -GAP, 0.1);\n  params.s = { hue: 0, speed: 2, K: 0, tour: 0.06, t: 0, sw: [top, bot], buf: new Uint8Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.K = cl(k[2], -1, 0.5);\n  S.tour = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  // The tour: both couplings swing together, a sine about the knob's K.\n  const swing = sqrt(S.tour) * sin((TAU * S.t) / PERIOD);\n  S.sw[0].K = S.K + swing;\n  S.sw[1].K = S.K - GAP + swing;\n  // Four time units a story second, in steps of at most 0.07.\n  const T = g * 4;\n  const n = max(1, ceil(T / 0.07));\n  for (let q = 0; q \u003c n; q++) for (const sw of S.sw) step(sw, sw.K, T / n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf;\n  buf.fill(0);\n  for (const sw of S.sw) {\n    // Each swarm keeps to its own half: a dot flung out (one in antiphase\n    // with the rest feels no pull, only the push) leaves the panel rather\n    // than wander into the other swarm.\n    const y0h = sw.cy - 32, y1h = sw.cy + 32;\n    let mx = 0, my = 0;\n    for (let i = 0; i \u003c N; i++) (mx += sw.x[i]), (my += sw.y[i]);\n    mx /= N;\n    my /= N;\n    for (let i = 0; i \u003c N; i++) {\n      const c = hsv(ux(ux(sw.th[i] / TAU + S.hue)), 1, 1);\n      const r = round(c[0] * 255), g = round(c[1] * 255), b = round(c[2] * 255);\n      const px = 32 + (sw.x[i] - mx) * SC, py = sw.cy + (sw.y[i] - my) * SC;\n      const x0 = floor(px), y0 = floor(py);\n      for (let dy = -2; dy \u003c= 2; dy++)\n        for (let dx = -2; dx \u003c= 2; dx++) {\n          const ex = x0 + dx + 0.5 - px, ey = y0 + dy + 0.5 - py;\n          if (ex * ex + ey * ey > R2) continue;\n          const xx = x0 + dx, yy = y0 + dy;\n          if (xx \u003c 0 || xx >= W || yy \u003c y0h || yy >= y1h) continue;\n          const o = (yy * W + xx) * 3;\n          buf[o] = r;\n          buf[o + 1] = g;\n          buf[o + 2] = b;\n        }\n    }\n  }\n  for (let i = 0; i \u003c W * H; i++) display.setPixel(i % W, floor(i / W), buf[i * 3], buf[i * 3 + 1], buf[i * 3 + 2]);\n}\n","talking-board":"// ===== Patternflow pattern =====\n// Title:   Talking Board\n// Family:  halloween\n// Idea:    A near-black spirit board lies on the table between two candles, its bone-white alphabet in two arcs, the numbers, YES and NO by a sun and a moon, GOODBYE at the foot, and the heart-shaped pointer glides over it on its own, circling, tilting as it swings, stopping with its round glass window over one letter at a time, which lights up green through the glass and joins a word spelled out above the board: HELLO, BOO, BEHIND YOU, YES, I SEE YOU, 1031, NO, RUN and at last GOODBYE.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Flicker=0..1, Aura=0..1\n//\n// Knob 1: Hue. The colour of whatever answers: the light in and round the pointer's window, the lit letter and the spelled word open a poison green at 0, turn cyan at 0.25, blue at 0.5, violet at 0.75 and pink at 1. The board's dark lacquer turns with it through the cold hues only, violet at 0, magenta at 0.25 and blue at 0.75, so it never goes brown; the bone letters and the candles stay as they are.\n// Knob 2: Speed. At 2 the pointer glides about 55 LEDs a second and rests 0.65 seconds on each letter once it lights; HELLO takes 13 seconds from the first circling to the word fading, and all nine messages 111. At 0.2 everything runs ten times slower, at 3 half as fast again. The candles flicker at their own pace.\n// Knob 3: Flicker. How the two candles burn: at 0 low and nearly still, the foot of the board in a steady pool of light; at 1 the flames stand 40 per cent taller, gutter and lean, a ragged dip can halve one, and their light reaches nearly twice as far up the board, swelling and sinking with them.\n// Knob 4: Aura. The answer's own light round the pointer: at 0.06 a soft glow about 18 LEDs round the window that brightens when a letter lights; at 1 it spreads over 42 LEDs, twice as strong, and washes most of the board in its colour.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ss = (t) => t * t * (3 - 2 * t);\nconst q = (v, n) => round(v * n) / n;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The board's letters, 3 by 5: five rows of three bits, as octal digits.\nconst F3 = {\n  A: \"25755\", B: \"65656\", C: \"34443\", D: \"65556\", E: \"74647\", F: \"74644\", G: \"34553\", H: \"55755\", I: \"72227\",\n  J: \"11152\", K: \"55655\", L: \"44447\", M: \"57755\", N: \"65555\", O: \"25552\", P: \"65644\", Q: \"25563\", R: \"65655\",\n  S: \"34216\", T: \"72222\", U: \"55557\", V: \"55552\", W: \"55775\", X: \"55255\", Y: \"55222\", Z: \"71247\",\n  0: \"75557\", 1: \"26227\", 2: \"61247\", 3: \"61216\", 4: \"55711\", 5: \"74616\", 6: \"34757\", 7: \"71222\", 8: \"75757\", 9: \"75716\",\n};\n// The spelled word's letters, 5 by 7: seven rows of five bits.\nconst F5 = {\n  A: [14, 17, 17, 31, 17, 17, 17], B: [30, 17, 17, 30, 17, 17, 30], C: [14, 17, 16, 16, 16, 17, 14], D: [28, 18, 17, 17, 17, 18, 28],\n  E: [31, 16, 16, 30, 16, 16, 31], F: [31, 16, 16, 30, 16, 16, 16], G: [14, 17, 16, 23, 17, 17, 15], H: [17, 17, 17, 31, 17, 17, 17],\n  I: [14, 4, 4, 4, 4, 4, 14], J: [7, 2, 2, 2, 2, 18, 12], K: [17, 18, 20, 24, 20, 18, 17], L: [16, 16, 16, 16, 16, 16, 31],\n  M: [17, 27, 21, 21, 17, 17, 17], N: [17, 17, 25, 21, 19, 17, 17], O: [14, 17, 17, 17, 17, 17, 14], P: [30, 17, 17, 30, 16, 16, 16],\n  Q: [14, 17, 17, 17, 21, 18, 13], R: [30, 17, 17, 30, 20, 18, 17], S: [15, 16, 16, 14, 1, 1, 30], T: [31, 4, 4, 4, 4, 4, 4],\n  U: [17, 17, 17, 17, 17, 17, 14], V: [17, 17, 17, 17, 17, 10, 4], W: [17, 17, 17, 21, 21, 21, 10], X: [17, 17, 10, 4, 10, 17, 17],\n  Y: [17, 17, 17, 10, 4, 4, 4], Z: [31, 1, 2, 4, 8, 16, 31], 0: [14, 17, 19, 21, 25, 17, 14], 1: [4, 12, 4, 4, 4, 4, 14],\n  2: [14, 17, 1, 2, 4, 8, 31], 3: [31, 2, 4, 2, 1, 17, 14], 4: [2, 6, 10, 18, 31, 2, 2], 5: [31, 16, 30, 1, 1, 17, 14],\n  6: [6, 8, 16, 30, 17, 17, 14], 7: [31, 1, 2, 4, 8, 8, 8], 8: [14, 17, 17, 14, 17, 17, 14], 9: [14, 17, 17, 15, 1, 2, 12],\n};\n\n// The board fills the panel below the spelled word, from row 20 down,\n// with a thin edge line 2 LEDs in.\nconst BTOP = 20;\n// The two alphabet arcs share a centre below them: A to M on the outer\n// arc from -50 to 50 degrees, N to Z on the inner one from -66 to 66.\nconst ARC_X = 32, ARC_Y = 80.5, R1 = 36.5, R2 = 23.5;\n// Where the pointer waits between words, and the two candles.\nconst REST = [32, 96];\nconst CANDLES = [[7, 120], [56, 120]];\n// The messages, spelled in turn. YES, NO and GOODBYE are answered with\n// the printed words.\nconst MESSAGES = [\"HELLO\", \"BOO\", \"BEHIND YOU\", \"YES\", \"I SEE YOU\", \"1031\", \"NO\", \"RUN\", \"GOODBYE\"];\n// Story seconds (one a second at Speed 2): the search loop before a word,\n// settling on a letter, the letter lighting, the rest on it once lit, the\n// hold on a finished word and its fade.\nconst SEARCH = 1.6, SETTLE = 0.15, LIGHT = 0.22, LINGER = 0.65, HOLD = 1.4, FADE = 1.4;\n\nexport function setup(params) {\n  const ink = new Uint8Array(N), glyphOf = new Int16Array(N).fill(-1), haloOf = new Int16Array(N).fill(-1);\n  const glyphs = [], targets = {};\n  // Print one 3 by 5 glyph with its centre at (cx, cy); returns its id.\n  const put = (ch, cx, cy) => {\n    const x0 = round(cx - 1.5), y0 = round(cy - 2.5), id = glyphs.length, rows = F3[ch];\n    glyphs.push({ x0, y0 });\n    for (let r = 0; r \u003c 5; r++)\n      for (let c = 0; c \u003c 3; c++)\n        if ((+rows[r] >> (2 - c)) & 1) {\n          const p = (y0 + r) * W + x0 + c;\n          ink[p] = 1;\n          glyphOf[p] = id;\n        }\n    return id;\n  };\n  const word = (text, cx, cy) => {\n    const ids = [], x0 = cx - (text.length * 4 - 1) / 2 + 1.5;\n    [...text].forEach((ch, i) => ids.push(put(ch, x0 + i * 4, cy)));\n    targets[text] = { x: cx, y: cy, ids };\n  };\n  const arc = (letters, R, a0) => {\n    [...letters].forEach((ch, i) => {\n      const a = ((-a0 + (2 * a0 * i) / (letters.length - 1)) * PI) / 180;\n      const x = ARC_X + R * sin(a), y = ARC_Y - R * cos(a);\n      targets[ch] = { x: round(x - 1.5) + 1.5, y: round(y - 2.5) + 2.5, ids: [put(ch, x, y)] };\n    });\n  };\n  arc(\"ABCDEFGHIJKLM\", R1, 50);\n  arc(\"NOPQRSTUVWXYZ\", R2, 66);\n  [...\"1234567890\"].forEach((ch, i) => {\n    const x = 32 + (i - 4.5) * 6;\n    targets[ch] = { x: round(x - 1.5) + 1.5, y: 84.5, ids: [put(ch, x, 84.5)] };\n  });\n  word(\"YES\", 16.5, 30.5);\n  word(\"NO\", 48, 30.5);\n  word(\"GOODBYE\", 32, 108.5);\n  // A glow ring round each glyph, for when it lights.\n  for (let p = 0; p \u003c N; p++) {\n    if (ink[p]) continue;\n    const x = p % W, y = floor(p / W);\n    for (let dy = -1; dy \u003c= 1 && haloOf[p] \u003c 0; dy++)\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        const xx = x + dx, yy = y + dy;\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H && glyphOf[yy * W + xx] >= 0) {\n          haloOf[p] = glyphOf[yy * W + xx];\n          break;\n        }\n      }\n  }\n  // The sun by YES and the moon by NO, the board's edge, and the table.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, px = x + 0.5, py = y + 0.5;\n      const ds = hypot(px - 5, py - 30.5);\n      if (ds \u003c 2.3 || (ds > 3.4 && ds \u003c 4.6 && floor(((Math.atan2(py - 30.5, px - 5) / TAU) * 16 + 16.5) % 2) === 0)) ink[p] = 2;\n      const dm = hypot(px - 58, py - 30.5), dm2 = hypot(px - 59.6, py - 29.3);\n      if (dm \u003c 3.6 && dm2 > 3) ink[p] = 2;\n      // The edge: a thin line 2 LEDs in from a rounded rectangle.\n      const ex = max(0, abs(px - 32) - 25), ey = max(0, abs(py - 74) - 47);\n      const e = hypot(ex, ey);\n      if (abs(e - 4.5) \u003c 0.5) ink[p] = 3;\n      if (e > 6.5 || py \u003c BTOP) ink[p] = 4;\n    }\n  params.s = {\n    hue: 0, speed: 2, flick: 0, aura: 0.06, rt: 0,\n    ink, glyphOf, haloOf, glyphs, targets, lit: new Float32Array(glyphs.length),\n    // The pointer: where it is, its tilt, and the step it is on.\n    px: REST[0], py: REST[1], ang: 0, vx: 0,\n    msg: 0, steps: [], si: 0, st: 0, mv: null, said: \"\", flash: 0, wordA: 1,\n    flame: [1, 1], sway: [0, 0], light: new Float32Array(N * 3),\n  };\n  plan(params.s);\n  // The first search is a short one.\n  params.s.steps[0] = { k: \"loop\", r: 6, dur: 0.5 };\n}\n\n// The steps for one message: a search loop, then for each letter a glide\n// to it (a small loop first when a letter repeats), a hold and a fade.\nfunction plan(S) {\n  const text = MESSAGES[S.msg % MESSAGES.length], steps = [{ k: \"loop\", r: 10, dur: SEARCH }];\n  if (S.targets[text] && text.length > 1) steps.push({ k: \"go\", t: S.targets[text], say: text });\n  else {\n    let prev = null;\n    for (const ch of text) {\n      if (ch === \" \") {\n        steps.push({ k: \"go\", t: { x: REST[0], y: REST[1] - 4, ids: [] }, say: \" \" });\n        prev = null;\n        continue;\n      }\n      if (prev === ch) steps.push({ k: \"loop\", r: 5, dur: 0.7 });\n      steps.push({ k: \"go\", t: S.targets[ch], say: ch });\n      prev = ch;\n    }\n  }\n  steps.push({ k: \"hold\", dur: HOLD }, { k: \"fade\", dur: FADE });\n  S.steps = steps;\n  S.si = 0;\n  S.st = 0;\n  S.mv = null;\n  S.said = \"\";\n  S.text = text;\n  S.wordA = 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.flick = cl(k[2], 0, 1);\n  S.aura = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.rt += d;\n  // The candles keep their own time: two beats each and a slow sway. With\n  // Flicker up the flames burn taller and throw more light, and a ragged\n  // gutter can drop one to half.\n  const fk = 0.12 + 0.88 * S.flick, t = S.rt;\n  for (let i = 0; i \u003c 2; i++) {\n    const o = i * 2.3;\n    const gut = 0.5 + 0.5 * sin(t * 3.1 + o) * sin(t * 1.7 + 2 * o);\n    S.flame[i] = (1 + 0.4 * S.flick) * (1 - fk * (0.1 + 0.08 * sin(t * 13.1 + o) + 0.06 * sin(t * 7.3 + 1.3 * sin(t * 2.1 + o))) - 0.4 * S.flick * gut * gut);\n    S.sway[i] = fk * (0.8 * sin(t * 1.7 + o) + 0.5 * sin(t * 4.3 + 3 * o));\n  }\n  const x0 = S.px, y0 = S.py;\n  const step = S.steps[S.si];\n  S.st += g;\n  if (step.k === \"loop\") {\n    // A loop that starts and ends where the pointer is.\n    if (!S.mv) S.mv = { x: S.px, y: S.py };\n    const u = cl(S.st / step.dur, 0, 1), a = TAU * ss(u);\n    S.px = S.mv.x + step.r * sin(a);\n    S.py = S.mv.y - step.r * (1 - cos(a)) * 0.8;\n    if (u >= 1) nextStep(S);\n  } else if (step.k === \"go\") {\n    if (!S.mv) {\n      // A curved glide: a quadratic path bowed to one side by up to a\n      // third of its length, at about 55 LEDs a second.\n      const dx = step.t.x - S.px, dy = step.t.y - S.py, L = hypot(dx, dy);\n      const bow = (Math.random() - 0.5) * 0.6 * L;\n      S.mv = { x0: S.px, y0: S.py, cx: S.px + dx / 2 - (dy / (L || 1)) * bow, cy: S.py + dy / 2 + (dx / (L || 1)) * bow, dur: 0.3 + L / 55, said: false };\n    }\n    const m = S.mv, u = cl(S.st / m.dur, 0, 1), e = ss(u);\n    const a = (1 - e) * (1 - e), b = 2 * (1 - e) * e, c = e * e;\n    S.px = a * m.x0 + b * m.cx + c * step.t.x;\n    S.py = a * m.y0 + b * m.cy + c * step.t.y;\n    const rest = S.st - m.dur;\n    if (rest > SETTLE) for (const id of step.t.ids) S.lit[id] = max(S.lit[id], cl((rest - SETTLE) / LIGHT, 0, 1));\n    if (rest > SETTLE + LIGHT && !m.said) {\n      // The letter is read: it joins the word.\n      m.said = true;\n      S.said += step.say;\n      S.flash = 1;\n    }\n    if (rest > SETTLE + LIGHT + LINGER) nextStep(S);\n  } else if (step.k === \"hold\") {\n    if (S.st >= step.dur) nextStep(S);\n  } else if (step.k === \"fade\") {\n    // The word fades as the pointer drifts back to where it waits.\n    if (!S.mv) S.mv = { x: S.px, y: S.py };\n    const u = cl(S.st / step.dur, 0, 1), e = ss(u);\n    S.px = mix(S.mv.x, REST[0], e);\n    S.py = mix(S.mv.y, REST[1], e);\n    S.wordA = 1 - e;\n    if (u >= 1) {\n      S.msg++;\n      plan(S);\n    }\n  }\n  // Letters let go of their light once the pointer leaves them.\n  const cur = S.steps[S.si];\n  const keep = cur && cur.k === \"go\" && S.mv && S.mv.said ? cur.t.ids : null;\n  for (let i = 0; i \u003c S.lit.length; i++) if (!keep || !keep.includes(i)) S.lit[i] = max(0, S.lit[i] - g / 0.5);\n  S.flash = max(0, S.flash - g / 0.6);\n  // Tilt with the swing: the pointer leans into its sideways motion.\n  if (g > 0) {\n    const vx = (S.px - x0) / g;\n    S.vx += (vx - S.vx) * min(1, g * 8);\n    S.ang += (cl(-S.vx * 0.006, -0.38, 0.38) - S.ang) * min(1, g * 6);\n  }\n}\n\nfunction nextStep(S) {\n  S.si = min(S.si + 1, S.steps.length - 1);\n  S.st = 0;\n  S.mv = null;\n}\n\n// The pointer, in its own frame with the window centre at the origin: a\n// heart with its point up, 25 LEDs wide and 24 tall. Returns 0 outside, 1\n// for the body, 2 for its rim, 3 for the window's brass ring and 4 inside\n// the glass.\nfunction pointer(lx, ly) {\n  const rw = hypot(lx, ly);\n  if (rw \u003c 4.4) return 4;\n  if (rw \u003c 5.6) return 3;\n  const X = lx / 11, Y = (ly + 1.8) / 11;\n  const h = X * X + Y * Y - 1;\n  if (h * h * h - X * X * Y * Y * Y > 0) return 0;\n  // Within about 1.3 LEDs of the outline: the rim.\n  const X2 = lx / 9.7, Y2 = (ly + 1.3) / 9.7, h2 = X2 * X2 + Y2 * Y2 - 1;\n  return h2 * h2 * h2 - X2 * X2 * Y2 * Y2 * Y2 > 0 ? 2 : 1;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { ink, glyphOf, haloOf, lit, light } = S;\n  // The answer's colour runs from green through cyan, blue and violet to\n  // pink and never through orange, which dims to brown on a dark board.\n  const spirit = hsv(0.33 + 0.64 * S.hue, 0.85, 1);\n  // The board's lacquer turns with Hue only through the cold hues, violet\n  // at 0, so a near-black board never reads brown.\n  const tint = hsv(0.77 + 0.17 * sin(2 * PI * S.hue), 0.7, 1);\n  // Candlelight: a broad pool in the lacquer's colour, and a warm halo\n  // close round each flame, bright enough to stay orange.\n  const fl0 = S.flame[0], fl1 = S.flame[1];\n  const c0x = CANDLES[0][0], c0y = CANDLES[0][1] - 6, c1x = CANDLES[1][0], c1y = CANDLES[1][1] - 6;\n  // The answer's own light round the pointer's window, wider with Aura.\n  const glowA = 0.35 + 0.65 * litMax(lit), ar2 = (18 + 24 * S.aura) ** 2, aK = (0.36 + 0.36 * S.aura) * glowA;\n  // The pool's reach grows with Flicker.\n  const reach = 900 + 1900 * S.flick;\n  const PX = S.px, PY = S.py;\n  for (let p = 0; p \u003c N; p++) {\n    const x = (p % W) + 0.5, y = floor(p / W) + 0.5;\n    const d0 = (x - c0x) ** 2 + (y - c0y) ** 2, d1 = (x - c1x) ** 2 + (y - c1y) ** 2;\n    const o = p * 3;\n    // In steps of a 20th, a 16th and a 16th, so the glows do not cost a\n    // smooth gradient.\n    light[o] = q(fl0 / (1 + d0 / reach) + fl1 / (1 + d1 / reach), 20);\n    light[o + 1] = q((fl0 * fl0) / (1 + d0 / 45) + (fl1 * fl1) / (1 + d1 / 45), 16);\n    const da = (x - PX) ** 2 + (y - PY) ** 2;\n    light[o + 2] = q(aK / (1 + (2.2 * da) / ar2), 16);\n  }\n  // The pointer's frame.\n  const ca = cos(S.ang), sa = sin(S.ang);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, kind = ink[p], L = light[p * 3], Lw = light[p * 3 + 1], La = light[p * 3 + 2];\n      let r, g, b;\n      if (kind === 4) {\n        // The table: almost black.\n        (r = 0.01 + 0.3 * Lw), (g = 0.008 + 0.15 * Lw), (b = 0.016);\n      } else {\n        // The board: near-black lacquer, lit by the pool and the flames.\n        const k = 0.05 + 0.15 * L;\n        (r = tint[0] * k + 0.8 * Lw), (g = tint[1] * k + 0.42 * Lw), (b = tint[2] * k + 0.08 * Lw);\n        if (kind === 1 || kind === 2 || kind === 3) {\n          // Bone paint, brighter in the candlelight.\n          const v = (0.34 + 0.36 * L + 0.4 * Lw) * (kind === 3 ? 0.5 : 1);\n          (r = 0.86 * v), (g = 0.8 * v), (b = 0.72 * v);\n        }\n        const gi = glyphOf[p], hi = haloOf[p];\n        if (gi >= 0 && lit[gi] > 0) {\n          const a = lit[gi];\n          (r = mix(r, 0.3 + 0.7 * spirit[0], a)), (g = mix(g, 0.3 + 0.7 * spirit[1], a)), (b = mix(b, 0.3 + 0.7 * spirit[2], a));\n        } else if (hi >= 0 && lit[hi] > 0) {\n          const a = lit[hi] * 0.6;\n          (r += spirit[0] * a), (g += spirit[1] * a), (b += spirit[2] * a);\n        }\n        (r += spirit[0] * La), (g += spirit[1] * La), (b += spirit[2] * La);\n      }\n      // The pointer: a shadow first, then its body over the board.\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY;\n      if (abs(dx) \u003c 18 && abs(dy) \u003c 19) {\n        const lx = ca * dx + sa * dy, ly = -sa * dx + ca * dy;\n        const pk = pointer(lx, ly);\n        if (pk === 0) {\n          const sx = ca * (dx - 2) + sa * (dy - 3), sy = -sa * (dx - 2) + ca * (dy - 3);\n          if (pointer(sx, sy) > 0) (r *= 0.45), (g *= 0.45), (b *= 0.45);\n        } else if (pk === 1) {\n          // Smoked glass over the board: the letters show through dimly.\n          (r = r * 0.42 + 0.05), (g = g * 0.42 + 0.04), (b = b * 0.42 + 0.06);\n        } else if (pk === 2) {\n          const v = 0.78 + 0.22 * min(1, L);\n          (r = 0.92 * v), (g = 0.88 * v), (b = 0.8 * v);\n        } else if (pk === 3) {\n          // The window's ring takes the colour of what answers.\n          (r = mix(0.95, spirit[0], 0.5 * glowA)), (g = mix(0.85, spirit[1], 0.5 * glowA)), (b = mix(0.6, spirit[2], 0.5 * glowA));\n        } else {\n          // The glass: clear, the board a little brighter through it, tinted.\n          const a = 0.18 + 0.3 * glowA;\n          (r = r * 1.15 + spirit[0] * a), (g = g * 1.15 + spirit[1] * a), (b = b * 1.15 + spirit[2] * a);\n        }\n      }\n      display.setPixel(x, y, round(255 * cl(r, 0, 1)), round(255 * cl(g, 0, 1)), round(255 * cl(b, 0, 1)));\n    }\n  drawCandles(S, display);\n  drawWord(S, display, spirit);\n}\n\nconst litMax = (lit) => {\n  let m = 0;\n  for (let i = 0; i \u003c lit.length; i++) if (lit[i] > m) m = lit[i];\n  return m;\n};\n\n// Two candles seen from above at the board's foot: an ivory top with its\n// wick, and a flame leaning away from us that sways and stretches.\nfunction drawCandles(S, display) {\n  for (let i = 0; i \u003c 2; i++) {\n    const [cx, cy] = CANDLES[i], fl = S.flame[i], sw = S.sway[i];\n    for (let y = cy - 14; y \u003c min(H, cy + 6); y++)\n      for (let x = cx - 6; x \u003c= cx + 6; x++) {\n        if (x \u003c 0 || x >= W) continue;\n        const px = x + 0.5, py = y + 0.5, dw = hypot(px - cx, (py - cy) * 1.15);\n        let c = null;\n        if (dw \u003c 5) {\n          const v = dw \u003c 1 ? 0.25 : 0.72 + 0.28 * fl - 0.08 * (dw / 5);\n          c = dw \u003c 1 ? [0.2, 0.15, 0.12] : [v, v * 0.93, v * 0.8];\n        }\n        const fh = 9 + 2.5 * fl, fy = cy - 1 - py, fx = px - cx - sw * (fy / fh);\n        if (fy > -0.5 && fy \u003c fh) {\n          const u = fy / fh, w = (u \u003c 0.25 ? 2.4 * sqrt(u / 0.25) : 2.4 * (1 - (u - 0.25) / 0.75) ** 0.8) * (0.85 + 0.15 * fl);\n          if (abs(fx) \u003c w + 0.25) {\n            if (abs(fx) \u003c w * 0.45 && u \u003c 0.6) c = [1, 0.97, 0.78];\n            else if (abs(fx) \u003c w * 0.8 && u \u003c 0.85) c = [1, 0.78, 0.2];\n            else c = [1, 0.5, 0.06];\n          }\n        }\n        if (c) display.setPixel(x, y, round(255 * c[0]), round(255 * c[1]), round(255 * c[2]));\n      }\n  }\n}\n\n// The word spelled so far, above the board: twice size for five letters\n// or fewer, the newest letter flashing white as it arrives, every letter\n// glowing two LEDs round in the answer's colour.\nconst WH = 20, wmask = new Uint8Array(W * WH);\nfunction drawWord(S, display, spirit) {\n  const text = S.text, said = S.said, sc = text.length \u003c= 5 ? 2 : 1, pitch = 6 * sc;\n  const width = text.length * pitch - sc, x0 = round(32 - width / 2), y0 = sc === 2 ? 3 : 7;\n  const a = S.wordA;\n  if (a \u003c= 0 || !said.length) return;\n  wmask.fill(0);\n  for (let i = 0; i \u003c said.length; i++) {\n    const rows = F5[said[i]];\n    if (!rows) continue;\n    for (let ry = 0; ry \u003c 7 * sc; ry++)\n      for (let rx = 0; rx \u003c 5 * sc; rx++) {\n        if (!((rows[floor(ry / sc)] >> (4 - floor(rx / sc))) & 1)) continue;\n        const x = x0 + i * pitch + rx, y = y0 + ry;\n        if (x >= 0 && x \u003c W) wmask[y * W + x] = i === said.length - 1 ? 2 : 1;\n      }\n  }\n  const fr = S.flash;\n  for (let y = 0; y \u003c WH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const m = wmask[y * W + x];\n      let r, g, b;\n      if (m) {\n        const f = m === 2 ? fr : 0;\n        (r = mix(spirit[0], 1, f)), (g = mix(spirit[1], 1, f)), (b = mix(spirit[2], 1, f));\n      } else {\n        // The glow: the nearest letter LED within two.\n        let best = 9;\n        for (let dy = -2; dy \u003c= 2; dy++)\n          for (let dx = -2; dx \u003c= 2; dx++) {\n            const xx = x + dx, yy = y + dy;\n            if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c WH && wmask[yy * W + xx]) best = min(best, dx * dx + dy * dy);\n          }\n        if (best > 5) continue;\n        const k = best \u003c= 2 ? 0.34 : 0.14;\n        (r = 0.01 + spirit[0] * k), (g = 0.008 + spirit[1] * k), (b = 0.016 + spirit[2] * k);\n      }\n      display.setPixel(x, y, round(255 * cl(r * a, 0, 1)), round(255 * cl(g * a, 0, 1)), round(255 * cl(b * a, 0, 1)));\n    }\n}\n","web-tremor":"// ===== Patternflow pattern =====\n// Title:   Web Tremor\n// Family:  halloween\n// Idea:    A pale moth blunders into a tall orb web under the moon and every time it struggles a pulse of light runs out from it along the silk, fast down the radial threads and slower round the spiral, until the spider at the hub feels it, turns, runs out, wraps the moth into a white bundle and walks back, the web sagging and quivering under them, and then another moth comes.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Struggle=0..1, Sag=0..1\n//\n// Knob 1: Hue. The colour of the pulses: at 0 toxic green, at 0.25 icy cyan, at 0.5 moonlight white, at 0.75 violet, each held for 0.06 either side of its point and blending into the next, and 1 is green again. The silk, the moon, the moth and the spider keep their colours.\n// Knob 2: Speed. At 2 one hunt takes about 13 seconds: the moth flutters in for 2, struggles for 3 to 4 while the spider feels it, turns and runs out, is wrapped for 2.8, and the spider walks back for 2 and rests for 1. A pulse crosses the web in about 2 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Struggle. How hard the moth fights: at 0 it heaves in twos about every 1.3 seconds and a pulse has lost half its light 52 LEDs out; at 1 it heaves in threes every 0.6 seconds, the pulses start a quarter brighter and keep half their light to 83 LEDs, and the web round the moth shakes three times as hard.\n// Knob 4: Sag. How slack the web hangs: at 0.06 the hub sits 1.4 LEDs low, 3 with the spider on it, and the moth pulls its crossing about 3 down; at 1 the web bellies 7 LEDs at the hub, 11 with the spider, and the moth drags its crossing about 9 down. The frame never moves.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, round, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// Pulse colours round K1: toxic green, icy cyan, moonlight white, violet.\nconst PULSE = [[0.35, 1, 0.12], [0.2, 0.9, 1], [0.88, 0.94, 1], [0.8, 0.3, 1]];\n// Silk in moonlight, the moon, the moth, the spider (a cold violet grey\n// with green eyes), the wrapping silk.\nconst SILK = [0.56, 0.6, 0.92], MOON = [0.86, 0.9, 1], WING = [0.88, 0.85, 0.98], MBODY = [1, 0.96, 0.86];\nconst SBODY = [0.42, 0.32, 0.66], SLEG = [0.58, 0.54, 0.78], SEYE = [0.4, 1, 0.3], WRAP = [0.97, 0.97, 1];\nconst SILK_V = 0.34;\n// The web: hub, sixteen radials out to a frame just inside the panel, and\n// the sticky spiral as rings 4.6 LEDs apart; a ring stops where a radial is\n// too short for it, so the long upper and lower parts have more turns.\nconst HX = 32, HY = 63, K = 16, HUBR = 3, R0 = 7.5, GAP = 4.6;\nconst BOX = [3, 6, 60, 122];\nconst MOONX = 46, MOONY = 19, MOONR = 10;\n// A pulse runs along the graph of the web at V LEDs a second, the spiral\n// costing SPIRAL times its length (vibration carries best down the\n// radials, which are stiffer), with a sharp front and a short tail.\nconst V = 44, SPIRAL = 1.8, FRONT = 3, TAIL = 9;\n// Story seconds (one a second at Speed 2): the moth's flight in, the\n// spider's turn, the wrap, the rest at the hub; and the spider's pace out\n// and back, in LEDs a second.\nconst FLY = 2, TURN = 0.5, WRAPT = 2.8, REST = 1;\nconst RUN = 30, BACK = 20;\n\nfunction buildWeb(S) {\n  const nx = [], ny = [], nu = [], edges = [], th = [], R = [];\n  const node = (x, y, u) => (nx.push(x), ny.push(y), nu.push(u), nx.length - 1);\n  const hub = node(HX, HY, 0);\n  for (let k = 0; k \u003c K; k++) {\n    const a = ((k + 0.5) * TAU) / K + rnd(-0.07, 0.07), c = cos(a), s = sin(a);\n    // Out to the box, a little short of it.\n    let L = 1e9;\n    if (c > 0) L = min(L, (BOX[2] - HX) / c);\n    if (c \u003c 0) L = min(L, (BOX[0] - HX) / c);\n    if (s > 0) L = min(L, (BOX[3] - HY) / s);\n    if (s \u003c 0) L = min(L, (BOX[1] - HY) / s);\n    th.push(a);\n    R.push(L * 0.97);\n  }\n  // Rings: the hub ring, then the sticky rings while any radial reaches.\n  const rings = [HUBR];\n  for (let r = R0; r \u003c max(...R) - 3; r += GAP) rings.push(r);\n  const id = [];\n  for (let k = 0; k \u003c K; k++) {\n    id.push([]);\n    for (let j = 0; j \u003c rings.length; j++) {\n      const r = rings[j];\n      id[k].push(r \u003c= R[k] - 2.5 ? node(HX + r * cos(th[k]), HY + r * sin(th[k]), r / R[k]) : -1);\n    }\n    id[k].frame = node(HX + R[k] * cos(th[k]), HY + R[k] * sin(th[k]), 1);\n  }\n  // Edges: 0 radial, 1 spiral, 2 frame.\n  for (let k = 0; k \u003c K; k++) {\n    let prev = hub;\n    for (let j = 0; j \u003c rings.length; j++) if (id[k][j] >= 0) edges.push([prev, id[k][j], 0]), (prev = id[k][j]);\n    edges.push([prev, id[k].frame, 0]);\n    const k2 = (k + 1) % K;\n    for (let j = 0; j \u003c rings.length; j++) if (id[k][j] >= 0 && id[k2][j] >= 0) edges.push([id[k][j], id[k2][j], 1]);\n    edges.push([id[k].frame, id[k2].frame, 2]);\n  }\n  // Moorings from the frame to the panel's edges, out of the graph.\n  const moor = [];\n  for (const [k, ex, ey] of [[1, 63, 127], [6, 0, 127], [9, 0, 0], [14, 63, 0]]) moor.push([id[k].frame, ex, ey]);\n  const n = nx.length, cost = edges.map(([a, b, t]) => sqrt((nx[a] - nx[b]) ** 2 + (ny[a] - ny[b]) ** 2) * (t === 1 ? SPIRAL : t === 2 ? 1.3 : 1));\n  const adj = Array.from({ length: n }, () => []);\n  edges.forEach(([a, b], e) => (adj[a].push([b, e]), adj[b].push([a, e])));\n  Object.assign(S, { nx, ny, nu, edges, cost, adj, id, rings, th, R, hub, moor, n, px: new Float32Array(n), py: new Float32Array(n) });\n}\n\n// Graph distance of every node from a source node, by Dijkstra.\nfunction dists(S, src) {\n  const d = new Float32Array(S.n).fill(1e9), done = new Uint8Array(S.n);\n  d[src] = 0;\n  for (let it = 0; it \u003c S.n; it++) {\n    let u = -1, best = 1e9;\n    for (let i = 0; i \u003c S.n; i++) if (!done[i] && d[i] \u003c best) (best = d[i]), (u = i);\n    if (u \u003c 0) break;\n    done[u] = 1;\n    for (const [w, e] of S.adj[u]) if (d[u] + S.cost[e] \u003c d[w]) d[w] = d[u] + S.cost[e];\n  }\n  return d;\n}\n\nexport function setup(params) {\n  const S = {\n    hue: 0, speed: 2, fight: 0, sag: 0.06, t: 0, rt: 0,\n    rgb: new Float32Array(N * 3), P: new Float32Array(N), B: new Float32Array(N), T: new Float32Array(N), bg: new Float32Array(N * 3),\n    pulses: [], kicks: [], bundles: [],\n    phase: \"fly\", pt: FLY * 0.45, moth: null, sp: { x: HX, y: HY + 1, ox: HX, oy: HY, hd: PI / 2, gait: 0, s: 0, state: \"wait\", st: 0, feel: 0, heard: 0 },\n  };\n  buildWeb(S);\n  // The sky: violet at the top to blue-black below, in steps of a 64th,\n  // and the moon's halo in steps of an eighth.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, v = 1 - y / H, d = sqrt((x + 0.5 - MOONX) ** 2 + (y + 0.5 - MOONY) ** 2);\n      const halo = q(cl(1 - (d - MOONR) / 22, 0, 1) ** 2, 8);\n      S.bg[i * 3] = q(0.035 + 0.045 * v, 64) + 0.12 * halo;\n      S.bg[i * 3 + 1] = q(0.008 + 0.006 * v, 64) + 0.1 * halo;\n      S.bg[i * 3 + 2] = q(0.075 + 0.05 * v, 64) + 0.2 * halo;\n    }\n  params.s = S;\n  newMoth(S);\n  web(S);\n}\n\n// A new moth: it picks a crossing of the spiral and a radial away from the\n// hub, not on or next to a radial with a bundle already hanging, and flies\n// in from the side it is nearer.\nfunction newMoth(S) {\n  let k, j, node, tries = 0;\n  do {\n    k = floor(Math.random() * K);\n    j = 5 + floor(Math.random() * (S.rings.length - 5));\n    node = S.id[k][j];\n    tries++;\n  } while ((node \u003c 0 || S.bundles.some((b) => b.node === node || abs(b.k - k) % (K - 1) \u003c 2)) && tries \u003c 60);\n  if (node \u003c 0) (k = 4), (j = 4), (node = S.id[4][4]);\n  const left = S.nx[node] > HX ? 0 : 1;\n  const d = dists(S, node);\n  S.moth = { k, j, node, d, dmax: max(...d), x0: left ? -8 : W + 8, y0: rnd(20, 108), x: 0, y: 0, flap: 0, wrap: 0, next: 0, heave: 0 };\n}\n\n// A struggle: a pulse from the moth along the silk, and a kick to the web.\nfunction heave(S, amp) {\n  S.pulses.push({ t0: S.t, a: amp, d: S.moth.d });\n  S.kicks.push({ t0: S.t, a: amp, x: S.moth.x, y: S.moth.y });\n  S.moth.heave = 0.3;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  S.fight = cl(k[2], 0, 1);\n  S.sag = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2, M = S.moth, sp = S.sp;\n  S.t += g;\n  S.rt += d;\n  S.pt += g;\n  M.heave = max(0, M.heave - g);\n  M.flap += g * (S.phase === \"fly\" ? 60 : M.heave > 0 ? 75 : 8);\n  // The moth heaves in bouts, two or three heaves a fifth of a second\n  // apart, then a rest; Struggle shortens the rest and adds the third.\n  const every = mix(1.3, 0.6, S.fight), amp = mix(1.1, 1.375, S.fight);\n  if (S.phase === \"fly\") {\n    const u = cl(S.pt / FLY, 0, 1), e = u * u * (3 - 2 * u);\n    M.x = mix(M.x0, S.px[M.node], e) + 5 * sin(u * PI * 3) * (1 - u);\n    M.y = mix(M.y0, S.py[M.node], e) + 4 * sin(u * PI * 5) * (1 - u) + 1.5 * sin(S.t * 9) * (1 - u);\n    if (u >= 1) {\n      S.phase = \"caught\";\n      S.pt = 0;\n      heave(S, 1.5);\n      M.next = 0.2;\n      M.bout = 3;\n      sp.state = \"wait\";\n      sp.heard = 0;\n    }\n  } else {\n    M.x = S.px[M.node];\n    M.y = S.py[M.node];\n  }\n  if (S.phase === \"caught\" || S.phase === \"wrap\") {\n    M.next -= g;\n    if (M.next \u003c= 0) {\n      // While it is being wrapped it fights less and less.\n      heave(S, amp * (S.phase === \"wrap\" ? 0.7 * (1 - M.wrap) : rnd(0.8, 1)));\n      if (--M.bout > 0) M.next = 0.2;\n      else {\n        M.next = every * rnd(0.8, 1.2) * (S.phase === \"wrap\" ? 1.5 : 1);\n        M.bout = 2 + (Math.random() \u003c S.fight ? 1 : 0);\n      }\n    }\n  }\n  // The spider: at the hub until the first pulse reaches it, then it turns\n  // to the moth's radial, waits for more to be sure (six in all, or four\n  // seconds), then runs out along the radial to wrap the moth and walk back.\n  const hubT = M.d[S.hub] / V;\n  const path = [S.hub];\n  for (let j = 0; j \u003c= M.j; j++) if (S.id[M.k][j] >= 0) path.push(S.id[M.k][j]);\n  const plen = [0];\n  for (let i = 1; i \u003c path.length; i++) plen.push(plen[i - 1] + sqrt((S.px[path[i]] - S.px[path[i - 1]]) ** 2 + (S.py[path[i]] - S.py[path[i - 1]]) ** 2));\n  const total = plen[plen.length - 1];\n  const at = (s) => {\n    let i = 1;\n    while (i \u003c path.length - 1 && plen[i] \u003c s) i++;\n    const f = cl((s - plen[i - 1]) / (plen[i] - plen[i - 1] || 1), 0, 1);\n    return [mix(S.px[path[i - 1]], S.px[path[i]], f), mix(S.py[path[i - 1]], S.py[path[i]], f), atan2(S.py[path[i]] - S.py[path[i - 1]], S.px[path[i]] - S.px[path[i - 1]])];\n  };\n  sp.st += g;\n  sp.feel = max(0, sp.feel - g * 2);\n  // Count the pulses that have reached the hub.\n  let heard = 0;\n  for (const p of S.pulses) if (p.d === M.d && S.t - p.t0 >= hubT) heard++;\n  if (heard > sp.heard) (sp.feel = 1), (sp.heard = heard);\n  let moving = 0;\n  if (sp.state === \"wait\") {\n    sp.s = 0;\n    turnTo(sp, PI / 2, g);\n    if (S.phase === \"caught\" && heard >= 1) (sp.state = \"turn\"), (sp.st = 0);\n  } else if (sp.state === \"turn\") {\n    turnTo(sp, S.th[M.k], g * 1.6);\n    if (sp.st > TURN && (heard >= 6 || sp.st > 4)) (sp.state = \"run\"), (sp.st = 0);\n  } else if (sp.state === \"run\") {\n    sp.s = min(total - 3, sp.s + RUN * g);\n    moving = RUN * g;\n    if (sp.s >= total - 3) {\n      sp.state = \"wrap\";\n      sp.st = 0;\n      S.phase = \"wrap\";\n      S.pt = 0;\n      sp.orb = S.th[M.k] + PI;\n    }\n  } else if (sp.state === \"wrap\") {\n    // Round and round the moth, turning it in silk.\n    sp.orb += g * 5.5;\n    M.wrap = cl(S.pt / WRAPT, 0, 1);\n    moving = g * 18;\n    if (M.wrap >= 1) {\n      S.bundles.push({ node: M.node, k: M.k, life: 1 });\n      if (S.bundles.length > 2) S.bundles[0].fade = 1;\n      sp.state = \"back\";\n      sp.st = 0;\n      S.phase = \"rest\";\n      S.pt = 0;\n      sp.s = total - 3;\n    }\n  } else if (sp.state === \"back\") {\n    sp.s = max(0, sp.s - BACK * g);\n    moving = BACK * g;\n    if (sp.s \u003c= 0) (sp.state = \"home\"), (sp.st = 0);\n  } else if (sp.state === \"home\") {\n    turnTo(sp, PI / 2, g * 1.2);\n    if (sp.st > REST) {\n      sp.state = \"wait\";\n      newMoth(S);\n      S.phase = \"fly\";\n      S.pt = 0;\n      S.pulses.length = 0;\n    }\n  }\n  if (sp.state === \"wrap\") {\n    const mx = S.px[M.node], my = S.py[M.node];\n    sp.x = mx + 4 * cos(sp.orb);\n    sp.y = my + 4 * sin(sp.orb);\n    sp.hd = sp.orb + PI;\n  } else {\n    const [x, y, a] = at(sp.s);\n    sp.x = x;\n    sp.y = y + (sp.s === 0 ? 1 : 0);\n    if (sp.state === \"run\") turnTo(sp, a, g * 3);\n    if (sp.state === \"back\") turnTo(sp, a + PI, g * 3);\n  }\n  sp.gait += moving * 0.9;\n  for (const b of S.bundles) if (b.fade) b.life -= g / 2.5;\n  S.bundles = S.bundles.filter((b) => b.life > 0);\n  S.pulses = S.pulses.filter((p) => V * (S.t - p.t0) \u003c M.dmax + 4 * TAIL);\n  S.kicks = S.kicks.filter((c) => S.t - c.t0 \u003c 2.5);\n  web(S);\n}\n\nfunction turnTo(sp, a, rate) {\n  const dh = ((a - sp.hd + 3 * PI) % TAU) - PI;\n  sp.hd += dh * min(1, rate * 6);\n}\n\n// Where every node of the web hangs now: the web's own belly, deepest at\n// the hub and nothing at the frame; the pull of the moth, the spider and\n// the bundles where they hang; and the quiver each heave sets going.\nfunction web(S) {\n  const G = 1 + 6 * S.sag, load = 3 + 5 * S.sag, M = S.moth, sp = S.sp;\n  const loads = [];\n  if (S.phase !== \"fly\") loads.push([S.nx[M.node], S.ny[M.node], load]);\n  loads.push([sp.ox, sp.oy, load * 0.5]);\n  for (const b of S.bundles) loads.push([S.nx[b.node], S.ny[b.node], load * 0.6 * b.life]);\n  let qy = 0;\n  const kx = [], ky = [], ka = [];\n  for (const c of S.kicks) {\n    const tau = S.t - c.t0, a = c.a * mix(1, 3, S.fight) * exp(-tau / 0.45) * sin(TAU * 5 * tau);\n    qy += 0.6 * a;\n    kx.push(c.x), ky.push(c.y), ka.push(a);\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = S.nx[i], y = S.ny[i], u = S.nu[i], taper = 1 - u * u;\n    let dy = G, dx = 0;\n    for (const [lx, ly, w] of loads) dy += w * exp(-((x - lx) ** 2 + (y - ly) ** 2) / (2 * 14 * 14));\n    let jig = qy;\n    for (let c = 0; c \u003c kx.length; c++) {\n      const f = exp(-((x - kx[c]) ** 2 + (y - ky[c]) ** 2) / (2 * 16 * 16));\n      jig += 1.4 * ka[c] * f;\n      dx += 0.8 * ka[c] * f * sin(i * 2.3);\n    }\n    S.px[i] = x + dx * taper;\n    S.py[i] = y + (dy + jig) * taper;\n  }\n  // The spider's own weight follows it out along the radial.\n  sp.ox = sp.x;\n  sp.oy = sp.y;\n}\n\n// The pulse colour for K1, holding near each of the four stops.\nfunction pulseColour(h) {\n  h = (h - floor(h)) * 4;\n  const i = floor(h) % 4, j = (i + 1) % 4, f = h - floor(h), g = cl((f - 0.25) / 0.5, 0, 1), s = g * g * (3 - 2 * g);\n  return [0, 1, 2].map((c) => mix(PULSE[i][c], PULSE[j][c], s));\n}\n\n// The light a pulse puts on a point d along the silk from the moth: a\n// sharp front running out at V, a short tail behind it, fading with the\n// distance it has run.\nfunction glow(S, d) {\n  const fr = S.fr, am = S.am;\n  let v = 0;\n  for (let i = 0; i \u003c fr.length; i++) {\n    const x = fr[i] - d;\n    if (x \u003c -FRONT * 3 || x > TAIL * 4) continue;\n    v += am[i] * (x \u003c 0 ? exp(-((x / FRONT) ** 2)) : exp(-x / TAIL));\n  }\n  return v > 0 ? v * exp(-d / S.reach) : 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, P, bg } = S;\n  rgb.set(bg);\n  P.fill(0);\n  // The moon: pale, with darker seas in steps.\n  for (let y = MOONY - MOONR - 1; y \u003c= MOONY + MOONR + 1; y++)\n    for (let x = MOONX - MOONR - 1; x \u003c= MOONX + MOONR + 1; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0) continue;\n      const dx = x + 0.5 - MOONX, dy = y + 0.5 - MOONY, r = sqrt(dx * dx + dy * dy);\n      if (r > MOONR) continue;\n      const sea = exp(-((dx + 3) ** 2 + (dy + 2) ** 2) / 14) * 0.5 + exp(-((dx - 4) ** 2 + (dy - 4) ** 2) / 8) * 0.4 + exp(-((dx - 2) ** 2 + (dy + 5) ** 2) / 5) * 0.3;\n      const v = q(0.95 - 0.35 * sea - 0.12 * (r / MOONR) ** 4, 10), o = (y * W + x) * 3;\n      rgb[o] = MOON[0] * v;\n      rgb[o + 1] = MOON[1] * v;\n      rgb[o + 2] = MOON[2] * v;\n    }\n  // Silk: each thread from node to node, and on it the pulses, with the\n  // distance along the silk from the moth taken the short way round.\n  const pc = pulseColour(S.hue), M = S.moth, D = M.d;\n  // Where each pulse's front has got to, once a frame.\n  S.fr = S.pulses.map((p) => V * (S.t - p.t0));\n  S.am = S.pulses.map((p) => p.a);\n  S.reach = mix(75, 120, S.fight);\n  const plot = (x, y, base, pv) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = y * W + x, o = i * 3;\n    // Over the moon the silk is a dark line against it.\n    const onMoon = (x + 0.5 - MOONX) ** 2 + (y + 0.5 - MOONY) ** 2 \u003c MOONR * MOONR;\n    if (onMoon) (rgb[o] *= 0.55), (rgb[o + 1] *= 0.55), (rgb[o + 2] *= 0.6);\n    else (rgb[o] = max(rgb[o], SILK[0] * base)), (rgb[o + 1] = max(rgb[o + 1], SILK[1] * base)), (rgb[o + 2] = max(rgb[o + 2], SILK[2] * base));\n    if (pv > P[i]) P[i] = pv;\n  };\n  const seg = (a, b, ca, cb, cost, base) => {\n    const x0 = S.px[a], y0 = S.py[a], x1 = S.px[b], y1 = S.py[b];\n    const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n    for (let s = 0; s \u003c= n; s++) {\n      const t = n ? s / n : 0, dd = min(ca + t * cost, cb + (1 - t) * cost);\n      plot(floor(mix(x0, x1, t) + 0.5), floor(mix(y0, y1, t) + 0.5), base, glow(S, dd));\n    }\n  };\n  S.edges.forEach(([a, b, t], e) => seg(a, b, D[a], D[b], S.cost[e], t === 1 ? SILK_V * 0.85 : SILK_V));\n  for (const [a, ex, ey] of S.moor) {\n    const x0 = S.px[a], y0 = S.py[a], n = Math.ceil(max(abs(ex - x0), abs(ey - y0)));\n    for (let s = 0; s \u003c= n; s++) plot(floor(mix(x0, ex, s / n) + 0.5), floor(mix(y0, ey, s / n) + 0.5), SILK_V * 0.7, 0);\n  }\n  // The pulse on the silk, and a soft glow round it so it reads from\n  // across a room: a blur two LEDs wide, across then down.\n  const B = S.B, T = S.T;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let s = 3 * P[i];\n      if (x > 0) s += 2 * P[i - 1];\n      if (x > 1) s += P[i - 2];\n      if (x \u003c W - 1) s += 2 * P[i + 1];\n      if (x \u003c W - 2) s += P[i + 2];\n      T[i] = s / 9;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let s = 3 * T[i];\n      if (y > 0) s += 2 * T[i - W];\n      if (y > 1) s += T[i - 2 * W];\n      if (y \u003c H - 1) s += 2 * T[i + W];\n      if (y \u003c H - 2) s += T[i + 2 * W];\n      B[i] = s / 9;\n    }\n  for (let i = 0; i \u003c N; i++) {\n    const p = P[i], b = B[i], o = i * 3;\n    if (p \u003c= 0.02 && b \u003c= 0.02) continue;\n    const v = max(min(1.2, p), q(min(0.6, 1.4 * b), 6));\n    rgb[o] = max(rgb[o], pc[0] * v);\n    rgb[o + 1] = max(rgb[o + 1], pc[1] * v);\n    rgb[o + 2] = max(rgb[o + 2], pc[2] * v);\n  }\n  // Each heave flashes round the moth, the light the pulses start from.\n  if (M.heave > 0 && S.phase !== \"fly\") {\n    const a = M.heave / 0.3, R = 9;\n    for (let y = floor(M.y - R); y \u003c= M.y + R; y++)\n      for (let x = floor(M.x - R); x \u003c= M.x + R; x++) {\n        const r = sqrt((x + 0.5 - M.x) ** 2 + (y + 0.5 - M.y) ** 2) / R;\n        if (r \u003c 1) put(S, x, y, pc, q(a * 0.7 * (1 - r) ** 1.5, 6));\n      }\n  }\n  // Bundles of silk left in the web.\n  for (const b of S.bundles) drawBundle(S, S.px[b.node], S.py[b.node], 1, b.life);\n  // The moth: wings flapping as it flies, heaving in the web, folding away\n  // into the bundle as it is wrapped.\n  drawMoth(S, M);\n  drawSpider(S, S.sp);\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(255 * cl(rgb[o], 0, 1)), round(255 * cl(rgb[o + 1], 0, 1)), round(255 * cl(rgb[o + 2], 0, 1)));\n}\n\nfunction put(S, x, y, c, a) {\n  x = floor(x);\n  y = floor(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  S.rgb[o] = mix(S.rgb[o], c[0], a);\n  S.rgb[o + 1] = mix(S.rgb[o + 1], c[1], a);\n  S.rgb[o + 2] = mix(S.rgb[o + 2], c[2], a);\n}\n\nfunction drawBundle(S, cx, cy, size, life) {\n  for (let y = floor(cy - 6); y \u003c= cy + 6; y++)\n    for (let x = floor(cx - 4); x \u003c= cx + 4; x++) {\n      const u = (x + 0.5 - cx) / (3 * size), v = (y + 0.5 - cy) / (4.6 * size), r = u * u + v * v;\n      if (r > 1) continue;\n      // Wound round: bands of brighter and dimmer silk across it.\n      const band = ((y + x * 0.6 + 40) % 2.4) \u003c 1.2 ? 1 : 0.78;\n      put(S, x, y, WRAP.map((c) => c * band), min(1, life * 1.5));\n    }\n}\n\nfunction drawMoth(S, M) {\n  const wrap = M.wrap, open = 1 - wrap;\n  if (wrap > 0) drawBundle(S, M.x, M.y, 0.25 + 0.75 * wrap, 1);\n  if (open \u003c= 0.05) return;\n  // Wing span: the flap swings it between full and a sliver.\n  const f = 0.35 + 0.65 * abs(cos(M.flap)), span = 7 * f * open;\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let y = -5; y \u003c= 5; y++)\n      for (let x = 1; x \u003c= 8; x++) {\n        const wx = x / max(0.6, span), wy = y / 5;\n        // Forewing above, smaller hindwing below.\n        const fore = wy \u003c 0.2 && wx \u003c 1 && wy > -1 + 0.6 * wx;\n        const hind = wy >= 0.2 && wx \u003c 0.75 && wy \u003c 0.95 - 0.5 * wx;\n        if (!fore && !hind) continue;\n        // A grey eye-spot on each forewing, a darker leading edge.\n        const spot = fore && abs(wx - 0.5) \u003c 0.17 && abs(wy + 0.35) \u003c 0.15;\n        const shade = spot ? 0.58 : hind ? 0.75 : x === 1 || wy \u003c -0.6 ? 0.85 : 1;\n        put(S, M.x + side * (x - 0.5), M.y + y, WING.map((c) => c * shade * (0.6 + 0.4 * open)), 1);\n      }\n  for (let y = -4; y \u003c= 4; y++) put(S, M.x, M.y + y, MBODY, 1);\n  put(S, M.x - 1, M.y - 5, MBODY, 0.7);\n  put(S, M.x + 1, M.y - 5, MBODY, 0.7);\n}\n\n// The spider: abdomen behind, head in front, eight legs that step as it\n// walks and twitch when a pulse reaches it.\nfunction drawSpider(S, sp) {\n  const fx = cos(sp.hd), fy = sin(sp.hd), sx = -fy, sy = fx, x = sp.x, y = sp.y;\n  const line = (x0, y0, x1, y1, c) => {\n    const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n    for (let s = 0; s \u003c= n; s++) put(S, mix(x0, x1, s / (n || 1)) + 0.5, mix(y0, y1, s / (n || 1)) + 0.5, c, 1);\n  };\n  const tw = 0.25 * sp.feel * sin(S.rt * 40);\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let k = 0; k \u003c 4; k++) {\n      const a = [0.5, 1.1, 1.9, 2.5][k] + 0.25 * sin(sp.gait + k * 1.7 + (side > 0 ? PI : 0)) + tw;\n      const ca = cos(a), sa = side * sin(a), r = 3.2;\n      const kx = x + (ca * fx + sa * sx) * r, ky = y + (ca * fy + sa * sy) * r;\n      // The lower leg bends forward for the front pair, back for the rear.\n      const ex = kx + (ca * fx + sa * sx) * 2.8 + (k \u003c 2 ? fx : -fx) * 1.2, ey = ky + (ca * fy + sa * sy) * 2.8 + (k \u003c 2 ? fy : -fy) * 1.2;\n      line(x, y, kx, ky, SLEG);\n      line(kx, ky, ex, ey, SLEG);\n    }\n  const blob = (cx, cy, ra, rb, c) => {\n    for (let yy = floor(cy - 4); yy \u003c= cy + 4; yy++)\n      for (let xx = floor(cx - 4); xx \u003c= cx + 4; xx++) {\n        const px = xx + 0.5 - cx, py = yy + 0.5 - cy, u = px * fx + py * fy, v = px * sx + py * sy;\n        if ((u / ra) ** 2 + (v / rb) ** 2 \u003c= 1) put(S, xx, yy, c, 1);\n      }\n  };\n  blob(x - 2.2 * fx, y - 2.2 * fy, 2.8, 2.2, SBODY);\n  blob(x + 0.8 * fx, y + 0.8 * fy, 1.5, 1.3, SBODY.map((c) => c * 1.2));\n  put(S, x + 1.6 * fx + 0.7 * sx, y + 1.6 * fy + 0.7 * sy, SEYE, 1);\n  put(S, x + 1.6 * fx - 0.7 * sx, y + 1.6 * fy - 0.7 * sy, SEYE, 1);\n}\n","belfry":"// ===== Patternflow pattern =====\n// Title:   Belfry\n// Family:  halloween\n// Idea:    A black stone bell tower fills the panel against a stormy purple sky and a low orange moon, its bronze bell swinging like a real pendulum while the clapper lags inside and strikes the rim near each end of the swing, each strike sending out a ring of sound and a burst of bats to wheel round the spire, as the green clock creeps to midnight and the bell tolls twelve.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bats=8..40, Storm=0..1\n//\n// Knob 1: Hue. The moon, the lit windows and the moonlit cloud edges, with the clock and the middle window a quarter of the wheel on; stone, sky and bell stay. At 0 an orange moon and a toxic green clock, at 0.25 a green moon and a sky blue clock, at 0.5 a blue moon and a magenta clock, at 0.75 a magenta moon and an orange clock.\n// Knob 2: Speed. At 2 the bell swings there and back in 1.8 s and strikes every 0.93 s, the minute hand goes round in 30 s so the hour tolls every 30 s, and a bat beats its wings 6 to 9 times a second and wheels 7 to 14 s before it flies home; at 0.2 all ten times slower, at 3 half as fast again.\n// Knob 3: Bats. How many bats each strike scares out of the belfry and the spire's louvre: 8 at the start, so midnight puts 96 more in the air, 16 at a quarter, 24 at half, 32 at three quarters, 40 at the end. Four times that many stay out between the hours, at most 300 at once.\n// Knob 4: Storm. Cloud, wind and lightning. At 0.06 a fifth of the sky is cloud drifting right at 4 LEDs a second and lightning forks down from the top about every 28 s, the first at 5 s; at 0.5 half the sky is cloud moving at 13, it rains, and lightning comes every 15 s; at 1 cloud covers nine tenths of the sky at 23 a second, the rain is heavy and lightning comes every 2 s.\n// Buttons: K1 tap sets the hands to two minutes to twelve and the bell tolls midnight at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\nconst put = (buf, o, r, g, b) => {\n  buf[o] = r;\n  buf[o + 1] = g;\n  buf[o + 2] = b;\n};\n\n// The tower, laid out once.\n// Its axis is column TX; the moon sits low behind its right shoulder.\nconst TX = 25, AX = TX + 0.5;\nconst ARCH_Y = 47.5, ARCH_R = 10.5, SILL = 62;\nconst PX = AX, PY = 40.5;\nconst CLX = AX, CLY = 76.5, CLR = 7.5;\nconst MX = 46, MY = 84, MR = 21;\n// Mask codes. BACK is the sky seen through the belfry's back arch.\nconst SKY = 0, STONE = 1, INSIDE = 2, BACK = 3, FACE = 4, WIN = 5, BEAM = 6;\nconst MASK = new Uint8Array(N), RIM = new Uint8Array(N), WID = new Int8Array(N).fill(-1);\n// Half the tower's width by row, [last row, half]: finial, spire (-2, a\n// taper), eave, belfry, ledge, clock stage, ledge, shaft, buttresses.\nconst ROWS = [[0, -1], [2, 0], [4, 1], [29, -2], [30, 15], [32, 16], [63, 14], [66, 15], [86, 13], [88, 14], [109, 12], [113, 13], [H, 15]];\nconst half = (y) => {\n  const r = ROWS.find((q) => y \u003c= q[0])[1];\n  return r === -2 ? round(1 + ((y - 5) * 13) / 24) : r;\n};\nconst groundY = (x) => 121 + round(1.6 * sin(x / 7 + 1) + 0.8 * sin(x / 3.1));\n// Gravestones on the ground line: [left column, pixel art].\nconst GRAVES = [\n  [41, [\".xxx.\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\"]],\n  [49, [\"..x..\", \"..x..\", \"xxxxx\", \"..x..\", \"..x..\", \"..x..\", \"..x..\", \".xxx.\"]],\n  [57, [\".xx.\", \"xxxx\", \"xxxx\", \"xxxx\", \"xxxx\"]],\n];\n// A dead tree's limbs, [x0, y0, x1, y1].\nconst TREE = [[4, 122, 4, 107], [5, 122, 5, 110], [4, 110, 1, 103], [4, 107, 7, 100], [7, 100, 9, 96], [7, 101, 5, 95], [1, 103, 0, 99], [2, 105, -1, 104], [9, 96, 11, 95], [5, 95, 6, 92]];\n// Lit windows: [middle column, top row, 0 moon or 1 clock colour, seed].\nconst WINS = [[TX - 5, 91, 0, 3], [TX + 5, 91, 0, 7], [TX, 101, 1, 11], [TX, 114, 0, 17]];\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x, dx = x + 0.5 - AX, hw = half(y);\n    let m = SKY;\n    if (hw >= 0 && abs(x - TX) \u003c= hw) m = STONE;\n    // Two pinnacles on the corners of the eave.\n    for (const c of [TX - 15, TX + 15]) if (y >= 21 && y \u003c= 29 && abs(x - c) \u003c= (y \u003c 25 ? 0 : 1)) m = STONE;\n    if (y >= groundY(x)) m = STONE;\n    for (const [sx, art] of GRAVES) {\n      const r = y - (groundY(sx + 2) - art.length + 1);\n      if (r >= 0 && r \u003c art.length && art[r][x - sx] === \"x\") m = STONE;\n    }\n    for (const [x0, y0, x1, y1] of TREE) {\n      const n = max(abs(x1 - x0), abs(y1 - y0));\n      for (let i = 0; i \u003c= n; i++) if (round(x0 + ((x1 - x0) * i) / n) === x && round(y0 + ((y1 - y0) * i) / n) === y) m = STONE;\n    }\n    // The belfry arch, its back arch and the beam the bell hangs from.\n    const ar = sqrt(dx * dx + max(0, ARCH_Y - (y + 0.5)) ** 2);\n    if (y \u003c SILL && ar \u003c ARCH_R && y >= 36) {\n      m = INSIDE;\n      if (sqrt(dx * dx + max(0, ARCH_Y + 1 - (y + 0.5)) ** 2) \u003c 6.8 && y \u003c SILL - 2) m = BACK;\n      if (y >= 39 && y \u003c= 40) m = BEAM;\n    }\n    // A louvre in the spire: three slats with dark gaps.\n    if (abs(x - TX) \u003c= 1 && y >= 16 && y \u003c= 21 && y % 2 === 1) m = INSIDE;\n    if ((x + 0.5 - CLX) ** 2 + (y + 0.5 - CLY) ** 2 \u003c CLR * CLR) m = FACE;\n    // Three lancets and the door, which is wider.\n    WINS.forEach(([wx, wy], i) => {\n      const r = y - wy, w2 = i === 3 ? 2 : 1;\n      if (r >= 0 && r \u003c 5 + w2 && abs(x - wx) \u003c= (r ? w2 : w2 - 1)) (m = WIN), (WID[p] = i);\n    });\n    MASK[p] = m;\n  }\n// Rim light where stone meets sky: brightest on the right, towards the\n// moon, then on top, then dim on the left.\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x;\n    if (MASK[p] !== STONE) continue;\n    const sky = (q) => q >= 0 && q \u003c N && MASK[q] === SKY;\n    RIM[p] = x \u003c W - 1 && sky(p + 1) ? 3 : y > 0 && sky(p - W) ? 2 : x > 0 && sky(p - 1) ? 1 : 0;\n  }\nconst RIMC = [0, [50, 20, 76], [92, 40, 132], [124, 56, 176]];\n\n// Sky by row in nine flat steps, deep violet overhead to a dusky mauve low down.\nconst SKYC = new Float32Array(H * 3);\nfor (let y = 0; y \u003c H; y++) {\n  const t = floor((y / H) * 9) / 8;\n  SKYC[3 * y] = 22 + 66 * t;\n  SKYC[3 * y + 1] = 6 + 22 * t;\n  SKYC[3 * y + 2] = 42 + 50 * t;\n}\n// The moon's tone at each LED (1 limb, 2 sea, 3 bright) and its glow in\n// stepped rings, which also lights the cloud edges there.\nconst MOONT = new Uint8Array(N), GLOW = new Float32Array(N);\nconst SEAS = [[-7, -8, 6, 4], [6, -3, 5, 6], [-4, 6, 7, 4], [9, 9, 4, 3]];\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR) {\n    const sea = SEAS.some(([cx, cy, rx, ry]) => ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 \u003c 1);\n    MOONT[p] = r > MR - 1.3 ? 1 : sea ? 2 : 3;\n    GLOW[p] = 1;\n  } else GLOW[p] = r \u003c MR + 3 ? 0.24 : r \u003c MR + 7 ? 0.14 : r \u003c MR + 13 ? 0.07 : r \u003c MR + 22 ? 0.03 : 0;\n}\n// Clouds: a wrapping noise sheet slid along by the wind. CQ is its values\n// sorted, so a cloud cover maps straight to a threshold.\nconst CW = 128, CH = 32, CN = new Float32Array(CW * CH);\nfor (let j = 0; j \u003c CH; j++)\n  for (let i = 0; i \u003c CW; i++) {\n    let v = 0, a = 0.6;\n    for (const [cell, sd] of [[16, 1], [8, 2], [4, 3]]) {\n      const nx = CW / cell, u = i / cell, w = j / (cell / 2), iu = floor(u), iw = floor(w), fu = u - iu, fw = w - iw;\n      const su = fu * fu * (3 - 2 * fu), sw = fw * fw * (3 - 2 * fw);\n      const hh = (a2, b2) => hash(((a2 % nx) + nx) % nx * 131 + b2 * 977 + sd * 7);\n      v += a * ((hh(iu, iw) * (1 - su) + hh(iu + 1, iw) * su) * (1 - sw) + (hh(iu, iw + 1) * (1 - su) + hh(iu + 1, iw + 1) * su) * sw);\n      a *= 0.5;\n    }\n    CN[j * CW + i] = v;\n  }\nconst CQ = Float32Array.from(CN).sort();\n\n// The bell: a heavy pendulum, 1.8 s there and back at Speed 2, that its\n// ringer pushes to a 0.85 rad swing. The clapper is a pendulum 0.4 as long\n// hung 0.2 below the bell's pivot and carried by the bell. Shorter, it lags,\n// and as the bell slows at the end of a swing its rim comes round onto the\n// clapper: a strike when the two are 0.4 rad apart.\nconst TB = 1.8, AMP = 0.85, CA = 0.2, CLL = 0.4, ALIM = 0.4, BOUNCE = 0.2;\nconst WB = TAU / TB, G = WB * WB;\n// The bell's outline: half its width at distances down its axis from the pivot.\nconst BV = [1.5, 2.5, 3.5, 5, 9, 11, 13, 14.5], BW = [1.5, 4, 5.3, 5.7, 6.1, 6.8, 7.8, 8.4];\nfunction bellHalf(v) {\n  if (v \u003c BV[0] || v > BV[7]) return -1;\n  let i = 0;\n  while (i \u003c 6 && v > BV[i + 1]) i++;\n  return BW[i] + ((BW[i + 1] - BW[i]) * (v - BV[i])) / (BV[i + 1] - BV[i]);\n}\nconst LIP = 14.5, LIPW = 8.4, CLAP = 11.8;\nconst BRONZE = [[64, 34, 12], [140, 82, 28], [208, 142, 56], [255, 212, 128]];\n\n// Three wing positions, 9 wide close in front, 7 further round, 5 behind.\nconst SPR = [\n  [[\"x.......x\", \"xx.....xx\", \".xx.x.xx.\", \"..xxxxx..\", \"...xxx...\", \"....x....\"], [\"x.....x\", \"xx...xx\", \".xx.xx.\", \"..xxx..\", \"...x...\"], [\"x...x\", \".x.x.\", \"..x..\"]],\n  [[\"...x.x...\", \"xxxxxxxxx\", \".xx.x.xx.\", \"....x....\"], [\".......\", \"xxx.xxx\", \".xxxxx.\", \"...x...\"], [\"xx.xx\", \".xxx.\", \"..x..\"]],\n  [[\"...x.x...\", \"..xxxxx..\", \".xx.x.xx.\", \"xx.....xx\", \"x.......x\"], [\"...x...\", \".xxxxx.\", \"xx.x.xx\", \"x.....x\"], [\"..x..\", \".xxx.\", \"x...x\"]],\n];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, nb: 8, storm: 0.06,\n    // Clock in minutes past twelve, 0..720: it opens at 11:57.\n    clk: 717, toll: 0, count: 0, pump: false, brake: 0,\n    th: 0, w: 0, ph: 0, pw: 0, spark: 9, sparkS: 1,\n    bats: [], rips: [], rain: [], cloud: 0,\n    bolt: null, boltAge: 9, boltWait: 5, begun: false,\n    buf: new Float32Array(N * 3), c: [0, 0, 0], g: [0, 0, 0],\n  };\n}\n\nfunction spawnBats(S, n) {\n  for (let i = 0; i \u003c n && S.bats.length \u003c 300; i++) {\n    // Out of the spire's louvre or from under the arch's crown, and away fast.\n    const spire = Math.random() \u003c 0.3, side = Math.random() \u003c 0.5 ? -1 : 1;\n    const hx = spire ? AX + rnd(-1, 1) : AX + side * rnd(3, 9), hy = spire ? 18.5 : rnd(37.5, 42);\n    const a = -PI / 2 + side * rnd(0.2, 1.4), sp = rnd(30, 55);\n    S.bats.push({\n      x: hx, y: hy, vx: cos(a) * sp + (hx - AX) * 2, vy: sin(a) * sp, mode: 0, t: rnd(0.45, 0.9),\n      R: rnd(11, 33), yc: Math.random() \u003c 0.6 ? rnd(4, 40) : rnd(40, 82), w: (Math.random() \u003c 0.5 ? -1 : 1) * rnd(1.1, 2.1), psi: rnd(0, TAU), amp: rnd(3, 11),\n      hx, hy, ph: rnd(0, TAU), fr: rnd(6, 9), z: 1, sd: floor(rnd(0, 1e5)),\n    });\n  }\n}\n\nconst ring = (S, n) => Object.assign(S, { toll: n, count: 0, pump: true, brake: 0 });\n\nfunction strike(S, side) {\n  S.count++;\n  S.spark = 0;\n  S.sparkS = side;\n  S.rips.push(0);\n  spawnBats(S, S.nb);\n  if (S.count >= S.toll) {\n    S.pump = false;\n    S.brake = 2.5;\n  }\n}\n\n// One small step of the bell and the clapper.\nfunction physics(S, h) {\n  const th = S.th, w = S.w, E = 0.5 * w * w + G * (1 - cos(th)), Et = G * (1 - cos(AMP));\n  let acc = -G * sin(th);\n  if (S.pump) acc += ((3 * (Et - E)) / Et) * w + (E \u003c 0.02 * Et ? 2 * (w >= 0 ? 1 : -1) : 0);\n  else if (S.brake > 0) acc -= 3 * w;\n  else acc += -0.4 * w + S.storm * 1.6 * vn(S.t * 0.8, 5);\n  // The clapper's pivot rides on the bell; its acceleration swings the clapper.\n  const ax = CA * (acc * cos(th) - w * w * sin(th)), ay = CA * (-acc * sin(th) - w * w * cos(th));\n  let pacc = (-G * sin(S.ph) - ax * cos(S.ph) + ay * sin(S.ph)) / CLL;\n  if (!S.pump) pacc -= 0.4 * (S.pw - w);\n  S.th += (S.w += acc * h) * h;\n  S.ph += (S.pw += pacc * h) * h;\n  // After the last stroke the ringer checks the bell and holds the clapper,\n  // or it would knock once more.\n  if (S.brake > 0) {\n    S.ph += (S.th - S.ph) * min(1, h * 8);\n    S.pw = S.w;\n  }\n  const rel = S.ph - S.th;\n  if (abs(rel) > ALIM) {\n    const s = rel > 0 ? 1 : -1, rv = S.pw - S.w;\n    S.ph = S.th + s * ALIM;\n    if (rv * s > 0) {\n      if (abs(rv) > 0.5 && S.pump) strike(S, s);\n      S.pw = S.w - BOUNCE * rv;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.nb, S.storm] = [cl(k[0], 0, 1), cl(k[1], 0.2, 3), round(cl(k[2], 8, 40)), cl(k[3], 0, 1)];\n  if (!S.begun) {\n    S.boltWait = 5 - 3 * S.storm;\n    S.begun = true;\n    // Four strikes' worth of bats are already out, along their rings.\n    spawnBats(S, 4 * S.nb);\n    for (const b of S.bats)\n      Object.assign(b, { mode: 1, t: rnd(1, 12), x: AX + b.R * cos(b.psi), y: b.yc + b.amp * sin(b.psi) * 0.6, vx: -b.R * b.w * sin(b.psi), vy: 0, z: sin(b.psi) });\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // The clock gains 2 minutes a second at Speed 2. Two minutes before each\n  // hour the ringer starts the bell, so the first strike falls on the hour,\n  // and it strikes the hour: twelve at midnight.\n  const was = S.clk;\n  S.clk += ds * 2;\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.clk = 718;\n    ring(S, 12);\n  } else if (floor((was + 2) / 60) !== floor((S.clk + 2) / 60) && !S.pump) ring(S, floor((S.clk + 2) / 60) % 12 || 12);\n  if (S.clk >= 720) S.clk -= 720;\n  for (let i = 0; i \u003c 8; i++) physics(S, ds / 8);\n  S.brake -= ds;\n  S.spark += ds;\n  // Sound rings run out at 38 LEDs a second for 1.4 s.\n  S.rips = S.rips.map((a) => a + ds).filter((a) => a \u003c 1.4);\n  // Wind: the clouds slide 4 to 23 LEDs a second and the bats lean with it.\n  const wind = 3 + 20 * S.storm;\n  S.cloud += ds * wind;\n  const lean = 5 * S.storm;\n  // As many stay out between the hours: as bats go home, others slip out.\n  if (S.bats.length \u003c 4 * S.nb && Math.random() \u003c ds * 4) spawnBats(S, 1);\n  S.bats = S.bats.filter((b) => {\n    b.ph += ds * TAU * b.fr * (b.mode === 0 ? 1.4 : 1);\n    if (b.mode === 0) {\n      const f = exp(-2.2 * ds);\n      b.x += (b.vx *= f) * ds;\n      b.y += (b.vy *= f) * ds;\n      if ((b.t -= ds) \u003c 0) {\n        b.mode = 1;\n        b.t = rnd(7, 14);\n        b.psi = Math.acos(cl((b.x - AX) / b.R, -1, 1)) * (b.y \u003c b.yc ? -1 : 1);\n      }\n      return true;\n    }\n    let tx, ty;\n    if (b.mode === 1) {\n      // Round the spire on a tilted ring, in front of it while sin(psi) > 0.\n      b.psi += b.w * ds;\n      tx = AX + b.R * cos(b.psi) + lean;\n      ty = b.yc + b.amp * sin(b.psi) * 0.6 + 2.5 * vn(S.t * 0.9, b.sd);\n      b.z = sin(b.psi);\n      if ((b.t -= ds) \u003c 0) b.mode = 2;\n    } else {\n      tx = b.hx;\n      ty = b.hy;\n      b.z += (1 - b.z) * min(1, ds * 3);\n      if (abs(b.x - tx) \u003c 1.2 && abs(b.y - ty) \u003c 1.2) return false;\n    }\n    const kk = b.mode === 2 ? 9 : 6, cc = b.mode === 2 ? 5 : 4.2;\n    b.x += (b.vx += (kk * (tx - b.x) - cc * b.vx) * ds) * ds;\n    b.y += (b.vy += (kk * (ty - b.y) - cc * b.vy) * ds) * ds;\n    return true;\n  });\n  // Lightning: a fork from the top edge.\n  S.boltAge += ds;\n  if ((S.boltWait -= ds) \u003c 0) {\n    S.boltAge = 0;\n    S.boltWait = (30 - 28 * S.storm) * rnd(0.6, 1.4);\n    let x = Math.random() \u003c 0.5 ? rnd(2, 12) : rnd(40, 62), y = 0;\n    const pts = [x, y], end = rnd(26, 58);\n    while (y \u003c end) {\n      x += rnd(-3, 3);\n      y += rnd(2, 5);\n      pts.push(x, y);\n    }\n    S.bolt = pts;\n  }\n  // Rain from Storm 0.3 up.\n  const want = round(max(0, S.storm - 0.3) * 140);\n  while (S.rain.length \u003c want) S.rain.push([rnd(-10, W + 10), rnd(-H, H)]);\n  S.rain.length = want;\n  for (const r of S.rain) {\n    r[0] += ds * wind * 1.5;\n    if ((r[1] += ds * 150) > H) (r[1] -= H + rnd(0, 20)), (r[0] = rnd(-20, W));\n  }\n}\n\n// Flash brightness at a bolt's age: a stroke, a dim gap and a restrike.\nconst flashOf = (a) => (a \u003c 0.07 ? 1 : a \u003c 0.13 ? 0.25 : a \u003c 0.21 ? 0.8 : a \u003c 0.5 ? 0.8 * (1 - (a - 0.21) / 0.29) : 0);\n\nfunction add(buf, x, y, c, f) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  for (let i = 0, o = (y * W + x) * 3; i \u003c 3; i++) buf[o + i] += c[i] * f;\n}\n\nfunction drawBats(S, buf, front) {\n  for (const b of S.bats) {\n    if (b.z \u003c -0.15 === front) continue;\n    const s = sin(b.ph), fr = s > 0.35 ? 0 : s \u003c -0.35 ? 2 : 1, spr = SPR[fr][b.z > 0.55 ? 0 : front ? 1 : 2];\n    const ox = round(b.x) - (spr[0].length >> 1), oy = round(b.y) - 1;\n    for (let j = 0; j \u003c spr.length; j++)\n      for (let i = 0; i \u003c spr[j].length; i++) {\n        if (spr[j][i] !== \"x\") continue;\n        const x = ox + i, y = oy + j;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        // Black against the sky; over black stone, moonlit wings instead.\n        const dark = max(buf[o], buf[o + 1], buf[o + 2]) \u003c 34;\n        put(buf, o, dark ? 60 : 8, dark ? 28 : 3, dark ? 82 : 14);\n      }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, M = hsv(0.075 + S.hue, 0.8, 1, S.c), Gc = hsv(0.32 + S.hue, 0.78, 1, S.g);\n  const F = S.bolt ? flashOf(S.boltAge) : 0;\n  const cover = 0.17 + 0.73 * S.storm, thr = CQ[floor((1 - cover) * (CQ.length - 1))];\n  const off = S.cloud;\n  for (let y = 0; y \u003c H; y++) {\n    const fy = y / 2.6, j0 = floor(fy) % CH, j1 = (j0 + 1) % CH, ty = fy - floor(fy);\n    // Clouds keep off the bottom rows, over the roofs.\n    const band = y > 100 ? (y - 100) * 0.03 : 0;\n    const fl = F * max(0, 1 - y / 80);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p;\n      let R = SKYC[3 * y] + fl * 70, Gg = SKYC[3 * y + 1] + fl * 60, B = SKYC[3 * y + 2] + fl * 100;\n      const gl = GLOW[p], mt = MOONT[p];\n      if (mt) {\n        // The seas are paler, not darker: dark orange would read as brown.\n        const v = mt === 1 ? 0.86 : 1, wv = mt === 2 ? 0.3 : 0;\n        (R = (M[0] + (255 - M[0]) * wv) * v), (Gg = (M[1] + (255 - M[1]) * wv) * v), (B = (M[2] + (255 - M[2]) * wv * 0.7) * v);\n      } else if (gl > 0) {\n        R += M[0] * gl, Gg += M[1] * gl, B += M[2] * gl;\n      }\n      // A cloud here: thin edges catch the moonlight, cores are dark.\n      const fx = (x + off) * 0.32, i0 = floor(fx), tx = fx - i0, a0 = ((i0 % CW) + CW) % CW, a1 = (a0 + 1) % CW;\n      const n = (CN[j0 * CW + a0] * (1 - tx) + CN[j0 * CW + a1] * tx) * (1 - ty) + (CN[j1 * CW + a0] * (1 - tx) + CN[j1 * CW + a1] * tx) * ty;\n      const e = n - band - thr;\n      if (e > 0) {\n        const lit = min(1, gl * 2.2) + fl;\n        if (e \u003c 0.025) {\n          (R = 64 + M[0] * 0.55 * lit), (Gg = 32 + M[1] * 0.55 * lit), (B = 84 + M[2] * 0.4 * lit);\n        } else if (e \u003c 0.07) {\n          (R = 44 + M[0] * 0.18 * lit), (Gg = 22 + M[1] * 0.18 * lit), (B = 60 + M[2] * 0.12 * lit);\n        } else {\n          (R = 30 + fl * 30), (Gg = 14 + fl * 24), (B = 44 + fl * 40);\n        }\n      }\n      put(buf, o, R, Gg, B);\n    }\n  }\n  // The bolt, behind the tower.\n  if (F > 0.5 && S.bolt) {\n    const P = S.bolt;\n    for (let i = 0; i + 3 \u003c P.length; i += 2) {\n      const n = ceil(max(abs(P[i + 2] - P[i]), abs(P[i + 3] - P[i + 1])) * 2);\n      for (let j = 0; j \u003c= n; j++) {\n        const x = round(P[i] + ((P[i + 2] - P[i]) * j) / n), y = round(P[i + 1] + ((P[i + 3] - P[i + 1]) * j) / n);\n        if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(buf, (y * W + x) * 3, 235, 225, 255);\n      }\n    }\n  }\n  drawBats(S, buf, false);\n  // The tower.\n  const sk = S.spark \u003c 0.12, cs = cos(S.th), sn = sin(S.th), rel = S.ph - S.th;\n  const bx = CLAP * sin(rel), by = 3 + CLAP * cos(rel);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p, m = MASK[p];\n      if (m === SKY) continue;\n      if (m === STONE) {\n        let R = 7, Gg = 3, B = 12;\n        const r = RIM[p];\n        if (r) {\n          const c = RIMC[r], f = 1 + F * 0.8;\n          (R = c[0] * f), (Gg = c[1] * f), (B = c[2] * f);\n        }\n        // Green light spilling from the clock onto the stone round it.\n        const cd = sqrt((x + 0.5 - CLX) ** 2 + (y + 0.5 - CLY) ** 2);\n        if (cd \u003c 12.5) {\n          const f = cd \u003c 8.6 ? 0.1 : cd \u003c 10.5 ? 0.16 : 0.07;\n          R += Gc[0] * f, Gg += Gc[1] * f, B += Gc[2] * f;\n        }\n        put(buf, o, R, Gg, B);\n        continue;\n      }\n      if (m === WIN) {\n        const [, , kind, sd] = WINS[WID[p]], c = kind ? Gc : M;\n        // Candlelight: two noises, about 2 and 7 times a second, in three steps.\n        const v = 0.62 + 0.24 * vn(S.t * 2.2, sd) + 0.14 * vn(S.t * 7, sd + 1), lv = WID[p] === 3 ? 0.72 : 1;\n        const f = (v > 0.78 ? 1 : v > 0.56 ? 0.8 : 0.6) * lv;\n        put(buf, o, c[0] * f, c[1] * f, c[2] * f);\n        continue;\n      }\n      if (m === FACE) {\n        const dx = x + 0.5 - CLX, dy = y + 0.5 - CLY, r = sqrt(dx * dx + dy * dy), f = r \u003c 3.5 ? 1 : r \u003c 6 ? 0.86 : 0.72;\n        put(buf, o, Gc[0] * f, Gc[1] * f, Gc[2] * f);\n        continue;\n      }\n      if (m === BEAM) {\n        if (y === 39) put(buf, o, 86, 46, 22);\n        else put(buf, o, 44, 22, 10);\n        continue;\n      }\n      // Inside the belfry: dark, with the sky through the back arch.\n      if (m === BACK) for (let c = 0; c \u003c 3; c++) buf[o + c] *= 0.62;\n      else put(buf, o, 14, 7, 22);\n      if (y \u003c 41) continue;\n      // The bell, in its own frame: u across, v down its axis from the pivot.\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY, u = dx * cs - dy * sn, v = dx * sn + dy * cs;\n      const hw = bellHalf(v), lipv = abs(u) \u003c LIPW ? LIP + 1.8 * sqrt(1 - (u / LIPW) ** 2) : -1;\n      const mouth = (u / 6.8) ** 2 + ((v - LIP) / 1.3) ** 2 \u003c 1;\n      // The clapper's ball, seen inside the mouth.\n      const ball = (u - bx) ** 2 + (v - by) ** 2 \u003c 2.6;\n      if (mouth) {\n        const lt = u - bx + (v - by) \u003c -0.5;\n        if (ball) put(buf, o, lt ? 150 : 70, lt ? 140 : 62, lt ? 150 : 74);\n        else put(buf, o, 22, 10, 6);\n        continue;\n      }\n      if ((hw >= 0 && abs(u) \u003c= hw) || (v > LIP && v \u003c= lipv)) {\n        // Bronze in four tones: a bright band left of the middle, a moonlit\n        // rim on the right, dark edges and a rib round the waist.\n        const t = u / (hw > 0 ? hw : LIPW);\n        let tone = t \u003c -0.78 ? 0 : t \u003c -0.18 ? 2 : t \u003c 0.5 ? 1 : t \u003c 0.82 ? 0 : 2;\n        if (v > LIP - 0.6) tone = t \u003c -0.3 ? 3 : 2;\n        else if (abs(v - 4.2) \u003c 0.5 || abs(v - 12.6) \u003c 0.45) tone = max(0, tone - 1);\n        if (t > -0.6 && t \u003c -0.3 && v > 5 && v \u003c 11) tone = 3;\n        const c = BRONZE[tone];\n        put(buf, o, c[0], c[1], c[2]);\n      } else if (ball && v > LIP) {\n        put(buf, o, 70, 62, 74);\n      }\n    }\n  // The spark where the clapper hits the soundbow.\n  if (sk) {\n    const u = S.sparkS * 6.2, v = LIP - 0.4, x = PX + u * cs + v * sn, y = PY - u * sn + v * cs;\n    for (const [i, j] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) add(buf, x - 0.5 + i, y - 0.5 + j, [255, 240, 190], 1);\n  }\n  // The clock: twelve ticks and two hands, the hour hand short.\n  for (let i = 0; i \u003c 12; i++) {\n    const a = (i / 12) * TAU, x = round(CLX + 6.2 * sin(a) - 0.5), y = round(CLY - 6.2 * cos(a) - 0.5), o = (y * W + x) * 3;\n    for (let c = 0; c \u003c 3; c++) buf[o + c] *= 0.25;\n  }\n  const hand = (a, len) => {\n    for (let r = 0; r \u003c= len; r += 0.35) put(buf, (round(CLY - r * cos(a) - 0.5) * W + round(CLX + r * sin(a) - 0.5)) * 3, 6, 14, 6);\n  };\n  hand(((S.clk % 60) / 60) * TAU, 6.6);\n  hand((S.clk / 720) * TAU, 4.2);\n  drawBats(S, buf, true);\n  // Rings of sound from the bell, two at a time, fading in steps.\n  for (const a of S.rips) {\n    const r = 3 + 38 * a, f = a \u003c 0.45 ? 0.3 : a \u003c 0.9 ? 0.2 : 0.11;\n    for (const [rr, ff] of [[r, f], [r - 5, f * 0.55]]) {\n      if (rr \u003c 2) continue;\n      const n = ceil(TAU * rr * 1.2);\n      for (let i = 0; i \u003c n; i++) add(buf, PX - 0.5 + rr * cos((i / n) * TAU), 52 - 0.5 + rr * sin((i / n) * TAU), [210, 170, 255], ff);\n    }\n  }\n  for (const [rx, ry] of S.rain) {\n    const sl = 0.3 + 0.05 * (3 + 20 * S.storm);\n    for (let j = 0; j \u003c 3; j++) add(buf, rx + sl * j, ry + j, [110, 96, 160], 0.55);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) | 0, min(255, buf[o + 1]) | 0, min(255, buf[o + 2]) | 0);\n}\n","brillouin-zones":"// ===== Patternflow pattern =====\n// Title:   Brillouin Zones\n// Family:  cells\n// Idea:    The plane round one point of a slowly turning, shearing lattice is cut into its Brillouin zones, every LED coloured by how many lattice points are closer to it than the origin is, so the first zone sits in the middle as a hexagon or a square and the higher zones spread outwards as rings of scattered shards in rainbow order, a dark band runs out through the zones one index at a time and relights each in its next colour, and every so often the shards of one zone slide along their lattice vectors into the first zone, fill it with no gap and no overlap, and slide back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Brillouin zones (Léon Brillouin, 1930), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Zones=16..48, Shear=0..1\n//\n// Knob 1: Hue. Turns the whole glass round the colour wheel; zone n sits n - 1 sevenths of the wheel on from zone 1, so the order of the zones reads as a rainbow outwards. At 0 the first zone opens cyan with blue, violet, rose, orange, lime and green round it, and wears blue once the first band has passed; at 0.25 it opens violet, at 0.5 red, at 0.75 lime green.\n// Knob 2: Speed. The lattice's clock. At 2 the dark band runs out 3.2 zones a second, a new band every 8.4 s, the lattice turns 3.4 degrees a second and its angle swings between hexagonal and square over about 27 s; at 0.2 everything is ten times slower, at 3 half as fast again. A fold always takes 3.3 s.\n// Knob 3: Zones. Roughly how many zones fit between the centre and the top edge, which sets the cell: pi 64^2 / Zones LEDs. At 16 each zone is 804 LEDs and about 21 zones reach the corners; at 24 it is 536 LEDs, at 32 402 and about 41 zones, at 48 268 LEDs and about 60 zones, the outer ones broken into single LEDs.\n// Knob 4: Shear. How far the lattice leaves the symmetric ones. At 0 its two arms stay equal within 5% and the angle between them wanders from 55 to 90 degrees, hexagon to square; at 0.06 (the start) the arms differ by 4%; at 0.5 the second arm is 1.35 times the first and the angle runs 45 to 80; at 1 it is 1.7 times and 33 to 68, and the first zone is a long slanted hexagon.\n// Buttons: K1 tap folds the next zone of 4, 5, 6, 7, 8 into the first zone at once. Without a press a fold comes at 12 s and every 24 s after on the lattice's clock.\n\nconst W = 64, H = 128, N = W * H;\n// The origin sits on the corner between the four middle LEDs.\nconst OX = 32, OY = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n// A lattice point farther than twice an LED's distance from the origin can\n// never be closer to that LED than the origin is.\nconst RMAX = 2 * sqrt(OX * OX + OY * OY) + 2;\nconst MAXL = 2048;\n// Zone n is n - 1 sevenths of the wheel on from zone 1: neighbouring zones\n// are always 51 degrees apart and the order outwards reads as a rainbow.\n// Zone 1 at hue 0 is cyan.\nconst STEP = 1 / 7;\nconst HUE0 = 0.52;\n// Glass saturation, the dim glass's brightness, and the lead between panes.\nconst SAT = 0.76, VD = 0.3, LEAD = 0.35;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A dark band BAND_W zones wide runs out through the zones in order 1, 2,\n// 3 ..., BAND_RATE zones a second, a new band every BAND_P zones; each zone\n// it passes relights in its next colour. Since every zone has the same\n// area, the band covers the same area of glass wherever it is.\nconst BAND_RATE = 3.2, BAND_W = 3, BAND_P = 27, PHI0 = -2;\n// Folds come by themselves at 12 s and every 24 s after, in pattern seconds.\nconst AUTO0 = 12, AUTO_EVERY = 24;\n// The fold, in real seconds: the rest of the glass dims, the pieces slide\n// home, hold, slide back, the glass comes up again.\nconst F_IN = 0.35, F_SLIDE = 0.9, F_HOLD = 0.8, F_LEN = 2 * F_IN + 2 * F_SLIDE + F_HOLD;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, nextFold: AUTO0, hue: 0, speed: 2, zones: 16, shear: 0.06,\n    zone: new Uint16Array(N), diff: new Int32Array(W + 1),\n    lx: new Float32Array(MAXL), ly: new Float32Array(MAXL), nl: 0, zTop: 1,\n    // The fold: its age (-1 when none), which zone, how many so far, the\n    // frozen lattice sorted by length (origin first), the candidate pieces\n    // and the first zone's radius.\n    fold: -1, fz: 4, folds: 0,\n    sx: new Float32Array(MAXL + 1), sy: new Float32Array(MAXL + 1), sn: new Float32Array(MAXL + 1), ns: 0,\n    cx: new Float32Array(512), cy: new Float32Array(512), nc: 0, rv: 1,\n    cover: new Int16Array(N),\n    pal: new Float32Array(3 * 256), dot: new Uint8Array(N),\n  };\n}\n\n// The lattice now: basis b1 = a(1,0), b2 = a rho (cos g, sin g), both\n// turned by th, with a set so the cell keeps the area the Zones knob asks.\nfunction lattice(S) {\n  const t = S.t, sh = S.shear;\n  // g wanders between about 55 and 90 degrees: square at 90, hexagonal at 60.\n  const g = (72.5 - 12 * sin(0.23 * t) - 5.5 * sin(0.37 * t + 2) - 22 * sh) * PI / 180;\n  const rho = 1 + 0.05 * sin(0.17 * t + 1) + 0.7 * sh;\n  const th = 0.06 * t + 0.4 * sh;\n  const A = (PI * OY * OY) / S.zones;\n  const a = sqrt(A / (rho * sin(g)));\n  const c = cos(th), s = sin(th);\n  const b1x = a * c, b1y = a * s;\n  const ux = a * rho * cos(g), uy = a * rho * sin(g);\n  const b2x = c * ux - s * uy, b2y = s * ux + c * uy;\n  const mi = ceil((RMAX * a * rho) / A) + 1, mj = ceil((RMAX * a) / A) + 1;\n  let n = 0;\n  for (let i = -mi; i \u003c= mi; i++)\n    for (let j = -mj; j \u003c= mj; j++) {\n      if (!i && !j) continue;\n      const x = i * b1x + j * b2x, y = i * b1y + j * b2y;\n      if (x * x + y * y >= RMAX * RMAX || n >= MAXL) continue;\n      S.lx[n] = x;\n      S.ly[n] = y;\n      n++;\n    }\n  S.nl = n;\n}\n\n// Zone of every LED: 1 + how many lattice points are strictly closer to it\n// than the origin. L is closer to p exactly when p.L > |L|^2 / 2, a half\n// plane bounded by the perpendicular bisector of 0 and L, so along a row\n// each lattice point starts or stops counting at one x.\nfunction zones(S) {\n  const Z = S.zone, D = S.diff, LX = S.lx, LY = S.ly, nl = S.nl;\n  let top = 1;\n  for (let y = 0; y \u003c H; y++) {\n    D.fill(0);\n    const py = y + 0.5 - OY;\n    const rr = 4 * (OX * OX + py * py) + 4;\n    for (let k = 0; k \u003c nl; k++) {\n      const lx = LX[k], ly = LY[k], l2 = lx * lx + ly * ly;\n      if (l2 > rr) continue;\n      const c = l2 / 2 - py * ly;\n      if (abs(lx) \u003c 1e-9) {\n        if (c \u003c 0) D[0]++;\n        continue;\n      }\n      const tx = c / lx + OX - 0.5;\n      if (lx > 0) {\n        const x0 = floor(tx) + 1;\n        if (x0 \u003c W) D[x0 \u003c 0 ? 0 : x0]++;\n      } else {\n        const x1 = ceil(tx);\n        if (x1 > 0) {\n          D[0]++;\n          if (x1 \u003c W) D[x1]--;\n        }\n      }\n    }\n    let run = 1;\n    for (let x = 0; x \u003c W; x++) {\n      run += D[x];\n      Z[y * W + x] = run;\n      if (run > top) top = run;\n    }\n  }\n  S.zTop = top;\n}\n\n// Freeze the lattice for a fold of zone n. Each piece of zone n is the part\n// whose nearest lattice point is one L, and it lands on the first zone when\n// moved by -L. A point u of the first zone is covered by piece L exactly\n// when -L is its n-th nearest lattice point, so L can be a piece only if\n// its length is within twice the first zone's radius of the n-th length.\nfunction foldStart(S, n) {\n  const m = S.nl, idx = new Array(m);\n  for (let k = 0; k \u003c m; k++) idx[k] = k;\n  idx.sort((a, b) => S.lx[a] ** 2 + S.ly[a] ** 2 - S.lx[b] ** 2 - S.ly[b] ** 2);\n  S.sx[0] = S.sy[0] = S.sn[0] = 0;\n  for (let k = 0; k \u003c m; k++) {\n    const x = S.lx[idx[k]], y = S.ly[idx[k]];\n    S.sx[k + 1] = x;\n    S.sy[k + 1] = y;\n    S.sn[k + 1] = sqrt(x * x + y * y);\n  }\n  S.ns = m + 1;\n  let rv = 0;\n  for (let p = 0; p \u003c N; p++)\n    if (S.zone[p] === 1) rv = max(rv, sqrt(((p % W) + 0.5 - OX) ** 2 + (floor(p / W) + 0.5 - OY) ** 2));\n  S.rv = rv + 1;\n  const below = (r) => {\n    let c = 0;\n    while (c \u003c S.ns && S.sn[c] \u003c r) c++;\n    return c;\n  };\n  let nc = 0;\n  for (let k = 1; k \u003c S.ns && nc \u003c 512; k++) {\n    const r = S.sn[k];\n    if (below(r - 2 * S.rv) \u003c= n - 1 && below(r + 2 * S.rv) - 1 >= n - 1) {\n      S.cx[nc] = S.sx[k];\n      S.cy[nc] = S.sy[k];\n      nc++;\n    }\n  }\n  S.nc = nc;\n  S.fz = n;\n  S.fold = 0;\n}\n\n// Which piece of the folding zone covers each LED when the pieces have\n// moved the fraction s of the way home (0 for none).\nfunction foldCover(S, s) {\n  const C = S.cover, n = S.fz, rv = S.rv, SX = S.sx, SY = S.sy, SN = S.sn, ns = S.ns;\n  const nshort = min(17, ns);\n  C.fill(0);\n  for (let k = 0; k \u003c S.nc; k++) {\n    const Lx = S.cx[k], Ly = S.cy[k], ox = (1 - s) * Lx, oy = (1 - s) * Ly;\n    const x0 = max(0, floor(ox + OX - rv)), x1 = min(W - 1, ceil(ox + OX + rv));\n    const y0 = max(0, floor(oy + OY - rv)), y1 = min(H - 1, ceil(oy + OY + rv));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const ux = x + 0.5 - OX - ox, uy = y + 0.5 - OY - oy;\n        // u must lie in the first zone: no short lattice vector closer.\n        let inside = true;\n        for (let j = 1; j \u003c nshort; j++)\n          if (ux * SX[j] + uy * SY[j] > (SN[j] * SN[j]) / 2) {\n            inside = false;\n            break;\n          }\n        if (!inside) continue;\n        // And -L must be its n-th nearest lattice point.\n        const ex = ux + Lx, ey = uy + Ly, d2 = ex * ex + ey * ey, lim = sqrt(ux * ux + uy * uy) + sqrt(d2);\n        let cnt = 0;\n        for (let j = 0; j \u003c ns && SN[j] \u003c= lim; j++) {\n          const dx = ux - SX[j], dy = uy - SY[j];\n          if (dx * dx + dy * dy \u003c d2 && ++cnt >= n) break;\n        }\n        if (cnt === n - 1) C[y * W + x] = k + 1;\n      }\n  }\n}\n\nconst foldS = (a) => (a \u003c F_IN ? 0 : a \u003c F_IN + F_SLIDE ? sm(F_IN, F_IN + F_SLIDE, a) : a \u003c F_IN + F_SLIDE + F_HOLD ? 1 : 1 - sm(F_LEN - F_IN - F_SLIDE, F_LEN - F_IN, a));\nconst foldDim = (a) => sm(0, F_IN, a) * (1 - sm(F_LEN - F_IN, F_LEN, a));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 16, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.zones = cl(k[2], 16, 48);\n  S.shear = cl(k[3], 0, 1);\n  if (S.fold >= 0) {\n    // The lattice holds still while its pieces move.\n    S.fold += d;\n    if (S.fold >= F_LEN) S.fold = -1;\n    else {\n      foldCover(S, foldS(S.fold));\n      return;\n    }\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  lattice(S);\n  zones(S);\n  const press = input.btnPressed && input.btnPressed[0];\n  const auto = S.t >= S.nextFold;\n  if (auto) S.nextFold += AUTO_EVERY;\n  if (press || auto) {\n    // Zones 4 to 8 in turn.\n    foldStart(S, 4 + (S.folds % 5));\n    S.folds++;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const Z = S.zone, PAL = S.pal, DOT = S.dot;\n  const folding = S.fold >= 0, fd = folding ? foldDim(S.fold) : 0;\n  const phi = BAND_RATE * S.t + PHI0;\n  // Each zone's glass: its colour moves one golden step on for every band\n  // that has passed it.\n  const nz = min(S.zTop + 2, 255);\n  for (let n = 1; n \u003c= nz; n++) {\n    const k = phi >= n ? floor((phi - n) / BAND_P) + 1 : 0;\n    hsv(HUE0 + S.hue + (n - 1 + k) * STEP, SAT, 1, PAL, 3 * n);\n  }\n  // The lattice points themselves, as single pale LEDs.\n  DOT.fill(0);\n  for (let k = -1; k \u003c S.nl; k++) {\n    const x = floor((k \u003c 0 ? 0 : S.lx[k]) + OX), y = floor((k \u003c 0 ? 0 : S.ly[k]) + OY);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) DOT[y * W + x] = 1;\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, z = Z[p];\n      const e = (x + 1 \u003c W && Z[p + 1] !== z) || (y + 1 \u003c H && Z[p + W] !== z);\n      // Where this zone is in the band's cycle: dim inside the band, and\n      // flaring towards white just as it relights.\n      const o = 3 * min(z, nz), u = phi >= z ? (phi - z) % BAND_P : BAND_P;\n      const v = u \u003c BAND_W ? VD : 1;\n      let r = PAL[o] * v, g = PAL[o + 1] * v, b = PAL[o + 2] * v;\n      const fl = folding || u \u003c BAND_W ? 0 : max(0, 1 - (u - BAND_W) / 1.2) * 0.6;\n      r += (1 - r) * fl;\n      g += (1 - g) * fl;\n      b += (1 - b) * fl;\n      // Lead between the panes.\n      let f = e ? LEAD : 1;\n      if (folding) {\n        const pc = S.cover[p];\n        if (pc) {\n          // A piece of the folding zone, each piece its own shade.\n          const q = 3 * S.fz, sh = 0.75 + 0.125 * ((pc * 7) % 3);\n          const pe = (x + 1 \u003c W && S.cover[p + 1] !== pc) || (y + 1 \u003c H && S.cover[p + W] !== pc);\n          r = PAL[q] * sh;\n          g = PAL[q + 1] * sh;\n          b = PAL[q + 2] * sh;\n          f = pe ? 0.45 : 1;\n        } else {\n          // The rest dims, the places the pieces left go dark, and the\n          // first zone's rim shows white.\n          f *= 1 - fd * (z === S.fz ? 0.94 : 0.72);\n          const rim = z === 1 && ((x > 0 && Z[p - 1] !== 1) || (x + 1 \u003c W && Z[p + 1] !== 1) || (y > 0 && Z[p - W] !== 1) || (y + 1 \u003c H && Z[p + W] !== 1));\n          if (rim) (r = g = b = 1), (f = 0.25 + 0.6 * fd);\n        }\n      }\n      if (DOT[p]) {\n        r += (1 - r) * 0.7;\n        g += (1 - g) * 0.7;\n        b += (1 - b) * 0.7;\n        f = max(f, 0.8);\n      }\n      display.setPixel(x, y, r * f * 255, g * f * 255, b * f * 255);\n    }\n}\n","ghost-ship":"// ===== Patternflow pattern =====\n// Title:   Ghost Ship\n// Family:  halloween\n// Idea:    A tattered three-masted ship drifts across a dark sea under a pale moon, pitching and heaving on the swells under her while her torn sails flap, her slack rigging swings, St. Elmo's fire flickers on her mast tops and green lanterns sway at bow and stern and throw their light on the water and into the fog, and now and then she turns half see-through so the moon shows through her, or sinks into the rolling purple fog and comes back further on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Swell=1..4, Fog=0..1\n//\n// Knob 1: Hue. The ghost light: lanterns, their halos, streaks and glow in the fog, the glow round her outline, gunports, rail and St. Elmo's fire. At 0 toxic green, at 0.25 azure, at 0.5 violet, at 0.75 red orange; the moon, the sails and the orange cabin windows stay as they are.\n// Knob 2: Speed. At 2 a swell passes under her every 3.5 seconds, the sails flap 1.2 times a second and she drifts 12 LEDs in 24 seconds before the fog takes her and gives her back at the right; at 0.2 all ten times slower, at 3 half as fast again.\n// Knob 3: Swell. At 1 a gentle sea: she pitches 0.1 rad either way, her main truck swings 16 LEDs and spray flies about once a second; at 2.5 she pitches 0.25 rad, heaves 5 LEDs and throws spray at every plunge; at 4 she pitches 0.38 rad, heaves 8 LEDs and the near swells wash over her hull.\n// Knob 4: Fog. At 0 and at the opening 0.06, wisps along the waterline, thickest round the hull; at 0.5 the fog swallows the lower hull and the far sea and reaches the lower sails; at 1 it climbs to row 20, her hull is gone and only the sails, masts and lantern glow show through.\n// Buttons: K1 tap sinks the ship into the fog: she fades out in a second, the fog closes over where she was, and 1.5 seconds later she comes back 5 LEDs further on.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan, exp, PI } = Math;\nconst TAU = 2 * PI, R = () => Math.random();\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n  return out;\n}\n// Into the float frame: set, add colour c times v, move towards a colour by a.\nconst put = (B, p, r, g, b) => ((B[p] = r), (B[p + 1] = g), (B[p + 2] = b));\nconst add = (B, p, c, v) => ((B[p] += c[0] * v), (B[p + 1] += c[1] * v), (B[p + 2] += c[2] * v));\nconst mix = (B, p, r, g, b, a) => ((B[p] += (r - B[p]) * a), (B[p + 1] += (g - B[p + 1]) * a), (B[p + 2] += (b - B[p + 2]) * a));\n// Value noise for the fog.\nconst NT = new Float32Array(65536);\nfor (let i = 0; i \u003c 65536; i++) NT[i] = hash(i * 7 + 3);\nfunction vn(x, y) {\n  const xi = floor(x), yi = floor(y);\n  let fx = x - xi, fy = y - yi;\n  fx = fx * fx * (3 - 2 * fx);\n  fy = fy * fy * (3 - 2 * fy);\n  const x0 = xi & 255, x1 = (xi + 1) & 255, y0 = (yi & 255) \u003c\u003c 8, y1 = ((yi + 1) & 255) \u003c\u003c 8;\n  const a = NT[y0 + x0], b = NT[y0 + x1], c = NT[y1 + x0], d = NT[y1 + x1];\n  return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;\n}\n\n// The night, built once: the horizon row, the moon's centre and radius.\nconst HZ = 84, MX = 46, MY = 25, MR = 10;\n// Sky in eight flat steps, near black at the top to a purple haze on the horizon.\nconst SKY = new Float32Array(N * 3);\nfor (let y = 0; y \u003c HZ + 6; y++) {\n  const t = round(8 * sm(0, HZ, y)) / 8;\n  for (let x = 0; x \u003c W; x++) {\n    put(SKY, (y * W + x) * 3, 0.03 + 0.2 * t, 0.02 + 0.1 * t, 0.09 + 0.24 * t);\n  }\n}\n// The moon with three darker seas, and its halo in stepped rings.\nconst MOON = new Float32Array(N);\nconst SEAS = [[-3, -3, 4, 3], [4, 1, 3, 4], [-2, 5, 3, 2]];\nfor (let y = 0; y \u003c HZ; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy), p = (y * W + x) * 3;\n    if (r \u003c MR) {\n      let e = 9;\n      for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2);\n      MOON[y * W + x] = e \u003c 1 ? 0.84 : 1;\n      continue;\n    }\n    add(SKY, p, [0.9, 0.85, 0.8], r \u003c MR + 3 ? 0.2 : r \u003c MR + 7 ? 0.11 : r \u003c MR + 13 ? 0.05 : 0);\n  }\n// Stars, each with a twinkle phase.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 22 && i \u003c 500; i++) {\n  const x = floor(hash(i * 3 + 1) * W), y = floor(hash(i * 3 + 2) * 70);\n  if ((x - MX) ** 2 + (y - MY) ** 2 \u003c (MR + 5) ** 2) continue;\n  STARS.push([x, y, hash(i * 3 + 3) * TAU]);\n}\n\n// How a lantern's light in the fog falls off with the squared distance.\nconst FALL = new Float32Array(900);\nfor (let i = 0; i \u003c 900; i++) FALL[i] = exp(-sqrt(i) / 10);\n\n// Thin clouds far behind her: row, length, thickness, speed, start.\nconst CLOUDS = [[13, 30, 2.2, 1.6, 62], [33, 24, 1.8, 2.3, 78], [46, 36, 2.6, 1.2, 50]];\n\n// ---- The sea: six layers of swell, far to near. Each is a wave line\n// (base row, amplitude per unit of Swell, wavenumber, frequency, phase) with a\n// flat face below it; the ship rides on layer 3.\nconst LAYERS = [\n  [87, 0.35, 0.24, 2.0, 0.0],\n  [91, 0.6, 0.18, 1.95, 1.7],\n  [96, 0.9, 0.14, 1.9, 3.1],\n  [101, 2.0, 0.105, 1.8, 0.6],\n  [110, 2.6, 0.085, 1.7, 2.4],\n  [121, 3.2, 0.07, 1.6, 4.4],\n];\nconst SHIP_LAYER = 3;\n// Face and crest colours of each layer: hazy far, black-blue near.\nconst FACE = [[0.15, 0.12, 0.3], [0.11, 0.1, 0.25], [0.08, 0.075, 0.2], [0.06, 0.06, 0.16], [0.045, 0.045, 0.13], [0.035, 0.035, 0.11]];\nconst CREST = [[0.32, 0.27, 0.5], [0.3, 0.27, 0.52], [0.3, 0.28, 0.55], [0.33, 0.32, 0.6], [0.34, 0.33, 0.62], [0.36, 0.35, 0.66]];\nfunction eta(j, x, t, swell) {\n  const L = LAYERS[j], k = L[2], w = L[3];\n  return swell * L[1] * (sin(k * x - w * t + L[4]) + 0.35 * sin(2.3 * k * x + 1.7 * w * t + 2 * L[4]));\n}\n\n// ---- The ship, in her own frame: u along the hull, bow at -u, w up from\n// the waterline.\nconst MASTS = [[-11, 68], [0, 79], [11, 58]];\n// Sails: top and bottom centre, top and bottom row, top and bottom half width.\n// Three tiers on fore and main, two on the mizzen, a jib to the bowsprit.\nconst SAILS = [\n  [-11, -11, 64, 54, 2.5, 3.5], [-11, -11, 52, 41, 3.5, 4.5], [-11, -11, 39, 27, 4, 4.8],\n  [0, 0, 75, 65, 2.5, 3.5], [0, 0, 63, 51, 3.5, 4.5], [0, 0, 49, 35, 4.2, 5],\n  [11, 11, 54, 45, 2.5, 3.5], [11, 11, 43, 31, 3.5, 4.5],\n  [-12.5, -22, 48, 15, 0.3, 4.5],\n];\n// Yards across the square sails' tops and bottoms: mast u, row, half width.\nconst YARDS = [];\nfor (const s of SAILS.slice(0, 8)) YARDS.push([s[0], s[2], s[4] + 1], [s[0], s[3] + 0.5, s[5] + 0.5]);\nconst hullTop = (u) => 9 + 2.5 * sm(-14, -19, u) + 4 * sm(10, 12, u) + 2 * sm(14, 21, u);\nconst hullBot = (u) => -5 + 15 * sm(-15, -23, u) + 7 * sm(17, 22, u);\n// Broken stretches of rail, as rows taken off the top.\nconst RAIL = new Float32Array(48);\nfor (let i = 0; i \u003c 48; i++) RAIL[i] = hash(i + 900) \u003c 0.22 ? 1 : 0;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, swell: 1, fog: 0.06, t: 0,\n    // Where she is, her pitch, heave and lagging pitch (the lanterns swing\n    // from it), and the bow's depth and how fast it plunges.\n    xs: 36, pitch: 0, heave: 0, lag: 0, bowY: 0, bowV: 0,\n    // Her opacity: a ghost dip now and then, and the vanish that the button\n    // or the end of a crossing starts (age -1 when none).\n    alpha: 1, dip: -1, dipWait: 5, van: -1, moveTo: 36,\n    spray: [], fires: [], buf: new Float32Array(N * 3), ship: new Float32Array(N * 4),\n    lines: new Float32Array(W * 6), aura: new Float32Array(N), tmp: new Float32Array(N), lamps: [[0, 0], [0, 0]], g: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.swell = cl(k[2], 1, 4);\n  S.fog = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  const t = S.t, sw = S.swell;\n  // She rides her layer's swell: heave from the water under her middle,\n  // pitch from the slope between bow and stern, both lagging a little.\n  const e0 = eta(SHIP_LAYER, S.xs - 17, t, sw), e1 = eta(SHIP_LAYER, S.xs + 17, t, sw), em = eta(SHIP_LAYER, S.xs, t, sw);\n  const tp = atan((e0 - e1) / 34) * 0.75;\n  S.pitch += (tp - S.pitch) * min(1, ds * 5);\n  S.heave += (0.85 * em - S.heave) * min(1, ds * 5);\n  S.lag += (S.pitch - S.lag) * min(1, ds * 2.2);\n  // Drift: 12 LEDs in 24 s, then she sinks into the fog and comes back\n  // at the right.\n  if (S.van \u003c 0) S.xs -= ds * 0.5;\n  if (S.van \u003c 0 && S.xs \u003c 26) start(S, 38);\n  if (input.btnPressed && input.btnPressed[0] && S.van \u003c 0) start(S, S.xs - 5 \u003c 26 ? 38 : S.xs - 5);\n  // The vanish: out in 1 s, gone 1.5 s (she moves then), back in 1.5 s.\n  let a = 1;\n  if (S.van >= 0) {\n    S.van += ds;\n    if (S.van \u003c 1) a = 1 - sm(0, 1, S.van);\n    else if (S.van \u003c 2.5) {\n      a = 0;\n      S.xs = S.moveTo;\n    } else if (S.van \u003c 4) a = sm(2.5, 4, S.van);\n    else S.van = -1;\n  } else if (S.dip >= 0) {\n    // A ghost dip: down to 0.45 in 0.8 s, held 1.2 s, back in 0.8 s.\n    S.dip += ds;\n    a = 1 - 0.55 * (S.dip \u003c 0.8 ? sm(0, 0.8, S.dip) : S.dip \u003c 2 ? 1 : 1 - sm(2, 2.8, S.dip));\n    if (S.dip > 2.8) {\n      S.dip = -1;\n      S.dipWait = 8 + 7 * R();\n    }\n  } else {\n    S.dipWait -= ds;\n    if (S.dipWait \u003c= 0) S.dip = 0;\n  }\n  S.alpha = a;\n  // Spray: the bow's depth in the water under it (LEDs, deeper positive),\n  // and droplets thrown forward and up while it plunges.\n  const bx = S.xs - 22 * cos(S.pitch), wl = LAYERS[SHIP_LAYER][0];\n  const by = 22 * sin(S.pitch) - S.heave + eta(SHIP_LAYER, bx, t, sw);\n  S.bowV = ds > 0 && S.t > ds ? (by - S.bowY) / ds : 0;\n  S.bowY = by;\n  if (S.bowV > 2 && by > -3 && S.spray.length \u003c 60 && a > 0.2 && R() \u003c ds * 0.8 * sw * (S.bowV - 2)) {\n    const n = 1 + floor(R() * sw);\n    for (let i = 0; i \u003c n; i++)\n      S.spray.push({ x: bx - 2 * R(), y: wl - eta(SHIP_LAYER, bx, t, sw) - 1, vx: -6 - 10 * R(), vy: -(8 + 7 * sw) * (0.6 + 0.6 * R()), age: 0, life: 0.5 + 0.5 * R() });\n  }\n  for (const p of S.spray) {\n    p.age += ds;\n    p.vy += 45 * ds;\n    p.x += p.vx * ds;\n    p.y += p.vy * ds;\n  }\n  S.spray = S.spray.filter((p) => p.age \u003c p.life);\n}\n\nfunction start(S, to) {\n  S.van = 0;\n  S.dip = -1;\n  S.moveTo = to;\n}\n\n// The ship's frame to the screen.\nfunction toScreen(S, u, w, out) {\n  const c = cos(S.pitch), s = sin(S.pitch), y0 = LAYERS[SHIP_LAYER][0] - S.heave;\n  out[0] = S.xs + u * c - w * s;\n  out[1] = y0 - (u * s + w * c);\n  return out;\n}\n\n// One sail: is (u, w) on its cloth, and how lit. 0 when not.\nfunction sailAt(S, i, u, w) {\n  const sl = SAILS[i], wt = sl[2], wb = sl[3];\n  if (w > wt + 0.5 || w \u003c wb - 4) return 0;\n  const ut = sl[0], ub = sl[1], ht = sl[4], hb = sl[5], t = S.t;\n  const span = wt - wb, s = (wt - w) / span, hw = ht + (hb - ht) * cl(s, 0, 1);\n  if (abs(u - ut - (ub - ut) * s) > hw + 3.5) return 0;\n  // The flap: a wave running down the cloth about once a second, pushing the\n  // lower part to and fro, with the belly blown towards the bow.\n  const ph = 7.5 * t - 2.6 * s + i * 1.9;\n  const du = (1.2 + 0.3 * S.swell) * s * s * sin(ph) - 1.6 * s * (1 - s);\n  const ul = u - ut - (ub - ut) * s - du;\n  if (abs(ul) > hw + 0.5) return 0;\n  // The torn foot: tongues of cloth of different lengths, each swinging.\n  const tongue = floor((ul + 12) / 1.7) + i * 31;\n  const rag = (hash(tongue) - 0.35) * 0.5 + 0.06 * sin(ph * 1.3 + tongue);\n  const belly = 0.1 * (1 - (ul / hw) ** 2);\n  if (s > 1 + belly + rag || s \u003c 0) return 0;\n  // Holes, fixed to the cloth.\n  if (hash(floor((ul + 12) / 1.6) * 97 + floor((s * span) / 1.6) * 13 + i * 7) \u003c 0.1) return 0;\n  // Folds catch the moon as the wave runs down: three tones.\n  const lit = 0.5 + 0.5 * cos(ph + ul * 0.5);\n  return lit > 0.66 ? 1 : lit > 0.33 ? 0.76 : 0.52;\n}\n\nfunction plot(S, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const q = (y * W + x) * 4, sh = S.ship;\n  if (a \u003c sh[q + 3]) return;\n  put(sh, q, r, g, b);\n  sh[q + 3] = a;\n}\n// A line in the ship's frame, sagging sideways by sag at its middle.\nconst P = [0, 0];\nfunction line(S, u0, w0, u1, w1, sag, r, g, b, a) {\n  const len = sqrt((u1 - u0) ** 2 + (w1 - w0) ** 2), n = Math.ceil(len * 1.6);\n  const nu = -(w1 - w0) / (len || 1), nw = (u1 - u0) / (len || 1);\n  for (let i = 0; i \u003c= n; i++) {\n    const f = i / n, bow = 4 * f * (1 - f) * sag;\n    toScreen(S, u0 + (u1 - u0) * f + nu * bow, w0 + (w1 - w0) * f + nw * bow, P);\n    plot(S, P[0], P[1], r, g, b, a);\n  }\n}\n\n// A 7-wide running mean along each of the lines of a frame: n LEDs a line,\n// lines starting ls apart, LEDs st apart along them.\nfunction box(src, dst, n, lines, ls, st) {\n  for (let l = 0; l \u003c lines; l++) {\n    let run = 0;\n    const o = l * ls;\n    for (let i = -3; i \u003c n + 3; i++) {\n      if (i + 3 \u003c n) run += src[o + (i + 3) * st];\n      if (i - 4 >= 0) run -= src[o + (i - 4) * st];\n      if (i >= 0 && i \u003c n) dst[o + i * st] = run / 7;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const t = S.t, sw = S.swell, A = S.alpha, B = S.buf, sh = S.ship, G = S.g;\n  // The ghost light, toxic green at the opening.\n  hsv(0.3 + S.hue, 0.85, 1, G);\n  const flick = 0.82 + 0.1 * sin(t * 13.1) + 0.08 * sin(t * 29.7 + 1);\n\n  // Sky, moon and stars.\n  B.set(SKY);\n  for (let p = 0; p \u003c N; p++)\n    if (MOON[p] > 0) put(B, 3 * p, 0.9 * MOON[p], 0.88 * MOON[p], 0.78 * MOON[p]);\n  for (const [x, y, ph] of STARS) {\n    const v = 0.3 + 0.25 * sin(t * 2.3 + ph), p = (y * W + x) * 3;\n    put(B, p, max(B[p], v), max(B[p + 1], v), max(B[p + 2], v * 1.1));\n  }\n\n  // Clouds: dark slate with a rim lit by the moon along the top, brighter\n  // and see-through where they cross the moon.\n  for (let k = 0; k \u003c CLOUDS.length; k++) {\n    const [cy, len, th, sp, x0] = CLOUDS[k], cx = ((((x0 - sp * t) % 110) + 110) % 110) - 23;\n    for (let x = max(0, floor(cx - len / 2 - 2)); x \u003c min(W, cx + len / 2 + 2); x++) {\n      const u = (x + 0.5 - cx) / (len / 2);\n      if (abs(u) >= 1) continue;\n      const half = th * sqrt(1 - u * u) * (0.75 + 0.25 * sin(u * 7 + k * 2)), mid = cy + 1.2 * sin(u * 2.5 + k);\n      for (let y = max(0, floor(mid - half)); y \u003c min(HZ, mid + half + 1); y++) {\n        const p = (y * W + x) * 3, near = MOON[y * W + x] > 0;\n        const rim = y + 0.5 \u003c mid - half + 1, a = near ? 0.6 : 0.85;\n        mix(B, p, rim ? 0.42 : 0.13, rim ? 0.38 : 0.09, rim ? 0.5 : 0.22, a);\n      }\n    }\n  }\n\n  // The sea lines for every column, then the layers far to near.\n  const L = S.lines;\n  for (let j = 0; j \u003c 6; j++) for (let x = 0; x \u003c W; x++) L[j * W + x] = round(LAYERS[j][0] - eta(j, x + 0.5, t, sw));\n  // Which layer's water each LED shows, -1 for sky; she shows only in\n  // front of the sky and the layers behind hers.\n  const layerOf = (x, y) => {\n    for (let j = 5; j >= 0; j--) if (y >= L[j * W + x]) return j;\n    return -1;\n  };\n  for (let y = HZ - 6; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const j = layerOf(x, y);\n      if (j \u003c 0) continue;\n      const p = (y * W + x) * 3, top = y - L[j * W + x];\n      // Crests one LED thick on the far layers, two on the near ones.\n      const c = top \u003c 1 || (top \u003c 2 && j >= SHIP_LAYER) ? CREST[j] : FACE[j];\n      put(B, p, c[0], c[1], c[2]);\n      // Moon glitter: dashes under the moon, wider towards the viewer,\n      // flickering with the crests.\n      const spread = 0.8 + (y - HZ) * 0.08, dx = abs(x + 0.5 - MX + 0.12 * (y - HZ));\n      if (dx \u003c spread && (top \u003c 1 || hash(x * 131 + y * 7 + floor(t * 7) * 1009) \u003c 0.1)) {\n        const v = top \u003c 1 ? 0.85 : 0.5;\n        put(B, p, 0.9 * v, 0.87 * v, 0.72 * v);\n      } else if (top >= 2 && top === round(3.5 + 2.5 * sin(x * LAYERS[j][2] * 2.1 + t * 2.3 + j * 1.3))) {\n        // A ripple across each face, a second, fainter crest.\n        put(B, p, (c[0] + CREST[j][0]) / 2, (c[1] + CREST[j][1]) / 2, (c[2] + CREST[j][2]) / 2);\n      }\n    }\n\n  // ---- The ship, into its own buffer with an opacity per LED.\n  sh.fill(0);\n  if (A > 0.01) {\n    const c = cos(S.pitch), s = sin(S.pitch), y0 = LAYERS[SHIP_LAYER][0] - S.heave;\n    // Hull and sails, LED by LED, in a box round her.\n    const x0 = max(0, floor(S.xs - 40)), x1 = min(W - 1, Math.ceil(S.xs + 40));\n    const yTop = max(0, floor(y0 - 77 * c - 32 * abs(s)));\n    for (let y = yTop; y \u003c y0 + 8 && y \u003c H; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - S.xs, dy = y0 - (y + 0.5);\n        const u = dx * c + dy * s, w = -dx * s + dy * c, q = (y * W + x) * 4;\n        if (w \u003c 15.5 && u > -23 && u \u003c 22 && w > hullBot(u) && w \u003c hullTop(u)) {\n          const top = hullTop(u), rail = RAIL[cl(floor(u + 24), 0, 47)];\n          if (w > top - rail) continue;\n          let r = 0.07, g = 0.05, b = 0.11;\n          // Planks: a lighter seam every third row.\n          if (((w + 30) | 0) % 3 === 0) (r = 0.1), (g = 0.08), (b = 0.15);\n          // The rail lit by the ghost light.\n          if (w > top - rail - 1.1) (r = G[0] * 0.3), (g = G[1] * 0.3), (b = G[2] * 0.3);\n          // Gunports glowing from inside.\n          const gp = (u + 30) / 5 - floor((u + 30) / 5);\n          if (w > 4 && w \u003c 6 && gp > 0.45 && gp \u003c 0.8 && u > -15 && u \u003c 10) (r = G[0] * 0.6 * flick), (g = G[1] * 0.6 * flick), (b = G[2] * 0.6 * flick);\n          // The stern's cabin windows, candle orange.\n          if (w > 9.5 && w \u003c 11.6 && ((u > 13.5 && u \u003c 15.5) || (u > 17 && u \u003c 19))) (r = 1 * flick), (g = 0.45 * flick), (b = 0.06);\n          put(sh, q, r, g, b);\n          sh[q + 3] = A;\n          continue;\n        }\n        if (w \u003c 12 || w > 76 || u \u003c -30 || u > 19) continue;\n        for (let i = 0; i \u003c SAILS.length; i++) {\n          const v = sailAt(S, i, u, w);\n          if (v > 0) {\n            put(sh, q, 0.68 * v, 0.66 * v, 0.78 * v);\n            sh[q + 3] = 0.88 * A;\n            break;\n          }\n        }\n      }\n    // Masts, yards and bowsprit in dark grey-violet; the rigging fainter,\n    // slack and swinging.\n    const mr = 0.2, mg = 0.17, mb = 0.27;\n    for (const [mu, mh] of MASTS) line(S, mu, 8, mu, mh, 0, mr, mg, mb, A);\n    line(S, 0.6, 8, 0.6, 60, 0, mr, mg, mb, A);\n    for (const [yu, yw, yh] of YARDS) line(S, yu - yh, yw, yu + yh, yw, 0, mr, mg, mb, A);\n    line(S, -21, 10, -31, 16, 0, mr, mg, mb, A);\n    const rr = 0.13, rg = 0.12, rb = 0.2;\n    MASTS.forEach(([mu, mh], i) => {\n      const sway = 0.9 * sin(t * 2.1 + i * 2) + 6 * (S.pitch - S.lag);\n      line(S, mu, mh, i ? MASTS[i - 1][0] : -31, i ? MASTS[i - 1][1] - 14 : 16, sway, rr, rg, rb, 0.8 * A);\n      line(S, mu, mh - 3, mu + 7, hullTop(mu + 7), -0.5 * sway, rr, rg, rb, 0.8 * A);\n      line(S, mu, mh - 3, mu - 6, hullTop(mu - 6), 0.5 * sway, rr, rg, rb, 0.8 * A);\n    });\n    line(S, 11, 58, 21, hullTop(21), 0.7 * sin(t * 1.7), rr, rg, rb, 0.8 * A);\n    // A torn pennant streaming forward off the main truck.\n    for (let i = 0; i \u003c= 14; i++) {\n      const f = i / 14, pw = 79 - 1.2 * f + 1.6 * f * sin(t * 9 - 5 * f);\n      toScreen(S, -f * 9, pw, P);\n      plot(S, P[0], P[1], 0.6, 0.58, 0.7, A);\n      if (f \u003c 0.55) {\n        toScreen(S, -f * 9, pw - 1, P);\n        plot(S, P[0], P[1], 0.6, 0.58, 0.7, A);\n      }\n    }\n    // Lanterns at bow and stern, swinging on hooks against the pitch.\n    const sway = cl(-4 * (S.pitch - S.lag) + 0.15 * sin(t * 3), -0.9, 0.9);\n    [[-20, 14], [20, 18]].forEach(([lu, lw], i) => {\n      toScreen(S, lu, lw, P);\n      const hx = P[0], hy = P[1];\n      const lx = hx + 2.5 * sin(sway + S.pitch), ly = hy + 2.5 * cos(sway + S.pitch);\n      S.lamps[i] = [lx, ly];\n      for (let k = 0; k \u003c= 3; k++) plot(S, hx + (lx - hx) * (k / 3), hy + (ly - hy) * (k / 3) - 1, mr, mg, mb, A);\n    });\n    // Where St. Elmo's fire can burn: the three mast tops and the main\n    // course yard's two arms.\n    S.fires.length = 0;\n    for (const [mu, mh] of MASTS) S.fires.push(toScreen(S, mu, mh + 1, [0, 0]));\n    S.fires.push(toScreen(S, -6, 36, [0, 0]), toScreen(S, 6, 36, [0, 0]));\n  }\n\n  // The ghost light round her: her opacity blurred twice over 7 x 7 LEDs,\n  // laid on in four flat steps just outside her outline.\n  const au = S.aura, tm = S.tmp;\n  for (let i = 0; i \u003c N; i++) au[i] = sh[i * 4 + 3];\n  for (let pass = 0; pass \u003c 2; pass++) {\n    box(au, tm, W, H, W, 1);\n    box(tm, au, H, W, 1, W);\n  }\n  // The ship over the sky and far sea, under her own water.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 4, a = sh[q + 3], i = y * W + x;\n      // Only outside her outline: inside a sail's holes the blur runs high.\n      if (au[i] > 0.04 && au[i] \u003c 0.5 && a \u003c 0.5 && y \u003c LAYERS[SHIP_LAYER][0] + 2) {\n        add(B, i * 3, G, (round(min(1, au[i] * 2) * 4) / 4) * 0.36 * flick);\n      }\n      if (a > 0 && layerOf(x, y) \u003c SHIP_LAYER) mix(B, i * 3, sh[q], sh[q + 1], sh[q + 2], a);\n    }\n\n  // Lantern light: halos in stepped rings and a trembling streak below.\n  const la = (0.35 + 0.65 * A) * flick;\n  if (A > 0.01)\n    for (const [lx, ly] of S.lamps) {\n      for (let y = max(0, floor(ly - 13)); y \u003c min(H, ly + 14); y++)\n        for (let x = max(0, floor(lx - 13)); x \u003c min(W, lx + 14); x++) {\n          const r = sqrt((x + 0.5 - lx) ** 2 + (y + 0.5 - ly) ** 2), p = (y * W + x) * 3;\n          const v = r \u003c 1.2 ? 1 : r \u003c 3 ? 0.42 : r \u003c 5.5 ? 0.2 : r \u003c 9 ? 0.09 : r \u003c 13 ? 0.04 : 0;\n          if (v === 1) put(B, p, 0.6 + 0.4 * G[0], 0.6 + 0.4 * G[1], 0.6 + 0.4 * G[2]);\n          else add(B, p, G, v * la);\n        }\n      const wl = LAYERS[SHIP_LAYER][0] - eta(SHIP_LAYER, lx, t, sw);\n      for (let y = round(wl) + 1; y \u003c H; y += 1) {\n        const f = (y - wl) / 30, wob = round(lx + 1.8 * sin(y * 0.8 - t * 5) * (0.5 + f));\n        if (hash(y * 17 + floor(t * 9) * 131 + round(lx)) > 0.62 - 0.2 * f) continue;\n        const v = la * 0.75 * (1 - 0.6 * cl(f, 0, 1));\n        for (let x = max(0, wob - 1); x \u003c= min(W - 1, wob + 1); x++) add(B, (y * W + x) * 3, G, x === wob ? v : v / 2);\n      }\n    }\n  // St. Elmo's fire: each point flares and dies on its own noise, a core\n  // with a flame licking upward.\n  if (A > 0.01)\n    S.fires.forEach(([fx, fy], i) => {\n      const on = vn(t * 2.6 + i * 37, i * 11) * (0.6 + 0.4 * sin(t * 17 + i * 3));\n      if (on \u003c 0.42) return;\n      const v = cl((on - 0.42) * 3, 0, 1) * (0.4 + 0.6 * A), lick = round(1 + 1.5 * vn(t * 9 + i * 5, 3));\n      const pts = [[0, 0, 1], [-1, 0, 0.45], [1, 0, 0.45], [0, 1, 0.35]];\n      for (let k = 1; k \u003c= lick; k++) pts.push([round(0.6 * sin(t * 11 + i + k)), -k, 0.7 - 0.25 * k]);\n      for (const [ox, oy, e] of pts) {\n        const x = round(fx) + ox, y = round(fy) + oy;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        mix(B, (y * W + x) * 3, 0.5 * G[0] + 0.5, 0.5 * G[1] + 0.5, 0.5 * G[2] + 0.5, v * e);\n      }\n    });\n  // Spray off the bow.\n  for (const s of S.spray) {\n    const x = round(s.x), y = round(s.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const v = 0.85 * (1 - s.age / s.life), p = (y * W + x) * 3;\n    put(B, p, max(B[p], 0.8 * v), max(B[p + 1], 0.85 * v), max(B[p + 2], v));\n  }\n\n  // The fog bank: two octaves of rolling noise along the waterline,\n  // thickened where she has just vanished, in five flat steps.\n  const fogAmt = 0.5 + 1.4 * S.fog, gone = 1 - A, roll = 0.4 * sin(t * 0.4);\n  const [l0x, l0y] = S.lamps[0], [l1x, l1y] = S.lamps[1], lit = A > 0.01 ? 0.6 * la : 0;\n  for (let y = floor(48 - 28 * S.fog); y \u003c H; y++) {\n    const band = sm(48 - 28 * S.fog, 80 - 20 * S.fog, y) * (1 - 0.5 * sm(104, 127, y));\n    for (let x = 0; x \u003c W; x++) {\n      const n = 0.6 * vn(x * 0.045 + t * 0.4, y * 0.09 + 7) + 0.4 * vn(x * 0.13 - t * 0.8 + 3, y * 0.26 + roll);\n      let dd = band * fogAmt * (n * 2.2 - 0.75);\n      if (gone > 0) dd += gone * 0.9 * exp(-(((x - S.xs) / 18) ** 2)) * sm(30, 70, y) * (1 - sm(105, 125, y));\n      dd = round(cl(dd, 0, 0.9) * 5) / 5;\n      if (dd \u003c= 0) continue;\n      // The fog glows with the lanterns near them.\n      const r0 = round((x - l0x) ** 2 + (y - l0y) ** 2), r1 = round((x - l1x) ** 2 + (y - l1y) ** 2);\n      const gl = round(lit * ((r0 \u003c 900 ? FALL[r0] : 0) + (r1 \u003c 900 ? FALL[r1] : 0)) * 10) / 10;\n      mix(B, (y * W + x) * 3, 0.36 + G[0] * gl, 0.25 + G[1] * gl, 0.5 + G[2] * gl, dd);\n    }\n  }\n\n  for (let p = 0; p \u003c N; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(B[3 * p], 0, 1) * 255), round(cl(B[3 * p + 1], 0, 1) * 255), round(cl(B[3 * p + 2], 0, 1) * 255));\n}\n","glass-patterns":"// ===== Patternflow pattern =====\n// Title:   Glass Patterns\n// Family:  noise\n// Idea:    A field of random dots is laid over three copies of itself, each moved on once more by the same small linear map T = exp(εA) about a wandering fixed point, so the eye joins every dot to its partners and reads the flow of x' = Ax, concentric circles for a rotation, spirals, rays out of a source and into a sink, hyperbolas for a saddle, while the dots shimmer, die and are dealt again and A travels a slow loop through the trace-determinant plane drawn in a strip at the top, where the axes, the parabola τ² = 4Δ and the tinted regions say which kind of picture the field below is showing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Glass patterns (Leon Glass, 1969), with the trace-determinant classification of linear systems (Henri Poincaré, 1881), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dots=320..800, Step=0..1\n//\n// Knob 1: Hue. Turns the dots round the wheel; each chain of four runs from a deep tail to a pale head, the head leading the flow. At 0 ice cyan heads over violet tails, at 0.25 violet over red, at 0.5 rose over lime, at 0.75 lime over cyan. The strip keeps its own colours: magenta for the saddles, amber for the nodes, teal for the spirals.\n// Knob 2: Speed. How fast A goes round its loop of four stops (circles, rays out, hyperbolas, rays in): at 2 a stop every 4 s and the whole loop in 16 s, each stop held for about a second, the dots riding the flow at 0.3 of its rate and living 0.9 to 1.8 s; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Dots. How many chains of four are dealt over the 64 x 104 field, one to a cell of a grid: 320 at the start (1280 dots), 440 at a quarter, 560 at half, 680 at three quarters and 800 at the end (3200 dots), where the field is so crowded that the flow starts to drown in it.\n// Knob 4: Step. The size of the map, ε in T = exp(εA): 0.012 at 0, where the four dots of a chain fall within an LED or two of each other and the flow is hidden; 0.049 at 0.06, where a chain 30 LEDs from the fixed point is about 4 LEDs long; 0.10 at 0.25, long and loose; 0.14 at 0.5, where the chains come apart; 0.21 at 1, where partners land too far apart to pair and the field is noise again.\n// Buttons: K1 tap jumps A straight on to the next stop of the loop.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, sinh, cosh, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The strip: rows 0..21 hold the (τ, Δ) plane at 10 LEDs to a unit, τ = 0 on\n// column 32 and Δ = 0 on row 15. Row 22 is a faint rule; the dots live on\n// rows 24..127.\nconst IH = 22, FY = 24, FH = H - FY;\nconst SX = 10, OX = 32, OY = 15;\nconst toX = (tau) => OX + SX * tau, toY = (det) => OY - SX * det;\n// A's loop: an ellipse round the origin of the plane, τ = 2.6 sin φ and\n// Δ = 0.425 + 0.925 cos φ. It starts at the top, a pure rotation (τ = 0,\n// Δ = 1.35); passes through the spirals; meets the parabola at φs, where A is\n// a multiple of the identity, a star node; runs through the nodes into Δ \u003c 0;\n// stops at φ = π, a pure saddle; and comes back the other side with τ \u003c 0.\nconst TA = 2.6, D0 = 0.425, DB = 0.925;\n// Where the ellipse meets τ² = 4Δ: 1.69 sin² φ = 0.425 + 0.925 cos φ, a\n// quadratic in cos φ.\nconst PHS = (() => {\n  const a = (TA * TA) / 4, c = (-DB + sqrt(DB * DB + 4 * a * (a - D0))) / (2 * a);\n  return Math.acos(c);\n})();\nconst STOPS = [0, PHS, PI, 2 * PI - PHS, 2 * PI];\nconst SEG = 4; // seconds from stop to stop at Speed 2\n// Types, as the plane's regions: 0 saddle, 1 node, 2 spiral (3 the centre,\n// the positive Δ axis, which the loop only touches).\nconst typeOf = (tau, det) => (det \u003c 0 ? 0 : tau * tau - 4 * det >= -1e-9 ? 1 : abs(tau) \u003c 1e-6 ? 3 : 2);\n// Faint tints for the regions, and the brighter one for the region A is in.\nconst TINT = [[0.16, 0.03, 0.15], [0.17, 0.09, 0.0], [0.0, 0.1, 0.15], [0.0, 0.1, 0.15]];\nconst MARK = [[1, 0.35, 0.95], [1, 0.72, 0.2], [0.3, 0.9, 1], [0.3, 0.9, 1]];\n\n// Each inset LED: its region and how much of the axes or the parabola it holds.\nconst IREG = new Uint8Array(W * IH), ILINE = new Float32Array(W * IH), IAX = new Float32Array(W * IH), IPATH = new Float32Array(W * IH);\nfor (let y = 0; y \u003c IH; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const tau = (x + 0.5 - OX) / SX, det = (OY - (y + 0.5)) / SX, i = y * W + x;\n    IREG[i] = det \u003c 0 ? 0 : tau * tau > 4 * det ? 1 : 2;\n    // Distance to the parabola, in LEDs, from the gradient of Δ - τ²/4.\n    const f = det - (tau * tau) / 4, dp = (SX * abs(f)) / sqrt(1 + (tau * tau) / 4);\n    ILINE[i] = cl(1.1 - dp, 0, 1);\n    IAX[i] = y === OY || x === OX ? 1 : 0;\n  }\n// The loop's path, dotted every 3 LEDs of its length.\nfor (let k = 0, run = 0, px = toX(0), py = toY(D0 + DB); k \u003c= 720; k++) {\n  const ph = (k / 720) * 2 * PI, x = toX(TA * sin(ph)), y = toY(D0 + DB * cos(ph));\n  run += sqrt((x - px) ** 2 + (y - py) ** 2);\n  px = x;\n  py = y;\n  const ix = floor(x), iy = floor(y);\n  if (ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c IH && run % 3 \u003c 1.2) IPATH[iy * W + ix] = 1;\n}\n\nconst MAXD = 800, CH = 4, FLOW = 0.3;\nexport function setup(params) {\n  params.s = {\n    begun: false, t: 0, u: 0, hue: 0, speed: 2, n: 0, eps: 0.05,\n    // Each chain: its cell, its first dot (anywhere a little beyond the field), its age and its life.\n    cell: new Int32Array(MAXD), gx: 1, gy: 1,\n    ax: new Float32Array(MAXD), ay: new Float32Array(MAXD), age: new Float32Array(MAXD), life: new Float32Array(MAXD),\n    // A now (row by row), its trace and determinant on the loop, its type,\n    // the fixed point and the strain's axis.\n    A: new Float64Array(4), T1: new Float64Array(4), E: new Float64Array(4), s: 0, k2: 0, M: [0, 0, 0, 0], TP: new Float64Array(4 * 8),\n    tau: 0, det: 1, type: 3, cx: 32, cy: 76, psi: 0,\n    buf: new Float32Array(W * H * 3), col: new Float32Array(24),\n  };\n}\n\n// The first dots are dealt one to a cell of a grid laid over the field and a\n// margin of 5 LEDs round it, at a random place in the cell. Pure random dots\n// clump and leave holes, and on 64 columns the clumps read as structure of\n// their own; one to a cell keeps the only structure the one the map makes.\nconst MG = 5, AW = W + 2 * MG, AH = FH + 2 * MG;\nfunction layout(S, n) {\n  const gx = max(1, round(sqrt((n * AW) / AH))), gy = Math.ceil(n / gx);\n  S.gx = gx;\n  S.gy = gy;\n  // Which cells are used when n is short of gx * gy: a shuffle.\n  const all = Array.from({ length: gx * gy }, (_, i) => i);\n  for (let i = all.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = all[i];\n    all[i] = all[j];\n    all[j] = t;\n  }\n  for (let i = 0; i \u003c n; i++) S.cell[i] = all[i];\n  for (let i = 0; i \u003c n; i++) spawn(S, i), (S.age[i] = Math.random() * S.life[i]);\n}\nfunction spawn(S, i) {\n  const c = S.cell[i], cx = c % S.gx, cy = floor(c / S.gx);\n  S.ax[i] = -MG + ((cx + Math.random()) * AW) / S.gx;\n  S.ay[i] = FY - MG + ((cy + Math.random()) * AH) / S.gy;\n  S.life[i] = 0.9 + 0.9 * Math.random();\n  S.age[i] = 0;\n}\n\n// φ from the loop clock u (one unit a stop): each stop is held while the\n// smoothstep is flat, the first and last 12% of every leg.\nfunction phiOf(u) {\n  const i = floor(u) % 4, f = u - floor(u);\n  return STOPS[i] + (STOPS[i + 1] - STOPS[i]) * sm(0.12, 0.88, f);\n}\n\n// A from its trace and determinant, as the plainest matrix with them: a\n// dilation τ/2 plus a rotation w when τ² \u003c 4Δ, plus a strain e along the\n// axis ψ when τ² > 4Δ. Scaled to unit size (τ²/4 + w² + e² = 1), which\n// keeps its type: (τ, Δ) -> (cτ, c²Δ) leaves the axes and the parabola where\n// they are. exp(tA) comes in closed form, since the traceless part M has\n// M² = (e² - w²) I: cosh and sinh of t k for a node or saddle, cos and sin\n// for a spiral or centre.\nfunction expA(S, t, out) {\n  const k2 = S.k2, M = S.M;\n  let a, b;\n  if (k2 > 1e-12) {\n    const k = sqrt(k2);\n    a = cosh(t * k);\n    b = sinh(t * k) / k;\n  } else if (k2 \u003c -1e-12) {\n    const k = sqrt(-k2);\n    a = cos(t * k);\n    b = sin(t * k) / k;\n  } else {\n    a = 1;\n    b = t;\n  }\n  const g = exp(t * S.s);\n  out[0] = g * (a + b * M[0]);\n  out[1] = g * b * M[1];\n  out[2] = g * b * M[2];\n  out[3] = g * (a + b * M[3]);\n}\nfunction build(S) {\n  const tau = S.tau, det = S.det, disc = (tau * tau) / 4 - det;\n  let w = 0, e = 0;\n  if (disc \u003c 0) w = sqrt(-disc);\n  else e = sqrt(disc);\n  const m = sqrt((tau * tau) / 4 + w * w + e * e) || 1, s = tau / 2 / m;\n  w /= m;\n  e /= m;\n  const c2 = cos(2 * S.psi), s2 = sin(2 * S.psi);\n  // M = w J + e S(ψ), J the quarter turn, S(ψ) the reflection-like strain.\n  const M = [e * c2, e * s2 - w, e * s2 + w, -e * c2];\n  const A = S.A;\n  A[0] = s + M[0];\n  A[1] = M[1];\n  A[2] = M[2];\n  A[3] = s + M[3];\n  S.s = s;\n  S.k2 = e * e - w * w;\n  S.M = M;\n  expA(S, S.eps, S.T1);\n  const T1 = S.T1, TP = S.TP;\n  // TP holds T^k for k = 0 .. CH - 1.\n  TP[0] = TP[3] = 1;\n  TP[1] = TP[2] = 0;\n  for (let k = 1; k \u003c CH; k++) {\n    const o = 4 * k, q = o - 4;\n    TP[o] = T1[0] * TP[q] + T1[1] * TP[q + 2];\n    TP[o + 1] = T1[0] * TP[q + 1] + T1[1] * TP[q + 3];\n    TP[o + 2] = T1[2] * TP[q] + T1[3] * TP[q + 2];\n    TP[o + 3] = T1[2] * TP[q + 1] + T1[3] * TP[q + 3];\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 320, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = round(cl(kv[2], 320, MAXD));\n  S.eps = 0.012 + 0.2 * Math.pow(cl(kv[3], 0, 1), 0.6);\n  // A new count lays a new grid and deals every dot again.\n  if (!S.begun || n !== S.n) {\n    layout(S, n);\n    S.n = n;\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.u = (S.u + ds / SEG) % 4;\n  if (input.btnPressed && input.btnPressed[0]) S.u = (floor(S.u + 0.12) + 1) % 4;\n  const ph = phiOf(S.u);\n  S.tau = TA * sin(ph);\n  S.det = D0 + DB * cos(ph);\n  S.type = typeOf(S.tau, S.det);\n  // The fixed point wanders over the middle of the field, and the strain's\n  // axis turns slowly, so the nodes and the saddle do not always line up\n  // with the LED grid.\n  S.cx = 32 + 7 * sin(0.21 * S.t + 0.4);\n  S.cy = FY + FH / 2 + 14 * sin(0.13 * S.t + 1.1);\n  S.psi = 0.5 * sin(0.07 * S.t);\n  build(S);\n  // The dynamic Glass pattern: dots die and are dealt again somewhere new,\n  // so the texture never holds still while the flow it shows stays put.\n  // The dots also ride the flow itself, at FLOW times the field's speed, so\n  // the circles turn, the rays stream and the saddle pours in along one axis\n  // and out along the other.\n  expA(S, FLOW * ds, S.E);\n  const E = S.E, cx = S.cx, cy = S.cy;\n  for (let i = 0; i \u003c S.n; i++) {\n    const rx = S.ax[i] - cx, ry = S.ay[i] - cy;\n    S.ax[i] = cx + E[0] * rx + E[1] * ry;\n    S.ay[i] = cy + E[2] * rx + E[3] * ry;\n    S.age[i] += ds;\n    if (S.age[i] >= S.life[i]) spawn(S, i);\n  }\n}\n\nfunction addDot(buf, x, y, c, o, v) {\n  const ix = floor(x), iy = floor(y);\n  if (ix \u003c 0 || ix >= W || iy \u003c FY || iy >= H) return;\n  const p = (iy * W + ix) * 3;\n  buf[p] += c[o] * v;\n  buf[p + 1] += c[o + 1] * v;\n  buf[p + 2] += c[o + 2] * v;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, C = S.col, TP = S.TP;\n  buf.fill(0);\n  // Tail to head of each chain: the head leads, so the brightness says which\n  // way the flow runs.\n  const h0 = 0.5 + S.hue;\n  for (let k = 0; k \u003c CH; k++) {\n    const u = k / (CH - 1);\n    hsv(h0 + 0.27 * (1 - u), 0.9 - 0.3 * u, 0.65 + 0.35 * u, C, 3 * k);\n  }\n  const cx = S.cx, cy = S.cy;\n  for (let i = 0; i \u003c S.n; i++) {\n    const a = S.age[i], l = S.life[i];\n    // Fade in over 0.12 s and out over 0.2 s in three steps, so a chain comes and goes softly.\n    const f = min(1, a / 0.12, (l - a) / 0.2), v = f > 0.66 ? 1 : f > 0.33 ? 0.6 : 0.3;\n    const rx = S.ax[i] - cx, ry = S.ay[i] - cy;\n    for (let k = 0, o = 0; k \u003c CH; k++, o += 4) addDot(buf, cx + TP[o] * rx + TP[o + 1] * ry, cy + TP[o + 2] * rx + TP[o + 3] * ry, C, 3 * k, v);\n  }\n  // The strip: tinted regions, the one A is in lit more, axes, the parabola,\n  // the loop dotted, and A as a bright dot with a cross in its region's colour.\n  const reg = S.type === 3 ? 2 : S.type, mk = MARK[S.type];\n  for (let y = 0; y \u003c IH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, tn = TINT[IREG[i]], k = IREG[i] === reg ? 1.6 : 0.8;\n      let R = tn[0] * k, G = tn[1] * k, B = tn[2] * k;\n      if (IPATH[i]) (R += 0.12), (G += 0.12), (B += 0.12);\n      if (IAX[i]) (R = max(R, 0.24)), (G = max(G, 0.24)), (B = max(B, 0.3));\n      const pl = ILINE[i] * 0.55;\n      R = max(R, pl);\n      G = max(G, pl * 0.9);\n      B = max(B, pl * 0.6);\n      const p = i * 3;\n      buf[p] = R;\n      buf[p + 1] = G;\n      buf[p + 2] = B;\n    }\n  const mx = floor(toX(S.tau)), my = floor(toY(S.det));\n  for (const [dx, dy, v] of [[0, 0, 2], [1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1]]) {\n    const x = mx + dx, y = my + dy;\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= IH) continue;\n    const p = (y * W + x) * 3;\n    if (v === 2) buf[p] = buf[p + 1] = buf[p + 2] = 1;\n    else (buf[p] = mk[0]), (buf[p + 1] = mk[1]), (buf[p + 2] = mk[2]);\n  }\n  // The rule under the strip, in the colour of A's region.\n  for (let x = 0; x \u003c W; x++) {\n    const p = (IH * W + x) * 3;\n    buf[p] = mk[0] * 0.22;\n    buf[p + 1] = mk[1] * 0.22;\n    buf[p + 2] = mk[2] * 0.22;\n  }\n  for (let p = 0, q = 0; p \u003c W * H; p++, q += 3)\n    display.setPixel(p % W, floor(p / W), round(255 * min(1, buf[q])), round(255 * min(1, buf[q + 1])), round(255 * min(1, buf[q + 2])));\n}\n","howling-wolf":"// ===== Patternflow pattern =====\n// Title:   Howling Wolf\n// Family:  halloween\n// Idea:    A black wolf on a rocky crag before a huge rising moon, orange at its foot and pale gold above, lifts its muzzle and howls, throat swelling, breath puffing off on the wind and faint toxic green rings spreading from its jaws, and the small wolves on the far ridge answer one after another in a green glow, while clouds drift, a dead tree bends and the wolf breathes, flicks its ears and sways its tail.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pack=2..6, Wind=0..1\n//\n// Knob 1: Hue. The moon, its glow and the rims of light: at 0 orange rising to pale gold, at 0.25 green to mint, at 0.5 azure to ice, at 0.75 magenta to pink. Rings and glow stay toxic green.\n// Knob 2: Speed. At 2 the wolf raises its head in 0.9 s, howls 3.6 s with a ring every 0.3 s, lowers it in 1 s and howls again 3.2 to 4.8 s after the pack falls quiet; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Pack. How many far wolves answer: 2 at the start, then 3, 4, 5 and 6, four against the moon. The first comes in 1.2 s into the howl at 2 and 0.4 s at 6, the rest every 1.1 s or 0.3 s, each howling 3.3 s in a green glow with rings.\n// Knob 4: Wind. At 0 two thin clouds drift 2.5 LEDs a second and the tree barely stirs; at 0.06 they drift at 3; at 0.5 five thicker clouds at 6.8, the tree leaning; at 1 eight heavy clouds at 11, the tree bent hard.\n// Buttons: K1 tap makes the wolf howl at once (and the pack answer) unless it already is.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  for (let i = 0; i \u003c 3; i++) {\n    const k = (5 - 2 * i + 6 * (h - floor(h))) % 6;\n    out[i] = v - v * s * max(0, min(k, 4 - k, 1));\n  }\n}\n// Channels in steps of 4 of 255: no banding on the panel, flat areas stay flat.\nconst q4 = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\n// Signed distances in LEDs, negative inside, and a smooth union.\nconst circle = (px, py, cx, cy, r) => sqrt((px - cx) ** 2 + (py - cy) ** 2) - r;\nfunction capsule(px, py, ax, ay, bx, by, ra, rb) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey || 1), 0, 1);\n  return sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) - (ra + (rb - ra) * u);\n}\nconst smin = (a, b, k) => {\n  const h = cl(0.5 + (0.5 * (b - a)) / k, 0, 1);\n  return b + (a - b) * h - k * h * (1 - h);\n};\n// Blend a colour into buf at LED p by a.\nfunction mix(buf, p, r, g, b, a) {\n  const q = 3 * p;\n  buf[q] += (r - buf[q]) * a;\n  buf[q + 1] += (g - buf[q + 1]) * a;\n  buf[q + 2] += (b - buf[q + 2]) * a;\n}\n// A black silhouette covering LED p by a, with a rim of the moon's colour mc.\nconst black = (buf, mc, p, a, rim) => mix(buf, p, 0.012 + mc[3 * p] * rim, 0.008 + mc[3 * p + 1] * rim, 0.02 + mc[3 * p + 2] * rim, a);\n\n// The moon low on the horizon, its seas, its glow, and per row its blend\n// from orange at the foot (0) to gold near the top (1).\nconst MX = 33, MY = 55, MR = 26;\nconst SEAS = [[-8, -8, 6, 5], [7, -11, 5, 4], [10, 3, 6, 6], [-11, 6, 5, 6], [1, 12, 6, 4], [-3, -1, 3, 3]];\nconst MOONT = new Float32Array(N), GLOW = new Float32Array(N), MROW = new Float32Array(H);\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR + 1) {\n    let e = 9;\n    for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 + 0.25 * sin(dx + dy));\n    MOONT[p] = (e \u003c 1 ? 0.86 : e \u003c 1.6 ? 0.93 : 1) * cl(MR + 0.5 - r, 0, 1);\n  }\n  const out = max(0, r - MR);\n  GLOW[p] = round((0.3 * exp(-out / 4) + 0.1 * exp(-out / 14)) * 16) / 16;\n}\nfor (let y = 0; y \u003c H; y++) MROW[y] = sm(MY + MR, MY - MR * 0.6, y + 0.5);\n// Stars: [LED, twinkle phase], clear of the moon.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 22; i++) {\n  const x = floor(hash(i * 3 + 1) * W), y = floor(2 + hash(i * 3 + 2) * 62);\n  if ((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2 > (MR + 5) ** 2) STARS.push([y * W + x, hash(i * 3 + 3) * 6.28]);\n}\n\n// Three far ridges as the row of their crest in each column, the far one\n// across the moon's foot; the wolf's crag ends in a cliff at x = 42.\nconst R = [new Float32Array(W), new Float32Array(W), new Float32Array(W)], CRAG = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) {\n  R[0][x] = 79.5 + 3 * sm(44, 64, x) - 2 * sm(12, 0, x) + 1.1 * sin(x * 0.45) + 0.6 * sin(x * 1.3 + 2);\n  R[1][x] = 94 - 3 * sm(46, 64, x) + 1.4 * sin(x * 0.55 + 1) + 0.6 * sin(x * 1.6);\n  R[2][x] = 110 - 2 * sm(44, 64, x) + 1.6 * sin(x * 0.4 + 2) + 0.6 * sin(x * 1.4);\n  CRAG[x] = x \u003c 42 ? 104 - 1.1 * sin(x * 0.7) - 0.7 * sin(x * 1.9 + 1) - 2.5 * sm(10, 0, x) : 104 + (x - 42) * 3.2 + 1.4 * sin(x * 2.1);\n}\nconst RC = [[0.17, 0.062, 0.25], [0.095, 0.034, 0.15], [0.05, 0.018, 0.085]], ROCK = [0.012, 0.008, 0.022];\n// The ridge in front at each LED (-1 none), and the crag (2 on its top).\nconst RIDX = new Int8Array(N).fill(-1), CRG = new Uint8Array(N);\nfor (let p = 0; p \u003c N; p++) {\n  const x = p % W, py = floor(p / W) + 0.5;\n  for (let i = 0; i \u003c 3; i++) if (py > R[i][x]) RIDX[p] = i;\n  if (py > CRAG[x]) CRG[p] = py - CRAG[x] \u003c 1.2 ? 2 : 1;\n}\n\n// The far wolves, [x of their feet, ridge], in the order they answer, a\n// shade darker than their ridge, facing left.\nconst PACK = [[26, 0], [57, 0], [49, 0], [17, 0], [56, 1], [8, 0]];\nconst FC = [[0.075, 0.026, 0.12], [0.035, 0.012, 0.06]];\n// A far wolf facing right, standing and howling.\nconst FAR = [\n  [\".........\", \".........\", \"......#..\", \".....####\", \".######..\", \"#######..\", \"##.#..##.\", \".#.#...#.\"],\n  [\".......#.\", \"......##.\", \".....##..\", \"....###..\", \".#####...\", \"#######..\", \"##.#..##.\", \".#.#...#.\"],\n];\n// The glow round a howling far wolf: offsets within 5 LEDs, with weights.\nconst KERN = [];\nfor (let dy = -5; dy \u003c= 5; dy++) for (let dx = -5; dx \u003c= 5; dx++) if (dx * dx + dy * dy \u003c= 26) KERN.push([dx, dy, exp(-sqrt(dx * dx + dy * dy) / 2.2)]);\n\n// The dead tree as branches [parent, length, angle from the parent\n// (clockwise from up), base and tip radius].\nconst TREE = [\n  [-1, 13, 0.06, 2.2, 1.6], [0, 11, -0.1, 1.6, 1.1], [1, 9, 0.3, 1.1, 0.75], [2, 7, 0.35, 0.75, 0.5],\n  [1, 7, -0.7, 0.9, 0.55], [4, 5, -0.35, 0.55, 0.4], [0, 9, 0.95, 1.0, 0.55], [6, 6, 0.45, 0.55, 0.4],\n  [2, 6, -0.6, 0.65, 0.4], [3, 5, 0.95, 0.5, 0.35], [6, 4, -0.5, 0.5, 0.35], [7, 4, 0.7, 0.4, 0.3],\n];\nconst TREEX = 4, TREEY = 104;\n// Clouds: [row, length, where on its lap it starts].\nconst CLOUDS = [[66, 30, 0.47], [40, 26, 0.3], [52, 34, 0.85], [28, 24, 0.62], [72, 28, 0.12], [46, 36, 0.05], [60, 30, 0.7], [34, 28, 0.95]];\nconst CST = new Float64Array(15), RING = [1, 0.45, 0.2];\n\n// The wolf is laid out with paws on row 101 and drawn at 0.8 size, (30, 101) on (26, 104).\nconst SC = 0.8, AX = 30, AY = 101, WX = 26, WY = 104;\nconst L1 = 0.9, L2 = 3.6, L3 = 1.0, F1 = 0.3, F2 = 2.6, F3 = 0.4;\n// How far a head is up at age a of a howl: up in u s, held h s, down in w s.\nconst env = (a, u, h, w) => (a \u003c 0 ? 0 : sm(0, u, a) - sm(u + h, u + h + w, a));\nconst farLift = (a) => env(a, F1, F2, F3);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, pack: 2, wind: 0.06, cloudX: 0,\n    // The howl's age (-1 none), the wait for the next, ring and breath clocks.\n    howl: -1, wait: 0.05, ring: 0, puff: 0, lift: 0,\n    // Each far wolf: wait, howl age (-1 none), ring clock, first ring still to go.\n    fs: new Float32Array(6).fill(-1), fh: new Float32Array(6).fill(-1), fr: new Float32Array(6), fc: new Uint8Array(6),\n    rings: [], vap: [], earAge: [9, 9], earWait: [2.2, 3.6],\n    buf: new Float32Array(N * 3), bg: new Float32Array(N * 3), mc: new Float32Array(N * 3), bgHue: -1,\n    sil: new Float32Array(N), wd: new Float32Array(N), glow: new Float32Array(N), tree: new Float32Array(N),\n    moon: [0, 0, 0], gold: [0, 0, 0], tb: [0, 0, 0, 0], tail: new Float32Array(20), seg: new Float32Array(TREE.length * 6),\n  };\n}\n\n// The head: centre and muzzle angle (0 level, negative up).\nconst headPose = (S, l = S.lift) => ({ hx: 46.5 - 1.2 * l, hy: 76 - 4.5 * l, a: 0.2 - 1.32 * l });\n\n// A ring: place, heading, half width, speed, strength, reach, depth, pack's.\nconst ring = (x, y, a, w, v, s, lim, rows, far) => ({ x, y, r: 1.5, a, w, v, s, lim, rows, far });\n\nfunction startHowl(S) {\n  S.howl = 0;\n  S.ring = 0.05;\n  S.puff = 0;\n  // A bigger pack comes in sooner and closer together.\n  for (let k = 0; k \u003c 6; k++) (S.fs[k] = 1.6 - 0.2 * S.pack + (2.4 / S.pack - 0.1) * k + 0.1 * Math.random()), (S.fh[k] = -1);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.pack = round(cl(kv[2], 2, 6));\n  S.wind = cl(kv[3], 0, 1);\n  const ds = (d * S.speed) / 2, wv = 2.5 + 8.5 * S.wind;\n  S.t += ds;\n  S.cloudX += ds * wv;\n  if (input.btnPressed && input.btnPressed[0] && S.howl \u003c 0) startHowl(S);\n  if (S.howl >= 0) {\n    S.howl += ds;\n    // Rings and breath leave the nose tip while it holds the note.\n    const hp = headPose(S), ca = cos(hp.a), sa = sin(hp.a);\n    const nx = WX + (hp.hx + 9.8 * ca - 0.5 * sa - AX) * SC, ny = WY + (hp.hy + 9.8 * sa + 0.5 * ca - AY) * SC;\n    if (S.howl > L1 && S.howl \u003c L1 + L2) {\n      if ((S.ring -= ds) \u003c= 0) (S.ring += 0.3), S.rings.push(ring(nx, ny, hp.a, 1.45, 18, 0.9, 62, 3, 0));\n      if ((S.puff -= ds) \u003c= 0) (S.puff += 0.22), S.vap.push({ x: nx, y: ny, vx: 5 * ca, vy: 5 * sa, age: 0, life: 1.5 + 0.6 * Math.random() });\n    }\n    if (S.howl > L1 + L2 + L3) (S.howl = -1), (S.wait = 1e9);\n  }\n  // The pack, counted from the start of the main howl.\n  let busy = false;\n  for (let k = 0; k \u003c 6; k++) {\n    if (k >= S.pack) S.fs[k] = S.fh[k] = -1;\n    if (S.fs[k] >= 0 && (busy = true) && (S.fs[k] -= ds) \u003c 0) (S.fh[k] = 0), (S.fr[k] = 0), (S.fc[k] = 1);\n    if (S.fh[k] \u003c 0) continue;\n    busy = true;\n    S.fh[k] += ds;\n    if (S.fh[k] > F1 && S.fh[k] \u003c F1 + F2 && (S.fr[k] -= ds) \u003c= 0) {\n      S.fr[k] += 0.45;\n      const [fx, ridge] = PACK[k], x = fx - 3.5, y = round(R[ridge][fx]) - 6.5;\n      S.rings.push(ring(x, y, -1.92, 1.5, 10, 0.85, 28, 2, 1));\n      // The first note of each answer carries: one wide, faint ring.\n      if (S.fc[k]) S.rings.push(ring(x, y, -1.77, 1.6, 24, 0.55, 64, 2, 1)), (S.fc[k] = 0);\n    }\n    if (S.fh[k] > F1 + F2 + F3) S.fh[k] = -1;\n  }\n  // The next howl 3.2 to 4.8 s after the pack has done.\n  if (S.howl \u003c 0 && !busy) {\n    if (S.wait > 100) S.wait = 3.2 + 1.6 * Math.random();\n    if ((S.wait -= ds) \u003c= 0) startHowl(S);\n  }\n  S.lift = env(S.howl, L1, L2, L3);\n  // Rings spread; breath drifts off on the wind, rising.\n  for (const r of S.rings) r.r += r.v * ds;\n  S.rings = S.rings.filter((r) => r.r \u003c r.lim);\n  for (const v of S.vap) {\n    const e = min(1, ds * 1.5);\n    v.age += ds;\n    v.x += (v.vx += (wv * 0.9 - v.vx) * e) * ds;\n    v.y += (v.vy += (-1.6 - v.vy) * e) * ds;\n  }\n  S.vap = S.vap.filter((v) => v.age \u003c v.life);\n  for (let i = 0; i \u003c 2; i++) {\n    S.earAge[i] += ds;\n    if ((S.earWait[i] -= ds) \u003c= 0) (S.earAge[i] = 0), (S.earWait[i] = 1.8 + 3.5 * Math.random());\n  }\n}\n\n// The tail's joints: it hangs, sways and lifts a little in the howl; tb boxes it.\nfunction tailPose(S) {\n  const T = S.tail, tb = S.tb, t = S.t;\n  let x = 19.4, y = 81.5, a = 2.0 - 0.25 * S.lift;\n  const sw = 0.16 * sin(t * ((2 * PI) / 3.4)), w = 0.07 * sin(t * ((2 * PI) / 1.7) + 1);\n  tb[0] = tb[1] = 1e9;\n  tb[2] = tb[3] = -1e9;\n  for (let i = 0; i \u003c= 9; i++) {\n    T[2 * i] = x;\n    T[2 * i + 1] = y;\n    (tb[0] = min(tb[0], x - 5)), (tb[1] = min(tb[1], y - 5)), (tb[2] = max(tb[2], x + 5)), (tb[3] = max(tb[3], y + 5));\n    a += 0.07 + sw * (0.4 + i / 9) * 0.5 + (w * i) / 9;\n    x += cos(a) * 1.75;\n    y += sin(a) * 1.75;\n  }\n}\nconst tailR = (u) => 1.3 + 2.1 * sin(PI * min(1, u * 1.1) ** 0.8) * (0.55 + 0.45 * u);\n\n// Legs [from, to, radii, blend (0 plain)]: front near and far (forearm, cannon,\n// paw), hind near and far (thigh, shin back to the hock, foot, paw).\nconst LEGS = [\n  [[39.6, 87, 40.4, 95, 2.6, 1.6, 1.5], [40.4, 95, 40.8, 100.2, 1.5, 1.25, 0], [40.6, 100.3, 43, 100.5, 1.1, 1, 0],\n    [35.8, 88, 35.6, 95, 2.1, 1.3, 1], [35.6, 95, 35.4, 100.2, 1.25, 1.1, 0], [35.2, 100.3, 37.4, 100.5, 1, 0.95, 0]],\n  [[23.5, 84, 26, 91.5, 4.8, 2.4, 1.5], [26, 91.5, 21.6, 96.2, 2, 1.4, 0.8], [21.6, 96.2, 22.4, 100.2, 1.3, 1.15, 0], [22.2, 100.3, 24.6, 100.5, 1.05, 1, 0],\n    [27.5, 85.5, 29.5, 91.5, 3.2, 1.8, 1], [29.5, 91.5, 25.8, 96.2, 1.6, 1.2, 0.6], [25.8, 96.2, 26.4, 100.2, 1.15, 1.05, 0], [26.2, 100.3, 28.4, 100.5, 0.95, 0.9, 0]],\n];\n// The wolf, facing right; info gets the head's frame (u along the muzzle, v down) for the eye.\nfunction wolfDist(S, px, py, hp, info) {\n  const l = S.lift, br = sin(S.t * ((2 * PI) / 2.8)) * (1 - l);\n  // Body: the chest rises and falls with the breath.\n  let d = capsule(px, py, 24, 83.5, 37, 82.8 - 0.2 * br, 5, 6.2);\n  d = smin(d, circle(px, py, 39, 85 - 0.3 * br, 6.2 + 0.3 * br), 2.5);\n  d = smin(d, circle(px, py, 22.5, 83, 5), 1.5);\n  // Legs, below row 78: the front pair right of column 33, the hind pair left.\n  if (py > 78)\n    for (const [ax, ay, bx, by, ra, rb, k] of LEGS[px > 33 ? 0 : 1]) {\n      const c = capsule(px, py, ax, ay, bx, by, ra, rb);\n      d = k ? smin(d, c, k) : min(d, c);\n    }\n  // The tail, a bushy chain from the rump.\n  const T = S.tail, tb = S.tb;\n  if (px > tb[0] && px \u003c tb[2] && py > tb[1] && py \u003c tb[3])\n    for (let i = 0; i \u003c 9; i++) d = smin(d, capsule(px, py, T[2 * i], T[2 * i + 1], T[2 * i + 2], T[2 * i + 3], tailR(i / 9), tailR((i + 1) / 9)), 1.2);\n  // Neck and throat; the throat swells while it howls.\n  const ca = cos(hp.a), sa = sin(hp.a), hx = hp.hx, hy = hp.hy, sw = l > 0.9 ? 0.8 + 0.4 * sin(S.howl * 9) : l * 0.8;\n  d = smin(d, capsule(px, py, 37, 81.5, hx - 0.5 * ca, hy - 0.5 * sa, 5.2, 4), 2);\n  d = smin(d, capsule(px, py, 41.5, 87, hx + 1.2 * ca - 3.2 * sa, hy + 1.2 * sa + 3.2 * ca, 3.2 + 0.4 * sw, 2.2 + 1.1 * sw), 2);\n  // The ruff down the front of the neck, a row of tufts.\n  if (d \u003c 2.5 && d > -2.5 && px > 36 && py \u003c 90 && px \u003c hx + 4) d -= 0.7 * max(0, 1 - 2.6 * abs((((px + py * 0.6) / 2.3) % 1) - 0.5));\n  // The head in its own frame: skull, cheek, muzzle.\n  const qx = px - hx, qy = py - hy, u = qx * ca + qy * sa, v = -qx * sa + qy * ca;\n  info.u = u;\n  info.v = v;\n  if (u > 14 || u \u003c -10 || v > 9 || v \u003c -12) return d;\n  let dh = smin(circle(u, v, 0, 0, 4.2), circle(u, v, 1.8, 1.5, 3.2), 1.5);\n  dh = smin(dh, capsule(u, v, 2.5, -0.5, 9.4, 0.8, 2.3, 1.2), 1.2);\n  // The lower jaw drops while it howls, opening the mouth.\n  const jw = 0.32 * sm(L1, L1 + 0.3, S.howl) * (S.howl \u003c L1 + L2 ? 1 : 1 - sm(L1 + L2, L1 + L2 + 0.4, S.howl));\n  const jc = cos(jw), js = sin(jw);\n  dh = smin(dh, capsule(2.5 + (u - 2.5) * jc + (v - 2.2) * js, 2.2 - (u - 2.5) * js + (v - 2.2) * jc, 2.5, 2.2, 8.4, 2.4, 1.5, 0.8), 0.8);\n  // Ears, the far one behind: laid back in the howl, each flicking now and then.\n  for (let i = 0; i \u003c 2; i++) {\n    const ag = S.earAge[i], back = 0.3 * l + (ag \u003c 0.25 ? 0.45 * sin((PI * ag) / 0.25) : 0) + (i ? 0 : 0.15);\n    const bx = i ? -0.2 : -2.5, by = i ? -3.6 : -3.3, ec = cos(back), es = sin(back);\n    dh = min(dh, capsule(bx + (u - bx) * ec + (v - by) * es, by - (u - bx) * es + (v - by) * ec, bx + 0.2, by + 0.3, bx - 0.2, by - 4.8, 1.7, 0.15));\n  }\n  return min(d, dh);\n}\n\n// The tree's branches: a lean in the wind plus gusts, more the higher the branch.\nfunction treePose(S) {\n  const seg = S.seg, t = S.t, wind = S.wind, lean = (0.03 + 0.3 * wind) * (0.4 + 0.6 * (0.5 + 0.5 * sin(t * 1.3) * sin(t * 0.47 + 1)));\n  for (let i = 0; i \u003c TREE.length; i++) {\n    const [par, len, ang] = TREE[i], o = par * 6;\n    const x0 = par \u003c 0 ? TREEX : seg[o + 2], y0 = par \u003c 0 ? TREEY : seg[o + 3], depth = par \u003c 0 ? 0 : seg[o + 5] + 1;\n    const a = (par \u003c 0 ? 0 : seg[o + 4]) + ang + lean * (0.5 + depth * 0.5) + 0.03 * (1 + 2 * wind) * sin(t * 2.3 + i * 1.7) * depth;\n    seg.set([x0, y0, x0 + sin(a) * len, y0 - cos(a) * len, a, depth], i * 6);\n  }\n}\n\n// Sky, moon, ridges and crag, kept until Hue moves; mc is the moon's colour\n// at each LED, for the rims of light.\nfunction background(S) {\n  const bg = S.bg, mc = S.mc, M = S.moon, G = S.gold;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), k = MROW[y], gl = GLOW[p], mt = MOONT[p];\n    const mr = M[0] + (G[0] - M[0]) * k, mg = M[1] + (G[1] - M[1]) * k, mb = M[2] + (G[2] - M[2]) * k;\n    mc.set([mr, mg, mb], 3 * p);\n    // The sky in ten steps, near black at the top and purple at the horizon.\n    const t = round(10 * sm(0, 86, y)) / 10;\n    let r = 0.025 + 0.2 * t + mr * gl * 0.8, g = 0.01 + 0.055 * t + mg * gl * 0.8, b = 0.06 + 0.24 * t + mb * gl * 0.8;\n    r += (mr * mt - r) * mt;\n    g += (mg * mt - g) * mt;\n    b += (mb * mt - b) * mt;\n    if (RIDX[p] >= 0) [r, g, b] = RC[RIDX[p]];\n    if (CRG[p]) {\n      // Black rock: moonlit top and cliff edges, faint slanting ledges.\n      const top = CRG[p] === 2, ledge = !top && (x * 0.45 + y + 3 * hash(floor(x / 6))) % 9 \u003c 1;\n      const lit = top ? 0.22 : x >= 41 && !CRG[p - 1] ? 0.14 : ledge ? 0.05 : 0, f = top || ledge ? 1 : 0;\n      [r, g, b] = [ROCK[0] + 0.03 * f + mr * lit, ROCK[1] + 0.012 * f + mg * lit * 0.7, ROCK[2] + 0.04 * f + mb * lit * 0.4];\n    }\n    bg.set([r, g, b], 3 * p);\n  }\n}\n\n// Rings of sound: arcs about the muzzle's line, fading as they spread and\n// toward their ends, mixed towards toxic green (not added) so they show on\n// the moon too. far picks the pack's rings or the wolf's own.\nfunction rings(S, buf, far) {\n  for (const rg of S.rings) {\n    if (rg.far !== far) continue;\n    const fade = (1 - rg.r / rg.lim) * rg.s, steps = max(6, round(rg.r * rg.w * 1.6));\n    for (let j = 0; j \u003c rg.rows; j++) {\n      const rr = rg.r - j;\n      if (rr \u003c 0.5) continue;\n      for (let i = -steps; i \u003c= steps; i++) {\n        const u = i / steps, a = rg.a + u * rg.w, ix = floor(rg.x + rr * cos(a)), iy = floor(rg.y + rr * sin(a));\n        if (ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c H) mix(buf, iy * W + ix, 0.3, 0.95, 0.22, fade * (1 - u * u) * 0.7 * RING[j]);\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, sil = S.sil, wd = S.wd, mc = S.mc, glow = S.glow, tree = S.tree, wind = S.wind;\n  if (S.bgHue !== S.hue) {\n    // The moon: orange at its foot, pale gold at the top.\n    hsv(0.07 + S.hue, 0.85, 1, S.moon);\n    hsv(0.12 + S.hue, 0.42, 1, S.gold);\n    background(S);\n    S.bgHue = S.hue;\n  }\n  buf.set(S.bg);\n  for (const [p, ph] of STARS) {\n    const v = 0.22 + 0.22 * sin(S.t * 2.4 + ph), q = 3 * p;\n    buf[q] = max(buf[q], v);\n    buf[q + 1] = max(buf[q + 1], v);\n    buf[q + 2] = max(buf[q + 2], v * 1.15);\n  }\n  // Clouds: two or three ragged strands each, slowly boiling, purple, their\n  // edges lit where the moon is behind.\n  const nc = 2 + round(6 * wind), thick = 1.05 + 1.1 * wind, st = CST;\n  for (let i = 0; i \u003c nc; i++) {\n    const [cy0, len0, ph] = CLOUDS[i], len = len0 * (0.85 + 0.8 * wind), span = W + len + 20;\n    const x0 = ((S.cloudX * (0.85 + 0.3 * hash(i + 40)) + ph * span) % span) - len - 15, cy = cy0 + 1.5 * sin(S.t * 0.2 + i), ns = 2 + (i % 2);\n    for (let j = 0; j \u003c ns; j++) {\n      const h1 = hash(i * 17 + j), h3 = hash(i * 17 + j + 11);\n      st.set([x0 + (h1 - 0.3) * len * 0.35, len * (0.55 + 0.45 * hash(i * 17 + j + 5)), cy + j * 2.8 - 2 + h3, thick * (1.1 + 1.5 * h3), h1 * 6.28], 5 * j);\n    }\n    for (let y = max(0, floor(cy - 14)); y \u003c min(90, cy + 14); y++)\n      for (let x = max(0, floor(x0 - 10)); x \u003c min(W, x0 + len * 1.3); x++) {\n        const p = y * W + x;\n        if (RIDX[p] >= 0) continue;\n        const px = x + 0.5, py = y + 0.5, lx = px - x0;\n        let dc = 1e9;\n        for (let o = 0; o \u003c 5 * ns; o += 5) {\n          const u = (px - st[o]) / st[o + 1], sd = st[o + 4], dy = abs(py - st[o + 2]);\n          if (u \u003c= 0 || u >= 1 || dy - st[o + 3] > 1) continue;\n          dc = min(dc, dy - st[o + 3] * sin(PI * u) ** 0.6 * (0.75 + 0.2 * sin(lx * 0.8 + sd) + 0.15 * sin(lx * 1.9 + 2 * sd + S.t * 0.9)));\n        }\n        const cov = cl(0.5 - dc, 0, 1);\n        if (cov \u003c= 0) continue;\n        const near = min(1, GLOW[p] * 1.5 + MOONT[p]), rim = dc > -1 ? near * 0.4 : 0;\n        mix(buf, p, 0.13 + 0.07 * near + mc[3 * p] * rim, 0.045 + 0.03 * near + mc[3 * p + 1] * rim * 0.8, 0.2 + 0.07 * near + mc[3 * p + 2] * rim * 0.6, cov * 0.92);\n      }\n  }\n  // The far wolves, a green glow kindling round each one that howls.\n  glow.fill(0);\n  const fw = [];\n  for (let k = 0; k \u003c S.pack; k++) {\n    const g = 0.6 * farLift(S.fh[k]), [fx, ridge] = PACK[k], top = round(R[ridge][fx]) - 7, bm = FAR[g > 0.3 ? 1 : 0];\n    for (let q = 0; q \u003c 72; q++) {\n      const x = fx + 3 - (q % 9), y = top + floor(q / 9);\n      if (bm[floor(q / 9)][q % 9] !== \"#\" || x \u003c 0 || x >= W) continue;\n      fw.push([y * W + x, ridge]);\n      if (g > 0.01) for (const [dx, dy, w] of KERN) if (x + dx >= 0 && x + dx \u003c W) glow[(y + dy) * W + x + dx] = max(glow[(y + dy) * W + x + dx], g * w);\n    }\n  }\n  for (let p = 60 * W; p \u003c 100 * W; p++) if (glow[p] > 0) mix(buf, p, 0.3, 0.95, 0.22, glow[p]);\n  for (const [p, ridge] of fw) buf.set(FC[ridge], 3 * p);\n  // Their rings go behind the tree and the wolf.\n  rings(S, buf, 1);\n  // The tree, black with moonlight on its upper edges.\n  tailPose(S);\n  treePose(S);\n  const seg = S.seg;\n  tree.fill(0);\n  for (let i = 0; i \u003c TREE.length; i++) {\n    const [x0, y0, x1, y1] = seg.subarray(i * 6, i * 6 + 4), [, , , r0, r1] = TREE[i];\n    for (let y = max(0, floor(min(y0, y1) - r0 - 1)); y \u003c= floor(max(y0, y1) + r0 + 1); y++)\n      for (let x = max(0, floor(min(x0, x1) - r0 - 1)); x \u003c= floor(max(x0, x1) + r0 + 1); x++)\n        tree[y * W + x] = max(tree[y * W + x], cl(0.5 - capsule(x + 0.5, y + 0.5, x0, y0, x1, y1, r0, r1), 0, 1));\n  }\n  for (let p = 30 * W; p \u003c 105 * W; p++) {\n    const tc = tree[p], rim = tc \u003c 0.99 || tree[p - W] \u003c 0.5 ? 0.45 * (1 - MOONT[p]) * min(1, GLOW[p] * 2 + 0.3) : 0;\n    if (tc > 0) black(buf, mc, p, tc, rim);\n  }\n  // The wolf: blocks of 4 x 4 clear of it or deep inside are settled at\n  // once; only edge blocks and the eye's are worked out LED by LED.\n  const hp = headPose(S), info = { u: 0, v: 0 }, eyeOpen = 1 - sm(0.15, 0.5, S.lift);\n  const eyeX = WX + (hp.hx + 1.3 * cos(hp.a) + 0.9 * sin(hp.a) - AX) * SC, eyeY = WY + (hp.hy + 1.3 * sin(hp.a) - 0.9 * cos(hp.a) - AY) * SC;\n  const lx = (x) => AX + (x - WX) / SC, ly = (y) => AY + (y - WY) / SC;\n  sil.fill(0);\n  wd.fill(9);\n  for (let by = 64; by \u003c 108; by += 4)\n    for (let bx = 4; bx \u003c 52; bx += 4) {\n      const dc = wolfDist(S, lx(bx + 2), ly(by + 2), hp, info) * SC, nearEye = abs(bx + 2 - eyeX) \u003c 5 && abs(by + 2 - eyeY) \u003c 5;\n      if (dc > 5 && !nearEye) continue;\n      for (let y = by; y \u003c by + 4; y++)\n        for (let x = bx; x \u003c bx + 4; x++) {\n          const p = y * W + x;\n          const dd = dc \u003c -5 && !nearEye ? -9 : wolfDist(S, lx(x + 0.5), ly(y + 0.5), hp, info) * SC;\n          wd[p] = dd;\n          sil[p] = cl(0.5 - dd, 0, 1);\n          // The eye, a toxic green glint, shut while it howls.\n          if (dd \u003c -0.5 && eyeOpen > 0.1 && ((info.u - 1.3) / 1.15) ** 2 + ((info.v + 0.9) / (0.8 * eyeOpen)) ** 2 \u003c 1) sil[p] = -1;\n        }\n    }\n  for (let y = 64; y \u003c 108; y++)\n    for (let x = 4; x \u003c 52; x++) {\n      const p = y * W + x, sv = sil[p];\n      if (sv \u003c 0) buf.set([0.45, 1, 0.25], 3 * p);\n      if (sv \u003c= 0) continue;\n      // Moonlight rims edges facing up, half the sides, none on the moon's face.\n      const up = sil[p - W], side = min(sil[p - 1], sil[p + 1]);\n      const edge = wd[p] > -1.1 ? (up \u003c 0.5 && up >= 0 ? 1 : side \u003c 0.5 && side >= 0 ? 0.55 : 0.2) : 0;\n      black(buf, mc, p, sv, edge * (1 - 0.85 * MOONT[p]) * min(1, GLOW[p] * 2.2 + 0.25) * 0.8);\n    }\n  // Breath: pale puffs that swell and fade as they drift.\n  for (const v of S.vap) {\n    const f = 1 - v.age / v.life, a = 0.34 * f * f, rr = 3.2 - 2.4 * f;\n    for (let y = max(0, floor(v.y - rr - 1)); y \u003c= min(H - 1, floor(v.y + rr + 1)); y++)\n      for (let x = max(0, floor(v.x - rr - 1)); x \u003c= min(W - 1, floor(v.x + rr + 1)); x++) {\n        const c = cl(rr + 0.5 - sqrt((x + 0.5 - v.x) ** 2 + (y + 0.5 - v.y) ** 2), 0, 1) * a;\n        if (c > 0) mix(buf, y * W + x, 0.85, 0.8, 0.95, c);\n      }\n  }\n  // The wolf's own rings, in front of everything.\n  rings(S, buf, 0);\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), q4(buf[3 * p]), q4(buf[3 * p + 1]), q4(buf[3 * p + 2]));\n}\n","lantern-procession":"// ===== Patternflow pattern =====\n// Title:   Lantern Procession\n// Family:  halloween\n// Idea:    On a black night a line of hooded walkers with lanterns hung from crooked staffs winds up a path from the foot of the panel to a hilltop near the top, smaller and dimmer the further they go, each lantern a soft warm halo swinging with its walker's steps and each dark robe rimmed with its light and standing in a pool of glowing mist, while now and then a gust runs up the line ducking the flames, a lantern gutters out and a cold green ghost-lantern walks on in its place with a faint green figure under it, and the walkers at the top fade into the fog.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Walkers=8..24, Fog=0..1\n//\n// Knob 1: Hue. The colour of the lanterns and of the light they throw, the ghost-lanterns a quarter of the way on round the wheel. At 0 amber lanterns and green ghosts; at 0.25 lime lanterns and cyan ghosts, at 0.31 the living lanterns themselves ghost green, at 0.5 aqua with violet ghosts, at 0.75 blue with pink ghosts and at 1 violet with orange ones.\n// Knob 2: Speed. At 2 a walker climbs the whole path in 28 s at about 1.8 steps a second, its lantern swinging once every two steps; a gust runs up the line every 7 to 11 s and a lantern gutters every 6 to 10 s, flickering down for 1.4 s, dark for 0.9 s and lit again as a ghost over 0.6 s. At 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Walkers. How many walk the path, 8 to 24, spread evenly along it, so 8 put seven or eight lanterns in view at once, 16 about fifteen and 24 a close line of 21 or 22 from the foot to the top; a walker is 23 LEDs tall near the foot and 6 at the hilltop. At most a quarter of them are ghosts at once, and a ghost that goes over the top comes round again at the foot with a living lantern.\n// Knob 4: Fog. At 0 the night is clear: a lantern near the hilltop keeps 74% of its light and the glow in the air round each lantern spreads 0.42 of its walker's height. At 0.06 the hilltop lanterns keep 65% and faint banks start to drift across. At 1 they keep 9% and are lost, every glow spreads 60% wider and shines twice as bright, the pools of mist on the ground more than twice, and a drifting haze stands in front of the whole procession, thickest up the hill.\n// Buttons: K1 tap turns the nearest lantern wholly in view into a ghost: it gutters for 0.4 s, is dark for 0.3 s and lights green.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, exp, log, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The path in perspective. A walker's place on it is u, 0 at the foot of\n// the panel and 1 at the hilltop; it stands 1 + PK*u times further off than\n// at the foot, so it is that much smaller, and its feet are at pathY(u),\n// which runs from row Y0 (just under the panel) to row 18 at u = 1.\nconst Y0 = 134, YK = 68, PK = 4.5, SPAN = 1.16, UIN = -0.12;\nconst depth = (u) => 1 + PK * max(0, u);\nconst pathY = (u) => (u \u003c 0 ? Y0 - YK * PK * u : Y0 - YK * log(1 + PK * u));\nconst pathX = (u) => 32 + (23 * sin(2 * PI * 1.55 * u + 0.45) - 3) / depth(u) + 2;\nconst uOfY = (y) => (exp((Y0 - y) / YK) - 1) / PK;\n// A walker's height in LEDs at the foot of the panel.\nconst TALL = 34;\n// The ridge the path goes over, row by row across the panel.\nconst CREST = pathY(1);\nconst ridge = (x) => CREST - 0.6 + 0.0045 * (x - pathX(1)) ** 2 + 0.9 * sin(x * 0.19 + 1.3);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// A hooded robe seen from behind: half its width at heights 0 (the hem) to\n// 1 (the hood's point), in walker heights.\nconst PROF_T = [0, 0.05, 0.4, 0.62, 0.69, 0.75, 0.83, 0.9, 0.96, 1];\nconst PROF_W = [0.23, 0.235, 0.19, 0.195, 0.165, 0.12, 0.135, 0.115, 0.055, 0];\nfunction prof(t) {\n  if (t \u003c= 0 || t >= 1) return t \u003c= 0 ? PROF_W[0] : 0;\n  let i = 1;\n  while (PROF_T[i] \u003c t) i++;\n  const a = (t - PROF_T[i - 1]) / (PROF_T[i] - PROF_T[i - 1]);\n  return PROF_W[i - 1] + (PROF_W[i] - PROF_W[i - 1]) * a;\n}\n\n// Lantern states: lit, guttering, out, ghost.\nconst LIT = 0, GUTTER = 1, OUT = 2, GHOST = 3;\n\nfunction walker(u) {\n  return {\n    u, side: Math.random() \u003c 0.5 ? -1 : 1, ph: Math.random() * 2, jx: (Math.random() - 0.5) * 3,\n    sw: 0.35 + Math.random() * 0.2, state: LIT, st: 0, gut: 1.4, outT: 0.9,\n    f1: Math.random() * 7, f2: Math.random() * 7, f3: Math.random() * 7, cad: 0.9 + Math.random() * 0.2,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, t: 0, hue: 0, speed: 1, n: 0, fog: 0.06, ws: [], next: 3.2, gust: -1, gustWait: 2.2,\n    L: new Float32Array(N * 3), stars: [],\n    lc: [0, 0, 0], gc: [0, 0, 0], tmp: [0, 0, 0],\n  };\n  const S = params.s;\n  for (let i = 0; i \u003c 26; i++) {\n    const x = Math.random() * W;\n    S.stars.push({ x: floor(x), y: floor(Math.random() * (ridge(x) - 2)), a: 8 + Math.random() * 14, f: Math.random() * 7, w: 0.8 + Math.random() * 2 });\n  }\n}\n\nfunction build(S, n) {\n  S.n = n;\n  const ws = [], off = S.ws.length ? S.ws[0].u : 0.0;\n  for (let i = 0; i \u003c n; i++) {\n    let u = off + (i * SPAN) / n + (Math.random() - 0.5) * (0.25 * SPAN) / n;\n    while (u > UIN + SPAN) u -= SPAN;\n    const w = walker(u);\n    // Staffs on alternate sides down the line, now and then two together.\n    w.side = i % 2 ? 1 : -1;\n    if (Math.random() \u003c 0.2) w.side = -w.side;\n    ws.push(w);\n  }\n  S.ws = ws;\n}\n\nfunction ghosts(S) {\n  let g = 0;\n  for (const w of S.ws) if (w.state !== LIT) g++;\n  return g;\n}\n\n// A lit lantern in view begins to gutter: a random one in the nearer half\n// of the path, or with the button the nearest one wholly in view, quickly.\nfunction gutter(S, quick) {\n  const c = S.ws.filter((w) => w.state === LIT && w.u > (quick ? 0.07 : 0.04) && w.u \u003c (quick ? 0.85 : 0.55));\n  if (!c.length) return;\n  c.sort((a, b) => a.u - b.u);\n  const w = quick ? c[0] : c[floor(Math.random() * c.length)];\n  w.state = GUTTER;\n  w.st = 0;\n  w.gut = quick ? 0.4 : 1.4;\n  w.outT = quick ? 0.3 : 0.9;\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  // At Speed 2 a walker climbs the whole path in 28 s and takes 1.8 steps a second.\n  const du = (SPAN / 28) * dt;\n  for (const w of S.ws) {\n    w.u += du;\n    w.ph += 1.8 * w.cad * dt;\n    w.st += dt;\n    if (w.state === GUTTER && w.st > w.gut) (w.state = OUT), (w.st = 0);\n    else if (w.state === OUT && w.st > w.outT) (w.state = GHOST), (w.st = 0);\n    // Over the hilltop and into the fog: the walker comes round again at the\n    // foot of the path with a lit lantern.\n    if (w.u > UIN + SPAN) {\n      w.u -= SPAN;\n      w.state = LIT;\n      w.side = Math.random() \u003c 0.5 ? -1 : 1;\n    }\n  }\n  // A gust of wind runs up the line from the foot of the path, 0.9 of the\n  // path a second, every 7 to 11 s.\n  S.gustWait -= dt;\n  if (S.gustWait \u003c= 0) (S.gust = UIN), (S.gustWait = 7 + Math.random() * 4);\n  if (S.gust > -1) S.gust = S.gust > 1.3 ? -1 : S.gust + 0.9 * dt;\n  S.next -= dt;\n  if (S.next \u003c= 0) {\n    S.next = 6 + Math.random() * 4;\n    if (ghosts(S) \u003c max(1, round(S.n * 0.25))) gutter(S, false);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3) / 2;\n  S.fog = cl(k[3], 0, 1);\n  const n = cl(round(k[2]), 8, 24);\n  if (n !== S.n) build(S, n);\n  if (!S.begun) S.begun = true;\n  if (input.btnPressed && input.btnPressed[0]) gutter(S, true);\n  step(S, cl(dt || 0, 0, 0.1) * S.speed);\n}\n\n// The lantern's brightness now, 0..1. Wind does not touch a ghost's light.\nfunction flame(S, w) {\n  const t = S.t;\n  let fl = 0.74 + 0.11 * sin(t * 9.1 + w.f1) + 0.08 * sin(t * 14.3 + w.f2) + 0.07 * sin(t * 22.7 + w.f3);\n  // As the gust reaches a lantern its flame ducks to half and flares after.\n  if (S.gust > -1) {\n    const g = (w.u - S.gust) / 0.05, f = (w.u - S.gust + 0.13) / 0.07;\n    fl *= 1 - 0.5 * exp(-g * g) * (0.8 + 0.2 * sin(t * 31 + w.f1)) + 0.18 * exp(-f * f);\n  }\n  if (w.state === LIT) return fl;\n  if (w.state === GUTTER) {\n    const p = w.st / w.gut;\n    return fl * (1 - p) * (0.55 + 0.45 * abs(sin(t * 17 + w.f1 * 3) * sin(t * 6.3 + w.f2)));\n  }\n  if (w.state === OUT) return 0;\n  return sm(0, 0.6, w.st) * (0.78 + 0.16 * sin(t * 2.3 + w.f1) + 0.06 * sin(t * 7.7 + w.f2));\n}\n\nfunction add(L, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  L[o] += r;\n  L[o + 1] += g;\n  L[o + 2] += b;\n}\n\n// A soft elliptical glow, amplitude a (0..255) of colour c, sx and sy wide;\n// with wisp > 0 it is mist, drifting thicker and thinner through it.\nfunction glow(L, cx, cy, sx, sy, a, c, wisp = 0, t = 0) {\n  if (a \u003c 0.5) return;\n  const rx = sx * 3, ry = sy * 3;\n  const x0 = max(0, floor(cx - rx)), x1 = min(W - 1, ceil(cx + rx)), y0 = max(0, floor(cy - ry)), y1 = min(H - 1, ceil(cy + ry));\n  const kx = 1 / (2 * sx * sx), ky = 1 / (2 * sy * sy);\n  for (let y = y0; y \u003c= y1; y++) {\n    const dy = y + 0.5 - cy, ey = exp(-dy * dy * ky) * a;\n    if (ey \u003c 0.3) continue;\n    const o = y * W * 3;\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x + 0.5 - cx;\n      let v = ey * exp(-dx * dx * kx);\n      if (wisp) v *= 1 - wisp * (0.5 + 0.5 * sin(x * 0.45 + y * 0.21 + t * 2.9) * sin(x * 0.17 - y * 0.52 - t * 2.1));\n      const p = o + x * 3;\n      L[p] += c[0] * v;\n      L[p + 1] += c[1] * v;\n      L[p + 2] += c[2] * v;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const L = S.L, t = S.t, fog = S.fog;\n  L.fill(0);\n  hsv(0.085 + 0.7 * S.hue, 0.82, 1, S.lc);\n  hsv(0.085 + 0.7 * S.hue + 0.27, 0.7, 1, S.gc);\n  // The sky over the ridge, deep violet, a little lighter down at the\n  // ridge; faint stars; the hillside under it nearly black, and the path a\n  // pale ribbon on it.\n  for (let x = 0; x \u003c W; x++) {\n    const yr = ridge(x);\n    for (let y = 0; y \u003c H; y++) {\n      const o = (y * W + x) * 3;\n      if (y + 0.5 \u003c yr) {\n        const v = 5 + 9 * (y / yr);\n        L[o] = v * 0.55;\n        L[o + 1] = v * 0.4;\n        L[o + 2] = v;\n      } else {\n        L[o] = 2.2;\n        L[o + 1] = 1.6;\n        L[o + 2] = 3;\n      }\n    }\n  }\n  for (const s of S.stars) {\n    const v = s.a * (0.6 + 0.4 * sin(t * s.w + s.f));\n    if (s.y + 1 \u003c ridge(s.x)) add(L, s.x, s.y, v * 0.8, v * 0.8, v);\n  }\n  for (let y = ceil(CREST); y \u003c H; y++) {\n    const u = uOfY(y + 0.5), d = depth(u), cx = pathX(u), hw = 4.5 / d + 0.6;\n    const x0 = max(0, floor(cx - hw - 1)), x1 = min(W - 1, ceil(cx + hw + 1));\n    for (let x = x0; x \u003c= x1; x++) {\n      const a = cl(hw - abs(x + 0.5 - cx) + 0.5, 0, 1);\n      if (y + 0.5 \u003c ridge(x)) continue;\n      const o = (y * W + x) * 3, v = a * (8 + 4 / d);\n      L[o] += v * 0.75;\n      L[o + 1] += v * 0.62;\n      L[o + 2] += v * 0.7;\n    }\n  }\n  // How fast the night and the fog swallow light up the path.\n  const dens = 0.25 + 1.8 * fog;\n  // Walkers, the furthest first, so the nearer stand in front.\n  const order = S.ws.slice().sort((a, b) => b.u - a.u);\n  const c = S.tmp;\n  for (const w of order) {\n    const u = w.u, d = depth(u), hs = TALL / d;\n    const fy0 = pathY(u);\n    if (fy0 - 1.3 * hs > H + 2) continue;\n    const ghost = w.state === GHOST, I = flame(S, w);\n    // Far walkers fade into the night and the fog; over the top they are gone.\n    const att = exp(-dens * max(0, u) * 1.4) * (u > 0.86 ? sm(1.02, 0.86, u) : 1);\n    if (att \u003c 0.01) continue;\n    const step = w.ph * PI, bob = ghost ? 0.03 * hs * sin(t * 1.7 + w.f1) : 0.025 * hs * abs(sin(step));\n    const fx = pathX(u) + w.jx / d, fy = fy0 - bob - (ghost ? 0.05 * hs : 0);\n    const col = ghost ? S.gc : S.lc;\n    // The lantern hangs from the tip of a staff held out to one side, at\n    // head height, and swings with the steps.\n    const th = w.sw * sin(step + 0.4);\n    const tx = fx + w.side * 0.33 * hs, ty = fy - 1.2 * hs;\n    const lx = tx + sin(th) * 0.17 * hs, ly = ty + cos(th) * 0.17 * hs;\n    const Ia = I * att;\n    const sg = max(1.1, 0.13 * hs), A = min(240, 90 * sg) * Ia, sa = (0.42 + 0.25 * fog) * hs + 1;\n    // The pool of light the lantern throws on the ground and the mist round\n    // the walker's feet; the halo, and the glow in the air round it that\n    // the hood stands dark against. All of it is behind the walker.\n    glow(L, fx + 0.3 * (lx - fx), fy - 0.08 * hs, 0.62 * hs + 1, 0.2 * hs + 0.6, 46 * Ia * (0.6 + 0.8 * fog), col, 0.45, t);\n    glow(L, lx, ly + 0.1 * hs, sa, sa * 1.1, A * 0.22 * (1 + fog), col, 0.3, t);\n    glow(L, lx, ly, sg, sg * 1.25, A, col);\n    // The robe: a dark shape that hides most of the light behind it, warmed\n    // on the lantern's side. A ghost lets most of it through.\n    const op = (ghost ? 0.75 : 1) * min(1, att * 1.6), front = ghost ? 0.5 : 0.07;\n    const soft = max(1, 0.07 * hs), y0 = max(0, floor(fy - hs)), y1 = min(H - 1, floor(fy));\n    const sig2 = 2 * (0.6 * hs) ** 2;\n    for (let y = y0; y \u003c= y1; y++) {\n      const tt = (fy - (y + 0.5)) / hs;\n      // The hem swings a little with each step; a ghost's hem trails away.\n      const sway = tt \u003c 0.3 ? (0.3 - tt) * 0.06 * hs * sin(step) : 0;\n      // The sleeve of the arm that holds the staff stands out on that side.\n      const hw = prof(tt) * hs, cxr = fx + sway, sl = 0.07 * hs * sm(0.4, 0.5, tt) * sm(0.68, 0.58, tt);\n      const hem = ghost ? sm(0, 0.35, tt) : 1;\n      const x0 = max(0, floor(cxr - hw - 2)), x1 = min(W - 1, ceil(cxr + hw + 2));\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - cxr, hx = hw + (dx * w.side > 0 ? sl : 0), a = cl((hx - abs(dx)) / soft + 0.5, 0, 1) * op * hem;\n        if (a \u003c= 0) continue;\n        const ddx = x + 0.5 - lx, ddy = y + 0.5 - ly;\n        const near = exp(-(ddx * ddx + ddy * ddy) / sig2);\n        // A rim of light down the edge on the lantern's side, a band of about\n        // an LED and a half; the rest of the robe stays dark.\n        const e = dx * w.side > 0 ? sm(soft + 0.08 * hs, 0, hx - abs(dx)) : 0;\n        const rim = 150 * Ia * near * (0.04 + 0.96 * e);\n        const o = (y * W + x) * 3, k = 1 - a * (1 - front);\n        // A ghost's robe glows faintly from inside in its lantern's colour,\n        // most at the hood; a living walker's is a dark violet-grey.\n        const gl = ghost ? 30 * Ia * (0.35 + 0.65 * tt) : 0;\n        L[o] = L[o] * k + a * (4 + gl * col[0] + rim * col[0]);\n        L[o + 1] = L[o + 1] * k + a * (2.8 + gl * col[1] + rim * col[1]);\n        L[o + 2] = L[o + 2] * k + a * (5 + gl * col[2] + rim * col[2]);\n      }\n    }\n    // The staff, straight up from the hand to the crook the lantern hangs\n    // from, dark against the glow.\n    if (hs > 7) {\n      const ax = fx + w.side * 0.2 * hs, ay = fy - 0.5 * hs, m = ceil(2 * hs * 0.75);\n      let last = -1;\n      const k = ghost ? 0.85 : 0.6;\n      for (let i = 0; i \u003c= m; i++) {\n        // Up the shaft for the first four fifths, then out along the crook.\n        const f = i / m, x = floor(f \u003c 0.8 ? ax : ax + ((tx - ax) * (f - 0.8)) / 0.2), y = floor(f \u003c 0.8 ? ay + ((ty - ay) * f) / 0.8 : ty);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        if (o === last) continue;\n        last = o;\n        L[o] *= k;\n        L[o + 1] *= k;\n        L[o + 2] *= k;\n      }\n    }\n    // The lantern itself in front: a whiter core.\n    c[0] = 1;\n    c[1] = 0.88;\n    c[2] = 0.68;\n    if (ghost) (c[0] = 0.75), (c[1] = 1), (c[2] = 0.85);\n    glow(L, lx, ly, sg * 0.55, sg * 0.7, A * 0.35, c);\n  }\n  // The fog in front of it all: banks drifting across, thicker up the hill,\n  // a dim grey-violet.\n  for (let y = 0; y \u003c H && fog > 0.004; y++) {\n    const far = 1 - sm(20, 120, y);\n    for (let x = 0; x \u003c W; x++) {\n      const n = 0.5 + 0.3 * sin(x * 0.09 + y * 0.045 + t * 0.31) + 0.2 * sin(x * 0.043 - y * 0.12 - t * 0.23);\n      const v = fog * n * (5 + 11 * far);\n      const o = (y * W + x) * 3;\n      L[o] += v * 0.8;\n      L[o + 1] += v * 0.75;\n      L[o + 2] += v;\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    let r = L[o], g = L[o + 1], b = L[o + 2];\n    if (r + g + b \u003c 1.5) continue;\n    // A soft shoulder above 190, and every channel in steps of 4.\n    r = r \u003c 190 ? r : 190 + 65 * (1 - exp(-(r - 190) / 65));\n    g = g \u003c 190 ? g : 190 + 65 * (1 - exp(-(g - 190) / 65));\n    b = b \u003c 190 ? b : 190 + 65 * (1 - exp(-(b - 190) / 65));\n    display.setPixel(p % W, (p / W) | 0, round(r / 4) * 4, round(g / 4) * 4, round(b / 4) * 4);\n  }\n}\n","lorentz-gas":"// ===== Patternflow pattern =====\n// Title:   Lorentz Gas\n// Family:  particle\n// Idea:    A triangular array of round scatterers fills the panel and a burst of point particles leaves one spot between them in every direction at once, each bouncing specularly off the discs and changing colour with every bounce, so the bright bead breaks into a cloud that seeps from pocket to pocket through the narrow gaps while a thin ring at the measured root mean square distance grows like the square root of time, until the cloud fills the view and a new burst leaves another spot; with smaller discs straight corridors open between the rows and particles shoot along them in long streaks.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lorentz gas (Hendrik Lorentz, 1905), with the periodic Sinai billiard (Yakov Sinai, 1970), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Particles=800..3000, Radius=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a fresh burst is ice cyan and shades through blue and violet to magenta as its particles bounce, most of the way by 120 bounces, over discs with grey-blue rims and inside a pale gold ring; at 0.25 the cloud runs from violet to orange, at 0.5 from red through yellow to green and at 0.75 from lime to blue.\n// Knob 2: Speed. Particles fly 15 LEDs a second for each unit: 30 at 2, where each bounces about 10 times a second at the opening radius and a burst fills the view in 8 to 9 s; 3 LEDs a second at 0.2, a burst lasting about 85 s, and 45 at 3, about 5.5 s.\n// Knob 3: Particles. How many leave each burst: 800 at the start, 1350 at a quarter, 1900 at half, 2450 at three quarters and 3000 at the end, the pockets lit denser and brighter the more there are. Turned during a burst it copies particles already in flight or drops some, so the cloud keeps its shape.\n// Knob 4: Radius. The discs' radius on a lattice of spacing 1, which is 12 LEDs: 0.47 at 0, 0.455 at the opening 0.06, 0.4075 at a quarter, 0.345 at half, 0.2825 at three quarters and 0.22 at 1. Above sqrt(3)/4 = 0.433, which is the knob at 0.148, every straight line meets a disc, the cloud seeps from pocket to pocket through gaps 0.7 to 1.6 LEDs wide and its mean square displacement grows in step with time; a burst lasts 10 to 12 s at 0, 8 to 9 s at 0.06 and about 6 s at the threshold. Past it corridors open between the rows of discs, up the panel and at 60 degrees to it, 2.1 LEDs wide at half and 5.1 at 1, particles shoot along them in streaks that stick out of the cloud, and the spread grows faster than time (as t log t): a burst lasts 2.4 s at half and 1.6 s at 1.\n// Buttons: K1 tap starts a new burst from another spot between the discs while the old cloud fades out over 1.2 s. A burst also starts by itself once the ring passes 30 LEDs.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sqrt, exp, cos, sin, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The lattice: spacing 1 in its own units, D LEDs on the panel. Its rows run\n// up the panel, so the corridors that open below the threshold run the\n// panel's long way and at 60 degrees to it. A lattice point sits at\n// (i + j/2, j*SQ); the lattice X axis is the panel's y.\nconst D = 12, SQ = sqrt(3) / 2, CX = 32, CY = 64;\n// Disc radius from knob 4: 0.47 at 0, 0.455 at the opening 0.06, 0.22 at\n// 1. Discs touch at 0.5. The horizon is finite exactly when the discs block\n// every row corridor: rows are SQ apart, so a corridor SQ - 2r wide is open\n// below r = sqrt(3)/4, the knob at 0.148. Below r = 1/4 a second family\n// opens, between rows of the lattice's 30-degree direction, half apart.\nconst rOf = (k) => 0.47 - 0.25 * k;\n// Flight per second for each unit of Speed, in lattice units.\nconst RATE = 1.25;\n// The longest straight piece looked at in one go. With r + STEP under SQ,\n// only the four corners of the lattice cell a particle is in can be hit.\nconst STEP = 0.3;\n// A burst ends when its ring passes this many lattice units (30 LEDs).\nconst RMAX = 2.5;\nconst NMAX = 3000, FADE = 1.2;\n// Hue of a fresh particle at knob 0: ice cyan, shading to violet and\n// magenta as the bounces add up.\nconst HUE0 = 0.5, SHIFT = 0.38, NB = 60;\n// A particle's light fades as it moves on, over TRAIL LEDs of its path\n// whatever the speed, so a flight down a corridor shows as a streak.\nconst TRAIL = 3, VLED = RATE * D;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nfunction makeSet() {\n  return {\n    n: 0, live: false, fade: 1, ox: 0, oy: 0, s: 0, msd: 0,\n    X: new Float64Array(NMAX), Y: new Float64Array(NMAX), VX: new Float64Array(NMAX), VY: new Float64Array(NMAX),\n    PX: new Float64Array(NMAX), PY: new Float64Array(NMAX), B: new Uint16Array(NMAX),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: -1, speed: 2, count: 800, r: -1, rmax: RMAX, keep: 0,\n    sets: [makeSet(), makeSet()], cur: 0,\n    bg: new Float32Array(N * 3), acc: new Float32Array(N * 3), lit: new Float32Array(N * 3), lut: new Float32Array(256 * 3), ring: new Float32Array(3),\n    bgKey: \"\",\n  };\n}\n\n// The centre of the disc nearest (x, y), into NC. A point in the lattice\n// cell with corners (fa, fb)..(fa+1, fb+1) is never nearer another point.\nconst NC = [0, 0, 0];\nfunction nearest(x, y) {\n  const b = y / SQ, a = x - 0.5 * b, fa = floor(a), fb = floor(b);\n  let best = 1e9;\n  for (let j = fb; j \u003c= fb + 1; j++)\n    for (let i = fa; i \u003c= fa + 1; i++) {\n      const cx = i + 0.5 * j, cy = j * SQ, d2 = (x - cx) * (x - cx) + (y - cy) * (y - cy);\n      if (d2 \u003c best) (best = d2), (NC[0] = cx), (NC[1] = cy);\n    }\n  NC[2] = best;\n}\n\n// Flies particle i of set P a distance L, bouncing off every disc it meets\n// on the way: the exact first crossing of the ray with each of the four\n// discs it can reach, the mirror reflection there, and on with what is left.\nfunction fly(P, i, L, r) {\n  let x = P.X[i], y = P.Y[i], vx = P.VX[i], vy = P.VY[i], rem = L, hits = 0;\n  const r2 = r * r;\n  for (let guard = 0; rem > 1e-12 && guard \u003c 64; guard++) {\n    const seg = min(rem, STEP);\n    const b = y / SQ, a = x - 0.5 * b, fa = floor(a), fb = floor(b);\n    let tb = seg, hx = 0, hy = 0, hit = false;\n    for (let j = fb; j \u003c= fb + 1; j++)\n      for (let k = fa; k \u003c= fa + 1; k++) {\n        const cx = k + 0.5 * j, cy = j * SQ, dx = x - cx, dy = y - cy;\n        const bd = dx * vx + dy * vy;\n        // Moving away from this disc, or along its tangent: no hit.\n        if (bd >= 0) continue;\n        const q = bd * bd - (dx * dx + dy * dy - r2);\n        if (q \u003c= 0) continue;\n        let t = -bd - sqrt(q);\n        if (t \u003c 0) t = 0;\n        if (t \u003c tb) (tb = t), (hx = cx), (hy = cy), (hit = true);\n      }\n    x += vx * tb;\n    y += vy * tb;\n    rem -= tb;\n    if (hit) {\n      // The normal at the hit point; the particle is set back onto the rim\n      // a hair outside it, so rounding never leaves it in the disc.\n      let nx = x - hx, ny = y - hy;\n      const l = sqrt(nx * nx + ny * ny);\n      nx /= l;\n      ny /= l;\n      const dn = vx * nx + vy * ny;\n      vx -= 2 * dn * nx;\n      vy -= 2 * dn * ny;\n      x = hx + nx * (r + 1e-9);\n      y = hy + ny * (r + 1e-9);\n      hits++;\n    }\n  }\n  P.X[i] = x;\n  P.Y[i] = y;\n  P.VX[i] = vx;\n  P.VY[i] = vy;\n  P.B[i] = min(65535, P.B[i] + hits);\n}\n\n// A spot in the gaps, in the middle of the view and away from the last one.\nfunction spot(S, last) {\n  let bx = 0, by = 0, bd = -1;\n  for (let k = 0; k \u003c 40; k++) {\n    const x = (Math.random() * 2 - 1) * 3.2, y = (Math.random() * 2 - 1) * 1.6;\n    nearest(x, y);\n    if (sqrt(NC[2]) \u003c S.r + 0.04) continue;\n    const d = last ? (x - last.ox) ** 2 + (y - last.oy) ** 2 : 1;\n    if (d > bd) (bd = d), (bx = x), (by = y);\n  }\n  if (bd \u003c 0) {\n    // Every try fell in a disc (only possible with the largest discs): the\n    // middle of a pocket is always free.\n    bx = 0.5;\n    by = SQ / 3;\n  }\n  return [bx, by];\n}\n\nfunction burst(S) {\n  const old = S.sets[S.cur];\n  S.cur ^= 1;\n  const P = S.sets[S.cur];\n  const [ox, oy] = spot(S, old.live ? old : null);\n  if (old.live) old.fade = 1 - 1e-6;\n  P.live = true;\n  P.fade = 1;\n  P.ox = ox;\n  P.oy = oy;\n  P.s = 0;\n  P.msd = 0;\n  P.n = S.count;\n  // Headings evenly round the circle, so the first ring is a true circle\n  // until it meets the discs.\n  const a0 = Math.random() * TAU;\n  for (let i = 0; i \u003c P.n; i++) {\n    const a = a0 + (TAU * (i + Math.random() * 0.5)) / P.n;\n    P.X[i] = P.PX[i] = ox;\n    P.Y[i] = P.PY[i] = oy;\n    P.VX[i] = cos(a);\n    P.VY[i] = sin(a);\n    P.B[i] = 0;\n  }\n}\n\n// A new radius can swallow particles: those it does are put back on the\n// rim, turned outward if they were heading in.\nfunction pushOut(S) {\n  const r = S.r;\n  for (const P of S.sets) {\n    if (!P.live) continue;\n    for (let i = 0; i \u003c P.n; i++) {\n      nearest(P.X[i], P.Y[i]);\n      if (NC[2] >= r * r) continue;\n      let nx = P.X[i] - NC[0], ny = P.Y[i] - NC[1];\n      const l = sqrt(nx * nx + ny * ny);\n      if (l \u003c 1e-9) (nx = 1), (ny = 0);\n      else (nx /= l), (ny /= l);\n      P.X[i] = P.PX[i] = NC[0] + nx * (r + 1e-9);\n      P.Y[i] = P.PY[i] = NC[1] + ny * (r + 1e-9);\n      const dn = P.VX[i] * nx + P.VY[i] * ny;\n      if (dn \u003c 0) (P.VX[i] -= 2 * dn * nx), (P.VY[i] -= 2 * dn * ny);\n    }\n  }\n}\n\n// More particles: copies of particles already in flight, in new\n// directions, so the cloud keeps its shape. Fewer: the last ones go.\nfunction resize(S, n) {\n  const P = S.sets[S.cur];\n  if (P.live && n > P.n) {\n    for (let i = P.n; i \u003c n; i++) {\n      const j = floor(Math.random() * P.n), a = Math.random() * TAU;\n      P.X[i] = P.PX[i] = P.X[j];\n      P.Y[i] = P.PY[i] = P.Y[j];\n      P.VX[i] = cos(a);\n      P.VY[i] = sin(a);\n      P.B[i] = P.B[j];\n    }\n  }\n  if (P.live) P.n = n;\n  S.count = n;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 800, 0.06];\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = round(cl(kv[2], 800, NMAX)), r = rOf(cl(kv[3], 0, 1));\n  if (r !== S.r) {\n    S.r = r;\n    pushOut(S);\n  }\n  if (n !== S.count) resize(S, n);\n  if (!S.begun) {\n    S.begun = true;\n    burst(S);\n  }\n  if (input.btnPressed && input.btnPressed[0]) burst(S);\n  const d = cl(dt || 0, 0, 0.1), L = d * RATE * S.speed;\n  S.keep = exp(-(d * VLED * S.speed) / TRAIL);\n  for (const P of S.sets) {\n    if (!P.live) continue;\n    if (P.fade \u003c 1) {\n      P.fade -= d / FADE;\n      if (P.fade \u003c= 0) {\n        P.live = false;\n        continue;\n      }\n    }\n    let m = 0;\n    for (let i = 0; i \u003c P.n; i++) {\n      P.PX[i] = P.X[i];\n      P.PY[i] = P.Y[i];\n      fly(P, i, L, S.r);\n      const dx = P.X[i] - P.ox, dy = P.Y[i] - P.oy;\n      m += dx * dx + dy * dy;\n    }\n    P.s += L;\n    P.msd = m / P.n;\n  }\n  // The measured spread of the cloud, from where it started.\n  if (sqrt(S.sets[S.cur].msd) > S.rmax) burst(S);\n}\n\n// The discs: a faint fill and a soft rim, laid down once for each radius.\nfunction background(S) {\n  const key = S.r + \":\" + S.hue;\n  if (key === S.bgKey) return;\n  S.bgKey = key;\n  const bg = S.bg, c = [0, 0, 0], e = [0, 0, 0];\n  hsv(HUE0 + S.hue + 0.12, 0.6, 1, c, 0);\n  hsv(HUE0 + S.hue + 0.08, 0.35, 1, e, 0);\n  const R = S.r * D;\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      // Lattice X is the panel's y, lattice Y its x.\n      nearest((py + 0.5 - CY) / D, (px + 0.5 - CX) / D);\n      const dd = sqrt(NC[2]) * D - R;\n      const fill = dd \u003c 0 ? 0.035 + 0.02 * min(1, -dd / R) : 0;\n      const rim = 0.17 * exp(-(dd * dd) / 0.45);\n      const o = (py * W + px) * 3;\n      for (let k = 0; k \u003c 3; k++) bg[o + k] = c[k] * fill + e[k] * rim;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  background(S);\n  const { bg, acc, lut } = S;\n  for (let o = 0; o \u003c N * 3; o++) acc[o] *= S.keep;\n  // Colour by bounce count: a fresh particle a pale cyan, then deeper and\n  // further round the wheel, most of the way by 2 * NB bounces.\n  for (let b = 0; b \u003c 256; b++) {\n    const u = 1 - exp(-b / NB);\n    hsv(HUE0 + S.hue + SHIFT * u, 0.6 + 0.3 * min(1, b / 12), 1, lut, b * 3);\n  }\n  for (const P of S.sets) {\n    if (!P.live) continue;\n    const w = (P.fade \u003c 1 ? P.fade * P.fade : 1) * (1 - S.keep) * 1.6;\n    for (let i = 0; i \u003c P.n; i++) {\n      const c = min(255, P.B[i]) * 3;\n      // The stretch of path flown since the last frame, in steps of half\n      // an LED.\n      const x1 = CX + P.Y[i] * D, y1 = CY + P.X[i] * D, x0 = CX + P.PY[i] * D, y0 = CY + P.PX[i] * D;\n      const m = max(1, Math.ceil(2 * max(abs(x1 - x0), abs(y1 - y0)))), wk = w / m;\n      for (let k = 1; k \u003c= m; k++) {\n        const x = floor(x0 + ((x1 - x0) * k) / m), y = floor(y0 + ((y1 - y0) * k) / m);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        acc[o] += lut[c] * wk;\n        acc[o + 1] += lut[c + 1] * wk;\n        acc[o + 2] += lut[c + 2] * wk;\n      }\n    }\n  }\n  // The ring: the root mean square distance from the burst's start.\n  const P = S.sets[S.cur], rr = sqrt(P.msd) * D, ox = CX + P.oy * D, oy = CY + P.ox * D;\n  const ring = S.ring, lit = S.lit;\n  lit.fill(0);\n  hsv(HUE0 + S.hue + 0.62, 0.3, 0.6, ring, 0);\n  if (rr > 1.5) {\n    const y0 = max(0, floor(oy - rr - 2)), y1 = min(H - 1, floor(oy + rr + 2));\n    const x0 = max(0, floor(ox - rr - 2)), x1 = min(W - 1, floor(ox + rr + 2));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dd = abs(sqrt((x + 0.5 - ox) ** 2 + (y + 0.5 - oy) ** 2) - rr);\n        if (dd >= 1) continue;\n        const o = (y * W + x) * 3, a = 1 - dd;\n        for (let k = 0; k \u003c 3; k++) lit[o + k] = ring[k] * a;\n      }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const r = bg[o] + lit[o] + 1 - exp(-acc[o]), g = bg[o + 1] + lit[o + 1] + 1 - exp(-acc[o + 1]), b = bg[o + 2] + lit[o + 2] + 1 - exp(-acc[o + 2]);\n    if (r + g + b \u003c 0.008) continue;\n    // Each channel in steps of 4 of 255, too fine to see, and a frame packs\n    // smaller for it.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(r * 63.75) * 4), min(255, round(g * 63.75) * 4), min(255, round(b * 63.75) * 4));\n  }\n}\n","reeb-graph":"// ===== Patternflow pattern =====\n// Title:   Reeb Graph\n// Family:  topology\n// Idea:    A closed surface of genus two to six, that many rings fused in one upright chain, turns slowly about the vertical while a level plane rises through it from the bottom, the surface below the plane lit solid and the surface above it a faint ghost, the cut drawn as bright rings on the plane, each ring shrinking to one point whose path down the inside of the chain draws the Reeb graph, a stem from the bottom that splits at the bottom of every hole and joins again at its top, so that each critical point flashes in its own colour as the plane passes it and the count of minima, saddles and maxima always comes to two minus twice the genus.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Morse theory (Marston Morse, 1934) and the Reeb graph (Georges Reeb, 1946), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Holes=2..6, Tilt=0..1\n//\n// Knob 1: Hue. The surface's colour, with the cut, the graph and the three kinds of critical point turned with it. At 0 an azure surface cut in amber, minima green, saddles white, maxima magenta; at 0.25 magenta cut in lime, at 0.5 orange cut in azure, at 0.75 green cut in purple.\n// Knob 2: Speed. At 2 the plane climbs the whole chain in 5 seconds, waits a second at the top and starts again, and the chain turns once in 16 seconds; at 0.2 both are ten times slower, at 3 half as fast again.\n// Knob 3: Holes. The genus, the knob rounded: 2 at the start, 3 at a quarter, 4 at half, 5 at three quarters, 6 at the end. Genus g has one minimum, one maximum and 2g saddles, 1 - 2g + 1 = 2 - 2g, and its Reeb graph is a chain of g loops; the chain is scaled to fill the 128 rows each time.\n// Knob 4: Tilt. Leans the chain off the vertical in the plane of its rings, 0.06 rad at the start and 1.05 rad (60 degrees) at 1, and the chain shrinks to keep fitting the panel as it turns. Up to about 0.8 the loops of the graph only slide into a staircase and the count stays 1, 2g, 1. Past that each ring overhangs the next: the joints grow short spurs, a new minimum with its saddle on the low side and a new maximum with its saddle on the high side, and from about 0.85 two holes share a level and the cut has three pieces at once; genus 2 at 1 counts 2, 6, 2 and genus 6 counts 6, 20, 4, and every count still comes to 2 - 2g.\n// Buttons: K1 tap turns the height upside down: the plane sweeps down from the top, the top point is now the minimum and the bottom the maximum, and the count does not change. K2 tap starts the sweep again.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// An orthographic camera looking down at the chain from 0.36 rad above the\n// level, so the cut shows as flat rings, a third as tall as they are wide.\nconst EL = 0.36, CA = cos(EL), SA = sin(EL);\n// The surface, in units of the ring's radius: tube radius, distance between\n// ring centres along the chain, and how wide the smooth union blends. The\n// rings overlap by 0.15, so neighbours share one bar between their holes.\nconst TR = 0.32, GAP = 2.15, KS = 0.2;\n// Tilt at knob 1, in radians.\nconst TILT = 1.05;\n// Surface hue at Hue 0: azure.\nconst HUE0 = 0.58;\n// Sphere tracing: closest approach that counts as a hit, and most steps.\nconst EPS = 0.004, STEPS = 48;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The chain being drawn. draw() and build() copy it here from the state\n// before they touch the distance function, so two panels never mix.\nlet NG = 2, ST = 0, CT = 1, HALF = 0.5, CX = new Float64Array(8), CY = new Float64Array(8);\nfunction use(S) {\n  NG = S.g;\n  ST = sin(S.tilt);\n  CT = cos(S.tilt);\n  HALF = (NG - 1) / 2;\n  CX = S.cx;\n  CY = S.cy;\n}\n\n// Signed distance to the surface in the chain's own frame: the rings lie in\n// the x-y plane, y is height. Only the two rings either side of the point\n// along the chain can be near it, so only those two are measured.\nfunction sdf(x, y, z) {\n  let k = floor((x * ST + y * CT) / GAP + HALF);\n  if (k \u003c 0) k = 0;\n  else if (k > NG - 2) k = NG - 2;\n  let ax = x - CX[k], ay = y - CY[k], q = sqrt(ax * ax + ay * ay) - 1;\n  const a = sqrt(q * q + z * z) - TR;\n  ax = x - CX[k + 1];\n  ay = y - CY[k + 1];\n  q = sqrt(ax * ax + ay * ay) - 1;\n  const b = sqrt(q * q + z * z) - TR;\n  const h = 0.5 + (0.5 * (b - a)) / KS;\n  if (h \u003c= 0) return b;\n  if (h >= 1) return a;\n  return b + (a - b) * h - KS * h * (1 - h);\n}\n\n// The same, with its gradient in GR: the polynomial smooth minimum's\n// gradient is exactly the blend of the two rings' gradients.\nconst GR = new Float64Array(3);\nfunction torusG(x, y, z, k, o) {\n  const ax = x - CX[k], ay = y - CY[k], rh = sqrt(ax * ax + ay * ay) || 1e-9, q = rh - 1, d = sqrt(q * q + z * z) || 1e-9;\n  TG[o] = ((q / d) * ax) / rh;\n  TG[o + 1] = ((q / d) * ay) / rh;\n  TG[o + 2] = z / d;\n  return d - TR;\n}\nconst TG = new Float64Array(6);\nfunction sdfG(x, y, z) {\n  let k = floor((x * ST + y * CT) / GAP + HALF);\n  if (k \u003c 0) k = 0;\n  else if (k > NG - 2) k = NG - 2;\n  const a = torusG(x, y, z, k, 0), b = torusG(x, y, z, k + 1, 3);\n  const h = cl(0.5 + (0.5 * (b - a)) / KS, 0, 1);\n  for (let i = 0; i \u003c 3; i++) GR[i] = TG[i] * h + TG[i + 3] * (1 - h);\n  return b + (a - b) * h - KS * h * (1 - h);\n}\n\n// Lay the chain out for genus g and tilt, fit it to the panel and find its\n// Reeb graph.\nfunction layout(S) {\n  const g = S.g;\n  for (let k = 0; k \u003c g; k++) {\n    const u = (k - (g - 1) / 2) * GAP;\n    S.cx[k] = u * sin(S.tilt);\n    S.cy[k] = u * cos(S.tilt);\n  }\n  // The panel must hold the chain at every turn: a point at height y and\n  // distance r from the axis reaches screen heights y*CA +- r*SA.\n  let rho = 0, bLo = 1e9, bHi = -1e9;\n  for (let k = 0; k \u003c g; k++)\n    for (let i = 0; i \u003c 48; i++) {\n      const t = (i / 48) * 2 * PI;\n      for (let j = 0; j \u003c 12; j++) {\n        const u = (j / 12) * 2 * PI, rr = 1 + TR * cos(u);\n        const x = S.cx[k] + rr * cos(t), y = S.cy[k] + rr * sin(t), z = TR * sin(u), r = sqrt(x * x + z * z);\n        rho = max(rho, r);\n        bLo = min(bLo, y * CA - r * SA);\n        bHi = max(bHi, y * CA + r * SA);\n      }\n    }\n  S.rho = rho;\n  S.yLo = S.cy[0] - 1 - TR;\n  S.yHi = S.cy[g - 1] + 1 + TR;\n  S.sc = min(62 / (2 * rho), 125 / (bHi - bLo));\n  S.bc = (bHi + bLo) / 2;\n  build(S);\n}\n\n// The Reeb graph, found the way it is defined: cut the surface at a level,\n// count the pieces of the cut, and join each piece to the pieces it touches\n// one level down. The surface is mirror symmetric in z and grows in |z| from\n// the rings' plane, so every piece of a cut crosses the plane z = 0 in one\n// run of x, and the runs along that line are the pieces. A level every half\n// LED, a sample every 0.4 LED along it.\nfunction build(S) {\n  use(S);\n  const s = S.sc, dy = 0.5 / s, dx = 0.4 / s, nl = ceil((S.yHi - S.yLo) / dy), nx = ceil((2 * S.rho) / dx) + 2;\n  const NX = [], NY = [], NA = [], NB = [], L0 = [0];\n  for (let i = 0; i \u003c nl; i++) {\n    const y = S.yLo + (i + 0.5) * dy;\n    let prev = 1, xa = 0, sw = 0, swx = 0;\n    for (let j = 0; j \u003c= nx; j++) {\n      const x = -S.rho - dx + j * dx, v = j === nx ? 1 : sdf(x, y, 0);\n      if (v \u003c 0) {\n        if (prev >= 0) {\n          xa = x - (dx * -v) / (prev - v);\n          sw = swx = 0;\n        }\n        // Weighted by how far the piece reaches out of the plane, so the\n        // point sits at the middle of the piece, not of the run.\n        const u = v + TR, w = u \u003c= 0 ? TR : sqrt(max(0, TR * TR - u * u));\n        sw += w;\n        swx += w * x;\n      } else if (prev \u003c 0) {\n        NX.push(sw > 0 ? swx / sw : xa);\n        NY.push(y);\n        NA.push(xa);\n        NB.push(x - (dx * v) / (v - prev));\n      }\n      prev = v;\n    }\n    L0.push(NX.length);\n  }\n  // Join the runs of neighbouring levels that overlap.\n  const n = NX.length, up = new Int16Array(n), dn = new Int16Array(n), EA = [], EB = [];\n  for (let i = 0; i + 1 \u003c nl; i++)\n    for (let a = L0[i]; a \u003c L0[i + 1]; a++)\n      for (let b = L0[i + 1]; b \u003c L0[i + 2]; b++)\n        if (NA[a] \u003c NB[b] && NA[b] \u003c NB[a]) {\n          EA.push(a);\n          EB.push(b);\n          up[a]++;\n          dn[b]++;\n        }\n  // Critical points: a run with nothing below is born at a minimum, one with\n  // nothing above dies at a maximum, and every extra branch up or down is a\n  // saddle, placed in the gap between the two branches.\n  const C = [];\n  for (let a = 0; a \u003c n; a++) {\n    if (!dn[a]) C.push(NX[a], NY[a] - dy / 2, 0);\n    if (!up[a]) C.push(NX[a], NY[a] + dy / 2, 2);\n  }\n  // Edges are listed by lower run and then left to right, so the branches\n  // of a split sit side by side in the list.\n  for (let i = 0; i + 1 \u003c EA.length; i++)\n    if (EA[i + 1] === EA[i]) C.push((NB[EB[i]] + NA[EB[i + 1]]) / 2, NY[EA[i]] + dy / 2, 1);\n  for (let b = 0; b \u003c n; b++) {\n    if (dn[b] \u003c 2) continue;\n    const lev = NY[b], row = [];\n    for (let i = 0; i \u003c EA.length; i++) if (EB[i] === b) row.push(EA[i]);\n    row.sort((p, q) => NA[p] - NA[q]);\n    for (let j = 0; j + 1 \u003c row.length; j++) C.push((NB[row[j]] + NA[row[j + 1]]) / 2, lev - dy / 2, 1);\n  }\n  let nmin = 0, nsad = 0, nmax = 0;\n  for (let i = 2; i \u003c C.length; i += 3) C[i] === 0 ? nmin++ : C[i] === 1 ? nsad++ : nmax++;\n  S.graph = { NX, NY, EA, EB, C, L0, dy, age: new Float32Array(C.length / 3).fill(-1), was: new Uint8Array(C.length / 3) };\n  S.nMin = nmin;\n  S.nSad = nsad;\n  S.nMax = nmax;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, g: 0, tilt: -1, ph: 0, spin: 0.6, dir: 1,\n    cx: new Float64Array(8), cy: new Float64Array(8), rho: 1, yLo: -1, yHi: 1, sc: 1, bc: 0, h: -1,\n    graph: null, nMin: 0, nSad: 0, nMax: 0,\n    buf: new Float32Array(W * H * 3), ov: new Float32Array(W * H), col: new Float32Array(24),\n  };\n}\n\n// The plane takes 10 / Speed seconds to climb and waits 2 / Speed at the top.\nconst CLIMB = 10, WAIT = 2;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const g = cl(Math.round(kv[2]), 2, 6), tilt = cl(kv[3], 0, 1) * TILT;\n  if (g !== S.g || abs(tilt - S.tilt) > 1e-4) {\n    S.g = g;\n    S.tilt = tilt;\n    layout(S);\n  }\n  const bp = input.btnPressed || [];\n  if (bp[0]) {\n    S.dir = -S.dir;\n    S.ph = 0;\n  }\n  if (bp[1]) S.ph = 0;\n  S.spin += d * 0.2 * S.speed;\n  S.ph += (d * S.speed) / CLIMB;\n  if (S.ph > 1 + WAIT / CLIMB) S.ph = 0;\n  const u = min(1, S.ph), lo = S.yLo - 0.04, hi = S.yHi + 0.04;\n  S.h = S.dir > 0 ? lo + (hi - lo) * u : hi - (hi - lo) * u;\n  // A critical point lights as the plane passes it and flashes for 0.8 s.\n  const G = S.graph, C = G.C;\n  for (let i = 0; i \u003c G.age.length; i++) {\n    const swept = S.dir > 0 ? C[3 * i + 1] \u003c= S.h : C[3 * i + 1] >= S.h;\n    if (swept && !G.was[i]) G.age[i] = 0;\n    else if (G.age[i] >= 0) G.age[i] += d;\n    G.was[i] = swept ? 1 : 0;\n  }\n}\n\n// One ray through the panel's LED, in the chain's frame: origin at t = 0 and\n// direction, filled by draw().\nlet OX = 0, OY = 0, OZ = 0, DX = 0, DY = 0, DZ = 0;\nfunction march(t, end) {\n  let v = 1;\n  for (let n = 0; n \u003c STEPS; n++) {\n    v = sdf(OX + DX * t, OY + DY * t, OZ + DZ * t);\n    if (v \u003c EPS) return t;\n    t += v;\n    if (t > end) return -1e9;\n  }\n  // A ray that grazes the surface along a hole's edge runs out of steps\n  // still close to it; that counts as a hit, or it would leave a black dot.\n  return v \u003c 0.03 ? t : -1e9;\n}\n\n// Splat one point of a line into the overlay, a tent one LED wide.\nfunction dot(ov, fx, fy, w) {\n  const x0 = floor(fx), y0 = floor(fy), ax = fx - x0, ay = fy - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const x = x0 + i, y = y0 + j;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const v = w * (i ? ax : 1 - ax) * (j ? ay : 1 - ay) * 1.6;\n      if (v > ov[y * W + x]) ov[y * W + x] = min(1, v);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.graph) return;\n  use(S);\n  const s = S.sc, cp = cos(S.spin), sp = sin(S.spin), h = S.h, dir = S.dir, buf = S.buf, ov = S.ov, C = S.col;\n  // Colours: surface lit and ghost, the cut's fill and its edge, the graph,\n  // and the three kinds of critical point.\n  const hb = HUE0 + S.hue, hc = hb + 0.5;\n  hsv(hb, 0.72, 1, C, 0);\n  hsv(hb, 0.45, 1, C, 3);\n  hsv(hc, 0.9, 0.42, C, 6);\n  hsv(hc, 0.75, 1, C, 9);\n  hsv(hc + 0.03, 0.5, 1, C, 12);\n  hsv(hb - 0.25, 0.8, 1, C, 15);\n  C[18] = C[19] = C[20] = 1;\n  hsv(hb + 0.3, 0.75, 1, C, 21);\n  // Light from the upper left, in front, turned into the chain's frame.\n  const lx0 = -0.5, ly = 0.72, lz0 = -0.48, ll = sqrt(lx0 * lx0 + ly * ly + lz0 * lz0);\n  const lx = (lx0 * cp - lz0 * sp) / ll, lz = (lx0 * sp + lz0 * cp) / ll, lyn = ly / ll;\n  // The ray direction in the chain's frame, the same for every LED.\n  DX = -CA * sp;\n  DY = -SA;\n  DZ = CA * cp;\n  // The chain's box: across the chain in its plane, along it, and out of it.\n  const hw = 1 + TR + 0.07, hl = HALF * GAP + 1 + TR + 0.07, hz = TR + 0.07;\n  const q1 = DX * CT - DY * ST, q2 = DX * ST + DY * CT;\n  const pr = 31 / s;\n  for (let py = 0; py \u003c H; py++) {\n    const b = S.bc + (63.5 - py) / s;\n    for (let px = 0; px \u003c W; px++) {\n      const a = (px + 0.5 - 32) / s, o = (py * W + px) * 3;\n      OX = a * cp - b * SA * sp;\n      OY = b * CA;\n      OZ = a * sp + b * SA * cp;\n      let tA = -1e9, tB = 1e9;\n      // Slab by slab, the stretch of the ray inside the box.\n      const p1 = OX * CT - OY * ST, p2 = OX * ST + OY * CT;\n      if (abs(q1) > 1e-9) {\n        const u = (-hw - p1) / q1, v = (hw - p1) / q1;\n        tA = max(tA, min(u, v));\n        tB = min(tB, max(u, v));\n      } else if (abs(p1) > hw) tB = -1e9;\n      if (abs(q2) > 1e-9) {\n        const u = (-hl - p2) / q2, v = (hl - p2) / q2;\n        tA = max(tA, min(u, v));\n        tB = min(tB, max(u, v));\n      } else if (abs(p2) > hl) tB = -1e9;\n      if (abs(DZ) > 1e-9) {\n        const u = (-hz - OZ) / DZ, v = (hz - OZ) / DZ;\n        tA = max(tA, min(u, v));\n        tB = min(tB, max(u, v));\n      } else if (abs(OZ) > hz) tB = -1e9;\n      // Where the ray meets the level plane.\n      const tp = (OY - h) / SA;\n      let R = 0, G = 0, B = 0, ghost = -1e9, solid = -1e9, cap = false, ls = 0;\n      if (tA \u003c tB) {\n        const above = dir > 0 ? -1 : 1;\n        // Before the plane the ray is above it. Sweeping up, that is ghost.\n        if (tA \u003c tp) {\n          const t = march(tA, min(tB, tp));\n          if (above \u003c 0) ghost = t;\n          else solid = t;\n        }\n        if (tp >= tA && tp \u003c= tB) {\n          const x = OX + DX * tp, z = OZ + DZ * tp, v = sdfG(x, h, z);\n          if (v \u003c 0 && dir > 0) cap = true;\n          // The cut's edge, a line one LED wide whatever its slope on the panel.\n          const gX = GR[0] * cp + GR[2] * sp, gZ = -GR[0] * sp + GR[2] * cp, gs = sqrt(gX * gX + (gZ * gZ) / (SA * SA)) / s;\n          ls = gs > 1e-6 ? cl(1.3 - abs(v) / gs, 0, 1) : 0;\n        }\n        if (!cap && solid \u003c -1e8 && ((dir > 0) || ghost \u003c -1e8)) {\n          const t = march(max(tA, tp), tB);\n          if (dir > 0) solid = t;\n          else ghost = t;\n        }\n      }\n      if (solid > -1e8) {\n        sdfG(OX + DX * solid, OY + DY * solid, OZ + DZ * solid);\n        const nl = GR[0] * lx + GR[1] * lyn + GR[2] * lz, nv = -(GR[0] * DX + GR[1] * DY + GR[2] * DZ);\n        // Five flat bands of light, and a brighter band where the surface\n        // turns away along the outline.\n        let v = 0.16 + 0.84 * max(0, nl);\n        v = (floor(v * 5) + 1) / 5;\n        if (nv \u003c 0.3) v = max(v, 0.6);\n        R = C[0] * v;\n        G = C[1] * v;\n        B = C[2] * v;\n      } else if (cap) {\n        R = C[6];\n        G = C[7];\n        B = C[8];\n      }\n      if (ghost > -1e8) {\n        sdfG(OX + DX * ghost, OY + DY * ghost, OZ + DZ * ghost);\n        const nl = GR[0] * lx + GR[1] * lyn + GR[2] * lz;\n        const v = nl > 0.35 ? 0.24 : 0.16;\n        R = R * 0.6 + C[3] * v;\n        G = G * 0.6 + C[4] * v;\n        B = B * 0.6 + C[5] * v;\n      }\n      // The plane: a faint pane, its near and far edges a little brighter.\n      const Zw = b * SA + tp * CA;\n      if (abs(Zw) \u003c pr && (dir > 0 || solid \u003c -1e8)) {\n        const e = (pr - abs(Zw)) * s * SA, f = e \u003c 1 ? 0.2 : 0.05;\n        R += f * 0.6;\n        G += f * 0.65;\n        B += f * 0.8;\n      }\n      if (ls > 0) {\n        R += (C[9] - R) * ls;\n        G += (C[10] - G) * ls;\n        B += (C[11] - B) * ls;\n      }\n      buf[o] = R;\n      buf[o + 1] = G;\n      buf[o + 2] = B;\n    }\n  }\n  // The Reeb graph: every edge between two levels the plane has passed,\n  // through the middle of the chain.\n  ov.fill(0);\n  const P = S.graph, NX = P.NX, NY = P.NY, sx = (x, z) => 32 + (x * cp + z * sp) * s - 0.5;\n  const sy = (x, y, z) => 63.5 - ((y * CA + (-x * sp + z * cp) * SA) - S.bc) * s;\n  for (let i = 0; i \u003c P.EA.length; i++) {\n    const a = P.EA[i], c = P.EB[i];\n    const ya = NY[a], yb = NY[c];\n    if (dir > 0 ? yb > h : ya \u003c h) continue;\n    const x0 = sx(NX[a], 0), y0 = sy(NX[a], ya, 0), x1 = sx(NX[c], 0), y1 = sy(NX[c], yb, 0);\n    const len = max(abs(x1 - x0), abs(y1 - y0)), n = ceil(len / 0.4) + 1;\n    for (let j = 0; j \u003c= n; j++) dot(ov, x0 + ((x1 - x0) * j) / n, y0 + ((y1 - y0) * j) / n, 1);\n  }\n  // Where each piece of the cut shrinks to now: the graph's growing tips.\n  for (let p = 0; p \u003c W * H; p++) {\n    const w = ov[p];\n    if (w \u003c= 0) continue;\n    const o = p * 3;\n    buf[o] += (C[12] - buf[o]) * w;\n    buf[o + 1] += (C[13] - buf[o + 1]) * w;\n    buf[o + 2] += (C[14] - buf[o + 2]) * w;\n  }\n  // Each piece of the cut at the plane, shrunk to its point: the tips the\n  // graph grows from.\n  const lv = floor((h - S.yLo) / P.dy - 0.5) + (dir > 0 ? 0 : 1);\n  if (lv >= 0 && lv \u003c P.L0.length - 1)\n    for (let a = P.L0[lv]; a \u003c P.L0[lv + 1]; a++) {\n      const fx = sx(NX[a], 0), fy = sy(NX[a], NY[a], 0);\n      for (let j = -1; j \u003c= 1; j++)\n        for (let i = -1; i \u003c= 1; i++) {\n          const x = Math.round(fx) + i, y = Math.round(fy) + j;\n          if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || (i && j)) continue;\n          const o = (y * W + x) * 3;\n          buf[o] = buf[o + 1] = buf[o + 2] = 1;\n        }\n    }\n  // Critical points the plane has passed: a dot in the colour of their\n  // index, a ring that opens and fades as the plane crosses them, and a tick\n  // at their height on the ruler down the left edge.\n  const K = P.C;\n  for (let i = 0; i \u003c P.age.length; i++) {\n    if (!P.was[i]) continue;\n    let idx = K[3 * i + 2];\n    if (dir \u003c 0) idx = 2 - idx;\n    const co = idx === 0 ? 15 : idx === 1 ? 18 : 21;\n    const fx = sx(K[3 * i], 0), fy = sy(K[3 * i], K[3 * i + 1], 0), cx = Math.round(fx), cy = Math.round(fy);\n    const put = (x, y, w) => {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n      const o = (y * W + x) * 3;\n      buf[o] += (C[co] - buf[o]) * w;\n      buf[o + 1] += (C[co + 1] - buf[o + 1]) * w;\n      buf[o + 2] += (C[co + 2] - buf[o + 2]) * w;\n    };\n    put(cx, cy, 1);\n    put(cx - 1, cy, 1);\n    put(cx + 1, cy, 1);\n    put(cx, cy - 1, 1);\n    put(cx, cy + 1, 1);\n    const ag = P.age[i];\n    if (ag >= 0 && ag \u003c 0.8) {\n      const r = 1.5 + 9 * ag, w = 1 - ag / 0.8;\n      for (let k = 0; k \u003c 40; k++) put(Math.round(fx + r * cos((k / 40) * 2 * PI)), Math.round(fy + r * sin((k / 40) * 2 * PI) * 0.8), w);\n    }\n    const ty = Math.round(63.5 - (K[3 * i + 1] * CA - S.bc) * s);\n    put(0, ty, 1);\n    put(1, ty, 1);\n  }\n  const hy = Math.round(63.5 - (h * CA - S.bc) * s);\n  for (let x = 0; x \u003c 3; x++) {\n    const o = (cl(hy, 0, H - 1) * W + x) * 3;\n    buf[o] = buf[o + 1] = buf[o + 2] = 1;\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o] * 255) | 0, min(255, buf[o + 1] * 255) | 0, min(255, buf[o + 2] * 255) | 0);\n}\n","stochastic-resonance":"// ===== Patternflow pattern =====\n// Title:   Stochastic Resonance\n// Family:  rhythm\n// Idea:    Sixty particles each sit in their own copy of the double well V(x) = -x^2/2 + x^4/4, drawn at the top rocking under a periodic push too weak to tip anyone over the hump while white noise kicks them about, and below it every particle's well is written down one row per moment and sinks away, so at the noise where the Kramers escape time is half the push's period the record turns into violet and amber bands in time with the beat, a rhythm made out of noise.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: stochastic resonance (Roberto Benzi, Alfonso Sutera and Angelo Vulpiani, 1981), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=-1..1, Drive=0.55..0.95\n//\n// Knob 1: Hue. Turns both wells' colours round the wheel a third apart, the one nearer blue drawn dim; the curve stays white. At 0 the left well is a dim violet and the right amber, at 0.25 bright red and dim green, at 0.5 lime and dim azure, at 0.75 dim teal and magenta.\n// Knob 2: Speed. Rows of the record a second, six times the knob: 12 at 2, so the push beats once every 2 seconds and the 97-row record holds four beats; at 0.2 a beat takes 20 seconds, at 3 it takes 1.3.\n// Knob 3: Noise. The noise strength D, 0.079 times 3 to the knob. At 0, D = 0.079, where the Kramers time 4.44 e^(0.25/D) is exactly half the push's period, each particle hops about twice a beat and the record is bands; the white bar along the top row, the response at the push's frequency over the newest four beats, stands at about 0.79 of a perfect square wave. At -1 (D = 0.026) a particle hops once in about three beats, the record is long stripes down the panel and the bar shrinks to 0.16; at -0.5 most hops land in time but beats are skipped; at 0.5 (D = 0.137) they hop four times a beat; at 1 (D = 0.237) the record is speckle and the bar is back to 0.52.\n// Knob 4: Drive. The push's amplitude as a share of the static threshold 2/(3 sqrt 3) = 0.385, below which a still particle never leaves its well: 0.55 at the start (A = 0.21), 0.95 at the end (A = 0.37), where the hump nearly flattens at each beat and even the quiet setting locks.\n// Buttons: K1 tap throws every particle into a well at random, and the record shows the beat pulling them back into step.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, log, cos, sin, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The double well: barrier dV = 1/4 between minima at x = +-1, curvature 2\n// at the minima and 1 on the hump, so the Kramers escape time is\n// (2 pi / sqrt 2) e^(dV / D).\nconst DV = 0.25;\n// Push frequency in the particles' own time. One beat is 209 time units,\n// 419 relaxation times of a well, so the particles feel it as slow. A faster\n// push (0.1) put the resonance at D = 0.128 with A/D only 1.6, and the bands\n// came out ragged; at 0.03 the resonant D is 0.079 and the bands are clean.\nconst OMEGA = 0.03;\nconst PERIOD = TAU / OMEGA;\n// Time-scale matching: the D at which the Kramers time is half a beat.\nconst DSTAR = DV / log(1 / (Math.SQRT2 * OMEGA));\n// The static threshold: the push that removes the hump of a still particle.\nconst ACRIT = 2 / (3 * sqrt(3));\n// Rows of the record per beat, and rows per second for each unit of Speed.\nconst ROWS_PER_BEAT = 24, RATE = 6;\nconst ROWT = PERIOD / ROWS_PER_BEAT;\n// Euler-Maruyama step: the well's stiffness 3x^2 - 1 is at most 19 inside\n// the clamp at |x| = 2.6, and h = 0.06 keeps 19 h under the limit of 2.\nconst HSTEP = 0.06;\n\n// Sixty particles in columns 2..61; columns 0 and 63 carry the push.\nconst N = 60, X0 = 2;\n// The well band: rows 0..29. Record rows 31..127, newest at the top.\nconst BAND = 30, R0 = 31, NR = H - R0;\n// The meter reads the newest four beats of the record.\nconst MROWS = 4 * ROWS_PER_BEAT;\n// Column c shows x = (c + 0.5 - 32) / 32 * XS.\nconst XS = 1.6;\n// The curve's height: row = VY - VS * V.\nconst VY = 9.5, VS = 30;\n// Hue of the left well at knob 0, and how far round the right one sits.\nconst HUE0 = 0.76, HUE_GAP = 0.33;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = round(255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p));\n  out[o + 1] = round(255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p));\n  out[o + 2] = round(255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p));\n}\n\n// Normal deviates two at a time, by Box-Muller.\nlet spare = 0, hasSpare = false;\nfunction gauss() {\n  if (hasSpare) {\n    hasSpare = false;\n    return spare;\n  }\n  let u = Math.random();\n  if (u \u003c 1e-12) u = 1e-12;\n  const r = sqrt(-2 * log(u)), a = TAU * Math.random();\n  spare = r * sin(a);\n  hasSpare = true;\n  return r * cos(a);\n}\n\n// How near a hue is to blue (0.62), 0 at the far side of the wheel.\nconst coolness = (h) => {\n  const d = abs(h - floor(h) - 0.62);\n  return 0.5 - min(d, 1 - d);\n};\n\nconst V = (x, f) => -0.5 * x * x + 0.25 * x * x * x * x - f * x;\n\nfunction scatter(S) {\n  for (let i = 0; i \u003c N; i++) {\n    const w = Math.random() \u003c 0.5 ? -1 : 1;\n    S.x[i] = w + 0.2 * gauss();\n    S.s[i] = w;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, D: DSTAR, A: 0.55 * ACRIT, begun: false,\n    // Position and well (-1 left, 1 right) of each particle, the particles'\n    // clock, and the time left to the next record row.\n    x: new Float32Array(N), s: new Int8Array(N), t: 0, toRow: ROWT,\n    // The record as a ring: one byte per particle per row (1 = right well),\n    // and the push's sign for each row. head is the newest row.\n    rec: new Uint8Array(NR * N), push: new Int8Array(NR), head: 0,\n    // Each row's mean well (-1..1) and the push's phase when it was written,\n    // and the response at the push's frequency over the last four beats.\n    mean: new Float32Array(NR), phase: new Float32Array(NR), R: 0,\n    col: new Uint8Array(12), curve: new Int16Array(W), pile: new Uint8Array(W),\n  };\n  scatter(params.s);\n}\n\n// Start with a full record, as if the particles had been running at these\n// knobs for four beats already.\nfunction prefill(S) {\n  for (let r = 0; r \u003c NR; r++) {\n    run(S, ROWT);\n    writeRow(S);\n  }\n  S.begun = true;\n}\n\n// Advance every particle by time T: dx = (x - x^3 + A cos(w t)) dt + sqrt(2D) dW.\n// A particle changes well only once it is past +-0.5, so jitter on the hump\n// is not counted as a hop.\nfunction run(S, T) {\n  const n = Math.max(1, round(T / HSTEP)), h = T / n, kick = sqrt(2 * S.D * h), x = S.x, s = S.s;\n  for (let k = 0; k \u003c n; k++) {\n    const f = S.A * cos(OMEGA * S.t);\n    for (let i = 0; i \u003c N; i++) {\n      let xi = x[i];\n      xi += (xi - xi * xi * xi + f) * h + kick * gauss();\n      xi = cl(xi, -2.6, 2.6);\n      x[i] = xi;\n      if (xi > 0.5) s[i] = 1;\n      else if (xi \u003c -0.5) s[i] = -1;\n    }\n    S.t += h;\n  }\n}\n\nfunction writeRow(S) {\n  S.head = (S.head + NR - 1) % NR;\n  const o = S.head * N;\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) {\n    S.rec[o + i] = S.s[i] > 0 ? 1 : 0;\n    m += S.s[i];\n  }\n  const ph = OMEGA * S.t;\n  S.push[S.head] = cos(ph) >= 0 ? 1 : -1;\n  S.mean[S.head] = m / N;\n  S.phase[S.head] = ph;\n  // The meter: the first Fourier coefficient of the mean well over four\n  // whole beats, |(2/n) sum m e^(-i w t)|, as a share of the 4/pi a square\n  // wave in perfect step would give.\n  let re = 0, im = 0;\n  for (let r = 0; r \u003c MROWS; r++) {\n    const k = (S.head + r) % NR;\n    re += S.mean[k] * cos(S.phase[k]);\n    im += S.mean[k] * sin(S.phase[k]);\n  }\n  S.R = ((2 / MROWS) * sqrt(re * re + im * im)) / (4 / PI);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.55];\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.D = DSTAR * Math.pow(3, cl(kv[2], -1, 1));\n  S.A = cl(kv[3], 0.55, 0.95) * ACRIT;\n  if (!S.begun) prefill(S);\n  if (input.btnPressed && input.btnPressed[0]) scatter(S);\n  // Particle time this frame; a record row each time it passes a row mark.\n  let T = cl(dt || 0, 0, 0.1) * S.speed * RATE * ROWT;\n  while (T > 0) {\n    const step = min(T, S.toRow);\n    run(S, step);\n    T -= step;\n    S.toRow -= step;\n    if (S.toRow \u003c= 1e-9) {\n      writeRow(S);\n      S.toRow += ROWT;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const C = S.col;\n  // Left well, right well, and the same two lighter for the particles. Of\n  // the two hues the one nearer blue is drawn dim: a dim red or yellow\n  // turns to maroon and olive on the panel, a dim blue or violet does not.\n  const ha = HUE0 + S.hue, hb = ha + HUE_GAP;\n  const dimA = coolness(ha) >= coolness(hb);\n  hsv(ha, dimA ? 0.72 : 0.86, dimA ? 0.5 : 1, C, 0);\n  hsv(hb, dimA ? 0.86 : 0.72, dimA ? 1 : 0.5, C, 3);\n  hsv(ha, 0.55, 1, C, 6);\n  hsv(hb, 0.6, 1, C, 9);\n\n  // The well band. The curve under the push now, one row per column.\n  const f = S.A * cos(OMEGA * S.t), cv = S.curve;\n  for (let c = 0; c \u003c W; c++) cv[c] = round(VY - VS * V(((c + 0.5 - 32) / 32) * XS, f));\n  // Ground under the curve: deep navy, so the well reads as a shape.\n  for (let c = 0; c \u003c W; c++) {\n    const top = max(0, cv[c] + 1);\n    for (let y = top; y \u003c BAND; y++) display.setPixel(c, y, 18, 12, 46);\n  }\n  // The curve itself, joined to its neighbours so the steep walls stay whole.\n  for (let c = 0; c \u003c W; c++) {\n    const a = cv[c], b = c ? cv[c - 1] : a, c1 = c \u003c W - 1 ? cv[c + 1] : a;\n    const lo = min(a, round((a + b) / 2), round((a + c1) / 2)), hi = max(a, round((a + b) / 2), round((a + c1) / 2));\n    for (let y = max(0, lo); y \u003c= min(BAND - 1, hi); y++) display.setPixel(c, y, 210, 210, 225);\n  }\n  // Particles resting on the curve, piled up where they crowd.\n  const pile = S.pile;\n  pile.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const c = cl(floor((S.x[i] / XS + 1) * 32), 0, W - 1);\n    const y = cv[c] - 1 - pile[c]++;\n    if (y \u003c 0 || y >= BAND) continue;\n    const o = S.s[i] > 0 ? 9 : 6;\n    display.setPixel(c, y, C[o], C[o + 1], C[o + 2]);\n  }\n\n  // The meter along the top row, out from the middle both ways: 56 LEDs\n  // wide when the record is a square wave in perfect step with the push.\n  const mw = round(cl(S.R, 0, 1) * 28);\n  for (let c = 32 - mw; c \u003c 32 + mw; c++) display.setPixel(c, 0, 150, 150, 165);\n\n  // The record: newest row at the top, sinking a row at a time.\n  for (let r = 0; r \u003c NR; r++) {\n    const y = R0 + r, ring = (S.head + r) % NR, o = ring * N;\n    // The push's direction down both edges, in the colour of the well it favours.\n    const pc = S.push[ring] > 0 ? 3 : 0;\n    display.setPixel(0, y, C[pc], C[pc + 1], C[pc + 2]);\n    display.setPixel(W - 1, y, C[pc], C[pc + 1], C[pc + 2]);\n    for (let i = 0; i \u003c N; i++) {\n      const k = S.rec[o + i] ? 3 : 0;\n      display.setPixel(X0 + i, y, C[k], C[k + 1], C[k + 2]);\n    }\n  }\n}\n","vampire-coffin":"// ===== Patternflow pattern =====\n// Title:   Vampire Coffin\n// Family:  halloween\n// Idea:    An upright wooden coffin stands in a dim purple crypt under a moonlit lancet window, between two candles on iron stands and under cobwebbed vaulting, and every few seconds its lid creaks open a few degrees at a time on its hinge while cold green mist pours from the black crack and two red eyes peer out, then the lid swings wide towards us and a swarm of bats bursts out and wheels up through the vault and out of the top, the eyes blink and the lid slams shut, mist puffs from the seams, dust sifts down and the candle flames flatten in the draught and recover.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bats=24..72, Mist=0..1\n//\n// Knob 1: Hue. The mist and its light, with the eyes a third of the wheel behind; the candles, wood and stone keep their colours. At 0 toxic green mist and red eyes, at 0.25 sky-blue mist and lime eyes, at 0.5 magenta mist and cyan eyes, at 0.75 orange mist and violet eyes.\n// Knob 2: Speed. The crypt's clock. At 2 an opening takes about 6.5 s: four creaks 0.6 to 0.75 s apart, the swing wide 0.45 s, the slam 2.7 s after it, and the bats all gone out of the top within about 4 s; the first burst comes at 1.3 s. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Bats. How many bats burst out each time: 24 at the start, 36 at a quarter, 48 at half, 72 at the end. One in three swings close past us as a big 13-LED bat; the far side of each turn is small and dark.\n// Knob 4: Mist. How much mist pours while the lid is open, in puffs a second: 21 at 0, a thin stream that fades on the floor; 33 at 0.06 (the start); 46 at 0.25, a steady fall spreading both ways along the flagstones; 70 at 1, a glowing bank across the whole floor. Each burst adds a rush of 1.7 times as much for 1.2 s.\n// Buttons: K1 tap swings the lid wide and lets the bats out at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n// Colour buffers, three floats an LED: set, blend towards, add.\nconst set = (C, p, r, g, b) => ((C[3 * p] = r), (C[3 * p + 1] = g), (C[3 * p + 2] = b));\nconst mix = (C, p, r, g, b, a) => ((C[3 * p] += (r - C[3 * p]) * a), (C[3 * p + 1] += (g - C[3 * p + 1]) * a), (C[3 * p + 2] += (b - C[3 * p + 2]) * a));\nconst add = (C, p, r, g, b, a) => ((C[3 * p] += r * a), (C[3 * p + 1] += g * a), (C[3 * p + 2] += b * a));\n\n// The crypt: the floor starts at row 108. The coffin stands on it, a\n// six-sided box from row 26 (head) through its shoulders at 46 to its foot\n// at 106, centred on x = 32; hw gives its half width on a row.\nconst FLOOR = 108, CT = 26, CS = 46, CB = 106, CX = 32;\nconst hw = (y) => (y \u003c CS ? 8 + (6 * (y - CT)) / (CS - CT) : 14 - (6 * (y - CS)) / (CB - CS));\n// The lid hinges on the vertical line through the left shoulder, is 2.5\n// LEDs thick, and comes towards a viewer 150 LEDs away at eye height 66.\nconst HX = CX - 14, THK = 2.5, VIEW = 150, VY = 66;\n// The candles: flame x, the row the flame stands on, and which way it\n// leans in the draught from the coffin.\nconst CANDLE = [[6, 53, -1], [58, 53, 1]];\n\n// ---------- the still crypt, drawn once ----------\nconst BG = new Float32Array(N * 3), LIT = new Float32Array(N), HALO = [new Float32Array(N), new Float32Array(N)];\nconst put = (x, y, r, g, b, a) => x >= 0 && x \u003c W && y >= 0 && y \u003c H && mix(BG, y * W + x, r, g, b, a);\nfunction line(x0, y0, x1, y1, r, g, b, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0)) * 2 + 1;\n  for (let i = 0; i \u003c= n; i++) put(round(x0 + ((x1 - x0) * i) / n), round(y0 + ((y1 - y0) * i) / n), r, g, b, a);\n}\n// Inside the pointed arch of the vault (springing at row 44), and inside the\n// lancet window above the coffin, grown by g.\nconst inVault = (x, y) => y >= 44 || ((x - 63.5) ** 2 + (y - 44) ** 2 \u003c= 3969 && (x - 0.5) ** 2 + (y - 44) ** 2 \u003c= 3969);\nconst inWindow = (x, y, g) => y \u003c= 24 + g && x >= 24 - g && x \u003c= 40 + g && (y >= 14 || ((x - 40 - g) ** 2 + (y - 14) ** 2 \u003c= (16 + 2 * g) ** 2 && (x - 24 + g) ** 2 + (y - 14) ** 2 \u003c= (16 + 2 * g) ** 2));\nconst ROWS = [108, 111, 115, 120, 126];\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x, px = x + 0.5, py = y + 0.5;\n    let r = 14, g = 8, b = 21, lit = 0.6;\n    if (y >= FLOOR) {\n      // Flagstones in perspective towards (32, 70).\n      const k = ROWS.filter((v) => y >= v).length - 1, sc = (py - 70) / 38, u = (px - 32) / (11 * sc) + (k % 2) * 0.5;\n      const v = ROWS.includes(y) || u - floor(u) \u003c 0.09 / sc ? 0.45 : 0.8 + 0.25 * round(hash(k * 97 + floor(u) + 50) * 3) / 3;\n      (r = 30 * v), (g = 22 * v), (b = 40 * v), (lit = 1);\n    } else if (inVault(px, py)) {\n      // Stone blocks, 7 rows high and 12 wide, every other course offset,\n      // darker towards the vault; the arch's rib paler.\n      const k = floor(y / 7), u = x + (k % 2) * 6;\n      const v = (y % 7 === 0 || u % 12 === 0 ? 0.5 : 0.82 + 0.24 * round(hash(k * 131 + floor(u / 12)) * 3) / 3) * (0.62 + 0.38 * sm(0, 100, y));\n      (r = 36 * v), (g = 23 * v), (b = 50 * v), (lit = 1);\n      if (!inVault(px - 2, py - 2) || !inVault(px + 2, py - 2)) (r = 46), (g = 32), (b = 60);\n    }\n    if (y === FLOOR - 1) (r *= 0.5), (g *= 0.5), (b *= 0.5);\n    // The window: night sky, the moon, a mullion and a ring of tracery, in\n    // a frame of paler stone.\n    if (inWindow(px, py, 1.5)) (r = 58), (g = 44), (b = 74);\n    if (inWindow(px, py, 0)) {\n      const md = sqrt((px - 36) ** 2 + (py - 10.5) ** 2), sky = 0.75 + 0.25 * sm(24, 2, py);\n      (r = 44 * sky), (g = 40 * sky), (b = 92 * sky), (lit = 0);\n      if (md \u003c 4) (r = 205), (g = 196), (b = 225);\n      else if (md \u003c 6) (r += 30), (g += 28), (b += 36);\n      if ((abs(px - 32) \u003c 0.8 && py > 8.5) || abs(sqrt((px - 32) ** 2 + (py - 6) ** 2) - 2.6) \u003c 0.7) (r = 30), (g = 22), (b = 40);\n    }\n    // Moonlight falling from the window down the wall, in two steps.\n    if (y > 25 && y \u003c 64 && abs(px - 33) \u003c 9 + (py - 25) * 0.35) {\n      const m = py \u003c 44 ? 1 : 0.5;\n      (r += 9 * m), (g += 8 * m), (b += 16 * m);\n    }\n    set(BG, p, r, g, b);\n    LIT[p] = lit;\n  }\n// Cobwebs in both upper corners: radial threads with sagging cross threads.\nfor (const side of [0, 1]) {\n  const X = (x) => (side ? 63 - x : x), A = [0.08, 0.42, 0.78, 1.1, 1.45], at = (r, a) => [X(round(r * cos(a))), round(r * sin(a))];\n  for (const a of A) line(X(0), 0, ...at(24, a), 92, 86, 110, 0.55);\n  for (const rr of [6, 11, 16, 21])\n    for (let i = 0; i \u003c 4; i++) {\n      const m = at(rr * 0.86, (A[i] + A[i + 1]) / 2);\n      line(...at(rr, A[i]), ...m, 92, 86, 110, 0.4);\n      line(...m, ...at(rr, A[i + 1]), 92, 86, 110, 0.4);\n    }\n}\n// The iron stands, and on each a pillar of wax 4 wide, lit from above,\n// with drips down its side.\nfor (const [cx] of CANDLE) {\n  const x0 = cx - 1;\n  for (let y = 64; y \u003c FLOOR + 2; y++) put(x0, y, 24, 22, 28, 1), put(x0 + 1, y, 44, 40, 50, 1);\n  line(x0, FLOOR, x0 - 4, FLOOR + 5, 30, 28, 34, 1);\n  line(x0 + 1, FLOOR, x0 + 5, FLOOR + 5, 30, 28, 34, 1);\n  for (let x = cx - 4; x \u003c= cx + 3; x++) put(x, 63, 40, 36, 44, 1), put(x, 64, 28, 26, 32, x > cx - 4 && x \u003c cx + 3 ? 1 : 0);\n  for (let y = 54; y \u003c 63; y++)\n    for (let x = cx - 2; x \u003c= cx + 1; x++) {\n      const v = (x === cx - 2 ? 0.75 : x === cx + 1 ? 0.62 : 0.9) * (1.05 - (y - 54) * 0.04);\n      put(x, y, 200 * v, 178 * v, 140 * v, 1);\n    }\n  put(cx - 3, 56, 170, 150, 120, 1);\n  put(cx - 3, 57, 150, 132, 104, 1);\n  put(cx + 2, 55, 160, 140, 112, 1);\n}\n// The warm light each candle throws, in rings 3.5 LEDs apart.\nconst RING = [0.55, 0.42, 0.31, 0.22, 0.15, 0.09, 0.05];\nCANDLE.forEach(([cx, cy], i) => {\n  for (let p = 0; p \u003c N; p++) HALO[i][p] = RING[floor(sqrt(((p % W) + 0.5 - cx) ** 2 + ((floor(p / W) + 2.5 - cy) * 0.8) ** 2) / 3.5)] || 0;\n});\n\n// Bats in three sizes, three wing poses each: up, level, down.\nconst SPR = [\n  [[\"#.....#\", \".#.#.#.\", \"..###..\", \"...#...\"], [\"..#.#..\", \"#######\", \"#..#..#\", \".......\"], [\"..#.#..\", \".#####.\", \"#..#..#\", \"#.....#\"]],\n  [[\"#.......#\", \"##.#.#.##\", \".#######.\", \"...###...\", \"....#....\"], [\"...#.#...\", \".#######.\", \"#########\", \"#..###..#\", \"....#....\"], [\"...#.#...\", \"...###...\", \".#######.\", \"##.###.##\", \"#...#...#\"]],\n  [\n    [\"##.........##\", \".##..#.#..##.\", \"..##.###.##..\", \"...#######...\", \".....###.....\", \"......#......\"],\n    [\".....#.#.....\", \".....###.....\", \".###########.\", \"#############\", \"##...###...##\", \"#.....#.....#\"],\n    [\".....#.#.....\", \".....###.....\", \"....#####....\", \"..#########..\", \".##..###..##.\", \"##....#....##\"],\n  ],\n];\nconst MAXB = 72, MAXM = 360, DUST = 30;\nconst F32 = (n) => new Float32Array(n);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, c: 0, hue: 0, speed: 2, bats: 24, mist: 0.06,\n    // The lid: its angle in degrees and the move it is making.\n    th: 0, seg: null, plan: null, draft: 0, shake: 0, eyes: 0, fl: [1, 1], fh: [6, 6], fx: [0, 0],\n    bt: F32(MAXB).fill(-9), bp: F32(4 * MAXB), nb: 0,\n    // Mist puffs: x, y, vx, vy, age, life; dust motes: x, y, age.\n    m: F32(6 * MAXM), nm: 0, macc: 0, dust: F32(3 * DUST).fill(9),\n    C: F32(3 * N), M: F32(N), GL: F32(N), K: new Uint8Array(N), mc: [0, 0, 0], ec: [0, 0, 0],\n  };\n}\n\n// One opening: the lid creaks a few degrees at a time, the eyes come, it\n// swings wide and the bats burst out, the eyes blink, it slams. The panel\n// opens on a lid already creaking, the first burst at 1.3 s; from the third\n// opening on, the coffin sometimes rests up to 2.5 s more.\nconst timesFrom = (P, b) => Object.assign(P, { burst: b, blink2: b + 2.2, slam: b + 2.7, end: b + 3.3 });\nfunction plan(S) {\n  const j = (a) => a + (Math.random() - 0.5) * 3, n = S.plan ? S.plan.n + 1 : 0;\n  let P;\n  if (!n) P = { creaks: [[0.2, j(16)], [0.7, j(34)]], eyes: 0.55, blink: 1, b: 1.3 };\n  else {\n    const t0 = 0.3 + Math.random() * 0.5 + (n > 1 && Math.random() \u003c 0.5 ? 2.5 * Math.random() : 0);\n    P = { creaks: [[t0, j(10)], [t0 + 0.6, j(21)], [t0 + 1.25, j(32)], [t0 + 2, j(44)]], eyes: t0 + 1.3, blink: t0 + 2.3, b: t0 + 2.7 };\n  }\n  S.plan = timesFrom(Object.assign(P, { n, k: 0, burstDone: false, slamDone: false }), P.b);\n}\n\nconst backOut = (u) => 1 + 2.70158 * (u - 1) ** 3 + 1.70158 * (u - 1) ** 2;\nfunction lidAngle(S) {\n  const g = S.seg;\n  if (!g) return S.th;\n  const u = cl((S.c - g.t0) / g.d, 0, 1);\n  // A creak: quick, then slower, with a stick-slip judder.\n  if (g.kind === 0) return g.a0 + (g.a1 - g.a0) * (1 - (1 - u) ** 3) + 0.9 * sin(u * PI * 6) * (1 - u);\n  if (g.kind === 1) return g.a0 + (g.a1 - g.a0) * backOut(u);\n  if (g.kind === 2) return g.a0 * (1 - u * u);\n  return 3.5 * sin(PI * u);\n}\nconst move = (S, d, a1, kind) => (S.seg = { t0: S.c, d, a0: S.th, a1, kind });\n\n// A puff of mist; when the pool is full, a random old one is reused.\nfunction puff(S, x, y, vx, vy) {\n  const o = 6 * (S.nm \u003c MAXM ? S.nm++ : floor(Math.random() * MAXM));\n  S.m.set([x, y, vx, vy, 0, 3.5 + Math.random() * 2.5], o);\n}\n\nfunction burst(S) {\n  const P = S.plan;\n  P.burstDone = true;\n  P.k = P.creaks.length;\n  move(S, 0.45, 106, 1);\n  S.draft = 1;\n  // The swarm: each bat starts somewhere in the dark of the coffin, at its\n  // own moment in the first 0.8 s, and wheels up round a rising centre.\n  S.nb = min(MAXB, round(S.bats));\n  for (let i = 0; i \u003c S.nb; i++) {\n    S.bt[i] = -(i / S.nb) * 0.7 - Math.random() * 0.1;\n    S.bp.set([32 + (Math.random() - 0.5) * 14, 40 + Math.random() * 50, Math.random() * 2 * PI, (Math.random() \u003c 0.8 ? 1 : -1) * (2.2 + Math.random() * 1.4)], 4 * i);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 24, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.bats = cl(k[2], 24, 72);\n  S.mist = cl(k[3], 0, 1);\n  if (!S.plan) plan(S);\n  const ds = (d * S.speed) / 2, P = S.plan;\n  S.t += ds;\n  S.c += ds;\n  if (input.btnPressed && input.btnPressed[0] && !P.burstDone) timesFrom(P, S.c), (P.eyes = min(P.eyes, S.c));\n  // Each creak stirs the air: the flames duck and the coffin breathes out\n  // a little mist.\n  while (P.k \u003c P.creaks.length && S.c >= P.creaks[P.k][0] && S.c \u003c P.burst) {\n    move(S, 0.3, P.creaks[P.k++][1], 0);\n    S.draft = max(S.draft, 0.35);\n    S.macc += 6;\n  }\n  if (!P.burstDone && S.c >= P.burst) burst(S);\n  if (P.burstDone && !P.slamDone && S.c >= P.slam) (P.slamDone = true), move(S, 0.2, 0, 2);\n  if (S.seg && S.seg.kind === 2 && S.c >= S.seg.t0 + S.seg.d) {\n    // The slam lands: the coffin shudders, the lid bounces once, the\n    // flames flatten again, mist squeezes out of the seams and dust is\n    // shaken down from the vault.\n    move(S, 0.3, 0, 3);\n    S.shake = 1;\n    S.draft = max(S.draft, 0.7);\n    for (let i = 0; i \u003c 26; i++) {\n      const y = CT + 4 + Math.random() * (CB - CT - 4), sd = i % 2 ? 1 : -1;\n      puff(S, CX + sd * hw(y), y, sd * (6 + Math.random() * 8), Math.random() * 2);\n    }\n    for (let i = 0; i \u003c DUST; i++) S.dust.set([Math.random() * W, Math.random() * 26, -Math.random() * 0.6], 3 * i);\n  }\n  S.th = lidAngle(S);\n  if (S.c >= P.end) (S.c = 0), plan(S);\n  // The eyes: fade in after the third creak, blink twice, gone at the slam.\n  const blink = (t) => S.c > t && S.c \u003c t + 0.16;\n  S.eyes = S.c \u003c P.eyes || P.slamDone ? 0 : sm(P.eyes, P.eyes + 0.45, S.c) * (blink(P.blink) || blink(P.blink2) ? 0 : 1);\n  S.draft *= exp(-ds * 1.3);\n  S.shake *= exp(-ds * 9);\n  // The flames: two noises each, flattened and pushed outwards by the draught.\n  for (let i = 0; i \u003c 2; i++) {\n    const n1 = vn(S.t * 4.3, 11 + i * 5), n2 = vn(S.t * 11, 23 + i * 7), dr = S.draft;\n    S.fh[i] = 7 + 1.3 * n1 + 0.6 * n2 - 4 * dr;\n    S.fx[i] = 0.7 * vn(S.t * 2.2, 41 + i) + CANDLE[i][2] * dr * (3.5 + 0.8 * sin(S.t * 13));\n    S.fl[i] = 0.82 + 0.16 * n1 + 0.1 * n2 - 0.45 * dr;\n  }\n  for (let i = 0; i \u003c S.nb; i++) if (S.bt[i] > -5) S.bt[i] += ds;\n  // Mist: poured from the gap while the lid is open, a wisp now and then\n  // through the seams when it is shut.\n  const ca = cos((min(S.th, 90) * PI) / 180), open = sm(0, 0.3, sqrt(1 - ca * ca));\n  const amount = 0.3 + 0.7 * sqrt(S.mist), surge = P.burstDone && S.c \u003c P.burst + 1.2 ? 1 : 0;\n  S.macc += ds * amount * (70 * open + 120 * surge + 3);\n  const gapL = HX + 28 * ca;\n  for (; S.macc >= 1; S.macc--) {\n    const x = S.th > 50 ? CX + (Math.random() - 0.5) * 16 : min(gapL + Math.random() * (CX + 14 - gapL), CX + 10);\n    puff(S, x, open > 0.05 ? 70 + Math.random() * 34 : CB - 1, (Math.random() - 0.3) * 4, 3 + Math.random() * 6);\n  }\n  const D = S.dust;\n  for (let i = 0; i \u003c DUST; i++)\n    if (D[3 * i + 2] \u003c 3) (D[3 * i + 2] += ds), (D[3 * i + 1] += ds * (7 + (i % 4))), (D[3 * i] += ds * 3 * sin(S.t * 2 + i));\n  const m = S.m;\n  for (let i = 0; i \u003c S.nm; i++) {\n    const o = 6 * i;\n    if (m[o + 4] >= m[o + 5]) continue;\n    m[o + 4] += ds;\n    if (m[o + 1] \u003c FLOOR + 2 + (i % 9)) {\n      // Cold mist sinks down the coffin's front.\n      m[o + 3] = min(16, m[o + 3] + 20 * ds);\n    } else {\n      // On the floor it spreads outwards and lifts a little as it thins.\n      m[o + 3] += (-1.5 - m[o + 3]) * min(1, 4 * ds);\n      m[o + 2] += ((m[o] \u003c CX ? -1 : 1) * (7 + (i % 5) * 2.5) - m[o + 2]) * min(1, 1.5 * ds);\n    }\n    m[o] += (m[o + 2] + 2.4 * vn(S.t * 1.3 + i, 77)) * ds;\n    m[o + 1] += m[o + 3] * ds;\n  }\n}\n\n// Where the lid face at offset off (0 front, THK back) meets the LED, in\n// the lid's own closed coordinates, or null.\nfunction lidHit(px, py, off, c, s) {\n  const u = (px - HX - off * s) / (abs(c) \u003c 0.03 ? (c \u003c 0 ? -0.03 : 0.03) : c);\n  if (u \u003c 0 || u > 29) return null;\n  const y = VY + ((py - VY) * (VIEW - (u * s - off * c))) / VIEW, x = HX + u;\n  return y \u003c CT || y > CB || abs(x - CX) > hw(y) ? null : [x, y];\n}\n// Distance inside the coffin's outline.\nconst inset = (x, y) => min(hw(y) - abs(x - CX), y - CT, CB - y);\n// Buttoned satin, on a diamond grid 4 LEDs across, times v.\nfunction satin(x, y, v) {\n  const a = (x + y) / 4, b = (x - y) / 4, fa = a - floor(a) - 0.5, fb = b - floor(b) - 0.5;\n  v *= fa * fa + fb * fb \u003c 0.03 ? 0.45 : abs(fa) + abs(fb) \u003c 0.3 ? 1.05 : 0.75;\n  return [84 * v, 10 * v, 30 * v];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const C = S.C, M = S.M, GL = S.GL, K = S.K, MC = hsv(0.33 + S.hue, 0.62, 1, S.mc), EC = hsv(S.hue, 0.9, 1, S.ec);\n  C.set(BG);\n  K.fill(0);\n  const th = (S.th * PI) / 180, c = cos(th), s = sin(th), sx = round(S.shake * 1.4 * sin(S.t * 70));\n  const open = sm(0, 0.4, sin(min(th, PI / 2))), shade = 0.2 + 0.8 * sm(45, 95, S.th);\n  // The coffin's box: its right side, then the inside, which only shows\n  // where the lid is not. Barely open, the lid keeps the inside in shadow,\n  // a black crack.\n  for (let y = CT; y \u003c CB; y++)\n    for (let x = 14; x \u003c 50; x++) {\n      const p = y * W + x, px = x + 0.5 - sx, py = y + 0.5, e = hw(py), dx = px - CX;\n      if (dx > e && dx \u003c e + 2.2) {\n        const v = py \u003c CT + 1.5 ? 1.4 : 1;\n        set(C, p, 36 * v, 17 * v, 15 * v);\n        K[p] = 1;\n      } else if (abs(dx) \u003c= e) {\n        const d = inset(px, py), gl = open * 0.3 * sm(50, CB, py);\n        K[p] = 2;\n        if (d \u003c 1) set(C, p, 60 * shade, 28 * shade, 22 * shade);\n        else if (d \u003c 3.4) set(C, p, ...satin(px, py, shade));\n        // The black inside, with the mist's glow rising from the bottom.\n        else set(C, p, 4 + MC[0] * gl, 2 + MC[1] * gl, 6 + MC[2] * gl);\n      }\n    }\n  // The eyes, at head height in the dark: peering out of the gap while it\n  // is narrow, in the middle once the lid is wide.\n  if (S.eyes > 0.01) {\n    const e = CX + hw(37), mid = max(CX, (HX + (e - HX) * c + e) / 2 - 0.5), ex = CX + (mid - CX) * (1 - sm(35, 70, S.th));\n    for (const ox of [-1.5, 1.5])\n      for (let yy = -2; yy \u003c= 2; yy++)\n        for (let xx = -2; xx \u003c= 2; xx++) {\n          const p = (37 + yy) * W + floor(ex + ox + sx) + xx;\n          if (K[p] === 2) mix(C, p, EC[0], EC[1] * 0.6, EC[2] * 0.6, (xx || yy ? 0.4 / (xx * xx + yy * yy + 0.5) : 1) * S.eyes);\n        }\n  }\n  // The lid, swung th about its hinge: the face towards us (wood in front,\n  // satin behind), and the slab's edge where only the other face reaches.\n  const front = c >= 0;\n  for (let y = CT - 10; y \u003c= CB + 10; y++)\n    for (let x = front ? HX - 2 : 6; x \u003c 50; x++) {\n      const p = y * W + x, px = x + 0.5 - sx, py = y + 0.5, h = lidHit(px, py, front ? 0 : THK, c, s);\n      if (h) {\n        const [lx, ly] = h, d = inset(lx, ly);\n        if (front) {\n          // Planks running the length of the lid, a carved moulding 3 in\n          // from the edge, two iron hinge straps and a ring; it darkens as\n          // it turns from the light.\n          const sh = 0.6 + 0.4 * c, v = (d > 2.5 && d \u003c 3.5 ? 1.35 : d >= 3.5 && d \u003c 4.5 ? 0.6 : 0.85 + 0.2 * round(hash(floor(lx) * 31 + floor(ly / 13)) * 2) / 2) * sh;\n          if (lx - (CX - hw(ly)) \u003c 3.5 && lx - HX \u003c 4 && ((ly > 36 && ly \u003c 39) || (ly > 92 && ly \u003c 95))) set(C, p, 46 * sh, 44 * sh, 54 * sh);\n          else if (abs(lx - (CX + hw(ly) - 3)) \u003c 1 && abs(ly - 68) \u003c 1.5) set(C, p, 56 * sh, 52 * sh, 62 * sh);\n          else set(C, p, 76 * v, 37 * v, 29 * v);\n        } else {\n          const sh = 0.55 - 0.45 * c;\n          if (d \u003c 1.6) set(C, p, 50 * sh, 24 * sh, 20 * sh);\n          else set(C, p, ...satin(lx, ly, sh));\n        }\n      } else if (lidHit(px, py, front ? THK : 0, c, s)) set(C, p, 92, 50, 36);\n      else continue;\n      K[p] = 1;\n    }\n  // Candlelight on everything but the dark inside of the coffin.\n  for (let p = 0; p \u003c N; p++) {\n    const l = (HALO[0][p] * S.fl[0] + HALO[1][p] * S.fl[1]) * (K[p] === 2 ? 0.1 : K[p] === 1 ? 0.8 : LIT[p]);\n    if (l > 0) add(C, p, 255, 120, 40, l);\n  }\n  // Mist: each puff a soft disc that grows as it ages and flattens into a\n  // low bank on the floor, and throws its light twice as far as it reaches.\n  M.fill(0);\n  GL.fill(0);\n  const m = S.m;\n  for (let i = 0; i \u003c S.nm; i++) {\n    const o = 6 * i, a = m[o + 4], L = m[o + 5], mx = m[o], my = m[o + 1];\n    if (a >= L) continue;\n    const al = sm(0, 0.4, a) * (1 - sm(L * 0.55, L, a)) * 0.19, r = 2.5 + 6 * (a / L), fl = my > FLOOR ? 0.55 : 1, rx = r * (2 - fl), ry = r * fl;\n    for (let y = max(0, floor(my - 2 * ry)); y \u003c= min(H - 1, floor(my + 2 * ry)); y++)\n      for (let x = max(0, floor(mx - 2 * rx)); x \u003c= min(W - 1, floor(mx + 2 * rx)); x++) {\n        const dd = ((x + 0.5 - mx) / rx) ** 2 + ((y + 0.5 - my) / ry) ** 2;\n        if (dd \u003c 4) GL[y * W + x] += al * (1 - dd / 4);\n        if (dd \u003c 1) M[y * W + x] += al * (1 - dd);\n      }\n  }\n  // The light where puffs crowd, in three steps; the mist itself as light\n  // in six: thin mist tints what is behind it, thick mist glows pale.\n  for (let p = 0; p \u003c N; p++) {\n    const q = min(5, floor(M[p] * 6)) / 5, w = max(0, q - 0.6) * 200;\n    add(C, p, MC[0], MC[1], MC[2], min(3, floor(GL[p] * 6)) * 0.06);\n    if (M[p] >= 0.04) add(C, p, MC[0] + w, MC[1] + w, MC[2] + w, 0.1 + 0.5 * q);\n  }\n  // Bats, wheeling up round a rising centre and out of the top. The far\n  // side of each turn is drawn small and dark purple, the near side black\n  // with moonlight on the top edge of its wings; one bat in three swings\n  // close past us there.\n  const bats = [];\n  for (let i = 0; i \u003c S.nb; i++) {\n    const t = S.bt[i], o = 4 * i;\n    if (t \u003c 0) continue;\n    const rad = (10 + (i % 7) * 2.6) * (1 - exp(-t / 0.45)), a = S.bp[o + 2] + S.bp[o + 3] * t;\n    const x = CX + 4 * sin(0.7 * t + i) + rad * sin(a) + 1.5 * vn(t * 3 + i * 7, 5), y = S.bp[o + 1] - (12 * t + 6 * t * t) + rad * 0.35 * cos(a) + 1.2 * vn(t * 3 + i * 7, 9);\n    if (y \u003c -10) S.bt[i] = -9;\n    else bats.push([x, y, cos(a) \u003c -0.2 ? 0 : i % 3 === 0 && cos(a) > 0.5 ? 2 : 1, floor((t * (7 + (i % 3)) + i * 0.3) * 4) % 4]);\n  }\n  const blit = (bt) => {\n    const spr = SPR[bt[2]][[0, 1, 2, 1][bt[3]]], h = spr.length, w = spr[0].length, x0 = round(bt[0] - w / 2), y0 = round(bt[1] - h / 2);\n    for (let j = 0; j \u003c h; j++)\n      for (let i = 0; i \u003c w; i++) {\n        const x = x0 + i, y = y0 + j;\n        if (spr[j][i] !== \"#\" || x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        if (!bt[2]) set(C, y * W + x, 26, 14, 36);\n        else if (!j || spr[j - 1][i] !== \"#\") set(C, y * W + x, 84, 68, 104);\n        else set(C, y * W + x, 6, 3, 10);\n      }\n  };\n  const D = S.dust;\n  for (let i = 0; i \u003c DUST; i++) {\n    const a = D[3 * i + 2], x = floor(D[3 * i]), y = floor(D[3 * i + 1]);\n    if (a >= 0 && a \u003c 3 && x >= 0 && x \u003c W && y \u003c H) mix(C, y * W + x, 150, 140, 160, 0.55 * (1 - a / 3));\n  }\n  for (const b of bats) if (!b[2]) blit(b);\n  // Flames: teardrops with a white core, leaning in the draught.\n  for (let i = 0; i \u003c 2; i++) {\n    const [fx, fy] = CANDLE[i], h = max(1.5, S.fh[i]), L = S.fx[i], f = S.fl[i];\n    for (let y = floor(fy - h - 1); y \u003c= fy + 1; y++)\n      for (let x = fx - 6; x \u003c= fx + 5; x++) {\n        const t = (fy - y) / h, wv = 2.74 * sqrt(max(0, (t + 0.25) * (1 - t))), dx = abs(x + 0.5 - fx - L * t * t);\n        if (t \u003c -0.25 || t > 1 || dx > wv) continue;\n        const col = t \u003c 0.55 && dx \u003c 0.5 * wv ? [255, 240, 200] : t > 0.7 ? [235, 105, 30] : [255, 175, 60];\n        set(C, y * W + x, col[0] * f + 30, col[1] * f + 10, col[2] * f);\n      }\n  }\n  for (const b of bats) if (b[2]) blit(b);\n  // Channels go out in steps of 6, which the eye does not see on the panel\n  // and which keeps the soft light from turning into noise.\n  const q6 = (v) => min(255, round(v / 6) * 6);\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), q6(C[3 * p]), q6(C[3 * p + 1]), q6(C[3 * p + 2]));\n}\n","candy-corn":"// ===== Patternflow pattern =====\n// Title:   Candy Corn\n// Family:  halloween\n// Idea:    Candy corn kernels, white tip, orange middle and yellow base, pour in three wandering streams from above the panel, tumble end over end down all 128 rows, bounce off a growing heap, slide down its slopes and settle at random angles, and when the heap stands high the floor splits into a trapdoor and the whole heap drops out the bottom while the pour goes on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pour=14..44, Bounce=0..1\n//\n// Knob 1: Hue. The night behind the candy and the trapdoor floor, kept to the cool side so the night never turns brown: deep purple at 0, blue at 0.25, teal at 0.5, green at 0.75 and a toxic yellow-green at 1. The candy keeps its own colours.\n// Knob 2: Speed. Runs the whole scene faster or slower: at 2 a kernel takes about 2.6 seconds to fall the panel, and at the lowest pour the heap fills in 4.5 to 6 seconds and drains in about 2; at 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Pour. Kernels a second at Speed 2, 14 to 44. At 14 about 40 kernels are in the air at once and the heap fills and drops every 6.5 to 8 seconds; at 44 about 120 are in the air and it goes every 4.5 seconds.\n// Knob 4: Bounce. How hard a kernel bounces off the heap: at 0.06 it keeps a fifth of its speed, hops less than a row and skids; at 1 it keeps nine tenths, springs back up 4 to 10 rows and skitters sideways up to 25 LEDs, so the heap spreads flatter.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sin, cos, abs, round, random, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * random();\nconst gauss = () => (random() + random() + random() - 1.5) * 1.15;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The three bands of a kernel, base to tip. The orange is full and bright:\n// any darker and it reads brown on LEDs.\nconst YELLOW = [255, 205, 18], ORANGE = [255, 112, 0], WHITE = [255, 248, 232];\n// A kernel is 8 LEDs from base to tip and 5.8 across the base, give or\n// take the 0.98 to 1.14 size each kernel draws.\nconst LEN = 8, BASE = 2.9;\n// The floor: its top row, and the rows under it where the trapdoor swings.\nconst FLOOR = 120;\n// Fall: gravity and the speed drag holds a kernel to, in LEDs per second at\n// Speed 2. Candy is light; at 55 a second a kernel stays about a second in\n// the top third, and that is what keeps the top of the panel busy.\nconst G = 150, VT = 55;\n// The heap is full when its mean height over the middle columns reaches\n// this many rows, or one peak reaches PEAK.\nconst FULL = 40, PEAK = 66;\n// The trapdoor opens and closes in this many seconds.\nconst DOOR = 0.35;\n// Rows a kernel may overlap those under it, and the drop over 4 columns\n// past which a kernel slides on: about the angle a heap of candy holds.\nconst OVERLAP = 3, SLOPE = 4;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, pour: 14, bounce: 0.06,\n    kernels: [], acc: 0,\n    // Height of the heap's surface: the top lit row in each column.\n    surf: new Float32Array(W).fill(FLOOR),\n    // The settled heap, drawn once into a buffer as each kernel comes to rest.\n    heap: new Uint8Array(N * 3), mask: new Uint8Array(N),\n    door: 0, open: false, held: 0, warm: 0,\n    bg: null, bgHue: NaN,\n  };\n}\n\n// The corners of a kernel at angle a, in panel offsets from its centre: the\n// two base corners and the two sides of the blunt tip. The tip points up at\n// angle 0.\nfunction extent(k) {\n  const L = LEN * k.sz, B = BASE * k.sz, sa = sin(k.a), ca = cos(k.a);\n  let x0 = 9, x1 = -9, y1 = -9;\n  for (const [s, t] of [[-L / 2, -B], [-L / 2, B], [L / 2, -0.3 * B], [L / 2, 0.3 * B]]) {\n    const dx = s * sa + t * ca, dy = -s * ca + t * sa;\n    x0 = min(x0, dx);\n    x1 = max(x1, dx);\n    y1 = max(y1, dy);\n  }\n  return [x0, x1, y1];\n}\n\n// Every LED the kernel covers, with its colour: a blunt triangle with a\n// rounded base, banded yellow, orange and white from base to tip.\nfunction raster(k, out) {\n  const L = LEN * k.sz, B = BASE * k.sz, sa = sin(k.a), ca = cos(k.a), R = L / 2 + 1;\n  for (let py = floor(k.y - R); py \u003c= ceil(k.y + R); py++) {\n    if (py \u003c 0 || py >= H) continue;\n    for (let px = floor(k.x - R); px \u003c= ceil(k.x + R); px++) {\n      if (px \u003c 0 || px >= W) continue;\n      const dx = px + 0.5 - k.x, dy = py + 0.5 - k.y;\n      const s = dx * sa - dy * ca, t = dx * ca + dy * sa, q = (s + L / 2) / L;\n      if (q \u003c 0 || q > 1) continue;\n      let hw = B * (1 - 0.74 * q);\n      if (q \u003c 0.16) hw *= 0.78 + 1.375 * q;\n      if (abs(t) > hw) continue;\n      out(px, py, q \u003c 0.37 ? YELLOW : q \u003c 0.7 ? ORANGE : WHITE);\n    }\n  }\n}\n\nfunction spawn(S) {\n  // Three streams whose mouths wander slowly across the top, out of step.\n  const i = floor(random() * 3), c = 32 + 21 * sin(S.t * (0.23 + 0.07 * i) + 2.1 * i);\n  S.kernels.push({\n    x: cl(c + gauss() * 3.5, 4, 60), y: -5, vx: gauss() * 7, vy: rnd(4, 16),\n    a: rnd(0, TAU), w: gauss() * 6, st: 0, slide: 0, delay: 0, drop: 0, sz: rnd(0.98, 1.14), sh: rnd(0.86, 1),\n  });\n}\n\n// How far a kernel has sunk into the heap: the most any of its LEDs lies\n// below the surface row of its column, less the three rows a kernel may\n// overlap the ones it rests on. The overlap packs the heap the way a jumble\n// of candy looks; resting on the top row alone left it full of holes. Also\n// notes the column where the kernel sank deepest.\nfunction sink(S, k) {\n  let p = -1e9;\n  const surf = S.surf;\n  raster(k, (x, y) => {\n    const v = y - surf[x] + 1 - OVERLAP;\n    if (v > p) (p = v), (S.deep = x);\n  });\n  return p;\n}\n\n// Stamp a kernel into the heap and raise the surface under it.\nfunction settle(S, k) {\n  k.st = 2;\n  const heap = S.heap, mask = S.mask, surf = S.surf, sh = k.sh;\n  raster(k, (x, y, c) => {\n    const i = y * W + x;\n    heap[i * 3] = c[0] * sh;\n    heap[i * 3 + 1] = c[1] * sh;\n    heap[i * 3 + 2] = c[2] * sh;\n    mask[i] = 1;\n    if (y \u003c surf[x]) surf[x] = y;\n  });\n}\n\nfunction step(S, k, d) {\n  const e = 0.15 + 0.75 * S.bounce;\n  if (k.st === 3) {\n    // Waiting on the open trapdoor: the bottom of the heap goes first.\n    k.delay -= d;\n    if (k.delay \u003c= 0) k.st = 0;\n    return;\n  }\n  const ox = k.x, oy = k.y, oa = k.a;\n  if (k.st === 0) {\n    k.vy += (G - (G / VT) * k.vy) * d;\n    k.vx -= k.vx * 0.8 * d;\n    k.x += k.vx * d;\n    k.y += k.vy * d;\n    k.a += k.w * d;\n  }\n  const [x0, x1] = extent(k);\n  // The side walls of the panel.\n  if (k.x + x0 \u003c 0) (k.x = -x0), (k.vx = abs(k.vx) * 0.4);\n  if (k.x + x1 > W) (k.x = W - x1), (k.vx = -abs(k.vx) * 0.4);\n  // Under the floor line, or with the trapdoor open, nothing holds a kernel.\n  if (S.open || k.y > FLOOR + 3) return;\n  if (k.st === 0) {\n    let p = sink(S, k);\n    if (p \u003c= 0) return;\n    // Sunk deeper than this step's fall: it ran into the side of a peak, not\n    // onto it. Take back the sideways move and the turn and glance off;\n    // lifting it to the top instead built the heap into thin towers.\n    const fair = max(0, k.y - oy) + 1.5;\n    if (p > fair) {\n      k.x = ox;\n      k.a = oa;\n      k.vx = -k.vx * 0.5;\n      k.w = -k.w * 0.5;\n      p = sink(S, k);\n      if (p > fair) {\n        k.x += k.x \u003c S.deep + 0.5 ? -1 : 1;\n        k.vx += k.x \u003c S.deep + 0.5 ? -6 : 6;\n        return;\n      }\n      if (p \u003c= 0) return;\n    }\n    k.y -= p;\n    if (k.vy > 20) {\n      // A bounce: back up with some of its speed, kicked sideways and spun.\n      k.vy = -k.vy * e * rnd(0.7, 1.1);\n      k.vx = k.vx * 0.4 + gauss() * (6 + 40 * e);\n      k.w = gauss() * (6 + 12 * e);\n      return;\n    }\n    k.st = 1;\n    k.slide = 0;\n  }\n  // On the heap: slide down the steeper side while the slope is steeper\n  // than the candy can hold, rolling as it goes, then come to rest.\n  const c = cl(floor(k.x), 0, W - 1), surf = S.surf;\n  const top = min(surf[max(0, c - 1)], surf[c], surf[min(W - 1, c + 1)]);\n  const l = c >= 4 ? surf[c - 4] : -1e9, r = c \u003c= W - 5 ? surf[c + 4] : -1e9;\n  const drop = max(l, r) - top, dir = r > l ? 1 : -1;\n  k.slide += d;\n  if (drop >= SLOPE && k.slide \u003c 1.6) {\n    const sx = k.x, sa = k.a;\n    k.x += dir * 22 * d;\n    k.a += dir * 5 * d;\n    const p = sink(S, k);\n    if (p > 1.5) {\n      // Slid into something higher: stop where it was.\n      k.x = sx;\n      k.a = sa;\n      settle(S, k);\n    } else if (p \u003c -2) {\n      // Off the edge of a step it falls again.\n      (k.st = 0), (k.vy = 0), (k.vx = dir * 16);\n    } else k.y -= p;\n    return;\n  }\n  settle(S, k);\n}\n\n// One step of the scene, d seconds of scene time.\nfunction advance(S, d) {\n  S.t += d;\n  S.acc += S.pour * d;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    spawn(S);\n  }\n  // Two sub-steps a frame keep a fast kernel from passing through a peak.\n  for (let n = 0; n \u003c 2; n++) for (const k of S.kernels) if (k.st !== 2) step(S, k, d / 2);\n  S.kernels = S.kernels.filter((k) => k.y \u003c H + 10);\n  // The trapdoor.\n  if (!S.open) {\n    S.door = max(0, S.door - d / DOOR);\n    let sum = 0, peak = FLOOR;\n    for (let x = 6; x \u003c W - 6; x++) (sum += FLOOR - S.surf[x]), (peak = min(peak, S.surf[x]));\n    if (sum / (W - 12) >= FULL || FLOOR - peak >= PEAK) {\n      S.open = true;\n      S.held = 0;\n      // Every kernel in the heap lets go, the lowest first and the top ones\n      // up to 0.4 seconds later, each with a little spin, so the heap pours\n      // out from below instead of dropping as one block.\n      for (const k of S.kernels) if (k.st === 2 || k.st === 1) (k.st = 3), (k.drop = 1), (k.delay = (FLOOR - k.y) * 0.009 + random() * 0.06), (k.vy = 0), (k.vx = gauss() * 5), (k.w = gauss() * 4);\n      S.heap.fill(0);\n      S.mask.fill(0);\n    }\n  } else {\n    S.door = min(1, S.door + d / DOOR);\n    S.held += d;\n    if (S.held > 0.6 && !S.kernels.some((k) => k.drop)) {\n      S.open = false;\n      S.surf.fill(FLOOR);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 14, 0.06];\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.pour = cl(kv[2], 14, 44);\n  S.bounce = cl(kv[3], 0, 1);\n  // The pattern opens on a pour already under way: the first 2.2 seconds\n  // of candy have fallen and the heap has begun.\n  if (!S.warm) {\n    S.warm = 1;\n    for (let n = 0; n \u003c 66; n++) advance(S, 1 / 30);\n  }\n  advance(S, cl(dt || 0, 0, 0.1) * (S.speed / 2));\n}\n\nfunction backdrop(S) {\n  // Night behind the candy, kept at or under 24 of 255 so only the candy\n  // and the floor count as lit, a little lighter toward the floor.\n  const h = 0.78 - 0.55 * S.hue;\n  S.bg = new Uint8Array(H * 3);\n  for (let y = 0; y \u003c H; y++) {\n    const c = hsv(h, 0.85, 0.05 + 0.044 * (y / H));\n    for (let j = 0; j \u003c 3; j++) S.bg[y * 3 + j] = round(255 * c[j]);\n  }\n  S.floor = hsv(h, 0.55, 0.85);\n  S.floorDark = hsv(h, 0.7, 0.5);\n  S.bgHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.bgHue !== S.hue) backdrop(S);\n  const bg = S.bg, heap = S.heap, mask = S.mask;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (mask[i]) display.setPixel(x, y, heap[i * 3], heap[i * 3 + 1], heap[i * 3 + 2]);\n      else display.setPixel(x, y, bg[y * 3], bg[y * 3 + 1], bg[y * 3 + 2]);\n    }\n  // The trapdoor: two leaves hinged at the walls, swinging down from the\n  // floor line as it opens. Drawn under the candy so kernels fall in front.\n  const th = (S.door * PI) / 2, fc = S.floor, fd = S.floorDark;\n  for (let side = 0; side \u003c 2; side++)\n    for (let r = 0; r \u003c 32; r += 0.5)\n      for (let w = 0; w \u003c 2; w++) {\n        const px = side ? W - 1 - r * cos(th) : r * cos(th), py = FLOOR + w + r * sin(th);\n        const x = round(px), y = round(py);\n        if (y >= H || x \u003c 0 || x >= W || mask[y * W + x]) continue;\n        const c = w ? fd : fc;\n        display.setPixel(x, y, round(255 * c[0]), round(255 * c[1]), round(255 * c[2]));\n      }\n  // Kernels in the air and on the move, over the heap.\n  for (const k of S.kernels) {\n    if (k.st === 2) continue;\n    const sh = k.sh;\n    raster(k, (x, y, c) => display.setPixel(x, y, round(c[0] * sh), round(c[1] * sh), round(c[2] * sh)));\n  }\n}\n","corn-maze":"// ===== Patternflow pattern =====\n// Title:   Corn Maze\n// Family:  halloween\n// Idea:    Seen from above at night, someone with a flashlight steps into a corn maze and walks its dirt paths, the warm beam lighting the corn tops ahead while the corridors behind the corn fall into violet shadow, until at a dead end two green eyes glint back out of the stalks, the beam shakes, and the walker turns and runs.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beam=0..1, Moon=0..1\n//\n// Knob 1: Hue. The colour of the flashlight: warm amber at 0, orange-gold at 0.95, toxic green at 0.2, cold blue at 0.45 and violet at 0.6; the eyes stay green, or turn yellow while the beam itself is green.\n// Knob 2: Speed. How fast the walker goes: at 2 it walks 15 LEDs a second, about two corridors, and runs 36 after the eyes; at 0.2 it creeps ten times slower, at 3 half as fast again. The pauses at the dead ends scale with it.\n// Knob 3: Beam. The flashlight's reach and spread: at 0 the cone is 68 LEDs long and 103 degrees wide, so pointed up the aisle it fills the half of the panel ahead of the walker; at 1 it is 94 long and 126 wide and lights most of the panel.\n// Knob 4: Moon. Moonlight on the corn tops outside the beam: at 0.06 the brightest stalks reach 20 of 255, just enough to hint at the maze in a dark room; at 1 the whole maze stands out lilac and the beam is a warm patch on it.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, atan2, sqrt, ceil, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The maze: 8 by 16 cells of 8 LEDs. Each cell keeps a 4 by 4 patch of path\n// in its middle, so corridors are 4 wide and the corn between them 4 thick\n// (2 on the outer edge). A stalk row any thinner reads as a drawn line, not\n// as a field.\nconst P = 8, CW = 8, CH = 16;\n// The top cell row of the entrance aisle.\nconst AISLE_TOP = 3;\n// Materials: trampled path, a gap between stalks, a leaf, a tassel.\nconst PATH = 0, GAP = 1, LEAF = 2, TASSEL = 3;\n// The torch is held up over the corn, so the tops of the stalks catch the\n// beam all over the cone; each row of corn the light has crossed takes this\n// share off the tops beyond it.\nconst CORN_PASS = 0.94;\n// How far the beam fades over its last quarter.\nconst FAR = 0.25;\n// The ground behind corn gets only this share of the light over the tops: the\n// paths beyond a wall lie in the corn's shadow.\nconst GROUND_SHADOW = 0.45;\n// The shadowed ground takes the night's violet, lifted a little: blue\n// carries the least light of the three, and at the same level it reads dimmer.\nconst SHADOW = hsv(0.765, 0.7, 1), SHADOW_LIFT = 1.3;\n// The pool of spill light round the torch, LEDs.\nconst POOL = 6.5;\n// Below this the beam is not drawn at all, so the shadows end hard.\nconst CUT = 0.36;\n// Walking pace at Speed 2, LEDs a second, and how much faster a run is.\nconst WALK = 15, RUN = 2.4;\n// Story seconds (one a second at Speed 2): standing at the entrance, looking\n// at a dead end, staring at the eyes, and how long a run lasts.\nconst ENTER = 2.25, LOOK = 0.7, STARE = 1.25, RUNFOR = 2.2;\n\nconst cx0 = (c) => (c % CW) * P + 3.5 + 0.5, cy0 = (c) => floor(c / CW) * P + 3.5 + 0.5;\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, beamK: 0, moon: 0.06,\n    east: new Uint8Array(CW * CH), south: new Uint8Array(CW * CH),\n    path: new Uint8Array(N), phase: new Float32Array(N), light: new Float32Array(N), shade: new Uint8Array(N),\n    aisle: 3, route: [], seg: 0, u: 0, mode: \"enter\", timer: 0, visits: new Uint16Array(CW * CH),\n    wx: 0, wy: 0, ang: -PI / 2, look: -PI / 2, stride: 0, power: 1, jitter: 0,\n    eyes: null, seen: 0, flick: 0, nextFlick: 8 + 6 * Math.random(), runLeft: 0, deadAt: -1, sub: new Uint8Array(CW * CH), up: new Int16Array(CW * CH),\n  });\n  buildMaze(S);\n  rootTree(S);\n  // The walker starts in the entrance gap at the foot of the aisle, facing in.\n  const c = 15 * CW + S.aisle;\n  S.wx = cx0(c);\n  S.wy = cy0(c) + 2;\n  S.route = [];\n  for (let cy = 15; cy >= AISLE_TOP; cy--) S.route.push(cy * CW + S.aisle);\n  S.seg = 0;\n  S.u = -2;\n  S.visits[c] = 1;\n}\n\n// A recursive backtracker grown from a straight entrance aisle. The aisle\n// runs up from a gap in the bottom edge through 13 of the 16 cell rows, the\n// way a field maze is often cut, and ends blind: its top cell takes no\n// branch. The backtracker grows the rest of the maze off its other cells.\nfunction buildMaze(S) {\n  const { east, south } = S;\n  const seen = new Uint8Array(CW * CH);\n  S.aisle = Math.random() \u003c 0.5 ? 3 : 4;\n  const stack = [];\n  for (let cy = AISLE_TOP; cy \u003c= 15; cy++) {\n    const c = cy * CW + S.aisle;\n    seen[c] = 1;\n    if (cy \u003c 15) south[c] = 1;\n    if (cy > AISLE_TOP) stack.splice(floor(Math.random() * (stack.length + 1)), 0, c);\n  }\n  while (stack.length) {\n    const c = stack[stack.length - 1], x = c % CW, y = floor(c / CW);\n    const opts = [];\n    if (x > 0 && !seen[c - 1]) opts.push(c - 1);\n    if (x \u003c CW - 1 && !seen[c + 1]) opts.push(c + 1);\n    if (y > 0 && !seen[c - CW]) opts.push(c - CW);\n    if (y \u003c CH - 1 && !seen[c + CW]) opts.push(c + CW);\n    if (!opts.length) {\n      stack.pop();\n      continue;\n    }\n    const n = opts[floor(Math.random() * opts.length)];\n    if (n === c + 1) east[c] = 1;\n    else if (n === c - 1) east[n] = 1;\n    else if (n === c + CW) south[c] = 1;\n    else south[n] = 1;\n    seen[n] = 1;\n    stack.push(n);\n  }\n  // Mark the LEDs: path where a cell or a link between cells is, and the\n  // entrance gap; corn everywhere else.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const cx = floor(x / P), cy = floor(y / P), lx = x - cx * P, ly = y - cy * P, c = cy * CW + cx;\n      const inX = lx >= 2 && lx \u003c= 5, inY = ly >= 2 && ly \u003c= 5;\n      let p = inX && inY;\n      if (inY && lx >= 6 && east[c]) p = true;\n      if (inY && lx \u003c= 1 && cx > 0 && east[c - 1]) p = true;\n      if (inX && ly >= 6 && (south[c] || (cy === 15 && cx === S.aisle))) p = true;\n      if (inX && ly \u003c= 1 && cy > 0 && south[c - CW]) p = true;\n      const i = y * W + x;\n      S.path[i] = p ? 1 : 0;\n      S.phase[i] = hash(i * 7 + 3);\n    }\n}\n\n// How many cells lie beyond the step from c to n: the maze is a tree, so\n// rooted at cell 0 this is n's subtree when n hangs below c, and everything\n// but c's subtree when n is c's parent. A runner prefers the roomier way.\nfunction rootTree(S) {\n  const order = [0], seen = new Uint8Array(CW * CH);\n  seen[0] = 1;\n  S.up.fill(-1);\n  for (let k = 0; k \u003c order.length; k++)\n    for (const n of neighbours(S, order[k])) if (!seen[n]) (seen[n] = 1), (S.up[n] = order[k]), order.push(n);\n  S.sub.fill(1);\n  for (let k = order.length - 1; k > 0; k--) S.sub[S.up[order[k]]] += S.sub[order[k]];\n}\nconst room = (S, c, n) => (S.up[n] === c ? S.sub[n] : CW * CH - S.sub[c]);\n\nconst linked = (S, a, b) => {\n  if (b === a + 1) return a % CW \u003c CW - 1 && S.east[a];\n  if (b === a - 1) return b % CW \u003c CW - 1 && S.east[b];\n  if (b === a + CW) return S.south[a];\n  if (b === a - CW) return S.south[b];\n  return false;\n};\nconst neighbours = (S, c) => [c - 1, c + 1, c - CW, c + CW].filter((n) => n >= 0 && n \u003c CW * CH && linked(S, c, n));\n\n// Decide where the walker goes after the last cell of its route. Walking, it\n// prefers corridors it has seen least; running, the ones that lead away from\n// the eyes. A cell with no way on but back is a dead end: the route marks\n// it, then turns round.\nfunction extend(S) {\n  const r = S.route, c = r[r.length - 1], prev = r.length > 1 ? r[r.length - 2] : -1;\n  const opts = neighbours(S, c).filter((n) => n !== prev);\n  if (!opts.length) {\n    S.deadAt = r.length - 1;\n    r.push(prev);\n    return;\n  }\n  let best = opts[0], score = -1e9;\n  for (const n of opts) {\n    let v = Math.random() * 1.5;\n    if (S.runLeft > 0 && S.eyes) v += 0.3 * sqrt((cx0(n) - S.eyes.x) ** 2 + (cy0(n) - S.eyes.y) ** 2) + 2 * Math.log(room(S, c, n));\n    else v -= 2 * S.visits[n];\n    if (v > score) (score = v), (best = n);\n  }\n  r.push(best);\n}\n\n// The walker's place on its route, a distance ahead along it, never past a\n// dead end it has not reached.\nfunction along(S, ahead) {\n  let seg = S.seg, u = S.u + ahead;\n  while (u > P) {\n    if (seg + 1 === S.deadAt || seg + 2 >= S.route.length) {\n      u = P;\n      break;\n    }\n    u -= P;\n    seg++;\n  }\n  const a = S.route[seg], b = S.route[seg + 1];\n  const t = u / P;\n  return [cx0(a) + (cx0(b) - cx0(a)) * t, cy0(a) + (cy0(b) - cy0(a)) * t];\n}\n\nfunction turnTo(a, target, rate) {\n  let d = target - a;\n  d -= TAU * round(d / TAU);\n  return a + cl(d, -rate, rate);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.beamK = cl(k[2], 0, 1);\n  S.moon = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1) * (S.speed / 2);\n  S.t += d;\n  S.timer += d;\n  // Keep two cells of route decided ahead, so the beam can look round a\n  // corner before the walker gets there.\n  while (S.route.length \u003c S.seg + 4 && S.deadAt \u003c S.seg) extend(S);\n\n  let pace = 0, turnRate = 7;\n  if (S.mode === \"enter\") {\n    // At the entrance the walker sweeps the beam left and right once, then\n    // goes in. The sweep is back on the aisle at 2 seconds.\n    const u = cl(S.timer / ENTER, 0, 1);\n    S.look = -PI / 2 + 0.55 * sin(TAU * cl(S.timer / 2, 0, 1)) * (1 - u);\n    turnRate = 99;\n    if (S.timer >= ENTER) (S.mode = \"walk\"), (S.timer = 0);\n  } else if (S.mode === \"walk\" || S.mode === \"run\") {\n    pace = WALK * (S.mode === \"run\" ? RUN : 1);\n    turnRate = S.mode === \"run\" ? 14 : 7;\n    if (S.mode === \"run\" && (S.runLeft -= d) \u003c= 0) S.mode = \"walk\";\n  } else if (S.mode === \"look\") {\n    // A dead end with nothing in it: a glance either side, then back.\n    S.look = S.deadAng + 0.45 * sin(TAU * S.timer / LOOK);\n    if (S.timer >= LOOK) leave(S, false);\n  } else if (S.mode === \"stare\") {\n    // Eyes. The walker freezes, the beam shakes more and more, the torch\n    // stutters, and then it turns and runs.\n    const u = S.timer / STARE;\n    S.jitter = 0.04 + 0.16 * u;\n    S.look = S.deadAng + S.jitter * (2 * Math.random() - 1);\n    S.power = 0.75 + 0.25 * Math.random() - (Math.random() \u003c 0.08 ? 0.6 : 0);\n    if (S.eyes) S.eyes.on = S.timer > 0.15 && !(S.timer > 0.7 && S.timer \u003c 0.82);\n    if (S.timer >= STARE) leave(S, true);\n  }\n\n  if (pace > 0) {\n    S.u += pace * d;\n    S.stride += pace * d;\n    while (S.u >= P) {\n      S.u -= P;\n      S.seg++;\n      const c = S.route[S.seg];\n      S.visits[c] = min(65000, S.visits[c] + 1);\n      while (S.route.length \u003c S.seg + 4 && S.deadAt \u003c S.seg) extend(S);\n      if (S.seg === S.deadAt) {\n        // Arrived at a dead end: stand in it facing the corn.\n        const a = S.route[S.seg - 1], b = S.route[S.seg];\n        S.u = 0;\n        S.deadAng = atan2(cy0(b) - cy0(a), cx0(b) - cx0(a));\n        S.timer = 0;\n        const ran = S.mode === \"run\";\n        S.runLeft = 0;\n        // Eyes in the corn beyond, at the first dead end the walker finds and\n        // then at three in five; never in the entrance gap, which opens on\n        // the field outside. A runner who hits a dead end only looks and\n        // turns: the same eyes twice in a row would be one fright too many.\n        const entrance = b === 15 * CW + S.aisle && S.deadAng > 0;\n        if (!entrance && !ran && (S.seen === 0 || Math.random() \u003c 0.6)) {\n          S.seen++;\n          const ex = cx0(b) + cos(S.deadAng) * 6.5, ey = cy0(b) + sin(S.deadAng) * 6.5;\n          S.eyes = { x: cl(ex, 1, W - 2), y: cl(ey, 1, H - 2), ang: S.deadAng, on: false, fade: 1 };\n          S.mode = \"stare\";\n        } else S.mode = \"look\";\n        break;\n      }\n    }\n    S.seg = min(S.seg, S.route.length - 2);\n    const [x, y] = along(S, 0);\n    S.wx = x;\n    S.wy = y;\n    if (S.mode === \"walk\" || S.mode === \"run\") {\n      const [lx, ly] = along(S, 7);\n      if (abs(lx - x) + abs(ly - y) > 0.5) S.look = atan2(ly - y, lx - x);\n    }\n  }\n  S.ang = turnTo(S.ang, S.look, turnRate * d + 1e-6);\n  if (S.mode !== \"stare\") S.power = 1;\n\n  // The eyes stay a moment after the walker has run, then blink out.\n  if (S.eyes && S.mode !== \"stare\") {\n    S.eyes.fade -= d * 0.8;\n    S.eyes.on = S.eyes.fade > 0;\n    if (S.eyes.fade \u003c= 0 && S.runLeft \u003c= 0) S.eyes = null;\n  }\n  // Now and then the old torch flickers: a few fast drops over 0.4 seconds.\n  if (S.t >= S.nextFlick) {\n    S.flick = 0.4;\n    S.nextFlick = S.t + 6 + 10 * Math.random();\n  }\n  if (S.flick > 0) {\n    S.flick -= d;\n    const f = floor(S.flick * 20);\n    S.power *= [1, 0.15, 1, 0.5, 0, 0.9, 0.2, 1, 0][f % 9];\n  }\n}\n\n// Leave a dead end: turn round, the route already heads back.\nfunction leave(S, ran) {\n  S.mode = ran ? \"run\" : \"walk\";\n  S.runLeft = ran ? RUNFOR : 0;\n  S.jitter = 0;\n  S.timer = 0;\n  // Drop the decided cells after the turn: a runner picks its way afresh.\n  S.route.length = S.seg + 2;\n  S.deadAt = -1;\n  S.look = S.deadAng + PI;\n}\n\n// The light is cast from just ahead of the walker's head, not from the torch\n// held out in front: at a dead end the torch is already in the corn, and a\n// beam starting inside a wall would light nothing.\nconst torch = (S) => [S.wx + 0.8 * cos(S.ang), S.wy + 0.8 * sin(S.ang)];\n\n// Cast the beam: rays fanned over the cone from the torch, each one dimmed\n// by the corn it passes through. The tops of the stalks catch what is left;\n// the ground behind any corn lies in shadow.\nfunction castBeam(S) {\n  const L = S.light, Sh = S.shade;\n  L.fill(0);\n  const pw = S.power;\n  if (pw \u003c= 0.02) return;\n  const len = 68 + 26 * S.beamK, half = 0.9 + 0.2 * S.beamK;\n  const [ox, oy] = torch(S);\n  const rays = ceil((2 * half * len) / 0.55);\n  for (let r = 0; r \u003c= rays; r++) {\n    const phi = -half + (2 * half * r) / rays, a = S.ang + phi, dx = cos(a), dy = sin(a);\n    const edge = abs(phi) / half;\n    const prof = pw * (edge \u003c 0.6 ? 1 : 1 - 0.35 * (edge - 0.6) / 0.4);\n    let T = 1, walls = 0, inCorn = false;\n    for (let s = 0.5; s \u003c len; s += 0.5) {\n      const x = ox + dx * s, y = oy + dy * s;\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) break;\n      const p = (y | 0) * W + (x | 0);\n      const fall = s \u003c 0.72 * len ? 1 : 1 - FAR * (s - 0.72 * len) / (0.28 * len);\n      let v, sh = 0;\n      if (S.path[p]) {\n        inCorn = false;\n        v = walls ? T * GROUND_SHADOW : 1;\n        sh = walls ? 1 : 0;\n      } else {\n        if (!inCorn) (walls++), (T *= CORN_PASS), (inCorn = true);\n        v = T;\n      }\n      v *= prof * fall;\n      if (v > L[p]) (L[p] = v), (Sh[p] = sh);\n    }\n  }\n  // Spill: the torch also lights the ground round the walker, as far as it\n  // can see along the path, so the walker stands in a small pool of light\n  // even facing a wall at the panel's edge.\n  for (let y = floor(oy - POOL); y \u003c= oy + POOL; y++)\n    for (let x = floor(ox - POOL); x \u003c= ox + POOL; x++) {\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) continue;\n      const ex = x + 0.5 - ox, ey = y + 0.5 - oy, dd = sqrt(ex * ex + ey * ey);\n      if (dd >= POOL) continue;\n      let clear = true;\n      for (let t = 0.5; t \u003c dd - 0.5 && clear; t += 0.5) clear = S.path[floor(oy + (ey * t) / dd) * W + floor(ox + (ex * t) / dd)] === 1;\n      const p = y * W + x, v = pw * (0.95 - (0.3 * dd) / POOL);\n      if (clear && v > L[p]) (L[p] = v), (Sh[p] = 0);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  castBeam(S);\n  const L = S.light;\n  // The beam's colours: the hue knob turns the torch round the wheel from\n  // amber. Leaves take the full colour, tassels a paler one, the dirt path a\n  // cream between.\n  const h0 = 0.115 + S.hue;\n  const cols = [hsv(h0, 0.5, 0.92), null, hsv(h0, 0.86, 1), hsv(h0 + 0.02, 0.35, 1)];\n  // Moonlight on the corn tops, lilac, faint at the start.\n  const m = 0.045 + 0.55 * S.moon;\n  const moon = [0.62 * m, 0.5 * m, m];\n  const wind = S.t * 0.9;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      // Corn rustles: each stalk LED rolls a new look about once a second.\n      let mat = PATH;\n      if (!S.path[i]) {\n        const roll = hash(i * 131 + floor(wind + S.phase[i] * 7));\n        mat = roll \u003c 0.14 ? GAP : roll \u003c 0.68 ? LEAF : TASSEL;\n      }\n      let r = 0, g = 0, b = 0;\n      if (mat === TASSEL) (r = moon[0]), (g = moon[1]), (b = moon[2]);\n      else if (mat === LEAF) (r = moon[0] * 0.55), (g = moon[1] * 0.55), (b = moon[2] * 0.55);\n      else if (mat === PATH) (r = moon[0] * 0.12), (g = moon[1] * 0.12), (b = moon[2] * 0.12);\n      let v = L[i];\n      if (v >= CUT && mat === PATH && S.shade[i]) {\n        // Ground in the corn's shadow, inside the cone: a violet channel.\n        v = min(1, round(v * 8) / 8 * SHADOW_LIFT);\n        (r = SHADOW[0] * v), (g = SHADOW[1] * v), (b = SHADOW[2] * v);\n      } else if (v >= CUT && mat !== GAP) {\n        // The lit corn and path never go below 60% brightness: a warm\n        // colour any dimmer reads brown on the panel. The edge of the beam\n        // is a step, the way a torch's edge is.\n        v = round((0.6 + (0.4 * (v - CUT)) / (1 - CUT)) * 10) / 10;\n        const c = cols[mat];\n        r = max(r, c[0] * v);\n        g = max(g, c[1] * v);\n        b = max(b, c[2] * v);\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  drawEyes(display, S);\n  drawWalker(display, S);\n}\n\n// Two eyes in the corn, side by side across the corridor: each 2 LEDs wide\n// with a 2 LED gap, the narrowest pair that still reads as a face. Round\n// them a dark head blots out the lit stalks, so the eyes do not drown in\n// the gold of the beam.\nfunction drawEyes(display, S) {\n  const e = S.eyes;\n  if (!e || !e.on) return;\n  const c = abs(((0.115 + S.hue) % 1) - 0.3) \u003c 0.08 ? [255, 235, 40] : [90, 255, 70];\n  const ca = cos(e.ang), sa = sin(e.ang);\n  for (let y = floor(e.y - 4); y \u003c= e.y + 4; y++)\n    for (let x = floor(e.x - 4); x \u003c= e.x + 4; x++) {\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) continue;\n      const dx = x + 0.5 - e.x, dy = y + 0.5 - e.y, f = dx * ca + dy * sa - 0.6, s = -dx * sa + dy * ca;\n      if ((f / 2.1) ** 2 + (s / 3.9) ** 2 \u003c 1) display.setPixel(x, y, 8, 3, 14);\n    }\n  for (const o of [-2.5, -1.5, 1.5, 2.5]) {\n    const x = floor(e.x - sa * o), y = floor(e.y + ca * o);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, c[0], c[1], c[2]);\n  }\n}\n\n// The walker from above: a pale head over shoulders in a violet coat that\n// rock with each step, one arm out in front holding the torch. About 5 LEDs\n// across, so it fills the corridor and reads as someone, not a spark.\nfunction drawWalker(display, S) {\n  const ca = cos(S.ang), sa = sin(S.ang);\n  const rock = 0.22 * sin(S.stride * 0.8);\n  for (let y = floor(S.wy - 5); y \u003c= S.wy + 5; y++)\n    for (let x = floor(S.wx - 5); x \u003c= S.wx + 5; x++) {\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) continue;\n      const dx = x + 0.5 - S.wx, dy = y + 0.5 - S.wy;\n      const f = dx * ca + dy * sa, s = -dx * sa + dy * ca, fs = f + rock * s;\n      if (f > 2.3 && f \u003c 3.5 && s > 0.2 && s \u003c 1.6) display.setPixel(x, y, 255, 250, 225);\n      else if ((f - 0.15) ** 2 + s * s \u003c 1.5) display.setPixel(x, y, 255, 208, 165);\n      else if (f > 0.4 && f \u003c= 2.3 && s > 0.3 && s \u003c 1.5) display.setPixel(x, y, 175, 95, 255);\n      else if (((fs + 0.45) / 1.45) ** 2 + (s / 2.6) ** 2 \u003c 1) display.setPixel(x, y, 140, 55, 255);\n    }\n}\n","fogged-mirror":"// ===== Patternflow pattern =====\n// Title:   Fogged Mirror\n// Family:  halloween\n// Idea:    A tall oval mirror in a dark purple room, lit by one candle below, mists over from its rim inwards until the glass is milky; then an unseen finger writes on the fog from the other side, BOO or GET OUT or a smile with too many teeth, stroke by stroke down to the dark glass, drops run from the strokes leaving streaks, and as the fog clears the mirror shows, for one second, a pale thin figure standing in the room behind you.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fog=0..1, Drips=0..1\n//\n// Knob 1: Hue. Tints the fog and the figure in the glass: at 0 the fog is milky violet and the figure ghost green; at 0.3 the fog is peach and the figure pale cyan; at 0.6 the fog is pale green and the figure pale blue; at 1 the fog is violet again and the figure lilac. The candle and the room stay as they are.\n// Knob 2: Speed. At 2 one round takes 9 to 11 seconds: the fog creeps in for 2.2, the finger writes for 3 to 5, the drops run on for 1, the fog clears in 1.3 with the figure showing through it for 1.3, and the glass rests dark for 0.8. At 0.2 everything runs ten times slower, at 3 half as fast again; the candle flickers at its own pace.\n// Knob 3: Fog. How thick the fog is and how fast it comes: at 0 it creeps in from the rim in 2.2 seconds to a milky veil with the dark glass faintly through it; at 1 it rolls in within a second, paler and opaque.\n// Knob 4: Drips. How wet the breath is: at 0.06 a stroke's end sheds a drop about every other time and the fog gathers a few beads; at 1 every stroke end sheds one, drops fall from the strokes three times as often, the fog is a quarter thinner, beads all over and sweats ten drops a second of its own, each running down the glass and clearing a streak.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The glass: an ellipse, and the frame 3 LEDs round it.\nconst MX = 32, MY = 52, MA = 27, MB = 47, FR = 3;\n// The candle below the mirror: wick, wax body, the dish it stands in.\nconst CX = 32, WICK = 112, WAX_TOP = 113;\n// One round, in story seconds (one a second at Speed 2).\nconst CREEP = 2.2, HOLD = 1.0, CLEAR = 1.3, STAY = 0.6, REST = 0.8;\n\n// A chunky hand-written font: each letter is strokes on a 4 by 6 grid, in\n// the order a finger would draw them.\nconst FONT = {\n  B: [[[0, 6], [0, 0]], [[0, 0], [3, 0], [4, 1], [4, 2], [3, 3], [0, 3]], [[3, 3], [4, 4], [4, 5], [3, 6], [0, 6]]],\n  O: [[[1.5, 0], [0.3, 1], [0, 3], [0.3, 5], [1.5, 6], [2.5, 6], [3.7, 5], [4, 3], [3.7, 1], [2.5, 0], [1.5, 0]]],\n  H: [[[0, 0], [0, 6]], [[4, 0], [4, 6]], [[0, 3], [4, 3]]],\n  I: [[[0.5, 0], [3.5, 0]], [[2, 0], [2, 6]], [[0.5, 6], [3.5, 6]]],\n  G: [[[4, 1], [3, 0], [1, 0], [0, 1.2], [0, 4.8], [1, 6], [3, 6], [4, 5], [4, 3.3], [2.3, 3.3]]],\n  E: [[[4, 0], [0, 0], [0, 6], [4, 6]], [[0, 3], [3, 3]]],\n  T: [[[0, 0], [4, 0]], [[2, 0], [2, 6]]],\n  U: [[[0, 0], [0, 4.8], [1, 6], [3, 6], [4, 4.8], [4, 0]]],\n  L: [[[0, 0], [0, 6], [4, 6]]],\n  K: [[[0, 0], [0, 6]], [[4, 0], [0, 4]], [[1.4, 2.7], [4, 6]]],\n  A: [[[0, 6], [0, 2], [2, 0], [4, 2], [4, 6]], [[0, 3.6], [4, 3.6]]],\n  C: [[[4, 1], [3, 0], [1, 0], [0, 1.2], [0, 4.8], [1, 6], [3, 6], [4, 5]]],\n};\n\n// Lay a word out: lines of text, centred on the glass, at a scale chosen so\n// the widest line fits. The finger behind the glass writes backwards for\n// itself so that it reads the right way round to us. Returns strokes in\n// panel LEDs and the finger's radius.\nfunction words(lines, sc, y0) {\n  const strokes = [], pitch = 4 * sc + 5, lh = 6 * sc + 6;\n  lines.forEach((line, li) => {\n    const w = (line.length - 1) * pitch + 4 * sc, x0 = MX - w / 2, top = y0 + li * lh;\n    [...line].forEach((ch, ci) => {\n      for (const s of FONT[ch]) strokes.push(s.map(([x, y]) => [x0 + ci * pitch + x * sc, top + y * sc]));\n    });\n  });\n  return { strokes, r: 1.6 };\n}\n\n// A smile with too many teeth: the face, two eyes, the mouth, eleven teeth.\nfunction smile() {\n  const strokes = [], arc = (cx, cy, rx, ry, a0, a1, n) => {\n    const pts = [];\n    for (let i = 0; i \u003c= n; i++) {\n      const a = a0 + ((a1 - a0) * i) / n;\n      pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n    }\n    return pts;\n  };\n  strokes.push(arc(MX, 50, 19, 21, -PI / 2, (3 * PI) / 2, 28));\n  strokes.push(arc(MX - 7, 42, 2.4, 3, 0, TAU, 8), arc(MX + 7, 42, 2.4, 3, 0, TAU, 8));\n  strokes.push(arc(MX, 49, 13, 6, 0.15, PI - 0.15, 12));\n  strokes.push(arc(MX, 49, 13, 13, 0.25, PI - 0.25, 14));\n  for (let k = 0; k \u003c 11; k++) {\n    const x = MX - 11 + 2.2 * k, y = 49 + 6 * sin(PI * (0.08 + (0.84 * k) / 10));\n    strokes.push([[x, y - 0.5], [x, y + 6.5 * sin(PI * (0.08 + (0.84 * k) / 10)) + 0.5]]);\n  }\n  return { strokes, r: 1.1 };\n}\n\n// A hand pressed flat against the other side: the palm, then four fingers\n// and the thumb pushed out of it, as strokes from the palm outwards.\nfunction hand() {\n  const strokes = [], cx = MX + 1, cy = 60;\n  for (let ring = 6; ring >= 0; ring -= 2) {\n    const pts = [];\n    for (let i = 0; i \u003c= 16; i++) pts.push([cx + ring * 1.05 * cos((TAU * i) / 16), cy + ring * 1.2 * sin((TAU * i) / 16)]);\n    strokes.push(pts);\n  }\n  for (const [dx, len, a] of [[-6, 14, -0.32], [-2, 18, -0.1], [2.2, 19, 0.06], [6, 15, 0.24]])\n    strokes.push([[cx + dx, cy - 5], [cx + dx + len * sin(a), cy - 5 - len * cos(a)]]);\n  strokes.push([[cx - 7, cy + 1], [cx - 15, cy - 7]]);\n  return { strokes, r: 2.1 };\n}\n\nconst MESSAGES = [\n  () => words([\"BOO\"], 2.4, 40),\n  () => words([\"GET\", \"OUT\"], 2.2, 30),\n  smile,\n  () => words([\"HI\"], 3.2, 36),\n  hand,\n  () => words([\"LOOK\", \"BACK\"], 1.7, 37),\n];\n\nexport function setup(params) {\n  const rho = new Float32Array(N), n1 = new Float32Array(N), n2 = new Float32Array(N);\n  // Two fixed fields of soft value noise; their blend drifts over time, so\n  // the fog's front creeps unevenly.\n  const lat = (seed, gx, gy, x, y) => {\n    const fx = (x / W) * gx, fy = (y / H) * gy, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n    const v = (i, j) => hash(seed + i * 131 + j * 977);\n    const sx = tx * tx * (3 - 2 * tx), sy = ty * ty * (3 - 2 * ty);\n    return mix(mix(v(ix, iy), v(ix + 1, iy), sx), mix(v(ix, iy + 1), v(ix + 1, iy + 1), sx), sy);\n  };\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      rho[i] = hypot((x + 0.5 - MX) / MA, (y + 0.5 - MY) / MB);\n      n1[i] = 0.65 * lat(11, 5, 9, x, y) + 0.35 * lat(23, 11, 19, x, y);\n      n2[i] = 0.65 * lat(37, 5, 9, x, y) + 0.35 * lat(51, 11, 19, x, y);\n    }\n  params.s = {\n    t: 0, rt: 0, hue: 0, speed: 2, fogK: 0, drips: 0.06,\n    rho, n1, n2,\n    clear: new Float32Array(N), wet: new Uint8Array(N), bead: new Uint8Array(N),\n    // The round: phase, time in it, which message, the finger's progress.\n    phase: \"creep\", pt: CREEP * 0.3, msg: 0, cur: null, si: 0, sd: 0, pause: 0,\n    drops: [], fig: 0, near: 1, flame: 1, sway: 0,\n    rgb: new Float32Array(N * 3),\n  };\n}\n\n// Clear the fog along a segment of the finger's path: inside the radius to\n// the glass, and a wet rim one LED round it where the water piles up.\nfunction wipe(S, x0, y0, x1, y1, r) {\n  const ex = x1 - x0, ey = y1 - y0, L2 = ex * ex + ey * ey || 1e-6;\n  const xa = max(0, floor(min(x0, x1) - r - 2)), xb = min(W - 1, floor(max(x0, x1) + r + 2));\n  const ya = max(0, floor(min(y0, y1) - r - 2)), yb = min(H - 1, floor(max(y0, y1) + r + 2));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * ex + py * ey) / L2, 0, 1);\n      const d = hypot(px - t * ex, py - t * ey), i = y * W + x;\n      if (d \u003c r) (S.clear[i] = 1), (S.wet[i] = 0);\n      else if (d \u003c r + 1.1 && S.clear[i] \u003c 1) S.wet[i] = 1;\n    }\n}\n\nfunction spawnDrop(S, x, y, big) {\n  if (S.drops.length > 40) return;\n  S.drops.push({ x, y, v: 0, wait: 0.15 + 0.6 * Math.random(), stop: 0, big: big ? 1 : 0, ph: TAU * Math.random() });\n}\n\n// The fog's thickness at an LED for a front that has come in by p (0 none,\n// 1 the whole glass): it starts at the rim and creeps inwards unevenly.\nfunction fogAt(S, i, p, wob) {\n  const n = mix(S.n1[i], S.n2[i], wob), front = p * 2 - (1 - S.rho[i]) - 0.55 * n;\n  return cl(front / 0.22, 0, 1);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.fogK = cl(k[2], 0, 1);\n  S.drips = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  S.rt += d;\n  S.pt += g;\n  // The candle keeps its own time: a flicker of two beats and a slow sway.\n  S.flame = 0.86 + 0.08 * sin(S.rt * 13.1) + 0.06 * sin(S.rt * 7.3 + 1.3 * sin(S.rt * 2.1));\n  S.sway = 0.7 * sin(S.rt * 1.7) + 0.3 * sin(S.rt * 4.3);\n  const creep = mix(CREEP, 1, S.fogK);\n  if (S.phase === \"creep\" && S.pt >= creep) {\n    S.phase = \"write\";\n    S.pt = 0;\n    S.cur = MESSAGES[S.msg % MESSAGES.length]();\n    S.si = 0;\n    S.sd = 0;\n    S.pause = 0.3;\n    let len = 0;\n    for (const s of S.cur.strokes) for (let j = 1; j \u003c s.length; j++) len += hypot(s[j][0] - s[j - 1][0], s[j][1] - s[j - 1][1]);\n    // The finger writes 55 LEDs a second, faster for a long message so no\n    // message takes more than about 3.5 seconds.\n    S.fspeed = max(55, len / 3.2);\n  }\n  if (S.phase === \"write\") {\n    if (S.pause > 0) S.pause -= g;\n    else {\n      // Move the finger along the current stroke, wiping as it goes.\n      let budget = g * S.fspeed;\n      const { strokes, r } = S.cur;\n      while (budget > 0 && S.si \u003c strokes.length) {\n        const st = strokes[S.si];\n        let acc = 0, seg = 0;\n        for (seg = 1; seg \u003c st.length; seg++) {\n          const l = hypot(st[seg][0] - st[seg - 1][0], st[seg][1] - st[seg - 1][1]);\n          if (acc + l > S.sd) break;\n          acc += l;\n        }\n        if (seg >= st.length) {\n          // The stroke is done: its end sheds a drop, sometimes.\n          const end = st[st.length - 1];\n          if (Math.random() \u003c 0.45 + 0.55 * S.drips) spawnDrop(S, end[0], end[1] + r, false);\n          S.si++;\n          S.sd = 0;\n          S.pause = 0.1;\n          break;\n        }\n        const a = st[seg - 1], b = st[seg], l = hypot(b[0] - a[0], b[1] - a[1]) || 1e-6;\n        const u0 = (S.sd - acc) / l, step = min(budget, acc + l - S.sd), u1 = (S.sd - acc + step) / l;\n        wipe(S, mix(a[0], b[0], u0), mix(a[1], b[1], u0), mix(a[0], b[0], u1), mix(a[1], b[1], u1), r);\n        // Water squeezed off the finger now and then runs from where it is.\n        if (Math.random() \u003c step * (0.012 + 0.03 * S.drips)) spawnDrop(S, mix(a[0], b[0], u1), mix(a[1], b[1], u1) + r, false);\n        S.sd += step;\n        budget -= step;\n      }\n      if (S.si >= strokes.length) {\n        S.phase = \"hold\";\n        S.pt = 0;\n      }\n    }\n  } else if (S.phase === \"hold\" && S.pt >= HOLD) {\n    S.phase = \"clear\";\n    S.pt = 0;\n  } else if (S.phase === \"clear\" && S.pt >= CLEAR + STAY) {\n    S.phase = \"rest\";\n    S.pt = 0;\n  } else if (S.phase === \"rest\" && S.pt >= REST) {\n    // New breath on the glass: the old writing fogs over with the rest.\n    S.phase = \"creep\";\n    S.pt = 0;\n    S.msg++;\n    S.clear.fill(0);\n    S.wet.fill(0);\n    S.bead.fill(0);\n    S.drops.length = 0;\n  }\n  // The figure behind you: it is there as the fog thins, stays a second,\n  // and is gone in a blink.\n  // While it is there it comes a step closer: from 1 to 1.14 times its size.\n  if (S.phase === \"clear\") S.fig = S.pt \u003c CLEAR * 0.45 ? 0 : S.pt \u003c CLEAR + STAY ? 1 : 0;\n  else S.fig = 0;\n  S.near = S.fig ? 1 + 0.14 * cl((S.pt - CLEAR * 0.45) / (CLEAR * 0.55 + STAY), 0, 1) : 1;\n  // Fog that sits gathers beads of water, a few at Drips 0.06 and hundreds\n  // a second at 1, and with Drips up it sweats drops of its own.\n  const fogged = S.phase === \"write\" || S.phase === \"hold\" || (S.phase === \"creep\" && S.pt > creep * 0.6);\n  if (fogged) {\n    let nb = g * (6 + 150 * S.drips ** 1.5);\n    while (nb > 0) {\n      if (nb >= 1 || Math.random() \u003c nb) {\n        const i = floor(Math.random() * N);\n        if (S.rho[i] \u003c 0.97 && S.clear[i] \u003c 1) S.bead[i] = 1;\n      }\n      nb -= 1;\n    }\n  }\n  if (fogged && Math.random() \u003c g * 10 * S.drips * S.drips) {\n    const a = TAU * Math.random(), rr = sqrt(Math.random()) * 0.8;\n    spawnDrop(S, MX + MA * rr * cos(a), MY + MB * rr * sin(a) * 0.7, Math.random() \u003c 0.5);\n  }\n  // Drops: swell, then run down in fits and starts, clearing a streak.\n  for (const p of S.drops) {\n    if (p.wait > 0) {\n      p.wait -= g;\n      continue;\n    }\n    if (p.stop > 0) p.stop -= g;\n    else {\n      p.v = min(p.v + g * 55, 26 + 8 * p.big);\n      if (Math.random() \u003c g * 1.4) (p.stop = 0.1 + 0.25 * Math.random()), (p.v *= 0.3);\n    }\n    const y0 = p.y;\n    p.y += p.v * (p.stop > 0 ? 0 : g);\n    p.x += 0.25 * sin(p.y * 0.3 + p.ph) * g;\n    const x = floor(p.x);\n    for (let y = floor(y0); y \u003c= floor(p.y); y++) {\n      if (y \u003c 0 || y >= H) continue;\n      for (let dx = 0; dx \u003c= p.big; dx++) {\n        const i = y * W + x + dx;\n        if (x + dx >= 0 && x + dx \u003c W && S.clear[i] \u003c 0.8) (S.clear[i] = 0.8), (S.wet[i] = 0);\n      }\n    }\n    const i = cl(floor(p.y), 0, H - 1) * W + cl(x, 0, W - 1);\n    if (S.rho[i] > 0.985) p.dead = 1;\n  }\n  S.drops = S.drops.filter((p) => !p.dead);\n}\n\n// How far the fog is in, 0 to 1, by phase.\nfunction fogProgress(S) {\n  const creep = mix(CREEP, 1, S.fogK);\n  if (S.phase === \"creep\") return S.pt / creep;\n  if (S.phase === \"write\" || S.phase === \"hold\") return 1;\n  if (S.phase === \"clear\") return 1 - cl(S.pt / CLEAR, 0, 1);\n  return 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, fl = S.flame;\n  const p = fogProgress(S), wob = 0.5 + 0.5 * sin(S.t * 0.6);\n  const thick = mix(0.72, 1, S.fogK);\n  // Wetter breath (Drips up) makes a thinner, glassier fog.\n  const wetK = 1 - 0.25 * S.drips;\n  const fogTint = hsv(0.76 + S.hue, mix(0.24, 0.12, S.fogK), 1);\n  // The figure turns only half as far, through the cold hues: a dim warm\n  // figure would read brown.\n  const ghost = hsv(0.36 + 0.5 * S.hue, 0.22, 1);\n  const flameX = CX + S.sway, flameH = 7 + 1.5 * fl;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, ro = S.rho[i];\n      let r, gg, b;\n      // Candlelight on the room and the frame: brighter near the flame, in\n      // steps of a 24th so the glow does not cost a smooth gradient.\n      const dl = hypot((x + 0.5 - flameX) * 1.1, y + 0.5 - (WICK - 3));\n      const lamp = q(cl(1 - dl / 70, 0, 1) ** 1.6 * fl, 24);\n      if (ro \u003c 1) {\n        // The glass: the dark room reflected, the candle's own flame low in\n        // it, a faint sheen, and sometimes the one standing behind you.\n        const sheen = abs(((x - y * 0.45 + 40) % 46) - 23) \u003c 3 ? 0.03 : 0;\n        r = 0.04 + sheen + 0.18 * lamp;\n        gg = 0.02 + sheen + 0.08 * lamp;\n        b = 0.08 + sheen * 1.4 + 0.1 * lamp;\n        const fy = y + 0.5 - 96, fx = x + 0.5 - (CX - S.sway * 0.8);\n        if (fy > -5 && fy \u003c 2) {\n          const w = (fy \u003c 0 ? 1.7 * (1 + fy / 5) : 1.7 - fy * 0.6) * fl;\n          if (abs(fx) \u003c w) (r = 1), (gg = fy > -1.5 && abs(fx) \u003c w * 0.5 ? 0.85 : 0.5), (b = 0.1);\n        }\n        if (S.fig > 0) {\n          // Scaled about its feet, below the frame, as it comes closer.\n          const f = figure(40 + (x + 0.5 - 40) / S.near, 104 + (y + 0.5 - 104) / S.near);\n          if (f > 0) {\n            // The face is the palest, lit from below; the body fades into\n            // the dark of the room, the hands catch the light again.\n            const lit = f === 1 ? (y > 27 ? 0.66 : 0.52) : f === 2 ? 0.05 : f === 5 ? 0.46 : q(0.4 - 0.26 * cl((y - 34) / 62, 0, 1), 16);\n            r = ghost[0] * lit;\n            gg = ghost[1] * lit;\n            b = ghost[2] * lit;\n            if (f === 3) (r = ghost[0] * 0.35), (gg = 0.95), (b = ghost[2] * 0.35);\n          }\n        }\n        // The fog over it, thinner on a bead of water.\n        const fog = fogAt(S, i, p, wob) * thick * wetK * (1 - S.clear[i]) * (S.bead[i] ? 0.5 : 1);\n        if (fog > 0) {\n          // The fog scatters the flame's reflection into a warm patch, and\n          // hides the flame itself once it is thick.\n          const a = min(1, q(fog, 12) * (fy > -6 && fy \u003c 3 ? 1.4 : 1));\n          const spot = q(cl(1 - hypot(fx, fy * 0.8) / 10, 0, 1), 8) * fl;\n          // Milky, brighter low down where the candle lights it, and a\n          // bright rim where the finger piled the water up.\n          const L = (0.55 + 0.25 * lamp + 0.1 * (y / H)) * (S.wet[i] ? 1.3 : 1);\n          r = mix(r, min(1, fogTint[0] * L + 0.15 * lamp + 0.4 * spot), a);\n          gg = mix(gg, min(1, fogTint[1] * L + 0.06 * lamp + 0.15 * spot), a);\n          b = mix(b, min(1, fogTint[2] * L), a);\n        }\n      } else if (ro \u003c 1 + FR / MA) {\n        // The frame: dark violet up top, candle gold at the bottom, with a\n        // lighter bevel on its inner edge.\n        const bev = ro \u003c 1 + 1.2 / MA ? 1.25 : ro > 1 + 2.4 / MA ? 0.7 : 1;\n        const warm = cl(lamp * 2.2, 0, 1);\n        r = mix(0.2, 1, warm) * bev;\n        gg = mix(0.08, 0.6, warm) * bev;\n        b = mix(0.26, 0.12, warm) * bev;\n      } else {\n        // The wall: dark purple, warmer round the candle.\n        r = 0.09 + 0.55 * lamp;\n        gg = 0.025 + 0.2 * lamp;\n        b = 0.15 + 0.08 * lamp;\n      }\n      // The candle: an ivory stub with a lit left side, in a dish.\n      if (y >= WAX_TOP && y \u003c 124 && abs(x + 0.5 - CX) \u003c 4) {\n        const side = x + 0.5 - CX;\n        const v = side \u003c -1 ? 1 : side \u003c 1.5 ? 0.82 : 0.6;\n        (r = 1 * v), (gg = 0.9 * v), (b = 0.72 * v);\n        if (y === WAX_TOP && (x === CX - 3 || x === CX + 1)) (r = 1), (gg = 0.97), (b = 0.85);\n      } else if (y >= 124 && y \u003c 127 && abs(x + 0.5 - CX) \u003c 9 - (y - 124) * 2) {\n        (r = 0.72), (gg = 0.36), (b = 0.1);\n        if (y === 124) (r = 1), (gg = 0.6), (b = 0.2);\n      }\n      // The flame: a teardrop that sways and stretches with the flicker.\n      const fy = WICK - (y + 0.5), fx = x + 0.5 - CX - S.sway * (fy / flameH);\n      if (fy > -1 && fy \u003c flameH) {\n        const u = fy / flameH, w = u \u003c 0.3 ? 2.3 * sqrt(u / 0.3) : 2.3 * (1 - (u - 0.3) / 0.7) ** 0.8;\n        if (abs(fx) \u003c w + 0.2) {\n          const core = abs(fx) \u003c w * 0.45 && u \u003c 0.6, mid = abs(fx) \u003c w * 0.75 && u \u003c 0.8;\n          if (fy \u003c 0.6) (r = 0.35), (gg = 0.3), (b = 0.9);\n          else if (core) (r = 1), (gg = 0.97), (b = 0.75);\n          else if (mid) (r = 1), (gg = 0.78), (b = 0.2);\n          else (r = 1), (gg = 0.5), (b = 0.05);\n        }\n      }\n      const o = i * 3;\n      rgb[o] = r;\n      rgb[o + 1] = gg;\n      rgb[o + 2] = b;\n    }\n  // Drop heads: a bright bead, bigger for a big drop.\n  for (const p of S.drops) {\n    const x = floor(p.x), y = floor(p.y);\n    for (let dy = -1; dy \u003c= 0; dy++)\n      for (let dx = 0; dx \u003c= p.big; dx++) {\n        const xx = x + dx, yy = y + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || S.rho[yy * W + xx] >= 1) continue;\n        const o = (yy * W + xx) * 3, v = dy === 0 ? 1 : 0.7;\n        rgb[o] = mix(rgb[o], 0.95, v);\n        rgb[o + 1] = mix(rgb[o + 1], 0.95, v);\n        rgb[o + 2] = mix(rgb[o + 2], 1, v);\n      }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, floor(i / W), round(255 * cl(rgb[o], 0, 1)), round(255 * cl(rgb[o + 1], 0, 1)), round(255 * cl(rgb[o + 2], 0, 1)));\n  }\n}\n\n// The one standing behind you, as the mirror shows it: 1 for the pale\n// face, 2 for the eye holes, 3 for the faint light in them, 4 for the body,\n// 5 for the hands, 0 elsewhere.\n// Tall and thin, head at row 27, arms hanging past the hips.\nfunction figure(x, y) {\n  const cx = 40;\n  const hx = (x - cx) / 3.6, hy = (y - 27) / 4.8;\n  if (hx * hx + hy * hy \u003c 1) {\n    for (const ex of [-1.6, 1.6]) {\n      const dx = x - (cx + ex), dy = y - 27.2;\n      if (abs(dx) \u003c 1 && abs(dy) \u003c 1.2) return abs(dx) \u003c 0.5 && abs(dy) \u003c 0.5 ? 3 : 2;\n    }\n    return 1;\n  }\n  if (y >= 31.5 && y \u003c 34 && abs(x - cx) \u003c 1.4) return 4;\n  if (y >= 34) {\n    // Narrow shoulders, a body that tapers to the waist and widens a little\n    // to the hem of a long shape below.\n    const u = (y - 34) / 66, half = y \u003c 36 ? 3 + (y - 34) * 1.2 : 5.4 - 2.2 * sin(PI * cl(u * 1.4, 0, 1)) + 1.6 * u;\n    if (abs(x - cx) \u003c half) return 4;\n    // The arms: a thin line each side, an LED clear of the body.\n    const arm = y \u003c 76 ? 1 : 0, side = abs(x - cx), at = 6.6 + 0.02 * (y - 36);\n    if (arm && y > 35 && side > at - 0.8 && side \u003c at + 0.7) return y > 68 ? 5 : 4;\n  }\n  return 0;\n}\n","hadwiger-nelson":"// ===== Patternflow pattern =====\n// Title:   Hadwiger-Nelson\n// Family:  cells\n// Idea:    Isbell's seven-colouring of the plane, regular hexagons in seven glass colours with each cell's six neighbours the six other colours, drifts and turns slowly under rigid figures of unit length, a Moser spindle, an equilateral triangle and single sticks, that tumble over it with every unit edge drawn in light and the cells under its ends lit, so the two ends of every edge always sit on different colours until the hexagons are sized out of the window where the colouring works, and then the edges that land on one colour flash red and their cells pulse.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hadwiger-Nelson problem (Edward Nelson, 1950), with John Isbell's seven-colouring, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Figures=0..1\n//\n// Knob 1: Hue. Turns the seven glass colours round the colour wheel together: at 0 they are amber, olive, green, teal, blue, violet and crimson; at 0.5 the amber cells have turned sky blue and the teal ones rose. The light of the edges stays white.\n// Knob 2: Speed. How fast the figures glide and tumble and the mosaic drifts: at 2 a figure glides 5 to 13 LEDs a second and turns once in 5 to 9 seconds, and the mosaic slides 4 LEDs a second and turns once in 70; at 0.2 ten times slower, at 3 half as fast again. The red flashes beat three times a second at any Speed.\n// Knob 3: Size. The hexagon's diameter in units, 0.87 times 1.6 to the power of the knob: 0.54 at -1, 0.87 at 0, 1.39 at 1. Isbell's colouring is proper from 0.756 to 1 (the knob from -0.30 to 0.30), and there nothing ever flashes; below it two cells of one colour lie closer than 1 and a unit edge can reach from one to the other, above it a whole unit edge fits inside one hexagon, and each such edge flashes red while its cells pulse.\n// Knob 4: Figures. How many unit figures tumble over the plane: 3 at 0 and 0.06 (a Moser spindle, a unit triangle and a stick), one more at each eighth of the range, up to 10 at 1 (two spindles, three triangles and five sticks, 36 unit edges).\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, sin, cos, sqrt, hypot, PI } = Math;\nconst TAU = 2 * PI, SQ3 = sqrt(3);\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The unit length on the panel, in LEDs.\nconst U = 22;\n\n// The window. Hexagon centres sit on a triangular lattice with spacing s; a\n// hexagon of diameter D (corner to corner) has s = D√3/2. Centre (a, b), at\n// a·(s, 0) + b·(s/2, s√3/2), gets colour (a + 3b) mod 7: its six neighbours\n// (±1, 0), (0, ±1), (1, -1), (-1, 1) get +1, -1, +3, -3, -2, +2, the six\n// other colours. The cells of one colour sit on the sublattice of index 7,\n// whose shortest vectors are √7 lattice steps long. The nearest two points of\n// two hexagons whose centres differ by v are |v| less the hexagon's size in\n// that direction, which is the distance from v to the hexagon doubled. That\n// is computed here over the sublattice and comes out at √7/2 = 1.3229\n// diameters, corner to corner, so the colouring needs D > 2/√7 = 0.7559 for\n// two cells of one colour to be more than 1 apart, and D \u003c 1 for no two\n// points of one cell to be 1 apart.\nfunction sameColourGap() {\n  const D = 1, s = (D * SQ3) / 2, R = D / 2;\n  // The doubled hexagon: corners at 30° + 60°k, circumradius 2R.\n  const P = [];\n  for (let k = 0; k \u003c 6; k++) P.push([2 * R * cos(PI / 6 + (k * PI) / 3), 2 * R * sin(PI / 6 + (k * PI) / 3)]);\n  let gap = Infinity;\n  for (let a = -6; a \u003c= 6; a++)\n    for (let b = -6; b \u003c= 6; b++) {\n      if ((a === 0 && b === 0) || (((a + 3 * b) % 7) + 7) % 7 !== 0) continue;\n      const vx = s * (a + b / 2), vy = (s * SQ3 * b) / 2;\n      for (let k = 0; k \u003c 6; k++) {\n        const [x0, y0] = P[k], [x1, y1] = P[(k + 1) % 6];\n        const ex = x1 - x0, ey = y1 - y0, t = cl(((vx - x0) * ex + (vy - y0) * ey) / (ex * ex + ey * ey), 0, 1);\n        gap = min(gap, hypot(vx - x0 - t * ex, vy - y0 - t * ey));\n      }\n    }\n  return gap;\n}\nconst GAP = sameColourGap();\nconst D_LO = 1 / GAP, D_HI = 1;\n// Size 0 is the geometric middle of the window: √(0.7559 · 1) = 0.87.\nconst D_MID = 0.87, D_STEP = 1.6;\n\n// Seven glass colours, one per colour class, a seventh of the wheel apart\n// with saturation and value varied so neighbours never blur together.\nconst SAT = [0.95, 0.8, 1, 0.85, 1, 0.75, 0.9];\nconst VAL = [0.62, 0.5, 0.46, 0.52, 0.6, 0.52, 0.56];\n// Hue 0 opens on amber, not red.\nconst HUE0 = 0.09;\nconst LIGHT = [1, 0.96, 0.86], RED = [1, 0.08, 0.04];\n\n// The figures, in units. Every listed edge is exactly 1 long.\nfunction spindle() {\n  // Two rhombi of two unit triangles each share the corner A; the second is\n  // turned about A until its far tip is 1 from the first one's (2√3 sin(β/2)\n  // = 1). Seven points, eleven unit edges, and no proper 3-colouring.\n  const beta = 2 * Math.asin(1 / (2 * SQ3)), pts = [[0, 0]];\n  for (const r of [-beta / 2, beta / 2]) {\n    const at = (d, a) => [d * cos(a + r), d * sin(a + r)];\n    pts.push(at(1, -PI / 6), at(1, PI / 6), at(SQ3, 0));\n  }\n  const edges = [[0, 1], [0, 2], [1, 2], [1, 3], [2, 3], [0, 4], [0, 5], [4, 5], [4, 6], [5, 6], [3, 6]];\n  return centre({ pts, edges });\n}\nconst triangle = () => centre({ pts: [[0, 0], [1, 0], [0.5, SQ3 / 2]], edges: [[0, 1], [1, 2], [2, 0]] });\nconst stick = () => centre({ pts: [[0, 0], [1, 0]], edges: [[0, 1]] });\nfunction centre(f) {\n  let cx = 0, cy = 0;\n  for (const p of f.pts) (cx += p[0]), (cy += p[1]);\n  cx /= f.pts.length;\n  cy /= f.pts.length;\n  f.pts = f.pts.map((p) => [p[0] - cx, p[1] - cy]);\n  f.reach = max(...f.pts.map((p) => hypot(p[0], p[1])));\n  return f;\n}\nconst KINDS = [spindle, triangle, stick, stick, triangle, stick, spindle, stick, triangle, stick];\n\nfunction makeFigure(i) {\n  const f = KINDS[i]();\n  const a = TAU * hash(i * 7 + 1), v = 5 + 3 * hash(i * 7 + 2);\n  f.x = 14 + 36 * hash(i * 7 + 3);\n  f.y = 14 + 100 * ((i * 0.38 + 0.2 * hash(i * 7 + 4)) % 1);\n  f.vx = v * cos(a);\n  f.vy = v * sin(a) * 1.6;\n  f.ang = TAU * hash(i * 7 + 5);\n  f.spin = (hash(i * 7 + 6) \u003c 0.5 ? -1 : 1) * (0.35 + 0.35 * hash(i * 7 + 7));\n  f.ph = TAU * hash(i * 7 + 8);\n  // Per edge: how hot its flash is; per point: where it is on the panel.\n  f.hot = new Float32Array(f.edges.length);\n  f.at = f.pts.map(() => [0, 0]);\n  return f;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, rt: 0, hue: 0, speed: 2, size: 0, D: D_MID, n: 3,\n    // The plane under the panel: its turn and where the panel's centre is.\n    rot: 0.3, ox: 0.37, oy: 0.21,\n    figs: KINDS.map((_, i) => makeFigure(i)),\n    lit: new Map(), pulse: new Map(),\n    rgb: new Float32Array(W * H * 3),\n    pal: null, palHue: NaN, flash: 0,\n  };\n}\n\n// The cell of the colouring that holds plane point (x, y), in units:\n// lattice coordinates a, b of its centre and its colour.\nfunction cellAt(S, x, y) {\n  const s = S.s, b = (2 * y) / (s * SQ3), a = x / s - b / 2, c = -a - b;\n  let ra = round(a), rb = round(b);\n  const rc = round(c), da = abs(ra - a), db = abs(rb - b), dc = abs(rc - c);\n  if (da > db && da > dc) ra = -rb - rc;\n  else if (db > dc) rb = -ra - rc;\n  return [ra, rb, (((ra + 3 * rb) % 7) + 7) % 7];\n}\nconst key = (a, b) => (a + 2048) * 4096 + b + 2048;\n\n// A panel point (LEDs) to the plane (units).\nfunction toPlane(S, px, py) {\n  const u = (px - W / 2) / U, v = (py - H / 2) / U, c = cos(S.rot), s = sin(S.rot);\n  return [c * u - s * v + S.ox, s * u + c * v + S.oy];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.size = cl(k[2], -1, 1);\n  S.D = D_MID * D_STEP ** S.size;\n  S.s = (S.D * SQ3) / 2;\n  S.n = min(KINDS.length, 3 + floor(cl(k[3], 0, 1) * 7.99));\n  const g = d * S.speed;\n  S.t += g;\n  S.rt += d;\n  // The mosaic drifts a tenth of a unit a second and turns once in 140 s at\n  // Speed 1, so its cells slide under the figures as well.\n  S.rot += g * 0.045;\n  S.ox += g * 0.06 * cos(S.t * 0.13);\n  S.oy += g * 0.1;\n  S.lit.clear();\n  S.pulse.clear();\n  // Flashes beat three times a second whatever the Speed.\n  S.flash = 0.5 + 0.5 * sin(S.rt * TAU * 3);\n  for (let i = 0; i \u003c S.n; i++) {\n    const f = S.figs[i];\n    // Glide, bounce off the panel's sides so the figure stays mostly on it,\n    // and tumble with a spin that swells and slackens.\n    f.x += f.vx * g * 0.5;\n    f.y += f.vy * g * 0.5;\n    const mx = 4 + f.reach * U * 0.5, my = 6 + f.reach * U * 0.5;\n    if (f.x \u003c mx) f.vx = abs(f.vx);\n    if (f.x > W - mx) f.vx = -abs(f.vx);\n    if (f.y \u003c my) f.vy = abs(f.vy);\n    if (f.y > H - my) f.vy = -abs(f.vy);\n    f.ang += g * f.spin * (0.75 + 0.5 * sin(S.t * 0.7 + f.ph));\n    const c = cos(f.ang), s = sin(f.ang);\n    const cells = f.pts.map((p, j) => {\n      const px = f.x + U * (c * p[0] - s * p[1]), py = f.y + U * (s * p[0] + c * p[1]);\n      f.at[j][0] = px;\n      f.at[j][1] = py;\n      const [x, y] = toPlane(S, px, py);\n      const cell = cellAt(S, x, y);\n      S.lit.set(key(cell[0], cell[1]), 1);\n      return cell;\n    });\n    // A unit edge whose two ends land on one colour breaks the colouring.\n    // Inside the window it cannot happen; outside it the edge heats up and\n    // cools over a third of a second after it lands on two colours again.\n    f.edges.forEach(([p, q], e) => {\n      const bad = cells[p][2] === cells[q][2];\n      f.hot[e] = bad ? 1 : max(0, f.hot[e] - d * 3);\n      if (f.hot[e] > 0) {\n        for (const cc of [cells[p], cells[q]]) {\n          const kk = key(cc[0], cc[1]);\n          S.pulse.set(kk, max(S.pulse.get(kk) || 0, f.hot[e]));\n        }\n      }\n    });\n  }\n}\n\nfunction palette(S) {\n  S.pal = [];\n  for (let c = 0; c \u003c 7; c++) {\n    const h = HUE0 + S.hue + c / 7, f = h - floor(h);\n    // Dim amber and orange read brown on LEDs: lift them.\n    const band = max(0, 1 - abs(f - 0.08) / 0.07);\n    S.pal.push(hsv(h, SAT[c], VAL[c] + 0.2 * band), hsv(h, SAT[c] * 0.8, 1));\n  }\n  S.palHue = S.hue;\n}\n\n// Light along a segment, a line about 1.6 LEDs wide in three steps of\n// brightness, blended over what is there.\nfunction line(S, x0, y0, x1, y1, col, a) {\n  const rgb = S.rgb, ex = x1 - x0, ey = y1 - y0, L2 = ex * ex + ey * ey || 1;\n  const xa = max(0, floor(min(x0, x1) - 1)), xb = min(W - 1, floor(max(x0, x1) + 1));\n  const ya = max(0, floor(min(y0, y1) - 1)), yb = min(H - 1, floor(max(y0, y1) + 1));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * ex + py * ey) / L2, 0, 1);\n      const dd = hypot(px - t * ex, py - t * ey);\n      if (dd >= 1.2) continue;\n      const w = a * (dd \u003c 0.45 ? 1 : dd \u003c 0.85 ? 0.6 : 0.25), i = (y * W + x) * 3;\n      rgb[i] += (col[0] - rgb[i]) * w;\n      rgb[i + 1] += (col[1] - rgb[i + 1]) * w;\n      rgb[i + 2] += (col[2] - rgb[i + 2]) * w;\n    }\n}\n\nfunction dot(S, px, py, col) {\n  const rgb = S.rgb, cx = round(px - 0.5), cy = round(py - 0.5);\n  for (let dy = -2; dy \u003c= 2; dy++)\n    for (let dx = -2; dx \u003c= 2; dx++) {\n      const x = cx + dx, y = cy + dy, r2 = dx * dx + dy * dy;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || r2 > 5 || r2 === 4) continue;\n      const i = (y * W + x) * 3;\n      // A round white core with a dark ring, so the point reads on any glass.\n      const c = r2 \u003c= 1 ? col : r2 === 2 ? [col[0] * 0.75, col[1] * 0.75, col[2] * 0.75] : [0.03, 0.02, 0.05];\n      rgb[i] = c[0];\n      rgb[i + 1] = c[1];\n      rgb[i + 2] = c[2];\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.s) return;\n  if (S.palHue !== S.hue) palette(S);\n  const rgb = S.rgb, s = S.s, half = s / 2, pal = S.pal;\n  const c = cos(S.rot), sn = sin(S.rot);\n  // Grout: a dark line about 1.4 LEDs wide on every cell boundary.\n  const g1 = 0.45 / U, g2 = 0.9 / U;\n  for (let y = 0; y \u003c H; y++) {\n    const v = (y + 0.5 - H / 2) / U;\n    for (let x = 0; x \u003c W; x++) {\n      const u = (x + 0.5 - W / 2) / U;\n      const px = c * u - sn * v + S.ox, py = sn * u + c * v + S.oy;\n      const [a, b, col] = cellAt(S, px, py);\n      // Distance to the cell's edge: its inradius less the largest\n      // projection on the three face normals.\n      const lx = px - s * (a + b / 2), ly = py - (s * SQ3 * b) / 2;\n      const hd = max(abs(lx), abs(0.5 * lx + 0.866 * ly), abs(-0.5 * lx + 0.866 * ly));\n      const edge = half - hd, kk = key(a, b);\n      let r, gg, bb;\n      const lit = S.lit.has(kk), p = S.pulse.get(kk) || 0;\n      const base = pal[col * 2 + (lit ? 1 : 0)];\n      // A bevel: the glass a little darker near the lead.\n      const bev = edge \u003c half * 0.28 ? 0.8 : 1;\n      r = base[0] * bev;\n      gg = base[1] * bev;\n      bb = base[2] * bev;\n      if (p > 0) {\n        // An offending cell pulses towards white and red with its edge.\n        const w = p * 0.85 * S.flash;\n        r += (1 - r) * w;\n        gg += (0.75 - gg) * w;\n        bb += (0.7 - bb) * w;\n      }\n      if (edge \u003c g2) {\n        const f = edge \u003c g1 ? 0.06 : 0.4;\n        r *= f;\n        gg *= f;\n        bb *= f;\n      }\n      const i = (y * W + x) * 3;\n      rgb[i] = r;\n      rgb[i + 1] = gg;\n      rgb[i + 2] = bb;\n    }\n  }\n  for (let n = 0; n \u003c S.n; n++) {\n    const f = S.figs[n];\n    f.edges.forEach(([p, q], e) => {\n      const h = f.hot[e];\n      const col = h > 0 ? (S.flash > 0.5 ? RED : LIGHT) : LIGHT;\n      line(S, f.at[p][0], f.at[p][1], f.at[q][0], f.at[q][1], col, h > 0 ? 1 : 0.85);\n    });\n    for (const pt of f.at) dot(S, pt[0], pt[1], [1, 1, 1]);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, round(255 * cl(rgb[i], 0, 1)), round(255 * cl(rgb[i + 1], 0, 1)), round(255 * cl(rgb[i + 2], 0, 1)));\n    }\n}\n","ising-interface":"// ===== Patternflow pattern =====\n// Title:   Ising Interface\n// Family:  noise\n// Idea:    An Ising magnet at its critical temperature, held up on the left and down on the right, boils in two quiet colours while the one domain wall that must cross it from bottom to top is traced every frame as a bright fractal thread, the curve whose scaling limit is SLE(3).\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ising model (Wilhelm Lenz, 1920), with the SLE(3) interface of Stanislav Smirnov (2010), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Temp=-0.15..0.3, Trail=0..1\n//\n// Knob 1: Hue. Turns the thread round the wheel from pale gold at 0: pale green at 0.25, sky blue at 0.45, lilac at 0.6, pink at 0.8; its ghost turns with it from rose. The spins stay cool and quiet: teal and indigo at 0 and 0.5, green and navy at 0.25, azure and violet at 0.75.\n// Knob 2: Speed. Sweeps a second, every spin offered a flip once per sweep: 20 at 2, 2 at 0.2, 30 at 3. At 2 the small bays of the wall open and close several times a second while its big bends shift over tens of seconds.\n// Knob 3: Temp. The temperature as a step from Onsager's critical point T_c = 2.269: 0 is T_c, where the thread is the SLE(3) curve, about 240 lattice edges long on this 32 by 64 lattice. At -0.15 (0.85 T_c) the magnet orders, the islands shrink and the thread straightens to about 135 edges; at 0.3 (1.3 T_c) the spins scatter and the thread, about 485 edges, winds round every island it touches.\n// Knob 4: Trail. How long earlier walls linger as a ghost under the thread: a half-life of 0.12 seconds at 0.06, 0.08 at 0, and 3.5 at 1, where the ghost fills the whole band the wall has wandered over.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, exp, log, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// One spin for each 2 by 2 block of LEDs: a lattice of 32 by 64. With a spin\n// per LED the wall is rough at the scale of single LEDs, its strands run\n// side by side one LED apart and merge into a blob; on 2 by 2 blocks every\n// strand has a spin's width of its own colour between it and the next, and\n// the thread is drawn one LED wide on the up side of the wall. The smaller\n// lattice also settles before the first frame: near T_c the big domains take\n// about L^2.17 sweeps to form, some 1800 for L = 32, and a 64 by 128\n// lattice would want four times the sweeps of four times the spins.\nconst B = 2, NX = W / B, NY = H / B, PW = NX + 2;\n// Onsager's critical temperature, 2 / ln(1 + sqrt 2).\nconst TC = 2 / log(1 + sqrt(2));\n// Sweeps a second at Speed 1.\nconst SWEEPS = 10;\n// How far a fresh ghost of the wall covers the spins under it.\nconst GHOST = 0.6;\n// Half sweeps run before the first frame, 2500 full sweeps. Tried with 300,\n// the magnet still looked frozen in its ordered start: two flat halves with\n// specks, and a wall that hardly left the middle line.\nconst BURN = 5000;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, temp: 0, trailK: 0.06, beta: 0, acc: 0, ready: false,\n    spin: new Int8Array(PW * (NY + 2)), p: new Float32Array(5), parity: 0, line: new Uint8Array(N), trail: new Float32Array(N), len: 0,\n  };\n  const S = params.s;\n  // The lattice is stored with a frame of fixed boundary spins round it.\n  // Start ordered, up on the left half and down on the right, the wall\n  // straight up the middle; the first update shakes it to the knob's\n  // temperature.\n  for (let j = -1; j \u003c= NY; j++) for (let i = -1; i \u003c= NX; i++) S.spin[(j + 1) * PW + i + 1] = bound(i, j);\n}\n\n// Dobrushin boundary: up all along the left edge, down all along the right,\n// and on the top and bottom rows up over the left half and down over the\n// right. Exactly one wall then runs from the middle of the bottom edge to\n// the middle of the top.\nconst bound = (i, j) => (i \u003c 0 ? 1 : i >= NX ? -1 : i \u003c NX / 2 ? 1 : -1);\nconst spinAt = (S, i, j) => (i \u003c -1 || i > NX || j \u003c -1 || j > NY ? bound(i, j) : S.spin[(j + 1) * PW + i + 1]);\n\n// Heat-bath probabilities that a spin comes up, for local field -4..4 in\n// steps of 2: 1 / (1 + exp(-2 beta h)).\nfunction table(S) {\n  const beta = 1 / (TC * (1 + S.temp));\n  S.beta = beta;\n  for (let k = 0; k \u003c 5; k++) S.p[k] = 1 / (1 + exp(-2 * beta * (2 * k - 4)));\n}\n\n// Half a sweep: every spin of one colour of the checkerboard, which share no\n// neighbours, so each sees the others as they were.\nfunction halfSweep(S, parity) {\n  const sp = S.spin, p = S.p;\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = (j + parity) & 1, q = (j + 1) * PW + i + 1; i \u003c NX; i += 2, q += 2) {\n      const h = sp[q - 1] + sp[q + 1] + sp[q - PW] + sp[q + PW];\n      sp[q] = Math.random() \u003c p[(h + 4) >> 1] ? 1 : -1;\n    }\n}\n\n// The exploration path. It walks the corners of the spin squares from the\n// middle of the bottom edge, keeping up spins on its left and down spins on\n// its right, until it reaches the middle of the top edge. At each corner it\n// looks at the two spins ahead: a down spin ahead on the left turns it left,\n// an up spin ahead on the right turns it right, otherwise it goes straight.\n// Where both happen at once it turns left.\n// Directions: 0 up, 1 right, 2 down, 3 left.\nconst DX = [0, 1, 0, -1], DY = [-1, 0, 1, 0];\nfunction trace(S) {\n  const L = S.line;\n  L.fill(0);\n  let a = NX / 2, b = NY, d = 0, n = 0;\n  const cap = 4 * (NX + 1) * (NY + 1);\n  while (n++ \u003c cap && !(a === NX / 2 && b === 0)) {\n    // The spins ahead on the left and on the right of the corner (a, b).\n    let fl, fr;\n    if (d === 0) (fl = spinAt(S, a - 1, b - 1)), (fr = spinAt(S, a, b - 1));\n    else if (d === 1) (fl = spinAt(S, a, b - 1)), (fr = spinAt(S, a, b));\n    else if (d === 2) (fl = spinAt(S, a, b)), (fr = spinAt(S, a - 1, b));\n    else (fl = spinAt(S, a - 1, b)), (fr = spinAt(S, a - 1, b - 1));\n    if (fl \u003c 0) d = (d + 3) & 3;\n    else if (fr > 0) d = (d + 1) & 3;\n    const na = a + DX[d], nb = b + DY[d];\n    edge(L, a, b, na, nb, d);\n    a = na;\n    b = nb;\n  }\n  S.len = n;\n}\n\n// Light the two LEDs along one edge of the wall, inside the spin on its\n// left, the up side; or inside the spin on its right where the left one is\n// the fixed frame outside the panel, as it is all along the left edge.\nfunction edge(L, a, b, na, nb, d) {\n  // The spin on the left of the step and the one on its right.\n  let li, lj, ri, rj;\n  if (d === 0) (li = a - 1), (lj = nb), (ri = a), (rj = nb);\n  else if (d === 2) (li = a), (lj = b), (ri = a - 1), (rj = b);\n  else if (d === 1) (li = a), (lj = b - 1), (ri = a), (rj = b);\n  else (li = na), (lj = b), (ri = na), (rj = b - 1);\n  let i = li, j = lj;\n  if (i \u003c 0 || i >= NX || j \u003c 0 || j >= NY) (i = ri), (j = rj);\n  if (i \u003c 0 || i >= NX || j \u003c 0 || j >= NY) return;\n  // Which two of the block's four LEDs touch the edge: for a vertical step\n  // the block's right column if the block lies west of it, else its left\n  // column; for a horizontal step its bottom or top row the same way.\n  const vertical = d === 0 || d === 2;\n  const x0 = B * i, y0 = B * j;\n  if (vertical) {\n    const west = i \u003c a;\n    const x = west ? x0 + B - 1 : x0;\n    for (let k = 0; k \u003c B; k++) L[(y0 + k) * W + x] = 1;\n  } else {\n    const north = j \u003c b;\n    const y = north ? y0 + B - 1 : y0;\n    for (let k = 0; k \u003c B; k++) L[y * W + x0 + k] = 1;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const temp = cl(k[2], -0.15, 0.3);\n  if (temp !== S.temp || !S.beta) {\n    S.temp = temp;\n    table(S);\n  }\n  S.trailK = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  if (!S.ready) {\n    // Settle the ordered start at this temperature before the first frame.\n    for (let n = 0; n \u003c BURN; n++) halfSweep(S, n & 1);\n    S.ready = true;\n  }\n  S.acc += d * S.speed * SWEEPS * 2;\n  let n = 0;\n  while (S.acc >= 1 && n \u003c 16) {\n    halfSweep(S, (S.parity ^= 1));\n    S.acc -= 1;\n    n++;\n  }\n  trace(S);\n  // The ghost of earlier walls fades with a half-life set by Trail.\n  const half = 0.08 + 3 * S.trailK * S.trailK + 0.4 * S.trailK;\n  const keep = exp((-d * Math.LN2) / half);\n  const tr = S.trail, L = S.line;\n  for (let p = 0; p \u003c N; p++) tr[p] = L[p] ? 1 : tr[p] * keep;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // The wall goes round the whole wheel from pale gold. The spins stay in\n  // cool hues, teal to azure for up and blue to violet for down: dark warm\n  // colours read brown on the panel, and these two are meant to be quiet.\n  const k = S.hue, w = sin(2 * PI * k);\n  const up = hsv(0.48 - 0.12 * w, 0.75, 0.42), down = hsv(0.72 - 0.1 * w, 0.8, 0.3);\n  const wall = hsv(0.12 + k, 0.3, 1), ghost = hsv(0.93 + k, 0.55, 0.9);\n  const sp = S.spin, L = S.line, tr = S.trail;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let c = sp[(floor(y / B) + 1) * PW + floor(x / B) + 1] > 0 ? up : down;\n      let r = c[0], g = c[1], b = c[2];\n      if (L[p]) (r = wall[0]), (g = wall[1]), (b = wall[2]);\n      else if (tr[p] > 0.05) {\n        const a = (round(tr[p] * 8) / 8) * GHOST;\n        r += (ghost[0] - r) * a;\n        g += (ghost[1] - g) * a;\n        b += (ghost[2] - b) * a;\n      }\n      display.setPixel(x, y, round(255 * r), round(255 * g), round(255 * b));\n    }\n}\n","mummy":"// ===== Patternflow pattern =====\n// Title:   Mummy\n// Family:  halloween\n// Idea:    A mummy the height of the panel shambles in a dark purple tomb with its arms out and its hands hanging, glowing green eyes in the slit of its wrappings, loose bandage ends fluttering in the draught, and every few seconds one long strip peels off and whips away in the wind, twisting as it goes, baring a glowing empty hollow where it was, then winds itself back on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Glow=0..1, Speed=0.2..3, Wind=0..1, Torch=0..1\n//\n// Knob 1: Glow. The colour of the eyes, of the hollow inside and of the motes that blow out of it: toxic green at 0, cyan at 0.35, blue at 0.6, violet at 0.8, magenta at 1. The wrappings stay bone white, with the glow only on their right flanks and the undersides of the arms.\n// Knob 2: Speed. At 2 a shambling step takes 2.8 seconds, a strip peels off in 1.6, flies for 2.4 and winds back on in 1.8, and the next comes 2 to 4 seconds later; the first starts at 1.6 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Wind. At 0 a draught: the loose ends hang and sway, and the strip that peels off, 38 LEDs long, streams out to the right and curls down beside the legs. At 1 a gale from the left: the ends stand out straight and snap, the strip is 64 LEDs long and climbs the right side of the panel, the mummy leans into it, and two strips can be off at once.\n// Knob 4: Torch. A torch on the left wall. At 0 a small low flame and a little warm light on the mummy's left side; at 0.06 about the same; at 1 a flame twice the size that throws flickering orange light over the wall and the wrappings.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, atan2, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n// Piecewise linear lookup in a table of [at, value] rows.\nconst tab = (T, v) => {\n  if (v \u003c= T[0][0]) return T[0][1];\n  for (let i = 1; i \u003c T.length; i++) if (v \u003c= T[i][0]) return T[i - 1][1] + ((T[i][1] - T[i - 1][1]) * (v - T[i - 1][0])) / (T[i][0] - T[i - 1][0]);\n  return T[T.length - 1][1];\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Linen in the light, and the cold purple of the tomb it turns to in shadow.\n// A dark warm shade reads brown on the panel, so the shadows go violet.\nconst CREAM = [1, 0.93, 0.76], DUSK = [0.16, 0.09, 0.26];\nconst FIRE = [1, 0.52, 0.12];\n// Half widths of the torso by row (shoulders, chest, waist, hips) and of a\n// leg by distance down from the hip.\nconst TORSO_W = [[31, 7], [34, 12], [44, 11.5], [62, 9.2], [72, 10.4], [80, 10.8]];\nconst LEG_W = [[0, 5.9], [14, 5.2], [23, 4.3], [34, 3.9], [44, 3.5]];\n// The torch on the left wall: the top of its bowl.\nconst TX = 4, TY = 74;\n// One strip's turn, in story seconds: it peels off, flies, winds back on.\nconst PEEL = 1.6, FLY = 2.4, REWIND = 1.8;\n// Where the loose ends hang: which part, how far along it, which side, length.\nconst ENDS = [\n  [\"armL\", 0.45, 1, 9], [\"armR\", 0.82, 1, 7], [\"torso\", 35, -1, 8], [\"torso\", 21, 1, 10],\n  [\"legR\", 23, 1, 7], [\"legL\", 36, -1, 6], [\"head\", -6, 1, 6],\n];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, glow: 0, speed: 2, wind: 0, torch: 0.06, gust: 0.5,\n    ev: [], rest: 1.6, motes: [], voids: [],\n    bg: null, buf: new Float32Array(N * 3), pose: null,\n  };\n}\n\n// The tomb wall: courses of big stones, all below the panel's lit threshold\n// of 24, so what counts as lit is the mummy and the torch.\nfunction wall(S) {\n  const bg = new Float32Array(N * 3);\n  for (let y = 0; y \u003c H; y++) {\n    const row = floor(y / 11), off = (row & 1) * 9, my = y % 11 === 0;\n    for (let x = 0; x \u003c W; x++) {\n      const col = floor((x + off) / 18), mx = (x + off) % 18 === 0;\n      const v = (0.62 + 0.38 * hash(row * 31 + col * 7)) * (my || mx ? 0.45 : 1) * (0.7 + 0.3 * (y / H));\n      const o = (y * W + x) * 3;\n      const floorY = y >= 124;\n      bg[o] = (floorY ? 0.07 : 0.05) * v;\n      bg[o + 1] = (floorY ? 0.035 : 0.022) * v;\n      bg[o + 2] = 0.085 * v;\n    }\n  }\n  S.bg = bg;\n}\n\nfunction newEvent(S) {\n  const busy = S.ev.map((e) => e.part);\n  // The first strip always comes off the chest, where it shows most.\n  let part = \"torso\";\n  for (let k = S.begun ? 0 : 6; k \u003c 6; k++) {\n    const r = Math.random() * 5.6;\n    part = r \u003c 3 ? \"torso\" : r \u003c 4 ? \"legL\" : r \u003c 5 ? \"legR\" : \"head\";\n    if (!busy.includes(part)) break;\n  }\n  // A band well inside the part, so the strip and its hollow are seen whole.\n  const span = { torso: [9, 40, 4.2], legL: [9, 36, 4], legR: [9, 36, 4], head: [4, 16, 3] }[part];\n  const band = floor((span[0] + Math.random() * (span[1] - span[0])) / span[2]);\n  // A strip off the chest is two bands wide.\n  S.ev.push({ part, band, bands: part === \"torso\" ? 2 : 1, stage: 0, timer: 0, p: 0, seed: Math.random() * 6.3 });\n  S.begun = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.glow = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.torch = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  const T = S.t, wind = S.wind;\n  // Gusts: the draught swells and drops on two slow beats.\n  S.gust = 0.5 + 0.5 * sin(T * 0.9) * sin(T * 0.37 + 1);\n  // The strips: one at a time, two at once in a strong wind. The rest\n  // before the next one only runs while there is room for it.\n  if (S.ev.length \u003c (wind > 0.5 ? 2 : 1)) S.rest -= ds;\n  if (S.rest \u003c= 0) {\n    newEvent(S);\n    S.rest = (2 + 2 * Math.random()) * (1 - 0.35 * wind);\n  }\n  for (const e of S.ev) {\n    e.timer += ds;\n    if (e.stage === 0) {\n      e.p = sm(0, PEEL, e.timer);\n      if (e.timer >= PEEL) (e.stage = 1), (e.timer = 0);\n    } else if (e.stage === 1) {\n      e.p = 1;\n      if (e.timer >= FLY) (e.stage = 2), (e.timer = 0);\n    } else {\n      e.p = 1 - sm(0, REWIND, e.timer);\n      if (e.timer >= REWIND) e.done = true;\n    }\n  }\n  S.ev = S.ev.filter((e) => !e.done);\n  // Motes of the glow blow out of an open hollow and away on the wind.\n  const aw = windAngle(S), v0 = 9 + 22 * wind;\n  if (S.voids.length) {\n    let n = ds * 14;\n    while (n > 0 && S.motes.length \u003c 60) {\n      if (Math.random() \u003c n) {\n        const [x, y] = S.voids[floor(Math.random() * S.voids.length)];\n        const a = aw + (Math.random() - 0.5) * 0.9, v = v0 * (0.5 + Math.random());\n        S.motes.push({ x, y, vx: cos(a) * v, vy: sin(a) * v - 4, life: 1, ph: Math.random() * 6 });\n      }\n      n -= 1;\n    }\n  }\n  for (const m of S.motes) {\n    m.life -= ds * 0.75;\n    m.x += m.vx * ds;\n    m.y += (m.vy + 4 * sin(T * 5 + m.ph)) * ds;\n  }\n  S.motes = S.motes.filter((m) => m.life > 0 && m.x > -2 && m.x \u003c W + 2 && m.y > -2 && m.y \u003c H + 2);\n  S.pose = pose(S);\n}\n\n// The wind's direction for strips and ends: down and to the right in a\n// draught, out and up to the right in a gale.\nfunction windAngle(S) {\n  const B = 0.45 + 0.25 * S.gust + S.wind * (0.3 + 0.3 * S.gust);\n  return mix(1.45, -0.4, min(1.05, B));\n}\n\n// The body this frame. The shamble is one step every 2.8 story seconds: the\n// weight goes from foot to foot, the free foot drags up, the hips and then\n// the shoulders swing over it, the head lolls behind, and the arms bob out\n// of step.\nfunction pose(S) {\n  const T = S.t, w = (2 * PI * T) / 2.8, sw = sin(w);\n  const dy = 0.6 - 0.9 * abs(sw);\n  const hipX = 32 + 1.1 * sw;\n  // The gale pushes the mummy over a little; it leans back into it.\n  const lean = -2.4 * S.wind * (0.6 + 0.4 * S.gust);\n  const sway = 2.1 * sin(w - 0.4) + lean;\n  const torsoX = (y) => hipX + sway * cl((78 - y) / 46, 0, 1.15);\n  const torso = { y0: 31 + dy, y1: 80 + dy, cx: (y) => torsoX(y - dy), w: (y) => tab(TORSO_W, y - dy), tilt: 0.42, bw: 4.2, seed: 0.3 };\n  const legs = {};\n  for (const [name, side, lift] of [[\"legL\", -1, 2.6 * max(0, sw) ** 1.5], [\"legR\", 1, 2.6 * max(0, -sw) ** 1.5]]) {\n    const hx = hipX + side * 6.1, ax = 32 + side * 7.2, y0 = 77 + dy, y1 = 120 - lift, L = y1 - y0;\n    // A lifted leg bends its knee in.\n    const knee = -side * 1.6 * (lift / 2.6);\n    legs[name] = {\n      y0, y1, cx: (y) => mix(hx, ax, (y - y0) / L) + knee * sin((PI * (y - y0)) / L),\n      w: (y) => tab(LEG_W, ((y - y0) * 44) / L), tilt: side * 0.5, bw: 4, seed: side > 0 ? 0.6 : 0.1, foot: [ax + side * 0.8, y1 + 3],\n    };\n  }\n  const sy = 37 + dy, shX = torsoX(37);\n  const reach = -1.4 * sin(T * 0.7);\n  const arms = {};\n  for (const [name, side, bob] of [[\"armL\", -1, 2.6 * sin(w + 0.6)], [\"armR\", 1, 2.6 * sin(w + PI + 0.6)]]) {\n    const x0 = shX + side * 9, x1 = cl(shX + side * 25, 4, 59), wy = sy - 1.5 + bob + reach;\n    arms[name] = {\n      x0, x1, cy: (x) => mix(sy, wy, (x - x0) / (x1 - x0)), w: (x) => mix(4.3, 3, (x - x0) / (x1 - x0)), tilt: 0.5, bw: 3.6, seed: side > 0 ? 0.5 : 0,\n      // The hand hangs limp from the wrist and swings.\n      hand: [x1 + side * 0.5, wy, 1.3 * sin(w * 2 + side) + side * 0.6],\n    };\n  }\n  const head = { hx: torsoX(31) + 1.3 * sin(w - 1.3), hy: 18.5 + dy * 0.5 - 0.6 * abs(sin(w - 0.9)), rx: 8.4, ry: 11 };\n  return { dy, torso, ...legs, ...arms, head };\n}\n\n// The colour of bandage: lit level v (0 to 1) on the linen ramp, in steps\n// of 1/14 so a smooth shade does not cost the frame its bytes.\nfunction linen(buf, o, v) {\n  v = round(cl(v, 0, 1) * 14) / 14;\n  const k = 0.32 + 0.68 * v;\n  buf[o] = mix(DUSK[0], CREAM[0], v) * k;\n  buf[o + 1] = mix(DUSK[1], CREAM[1], v) * k;\n  buf[o + 2] = mix(DUSK[2], CREAM[2], v) * k;\n}\n\n// The torch turns the side of the linen that faces it orange, in steps;\n// t is where the LED sits across its limb, -1 on the left.\nfunction torchlit(S, o, x, y, t, v) {\n  const dx = x - TX, dy = y - TY + 6;\n  const warm = round(((S.tl * max(0, 0.6 - t)) / 1.6 / (1 + (dx * dx + dy * dy) / 5000)) * 10) / 10;\n  if (warm \u003c= 0) return;\n  const a = min(0.85, warm * 0.9), k = 0.35 + 0.65 * v;\n  S.buf[o] = S.buf[o] * (1 - a) + FIRE[0] * k * a;\n  S.buf[o + 1] = S.buf[o + 1] * (1 - a) + FIRE[1] * k * a;\n  S.buf[o + 2] = S.buf[o + 2] * (1 - a) + FIRE[2] * k * a;\n}\n\n// One LED on a wrapped limb. t runs across the limb (-1 to 1), s along it;\n// the bands run round it on a helix, so on the front they cross at a slant\n// and bend over the curve. Each band throws a thin shadow on the next, and\n// the light comes from the upper left.\nfunction wrapped(S, o, x, y, t, s, part, id, light) {\n  const th = asin(t), phi = (s + part.tilt * part.wd * th) / part.bw + part.seed, b = floor(phi), f = phi - b;\n  for (const e of S.ev)\n    if (e.part === id && b >= e.band && b \u003c e.band + e.bands && t \u003c -1 + 2 * min(1, e.p * 1.5)) {\n      // The hollow: nothing inside but the glow, brightest deep in the middle.\n      const g = round((0.12 + 0.55 * (1 - abs(t)) * (0.85 + 0.15 * sin(S.t * 7 + y * 0.4))) * 10) / 10;\n      S.buf[o] = S.G[0] * g;\n      S.buf[o + 1] = S.G[1] * g;\n      S.buf[o + 2] = S.G[2] * g;\n      if (((x * 7 + y * 3) & 7) === 0) S.voids.push([x, y]);\n      return;\n    }\n  const lam = 0.36 + 0.64 * max(0, cos(th - light));\n  const band = f \u003c 0.15 ? 0.5 : 0.78 + 0.22 * ((f - 0.15) / 0.85);\n  const vary = 0.86 + 0.14 * hash(b * 13 + floor(part.seed * 10));\n  const v = lam * band * vary;\n  linen(S.buf, o, v);\n  // The torch turns the near side orange, in steps.\n  torchlit(S, o, x, y, t, v);\n  // The glow from inside the tomb catches the far side: the right flank of\n  // an upright limb, the underside of an arm.\n  const gl = round(max(0, t - 0.05) * 0.66 * 8 * (0.9 + 0.1 * sin(S.t * 3.1))) / 8;\n  if (gl > 0) {\n    S.buf[o] = S.buf[o] * (1 - gl) + S.G[0] * gl;\n    S.buf[o + 1] = S.buf[o + 1] * (1 - gl) + S.G[1] * gl;\n    S.buf[o + 2] = S.buf[o + 2] * (1 - gl) + S.G[2] * gl;\n  }\n}\n\n// A limb standing up: centre and half width by row.\nfunction upright(S, part, id) {\n  const y0 = max(0, Math.ceil(part.y0)), y1 = min(H - 1, floor(part.y1));\n  for (let y = y0; y \u003c= y1; y++) {\n    const c = part.cx(y), w = part.w(y);\n    if (w \u003c 0.6) continue;\n    part.wd = w;\n    for (let x = max(0, Math.ceil(c - w)); x \u003c= min(W - 1, floor(c + w)); x++) {\n      const t = (x - c) / w;\n      if (abs(t) > 1) continue;\n      wrapped(S, (y * W + x) * 3, x, y, t, y - part.y0, part, id, -0.55);\n    }\n  }\n}\n\n// An arm held out: centre row and half height by column.\nfunction outstretched(S, arm) {\n  const a = min(arm.x0, arm.x1), b = max(arm.x0, arm.x1);\n  for (let x = max(0, Math.ceil(a)); x \u003c= min(W - 1, floor(b)); x++) {\n    const c = arm.cy(x), w = arm.w(x);\n    arm.wd = w;\n    for (let y = max(0, Math.ceil(c - w)); y \u003c= min(H - 1, floor(c + w)); y++) {\n      const t = (y - c) / w;\n      if (abs(t) > 1) continue;\n      wrapped(S, (y * W + x) * 3, x, y, t, abs(x - arm.x0), arm, \"arm\", -1.1);\n    }\n  }\n  // The hand hangs from the wrist, wrapped too, with the fingers parted at\n  // the bottom.\n  const [hx, hy, swing] = arm.hand;\n  const hand = { y0: hy - 2, y1: hy + 8, cx: (y) => hx + (swing * (y - hy)) / 8, w: (y) => (y \u003c hy + 4 ? 2.7 : 2.7 - (y - hy - 4) * 0.2), tilt: 0.2, bw: 2.4, seed: 0.2 };\n  upright(S, hand, \"hand\");\n  for (let y = round(hy + 4); y \u003c= round(hy + 8); y++)\n    for (const f of [-0.9, 0.9]) {\n      const x = round(hand.cx(y) + f);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) linen(S.buf, (y * W + x) * 3, 0.12);\n    }\n}\n\n// A ribbon of linen from (x, y), heading off at angle a0 and turning into\n// the wind over its first 9 LEDs, whipping more towards its free end and\n// curling by curl radians an LED after that. It\n// twists as it goes: where it turns edge-on it narrows, and its back is\n// darker than its face, so the twist reads as a spiral.\nfunction ribbon(S, x, y, a0, L, aw, flut, ph, wide, curl) {\n  const buf = S.buf;\n  for (let s = 0; s \u003c L; s += 0.5) {\n    const u = s / L;\n    const a = mix(a0, aw, sm(0, 9, s)) + curl * max(0, s - 6) + flut * u * sin(ph - 0.3 * s) + 0.18 * flut * sin(ph * 1.7 - 0.7 * s);\n    x += 0.5 * cos(a);\n    y += 0.5 * sin(a);\n    const tw = cos(0.36 * s - ph * 1.2), hw = wide * (0.3 + 0.7 * abs(tw)), face = tw > 0 ? 1 : 0.74;\n    const nx = -sin(a), ny = cos(a);\n    for (let q = -hw; q \u003c= hw + 1e-6; q += 0.5) {\n      const px = round(x + q * nx), py = round(y + q * ny);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const o = (py * W + px) * 3, v = face * (1 - 0.25 * (q / max(hw, 0.5)) ** 2) * (0.92 + 0.08 * cos(s * 1.3));\n      linen(buf, o, v);\n      torchlit(S, o, px, py, 0, v);\n    }\n  }\n}\n\n// The torch: a bowl on a bracket and a flame that licks and leans with the\n// wind, its light on the wall in steps.\nfunction torch(S) {\n  const buf = S.buf, T = S.t, size = 0.75 + 0.85 * S.torch, lit = S.tl;\n  for (let y = 40; y \u003c 104; y++)\n    for (let x = 0; x \u003c 30; x++) {\n      const dx = x - TX, dy = (y - TY + 6) * 0.8, r = sqrt(dx * dx + dy * dy);\n      const g = round(exp(-r / (5 + 9 * S.torch)) * lit * 14) / 20;\n      if (g \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      buf[o] += FIRE[0] * g * 0.55;\n      buf[o + 1] += FIRE[1] * g * 0.45;\n      buf[o + 2] += FIRE[2] * g * 0.4;\n    }\n  // Bracket and bowl, dark iron with a lit rim.\n  for (let y = TY; y \u003c TY + 10; y++) for (const x of [TX - 1, TX]) if (y > TY + 2 || x === TX) buf.set([0.1, 0.06, 0.1], (y * W + x) * 3);\n  for (let x = TX - 3; x \u003c= TX + 3; x++) {\n    buf.set([0.32, 0.16, 0.08], (TY * W + x) * 3);\n    if (abs(x - TX) \u003c 3) buf.set([0.12, 0.07, 0.1], ((TY + 1) * W + x) * 3);\n  }\n  const Hf = 9 * size * (0.9 + 0.1 * sin(T * 17) * sin(T * 6.1)), bend = (0.15 + 0.5 * S.wind) * (0.7 + 0.6 * S.gust);\n  for (let y = floor(TY - Hf - 1); y \u003c TY; y++) {\n    const u = (TY - y) / Hf;\n    if (u > 1 || y \u003c 0) continue;\n    const fx = TX + bend * u * u * Hf * 0.5 + 0.8 * u * sin(T * 13 + y * 0.7);\n    const fw = 2.6 * size * sin(PI * min(1, u * 1.2 + 0.12)) ** 0.7 * (1 - 0.5 * u);\n    for (let x = floor(fx - fw); x \u003c= Math.ceil(fx + fw); x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const r = abs(x - fx) / max(0.5, fw);\n      if (r > 1) continue;\n      const o = (y * W + x) * 3;\n      const c = r \u003c 0.45 && u \u003c 0.55 ? [1, 0.92, 0.55] : r \u003c 0.75 && u \u003c 0.85 ? [1, 0.62, 0.12] : [1, 0.36, 0.05];\n      buf[o] = c[0];\n      buf[o + 1] = c[1];\n      buf[o + 2] = c[2];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.pose) return;\n  if (!S.bg) wall(S);\n  const P = S.pose, buf = S.buf, T = S.t;\n  S.G = hsv(0.3 + 0.55 * S.glow, 0.88, 1);\n  // The torch's light now: it flickers.\n  S.tl = (0.12 + 1.25 * S.torch) * (0.82 + 0.18 * sin(T * 11) * sin(T * 7.3 + 1));\n  buf.set(S.bg);\n  S.voids = [];\n  torch(S);\n  // A shadow on the floor under the feet.\n  for (let y = 122; y \u003c H; y++)\n    for (let x = 14; x \u003c 50; x++) {\n      const q = ((x - 32) / 18) ** 2 + ((y - 125) / 3) ** 2;\n      if (q \u003c 1) for (let c = 0; c \u003c 3; c++) buf[(y * W + x) * 3 + c] *= 0.4;\n    }\n  // Back to front: legs and feet, torso, neck, arms, head.\n  for (const id of [\"legL\", \"legR\"]) {\n    const L = P[id];\n    upright(S, L, id);\n    const [fx, fy] = L.foot;\n    upright(S, { y0: fy - 2.6, y1: fy + 2.4, cx: () => fx, w: (y) => 4.6 * sqrt(max(0, 1 - ((y - fy) / 2.7) ** 2)), tilt: 0.1, bw: 2.5, seed: 0.4 }, \"foot\");\n  }\n  upright(S, { y0: P.head.hy + 8, y1: P.torso.y0 + 2, cx: (y) => P.torso.cx(y), w: () => 5, tilt: 0.3, bw: 2.6, seed: 0 }, \"neck\");\n  upright(S, P.torso, \"torso\");\n  outstretched(S, P.armL);\n  outstretched(S, P.armR);\n  const h = P.head;\n  const head = {\n    y0: h.hy - h.ry, y1: h.hy + h.ry, cx: () => h.hx, tilt: -0.12, bw: 3, seed: 0.1,\n    w: (y) => h.rx * sqrt(max(0, 1 - ((y - h.hy) / h.ry) ** 2)) * (y > h.hy ? 1 - (0.14 * (y - h.hy)) / h.ry : 1),\n  };\n  upright(S, head, \"head\");\n  // The slit in the wrappings and the eyes in it.\n  const ey = round(h.hy), ex = round(h.hx);\n  const flare = S.ev.reduce((m, e) => max(m, e.p), 0);\n  const eg = 0.8 + 0.2 * sin(T * 3.1) + 0.2 * flare;\n  for (let y = ey - 2; y \u003c= ey + 1; y++)\n    for (let x = ex - 6; x \u003c= ex + 6; x++) {\n      if (abs(x - ex) > (y === ey - 2 || y === ey + 1 ? 4 : 6)) continue;\n      const o = (y * W + x) * 3, eye = (y === ey - 1 || y === ey) && (x === ex - 4 || x === ex - 3 || x === ex + 3 || x === ex + 4);\n      const near = abs(abs(x - ex) - 3.5) \u003c 2 ? 0.3 : 0.06;\n      const g = eye ? min(1, eg) : near * eg;\n      buf[o] = 0.02 + S.G[0] * g + (eye ? 0.35 * flare : 0);\n      buf[o + 1] = 0.01 + S.G[1] * g + (eye ? 0.35 * flare : 0);\n      buf[o + 2] = 0.04 + S.G[2] * g + (eye ? 0.35 * flare : 0);\n    }\n  // Loose ends: short tails pinned to the body, fluttering on the wind.\n  const aw = windAngle(S), wind = S.wind;\n  ENDS.forEach(([id, at, side, len], n) => {\n    let x, y;\n    if (id === \"armL\" || id === \"armR\") {\n      const A = P[id];\n      x = mix(A.x0, A.x1, at);\n      y = A.cy(x) + A.w(x) * side;\n    } else if (id === \"head\") {\n      x = h.hx + side * 5.5;\n      y = h.hy + at;\n    } else {\n      const L = P[id], yy = L.y0 + at;\n      x = L.cx(yy) + L.w(yy) * side;\n      y = yy;\n    }\n    const a = mix(1.5, aw, 0.35 + 0.6 * wind), ph = T * (6 + 7 * wind) + n * 1.9;\n    ribbon(S, x, y, PI / 2 - side * 0.2, len * (1 + 0.3 * wind), a, 0.5 + 0.6 * wind, ph, 1, 0);\n  });\n  // The strips coming off: each leaves its band at the peel point, which\n  // runs across the front from the left as it unwinds and back as it winds\n  // on.\n  for (const e of S.ev) {\n    const part = P[e.part === \"head\" ? \"head\" : e.part], geo = e.part === \"head\" ? head : part;\n    const tp = cl(-1 + 2 * min(1, e.p * 1.5), -0.98, 0.98), th = asin(tp);\n    const mid = e.band + e.bands / 2 - geo.seed;\n    let y = geo.y0 + mid * geo.bw;\n    for (let it = 0; it \u003c 3; it++) y = geo.y0 + mid * geo.bw - geo.tilt * geo.w(y) * th;\n    const x = geo.cx(y) + geo.w(y) * tp;\n    const L = e.p * (38 + 26 * wind);\n    // In a draught the strip streams out to the right and curls down into\n    // the open space beside the legs; in a gale it catches the updraft and\n    // climbs the right side of the panel. Either way it stays on the panel.\n    if (L > 1) ribbon(S, x, y, atan2(-geo.tilt, cos(th)), L, aw + mix(0.15, -0.7, wind), 0.7 + 0.6 * wind, T * (7 + 6 * wind) + e.seed, 0.9 + 0.7 * e.bands, mix(0.035, -0.02, wind));\n  }\n  // Motes from the hollows.\n  for (const m of S.motes) {\n    const x = round(m.x), y = round(m.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3, g = round(m.life * 4) / 4;\n    buf[o] = max(buf[o], S.G[0] * g);\n    buf[o + 1] = max(buf[o + 1], S.G[1] * g);\n    buf[o + 2] = max(buf[o + 2], S.G[2] * g);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, round(255 * min(1, buf[o])), round(255 * min(1, buf[o + 1])), round(255 * min(1, buf[o + 2])));\n}\n","plancherel-growth":"// ===== Patternflow pattern =====\n// Title:   Plancherel Growth\n// Family:  data\n// Idea:    A Young diagram grows one diamond box at a time by Robinson-Schensted insertion of random numbers, its corner on the left edge and its rows and columns running up and down the panel, and as the boxes pile up the diagram fills out toward the thin Logan-Shepp-Vershik-Kerov curve drawn for its final size, in rings coloured by arrival that are the same curve, smaller.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Plancherel growth of Young diagrams, with the limit shape of Benjamin Logan and Larry Shepp, and of Anatoly Vershik and Sergei Kerov (1977), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=3..6, Curve=0..1\n//\n// Knob 1: Hue. Turns the arrival colours round the wheel: at 0 the first boxes in the corner are violet, then blue, cyan and green out to the last boxes at the edge; at 0.35 they run orange, red, magenta and violet to blue; at 0.6 green, yellow, orange and red to pink.\n// Knob 2: Speed. At 2 the boxes come 27 a second: after a second's pause a diagram of 196 boxes grows in 7.3 seconds, holds for 3, then shrinks back into the corner in one, and a new random diagram starts. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Size. The half-diagonal of a box in LEDs, 3 to 6. The final count is chosen so the limit curve keeps its place on the panel: 196 boxes at 3, 110 at 4, 71 at 5, 49 at 6, and as the boxes come at the same rate the bigger ones fill it sooner.\n// Knob 4: Curve. Brightness of the limit curve and of the two axes it leans on, from dim at 0 to white at 1. Past about 0.3 the boxes the limit shape expects but the diagram has not yet reached show faintly, each in the colour it is expected to arrive in.\n\nconst W = 64, H = 128, MIDY = 64;\nconst { floor, min, max, abs, sqrt, round, asin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The limit shape in Russian coordinates: u is the content j - i, v is\n// i + j, both over the square root of the box count. A box is then a\n// diamond of half-diagonal 1/sqrt(n) and area 2/n, so the area between\n// Omega and |u| is 2 whatever n is (checked numerically: 2.0000, and an RSK\n// run of 10000 boxes sits within 0.01 of the curve on average).\nconst omega = (u) => (abs(u) >= 2 ? abs(u) : (2 / PI) * (u * asin(u / 2) + sqrt(4 - u * u)));\n\n// The unit of the limit shape on the panel, h sqrt(n) LEDs: the curve's\n// middle sits 4/pi of it from the corner (53 LEDs) and its ends would meet\n// the axes at twice it, past the right edge, so the curve leaves the panel\n// 12 rows from the top and bottom. At 38 the full diagram lit a quarter of\n// the panel and the picture changed too little while it grew (drift 0.20);\n// at 42 it lights about a third.\nconst SCALE = 42;\n// One cycle, in story seconds (one a second at Speed 2): an empty pause, the\n// growth at BPS boxes a second, the hold on the full diagram, and the\n// shrink back to the corner. The rate is in boxes, not in share of the\n// diagram, so bigger boxes fill the curve sooner: 196 boxes take 7.3\n// seconds and 49 take 1.8.\nconst PRE = 1, BPS = 27, HOLD = 3, SHRINK = 1;\n// The seams between boxes keep this much of the box's colour, so each box\n// reads as its own diamond.\nconst SEAM = 0.4;\n// Rows and columns kept for a diagram: far more than any arm of 196 boxes reaches.\nconst M = 64;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: -1, speed: 2, size: 0, curveK: 0.06,\n    h: 3, n: 0, sc: SCALE, phase: 0, cycleT: 0, shown: 0,\n    rows: [], count: 0, arr: new Int16Array(M * M), col: null, colHue: NaN,\n    cell: new Int32Array(W * H * 4), inner: new Uint8Array(W * H), lens: new Uint8Array(W * H),\n    curveX: new Int16Array(H), expect: new Float32Array(M * M),\n  };\n}\n\n// The pixel tables for box half-diagonal h. With A = x + y - 64 and\n// B = x - y + 64, box (i, j) has its centre at A = (2j+1)h, B = (2i+1)h,\n// so j = floor(A / 2h), i = floor(B / 2h), and a pixel with A or B a\n// multiple of 2h lies on a seam between two boxes (four at a vertex).\nfunction rebuild(S, h) {\n  S.h = h;\n  S.n = round((SCALE / h) ** 2);\n  S.sc = h * sqrt(S.n);\n  S.size = h;\n  const cell = S.cell, h2 = 2 * h;\n  cell.fill(-1);\n  S.inner.fill(0);\n  S.lens.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const xc = S.sc * omega((y - MIDY) / S.sc);\n    S.curveX[y] = abs(y - MIDY) \u003c 2 * S.sc ? round(xc) : -1;\n    for (let x = 0; x \u003c W; x++) {\n      const A = x + y - MIDY, B = x - y + MIDY, p = y * W + x;\n      if (A \u003c 0 || B \u003c 0) continue;\n      const j = floor(A / h2), i = floor(B / h2), sa = A % h2 === 0, sb = B % h2 === 0;\n      if (x \u003c= xc) S.lens[p] = 1;\n      if (!sa && !sb) {\n        S.inner[p] = 1;\n        cell[p * 4] = i \u003c M && j \u003c M ? i * M + j : -1;\n        continue;\n      }\n      // A seam: the boxes on either side of it that exist.\n      let n = 0;\n      for (const [di, dj] of [[0, 0], [0, sa ? -1 : 0], [sb ? -1 : 0, 0], [sb ? -1 : 0, sa ? -1 : 0]]) {\n        const ii = i + di, jj = j + dj;\n        if (ii \u003c 0 || jj \u003c 0 || ii >= M || jj >= M) continue;\n        const c = ii * M + jj;\n        if (n === 0 || cell[p * 4 + n - 1] !== c) cell[p * 4 + n++] = c;\n      }\n    }\n  }\n  // When the limit shape expects each box to be covered, kept as the square\n  // root of the share k/n of the final count: the diagram after k boxes\n  // hugs the curve scaled by sqrt(k/n), and those scaled curves are nested,\n  // so it is the scale whose curve passes through the box's centre.\n  const rn = sqrt(S.n);\n  for (let i = 0; i \u003c M; i++)\n    for (let j = 0; j \u003c M; j++) {\n      const u = (j - i) / rn, v = (i + j + 1) / rn;\n      if (v > omega(u)) {\n        S.expect[i * M + j] = -1;\n        continue;\n      }\n      let lo = 0, hi = 1;\n      for (let it = 0; it \u003c 24; it++) {\n        const s = (lo + hi) / 2;\n        if (s * omega(u / s) \u003c v) lo = s;\n        else hi = s;\n      }\n      S.expect[i * M + j] = hi;\n    }\n  S.colHue = NaN;\n  restart(S);\n}\n\n// A fresh diagram: empty rows, and no box has arrived yet.\nfunction restart(S) {\n  S.rows = [];\n  S.count = 0;\n  S.shown = 0;\n  S.arr.fill(-1);\n  S.phase = 0;\n  S.cycleT = 0;\n}\n\n// Robinson-Schensted row insertion of one uniform random number: into row 0\n// it bumps the smallest entry bigger than itself into the next row, and so\n// on; where nothing is bumped it goes on the end of the row, and that is the\n// new box. After k insertions the shape is Plancherel-distributed.\nfunction insert(S) {\n  let x = Math.random(), r = 0;\n  for (;;) {\n    if (r === S.rows.length) S.rows.push([]);\n    const row = S.rows[r];\n    let lo = 0, hi = row.length;\n    while (lo \u003c hi) {\n      const m = (lo + hi) >> 1;\n      if (row[m] > x) hi = m;\n      else lo = m + 1;\n    }\n    if (lo === row.length) {\n      row.push(x);\n      if (r \u003c M && lo \u003c M) S.arr[r * M + lo] = S.count;\n      S.count++;\n      return;\n    }\n    const y = row[lo];\n    row[lo] = x;\n    x = y;\n    r++;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.curveK = cl(k[3], 0, 1);\n  const h = cl(round(k[2]), 3, 6);\n  if (h !== S.size) rebuild(S, h);\n  const ds = (d * S.speed) / 2;\n  S.cycleT += ds;\n  if (S.phase === 0) {\n    // Growing: the boxes come at an even rate, one random number each.\n    const want = min(S.n, floor(BPS * max(0, S.cycleT - PRE)));\n    while (S.count \u003c want) insert(S);\n    S.shown = S.count;\n    if (S.count >= S.n) (S.phase = 1), (S.cycleT = 0);\n  } else if (S.phase === 1) {\n    if (S.cycleT >= HOLD) (S.phase = 2), (S.cycleT = 0);\n  } else {\n    // Shrinking back the way it came: the last box to arrive leaves first,\n    // so the rings close in on the corner.\n    S.shown = floor(S.n * (1 - cl(S.cycleT / SHRINK, 0, 1)));\n    if (S.cycleT >= SHRINK) restart(S);\n  }\n}\n\n// One colour per arrival. Colouring by arrival is the recording tableau of\n// the insertion, so a box never changes colour once it is down (the\n// inserted values do change as they are bumped). And it shows the\n// mathematics: the boxes that came by the k-th hug the limit curve scaled\n// by sqrt(k/n), so the hue runs with sqrt(k/n) and the colour bands are\n// evenly spaced copies of the curve, nested in the corner.\nfunction palette(S) {\n  const n = S.n;\n  S.col = new Float32Array(n * 3);\n  for (let a = 0; a \u003c n; a++) {\n    const c = hsv(0.8 + S.hue - 0.5 * sqrt((a + 1) / n), 0.88, 1);\n    S.col.set(c, a * 3);\n  }\n  S.colHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  if (S.colHue !== S.hue) palette(S);\n  const { cell, inner, lens, arr, col, shown, expect } = S;\n  const ck = S.curveK;\n  // The limit curve and the axes: dim at 0, white at 1.\n  const lineV = 0.42 + 0.58 * ck, axisV = 0.18 + 0.4 * ck;\n  // The expected boxes show from about 0.3 up.\n  const ghost = 0.3 * cl((ck - 0.25) / 0.75, 0, 1);\n  for (let y = 0; y \u003c H; y++) {\n    const cx = S.curveX[y];\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r = 0, g = 0, b = 0;\n      if (inner[p]) {\n        const c = cell[p * 4];\n        const a = c >= 0 ? arr[c] : -1;\n        if (a >= 0 && a \u003c shown) (r = col[a * 3]), (g = col[a * 3 + 1]), (b = col[a * 3 + 2]);\n        else if (ghost > 0 && c >= 0 && lens[p] && expect[c] > 0) {\n          const e = min(S.n - 1, floor(expect[c] * expect[c] * S.n)) * 3;\n          (r = col[e] * ghost), (g = col[e + 1] * ghost), (b = col[e + 2] * ghost);\n        }\n      } else if (cell[p * 4] >= 0 || cell[p * 4 + 1] >= 0) {\n        // A seam takes the colour of the first box beside it to arrive, so it\n        // is set once and never changes while the diagram grows.\n        let best = 1e9;\n        for (let q = 0; q \u003c 4; q++) {\n          const c = cell[p * 4 + q];\n          if (c \u003c 0) break;\n          const a = arr[c];\n          if (a >= 0 && a \u003c shown && a \u003c best) best = a;\n        }\n        if (best \u003c 1e9) (r = col[best * 3] * SEAM), (g = col[best * 3 + 1] * SEAM), (b = col[best * 3 + 2] * SEAM);\n        // The two axes the diagram stands on: the outer seams of row 0 and\n        // column 0.\n        if (x + y === MIDY || x - y + MIDY === 0) {\n          r = max(r, axisV * 0.85);\n          g = max(g, axisV * 0.9);\n          b = max(b, axisV);\n        }\n      }\n      if (x === cx) {\n        // The limit curve for the final count, drawn over everything.\n        r = lineV;\n        g = lineV * 0.96;\n        b = lineV * 0.88;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  }\n}\n","poltergeist":"// ===== Patternflow pattern =====\n// Title:   Poltergeist\n// Family:  halloween\n// Idea:    In a dim parlour lit by a hanging oil lamp, an unseen spirit gets restless: books fly off the shelf flapping open like birds, plates spin up off the table and circle the lamp, the chair rises and tilts, the picture swings crooked and the clock hands race backwards, each flying thing trailing green ectoplasm, until everything drops at once with a crash, the lamp gutters, and after a pause it starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fury=1..5, Lamp=0..1\n//\n// Knob 1: Hue. The colour of the ectoplasm the spirit and the flying things trail, and of the mist it leaves pooled on the floor: toxic green at 0, cyan at 0.2, blue at 0.3, violet at 0.45, pink at 0.55, orange at 0.78 and yellow at 0.86. The lamplight and the room stay orange and purple.\n// Knob 2: Speed. At 2 one haunting takes about 10 seconds: 1.2 quiet, 1.2 of rattling, 5 in the air, a crash, and 1.6 while the lamp gutters; the first things lift at 1.8 seconds. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Fury. How many things fly and how wildly. At 1 two books, one plate and the chair, which rocks about 2 LEDs off the floor; at 3 four books, three plates and the chair about 10 LEDs up; at 5 all six books and all four plates, flying half as fast again in loops a third wider, and the chair about 19 LEDs up.\n// Knob 4: Lamp. How far the hanging lamp swings, so its pool of light sweeps the walls and the things in the air: at 0 a sway of 4 degrees, at 0.06 6 degrees, at 1 a swing of 30 degrees either way. While things fly the spirit pushes it further, half as far again at Fury 1 and 2.2 times at Fury 5, never past 45 degrees.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sqrt, sin, cos, exp, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The room. The lamp hangs on a chain from a hook above the panel; the\n// wall runs down to the chair rail, then panelling, then the floor.\nconst HOOK_X = 32, CHAIN = 40, RAIL = 84, BASE = 104;\n// The table: its top and its two ends.\nconst TOP = 93, TX0 = 5, TX1 = 37;\n// The shelf on the right wall, and the books on it.\nconst SHELF = 60, SX0 = 40, SX1 = 62;\n// The chair's resting place: the middle of its seat.\nconst CHX = 51, CHY = 98;\n// Picture frame on a nail, and the clock.\nconst NAIL_X = 14, NAIL_Y = 7, FW = 16, FH = 20;\nconst CLX = 52, CLY = 20, CLR = 8;\n\n// The lamplight on a surface, as a ramp from purple shadow through rose to\n// orange and yellow. Light is quantised into eleven steps: the steps do not\n// show on the panel and a smooth glow would only add noise.\nconst RAMP = [\n  [0, [0.05, 0.012, 0.09]],\n  [0.14, [0.15, 0.04, 0.24]],\n  [0.3, [0.36, 0.08, 0.42]],\n  [0.46, [0.8, 0.22, 0.36]],\n  [0.62, [1, 0.46, 0.1]],\n  [0.8, [1, 0.7, 0.22]],\n  [1, [1, 0.9, 0.55]],\n];\nconst LUT = [];\nfor (let n = 0; n \u003c= 10; n++) {\n  const f = n / 10;\n  let k = 1;\n  while (k \u003c RAMP.length - 1 && RAMP[k][0] \u003c f) k++;\n  const [f0, c0] = RAMP[k - 1], [f1, c1] = RAMP[k], u = cl((f - f0) / (f1 - f0), 0, 1);\n  LUT.push([0, 1, 2].map((i) => c0[i] + (c1[i] - c0[i]) * u));\n}\nconst ramp = (f) => LUT[cl(round(f * 10), 0, 10)];\n\n// Book covers (no dark warm colours: they read brown), and the pages.\nconst COVERS = [[0.2, 0.75, 0.7], [0.55, 0.3, 1], [0.95, 0.85, 0.6], [0.3, 0.9, 0.35], [1, 0.35, 0.55], [0.35, 0.5, 1]];\nconst PAGES = [1, 0.95, 0.82];\n\n// One haunting, in story seconds: quiet, rattling, in the air, the drop,\n// and the hush while the lamp gutters.\nconst QUIET = 1.2, STIR = 1.2, FLY = 5, HUSH = 1.6;\n\nfunction newThing(kind, k) {\n  const book = kind === 0;\n  return {\n    kind, k, x: 0, y: 0, rx: book ? SX0 + 2 + 3.3 * k : 9 + 7.5 * k, ry: book ? SHELF - 4 : TOP - 1,\n    // Where it lies: 0 standing on the shelf, 1 flat on the table or floor.\n    pose: book ? 0 : 1, state: \"rest\", lift: 0, vx: 0, vy: 0, tilt: 0,\n    // Its own loop through the room: frequencies, phases, size.\n    w1: rnd(0.55, 0.85) * (Math.random() \u003c 0.5 ? -1 : 1), w2: rnd(0.9, 1.4), p1: rnd(0, TAU), p2: rnd(0, TAU),\n    ax: rnd(16, 24), ay: rnd(16, 28), cy: book ? rnd(44, 60) : rnd(40, 56), flap: rnd(0, TAU), spin: rnd(0, TAU),\n    col: COVERS[k % COVERS.length],\n  };\n}\n\nexport function setup(params) {\n  const tex = new Float32Array(N);\n  // How much lamplight each surface returns: striped wallpaper, a chair rail,\n  // panelling and floorboards.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let f = 1;\n      if (y \u003c RAIL) f = x % 6 === 0 ? 0.84 : (x + 3) % 6 === 0 && (y >> 2) % 2 ? 0.92 : 1;\n      else if (y \u003c RAIL + 2) f = 1.05;\n      else if (y \u003c BASE) f = x % 11 === 0 || y === RAIL + 3 || y === BASE - 2 ? 0.45 : 0.72;\n      else if (y \u003c BASE + 2) f = 0.4;\n      else f = (y - BASE) % 5 === 0 ? 0.35 : 0.58;\n      tex[y * W + x] = f;\n    }\n  const things = [];\n  for (let k = 0; k \u003c 6; k++) things.push(newThing(0, k));\n  for (let k = 0; k \u003c 4; k++) things.push(newThing(1, k));\n  params.s = {\n    t: 0, hue: 0, speed: 2, fury: 1, lampK: 0.06,\n    phase: \"quiet\", pt: QUIET - 0.6, age: 0,\n    lampA: 0.1, lampP: 0, glow: 1, gutter: 0,\n    pic: 0.06, picV: 0, hands: [0.4, 2.2],\n    chair: { h: 0, tilt: 0, vh: 0, lift: 0 },\n    mist: 0, shake: 0, crashed: false,\n    things, dust: [], tex,\n    E: new Float32Array(N), F: new Float32Array(N * 3), L: new Float32Array(N),\n    lx: HOOK_X, ly: CHAIN,\n  };\n}\n\n// Where a flying thing wants to be at story time a: a loop of its own\n// through the room, wider and faster with Fury.\nfunction path(S, o, a) {\n  const g = 0.75 + 0.12 * S.fury, sz = 0.8 + 0.07 * S.fury;\n  return [\n    cl(32 + o.ax * sz * sin(o.w1 * g * a + o.p1) + 4 * sin(2.3 * o.w2 * g * a), 5, 59),\n    cl(o.cy + o.ay * sz * 0.8 * sin(o.w2 * g * a + o.p2), 8, 100),\n  ];\n}\n\nfunction flying(S) {\n  const f = S.fury;\n  const books = round(0.5 + f), plates = round(0.75 * f + 0.25);\n  return (o) => (o.kind === 0 ? o.k \u003c min(6, books) : o.k \u003c min(4, plates));\n}\n\nfunction startPhase(S, ph) {\n  S.phase = ph;\n  S.pt = 0;\n  if (ph === \"fly\") {\n    const flies = flying(S);\n    let n = 0;\n    for (const o of S.things)\n      if (flies(o)) {\n        o.state = \"lift\";\n        o.lift = -0.18 * n++;\n        o.x = o.rx;\n        o.y = o.ry;\n      }\n  }\n  if (ph === \"drop\") {\n    // Everything lets go at once: each thing keeps the speed it had.\n    for (const o of S.things) {\n      // A thing still waiting its turn to lift stays where it is.\n      if (o.state === \"lift\" && o.lift \u003c= 0) o.state = \"rest\";\n      if (o.state === \"lift\" || o.state === \"fly\") {\n        o.state = \"fall\";\n        const [ax, ay] = path(S, o, S.age), [bx, by] = path(S, o, S.age + 0.05);\n        o.vx = ((bx - ax) / 0.05) * 0.5;\n        o.vy = ((by - ay) / 0.05) * 0.5;\n        o.land = rnd(BASE + 7, 124);\n      }\n    }\n    S.crashed = false;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.fury = cl(k[2], 1, 5);\n  S.lampK = cl(k[3], 0, 1);\n  // Story time: one story second a second at Speed 2.\n  const d = cl(dt || 0, 0, 0.1) * S.speed * 0.5;\n  S.t += d;\n  S.age += d;\n  S.pt += d;\n  if (S.phase === \"quiet\" && S.pt >= QUIET) startPhase(S, \"stir\");\n  else if (S.phase === \"stir\" && S.pt >= STIR) startPhase(S, \"fly\");\n  else if (S.phase === \"fly\" && S.pt >= FLY) startPhase(S, \"drop\");\n  else if (S.phase === \"drop\" && S.things.every((o) => o.state === \"rest\") && S.chair.h \u003c= 0 && S.pt > 0.3) startPhase(S, \"hush\");\n  else if (S.phase === \"hush\" && S.pt >= HUSH) startPhase(S, \"quiet\");\n  const ph = S.phase, active = ph === \"stir\" ? sm(S.pt / STIR) * 0.4 : ph === \"fly\" ? 1 : 0;\n\n  // The lamp: a pendulum whose swing grows while the spirit is about.\n  const target = min(0.78, (0.07 + 0.45 * S.lampK) * (1 + active * (0.4 + 0.15 * S.fury)));\n  S.lampA += (target - S.lampA) * (1 - exp(-d * 1.5));\n  S.lampP += (d * TAU) / 2.2;\n  const th = S.lampA * sin(S.lampP);\n  S.lx = HOOK_X + CHAIN * sin(th);\n  S.ly = CHAIN * cos(th) - 2;\n  // The flame: a steady flicker, guttering after the crash.\n  if (ph === \"hush\") S.gutter = max(S.gutter, 1 - S.pt / HUSH);\n  else S.gutter *= exp(-d * 4);\n  const fl = 0.04 * sin(S.t * 23) + 0.03 * sin(S.t * 37);\n  S.glow = (1 + fl) * (1 - 0.7 * S.gutter * (0.6 + 0.4 * sin(S.t * 41) * sin(S.t * 17)));\n\n  // The picture on its nail: swings while the spirit pushes it, and when the\n  // push stops friction holds it wherever it is, crooked.\n  if (active > 0) {\n    S.picV += d * (-9 * S.pic + 3.5 * active * sin(S.t * 2.6) * (0.6 + 0.12 * S.fury));\n    S.picV *= exp(-d * 0.6);\n  } else S.picV *= exp(-d * 6);\n  S.pic = cl(S.pic + S.picV * d, -0.6, 0.6);\n  // The clock: its hands race backwards while things fly.\n  S.hands[0] += d * (active ? -1.2 * active * (0.6 + 0.2 * S.fury) : 0.01);\n  S.hands[1] += d * (active ? -9 * active * (0.6 + 0.2 * S.fury) : 0.1);\n\n  // The chair rises and tilts while things fly, and drops with them.\n  const C = S.chair;\n  if (ph === \"fly\") {\n    C.lift = min(1, C.lift + d / 0.9);\n    const hgt = (2 + 4.5 * (S.fury - 1)) * (0.75 + 0.25 * sin(S.age * 1.7)) + 1.5 * sin(S.age * 5.1);\n    C.h += (sm(C.lift) * hgt - C.h) * (1 - exp(-d * 6));\n    C.tilt = sm(C.lift) * (0.12 + 0.05 * S.fury) * sin(S.age * 1.3 + 0.5) + 0.04 * sin(S.age * 6.7);\n  } else if (C.h > 0 || C.vh) {\n    C.vh += d * 300;\n    C.h -= C.vh * d;\n    C.tilt *= exp(-d * 5);\n    if (C.h \u003c= 0) {\n      // A bounce, then it stands.\n      C.vh = C.vh > 40 ? -C.vh * 0.3 : 0;\n      C.h = 0;\n      if (C.vh === 0) C.lift = 0;\n      dustAt(S, CHX, 121, 6);\n    }\n  } else C.tilt *= exp(-d * 5);\n  if (ph === \"stir\") C.tilt = 0.03 * active * sin(S.t * 31);\n\n  // The flying things.\n  for (const o of S.things) {\n    if (o.state === \"lift\" || o.state === \"fly\") {\n      o.lift += d / 0.8;\n      if (o.lift \u003c 0) continue;\n      o.state = o.lift >= 1 ? \"fly\" : \"lift\";\n      const [px, py] = path(S, o, S.age), e = sm(o.lift);\n      const nx = o.rx + (px - o.rx) * e, ny = o.ry - 5 * sin(PI * e) + (py - o.ry) * e;\n      o.tilt = cl((nx - o.x) / max(d, 1e-3) / 60, -0.5, 0.5);\n      o.x = nx;\n      o.y = ny;\n      o.flap += d * (o.kind === 0 ? 13 : 0);\n      o.spin += d * (o.kind === 1 ? 9 + S.fury : 0);\n      if (e > 0.2) deposit(S, o.x, o.y + (o.kind === 0 ? 0 : 0.5), 0.85, 2);\n    } else if (o.state === \"fall\") {\n      o.vy += d * 320;\n      o.x = cl(o.x + o.vx * d, 4, 60);\n      // It lands on the table if it comes down onto it, or else on the floor.\n      if (o.y \u003c TOP - 1 && o.y + o.vy * d >= TOP - 1 && o.x > TX0 + 2 && o.x \u003c TX1 - 2) o.land = TOP - 1;\n      o.y += o.vy * d;\n      o.spin += d * 6;\n      if (o.y >= o.land) {\n        o.y = o.land;\n        o.state = \"rest\";\n        o.rx = o.x;\n        o.ry = o.y;\n        o.pose = 1;\n        o.flap = 0;\n        dustAt(S, o.x, o.y, o.kind === 1 ? 7 : 5);\n        if (!S.crashed) {\n          S.crashed = true;\n          S.shake = 0.45;\n        }\n      }\n    }\n  }\n  S.shake = max(0, S.shake - d);\n  S.mist += ((ph === \"fly\" || ph === \"drop\" ? 1 : ph === \"stir\" ? sm(S.pt / STIR) : 0) - S.mist) * (1 - exp(-d * 1.2));\n\n  // The spirit itself is never seen, only the faint trail it leaves as it\n  // drifts round the room, brighter while it stirs things up.\n  const wx = 32 + 22 * sin(S.t * 0.83) + 6 * sin(S.t * 2.1), wy = 58 + 34 * sin(S.t * 0.57 + 1) + 5 * cos(S.t * 1.9);\n  deposit(S, wx, wy, ph === \"quiet\" || ph === \"hush\" ? 0.45 : 0.75, 2.2);\n  const fade = exp(-d * 1.7);\n  for (let i = 0; i \u003c N; i++) S.E[i] *= fade;\n\n  for (const p of S.dust) {\n    p.x += p.vx * d;\n    p.y += p.vy * d;\n    p.vx *= exp(-d * 2);\n    p.vy = p.vy * exp(-d * 2) - d * 2;\n    p.life -= d / p.span;\n  }\n  S.dust = S.dust.filter((p) => p.life > 0);\n}\n\nfunction deposit(S, x, y, v, r = 1.6) {\n  const x0 = round(x), y0 = round(y), R = Math.ceil(r);\n  for (let j = -R; j \u003c= R; j++)\n    for (let i = -R; i \u003c= R; i++) {\n      const xx = x0 + i, yy = y0 + j, dd = sqrt(i * i + j * j);\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || dd > r + 0.4) continue;\n      const n = yy * W + xx;\n      S.E[n] = max(S.E[n], v * (dd > r - 0.6 ? 0.55 : 1));\n    }\n}\n\nfunction dustAt(S, x, y, n) {\n  for (let k = 0; k \u003c n; k++) S.dust.push({ x: x + rnd(-3, 3), y: y - rnd(0, 2), vx: rnd(-14, 14), vy: rnd(-16, -4), life: 1, span: rnd(0.7, 1.4) });\n}\n\n// Painting into the frame buffer.\nfunction put(S, x, y, c, a = 1) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const n = (y * W + x) * 3;\n  S.F[n] += (c[0] - S.F[n]) * a;\n  S.F[n + 1] += (c[1] - S.F[n + 1]) * a;\n  S.F[n + 2] += (c[2] - S.F[n + 2]) * a;\n}\n// An object's colour in the lamplight where it stands.\nfunction lit(S, c, x, y, lo = 0.3) {\n  const f = S.L[cl(round(y), 0, H - 1) * W + cl(round(x), 0, W - 1)], v = lo + (1.15 - lo) * f;\n  return [min(1, c[0] * v), min(1, c[1] * v), min(1, c[2] * v)];\n}\n// A thick segment: every LED within r of the line from a to b.\nfunction seg(S, ax, ay, bx, by, r, c) {\n  const x0 = floor(min(ax, bx) - r), x1 = Math.ceil(max(ax, bx) + r), y0 = floor(min(ay, by) - r), y1 = Math.ceil(max(ay, by) + r);\n  const dx = bx - ax, dy = by - ay, ll = dx * dx + dy * dy || 1;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const u = cl(((x - ax) * dx + (y - ay) * dy) / ll, 0, 1), ex = ax + dx * u - x, ey = ay + dy * u - y;\n      if (ex * ex + ey * ey \u003c= r * r) put(S, x, y, c);\n    }\n}\n// A box in a frame turned by angle a about (ox, oy): local x from x0 to x1,\n// local y from y0 to y1.\nfunction box(S, ox, oy, a, x0, y0, x1, y1, c) {\n  const ca = cos(a), sa = sin(a);\n  const rad = sqrt(max(x0 * x0, x1 * x1) + max(y0 * y0, y1 * y1)) + 1;\n  for (let y = floor(oy - rad); y \u003c= oy + rad; y++)\n    for (let x = floor(ox - rad); x \u003c= ox + rad; x++) {\n      const dx = x - ox, dy = y - oy, u = dx * ca + dy * sa, v = -dx * sa + dy * ca;\n      if (u >= x0 - 0.5 && u \u003c= x1 + 0.5 && v >= y0 - 0.5 && v \u003c= y1 + 0.5) put(S, x, y, typeof c === \"function\" ? c(u, v, x, y) : c);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const F = S.F, L = S.L, lx = S.lx, ly = S.ly - 1, g = S.glow;\n  // The room in the lamplight.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - lx, dy = (y - ly) * 0.85, n = y * W + x;\n      const f = (g * 1.1) / (1 + (dx * dx + dy * dy) / 380);\n      L[n] = f;\n      const c = ramp(f * S.tex[n]);\n      F[n * 3] = c[0];\n      F[n * 3 + 1] = c[1];\n      F[n * 3 + 2] = c[2];\n    }\n  const DARK = [0.03, 0.008, 0.05];\n\n  // The picture: a gilt frame round a dim portrait, hanging on a nail.\n  const pc = cos(S.pic), ps = sin(S.pic), cord = lit(S, [0.6, 0.5, 0.4], NAIL_X, NAIL_Y);\n  for (const u of [-6, 6]) seg(S, NAIL_X, NAIL_Y, NAIL_X + u * pc - 4 * ps, NAIL_Y + u * ps + 4 * pc, 0.45, cord);\n  const gold = lit(S, [1, 0.72, 0.2], NAIL_X, NAIL_Y + 12, 0.45), canvas = lit(S, [0.16, 0.12, 0.3], NAIL_X, NAIL_Y + 12);\n  const face = lit(S, [0.75, 0.62, 0.7], NAIL_X, NAIL_Y + 12, 0.25);\n  box(S, NAIL_X, NAIL_Y, S.pic, -FW / 2, 3, FW / 2, 3 + FH, (u, v) => {\n    if (abs(u) > FW / 2 - 2 || v \u003c 5 || v > FH + 1) return gold;\n    // The sitter: a pale oval head over dark shoulders.\n    const hu = u / 2.6, hv = (v - 11) / 3.4;\n    if (hu * hu + hv * hv \u003c 1) return face;\n    if (v > 16 && abs(u) \u003c 5 - (v - 16) * -0.4) return DARK;\n    return canvas;\n  });\n\n  // The clock: a pale face with a dark rim and two hands.\n  const cface = lit(S, [0.95, 0.9, 0.75], CLX, CLY, 0.3), rim = lit(S, [0.35, 0.18, 0.45], CLX, CLY, 0.3);\n  for (let y = CLY - CLR; y \u003c= CLY + CLR; y++)\n    for (let x = CLX - CLR; x \u003c= CLX + CLR; x++) {\n      const r = sqrt((x - CLX) ** 2 + (y - CLY) ** 2);\n      if (r \u003c= CLR) put(S, x, y, r > CLR - 1.5 ? rim : cface);\n    }\n  seg(S, CLX, CLY, CLX + 3.5 * sin(S.hands[0]), CLY - 3.5 * cos(S.hands[0]), 0.6, DARK);\n  seg(S, CLX, CLY, CLX + 5.5 * sin(S.hands[1]), CLY - 5.5 * cos(S.hands[1]), 0.5, DARK);\n\n  // The shelf and the table.\n  seg(S, SX0, SHELF, SX1, SHELF, 0.6, lit(S, [0.45, 0.25, 0.55], 51, SHELF));\n  const cloth = lit(S, [0.75, 0.6, 1], 20, TOP + 3, 0.25);\n  for (let y = TOP; y \u003c= TOP + 7; y++)\n    for (let x = TX0; x \u003c= TX1; x++) put(S, x, y, y === TOP || (y === TOP + 7 && (x & 3) === 0) ? lit(S, [1, 0.9, 1], x, y, 0.3) : (x - TX0) % 5 === 2 ? lit(S, [0.55, 0.42, 0.8], x, y, 0.25) : cloth);\n  for (const lxg of [TX0 + 3, TX1 - 3]) seg(S, lxg, TOP + 8, lxg, 121, 0.7, DARK);\n  seg(S, TX0 + 3, 113, TX1 - 3, 113, 0.5, DARK);\n\n  // Ectoplasm: added light in the trail colour, in steps of a twelfth, under\n  // the things that leave it.\n  // It also pools on the floor as a low mist that rolls and thickens while\n  // the spirit is about.\n  const ec = hsv(0.31 + S.hue, 0.85, 1), E = S.E, M = 0.2 + 0.16 * S.mist;\n  for (let x = 0; x \u003c W; x++) {\n    // Its top rolls along in two slow waves going opposite ways.\n    const top = BASE + 2 - 8 * S.mist + 2.5 * sin(x * 0.13 + S.t * 0.7) + 1.5 * sin(x * 0.31 - S.t * 1.1);\n    for (let y = max(0, floor(top)); y \u003c H; y++) {\n      const n = y * W + x;\n      E[n] = max(E[n], cl((y - top) / 22, 0, 1) * M * (0.8 + 0.2 * sin(x * 0.07 - S.t * 0.5 + y * 0.05)));\n    }\n  }\n  for (let n = 0; n \u003c N; n++) {\n    const e = round(E[n] * 12) / 12;\n    if (e \u003c= 0) continue;\n    F[n * 3] = min(1, F[n * 3] * (1 - 0.5 * e) + ec[0] * e);\n    F[n * 3 + 1] = min(1, F[n * 3 + 1] * (1 - 0.5 * e) + ec[1] * e);\n    F[n * 3 + 2] = min(1, F[n * 3 + 2] * (1 - 0.5 * e) + ec[2] * e);\n  }\n  // The chair: a dark shape against the lit wall, with a rim of lamplight.\n  const C = S.chair, cx = CHX, cy = CHY - C.h;\n  const rimC = lit(S, [1, 0.6, 0.3], cx, cy - 12, 0.15);\n  // Seen from the side: the back leg runs on up into the back, the front leg\n  // stops at the seat, so it reads as a chair and not a ladder.\n  const chairCol = (u, v) => (v \u003c -21.5 || (v \u003c -1.2 && u \u003c 3) ? rimC : DARK);\n  const parts = [[-8, -2, 7, 1], [4, -23, 7, 22], [-8, 2, -6, 22], [-6, 13, 4, 14], [3, -12, 7, -10]];\n  for (const [x0, y0, x1, y1] of parts) box(S, cx, cy, C.tilt, x0, y0, x1, y1, chairCol);\n\n  // Books on the shelf stand upright; books on the table or the floor lie\n  // closed; books in the air open into a V and flap like wings.\n  const tremble = S.phase === \"stir\" ? 0.6 * sm(S.pt / STIR) : S.phase === \"fly\" ? 0.4 : 0;\n  for (const o of S.things) {\n    const air = o.state === \"fly\" || o.state === \"fall\" || (o.state === \"lift\" && o.lift > 0);\n    const jx = !air && tremble ? (Math.random() - 0.5) * 2 * tremble : 0, jy = !air && tremble && Math.random() \u003c tremble * 0.5 ? -1 : 0;\n    const x = (air ? o.x : o.rx) + jx, y = (air ? o.y : o.ry) + jy;\n    if (o.kind === 0) {\n      const col = lit(S, o.col, x, y, 0.35), pg = lit(S, PAGES, x, y, 0.4);\n      if (o.state === \"fall\" || (air && o.lift \u003c 0.15)) box(S, x, y, o.spin * 0.5, -3, -1, 3, 0, (u, v) => (v \u003c -0.5 ? col : pg));\n      else if (air) {\n        // Wings: each cover from the spine out to a tip that beats up and down.\n        const beat = 0.85 * sin(o.flap), L5 = 6.5;\n        for (const s of [-1, 1]) {\n          const a = o.tilt * s + beat, tx = x + s * L5 * cos(a), ty = y - L5 * sin(a);\n          seg(S, x, y, tx, ty, 0.9, col);\n          seg(S, x, y - 1, x + s * 3.8 * cos(a), y - 1 - 3.8 * sin(a), 0.45, pg);\n        }\n      } else if (o.pose === 0) box(S, x, y, 0, -1, -3, 0, 3, (u, v) => (v \u003c -2.5 ? pg : col));\n      else box(S, x, y, 0, -3, -1, 3, 0, (u, v) => (v \u003c -0.5 ? col : pg));\n    } else {\n      // A plate: a cream disc with a blue rim, seen flat on the table and\n      // tumbling edge over edge in the air.\n      const a = 3.1, b = air ? 0.6 + 2.5 * abs(sin(o.spin)) : 0.9, rot = air ? 0.4 * sin(o.spin * 0.37) : 0;\n      const cream = lit(S, [1, 0.96, 0.85], x, y, 0.62), blue = lit(S, [0.35, 0.45, 1], x, y, 0.62);\n      const ca = cos(rot), sa = sin(rot);\n      for (let yy = floor(y - 4); yy \u003c= y + 4; yy++)\n        for (let xx = floor(x - 4); xx \u003c= x + 4; xx++) {\n          const dx = xx - x, dy = yy - y, u = (dx * ca + dy * sa) / a, v = (-dx * sa + dy * ca) / b, r = u * u + v * v;\n          if (r \u003c= 1.15) put(S, xx, yy, r > 0.55 ? blue : cream);\n        }\n    }\n  }\n\n  // The lamp: chain, brass cap, the glass chimney with the flame, the oil font.\n  const th = atan2(S.lx - HOOK_X, S.ly + 2);\n  for (let s = 0; s \u003c CHAIN - 6; s += 2) put(S, HOOK_X + s * sin(th), s * cos(th), lit(S, [0.75, 0.6, 0.5], HOOK_X, s, 0.2));\n  // Its iron cap and font are dark against its own pool of light.\n  const iron = [0.1, 0.03, 0.12], edge = [1, 0.6, 0.15], glass = [1, 0.95 * min(1, g), 0.55 * min(1, g)];\n  box(S, S.lx, S.ly, -th, -4, -7, 4, -5, (u, v) => (v > -5.5 ? edge : iron));\n  box(S, S.lx, S.ly, -th, -2, -4, 2, 2, (u, v) => (abs(u) \u003c 1 && v > -2 ? [1, 1, 0.85] : glass));\n  box(S, S.lx, S.ly, -th, -4, 3, 4, 6, (u, v) => (v \u003c 3.5 ? edge : iron));\n\n  for (const p of S.dust) put(S, p.x, p.y, [0.8, 0.72, 0.85], 0.7 * p.life);\n\n  // The crash shakes the whole room for a moment.\n  const sx = S.shake > 0 ? round((Math.random() - 0.5) * 3) : 0, sy = S.shake > 0 ? round((Math.random() - 0.5) * 3) : 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const xx = cl(x + sx, 0, W - 1), yy = cl(y + sy, 0, H - 1), n = (yy * W + xx) * 3;\n      display.setPixel(x, y, round(255 * F[n]), round(255 * F[n + 1]), round(255 * F[n + 2]));\n    }\n}\n","polya-orchard":"// ===== Patternflow pattern =====\n// Title:   Pólya's Orchard\n// Family:  space\n// Idea:    Seen from above, a lantern at the centre of a round orchard of trunks on the integer lattice throws a shadow wedge behind every trunk, and as the trunks slowly thicken towards Pólya's threshold 1/R the lines of sight that escape between them narrow into thin rays and go out one by one, the last eight towards the lattice points just outside the orchard, until no ray leaves, then the trunks thin and the starburst comes back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pólya's orchard problem (George Pólya, 1918), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Trunk=0.45..0.95, Walk=0..1\n//\n// Knob 1: Hue. Turns the lantern light round the colour wheel: aqua at 0, blue at 0.15, violet at 0.3, pink at 0.45, orange at 0.6, yellow at 0.67 and green at 0.83; the escaping rays are a paler tint of it, and the lit faces of the trunks sit about a third of the wheel away (pink when the light is aqua).\n// Knob 2: Speed. How fast the trunks breathe: at 2 one breath, thin to thick and back, takes 8 seconds; at 0.2 it takes 80 seconds and at 3 it takes 5.3.\n// Knob 3: Trunk. The thinnest the trunks get, as a multiple of the threshold radius 1/R; the thickest is always 1.03, just past it. At 0.45 all 32 rays open and then go out in four groups of eight, at 0.69, 0.74, 0.80 and 0.97; at 0.95 only the last eight ever open, as hairlines.\n// Knob 4: Walk. The observer walks a small loop off the lattice point, which breaks the eightfold symmetry so the rays of one group go out one at a time, and sweeps the gaps round. At 0 the observer stands still on the point; at 0.06 the loop is 0.015 of a tree spacing across; at 1 it is a quarter of a spacing and some rays escape past the threshold.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, sqrt, sin, cos, atan2, asin, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst q = (v, n) => round(v * n) / n;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The orchard: every lattice point within radius R of the origin but the\n// origin itself. R = 4 gives 48 trees and 32 directions in which a thin\n// enough line of sight escapes (between Farey neighbours of the visible\n// points). The lattice spacing in LEDs puts the circle 30 LEDs across each\n// way from the centre, so the orchard fills the panel width and the rows\n// above and below it show only the light that gets out.\nconst R = 4, SP = 7.5, CX = 31.5, CY = 63.5;\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\nconst TREES = [];\nfor (let j = -R; j \u003c= R; j++)\n  for (let i = -R; i \u003c= R; i++)\n    if ((i || j) && i * i + j * j \u003c= R * R) TREES.push({ i, j, x: CX + SP * i, y: CY + SP * j, seen: gcd(abs(i), abs(j)) === 1 });\nconst NT = TREES.length;\n// Which tree stands at lattice point (i, j), for the trunk lookup per LED.\nconst AT = new Int16Array((2 * R + 1) * (2 * R + 1)).fill(-1);\nTREES.forEach((T, k) => (AT[(T.j + R) * (2 * R + 1) + T.i + R] = k));\n// The thickest the trunks get, as a multiple of 1/R: a little past Pólya's\n// bound, so at the top of every breath the orchard is closed in every direction.\nconst TOP = 1.03;\n// Shadows are found per LED through a table of angle bins: each bin lists\n// the trees whose shadow wedge (padded by an LED's angular size) reaches it.\nconst NB = 720;\n\nexport function setup(params) {\n  const bins = [];\n  for (let b = 0; b \u003c NB; b++) bins.push([]);\n  params.s = {\n    t: 0, hue: 0, speed: 2, thin: 0.45, walk: 0.06, rR: 0.3, ox: CX, oy: CY,\n    bins, ta: new Float32Array(NT), td: new Float32Array(NT), tw: new Float32Array(NT), lit: new Float32Array(NT),\n    lo: new Float32Array(64), hi: new Float32Array(64),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.thin = cl(k[2], 0.45, 0.95);\n  S.walk = cl(k[3], 0, 1);\n  S.t += d * S.speed;\n  // One breath is 16 story seconds (8 s at Speed 2). It starts thin, so the\n  // picture opens on the full starburst, and runs at an even pace through\n  // the middle, where the rays narrow and go out, easing only at its ends.\n  const p = (S.t / 16) % 1, tri = 1 - abs(2 * p - 1);\n  S.rR = S.thin + (TOP - S.thin) * (0.5 * tri + 0.5 * tri * tri * (3 - 2 * tri));\n  // The walk: a small loop round the lattice point, two lobes so it never\n  // repeats the breath. A quarter of a spacing across at Walk 1.\n  const w = S.walk * 0.125 * SP, u = (TAU * S.t) / 11.3;\n  S.ox = CX + w * cos(u) + 0.35 * w * sin(2 * u);\n  S.oy = CY + w * sin(u);\n}\n\n// Length of the union of the intervals [lo[i], hi[i]], i \u003c n (already clipped\n// to the LED's window). n is small, so an insertion sort is the cheap way.\nfunction union(lo, hi, n) {\n  for (let i = 1; i \u003c n; i++) {\n    const a = lo[i], bb = hi[i];\n    let j = i - 1;\n    while (j >= 0 && lo[j] > a) {\n      lo[j + 1] = lo[j];\n      hi[j + 1] = hi[j];\n      j--;\n    }\n    lo[j + 1] = a;\n    hi[j + 1] = bb;\n  }\n  let sum = 0, a = lo[0], e = hi[0];\n  for (let i = 1; i \u003c n; i++) {\n    if (lo[i] > e) {\n      sum += e - a;\n      a = lo[i];\n      e = hi[i];\n    } else if (hi[i] > e) e = hi[i];\n  }\n  return sum + e - a;\n}\n\nconst wrap = (a) => (a > PI ? a - TAU : a \u003c -PI ? a + TAU : a);\n\n// The share of the angular window [phi - hw, phi + hw] that the shadows of\n// the trees nearer than rho leave in the light. Exact for the wedges, so a\n// ray narrower than an LED dims in proportion instead of flickering.\nfunction lightAt(S, phi, hw, rho, skip) {\n  const list = S.bins[min(NB - 1, floor(((phi + PI) / TAU) * NB))];\n  let n = 0;\n  for (let m = 0; m \u003c list.length; m++) {\n    const k = list[m];\n    if (k === skip || S.td[k] >= rho) continue;\n    const rel = wrap(S.ta[k] - phi), w = S.tw[k];\n    const lo = max(-hw, rel - w), hi = min(hw, rel + w);\n    if (lo \u003c hi) {\n      S.lo[n] = lo;\n      S.hi[n] = hi;\n      n++;\n    }\n  }\n  return n ? max(0, 1 - union(S.lo, S.hi, n) / (2 * hw)) : 1;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rr = (S.rR / R) * SP, ox = S.ox, oy = S.oy;\n  // Each tree's direction, distance and the half angle of its shadow wedge,\n  // then the bins its padded wedge covers.\n  for (const list of S.bins) list.length = 0;\n  for (let k = 0; k \u003c NT; k++) {\n    const T = TREES[k], dx = T.x - ox, dy = T.y - oy, dd = sqrt(dx * dx + dy * dy);\n    S.ta[k] = atan2(dy, dx);\n    S.td[k] = dd;\n    S.tw[k] = asin(min(1, rr / dd));\n    const pad = S.tw[k] + 0.6 / max(1, dd - rr);\n    const b0 = floor(((S.ta[k] - pad + PI) / TAU) * NB), b1 = floor(((S.ta[k] + pad + PI) / TAU) * NB);\n    for (let b = b0; b \u003c= b1; b++) S.bins[((b % NB) + NB) % NB].push(k);\n  }\n  // How much of each trunk's near face the lantern reaches: the visible trees\n  // are the ones with coprime coordinates, Euclid's orchard.\n  for (let k = 0; k \u003c NT; k++) S.lit[k] = lightAt(S, S.ta[k], max(0.004, S.tw[k] * 0.8), S.td[k] - 0.01, k);\n\n  const h = 0.5 + S.hue;\n  const LAMP = hsv(h, 0.72, 1), RAY = hsv(h + 0.05, 0.36, 1), FACE = hsv(h + 0.36, 0.55, 1);\n  const SHADE = [0.035, 0.02, 0.075], CORE = [0.16, 0.1, 0.3], RIM = [0.01, 0, 0.02];\n  const RING = (R + 0.5) * SP;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - ox, dy = y - oy, rho = sqrt(dx * dx + dy * dy);\n      const cx = x - CX, cy = y - CY, rc = sqrt(cx * cx + cy * cy);\n      let r, g, b;\n      if (rho \u003c 2.2) {\n        // The lantern: a white core in a small halo of its own light.\n        const v = rho \u003c 1.1 ? 1 : 0.55;\n        r = v + (1 - v) * LAMP[0];\n        g = v + (1 - v) * LAMP[1];\n        b = v + (1 - v) * LAMP[2];\n      } else {\n        const phi = atan2(dy, dx), hw = min(0.4, 0.55 / rho);\n        const L = lightAt(S, phi, hw, rho, -1);\n        // The light fades with distance in steps, gently, so a ray reads as\n        // one line from the lantern to the panel's edge; past the circle the\n        // escaping light turns a paler tint.\n        const out = cl((rc - RING + 1.5) / 3, 0, 1);\n        const fall = q(1 - 0.0065 * rho, 20);\n        const col = out ? RAY : LAMP, v = L * fall;\n        r = SHADE[0] + (col[0] - SHADE[0]) * v;\n        g = SHADE[1] + (col[1] - SHADE[1]) * v;\n        b = SHADE[2] + (col[2] - SHADE[2]) * v;\n        // The edge of the orchard, a faint dotted circle where it runs in shadow.\n        if (abs(rc - RING) \u003c 0.5 && ((x + y) & 1) === 0 && v \u003c 0.2) (r = CORE[0] * 1.3), (g = CORE[1] * 1.3), (b = CORE[2] * 1.3);\n      }\n      // A trunk on this LED: the nearest lattice point within the orchard.\n      const ti = round(cx / SP), tj = round(cy / SP);\n      if ((ti || tj) && ti * ti + tj * tj \u003c= R * R) {\n        const tx = cx - SP * ti, ty = cy - SP * tj, dt = sqrt(tx * tx + ty * ty);\n        const cov = cl(rr + 0.5 - dt, 0, 1);\n        if (cov > 0) {\n          const k = AT[(tj + R) * (2 * R + 1) + ti + R];\n          // The face turned to the lantern catches its light, if the lantern\n          // reaches the trunk; the rest of the disk is a dark rim.\n          const fx = ox - (CX + SP * ti), fy = oy - (CY + SP * tj), fd = sqrt(fx * fx + fy * fy) || 1;\n          const facing = dt \u003c 0.01 ? 1 : (tx * fx + ty * fy) / (dt * fd);\n          const inner = cl(rr - 0.35 - dt, 0, 1);\n          const lit = S.lit[k] * cl(0.45 + facing, 0, 1);\n          const cr = RIM[0] + (CORE[0] + (FACE[0] - CORE[0]) * lit - RIM[0]) * inner;\n          const cg = RIM[1] + (CORE[1] + (FACE[1] - CORE[1]) * lit - RIM[1]) * inner;\n          const cb = RIM[2] + (CORE[2] + (FACE[2] - CORE[2]) * lit - RIM[2]) * inner;\n          r += (cr - r) * cov;\n          g += (cg - g) * cov;\n          b += (cb - b) * cov;\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  }\n}\n","rotor-router":"// ===== Patternflow pattern =====\n// Title:   Rotor-Router\n// Family:  sim\n// Idea:    Chips leave by turns from two sources on the centre column and walk by the arrow at every lit LED, each arrow turning a quarter turn before a chip leaves along it, and each chip stops on the first dark LED it reaches, so the lit set grows into a tall peanut with a smooth rim and a filling waist while the arrows inside, one colour for each direction, set into a lace of triangles and diagonals; when the shape reaches the sides it holds, dissolves from the rim inward and grows again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rotor-router walk, the Eulerian walkers of Vyatcheslav Priezzhev, Deepak Dhar, Abhishek Dhar and Supriya Krishnamurthy (1996), with the disk and smash sum of Lionel Levine and Yuval Peres (2009), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Join=0..1, Random=0..1\n//\n// Knob 1: Hue. Turns the four arrow colours round the wheel together: at 0 north is cream, east teal, south deep purple and west pink; at 0.5 east is crimson, south dark green and west aqua. North stays a pale tint.\n// Knob 2: Speed. Arrow steps a frame, which grow with the shape so its area grows at a steady rate: at 2 the peanut of about 5,500 LEDs grows in 4.2 seconds, holds 1.3, dissolves in 1 and starts again 0.3 later; at 3 it grows in 2.8 seconds, at 0.2 in 42.\n// Knob 3: Join. Slides the two sources together along the centre column: at 0 they sit on rows 40 and 87 and grow two disks that meet and fill in the waist; at 0.5 on rows 52 and 75 and the shape is an oval; at 1 on rows 64 and 63, side by side, and the chips grow one disk of about 2,800 LEDs, 60 across.\n// Knob 4: Random. The chance that a step ignores its arrow and goes a random way, which then becomes the arrow, is the square of the knob: one step in 280 at 0.06, one in 16 at 0.25, every step at 1. At 1 the walk is internal DLA, the rim turns ragged and the lace inside turns to noise.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Arrow directions N, E, S, W as steps on the LED index.\nconst STEP = [-W, 1, W, -1];\n// The four arrow colours: hue at Hue 0, saturation, value. One pale, two\n// strong and one dark: four hues alone at one brightness read as confetti on\n// a 64 LED wide disk, and the brightness steps are what bring out the\n// triangles and diagonals of the arrows.\nconst ARROW = [\n  [0.1, 0.12, 1],\n  [0.47, 1, 0.8],\n  [0.8, 1, 0.6],\n  [0.93, 0.65, 1],\n];\n// The sources sit on the centre column, mirrored about the middle of the\n// panel; how far each one sits from the middle at Join 0.\nconst SX = 32, HALF = 24;\n// How long the shape holds once it reaches a side, how long it takes to\n// dissolve, and the dark pause before it grows again, in seconds at Speed 2.\nconst HOLD = 1.3, MELT = 1, PAUSE = 0.3;\n// Steps a frame at Speed 1: A plus B for every lit LED. A chip's walk from\n// a source to the rim takes about a sixth as many steps as there are lit\n// LEDs, so this lets through about 20 chips a frame at any size and the area\n// grows at a steady rate instead of slowing down as the shape gets big.\nconst A = 500, B = 3.4;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, join: 0, rand: 0.0036,\n    occ: new Uint8Array(N), rot: new Uint8Array(N), born: new Float32Array(N), key: new Float32Array(N),\n    lit: 0, t0: 0, grown: 0, chip: -1, next: 0, src: [0, 0], gap: -1,\n    phase: 0, clock: 0, cycle: 0, turn: 1,\n    pal: null, palHue: NaN,\n  };\n  for (let i = 0; i \u003c N; i++) params.s.key[i] = Math.random();\n}\n\n// Clear the lattice and set the arrows. The top half starts with every arrow\n// one way and turns clockwise; the bottom half is its mirror image, its\n// arrows reflected and turning the other way, so the two lobes come up as\n// mirror images of each other. Each round starts from another direction and\n// every fourth round swaps the turning, so the lace comes up new each time.\nfunction start(S) {\n  S.cycle++;\n  const d0 = S.cycle & 3;\n  S.turn = (S.cycle >> 2) & 1 ? 3 : 1;\n  S.occ.fill(0);\n  S.rot.fill(d0, 0, N / 2);\n  S.rot.fill((2 - d0) & 3, N / 2);\n  S.lit = 0;\n  S.chip = -1;\n  S.next = 0;\n  S.gap = round(HALF * (1 - S.join));\n  S.src = [(64 - S.gap) * W + SX, (63 + S.gap) * W + SX];\n  S.phase = 0;\n  S.clock = 0;\n  S.t0 = S.t;\n}\n\n// Run up to `budget` steps of the walk. A chip on a lit LED turns that LED's\n// arrow a quarter turn and steps where it now points; a chip on a dark LED\n// stops and lights it, and the next chip leaves from the other source. The\n// growth stops once a chip lights an LED one in from any side.\nfunction walk(S, budget) {\n  const occ = S.occ, rot = S.rot, p = S.rand, top = S.turn, bottom = 4 - S.turn, half = N / 2;\n  let chip = S.chip;\n  while (budget > 0) {\n    if (chip \u003c 0) {\n      chip = S.src[S.next];\n      S.next ^= 1;\n    }\n    if (!occ[chip]) {\n      occ[chip] = 1;\n      S.born[chip] = S.t;\n      S.lit++;\n      const x = chip % W, y = (chip / W) | 0;\n      chip = -1;\n      if (x \u003c= 1 || x >= W - 2 || y \u003c= 1 || y >= H - 2) {\n        S.phase = 1;\n        S.clock = 0;\n        S.grown = S.t;\n        break;\n      }\n      continue;\n    }\n    let d;\n    if (p > 0 && Math.random() \u003c p) d = (Math.random() * 4) | 0;\n    else d = (rot[chip] + (chip \u003c half ? top : bottom)) & 3;\n    rot[chip] = d;\n    chip += STEP[d];\n    budget--;\n  }\n  S.chip = chip;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.join = cl(k[2], 0, 1);\n  const r = cl(k[3], 0, 1);\n  S.rand = r * r;\n  S.t += d;\n  if (S.cycle === 0) start(S);\n  // Moving the sources by two LEDs or more sends the shape off to dissolve,\n  // and the next one grows from the new places.\n  if (S.phase \u003c 2 && abs(round(HALF * (1 - S.join)) - S.gap) >= 2) {\n    S.phase = 2;\n    S.clock = 0;\n    S.grown = S.t;\n  }\n  S.clock += (d * S.speed) / 2;\n  if (S.phase === 0) walk(S, round(S.speed * (A + B * S.lit)));\n  else if (S.phase === 1 && S.clock >= HOLD) (S.phase = 2), (S.clock = 0);\n  else if (S.phase === 2 && S.clock >= MELT + PAUSE) start(S);\n}\n\nfunction palette(S) {\n  S.pal = ARROW.map(([h0, s, v]) => {\n    const h = h0 + S.hue - floor(h0 + S.hue);\n    // A dark orange reads brown on LEDs, so a colour near orange is lifted\n    // toward full brightness.\n    const warm = max(0, 1 - abs(h - 0.08) / 0.1);\n    return hsv(h, s, v + (1 - v) * warm);\n  });\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cycle) return;\n  if (S.palHue !== S.hue) palette(S);\n  const pal = S.pal, occ = S.occ, rot = S.rot, born = S.born, key = S.key, t = S.t;\n  // While it dissolves the rim goes first: an LED goes dark when its share of\n  // the way from the first lit to the last lit, roughened by a fixed random\n  // key, passes the melt.\n  const melt = S.phase === 2 ? min(1, S.clock / MELT) : -1;\n  const t0 = S.t0, span = max(0.01, S.grown - t0), fade = S.speed;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (!occ[i]) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      if (melt >= 0 && 0.65 * cl((born[i] - t0) / span, 0, 1) + 0.35 * key[i] > 1 - melt) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const c = pal[rot[i]];\n      // LEDs lit in the last half second (at Speed 2) are lifted toward\n      // white, so the growing rim reads as a bright edge.\n      const fresh = cl(1 - (t - born[i]) * fade, 0, 1) * 0.5;\n      display.setPixel(x, y, round(255 * (c[0] + (1 - c[0]) * fresh)), round(255 * (c[1] + (1 - c[1]) * fresh)), round(255 * (c[2] + (1 - c[2]) * fresh)));\n    }\n  // The sources, white.\n  for (const s of S.src) if (occ[s] && melt \u003c 0) display.setPixel(s % W, (s / W) | 0, 255, 255, 255);\n}\n","ballistic-annihilation":"// ===== Patternflow pattern =====\n// Title:   Ballistic Annihilation\n// Family:  particle\n// Idea:    A gun at the foot of the panel fires one bullet a beat straight up at one of three speeds, and the panel is their space-time diagram, the gun's present at the right edge and the past scrolling left, so each bullet is a straight rising line of its speed's slope that ends in a spark where a faster bullet catches a slower one and both vanish.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: ballistic annihilation (Yves Elskens and Harry Frisch, 1985); with three speeds the middle ones survive exactly when their share is over 1/4 (Droz, Rey, Frachebourg and Piasecki, 1995; proved by Haslegrave, Sidoravicius and Tournier, 2018)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Middle=-1..1, Spread=-1..1\n//\n// Knob 1: Hue. Turns the three bullet colours round the wheel together. At 0 slow bullets are magenta, middle ones gold and fast ones cyan; at 0.33 slow lime, middle aqua and fast purple.\n// Knob 2: Speed. Columns of time a second. At 2 the diagram scrolls 8 columns a second, the gun fires twice a second and a middle bullet climbs the 128 rows in 8 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Middle. The share p of middle-speed bullets, p = 0.25 + 0.15 x knob, from 0.10 at -1 to 0.40 at 1, the rest split evenly between slow and fast. It opens at 0, the critical 1/4: above it a middle bullet outlives every collision with positive probability, at or below it every middle bullet is caught in the end. On the panel 14% of the middle bullets reach the top at -1, 22% at 0 and 33% at 1.\n// Knob 4: Spread. How far the slow and fast speeds sit from the middle one, which climbs 2 rows a column. Their paces (columns a row) sit symmetric round the middle's, 1/2 x (1 +- r) with r = 0.35 + 0.25 x knob. At -1 r is 0.1, the speeds 1.82, 2 and 2.22 rows a column, the lines nearly parallel and a third of the bullets reach the top; at 0.06 the speeds are 1.47, 2 and 3.15 and a fifth reach it; at 1 they are 1.25, 2 and 5, the first meetings come 7 rows over the gun and one bullet in seven reaches the top. The spread changes where bullets meet, never which ones meet.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Time runs in columns of the diagram. The gun fires every BEAT columns on\n// average; each gap is drawn from 0.9 to 1.1 of it, so no three bullets ever\n// meet at one point and the threshold stays the one for any spacing.\nconst BEAT = 4, WOB = 0.2;\n// The middle speed in rows a column: a middle bullet crosses the 128 rows\n// while the diagram scrolls its 64 columns, so a survivor runs corner to\n// corner.\nconst VM = 2;\n// Columns a second at Speed 1.\nconst RATE = 4;\n// Slow, middle and fast on the wheel at Hue 0: magenta, gold, cyan.\nconst HUES = [0.9, 0.135, 0.52];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: 0, speed: 2, p: 0.25, r: 0.365,\n    now: 0, next: 0, top: H + 2, keep: true,\n    live: [], done: [], sparks: [], shot: [0, 0, 0], out: [0, 0, 0], muzzle: 0, mk: 1,\n    pal: [new Float32Array(3), new Float32Array(3), new Float32Array(3)],\n    tip: [new Float32Array(3), new Float32Array(3), new Float32Array(3)],\n    rgb: new Uint8Array(W * H * 3),\n  };\n}\n\n// Speed of class k (0 slow, 1 middle, 2 fast) in rows a column. The paces,\n// not the speeds, sit symmetric round the middle: swap time and height in\n// the diagram and the gun's bullets become particles spaced along a line at\n// relative speeds -r, 0 and +r, the three-speed problem the 1/4 belongs to.\nconst speedOf = (k, r) => VM / (1 + r * (1 - k));\n\nfunction fire(S, t) {\n  const u = Math.random(), q = (1 - S.p) / 2;\n  const k = u \u003c q ? 0 : u \u003c q + S.p ? 1 : 2;\n  S.live.push({ t0: t, v: speedOf(k, S.r), k, t1: 0 });\n  S.shot[k]++;\n  S.muzzle = t;\n  S.mk = k;\n  S.next = t + BEAT * (1 + WOB * (Math.random() - 0.5));\n}\n\n// Run the gun and its bullets on to time t1. The live bullets sit in firing\n// order, which is also height order, oldest and highest first: two bullets\n// cannot pass without meeting. So the next event is a shot, the oldest\n// bullet leaving over the top, or the earliest meeting of two neighbours in\n// the list, a newer bullet faster than the one above it. Each is taken at\n// its exact time; a meeting removes both and makes their outer neighbours\n// the new pair.\nfunction advance(S, t1) {\n  const L = S.live;\n  for (;;) {\n    let tc = Infinity, at = -1;\n    for (let i = 0; i + 1 \u003c L.length; i++) {\n      const a = L[i], b = L[i + 1];\n      if (b.v \u003c= a.v) continue;\n      const t = (b.v * b.t0 - a.v * a.t0) / (b.v - a.v);\n      if (t \u003c tc) (tc = t), (at = i);\n    }\n    const te = L.length ? L[0].t0 + S.top / L[0].v : Infinity;\n    const t = min(tc, te, S.next);\n    if (t > t1) break;\n    if (t === S.next) fire(S, t);\n    else if (t === tc) {\n      const a = L[at], b = L[at + 1], h = a.v * (t - a.t0);\n      a.t1 = b.t1 = t;\n      L.splice(at, 2);\n      if (S.keep) {\n        S.done.push(a, b);\n        S.sparks.push({ t, h });\n      }\n    } else {\n      const a = L.shift();\n      a.t1 = t;\n      S.out[a.k]++;\n      if (S.keep) S.done.push(a);\n    }\n  }\n  S.now = t1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.p = 0.25 + 0.15 * cl(k[2], -1, 1);\n  S.r = 0.35 + 0.25 * cl(k[3], -1, 1);\n  // The first frame already shows a full diagram: the gun has been firing\n  // for as long as the slowest bullet takes to clear the panel's 64 columns.\n  if (!S.begun) {\n    S.begun = true;\n    fire(S, 0);\n    advance(S, W + H / speedOf(0, S.r) + 8);\n  }\n  advance(S, S.now + cl(dt || 0, 0, 0.1) * S.speed * RATE);\n  // Forget lines and sparks that have scrolled off the left edge.\n  const left = floor(S.now) - W - 2;\n  if (S.done.length > 400 || S.sparks.length > 200 || (S.done.length && S.done[0].t1 \u003c left)) {\n    S.done = S.done.filter((b) => b.t1 >= left);\n    S.sparks = S.sparks.filter((s) => s.t >= left - 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const { rgb, pal, tip } = S;\n  rgb.fill(0);\n  for (let k = 0; k \u003c 3; k++) {\n    hsv(HUES[k] + S.hue, k === 1 ? 0.88 : 0.82, 1, pal[k]);\n    hsv(HUES[k] + S.hue, 0.3, 1, tip[k]);\n  }\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = round(c[0] * a * 255);\n    rgb[o + 1] = round(c[1] * a * 255);\n    rgb[o + 2] = round(c[2] * a * 255);\n  };\n  // Time T sits in column T + off: the diagram moves a whole column at a\n  // time, and the heads grow smoothly up the right edge.\n  const nq = floor(S.now), off = W - 1 - nq;\n  const line = (b, live) => {\n    const end = live ? S.now : b.t1, top = min(H - 1, floor(b.v * (end - b.t0)));\n    const c = pal[b.k];\n    for (let h = 0; h \u003c= top; h++) {\n      let x = round(b.t0 + h / b.v + off);\n      if (x > W - 1) x = W - 1;\n      if (x \u003c 0) continue;\n      const y = H - 1 - h, head = live && h > top - 3;\n      put(x - 1, y, head ? tip[b.k] : c, 1);\n      put(x, y, head ? tip[b.k] : c, 1);\n    }\n  };\n  // Middle bullets last, over the others: they are the ones the question is\n  // about.\n  for (const k of [0, 2, 1]) {\n    for (const b of S.done) if (b.k === k && b.t1 + off >= -1) line(b, false);\n    for (const b of S.live) if (b.k === k) line(b, true);\n  }\n  // Sparks: a burst for the first three columns, then a small white cross\n  // that stays on the diagram where the two lines end.\n  const white = [1, 0.97, 0.88], hot = [1, 0.75, 0.35];\n  for (const s of S.sparks) {\n    const x = round(s.t + off) - 1, y = H - 1 - round(s.h), age = S.now - s.t;\n    if (x \u003c -4) continue;\n    if (age \u003c 3) {\n      const r = 1 + floor(age);\n      for (let d = -r - 1; d \u003c= r + 1; d++) {\n        put(x + d, y, hot, 1);\n        put(x, y + d, hot, 1);\n      }\n      for (let d = -r; d \u003c= r; d++) {\n        put(x + d, y + d, hot, 0.8);\n        put(x + d, y - d, hot, 0.8);\n      }\n    }\n    for (let d = -2; d \u003c= 2; d++) {\n      put(x + d, y, white, 1);\n      put(x, y + d, white, 1);\n    }\n  }\n  // The gun's muzzle flash at the foot of the right edge.\n  const m = S.now - S.muzzle;\n  if (m \u003c 1.2) {\n    const a = 1 - m / 1.2;\n    for (let y = H - 3; y \u003c H; y++) for (let x = W - 3; x \u003c W; x++) put(x, y, tip[S.mk], a);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o], rgb[o + 1], rgb[o + 2]);\n}\n","black-cat":"// ===== Patternflow pattern =====\n// Title:   Black Cat\n// Family:  halloween\n// Idea:    A big black cat sits in profile on a garden wall against a low harvest moon beside a jack-o'-lantern, swishing its tail in slow S-curves, twitching its ears and following the bats round the moon with glowing eyes, and now and then it arches its back, fur on end and mouth open in a hiss, before it settles again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mood=0..1, Startle=0..1\n//\n// Knob 1: Hue. The moon and the light it throws round the cat's edges and whiskers, with the eyes in the colour opposite; the jack-o'-lantern stays candle orange. At 0 a harvest orange moon and toxic green eyes; at 0.25 a green moon and blue eyes, at 0.5 a cold blue moon and magenta eyes, at 0.75 a magenta moon and orange eyes.\n// Knob 2: Speed. The cat's clock. At 2 a wave runs down the tail every 2.6 seconds while the whole curl sways once in 5.2, the tail snaps upright every 1.6 to 3.2 seconds, the cat blinks every 2 to 5 seconds and the bats flap 4.5 times a second; at 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Mood. At 0 the cat is watchful: the wave on its tail bends each joint 0.3 rad, the ears stand up, the pupils are wide. At 1 it is furious: the wave runs 1.7 times as fast and bends 0.52 rad, the tail snaps up 2.4 times as often, the cat leans 0.12 rad forward over its paws, its ears are laid back, its eyes narrow to slits and the fur along its back stands up.\n// Knob 4: Startle. How often it arches and hisses: up in 0.35 s, held 1.6 s, down in 1.2 s. At 0.06 the first arch comes at 3.1 s and the next 11.5 s after the last has settled; at 1 the first comes at 0.5 s and the next 3 s after.\n// Buttons: K4 tap startles it into an arch at once.\n\nconst W = 64, H = 128, N = W * H, WALL = 102;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Signed distances in LEDs: negative inside.\nconst circle = (px, py, cx, cy, r) => sqrt((px - cx) ** 2 + (py - cy) ** 2) - r;\nfunction capsule(px, py, ax, ay, bx, by, ra, rb) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey || 1), 0, 1);\n  return sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) - (ra + (rb - ra) * u);\n}\nfunction tri(px, py, v) {\n  let dd = 1e9, s = 1;\n  for (let i = 0, j = 4; i \u003c 6; j = i, i += 2) {\n    const ex = v[j] - v[i], ey = v[j + 1] - v[i + 1], wx = px - v[i], wy = py - v[i + 1];\n    const u = cl((wx * ex + wy * ey) / (ex * ex + ey * ey), 0, 1), bx = wx - ex * u, by = wy - ey * u;\n    dd = min(dd, bx * bx + by * by);\n    const c1 = py >= v[i + 1], c2 = py \u003c v[j + 1], c3 = ex * wy > ey * wx;\n    if ((c1 && c2 && c3) || (!c1 && !c2 && !c3)) s = -s;\n  }\n  return s * sqrt(dd);\n}\n// Smooth union, so the parts of the cat grow into one another.\nconst smin = (a, b, k) => {\n  const h = cl(0.5 + (0.5 * (b - a)) / k, 0, 1);\n  return b + (a - b) * h - k * h * (1 - h);\n};\n\n// The moon: centre and radius, and its seas in three tones.\nconst MX = 43, MY = 47, MR = 26;\nconst SEAS = [[-9, -9, 7, 5], [6, -12, 6, 4], [11, 2, 6, 7], [-12, 6, 5, 7], [2, 12, 7, 4]];\nconst MOONT = new Float32Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n    if (r > MR + 1) continue;\n    let e = 9;\n    for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2);\n    MOONT[y * W + x] = (e \u003c 1 ? 0.8 : e \u003c 1.6 ? 0.9 : 1) * cl(MR + 0.5 - r, 0, 1);\n  }\n// Sky by row, in eight steps: near black at the top, a purple band over the wall.\nconst SKY = new Float32Array(H * 3);\nfor (let y = 0; y \u003c H; y++) {\n  const t = round(8 * sm(10, WALL, y)) / 8;\n  SKY[3 * y] = 0.02 + 0.17 * t;\n  SKY[3 * y + 1] = 0.008 + 0.05 * t;\n  SKY[3 * y + 2] = 0.05 + 0.22 * t;\n}\n// Stars, as each LED's twinkle phase (or -1); and the moon's glow by LED.\nconst STAR = new Float32Array(N).fill(-1), GLOW = new Float32Array(N);\nfor (let i = 0, n = 0; n \u003c 16 && i \u003c 400; i++) {\n  const x = floor(hash(i * 3 + 11) * W), y = floor(hash(i * 3 + 12) * 92);\n  if ((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2 \u003c (MR + 6) ** 2) continue;\n  STAR[y * W + x] = hash(i * 3 + 13) * 6.28;\n  n++;\n}\nfor (let p = 0; p \u003c N; p++) {\n  const out = max(0, sqrt(((p % W) + 0.5 - MX) ** 2 + (floor(p / W) + 0.5 - MY) ** 2) - MR);\n  GLOW[p] = round((0.22 * exp(-out / 5) + 0.08 * exp(-out / 16)) * 16) / 16;\n}\n\n// A jack-o'-lantern on the wall by the cat's front paws, as pixel art:\n// s stem, o skin, f the carved face lit from inside.\nconst PUMPKIN = [\n  \"........ss.......\",\n  \".......ss........\",\n  \"....ooooooooo....\",\n  \"..ooooooooooooo..\",\n  \".ooooooooooooooo.\",\n  \".oooofooooofoooo.\",\n  \"ooooffoooooffoooo\",\n  \"oooffffooofffffoo\",\n  \"oooooooofoooooooo\",\n  \"oofoooooooooooofo\",\n  \"ooffffofffoffffoo\",\n  \".oofffffffffffoo.\",\n  \"..ooooffffoooo...\",\n  \"....ooooooooo....\",\n];\nconst FLAME = [1, 0.5, 0.08];\nconst PX0 = 0, PY0 = WALL - PUMPKIN.length, PCX = 8.5, PCY = WALL - 7;\n// How far its light reaches each LED, before the flame's flicker.\nconst WARM = new Float32Array(N);\nfor (let p = 0; p \u003c N; p++) WARM[p] = 0.5 * exp(-sqrt(((p % W) + 0.5 - PCX) ** 2 + ((floor(p / W) + 0.5 - PCY) * 1.3) ** 2) / 9);\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\n\n// Bats flitting round the moon, behind the cat: each loops on its own\n// figure of eight [centre x, centre y, half width, half height, rate x,\n// rate y, phase], with a jitter on top, and flaps about 4.5 times a second.\nconst BATS = [[50, 32, 11, 10, 0.53, 0.97, 0], [44, 19, 16, 7, 0.41, 0.83, 2.1], [54, 58, 7, 12, 0.67, 0.59, 4.2], [47, 45, 13, 15, 0.47, 0.71, 5.3]];\nconst batAt = (b, t) => [b[0] + b[2] * sin(b[4] * t + b[6]) + 1.5 * vn(t * 1.7, b[6] * 9), b[1] + b[3] * sin(b[5] * t + b[6] * 1.3) + 1.5 * vn(t * 1.9, b[6] * 9 + 3)];\nfunction batDist(px, py, bx, by, dir, flap) {\n  const x = (px - bx) * dir, y = py - by, ax = abs(x), tip = -1.2 + 3.2 * flap;\n  let d = sqrt((x / 1.2) ** 2 + (y / 1.7) ** 2) - 1;\n  d = min(d, tri(ax, y, [0.6, -0.9, 0.6, 0.7, 5.6, tip]));\n  d = min(d, tri(ax, y, [0.6, 0.4, 3.4, 0.6 + 1.6 * flap, 5.6, tip]));\n  d = min(d, tri(x, y, [-0.9, -1.2, 0.1, -1.4, -0.6, -2.6]));\n  return min(d, tri(x, y, [0.9, -1.2, -0.1, -1.4, 0.6, -2.6]));\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, mood: 0, startle: 0.06, t: 0, begun: false, fl: 0.72,\n    // The arch: its age (-1 when none), the wait for the next.\n    arch: -1, wait: 3.3,\n    // Eyes: blink clock, look target and where they look now; ear twitches.\n    blink: 1.5, blinkAge: 9, look: 0, lookTo: 0.6, lookWait: 1.2, tilt: 0,\n    earWait: [2.5, 4], earAge: [9, 9], lash: 9, lashWait: 0.8,\n    tail: new Float32Array(2 * 15), blk: new Uint8Array(16 * 32), tb: [0, 0, 0, 0], flap: 0, bats: BATS.map(() => [0, 0, 1]),\n    c: [0, 0, 0], e: [0, 0, 0],\n  };\n}\n\n// How far the cat is arched at an arch's age: up in 0.35 s, held 1.6 s, down in 1.2 s.\nconst archOf = (a) => (a \u003c 0 ? 0 : a \u003c 0.35 ? sm(0, 0.35, a) : a \u003c 1.95 ? 1 : 1 - sm(1.95, 3.15, a));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.mood = cl(k[2], 0, 1);\n  S.startle = cl(k[3], 0, 1);\n  if (!S.begun) {\n    S.wait = 3.3 - 2.8 * S.startle;\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // The candle in the pumpkin: two noises, about 3 and 9 times a second.\n  S.fl = 0.72 + 0.17 * vn(S.t * 2.8, 5) + 0.11 * vn(S.t * 9, 11);\n  if (input.btnPressed && input.btnPressed[3] && S.arch \u003c 0) S.arch = 0;\n  if (S.arch >= 0) {\n    S.arch += ds;\n    if (S.arch > 3.15) {\n      S.arch = -1;\n      S.wait = 12 - 9 * S.startle;\n    }\n  } else {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) S.arch = 0;\n  }\n  // The bats, and which way each is flying.\n  S.flap += ds * 2 * PI * 4.5;\n  BATS.forEach((b, i) => {\n    const [x, y] = batAt(b, S.t * 1.6), [x2] = batAt(b, S.t * 1.6 + 0.05);\n    S.bats[i] = [x, y, x2 >= x ? 1 : -1];\n  });\n  // Blinks every 2 to 5 s, each 0.18 s shut.\n  S.blink -= ds;\n  S.blinkAge += ds;\n  if (S.blink \u003c= 0) {\n    S.blinkAge = 0;\n    S.blink = 2 + 3 * Math.random();\n  }\n  // The eyes pick somewhere new to look every 1 to 3 s and get there in about 0.3 s; the head follows a little.\n  S.lookWait -= ds;\n  if (S.lookWait \u003c= 0) {\n    S.lookTo = Math.random() * 2 - 1;\n    S.lookWait = 1 + 2 * Math.random();\n  }\n  S.look += (S.lookTo - S.look) * min(1, ds * 10);\n  // The head follows the nearest bat up and down.\n  let near = 1e9, aim = 0;\n  for (const [bx, by] of S.bats) {\n    const dd = (bx - 20) ** 2 + (by - 40) ** 2;\n    if (dd \u003c near) (near = dd), (aim = cl((by - 40) / 25, -1, 1));\n  }\n  S.tilt += (-0.3 * aim + 0.06 * S.lookTo - S.tilt) * min(1, ds * 4);\n  // Now and then the tail lashes: it whips out straight in a quarter of a\n  // second and curls back over a second. Every 2.5 to 4.5 s when watchful,\n  // more than twice as often when cross.\n  S.lash += ds;\n  S.lashWait -= ds * (1 + 1.4 * S.mood);\n  if (S.lashWait \u003c= 0 && S.arch \u003c 0) {\n    S.lash = 0;\n    S.lashWait = 1.6 + 1.6 * Math.random();\n  }\n  // Each ear flicks back now and then, quicker and more often when cross.\n  for (let i = 0; i \u003c 2; i++) {\n    S.earWait[i] -= ds * (1 + S.mood);\n    S.earAge[i] += ds;\n    if (S.earWait[i] \u003c= 0) {\n      S.earAge[i] = 0;\n      S.earWait[i] = 1.5 + 3 * Math.random();\n    }\n  }\n}\n\n// The cat, built from its pose: arch a, mood m, the head's tilt and the ears.\nfunction pose(S) {\n  const a = archOf(S.arch), m = S.mood, t = S.t;\n  // The tail: fifteen joints from the root behind the haunch. It rises,\n  // then curls forward over the back like a question mark; the whole curl\n  // swings to and fro while a wave runs out to the tip. Arched, it stands\n  // straight up from the raised haunch and puffs.\n  const amp = (0.3 + 0.22 * m) * (1 - 0.7 * a), w = (2 * PI) / (2.6 / (1 + 0.7 * m));\n  const swing = (0.38 + 0.25 * m) * sin(w * 0.5 * t), la = S.lash;\n  const lash = la \u003c 0.25 ? sm(0, 0.25, la) : 1 - sm(0.25, 1.3, la);\n  let x = 48 - 2 * a, y = WALL - 6 - 26 * a, head = 0;\n  const T = S.tail;\n  for (let i = 0; i \u003c 15; i++) {\n    const u = i / 14;\n    const calm = -0.8 + swing * (1 - 0.4 * u) - 0.8 * sm(0, 0.35, u) - 1.1 * sm(0.45, 1, u) + amp * sin(w * t - 0.6 * i) * (0.25 + 0.75 * u);\n    const up = -1.5 - 0.15 * u + 0.08 * sin(w * 2 * t - 0.4 * i);\n    head = calm + (up - calm) * max(a, 0.85 * lash);\n    T[2 * i] = x;\n    T[2 * i + 1] = y;\n    x += cos(head) * 3.4;\n    y += sin(head) * 3.4;\n  }\n  // The tail's box, with room for its fur.\n  const tb = S.tb;\n  tb[0] = tb[1] = 1e9;\n  tb[2] = tb[3] = -1e9;\n  for (let i = 0; i \u003c 15; i++) {\n    tb[0] = min(tb[0], T[2 * i] - 8);\n    tb[1] = min(tb[1], T[2 * i + 1] - 8);\n    tb[2] = max(tb[2], T[2 * i] + 8);\n    tb[3] = max(tb[3], T[2 * i + 1] + 8);\n  }\n  return a;\n}\n\n// Fur standing up: a row of teeth every 2.4 LEDs along a coordinate.\nconst teeth = (v) => max(0, 1 - 3 * abs(v / 2.4 - floor(v / 2.4) - 0.5));\n\n// The cat is drawn 1.1 times the size it is laid out at, standing on the\n// wall, its middle (38 as laid out) at x = 35.\nconst SC = 1.1, AX = 35;\nconst ARC = [];\nfor (let k = 0; k \u003c= 6; k++) {\n  const th = PI + 0.25 + (k * (PI - 0.5)) / 6;\n  ARC.push([34 + 14 * cos(th), 82 + 24 * sin(th), 7.5 - 1.5 * sin((k * PI) / 6)]);\n}\nfunction catDist(S, sx, sy, a) {\n  const px = 38 + (sx - AX) / SC, py = WALL + (sy - WALL) / SC;\n  const m = S.mood, hiss = sm(0.3, 0.8, a) * (S.arch >= 0 ? 0.6 + 0.4 * sin(S.arch * 14) : 0);\n  let d = 1e9;\n  // A cross cat leans forward over its front paws, about the root of its\n  // tail: the sitting body and the head are drawn turned by up to 0.12 rad.\n  const ln = -0.12 * m * (1 - a), lc = cos(ln), ls = sin(ln);\n  const lx = 40 + lc * (px - 40) + ls * (py - 100), ly = 100 - ls * (px - 40) + lc * (py - 100);\n  // Sitting: haunch, back and chest from the wall up to the neck, the front\n  // legs and the paws.\n  if (a \u003c 1) {\n    const px = lx, py = ly;\n    let ds = circle(px, py, 38, WALL - 14, 14);\n    ds = smin(ds, capsule(px, py, 37, WALL - 16, 27, 63, 13, 9), 2);\n    ds = smin(ds, circle(px, py, 25, 74, 9), 3);\n    ds = min(ds, capsule(px, py, 22, 76, 21, WALL - 1, 3.4, 2.6));\n    ds = min(ds, capsule(px, py, 27.5, 78, 27, WALL - 1, 3, 2.4));\n    ds = min(ds, capsule(px, py, 17.5, WALL - 1, 23, WALL - 1, 1.8, 1.8));\n    ds = min(ds, capsule(px, py, 31, WALL - 1.5, 44, WALL - 1.5, 2.2, 2.2));\n    // A cross cat's fur rises along its back.\n    if (m > 0) ds -= 1.4 * m * sm(36, 44, px) * sm(96, 80, py) * teeth(py);\n    d = ds;\n  }\n  // Arched: up on straight legs, the back bowed high, the fur on end.\n  if (a > 0) {\n    let da = 1e9;\n    for (let k = 0; k \u003c 6; k++) da = min(da, capsule(px, py, ARC[k][0], ARC[k][1], ARC[k + 1][0], ARC[k + 1][1], ARC[k][2], ARC[k + 1][2]));\n    da = smin(da, circle(px, py, 21, 74, 7), 2);\n    da = smin(da, circle(px, py, 46, 74, 8), 2);\n    da = min(da, capsule(px, py, 21, 78, 20, WALL - 1, 3, 2.4));\n    da = min(da, capsule(px, py, 25, 80, 26, WALL - 1, 2.6, 2.2));\n    da = min(da, capsule(px, py, 46, 78, 45, WALL - 1, 3.4, 2.4));\n    da = min(da, capsule(px, py, 49, 80, 50, WALL - 1, 2.8, 2.2));\n    if (py \u003c 80) da -= 1.8 * teeth(atan2(py - 82, px - 34) * 18);\n    d = a \u003c 1 ? d + (da - d) * a : da;\n  }\n  // The tail.\n  const T = S.tail, puff = 1 + 0.7 * a;\n  if (px > S.tb[0] && px \u003c S.tb[2] && py > S.tb[1] && py \u003c S.tb[3]) for (let i = 0; i \u003c 14; i++) {\n    const r0 = (3.2 - 1.3 * (i / 14)) * puff, r1 = (3.2 - 1.3 * ((i + 1) / 14)) * puff;\n    let dt = capsule(px, py, T[2 * i], T[2 * i + 1], T[2 * i + 2], T[2 * i + 3], r0, r1);\n    if (a > 0.05) dt -= a * 1.4 * teeth(py);\n    d = smin(d, dt, 1.5);\n  }\n  // The head, turned about the neck by its tilt; arched, it comes down and\n  // forward with the chest and dips its nose.\n  const tl = S.tilt + 0.3 * a, c = cos(tl), s = sin(tl), nx = 28 - 5 * a, ny = 58 + 13 * a;\n  const qx = 28 + c * (lx - nx) + s * (ly - ny), qy = 58 - s * (lx - nx) + c * (ly - ny);\n  let dh = circle(qx, qy, 24, 47, 9.5);\n  dh = smin(dh, circle(qx, qy, 16, 50, 5), 3);\n  dh = smin(dh, circle(qx, qy, 19.5, 53.5, 5), 2.5);\n  dh = smin(dh, capsule(qx, qy, 24, 47, 28, 60, 7, 8), 3);\n  // Ears: laid back by mood and arch, each flicking back now and then.\n  for (let i = 0; i \u003c 2; i++) {\n    const fl = S.earAge[i] \u003c 0.3 ? sin((PI * S.earAge[i]) / 0.3) : 0;\n    const ang = (0.55 * m + 0.7 * a + 0.5 * fl) * (i ? 1 : 0.8);\n    const bx = i ? 28 : 20, by = 40, ec = cos(ang), es = sin(ang);\n    const ex = bx + ec * (qx - bx) + es * (qy - by), ey = by - es * (qx - bx) + ec * (qy - by);\n    dh = min(dh, tri(ex, ey, i ? [24, 41, 32.5, 43, 29.5, 30] : [15.5, 44, 23.5, 40, 17.5, 30]) - 0.6);\n  }\n  // A hiss opens the mouth: a wedge cut from the muzzle.\n  if (hiss > 0.05) dh = max(dh, -tri(qx, qy, [10, 51.5 - 1.5 * hiss, 19, 52.5, 10, 53.5 + 3 * hiss]));\n  // Three whiskers from the muzzle, thin enough to show only as light.\n  let wk = 1e9;\n  if (qx \u003c 16 && qy > 45 && qy \u003c 58) for (let i = 0; i \u003c 3; i++) wk = min(wk, capsule(qx, qy, 13, 50 + i, 7.5, 48 + 2.6 * i, 0.3, 0.3));\n  return { d: min(d, dh) * SC, qx, qy, wk: wk * SC };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const a = pose(S), L = S.c, E = S.e;\n  // The light: moon and rim in one hue, the eyes in the opposite one.\n  hsv(0.075 + S.hue, 0.78, 1, L);\n  hsv(0.33 + S.hue, 0.85, 1, E);\n  // Eye: open, blinking, narrowed by mood or a hiss.\n  const bl = S.blinkAge \u003c 0.18 ? abs(1 - S.blinkAge / 0.09) : 1;\n  const open = bl * (1 - 0.45 * max(S.mood, sm(0.3, 0.8, a)));\n  const slit = 1.1 - 0.75 * max(S.mood, a);\n  // The cat's distance is worked out only near its outline and its eye: a\n  // first pass over 4 x 4 blocks marks each as clear of the cat (0), deep\n  // inside it (1) or near its edge (2). The fur's teeth make the distance\n  // change up to 3.3 times faster than the LEDs, hence the wider margin.\n  const blk = S.blk, margin = a > 0.01 || S.mood > 0 ? 11 : 5;\n  for (let by = 0; by \u003c 32; by++)\n    for (let bx = 0; bx \u003c 16; bx++) {\n      const y0 = by * 4;\n      if (y0 + 4 \u003c= 8 || y0 > WALL) {\n        blk[by * 16 + bx] = 0;\n        continue;\n      }\n      const C = catDist(S, bx * 4 + 2, y0 + 2, a), nearEye = (C.qx - 19.5) ** 2 + (C.qy - 46) ** 2 \u003c 64;\n      blk[by * 16 + bx] = C.d > margin ? 0 : C.d \u003c -margin && !nearEye ? 1 : 2;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, px = x + 0.5, py = y + 0.5;\n      let R = SKY[3 * y], G = SKY[3 * y + 1], B = SKY[3 * y + 2];\n      // Moon glow in rings, then the moon.\n      const glow = GLOW[p];\n      R += L[0] * glow;\n      G += L[1] * glow;\n      B += L[2] * glow;\n      const mt = MOONT[p];\n      if (mt > 0) {\n        R += (L[0] * 0.95 * mt - R) * mt;\n        G += (L[1] * 0.95 * mt - G) * mt;\n        B += (L[2] * 0.95 * mt - B) * mt;\n      }\n      if (STAR[p] >= 0) {\n        const v = 0.25 + 0.2 * sin(S.t * 2.1 + STAR[p]);\n        R = max(R, v);\n        G = max(G, v);\n        B = max(B, v * 1.1);\n      }\n      // Bats: black against the moon, a shade lighter than the night sky.\n      for (let i = 0; i \u003c BATS.length; i++) {\n        const [bx, by, dir] = S.bats[i];\n        if (abs(px - bx) > 7 || abs(py - by) > 6) continue;\n        const cov = cl(0.5 - batDist(px, py, bx, by, dir, sin(S.flap + i * 2.2)), 0, 1);\n        if (cov > 0) {\n          R += (0.03 - R) * cov;\n          G += (0.01 - G) * cov;\n          B += (0.05 - B) * cov;\n        }\n      }\n      // The pumpkin's candlelight, in rings that breathe with the flame.\n      const warm = round(S.fl * WARM[p] * 20) / 20;\n      // The wall: a coping stone lit along its top, bricks below in shadow.\n      if (y >= WALL) {\n        if (y \u003c WALL + 3) {\n          const top = y === WALL ? 0.55 : 0.12;\n          R = 0.1 + L[0] * top;\n          G = 0.07 + L[1] * top;\n          B = 0.13 + L[2] * top;\n        } else {\n          const row = floor((y - WALL - 3) / 5), bx = (x + (row & 1) * 5) % 10, by = (y - WALL - 3) % 5;\n          const tone = 0.7 + 0.3 * hash(row * 17 + floor((x + (row & 1) * 5) / 10));\n          const mortar = by === 4 || bx === 9;\n          R = mortar ? 0.03 : 0.13 * tone;\n          G = mortar ? 0.02 : 0.08 * tone;\n          B = mortar ? 0.05 : 0.17 * tone;\n        }\n      }\n      R += FLAME[0] * warm;\n      G += FLAME[1] * warm;\n      B += FLAME[2] * warm;\n      // The jack-o'-lantern itself.\n      const sx = x - PX0, sy = y - PY0;\n      if (sy >= 0 && sy \u003c PUMPKIN.length && sx >= 0 && sx \u003c 17) {\n        const ch = PUMPKIN[sy][sx];\n        if (ch === \"f\") {\n          const v = min(1, S.fl * 1.25);\n          R = v;\n          G = 0.78 * v * v;\n          B = 0.2 * v * v * v;\n        } else if (ch === \"o\") {\n          const edge = PUMPKIN[sy - 1] === undefined || PUMPKIN[sy - 1][sx] === \".\" || PUMPKIN[sy - 1][sx] === \"s\" || sx === 0 || PUMPKIN[sy][sx - 1] === \".\" || PUMPKIN[sy][sx + 1] === \".\" || sx === 16;\n          R = edge ? 0.62 : 0.3 + 0.14 * S.fl;\n          G = edge ? 0.24 : 0.09 + 0.04 * S.fl;\n          B = edge ? 0.04 : 0.02;\n        } else if (ch === \"s\") {\n          R = 0.16;\n          G = 0.2;\n          B = 0.05;\n        }\n      }\n      const bk = blk[(y >> 2) * 16 + (x >> 2)];\n      if (bk === 1) {\n        R = 0.012;\n        G = 0.008;\n        B = 0.02;\n      } else if (bk === 2 && y > 8 && y \u003c WALL + 1) {\n        const C = catDist(S, px, py, a), cov = cl(0.5 - C.d, 0, 1);\n        // The whiskers catch the moonlight where the night is behind them.\n        const wv = cov === 0 ? cl(0.6 - C.wk, 0, 0.6) * (1 - MOONT[p]) : 0;\n        if (wv > 0) {\n          R += (L[0] - R) * wv;\n          G += (L[1] - G) * wv;\n          B += (L[2] - B) * wv;\n        }\n        if (cov > 0) {\n          // Rim light: the first LED inside the edge in the moon's colour,\n          // the second at a third, strongest away from the moon's face.\n          const rim = (C.d > -1.2 ? 1 : C.d > -2.2 ? 0.35 : 0) * (0.35 + 0.65 * (1 - MOONT[p]));\n          const k = 1 - cov;\n          // Where the pumpkin's light reaches, its warm rim joins the moon's.\n          const rw = C.d > -1.2 ? min(1, 1.6 * warm) : 0;\n          R = R * k + cov * (0.012 + L[0] * 0.9 * rim + FLAME[0] * rw);\n          G = G * k + cov * (0.008 + L[1] * 0.9 * rim + FLAME[1] * rw);\n          B = B * k + cov * (0.02 + L[2] * 0.9 * rim + FLAME[2] * rw);\n          // The eye: an almond of light with a slit pupil that looks round.\n          const ex = (C.qx - 19.5) / 2.6, ey = (C.qy - 46) / (1.8 * open + 0.01);\n          if (open > 0.1 && ex * ex + ey * ey \u003c 1) {\n            const pup = abs(C.qx - (19.3 + 1.1 * S.look)) \u003c slit * 0.6 + 0.2;\n            R = pup ? 0 : E[0];\n            G = pup ? 0 : E[1];\n            B = pup ? 0 : E[2];\n          }\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, R)), round(255 * min(1, G)), round(255 * min(1, B)));\n    }\n}\n","bulgarian-solitaire":"// ===== Patternflow pattern =====\n// Title:   Bulgarian Solitaire\n// Family:  number\n// Idea:    Cards stand in piles on the floor, and every move one card lifts off each pile, they fly up into a new pile that drops into its place while the old piles slide into order, until the ten cards stand as the staircase 4, 3, 2, 1, which holds, and they are gathered and dealt again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Bulgarian solitaire (Jørgen Brandt, 1982)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.25..6, Size=4..8, Extra=0..1\n//\n// Knob 1: Hue. Turns the cards' colours together. Each pile of a deal has its own colour and its cards keep it through the play; at 0 the piles are azure, blue, violet, rose, orange, lime and so on in steps of 0.13 round the wheel, every card at full brightness, with a white suit on its face.\n// Knob 2: Speed. At 2 a move takes 1.6 seconds, so the slowest start of ten cards reaches the staircase in 12 moves and 19 seconds; at 0.25 a move takes 12.8 seconds, at 6 half a second.\n// Knob 3: Size. The staircase k, from 4 to 8: 10, 15, 21, 28 or 36 cards. A new size is dealt first from the slowest start, k - 1, k - 1, k - 2, ..., 2, 1, 1, which takes the most moves any start can, k^2 - k: 12, 20, 30, 42 or 56; then twice from a random start, then the slowest again. The tally along the top lights a mark a move against k^2 - k dim marks.\n// Knob 4: Extra. Cards beyond k(k + 1)/2: none below 1/(k + 1), 0.2 at Size 4, and one more for each further 1/(k + 1), up to k at 1. Then the play never settles: it falls into a cycle where the piles are the staircase with one extra card, rimmed white, on some of its steps, and the white rims move round the steps and come back to where they were after k + 1 moves or a divisor of it. The cycle is played round once more with gold marks in the tally, and then the cards are dealt again.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst lerp = (a, b, t) => a + (b - a) * t;\n\n// The floor's top row; cards stand on it. Rows above TOP stay clear for the tally.\nconst FLOOR = 124, TOP = 10;\n// Tallest and shortest card, in LEDs, and the widest pile slot.\nconst CHMAX = 18, CHMIN = 4, SWMAX = 14;\n// Seconds at Speed 2: one move, gathering the cards, dealing them, holding the end.\nconst MOVE = 1.6, GATHER = 0.9, DEAL = 1.8, HOLD = 2.6;\n// Phases of a move: the lift ends at A and the flight at B; the old piles\n// slide into order from S0 to SL, clearing the place under the new pile,\n// which drops from SL to C and bounces BOUNCE LEDs.\nconst A = 0.14, B = 0.5, S0 = 0.36, SL = 0.68, C = 0.86, BOUNCE = 2;\n// Every DEALS-th deal is the slowest start, k - 1, k - 1, k - 2, ..., 2, 1, 1.\nconst DEALS = 3;\n// Hue at Hue 0 and the step between the hues of the dealt piles.\nconst HUE0 = 0.55, STEP = 0.13;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// One move of Bulgarian solitaire on piles of card ids (each pile bottom to\n// top): the top card of every pile, left to right, makes a new pile; the\n// piles are then sorted tallest first, the new one after the old of its height.\nfunction move(piles) {\n  const fresh = piles.map((p) => p[p.length - 1]);\n  const out = piles.map((p) => p.slice(0, -1)).filter((p) => p.length);\n  out.push(fresh);\n  return out.map((p, i) => [p, i]).sort((a, b) => b[0].length - a[0].length || a[1] - b[1]).map((e) => e[0]);\n}\n\nconst key = (piles) => piles.map((p) => p.length).join(\",\");\n\n// Play from a start until the heights repeat: the staircase, or a cycle.\nfunction play(start) {\n  const states = [start], seen = new Map([[key(start), 0]]);\n  for (;;) {\n    const next = move(states[states.length - 1]), k = key(next);\n    if (seen.has(k)) return { states, loop: seen.get(k) };\n    seen.set(k, states.length);\n    states.push(next);\n  }\n}\n\n// Partitions of n into at most b parts of at most a each, counted, so a\n// random start can be drawn evenly from those that fit a box of side k + 1.\nconst QCOUNT = new Map();\nfunction qcount(n, a, b) {\n  if (n === 0) return 1;\n  if (a === 0 || b === 0 || n > a * b) return 0;\n  const key = (n * 64 + a) * 64 + b;\n  if (QCOUNT.has(key)) return QCOUNT.get(key);\n  let s = 0;\n  for (let p = 1; p \u003c= min(n, a); p++) s += qcount(n - p, p, b - 1);\n  QCOUNT.set(key, s);\n  return s;\n}\nfunction randomPartition(n, side) {\n  const out = [];\n  let a = side, b = side;\n  while (n > 0) {\n    let r = Math.random() * qcount(n, a, b), p = min(n, a);\n    for (; p > 1; p--) {\n      const c = qcount(n - p, p, b - 1);\n      if (r \u003c c) break;\n      r -= c;\n    }\n    out.push(p);\n    n -= p;\n    a = p;\n    b--;\n  }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, k: 4, extra: 0, hue: 0, rate: 1, deals: 0,\n    game: null, mode: \"deal\", t: 0, at: 0, hues: null, prevHues: null, suits: null, prevSuits: null, prev: null, cards: null,\n    rgb: new Float32Array(W * H * 3), c3: new Float32Array(3),\n  };\n}\n\n// A new game: the heights of the start, the cards dealt into them, the play\n// worked out to the end, and the layout that fits every state of it.\nfunction newGame(S) {\n  const k = S.k, tri = (k * (k + 1)) / 2, n = tri + S.extra;\n  let heights;\n  if (S.extra === 0 && S.deals % DEALS === 0) {\n    heights = [k - 1];\n    for (let h = k - 1; h >= 1; h--) heights.push(h);\n    heights.push(1);\n  } else heights = randomPartition(n, k + 1);\n  S.deals++;\n  let id = 0;\n  const start = heights.map((h) => Array.from({ length: h }, () => id++));\n  const hues = new Float32Array(n), suits = new Uint8Array(n);\n  start.forEach((p, i) => p.forEach((c) => ((hues[c] = i * STEP), (suits[c] = i % 4))));\n  const g = play(start);\n  // Slots for the most piles of any state; cards as tall as the tallest pile allows.\n  let slots = 0, tall = 0;\n  for (const s of g.states) {\n    slots = max(slots, s.length);\n    for (const p of s) tall = max(tall, p.length);\n  }\n  const sw = min(SWMAX, floor(W / slots)), cw = sw - (sw >= 8 ? 2 : 1);\n  const ch = cl(floor((FLOOR - TOP) / (tall + 0.6)), CHMIN, CHMAX);\n  S.game = { ...g, n, k, tri: S.extra === 0, sw, cw, ch, period: g.states.length - g.loop };\n  S.prevHues = S.hues;\n  S.prevSuits = S.suits;\n  S.hues = hues;\n  S.suits = suits;\n  S.prev = S.cards;\n  S.mode = \"gather\";\n  S.t = 0;\n  S.at = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kn[0];\n  S.rate = cl(kn[1], 0.25, 6) / 2;\n  const k = round(cl(kn[2], 4, 8)), extra = min(k, floor(cl(kn[3], 0, 1) * (k + 1)));\n  if (!S.begun || k !== S.k || extra !== S.extra) {\n    // A new size starts again from the slowest start.\n    if (k !== S.k || !S.begun) S.deals = 0;\n    S.k = k;\n    S.extra = extra;\n    newGame(S);\n    if (!S.begun) (S.mode = \"deal\"), (S.prev = null);\n    S.begun = true;\n  }\n  S.t += d * S.rate;\n  const G = S.game;\n  if (S.mode === \"gather\" && S.t >= GATHER) (S.mode = \"deal\"), (S.t = 0);\n  else if (S.mode === \"deal\" && S.t >= DEAL) (S.mode = \"move\"), (S.t = 0), (S.at = 0);\n  else if (S.mode === \"move\") {\n    while (S.t >= MOVE && S.mode === \"move\") {\n      S.t -= MOVE;\n      S.at++;\n      // A cycle is played round once more after it is found.\n      const last = G.states.length - 1 + (G.tri ? 0 : G.period);\n      if (S.at >= last) (S.mode = \"hold\"), (S.t = 0);\n    }\n  } else if (S.mode === \"hold\" && S.t >= HOLD) newGame(S);\n}\n\n// The state after `i` moves; past the end of a cycle's states it goes round the cycle.\nfunction stateAt(G, i) {\n  const L = G.states.length;\n  if (i \u003c L) return G.states[i];\n  return G.states[G.loop + ((i - G.loop) % G.period)];\n}\n\n// In a cycle every state is the staircase k, k - 1, ..., 1, 0 with one card\n// more on some of its k + 1 steps; those top cards are the extra ones.\nfunction extras(G, i) {\n  const out = new Set();\n  if (G.tri || i \u003c G.loop) return out;\n  stateAt(G, i).forEach((p, j) => {\n    if (p.length > G.k - j) out.add(p[p.length - 1]);\n  });\n  return out;\n}\n\nconst slotX = (G, i, count) => (W - count * G.sw) / 2 + i * G.sw + (G.sw - G.cw) / 2;\nconst levelY = (G, j) => FLOOR - (j + 1) * G.ch;\n\n// Where every card is this frame, as [id, x, y, flying, extra]: x and y\n// are its top-left corner, a card of the last game has id -1 - its id.\nfunction layout(S) {\n  const G = S.game, out = [];\n  const rest = (piles, ex) => piles.forEach((p, i) => p.forEach((c, j) => out.push([c, slotX(G, i, piles.length), levelY(G, j), 0, ex.has(c)])));\n  if (S.mode === \"gather\" || S.mode === \"deal\") {\n    // The deck sits high in the middle; cards fly to it and from it.\n    const dx = (W - G.cw) / 2, dy = 30;\n    if (S.mode === \"gather\") {\n      const u = S.t / GATHER;\n      for (const [c, x, y] of S.prev || []) {\n        const e = sm(u * 1.4 - (c % 7) * 0.05);\n        out.push([-1 - c, lerp(x, dx, e), lerp(y, dy, e) - 14 * sin(PI * e), 0]);\n      }\n      return out;\n    }\n    const start = G.states[0], n = G.n, u = S.t / DEAL;\n    let order = 0;\n    start.forEach((p, i) =>\n      p.forEach((c, j) => {\n        const e = sm((u - (order++ / n) * 0.7) / 0.3);\n        out.push([c, lerp(dx, slotX(G, i, start.length), e), lerp(dy, levelY(G, j), e) - 10 * sin(PI * e), 0]);\n      }),\n    );\n    return out;\n  }\n  const P = stateAt(G, S.at);\n  if (S.mode === \"hold\") {\n    rest(P, extras(G, S.at));\n    return out;\n  }\n  const Q = stateAt(G, S.at + 1), m = P.length, u = S.t / MOVE;\n  // The top cards lift, fly up and stack bottom first into the new pile,\n  // which hangs at the top of the panel above its place in Q; the old piles\n  // slide into their places, and it drops to the floor.\n  const a = sm(u / A), c = sm((u - S0) / (SL - S0)), d = cl((u - SL) / (C - SL), 0, 1);\n  const qIndex = new Map(Q.map((p, i) => [p[0], i]));\n  const nx = slotX(G, qIndex.get(P[0][P[0].length - 1]), Q.length);\n  const R = max(0, FLOOR - m * G.ch - TOP);\n  const drop = R * (1 - d * d) - (u > C ? BOUNCE * sin((PI * (u - C)) / (1 - C)) : 0);\n  const st = min(0.03, (B - A) / (2 * m)), lift = a * (G.ch * 0.5 + 3), ex = extras(G, u \u003c SL ? S.at : S.at + 1);\n  P.forEach((p, i) => {\n    const below = p.length - 1;\n    let x = slotX(G, i, m);\n    if (below > 0) x = lerp(x, slotX(G, qIndex.get(p[0]), Q.length), c);\n    for (let j = 0; j \u003c below; j++) out.push([p[j], x, levelY(G, j), 0, ex.has(p[j])]);\n    const f = sm((u - A - i * st) / (B - A - (m - 1) * st));\n    const tx = lerp(x, nx, f), ty = lerp(levelY(G, below) - lift, levelY(G, i) - R, f) - 6 * sin(PI * f) + (u >= B ? R - drop : 0);\n    out.push([p[below], u \u003c B ? tx : nx, ty, 1, ex.has(p[below])]);\n  });\n  return out;\n}\n\n// Suits, 5 by 5, one row per string: diamond, heart, spade, club.\nconst SUITS = [\n  [\"..#..\", \".###.\", \"#####\", \".###.\", \"..#..\"],\n  [\".#.#.\", \"#####\", \"#####\", \".###.\", \"..#..\"],\n  [\"..#..\", \".###.\", \"#####\", \"#.#.#\", \"..#..\"],\n  [\"..#..\", \".###.\", \"##.##\", \"#####\", \"..#..\"],\n].map((rows) => rows.map((r) => [...r].map((ch) => ch === \"#\")));\n// The same, 3 by 3, for the corners.\nconst PIPS = [\n  [\".#.\", \"###\", \".#.\"],\n  [\"#.#\", \"###\", \".#.\"],\n  [\".#.\", \"###\", \"#.#\"],\n  [\".#.\", \"###\", \"###\"],\n].map((rows) => rows.map((r) => [...r].map((ch) => ch === \"#\")));\n\nfunction put(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= FLOOR) return;\n  const o = (y * W + x) * 3;\n  (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.game) return;\n  const G = S.game, { rgb, c3 } = S;\n  rgb.fill(0);\n  const cards = layout(S);\n  S.cards = cards.filter((e) => e[0] >= 0);\n  // The floor.\n  for (let x = 0; x \u003c W; x++)\n    for (let y = FLOOR; y \u003c FLOOR + 2; y++) {\n      const o = (y * W + x) * 3;\n      (rgb[o] = 0.3), (rgb[o + 1] = 0.26), (rgb[o + 2] = 0.42);\n    }\n  // Cards: resting ones first, flying ones on top. A card is its pile's\n  // colour with a paler rim and a white suit in the middle; an extra card of\n  // a cycle has a white rim.\n  cards.sort((p, q) => p[3] - q[3]);\n  const cw = G.cw, chh = G.ch - 1;\n  for (const [id, x0, y0, , mark] of cards) {\n    const old = id \u003c 0, c = old ? -1 - id : id;\n    hsv(HUE0 + S.hue + (old ? S.prevHues : S.hues)[c], 0.85, 1, c3, 0);\n    const [r, g, b] = c3, X = round(x0), Y = round(y0);\n    const rr = mark ? 1 : r + (1 - r) * 0.45, rg = mark ? 1 : g + (1 - g) * 0.45, rb = mark ? 1 : b + (1 - b) * 0.45;\n    for (let y = Y; y \u003c Y + chh; y++)\n      for (let x = X; x \u003c X + cw; x++) {\n        const rim = x === X || x === X + cw - 1 || y === Y || y === Y + chh - 1;\n        if (rim) put(rgb, x, y, rr, rg, rb);\n        else put(rgb, x, y, r, g, b);\n      }\n    if (cw >= 7 && chh >= 7) {\n      const suit = SUITS[(old ? S.prevSuits : S.suits)[c]], sx = X + ((cw - 5) >> 1), sy = Y + ((chh - 5) >> 1);\n      for (let v = 0; v \u003c 5; v++) for (let u = 0; u \u003c 5; u++) if (suit[v][u]) put(rgb, sx + u, sy + v, 1, 1, 1);\n      if (cw >= 9 && chh >= 15) {\n        // Corner pips, the bottom one upside down.\n        const pip = PIPS[(old ? S.prevSuits : S.suits)[c]];\n        for (let v = 0; v \u003c 3; v++)\n          for (let u = 0; u \u003c 3; u++)\n            if (pip[v][u]) put(rgb, X + 2 + u, Y + 2 + v, 1, 1, 1), put(rgb, X + cw - 3 - u, Y + chh - 3 - v, 1, 1, 1);\n      }\n    } else if (cw >= 3 && chh >= 3) put(rgb, X + ((cw - 1) >> 1), Y + ((chh - 1) >> 1), 1, 1, 1);\n  }\n  // The staircase, once reached, is outlined in white step by step.\n  if (S.mode === \"hold\" && G.tri) {\n    const P = stateAt(G, S.at), e = cl(S.t / 0.8, 0, 1) * P.length;\n    for (let i = 0; i \u003c P.length && i \u003c e; i++) {\n      const x0 = round(slotX(G, i, P.length)) - 1, y0 = round(levelY(G, P[i].length - 1)) - 2, x1 = x0 + G.sw;\n      for (let x = x0; x \u003c= x1; x++) put(rgb, x, y0, 1, 1, 1);\n      const y1 = i + 1 \u003c P.length ? round(levelY(G, P[i + 1].length - 1)) - 2 : FLOOR;\n      for (let y = y0; y \u003c= y1; y++) put(rgb, x1, y, 1, 1, 1);\n    }\n  }\n  // The tally: a mark a move, along the top; for a staircase the dim marks\n  // count out the most moves any start can take, k^2 - k.\n  const done = S.mode === \"hold\" ? S.at : S.mode === \"move\" ? S.at + (S.t / MOVE > C ? 1 : 0) : 0;\n  const total = G.tri ? G.k * G.k - G.k : G.states.length - 1 + G.period;\n  const rows = Math.ceil(total / 32), per = Math.ceil(total / rows), pitch = floor(W / per), tw = max(1, pitch - 1);\n  const x0 = floor((W - per * pitch + 1) / 2);\n  for (let i = 0; i \u003c total; i++) {\n    const lit = i \u003c done, loop = !G.tri && i >= G.loop;\n    const v = lit ? 1 : G.tri ? 0.22 : 0;\n    if (!v) continue;\n    const X = x0 + (i % per) * pitch, Y = 2 + floor(i / per) * 5;\n    for (let y = Y; y \u003c Y + 3; y++) for (let x = X; x \u003c X + tw; x++) put(rgb, x, y, v, v * (loop ? 0.8 : 1), v * (loop ? 0.2 : 1));\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o] * 255, rgb[o + 1] * 255, rgb[o + 2] * 255);\n}\n","crystal-ball":"// ===== Patternflow pattern =====\n// Title:   Crystal Ball\n// Family:  halloween\n// Idea:    A big crystal ball sits on a small brass stand in a dark room, purple and toxic green smoke rising up its middle and spiralling down its sides, and now and then the smoke gathers into a vision, a grinning skull, a staring eye or a crescent moon, holds it for a second or two and lets it go back into the swirl.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Smoke=0..1, Visions=0..1\n//\n// Knob 1: Hue. The two smokes' colours, kept out of red, orange and yellow, which turn brown when smoke thins. At 0 purple and toxic green, at 0.25 indigo and sea green, at 0.5 magenta and sky blue, at 0.75 crimson and blue violet, at 1 cyan and pink; the glass takes a dark shade of the first, visions stay bone white.\n// Knob 2: Speed. At 2 the smoke rises up the middle of the ball at 14 LEDs a second and sinks down the sides, the whole swirl turning once in 3.9 s; a vision gathers in 1.4 s and lets go over 1.6 s. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Smoke. How much smoke: 700 chunks at 0, 1500 at 1, each living 4.5 to 8 s from one of two wells low in the glass, one for each colour, turning slowly round the middle.\n// Knob 4: Visions. How often a vision comes and how much of the smoke goes into it. At 0.06 the first comes at 2 s and takes 62% of the smoke, holds 1.5 s, and the next comes 12.4 s after one has gone; at 1 the first comes at 0.4 s and takes all of it, holds 2.6 s, and the next comes after 3 s. They come as a grinning skull with a chattering jaw, a slit-pupilled eye that blinks once, and a crescent moon, then in any order.\n// Buttons: any tap calls the next vision at once when none is showing.\n\nconst W = 64, H = 128, CX = 32, CY = 60, R = 28, RIN = 25.5, GW = 32, GH = 64;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (v) => v * v * (3 - 2 * v);\nconst MAXN = 1500;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const r = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  const g = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  const b = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return [round(r * 63) * 4, round(g * 63) * 4, round(b * 63) * 4];\n}\n\n// The visions, in u, v from -1 to 1 (v down), 20 LEDs to a unit, tested\n// at the middle of each 2x2 cell. Each returns 0 outside, else the colour\n// class: 1 the first smoke, 2 the second, 3 bone. The skull is drawn by\n// hand, one character to a cell.\nconst SKULL = [\n  \"......######......\",\n  \"...############...\",\n  \"..##############..\",\n  \".################.\",\n  \".################.\",\n  \"##################\",\n  \"##################\",\n  \"##.....####.....##\",\n  \"#......####......#\",\n  \"#......####......#\",\n  \"##.....####.....##\",\n  \"###...######...###\",\n  \".#######..#######.\",\n  \"..######..######..\",\n  \"...############...\",\n  \"...#.##.##.##.#...\",\n  \"....##########....\",\n  \".....########.....\",\n];\nfunction skull(u, v) {\n  const c = floor(u * 10 + 9), r = floor(v * 10 + 9);\n  return r >= 0 && r \u003c SKULL.length && c >= 0 && c \u003c 18 && SKULL[r][c] === \"#\" ? 3 : 0;\n}\nfunction eye(u, v) {\n  const lid = 0.5 * (1 - u * u) ** 0.9;\n  if (abs(u) >= 1 || abs(v) > lid + 0.1) return 0;\n  if (abs(v) > lid) return 1;\n  // A slit pupil in a green iris.\n  if (u * u + v * v \u003c 0.38 ** 2) return abs(u) \u003c 0.06 && abs(v) \u003c 0.32 ? 0 : 2;\n  return 3;\n}\nfunction moon(u, v) {\n  if (u * u + v * v > 0.82 ** 2) return 0;\n  return (u - 0.42) ** 2 + (v + 0.2) ** 2 \u003c 0.64 ** 2 ? 0 : 3;\n}\nconst SHAPES = [skull, eye, moon];\n// Which layer a vision's colour class draws in: lids, iris, bone.\nconst LAYER = [0, 3, 4, 2];\n\n// The two smoke hues along Hue, kept out of red, orange and yellow, which\n// go brown when the smoke thins.\nconst STOPS = [[0.78, 0.33], [0.66, 0.46], [0.88, 0.55], [0.95, 0.7], [0.55, 0.9]];\nfunction smokeHues(k) {\n  const f = cl(k, 0, 1) * 4, i = min(3, floor(f)), u = f - i;\n  return [0, 1].map((j) => STOPS[i][j] + (STOPS[i + 1][j] - STOPS[i][j]) * u);\n}\n\n// Targets on the 2-LED lattice the smoke is drawn on, so a vision's cells\n// tile it edge to edge: [x, y, class] relative to the ball's middle.\nfunction targets(shape) {\n  const cells = [];\n  for (let j = -24; j \u003c 24; j += 2)\n    for (let i = -24; i \u003c 24; i += 2) {\n      const a = shape((i + 1) / 20, (j + 1) / 20);\n      if (a) cells.push(i, j, a);\n    }\n  return cells;\n}\n\nexport function setup(params) {\n  const P = {\n    hue: 0, speed: 1, smoke: 0, rate: 0.06, share: 0.62, n: 0, t: 0, warm: false,\n    x: new Float32Array(MAXN), y: new Float32Array(MAXN), z: new Float32Array(MAXN),\n    age: new Float32Array(MAXN), life: new Float32Array(MAXN), sp: new Uint8Array(MAXN), lag: new Float32Array(MAXN),\n    slot: new Uint16Array(MAXN),\n    shapes: SHAPES.map(targets), vis: -1, vt: 0, next: 2, order: 0, glow: 0,\n    vc: 0, sparks: [], cw: [0, 1, 2, 3, 4].map(() => new Float32Array(GW * GH)), tmp: new Float32Array(GW * GH),\n  };\n  for (let i = 0; i \u003c MAXN; i++) {\n    P.sp[i] = Math.random() \u003c 0.55 ? 1 : 2;\n    P.lag[i] = Math.random();\n    P.slot[i] = floor(Math.random() * 65536);\n    spawn(P, i, Math.random());\n  }\n  params.s = P;\n}\n\n// A particle starts at one of two wells low in the ball, the purple one and\n// the green one across from it, both turning slowly round the middle.\nfunction spawn(P, i, age) {\n  const a = P.t * 0.35 + (P.sp[i] === 1 ? 0 : PI) + (Math.random() - 0.5) * 1.2, rr = (0.3 + 0.4 * Math.random()) * RIN;\n  P.x[i] = rr * cos(a);\n  P.z[i] = rr * sin(a);\n  P.y[i] = (0.4 + 0.3 * Math.random()) * RIN;\n  P.life[i] = 4.5 + 3.5 * Math.random();\n  P.age[i] = age * P.life[i];\n}\n\n// The flow inside the glass: a turn about the upright axis, a ring vortex\n// rising up the middle and sinking down the sides (Hill's vortex, which\n// never crosses the glass), and an ABC flow drifting in phase for the curls.\nfunction step(P, d) {\n  const t = P.t, om = 1.6, C = 14, Rq = RIN * RIN, k = 0.16;\n  const p1 = t * 0.7, p2 = t * 0.53 + 2, p3 = t * 0.47 + 4;\n  const s = P.vis >= 0 ? 1 - 0.7 * P.glow : 1;\n  for (let i = 0; i \u003c P.n; i++) {\n    let x = P.x[i], y = P.y[i], z = P.z[i];\n    const vx = -om * z - (C * x * y) / Rq + 8 * sin(k * z + p1) + 6 * cos(k * y + p2);\n    const vz = om * x - (C * z * y) / Rq + 8 * cos(k * x + p3) + 6 * sin(k * y + p1);\n    const vy = -C * (1 - (2 * (x * x + z * z) + y * y) / Rq) + 6 * sin(k * x + p2) + 8 * cos(k * z + p3);\n    x += vx * d;\n    y += vy * d;\n    z += vz * d;\n    const r = sqrt(x * x + y * y + z * z);\n    if (r > RIN) {\n      const f = RIN / r;\n      x *= f;\n      y *= f;\n      z *= f;\n    }\n    P.x[i] = x;\n    P.y[i] = y;\n    P.z[i] = z;\n    P.age[i] += d * s;\n    if (P.age[i] > P.life[i]) spawn(P, i, 0);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3) / 2;\n  P.smoke = cl(k[2], 0, 1);\n  P.rate = cl(k[3], 0, 1);\n  P.share = 0.6 + 0.4 * P.rate;\n  P.n = round(700 + 800 * P.smoke);\n  const real = cl(dt || 0, 0, 0.1), d = real * P.speed;\n  if (!P.warm) {\n    // Let the smoke fill the ball before the first frame.\n    P.warm = true;\n    for (let i = 0; i \u003c 120; i++) {\n      P.t += 0.05;\n      step(P, 0.05);\n    }\n  }\n  P.t += d;\n  P.vc += d;\n  step(P, d);\n\n  // Visions: gather 1.4 s, hold 1.4 to 2.6 s, let go over 1.6 s. The\n  // smoke ages slower while it is held.\n  const press = input.btnPressed && (input.btnPressed[0] || input.btnPressed[1] || input.btnPressed[2] || input.btnPressed[3]);\n  if (P.order === 0) P.next = 2.1 - 1.7 * P.rate;\n  if (P.vis \u003c 0 && (P.vc >= P.next || press)) {\n    P.vis = P.order \u003c 3 ? P.order : floor(Math.random() * 3);\n    P.order++;\n    P.vt = 0;\n    const cells = P.shapes[P.vis], m = cells.length / 3;\n    // The particles that join take the cells in turn, so every cell gets\n    // one before any gets two.\n    const idx = [];\n    for (let i = 0; i \u003c P.n; i++) idx.push(i);\n    for (let i = idx.length - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [idx[i], idx[j]] = [idx[j], idx[i]];\n    }\n    let q = 0;\n    for (const i of idx) if (P.lag[i] \u003c P.share) P.slot[i] = q++ % m;\n  }\n  if (P.vis >= 0) {\n    P.vt += d;\n    const hold = 1.4 + 1.2 * P.rate, end = 1.4 + hold + 1.6;\n    P.glow = P.vt \u003c 1.4 ? ease(P.vt / 1.4) : P.vt \u003c 1.4 + hold ? 1 : 1 - ease(cl((P.vt - 1.4 - hold) / 1.6, 0, 1));\n    if (P.vt > 1.4 && P.vt - d \u003c= 1.4)\n      for (let i = 0; i \u003c 26; i++) {\n        const a = Math.random() * 2 * PI;\n        P.sparks.push({ x: CX + R * cos(a), y: CY + R * sin(a), vx: cos(a) * 8, vy: sin(a) * 8 - 6, life: 0.8 + 0.8 * Math.random(), g: 1 });\n      }\n    if (P.vt > end) {\n      P.vis = -1;\n      P.glow = 0;\n      P.next = P.vc + 13 - 10 * P.rate;\n    }\n  }\n\n  // Sparks leave the top of the glass and drift up.\n  if (Math.random() \u003c 8 * d) {\n    const a = -PI / 2 + (Math.random() - 0.5) * 2.4;\n    P.sparks.push({ x: CX + (R + 1) * cos(a), y: CY + (R + 1) * sin(a), vx: (Math.random() - 0.5) * 3, vy: -5 - 5 * Math.random(), life: 1 + Math.random(), g: Math.random() \u003c 0.5 ? 1 : 0 });\n  }\n  for (const s of P.sparks) {\n    s.x += s.vx * d;\n    s.y += s.vy * d;\n    s.vx += sin(s.y * 0.3 + P.t * 3) * 6 * d;\n    s.life -= d;\n  }\n  P.sparks = P.sparks.filter((s) => s.life > 0 && s.y > -1);\n}\n\n// Blur one coarse layer with a 1-2-1 kernel each way.\nfunction blur(a, tmp) {\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      const p = y * GW + x;\n      tmp[p] = (2 * a[p] + (x > 0 ? a[p - 1] : 0) + (x \u003c GW - 1 ? a[p + 1] : 0)) / 4;\n    }\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      const p = y * GW + x;\n      a[p] = (2 * tmp[p] + (y > 0 ? tmp[p - GW] : 0) + (y \u003c GH - 1 ? tmp[p + GW] : 0)) / 4;\n    }\n}\n\nconst put = (display, x, y, c) => {\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, c[0], c[1], c[2]);\n};\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.warm) return;\n  const cw = P.cw;\n  const vis = P.vis, cells = vis >= 0 ? P.shapes[vis] : null, G = P.glow;\n  // Smoke on 2x2-LED cells. A vision takes a share of the particles that\n  // grows with Visions; each comes a little earlier or later than the next.\n  const share = P.share;\n  // Held, a vision bobs a cell up and down; the skull's jaw chatters and the\n  // eye blinks once.\n  const vt = P.vt - 1.4, hold = 1.4 + 1.2 * P.rate;\n  const bob = 2 * round(sin(P.vt * 4)), jaw = vt > 0 && sin(vt * 14) > 0.2 ? 2 : 0;\n  const blink = vt > 0 ? max(0, 1 - abs(vt - hold * 0.6) / 0.18) : 0;\n  for (const c of P.cw) c.fill(0);\n  const raw = [];\n  for (let i = 0; i \u003c P.n; i++) {\n    let x = P.x[i], y = P.y[i];\n    const a = P.age[i] / P.life[i];\n    let w = (0.55 + 0.45 * cl((P.z[i] / RIN + 1) / 2, 0, 1)) * min(1, a / 0.12, (1 - a) / 0.3);\n    let cls = P.sp[i] - 1;\n    if (cells && P.lag[i] >= share) w *= 1 - 0.5 * G;\n    if (cells && P.lag[i] \u003c share) {\n      const s = ease(cl(G * 1.5 - (0.5 * P.lag[i]) / share, 0, 1));\n      if (s > 0) {\n        const c = (P.slot[i] % (cells.length / 3)) * 3;\n        let ty = cells[c + 1];\n        if (vis === 0 && ty >= 10) ty += jaw;\n        if (vis === 1) ty = 2 * round((ty * (1 - blink)) / 2);\n        x += (cells[c] + 1 - x) * s;\n        y += (ty + bob + 1 - y) * s;\n        w += (1.4 - w) * s;\n        if (s > 0.5) cls = LAYER[cells[c + 2]];\n      }\n    }\n    const gx = floor((CX + x) / 2), gy = floor((CY + y) / 2);\n    if (gx >= 0 && gx \u003c GW && gy >= 0 && gy \u003c GH) cw[cls][gy * GW + gx] += w;\n  }\n  // The free smoke is blurred into soft blobs; a vision stands sharp.\n  for (let k = 0; k \u003c 5; k++) {\n    const c = cw[k];\n    if (G > 0) raw[k] = c.slice();\n    blur(c, P.tmp);\n    if (G > 0) for (let p = 0; p \u003c c.length; p++) c[p] += (raw[k][p] - c[p]) * G;\n  }\n  // Colours: the two smokes in four levels, bone for visions; a vision's\n  // lids and iris stay saturated.\n  const [hA, hB] = smokeHues(P.hue);\n  const PUR = [hsv(hA, 0.85, 0.36), hsv(hA, 0.82, 0.6), hsv(hA + 0.01, 0.66, 0.84), hsv(hA + 0.02, 0.36, 1)];\n  const GRN = [hsv(hB, 0.9, 0.36), hsv(hB - 0.01, 0.9, 0.6), hsv(hB - 0.03, 0.78, 0.86), hsv(hB - 0.05, 0.4, 1)];\n  const BONE = [hsv(hB, 0.3, 0.4), hsv(hB, 0.25, 0.65), hsv(hB - 0.02, 0.18, 0.88), [244, 255, 232]];\n  const PAL = [PUR, GRN, BONE, [PUR[0], PUR[1], PUR[2], PUR[2]], [GRN[0], GRN[1], GRN[2], GRN[2]]];\n  const GLASS = hsv(hA - 0.03, 0.75, 0.12), RIM = hsv(hA - 0.04, 0.5, 0.36);\n  let sumP = 0, sumG = 0;\n\n  // The ball.\n  for (let y = CY - R - 1; y \u003c= CY + R + 1; y++)\n    for (let x = CX - R - 1; x \u003c= CX + R + 1; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      if (r > R + 0.5) continue;\n      if (r > R - 0.6) {\n        put(display, x, y, RIM);\n        continue;\n      }\n      const p = (y >> 1) * GW + (x >> 1);\n      let w = 0, top = 0, best = 0;\n      for (let k = 0; k \u003c 5; k++) {\n        const v = cw[k][p];\n        w += v;\n        if (v > best) (best = v), (top = k);\n      }\n      sumP += cw[0][p];\n      sumG += cw[1][p];\n      let col = GLASS;\n      if (w >= 0.3) col = PAL[top][w \u003c 0.75 ? 0 : w \u003c 1.4 ? 1 : w \u003c 2.3 ? 2 : 3];\n      put(display, x, y, col);\n    }\n  // The highlight: an arc high on the left and a small glint.\n  for (let y = CY - R; y \u003c CY; y++)\n    for (let x = CX - R; x \u003c CX; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy), an = Math.atan2(dy, dx);\n      if (r > R - 4.6 && r \u003c R - 2.4 && an > -2.75 && an \u003c -1.95) display.setPixel(x, y, 200, 196, 228);\n    }\n  for (const [x, y] of [[13, 44], [14, 44], [13, 45], [16, 41]]) display.setPixel(x, y, 236, 236, 252);\n\n  // Light under the ball: the smoke's colour, brighter in a vision.\n  const gmix = sumG / max(1e-6, sumP + sumG), lit = 0.55 + 0.45 * G;\n  const tint = hsv(gmix > 0.5 ? hB : hA, 0.75, 1);\n  // The table: a pool of light in three rings, then the stand on it.\n  for (let y = 100; y \u003c 118; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const e = ((x + 0.5 - CX) / 30) ** 2 + ((y + 0.5 - 104) / 7) ** 2;\n      if (e >= 1) continue;\n      const v = lit * (e \u003c 0.25 ? 0.5 : e \u003c 0.6 ? 0.32 : 0.18);\n      put(display, x, y, [round((tint[0] * v) / 4) * 4, round((tint[1] * v) / 4) * 4, round((tint[2] * v) / 4) * 4]);\n    }\n  drawStand(display, G);\n\n  // A faint ring round the glass while a vision holds.\n  if (G > 0.3)\n    for (let a = 0; a \u003c 2 * PI; a += 0.02) {\n      const c = G > 0.8 ? BONE[1] : PUR[0];\n      put(display, floor(CX + (R + 2) * cos(a)), floor(CY + (R + 2) * sin(a)), c);\n    }\n  for (const s of P.sparks) {\n    const c = s.life \u003c 0.3 ? (s.g ? GRN[1] : PUR[1]) : s.g ? GRN[3] : PUR[3];\n    put(display, floor(s.x), floor(s.y), c);\n  }\n}\n\n// The brass stand: a cup round the bottom of the glass, a neck and a foot,\n// lit from the left in three tones, its top edge catching the ball's light.\nconst BRASS = [[244, 204, 96], [184, 128, 40], [112, 72, 24]];\nfunction drawStand(display) {\n  const rows = [];\n  for (let y = 80; y \u003c= 91; y++) rows.push([y, 19 - ((y - 80) * 7) / 11]);\n  for (let y = 92; y \u003c= 95; y++) rows.push([y, 6]);\n  for (let y = 96; y \u003c= 103; y++) rows.push([y, y === 96 ? 8 : 10 + ((y - 97) * 7) / 6]);\n  for (const [y, hw] of rows) {\n    const x0 = round(CX - hw), x1 = round(CX + hw);\n    for (let x = x0; x \u003c x1; x++) {\n      const u = (x + 0.5 - CX) / hw;\n      let t = u \u003c -0.35 ? 0 : u \u003c 0.45 ? 1 : 2;\n      if (y === 80 || y === 92 || y === 97) t = max(0, t - 1);\n      if (y === 91 || y === 95 || y === 103) t = 2;\n      put(display, x, y, BRASS[t]);\n    }\n  }\n}\n","ham-sandwich":"// ===== Patternflow pattern =====\n// Title:   Ham Sandwich\n// Family:  topology\n// Idea:    Two clouds of 4,401 crumbs each, cyan bread and magenta ham, drift round each other, stretch, split and merge, and every frame one straight knife through one crumb of each leaves 2,200 of each cloud on either side, the crumbs on one side lit bright and on the other dim.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: ham sandwich theorem (Arthur Stone and John Tukey, 1942)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..6, Thin=0..1, Scatter=0..1\n//\n// Knob 1: Hue. The two clouds' colours. At 0 the bread is cyan and the ham magenta, at 0.14 azure and rose, at 0.64 green and blue, and back to cyan and magenta at 1. They stay between green and rose because red, orange and yellow turn brown on the dim side of the knife.\n// Knob 2: Speed. At 2 the clouds go once round each other in 10 seconds and each cloud's two lobes part and meet again every 7.7 seconds; at 0.2 everything takes ten times as long, at 6 a third as long.\n// Knob 3: Thin. Crumbs in each cloud, always an odd number: 4,401 at 0, 2,401 at 0.5, 401 at 1. At 0 the clouds fill the panel with a checkerboard stipple; at 1 the crumbs stand apart and the knife can be seen to pass between them.\n// Knob 4: Scatter. The share of crumbs that leave their cloud for a place of their own anywhere on the panel: about 4% at the start, all of them at 1, when bread and ham are two even sprinklings over the whole panel and the knife still halves both.\n\nconst W = 64, H = 128;\nconst { floor, round, min, abs, sqrt, sin, cos, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Crumbs in each cloud at Thin 0 and at Thin 1.\nconst NMAX = 4401, NMIN = 401;\n// The bread's hue sweeps HUE_LO..HUE_LO + HUE_SPAN as Hue turns, cyan (0.52)\n// at Hue 0; the ham stays GAP round the wheel from it.\nconst HUE_LO = 0.32, HUE_SPAN = 0.28, GAP = 0.34, HUE_U0 = 0.357;\n// Level of a crumb on the bright side and the dim side of the knife.\nconst BRIGHT = 1, DIM = 0.38;\n// Level of the glow round a crumb on the bright side.\nconst GLOW = 0.4;\n// Half width of the knife in LEDs.\nconst KNIFE = 2.0;\n// One orbit of the two clouds round each other, in seconds at Speed 2, and\n// the orbit's half axes in LEDs.\nconst ORBIT = 10, RX = 13, RY = 32;\n// The orbit's angle at the start.\nconst PHASE0 = -0.9 * PI;\n// Most distance between a cloud's two lobes, in LEDs.\nconst SPLIT = 26;\n// A lobe's half axes in LEDs: long LA +- LA1, short LB +- LB1; how far its rim frays.\nconst LA = 32, LA1 = 5, LB = 21, LB1 = 3, FRAY = 0.3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A crumb's place in its lobe: even over the unit disk, its rim frayed.\nfunction inDisk() {\n  const r = sqrt(Math.random()) * (1 + FRAY * (Math.random() + Math.random() - 1)), a = TAU * Math.random();\n  return [r * cos(a), r * sin(a)];\n}\n\nfunction cloud() {\n  const C = {\n    gx: new Float32Array(NMAX), gy: new Float32Array(NMAX), w: new Float32Array(NMAX), lobe: new Uint8Array(NMAX),\n    ux: new Float32Array(NMAX), uy: new Float32Array(NMAX), rank: new Float32Array(NMAX), ph: new Float32Array(NMAX),\n    x: new Float64Array(NMAX), y: new Float64Array(NMAX), lobes: [new Float64Array(6), new Float64Array(6)],\n  };\n  for (let i = 0; i \u003c NMAX; i++) {\n    const [a, b] = inDisk();\n    C.gx[i] = a;\n    C.gy[i] = b;\n    C.w[i] = (0.15 + 0.35 * Math.random()) * (Math.random() \u003c 0.5 ? -1 : 1);\n    C.lobe[i] = Math.random() \u003c 0.5 ? 1 : 0;\n    C.ux[i] = Math.random() * W;\n    C.uy[i] = Math.random() * H;\n    C.rank[i] = Math.random();\n    C.ph[i] = Math.random() * TAU;\n  }\n  return C;\n}\n\nexport function setup(params) {\n  params.s = {\n    A: cloud(), B: cloud(), nA: NMAX, nB: NMAX, tau: 0, hue: 0, scatter: 0.06, th: 0,\n    proj: new Float64Array(NMAX), idx: new Int32Array(NMAX), idxN: 0, m: 0, med: 0,\n    line: { ax: 0, ay: 0, nx: 1, ny: 0, ia: 0, ib: 0 },\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(12),\n  };\n}\n\nconst odd = (v) => {\n  const n = round(v);\n  return n % 2 ? n : n + 1;\n};\n\n// Place the crumbs of cloud C (centre cx, cy) at time tau.\nfunction place(C, n, cx, cy, tau, k, scatter) {\n  const split = SPLIT * (0.5 - 0.5 * cos((TAU * tau) / 7.7 + k * 2.1));\n  const beta = (TAU * tau) / 17 + k * 1.3;\n  const dx = 0.5 * split * cos(beta), dy = 0.5 * split * sin(beta);\n  for (let L = 0; L \u003c 2; L++) {\n    // Each lobe is a disk stretched to an ellipse that breathes and turns.\n    const sa = LA + LA1 * sin((TAU * tau) / 9.1 + k + L * 2), sb = LB + LB1 * sin((TAU * tau) / 6.3 + 2 * k + L);\n    const phi = (TAU * tau) / 13 + k * 0.7 + L * 1.9;\n    C.lobes[L].set([cx + (L ? dx : -dx), cy + (L ? dy : -dy), sa, sb, cos(phi), sin(phi)]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    // Each crumb also circles inside its lobe at its own pace.\n    const [lx, ly, sa, sb, pc, ps] = C.lobes[C.lobe[i]];\n    const sw = C.w[i] * tau, swc = cos(sw), sws = sin(sw);\n    const gx = C.gx[i] * swc - C.gy[i] * sws, gy = C.gx[i] * sws + C.gy[i] * swc;\n    const ex = gx * sa, ey = gy * sb;\n    let x = lx + ex * pc - ey * ps, y = ly + ex * ps + ey * pc;\n    const u = sm((1.04 * scatter - C.rank[i]) / 0.04);\n    if (u > 0) {\n      const sx = C.ux[i] + 6 * sin(0.4 * tau + C.ph[i]), sy = C.uy[i] + 10 * cos(0.3 * tau + C.ph[i]);\n      x += (sx - x) * u;\n      y += (sy - y) * u;\n    }\n    // Mirror back off the panel's edges.\n    if (x \u003c 0) x = -x;\n    if (x >= W) x = 2 * W - x;\n    if (y \u003c 0) y = -y;\n    if (y >= H) y = 2 * H - y;\n    C.x[i] = cl(x, 0.001, W - 0.001);\n    C.y[i] = cl(y, 0.001, H - 0.001);\n  }\n}\n\n// The index of the k-th smallest key among idx[0..n-1] (Hoare's select).\nfunction select(idx, key, n, k) {\n  let lo = 0, hi = n - 1;\n  while (hi > lo) {\n    const pv = key[idx[(lo + hi) >> 1]];\n    let i = lo, j = hi;\n    while (i \u003c= j) {\n      while (key[idx[i]] \u003c pv) i++;\n      while (key[idx[j]] > pv) j--;\n      if (i \u003c= j) {\n        const t = idx[i];\n        idx[i] = idx[j];\n        idx[j] = t;\n        i++;\n        j--;\n      }\n    }\n    if (k \u003c= j) hi = j;\n    else if (k >= i) lo = i;\n    else break;\n  }\n  return idx[k];\n}\n\n// For the normal at angle th: the bread crumb at the median of the\n// projections (left in S.m, its projection in S.med), and how many ham\n// crumbs lie above the line through it minus how many lie below. idx keeps\n// last call's order, so the select starts nearly done.\nfunction halve(S, th) {\n  const { A, B, nA, nB, proj, idx } = S, c = cos(th), s = sin(th), ax = A.x, ay = A.y, bx = B.x, by = B.y;\n  for (let i = 0; i \u003c nA; i++) proj[i] = c * ax[i] + s * ay[i];\n  const m = select(idx, proj, nA, (nA - 1) >> 1), med = proj[m];\n  let g = 0;\n  for (let j = 0; j \u003c nB; j++) {\n    const v = c * bx[j] + s * by[j] - med;\n    g += v > 0 ? 1 : v \u003c 0 ? -1 : 0;\n  }\n  S.m = m;\n  S.med = med;\n  return g;\n}\n\n// The cut, searched for near last frame's angle so the knife does not jump\n// from one cut to another. g(th + pi) = -g(th), so g changes sign within\n// pi/2 of any angle.\nconst STEPS = [0.02, 0.06, 0.15, 0.35, 0.8, PI / 2];\nfunction cut(S) {\n  if (S.idxN !== S.nA) {\n    for (let i = 0; i \u003c S.nA; i++) S.idx[i] = i;\n    S.idxN = S.nA;\n  }\n  let lo = S.th, hi = NaN;\n  const g0 = halve(S, lo);\n  if (g0 === 0) return finish(S, lo, lo);\n  outer: for (const sgn of [1, -1]) {\n    let prev = lo;\n    for (const d of STEPS) {\n      const t = S.th + sgn * d, g = halve(S, t);\n      if (g === 0) return finish(S, t, t);\n      if (g * g0 \u003c 0) {\n        (lo = prev), (hi = t);\n        break outer;\n      }\n      prev = t;\n    }\n  }\n  if (hi !== hi) hi = lo + PI;\n  // Halve the bracket until it is narrow, then until the median bread crumb\n  // is the same at both ends and one ham crumb crosses between them.\n  for (let it = 0; it \u003c 80; it++) {\n    if (abs(hi - lo) \u003c 2e-6 && finish(S, lo, hi)) return;\n    const mid = 0.5 * (lo + hi), g = halve(S, mid);\n    if (g === 0) return finish(S, mid, mid);\n    if (g * g0 > 0) lo = mid;\n    else hi = mid;\n  }\n  finish(S, lo, hi, true);\n}\n\n// Between th0 and th1 the line through the median bread crumb turns across\n// one ham crumb. The knife is the line through those two crumbs.\nfunction finish(S, th0, th1, force) {\n  const { A, B, nB } = S;\n  halve(S, th0);\n  const m0 = S.m, med0 = S.med;\n  halve(S, th1);\n  const m1 = S.m, med1 = S.med;\n  const c0 = cos(th0), s0 = sin(th0), c1 = cos(th1), s1 = sin(th1);\n  let ib = -1, crossed = 0, best = 1e9;\n  for (let j = 0; j \u003c nB; j++) {\n    const v0 = c0 * B.x[j] + s0 * B.y[j] - med0, v1 = c1 * B.x[j] + s1 * B.y[j] - med1;\n    if (v0 * v1 \u003c= 0) {\n      crossed++;\n      if (best > 0) (best = 0), (ib = j);\n    } else if (min(abs(v0), abs(v1)) \u003c best) (best = min(abs(v0), abs(v1))), (ib = j);\n  }\n  if (!force && (m0 !== m1 || crossed !== 1)) return false;\n  const th = 0.5 * (th0 + th1), ia = m0;\n  const ax = A.x[ia], ay = A.y[ia], bx = B.x[ib], by = B.y[ib];\n  let nx = cos(th), ny = sin(th);\n  const L = sqrt((bx - ax) ** 2 + (by - ay) ** 2);\n  if (L > 1e-6) {\n    // The normal of the line through both crumbs, turned to face like th's.\n    let qx = -(by - ay) / L, qy = (bx - ax) / L;\n    if (qx * nx + qy * ny \u003c 0) (qx = -qx), (qy = -qy);\n    (nx = qx), (ny = qy);\n  }\n  S.th = th;\n  Object.assign(S.line, { ax, ay, nx, ny, ia, ib });\n  return true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.tau += (d * cl(k[1], 0.2, 6)) / 2;\n  S.nA = S.nB = odd(NMAX - (NMAX - NMIN) * cl(k[2], 0, 1));\n  S.scatter = cl(k[3], 0, 1);\n  const w = PHASE0 + (TAU * S.tau) / ORBIT + 0.35 * sin((TAU * S.tau) / 23);\n  const rx = RX + 3 * sin((TAU * S.tau) / 11), ry = RY + 5 * sin((TAU * S.tau) / 14.5);\n  place(S.A, S.nA, W / 2 + rx * cos(w), H / 2 + ry * sin(w), S.tau, 0, S.scatter);\n  place(S.B, S.nB, W / 2 - rx * cos(w), H / 2 - ry * sin(w), S.tau, 1, S.scatter);\n  cut(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c, A, B, nA, nB, line } = S;\n  rgb.fill(0);\n  // Hue runs the bread up and down HUE_LO..HUE_LO + HUE_SPAN and the ham\n  // GAP behind it, both between green and pink: red, orange and yellow\n  // turn brown on the dim side.\n  const u = (S.hue + HUE_U0) % 1, ha = HUE_LO + HUE_SPAN * (1 - abs(2 * u - 1)), hb = ha + GAP;\n  hsv(ha, 0.85, BRIGHT, c, 0);\n  hsv(ha, 0.9, DIM, c, 3);\n  hsv(hb, 0.75, BRIGHT, c, 6);\n  hsv(hb, 0.9, DIM, c, 9);\n  const { ax, ay, nx, ny } = line;\n  // Crumbs sit on the white squares of a checkerboard of LEDs (x + y even);\n  // one off it steps to the nearer neighbour on it. A crumb on the bright\n  // side lights its four neighbours at GLOW.\n  const spot = (C, i) => {\n    const x = C.x[i], y = C.y[i];\n    let X = x | 0, Y = y | 0;\n    if ((X + Y) & 1) {\n      const fx = x - X - 0.5, fy = y - Y - 0.5;\n      if (abs(fx) > abs(fy)) X += fx > 0 ? (X \u003c W - 1 ? 1 : -1) : X > 0 ? -1 : 1;\n      else Y += fy > 0 ? (Y \u003c H - 1 ? 1 : -1) : Y > 0 ? -1 : 1;\n    }\n    return Y * W + X;\n  };\n  const glow = (C, n, o) => {\n    const r = c[o] * GLOW, g = c[o + 1] * GLOW, b = c[o + 2] * GLOW;\n    const put = (p) => {\n      (rgb[3 * p] = r), (rgb[3 * p + 1] = g), (rgb[3 * p + 2] = b);\n    };\n    for (let i = 0; i \u003c n; i++) {\n      if (nx * (C.x[i] - ax) + ny * (C.y[i] - ay) \u003c= 0) continue;\n      const p = spot(C, i), X = p % W;\n      if (X > 0) put(p - 1);\n      if (X \u003c W - 1) put(p + 1);\n      if (p >= W) put(p - W);\n      if (p \u003c W * (H - 1)) put(p + W);\n    }\n  };\n  const dot = (C, n, o) => {\n    for (let i = 0; i \u003c n; i++) {\n      const q = nx * (C.x[i] - ax) + ny * (C.y[i] - ay) > 0 ? o : o + 3, p = spot(C, i) * 3;\n      rgb[p] = c[q];\n      rgb[p + 1] = c[q + 1];\n      rgb[p + 2] = c[q + 2];\n    }\n  };\n  glow(A, nA, 0);\n  glow(B, nB, 6);\n  dot(A, nA, 0);\n  dot(B, nB, 6);\n  // The knife.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      const dd = abs(nx * (x + 0.5 - ax) + ny * (y + 0.5 - ay));\n      if (dd \u003c KNIFE) (rgb[p] = 1), (rgb[p + 1] = 0.95), (rgb[p + 2] = 0.8);\n    }\n  // The two crumbs the knife passes through: white, in a hole in the blade\n  // ringed in their cloud's colour.\n  for (const [C, i, o] of [[A, line.ia, 0], [B, line.ib, 6]]) {\n    const p0 = spot(C, i), x = p0 % W, y = (p0 - x) / W;\n    for (let v = -3; v \u003c= 3; v++)\n      for (let u = -3; u \u003c= 3; u++) {\n        const r = u * u + v * v, X = x + u, Y = y + v;\n        if (r > 13 || X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const p = (Y * W + X) * 3, m = r === 0 ? -1 : r \u003c 7 ? 0 : 1;\n        rgb[p] = m \u003c 0 ? 1 : c[o] * m;\n        rgb[p + 1] = m \u003c 0 ? 1 : c[o + 1] * m;\n        rgb[p + 2] = m \u003c 0 ? 1 : c[o + 2] * m;\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o] * 255, rgb[o + 1] * 255, rgb[o + 2] * 255);\n}\n","haunted-swing":"// ===== Patternflow pattern =====\n// Title:   Haunted Swing\n// Family:  halloween\n// Idea:    An empty swing set seen from the side on a purple night, a plank swing on 100 LEDs of chain swinging by itself as a lightly damped pendulum, a glowing hand of mist now and then shoving it on as it passes the bottom, and the smaller swing behind it on the same crossbar starting to move on its own as the shared bar hands the motion over and back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Coupling=0.2..1, Haunt=0..1\n//\n// Knob 1: Hue. The ghost's light and the night with it. At 0 a toxic green hand in a purple night with lilac moonlight on the metal; at 0.25 cold white in deep blue; at 0.5 violet in dark teal with pale aqua moonlight; at 0.75 pumpkin orange in indigo.\n// Knob 2: Speed. The clock of the scene. At 2 a swing takes 2.6 s to go out and back; at 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Coupling. How strongly the shared bar ties the two swings, as the time the near swing takes to hand all its motion to the one behind: 9 s at 0.2, 3.7 s at 0.5 and 1.6 s at 1 (at Speed 2). At 0.2 the swing behind starts still, and after the first push it swings 15 degrees by 8 s while the near one falls from 17 to 8.\n// Knob 4: Haunt. How often and how hard the hand comes, and how much of the ghost stays. After a hand has faded the next comes in 8 to 11 s at 0, 7.6 to 10.5 s at 0.06 and 2 to 3 s at 1, pushing twice as hard there, and three times in ten for the swing behind. The seats' after-image lasts 0.9 s at 0.06 and 2 s at 1, where a cold glow also sits on each seat. The first hand comes at 2.2 to 3.5 s at Speed 2 whatever the knob.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The pendulum, in seconds at Speed 2: angular frequency for a 2.6 s swing,\n// damping (a swing left alone loses half its energy in 15 s), and the\n// half beat of the coupling through the bar at Coupling 1: the two swings\n// trade their motion in 1.8 s there, and in 9 s at 0.2.\nconst OM = (2 * PI) / 2.6, GAM = 0.046, HALF = 1.8;\n// The coupling constant that splits the two swings' frequencies by dw.\nconst kappa = (dw) => ((OM + dw) ** 2 - OM * OM) / 2;\n// The largest swing a push may give, in radians.\nconst AMAX = 0.32;\n// The near swing in LEDs: pivot and the distance from pivot to seat. Swings\n// farther back are the near one scaled by DEPTH about the point VP, so each\n// hangs a little higher and to the right, a fifth smaller.\nconst PX = 31, PY = 9, LEN = 100, DEPTH = 0.82, VPX = 64, VPY = 0;\n// Seconds a push lasts, and its hand fades after.\nconst PUSH = 0.5, FADE = 1.6;\n// Along Hue: the ghost's light (toxic green, cold white, violet, pumpkin,\n// green), the night behind it at its glow over the ground (purple, deep\n// blue, dark teal, indigo, purple) and the moonlight on the metal and the\n// seats (lilac, ice, pale aqua, lavender, lilac).\nconst TINTS = [[0.45, 1, 0.2], [0.78, 0.92, 1], [0.72, 0.42, 1], [1, 0.5, 0.08], [0.45, 1, 0.2]];\nconst NIGHTS = [[0.2, 0.04, 0.25], [0.03, 0.07, 0.3], [0, 0.16, 0.2], [0.12, 0.03, 0.3], [0.2, 0.04, 0.25]];\nconst MOONS = [[0.84, 0.78, 1], [0.7, 0.86, 1], [0.66, 1, 0.9], [0.88, 0.74, 1], [0.84, 0.78, 1]];\n// The moon, top left, and the stars.\nconst MX = 12, MY = 21, MR = 5;\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 12; i++) {\n  const x = floor(hash(i * 3 + 7) * W), y = floor(hash(i * 3 + 8) * 70);\n  if ((x - MX) ** 2 + (y - MY) ** 2 > 140) STARS.push([x, y, hash(i * 3 + 9) * 6.28]);\n}\n// The sky by row, black at the top and the night's colour towards the\n// ground, in five bands.\nconst SKY = new Float32Array(H);\nfor (let y = 0; y \u003c H; y++) SKY[y] = round(cl((y - 30) / 90, 0, 1) ** 1.6 * 5) / 5;\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: 0, speed: 2, couple: 0.2, haunt: 0.06,\n    // Angle and angular speed of the near swing (0) and the one behind (1).\n    t: 0, th: new Float64Array(2), om: new Float64Array(2),\n    // Seconds to the next push, and the one under way.\n    wait: 2.2, push: null,\n    // Recent angles, for the after-image of the seats.\n    trail: [], rgb: new Float32Array(W * H * 3), tint: [0.45, 1, 0.2], night: [0.2, 0.04, 0.25], moon: [0.84, 0.78, 1],\n  };\n}\n\nconst scaleOf = (j) => DEPTH ** j;\nconst pivot = (j) => [VPX + (PX - VPX) * scaleOf(j), VPY + (PY - VPY) * scaleOf(j)];\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.couple = cl(k[2], 0.2, 1);\n  S.haunt = cl(k[3], 0, 1);\n  if (!S.begun) {\n    S.begun = true;\n    // The near swing is already moving when the picture opens, more the\n    // more haunted the night.\n    S.th[0] = 0.21 + 0.09 * S.haunt;\n  }\n  const ds = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += ds;\n  // Pushes: when one is due, the hand comes for the near swing, or now and\n  // then, with Haunt, for the one at the back.\n  const P = S.push;\n  if (!P) {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) {\n      const j = Math.random() \u003c 0.3 * S.haunt ? 1 : 0;\n      S.push = { j, age: -1, dir: 0, last: S.th[j], at: null };\n    }\n  } else if (P.age \u003c 0) {\n    // The hand waits for the seat to pass the bottom of its arc, and shoves\n    // it on from behind, the way it is going.\n    const th = S.th[P.j];\n    if ((th \u003c= 0 && P.last > 0) || (th >= 0 && P.last \u003c 0) || abs(th) + abs(S.om[P.j]) \u003c 0.02) {\n      P.age = 0;\n      P.dir = S.om[P.j] >= 0 ? 1 : -1;\n    }\n    P.last = th;\n  } else {\n    P.age += ds;\n    if (P.age > PUSH + FADE) {\n      S.push = null;\n      const h = S.haunt;\n      S.wait = 8 - 6 * h + (3 - 2 * h) * Math.random();\n    }\n  }\n  // The pendulums in small steps: the large-angle equation with light\n  // damping, each swing pulled towards its neighbours through the bar.\n  const steps = max(1, ceil(ds / 0.004)), h = ds / steps, KAP = kappa((PI / HALF) * S.couple);\n  for (let i = 0; i \u003c steps; i++) {\n    for (let j = 0; j \u003c 2; j++) {\n      let a = -OM * OM * sin(S.th[j]) - GAM * S.om[j];\n      a += KAP * (S.th[1 - j] - S.th[j]);\n      const Q = S.push;\n      if (Q && Q.j === j && Q.age >= 0 && Q.age \u003c PUSH) {\n        // The push gives out as the swing nears the largest swing allowed.\n        const e = (S.om[j] / OM) ** 2 + 2 * (1 - cos(S.th[j]));\n        a += Q.dir * (3 + 3 * S.haunt) * cl(1 - e / (AMAX * AMAX), 0, 1);\n      }\n      S.om[j] += a * h;\n    }\n    for (let j = 0; j \u003c 2; j++) S.th[j] += S.om[j] * h;\n  }\n  S.trail.push([S.t, S.th[0], S.th[1]]);\n  while (S.trail.length && S.t - S.trail[0][0] > 2) S.trail.shift();\n}\n\n// --- drawing -------------------------------------------------------------\n\nfunction put(rgb, x, y, c, f) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = 3 * (y * W + x);\n  rgb[o] = c[0] * f;\n  rgb[o + 1] = c[1] * f;\n  rgb[o + 2] = c[2] * f;\n}\nfunction glow(rgb, x, y, c, f) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = 3 * (y * W + x);\n  rgb[o] = max(rgb[o], c[0] * f);\n  rgb[o + 1] = max(rgb[o + 1], c[1] * f);\n  rgb[o + 2] = max(rgb[o + 2], c[2] * f);\n}\n// A capsule of radius r round a-b with a hard edge. fn(x, y, u) paints a\n// covered LED, u the share of the way from a to b.\nfunction capsule(ax, ay, bx, by, r, fn) {\n  const ex = bx - ax, ey = by - ay, L2 = ex * ex + ey * ey || 1;\n  for (let y = max(0, floor(min(ay, by) - r)); y \u003c= min(H - 1, ceil(max(ay, by) + r)); y++)\n    for (let x = max(0, floor(min(ax, bx) - r)); x \u003c= min(W - 1, ceil(max(ax, bx) + r)); x++) {\n      const qx = x + 0.5 - ax, qy = y + 0.5 - ay, u = cl((qx * ex + qy * ey) / L2, 0, 1);\n      if ((qx - u * ex) ** 2 + (qy - u * ey) ** 2 \u003c= r * r) fn(x, y, u);\n    }\n}\nconst fill = (rgb, c, f) => (x, y) => put(rgb, x, y, c, f);\n\nconst PIPE = [0.17, 0.13, 0.27];\nconst mul = (c, f) => [c[0] * f, c[1] * f, c[2] * f];\n\n// Where swing j's seat is at angle th, and the way along it.\nfunction seatOf(j, th) {\n  const s = scaleOf(j), [px, py] = pivot(j);\n  return [px + sin(th) * LEN * s, py + cos(th) * LEN * s, cos(th), -sin(th)];\n}\n\n// One swing seen from the side: a chain from the bar, two hangers spread to\n// the ends of the seat, and the seat, a plank seen edge on, top lit.\nfunction drawSwing(rgb, C, j, th, f) {\n  const s = scaleOf(j), [px, py] = pivot(j), [cx, cy, vx, vy] = seatOf(j, th);\n  const ux = sin(th), uy = cos(th), half = 9 * s;\n  const kx = px + ux * (LEN - 17) * s, ky = py + uy * (LEN - 17) * s;\n  const len = (LEN - 17) * s, r = j ? 0.6 : 0.9;\n  // Links: every other two LEDs of chain catch the moon, and one glint\n  // runs up and down the chain as its angle to the moon changes.\n  const g = (0.45 + 2.4 * th) * len;\n  capsule(px, py, kx, ky, r, (x, y, u) => put(rgb, x, y, abs(u * len - g) \u003c 2 ? C.glint : floor((u * len) / 2) % 2 ? C.linkDim : C.link, f));\n  for (const e of [-1, 1]) capsule(kx, ky, cx + e * vx * half, cy + e * vy * half, 0.6, (x, y, u) => put(rgb, x, y, floor(u * 8) % 2 ? C.linkDim : C.link, f));\n  const t = max(1, 2.1 * s);\n  capsule(cx - vx * half, cy - vy * half, cx + vx * half, cy + vy * half, t, fill(rgb, C.seat, f));\n  capsule(cx - vx * half - ux * t * 0.6, cy - vy * half - uy * t * 0.6, cx + vx * half - ux * t * 0.6, cy + vy * half - uy * t * 0.6, 0.6, fill(rgb, C.seatLit, f));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, T = S.tint, N = S.night, M = S.moon, hn = S.haunt;\n  const hk = S.hue * (TINTS.length - 1), i0 = min(TINTS.length - 2, floor(hk)), ht = hk - i0;\n  for (let c = 0; c \u003c 3; c++) {\n    T[c] = TINTS[i0][c] + (TINTS[i0 + 1][c] - TINTS[i0][c]) * ht;\n    N[c] = NIGHTS[i0][c] + (NIGHTS[i0 + 1][c] - NIGHTS[i0][c]) * ht;\n    M[c] = MOONS[i0][c] + (MOONS[i0 + 1][c] - MOONS[i0][c]) * ht;\n  }\n  const C = { pipe: PIPE, pipeLit: mul(M, 0.6), link: mul(M, 0.78), linkDim: mul(M, 0.4), seat: mul(M, 0.16), seatLit: mul(M, 1), glint: [1, 1, 1] };\n  // Sky, moon and its rings.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = 3 * (y * W + x), d = sqrt((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2);\n      let R = 0.012 + N[0] * SKY[y], G = 0.004 + N[1] * SKY[y], B = 0.035 + N[2] * SKY[y];\n      if (d \u003c MR) {\n        R = 0.95 * M[0];\n        G = 0.95 * M[1];\n        B = 0.95 * M[2];\n      }\n      else {\n        const g = d \u003c MR + 2 ? 0.16 : d \u003c MR + 5 ? 0.08 : 0;\n        R += g;\n        G += g;\n        B += g * 1.2;\n      }\n      rgb[o] = R;\n      rgb[o + 1] = G;\n      rgb[o + 2] = B;\n    }\n  for (const [x, y, ph] of STARS) glow(rgb, x, y, [0.8, 0.8, 1], 0.3 + 0.2 * sin(S.t * 2 + ph));\n  // Fog over the ground: three layers of streaks drifting, the nearer ones\n  // faster and lower, tinted by the ghost's light, with gaps where the\n  // night shows through.\n  const fc = [0.3 + 0.4 * T[0], 0.24 + 0.4 * T[1], 0.4 + 0.4 * T[2]];\n  for (let l = 0; l \u003c 3; l++) {\n    const v = [-1.6, 2.4, -3.4][l], y0 = [104, 111, 117][l], thick = 3 + 2 * l, a = [0.3, 0.38, 0.46][l];\n    for (let x = 0; x \u003c W; x++) {\n      const u = x + S.t * v;\n      const d = sin(u * 0.08 + l * 1.7) + 0.7 * sin(u * 0.21 + l * 2.9);\n      if (d \u003c -0.3) continue;\n      const top = y0 + round(1.5 * sin(u * 0.05 + l)), hgt = round(thick * min(1, (d + 0.3) * 1.5));\n      for (let y = top; y \u003c top + hgt && y \u003c H; y++) {\n        const o = 3 * (y * W + x);\n        for (let q = 0; q \u003c 3; q++) rgb[o + q] = rgb[o + q] * (1 - a) + fc[q] * a;\n      }\n    }\n  }\n  // The ground: black with a ragged edge of grass.\n  for (let x = 0; x \u003c W; x++) {\n    const g = 124 - (hash(x + 99) \u003c 0.3 ? 1 : 0) - (hash(x + 5) \u003c 0.12 ? 2 : 0);\n    for (let y = g; y \u003c H; y++) put(rgb, x, y, [0.02, 0.01, 0.03], 1);\n  }\n  // The swings at the back, then the bar, the frame and the near swing.\n  const afterimage = (j) => {\n    const s = scaleOf(j), len = 0.8 + 1.2 * hn;\n    let prev = null;\n    for (const p of S.trail) {\n      const a = 1 - (S.t - p[0]) / len;\n      if (a \u003c= 0) continue;\n      const [cx, cy] = seatOf(j, p[1 + j]);\n      const bx = cx - sin(p[1 + j]) * -2.5 * s, by = cy + cos(p[1 + j]) * 2.5 * s;\n      if (prev) capsule(prev[0], prev[1], bx, by, 0.8 * s + 0.3, (x, y) => glow(rgb, x, y, T, (ceil(a * 3) / 3) * (0.4 + 0.3 * hn) * DEPTH ** j));\n      prev = [bx, by];\n    }\n  };\n  // With Haunt, a cold glow sits on each seat, as if something invisible\n  // were riding it.\n  const halo = (j) => {\n    const s = scaleOf(j), [cx, cy] = seatOf(j, S.th[j]), R = 13 * s;\n    for (let y = max(0, floor(cy - R)); y \u003c= min(H - 1, ceil(cy + R)); y++)\n      for (let x = max(0, floor(cx - R)); x \u003c= min(W - 1, ceil(cx + R)); x++) {\n        const d = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy + 3 * s) ** 2) / s;\n        const g = d \u003c 7 ? 0.24 : d \u003c 13 ? 0.12 : 0;\n        if (g) glow(rgb, x, y, T, round(g * hn * 16) / 16);\n      }\n  };\n  halo(1);\n  afterimage(1);\n  drawSwing(rgb, C, 1, S.th[1], 0.75 * DEPTH ** 2);\n  const [bx0, by0] = pivot(0), [bx1, by1] = pivot(1.6);\n  capsule(bx0, by0, bx1, by1, 1.7, fill(rgb, PIPE, 1));\n  capsule(bx0, by0 - 1.2, bx1, by1 - 1.2, 0.55, fill(rgb, C.pipeLit, 1));\n  for (const side of [-1, 1]) {\n    const fx = PX + side * 38;\n    capsule(PX, PY, fx, 132, 1.7, fill(rgb, PIPE, 1));\n    capsule(PX - 1.1, PY, fx - 1.1, 132, 0.55, fill(rgb, C.pipeLit, 1));\n  }\n  capsule(PX, PY, PX, PY, 3, fill(rgb, PIPE, 1));\n  capsule(PX - 1, PY - 1, PX - 1, PY - 1, 1.2, fill(rgb, C.pipeLit, 1));\n  halo(0);\n  afterimage(0);\n  drawSwing(rgb, C, 0, S.th[0], 1);\n  if (S.push && S.push.age >= 0) drawHand(S);\n  // Out in steps of 4, which keeps the frame small for its colours.\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, 4 * round(63.75 * min(1, rgb[o])), 4 * round(63.75 * min(1, rgb[o + 1])), 4 * round(63.75 * min(1, rgb[o + 2])));\n}\n\n// A hand of mist behind the seat's back end, palm to it, fingers up and the\n// thumb towards the seat, in the ghost's colour with a lit outline, and a\n// cold glow round it. It rides with the seat while it pushes, then lets go\n// and drifts back and up as it fades.\nconst HAND = [\n  [0, -0.5, 0, 1.5, 4],\n  [-3.6, -3, -5, -10, 1.05],\n  [-1.3, -4, -1.8, -12, 1.05],\n  [1.3, -4, 1.8, -11.5, 1.05],\n  [3.5, -3, 4.8, -9, 1],\n  [3.5, 1.5, 8, -2.5, 1],\n];\nfunction drawHand(S) {\n  const P = S.push, j = P.j, rgb = S.rgb, T = S.tint, s = scaleOf(j), hn = S.haunt;\n  const a = P.age \u003c 0.12 ? P.age / 0.12 : P.age \u003c PUSH ? 1 : 1 - (P.age - PUSH) / FADE;\n  const f = round(a * 4) / 4, big = (1.4 + 0.3 * hn) * s, back = -P.dir;\n  if (P.age \u003c PUSH || !P.at) {\n    const [cx, cy, vx, vy] = seatOf(j, S.th[j]);\n    P.at = [cx - P.dir * vx * 9 * s + back * 5.5 * big, cy - P.dir * vy * 9 * s - 3 * big];\n  }\n  const drift = P.age > PUSH ? (P.age - PUSH) * 7 : 0;\n  const hx = P.at[0] + back * drift * big, hy = P.at[1] - drift * 0.6 * big;\n  for (let y = max(0, floor(hy - 30)); y \u003c= min(H - 1, floor(hy + 30)); y++)\n    for (let x = max(0, floor(hx - 30)); x \u003c= min(W - 1, floor(hx + 30)); x++) {\n      const d = sqrt((x + 0.5 - hx) ** 2 + (y + 0.5 - hy + 3 * big) ** 2) / big;\n      const g = d \u003c 10 ? 0.3 : d \u003c 15 ? 0.18 : d \u003c 20 ? 0.09 : 0;\n      if (g) glow(rgb, x, y, T, g * f);\n    }\n  const mask = new Uint8Array(W * H);\n  for (const [x0, y0, x1, y1, r] of HAND)\n    capsule(hx - x0 * big * back, hy + y0 * big, hx - x1 * big * back, hy + y1 * big, r * big, (x, y) => (mask[y * W + x] = 1));\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (!mask[p]) continue;\n      const edge = !mask[p - 1] || !mask[p + 1] || !mask[p - W] || !mask[p + W];\n      glow(rgb, x, y, T, (edge ? 1 : 0.5) * f);\n    }\n}\n","kac-ring":"// ===== Patternflow pattern =====\n// Title:   Kac Ring\n// Family:  rhythm\n// Idea:    Mark Kac's ring of 64 balls steps round the 64 columns, every ball changing colour as it crosses one of an odd number of marked edges, the newest step entering at the bottom so the panel always holds one whole period of 128 steps, a quilt of parallelograms whose middle row is the start with light and dark swapped and whose ends are the start again, each period on a fresh set of marks, with each row's light share traced in white against the dashed Stosszahlansatz curve that says it should settle at one half.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kac ring model (Mark Kac, 1959)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Marks=3..15, Dark=0..0.5\n//\n// Knob 1: Hue. Turns the colour of the light balls round the wheel, and the dashed prediction opposite them; the dark balls stay a deep navy and the measured trace white. At 0 the light balls are ice cyan and the prediction coral, at 0.25 violet, at 0.5 rose with a cyan prediction and at 0.75 lime.\n// Knob 2: Speed. Steps a second, eight times the knob: 16 at 2, so a whole period of 128 steps passes in 8 s; 1.6 at 0.2 and 24 at 3.\n// Knob 3: Marks. How many of the 64 edges are marked, the knob rounded to an odd number: 3 at the start, 7 at a quarter of the way, 9 at half, 13 at three quarters and 15 at the end. Three marks make parallelograms tens of LEDs tall; fifteen make a close weave. A new count redraws the whole period at once.\n// Knob 4: Dark. How many balls start dark, side by side in one run: none at 0, 4 of 64 at 0.06 (a 4-LED band that crosses the quilt and inverts it), 16 at 0.25 and half the ring at 0.5. The ring comes back to exactly this start every 128 steps whatever the share, and the prediction starts from it.\n\nconst W = 64, H = 128;\n// The ring: N sites, one per column, and the period 2N, one per row.\nconst N = 64, P = 128;\nconst { floor, round, min, max, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Steps a second for each unit of Speed.\nconst RATE = 8;\n// Hue of the light balls at knob 0.\nconst HUE0 = 0.5;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: 0, speed: 2, m: 0, nd: -1, acc: 0,\n    // marks[e] is 1 when the edge from site e to site e+1 is marked; init is\n    // the start (1 = a dark ball), cur the ring now, at step k of its period.\n    marks: new Uint8Array(N), init: new Uint8Array(N), cur: new Uint8Array(N), nxt: new Uint8Array(N), k: 0,\n    // One row per step of the period, indexed by step mod 128: the colours,\n    // the light share, and the Stosszahlansatz prediction for that step.\n    rows: new Uint8Array(P * N), wf: new Float32Array(P), wp: new Float32Array(P),\n    col: new Float32Array(15),\n  };\n}\n\nconst oddOf = (v) => 2 * round((cl(v, 3, 15) - 1) / 2) + 1;\n\n// m distinct edges out of N, a partial shuffle.\nfunction pick(out, m) {\n  const idx = Array.from({ length: N }, (_, i) => i);\n  out.fill(0);\n  for (let i = 0; i \u003c m; i++) {\n    const j = i + floor(Math.random() * (N - i));\n    const t = idx[i];\n    idx[i] = idx[j];\n    idx[j] = t;\n    out[idx[i]] = 1;\n  }\n}\n\n// One step of the ring: every ball moves one site on, and a ball that\n// crosses a marked edge changes colour.\nfunction step(cur, marks, out) {\n  for (let x = 0; x \u003c N; x++) out[(x + 1) % N] = cur[x] ^ marks[x];\n}\n\nfunction lightShare(c) {\n  let n = 0;\n  for (let x = 0; x \u003c N; x++) n += c[x] ? 0 : 1;\n  return n / N;\n}\n\n// Boltzmann's coarse equation for the ring: the light-minus-dark share\n// shrinks by (1 - 2 mu) every step, so the light share heads for one half.\nfunction predict(S, k) {\n  const w0 = lightShare(S.init), mu = S.m / N;\n  return 0.5 + (w0 - 0.5) * pow(1 - 2 * mu, k);\n}\n\nfunction store(S, k, c) {\n  S.rows.set(c, k * N);\n  S.wf[k] = lightShare(c);\n  S.wp[k] = predict(S, k);\n}\n\n// The whole period at once, as if these marks had run all along: rows for\n// steps 0..127 from the start, and the ring set back to step k.\nfunction fill(S) {\n  const a = S.init.slice(), b = new Uint8Array(N);\n  for (let k = 0; k \u003c P; k++) {\n    store(S, k, a);\n    if (k === S.k) S.cur.set(a);\n    step(a, S.marks, b);\n    a.set(b);\n  }\n}\n\nfunction advance(S) {\n  step(S.cur, S.marks, S.nxt);\n  S.cur.set(S.nxt);\n  S.k = (S.k + 1) % P;\n  // Back at the start: a fresh set of marks, as many as before.\n  if (S.k === 0) pick(S.marks, S.m);\n  store(S, S.k, S.cur);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 3, 0.06];\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const m = oddOf(kv[2]), nd = round(cl(kv[3], 0, 0.5) * N);\n  if (!S.begun || m !== S.m || nd !== S.nd) {\n    if (m !== S.m) {\n      S.m = m;\n      pick(S.marks, m);\n    }\n    if (nd !== S.nd) {\n      S.nd = nd;\n      // The dark balls start side by side, a run of nd from a random site.\n      const a = floor(Math.random() * N);\n      S.init.fill(0);\n      for (let i = 0; i \u003c nd; i++) S.init[(a + i) % N] = 1;\n    }\n    S.begun = true;\n    fill(S);\n  }\n  S.acc += cl(dt || 0, 0, 0.1) * RATE * S.speed;\n  for (let n = 0; S.acc >= 1 && n \u003c 8; n++) {\n    S.acc -= 1;\n    advance(S);\n  }\n  S.acc = min(S.acc, 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const C = S.col;\n  // Light balls, dark balls, the measured trace and the predicted one.\n  hsv(HUE0 + S.hue, 0.6, 1, C, 0);\n  hsv(0.66, 0.85, 0.2, C, 3);\n  C[6] = C[7] = C[8] = 1;\n  hsv(HUE0 + S.hue + 0.5, 0.7, 0.9, C, 9);\n  const c8 = Array.from(C, (v) => round(v * 255));\n  const xa = new Int16Array(H), xp = new Int16Array(H);\n  for (let y = 0; y \u003c H; y++) {\n    const r = (S.k + 1 + y) % P;\n    xa[y] = round(S.wf[r] * (W - 2));\n    xp[y] = round(S.wp[r] * (W - 2));\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const r = (S.k + 1 + y) % P, o = r * N;\n    const a0 = min(xa[y], y ? xa[y - 1] : xa[y]), a1 = max(xa[y], y ? xa[y - 1] : xa[y]) + 1;\n    // The prediction starts again with each period, so it is not joined\n    // across the start row.\n    const q = y && r ? xp[y - 1] : xp[y], p0 = min(xp[y], q), p1 = max(xp[y], q) + 1;\n    // The prediction is dashed, two rows on and two off, the dashes riding\n    // with their steps.\n    const dash = (r & 3) \u003c 2;\n    for (let x = 0; x \u003c W; x++) {\n      let c = S.rows[o + x] ? 3 : 0;\n      if (x >= a0 && x \u003c= a1) c = 6;\n      // A black edge each side keeps the white trace apart from light balls.\n      else if (x === a0 - 1 || x === a1 + 1) c = 12;\n      else if (dash && x >= p0 && x \u003c= p1) c = 9;\n      display.setPixel(x, y, c8[c], c8[c + 1], c8[c + 2]);\n    }\n  }\n}\n","lace-phantom":"// ===== Patternflow pattern =====\n// Title:   Lace Phantom\n// Family:  halloween\n// Idea:    A lace curtain fills a tall broken window at night and billows in the wind with the moon behind it, and now and then a face presses through from behind, the lace stretching over a brow, two eye hollows and an open mouth before it sinks back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lace=-1..1, Haunt=0..1\n//\n// Knob 1: Hue. The tint of the lace. At 0 lavender, at 0.35 cold blue-white, at 0.7 ice cyan and at 1 a ghostly green.\n// Knob 2: Speed. The wind. At 2 the hem swings about 5 LEDs each way every 4 seconds and the pleats ripple across it; at 0.2 all of it, the face too, is ten times slower, at 3 half as fast again.\n// Knob 3: Lace. The size of the pattern. At 0 a diamond trellis 26 LEDs across with a flower in each diamond; at -1 a finer one 20 LEDs across, its threads broken; at 1 a bold one 34 LEDs across with thick threads.\n// Knob 4: Haunt. How often a face presses through, and how hard. At 0.06 the first one starts at 2.2 s, is pressed full by 3.5 s, holds 1.6 s and is gone by 6.9 s, and the next comes 8.6 s later; at 1 the first is there at once, 25% bigger and deeper, and the next comes 2 s after the last has gone.\n// Buttons: K4 tap sends a face through now, or straight after the one already there.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// The tulle is a one-LED checker: the threads (x + y even) stand STEP above\n// the holes beside them, so every pair of neighbours is a gentle step. The\n// knots of the lace are threads at full level, each with four holes round\n// it, and there are always KNOTS of them: that count alone fixes how many\n// neighbour pairs are hard steps.\nconst STEP = 39, KNOTS = 800;\nconst CAND = [];\nfor (let y = 1; y \u003c H - 1; y++) for (let x = 2 - (y & 1); x \u003c W - 1; x += 2) CAND.push(y * W + x);\n// A fixed shuffle: where two places score the same, the earlier one in this\n// order gets the knot, so ties do not flicker from frame to frame.\nconst ORDER = CAND.slice();\nfor (let i = ORDER.length - 1; i > 0; i--) {\n  const j = floor(hash(i * 31 + 7) * (i + 1));\n  [ORDER[i], ORDER[j]] = [ORDER[j], ORDER[i]];\n}\nconst BINS = 1280, LO = -12, PER = 64;\n\n// The window behind the curtain: a mullion down the middle and two\n// transoms make six panes, and their shadows fall on the curtain. The moon\n// stands behind the upper right pane. The lower left pane is broken: a\n// jagged hole round (15, 108) lets the moonlight in unglazed, so the lace\n// over it is lit a little more, and cracks run from its points to the frame,\n// glinting where they catch the light.\nconst MOON = [48, 21, 8];\nconst HOLE = [15, 108];\nconst SPIKES = 11;\nconst RIM = [];\nfor (let k = 0; k \u003c SPIKES; k++) RIM.push((k & 1 ? 4 : 8.5) + 2.5 * hash(k + 60));\nconst holeR = (a) => {\n  const f = ((a / (2 * PI)) * SPIKES + SPIKES) % SPIKES, i = floor(f), u = f - i;\n  return RIM[i] + (RIM[(i + 1) % SPIKES] - RIM[i]) * u;\n};\nconst CRACKS = [];\nfor (let k = 0; k \u003c SPIKES; k += 2) {\n  const a = ((k + 0.5) / SPIKES) * 2 * PI, r0 = RIM[k] * 0.9, len = 12 + 14 * hash(k + 50);\n  CRACKS.push([HOLE[0] + cos(a) * r0, HOLE[1] + sin(a) * r0, HOLE[0] + cos(a + 0.15) * (r0 + len), HOLE[1] + sin(a + 0.15) * (r0 + len)]);\n}\nconst SHADE = new Float32Array(N), GAP = new Float32Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    let s = 0;\n    if (abs(x - 31.5) \u003c 2) s = 1;\n    if (abs(y - 43.5) \u003c 2 || abs(y - 86.5) \u003c 2) s = 1;\n    const hx = x - HOLE[0], hy = y - HOLE[1];\n    if (s === 0 && sqrt(hx * hx + hy * hy) \u003c holeR(Math.atan2(hy, hx) + PI)) GAP[y * W + x] = 1;\n    for (const [x0, y0, x1, y1] of CRACKS) {\n      if (x > 29 || y \u003c 89) continue;\n      const ex = x1 - x0, ey = y1 - y0, qx = x - x0, qy = y - y0, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey), 0, 1);\n      if (sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) \u003c 0.7) GAP[y * W + x] = max(GAP[y * W + x], 0.6);\n    }\n    SHADE[y * W + x] = s;\n  }\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, lace: 0, haunt: 0.06, t: 0,\n    face: null, wait: 2.3, queued: false,\n    L: new Uint8Array(N), lit: new Float32Array(N), score: new Float32Array(N), knot: new Uint8Array(N),\n    hist: new Int32Array(BINS), c: [0, 0, 0],\n  };\n}\n\nfunction newFace(S) {\n  S.face = {\n    x: 22 + 20 * Math.random(), y: 52 + 22 * Math.random(), r: (17 + 3 * Math.random()) * (1 + 0.25 * S.haunt),\n    age: 0, deep: 0.75 + 0.35 * S.haunt, turn: (Math.random() - 0.5) * 0.3, open: 1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.lace = cl(k[2], -1, 1);\n  S.haunt = cl(k[3], 0, 1);\n  if (!S.begun) {\n    // The first face comes sooner the higher Haunt is.\n    S.wait = 2.3 * (1 - S.haunt);\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  if (input.btnPressed && input.btnPressed[3]) {\n    if (S.face) S.queued = true;\n    else newFace(S);\n  }\n  if (S.face) {\n    S.face.age += ds;\n    // The mouth works open and shut while the face is held.\n    S.face.open = 0.75 + 0.3 * sin(S.face.age * 4.2);\n    if (S.face.age > 4.7) {\n      S.face = null;\n      S.wait = S.queued ? 0 : 9 - 7 * S.haunt;\n      S.queued = false;\n    }\n  } else {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) newFace(S);\n  }\n}\n\n// How far the face presses at its age: in for 1.3 s, held 1.6 s, back for 1.8 s.\nconst press = (a) => (a \u003c 1.3 ? sm(0, 1.3, a) : a \u003c 2.9 ? 1 : 1 - sm(2.9, 4.7, a));\n\n// Distance in LEDs from curtain point (u, v) to the nearest thread of the\n// lace motif: a diamond trellis, a ring and a centre knot in each diamond,\n// and a scalloped hem along the bottom.\nfunction motif(u, v, T) {\n  const a = u / T, b = v / T;\n  const p = a + b, q = a - b;\n  let dd = (abs(p - floor(p) - 0.5) * T) / 1.4142;\n  dd = min(dd, (abs(q - floor(q) - 0.5) * T) / 1.4142);\n  // Diamond centres sit where a + b and a - b are both whole.\n  const cp = round(p), cq = round(q), ca = (cp + cq) / 2, cb = (cp - cq) / 2;\n  const rx = (a - ca) * T, ry = (b - cb) * T, rr = sqrt(rx * rx + ry * ry);\n  dd = min(dd, abs(rr - 0.2 * T), rr);\n  if (v > 108) {\n    const sx = T / 2, k = round(u / sx), hx = u - k * sx, hy = v - 114;\n    dd = min(dd, abs(v - 109.5), hy > 0 ? abs(sqrt(hx * hx + hy * hy) - sx / 2) : 9);\n  }\n  return dd;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { L, lit, score, knot, hist } = S, t = S.t, T = 26 * 1.3 ** S.lace;\n  const F = S.face, fa = F ? press(F.age) * F.deep : 0;\n  // Face fields are drawn in the face's own units, its radius 1.\n  for (let y = 0; y \u003c H; y++) {\n    const sy = (y / H) ** 1.3;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      // The wind comes in at the broken pane and the hem swings most.\n      const gust = 1 + 0.9 * exp(-((x - HOLE[0]) ** 2 + (y - HOLE[1]) ** 2) / 700);\n      const dx = gust * sy * (5 * sin(1.6 * t - 0.045 * y + 0.6) + 1.6 * sin(3.1 * t - 0.11 * y + 0.07 * x));\n      const dy = gust * sy * 2.2 * sin(2.2 * t + 0.08 * x - 0.03 * y);\n      // Pleats: the cloth gathers into folds 13 LEDs apart that ripple.\n      const ph = (2 * PI * (x + dx)) / 13 + 0.7 * sin(0.9 * t + y * 0.02);\n      let u = x + dx + 1.4 * sin(ph), v = y + dy;\n      let light = 0.5 + 0.5 * cos(ph);\n      let face = -99, thin = 0, deep = 0, rise = 0;\n      if (fa > 0) {\n        const fx = (x - F.x) / F.r, fy = (y - F.y) / F.r, e = fx * fx + (fy / 1.25) ** 2;\n        if (e \u003c 1.6) {\n          const dome = max(0, 1 - e);\n          // The lace stretches over the head: the pattern grows there.\n          const st = 1 - 0.35 * fa * dome;\n          u = F.x + (u - F.x) * st;\n          v = F.y + (v - F.y) * st;\n          // The cloth drawn over the face lets more moonlight through: a\n          // pale glow, its level ramped over 8 LEDs or more so the checker\n          // keeps its gentle steps. The eye sockets and the open mouth are\n          // dark hollows in it. Where the cloth is drawn tightest (brow,\n          // nose, cheekbones) its knots crowd.\n          const ax = abs(fx + F.turn * fy), op = F.open;\n          const eye = ((ax - 0.36) / 0.2) ** 2 + ((fy + 0.08) / 0.16) ** 2;\n          const mouth = (fx / 0.17) ** 2 + ((fy - 0.56) / (0.22 * op)) ** 2;\n          const hol = min(sm(0.45, 2.2, eye), sm(0.45, 2.2, mouth));\n          let hi = sm(0.1, 0.05, abs(fy + 0.38 - 0.2 * ax * ax)) * sm(0.66, 0.5, ax);\n          hi = max(hi, sm(0.07, 0.03, abs(fx)) * sm(-0.3, -0.18, fy) * sm(0.36, 0.28, fy));\n          hi = max(hi, sm(0.06, 0.03, abs(fy - 0.15 - 0.4 * (ax - 0.36) ** 2)) * sm(0.66, 0.52, ax) * sm(0.1, 0.2, ax));\n          face = hi > 0 ? 1.6 * fa * hi - 1 : -99;\n          thin = 0.6 * fa * dome;\n          if (eye \u003c 1.2 || mouth \u003c 1.2) deep = fa;\n          rise = fa * sm(0, 0.8, dome);\n          light = light * (1 - rise) + rise * hol;\n          rise *= hol;\n        }\n      }\n      // The face is in front of the window, so no frame shadow falls on it.\n      const sh = SHADE[p] * (1 - min(1, 3 * rise));\n      // The moon is a disc behind the upper right pane, its rim ramped over 6 LEDs.\n      const mg = sm(MOON[2] + 6, MOON[2], sqrt((x - MOON[0]) ** 2 + (y - MOON[1]) ** 2));\n      L[p] = sh >= 1 ? 0 : round(min(80, 64 * mg + 76 * rise + 28 * GAP[p]) * (1 - sh));\n      lit[p] = deep > 0.3 ? 0 : cl(light * (1 - sh) + mg + GAP[p], 0, 1);\n      if ((x + y) & 1) continue;\n      score[p] = max(-motif(u, v, T) - thin, face) - 9 * deep - 9 * sh - 0.012 * L[p];\n    }\n  }\n  // Exactly KNOTS knots: the best-scored places, ties broken by ORDER.\n  hist.fill(0);\n  const binOf = (s) => cl(floor((s - LO) * PER), 0, BINS - 1);\n  for (const p of CAND) hist[binOf(score[p])]++;\n  let need = KNOTS, cut = BINS - 1;\n  while (cut > 0 && hist[cut] \u003c need) need -= hist[cut--];\n  knot.fill(0);\n  for (const p of ORDER) {\n    const b = binOf(score[p]);\n    if (b > cut) knot[p] = 1;\n    else if (b === cut && need > 0) {\n      knot[p] = 1;\n      need--;\n    }\n  }\n  // Colours: a pale tint where the lace is lit, the deep tint in shadow;\n  // either way the brightest channel is the level the checker asks for.\n  const h = 0.76 - 0.42 * S.hue, c = S.c;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let lv;\n      const q = round(lit[p] * 3) / 3;\n      if ((x + y) & 1) {\n        lv = L[p];\n        if (lv === 0) {\n          display.setPixel(x, y, 0, 0, 0);\n          continue;\n        }\n        hsv(h, 0.9 - 0.5 * q, 1, c);\n      } else if (knot[p]) {\n        lv = 255;\n        hsv(h, 0.38 - 0.26 * q, 1, c);\n      } else {\n        let m = 255;\n        if (x > 0) m = min(m, L[p - 1]);\n        if (x \u003c W - 1) m = min(m, L[p + 1]);\n        if (y > 0) m = min(m, L[p - W]);\n        if (y \u003c H - 1) m = min(m, L[p + W]);\n        lv = m + STEP;\n        hsv(h + 0.03 * (1 - q), 1 - 0.72 * q, 1, c);\n      }\n      display.setPixel(x, y, round(c[0] * lv), round(c[1] * lv), round(c[2] * lv));\n    }\n}\n","peregrine-soliton":"// ===== Patternflow pattern =====\n// Title:   Peregrine Soliton\n// Family:  wave\n// Idea:    A regular train of sea waves runs under a dark sky with the modulus of a breather of the focusing nonlinear Schrödinger equation as its envelope, so one crest rises out of nowhere to three times the swell between two calm holes and sinks again, while the envelope's space-time record scrolls up above the sea.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Peregrine soliton (Howell Peregrine, 1983)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Family=-1..1, Swell=0..1\n//\n// Knob 1: Hue. Turns the sea and the record from teal at 0 through blue (0.25), indigo (0.5) and purple (0.75) to rose at 1; the foam stays white.\n// Knob 2: Speed. At 2 the equation's clock runs 0.77 units a second at the opening swell: the Peregrine crest stands above twice the swell for 1.7 s and the next breather comes 9 s later. The crests run 14 LEDs a second and the envelope 7, the group speed of deep water. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Family. Which breather of the one-parameter family. At 0 the Peregrine soliton (a = 1/2): one crest three times the swell, once, one to three crests further on each time. Below 0 Akhmediev breathers, periodic along the sea, down to a = 0.2 at -1: three crests 20.5 LEDs apart rising together to 2.26 times the swell (the sea is drawn finer for them). Above 0 Kuznetsov-Ma breathers, periodic in time, up to a = 0.9 at 1: one crest that pulses to 3.68 times the swell every 2.6 units (3.4 s) for ever.\n// Knob 4: Swell. The background amplitude A, 0.75 at 0 to 1.35 at 1, 0.79 at 0.06: a swell 12.6 LEDs high and a rogue of 38 standing 15.7 LEDs wide between its holes. The equation's scaling A psi(Ax, A^2 t) keeps the rogue three times the swell at every A, but makes it 1/A as wide and 1/A^2 as quick: at 1 the swell is 22 LEDs, the rogue 65 LEDs high and 9 wide, and a breather comes every 3 s.\n\nconst W = 64, H = 128, REC = 40, MEAN = 96, VS = 16, LAM = 16;\nconst { floor, round, min, max, abs, sqrt, cos, sin, cosh, sinh, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => v * v * (3 - 2 * v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const r = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  const g = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  const b = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return [round(r * 63) * 4, round(g * 63) * 4, round(b * 63) * 4];\n}\n\n// The breather family of i psi_t + psi_xx / 2 + |psi|^2 psi = 0 on the\n// background e^{it}, written as psi = phi(x, t) e^{it}. For a \u003c 1/2 the\n// Akhmediev breather, for a > 1/2 the Kuznetsov-Ma breather (b and w turn\n// imaginary, cos and cosh trade places), at a = 1/2 the Peregrine soliton.\n// out gets [Re phi, Im phi].\nexport function breather(a, x, t, out) {\n  if (abs(a - 0.5) \u003c 1e-9) {\n    const D = 1 + 4 * x * x + 4 * t * t;\n    out[0] = 1 - 4 / D;\n    out[1] = (-8 * t) / D;\n    return out;\n  }\n  const s = sqrt(2 * a);\n  if (a \u003c 0.5) {\n    const b = sqrt(8 * a * (1 - 2 * a)), w = 2 * sqrt(1 - 2 * a);\n    const ch = cosh(b * t), c = cos(w * x), den = s * c - ch;\n    out[0] = ((1 - 4 * a) * ch + s * c) / den;\n    out[1] = (b * sinh(b * t)) / den;\n    return out;\n  }\n  const b = sqrt(8 * a * (2 * a - 1)), w = 2 * sqrt(2 * a - 1);\n  const ch = cosh(min(30, w * abs(x))), c = cos(b * t), den = s * ch - c;\n  out[0] = ((1 - 4 * a) * c + s * ch) / den;\n  out[1] = (-b * sin(b * t)) / den;\n  return out;\n}\nconst tmp = [0, 0];\nconst amp = (a, x, t) => {\n  breather(a, x, t, tmp);\n  return sqrt(tmp[0] * tmp[0] + tmp[1] * tmp[1]);\n};\n\n// Half a cycle of the equation's clock. Peregrine and Akhmediev breathers\n// rise once out of the background, so the clock runs -3.5..3.5 and starts\n// again with the next one; a Kuznetsov-Ma breather is periodic, and the\n// clock runs one whole period when that is not too long. |psi| is even in t,\n// so the end of a cycle and the start of the next one agree.\nfunction halfCycle(a) {\n  if (a \u003c= 0.5) return 3.5;\n  const T = PI / sqrt(8 * a * (2 * a - 1));\n  return T \u003c= 6 ? T : 3.5;\n}\nconst knobA = (k) => (abs(k) \u003c 0.02 ? 0.5 : 0.5 + (k \u003c 0 ? 0.3 : 0.4) * k);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, a: 0.5, A: 0.8, t: -3.4, xu: 14 + 10 * Math.random(), started: false, kap: 1.8,\n    rec: new Uint8Array(REC * W), head: 0, acc: 0, env: new Float32Array(W), spray: [],\n  };\n}\n\n// Units of the equation per LED at A = 1: 0.14, so the Peregrine crest is\n// 15.7 LEDs wide between its holes at the opening swell; finer for an\n// Akhmediev breather, so three of its peaks fit at a = 0.2.\nconst xScale = (a) => 0.14 * (a \u003c 0.5 ? 1 + (0.8 * (0.5 - a)) / 0.3 : 1);\n\n// The envelope |psi| along the sea, unscaled (the background is 1), with\n// the breather's middle at column xu. A localised breather wraps round the\n// 64 columns; an Akhmediev breather is periodic in x and needs no wrap.\nfunction envelope(P, xu, t) {\n  const k = P.A * xScale(P.a);\n  for (let x = 0; x \u003c W; x++) {\n    let dx = x + 0.5 - xu;\n    if (P.a >= 0.5) dx -= 64 * floor(dx / 64 + 0.5);\n    P.env[x] = amp(P.a, k * dx, t);\n  }\n}\n\n// One row of the record: the envelope in nine levels, black where it\n// falls under half the swell, the background 0.9..1.1.\nconst LEVELS = [0.5, 0.7, 0.9, 1.1, 1.35, 1.7, 2.1, 2.5];\nfunction pushRow(P) {\n  P.head = (P.head + 1) % REC;\n  const o = P.head * W;\n  for (let x = 0; x \u003c W; x++) {\n    const e = P.env[x];\n    let l = 0;\n    while (l \u003c 8 && e >= LEVELS[l]) l++;\n    P.rec[o + x] = l;\n  }\n}\n\n// The carrier: crests at theta = 0 (mod 2 pi), 1 at a crest and -0.5 in a\n// trough, the troughs a little flatter than the crests.\nconst theta = (P, x) => (2 * PI * (x + 0.5 - P.xu)) / LAM - P.kap * P.t;\nconst shape = (th) => 1.5 * ((1 + cos(th)) / 2) ** 0.8 - 0.5;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const speed = cl(k[1], 0.2, 3);\n  P.hue = k[0];\n  P.a = knobA(cl(k[2], -1, 1));\n  P.A = 0.75 + 0.6 * cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1);\n  // The equation's clock runs A^2 as fast at swell A: the scaling at work.\n  // The envelope travels at the group speed, half the crests' speed in deep\n  // water; the crests run through it once every 2 pi / kap units of the\n  // clock, and one stands on the breather's middle at t = 0.\n  const step = 0.625 * speed * P.A * P.A;\n  let T = halfCycle(P.a);\n  P.kap = (2 * PI * max(1, round((3.6 * T) / PI))) / (2 * T);\n  const cg = (LAM * P.kap * step) / (2 * PI);\n  if (!P.started) {\n    // Fill the record with the 4 units before the opening.\n    P.started = true;\n    for (let i = REC - 1; i >= 0; i--) {\n      envelope(P, P.xu - (cg * i * 0.1) / step, P.t - i * 0.1);\n      pushRow(P);\n    }\n  }\n  P.t += step * d;\n  P.xu += cg * d;\n  while (P.t > T) {\n    P.t -= 2 * T;\n    // Once a breather has risen and gone, the next one rises one to three\n    // crests further on; a whole number of crests, so the sea does not jump.\n    if (P.a \u003c= 0.5 || T === 3.5) P.xu += LAM * floor(1 + 3 * Math.random());\n  }\n  envelope(P, P.xu, P.t);\n  P.acc += step * d;\n  for (; P.acc >= 0.1; P.acc -= 0.1) pushRow(P);\n\n  // Spray off a crest higher than 2.3 times the swell.\n  const sp = speed / 2;\n  for (let x = 0; x \u003c W; x++) {\n    const hgt = P.env[x] * shape(theta(P, x));\n    if (hgt > 2.3 && Math.random() \u003c 6 * sp * (hgt - 2.2) * d * 30 * 0.1) {\n      P.spray.push({ x: x + Math.random(), y: MEAN - VS * P.A * hgt - 1, vx: (Math.random() - 0.3) * 16, vy: -(10 + 16 * Math.random()) * P.A, life: 1 + 0.5 * Math.random() });\n    }\n  }\n  for (const p of P.spray) {\n    p.x += p.vx * d * sp;\n    p.y += p.vy * d * sp;\n    p.vy += 40 * d * sp;\n    p.life -= d * sp;\n  }\n  P.spray = P.spray.filter((p) => p.life > 0 && p.y \u003c MEAN + 6 && p.x >= 0 && p.x \u003c W);\n  if (P.spray.length > 160) P.spray.splice(0, P.spray.length - 160);\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.started) return;\n  const h0 = 0.52 + 0.4 * P.hue;\n  const REC_COL = [null, hsv(h0 + 0.1, 0.8, 0.08), hsv(h0 + 0.06, 0.8, 0.12), hsv(h0, 0.85, 0.17), hsv(h0, 0.85, 0.26),\n    hsv(h0, 0.85, 0.38), hsv(h0, 0.8, 0.54), hsv(h0 - 0.03, 0.55, 0.78), [228, 248, 252]];\n  const FOAM = [236, 248, 252], SURF = hsv(h0, 0.7, 0.86), BODY = hsv(h0 + 0.02, 0.9, 0.52), DEEP = hsv(h0 + 0.05, 0.95, 0.3);\n\n  // The record: newest row at the bottom, scrolling up.\n  for (let r = 0; r \u003c REC; r++) {\n    const o = ((P.head + 1 + r) % REC) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const c = REC_COL[P.rec[o + x]];\n      if (c) display.setPixel(x, r, c[0], c[1], c[2]);\n    }\n  }\n  // The sea under the envelope, foam on the crests, a lit band under the\n  // surface and a darker deep.\n  for (let x = 0; x \u003c W; x++) {\n    const th = theta(P, x), c = (1 + cos(th)) / 2;\n    const e = P.env[x], hgt = VS * P.A * e * shape(th);\n    const ys = round(MEAN - hgt);\n    const foam = c > 0.85 - 0.06 * e ? cl(round((e - 0.6) * 2.5), 1, 6) : 0;\n    const deep = MEAN + 18 + round(3 * shape(th));\n    for (let y = max(0, ys); y \u003c H; y++) {\n      const col = y \u003c ys + foam ? FOAM : y \u003c ys + foam + 3 ? SURF : y \u003c deep ? BODY : DEEP;\n      display.setPixel(x, y, col[0], col[1], col[2]);\n    }\n  }\n  for (const p of P.spray) {\n    const x = floor(p.x), y = floor(p.y);\n    if (y >= 0 && y \u003c H) display.setPixel(x, y, FOAM[0], FOAM[1], FOAM[2]);\n  }\n}\n","slime-drip":"// ===== Patternflow pattern =====\n// Title:   Slime Drip\n// Family:  halloween\n// Idea:    Toxic green ectoplasm oozes from under a purple stone ledge along the top edge, bulges swell and stretch into drips whose necks thin and pinch off, some hanging long on a thread and swaying before they snap, and the drops fall the full height of the panel to splat into a glowing puddle at the bottom that grows and bubbles.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drips=5..12, Viscosity=-1..1\n//\n// Knob 1: Hue. The slime's colour, the stone opposite it on the wheel. At 0 toxic green on purple stone; at 0.3 aqua on dark red, at 0.5 blue, at 0.75 violet on olive and at 1 pink. The warm hues from red to yellow are left out: in the slime's dark edges and its glow they turn brown.\n// Knob 2: Speed. At 2 a drip swells for half a second and stretches for 2 to 2.6 s, a drip on a thread hangs and sways 2.3 to 3.3 s more, and a drop falls from row 10 to the puddle in 1.1 s at up to 130 rows a second; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Drips. How many drips hang from the ledge, 5 to 12, spread along it. At 5 about 0.9 drops fall a second and the puddle rises from 9 rows deep at the start to 18 in a minute; at 12 about 2.1 a second and it rises to 26.\n// Knob 4: Viscosity. How thick the slime is. At -1 it runs: drops 4 to 6 LEDs across let go about 19 rows down, 1.6 a second, and one drip at a time hangs long on a thread. At 0.06 drops 7 or 8 across let go anywhere from row 28 to 96, 0.9 a second, and three drips of five hang on threads at a time, swaying, with lumps of goo sliding down them. At 1 every drip stretches to row 74 to 102 on a thread before it drops 9 or 10 LEDs across, 0.5 a second.\n\nconst W = 64, H = 128, STONE = 4;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Tones: 0 dark, 1 glow, 2 slime edge, 3 slime, 4 slime core, 5 shine,\n// 6 stone, 7 stone lip, 8 deep puddle, 9 bubble, 10 faint glow.\nconst SLIME = 2;\n\nexport function setup(params) {\n  params.s = {\n    begun: false, t: 0, hue: 0, speed: 1, n: 0, visc: 0.53,\n    drips: [], drops: [], bits: [], rips: [], bubs: [], flashes: [],\n    level: 6, bubWait: 0.3,\n    tone: new Uint8Array(W * H), pal: Array.from({ length: 11 }, () => [0, 0, 0]),\n  };\n}\n\n// The underside of the slime coat on the stone, a slow wave.\nconst coat = (S, x) => 7.5 + 1.3 * sin(x * 0.21 + S.t * 0.5) + 0.8 * sin(x * 0.53 - S.t * 0.8);\n\nfunction newCycle(S, d) {\n  const v = S.visc;\n  d.phase = \"swell\";\n  d.pt = 0;\n  d.Rt = 2.2 + 2.2 * v + rnd(0, 0.8);\n  // Drips take turns at hanging long: a drip hangs when fewer than the\n  // share of them are hanging already.\n  let hanging = 0;\n  for (const o of S.drips) if (o !== d && o.long && o.phase !== \"rest\" && o.phase !== \"recoil\") hanging++;\n  d.long = hanging \u003c round(S.n * (0.1 + 0.8 * v)) || Math.random() \u003c 0.1;\n  d.Lp = d.long ? rnd(50, 95) : 10 + 10 * v + rnd(0, 40 * v);\n  d.T = 0.8 + 2.2 * v + rnd(0, 0.6);\n  d.hang = 1.2 + 2 * v + rnd(0, 1);\n  d.amp = d.long ? rnd(0.07, 0.16) : rnd(0.02, 0.06);\n  d.w = rnd(2.2, 3.4);\n  d.ph = rnd(0, 2 * PI);\n  d.Ls = d.L;\n}\n\nfunction build(S, n) {\n  S.n = n;\n  S.drips = [];\n  const slot = W / n;\n  for (let i = 0; i \u003c n; i++) {\n    const d = {\n      x: (i + 0.5) * slot + rnd(-0.15, 0.15) * slot, root: min(slot * 0.36, 3 + 1.5 * S.visc + rnd(0, 1)),\n      L: 2, R: 1.2, neck: 1.5, th: 0, phase: \"rest\", pt: 0, lump: -rnd(0, 20),\n      // Starts spread over a whole cycle, so the drips never fall in step.\n      wait: (((i * 0.618) % 1) + rnd(0, 0.1)) * (1.5 + 5 * S.visc),\n    };\n    S.drips.push(d);\n  }\n}\n\n// The surface of the puddle at column x, in rows from the top.\nfunction surface(S, x) {\n  let y = H - S.level;\n  for (const r of S.rips) {\n    const dx = abs(x - r.x), front = 16 * r.age + 2;\n    if (dx > front) continue;\n    y -= r.a * exp(-r.age * 1.8 - dx / 22) * cos(0.7 * dx - 10 * r.age);\n  }\n  return y;\n}\n\nfunction splat(S, x, y, R, vy) {\n  S.level += (PI * R * R) / W;\n  S.rips.push({ x, age: 0, a: 0.5 + 0.35 * R });\n  S.flashes.push({ x, y, age: 0, r: R });\n  const n = 3 + round(R * 1.6);\n  for (let i = 0; i \u003c n; i++)\n    S.bits.push({ x, y: y - 1, vx: rnd(-1, 1) * (18 + 8 * R), vy: -rnd(25, 45 + 0.1 * vy) * sqrt(R / 3), big: Math.random() \u003c 0.35 });\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  const g = 260;\n  for (const d of S.drips) {\n    d.pt += dt;\n    // Lumps of goo slide down a long drip into its bulb.\n    d.lump += 16 * dt;\n    if (d.lump > d.L) d.lump = -rnd(4, 16);\n    if (d.phase === \"rest\") {\n      if (d.pt > d.wait) newCycle(S, d);\n    } else if (d.phase === \"swell\") {\n      const u = cl(d.pt / 0.5, 0, 1);\n      d.R = 1.2 + (d.Rt * 0.7 - 1.2) * u;\n      d.L = d.Ls + (d.R + 1 - d.Ls) * u;\n      d.neck = d.root * (0.9 - 0.3 * u);\n      if (u >= 1) (d.phase = \"stretch\"), (d.pt = 0), (d.Ls = d.L), (d.n0 = d.neck);\n    } else if (d.phase === \"stretch\") {\n      // The bulb grows and sinks faster as it fills; the neck above it thins.\n      const u = cl(d.pt / d.T, 0, 1);\n      d.R = d.Rt * (0.7 + 0.3 * u);\n      d.L = d.Ls + (d.Lp - d.Ls) * u * u * (1.5 - 0.5 * u);\n      // A drip that will hang keeps a thread 2 LEDs wide; the others thin to one.\n      const thin = d.long ? 1 : 0.5;\n      d.neck = thin + (d.n0 - thin) * (1 - u) ** 1.4;\n      if (u >= 1) {\n        if (d.long) (d.phase = \"hang\"), (d.pt = 0), (d.L0 = d.L);\n        else pinch(S, d);\n      }\n    } else if (d.phase === \"hang\") {\n      // On a thread: the bulb sways like a pendulum and creeps lower.\n      d.L = d.L0 + 8 * (d.pt / d.hang) + 1.5 * sin(d.pt * 7);\n      if (d.pt > d.hang) pinch(S, d);\n    } else if (d.phase === \"recoil\") {\n      // What is left above the pinch snaps back up and wobbles.\n      const u = d.pt;\n      d.L = d.stub + (d.Lr - d.stub) * exp(-u * 11) + 1.2 * sin(u * 26) * exp(-u * 5);\n      d.R = 1.3;\n      d.neck = d.root * 0.6 * (1 - exp(-u * 4)) + 0.5;\n      if (u > 0.6) (d.phase = \"rest\"), (d.pt = 0), (d.wait = rnd(0.1, 0.7));\n    }\n    // Sway: the angle of the bulb under the root.\n    if (d.phase === \"recoil\") d.th = d.th0 * exp(-d.pt * 5);\n    else d.th = (d.phase === \"hang\" ? d.amp * min(1, d.pt / 0.6) : d.amp * 0.4) * sin(d.pt * d.w + d.ph);\n  }\n  // Drops fall, with air holding them under 130 rows a second.\n  for (const p of S.drops) {\n    p.vy += (g - 0.0154 * p.vy * p.vy) * dt;\n    p.y += p.vy * dt;\n    p.x += p.vx * dt;\n    p.vx *= exp(-dt * 1.5);\n    if (p.x \u003c p.R) (p.x = p.R), (p.vx = abs(p.vx));\n    if (p.x > W - p.R) (p.x = W - p.R), (p.vx = -abs(p.vx));\n    if (p.y + p.R >= surface(S, p.x)) (p.dead = true), splat(S, p.x, surface(S, p.x), p.R, p.vy);\n  }\n  S.drops = S.drops.filter((p) => !p.dead);\n  for (const b of S.bits) {\n    b.vy += g * dt;\n    b.x += b.vx * dt;\n    b.y += b.vy * dt;\n    if (b.vy > 0 && b.y >= surface(S, b.x)) b.dead = true;\n    if (b.x \u003c 0 || b.x >= W) b.dead = true;\n  }\n  S.bits = S.bits.filter((b) => !b.dead);\n  for (const r of S.rips) r.age += dt;\n  S.rips = S.rips.filter((r) => r.age \u003c 2.5);\n  for (const f of S.flashes) f.age += dt;\n  S.flashes = S.flashes.filter((f) => f.age \u003c 0.2);\n  // The puddle drains slowly toward 6 rows.\n  S.level -= (S.level - 6) * 0.06 * dt;\n  S.level = min(S.level, 26);\n  // Bubbles rise through the puddle, swell into a dome and pop.\n  S.bubWait -= dt;\n  if (S.bubWait \u003c= 0) {\n    S.bubWait = rnd(0.15, 0.6);\n    S.bubs.push({ x: rnd(3, W - 3), y: H - 1, r: rnd(1, 1.6), vy: rnd(5, 10), dome: -1 });\n  }\n  for (const b of S.bubs) {\n    const top = surface(S, b.x);\n    if (b.dome \u003c 0) {\n      b.y -= b.vy * dt;\n      b.r = min(b.r + dt * 1.2, 3);\n      if (b.y - b.r \u003c= top) b.dome = 0;\n    } else {\n      b.dome += dt;\n      b.y = top;\n      if (b.dome > 0.45) {\n        b.dead = true;\n        S.flashes.push({ x: b.x, y: top - b.r, age: 0, r: b.r * 0.7 });\n        for (let i = 0; i \u003c 2; i++) S.bits.push({ x: b.x, y: top - b.r, vx: rnd(-14, 14), vy: rnd(-40, -20), big: false });\n      }\n    }\n  }\n  S.bubs = S.bubs.filter((b) => !b.dead);\n}\n\nfunction pinch(S, d) {\n  const X = d.L * sin(d.th), y = coat(S, d.x) + d.L;\n  const swing = d.L * d.amp * d.w * cos(d.pt * d.w + d.ph);\n  S.drops.push({ x: d.x + X, y, vx: d.phase === \"hang\" ? swing : 0, vy: 15, R: d.R });\n  // Now and then a small satellite drop from the neck.\n  if (Math.random() \u003c 0.5) S.drops.push({ x: d.x + X * 0.85, y: y - d.R - 2, vx: 0, vy: 5, R: 1 });\n  d.phase = \"recoil\";\n  d.pt = 0;\n  d.th0 = d.th;\n  d.Lr = max(3, d.L - d.R * 1.6);\n  d.stub = rnd(3, 8);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3) / 2;\n  S.visc = (cl(k[3], -1, 1) + 1) / 2;\n  const n = cl(round(k[2]), 5, 12);\n  if (n !== S.n) build(S, n);\n  if (!S.begun) {\n    // The first frame is a drip already running: 8 s of it, run at once.\n    S.begun = true;\n    for (let i = 0; i \u003c 240; i++) step(S, 1 / 30);\n  }\n  step(S, cl(dt || 0, 0, 0.1) * S.speed);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const { tone, pal } = S;\n  tone.fill(0);\n  const put = (x, y, v) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = y * W + x;\n    if (v > tone[o] || tone[o] >= 8 || tone[o] === 1) tone[o] = v;\n  };\n  // A horizontal run of slime at row y between xa and xb, lit from the left.\n  const span = (y, xc, h) => {\n    const a = floor(xc - h + 0.5), b = max(a, floor(xc + h - 0.5));\n    for (let x = a; x \u003c= b; x++) {\n      const u = h \u003c 1.2 ? 0 : (x + 0.5 - xc) / h;\n      put(x, y, u > 0.7 || u \u003c -0.85 ? 2 : u > -0.6 && u \u003c -0.15 ? 4 : 3);\n    }\n  };\n  // The stone ledge and its slime coat.\n  for (let x = 0; x \u003c W; x++) {\n    for (let y = 0; y \u003c STONE; y++) put(x, y, y === STONE - 1 || ((x * 7 + y * 13) % 11 === 0 && y > 0) ? 7 : 6);\n    const c = round(coat(S, x));\n    for (let y = STONE; y \u003c c; y++) put(x, y, y === STONE ? 4 : y === c - 1 ? 2 : 3);\n  }\n  // Drips: a root that tapers into the neck, and the bulb under it.\n  for (const d of S.drips) {\n    const y0 = coat(S, d.x) - 1, X = d.L * sin(d.th), k = 3 + 0.12 * d.L;\n    const yb = y0 + d.L * cos(d.th), R = d.R, ry = R * 1.12;\n    for (let y = floor(y0); y \u003c= min(H - 1, ceil(yb + ry)); y++) {\n      const dd = y + 0.5 - y0;\n      if (dd \u003c= d.L) {\n        const f = dd / max(1, d.L);\n        const lump = d.L > 18 && (d.phase === \"stretch\" || d.phase === \"hang\") ? 1.1 * exp(-(((dd - d.lump) / 2.5) ** 2)) : 0;\n        span(y, d.x + X * f * f, d.neck + (d.root - d.neck) * exp(-dd / k) + lump);\n      }\n      const dy = (y + 0.5 - yb) / ry;\n      if (abs(dy) \u003c 1) span(y, d.x + X, R * sqrt(1 - dy * dy));\n    }\n    if (R > 2) put(d.x + X - R * 0.45, yb - ry * 0.45, 5);\n  }\n  // Falling drops: round below, drawn out to a point above as they speed up.\n  for (const p of S.drops) {\n    const s = 1 + p.vy / 260, rx = p.R / sqrt(s), ry = p.R * s;\n    for (let y = floor(p.y - ry * 1.7); y \u003c= p.y + ry; y++) {\n      const dy = (y + 0.5 - p.y) / ry;\n      const h = dy >= 0 ? rx * sqrt(max(0, 1 - dy * dy)) : rx * max(0, 1 + dy / 1.7) ** 1.4;\n      if (h > 0.3) span(y, p.x, max(0.5, h));\n    }\n    if (p.R > 1.5) put(p.x - rx * 0.4, p.y - ry * 0.35, 5);\n  }\n  // The puddle: a bright skin, slime under it and deep slime below.\n  for (let x = 0; x \u003c W; x++) {\n    const top = round(surface(S, x));\n    for (let y = max(0, top); y \u003c H; y++) put(x, y, y === top ? 4 : y \u003c top + 4 ? 3 : 8);\n  }\n  for (const b of S.bubs) {\n    if (b.dome \u003c 0) {\n      // A rising bubble: a bright ring in the deep slime.\n      const r = b.r;\n      for (let a = 0; a \u003c 12; a++) put(b.x + r * cos((a * PI) / 6), b.y + r * sin((a * PI) / 6), 9);\n    } else {\n      const r = b.r * min(1, b.dome / 0.2 + 0.3);\n      for (let y = floor(b.y - r); y \u003c= b.y; y++) {\n        const dy = (y + 0.5 - b.y) / r;\n        if (abs(dy) \u003c 1) span(y, b.x, r * sqrt(1 - dy * dy));\n      }\n      put(b.x - r * 0.4, b.y - r * 0.6, 5);\n    }\n  }\n  for (const b of S.bits) {\n    put(b.x, b.y, 3);\n    if (b.big) put(b.x + 1, b.y, 3), put(b.x, b.y - 1, 4);\n  }\n  for (const f of S.flashes) {\n    const r = f.r + f.age * 40;\n    for (let a = 0; a \u003c 16; a++) put(f.x + r * cos((a * PI) / 8), f.y - abs(r * 0.6 * sin((a * PI) / 8)), 5);\n  }\n  // Glow: one LED of light round every bit of slime.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      if (tone[o]) continue;\n      let lit = false;\n      for (let j = max(0, y - 1); j \u003c= min(H - 1, y + 1) && !lit; j++)\n        for (let i = max(0, x - 1); i \u003c= min(W - 1, x + 1); i++) {\n          const v = tone[j * W + i];\n          if (v >= SLIME && v \u003c= 5) {\n            lit = true;\n            break;\n          }\n        }\n      if (lit) tone[o] = 1;\n    }\n  // And a fainter LED round that.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      if (tone[o]) continue;\n      if ((x > 0 && tone[o - 1] === 1) || (x \u003c W - 1 && tone[o + 1] === 1) || (y > 0 && tone[o - W] === 1) || (y \u003c H - 1 && tone[o + W] === 1)) tone[o] = 10;\n    }\n  const h = 0.31 + 0.62 * S.hue;\n  hsv(h, 1, 0.26, pal[1]);\n  hsv(h, 1, 0.13, pal[10]);\n  hsv(h + 0.01, 1, 0.55, pal[2]);\n  hsv(h, 0.92, 0.86, pal[3]);\n  hsv(h - 0.04, 0.6, 1, pal[4]);\n  hsv(h - 0.04, 0.16, 1, pal[5]);\n  hsv(h + 0.47, 0.6, 0.3, pal[6]);\n  hsv(h + 0.47, 0.5, 0.46, pal[7]);\n  hsv(h + 0.02, 1, 0.42, pal[8]);\n  hsv(h + 0.47, 0.45, 0.9, pal[9]);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const t = tone[o];\n      if (!t) continue;\n      const c = pal[t];\n      display.setPixel(x, y, round(c[0] * 255), round(c[1] * 255), round(c[2] * 255));\n    }\n}\n","bone-jig":"// ===== Patternflow pattern =====\n// Title:   Bone Jig\n// Family:  halloween\n// Idea:    A skeleton the height of the panel dances on a black floor lit from below by a toxic green pool, its jaw clacking on the beat, going through a hopping jig, side kicks, swinging arms, a hip shake, a spin and a rattling shiver, every bone a knobbed capsule rimmed with the glow.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the jointed dancing skeletons of Halloween decorations and the danse macabre\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Glow=0..1, Speed=0.2..3, Dancers=1..3, Trails=0..1\n//\n// Knob 1: Glow. Three lights round the knob: at 0 a toxic green pool with a violet rim, at 0.33 an orange one with violet, at 0.67 a violet one with green. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again. The bones stay near white, 12 percent of the light in them; the light takes their lower edges, the embers in the eye sockets and the pool, and the faint haze round them fades through the rim colour, so a dim orange never reads brown.\n// Knob 2: Speed. The tempo: 2 is 96 beats a minute, and the six moves take 8, 8, 8, 8, 4 and 4 beats, 25 seconds in all. At 0.2 the round takes 250 seconds, at 3 about 17.\n// Knob 3: Dancers, 1 to 3. At 2 a second skeleton 0.6 the size dances on the right, standing 10 rows further back on the floor and dimmer, a quarter beat behind the first; at 3 a third on the left dances the same moves mirrored. Both stand behind the first.\n// Knob 4: Trails. Afterimages behind every moving bone, in the light's colour where they are strong and the rim colour where they fade. Up to 0.1 almost none; at 1 a swinging leg leaves a fan of them that fades by half in 0.28 seconds.\n// Buttons: K1 tap pops the skull off: it flies up out of the top of the panel with its jaw chattering, spins twice and drops back onto the neck 1.4 seconds later while the body dances on with its arms up.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sstep = (t) => {\n  t = cl(t, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Bone lengths in LEDs for the first dancer before its scale.\nconst FEMUR = 22, TIBIA = 21, HUMERUS = 16, ULNA = 14, SPINE = 29, NECK = 5, SKULL = 8.6;\nconst HIP_X = 6, HIP_Y = 3, SHOULDER_X = 11;\n// Ribs: half width, droop toward the breastbone, for four pairs.\nconst RIBS = [[8.2, 3.2], [9.8, 3.8], [10.2, 4.2], [9.2, 4]];\n// Floor row for the first dancer and for the two behind it.\nconst FLOOR = 122, FLOOR_BACK = 112;\n// Lights round K1: the glow (pool, bone rims, eye embers) and the rim\n// colour round the pool, on the floor line and in faint haze.\nconst PAL = [\n  [[0.42, 1, 0.12], [0.55, 0.18, 0.95]],\n  [[1, 0.5, 0.06], [0.6, 0.2, 1]],\n  [[0.72, 0.32, 1], [0.3, 0.95, 0.25]],\n];\nconst BONE = [1, 0.95, 0.84];\n\n// A pose is 25 numbers: root shift x and hop y, turn about the vertical,\n// torso lean, pelvis tilt, spine bend, head tilt, jaw, shoulder shimmy,\n// then for the screen-left and screen-right arm and leg the upper bone's\n// angle out from straight down and its pitch toward the viewer, and the\n// same for the lower bone.\nconst PX = 0, PY = 1, SPIN = 2, LEAN = 3, TILT = 4, CURVE = 5, HEAD = 6, JAW = 7, SHIM = 8, ARM = 9, LEG = 17, NP = 25;\nconst limb = (o, at, s, a1, p1, a2, p2) => {\n  const k = at + 4 * s;\n  (o[k] = a1), (o[k + 1] = p1), (o[k + 2] = a2), (o[k + 3] = p2);\n};\nconst clack = (b) => max(0, sin(TAU * b)) ** 2;\n\n// The moves, each a function of the beat b since it started.\nfunction jig(b, o) {\n  // Hop on alternate feet: four beats of knees up, four of the foot\n  // flicked out to the side; the arms flap out a little on each hop.\n  const f = b - floor(b), side = floor(b) & 1, lift = sin(PI * f) ** 1.3, flick = sstep(b - 3.6);\n  o[PX] = 1.6 * sin(PI * b);\n  o[PY] = -3.5 * lift;\n  o[SPIN] = 0.2 * sin((PI * b) / 2);\n  o[LEAN] = 0.05 * sin(PI * b);\n  o[TILT] = (side ? -0.1 : 0.1) * lift;\n  o[HEAD] = 0.12 * sin(PI * b);\n  o[JAW] = clack(b);\n  for (const s of [0, 1]) limb(o, ARM, s, 0.14 + 0.3 * lift, 0.1, 0.1 + 0.5 * lift, 0);\n  limb(o, LEG, side, mix(0.1, 0.3, flick) * lift, mix(1.3, 0.5, flick) * lift, mix(-0.1, 1.1, flick) * lift, mix(-0.15, 0.2, flick) * lift);\n  limb(o, LEG, 1 - side, 0.03, 0, 0.02, 0);\n}\n\nfunction kicks(b, o) {\n  // Kick out to alternate sides, leaning away; hands on hips for four\n  // beats, then fists pumping overhead.\n  const f = b - floor(b), side = floor(b) & 1, sg = side ? 1 : -1, k = sin(PI * f) ** 0.8, up = sstep(b - 3.6);\n  o[PX] = -sg * 3.5 * k;\n  o[PY] = -1 * k;\n  o[SPIN] = sg * 0.15 * k;\n  o[LEAN] = -sg * 0.14 * k;\n  o[TILT] = -sg * 0.1 * k;\n  o[HEAD] = sg * 0.12 * k;\n  o[JAW] = clack(b);\n  for (const s of [0, 1]) limb(o, ARM, s, mix(0.8, 2.45 + 0.2 * k, up), mix(0.15, 0, up), mix(-0.85, 3.1 - 0.35 * k, up), mix(0.35, 0, up));\n  limb(o, LEG, side, 0.65 * k, 0.3 * k, 0.9 * k, 0.15 * k);\n  limb(o, LEG, 1 - side, -0.05 * k, 0, -0.03 * k, 0);\n}\n\nfunction windmill(b, o) {\n  // Arms swing over and down in turn, forearms bent up so the hands stay\n  // on the panel; the knees twist in and out, Charleston fashion.\n  const th = (PI * b) / 2, tw = sin(PI * b);\n  for (const s of [0, 1]) {\n    const c = cos(th + s * PI), a1 = 1.45 - 1.25 * c;\n    limb(o, ARM, s, a1, 0.25 * sin(th + s * PI), a1 + 1.6, 0);\n    limb(o, LEG, s, 0.06 + 0.12 * tw, 0.1, 0.04 - 0.28 * tw, 0);\n  }\n  o[SPIN] = 0.3 * sin(th);\n  o[LEAN] = 0.08 * sin(th);\n  o[HEAD] = -0.1 * sin(th);\n  o[JAW] = clack(b);\n}\n\nfunction hips(b, o) {\n  // Hips out to one side each beat, chest held over the feet, the other\n  // knee bent; arms up in a Y with the hands waving.\n  const sw = sin(PI * b);\n  o[PX] = 5.5 * sw;\n  o[TILT] = -0.25 * sw;\n  o[LEAN] = -0.2 * sw;\n  o[CURVE] = 0.5 * sw;\n  o[HEAD] = 0.1 * sw;\n  o[JAW] = clack(2 * b);\n  for (const s of [0, 1]) {\n    const sg = s ? 1 : -1, bend = max(0, -sg * sw);\n    limb(o, ARM, s, 2.55 - 0.12 * sg * sw, 0.1, 3.0 + 0.35 * sin(TAU * b + s * PI), 0);\n    limb(o, LEG, s, 0.04 + 0.02 * (1 - bend), 0.5 * bend, 0.04 - 0.14 * bend, -0.3 * bend);\n  }\n}\n\nfunction spin(b, o) {\n  // One whole turn on one foot, the other drawn up to the knee.\n  const e = sstep(b / 3.2);\n  o[SPIN] = TAU * e;\n  o[PY] = -2.5 * sin(PI * min(1, b / 3.2));\n  o[JAW] = 0.7;\n  for (const s of [0, 1]) limb(o, ARM, s, 1.2, 0.25, 2.5, 0);\n  limb(o, LEG, 1, 0.35, 1.0, -0.55, 0.2);\n  limb(o, LEG, 0, 0.02, 0, 0.02, 0);\n}\n\nfunction rattle(b, o) {\n  // A crouched shiver: shoulders shaking four times a beat, knees\n  // knocking, teeth chattering.\n  const q = sin(8 * PI * b);\n  o[SHIM] = 1.6 * q;\n  o[JAW] = 0.5 + 0.5 * sin(16 * PI * b);\n  o[HEAD] = 0.12 * sin(4 * PI * b);\n  for (const s of [0, 1]) {\n    limb(o, ARM, s, 0.95, 0.35, -1.25 + 0.3 * q, 0.5);\n    limb(o, LEG, s, 0.22 + 0.1 * q, 0.45, -0.2 - 0.1 * q, -0.45);\n  }\n}\n\nconst MOVES = [[jig, 8], [kicks, 8], [windmill, 8], [hips, 8], [spin, 4], [rattle, 4]];\nconst ROUND = MOVES.reduce((a, m) => a + m[1], 0);\n// The last BLEND of a beat of each move eases into the next one's start.\nconst BLEND = 0.6;\n\nfunction pose(B, out, tmp) {\n  let b = B - floor(B / ROUND) * ROUND, m = 0;\n  while (b >= MOVES[m][1]) (b -= MOVES[m][1]), m++;\n  out.fill(0);\n  MOVES[m][0](b, out);\n  out[SPIN] -= TAU * round(out[SPIN] / TAU);\n  const w = sstep((b - (MOVES[m][1] - BLEND)) / BLEND);\n  if (w > 0) {\n    tmp.fill(0);\n    MOVES[(m + 1) % MOVES.length][0](0, tmp);\n    for (let i = 0; i \u003c NP; i++) out[i] = mix(out[i], tmp[i], w);\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, count: 1, trail: 0.06, beat: 0, dt: 0,\n    // Skull flight after a K1 tap: seconds since, or -1.\n    fly: -1,\n    pose: new Float64Array(NP), tmp: new Float64Array(NP),\n    rgb: new Float32Array(N * 3), a: new Float32Array(N), halo: new Float32Array(N), blur: new Float32Array(N), ghost: new Float32Array(N),\n    prims: [],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 1, 3);\n  S.trail = cl(k[3], 0, 1);\n  S.beat += d * S.speed * 0.8;\n  S.dt = d;\n  if (input.btnPressed && input.btnPressed[0] && S.fly \u003c 0) S.fly = 0;\n  if (S.fly >= 0) {\n    S.fly += d;\n    if (S.fly > 1.75) S.fly = -1;\n  }\n}\n\n// --- the body ---\n\n// A unit vector for a bone on side sg (-1 screen left, 1 right): angle a\n// out from straight down, pitch p toward the viewer (negative z).\nfunction dir(sg, a, p) {\n  const cp = cos(p);\n  return [sg * sin(a) * cp, cos(a) * cp, -sin(p)];\n}\nconst rot = (v, a) => [v[0] * cos(a) - v[1] * sin(a), v[0] * sin(a) + v[1] * cos(a), v[2]];\nconst add = (a, b, k = 1) => [a[0] + k * b[0], a[1] + k * b[1], a[2] + k * b[2]];\n\n// Build one dancer as primitives on the panel. kind 0 a plain capsule,\n// 1 a long bone with knobbed ends, 2 a disc, 3 the skull.\nfunction build(S, P, cx, floorY, sc, mirror, dim, flyY, flySpin, armsUp, back) {\n  const out = S.prims, lean = P[LEAN], tilt = P[TILT], sh = P[SHIM];\n  const segs = [];\n  const seg = (a, b, r, kind) => segs.push([a, b, r, kind]);\n  // Pelvis: two wings, the arch in front and the sacrum behind.\n  const pel = (x, y, z) => rot([x, y, z], tilt);\n  for (const sg of [-1, 1]) {\n    const pts = [[1.5, -4, 1.5], [8, -7, 1], [10.5, -3, 0.5], [8, 1.5, -0.5], [HIP_X, HIP_Y, 0], [3, 6, -2], [0, 6.5, -2.5]].map(([x, y, z]) => pel(sg * x, y, z));\n    for (let i = 0; i + 1 \u003c pts.length; i++) seg(pts[i], pts[i + 1], 1.15, 0);\n  }\n  const base = pel(0, -5, 2);\n  seg(base, pel(0, 2, 2.5), 1.5, 0);\n  // Spine, bent sideways by CURVE and leant by LEAN; the vertebrae are\n  // beads along it.\n  const torso = (v) => add(base, rot(v, lean));\n  let prev = base;\n  for (let i = 1; i \u003c= 8; i++) {\n    const u = i / 8, q = torso([P[CURVE] * 6 * sin(PI * u), -SPINE * u, 1.5 + 2 * sin(PI * u)]);\n    seg(prev, q, 0.7, 0);\n    segs.push([q, q, 1.35, 2]);\n    prev = q;\n  }\n  const neck = prev, chest = (x, y, z) => add(neck, rot([x, y, z], lean));\n  // Ribs: half ellipses round from the spine to the breastbone, dipping\n  // toward the front, and the breastbone down the middle.\n  RIBS.forEach(([w, droop], k) => {\n    for (const sg of [-1, 1]) {\n      let p0 = null;\n      for (let j = 0; j \u003c= 6; j++) {\n        const th = 0.25 + ((PI - 0.6) * j) / 6;\n        const p = chest(sg * w * sin(th) + 0.5 * sh, 4 + 5.2 * k + (droop * (1 - cos(th))) / 2, 0.75 * w * cos(th));\n        if (p0) seg(p0, p, 0.75, 0);\n        p0 = p;\n      }\n    }\n  });\n  seg(chest(0.5 * sh, 4 + RIBS[0][1], -6), chest(0.5 * sh, 4 + 5.2 * 3 + RIBS[3][1], -7), 1, 0);\n  // Shoulders, collarbones and arms.\n  for (const s of [0, 1]) {\n    const sg = s ? 1 : -1, o = ARM + 4 * s, w = armsUp;\n    const sho = chest(sg * SHOULDER_X + sh, 3, 0);\n    seg(chest(0, 1, -2), sho, 0.9, 0);\n    // Arms thrown up for the flying skull swing up through the front, so a\n    // straight arm never sweeps out past the panel's sides.\n    const a1 = mix(P[o], 2.7, w), p1 = mix(P[o + 1], 0, w) + 1.3 * sin(PI * w), a2 = mix(P[o + 2], 3.0, w), p2 = mix(P[o + 3], 0, w) + 1.1 * sin(PI * w);\n    const elb = add(sho, rot(dir(sg, a1, p1), lean), HUMERUS), d2 = rot(dir(sg, a2, p2), lean), wri = add(elb, d2, ULNA);\n    seg(sho, elb, 1.05, 1);\n    seg(elb, wri, 0.95, 1);\n    // A bony hand: palm knob and three fingers fanned along the forearm.\n    segs.push([add(wri, d2, 1.2), add(wri, d2, 1.2), 1.5, 2]);\n    for (const f of [-0.45, 0, 0.45]) {\n      const fd = rot(d2, f * sg);\n      seg(add(wri, d2, 1.5), add(wri, fd, 5), 0.55, 0);\n    }\n  }\n  // Legs and feet.\n  let low = -1e9;\n  const legs = [];\n  for (const s of [0, 1]) {\n    const sg = s ? 1 : -1, o = LEG + 4 * s;\n    const hip = pel(sg * HIP_X, HIP_Y, 0);\n    const kne = add(hip, dir(sg, P[o], P[o + 1]), FEMUR), ank = add(kne, dir(sg, P[o + 2], P[o + 3]), TIBIA);\n    const fd = [sg * 0.45, 0.3, -0.84], toe = add(ank, fd, 5);\n    legs.push([hip, kne, ank, toe]);\n    low = max(low, ank[1] + 1.5, toe[1] + 1);\n  }\n  for (const [hip, kne, ank, toe] of legs) {\n    segs.push([hip, hip, 2, 2]);\n    seg(hip, kne, 1.2, 1);\n    seg(kne, ank, 1.1, 1);\n    seg(ank, toe, 1.1, 0);\n  }\n  // Neck and skull.\n  const nt = add(neck, rot(rot([0, -NECK, 0], P[HEAD] * 0.5), lean));\n  seg(neck, nt, 1.1, 0);\n  segs.push([nt, nt, 1.3, 2]);\n  const sk = add(nt, rot(rot([0, -SKULL * 0.95, 0], P[HEAD]), lean));\n  // Turn about the vertical through the root, mirror, scale and place\n  // with the lowest foot on the floor.\n  const sp = P[SPIN], cs = cos(sp), sn = sin(sp), m = mirror ? -1 : 1;\n  const ry = floorY - low * sc + P[PY] * sc, rx = cx + m * P[PX] * sc;\n  const proj = (v) => {\n    const x = (v[0] * cs + v[2] * sn) * m, z = -v[0] * sn + v[2] * cs;\n    return [rx + x * sc, ry + v[1] * sc, z];\n  };\n  for (const [a, b, r, kind] of segs) {\n    const A = proj(a), B = proj(b);\n    out.push({ kind, x0: A[0], y0: A[1], x1: B[0], y1: B[1], z: (A[2] + B[2]) / 2 + back, r: r * sc, dim });\n  }\n  const C = proj(sk);\n  out.push({ kind: 3, x0: C[0], y0: C[1] + flyY * sc, z: C[2] - 1 + back, r: SKULL * sc, dim, yaw: m * (sp + flySpin), roll: m * (P[HEAD] + lean), jaw: P[JAW] });\n}\n\n// --- drawing ---\n\nfunction shade(S, ny, y, dim, out, edge = 1) {\n  // Lit from below: the lower edge takes the glow, more so near the floor;\n  // the upper edge is a little darker.\n  const g = S.glow, rim = max(0, ny) * edge, low = cl((y - 40) / 85, 0, 1);\n  const t = cl(0.05 + 0.75 * rim ** 3 + 0.2 * low, 0, 0.85), lum = (0.86 + 0.14 * rim + 0.22 * min(0, ny)) * dim;\n  // Bone white, a little of the light's colour in it everywhere.\n  for (let c = 0; c \u003c 3; c++) out[c] = mix(mix(BONE[c], g[c], 0.12) * lum, g[c] * dim, t);\n}\n\nconst COL = [0, 0, 0];\n\nfunction capsule(S, p) {\n  const { rgb, a } = S, r = p.r, knob = p.kind === 1, x0 = p.x0, y0 = p.y0, x1 = p.x1, y1 = p.y1;\n  const dx = x1 - x0, dy = y1 - y0, ll = dx * dx + dy * dy, len = sqrt(ll) || 1;\n  const nx = -dy / len, ny = dx / len, lo = 0.7 * r, lr = 0.78 * r + 0.15, ux = dx / len, uy = dy / len;\n  const pad = r + 2.6;\n  const xa = max(0, floor(min(x0, x1) - pad)), xb = min(W - 1, floor(max(x0, x1) + pad));\n  const ya = max(0, floor(min(y0, y1) - pad)), yb = min(H - 1, floor(max(y0, y1) + pad));\n  // Knobs: two lobes at each end, set a little in from the joint.\n  const L = knob ? [[x0 + ux * 0.4 * r + nx * lo, y0 + uy * 0.4 * r + ny * lo], [x0 + ux * 0.4 * r - nx * lo, y0 + uy * 0.4 * r - ny * lo], [x1 - ux * 0.4 * r + nx * lo, y1 - uy * 0.4 * r + ny * lo], [x1 - ux * 0.4 * r - nx * lo, y1 - uy * 0.4 * r - ny * lo]] : [];\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const u = ll > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / ll, 0, 1) : 0;\n      let cx = x0 + u * dx, cy = y0 + u * dy, dd = sqrt((px - cx) ** 2 + (py - cy) ** 2) - r;\n      for (let k = 0; k \u003c L.length; k++) {\n        const lx = L[k][0], ly = L[k][1], e = sqrt((px - lx) ** 2 + (py - ly) ** 2) - lr;\n        if (e \u003c dd) (dd = e), (cx = lx), (cy = ly);\n      }\n      const o = y * W + x;\n      // A dark line round each bone where it passes in front of another.\n      if (dd > 0.5) {\n        if (dd \u003c 1.3) for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] *= 0.35;\n        continue;\n      }\n      const cov = cl(0.5 - dd, 0, 1), dl = sqrt((px - cx) ** 2 + (py - cy) ** 2) || 1;\n      shade(S, (py - cy) / dl, py, p.dim, COL);\n      for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] = mix(rgb[o * 3 + c], COL[c], cov);\n      if (cov > a[o]) a[o] = cov;\n    }\n}\n\nfunction skull(S, p) {\n  const { rgb, a } = S, r = p.r, cx = p.x0, cy = p.y0, yaw = p.yaw, cr = cos(p.roll), sr = sin(p.roll);\n  const vn = cos(yaw), sn = sin(yaw), rx = r * (0.92 + 0.14 * abs(sn)), ry = r, rm = min(rx, ry);\n  // The jaw hangs below the cranium and drops as it opens; seen from the\n  // side it juts forward.\n  const jo = cl(p.jaw, 0, 1), fwd = sn * r * 0.35;\n  const jx = fwd, jy = 0.74 * r + 0.3 * r * jo, jrx = 0.58 * r * (0.62 + 0.38 * abs(vn)), jry = 0.37 * r;\n  // Mouth with a row of teeth along each lip, the nose, and the two eye\n  // sockets, each turned with the head and faded as it turns away.\n  const mouthY = 0.8 * r + 0.15 * r * jo, mh = 0.05 * r + 0.18 * r * jo, mw = 0.42 * r * (0.55 + 0.45 * abs(vn)), mx = fwd * 0.7;\n  const nx = sn * rx * 0.95, ny = 0.42 * r, nw = 0.13 * r * vn + 0.35;\n  const eyes = [-0.48, 0.48].map((f) => {\n    const vis = cos(f + yaw);\n    return [vis, sin(f + yaw) * rx * 0.82, 0.04 * r, 0.3 * r * (0.35 + 0.65 * vis), 0.3 * r];\n  }).filter((e) => e[0] >= 0.12);\n  const ex = S.ember, glow = S.glow, dim = p.dim;\n  const pad = r * 1.3 + 4;\n  for (let y = max(0, floor(cy - pad)); y \u003c= min(H - 1, floor(cy + pad + r)); y++)\n    for (let x = max(0, floor(cx - pad)); x \u003c= min(W - 1, floor(cx + pad)); x++) {\n      // Into the skull's own frame, rolled with the head.\n      const qx = x + 0.5 - cx, qy = y + 0.5 - cy, X = qx * cr + qy * sr, Y = -qx * sr + qy * cr;\n      const dc = sqrt((X / rx) ** 2 + (Y / ry) ** 2), dj = sqrt(((X - jx) / jrx) ** 2 + ((Y - jy) / jry) ** 2);\n      const ec = (1 - dc) * rm, ej = (1 - dj) * jry;\n      const e = max(ec, ej), o = y * W + x;\n      if (e \u003c -0.5) {\n        if (e > -1.3) for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] *= 0.35;\n        continue;\n      }\n      const cov = cl(e + 0.5, 0, 1), onC = ec >= ej;\n      const nyv = onC ? Y / ry / max(dc, 1e-3) : (Y - jy) / jry / max(dj, 1e-3);\n      shade(S, cl(nyv, -1, 1), y + 0.5, dim, COL, sstep(((onC ? dc : dj) - 0.6) / 0.4));\n      let dark = 0, ember = 0;\n      if (vn > 0.2 && ec \u003c ej + 0.6 && abs(Y - mouthY) \u003c mh + 0.5 && abs(X - mx) \u003c mw) {\n        const tooth = (X - mx) / (0.21 * r) + 10.25, gap = tooth - floor(tooth) \u003c 0.3;\n        dark = abs(Y - mouthY) > mh - 1 && !gap ? 0 : 1;\n      }\n      for (const [vis, fx, fy, ew, eh] of eyes) {\n        const de = ((X - fx) / ew) ** 2 + ((Y - fy) / eh) ** 2;\n        if (de \u003c 1) {\n          dark = 1;\n          if (de \u003c 0.16) ember = max(ember, vis * (1 - de / 0.16));\n        }\n      }\n      // The nose: a small triangle pointing down.\n      if (vn > 0.15 && Y > ny && Y \u003c ny + 0.22 * r && abs(X - nx) \u003c nw * (1 - (Y - ny) / (0.26 * r))) dark = 1;\n      for (let c = 0; c \u003c 3; c++) {\n        const v = dark ? (0.04 + ex * ember * glow[c]) * dim : COL[c];\n        rgb[o * 3 + c] = mix(rgb[o * 3 + c], v, cov);\n      }\n      if (cov > a[o]) a[o] = cov;\n    }\n}\n\nfunction lights(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  S.glow = [0, 1, 2].map((c) => mix(PAL[i][0][c], PAL[j][0][c], s));\n  S.rim = [0, 1, 2].map((c) => mix(PAL[i][1][c], PAL[j][1][c], s));\n}\n\n// Box blur of src into dst, radius 2, across then down.\nfunction blur(src, tmp, dst) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let k = -2; k \u003c= 2; k++) s += src[y * W + cl(x + k, 0, W - 1)];\n      tmp[y * W + x] = s / 5;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let k = -2; k \u003c= 2; k++) s += tmp[cl(y + k, 0, H - 1) * W + x];\n      dst[y * W + x] = s / 5;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  lights(S);\n  const { rgb, a, halo, ghost } = S, P = S.pose;\n  rgb.fill(0);\n  a.fill(0);\n  S.prims.length = 0;\n  const pulse = 0.5 + 0.5 * cos(TAU * S.beat);\n  S.ember = 0.75 + 0.25 * pulse;\n  // The skull's flight: up out of the panel and back in 1.4 seconds, two\n  // turns, then a little bounce on the neck.\n  let flyY = 0, flySpin = 0, armsUp = 0;\n  if (S.fly >= 0) {\n    const u = S.fly / 1.4;\n    if (u \u003c 1) {\n      flyY = -150 * u * (1 - u);\n      flySpin = 2 * TAU * sstep(u);\n      armsUp = sin(PI * u) ** 0.6;\n    } else flyY = -3 * sin(PI * cl((S.fly - 1.4) / 0.35, 0, 1));\n  }\n  // Backing dancers first: smaller, dimmer, a quarter beat behind, the\n  // one on the left mirrored.\n  if (S.count > 1) {\n    pose(S.beat - 0.25, P, S.tmp);\n    const backs = S.count > 2 ? [12, 52] : [50];\n    for (const bx of backs) build(S, P, bx, FLOOR_BACK, 0.6, bx \u003c 32, 0.72, 0, 0, 0, 100);\n  }\n  pose(S.beat, P, S.tmp);\n  if (S.fly >= 0 && S.fly \u003c 1.4) P[JAW] = 0.5 + 0.5 * sin(TAU * 7 * S.fly);\n  build(S, P, 32, FLOOR, 1.08, false, 1, flyY, flySpin, armsUp, 0);\n  S.prims.sort((p, q) => q.z - p.z);\n  for (const p of S.prims) (p.kind === 3 ? skull : capsule)(S, p);\n  // Haze round the bones, and the afterimages.\n  blur(a, S.blur, halo);\n  const keep = (0.5 + 0.42 * S.trail) ** (S.dt * 30), gain = sstep(S.trail / 0.6);\n  for (let o = 0; o \u003c N; o++) ghost[o] = max(ghost[o] * keep, a[o]);\n  const g = S.glow, rim = S.rim;\n  for (let y = 0, o = 0; y \u003c H; y++) {\n    // The floor: a pool of light under the first dancer with a rim of the\n    // second colour, and a faint floor line.\n    const fy = (y + 0.5 - FLOOR - 1.5) / 5.5;\n    for (let x = 0; x \u003c W; x++, o++) {\n      const fx = (x + 0.5 - 32) / 27, q = sqrt(fx * fx + fy * fy);\n      const pool = max(0, 1 - q) ** 1.3 * (0.9 + 0.1 * pulse), ring = max(0, 1 - abs(q - 0.95) / 0.35) * 0.35;\n      const line = abs(y - FLOOR - 2) \u003c 0.6 ? 0.16 * max(0, 1 - abs(fx) / 1.25) : 0;\n      const hz = 0.22 * halo[o] * (1 - a[o]), gh = gain * 0.9 * max(0, ghost[o] - a[o]);\n      // Bones are already weighted by their cover, and the light shows\n      // round them in steps of 1/24: a smooth ramp costs more to store than\n      // it shows. Faint haze and afterimages take the rim colour, so a faint\n      // orange never reads brown; the brighter, the more the glow's own.\n      const al = 1 - a[o], lp = round(pool * 0.75 * 24) / 24, lh = round((hz + gh) * 24) / 24, lr = round((ring + line) * 24) / 24;\n      const wg = sstep((lh - 0.3) * 2.5);\n      const r = rgb[o * 3] + min(1, g[0] * lp + mix(rim[0], g[0], wg) * lh + rim[0] * lr) * al;\n      const gg = rgb[o * 3 + 1] + min(1, g[1] * lp + mix(rim[1], g[1], wg) * lh + rim[1] * lr) * al;\n      const b = rgb[o * 3 + 2] + min(1, g[2] * lp + mix(rim[2], g[2], wg) * lh + rim[2] * lr) * al;\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, gg)), round(255 * min(1, b)));\n    }\n  }\n}\n","grave-hand":"// ===== Patternflow pattern =====\n// Title:   Grave Hand\n// Family:  halloween\n// Idea:    Under a big low moon a headstone and a heap of fresh grave earth stand black; the heap heaves and cracks with green light, a bony hand bursts out of it throwing clods, gropes and claws at the air in front of the moon, then sinks back and the earth settles, and it all begins again a few seconds later.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the hand rising from the grave of Halloween yard decorations\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Hands=1..3, Fog=0..1\n//\n// Knob 1: Colour. Three palettes round the knob: at 0 an orange moon in a purple sky, with toxic green light from the grave on the hands; at 0.33 a sickly green moon and orange light; at 0.67 a lilac moon and green light. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 a round takes 12 to 13 seconds: the earth heaves for 1.6, the hand is out in 0.45, gropes for 4.2, sinks back in three pulls over 2.2, the heap settles for 1.5 and rests 0.8 to 2.2. The first hand bursts out at 2.3 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Hands, 1 to 3. The first comes up in the middle of the heap in front of the moon, its fingertips 56 LEDs above the hole at full stretch. The second, 0.86 its size, comes up on the right, and the third, 0.82, on the left in front of the headstone; each keeps its own round, so they rise and sink out of step.\n// Knob 4: Fog. How high and thick the ground fog lies. At 0 a thin layer fills the bottom 29 rows; at 1 it climbs to row 55, over the heap and the lower half of the moon, three times as thick. Over a glowing hole it is lit the colour of the grave light.\n// Buttons: K1 tap brings every hand that is under the earth, resting, heaving, sinking or settling, bursting out at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The moon, low behind the grave.\nconst MX = 35, MY = 58, MR = 25;\n// The ground line, and the mound of fresh earth on it: centre, half width,\n// height.\nconst GY = 105, KX = 37, KW = 27, KH = 13;\n// Palettes, cycled by K1: sky top, sky at the horizon, moon, moon's bright\n// limb, rim light on the hands, glow from the grave, fog, lit edge of earth.\nconst PAL = [\n  [[0.02, 0, 0.05], [0.24, 0.06, 0.32], [1, 0.55, 0.12], [1, 0.8, 0.45], [0.45, 1, 0.12], [0.35, 1, 0.1], [0.55, 0.42, 0.85], [1, 0.55, 0.15]],\n  [[0, 0.02, 0.05], [0.2, 0.04, 0.3], [0.62, 1, 0.22], [0.85, 1, 0.6], [1, 0.5, 0.08], [1, 0.42, 0.05], [0.4, 0.9, 0.35], [0.6, 1, 0.25]],\n  [[0.01, 0, 0.03], [0.13, 0.03, 0.16], [0.82, 0.68, 1], [0.95, 0.9, 1], [0.45, 1, 0.15], [0.4, 1, 0.12], [0.7, 0.45, 1], [0.8, 0.65, 1]],\n];\n// Where each hand comes up: x on the mound, its size, and when its first\n// burst comes, in story seconds (one a second at Speed 2).\nconst HANDS = [\n  { x: 37, s: 1.12, first: 2.3 },\n  { x: 53, s: 0.86, first: 0.9 },\n  { x: 22, s: 0.82, first: 1.3 },\n];\n// One round, in story seconds: the earth heaves, the hand bursts out, gropes,\n// sinks back, and the earth settles.\nconst HEAVE = 1.6, BURST = 0.45, GROPE = 4.2, SINK = 2.2, SETTLE = 1.5;\n// Fingers: base on the palm (local x across, y up, at full size), splay\n// angle, segment lengths, and which way the finger hooks as the hand closes.\n// The last is the thumb. RAD holds the radii at the knuckles and the tip.\nconst FINGERS = [\n  { bx: -3.4, by: 9.2, a: -0.32, len: [4.4, 3.1, 2.7], hook: 1 },\n  { bx: -1.1, by: 10, a: -0.08, len: [4.9, 3.4, 2.9], hook: 0.4 },\n  { bx: 1.2, by: 9.8, a: 0.14, len: [4.6, 3.2, 2.7], hook: -1 },\n  { bx: 3.4, by: 8.8, a: 0.4, len: [3.6, 2.6, 2.3], hook: -1 },\n  { bx: -4.2, by: 3, a: -1.05, len: [3.6, 3.1], hook: 1 },\n];\nconst RAD = [1.35, 1.2, 1.0, 0.55];\n// Upper arm, forearm and hand (wrist to fingertip), and how far the\n// fingertips reach above the hole, all at full size.\nconst UA = 22, FA = 21, HL = 21, REACH = 50;\n\n// The surface of the mound, before any heave: a heap with a few lumps.\nconst mound = (x) => {\n  const q = (x - KX) / KW;\n  return q * q \u003c 1 ? GY - KH * (1 - q * q) ** 0.7 - 0.8 * sin(x * 1.7) * (1 - q * q) : GY;\n};\n\nfunction newHand(d, i) {\n  // The first round starts in the heave, or rests until it is due.\n  const wait = d.first - HEAVE;\n  const cracks = [];\n  for (let c = 0; c \u003c 4; c++) {\n    let a = PI / 2 + (c - 1.5) * 0.75 + 0.3 * (hash(i * 31 + c) - 0.5), x = 0, y = 1;\n    const pts = [[x, y]];\n    for (let k = 0; k \u003c 3; k++) {\n      a += 0.6 * (hash(i * 31 + c * 7 + k) - 0.5);\n      x += cos(a) * (2.5 + 1.5 * hash(i * 17 + c * 5 + k)) * 1.6;\n      y += sin(a) * (2.5 + 1.5 * hash(i * 19 + c * 3 + k)) * 0.7;\n      pts.push([x, y]);\n    }\n    cracks.push(pts);\n  }\n  return {\n    ...d, i, on: false, phase: wait > 0 ? \"rest\" : \"heave\", timer: wait > 0 ? 0 : -wait, rest: max(0, wait),\n    L: 0, from: 0, bump: 0, lift: 0, glow: 0, crack: 0, sway: 0, bend: 0, tilt: 0, open: 0.3, g: 0, cracks,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, pal: -1, colour: 0, speed: 2, count: 1, fog: 0.06,\n    hands: HANDS.map(newHand), clods: [],\n    bg: new Float32Array(N * 3), rgb: new Float32Array(N * 3), sdf: new Float32Array(N), surf: new Float32Array(W), gx: new Float32Array(W),\n  };\n}\n\nfunction spawnClods(S, h, n, fast) {\n  const y0 = mound(h.x) - h.bump;\n  for (let k = 0; k \u003c n; k++) {\n    const a = -PI / 2 + (Math.random() - 0.5) * (fast ? 2.3 : 1.6), v = (fast ? 28 + 52 * Math.random() : 8 + 14 * Math.random()) * (0.6 + 0.4 * h.s);\n    S.clods.push({ x: h.x + (Math.random() - 0.5) * 6 * h.s, y: y0 - 1, vx: cos(a) * v, vy: sin(a) * v, r: fast ? 0.5 + 1.1 * Math.random() : 0.5, life: 3 + Math.random() * 2, hot: fast ? 1 : 0.4, bounces: 0 });\n  }\n}\n\n// A hand at rest or switched off: the heap and the light die down.\nfunction calm(h, d) {\n  const f = exp(-d * 3);\n  h.bump *= f;\n  h.lift *= f;\n  h.glow *= f;\n  h.crack *= f;\n}\n\n// One hand's round. Everything runs on story time d.\nfunction stepHand(S, h, d, tap) {\n  h.timer += d;\n  h.g += d;\n  const s = h.s;\n  // A tap: a hand under the earth bursts out now, even one sinking back.\n  if (tap && h.phase !== \"burst\" && h.phase !== \"grope\") {\n    h.phase = \"heave\";\n    h.timer = HEAVE;\n  }\n  // The pose eases towards what the phase asks for, so nothing snaps when\n  // one phase hands over to the next.\n  const ease = 1 - exp(-d * 9);\n  if (h.phase === \"rest\") {\n    calm(h, d);\n    if (h.timer >= h.rest) {\n      h.phase = \"heave\";\n      h.timer = 0;\n    }\n  }\n  if (h.phase === \"heave\") {\n    const u = cl(h.timer / HEAVE, 0, 1);\n    // The earth swells and trembles over the hand, and a few crumbs hop.\n    h.bump = s * (4.5 * sm(0, 1, u) + 0.9 * u * sin(h.g * 31 + h.i));\n    h.crack = sm(0.35, 1, u);\n    h.glow = 0.3 * u;\n    if (Math.random() \u003c d * 7 * u) spawnClods(S, h, 1, false);\n    if (h.timer >= HEAVE) {\n      h.phase = \"burst\";\n      h.timer = 0;\n      h.from = h.L;\n      spawnClods(S, h, round(26 * s), true);\n    }\n  } else if (h.phase === \"burst\") {\n    const u = cl(h.timer / BURST, 0, 1);\n    // Out in under half a second, a little past full height and back.\n    h.L = mix(h.from, REACH * s * (1 + 0.12 * sin(PI * u)), 1 - (1 - u) ** 3);\n    h.bump = 4.5 * s * (1 - u);\n    h.lift = 3.2 * s * sm(0, 1, u);\n    h.glow = 1;\n    h.open = mix(0.05, 1, u);\n    h.sway += (0.08 * sin(h.g * 5 + h.i) - h.sway) * ease;\n    h.bend += (0 - h.bend) * ease;\n    h.tilt += (0 - h.tilt) * ease;\n    if (h.timer >= BURST) {\n      h.phase = \"grope\";\n      h.timer = 0;\n    }\n  } else if (h.phase === \"grope\") {\n    const t = h.timer;\n    // Groping at the air: the arm sways and stretches, the wrist turns, and\n    // the fingers open wide and close into a claw about once a second.\n    const w = sm(0, 0.8, t);\n    h.L = REACH * s * (1 + w * (0.09 * sin(t * 2.6) - 0.05 * sin(t * 5.1 + 1)));\n    h.sway += (w * (0.2 * sin(t * 1.8 + h.i * 2) + 0.06 * sin(t * 4.1)) - h.sway) * ease;\n    h.bend += (w * 0.5 * sin(t * 1.25 + 2 + h.i) - h.bend) * ease;\n    h.tilt += (w * (0.45 * sin(t * 2.4 + 1 + h.i) + 0.12 * sin(t * 4.7)) - h.tilt) * ease;\n    h.open += (0.5 + 0.5 * sin(t * 6.3 + 1.6) - h.open) * ease;\n    h.glow = mix(1, 0.35, sm(0, 1.5, t));\n    h.crack = 1 - sm(0, 2, t) * 0.5;\n    if (h.timer >= GROPE) {\n      h.phase = \"sink\";\n      h.timer = 0;\n    }\n  } else if (h.phase === \"sink\") {\n    const u = cl(h.timer / SINK, 0, 1);\n    // Back down in three pulls, the fingers clawing at the earth.\n    const pull = (u * 3 + 0.35 * sin(u * 6 * PI)) / 3;\n    h.L = REACH * s * (1 - sm(0, 1, pull)) * (1 + 0.05 * sin(h.g * 4));\n    h.sway *= exp(-d * 1.5);\n    h.bend *= exp(-d * 2);\n    h.tilt += (0.25 * sin(h.timer * 3.1) - h.tilt) * ease;\n    h.open += (0.25 + 0.25 * sin(h.timer * 9) - h.open) * ease;\n    h.glow = 0.35 * (1 - u) + 0.15;\n    h.lift = 3.2 * s * (1 - 0.4 * u);\n    if (h.timer >= SINK) {\n      h.phase = \"settle\";\n      h.timer = 0;\n      h.L = 0;\n    }\n  } else if (h.phase === \"settle\") {\n    h.L = 0;\n    const u = cl(h.timer / SETTLE, 0, 1);\n    // The heap slumps back and wobbles still.\n    h.lift = 1.9 * s * (1 - sm(0, 1, u));\n    h.bump = -1.2 * s * sin(u * PI) * exp(-u * 2);\n    h.glow = 0.15 * (1 - u);\n    h.crack = 0.5 * (1 - u);\n    if (h.timer >= SETTLE) {\n      h.phase = \"rest\";\n      h.timer = 0;\n      h.rest = 0.8 + 1.4 * Math.random();\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.colour = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 1, 3);\n  S.fog = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  const tap = !!(input.btnPressed && input.btnPressed[0]);\n  // The hands the knob asks for at the start keep their first schedule; one\n  // turned on later comes up after a short rest.\n  if (!S.begun) for (const h of S.hands) h.on = h.i \u003c S.count;\n  S.begun = true;\n  for (const h of S.hands) {\n    const on = h.i \u003c S.count;\n    if (on && !h.on) {\n      h.phase = \"rest\";\n      h.timer = 0;\n      h.rest = 0.3 + 0.5 * h.i;\n    }\n    h.on = on;\n    if (on) stepHand(S, h, ds, tap);\n    else {\n      h.L = 0;\n      calm(h, ds);\n    }\n  }\n  // Clods: thrown, falling, bouncing once on the heap, then lying on it until\n  // they fade into it.\n  const surf = S.surf;\n  surface(S, surf);\n  for (const c of S.clods) {\n    c.life -= ds;\n    c.hot *= exp(-ds * 2);\n    if (c.bounces \u003c 2) {\n      c.vy += 120 * ds;\n      c.x += c.vx * ds;\n      c.y += c.vy * ds;\n      const xi = cl(floor(c.x), 0, W - 1);\n      if (c.y >= surf[xi] - c.r * 0.5 && c.vy > 0) {\n        c.y = surf[xi] - c.r * 0.5;\n        c.vy *= -0.25;\n        c.vx *= 0.4;\n        c.bounces++;\n      }\n    } else {\n      const xi = cl(floor(c.x), 0, W - 1);\n      c.y = surf[xi] - c.r * 0.5;\n    }\n  }\n  S.clods = S.clods.filter((c) => c.life > 0 && c.x > -3 && c.x \u003c W + 3 && c.y \u003c H + 3);\n}\n\n// The heap's surface now, column by column: the mound, the heave over each\n// hand and the earth pushed up on either side of an arm.\nfunction surface(S, surf) {\n  for (let x = 0; x \u003c W; x++) {\n    let y = mound(x + 0.5);\n    for (const h of S.hands) {\n      const dx = x + 0.5 - h.x, w = 5.5 * h.s, sh = 4.6 * h.s, sw = 2.6 * h.s;\n      y -= h.bump * exp(-(dx * dx) / (w * w));\n      y -= h.lift * (exp(-((dx - sh) ** 2) / (sw * sw)) + exp(-((dx + sh) ** 2) / (sw * sw)));\n    }\n    surf[x] = y;\n  }\n}\n\nfunction palette(S) {\n  const h = (S.colour - floor(S.colour)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  // Each palette holds for 0.1 either side of 0, 1/3 and 2/3 of the knob.\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  return PAL[0].map((_, n) => [0, 1, 2].map((c) => mix(PAL[i][n][c], PAL[j][n][c], s)));\n}\n\n// Sky, stars, moon and headstone: they change only with the palette.\nfunction background(S, pal) {\n  const bg = S.bg, [top, hor, moon, limb, , , , edge] = pal;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, f = cl(y / GY, 0, 1) ** 1.6;\n      const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n      // The halo in steps of 0.02: a smooth one costs the frame a third more\n      // bytes and looks no different on the panel.\n      const halo = round(15 * exp(-max(0, r - MR) / 7)) * 0.02;\n      const a = cl(MR - r + 0.5, 0, 1);\n      let sea = 0;\n      for (const [sx, sy, sr] of [[-8, -6, 7], [6, 4, 6], [-3, 10, 4], [9, -9, 4], [-12, 5, 3]]) sea = max(sea, cl(1 - sqrt((dx - sx) ** 2 + (dy - sy) ** 2) / sr, 0, 1));\n      const lift = cl(0.55 - (dx + dy) / (2.2 * MR), 0, 1);\n      for (let c = 0; c \u003c 3; c++) {\n        const sky = mix(top[c], hor[c], f) + halo * moon[c];\n        bg[o + c] = mix(sky, mix(moon[c], limb[c], lift) * (1 - 0.25 * sea), a);\n      }\n    }\n  // Stars, out of the moon's halo.\n  for (let n = 0; n \u003c 16; n++) {\n    const x = floor(hash(n * 3 + 1) * W), y = floor(hash(n * 3 + 2) * 40), dx = x - MX, dy = y - MY;\n    if (dx * dx + dy * dy \u003c (MR + 6) ** 2) continue;\n    const o = (y * W + x) * 3, b = 0.35 + 0.4 * hash(n * 3 + 3);\n    bg[o] = max(bg[o], b * 0.9);\n    bg[o + 1] = max(bg[o + 1], b * 0.85);\n    bg[o + 2] = max(bg[o + 2], b);\n  }\n  // The headstone: a slab with a round top, leaning a little, black against\n  // the moon with its right edge lit.\n  for (let y = 60; y \u003c GY; y++)\n    for (let x = 0; x \u003c 26; x++) {\n      const lx = x + 0.5 - 12 - (GY - y) * 0.08, ly = y + 0.5;\n      const top = 75, half = 8.5;\n      let inside = abs(lx) \u003c half && ly > top;\n      if (!inside && ly \u003c= top) inside = lx * lx + (ly - top) ** 2 \u003c half * half;\n      if (!inside) continue;\n      const o = (y * W + x) * 3, d = min(half - abs(lx), ly \u003c= top ? half - sqrt(lx * lx + (ly - top) ** 2) : 99);\n      const rim = lx > 0 && d \u003c 1.2 ? 0.55 : 0;\n      for (let c = 0; c \u003c 3; c++) bg[o + c] = 0.025 + rim * edge[c] * 0.8;\n    }\n  // RIP cut into the stone, a little lighter than the stone.\n  const RIP = [\"110 111 110\", \"101 010 101\", \"110 010 110\", \"101 010 100\", \"101 111 100\"];\n  RIP.forEach((row, j) => {\n    for (let i = 0; i \u003c row.length; i++) {\n      if (row[i] !== \"1\") continue;\n      const y = 79 + j, x = floor(6.5 + i + (GY - y) * 0.08), o = (y * W + x) * 3;\n      for (let c = 0; c \u003c 3; c++) bg[o + c] = 0.06 + 0.16 * edge[c] * 0.6 + (c === 2 ? 0.08 : 0.03);\n    }\n  });\n  // Grass along the ground line, black against the glow of the horizon.\n  for (let x = 0; x \u003c W; x++) {\n    const tall = floor(1 + 3.2 * hash(x * 7 + 5) * hash(x * 11 + 3));\n    for (let y = GY - tall; y \u003c GY; y++) for (let c = 0; c \u003c 3; c++) bg[(y * W + x) * 3 + c] = 0.02;\n  }\n  for (let y = GY; y \u003c H; y++) for (let x = 0; x \u003c W; x++) for (let c = 0; c \u003c 3; c++) bg[(y * W + x) * 3 + c] = c === 2 ? 0.035 : 0.02;\n}\n\n// The fog's two waves across the panel, as tables.\nconst SX1 = new Float32Array(W), CX1 = new Float32Array(W), SX2 = new Float32Array(W), CX2 = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) {\n  SX1[x] = sin(x * 0.17);\n  CX1[x] = cos(x * 0.17);\n  SX2[x] = sin(x * 0.07);\n  CX2[x] = cos(x * 0.07);\n}\n\n// How bright the glow from a hand's hole is this instant: it throbs.\nconst pulse = (h) => 0.62 + 0.25 * sin(h.g * 6.3) + 0.13 * sin(h.g * 15.1 + 1);\n\n// The hand's bones for this frame, in panel coordinates. L is how high the\n// fingertips stand above the hole when the arm is straight; the arm slides\n// out of the hole along the upper arm, and bends at the elbow only once the\n// elbow is out.\nfunction bones(h) {\n  const s = h.s, hole = mound(h.x);\n  const d1x = sin(h.sway), d1y = -cos(h.sway), e = h.L - (FA + HL) * s;\n  const ex = h.x + e * d1x, ey = hole + e * d1y;\n  const a2 = h.sway + h.bend * sm(0, 5 * s, e), d2x = sin(a2), d2y = -cos(a2);\n  const wx = ex + FA * s * d2x, wy = ey + FA * s * d2y;\n  const ang = a2 + h.tilt, ux = sin(ang), uy = -cos(ang), rx = -uy, ry = ux;\n  const P = (lx, ly) => [wx + (lx * rx + ly * ux) * s, wy + (lx * ry + ly * uy) * s];\n  const caps = [];\n  caps.push([ex, ey, ex - d1x * UA * s, ey - d1y * UA * s, 4 * s, 4.6 * s]);\n  caps.push([ex, ey, wx, wy, 3.9 * s, 3.2 * s]);\n  // Palm: two fat bones side by side.\n  const p0 = P(-2.2, 1.5), p1 = P(-2.4, 7.6), p2 = P(2.2, 1.5), p3 = P(2.3, 7.2);\n  caps.push([p0[0], p0[1], p1[0], p1[1], 3 * s, 2.6 * s]);\n  caps.push([p2[0], p2[1], p3[0], p3[1], 3 * s, 2.5 * s]);\n  // Fingers splay with h.open and hook inwards as they close.\n  const close = 1 - h.open;\n  for (let f = 0; f \u003c FINGERS.length; f++) {\n    const F = FINGERS[f], lag = sin(h.g * 6.3 + 1.6 - f * 0.5) * 0.12;\n    const c = cl(close + lag, 0, 1);\n    let [x, y] = [F.bx, F.by], a = F.a * (0.55 + 0.75 * (1 - c));\n    for (let k = 0; k \u003c F.len.length; k++) {\n      a += F.hook * c * [0.35, 0.6, 0.55][k];\n      const l = F.len[k] * (1 - 0.35 * c);\n      const nx = x + sin(a) * l, ny = y + cos(a) * l;\n      const A = P(x, y), B = P(nx, ny);\n      const r0 = RAD[k] * (f === 4 ? 1.1 : 1), r1 = (k === F.len.length - 1 ? RAD[3] : RAD[k + 1]) * (f === 4 ? 1.1 : 1);\n      caps.push([A[0], A[1], B[0], B[1], r0 * s, r1 * s]);\n      x = nx;\n      y = ny;\n    }\n  }\n  return { caps, wx, wy };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const pal = palette(S);\n  const [, , , , rimC, glowC, fogC, edgeC] = pal;\n  if (S.pal !== S.colour) {\n    background(S, pal);\n    S.pal = S.colour;\n  }\n  const { rgb, sdf, surf } = S;\n  rgb.set(S.bg);\n  surface(S, surf);\n  sdf.fill(99);\n  // The hands, as one distance field: below zero is inside.\n  for (const h of S.hands) {\n    if (!h.on || h.L \u003c= 0.2) continue;\n    const B = bones(h);\n    let bx0 = 99, bx1 = -99, by0 = 999;\n    for (const c of B.caps) {\n      bx0 = min(bx0, c[0] - c[4], c[2] - c[5]);\n      bx1 = max(bx1, c[0] + c[4], c[2] + c[5]);\n      by0 = min(by0, c[1] - c[4], c[3] - c[5]);\n    }\n    const x0 = max(0, floor(bx0 - 1)), x1 = min(W - 1, floor(bx1 + 1)), y0 = max(0, floor(by0 - 1)), y1 = min(H - 1, floor(mound(h.x) + 2));\n    // Each bone as a, b - a, 1 / |b - a|^2 and its two radii, for the\n    // distance from a pixel to the bone rounded from ra to rb.\n    const n = B.caps.length, K = new Float64Array(n * 7);\n    B.caps.forEach((c, i) => {\n      const ex = c[2] - c[0], ey = c[3] - c[1];\n      K.set([c[0], c[1], ex, ey, 1 / (ex * ex + ey * ey || 1e-9), c[4], c[5] - c[4]], i * 7);\n    });\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        if (y > surf[x] + 1) continue;\n        const px = x + 0.5, py = y + 0.5;\n        let d = 99;\n        for (let i = 0; i \u003c n * 7; i += 7) {\n          const wx = px - K[i], wy = py - K[i + 1];\n          let t = (wx * K[i + 2] + wy * K[i + 3]) * K[i + 4];\n          t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n          const dx = wx - K[i + 2] * t, dy = wy - K[i + 3] * t, e = sqrt(dx * dx + dy * dy) - K[i + 5] - K[i + 6] * t;\n          if (e \u003c d) d = e;\n        }\n        const o = y * W + x;\n        if (d \u003c sdf[o]) sdf[o] = d;\n      }\n  }\n  // Hands: black, with a rim of light from the grave all round. The fingers\n  // are thin enough to be all rim.\n  for (let o = 0; o \u003c N; o++) {\n    const d = sdf[o];\n    if (d >= 0.7) continue;\n    const q = o * 3;\n    if (d >= 0) {\n      const a = 0.55 * (1 - d / 0.7);\n      for (let c = 0; c \u003c 3; c++) rgb[q + c] = mix(rgb[q + c], rimC[c], a);\n    } else {\n      const rim = cl(1 + d / 1.5, 0, 1);\n      for (let c = 0; c \u003c 3; c++) rgb[q + c] = 0.015 + rimC[c] * rim * 0.8;\n    }\n  }\n  // The heap: dark earth up to its surface, its top edge caught by the moon,\n  // cracks and the ground round each arm lit from below.\n  for (let x = 0; x \u003c W; x++) {\n    const ys = surf[x];\n    for (let y = max(0, floor(ys)); y \u003c GY + 1; y++) {\n      const o = (y * W + x) * 3, cov = cl(y + 1 - ys, 0, 1);\n      if (cov \u003c= 0) continue;\n      const depth = y + 0.5 - ys, lit = depth \u003c 1.3 ? 0.45 * (1 - depth / 1.3) : 0;\n      for (let c = 0; c \u003c 3; c++) {\n        const earth = (c === 2 ? 0.04 : c === 0 ? 0.035 : 0.022) + edgeC[c] * lit;\n        rgb[o + c] = mix(rgb[o + c], earth, cov);\n      }\n    }\n  }\n  for (const h of S.hands) {\n    if (h.glow \u003c= 0.01 && h.crack \u003c= 0.01) continue;\n    const ys = mound(h.x) - h.bump;\n    // Glow from the hole, throbbing, spilling up into the air and over the\n    // earth.\n    const R = 11 * h.s, beat = h.glow * pulse(h), gx = S.gx;\n    for (let x = 0; x \u003c W; x++) gx[x] = exp(-(((x + 0.5 - h.x) / (1.6 * R)) ** 2));\n    for (let y = max(0, floor(ys - 2.6 * R)); y \u003c min(H, ys + 2.2 * R); y++) {\n      const gy = beat * exp(-(((y + 0.5 - ys) / R) ** 2));\n      for (let x = 0; x \u003c W; x++) {\n        const g = gy * gx[x] * (y + 0.5 >= surf[x] ? 0.6 : 0.35), o = (y * W + x) * 3;\n        rgb[o] += glowC[0] * g;\n        rgb[o + 1] += glowC[1] * g;\n        rgb[o + 2] += glowC[2] * g;\n      }\n    }\n    // Cracks in the heaving earth.\n    if (h.crack > 0.01)\n      for (const pts of h.cracks)\n        for (let k = 0; k + 1 \u003c pts.length; k++)\n          for (let n = 0; n \u003c= 4; n++) {\n            const x = floor(h.x + mix(pts[k][0], pts[k + 1][0], n / 4) * h.s), y = floor(ys + 1 + mix(pts[k][1], pts[k + 1][1], n / 4) * h.s);\n            if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || y \u003c surf[x] + 0.5) continue;\n            const o = (y * W + x) * 3, a = h.crack * (1 - 0.25 * k);\n            for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(rgb[o + c], glowC[c], a * 0.85);\n          }\n  }\n  // Clods: black against the moon, dim earth against the night, and green\n  // while they are fresh from the hole.\n  for (const c of S.clods) {\n    const fade = cl(c.life / 1.2, 0, 1);\n    for (let y = floor(c.y - c.r); y \u003c= floor(c.y + c.r); y++)\n      for (let x = floor(c.x - c.r); x \u003c= floor(c.x + c.r); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const dx = x + 0.5 - c.x, dy = y + 0.5 - c.y;\n        if (dx * dx + dy * dy > (c.r + 0.35) ** 2) continue;\n        const o = (y * W + x) * 3, lum = max(rgb[o], rgb[o + 1], rgb[o + 2]);\n        for (let ch = 0; ch \u003c 3; ch++) {\n          const col = lum > 0.3 ? 0.02 : edgeC[ch] * 0.3;\n          rgb[o + ch] = mix(rgb[o + ch], mix(col, glowC[ch] * 0.8, c.hot * 0.6), fade);\n        }\n      }\n  }\n  // Ground fog rolling in front of everything, lit green where the grave\n  // glows under it.\n  const fog = S.fog, top = GY - 6 - 44 * fog, dens = 0.22 + 0.5 * fog, t = S.t;\n  // Each lamp's light falls off as a Gaussian, so it splits into a factor per\n  // column, kept here, and one per row.\n  const lamps = S.hands.filter((h) => h.glow > 0.01).map((h) => {\n    const r2 = (16 * h.s) ** 2, gx = new Float32Array(W);\n    for (let x = 0; x \u003c W; x++) gx[x] = exp(-((x + 0.5 - h.x) ** 2) / r2);\n    return { y: mound(h.x), g: h.glow * pulse(h), r2, gx };\n  });\n  for (let y = max(0, floor(top)); y \u003c H; y++) {\n    const rise = sm(top, top + 12 + 10 * fog, y), p1 = y * 0.09 - t * 0.9, p2 = -y * 0.21 + t * 0.55 + 1.3;\n    const s1 = sin(p1), c1 = cos(p1), s2 = sin(p2), c2 = cos(p2);\n    for (const L of lamps) L.row = L.g * exp(-((y + 0.5 - L.y) ** 2) / L.r2);\n    for (let x = 0; x \u003c W; x++) {\n      // sin(x k + p) as sin(x k) cos p + cos(x k) sin p, from tables.\n      const n = 0.5 + 0.28 * (SX1[x] * c1 + CX1[x] * s1) + 0.22 * (SX2[x] * c2 + CX2[x] * s2);\n      const a = round(16 * cl(dens * rise * n, 0, 0.85)) / 16, o = (y * W + x) * 3;\n      let lit = 0;\n      for (const L of lamps) lit += L.row * L.gx[x];\n      lit = round(12 * min(1, lit)) / 12;\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(rgb[o + c], mix(fogC[c] * 0.6, glowC[c] * 0.9, lit), a);\n    }\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * cl(rgb[o * 3], 0, 1)), round(255 * cl(rgb[o * 3 + 1], 0, 1)), round(255 * cl(rgb[o * 3 + 2], 0, 1)));\n}\n","hitomezashi":"// ===== Patternflow pattern =====\n// Title:   Hitomezashi\n// Family:  line\n// Idea:    Rows and columns of running stitches, each line's dashes set one step on or off by a bit, split a woven cloth into regions of two colours, and as the bits flip one at a time a whole line of dashes jumps over by one and a wave recolours everything on one side of it, while a light runs round the newest closed loop of thread.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hitomezashi sashiko, with the loop theorem of Colin Defant and Noah Kravitz (2022), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cell=6..10, Loops=0..1\n//\n// Knob 1: Hue. Turns the light cloth round the colour wheel: aqua at 0, blue at 0.2, violet at 0.3, pink at 0.45, orange at 0.6, yellow at 0.7 and green at 0.85; the dark cloth stays indigo to violet and the thread stays cream.\n// Knob 2: Speed. How often a bit flips and how fast the light runs: at 2 about 2.7 flips a second and 24 stitches a second round the loop; at 0.2 one flip every 3.7 seconds, at 3 four flips a second.\n// Knob 3: Cell. The stitch length in LEDs, 6 to 10: at 6 the panel holds 11 by 22 crossings of the thread lines, at 10 it holds 7 by 13.\n// Knob 4: Loops. Picks the closed loops out of the open threads: the loops are lit gold, biggest first, and the threads that run off the panel dim. At 0 only the loop with the running light is gold; at 0.06 the biggest 6% of the others are too; at 1 every closed loop on the panel is gold, each 4, 12, 20, 28 or more stitches long and always 4 more than a multiple of 8, and the open threads are down to a third.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The thread, the gold of a lit loop, and the head of the running light.\nconst THREAD = [1, 0.94, 0.84], GOLD = [1, 0.62, 0.1], HEAD = [1, 1, 0.85];\n// The cloth is a plain weave: an LED with x + y even is a thread lying on\n// top and catches more light. Brightness of the two kinds in each fill.\nconst WEAVE = { lightHi: 1, lightLo: 0.6, darkHi: 0.2, darkLo: 0 };\n// The recolouring runs out from a flipped line at this many LEDs a second.\nconst WAVE = 150;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, pitch: 0, loopsK: 0.06,\n    // Row line bits a[j] and column line bits b[i], enough for any pitch.\n    a: new Uint8Array(32), b: new Uint8Array(16),\n    nextFlip: 0.4, swap: 0, recent: [],\n    // Cells: colour (0 dark, 1 light), the colour shown, and when it turned.\n    col: new Uint8Array(0), show: new Uint8Array(0), when: new Float32Array(0),\n    // Lines that just flipped glow for a moment: [row?, index, glow].\n    flash: [],\n    loops: [], cur: null, head: 0, laps: 0,\n    loopOf: new Int16Array(N), posOf: new Float32Array(N),\n    geo: null, pal: null, palHue: NaN,\n  };\n  const S = params.s;\n  for (let j = 0; j \u003c S.a.length; j++) S.a[j] = Math.random() \u003c 0.5 ? 1 : 0;\n  for (let i = 0; i \u003c S.b.length; i++) S.b[i] = Math.random() \u003c 0.5 ? 1 : 0;\n}\n\n// The lattice for a pitch P: node columns i = 0..NI-1 at x = OX + P i and\n// node rows j = 0..NJ-1 at y = OY + P j. Cells run one past the nodes on\n// every side (cell i lies between node columns i and i+1) and are stored\n// at i + 1.\nfunction geometry(P) {\n  const NI = floor(63 / P) + 1, NJ = floor(127 / P) + 1;\n  const OX = floor((63 - P * (NI - 1)) / 2), OY = floor((127 - P * (NJ - 1)) / 2);\n  return { P, NI, NJ, OX, OY, CW: NI + 1, CH: NJ + 1 };\n}\n\n// The stitch rule. On row line j the segment from node i to i+1 is a stitch\n// when i + a[j] is even; on column line i the segment from node j to j+1 is\n// a stitch when j + b[i] is even. So every node has exactly one horizontal\n// and one vertical stitch, and the thread turns at every node.\nconst hs = (S, i, j) => ((i + S.a[j]) & 1) === 0;\nconst vs = (S, i, j) => ((j + S.b[i]) & 1) === 0;\n\n// Two-colour the cells: crossing a stitch changes colour, crossing a gap\n// does not. It is consistent because two stitches meet at every node.\n// Starts from the top-left cell, coloured S.swap.\nfunction colour(S, out) {\n  const { NI, NJ, CW } = S.geo;\n  let c = S.swap;\n  for (let j = -1; j \u003c NJ; j++) {\n    if (j >= 0) c ^= hs(S, -1, j) ? 1 : 0;\n    let r = c;\n    out[(j + 1) * CW] = r;\n    for (let i = 0; i \u003c NI; i++) {\n      r ^= vs(S, i, j) ? 1 : 0;\n      out[(j + 1) * CW + i + 1] = r;\n    }\n  }\n}\n\n// Follow the thread from node (i0, j0): its nodes in order if it closes into\n// a loop on the panel's lattice, or null if it runs off the edge.\nfunction trace(S, i0, j0) {\n  const { NI, NJ } = S.geo;\n  const path = [];\n  let i = i0, j = j0, pi = -9, pj = -9;\n  for (let n = 0; n \u003c= NI * NJ; n++) {\n    path.push(j * NI + i);\n    const hx = hs(S, i, j) ? i + 1 : i - 1, vy = vs(S, i, j) ? j + 1 : j - 1;\n    if (hx \u003c 0 || hx >= NI || vy \u003c 0 || vy >= NJ) return null;\n    // The thread alternates: after a horizontal stitch comes a vertical one.\n    if (hx === pi && j === pj) (pi = i), (pj = j), (j = vy);\n    else (pi = i), (pj = j), (i = hx);\n    if (i === i0 && j === j0) return path;\n  }\n  return null;\n}\n\n// Every closed loop on the lattice, biggest first, and which LED lies on\n// which loop and how far round it, in stitches.\nfunction findLoops(S) {\n  const { NI, NJ, P, OX, OY } = S.geo;\n  const seen = new Uint8Array(NI * NJ), loops = [];\n  for (let n = 0; n \u003c NI * NJ; n++) {\n    if (seen[n]) continue;\n    const path = trace(S, n % NI, floor(n / NI));\n    if (!path) continue;\n    for (const u of path) seen[u] = 1;\n    loops.push(path);\n  }\n  loops.sort((p, q) => q.length - p.length);\n  S.loops = loops;\n  S.loopOf.fill(-1);\n  loops.forEach((path, n) => {\n    const L = path.length;\n    for (let k = 0; k \u003c L; k++) {\n      const u = path[k], v = path[(k + 1) % L];\n      const x0 = OX + P * (u % NI), y0 = OY + P * floor(u / NI), x1 = OX + P * (v % NI), y1 = OY + P * floor(v / NI);\n      for (let s = 0; s \u003c P; s++) {\n        const x = x0 + ((x1 - x0) / P) * s, y = y0 + ((y1 - y0) / P) * s;\n        S.loopOf[y * W + x] = n;\n        S.posOf[y * W + x] = k + s / P;\n      }\n    }\n  });\n}\n\n// The longest loop through line k (a row line or a column line), which is\n// the longest loop a flip of that line's bit makes or keeps whole: a loop\n// that does not touch the line is left as it was.\nfunction longestThrough(S, row, k) {\n  const { NI, NJ } = S.geo;\n  let best = 0;\n  for (let n = 0; n \u003c (row ? NI : NJ); n++) {\n    const path = row ? trace(S, n, k) : trace(S, k, n);\n    if (path) best = max(best, path.length);\n  }\n  return best;\n}\n\n// Put the running light on a loop: the given one, or a loop drawn at random\n// weighted by length cubed, so the long winding loops come round far more\n// often than the squares of 4 stitches.\nfunction setLoop(S, path) {\n  if (!path) {\n    let total = 0;\n    for (const p of S.loops) total += p.length ** 3;\n    let r = Math.random() * total;\n    for (const p of S.loops) if ((r -= p.length ** 3) \u003c= 0) {\n      path = p;\n      break;\n    }\n  }\n  S.cur = path || null;\n  S.head = 0;\n  S.laps = 0;\n}\n\nfunction rebuild(S, P) {\n  S.pitch = P;\n  S.geo = geometry(P);\n  const n = S.geo.CW * S.geo.CH;\n  S.col = new Uint8Array(n);\n  S.when = new Float32Array(n).fill(-9);\n  colour(S, S.col);\n  S.show = S.col.slice();\n  S.flash = [];\n  S.recent = [];\n  findLoops(S);\n  setLoop(S, null);\n}\n\n// Flip one bit: every stitch on that line moves over by one, and every cell\n// on one side of the line changes colour. The line is drawn at random,\n// weighted towards lines whose flip closes a long loop. Which side changes\n// colour is a choice (the other is the same picture with the colours\n// swapped): take the bigger side, and let the change run out from the line.\nfunction flip(S) {\n  const { NI, NJ, CW, CH, P, OX, OY } = S.geo;\n  const cand = [];\n  let total = 0;\n  for (let row = 0; row \u003c 2; row++)\n    for (let k = 0; k \u003c (row ? NJ : NI); k++) {\n      if (S.recent.some((r) => r[0] === row && r[1] === k)) continue;\n      const bits = row ? S.a : S.b;\n      bits[k] ^= 1;\n      const L = longestThrough(S, row, k);\n      bits[k] ^= 1;\n      const w = L >= 12 ? (L / 4) ** 2 : 1;\n      cand.push([row, k, w]);\n      total += w;\n    }\n  let r = Math.random() * total, pick = cand[cand.length - 1];\n  for (const c of cand) if ((r -= c[2]) \u003c= 0) {\n    pick = c;\n    break;\n  }\n  const [row, k] = pick;\n  (row ? S.a : S.b)[k] ^= 1;\n  S.recent.push([row, k]);\n  if (S.recent.length > 3) S.recent.shift();\n  const old = S.col.slice();\n  colour(S, S.col);\n  let changed = 0;\n  for (let c = 0; c \u003c old.length; c++) changed += old[c] !== S.col[c] ? 1 : 0;\n  if (changed * 2 \u003c old.length) {\n    S.swap ^= 1;\n    colour(S, S.col);\n  }\n  const at = row ? OY + P * k : OX + P * k;\n  for (let cj = 0; cj \u003c CH; cj++)\n    for (let ci = 0; ci \u003c CW; ci++) {\n      const c = cj * CW + ci;\n      if (old[c] === S.col[c]) continue;\n      const centre = row ? OY + P * (cj - 1) + P / 2 : OX + P * (ci - 1) + P / 2;\n      S.when[c] = max(S.when[c], S.t + abs(centre - at) / WAVE);\n    }\n  S.flash.push([row, k, 1]);\n  // The light stays on its loop if the flip left it whole; it moves to the\n  // longest loop the flip closed if that one is longer.\n  const kept = S.cur && !S.cur.some((u) => (row ? floor(u / NI) : u % NI) === k);\n  findLoops(S);\n  if (kept) {\n    const u = S.cur[0];\n    S.cur = S.loops[S.loopOf[(OY + P * floor(u / NI)) * W + OX + P * (u % NI)]];\n  }\n  let fresh = null;\n  for (const p of S.loops) if (p.some((u) => (row ? floor(u / NI) : u % NI) === k)) {\n    fresh = p;\n    break;\n  }\n  if (fresh && fresh.length >= 12 && (!kept || fresh.length >= S.cur.length)) setLoop(S, fresh);\n  else if (!kept) setLoop(S, null);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.loopsK = cl(k[3], 0, 1);\n  const P = cl(round(k[2]), 6, 10);\n  if (P !== S.pitch) rebuild(S, P);\n  S.t += d;\n  // Flips come at random, 1.34 a second per unit of Speed on average, never\n  // closer than 0.28 seconds at Speed 1.\n  S.nextFlip -= d * S.speed * 1.2;\n  if (S.nextFlip \u003c= 0) {\n    flip(S);\n    S.nextFlip = 0.33 - 0.67 * log(1 - Math.random() * 0.95);\n  }\n  for (let c = 0; c \u003c S.show.length; c++) if (S.t >= S.when[c]) S.show[c] = S.col[c];\n  for (const f of S.flash) f[2] -= d * 2.5;\n  S.flash = S.flash.filter((f) => f[2] > 0);\n  // The running light: 12 stitches a second per unit of Speed, two laps\n  // round a short loop and one round a long one before it moves on.\n  if (S.cur) {\n    const L = S.cur.length;\n    S.head += d * S.speed * 12;\n    if (S.head >= L) {\n      S.head -= L;\n      if (++S.laps >= (L \u003c 40 ? 2 : 1)) {\n        const was = S.cur;\n        setLoop(S, null);\n        if (S.cur === was && S.loops.length > 1) setLoop(S, S.loops.find((p) => p !== was));\n      }\n    }\n  }\n}\n\nfunction palette(S) {\n  const hB = 0.47 + S.hue;\n  const band = max(0, 1 - abs(hB - floor(hB) - 0.1) / 0.12);\n  const hD = 0.66 + 0.06 * sin(TAU * S.hue);\n  S.pal = {\n    // The light cloth takes any hue; near orange its low threads are lifted\n    // so they do not read brown.\n    lightHi: hsv(hB, 0.45, WEAVE.lightHi),\n    lightLo: hsv(hB, 0.85, WEAVE.lightLo + 0.2 * band),\n    // The dark cloth keeps to indigo and violet: a dark warm cloth reads brown.\n    darkHi: hsv(hD, 0.8, WEAVE.darkHi),\n    darkLo: hsv(hD, 0.9, WEAVE.darkLo),\n  };\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.geo) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { P, NI, NJ, OX, OY, CW } = S.geo;\n  const pal = S.pal;\n  // K4 lights the closed loops gold, the biggest first. It also dims the\n  // threads that run off the panel, down to a third at 1.\n  const lit = round(S.loopsK * S.loops.length), open = 1 - 0.67 * S.loopsK;\n  const cur = S.cur ? S.loops.indexOf(S.cur) : -1, Lc = S.cur ? S.cur.length : 1;\n  const rowGlow = new Float32Array(NJ), colGlow = new Float32Array(NI);\n  for (const [row, k, g] of S.flash) {\n    if (row) rowGlow[k] = max(rowGlow[k], g);\n    else colGlow[k] = max(colGlow[k], g);\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const v = y - OY, j = floor(v / P), fy = v - j * P;\n    for (let x = 0; x \u003c W; x++) {\n      const u = x - OX, i = floor(u / P), fx = u - i * P;\n      const cell = (min(max(j, -1), NJ - 1) + 1) * CW + min(max(i, -1), NI - 1) + 1;\n      // The cloth under this LED: the cell's colour in the weave.\n      const up = ((x + y) & 1) === 0, m = S.show[cell];\n      const c = m ? (up ? pal.lightHi : pal.lightLo) : up ? pal.darkHi : pal.darkLo;\n      let r = c[0], g = c[1], b = c[2];\n      let stitch = false, glow = 0, onLine = true;\n      if (fx === 0 && fy === 0 && i >= 0 && i \u003c NI && j >= 0 && j \u003c NJ) stitch = true;\n      else if (fy === 0 && j >= 0 && j \u003c NJ) (stitch = hs(S, i, j)), (glow = rowGlow[j]);\n      else if (fx === 0 && i >= 0 && i \u003c NI) (stitch = vs(S, i, j)), (glow = colGlow[i]);\n      else onLine = false;\n      if (onLine) {\n        if (stitch) {\n          const n = S.loopOf[y * W + x];\n          if (n >= 0 && n === cur) {\n            // The running light: a head and a fading tail a third of the loop long.\n            let dd = S.head - S.posOf[y * W + x];\n            if (dd \u003c 0) dd += Lc;\n            const tail = max(0, 1 - dd / max(4, Lc / 3));\n            r = GOLD[0] + (HEAD[0] - GOLD[0]) * tail;\n            g = GOLD[1] + (HEAD[1] - GOLD[1]) * tail;\n            b = GOLD[2] + (HEAD[2] - GOLD[2]) * tail;\n          } else if (n >= 0 && n \u003c lit) [r, g, b] = GOLD;\n          else if (n >= 0) [r, g, b] = THREAD;\n          else (r = THREAD[0] * open), (g = THREAD[1] * open), (b = THREAD[2] * open);\n        } else if (glow > 0) {\n          // A line that just flipped: its gaps flash with thread for a moment.\n          r += (THREAD[0] - r) * glow * 0.8;\n          g += (THREAD[1] - g) * glow * 0.8;\n          b += (THREAD[2] - b) * glow * 0.8;\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  }\n}\n","kaleidocycle":"// ===== Patternflow pattern =====\n// Title:   Kaleidocycle\n// Family:  space\n// Idea:    A closed ring of six tetrahedra joined edge to edge by hinges turns through itself without end, seen from the front in the top half of the panel and from behind in the bottom half, every piece tumbling over in its place so the hexagon of faces on each side changes colour through four face sets.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: kaleidocycles (Wallace Walker, 1958), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tetrahedra=6..12, Tilt=0..1\n//\n// Knob 1: Hue. Turns the four face sets' colours round the wheel together. At 0 they are gold, green, azure and magenta; a set that comes round to orange or yellow is paled and lit higher, so it never reads brown.\n// Knob 2: Speed. At 2 the ring turns a quarter in 2.6 seconds, every piece rolls a quarter over and the next face set comes to the front; after 10.5 seconds all four sets have had their turn and it is back where it started. At 0.2 a quarter takes 26 seconds, at 3 it takes 1.7.\n// Knob 3: Tetrahedra, 6 to 12 in steps of 2. 6 is the hexagonal ring of the paper models, here six isosceles tetrahedra whose faces are as tall as their hinge edge is long, the fattest six that still turn all the way: neighbours close face to face at the end of each swing. Six regular tetrahedra would run into each other; 8, 10 and 12 are rings of regular ones, each a wider hoop with a bigger hole.\n// Knob 4: Tilt. How far both views look off the ring's axis, 10 degrees at 0 and 70 at 1. At 0 each view is a hexagon of six faces round a hole that opens into a three-pointed star; at 1 both look at the ring from 20 degrees off its side, where the pieces tumble as wedges and the face set on the outer wall comes into view.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, acos, atan2, round, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The light, a unit vector toward it: from the upper left, in front.\nconst LX = -0.48, LY = -0.62, LZ = -0.62;\n// The camera sits this many ring radii in front of the ring's centre.\nconst CAM = 4.2;\n// The two views: centre row on the panel, and which side of the ring.\nconst VIEWS = [[32, 1], [96, -1]];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, n: 6, tilt: 0.06, phase: 0,\n    // Hinge midpoints p_i and hinge directions z_i, i = 0..N, as the chain\n    // builds them; the tetrahedra's corners about the ring's centre, axis\n    // first; and the same corners on the panel for one view.\n    p: new Float64Array(13 * 3), z: new Float64Array(13 * 3),\n    v: new Float64Array(12 * 4 * 3), sv: new Float64Array(12 * 4 * 3), P: new Float64Array(12 * 4 * 3),\n    fitKey: \"\", scale: 1, radius: 1, gap: 0,\n    id: new Int16Array(W * H), cs: new Uint8Array(W * H), zb: new Float32Array(W * H), sh: new Float32Array(W * H),\n    col: new Float32Array(12), colHue: NaN, warm: new Float32Array(4),\n  };\n}\n\n// The joint angles of the turning ring. Hinge i is where tetrahedra i - 1\n// and i meet, and going from one tetrahedron's common perpendicular to the\n// next one's turns theta_i about it. Every tetrahedron holds its two hinges\n// at right angles, 1 apart, each crossed at its middle by the perpendicular\n// between them. The ring turns with theta = A, B, -A, -B, A, B, ... and is\n// closed exactly when cos(A/2) cos(B/2) = cos(2 pi / N); phi walks once\n// round that loop, and a quarter of it hands each tetrahedron's place and\n// pose to its neighbour.\nfunction angles(n, phi) {\n  const c = cos(TAU / n), s = sin(phi) ** 2;\n  const u = acos(pow(c, s)) * (sin(phi) \u003c 0 ? -1 : 1), w = acos(pow(c, 1 - s)) * (cos(phi) \u003c 0 ? -1 : 1);\n  return [2 * u, 2 * w];\n}\n\n// Build the chain from hinge 0 with Denavit-Hartenberg steps: 1 along the\n// common perpendicular x, a quarter turn about it, then theta about the new\n// hinge. The frame (x, y, z) at hinge i + 1 is c x + s z, -s x + c z, -y.\nfunction chain(S, n, phi) {\n  const [A, B] = angles(n, phi), th = [A, B, -A, -B];\n  const { p, z } = S;\n  let x0 = 1, x1 = 0, x2 = 0, y0 = 0, y1 = 1, y2 = 0, z0 = 0, z1 = 0, z2 = 1, q0 = 0, q1 = 0, q2 = 0;\n  for (let i = 0; i \u003c= n; i++) {\n    (p[3 * i] = q0), (p[3 * i + 1] = q1), (p[3 * i + 2] = q2);\n    (z[3 * i] = z0), (z[3 * i + 1] = z1), (z[3 * i + 2] = z2);\n    const t = th[(i + 1) % 4], c = cos(t), s = sin(t);\n    (q0 += x0), (q1 += x1), (q2 += x2);\n    const a0 = c * x0 + s * z0, a1 = c * x1 + s * z1, a2 = c * x2 + s * z2;\n    const b0 = -s * x0 + c * z0, b1 = -s * x1 + c * z1, b2 = -s * x2 + c * z2;\n    (z0 = -y0), (z1 = -y1), (z2 = -y2);\n    (x0 = a0), (x1 = a1), (x2 = a2);\n    (y0 = b0), (y1 = b1), (y2 = b2);\n  }\n  // How far the chain misses its own start: hinge N must lie on hinge 0,\n  // pointing the other way when N is 2 more than a multiple of 4.\n  const sg = n % 4 === 2 ? -1 : 1;\n  S.gap = max(\n    sqrt((p[3 * n] - p[0]) ** 2 + (p[3 * n + 1] - p[1]) ** 2 + (p[3 * n + 2] - p[2]) ** 2),\n    sqrt((z[3 * n] - sg * z[0]) ** 2 + (z[3 * n + 1] - sg * z[1]) ** 2 + (z[3 * n + 2] - sg * z[2]) ** 2),\n  );\n}\n\n// Half the hinge edge for N tetrahedra. Neighbours sharing hinge i stay\n// apart while 180 - |theta_i| >= 2 atan(a), and |theta| reaches 720 / N\n// degrees, so six tetrahedra can be at most tan 30 degrees; from eight on\n// they are regular, 1 / sqrt 2.\nconst halfHinge = (n) => (n === 6 ? 1 / sqrt(3) : 1 / sqrt(2));\n\n// The ring about its centre: the hinge midpoints' mean, the axis along their\n// polygon's vector area, turned about the axis so the tetrahedra keep their\n// places on average. Each corner is written as (along the axis, and two\n// across it).\nfunction place(S, n, phi, out) {\n  chain(S, n, phi);\n  const { p, z } = S, a = halfHinge(n);\n  let c0 = 0, c1 = 0, c2 = 0;\n  for (let i = 0; i \u003c n; i++) (c0 += p[3 * i]), (c1 += p[3 * i + 1]), (c2 += p[3 * i + 2]);\n  (c0 /= n), (c1 /= n), (c2 /= n);\n  let e0 = 0, e1 = 0, e2 = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const r0 = p[3 * i] - c0, r1 = p[3 * i + 1] - c1, r2 = p[3 * i + 2] - c2;\n    const s0 = p[3 * i + 3] - c0, s1 = p[3 * i + 4] - c1, s2 = p[3 * i + 5] - c2;\n    (e0 += r1 * s2 - r2 * s1), (e1 += r2 * s0 - r0 * s2), (e2 += r0 * s1 - r1 * s0);\n  }\n  let l = sqrt(e0 * e0 + e1 * e1 + e2 * e2);\n  (e0 /= l), (e1 /= l), (e2 /= l);\n  // A first direction across the axis from hinge 0, then the mean turn that\n  // puts tetrahedron i at angle 2 pi i / N.\n  let u0 = p[0] - c0, u1 = p[1] - c1, u2 = p[2] - c2;\n  const d = u0 * e0 + u1 * e1 + u2 * e2;\n  (u0 -= d * e0), (u1 -= d * e1), (u2 -= d * e2);\n  l = sqrt(u0 * u0 + u1 * u1 + u2 * u2);\n  (u0 /= l), (u1 /= l), (u2 /= l);\n  const w0 = e1 * u2 - e2 * u1, w1 = e2 * u0 - e0 * u2, w2 = e0 * u1 - e1 * u0;\n  let sx = 0, sy = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const g0 = (p[3 * i] + p[3 * i + 3]) / 2 - c0, g1 = (p[3 * i + 1] + p[3 * i + 4]) / 2 - c1, g2 = (p[3 * i + 2] + p[3 * i + 5]) / 2 - c2;\n    const az = atan2(g0 * w0 + g1 * w1 + g2 * w2, g0 * u0 + g1 * u1 + g2 * u2) - (TAU * i) / n;\n    (sx += cos(az)), (sy += sin(az));\n  }\n  const rho = atan2(sy, sx) + PI / 2, cr = cos(rho), sr = sin(rho);\n  const f0 = cr * u0 + sr * w0, f1 = cr * u1 + sr * w1, f2 = cr * u2 + sr * w2;\n  const h0 = -sr * u0 + cr * w0, h1 = -sr * u1 + cr * w1, h2 = -sr * u2 + cr * w2;\n  let k = 0;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c 4; j++, k += 3) {\n      const m = j \u003c 2 ? i : i + 1, sg = j & 1 ? -a : a;\n      const q0 = p[3 * m] + sg * z[3 * m] - c0, q1 = p[3 * m + 1] + sg * z[3 * m + 1] - c1, q2 = p[3 * m + 2] + sg * z[3 * m + 2] - c2;\n      out[k] = q0 * e0 + q1 * e1 + q2 * e2;\n      out[k + 1] = q0 * f0 + q1 * f1 + q2 * f2;\n      out[k + 2] = q0 * h0 + q1 * h1 + q2 * h2;\n    }\n}\n\n// One view: side 1 looks at the ring from the end its axis points to, side\n// -1 from the other end, both tipped off the axis by `off` about the\n// panel's vertical. Writes screen x, y about the view's centre and depth.\nfunction view(v, nv, side, off, out) {\n  const co = cos(off), so = sin(off);\n  for (let k = 0; k \u003c nv; k++) {\n    const X = v[3 * k], Y = v[3 * k + 1], Z = v[3 * k + 2];\n    const x = side * Z, dz = -side * X;\n    out[3 * k] = x * co - dz * so;\n    out[3 * k + 1] = Y;\n    out[3 * k + 2] = x * so + dz * co;\n  }\n}\n\nconst offAxis = (tilt) => ((10 + 60 * tilt) * PI) / 180;\n\n// The scale that keeps the whole turn inside each half of the panel, from\n// 48 poses round the loop, seen through the camera from both sides.\nfunction fit(S) {\n  const key = S.n + \":\" + S.tilt.toFixed(3);\n  if (key === S.fitKey) return;\n  const v = S.v, sv = S.sv, nv = S.n * 4, off = offAxis(S.tilt);\n  let R = 0, mx = 0, my = 0;\n  for (let q = 0; q \u003c 48; q++) {\n    place(S, S.n, (q / 48) * TAU, v);\n    for (let k = 0; k \u003c nv; k++) R = max(R, sqrt(v[3 * k] ** 2 + v[3 * k + 1] ** 2 + v[3 * k + 2] ** 2));\n  }\n  for (let q = 0; q \u003c 48; q++) {\n    place(S, S.n, (q / 48) * TAU, v);\n    for (const [, side] of VIEWS) {\n      view(v, nv, side, off, sv);\n      for (let k = 0; k \u003c nv; k++) {\n        const pf = (CAM * R) / (CAM * R + sv[3 * k + 2]);\n        mx = max(mx, abs(sv[3 * k] * pf));\n        my = max(my, abs(sv[3 * k + 1] * pf));\n      }\n    }\n  }\n  S.radius = R;\n  S.scale = min((W / 2 - 1) / mx, (H / 4 - 1) / my);\n  S.fitKey = key;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.n = cl(2 * round(cl(k[2], 6, 12) / 2), 6, 12);\n  S.tilt = cl(k[3], 0, 1);\n  S.phase += d * S.speed * 0.3;\n  fit(S);\n}\n\nfunction palette(S) {\n  const col = S.col;\n  for (let c = 0; c \u003c 4; c++) {\n    const h = S.hue + 0.12 + 0.25 * c, hh = h - floor(h);\n    // Orange and yellow go brown in shade: paler, and lit higher.\n    S.warm[c] = cl(1.6 - abs(hh - 0.11) / 0.08, 0, 1);\n    hsv(h, 0.8 - 0.25 * S.warm[c], 1, col, 3 * c);\n  }\n  S.colHue = S.hue;\n}\n\n// Corners of face f of a tetrahedron, 0 and 1 the ends of its first hinge,\n// 2 and 3 of its second, and the corner left out: two faces hold each hinge.\nconst FACES = [[0, 1, 2, 3], [0, 1, 3, 2], [2, 3, 0, 1], [2, 3, 1, 0]];\n// The face sets. Along the ring the pieces come in fours: every second one\n// is turned end for end and every odd one turned over, so the faces of a\n// set are the ones that face the same way at the same time, front, back,\n// inside or outside. Numbered in the order they come round to the front.\nconst CLASS = [[1, 3, 2, 0], [0, 2, 1, 3], [3, 1, 0, 2], [2, 0, 3, 1]];\n\n// Rasterise one view into rows y0..y1 of the panel: back faces culled, the\n// nearest face kept at each LED, lit flat.\nfunction render(S, n, cy, y0, y1) {\n  const v = S.sv, P = S.P, { id, cs, zb, sh, warm } = S, cam = CAM * S.radius, k = S.scale;\n  for (let q = 0; q \u003c n * 4; q++) {\n    const pf = cam / (cam + v[3 * q + 2]);\n    P[3 * q] = W / 2 + v[3 * q] * pf * k;\n    P[3 * q + 1] = cy + v[3 * q + 1] * pf * k;\n    P[3 * q + 2] = v[3 * q + 2];\n  }\n  for (let t = 0; t \u003c n; t++)\n    for (let f = 0; f \u003c 4; f++) {\n      const F = FACES[f], o = t * 4;\n      let ia = o + F[0], ib = o + F[1];\n      const ic = o + F[2], other = o + F[3];\n      // Outward normal; a face turned away from the camera is skipped.\n      const ax = v[3 * ia], ay = v[3 * ia + 1], az = v[3 * ia + 2];\n      let n0 = (v[3 * ib + 1] - ay) * (v[3 * ic + 2] - az) - (v[3 * ib + 2] - az) * (v[3 * ic + 1] - ay);\n      let n1 = (v[3 * ib + 2] - az) * (v[3 * ic] - ax) - (v[3 * ib] - ax) * (v[3 * ic + 2] - az);\n      let n2 = (v[3 * ib] - ax) * (v[3 * ic + 1] - ay) - (v[3 * ib + 1] - ay) * (v[3 * ic] - ax);\n      if (n0 * (v[3 * other] - ax) + n1 * (v[3 * other + 1] - ay) + n2 * (v[3 * other + 2] - az) > 0) (n0 = -n0), (n1 = -n1), (n2 = -n2), ([ia, ib] = [ib, ia]);\n      if (n0 * ax + n1 * ay + n2 * (az + cam) >= 0) continue;\n      const nl = sqrt(n0 * n0 + n1 * n1 + n2 * n2), cls = CLASS[t & 3][f];\n      const lit0 = 0.26 + 0.74 * max(0, (n0 * LX + n1 * LY + n2 * LZ) / nl);\n      const lit = lit0 + (1 - lit0) * 0.6 * warm[cls];\n      const x0 = P[3 * ia], yy0 = P[3 * ia + 1], x1 = P[3 * ib], yy1 = P[3 * ib + 1], x2 = P[3 * ic], yy2 = P[3 * ic + 1];\n      const area = (x1 - x0) * (yy2 - yy0) - (yy1 - yy0) * (x2 - x0);\n      if (abs(area) \u003c 1e-9) continue;\n      const za = P[3 * ia + 2], zbb = P[3 * ib + 2], zc = P[3 * ic + 2];\n      const xa = max(0, floor(min(x0, x1, x2))), xb = min(W - 1, floor(max(x0, x1, x2)));\n      const ya = max(y0, floor(min(yy0, yy1, yy2))), yb = min(y1, floor(max(yy0, yy1, yy2)));\n      const tag = 1 + t * 4 + f;\n      for (let y = ya; y \u003c= yb; y++) {\n        const Y = y + 0.5;\n        for (let x = xa; x \u003c= xb; x++) {\n          const X = x + 0.5;\n          const w0 = ((x1 - X) * (yy2 - Y) - (yy1 - Y) * (x2 - X)) / area;\n          const w1 = ((x2 - X) * (yy0 - Y) - (yy2 - Y) * (x0 - X)) / area;\n          const w2 = 1 - w0 - w1;\n          if (w0 \u003c -1e-6 || w1 \u003c -1e-6 || w2 \u003c -1e-6) continue;\n          const zz = w0 * za + w1 * zbb + w2 * zc, q = y * W + x;\n          if (zz \u003c zb[q]) (zb[q] = zz), (id[q] = tag), (cs[q] = cls), (sh[q] = lit);\n        }\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  const n = S.n, col = S.col, { id, cs, zb, sh } = S;\n  place(S, n, S.phase, S.v);\n  id.fill(0);\n  zb.fill(1e9);\n  for (const [cy, side] of VIEWS) {\n    view(S.v, n * 4, side, offAxis(S.tilt), S.sv);\n    render(S, n, cy, cy - 32, cy + 31);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const g = id[o];\n      if (!g) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      // A one-LED dark seam where two faces meet, on the far one's side.\n      let edge = false;\n      for (const q of [x > 0 ? o - 1 : -1, x \u003c W - 1 ? o + 1 : -1, y > 0 ? o - W : -1, y \u003c H - 1 ? o + W : -1]) {\n        if (q \u003c 0 || id[q] === 0 || id[q] === g) continue;\n        if (zb[q] \u003c zb[o] - 1e-3 || (abs(zb[q] - zb[o]) \u003c= 1e-3 && id[q] \u003c g)) edge = true;\n      }\n      const c = cs[o] * 3, b = sh[o] * (edge ? 0.45 : 1);\n      display.setPixel(x, y, round(255 * col[c] * b), round(255 * col[c + 1] * b), round(255 * col[c + 2] * b));\n    }\n}\n","leaf-devil":"// ===== Patternflow pattern =====\n// Title:   Leaf Devil\n// Family:  halloween\n// Idea:    A drift of orange, red and yellow leaves lies at the foot of a deep purple night until a dust devil spins up out of it, skids the pile in, lifts the leaves round and round a swaying funnel that climbs all 128 rows, flings them off the top and then breaks, and the leaves flutter and zigzag back down, flashing as they turn, onto a new pile.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after autumn leaves caught in a dust devil on Halloween night\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Leaves=150..300, Wind=0..1\n//\n// Knob 1: Colour. Three nights round the knob: at 0 orange, red and yellow leaves with a few purple-black ones under a purple sky; at 0.33 toxic green and orange leaves under a green-black sky; at 0.67 orange, gold and violet leaves under a blue night. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 one round takes about 13 seconds: the devil spins up at 0.6 seconds, reaches the top of the panel 1.6 seconds later, spins for 4.2, breaks over 0.8, and the leaves are down about 5 seconds after that. At 0.2 a round takes about two minutes, at 3 about 9 seconds.\n// Knob 3: Leaves, 150 to 300. With 150 the pile at the foot is 7 or 8 rows deep in the middle, with 300 about 16; the funnel takes up nearly all of them at once.\n// Knob 4: Wind. A crosswind from the left: it leans the top of the funnel up to 20 LEDs to the right, makes the funnel half as wide again, widens its sway from 7 to 19 LEDs and blows the falling leaves along at up to 22 LEDs a second, so the new pile drifts to the right.\n// Buttons: K1 tap is a gust: it throws the whole pile into the air at once and spins up a devil if none is turning.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// The ground's top row; the pile stacks up from here.\nconst GROUND = 125;\nconst MAXLEAVES = 300;\n// Leaf shapes as LED offsets, 2 to 4 LEDs: maple, oak, a slim willow leaf and\n// a small curled one. The first offset is the stem end, drawn when edge on.\nconst SHAPES = [\n  [[0, 0], [-1, -1], [1, -1], [0, -1]],\n  [[0, 0], [1, 0], [0, -1]],\n  [[0, 0], [1, -1]],\n  [[0, 0], [1, 0], [1, -1]],\n];\n// Palettes, cycled by K1: sky at the top, sky at the horizon, ground, dust,\n// and five leaf colours (the last is the dark one, given to 8% of leaves).\nconst PAL = [\n  {\n    top: [0.04, 0, 0.08], low: [0.2, 0.04, 0.3], ground: [0.05, 0.01, 0.06], dust: [0.5, 0.36, 0.62],\n    leaf: [[1, 0.5, 0.04], [1, 0.14, 0.04], [1, 0.8, 0.08], [1, 0.33, 0.02], [0.36, 0.1, 0.5]],\n  },\n  {\n    top: [0, 0.05, 0.04], low: [0.04, 0.2, 0.12], ground: [0.01, 0.05, 0.03], dust: [0.4, 0.62, 0.4],\n    leaf: [[0.5, 1, 0.08], [1, 0.48, 0.04], [0.8, 1, 0.1], [1, 0.62, 0.05], [0.42, 0.08, 0.5]],\n  },\n  {\n    top: [0.01, 0.02, 0.1], low: [0.08, 0.1, 0.32], ground: [0.02, 0.02, 0.07], dust: [0.45, 0.5, 0.72],\n    leaf: [[1, 0.5, 0.04], [1, 0.75, 0.12], [0.72, 0.3, 1], [1, 0.3, 0.06], [0.45, 0.12, 0.62]],\n  },\n];\n// The devil's phases, in seconds at Speed 2: calm, spin-up, full, break.\nconst CALM = 1.4, SPIN = 1.6, FULL = 4.2, BREAK = 0.8;\n\nfunction rnd(a, b) {\n  return a + (b - a) * Math.random();\n}\n\nfunction newLeaf(i) {\n  const r = Math.random();\n  return {\n    i, state: 0, x: 0, y: 0, vx: 0, vy: 0, th: 0, rise: rnd(24, 40), rf: rnd(0.45, 1.1), ceil: 0, hover: null, bob: 0,\n    phi: rnd(0, TAU), spin: rnd(5, 13) * (Math.random() \u003c 0.5 ? -1 : 1), psi: rnd(0, TAU), wf: rnd(2.4, 4.4), af: rnd(14, 30),\n    tumble: Math.random() \u003c 0.3, quarter: floor(rnd(0, 4)), shape: floor(rnd(0, 4)), col: r \u003c 0.08 ? 4 : floor(rnd(0, 4)), release: 0, hop: 0, order: i,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, tau: 0, speed: 2, count: 150, wind: 0.06, hue: 0,\n    // Devil: phase 0 calm, 1 spin-up, 2 full, 3 break; time in phase; base x.\n    phase: 0, ph: CALM - 0.6, x0: 32, x0v: 0, s: 0, top: GROUND, spinA: 0, life: 0,\n    leaves: [], landed: 0, stack: new Float32Array(W),\n    rgb: new Float32Array(N * 3), sky: new Float32Array(N * 3), skyHue: NaN, pal: null,\n    stars: [], wasDown: false,\n  };\n  const S = params.s;\n  for (let i = 0; i \u003c MAXLEAVES; i++) S.leaves.push(newLeaf(i));\n  // The first pile: leaves dropped round the middle of the foot, each\n  // rolling off where the pile is steep, so they make a low mound.\n  for (const L of S.leaves) {\n    L.x = cl(round(31 + (Math.random() + Math.random() + Math.random() - 1.5) * 30), 1, 62);\n    L.order = S.landed++;\n    L.phi = Math.random() \u003c 0.5 ? 0 : PI;\n    roll(S, L);\n    stackLeaf(S, L);\n  }\n  for (let n = 0; n \u003c 12; n++) S.stars.push([floor(rnd(0, W)), floor(rnd(0, 50)), rnd(0.12, 0.3), rnd(0, TAU)]);\n}\n\n// The funnel's axis at row y: it sways, more toward the top, and a\n// crosswind leans the top over to the right.\nfunction axis(S, y) {\n  const up = cl((GROUND - y) / GROUND, 0, 1.1);\n  const sway = (7 + 12 * S.wind) * sin(1.1 * S.tau + 0.035 * (GROUND - y)) * up + 2 * sin(2.7 * S.tau + 0.08 * y) * up;\n  return S.x0 + sway + 20 * S.wind * up * (0.4 + 0.6 * up);\n}\n// The funnel widens upward, and a stronger wind feeds a wider one.\nconst radius = (S, y) => (3.5 + 17 * cl((GROUND - y) / GROUND, 0, 1.1) ** 1.2 * (0.9 + 0.2 * S.s)) * (0.9 + 0.5 * S.wind);\n\n// A resting leaf lies on whatever is under its width, and adds half a row to\n// the pile there: leaves lie flat and overlap.\nfunction stackLeaf(S, L) {\n  const w = L.shape === 0 ? 3 : 2, x = L.shape === 0 ? L.x - 1 : L.x;\n  L.y = pileTop(S, x, w);\n  for (let c = x; c \u003c x + w; c++) S.stack[(c + W) % W] = GROUND - 1 - L.y + 0.5;\n}\n\n// A leaf landing where the pile is steeper than about half a row a column\n// slides down the slope.\nfunction roll(S, L) {\n  for (let k = 0; k \u003c 24; k++) {\n    const here = S.stack[L.x], l = S.stack[(L.x + W - 2) % W], r = S.stack[(L.x + 2) % W];\n    if (here > l + 1 && l \u003c= r) L.x = (L.x + W - 1) % W;\n    else if (here > r + 1) L.x = (L.x + 1) % W;\n    else break;\n  }\n}\n\n// The top row of the pile over columns x..x+w-1.\nfunction pileTop(S, x, w) {\n  let h = 0;\n  for (let c = x; c \u003c x + w; c++) h = max(h, S.stack[(c + W) % W]);\n  return GROUND - 1 - h;\n}\n\nfunction enter(L) {\n  L.state = 2;\n  L.ceil = Math.random() \u003c 0.17 ? 2 : rnd(0.12, 0.98);\n  L.hover = null;\n}\n\nfunction release(S, L) {\n  // Thrown off the funnel along its spin, still rising a little.\n  const w = 5 * S.s + 1;\n  L.state = 3;\n  L.vx = -sin(L.th) * w * radius(S, L.y) * L.rf + rnd(-8, 8);\n  L.vy = -L.rise * 0.4 * S.s - rnd(0, 12);\n}\n\nfunction stepDevil(S, d, gust) {\n  S.ph += d;\n  if (gust && S.phase === 0) (S.phase = 1), (S.ph = 0.4 * SPIN);\n  if (S.phase === 0 && S.ph > CALM) {\n    // A new devil, somewhere the pile is.\n    let sum = 0, n = 0;\n    for (const L of S.leaves) if (L.i \u003c S.count && L.state === 0) (sum += L.x), n++;\n    S.x0 = cl((n ? sum / n : 32) + rnd(-10, 10), 18, 46);\n    S.x0v = rnd(-3, 3);\n    S.phase = 1;\n    S.ph = 0;\n  } else if (S.phase === 1 && S.ph > SPIN) (S.phase = 2), (S.ph = 0);\n  else if (S.phase === 2 && S.ph > FULL) {\n    S.phase = 3;\n    S.ph = 0;\n    for (const L of S.leaves) L.release = rnd(0, BREAK);\n  } else if (S.phase === 3 && S.ph > BREAK) {\n    // Calm again once nearly everything has landed.\n    let flying = 0;\n    for (const L of S.leaves) if (L.i \u003c S.count && L.state === 3) flying++;\n    if (flying \u003c S.count * 0.04 || S.ph > BREAK + 7) (S.phase = 0), (S.ph = 0);\n  }\n  const u = S.ph / (S.phase === 1 ? SPIN : S.phase === 3 ? BREAK : 1);\n  S.s = S.phase === 1 ? 0.3 + 0.7 * ease(u) : S.phase === 2 ? 1 : S.phase === 3 ? 1 - ease(u) : 0;\n  S.top = S.phase === 1 ? GROUND - (GROUND + 12) * ease(u) : S.phase === 0 ? GROUND : -12;\n  // The base wanders, more so in a crosswind.\n  S.x0v += (rnd(-1, 1) * 6 + (32 - S.x0) * 0.08) * d;\n  S.x0 = cl(S.x0 + (S.x0v + 4 * S.wind) * d, 16, 48 - 10 * S.wind);\n  S.spinA += d * 5 * S.s;\n  S.life = S.phase === 1 ? ease(u) * 0.5 : S.phase === 2 ? 0.5 + 0.5 * min(1, S.ph / 2) : S.phase === 3 ? 1 : 0;\n}\n\nfunction stepLeaf(S, L, d, gust) {\n  const active = S.phase === 1 || S.phase === 2;\n  if (L.state === 0) {\n    // Lying in the pile: now and then one turns over in the draught.\n    if (Math.random() \u003c d * 0.05) L.flipT = 0.4;\n    if (gust) {\n      L.state = 3;\n      L.vx = rnd(-35, 35);\n      L.vy = rnd(-130, -50);\n      return;\n    }\n    if (active) {\n      const dx = L.x - S.x0, reach = 5 + 36 * S.life;\n      if (abs(dx) \u003c reach && Math.random() \u003c d * (1.5 + 4 * S.s)) L.state = 1;\n    }\n  } else if (L.state === 1) {\n    // Skidding over the pile toward the foot of the funnel in little hops.\n    if (!active) {\n      L.state = 3;\n      L.vx = rnd(-10, 10);\n      L.vy = -rnd(5, 20);\n      return;\n    }\n    const dx = L.x - S.x0;\n    L.x -= Math.sign(dx) * (24 + 30 * S.s) * d;\n    L.hop += d * 9;\n    L.y = pileTop(S, floor(L.x), 2) - 2.5 * abs(sin(L.hop));\n    L.phi += L.spin * d;\n    if (abs(dx) \u003c 2 + 3 * L.rf) {\n      enter(L);\n      const r = radius(S, L.y) * L.rf;\n      L.th = Math.acos(cl((L.x - axis(S, L.y)) / r, -1, 1)) * (Math.random() \u003c 0.5 ? 1 : -1);\n    }\n  } else if (L.state === 2) {\n    // Round and up the funnel, faster round near the ground. Each leaf rises\n    // to its own height and rides round there, bobbing, so the funnel is full\n    // from the ground to the top; one in six goes over the top.\n    if (S.phase === 3 && S.ph >= L.release) return release(S, L);\n    if (!active && S.phase !== 3) return release(S, L);\n    const up = (GROUND - L.y) / GROUND;\n    L.th += d * S.s * (6.5 - 3 * min(1, up));\n    if (L.ceil \u003c 1 && up >= L.ceil) {\n      if (L.hover === null) (L.hover = L.y), (L.bob = 0);\n      L.bob += d * 2.2;\n      L.y = L.hover - 3 * sin(L.bob);\n    } else L.y -= d * L.rise * S.s * (0.75 + 0.5 * up);\n    L.phi += L.spin * d * 1.4;\n    // Flung out over the top of the column.\n    if (L.y \u003c max(S.top, 0) + 3 + 6 * L.rf) return release(S, L);\n    L.x = axis(S, L.y) + radius(S, L.y) * L.rf * cos(L.th);\n  } else if (L.state === 3) {\n    // Fluttering down: rocking from side to side, falling fastest through the\n    // middle of each swing, with the crosswind and some drag.\n    L.psi += L.wf * d;\n    const tx = L.af * cos(L.psi) + 22 * S.wind, ty = 16 + 12 * abs(sin(L.psi));\n    L.vx += (tx - L.vx) * min(1, d * 2.2);\n    L.vy += (ty - L.vy) * min(1, d * (L.vy \u003c 0 ? 1.4 : 2.2));\n    L.x += L.vx * d;\n    L.y += L.vy * d;\n    L.x = (L.x + W) % W;\n    if (L.tumble) L.phi += L.spin * d;\n    else L.phi = 1.3 * sin(L.psi);\n    // Caught again by the foot of a turning funnel.\n    if (active && S.s > 0.6 && L.y > GROUND - 45) {\n      const dx = L.x - axis(S, L.y);\n      if (abs(dx) \u003c radius(S, L.y) * 0.9 && Math.random() \u003c d * 3) {\n        enter(L);\n        L.rf = cl(abs(dx) / radius(S, L.y), 0.4, 1.1);\n        L.th = dx >= 0 ? 0 : PI;\n        return;\n      }\n    }\n    if (L.vy > 0 && L.y >= pileTop(S, floor(L.x), 2)) {\n      L.state = 0;\n      L.order = S.landed++;\n      L.x = floor(L.x);\n      L.phi = cos(L.phi) \u003c 0 ? PI : 0;\n      roll(S, L);\n      stackLeaf(S, L);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 150, 0.06], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[3], 0, 1);\n  const count = cl(round(k[2]), 150, MAXLEAVES);\n  // Leaves added by K3 drift in from above the panel; on the first frame\n  // they are simply part of the pile.\n  if (!S.started) (S.started = true), (S.count = count);\n  for (const L of S.leaves)\n    if (L.i >= S.count && L.i \u003c count) {\n      L.state = 3;\n      L.x = rnd(0, W);\n      L.y = rnd(-40, -2);\n      L.vx = L.vy = 0;\n    }\n  S.count = count;\n  const down = !!(input.btnPressed && input.btnPressed[0]);\n  const gust = down && !S.wasDown;\n  S.wasDown = down;\n  const d = d0 * S.speed * 0.5;\n  S.t += d0;\n  S.tau += d;\n  stepDevil(S, d, gust);\n  // The pile, restacked each frame in landing order so it settles into gaps\n  // left by the leaves the devil took.\n  S.stack.fill(0);\n  const resting = [];\n  for (const L of S.leaves) if (L.i \u003c S.count && L.state === 0) resting.push(L);\n  resting.sort((a, b) => a.order - b.order);\n  for (const L of resting) stackLeaf(S, L);\n  for (const L of S.leaves) {\n    if (L.i >= S.count) continue;\n    stepLeaf(S, L, d, gust);\n    if (L.flipT > 0) {\n      L.flipT -= d;\n      L.phi += (PI / 0.4) * d;\n    }\n  }\n}\n\n// --- drawing ---\n\nfunction palette(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  const m = (a, b) => a.map((v, c) => mix(v, b[c], s));\n  const A = PAL[i], B = PAL[j];\n  return { top: m(A.top, B.top), low: m(A.low, B.low), ground: m(A.ground, B.ground), dust: m(A.dust, B.dust), leaf: A.leaf.map((c, n) => m(c, B.leaf[n])) };\n}\n\nfunction put(rgb, x, y, c, a) {\n  x = floor(x);\n  y = floor(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  rgb[o] = mix(rgb[o], c[0], a);\n  rgb[o + 1] = mix(rgb[o + 1], c[1], a);\n  rgb[o + 2] = mix(rgb[o + 2], c[2], a);\n}\n\nfunction drawLeaf(S, rgb, L, pal) {\n  const base = pal.leaf[L.col], c = cos(L.phi);\n  // The far side of the funnel is a little darker, never so dark that an\n  // orange leaf turns brown.\n  const far = L.state === 2 ? 0.88 + 0.12 * sin(L.th) : 1;\n  const back = c \u003c 0;\n  // Back of the leaf: a shade warmer and deeper.\n  const col = back ? [base[0], base[1] * 0.78, base[2] * 0.8] : base;\n  const lit = col.map((v) => min(1, v * far));\n  const ox = L.x, oy = L.y;\n  if (abs(c) \u003c 0.32) {\n    // Edge on: a sliver catching the light.\n    put(rgb, ox, oy, lit.map((v) => mix(v, 1, 0.35)), 1);\n    if (L.shape !== 2) put(rgb, ox + (L.quarter & 1 ? 0 : 1), oy - (L.quarter & 1 ? 1 : 0), lit, 0.7);\n    return;\n  }\n  const shape = SHAPES[L.shape], q = L.quarter;\n  for (let n = 0; n \u003c shape.length; n++) {\n    let [dx, dy] = shape[n];\n    if (back) dx = -dx;\n    for (let r = 0; r \u003c q; r++) [dx, dy] = [-dy, dx];\n    put(rgb, ox + dx, oy + dy, lit, 1);\n  }\n  // Face full on: a flash on the leaf's blade.\n  if (abs(c) > 0.93) {\n    let [dx, dy] = shape[shape.length - 1];\n    if (back) dx = -dx;\n    for (let r = 0; r \u003c q; r++) [dx, dy] = [-dy, dx];\n    put(rgb, ox + dx, oy + dy, [1, 0.95, 0.7], 0.55 * (abs(c) - 0.93) / 0.07 + (L.col === 4 ? 0.2 : 0));\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const pal = (S.pal = S.skyHue === S.hue && S.pal ? S.pal : palette(S));\n  const { rgb, sky } = S;\n  // Sky, stars and ground only change with the colour.\n  if (S.skyHue !== S.hue) {\n    for (let y = 0; y \u003c H; y++) {\n      const u = (y / GROUND) ** 1.6;\n      for (let x = 0; x \u003c W; x++) {\n        const o = (y * W + x) * 3, c = y >= GROUND ? pal.ground : null;\n        for (let ch = 0; ch \u003c 3; ch++) sky[o + ch] = c ? c[ch] : mix(pal.top[ch], pal.low[ch], u);\n      }\n    }\n    S.skyHue = S.hue;\n  }\n  rgb.set(sky);\n  for (const [x, y, a, p] of S.stars) put(rgb, x, y, [0.9, 0.85, 1], a * (0.6 + 0.4 * sin(S.t * 1.3 + p)));\n  const flying = [];\n  for (const L of S.leaves) if (L.i \u003c S.count) flying.push(L);\n  // The far half of the funnel's leaves go behind the dust.\n  for (const L of flying) if (L.state === 2 && sin(L.th) \u003c 0) drawLeaf(S, rgb, L, pal);\n  // Dust: a twisting veil round the funnel's axis, and a cloud at its foot.\n  if (S.s > 0.01) {\n    const dust = pal.dust;\n    for (let y = max(0, floor(S.top - 6)); y \u003c= GROUND + 2 && y \u003c H; y++) {\n      const xa = axis(S, y), r = radius(S, y) * 1.1, fade = cl((y - S.top) / 14, 0, 1);\n      for (let x = 0; x \u003c W; x++) {\n        const u = (x - xa) / r;\n        if (abs(u) > 1.7) continue;\n        const band = 0.55 + 0.45 * sin(0.3 * y - 3 * S.spinA + 2.6 * u);\n        let a = exp(-u * u * 1.6) * band * 0.3;\n        const gy = (y - GROUND) / 5, gx = (x - S.x0) / (10 + 12 * S.life);\n        a += 0.35 * exp(-gy * gy - gx * gx);\n        a *= S.s * fade;\n        if (a > 0.004) {\n          const o = (y * W + x) * 3;\n          for (let ch = 0; ch \u003c 3; ch++) rgb[o + ch] = min(1, rgb[o + ch] + dust[ch] * a);\n        }\n      }\n    }\n  }\n  // The pile, bottom up, then everything in the air.\n  for (const L of flying) if (L.state === 0) drawLeaf(S, rgb, L, pal);\n  for (const L of flying) if (L.state === 1 || L.state === 3 || (L.state === 2 && sin(L.th) >= 0)) drawLeaf(S, rgb, L, pal);\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","mobius-loxodrome":"// ===== Patternflow pattern =====\n// Title:   Möbius Loxodrome\n// Family:  geometry\n// Idea:    The flow of a Möbius transformation with a source above the panel and a sink below it: a conformal checkerboard, every tile streaked with bright sawtooth ripples, pours out of the source and into the sink along circles, and along double spirals once the transformation is turned loxodromic.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Möbius transformations (August Ferdinand Möbius, 1855), the loxodromic case, drawn as a conformal checkerboard shaded like an enhanced phase portrait (Elias Wegert, 2012), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Twist=0..1, Poles=0..1\n//\n// Knob 1: Hue. Turns both colours of the checker round the wheel together. At 0 the tiles are teal and magenta, at 0.25 violet and orange, at 0.6 green and coral; where a colour lands on orange, the dark half of each ripple is turned towards rose so it does not read brown.\n// Knob 2: Speed. How fast the plane streams from the source to the sink. At 2 the multiplier is 1.068 a second, so a ring of tiles passes every 5.3 seconds and a tile in the middle moves 3.3 LEDs a second; at 0.2 a ring takes 53 seconds, at 3 it takes 3.5. The axis through the two fixed points also rocks 7 degrees either way, once in 42 seconds at 2.\n// Knob 3: Twist. The argument of the multiplier. At 0 the transformation is hyperbolic: the tiles run straight down the circles through both fixed points. Turned up, it turns loxodromic and the lanes of tiles wind into spirals; at 1 they cross the circles through the fixed points at 54 degrees and the plane turns 3.1 degrees a second about each fixed point while it streams.\n// Knob 4: Poles. How far the fixed points stand beyond the panel's top and bottom edges: 38 LEDs at 0, so the middle tiles are 17 LEDs across and the rings only bow, down to 0 at 1, where they sit on the middle of the edges, the lanes fan out of them and the tiles shrink into a pale glow there.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, atan2, log, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// In w = log((z - p) / (z - q)) the transformation z -> (az + b) / (cz + d)\n// that fixes p and q is a shift by log k, k its multiplier, so a picture\n// drawn in w and slid along log k is the flow. The picture: a checker whose\n// rows are the flow lines, and over it ripples, a sawtooth whose drops run at\n// 45 degrees to the flow. On the panel those come out near diagonal, so a\n// ripple climbs about 30 levels from one LED to the next along a row and\n// along a column alike, and only its drop is a hard edge.\n//\n// The tiling of the w-plane. w is only defined up to 2 pi i, so it has to\n// close up when v goes once round: LANES flow lanes round each fixed point\n// (even, so the checker closes too), ARMS ripple arms, and rings spaced\n// RING apart in u.\nconst LANES = 18, ARMS = 42, RING = (2 * PI) / LANES;\n// The steepest a ripple may rise from one LED to the next along a row or a\n// column, in levels of 255. Where the ripples crowd, near a fixed point, their\n// height is cut so a rise never passes it.\nconst LIM = 38;\n// How far the fixed points stand beyond the panel's top and bottom, in LEDs,\n// at Poles 0 and 1.\nconst FAR = 38, NEAR = 0;\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, twist: 0, poles: 0.06, T: 0, clock: 0, rgb: new Float64Array(3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.twist = cl(k[2], 0, 1);\n  S.poles = cl(k[3], 0, 1);\n  // T is how far the flow has carried the w-plane along log k.\n  S.T += d * S.speed * 0.033;\n  S.clock += d * S.speed;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  // The fixed points: p above, q below, on an axis through the middle of the\n  // panel that rocks slowly from side to side.\n  const R = 64 + FAR + (NEAR - FAR) * S.poles, sway = 0.12 * sin(S.clock * 0.075);\n  const px = 32 - R * sin(sway) + 1e-4, py = 64 - R * cos(sway), qx = 32 + R * sin(sway) + 1e-4, qy = 64 + R * cos(sway);\n  const dx = px - qx, dy = py - qy;\n  // log k = |log k| e^(i beta): beta 0 is hyperbolic, the flow running\n  // straight along the circles through p and q; beta > 0 is loxodromic.\n  const beta = S.twist * 0.95, cb = cos(beta), sb = sin(beta), tb = sb / cb;\n  // Ripples at 45 degrees to the flow: r = ARMS v / 2 pi + kap u.\n  const m = ARMS / (2 * PI), kap = m / Math.tan(beta + PI / 4), rw = sqrt(kap * kap + m * m);\n  const ou = S.T * cb, ov = S.T * sb;\n  const h0 = S.hue + 0.48, h1 = S.hue + 0.84;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const ax = x + 0.5 - px, ay = y + 0.5 - py, bx = x + 0.5 - qx, by = y + 0.5 - qy;\n      // w = log((z - p) / (z - q)), moved back along the flow.\n      const u = 0.5 * log((ax * ax + ay * ay) / (bx * bx + by * by)) - ou;\n      const v = atan2(ay, ax) - atan2(by, bx) - ov;\n      // dw/dz = (p - q) / ((z - p)(z - q)): how far w moves over one LED.\n      const mr = ax * bx - ay * by, mi = ax * by + ay * bx, mm = mr * mr + mi * mi;\n      const wr = (dx * mr + dy * mi) / mm, wi = (dy * mr - dx * mi) / mm, sc = sqrt(wr * wr + wi * wi);\n      // The checker: rows are the flow lines, cut by the circles round p.\n      const a = u / RING, b = (v - u * tb) / RING;\n      const odd = (floor(a) + floor(b)) & 1;\n      // The ripple's sawtooth: dark, rising to a bright crest, then a drop.\n      const r = m * v + kap * u, f = r - floor(r);\n      const gx = kap * wr + m * wi, gy = m * wr - kap * wi;\n      const amp = min(1, LIM / 255 / max(abs(gx), abs(gy)));\n      let lev = 1 - amp + amp * f;\n      // Ripples narrower than 2.8 LEDs fade into the glow of the fixed point,\n      // gone under 1.6, and the checker after them, from 6 LEDs to 3.\n      const pr = 1 / (rw * sc), fr = cl((pr - 1.6) / 1.2, 0, 1), ft = cl((RING / sc - 3) / 3, 0, 1);\n      const core = cl(1 - pr / 1.6, 0, 1);\n      lev = lev * fr + (0.6 + 0.4 * core) * (1 - fr);\n      let h = odd ? h1 : h0;\n      // An orange family turns towards rose and plum in its dark half, which\n      // would read brown on the panel.\n      const warm = max(0, 1 - abs(h - floor(h) - 0.095) / 0.09);\n      h -= 0.17 * warm * (1 - f) * fr;\n      const sat = ((f > 0.8 ? 0.55 : 0.88) * fr + 0.45 * (1 - fr)) * ft + 0.4 * (1 - ft);\n      hsv(h * ft + (0.5 * (h0 + h1) + 0.25) * (1 - ft), sat * (1 - core), lev, rgb);\n      display.setPixel(x, y, round(rgb[0] * 255), round(rgb[1] * 255), round(rgb[2] * 255));\n    }\n}\n","orb-weaver":"// ===== Patternflow pattern =====\n// Title:   Orb Weaver\n// Family:  halloween\n// Idea:    A purple and orange garden spider builds an orb web down the whole panel: bridge line, frame, radii one by one, a temporary spiral, then the sticky spiral from the rim inward with turnbacks in the long lower half, until the finished web shimmers with orange dew and a gust tears it away.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the orb webs of garden spiders (Araneidae) and the cobwebs of Halloween\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Radii=20..44, Wind=0..1\n//\n// Knob 1: Colour. Three silks round the knob, all lit brighter and warmer toward the bottom of the panel: at 0 silver-violet, at 0.33 toxic green, at 0.67 the bone white of Halloween cobwebs. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again. The spider stays purple with an orange cross and the dew stays orange.\n// Knob 2: Speed. At 2 a web of 20 radii takes 63 seconds: 2 for the bridge line to float across, 5 for the frame, 22 for the radii, 2.5 for the hub and temporary spiral, 16 for the sticky spiral, 11 shimmering with dew, 3.3 for the gust and 1.5 for the spider to walk back in. At 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Radii, 20 to 44 in steps of 2, spaced evenly along the frame so the long lower half gets as many as the rest; at 44 the radii take 44 seconds at Speed 2. Turning it respins the web at the same stage of building.\n// Knob 4: Wind. Sways the web sideways, 1 LED at the hub at 0.06 and 6 LEDs at 1, makes the floating bridge line flutter harder, and throws the torn pieces further.\n// Buttons: K1 tap sends the gust: the web tears now and a new one starts.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, round, exp, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// Silks by K1: silver-violet, toxic green, bone white. The spider's body,\n// its cross and leg colour, and the dew stay put.\nconst SILK = [[0.76, 0.62, 1], [0.42, 1, 0.22], [0.92, 0.9, 0.84]];\nconst BODY = [0.55, 0.14, 1], MARK = [1, 0.55, 0.05], LEG = [0.72, 0.38, 1], DEW = [1, 0.5, 0.04], GLINT = [1, 0.82, 0.45];\n// Spider speeds in LEDs per second at Speed 1: walking on laid silk,\n// laying a frame line or radius, dropping, laying the sticky spiral.\nconst WALK = 65, LAY = 50, DROP = 60, STICKY = 40;\n// Sticky spiral: spacing, the free zone round the hub, the gap to the frame.\nconst GAP = 3.3, FREE = 7.5, RIM = 4;\n// Seconds at Speed 1: bridge float, dew, tear, walking back in.\nconst FLOAT = 4, DEWT = 22, TEAR = 6.5, ENTER = 3;\n\n// A thread or path: points subdivided to at most 5 LEDs apart, with the\n// length up to each point and, for spirals, the distance from the hub.\nfunction poly(points, rs) {\n  const xs = [], ys = [], r = [];\n  for (let i = 0; i \u003c points.length; i++) {\n    const [x, y] = points[i];\n    if (i) {\n      const [px, py] = points[i - 1], n = Math.ceil(sqrt((x - px) ** 2 + (y - py) ** 2) / 5);\n      for (let k = 1; k \u003c n; k++) xs.push(mix(px, x, k / n)), ys.push(mix(py, y, k / n)), r.push(rs ? mix(rs[i - 1], rs[i], k / n) : 0);\n    }\n    xs.push(x), ys.push(y), r.push(rs ? rs[i] : 0);\n  }\n  const cum = [0];\n  for (let i = 1; i \u003c xs.length; i++) cum.push(cum[i - 1] + sqrt((xs[i] - xs[i - 1]) ** 2 + (ys[i] - ys[i - 1]) ** 2));\n  return { xs, ys, r, cum, len: cum[cum.length - 1] };\n}\n\n// The point at distance s along a path, and the heading there.\nfunction along(p, s, out) {\n  const { xs, ys, cum } = p;\n  let i = 1;\n  while (i \u003c cum.length - 1 && cum[i] \u003c s) i++;\n  const f = cl((s - cum[i - 1]) / (cum[i] - cum[i - 1] || 1), 0, 1);\n  out[0] = mix(xs[i - 1], xs[i], f);\n  out[1] = mix(ys[i - 1], ys[i], f);\n  out[2] = atan2(ys[i] - ys[i - 1], xs[i] - xs[i - 1]);\n}\n\n// The web's plan: hub, bridge, frame, radii anchored evenly along the frame,\n// and the moves the spider makes to build it, each tagged with its stage:\n// 0 bridge, 1 frame, 2 radii, 3 hub and temporary spiral, 4 sticky, 5 home.\nfunction plan(S, n) {\n  // Each web's own wobble, kept while K3 respins it.\n  let ji = 0;\n  const j = () => S.jit[ji++];\n  const hub = [31.5 + 1.5 * j(), 37 + 2 * j()];\n  const BL = [0, 6 + 1.5 * j()], BR = [63, 5 + 1.5 * j()];\n  const onBridge = (x) => [x, mix(BL[1], BR[1], x / 63)];\n  const F0 = onBridge(7 + 2 * j()), F1 = onBridge(56 + 2 * j());\n  const F2 = [60 + j(), 47 + 3 * j()], F3 = [51 + 2 * j(), 121 + j()], F4 = [12 + 2 * j(), 122 + j()], F5 = [3 + j(), 49 + 3 * j()];\n  const M = onBridge(hub[0]), G = [hub[0], mix(F4[1], F3[1], (hub[0] - F4[0]) / (F3[0] - F4[0]))];\n  // The frame as a ring from M: down the right side to G and back up the left.\n  const ring = [M, F1, F2, F3, G, F4, F5, F0], R = ring.length, sAt = [0];\n  for (let i = 1; i \u003c= R; i++) sAt.push(sAt[i - 1] + sqrt((ring[i % R][0] - ring[i - 1][0]) ** 2 + (ring[i % R][1] - ring[i - 1][1]) ** 2));\n  const P = sAt[R], sG = sAt[4], wrap = (s) => ((s % P) + P) % P;\n  const ringAt = (s) => {\n    s = wrap(s);\n    let i = 1;\n    while (sAt[i] \u003c s) i++;\n    const f = (s - sAt[i - 1]) / (sAt[i] - sAt[i - 1]);\n    return [mix(ring[i - 1][0], ring[i % R][0], f), mix(ring[i - 1][1], ring[i % R][1], f)];\n  };\n  // Along the frame from s0 to s1 the short way, through its corners.\n  const frameWalk = (s0, s1) => {\n    let d = wrap(s1 - s0);\n    if (d > P / 2) d -= P;\n    const mid = [];\n    for (let k = 0; k \u003c R; k++) {\n      const t = d > 0 ? wrap(sAt[k] - s0) : wrap(s0 - sAt[k]);\n      if (t > 0 && t \u003c abs(d)) mid.push([t, ring[k]]);\n    }\n    mid.sort((a, b) => a[0] - b[0]);\n    return [ringAt(s0), ...mid.map((m) => m[1]), ringAt(s0 + d)];\n  };\n  const h = n / 2, rad = [];\n  for (let k = 0; k \u003c n; k++) {\n    const s = k \u003c= h ? (sG * k) / h : sG + ((P - sG) * (k - h)) / h, a = ringAt(s);\n    const dx = a[0] - hub[0], dy = a[1] - hub[1], L = sqrt(dx * dx + dy * dy);\n    rad.push({ s, a, L, ux: dx / L, uy: dy / L, th: atan2(dy, dx) });\n  }\n  const at = (k, r) => [hub[0] + r * rad[k].ux, hub[1] + r * rad[k].uy];\n\n  const threads = [], moves = [];\n  const thread = (pts, rs, a) => (threads.push({ p: poly(pts, rs), a, shown: 0 }), threads.length - 1);\n  const lay = (t, v, stage) => moves.push({ p: threads[t].p, t, v, stage });\n  const walk = (pts, v, stage) => moves.push({ p: poly(pts), t: -1, v, stage });\n\n  // The bridge floats across first (drawn apart); then the spider walks to M.\n  const bridge = thread([BL, BR], null, 0.85);\n  walk([BL, M], WALK, 0);\n  // Drop from M through the hub to G, frame the left side up to the bridge,\n  // cross it, frame the right side down, and climb back to the hub.\n  lay(thread([M, hub, G], null, 0.85), DROP, 1);\n  const left = thread([G, F4, F5, F0], null, 0.8);\n  lay(left, LAY, 1);\n  walk([F0, M, F1], WALK, 1);\n  const right = thread([F1, F2, F3, G], null, 0.8);\n  lay(right, LAY, 1);\n  walk([G, hub], WALK, 1);\n  // Moorings to the panel's edges, each grown once the spider framing that\n  // side has passed its corner.\n  const d2 = (a, b) => sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2);\n  const moor = [\n    [F2, [63, F2[1] - 7], right, d2(F1, F2)],\n    [F3, [57, 127], right, d2(F1, F2) + d2(F2, F3)],\n    [F4, [6, 127], left, d2(G, F4)],\n    [F5, [0, F5[1] + 6], left, d2(G, F4) + d2(F4, F5)],\n  ].map(([a, b, f, s]) => ({ t: thread([a, b], null, 0.75), f, s }));\n  // Radii: up and down are the drag line. Each new one goes into the widest\n  // gap left: out along the nearest laid radius, along the frame, and back\n  // to the hub laying the new one.\n  const laid = new Set([0, h]);\n  while (laid.size \u003c n) {\n    let best = -1, gap = -1, nb = 0;\n    for (let k = 0; k \u003c n; k++) {\n      if (laid.has(k)) continue;\n      let g = 1e9, near = 0;\n      for (const q of laid) {\n        const dd = abs(((rad[k].th - rad[q].th + 3 * PI) % TAU) - PI);\n        if (dd \u003c g) (g = dd), (near = q);\n      }\n      if (g > gap + 1e-6) (gap = g), (best = k), (nb = near);\n    }\n    walk([hub, rad[nb].a], WALK, 2);\n    walk(frameWalk(rad[nb].s, rad[best].s), WALK, 2);\n    lay(thread([rad[best].a, hub], null, 0.85), LAY, 2);\n    laid.add(best);\n  }\n  // The hub mesh and the temporary spiral, outward to the shortest radius.\n  let Rf = 1e9, Rx = 0;\n  for (const r of rad) (Rf = min(Rf, r.L - RIM)), (Rx = max(Rx, r.L - RIM));\n  const spiral = (r0, r1, pitch, k0) => {\n    const pts = [], rs = [];\n    for (let q = 0, r = r0; r \u003c= r1; q++, r = r0 + (pitch * q) / n) pts.push(at((k0 + q) % n, r)), rs.push(r);\n    return [pts, rs];\n  };\n  const [hp, hr] = spiral(1.6, FREE - 1.5, 1.4, 0);\n  lay(thread(hp, hr, 1), LAY, 3);\n  const [tp, tr] = spiral(FREE - 1.5, Rf + 2, 7, hp.length % n);\n  const temp = thread(tp, tr, 0.5);\n  lay(temp, 1.4 * LAY, 3);\n  // The sticky spiral from the rim inward: an arc round the bottom radius at\n  // every level only the long lower radii reach, turning back at each end,\n  // then whole turns once every radius is long enough.\n  const sp = [], sr = [];\n  let dir = 1, kEnd = h, kStart = -1;\n  for (let r = Rf + GAP * floor((Rx - Rf) / GAP); r > Rf + 1e-6; r -= GAP) {\n    let lo = h, hi = h;\n    while (lo > 1 && rad[lo - 1].L - RIM >= r) lo--;\n    while (hi \u003c n - 1 && rad[hi + 1].L - RIM >= r) hi++;\n    if (hi - lo \u003c 1) continue;\n    for (let k = dir > 0 ? lo : hi; dir > 0 ? k \u003c= hi : k >= lo; k += dir) {\n      if (kStart \u003c 0) kStart = k;\n      sp.push(at(k, r)), sr.push(r);\n    }\n    kEnd = dir > 0 ? hi : lo;\n    dir = -dir;\n  }\n  if (sp.length) dir = -dir;\n  for (let q = 0, r = Rf; r >= FREE; q++, r = Rf - (GAP * q) / n) {\n    const k = (((kEnd + dir * q) % n) + n) % n;\n    if (kStart \u003c 0) kStart = k;\n    sp.push(at(k, r)), sr.push(r);\n  }\n  const kT = (hp.length + tp.length - 1) % n;\n  walk([tp[tp.length - 1], rad[kT].a], WALK, 4);\n  walk(frameWalk(rad[kT].s, rad[kStart].s), WALK, 4);\n  walk([rad[kStart].a, sp[0]], WALK, 4);\n  const sticky = thread(sp, sr, 1);\n  lay(sticky, STICKY, 4);\n  walk([sp[sp.length - 1], hub], WALK, 5);\n  Object.assign(S, { threads, moves, bridge, moor, temp, sticky, hub, BL, BR, mi: 0, ms: 0 });\n}\n\n// Jump to a share f of the way through a stage, everything before it built.\nfunction seek(S, stage, f) {\n  const { moves, threads } = S;\n  let total = 0;\n  for (const m of moves) if (m.stage === stage) total += m.p.len;\n  let left = f * total;\n  S.mi = moves.length;\n  for (let i = 0; i \u003c moves.length; i++) {\n    const m = moves[i];\n    if (m.stage \u003c stage || (m.stage === stage && left >= m.p.len && i \u003c moves.length - 1)) {\n      if (m.stage === stage) left -= m.p.len;\n      if (m.t >= 0) threads[m.t].shown = m.p.len;\n      continue;\n    }\n    S.mi = i;\n    S.ms = m.stage === stage ? left : 0;\n    if (m.t >= 0) threads[m.t].shown = S.ms;\n    break;\n  }\n  threads[S.bridge].shown = threads[S.bridge].p.len;\n  for (const m of S.moor) threads[m.t].shown = stage > 1 ? threads[m.t].p.len : 0;\n}\n\n// How far through its stage the build is, 0..1.\nfunction progress(S) {\n  const stage = S.moves[S.mi].stage;\n  let total = 0, done = 0;\n  S.moves.forEach((m, i) => {\n    if (m.stage !== stage) return;\n    total += m.p.len;\n    if (i \u003c S.mi) done += m.p.len;\n  });\n  return [stage, (done + S.ms) / (total || 1)];\n}\n\nexport function setup(params) {\n  params.s = {\n    col: 0, speed: 2, wind: 0.06, rt: 0, phase: \"build\", clock: 0, builtFor: -1, gust: 1,\n    T: new Float32Array(N), rgb: new Float32Array(N * 3), legs: new Float32Array(N), row: new Float32Array(H * 3),\n    pos: [0, 0, 0], heading: 0, gait: 0, frags: [], dew: [], fly: null, jit: [],\n  };\n  newJitter(params.s);\n}\n\nfunction newJitter(S) {\n  S.jit = Array.from({ length: 16 }, () => rnd(-1, 1));\n}\n\n// The gust: the web bellies out downwind, then breaks piece by piece from\n// the windward side, each piece flying off, tumbling, falling and fading.\nfunction gustOn(S, f, x) {\n  const side = S.gust > 0 ? x / 63 : 1 - x / 63, w = 1 + 1.5 * S.wind;\n  return Object.assign(f, { tb: 0.5 + 2.2 * side + rnd(0, 0.6), vx: S.gust * rnd(8, 22) * w, vy: rnd(-8, 2), om: rnd(-3, 3) });\n}\n\n// Where a piece is now: offset, turn and how much is left of it.\nfunction blown(S, f, x, y) {\n  const tau = S.clock - f.tb, belly = S.gust * (2 + 3 * S.wind) * sin(PI * cl(x / 63, 0, 1)) * sin(PI * cl(y / 127, 0, 1));\n  if (tau \u003c 0) return [belly * (S.clock / f.tb) ** 2, 0, 0, 1];\n  return [belly + f.vx * tau, f.vy * tau + 6 * tau * tau, f.om * tau, max(0, 1 - tau / 2.6)];\n}\n\nfunction startTear(S) {\n  S.dewOn = S.phase === \"dew\" ? 1 : 0;\n  S.phase = \"tear\";\n  S.clock = 0;\n  S.gust = Math.random() \u003c 0.5 ? -1 : 1;\n  const frags = [], cut = S.rCut;\n  for (const th of S.threads) {\n    const { xs, ys, r, cum } = th.p;\n    for (let i = 1; i \u003c xs.length && cum[i] \u003c= th.shown + 1e-6; i++) {\n      if (th === S.threads[S.temp] && r[i] > cut) continue;\n      const [ax, ay] = sway(S, xs[i - 1], ys[i - 1]), [bx, by] = sway(S, xs[i], ys[i]);\n      const cx = (ax + bx) / 2, cy = (ay + by) / 2;\n      frags.push(gustOn(S, { cx, cy, hx: (bx - ax) / 2, hy: (by - ay) / 2, a: th.a }, cx));\n    }\n  }\n  S.frags = frags;\n  for (const d of S.dew) gustOn(S, d, d.x);\n  S.fly = gustOn(S, { x: S.pos[0], y: S.pos[1] }, S.pos[0]);\n  S.fly.om = 5 * S.gust;\n}\n\n// Where the wind has pushed a point of the web: anchored at the panel's\n// edges, freest in the middle.\nfunction sway(S, x, y) {\n  const f = sin(PI * cl(x / 63, 0, 1)) ** 0.7 * sin(PI * cl(y / 127, 0, 1)) ** 0.7;\n  return [x + S.dx * f, y + S.dy * f];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 20, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.col = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[3], 0, 1);\n  const n = 20 + 2 * round((cl(k[2], 20, 44) - 20) / 2), sp = d * S.speed;\n  S.rt += d;\n  const A = 0.6 + 6 * S.wind;\n  S.dx = A * (0.65 * sin(0.8 * S.rt) + 0.35 * sin(2.1 * S.rt + 1.3));\n  S.dy = 0.3 * A * sin(1.3 * S.rt + 0.4);\n  if (S.builtFor !== n) {\n    // The first web opens with the spider at the rim, about to lay the\n    // sticky spiral; a new count respins the web at the same stage.\n    if (S.builtFor \u003c 0) {\n      plan(S, n);\n      seek(S, 4, 0);\n      while (S.moves[S.mi].t !== S.sticky) S.mi++;\n    } else if (S.phase === \"build\") {\n      const [stage, f] = progress(S);\n      plan(S, n);\n      seek(S, stage, f);\n    } else if (S.phase === \"dew\") plan(S, n), seek(S, 6, 0), makeDew(S);\n    else if (S.phase !== \"tear\") plan(S, n);\n    S.builtFor = n;\n  }\n  if (input.btnPressed && input.btnPressed[0] && (S.phase === \"build\" || S.phase === \"dew\" || S.phase === \"float\")) startTear(S);\n  S.clock += sp;\n  const pos = S.pos;\n  let moved = 0;\n  if (S.phase === \"float\") {\n    (pos[0] = S.BL[0] + 1.5), (pos[1] = S.BL[1] + 1), (pos[2] = 0);\n    if (S.clock >= FLOAT) (S.phase = \"build\"), (S.mi = 0), (S.ms = 0), (S.threads[S.bridge].shown = S.threads[S.bridge].p.len);\n  } else if (S.phase === \"build\") {\n    let m = S.moves[S.mi];\n    S.ms += m.v * sp;\n    moved = m.v * sp;\n    while (S.ms >= m.p.len) {\n      if (m.t >= 0) S.threads[m.t].shown = m.p.len;\n      S.ms -= m.p.len;\n      if (++S.mi >= S.moves.length) break;\n      m = S.moves[S.mi];\n    }\n    if (S.mi >= S.moves.length) {\n      S.phase = \"dew\";\n      S.clock = 0;\n      S.mi = S.moves.length - 1;\n      S.ms = m.p.len;\n      makeDew(S);\n    } else if (m.t >= 0) S.threads[m.t].shown = S.ms;\n    along(S.moves[S.mi].p, S.ms, pos);\n    for (const mo of S.moor) if (S.threads[mo.f].shown >= mo.s) S.threads[mo.t].shown = min(S.threads[mo.t].p.len, S.threads[mo.t].shown + 2 * LAY * sp);\n  } else if (S.phase === \"dew\") {\n    (pos[0] = S.hub[0]), (pos[1] = S.hub[1] + 1), (pos[2] = PI / 2);\n    if (S.clock >= DEWT) startTear(S);\n  } else if (S.phase === \"tear\") {\n    if (S.clock >= TEAR) {\n      newJitter(S);\n      plan(S, n);\n      S.phase = \"enter\";\n      S.clock = 0;\n      S.fly = null;\n    }\n  } else if (S.phase === \"enter\") {\n    const u = cl(S.clock / ENTER, 0, 1);\n    moved = (sp * 12) / ENTER;\n    (pos[0] = mix(-8, S.BL[0] + 1.5, u)), (pos[1] = S.BL[1] + 1), (pos[2] = 0);\n    if (u >= 1) (S.phase = \"float\"), (S.clock = 0);\n  }\n  // The temporary spiral is taken up as the sticky one passes over it.\n  const st = S.threads[S.sticky];\n  S.rCut = 1e9;\n  if (st.shown > 0) {\n    const { cum, r } = st.p;\n    let i = 0;\n    while (i \u003c cum.length - 1 && cum[i + 1] \u003c= st.shown) i++;\n    S.rCut = st.shown >= st.p.len ? 0 : r[i] - 0.5 * GAP;\n  }\n  // Heading eases round to the way the spider is going; the legs step with\n  // the distance it covers.\n  let dh = ((pos[2] - S.heading + 3 * PI) % TAU) - PI;\n  S.heading += dh * min(1, d * 14);\n  S.gait += moved * 0.9;\n}\n\nfunction makeDew(S) {\n  const p = S.threads[S.sticky].p, out = [0, 0, 0];\n  S.dew = [];\n  for (let s = rnd(1, 4); s \u003c p.len; s += rnd(3, 7)) {\n    along(p, s, out);\n    S.dew.push({ x: out[0], y: out[1], ph: rnd(0, TAU), w: rnd(1.2, 3.2), on: rnd(0, 6) });\n  }\n}\n\n// --- drawing ---\n\nfunction plot(buf, x, y, c) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || c \u003c= 0) return;\n  const o = y * W + x;\n  if (c > buf[o]) buf[o] = c;\n}\n\n// Xiaolin Wu's antialiased line, one LED wide, keeping the most at each LED.\nfunction wu(buf, x0, y0, x1, y1, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  if (steep) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x0 > x1) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const dx = x1 - x0, g = dx \u003c 1e-9 ? 0 : (y1 - y0) / dx;\n  const xs = round(x0), xe = round(x1);\n  let yy = y0 + g * (xs - x0);\n  for (let x = xs; x \u003c= xe; x++, yy += g) {\n    const yi = floor(yy), f = yy - yi;\n    if (steep) plot(buf, yi, x, (1 - f) * a), plot(buf, yi + 1, x, f * a);\n    else plot(buf, x, yi, (1 - f) * a), plot(buf, x, yi + 1, f * a);\n  }\n}\n\nfunction silk(S) {\n  const h = (S.col - floor(S.col)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  return [0, 1, 2].map((c) => mix(SILK[i][c], SILK[j][c], s));\n}\n\n// The spider: abdomen behind, head in front, four legs a side that step as\n// it walks. Heading hd points the way the head faces.\nfunction drawSpider(S, x, y, hd) {\n  const { rgb, legs } = S, fx = cos(hd), fy = sin(hd), sx = -fy, sy = fx;\n  const x0 = max(0, floor(x - 9)), x1 = min(W - 1, floor(x + 9)), y0 = max(0, floor(y - 9)), y1 = min(H - 1, floor(y + 9));\n  for (let yy = y0; yy \u003c= y1; yy++) legs.fill(0, yy * W + x0, yy * W + x1 + 1);\n  const hx = x + 1.3 * fx, hy = y + 1.3 * fy;\n  const base = [0.55, 1.15, 1.95, 2.55];\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let k = 0; k \u003c 4; k++) {\n      const a = base[k] + 0.22 * sin(S.gait + k * 1.7 + (side > 0 ? PI : 0));\n      const ca = cos(a), sa = side * sin(a), cb = 2.6 * cos(a * 0.9) + (k \u003c 2 ? 0.8 : -0.8), sb = 2.6 * side * sin(a * 0.9);\n      const rx = hx - 0.3 * k * fx, ry = hy - 0.3 * k * fy;\n      const kx = rx + (ca * fx + sa * sx) * 3, ky = ry + (ca * fy + sa * sy) * 3, lx = kx + cb * fx + sb * sx, ly = ky + cb * fy + sb * sy;\n      wu(legs, rx, ry, kx, ky, 1);\n      wu(legs, kx, ky, lx, ly, 0.9);\n    }\n  for (let yy = y0; yy \u003c= y1; yy++)\n    for (let xx = x0; xx \u003c= x1; xx++) {\n      const o = yy * W + xx, a = legs[o];\n      if (a > 0.08) for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] = mix(rgb[o * 3 + c], LEG[c], min(1, a * 1.3));\n    }\n  // Abdomen with the orange cross, head orange.\n  const blob = (cx, cy, ra, rb, cross) => {\n    for (let yy = max(0, floor(cy - 4)); yy \u003c= min(H - 1, floor(cy + 4)); yy++)\n      for (let xx = max(0, floor(cx - 4)); xx \u003c= min(W - 1, floor(cx + 4)); xx++) {\n        const px = xx - cx, py = yy - cy, u = px * fx + py * fy, v = px * sx + py * sy;\n        const q = sqrt((u / ra) ** 2 + (v / rb) ** 2), a = cl((1 - q) * min(ra, rb) + 0.6, 0, 1);\n        if (a \u003c= 0) continue;\n        const o = (yy * W + xx) * 3, mark = cross === 2 || (cross === 1 && q \u003c 0.75 && (abs(v) \u003c 0.6 || abs(u + 0.3) \u003c 0.6));\n        const col = mark ? MARK : BODY, sh = 1 - 0.3 * cl(q, 0, 1);\n        for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(rgb[o + c], col[c] * sh, a);\n      }\n  };\n  blob(x - 1.9 * fx, y - 1.9 * fy, 2.7, 2.2, 1);\n  blob(hx, hy, 1.4, 1.2, 2);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.threads) return;\n  const { T, rgb, row } = S;\n  T.fill(0);\n  rgb.fill(0);\n  const tear = S.phase === \"tear\", dew = S.phase === \"dew\" ? cl(S.clock / 3, 0, 1) : 0;\n  if (tear) {\n    for (const f of S.frags) {\n      const [ox, oy, an, left] = blown(S, f, f.cx, f.cy), c = cos(an), s = sin(an);\n      const cx = f.cx + ox, cy = f.cy + oy, hx = f.hx * c - f.hy * s, hy = f.hx * s + f.hy * c;\n      if (left > 0.02) wu(T, cx - hx, cy - hy, cx + hx, cy + hy, f.a * left);\n    }\n  } else if (S.phase !== \"enter\") {\n    for (let ti = 0; ti \u003c S.threads.length; ti++) {\n      const th = S.threads[ti];\n      if (th.shown \u003c= 0) continue;\n      if (ti === S.bridge && S.phase === \"float\") continue;\n      // Silk just laid shines, fading over the 60 LEDs behind the spider.\n      const { xs, ys, r, cum } = th.p, temp = ti === S.temp, fresh = S.phase === \"build\" && S.moves[S.mi].t === ti;\n      let [ax, ay] = sway(S, xs[0], ys[0]);\n      for (let i = 1; i \u003c xs.length; i++) {\n        if (cum[i - 1] >= th.shown) break;\n        let bx = xs[i], by = ys[i];\n        if (cum[i] > th.shown) {\n          const f = (th.shown - cum[i - 1]) / (cum[i] - cum[i - 1]);\n          bx = mix(xs[i - 1], xs[i], f);\n          by = mix(ys[i - 1], ys[i], f);\n        }\n        const [px, py] = sway(S, bx, by);\n        const glow = fresh ? 1 + 0.9 * cl(1 - (th.shown - cum[i]) / 60, 0, 1) : 1;\n        if (!temp || r[i] \u003c= S.rCut) wu(T, ax, ay, px, py, th.a * glow);\n        ax = px;\n        ay = py;\n      }\n    }\n    if (S.phase === \"float\") {\n      // The bridge line drifting out on the breeze from the left anchor, its\n      // free end fluttering, until it snags on the far side.\n      const u = cl(S.clock / FLOAT, 0, 1), e = u * u * (3 - 2 * u), A = 1.5 + 5 * S.wind;\n      const ex = mix(S.BL[0], S.BR[0], e), ey = mix(S.BL[1], S.BR[1], e) + A * sin(S.rt * 5) * (1 - e) + 4 * (1 - e) * e;\n      let px = S.BL[0], py = S.BL[1];\n      for (let k = 1; k \u003c= 16; k++) {\n        const t = k / 16, qx = mix(S.BL[0], ex, t), qy = mix(S.BL[1], ey, t) + (6 * (1 - e) + 1) * sin(PI * t) * (0.7 + 0.3 * sin(S.rt * 3 + t * 4));\n        wu(T, px, py, qx, qy, 0.85);\n        (px = qx), (py = qy);\n      }\n    }\n  }\n  // Silk lit from below: brighter and warmer toward the bottom row. When\n  // the web is done a band of light climbs it, catching the dew.\n  const sk = silk(S), band = 135 - ((S.clock * 20) % 180);\n  for (let y = 0; y \u003c H; y++) {\n    const v = y / 127, lit = 0.42 + 0.58 * v ** 1.2, warm = 0.3 * v * v;\n    const sh = 1 + 0.8 * dew * exp(-(((y - band) / 9) ** 2));\n    row[y * 3] = mix(sk[0], 1, warm) * lit * sh;\n    row[y * 3 + 1] = mix(sk[1], 0.72, warm) * lit * sh;\n    row[y * 3 + 2] = mix(sk[2], 0.42, warm) * lit * sh;\n  }\n  for (let o = 0; o \u003c N; o++) {\n    const t = T[o];\n    if (t \u003c= 0) continue;\n    const y3 = floor(o / W) * 3;\n    rgb[o * 3] = row[y3] * t;\n    rgb[o * 3 + 1] = row[y3 + 1] * t;\n    rgb[o * 3 + 2] = row[y3 + 2] * t;\n  }\n  // Dew: orange beads along the sticky spiral that gather over the first\n  // three seconds, each glinting now and then and all flaring pale gold as\n  // the band of light climbs past.\n  if (dew > 0)\n    for (const dd of S.dew) {\n      const [x, y] = sway(S, dd.x, dd.y), xi = round(x), yi = round(y);\n      if (xi \u003c 0 || xi >= W || yi \u003c 0 || yi >= H) continue;\n      const on = cl((S.clock - dd.on) / 1.5, 0, 1);\n      if (on \u003c= 0) continue;\n      const tw = (0.5 + 0.5 * sin(S.rt * dd.w + dd.ph)) ** 8, b = min(1, max(tw, exp(-(((y - band) / 7) ** 2))));\n      const v = on * (0.62 + 0.38 * b), o = yi * W + xi;\n      for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] = mix(DEW[c], GLINT[c], b * b) * v;\n      if (b > 0.4)\n        for (const q of [o - 1, o + 1, o - W, o + W])\n          if (q >= 0 && q \u003c N && abs((q % W) - xi) \u003c= 1) for (let c = 0; c \u003c 3; c++) rgb[q * 3 + c] = max(rgb[q * 3 + c], DEW[c] * on * (b - 0.4));\n    }\n  if (tear && S.dewOn)\n    for (const dd of S.dew) {\n      const [ox, oy, , left] = blown(S, dd, dd.x, dd.y), xi = round(dd.x + ox), yi = round(dd.y + oy);\n      if (left > 0.05 && xi >= 0 && xi \u003c W && yi >= 0 && yi \u003c H) for (let c = 0; c \u003c 3; c++) rgb[(yi * W + xi) * 3 + c] = DEW[c] * left;\n    }\n  if (!tear) drawSpider(S, ...sway(S, S.pos[0], S.pos[1]), S.heading);\n  else if (S.fly) {\n    const f = S.fly, [ox, oy, an] = blown(S, f, f.x, f.y);\n    drawSpider(S, f.x + ox, f.y + oy, S.heading + an);\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","runge-phenomenon":"// ===== Patternflow pattern =====\n// Title:   Runge Phenomenon\n// Family:  wave\n// Idea:    The bump 1/(1 + 25x²) stands up the panel with its interpolation nodes as beads on it, and as equally spaced nodes multiply from 3 to 21 the polynomial through them throws pink and gold lobes from edge to edge at the top and bottom, until the beads slide to Chebyshev's places and the curve lies down on the bump, while a violet glow behind shows where the nodes leave room for error.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Runge's phenomenon (Carl Runge, 1901), with Chebyshev nodes, pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Nodes=21..41, Chebyshev=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the bump is azure, the lobes where the polynomial overshoots it pink and where it falls short gold, the curve white and the beads pale gold; at 0.25 the bump is violet with yellow and green lobes. The dim bump never takes red, orange or yellow, which read maroon, brown and olive: from 0.35 to 0.53 it is crimson and from 0.53 to 0.72 green, while the lobes keep turning.\n// Knob 2: Speed. At 2 one round takes 17.5 seconds: 7 to climb from 3 nodes to the most, 1.2 held, 3 sliding to Chebyshev's nodes, 1.3 held, 3.5 back down to 3 and 1.5 sliding home. At 0.2 a round takes 175 seconds, at 3 about 11.7.\n// Knob 3: Nodes, the most the climb reaches, odd counts from 21 to 41. At 21 the worst error is 59.8 where the bump is 1 tall, at 31 it is 2,388 and at 41 about 105,000. The lobes that run off the panel's edge reach in 11 rows from each end at 21 nodes and 14 at 41, as thinner bars, and the climb goes 2.1 times as fast.\n// Knob 4: Chebyshev. Where the nodes sit while they climb, from equally spaced to Chebyshev's. Up to 0.06 equally spaced exactly; at 0.5 nearly halfway, the worst error 1.6 at 21 nodes and 44 at 41; at 0.75 about 0.15 at any count; at 1 Chebyshev's all along, the curve never more than 0.6 off the bump (at 3 nodes) and 0.015 at 21, so the lobes never come and the beads and the glow do the moving.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Runge's function: 1 in the middle, 1/26 at the ends.\nconst A = 25;\nconst runge = (x) => 1 / (1 + A * x * x);\n\n// The interval stands up the panel: x = -1 at the centre of row 2, x = 1 at\n// the centre of row 125, so the end beads fit.\nconst YA = 2.5, YB = 125.5;\nconst toX = (py) => -1 + (2 * (py - YA)) / (YB - YA);\nconst toY = (x) => YA + ((x + 1) * (YB - YA)) / 2;\n// A value v sits at column C0 + SC v: the bump's foot at column 16.5, its top\n// at 52.5. Past -0.4 and 1.15 the scale squeezes into the last LEDs, so a\n// lobe of 2 and a lobe of 60 both reach the edge and still differ there.\nconst C0 = 16.5, SC = 36, VL = -0.4, VH = 1.15;\nfunction col(v) {\n  if (v > VH) return C0 + SC * VH + 5.6 * (1 - exp(-(v - VH) / 0.7));\n  if (v \u003c VL) return C0 + SC * VL - 2.8 * (1 - exp((v - VL) / 0.7));\n  return C0 + SC * v;\n}\n\n// The round, in units that pass at one a second at Speed 2.\nconst T_CLIMB = 7, T_WILD = 1.2, T_SETTLE = 3, T_CALM = 1.3, T_DOWN = 3.5, T_HOME = 1.5;\nconst T_ROUND = T_CLIMB + T_WILD + T_SETTLE + T_CALM + T_DOWN + T_HOME;\nconst NMAX = 41, SUB = 4;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, top: 21, base: 0, tau: 0,\n    // Up to three node sets in play: the one sliding, or the old set at its\n    // new places and the new set it is blending into.\n    sets: [0, 1].map(() => ({ X: new Float64Array(NMAX + 2), w: new Float64Array(NMAX + 2), F: new Float64Array(NMAX + 2), n: 0, k: 0 })),\n    nsets: 1,\n    dots: new Float64Array((NMAX + 2) * 3), ndots: 0,\n    pc: new Float64Array(SUB), fc: new Float64Array(SUB), om: new Float64Array(H),\n    col: new Float32Array(8 * 3), colHue: NaN,\n    tmpA: new Float64Array(NMAX + 2), tmpB: new Float64Array(NMAX + 2),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 21, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // Odd counts only: every set then has a node at 0 and the picture is the\n  // same at the top and the bottom.\n  S.top = 2 * round((cl(k[2], 21, 41) - 1) / 2) + 1;\n  // Up to 0.06 the nodes are equally spaced exactly.\n  S.base = max(0, cl(k[3], 0, 1) - 0.06) / 0.94;\n  S.tau = (S.tau + d * S.speed * 0.5) % T_ROUND;\n}\n\n// n nodes, sorted, a fraction c of the way from equally spaced to\n// Chebyshev's, cos((2k + 1) pi / 2n).\nfunction nodes(n, c, out) {\n  for (let k = 0; k \u003c n; k++) {\n    const e = -1 + (2 * k) / (n - 1), ch = -cos(((2 * k + 1) * PI) / (2 * n));\n    out[k] = e + (ch - e) * c;\n  }\n}\n\n// Barycentric weights w_j = 1 / prod (x_j - x_k), scaled to a largest of 1.\n// With them p(x) = sum w_j f_j / (x - x_j) / sum w_j / (x - x_j), the second\n// barycentric form (Berrut and Trefethen, 2004), stable for any nodes.\nfunction prepare(set, X, n, weight) {\n  let big = 0;\n  for (let j = 0; j \u003c n; j++) {\n    let p = 1;\n    for (let k = 0; k \u003c n; k++) if (k !== j) p *= X[j] - X[k];\n    set.X[j] = X[j];\n    set.F[j] = runge(X[j]);\n    set.w[j] = 1 / p;\n    big = max(big, abs(set.w[j]));\n  }\n  for (let j = 0; j \u003c n; j++) set.w[j] /= big;\n  set.n = n;\n  set.k = weight;\n}\n\nfunction bary(set, x) {\n  const { X, w, F, n } = set;\n  let num = 0, den = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const d = x - X[j];\n    if (d === 0) return F[j];\n    const t = w[j] / d;\n    num += t * F[j];\n    den += t;\n  }\n  return num / den;\n}\n\n// Where the round is: the node level m (n = 2m + 1) with the step's progress\n// u, and how far the nodes are toward Chebyshev's.\nfunction stage(S) {\n  const M = (S.top - 1) / 2, b = S.base;\n  let t = S.tau;\n  if (t \u003c T_CLIMB) return [1 + (M - 1) * (t / T_CLIMB), b];\n  t -= T_CLIMB;\n  if (t \u003c T_WILD) return [M, b];\n  t -= T_WILD;\n  if (t \u003c T_SETTLE) return [M, mix(b, 1, sm(t / T_SETTLE))];\n  t -= T_SETTLE;\n  if (t \u003c T_CALM) return [M, 1];\n  t -= T_CALM;\n  if (t \u003c T_DOWN) return [M - (M - 1) * (t / T_DOWN), 1];\n  t -= T_DOWN;\n  return [1, mix(1, b, sm(t / T_HOME))];\n}\n\n// Build the node sets and the beads for this frame. Going from n to n + 2\n// nodes takes two halves: first the n nodes spread to their places in the\n// new set, the curve through them all the way; then the two new nodes beside\n// the middle one grow in and the curve blends to the one through all n + 2.\nfunction build(S) {\n  const [lv, c] = stage(S);\n  let m = floor(lv), u = lv - m;\n  if (m >= (S.top - 1) / 2) (m = (S.top - 1) / 2), (u = 0);\n  const n = 2 * m + 1, OLD = S.tmpA, NEW = S.tmpB;\n  nodes(n, c, OLD);\n  if (u === 0) {\n    prepare(S.sets[0], OLD, n, 1);\n    S.nsets = 1;\n    for (let k = 0; k \u003c n; k++) setDot(S, k, OLD[k], 1);\n    S.ndots = n;\n    return;\n  }\n  nodes(n + 2, c, NEW);\n  // Old node k goes to new k below the middle, the middle to the middle, and\n  // the rest two places on: new m and m + 2 are the ones born.\n  const to = (k) => (k \u003c m ? k : k === m ? m + 1 : k + 2);\n  if (u \u003c 0.5) {\n    const e = sm(u / 0.5);\n    for (let k = 0; k \u003c n; k++) OLD[k] = mix(OLD[k], NEW[to(k)], e);\n    prepare(S.sets[0], OLD, n, 1);\n    S.nsets = 1;\n    for (let k = 0; k \u003c n; k++) setDot(S, k, OLD[k], 1);\n    S.ndots = n;\n    return;\n  }\n  const e = sm((u - 0.5) / 0.5);\n  for (let k = 0; k \u003c n; k++) OLD[k] = NEW[to(k)];\n  prepare(S.sets[0], OLD, n, 1 - e);\n  prepare(S.sets[1], NEW, n + 2, e);\n  S.nsets = 2;\n  for (let k = 0; k \u003c n + 2; k++) setDot(S, k, NEW[k], k === m || k === m + 2 ? e : 1);\n  S.ndots = n + 2;\n}\n\nfunction setDot(S, k, x, size) {\n  S.dots[3 * k] = col(runge(x));\n  S.dots[3 * k + 1] = toY(x);\n  S.dots[3 * k + 2] = size;\n}\n\n// The bump's hue, which skips red, orange and yellow: dim, those read\n// maroon, brown and olive on the panel. A hue from -0.07 to 0.3 takes the\n// nearer end, crimson-pink or green, so the bump jumps between the two.\nfunction bumpHue(h) {\n  let f = h - floor(h);\n  if (f >= 0.93) f -= 1;\n  if (f >= 0.3) return f;\n  return f \u003c 0.11 ? 0.93 : 0.3;\n}\n\nfunction palette(S) {\n  const c = S.col, h = S.hue, hb = bumpHue(h + 0.58);\n  // 0 the bump, 1 its edge, 2 overshoot lobes, 3 short lobes, 4 the curve,\n  // 5 the beads, 6 the axis, 7 the glow of the node polynomial.\n  hsv(hb, 0.85, 0.3, c, 0);\n  hsv(hb, 0.55, 0.8, c, 3);\n  hsv(h + 0.9, 0.8, 1, c, 6);\n  hsv(h + 0.13, 0.85, 1, c, 9);\n  hsv(hb, 0.12, 1, c, 12);\n  hsv(h + 0.13, 0.35, 1, c, 15);\n  hsv(hb, 0.5, 0.16, c, 18);\n  hsv(0.72, 0.6, 0.24, c, 21);\n  S.colHue = h;\n}\n\n// The node polynomial (x - x_1) ... (x - x_n), the factor the error carries\n// whatever the function: log10 of its size, the largest in each row, blended\n// like the curve. Equally spaced, it is 54,000 times bigger at the ends than\n// in the middle at 21 nodes; Chebyshev's, the same in every gap.\nfunction omega(S) {\n  const { sets, nsets, om } = S;\n  let top = -1e9;\n  for (let y = 0; y \u003c H; y++) {\n    let L = 0;\n    for (let s = 0; s \u003c nsets; s++) {\n      const { X, n, k } = sets[s];\n      if (k \u003c= 0) continue;\n      let best = -1e9;\n      for (let i = 0; i \u003c SUB; i++) {\n        const x = cl(toX(y + (i + 0.5) / SUB), -1, 1);\n        let p = 1;\n        for (let j = 0; j \u003c n; j++) p *= x - X[j];\n        best = max(best, Math.log10(abs(p) + 1e-300));\n      }\n      L += k * best;\n    }\n    om[y] = L;\n    top = max(top, L);\n  }\n  for (let y = 0; y \u003c H; y++) om[y] = cl(1 + (om[y] - top) / 5, 0, 1) ** 1.5;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  build(S);\n  omega(S);\n  const { sets, nsets, pc, fc, dots, ndots, om } = S, c = S.col;\n  const axis = floor(C0);\n  for (let y = 0; y \u003c H; y++) {\n    // The curve and the bump at four heights inside the row, so a lobe\n    // that crosses the panel in one row is drawn whole.\n    let pLo = 1e9, pHi = -1e9, bLo = 1e9, bHi = -1e9;\n    const inside = y + 1 > YA - 0.5 && y \u003c YB + 0.5;\n    if (inside)\n      for (let i = 0; i \u003c SUB; i++) {\n        const x = cl(toX(y + (i + 0.5) / SUB), -1, 1);\n        let p = 0;\n        for (let s = 0; s \u003c nsets; s++) if (sets[s].k > 0) p += sets[s].k * bary(sets[s], x);\n        pc[i] = col(p);\n        fc[i] = col(runge(x));\n        pLo = min(pLo, pc[i]);\n        pHi = max(pHi, pc[i]);\n        bLo = min(bLo, pc[i], fc[i]);\n        bHi = max(bHi, pc[i], fc[i]);\n      }\n    const fRow = col(runge(cl(toX(y + 0.5), -1, 1)));\n    for (let x = 0; x \u003c W; x++) {\n      const X = x + 0.5;\n      let o = -1;\n      if (inside) {\n        if (X >= pLo - 0.9 && X \u003c= pHi + 0.9) o = 12;\n        else if (X >= bLo && X \u003c= bHi && abs(X - fRow) > 0.6) o = X > fRow ? 6 : 9;\n        else if (abs(X - fRow) \u003c 0.75) o = 3;\n        else if (X > C0 && X \u003c fRow) o = 0;\n      }\n      if (o \u003c 0 && x === axis) o = 18;\n      if (o \u003c 0) {\n        // Behind everything, the node polynomial's glow.\n        const g = inside ? om[y] : 0;\n        display.setPixel(x, y, round(255 * c[21] * g), round(255 * c[22] * g), round(255 * c[23] * g));\n      }\n      else display.setPixel(x, y, round(255 * c[o]), round(255 * c[o + 1]), round(255 * c[o + 2]));\n    }\n  }\n  // The beads, each in a dark ring so the curve threads through it.\n  for (let k = 0; k \u003c ndots; k++) {\n    const bx = dots[3 * k], by = dots[3 * k + 1], sz = dots[3 * k + 2];\n    if (sz \u003c= 0.02) continue;\n    const r = 1.75 * sz, ring = r + 0.9;\n    for (let yy = max(0, floor(by - ring)); yy \u003c= min(H - 1, floor(by + ring)); yy++)\n      for (let xx = max(0, floor(bx - ring)); xx \u003c= min(W - 1, floor(bx + ring)); xx++) {\n        const dx = xx + 0.5 - bx, dy = yy + 0.5 - by, d = Math.sqrt(dx * dx + dy * dy);\n        if (d \u003c r) display.setPixel(xx, yy, round(255 * c[15]), round(255 * c[16]), round(255 * c[17]));\n        else if (d \u003c ring) display.setPixel(xx, yy, 0, 0, 0);\n      }\n  }\n}\n","scarecrow-crows":"// ===== Patternflow pattern =====\n// Title:   Scarecrow Crows\n// Family:  halloween\n// Idea:    A black scarecrow with a straw hat and a stitched sack face sways on its pole against a big low moon in a dusk sky, crows fly in and land on its arms and hat, hop, turn, stretch and caw, and when its head twitches round they all burst off flapping, circle above it and come back one by one, the ones that find it full pecking along the glowing horizon.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the scarecrows and crows of Halloween fields\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Crows=8..20, Nerves=0..1\n//\n// Knob 1: Colour. Three skies round the knob: at 0 a pale gold moon in a sky going from violet at the top through rose to orange at the horizon; at 0.33 a toxic green moon in a purple sky over a green glow; at 0.67 a cold white moon in a blue night. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 the first twitch comes at 3.4 seconds, the crows climb for 0.7 of a second, circle 2 to 6 seconds and take 1.5 seconds to land (0.9 to 2.8); at 0.2 everything is ten times slower, at 3 one and a half times faster.\n// Knob 3: Crows, 8 to 20. There are seven places on the scarecrow, two on each arm, the crown of the hat and the two ends of its brim, and six on the ground along the horizon; at 8 one crow is left for the ground, at 20 six peck there and seven keep circling. At the start 0.45 of them are already perched, 4 of 8 and 9 of 20.\n// Knob 4: Nerves. How jumpy the scarecrow is. At 0.06 the head twitches round every 11.5 seconds on average and a crow spends 41% of its time perched; at 1 every 3 seconds, and the crows hardly ever get to land. The twitch turns the face 0.67 of the way to its side at 0.06 and all the way at 1, and from 0.3 the head keeps glancing about between twitches.\n// Buttons: K1 tap twitches the head at once and every perched crow bursts off.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, round, atan2, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// The horizon, the moon, the scarecrow's neck, and the row its pole sways\n// about, in the ground below the horizon.\nconst HZ = 101, MX = 32, MY = 61, MR = 26, NX = 32, NY = 50, BASE = 118;\n// Crows are drawn this many times their unit size: 14 LEDs beak to tail\n// sitting, and a little bigger in the air, where the wings spread.\nconst K = 1.2, KF = 1.45;\n// Skies, cycled by K1: sky at the top, in the middle, low down and at the\n// horizon; the moon, its seas, and the dim field.\nconst PAL = [\n  [[104, 40, 168], [196, 62, 142], [246, 100, 58], [255, 182, 74], [255, 206, 104], [236, 168, 72], [24, 8, 30]],\n  [[70, 30, 140], [128, 46, 172], [150, 70, 176], [130, 236, 92], [176, 255, 96], [134, 218, 64], [10, 22, 14]],\n  [[40, 52, 142], [62, 92, 192], [106, 128, 222], [196, 172, 244], [240, 240, 222], [202, 204, 196], [10, 12, 32]],\n];\n// Places to land: two on each arm, the crown of the hat and the brim's ends.\n// Feet at (x, y); arm places dip with their arm, hat places turn with the\n// head.\nconst SLOTS = [\n  { x: 6.5, y: 54.4, arm: -1 }, { x: 18, y: 54.4, arm: -1 },\n  { x: 46, y: 54.4, arm: 1 }, { x: 57.5, y: 54.4, arm: 1 },\n  { x: 32, y: 21.8, arm: 0 }, { x: 18.6, y: 33.3, arm: 0, out: -1 }, { x: 45.4, y: 33.3, arm: 0, out: 1 },\n  // And six on the ground along the horizon, against its glow, for the\n  // crows that find the scarecrow full; they peck.\n  ...[5, 14, 23, 42, 51, 59].map((x) => ({ x, y: HZ, arm: 0, ground: true })),\n];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, count: 8, nerves: 0.06,\n    // The head: how far it is turned (-1 left, 1 right), where it is going,\n    // and how long it holds there; the shudder of a twitch; the sway.\n    turn: 0, turnTo: 0, hold: 0, glance: 2, jolt: 0, sway: 0, next: -1, started: false,\n    // Each arm's dip when a crow lands on it: a damped spring.\n    dip: [0, 0], dipV: [0, 0],\n    crows: [], bg: new Uint8Array(N * 3), bgHue: NaN, m: new Uint8Array(N),\n  };\n}\n\nfunction newCrow(i) {\n  return {\n    i, st: \"circle\", x: 32, y: 30, vx: 0, vy: 0, face: 1, slot: -1, flap: Math.random() * TAU,\n    beak: 0, cawT: 0, hop: 0, hopT: -1, flip: false, wing: 0, stretchT: 0, peck: 0, peckT: 0, act: rnd(0.4, 1.5),\n    circ: 0, ang: Math.random() * TAU, dir: Math.random() \u003c 0.5 ? -1 : 1, rx: rnd(16, 31), ry: rnd(6, 13), cy: rnd(12, 22), wait: rnd(2, 6), delay: 0,\n  };\n}\n\n// The opening: 0.45 of the crows already perched, 4 of 8, the rest in the\n// air coming down one by one.\nfunction start(S) {\n  S.crows = [];\n  for (let i = 0; i \u003c 20; i++) S.crows.push(newCrow(i));\n  const first = [1, 2, 4, 6, 0, 3, 5, 8, 11, 9];\n  const n0 = round(S.count * 0.45);\n  for (let i = 0; i \u003c n0; i++) perch(S, S.crows[i], first[i], i & 1 ? -1 : 1, false);\n  for (let i = n0; i \u003c 20; i++) {\n    const c = S.crows[i];\n    c.ang = (i * 2.3) % TAU;\n    c.x = NX + c.rx * cos(c.ang);\n    c.y = c.cy + c.ry * sin(c.ang);\n    c.wait = 0.3 + (i - n0) * 0.8;\n  }\n  S.started = true;\n}\n\nfunction perch(S, c, slot, face, bounce) {\n  c.st = \"perch\";\n  c.slot = slot;\n  // On a brim end a crow faces out, or it is lost against the crown.\n  c.face = SLOTS[slot].out || face;\n  c.vx = c.vy = 0;\n  c.act = rnd(0.3, 1.2);\n  const arm = SLOTS[slot].arm;\n  if (bounce && arm) S.dipV[arm > 0 ? 1 : 0] += 9;\n}\n\n// Every point of the scarecrow goes through here: the sway leans it about\n// row BASE, and a twitch shudders it.\nfunction body(S, x, y, out) {\n  out[0] = x + S.sway * (BASE - y);\n  out[1] = y + S.jolt;\n}\n\n// A point of an arm, dipping more the further it is from the shoulder.\nfunction armPoint(S, x, y, out) {\n  const side = x \u003c NX ? 0 : 1, reach = cl((abs(x - NX) - 8) / 22, 0, 1.2);\n  body(S, x, y + S.dip[side] * reach, out);\n}\n\n// A point of the head or hat, tilted and shifted with the turn.\nfunction headPoint(S, x, y, out) {\n  const a = 0.15 * S.turn, c = cos(a), s = sin(a), dx = x - NX, dy = y - NY;\n  body(S, NX + 1.4 * S.turn + dx * c - dy * s, NY + dx * s + dy * c, out);\n}\n\nfunction slotPos(S, k, out) {\n  const s = SLOTS[k];\n  if (s.ground) (out[0] = s.x), (out[1] = s.y);\n  else if (s.arm) armPoint(S, s.x, s.y, out);\n  else headPoint(S, s.x, s.y, out);\n}\n\nfunction twitch(S) {\n  S.turnTo = (Math.random() \u003c 0.5 ? -1 : 1) * (0.65 + 0.35 * S.nerves);\n  S.hold = rnd(0.7, 1.2);\n  S.jolt = -1.6;\n  for (const c of S.crows) {\n    if (c.i >= S.count) continue;\n    if (c.st === \"perch\" || c.st === \"land\") {\n      c.delay = c.st === \"land\" ? 0 : rnd(0, 0.25);\n      c.st = \"flee\";\n      c.slot = -1;\n      c.circ = 0;\n    }\n    // Back one by one: each circles 2 to 6 seconds before it tries to land.\n    c.wait = max(c.wait, rnd(2, 6));\n  }\n}\n\nconst P = [0, 0];\n\nfunction stepPerched(S, c, d) {\n  // On the scarecrow: now and then a hop, a turn, a stretch or a caw.\n  c.act -= d;\n  if (c.hopT >= 0) {\n    c.hopT += d;\n    const u = c.hopT / 0.4;\n    c.hop = 3.4 * 4 * u * (1 - u);\n    c.wing = sin(PI * cl(u, 0, 1)) * 0.9;\n    if (u > 0.5 && c.flip) (c.face = -c.face), (c.flip = false);\n    if (u >= 1) (c.hopT = -1), (c.hop = 0), (c.wing = 0);\n  }\n  if (c.stretchT > 0) {\n    c.stretchT -= d;\n    c.wing = sin(PI * cl(1 - c.stretchT / 0.8, 0, 1));\n    if (c.stretchT \u003c= 0) c.wing = 0;\n  }\n  if (c.cawT > 0) {\n    c.cawT -= d;\n    c.beak = sin(((0.9 - c.cawT) / 0.45) * PI) > 0.2 ? 1 : 0;\n    if (c.cawT \u003c= 0) c.beak = 0;\n  }\n  if (c.peckT > 0) {\n    // Two jabs at the ground in 0.7 of a second.\n    c.peckT -= d;\n    c.peck = max(0, sin(((0.7 - c.peckT) / 0.35) * PI));\n    if (c.peckT \u003c= 0) c.peck = 0;\n  }\n  if (c.act \u003c= 0 && c.hopT \u003c 0 && c.cawT \u003c= 0 && c.stretchT \u003c= 0 && c.peckT \u003c= 0) {\n    const r = Math.random();\n    const fixed = !!SLOTS[c.slot].out;\n    if (SLOTS[c.slot].ground && r \u003c 0.5) c.peckT = 0.7;\n    else if (r \u003c 0.35) (c.hopT = 0), (c.flip = !fixed && Math.random() \u003c 0.6);\n    else if (r \u003c 0.55 && !fixed) c.face = -c.face;\n    else if (r \u003c 0.75) c.stretchT = 0.8;\n    else c.cawT = 0.9;\n    c.act = rnd(0.4, 1.6);\n  }\n  slotPos(S, c.slot, P);\n  c.x = P[0];\n  c.y = P[1] - c.hop;\n}\n\nfunction stepCrow(S, c, d) {\n  c.flap += d * (c.st === \"flee\" ? 38 : 25);\n  if (c.st === \"perch\") return stepPerched(S, c, d);\n  if (c.st === \"flee\") {\n    // Burst off: up and away from the head, wings going hard.\n    if (c.delay > 0) {\n      c.delay -= d;\n      return;\n    }\n    if (c.circ === 0) {\n      const away = c.x \u003c NX ? -1 : 1;\n      c.vx = away * rnd(16, 30);\n      c.vy = -rnd(26, 40);\n      c.beak = c.hop = c.wing = c.peck = 0;\n      c.hopT = -1;\n      c.stretchT = c.cawT = c.peckT = 0;\n    }\n    c.circ += d;\n    c.vy += 22 * d;\n    c.x += c.vx * d;\n    c.y += c.vy * d;\n    c.face = c.vx >= 0 ? 1 : -1;\n    if (c.circ > 0.7) {\n      // Join its own ellipse where it is, going round the way it flies.\n      c.st = \"circle\";\n      c.ang = atan2((c.y - c.cy) / c.ry, (c.x - NX) / c.rx);\n      c.dir = -sin(c.ang) * c.vx >= 0 ? 1 : -1;\n    }\n    return;\n  }\n  if (c.st === \"circle\") {\n    // Round and round above the scarecrow, each on an ellipse of its own;\n    // when its time is up and a place is free, come in to land.\n    c.ang += d * c.dir * (24 / ((c.rx + c.ry) / 2));\n    steer(c, NX + c.rx * cos(c.ang), c.cy + c.ry * sin(c.ang), 34, d, 3);\n    c.wait -= d;\n    if (c.wait \u003c= 0) {\n      const k = freeSlot(S, c);\n      if (k >= 0) (c.st = \"land\"), (c.slot = k);\n      else c.wait = rnd(1, 3);\n    }\n    return;\n  }\n  // Landing: come in above the place, then drop onto it.\n  slotPos(S, c.slot, P);\n  const dx = P[0] - c.x, dy = P[1] - c.y, dist = sqrt(dx * dx + dy * dy);\n  steer(c, P[0], P[1] - (dist > 9 ? 6 : 0), min(30, 4 + dist * 2.6), d, 5);\n  if (dist \u003c 0.8) perch(S, c, c.slot, c.vx >= 0 ? 1 : -1, true);\n}\n\nfunction steer(c, tx, ty, speed, d, k) {\n  const dx = tx - c.x, dy = ty - c.y, L = sqrt(dx * dx + dy * dy) || 1;\n  const v = min(speed, L * 4), f = min(1, d * k);\n  c.vx += ((dx / L) * v - c.vx) * f;\n  c.vy += ((dy / L) * v - c.vy) * f;\n  c.x += c.vx * d;\n  c.y += c.vy * d;\n  if (abs(c.vx) > 3) c.face = c.vx > 0 ? 1 : -1;\n}\n\n// The nearest free place, so crows do not cross each other's paths.\nfunction freeSlot(S, me) {\n  let best = -1, bd = 1e9;\n  for (let k = 0; k \u003c SLOTS.length; k++) {\n    let taken = false;\n    for (const c of S.crows) if (c !== me && c.i \u003c S.count && c.slot === k) taken = true;\n    if (taken) continue;\n    slotPos(S, k, P);\n    const dd = (P[0] - me.x) ** 2 + (P[1] - me.y) ** 2;\n    if (dd \u003c bd) (bd = dd), (best = k);\n  }\n  return best;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 8, 20);\n  S.nerves = cl(k[3], 0, 1);\n  if (!S.started) start(S);\n  const d = d0 * S.speed * 0.5;\n  S.t += d;\n  // Twitches come every 11.5 seconds on average at Nerves 0.06, every 3 at\n  // 1; the first at 0.3 of the interval, 3.4 seconds at the start knobs.\n  const T = mix(12, 3, S.nerves);\n  if (S.next \u003c 0) S.next = 0.3 * T;\n  const tap = !!(input.btnPressed && input.btnPressed[0]);\n  if (tap || S.t >= S.next) {\n    twitch(S);\n    S.next = S.t + T * rnd(0.7, 1.3);\n  }\n  // The head snaps to its side, holds, then comes slowly back; between\n  // twitches a nervous one glances about.\n  if (S.hold > 0) {\n    S.hold -= d;\n    if (S.hold \u003c= 0) S.turnTo = 0;\n  } else {\n    S.glance -= d;\n    if (S.glance \u003c= 0) {\n      S.turnTo = S.nerves > 0.3 ? (rnd(-1, 1) * 0.45 * (S.nerves - 0.3)) / 0.7 : 0;\n      S.glance = rnd(0.8, 2.5);\n    }\n  }\n  S.turn += (S.turnTo - S.turn) * min(1, d * (S.hold > 0 ? 30 : 2.2));\n  S.jolt *= exp(-d * 9);\n  // The wind leans the scarecrow up to 2 LEDs at the hat.\n  S.sway = 0.012 * sin(S.t * 0.8) + 0.007 * sin(S.t * 2.1 + 1);\n  for (let a = 0; a \u003c 2; a++) {\n    S.dipV[a] += (-60 * S.dip[a] - 5 * S.dipV[a]) * d;\n    S.dip[a] += S.dipV[a] * d;\n  }\n  for (const c of S.crows) {\n    if (c.i >= S.count) {\n      // A crow the knob takes away is gone, and its place is free.\n      c.slot = -1;\n      if (c.st !== \"circle\") c.st = \"circle\";\n      continue;\n    }\n    stepCrow(S, c, d);\n  }\n}\n\n// --- drawing: a sky, then one silhouette mask for the scarecrow and crows ---\n\nfunction inPoly(x, y, pts) {\n  let inside = false;\n  for (let i = 0, j = pts.length - 2; i \u003c pts.length; j = i, i += 2) {\n    const xi = pts[i], yi = pts[i + 1], xj = pts[j], yj = pts[j + 1];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;\n  }\n  return inside;\n}\n\nfunction fillPoly(m, pts, v) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c pts.length; i += 2) (x0 = min(x0, pts[i])), (x1 = max(x1, pts[i])), (y0 = min(y0, pts[i + 1])), (y1 = max(y1, pts[i + 1]));\n  for (let y = max(0, floor(y0)); y \u003c= min(H - 1, floor(y1)); y++)\n    for (let x = max(0, floor(x0)); x \u003c= min(W - 1, floor(x1)); x++) if (inPoly(x + 0.5, y + 0.5, pts)) m[y * W + x] = v;\n}\n\nfunction fillEllipse(m, cx, cy, rx, ry, rot, v) {\n  const c = cos(rot), s = sin(rot), R = max(rx, ry) + 1;\n  for (let y = max(0, floor(cy - R)); y \u003c= min(H - 1, floor(cy + R)); y++)\n    for (let x = max(0, floor(cx - R)); x \u003c= min(W - 1, floor(cx + R)); x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, u = (dx * c + dy * s) / rx, w = (-dx * s + dy * c) / ry;\n      if (u * u + w * w \u003c= 1) m[y * W + x] = v;\n    }\n}\n\nfunction stroke(m, x0, y0, x1, y1, r, v) {\n  const dx = x1 - x0, dy = y1 - y0, ll = dx * dx + dy * dy || 1e-9;\n  for (let y = max(0, floor(min(y0, y1) - r)); y \u003c= min(H - 1, floor(max(y0, y1) + r)); y++)\n    for (let x = max(0, floor(min(x0, x1) - r)); x \u003c= min(W - 1, floor(max(x0, x1) + r)); x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = cl((px * dx + py * dy) / ll, 0, 1), ex = px - u * dx, ey = py - u * dy;\n      if (ex * ex + ey * ey \u003c= r * r) m[y * W + x] = v;\n    }\n}\n\nfunction setAt(m, x, y, v) {\n  x = floor(x);\n  y = floor(y);\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) m[y * W + x] = v;\n}\n\n// A flat list of points [x0, y0, x1, y1, ...] moved through fn.\nfunction moved(S, fn, pts) {\n  const out = [];\n  for (let i = 0; i \u003c pts.length; i += 2) {\n    fn(S, pts[i], pts[i + 1], P);\n    out.push(P[0], P[1]);\n  }\n  return out;\n}\n\nfunction scarecrow(S, m) {\n  const t = S.t, A = [0, 0], B = [0, 0];\n  // Pole, shirt with a ragged hem, and the sleeves on the crossbar.\n  body(S, NX, 60, A);\n  body(S, NX, H + 4, B);\n  stroke(m, A[0], A[1], B[0], B[1], 1.4, 1);\n  fillPoly(m, moved(S, body, [24, 53, 40, 53, 42.5, 68, 44, 82, 42, 85.5, 40, 83, 37.5, 86, 35, 83.2, 32.5, 86.5, 30, 83.2, 27, 86, 24.5, 83, 22, 85.5, 20, 82, 21.5, 68]), 1);\n  fillPoly(m, moved(S, armPoint, [3.5, 54.6, 22, 54.6, 42, 54.6, 60.5, 54.6, 61.8, 60, 56, 59, 42, 59.6, 32, 60, 22, 59.6, 8, 59, 2.2, 60]), 1);\n  // Straw: out of the cuffs, the hem and the neck, trembling in the air.\n  const straw = (fn, x, y, a, L, n) => {\n    fn(S, x, y, A);\n    const w = a + 0.18 * sin(t * 4.1 + n * 1.7) + 0.08 * sin(t * 9.3 + n);\n    stroke(m, A[0], A[1], A[0] + L * cos(w), A[1] + L * sin(w), 0.5, 1);\n  };\n  for (let n = 0; n \u003c 4; n++) {\n    straw(armPoint, 3, 58, PI * (0.62 + 0.09 * n), 4.5 + (n & 1), n);\n    straw(armPoint, 61, 58, PI * (0.38 - 0.09 * n), 4.5 + (n & 1), n + 4);\n  }\n  for (let n = 0; n \u003c 6; n++) straw(body, 23 + n * 3.6, 85, PI * (0.5 + 0.06 * (n - 2.5)), 3 + (n % 3), n + 8);\n  for (let n = 0; n \u003c 3; n++) straw(headPoint, NX, 51.5, PI * (0.25 + 0.25 * n), 3.5, n + 14);\n  // Head: a sack, tied at the neck, under a straw hat; all of it turns.\n  headPoint(S, NX, 41.5, A);\n  fillEllipse(m, A[0], A[1], 7.6, 8.4, 0.15 * S.turn, 1);\n  headPoint(S, NX, 50.5, A);\n  fillEllipse(m, A[0], A[1], 3.4, 1.9, 0, 1);\n  fillPoly(m, moved(S, headPoint, [16.5, 34.5, 21, 31.6, 43, 31.6, 47.5, 34.5, 41, 34.2, 23, 34.2]), 1);\n  fillPoly(m, moved(S, headPoint, [24, 31.8, 24.8, 25.5, 27, 22.6, 32, 21.6, 37, 22.6, 39.2, 25.5, 40, 31.8]), 1);\n  for (let n = 0; n \u003c 3; n++) {\n    straw(headPoint, 17 + n * 1.3, 34.2, PI * (0.62 - 0.05 * n), 2.6, n + 17);\n    straw(headPoint, 47 - n * 1.3, 34.2, PI * (0.38 + 0.05 * n), 2.6, n + 20);\n  }\n  // The face is cut out, so the moon shows through: X-stitched eyes and a\n  // stitched mouth, sliding to the side the head turns to.\n  const tu = S.turn, fx = NX + 4.4 * tu, sp = 3.4 * (1 - 0.45 * abs(tu));\n  for (const e of [-1, 1]) {\n    headPoint(S, fx + e * sp, 39.5, A);\n    for (const [ox, oy] of [[0, 0], [-1, -1], [1, -1], [-1, 1], [1, 1]]) setAt(m, A[0] + ox, A[1] + oy, 0);\n  }\n  const half = 4.2 * (1 - 0.35 * abs(tu));\n  for (let u = -half; u \u003c= half + 0.01; u += 1) {\n    headPoint(S, fx + u, 45.5 - (abs(u) > half - 1.2 ? 0.8 : 0), A);\n    setAt(m, A[0], A[1], 0);\n    if (round(u + half) % 2 === 1) {\n      setAt(m, A[0], A[1] - 1, 0);\n      setAt(m, A[0], A[1] + 1, 0);\n    }\n  }\n}\n\n// Wings from a shoulder at (x, y): a near and a far one, root along the\n// back, tip out and up (a > 0) or down. pt maps body coordinates (u along,\n// v below) to the panel.\nfunction wings(m, pt, a, L) {\n  for (const [k, back, sh] of [[1, 0, 0], [0.8, -1.2, 0.35]]) {\n    const l = L * k, sa = sin(a + sh), ca = cos(a + sh);\n    fillPoly(m, [...pt(1.4 + back * 0.3, -0.6), ...pt(0.2 + back - 1.2 * ca, -0.6 - 0.6 * l * sa), ...pt(-1.6 + back - 2.2 * ca, -0.6 - l * sa), ...pt(-1.8 + back * 0.3, -0.6)], 1);\n  }\n}\n\n// A crow standing, feet at (fx, fy), facing f (1 right, -1 left), beak open\n// when b is 1, wings raised by w (0 folded, 1 stretched high), head down to\n// the ground by p (0 up, 1 pecking).\nfunction crowSitting(m, fx, fy, f, b, w, p) {\n  const pt = (u, v) => [fx + f * u * K, fy + v * K];\n  // The head and beak swing down about the shoulder as it pecks.\n  const hp = (u, v) => pt(mix(u, 1.2 + 0.25 * (u - 1.2) + 0.95 * (v + 4.2), p), mix(v, -2.4 + 0.25 * (v + 4.2) + 0.95 * (u - 1.2), p));\n  stroke(m, ...pt(-0.8, -2), ...pt(-0.8, -0.2), 0.5, 1);\n  stroke(m, ...pt(0.6, -2), ...pt(0.6, -0.2), 0.5, 1);\n  const bc = pt(-0.6, -3.6), hc = hp(2.1, -5.6);\n  fillEllipse(m, bc[0], bc[1], 3 * K, 2 * K, (-0.35 + 0.5 * p) * f, 1);\n  fillEllipse(m, hc[0], hc[1], 1.6 * K, 1.5 * K, 0, 1);\n  fillPoly(m, [...pt(-2.6, -4.6), ...pt(-6, -1.4 - 2 * p), ...pt(-5.4, -0.4 - 2 * p), ...pt(-2.4, -2.4)], 1);\n  if (b) {\n    fillPoly(m, [...hp(3.2, -6.6), ...hp(5.7, -7.6), ...hp(3.4, -5.6)], 1);\n    fillPoly(m, [...hp(3.2, -5.2), ...hp(5.2, -3.8), ...hp(3.2, -4.4)], 1);\n  } else fillPoly(m, [...hp(3.2, -6.5), ...hp(5.8, -5.5), ...hp(3.2, -4.6)], 1);\n  if (w > 0.05) wings(m, (u, v) => pt(u - 0.8, v - 4.2), 0.2 + 1.1 * w, 6.5 * K * w + 1);\n  const e = hp(2.5, -6.1);\n  setAt(m, e[0], e[1], 2);\n}\n\n// A crow in the air, centre (x, y), facing f, nose tilted down by tilt,\n// wings at angle a, drawn a little from above so both wings show.\nfunction crowFlying(m, x, y, f, a, tilt) {\n  const c = cos(tilt), s = sin(tilt);\n  const pt = (u, v) => [x + f * KF * (u * c - v * s), y + KF * (u * s + v * c)];\n  fillEllipse(m, x, y, 3.2 * KF, 1.5 * KF, tilt * f, 1);\n  const hd = pt(3.2, -0.6);\n  fillEllipse(m, hd[0], hd[1], 1.4 * KF, 1.3 * KF, 0, 1);\n  fillPoly(m, [...pt(4.2, -1), ...pt(6, -0.4), ...pt(4.2, 0.1)], 1);\n  fillPoly(m, [...pt(-2.6, -0.8), ...pt(-6, -1.6), ...pt(-6, 1.2), ...pt(-2.6, 0.8)], 1);\n  wings(m, pt, a, 7.5);\n  const e = pt(3.6, -1.1);\n  setAt(m, e[0], e[1], 2);\n}\n\nfunction palette(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), sm = g * g * (3 - 2 * g);\n  return PAL[0].map((_, n) => [0, 1, 2].map((ch) => mix(PAL[i][n][ch], PAL[j][n][ch], sm)));\n}\n\n// The sky, the moon and the field only change with the colour.\nfunction background(S) {\n  const [top, midc, low, hz, moon, sea, field] = palette(S), bg = S.bg;\n  const lerp3 = (a, b, u) => [0, 1, 2].map((ch) => mix(a[ch], b[ch], u));\n  // Violet at the top, the middle colour at row 45, the low one at row 80\n  // and the horizon's glow at 101.\n  const skyAt = (y) => (y \u003c 45 ? lerp3(top, midc, y / 45) : y \u003c 80 ? lerp3(midc, low, (y - 45) / 35) : lerp3(low, hz, (y - 80) / (HZ - 80)));\n  for (let y = 0; y \u003c H; y++) {\n    const sky = skyAt(y);\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let c = sky;\n      if (y >= HZ) {\n        // The field: dark, with furrows running to the foot of the pole.\n        const u = (x + 0.5 - NX) / (y + 1 - HZ + 4), lane = abs(u * 3 - round(u * 3));\n        c = field.map((v) => v * (lane \u003c 0.1 + (0.02 * (y - HZ)) / 4 ? 1.9 : 1));\n      } else {\n        const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n        if (r \u003c MR) {\n          let s = 0;\n          for (const [sx, sy, sr] of [[-8, -6, 6], [6, 4, 5], [-3, 10, 4], [9, -10, 3.5]]) if ((dx - sx) ** 2 + (dy - sy) ** 2 \u003c sr * sr) s = 1;\n          c = s ? sea : moon;\n        } else if (r \u003c MR + 3) c = sky.map((v, ch) => min(255, v + 0.25 * (moon[ch] - v)));\n      }\n      bg[o] = c[0];\n      bg[o + 1] = c[1];\n      bg[o + 2] = c[2];\n    }\n  }\n  // Three pumpkins left in the field, lit orange whatever the sky.\n  for (const [px, py, rx, ry] of [[11, 113, 5.5, 4.2], [53, 109, 4.2, 3.3], [41, 121, 6.5, 4.8]]) {\n    for (let y = floor(py - ry - 2); y \u003c= floor(py + ry); y++)\n      for (let x = floor(px - rx); x \u003c= floor(px + rx); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const u = (x + 0.5 - px) / rx, v = (y + 0.5 - py) / ry, o = (y * W + x) * 3;\n        let c = null;\n        if (u * u + v * v \u003c= 1) {\n          // Ribs as darker grooves, and a darker rim at the bottom.\n          const rib = abs(abs(u) - 0.45) \u003c 0.13 || abs(u) \u003c 0.07 ? 0.62 : 1, rim = v > 0.65 ? 0.75 : 1;\n          c = [236 * rib * rim, 112 * rib * rim, 18 * rib * rim];\n        } else if (abs(x + 0.5 - px) \u003c 0.9 && y + 0.5 \u003c py - ry + 0.6 && y + 0.5 > py - ry - 2) c = [70, 120, 30];\n        if (c) (bg[o] = c[0]), (bg[o + 1] = c[1]), (bg[o + 2] = c[2]);\n      }\n  }\n  S.bgHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  if (S.bgHue !== S.hue) background(S);\n  const m = S.m, bg = S.bg;\n  m.fill(0);\n  scarecrow(S, m);\n  for (const c of S.crows) {\n    if (c.i >= S.count) continue;\n    if (c.st === \"perch\" || (c.st === \"flee\" && c.delay > 0)) crowSitting(m, c.x, c.y, c.face, c.beak, c.wing, c.peck);\n    else {\n      // Flapping in the air; gliding with wings raised on the way in.\n      const glide = c.st === \"land\" && Math.hypot(c.vx, c.vy) \u003c 14;\n      crowFlying(m, c.x, c.y, c.face, glide ? 0.75 : 0.25 + sin(c.flap), cl(c.vy / 60, -0.5, 0.5));\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const v = m[p];\n      if (v === 1) display.setPixel(x, y, 6, 2, 10);\n      else if (v === 2) display.setPixel(x, y, 150, 140, 120);\n      else display.setPixel(x, y, bg[p * 3], bg[p * 3 + 1], bg[p * 3 + 2]);\n    }\n}\n","tutte-embedding":"// ===== Patternflow pattern =====\n// Title:   Tutte Embedding\n// Family:  algo\n// Idea:    A 3-connected planar net of 90 to 210 knots is pinned by its outer face to a tall convex polygon that fills the panel, its inner knots are thrown into a tangle whose crossing threads glow orange, and every knot keeps moving to the average of its neighbours until the crossings are gone and every face is convex, as Tutte proved, while the rim knots slide round the polygon and keep the whole net flowing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Tutte's spring embedding (W. T. Tutte, 1963), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knots=90..210, Triangles=0..1\n//\n// Knob 1: Hue. Turns the net's colour round the wheel. At 0 the settled net is azure with pale knots and a crossing thread glows orange; the alarm colour always sits 0.46 of the wheel from the net's, and a net that lands on orange, near 0.5, is paled and lifted so it does not read brown.\n// Knob 2: Speed. How fast the knots relax and the rim turns. At 2 a tangle of 90 knots comes apart in about 3.5 seconds and one of 210 in about 4, the rim knots go once round the polygon in 75 seconds, and the net is thrown again every 20 seconds; at 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Knots, 90 to 210 inner and rim knots together, from random points 7.5 LEDs apart at 90 down to 5 at 210. Turning it builds a new net in steps of 10, thrown into a fresh tangle.\n// Knob 4: Triangles. At 0 as many threads are cut as the net allows while it stays 3-connected and no face passes six sides: about 80 of 229 at 90 knots, leaving about a third of the faces triangles and the rest quadrilaterals, pentagons and hexagons. At 1 every face is a triangle. Cutting or restoring threads moves the knots to the new net's embedding, still without a crossing.\n// Buttons: K1 tap throws the inner knots into a new tangle.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, round, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The rim: a superellipse |x/A|^p + |y/B|^p = 1 about the panel's centre,\n// strictly convex for every p above 1, so knots taken round it in order\n// always make a convex polygon. p breathes between 2.6 and 4.6.\nconst CX = 31.5, CY = 63.5, A = 31, B = 63, SAMPLES = 400;\n// Seconds per rim turn, between tangles and for the throw, all at Speed 1.\nconst TURN = 150, EVERY = 38.6, THROW = 1.4;\n// The relaxation rate after a throw, in sweeps per second at Speed 1: it\n// starts at K0 and grows e-fold every KT seconds up to KMAX, so the tangle\n// shrinks slowly at first and the net settles fast once it is nearly there.\nconst K0 = 0.067, KT = 1.78, KMAX = 15;\n\nfunction rimPoint(t, p) {\n  const c = cos(t), s = sin(t), e = 2 / p;\n  return [CX + A * Math.sign(c) * abs(c) ** e, CY + B * Math.sign(s) * abs(s) ** e];\n}\n\n// The rim sampled by arc length: cum[k] is the length up to sample k.\nfunction rimTable(S, p) {\n  const { rx, ry, cum } = S;\n  for (let k = 0; k \u003c= SAMPLES; k++) {\n    const [x, y] = rimPoint((k / SAMPLES) * TAU, p);\n    rx[k] = x;\n    ry[k] = y;\n    cum[k] = k ? cum[k - 1] + sqrt((x - rx[k - 1]) ** 2 + (y - ry[k - 1]) ** 2) : 0;\n  }\n}\n\n// The point a share u of the way round the rim, by length.\nfunction rimAt(S, u, X, Y, i) {\n  const { rx, ry, cum } = S;\n  const d = (u - floor(u)) * cum[SAMPLES];\n  let lo = 0, hi = SAMPLES;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (cum[mid] \u003c= d) lo = mid;\n    else hi = mid;\n  }\n  const f = (d - cum[lo]) / (cum[hi] - cum[lo] || 1);\n  X[i] = rx[lo] + (rx[hi] - rx[lo]) * f;\n  Y[i] = ry[lo] + (ry[hi] - ry[lo]) * f;\n}\n\n// Bowyer-Watson Delaunay triangulation; triangles come back as vertex\n// triples that all turn the same way.\nfunction delaunay(px, py) {\n  const n = px.length;\n  const X = [...px, -3000, 3000, CX], Y = [...py, -3000, -3000, 6000];\n  const circ = (a, b, c) => {\n    const ax = X[a], ay = Y[a], bx = X[b], by = Y[b], cx = X[c], cy = Y[c];\n    const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));\n    const a2 = ax * ax + ay * ay, b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n    const ux = (a2 * (by - cy) + b2 * (cy - ay) + c2 * (ay - by)) / d, uy = (a2 * (cx - bx) + b2 * (ax - cx) + c2 * (bx - ax)) / d;\n    return [a, b, c, ux, uy, (ax - ux) ** 2 + (ay - uy) ** 2];\n  };\n  let tri = [circ(n, n + 1, n + 2)];\n  for (let i = 0; i \u003c n; i++) {\n    const keep = [], edges = new Map();\n    for (const t of tri) {\n      if ((X[i] - t[3]) ** 2 + (Y[i] - t[4]) ** 2 \u003c t[5])\n        for (let k = 0; k \u003c 3; k++) {\n          const a = t[k], b = t[(k + 1) % 3], key = a \u003c b ? a * 4096 + b : b * 4096 + a;\n          edges.set(key, edges.has(key) ? null : [a, b]);\n        }\n      else keep.push(t);\n    }\n    for (const e of edges.values()) if (e) keep.push(circ(e[0], e[1], i));\n    tri = keep;\n  }\n  const out = [];\n  for (const [a, b, c] of tri) {\n    if (a >= n || b >= n || c >= n) continue;\n    const cr = (X[b] - X[a]) * (Y[c] - Y[a]) - (Y[b] - Y[a]) * (X[c] - X[a]);\n    out.push(cr > 0 ? [a, b, c] : [a, c, b]);\n  }\n  return out;\n}\n\n// A new net of about n knots: m on the rim, the rest scattered inside by\n// dart throwing so no two sit closer than d. Tried again while the\n// triangulation has a chord between two rim knots, which would make those\n// two a cut pair and the net only 2-connected.\nfunction buildNet(S, n) {\n  rimTable(S, 3.4);\n  const perim = S.cum[SAMPLES], area = 4 * A * B * 0.9;\n  for (let tries = 0; tries \u003c 16; tries++) {\n    const d = 0.86 * sqrt(area / n), m = max(12, round(perim / (1.15 * d)));\n    const px = new Float64Array(m), py = new Float64Array(m);\n    for (let k = 0; k \u003c m; k++) rimAt(S, k / m, px, py, k);\n    const X = [...px], Y = [...py];\n    // Inner knots keep 0.55 of a spacing inside the rim polygon.\n    const inside = (x, y) => {\n      for (let k = 0; k \u003c m; k++) {\n        const j = (k + 1) % m, ex = X[j] - X[k], ey = Y[j] - Y[k];\n        if (((x - X[k]) * ey - (y - Y[k]) * ex) / sqrt(ex * ex + ey * ey) > -0.55 * d) return false;\n      }\n      return true;\n    };\n    for (let k = 0; k \u003c 60 * n && X.length \u003c n; k++) {\n      const x = CX + (Math.random() * 2 - 1) * A, y = CY + (Math.random() * 2 - 1) * B;\n      if (!inside(x, y)) continue;\n      let ok = true;\n      for (let j = 0; j \u003c X.length && ok; j++) if ((X[j] - x) ** 2 + (Y[j] - y) ** 2 \u003c d * d) ok = false;\n      if (ok) X.push(x), Y.push(y);\n    }\n    const tri = delaunay(X, Y), N = X.length;\n    const seen = new Map(), E = [];\n    for (const t of tri)\n      for (let k = 0; k \u003c 3; k++) {\n        const a = min(t[k], t[(k + 1) % 3]), b = max(t[k], t[(k + 1) % 3]), key = a * 4096 + b;\n        if (!seen.has(key)) seen.set(key, E.length), E.push([a, b]);\n      }\n    let chord = false;\n    for (const [a, b] of E) if (b \u003c m && b - a !== 1 && !(a === 0 && b === m - 1)) chord = true;\n    if (chord && tries \u003c 15) continue;\n    S.n = N;\n    S.m = m;\n    S.E = E;\n    S.tris = tri;\n    S.x = Float64Array.from(X);\n    S.y = Float64Array.from(Y);\n    for (const k of [\"nx\", \"ny\", \"fx\", \"fy\", \"tx\", \"ty\"]) S[k] = new Float64Array(N);\n    // The order threads are tried for cutting, fixed with the net, so a\n    // Triangles setting always cuts the same ones.\n    const order = E.map((_, i) => i);\n    for (let i = order.length - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [order[i], order[j]] = [order[j], order[i]];\n    }\n    S.cuts = cutThreads(S, order, Infinity).cuts;\n    S.heat = new Float32Array(E.length);\n    S.cutsOn = -1;\n    return;\n  }\n}\n\n// Cut threads in the given order while the net stays 3-connected. A\n// 2-connected plane graph is 3-connected exactly when any two faces meet in\n// nothing, one knot, or one thread (both ends of it); a cut joins the\n// thread's two faces into one, so only the joined face needs checking, and\n// both ends must keep at least three threads. Faces are kept to hexagons.\n// Returns the cuts in order and the faces after the first `limit` of them.\nfunction cutThreads(S, order, limit) {\n  const { E, n, m, tris } = S;\n  // Face 0 is the outer face: the rim knots in order.\n  const faces = [[...Array(m).keys()], ...tris.map((t) => t.slice())];\n  const alive = faces.map(() => true);\n  const deg = new Int32Array(n);\n  for (const [a, b] of E) deg[a]++, deg[b]++;\n  const at = Array.from({ length: n }, () => []);\n  faces.forEach((f, i) => f.forEach((v) => at[v].push(i)));\n  const step = (f, a, b) => {\n    const L = f.length;\n    for (let k = 0; k \u003c L; k++) if (f[k] === a && f[(k + 1) % L] === b) return true;\n    return false;\n  };\n  const rot = (f, s) => {\n    const k = f.indexOf(s);\n    return [...f.slice(k), ...f.slice(0, k)];\n  };\n  const cuts = [];\n  for (const ei of order) {\n    if (cuts.length >= limit) break;\n    const [a, b] = E[ei];\n    if (b \u003c m || deg[a] \u003c 4 || deg[b] \u003c 4) continue;\n    // The face with the step a -> b and the one with b -> a.\n    let f1 = -1, f2 = -1;\n    for (const fi of at[a]) {\n      if (!alive[fi]) continue;\n      if (step(faces[fi], a, b)) f1 = fi;\n      else if (step(faces[fi], b, a)) f2 = fi;\n    }\n    if (f1 \u003c= 0 || f2 \u003c= 0 || faces[f1].length + faces[f2].length > 8) continue;\n    const g1 = rot(faces[f1], b), g2 = rot(faces[f2], a);\n    const joined = [...g1, ...g2.slice(1, -1)];\n    let ok = true;\n    const checked = new Set([f1, f2]);\n    for (const v of joined) {\n      for (const fi of at[v]) {\n        if (!alive[fi] || checked.has(fi)) continue;\n        checked.add(fi);\n        const g = faces[fi], both = joined.filter((u) => g.includes(u));\n        if (both.length > 2) ok = false;\n        else if (both.length === 2) {\n          const [p, q] = both;\n          if (!((step(joined, p, q) || step(joined, q, p)) && (step(g, p, q) || step(g, q, p)))) ok = false;\n        }\n        if (!ok) break;\n      }\n      if (!ok) break;\n    }\n    if (!ok) continue;\n    cuts.push(ei);\n    deg[a]--;\n    deg[b]--;\n    alive[f1] = alive[f2] = false;\n    faces.push(joined);\n    alive.push(true);\n    joined.forEach((v) => at[v].push(faces.length - 1));\n  }\n  return { cuts, faces: faces.filter((_, i) => alive[i]) };\n}\n\n// The live threads and each knot's neighbours (CSR) for the first k cuts.\nfunction wire(S, k) {\n  const { E, n } = S, off = new Uint8Array(E.length);\n  for (let i = 0; i \u003c k; i++) off[S.cuts[i]] = 1;\n  S.live = [];\n  for (let i = 0; i \u003c E.length; i++) if (!off[i]) S.live.push(i);\n  const deg = new Int32Array(n + 1);\n  for (const i of S.live) deg[E[i][0] + 1]++, deg[E[i][1] + 1]++;\n  for (let i = 0; i \u003c n; i++) deg[i + 1] += deg[i];\n  const adj = new Int32Array(deg[n]), fill = deg.slice();\n  for (const i of S.live) {\n    const [a, b] = E[i];\n    adj[fill[a]++] = b;\n    adj[fill[b]++] = a;\n  }\n  S.start = deg;\n  S.adj = adj;\n  S.cutsOn = k;\n}\n\n// Inner knots to random places inside the rim, the far end of a throw.\nfunction throwTargets(S) {\n  const { m, n, tx, ty } = S;\n  for (let i = m; i \u003c n; i++) {\n    let x, y;\n    do {\n      x = (Math.random() * 2 - 1) * 0.94;\n      y = (Math.random() * 2 - 1) * 0.94;\n    } while (abs(x) ** 3 + abs(y) ** 3 > 0.8);\n    tx[i] = CX + A * x;\n    ty[i] = CY + B * y;\n  }\n}\n\nfunction startThrow(S, instant) {\n  throwTargets(S);\n  S.fx.set(S.x);\n  S.fy.set(S.y);\n  S.phase = instant ? 1 : 0;\n  S.clock = 0;\n  if (instant) for (let i = S.m; i \u003c S.n; i++) (S.x[i] = S.tx[i]), (S.y[i] = S.ty[i]);\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, tri: 0.06, t: 0, turn: 0,\n    rx: new Float64Array(SAMPLES + 1), ry: new Float64Array(SAMPLES + 1), cum: new Float64Array(SAMPLES + 1),\n    builtFor: -1, phase: 1, clock: 0, crossings: 0, crossing: null,\n    C: new Float32Array(W * H), Al: new Float32Array(W * H), V: new Float32Array(W * H),\n  };\n}\n\n// Place the rim knots for this moment: evenly by length round the rim, the\n// whole ring turning, with a ripple in the spacing that travels round it.\nfunction placeRim(S) {\n  const p = 3.6 + 1.0 * sin(S.t * 0.21);\n  rimTable(S, p);\n  const { m } = S;\n  for (let k = 0; k \u003c m; k++) {\n    const u = (k + S.turn * m + 0.3 * sin((TAU * 2 * k) / m - S.t * 0.37)) / m;\n    rimAt(S, u, S.x, S.y, k);\n  }\n}\n\n// Damped Jacobi sweeps: every inner knot moves the share w of the way to\n// the mean of its neighbours. The fixed point is Tutte's barycentric\n// embedding.\nfunction relax(S, sweeps, w) {\n  const { m, n, x, y, nx, ny, start, adj } = S;\n  for (let s = 0; s \u003c sweeps; s++) {\n    for (let i = m; i \u003c n; i++) {\n      let sx = 0, sy = 0;\n      const a = start[i], b = start[i + 1];\n      for (let j = a; j \u003c b; j++) (sx += x[adj[j]]), (sy += y[adj[j]]);\n      const k = b - a;\n      nx[i] = x[i] + w * (sx / k - x[i]);\n      ny[i] = y[i] + w * (sy / k - y[i]);\n    }\n    for (let i = m; i \u003c n; i++) (x[i] = nx[i]), (y[i] = ny[i]);\n  }\n}\n\n// Which live threads cross another: a sweep over threads sorted by their\n// left end, testing pairs whose boxes meet. Threads sharing a knot never\n// count as crossing.\nfunction countCrossings(S, flags) {\n  const { E, live, x, y } = S, L = live.length;\n  const lo = new Float64Array(L), idx = live.slice();\n  idx.sort((p, q) => min(x[E[p][0]], x[E[p][1]]) - min(x[E[q][0]], x[E[q][1]]));\n  for (let i = 0; i \u003c L; i++) lo[i] = min(x[E[idx[i]][0]], x[E[idx[i]][1]]);\n  let count = 0;\n  for (let i = 0; i \u003c L; i++) {\n    const [a, b] = E[idx[i]], ax = x[a], ay = y[a], bx = x[b], by = y[b];\n    const hiX = max(ax, bx), loY = min(ay, by), hiY = max(ay, by);\n    for (let j = i + 1; j \u003c L && lo[j] \u003c= hiX; j++) {\n      const [c, d] = E[idx[j]];\n      if (c === a || c === b || d === a || d === b) continue;\n      const cx = x[c], cy = y[c], dx = x[d], dy = y[d];\n      if (max(cy, dy) \u003c loY || min(cy, dy) > hiY) continue;\n      const o1 = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax), o2 = (bx - ax) * (dy - ay) - (by - ay) * (dx - ax);\n      if (o1 * o2 >= 0) continue;\n      const o3 = (dx - cx) * (ay - cy) - (dy - cy) * (ax - cx), o4 = (dx - cx) * (by - cy) - (dy - cy) * (bx - cx);\n      if (o3 * o4 >= 0) continue;\n      count++;\n      if (flags) flags[idx[i]] = flags[idx[j]] = 1;\n    }\n  }\n  return count;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 90, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tri = cl(k[3], 0, 1);\n  const want = 90 + 10 * round((cl(k[2], 90, 210) - 90) / 10);\n  const fresh = S.builtFor !== want;\n  if (fresh) {\n    buildNet(S, want);\n    S.builtFor = want;\n    S.crossing = new Uint8Array(S.E.length);\n  }\n  const cuts = round((1 - S.tri) * S.cuts.length);\n  if (S.cutsOn !== cuts) wire(S, cuts);\n  const sp = d * S.speed;\n  S.t += sp;\n  S.turn += sp / TURN;\n  placeRim(S);\n  if (fresh) startThrow(S, S.t \u003c 0.5);\n  if (input.btnPressed && input.btnPressed[0] && S.phase === 1 && S.clock > 0.3) startThrow(S, false);\n  S.clock += sp;\n  if (S.phase === 0) {\n    // The throw: inner knots fly out to the tangle along eased paths.\n    const u = ease(S.clock / THROW);\n    for (let i = S.m; i \u003c S.n; i++) {\n      S.x[i] = S.fx[i] + (S.tx[i] - S.fx[i]) * u;\n      S.y[i] = S.fy[i] + (S.ty[i] - S.fy[i]) * u;\n    }\n    if (S.clock >= THROW) (S.phase = 1), (S.clock = 0);\n  } else {\n    const k = min(KMAX, K0 * exp(S.clock / KT)) * sp, n = min(12, Math.ceil(k / 0.9));\n    relax(S, n, k / n);\n    if (S.clock > EVERY) startThrow(S, false);\n  }\n  S.crossing.fill(0);\n  S.crossings = countCrossings(S, S.crossing);\n  const fade = exp(-d / 0.35);\n  for (let i = 0; i \u003c S.E.length; i++) S.heat[i] = S.crossing[i] ? 1 : S.heat[i] * fade;\n}\n\n// --- drawing ---\n\nfunction plot(buf, x, y, c) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || c \u003c= 0) return;\n  const o = y * W + x;\n  if (c > buf[o]) buf[o] = c;\n}\n\n// Xiaolin Wu's antialiased line, one LED wide, keeping the most at each LED.\nfunction wu(buf, x0, y0, x1, y1, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  if (steep) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x0 > x1) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const dx = x1 - x0, g = dx \u003c 1e-9 ? 0 : (y1 - y0) / dx;\n  const xs = round(x0), xe = round(x1);\n  let yy = y0 + g * (xs - x0);\n  for (let x = xs; x \u003c= xe; x++, yy += g) {\n    const yi = floor(yy), f = yy - yi;\n    if (steep) plot(buf, yi, x, (1 - f) * a), plot(buf, yi + 1, x, f * a);\n    else plot(buf, x, yi, (1 - f) * a), plot(buf, x, yi + 1, f * a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.live) return;\n  const { C, Al, V, E, x, y, heat } = S;\n  C.fill(0);\n  Al.fill(0);\n  V.fill(0);\n  // A net turned orange is paled and lifted: dim orange reads brown.\n  const nh = S.hue + 0.56, band = max(0, 1 - abs(nh - floor(nh) - 0.09) / 0.13), lift = 1 + 0.6 * band;\n  const net = hsv(nh, 0.78 - 0.22 * band, 1).map((c) => c * lift), alarm = hsv(S.hue + 0.1, 0.92, 1), knot = hsv(S.hue + 0.53, 0.25, 1);\n  for (const i of S.live) {\n    const [a, b] = E[i], h = heat[i];\n    if (h \u003c 0.98) wu(C, x[a], y[a], x[b], y[b], 0.62 * (1 - h));\n    if (h > 0.02) wu(Al, x[a], y[a], x[b], y[b], h);\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const px = round(x[i]), py = round(y[i]);\n    plot(V, px, py, 1);\n  }\n  for (let o = 0, py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++, o++) {\n      const c = C[o], al = Al[o], v = V[o];\n      const r = net[0] * c + alarm[0] * al + knot[0] * v, g = net[1] * c + alarm[1] * al + knot[1] * v, b = net[2] * c + alarm[2] * al + knot[2] * v;\n      display.setPixel(px, py, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","bat-emergence":"// ===== Patternflow pattern =====\n// Title:   Bat Emergence\n// Family:  halloween\n// Idea:    At dusk a ribbon of bats pours out of a cave mouth in a dark ridge and climbs the whole panel in pulses, twisting and swaying like smoke where the gusts push it, each bat a three-LED silhouette flapping against a sky that runs from deep purple to burnt orange.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bats=400..1200, Swirl=0..1\n//\n// Knob 1: Hue. Turns the sky round the wheel; the bats stay black. At 0 it is deep purple overhead, mauve and dusky rose lower down, and burnt orange going to peach over the ridge; at 0.5 green overhead, teal lower down and sky blue over the ridge.\n// Knob 2: Speed. At 2 a bat takes 4.7 seconds from the cave mouth to the top of the panel and beats its wings 5 times a second, and about 5,200 bats leave the cave a minute; at 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Bats. How many are in the air on average: 400 at the start, a ribbon over the ridge with sky showing through it; at 1200 the lower ribbon is solid black. The stream comes in pulses about every 3.7 seconds, and between pulses the cave lets out 0.15 of what it lets out at their height.\n// Knob 4: Swirl. How hard the column twists and sways. At 0 the ribbon turns once in the panel's height, the waves running up it swing its top up to 7 LEDs and a gust leans it up to 5 more; at 0.06, where the knob opens, about the same; at 1 it turns four times, swings 23 LEDs and a gust leans it 18.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The sky, top to horizon, as hue, saturation and value stops at heights\n// 0..1 of the sky. Hue runs the short way round between stops.\nconst SKY = [\n  [0, 0.75, 0.86, 0.26],\n  [0.4, 0.79, 0.74, 0.42],\n  [0.7, 0.9, 0.56, 0.6],\n  [0.86, 0.02, 0.52, 0.8],\n  [0.94, 0.065, 0.62, 0.93],\n  [1, 0.09, 0.5, 1],\n];\n// The ridge: its height above the bottom row at each column, and the cave\n// mouth, an arch MW wide at the base and MH tall, centred on column MX.\nconst MX = 29.5, MW = 7, MH = 8;\nconst RIDGE = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++)\n  RIDGE[x] = 13 + 4 * sin(x * 0.09 + 0.6) + 2.4 * sin(x * 0.23 + 2.1) + 1.2 * sin(x * 0.61 + 0.3) + 4 * exp(-(((x - MX) / 9) ** 2));\nconst RIDGE_TOP = H - 1 - 13;\n// The row of the top of the cave mouth; a bat's height is counted from it.\nconst MOUTH_Y = H - 1 - MH + 1;\nconst MAXB = 2600;\n// Rise speed in rows per second of scene time, and flaps per second.\nconst VUP = 20, FLAP = 5;\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: -1, speed: 2, bats: 400, swirl: 0.06, t: 0, begun: false,\n    x: new Float32Array(MAXB), y: new Float32Array(MAXB), sl: new Float32Array(MAXB), th: new Float32Array(MAXB), dp: new Float32Array(MAXB), jt: new Float32Array(MAXB),\n    ph: new Float32Array(MAXB), fr: new Float32Array(MAXB), vv: new Float32Array(MAXB), live: new Uint8Array(MAXB),\n    count: 0, next: 0, carry: 0, gust: 0, gustV: 0, gustTo: 0, gustWait: 2,\n    sky: new Float32Array(H * 3), rgb: new Float32Array(W * H * 3), stars: [],\n  });\n  for (let i = 0; i \u003c 9; i++) S.stars.push([floor(hash(i * 7 + 1) * W), floor(hash(i * 7 + 2) * 36), hash(i * 7 + 3) * TAU]);\n}\n\n// The column's centre at height h above the mouth: waves running up it like\n// smoke, wider higher up, and the gust bending the top.\nfunction centre(S, h, sw) {\n  const t = S.t, u = h / 120;\n  return (\n    MX +\n    sw * (4 * u * sin(h * 0.045 - 1.1 * t) + 2.5 * u * u * sin(h * 0.09 - 1.7 * t + 1.3) + 1.2 * sin(h * 0.02 - 0.5 * t + 2)) +\n    S.gust * 18 * u * u\n  );\n}\n\n// Pulses: the stream thickens about every 3.7 seconds.\nconst pulse = (t) => {\n  const p = 0.5 + 0.5 * sin(TAU * (t / 3.7) + 0.8 * sin((TAU * t) / 9.1));\n  return 0.15 + 0.85 * p * p;\n};\n\nfunction spawn(S) {\n  // The next free slot, searched from where the last one was found.\n  let i = -1;\n  for (let n = 0; n \u003c MAXB; n++) {\n    const j = (S.next + n) % MAXB;\n    if (!S.live[j]) {\n      i = j;\n      break;\n    }\n  }\n  if (i \u003c 0) return;\n  S.next = (i + 1) % MAXB;\n  S.count = max(S.count, i + 1);\n  S.live[i] = 1;\n  S.x[i] = MX + (Math.random() * 2 - 1) * (MW / 2 - 0.5);\n  S.y[i] = H - 1 - Math.random() * (MH - 2);\n  S.sl[i] = Math.random() * 2 - 1;\n  S.th[i] = Math.random() * 2 - 1;\n  S.jt[i] = Math.random() * TAU;\n  S.ph[i] = Math.random();\n  S.fr[i] = FLAP * (0.8 + 0.4 * Math.random());\n  S.vv[i] = 0.75 + 0.5 * Math.random();\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  const sw = 0.9 + 2.1 * S.swirl, twist = (TAU * (1 + 3 * S.swirl)) / 120;\n  // Gusts: every 3 to 8 seconds the wind picks a new lean, eased in.\n  S.gustWait -= dt;\n  if (S.gustWait \u003c= 0) {\n    S.gustTo = (Math.random() * 2 - 1) * (0.3 + 0.7 * S.swirl);\n    S.gustWait = 3 + 5 * Math.random();\n  }\n  S.gustV += ((S.gustTo - S.gust) * 1.6 - S.gustV * 1.8) * dt;\n  S.gust += S.gustV * dt;\n  // Bats leaving the cave per second: 0.43 times S.bats at the height of a\n  // pulse, which keeps about S.bats in the air on average.\n  S.carry += S.bats * 0.43 * pulse(S.t) * dt;\n  while (S.carry >= 1) {\n    spawn(S);\n    S.carry -= 1;\n  }\n  const { x, y, sl, th, dp, jt, ph, fr, vv, live } = S, k = min(1, 8 * dt);\n  for (let i = 0; i \u003c S.count; i++) {\n    if (!live[i]) continue;\n    const h = MOUTH_Y - y[i], u = cl(h / 120, 0, 1.2);\n    // Out of the mouth fast, slower over the ridge, then faster again as\n    // the column breaks up at the top.\n    y[i] -= vv[i] * VUP * (1 + 0.6 * exp(-h / 12)) * (0.8 + 1.8 * u * u) * dt;\n    // The ribbon: a flat band turning about the column, each bat at its\n    // own place across it, so where the band turns edge-on it pinches and\n    // the bats on it cross over. It widens as it climbs and frays at the top.\n    const wdt = 3 + 20 * u ** 1.3 + 90 * max(0, u - 0.55) ** 2, phi = twist * h - 1.3 * S.t + 0.4, c = cos(phi), sn = sin(phi);\n    const tx = centre(S, h, sw) + wdt * (sl[i] * c + 0.18 * th[i] * sn) + sin(jt[i] + 2.3 * S.t) * (0.4 + 1.5 * u);\n    dp[i] = sl[i] * sn;\n    x[i] += (tx - x[i]) * k;\n    ph[i] += fr[i] * dt;\n    if (y[i] \u003c -3 || x[i] \u003c -4 || x[i] > W + 3) live[i] = 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 400, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hueK = kn[0];\n  S.speed = cl(kn[1], 0.2, 3);\n  S.bats = cl(kn[2], 400, 1200);\n  S.swirl = cl(kn[3], 0, 1);\n  // The first frame opens on a column already standing up the panel.\n  if (!S.begun) {\n    S.begun = true;\n    for (let k = 0; k \u003c 140; k++) step(S, 1 / 20);\n  }\n  step(S, (d * S.speed) / 2);\n}\n\nfunction paintSky(S) {\n  const c = [0, 0, 0];\n  for (let y = 0; y \u003c H; y++) {\n    const f = cl(y / RIDGE_TOP, 0, 1);\n    let j = 0;\n    while (j \u003c SKY.length - 2 && f > SKY[j + 1][0]) j++;\n    const a = SKY[j], b = SKY[j + 1], t = (f - a[0]) / (b[0] - a[0]);\n    let dh = b[1] - a[1];\n    dh -= round(dh);\n    hsv(S.hueK + a[1] + dh * t, mix(a[2], b[2], t), mix(a[3], b[3], t), c, 0);\n    S.sky[y * 3] = c[0];\n    S.sky[y * 3 + 1] = c[1];\n    S.sky[y * 3 + 2] = c[2];\n  }\n  S.hue = S.hueK;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.hue !== S.hueK) paintSky(S);\n  const { rgb, sky } = S;\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) {\n      rgb[q] = sky[y * 3];\n      rgb[q + 1] = sky[y * 3 + 1];\n      rgb[q + 2] = sky[y * 3 + 2];\n    }\n  // A few faint stars high up, breathing slowly.\n  for (const [sx, sy, sp] of S.stars) {\n    const q = (sy * W + sx) * 3, a = 0.18 + 0.12 * sin(0.9 * S.t + sp);\n    rgb[q] += a;\n    rgb[q + 1] += a;\n    rgb[q + 2] += a;\n  }\n  // The ridge: dark purple, its skyline lit by the afterglow, and the cave\n  // mouth black.\n  const r0 = sky[RIDGE_TOP * 3], g0 = sky[RIDGE_TOP * 3 + 1], b0 = sky[RIDGE_TOP * 3 + 2];\n  for (let x = 0; x \u003c W; x++) {\n    const top = H - RIDGE[x];\n    for (let y = max(0, floor(top)); y \u003c H; y++) {\n      const q = (y * W + x) * 3, rim = y - top \u003c 1.2 ? 0.5 : 0;\n      const dx = (x + 0.5 - MX) / (MW / 2), dy = (H - 0.5 - y) / MH;\n      const cave = dx * dx + dy * dy \u003c 1;\n      if (cave) rgb[q] = rgb[q + 1] = rgb[q + 2] = 0;\n      else {\n        rgb[q] = 0.15 + rim * r0 * 0.5;\n        rgb[q + 1] = 0.075 + rim * g0 * 0.5;\n        rgb[q + 2] = 0.17 + rim * b0 * 0.5;\n      }\n    }\n  }\n  // The bats: three LEDs each, wings up, level, down, a third of a beat\n  // each. Bats on the far side of the band are a little hazed with the sky\n  // behind them, which shows which way the ribbon turns.\n  const { x, y, ph, dp, live } = S;\n  for (let i = 0; i \u003c S.count; i++) {\n    if (!live[i]) continue;\n    const bx = round(x[i]), by = round(y[i]), st = floor(ph[i] * 3) % 3, wy = st - 1, hz = 0.3 * max(0, -dp[i]);\n    for (let w = -1; w \u003c= 1; w++) {\n      const px = bx + w, py = by + (w ? wy : 0);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const q = (py * W + px) * 3, sy = min(py, RIDGE_TOP) * 3;\n      rgb[q] = 0.02 + hz * sky[sy];\n      rgb[q + 1] = 0.008 + hz * sky[sy + 1];\n      rgb[q + 2] = 0.03 + hz * sky[sy + 2];\n    }\n  }\n  for (let yy = 0, q = 0; yy \u003c H; yy++)\n    for (let xx = 0; xx \u003c W; xx++, q += 3) display.setPixel(xx, yy, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","candle-vigil":"// ===== Patternflow pattern =====\n// Title:   Candle Vigil\n// Family:  halloween\n// Idea:    Three pillar candles of purple, ivory and pumpkin wax stand on a dark purple floor, their teardrop flames swaying and flickering in a warm halo that breathes with them, wax drips forming at the rims and creeping down the sides, a draft now and then bending every flame the same way, and a flame now and then guttering out in a thin curl of smoke before it lights again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Candles=3..6, Draft=0..1\n//\n// Knob 1: Hue. Turns the colours of the wax round the wheel; the flames and their light stay candle light. At 0 purple, ivory and pumpkin orange (then toxic green, black and violet as more candles come); at 0.5 the purple wax turns olive and the orange wax sky blue.\n// Knob 2: Speed. How fast the room lives. At 2 a flame sways about twice a second and its light flickers about nine times, a drip starts down at 3 to 6 LEDs a second and slows to a stop, and smoke leaves the wick at 8 LEDs a second; at 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Candles. How many candles stand on the floor, 3 to 6, each 15 LEDs wide at 3 and 8 at 6, between 50 and 90 LEDs tall. Each throws less light the more there are, so six light the room about as much as three.\n// Knob 4: Draft. How much the air moves. At 0 a draft comes about every 18 s and one of three flames gutters out about once a minute; at 0.06 a draft every 15 s and a guttering every 40 s, the first draft at 4 s and the first guttering at 6.5 s; at 1 a draft every 5 s, every flame leaning hard to the right even between them and fluttering, and a guttering every 7 or 8 s. A guttered flame stays dark 3 to 4.5 s while its smoke curls up, then lights again.\n\nconst W = 64, H = 128, FLOOR = 123;\nconst { floor, round, min, max, abs, exp, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n// Smooth 1-D value noise, -1..1.\nconst vn = (x, s) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + s) * (1 - u) + hash((i + 1) * 7919 + s) * u) * 2 - 1;\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Wax colours as hue, saturation, value: purple, ivory, pumpkin, toxic\n// green, black, violet. Which candle gets which, for 3 to 6 candles, and how\n// tall each stands.\nconst WAX = [[0.78, 0.6, 0.55], [0.11, 0.22, 0.85], [0.075, 0.85, 0.8], [0.3, 0.85, 0.6], [0.76, 0.3, 0.2], [0.84, 0.45, 0.65]];\nconst ORDER = { 3: [0, 1, 2], 4: [0, 1, 3, 2], 5: [4, 0, 1, 3, 2], 6: [4, 0, 1, 5, 3, 2] };\nconst TALL = { 3: [68, 90, 52], 4: [62, 88, 74, 50], 5: [54, 80, 90, 64, 50], 6: [50, 76, 90, 58, 84, 54] };\n// Flame palette by heat: deep orange at the rim, white-yellow in the core.\nconst HEAT = [[0, 0.95, 0.32, 0.03], [0.28, 1, 0.55, 0.08], [0.5, 1, 0.82, 0.3], [0.68, 1, 0.95, 0.72], [1, 1, 1, 0.92]];\nconst WARM = [1, 0.52, 0.1], ROSE = [0.95, 0.36, 0.3], BLUE = [0.18, 0.32, 1], SMOKE = [0.6, 0.55, 0.72];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 1, draft: 0.06, count: 0, t: 0, real: 0,\n    cands: [], gust: 0, gDir: 1, gStart: -1, gLen: 0, gPow: 0, nextGust: -1,\n    // The opening guttering: the right-hand candle goes out at 6.5 s.\n    scripted: true,\n    rgb: new Float32Array(W * H * 3), c3: [0, 0, 0],\n  };\n}\n\nfunction build(P, n) {\n  const sw = W / n, cands = [];\n  for (let i = 0; i \u003c n; i++) {\n    const w = min(15, max(8, round(sw * 0.72))), h = TALL[n][i];\n    const xc = (i + 0.5) * sw + (hash(i * 31 + n) - 0.5) * sw * 0.12;\n    const x0 = round(xc - w / 2);\n    cands.push({\n      x0, w, xc: x0 + w / 2, top: FLOOR - h, wax: WAX[ORDER[n][i]], seed: i * 101 + 7,\n      mode: \"lit\", mt: 0, s: 1, wait: 0, drips: [], wisp: [], emit: 0, ember: 0,\n      // Flame for this frame: base, height, half-width, lean, light.\n      fx: 0, fy: 0, hf: 0, r: 0, lean: 0, I: 1,\n    });\n  }\n  P.cands = cands;\n  P.count = n;\n  // More candles light the room no brighter than three: each throws less.\n  P.share = (3 / n) ** 0.8;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 3, 0.06];\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3) / 2;\n  P.draft = cl(k[3], 0, 1);\n  const n = cl(round(k[2]), 3, 6);\n  if (n !== P.count) build(P, n);\n  const real = cl(dt || 0, 0, 0.1), d = real * P.speed;\n  P.real += real;\n  P.t += d;\n  const t = P.t, dr = P.draft;\n  // The first draft comes at 4 s, sooner the more the air moves.\n  if (P.nextGust \u003c 0) P.nextGust = 4 - 2.5 * dr;\n\n  // Drafts: a gust rises in 0.5 s, holds and then dies away over 1.2 s, all\n  // flames leaning its way.\n  if (t >= P.nextGust && P.gStart \u003c 0) {\n    P.gStart = t;\n    P.gDir = Math.random() \u003c 0.5 ? -1 : 1;\n    P.gLen = 1.2 + 1.3 * Math.random();\n    P.gPow = 0.6 + 0.4 * Math.random();\n  }\n  if (P.gStart >= 0) {\n    const a = t - P.gStart;\n    P.gust = P.gDir * P.gPow * sm(0, 0.5, a) * (1 - sm(P.gLen, P.gLen + 1.2, a));\n    if (a > P.gLen + 1.2) {\n      P.gStart = -1;\n      P.gust = 0;\n      P.nextGust = t - Math.log(1 - Math.random() * 0.95) / (0.06 + 0.35 * dr);\n    }\n  }\n  const breeze = 0.45 * dr * dr, flutter = abs(P.gust) + 0.7 * dr;\n  let out = 0;\n  for (const c of P.cands) if (c.mode !== \"lit\") out++;\n\n  for (const c of P.cands) {\n    c.mt += d;\n    const sd = c.seed;\n    // A flame goes out, stays dark a while, then lights again.\n    if (c.mode === \"lit\") {\n      let chance = (0.006 + 0.05 * dr + (abs(P.gust) > 0.6 ? 0.15 * dr : 0)) * d;\n      if (out) chance *= 0.3;\n      // The opening keeps its own guttering at 6.5 s and none before 10 s.\n      if (P.scripted || P.real \u003c 10) chance = 0;\n      const due = P.scripted && c === P.cands[P.cands.length - 1] && P.real >= 6.5;\n      if (due || Math.random() \u003c chance) {\n        if (due) P.scripted = false;\n        (c.mode = \"dying\"), (c.mt = 0), out++;\n      }\n    } else if (c.mode === \"dying\") {\n      c.s = 1 - sm(0, 1.1, c.mt);\n      if (c.mt > 1.1) (c.mode = \"out\"), (c.mt = 0), (c.s = 0), (c.ember = 1), (c.wait = 3 + 1.5 * Math.random());\n    } else if (c.mode === \"out\") {\n      c.ember = max(0, 1 - c.mt / 2);\n      if (c.mt > c.wait) (c.mode = \"relight\"), (c.mt = 0);\n    } else if (c.mode === \"relight\") {\n      c.s = sm(0.25, 1.2, c.mt);\n      if (c.mt > 1.2) (c.mode = \"lit\"), (c.mt = 0), (c.s = 1);\n    }\n    if (P.scripted && c.mode !== \"lit\") P.scripted = false;\n\n    // The flame: noise for height and sway, the draft for lean.\n    const n1 = vn(t * 2.8, sd), n2 = vn(t * 9, sd + 1), n3 = vn(t * 1.9, sd + 2), n4 = vn(t * 14, sd + 3);\n    const flick = 1 + 0.12 * n1 + 0.07 * n2 + 0.1 * flutter * n4;\n    c.lean = 0.22 * n3 + 0.07 * n2 + P.gust * (0.5 + 0.4 * dr) + breeze + 0.08 * flutter * n4;\n    const bend = min(1, abs(c.lean));\n    const hf0 = cl(c.w * 1.9, 13, 28), sz = c.s * (c.mode === \"dying\" ? 1 + 0.25 * vn(t * 20, sd) : 1);\n    c.hf = hf0 * sz * flick * (1 - 0.3 * bend);\n    c.r = hf0 * 0.23 * (c.s > 0 ? c.s ** 0.6 : 0) * (1 + 0.15 * bend);\n    // A flame bent by the air is smaller and gives less light.\n    c.I = c.s * (0.72 + 0.16 * n1 + 0.16 * n2 + 0.06 * flutter * n4) * (1 - 0.3 * bend);\n    c.fx = round(c.xc - 0.5);\n    c.fy = c.top - 2;\n\n    // Drips: a bead swells on the rim for half a second, runs down fast and\n    // slows to a stop, holds for 40 s and sinks back into the wax over 10.\n    if (c.mode === \"lit\" && c.drips.length \u003c 7 && Math.random() \u003c 0.16 * d) {\n      const edge = Math.random() \u003c 0.45;\n      const dx = edge ? (Math.random() \u003c 0.5 ? -1 : c.w) : 1 + floor(Math.random() * (c.w - 3));\n      if (!c.drips.some((q) => abs(q.dx - dx) \u003c 3))\n        c.drips.push({ dx, len: 0, max: 8 + Math.random() * min(46, (FLOOR - c.top) * 0.6), v: 3 + 3 * Math.random(), age: 0, wig: Math.random() * 9 });\n    }\n    for (const q of c.drips) {\n      q.age += d;\n      if (q.age > 0.5) q.len = q.max * (1 - exp((-(q.age - 0.5) * q.v) / q.max));\n    }\n    c.drips = c.drips.filter((q) => q.age \u003c 60);\n\n    // Smoke: for 2.5 s after the flame dies a curl leaves the wick, rising\n    // 10 LEDs a second and swinging with the air.\n    if (c.mode === \"out\" && c.mt \u003c 2.5) {\n      c.emit += 40 * d;\n      for (; c.emit >= 1; c.emit--)\n        c.wisp.push({ x: c.fx + 0.5, y: c.fy, a: 0, ph: t * 2.1 + c.seed, w: 1 - c.mt / 2.5 });\n    }\n    for (const p of c.wisp) {\n      p.a += d;\n      p.y -= (8 + 4 * p.a) * d;\n      p.x += (5 * sin(p.ph + p.a * 2.4) * min(1, p.a) + (P.gust + breeze) * 14) * d;\n    }\n    c.wisp = c.wisp.filter((p) => p.a \u003c 4 && p.y > -2);\n  }\n}\n\n// Where a flame is and how hot, at LED (x, y): 0 outside.\nfunction flameAt(c, x, y, out) {\n  if (c.s \u003c= 0.02) return 0;\n  const tau = (c.fy + 1 - y + c.hf * 0.12) / (c.hf * 1.12);\n  if (tau \u003c= 0 || tau >= 1) return 0;\n  const prof = (sqrt(tau) * (1 - tau) ** 1.1) / 0.37;\n  const xc = c.fx + 0.5 + c.lean * c.hf * tau ** 1.7;\n  const d = abs(x + 0.5 - xc) / max(0.3, c.r * prof);\n  if (d >= 1) return 0;\n  const heat = cl((1 - d) * (1.15 - 0.95 * tau), 0, 1);\n  let j = 0;\n  while (j \u003c HEAT.length - 2 && heat > HEAT[j + 1][0]) j++;\n  const [h0, r0, g0, b0] = HEAT[j], [h1, r1, g1, b1] = HEAT[j + 1], f = cl((heat - h0) / (h1 - h0), 0, 1);\n  (out[0] = r0 + (r1 - r0) * f), (out[1] = g0 + (g1 - g0) * f), (out[2] = b0 + (b1 - b0) * f);\n  // The thin blue base, and a small flame is mostly blue.\n  const bw = max((1 - tau / 0.26) * sm(0.15, 0.7, d), c.s \u003c 0.45 ? (1 - c.s / 0.45) * 0.8 : 0);\n  for (let i = 0; i \u003c 3; i++) out[i] += (BLUE[i] - out[i]) * cl(bw, 0, 1);\n  return sm(1, 0.68, d) * cl(tau / 0.07, 0, 1) * (1 - sm(0.86, 1, tau));\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.cands.length) return;\n  const { rgb, c3, cands } = P;\n  // Light in the air round each flame: a tight halo and a wide one, both\n  // breathing with the flame.\n  rgb.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const g = y / (H - 1), br = 0.008 + 0.05 * g * g, bg = 0.002 + 0.012 * g * g, bb = 0.015 + 0.072 * g * g;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let L = 0, F = 0;\n      for (const c of cands) {\n        if (c.I \u003c= 0.01) continue;\n        const cx = c.fx + 0.5 + c.lean * c.hf * 0.45, cy = c.fy - c.hf * 0.4;\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, d2 = dx * dx + dy * dy, s1 = 9 + 3 * c.I;\n        L += c.I * P.share * 0.42 * exp(-d2 / (2 * s1 * s1));\n        F += c.I * P.share * 0.1 * exp(-d2 / 1100);\n      }\n      // The near halo is flame orange; the far one leans rose, so where it\n      // thins out over the purple it does not read brown.\n      (rgb[p * 3] = br + WARM[0] * L + ROSE[0] * F), (rgb[p * 3 + 1] = bg + WARM[1] * L + ROSE[1] * F), (rgb[p * 3 + 2] = bb + WARM[2] * L + ROSE[2] * F);\n    }\n  }\n  // The floor: dark plum, lit in pools under the flames.\n  for (let y = FLOOR; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let L = 0;\n      for (const c of cands) {\n        const dx = (x + 0.5 - c.xc) / 18;\n        L += c.I * P.share * 0.5 * exp(-dx * dx) * (1 - (y - FLOOR) * 0.12);\n      }\n      (rgb[p * 3] = 0.07 + 0.55 * L), (rgb[p * 3 + 1] = 0.025 + 0.28 * L), (rgb[p * 3 + 2] = 0.1 + 0.07 * L);\n    }\n\n  for (const c of cands) {\n    const wax = hsv(c.wax[0] + P.hue, c.wax[1], c.wax[2], [0, 0, 0]);\n    // A wax LED's colour: lit by every flame by distance, rounder in the\n    // middle, glowing through from its own flame near the top.\n    const waxAt = (x, y, lift) => {\n      const u = (x + 0.5 - c.xc) / (c.w / 2), cyl = 0.45 + 0.55 * sqrt(max(0, 1 - u * u));\n      let L = 0;\n      for (const o of cands) {\n        if (o.I \u003c= 0.01) continue;\n        const dx = o.fx + 0.5 - (x + 0.5), dy = o.fy - (y + 0.5), r = (dx * dx + dy * dy) / 450;\n        const face = o === c ? 1 : P.share * cl(0.55 + 0.6 * u * Math.sign(dx), 0.15, 1.15);\n        L += (o.I * face) / (1 + r);\n      }\n      const glow = c.I * 0.5 * exp(-(y - c.top) / 6);\n      const k = (0.16 + 0.95 * L) * cyl * lift;\n      (c3[0] = wax[0] * k + glow * 1.0), (c3[1] = wax[1] * k + glow * 0.6), (c3[2] = wax[2] * k + glow * 0.28);\n      return c3;\n    };\n    const put = (x, y, col) => {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n      const o = (y * W + x) * 3;\n      (rgb[o] = col[0]), (rgb[o + 1] = col[1]), (rgb[o + 2] = col[2]);\n    };\n    // Body, with the rim standing a little proud of the melt pool.\n    for (let y = c.top - 1; y \u003c FLOOR; y++)\n      for (let x = c.x0; x \u003c c.x0 + c.w; x++) {\n        const u = (x + 0.5 - c.xc) / (c.w / 2);\n        if (y === c.top - 1 && abs(u) \u003c 0.72) continue;\n        put(x, y, waxAt(x, y, 1));\n        // The melt pool: a shallow lit ellipse inside the rim.\n        const e = (u / 0.8) ** 2 + ((y - c.top - 0.6) / 1.4) ** 2;\n        if (e \u003c 1 && c.s > 0) {\n          const o = (y * W + x) * 3, k = c.I * (1 - e) * 0.75;\n          (rgb[o] += k), (rgb[o + 1] += k * 0.62), (rgb[o + 2] += k * 0.3);\n        }\n      }\n    // Drips: a raised streak, lighter on its left, a bead at its foot. A drip\n    // on the edge stands one LED out from the side.\n    for (const q of c.drips) {\n      const fade = 1 - sm(50, 60, q.age), bead = q.age \u003c 0.5 ? q.age / 0.5 : 1;\n      if (q.len \u003c 0.5 && bead \u003c 1) {\n        const x = c.x0 + q.dx, y = c.top;\n        const col = waxAt(cl(x, c.x0, c.x0 + c.w - 1), y, 1.25 * bead + (1 - bead));\n        put(x, y, col);\n        continue;\n      }\n      const end = c.top + round(q.len);\n      for (let y = c.top; y \u003c= end; y++) {\n        const x = c.x0 + q.dx + (vn(y * 0.18 + q.wig, 5) > 0.55 ? 1 : 0) * (q.dx >= 0 && q.dx \u003c c.w - 1 ? 1 : 0);\n        const lift = 1 + 0.32 * fade;\n        put(x, y, waxAt(cl(x, c.x0, c.x0 + c.w - 1), y, lift));\n        if (q.dx >= 0 && q.dx \u003c c.w - 1) put(x + 1, y, waxAt(x + 1, y, 1 + 0.12 * fade));\n        if (y === end) {\n          put(x - 1, y, waxAt(cl(x - 1, c.x0, c.x0 + c.w - 1), y, 1 + 0.2 * fade));\n          put(x, y + 1, waxAt(cl(x, c.x0, c.x0 + c.w - 1), y + 1, 1 + 0.25 * fade));\n        }\n      }\n    }\n    // Wick, and its ember after the flame dies.\n    for (let y = c.top - 3; y \u003c c.top; y++) put(c.fx, y, [0.07, 0.04, 0.05]);\n    if (c.ember > 0) put(c.fx, c.top - 3, [0.9 * c.ember, 0.25 * c.ember, 0.05 * c.ember]);\n    if (c.mode === \"relight\" && c.mt \u003c 0.3) put(c.fx, c.top - 4, [1, 0.95, 0.8]);\n  }\n  // Flames over everything.\n  for (const c of cands) {\n    if (c.s \u003c= 0.02) continue;\n    const reach = c.r + abs(c.lean) * c.hf + 2;\n    for (let y = max(0, floor(c.fy - c.hf - 1)); y \u003c= min(H - 1, c.fy + 2); y++)\n      for (let x = max(0, floor(c.fx - reach)); x \u003c= min(W - 1, c.fx + reach + 1); x++) {\n        const a = flameAt(c, x, y, c3);\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        for (let i = 0; i \u003c 3; i++) rgb[o + i] = rgb[o + i] * (1 - a) + c3[i] * a;\n      }\n  }\n  // Smoke curls, thin and grey-violet, fading as they rise.\n  for (const c of cands)\n    for (const p of c.wisp) {\n      const x = floor(p.x), y = floor(p.y);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const a = 0.55 * (1 - p.a / 4) * (0.4 + 0.6 * p.w), o = (y * W + x) * 3;\n      for (let i = 0; i \u003c 3; i++) rgb[o + i] = max(rgb[o + i], rgb[o + i] * (1 - a) + SMOKE[i] * a);\n    }\n  // Out in steps of 4 levels, 64 to a channel: the soft light then packs\n  // into runs, and no step shows on the panel.\n  const lv = (v) => min(255, round(v * 63.75) * 4);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, lv(rgb[o]), lv(rgb[o + 1]), lv(rgb[o + 2]));\n}\n","fput-recurrence":"// ===== Patternflow pattern =====\n// Title:   FPUT Recurrence\n// Family:  physics\n// Idea:    The 1955 chain of 31 masses on springs with a quadratic term vibrates as a string down the panel, plucked with all its energy in its lowest mode; the energy runs into modes 2, 3 and 4, drawn as coloured lobes round the string, until mode 1 keeps 9% of it, and 147 swings after the pluck 98% of it is back in mode 1.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fermi–Pasta–Ulam–Tsingou problem (Enrico Fermi, John Pasta, Stanislaw Ulam, Mary Tsingou, 1955), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Amplitude=1..1.9, Alpha=0..1\n//\n// Knob 1: Hue. Turns the mode colours round the wheel together. At 0 mode 1 is magenta, mode 2 cyan, mode 3 gold, mode 4 green and modes 5 to 8 a pale ice blue; at 0.5 mode 1 is green and mode 2 red.\n// Knob 2: Speed. At 2 the chain runs 300 units of its own time a second, so mode 1 swings 4.7 times a second and the energy is back in mode 1 after 31 seconds; at 0.2 a swing takes 2.1 seconds and the return 5 minutes, at 3 the return takes 21 seconds.\n// Knob 3: Amplitude. How far the pluck pulls the middle mass: 1 unit at the start, as in 1955, drawn 24 LEDs to the side; up to 1.9 units, drawn 31 LEDs to the side, the scale shrinking so the string stays on the panel. Only Alpha times Amplitude matters to the motion. At 1.9 mode 1 drops to 4.5% and 97% is back after 107 swings.\n// Knob 4: Alpha. The strength of the springs' quadratic term, alpha = 0.25 times the square root of the knob over 0.06: 0.25 at 0.06, where the knob opens, as in 1955; 0.5 at 0.24; 1.02 at 1, where mode 1 drops to 2% and 95% is back after 73 swings. At 0 the springs are linear and the energy never leaves mode 1. With Amplitude at 1.9 and Alpha at 1 the energy runs up into modes 5 to 8 within 2 seconds and does not come back in two minutes. A turned Amplitude or Alpha plucks the chain again once the knob has rested 0.4 seconds.\n// Buttons: K1 tap plucks the chain again, all its energy in mode 1.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The chain: N springs, masses 1..N-1 moving, masses 0 and N held. In the\n// model each mass moves along the chain; here its displacement is drawn\n// sideways, so the chain reads as a string stretched from the top of the\n// panel to the bottom.\nconst N = 32;\n// Rows of the two held ends and the step between masses.\nconst Y0 = 0.5, DY = 127 / N;\nconst CX = 31.5;\n// LEDs per unit of displacement: 24 at amplitude 1, fewer for a bigger\n// pluck so the swing stays on the panel, 31 LEDs either side at 1.9.\nconst scaleOf = (A) => 24 * A ** -0.6;\n// Velocity Verlet step in the chain's own time. With a step of 0.1 the\n// energy is back in mode 1 after 147 periods of mode 1 (T1 = 64.03); 0.05\n// gives the same within half a period. A coarser step stretches it: a step\n// of 0.354, the square root of 1/8, gives 157 periods and 0.4 gives 160.\nconst HSTEP = 0.1;\n// Chain time per second at Speed 1.\nconst RATE = 150;\n// Mode k: frequency 2 sin(pi k / 2N), shape sqrt(2/N) sin(pi k i / N).\nconst OM = new Float64Array(N), SH = new Float64Array(N * (N + 1));\nfor (let k = 1; k \u003c N; k++) {\n  OM[k] = 2 * sin((PI * k) / (2 * N));\n  for (let i = 0; i \u003c= N; i++) SH[k * (N + 1) + i] = sqrt(2 / N) * sin((PI * k * i) / N);\n}\nconst T1 = (2 * PI) / OM[1];\n// Energy of mode 1 plucked to amplitude 1: the unit the lobes are drawn in.\nconst EREF = 0.5 * OM[1] * OM[1] * (N / 2);\n// Mode colours at Hue 0: magenta, cyan, gold and green for modes 1 to 4,\n// and one pale ice blue for modes 5 to 8. At the opening knobs mode 5 holds\n// 15% at most and mode 6 4%; a larger Alpha or Amplitude fills up to mode 8.\nconst MHUE = [0, 0.87, 0.5, 0.13, 0.3, 0.58, 0.58, 0.58, 0.58], MSAT = [0, 0.75, 0.8, 0.7, 0.75, 0.35, 0.35, 0.35, 0.35];\nconst GHOSTS = 8;\n// Lobe fill, as a share of the outline's level.\nconst FILL = 0.2;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst alphaOf = (k) => 0.25 * sqrt(max(0, k) / 0.06);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, amp: 1, alpha: 0.25, ampSet: -1, alphaSet: -1, wait: 0, begun: false,\n    u: new Float64Array(N + 1), v: new Float64Array(N + 1), a: new Float64Array(N + 1),\n    clock: 0, carry: 0, e: new Float64Array(N), es: new Float64Array(N),\n    rgb: new Float32Array(W * H * 3), col: new Float32Array(3 * (GHOSTS + 1)),\n  };\n}\n\nfunction accel(S) {\n  const { u, a } = S, al = S.alphaSet;\n  for (let i = 1; i \u003c N; i++) {\n    const dr = u[i + 1] - u[i], dl = u[i] - u[i - 1];\n    a[i] = dr - dl + al * (dr * dr - dl * dl);\n  }\n}\n\nfunction modes(S, out) {\n  const { u, v } = S;\n  for (let k = 1; k \u003c N; k++) {\n    let q = 0, p = 0;\n    const o = k * (N + 1);\n    for (let i = 1; i \u003c N; i++) {\n      q += SH[o + i] * u[i];\n      p += SH[o + i] * v[i];\n    }\n    out[k] = 0.5 * (p * p + OM[k] * OM[k] * q * q);\n  }\n}\n\nfunction pluck(S) {\n  const { u, v } = S;\n  S.ampSet = S.amp;\n  S.alphaSet = S.alpha;\n  for (let i = 0; i \u003c= N; i++) {\n    u[i] = S.amp * sin((PI * i) / N);\n    v[i] = 0;\n  }\n  u[0] = u[N] = 0;\n  accel(S);\n  S.clock = 0;\n  S.carry = 0;\n  modes(S, S.es);\n  S.wait = 0;\n}\n\n// The string's column at row y (any real y), straight between masses.\nfunction colAt(u, y, sc) {\n  const f = cl((y - Y0) / DY, 0, N), i = min(N - 1, floor(f)), t = f - i;\n  return CX + sc * (u[i] + (u[i + 1] - u[i]) * t);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.amp = cl(k[2], 1, 1.9);\n  S.alpha = alphaOf(cl(k[3], 0, 1));\n  if (!S.begun) {\n    pluck(S);\n    S.begun = true;\n  }\n  if (abs(S.amp - S.ampSet) > 0.004 || abs(S.alpha - S.alphaSet) > 0.004) {\n    S.wait += d;\n    if (S.wait > 0.4) pluck(S);\n  } else S.wait = 0;\n  if (input.btnPressed && input.btnPressed[0]) pluck(S);\n\n  const { u, v, a } = S;\n  S.carry += d * S.speed * RATE;\n  while (S.carry >= HSTEP) {\n    for (let i = 1; i \u003c N; i++) {\n      v[i] += 0.5 * HSTEP * a[i];\n      u[i] += HSTEP * v[i];\n    }\n    accel(S);\n    for (let i = 1; i \u003c N; i++) v[i] += 0.5 * HSTEP * a[i];\n    S.carry -= HSTEP;\n    S.clock += HSTEP;\n  }\n  // A chain thrown past its springs' hump starts again.\n  let big = 0;\n  for (let i = 1; i \u003c N; i++) big = max(big, abs(u[i]));\n  if (!(big \u003c 6)) pluck(S);\n  // Mode energies, smoothed over one period of mode 1 so the lobes show\n  // where the energy is, not the swing of each mode.\n  modes(S, S.e);\n  const g = 1 - exp(-(d * S.speed * RATE) / T1);\n  for (let k2 = 1; k2 \u003c N; k2++) S.es[k2] += (S.e[k2] - S.es[k2]) * g;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, col, es, u } = S, sc = scaleOf(S.ampSet);\n  for (let m = 1; m \u003c= GHOSTS; m++) hsv(S.hue + MHUE[m], MSAT[m], 1, col, 3 * m);\n  let tot = 0;\n  for (let k = 1; k \u003c N; k++) tot += es[k];\n  tot = max(tot, 1e-12);\n  // String colour: the modes' colours weighted by the fourth power of their\n  // shares, so the string takes the colour of the mode holding the most.\n  let wr = 0, wg = 0, wb = 0, ws = 0;\n  for (let m = 1; m \u003c= GHOSTS; m++) {\n    const w = (es[m] / tot) ** 4;\n    wr += w * col[3 * m];\n    wg += w * col[3 * m + 1];\n    wb += w * col[3 * m + 2];\n    ws += w;\n  }\n  ws = max(ws, 1e-9);\n  const sr = wr / ws, sg = wg / ws, sb = wb / ws;\n  rgb.fill(0);\n  // Lobes: mode m as the envelope it would swing through if it held its\n  // energy alone, |sin(pi m y / L)| wide, outlined in its colour. A mode\n  // holding under 5% of the energy is not drawn; from 20% it is at full.\n  for (let m = 1; m \u003c= GHOSTS; m++) {\n    const sh = es[m] / tot, w = sc * sqrt(es[m] / EREF), lv = 0.85 * sm(0.05, 0.2, sh);\n    if (w \u003c 0.8 || lv \u003c= 0) continue;\n    const cr = col[3 * m] * lv, cg = col[3 * m + 1] * lv, cb = col[3 * m + 2] * lv, L = N * DY;\n    for (let y = 0; y \u003c H; y++) {\n      const hw0 = w * abs(sin((PI * m * (y - Y0)) / L)), hw1 = w * abs(sin((PI * m * (y + 1 - Y0)) / L));\n      const lo = min(hw0, hw1) - 0.6, hi = max(hw0, hw1) + 0.6;\n      for (let x = max(0, floor(CX - lo + 1)); x \u003c= min(W - 1, floor(CX + lo - 1)); x++) {\n        const q = (y * W + x) * 3;\n        rgb[q] = max(rgb[q], FILL * cr);\n        rgb[q + 1] = max(rgb[q + 1], FILL * cg);\n        rgb[q + 2] = max(rgb[q + 2], FILL * cb);\n      }\n      for (const sgn of [-1, 1]) {\n        const xa = CX + sgn * lo, xb = CX + sgn * hi;\n        for (let x = max(0, floor(min(xa, xb))); x \u003c= min(W - 1, floor(max(xa, xb))); x++) {\n          const q = (y * W + x) * 3;\n          rgb[q] = max(rgb[q], cr);\n          rgb[q + 1] = max(rgb[q + 1], cg);\n          rgb[q + 2] = max(rgb[q + 2], cb);\n        }\n      }\n    }\n  }\n  // The string, straight between masses, and the 31 masses on it.\n  for (let y = 0; y \u003c H; y++) {\n    const xa = colAt(u, y, sc), xb = colAt(u, y + 1, sc), x0 = floor(min(xa, xb) - 0.4), x1 = floor(max(xa, xb) + 0.4);\n    for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) {\n      const q = (y * W + x) * 3;\n      rgb[q] = 0.25 + 0.75 * sr;\n      rgb[q + 1] = 0.25 + 0.75 * sg;\n      rgb[q + 2] = 0.25 + 0.75 * sb;\n    }\n  }\n  for (let i = 1; i \u003c N; i++) {\n    const bx = CX + sc * u[i], by = Y0 + i * DY;\n    for (let y = floor(by - 1); y \u003c= floor(by + 1); y++)\n      for (let x = floor(bx - 1); x \u003c= floor(bx + 1); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        if ((x + 0.5 - bx) ** 2 + (y + 0.5 - by) ** 2 > 1.2) continue;\n        const q = (y * W + x) * 3;\n        rgb[q] = rgb[q + 1] = rgb[q + 2] = 1;\n      }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","graveyard-fog":"// ===== Patternflow pattern =====\n// Title:   Graveyard Fog\n// Family:  halloween\n// Idea:    Banks of ground fog roll sideways at three depths through a night graveyard of black headstones, a cross, a leaning stone and a crooked iron fence under a thin crescent moon, the mist carrying a fine one-LED dither like suspended droplets, while small toxic-green will-o'-wisps bob and drift between the stones and light the fog round them.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wisps=4..14, Fog=0..1\n//\n// Knob 1: Hue. Turns the fog, the sky and the wisps round the wheel together. At 0 the fog is a cold periwinkle under a deep violet sky and the wisps are toxic green; at 0.25 the fog goes rose and the wisps sky blue; at 0.6 the fog is green under a dark green sky and the wisps pink. From about 0.2 to 0.53, where the sky would come out maroon, brown or olive, it is held purple instead.\n// Knob 2: Speed. How fast the fog rolls: at 2 the front bank slides 9 LEDs a second, the middle one 4.5 and the far one 2.5, and a wisp bobs once in about 4 seconds; at 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Wisps. How many will-o'-wisps there are, 4 to 14. Each one floats at its own depth, so a stone or the fence can hide it as it passes, and lights the fog for about 10 LEDs round it. Every wisp past the fourth also gives all the fog 3% of their green, so at 14 the banks have a green cast.\n// Knob 4: Fog. How high and thick the banks stand. Near 0 the front bank reaches the knees of the near stones; at 1 it climbs past the crossbar of the cross, the middle bank swallows the fence, the far bank rises half again and the haze over the sky thickens by a third.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Value noise on a 256 x 256 lattice of fixed random values.\nconst NT = new Float32Array(65536);\nfor (let i = 0; i \u003c 65536; i++) NT[i] = hash(i * 7 + 3);\nfunction vn(x, y) {\n  const xi = floor(x), yi = floor(y);\n  let fx = x - xi, fy = y - yi;\n  fx = fx * fx * (3 - 2 * fx);\n  fy = fy * fy * (3 - 2 * fy);\n  const x0 = xi & 255, x1 = (xi + 1) & 255, y0 = (yi & 255) \u003c\u003c 8, y1 = ((yi + 1) & 255) \u003c\u003c 8;\n  const a = NT[y0 + x0], b = NT[y0 + x1], c = NT[y1 + x0], d = NT[y1 + x1];\n  return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;\n}\n\n// ---- The graveyard, built once as coverage masks (4 x 4 samples per LED).\n// Far row: small stones standing on a low rise at row 84.\nconst FAR_BASE = 84;\n// Front row: three big stones on the ground at row 125.\nconst FRONT_BASE = 125;\n// The fence stands on row 111.\nconst FENCE_BASE = 111;\n\nfunction roundStone(px, py, cx, base, w, h, lean) {\n  const dx = px - cx, dy = py - base, c = cos(lean), s = sin(lean);\n  const lx = dx * c - dy * s, ly = dx * s + dy * c, r = w / 2;\n  if (ly > 1 || abs(lx) > r || ly \u003c -h) return false;\n  const top = -h + r;\n  return ly >= top || lx * lx + (ly - top) * (ly - top) \u003c= r * r;\n}\nfunction gableStone(px, py, cx, base, w, h, peak) {\n  const dx = abs(px - cx), up = base - py;\n  if (up \u003c -1 || up > h || dx > w / 2) return false;\n  return up \u003c= h - peak || dx \u003c= ((w / 2) * (h - up)) / peak;\n}\nfunction cross(px, py, cx, base, h, bw, aw, ay, at) {\n  const dx = abs(px - cx), up = base - py;\n  if (up \u003c -1) return false;\n  if (up \u003c= h && dx \u003c= bw / 2) return true;\n  if (dx \u003c= aw / 2 && abs(up - ay) \u003c= at / 2) return true;\n  return up \u003c= 4 && dx \u003c= 6.5;\n}\n\nfunction farInside(px, py) {\n  if (py >= FAR_BASE + 1.5 * sin(px * 0.16 + 1)) return true;\n  return (\n    roundStone(px, py, 4, FAR_BASE + 1, 7, 10, -0.05) ||\n    cross(px, py, 16, FAR_BASE + 1, 14, 2.4, 8, 10, 2.2) ||\n    gableStone(px, py, 26.5, FAR_BASE + 1, 6, 9, 3) ||\n    roundStone(px, py, 38, FAR_BASE + 1, 8, 11, 0.12) ||\n    gableStone(px, py, 50, FAR_BASE + 1, 3.4, 15, 4) ||\n    roundStone(px, py, 60, FAR_BASE + 1, 6, 8, 0)\n  );\n}\n\nfunction frontInside(px, py) {\n  if (py >= FRONT_BASE + 1.2 * sin(px * 0.11 + 2)) return true;\n  return (\n    roundStone(px, py, 11.5, FRONT_BASE + 1, 15, 31, -0.03) ||\n    cross(px, py, 32, FRONT_BASE + 1, 39, 5, 18, 29, 5) ||\n    roundStone(px, py, 51.5, FRONT_BASE + 1, 13, 27, 0.24)\n  );\n}\n\n// The fence: thin iron pickets with spear tips, leaning this way and that,\n// on two sagging rails; one picket snapped short and one gone.\nconst PICKETS = [];\nfor (let i = 0; i \u003c 13; i++) {\n  if (i === 9) continue;\n  PICKETS.push({\n    x: 2.5 + 5 * i + (hash(i * 5 + 1) - 0.5) * 1.2,\n    lean: (hash(i * 5 + 2) - 0.5) * 0.16,\n    top: FENCE_BASE - 18 + (hash(i * 5 + 3) - 0.5) * 3 + (i === 5 ? 7 : 0),\n    tip: i !== 5,\n  });\n}\nconst RAILS = [FENCE_BASE - 5, FENCE_BASE - 14].map((y0, r) => PICKETS.map((p, i) => y0 + (hash(i * 11 + r * 3 + 7) - 0.5) * 2.4));\nfunction fenceInside(px, py) {\n  if (py > FENCE_BASE + 0.5) return false;\n  for (const p of PICKETS) {\n    const cx = p.x + p.lean * (FENCE_BASE - py);\n    if (py >= p.top && abs(px - cx) \u003c= 0.62) return true;\n    if (p.tip && py \u003c p.top && py >= p.top - 3.2 && abs(px - cx) \u003c= ((py - (p.top - 3.2)) / 3.2) * 1.7) return true;\n  }\n  for (const rail of RAILS)\n    for (let i = 0; i + 1 \u003c PICKETS.length; i++) {\n      const a = PICKETS[i], b = PICKETS[i + 1];\n      if (px \u003c a.x || px > b.x) continue;\n      const f = (px - a.x) / (b.x - a.x), y = rail[i] + (rail[i + 1] - rail[i]) * f;\n      if (abs(py - y) \u003c= 0.62) return true;\n    }\n  return false;\n}\n\nfunction buildMask(inside) {\n  const m = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let c = 0;\n      for (let j = 0; j \u003c 4; j++) for (let i = 0; i \u003c 4; i++) if (inside(x + (i + 0.5) / 4, y + (j + 0.5) / 4)) c++;\n      m[y * W + x] = c / 16;\n    }\n  return m;\n}\n\n// The crescent: a disc of radius 6.5 with a slightly smaller one cut from its\n// lower left, so a thin bow is left on the upper right.\nconst MOON_X = 47, MOON_Y = 19;\nfunction moonInside(px, py) {\n  const a = (px - MOON_X) ** 2 + (py - MOON_Y) ** 2, b = (px - MOON_X + 2.6) ** 2 + (py - MOON_Y - 1.4) ** 2;\n  return a \u003c= 6.5 * 6.5 && b > 6.1 * 6.1;\n}\n\n// Fog banks, back to front: the row they lie on, how high they stand at the\n// opening, how fast they slide at Speed 2 (LEDs a second), how much the Fog\n// knob raises them, how bright they are and how thick, and how big their\n// billows are.\nconst BANKS = [\n  { base: 86, h: 18, v: 2.5, rise: 0.5, lum: 0.62, op: 0.8, sx: 12, sy: 7, seed: 17 },\n  { base: 114, h: 22, v: 4.5, rise: 1.3, lum: 0.8, op: 0.84, sx: 15, sy: 8, seed: 59 },\n  { base: 131, h: 20, v: 9, rise: 2, lum: 1, op: 0.9, sx: 17, sy: 9, seed: 101 },\n];\n// Wisp depth slots: 0 behind the far stones, 1 between them and the fence,\n// 2 between the fence and the near stones, 3 in front of everything. Each\n// slot has the rows a wisp there floats at.\nconst SLOT_ROWS = [[72, 80], [86, 100], [98, 112], [108, 120]];\nconst WMAX = 14;\n// Grain: neighbouring LEDs alternate half a step above and below the fog,\n// so the mist carries a fine ordered dither. GRAIN is the half step at full\n// fog, in levels of 255.\nconst GRAIN = 16, AIR = 0.2;\n\nexport function setup(params) {\n  const wisps = [];\n  // The first four, the opening count, take slots 1, 2, 3 and 1 and are\n  // spread across the width; the rest are placed at random.\n  const open = [[1, 10], [2, 44], [3, 24], [1, 56]];\n  for (let i = 0; i \u003c WMAX; i++) {\n    const slot = i \u003c 4 ? open[i][0] : floor(Math.random() * 4);\n    const [r0, r1] = SLOT_ROWS[slot];\n    wisps.push({\n      slot,\n      x0: i \u003c 4 ? open[i][1] : Math.random() * W,\n      y0: r0 + Math.random() * (r1 - r0),\n      dir: Math.random() \u003c 0.5 ? -1 : 1,\n      v: 1.2 + Math.random() * 2,\n      ph: Math.random() * 2 * PI,\n      bob: 2 + Math.random() * 2.5,\n      flick: 0.6 + Math.random() * 0.8,\n    });\n  }\n  params.s = {\n    hue: 0, speed: 2, count: 4, fog: 0.06, t: 0,\n    far: buildMask(farInside), fence: buildMask(fenceInside), front: buildMask(frontInside), moon: buildMask(moonInside),\n    wisps, wx: new Float32Array(WMAX), wy: new Float32Array(WMAX), wb: new Float32Array(WMAX),\n    // Light the wisps cast on the fog, and their own glow at each depth.\n    lit: new Float32Array(N), glow: [new Float32Array(N), new Float32Array(N), new Float32Array(N), new Float32Array(N)],\n    tops: [new Float32Array(W), new Float32Array(W), new Float32Array(W)],\n    sky: new Float32Array(H * 3), fogC: [0, 0, 0], wispC: [0, 0, 0], hazeC: [0, 0, 0], colHue: NaN,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = round(cl(k[2], 4, WMAX));\n  S.fog = cl(k[3], 0, 1);\n  // The pattern's clock: one unit a second at Speed 2.\n  S.t += (d * S.speed) / 2;\n  const t = S.t;\n  for (let i = 0; i \u003c WMAX; i++) {\n    const w = S.wisps[i];\n    // Drift with the fog plus a slow wander, wrapping round the width.\n    let x = w.x0 + w.dir * w.v * t + 7 * sin(0.5 * t + w.ph);\n    x = ((((x + 8) % (W + 16)) + (W + 16)) % (W + 16)) - 8;\n    S.wx[i] = x;\n    S.wy[i] = w.y0 + w.bob * sin(1.6 * t + w.ph) + 1.1 * sin(3.7 * t + 2 * w.ph);\n    S.wb[i] = 0.82 + 0.18 * sin(w.flick * 9 * t + w.ph) * sin(w.flick * 5.3 * t);\n  }\n}\n\nfunction palette(S) {\n  const h = S.hue;\n  // Fog: cold periwinkle at Hue 0.\n  hsv(h + 0.68, 0.32, 1, S.fogC);\n  // Wisps: toxic yellow-green at Hue 0, always 0.6 of the wheel from the fog.\n  hsv(h + 0.28, 0.82, 1, S.wispC);\n  // Sky: a deep version of the fog's hue, a little further round. A dark\n  // sky from red through orange to yellow-green reads maroon, brown or\n  // olive, so across that stretch it is blended over to purple (0.8).\n  const sh = h + 0.73, dw = abs(((sh - 0.09 + 10.5) % 1) - 0.5), w = 1 - sm(0.17, 0.21, dw);\n  const c = [0, 0, 0], e = [0, 0, 0];\n  for (let y = 0; y \u003c H; y++) {\n    // Darkest at the top, a hazy glow toward the horizon at row 80.\n    const u = sm(0, 84, y), sat = 0.75 - 0.2 * u, val = 0.1 + 0.22 * u * u;\n    hsv(sh, sat, val, c);\n    hsv(0.8, sat, val, e);\n    for (let i = 0; i \u003c 3; i++) S.sky[y * 3 + i] = (c[i] + (e[i] - c[i]) * w) * 255;\n  }\n  hsv(sh, 0.45, 0.5, c);\n  hsv(0.8, 0.45, 0.5, e);\n  for (let i = 0; i \u003c 3; i++) S.hazeC[i] = c[i] + (e[i] - c[i]) * w;\n  S.colHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  const { far, fence, front, moon, lit, glow, tops, sky, fogC, wispC, hazeC, t } = S;\n  const fog = S.fog, thick = 0.88 + 0.12 * fog;\n  // Every wisp past the first four adds 3% of their green to all the fog.\n  const amb = 0.03 * (S.count - 4), dropOff = 1.5 * t;\n\n  // Each bank's top edge along the width: its height times a billow that\n  // slides with it.\n  for (let b = 0; b \u003c 3; b++) {\n    const B = BANKS[b], off = B.v * t, tp = tops[b], rise = 0.8 + B.rise * fog;\n    for (let x = 0; x \u003c W; x++) tp[x] = B.base - B.h * rise * (0.45 + 0.8 * vn((x + off) / B.sx, B.seed + 0.13 * t));\n  }\n\n  // Wisp light.\n  lit.fill(0);\n  for (const g of glow) g.fill(0);\n  for (let i = 0; i \u003c S.count; i++) {\n    const wx = S.wx[i], wy = S.wy[i], wb = S.wb[i], g = glow[S.wisps[i].slot], R = 13;\n    for (let y = max(0, floor(wy - R)); y \u003c= min(H - 1, floor(wy + R)); y++)\n      for (let x = max(0, floor(wx - R)); x \u003c= min(W - 1, floor(wx + R)); x++) {\n        const dx = x + 0.5 - wx, dy = y + 0.5 - wy, d2 = dx * dx + dy * dy;\n        if (d2 > R * R) continue;\n        const p = y * W + x;\n        lit[p] += wb * exp(-d2 / 70);\n        g[p] += wb * (sm(2.2, 0.8, sqrt(d2)) + 0.45 * exp(-d2 / 7));\n      }\n  }\n\n  const hazeOff = 1.6 * t;\n  for (let y = 0; y \u003c H; y++) {\n    const sr = sky[y * 3], sg = sky[y * 3 + 1], sb = sky[y * 3 + 2];\n    // High haze: thin at the top, thicker toward the horizon, in slow streaks.\n    const hz = (0.3 + 0.5 * sm(0, 90, y)) * (0.7 + 0.6 * fog);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r = sr, g = sg, b = sb;\n      // The moon and a faint halo round it.\n      const md = (x + 0.5 - MOON_X) ** 2 + (y + 0.5 - MOON_Y) ** 2;\n      if (md \u003c 400) {\n        const halo = 30 * exp(-md / 90);\n        r += halo;\n        g += halo;\n        b += halo * 0.9;\n      }\n      const mo = moon[p];\n      if (mo > 0) {\n        r += (250 - r) * mo;\n        g += (240 - g) * mo;\n        b += (205 - b) * mo;\n      }\n      // Mist in view along the line of sight, for the grain: the night air\n      // itself counts for AIR, then the haze and banks add to it.\n      let seen = 0;\n      const ha = min(0.85, hz * (0.15 + 1.3 * vn((x + hazeOff) / 21, y / 5 + 40)));\n      r += (hazeC[0] * 255 - r) * ha;\n      g += (hazeC[1] * 255 - g) * ha;\n      b += (hazeC[2] * 255 - b) * ha;\n      seen = AIR + (1 - AIR) * ha;\n      for (let layer = 0; layer \u003c 3; layer++) {\n        // Wisps at this depth, then this depth's silhouettes, then the bank in front of them.\n        const gl = glow[layer];\n        if (gl[p] > 0) {\n          const a = min(1, gl[p]);\n          r += (wispC[0] * 255 + 120 - r) * a;\n          g += (wispC[1] * 255 + 120 - g) * a;\n          b += (wispC[2] * 255 + 120 - b) * a;\n        }\n        const m = layer === 0 ? far[p] : layer === 1 ? fence[p] : front[p];\n        if (m > 0) {\n          const sc = layer === 0 ? 0.11 : layer === 1 ? 0.05 : 0.025;\n          r += (hazeC[0] * 255 * sc - r) * m;\n          g += (hazeC[1] * 255 * sc - g) * m;\n          b += (hazeC[2] * 255 * sc - b) * m;\n          seen *= 1 - m;\n        }\n        const B = BANKS[layer], top = tops[layer][x];\n        if (y > top - 6) {\n          const body = sm(top - 6, top + 8, y) * (0.3 + 1.0 * vn((x + B.v * 1.35 * t) / (B.sx * 0.6), y / B.sy + B.seed - 0.25 * t));\n          const a = min(0.95, body * B.op * thick);\n          if (a > 0) {\n            const L = lit[p] + amb, lv = B.lum * 255, keep = 1 - 0.25 * min(1, L);\n            const fr = fogC[0] * lv * keep + wispC[0] * 230 * L;\n            const fg = fogC[1] * lv * keep + wispC[1] * 230 * L;\n            const fb = fogC[2] * lv * keep + wispC[2] * 230 * L;\n            r += (fr - r) * a;\n            g += (fg - g) * a;\n            b += (fb - b) * a;\n            seen = seen + (1 - seen) * a;\n          }\n        }\n      }\n      if (glow[3][p] > 0) {\n        const a = min(1, glow[3][p]);\n        r += (wispC[0] * 255 + 120 - r) * a;\n        g += (wispC[1] * 255 + 120 - g) * a;\n        b += (wispC[2] * 255 + 120 - b) * a;\n      }\n      r = min(255, r);\n      g = min(255, g);\n      b = min(255, b);\n      // The grain: half a step up on one colour of the checker, half down on\n      // the other, scaled by the fog in view and kept inside 0..255.\n      const m = max(r, g, b, 1);\n      // Droplets: the half step swells and shrinks over a few LEDs, and that\n      // pattern drifts with the air, so the dither reads as moving mist\n      // rather than a ruled grid.\n      const drop = 0.7 + 0.3 * vn((x + dropOff) / 2.3, y / 2.3 + 90);\n      const amp = min(GRAIN * min(1, 2.4 * seen) * drop, 0.45 * m, 0.45 * (255 - m));\n      const f = (m + ((x + y) & 1 ? amp : -amp)) / m;\n      display.setPixel(x, y, round(r * f), round(g * f), round(b * f));\n    }\n  }\n}\n","haunted-manor":"// ===== Patternflow pattern =====\n// Title:   Haunted Manor\n// Family:  halloween\n// Idea:    A crooked house with two spired towers and a dead tree stands on a hill under a violet storm, rain slanting across, and every few seconds a branching bolt cracks down behind it, the sky flashes pale violet and the house goes stark black while its orange and green windows flicker, a figure passes behind one and a shutter bangs.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Storm=0..1, Lights=0..1\n//\n// Knob 1: Hue. The storm's tint, kept to the cool side of the wheel so the dim sky never reads brown: violet at 0, blue at 0.25, teal at 0.5, sea green at 0.75 and a sickly green at 1. The flash pales the same hue; the windows stay orange and green.\n// Knob 2: Speed. Rain falls at 115 LEDs a second at 2, so a drop crosses the panel in about a second; 30 at 0.2 and 160 at 3. Clouds, candle flicker, the figure and the shutter run on the same clock, and the gaps between strikes stretch by 2 over Speed, though never past 2.9 times; a flash always lasts the same half second.\n// Knob 3: Storm. At 0 a strike comes every 4.2 seconds on average (each gap 0.6 to 1.4 times that) and 90 drops a second fall; at 1 every 1.1 seconds and 330 drops. The first strike always comes 2.4 seconds after the start, down behind the house; later ones may hit the tall spire or the tree.\n// Knob 4: Lights. How many of the thirteen windows are lit: 2 at 0, 3 at the opening 0.06, 8 at 0.5 and all 13 at 1, each with a one-LED glow on the wall round it. Every 4 to 8 seconds one room goes dark and another lights. The wet ground under the house mirrors the lower windows and the door, broken into rippling rows.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// A fixed generator for the house and the tree, so they never change with\n// the knobs; Math.random is left for the weather.\nfunction prng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n// Smooth value noise on a 16 x 16 lattice that wraps.\nconst LAT = new Float32Array(256);\n{\n  const r = prng(7);\n  for (let i = 0; i \u003c 256; i++) LAT[i] = r();\n}\nfunction noise(x, y) {\n  const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n  const u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);\n  const a = LAT[(yi & 15) * 16 + (xi & 15)], b = LAT[(yi & 15) * 16 + ((xi + 1) & 15)];\n  const c = LAT[((yi + 1) & 15) * 16 + (xi & 15)], d = LAT[((yi + 1) & 15) * 16 + ((xi + 1) & 15)];\n  return mix(mix(a, b, u), mix(c, d, u), v);\n}\n\n// The hill's top edge.\nconst hillTop = (x) => 101 + 0.0075 * (x - 20) * (x - 20);\n\n// The house, part by part: a polygon and how far it leans, in LEDs per row\n// above row 108. Windows are rectangles (or a circle) in the part they sit in.\nconst PARTS = [\n  { lean: 0.03, pts: [[1, 50], [11, 50], [11, 108], [1, 108]] },\n  { lean: 0.03, pts: [[-1, 51], [13, 51], [8.5, 34], [10, 15], [5.5, 32]] },\n  { lean: -0.012, pts: [[10, 74], [36, 74], [36, 108], [10, 108]] },\n  { lean: -0.012, pts: [[7.5, 75], [38.5, 75], [24.5, 48], [22.5, 46.5], [20.5, 49]] },\n  { lean: 0.05, pts: [[29, 64], [32, 64], [32, 53], [29, 53]] },\n  { lean: 0.05, pts: [[28, 53], [33, 53], [33, 51], [28, 51]] },\n  { lean: -0.045, pts: [[34, 68], [43, 68], [43, 106], [34, 106]] },\n  { lean: -0.045, pts: [[32, 69], [45, 69], [38.5, 49]] },\n  { lean: -0.012, pts: [[17, 92], [29, 92], [23, 87]] },\n];\n// Windows: part, x0, y0, width, height (or round with a radius), colour\n// 0 orange, 1 green. The order is the order they light in as Lights rises.\nconst WINDOWS = [\n  { part: 2, x: 11, y: 77, w: 9, h: 10, c: 0 },\n  { part: 3, round: true, x: 22.5, y: 63, r: 3.2, c: 1 },\n  { part: 2, x: 26, y: 92, w: 9, h: 10, c: 0 },\n  { part: 0, x: 4, y: 56, w: 5, h: 9, c: 1, arch: true },\n  { part: 2, x: 26, y: 77, w: 9, h: 10, c: 0 },\n  { part: 6, x: 36, y: 74, w: 5, h: 8, c: 0, arch: true },\n  { part: 2, x: 20.5, y: 94, w: 5, h: 14, c: 0, arch: true, door: true },\n  { part: 0, x: 4, y: 72, w: 5, h: 9, c: 0 },\n  { part: 2, x: 11, y: 92, w: 9, h: 10, c: 1 },\n  { part: 1, x: 6, y: 38, w: 3, h: 5, c: 0, arch: true },\n  { part: 3, x: 13, y: 67, w: 3, h: 4, c: 0 },\n  { part: 3, x: 29, y: 67, w: 3, h: 4, c: 1 },\n  { part: 6, x: 36, y: 89, w: 5, h: 8, c: 0, arch: true },\n];\nconst NW = WINDOWS.length;\n// The tip of the tall spire, leant.\nconst SPIRE = [10 + 0.03 * (108 - 15), 15];\n\nfunction inPoly(pts, x, y) {\n  let c = false;\n  for (let i = 0, j = pts.length - 1; i \u003c pts.length; j = i++) {\n    const [xi, yi] = pts[i], [xj, yj] = pts[j];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) c = !c;\n  }\n  return c;\n}\n\n// The dead tree: branches as segments, each with its parent, grown once from\n// a fixed seed. Each frame they are laid out again with the wind's sway.\nfunction growTree() {\n  const r = prng(31), segs = [];\n  const grow = (parent, ang, len, depth, width) => {\n    const i = segs.length;\n    segs.push({ parent, ang, len, width, depth });\n    if (depth >= 5 || len \u003c 3) return;\n    const kids = depth \u003c 2 ? 2 : r() \u003c 0.35 ? 3 : 2;\n    for (let k = 0; k \u003c kids; k++) {\n      const spread = (k - (kids - 1) / 2) * (0.55 + 0.35 * r()) + (r() - 0.5) * 0.3;\n      grow(i, ang + spread, len * (0.62 + 0.18 * r()), depth + 1, max(1, width - 1));\n    }\n  };\n  grow(-1, -PI / 2 + 0.1, 22, 0, 3);\n  return segs;\n}\nconst TREE_X = 55;\n\n// Branch ends for a given sway, root first; each branch bends with the wind\n// in proportion to how far out it is.\nfunction layTree(tree, sway, ends) {\n  for (let i = 0; i \u003c tree.length; i++) {\n    const g = tree[i];\n    const x0 = g.parent \u003c 0 ? TREE_X : ends[g.parent][2], y0 = g.parent \u003c 0 ? hillTop(TREE_X) + 2 : ends[g.parent][3];\n    const a = g.ang + sway * g.depth;\n    ends[i] = [x0, y0, x0 + cos(a) * g.len, y0 + sin(a) * g.len];\n  }\n  return ends;\n}\n\nexport function setup(params) {\n  const house = new Uint8Array(N), win = new Int8Array(N).fill(-1), pane = new Uint8Array(N);\n  // Window pixels keep their place in the window, for mullions and figures.\n  const wx = new Float32Array(N), wy = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, X = x + 0.5, Y = y + 0.5;\n      if (Y >= hillTop(X)) house[p] = 2;\n      for (let k = 0; k \u003c PARTS.length; k++) {\n        const part = PARTS[k], sx = X - part.lean * (108 - Y);\n        if (inPoly(part.pts, sx, Y)) house[p] = 1;\n      }\n      for (let n = 0; n \u003c NW; n++) {\n        const w = WINDOWS[n], part = PARTS[w.part], sx = X - part.lean * (108 - Y);\n        let inside = false, u = 0, v = 0;\n        if (w.round) {\n          const dx = sx - w.x, dy = Y - w.y;\n          inside = dx * dx + dy * dy \u003c= w.r * w.r;\n          u = dx;\n          v = dy;\n          if (inside && (abs(dx) \u003c 0.5 || abs(dy) \u003c 0.5)) pane[p] = 1;\n        } else {\n          inside = sx >= w.x && sx \u003c w.x + w.w && Y >= w.y && Y \u003c w.y + w.h;\n          u = sx - w.x;\n          v = Y - w.y;\n          if (inside && w.arch && v \u003c 1 && (u \u003c 1 || u >= w.w - 1)) inside = false;\n          if (inside && !w.door && w.w > 3 && (floor(u) === floor(w.w / 2) || floor(v) === floor(w.h * 0.4))) pane[p] = 1;\n        }\n        if (inside) {\n          win[p] = n;\n          wx[p] = u;\n          wy[p] = v;\n        }\n      }\n    }\n  const tree = growTree(), still = layTree(tree, 0, []);\n  let treeTop = [TREE_X, 99];\n  for (const e of still) if (e[3] \u003c treeTop[1]) treeTop = [e[2], e[3]];\n  // A one-LED glow round each window on the wall: which window, and how\n  // strong (full beside an edge, less at a corner).\n  const halo = new Int8Array(N).fill(-1), haloW = new Float32Array(N);\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (house[p] !== 1 || win[p] >= 0) continue;\n      for (const [dx, dy, wt] of [[1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1], [1, 1, 0.5], [-1, 1, 0.5], [1, -1, 0.5], [-1, -1, 0.5]]) {\n        const n = win[p + dy * W + dx];\n        if (n >= 0 && wt > haloW[p]) (halo[p] = n), (haloW[p] = wt);\n      }\n    }\n  params.s = {\n    hue: 0, speed: 2, storm: 0, lights: 0.06,\n    t: 0, clock: 0, house, win, pane, wx, wy, halo, haloW,\n    tree, treeMask: new Uint8Array(N), ends: [], treeTop,\n    drops: [], dropCarry: 0,\n    // Windows: how lit each is (0..1), the flicker phase, and the order.\n    lit: new Float32Array(NW), fl: new Float32Array(NW),\nwant: new Uint8Array(NW), order: WINDOWS.map((_, i) => i),\n    swapAt: 6, gust: 0,\n    // Lightning: when the strike began, its strokes, the bolt as a field.\n    strikeAt: -99, nextStrike: 2.4, strikes: 0, strokes: [], bolt: new Float32Array(N), boltX: 32,\n    figure: null, figureAt: 4, shutter: null, shutterAt: 3,\n    rgb: new Float32Array(3), sky: new Float32Array(3), buf: new Float32Array(N * 3),\n  };\n}\n\n// The bolt: a jagged main channel by midpoint displacement from the top of\n// the panel to its target, and a few branches peeling off it.\nfunction makeBolt(S) {\n  const b = S.bolt;\n  b.fill(0);\n  // The first strike comes down behind the house; later ones may hit the\n  // tall spire or the top of the tree instead.\n  const first = S.strikes++ === 0, pick = first ? 1 : Math.random();\n  const x0 = first ? 30 + Math.random() * 16 : 6 + Math.random() * 52;\n  let tx, ty;\n  if (pick \u003c 0.2) (tx = SPIRE[0]), (ty = SPIRE[1]);\n  else if (pick \u003c 0.35) (tx = S.treeTop[0]), (ty = S.treeTop[1]);\n  else (tx = first ? 22 + Math.random() * 14 : 4 + Math.random() * 56), (ty = 100);\n  S.boltX = (x0 + tx) / 2;\n  const path = (ax, ay, bx, by, rough, depth, out) => {\n    if (depth === 0) {\n      out.push([bx, by]);\n      return;\n    }\n    const L = sqrt((bx - ax) ** 2 + (by - ay) ** 2);\n    const mx = (ax + bx) / 2 + (Math.random() - 0.5) * L * rough, my = (ay + by) / 2 + (Math.random() - 0.5) * L * rough * 0.3;\n    path(ax, ay, mx, my, rough, depth - 1, out);\n    path(mx, my, bx, by, rough, depth - 1, out);\n  };\n  const line = (pts, level) => {\n    for (let i = 1; i \u003c pts.length; i++) {\n      const [ax, ay] = pts[i - 1], [bx, by] = pts[i], n = max(1, Math.ceil(max(abs(bx - ax), abs(by - ay)) * 2));\n      for (let s = 0; s \u003c= n; s++) {\n        const x = floor(ax + ((bx - ax) * s) / n), y = floor(ay + ((by - ay) * s) / n);\n        if (x >= 0 && x \u003c W && y >= 0 && y \u003c H && b[y * W + x] \u003c level) b[y * W + x] = level;\n      }\n    }\n  };\n  const main = [[x0, -2]];\n  path(x0, -2, tx, ty, 0.55, 6, main);\n  line(main, 1);\n  const branches = 2 + floor(Math.random() * 3);\n  for (let k = 0; k \u003c branches; k++) {\n    const at = main[3 + floor(Math.random() * (main.length * 0.6))];\n    const side = Math.random() \u003c 0.5 ? -1 : 1, len = 12 + Math.random() * 22;\n    const br = [[at[0], at[1]]];\n    path(at[0], at[1], at[0] + side * len * 0.8, at[1] + len * 0.7, 0.6, 4, br);\n    line(br, 0.55);\n  }\n  // A glow one LED round the channel.\n  const glow = Float32Array.from(b);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (b[p] > 0) continue;\n      let g = 0;\n      if (x > 0) g = max(g, glow[p - 1]);\n      if (x \u003c W - 1) g = max(g, glow[p + 1]);\n      if (y > 0) g = max(g, glow[p - W]);\n      if (y \u003c H - 1) g = max(g, glow[p + W]);\n      b[p] = 0.45 * g;\n    }\n  // Two to four return strokes down the same channel.\n  S.strokes = [0];\n  const extra = 1 + floor(Math.random() * 3);\n  for (let k = 0; k \u003c extra; k++) S.strokes.push(S.strokes[k] + 0.07 + Math.random() * 0.09);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.storm = cl(k[2], 0, 1);\n  S.lights = cl(k[3], 0, 1);\n  const sp = S.speed / 2, ds = d * sp;\n  S.t += d;\n  S.clock += ds;\n  S.gust = 0.5 + 0.5 * sin(S.clock * 0.7 + 1.5 * sin(S.clock * 0.23));\n\n  // Lightning on the knob's clock, except the first, at 2.4 s.\n  if (S.t >= S.nextStrike) {\n    S.strikeAt = S.t;\n    makeBolt(S);\n    const mean = mix(4.2, 1.1, S.storm);\n    S.nextStrike = S.t + (mean * (0.6 + 0.8 * Math.random())) / max(0.35, sp);\n  }\n\n  // Rain: drops spawned at the top at a rate set by Storm.\n  const rate = mix(90, 330, S.storm) * sp;\n  S.dropCarry += rate * d;\n  const vy0 = 95 * sp + 20;\n  while (S.dropCarry >= 1) {\n    S.dropCarry -= 1;\n    S.drops.push({ x: -20 + Math.random() * (W + 30), y: -8 - Math.random() * 20, v: vy0 * (0.8 + 0.4 * Math.random()), l: 3 + floor(Math.random() * 4), a: 0.5 + 0.5 * Math.random() });\n  }\n  const slant = 0.18 + 0.22 * S.gust;\n  for (const r of S.drops) {\n    r.y += r.v * d;\n    r.x += r.v * slant * d;\n  }\n  S.drops = S.drops.filter((r) => r.y \u003c H + 8 && r.y \u003c hillTop(r.x) + 6);\n  S.slant = slant;\n\n  // Windows: the first n of the order want light; now and then one room goes\n  // dark and another lights.\n  const n = round(2 + 11 * S.lights);\n  if (S.clock >= S.swapAt && n \u003c NW) {\n    S.swapAt = S.clock + 4 + 4 * Math.random();\n    const a = floor(Math.random() * n), b = n + floor(Math.random() * (NW - n));\n    [S.order[a], S.order[b]] = [S.order[b], S.order[a]];\n  }\n  S.want.fill(0);\n  for (let i = 0; i \u003c n; i++) S.want[S.order[i]] = 1;\n  for (let i = 0; i \u003c NW; i++) S.lit[i] = cl(S.lit[i] + (S.want[i] ? 1 : -1) * d * 3, 0, 1);\n  if (S.t \u003c d * 1.5) for (let i = 0; i \u003c NW; i++) S.lit[i] = S.want[i];\n\n  // A figure crossing a lit window, left to right or right to left.\n  if (!S.figure && S.clock >= S.figureAt) {\n    const cands = [0, 2, 4, 8].filter((i) => S.lit[i] > 0.9);\n    if (cands.length) S.figure = { w: cands[floor(Math.random() * cands.length)], u: 0, dir: Math.random() \u003c 0.5 ? 1 : -1 };\n    S.figureAt = S.clock + 5 + 5 * Math.random();\n  }\n  if (S.figure) {\n    S.figure.u += ds / 1.8;\n    if (S.figure.u >= 1) S.figure = null;\n  }\n  // A shutter banging shut and swinging open on a gust.\n  if (!S.shutter && S.clock >= S.shutterAt) {\n    const cands = [];\n    for (let i = 0; i \u003c NW; i++) if (S.lit[i] > 0.9 && !WINDOWS[i].round) cands.push(i);\n    if (cands.length) S.shutter = { w: cands[floor(Math.random() * cands.length)], u: 0 };\n    S.shutterAt = S.clock + 4 + 5 * Math.random();\n  }\n  if (S.shutter) {\n    S.shutter.u += ds;\n    if (S.shutter.u >= 1.2) S.shutter = null;\n  }\n}\n\n// How bright the strike is t seconds after it began: a spike for each\n// return stroke and a slow afterglow.\nfunction flashAt(S, t) {\n  if (t \u003c 0 || t > 3) return [0, 0, 0];\n  let spike = 0, chan = 0;\n  for (const s of S.strokes)\n    if (t >= s) {\n      spike = max(spike, exp(-(t - s) / 0.05));\n      chan = max(chan, exp(-(t - s) / 0.12));\n    }\n  return [spike, exp(-t / 0.55), chan];\n}\n\n// How much of the window a shutter covers, from its hinge: shut in 0.06 s,\n// open again, a smaller swing back, and still by 1.2.\nfunction shutterCover(u) {\n  if (u \u003c 0.06) return u / 0.06;\n  if (u \u003c 0.3) return 1 - sm(0.06, 0.3, u);\n  if (u \u003c 0.5) return 0.6 * sm(0.3, 0.42, u) * (1 - sm(0.42, 0.5, u));\n  if (u \u003c 0.75) return 0.25 * sm(0.5, 0.6, u) * (1 - sm(0.6, 0.75, u));\n  return 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { house, win, pane, wx, wy, bolt, lit, halo, haloW } = S;\n  const ts = S.t - S.strikeAt, [spike, glow, chan] = flashAt(S, ts);\n  // The channel stays a moment after the strokes as a fading violet trace.\n  const flash = min(1, 0.62 * spike + 0.3 * glow), boltOn = max(chan, 0.3 * glow * glow);\n  const skyH = 0.76 - 0.44 * S.hue, col = S.rgb, lite = S.sky;\n  // What the sky turns to at full flash: the storm's own hue, pale.\n  hsv(skyH, 0.32, 1, lite);\n  // The tree, laid out with the wind.\n  const tm = S.treeMask;\n  tm.fill(0);\n  const sway = (S.gust - 0.5) * 0.08 + 0.02 * sin(S.clock * 5.3);\n  const ends = layTree(S.tree, sway, S.ends);\n  for (let i = 0; i \u003c S.tree.length; i++) {\n    const g = S.tree[i], [x0, y0, x1, y1] = ends[i];\n    const steps = Math.ceil(g.len * 2), hw = g.width / 2;\n    for (let s = 0; s \u003c= steps; s++) {\n      const x = x0 + ((x1 - x0) * s) / steps, y = y0 + ((y1 - y0) * s) / steps;\n      for (let yy = floor(y - hw + 0.5); yy \u003c= floor(y + hw - 0.5); yy++)\n        for (let xx = floor(x - hw + 0.5); xx \u003c= floor(x + hw - 0.5); xx++) if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tm[yy * W + xx] = 1;\n    }\n  }\n  // The figure's place, in the window's own columns.\n  const fig = S.figure, fw = fig ? WINDOWS[fig.w] : null;\n  const fx = fig ? (fig.dir > 0 ? mix(-3, fw.w + 3, fig.u) : mix(fw.w + 3, -3, fig.u)) : 0;\n  const sh = S.shutter, shCover = sh ? shutterCover(sh.u) : 0;\n  const rgb = S.buf, fl = S.fl;\n  for (let n = 0; n \u003c NW; n++) fl[n] = lit[n] * (0.78 + 0.22 * noise(S.clock * 7 + n * 3.7, n * 5.1));\n  for (let y = 0; y \u003c H; y++) {\n    const yt = y / 100;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, q = p * 3;\n      let r, g, b;\n      const hm = house[p] || tm[p];\n      if (!hm) {\n        // Sky: a violet gradient, brighter toward the hill, with storm\n        // clouds drifting across, lit up by the flash nearest the bolt.\n        const c1 = noise(x / 20 + S.clock * 0.25, y / 13 + 2), c2 = noise(x / 11 + S.clock * 0.45 + 5, y / 8);\n        const cloud = cl((0.75 * c1 + 0.25 * c2 - 0.35) * 1.8, 0, 1) * (1 - sm(0.3, 0.85, yt));\n        hsv(skyH + 0.03 * yt, 0.72 - 0.15 * yt - 0.25 * cloud, 0.2 + 0.2 * yt + 0.16 * cloud, col);\n        const near = 0.55 + 0.45 * exp(-((x - S.boltX) ** 2) / 600);\n        const f = flash * near * (0.85 + 0.25 * cloud);\n        r = mix(col[0], lite[0], f);\n        g = mix(col[1], lite[1], f);\n        b = mix(col[2], lite[2], f);\n        const bl = bolt[p] * boltOn;\n        if (bl > 0) {\n          const wt = min(1, chan * 2);\n          r = mix(r, mix(lite[0], 1, wt), bl);\n          g = mix(g, mix(lite[1], 1, wt), bl);\n          b = mix(b, mix(lite[2], 1, wt), bl);\n        }\n      } else {\n        // Hill, house and tree: dark, and black while the sky is lit.\n        const k = 1 - min(1, flash * 2.2);\n        r = 0.07 * k;\n        g = 0.04 * k;\n        b = 0.1 * k;\n        const n = house[p] === 1 ? win[p] : -1;\n        if (house[p] === 2 && !tm[p] && y > 108) {\n          // The wet ground under the house mirrors what is lit above row\n          // 108, each row shifted a little and some rows dropped, more of\n          // them further down. Rows above are already drawn, so it copies.\n          const dy = y - 108, sy = 216 - y, sx = x + round(0.9 * sin(dy * 3.1 + S.clock * 4));\n          if (sx >= 0 && sx \u003c W && sin(dy * 2.3 - S.clock * 5) > -0.6 + dy / 16) {\n            const sp = sy * W + sx;\n            if (house[sp] === 1 && win[sp] >= 0) {\n              r = 0.8 * rgb[sp * 3];\n              g = 0.8 * rgb[sp * 3 + 1];\n              b = 0.8 * rgb[sp * 3 + 2];\n            }\n          }\n        }\n        const hn = house[p] === 1 ? halo[p] : -1;\n        if (hn >= 0 && fl[hn] > 0) {\n          const a = 0.42 * haloW[p] * fl[hn] * k, c = WINDOWS[hn].c;\n          r += ((c ? 0.45 : 1) - r) * a;\n          g += ((c ? 1 : 0.5) - g) * a;\n          b += ((c ? 0.18 : 0.1) - b) * a;\n        }\n        if (n >= 0 && lit[n] > 0) {\n          const w = WINDOWS[n];\n          let on = fl[n];\n          if (pane[p]) on *= 0.15;\n          if (fig && fig.w === n) {\n            const u = wx[p], v = wy[p], du = u - fx;\n            if (du * du + (v - 2.2) ** 2 \u003c 2.6 || (v > 3.6 && abs(du) \u003c 1.2 + 0.6 * (v - 3.6))) on *= 0.06;\n          }\n          if (sh && sh.w === n && wx[p] >= w.w * (1 - shCover)) on *= 0.04;\n          if (w.c === 0) (r = 1 * on), (g = 0.5 * on), (b = 0.1 * on);\n          else (r = 0.45 * on), (g = 1 * on), (b = 0.18 * on);\n        }\n      }\n      rgb[q] = r;\n      rgb[q + 1] = g;\n      rgb[q + 2] = b;\n    }\n  }\n  // Rain over everything, pale, turning white while the sky is lit.\n  const sl = S.slant, rl = mix(0.28, 0.85, flash);\n  for (const d of S.drops) {\n    for (let s = 0; s \u003c d.l; s++) {\n      const x = floor(d.x - sl * s), y = floor(d.y - s);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = (y * W + x) * 3, a = d.a * rl * (1 - s / (d.l + 1));\n      rgb[q] += (0.75 - rgb[q]) * a;\n      rgb[q + 1] += (0.72 - rgb[q + 1]) * a;\n      rgb[q + 2] += (0.95 - rgb[q + 2]) * a;\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","knights-tour":"// ===== Patternflow pattern =====\n// Title:   Knight's Tour\n// Family:  algo\n// Idea:    A knight tours an 8 by 16 chessboard of 8-LED squares filling the panel by Warnsdorff's rule, always jumping to the unvisited square with the fewest onward moves, each jump leaving a 1-LED line from centre to centre over the dotted lines of the tour before, until the 127 lines of a whole tour show whether it closed and fade, and the next tour starts from another square.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: knight's tour by Warnsdorff's rule (H. C. von Warnsdorff, 1823), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.25..12, Board=0..1, Stray=0..1\n//\n// Knob 1: Hue. Turns the tour's colours round the wheel. At 0 the first jumps are cyan and the last violet, the newest jumps near white, and a closed tour's jump home gold; at 0.5 the tour runs from red through orange and yellow to green and the jump home is blue.\n// Knob 2: Speed. Jumps a second. At 2 a jump takes half a second, the knight gliding the 18 LEDs from centre to centre in 0.36 s and resting on its square for the rest, so a tour of 127 jumps takes about a minute; at 0.25 a jump takes 4 s, at 12 a whole tour takes 11 s.\n// Knob 3: Board. Columns of squares: 8 at 0, 7 at 0.25, 6 at 0.5, 5 at 0.75 and 4 at 1, always with twice as many rows, so the board fills the panel with squares from 8 to 16 LEDs. A new board starts with a tour run up to four fifths at 40 jumps a second. No board 4 squares wide has a closed tour (Schwenk, 1991), so at 1 every tour ends open.\n// Knob 4: Stray. The chance that the knight ignores the rule and takes any legal jump. Up to 0.1 it never strays, and a tour that would dead-end on an unlucky tie (2.2% of them on 8 by 16, 81% on 4 by 8) is drawn again with other ties, so every tour completes. Past 0.1 the chance climbs to 1 at 1: at 0.2 four tours in ten complete, at 0.3 one in ten, and at 1 the knight wanders at random and is stuck after about 60 of the 128 squares. A stuck square flashes red three times and a red cross marks each square left unvisited.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst MOVES = [[1, 2], [2, 1], [2, -1], [1, -2], [-1, -2], [-2, -1], [-2, 1], [-1, 2]];\n// Stray at or under DEAD never strays; a tour that dead-ends is re-rolled up to TRIES times.\nconst DEAD = 0.1, TRIES = 400;\n// The opening shows a tour this far in, so the first frames already hold a web.\nconst HEAD = 0.8;\n// Share of each jump spent gliding; the rest the knight rests on its square.\nconst GLIDE = 0.72;\n// Seconds for the end: the sweep along the tour, the hold, the fade.\nconst SWEEP = 3, HOLD = 1.6, FADE = 2, STUCK = 2.2;\n// Hue at knob 0, and how far round the wheel the tour's colours run.\nconst HUE0 = 0.52, SPAN = 0.3;\n// Line colour: saturation and value a line settles to, the ghost's value,\n// and the tint of a visited light and dark square.\nconst SAT = 0.75, VAL = 1, GHOST = 0.85, TINT = [0.09, 0];\n// A square just reached glows WAKE brighter, fading over the next WAKEN jumps.\nconst WAKE = 0.34, WAKEN = 6;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, ghost: null, hue: 0, speed: 2, stray: 0.06, planStray: 0.06, boardWait: 0,\n    C: 0, R: 0, N: 0, path: null, vis: null, cx: null, cy: null, xs: null, ys: null,\n    len: 0, at: 0, phase: 0, ff: 0, lastStart: -1,\n    mode: \"run\", mt: 0, closed: false,\n    rgb: new Float32Array(W * H * 3), c3: new Float32Array(3), gold: new Float32Array(3),\n  };\n}\n\nconst colsOf = (k) => 8 - round(cl(k, 0, 1) * 4);\nconst strayP = (k) => (k \u003c= DEAD ? 0 : (k - DEAD) / (1 - DEAD));\n\nfunction newBoard(P, C) {\n  const R = 2 * C, N = C * R, sx = W / C;\n  Object.assign(P, { C, R, N, path: new Int16Array(N), vis: new Uint8Array(N), cx: new Int16Array(N), cy: new Int16Array(N) });\n  // Square (c, r) covers LEDs xs[c]..xs[c+1]-1 and ys[r]..ys[r+1]-1; its\n  // centre LED is the one just up and left of the middle when the side is even.\n  P.xs = Array.from({ length: C + 1 }, (_, c) => round(c * sx));\n  P.ys = Array.from({ length: R + 1 }, (_, r) => round(r * sx));\n  for (let q = 0; q \u003c N; q++) {\n    const c = q % C, r = floor(q / C);\n    P.cx[q] = floor((P.xs[c] + P.xs[c + 1] - 1) / 2);\n    P.cy[q] = floor((P.ys[r] + P.ys[r + 1] - 1) / 2);\n  }\n  P.lastStart = -1;\n}\n\n// Unvisited squares one knight's move from q.\nfunction onward(P, q, list) {\n  const { C, R, vis } = P, x = q % C, y = floor(q / C);\n  let n = 0;\n  for (const [dx, dy] of MOVES) {\n    const a = x + dx, b = y + dy;\n    if (a \u003c 0 || a >= C || b \u003c 0 || b >= R) continue;\n    const t = b * C + a;\n    if (vis[t]) continue;\n    if (list) list[n] = t;\n    n++;\n  }\n  return n;\n}\n\n// Plan the rest of the tour after path[0..from]. Warnsdorff's rule: the next\n// square is the unvisited neighbour with the fewest unvisited neighbours of\n// its own, ties broken at random; with probability p any unvisited neighbour.\nfunction plan(P, from) {\n  const { N, path, vis } = P, p = strayP(P.stray), tries = p === 0 ? TRIES : 1;\n  const cand = new Int16Array(8), best = new Int16Array(8);\n  P.planStray = P.stray;\n  for (let t = 0; t \u003c tries; t++) {\n    vis.fill(0);\n    for (let i = 0; i \u003c= from; i++) vis[path[i]] = 1;\n    let n = from + 1, q = path[from];\n    while (n \u003c N) {\n      const k = onward(P, q, cand);\n      if (!k) break;\n      let next;\n      if (p > 0 && Math.random() \u003c p) next = cand[floor(Math.random() * k)];\n      else {\n        let lo = 99, m = 0;\n        for (let j = 0; j \u003c k; j++) {\n          const d = onward(P, cand[j], null);\n          if (d \u003c lo) (lo = d), (m = 0);\n          if (d === lo) best[m++] = cand[j];\n        }\n        next = best[floor(Math.random() * m)];\n      }\n      path[n++] = next;\n      vis[next] = 1;\n      q = next;\n    }\n    P.len = n;\n    if (n === N) break;\n  }\n}\n\nconst isMove = (P, a, b) => {\n  const dx = abs((a % P.C) - (b % P.C)), dy = abs(floor(a / P.C) - floor(b / P.C));\n  return (dx === 1 && dy === 2) || (dx === 2 && dy === 1);\n};\n\n// A new tour from a square other than the last one's start, shown `head` of\n// the way in at once (the opening), or run up to there at 40 jumps a second\n// (`ff`, after the board changes), or from its first square.\nfunction startTour(P, head, ff, fresh) {\n  if (fresh) {\n    // A new board has no tour before it, so one is run for the ghost.\n    P.path[0] = floor(Math.random() * P.N);\n    plan(P, 0);\n    P.lastStart = P.path[0];\n  }\n  P.ghost = P.path.slice(0, P.len);\n  let s = floor(Math.random() * P.N);\n  if (s === P.lastStart) s = (s + 1 + floor(Math.random() * (P.N - 1))) % P.N;\n  P.lastStart = s;\n  P.path[0] = s;\n  plan(P, 0);\n  const target = min(round(head * P.N), max(0, P.len - 7));\n  P.at = ff ? 0 : target;\n  P.ff = ff ? target : 0;\n  P.phase = 0;\n  P.mode = \"run\";\n  P.mt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.25, 12);\n  P.stray = cl(k[3], 0, 1);\n  const cols = colsOf(k[2]);\n  if (!P.begun) {\n    P.begun = true;\n    newBoard(P, cols);\n    startTour(P, HEAD, false, true);\n    return;\n  }\n  // The board changes once the knob has rested 0.4 s on a new size.\n  if (cols !== P.C) {\n    P.boardWait += d;\n    if (P.boardWait >= 0.4) {\n      newBoard(P, cols);\n      startTour(P, HEAD, true, true);\n      P.boardWait = 0;\n    }\n  } else P.boardWait = 0;\n  // Stray moved: plan again from the square the knight is jumping to.\n  if (P.mode === \"run\" && abs(P.stray - P.planStray) > 0.02 && P.at + 1 \u003c P.len) plan(P, P.at + 1);\n\n  P.mt += d;\n  if (P.mode === \"run\") {\n    const rate = P.at \u003c P.ff ? 40 : P.speed;\n    P.phase += d * rate;\n    while (P.phase >= 1 && P.mode === \"run\") {\n      P.phase -= 1;\n      P.at++;\n      if (P.at >= P.len - 1) {\n        P.phase = 0;\n        P.mt = 0;\n        if (P.len === P.N) (P.mode = \"end\"), (P.closed = isMove(P, P.path[P.N - 1], P.path[0]));\n        else P.mode = \"stuck\";\n      }\n    }\n  } else if (P.mode === \"end\") {\n    // A closed tour first jumps home along the closing line, one jump long.\n    const home = P.closed ? 1 / P.speed : 0;\n    if (P.mt > home + SWEEP + HOLD) (P.mode = \"fade\"), (P.mt = 0);\n  } else if (P.mode === \"stuck\") {\n    if (P.mt > STUCK) (P.mode = \"fade\"), (P.mt = 0);\n  } else if (P.mode === \"fade\") {\n    if (P.mt >= FADE) startTour(P, 0, false, false);\n  }\n}\n\n// Paint the line between the centres of squares a and b up to share f of\n// the way from a. The LEDs are worked out from the lower-numbered end, so a\n// jump and its reverse light the same LEDs.\nfunction seg(P, a, b, f, r, g, bl, odd = 1) {\n  const { rgb } = P;\n  const flip = a > b, p = flip ? b : a, q = flip ? a : b;\n  const x0 = P.cx[p], y0 = P.cy[p], dx = P.cx[q] - x0, dy = P.cy[q] - y0, n = max(abs(dx), abs(dy));\n  const lim = f * n + 1e-6;\n  for (let i = 0; i \u003c= n; i++) {\n    if ((flip ? n - i : i) > lim) continue;\n    const x = x0 + round((dx * i) / n), y = y0 + round((dy * i) / n);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3, m = i & 1 ? odd : 1;\n    if (m \u003c= 0) continue;\n    (rgb[o] = r * m), (rgb[o + 1] = g * m), (rgb[o + 2] = bl * m);\n  }\n}\n\nfunction box(P, q, r, g, b, inset) {\n  const { rgb } = P, c = q % P.C, w = floor(q / P.C);\n  const x0 = P.xs[c] + inset, x1 = P.xs[c + 1] - 1 - inset, y0 = P.ys[w] + inset, y1 = P.ys[w + 1] - 1 - inset;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      if (x !== x0 && x !== x1 && y !== y0 && y !== y1) continue;\n      const o = (y * W + x) * 3;\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n}\n\nfunction fill(P, q, r, g, b) {\n  const { rgb } = P, c = q % P.C, w = floor(q / P.C);\n  for (let y = P.ys[w]; y \u003c P.ys[w + 1]; y++)\n    for (let x = P.xs[c]; x \u003c P.xs[c + 1]; x++) {\n      const o = (y * W + x) * 3;\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.begun) return;\n  const { rgb, c3, path, N, C, ghost } = P;\n  rgb.fill(0);\n  const base = HUE0 + P.hue, gold = P.gold;\n  const hueOf = (i) => base + (SPAN * i) / (N - 1);\n  // The knight's place: e is how far along jump `at` it has glided.\n  const run = P.mode === \"run\";\n  const e = run ? sm(P.phase / GLIDE) : 0;\n  const done = P.at + e; // jumps made, counting the glide\n  const last = run ? P.at : P.len - 1; // squares path[0..last] are visited\n  // u runs 0 to 1 over the fade, while this tour turns into the next one's ghost.\n  const u = P.mode === \"fade\" ? sm(P.mt / FADE) : 0, keep = 1 - u;\n\n  // Visited squares: a faint tint in the colour of the jump that reached\n  // them, lighter on the light squares of the chessboard.\n  for (let i = 0; i \u003c= min(last + (run ? 1 : 0), P.len - 1); i++) {\n    const q = path[i], w = cl((done - i + 0.5) * 2, 0, 1) * keep;\n    if (w \u003c= 0) continue;\n    const light = ((q % C) + floor(q / C)) % 2 === 0;\n    hsv(hueOf(i), 0.75, ((light ? TINT[0] : TINT[1]) + WAKE * exp(-max(0, done - i) / WAKEN)) * w, c3, 0);\n    fill(P, q, c3[0], c3[1], c3[2]);\n  }\n  // The tour before this one, dotted: every other LED of each of its lines.\n  if (ghost && keep > 0)\n    for (let i = 0; i + 1 \u003c ghost.length; i++) {\n      hsv(hueOf(i), 0.85, GHOST * keep, c3, 0);\n      seg(P, ghost[i], ghost[i + 1], 1, c3[0], c3[1], c3[2], 0);\n    }\n\n  // The lines, oldest first so the newest lie on top. A line fresh from the\n  // knight is near white; over the next jumps it settles into its colour.\n  // In the fade they dim to the ghost's level and lose every other LED.\n  // The end's sweep: a gold light runs the tour in order, from the first\n  // jump to the last. On a closed tour it carries on over the jump home and\n  // keeps going round, since the tour is a loop.\n  const end = P.mode === \"end\", home = P.closed ? 1 / P.speed : 0;\n  const sweepAt = end ? ((P.mt - home) / SWEEP) * (N - 1 + (P.closed ? 1 : 0)) : -1e9;\n  hsv(base + 0.62, 0.62, 1, gold, 0);\n  const sweep = (c, lag) => {\n    if (sweepAt \u003c 0) return;\n    if (P.closed) lag = ((lag % N) + N) % N;\n    if (lag \u003c 0 || lag >= 14) return;\n    const w = exp(-lag / 3.5);\n    for (let j = 0; j \u003c 3; j++) c[j] += (gold[j] - c[j]) * w;\n  };\n  for (let i = 0; i \u003c last + (run ? 1 : 0) && i \u003c P.len - 1; i++) {\n    const age = max(0, done - i - 1), f = i \u003c P.at ? 1 : e;\n    if (f \u003c= 0) continue;\n    const s = SAT - (SAT - 0.1) * exp(-age / 2.5), v = VAL + (1 - VAL) * exp(-age / 3);\n    hsv(hueOf(i), s, v * keep + GHOST * u, c3, 0);\n    sweep(c3, sweepAt - i);\n    seg(P, path[i], path[i + 1], f, c3[0], c3[1], c3[2], keep);\n  }\n  let mx = -1, my = -1;\n  if (end || (P.mode === \"fade\" && P.len === N)) {\n    const a = path[N - 1], b = path[0];\n    if (P.closed) {\n      // The jump home, gold, drawn at the knight's pace.\n      const f = end ? sm((P.mt * P.speed) / GLIDE) : 1;\n      hsv(base + 0.62, 0.7, keep, c3, 0);\n      sweep(c3, sweepAt - (N - 1));\n      seg(P, a, b, f, c3[0], c3[1], c3[2]);\n      if (f \u003c 1) (mx = P.cx[a] + (P.cx[b] - P.cx[a]) * f), (my = P.cy[a] + (P.cy[b] - P.cy[a]) * f);\n    } else {\n      // An open tour: once the sweep reaches the end, its two ends are boxed.\n      const w = (end ? cl(sweepAt - (N - 1) + 1, 0, 1) : 1) * keep;\n      hsv(base + 0.62, 0.7, w, c3, 0);\n      box(P, a, c3[0], c3[1], c3[2], 1);\n      box(P, b, c3[0], c3[1], c3[2], 1);\n    }\n  }\n  if (P.mode === \"stuck\" || (P.mode === \"fade\" && P.len \u003c N)) {\n    // Stuck: a small red cross on each square the walk can no longer reach.\n    const seen = new Uint8Array(N);\n    for (let i = 0; i \u003c P.len; i++) seen[path[i]] = 1;\n    for (let q = 0; q \u003c N; q++) {\n      if (seen[q]) continue;\n      const x = P.cx[q], y = P.cy[q], w = 0.7 * keep;\n      for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) {\n        const o = ((y + dy) * W + x + dx) * 3;\n        (rgb[o] = w), (rgb[o + 1] = 0.1 * w), (rgb[o + 2] = 0.15 * w);\n      }\n    }\n  }\n  if (P.mode === \"stuck\") {\n    // The square the knight is stuck on flashes three times.\n    const w = sin((PI * 3 * P.mt) / STUCK) ** 2;\n    fill(P, path[P.len - 1], 0.95 * w, 0.12 * w, 0.1 * w);\n  }\n  if (run) {\n    const a = path[P.at], b = path[min(P.at + 1, P.len - 1)];\n    (mx = P.cx[a] + (P.cx[b] - P.cx[a]) * e), (my = P.cy[a] + (P.cy[b] - P.cy[a]) * e);\n  }\n  if (mx >= 0) {\n    // The knight: a white point in a soft round glow that swells as it\n    // lands and settles while it rests.\n    const land = run && P.at > 0 ? exp(-((P.phase - GLIDE + 1) % 1) / 0.3) : 0, gr = 7 + 7 * land, ga = 0.75 + 0.25 * land;\n    for (let py = floor(my) - 5; py \u003c= floor(my) + 6; py++)\n      for (let px = floor(mx) - 5; px \u003c= floor(mx) + 6; px++) {\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const r2 = (px - mx) ** 2 + (py - my) ** 2, l = r2 \u003c 0.3 ? 1 : ga * exp(-r2 / gr);\n        if (l \u003c 0.04) continue;\n        const o = (py * W + px) * 3;\n        (rgb[o] = max(rgb[o], l)), (rgb[o + 1] = max(rgb[o + 1], l * 0.95)), (rgb[o + 2] = max(rgb[o + 2], l * 0.85));\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, rgb[o] * 255), min(255, rgb[o + 1] * 255), min(255, rgb[o + 2] * 255));\n}\n","morley-triangle":"// ===== Patternflow pattern =====\n// Title:   Morley Triangle\n// Family:  geometry\n// Idea:    A triangle bigger than the panel is wide keeps changing shape, and the three points where the angle trisectors next to each side meet always form an equilateral triangle, filled bright gold among the six flat triangles the trisectors cut, turning, growing and shrinking while the big one writhes.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Morley's trisector theorem (Frank Morley, 1899), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wander=0..1, Exterior=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the equilateral triangle is gold and the three triangles on the sides of the big one are teal, blue and magenta; the rest of the big triangle stays dim slate at every hue, and a side triangle that lands between orange and yellow is paled and lifted so it does not read brown.\n// Knob 2: Speed. How fast the shape changes. At 2 the angles swing from about 60, 60, 60 out to their widest and back in about 10 seconds; at 0.2 it takes 95 seconds, at 3 about 6.\n// Knob 3: Wander. How far the angles roam. At 0 they stay between 31 and 103 degrees and the equilateral triangle's side between 14 and 21 LEDs; at 1 they reach 12 and 132 degrees, a sliver lying along the panel's diagonal whose Morley triangle shrinks to 6 LEDs a side.\n// Knob 4: Exterior. Draws the exterior Morley triangle behind the big one: the points where the trisectors of the exterior angles meet beyond each side, also always equilateral, its sides parallel to the inner one's and 7 to 17 times as long, so mostly its edges cross the panel. Up to 0.1 nothing; its edge comes up to full by 0.6, and from 0.4 a dim fill grows inside it.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI, DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Smallest and largest angle the triangle may take at Wander 1, in degrees.\nconst AMIN = 12, AMAX = 132;\n// How far past the panel's edge the triangle's box may reach, in LEDs: a\n// corner may leave the panel sideways by up to OX and up or down by up to OY.\nconst OX = 12, OY = 2;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, wander: 0, ext: 0.06,\n    tau: 0, theta: NaN,\n    ang: new Float64Array(3),\n    // Panel corners A, B, C, the Morley points P (by BC), Q (by CA), R (by AB)\n    // and the exterior ones P', Q', R'.\n    v: new Float64Array(6), m: new Float64Array(6), e: new Float64Array(6),\n    lab: new Uint8Array(W * H), col: new Float32Array(9 * 3), colHue: NaN,\n  };\n}\n\n// The angles at time tau: a point in the plane a + b + c = 180 that swings\n// out from 60, 60, 60 toward a corner or an edge of the allowed region and\n// back, turning as it goes so every vertex takes its turn at being obtuse.\nfunction angles(S) {\n  const t = S.tau, roam = 0.6 + 0.4 * S.wander;\n  const phi = 0.23 * t + 1.3 * sin(0.071 * t + 0.4);\n  const e = 0.55 - 0.45 * cos(0.47 * t + 0.9 * sin(0.13 * t) + 0.9);\n  const c = [cos(phi), cos(phi - TAU / 3), cos(phi + TAU / 3)];\n  let rmax = 1e9;\n  for (const ck of c) rmax = min(rmax, ck > 0 ? (AMAX - 60) / ck : ck \u003c 0 ? (60 - AMIN) / -ck : 1e9);\n  const rho = roam * e * rmax;\n  for (let k = 0; k \u003c 3; k++) S.ang[k] = 60 + rho * c[k];\n}\n\n// The triangle with these angles, side V0V1 of length 1, about its centroid.\nfunction canonical(ang) {\n  const [a, b, c] = ang, L = sin(b * DEG) / sin(c * DEG);\n  const x = [0, 1, L * cos(a * DEG)], y = [0, 0, L * sin(a * DEG)];\n  const gx = (x[0] + x[1] + x[2]) / 3, gy = (y[0] + y[1] + y[2]) / 3;\n  return [x[0] - gx, y[0] - gy, x[1] - gx, y[1] - gy, x[2] - gx, y[2] - gy];\n}\n\n// The scale at which the triangle, turned by th, just fits inside the panel.\nfunction fit(T, th) {\n  const c = cos(th), s = sin(th);\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let k = 0; k \u003c 3; k++) {\n    const x = T[2 * k] * c - T[2 * k + 1] * s, y = T[2 * k] * s + T[2 * k + 1] * c;\n    x0 = min(x0, x), x1 = max(x1, x), y0 = min(y0, y), y1 = max(y1, y);\n  }\n  return { k: min((W + 2 * OX) / (x1 - x0), (H + 2 * OY) / (y1 - y0)), cx: (x0 + x1) / 2, cy: (y0 + y1) / 2 };\n}\n\n// Where the ray from p along d meets the ray from q along e.\nfunction meet(px, py, dx, dy, qx, qy, ex, ey, out, o) {\n  const den = dx * ey - dy * ex, t = ((qx - px) * ey - (qy - py) * ex) / den;\n  out[o] = px + t * dx;\n  out[o + 1] = py + t * dy;\n}\n\n// The trisector from vertex i nearest the side towards vertex j: the unit\n// vector from i to j turned a third of the angle at i towards the third\n// vertex, or with ext a third of the exterior angle, 180 less the angle,\n// away from it.\nfunction trisector(v, ang, i, j, out, ext) {\n  const k = 3 - i - j;\n  let ux = v[2 * j] - v[2 * i], uy = v[2 * j + 1] - v[2 * i + 1];\n  const ul = sqrt(ux * ux + uy * uy);\n  ux /= ul;\n  uy /= ul;\n  const wx = v[2 * k] - v[2 * i], wy = v[2 * k + 1] - v[2 * i + 1], dp = wx * ux + wy * uy;\n  let nx = wx - dp * ux, ny = wy - dp * uy;\n  const nl = sqrt(nx * nx + ny * ny);\n  nx /= ext ? -nl : nl;\n  ny /= ext ? -nl : nl;\n  const t = ((ext ? 180 - ang[i] : ang[i]) * DEG) / 3;\n  out[0] = ux * cos(t) + nx * sin(t);\n  out[1] = uy * cos(t) + ny * sin(t);\n}\n\nconst PAIRS = [[1, 2], [2, 1], [2, 0], [0, 2], [0, 1], [1, 0]];\nconst D = [new Float64Array(2), new Float64Array(2), new Float64Array(2), new Float64Array(2), new Float64Array(2), new Float64Array(2)];\n\nfunction place(S, d) {\n  angles(S);\n  const T = canonical(S.ang);\n  // Turn towards the angle at which the triangle fits largest, preferring\n  // angles near the current one so it does not flip between equal fits.\n  if (S.theta !== S.theta) {\n    let top = -1;\n    for (let n = 0; n \u003c 90; n++) {\n      const th = (n / 90) * PI, sc = fit(T, th).k;\n      if (sc > top) (top = sc), (S.theta = th);\n    }\n  }\n  let best = -1, target = S.theta;\n  for (let n = 0; n \u003c 60; n++) {\n    const th = S.theta + ((n - 30) / 30) * (PI / 2), u = (th - S.theta) / (PI / 2);\n    const sc = fit(T, th).k * (1 - 0.22 * u * u);\n    if (sc > best) (best = sc), (target = th);\n  }\n  S.theta += (target - S.theta) * min(1, d);\n  const F = fit(T, S.theta), c = cos(S.theta), s = sin(S.theta);\n  for (let k = 0; k \u003c 3; k++) {\n    const x = T[2 * k] * c - T[2 * k + 1] * s, y = T[2 * k] * s + T[2 * k + 1] * c;\n    S.v[2 * k] = W / 2 + (x - F.cx) * F.k;\n    S.v[2 * k + 1] = H / 2 + (y - F.cy) * F.k;\n  }\n  // Morley points: P where the trisectors of B and C next to BC meet, Q for\n  // C and A next to CA, R for A and B next to AB; then the same with the\n  // exterior trisectors, P', Q' and R' beyond the sides.\n  const v = S.v, a = S.ang;\n  for (const [ext, out] of [[false, S.m], [true, S.e]]) {\n    for (let n = 0; n \u003c 6; n++) trisector(v, a, PAIRS[n][0], PAIRS[n][1], D[n], ext);\n    for (let n = 0; n \u003c 3; n++) {\n      const i = PAIRS[2 * n][0], j = PAIRS[2 * n][1];\n      meet(v[2 * i], v[2 * i + 1], D[2 * n][0], D[2 * n][1], v[2 * j], v[2 * j + 1], D[2 * n + 1][0], D[2 * n + 1][1], out, 2 * n);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.wander = cl(k[2], 0, 1);\n  S.ext = cl(k[3], 0, 1);\n  S.tau += d * S.speed * 0.7;\n  place(S, d * (0.6 + 0.6 * S.speed));\n}\n\n// Inside test for triangle p0 p1 p2 at (x, y), either winding.\nfunction inside(x, y, ax, ay, bx, by, cx, cy) {\n  const e0 = (bx - ax) * (y - ay) - (by - ay) * (x - ax);\n  const e1 = (cx - bx) * (y - by) - (cy - by) * (x - bx);\n  const e2 = (ax - cx) * (y - cy) - (ay - cy) * (x - cx);\n  return (e0 >= 0 && e1 >= 0 && e2 >= 0) || (e0 \u003c= 0 && e1 \u003c= 0 && e2 \u003c= 0);\n}\n\nfunction palette(S) {\n  const col = S.col, h0 = S.hue + 0.13;\n  // 1 Morley, 2..4 the side triangles, 5 the dim rest, 6 the rim of ABC,\n  // 7 the rim of the exterior Morley triangle.\n  hsv(h0, 0.62, 1, col, 3);\n  const sides = [0.34, 0.49, 0.71];\n  for (let n = 0; n \u003c 3; n++) {\n    const h = h0 + sides[n], hf = h - floor(h), band = max(0, 1 - abs(hf - 0.12) / 0.13);\n    hsv(h, 0.82 - 0.25 * band, 0.62 + 0.3 * band, col, 6 + 3 * n);\n  }\n  // The dim rest stays slate whatever the hue: a dim warm colour reads brown.\n  hsv(0.68, 0.5, 0.19, col, 15);\n  hsv(h0 + 0.55, 0.25, 0.8, col, 18);\n  hsv(h0, 0.35, 1, col, 21);\n  S.colHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  const { v, m, e, lab, col } = S;\n  const [ax, ay, bx, by, cx, cy] = v, [px, py, qx, qy, rx, ry] = m;\n  const amt = sm(0.1, 0.6, S.ext), fill = 0.8 * sm(0.4, 1, S.ext);\n  // Edge lines of the exterior Morley triangle as unit normals pointing in,\n  // so a point's distance inside is the least of three dot products.\n  const nrm = [];\n  if (amt > 0) {\n    const turn = (e[2] - e[0]) * (e[5] - e[1]) - (e[3] - e[1]) * (e[4] - e[0]) > 0 ? 1 : -1;\n    for (let k = 0; k \u003c 3; k++) {\n      const x0 = e[2 * k], y0 = e[2 * k + 1], x1 = e[(2 * k + 2) % 6], y1 = e[(2 * k + 3) % 6], L = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2);\n      nrm.push([(-(y1 - y0) * turn) / L, ((x1 - x0) * turn) / L, x0, y0]);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const X = x + 0.5, Y = y + 0.5;\n      let l = 0;\n      if (inside(X, Y, ax, ay, bx, by, cx, cy)) {\n        if (inside(X, Y, px, py, qx, qy, rx, ry)) l = 1;\n        else if (inside(X, Y, bx, by, cx, cy, px, py)) l = 2;\n        else if (inside(X, Y, cx, cy, ax, ay, qx, qy)) l = 3;\n        else if (inside(X, Y, ax, ay, bx, by, rx, ry)) l = 4;\n        else l = 5;\n      }\n      lab[y * W + x] = l;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, l = lab[p];\n      let r = 0, g = 0, b = 0;\n      if (l > 0) {\n        let o = l * 3;\n        if ((x > 0 && lab[p - 1] === 0) || (x \u003c W - 1 && lab[p + 1] === 0) || (y > 0 && lab[p - W] === 0) || (y \u003c H - 1 && lab[p + W] === 0)) o = 18;\n        (r = col[o]), (g = col[o + 1]), (b = col[o + 2]);\n      } else if (amt > 0) {\n        // Behind the triangle, the exterior Morley triangle: an edge two\n        // LEDs wide in the hero's colour, paled, and a dim fill.\n        let d = 1e9;\n        for (const [nx, ny, x0, y0] of nrm) d = min(d, (x + 0.5 - x0) * nx + (y + 0.5 - y0) * ny);\n        if (d >= 0 && d \u003c 1.6) (r = col[21] * amt), (g = col[22] * amt), (b = col[23] * amt);\n        else if (d >= 1.6) (r = col[15] * fill), (g = col[16] * fill), (b = col[17] * fill);\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","peaucellier-linkage":"// ===== Patternflow pattern =====\n// Title:   Peaucellier Linkage\n// Family:  line\n// Idea:    A Peaucellier inversor of seven thick bars swings on two fixed pivots, its crank rocking one corner of the rhombus along a circle through the main pivot so that the opposite corner runs up and down an exact straight line nearly the height of the panel, drawn as a glowing rail, and moving the crank's pivot off its place sends that corner along a circle arc beside the rail instead.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Peaucellier–Lipkin linkage (Charles-Nicolas Peaucellier, 1864; Yom Tov Lipman Lipkin, 1871), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Arms=0..1, Offset=0..1\n//\n// Knob 1: Hue. Turns the bars round the wheel together. At 0 the long arms are azure, the rhombus gold, the crank rose and the rail mint; at 0.5 the arms are orange, the rhombus blue, the crank green and the rail pink.\n// Knob 2: Speed. How fast the crank rocks: at 2 the output joint runs the rail top to bottom and back in 6 seconds, at 0.2 in a minute, at 3 in 4 seconds.\n// Knob 3: Arms. The ratio of the long arms to the rhombus side, with their sum kept at 78 LEDs. At 0 the arms are 52 and the side 26, the rail stands 51 LEDs from the main pivot and the output runs 53 LEDs either side of centre; at 1 the arms are 45 and the side 33, the rhombus opens out, the rail moves in to 34 LEDs and the crank swings 116 degrees each way for a stroke of 55. The crank is always 0.44 of the inversion radius, so the output joint never crosses the joint the crank drives.\n// Knob 4: Offset. Moves the crank's pivot away from the main pivot. Up to 0.08 it sits exactly the crank's length away and the output runs on the straight rail, within 1e-13 LEDs of it; at 1 it is a tenth of the inversion radius farther (4.5 LEDs at Arms 0), the crank's circle misses the main pivot, and the output's white track runs on a circle arc of radius about 200, 5 LEDs inside the rail at the middle of the stroke.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sqrt, abs, sin, cos, atan, hypot, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// The main pivot O, on the left edge halfway down. The crank's pivot Q lies\n// to its right, and the output rail stands farther right, upright, so the\n// stroke runs along the panel's long side.\nconst OX = 6.5, OY = 64;\n// Arms plus side, in LEDs, and the half stroke the crank aims for.\nconst REACH = 78, STROKE = 55;\n// Bar half widths: arms and crank 4 LEDs wide, the rhombus 3.\nconst HW_ARM = 2, HW_RH = 1.5, HW_CR = 2;\n// Base hues of the arms, rhombus, crank and rail.\nconst HUES = [0.56, 0.12, 0.93, 0.42];\nconst TRAIL = 150;\n\n// The linkage for the knobs: long arm L, side s, inversion constant k =\n// L^2 - s^2 (|OP| |OP'| = k), crank length r, the rail's distance from O\n// d = k / 2r, and the crank pivot's offset.\nfunction geometry(G, arms, off) {\n  const rho = 2 - 0.65 * arms;\n  G.s = REACH / (1 + rho);\n  G.L = REACH - G.s;\n  G.k = G.L * G.L - G.s * G.s;\n  G.r = 0.44 * sqrt(G.k);\n  G.d = G.k / (2 * G.r);\n  G.off = (0.1 * sqrt(G.k) * max(0, off - 0.08)) / 0.92;\n  G.qx = OX + G.r + G.off;\n}\n\n// Solve the linkage for crank angle th: P on the crank's circle, A and B\n// where the circle of radius L round O meets the circle of radius s round\n// P, and P' the fourth corner of the rhombus, A + B - P. Nothing here uses\n// the inversion; the straight line is what the bars give.\nfunction solve(G, th, J) {\n  const px = G.qx + G.r * cos(th), py = OY + G.r * sin(th);\n  const dx = px - OX, dy = py - OY, D = hypot(dx, dy), ex = dx / D, ey = dy / D;\n  const a = (G.L * G.L - G.s * G.s + D * D) / (2 * D), hh = sqrt(max(0, G.L * G.L - a * a));\n  const mx = OX + a * ex, my = OY + a * ey;\n  J.px = px;\n  J.py = py;\n  J.ax = mx - hh * ey;\n  J.ay = my + hh * ex;\n  J.bx = mx + hh * ey;\n  J.by = my - hh * ex;\n  J.qx = 2 * mx - px;\n  J.qy = 2 * my - py;\n  J.D = D;\n  J.ok = G.L * G.L - a * a >= 0;\n}\n\n// How far the crank may swing: the largest angle up to the one that gives\n// the full stroke at which the rhombus is not flat, the arms are not\n// straight and P' stays on the panel. Both sides are mirror images.\nfunction swing(G, J) {\n  const goal = 2 * atan(STROKE / G.d);\n  let ok = 0;\n  for (let th = 0; th \u003c= goal + 1e-9; th += 0.004) {\n    solve(G, th, J);\n    const Dp = hypot(J.qx - OX, J.qy - OY);\n    if (!J.ok || J.D \u003c G.L - G.s + 1.5 || Dp > G.L + G.s - 3 || J.qy \u003c 6 || J.qy > H - 6) break;\n    ok = th;\n  }\n  return ok;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, arms: 0, offset: 0.06, ph: 0,\n    G: {}, J: {}, theta: 0, amp: 0, gKey: '',\n    rgb: new Float32Array(N * 3), tr: new Float32Array(N), col: new Float32Array(15),\n    tx: new Float32Array(TRAIL), ty: new Float32Array(TRAIL), tn: 0, ti: 0,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.arms = cl(k[2], 0, 1);\n  S.offset = cl(k[3], 0, 1);\n  // Inside the dead band the linkage is the same, so the track is kept.\n  const key = S.arms.toFixed(4) + ',' + max(0, S.offset - 0.08).toFixed(4);\n  if (key !== S.gKey) {\n    geometry(S.G, S.arms, S.offset);\n    S.amp = swing(S.G, S.J);\n    // A changed linkage starts a fresh track.\n    if (S.gKey) S.tn = 0;\n    S.gKey = key;\n  }\n  // One full rock (out, back, out the other way, back) is 6 s at Speed 2.\n  S.ph += (d * S.speed * 2 * PI) / 12;\n  // The crank angle is chosen so that, with the pivot in place, P' runs the\n  // rail in simple harmonic motion: y = T sin(phase) along the rail.\n  const T = S.G.d * Math.tan(S.amp / 2);\n  S.theta = 2 * atan((T * sin(S.ph)) / S.G.d);\n  S.stroke = T;\n  solve(S.G, S.theta, S.J);\n  S.tx[S.ti] = S.J.qx;\n  S.ty[S.ti] = S.J.qy;\n  S.ti = (S.ti + 1) % TRAIL;\n  S.tn = min(TRAIL, S.tn + 1);\n}\n\n// Paint colour c at cover a over what is there.\nfunction paint(rgb, p, a, r, g, b) {\n  const q = p * 3;\n  rgb[q] += (r - rgb[q]) * a;\n  rgb[q + 1] += (g - rgb[q + 1]) * a;\n  rgb[q + 2] += (b - rgb[q + 2]) * a;\n}\n\n// A bar from (ax, ay) to (bx, by) with round ends: a black rim one LED wide\n// first, so crossing bars stay apart, then the bar in its flat colour.\nfunction bar(rgb, ax, ay, bx, by, hw, col, o) {\n  const R = hw + 1.2, vx = bx - ax, vy = by - ay, ll = vx * vx + vy * vy || 1;\n  const x0 = max(0, floor(min(ax, bx) - R)), x1 = min(W - 1, ceil(max(ax, bx) + R));\n  const y0 = max(0, floor(min(ay, by) - R)), y1 = min(H - 1, ceil(max(ay, by) + R));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const cx = x + 0.5 - ax, cy = y + 0.5 - ay, t = cl((cx * vx + cy * vy) / ll, 0, 1);\n      const dd = hypot(cx - t * vx, cy - t * vy), p = y * W + x;\n      const rim = cl(R + 0.5 - dd, 0, 1);\n      if (rim \u003c= 0) continue;\n      paint(rgb, p, rim, 0, 0, 0);\n      const c = cl(hw + 0.5 - dd, 0, 1);\n      if (c > 0) paint(rgb, p, c, col[o], col[o + 1], col[o + 2]);\n    }\n}\n\n// A moving joint: a disc a shade paler than its bar, with a dark pin.\nfunction joint(rgb, cx, cy, rad, col, o) {\n  for (let y = max(0, floor(cy - rad - 2)); y \u003c= min(H - 1, ceil(cy + rad + 2)); y++)\n    for (let x = max(0, floor(cx - rad - 2)); x \u003c= min(W - 1, ceil(cx + rad + 2)); x++) {\n      const dd = hypot(x + 0.5 - cx, y + 0.5 - cy), p = y * W + x;\n      const rim = cl(rad + 1.5 - dd, 0, 1);\n      if (rim \u003c= 0) continue;\n      paint(rgb, p, rim, 0, 0, 0);\n      const c = cl(rad + 0.5 - dd, 0, 1);\n      if (c > 0) paint(rgb, p, c, 0.55 + 0.45 * col[o], 0.55 + 0.45 * col[o + 1], 0.55 + 0.45 * col[o + 2]);\n      const pin = cl(1.2 - dd, 0, 1);\n      if (pin > 0) paint(rgb, p, pin, 0.08, 0.08, 0.1);\n    }\n}\n\n// A fixed pivot: a pale ring round a dark centre, on a short ground bar.\nfunction anchor(rgb, cx, cy) {\n  for (let y = max(0, floor(cy - 6)); y \u003c= min(H - 1, ceil(cy + 6)); y++)\n    for (let x = max(0, floor(cx - 6)); x \u003c= min(W - 1, ceil(cx + 6)); x++) {\n      const dd = hypot(x + 0.5 - cx, y + 0.5 - cy), p = y * W + x;\n      const rim = cl(4.6 - dd, 0, 1);\n      if (rim \u003c= 0) continue;\n      paint(rgb, p, rim, 0, 0, 0);\n      const ring = cl(3.6 - dd, 0, 1) * cl(dd - 1.1, 0, 1);\n      if (ring > 0) paint(rgb, p, ring, 0.86, 0.88, 0.92);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.gKey) return;\n  const { rgb, col, G, J, tr } = S;\n  for (let i = 0; i \u003c 4; i++) hsv(S.hue + HUES[i], i === 3 ? 0.55 : 0.78, 1, col, i * 3);\n  rgb.fill(0);\n  tr.fill(0);\n\n  // The crank's circle, dotted and faint: it runs through O only when the\n  // crank's pivot is in place.\n  const nd = max(24, round((2 * PI * G.r) / 2.6));\n  for (let i = 0; i \u003c nd; i++) {\n    const a = (2 * PI * i) / nd, x = floor(G.qx + G.r * cos(a)), y = floor(OY + G.r * sin(a));\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) paint(rgb, y * W + x, 0.6, col[6], col[7], col[8]);\n  }\n\n  // The rail: the straight line P' runs on with the pivot in place, at d\n  // from O and as long as the stroke, glowing.\n  const lx = OX + G.d, top = OY - S.stroke - 2, bot = OY + S.stroke + 2;\n  for (let y = max(0, floor(top)); y \u003c= min(H - 1, ceil(bot)); y++) {\n    const end = cl(y + 1 - top, 0, 1) * cl(bot - y, 0, 1);\n    for (let x = max(0, floor(lx - 4)); x \u003c= min(W - 1, ceil(lx + 4)); x++) {\n      const dx = abs(x + 0.5 - lx), v = (cl(1.25 - dx, 0, 1) * 0.85 + 0.22 * Math.exp(-dx * dx / 3)) * end;\n      if (v > 0) paint(rgb, y * W + x, min(1, v), col[9], col[10], col[11]);\n    }\n  }\n\n  // P's own track over the last five seconds, a white line one LED wide,\n  // newest brightest. With the pivot in place it lies on the rail's centre.\n  for (let n = 0; n + 1 \u003c S.tn; n++) {\n    const i = (S.ti - 1 - n + TRAIL) % TRAIL, j = (i - 1 + TRAIL) % TRAIL, a = 1 - (0.75 * n) / TRAIL;\n    const x0 = S.tx[i], y0 = S.ty[i], x1 = S.tx[j], y1 = S.ty[j], steps = max(1, ceil(hypot(x1 - x0, y1 - y0) * 2));\n    for (let m = 0; m \u003c steps; m++) {\n      const f = m / steps, tx = x0 + (x1 - x0) * f, ty = y0 + (y1 - y0) * f, x = floor(tx), y = floor(ty);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) tr[y * W + x] = max(tr[y * W + x], a * cl(1.3 - abs(x + 0.5 - tx), 0, 1));\n    }\n  }\n  for (let p = 0; p \u003c N; p++) if (tr[p] > 0) paint(rgb, p, tr[p], 1, 1, 1);\n\n  // Bars, back to front: arms, crank, rhombus.\n  bar(rgb, OX, OY, J.ax, J.ay, HW_ARM, col, 0);\n  bar(rgb, OX, OY, J.bx, J.by, HW_ARM, col, 0);\n  bar(rgb, G.qx, OY, J.px, J.py, HW_CR, col, 6);\n  bar(rgb, J.ax, J.ay, J.px, J.py, HW_RH, col, 3);\n  bar(rgb, J.px, J.py, J.bx, J.by, HW_RH, col, 3);\n  bar(rgb, J.bx, J.by, J.qx, J.qy, HW_RH, col, 3);\n  bar(rgb, J.qx, J.qy, J.ax, J.ay, HW_RH, col, 3);\n  joint(rgb, J.ax, J.ay, 2.4, col, 0);\n  joint(rgb, J.bx, J.by, 2.4, col, 0);\n  joint(rgb, J.px, J.py, 2.4, col, 6);\n  joint(rgb, J.qx, J.qy, 2.6, col, 9);\n  anchor(rgb, OX, OY);\n  anchor(rgb, G.qx, OY);\n\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) display.setPixel(p % W, (p / W) | 0, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","pivot-walk":"// ===== Patternflow pattern =====\n// Title:   Pivot Walk\n// Family:  sim\n// Idea:    A self-avoiding walk of 80 to 160 steps on a 16 x 32 square lattice, drawn as a glowing chain coloured end to end, thrashes by the pivot algorithm: a random site is picked, one of the seven non-identity symmetries of the lattice is applied to the walk on one side of it, and when the result still avoids itself and fits on the panel the moved part swings round the pivot (a rotation) or folds over it (a reflection).\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: self-avoiding walk by the pivot algorithm (Moti Lal, 1969; Neal Madras and Alan Sokal, 1988), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Length=80..160, Stiff=0..1\n//\n// Knob 1: Hue. Turns the chain's gradient round the wheel. At 0 it runs from aqua at the first site through blue and violet to pink at the last; at 0.5 from coral through gold to green. The two end sites carry a white bead.\n// Knob 2: Speed. Pivot tries a second while the chain is at rest: 14 times the knob, so 28 at 2. An accepted try swings for 0.5 s at 2 when the moved arm is the whole chain and down to 0.25 s for an arm of one site; 0.33 s at 3 and 1.5 s at 0.2. A rejected try flashes its pivot site white for 0.15 s. At the opening knobs that comes to about 1.6 swings a second, the chain moving 66% of the time.\n// Knob 3: Length. The number of steps, 80 to 160, on 512 lattice sites 4 LEDs apart. Turning it grows or trims the chain at its ends, 30 steps a second. At 80 one try in 5 is accepted, at 160 one in 21, and the longer chain swings about half as often.\n// Knob 4: Stiff. A bending cost J from 0 to 3 per corner, taken by the Metropolis rule. A pivot changes only the corner at its own site, so a try that makes a new corner passes with chance exp(-J). Up to 0.06 there is no cost and the walk is the plain self-avoiding walk, with a corner at 66% of its sites; at 1 only 9% are corners, straight runs average 11 steps and the chain folds like a hairpin between the walls.\n// Buttons: K1 tap shrinks the chain to one site in the middle and it grows back at both ends, 30 steps a second, swinging as it grows.\n\nconst W = 64, H = 128, GW = 16, GH = 32, STEP = 4, NMAX = 160;\nconst { floor, min, max, sqrt, abs, round, cos, sin, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The seven non-identity symmetries of the square lattice acting on a\n// vector: rotations by +90, -90 and 180 degrees, then reflections in the\n// horizontal axis, the vertical axis, the diagonal y = x and y = -x.\nconst SX = [[0, -1], [0, 1], [-1, 0], [1, 0], [-1, 0], [0, 1], [0, -1]];\nconst SY = [[1, 0], [-1, 0], [0, -1], [0, -1], [0, 1], [1, 0], [-1, 0]];\n// For the drawing: the angle each rotation swings through, and the axis\n// each reflection folds about.\nconst ANG = [PI / 2, -PI / 2, PI];\nconst R2 = Math.SQRT1_2;\nconst AXIS = [null, null, null, [1, 0], [0, 1], [R2, R2], [R2, -R2]];\n// Gradient start hue at Hue 0 (aqua) and its span (to pink).\nconst HUE0 = 0.47, SPAN = 0.42;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, len: 80, J: 0, begun: false,\n    n: 0, xs: new Int16Array(NMAX + 1), ys: new Int16Array(NMAX + 1), grid: new Int16Array(GW * GH),\n    nx: new Int16Array(NMAX + 1), ny: new Int16Array(NMAX + 1),\n    // The swing under way: pivot k, moved side lo..hi, symmetry g, how far\n    // through (0..1) and how long it takes.\n    swing: null, acc: 0, grow: 0, flashes: [], tries: 0, accepted: 0,\n    // Drawing: positions in LEDs, the two layers (resting chain and the arm\n    // in motion) and the gradient table.\n    px: new Float32Array(NMAX + 1), py: new Float32Array(NMAX + 1),\n    keyA: new Float32Array(W * H), rgbA: new Float32Array(W * H * 3),\n    covB: new Float32Array(W * H), rgbB: new Float32Array(W * H * 3),\n    lut: new Float32Array(256 * 3), lutHue: NaN,\n  };\n}\n\nconst cell = (x, y) => y * GW + x;\n\n// One site in the middle of the lattice, for the walk to grow from.\nfunction seed(S) {\n  S.grid.fill(0);\n  S.n = 0;\n  S.xs[0] = GW >> 1;\n  S.ys[0] = GH >> 1;\n  S.grid[cell(S.xs[0], S.ys[0])] = 1;\n  S.swing = null;\n  S.flashes.length = 0;\n}\n\n// One pivot try. Returns true if it was accepted (and the walk changed).\n// The pivot site, the side that moves (a coin toss) and the symmetry are\n// all picked evenly, and a symmetry's inverse is one of the seven too, so a\n// move and its undoing are equally likely and the walks are sampled evenly.\nfunction attempt(S, animate) {\n  const n = S.n;\n  if (n \u003c 2) return false;\n  const k = 1 + floor(Math.random() * (n - 1)), tail = Math.random() \u003c 0.5, g = floor(Math.random() * 7);\n  const xs = S.xs, ys = S.ys, grid = S.grid, sx = SX[g], sy = SY[g];\n  const lo = tail ? k + 1 : 0, hi = tail ? n : k - 1, cx = xs[k], cy = ys[k];\n  S.tries++;\n  // The corner at k is the only one a pivot changes.\n  if (S.J > 0) {\n    let ax = xs[k] - xs[k - 1], ay = ys[k] - ys[k - 1], bx = xs[k + 1] - xs[k], by = ys[k + 1] - ys[k];\n    const before = ax !== bx || ay !== by;\n    if (tail) [bx, by] = [sx[0] * bx + sx[1] * by, sy[0] * bx + sy[1] * by];\n    else [ax, ay] = [sx[0] * ax + sx[1] * ay, sy[0] * ax + sy[1] * ay];\n    const after = ax !== bx || ay !== by;\n    if (after && !before && Math.random() > exp(-S.J)) return reject(S, k, animate);\n  }\n  // New places for the moved side. A place off the lattice cannot meet the\n  // resting side, which is all on it; the walk is slid back on afterwards\n  // if its bounding box still fits in 16 by 32 sites.\n  const nx = S.nx, ny = S.ny;\n  let x0 = GW, x1 = -1, y0 = GH, y1 = -1;\n  for (let i = 0; i \u003c= n; i++) {\n    if (i >= lo && i \u003c= hi) {\n      const dx = xs[i] - cx, dy = ys[i] - cy, x = cx + sx[0] * dx + sx[1] * dy, y = cy + sy[0] * dx + sy[1] * dy;\n      if (x >= 0 && x \u003c GW && y >= 0 && y \u003c GH) {\n        const o = grid[cell(x, y)] - 1;\n        if (o >= 0 && (o \u003c lo || o > hi)) return reject(S, k, animate);\n      }\n      nx[i] = x;\n      ny[i] = y;\n    } else {\n      nx[i] = xs[i];\n      ny[i] = ys[i];\n    }\n    if (nx[i] \u003c x0) x0 = nx[i];\n    if (nx[i] > x1) x1 = nx[i];\n    if (ny[i] \u003c y0) y0 = ny[i];\n    if (ny[i] > y1) y1 = ny[i];\n  }\n  if (x1 - x0 >= GW || y1 - y0 >= GH) return reject(S, k, animate);\n  // The slide also centres the walk's box on the lattice. Which shapes are\n  // allowed depends only on the size of that box, never where it sits.\n  const ox = floor((GW - 1 - x0 - x1) / 2), oy = floor((GH - 1 - y0 - y1) / 2);\n  if (animate) {\n    S.px.set(xs.subarray(0, n + 1));\n    S.py.set(ys.subarray(0, n + 1));\n  }\n  grid.fill(0);\n  for (let i = 0; i \u003c= n; i++) {\n    xs[i] = nx[i] + ox;\n    ys[i] = ny[i] + oy;\n    grid[cell(xs[i], ys[i])] = i + 1;\n  }\n  S.accepted++;\n  if (animate) {\n    // A short arm swings in as little as half the time of a long one.\n    const size = hi - lo + 1, T = cl(1 / S.speed, 0.3, 1.5) * (0.5 + 0.5 * sqrt(size / n));\n    S.swing = { k, lo, hi, g, t: 0, T, sx: ox, sy: oy, ox: S.px.slice(0, n + 1), oy: S.py.slice(0, n + 1) };\n  }\n  return true;\n}\n\nfunction reject(S, k, animate) {\n  if (animate && S.flashes.length \u003c 24) S.flashes.push({ k, life: 1 });\n  return false;\n}\n\n// Grow one step at an end: a free neighbour of the last (or first) site.\nfunction growOne(S) {\n  const n = S.n, xs = S.xs, ys = S.ys, grid = S.grid;\n  for (const atEnd of Math.random() \u003c 0.5 ? [true, false] : [false, true]) {\n    const e = atEnd ? n : 0, free = [];\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n      const x = xs[e] + dx, y = ys[e] + dy;\n      if (x >= 0 && x \u003c GW && y >= 0 && y \u003c GH && !grid[cell(x, y)]) free.push([x, y]);\n    }\n    if (!free.length) continue;\n    const [x, y] = free[floor(Math.random() * free.length)];\n    if (!atEnd) {\n      for (let i = n; i >= 0; i--) {\n        xs[i + 1] = xs[i];\n        ys[i + 1] = ys[i];\n        grid[cell(xs[i + 1], ys[i + 1])] = i + 2;\n      }\n      xs[0] = x;\n      ys[0] = y;\n      grid[cell(x, y)] = 1;\n    } else {\n      xs[n + 1] = x;\n      ys[n + 1] = y;\n      grid[cell(x, y)] = n + 2;\n    }\n    S.n = n + 1;\n    return true;\n  }\n  return false;\n}\n\n// Trim one step, from the end the coin picks.\nfunction trimOne(S) {\n  const n = S.n, xs = S.xs, ys = S.ys, grid = S.grid;\n  if (Math.random() \u003c 0.5) grid[cell(xs[n], ys[n])] = 0;\n  else {\n    grid[cell(xs[0], ys[0])] = 0;\n    for (let i = 0; i \u003c n; i++) {\n      xs[i] = xs[i + 1];\n      ys[i] = ys[i + 1];\n      grid[cell(xs[i], ys[i])] = i + 1;\n    }\n  }\n  S.n = n - 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 80, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.len = round(cl(kv[2], 80, NMAX));\n  const st = cl(kv[3], 0, 1);\n  S.J = st \u003c= 0.06 ? 0 : (3 * (st - 0.06)) / 0.94;\n  if (!S.begun) {\n    // Open on a walk already crumpled: grown from one site a step at a\n    // time with 30 tries after each step, then 30 tries a step more.\n    seed(S);\n    for (let guard = 0; S.n \u003c S.len && guard \u003c 20 * S.len; guard++) {\n      growOne(S);\n      for (let i = 0; i \u003c 30; i++) attempt(S, false);\n    }\n    for (let i = 0; i \u003c 30 * S.len; i++) attempt(S, false);\n    S.begun = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) seed(S);\n  for (const f of S.flashes) f.life -= d / 0.15;\n  S.flashes = S.flashes.filter((f) => f.life > 0 && f.k \u003c S.n);\n  if (S.swing) {\n    S.swing.t += d / S.swing.T;\n    if (S.swing.t >= 1) S.swing = null;\n    return;\n  }\n  // Length: 30 steps a second toward the knob, with no tries meanwhile\n  // unless both ends are boxed in and only a pivot can free them.\n  if (S.n !== S.len) {\n    S.grow += d * 30;\n    let stuck = false;\n    while (S.grow >= 1 && S.n !== S.len) {\n      S.grow -= 1;\n      if (S.n > S.len) trimOne(S);\n      else if (!growOne(S)) {\n        stuck = true;\n        break;\n      }\n    }\n    if (!stuck) {\n      S.acc = 0;\n      return;\n    }\n  } else S.grow = 0;\n  S.acc += d * 14 * S.speed;\n  while (S.acc >= 1 && !S.swing) {\n    S.acc -= 1;\n    attempt(S, true);\n  }\n  if (S.swing) S.acc = 0;\n}\n\nconst ease = (t) => t * t * (3 - 2 * t);\n\n// Where every site is drawn this frame, in LEDs.\nfunction positions(S) {\n  const { xs, ys, px, py, n, swing } = S;\n  if (!swing) {\n    for (let i = 0; i \u003c= n; i++) {\n      px[i] = xs[i] * STEP + 2;\n      py[i] = ys[i] * STEP + 2;\n    }\n    return 1;\n  }\n  // Every site from where it was: the resting side only slides with the\n  // shift that keeps the walk on the panel, the moved side turns about the\n  // pivot as well.\n  const e = ease(cl(swing.t, 0, 1)), ox = swing.ox, oy = swing.oy, cx = ox[swing.k], cy = oy[swing.k];\n  const tx = swing.sx * e * STEP, ty = swing.sy * e * STEP;\n  for (let i = 0; i \u003c= n; i++) {\n    px[i] = ox[i] * STEP + 2 + tx;\n    py[i] = oy[i] * STEP + 2 + ty;\n  }\n  let fold = 1;\n  if (swing.g \u003c 3) {\n    const a = ANG[swing.g] * e, c = cos(a), s = sin(a);\n    for (let i = swing.lo; i \u003c= swing.hi; i++) {\n      const dx = (ox[i] - cx) * STEP, dy = (oy[i] - cy) * STEP;\n      px[i] = cx * STEP + 2 + tx + c * dx - s * dy;\n      py[i] = cy * STEP + 2 + ty + s * dx + c * dy;\n    }\n  } else {\n    // A fold: the part across the axis shrinks through zero and opens on\n    // the other side, as if the arm turned over out of the panel.\n    const [ax, ay] = AXIS[swing.g], f = cos(PI * e);\n    fold = 0.55 + 0.45 * abs(f);\n    for (let i = swing.lo; i \u003c= swing.hi; i++) {\n      const dx = (ox[i] - cx) * STEP, dy = (oy[i] - cy) * STEP;\n      const along = dx * ax + dy * ay, across = (dx * -ay + dy * ax) * f;\n      px[i] = cx * STEP + 2 + tx + along * ax - across * ay;\n      py[i] = cy * STEP + 2 + ty + along * ay + across * ax;\n    }\n  }\n  return fold;\n}\n\n// One bond as a 2-LED line with a dim glow 2 LEDs out, its colour taken\n// from the gradient at each LED's place along the chain.\nfunction bond(S, i, moving, bright) {\n  const { px, py, lut, n } = S, x0 = px[i], y0 = py[i], x1 = px[i + 1], y1 = py[i + 1];\n  const ex = x1 - x0, ey = y1 - y0, L2 = ex * ex + ey * ey || 1, R = 3.2;\n  const xa = max(0, floor(min(x0, x1) - R)), xb = min(W - 1, floor(max(x0, x1) + R));\n  const ya = max(0, floor(min(y0, y1) - R)), yb = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const qx = x + 0.5 - x0, qy = y + 0.5 - y0, u = cl((qx * ex + qy * ey) / L2, 0, 1);\n      const dx = qx - u * ex, dy = qy - u * ey, dd = sqrt(dx * dx + dy * dy);\n      if (dd >= R) continue;\n      const cov = cl(1.5 - dd, 0, 1), glow = 0.18 * cl(1 - (dd - 1.2) / 1.8, 0, 1);\n      const c = 3 * min(255, floor(((i + u) / n) * 255.99)), p = y * W + x;\n      if (moving) {\n        if (cov \u003c= S.covB[p]) continue;\n        S.covB[p] = cov;\n        S.rgbB[3 * p] = lut[c] * bright;\n        S.rgbB[3 * p + 1] = lut[c + 1] * bright;\n        S.rgbB[3 * p + 2] = lut[c + 2] * bright;\n      } else {\n        const key = cov > 0 ? 1 + cov : glow;\n        if (key \u003c= S.keyA[p]) continue;\n        S.keyA[p] = key;\n        const v = cov > 0 ? cov : glow;\n        S.rgbA[3 * p] = lut[c] * v;\n        S.rgbA[3 * p + 1] = lut[c + 1] * v;\n        S.rgbA[3 * p + 2] = lut[c + 2] * v;\n      }\n    }\n}\n\n// A round dot: white core of radius r, edge of the given colour.\nfunction bead(S, x0, y0, r, wr, wg, wb, a) {\n  for (let y = max(0, floor(y0 - r - 1)); y \u003c= min(H - 1, floor(y0 + r + 1)); y++)\n    for (let x = max(0, floor(x0 - r - 1)); x \u003c= min(W - 1, floor(x0 + r + 1)); x++) {\n      const dd = sqrt((x + 0.5 - x0) ** 2 + (y + 0.5 - y0) ** 2), c = cl(r + 0.5 - dd, 0, 1) * a, p = y * W + x;\n      if (c \u003c= 0) continue;\n      const o = 3 * p, bA = S.covB[p];\n      // Beads sit on top of both layers: write the moving layer.\n      S.rgbB[o] = S.rgbB[o] * bA * (1 - c) + wr * c;\n      S.rgbB[o + 1] = S.rgbB[o + 1] * bA * (1 - c) + wg * c;\n      S.rgbB[o + 2] = S.rgbB[o + 2] * bA * (1 - c) + wb * c;\n      const nb = 1 - (1 - bA) * (1 - c);\n      if (nb > 0) {\n        S.rgbB[o] /= nb;\n        S.rgbB[o + 1] /= nb;\n        S.rgbB[o + 2] /= nb;\n      }\n      S.covB[p] = nb;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  if (S.lutHue !== S.hue) {\n    for (let i = 0; i \u003c 256; i++) {\n      const t = i / 255, h = S.hue + HUE0 + SPAN * t, hf = h - floor(h);\n      // Pure blue reads dim beside the rest: a little white in it.\n      const blue = max(0, 1 - abs(hf - 0.66) / 0.08);\n      hsv(h, 0.92 - 0.25 * blue, 1, S.lut, 3 * i);\n    }\n    S.lutHue = S.hue;\n  }\n  const fold = positions(S), sw = S.swing, n = S.n;\n  S.keyA.fill(0);\n  S.rgbA.fill(0);\n  S.covB.fill(0);\n  S.rgbB.fill(0);\n  // The bond from the pivot into the moved side turns with it.\n  for (let i = 0; i \u003c n; i++) {\n    const moving = sw && ((sw.lo > sw.k && i >= sw.k) || (sw.lo \u003c sw.k && i \u003c sw.k));\n    if (!moving) bond(S, i, false, 1);\n  }\n  if (sw) {\n    const lift = 1 + 0.25 * sin(PI * cl(sw.t, 0, 1));\n    for (let i = 0; i \u003c n; i++)\n      if ((sw.lo > sw.k && i >= sw.k) || (sw.lo \u003c sw.k && i \u003c sw.k)) bond(S, i, true, fold * lift);\n  }\n  const { px, py } = S;\n  bead(S, px[0], py[0], 1.9, 1, 1, 1, 1);\n  bead(S, px[n], py[n], 1.9, 1, 1, 1, 1);\n  if (sw) bead(S, px[sw.k], py[sw.k], 1.2, 1, 1, 1, 0.9 * sin(PI * cl(sw.t, 0, 1)));\n  for (const f of S.flashes) bead(S, px[f.k], py[f.k], 1.1, 1, 1, 1, 0.85 * f.life);\n  const { rgbA, rgbB, covB } = S;\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const a = covB[p];\n    let r = rgbA[o], g = rgbA[o + 1], b = rgbA[o + 2];\n    if (a > 0) {\n      r = r * (1 - a) + min(1, rgbB[o]) * a;\n      g = g * (1 - a) + min(1, rgbB[o + 1]) * a;\n      b = b * (1 - a) + min(1, rgbB[o + 2]) * a;\n    }\n    display.setPixel(p % W, (p / W) | 0, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n  }\n}\n","witch-moon":"// ===== Patternflow pattern =====\n// Title:   Witch Moon\n// Family:  halloween\n// Idea:    A huge full moon hangs in the upper middle of a purple night, ragged clouds drift across it with their edges lit by its light, bare branches sway along the bottom, and every so often a witch on a broomstick, cloak and bristles fluttering and a trail of green sparks behind her, flies across the face of the moon.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Flights=0..1\n//\n// Knob 1: Hue. The moon's tint, and the light on the cloud edges with it. At 0 harvest orange, at 0.25 amber, at 0.5 bone white, at 0.75 a ghostly green and at 1 lilac.\n// Knob 2: Speed. The clock of the whole scene. At 2 the near clouds drift 7 LEDs a second and the far ones 3.5, a branch sways once in 3 seconds, and a witch flies 18 LEDs a second and is in sight for about 7 seconds; at 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Clouds. At 0 three near and three far cloud banks take turns across the sky and a fifth of the moon is under cloud on average; at 0.5 six of each and 43% of the moon is hidden; at 1 eight of each, 30% longer and 60% thicker, and two thirds of it. Far banks let 30% of the light behind them through, near ones none.\n// Knob 4: Flights. How many witches fly together and how often. Below 0.25 one witch, then two, three and from 0.75 four, the others smaller and ahead of the last in a V. The next flight leaves 8 seconds after the last one has gone at 0 and 2 seconds after at 1 (at Speed 2). The first flight leaves at once and its middle crosses the middle of the moon at 3.7 seconds.\n// Buttons: K1 tap sends the next flight at once, or the moment the one in the air has gone.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n// A fixed hash, so the clouds, stars and trees are the same on every run.\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The moon: centre and radius in LEDs.\nconst MX = 32, MY = 42, MR = 24;\n// Moon tints along Hue: harvest orange, amber, bone white, ghost green, lilac.\nconst TINTS = [[1, 0.57, 0.16], [1, 0.79, 0.36], [0.94, 0.9, 0.8], [0.69, 1, 0.6], [0.8, 0.67, 1]];\n\n// Value noise on a 64 x 64 table that wraps, for ragged cloud edges and\n// the shores of the moon's seas.\nconst NT = new Float32Array(64 * 64);\nfor (let i = 0; i \u003c NT.length; i++) NT[i] = hash(i * 7 + 3);\nfunction vnoise(x, y) {\n  const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n  const ux = fx * fx * (3 - 2 * fx), uy = fy * fy * (3 - 2 * fy);\n  const i0 = xi & 63, i1 = (xi + 1) & 63, j0 = (yi & 63) \u003c\u003c 6, j1 = ((yi + 1) & 63) \u003c\u003c 6;\n  const a = NT[j0 + i0], b = NT[j0 + i1], c = NT[j1 + i0], d = NT[j1 + i1];\n  return a + (b - a) * ux + (c - a) * uy + (a - b - c + d) * ux * uy;\n}\n\n// Cloud streaks in two layers, both drifting left: far ones thin, slow and\n// letting 30% of what is behind them through, near ones thicker, faster and\n// dark. Each is [row, length, thickness, where it is at the start]; the\n// Clouds knob brings in more of each list and fattens them. Speeds are\n// LEDs a second at Speed 2.\nconst LAYERS = [\n  { v: 3.5, body: [0.1, 0.065, 0.15], op: 0.7, list: [[28, 56, 6, 40], [64, 60, 6, 0], [46, 48, 5, 100], [14, 44, 5, 75], [36, 52, 6, 130], [72, 40, 5, 60], [54, 50, 6, 20], [20, 46, 5, 115]] },\n  { v: 7, body: [0.04, 0.028, 0.075], op: 1, list: [[61, 46, 10, 74], [32, 38, 9, 18], [70, 52, 11, 110], [84, 44, 10, 40], [42, 34, 8, 128], [24, 30, 8, 95], [60, 40, 9, -10], [92, 50, 11, 130]] },\n];\nconst CLOUDS = [];\nLAYERS.forEach((L, l) =>\n  L.list.forEach(([y, len, th, x], i) => {\n    const puffs = [];\n    for (let k = 0; k \u003c 5; k++) {\n      const hs = (n) => hash(l * 1000 + i * 50 + k * 7 + n);\n      puffs.push([(k + 0.5) / 5 - 0.5 + (hs(1) - 0.5) / 10, (0.75 + 0.5 * hs(2)) / 5, 0.55 + 0.45 * sin((PI * (k + 0.5)) / 5) * hs(3)]);\n    }\n    CLOUDS.push({ l, i, y, len, th, x, puffs, seed: l * 13 + i * 5.7 });\n  }),\n);\n\n// The moon's face, fixed and drawn in four tones like pixel art: bright\n// highland, the shore of a sea, the seas and crater floors. Six seas are\n// ellipses with wobbly edges, placed roughly where they are on the Moon;\n// a ring at the limb is one tone darker, and each crater is a dark floor\n// with a lit rim on its lower right.\nconst TONES = [1, 0.88, 0.76, 0.66];\nconst SEAS = [[-7, -8, 8, 6], [6, -10, 6, 5], [10, -2, 6, 5], [-12, 4, 6, 9], [3, 7, 5, 4], [15, 8, 3.5, 3]];\nconst CRATERS = [[-4, 15, 2.6], [14, -14, 2.2], [-16, -7, 2], [9, 16, 2.2], [-1, -18, 1.8]];\nconst FACE = new Float32Array(W * H);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n    if (r > MR + 1) continue;\n    let e = 9;\n    for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2);\n    e += 0.6 * (vnoise(x / 3.1 + 7, y / 3.1 + 2) - 0.5);\n    let tone = e \u003c 1 ? 2 : e \u003c 1.35 ? 1 : 0;\n    if (r > MR - 2.2) tone++;\n    for (const [cx, cy, cr] of CRATERS) {\n      const qx = dx - cx, qy = dy - cy, d = sqrt(qx * qx + qy * qy);\n      if (d \u003c cr) tone = max(tone + 1, 2);\n      else if (d \u003c cr + 1.2 && qx + qy > 0.6 * cr) tone = 0;\n    }\n    FACE[y * W + x] = TONES[min(3, tone)];\n  }\n\n// The sky by row: deep blue-violet at the top, a purple glow at the horizon.\nconst SKY = [[0, 0.02, 0.016, 0.08], [60, 0.065, 0.032, 0.135], [98, 0.19, 0.065, 0.25], [120, 0.33, 0.11, 0.33]];\nconst SKYROW = new Float32Array(H * 3);\nfor (let y = 0; y \u003c H; y++) {\n  let k = 0;\n  while (k \u003c SKY.length - 2 && y > SKY[k + 1][0]) k++;\n  const [y0, r0, g0, b0] = SKY[k], [y1, r1, g1, b1] = SKY[k + 1], t = sm(0, 1, cl((y - y0) / (y1 - y0), 0, 1));\n  SKYROW[3 * y] = r0 + (r1 - r0) * t;\n  SKYROW[3 * y + 1] = g0 + (g1 - g0) * t;\n  SKYROW[3 * y + 2] = b0 + (b1 - b0) * t;\n}\n\n// Stars in the dark upper sky, clear of the moon's glow.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 14 && i \u003c 400; i++) {\n  const x = floor(hash(i * 3 + 101) * W), y = floor(hash(i * 3 + 102) * 80);\n  if ((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2 \u003c (MR + 9) ** 2) continue;\n  STARS.push([x, y, hash(i * 3 + 103) * 6.28]);\n}\n\n// The trees: two bare trees grown from fixed numbers. Each branch is\n// [parent, angle to its parent, length, start radius, end radius, depth,\n// sway phase]; angle 0 is straight up.\nconst TREES = [];\nfunction grow(root, x, y, angle, len, r, depth, maxD, seed) {\n  const id = TREES.length;\n  TREES.push({ parent: root, x, y, a: angle, len, r0: r, r1: max(0.5, r * 0.66), depth, ph: hash(seed) * 6.28 });\n  if (depth >= maxD) return;\n  const kids = depth \u003c 2 ? 2 : hash(seed + 1) \u003c 0.65 ? 2 : 1;\n  for (let k = 0; k \u003c kids; k++) {\n    const s = seed * 5 + k * 17 + 3, side = kids === 1 ? (hash(s) \u003c 0.5 ? -1 : 1) : k === 0 ? -1 : 1;\n    const da = side * (0.3 + 0.45 * hash(s + 1)) + (hash(s + 2) - 0.5) * 0.3;\n    grow(id, 0, 0, da, len * (0.62 + 0.22 * hash(s + 3)), max(0.5, r * 0.66), depth + 1, maxD, s + 9);\n  }\n}\ngrow(-1, 3, 131, 0.32, 24, 3.6, 0, 6, 5);\ngrow(-1, 62, 131, -0.42, 18, 2.8, 0, 5, 77);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, clouds: 0, flights: 0.06,\n    // Scene clock (seconds at Speed 2; the clouds are placed from it), the\n    // flight under way and the wait for the next, sparks behind the brooms.\n    t: 0, flight: null, wait: 0, nflight: 0, sparks: [],\n    rgb: new Float32Array(W * H * 3), mask: new Float32Array(W * H), tint: [1, 0.6, 0.2],\n    bx: new Float32Array(TREES.length), by: new Float32Array(TREES.length), ex: new Float32Array(TREES.length), ey: new Float32Array(TREES.length),\n    begun: false, queued: false,\n  };\n}\n\n// A flight: direction alternates; the leader's centre runs from 35 LEDs off\n// one side to 35 off the other, rising gently, at 18 LEDs a second at Speed 2.\nfunction launch(S) {\n  const dir = S.nflight % 2 === 0 ? 1 : -1, n = 1 + min(3, floor(4 * S.flights));\n  // The flight is placed by its middle, so whatever the number of witches\n  // the group is centred on the moon 3.7 s after it leaves (at Speed 2).\n  let mid = 0;\n  for (let j = 0; j \u003c n; j++) mid += COVEN[j][0] / n;\n  S.flight = { dir, age: 0, n, mid };\n  S.nflight++;\n}\n// Places of the witches in a flight, as [LEDs ahead of the last one, LEDs\n// up or down, scale]: the last is the biggest, the others fly ahead of her\n// in a V, smaller as if farther off.\nconst COVEN = [[0, 0, 0.88], [22, -19, 0.7], [22, 19, 0.72], [44, 0, 0.64]];\nconst FLY = 18, MARGIN = 35;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.clouds = cl(k[2], 0, 1);\n  S.flights = cl(k[3], 0, 1);\n  // The first flight leaves at once, with as many witches as the knob asks.\n  if (!S.begun) {\n    launch(S);\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // A tap sends the next flight at once, or straight after the one in the air.\n  if (input.btnPressed && input.btnPressed[0]) {\n    if (S.flight) S.queued = true;\n    else launch(S);\n  }\n  if (S.flight) {\n    const f = S.flight;\n    f.age += ds;\n    const span = W + 2 * MARGIN + f.mid;\n    if (f.age * FLY > span) {\n      S.flight = null;\n      S.wait = S.queued ? 0 : 8 - 6 * S.flights;\n      S.queued = false;\n    } else {\n      // Sparks from each broom's bristles, 40 a second each.\n      for (let j = 0; j \u003c f.n; j++) {\n        const w = witchPlace(S, f, j), bx = w.x - w.dir * 20 * w.s, by = w.y + 2 * w.s;\n        for (let e = ds * 40; e > 0 && S.sparks.length \u003c 400; e--) {\n          if (e \u003c 1 && Math.random() > e) break;\n          S.sparks.push({ x: bx + (Math.random() - 0.5) * 4, y: by + (Math.random() - 0.5) * 4, vx: -w.dir * (1 + 4 * Math.random()), vy: 1.5 + 4 * Math.random(), life: 1, ph: Math.random() * 6.28 });\n        }\n      }\n    }\n  } else {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) launch(S);\n  }\n  for (const p of S.sparks) {\n    p.x += p.vx * ds;\n    p.y += p.vy * ds;\n    p.life -= ds / 2;\n  }\n  S.sparks = S.sparks.filter((p) => p.life > 0);\n}\n\n// Witch j of a flight: centre, scale, direction, tilt. She climbs 0.22 LEDs\n// for each LED she flies and swoops 3.5 LEDs up and down every 2.6 s.\nfunction witchPlace(S, f, j) {\n  const [ahead, up, s] = COVEN[j], run = f.age * FLY - MARGIN + ahead - f.mid, x = f.dir > 0 ? run : W - run;\n  const ph = f.age * 2.4 + j * 0.5, y = MY + 1 + up - 0.22 * (run - MX) + 3.5 * sin(ph);\n  return { x, y, s, dir: f.dir, tilt: f.dir * (-0.14 + 0.28 * cos(ph)) };\n}\n\n// Signed distance to a capsule and to a polygon, in the witch's own units.\nfunction capsule(px, py, ax, ay, bx, by, r) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey), 0, 1);\n  return sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) - r;\n}\nfunction poly(px, py, v) {\n  let dd = 1e9, s = 1;\n  for (let i = 0, j = v.length - 2; i \u003c v.length; j = i, i += 2) {\n    const ex = v[j] - v[i], ey = v[j + 1] - v[i + 1], wx = px - v[i], wy = py - v[i + 1];\n    const u = cl((wx * ex + wy * ey) / (ex * ex + ey * ey), 0, 1), bx = wx - ex * u, by = wy - ey * u;\n    dd = min(dd, bx * bx + by * by);\n    const c1 = py >= v[i + 1], c2 = py \u003c v[j + 1], c3 = ex * wy > ey * wx;\n    if ((c1 && c2 && c3) || (!c1 && !c2 && !c3)) s = -s;\n  }\n  return s * sqrt(dd);\n}\n\n// The witch as one shape, facing +x with y down, the seat on the broom at\n// the origin; fl is her own flutter clock. Generic: pointed hat with a brim\n// and a bent tip, hair and cloak streaming back, a hooked nose, one arm to\n// the broom, a boot hanging below it and a fan of bristles.\nfunction witchShapes(fl) {\n  const f = (k, a) => a * sin(fl * 9 + k * 1.9);\n  return [\n    [\"c\", -11, 1.2, 15, -1.2, 0.9],\n    [\"p\", [-10, 0, -10, 2.4, -18.5, 6 + f(1, 1), -21, 3.5 + f(2, 1.2), -21, 0 + f(3, 1.2), -18.5, -2.5 + f(4, 1)]],\n    [\"p\", [4.5, -9, 6, -2, 5, 1.5, -2, 1.5, -8 + f(5, 1), -1 + f(6, 1.4), -12.5 + f(7, 1.2), -4 + f(8, 1.8), -5, -6.5, 1, -9.5]],\n    [\"c\", 3, 1, 6.5, 5.5, 1.2],\n    [\"c\", 6.5, 5.5, 9.5, 5, 0.9],\n    [\"c\", 3.5, -7, 9.5, -1.5, 1],\n    [\"c\", 3.5, -11.5, 3.5, -11.5, 2.4],\n    [\"p\", [5.5, -12.3, 8.4, -10.6, 5.6, -10.4]],\n    [\"c\", 2, -11, -3.5 + f(9, 0.8), -8.5 + f(10, 0.8), 1],\n    [\"c\", 2, -10, -4.5 + f(11, 0.8), -6.2 + f(12, 0.8), 0.8],\n    [\"c\", -2, -13.6, 8.8, -14.6, 0.75],\n    [\"p\", [0.5, -14, 6.5, -14.6, 3.8, -19.5, -1.5 + f(13, 0.6), -23 + f(14, 0.4), 2, -19]],\n  ];\n}\n\nfunction drawWitch(S, w, fl) {\n  const shapes = witchShapes(fl), mask = S.mask, c = cos(w.tilt), s = sin(w.tilt), R = 24 * w.s;\n  for (let y = max(0, floor(w.y - R)); y \u003c= min(H - 1, floor(w.y + R)); y++)\n    for (let x = max(0, floor(w.x - R)); x \u003c= min(W - 1, floor(w.x + R)); x++) {\n      const dx = x + 0.5 - w.x, dy = y + 0.5 - w.y;\n      const lx = ((c * dx + s * dy) / w.s) * w.dir, ly = (-s * dx + c * dy) / w.s;\n      if (lx \u003c -23 || lx > 17 || ly \u003c -25 || ly > 8) continue;\n      let dd = 1e9;\n      for (const sh of shapes) {\n        const v = sh[0] === \"c\" ? capsule(lx, ly, sh[1], sh[2], sh[3], sh[4], sh[5]) : poly(lx, ly, sh[1]);\n        if (v \u003c dd) dd = v;\n      }\n      const cov = cl(0.5 - dd * w.s, 0, 1), p = y * W + x;\n      if (cov > mask[p]) mask[p] = cov;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, mask } = S;\n  // Moon tint from Hue.\n  const hk = S.hue * (TINTS.length - 1), i0 = min(TINTS.length - 2, floor(hk)), ht = hk - i0;\n  const T = S.tint;\n  for (let c = 0; c \u003c 3; c++) T[c] = TINTS[i0][c] + (TINTS[i0 + 1][c] - TINTS[i0][c]) * ht;\n  // Where each cloud is now, and how big, for the clouds the knob lets in.\n  const live = [], c = S.clouds;\n  for (const C of CLOUDS) {\n    if (C.i >= 3 + round(5 * c)) continue;\n    const len = C.len * (1 + 0.3 * c), th = C.th * (1 + 0.6 * c), m = len / 2 + 8, span = W + 2 * m;\n    let u = (C.x + m - LAYERS[C.l].v * S.t) % span;\n    if (u \u003c 0) u += span;\n    live.push({ C, cx: u - m, len, th });\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p, dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n      let R = SKYROW[3 * y], G = SKYROW[3 * y + 1], B = SKYROW[3 * y + 2];\n      // Glow round the moon in rings, then the moon itself.\n      const out = max(0, r - MR), glow = round((0.34 * exp(-out / 6) + 0.12 * exp(-out / 22)) * 20) / 20;\n      R += T[0] * glow;\n      G += T[1] * glow;\n      B += T[2] * glow;\n      if (r \u003c MR + 0.5) {\n        const f = FACE[p], disc = r \u003c MR - 0.3 ? 1 : 0.6;\n        R += (T[0] * f - R) * disc;\n        G += (T[1] * f - G) * disc;\n        B += (T[2] * f - B) * disc;\n      }\n      // Clouds, far then near, in flat tones: a puffy top, a flatter base\n      // and a ragged edge. The edge of a cloud near the moon is lit in the\n      // moon's tint; its body takes a little of that light.\n      const light = round(4 * exp(-max(0, r - 0.8 * MR) / 10)) / 4;\n      for (const K of live) {\n        const { C, cx, len, th } = K, qx = x + 0.5 - cx, qy = y + 0.5 - C.y;\n        if (abs(qx) > len / 2 + 4 || qy \u003c -th - 2 || qy > 0.5 * th + 2) continue;\n        let dd = 1e9;\n        for (const [px, rx, ry] of C.puffs) {\n          const ex = (qx - px * len) / (rx * len), ey = qy / (qy \u003c 0 ? ry * th : 0.42 * th);\n          dd = min(dd, (sqrt(ex * ex + ey * ey) - 1) * min(rx * len, ry * th));\n        }\n        dd += 2.2 * (vnoise(qx / 3.2 + C.seed, y / 2.6) - 0.5) + 1.6 * (vnoise(qx / 7 + C.seed, y / 5) - 0.5);\n        if (dd >= 0) continue;\n        // The lit edge is the tint halfway to white, so over the moon it\n        // still shows as a line brighter than the face behind it.\n        const L = LAYERS[C.l], a = L.op;\n        if (dd > -1.1) {\n          R += ((T[0] * 0.55 + 0.45) * light + L.body[0] - R) * a;\n          G += ((T[1] * 0.55 + 0.45) * light + L.body[1] - G) * a;\n          B += ((T[2] * 0.55 + 0.45) * light + L.body[2] - B) * a;\n        } else {\n          R += (L.body[0] + T[0] * 0.12 * light - R) * a;\n          G += (L.body[1] + T[1] * 0.12 * light - G) * a;\n          B += (L.body[2] + T[2] * 0.12 * light - B) * a;\n        }\n      }\n      rgb[o] = R;\n      rgb[o + 1] = G;\n      rgb[o + 2] = B;\n    }\n  // Stars twinkle where nothing covers them.\n  for (const [x, y, ph] of STARS) {\n    const o = 3 * (y * W + x), v = 0.22 + 0.2 * sin(S.t * 2.3 + ph);\n    if (rgb[o + 2] \u003c 0.2) {\n      rgb[o] = max(rgb[o], v);\n      rgb[o + 1] = max(rgb[o + 1], v);\n      rgb[o + 2] = max(rgb[o + 2], v * 1.1);\n    }\n  }\n  // Silhouettes: the witches, then the trees and the ground, all black.\n  mask.fill(0);\n  if (S.flight) for (let j = 0; j \u003c S.flight.n; j++) drawWitch(S, witchPlace(S, S.flight, j), S.t * 1.1 + j * 2.3);\n  for (let p = 0; p \u003c W * H; p++) {\n    const a = mask[p];\n    if (a > 0) {\n      rgb[3 * p] *= 1 - a;\n      rgb[3 * p + 1] *= 1 - a;\n      rgb[3 * p + 2] *= 1 - a;\n    }\n  }\n  // Sparks over the witches, under the trees: toxic green, flickering.\n  for (const sp of S.sparks) {\n    const x = floor(sp.x), y = floor(sp.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const v = min(1, sp.life * 1.3) * (0.6 + 0.4 * sin(S.t * 30 + sp.ph));\n    spark(rgb, x, y, v);\n    // A new spark is a small cross.\n    if (sp.life > 0.75) for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) spark(rgb, x + dx, y + dy, 0.45 * v);\n  }\n  mask.fill(0);\n  drawTrees(S);\n  for (let x = 0; x \u003c W; x++) {\n    const g = 119.5 + 2.6 * sin(x * 0.11 + 1.3) + 1.4 * sin(x * 0.31);\n    for (let y = floor(g) - 1; y \u003c H; y++) {\n      const p = y * W + x;\n      mask[p] = max(mask[p], cl(y + 0.5 - g + 0.5, 0, 1));\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const a = 1 - mask[p];\n    display.setPixel(p % W, (p / W) | 0, round(255 * min(1, rgb[o] * a)), round(255 * min(1, rgb[o + 1] * a)), round(255 * min(1, rgb[o + 2] * a)));\n  }\n}\n\nfunction spark(rgb, x, y, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = 3 * (y * W + x);\n  rgb[o] = max(rgb[o], 0.45 * v);\n  rgb[o + 1] = max(rgb[o + 1], v);\n  rgb[o + 2] = max(rgb[o + 2], 0.3 * v);\n}\n\n// Each branch is placed from its parent's end every frame, its angle swayed\n// by the wind: more at the twigs, a slow sway and a faster shiver.\nfunction drawTrees(S) {\n  const { bx, by, ex, ey, mask } = S, t = S.t, ang = new Float32Array(TREES.length);\n  for (let i = 0; i \u003c TREES.length; i++) {\n    const b = TREES[i], w = (b.depth / 6) ** 1.5;\n    const sway = w * (0.15 * sin(t * 2.1 + b.ph) + 0.05 * sin(t * 5.3 + 2 * b.ph)) + 0.04 * (b.depth / 6) * sin(t * 0.9);\n    ang[i] = (b.parent \u003c 0 ? b.a : ang[b.parent] + b.a) + sway;\n    if (b.parent \u003c 0) {\n      bx[i] = b.x;\n      by[i] = b.y;\n    } else {\n      bx[i] = ex[b.parent];\n      by[i] = ey[b.parent];\n    }\n    ex[i] = bx[i] + sin(ang[i]) * b.len;\n    ey[i] = by[i] - cos(ang[i]) * b.len;\n    const x0 = bx[i], y0 = by[i], x1 = ex[i], y1 = ey[i], R = b.r0 + 1;\n    const exx = x1 - x0, eyy = y1 - y0, L2 = exx * exx + eyy * eyy || 1;\n    for (let y = max(0, floor(min(y0, y1) - R)); y \u003c= min(H - 1, floor(max(y0, y1) + R)); y++)\n      for (let x = max(0, floor(min(x0, x1) - R)); x \u003c= min(W - 1, floor(max(x0, x1) + R)); x++) {\n        const qx = x + 0.5 - x0, qy = y + 0.5 - y0, u = cl((qx * exx + qy * eyy) / L2, 0, 1);\n        const dd = sqrt((qx - u * exx) ** 2 + (qy - u * eyy) ** 2), rr = b.r0 + (b.r1 - b.r0) * u;\n        const cov = cl(rr + 0.5 - dd, 0, 1), p = y * W + x;\n        if (cov > mask[p]) mask[p] = cov;\n      }\n  }\n}\n","cauldron":"// ===== Patternflow pattern =====\n// Title:   Cauldron\n// Family:  halloween\n// Idea:    A black iron cauldron over a small fire near the foot of the panel heaves with glowing toxic-green brew; bubbles swell and pop into flying droplets, green and purple fumes curl up the full height of the panel, and a tap drops an eyeball in with a splash that turns the brew another colour.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the witch's cauldron of Halloween decorations\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Boil=0..1, Fume=0..1\n//\n// Knob 1: Hue. Turns the brew and its fumes round the wheel together. At 0 the brew is toxic green and the fumes green and purple; at 0.5 the brew is purple and the fumes purple and lime; at 0.75 the brew is orange and the fumes orange and cyan.\n// Knob 2: Speed. Runs everything faster or slower: at 2 a fume takes about 4 seconds to climb from the brew to the top of the panel, at 0.2 about 40.\n// Knob 3: Boil. How hard it boils. At 0 about 3 bubbles a second swell to as much as 9 LEDs across before they pop, and the brew heaves up to 4 LEDs over the far lip; at 1 about 11 a second swell to 19 across, the brew heaves up to 9 LEDs and the droplets fly about four times as high.\n// Knob 4: Fume. How much fume rises: 12 puffs a second at 0, each swelling to as much as 17 LEDs across as it climbs; 36 a second at 1, each up to 28 across, when the two ribbons thicken into plumes that fill most of the panel above the pot.\n// Buttons: K1 tap drops an eyeball from the top of the panel. It lands in the brew with a splash a third of the panel high, the surface rings, and the brew turns from green to violet, then orange, then cyan, then green again.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// The pot. The mouth is an ellipse centred on (CX, RY0): the brew fills the\n// inner one, the iron lip lies between the inner and the outer one. The body\n// is the part of a wider ellipse below the lip, cut flat at its foot.\nconst CX = 32, RY0 = 89;\nconst IN_A = 23.5, IN_B = 4.5, OUT_A = 27.5, OUT_B = 6.5;\nconst BODY_CY = 100, BODY_A = 30, BODY_B = 21, FOOT = 120;\n// Brew hue at Hue 0, and the four brews a tap steps through: green, violet,\n// orange, cyan.\nconst BREW0 = 0.3, BREWS = [0, 0.46, 0.77, 0.25];\n\n// Pot pixels, worked out once: 0 none, 1-3 body from shadow to light, 4 the\n// glint, 5 lip, 6 lip highlight, 7 leg. FRONT marks the half of the lip that\n// lies in front of the brew.\nconst POT = new Uint8Array(W * H), FRONT = new Uint8Array(W * H);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const px = x + 0.5 - CX, py = y + 0.5, p = y * W + x;\n    const u = px / BODY_A, v = (py - BODY_CY) / BODY_B, r2 = u * u + v * v;\n    if (r2 \u003c= 1 && py >= RY0 && py \u003c= FOOT) {\n      // Lit from the upper left: three flat bands and a glint, so the round\n      // body reads from across a room.\n      const nz = sqrt(max(0, 1 - r2)), l = -0.62 * u - 0.38 * v + 0.55 * nz;\n      POT[p] = l > 0.8 ? 4 : l > 0.5 ? 3 : l > 0.15 ? 2 : 1;\n    }\n    // Two stubby legs, splayed out from under the body.\n    for (const s of [-1, 1]) {\n      const t = (py - 114) / 11;\n      if (t >= 0 && t \u003c= 1 && abs(px - s * (14 + 4 * t)) \u003c= 2.6 - 0.8 * t && !POT[p]) POT[p] = 7;\n    }\n    const ei = (px / IN_A) ** 2 + ((py - RY0) / IN_B) ** 2, eo = (px / OUT_A) ** 2 + ((py - RY0) / OUT_B) ** 2;\n    if (eo \u003c= 1 && ei > 1) {\n      // The lip's top face catches the light on the far side and the left.\n      POT[p] = py \u003c RY0 - 2.5 || (px \u003c -18 && py \u003c RY0 + 2) ? 6 : 5;\n      FRONT[p] = py > RY0 ? 1 : 0;\n    }\n  }\n// Iron colours for 1-7 (index 0 unused).\nconst IRON = [\n  [0, 0, 0], [0.07, 0.05, 0.1], [0.14, 0.1, 0.19], [0.25, 0.2, 0.32], [0.62, 0.58, 0.72], [0.26, 0.22, 0.32], [0.5, 0.46, 0.6], [0.12, 0.09, 0.15],\n];\n\n// Inner mouth half-depth at column x (0 outside the mouth).\nconst mouth = (x) => {\n  const u = (x - CX) / IN_A;\n  return abs(u) \u003c 1 ? IN_B * sqrt(1 - u * u) : 0;\n};\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, boil: 0, fume: 0.06,\n    t: 0, begun: false,\n    brew: 0, brewFrom: 0, brewTo: 0, brewMix: 1, brewIdx: 0,\n    bubbles: [], drops: [], puffs: [], rings: [],\n    bubbleDue: 0, puffDue: 0, vent: 0,\n    eye: null, jet: null, shock: null,\n    lift: new Float32Array(W),\n    fg: new Float32Array(W * H), fp: new Float32Array(W * H), cf: new Float32Array(6 * W * H),\n    rgb: new Float32Array(W * H * 3),\n    c: new Float32Array(9 * 3),\n  };\n}\n\n// The fumes swirl in a velocity field with no divergence, the curl of a\n// stream function made of three travelling cells, on top of a steady rise.\nfunction flow(x, y, t, out) {\n  // psi = sum a sin(kx x + p) sin(ky y + q), velocity (dpsi/dy, -dpsi/dx).\n  let vx = 0, vy = 0;\n  const M = [\n    [10, 0.16, 0.1, 0.8, 1.2, 0.0], [8, 0.22, 0.17, -1.1, 0.7, 2.0], [6, 0.1, 0.24, 0.6, -1.5, 4.0],\n  ];\n  for (const [a, kx, ky, w1, w2, ph] of M) {\n    const sx = sin(kx * x + w1 * t + ph), cx = cos(kx * x + w1 * t + ph), sy = sin(ky * y + w2 * t), cy = cos(ky * y + w2 * t);\n    vx += a * sx * cy;\n    vy -= ((a * kx) / ky) * cx * sy;\n  }\n  out[0] = vx;\n  out[1] = vy * 0.5 - 22;\n}\n\nfunction spawnBubble(S) {\n  const x = CX + (random() * 2 - 1) * (IN_A - 6), d = random();\n  const R = 3 + 2 * S.boil + random() * (1.5 + 3 * S.boil);\n  S.bubbles.push({ x, d, R, age: 0, life: 0.55 + random() * 0.6 });\n}\n\nfunction pop(S, b, y) {\n  const n = 2 + floor(b.R * 0.6);\n  const sp = 1 + S.boil;\n  for (let i = 0; i \u003c n; i++) {\n    const a = -PI / 2 + (random() * 2 - 1) * 0.9;\n    const v = (26 + random() * 30) * sqrt(sp) * (0.6 + b.R / 8);\n    S.drops.push({ x: b.x, y: y - b.R * 0.5, vx: cos(a) * v * 0.7, vy: sin(a) * v, big: random() \u003c 0.5 });\n  }\n  S.rings.push({ x: b.x, y, r: b.R, age: 0 });\n}\n\n// Two vents, one for each colour of fume, wander across the brew, so each\n// lays a ribbon that the swirl then bends and curls.\nfunction emitPuff(S, kind, x) {\n  S.puffs.push({\n    x, y: RY0 - 3, age: 0, life: 4.4 + random() * 1.4 + 1.2 * S.fume,\n    R: 4.5 + random() * 2 + 4 * S.fume, kind, brew: S.brew,\n  });\n}\n\nfunction step(S, d) {\n  S.t += d;\n  const t = S.t, boil = S.boil;\n  // The surface lift, LEDs up from the far edge of the mouth: a slow heave\n  // of the whole brew, two travelling swells, a dome in the middle that\n  // breathes, and the ring a splash leaves.\n  const amp = 2 + 3 * boil;\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5 - CX) / IN_A;\n    if (abs(u) >= 1) {\n      S.lift[x] = 0;\n      continue;\n    }\n    let L = amp * (0.55 + 0.45 * sin(1.3 * t)) * (1 - u * u) + amp * 0.5 * (sin(0.31 * x + 2.6 * t) * 0.6 + sin(0.53 * x - 3.4 * t + 1) * 0.4 + 0.6);\n    if (S.shock) {\n      const g = S.shock, a = g.age, dx = abs(x + 0.5 - g.x);\n      L += 7 * Math.exp(-1.6 * a) * cos(0.42 * dx - 9 * a) * Math.exp(-dx / 30);\n    }\n    S.lift[x] = max(0, L);\n  }\n  // Bubbles, at 3 a second at Boil 0 and 11 at 1, faster for 3 seconds\n  // after a splash.\n  const rate = (3 + 8 * boil) * (S.shock ? 1 + 2 * Math.exp(-S.shock.age) : 1);\n  S.bubbleDue += d * rate;\n  while (S.bubbleDue >= 1) (S.bubbleDue -= 1), spawnBubble(S);\n  for (let i = S.bubbles.length - 1; i >= 0; i--) {\n    const b = S.bubbles[i];\n    b.age += d;\n    if (b.age >= b.life) {\n      pop(S, b, surfY(S, b));\n      S.bubbles.splice(i, 1);\n    }\n  }\n  // Droplets fly, fall back into the mouth or off the foot of the panel.\n  for (let i = S.drops.length - 1; i >= 0; i--) {\n    const p = S.drops[i];\n    p.vy += 150 * d;\n    p.x += p.vx * d;\n    p.y += p.vy * d;\n    const xi = floor(p.x), m = xi >= 0 && xi \u003c W ? mouth(p.x) : 0;\n    const back = p.vy > 0 && m > 0 && p.y > RY0 - m - S.lift[cl(xi, 0, W - 1)] + 1.5;\n    const hit = p.vy > 0 && xi >= 0 && xi \u003c W && p.y >= 0 && p.y \u003c H && POT[floor(p.y) * W + xi] && !m;\n    if (back || hit || p.y > H + 2 || p.x \u003c -3 || p.x > W + 3) S.drops.splice(i, 1);\n  }\n  for (let i = S.rings.length - 1; i >= 0; i--) if ((S.rings[i].age += d) > 0.18) S.rings.splice(i, 1);\n  // Fumes.\n  S.puffDue += d * (12 + 24 * S.fume);\n  while (S.puffDue >= 1) {\n    S.puffDue -= 1;\n    const kind = (S.vent = 1 - S.vent);\n    emitPuff(S, kind, CX + 13 * sin(0.43 * t + kind * 2.4) + 3 * sin(1.7 * t + kind));\n  }\n  const v = [0, 0];\n  for (let i = S.puffs.length - 1; i >= 0; i--) {\n    const q = S.puffs[i];\n    q.age += d;\n    flow(q.x, q.y, t, v);\n    // Fresh fume leaves straight up and only takes the swirl as it climbs.\n    const k = cl(q.age / 0.8, 0, 1);\n    q.x += v[0] * k * d;\n    q.y += v[1] * d;\n    if (q.age > q.life || q.y \u003c -20) S.puffs.splice(i, 1);\n  }\n  // The eyeball, the jet it throws up, and the brew changing colour.\n  if (S.eye) {\n    const e = S.eye;\n    e.vy += 150 * d;\n    e.y += e.vy * d;\n    e.spin += d * 5;\n    const top = RY0 - mouth(e.x) - S.lift[floor(e.x)];\n    if (!e.in && e.y > top) {\n      e.in = true;\n      S.jet = { x: e.x, age: 0 };\n      S.shock = { x: e.x, age: 0 };\n      for (let i = 0; i \u003c 26; i++) {\n        const a = -PI / 2 + (random() * 2 - 1) * 1.1, sp = 60 + random() * 55;\n        S.drops.push({ x: e.x + (random() * 2 - 1) * 4, y: top, vx: cos(a) * sp * 0.6, vy: sin(a) * sp, big: true });\n      }\n      S.brewFrom = S.brew;\n      S.brewIdx = (S.brewIdx + 1) % BREWS.length;\n      S.brewTo = BREWS[S.brewIdx];\n      S.brewMix = 0;\n    }\n    if (e.in) e.vy = min(e.vy, 20);\n    if (e.in && e.y > top + 10) S.eye = null;\n  }\n  if (S.jet && (S.jet.age += d) > 0.7) S.jet = null;\n  if (S.shock && (S.shock.age += d) > 3) S.shock = null;\n  if (S.brewMix \u003c 1) {\n    S.brewMix = min(1, S.brewMix + d / 0.8);\n    let dh = S.brewTo - S.brewFrom;\n    dh -= Math.round(dh);\n    S.brew = S.brewFrom + dh * S.brewMix;\n  }\n}\n\n// Row of a bubble's centre: its place between the far and the near edge of\n// the brew, the far edge lifted with the surface.\nfunction surfY(S, b) {\n  const xi = cl(floor(b.x), 0, W - 1), m = mouth(b.x);\n  return RY0 - m - S.lift[xi] + (2 * m + S.lift[xi]) * (0.15 + 0.6 * b.d);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.boil = cl(k[2], 0, 1);\n  S.fume = cl(k[3], 0, 1);\n  if (!S.begun) {\n    // Start with the fume already up the panel.\n    S.begun = true;\n    for (let i = 0; i \u003c 150; i++) step(S, 1 / 30);\n  }\n  if (input.btnPressed && input.btnPressed[0] && !S.eye) S.eye = { x: CX - 6 + random() * 12, y: -6, vy: 10, spin: 0, in: false };\n  step(S, d * S.speed * 0.5);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, fg, fp, cf, c, lift } = S;\n  const bh = BREW0 + S.hue + S.brew;\n  // Palette, three entries each: brew 0, brew crest 3, brew deep 6, bubble\n  // 9, bubble rim 12, flame 15, flame core 18, droplet 21, white 24.\n  hsv(bh, 0.88, 1, c, 0);\n  hsv(bh - 0.02, 0.45, 1, c, 3);\n  hsv(bh, 0.92, 0.62, c, 6);\n  hsv(bh + 0.02, 0.55, 1, c, 9);\n  hsv(bh, 0.95, 0.5, c, 12);\n  hsv(0.04, 0.95, 1, c, 15);\n  hsv(0.13, 0.75, 1, c, 18);\n  hsv(bh, 0.6, 1, c, 21);\n  c[24] = c[25] = c[26] = 1;\n  rgb.fill(0);\n  const put = (x, y, o) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const q = (y * W + x) * 3;\n    rgb[q] = c[o];\n    rgb[q + 1] = c[o + 1];\n    rgb[q + 2] = c[o + 2];\n  };\n\n  // Fume: one field per vent, each puff a soft bump that swells and fades\n  // with age, cut into three flat levels so the fume reads as bold shapes.\n  // A puff keeps the colour of the brew it rose from, so after a splash the\n  // new colour climbs the panel under the old one.\n  fg.fill(0);\n  fp.fill(0);\n  cf.fill(0);\n  const pc = [0, 0, 0];\n  for (const q of S.puffs) {\n    const a = q.age / q.life, R = q.R * (0.45 + 0.9 * sqrt(a));\n    const w = cl(q.age / 0.5, 0, 1) * (a \u003c 0.55 ? 1 : 1 - (a - 0.55) / 0.45) * 1.25;\n    const F = q.kind ? fp : fg, o3 = q.kind ? 3 * W * H : 0;\n    hsv(BREW0 + S.hue + q.brew + (q.kind ? 0.47 : 0), q.kind ? 0.72 : 0.8, 1, pc, 0);\n    for (let y = max(0, floor(q.y - R)); y \u003c= min(H - 1, floor(q.y + R)); y++)\n      for (let x = max(0, floor(q.x - R)); x \u003c= min(W - 1, floor(q.x + R)); x++) {\n        const dx = (x + 0.5 - q.x) / R, dy = (y + 0.5 - q.y) / R, r2 = dx * dx + dy * dy;\n        if (r2 >= 1) continue;\n        const k = w * (1 - r2) * (1 - r2), p = y * W + x, i = o3 + p * 3;\n        F[p] += k;\n        cf[i] += k * pc[0];\n        cf[i + 1] += k * pc[1];\n        cf[i + 2] += k * pc[2];\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const a = fg[p], b = fp[p], top = a >= b ? a : b, i = (a >= b ? 0 : 3 * W * H) + p * 3;\n    const lv = top > 1.1 ? 0.92 : top > 0.55 ? 0.55 : top > 0.25 ? 0.3 : 0;\n    if (!lv) continue;\n    rgb[p * 3] = (cf[i] / top) * lv;\n    rgb[p * 3 + 1] = (cf[i + 1] / top) * lv;\n    rgb[p * 3 + 2] = (cf[i + 2] / top) * lv;\n  }\n\n  // Fire under the pot: tongues that flicker, red-orange round a yellow core.\n  const t = S.t;\n  for (let x = 12; x \u003c 52; x++) {\n    const e = 1 - abs(x + 0.5 - CX) / 20;\n    const h = e * (6 + 3.5 * sin(0.9 * x + 11 * t) * sin(0.37 * x - 7 * t) + 2 * sin(1.7 * x + 17 * t));\n    for (let y = H - 1; y > H - 1 - h; y--) {\n      const core = H - 1 - y \u003c h * 0.5 && e > 0.25;\n      put(x, y, core ? 18 : 15);\n    }\n  }\n\n  // The pot body and legs, the far half of the lip, with the brew's light\n  // on the top of the body and the fire's on its foot.\n  const gl = [c[0], c[1], c[2]];\n  for (let y = 80; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, m = POT[p];\n      if (!m || FRONT[p]) continue;\n      const q = p * 3, col = IRON[m];\n      let r = col[0], g = col[1], b = col[2];\n      if (m \u003c= 4 && y \u003c RY0 + 5 && m > 1) {\n        r = r * 0.6 + gl[0] * 0.25;\n        g = g * 0.6 + gl[1] * 0.25;\n        b = b * 0.6 + gl[2] * 0.25;\n      } else if (m \u003c= 2 && y > FOOT - 5) {\n        r = max(r, 0.45);\n        g = max(g, 0.16);\n      }\n      rgb[q] = r;\n      rgb[q + 1] = g;\n      rgb[q + 2] = b;\n    }\n\n  // The brew: the inner mouth, its far edge lifted by the heave.\n  for (let x = 0; x \u003c W; x++) {\n    const m = mouth(x + 0.5);\n    if (!m) continue;\n    const top = RY0 - m - lift[x], bot = RY0 + m;\n    for (let y = max(0, floor(top)); y \u003c= floor(bot); y++) {\n      const o = y - top \u003c 1.6 ? 3 : y > bot - 1.5 ? 6 : 0;\n      put(x, y, o);\n    }\n  }\n  // Bubbles: a pale dome with a dark rim and a white glint; a popped one\n  // leaves a ring for a moment.\n  for (const b of S.bubbles) {\n    const a = b.age / b.life, R = b.R * (0.35 + 0.65 * sqrt(a)), cy = surfY(S, b) - R * 0.45;\n    for (let y = floor(cy - R - 1); y \u003c= floor(cy + R + 1); y++)\n      for (let x = floor(b.x - R - 1); x \u003c= floor(b.x + R + 1); x++) {\n        const dd = sqrt((x + 0.5 - b.x) ** 2 + (y + 0.5 - cy) ** 2);\n        if (dd > R + 0.5) continue;\n        put(x, y, dd > R - 0.8 ? 12 : 9);\n      }\n    const gx = floor(b.x - R * 0.4), gy = floor(cy - R * 0.4);\n    if (R > 2.2) put(gx, gy, 24);\n  }\n  for (const g of S.rings) {\n    const R = g.r * (1 + g.age * 6);\n    for (let i = 0; i \u003c 24; i++) {\n      const a = (2 * PI * i) / 24;\n      put(floor(g.x + R * cos(a)), floor(g.y - g.r * 0.4 + R * 0.5 * sin(a)), 3);\n    }\n  }\n  // The jet a splash throws up: a column of brew that shoots up 42 LEDs and\n  // falls back in 0.7 seconds of pattern time.\n  if (S.jet) {\n    const j = S.jet, hgt = 42 * sin((PI * j.age) / 0.7), base = RY0 - mouth(j.x) - lift[floor(j.x)];\n    for (let y = floor(base - hgt); y \u003c= base; y++) {\n      const w = 2.6 + 1.6 * ((y - (base - hgt)) / max(1, hgt));\n      for (let x = floor(j.x - w); x \u003c= floor(j.x + w); x++) put(x, y, abs(x + 0.5 - j.x) \u003c w * 0.45 ? 3 : 0);\n    }\n    for (let x = floor(j.x - 3); x \u003c= floor(j.x + 3); x++)\n      for (let y = floor(base - hgt - 3); y \u003c= floor(base - hgt + 1); y++)\n        if ((x + 0.5 - j.x) ** 2 + (y + 0.5 - (base - hgt - 1)) ** 2 \u003c 9) put(x, y, 3);\n  }\n  // The near half of the lip, in front of the brew.\n  for (let y = RY0; y \u003c RY0 + OUT_B + 1; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (!FRONT[p]) continue;\n      const col = IRON[POT[p]], q = p * 3;\n      rgb[q] = col[0];\n      rgb[q + 1] = col[1];\n      rgb[q + 2] = col[2];\n    }\n  // Droplets, 2 LEDs square, the big ones 3.\n  for (const p of S.drops) {\n    const s = p.big ? 3 : 2, x0 = floor(p.x - s / 2), y0 = floor(p.y - s / 2);\n    for (let y = y0; y \u003c y0 + s; y++) for (let x = x0; x \u003c x0 + s; x++) put(x, y, 21);\n  }\n  // The eyeball: white, a violet iris that rolls as it falls, a black pupil.\n  if (S.eye) {\n    const e = S.eye, ix = e.x + 2 * cos(e.spin), iy = e.y + 2 * sin(e.spin);\n    const top = RY0 - mouth(e.x) - lift[floor(e.x)];\n    for (let y = floor(e.y - 5); y \u003c= floor(e.y + 5); y++)\n      for (let x = floor(e.x - 5); x \u003c= floor(e.x + 5); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || (e.in && y > top)) continue;\n        const d0 = (x + 0.5 - e.x) ** 2 + (y + 0.5 - e.y) ** 2;\n        if (d0 > 4.6 * 4.6) continue;\n        const di = (x + 0.5 - ix) ** 2 + (y + 0.5 - iy) ** 2, q = (y * W + x) * 3;\n        const col = di \u003c 1.1 ? [0, 0, 0] : di \u003c 5.3 ? [0.55, 0.2, 1] : [0.95, 0.93, 0.9];\n        rgb[q] = col[0];\n        rgb[q + 1] = col[1];\n        rgb[q + 2] = col[2];\n      }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, floor(min(1, rgb[q]) * 255), floor(min(1, rgb[q + 1]) * 255), floor(min(1, rgb[q + 2]) * 255));\n}\n","eyes-in-the-dark":"// ===== Patternflow pattern =====\n// Title:   Eyes in the Dark\n// Family:  halloween\n// Idea:    On a black panel sets of glowing eyes, a cat's slit-pupilled almonds, an owl's orange discs, a pair of red slits that glare and a spider's eight, open, follow a wandering will-o'-the-wisp with their pupils, blink, prowl, dash across the dark, shut and open again somewhere else.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the will-o'-the-wisp of European folklore\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Shift=0..1, Speed=0.2..3, Pairs=5..9, Jumpy=0..1\n//\n// Knob 1: Shift. Turns every colour round the wheel together. At 0 the cat's eyes are yellow-green, the owl's orange, the slits red, the spider's eight magenta and the wisp pale aqua; at 0.25 the owl turns green and the slits lime, at 0.5 the owl is blue and the cat violet. An iris edge that lands between orange and lime is paled and lifted, so it never reads brown or olive.\n// Knob 2: Speed. At 2 the wisp moves 26 LEDs a second on average and 57 at its fastest, and crosses the panel's height in about five seconds; a set of eyes stays open 2 to 4.5 seconds and is gone 0.3 to 1.2 before it opens elsewhere. At 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Pairs. How many sets of eyes, 5 to 9, and never fewer than all but two of them open at once. At 5 they are full size: a cat's eye 18 LEDs wide, an owl's 15, a slit 16, the spider's eight 23 across. Each set over 5 makes the eyes 7% smaller, to 72% at 9, so they still fit.\n// Knob 4: Jumpy. At 0.06 the eyes blink every 1 to 3 seconds, glance away from the wisp every 1.5 to 6, dash to a new spot every 3 to 8 and prowl at up to 4.5 LEDs a second; at 1 they blink every 0.3 to 0.8 seconds, glance every 0.3 to 1.2, dash every 0.9 to 2.4, prowl two and a half times as fast and their pupils catch up with what they look at in 0.04 seconds instead of 0.11. Any eye blinks when the wisp comes within 10 LEDs of it.\n// Buttons: K1 tap opens every set at once, the shut ones wherever there is room, and for 2.5 seconds they all stare at the middle of the panel without blinking before they go back to the wisp.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, sin, cos, abs, round, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst len = (x, y) => sqrt(x * x + y * y);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst rnd = (a, b) => a + (b - a) * Math.random();\n// How bright the eyes' glow on the dark is, against the eyes themselves.\nconst GLOW = 1.3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The kinds: a cat's almonds, an owl's discs, a pair of red slits that\n// glare, and a spider's eight. For each: half-size of the group's box, the\n// eye's half-width and half-height, how far each eye sits from the middle,\n// and the hues of the iris centre and edge at Shift 0.\nconst CAT = 0, OWL = 1, RED = 2, SPIDER = 3;\nconst BOX = [[21, 8], [16, 9], [18, 7], [13, 11]];\nconst EYE = [[9, 5.6, 11.6], [7.4, 7.4, 8.6], [7.8, 3.1, 10]];\nconst HUE = [[0.17, 0.27], [0.13, 0.05], [0.05, 0.99], [0.83, 0.92]];\n// The spider's eight: x, y and radius, the big front pair in the middle.\nconst SPIDER_EYES = [[-3.4, 2.4, 4], [3.4, 2.4, 4], [-9, 1.2, 2.5], [9, 1.2, 2.5], [-7.6, -6, 1.9], [-2.6, -7.8, 1.9], [2.6, -7.8, 1.9], [7.6, -6, 1.9]];\n\nexport function setup(params) {\n  params.s = {\n    shift: 0, speed: 2, pairs: 5, jumpy: 0.06,\n    clock: 0, stare: 0,\n    wx: 32, wy: 64, wvx: 0, wvy: -1, flick: 1, trail: [],\n    groups: [],\n    rgb: new Float32Array(N * 3), glow: new Float32Array(N * 3), halo: new Float32Array(N * 3), tmp: new Float32Array(N * 3), inside: new Uint8Array(N),\n    col: new Float32Array(4 * 6), warm: new Float32Array(4),\n  };\n}\n\nfunction overlaps(S, g, x, y) {\n  const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc;\n  for (const o of S.groups) {\n    if (o === g || o.state === 0) continue;\n    const w2 = w + BOX[o.type][0] * o.sc + 2, h2 = h + BOX[o.type][1] * o.sc + 3;\n    if (abs(o.x - x) \u003c w2 && abs(o.y - y) \u003c h2) return true;\n    // A set in the middle of a dash already holds where it is going.\n    if (o.dash >= 0 && abs(o.x1 - x) \u003c w2 && abs(o.y1 - y) \u003c h2) return true;\n  }\n  return false;\n}\n\n// Somewhere free on the panel, as a new kind (one spider at a time); false\n// if nowhere was found.\nfunction place(S, g) {\n  const spider = S.groups.some((o) => o !== g && o.state !== 0 && o.type === SPIDER);\n  g.type = floor(rnd(0, spider ? 3 : 4));\n  // More pairs, smaller eyes: full size at 5, 0.72 at 9.\n  g.sc = 1 - 0.07 * (S.pairs - 5);\n  const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc;\n  for (let n = 0; n \u003c 120; n++) {\n    const x = rnd(w + 1, W - 1 - w), y = rnd(h + 3, H - 3 - h);\n    if (!overlaps(S, g, x, y)) {\n      g.x = x;\n      g.y = y;\n      g.ph = rnd(0, 7);\n      const a = rnd(0, 2 * PI);\n      g.vx = cos(a) * rnd(2, 4.5);\n      g.vy = sin(a) * rnd(1, 2.5);\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction newGroup(S, open) {\n  const g = { type: CAT, x: 32, y: 64, sc: 1, vx: 0, vy: 0, ph: 0, state: 0, t: 0, dur: rnd(0.3, 1.5), o: 0, blink: rnd(0.5, 3), bt: -1, px: 0, py: 0, gx: 0, gy: 0, glance: 0, gap: rnd(1, 5), dil: 0.5, near: 0, dash: -1, dashT: rnd(0.8, 4.5), x0: 0, y0: 0, x1: 0, y1: 0 };\n  if (open && place(S, g)) (g.state = 2), (g.o = 1), (g.dur = rnd(2, 7));\n  return g;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.shift = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.pairs = round(cl(k[2], 5, 9));\n  S.jumpy = cl(k[3], 0, 1);\n  const J = S.jumpy, f = (d * S.speed) / 2;\n  S.clock += f;\n  while (S.groups.length \u003c S.pairs) S.groups.push(newGroup(S, S.groups.length \u003c S.pairs - 1));\n  // Groups past the count shut and leave when the knob comes down.\n  for (let i = S.pairs; i \u003c S.groups.length; i++) if (S.groups[i].state === 2) (S.groups[i].state = 3), (S.groups[i].t = 0);\n  S.groups = S.groups.filter((g, i) => i \u003c S.pairs || g.state !== 0);\n\n  // The wisp wanders the whole panel on two slow beats.\n  const T = S.clock * 2.5, ox = S.wx, oy = S.wy;\n  S.wx = 32 + 24 * sin(0.37 * T + 1.3 * sin(0.13 * T));\n  S.wy = 64 + 54 * sin(0.23 * T + 0.8 * sin(0.17 * T + 1));\n  if (f > 0) (S.wvx = (S.wx - ox) / f), (S.wvy = (S.wy - oy) / f);\n  S.flick = 0.82 + 0.18 * sin(T * 7.1) * sin(T * 3.3 + 1);\n  S.trail.unshift([S.wx, S.wy]);\n  if (S.trail.length > 16) S.trail.pop();\n\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.stare = 2.5;\n    for (const g of S.groups) {\n      if (g.state === 0 && !place(S, g)) continue;\n      (g.state = 2), (g.t = 0), (g.dur = rnd(2.5, 5)), (g.bt = -1);\n    }\n  }\n  S.stare = max(0, S.stare - f);\n\n  for (const g of S.groups) {\n    g.t += f;\n    // A dash slides the eyes to somewhere else on the panel in 0.7 seconds,\n    // narrowed, looking where they go. Otherwise whatever owns them prowls:\n    // it drifts a few LEDs a second and turns back from the panel's edge and\n    // from the others.\n    if (g.dash >= 0) {\n      g.dash = min(1, g.dash + f / 0.7);\n      const e = sm(0, 1, g.dash);\n      g.x = g.x0 + (g.x1 - g.x0) * e;\n      g.y = g.y0 + (g.y1 - g.y0) * e;\n      if (g.dash >= 1) (g.dash = -1), (g.dashT = rnd(2.5, 7) * (1 - 0.7 * J));\n    } else if (g.state !== 0) {\n      const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc, sp = f * (1 + 1.5 * J);\n      let nx = g.x + g.vx * sp, ny = g.y + g.vy * sp;\n      if (nx \u003c w + 1 || nx > W - 1 - w || overlaps(S, g, nx, g.y)) (g.vx = -g.vx), (nx = g.x);\n      if (ny \u003c h + 3 || ny > H - 3 - h || overlaps(S, g, nx, ny)) (g.vy = -g.vy), (ny = g.y);\n      g.x = nx;\n      g.y = ny;\n    }\n    if (g.state === 0) {\n      if (g.t > g.dur && S.groups.indexOf(g) \u003c S.pairs && place(S, g)) (g.state = 1), (g.t = 0);\n    } else if (g.state === 1) {\n      g.o = sm(0, 0.35, g.t);\n      if (g.t > 0.35) (g.state = 2), (g.t = 0), (g.dur = rnd(2, 4.5) * (1 - 0.6 * J));\n    } else if (g.state === 2) {\n      g.o = S.stare > 0 ? min(1, g.o + f * 12) : 1;\n      // It shuts when its time is up, unless that would leave fewer than\n      // all but two of the sets open.\n      if (g.t > g.dur && S.stare \u003c= 0) {\n        if (S.groups.filter((o) => o.state === 1 || o.state === 2).length > S.pairs - 2) (g.state = 3), (g.t = 0);\n        else g.dur += rnd(0.4, 1.2);\n      }\n    } else {\n      g.o = 1 - sm(0, 0.3, g.t);\n      if (g.t > 0.3) (g.state = 0), (g.t = 0), (g.o = 0), (g.dur = rnd(0.3, 1.2) * (1 - 0.5 * J));\n    }\n    // Blinks: every 1 to 3 seconds when calm, 0.3 to 0.8 when jumpy, and\n    // a flinch when the wisp comes within 10 LEDs.\n    if (g.state === 2 && S.stare \u003c= 0) {\n      g.blink -= f;\n      if (g.near > 0.7 && g.blink > 0.6) g.blink = 0;\n      if (g.blink \u003c= 0 && g.bt \u003c 0) (g.bt = 0), (g.blink = rnd(1, 3) * (1 - 0.72 * J));\n    }\n    if (g.bt >= 0) {\n      g.bt += f / (g.type === OWL ? 0.32 : 0.2);\n      if (g.bt >= 1) g.bt = -1;\n    }\n    if (g.state === 2 && g.dash \u003c 0 && g.bt \u003c 0 && S.stare \u003c= 0) {\n      g.dashT -= f;\n      if (g.dashT \u003c= 0) {\n        const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc;\n        g.dashT = 0.5;\n        for (let n = 0; n \u003c 60; n++) {\n          const x = rnd(w + 1, W - 1 - w), y = rnd(h + 3, H - 3 - h);\n          if (len(x - g.x, y - g.y) > 24 && !overlaps(S, g, x, y)) {\n            Object.assign(g, { dash: 0, x0: g.x, y0: g.y, x1: x, y1: y });\n            break;\n          }\n        }\n      }\n    }\n    // Where it looks: the wisp, the centre when staring, ahead in a dash, or\n    // a glance away.\n    g.glance -= f;\n    if (g.glance \u003c -g.gap) (g.glance = rnd(0.3, 0.8)), (g.gap = rnd(1.5, 6) * (1 - 0.8 * J)), (g.gx = rnd(0, W)), (g.gy = rnd(0, H));\n    let tx = S.wx, ty = S.wy;\n    if (S.stare > 0) (tx = 31.5), (ty = 63.5);\n    else if (g.dash >= 0) (tx = 2 * g.x1 - g.x0), (ty = 2 * g.y1 - g.y0);\n    else if (g.glance > 0) (tx = g.gx), (ty = g.gy);\n    const dx = tx - g.x, dy = ty - g.y, r = len(dx, dy) + 8, a = 1 - exp(-f * (8 + 20 * J));\n    g.px += (dx / r - g.px) * a;\n    g.py += (dy / r - g.py) * a;\n    // The wisp's light: cat pupils shut to slits near it, and every eye\n    // burns brighter.\n    const wd = len(S.wx - g.x, S.wy - g.y);\n    g.dil += (cl(wd / 40, 0, 1) - g.dil) * (1 - exp(-f * 3));\n    g.near = exp(-wd / 28);\n  }\n}\n\n// Signed distance to an almond (a lens of half-width a and half-height b)\n// in its own frame, negative inside.\nfunction almond(u, v, a, b) {\n  const au = abs(u);\n  if (au >= a) return len(au - a, v);\n  const h = b * (1 - (u * u) / (a * a)), s = (2 * b * au) / (a * a);\n  return (abs(v) - h) / sqrt(1 + s * s);\n}\n\nfunction put(S, x, y, r, g, b) {\n  const p = y * W + x, q = p * 3;\n  S.rgb[q] = r;\n  S.rgb[q + 1] = g;\n  S.rgb[q + 2] = b;\n  S.inside[p] = 1;\n}\n\n// One eye of a pair: centre (cx, cy), side -1 or 1, lids open by `open`.\nfunction eye(S, g, cx, cy, side, open, gain) {\n  const type = g.type, c = S.col, o = type * 6, a = EYE[type][0] * g.sc, b = EYE[type][1] * g.sc, z = g.sc;\n  // A cat's outer corner rises; a red eye's inner corner drops, so it glares.\n  const tilt = type === CAT ? -0.16 * side : type === RED ? 0.32 * side : 0, ct = cos(tilt), st = sin(tilt);\n  const pu = g.px * (type === OWL ? 2.6 : 3.8) * z, pv = g.py * (type === OWL ? 2.4 : 1.2) * z;\n  const bo = b * open, pw = 1.1 + 1.8 * g.dil * z;\n  for (let y = max(0, floor(cy - b - 2)); y \u003c= min(H - 1, floor(cy + b + 2)); y++)\n    for (let x = max(0, floor(cx - a - 2)); x \u003c= min(W - 1, floor(cx + a + 2)); x++) {\n      const X = x + 0.5 - cx, Y = y + 0.5 - cy, u = ct * X + st * Y, v = -st * X + ct * Y;\n      let dd, rr;\n      if (type === OWL) {\n        // Round, with lids that close from above and below.\n        rr = len(u, v);\n        dd = max(rr - a, abs(v) - bo);\n        rr /= a;\n      } else {\n        dd = almond(u, v, a, bo);\n        rr = len(u / a, v / b);\n      }\n      const cov = cl(0.5 - dd, 0, 1);\n      if (cov \u003c= 0) continue;\n      // Iris: bright at the centre, deeper at the edge.\n      const m = rr >= 1 ? 1 : rr * sqrt(rr), k = gain;\n      let R = (c[o] + (c[o + 3] - c[o]) * m) * k, G = (c[o + 1] + (c[o + 4] - c[o + 1]) * m) * k, B = (c[o + 2] + (c[o + 5] - c[o + 2]) * m) * k;\n      // Pupil: a slit for the cat, a disc for the owl, a coal for the red.\n      let p;\n      if (type === CAT) p = (len((u - pu) / pw, (v - pv) / (b * 0.92)) - 1) * pw;\n      else if (type === OWL) p = len(u - pu, v - pv) - 3.8 * z;\n      else p = len(u - pu * 0.8, v - pv) - 1.6 * z;\n      const pc = cl(0.5 - p, 0, 1) * (type === RED ? 0.75 : 1);\n      R *= 1 - pc;\n      G *= 1 - pc;\n      B *= 1 - pc;\n      // A glint, upper left of the middle.\n      if (type !== RED && len(u + 1.8 * z, v + (type === OWL ? 2.2 : 1.3) * z) \u003c 1.15) (R = 1), (G = 1), (B = 0.95);\n      put(S, x, y, R * cov, G * cov, B * cov);\n    }\n}\n\nfunction spider(S, g, open, gain) {\n  const c = S.col, o = SPIDER * 6, fl = 0.35 + 0.35 * S.warm[SPIDER];\n  for (let i = 0; i \u003c 8; i++) {\n    const [ex, ey, er0] = SPIDER_EYES[i];\n    // The eight light up one after another, the big pair first.\n    const er = er0 * g.sc * cl(open * 1.6 - i * 0.08, 0, 1);\n    if (er \u003c= 0.2) continue;\n    const cx = g.x + (ex + g.px * 1.5) * g.sc, cy = g.y + (ey + g.py * 1.5) * g.sc;\n    for (let y = max(0, floor(cy - er - 1)); y \u003c= min(H - 1, floor(cy + er + 1)); y++)\n      for (let x = max(0, floor(cx - er - 1)); x \u003c= min(W - 1, floor(cx + er + 1)); x++) {\n        const u = x + 0.5 - cx, v = y + 0.5 - cy, rr = len(u, v), cov = cl(er + 0.5 - rr, 0, 1);\n        if (cov \u003c= 0) continue;\n        // A glossy dome: dark in the middle, the rim lit, and the wisp's\n        // reflection sliding toward where it is.\n        const m = (fl + (1 - fl) * (rr / er) ** 2) * gain;\n        let R = c[o + 3] * m, G = c[o + 4] * m, B = c[o + 5] * m;\n        const hl = cl(er * 0.42 + 0.5 - len(u - g.px * er * 0.5, v - g.py * er * 0.5 + er * 0.25), 0, 1);\n        R += (1 - R) * hl;\n        G += (c[o + 1] * 0.4 + 0.6 - G) * hl;\n        B += (1 - B) * hl;\n        put(S, x, y, R * cov, G * cov, B * cov);\n      }\n  }\n}\n\n// Box blur of radius r along rows then columns, from src into dst, the\n// three colours in step.\nfunction blur(src, dst, tmp, r) {\n  const n = 1 / (2 * r + 1), st = W * 3;\n  for (let y = 0; y \u003c H; y++) {\n    const row = y * st;\n    let a = 0, b = 0, c = 0;\n    for (let x = 0; x \u003c= r; x++) (a += src[row + x * 3]), (b += src[row + x * 3 + 1]), (c += src[row + x * 3 + 2]);\n    for (let x = 0, q = row; x \u003c W; x++, q += 3) {\n      tmp[q] = a * n;\n      tmp[q + 1] = b * n;\n      tmp[q + 2] = c * n;\n      if (x >= r) (a -= src[q - r * 3]), (b -= src[q - r * 3 + 1]), (c -= src[q - r * 3 + 2]);\n      if (x + r + 1 \u003c W) (a += src[q + (r + 1) * 3]), (b += src[q + (r + 1) * 3 + 1]), (c += src[q + (r + 1) * 3 + 2]);\n    }\n  }\n  for (let x = 0; x \u003c W; x++) {\n    let a = 0, b = 0, c = 0;\n    for (let y = 0; y \u003c= r; y++) (a += tmp[y * st + x * 3]), (b += tmp[y * st + x * 3 + 1]), (c += tmp[y * st + x * 3 + 2]);\n    for (let y = 0, q = x * 3; y \u003c H; y++, q += st) {\n      dst[q] = a * n;\n      dst[q + 1] = b * n;\n      dst[q + 2] = c * n;\n      if (y >= r) (a -= tmp[q - r * st]), (b -= tmp[q - r * st + 1]), (c -= tmp[q - r * st + 2]);\n      if (y + r + 1 \u003c H) (a += tmp[q + (r + 1) * st]), (b += tmp[q + (r + 1) * st + 1]), (c += tmp[q + (r + 1) * st + 2]);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, glow, halo, tmp, inside, col } = S;\n  for (let t = 0; t \u003c 4; t++) {\n    // An edge from orange round to lime is paled and lifted, or it would\n    // read brown or olive; the spider's dark domes most of all.\n    const e = S.shift + HUE[t][1], wm = max(0, 1 - abs(e - floor(e) - 0.14) / 0.14);\n    S.warm[t] = wm;\n    hsv(S.shift + HUE[t][0], t === SPIDER ? 0.6 : 0.55, 1, col, t * 6);\n    hsv(e, 0.95 - 0.3 * wm, (t === SPIDER ? 0.8 : 0.9) + 0.1 * wm, col, t * 6 + 3);\n  }\n  rgb.fill(0);\n  inside.fill(0);\n  for (const g of S.groups) {\n    if (g.state === 0) continue;\n    // A blink closes the lids and opens them again, quicker down than up;\n    // between blinks the lids narrow and widen a little on their own.\n    const bl = g.bt >= 0 ? sin(PI * (g.bt \u003c 0.4 ? g.bt / 0.8 : 0.5 + (g.bt - 0.4) / 1.2)) : 0;\n    const open = g.o * (1 - bl) * (g.type === OWL ? 1 : 0.86 + 0.14 * sin(S.clock * 1.7 + g.ph)) * (g.dash >= 0 ? 1 - 0.45 * sin(PI * g.dash) : 1);\n    const gain = 0.62 + 0.38 * g.near;\n    if (g.type === SPIDER) spider(S, g, g.o, gain);\n    else {\n      // The head turns with the eyes: the pair slides toward where it looks.\n      const sep = EYE[g.type][2] * g.sc * (1 - 0.1 * abs(g.px)), hx = g.x + g.px * 2.5 * g.sc, hy = g.y + g.py * 1.5 * g.sc;\n      eye(S, g, hx - sep, hy, -1, open, gain);\n      eye(S, g, hx + sep, hy, 1, open, gain);\n    }\n  }\n  // The eyes' glow on the dark round them.\n  blur(rgb, halo, tmp, 3);\n  blur(halo, glow, tmp, 3);\n  // The wisp: a pale flame whose tail is where it has just been.\n  const wc = [0, 0, 0];\n  hsv(S.shift + 0.45, 0.45, 1, wc, 0);\n  const tr = S.trail;\n  let x0 = W, x1 = 0, y0 = H, y1 = 0;\n  for (const [tx, ty] of tr) (x0 = min(x0, tx)), (x1 = max(x1, tx)), (y0 = min(y0, ty)), (y1 = max(y1, ty));\n  x0 = max(0, floor(x0 - 14));\n  x1 = min(W - 1, floor(x1 + 14));\n  y0 = max(0, floor(y0 - 14));\n  y1 = min(H - 1, floor(y1 + 14));\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const q = p * 3;\n      let r = rgb[q], gg = rgb[q + 1], b = rgb[q + 2];\n      if (!inside[p]) (r = floor(glow[q] * GLOW * 40) / 40), (gg = floor(glow[q + 1] * GLOW * 40) / 40), (b = floor(glow[q + 2] * GLOW * 40) / 40);\n      if (x >= x0 && x \u003c= x1 && y >= y0 && y \u003c= y1) {\n        let wl = 0, core = 0;\n        for (let i = 0; i \u003c tr.length; i += 3) {\n          const k = 1 - i / tr.length, rad = 1.2 + 1.9 * k, dd = len(x + 0.5 - tr[i][0], y + 0.5 - tr[i][1]);\n          if (dd \u003c 13) wl += k * k * exp(-dd / (2.4 + 2.6 * k)) * (1 - dd / 13);\n          core = max(core, k * cl(rad + 0.5 - dd, 0, 1));\n        }\n        wl *= 0.5 * S.flick;\n        r += wc[0] * wl + core * (1 - r) * 0.85;\n        gg += wc[1] * wl + core * (1 - gg) * 0.85;\n        b += wc[2] * wl + core * (1 - b) * 0.85;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, gg)), round(255 * min(1, b)));\n    }\n}\n","hinged-dissection":"// ===== Patternflow pattern =====\n// Title:   Hinged Dissection\n// Family:  geometry\n// Idea:    An equilateral triangle 62 LEDs on a side, cut into Dudeney's four pieces and hinged at three points, swings open into a chain that stands the height of the panel and folds shut into a square of the same area, then swings back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dudeney's hinged dissection of the triangle into the square (Henry Dudeney, 1902), and the Wallace-Bolyai-Gerwien theorem that any two polygons of equal area cut into each other (William Wallace, 1807; Farkas Bolyai, 1832; Paul Gerwien, 1833), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hold=0..3, Gap=0..1\n//\n// Knob 1: Hue. Turns the four pieces round the wheel together. At 0 they are gold, rose, azure and mint.\n// Knob 2: Speed. At 2 one swing, triangle to square, takes 2.5 seconds; at 0.2 it takes 25 and at 3 it takes 1.7.\n// Knob 3: Hold. Seconds the triangle and the square stand still before the next swing: none at 0, so the pieces never stop, up to 3.\n// Knob 4: Gap. Pushes each piece out from the middle of the chain, an exploded view: at 0 the pieces meet along their cuts with a dark seam under 1 LED wide, at 1 each has moved 7 LEDs out.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// Dudeney's cut, on a triangle of side 2 with A bottom left, B the apex and\n// C bottom right. D and E are the midpoints of AB and BC. The square has\n// side s = 3^(1/4), the root of the triangle's area sqrt(3). J is the point\n// of AC at distance s from E, K is 1 (half a side) further along AC, and L\n// and M are the feet of the perpendiculars from D and K to the cut EJ.\n// Pieces, each listed clockwise: ADLJ, DBEL, ECKM and the triangle JMK,\n// hinged at D, E and K.\nconst S3 = sqrt(3), SQ = 3 ** 0.25;\nconst A = [0, 0], B = [1, S3], C = [2, 0], D = [0.5, S3 / 2], E = [1.5, S3 / 2];\nconst J = [1.5 - sqrt(SQ * SQ - 0.75), 0], K = [J[0] + 1, 0];\nconst U = [(J[0] - E[0]) / SQ, (J[1] - E[1]) / SQ];\nconst foot = (p) => {\n  const t = (p[0] - E[0]) * U[0] + (p[1] - E[1]) * U[1];\n  return [E[0] + t * U[0], E[1] + t * U[1]];\n};\nconst L = foot(D), M = foot(K);\nconst PIECES = [[A, D, L, J], [D, B, E, L], [E, C, K, M], [J, M, K]];\n// Which corner of each piece is a hinge, as [piece, corner] pairs per hinge.\nconst HINGES = [[[0, 1], [1, 0]], [[1, 2], [2, 0]], [[2, 2], [3, 2]]];\nconst AREA = PIECES.map((p) => {\n  let a = 0;\n  for (let i = 0; i \u003c p.length; i++) a += p[i][0] * p[(i + 1) % p.length][1] - p[(i + 1) % p.length][0] * p[i][1];\n  return abs(a) / 2;\n});\n\n// LEDs per unit: the triangle is 62 LEDs on a side, the square 40.8.\nconst SC = 31;\n// Base hues: gold, rose, azure, mint.\nconst HUES = [0.13, 0.95, 0.58, 0.4];\n\n// Swing f runs 0 (triangle) to 1 (square). Every hinge turns the same way\n// by pi f, so piece n has turned n pi f: a search over the swing found no\n// overlap this way, where turning any hinge the other way overlaps.\n// The whole chain is turned by G(f) degrees as well: 0 at the triangle,\n// -41.15 at the square, which is the angle that sets the square upright,\n// and between them a sum of three sines fitted so the open chain stands\n// along the panel and never hangs more than 4 LEDs over either side.\nconst G = (f) => (PI / 180) * (-41.1503 * f + 34 * sin(PI * f) + 57 * sin(2 * PI * f) + 34 * sin(3 * PI * f));\n\nfunction rotAbout(p, c, a, out) {\n  const x = p[0] - c[0], y = p[1] - c[1], cs = cos(a), sn = sin(a);\n  out[0] = c[0] + cs * x - sn * y;\n  out[1] = c[1] + sn * x + cs * y;\n}\n\n// The four pieces at swing f, in triangle units.\nfunction pose(f, out) {\n  const t = PI * f, q = [0, 0];\n  for (let n = 0; n \u003c 4; n++) {\n    const src = PIECES[n], dst = out[n];\n    for (let i = 0; i \u003c src.length; i++) {\n      let p = src[i];\n      // Turn about the hinges from the far end of the chain inward: K, E, D.\n      if (n >= 3) (rotAbout(p, K, t, q), (p = [q[0], q[1]]));\n      if (n >= 2) (rotAbout(p, E, t, q), (p = [q[0], q[1]]));\n      if (n >= 1) (rotAbout(p, D, t, q), (p = [q[0], q[1]]));\n      dst[i][0] = p[0];\n      dst[i][1] = p[1];\n    }\n  }\n}\n\nfunction centroid(p) {\n  let a = 0, x = 0, y = 0;\n  for (let i = 0; i \u003c p.length; i++) {\n    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % p.length], c = x0 * y1 - x1 * y0;\n    a += c;\n    x += (x0 + x1) * c;\n    y += (y0 + y1) * c;\n  }\n  return [x / (3 * a), y / (3 * a)];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, hold: 0, gap: 0.06,\n    tau: 0, dir: 1, wait: 0, begun: false,\n    world: PIECES.map((p) => p.map(() => [0, 0])),\n    scr: PIECES.map((p) => p.map(() => [0, 0])),\n    col: new Float32Array(4 * 6), colHue: NaN,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.hold = cl(k[2], 0, 3);\n  S.gap = cl(k[3], 0, 1);\n  // The triangle stands for one hold before the first swing too.\n  if (!S.begun) (S.begun = true), (S.wait = S.hold);\n  if (S.wait > 0) {\n    S.wait = min(S.wait, S.hold) - d;\n    return;\n  }\n  S.tau += (S.dir * d * S.speed) / 5;\n  if (S.tau >= 1) (S.tau = 1), (S.dir = -1), (S.wait = S.hold);\n  else if (S.tau \u003c= 0) (S.tau = 0), (S.dir = 1), (S.wait = S.hold);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { world, scr, col } = S;\n  if (S.colHue !== S.hue) {\n    for (let n = 0; n \u003c 4; n++) {\n      hsv(S.hue + HUES[n], 0.8, 0.9, col, n * 6);\n      hsv(S.hue + HUES[n], 0.42, 1, col, n * 6 + 3);\n    }\n    S.colHue = S.hue;\n  }\n  const t = S.tau, f = t * t * (3 - 2 * t);\n  pose(f, world);\n  // Turn the chain about its centre of area, then centre its bounding box.\n  let ax = 0, ay = 0, at = 0;\n  const cent = world.map(centroid);\n  for (let n = 0; n \u003c 4; n++) (ax += AREA[n] * cent[n][0]), (ay += AREA[n] * cent[n][1]), (at += AREA[n]);\n  (ax /= at), (ay /= at);\n  const g = G(f), cg = cos(g), sg = sin(g);\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let n = 0; n \u003c 4; n++)\n    for (let i = 0; i \u003c world[n].length; i++) {\n      const x = world[n][i][0] - ax, y = world[n][i][1] - ay, X = cg * x - sg * y, Y = sg * x + cg * y;\n      scr[n][i][0] = X;\n      scr[n][i][1] = Y;\n      (x0 = min(x0, X)), (x1 = max(x1, X)), (y0 = min(y0, Y)), (y1 = max(y1, Y));\n    }\n  const mx = (x0 + x1) / 2, my = (y0 + y1) / 2;\n  // To LEDs, y down. The gap pushes each piece out along the line from the\n  // chain's centre to its own.\n  const gapL = 7 * S.gap;\n  const polys = [];\n  for (let n = 0; n \u003c 4; n++) {\n    let cx = 0, cy = 0;\n    for (const p of scr[n]) (cx += p[0]), (cy += p[1]);\n    (cx /= scr[n].length), (cy /= scr[n].length);\n    const r = hypot(cx, cy) || 1, ox = (gapL * cx) / r, oy = (gapL * cy) / r;\n    const pts = scr[n].map((p) => [W / 2 + (p[0] - mx) * SC + ox, H / 2 - (p[1] - my) * SC - oy]);\n    // Edges as half-planes, n.p \u003c= c inside, with n turned outward by the\n    // sign of the piece's area as it now lies.\n    let sa = 0;\n    for (let i = 0; i \u003c pts.length; i++) sa += pts[i][0] * pts[(i + 1) % pts.length][1] - pts[(i + 1) % pts.length][0] * pts[i][1];\n    const sgn = sa > 0 ? 1 : -1, edges = [];\n    let bx0 = 1e9, bx1 = -1e9, by0 = 1e9, by1 = -1e9;\n    for (let i = 0; i \u003c pts.length; i++) {\n      const [px, py] = pts[i], [qx, qy] = pts[(i + 1) % pts.length], len = hypot(qx - px, qy - py);\n      const nx = (sgn * (qy - py)) / len, ny = (-sgn * (qx - px)) / len;\n      edges.push(nx, ny, nx * px + ny * py);\n      (bx0 = min(bx0, px)), (bx1 = max(bx1, px)), (by0 = min(by0, py)), (by1 = max(by1, py));\n    }\n    polys.push({ edges, pts, bx0, bx1, by0, by1 });\n  }\n  // Signed distance to a convex piece: the largest of its edge distances.\n  // Inside by more than 0.35 LED is lit, so pieces that touch keep a dark\n  // seam; the outer 1.1 LED of a piece is its rim.\n  const sd = (e, x, y) => {\n    let m = -1e9;\n    for (let i = 0; i \u003c e.length; i += 3) m = max(m, e[i] * x + e[i + 1] * y - e[i + 2]);\n    return m;\n  };\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let r = 0, gg = 0, b = 0;\n      for (let n = 0; n \u003c 4; n++) {\n        const P = polys[n];\n        if (px \u003c P.bx0 || px > P.bx1 || py \u003c P.by0 || py > P.by1) continue;\n        const dd = sd(P.edges, px, py);\n        if (dd > -0.35) continue;\n        const o = n * 6 + (dd > -1.45 ? 3 : 0);\n        (r = col[o]), (gg = col[o + 1]), (b = col[o + 2]);\n      }\n      display.setPixel(x, y, floor(r * 255), floor(gg * 255), floor(b * 255));\n    }\n  // The hinges: a white pin on each piece's own copy of the hinge point.\n  for (const pair of HINGES)\n    for (const [n, i] of pair) {\n      const [hx, hy] = polys[n].pts[i];\n      for (let y = floor(hy - 2); y \u003c= floor(hy + 2); y++)\n        for (let x = floor(hx - 2); x \u003c= floor(hx + 2); x++) {\n          if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n          if (hypot(x + 0.5 - hx, y + 0.5 - hy) \u003c 1.6) display.setPixel(x, y, 255, 255, 255);\n        }\n    }\n}\n","jack-o-lantern":"// ===== Patternflow pattern =====\n// Title:   Jack-o'-Lantern\n// Family:  halloween\n// Idea:    A carved pumpkin sits at the foot of the panel lit by a candle inside, its eyes, nose and grin pulsing from deep orange to white-hot as the flame flickers, and from every opening a shaft of light climbs the panel and swings with the flame, a violet haze in clear air that turns orange where it crosses the drifting purple fog banks.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the carved turnip and pumpkin lanterns of Halloween\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Fire=0..1, Speed=0.2..3, Face=0..3, Fog=-1..1\n//\n// Knob 1: Fire. The colour of the candle, and so of the carving and the shafts. At 0 an orange flame in purple mist; at 0.33 toxic green in purple; at 0.67 violet in green mist; at 1 a blue flame in purple. The pumpkin itself stays orange.\n// Knob 2: Speed. Runs the flame, its sway and the mist together. At 2 the flame pulses on beats of 1.4, 3.4 and 7.2 a second under a wandering dip, the candle sways up to 3 LEDs either way and swings the eye shafts about 5 degrees, and the fog banks sink 1.6 LEDs a second while their ripples drift left at about 6; at 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Face. Four carvings. 0: triangle eyes and nose and a grin with three teeth. 1: slanted angry eyes and a jagged mouth whose teeth interlock. 2: round eyes with the pupils left standing, so each eye's shaft carries a dark core up the panel, and an open O. 3: crescent eyes and a grin crossed by stitches, each gap throwing its own thin shaft down to the ground fog.\n// Knob 4: Fog. At -1 the air is clear and the shafts show only as violet haze, about 108 to 126 LEDs long. At 0.06, the opening, fog banks about 20 rows apart drift across, turning orange where a shaft crosses them, and the shafts reach about 81 to 94 LEDs, their ends ragged with the mist. At 1 the fog fills most of the panel and the shafts reach about 57 to 66.\n// Buttons: K1 tap snuffs the candle: for 0.8 seconds it gutters and the shafts draw back into the pumpkin, then it is out for 1.2 seconds with the carving an ember red, then it flares white and burns again by 2.5 seconds.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, hypot, sqrt, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hash(i, j) {\n  let h = Math.imul(i, 374761393) ^ Math.imul(j, 668265263);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nfunction vnoise(x, y) {\n  const i = floor(x), j = floor(y), fx = x - i, fy = y - j;\n  const u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);\n  const a = hash(i, j), b = hash(i + 1, j), c = hash(i, j + 1), d = hash(i + 1, j + 1);\n  return a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v;\n}\n\n// The pumpkin, centred at PX, PY: five lobes, [x offset, half-width,\n// half-height], the front one first so it shades the LEDs it holds.\nconst PX = 32, PY = 100;\nconst LOBES = [\n  [0, 13, 22],\n  [-10, 13, 21],\n  [10, 13, 21],\n  [-18, 10, 18],\n  [18, 10, 18],\n];\n// The candle, from the pumpkin's centre: between the nose and the grin.\nconst CX = 0, CY = 4.5;\n\nfunction inTri(px, py, t) {\n  const [[ax, ay], [bx, by], [cx, cy]] = t;\n  const d1 = (px - bx) * (ay - by) - (ax - bx) * (py - by);\n  const d2 = (px - cx) * (by - cy) - (bx - cx) * (py - cy);\n  const d3 = (px - ax) * (cy - ay) - (cx - ax) * (py - ay);\n  return !((d1 \u003c 0 || d2 \u003c 0 || d3 \u003c 0) && (d1 > 0 || d2 > 0 || d3 > 0));\n}\nconst tri = (x) => abs(x - 6 * floor(x / 6) - 3);\n\n// The four carvings, in pumpkin coordinates (x right, y down from the\n// centre): 1 where the knife went through.\nconst FACES = [\n  // Triangle eyes, triangle nose, a grin with two teeth above and one below.\n  (x, y) => {\n    if (inTri(x, y, [[-17, -4], [-5, -4], [-11, -15]]) || inTri(x, y, [[17, -4], [5, -4], [11, -15]])) return 1;\n    if (inTri(x, y, [[-3.5, 3], [3.5, 3], [0, -3]])) return 1;\n    const u = x / 20;\n    if (abs(u) >= 1) return 0;\n    const top = 6 + 4 * (1 - u * u), bot = 6 + 12 * (1 - u * u);\n    if (y \u003c= top || y >= bot) return 0;\n    if (((x > -10 && x \u003c -5) || (x > 5 && x \u003c 10)) && y \u003c top + 4) return 0;\n    return x > -2.5 && x \u003c 2.5 && y > bot - 4 ? 0 : 1;\n  },\n  // Slanted angry eyes and a jagged mouth whose teeth interlock.\n  (x, y) => {\n    if (inTri(x, y, [[-18, -13], [-4, -6], [-13, -2]]) || inTri(x, y, [[18, -13], [4, -6], [13, -2]])) return 1;\n    if (inTri(x, y, [[-3, 3], [3, 3], [0, -2]])) return 1;\n    if (abs(x) > 19) return 0;\n    const bend = 0.012 * x * x;\n    return y > 7 + tri(x + 19) - bend && y \u003c 16 - tri(x + 22) - bend ? 1 : 0;\n  },\n  // Round eyes with the pupils left standing, and an open O.\n  (x, y) => {\n    for (const s of [-1, 1]) {\n      const d = hypot(x - s * 10, y + 7);\n      if (d \u003c 6) return d > 2.4 ? 1 : 0;\n    }\n    if (inTri(x, y, [[-2.5, 3], [2.5, 3], [0, -1]])) return 1;\n    return hypot(x / 7.5, (y - 11) / 6.5) \u003c 1 ? 1 : 0;\n  },\n  // Crescent eyes and a wide grin crossed by stitches.\n  (x, y) => {\n    for (const s of [-1, 1]) {\n      const ex = x - s * 10, ey = y + 6;\n      if (hypot(ex, ey) \u003c 6.5 && hypot(ex, ey + 4) > 6) return 1;\n    }\n    const u = x / 22;\n    if (abs(u) >= 1) return 0;\n    const top = 3 + 8 * (1 - u * u), bot = top + 5 + 2 * (1 - u * u);\n    return y > top && y \u003c bot && abs(x + 30 - 5 * floor((x + 30) / 5) - 2.5) \u003c 1.4 ? 1 : 0;\n  },\n];\n\n// Fire colours along K1: flame, white-hot core, mist.\nconst FIRES = [\n  [[1, 0.48, 0.03], [1, 0.93, 0.55], [0.42, 0.1, 0.66]],\n  [[0.42, 1, 0.06], [0.88, 1, 0.6], [0.42, 0.1, 0.66]],\n  [[0.68, 0.2, 1], [0.96, 0.82, 1], [0.08, 0.5, 0.2]],\n  [[0.2, 0.55, 1], [0.82, 0.96, 1], [0.4, 0.1, 0.62]],\n];\n\nexport function setup(params) {\n  const body = new Float32Array(N), holes = FACES.map(() => new Uint8Array(N)), stem = new Uint8Array(N);\n  // The stem: a thick green curve leaning right from the top of the pumpkin.\n  const curve = [];\n  for (let i = 0; i \u003c= 24; i++) {\n    const t = i / 24;\n    curve.push([mix(mix(-1, -1.5, t), mix(-1.5, 5, t), t), mix(mix(-19, -26, t), mix(-26, -29, t), t), 2.4 - 0.8 * t]);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5 - PX, py = y + 0.5 - PY, p = y * W + x;\n      for (const [lx, rx, ry] of LOBES) {\n        const rho = hypot((px - lx) / rx, py / ry);\n        if (rho \u003c 1) {\n          body[p] = sqrt(1 - rho * rho);\n          break;\n        }\n      }\n      if (body[p] > 0) FACES.forEach((f, i) => (holes[i][p] = f(px, py)));\n      else for (const [sx, sy, sr] of curve) if (hypot(px - sx, py - sy) \u003c sr) stem[p] = 1;\n    }\n  // Each hole LED's distance to the flesh, for the glowing cut rim.\n  const edges = holes.map((h) => {\n    const e = new Float32Array(N);\n    for (let p = 0; p \u003c N; p++) {\n      if (!h[p]) continue;\n      const x = p % W, y = floor(p / W);\n      let best = 9;\n      for (let j = -3; j \u003c= 3; j++)\n        for (let i = -3; i \u003c= 3; i++) if (!h[(y + j) * W + x + i]) best = min(best, hypot(i, j));\n      e[p] = best;\n    }\n    return e;\n  });\n  // The openings of each carving, by flood fill. Slivers at the tapering\n  // ends of a grin, under 10 LEDs, throw no shaft of their own.\n  const openings = holes.map((h) => {\n    const seen = new Uint8Array(N), out = [];\n    for (let p0 = 0; p0 \u003c N; p0++) {\n      if (!h[p0] || seen[p0]) continue;\n      const px = [], stack = [p0];\n      seen[p0] = 1;\n      while (stack.length) {\n        const p = stack.pop(), x = p % W;\n        px.push(p);\n        for (const q of [x \u003c W - 1 ? p + 1 : -1, x > 0 ? p - 1 : -1, p + W, p - W]) if (q >= 0 && q \u003c N && h[q] && !seen[q]) (seen[q] = 1), stack.push(q);\n      }\n      if (px.length \u003c 10) continue;\n      let sx = 0, sy = 0;\n      for (const p of px) (sx += (p % W) + 0.5), (sy += floor(p / W) + 0.5);\n      out.push({ px, x: sx / px.length, y: sy / px.length, ux: 0, uy: 1, mask: new Uint8Array(NB), end: new Float32Array(NB) });\n    }\n    return out;\n  });\n  params.s = {\n    fire: 0, speed: 2, face: 0, fog: 0.06, t: 0, pulse: 0.5, sway: 0, bob: 0, light: 1, gut: -1,\n    body, holes, edges, openings, stem, grid: new Float32Array(17 * 33), pal: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n}\n\n// The candle out, then back: seconds from the tap.\nconst DIE = 0.8, DARK = 2, LIGHT = 2.5;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.fire = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.face = round(cl(k[2], 0, 3));\n  S.fog = cl(k[3], -1, 1);\n  S.t += d * S.speed;\n  // The flame: a slow breath, a quick shiver and a wandering dip, 0..1.\n  const t = S.t * 2.5;\n  S.pulse = cl(0.55 + 0.2 * sin(t * 1.7) + 0.12 * sin(t * 4.3 + 1) + 0.1 * sin(t * 9.1 + 2) + 0.7 * (vnoise(t * 2.6, 3.7) - 0.5), 0, 1);\n  S.sway = 3 * (vnoise(S.t * 1.1, 9.1) - 0.5) * 2;\n  S.bob = vnoise(S.t * 2.3, 1.3) - 0.5;\n  if (input.btnPressed && input.btnPressed[0] && S.gut \u003c 0) S.gut = 0;\n  if (S.gut >= 0) {\n    S.gut += d;\n    const g = S.gut;\n    // Gutters: shrinking with big shudders; out; then a flare and back.\n    if (g \u003c DIE) S.light = (1 - g / DIE) * (0.6 + 0.4 * vnoise(g * 14, 2.2));\n    else if (g \u003c DARK) S.light = 0;\n    else if (g \u003c LIGHT) S.light = 1.25 * sm(DARK, DARK + 0.12, g) - 0.25 * sm(DARK + 0.12, LIGHT, g);\n    else (S.light = 1), (S.gut = -1);\n  }\n}\n\n// Each opening throws its own shaft: the opening pushed outward along the\n// line from the candle through its middle, that line squeezed sideways to\n// 0.42 so the shafts climb the tall panel instead of leaving by its sides,\n// and widening by 0.6% a LED. The profile across a shaft is the opening's\n// own, teeth and pupils and all.\nconst SQUEEZE = 0.42, SPREAD = 0.006, BIN = 2, NB = 120;\nfunction aim(S, cx, cy) {\n  const list = S.openings[S.face];\n  for (const c of list) {\n    let ux = (c.x - cx) * SQUEEZE, uy = c.y - cy;\n    const l = hypot(ux, uy) || 1;\n    (ux /= l), (uy /= l), (c.ux = ux), (c.uy = uy);\n    c.mask.fill(0);\n    c.end.fill(-1e9);\n    for (const p of c.px) {\n      const dx = (p % W) + 0.5 - c.x, dy = floor(p / W) + 0.5 - c.y, sv = dx * ux + dy * uy, vv = dy * ux - dx * uy;\n      for (let b = floor((vv - 0.5) * BIN + NB / 2); b \u003c= floor((vv + 0.5) * BIN + NB / 2); b++) {\n        if (b \u003c 0 || b >= NB) continue;\n        c.mask[b] = 1;\n        c.end[b] = max(c.end[b], sv);\n      }\n    }\n  }\n  return list;\n}\n\nfunction palette(S) {\n  const u = S.fire * 3, i = min(2, floor(u)), t = u - i;\n  for (let c = 0; c \u003c 3; c++) for (let ch = 0; ch \u003c 3; ch++) S.pal[c][ch] = mix(FIRES[i][c][ch], FIRES[i + 1][c][ch], t);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const { body, stem, grid: G } = S, hole = S.holes[S.face], edge = S.edges[S.face];\n  const [flame, hot, mist] = S.pal, P = S.pulse, L = S.light;\n  const list = aim(S, PX + CX + S.sway, PY + CY + S.bob);\n  // Fog: how much of the dark the mist takes, and how far the shafts reach,\n  // which breathes with the flame and shrinks to nothing as it gutters.\n  const fogD = 0.37 + 0.3 * S.fog, reach = (96 - 30 * S.fog) * (0.86 + 0.14 * P) * min(1, L);\n  // The mist, on a grid 4 LEDs a cell read back bilinearly: banks every 20\n  // rows, sinking slowly and rippled by a noise drifting left, broken by a\n  // finer noise drifting right and up, thicker on the ground where the\n  // grin's shaft lands, and cut at two levels.\n  const mt = S.t;\n  for (let j = 0; j \u003c 33; j++)\n    for (let i = 0; i \u003c 17; i++)\n      G[j * 17 + i] = 0.5 + 0.28 * sin(TAU * (j / 5 - mt * 0.04) + 3 * (vnoise(i / 8 + mt * 0.09, j / 4) - 0.5)) + 0.3 * (vnoise(i / 4 - mt * 0.16, j / 1.5 + 0.3 * mt) - 0.5) + 0.2 * sm(28, 32, j);\n  // The openings: white-hot inside, flame-coloured at the cut rim; as the\n  // candle dies they sink to an ember red.\n  const ember = [0.45, 0.04, 0.02], lit = min(1, L), flare = max(0, L - 1) * 4;\n  const holeCol = (rim, ch) => mix(ember[ch], mix(rim ? flame[ch] : mix(flame[ch], hot[ch], 0.45 + 0.55 * P), 1, flare) * (0.82 + 0.18 * P), lit);\n  const inner = [holeCol(false, 0), holeCol(false, 1), holeCol(false, 2)], rim = [holeCol(true, 0), holeCol(true, 1), holeCol(true, 2)];\n  // Lit mist: the flame colour a little toward white-hot when the flame peaks.\n  const beam = [0, 1, 2].map((ch) => mix(flame[ch], hot[ch], 0.3 * P) * (0.84 + 0.16 * P));\n  const glow = mix(0.45, 0.74 + 0.26 * P, lit);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r = 0, g = 0, b = 0;\n      if (body[p] > 0) {\n        if (hole[p]) {\n          const c = edge[p] \u003c 1.6 ? rim : inner;\n          (r = c[0]), (g = c[1]), (b = c[2]);\n        } else {\n          // Two tones a lobe and a dark seam between lobes, warmed by the candle.\n          const v = (body[p] > 0.6 ? 0.74 : body[p] > 0.4 ? 0.52 : 0) * glow;\n          (r = v), (g = 0.36 * v * v), (b = 0.02 * v);\n        }\n      } else if (stem[p]) {\n        (r = 0.32), (g = 0.86), (b = 0.12);\n      } else {\n        const gx = x / 4, gy = y / 4, i = floor(gx), j = floor(gy), u = gx - i, v = gy - j, q = j * 17 + i;\n        const n = (G[q] * (1 - u) + G[q + 1] * u) * (1 - v) + (G[q + 17] * (1 - u) + G[q + 18] * u) * v;\n        const m = n > 1.12 - fogD ? 2 : n > 1 - fogD ? 1 : 0;\n        // Inside a shaft? Its end is ragged with the mist.\n        let inside = false;\n        const far = reach * (0.75 + 0.5 * n);\n        for (const c of list) {\n          const dx = x + 0.5 - c.x, dy = y + 0.5 - c.y, sv = dx * c.ux + dy * c.uy;\n          if (sv \u003c= 0) continue;\n          const bn = floor(((dy * c.ux - dx * c.uy) / (1 + SPREAD * sv)) * BIN + NB / 2);\n          if (bn >= 0 && bn \u003c NB && c.mask[bn] && sv > c.end[bn] && sv \u003c c.end[bn] + far) {\n            inside = true;\n            break;\n          }\n        }\n        // Lit mist takes the flame's colour; a shaft through clear air shows\n        // as a faint violet haze between the banks.\n        if (inside && m) {\n          const lv = m === 2 ? 1 : 0.8;\n          (r = beam[0] * lv), (g = beam[1] * lv), (b = beam[2] * lv);\n        } else if (inside) {\n          (r = mist[0] * 0.3 + beam[0] * 0.12), (g = mist[1] * 0.3 + beam[1] * 0.12), (b = mist[2] * 0.3 + beam[2] * 0.12);\n        } else if (m) {\n          const lv = m === 2 ? 0.44 : 0.26;\n          (r = mist[0] * lv), (g = mist[1] * lv), (b = mist[2] * lv);\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","polytope-slices":"// ===== Patternflow pattern =====\n// Title:   Polytope Slices\n// Family:  space\n// Idea:    A regular four-dimensional polytope passes down through three parallel 3D hyperplanes stacked up the panel while it tilts slowly in 4D, and each cut is drawn as a flat-shaded solid turning in space that swells from a point or a whole cell into a polyhedron, changes shape each time its hyperplane crosses a layer of vertices and shrinks away, every face coloured by the 4D cell it lies in.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the regular convex 4-polytopes (Ludwig Schläfli, 1852), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Polytope=0..3, Tilt=-1..1\n//\n// Knob 1: Hue. Turns the cell colours round the wheel together. At 0 the 24-cell's three families of cells, three 16-cells' worth that never share a face, are teal, violet and rose; the tesseract and the 16-cell add azure and the 5-cell plum. A face that comes round to orange, yellow or lime is paled and lit higher, so it never reads brown or olive.\n// Knob 2: Speed. At 2 a pass takes 7 seconds, from the top slice's first point to the bottom slice's last, and a pass spends most of it near the polytope's middle and crosses its outer fifth fast; at 0.2 it takes 70 seconds, at 3 under 5. The slices turn round the vertical once in 12.6 seconds at 2, and the 4D wander keeps the same pace.\n// Knob 3: Polytope. 0 the 24-cell (24 octahedra, its slices up to 18 faces), 1 the tesseract (8 cubes, up to 8), 2 the 16-cell (16 tetrahedra, up to 14), 3 the 5-cell (5 tetrahedra, up to 5). Each is scaled so its circumradius is 29 LEDs, and a slice through the middle can fill the panel's width.\n// Knob 4: Tilt. Swings the hyperplanes' normal from the centre of one cell (-1) to a vertex of that cell (+1), 45 degrees for the 24-cell, 60 for the tesseract and the 16-cell, 75.5 for the 5-cell. At -1 nothing turns in 4D: the 24-cell comes in as a whole octahedron, is a truncated octahedron all the way down and a cuboctahedron at its middle, and the tesseract is one cube that appears and vanishes whole. At +1 the tesseract grows from a point as a tetrahedron, is truncated from half its reach on and is an octahedron at the middle, and the 24-cell grows as a cube, chamfers and is a rhombic dodecahedron at the middle. Between the ends the normal wanders up to 0.3 radians toward the vertex and 0.9 round it, most at 0, so the polytope turns slowly in 4D and no two passes are alike.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, round, acos, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst dot4 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A polytope is its facets, one per 3D cell (unit normal n and offset d, the\n// cell lying in n.x = d and the polytope in n.x \u003c= d), a colour class per\n// cell chosen so two cells that share a 2-face never share a class, and its\n// vertices. It is turned once so that the centre of one cell lies on the\n// fourth axis and a vertex of that same cell in the plane of the first and\n// fourth axes, alpha away: Tilt swings the hyperplanes' normal through that\n// angle, from the cell to the vertex.\nfunction build(normals, d, cls, verts, cellAxis, vertexAxis) {\n  const unit = (x) => {\n    const l = hypot(x[0], x[1], x[2], x[3]);\n    return x.map((t) => t / l);\n  };\n  const g4 = unit(cellAxis), vv = unit(vertexAxis), c = dot4(vv, g4);\n  const G = [unit(vv.map((t, i) => t - c * g4[i])), g4];\n  for (const e of [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) {\n    if (G.length === 4) break;\n    let w = e.slice();\n    for (const g of G) {\n      const p = dot4(w, g);\n      w = w.map((t, i) => t - p * g[i]);\n    }\n    if (hypot(w[0], w[1], w[2], w[3]) > 1e-6) G.push(unit(w));\n  }\n  const B = [G[0], G[2], G[3], G[1]], to = (x) => B.map((b) => dot4(b, x));\n  // The edges: pairs of vertices at the shortest distance.\n  const dist = (a, b) => hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]);\n  let shortest = 1e9;\n  for (let i = 0; i \u003c verts.length; i++) for (let j = i + 1; j \u003c verts.length; j++) shortest = min(shortest, dist(verts[i], verts[j]));\n  const edges = [];\n  for (let i = 0; i \u003c verts.length; i++) for (let j = i + 1; j \u003c verts.length; j++) if (dist(verts[i], verts[j]) \u003c shortest + 1e-9) edges.push(i, j);\n  return {\n    n: normals.map(to).flat(), d, cls, v: verts.map(to).flat(), k: normals.length, edges,\n    R: hypot(verts[0][0], verts[0][1], verts[0][2], verts[0][3]), alpha: acos(c),\n  };\n}\nconst sgn = (m, i) => ((m >> i) & 1 ? -1 : 1);\nconst pop = (m) => (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1);\nconst axes = () => {\n  const out = [];\n  for (let i = 0; i \u003c 4; i++)\n    for (const s of [1, -1]) {\n      const e = [0, 0, 0, 0];\n      e[i] = s;\n      out.push([e, i]);\n    }\n  return out;\n};\nconst halves = () => Array.from({ length: 16 }, (_, m) => [[0, 1, 2, 3].map((i) => sgn(m, i) / 2), pop(m)]);\n\n// The 24-cell: 24 octahedra, 24 vertices (+-1, +-1, 0, 0). Its cells fall\n// into three 16-cells' worth, and cells in the same one never touch.\nfunction cell24() {\n  const f = [...axes().map(([e]) => [e, 0]), ...halves().map(([e, p]) => [e, 1 + (p & 1)])], v = [];\n  for (let i = 0; i \u003c 4; i++)\n    for (let j = i + 1; j \u003c 4; j++)\n      for (let m = 0; m \u003c 4; m++) {\n        const e = [0, 0, 0, 0];\n        e[i] = sgn(m, 0);\n        e[j] = sgn(m, 1);\n        v.push(e);\n      }\n  return build(f.map((x) => x[0]), f.map(() => 1), f.map((x) => x[1]), v, [0, 0, 0, 1], [1, 0, 0, 1]);\n}\n// The tesseract: 8 cubes, opposite ones share a colour.\nfunction tesseract() {\n  const f = axes();\n  const v = Array.from({ length: 16 }, (_, m) => [0, 1, 2, 3].map((i) => sgn(m, i)));\n  return build(f.map((x) => x[0]), f.map(() => 1), f.map((x) => x[1]), v, [0, 0, 0, 1], [1, 1, 1, 1]);\n}\n// The 16-cell: 16 tetrahedra; two touch when their normals differ in one\n// sign, so the count of minus signs, mod 4, never repeats across a face.\nfunction cell16() {\n  const f = halves();\n  return build(f.map((x) => x[0]), f.map(() => 0.5), f.map((x) => x[1] & 3), axes().map(([e]) => e), [1, 1, 1, 1], [1, 0, 0, 0]);\n}\n// The 5-cell: 5 tetrahedra, every one touching every other.\nfunction cell5() {\n  const a = 1 / sqrt(5), R = sqrt(3.2);\n  const v = [[1, 1, 1, -a], [1, -1, -1, -a], [-1, 1, -1, -a], [-1, -1, 1, -a], [0, 0, 0, 4 * a]];\n  return build(v.map((p) => p.map((x) => -x / R)), v.map(() => R / 4), [0, 1, 2, 3, 4], v, v[0].map((x) => -x), v[4]);\n}\nconst POLY = [cell24(), tesseract(), cell16(), cell5()];\n\n// LEDs to the circumradius: a slice through the centre is up to 58 LEDs\n// across. The map's detail comes from the seams and rims and its drift from\n// the dark moment between passes, and both grow with the slices: at 28 they\n// read 0.092 and 0.357, at 30 0.096 and 0.401, near the drift axis's end.\nconst FILL = 29;\n// How far a rim LED is lifted toward white, and a seam's share of its face.\nconst RING = 0.5, SEAM = 0.06;\n// The three hyperplanes' rows, and how far apart they lie in 4D as a share\n// of the polytope's reach along the normal: close enough that the three cuts\n// are plainly one solid, far enough that the top one empties first.\nconst SLOT_Y = [23, 64, 105], DEL = 0.22;\n// Seconds a pass takes at Speed 1, and how much of it the slices spend near\n// the middle: the hyperplanes cross the outer fifth of the polytope fast.\nconst PASS = 14, DW = 0.3;\n// Opening hues of the five colour classes: teal, violet, rose, azure, plum.\nconst PAL = [0.5, 0.75, 0.92, 0.6, 0.83];\n// Light from the upper left, in front.\nconst LX = -0.45, LY = -0.55, LZ = -0.7;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, poly: 0, tilt: 0.06,\n    pass: 0.15, spin: 0.7, view: 0.4,\n    m: new Float64Array(3 * 24), w: new Float64Array(24), fcol: new Float32Array(3 * 24),\n    vx: new Float64Array(24), vy: new Float64Array(24), vw: new Float64Array(24),\n    fa: new Float64Array(24), fb: new Float64Array(24), fc: new Float64Array(24), fr: new Float64Array(24), fi: new Int8Array(24),\n    ba: new Float64Array(24), bb: new Float64Array(24), bc: new Float64Array(24), br: new Float64Array(24),\n    col: new Float32Array(5 * 3), warm: new Float32Array(5),\n    id: new Int16Array(W * H), rgb: new Float32Array(W * H * 3), z: new Float32Array(W * H), e: new Uint8Array(W * H),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.poly = min(3, floor(cl(k[2], 0, 3) + 0.5));\n  S.tilt = cl(k[3], -1, 1);\n  const v = d * S.speed;\n  S.pass += v / PASS;\n  S.spin += v * 0.12;\n  S.view += v * 0.25;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const P = POLY[S.poly], K = P.k, m = S.m, w = S.w, fcol = S.fcol, id = S.id, rgb = S.rgb, z = S.z, col = S.col, warm = S.warm;\n  for (let c = 0; c \u003c 5; c++) {\n    const h = S.hue + PAL[c], hh = h - floor(h);\n    // Orange to lime would read brown or olive in shadow: paler, lit higher.\n    warm[c] = min(1, max(0, 1.6 - abs(hh - 0.15) / 0.1));\n    hsv(h, 0.75 - 0.25 * warm[c], 1, col, c * 3);\n  }\n  // The hyperplanes' normal u, in the polytope's frame: tilted theta from\n  // the cell axis toward D, D a unit vector in the first three axes near the\n  // vertex. Between the ends of Tilt both wander, so the polytope turns in 4D.\n  const t4 = S.tilt, amp = 1 - t4 * t4;\n  const th = (P.alpha * (t4 + 1)) / 2 + 0.3 * amp * sin(S.spin);\n  const ph = 0.9 * amp * sin(0.77 * S.spin + 1), ps = 0.9 * amp * sin(0.53 * S.spin + 2);\n  const D0 = cos(ph) * cos(ps), D1 = sin(ph) * cos(ps), D2 = sin(ps), ct = cos(th), st = sin(th);\n  // The hyperplane's own axes are the first three axes turned with u, in\n  // the plane of D and the fourth axis; then the whole slice turns round the\n  // panel's vertical and leans 0.45 radians toward the viewer.\n  const ca = cos(S.view), sa = sin(S.view), cb = cos(0.45), sb = sin(0.45);\n  for (let f = 0, o = 0; f \u003c K; f++, o += 4) {\n    const n0 = P.n[o], n1 = P.n[o + 1], n2 = P.n[o + 2], n3 = P.n[o + 3], nD = n0 * D0 + n1 * D1 + n2 * D2, g = (ct - 1) * nD - st * n3;\n    const x0 = n0 + D0 * g, y0 = n1 + D1 * g, z0 = n2 + D2 * g;\n    const x1 = ca * x0 + sa * z0, z1 = -sa * x0 + ca * z0;\n    m[f * 3] = x1;\n    m[f * 3 + 1] = cb * y0 - sb * z1;\n    m[f * 3 + 2] = sb * y0 + cb * z1;\n    w[f] = st * nD + ct * n3;\n    // Flat shading, 0.32 to 0.92 of the cell's colour by how the face meets\n    // the light.\n    const nx = m[f * 3], ny = m[f * 3 + 1], nz = m[f * 3 + 2], c3 = P.cls[f];\n    const lit0 = 0.32 + 0.6 * max(0, (nx * LX + ny * LY + nz * LZ) / sqrt(nx * nx + ny * ny + nz * nz)), lit = lit0 + (1 - lit0) * 0.75 * warm[c3];\n    for (let i = 0; i \u003c 3; i++) fcol[f * 3 + i] = col[c3 * 3 + i] * lit;\n  }\n  // Each vertex on the screen (vx, vy) and along u (vw), to find where the\n  // edges cross a hyperplane and so the slice's own box on the panel.\n  const { vx, vy, vw } = S;\n  let reach = 0;\n  for (let j = 0, o = 0; o \u003c P.v.length; j++, o += 4) {\n    const v0 = P.v[o], v1 = P.v[o + 1], v2 = P.v[o + 2], v3 = P.v[o + 3], vD = v0 * D0 + v1 * D1 + v2 * D2, g = (ct - 1) * vD - st * v3;\n    const x0 = v0 + D0 * g, y0 = v1 + D1 * g, z0 = v2 + D2 * g;\n    vx[j] = ca * x0 + sa * z0;\n    vy[j] = cb * y0 - sb * (-sa * x0 + ca * z0);\n    vw[j] = st * vD + ct * v3;\n    reach = max(reach, vw[j]);\n  }\n  id.fill(0);\n  rgb.fill(0);\n  z.fill(1e9);\n  const sc = FILL / P.R, E = P.edges;\n  const { fa, fb, fc, fr, fi, ba, bb, bc, br } = S;\n  // One pass: the middle hyperplane runs from (1 + DEL) reach to -(1 + DEL)\n  // reach, the top one DEL behind it and the bottom one DEL ahead, so the\n  // top meets the polytope first.\n  const a = S.pass - floor(S.pass), u = 1 - 2 * a, mid = (1 + DEL) * u * (DW + (1 - DW) * u * u * u * u);\n  for (let s = 0; s \u003c 3; s++) {\n    const c = reach * (mid - (1 - s) * DEL);\n    if (abs(c) >= reach) continue;\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (let q = 0; q \u003c E.length; q += 2) {\n      const i = E[q], j = E[q + 1], wi = vw[i] - c, wj = vw[j] - c;\n      if (wi * wj > 0 || wi === wj) continue;\n      const t = wi / (wi - wj), X = vx[i] + t * (vx[j] - vx[i]), Y = vy[i] + t * (vy[j] - vy[i]);\n      (x0 = min(x0, X)), (x1 = max(x1, X)), (y0 = min(y0, Y)), (y1 = max(y1, Y));\n    }\n    if (x1 \u003c x0) continue;\n    // Along the view ray (X, Y, t) a face's half-space starts or ends at\n    // t = a + b X + c Y: faces turned toward the viewer give where the ray\n    // may enter, the others where it must leave. The face of the latest\n    // entry is the one seen.\n    let nf = 0, nb = 0, side = false;\n    for (let f = 0; f \u003c K; f++) {\n      const h = P.d[f] - c * w[f], mx = m[f * 3], my = m[f * 3 + 1], mz = m[f * 3 + 2];\n      if (mz \u003c -1e-9) (fa[nf] = h / mz), (fb[nf] = -mx / mz), (fc[nf] = -my / mz), (fi[nf++] = f);\n      else if (mz > 1e-9) (ba[nb] = h / mz), (bb[nb] = -mx / mz), (bc[nb++] = -my / mz);\n      else side = true;\n    }\n    const cy = SLOT_Y[s], cx = 31.5;\n    const ya = max(0, floor(cy + y0 * sc)), yb = min(H - 1, floor(cy + y1 * sc)), xa = max(0, floor(cx + x0 * sc)), xb = min(W - 1, floor(cx + x1 * sc));\n    for (let y = ya; y \u003c= yb; y++) {\n      const Y = (y + 0.5 - cy) / sc;\n      for (let f = 0; f \u003c nf; f++) fr[f] = fa[f] + fc[f] * Y;\n      for (let f = 0; f \u003c nb; f++) br[f] = ba[f] + bc[f] * Y;\n      for (let x = xa; x \u003c= xb; x++) {\n        const X = (x + 0.5 - cx) / sc;\n        let lo = -1e9, hi = 1e9, face = -1;\n        for (let f = 0; f \u003c nf; f++) {\n          const t = fr[f] + fb[f] * X;\n          if (t > lo) (lo = t), (face = f);\n        }\n        for (let f = 0; f \u003c nb && hi > lo; f++) {\n          const t = br[f] + bb[f] * X;\n          if (t \u003c hi) hi = t;\n        }\n        if (lo >= hi || face \u003c 0) continue;\n        if (side) {\n          let out = false;\n          for (let f = 0; f \u003c K && !out; f++) if (abs(m[f * 3 + 2]) \u003c= 1e-9 && P.d[f] - c * w[f] - m[f * 3] * X - m[f * 3 + 1] * Y \u003c 0) out = true;\n          if (out) continue;\n        }\n        face = fi[face];\n        // A lower slice stands in front of the one above where they overlap.\n        const q = y * W + x, zz = lo - s * 100;\n        if (zz >= z[q]) continue;\n        z[q] = zz;\n        id[q] = s * 64 + face + 1;\n        rgb[q * 3] = fcol[face * 3];\n        rgb[q * 3 + 1] = fcol[face * 3 + 1];\n        rgb[q * 3 + 2] = fcol[face * 3 + 2];\n      }\n    }\n  }\n  // Seams: an LED with a 4-neighbour on another lit face, so two LEDs wide.\n  // Rims: an LED beside a seam or beside the dark.\n  const e = S.e;\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      const i = id[q];\n      e[q] = 0;\n      if (!i) continue;\n      const l = x > 0 ? id[q - 1] : i, r = x \u003c W - 1 ? id[q + 1] : i, u = y > 0 ? id[q - W] : i, d = y \u003c H - 1 ? id[q + W] : i;\n      e[q] = (l && l !== i) || (r && r !== i) || (u && u !== i) || (d && d !== i) ? 2 : !l || !r || !u || !d ? 3 : 1;\n    }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      if (e[q] !== 1) continue;\n      if ((x > 0 && e[q - 1] === 2) || (x \u003c W - 1 && e[q + 1] === 2) || (y > 0 && e[q - W] === 2) || (y \u003c H - 1 && e[q + W] === 2)) e[q] = 3;\n    }\n  for (let q = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      let r = rgb[q * 3], g = rgb[q * 3 + 1], b = rgb[q * 3 + 2];\n      if (e[q] === 3) {\n        const o = P.cls[(id[q] - 1) & 63] * 3;\n        (r = col[o] + (1 - col[o]) * RING), (g = col[o + 1] + (1 - col[o + 1]) * RING), (b = col[o + 2] + (1 - col[o + 2]) * RING);\n      } else if (e[q] === 2) (r *= SEAM), (g *= SEAM), (b *= SEAM);\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","poncelet-porism":"// ===== Patternflow pattern =====\n// Title:   Poncelet Porism\n// Family:  line\n// Idea:    Three polygons with their corners on a tall ellipse and every side tangent to a smaller ellipse inside it slide round together in three colours, the corners creeping past the end where the inner ellipse comes close and racing round the far end, and each one closes from wherever it starts.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Poncelet's porism (Jean-Victor Poncelet, 1822), with Euler's relation for triangles (Leonhard Euler, 1765) and Fuss's for quadrilaterals (Nicolas Fuss, 1798), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Centre=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together, a fifth of the wheel apart. At 0 cyan, violet and pink, and the inner ellipse, where all three fills overlap, pale lavender; at 0.25 violet, rose and pale yellow; at 0.5 red, yellow-green and green. A polygon that comes round between orange and yellow-green is paled and its fill raised from 42% to 60%, so it never reads brown or olive.\n// Knob 2: Speed. At 2 each corner goes once round the circles in 12 seconds while the two circles turn once round the centre in 64, so the end where the corners crowd wanders round the panel; at 0.2 that is 120 and 640 seconds, at 3 8 and 43.\n// Knob 3: Shape. Six polygons: 0 triangles, 1 quadrilaterals, 2 pentagrams {5/2}, 3 heptagrams {7/2}, 4 heptagrams {7/3}, 5 octagrams {8/3}, whose sides wind round the inner circle 2 or 3 times before they close. Fills are even-odd, so the pentagram and the {7/2} leave the middle round the inner ellipse dark and the {7/3} and {8/3} light it again. From 3 up two polygons instead of three.\n// Knob 4: Centre. How near the centre the inner circle sits, set as the fastest corner against the slowest: 3.4 times at 0, 3.24 at the opening 0.06, where a corner creeps past the near end at 7.5 LEDs a second and races past the far end at 39; 2.1 times at 0.5; at 1 the circles are concentric, the polygons are regular ones seen through the stretch and only the stretch changes a corner's pace, 14.7 to 29.3 LEDs a second. The inner radius comes from Euler's relation for triangles, d^2 = R^2 - 2Rr, Fuss's for quadrilaterals and bisection on the closing gap for the stars; at the opening the triangles' inner circle is 0.414 of the outer one and sits 0.415 of it off centre.\n// Buttons: K1 tap swings both circles half a turn round the centre in 1.6 seconds, carrying the crowded end to the far end of the panel, and every polygon stays closed through the swing.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, asin, atan2, cos, sin, round, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// The two circles: the outer one of radius 1 at the origin, the inner one of\n// radius r centred (0, e). The panel shows them through the affine map\n// x -> CX + S x, y -> CY + 2 S y, turned by phi first, which keeps every\n// corner on the outer ellipse and every side tangent to the inner one.\nconst S = 28, CX = 31.5, CY = 63.5;\n// The polygons K3 steps through, as [corners, turns]: a triangle, a\n// quadrilateral, then the stars {5/2}, {7/2}, {7/3} and {8/3}, whose sides\n// go round the inner circle two or three times before they close.\nconst SHAPES = [[3, 1], [4, 1], [5, 2], [7, 2], [7, 3], [8, 3]];\n// Polygons on the panel at once, and the samples of the table that turns the\n// invariant parameter into an angle.\nconst POLYS = 3, M = 512;\n// Line half-width and corner disc radius, in LEDs.\nconst HW = 1.25, DISC = 3.3;\n// Opening hues: cyan, violet, pink, a fifth of the wheel apart.\nconst HUE0 = 0.5, SPREAD = 0.2;\n\n// One Poncelet step from angle th on the outer circle: the tangent from that\n// point to the inner circle, on the side that turns counterclockwise, meets\n// the outer circle again at th + the returned advance, in (0, 2 pi).\nfunction advance(th, e, r) {\n  const px = cos(th), py = sin(th), wx = -px, wy = e - py, D = hypot(wx, wy);\n  const a = -asin(cl(r / D, -1, 1)), ca = cos(a), sa = sin(a);\n  const ux = (wx * ca - wy * sa) / D, uy = (wx * sa + wy * ca) / D;\n  const t = -2 * (px * ux + py * uy);\n  const d = atan2(py + t * uy, px + t * ux) - th;\n  return d - floor(d / TAU) * TAU;\n}\n\n// How far n steps overshoot k whole turns. It has one sign for every start\n// unless the polygon closes, so bisection on r finds the closing circle.\nfunction overshoot(e, r, n, k) {\n  let th = 0.3, s = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const d = advance(th, e, r);\n    s += d;\n    th += d;\n  }\n  return s - TAU * k;\n}\n\nfunction closingRadius(e, n, k) {\n  let lo = 0, hi = 1 - e;\n  for (let i = 0; i \u003c 52; i++) {\n    const m = (lo + hi) / 2;\n    if (overshoot(e, m, n, k) > 0) lo = m;\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\n// A corner moves along the outer circle as fast as the tangent from it to the\n// inner circle is long, so the longest tangent over the shortest is the\n// fastest corner against the slowest.\nconst ratioAt = (e, r) => sqrt((1 + e) ** 2 - r * r) / sqrt(max(1e-12, (1 - e) ** 2 - r * r));\n\nfunction solve(P, n, k, rho) {\n  let lo = 0, hi = 0.95;\n  for (let i = 0; i \u003c 40; i++) {\n    const m = (lo + hi) / 2;\n    if (ratioAt(m, closingRadius(m, n, k)) \u003c rho) lo = m;\n    else hi = m;\n  }\n  P.e = (lo + hi) / 2;\n  P.r = closingRadius(P.e, n, k);\n  // The invariant parameter: the integral of d theta over the tangent length,\n  // scaled to 1 round the circle. Each Poncelet step adds exactly k/n to it.\n  const { e, r, tab } = P, L = (th) => 1 / sqrt(1 + e * e - 2 * e * sin(th) - r * r);\n  let acc = 0;\n  tab[0] = 0;\n  for (let i = 0; i \u003c M; i++) {\n    const a = (TAU * i) / M, b = (TAU * (i + 1)) / M;\n    acc += ((b - a) / 6) * (L(a) + 4 * L((a + b) / 2) + L(b));\n    tab[i + 1] = acc;\n  }\n  for (let i = 0; i \u003c= M; i++) tab[i] /= acc;\n}\n\nfunction angleOf(tab, s) {\n  s -= floor(s);\n  let lo = 0, hi = M;\n  while (hi - lo > 1) {\n    const m = (lo + hi) >> 1;\n    if (tab[m] \u003c= s) lo = m;\n    else hi = m;\n  }\n  return (TAU * (lo + (s - tab[lo]) / max(1e-12, tab[lo + 1] - tab[lo]))) / M;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, shape: 0, rho: 0, key: '', e: 0, r: 0.5, tab: new Float64Array(M + 1),\n    t: 0, phi: 0, swing: 0, from: 0,\n    vx: new Float32Array(POLYS * 8), vy: new Float32Array(POLYS * 8), xs: new Float32Array(8),\n    rgb: new Float32Array(W * H * 3), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0]], fill: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3);\n  P.shape = round(cl(k[2], 0, 5));\n  P.rho = 1 + 2.4 * (1 - cl(k[3], 0, 1)) ** 1.1;\n  const key = P.shape + ':' + P.rho.toFixed(4);\n  if (key !== P.key) {\n    const [n, t] = SHAPES[P.shape];\n    solve(P, n, t, P.rho);\n    P.key = key;\n  }\n  if (input.btnPressed && input.btnPressed[0] && P.swing \u003c= 0) {\n    P.swing = 1;\n    P.from = P.phi;\n  }\n  // The corners go round once in 12 seconds at Speed 2, and the pair of\n  // circles turns once in 64, so the side where the corners crowd wanders.\n  // A swing adds half a turn over 1.6 seconds on top of that.\n  const turn = (d * P.speed * TAU) / 128;\n  P.t += (d * P.speed) / 24;\n  if (P.swing > 0) {\n    P.from += turn;\n    P.swing = max(0, P.swing - d / 1.6);\n    P.phi = P.from + PI * sm(0, 1, 1 - P.swing);\n  } else P.phi += turn;\n}\n\n// Paint value a of colour c over the buffer at q.\nfunction over(rgb, q, c, a, wh) {\n  rgb[q] += (c[0] + (1 - c[0]) * wh - rgb[q]) * a;\n  rgb[q + 1] += (c[1] + (1 - c[1]) * wh - rgb[q + 1]) * a;\n  rgb[q + 2] += (c[2] + (1 - c[2]) * wh - rgb[q + 2]) * a;\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const { e, r, tab, vx, vy, xs, rgb, col, fill } = P, [n, turns] = SHAPES[P.shape];\n  const cp = cos(P.phi), sp = sin(P.phi);\n  // Three polygons, or two of the seven- and eight-cornered stars, which\n  // would otherwise draw 21 or 24 sides.\n  const polys = n \u003c 7 ? POLYS : 2;\n  for (let j = 0; j \u003c polys; j++) {\n    const h = P.hue + HUE0 + (j * SPREAD * 2) / (polys - 1), hh = h - floor(h);\n    const warm = sm(0.0, 0.06, hh) * (1 - sm(0.17, 0.24, hh));\n    hsv(h, 0.85 - 0.35 * warm, 1, col[j]);\n    const f = 0.42 + 0.18 * warm;\n    for (let c = 0; c \u003c 3; c++) fill[j][c] = col[j][c] * f;\n    // The first corner rides the invariant parameter; the rest are the\n    // Poncelet steps from it.\n    let th = angleOf(tab, P.t + j / (polys * n));\n    for (let i = 0; i \u003c n; i++) {\n      const x = cos(th), y = sin(th);\n      vx[j * 8 + i] = CX + S * (x * cp - y * sp);\n      vy[j * 8 + i] = CY + 2 * S * (x * sp + y * cp);\n      th += advance(th, e, r);\n    }\n  }\n  rgb.fill(0);\n  // Fills, even-odd, added: a triangle is filled whole, a star has its points\n  // filled and its middle left open, and where several overlap they sum.\n  for (let j = 0; j \u003c polys; j++) {\n    const o = j * 8, f = fill[j];\n    for (let y = 0; y \u003c H; y++) {\n      const yc = y + 0.5;\n      let m = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const ax = vx[o + i], ay = vy[o + i], bx = vx[o + ((i + 1) % n)], by = vy[o + ((i + 1) % n)];\n        if ((ay \u003c= yc) === (by \u003c= yc)) continue;\n        const x = ax + ((yc - ay) * (bx - ax)) / (by - ay);\n        let p = m++;\n        for (; p > 0 && xs[p - 1] > x; p--) xs[p] = xs[p - 1];\n        xs[p] = x;\n      }\n      for (let i = 0; i + 1 \u003c m; i += 2) {\n        const xa = xs[i], xb = xs[i + 1];\n        for (let x = max(0, floor(xa)); x \u003c= min(W - 1, floor(xb)); x++) {\n          const a = min(x + 1, xb) - max(x, xa);\n          if (a \u003c= 0) continue;\n          const q = (y * W + x) * 3;\n          rgb[q] += f[0] * a;\n          rgb[q + 1] += f[1] * a;\n          rgb[q + 2] += f[2] * a;\n        }\n      }\n    }\n  }\n  // Sides, laid over the fills in each polygon's full colour. For each row\n  // only the stretch of the band within reach of the line is visited.\n  const R = HW + 1;\n  for (let j = 0; j \u003c polys; j++) {\n    const o = j * 8, c = col[j];\n    for (let i = 0; i \u003c n; i++) {\n      const ax = vx[o + i], ay = vy[o + i], bx = vx[o + ((i + 1) % n)], by = vy[o + ((i + 1) % n)];\n      const dx = bx - ax, dy = by - ay, l2 = dx * dx + dy * dy || 1, l = sqrt(l2), nx = -dy / l, ny = dx / l;\n      const xmin = min(ax, bx) - R, xmax = max(ax, bx) + R;\n      for (let y = max(0, floor(min(ay, by) - R)); y \u003c= min(H - 1, floor(max(ay, by) + R)); y++) {\n        const py = y + 0.5;\n        let x0 = xmin, x1 = xmax;\n        if (nx > 0.02 || nx \u003c -0.02) {\n          const u = (-R - ny * (py - ay)) / nx + ax, v = (R - ny * (py - ay)) / nx + ax;\n          x0 = max(x0, min(u, v));\n          x1 = min(x1, max(u, v));\n        }\n        for (let x = max(0, floor(x0)); x \u003c= min(W - 1, floor(x1)); x++) {\n          const px = x + 0.5 - ax, qy = py - ay, u = cl((px * dx + qy * dy) / l2, 0, 1);\n          const a = cl(HW + 0.5 - hypot(px - u * dx, qy - u * dy), 0, 1);\n          if (a > 0) over(rgb, (y * W + x) * 3, c, a, 0);\n        }\n      }\n    }\n  }\n  // Corners: a disc of the polygon's colour with a white heart.\n  for (let j = 0; j \u003c polys; j++) {\n    const o = j * 8, c = col[j];\n    for (let i = 0; i \u003c n; i++) {\n      const cx = vx[o + i], cy = vy[o + i];\n      for (let y = max(0, floor(cy - DISC - 1)); y \u003c= min(H - 1, floor(cy + DISC + 1)); y++)\n        for (let x = max(0, floor(cx - DISC - 1)); x \u003c= min(W - 1, floor(cx + DISC + 1)); x++) {\n          const dd = hypot(x + 0.5 - cx, y + 0.5 - cy), a = cl(DISC + 0.5 - dd, 0, 1);\n          if (a > 0) over(rgb, (y * W + x) * 3, c, a, sm(DISC - 0.6, 0.6, dd) * 0.85);\n        }\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","sheet-ghosts":"// ===== Patternflow pattern =====\n// Title:   Sheet Ghosts\n// Family:  halloween\n// Idea:    Bedsheet ghosts 24 to 40 LEDs wide rise up the tall panel through the dark, swaying, their hems rippling and their bodies trailing behind the sway, see-through where they pass through one another, with dark eye holes and a cold glow round each sheet.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the bedsheet ghost costume of Halloween\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Glow=0..1, Speed=0.2..3, Ghosts=3..6, Wind=-1..1\n//\n// Knob 1: Glow. The colour of the glow round each sheet and of the sheet's edge. At 0 toxic green; at 0.25 ice blue; at 0.5 purple; at 0.75 pumpkin orange, which starts half as bright again at the sheet's edge and falls off a third sooner, so it never fades through brown. The sheets stay cold white at the head and pale violet at the hem.\n// Knob 2: Speed. At 2 the ghosts rise 3.7 LEDs a second when 24 wide and 6 when 40 wide, the wide ones being nearer, sway 4 to 9 LEDs each way once every 2.8 to 4.5 seconds, and a wave of the hem runs across in 1.8 seconds; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Ghosts. How many take turns coming up, 3 to 6. Each starts 0.45 to 1.15 of an even share of a 194-row cycle below the last, so at 3 two or three are on the panel at once and at 6 five or six crowd it, overlapping, each sheet showing the others through it.\n// Knob 4: Wind. From -1 (to the left) to 1 (to the right): pushes the ghosts up to 9 LEDs downwind, swings them half as wide again, runs the hem's ripple downwind twice as fast and leans every body so its hem trails downwind, 16 LEDs behind the head on a 40-wide ghost. The opening 0.06 is a breath to the right.\n// Buttons: K1 tap: every ghost rushes at the viewer, swelling to 3.2 times its size about its face in 0.8 seconds, eyes up to 19 LEDs wide, and fades out by 1.1; then a new set fades in where it stands by 2.1.\n\nconst W = 64, H = 128, MAXG = 6;\nconst { floor, min, max, sqrt, sin, cos, exp, abs, round, sign, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Opening glow: toxic green.\nconst HUE0 = 0.31;\n// Glow reach in LEDs and its strength at the sheet's edge.\nconst GR = 2.1, GK = 0.65;\n// A ghost's shape, in units of its width w, from the centre of its head:\n// the head a circle of radius 0.46, the body flaring below it to a hem 1.25\n// down, rippling 0.07 up and down in 2.5 waves across.\nconst RH = 0.46, LB = 1.25, AH = 0.07, WAVES = 2.5;\n// The rush on a K1 tap: swell for 0.8 s, gone by 1.1, back in by 2.1.\nconst SWELL = 0.8, GONE = 1.1, BACK = 2.1;\n\n// A fresh ghost: its size, sway and colour.\nfunction dress(g) {\n  g.w = 24 + 16 * Math.random();\n  g.sa = 4 + 5 * Math.random();\n  g.sf = 0.22 + 0.14 * Math.random();\n  g.ph = TAU * Math.random();\n  g.tint = Math.random();\n  g.on = true;\n}\n\n// Where the head is across the panel: its lane, pushed up to 9 LEDs\n// downwind, and its sway, half as wide again in a full wind.\nconst swayX = (g, P) => g.x0 + 9 * P.wind + g.sa * (1 + 0.5 * abs(P.wind)) * sin(TAU * g.sf * P.t + g.ph);\n\n// A ghost from below, on the other side of the middle from the one that\n// came up last.\nfunction spawn(g, P) {\n  dress(g);\n  let low = null, n = 0;\n  for (const o of P.gs) {\n    if (o === g || !o.on) continue;\n    n++;\n    if (!low || o.hy > low.hy) low = o;\n  }\n  const side = low ? (low.x0 \u003c 32 ? 1 : -1) : Math.random() \u003c 0.5 ? 1 : -1;\n  g.x0 = 32 + side * (3 + 13 * Math.random());\n  g.cx = swayX(g, P);\n  // Below the panel, and 0.45 to 1.15 times an even share of the cycle\n  // below the lowest ghost already up: they keep coming at a steady pace,\n  // sometimes two close enough to cross.\n  g.hy = max(H + RH * g.w + 3, low ? low.hy + ((H + 66) * (0.45 + 0.7 * Math.random())) / (n + 1) : 0);\n}\n\n// Ghosts spread up the panel, lanes taking turns left and right: the\n// opening frame, and the return after a rush.\nfunction spread(P) {\n  P.gs.forEach((g, i) => {\n    g.on = false;\n    if (i >= P.count) return;\n    dress(g);\n    g.x0 = 32 + (i % 2 ? 1 : -1) * (8 + 6 * Math.random());\n    g.hy = -8 + (i * (H + 66)) / P.count + 6 * Math.random();\n    g.cx = swayX(g, P);\n  });\n}\n\nexport function setup(params) {\n  const gs = [];\n  for (let i = 0; i \u003c MAXG; i++) gs.push({ w: 30, x0: 32, hy: 0, sa: 6, sf: 0.3, ph: 0, tint: 0, on: false, cx: 32, vx: 0, shear: 0 });\n  params.s = { hue: 0, speed: 2, count: 3, wind: 0.06, t: 0, rip: 0, fl: 0, gs, begun: false, boo: -1, rgb: new Float32Array(W * H * 3), glow: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3);\n  P.count = round(cl(k[2], 3, MAXG));\n  P.wind = cl(k[3], -1, 1);\n  if (!P.begun) {\n    spread(P);\n    P.begun = true;\n  }\n  const sp = P.speed / 2, wa = abs(P.wind);\n  P.t += d * sp;\n  // The hem's ripple runs downwind, faster in a wind; the sides flutter.\n  P.rip += d * sp * (3.4 + 4 * wa) * (P.wind \u003c 0 ? -1 : 1);\n  P.fl += d * sp * (2.6 + 4 * wa);\n  if (input.btnPressed && input.btnPressed[0] && P.boo \u003c 0) P.boo = 0;\n  if (P.boo >= 0) {\n    const was = P.boo;\n    P.boo += d;\n    if (was \u003c GONE && P.boo >= GONE) spread(P);\n    if (P.boo >= BACK) P.boo = -1;\n  }\n  const rushing = P.boo >= 0 && P.boo \u003c GONE;\n  for (let i = 0; i \u003c MAXG; i++) {\n    const g = P.gs[i];\n    if (i >= P.count) {\n      g.on = false;\n      continue;\n    }\n    if (!g.on && !rushing) spawn(g, P);\n    // Bigger ghosts are nearer, so they rise faster, 3.7 to 6 LEDs a second\n    // at Speed 2, and now and then a near one catches up a far one and\n    // passes through it.\n    if (!rushing) g.hy -= d * sp * (0.2 + 0.145 * g.w);\n    const cx = swayX(g, P);\n    g.vx = d > 0 ? (cx - g.cx) / d : 0;\n    g.cx = cx;\n    // The body trails the head: it leans away from the way the head is\n    // going, and the wind pushes the hem further downwind.\n    g.shear += (cl(-0.02 * g.vx + 0.32 * P.wind, -0.5, 0.5) - g.shear) * min(1, d * 4);\n    if (g.hy + (LB + AH) * g.w \u003c -GR * 3 && !rushing) spawn(g, P);\n  }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const { rgb, glow, gs } = P;\n  const gh = P.hue + HUE0, hh = gh - floor(gh);\n  // Orange and yellow glows start half as bright again and fall off a third\n  // sooner, so they do not fade through brown.\n  const warm = sm(0.0, 0.05, hh) * (1 - sm(0.14, 0.2, hh));\n  hsv(gh, 0.9 - 0.15 * warm, 1, glow);\n  const reach = GR * (1 - 0.35 * warm), gk = GK * (1 + 0.5 * warm);\n  rgb.fill(0);\n  const T = P.t, boo = P.boo, rip = P.rip, wa = abs(P.wind);\n  // The rush: each ghost swells to 3.2 times its size about its face and\n  // fades out, and then the next ones fade in where they stand.\n  let sc = 1, fade = 1, flare = 1;\n  if (boo >= 0 && boo \u003c GONE) {\n    const u = cl(boo / SWELL, 0, 1);\n    sc = 1 + 2.2 * u * u * u;\n    fade = 1 - sm(0.55, GONE, boo);\n    flare = 1 + 0.8 * sm(0, 0.5, boo);\n  } else if (boo >= GONE) fade = sm(GONE, BACK, boo);\n  // Far (narrow) ghosts first.\n  const order = gs.filter((g) => g.on).sort((a, b) => a.w - b.w);\n  for (const g of order) {\n    const w = g.w, hx = g.cx, hy = g.hy, rh = RH * w, lb = LB * w, ah = AH * w, sh = g.shear;\n    const kk = (TAU * WAVES) / (2.4 * rh), ph = g.ph * 3;\n    const ex = 0.16 * w, ey = -0.08 * w, erx = 0.075 * w, ery = 0.115 * w;\n    // The eyes look a little the way the ghost is swaying; the mouth opens\n    // and closes.\n    const look = cl(g.vx * 0.06, -1, 1) * 0.05 * w;\n    const my = 0.13 * w, mrx = 0.05 * w, mry = (0.055 + 0.02 * sin(1.7 * T + g.ph)) * w;\n    // Sheet colour: cold white at the head to pale violet at the hem; the\n    // nearer (wider) ghosts are brighter.\n    const br = 0.86 + (0.14 * (w - 24)) / 16, vr = 0.66 + 0.1 * g.tint, vg = 0.52 + 0.12 * g.tint;\n    const op = 0.9 * fade, flut = 0.05 * w * (1 + 1.5 * wa);\n    const pad = reach * 3 + 1, side = rh * 1.3 + flut + abs(sh) * lb + pad;\n    const fy = hy - sc * (rh + pad), ly = hy + sc * (lb + ah + pad);\n    for (let y = max(0, floor(fy)); y \u003c= min(H - 1, floor(ly)); y++) {\n      const v = (y + 0.5 - hy) / sc, t = cl(v / lb, 0, 1);\n      // The sides flare toward the hem and flutter.\n      const hw = rh * (1 + 0.2 * t ** 1.4) + flut * t * sin(0.22 * v - P.fl + ph);\n      const off = sh * max(0, v), vt = sm(-0.3, 0.9, t), fa = 1 - 0.55 * sm(0.35, 1.05, t), fz = sm(0.55, 1, t);\n      const cr = br * (0.97 + (vr - 0.97) * vt), cg = br * (0.95 + (vg - 0.95) * vt), cb = br;\n      for (let x = max(0, floor(hx - sc * side)); x \u003c= min(W - 1, floor(hx + sc * side)); x++) {\n        const u = (x + 0.5 - hx) / sc - off;\n        const dh = sqrt(u * u + v * v) - rh;\n        const hem = lb + ah * (sin(kk * u - rip + ph) + 0.2 * sin(2 * kk * u + 1.3 * rip));\n        const dd = min(dh, max(abs(u) - hw, v - hem, -v)) * sc;\n        const q = (y * W + x) * 3;\n        if (dd > 0) {\n          // Outside: the cold glow.\n          const a = gk * flare * fade * exp(-dd / (reach * sc));\n          if (a \u003c 0.01) continue;\n          rgb[q] = 1 - (1 - rgb[q]) * (1 - glow[0] * a);\n          rgb[q + 1] = 1 - (1 - rgb[q + 1]) * (1 - glow[1] * a);\n          rgb[q + 2] = 1 - (1 - rgb[q + 2]) * (1 - glow[2] * a);\n          continue;\n        }\n        // Eye holes and the mouth darken whatever is behind them.\n        const e1 = ((abs(u) - ex - look * sign(u)) / erx) ** 2 + ((v - ey) / ery) ** 2;\n        const e2 = ((u - look) / mrx) ** 2 + ((v - my) / mry) ** 2;\n        const hole = max(sm(1.25, 0.75, e1), sm(1.3, 0.7, e2));\n        // Folds run down to the troughs of the hem; the sheet's edge takes\n        // the glow's colour; the lower body thins toward the hem.\n        const lit = 1 - 0.18 * fz * (0.5 + 0.5 * cos(kk * u - rip + ph));\n        const rim = sm(-2.2 * sc, 0, dd) * 0.75, a = op * cl(0.5 - dd, 0, 1) * fa;\n        const r = cr * lit * (1 - rim) + glow[0] * rim, gg = cg * lit * (1 - rim) + glow[1] * rim, b = cb * lit * (1 - rim) + glow[2] * rim;\n        const dark = 1 - 0.92 * hole * a, ab = a * (1 - hole);\n        rgb[q] = 1 - (1 - rgb[q] * dark) * (1 - r * ab);\n        rgb[q + 1] = 1 - (1 - rgb[q + 1] * dark) * (1 - gg * ab);\n        rgb[q + 2] = 1 - (1 - rgb[q + 2] * dark) * (1 - b * ab);\n      }\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","siteswap":"// ===== Patternflow pattern =====\n// Title:   Siteswap\n// Family:  rhythm\n// Idea:    Glowing balls fly between two hands at the foot of the panel, each throw staying up as many beats as its siteswap number says, so in 531 the 5 reaches the top while the 1 zips straight across, and the juggler works through a list of patterns with the throws between two of them found in the state diagram.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: siteswap juggling notation (Paul Klimek, 1981; Bruce Tiemann and Bengt Magnusson, 1985), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Balls=3..7, Tail=0..1\n//\n// Knob 1: Hue. Turns every ball round the wheel together. The balls sit 0.618 of a turn apart, so at 0 three balls are azure, yellow and violet, a fourth is green and a fifth red. A ball that comes round to orange is paled and its tail kept at full brightness, so it never reads brown.\n// Knob 2: Speed. At 2 the highest throw of the pattern stays up 1.8 seconds and the beat follows from it: 0.4 s in 51, 0.21 s in 97531, and never longer than 0.62 s, so a plain 3 stays up 1.55 s. At 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Balls, 3 to 7, each count with its own list of 7 to 10 patterns (for 3: 51, 531, 3, 441, 6316131 and on). Turning it brings a new ball out of a hand that has a free beat or lets one fall off the bottom of the panel, and the throws in between come from the state diagram. Each pattern runs 7 seconds at Speed 2 and then to the end of its cycle.\n// Knob 4: Tail. Each ball trails a comet tail as wide as the ball that tapers to nothing. At Speed 2 it holds the last 0.72 s of flight at 0, 0.78 s at the opening 0.06 and 1.8 s at 1, the whole flight of the highest throw, so every ball paints its full arch.\n// Buttons: K1 tap moves on to the next pattern at the next beat.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, round, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Hands: the ball centre's row at the hands, the inner point each hand\n// throws from and the outer point it catches at. Hand 0 is the left.\nconst YH = 114, YTOP = 9, HMAX = YH - YTOP, DIP = 5;\nconst THROW_X = [26, 38], CATCH_X = [7, 57];\n// Dwell: the share of a beat a ball spends in the hand before it is thrown\n// again. A 1 is in the air 1 - DWELL beats, a 9 is in the air 8.5.\nconst DWELL = 0.5;\n// The highest throw of a pattern takes T_HI seconds at Speed 2, and a beat\n// is never shorter than B_MIN or longer than B_MAX seconds.\nconst T_HI = 1.8, B_MIN = 0.2, B_MAX = 0.62;\n// Each pattern runs at least this many seconds (at Speed 2), then the next.\nconst RUN = 7;\nconst MAXT = 9;\nconst R_BALL = 4, R_GLOW = 7, R_TAIL = 3.7;\nconst HUE0 = 0.55, GOLD = 0.618034;\n\n// Patterns by ball count. Every one is checked in setup: a sequence is\n// jugglable exactly when i + s_i mod n hits every i once, and then its\n// average is the number of balls. The first of each list opens.\nconst LISTS = {\n  3: [\"51\", \"531\", \"3\", \"441\", \"6316131\", \"423\", \"711\", \"52512\", \"4413\", \"72312\"],\n  4: [\"4\", \"534\", \"7531\", \"5551\", \"633\", \"741\", \"552\", \"6451\", \"53\", \"7441\"],\n  5: [\"5\", \"744\", \"97531\", \"645\", \"75751\", \"663\", \"771\", \"753\", \"726\"],\n  6: [\"6\", \"75\", \"864\", \"756\", \"9555\", \"774\", \"8448\", \"855\"],\n  7: [\"7\", \"966\", \"86\", \"975\", \"95\", \"9559\", \"8677\"],\n};\n\nfunction jugglable(seq) {\n  const n = seq.length, hit = new Array(n).fill(false);\n  for (let i = 0; i \u003c n; i++) {\n    const j = (i + seq[i]) % n;\n    if (hit[j]) return false;\n    hit[j] = true;\n  }\n  return true;\n}\n\n// The state at phase j: bit k is set when a ball thrown earlier lands k\n// beats from now, bit 0 being the ball in the hand that throws now.\nfunction stateAt(seq, j) {\n  const n = seq.length;\n  let st = 0;\n  for (let m = 1; m \u003c= MAXT; m++) {\n    const k = seq[(((j - m) % n) + n) % n] - m;\n    if (k >= 0) st |= 1 \u003c\u003c k;\n  }\n  return st;\n}\n\nconst pop = (st) => {\n  let c = 0;\n  for (; st; st &= st - 1) c++;\n  return c;\n};\n\nfunction buildLists() {\n  const out = {};\n  for (const [count, list] of Object.entries(LISTS)) {\n    out[count] = [];\n    for (const text of list) {\n      const seq = [...text].map(Number), sum = seq.reduce((a, b) => a + b, 0);\n      if (!jugglable(seq) || sum !== +count * seq.length) continue;\n      out[count].push({ text, seq, top: max(...seq), states: seq.map((_, j) => stateAt(seq, j)) });\n    }\n  }\n  return out;\n}\n\n// Shortest run of throws from state st to any state of pattern P, throws no\n// higher than the lowest cap that finds one. Where the ball count differs a\n// throw may be a new ball from an empty hand (add) or a ball let fall (drop).\nfunction bridge(st, P, cap0) {\n  const want = pop(P.states[0]);\n  for (let cap = cap0; cap \u003c= MAXT; cap++) {\n    const prev = new Map([[st, null]]);\n    let front = [st];\n    while (front.length) {\n      const next = [];\n      for (const s of front) {\n        const j = P.states.indexOf(s);\n        if (j >= 0) {\n          const path = [];\n          for (let c = s; prev.get(c); c = prev.get(c).from) path.unshift(prev.get(c).move);\n          return { path, phase: j };\n        }\n        const here = s & 1, rest = s >> 1, c = pop(s);\n        const moves = [];\n        if (here && c > want) moves.push({ v: 0, drop: true, to: rest });\n        if (!here) moves.push({ v: 0, to: rest });\n        if (here || c \u003c want)\n          for (let v = 1; v \u003c= cap; v++) if (!(rest & (1 \u003c\u003c (v - 1)))) moves.push({ v, add: !here, to: rest | (1 \u003c\u003c (v - 1)) });\n        for (const m of moves)\n          if (!prev.has(m.to)) {\n            prev.set(m.to, { from: s, move: m });\n            next.push(m.to);\n          }\n      }\n      front = next;\n    }\n  }\n  return null;\n}\n\nexport function setup(params) {\n  const lists = buildLists();\n  params.s = {\n    lists, count: 3, pat: lists[3][0], idx: 0, phase: 0, st: 0, trans: [],\n    beat: 0, next: 0, run: 0, want: false, begun: false,\n    air: 1, bLen: 1, balls: [],\n    hue: 0, speed: 2, tail: 0.06,\n    zA: new Float32Array(N), zC: new Float32Array(N), zB: new Int8Array(N),\n    rgb: new Float32Array(N * 3),\n  };\n}\n\nconst beatLen = (air) => cl(T_HI / air, B_MIN, B_MAX);\n\nfunction newBall(S, t) {\n  let id = 0;\n  while (S.balls.some((b) => b.id === id)) id++;\n  const b = { id, segs: [], land: 0, born: t, gone: false };\n  S.balls.push(b);\n  return b;\n}\n\n// A throw from hand (t & 1) at beat t: up along a parabola to the far hand's\n// catching point, then a scoop in that hand back to its throwing point. A\n// throw of v climbs HMAX ((v - DWELL) / air)^2 rows, air being the beats the\n// pattern's highest throw stays up, so in 531 the 5 climbs 105 rows, the 3\n// climbs 32 and the 1 barely leaves the hands.\nfunction launch(S, b, t, v) {\n  const h = t & 1, h2 = (t + v) & 1, t1 = t + v - DWELL;\n  const a = (v - DWELL) / S.air, A = HMAX * min(1, a * a);\n  b.segs.push({ k: 0, t0: t, t1, x0: THROW_X[h], x1: CATCH_X[h2], A });\n  b.segs.push({ k: 1, t0: t1, t1: t + v, x0: CATCH_X[h2], x1: THROW_X[h2] });\n  b.land = t + v;\n}\n\n// The pattern already running at beat 0: every throw of the last MAXT beats\n// that is still to land, in flight.\nfunction start(S, P) {\n  S.pat = P;\n  S.air = P.top - DWELL;\n  S.bLen = beatLen(S.air);\n  S.st = P.states[0];\n  S.phase = 0;\n  const n = P.seq.length;\n  for (let m = MAXT; m >= 1; m--) {\n    const v = P.seq[(((-m) % n) + n) % n];\n    if (v - m >= 0 && v > 0) launch(S, newBall(S, -m - 1), -m, v);\n  }\n  S.beat = -0.001;\n  S.next = 0;\n}\n\n// The next pattern: the next in the list, or the first when the ball count\n// is changing, reached by the shortest bridge from where the juggle stands.\nfunction plan(S) {\n  const list = S.lists[S.count];\n  if (S.count !== pop(S.st)) S.idx = 0;\n  else S.idx = (S.idx + 1) % list.length;\n  const P = list[S.idx];\n  const cap = max(P.top, S.pat.top);\n  const r = bridge(S.st, P, min(MAXT, cap));\n  if (!r) return;\n  S.trans = r.path;\n  S.pat = P;\n  S.phase = r.phase;\n  S.run = 0;\n}\n\n// Beat t: hand t & 1 throws the ball that lands now with the next value of\n// the bridge, or of the pattern once the bridge is done. A 0 leaves the hand\n// empty, a drop lets its ball fall off the panel, and a throw from an empty\n// hand is a new ball.\nfunction onBeat(S, t) {\n  const sw = S.want || (S.count !== pop(S.st) && !S.trans.length) || (S.run >= RUN && S.phase === 0 && !S.trans.length);\n  if (sw) {\n    S.want = false;\n    plan(S);\n  }\n  let move;\n  if (S.trans.length) move = S.trans.shift();\n  else {\n    const v = S.pat.seq[S.phase];\n    S.phase = (S.phase + 1) % S.pat.seq.length;\n    move = { v };\n  }\n  const here = S.st & 1, rest = S.st >> 1;\n  const b = S.balls.find((x) => !x.gone && x.land === t);\n  if (move.drop) {\n    if (b) {\n      b.gone = true;\n      b.segs.push({ k: 2, t0: t, x0: THROW_X[t & 1], dir: t & 1 ? 1 : -1 });\n    }\n    S.st = rest;\n  } else if (move.v === 0) S.st = rest;\n  else {\n    const ball = here && b ? b : newBall(S, t);\n    launch(S, ball, t, move.v);\n    S.st = rest | (1 \u003c\u003c (move.v - 1));\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 3, 7);\n  S.tail = cl(k[3], 0, 1);\n  // The first frame opens on the first pattern for the knob's ball count.\n  if (!S.begun) {\n    start(S, S.lists[S.count][0]);\n    S.begun = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) S.want = true;\n  const pd = d * S.speed * 0.5;\n  // Scale and tempo ease toward the pattern being juggled.\n  const e = 1 - Math.exp(-pd / 0.5);\n  S.air += (S.pat.top - DWELL - S.air) * e;\n  S.bLen += (beatLen(S.pat.top - DWELL) - S.bLen) * e;\n  S.run += pd;\n  S.beat += pd / S.bLen;\n  while (S.beat >= S.next) onBeat(S, S.next++);\n  // Forget what the longest tail no longer reaches.\n  const keep = S.beat - T_HI / S.bLen - 2;\n  for (const b of S.balls) while (b.segs.length > 2 && (b.segs[0].t1 ?? 1e9) \u003c keep) b.segs.shift();\n  S.balls = S.balls.filter((b) => !(b.gone && S.beat - b.segs[b.segs.length - 1].t0 > 4));\n}\n\n// Where ball b is at beat t, or false before its first segment.\nfunction posAt(b, t, out) {\n  for (let i = b.segs.length - 1; i >= 0; i--) {\n    const s = b.segs[i];\n    if (t \u003c s.t0) continue;\n    if (s.k === 2) {\n      const u = t - s.t0;\n      out[0] = s.x0 + s.dir * 10 * u;\n      out[1] = YH + 70 * u * u;\n      return true;\n    }\n    const u = cl((t - s.t0) / (s.t1 - s.t0), 0, 1);\n    if (s.k === 0) {\n      out[0] = s.x0 + (s.x1 - s.x0) * u;\n      out[1] = YH - 4 * s.A * u * (1 - u);\n    } else {\n      const w = u * u * (3 - 2 * u);\n      out[0] = s.x0 + (s.x1 - s.x0) * w;\n      out[1] = YH + DIP * sin(PI * u);\n    }\n    return true;\n  }\n  return false;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { zA, zC, zB, rgb, balls } = S;\n  zA.fill(1e9);\n  zC.fill(0);\n  rgb.fill(0);\n  // Tail length in beats.\n  const L = (T_HI * (0.4 + 0.6 * S.tail)) / S.bLen;\n  const p = [0, 0], q = [0, 0];\n  for (let bi = 0; bi \u003c balls.length; bi++) {\n    const b = balls[bi];\n    const steps = max(8, Math.ceil(L * 40));\n    let have = posAt(b, S.beat, q);\n    for (let s = 1; s \u003c= steps && have; s++) {\n      const a0 = ((s - 1) / steps) * L, a1 = (s / steps) * L;\n      p[0] = q[0];\n      p[1] = q[1];\n      have = posAt(b, S.beat - a1, q) && S.beat - a1 >= b.born;\n      if (!have) break;\n      // A capsule from p to q, its radius tapering with age.\n      const r = R_TAIL * (1 - a0 / L) ** 0.5;\n      if (r \u003c 0.3) break;\n      const x0 = max(0, floor(min(p[0], q[0]) - r - 1)), x1 = min(W - 1, floor(max(p[0], q[0]) + r + 1));\n      const y0 = max(0, floor(min(p[1], q[1]) - r - 1)), y1 = min(H - 1, floor(max(p[1], q[1]) + r + 1));\n      const dx = q[0] - p[0], dy = q[1] - p[1], ll = dx * dx + dy * dy || 1e-9;\n      for (let y = y0; y \u003c= y1; y++)\n        for (let x = x0; x \u003c= x1; x++) {\n          const px = x + 0.5 - p[0], py = y + 0.5 - p[1], u = cl((px * dx + py * dy) / ll, 0, 1);\n          const ex = px - u * dx, ey = py - u * dy, dd = sqrt(ex * ex + ey * ey);\n          const c = cl(r - dd + 0.5, 0, 1);\n          if (c \u003c= 0) continue;\n          const o = y * W + x, age = a0 + u * (a1 - a0);\n          if (age \u003c zA[o] - 0.02 || (zB[o] === bi && c > zC[o])) {\n            zA[o] = age;\n            zB[o] = bi;\n            zC[o] = c;\n          }\n        }\n    }\n  }\n  const col = [0, 0, 0];\n  const cols = balls.map((b) => {\n    const h = S.hue + HUE0 + b.id * GOLD, hh = h - floor(h);\n    const warm = max(0, 1 - abs(hh - 0.11) / 0.1);\n    hsv(h, 0.85 - 0.25 * warm, 1, col);\n    return [col[0], col[1], col[2], warm];\n  });\n  for (let o = 0; o \u003c N; o++) {\n    const c = zC[o];\n    if (c \u003c= 0) continue;\n    const bc = cols[zB[o]], age = zA[o] / L, lv = (1 - 0.45 * age) * (1 - 0.6 * bc[3]) + bc[3];\n    rgb[o * 3] = bc[0] * lv * c;\n    rgb[o * 3 + 1] = bc[1] * lv * c;\n    rgb[o * 3 + 2] = bc[2] * lv * c;\n  }\n  // The balls: a glow, a full disc and a pale core.\n  for (let bi = 0; bi \u003c balls.length; bi++) {\n    const b = balls[bi];\n    if (!posAt(b, S.beat, q)) continue;\n    const grow = cl((S.beat - b.born) / 0.4, 0, 1), c = cols[bi];\n    const R = R_BALL * grow, G = R_GLOW * grow;\n    for (let y = max(0, floor(q[1] - G)); y \u003c= min(H - 1, floor(q[1] + G)); y++)\n      for (let x = max(0, floor(q[0] - G)); x \u003c= min(W - 1, floor(q[0] + G)); x++) {\n        const dd = sqrt((x + 0.5 - q[0]) ** 2 + (y + 0.5 - q[1]) ** 2);\n        if (dd > G) continue;\n        const o = (y * W + x) * 3, halo = 0.55 * (1 - dd / G) ** 1.4, disc = cl(R - dd + 0.5, 0, 1), core = cl(1 - dd / (R * 0.8), 0, 1) * 0.6;\n        for (let ch = 0; ch \u003c 3; ch++) {\n          let v = 1 - (1 - rgb[o + ch]) * (1 - c[ch] * halo);\n          v += (c[ch] - v) * disc;\n          v += (1 - v) * core * disc;\n          rgb[o + ch] = v;\n        }\n      }\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","spider-drop":"// ===== Patternflow pattern =====\n// Title:   Spider Drop\n// Family:  halloween\n// Idea:    A spider sits at the hub of an orb web strung across the moon, lets go and falls on its silk to the foot of the panel between two corner cobwebs, bounces and twists on the line, then climbs back up it, and the web jolts each time the line snaps tight or the spider lets go.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the drop-down spiders hung over doorways at Halloween\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Spiders=1..3, Wind=0..1\n//\n// Knob 1: Colour. Three palettes round the knob: at 0 an orange moon, a violet web and a toxic green spider with orange spots; at 0.33 a toxic green moon, an orange web and a purple spider; at 0.67 a lilac moon, a green web and an orange spider. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 one round takes 8.4 seconds: 1.1 at the hub, a 1.3-second fall to 62 rows below it, 3.2 bouncing and twisting on the line and 2.7 climbing back. At 0.2 a round takes 84 seconds, at 3 it takes 5.6.\n// Knob 3: Spiders, 1 to 3. The second and third are 0.72 the size of the first and hang from the left and right of the web's rim, dropping 44 and 52 rows. With all three on their lines the hub sags 9 LEDs when they land, against 6 for one.\n// Knob 4: Wind. Sways the web sideways, up to 3 LEDs at the hub, and swings the spiders on their lines. At 0.06 the main spider swings about 10 LEDs either side, most of it from the landing; at 1 the gusts swing it 20.\n// Buttons: K1 tap drops every spider that is sitting at the hub or climbing, at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, round, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The orb web: hub, spokes, frame radius per spoke, capture spiral.\nconst HX = 31, HY = 30, SPOKES = 10, TURNS = 3.2, R_IN = 6;\n// The moon behind it.\nconst MX = 37, MY = 27, MR = 19;\n// Palettes, cycled by K1: moon, moon's rim, web, spider, spider's mark.\nconst PAL = [\n  [[1, 0.62, 0.16], [1, 0.84, 0.5], [0.72, 0.5, 1], [0.42, 1, 0.16], [1, 0.45, 0.05]],\n  [[0.55, 1, 0.22], [0.85, 1, 0.6], [1, 0.58, 0.12], [0.72, 0.3, 1], [0.45, 1, 0.2]],\n  [[0.74, 0.5, 1], [0.9, 0.8, 1], [0.45, 1, 0.25], [1, 0.55, 0.08], [0.75, 0.3, 1]],\n];\n// Spiders: where each hangs from (the hub, or a point on spoke n at 0.8 of\n// its length), how far it drops in rows, and its size.\nconst SPIDERS = [\n  { from: -1, drop: 62, size: 1 },\n  { from: 8, drop: 44, size: 0.72 },\n  { from: 3, drop: 52, size: 0.72 },\n];\n\nfunction webGeometry() {\n  const spokes = [];\n  for (let i = 0; i \u003c SPOKES; i++) {\n    const a = (TAU * (i + 0.3 * (hash(i * 7 + 1) - 0.5))) / SPOKES - PI / 2;\n    const R = 24 + 4 * hash(i * 7 + 2);\n    spokes.push({ a, R });\n  }\n  return spokes;\n}\n\n// Corner cobwebs at the foot of the panel, drawn once: radial threads from\n// each bottom corner and three sagging arcs across them.\nfunction cornerWebs() {\n  const cov = new Float32Array(N);\n  for (const side of [-1, 1]) {\n    const cx = side \u003c 0 ? 0 : W, cy = H, angs = [0.05, 0.55, 1.05, 1.52];\n    const pt = (r, a) => [cx - side * r * cos(a), cy - r * sin(a)];\n    for (const a of angs) line(cov, ...pt(0, a), ...pt(31, a), 1.6, 0.8);\n    for (const r of [10, 19, 28])\n      for (let n = 0; n \u003c angs.length - 1; n++)\n        for (let m = 1; m \u003c= 6; m++) {\n          const at = (k) => pt(r - 1.6 * sin((PI * k) / 6) * (r / 20), mix(angs[n], angs[n + 1], k / 6));\n          line(cov, ...at(m - 1), ...at(m), 1.5, 0.75);\n        }\n  }\n  return cov;\n}\n\nexport function setup(params) {\n  params.s = {\n    spokes: webGeometry(), t: 0, hue: 0, speed: 2, count: 1, wind: 0.06,\n    // The web's sag (rows) and its rate: a damped spring the spiders kick.\n    sag: 0, sagV: 0, gust: 0,\n    sp: SPIDERS.map((d, i) => ({ ...d, i, phase: \"rest\", timer: 0, y: 0, vy: 0, spin: 0, spinV: 0, sw: 0, swV: 0, gait: 0, on: i === 0 })),\n    base: cornerWebs(), cov: new Float32Array(N), legs: new Float32Array(N), rgb: new Float32Array(N * 3), moon: new Float32Array(N * 3), pal: -1,\n  };\n}\n\nconst REST = 1.1, HANG = 3.2, CLIMB = 30;\n\nfunction kickWeb(S, v) {\n  S.sagV += v;\n}\n\nfunction stepSpider(S, p, d, tap) {\n  p.timer += d;\n  if (!p.on) {\n    p.phase = \"rest\";\n    p.y = 0;\n    return;\n  }\n  if (tap && p.phase !== \"drop\" && p.phase !== \"hang\") {\n    p.phase = \"drop\";\n    p.timer = 0;\n    p.vy = max(p.vy, 0);\n    kickWeb(S, -6 * p.size);\n  }\n  if (p.phase === \"rest\") {\n    p.y = 0;\n    p.vy = 0;\n    p.spin *= exp(-d * 3);\n    if (p.timer > REST) {\n      p.phase = \"drop\";\n      p.timer = 0;\n      kickWeb(S, -6 * p.size);\n    }\n  } else if (p.phase === \"drop\" || p.phase === \"hang\") {\n    // A fall with drag, at most 79 rows a second, until the line runs out;\n    // then the line stretches like a spring, about 7 rows past its length.\n    const L = p.drop;\n    let acc = 150 - 1.9 * p.vy;\n    if (p.y > L) acc -= 110 * (p.y - L) + 1.6 * p.vy;\n    if (p.phase === \"drop\" && p.y > L) {\n      p.phase = \"hang\";\n      p.timer = 0;\n      p.spinV += (p.i & 1 ? -1 : 1) * 7;\n      p.swV += (p.i & 1 ? 1 : -1) * 0.2;\n      kickWeb(S, 0.17 * p.vy * p.size);\n    }\n    p.vy += acc * d;\n    p.y += p.vy * d;\n    if (p.phase === \"hang\") {\n      // Twisting on the line: a torsion pendulum.\n      p.spinV += (-5 * p.spin - 0.45 * p.spinV) * d;\n      p.spin += p.spinV * d;\n      if (p.timer > HANG) {\n        p.phase = \"climb\";\n        p.timer = 0;\n      }\n    }\n  } else if (p.phase === \"climb\") {\n    p.gait += d * 9;\n    const v = CLIMB * (0.55 + 0.45 * sin(p.gait) ** 2);\n    p.y = max(0, p.y - v * d);\n    p.vy = 0;\n    p.spin *= exp(-d * 2);\n    if (p.y \u003c= 0) {\n      p.phase = \"rest\";\n      p.timer = 0;\n      kickWeb(S, 3 * p.size);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 1, 3);\n  S.wind = cl(k[3], 0, 1);\n  const pd = d * S.speed * 0.5;\n  S.t += pd;\n  const tap = !!(input.btnPressed && input.btnPressed[0]);\n  for (const p of S.sp) {\n    const on = p.i \u003c S.count;\n    if (on && !p.on) p.timer = REST - 0.3 - p.i * 0.4;\n    p.on = on;\n    stepSpider(S, p, pd, tap);\n  }\n  // The web: a spring pulled down by the weight on its lines, and harder\n  // while a line is stretched past its length.\n  let load = 0;\n  for (const p of S.sp) if (p.on && p.y > 0) load += p.size * (p.phase === \"hang\" ? 1 + 0.03 * max(0, p.y - p.drop) * 10 : 1);\n  S.sagV += (-30 * (S.sag - 1.7 * load) - 2.4 * S.sagV) * pd;\n  S.sag += S.sagV * pd;\n  // Wind: a slow swell with gusts.\n  S.gust = S.wind * (0.6 * sin(S.t * 0.9) + 0.4 * sin(S.t * 2.3 + 1)) + 0.15 * sin(S.t * 1.7);\n  for (const p of S.sp) {\n    if (!p.on) continue;\n    const L = max(4, p.y);\n    p.swV += ((-90 / L) * sin(p.sw) - 0.5 * p.swV + (S.gust * 18) / L) * pd;\n    p.sw += p.swV * pd;\n    p.sw = cl(p.sw, -0.6, 0.6);\n  }\n}\n\n// --- drawing ---\n\n// Anti-aliased line of width w into the coverage buffer, keeping the most\n// coverage at each LED.\nfunction line(cov, x0, y0, x1, y1, w, a) {\n  const r = w / 2;\n  const xa = max(0, floor(min(x0, x1) - r - 1)), xb = min(W - 1, floor(max(x0, x1) + r + 1));\n  const ya = max(0, floor(min(y0, y1) - r - 1)), yb = min(H - 1, floor(max(y0, y1) + r + 1));\n  const dx = x1 - x0, dy = y1 - y0, ll = dx * dx + dy * dy || 1e-9;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = cl((px * dx + py * dy) / ll, 0, 1);\n      const ex = px - u * dx, ey = py - u * dy, c = cl(r - sqrt(ex * ex + ey * ey) + 0.5, 0, 1) * a;\n      const o = y * W + x;\n      if (c > cov[o]) cov[o] = c;\n    }\n}\n\nfunction palette(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  // Each palette holds for 0.1 either side of 0, 1/3 and 2/3 of the knob.\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  return PAL[0].map((_, n) => [0, 1, 2].map((c) => mix(PAL[i][n][c], PAL[j][n][c], s)));\n}\n\n// Where the web's point at radius r, angle a sits now: pulled down by the\n// sag, cone-shaped about the hub, and pushed sideways by the wind.\nfunction webPoint(S, r, a, R, out) {\n  const f = max(0, 1 - r / (R + 4));\n  out[0] = HX + r * cos(a) + S.gust * 3 * f;\n  out[1] = HY + r * sin(a) + S.sag * f + 0.6 * S.sag * f * sin(3 * a);\n}\n\nfunction drawSpider(S, rgb, p, x, y, pal) {\n  const sz = p.size, c = cos(p.spin), sx = (abs(c) \u003c 0.18 ? 0.18 * Math.sign(c || 1) : c) * sz;\n  const body = pal[3], mark = pal[4];\n  const legs = S.legs;\n  const bx0 = max(0, floor(x - 19 * sz)), bx1 = min(W - 1, floor(x + 19 * sz)), by0 = max(0, floor(y - 11 * sz)), by1 = min(H - 1, floor(y + 22 * sz));\n  for (let yy = by0; yy \u003c= by1; yy++) legs.fill(0, yy * W + bx0, yy * W + bx1 + 1);\n  // Head down: abdomen at (x, y), head below it. Legs from the head.\n  const hx = x, hy = y + 7.5 * sz;\n  const idle = p.phase === \"climb\" ? 0.35 : p.phase === \"drop\" ? 0.08 : 0.12;\n  const base = [0.45, 1.0, 1.85, 2.45];\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let j = 0; j \u003c 4; j++) {\n      const wig = idle * sin(p.gait + S.t * (p.phase === \"climb\" ? 0 : 2.2) + j * 1.6 + (side > 0 ? PI : 0));\n      const a = base[j] + wig + (p.phase === \"drop\" ? (j \u003c 2 ? -0.25 : 0.25) : 0);\n      const rx = hx + side * 1.2 * sx, ry = hy - 1 + j * 0.9 * sz;\n      const kx = rx + side * sin(a - 0.5) * 7 * sx, ky = ry + cos(a - 0.5) * 7 * sz - 3 * sz;\n      const fx = kx + side * sin(a + 0.35) * 8 * sx, fy = ky + cos(a + 0.35) * 8 * sz;\n      line(legs, rx, ry, kx, ky, 1.9, 1);\n      line(legs, kx, ky, fx, fy, 1.6, 1);\n    }\n  for (let yy = by0; yy \u003c= by1; yy++)\n    for (let xx = bx0; xx \u003c= bx1; xx++) {\n      const o = yy * W + xx, a = legs[o];\n      if (a \u003c= 0) continue;\n      for (let ch = 0; ch \u003c 3; ch++) rgb[o * 3 + ch] = mix(rgb[o * 3 + ch], body[ch] * 0.8, a);\n    }\n  // Abdomen and head: filled ellipses with a soft edge.\n  const blob = (cx, cy, rx, ry, col, lit) => {\n    for (let yy = max(0, floor(cy - ry - 1)); yy \u003c= min(H - 1, floor(cy + ry + 1)); yy++)\n      for (let xx = max(0, floor(cx - rx - 1)); xx \u003c= min(W - 1, floor(cx + rx + 1)); xx++) {\n        const u = (xx + 0.5 - cx) / rx, v = (yy + 0.5 - cy) / ry, q = sqrt(u * u + v * v);\n        const a = cl((1 - q) * min(rx, ry) + 0.5, 0, 1);\n        if (a \u003c= 0) continue;\n        const o = (yy * W + xx) * 3, sh = lit * (1 - 0.35 * cl(q, 0, 1));\n        for (let ch = 0; ch \u003c 3; ch++) rgb[o + ch] = mix(rgb[o + ch], col[ch] * sh, a);\n      }\n  };\n  const ax = 5.2 * sz * (0.75 + 0.25 * abs(c));\n  blob(x, y, ax, 6.2 * sz, body, 1);\n  blob(hx, hy, 3.2 * sz * (0.8 + 0.2 * abs(c)), 3 * sz, body, 0.85);\n  // The mark on the abdomen's back, seen when the back faces out.\n  const face = cl(c * 1.4, 0, 1);\n  if (face > 0) {\n    blob(x, y - 1.6 * sz, 1.6 * sz * abs(c) + 0.3, 1.6 * sz, mark, face);\n    blob(x, y + 2 * sz, 1.3 * sz * abs(c) + 0.3, 1.3 * sz, mark, face);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cov, rgb, spokes } = S;\n  const pal = palette(S);\n  const [moon, rim, web] = pal;\n  cov.set(S.base);\n  // Moon: a disc lit brighter toward its rim colour at the upper left, with\n  // a few darker seas, and a faint halo. It only changes with the colour.\n  if (S.pal !== S.hue) {\n    S.moon.fill(0);\n    for (let y = 0; y \u003c 60; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy), o = (y * W + x) * 3;\n        const a = cl(MR - r + 0.5, 0, 1);\n        const halo = 0.09 * cl(1 - (r - MR) / 7, 0, 1) * (r > MR ? 1 : 0);\n        let sea = 0;\n        for (const [sx, sy, sr] of [[-5, -3, 5], [4, 5, 4], [-2, 8, 3], [6, -6, 3]]) sea = max(sea, cl(1 - sqrt((dx - sx) ** 2 + (dy - sy) ** 2) / sr, 0, 1));\n        const lift = cl(0.5 - (dx + dy) / (2.4 * MR), 0, 1);\n        for (let ch = 0; ch \u003c 3; ch++) S.moon[o + ch] = a * mix(moon[ch], rim[ch], lift) * (1 - 0.28 * sea) + halo * moon[ch];\n      }\n    S.pal = S.hue;\n  }\n  rgb.set(S.moon);\n  // The orb web.\n  const P = [0, 0], Q = [0, 0];\n  for (const s of spokes) {\n    webPoint(S, 1.5, s.a, s.R, P);\n    webPoint(S, s.R, s.a, s.R, Q);\n    line(cov, P[0], P[1], Q[0], Q[1], 1.8, 1);\n  }\n  for (let i = 0; i \u003c SPOKES; i++) {\n    const a = spokes[i], b = spokes[(i + 1) % SPOKES];\n    webPoint(S, a.R, a.a, a.R, P);\n    webPoint(S, b.R, b.a, b.R, Q);\n    line(cov, P[0], P[1], Q[0], Q[1], 1.9, 1);\n  }\n  const steps = floor(TURNS * SPOKES);\n  for (let k = 0; k \u003c steps; k++) {\n    const i = k % SPOKES, j = (k + 1) % SPOKES, f0 = k / steps, f1 = (k + 1) / steps;\n    const a = spokes[i], b = spokes[j];\n    const r0 = R_IN + (a.R - 3 - R_IN) * f0, r1 = R_IN + (b.R - 3 - R_IN) * f1;\n    webPoint(S, r0, a.a, a.R, P);\n    webPoint(S, r1, b.a, b.R, Q);\n    line(cov, P[0], P[1], Q[0], Q[1], 1.7, 0.95);\n  }\n  // Moorings from the frame to the panel's edges.\n  for (const [i, ex, ey] of [[0, 30, 0], [2, 63, 2], [4, 63, 52], [7, 0, 56], [9, 0, 3]]) {\n    const s = spokes[i];\n    webPoint(S, s.R, s.a, s.R, P);\n    line(cov, P[0], P[1], ex, ey, 1.3, 0.85);\n  }\n  // Silk lines and the spiders' places.\n  const places = [];\n  for (const p of S.sp) {\n    if (!p.on) continue;\n    let ax, ay;\n    if (p.from \u003c 0) webPoint(S, 0, 0, 30, P);\n    else {\n      const s = spokes[p.from];\n      webPoint(S, s.R * 0.8, s.a, s.R, P);\n    }\n    ax = P[0];\n    ay = P[1];\n    const L = p.y, x = ax + sin(p.sw) * L, y = ay + cos(p.sw) * L;\n    if (L > 1) line(cov, ax, ay, x, y - 5 * p.size, 1, 0.9);\n    places.push([p, x, y + 2 * p.size]);\n  }\n  for (let o = 0; o \u003c N; o++) {\n    // Threads are drawn whole or not at all: a lit LED is a lit LED.\n    const c = cov[o] > 0.42 ? 1 : 0;\n    if (c \u003c= 0) continue;\n    const q = o * 3, lum = max(rgb[q], rgb[q + 1], rgb[q + 2]);\n    // Over the moon a thread is a dark line; over the sky a pale one.\n    if (lum > 0.3) for (let ch = 0; ch \u003c 3; ch++) rgb[q + ch] *= 1 - 0.85 * c;\n    else for (let ch = 0; ch \u003c 3; ch++) rgb[q + ch] = max(rgb[q + ch], web[ch] * c * 0.9);\n  }\n  for (const [p, x, y] of places) drawSpider(S, rgb, p, x, y, pal);\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","square-wheels":"// ===== Patternflow pattern =====\n// Title:   Square Wheels\n// Family:  physics\n// Idea:    Three lanes of polygon wheels, squares to begin with, roll along roads of inverted catenary arcs cut to the length of one side, and each wheel is only ever set down on its road, yet its axle runs dead level along a faint line, until the road is flattened and the axles start to bob.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Roads and wheels, the square wheel on inverted catenaries (Leon Hall and Stan Wagon, 1992), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sides=4..8, Road=0..1\n//\n// Knob 1: Hue. Turns the three lanes round the wheel together, a third of the wheel apart. At 0 azure, magenta and lime wheels on blue, wine and green roads; at 0.5 orange, green and violet. A road that comes round to orange, yellow or yellow-green is lifted and paled so it never reads brown or olive.\n// Knob 2: Speed. At 2 the wheels travel 10 LEDs a second, so a square of side 22.6 turns a quarter in 2 seconds; at 0.2 they travel 1 LED a second, at 3 they travel 15. The top and bottom lanes roll right, the middle one left.\n// Knob 3: Sides. The number of sides of every wheel, 4 to 8, each with its own road. Every wheel sweeps the same circle of radius 16, so a square has inradius 11.3 and humps 19.9 LEDs apart and 4.7 deep; an octagon has inradius 14.8 and humps 11.9 apart and 1.2 deep. Triangles are left out: on their road a corner cuts 0.095 of the inradius into the next hump.\n// Knob 4: Road. Up to 0.06 the road is Hall and Wagon's: the arcs y = -r cosh(x / r), and the axles stay on the line. Above that the humps flatten toward a flat road at 1, and since each wheel is only set down on the road, its axle lifts off the line as it tips over a corner: by 4.7 LEDs for a square on the flat road, 1.2 for an octagon.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, round, sin, cos, tan, sinh, cosh, asinh, hypot, sign, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Three lanes down the panel. R is the circle every wheel in a lane sweeps,\n// whatever its number of sides, so no wheel leaves its lane: 1 row above\n// the wheel, the axle, 2R rows down to the bottom of a trough, and the rest\n// of the lane is road. The middle lane is half a LED smaller, so its humps\n// fall out of step with the others.\nconst LANES = [\n  { y0: 0, h: 43, dir: 1, R: 16, hue: 0, start: 0 },\n  { y0: 43, h: 42, dir: -1, R: 15.5, hue: 1 / 3, start: 13.7 },\n  { y0: 85, h: 43, dir: 1, R: 16, hue: 2 / 3, start: 27.4 },\n];\n// Bands: 2 LEDs lit and 1 dark, inside the wheels and in the road.\nconst BW = 2, BP = 3;\n// Opening hues: azure, magenta, lime.\nconst HUE0 = 0.55;\n// Travel in LEDs a second per unit of Speed.\nconst PACE = 5;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, sides: 4, road: 0, t: 0,\n    code: new Uint8Array(W * H), key: \"\", rgb: new Float32Array(W * H * 3),\n    pal: LANES.map(() => [[0, 0, 0], [0, 0, 0], [0, 0, 0]]),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.sides = round(cl(k[2], 4, 8));\n  // Up to 0.06, the opening, the road is exactly the catenary one.\n  S.road = max(0, (cl(k[3], 0, 1) - 0.06) / 0.94);\n  S.t += d * S.speed * PACE;\n}\n\n// A lane's road and wheels for n sides at road blend kr (0 catenary, 1\n// flat). r is the inradius and a the half-span of one catenary arc, whose\n// length r sinh(a / r) = r tan(pi / n) is half a side; c is half a side. The\n// flat road needs a whole side per hump, so the hump spacing P blends the\n// two. Wheels sit a whole number of humps apart, at least 2R + 5.\nfunction laneGeom(L, n, kr) {\n  const R = L.R, r = R * cos(PI / n), a = r * asinh(tan(PI / n)), c = r * tan(PI / n);\n  const P = 2 * ((1 - kr) * a + kr * c);\n  // Arc i is y = -A cosh(sc (x - iP)) - B, axle level at y = 0, y up.\n  return { n, R, r, a, c, P, D: ceil((2 * R + 5) / P) * P, kr, A: r * (1 - kr), sc: (2 * a) / (P * r), B: r * kr };\n}\n\nconst roadAt = (g, x) => {\n  const xl = x - g.P * round(x / g.P);\n  return -g.A * cosh(g.sc * xl) - g.B;\n};\n\n// How far the axle sits from the middle of its hump when the wheel has\n// tipped by th: on the catenary road x = r asinh(tan th), so the axle stays\n// straight above the point of contact; on the flat road the wheel pivots on\n// a corner. The road blend blends the two.\nfunction xOfTheta(g, th) {\n  const cat = g.r * asinh(tan(th));\n  const piv = sign(th) * (g.c - g.R * sin(PI / g.n - abs(th)));\n  return (1 - g.kr) * cat + g.kr * piv;\n}\n\nfunction thetaOfX(g, xl) {\n  let lo = -PI / g.n, hi = PI / g.n;\n  for (let i = 0; i \u003c 36; i++) {\n    const mid = (lo + hi) / 2;\n    if (xOfTheta(g, mid) \u003c xl) lo = mid;\n    else hi = mid;\n  }\n  return (lo + hi) / 2;\n}\n\n// The wheels of a lane at axle position X: their turn psi (y up,\n// anticlockwise) from rolling, and their height Y found by setting the wheel\n// down on the road, the lowest height at which no side dips below it. The\n// road minus a side's line is concave along each arc, so its highest point\n// on a stretch is where the arc's slope equals the side's, or an end.\nfunction pose(g, X) {\n  const q = round(X / g.P), th = thetaOfX(g, X - q * g.P);\n  const psi = -(q * TAU) / g.n - th;\n  let Y = -1e9;\n  for (let i = 0; i \u003c g.n; i++) {\n    const a0 = psi - PI / 2 + ((i - 0.5) * TAU) / g.n, a1 = a0 + TAU / g.n;\n    let x0 = X + g.R * cos(a0), y0 = g.R * sin(a0), x1 = X + g.R * cos(a1), y1 = g.R * sin(a1);\n    if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n    if (x1 - x0 \u003c 1e-9) {\n      Y = max(Y, roadAt(g, x0) - min(y0, y1));\n      continue;\n    }\n    const m = (y1 - y0) / (x1 - x0);\n    for (let k = round(x0 / g.P); k \u003c= round(x1 / g.P); k++) {\n      const c = k * g.P, lo = max(x0, c - g.P / 2), hi = min(x1, c + g.P / 2);\n      if (hi \u003c lo) continue;\n      const t = cl(g.A > 1e-9 ? c + asinh(-m / (g.A * g.sc)) / g.sc : lo, lo, hi);\n      const need = (x) => -g.A * cosh(g.sc * (x - c)) - g.B - (y0 + m * (x - x0));\n      Y = max(Y, need(t), need(lo), need(hi));\n    }\n  }\n  return { psi, Y };\n}\n\n// Distance from (px, py) to arc k, by Newton's method on the squared\n// distance with the foot kept on the arc.\nfunction arcDist(g, k, px, py) {\n  const c = k * g.P, hw = g.P / 2, { A, B, sc } = g;\n  let t = cl(px, c - hw, c + hw);\n  for (let i = 0; i \u003c 4; i++) {\n    const u = sc * (t - c), ch = cosh(u), sh = sinh(u);\n    const gy = -A * ch - B, g1 = -A * sc * sh, g2 = -A * sc * sc * ch;\n    const f1 = t - px + (gy - py) * g1, f2 = 1 + g1 * g1 + (gy - py) * g2;\n    t = cl(t - f1 / max(0.2, f2), c - hw, c + hw);\n  }\n  return hypot(t - px, -A * cosh(sc * (t - c)) - B - py);\n}\n\nconst axleRow = (L) => floor(L.y0 + 1 + L.R) + 0.5;\n\n// The road layer, kept until Sides or Road moves: 1 for the surface band,\n// 2 for a lit band below it, the bands following the road's shape by true\n// distance, so under each trough they meet in a crease; 3 for the axle line.\nfunction buildRoads(S) {\n  const code = S.code;\n  code.fill(0);\n  for (const L of LANES) {\n    const g = laneGeom(L, S.sides, S.road), yA = axleRow(L);\n    for (let x = 0; x \u003c W; x++) {\n      const lx = x + 0.5, ry = roadAt(g, lx), k0 = round(lx / g.P), k1 = lx > k0 * g.P ? k0 + 1 : k0 - 1;\n      for (let y = L.y0; y \u003c L.y0 + L.h; y++) {\n        const ly = yA - (y + 0.5), p = y * W + x;\n        if (abs(ly) \u003c 0.5) code[p] = 3;\n        if (ly >= ry) continue;\n        const d = min(arcDist(g, k0, lx, ly), arcDist(g, k1, lx, ly));\n        if (d \u003c BW) code[p] = 1;\n        else if (d >= BP && (d - BP) % BP \u003c BW) code[p] = 2;\n      }\n    }\n  }\n}\n\nfunction palette(S) {\n  LANES.forEach((L, i) => {\n    const [wheel, road, top] = S.pal[i], h = S.hue + HUE0 + L.hue, hr = h + 0.06, f = hr - floor(hr);\n    // A deep road from orange round to yellow-green reads brown or olive:\n    // lift and pale it.\n    const warm = sm(0, 0.05, f) * (1 - sm(0.2, 0.26, f));\n    hsv(h, 0.8, 1, wheel);\n    hsv(hr, 0.75 - 0.25 * warm, 0.6 + 0.3 * warm, road);\n    hsv(hr, 0.4, 1, top);\n  });\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.sides + \"/\" + S.road;\n  if (key !== S.key) {\n    buildRoads(S);\n    S.key = key;\n  }\n  palette(S);\n  const { rgb, code, pal } = S;\n  rgb.fill(0);\n  for (let li = 0; li \u003c LANES.length; li++) {\n    const L = LANES[li], [, road, top] = pal[li];\n    for (let p = L.y0 * W; p \u003c (L.y0 + L.h) * W; p++) {\n      const c = code[p], o = p * 3;\n      if (c === 1) (rgb[o] = top[0]), (rgb[o + 1] = top[1]), (rgb[o + 2] = top[2]);\n      else if (c === 2) (rgb[o] = road[0]), (rgb[o + 1] = road[1]), (rgb[o + 2] = road[2]);\n      else if (c === 3) (rgb[o] = 0.11), (rgb[o + 1] = 0.11), (rgb[o + 2] = 0.15);\n    }\n  }\n  // The wheels: nested polygons 2 LEDs wide with 1-LED grooves, round a\n  // white hub on the axle.\n  for (let li = 0; li \u003c LANES.length; li++) {\n    const L = LANES[li], g = laneGeom(L, S.sides, S.road), wheel = pal[li][0], yA = axleRow(L);\n    const X0 = L.dir * S.t + L.start, { psi, Y } = pose(g, X0 - g.D * floor(X0 / g.D));\n    const ux = [], uy = [];\n    for (let i = 0; i \u003c g.n; i++) {\n      const an = -PI / 2 + (i * TAU) / g.n - psi;\n      ux.push(cos(an));\n      uy.push(sin(an));\n    }\n    for (let j = ceil((-g.R - 1 - X0) / g.D); X0 + j * g.D \u003c W + g.R + 1; j++) {\n      const cx = X0 + j * g.D, cy = yA - Y;\n      for (let y = max(L.y0, floor(cy - g.R)); y \u003c= min(L.y0 + L.h - 1, ceil(cy + g.R)); y++)\n        for (let x = max(0, floor(cx - g.R)); x \u003c= min(W - 1, ceil(cx + g.R)); x++) {\n          const dx = x + 0.5 - cx, dy = cy - (y + 0.5);\n          let gauge = -1e9;\n          for (let i = 0; i \u003c g.n; i++) gauge = max(gauge, dx * ux[i] + dy * uy[i]);\n          const e = g.r - gauge;\n          if (e \u003c 0) continue;\n          const rr = hypot(dx, dy), o = (y * W + x) * 3;\n          if (rr \u003c 2.2) (rgb[o] = 1), (rgb[o + 1] = 1), (rgb[o + 2] = 1);\n          else if (rr > 3.2 && e % BP \u003c BW) (rgb[o] = wheel[0]), (rgb[o + 1] = wheel[1]), (rgb[o + 2] = wheel[2]);\n          else rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        }\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","marbling":"// ===== Patternflow pattern =====\n// Title:   Marbling\n// Family:  print\n// Idea:    Drops of ink land on a dark bath and spread into rings, a comb is drawn across them one way and back the other and then down through them, dragging the rings into chevrons and feathers, then the paper is lifted and the bath starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-23\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Aubrey Jaffer's mathematical marbling, after Turkish ebru and Japanese suminagashi\n// Round:   15\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drops=3..8, Comb=0..1\n//\n// Knob 1: Hue. Turns the four inks round the colour wheel together, opening on ultramarine, turquoise, gold and rose.\n// Knob 2: Speed. How fast the marbler works: one bath, drops to lift, takes 116 s at the bottom of the range, 11.6 s where it opens and 7.7 s at the top.\n// Knob 3: Drops. How many places the inks are dropped, from 3 bullseyes about 50 LEDs across to 8 about 30 across; turning it lifts the print and the next bath has the new count.\n// Knob 4: Comb. How close the comb's teeth stand, from 3 teeth 43 LEDs apart that drag the rings most of the panel's width to 16 teeth 8 LEDs apart that crimp them; the comb drawn down afterwards goes from 3 teeth to 10.\n// Buttons: K1 tap lifts the paper now, whatever is on the bath, and the next bath starts.\n\nconst W = 64;\nconst H = 128;\nconst GW = W + 1;\nconst MAXSITES = 8;\n// Five drops land on each site: ink, clear water, ink, clear water, ink.\nconst DROPS = 5;\n// The drops of all the sites add up to this share of the panel's area.\nconst FILL = 0.8;\n// A clear drop's radius against an ink drop's: the dark rings between inks.\nconst CLEAR = 0.8;\n// How far a site stands off the panel's middle, in LEDs: OFF and up to 4 more.\nconst OFF = 5;\n// The bath's programme in bath seconds. Speed 2 runs 0.9 of them a second.\nconst RATE = 0.45;\nconst DROPS_END = 2.6;\nconst SPREAD = 0.5;\nconst ACROSS = 3.0;\nconst BACK = 4.8;\nconst PASS = 1.6;\nconst DOWN = 6.6;\nconst DOWN_LEN = 1.4;\nconst LIFT = 9.0;\nconst LIFT_LEN = 1.0;\nconst REST = 0.4;\n// The first frame finds the last site's drops landing.\nconst START = 1.6;\n// How far a coarse comb drags the ink sideways at a tooth, in LEDs, and how\n// far its pull reaches between teeth, as a share of the gap between them.\nconst ACROSS_PULL = 60;\nconst REACH = 0.75;\n// The sideways pull of the comb, in LEDs, as a function of height, and the\n// downward pull as a function of column: tables at a quarter LED, reaching\n// 64 LEDs past the panel, since the bath goes on beyond it.\nconst TQ = 4;\nconst TY0 = -64;\nconst TY = (H + 128) * TQ;\nconst TX0 = -64;\nconst TX = (W + 128) * TQ;\n// Ink hue and saturation, ultramarine, turquoise, gold, rose, before Hue turns them.\nconst INKS = [\n  [0.63, 1],\n  [0.48, 0.95],\n  [0.12, 1],\n  [0.94, 0.9],\n];\nconst NI = INKS.length;\n\nfunction hsvInto(out, o, h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[o] = (k === 0 || k === 5 ? v : k === 1 ? q : k === 4 ? t : p) * 255;\n  out[o + 1] = (k === 1 || k === 2 ? v : k === 0 ? t : k === 3 ? q : p) * 255;\n  out[o + 2] = (k === 3 || k === 4 ? v : k === 2 ? t : k === 5 ? q : p) * 255;\n}\n\nfunction ease(a, len, v) {\n  const t = Math.max(0, Math.min(1, (v - a) / len));\n  return t * t * (3 - 2 * t);\n}\n\n// Distance from d to the nearest tooth of a comb whose teeth stand at\n// phase, phase + pitch, phase + 2 pitch and so on.\nfunction toothDistance(d, phase, pitch) {\n  d -= phase;\n  d -= Math.floor(d / pitch) * pitch;\n  return d \u003c pitch - d ? d : pitch - d;\n}\n\n// A fresh bath. Each site is a spot where five drops land one after another.\n// The sites stand one above the other near the middle of their bands, every\n// other one 5 to 9 LEDs left of the panel's middle and the rest as far right,\n// and land in a shuffled order. All sites take the same size of drop.\nfunction newBath(P) {\n  P.tau = 0;\n  P.lift = -1;\n  const sites = P.sites;\n  const order = [];\n  for (let i = 0; i \u003c sites; i++) order.push(i);\n  for (let i = sites - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    const t = order[i];\n    order[i] = order[j];\n    order[j] = t;\n  }\n  const each = (DROPS_END - 0.1) / sites;\n  const R = Math.sqrt((FILL * W * H) / (sites * (DROPS - 0.5) * Math.PI));\n  let ink = Math.floor(Math.random() * NI);\n  const flip = Math.random() \u003c 0.5 ? 1 : -1;\n  for (let s = 0; s \u003c sites; s++) {\n    const band = order[s];\n    P.cx[s] = W / 2 + (band % 2 === 0 ? flip : -flip) * (OFF + Math.random() * 4);\n    P.cy[s] = ((band + 0.35 + Math.random() * 0.3) * H) / sites;\n    for (let d = 0; d \u003c DROPS; d++) {\n      const o = s * DROPS + d;\n      // Ink and clear water take turns, ink first and last, so the rings\n      // come out ink, dark, ink round an ink centre. The inks come round in\n      // turn, so every bath carries all four.\n      const clear = d % 2 === 1;\n      P.ink[o] = clear ? -1 : ink++ % NI;\n      P.rad[o] = R * (clear ? CLEAR : 1);\n      P.t0[o] = 0.1 + s * each + (d * each * 0.8) / DROPS;\n    }\n  }\n  // The first pass is drawn towards the side the even bands stand on (the\n  // top and bottom sites at Drops 3), so it drags the odd ones across the\n  // middle and folds the even ones back off the edge. Left to a coin, some\n  // baths came out of the first pass looking much as they went in.\n  P.dir = flip;\n}\n\nexport function setup(params) {\n  params.cx = new Float64Array(MAXSITES);\n  params.cy = new Float64Array(MAXSITES);\n  params.ink = new Int8Array(MAXSITES * DROPS);\n  params.rad = new Float64Array(MAXSITES * DROPS);\n  params.t0 = new Float64Array(MAXSITES * DROPS);\n  params.r2 = new Float64Array(MAXSITES * DROPS);\n  params.rowShift = new Float64Array(TY + 1);\n  params.colShift = new Float64Array(TX + 1);\n  params.tau = 0;\n  params.lift = -1;\n  params.dir = 1;\n  params.sites = 3;\n  params.live = 0;\n  params.hue = 0;\n  params.started = false;\n  params.idx = new Int8Array(GW * (H + 1));\n  params.px = new Float64Array(GW);\n  params.py = new Float64Array(GW);\n  params.hit = new Int8Array(GW);\n  params.rgb = new Float32Array(NI * 3);\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  dt = Math.min(dt, 0.1);\n  const P = params;\n  P.hue = k[0];\n  const comb = Math.max(0, Math.min(1, k[3]));\n  const sites = Math.max(3, Math.min(MAXSITES, Math.round(k[2])));\n  const step = dt * Math.max(0.05, k[1]) * RATE;\n  if (!P.started) {\n    P.started = true;\n    P.sites = sites;\n    newBath(P);\n    P.tau = START;\n  }\n  // The paper goes down on the bath and comes up with the print; then the\n  // bath is skimmed and the next drops fall. A tap, or a new Drops count,\n  // lifts whatever is on the bath now.\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (P.lift \u003c 0 && (P.tau >= LIFT || tap || sites !== P.sites)) P.lift = 0;\n  if (P.lift >= 0) {\n    P.lift += step;\n    if (P.lift >= LIFT_LEN + REST) {\n      P.sites = sites;\n      newBath(P);\n    }\n  } else P.tau += step;\n  const tau = P.tau;\n\n  // Every drop's radius squared as it stands now. A drop spreads fast and\n  // slows as it meets the bath.\n  let live = 0;\n  for (let o = 0; o \u003c P.sites * DROPS; o++) {\n    const u = Math.max(0, Math.min(1, (tau - P.t0[o]) / SPREAD));\n    const r = P.rad[o] * (1 - (1 - u) * (1 - u) * (1 - u));\n    P.r2[o] = r * r;\n    if (u > 0) live = Math.floor(o / DROPS) + 1;\n  }\n  P.live = live;\n\n  // The comb is drawn across, then back the other way with its teeth\n  // between the first pass's, then a finer comb is drawn down. A tooth drags\n  // the bath along with it, less the further from the tooth: Jaffer's tine\n  // line, a pull of size * lam / (d + lam) at distance d.\n  const teeth = 3 + Math.round(comb * 13);\n  const pitch = H / teeth;\n  const lam = 2 + pitch * REACH;\n  // A fine comb drags the ink less far than a coarse one.\n  const pull = ACROSS_PULL * Math.min(1, pitch / 30);\n  const a1 = pull * ease(ACROSS, PASS, tau) * P.dir;\n  const a2 = -pull * ease(BACK, PASS, tau) * P.dir;\n  const rows = P.rowShift;\n  for (let i = 0; i \u003c= TY; i++) {\n    const y = TY0 + i / TQ;\n    let sh = 0;\n    if (a1 !== 0) sh += (a1 * lam) / (toothDistance(y, pitch * 0.5, pitch) + lam);\n    if (a2 !== 0) sh += (a2 * lam) / (toothDistance(y, 0, pitch) + lam);\n    rows[i] = sh;\n  }\n  const down = 3 + Math.round(comb * 7);\n  const dpitch = W / down;\n  const a3 = 14 * Math.min(1, dpitch / 16) * ease(DOWN, DOWN_LEN, tau);\n  const cols = P.colShift;\n  for (let i = 0; i \u003c= TX; i++) cols[i] = a3 === 0 ? 0 : (a3 * 2.5) / (toothDistance(TX0 + i / TQ, dpitch * 0.5, dpitch) + 2.5);\n}\n\nfunction lookup(table, v, v0, n) {\n  let f = (v - v0) * TQ;\n  if (f \u003c= 0) return table[0];\n  if (f >= n) return table[n];\n  const i = Math.floor(f);\n  f -= i;\n  return table[i] + (table[i + 1] - table[i]) * f;\n}\n\n// Finds whose ink lies under each corner of LEDs along the row at height y:\n// follows each point backwards through the comb strokes and then every site,\n// newest first, and writes 0..3 into hit, or -1 for the dark bath. The whole\n// row goes through one site before the next, so the processor can work on\n// many points while each waits on its square root.\nfunction inkRow(P, y) {\n  const cx = P.cx;\n  const cy = P.cy;\n  const r2 = P.r2;\n  const inks = P.ink;\n  const px = P.px;\n  const py = P.py;\n  const hit = P.hit;\n  const rows = P.rowShift;\n  const cols = P.colShift;\n  for (let j = 0; j \u003c GW; j++) {\n    const yy = y - lookup(cols, j, TX0, TX);\n    let x = j - lookup(rows, yy, TY0, TY);\n    // The bath past the panel's sides mirrors the panel, so a comb pulls\n    // ink in from beyond the edge.\n    x -= Math.floor(x / (2 * W)) * 2 * W;\n    px[j] = x \u003c W ? x : 2 * W - x;\n    py[j] = yy;\n    hit[j] = -2;\n  }\n  for (let s = P.live - 1; s >= 0; s--) {\n    const ox = cx[s];\n    const oy = cy[s];\n    const base = s * DROPS;\n    for (let j = 0; j \u003c GW; j++) {\n      if (hit[j] !== -2) continue;\n      const dx = px[j] - ox;\n      const dy = py[j] - oy;\n      const d2 = dx * dx + dy * dy;\n      // Drops on one spot push straight outward, so their areas add up: a\n      // point is in the newest drop, or in the ring of the one before, and so\n      // on, and past them all it comes in by their total area.\n      let rest = d2;\n      let o = base + DROPS - 1;\n      for (; o >= base; o--) {\n        if (rest \u003c r2[o]) break;\n        rest -= r2[o];\n      }\n      if (o >= base) hit[j] = inks[o];\n      else if (rest \u003c d2) {\n        const f = Math.sqrt(rest / d2);\n        px[j] = ox + dx * f;\n        py[j] = oy + dy * f;\n      }\n    }\n  }\n}\n\nexport function draw(display, params, time) {\n  const P = params;\n  const idx = P.idx;\n  const rgb = P.rgb;\n  const hit = P.hit;\n  for (let i = 0; i \u003c NI; i++) hsvInto(rgb, i * 3, INKS[i][0] + P.hue, INKS[i][1], 1);\n  // The bath is sampled at the LEDs' corners, and each LED shows the mean of\n  // its four corners: one sample an LED, and edges come out soft by a step.\n  for (let y = 0; y \u003c= H; y++) {\n    inkRow(P, y);\n    for (let j = 0; j \u003c GW; j++) idx[y * GW + j] = hit[j] === -2 ? -1 : hit[j];\n  }\n  for (let y = 0; y \u003c H; y++) {\n    // The paper peels off from the top and takes the print with it.\n    const fade = P.lift \u003c 0 ? 1 : 1 - ease((y / H) * 0.4, 0.6, P.lift);\n    if (fade \u003c= 0) continue;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * GW + x;\n      const a = idx[p];\n      const b2 = idx[p + 1];\n      const c = idx[p + GW];\n      const d = idx[p + GW + 1];\n      let r = 0;\n      let g = 0;\n      let b = 0;\n      if (a === b2 && a === c && a === d) {\n        if (a \u003c 0) continue;\n        r = rgb[a * 3];\n        g = rgb[a * 3 + 1];\n        b = rgb[a * 3 + 2];\n      } else {\n        for (let n = 0; n \u003c 4; n++) {\n          const e = n === 0 ? a : n === 1 ? b2 : n === 2 ? c : d;\n          if (e \u003c 0) continue;\n          r += rgb[e * 3] * 0.25;\n          g += rgb[e * 3 + 1] * 0.25;\n          b += rgb[e * 3 + 2] * 0.25;\n        }\n      }\n      display.setPixel(x, y, r * fade, g * fade, b * fade);\n    }\n  }\n}\n","constant-width":"// ===== Patternflow pattern =====\n// Title:   Constant Width\n// Family:  geometry\n// Idea:    A column of curves of constant width 62, Reuleaux triangles, pentagons and heptagons, smooth curves built from odd harmonics and a disc, slides down a channel exactly 62 LEDs wide, each turning at its own rate while it touches both walls and the lines it shares with the curves above and below, so the stack never jams and never comes apart.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Curves of constant width, the Reuleaux polygons (Franz Reuleaux, 1876), and Barbier's theorem that they all have perimeter pi times their width (Joseph-Émile Barbier, 1860)\n// Round:   35\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Round=0..1, Spin=0..1\n//\n// Knob 1: Hue. Turns the eight colours round the wheel together. At 0 the Reuleaux polygons are gold, rose, teal and lime, lit to 81%, and the smooth curves and the disc violet, azure, indigo and sky at 52%. Where a deep one would land between orange and lime it is lifted and paled, since there it would read brown or olive.\n// Knob 2: Speed. How fast the column slides: 3 rows a second times the knob, so at 2 a curve takes 10 seconds to pass down its own height of 62 rows and at 0.2 it takes 100.\n// Knob 3: Round. Mixes every curve with the disc of the same width, support function by support function, which keeps the width at 62. At 0 the Reuleaux triangle has the least area a curve of width 62 can have, 2709 LEDs; at 1 every curve is the disc, 3019. The perimeter stays 194.8 the whole way.\n// Knob 4: Spin. How fast the curves turn, 0.4 radians a second at 0 and 3 at 1; neighbours turn opposite ways and each at its own multiple of that.\n// Buttons: K1 tap turns the corner trace on or off: each corner leaves a gold line in its own 62 x 62 square, and a turning Reuleaux triangle draws the square with rounded corners that the Watts drill cuts.\n\nconst W = 64, H = 128, WD = 62, N = 256, CYCLE = 8;\nconst { min, max, floor, ceil, round, sin, cos, sqrt, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The eight curves of the cycle, all of width WD. A Reuleaux n-gon is the\n// intersection of the n disks of radius WD centred on the corners of a\n// regular n-gon whose corner-to-far-corner distance is WD. A harmonic curve\n// has support function h = WD/2 + sum a cos(k t + c) over odd k from 3 up:\n// odd k is what makes h(t) + h(t + pi) = WD, the width in every direction,\n// and the radius of curvature h + h'' = WD/2 - sum a (k^2 - 1) cos(k t + c)\n// stays above 0, so it is convex. The amplitudes below keep that radius at\n// least 2 LEDs.\nconst SHAPES = [\n  { n: 3 },\n  { harm: [[3, 3.6, 0]] },\n  { n: 5 },\n  { harm: [[3, 2.2, 0], [5, 0.5, 1.1]] },\n  { n: 7 },\n  { disc: true },\n  { n: 3 },\n  { harm: [[3, 2.6, 0], [7, 0.16, 2.0]] },\n];\n// Base hue and brightness for each place in the cycle. The sharp curves are\n// lit brighter than the smooth ones, so the column reads as light and deep\n// shapes taking turns as it slides. The map's drift comes mostly from the\n// dark corners of each square, which swing round as the curves turn: with\n// all eight at one brightness it reads 0.263, with these 0.277.\nconst BASE = [[0.13, 0.86], [0.76, 0.55], [0.95, 0.86], [0.6, 0.55], [0.48, 0.86], [0.68, 0.55], [0.3, 0.86], [0.54, 0.55]];\n// The body angles each curve's trace follows: the n corners of a Reuleaux\n// polygon and the k peaks of a curve with one harmonic, which all run round\n// the same path, and for a curve of two harmonics the one point where its\n// support function peaks, since its corners are not alike and each would\n// draw a path of its own.\nfor (const s of SHAPES) {\n  if (s.n) s.tr = Array.from({ length: s.n }, (_, c) => (TAU * c) / s.n);\n  else if (s.harm && s.harm.length === 1) {\n    const [k, , c0] = s.harm[0];\n    s.tr = Array.from({ length: k }, (_, m) => (TAU * m - c0) / k);\n  } else if (s.harm) {\n    let best = -1e9, at = 0;\n    for (let i = 0; i \u003c 3600; i++) {\n      const b = (TAU * i) / 3600;\n      let h = 0;\n      for (const [k, a, c] of s.harm) h += a * cos(k * b + c);\n      if (h > best) (best = h), (at = b);\n    }\n    s.tr = [at];\n  } else s.tr = [0];\n}\n\n// Support function h and its derivative at body angle b, for a curve mixed\n// a share t of the way to the disc.\nfunction support(s, b, t, out) {\n  let h, d;\n  if (s.n) {\n    const n = s.n, R = WD / (2 * cos(PI / (2 * n))), step = TAU / n, half = PI / (2 * n);\n    let del = b - round(b / step) * step;\n    if (abs(del) \u003c= half) (h = R * cos(del)), (d = -R * sin(del));\n    else {\n      // The opposite direction falls in a corner's cone, so here the curve\n      // is the arc of radius WD round that corner.\n      const b2 = b + PI;\n      del = b2 - round(b2 / step) * step;\n      (h = WD - R * cos(del)), (d = R * sin(del));\n    }\n  } else if (s.harm) {\n    (h = WD / 2), (d = 0);\n    for (const [k, a, c] of s.harm) (h += a * cos(k * b + c)), (d -= a * k * sin(k * b + c));\n  } else (h = WD / 2), (d = 0);\n  out[0] = (1 - t) * h + (t * WD) / 2;\n  out[1] = (1 - t) * d;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, round: 0, spin: 0.06,\n    // The column's slide in rows and the spin clock in radians.\n    slide: 15, clock: 0,\n    trace: false, traces: new Map(),\n    px: new Float32Array(N), py: new Float32Array(N),\n    xl: new Float32Array(H), xr: new Float32Array(H),\n    lab: new Int8Array(W * H), rgb: new Float32Array(W * H * 3),\n    col: new Float32Array(CYCLE * 6), colHue: NaN, sup: new Float32Array(2),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3);\n  P.round = cl(k[2], 0, 1);\n  P.spin = cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) {\n    P.trace = !P.trace;\n    P.traces.clear();\n  }\n  P.slide += d * P.speed * 3;\n  P.clock += d * (0.4 + 2.6 * P.spin);\n}\n\n// The angle a curve in slot j has turned to: neighbours turn opposite ways,\n// each at a rate between 0.7 and 1.3 times the clock, from a start of its own.\nconst angle = (j, clock) => hash(j * 3 + 1) * TAU + (j & 1 ? -1 : 1) * (0.7 + 0.6 * hash(j * 3 + 2)) * clock;\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const { px, py, xl, xr, lab, rgb, col, sup, traces } = P;\n  if (P.colHue !== P.hue) {\n    // Fill and rim colours for each place in the cycle. The rim is the fill\n    // pushed to full brightness and halfway to white, at least 40 levels\n    // above every fill so it reads as a hard line.\n    // A deep fill from orange round to lime reads as brown or olive, so in\n    // that band the deep curves are lifted toward the light ones' level and\n    // paled a little.\n    for (let c = 0; c \u003c CYCLE; c++) {\n      const h = P.hue + BASE[c][0], hf = h - floor(h), band = BASE[c][1] \u003c 0.7 ? max(0, 1 - abs(hf - 0.14) / 0.15) : 0;\n      hsv(h, 0.8 - 0.22 * band, (BASE[c][1] + 0.3 * band) * 0.94, col, c * 6);\n      hsv(h, 0.45, 1, col, c * 6 + 3);\n    }\n    P.colHue = P.hue;\n  }\n  lab.fill(0);\n  rgb.fill(0);\n  // Slot j's top line sits at row slide - j * WD: the slots stack upward\n  // with j and the column slides down as slide grows.\n  const jLo = floor((P.slide - H) / WD), jHi = ceil(P.slide / WD);\n  const vis = [];\n  for (let j = jLo; j \u003c= jHi; j++) {\n    const top = P.slide - j * WD;\n    if (top >= H || top + WD \u003c= 0) continue;\n    const shape = SHAPES[((j % CYCLE) + CYCLE) % CYCLE], phi = angle(j, P.clock);\n    // Boundary points from the support function, panel direction a = 2 pi i\n    // / N: the point is h u(a) + h' u'(a) with the body angle a - phi. The\n    // panel's y runs down, so i = N/2 faces the left wall and 3N/4 faces up.\n    for (let i = 0; i \u003c N; i++) {\n      const a = (TAU * i) / N, ca = cos(a), sa = sin(a);\n      support(shape, a - phi, P.round, sup);\n      px[i] = sup[0] * ca - sup[1] * sa;\n      py[i] = sup[0] * sa + sup[1] * ca;\n    }\n    // The left support line on the inner face of the left wall, x = 1, and\n    // the top one on the slot's top line. The width is WD in every\n    // direction, so the right one lands on x = 63 and the bottom one on the\n    // next slot's top line without being placed there.\n    const ox = 1 - px[N / 2], oy = top - py[(3 * N) / 4];\n    const label = vis.length + 1;\n    xl.fill(1e9);\n    xr.fill(-1e9);\n    for (let i = 0; i \u003c N; i++) {\n      const xa = px[i] + ox, ya = py[i] + oy, i2 = (i + 1) % N, xb = px[i2] + ox, yb = py[i2] + oy;\n      if (ya === yb) continue;\n      const r0 = max(0, ceil(min(ya, yb) - 0.5)), r1 = min(H - 1, floor(max(ya, yb) - 0.5));\n      for (let r = r0; r \u003c= r1; r++) {\n        const x = xa + ((r + 0.5 - ya) * (xb - xa)) / (yb - ya);\n        if (x \u003c xl[r]) xl[r] = x;\n        if (x > xr[r]) xr[r] = x;\n      }\n    }\n    for (let r = max(0, floor(top)); r \u003c= min(H - 1, ceil(top + WD)); r++) {\n      if (xr[r] \u003c xl[r]) continue;\n      const x0 = max(1, ceil(xl[r] - 0.5)), x1 = min(W - 2, floor(xr[r] - 0.5));\n      for (let x = x0; x \u003c= x1; x++) lab[r * W + x] = label;\n    }\n    vis.push({\n      j, top, c: ((j % CYCLE) + CYCLE) % CYCLE, shape, phi, ox, oy,\n      left: py[N / 2] + oy, right: py[0] + oy, upX: px[(3 * N) / 4] + ox, downX: px[N / 4] + ox,\n    });\n  }\n  // Fill, with a rim wherever a 4-neighbour belongs to something else.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, l = lab[p];\n      if (!l) continue;\n      const rim = lab[p - 1] !== l || lab[p + 1] !== l || (y > 0 && lab[p - W] !== l) || (y \u003c H - 1 && lab[p + W] !== l);\n      const o = vis[l - 1].c * 6 + (rim ? 3 : 0), q = p * 3;\n      (rgb[q] = col[o]), (rgb[q + 1] = col[o + 1]), (rgb[q + 2] = col[o + 2]);\n    }\n  // The walls: dim slate, brighter where a slot's line meets them, and white\n  // over five rows where a curve touches them.\n  for (let y = 0; y \u003c H; y++)\n    for (const x of [0, W - 1]) {\n      const q = (y * W + x) * 3;\n      (rgb[q] = 0.14), (rgb[q + 1] = 0.18), (rgb[q + 2] = 0.24);\n    }\n  const dot = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const q = (y * W + x) * 3;\n    (rgb[q] = r), (rgb[q + 1] = g), (rgb[q + 2] = b);\n  };\n  for (const v of vis) {\n    const ty = floor(v.top);\n    for (const x of [0, W - 1]) dot(x, ty, 0.55, 0.6, 0.7);\n    for (let e = -2; e \u003c= 2; e++) dot(0, floor(v.left) + e, 1, 1, 1), dot(W - 1, floor(v.right) + e, 1, 1, 1);\n    // Above and below: a small white cross where the curve meets the line.\n    for (const [cx, cy] of [[v.upX, v.top], [v.downX, v.top + WD]]) {\n      const x = floor(cx), y = floor(cy - (cy === v.top ? 0 : 1e-3));\n      dot(x, y, 1, 1, 1), dot(x - 1, y, 1, 1, 1), dot(x + 1, y, 1, 1, 1), dot(x, y - 1, 1, 1, 1), dot(x, y + 1, 1, 1, 1);\n    }\n  }\n  // The corner trace, kept in each slot's own square so it slides with it.\n  if (P.trace) {\n    const seen = new Set();\n    for (const v of vis) {\n      seen.add(v.j);\n      let t = traces.get(v.j);\n      if (!t) traces.set(v.j, (t = { xs: [], ys: [], last: null }));\n      const tr = v.shape.tr, m = tr.length, now = [];\n      for (let c = 0; c \u003c m; c++) {\n        // At a peak of the support function h' is 0, so the point is h times\n        // the unit vector there.\n        const a = tr[c] + v.phi;\n        support(v.shape, tr[c], P.round, sup);\n        const ca = cos(a), sa = sin(a);\n        now.push([sup[0] * ca - sup[1] * sa + v.ox, sup[0] * sa + sup[1] * ca + v.oy - v.top]);\n      }\n      if (t.xs.length \u003c 12000)\n        for (let c = 0; c \u003c m; c++) {\n          const [x1, y1] = now[c], [x0, y0] = t.last ? t.last[c] : now[c];\n          const steps = max(1, ceil(sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) / 0.7));\n          for (let s = 1; s \u003c= steps; s++) t.xs.push(x0 + ((x1 - x0) * s) / steps), t.ys.push(y0 + ((y1 - y0) * s) / steps);\n        }\n      t.last = now;\n      for (let i = 0; i \u003c t.xs.length; i++) dot(floor(t.xs[i]), floor(t.ys[i] + v.top), 1, 0.78, 0.25);\n    }\n    for (const j of traces.keys()) if (!seen.has(j)) traces.delete(j);\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, min(255, rgb[q] * 255), min(255, rgb[q + 1] * 255), min(255, rgb[q + 2] * 255));\n}\n","voronoi":"// ===== Patternflow pattern =====\n// Title:   Voronoi\n// Family:  cells\n// Idea:    Seeds swirl in a current and every LED takes the colour of the nearest one, so flat panes of glass jostle behind lead, each with a roundel at its seed that turns from disc to diamond to square as the measure of distance changes.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// Round:   2\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..6, Cells=20..60, Metric=0..2\n//\n// Knob 1: Hue. The colour of most of the glass; a few panes take the colours across the wheel from it.\n// Knob 2: Speed. How fast the current carries the seeds round.\n// Knob 3: Cells. How many panes, from 20 big ones to 60 small ones.\n// Knob 4: Metric. How distance is measured: 0 is a ruler, 1 is city blocks, 2 is a king's moves on a chessboard, and the roundels go disc, diamond, square.\n// Buttons: K1 tap reshuffles the glass colours.\n\nconst W = 64;\nconst H = 128;\nconst MAX = 64;\n// Buckets of 8x8 LEDs, each holding the few seeds that can own one of its LEDs.\nconst B = 8;\nconst BX = W / B;\nconst BY = H / B;\n// Seeds keep this far off the frame, so a roundel is seldom cut in half.\nconst EDGE = 2.5;\n\n// Kinds of glass: hue offset, saturation, brightness, and how often each turns up.\nconst GLASS = [\n  [0.0, 0.95, 0.9, 0.34],\n  [0.0, 0.8, 0.62, 0.2],\n  [-0.1, 0.9, 0.85, 0.16],\n  [0.07, 0.75, 1.0, 0.1],\n  [0.5, 0.95, 1.0, 0.12],\n  [0.38, 0.9, 0.9, 0.08],\n];\n\nfunction hsv(h, s, v, out, o) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[o] = (k === 0 || k === 5 ? v : k === 1 ? q : k === 4 ? t : p) * 255;\n  out[o + 1] = (k === 1 || k === 2 ? v : k === 0 ? t : k === 3 ? q : p) * 255;\n  out[o + 2] = (k === 3 || k === 4 ? v : k === 2 ? t : k === 5 ? q : p) * 255;\n}\n\nfunction pickGlass(p) {\n  for (let i = 0; i \u003c MAX; i++) {\n    let r = Math.random();\n    let g = 0;\n    while (g \u003c GLASS.length - 1 && r > GLASS[g][3]) {\n      r -= GLASS[g][3];\n      g++;\n    }\n    p.kind[i] = g;\n    p.jitter[i] = (Math.random() - 0.5) * 0.05;\n  }\n  p.hue = -1;\n}\n\n// The current is a stream function made of four box modes, (1,2), (1,3),\n// (2,3) and (1,1), whose strengths rise and fall out of step. A stream\n// function cannot pile seeds up, and a box mode never flows through a wall,\n// so the seeds stay spread out and on the panel; the mix keeps the vortices\n// moving. Each mode is scaled so its fastest point moves at about one unit.\nfunction flow(amp, x, y, out) {\n  const px = Math.PI / W;\n  const py = Math.PI / H;\n  const s1x = Math.sin(px * x), c1x = Math.cos(px * x);\n  const s2x = Math.sin(2 * px * x), c2x = Math.cos(2 * px * x);\n  const s1y = Math.sin(py * y), c1y = Math.cos(py * y);\n  const s2y = Math.sin(2 * py * y), c2y = Math.cos(2 * py * y);\n  const s3y = Math.sin(3 * py * y), c3y = Math.cos(3 * py * y);\n  out[0] = amp[0] * 0.71 * s1x * c2y + amp[1] * 0.83 * s1x * c3y + amp[2] * 0.6 * s2x * c3y + amp[3] * 0.45 * s1x * c1y;\n  out[1] = -amp[0] * 0.71 * c1x * s2y - amp[1] * 0.55 * c1x * s3y - amp[2] * 0.8 * c2x * s3y - amp[3] * 0.9 * c1x * s1y;\n}\n\n// Push seeds apart where they crowd, so the panes stay roughly one size.\nfunction spread(p, n, strength) {\n  const reach = 0.95 * Math.sqrt((W * H) / n);\n  const sx = p.sx;\n  const sy = p.sy;\n  for (let i = 0; i \u003c n; i++) {\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = sx[j] - sx[i];\n      const dy = sy[j] - sy[i];\n      const d2 = dx * dx + dy * dy;\n      if (d2 >= reach * reach || d2 \u003c 1e-6) continue;\n      const d = Math.sqrt(d2);\n      const push = ((reach - d) / d) * strength * 0.5;\n      sx[i] -= dx * push;\n      sy[i] -= dy * push;\n      sx[j] += dx * push;\n      sy[j] += dy * push;\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    sx[i] = Math.min(W - EDGE, Math.max(EDGE, sx[i]));\n    sy[i] = Math.min(H - EDGE, Math.max(EDGE, sy[i]));\n  }\n}\n\nexport function setup(params) {\n  const p = params;\n  p.sx = new Float32Array(MAX);\n  p.sy = new Float32Array(MAX);\n  for (let i = 0; i \u003c MAX; i++) {\n    p.sx[i] = Math.random() * W;\n    p.sy[i] = Math.random() * H;\n  }\n  p.kind = new Uint8Array(MAX);\n  p.jitter = new Float32Array(MAX);\n  p.rgb = new Uint8Array(MAX * 3);\n  p.pale = new Uint8Array(MAX * 3);\n  p.jewel = new Float32Array(MAX);\n  p.tmp = new Float32Array(3);\n  p.owner = new Uint8Array(W * H);\n  p.cand = new Uint8Array(BX * BY * MAX);\n  p.count = new Uint8Array(BX * BY);\n  p.T = 0;\n  p.amp = new Float32Array(4);\n  p.vel = new Float32Array(2);\n  p.settled = false;\n  pickGlass(p);\n}\n\nexport function update(dt, input, params) {\n  const p = params;\n  const k = input.knobValues || [0, 2, 20, 0.06];\n  const n = Math.max(2, Math.min(MAX, Math.round(k[2])));\n  p.n = n;\n  if (!p.settled) {\n    // Relax the random scatter before the first frame, so it opens on even\n    // panes: all the seeds first, for when K3 turns up, then the ones in use.\n    for (let s = 0; s \u003c 30; s++) spread(p, MAX, 0.5);\n    for (let s = 0; s \u003c 30; s++) spread(p, n, 0.5);\n    p.settled = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) pickGlass(p);\n\n  const speed = k[1];\n  p.T += dt * speed * 0.16;\n  const T = p.T;\n  const amp = p.amp;\n  amp[0] = Math.cos(T * 1.0);\n  amp[1] = Math.cos(T * 0.71 + 1.3) * 0.9;\n  amp[2] = Math.cos(T * 1.37 + 2.1) * 0.6;\n  amp[3] = Math.cos(T * 0.53 + 4.0) * 0.8;\n  // A plain Euler step spirals outward round every vortex and, fast enough,\n  // packs the seeds against the walls. A midpoint step does not.\n  const step = 15.6 * speed * dt;\n  const vel = p.vel;\n  for (let i = 0; i \u003c MAX; i++) {\n    const x = p.sx[i];\n    const y = p.sy[i];\n    flow(amp, x, y, vel);\n    flow(amp, x + vel[0] * step * 0.5, y + vel[1] * step * 0.5, vel);\n    p.sx[i] = Math.min(W - EDGE, Math.max(EDGE, x + vel[0] * step));\n    p.sy[i] = Math.min(H - EDGE, Math.max(EDGE, y + vel[1] * step));\n  }\n  // A fast current shears the panes apart faster, so the push keeps pace.\n  spread(p, n, Math.min(0.35, 0.05 + 0.04 * speed));\n\n  // K4 0..1 blends a ruler into city blocks, 1..2 city blocks into king's moves.\n  const m = Math.max(0, Math.min(2, k[3]));\n  p.we = m \u003c 1 ? 1 - m : 0;\n  p.wm = m \u003c 1 ? m : 2 - m;\n  p.wc = m \u003c 1 ? 0 : m - 1;\n\n  if (k[0] !== p.hue) {\n    p.hue = k[0];\n    // K1 at 0 opens on cobalt rather than the red most of the study opens on.\n    const base = 0.6 + k[0];\n    for (let i = 0; i \u003c MAX; i++) {\n      const g = GLASS[p.kind[i]];\n      let h = base + g[0] + p.jitter[i];\n      h -= Math.floor(h);\n      // Dim orange glass reads as brown on the panel, so warm panes stay bright.\n      const warm = h > 0.02 && h \u003c 0.2;\n      hsv(h, g[1], warm ? Math.max(0.92, g[2]) : g[2], p.tmp, 0);\n      p.rgb[i * 3] = p.tmp[0];\n      p.rgb[i * 3 + 1] = p.tmp[1];\n      p.rgb[i * 3 + 2] = p.tmp[2];\n      // The roundel at the heart of each pane is a thinner, paler glass.\n      hsv(h, g[1] * 0.45, 1, p.tmp, 0);\n      p.pale[i * 3] = p.tmp[0];\n      p.pale[i * 3 + 1] = p.tmp[1];\n      p.pale[i * 3 + 2] = p.tmp[2];\n    }\n  }\n}\n\nexport function draw(display, params, time) {\n  const p = params;\n  const n = p.n;\n  const sx = p.sx;\n  const sy = p.sy;\n  const we = p.we;\n  const wm = p.wm;\n  const wc = p.wc;\n  const cand = p.cand;\n  const count = p.count;\n  const owner = p.owner;\n\n  // Each pane has a roundel round its seed, drawn in the same measure, so it\n  // is a disc, a diamond or a square. Under a third of the way to the nearest\n  // other seed it can never cross into the next pane.\n  const jewel = p.jewel;\n  for (let i = 0; i \u003c n; i++) jewel[i] = 1e9;\n  for (let i = 0; i \u003c n; i++) {\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = sx[j] - sx[i];\n      const dy = sy[j] - sy[i];\n      const ax = dx \u003c 0 ? -dx : dx;\n      const ay = dy \u003c 0 ? -dy : dy;\n      const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n      if (d \u003c jewel[i]) jewel[i] = d;\n      if (d \u003c jewel[j]) jewel[j] = d;\n    }\n  }\n  // A roundel under about two LEDs across would be all lead, a dark speck.\n  for (let i = 0; i \u003c n; i++) jewel[i] = jewel[i] * 0.3 \u003c 2.2 ? 0 : jewel[i] * 0.3;\n\n  // Any seed that owns an LED in a bucket is within the nearest seed's\n  // distance from the bucket centre plus twice the centre-to-corner distance.\n  // That holds for all three measures and for any blend of them.\n  const reachCorner = we * Math.SQRT2 * 3.5 + wm * 7 + wc * 3.5;\n  for (let by = 0; by \u003c BY; by++) {\n    for (let bx = 0; bx \u003c BX; bx++) {\n      const cx = bx * B + B / 2;\n      const cy = by * B + B / 2;\n      let best = 1e9;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = sx[i] - cx;\n        const dy = sy[i] - cy;\n        const ax = dx \u003c 0 ? -dx : dx;\n        const ay = dy \u003c 0 ? -dy : dy;\n        const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n        if (d \u003c best) best = d;\n      }\n      const limit = best + 2 * reachCorner + 0.01;\n      const b = by * BX + bx;\n      let c = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = sx[i] - cx;\n        const dy = sy[i] - cy;\n        const ax = dx \u003c 0 ? -dx : dx;\n        const ay = dy \u003c 0 ? -dy : dy;\n        const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n        if (d \u003c= limit) cand[b * MAX + c++] = i;\n      }\n      count[b] = c;\n    }\n  }\n\n  for (let y = 0; y \u003c H; y++) {\n    const row = ((y / B) | 0) * BX;\n    const py = y + 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const b = row + ((x / B) | 0);\n      const c = count[b];\n      const base = b * MAX;\n      const px = x + 0.5;\n      let best = 1e9;\n      let who = 0;\n      for (let j = 0; j \u003c c; j++) {\n        const i = cand[base + j];\n        const dx = sx[i] - px;\n        const dy = sy[i] - py;\n        const ax = dx \u003c 0 ? -dx : dx;\n        const ay = dy \u003c 0 ? -dy : dy;\n        const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n        if (d \u003c best) {\n          best = d;\n          who = i;\n        }\n      }\n      // Which piece of glass: the seed's number doubled, plus one inside its roundel.\n      owner[y * W + x] = who * 2 + (best \u003c jewel[who] ? 1 : 0);\n    }\n  }\n\n  // Lead goes on an LED whose right or lower neighbour belongs to another\n  // piece of glass, which draws one unbroken line between any two pieces\n  // whatever the measure.\n  const rgb = p.rgb;\n  const pale = p.pale;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      const id = owner[o];\n      const lead = (x \u003c W - 1 && owner[o + 1] !== id) || (y \u003c H - 1 && owner[o + W] !== id);\n      const c = (id >> 1) * 3;\n      if (lead) display.setPixel(x, y, 0, 0, 0);\n      else if (id & 1) display.setPixel(x, y, pale[c], pale[c + 1], pale[c + 2]);\n      else display.setPixel(x, y, rgb[c], rgb[c + 1], rgb[c + 2]);\n    }\n  }\n}\n","pentomino-cover":"// ===== Patternflow pattern =====\n// Title:   Pentomino Cover\n// Family:  algo\n// Idea:    A rectangle of sixty cells stands on the panel and Knuth's dancing links fill it with the twelve pentominoes as an exact cover, always placing a piece on the cell with the fewest choices left and taking pieces back out as it backs up, so the board flickers with pieces dropping in and leaving their outlines as they go, and each full cover holds for two seconds under a sweep of light and adds a tick below the board.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dancing Links and Algorithm X (Donald Knuth, 2000) on Solomon Golomb's pentominoes (1953), pattern round 34\n// Round:   34\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Board=0..3, Shuffle=0..1\n//\n// Knob 1: Hue. Turns the twelve piece colours, 30 degrees apart, together round the wheel. At 0 the F is sky blue, the I blue, the X green and the U red-orange; at 0.5 each piece takes the colour the piece six letters on had.\n// Knob 2: Speed. Steps of the search a second, one step being a column chosen, a row tried or a step back: 5 at 0.2, where each piece can be followed in and out; 394 at 2, where the 6 by 10 search averages 1532 steps, about 4 seconds, from one cover to the next; 4457 at 3.\n// Knob 3: Board. 0 is 6 by 10 cells of 10 LEDs, with 2339 covers; 1 is 5 by 12 of 10 LEDs, 1010 covers; 2 is 4 by 15 of 8 LEDs, 368 covers; 3 is 3 by 20 of 6 LEDs, where the whole search, 33,545 steps, finds only 2 covers before it starts again. Covers are counted once for each set of rotations and mirror images.\n// Knob 4: Shuffle. How far the rows are shuffled when a search starts: at 0 every column tries its placements in the fixed order F to Z, top left first; at 0.06 a row moves by up to 12% of the list; at 1 the order is random and the same board gives other covers first. Turning it by more than 0.04 starts a new search.\n// Buttons: K1 tap starts a new search in a new shuffled order.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs, pow, exp, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The twelve pentominoes, F I L N P T U V W X Y Z.\nconst PIECES = [\n  [[1, 0], [2, 0], [0, 1], [1, 1], [1, 2]],\n  [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]],\n  [[0, 0], [0, 1], [1, 1], [2, 1], [3, 1]],\n  [[0, 0], [1, 0], [1, 1], [2, 1], [3, 1]],\n  [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2]],\n  [[0, 0], [1, 0], [2, 0], [1, 1], [1, 2]],\n  [[0, 0], [2, 0], [0, 1], [1, 1], [2, 1]],\n  [[0, 0], [0, 1], [0, 2], [1, 2], [2, 2]],\n  [[0, 0], [0, 1], [1, 1], [1, 2], [2, 2]],\n  [[1, 0], [0, 1], [1, 1], [2, 1], [1, 2]],\n  [[1, 0], [0, 1], [1, 1], [2, 1], [3, 1]],\n  [[0, 0], [1, 0], [1, 1], [1, 2], [2, 2]],\n];\nconst P_ = 4, X_ = 9;\n// Boards, columns by rows, and the LEDs a cell takes.\nconst BOARDS = [[6, 10, 10], [5, 12, 10], [4, 15, 8], [3, 20, 6]];\n\n// Every distinct orientation of a piece: the four turns first, then the\n// four turns of its mirror image, so flip marks the mirrored ones.\nfunction orientations(cells) {\n  const out = [], seen = new Set();\n  for (let f = 0; f \u003c 2; f++)\n    for (let q = 0; q \u003c 4; q++) {\n      let c = cells.map(([x, y]) => (f ? [-x, y] : [x, y]));\n      for (let k = 0; k \u003c q; k++) c = c.map(([x, y]) => [-y, x]);\n      const mx = min(...c.map((p) => p[0])), my = min(...c.map((p) => p[1]));\n      c = c.map(([x, y]) => [x - mx, y - my]).sort((a, b) => a[1] - b[1] || a[0] - b[0]);\n      const key = c.join(\";\");\n      if (!seen.has(key)) seen.add(key), out.push({ cells: c, flip: f });\n    }\n  return out;\n}\nconst ORIENT = PIECES.map(orientations);\n\n// The exact cover matrix: one column per piece, one per cell, and one\n// secondary column that keeps the count to solutions up to symmetry. The X\n// may only sit in the board's first quarter; when it sits on a mirror line\n// of the board the P may not be mirrored, and the secondary column holds\n// those two choices apart.\nfunction placements(bw, bh) {\n  const rows = [];\n  PIECES.forEach((_, pi) => {\n    for (const o of ORIENT[pi]) {\n      const ow = max(...o.cells.map((p) => p[0])) + 1, oh = max(...o.cells.map((p) => p[1])) + 1;\n      for (let y = 0; y + oh \u003c= bh; y++)\n        for (let x = 0; x + ow \u003c= bw; x++) {\n          let sec = pi === P_ && o.flip === 1;\n          if (pi === X_) {\n            const cx = x + 1, cy = y + 1;\n            if (2 * cx > bw - 1 || 2 * cy > bh - 1) continue;\n            sec = (bw % 2 === 1 && 2 * cx === bw - 1) || (bh % 2 === 1 && 2 * cy === bh - 1);\n          }\n          rows.push({ piece: pi, cells: o.cells.map(([a, b]) => (y + b) * bw + x + a), sec });\n        }\n    }\n  });\n  return rows;\n}\n\nconst MAXN = 16000;\nfunction newSearch(S, again) {\n  const [bw, bh] = BOARDS[S.board];\n  const rows = placements(bw, bh);\n  // Shuffle moves each row by up to twice that share of the list. A search\n  // started again keeps the order it had.\n  if (!again) S.jit = rows.map(() => random());\n  const key = rows.map((_, i) => i / rows.length + 2 * S.shuffle * S.jit[i]);\n  const order = rows.map((_, i) => i).sort((a, b) => key[a] - key[b]);\n  const NC = 12 + bw * bh, SEC = NC + 1;\n  const { L, R, U, D, C, RW, SZ } = S;\n  for (let c = 0; c \u003c= NC; c++) (L[c] = c - 1), (R[c] = c + 1), (U[c] = D[c] = C[c] = c), (SZ[c] = 0);\n  L[0] = NC;\n  R[NC] = 0;\n  L[SEC] = R[SEC] = U[SEC] = D[SEC] = C[SEC] = SEC;\n  let k = SEC + 1;\n  S.rows = order.map((i) => rows[i]);\n  S.rows.forEach((r, ri) => {\n    const cols = [1 + r.piece, ...r.cells.map((c) => 13 + c)];\n    if (r.sec) cols.push(SEC);\n    const first = k;\n    for (const c of cols) {\n      C[k] = c;\n      RW[k] = ri;\n      U[k] = U[c];\n      D[k] = c;\n      D[U[c]] = k;\n      U[c] = k;\n      SZ[c]++;\n      L[k] = k - 1;\n      R[k] = k + 1;\n      k++;\n    }\n    L[first] = k - 1;\n    R[k - 1] = first;\n  });\n  S.bw = bw;\n  S.bh = bh;\n  S.cs = BOARDS[S.board][2];\n  S.k = 0;\n  S.mode = 0;\n  S.done = false;\n  S.found = 0;\n  S.hold = 0;\n  S.cell.fill(-1);\n  S.age.fill(9);\n  S.ghost.fill(-1);\n  S.gAge.fill(9);\n  S.builtBoard = S.board;\n  S.builtShuffle = S.shuffle;\n}\n\nfunction cover(S, c) {\n  const { L, R, U, D, C, SZ } = S;\n  L[R[c]] = L[c];\n  R[L[c]] = R[c];\n  for (let i = D[c]; i !== c; i = D[i])\n    for (let j = R[i]; j !== i; j = R[j]) (U[D[j]] = U[j]), (D[U[j]] = D[j]), SZ[C[j]]--;\n}\nfunction uncover(S, c) {\n  const { L, R, U, D, C, SZ } = S;\n  for (let i = U[c]; i !== c; i = U[i])\n    for (let j = L[i]; j !== i; j = L[j]) SZ[C[j]]++, (U[D[j]] = j), (D[U[j]] = j);\n  L[R[c]] = c;\n  R[L[c]] = c;\n}\nfunction place(S, node, on) {\n  const r = S.rows[S.RW[node]];\n  for (const c of r.cells) {\n    if (on) (S.cell[c] = r.piece), (S.age[c] = 0);\n    else (S.ghost[c] = S.cell[c]), (S.gAge[c] = 0), (S.cell[c] = -1);\n  }\n}\n\n// Algorithm X, one node of the search tree a call: enter a level and cover\n// the column with the fewest rows left, try its next row, or step back.\n// Returns true when the board is full.\nfunction searchStep(S) {\n  const { L, R, D, C, SZ, col, row } = S;\n  if (S.mode === 0) {\n    if (R[0] === 0) {\n      S.mode = 2;\n      return true;\n    }\n    let c = R[0], best = 1e9;\n    for (let j = R[0]; j !== 0; j = R[j]) if (SZ[j] \u003c best) (best = SZ[j]), (c = j);\n    cover(S, c);\n    col[S.k] = c;\n    row[S.k] = D[c];\n    S.mode = 1;\n  } else if (S.mode === 1) {\n    const r = row[S.k];\n    if (r === col[S.k]) {\n      uncover(S, col[S.k]);\n      S.mode = 2;\n      return false;\n    }\n    for (let j = R[r]; j !== r; j = R[j]) cover(S, C[j]);\n    place(S, r, true);\n    S.k++;\n    S.mode = 0;\n  } else {\n    if (S.k === 0) {\n      S.done = true;\n      return false;\n    }\n    S.k--;\n    const r = row[S.k];\n    place(S, r, false);\n    for (let j = L[r]; j !== r; j = L[j]) uncover(S, C[j]);\n    row[S.k] = D[r];\n    S.mode = 1;\n  }\n  return false;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const rgb = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[0] = rgb[0];\n  out[1] = rgb[1];\n  out[2] = rgb[2];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, board: 0, shuffle: 0.06, warm: false, acc: 0, sweep: 0,\n    L: new Int32Array(MAXN), R: new Int32Array(MAXN), U: new Int32Array(MAXN), D: new Int32Array(MAXN),\n    C: new Int32Array(MAXN), RW: new Int32Array(MAXN), SZ: new Int32Array(80), col: new Int32Array(16), row: new Int32Array(16),\n    cell: new Int8Array(60), age: new Float32Array(60), ghost: new Int8Array(60), gAge: new Float32Array(60),\n    key: new Int8Array(60), pc: new Int8Array(N), c: [0, 0, 0],\n  };\n}\n\n// A full cover holds for HOLD seconds; the search takes rate(Speed) steps a\n// second.\nconst HOLD = 2;\nconst rate = (sp) => 5 * pow(2, 3.5 * (sp - 0.2));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.board = cl(round(k[2]), 0, 3);\n  S.shuffle = cl(k[3], 0, 1);\n  const pressed = input.btnPressed && input.btnPressed[0];\n  if (!S.warm || pressed || S.board !== S.builtBoard || abs(S.shuffle - S.builtShuffle) > 0.04) {\n    newSearch(S);\n    if (!S.warm) {\n      // Open about 1100 steps short of the first full board, so at Speed 2\n      // the first solution comes near 2.8 s.\n      let n = 0;\n      while (!searchStep(S) && !S.done) n++;\n      newSearch(S, true);\n      for (let i = 0; i \u003c n - 1100; i++) searchStep(S);\n      S.age.fill(9);\n      S.ghost.fill(-1);\n      S.warm = true;\n    }\n  }\n  for (let c = 0; c \u003c 60; c++) (S.age[c] += d), (S.gAge[c] += d);\n  if (S.hold > 0) {\n    S.hold = max(0, S.hold - d);\n    S.sweep += d / HOLD;\n    return;\n  }\n  if (S.done) {\n    newSearch(S);\n    return;\n  }\n  S.acc += d * rate(S.speed);\n  while (S.acc >= 1) {\n    S.acc--;\n    if (searchStep(S)) {\n      S.found++;\n      S.hold = HOLD;\n      S.sweep = 0;\n      S.acc = 0;\n      break;\n    }\n    if (S.done) break;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { bw, bh, cs, cell, age, ghost, gAge, key, pc, c } = S, base = S.hue + 0.55;\n  const BW = bw * cs + 1, BH = bh * cs + 1, ox = floor((W - BW) / 2), oy = floor((H - BH) / 2);\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, 0, 0, 0);\n  // Each cell shows its piece, or for 0.18 s after the search takes a\n  // piece out, that piece's outline fading.\n  for (let i = 0; i \u003c bw * bh; i++) key[i] = cell[i] >= 0 ? cell[i] : ghost[i] >= 0 && gAge[i] \u003c 0.18 ? 12 + ghost[i] : -1;\n  const at = (x, y) => (x \u003c 0 || y \u003c 0 || x >= bw || y >= bh ? -2 : key[y * bw + x]);\n  // A cell's own LEDs show its piece, a grid line between two cells of one\n  // piece that piece, any other grid line the dark seam.\n  pc.fill(-1);\n  for (let Y = 0; Y \u003c BH; Y++)\n    for (let X = 0; X \u003c BW; X++) {\n      const gx = X % cs === 0, gy = Y % cs === 0, cx = floor(X / cs), cy = floor(Y / cs);\n      let q;\n      if (!gx && !gy) q = at(cx, cy);\n      else if (gx && !gy) q = at(cx - 1, cy) === at(cx, cy) ? at(cx, cy) : -1;\n      else if (!gx && gy) q = at(cx, cy - 1) === at(cx, cy) ? at(cx, cy) : -1;\n      else {\n        const a = at(cx - 1, cy - 1);\n        q = a === at(cx, cy - 1) && a === at(cx - 1, cy) && a === at(cx, cy) ? a : -1;\n      }\n      pc[(oy + Y) * W + ox + X] = q;\n    }\n  // A light sweeps across the board while a solution holds.\n  const band = S.hold > 0 ? -0.25 + 1.5 * cl(S.sweep, 0, 1) : -9;\n  for (let Y = 0; Y \u003c BH; Y++)\n    for (let X = 0; X \u003c BW; X++) {\n      const p = (oy + Y) * W + ox + X, q = pc[p];\n      const cx = min(bw - 1, floor(X / cs)), cy = min(bh - 1, floor(Y / cs)), ci = cy * bw + cx;\n      const g = (X / BW + Y / BH) / 2 - band, lit = S.hold > 0 ? exp(-g * g * 90) : 0;\n      if (q >= 0 && q \u003c 12) {\n        // A slight bevel: lighter next to a seam above or to the left,\n        // darker next to one below or to the right.\n        const up = pc[p - W] \u003c 0 || pc[p - W] >= 12, lf = pc[p - 1] \u003c 0 || pc[p - 1] >= 12;\n        const dn = pc[p + W] \u003c 0 || pc[p + W] >= 12, rt = pc[p + 1] \u003c 0 || pc[p + 1] >= 12;\n        const fresh = cl(1 - age[ci] / 0.15, 0, 1);\n        const v = min(1, 0.82 + (up || lf ? 0.18 : 0) - (dn || rt ? 0.2 : 0) + 0.15 * fresh + 0.3 * lit);\n        hsv(base + q / 12, (0.72 - 0.3 * fresh) * (1 - 0.7 * lit), 1, c);\n        display.setPixel(ox + X, oy + Y, round(c[0] * 255 * v), round(c[1] * 255 * v), round(c[2] * 255 * v));\n      } else if (q >= 12) {\n        // A piece just taken out leaves its outline for a moment.\n        if (pc[p - W] === q && pc[p + W] === q && pc[p - 1] === q && pc[p + 1] === q) continue;\n        const f = cl(1 - gAge[ci] / 0.18, 0, 1);\n        hsv(base + (q - 12) / 12, 0.6, 1, c);\n        display.setPixel(ox + X, oy + Y, round(c[0] * 150 * f), round(c[1] * 150 * f), round(c[2] * 150 * f));\n      } else if (X === 0 || Y === 0 || X === BW - 1 || Y === BH - 1) display.setPixel(ox + X, oy + Y, 44, 44, 54);\n      else if (X % cs === 0 && Y % cs === 0) display.setPixel(ox + X, oy + Y, 40, 40, 48);\n    }\n  // One tick under the board for each solution this search has found, 31\n  // to a row; a full row turns dim and the next starts over it.\n  const ty = oy + BH + (oy > 6 ? 2 : 0), full = floor(S.found / 31), part = S.found % 31;\n  for (let i = 0; i \u003c 31; i++) {\n    const on = i \u003c part, x = 1 + 2 * i;\n    if (!on && full === 0) continue;\n    hsv(base + 0.1 * (on ? full : full - 1), on ? 0.25 : 0.5, 1, c);\n    const v = on ? (i === part - 1 && S.hold > 0 ? 255 : 190) : 70;\n    for (let y = ty; y \u003c min(H, ty + 2); y++) display.setPixel(x, y, round(c[0] * v), round(c[1] * v), round(c[2] * v));\n  }\n}\n","moire-rings":"// ===== Patternflow pattern =====\n// Title:   Moire Rings\n// Family:  wave\n// Idea:    Two sets of rings slide past each other, and where they disagree the panel draws a third shape nobody drew.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.1..6, Rings=5..16, Spread=-1..1\n//\n// Knob 1: Hue. Turns the two-colour pair around the colour wheel.\n// Knob 2: Speed. How fast the two centres orbit.\n// Knob 3: Rings. Ring spacing in LEDs; small is a fine moire, large is a few fat bands.\n// Knob 4: Spread. How far apart the two centres travel, and below 0 the second one turns the other way.\n// Buttons: K1 tap swaps which set of rings is drawn bright.\n\nfunction hsv(h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  const r = k === 0 ? v : k === 1 ? q : k === 2 ? p : k === 3 ? p : k === 4 ? t : v;\n  const g = k === 0 ? t : k === 1 ? v : k === 2 ? v : k === 3 ? q : k === 4 ? p : p;\n  const b = k === 0 ? p : k === 1 ? p : k === 2 ? t : k === 3 ? v : k === 4 ? v : q;\n  return [r * 255, g * 255, b * 255];\n}\n\nexport function setup(params) {\n  params.phase = 0;\n  params.swap = false;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  // K1 at 0 opens on cyan rather than the red most of the study opens on.\n  params.hue = k[0] + 0.52;\n  params.speed = k[1];\n  params.spacing = k[2];\n  params.spread = k[3];\n  params.phase += dt * params.speed * 0.35;\n  if (input.btnPressed && input.btnPressed[0]) params.swap = !params.swap;\n}\n\nexport function draw(display, params, time) {\n  const w = display.width;\n  const h = display.height;\n  const reach = 0.15 + Math.abs(params.spread) * 0.85;\n  // Below 0 the second centre runs the other way round.\n  const dir = params.spread \u003c 0 ? -1 : 1;\n  const ax = w / 2 + Math.cos(params.phase) * w * 0.3 * reach;\n  const ay = h / 2 + Math.sin(params.phase * 1.3) * h * 0.35 * reach;\n  const bx = w / 2 - Math.cos(params.phase * 0.8) * w * 0.3 * reach;\n  const by = h / 2 - Math.sin(params.phase * 1.1) * h * 0.35 * reach * dir;\n  const s = params.spacing;\n  const a = hsv(params.hue, 0.85, 1);\n  const b = hsv(params.hue + 0.5, 0.7, 1);\n  const front = params.swap ? b : a;\n  const back = params.swap ? a : b;\n  for (let y = 0; y \u003c h; y++) {\n    for (let x = 0; x \u003c w; x++) {\n      const da = Math.hypot(x - ax, y - ay) / s;\n      const db = Math.hypot(x - bx, y - by) / s;\n      const ra = da - Math.floor(da) \u003c 0.5 ? 1 : 0;\n      const rb = db - Math.floor(db) \u003c 0.5 ? 1 : 0;\n      if (ra && rb) display.setPixel(x, y, front[0], front[1], front[2]);\n      else if (ra !== rb) display.setPixel(x, y, back[0] * 0.18, back[1] * 0.18, back[2] * 0.18);\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n  }\n}\n","kuramoto-sivashinsky":"// ===== Patternflow pattern =====\n// Title:   Kuramoto-Sivashinsky\n// Family:  noise\n// Idea:    The Kuramoto-Sivashinsky equation u_t + u u_x + u_xx + u_xxxx = 0 runs on a ring as wide as the panel, one grid point per column, and each new moment of u enters at the top and scrolls down, so the 128 rows are its space-time diagram: cyan streaks where u is positive and magenta where it is negative wobble, split and merge in a chaotic braid, black where u crosses zero.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kuramoto-Sivashinsky equation (Yoshiki Kuramoto, 1976; Gregory Sivashinsky, 1977), pattern round 37\n// Round:   37\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Length=22..66, Dispersion=-1..1\n//\n// Knob 1: Hue. Turns both sides of the colour map round the wheel together. At 0 positive u is cyan and negative u magenta, black where u crosses zero and pale where |u| passes 2.6; at 0.3 gold and violet, at 0.6 orange and teal.\n// Knob 2: Speed. Rows a second, 15 times the knob, and each row is 1.25 time units of the equation, so the panel always holds the last 160 time units. At 2 that is one row a frame and a moment takes 4.3 s from top to bottom; at 0.2 it takes 43 s.\n// Knob 3: Length. The length L of the ring, 22 to 66. L / 2 pi is the number of linearly unstable modes, 3.5 at 22 and 10.5 at 66. At 22, the size Predrag Cvitanovic and his group studied, two fat cyan streaks wobble in step and now and then slip sideways all at once; at 66 about seven thin ones split and merge.\n// Knob 4: Dispersion. A third-derivative term delta u_xxx, which makes it the Kawahara equation. At the start, 0.06, it is still Kuramoto-Sivashinsky; from about 0.15 at L 22 and 0.25 at L 66 the chaos settles into a train of pulses that lean one way across the diagram, right and cyan for positive delta, left and magenta for negative.\n// Buttons: K1 tap dents the front at a random place: u gets a dipole of plus and minus 4 there, its two halves run apart, as u above zero travels right and u below it left, and they leave a calm patch in the braid that the streaks fill in again over 1 to 3 s.\n\n// The solver is ETDRK4, the exponential time-differencing Runge-Kutta\n// scheme of Steven Cox and Paul Matthews (2002), with the coefficients\n// taken as means round a circle in the complex plane, the way Aly-Khan\n// Kassam and Lloyd Trefethen (2005) do it, so they hold for every mode from\n// the growing ones to the most damped. In Fourier space\n//   v_t = (k^2 - k^4 + i delta k^3) v - (i k / 2) FFT(u^2),\n// the linear part solved exactly and only u^2 stepped, 0.25 time units a\n// step, five steps a row, 40 FFTs of size 64 a frame at Speed 2. At 0.4\n// time units a row the streaks hardly bent in 128 rows; at 1.25 they braid.\n//\n// Checked over 10,000 time units from the same start at delta 0:\n// - The energy, the mean of u^2, stays bounded: it averages 1.41 at L 22\n//   and 1.71 at L 66, and never passes 3.13.\n// - The fastest-growing wavelength is 2 pi sqrt 2, so a ring of length L\n//   should hold about L / 8.89 cells. Counting the positive humps of u\n//   (with a 0.4 dead band) gives 2.26 at L 22 against 2.48, 3.66 at 36\n//   against 4.05, 5.34 at 50 against 5.63 and 6.89 at 66 against 7.43:\n//   always 91 to 93 percent of it.\n// - 64 grid points resolve the ring up to L 66, where the highest mode\n//   never carries more than 0.65 percent of the largest. At L 100 it\n//   reached 21 percent, so the knob stops at 66.\nconst W = 64, H = 128, N = 64, STEP = 0.25, ROW = 1.25, RATE = 15, MC = 32, PRERUN = 100;\nconst { floor, exp, cos, sin, abs, round, random, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// A complex FFT of size 64: bit reversal, then six rounds of butterflies.\nconst BR = new Uint8Array(N), CS = new Float64Array(N / 2), SN = new Float64Array(N / 2);\nfor (let i = 0; i \u003c N; i++) {\n  let r = 0;\n  for (let b = 0, v = i; b \u003c 6; b++, v >>= 1) r = (r \u003c\u003c 1) | (v & 1);\n  BR[i] = r;\n}\nfor (let k = 0; k \u003c N / 2; k++) (CS[k] = cos((TAU * k) / N)), (SN[k] = sin((TAU * k) / N));\n\nfunction fft(re, im, sign) {\n  for (let i = 0; i \u003c N; i++) {\n    const j = BR[i];\n    if (j > i) {\n      let t = re[i];\n      re[i] = re[j];\n      re[j] = t;\n      t = im[i];\n      im[i] = im[j];\n      im[j] = t;\n    }\n  }\n  for (let size = 2; size \u003c= N; size \u003c\u003c= 1) {\n    const half = size >> 1, step = N / size;\n    for (let i = 0; i \u003c N; i += size)\n      for (let k = 0; k \u003c half; k++) {\n        const wr = CS[k * step], wi = sign * SN[k * step], a = i + k, b = a + half;\n        const tr = re[b] * wr - im[b] * wi, ti = re[b] * wi + im[b] * wr;\n        re[b] = re[a] - tr;\n        im[b] = im[a] - ti;\n        re[a] += tr;\n        im[a] += ti;\n      }\n  }\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  out[o + 1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  out[o + 2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n}\n\nconst f64 = () => new Float64Array(N);\n\nexport function setup(params) {\n  params.s = {\n    ready: false, hue: -1, speed: 2, L: -1, delta: NaN, acc: 0, head: 0,\n    vr: f64(), vi: f64(), g: f64(),\n    Er: f64(), Ei: f64(), E2r: f64(), E2i: f64(), Qr: f64(), Qi: f64(),\n    f1r: f64(), f1i: f64(), f2r: f64(), f2i: f64(), f3r: f64(), f3i: f64(),\n    ar: f64(), ai: f64(), br: f64(), bi: f64(), cr: f64(), ci: f64(),\n    Nvr: f64(), Nvi: f64(), Nar: f64(), Nai: f64(), Nbr: f64(), Nbi: f64(), Ncr: f64(), Nci: f64(),\n    tr: f64(), ti: f64(), u: f64(),\n    hist: new Float32Array(H * N), next: new Float32Array(N), lut: new Uint8Array(2 * 257 * 3),\n  };\n}\n\n// The ETDRK4 coefficients for ring length L and dispersion delta. Mode n\n// has wavenumber k = 2 pi n / L for n below 32 and 2 pi (n - 64) / L above;\n// the Nyquist mode, n = 32, gets the damping of its true wavenumber but no\n// share of the nonlinear term, as an odd derivative cannot be taken there.\nfunction coefficients(S) {\n  const { L, delta, g } = S;\n  for (let n = 0; n \u003c N; n++) {\n    const kk = (TAU * (n \u003c N / 2 ? n : n - N)) / L, kn = n === N / 2 ? (TAU * (N / 2)) / L : kk;\n    g[n] = n === N / 2 ? 0 : -0.5 * kk;\n    const zr = STEP * (kn * kn - kn * kn * kn * kn), zi = n === N / 2 ? 0 : STEP * delta * kk * kk * kk;\n    let em = exp(zr);\n    S.Er[n] = em * cos(zi);\n    S.Ei[n] = em * sin(zi);\n    em = exp(zr / 2);\n    S.E2r[n] = em * cos(zi / 2);\n    S.E2i[n] = em * sin(zi / 2);\n    let qr = 0, qi = 0, a1 = 0, b1 = 0, a2 = 0, b2 = 0, a3 = 0, b3 = 0;\n    for (let j = 0; j \u003c MC; j++) {\n      const th = (TAU * (j + 0.5)) / MC, lr = zr + cos(th), li = zi + sin(th);\n      const ex = exp(lr), er = ex * cos(li), ei = ex * sin(li);\n      const hx = exp(lr / 2), hr = hx * cos(li / 2), hi = hx * sin(li / 2);\n      const l2r = lr * lr - li * li, l2i = 2 * lr * li;\n      const l3r = l2r * lr - l2i * li, l3i = l2r * li + l2i * lr;\n      const d1 = lr * lr + li * li, d3 = l3r * l3r + l3i * l3i;\n      qr += ((hr - 1) * lr + hi * li) / d1;\n      qi += (hi * lr - (hr - 1) * li) / d1;\n      let pr = 4 - 3 * lr + l2r, pi = -3 * li + l2i;\n      let nr = -4 - lr + er * pr - ei * pi, ni = -li + er * pi + ei * pr;\n      a1 += (nr * l3r + ni * l3i) / d3;\n      b1 += (ni * l3r - nr * l3i) / d3;\n      pr = lr - 2;\n      pi = li;\n      nr = 2 + lr + er * pr - ei * pi;\n      ni = li + er * pi + ei * pr;\n      a2 += (nr * l3r + ni * l3i) / d3;\n      b2 += (ni * l3r - nr * l3i) / d3;\n      pr = 4 - lr;\n      pi = -li;\n      nr = -4 - 3 * lr - l2r + er * pr - ei * pi;\n      ni = -3 * li - l2i + er * pi + ei * pr;\n      a3 += (nr * l3r + ni * l3i) / d3;\n      b3 += (ni * l3r - nr * l3i) / d3;\n    }\n    const m = STEP / MC;\n    S.Qr[n] = qr * m;\n    S.Qi[n] = qi * m;\n    S.f1r[n] = a1 * m;\n    S.f1i[n] = b1 * m;\n    S.f2r[n] = a2 * m;\n    S.f2i[n] = b2 * m;\n    S.f3r[n] = a3 * m;\n    S.f3i[n] = b3 * m;\n  }\n}\n\n// N(v) = -(i k / 2) FFT(u^2), u the real part of the inverse FFT of v.\nfunction nonlinear(S, xr, xi, outr, outi) {\n  const { tr, ti, g } = S;\n  for (let n = 0; n \u003c N; n++) (tr[n] = xr[n]), (ti[n] = xi[n]);\n  fft(tr, ti, 1);\n  for (let j = 0; j \u003c N; j++) {\n    const u = tr[j] / N;\n    tr[j] = u * u;\n    ti[j] = 0;\n  }\n  fft(tr, ti, -1);\n  for (let n = 0; n \u003c N; n++) {\n    outr[n] = -g[n] * ti[n];\n    outi[n] = g[n] * tr[n];\n  }\n}\n\nfunction step(S) {\n  const { vr, vi, ar, ai, br, bi, cr, ci, Nvr, Nvi, Nar, Nai, Nbr, Nbi, Ncr, Nci, E2r, E2i, Qr, Qi } = S;\n  nonlinear(S, vr, vi, Nvr, Nvi);\n  for (let n = 0; n \u003c N; n++) {\n    ar[n] = E2r[n] * vr[n] - E2i[n] * vi[n] + Qr[n] * Nvr[n] - Qi[n] * Nvi[n];\n    ai[n] = E2r[n] * vi[n] + E2i[n] * vr[n] + Qr[n] * Nvi[n] + Qi[n] * Nvr[n];\n  }\n  nonlinear(S, ar, ai, Nar, Nai);\n  for (let n = 0; n \u003c N; n++) {\n    br[n] = E2r[n] * vr[n] - E2i[n] * vi[n] + Qr[n] * Nar[n] - Qi[n] * Nai[n];\n    bi[n] = E2r[n] * vi[n] + E2i[n] * vr[n] + Qr[n] * Nai[n] + Qi[n] * Nar[n];\n  }\n  nonlinear(S, br, bi, Nbr, Nbi);\n  for (let n = 0; n \u003c N; n++) {\n    const xr = 2 * Nbr[n] - Nvr[n], xi = 2 * Nbi[n] - Nvi[n];\n    cr[n] = E2r[n] * ar[n] - E2i[n] * ai[n] + Qr[n] * xr - Qi[n] * xi;\n    ci[n] = E2r[n] * ai[n] + E2i[n] * ar[n] + Qr[n] * xi + Qi[n] * xr;\n  }\n  nonlinear(S, cr, ci, Ncr, Nci);\n  const { Er, Ei, f1r, f1i, f2r, f2i, f3r, f3i } = S;\n  for (let n = 0; n \u003c N; n++) {\n    const sr = Nar[n] + Nbr[n], si = Nai[n] + Nbi[n];\n    const nr =\n      Er[n] * vr[n] - Ei[n] * vi[n] +\n      (Nvr[n] * f1r[n] - Nvi[n] * f1i[n]) + 2 * (sr * f2r[n] - si * f2i[n]) + (Ncr[n] * f3r[n] - Nci[n] * f3i[n]);\n    const ni =\n      Er[n] * vi[n] + Ei[n] * vr[n] +\n      (Nvr[n] * f1i[n] + Nvi[n] * f1r[n]) + 2 * (sr * f2i[n] + si * f2r[n]) + (Ncr[n] * f3i[n] + Nci[n] * f3r[n]);\n    vr[n] = nr;\n    vi[n] = ni;\n  }\n  // u is real, so v_(64-n) is the conjugate of v_n. Round-off breaks that,\n  // and the broken part is invisible to u^2, so nothing holds it down: it\n  // grew at the linear rate of modes 2 and 3, 0.19 a time unit at L = 22,\n  // and blew the run up at t = 340. Folding it back each step keeps it at 0.\n  for (let n = 1; n \u003c N / 2; n++) {\n    const a = 0.5 * (vr[n] + vr[N - n]), b = 0.5 * (vi[n] - vi[N - n]);\n    vr[n] = vr[N - n] = a;\n    vi[n] = b;\n    vi[N - n] = -b;\n  }\n  vr[0] = vi[0] = vi[N / 2] = 0;\n}\n\n// u on the 64 grid points, one per column.\nfunction physical(S, out) {\n  const { tr, ti } = S;\n  for (let n = 0; n \u003c N; n++) (tr[n] = S.vr[n]), (ti[n] = S.vi[n]);\n  fft(tr, ti, 1);\n  for (let j = 0; j \u003c N; j++) out[j] = tr[j] / N;\n}\n\nfunction advanceRow(S) {\n  for (let s = 0, n = round(ROW / STEP); s \u003c n; s++) step(S);\n}\n\n// The row just computed goes in at the head; `next` is one row ahead of it,\n// so the top of the panel can slide between the two.\nfunction pushRow(S) {\n  S.head = (S.head + H - 1) % H;\n  S.hist.set(S.next, S.head * N);\n  advanceRow(S);\n  physical(S, S.next);\n}\n\n// u is the slope of Sivashinsky's flame front, so a dent pushed into the\n// front shows in u as a dipole, up on one side and down on the other: the\n// derivative of a Gaussian, 4 columns wide, peaks of +-amp. It has no mean.\n// A plain bump had one, and taking it off shifted the whole row by 0.78,\n// a hard line straight across the diagram.\nfunction kick(S, x0, amp) {\n  const u = S.u;\n  physical(S, u);\n  for (let j = 0; j \u003c N; j++) {\n    let d = j - x0;\n    if (d > N / 2) d -= N;\n    if (d \u003c -N / 2) d += N;\n    const q = d / 4;\n    S.tr[j] = u[j] + amp * 1.6487 * q * exp(-0.5 * q * q);\n    S.ti[j] = 0;\n  }\n  fft(S.tr, S.ti, -1);\n  for (let n = 0; n \u003c N; n++) (S.vr[n] = S.tr[n]), (S.vi[n] = S.ti[n]);\n  S.vr[0] = S.vi[0] = 0;\n}\n\nfunction start(S) {\n  // Low modes with random phases, then PRERUN time units so the first\n  // frame is already chaos, then a full panel of history.\n  for (let n = 0; n \u003c N; n++) S.vr[n] = S.vi[n] = 0;\n  for (let n = 1; n \u003c= 6; n++) {\n    const ph = random() * TAU, a = (0.3 * N) / n;\n    S.vr[n] = a * cos(ph);\n    S.vi[n] = a * sin(ph);\n    S.vr[N - n] = a * cos(ph);\n    S.vi[N - n] = -a * sin(ph);\n  }\n  for (let s = 0, n = round(PRERUN / STEP); s \u003c n; s++) step(S);\n  physical(S, S.next);\n  for (let r = 0; r \u003c H; r++) pushRow(S);\n  S.ready = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 22, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const L = cl(k[2], 22, 66), delta = cl(k[3], -1, 1);\n  if (L !== S.L || delta !== S.delta) {\n    S.L = L;\n    S.delta = delta;\n    coefficients(S);\n  }\n  if (!S.ready) start(S);\n  if (input.btnPressed && input.btnPressed[0]) kick(S, random() * N, 4);\n  S.acc += d * S.speed * RATE;\n  // 30 rows a second at 30 frames lands on 0.9999...; a hair of slack\n  // keeps it one row a frame instead of none and then two.\n  while (S.acc >= 1 - 1e-6) {\n    S.acc = Math.max(0, S.acc - 1);\n    pushRow(S);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const lut = S.lut;\n  if (S.lutHue !== S.hue) {\n    // Two ramps of 257 steps, positive u then negative: black at zero,\n    // rising straight to full colour at |u| = 2.64, then paling to a tint at\n    // 3.3. A straight ramp keeps the steps between neighbours soft; the\n    // first, steeper ramp put a hard step on 23 percent of them.\n    for (let side = 0; side \u003c 2; side++) {\n      const h = S.hue + (side === 0 ? 0.5 : 0.86);\n      for (let i = 0; i \u003c= 256; i++) {\n        const a = i / 256, f = cl(a / 0.8, 0, 1), w = cl((a - 0.8) / 0.2, 0, 1);\n        hsv(h + 0.05 * (f - 1), 1 - 0.55 * w, f, lut, (side * 257 + i) * 3);\n      }\n    }\n    S.lutHue = S.hue;\n  }\n  // Pulses grow with the dispersion, |u| up to 3.5 at delta 0 and 4.7 at\n  // delta 1, so the map stretches with it and the pulses do not wash out pale.\n  const { hist, next, head, acc } = S, inv = 256 / (3.3 * (1 + 0.4 * abs(S.delta)));\n  for (let y = 0; y \u003c H; y++) {\n    // Display row y is `acc` of the way from history row y - 1 to row y,\n    // where row -1 is the one computed ahead.\n    const a = y - acc, r0 = floor(a), t = a - r0;\n    const A = r0 \u003c 0 ? next : null, o0 = ((head + r0 + H) % H) * N, o1 = ((head + r0 + 1) % H) * N;\n    for (let x = 0; x \u003c W; x++) {\n      const u0 = A ? A[x] : hist[o0 + x], u1 = r0 + 1 \u003c H ? hist[o1 + x] : u0;\n      const u = u0 + (u1 - u0) * t, i = Math.min(256, round(abs(u) * inv)), o = ((u \u003c 0 ? 257 : 0) + i) * 3;\n      display.setPixel(x, y, lut[o], lut[o + 1], lut[o + 2]);\n    }\n  }\n}\n","plait":"// ===== Patternflow pattern =====\n// Title:   Plait\n// Family:  textile\n// Idea:    Coloured strands hang from a clip and are plaited down the panel, the outside strand crossing over to the middle each time, until the plait is tied off with a ribbon and lowered away, and the next clip of loose strands comes down.\n// Author:  patternflow-lab\n// Date:    2026-10-23\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 13\n// Round:   15\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Tension=0..1\n//\n// Knob 1: Hue. Turns the strands' colours together, starting from teal, blue and magenta.\n// Knob 2: Speed. How fast the hands work: at 2 the plait grows by 1.2 rows of crossings a second, at 3 by nearly two, at 0.2 by one every eight seconds.\n// Knob 3: Strands. 3 is the plait everyone knows; 4 to 7 make a flat braid, each outside strand weaving over and under all the way to the far edge.\n// Knob 4: Tension. At 0 the plait is loose and fat, 54 LEDs across with three strands crossing every 17 rows; at 1 it is pulled tight to 34 LEDs, crossing every 6 or 7.\n// Buttons: K1 tap ties the plait off with a ribbon where it has got to, long tails and all; it is lowered away and a new one starts.\n\nconst W = 64;\nconst H = 128;\nconst MAXN = 7;\n// The clip holds the strands at rows 1..6; the plait starts under it.\nconst CLIP = 7;\n// The plait is tied once its point gets this far down.\nconst TIE_AT = 100;\n// Seconds a tied plait hangs, and the seconds it takes to lower it away.\nconst HANG = 1.6;\nconst LOWER = 1.4;\n// Crossings a second at Speed 1.\nconst RATE = 0.6;\n// A tied plait is pinched to this share of its width at the ribbon.\nconst GATHER = 0.4;\n\nfunction hsvInto(out, o, h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[o] = (k === 0 || k === 5 ? v : k === 1 ? q : k === 4 ? t : p) * 255;\n  out[o + 1] = (k === 1 || k === 2 ? v : k === 0 ? t : k === 3 ? q : p) * 255;\n  out[o + 2] = (k === 3 || k === 4 ? v : k === 2 ? t : k === 5 ? q : p) * 255;\n}\n\nfunction smooth(a, b, v) {\n  const t = Math.max(0, Math.min(1, (v - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n}\n\n// A strand's lane on a cycle of 2N steps: it walks one lane a step from the\n// left edge to the right, waits a step there, walks back and waits again.\n// Spaced two steps apart, N strands always fill the N lanes, and between two\n// whole steps a strand walking right swaps lanes with one walking left.\nfunction laneAt(q, n) {\n  if (q \u003c= n - 1) return q;\n  if (q \u003c= n) return n - 1;\n  if (q \u003c= 2 * n - 1) return 2 * n - 1 - q;\n  return 0;\n}\n\n// The integral of laneAt, so the lane can be averaged over one step and the\n// strand turns round at the edges instead of folding.\nfunction laneInt(q, n) {\n  const c = 2 * n;\n  const m = n - 1;\n  const total = m * m + m;\n  const k = Math.floor(q / c);\n  const r = q - k * c;\n  let f;\n  if (r \u003c= m) f = (r * r) / 2;\n  else if (r \u003c= n) f = (m * m) / 2 + m * (r - m);\n  else if (r \u003c= 2 * n - 1) f = (m * m) / 2 + m + (2 * n - 1) * (r - n) - (r * r - n * n) / 2;\n  else f = total;\n  return k * total + f;\n}\n\n// Lane, its slope in lanes per step, and depth for strand k at step t.\n// Crossings fall on half steps. At a crossing after an even step the strand\n// walking right is on top, after an odd step the one walking left, so every\n// strand goes over, under, over, and for three strands the outside strand\n// always crosses over the middle one.\nfunction strandAt(k, t, n, out) {\n  const c = 2 * n;\n  const q = 2 * k + t;\n  out[0] = laneInt(q + 0.5, n) - laneInt(q - 0.5, n);\n  const qa = (((q + 0.5) % c) + c) % c;\n  const qb = (((q - 0.5) % c) + c) % c;\n  out[1] = laneAt(qa, n) - laneAt(qb, n);\n  const r = ((q % c) + c) % c;\n  const wave = Math.cos(Math.PI * (t - 0.5));\n  out[2] = r \u003c n - 1 ? wave : r >= n && r \u003c 2 * n - 1 ? -wave : 0;\n}\n\nexport function setup(params) {\n  params.t = 0;\n  params.phase = 0; // 0 plaiting, 1 tied and hanging, 2 lowered away\n  params.timer = 0;\n  params.tiedT = 0;\n  params.started = false;\n  params.n = 3;\n  params.hue = 0;\n  params.speed = 2;\n  params.tension = 0.06;\n  // Each strand's centre row by row: x, depth, the nudge from a row to the\n  // nearest point (slope / (1 + slope^2)) and radius, radius 0 where the strand\n  // is absent; lo..hi is the span of LEDs it can reach in that row.\n  params.cx = new Float32Array(MAXN * H);\n  params.cz = new Float32Array(MAXN * H);\n  params.cs = new Float32Array(MAXN * H);\n  params.cr = new Float32Array(MAXN * H);\n  params.lo = new Float32Array(MAXN * H);\n  params.hi = new Float32Array(MAXN * H);\n  params.dist = new Float32Array(MAXN);\n  params.surf = new Float32Array(MAXN);\n  params.col = new Float32Array(MAXN * 3 + 3);\n  params.tmp = new Float32Array(3);\n  params.img = new Float32Array(W * H * 3);\n  params.out = new Float32Array(W * H * 3);\n  // The tied plait and the next one, drawn once each while one replaces the other.\n  params.old = new Float32Array(W * H * 3);\n  params.next = new Float32Array(W * H * 3);\n  params.valid = 0;\n  params.cn = -1;\n  params.zbuf = new Float32Array(W * H);\n}\n\n// The plait's shape for the current knobs.\nfunction geometry(params) {\n  const n = params.n;\n  const tension = params.tension;\n  // Half the plait's width, from 27 LEDs loose to 17 tight.\n  const half = 27 - 10 * tension;\n  const lane = (2 * half) / (n - 1 + 1.4);\n  return {\n    n: n,\n    lane: lane,\n    radius: lane * 0.7,\n    step: lane * (1.1 - 0.45 * tension),\n    spread: (W - 4 - 1.4 * lane * 0.7) / (n - 1),\n  };\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  dt = Math.min(dt, 0.1);\n  params.hue = k[0];\n  params.speed = Math.max(0.05, k[1]);\n  params.n = Math.max(3, Math.min(MAXN, Math.round(k[2])));\n  params.tension = Math.max(0, Math.min(1, k[3]));\n  const g = geometry(params);\n  if (!params.started) {\n    params.started = true;\n    // Start part way down, so the first frame already shows a plait.\n    params.t = (44 - CLIP) / g.step;\n  }\n  if (input.btnPressed && input.btnPressed[0] && params.phase === 0) {\n    params.phase = 1;\n    params.timer = 0;\n  }\n  if (params.phase === 0) {\n    params.t += dt * params.speed * RATE;\n    if (CLIP + params.t * g.step >= TIE_AT) {\n      params.phase = 1;\n      params.timer = 0;\n    }\n  } else if (params.phase === 1) {\n    params.timer += dt;\n    if (params.timer > HANG) {\n      params.phase = 2;\n      params.timer = 0;\n      params.tiedT = params.t;\n      params.t = 0;\n    }\n  } else {\n    params.timer += dt;\n    if (params.timer > LOWER) {\n      params.phase = 0;\n      params.timer = 0;\n    }\n  }\n}\n\n// Lay out each strand's centre line, row by row, for a plait whose point is at\n// step tp, its clip shifted down by off rows; tied (0..1) is how far the\n// ribbon has pulled its end in.\nfunction layout(params, g, tp, off, tied) {\n  const n = g.n;\n  const mid = W / 2;\n  const tmp = params.tmp;\n  const cx = params.cx;\n  const cz = params.cz;\n  const cs = params.cs;\n  const cr = params.cr;\n  const depth = g.radius * 0.9;\n  const yp = CLIP + tp * g.step;\n  // The tails get shorter as the plait uses up the strands.\n  const prog = Math.min(1, (yp - CLIP) / (TIE_AT - CLIP));\n  const tailEnd = yp + (H - 1 - CLIP) * (1 - prog) + (20 - 4 * tied) * prog;\n  const reach = 26 - 16 * tied;\n  for (let k = 0; k \u003c n; k++) {\n    // Where the strand leaves the plait, which way it is going there, and how\n    // deep it lies: it keeps that depth all the way down, so a strand crossing\n    // over stays over to the hand.\n    strandAt(k, tp, n, tmp);\n    const c0 = tmp[0] - (n - 1) / 2;\n    const pinch = 1 - (1 - GATHER) * tied;\n    const x0 = mid + c0 * g.lane * pinch;\n    const s0 = ((1 - tied) * tmp[1] * g.lane) / g.step;\n    const z0 = tmp[2] * depth + k * 0.01;\n    const x1 = (x0 + c0 * 4) * tied + (mid + c0 * g.spread) * (1 - tied);\n    for (let y = 0; y \u003c H; y++) {\n      const i = k * H + y;\n      const yy = y + 0.5 - off;\n      cr[i] = 0;\n      if (yy \u003c 2) continue;\n      let sl = 0;\n      if (yy \u003c CLIP) {\n        // Under the clip the strands come straight down.\n        strandAt(k, 0, n, tmp);\n        cx[i] = mid + (tmp[0] - (n - 1) / 2) * g.lane;\n        cz[i] = -depth;\n        cr[i] = g.radius;\n      } else if (yy \u003c= yp) {\n        strandAt(k, (yy - CLIP) / g.step, n, tmp);\n        // A tied plait is gathered in to the ribbon over its last 14 rows.\n        const gather = 1 - (1 - GATHER) * tied * smooth(yp - 14, yp, yy);\n        cx[i] = mid + (tmp[0] - (n - 1) / 2) * g.lane * gather;\n        cz[i] = tmp[2] * depth;\n        sl = (tmp[1] * g.lane * gather) / g.step;\n        cr[i] = g.radius;\n      } else if (yy \u003c tailEnd) {\n        // Below the point a loose strand leaves the way it was going and bends\n        // down to the hand holding it; a tied plait's tails splay a little.\n        const u = Math.min(1, (yy - yp) / reach);\n        const u2 = u * u;\n        const u3 = u2 * u;\n        cx[i] = (2 * u3 - 3 * u2 + 1) * x0 + (u3 - 2 * u2 + u) * reach * s0 + (3 * u2 - 2 * u3) * x1;\n        sl = u \u003c 1 ? ((6 * u2 - 6 * u) * x0 + (3 * u2 - 4 * u + 1) * reach * s0 + (6 * u - 6 * u2) * x1) / reach : 0;\n        cz[i] = z0;\n        // A strand thins to its tip over the last eight rows.\n        const tip = Math.min(1, (tailEnd - yy) / 8);\n        cr[i] = g.radius * (1 - 0.25 * tied) * (0.45 + 0.55 * Math.sqrt(tip));\n      }\n      cs[i] = sl / (1 + sl * sl);\n    }\n  }\n  // The span of LEDs each strand can touch in each row: an LED within the\n  // radius of a strand finds its nearest point at most half a radius up or down.\n  const lo = params.lo;\n  const hi = params.hi;\n  const rows = Math.ceil(g.radius / 2 + 2);\n  for (let k = 0; k \u003c n; k++)\n    for (let y = 0; y \u003c H; y++) {\n      let a = 1e9;\n      let b = -1e9;\n      const j1 = Math.min(H - 1, y + rows);\n      for (let j = Math.max(0, y - rows); j \u003c= j1; j++) {\n        const i = k * H + j;\n        if (cr[i] === 0) continue;\n        if (cx[i] - cr[i] \u003c a) a = cx[i] - cr[i];\n        if (cx[i] + cr[i] > b) b = cx[i] + cr[i];\n      }\n      lo[k * H + y] = a - 2.5;\n      hi[k * H + y] = b + 2.5;\n    }\n}\n\n// Render the laid-out strands into img and zbuf from row y0 down. For each LED\n// and strand, step from the LED's row\n// along the strand's slope to the nearest point of its centre line, so where\n// one strand dives under another the edge follows the strand and not the row.\nfunction render(params, g, y0) {\n  const n = g.n;\n  const cx = params.cx;\n  const cz = params.cz;\n  const cs = params.cs;\n  const cr = params.cr;\n  const lo = params.lo;\n  const hi = params.hi;\n  const col = params.col;\n  const img = params.img;\n  const zbuf = params.zbuf;\n  const dist = params.dist;\n  const surf = params.surf;\n  const depth = g.radius * 0.9;\n  const hl = Math.sqrt(0.45 * 0.45 + 0.5 * 0.5 + 1.74 * 1.74);\n  for (let y = y0; y \u003c H; y++) {\n    const py = y + 0.5;\n    let xa = 1e9;\n    let xb = -1e9;\n    for (let k = 0; k \u003c n; k++) {\n      if (lo[k * H + y] \u003c xa) xa = lo[k * H + y];\n      if (hi[k * H + y] > xb) xb = hi[k * H + y];\n    }\n    xa = Math.max(0, Math.floor(xa));\n    xb = Math.min(W - 1, Math.ceil(xb));\n    for (let x = xa; x \u003c= xb; x++) {\n      const p = y * W + x;\n      const px = x + 0.5;\n      let best = -1e9;\n      let bk = -1;\n      let bnx = 0;\n      let bny = 0;\n      let bz = 0;\n      let bcov = 0;\n      for (let k = 0; k \u003c n; k++) {\n        const i0 = k * H + y;\n        dist[k] = 1e9;\n        if (px \u003c lo[i0] || px > hi[i0]) continue;\n        let ys = cr[i0] > 0 ? py + (px - cx[i0]) * cs[i0] : py;\n        if (ys \u003c 0.5) ys = 0.5;\n        else if (ys > H - 1.5) ys = H - 1.5;\n        const ya = Math.floor(ys - 0.5);\n        const f = ys - 0.5 - ya;\n        const ia = k * H + ya;\n        const ra = cr[ia];\n        const rb = cr[ia + 1];\n        let xs;\n        let zs;\n        let rs;\n        if (rb === 0) {\n          if (ra === 0) continue;\n          xs = cx[ia];\n          zs = cz[ia];\n          rs = ra;\n          ys = ya + 0.5;\n        } else if (ra === 0) {\n          xs = cx[ia + 1];\n          zs = cz[ia + 1];\n          rs = rb;\n          ys = ya + 1.5;\n        } else {\n          xs = cx[ia] + (cx[ia + 1] - cx[ia]) * f;\n          zs = cz[ia] + (cz[ia + 1] - cz[ia]) * f;\n          rs = ra + (rb - ra) * f;\n        }\n        const dx = px - xs;\n        const dy = py - ys;\n        const d2 = dx * dx + dy * dy;\n        if (d2 > (rs + 2) * (rs + 2)) continue;\n        const d = Math.sqrt(d2);\n        dist[k] = d - rs;\n        if (d >= rs) {\n          surf[k] = zs;\n          if (d \u003c rs + 0.5 && zs > best) {\n            best = zs;\n            bk = k;\n            bnx = dx / d;\n            bny = dy / d;\n            bz = zs / depth;\n            bcov = rs + 0.5 - d;\n          }\n          continue;\n        }\n        surf[k] = zs + Math.sqrt(rs * rs - d * d);\n        if (surf[k] > best) {\n          best = surf[k];\n          bk = k;\n          bnx = dx / rs;\n          bny = dy / rs;\n          bz = zs / depth;\n          bcov = Math.min(1, rs + 0.5 - d);\n        }\n      }\n      if (bk \u003c 0) continue;\n      // A strand lying over this one darkens the LEDs just outside its edge,\n      // so a strand going under reads as tucked in.\n      let shade = 1;\n      for (let k = 0; k \u003c n; k++) {\n        if (k === bk || dist[k] > 2 || dist[k] \u003c -0.5) continue;\n        if (surf[k] > best - 1) shade = Math.min(shade, 0.12 + 0.88 * smooth(0, 2, dist[k]));\n      }\n      const nn = Math.min(1, bnx * bnx + bny * bny);\n      const nz = Math.sqrt(1 - nn);\n      // Light from the upper left and in front.\n      // The square root flattens the lit middle of a strand and keeps its\n      // fall-off for the rim, so it reads as round without a smear of greys.\n      const diff = Math.sqrt(Math.max(0, -0.45 * bnx - 0.5 * bny + 0.74 * nz));\n      let sp = Math.max(0, (-0.45 * bnx - 0.5 * bny + 1.74 * nz) / hl);\n      sp *= sp;\n      sp *= sp;\n      sp *= sp;\n      sp *= sp;\n      // Under, a strand is dimmer; over, it is lit full. The floor stays high\n      // enough that an orange strand going under does not turn brown.\n      const lit = (0.56 + 0.44 * (0.5 + 0.5 * bz)) * shade;\n      const v = lit * (0.14 + 0.86 * diff);\n      const spec = sp * 0.5 * lit * 255;\n      const c = bk * 3;\n      const o = p * 3;\n      img[o] = img[o] * (1 - bcov) + Math.min(255, col[c] * v + spec) * bcov;\n      img[o + 1] = img[o + 1] * (1 - bcov) + Math.min(255, col[c + 1] * v + spec) * bcov;\n      img[o + 2] = img[o + 2] * (1 - bcov) + Math.min(255, col[c + 2] * v + spec) * bcov;\n      zbuf[p] = best;\n    }\n  }\n}\n\n// A ribbon tied in a bow round the plait at row yp, grown to size (0..1):\n// a band round the gathered strands, two loops, a knot and two tails cut in a fork.\nfunction ribbon(img, params, yp, band, size) {\n  if (size \u003c= 0) return;\n  const col = params.col;\n  const c = MAXN * 3;\n  const cx = W / 2;\n  const lw = 12 * size;\n  const lh = 6 * size;\n  const ca = Math.cos(0.42);\n  const sa = Math.sin(0.42);\n  for (let y = Math.max(0, Math.floor(yp - 14)); y \u003c Math.min(H, yp + 20); y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5 - cx;\n      const py = y + 0.5 - yp;\n      let v = 0;\n      // The band round the plait.\n      if (Math.abs(py) \u003c 1.8 && Math.abs(px) \u003c band * size) v = 0.85 - 0.12 * Math.max(0, py);\n      // The loops, tilted up and out, with a fold darker along the middle.\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const lx = s * px - lw * 0.55;\n        const ly = py + 2.5 * size;\n        const u = (lx * ca + ly * sa) / lw;\n        const w = (-lx * sa + ly * ca) / lh;\n        const e = (u * u) / 0.3 + w * w;\n        if (e \u003c 1) v = Math.max(v, Math.abs(w) \u003c 0.18 && u > -0.2 ? 0.72 : 1 - 0.18 * e);\n      }\n      // The tails, hanging down and out from the knot, forked at the end.\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const along = py / size;\n        const off = s * px - (1.5 + py * 0.42);\n        if (along > 0 && along \u003c 15 && Math.abs(off) \u003c 2.4 && !(along > 12 && Math.abs(off) \u003c (along - 12) * 0.9)) v = Math.max(v, 0.95 - 0.2 * (along / 15));\n      }\n      // The knot.\n      const kr = px * px + (py + 0.3) * (py + 0.3);\n      if (kr \u003c 10 * size * size) v = Math.max(v, 1);\n      else if (kr \u003c 14 * size * size) v = Math.min(v, 0.75);\n      if (v \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      img[o] = col[c] * v;\n      img[o + 1] = col[c + 1] * v;\n      img[o + 2] = col[c + 2] * v;\n    }\n}\n\n// The clip at the top, a rounded silver bar a little wider than the plait,\n// shifted down by off rows, drawn from row y0 down.\nfunction clip(params, half, off, y0) {\n  const img = params.img;\n  for (let j = 1; j \u003c CLIP; j++) {\n    const y = j + Math.round(off);\n    if (y \u003c y0 || y >= H) continue;\n    const u = (j + 0.5 - (CLIP + 1) / 2) / ((CLIP - 1) / 2);\n    const v = 0.35 + 0.65 * Math.sqrt(Math.max(0, 1 - u * u)) + (Math.abs(u + 0.35) \u003c 0.3 ? 0.25 : 0);\n    for (let x = 0; x \u003c W; x++) {\n      const ex = Math.abs(x + 0.5 - W / 2) - (half + 2);\n      if (ex > 1) continue;\n      const a = Math.max(0, Math.min(1, 1 - ex)) * (j === 1 || j === CLIP - 1 ? 0.75 : 1);\n      const o = (y * W + x) * 3;\n      img[o] = img[o] * (1 - a) + Math.min(255, 215 * v) * a;\n      img[o + 1] = img[o + 1] * (1 - a) + Math.min(255, 220 * v) * a;\n      img[o + 2] = img[o + 2] * (1 - a) + Math.min(255, 232 * v) * a;\n    }\n  }\n}\n\n// Copy src into out moved down by off rows, blending neighbouring rows for the\n// fraction. On top, src covers out where it is lit and lets it through where dark.\nfunction slide(out, src, off, top) {\n  const fo = Math.floor(off);\n  const fr = off - fo;\n  for (let y = 0; y \u003c H; y++) {\n    const ya = y - fo;\n    const yb = ya - 1;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let r = 0;\n      let g = 0;\n      let b = 0;\n      let cov = 0;\n      if (ya >= 0 && ya \u003c H) {\n        const a = (ya * W + x) * 3;\n        r += src[a] * (1 - fr);\n        g += src[a + 1] * (1 - fr);\n        b += src[a + 2] * (1 - fr);\n        if (src[a] + src[a + 1] + src[a + 2] > 0) cov += 1 - fr;\n      }\n      if (yb >= 0 && yb \u003c H) {\n        const a = (yb * W + x) * 3;\n        r += src[a] * fr;\n        g += src[a + 1] * fr;\n        b += src[a + 2] * fr;\n        if (src[a] + src[a + 1] + src[a + 2] > 0) cov += fr;\n      }\n      if (!top) cov = 1;\n      out[o] = r + out[o] * (1 - cov);\n      out[o + 1] = g + out[o + 1] * (1 - cov);\n      out[o + 2] = b + out[o + 2] * (1 - cov);\n    }\n  }\n}\n\nexport function draw(display, params, time) {\n  const g = geometry(params);\n  const col = params.col;\n  const hue = params.hue + 0.47;\n  const fan = (0.62 * (g.n - 1)) / g.n;\n  for (let k = 0; k \u003c g.n; k++) hsvInto(col, k * 3, hue + (k * 0.62) / g.n, 0.78, 1);\n  // The ribbon takes the colour in the middle of the gap the strands leave on the wheel.\n  hsvInto(col, MAXN * 3, hue + fan + (1 - fan) / 2 - 0.04, 0.68, 1);\n  const half = ((g.n - 1) * g.lane) / 2 + g.radius;\n  // Half the width of the gathered end, where the ribbon's band goes round.\n  const band = ((g.n - 1) * g.lane * GATHER) / 2 + g.radius * 0.9;\n  const img = params.img;\n  const zbuf = params.zbuf;\n  const phase = params.phase;\n  // While the knobs stay put, the plait above its point does not change, so\n  // the rows that were finished last frame are kept and only the rest drawn.\n  const same = params.cn === g.n && params.ct === params.tension && params.ch === params.hue && params.cp === phase;\n  let y0 = same ? params.valid : 0;\n  params.cn = g.n;\n  params.ct = params.tension;\n  params.ch = params.hue;\n  params.cp = phase;\n  let out = img;\n  if (phase === 2) {\n    // The tied plait is lowered out of sight on its clip and the next clip of\n    // loose strands comes down after it. Neither changes shape on the way, so\n    // each is drawn once and slid down a fraction of a row at a time.\n    if (!same) {\n      img.fill(0);\n      zbuf.fill(-1e9);\n      layout(params, g, params.tiedT, 0, 1);\n      render(params, g, 0);\n      clip(params, half, 0, 0);\n      ribbon(img, params, CLIP + params.tiedT * g.step, band, 1);\n      params.old.set(img);\n      img.fill(0);\n      zbuf.fill(-1e9);\n      layout(params, g, 0, 0, 0);\n      render(params, g, 0);\n      clip(params, half, 0, 0);\n      params.next.set(img);\n    }\n    const off = smooth(0, 1, params.timer / LOWER) * (H + 4);\n    out = params.out;\n    slide(out, params.next, off - H - 4, false);\n    slide(out, params.old, off, true);\n    params.valid = 0;\n  } else {\n    img.fill(0, y0 * W * 3);\n    zbuf.fill(-1e9, y0 * W);\n    const yp = CLIP + params.t * g.step;\n    if (y0 \u003c H) {\n      layout(params, g, params.t, 0, phase === 1 ? smooth(0, 0.35, params.timer) : 0);\n      render(params, g, y0);\n      clip(params, half, 0, y0);\n    }\n    // A hanging plait is still; a growing one is settled down to a radius above its point.\n    params.valid = phase === 1 ? (params.timer > 0.4 ? H : Math.floor(yp - 20 - g.radius)) : Math.max(0, Math.floor(yp - g.radius - 4));\n    if (phase === 1) {\n      out = params.out;\n      out.set(img);\n      ribbon(out, params, yp, band, smooth(0, 0.35, params.timer));\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      if (out[o] + out[o + 1] + out[o + 2] \u003c 1) continue;\n      display.setPixel(x, y, out[o], out[o + 1], out[o + 2]);\n    }\n}\n","domain-warp":"// ===== Patternflow pattern =====\n// Title:   Domain Warp\n// Family:  noise\n// Idea:    Noise that is pushed around by its own noise twice over stops looking like noise and starts looking like stone being poured.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// ===============================\n// @matrix 64x128\n// @knobs Cycle=0..1, Speed=0..5, Warp=1..6, Zoom=0.035..0.095\n// @ramp oklab wrap 0:#05030f 0.16:#0e1450 0.22:#2a7ac0 0.27:#100c44 0.5:#2c1478 0.62:#c83888 0.68:#ffd890 0.74:#ff6a3a 0.84:#4a0a3a 1:#05030f\n//\n// Knob 1: Cycle. Slides the palette through the stone, so the gold veins move onto other contours; one turn comes back.\n// Knob 2: Speed. How fast the marble pours; 0 holds it still.\n// Knob 3: Warp. How hard the noise is folded into itself, from loose marble to tight swirls.\n// Knob 4: Zoom. Size of the stone; low is a few big swirls, high is fine grain.\n\n// The noise is built once into a tileable texture, so each stage of the\n// warp is one lookup instead of four octaves of noise.\nconst N = 128;\n\nfunction hash(x, y, s) {\n  let h = Math.imul(x, 374761393) + Math.imul(y, 668265263) + Math.imul(s, 2147483647);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\n\nfunction fade(t) {\n  return t * t * t * (t * (t * 6 - 15) + 10);\n}\n\nfunction tap(tex, u, v) {\n  const fu = Math.floor(u);\n  const fv = Math.floor(v);\n  const x0 = fu & (N - 1);\n  const y0 = fv & (N - 1);\n  const x1 = (x0 + 1) & (N - 1);\n  const y1 = (y0 + 1) & (N - 1);\n  const tx = u - fu;\n  const ty = v - fv;\n  const a = tex[y0 * N + x0];\n  const b = tex[y0 * N + x1];\n  const c = tex[y1 * N + x0];\n  const d = tex[y1 * N + x1];\n  return a + (b - a) * tx + (c - a) * ty + (a - b - c + d) * tx * ty;\n}\n\nexport function setup(params) {\n  const tex = new Float32Array(N * N);\n  let amp = 1;\n  for (let o = 0; o \u003c 4; o++) {\n    const cells = 4 \u003c\u003c o;\n    const size = N / cells;\n    for (let y = 0; y \u003c N; y++) {\n      const gy = Math.floor(y / size);\n      const fy = fade(y / size - gy);\n      for (let x = 0; x \u003c N; x++) {\n        const gx = Math.floor(x / size);\n        const fx = fade(x / size - gx);\n        const x1 = (gx + 1) % cells;\n        const y1 = (gy + 1) % cells;\n        const a = hash(gx, gy, o);\n        const b = hash(x1, gy, o);\n        const c = hash(gx, y1, o);\n        const d = hash(x1, y1, o);\n        const top = a + (b - a) * fx;\n        const bottom = c + (d - c) * fx;\n        tex[y * N + x] += (top + (bottom - top) * fy) * amp;\n      }\n    }\n    amp *= 0.5;\n  }\n  let lo = Infinity;\n  let hi = -Infinity;\n  for (let i = 0; i \u003c tex.length; i++) {\n    lo = Math.min(lo, tex[i]);\n    hi = Math.max(hi, tex[i]);\n  }\n  for (let i = 0; i \u003c tex.length; i++) tex[i] = (tex[i] - lo) / (hi - lo);\n  params.tex = tex;\n  params.clock = 0;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 1, 0.06];\n  params.colour = k[0];\n  params.speed = k[1];\n  params.warp = k[2];\n  params.zoom = k[3];\n  params.clock += dt * params.speed * 0.4;\n}\n\nexport function draw(display, params, time) {\n  const tex = params.tex;\n  const w = display.width;\n  const h = display.height;\n  const t = params.clock;\n  // Texels per LED; the texture's coarsest noise cell is 32 texels wide.\n  const s = params.zoom * 12;\n  const amount = 36 + (params.warp - 1) * 5.5;\n  const ox = t * 3.1;\n  const oy = t * 1.7;\n  for (let y = 0; y \u003c h; y++) {\n    for (let x = 0; x \u003c w; x++) {\n      const px = (x - w / 2) * s + 64 + t * 1.3;\n      const py = (y - h / 2) * s + 64 + t * 0.4;\n      const qx = tap(tex, px + ox, py) - 0.5;\n      const qy = tap(tex, px + 41.3, py + 17.9 - oy) - 0.5;\n      const rx = tap(tex, px + amount * qx + 23.7 - oy, py + amount * qy + 91.1) - 0.5;\n      const ry = tap(tex, px + amount * qx + 77.2, py + amount * qy + 5.3 + ox * 0.6) - 0.5;\n      const f = tap(tex, px + amount * rx, py + amount * ry);\n      let v = f * 3 + params.colour;\n      v -= Math.floor(v);\n      display.setValue(x, y, v);\n    }\n  }\n}\n","heawood-torus":"// ===== Patternflow pattern =====\n// Title:   Heawood Torus\n// Family:  topology\n// Idea:    A tall torus turns and leans in front of you painted with Heawood's map of seven hexagonal countries, each of which touches all six others, so this map needs seven colours where a map on the sphere never needs more than four.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Heawood's seven-colour map on the torus (Percy Heawood, 1890), pattern round 36\n// Round:   36\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hole=0..1, Tilt=0..1\n//\n// Knob 1: Hue. Turns the seven colours round the wheel together, a seventh apart. At 0 they are orange, lime, green, cyan, blue, violet and pink; every seventh of the way round the same seven come back, each moved on to another country, and halfway between, at 0.07, 0.21 and so on, one of them is pure red.\n// Knob 2: Speed. How fast the torus turns about its long axis. At 2 a turn takes 16 s, so it goes from face-on to edge-on in 4 s, and its lean nods 3 degrees each way every 29 s; at 0.2 everything is ten times slower, at 3 a turn takes 10 s.\n// Knob 3: Hole. The tube's radius against the radius of the curve it runs round, the torus keeping its width, 59 LEDs at the opening tilt. At 0 it is 0.85: the tube is 27 LEDs thick and the hole a slot 5 LEDs wide and 65 tall; at 0.5 the tube is 23 thick and the hole 14 wide; at 1 it is 0.4, a 17 LED tube round a hole 25 wide and 86 tall.\n// Knob 4: Tilt. How far the top of the torus leans toward you: 8 degrees at 0.06, so you look almost straight at its side, 23 at 0.5 and 40 at 1, where you look down into the hole and see the top bend from above.\n// Buttons: K1 tap draws, for six seconds, the capital of each country and the 21 roads between them in white: the complete graph on seven points, drawn on the torus with no two roads crossing, each road crossing one border. Tapping again while they show keeps them up.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sin, cos, abs, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\n\n// The plane tiled by hexagons, the hexagon at axial (a, b) coloured\n// (a + 3b) mod 7. Its six neighbours sit at (+-1, 0), (0, +-1) and\n// +-(1, -1), so their colours differ from its own by +-1, +-3 and +-2: all\n// six other colours, once each. The colouring repeats on the lattice L of\n// (a, b) with a + 3b = 0 mod 7, which has index 7, so the torus plane / L\n// holds exactly one hexagon of each colour, and each touches the other six.\n// L is spanned by E1 = (2, -3) and E2 = (1, 2) (determinant 7); of all the\n// bases of L these two shear the hexagons least on the long, thin parameter\n// square of this torus.\nconst E1A = 2, E1B = -3, E2A = 1, E2B = 2;\n\n// Samples round the core curve and round the tube; samples along each road.\nconst NU = 600, NV = 120, NS = NU * NV, NR = 200;\n// The outer half width of the torus in LEDs, and its half height before it leans.\nconst RO = 31, HALF = 63;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The country at fractional axial coordinates (qa, qb): round to the nearest\n// hexagon centre in cube coordinates, then colour it.\nfunction country(qa, qb) {\n  const x = qa, z = qb, y = -x - z;\n  let rx = round(x), ry = round(y), rz = round(z);\n  const dx = abs(rx - x), dy = abs(ry - y), dz = abs(rz - z);\n  if (dx > dy && dx > dz) rx = -ry - rz;\n  else if (dy \u003c= dz) rz = -rx - ry;\n  return (((rx + 3 * rz) % 7) + 7) % 7;\n}\n\n// The surface: a tube of radius r round a stadium, two half circles of\n// radius rc joined by straights 2 ly long, standing up in the x-y plane.\n// (U, V) in the unit square is the fraction of the way round the stadium and\n// round the tube. core() writes the point of the stadium at U and its\n// outward normal in the plane, (cx, cy, ox, oy), at out[o..o+3]; the surface\n// point is (cx + r cos v ox, cy + r cos v oy, r sin v) with v = 2 pi V, and\n// its normal (cos v ox, cos v oy, sin v).\nfunction core(S, U, out, o) {\n  const rc = S.rc, ly = S.ly;\n  let s = (U - floor(U)) * S.per, cx, cy, ox, oy;\n  if (s \u003c 2 * ly) (cx = rc), (cy = -ly + s), (ox = 1), (oy = 0);\n  else if ((s -= 2 * ly) \u003c PI * rc) {\n    const a = s / rc;\n    (ox = cos(a)), (oy = sin(a)), (cx = rc * ox), (cy = ly + rc * oy);\n  } else if ((s -= PI * rc) \u003c 2 * ly) (cx = -rc), (cy = ly - s), (ox = -1), (oy = 0);\n  else {\n    const a = PI + (s - 2 * ly) / rc;\n    (ox = cos(a)), (oy = sin(a)), (cx = rc * ox), (cy = -ly + rc * oy);\n  }\n  out[o] = cx;\n  out[o + 1] = cy;\n  out[o + 2] = ox;\n  out[o + 3] = oy;\n}\n\n// The plane point U E1 + V E2 is the one painted at (U, V), so the square's\n// sides go to E1 and E2 and the map closes up on the torus. Back the other\n// way, (qa, qb) lands at U = (2 qa - qb) / 7, V = (3 qa + 2 qb) / 7.\nfunction build(S) {\n  S.rc = RO / (1 + S.ratio);\n  S.r = S.rc * S.ratio;\n  S.ly = HALF - RO;\n  S.per = 4 * S.ly + TAU * S.rc;\n  const { cc, tc, ts, cid, road } = S;\n  for (let j = 0; j \u003c NV; j++) {\n    tc[j] = cos((TAU * (j + 0.5)) / NV);\n    ts[j] = sin((TAU * (j + 0.5)) / NV);\n  }\n  for (let i = 0; i \u003c NU; i++) {\n    const U = (i + 0.5) / NU;\n    core(S, U, cc, 4 * i);\n    for (let j = 0; j \u003c NV; j++) cid[i * NV + j] = country(U * E1A + (j + 0.5) / NV * E2A, U * E1B + (j + 0.5) / NV * E2B);\n  }\n  // The dual graph: the capital of country a sits at the hexagon (a, 0), and\n  // three roads leave it toward (a + 1, 0), (a, 1) and (a + 1, -1). Seven\n  // capitals times three is all 21 roads of K7, each crossing one border.\n  const q4 = [0, 0, 0, 0];\n  let n = 0;\n  for (let a = 0; a \u003c 7; a++)\n    for (const [da, db] of [[1, 0], [0, 1], [1, -1]])\n      for (let t = 0; t \u003c NR; t++, n++) {\n        const qa = a + (da * t) / (NR - 1), qb = (db * t) / (NR - 1), v = (TAU * (3 * qa + 2 * qb)) / 7, o = 3 * n;\n        core(S, (2 * qa - qb) / 7, q4, 0);\n        road[o] = q4[0] + S.r * cos(v) * q4[2];\n        road[o + 1] = q4[1] + S.r * cos(v) * q4[3];\n        road[o + 2] = S.r * sin(v);\n      }\n}\n\nexport function setup(params) {\n  // The turn starts 0.4 short of face-on, so at Speed 2 the torus faces you\n  // squarely one second in and stands edge-on five seconds in.\n  params.s = {\n    hue: 0, speed: 2, ratio: -1, tilt: 0.06, spin: -0.4, nod: 0, roads: -1, rc: 0, r: 0, ly: 0, per: 0,\n    cc: new Float32Array(4 * NU), tc: new Float32Array(NV), ts: new Float32Array(NV), cid: new Uint8Array(NS), road: new Float32Array(3 * 21 * NR),\n    zb: new Float32Array(N), ib: new Int32Array(N), ib2: new Int32Array(N), cb: new Uint8Array(N), rb: new Uint8Array(N), pal: new Float32Array(21),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tilt = cl(k[3], 0, 1);\n  const ratio = 0.85 - 0.45 * cl(k[2], 0, 1);\n  if (abs(ratio - S.ratio) > 1e-4) {\n    S.ratio = ratio;\n    build(S);\n  }\n  S.spin += d * S.speed * 0.2;\n  S.nod += d * S.speed * 0.11;\n  if (S.roads >= 0) {\n    S.roads += d;\n    if (S.roads > 7) S.roads = -1;\n  }\n  if (input.btnPressed && input.btnPressed[0]) S.roads = S.roads \u003c 0 ? 0 : min(S.roads, 0.5);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cc, tc, ts, cid, zb, ib, ib2, cb, rb, road, pal } = S, r = S.r;\n  // Spin about the torus's long axis, then lean the top of that axis toward\n  // the viewer, who looks along +z.\n  const ph = S.spin, cp = cos(ph), sp = sin(ph);\n  const la = -(0.1 + 0.6 * S.tilt + 0.05 * sin(S.nod)), cla = cos(la), sla = sin(la);\n  const m0 = cp, m2 = sp;\n  const m3 = sla * sp, m4 = cla, m5 = -sla * cp;\n  const m6 = -cla * sp, m7 = sla, m8 = cla * cp;\n  // Fit the leaning torus to the panel height.\n  const sc = min(1, 63.5 / (HALF * cla - RO * sla));\n  zb.fill(1e9);\n  ib.fill(-1);\n  // Each sample's screen x, y and depth are a column part plus cos v and\n  // sin v times a part, so the loop over the tube is a few multiplies.\n  const Xb = sc * m2 * r, Yb = -sc * m5 * r, Zb = m8 * r;\n  for (let i = 0; i \u003c NU; i++) {\n    const cx = cc[4 * i], cy = cc[4 * i + 1], ox = cc[4 * i + 2], oy = cc[4 * i + 3], A = m6 * ox + m7 * oy;\n    const X0 = 32 + sc * m0 * cx, Xa = sc * m0 * r * ox, Y0 = 64 - sc * (m3 * cx + m4 * cy), Ya = -sc * r * (m3 * ox + m4 * oy);\n    const Z0 = m6 * cx + m7 * cy, Za = r * A;\n    for (let j = 0, k = i * NV; j \u003c NV; j++, k++) {\n      const cv = tc[j], sv = ts[j];\n      // Facing away from the eye.\n      if (cv * A + sv * m8 > 0.05) continue;\n      const px = floor(X0 + cv * Xa + sv * Xb), py = floor(Y0 + cv * Ya + sv * Yb);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px, Z = Z0 + cv * Za + sv * Zb;\n      if (Z \u003c zb[p]) (zb[p] = Z), (ib[p] = k);\n    }\n  }\n  // Fill LEDs that no front sample reached, or where the back of the tube\n  // shows through between two front samples.\n  ib2.set(ib);\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, z = zb[p];\n      for (let q = 1; q \u003c= W; q += W - 1) {\n        const a = zb[p - q], b = zb[p + q];\n        if (a \u003c 1e8 && b \u003c 1e8 && abs(a - b) \u003c 4 && z > max(a, b) + 3) {\n          ib2[p] = a \u003c b ? ib[p - q] : ib[p + q];\n          break;\n        }\n      }\n    }\n  for (let p = 0; p \u003c N; p++) {\n    const k = ib2[p];\n    cb[p] = k \u003c 0 ? 255 : cid[k];\n    if (k >= 0 && k !== ib[p]) {\n      const i = (k / NV) | 0, j = k - i * NV, o = 4 * i;\n      zb[p] = m6 * (cc[o] + r * tc[j] * cc[o + 2]) + m7 * (cc[o + 1] + r * tc[j] * cc[o + 3]) + m8 * r * ts[j];\n    }\n  }\n\n  // The roads, where they lie on the visible surface, and the capitals at\n  // their ends as 2 x 2 dots.\n  const e = S.roads \u003c 0 ? 0 : sm(S.roads / 0.5) * (1 - sm(S.roads - 6));\n  if (e > 0) {\n    rb.fill(0);\n    for (let i = 0, o = 0; i \u003c 21 * NR; i++, o += 3) {\n      const x = road[o], y = road[o + 1], z = road[o + 2];\n      const px = floor(32 + sc * (m0 * x + m2 * z)), py = floor(64 - sc * (m3 * x + m4 * y + m5 * z));\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px;\n      if (m6 * x + m7 * y + m8 * z > zb[p] + 1.5) continue;\n      rb[p] = 1;\n      if (i % NR === 0 && px \u003c W - 1 && py \u003c H - 1) rb[p + 1] = rb[p + W] = rb[p + W + 1] = 1;\n    }\n  }\n\n  // The seven colours, a seventh apart, opening off red.\n  const h0 = S.hue + 1 / 14;\n  for (let c = 0; c \u003c 7; c++) hsv(h0 + c / 7, 1, 1, pal, 3 * c);\n  // Light from the upper left, in front.\n  const lx = -0.45, ly = 0.6, lz = -0.66;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, c = cb[p];\n      if (c === 255) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const k = ib2[p], i = (k / NV) | 0, j = k - i * NV, nx = tc[j] * cc[4 * i + 2], ny = tc[j] * cc[4 * i + 3], nz = ts[j];\n      const vx = m0 * nx + m2 * nz, vy = m3 * nx + m4 * ny + m5 * nz, vz = m6 * nx + m7 * ny + m8 * nz;\n      const dif = max(0, vx * lx + vy * ly + vz * lz);\n      // Half vector of the light and the eye at -z, for a small shine.\n      let hv = max(0, (vx * lx + vy * ly + vz * (lz - 1)) / 1.82);\n      (hv *= hv), (hv *= hv), (hv *= hv), (hv *= hv), (hv *= hv);\n      const spec = hv * 0.5;\n      const lit = (0.6 + 0.55 * dif) * (1 - 0.2 * e);\n      let R = pal[3 * c] * lit + spec, G = pal[3 * c + 1] * lit + spec, B = pal[3 * c + 2] * lit + spec;\n      // A dark LED where the country changes to the right or below, and\n      // where the surface folds behind a nearer part of the tube.\n      const r = x \u003c W - 1 ? cb[p + 1] : 255, b = y \u003c H - 1 ? cb[p + W] : 255, zf = zb[p] - 6;\n      if ((r !== 255 && r !== c) || (b !== 255 && b !== c) ||\n        (x > 0 && cb[p - 1] !== 255 && zb[p - 1] \u003c zf) || (r !== 255 && zb[p + 1] \u003c zf) ||\n        (y > 0 && cb[p - W] !== 255 && zb[p - W] \u003c zf) || (b !== 255 && zb[p + W] \u003c zf)) (R *= 0.08), (G *= 0.08), (B *= 0.08);\n      if (e > 0 && rb[p]) {\n        R += (1 - R) * e;\n        G += (1 - G) * e;\n        B += (1 - B) * e;\n      }\n      display.setPixel(x, y, cl(R * 255, 0, 255), cl(G * 255, 0, 255), cl(B * 255, 0, 255));\n    }\n}\n","perron-tree":"// ===== Patternflow pattern =====\n// Title:   Perron Tree\n// Family:  geometry\n// Idea:    A tall triangle that holds a needle in every direction between its sides is cut into thin slivers that slide over each other level by level, as Perron did, until it is a tree of sprouts on a third of the area that still holds every direction, and a white needle turns through all of them, hopping from sprout to sprout.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kakeya needle problem (Sōichi Kakeya, 1917), Besicovitch set drawn as Oskar Perron's tree (1928), pattern round 29\n// Round:   29\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=5..8, Slide=-1..1\n//\n// Knob 1: Hue. Turns the sweep of colours that marks each sliver's direction round the wheel.\n// Knob 2: Speed. How fast the slivers slide and the needle turns; at 2 the tree takes five and a half seconds to grow, stands for six and folds back up in three.\n// Knob 3: Depth. How many times the base is halved, 5 to 8: from 32 slivers to 256, and as many levels of sliding. The finished tree covers 30% of the triangle at 5 and 24% at 8.\n// Knob 4: Slide. How far each pair slides over the other: at -1 a little, and the tree is a tall trunk with a small crown frayed out at the top; at 1 a long way, and a short stub carries a crown that fans out nearly as wide as the triangle was.\n// Buttons: K1 tap starts again from the single triangle.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, sqrt, exp, cos, abs, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\n\n// The triangle: base on the bottom edge, BW LEDs wide, apex HT LEDs up.\nconst BW = 60, HT = 120, Y0 = 128, MAXN = 8, MAXM = 1 \u003c\u003c MAXN;\n// How much of the blurred light comes back as glow (the blur sums to 81).\nconst GLOW = 0.22 / 81;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const c = i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n  out[o] = c[0];\n  out[o + 1] = c[1];\n  out[o + 2] = c[2];\n}\n\nexport function setup(params) {\n  params.s = {\n    lam: 0, hold: 0, phase: 0, needle: 0, n: 5, g: 0.8, hue: 0,\n    acc: new Float32Array(N * 3), trail: new Float32Array(N), fade: 1, blo: new Float32Array(N * 3), sh: new Float32Array(MAXM), tj: new Float32Array(MAXN + 1), dur: new Float32Array(MAXN + 1),\n    col: new Float32Array(MAXM * 3),\n  };\n}\n\n// Perron's slides. At level j the base pieces pair up in groups of 2^j and\n// the right half of each group slides left by tj[j]: first closing the gap\n// its heart left at the level before, then a further 2(1 - g) of its half\n// base, so the two halves cross at 2g - 1 of the group triangle's height and\n// fork into two sprouts above it. What lies below is the group's heart, its\n// triangle shrunk by g^j toward its left corner, and the next level slides\n// hearts the same way. (Stein's write-up of Schoenberg's version.)\nfunction slides(P, n, g) {\n  const w = BW / (1 \u003c\u003c n);\n  for (let j = 1; j \u003c= n; j++) {\n    const half = w * (1 \u003c\u003c (j - 1)), s = pow(g, j - 1);\n    P.tj[j] = half * (1 - s) + 2 * (1 - g) * s * half;\n  }\n  // Seconds per level at Speed 2: the first levels move a fraction of an\n  // LED and go by quickly, the last ones take their time.\n  for (let j = 1; j \u003c= n; j++) P.dur[j] = 0.3 + 1.7 * pow(P.tj[j] / P.tj[n], 0.6);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3) / 2;\n  P.hue = cl(k[0], 0, 1);\n  const n = cl(round(k[2]), 5, MAXN), g = 0.8 - 0.12 * cl(k[3], -1, 1);\n  if (n !== P.n || abs(g - P.g) > 1e-4) {\n    // Keep the same share of the build when the depth changes.\n    const frac = P.lam / P.n;\n    P.n = n;\n    P.g = g;\n    P.lam = frac * n;\n  }\n  slides(P, P.n, P.g);\n  if (input.btnPressed && input.btnPressed[0]) (P.phase = 0), (P.lam = 0), (P.hold = 0);\n  // Build level by level, hold the tree, take it apart again from the top\n  // level down at twice the pace, rest on the whole triangle, and again.\n  if (P.phase === 0) {\n    P.lam += d / P.dur[min(P.n, floor(P.lam) + 1)];\n    if (P.lam >= P.n) (P.lam = P.n), (P.phase = 1), (P.hold = 0);\n  } else if (P.phase === 1) {\n    if ((P.hold += d) > 6) P.phase = 2;\n  } else if (P.phase === 2) {\n    P.lam -= (2 * d) / P.dur[cl(Math.ceil(P.lam), 1, P.n)];\n    if (P.lam \u003c= 0) (P.lam = 0), (P.phase = 3), (P.hold = 0);\n  } else if ((P.hold += d) > 1.2) P.phase = 0;\n  P.needle += d * 0.11;\n  P.fade = exp(-cl(dt || 0, 0, 0.1) / 0.12);\n}\n\n// One row of one sliver into the light buffer: the span [l, r) at row y.\n// A span under an LED wide is drawn one LED wide and dimmer, so the sprouts\n// taper in light rather than vanish between LEDs.\nfunction span(acc, y, l, r, cr, cg, cb) {\n  let wd = r - l, k = 1;\n  if (wd \u003c 1) {\n    const c = (l + r) / 2;\n    k = sqrt(max(wd, 0));\n    (l = c - 0.5), (r = c + 0.5), (wd = 1);\n  }\n  const x0 = max(0, floor(l)), x1 = min(W - 1, floor(r - 1e-6));\n  for (let x = x0, p = (y * W + x0) * 3; x \u003c= x1; x++, p += 3) {\n    const cov = (min(r, x + 1) - max(l, x)) * k;\n    if (cov \u003c= 0) continue;\n    acc[p] += cr * cov;\n    acc[p + 1] += cg * cov;\n    acc[p + 2] += cb * cov;\n  }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const n = P.n, M = 1 \u003c\u003c n, w = BW / M, acc = P.acc, sh = P.sh, col = P.col;\n  acc.fill(0);\n  // How far each level has slid: level j runs while lam goes from j-1 to j.\n  let lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c M; i++) {\n    let s = 0;\n    for (let j = 1; j \u003c= n; j++) if ((i >> (j - 1)) & 1) s -= P.tj[j] * sm(P.lam - (j - 1));\n    sh[i] = s;\n    lo = min(lo, s + i * w, s + BW / 2);\n    hi = max(hi, s + (i + 1) * w, s + BW / 2);\n  }\n  // Keep the whole figure centred as it slides.\n  const ox = W / 2 - (lo + hi) / 2;\n  // Each sliver's colour from its direction, the hue sweeping 0.8 of the wheel\n  // from one side of the triangle to the other.\n  // One sliver alone tones to about 140 of 255, two to 200, four near white.\n  for (let i = 0; i \u003c M; i++) hsv(P.hue + 0.5 + (0.8 * (i + 0.5)) / M, 0.85, 0.5, col, i * 3);\n  for (let y = Y0 - HT; y \u003c Y0; y++) {\n    const h = Y0 - (y + 0.5), f = h / HT;\n    if (f \u003c 0 || f > 1) continue;\n    for (let i = 0; i \u003c M; i++) {\n      const a = ox + sh[i] + BW / 2, l = ox + sh[i] + i * w, r = l + w;\n      span(acc, y, l + (a - l) * f, r + (a - r) * f, col[i * 3], col[i * 3 + 1], col[i * 3 + 2]);\n    }\n  }\n  // The needle: a segment the height of the triangle, swinging through every\n  // direction between its sides and back. Its direction picks the base point\n  // it stands on, and that point the sliver whose sprout holds it.\n  const sw = 0.5 - 0.5 * cos(P.needle * 2 * PI), b = sw * BW, i = min(M - 1, floor(b / w));\n  const bx = ox + sh[i] + b, ax = ox + sh[i] + BW / 2, tr = P.trail, fd = P.fade;\n  // Its light fades over about a tenth of a second, which softens each hop.\n  for (let p = 0; p \u003c N; p++) tr[p] *= fd;\n  for (let y = Y0 - HT; y \u003c Y0; y++) {\n    const h = Y0 - (y + 0.5), f = h / HT, x = bx + (ax - bx) * f;\n    for (let xx = max(0, floor(x - 2)); xx \u003c= min(W - 1, floor(x + 2)); xx++) {\n      const dd = abs(xx + 0.5 - x), wgt = dd \u003c 0.5 ? 1 : dd \u003c 1.5 ? 0.9 * (1.5 - dd) : 0.12 * (2.5 - dd), p = y * W + xx;\n      if (wgt > tr[p]) tr[p] = wgt;\n    }\n  }\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    const v = tr[p];\n    if (v \u003c 0.01) continue;\n    acc[q] += 1.6 * v;\n    acc[q + 1] += 1.55 * v;\n    acc[q + 2] += 1.4 * v;\n  }\n  // A soft glow round everything bright: a 5 by 5 blur, about a fifth of it\n  // added back, so the thin sprouts read from a few metres away.\n  const blo = P.blo;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0, p = y * W * 3; x \u003c W; x++, p += 3)\n      for (let c = 0; c \u003c 3; c++) blo[p + c] = (x > 1 ? acc[p + c - 6] : 0) + 2 * (x > 0 ? acc[p + c - 3] : 0) + 3 * acc[p + c] + 2 * (x \u003c W - 1 ? acc[p + c + 3] : 0) + (x \u003c W - 2 ? acc[p + c + 6] : 0);\n  // Overlaps add up: light piles toward white where many slivers cross.\n  const R = W * 3, tone = (q, y) => {\n    const g = (y > 1 ? blo[q - 2 * R] : 0) + 2 * (y > 0 ? blo[q - R] : 0) + 3 * blo[q] + 2 * (y \u003c H - 1 ? blo[q + R] : 0) + (y \u003c H - 2 ? blo[q + 2 * R] : 0);\n    return 255 * (1 - exp(-1.6 * (acc[q] + GLOW * g)));\n  };\n  for (let p = 0, y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, tone(p, y), tone(p + 1, y), tone(p + 2, y));\n}\n","figure-eight-orbit":"// ===== Patternflow pattern =====\n// Title:   Figure-Eight Orbit\n// Family:  physics\n// Idea:    Three equal masses under Newton's gravity chase one another round one figure eight standing the height of the panel, each a third of a period behind the next, integrated step by step from Chenciner and Montgomery's starting values with a faint line of the exact eight under them, and a kick to their starting velocities leaves the eight wobbling or breaks it into a tight binary and a body flung off the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: figure-eight solution of the three-body problem (Cris Moore, 1993; Alain Chenciner and Richard Montgomery, 2000), pattern round 38\n// Round:   38\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Trail=0.33..2, Kick=0..1\n//\n// Knob 1: Hue. Turns the three bodies round the wheel together, a third of the wheel apart. At 0 azure, rose and lime; at 0.25 magenta, butter yellow and cyan; at 0.5 peach, sea green and violet; at 0.75 green, blue and red. A body that comes round to orange or yellow is paled and its tail kept near full brightness, so it never reads brown or olive.\n// Knob 2: Speed. At 2 one period of the eight, 6.33 units of the orbit's own time, takes 6.3 seconds, and a body runs up to 67 LEDs a second through the crossing and slows to 25 at the far ends; at 0.2 a period takes 63 seconds, at 3 it takes 4.2.\n// Knob 3: Trail. How long each tail is, in periods; a tail is 8 LEDs wide at its body and narrows to nothing at its end. At 0.33 each tail ends just at the next body, so the eight is three comets in three colours; from 1 the whole eight is drawn, each stretch in the colour of the body that passed it last; with a kick the older passes show under the newest, a band of eights 2 periods deep at 2.\n// Knob 4: Kick. Pushes bodies 1 and 2 apart along the line between them at the start, then scales every velocity back to the old kinetic energy, so energy, momentum and angular momentum stay those of the eight. Up to 0.06 no kick: the exact eight, its energy within 1e-8 of the start for 200 periods. At 0.25 a push of 0.07, 5% of the fastest speed, and the eight wobbles; at 0.5 (0.18) it swings wide but holds; from about 0.65 (0.25) it holds a few periods and then two bodies pair off and the third is slung away; at 1 (0.45) a body leaves the panel in the first tenth of a period. The push keeps the symmetry of the starting line-up, which is why the eight survives so much of it. The three start again after a body has been off the panel 3 seconds, and 0.4 seconds after the knob comes to rest.\n// Buttons: K1 tap nudges the running orbit: two bodies pushed apart by 0.05, or by the Kick if that is more, a different pair on each tap. Away from the starting line-up the eight is far less forgiving: one tap leaves it wobbling for a minute or more before it breaks, three taps a second apart break it in about 20 seconds.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, hypot, round, cbrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Chenciner and Montgomery's starting values, G = m = 1: body 3 at the\n// crossing, bodies 1 and 2 opposite each other, both moving at half body 3's\n// velocity the other way. The period is 6.32591398.\nconst X1 = 0.97000436, Y1 = -0.24308753, VX3 = -0.93240737, VY3 = -0.86473146, PERIOD = 6.32591398;\n// Orbit to panel: the eight's long axis down the panel, SC LEDs to the unit.\n// It reaches 1.081 along that axis and 0.358 across, so 115 by 38 LEDs.\nconst SC = 53, CX = 31.5, CY = 63.5;\n// Under RS the pull is that of a uniform ball, so a close pass of a binary\n// stays finite. The eight never comes closer than 0.69, so it never feels it.\nconst RS = 0.05;\n// Step in orbit time: Yoshida's fourth-order leapfrog at H0, shortened by\n// (r / 0.5)^1.5 when two bodies are closer than 0.5.\nconst H0 = 1 / 128;\nconst YW1 = 1 / (2 - cbrt(2)), YW0 = -cbrt(2) * YW1;\nconst YC = [YW1 / 2, (YW0 + YW1) / 2, (YW0 + YW1) / 2, YW1 / 2], YD = [YW1, YW0, YW1];\n// Tail half-width at the head, in LEDs, and how far a body glows.\nconst HW = 3.6, GLOW = 6;\n// Opening hues: azure, rose, lime.\nconst HUE0 = 0.58;\n// Longest tail, in periods, and so the history the pattern keeps.\nconst LMAX = 2;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, trail: 0.33, kick: 0, kickSet: -1, kickWait: 0, begun: false,\n    p: new Float64Array(6), v: new Float64Array(6), a: new Float64Array(6),\n    clock: 0, carry: 0, out: 0, fade: 1, phase: 0, nudges: 0,\n    // Per body and LED: when the body last passed (orbit time) and how close.\n    tv: new Float32Array(3 * N).fill(-1e9), td: new Float32Array(3 * N).fill(99),\n    lx: new Float32Array(3), ly: new Float32Array(3), warm: [0, 0, 0],\n    ref: new Float32Array(N), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n  drawReference(params.s);\n}\n\n// Pull on each body; under RS the force grows linearly from the centre.\nfunction accel(p, a) {\n  a.fill(0);\n  for (let i = 0; i \u003c 3; i++)\n    for (let j = i + 1; j \u003c 3; j++) {\n      const dx = p[2 * j] - p[2 * i], dy = p[2 * j + 1] - p[2 * i + 1], r = sqrt(dx * dx + dy * dy), q = max(r, RS);\n      const f = 1 / (q * q * q);\n      a[2 * i] += dx * f;\n      a[2 * i + 1] += dy * f;\n      a[2 * j] -= dx * f;\n      a[2 * j + 1] -= dy * f;\n    }\n}\n\nfunction closest(p) {\n  let m = 1e9;\n  for (let i = 0; i \u003c 3; i++)\n    for (let j = i + 1; j \u003c 3; j++) m = min(m, hypot(p[2 * j] - p[2 * i], p[2 * j + 1] - p[2 * i + 1]));\n  return m;\n}\n\n// One step of Yoshida's fourth-order symplectic integrator: three leapfrogs\n// of h w1, h w0, h w1, with w0 negative.\nfunction step(p, v, a, h) {\n  for (let s = 0; s \u003c 3; s++) {\n    for (let i = 0; i \u003c 6; i++) p[i] += YC[s] * h * v[i];\n    accel(p, a);\n    for (let i = 0; i \u003c 6; i++) v[i] += YD[s] * h * a[i];\n  }\n  for (let i = 0; i \u003c 6; i++) p[i] += YC[3] * h * v[i];\n}\n\nconst stepLength = (p) => H0 * min(1, (max(closest(p), RS) / 0.5) ** 1.5);\n\n// The kick: bodies i and j pushed apart along the line between them, each\n// by eps, and then every velocity scaled back to the kinetic energy before\n// the push. Positions do not move, so the energy stays what it was; the\n// momentum stays zero and the angular momentum stays zero too, as for the\n// eight itself, so only the shape of the motion changes.\nfunction push(S, i, j, eps) {\n  const { p, v } = S, dx = p[2 * i] - p[2 * j], dy = p[2 * i + 1] - p[2 * j + 1], r = hypot(dx, dy) || 1;\n  let k0 = 0, k1 = 0;\n  for (let n = 0; n \u003c 6; n++) k0 += v[n] * v[n];\n  v[2 * i] += (eps * dx) / r;\n  v[2 * i + 1] += (eps * dy) / r;\n  v[2 * j] -= (eps * dx) / r;\n  v[2 * j + 1] -= (eps * dy) / r;\n  for (let n = 0; n \u003c 6; n++) k1 += v[n] * v[n];\n  const f = sqrt(k0 / k1);\n  for (let n = 0; n \u003c 6; n++) v[n] *= f;\n}\n\n// Kick 0..1 to eps: nothing up to 0.06, then up to 0.45.\nconst epsOf = (k) => 0.45 * (max(0, k - 0.06) / 0.94) ** 1.2;\n\nfunction initial(S) {\n  const { p, v } = S;\n  p.set([X1, Y1, -X1, -Y1, 0, 0]);\n  v.set([-VX3 / 2, -VY3 / 2, -VX3 / 2, -VY3 / 2, VX3, VY3]);\n  push(S, 0, 1, epsOf(S.kick));\n  S.kickSet = S.kick;\n}\n\nconst toCol = (y) => CX + y * SC, toRow = (x) => CY - x * SC;\n\n// A tail at an LED: age a in orbit time, distance d in LEDs, tail length L.\n// It narrows from HW at the head to nothing at its end, and dims from full\n// at the head to 0.6 a third of a period behind it and 0.55 after that.\nfunction tailCover(a, d, L) {\n  if (a \u003c 0 || a >= L) return 0;\n  return cl((HW + 0.5) * (1 - a / L) ** 1.5 - d + 0.5, 0, 1);\n}\nconst tailBright = (a) => 0.55 + 0.45 * exp(-a / (0.15 * PERIOD));\nconst tailValue = (a, d, L) => tailCover(a, d, L) * tailBright(a);\n\n// Mark the LEDs round body k at orbit time t. Within one pass the closest\n// approach is kept; a later pass takes the LED when it would light it more.\nfunction deposit(S, k, t) {\n  const bx = toCol(S.p[2 * k + 1]), by = toRow(S.p[2 * k]), R = HW + 1.5, L = LMAX * PERIOD;\n  if (bx \u003c -R || bx > W + R || by \u003c -R || by > H + R) return;\n  const o = k * N, tv = S.tv, td = S.td;\n  for (let y = max(0, floor(by - R)); y \u003c= min(H - 1, floor(by + R)); y++)\n    for (let x = max(0, floor(bx - R)); x \u003c= min(W - 1, floor(bx + R)); x++) {\n      const d = hypot(x + 0.5 - bx, y + 0.5 - by);\n      if (d > R) continue;\n      const q = o + y * W + x, t0 = tv[q];\n      if (abs(t - t0) \u003c 0.3) {\n        if (d \u003c td[q]) {\n          tv[q] = t;\n          td[q] = d;\n        }\n        continue;\n      }\n      const ref = max(t, t0), vNew = tailValue(ref - t, d, L), vOld = tailValue(ref - t0, td[q], L);\n      if (vNew > vOld || (vNew === vOld && t > t0)) {\n        tv[q] = t;\n        td[q] = d;\n      }\n    }\n}\n\n// Deposit body k if it has moved half an LED since it last did.\nfunction trace(S, t) {\n  for (let k = 0; k \u003c 3; k++) {\n    const bx = toCol(S.p[2 * k + 1]), by = toRow(S.p[2 * k]);\n    if (hypot(bx - S.lx[k], by - S.ly[k]) \u003c 0.5) continue;\n    S.lx[k] = bx;\n    S.ly[k] = by;\n    deposit(S, k, t);\n  }\n}\n\nconst farthest = (p) => max(hypot(p[0], p[1]), hypot(p[2], p[3]), hypot(p[4], p[5]));\n\n// Start (or start again): the starting line-up with the current kick, and\n// its own past drawn behind it by running the orbit backward for up to LMAX\n// periods, or until a body would come in from off the panel.\nfunction restart(S) {\n  S.tv.fill(-1e9);\n  S.td.fill(99);\n  S.clock = 0;\n  S.carry = 0;\n  S.out = 0;\n  initial(S);\n  const { p, v, a } = S;\n  const p0 = Float64Array.from(p), v0 = Float64Array.from(v);\n  S.lx.fill(-99);\n  S.ly.fill(-99);\n  let t = 0;\n  while (t > -LMAX * PERIOD && farthest(p) \u003c 1.4) {\n    trace(S, t);\n    const h = stepLength(p);\n    step(p, v, a, -h);\n    t -= h;\n  }\n  p.set(p0);\n  v.set(v0);\n  S.lx.fill(-99);\n  S.ly.fill(-99);\n  trace(S, 0);\n}\n\n// Whole steps only, the remainder carried to the next frame, so at the\n// opening the step never changes and the integrator stays symplectic.\nfunction advance(S, dt) {\n  const { p, v, a } = S;\n  S.carry += dt;\n  for (let h = stepLength(p); S.carry >= h; h = stepLength(p)) {\n    step(p, v, a, h);\n    S.carry -= h;\n    S.clock += h;\n    trace(S, S.clock);\n  }\n}\n\n// The exact eight, sampled over one period, as a faint line under the tails.\nfunction drawReference(S) {\n  const p = Float64Array.from([X1, Y1, -X1, -Y1, 0, 0]);\n  const v = Float64Array.from([-VX3 / 2, -VY3 / 2, -VX3 / 2, -VY3 / 2, VX3, VY3]), a = new Float64Array(6);\n  const n = 1600, h = PERIOD / n, ref = S.ref;\n  for (let s = 0; s \u003c n; s++) {\n    const bx = toCol(p[1]), by = toRow(p[0]);\n    for (let y = max(0, floor(by - 1)); y \u003c= min(H - 1, floor(by + 1)); y++)\n      for (let x = max(0, floor(bx - 1)); x \u003c= min(W - 1, floor(bx + 1)); x++) {\n        const c = cl(1.1 - hypot(x + 0.5 - bx, y + 0.5 - by), 0, 1);\n        if (c > ref[y * W + x]) ref[y * W + x] = c;\n      }\n    step(p, v, a, h);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.33, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.trail = cl(k[2], 0.33, 2);\n  S.kick = cl(k[3], 0, 1);\n  if (!S.begun) {\n    restart(S);\n    S.begun = true;\n  }\n  // A turned Kick starts the three again once the knob has rested 0.4 s,\n  // fading the old orbit out over 0.5 s and the new one in.\n  if (abs(S.kick - S.kickSet) > 0.004) {\n    S.kickWait += d;\n    if (S.kickWait > 0.4 && S.phase === 0) S.phase = -1;\n  } else S.kickWait = 0;\n  if (input.btnPressed && input.btnPressed[0] && S.phase === 0) {\n    const pair = S.nudges++ % 3;\n    push(S, pair, (pair + 1) % 3, max(0.05, epsOf(S.kick)));\n  }\n  // At Speed 2 the orbit's clock runs 1 unit a second.\n  advance(S, d * S.speed * 0.5);\n  // Off the panel: a body more than 1.35 from the centre.\n  if (farthest(S.p) > 1.35) S.out += d;\n  else S.out = max(0, S.out - d);\n  if ((S.out > 3 || farthest(S.p) > 8) && S.phase === 0) S.phase = -1;\n  if (S.phase \u003c 0) {\n    S.fade -= d / 0.5;\n    if (S.fade \u003c= 0) {\n      S.fade = 0;\n      restart(S);\n      S.kickWait = 0;\n      S.phase = 1;\n    }\n  } else if (S.phase > 0) {\n    S.fade += d / 0.5;\n    if (S.fade >= 1) {\n      S.fade = 1;\n      S.phase = 0;\n    }\n  }\n}\n\nfunction palette(S) {\n  for (let k = 0; k \u003c 3; k++) {\n    const h = S.hue + HUE0 + k / 3, hh = h - floor(h);\n    // Orange to yellow-green: paler and kept at full value, so a tail never\n    // reads brown or olive.\n    const warm = sm(0.02, 0.08, hh) * (1 - sm(0.2, 0.27, hh));\n    hsv(h, 0.85 - 0.3 * warm, 1, S.col[k]);\n    S.warm[k] = warm;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const { tv, td, ref, col, clock, fade } = S, L = S.trail * PERIOD;\n  const bx = [0, 0, 0], by = [0, 0, 0];\n  for (let k = 0; k \u003c 3; k++) {\n    bx[k] = toCol(S.p[2 * k + 1]);\n    by[k] = toRow(S.p[2 * k]);\n  }\n  const ord = [0, 1, 2], ag = [0, 0, 0];\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      // The faint reference eight, then the tails painted oldest first, so\n      // the newest pass lies on top.\n      let r = 0.13 * ref[p], g = 0.13 * ref[p], b = 0.16 * ref[p];\n      for (let k = 0; k \u003c 3; k++) ag[k] = clock - tv[k * N + p];\n      ord[0] = 0;\n      ord[1] = 1;\n      ord[2] = 2;\n      if (ag[ord[0]] \u003c ag[ord[1]]) [ord[0], ord[1]] = [ord[1], ord[0]];\n      if (ag[ord[1]] \u003c ag[ord[2]]) [ord[1], ord[2]] = [ord[2], ord[1]];\n      if (ag[ord[0]] \u003c ag[ord[1]]) [ord[0], ord[1]] = [ord[1], ord[0]];\n      for (let n = 0; n \u003c 3; n++) {\n        const k = ord[n], age = ag[k], d = td[k * N + p], al = tailCover(age, d, L) * fade;\n        if (al \u003c= 0) continue;\n        const c = col[k], lv = 1 - (1 - tailBright(age)) * (1 - 0.8 * S.warm[k]), wh = 0.5 * (1 - age / L) ** 8 * cl(1 - d / HW, 0, 1);\n        r += ((c[0] + (1 - c[0]) * wh) * lv - r) * al;\n        g += ((c[1] + (1 - c[1]) * wh) * lv - g) * al;\n        b += ((c[2] + (1 - c[2]) * wh) * lv - b) * al;\n      }\n      // The bodies: a white core in a glow of the body's colour.\n      for (let k = 0; k \u003c 3; k++) {\n        const dx = x + 0.5 - bx[k], dy = y + 0.5 - by[k], d2 = dx * dx + dy * dy;\n        if (d2 >= GLOW * GLOW) continue;\n        const dd = sqrt(d2), halo = 0.7 * fade * (1 - dd / GLOW) ** 1.5, core = sm(2.8, 1.4, dd) * fade, c = col[k];\n        r = 1 - (1 - r) * (1 - c[0] * halo);\n        g = 1 - (1 - g) * (1 - c[1] * halo);\n        b = 1 - (1 - b) * (1 - c[2] * halo);\n        r += (1 - r) * core;\n        g += (1 - g) * core;\n        b += (1 - b) * core;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n\n","kdv-solitons":"// ===== Patternflow pattern =====\n// Title:   KdV Solitons\n// Family:  wave\n// Idea:    Zabusky and Kruskal's numerical experiment as a space-time diagram falling down the panel: the top row is the wave now, a cosine that steepens, nearly breaks and splits into a train of solitons, each a bright ridge whose slant is its speed, the tall fast ones passing through the small slow ones with a sideways jog, until the whole train pinches back together into the cosine and fans out again.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: solitons of the Korteweg-de Vries equation (Norman Zabusky and Martin Kruskal, 1965), pattern round 31\n// Round:   31\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dispersion=0..1, Start=0..1\n//\n// Knob 1: Hue. Turns the crest colour round the wheel; at 0 the crests are cyan over indigo troughs and the tallest go pale.\n// Knob 2: Speed. How fast the equation runs and the diagram falls: at 2 the cosine breaks after half a second, the panel holds the last five seconds and the train gathers back into the cosine after sixteen; at 0.2 everything is ten times slower.\n// Knob 3: Dispersion. The delta of the equation, 0.022 at 0 as in the 1965 paper, giving eight thin solitons; turned up to 0.06 at 1 the cosine breaks into three wide ones and gathers back almost three times as often.\n// Knob 4: Start. The wave each run starts from: the cosine of the paper, two humps of unequal height, a flat plateau whose front edge breaks into a ranked train, or a random sum of five cosines drawn fresh each run.\n// Buttons: K1 tap drops a tall sech-squared soliton into the lowest trough of the wave, a pale ridge that races through the whole train.\n\nconst W = 64, H = 128;\nconst { min, max, floor, abs, sqrt, cos, sin, exp, tanh, cosh, atan2, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The equation u_t + u u_x + delta^2 u_xxx = 0 on a ring of length 2, held on\n// 256 points, four to an LED column.\nconst NX = 256, MK = NX - 1, DX = 2 / NX, SUB = NX / W;\n// Rows of the diagram per unit of time, and history rows kept.\nconst RPT = 40, HR = H + 2;\n// Robert-Asselin filter on the leapfrog's middle level: it damps the\n// odd-even mode that otherwise grows to overflow after about five time units,\n// and takes under one percent off a soliton over a whole run.\nconst NU = 0.001;\n// Colour table over the height above the troughs, from UL to UH.\nconst NL = 512, UL = -0.5, UH = 5;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Dark troughs, the crest hue at the top of a soliton, pale at the very top.\n// Below the crest the hue leans away round the wheel, so the small solitons\n// and the ripples between read as deeper water rather than a dim copy of the\n// crests. A dim orange or yellow reads brown or olive, so for crests from\n// pink round to yellow the lean runs the other way, through violet,\n// magenta and red, and only the brightest tones reach the crest hue; the two\n// leans meet at a yellow green, where the middle tones change side.\nconst LH = [0, 0.08, 0.17, 0.27, 0.27, 0.33, 0.5, 0.67, 0.83, 0.92, 1];\nconst LL = [-0.3, -0.36, -0.42, -0.47, 0.53, 0.15, 0.12, 0.12, 0, -0.2, -0.3];\nfunction lean(h) {\n  h -= floor(h);\n  for (let i = 1; i \u003c LH.length; i++) if (h \u003c= LH[i] && LH[i] > LH[i - 1]) return LL[i - 1] + ((LL[i] - LL[i - 1]) * (h - LH[i - 1])) / (LH[i] - LH[i - 1]);\n  return LL[0];\n}\nfunction palette(P) {\n  const t = P.lut, h0 = P.hue + 0.5, L = lean(h0);\n  for (let i = 0; i \u003c NL; i++) {\n    const e = UL + ((UH - UL) * i) / (NL - 1);\n    const v = cl(e / 2.5, 0, 1), w = cl((e - 2.1) / 1.4, 0, 1), q = cl((e - 0.3) / 1.9, 0, 1);\n    hsv(h0 + L * (1 - q) ** 0.6, 0.9 - 0.8 * w * w, 0.04 + 0.96 * v ** 1.15, t, i * 3);\n  }\n  P.lutHue = P.hue;\n}\n\n// du/dt at point i in the scheme's own differences.\nfunction rhs(u, i, d2) {\n  const m2 = u[(i - 2) & MK], m1 = u[(i - 1) & MK], z = u[i], p1 = u[(i + 1) & MK], p2 = u[(i + 2) & MK];\n  return -((p1 + z + m1) * (p1 - m1)) / (6 * DX) - (d2 * (p2 - 2 * p1 + 2 * m1 - m2)) / (2 * DX * DX * DX);\n}\n\n// Leapfrog is stable while dt times the largest rate of the linear scheme\n// stays under 1: |u|/dx for the u u_x term and 2.6 delta^2/dx^3 for the\n// third derivative (its worst wave is three grid cells long). A new dt, or a\n// new wave, starts the leapfrog again with one step back by Euler.\nfunction restartLeap(P) {\n  const d2 = P.delta * P.delta;\n  P.dt = 0.85 / (P.umax / DX + (2.6 * d2) / (DX * DX * DX));\n  const a = P.ua, b = P.ub;\n  for (let i = 0; i \u003c NX; i++) a[i] = b[i] - P.dt * rhs(b, i, d2);\n}\n\n// A starting wave into out, mean zero. Places and heights for the humps,\n// the plateau and the random sum are drawn fresh each run.\nfunction makeWave(P, kind, phase, out) {\n  const R = P.rnd;\n  if (kind) {\n    R[0] = Math.random() * 2;\n    R[1] = R[0] + 0.7 + Math.random() * 0.6;\n    R[2] = 1.05 + Math.random() * 0.3;\n    R[3] = 0.6 + Math.random() * 0.3;\n    for (let k = 1; k \u003c= 5; k++) (R[3 + k] = (0.3 + Math.random()) / k), (R[8 + k] = Math.random() * 2 * PI);\n  }\n  for (let i = 0; i \u003c NX; i++) {\n    const x = i * DX;\n    let v = 0;\n    if (kind === 0) v = cos(PI * (x - phase));\n    else if (kind === 1) {\n      // Two humps, about 1.2 and 0.75 high.\n      const d1 = ((x - R[0] + 3) % 2) - 1, d2 = ((x - R[1] + 3) % 2) - 1;\n      v = R[2] * exp(-((d1 / 0.3) ** 2)) + R[3] * exp(-((d2 / 0.22) ** 2));\n    } else if (kind === 2) {\n      // A plateau 1.1 high and 0.8 wide with soft edges.\n      const d = ((x - R[0] + 3) % 2) - 1;\n      v = 0.55 * (tanh((d + 0.4) / 0.05) - tanh((d - 0.4) / 0.05));\n    } else for (let k = 1; k \u003c= 5; k++) v += R[3 + k] * cos(PI * k * x + R[8 + k]);\n    out[i] = v;\n  }\n  let s = 0, mx = 0;\n  for (let i = 0; i \u003c NX; i++) s += out[i];\n  s /= NX;\n  for (let i = 0; i \u003c NX; i++) mx = max(mx, abs((out[i] -= s)));\n  // The random sum peaks at 1, like the cosine.\n  if (kind === 3) for (let i = 0; i \u003c NX; i++) out[i] /= mx;\n}\n\nfunction begin(P, kind) {\n  P.ub.set(P.tg);\n  P.kind = kind;\n  P.tau = 0;\n  P.rec = 0;\n  P.drops = 0;\n  P.umax = 3;\n  restartLeap(P);\n}\n\n// The wave into one row of 64 columns as height above the troughs: a\n// little more than half the brightest of a column's four points and the\n// rest their mean, so a thin crest keeps its peak. The trough level follows\n// the lowest point of the wave over about a quarter time unit; it is -1 for\n// the cosine and sinks to about -0.7 once the solitons have taken their mass.\nfunction sample(P, out, o) {\n  const u = P.ub, bg = P.bg;\n  for (let c = 0, i = 0; c \u003c W; c++) {\n    let mx = -9, s = 0;\n    for (let k = 0; k \u003c SUB; k++, i++) {\n      const v = u[i];\n      s += v;\n      if (v > mx) mx = v;\n    }\n    out[o + c] = 0.55 * mx + (0.45 * s) / SUB - bg;\n  }\n}\n\n// The share of the wave's energy in the first cosine mode, 1 for the cosine\n// itself, and where that mode's crest stands.\nfunction mode1(P) {\n  const u = P.ub;\n  let c1 = 0, s1 = 0, e = 0;\n  for (let i = 0; i \u003c NX; i++) {\n    const a = PI * i * DX;\n    c1 += u[i] * cos(a);\n    s1 += u[i] * sin(a);\n    e += u[i] * u[i];\n  }\n  P.phase = atan2(s1, c1) / PI;\n  return (2 * (c1 * c1 + s1 * s1)) / (NX * e + 1e-9);\n}\n\n// A soliton 4.4 high over the trough, in the lowest stretch of the wave. Its\n// mass is taken evenly off the rest so the mean stays zero, and the older\n// leapfrog level gets it one step back along its path.\nfunction drop(P) {\n  const u = P.ub, a = P.ua;\n  let best = 99, at = 0;\n  for (let i = 0; i \u003c NX; i += 4) {\n    let s = 0;\n    for (let k = -12; k \u003c= 12; k++) s += u[(i + k) & MK];\n    if (s \u003c best) (best = s), (at = i);\n  }\n  const A = 4.4, w = P.delta * sqrt(12 / A), c = best / 25 + A / 3;\n  for (let pass = 0; pass \u003c 2; pass++) {\n    const tgt = pass ? a : u, back = pass ? c * P.dt : 0;\n    let m = 0;\n    for (let i = 0; i \u003c NX; i++) {\n      const d = ((((i - at) * DX + back + 3) % 2) - 1) / w;\n      m += P.uc[i] = A / cosh(d) ** 2;\n    }\n    for (let i = 0; i \u003c NX; i++) tgt[i] += P.uc[i] - m / NX;\n    if (!pass) P.bg -= m / NX;\n  }\n}\n\nfunction step(P, n) {\n  const d2 = P.delta * P.delta, k1 = P.dt / (3 * DX), k2 = (d2 * P.dt) / (DX * DX * DX);\n  for (let s = 0; s \u003c n; s++) {\n    const a = P.ua, b = P.ub, c = P.uc;\n    for (let i = 0; i \u003c NX; i++) {\n      const m2 = b[(i - 2) & MK], m1 = b[(i - 1) & MK], z = b[i], p1 = b[(i + 1) & MK], p2 = b[(i + 2) & MK];\n      c[i] = a[i] - k1 * (p1 + z + m1) * (p1 - m1) - k2 * (p2 - 2 * p1 + 2 * m1 - m2);\n    }\n    for (let i = 0; i \u003c NX; i++) b[i] += NU * (a[i] - 2 * b[i] + c[i]);\n    P.ua = b;\n    P.ub = c;\n    P.uc = a;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    ua: new Float64Array(NX), ub: new Float64Array(NX), uc: new Float64Array(NX), tg: new Float64Array(NX),\n    hist: new Float32Array(HR * W), now: new Float32Array(W), head: 0, frac: 0,\n    lut: new Float32Array(NL * 3), lutHue: -1, hue: 0, speed: 2, delta: 0.022,\n    dt: 1e-4, umax: 3, tau: 0, kind: -1, want: 0, wantT: 0, rnd: new Float64Array(14),\n    f1: 0, rising: 0, rec: 0, phase: 1, reform: -1, toKind: 0, rem: 1, rlen: 1, bg: -1, drops: 0,\n  };\n}\n\n// One row of time has passed: store it, keep dt safe, and watch for the\n// moment to start a new run.\nfunction row(P) {\n  const u = P.ub;\n  let um = 0, lo = 9, bad = false;\n  for (let i = 0; i \u003c NX; i++) {\n    const v = u[i];\n    if (!(v === v) || abs(v) > 40) bad = true;\n    else if (abs(v) > um) um = abs(v);\n    if (v \u003c lo) lo = v;\n  }\n  if (bad) return makeWave(P, P.kind, 1, P.tg), begin(P, P.kind);\n  P.bg += (lo - P.bg) * 0.1;\n  P.head = (P.head + HR - 1) % HR;\n  sample(P, P.hist, P.head * W);\n  // A taller wave than dt was set for: a smaller dt, from here.\n  if (um > 0.9 * P.umax) (P.umax = um * 1.4), restartLeap(P);\n  const f = mode1(P), Tr = 0.21 / P.delta, rowT = 1 / RPT;\n  // Each time the train gathers back, the energy flows into the first mode\n  // and out again; a peak of that share over 0.6 is one return.\n  if (f > P.f1) P.rising = 1;\n  else if (P.rising && P.f1 > 0.6 && P.tau > 0.5 * Tr) (P.rising = 0), P.rec++;\n  else P.rising = 0;\n  P.f1 = f;\n  if (P.reform \u003c 0) {\n    // The cosine runs through one return and is drawn back onto an exact\n    // cosine at the second, where the returning one stands; other starts,\n    // and runs a dropped soliton keeps from returning, start a fresh wave\n    // after about as long.\n    if (P.kind === 0 ? P.rec >= 1 && P.rising && f > 0.55 : P.tau > 1.2 * Tr) newRun(P, P.kind, P.kind ? 1 : 0.4);\n    else if (P.tau > 2.6 * Tr) newRun(P, P.kind, 1);\n  }\n  if (P.reform >= 0) {\n    // Both leapfrog levels are drawn over to the new wave, the cosine target\n    // following the returning crest, so that what is left of the old wave\n    // falls along a smoothstep; then the run starts from the new one exactly.\n    const r = (P.reform = min(1, P.reform + rowT / P.rlen)), rem = 1 - r * r * (3 - 2 * r), g = P.rem > 0 ? 1 - rem / P.rem : 1;\n    P.rem = rem;\n    if (P.toKind === 0) for (let i = 0; i \u003c NX; i++) P.tg[i] = cos(PI * (i * DX - P.phase));\n    for (let i = 0; i \u003c NX; i++) (u[i] += (P.tg[i] - u[i]) * g), (P.ua[i] += (P.tg[i] - P.ua[i]) * g);\n    if (r >= 1) (P.reform = -1), begin(P, P.toKind);\n  }\n}\n\n// A new run toward a wave of this kind, drawn over in len time units: 0.4\n// for the cosine coming back to itself, a whole unit for a different wave.\nfunction newRun(P, kind, len) {\n  P.reform = 0;\n  P.rem = 1;\n  P.rlen = len;\n  P.toKind = kind;\n  makeWave(P, kind, P.phase, P.tg);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = cl(k[0], 0, 1);\n  P.speed = cl(k[1], 0.2, 3);\n  // Delta from 0.022 to 0.06 on a log scale.\n  const delta = 0.022 * (0.06 / 0.022) ** cl(k[2], 0, 1);\n  const kind = min(3, floor(cl(k[3], 0, 1) * 4));\n  if (abs(delta - P.delta) > 1e-6) (P.delta = delta), restartLeap(P);\n  if (P.kind \u003c 0) {\n    // Before the first frame the panel shows the starting wave as if it had\n    // been held still, so the diagram falls out of it.\n    makeWave(P, kind, 1, P.tg);\n    begin(P, kind);\n    P.bg = 9;\n    for (let i = 0; i \u003c NX; i++) P.bg = min(P.bg, P.ub[i]);\n    sample(P, P.hist, 0);\n    for (let r = 1; r \u003c HR; r++) P.hist.copyWithin(r * W, 0, W);\n  }\n  // A new Start is taken once the knob has rested on it a quarter second,\n  // and the wave is drawn over into it like any new run.\n  if (kind === (P.reform >= 0 ? P.toKind : P.kind)) P.wantT = 0;\n  else {\n    if (kind !== P.want) (P.want = kind), (P.wantT = 0);\n    if ((P.wantT += d) > 0.25) newRun(P, kind, 1);\n  }\n  const b = input.btnPressed || [];\n  // Four drops a run at most; past that the train is lost in white.\n  if (b[0] && P.drops \u003c 4) P.drops++, drop(P);\n\n  // 0.6 time units a second at Speed 2; the cosine breaks at 1/pi.\n  let left = d * P.speed * 0.3;\n  const rowT = 1 / RPT;\n  while (left > 1e-12) {\n    const run = min(left, (1 - P.frac) * rowT);\n    step(P, min(4000, max(1, round(run / P.dt))));\n    P.tau += run;\n    left -= run;\n    P.frac += run / rowT;\n    if (P.frac >= 1 - 1e-9) (P.frac = 0), row(P);\n  }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || P.kind \u003c 0) return;\n  if (P.lutHue !== P.hue) palette(P);\n  const now = P.now, hist = P.hist, lut = P.lut, f = P.frac, sc = (NL - 1) / (UH - UL);\n  sample(P, now, 0);\n  for (let y = 0; y \u003c H; y++) {\n    // Row y is the wave y rows of time ago. The newest stored row is f rows\n    // old; the top row is the wave now.\n    let ra = hist, ia, ib, w;\n    if (y \u003c= f) (ra = now), (ia = 0), (ib = P.head * W), (w = f > 0 ? y / f : 0);\n    else {\n      const kk = floor(y - f);\n      ia = ((P.head + kk) % HR) * W;\n      ib = ((P.head + kk + 1) % HR) * W;\n      w = y - f - kk;\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const u = ra[ia + x] + (hist[ib + x] - ra[ia + x]) * w;\n      const o = cl(round((u - UL) * sc), 0, NL - 1) * 3;\n      display.setPixel(x, y, lut[o], lut[o + 1], lut[o + 2]);\n    }\n  }\n}\n","bokeh":"// ===== Patternflow pattern =====\n// Title:   Bokeh\n// Family:  light\n// Idea:    A city at night with the lens left out of focus, so every lamp turns into a disc the shape of the iris.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Pace=0.2..4, Size=-1..1, Lights=40..90\n//\n// Knob 1: Hue. Turns the lights round the colour wheel, starting from sodium amber with a few red and blue ones among them.\n// Knob 2: Pace. How fast the lights drift past and how quickly each one blooms and goes out.\n// Knob 3: Size. How far out of focus they are, from small bright points to wide soft discs.\n// Knob 4: Lights. How many are lit at once; big discs come in fewer.\n// Buttons: K1 tap racks the focus through, so every disc closes to a point and opens out again.\n\nconst W = 64;\nconst H = 128;\nconst N = 160;\n\nfunction hsvInto(out, h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[0] = (k === 0 ? v : k === 1 ? q : k === 2 ? p : k === 3 ? p : k === 4 ? t : v) * 255;\n  out[1] = (k === 0 ? t : k === 1 ? v : k === 2 ? v : k === 3 ? q : k === 4 ? p : p) * 255;\n  out[2] = (k === 0 ? p : k === 1 ? p : k === 2 ? t : k === 3 ? v : k === 4 ? v : q) * 255;\n}\n\nfunction smooth(a, b, x) {\n  const t = Math.max(0, Math.min(1, (x - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n}\n\nfunction spawn(params, i) {\n  params.x[i] = Math.random() * (W + 12) - 6;\n  params.y[i] = Math.random() * (H + 20) - 10;\n  // Bigger discs are nearer lamps, so they also drift faster.\n  params.size[i] = 0.65 + Math.random() * 0.75;\n  const pick = Math.random();\n  if (pick \u003c 0.62) {\n    params.off[i] = (Math.random() - 0.5) * 0.07;\n    params.sat[i] = 0.82 + Math.random() * 0.18;\n  } else if (pick \u003c 0.8) {\n    // Pale lamps, nearly white.\n    params.off[i] = (Math.random() - 0.5) * 0.05;\n    params.sat[i] = 0.25 + Math.random() * 0.25;\n  } else if (pick \u003c 0.92) {\n    // Tail lights, a step towards red.\n    params.off[i] = -0.07 - Math.random() * 0.03;\n    params.sat[i] = 0.95;\n  } else {\n    // The odd cool one across the wheel.\n    params.off[i] = 0.47 + Math.random() * 0.08;\n    params.sat[i] = 0.75;\n  }\n  params.bright[i] = 0.65 + Math.random() * 0.35;\n  params.life[i] = 1.8 + Math.random() * 1.6;\n  params.age[i] = 0;\n  params.jx[i] = (Math.random() - 0.5) * 2;\n  params.jy[i] = (Math.random() - 0.5) * 2;\n  params.on[i] = 1;\n}\n\nexport function setup(params) {\n  params.x = new Float32Array(N);\n  params.y = new Float32Array(N);\n  params.size = new Float32Array(N);\n  params.off = new Float32Array(N);\n  params.sat = new Float32Array(N);\n  params.bright = new Float32Array(N);\n  params.life = new Float32Array(N);\n  params.age = new Float32Array(N);\n  params.jx = new Float32Array(N);\n  params.jy = new Float32Array(N);\n  params.on = new Uint8Array(N);\n  params.buf = new Float32Array(W * H * 3);\n  params.col = new Float32Array(3);\n  params.t = 0;\n  params.rack = 0;\n  params.started = false;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 0, 40];\n  params.hue = k[0];\n  const pace = Math.max(0.05, k[1]);\n  params.radius = 9 * Math.pow(1.6, k[2]);\n  const want = Math.min(N, Math.round(k[3] * Math.pow(9 / params.radius, 1.8)));\n  // A crowd dims each lamp a little, so the overlaps stay colours rather than a white wash.\n  params.crowd = Math.min(1, Math.pow(45 / k[3], 0.6));\n  dt = Math.min(dt, 0.1);\n  const step = dt * pace;\n  params.t += step;\n\n  if (!params.started) {\n    // The first frame finds each lamp somewhere in its life, so they never bloom together.\n    for (let i = 0; i \u003c want; i++) {\n      spawn(params, i);\n      params.age[i] = Math.random() * params.life[i];\n    }\n    params.started = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) params.rack = 1;\n  params.rack = Math.max(0, params.rack - dt * 0.9);\n\n  // The whole view pans slowly, the way a car window passes a street.\n  const t = params.t;\n  const ang = 0.6 * Math.sin(t * 0.11) + 0.3 * Math.sin(t * 0.23 + 2);\n  const sp = 9;\n  const dx = Math.cos(ang) * sp;\n  const dy = Math.sin(ang) * sp * 0.6;\n  for (let i = 0; i \u003c N; i++) {\n    if (!params.on[i]) {\n      if (i \u003c want) {\n        spawn(params, i);\n        // A lamp that K4 adds waits a moment, so a quick turn does not light a crowd at once.\n        params.age[i] = -Math.random() * 1.5;\n      }\n      continue;\n    }\n    params.age[i] += step;\n    if (params.age[i] >= params.life[i]) {\n      if (i \u003c want) spawn(params, i);\n      else params.on[i] = 0;\n      continue;\n    }\n    const s = params.size[i];\n    params.x[i] += (dx * s + params.jx[i]) * step;\n    params.y[i] += (dy * s + params.jy[i]) * step;\n  }\n}\n\nexport function draw(display, params, time) {\n  const buf = params.buf;\n  buf.fill(0);\n  const col = params.col;\n  // Racking focus: the discs close to points and open again, brighter as they shrink.\n  const r0 = params.rack > 0 ? Math.sin(params.rack * Math.PI) : 0;\n  const focus = 1 - 0.8 * r0;\n  const gain = Math.min(4, 1 / (focus * focus));\n  // A six-bladed iris, turned a little off square.\n  const ic = Math.cos(0.3);\n  const is = Math.sin(0.3);\n  for (let i = 0; i \u003c N; i++) {\n    if (!params.on[i]) continue;\n    const u = params.age[i] / params.life[i];\n    const env = smooth(0, 0.2, u) * (1 - smooth(0.45, 1, u));\n    if (env \u003c= 0.01) continue;\n    const r = params.radius * params.size[i] * (0.6 + 0.4 * smooth(0, 0.35, u) + 0.1 * smooth(0.5, 1, u)) * focus;\n    hsvInto(col, params.hue + 0.075 + params.off[i], params.sat[i], 1);\n    const level = params.bright[i] * env * gain * params.crowd;\n    const cr = col[0] * level;\n    const cg = col[1] * level;\n    const cb = col[2] * level;\n    const cx = params.x[i];\n    const cy = params.y[i];\n    // Soft edge never narrower than four and a half LEDs.\n    const e = Math.max(0.3, 4.5 / r);\n    const e0 = 1 - e * 0.5;\n    const e1 = 1 + e * 0.5;\n    // Near the panel's edge the lens barrel clips the disc into a cat's eye,\n    // measured against the long side so the corners clip as much as before.\n    const vx = ((cx - W / 2) / (H / 2)) * 0.45 * r;\n    const vy = ((cy - H / 2) / (H / 2)) * 0.45 * r;\n    const reach = r * e1 * 1.12 + 1;\n    const x0 = Math.max(0, Math.floor(cx - reach));\n    const x1 = Math.min(W - 1, Math.ceil(cx + reach));\n    const y0 = Math.max(0, Math.floor(cy - reach));\n    const y1 = Math.min(H - 1, Math.ceil(cy + reach));\n    const inv = 1 / r;\n    const vinv = 1 / (r * 1.12);\n    for (let y = y0; y \u003c= y1; y++) {\n      const py = y - cy;\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x - cx;\n        const round = Math.sqrt(px * px + py * py) * inv;\n        if (round > e1 * 1.2) continue;\n        const ax = Math.abs(px * ic - py * is);\n        const ay = Math.abs(px * is + py * ic);\n        const hex = Math.max(ay, ax * 0.866 + ay * 0.5) * inv * 1.05;\n        let d = round * 0.6 + hex * 0.4;\n        const qx = px + vx;\n        const qy = py + vy;\n        const clip = Math.sqrt(qx * qx + qy * qy) * vinv;\n        if (clip > d) d = clip;\n        if (d >= e1) continue;\n        // Brighter towards the rim, the way a lens draws an out-of-focus light.\n        const v = (1 - smooth(e0, e1, d)) * (0.64 + 0.36 * smooth(0.15, e0, d));\n        const o = (y * W + x) * 3;\n        buf[o] += cr * v;\n        buf[o + 1] += cg * v;\n        buf[o + 2] += cb * v;\n      }\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, knee(buf[o]), knee(buf[o + 1]), knee(buf[o + 2]));\n    }\n  }\n}\n\n// Overlaps add up, and past 160 the light rolls off instead of clipping flat.\nfunction knee(c) {\n  if (c \u003c 160) return c;\n  return 160 + 95 * (1 - Math.exp(-(c - 160) / 95));\n}\n"}</script>
+<script id="study-data" type="application/json">{"patterns":[{"slug":"abracadabra","title":"Abracadabra","family":"type","round":73,"note":"ABRACADABRA 열한 줄이 한 글자씩 줄며 128줄을 내려가고, 열이 위에서 아래로 지나가며 줄마다 빠지는 한 글자를 태워 재로 부숴요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-abracadabra","type":"code","name":"abracadabra","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Form=0..2, Cooling=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Form","min":0,"max":2},{"name":"Cooling","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0476,"detail":0.1064,"edges":0.8578,"complexity":0.3125,"coverage":0.1968,"colour":0.1195,"drift":0.0544},"knobResponse":[0.0421,0.0455,0.0769,0.0452]},{"slug":"abrikosov-lattice","title":"Abrikosov Lattice","family":"physics","round":62,"note":"빠르게 도는 보스-아인슈타인 응축체가 세운 패널을 채우고, 위상이 색이고 밀도가 밝기라서 양자 소용돌이마다 모든 색이 한 번씩 감기는 검은 심이 돼요. 심들은 삼각 격자로 서서 유체와 함께 돌고, Rotation 을 올리면 간격이 좁아지며 어두운 가장자리에서 새 소용돌이가 들어와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-abrikosov-lattice","type":"code","name":"abrikosov-lattice","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rotation=0.3..0.95, Round=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rotation","min":0.3,"max":0.95},{"name":"Round","min":0,"max":1}],"start":[0,2,0.3,0.06],"measures":{"motion":0.1114,"detail":0.0307,"edges":0,"complexity":2.4522,"coverage":0.8728,"colour":0.5618,"drift":0.1244},"knobResponse":[0.3979,0.2644,0.2694,0.1322]},{"slug":"abyss","title":"Abyss","family":"ocean","round":16,"note":"물결 밑 햇빛층에서 심해 바닥까지 바다 한 기둥이 128줄에 서요. 빛내림과 정어리 떼 아래로 관해파리와 샛비늘치, 아귀의 미끼 불빛을 지나 잠수정이 등을 켜고 열수 분출공까지 내려갔다 올라와요. K1 을 누르면 죽은 고래가 기둥을 다 가라앉아 바닥에 뼈로 남아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-abyss","type":"code","name":"abyss","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Night=0..1, Speed=0.2..3, Current=-1..1, Bloom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Night","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Current","min":-1,"max":1},{"name":"Bloom","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1244,"detail":0.039,"edges":0.3461,"complexity":1.1983,"coverage":0.6808,"colour":0.2784,"drift":0.0583},"knobResponse":[0.1135,0.059,0.0565,0.0734]},{"slug":"agate","title":"Agate","family":"mineral","round":20,"note":"라이트박스에 올린 블루 레이스 마노 단면이 패널을 거의 다 채우고, 1 LED 남짓한 하늘색 띠와 젖빛 띠가 갈색 껍질을 따라 겹겹이 들어가 석영 결정이 반짝이는 빈 속에 닿아요. 톱이 천천히 더 깊이 썰어 들어가며 띠가 흐르고, K1 을 누르면 날이 라이트박스를 가로지르며 새 마노 덩어리의 단면이 깔려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-agate","type":"code","name":"agate","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stain=0..1, Speed=0.2..3, Width=1..4, Light=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stain","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Width","min":1,"max":4},{"name":"Light","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2044,"detail":0.342,"edges":0.8294,"complexity":2.5192,"coverage":1,"colour":0.128,"drift":0.0573},"knobResponse":[0.1001,0.2798,0.2989,0.0578]},{"slug":"aharonov-bohm","title":"Aharonov-Bohm","family":"wave","round":69,"note":"평면파가 패널을 위에서 아래로 내려오며 3분의 1 높이의 가는 자속관을 지나면, 자기장이 닿지 않는데도 관 뒤 그림자 선 양쪽의 마루가 자속만큼 어긋난 채 어두운 솔기에서 끊기고, 마루 빛깔이 관이 없을 때보다 얼마나 밀렸는지를 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-aharonov-bohm","type":"code","name":"aharonov-bohm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wavelength=7..16, Flux=0.5..1.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wavelength","min":7,"max":16},{"name":"Flux","min":0.5,"max":1.5}],"start":[0,2,7,0.5],"measures":{"motion":1.7809,"detail":0.1223,"edges":0.5237,"complexity":1.8374,"coverage":0.4378,"colour":0.2606,"drift":0.0554},"knobResponse":[0.1545,0.2573,0.2457,0.2735]},{"slug":"airy-beam","title":"Airy Beam","family":"wave","round":73,"note":"유한 에너지 에어리 빔이 위에서 들어와 주 로브와 곁 로브가 함께 포물선으로 휘며 내려가고, 위쪽에서 오가는 작은 구슬이 가린 로브는 아래에서 다시 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-airy-beam","type":"code","name":"airy-beam","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Truncation=0.04..0.4, Tilt=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Truncation","min":0.04,"max":0.4},{"name":"Tilt","min":-1,"max":1}],"start":[0,2,0.04,0.06],"measures":{"motion":0.0737,"detail":0.0427,"edges":0.1158,"complexity":2.1892,"coverage":0.6671,"colour":0.2485,"drift":0.0815},"knobResponse":[0.1936,0.056,0.0862,0.1557]},{"slug":"alphabet-lineage","title":"Alphabet Lineage","family":"type","round":82,"note":"사람 머리, 눈, 물, 소머리의 원시 시나이 그림 넷이 패널 아래로 쌓여 페니키아 글자로 휘고, 카드처럼 뒤집혀 오른쪽을 보는 그리스 글자가 된 뒤 굵고 가는 획과 세리프를 단 로마 대문자 ROMA 로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-alphabet-lineage","type":"code","name":"alphabet-lineage","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Lag=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":5},{"name":"Lag","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1574,"detail":0.0452,"edges":0.2195,"complexity":0.765,"coverage":0.2643,"colour":0.1547,"drift":0.0926},"knobResponse":[0.0431,0.1074,0.0835,0.0569]},{"slug":"ammann-beenker","title":"Ammann-Beenker","family":"geometry","round":64,"note":"정사각형과 45도 마름모로 된 팔각 비주기 타일링이 수직 공간에서 미끄러지면, 패널을 가로지르는 한 줄의 육각형들이 한꺼번에 뒤집혀요. 육각형마다 정사각형 하나와 마름모 둘이 미끄러져 자리를 바꾸며 하얗게 빛났다가 가라앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ammann-beenker","type":"code","name":"ammann-beenker","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Phason=0.2..3, Size=8..16, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Phason","min":0.2,"max":3},{"name":"Size","min":8,"max":16},{"name":"Glow","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.1944,"detail":0.2227,"edges":0.8433,"complexity":0.4519,"coverage":0.7641,"colour":0.4667,"drift":0.0622},"knobResponse":[0.3704,0.1224,0.3537,0.1676]},{"slug":"anagram","title":"Anagram","family":"type","round":76,"note":"세로로 선 LISTEN 의 글자들이 저마다 색을 지닌 채 S 자 길로 미끄러져 SILENT 가 되고, 길이 엇갈릴 때마다 튀는 불꽃이 켄들 거리를 세요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-anagram","type":"code","name":"anagram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Set=0..7, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Set","min":0,"max":7},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3574,"detail":0.0563,"edges":0.5169,"complexity":0.4781,"coverage":0.2256,"colour":0.181,"drift":0.1376},"knobResponse":[0.0738,0.0892,0.12,0.0504]},{"slug":"analemma","title":"Analemma","family":"celestial","round":15,"note":"일 년 동안 같은 시각에 찍은 해가 바다 위 하늘에 8자를 그려요. K1 이 시각을 아침에서 저녁까지 돌려 8자를 눕히고, K4 를 올리면 화성의 눈물방울 모양이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-analemma","type":"code","name":"analemma","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=-1..1, Speed=0.2..3, Latitude=-1..1, Orbit=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Latitude","min":-1,"max":1},{"name":"Orbit","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0266,"detail":0.0181,"edges":0.3039,"complexity":1.0442,"coverage":0.9984,"colour":0.1966,"drift":0.0308},"knobResponse":[0.0776,0.085,0.0971,0.0827]},{"slug":"anamorphosis","title":"Anamorphosis","family":"type","round":65,"note":"깊이가 제각각인 판과 상자 열세 개에 한 시점에서 비춘 것처럼 낱말을 칠해 두고, 카메라가 둘레를 8자로 날아요. 그 시점을 지나는 1초 남짓만 색 조각이 이어져 HERE 가 읽혀요","why":"","block":0,"ramped":false,"layer":{"id":"layer-anamorphosis","type":"code","name":"anamorphosis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Flatten=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":4},{"name":"Flatten","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.608,"detail":0.0669,"edges":0.6264,"complexity":0.5941,"coverage":0.7919,"colour":0.616,"drift":0.3963},"knobResponse":[0.3406,0.276,0.205,0.2121]},{"slug":"anderson-localization","title":"Anderson Localization","family":"wave","round":38,"note":"위치 에너지가 무작위로 놓인 사슬의 한 자리에 양자 입자를 놓고, 자리를 가로로, 시간을 세로로 그려요. 깨끗한 사슬이라면 점선을 따라 패널 끝까지 벌어졌을 원뿔이 27 LED 너비에서 멈추고, 얼룩진 기둥으로 끝까지 서 있어요. K3 은 무질서를 키워 기둥을 12 LED 까지 좁히고, K1 을 누르면 새 에너지와 새 자리에서 바로 다시 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-anderson-localization","type":"code","name":"anderson-localization","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Disorder=4..12, Samples=1..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Disorder","min":4,"max":12},{"name":"Samples","min":1,"max":16}],"start":[0,2,4,1],"measures":{"motion":0.0706,"detail":0.0573,"edges":0.2197,"complexity":1.2567,"coverage":0.5738,"colour":0.1923,"drift":0.1291},"knobResponse":[0.0885,0.0786,0.0464,0.0484]},{"slug":"andrews-curves","title":"Andrews Curves","family":"data","round":56,"note":"다섯 차원의 합성 점 40 개가 앤드루스 곡선이 되어 세 빛깔 다발로 꼬여요. 그랜드 투어가 데이터를 돌리는 동안 흰 곡선과 이웃 곡선 사이 틈은 부풀었다 오므라들지만, 바닥의 흰 막대는 길이가 그대로예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-andrews-curves","type":"code","name":"andrews-curves","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=0.12..0.6, Dims=5..9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":0.12,"max":0.6},{"name":"Dims","min":5,"max":9}],"start":[0,2,0.12,5],"measures":{"motion":0.2693,"detail":0.082,"edges":0.5228,"complexity":1.2778,"coverage":0.4709,"colour":0.3484,"drift":0.254},"knobResponse":[0.1694,0.208,0.2481,0.1765]},{"slug":"anscombes-quartet","title":"Anscombe's Quartet","family":"data","round":52,"note":"회귀선이 같은 앤스컴의 산점도 넷이 쌓였다가 한 그림으로 펴지고, 점 264개가 다섯 통계를 소수 둘째 자리까지 지킨 채 원과 별, 과녁과 빗금으로 모양을 바꾸는 동안 회귀선과 십자선은 꿈쩍하지 않아요. K3 은 담금질 온도, K4 는 점에서 선까지 내린 잔차 막대예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-anscombes-quartet","type":"code","name":"anscombes-quartet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Heat=0..1, Residuals=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Heat","min":0,"max":1},{"name":"Residuals","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.174,"detail":0.0764,"edges":0.907,"complexity":0.2046,"coverage":0.2024,"colour":0.1426,"drift":0.0225},"knobResponse":[0.054,0.1216,0.0387,0.0405]},{"slug":"ant-farm","title":"Ant Farm","family":"insect","round":17,"note":"유리 사이에 모래를 채운 개미집에서 수확개미들이 바닥의 여왕 방까지 굴을 파고, 판 모래를 입구 옆 더미에 올리거나 오래된 막다른 굴에 다시 다져 넣어요. K1 을 누르면 뚜껑으로 물을 줘서 젖은 모래 얼룩이 천천히 아래로 번져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-ant-farm","type":"code","name":"ant-farm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fill=0..1, Speed=0.2..3, Ants=40..120, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fill","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ants","min":40,"max":120},{"name":"Lamp","min":0,"max":1}],"start":[0,2,40,0.06],"measures":{"motion":0.0748,"detail":0.0791,"edges":0.3143,"complexity":0.7035,"coverage":0.9824,"colour":0.2295,"drift":0.0611},"knobResponse":[0.2509,0.0544,0.0511,0.2616]},{"slug":"antoine-necklace","title":"Antoine's Necklace","family":"space","round":37,"note":"경기장 트랙 모양 유리 목걸이 안에 고리 18개가 이웃끼리 한 번씩 걸린 사슬이 들어 있고, 고리마다 목걸이 전체를 0.184배로 줄인 꼴이라 그 안에 또 사슬이 있어요. 카메라가 고리 하나로 9초에 한 세대씩 날아 들어가면 겉은 유리 테두리로 얇아지고 속 사슬이 단단해져서, 9초 뒤에는 색만 한 세대 넘어간 처음 그림이 돼요. K3 은 사슬의 고리를 30개까지 늘리고, 누르면 옆의 고리로 옮겨 들어가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-antoine-necklace","type":"code","name":"antoine-necklace","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Links=18..30, Turn=45..90","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Links","min":18,"max":30},{"name":"Turn","min":45,"max":90}],"start":[0,2,18,45],"measures":{"motion":0.8976,"detail":0.0847,"edges":0.5082,"complexity":1.4555,"coverage":0.5229,"colour":0.1494,"drift":0.2617},"knobResponse":[0.1332,0.2651,0.185,0.2969]},{"slug":"apollonius-problem","title":"Problem of Apollonius","family":"geometry","round":71,"note":"세 흰 원이 패널 위를 떠다니는 동안 셋 모두에 접하는 원 여덟 개가 안팎 접촉에 따라 제 색으로 그려지고 접점마다 밝은 점이 찍히다가, 흰 원 둘이 겹치면 넷이 짝지어 합쳐지며 사라졌다 떨어지면 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-apollonius-problem","type":"code","name":"apollonius-problem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pair=0..4, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pair","min":0,"max":4},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8856,"detail":0.0945,"edges":0.7721,"complexity":0.7452,"coverage":0.1997,"colour":0.1905,"drift":0.1245},"knobResponse":[0.0633,0.1446,0.0701,0.1497]},{"slug":"aquarium","title":"Aquarium","family":"pixel","round":2,"note":"높은 수조에 흰동가리, 블루탱, 엔젤피시, 네온테트라 떼가 꼬리를 흔들며 헤엄쳐요. 모래 위 보물상자가 몇 초마다 뚜껑을 열어 공기 방울을 뱉고, K1 을 누르면 먹이가 떨어져 물고기가 몰려와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-aquarium","type":"code","name":"aquarium","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Water=0..1, Swim=0.2..4, Fish=6..18, Light=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Water","min":0,"max":1},{"name":"Swim","min":0.2,"max":4},{"name":"Fish","min":6,"max":18},{"name":"Light","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.1521,"detail":0.0707,"edges":0.4986,"complexity":0.73,"coverage":0.9459,"colour":0.2752,"drift":0.0492},"knobResponse":[0.1007,0.0662,0.0696,0.1627]},{"slug":"arcsine-law","title":"Arcsine Law","family":"data","round":54,"note":"공정한 동전 던지기 걸음 48개가 열마다 한 걸음에 한 줄씩 내려오며, 위로 간 걸음은 밝고 아래로 간 걸음은 어두워서 동전은 잡음처럼 흩어지는데, 0 위면 호박색이고 0 아래면 하늘색인 색은 대부분의 열에서 한 가지로 길게 이어져요. 126걸음이 끝나면 열마다 호박색 칸이 위로 떠올라 모이고 열이 그 수대로 줄을 서서 두 색의 경계가 아크사인 분위 곡선을 그리고, 옆의 히스토그램은 지금까지의 모든 걸음을 모아 레비의 U 자 법칙으로 다가가요. K3 은 줄 세우는 통계를 고르고, K4 는 걸음의 치우침이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-arcsine-law","type":"code","name":"arcsine-law","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Statistic=0..2, Drift=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Statistic","min":0,"max":2},{"name":"Drift","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0788,"detail":0.3087,"edges":0.905,"complexity":1.0822,"coverage":0.7327,"colour":0.379,"drift":0.2319},"knobResponse":[0.2567,0.2918,0.1212,0.3021]},{"slug":"arnold-tongues","title":"Arnold Tongues","family":"rhythm","round":32,"note":"아래 가장자리의 분수 p/q 마다 혀가 하나씩 위로 자라 벌어져요. 양옆은 0/1 과 1/1 혀, 가운데는 분홍 1/2 혀, 그 양쪽은 초록 1/3 과 2/3 혀예요. 혀마다 q박에 한 번 번쩍여서 판 전체가 13박까지의 폴리리듬으로 뛰고, 회색 탐침선이 오르내리며 그 높이의 악마의 계단을 그어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-arnold-tongues","type":"code","name":"arnold-tongues","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=0.2..3, Zoom=0..1, Depth=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":0.2,"max":3},{"name":"Zoom","min":0,"max":1},{"name":"Depth","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3954,"detail":0.0597,"edges":0.7533,"complexity":0.3067,"coverage":1,"colour":0.3016,"drift":0.0852},"knobResponse":[0.2048,0.0673,0.163,0.058]},{"slug":"art-gallery","title":"Art Gallery","family":"geometry","round":61,"note":"키 큰 다각형의 귀를 하나씩 잘라 삼각형으로 나누고 꼭짓점을 세 색으로 칠하면, 가장 적은 색의 꼭짓점에 선 경비원들의 빛이 갤러리를 빈틈없이 밝혀요. 세 번에 한 번은 이빨마다 경비원이 하나씩 있어야 하는 흐바탈의 빗이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-art-gallery","type":"code","name":"art-gallery","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Corners=12..30, Depth=0.6..0.95","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Corners","min":12,"max":30},{"name":"Depth","min":0.6,"max":0.95}],"start":[0,2,12,0.6],"measures":{"motion":0.1274,"detail":0.0489,"edges":0.5274,"complexity":1.0928,"coverage":0.6088,"colour":0.1804,"drift":0.3073},"knobResponse":[0.054,0.1398,0.1472,0.1053]},{"slug":"artin-braids","title":"Artin Braids","family":"topology","round":67,"note":"위 띠의 점 셋에서 일곱이 생성원마다 이웃과 반 바퀴 돌아 자리를 바꾸고, 그 자취가 아래로 흘러 앞으로 지난 가닥은 이어지고 뒤로 지난 가닥은 끊긴 브레이드가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-artin-braids","type":"code","name":"artin-braids","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Word=0..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":3,"max":7},{"name":"Word","min":0,"max":4}],"start":[0,2,3,0.06],"measures":{"motion":0.6036,"detail":0.0466,"edges":0.4184,"complexity":0.8835,"coverage":0.3211,"colour":0.2698,"drift":0.145},"knobResponse":[0.1127,0.1251,0.1771,0.111]},{"slug":"aurora","title":"Aurora","family":"light","round":1,"note":"떠도는 선에 빛 커튼이 걸리고, 빛줄기는 커튼이 흔들리는 것보다 느리게 일렁여요.","why":"예쁘지만 거의 제자리예요(움직임 0.04).","block":1,"ramped":true,"layer":{"id":"layer-aurora","type":"code","name":"aurora","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":0.18,"color":"#04122e","alpha":1},{"position":0.45,"color":"#0b6b5a","alpha":1},{"position":0.72,"color":"#3dff9a","alpha":1},{"position":0.9,"color":"#b8ffd9","alpha":1},{"position":1,"color":"#f0c8ff","alpha":1}],"mode":"oklab","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sway=0..1, Speed=0.1..5, Curtains=1..4, Rays=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sway","min":0,"max":1},{"name":"Speed","min":0.1,"max":5},{"name":"Curtains","min":1,"max":4},{"name":"Rays","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0423,"detail":0.0219,"edges":0.176,"complexity":1.1219,"coverage":0.4849,"colour":0.2574,"drift":0.0814},"knobResponse":[0.0412,0.0639,0.142,0.0829]},{"slug":"autogram","title":"Autogram","family":"type","round":72,"note":"제 글자 수를 늘어놓은 영어 문장을 글자마다 세어 주장과 맞춰 보고, 주장을 흔들면 틀린 문장을 센 수로 거듭 다시 쓰다 고리에 갇혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-autogram","type":"code","name":"autogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sentence=0..2, Doubt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sentence","min":0,"max":2},{"name":"Doubt","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0516,"detail":0.1474,"edges":0.9742,"complexity":0.1413,"coverage":0.1899,"colour":0.1454,"drift":0.0275},"knobResponse":[0.045,0.0894,0.0984,0.0516]},{"slug":"autostereogram","title":"Autostereogram","family":"type","round":74,"note":"무작위 색 점에 세 글자 낱말을 깊이로만 숨긴 단일 화면 입체 그림이고, 띠가 내려가며 LED 마다 한 주기 왼쪽 LED 와 견주면 낱말이 흰 점으로 드러나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-autostereogram","type":"code","name":"autostereogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Depth=-3..3, Period=11..15, Reveal=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Depth","min":-3,"max":3},{"name":"Period","min":11,"max":15},{"name":"Reveal","min":0,"max":1}],"start":[0,2,11,0.06],"measures":{"motion":0.1627,"detail":0.2351,"edges":0.7646,"complexity":1.782,"coverage":0.9412,"colour":0.3323,"drift":0.1174},"knobResponse":[0.1738,0.1554,0.1867,0.2562]},{"slug":"axon","title":"Axon","family":"body","round":23,"note":"어두운 조직 속에서 신경세포 하나가 초록 형광으로 빛나요. 세포체를 떠난 스파이크가 수초 사이의 랑비에 결절을 하나씩 건너뛰며 축삭을 내려가고, 말단 단추가 시냅스 틈 너머로 신호를 넘기면 아래의 자홍색 신경세포가 따라 켜져요. K4 를 올리면 수초가 벗겨져 신호가 기어가다 꺼져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-axon","type":"code","name":"axon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dye=0..1, Speed=0.2..3, Rate=1..8, Damage=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dye","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rate","min":1,"max":8},{"name":"Damage","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2284,"detail":0.0799,"edges":0.4159,"complexity":1.8734,"coverage":0.4953,"colour":0.2394,"drift":0.0867},"knobResponse":[0.1239,0.0564,0.0498,0.061]},{"slug":"aztec-diamond","title":"Aztec Diamond","family":"cells","round":28,"note":"아즈텍 다이아몬드 여덟 개가 패널을 덮고 저마다 도미노 셔플로 자라요. 도미노가 제 방향으로 한 LED 씩 미끄러지고 빈 2×2 칸에 새 쌍이 들어서면, 다 자란 다이아몬드의 네 모서리는 한 색 벽돌로 얼고 북극권 원 안만 뒤섞여요. K3 이 가로와 세로의 몫을 기울여 원을 타원으로 바꾸고, 누르면 처음부터 다시 자라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-aztec-diamond","type":"code","name":"aztec-diamond","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=-1..1, Checker=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":-1,"max":1},{"name":"Checker","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2173,"detail":0.3498,"edges":0.9816,"complexity":1.6331,"coverage":0.888,"colour":0.6403,"drift":0.1071},"knobResponse":[0.459,0.1665,0.2603,0.1486]},{"slug":"bait-ball","title":"Bait Ball","family":"ocean","round":23,"note":"옆에서 본 푸른 바다를 정어리 떼 공이 거의 다 채워요. 떼가 한꺼번에 몸을 틀면 은빛 물결이 공을 가로지르고, 등을 돌리면 짙은 남색으로 가라앉아요. 상어와 돌고래가 뚫고 지나간 구멍은 뒤에서 다시 닫히고, 가넷이 수면에서 거품 꼬리를 끌며 내리꽂혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bait-ball","type":"code","name":"bait-ball","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Water=0..1, Speed=0.2..3, Predators=1..5, Sun=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Water","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Predators","min":1,"max":5},{"name":"Sun","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.8889,"detail":0.2376,"edges":0.5511,"complexity":1.4993,"coverage":0.9518,"colour":0.2846,"drift":0.3724},"knobResponse":[0.0519,0.3412,0.1352,0.1016]},{"slug":"bak-sneppen","title":"Bak-Sneppen","family":"data","round":50,"note":"종 64개의 적합도 막대에서 가장 낮은 것과 양옆을 거듭 새로 뽑으면 막대의 바닥이 저절로 0.62 까지 오르고, 새 색의 사태가 가장 낮은 자리를 따라 번지다 멀리 뛰어요. K3 은 양옆을 고리 어디서나 고를 확률, K4 는 막대가 오래된 색이 되는 데 걸리는 걸음이고, K1 을 누르면 막대를 다시 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bak-sneppen","type":"code","name":"bak-sneppen","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Random=0..1, Memory=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Random","min":0,"max":1},{"name":"Memory","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5993,"detail":0.0856,"edges":0.259,"complexity":0.0878,"coverage":0.7857,"colour":0.385,"drift":0.0935},"knobResponse":[0.3999,0.1659,0.2098,0.1043]},{"slug":"balanced-rhythms","title":"Balanced Rhythms","family":"rhythm","round":62,"note":"재생 헤드가 위의 걸음 고리를 돌며 친 걸음마다 중심에서 그 단위 벡터를 긋고, 아래에서는 같은 벡터를 꼬리에 머리를 이어 붙인 걸음이 마디 끝마다 출발점으로 돌아와요. 첫 리듬은 오각형과 삼각형에서 둘을 잇는 이각형을 뺀 여섯 걸음이라, 어느 정다각형의 합집합도 아닌데 걸음이 닫혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-balanced-rhythms","type":"code","name":"balanced-rhythms","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rhythm=0..1, Rotate=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rhythm","min":0,"max":1},{"name":"Rotate","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1498,"detail":0.0431,"edges":0.519,"complexity":0.5682,"coverage":0.2534,"colour":0.1241,"drift":0.0663},"knobResponse":[0.0646,0.0388,0.096,0.0704]},{"slug":"ballistic-annihilation","title":"Ballistic Annihilation","family":"particle","round":44,"note":"총이 박자마다 느림, 가운데, 빠름 가운데 하나로 쏜 총알이 시공간 그림에서 제 기울기의 곧은 선이 되고, 빠른 것이 느린 것을 따라잡으면 둘 다 흰 불꽃으로 사라져요. 가운데 총알의 몫이 1/4 을 넘어야 끝까지 사는 총알이 생겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ballistic-annihilation","type":"code","name":"ballistic-annihilation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Middle=-1..1, Spread=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Middle","min":-1,"max":1},{"name":"Spread","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.3291,"detail":0.1292,"edges":0.9998,"complexity":0.0873,"coverage":0.1772,"colour":0.3485,"drift":0.1809},"knobResponse":[0.1075,0.179,0.1144,0.247]},{"slug":"ballistic-deposition","title":"Ballistic Deposition","family":"particle","round":30,"note":"입자가 64열 위로 곧게 떨어져 처음 닿는 자리에 붙어요. 처마 밑이 빈 퇴적물이 내려앉은 차례대로 띠를 이루고, 띠의 경계가 거칠어지는 앞면의 지난 모습이에요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-ballistic-deposition","type":"code","name":"ballistic-deposition","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slip=0..1, Layers=6..24","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slip","min":0,"max":1},{"name":"Layers","min":6,"max":24}],"start":[0,2,0,6],"measures":{"motion":0.6499,"detail":0.2394,"edges":0.9298,"complexity":0.4248,"coverage":0.4131,"colour":0.4145,"drift":0.0572},"knobResponse":[0.2133,0.2835,0.2999,0.1051]},{"slug":"balloon-box","title":"Balloon Box","family":"weather","round":11,"note":"새벽 골짜기에 바람이 둘이에요. 낮은 바람은 열기구를 왼쪽으로, 높은 바람은 오른쪽으로 데려가고, 조종사가 버너로 높이를 바꾸면 풍선이 멈췄다 되돌아가요. 옆으로 나간 자리에는 새 풍선이 바람을 타고 들어오거나 들판에서 떠올라요. K1 을 누르면 모든 버너가 한꺼번에 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-balloon-box","type":"code","name":"balloon-box","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Wind=0.2..3, Balloons=8..16, Sunrise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Wind","min":0.2,"max":3},{"name":"Balloons","min":8,"max":16},{"name":"Sunrise","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.167,"detail":0.0307,"edges":0.6336,"complexity":0.5511,"coverage":0.8946,"colour":0.5662,"drift":0.2806},"knobResponse":[0.306,0.2762,0.2316,0.2865]},{"slug":"banshee","title":"Banshee","family":"halloween","round":52,"note":"창 하나 밝힌 오두막 위 밤바람에 비치는 여인이 긴 머리와 해진 옷자락을 날리며 떠다니다 7초마다 고개를 젖혀 울면, 독한 초록 소리 고리가 밤을 휘며 퍼져서 하늘이 번쩍이고 유리창이 덜컹거리고 촛불이 눕고 까마귀가 흩어져요. K3 은 바람, K4 는 울음의 세기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-banshee","type":"code","name":"banshee","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Fury=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Fury","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5532,"detail":0.0402,"edges":0.2775,"complexity":0.7447,"coverage":0.7257,"colour":0.1068,"drift":0.0715},"knobResponse":[0.0665,0.0906,0.0657,0.1141]},{"slug":"barn-owl","title":"Barn Owl","family":"halloween","round":48,"note":"보라 밤하늘의 보름달 앞 마른 나무 높은 가지에서 원숭이올빼미가 하트 얼굴을 멀리 돌렸다 되돌리고 눈을 깜빡이다가, 날개를 크게 치며 패널 끝까지 내리꽂혀 풀밭의 쥐를 낚아채거나 놓치고 다시 가지로 올라가요. K3 은 사냥 사이의 기다림, K4 는 바람이고, K1 을 누르면 바로 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-barn-owl","type":"code","name":"barn-owl","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hunger=0..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hunger","min":0,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3665,"detail":0.044,"edges":0.5905,"complexity":0.2519,"coverage":0.8645,"colour":0.2004,"drift":0.0527},"knobResponse":[0.1297,0.0612,0.041,0.0703]},{"slug":"barrier-grid","title":"Barrier Grid","family":"type","round":66,"note":"낱말과 그 음화를 한 칸씩 엇갈려 짠 인쇄 위로 슬릿 난 막대 격자가 한 칸씩 미끄러져, 금빛 「빛」이 파란 바탕의 검은 「빛」으로 뒤집히고 네 걸음마다 다음 낱말이 와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-barrier-grid","type":"code","name":"barrier-grid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Frames=2..4, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Frames","min":2,"max":4},{"name":"Tilt","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.3479,"detail":0.3165,"edges":0.8138,"complexity":0.2788,"coverage":0.705,"colour":0.2937,"drift":0.3806},"knobResponse":[0.1993,0.3596,0.1969,0.184]},{"slug":"barycentric-subdivision","title":"Barycentric Subdivision","family":"fractal","round":53,"note":"정삼각형을 세 중선으로 여섯 조각 내고 조각마다 또 그렇게 자른 모자이크 속으로, 카메라가 무작위로 고른 자식 삼각형을 따라 늘이지 않고 돌리고 키우기만 하며 파고들어요. 조각은 가장 큰 각으로 칠해져 둥근 것은 청록, 납작할수록 자홍을 지나 호박색이 되고, 흰 선이 앞으로 들어갈 세 걸음을 미리 그어요. K3 은 모자이크를 현재 삼각형 몇 단 아래까지 자르는지이고, K4 는 가장 둥근 자식을 고를 확률이라 0.4 부터는 삼각형이 납작해지지 않아요. 단추를 누르면 정삼각형에서 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-barycentric-subdivision","type":"code","name":"barycentric-subdivision","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=2..3, Steer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":2,"max":3},{"name":"Steer","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":2.6277,"detail":0.1339,"edges":0.5315,"complexity":1.9596,"coverage":0.935,"colour":0.358,"drift":0.2554},"knobResponse":[0.272,0.2244,0.0682,0.0697]},{"slug":"bat-emergence","title":"Bat Emergence","family":"halloween","round":42,"note":"해 질 녘 능선의 동굴 어귀에서 박쥐 떼가 몇 초마다 몰려나와 128줄을 다 타고 오르고, 위로 갈수록 흩어져요. 날개를 퍼덕이는 세 LED 박쥐가 보라에서 주황으로 내려오는 하늘에 검게 비치고, 띠는 연기처럼 꼬여 흔들리다 돌풍이 불면 한쪽으로 휘어요. K3 은 하늘의 박쥐를 400 마리에서 1200 마리로 늘리고, K4 는 띠를 네 번까지 꼬아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bat-emergence","type":"code","name":"bat-emergence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bats=400..1200, Swirl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":400,"max":1200},{"name":"Swirl","min":0,"max":1}],"start":[0,2,400,0.06],"measures":{"motion":0.8455,"detail":0.0412,"edges":0.8734,"complexity":0.2736,"coverage":0.9228,"colour":0.2777,"drift":0.0354},"knobResponse":[0.236,0.0382,0.0363,0.0282]},{"slug":"bat-form","title":"Bat Form","family":"halloween","round":51,"note":"어두운 탑 방의 뾰족한 창턱에 선 흡혈귀가 진홍과 주황의 해 질 녘을 등지고 팔을 들어 망토를 펼치고, 망토 단이 박쥐 날개의 물결로 갈라지며 작아져 하늘로 고리를 그리고 날아갔다 돌아와 다시 사람이 되어 망토를 여며요. K3 은 망토가 펼쳐지는 너비와 날개 크기, K4 는 멀리 언덕 위를 도는 작은 박쥐 떼의 수예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bat-form","type":"code","name":"bat-form","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cape=-1..1, Flock=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cape","min":-1,"max":1},{"name":"Flock","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3823,"detail":0.0385,"edges":0.2665,"complexity":0.7369,"coverage":0.723,"colour":0.3727,"drift":0.1422},"knobResponse":[0.1088,0.0636,0.0426,0.037]},{"slug":"bath-fizz","title":"Bath Fizz","family":"cosmetic","round":35,"note":"패널 아래에서 녹는 배스 파우더가 깊은 물속으로 안료 구름을 올려 보내요. 분홍에서 색상환을 따라 벌려 놓은 안료 세 가지가 버섯 머리로 말리며 128줄을 채우고 맞닿은 가장자리에서 섞여요. 가는 거품 줄기가 그 사이를 뚫고 올라가며 물을 끌어올려요. K3 은 거품을 1초에 60개에서 360개로 늘려 첫 구름이 위 20줄에 닿는 때를 7.6초에서 2.4초로 당기고, K1 을 누르면 세 색이 바닥에서 한꺼번에 터져요.","why":"색은 굵고 진한데 패널을 꽉 채워요(채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-bath-fizz","type":"code","name":"bath-fizz","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fizz=0..1, Mix=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fizz","min":0,"max":1},{"name":"Mix","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7842,"detail":0.0381,"edges":0.0956,"complexity":2.4963,"coverage":1,"colour":0.5925,"drift":0.2882},"knobResponse":[0.3666,0.2615,0.3734,0.0989]},{"slug":"baudot-tape","title":"Baudot Tape","family":"type","round":81,"note":"다섯 구멍 천공 테이프가 패널 높이로 올라가고, 줄마다 뚫린 ITA2 부호를 읽은 글자가 그 옆에 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-baudot-tape","type":"code","name":"baudot-tape","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Message=0..2, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Message","min":0,"max":2},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8595,"detail":0.0644,"edges":0.7746,"complexity":0.1195,"coverage":0.6499,"colour":0.1569,"drift":0.0601},"knobResponse":[0.112,0.0788,0.0379,0.0343]},{"slug":"bauhaus","title":"Bauhaus","family":"geometry","round":1,"note":"바우하우스 포스터처럼 납작한 원반과 막대가 2×4 칸에 놓이고, 한 칸씩 천천히 다른 모양이나 색으로 바뀌어요.","why":"모양은 프리셋과 가장 닮았는데 거의 안 움직여요(움직임 0.04).","block":1,"ramped":false,"layer":{"id":"layer-bauhaus","type":"code","name":"bauhaus","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pace=0.25..6, Grid=4..12, Line=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pace","min":0.25,"max":6},{"name":"Grid","min":4,"max":12},{"name":"Line","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0436,"detail":0.04,"edges":0.8787,"complexity":0.0601,"coverage":0.5555,"colour":0.5847,"drift":0.0591},"knobResponse":[0.3486,0.141,0.3458,0.2172]},{"slug":"beading-letters","title":"Beading Letters","family":"type","round":81,"note":"부어 쓴 액체 낱말의 획이 반지름의 9.6배 물결로 잘록해지다 끊겨, 같은 간격 방울로 찍은 점 글자가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beading-letters","type":"code","name":"beading-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thickness=1.5..2.5, Viscosity=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thickness","min":1.5,"max":2.5},{"name":"Viscosity","min":0,"max":1}],"start":[0,2,1.5,0.06],"measures":{"motion":0.3003,"detail":0.0414,"edges":0.4095,"complexity":0.6624,"coverage":0.1881,"colour":0.1705,"drift":0.1317},"knobResponse":[0.0758,0.088,0.0766,0.0503]},{"slug":"beam-letters","title":"Beam Letters","family":"type","round":79,"note":"전자빔 하나가 한 획 글꼴의 획을 따라 LET THERE BE LIGHT 를 쓰며 모서리와 획 끝에서 느려져 밝게 타고, 형광체의 잔광이 쓰는 차례를 따라 줄마다 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beam-letters","type":"code","name":"beam-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Phosphor=0..1, Speed=0.2..3, Persistence=0..1, Focus=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Phosphor","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Persistence","min":0,"max":1},{"name":"Focus","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0651,"detail":0.0457,"edges":0.4222,"complexity":0.6663,"coverage":0.1867,"colour":0.1016,"drift":0.1237},"knobResponse":[0.0363,0.0881,0.0352,0.0713]},{"slug":"beatty-rhythm","title":"Beatty Rhythm","family":"rhythm","round":76,"note":"⌊nφ⌋ 와 ⌊nφ²⌋ 두 목소리가 내려오는 박을 자홍과 초록으로 나눠 치고, 옆의 기울어진 격자 띠가 둘이 왜 겹치지도 비지도 않는지 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beatty-rhythm","type":"code","name":"beatty-rhythm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Alpha=0..1, Ticks=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Alpha","min":0,"max":1},{"name":"Ticks","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.1369,"detail":0.1552,"edges":1,"complexity":0.1063,"coverage":0.2651,"colour":0.5931,"drift":0.077},"knobResponse":[0.2644,0.1828,0.1732,0.1676]},{"slug":"beckett-gray","title":"Beckett-Gray","family":"rhythm","round":58,"note":"여섯 줄 악보가 한 박에 두 줄씩 내려와 64박 한 바퀴가 판에 다 서고, 박마다 바뀐 줄이 지금 선에서 번쩍여요. 막 들어온 연기자는 어둡다가 앞사람이 나갈 때마다 한 단씩 밝아져 맨 앞에서 하얘진 뒤 나가고, 반사 그레이 코드로 돌리면 퇴장 32번 가운데 26번이 차례를 어겨 빨갛게 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-beckett-gray","type":"code","name":"beckett-gray","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Code=0..3, Rows=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Code","min":0,"max":3},{"name":"Rows","min":2,"max":8}],"start":[0,2,0,2],"measures":{"motion":0.2581,"detail":0.0667,"edges":0.5613,"complexity":0.2026,"coverage":0.4106,"colour":0.3039,"drift":0.2116},"knobResponse":[0.114,0.2805,0.2976,0.2353]},{"slug":"belfry","title":"Belfry","family":"halloween","round":46,"note":"보라 폭풍 하늘 아래 종탑의 청동 종이 진자로 흔들리며 추가 테를 치고, 칠 때마다 박쥐가 쏟아져요. 시계는 30초에 한 시간을 가서 자정에 열두 번 울려요. K3 은 박쥐 수, K4 는 구름과 비와 번개이고, K1 을 누르면 바로 자정을 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-belfry","type":"code","name":"belfry","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bats=8..40, Storm=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":8,"max":40},{"name":"Storm","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.9809,"detail":0.0592,"edges":0.5694,"complexity":0.3567,"coverage":0.6981,"colour":0.3005,"drift":0.1162},"knobResponse":[0.1022,0.0353,0.0293,0.1095]},{"slug":"belt-trick","title":"Belt Trick","family":"topology","round":53,"note":"패널 가운데 정육면체가 위아래 가장자리 막대에 리본으로 묶인 채 한 축으로 쉬지 않고 돌아요. 한 바퀴를 돌면 리본이 정육면체를 한 번 감아 풀 수 없게 되고, 두 바퀴째에 리본이 정육면체를 돌아 넘어가며 곧게 풀려요. 뒤의 고리가 첫 바퀴엔 보라, 둘째 바퀴엔 초록으로 차올라 몇 번째 바퀴인지 보여요. K3 은 리본 수(2~8), K4 는 회전축의 기울기이고, 단추를 누르면 도는 방향이 거꾸로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-belt-trick","type":"code","name":"belt-trick","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ribbons=2..8, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ribbons","min":2,"max":8},{"name":"Tilt","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2433,"detail":0.043,"edges":0.6786,"complexity":0.2692,"coverage":0.2395,"colour":0.2437,"drift":0.0453},"knobResponse":[0.0922,0.0556,0.0846,0.0488]},{"slug":"benford-law","title":"Benford's Law","family":"data","round":76,"note":"1 에서 10 까지의 로그 자 위로 2 의 거듭제곱이 하나씩 떨어져, 첫 자리 띠마다 막대가 차오르다 벤퍼드의 몫을 뜻하는 한 직선에서 닫혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-benford-law","type":"code","name":"benford-law","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=0..8, Digit=1..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":0,"max":8},{"name":"Digit","min":1,"max":2}],"start":[0,2,0,1],"measures":{"motion":0.6321,"detail":0.0509,"edges":0.7369,"complexity":0.1028,"coverage":0.8981,"colour":0.4045,"drift":0.18},"knobResponse":[0.224,0.201,0.2081,0.217]},{"slug":"benton-pantograph","title":"Benton Pantograph","family":"type","round":71,"note":"위쪽 큰 본 글자의 윤곽을 스타일러스가 따라 돌면 팬터그래프 막대가 그 움직임을 줄여 아래 블랭크에 4분의 1 크기 글자를 새기고, 노브가 깎는 글자만 기울이거나 좁히고 넓혀서, 다 깎은 펀치가 BENTON, PUNCH, MATRIX, FAMILY 로 아래 두 줄에 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-benton-pantograph","type":"code","name":"benton-pantograph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slant=0..0.45, Width=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slant","min":0,"max":0.45},{"name":"Width","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7392,"detail":0.0576,"edges":0.5082,"complexity":0.4239,"coverage":0.3594,"colour":0.118,"drift":0.1152},"knobResponse":[0.0501,0.0737,0.0359,0.0474]},{"slug":"berggren-tree","title":"Berggren Tree","family":"number","round":62,"note":"피타고라스 세 수가 (3, 4, 5) 에서 한 세대씩 자라요. A 와 C 가지는 c − b = k² 과 c − a = 2n² 포물선을 따라 하늘색과 장밋빛으로 뻗고, 원시 세 수는 두 포물선이 만나는 마디에만 켜져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-berggren-tree","type":"code","name":"berggren-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Reach=-1..1, Root=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Reach","min":-1,"max":1},{"name":"Root","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6124,"detail":0.1119,"edges":0.994,"complexity":0.2155,"coverage":0.1899,"colour":0.1654,"drift":0.0779},"knobResponse":[0.05,0.1298,0.1469,0.1311]},{"slug":"bernoulli-convolutions","title":"Bernoulli Convolutions","family":"fractal","round":38,"note":"128줄 하나하나가 λ 하나에 대한 ±1 ±λ ±λ² … 의 분포예요. 위의 칸토어 먼지에서 아래의 매끈한 종까지 항이 하나 더해질 때마다 모든 점이 둘로 쪼개지고, λ 가 피소 수의 역수인 열네 줄에서는 합이 같은 점에 거듭 내려앉아 흰 금빛으로 타요. K3 은 동전을 한쪽으로 기울여 종을 오른쪽 벽으로 밀고, K1 을 누르면 항을 다 걷었다가 첫 항부터 다시 쌓아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-bernoulli-convolutions","type":"code","name":"bernoulli-convolutions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=0.5..0.95, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":0.5,"max":0.95},{"name":"Zoom","min":0,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.1052,"detail":0.0778,"edges":0.2761,"complexity":1.7226,"coverage":0.81,"colour":0.2382,"drift":0.0505},"knobResponse":[0.3122,0.0507,0.314,0.1288]},{"slug":"bertrand-paradox","title":"Bertrand Paradox","family":"data","round":33,"note":"지름 40 LED 의 원 셋이 세 칸에 하나씩 서서, 원마다 다른 뜻의 무작위로 현을 1초에 24개씩 긋고 현은 LED 하나씩 부서져 사라져요. 삼각형 변보다 긴 현은 자홍, 짧은 현은 초록이고, 옆 막대와 숫자가 긴 현의 몫을 세어 위 원은 1/3 로, 가운데는 1/2 로, 아래는 1/4 로 모여요. K3 을 올리면 선이 원마다 다른 밀도의 점묘가 되고, K1 을 누르면 원과 셈을 비우고 처음부터 다시 그어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-bertrand-paradox","type":"code","name":"bertrand-paradox","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Chords=0..1, Persist=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Chords","min":0,"max":1},{"name":"Persist","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3006,"detail":0.2269,"edges":0.8503,"complexity":0.2324,"coverage":0.2638,"colour":0.5757,"drift":0.0802},"knobResponse":[0.24,0.1255,0.1353,0.0538]},{"slug":"bi-phase","title":"Bi-Phase","family":"cosmetic","round":30,"note":"흔들어 섞은 이중층 클렌저가 패널 가득 기름 방울로 흩어졌다가, 방울끼리 합쳐 떠올라 위에 한 층으로 모이고 경계선이 맑게 서요. 그러고 나면 다시 흔들려요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-bi-phase","type":"code","name":"bi-phase","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Oil=0.3..0.6, Shake=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Oil","min":0.3,"max":0.6},{"name":"Shake","min":0,"max":1}],"start":[0,2,0.3,0.06],"measures":{"motion":0.0579,"detail":0.0044,"edges":0.0095,"complexity":0.6088,"coverage":1,"colour":0.3088,"drift":0.0284},"knobResponse":[0.1292,0.1228,0.1399,0.1113]},{"slug":"bicycle-tracks","title":"Bicycle Tracks","family":"line","round":57,"note":"앞바퀴 점이 세운 패널을 굽이치며 오르고 한 축거 뒤의 뒷바퀴 점은 늘 앞바퀴를 향해서만 굴러서, 뒷바퀴 자취가 굽이마다 안쪽을 질러가요. 두 자취 사이 초승달에는 뒷바퀴 자취의 접선이 꼭 한 축거 앞에서 앞바퀴 자취에 닿는 선분이 빗살처럼 서서, 자전거가 어느 쪽으로 갔는지 알려 줘요. 34초쯤마다 앞바퀴가 원을 두 바퀴 돌면 뒷바퀴는 반지름 √(r²−L²) 의 원으로 감겨 들고, 빠져나올 때는 곧게 나가는 앞바퀴 뒤로 트랙트릭스를 그려요. K3 은 축거(16~24 LED), K4 는 굽이마다 핸들을 꺾어 두는 각도(50~70도)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bicycle-tracks","type":"code","name":"bicycle-tracks","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wheelbase=16..24, Bar=50..70","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wheelbase","min":16,"max":24},{"name":"Bar","min":50,"max":70}],"start":[0,2,16,50],"measures":{"motion":0.5515,"detail":0.0432,"edges":0.3968,"complexity":0.8058,"coverage":0.2338,"colour":0.2462,"drift":0.1434},"knobResponse":[0.0617,0.1208,0.1256,0.1437]},{"slug":"big-type","title":"Big Type","family":"type","round":1,"note":"화면을 꽉 채운 낱말 하나가 자석을 댄 옛 텔레비전 화면처럼 휘어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-big-type","type":"code","name":"big-type","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..5, Word=0..6, Warp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":5},{"name":"Word","min":0,"max":6},{"name":"Warp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4681,"detail":0.0954,"edges":0.9989,"complexity":0.0628,"coverage":0.2402,"colour":0.253,"drift":0.0745},"knobResponse":[0.0865,0.0522,0.1361,0.0808]},{"slug":"biliteral-cipher","title":"Biliteral Cipher","family":"type","round":72,"note":"다섯 자씩 한 줄로 친 겉글을 읽는 빛이 글자마다 a 활자인지 b 활자인지 적고, 다섯이 차면 베이컨의 표대로 숨은 글자 하나가 아래 줄에 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-biliteral-cipher","type":"code","name":"biliteral-cipher","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Message=0..4, Tell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Message","min":0,"max":4},{"name":"Tell","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.057,"detail":0.1007,"edges":0.8951,"complexity":0.0811,"coverage":0.2301,"colour":0.1404,"drift":0.0426},"knobResponse":[0.0462,0.1227,0.1302,0.0424]},{"slug":"binary-lens","title":"Binary Lens","family":"space","round":61,"note":"서로 도는 두 질량이 만드는 확대 지도에서 밝은 커스틱이 뾰족점에서 만나며 별 모양 둘과 육각 고리, 가운데 작은 것과 세모 둘 사이를 오가요. 지도를 건너는 별의 밝기가 아래 띠에 흘러가며 커스틱을 넘을 때마다 솟아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-binary-lens","type":"code","name":"binary-lens","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mass ratio=0.2..1, Orbit=15..60","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mass ratio","min":0.2,"max":1},{"name":"Orbit","min":15,"max":60}],"start":[0,2,0.2,15],"measures":{"motion":0.5756,"detail":0.0511,"edges":0.1417,"complexity":1.4821,"coverage":0.8311,"colour":0.1924,"drift":0.0601},"knobResponse":[0.156,0.0531,0.0447,0.0554]},{"slug":"bismuth","title":"Bismuth","family":"mineral","round":18,"note":"녹은 비스무트 웅덩이에서 계단 진 네모 호퍼 결정이 가지를 치며 패널 꼭대기까지 자라요. 테라스마다 산화막이 은색에서 금색, 자홍, 파랑, 청록을 지나 두 번째 금색과 분홍으로 바뀌어서 색이 그 단이 생긴 때를 말해요. K1 을 누르면 웅덩이가 패널을 타고 올라 결정을 녹였다가 빠지고, 결정이 다시 자라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bismuth","type":"code","name":"bismuth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Steps=3..8, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Steps","min":3,"max":8},{"name":"Heat","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0634,"detail":0.155,"edges":0.6769,"complexity":1.8463,"coverage":0.7656,"colour":0.3505,"drift":0.1056},"knobResponse":[0.1563,0.1868,0.0876,0.1811]},{"slug":"black-cat","title":"Black Cat","family":"halloween","round":44,"note":"낮은 달 앞 담 위의 검은 고양이가 꼬리를 흔들고 박쥐를 눈으로 좇다가, 등을 활처럼 세우고 털을 곤두세워 하악거려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-black-cat","type":"code","name":"black-cat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mood=0..1, Startle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mood","min":0,"max":1},{"name":"Startle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3528,"detail":0.0576,"edges":0.4704,"complexity":0.4583,"coverage":0.6305,"colour":0.2863,"drift":0.1432},"knobResponse":[0.1545,0.0965,0.0557,0.1036]},{"slug":"blinking-vortex","title":"Blinking Vortex","family":"sim","round":67,"note":"아레프의 깜박이는 소용돌이 둘이 위아래로 60 LED 떨어져 반 주기씩 번갈아 돌고, 청록과 보라의 부드러운 띠가 늘고 접혀 LED 보다 가늘어지면 한 빛깔로 섞이다가 새 물감이 깔려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-blinking-vortex","type":"code","name":"blinking-vortex","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strength=2..16, Dye=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strength","min":2,"max":16},{"name":"Dye","min":0,"max":3}],"start":[0,2,2,0.06],"measures":{"motion":1.9524,"detail":0.0535,"edges":0.1285,"complexity":2.3556,"coverage":0.9995,"colour":0.3873,"drift":0.0906},"knobResponse":[0.326,0.2144,0.2142,0.2519]},{"slug":"bloch-oscillations","title":"Bloch Oscillations","family":"wave","round":56,"note":"한 자리에서 출발한 입자가 기운 사슬 위에서 렌즈 모양으로 50자리까지 퍼졌다가 한 점으로 돌아오기를 되풀이하며 위로 흘러가요. 색은 준운동량이라서 힘이 띠를 감는 동안 렌즈 가장자리 색이 돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bloch-oscillations","type":"code","name":"bloch-oscillations","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Force=0.16..0.64, Width=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Force","min":0.16,"max":0.64},{"name":"Width","min":0,"max":1}],"start":[0,2,0.16,0.06],"measures":{"motion":1.5543,"detail":0.1156,"edges":0.5608,"complexity":1.8221,"coverage":0.5888,"colour":0.3107,"drift":0.2251},"knobResponse":[0.1747,0.2739,0.2211,0.2305]},{"slug":"blooming-gel","title":"Blooming Gel","family":"cosmetic","round":36,"note":"젖은 블루밍 베이스에 코발트와 라일락, 흰 젤 방울이 하나씩 떨어져 가장자리가 해진 꽃처럼 번지고, 안료는 번지는 앞선으로 밀려 테두리가 짙어져요. 6.2초를 그리고 나면 경화 램프 띠가 위에서 아래로 지나며 무늬를 굳히고, 닦아 낸 새 베이스에서 다시 시작해요. K3 은 방울 크기와 번지는 거리를 정하고, K1 을 누르면 방울 하나가 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-blooming-gel","type":"code","name":"blooming-gel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bloom=0..1, Rim=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bloom","min":0,"max":1},{"name":"Rim","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0712,"detail":0.0141,"edges":0.1484,"complexity":1.601,"coverage":1,"colour":0.1697,"drift":0.0438},"knobResponse":[0.2098,0.0709,0.1051,0.0332]},{"slug":"blotting-paper","title":"Blotting Paper","family":"cosmetic","round":39,"note":"결이 비치는 얇은 기름종이가 살에 눌린 자리마다 피지를 빨아들여, 반투명한 점이 결을 따라 √t 로 번지고 합쳐져요. 젖은 자리는 뒤 벽의 빛이 비쳐 밝고 짙은 색이 되고, LED 마다 한 번만 밝아져요. 종이가 거의 다 비치면 새 종이가 내려와 덮어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-blotting-paper","type":"code","name":"blotting-paper","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pores=20..80, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pores","min":20,"max":80},{"name":"Grain","min":0,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.0572,"detail":0.0504,"edges":0.1413,"complexity":1.9288,"coverage":1,"colour":0.225,"drift":0.3434},"knobResponse":[0.1516,0.0572,0.0394,0.0465]},{"slug":"bokeh","title":"Bokeh","family":"light","round":1,"note":"초점이 나간 밤거리 불빛이에요. 여섯 모 진 빛 원반이 피었다 흘러가며 겹친 자리만 부드럽게 밝아져요.","why":"흐린 빛 원이 떠다녀요. 0609, 0524 처럼 번진 빛 덩어리예요.","block":0,"ramped":false,"layer":{"id":"layer-bokeh","type":"code","name":"bokeh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pace=0.2..4, Size=-1..1, Lights=40..90","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pace","min":0.2,"max":4},{"name":"Size","min":-1,"max":1},{"name":"Lights","min":40,"max":90}],"start":[0,2,0,40],"measures":{"motion":0.9868,"detail":0.0384,"edges":0.1836,"complexity":1.7001,"coverage":0.5358,"colour":0.318,"drift":0.3822},"knobResponse":[0.2498,0.2782,0.2491,0.2757]},{"slug":"bone-jig","title":"Bone Jig","family":"halloween","round":43,"note":"패널 키만 한 해골이 아래에서 올라오는 독한 초록 빛 위에서 턱을 딱딱거리며 춤춰요. 깡충 지그, 옆차기, 팔 휘돌리기, 엉덩이 흔들기, 한 바퀴 돌기, 오들오들 떨기를 96 bpm 으로 25초에 한 번씩 돌아요. K3 은 0.6 크기 해골을 뒤에 둘까지 세우고 K4 는 뼈마다 보라로 스러지는 잔상을 남기며, K1 을 누르면 머리가 패널 위로 튀어 나가 두 바퀴 돌고 1.4초 만에 목에 다시 앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bone-jig","type":"code","name":"bone-jig","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Dancers=1..3, Trails=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dancers","min":1,"max":3},{"name":"Trails","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.4633,"detail":0.0641,"edges":0.4215,"complexity":0.7536,"coverage":0.2639,"colour":0.1233,"drift":0.1064},"knobResponse":[0.0356,0.118,0.0359,0.0585]},{"slug":"bone-pile","title":"Bone Pile","family":"halloween","round":48,"note":"보랏빛 조명 아래 지하 묘실에서 춤추던 해골이 박자에 맞춰 와르르 무너져 바닥에 뼈 더미로 쌓이고, 해골 눈에 빛이 들면 뼈가 발부터 하나씩 포물선을 그리며 날아올라 제자리에 끼워지고 마지막에 머리가 내려앉아 끄덕인 뒤 다시 춤춰요. K3 은 무너지기 전에 추는 박자 수, K4 는 땅안개이고, K1 을 누르면 바로 무너져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bone-pile","type":"code","name":"bone-pile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dance=4..32, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dance","min":4,"max":32},{"name":"Fog","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.5905,"detail":0.0945,"edges":0.5574,"complexity":0.3887,"coverage":0.8965,"colour":0.1276,"drift":0.0606},"knobResponse":[0.0687,0.1358,0.0743,0.0616]},{"slug":"book-from-the-sky","title":"Book from the Sky","family":"type","round":71,"note":"부수와 부품을 실제 한자의 틀에 맞춰 지어낸 읽을 수 없는 글자가 괘선 친 세로줄 다섯을 채우고, 얇은 새 종이가 오른쪽부터 덮여 밑의 쪽이 비치는 채로 한 줄씩 위에서 아래로 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-book-from-the-sky","type":"code","name":"book-from-the-sky","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Ink=0..1, Speed=0.2..3, Strokes=-1..1, Notes=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Ink","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strokes","min":-1,"max":1},{"name":"Notes","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0481,"detail":0.254,"edges":0.6947,"complexity":1.0115,"coverage":0.7695,"colour":0.075,"drift":0.073},"knobResponse":[0.7099,0.0504,0.1819,0.1881]},{"slug":"borromean-rings","title":"Borromean Rings","family":"topology","round":33,"note":"테이트의 보로메오 고리를 황금 직사각형 세 장으로 만들고 세로로 2.3배 늘여 세웠어요. 하늘색 고리가 키 크게 서고 분홍 고리가 그것을 가로지르며 연두 고리가 허리를 둘러 20초에 한 바퀴 돌고, 앞 관이 뒤 관을 지나는 자리마다 LED 한 줄이 어두워져 위아래가 읽혀요. K3 은 직사각형의 긴 변 비를 1.618 에서 2.4 까지 바꾸고, K1 을 누르면 분홍 고리가 사라진 동안 연두 고리가 긴 고리 아래 끝으로 빠져나갔다 돌아와요.","why":"고리 셋이 작고 느려요.","block":1,"ramped":false,"layer":{"id":"layer-borromean-rings","type":"code","name":"borromean-rings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Aspect=1.618..2.4, Tube=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Aspect","min":1.618,"max":2.4},{"name":"Tube","min":0,"max":1}],"start":[0,2,1.618,0.06],"measures":{"motion":0.1873,"detail":0.0417,"edges":0.4546,"complexity":0.6755,"coverage":0.2581,"colour":0.1929,"drift":0.1053},"knobResponse":[0.1012,0.1249,0.077,0.0449]},{"slug":"borsuk-ulam","title":"Borsuk-Ulam","family":"topology","round":39,"note":"기온과 기압이 천천히 바뀌는 지구가 돌아요. 위 원판은 앞 반구, 아래 원판은 뒤 반구라서 −x 가 x 와 같은 자리에 그려지고, 대척점과 기온이 같은 흰 선과 기압이 같은 자홍 선이 두 원판의 같은 자리를 지나요. 두 선이 만나는 금색 점이 보르수크-울람 정리가 늘 있다고 하는 대척점 쌍이에요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-borsuk-ulam","type":"code","name":"borsuk-ulam","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Degree=3..6, Speed=0.2..3, Weather=0..1, Hue=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Degree","min":3,"max":6},{"name":"Speed","min":0.2,"max":3},{"name":"Weather","min":0,"max":1},{"name":"Hue","min":0,"max":1}],"start":[3,2,0,0.06],"measures":{"motion":0.3065,"detail":0.0677,"edges":0.3854,"complexity":1.6473,"coverage":0.7507,"colour":0.3391,"drift":0.0903},"knobResponse":[0.1438,0.1696,0.1763,0.2221]},{"slug":"boustrophedon","title":"Boustrophedon","family":"type","round":69,"note":"빛 한 점이 쟁기처럼 고랑 스무 줄을 갈며 헤시오도스의 두루미 대목을 한 줄은 왼쪽에서 오른쪽으로, 다음 줄은 글자를 거울에 비춘 채 오른쪽에서 왼쪽으로 새기고, 앞에서는 지난번에 써서 식은 글자를 갈아엎어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-boustrophedon","type":"code","name":"boustrophedon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Way=-1..1, Words=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Way","min":-1,"max":1},{"name":"Words","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.033,"detail":0.321,"edges":0.3873,"complexity":2.0984,"coverage":0.8968,"colour":0.1258,"drift":0.0301},"knobResponse":[0.1032,0.0855,0.0985,0.1862]},{"slug":"bowling-lane","title":"Bowling Lane","family":"sport","round":22,"note":"볼러 뒤에서 본 10핀 레인이에요. 공이 오일 위로 제 반사를 끌며 휘어 올라가 핀을 흩고, 스위프 바가 데드우드를 쓸어 낸 뒤 핀이 다시 서요. 처음에는 블랙라이트 아래 핀과 화살표, 오일이 빛나고, K4 를 올리면 나무 레인에 하우스 조명이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bowling-lane","type":"code","name":"bowling-lane","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Ball=0..1, Speed=0.2..3, Hook=0..1, Lights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Ball","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hook","min":0,"max":1},{"name":"Lights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1625,"detail":0.0689,"edges":0.5323,"complexity":1.7471,"coverage":0.9404,"colour":0.2104,"drift":0.042},"knobResponse":[0.0566,0.0281,0.0252,0.2377]},{"slug":"boys-surface","title":"Boy's Surface","family":"topology","round":31,"note":"사영 평면을 3차원에 담은 보이 곡면이 위 칸에서 세 겹 대칭축으로 돌고, 수평면이 오르내리며 자른 곡선이 아래 칸에 위에서 본 그림으로 떠요. 평면 아래는 단단하고 위는 옅은 유리라 안쪽에서 앞면과 뒷면이 만나는 이음매가 보여요. K1 을 누르면 평면이 삼중점에 멈춰 세 고리가 한 점을 지나요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-boys-surface","type":"code","name":"boys-surface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Bands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2388,"detail":0.0514,"edges":0.351,"complexity":1.1851,"coverage":0.4559,"colour":0.1933,"drift":0.0801},"knobResponse":[0.0711,0.1334,0.081,0.0395]},{"slug":"brachistochrone","title":"Brachistochrone","family":"physics","round":39,"note":"왼쪽 위 한 점에서 구슬 다섯이 직선, 갈릴레이의 원호, 포물선, 깊이 떨어지는 길, 사이클로이드를 타고 함께 미끄러져요. 직선보다 긴 길을 타는 사이클로이드의 구슬이 먼저 닿고, 구슬이 지금까지 닿을 수 있는 점들의 앞면이 고리를 남기며 패널 아래까지 퍼져요. 한 판 걸러 사이클로이드의 여러 높이에서 놓은 구슬이 바닥에 함께 닿아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-brachistochrone","type":"code","name":"brachistochrone","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Gravity=0.2..3, End=0..1, Tracks=5..13","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Gravity","min":0.2,"max":3},{"name":"End","min":0,"max":1},{"name":"Tracks","min":5,"max":13}],"start":[0,2,0,5],"measures":{"motion":0.2086,"detail":0.0362,"edges":0.3333,"complexity":0.8549,"coverage":0.2988,"colour":0.08,"drift":0.1306},"knobResponse":[0.0398,0.0764,0.0473,0.038]},{"slug":"braille-relief","title":"Braille Relief","family":"type","round":67,"note":"루이 브라유의 여섯 점 글자로 헬렌 켈러의 우물가 두 문장을 네 쪽에 새기고, 3~20도로 낮게 도는 램프가 점마다 밝은 쪽과 긴 그림자를 그리는 동안 손끝이 한 칸씩 읽으면 그 칸 밑에 활자가 작게 떠올랐다 사라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-braille-relief","type":"code","name":"braille-relief","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Relief=0.4..2.4, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Relief","min":0.4,"max":2.4},{"name":"Light","min":0,"max":1}],"start":[0,2,0.4,0.06],"measures":{"motion":0.0705,"detail":0.0559,"edges":0.3053,"complexity":1.5414,"coverage":0.8712,"colour":0.076,"drift":0.0705},"knobResponse":[0.0463,0.0637,0.0557,0.0539]},{"slug":"brazil-nut","title":"Brazil Nut","family":"particle","round":77,"note":"쌓인 원판을 통째로 들었다 가라앉히는 흔들기마다, 일곱 띠로 칠한 작은 원판 540개 사이를 큰 원판 하나가 바닥에서 꼭대기까지 52초에 올라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-brazil-nut","type":"code","name":"brazil-nut","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Amplitude=-1..1, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Amplitude","min":-1,"max":1},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.6152,"detail":0.2389,"edges":0.6546,"complexity":2.3526,"coverage":0.797,"colour":0.4151,"drift":0.0568},"knobResponse":[0.2996,0.2242,0.2383,0.2333]},{"slug":"bread-mould","title":"Bread Mould","family":"fungi","round":21,"note":"도마 위 식빵 두 쪽이 곰팡이로 덮여 가는 저속 촬영이에요. 내려앉은 포자에서 흰 테를 두른 푸른곰팡이와 검은 털곰팡이가 고리를 그리며 번지고, 다 덮이면 새 두 쪽이 옆에서 밀려 들어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-bread-mould","type":"code","name":"bread-mould","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Mould=0..3, Speed=0.2..3, Spores=4..40, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Mould","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Spores","min":4,"max":40},{"name":"Damp","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.3259,"detail":0.0597,"edges":0.2499,"complexity":2.3664,"coverage":0.9889,"colour":0.1543,"drift":0.3583},"knobResponse":[0.188,0.3046,0.062,0.1018]},{"slug":"breath","title":"Breath","family":"body","round":24,"note":"후두에서 횡격막까지 해부도처럼 그린 폐가 숨을 쉬어요. 들이쉬면 횡격막이 내려가고 갈비뼈가 들리며, 푸르스름한 공기가 일곱 번 더 갈라지는 기관지를 타고 내려가 보랏빛 허파꽈리를 빨갛게 물들여요. K1 이 맑은 공기에서 입김이 하얗게 서리는 겨울과 매연 낀 도시까지 공기를 바꾸고, K1 을 누르면 기침을 해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-breath","type":"code","name":"breath","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Air=0..1, Rate=0.2..3, Depth=0..1, Altitude=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Air","min":0,"max":1},{"name":"Rate","min":0.2,"max":3},{"name":"Depth","min":0,"max":1},{"name":"Altitude","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3669,"detail":0.0863,"edges":0.4238,"complexity":2.0569,"coverage":0.8446,"colour":0.207,"drift":0.1347},"knobResponse":[0.0972,0.1294,0.1076,0.1068]},{"slug":"brick-factory","title":"Brick Factory","family":"geometry","round":74,"note":"완전 이분 그래프 K(m,n) 의 꼭짓점이 패널에 흩어져 떠도는 동안 변의 교차점마다 불꽃이 켜졌다 꺼지고, 그림이 자란키에비치의 가로세로 축 그림으로 풀리면 아래 세는 수가 Z(m,n) 까지 내려가 금빛으로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-brick-factory","type":"code","name":"brick-factory","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, m=4..6, n=6..9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"m","min":4,"max":6},{"name":"n","min":6,"max":9}],"start":[0,2,4,6],"measures":{"motion":0.3382,"detail":0.0689,"edges":0.6273,"complexity":0.6985,"coverage":0.2305,"colour":0.1466,"drift":0.1188},"knobResponse":[0.0613,0.1169,0.0549,0.115]},{"slug":"brillouin-zones","title":"Brillouin Zones","family":"cells","round":46,"note":"격자점 가운데 원점보다 가까운 것의 수로 LED 를 칠해, 가운데 1구역 둘레로 조각 난 구역 스무 개가 무지개 차례로 퍼져요. 때때로 한 구역의 조각들이 제 격자 벡터만큼 미끄러져 1구역에 꼭 맞게 들어가요. K3 은 칸 크기, K4 는 격자의 기울기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-brillouin-zones","type":"code","name":"brillouin-zones","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zones=16..48, Shear=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zones","min":16,"max":48},{"name":"Shear","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.5234,"detail":0.161,"edges":0.9828,"complexity":0.3382,"coverage":1,"colour":0.613,"drift":0.2583},"knobResponse":[0.3991,0.2962,0.3186,0.2228]},{"slug":"broad-nib","title":"Broad Nib","family":"type","round":64,"note":"넓적한 펜촉이 라틴어 경구를 한 줄에 한 낱말씩 획 차례대로 써 내려가고, 획마다 펜촉 각도와 만나는 방향에 따라 굵거나 가늘어져요. K1 로 펜촉을 돌리면 다 쓴 글자까지 그 자리에서 다시 칠해져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-broad-nib","type":"code","name":"broad-nib","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Angle=30..180, Speed=0.2..3, Weight=-1..1, Slant=0..20","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Angle","min":30,"max":180},{"name":"Speed","min":0.2,"max":3},{"name":"Weight","min":-1,"max":1},{"name":"Slant","min":0,"max":20}],"start":[30,2,0,0.06],"measures":{"motion":0.0389,"detail":0.1062,"edges":0.6307,"complexity":0.7952,"coverage":0.4305,"colour":0.1835,"drift":0.1337},"knobResponse":[0.1534,0.2462,0.119,0.1653]},{"slug":"brownian-frontier","title":"Brownian Frontier","family":"line","round":40,"note":"단순 무작위 걸음이 지나간 자리를 어두운 파랑으로, 바깥에 닿은 경계를 금빛 선으로 그려요. 걸음이 밖으로 나갔다 돌아와 경계를 먹을 때마다 주황 고리가 남고, 화면은 길을 따라 물러나 늘 패널을 채워요. K4 는 지난 경계를 겹겹의 주황 등고선으로 오래 남기고, K1 을 누르면 새 길이 시작돼요.","why":"검은 바탕의 덩어리는 좋은데 테두리 결이 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-brownian-frontier","type":"code","name":"brownian-frontier","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Trail=0..1, Speed=0.2..3, Fine=1..3, Rings=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Trail","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fine","min":1,"max":3},{"name":"Rings","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3651,"detail":0.0663,"edges":0.6024,"complexity":0.3231,"coverage":0.1928,"colour":0.1546,"drift":0.1284},"knobResponse":[0.0485,0.1252,0.1255,0.0359]},{"slug":"brushstrokes","title":"Brushstrokes","family":"noise","round":17,"note":"반 고흐의 「별이 빛나는 밤」을 짧고 두꺼운 붓질로 칠하고 또 칠해요. 흐름을 따라 놓인 군청과 코발트 붓질이 노란 별무리와 초승달을 감아 돌고, 불꽃처럼 솟은 사이프러스 옆 마을에 창이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-brushstrokes","type":"code","name":"brushstrokes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Flow=0.2..3, Length=4..12, Swirl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Flow","min":0.2,"max":3},{"name":"Length","min":4,"max":12},{"name":"Swirl","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0383,"detail":0.0951,"edges":0.2993,"complexity":2.3542,"coverage":0.998,"colour":0.5763,"drift":0.0278},"knobResponse":[0.4036,0.1538,0.1578,0.1518]},{"slug":"buffon-noodle","title":"Buffon's Noodle","family":"data","round":55,"note":"16 LED 간격의 바닥 선 위로 바늘이 1초에 10개씩 떨어져서, 선을 건넌 바늘은 금색, 못 건넌 바늘은 하늘색이 되고 건넌 자리마다 선 위에 흰 눈금이 서요. 아래에서는 떨어뜨린 길이와 건넌 횟수로 셈한 π 가 숫자와 자취로 흔들리며 다가가요. K3 은 바늘 길이(선 간격 × π 의 0.2~1배), K4 는 같은 길이 그대로 바늘을 휘는 정도예요. 길이 1 에서 다 휘면 지름 16 의 고리가 매번 꼭 두 번 건너서 숫자가 3.1416 에 멈추고, 단추를 누르면 셈을 처음부터 다시 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-buffon-noodle","type":"code","name":"buffon-noodle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=0.2..1, Bend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":0.2,"max":1},{"name":"Bend","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.3023,"detail":0.1243,"edges":0.8619,"complexity":0.4124,"coverage":0.1954,"colour":0.1973,"drift":0.1017},"knobResponse":[0.0469,0.06,0.1245,0.0711]},{"slug":"bulgarian-solitaire","title":"Bulgarian Solitaire","family":"number","round":44,"note":"바닥에 선 카드 더미마다 맨 위 한 장이 떠올라 새 더미로 쌓이고, 옛 더미가 비킨 자리에 새 더미가 떨어져요. 열 장은 아무리 늦어도 열두 수 만에 4, 3, 2, 1 계단에 닿아 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-bulgarian-solitaire","type":"code","name":"bulgarian-solitaire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..6, Size=4..8, Extra=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":6},{"name":"Size","min":4,"max":8},{"name":"Extra","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.6686,"detail":0.0383,"edges":1,"complexity":0.0703,"coverage":0.2377,"colour":0.3144,"drift":0.259},"knobResponse":[0.1051,0.1873,0.177,0.1723]},{"slug":"burrows-wheeler","title":"Burrows-Wheeler","family":"algo","round":55,"note":"128자 글의 회전 128개가 한 줄씩 쌓여 사선 줄무늬로 섰다가 1초 동안 정렬된 자리로 미끄러지면 오른쪽 끝의 마지막 글자 열이 같은 글자끼리 덩어리로 모이고, 행들이 이웃과 갈리는 글자까지만 남았다가 첫 글자와 마지막 글자 열만 빼고 흐려진 뒤 LF 걸음을 따라 한 줄씩 다시 살아나요. K3 은 글의 짜임으로 무작위 글에서 스투름 단어까지 가고, K4 는 글자 수(2~6)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-burrows-wheeler","type":"code","name":"burrows-wheeler","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=0..3, Letters=2..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":0,"max":3},{"name":"Letters","min":2,"max":6}],"start":[0,2,0,2],"measures":{"motion":1.4193,"detail":0.3669,"edges":0.7602,"complexity":0.1296,"coverage":0.8191,"colour":0.3774,"drift":0.273},"knobResponse":[0.3007,0.3445,0.3069,0.2824]},{"slug":"busy-beaver","title":"Busy Beaver","family":"algo","round":62,"note":"튜링 기계가 테이프를 가로로, 시간을 아래로 써요. 다섯 상태 챔피언의 47,176,870 걸음이 1분 동안 뒤로 물러나는 그림 속에 고리 하나에 삼각형 하나씩 쌓이고, 머리가 꺾인 자리가 금색과 장밋빛 빗변을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-busy-beaver","type":"code","name":"busy-beaver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Machine=0..3, Clock=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Machine","min":0,"max":3},{"name":"Clock","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1764,"detail":0.0319,"edges":0.6847,"complexity":0.1743,"coverage":0.5524,"colour":0.2528,"drift":0.1335},"knobResponse":[0.1731,0.184,0.4088,0.1937]},{"slug":"calabi-yau","title":"Calabi-Yau Quintic","family":"space","round":51,"note":"5차 페르마 곡선 z1^5 + z2^5 = 1 을 핸슨의 25 조각으로 지어 공간에 세우면, 조각마다 색이 다른 주름진 공이 천천히 돌며 다섯 조각이 한 점에 모이는 이음매를 보여요. K3 은 허수부를 섞는 투영각 α, K4 는 25 조각을 떼어 놓는 펼친 그림이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-calabi-yau","type":"code","name":"calabi-yau","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Angle=-45..45, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Angle","min":-45,"max":45},{"name":"Spread","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2146,"detail":0.0444,"edges":0.3684,"complexity":1.1186,"coverage":0.3875,"colour":0.2484,"drift":0.108},"knobResponse":[0.1075,0.1074,0.0983,0.1881]},{"slug":"calculator-words","title":"Calculator Words","family":"type","round":69,"note":"패널을 채운 계산기가 1 − .2266 = 같은 작은 셈을 키를 밝히며 쳐 넣고 180도 돌아누우면, 7세그먼트의 0.7734 가 hELLO 로 읽히고 소수점은 낱말 위쪽에 걸려 있다가 다시 돌아와 다음 셈을 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-calculator-words","type":"code","name":"calculator-words","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Words=0..3, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Words","min":0,"max":3},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4914,"detail":0.0368,"edges":0.3074,"complexity":0.3771,"coverage":0.6093,"colour":0.1269,"drift":0.2016},"knobResponse":[0.065,0.1634,0.1666,0.0403]},{"slug":"cam-wave","title":"Cam Wave","family":"machine","round":15,"note":"발치의 캠축이 돌면 캠마다 막대를 밀어 올리고, 막대 끝에 걸린 구슬 띠가 물결이 되어 옆으로 흘러가요. K1 을 누르면 캠이 둥근 편심에서 달걀꼴, 달팽이꼴로 바뀌어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-cam-wave","type":"code","name":"cam-wave","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cams=6..12, Phase=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cams","min":6,"max":12},{"name":"Phase","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.4062,"detail":0.0758,"edges":0.6341,"complexity":0.5068,"coverage":0.4175,"colour":0.2693,"drift":0.1185},"knobResponse":[0.0838,0.0978,0.1488,0.0628]},{"slug":"canard-explosion","title":"Canard Explosion","family":"rhythm","round":61,"note":"반 데르 폴 진동자가 작은 호프 고리에서 반발 가지를 타는 머리 없는 오리와 머리 달린 오리를 지나 완화 진동까지 차례로 걸어가고, 지나온 고리가 색 띠로 겹겹이 남아요. 아래에서는 x(t) 가 흘러내리며 잔물결이 긴 톱니로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-canard-explosion","type":"code","name":"canard-explosion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Epsilon=0.04..0.2, Pace=0.6..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Epsilon","min":0.04,"max":0.2},{"name":"Pace","min":0.6,"max":3}],"start":[0,2,0.04,0.6],"measures":{"motion":0.4103,"detail":0.0497,"edges":0.527,"complexity":0.55,"coverage":0.6685,"colour":0.1538,"drift":0.0839},"knobResponse":[0.0566,0.0578,0.0741,0.0664]},{"slug":"candle-vigil","title":"Candle Vigil","family":"halloween","round":42,"note":"어두운 보랏빛 바닥에 선 초 세 자루의 불꽃이 흔들리고, 따뜻한 빛무리가 그 깜빡임을 따라 숨 쉬어요. 가끔 바람이 불꽃을 다 한쪽으로 눕히고, 한 불꽃이 꺼져 연기 한 줄을 올린 뒤 다시 붙어요. K3 은 초를 여섯 자루까지 세우고, K4 는 바람과 꺼짐을 잦게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-candle-vigil","type":"code","name":"candle-vigil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Candles=3..6, Draft=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Candles","min":3,"max":6},{"name":"Draft","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.3206,"detail":0.0241,"edges":0.2327,"complexity":0.8369,"coverage":0.7844,"colour":0.2233,"drift":0.1344},"knobResponse":[0.056,0.0467,0.1409,0.0796]},{"slug":"candy-corn","title":"Candy Corn","family":"halloween","round":45,"note":"캔디콘 알이 세 갈래로 쏟아져 128줄을 뒹굴며 내려오고, 바닥 더미에 튀었다가 비탈을 미끄러져 아무 각도로나 누워요. 더미가 차면 바닥이 뚜껑문처럼 양쪽으로 열려 더미가 쏟아져 나가고, 그동안에도 사탕은 계속 내려와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-candy-corn","type":"code","name":"candy-corn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pour=14..44, Bounce=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pour","min":14,"max":44},{"name":"Bounce","min":0,"max":1}],"start":[0,2,14,0.06],"measures":{"motion":1.9963,"detail":0.0647,"edges":0.8061,"complexity":0.2587,"coverage":0.2371,"colour":0.3719,"drift":0.2091},"knobResponse":[0.0427,0.1666,0.2292,0.1127]},{"slug":"cantor-scalogram","title":"Cantor Scalogram","family":"data","round":82,"note":"칸토어 계단의 웨이블릿 변환을 세로로 자리, 가로로 로그 크기에 펼치면 계수 크기가 칸토어 집합처럼 둘씩 갈라지는 나무가 되고, 위상을 색으로 칠해 가는 가지일수록 LED 마다 색이 바뀌며, 6초마다 3배 당겨 들어가 같은 그림으로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cantor-scalogram","type":"code","name":"cantor-scalogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=1..8, Omega=3..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":1,"max":8},{"name":"Omega","min":3,"max":8}],"start":[0,2,1,3],"measures":{"motion":1.5062,"detail":0.1033,"edges":0.5815,"complexity":2.2753,"coverage":0.2775,"colour":0.1894,"drift":0.2254},"knobResponse":[0.1022,0.2221,0.2523,0.167]},{"slug":"cardinal-vowels","title":"Cardinal Vowels","family":"type","round":77,"note":"존스의 모음 사각형 위를 혀의 점이 떠돌고, 가장 가까운 기본 모음이 괄호 사이에 크게 서서 이웃 모음이나 입술 짝으로 녹아 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cardinal-vowels","type":"code","name":"cardinal-vowels","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cardinal=0..8, Lips=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cardinal","min":0,"max":8},{"name":"Lips","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0756,"detail":0.0472,"edges":0.7432,"complexity":0.4452,"coverage":0.1745,"colour":0.229,"drift":0.0589},"knobResponse":[0.0758,0.0484,0.0525,0.0743]},{"slug":"cat-eye","title":"Cat Eye","family":"cosmetic","round":34,"note":"보랏빛 젤리 폴리시 밑으로 보이지 않는 막대 자석이 미끄러지면, 자성 반짝이가 자기장을 따라 돌아 자기장이 표면과 나란한 자리에 날카로운 빛줄기 하나가 서고 그 양옆은 곧추선 반짝이로 짙어져요. 자석이 지나간 자리의 반짝이는 1.8초에 걸쳐 흩어진 은하 같은 반짝임으로 돌아가요. K3 은 막대를 둘로 늘려 줄 두 개나 별 모양을 세우고, K1 을 누르면 자석이 멀어졌다 돌아와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cat-eye","type":"code","name":"cat-eye","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Magnet=-1..1, Depth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Magnet","min":-1,"max":1},{"name":"Depth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3686,"detail":0.0762,"edges":0.2839,"complexity":2.114,"coverage":0.9599,"colour":0.1236,"drift":0.1602},"knobResponse":[0.1875,0.1414,0.1895,0.1794]},{"slug":"cat-map","title":"Cat Map","family":"noise","round":31,"note":"패널을 토러스로 보고 아르놀트의 고양이 사상을 두 번의 밀기로 나눠 움직여요. 과녁 무늬가 사선 줄무늬로 늘어나다 잡음이 되고, 한 바퀴의 절반쯤에 줄이 엇갈린 유령이 지나간 뒤 30초에 처음 그림으로 정확히 돌아와요. K1 을 누르면 돌아오기 네 걸음 앞으로 건너뛰어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-cat-map","type":"code","name":"cat-map","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Twist=1..4, Picture=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Twist","min":1,"max":4},{"name":"Picture","min":0,"max":3}],"start":[0,2,1,0.06],"measures":{"motion":2.7145,"detail":0.107,"edges":0.6749,"complexity":0.5255,"coverage":1,"colour":0.5686,"drift":0.058},"knobResponse":[0.4614,0.2648,0.264,0.2979]},{"slug":"catastrophe-machine","title":"Catastrophe Machine","family":"physics","round":36,"note":"원판 테두리의 한 점에 고무줄 둘을 묶어 하나는 위의 고정점에, 하나는 아래를 좌우로 오가는 점 B 에 걸었어요. B 가 뾰족점 넷인 마름모, 곧 원판이 설 자리가 둘인 곳을 빠져나가는 순간 원판이 120도쯤 반대로 튀어서, B 의 자취가 가는 길과 오는 길에서 다른 색으로 남아요. K3 은 고무줄의 자연 길이를 줄여 마름모를 작게 하다가 1 에서 없애고, K1 을 누르면 B 가 축 건너편으로 건너뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-catastrophe-machine","type":"code","name":"catastrophe-machine","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tension=0..1, Depth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tension","min":0,"max":1},{"name":"Depth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.213,"detail":0.0332,"edges":0.4458,"complexity":0.4561,"coverage":0.1952,"colour":0.1001,"drift":0.0525},"knobResponse":[0.0365,0.0378,0.0477,0.0428]},{"slug":"catenoid-helicoid","title":"Catenoid-Helicoid","family":"space","round":53,"note":"체커판을 칠한 나선면이 축을 따라 패널을 세로로 채운 채 돌다가, 늘어나지 않고 현수면으로 풀렸다가 반대쪽으로 다시 감기는데, 칸은 내내 같은 크기의 정사각형이고 축의 금빛 선은 현수면의 허리 원이 돼요. K3 은 한 바퀴의 칸 수(12~36), K4 는 내려다보는 각이고, 단추를 누르면 휨이 그 자리에 멈춘 채 돌기만 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-catenoid-helicoid","type":"code","name":"catenoid-helicoid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Squares=12..36, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Squares","min":12,"max":36},{"name":"Tilt","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.3335,"detail":0.0318,"edges":0.4044,"complexity":0.9814,"coverage":0.3928,"colour":0.1926,"drift":0.2581},"knobResponse":[0.0638,0.2131,0.039,0.1585]},{"slug":"catoptric-anamorphosis","title":"Catoptric Anamorphosis","family":"type","round":71,"note":"원기둥 거울 둘레 바닥에 고리로 휘어 그린 낱말이 거울 속에서만 바로 서고, 카메라가 바닥 그림을 쫓은 눈에서 멀어지면 거울 속 글자가 미끄러지며 기울어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-catoptric-anamorphosis","type":"code","name":"catoptric-anamorphosis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Away=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Away","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0821,"detail":0.0685,"edges":0.3656,"complexity":1.0052,"coverage":0.8274,"colour":0.4221,"drift":0.1641},"knobResponse":[0.2151,0.0487,0.198,0.1603]},{"slug":"cauldron","title":"Cauldron","family":"halloween","round":41,"note":"작은 불 위의 검은 무쇠 솥에서 독한 초록 물약이 들썩이고, 거품이 부풀다 터지며 방울을 튀겨요. 초록과 보라 연기 두 줄기가 패널 꼭대기까지 휘감겨 올라가요. K3 은 끓는 세기를, K4 는 오르는 연기 양을 정하고, K1 을 누르면 눈알이 떨어져 물이 튀고 물약이 초록, 보라, 주황, 청록 차례로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cauldron","type":"code","name":"cauldron","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Boil=0..1, Fume=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Boil","min":0,"max":1},{"name":"Fume","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5114,"detail":0.0428,"edges":0.8955,"complexity":0.1495,"coverage":0.4358,"colour":0.2987,"drift":0.1811},"knobResponse":[0.1048,0.1326,0.0528,0.1034]},{"slug":"caustic-letters","title":"Caustic Letters","family":"type","round":69,"note":"물결이 거칠 때는 수영장 바닥에 늘 보던 빛 그물이 일렁이다가, 물이 잔잔해지면 같은 빛이 세로로 쌓은 LIGHT, 큰 한 글자 빛, WAVE 로 모이고, 바람이나 떨어진 돌이 다시 흔들면 흩어져 다음 낱말이 와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-caustic-letters","type":"code","name":"caustic-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ripple=1..3, Focus=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ripple","min":1,"max":3},{"name":"Focus","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.4129,"detail":0.0726,"edges":0.1364,"complexity":1.7879,"coverage":0.9266,"colour":0.1623,"drift":0.1604},"knobResponse":[0.2196,0.2371,0.1217,0.1311]},{"slug":"center-pivot","title":"Center Pivot","family":"farm","round":27,"note":"비행기 창으로 내려다본 들판이에요. 흙길로 나뉜 황토색 땅에 원형 밭이 두 줄로 넷씩 놓이고, 은빛 스프링클러 팔이 돌며 지나간 부채꼴을 짙게 적셨다가 말려요. 금빛 밀밭은 콤바인이 바깥부터 베어 들어가요. K1 이 봄에서 늦가을까지 철을 돌리고, 누르면 모든 팔이 한 바퀴 돌아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-center-pivot","type":"code","name":"center-pivot","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Season=0..1, Speed=0.2..3, Fields=2..4, Clouds=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Season","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fields","min":2,"max":4},{"name":"Clouds","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0527,"detail":0.0683,"edges":0.2287,"complexity":2.4956,"coverage":1,"colour":0.1929,"drift":0.0389},"knobResponse":[0.1272,0.0462,0.1999,0.1865]},{"slug":"chain-fountain","title":"Chain Fountain","family":"physics","round":78,"note":"떨어지는 끝에 끌려 나온 구슬 사슬이 단지 위로 뒤집힌 현수선 아치를 그리고 바닥으로 쏟아지다, 더미가 바닥나면 꼬리가 휘어 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-chain-fountain","type":"code","name":"chain-fountain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drop=67..75, Push=0.26..0.29","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drop","min":67,"max":75},{"name":"Push","min":0.26,"max":0.29}],"start":[0,2,67,0.26],"measures":{"motion":0.8058,"detail":0.038,"edges":0.553,"complexity":0.3325,"coverage":0.19,"colour":0.1643,"drift":0.0482},"knobResponse":[0.0565,0.0433,0.065,0.0468]},{"slug":"change-ringing","title":"Change Ringing","family":"rhythm","round":20,"note":"종탑 종실에서 종들이 바퀴째 한 바퀴씩 돌며 칠 때마다 번쩍이고, 그 아래로 종마다 제 색의 선이 체인지 한 줄에 한 칸씩 Plain Bob 을 따라 지그재그로 흘러내려요. 트레블의 선만 빨강이고, K1 을 누르면 「Bob!」을 불러 다음 리드 엔드에서 2번 자리 대신 4번 자리를 만들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-change-ringing","type":"code","name":"change-ringing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lines=0..1, Speed=0.25..3, Bells=4..8, Method=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lines","min":0,"max":1},{"name":"Speed","min":0.25,"max":3},{"name":"Bells","min":4,"max":8},{"name":"Method","min":-1,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.4844,"detail":0.08,"edges":0.458,"complexity":1.2457,"coverage":0.5293,"colour":0.2305,"drift":0.0504},"knobResponse":[0.0499,0.1129,0.1732,0.0613]},{"slug":"chebyshev-bias","title":"Chebyshev's Bias","family":"number","round":48,"note":"로그 눈금 수직선을 따라 흰 앞줄이 올라가며 소수 경주 64개를 파랗게 칠하고, 반대쪽이 앞선 드문 자리만 주황 점으로 남아 26,861 에서 첫 고리가 퍼져요. K3 은 경주 묶음을, K4 는 아슬아슬한 자리를 보라로 칠할 폭을 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-chebyshev-bias","type":"code","name":"chebyshev-bias","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Races=0..2, Margin=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Races","min":0,"max":2},{"name":"Margin","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2555,"detail":0.0581,"edges":0.156,"complexity":1.14,"coverage":1,"colour":0.2935,"drift":0.2812},"knobResponse":[0.2202,0.1171,0.1174,0.0849]},{"slug":"chemical-garden","title":"Chemical Garden","family":"chemistry","round":21,"note":"물유리 용액을 채운 키 큰 유리컵 모래 위에 금속염 결정을 떨어뜨리면 코발트의 청보라나 철의 녹슨 주황 같은 속 빈 광물 관이 흔들리며 수면까지 자라요. 컵이 차면 빈 컵이 밀려 들어와 다시 자라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-chemical-garden","type":"code","name":"chemical-garden","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Salts=0..4, Speed=0.2..3, Crystals=5..20, Strength=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Salts","min":0,"max":4},{"name":"Speed","min":0.2,"max":3},{"name":"Crystals","min":5,"max":20},{"name":"Strength","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.044,"detail":0.0682,"edges":0.4036,"complexity":2.0411,"coverage":0.7726,"colour":0.152,"drift":0.0448},"knobResponse":[0.0762,0.0506,0.0924,0.0773]},{"slug":"chimera-state","title":"Chimera State","family":"rhythm","round":35,"note":"똑같은 위상 진동자 256개가 고리에 앉아 서로 당기는데, 고리가 발맞춰 도는 30% 와 위상이 흩어진 나머지로 갈라져요. 위 20줄은 진동자마다 위상을 제자리에 점으로 찍어 매끈한 호 옆에 흩뿌린 점을 보이고, 그 아래로 한 줄이 한 순간이라 가운데로 하늘색 띠가 곧게 흐르고 양옆은 한 바퀴씩 뒤처지는 진동자의 어두운 획으로 채워져요. K3 은 위상 지연을 80도에서 88도로 돌려 발맞춘 띠를 19열에서 9열로 좁히고, K1 을 누르면 새 무작위 출발에서 키메라가 다시 자라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-chimera-state","type":"code","name":"chimera-state","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lag=80..88, Stride=0.8..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lag","min":80,"max":88},{"name":"Stride","min":0.8,"max":4}],"start":[0,2,80,0.8],"measures":{"motion":0.871,"detail":0.1412,"edges":0.5685,"complexity":1.5664,"coverage":0.8292,"colour":0.6214,"drift":0.032},"knobResponse":[0.5105,0.2386,0.2458,0.1784]},{"slug":"chladni","title":"Chladni","family":"wave","round":16,"note":"세운 놋쇠 판에 뿌린 모래가 떨리는 자리에서 튀어 나가 가만히 있는 마디선에 모여 클라드니 도형을 그려요. 5초마다 활을 다시 그으면 모래가 흩어졌다가 새 모드의 도형을 찾아가고, K4 를 올리면 석송 가루가 배 자리마다 둥근 노란 더미로 모여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-chladni","type":"code","name":"chladni","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Plate=0..1, Drive=0.8..3, Pitch=-1..1, Powder=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Plate","min":0,"max":1},{"name":"Drive","min":0.8,"max":3},{"name":"Pitch","min":-1,"max":1},{"name":"Powder","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4769,"detail":0.0916,"edges":0.6144,"complexity":1.6152,"coverage":0.9904,"colour":0.0973,"drift":0.0566},"knobResponse":[0.0837,0.1502,0.16,0.131]},{"slug":"chromatography","title":"Chromatography","family":"chemistry","round":20,"note":"실험대 위 유리 수조에 거름종이 띠가 매달려 발끝을 용매에 담그고, 젖은 앞선이 올라가는 동안 연필 출발선의 잉크 점이 색 띠로 갈라져 저마다 다른 빠르기로 올라가요. K1 을 누르면 띠를 들어 올리고 새 띠를 걸어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-chromatography","type":"code","name":"chromatography","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Inks=0..3, Speed=0.2..3, Strips=3..6, Solvent=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Inks","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Strips","min":3,"max":6},{"name":"Solvent","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0352,"detail":0.0646,"edges":0.3051,"complexity":1.2207,"coverage":0.7347,"colour":0.2232,"drift":0.0399},"knobResponse":[0.0454,0.0548,0.2236,0.048]},{"slug":"chrome-powder","title":"Chrome Powder","family":"cosmetic","round":32,"note":"판 전체가 크롬 파우더를 얹은 젤 한 면이에요. 보이지 않는 어플리케이터가 작은 원을 그리며 위에서 아래로 문지르면 무광 회색 가루가 로즈골드 거울로 바뀌고, 거울에는 소프트박스의 흰 띠와 검은 반사판 띠가 물결지며 비쳐요. 다 덮이면 빛이 비스듬히 한 번 쓸고, 새 가루가 위에서부터 다시 덮여요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-chrome-powder","type":"code","name":"chrome-powder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Holo=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Holo","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1725,"detail":0.0415,"edges":0.2939,"complexity":1.5841,"coverage":0.922,"colour":0.1297,"drift":0.2833},"knobResponse":[0.0785,0.1385,0.1031,0.0512]},{"slug":"circuit-board","title":"Circuit Board","family":"circuit","round":17,"note":"회로 기판이 패널을 다 채우고, Lee 의 미로 라우터가 프로세서와 메모리 둘, 플래시, 크리스털, 금도금 단자 사이에 구리 선 47개를 곧게, 또 45도로 깔아요. 버스에는 펄스 열이 나란히 달리고 바쁜 선은 신호 색으로 데워지며, K1 을 누르면 기판이 꺼졌다가 부팅해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-circuit-board","type":"code","name":"circuit-board","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Mask=0..1, Clock=0.5..4, Traffic=0..1, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Mask","min":0,"max":1},{"name":"Clock","min":0.5,"max":4},{"name":"Traffic","min":0,"max":1},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2002,"detail":0.119,"edges":0.678,"complexity":0.7577,"coverage":0.9814,"colour":0.2535,"drift":0.0471},"knobResponse":[0.2116,0.0618,0.0696,0.0621]},{"slug":"circulation","title":"Circulation","family":"body","round":22,"note":"해부도처럼 머리부터 발끝까지 선 사람이에요. 심장이 뛸 때마다 붉은 피의 맥이 동맥을 타고 머리와 손발 끝까지 번져 가고, 푸른 정맥혈은 심장 쪽으로 거슬러 올라오며 폐가 박동과 숨에 분홍빛으로 물들어요. 발치의 모니터에는 심전도와 맥박 수가 떠요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-circulation","type":"code","name":"circulation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Chart=0..1, Rate=1..5, Detail=1..4, Effort=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Chart","min":0,"max":1},{"name":"Rate","min":1,"max":5},{"name":"Detail","min":1,"max":4},{"name":"Effort","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3125,"detail":0.0474,"edges":0.3512,"complexity":1.0533,"coverage":0.3719,"colour":0.2033,"drift":0.0315},"knobResponse":[0.1504,0.046,0.0247,0.0525]},{"slug":"cistercian-numerals","title":"Cistercian Numerals","family":"type","round":76,"note":"패널 높이의 막대 하나에 시토회 수도사 숫자로 네 자리 수를 적고, 수가 바뀔 때마다 단위, 십, 백, 천의 귀가 문처럼 닫혔다 새 꼴로 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cistercian-numerals","type":"code","name":"cistercian-numerals","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Count=0..3, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Count","min":0,"max":3},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5687,"detail":0.0427,"edges":0.4323,"complexity":0.1964,"coverage":0.2135,"colour":0.1776,"drift":0.1687},"knobResponse":[0.0928,0.0599,0.1203,0.1454]},{"slug":"clay-mask","title":"Clay Mask","family":"cosmetic","round":32,"note":"판 전체에 스패출러로 바른 로즈 클레이가 얇은 곳부터 말라 들어가요. 짙은 라즈베리색 윤이 먼저 빠지고 옅은 블러시색 무광이 섬처럼 번지다가, 두꺼운 결만 마지막까지 짙은 줄로 남아요. 8초쯤 다 마르면 물 띠가 위에서 아래로 2초 동안 지나가며 다시 적셔요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-clay-mask","type":"code","name":"clay-mask","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thickness=-1..1, Gloss=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thickness","min":-1,"max":1},{"name":"Gloss","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0642,"detail":0.0418,"edges":0.1071,"complexity":2.3182,"coverage":1,"colour":0.1574,"drift":0.2242},"knobResponse":[0.2918,0.1358,0.0941,0.1324]},{"slug":"cleansing-balm","title":"Cleansing Balm","family":"cosmetic","round":33,"note":"서리 낀 셔벗 밤이 무광으로 판을 채우고, 아래에서 올라오는 온기와 보이지 않는 손끝이 닿은 곳마다 밤이 녹아 맑은 광택 오일이 돼요. 오일은 흘러내려 바닥에 고이고, 다 녹으면 위에서 새 밤이 다시 휘핑돼요. K3 은 녹는 빠르기와 높이를 정하고, K1 을 누르면 손끝 하나가 지름 20 LED 를 한 번에 녹여요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cleansing-balm","type":"code","name":"cleansing-balm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Warmth=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Warmth","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1343,"detail":0.0375,"edges":0.1005,"complexity":2.1868,"coverage":1,"colour":0.1701,"drift":0.1197},"knobResponse":[0.2675,0.0873,0.1368,0.0422]},{"slug":"clebsch-surface","title":"Clebsch Surface","family":"space","round":59,"note":"직선 27개가 다 실수인 클렙시 3차 곡면이 납작한 회전타원체 안에서 돌고, 이중 여섯이 청록과 분홍, 나머지 15개가 초록으로 곡면 위에 서요. 흰 초점이 2.5초마다 만나는 직선 10개 가운데 하나로 옮겨 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-clebsch-surface","type":"code","name":"clebsch-surface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Glass=0..1, Tilt=12..60","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Glass","min":0,"max":1},{"name":"Tilt","min":12,"max":60}],"start":[0,2,0,12],"measures":{"motion":0.2109,"detail":0.0462,"edges":0.3866,"complexity":1.4036,"coverage":0.61,"colour":0.1889,"drift":0.1456},"knobResponse":[0.0905,0.1477,0.1012,0.2034]},{"slug":"climber","title":"Climber","family":"pixel","round":2,"note":"빨간 목도리를 맨 꼬마가 혼자서 끝없는 탑의 턱을 뛰어올라요. K4 를 돌리면 한낮에서 노을을 지나 횃불 켜진 밤이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-climber","type":"code","name":"climber","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.3..3.5, Gap=16..34, Sky=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.3,"max":3.5},{"name":"Gap","min":16,"max":34},{"name":"Sky","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":1.5193,"detail":0.0867,"edges":0.9308,"complexity":0.2662,"coverage":0.7278,"colour":0.1488,"drift":0.118},"knobResponse":[0.0827,0.1542,0.146,0.1338]},{"slug":"climbing-wall","title":"Climbing Wall","family":"sport","round":27,"note":"체육관의 리드 벽을 정면에서 봐요. 합판에 색깔별 루트가 박혀 있고, 클라이머가 스폿 빛을 받으며 손발을 하나씩 옮겨 오르다 퀵드로마다 로프를 걸어요. 꼭대기 앵커를 걸면 빌레이어가 내려 주고 둘이 자리를 바꿔요. K3 은 셋까지 나란히 오르게 하고, 누르면 클라이머가 떨어져 로프에 걸려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-climbing-wall","type":"code","name":"climbing-wall","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Route=0..1, Speed=0.2..3, Climbers=1..3, Light=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Route","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Climbers","min":1,"max":3},{"name":"Light","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.067,"detail":0.0707,"edges":0.3416,"complexity":1.7869,"coverage":0.9212,"colour":0.1755,"drift":0.0209},"knobResponse":[0.0608,0.0368,0.048,0.1959]},{"slug":"cloth","title":"Cloth","family":"physics","round":2,"note":"12×22 매듭 천이 나무 봉의 집게에 걸려 있고, 뒤에서 부는 돌풍이 천을 앞으로 들어 올려요. LED 마다 그 자리 천이 빛에서 기운 만큼 밝아서 주름이 등고선처럼 읽혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-cloth","type":"code","name":"cloth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Wind=0..3, Stiffness=0..1, Pins=2..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Wind","min":0,"max":3},{"name":"Stiffness","min":0,"max":1},{"name":"Pins","min":2,"max":12}],"start":[0,2,0,2],"measures":{"motion":0.5789,"detail":0.0244,"edges":0.3966,"complexity":0.9079,"coverage":0.5904,"colour":0.3319,"drift":0.4132},"knobResponse":[0.2963,0.322,0.2371,0.2837]},{"slug":"clothesline","title":"Clothesline","family":"type","round":72,"note":"줄 넷에 집게로 꽂은 「바람이 분다 살아야겠다」 카드가 왼쪽에서 건너오는 돌풍에 차례로 흔들리고 비틀렸다가 곧은 자리를 지나 되흔들려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-clothesline","type":"code","name":"clothesline","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=2..7, Gust=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":2,"max":7},{"name":"Gust","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2752,"detail":0.0584,"edges":0.486,"complexity":1.0766,"coverage":0.4305,"colour":0.1971,"drift":0.057},"knobResponse":[0.0882,0.0798,0.2338,0.1206]},{"slug":"cloud-chamber","title":"Cloud Chamber","family":"particle","round":27,"note":"과학관의 확산 안개상자를 유리 뚜껑 위에서 내려다봐요. 등줄 빛을 받은 검은 펠트 위로 우주선 뮤온이 가는 직선을 패널 끝까지 긋고, 알파 입자는 짧고 굵은 막대를, 전자는 흐린 실을 남겨요. 자취는 한순간에 맺혔다가 대류를 따라 흘러가며 몇 초 만에 번져 사라져요. K3 은 토륨 막대를 세워 알파 부채를 뿜게 하고, K4 는 자기장으로 전자를 나선으로 감아요.","why":"흰 줄 몇 개뿐이라 색이 없어요(색 0.05).","block":1,"ramped":false,"layer":{"id":"layer-cloud-chamber","type":"code","name":"cloud-chamber","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Source=0..1, Field=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Source","min":0,"max":1},{"name":"Field","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.104,"detail":0.0456,"edges":0.3473,"complexity":1.374,"coverage":0.2504,"colour":0.0521,"drift":0.0923},"knobResponse":[0.046,0.1102,0.1287,0.0714]},{"slug":"coded-aperture","title":"Coded Aperture","family":"type","round":75,"note":"위에서 빛나는 낱말이 MURA 구멍 카드를 지나 검출기에 광자 하나씩 그림자를 겹쳐 쌓고, 읽히지 않는 그 그림자를 해독 배열과 상관시키면 맨 아래 띠에서 낱말이 잡음 위로 떠올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-coded-aperture","type":"code","name":"coded-aperture","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rate=0.2..3, Mask=0..2, Word=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rate","min":0.2,"max":3},{"name":"Mask","min":0,"max":2},{"name":"Word","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.6625,"detail":0.1101,"edges":0.5519,"complexity":0.7864,"coverage":0.4538,"colour":0.1161,"drift":0.0824},"knobResponse":[0.0559,0.1354,0.1486,0.0861]},{"slug":"composing-stick","title":"Composing Stick","family":"type","round":68,"note":"활자 상자에서 한 개씩 날아온 활자가 조판 막대에 거꾸로 서서 스페이스로 줄을 맞추고, 판에서는 거울 글자로 오른쪽에서 왼쪽으로 읽히다가 아래 종이에 찍혀서야 바로 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-composing-stick","type":"code","name":"composing-stick","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Spacing=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Spacing","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1192,"detail":0.0955,"edges":0.4504,"complexity":0.6662,"coverage":0.8248,"colour":0.2109,"drift":0.1879},"knobResponse":[0.0397,0.0995,0.0603,0.04]},{"slug":"constant-width","title":"Constant Width","family":"geometry","round":35,"note":"너비 62 LED 의 통로를 폭이 일정한 곡선이 위아래로 맞닿아 쌓인 채 내려가요. 뢸로 삼각형과 오각형, 칠각형, 홀수 배음으로 지은 매끈한 곡선과 원이 저마다 다른 빠르기로 도는데도 늘 두 벽과 위아래 경계선에 닿고, 닿은 자리마다 흰 점이 서요. K3 은 곡선마다 같은 너비의 원을 섞어 둘레 194.8 은 그대로 두고 삼각형의 넓이 2709 LED 를 원의 3019 까지 부풀리고, K1 을 누르면 꼭짓점이 지나간 길이 금색으로 남아 삼각형이 귀만 둥근 정사각형을 그려요.","why":"세 색의 뢸로 삼각형이 맞물려 굴러요. 0531 처럼 큰 색면 몇 개가 화면 전부예요.","block":0,"ramped":false,"layer":{"id":"layer-constant-width","type":"code","name":"constant-width","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Round=0..1, Spin=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Round","min":0,"max":1},{"name":"Spin","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4094,"detail":0.0438,"edges":1,"complexity":0.0838,"coverage":0.7349,"colour":0.4286,"drift":0.2768},"knobResponse":[0.306,0.2393,0.1029,0.1377]},{"slug":"continuum-random-tree","title":"Continuum Random Tree","family":"fractal","round":40,"note":"정규화한 브라운 엑스커션으로 짠 앨더스의 연속 랜덤 나무가 바닥의 뿌리에서 선 끊기로 잎 하나씩 자라고, 새 가지마다 흰 빛이 타고 올라가요. 다 자라면 시야가 가지 하나로 뛰어들고, 브라운 크기로 늘린 그 가지가 다시 온전한 나무가 되어 계속 자라요. K3 은 뛰어들 가지의 질량을 0.3 에서 0.06 으로 줄이고, 누르면 바로 뛰어들어요.","why":"빛나는 나뭇가지로 읽혀서 나무 그림이 돼요.","block":1,"ramped":false,"layer":{"id":"layer-continuum-random-tree","type":"code","name":"continuum-random-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dive=0..1, Cut=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dive","min":0,"max":1},{"name":"Cut","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3771,"detail":0.0535,"edges":0.3564,"complexity":1.3506,"coverage":0.3764,"colour":0.1995,"drift":0.2451},"knobResponse":[0.0977,0.2136,0.2254,0.0526]},{"slug":"contour","title":"Contour Map","family":"data","round":2,"note":"천천히 솟고 가라앉는 땅의 지형도예요. 다섯째 등고선마다 밝고, 바닷물이 차오르면 선은 땅에 그대로 남은 채 물 밑으로 들어가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-contour","type":"code","name":"contour","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Morph=0..6, Interval=50..200, Sea level=-300..600","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Morph","min":0,"max":6},{"name":"Interval","min":50,"max":200},{"name":"Sea level","min":-300,"max":600}],"start":[0,2,50,0.06],"measures":{"motion":0.059,"detail":0.1124,"edges":0.4216,"complexity":2.7352,"coverage":1,"colour":0.2347,"drift":0.0329},"knobResponse":[0.3087,0.1314,0.1058,0.2222]},{"slug":"conways-soldiers","title":"Conway's Soldiers","family":"algo","round":47,"note":"선 아래 금색 병사가 옆 병사를 뛰어넘어 하나를 1, 2, 3, 4줄 위로 보내는 데 2, 4, 8, 20명이 들어요. 병사마다 단 x^d 무게만 한 보라 원판이 뛰어넘을 때마다 합쳐져 마지막 병사에서 무게 1 의 고리를 꼭 채우고, 5줄에는 끝없는 군대도 닿지 못해 빨간 X 가 남아요. K3 은 출정, K4 는 무게 빛이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-conways-soldiers","type":"code","name":"conways-soldiers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Row=0..5, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Row","min":0,"max":5},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0992,"detail":0.0443,"edges":0.2789,"complexity":0.1147,"coverage":0.3897,"colour":0.2082,"drift":0.0665},"knobResponse":[0.0918,0.0603,0.227,0.0597]},{"slug":"corn-maze","title":"Corn Maze","family":"halloween","round":45,"note":"손전등을 든 사람이 밤의 옥수수 미로를 걸으면 빛줄기가 앞쪽 옥수수를 금빛으로 밝히고, 옥수수 너머의 길은 보라 그림자로 남아요. 막다른 길에서 초록 눈 두 개가 번뜩이면 빛이 떨리고 사람은 돌아서서 달아나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-corn-maze","type":"code","name":"corn-maze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beam=0..1, Moon=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beam","min":0,"max":1},{"name":"Moon","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1764,"detail":0.0771,"edges":0.2834,"complexity":0.3394,"coverage":0.2735,"colour":0.2662,"drift":0.3821},"knobResponse":[0.1026,0.1685,0.0891,0.0964]},{"slug":"cornsweet-letters","title":"Cornsweet Letters","family":"type","round":81,"note":"속이 바탕과 똑같은 색인 글자 셋이 테두리의 밝기 계단만으로 바탕보다 밝아 보였다가 어두워 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cornsweet-letters","type":"code","name":"cornsweet-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Cover=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":1},{"name":"Cover","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0402,"detail":0.0203,"edges":0.1283,"complexity":0.2615,"coverage":1,"colour":0.1286,"drift":0.024},"knobResponse":[0.2492,0.0594,0.045,0.1326]},{"slug":"cornu-spiral","title":"Cornu Spiral","family":"line","round":60,"note":"오일러 나선의 두 팔이 두 눈으로 감기고, 한 눈에서 나오거나 정해진 호만큼 떨어진 두 점을 잇는 현이 나선을 따라 미끄러져요. 그 현 길이의 제곱이 아래에 직선 모서리나 슬릿 뒤의 프레넬 무늬로 쌓여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-cornu-spiral","type":"code","name":"cornu-spiral","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slit=0..1, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slit","min":0,"max":1},{"name":"Spread","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1715,"detail":0.0514,"edges":0.5539,"complexity":0.4702,"coverage":0.187,"colour":0.1843,"drift":0.0264},"knobResponse":[0.062,0.029,0.0654,0.0342]},{"slug":"costas-array","title":"Costas Array","family":"rhythm","round":53,"note":"위 절반에서 코스타스 배열이 주파수 도약 리듬으로 울리는 동안 장밋빛 사본이 시간과 높이로 한 칸씩 나선을 그리며 밀려 점에 닿을 때마다 번쩍이고, 아래 절반은 밀린 칸마다 맞은 점의 수를 채워 0 과 1 의 바닥 가운데 N 하나만 솟은 압정이 돼요. K3 은 배열을 짓는 유한체(원소 11~32개), K4 는 배열을 코스타스가 아닌 순열로 바꿔 지도에 2 이상의 능선을 키우는 것이고, 단추를 누르면 다음 배열로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-costas-array","type":"code","name":"costas-array","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Field=0..8, Rival=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Field","min":0,"max":8},{"name":"Rival","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.3252,"detail":0.0515,"edges":0.7559,"complexity":0.0988,"coverage":0.2034,"colour":0.1387,"drift":0.0603},"knobResponse":[0.0419,0.0476,0.0672,0.0563]},{"slug":"couette-shimmer","title":"Couette Shimmer","family":"cosmetic","round":38,"note":"두 원통 사이에 든 펄 세럼을 옆에서 봐요. 안쪽 원통이 빨라지면 옆으로 흐르던 결이 테일러 소용돌이의 밝고 어두운 띠로 128줄을 쌓고, 더 빨라지면 띠가 물결치며 원통을 돌아요. K3 은 띠를 다섯 쌍에서 열네 쌍으로 늘려 가는 골로 만들고, K4 는 바깥 원통을 거꾸로 돌려 띠를 나선으로 기울여요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-couette-shimmer","type":"code","name":"couette-shimmer","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Spin=0.5..4, Rolls=5..14, Counter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Spin","min":0.5,"max":4},{"name":"Rolls","min":5,"max":14},{"name":"Counter","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.2097,"detail":0.0404,"edges":0.1149,"complexity":2.5766,"coverage":0.9999,"colour":0.1504,"drift":0.059},"knobResponse":[0.3171,0.1536,0.1747,0.1924]},{"slug":"counterforms","title":"Counterforms","family":"type","round":64,"note":"굵은 글자 넷이 흐린 돌빛으로 어둠에 서 있고, 글자 안의 빈 자리인 카운터만 안에서 켠 창처럼 빛나요. 낱말이 바뀔 때마다 창이 비었다가 다음 낱말의 창이 아래부터 하나씩 차올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-counterforms","type":"code","name":"counterforms","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Words=0..2, Body=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Words","min":0,"max":2},{"name":"Body","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1606,"detail":0.0234,"edges":0.1514,"complexity":1.1058,"coverage":0.578,"colour":0.1785,"drift":0.3344},"knobResponse":[0.1819,0.1356,0.2615,0.2091]},{"slug":"coupling-from-the-past","title":"Coupling from the Past","family":"noise","round":80,"note":"모두 위로 놓은 이징 자석과 모두 아래로 놓은 이징 자석이 위아래 반에서 같은 난수로 −T 부터 0 까지 달리고, 둘이 어긋난 분홍 자리가 0 까지 다 녹으면 그 그림이 정확한 표본이고 하나라도 남으면 두 배 먼 과거에서 다시 출발해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-coupling-from-the-past","type":"code","name":"coupling-from-the-past","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beta=0.32..0.43, Field=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beta","min":0.32,"max":0.43},{"name":"Field","min":-1,"max":1}],"start":[0,2,0.32,0.06],"measures":{"motion":2.9321,"detail":0.1333,"edges":0.9379,"complexity":0.1472,"coverage":0.9836,"colour":0.2908,"drift":0.2061},"knobResponse":[0.3113,0.3054,0.2299,0.4225]},{"slug":"coxeter-frieze","title":"Conway-Coxeter Frieze","family":"number","round":72,"note":"칠각형의 삼각 분할이 정하는 정수 띠가 세로로 서서 모든 마름모가 ad − bc = 1 을 지키며 내려가고, 대각선 하나가 뒤집힐 때마다 바뀐 수가 하얗게 번쩍여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-coxeter-frieze","type":"code","name":"coxeter-frieze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=7..11, Chords=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":7,"max":11},{"name":"Chords","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.2849,"detail":0.0767,"edges":0.5929,"complexity":0.3454,"coverage":0.4879,"colour":0.1317,"drift":0.1196},"knobResponse":[0.0813,0.1338,0.1684,0.0742]},{"slug":"crackle-polish","title":"Crackle Polish","family":"cosmetic","round":39,"note":"형광 분홍 바탕 위의 검은 크래클 탑코트가 마르며 갈라져요. 긴 금이 먼저 패널을 가로지르고, 짧은 금이 옛 금에서 직각으로 나와 다른 금에 직각으로 닿고, 틈이 벌어지며 조각이 광택 테를 두른 구슬이 돼요. 다 갈라지면 새 코트를 위에서 칠해 내려와요.","why":"갈라진 선이 좋은데 거의 안 움직여요(움직임 0.06).","block":1,"ramped":false,"layer":{"id":"layer-crackle-polish","type":"code","name":"crackle-polish","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Craze=0..1, Coat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Craze","min":0,"max":1},{"name":"Coat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0606,"detail":0.0894,"edges":0.5269,"complexity":1.379,"coverage":0.5043,"colour":0.2853,"drift":0.1556},"knobResponse":[0.1036,0.1543,0.0671,0.6128]},{"slug":"crackling-noise","title":"Crackling Noise","family":"noise","round":61,"note":"영온 무작위장 이징 자석을 아래에서 위로 쓸어 올리면 눈사태 하나하나가 제 색으로 기어 나가서, 판이 크고 작은 덩어리의 조각보가 돼요. 다 뒤집히면 거꾸로 쓸어 내려 어둑한 조각보를 남기고 새 무질서로 다시 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-crackling-noise","type":"code","name":"crackling-noise","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Disorder=1.05..2.6, Grain=0..1.6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Disorder","min":1.05,"max":2.6},{"name":"Grain","min":0,"max":1.6}],"start":[0,2,1.05,0.06],"measures":{"motion":0.0576,"detail":0.0462,"edges":0.6729,"complexity":0.1681,"coverage":0.5893,"colour":0.4821,"drift":0.3457},"knobResponse":[0.2264,0.1134,0.2937,0.3249]},{"slug":"creaking-door","title":"Creaking Door","family":"halloween","round":52,"note":"보라 복도 끝의 문이 다섯 번 덜컹이며 삐걱 열리면 촛불 빛이 쐐기로 넓어지며 바닥과 왼쪽 벽을 타고, 그 빛 속으로 손가락이 긴 손 그림자가 기어 나오거나 뾰족 모자의 그림자가 지나가요. 문이 쾅 닫히면 판이 흔들리고 먼지가 떨어지고, 문 밑 빛줄기를 두 발이 지나가요. K3 은 빛이 닿는 거리, K4 는 공기 속 먼지이고, K1 을 누르면 문이 닫히거나 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-creaking-door","type":"code","name":"creaking-door","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Reach=0..1, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Reach","min":0,"max":1},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3271,"detail":0.0303,"edges":0.2098,"complexity":0.3788,"coverage":0.9562,"colour":0.2848,"drift":0.2119},"knobResponse":[0.1772,0.1071,0.1188,0.1277]},{"slug":"cream-swirl","title":"Cream Swirl","family":"cosmetic","round":29,"note":"보이지 않는 팔레트 나이프가 크림을 S자와 소용돌이로 펴 바르며 매끈한 띠와 윤기 나는 둔덕을 남기고, 떨어진 색 크림 덩이를 길쭉한 리본으로 끌고 가요. 부드러운 빛이 7초에 한 번 좌우로 오가며 결 위로 윤이 미끄러져요. K3 을 올리면 섞이는 색조가 셋까지 늘고, 누르면 가장 진한 색 덩이가 칼 앞에 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cream-swirl","type":"code","name":"cream-swirl","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tones=1..3, Gloss=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tones","min":1,"max":3},{"name":"Gloss","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0374,"detail":0.0161,"edges":0.0277,"complexity":1.8116,"coverage":1,"colour":0.1658,"drift":0.0429},"knobResponse":[0.2103,0.0689,0.1027,0.1086]},{"slug":"crofton-cell","title":"Crofton Cell","family":"cells","round":82,"note":"판을 가로지르는 푸아송 직선들이 움직이며 판을 볼록한 칸으로 자르고, 가운데 점을 품은 칸만 금빛 모서리 안의 옅은 내접원으로 빛나서 Big 을 올리면 그 칸이 커지며 변이 늘고 원에 가까워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-crofton-cell","type":"code","name":"crofton-cell","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=16..56, Big=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":16,"max":56},{"name":"Big","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.3316,"detail":0.0738,"edges":0.6777,"complexity":0.7314,"coverage":0.9037,"colour":0.3379,"drift":0.1617},"knobResponse":[0.2782,0.1733,0.2573,0.3703]},{"slug":"crossroads","title":"Crossroads","family":"city","round":17,"note":"드론으로 곧장 내려다본 밤 네거리예요. 차는 전조등과 미등으로만 보이고, 나트륨등 웅덩이 사이에서 신호가 줄을 세웠다 풀며, 모든 차가 서면 사람들이 건널목 넷을 한꺼번에 건너요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-crossroads","type":"code","name":"crossroads","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamps=0..1, Pace=0.2..3, Hour=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamps","min":0,"max":1},{"name":"Pace","min":0.2,"max":3},{"name":"Hour","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2133,"detail":0.0621,"edges":0.4808,"complexity":0.9935,"coverage":0.2564,"colour":0.385,"drift":0.0485},"knobResponse":[0.05,0.0417,0.0482,0.062]},{"slug":"crystal-ball","title":"Crystal Ball","family":"halloween","round":44,"note":"놋쇠 받침 위 수정 구슬 속에서 보라와 독초록 연기가 돌다가, 이따금 해골이나 눈, 초승달로 모였다 풀려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-crystal-ball","type":"code","name":"crystal-ball","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Smoke=0..1, Visions=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Smoke","min":0,"max":1},{"name":"Visions","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3664,"detail":0.0447,"edges":0.8468,"complexity":0.1092,"coverage":0.4161,"colour":0.198,"drift":0.0742},"knobResponse":[0.0514,0.1069,0.0438,0.0916]},{"slug":"curlicue","title":"Curlicue","family":"number","round":49,"note":"세타 합의 부분합이 가운데에서 양쪽으로 한 걸음씩 자라 서로 닿지 않는 LED 레이스가 되고, 화면이 끝없이 물러나도 단계마다 같은 갈고리가 다시 감겨 나와요. K3 은 √3 부터 √101 − 10 까지 무리수 다섯 가운데 x 를, K4 는 한 단계의 걸음 수를 골라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-curlicue","type":"code","name":"curlicue","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Number=0..1, Steps=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":1},{"name":"Steps","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4325,"detail":0.335,"edges":1,"complexity":0.1058,"coverage":0.1676,"colour":0.3546,"drift":0.1521},"knobResponse":[0.1317,0.1139,0.1229,0.113]},{"slug":"curve-shortening","title":"Curve Shortening","family":"line","round":36,"note":"굵은 나선이나 접힌 지렁이, 팔 여럿인 별 같은 닫힌 곡선 하나가 점마다 곡률만큼의 빠르기로 법선을 따라 움직여요. 곡선은 제 몸에 한 번도 닿지 않고 풀려 둥글어진 뒤 한 점으로 사라지고, 넓이는 모양과 상관없이 흐름 시간 1 에 2π 씩 줄며, 흰 점으로 찍힌 변곡점은 둘씩 만나 함께 없어져요. K3 은 나선을 2바퀴에서 3.5바퀴까지 감고, K1 을 누르면 남은 흐름이 0.6초 만에 끝나요.","why":"도형 하나가 줄어들다 사라져서 빈 화면이 길어요.","block":1,"ramped":false,"layer":{"id":"layer-curve-shortening","type":"code","name":"curve-shortening","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=2..3.5, Trace=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":2,"max":3.5},{"name":"Trace","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2037,"detail":0.0249,"edges":0.5796,"complexity":0.2104,"coverage":0.1942,"colour":0.2439,"drift":0.3752},"knobResponse":[0.229,0.2408,0.2872,0.1241]},{"slug":"cushion-mesh","title":"Cushion Mesh","family":"cosmetic","round":32,"note":"쿠션 팩트의 망사를 몇 밀리미터 앞에서 봐요. 1 LED 마다 검은 실과 장밋빛 구멍이 번갈아 서고, 보이지 않는 퍼프가 0.5초마다 지름 28 LED 쯤의 자국을 찍으면 그 안의 구멍 78% 에 흰 파운데이션 방울이 맺혀요. 방울은 연어색으로 물들었다가 자국 가장자리부터 빨려 들어가고, 판에는 늘 769개가 남아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-cushion-mesh","type":"code","name":"cushion-mesh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Press=-1..1, Puff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Press","min":-1,"max":1},{"name":"Puff","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0612,"detail":0.3133,"edges":0.19,"complexity":0.3734,"coverage":0.5,"colour":0.1055,"drift":0.1322},"knobResponse":[0.0477,0.1254,0.1656,0.1397]},{"slug":"cyanotype","title":"Cyanotype","family":"print","round":19,"note":"철염을 바른 종이에 고사리와 깃털, 민들레 씨앗, 레이스를 놓고 햇빛에 구운 뒤 물로 씻어 내리면 프러시안 블루 인화가 드러나요. 마르며 짙어진 인화가 옆으로 밀려 나가면 다음 장이 깔려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-cyanotype","type":"code","name":"cyanotype","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tone=0..1, Speed=0.2..3, Specimen=0..4, Exposure=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tone","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Specimen","min":0,"max":4},{"name":"Exposure","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2407,"detail":0.0234,"edges":0.2171,"complexity":1.3748,"coverage":1,"colour":0.239,"drift":0.1842},"knobResponse":[0.1554,0.128,0.0957,0.1334]},{"slug":"damask","title":"Damask","family":"type","round":73,"note":"한 가지 실로 LED 하나에 한 교차씩 짠 천에 큰 낱말이 경수자로 들어 있어서, 낮게 도는 램프를 따라 글자가 바탕보다 밝았다가 어두워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-damask","type":"code","name":"damask","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0333,"detail":0.3241,"edges":0.9743,"complexity":0.8781,"coverage":0.2626,"colour":0.1359,"drift":0.0572},"knobResponse":[0.065,0.0923,0.1287,0.4594]},{"slug":"dandelin-spheres","title":"Dandelin Spheres","family":"geometry","round":33,"note":"유리 원뿔을 평면이 자른 원뿔곡선 위아래로 당들랭 구 둘이 원뿔에 끼어 평면에 닿아 있어요. 곡선을 도는 점에서 두 초점까지의 거리와 원뿔 모선 위 두 토막이 금색과 분홍으로 짝지어 같은 길이로 보여요. K3 은 평면 기울기로 30도의 타원에서 74도의 포물선을 지나 쌍곡선까지 가고, K1 을 누르면 평면이 11초 동안 똑바로 섰다가 돌아와요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-dandelin-spheres","type":"code","name":"dandelin-spheres","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=30..90, Cone=16..34","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":30,"max":90},{"name":"Cone","min":16,"max":34}],"start":[0,2,30,16],"measures":{"motion":0.1793,"detail":0.0495,"edges":0.3572,"complexity":1.3922,"coverage":0.6125,"colour":0.1958,"drift":0.0301},"knobResponse":[0.1111,0.0383,0.2036,0.1906]},{"slug":"dark-field","title":"Dark Field","family":"microbe","round":26,"note":"암시야 현미경 속 연못물 한 방울이에요. 볼복스와 짚신벌레, 돌말, 해캄 실 위의 종벌레가 검은 바탕에 흩은 빛으로만 빛나요. K1 이 라인베르크와 위상차로 조명을 바꾸고, 누르면 종벌레 자루가 용수철처럼 감겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-dark-field","type":"code","name":"dark-field","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Crowd=0..1, Focus=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Crowd","min":0,"max":1},{"name":"Focus","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.3814,"detail":0.2217,"edges":0.4142,"complexity":2.0815,"coverage":0.2631,"colour":0.1726,"drift":0.1456},"knobResponse":[0.5278,0.261,0.0556,0.1832]},{"slug":"datamosh","title":"Datamosh","family":"glitch","round":15,"note":"키프레임을 잃은 영상이에요. 노을과 격자 바닥이 제 움직임대로 블록째 밀려 녹아 흐르고, 장면이 바뀌면 새 그림이 옛 움직임을 따라 부서져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-datamosh","type":"code","name":"datamosh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Block=8..16, Mosh=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Block","min":8,"max":16},{"name":"Mosh","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.3661,"detail":0.0404,"edges":0.6611,"complexity":0.3641,"coverage":1,"colour":0.4625,"drift":0.1386},"knobResponse":[0.3092,0.1339,0.1128,0.1158]},{"slug":"day-cycle","title":"Day and Night","family":"weather","round":2,"note":"호수 위 작은 집이 하루를 지켜봐요. 해가 언덕 뒤로 지면 하늘이 노을을 지나 별과 달로 넘어가고 창에 하나씩 불이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-day-cycle","type":"code","name":"day-cycle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Season=0..1, Time=0.2..8, Clouds=0.15..1, Sun path=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Season","min":0,"max":1},{"name":"Time","min":0.2,"max":8},{"name":"Clouds","min":0.15,"max":1},{"name":"Sun path","min":-1,"max":1}],"start":[0,2,0.15,0.06],"measures":{"motion":0.0549,"detail":0.0184,"edges":0.5425,"complexity":0.6376,"coverage":1,"colour":0.3226,"drift":0.2553},"knobResponse":[0.2229,0.2763,0.1419,0.1052]},{"slug":"de-bruijn-sequence","title":"de Bruijn Sequence","family":"rhythm","round":52,"note":"0과 1의 고리를 1 은 치고 0 은 쉬는 리듬으로 치면서, 박마다 마지막 여섯 비트 창이 가리키는 단어의 타일을 켜서 단어 64개의 판이 한 주기에 꼭 한 번 차고, 그 아래 띠와 베틀 실이 같은 단어를 하나씩 밝혀요. K3 은 수열을 고르는 규칙, K4 는 차수를 6 에서 3 까지 내리고, K1 을 누르면 주기를 끝내고 새 수열로 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-de-bruijn-sequence","type":"code","name":"de-bruijn-sequence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rule=0..2, Zoom=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rule","min":0,"max":2},{"name":"Zoom","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1175,"detail":0.085,"edges":0.5433,"complexity":0.2615,"coverage":0.3366,"colour":0.1693,"drift":0.1252},"knobResponse":[0.0436,0.0602,0.076,0.1567]},{"slug":"dead-leaves","title":"Dead Leaves","family":"noise","round":56,"note":"반지름이 반 LED 부터 20 LED 까지인 원판이 이미 놓인 원판 밑으로 들어가 빈틈에만 보이다가, 마지막 구멍이 닫히면 그 자리에서 흰 고리가 퍼져요. 색은 원판 반지름의 옥타브를 알려 주고, 다음 표본이 차는 동안 구멍으로는 앞 표본이 잿빛으로 비쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-dead-leaves","type":"code","name":"dead-leaves","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grain=0.5..4, Law=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grain","min":0.5,"max":4},{"name":"Law","min":-1,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.1708,"detail":0.1549,"edges":1,"complexity":2.3375,"coverage":0.9888,"colour":0.4014,"drift":0.1961},"knobResponse":[0.417,0.1763,0.28,0.2968]},{"slug":"defect-turbulence","title":"Defect Turbulence","family":"wave","round":40,"note":"복소 긴즈부르크-란다우 방정식을 패널에서 풀어, 허수부와 실수부가 0 인 선을 두 색으로 긋고 둘이 만나는 위상 결함마다 + 와 − 를 찍어요. 처음의 결함 난류에서 쌍이 생기고 사라지며 나선을 끌고 다니다가 나선이 이겨 얼어붙은 칸이 되고, K3 을 Benjamin-Feir 선 아래로 돌리면 난류가 끝내 가라앉지 않아요. K4 는 그리는 시계를 나선의 진동수에 맞춰 팔을 멈춰 세우고, K1 을 누르면 한 자리를 휘저어 결함 쌍을 새로 터뜨려요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-defect-turbulence","type":"code","name":"defect-turbulence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stability=-0.8..0.6, Strobe=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stability","min":-0.8,"max":0.6},{"name":"Strobe","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.8012,"detail":0.3482,"edges":0.8162,"complexity":2.0341,"coverage":0.6518,"colour":0.3884,"drift":0.081},"knobResponse":[0.2629,0.3137,0.315,0.3041]},{"slug":"dehn-twist","title":"Dehn Twist","family":"topology","round":81,"note":"원환면의 닫힌 곡선이 고리띠를 따라 한 바퀴 끌려 돌고 펴질 때마다 류가 (p, q) 에서 (p, q + p) 로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-dehn-twist","type":"code","name":"dehn-twist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Curve=0..5, Twists=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Curve","min":0,"max":5},{"name":"Twists","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2569,"detail":0.058,"edges":0.3986,"complexity":0.8019,"coverage":0.6818,"colour":0.1997,"drift":0.059},"knobResponse":[0.1236,0.0658,0.1067,0.0496]},{"slug":"delaunay-flips","title":"Delaunay Flips","family":"cells","round":68,"note":"한 모서리에서 편 부채꼴 삼각분할을 로슨의 뒤집기가 외접원 안에 든 점을 하나씩 찾아 풀고, 삼각형마다 가장 작은 각에 따라 자홍 바늘에서 청록 정삼각형으로 바뀌다가 들로네가 되면 빈 외접원 71 개가 한꺼번에 떠요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-delaunay-flips","type":"code","name":"delaunay-flips","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Circles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Points","min":30,"max":90},{"name":"Circles","min":0,"max":1}],"start":[0,2,30,0.06],"measures":{"motion":0.3457,"detail":0.0664,"edges":0.3927,"complexity":1.6784,"coverage":0.8257,"colour":0.1971,"drift":0.1621},"knobResponse":[0.1868,0.0737,0.1711,0.1725]},{"slug":"diffusion-front","title":"Diffusion Front","family":"fractal","round":50,"note":"바닥에서 퍼져 오르는 염료의 농도만큼 칸이 차고, 바닥에 이어진 덩어리의 금빛 프랙탈 앞줄이 스미기 문턱 0.5927 의 자리를 따라 √t 로 올라갔다가 바닥이 닫히면 가라앉아요. K3 은 칸이 난수를 새로 뽑는 빠르기, K4 는 이어지지 않은 섬의 밝기이고, K1 을 누르면 새 격자를 깔아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-diffusion-front","type":"code","name":"diffusion-front","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hop=0..1, Islands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hop","min":0,"max":1},{"name":"Islands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2495,"detail":0.2169,"edges":0.89,"complexity":0.5712,"coverage":0.6223,"colour":0.3344,"drift":0.3892},"knobResponse":[0.3092,0.3138,0.2165,0.1015]},{"slug":"distance-field","title":"Distance Field","family":"type","round":67,"note":"W, S, K, 3, 빛, ? 가 성긴 거리장 격자에서 쌍선형으로 되살아나 테두리와 바깥 빛을 두르고, 텍셀이 커질수록 모서리가 둥글어지고 가는 획이 사라지며 다음 글자로 녹아들어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-distance-field","type":"code","name":"distance-field","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Magnify=-1.5..1.8, Weight=-4..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Magnify","min":-1.5,"max":1.8},{"name":"Weight","min":-4,"max":5}],"start":[0,2,0,0.06],"measures":{"motion":0.4695,"detail":0.0715,"edges":0.2744,"complexity":1.5956,"coverage":0.6893,"colour":0.3778,"drift":0.2994},"knobResponse":[0.225,0.3049,0.214,0.406]},{"slug":"domain-warp","title":"Domain Warp","family":"noise","round":1,"note":"노이즈가 제 자신을 비틀어서 어두운 쪽빛 돌에 금빛 결이 흘러요. 대리석을 붓는 것처럼 천천히 뒤섞여요.","why":"어두운 바탕에 빛나는 결이 흘러가요. A Big Hit, 0524-2 와 같은 쪽이에요.","block":0,"ramped":true,"layer":{"id":"layer-domain-warp","type":"code","name":"domain-warp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#05030f","alpha":1},{"position":0.16,"color":"#0e1450","alpha":1},{"position":0.22,"color":"#2a7ac0","alpha":1},{"position":0.27,"color":"#100c44","alpha":1},{"position":0.5,"color":"#2c1478","alpha":1},{"position":0.62,"color":"#c83888","alpha":1},{"position":0.68,"color":"#ffd890","alpha":1},{"position":0.74,"color":"#ff6a3a","alpha":1},{"position":0.84,"color":"#4a0a3a","alpha":1},{"position":1,"color":"#05030f","alpha":1}],"mode":"oklab","wrap":true},"recolor":false,"knobsAnnotationRaw":"// @knobs Cycle=0..1, Speed=0..5, Warp=1..6, Zoom=0.035..0.095","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Cycle","min":0,"max":1},{"name":"Speed","min":0,"max":5},{"name":"Warp","min":1,"max":6},{"name":"Zoom","min":0.035,"max":0.095}],"start":[0,2,1,0.06],"measures":{"motion":0.2428,"detail":0.0806,"edges":0.2816,"complexity":1.8069,"coverage":0.9604,"colour":0.3247,"drift":0.15},"knobResponse":[0.3352,0.1929,0.1917,0.2107]},{"slug":"domino-run","title":"Domino Run","family":"physics","round":16,"note":"여섯 선반과 나선 계단 다섯을 잇는 도미노 마흔 개를 손끝이 밀면, 물결이 제 물리 빠르기로 내려가고 낮은 램프 빛을 받던 상아색 면이 쓰러지는 대로 어두워져요. 다 쓰러지면 필름이 거꾸로 돌아 줄을 다시 세워요. 줄이 달리는 동안 K1 을 누르면 아직 서 있는 선반 머리에서 두 번째 물결이 떠나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-domino-run","type":"code","name":"domino-run","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.5..4, Spacing=-1..1, Angle=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.5,"max":4},{"name":"Spacing","min":-1,"max":1},{"name":"Angle","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1541,"detail":0.079,"edges":0.5891,"complexity":0.4474,"coverage":0.2699,"colour":0.0868,"drift":0.2609},"knobResponse":[0.2214,0.1713,0.2211,0.2694]},{"slug":"double-gyre","title":"Double Gyre","family":"noise","round":48,"note":"위아래로 쌓인 두 소용돌이 칸 사이의 경계가 출렁이는 동안, 유체가 갈라지는 능선을 앞으로 볼 때는 호박색, 뒤로 볼 때는 하늘색으로 그려서 가는 능선 다발이 두 칸을 감고 가운데로 혀처럼 접히며 반 주기마다 위아래가 뒤집혀요. K3 은 따라가는 시간을, K4 는 경계가 출렁이는 폭을 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-double-gyre","type":"code","name":"double-gyre","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Horizon=-1..1, Epsilon=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Horizon","min":-1,"max":1},{"name":"Epsilon","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.2924,"detail":0.2316,"edges":0.8131,"complexity":1.01,"coverage":0.6619,"colour":0.4307,"drift":0.2617},"knobResponse":[0.2983,0.422,0.5059,0.3811]},{"slug":"doyle-spiral","title":"Doyle Spiral","family":"cells","round":80,"note":"원판마다 여섯 원판과 맞닿은 도일 나선이 패널 가운데의 어두운 극에서 흘러나와 가장자리 밖으로 커지고, 원판이 앉은 나선 팔마다 색이 달라서 원판이 4.2초에 한 칸씩 밖으로 나갈 때마다 다섯 색 팔이 한 팔씩 돌아가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-doyle-spiral","type":"code","name":"doyle-spiral","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Arms=5..10, Poles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Arms","min":5,"max":10},{"name":"Poles","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.4507,"detail":0.1091,"edges":0.9944,"complexity":2.4096,"coverage":0.7853,"colour":0.5586,"drift":0.1604},"knobResponse":[0.4055,0.3257,0.3977,0.4088]},{"slug":"dragon","title":"Dragon Fold","family":"fractal","round":2,"note":"종이띠를 반으로 접기를 열 번 되풀이하면 헤이웨이 드래곤이 돼요. 세대마다 선 전체의 복사본이 끝점을 축으로 90도 돌아 나오고, 다 접히면 거꾸로 닫혀요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-dragon","type":"code","name":"dragon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Fold Speed=0.5..6, Generations=8..10, Dragons=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Fold Speed","min":0.5,"max":6},{"name":"Generations","min":8,"max":10},{"name":"Dragons","min":1,"max":4}],"start":[0,2,8,1],"measures":{"motion":0.7649,"detail":0.0834,"edges":0.9552,"complexity":0.1947,"coverage":0.1168,"colour":0.2214,"drift":0.0797},"knobResponse":[0.0573,0.0725,0.0977,0.1563]},{"slug":"dripstone","title":"Dripstone","family":"mineral","round":19,"note":"석회동굴 단면이 128줄을 다 써요. 종유석 끝에서 물방울이 부풀다 떨어져 석순을 한 방울씩 키우고 웅덩이에 동심원을 그리는 사이, 쇼케이브 조명이 청록과 보라, 흰빛으로 번갈아 바뀌고 동굴 탐험가의 헤드램프가 옆으로 훑고 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-dripstone","type":"code","name":"dripstone","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Age=0..1, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Age","min":0,"max":1},{"name":"Damp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.113,"detail":0.0548,"edges":0.2063,"complexity":2.555,"coverage":0.9702,"colour":0.163,"drift":0.1125},"knobResponse":[0.0618,0.1355,0.0996,0.0869]},{"slug":"drop-tower","title":"Drop Tower","family":"fair","round":18,"note":"밤 놀이공원의 드롭 타워가 128줄을 다 써요. 링에 탄 여덟 사람을 꼭대기까지 끌어올려 매달아 두었다가 탑 높이에 맞춘 중력으로 떨어뜨리고, 자석 브레이크에서 번쩍이며 세워요. K1 을 누르면 오르는 중에도 바로 떨어뜨려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-drop-tower","type":"code","name":"drop-tower","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lights=0..1, Speed=0.2..3, Height=50..110, Thrill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lights","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Height","min":50,"max":110},{"name":"Thrill","min":0,"max":1}],"start":[0,2,50,0.06],"measures":{"motion":0.437,"detail":0.0668,"edges":0.5494,"complexity":1.5352,"coverage":0.8276,"colour":0.1705,"drift":0.1633},"knobResponse":[0.0483,0.0875,0.0709,0.0567]},{"slug":"drying-mud","title":"Drying Mud","family":"cells","round":16,"note":"젖은 흙이 마르며 금이 직각으로 갈라져 T 자로 만나고, 오래된 금은 넓고 깊어지며 조각 테두리가 밝게 말려 올라가요. K1 을 누르면 소나기가 와서 금이 물에 잠겨 닫히고 흙이 다시 말라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-drying-mud","type":"code","name":"drying-mud","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Clay=0..1, Sun=0.3..3, Cracks=0..1, Curl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Clay","min":0,"max":1},{"name":"Sun","min":0.3,"max":3},{"name":"Cracks","min":0,"max":1},{"name":"Curl","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0652,"detail":0.0775,"edges":0.2652,"complexity":2.4007,"coverage":0.991,"colour":0.1598,"drift":0.1523},"knobResponse":[0.1914,0.2254,0.1497,0.0607]},{"slug":"dupin-cyclide","title":"Dupin Cyclide","family":"geometry","round":67,"note":"위에서 도는 원환면을 아래의 구면 반전으로 뒤집은 뒤팽 사이클라이드가 같이 돌고, 원환면의 원 28 개가 상에서도 모두 원으로 남아 청록과 장미색 곡률선 두 무리를 이뤄요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-dupin-cyclide","type":"code","name":"dupin-cyclide","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..2, Distance=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":2},{"name":"Distance","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5408,"detail":0.0518,"edges":0.2837,"complexity":1.1224,"coverage":0.3055,"colour":0.0954,"drift":0.0765},"knobResponse":[0.0389,0.0843,0.0716,0.0475]},{"slug":"durer-alphabet","title":"Dürer's Alphabet","family":"type","round":73,"note":"위아래 두 정사각형에서 번갈아 펜이 획 가장자리를 자로 긋고 둥근 획과 세리프 받침을 컴퍼스로 돌리면, 상아빛 잉크가 로마 대문자의 몸을 채우고 둘레의 종이가 밝아져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-durer-alphabet","type":"code","name":"durer-alphabet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Letter=0..12, Stem=0.1..0.2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Letter","min":0,"max":12},{"name":"Stem","min":0.1,"max":0.2}],"start":[0,2,0,0.1],"measures":{"motion":0.0484,"detail":0.0669,"edges":0.4795,"complexity":0.9934,"coverage":0.6454,"colour":0.1303,"drift":0.2473},"knobResponse":[0.0709,0.0457,0.1421,0.0759]},{"slug":"durer-unfolding","title":"Dürer's Unfolding","family":"space","round":49,"note":"판화처럼 빗금 친 입체가 펼친 그물로 패널에 섰다가 경첩마다 접혀 닫히고, 어둠 속에서 돌다 점으로 사라지면 다음 입체가 돌며 겹치지 않는 새 그물로 펼쳐져요. K3 은 정육면체부터 육팔면체까지 여섯 입체 가운데 처음 것을, K4 는 입체마다 골라 둔 그물 여덟 가운데 하나를 골라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-durer-unfolding","type":"code","name":"durer-unfolding","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Solid=0..5, Tree=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Solid","min":0,"max":5},{"name":"Tree","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0998,"detail":0.1127,"edges":0.9887,"complexity":0.0934,"coverage":0.3291,"colour":0.2802,"drift":0.3649},"knobResponse":[0.2193,0.1359,0.2556,0.2327]},{"slug":"dust-motes","title":"Dust Motes","family":"particle","round":19,"note":"어두운 방, 높은 창에서 내려온 햇살 한 줄기 안에서만 먼지가 반짝이며 떠돌고, 커튼이 흔들리면 빛줄기가 좁아졌다 넓어져요. K1 을 누르면 사람이 방을 가로질러 빛줄기에 그림자를 내고, 발치에서 먼지가 빛 속으로 피어올라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-dust-motes","type":"code","name":"dust-motes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sun=0..1, Speed=0.2..3, Dust=1..4, Draft=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sun","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dust","min":1,"max":4},{"name":"Draft","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0301,"detail":0.0213,"edges":0.2348,"complexity":0.703,"coverage":0.3211,"colour":0.0688,"drift":0.0337},"knobResponse":[0.0562,0.0401,0.0354,0.0362]},{"slug":"dyson-gas","title":"Dyson Gas","family":"particle","round":29,"note":"고유값 열 개가 맨 위 줄에 구슬로 떨며 서로 밀어내고, 그 지나온 길이 실이 되어 아래로 흘러요. 실은 가운데에 빽빽하고 가장자리로 갈수록 성기며 서로 건너지 않아요. K3 은 행렬 크기(10~28)이고, K1 을 누르면 밀어내는 힘이 3초쯤 꺼져 실이 엉키며 건너요.","why":"선이 LED 한 알 굵기예요.","block":1,"ramped":false,"layer":{"id":"layer-dyson-gas","type":"code","name":"dyson-gas","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Count=10..28, Beta=1..9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Count","min":10,"max":28},{"name":"Beta","min":1,"max":9}],"start":[0,2,10,1],"measures":{"motion":1.3286,"detail":0.1297,"edges":0.5413,"complexity":1.7541,"coverage":0.3748,"colour":0.2639,"drift":0.1193},"knobResponse":[0.1261,0.1507,0.2251,0.1306]},{"slug":"ehrenfest-urn","title":"Ehrenfest Urn","family":"particle","round":73,"note":"위아래로 쌓은 두 방의 공 N 개 가운데 하나가 걸음마다 좁은 목을 지나 건너가고, 아래 띠가 위 방의 공 수가 N 에서 N/2 로 내려와 이항분포의 폭 안에서 떠도는 것을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ehrenfest-urn","type":"code","name":"ehrenfest-urn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Balls=8..200, Watch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Balls","min":8,"max":200},{"name":"Watch","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.5689,"detail":0.0432,"edges":0.5521,"complexity":0.4509,"coverage":0.1971,"colour":0.1609,"drift":0.098},"knobResponse":[0.0418,0.0617,0.1227,0.0789]},{"slug":"eight-principles-of-yong","title":"Eight Principles of Yong","family":"type","round":70,"note":"붓이 패널 높이의 永 을 다섯 획 차례로 쓰는 동안 여덟 필법의 이름이 그 획 옆에 주홍으로 켜지고, 다 쓰면 여덟이 차례로 제 획과 함께 빛나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eight-principles-of-yong","type":"code","name":"eight-principles-of-yong","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Brush=-1..1, Ink=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Brush","min":-1,"max":1},{"name":"Ink","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0425,"detail":0.0837,"edges":0.5269,"complexity":1.1359,"coverage":0.9999,"colour":0.263,"drift":0.0973},"knobResponse":[0.1386,0.0726,0.0645,0.0579]},{"slug":"ekg-sequence","title":"EKG Sequence","family":"data","round":79,"note":"EKG 수열을 한 항에 한 줄씩 써 내려가며 값을 가로로 찍어요. 항은 대개 a = n 곁에 붙고, 홀수 소수 p 마다 2p, p, 3p 가 n/2 와 3n/2 의 흐린 안내선까지 뻗는 획이 되어 왼쪽에 금빛으로 그 소수가 적혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ekg-sequence","type":"code","name":"ekg-sequence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zoom=1..4, Links=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zoom","min":1,"max":4},{"name":"Links","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.1069,"detail":0.1017,"edges":0.9956,"complexity":0.1174,"coverage":0.1385,"colour":0.2607,"drift":0.0703},"knobResponse":[0.0886,0.0878,0.1179,0.0441]},{"slug":"elastica","title":"Euler's Elastica","family":"physics","round":53,"note":"양 끝이 핀에 걸린 120 LED 짜리 가는 막대가 천천히 눌렸다 풀리며 오일러의 탄성 곡선 가족을 다 지나가요. 살짝 휜 활에서 아치와 직각 엘라스티카를 지나, 두 끝이 만나는 물방울과 끝이 서로 지나치는 고리까지 가요. 위의 진자는 막대를 달리는 구슬 자리의 막대와 늘 나란히 흔들리고, 아래에서는 그 진자의 궤도가 상평면을 돌아요. K3 은 반파 수 1~4 이고, K4 는 풀 때 어디까지 돌아오는지예요. 단추를 누르면 하중이 멈춰 한 모양이 서 있어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-elastica","type":"code","name":"elastica","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=1..4, Preload=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":1,"max":4},{"name":"Preload","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3145,"detail":0.0384,"edges":0.3274,"complexity":0.4646,"coverage":0.1716,"colour":0.1706,"drift":0.1169},"knobResponse":[0.0447,0.0924,0.0801,0.0827]},{"slug":"elephant-toothpaste","title":"Elephant Toothpaste","family":"chemistry","round":23,"note":"보라색 장갑을 낀 손이 실험대 위 눈금실린더에 아이오딘화 칼륨을 부으면, 유리 안쪽에 그어 둔 식용 색소 줄무늬를 두른 거품 기둥이 입구에서 솟아 패널 꼭대기까지 올라요. 기둥은 한쪽으로 꺾여 실린더 옆을 타고 흘러내려 김 나는 더미로 쌓이고, 더미가 굳어 바래면 손이 닦아 내고 새 실린더를 내려놓아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-elephant-toothpaste","type":"code","name":"elephant-toothpaste","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dye=0..1, Speed=0.2..3, Stripes=1..4, Strength=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dye","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stripes","min":1,"max":4},{"name":"Strength","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1815,"detail":0.029,"edges":0.1765,"complexity":0.9251,"coverage":0.367,"colour":0.1801,"drift":0.102},"knobResponse":[0.0441,0.1137,0.0453,0.0773]},{"slug":"elliptic-chords","title":"Elliptic Chords","family":"number","round":36,"note":"위에는 실수 곡선 y² = x³ − 6x 가, 아래에는 같은 곡선을 61 로 나눈 나머지로 푼 61×61 판이 있어요. G 와 kG 를 지나는 직선이 곡선과 세 번째로 만나는 점을 x축에 뒤집으면 (k+1)G 이고, 아래에서는 그 직선이 판을 감아 도는 점 61개가 되어 곡선의 점 셋에서만 하얗게 빛나며 배수들이 방문 순서대로 무지개색으로 켜져요. K3 은 상수 b 를 바꿔 알 모양 고리를 키우다 긴 가지에 붙이고, K1 을 누르면 새 생성원 G 로 O 에서 다시 세요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-elliptic-chords","type":"code","name":"elliptic-chords","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Curve=-4..8, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Curve","min":-4,"max":8},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0496,"detail":0.0598,"edges":0.5832,"complexity":0.5264,"coverage":0.6226,"colour":0.1255,"drift":0.0238},"knobResponse":[0.0592,0.0309,0.1041,0.0281]},{"slug":"elliptic-law","title":"Elliptic Law","family":"particle","round":56,"note":"세로로 선 타원 안에서 무작위 실수 행렬의 고윳값이 짧은 꼬리를 끌며 떠다니고, 가운데 실수축에서 거울 짝이 만나면 두 실수 고윳값으로 갈라져 축을 따라 달아나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-elliptic-law","type":"code","name":"elliptic-law","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tau=0.333..1, Size=40..80","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tau","min":0.333,"max":1},{"name":"Size","min":40,"max":80}],"start":[0,2,0.333,40],"measures":{"motion":0.2405,"detail":0.0808,"edges":0.4129,"complexity":1.1148,"coverage":0.3169,"colour":0.1472,"drift":0.0656},"knobResponse":[0.0525,0.0819,0.0956,0.1404]},{"slug":"embossed-glow","title":"Embossed Glow","family":"cosmetic","round":37,"note":"엠보싱한 하이라이터의 눌린 면이 패널을 채우고, 떠도는 작은 램프를 향한 비탈이 부드러운 띠로 빛나요. 반짝이 알갱이는 면이 램프 쪽으로 7도 안에 설 때만 빛나서 반짝임이 능선을 타고 옮겨 가요. 6.5초마다 보이지 않는 손끝이 홈을 쓸어 엠보싱을 새틴 띠로 눌러 펴고, 네 번 쓸면 판이 다시 눌려요. K3 은 물결과 퀼팅 마름모, 갈매기, 비늘 무늬를 고르고, 누르면 판을 바로 다시 눌러요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-embossed-glow","type":"code","name":"embossed-glow","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Relief=0..3, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Relief","min":0,"max":3},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0374,"detail":0.0733,"edges":0.2266,"complexity":2.4899,"coverage":1,"colour":0.1712,"drift":0.1081},"knobResponse":[0.3063,0.0963,0.1554,0.2659]},{"slug":"emergence","title":"Emergence","family":"mammal","round":24,"note":"해 질 녘 메마른 언덕의 동굴 입구에서 박쥐 떼가 검은 리본처럼 쏟아져 나와, 노을 하늘을 비틀며 패널 꼭대기까지 기둥으로 올라가요. 기둥은 두 가닥으로 갈라졌다 다시 붙고, 매가 내리꽂히면 박쥐들이 고리처럼 물러났다가 구멍이 닫혀요. K1 을 끝까지 돌리면 밤이 되어 박쥐가 보름달 앞을 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-emergence","type":"code","name":"emergence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Bats=400..1400, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":400,"max":1400},{"name":"Wind","min":-1,"max":1}],"start":[0,2,400,0.06],"measures":{"motion":1.359,"detail":0.0665,"edges":0.4877,"complexity":1.5604,"coverage":0.9427,"colour":0.3555,"drift":0.0712},"knobResponse":[0.2525,0.0481,0.0669,0.0629]},{"slug":"erdos-discrepancy","title":"Erdős Discrepancy","family":"rhythm","round":56,"note":"64개 열이 같은 리듬을 d 박마다 하나씩 듣고 그 합을 한 줄씩 써 내려가요. 곱셈적 리듬은 청록과 자홍의 차분한 타탄을 짜고 기록이 깨지는 걸음마다 한 줄이 통째로 하얘지며, 동전 던지기 박이 섞이면 시끄러운 세로 줄로 찢어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-erdos-discrepancy","type":"code","name":"erdos-discrepancy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Prime=3..13","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":0,"max":1},{"name":"Prime","min":3,"max":13}],"start":[0,2,0,3],"measures":{"motion":1.4087,"detail":0.0873,"edges":0.5343,"complexity":0.2701,"coverage":0.9126,"colour":0.4077,"drift":0.1626},"knobResponse":[0.2476,0.1533,0.3359,0.3111]},{"slug":"eruption","title":"Eruption","family":"volcano","round":25,"note":"해 질 녘 성층화산을 세로로 잘라 봐요. 아래 마그마 방에서 떠난 가스 덩어리가 황토와 잿빛 지층 사이 화도를 타고 올라 분화구에서 터지면, 화산탄이 포물선을 그리며 떨어지고 재 기둥은 패널 꼭대기까지 올라 번개를 품어요. K1 이 스트롬볼리식에서 하와이식 용암 분수를 지나 플리니식 재 기둥까지 분출을 바꾸고, K1 을 누르면 큰 폭발이 나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-eruption","type":"code","name":"eruption","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Style=0..1, Speed=0.2..3, Pressure=0..1, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Style","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pressure","min":0,"max":1},{"name":"Wind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3557,"detail":0.0525,"edges":0.231,"complexity":2.1856,"coverage":1,"colour":0.2971,"drift":0.0844},"knobResponse":[0.082,0.0543,0.0923,0.0549]},{"slug":"essence-drop","title":"Essence Drop","family":"cosmetic","round":33,"note":"맑은 물빛 에센스에 짙은 색 방울이 느린 화면으로 떨어져 손가락 아홉 개의 왕관을 세우고, 파인 자리가 닫히며 솟은 기둥 끝에서 구슬이 떨어져 나가요. 방울의 짙은 색은 소용돌이 고리로 말려 가라앉으며 웅덩이에 풀려요. K3 을 올리면 왕관과 구슬이 사라지고 젤처럼 무겁게 잠기며, K1 은 색상환을 다 돌고 누르면 방울이 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-essence-drop","type":"code","name":"essence-drop","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Viscosity=0..1, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Viscosity","min":0,"max":1},{"name":"Size","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0508,"detail":0.0106,"edges":0.2549,"complexity":1.4637,"coverage":1,"colour":0.1457,"drift":0.0297},"knobResponse":[0.2403,0.0329,0.0375,0.0322]},{"slug":"etaoin-shrdlu","title":"Etaoin Shrdlu","family":"data","round":66,"note":"앨리스 첫 두 문장이 한 자씩 떨어져 잦은 차례로 줄 선 막대 열여섯 개에 쌓이고, 다 읽으면 이름표가 ETIONS AHRDWG 가 되어 라이노타이프 자판의 ETAOIN SHRDLU 와 여섯 자리가 맞아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-etaoin-shrdlu","type":"code","name":"etaoin-shrdlu","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Forget=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Forget","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5391,"detail":0.1494,"edges":0.9947,"complexity":0.1546,"coverage":0.3122,"colour":0.2867,"drift":0.0582},"knobResponse":[0.1006,0.088,0.1243,0.1]},{"slug":"euclid-pulse","title":"Euclid Pulse","family":"rhythm","round":1,"note":"유클리드 리듬 셋이 고리 셋에서 함께 돌아요. 바깥 두 고리의 박은 고리 밖 제 조각을 따라 빛으로 퍼져서 세운 패널의 위아래 끝까지 닿아요. 처음은 E(3,8) 이에요.","why":"리듬은 좋은데 그림이 작고 어두워요.","block":1,"ramped":false,"layer":{"id":"layer-euclid-pulse","type":"code","name":"euclid-pulse","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=80..180, Pulses=3..13, Steps=8..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":80,"max":180},{"name":"Pulses","min":3,"max":13},{"name":"Steps","min":8,"max":16}],"start":[0,80,3,8],"measures":{"motion":0.5845,"detail":0.0325,"edges":0.366,"complexity":0.4817,"coverage":0.4069,"colour":0.1498,"drift":0.1272},"knobResponse":[0.0702,0.0945,0.0699,0.0495]},{"slug":"euler-strokes","title":"Euler Strokes","family":"type","round":75,"note":"펜이 세로로 쌓은 낱말을 오일러가 센 가장 적은 획 수로 히어홀처의 길을 따라 쓰고, 홀수 꼭짓점이 펜보다 먼저 빛나며 글자마다 획 수가 숫자와 점으로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-euler-strokes","type":"code","name":"euler-strokes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Order=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Order","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0655,"detail":0.0437,"edges":0.4034,"complexity":0.6379,"coverage":0.2926,"colour":0.1378,"drift":0.0723},"knobResponse":[0.0459,0.0418,0.158,0.0479]},{"slug":"eulers-officers","title":"Euler's Officers","family":"cells","round":60,"note":"위에는 오일러의 36 장교를 세운 6 × 6 의 가장 나은 시도가, 아래에는 100쌍이 한 번씩 서는 10 × 10 그레코-라틴 방진이 있고, 칸마다 바깥 고리가 계급 색, 안쪽 심이 연대 색이에요. 연대가 1.5초마다 하나씩 밝아져 줄과 칸과 계급을 한 번씩 지나는 가로지르기를 보여 주고, 위 방진에서 두 쌍이 겹친 네 칸은 하얗게 맥박쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eulers-officers","type":"code","name":"eulers-officers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Core=-1..1, Shuffle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Core","min":-1,"max":1},{"name":"Shuffle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.036,"detail":0.1723,"edges":0.9888,"complexity":0.1476,"coverage":0.7056,"colour":0.6253,"drift":0.0407},"knobResponse":[0.4368,0.0498,0.2438,0.1746]},{"slug":"excavation","title":"Excavation","family":"construction","round":25,"note":"도심 빌딩 사이의 깊은 터파기를 세로로 잘라 봐요. 굴착기가 바닥에 쌓은 흙을 갠트리의 클램셸이 100줄 위 덤프트럭까지 끌어올리고, 바닥이 한 단 깊어지면 흙막이 벽 사이에 강철 버팀보가 한 단 더 용접돼 걸려요. K1 을 돌리면 데크 틈으로 떨어지던 햇빛 기둥이 기울다가 밤의 나트륨등으로 바뀌고, 누르면 경고등 뒤에 발파가 일어나 바닥에 먼지가 차요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-excavation","type":"code","name":"excavation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Depth=8..10, Water=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":8,"max":10},{"name":"Water","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.0546,"detail":0.0796,"edges":0.3258,"complexity":1.9604,"coverage":0.986,"colour":0.2478,"drift":0.0543},"knobResponse":[0.2505,0.0522,0.0454,0.0762]},{"slug":"exclusion-process","title":"Exclusion Process","family":"particle","round":82,"note":"64칸 줄에 왼쪽으로 들어온 입자가 앞 칸이 빌 때만 오른쪽으로 한 칸씩 뛰는 것을 가장 새 줄이 위에 오는 시공간 그림으로 쌓아서 입자마다 제 색 실이 남고, 처음 노브에서는 성긴 흐름과 막힌 줄 사이의 경계가 이리저리 떠돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-exclusion-process","type":"code","name":"exclusion-process","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Alpha=0.25..1, Beta=0.25..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Alpha","min":0.25,"max":1},{"name":"Beta","min":0.25,"max":1}],"start":[0,2,0.25,0.25],"measures":{"motion":2.8227,"detail":0.216,"edges":1,"complexity":1.6671,"coverage":0.6251,"colour":0.4383,"drift":0.1553},"knobResponse":[0.2918,0.2685,0.244,0.268]},{"slug":"excursion-sets","title":"Excursion Sets","family":"noise","round":63,"note":"오르내리는 수준으로 자른 가우스 장이 섬과 호수로 갈라지고, 섬은 분홍 테두리로, 호수는 파랑으로 칠해져요. 아래 띠에 섬 수 빼기 호수 수인 오일러 지표가 점으로 찍혀 애들러의 이론 곡선을 따라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-excursion-sets","type":"code","name":"excursion-sets","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=3..8, Level=-1.5..1.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":3,"max":8},{"name":"Level","min":-1.5,"max":1.5}],"start":[0,2,3,0.06],"measures":{"motion":0.2095,"detail":0.077,"edges":0.8873,"complexity":0.1914,"coverage":0.5179,"colour":0.205,"drift":0.1795},"knobResponse":[0.0473,0.0968,0.0829,0.2034]},{"slug":"explicit-formula","title":"Explicit Formula","family":"number","round":39,"note":"소수 거듭제곱마다 log p 씩 뛰는 계단 ψ(x) 를 제타 함수의 영점으로 다시 지어요. x 가 아래로, ψ 가 옆으로 가고, 영점이 한 쌍씩 더해질 때마다 매끈한 선 x 에 물결이 붙다가 계단으로 날카로워지고, 제자리를 찾은 계단 띠부터 켜져요. 오른쪽 끝 세 열이 임계선이라 더해진 영점이 제 높이에서 켜져요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-explicit-formula","type":"code","name":"explicit-formula","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Reach=24..144, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Reach","min":24,"max":144},{"name":"Tilt","min":0,"max":1}],"start":[0,2,24,0.06],"measures":{"motion":0.0929,"detail":0.028,"edges":0.4504,"complexity":0.7997,"coverage":0.9982,"colour":0.172,"drift":0.1028},"knobResponse":[0.141,0.0429,0.064,0.081]},{"slug":"eye-chart","title":"Eye Chart","family":"type","round":74,"note":"뒤에서 비춘 시력표의 슬론 글자 여덟 줄이 렌즈가 바뀔 때마다 흐려졌다 맑아지고, 지시봉이 글자를 하나씩 읽다가 더는 못 읽는 줄에서 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eye-chart","type":"code","name":"eye-chart","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Error=0.5..2.5, Speed=0.2..3, Glare=0..1, Duochrome=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Error","min":0.5,"max":2.5},{"name":"Speed","min":0.2,"max":3},{"name":"Glare","min":0,"max":1},{"name":"Duochrome","min":0,"max":1}],"start":[0.5,2,0,0.06],"measures":{"motion":0.0665,"detail":0.0498,"edges":0.2212,"complexity":1.6593,"coverage":0.9578,"colour":0.112,"drift":0.036},"knobResponse":[0.1018,0.2333,0.0999,0.3162]},{"slug":"eyes-in-the-dark","title":"Eyes in the Dark","family":"halloween","round":41,"note":"까만 패널에 고양이의 연두 눈, 부엉이의 둥근 주황 눈, 노려보는 빨간 눈, 거미의 여덟 눈이 떠서 떠도는 도깨비불을 눈동자로 따라가요. 눈은 깜빡이며 어슬렁거리다 0.7초 만에 다른 자리로 미끄러지고, 감았다가 다른 곳에서 다시 떠요. K3 은 눈 무리를 5 에서 9 까지 늘리고 K4 는 깜빡임과 튀는 몸짓을 잦게 하며, K1 을 누르면 모든 눈이 한꺼번에 떠서 2.5초 동안 가운데를 노려봐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-eyes-in-the-dark","type":"code","name":"eyes-in-the-dark","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Shift=0..1, Speed=0.2..3, Pairs=5..9, Jumpy=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Shift","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pairs","min":5,"max":9},{"name":"Jumpy","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.3566,"detail":0.0262,"edges":0.2761,"complexity":0.5807,"coverage":0.1982,"colour":0.1282,"drift":0.1318},"knobResponse":[0.0445,0.0776,0.0581,0.0608]},{"slug":"ferris-wheel","title":"Ferris Wheel","family":"fair","round":25,"note":"밤 호숫가에서 지름 59 LED 의 관람차가 돌고, 곤돌라는 바퀴가 돌아도 늘 똑바로 매달려 있어요. 살과 테두리의 불빛이 쇼 여섯 가지를 6.5초씩 이어 가고, 호수가 바퀴와 불빛을 일렁이며 비춰요. K4 Wind 를 올리면 구름이 몰려오고 물그림자가 긴 빛줄기로 부서지며, 버튼은 다음 쇼로 넘겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-ferris-wheel","type":"code","name":"ferris-wheel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lights=0..1, Speed=0.2..3, Spokes=12..32, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lights","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spokes","min":12,"max":32},{"name":"Wind","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.2782,"detail":0.0637,"edges":0.3285,"complexity":1.8086,"coverage":0.9981,"colour":0.1705,"drift":0.1001},"knobResponse":[0.0444,0.0524,0.0479,0.0788]},{"slug":"ferrow","title":"Ferrow","family":"pixel","round":86,"note":"무너진 성채의 문을 이백 년째 지키는 파수 로봇이 받침 위에 한 손은 허리에 얹고, 홈이 호박색으로 달아오른 대검을 어깨에 멘 채 숨 쉬다가, 6.8초마다 그 대검을 받침에 꽂아 불꽃을 튀기고 등으로 증기를 뿜어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ferrow","type":"code","name":"ferrow","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Motion=0..1, Stand=0..3, Effect=0..1, Edition=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Motion","min":0,"max":1},{"name":"Stand","min":0,"max":3},{"name":"Effect","min":0,"max":1},{"name":"Edition","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1421,"detail":0.071,"edges":0.7411,"complexity":0.1751,"coverage":0.509,"colour":0.1503,"drift":0.0829},"knobResponse":[0.0826,0.0224,0.0542,0.0823]},{"slug":"feynman-checkerboard","title":"Feynman Checkerboard","family":"wave","round":62,"note":"시간이 아래로, 공간이 가로로 놓인 빛 원뿔 격자에서 모퉁이마다 진폭에 iε 를 곱하는 지그재그 길 넷이 원천에서 떨어지며 모퉁이에 i^R 의 네 색 점을 찍어요. 그 밑에는 모든 길을 더한 장이 위상은 색, 크기는 밝기로 빛나고, 금빛 평균 위치가 지터베베궁으로 좌우로 떨려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-feynman-checkerboard","type":"code","name":"feynman-checkerboard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mass=0.08..0.4, Focus=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mass","min":0.08,"max":0.4},{"name":"Focus","min":0,"max":1}],"start":[0,2,0.08,0.06],"measures":{"motion":0.1065,"detail":0.0504,"edges":0.6165,"complexity":2.4819,"coverage":0.9591,"colour":0.2856,"drift":0.1064},"knobResponse":[0.2331,0.0766,0.181,0.1347]},{"slug":"fibonacci-word","title":"Fibonacci Word","family":"fractal","round":68,"note":"피보나치 단어 0100101001001… 을 한 자씩 읽는 펜이 0 마다 직각으로 꺾어, 희미한 띠에 놓인 굵은 곡선 위에 정사각형 속 정사각형 곡선을 그리고, 첫 토막으로 1+√2 배 들어가면 그 토막이 다시 전체가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fibonacci-word","type":"code","name":"fibonacci-word","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=12..15, Angle=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":12,"max":15},{"name":"Angle","min":-1,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.5413,"detail":0.0567,"edges":0.8662,"complexity":0.2611,"coverage":0.2103,"colour":0.167,"drift":0.0933},"knobResponse":[0.0611,0.0519,0.121,0.1242]},{"slug":"fiddlehead","title":"Fiddlehead","family":"growth","round":21,"note":"봄 숲 바닥의 타임랩스예요. 털 덮인 고사리 순이 지난해 낙엽을 뚫고 올라와 아래부터 풀리며 패널 꼭대기에서 휘는 잎이 되고, 그사이 늙은 잎은 누렇게 시들어 쓰러지고 숲 지붕 틈으로 든 빛살이 그 위를 미끄러져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-fiddlehead","type":"code","name":"fiddlehead","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fern=0..3, Speed=0.2..3, Fronds=6..18, Breeze=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fern","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Fronds","min":6,"max":18},{"name":"Breeze","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2772,"detail":0.0937,"edges":0.4428,"complexity":2.2973,"coverage":0.9858,"colour":0.1938,"drift":0.0784},"knobResponse":[0.0694,0.0969,0.0478,0.0882]},{"slug":"fifteen-puzzle","title":"Fifteen Puzzle","family":"type","round":77,"note":"위아래 두 15 퍼즐이 같은 밀기를 같은 순간에 받아, 위 판은 1~15 로 풀리고 14 와 15 를 바꿔 놓고 시작한 아래 판은 15, 14 에서 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fifteen-puzzle","type":"code","name":"fifteen-puzzle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scramble=0..1, Swap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scramble","min":0,"max":1},{"name":"Swap","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3613,"detail":0.1135,"edges":0.85,"complexity":0.0988,"coverage":0.7033,"colour":0.2261,"drift":0.1417},"knobResponse":[0.2027,0.1237,0.1712,0.0532]},{"slug":"figure-eight-orbit","title":"Figure-Eight Orbit","family":"physics","round":38,"note":"같은 질량 셋이 뉴턴 중력으로 패널 높이만 한 8자 하나를 3분의 1주기씩 떨어져 돌아요. 식으로 그린 곡선이 아니라 한 걸음씩 푼 궤도라서, K4 로 처음 속도를 밀면 8자가 흔들리다가 더 밀면 둘이 짝을 짓고 하나가 패널 밖으로 튕겨 나가요. K3 은 꼬리를 늘려 세 혜성을 겹친 8자 띠로 바꾸고, K1 을 누르면 도는 궤도를 살짝 밀어요.","why":"빛나는 공 셋이 8자 궤도를 돌아요. 0529, 0701 처럼 선 하나와 점 몇 개가 전부예요.","block":0,"ramped":false,"layer":{"id":"layer-figure-eight-orbit","type":"code","name":"figure-eight-orbit","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Trail=0.33..2, Kick=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Trail","min":0.33,"max":2},{"name":"Kick","min":0,"max":1}],"start":[0,2,0.33,0.06],"measures":{"motion":0.2677,"detail":0.0329,"edges":0.6811,"complexity":0.5694,"coverage":0.1522,"colour":0.2009,"drift":0.1349},"knobResponse":[0.0772,0.0891,0.0607,0.1032]},{"slug":"final-approach","title":"Final Approach","family":"flight","round":23,"note":"밤에 내려앉는 여객기 조종석에서 앞을 봐요. 활주로 등과 진입등이 도시 불빛이 깔린 지평선 아래로 모이고, 래빗 섬광등이 1초에 두 번 활주로 쪽으로 달려가요. 왼쪽 PAPI 가 흰 둘 빨강 둘을 보이다가, 플레어와 접지 뒤에는 중심선 등이 발밑으로 쏟아져 지나가요. K1 을 누르면 복행해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-final-approach","type":"code","name":"final-approach","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Weather=0..3, Crosswind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Weather","min":0,"max":3},{"name":"Crosswind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.2895,"detail":0.0365,"edges":0.3949,"complexity":1.2312,"coverage":0.4908,"colour":0.0984,"drift":0.1085},"knobResponse":[0.0373,0.0632,0.3041,0.0884]},{"slug":"fire","title":"Fire","family":"sim","round":1,"note":"데모신의 불이에요. 바닥의 열이 올라가며 식고, K1 을 돌리면 나무 불에서 가스 불, 붕소 불까지 색이 바뀌어요.","why":"패널에서 잘 읽히지만 불꽃은 데모의 단골이에요.","block":1,"ramped":false,"layer":{"id":"layer-fire","type":"code","name":"fire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Height=0.6..4, Wind=-1..1, Crackle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Height","min":0.6,"max":4},{"name":"Wind","min":-1,"max":1},{"name":"Crackle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9647,"detail":0.0218,"edges":0.1201,"complexity":0.8283,"coverage":0.5059,"colour":0.4964,"drift":0.2161},"knobResponse":[0.3207,0.2786,0.0846,0.0537]},{"slug":"fireflies","title":"Fireflies","family":"insect","round":16,"note":"풀밭 위 반딧불이 200마리가 따로 깜박이다가 서로의 깜박임을 보고 박자를 맞춰, 한꺼번에 깜박이는 무리와 어두운 쉼이 번갈아 와요. K4 가 결합의 세기이고, K1 을 누르면 손전등이 지나가며 박자를 흩어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-fireflies","type":"code","name":"fireflies","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Moon=0..1, Pace=0.5..4, Fireflies=200..480, Coupling=0..0.25","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Moon","min":0,"max":1},{"name":"Pace","min":0.5,"max":4},{"name":"Fireflies","min":200,"max":480},{"name":"Coupling","min":0,"max":0.25}],"start":[0,2,200,0.06],"measures":{"motion":0.3823,"detail":0.021,"edges":0.1814,"complexity":0.404,"coverage":0.3382,"colour":0.0994,"drift":0.0945},"knobResponse":[0.0808,0.0516,0.0623,0.0425]},{"slug":"flag-hoist","title":"Flag Hoist","family":"type","round":74,"note":"국제 신호서의 글자 깃발로 쓴 낱말이 왼쪽 가장자리의 깃줄에 한 장씩 아래로 매달려 밤하늘로 끌려 올라가고, 바람에 펄럭이는 동안 깃발 옆에 그 글자가 섰다가 내려가면 다음 낱말이 올라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-flag-hoist","type":"code","name":"flag-hoist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wind=3..8, Speed=0.2..3, Letters=3..6, Sky=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wind","min":3,"max":8},{"name":"Speed","min":0.2,"max":3},{"name":"Letters","min":3,"max":6},{"name":"Sky","min":0,"max":1}],"start":[3,2,3,0.06],"measures":{"motion":0.4925,"detail":0.0446,"edges":0.5633,"complexity":0.2165,"coverage":0.4929,"colour":0.5773,"drift":0.2045},"knobResponse":[0.0527,0.2307,0.2153,0.1566]},{"slug":"flame-test","title":"Flame Test","family":"chemistry","round":22,"note":"분젠 버너의 파란 불꽃에 손이 니크롬 고리를 넣으면 불꽃이 그 염의 색으로 터져요. 구리는 청록, 나트륨은 짙은 노랑으로 타고 알갱이가 튀다가 파랗게 돌아오면, 고리를 염산에 씻어 이름표 붙은 다음 시계접시로 가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flame-test","type":"code","name":"flame-test","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Salt=0..8, Speed=0.2..3, Room=0..1, Air=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Salt","min":0,"max":8},{"name":"Speed","min":0.2,"max":3},{"name":"Room","min":0,"max":1},{"name":"Air","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0593,"detail":0.0588,"edges":0.4458,"complexity":1.5027,"coverage":0.9519,"colour":0.1298,"drift":0.0434},"knobResponse":[0.0735,0.0457,0.2666,0.1163]},{"slug":"flashing-ratchet","title":"Flashing Ratchet","family":"sim","round":48,"note":"여덟 칸 톱니 퍼텐셜이 켜졌다 꺼질 때마다 브라운 입자 3000개가 빛나는 선으로 모였다 안개로 퍼지고, 금빛 표지 구름이 켜 두기만 해도 꺼 두기만 해도 지는 아래쪽 짐을 거슬러 올라가요. K3 은 꺼졌다 켜지는 주기, K4 는 짐이고, K1 을 누르면 깜빡이기와 켜 두기, 꺼 두기를 차례로 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-flashing-ratchet","type":"code","name":"flashing-ratchet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Period=0.8..3.2, Load=0.25..1.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Period","min":0.8,"max":3.2},{"name":"Load","min":0.25,"max":1.5}],"start":[0,2,0.8,0.25],"measures":{"motion":2.0192,"detail":0.0449,"edges":0.0319,"complexity":1.4118,"coverage":0.9216,"colour":0.1633,"drift":0.1337},"knobResponse":[0.1421,0.1086,0.1193,0.0659]},{"slug":"flip-clock","title":"Flip Clock","family":"time","round":2,"note":"세워 둔 넘김 시계예요. 위에 시, 아래에 분 카드가 있고, 바뀔 때마다 옛 카드의 윗장이 앞으로 넘어가 그 뒷면이 새 카드의 아랫장으로 내려앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flip-clock","type":"code","name":"flip-clock","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Rate=0..3, Seconds=0..1, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Rate","min":0,"max":3},{"name":"Seconds","min":0,"max":1},{"name":"Light","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0975,"detail":0.0443,"edges":0.7774,"complexity":0.213,"coverage":0.7633,"colour":0.1458,"drift":0.128},"knobResponse":[0.0983,0.1045,0.1894,0.032]},{"slug":"flipdot","title":"Flipdot","family":"type","round":22,"note":"버스 앞에 다는 형광 노랑 플립 디스크 행선판을 세워 놓았어요. 위 칸에 노선 번호, 아래 칸에 행선지가 7줄 점 글꼴로 서고, 쪽이 바뀔 때마다 디스크가 한 줄씩 넘어가며 판 전체를 노랗게 뒤집었다가 반전된 경유지 쪽을 써요. 넘어가는 동안의 디스크는 가는 모서리로 보여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flipdot","type":"code","name":"flipdot","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Disc=0..1, Speed=0.2..3, Route=0..3, Wipe=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Disc","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Route","min":0,"max":3},{"name":"Wipe","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1111,"detail":0.2452,"edges":0.47,"complexity":0.3774,"coverage":0.3252,"colour":0.3924,"drift":0.2652},"knobResponse":[0.0968,0.1699,0.0516,0.048]},{"slug":"floating-letters","title":"Floating Letters","family":"type","round":78,"note":"한 판에서 오린 글자가 물에 떨어져 출렁이다가 저마다 무게 중심과 부력 중심이 한 줄에 서는 각에 앉고, 위의 곡선에서 점이 에너지 골짜기로 굴러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-floating-letters","type":"code","name":"floating-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=0.2..0.8, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":0.2,"max":0.8},{"name":"Swell","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.0511,"detail":0.0365,"edges":0.7713,"complexity":0.25,"coverage":0.5905,"colour":0.1882,"drift":0.0253},"knobResponse":[0.1028,0.0652,0.0626,0.0425]},{"slug":"flock","title":"Flock","family":"particle","round":1,"note":"새 90마리가 가까운 이웃만 보고 날아요. 보이지 않는 매가 무리를 쫓아 자꾸 갈라놓아요.","why":"새 떼가 점 크기라 멀리서 안 보여요.","block":1,"ramped":false,"layer":{"id":"layer-flock","type":"code","name":"flock","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.5..4, Scatter=-1..1, Trail=0.3..2.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.5,"max":4},{"name":"Scatter","min":-1,"max":1},{"name":"Trail","min":0.3,"max":2.5}],"start":[0,2,0,0.3],"measures":{"motion":0.7954,"detail":0.0794,"edges":0.4039,"complexity":1.2562,"coverage":0.2957,"colour":0.1808,"drift":0.1151},"knobResponse":[0.0754,0.1076,0.0932,0.1053]},{"slug":"fluoroscope","title":"Fluoroscope","family":"body","round":27,"note":"형광 투시 화면의 어두운 판 위에서 해골이 러닝머신을 옆모습으로 걸어요. 정수리에서 발가락까지 128줄을 다 쓰고, 먼 쪽 다리와 팔은 흐리며 움직이는 뼈 뒤에 인광이 잠깐 남아요. K3 은 걸음을 두 발이 뜨는 달리기로 바꾸고, 누르면 돌아서서 앞모습으로 손을 흔들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-fluoroscope","type":"code","name":"fluoroscope","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Screen=0..1, Speed=0.2..3, Gait=0..1, Dose=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Screen","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gait","min":0,"max":1},{"name":"Dose","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.988,"detail":0.0374,"edges":0.3589,"complexity":1.506,"coverage":0.2562,"colour":0.1011,"drift":0.06},"knobResponse":[0.0534,0.0544,0.0908,0.0578]},{"slug":"flying-trapeze","title":"Flying Trapeze","family":"stage","round":24,"note":"밤의 서커스 천막 꼭대기를 올려다봐요. 빨강과 크림 줄무늬 천 아래에서 플라이어가 공중그네를 타고 나가 공중제비를 돌고, 무릎으로 매달린 캐처가 손을 잡아요. 팔로 스폿 셋이 연무 속에 빛줄기를 그으며 따라가고, 차례가 끝나면 그물로 떨어져 튀어 올라요. K1 을 누르면 북이 울리고 세 바퀴 공중제비가 나와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-flying-trapeze","type":"code","name":"flying-trapeze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lights=0..1, Speed=0.2..3, Turns=1..3, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lights","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":1,"max":3},{"name":"Haze","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3174,"detail":0.0396,"edges":0.2107,"complexity":1.4663,"coverage":0.506,"colour":0.1821,"drift":0.1332},"knobResponse":[0.0514,0.1017,0.0609,0.161]},{"slug":"foam-coarsening","title":"Foam Coarsening","family":"cells","round":65,"note":"2차원 거품이 굵어지며 여섯 변보다 적은 칸은 줄어 사라지고 많은 칸은 자라요. 칸을 변의 수로 칠해서 폰 노이만의 n − 6 법칙이 색으로 보여요","why":"","block":0,"ramped":false,"layer":{"id":"layer-foam-coarsening","type":"code","name":"foam-coarsening","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3552,"detail":0.343,"edges":0.999,"complexity":0.3137,"coverage":0.6304,"colour":0.6276,"drift":0.0997},"knobResponse":[0.3696,0.3043,0.4038,0.35]},{"slug":"foam-lather","title":"Foam Lather","family":"cosmetic","round":31,"note":"거품 클렌저를 낸 거품 사백 개가 패널을 채우고, 작은 거품은 줄어 사라지고 벽이 터지며 둘이 합쳐져요. 위로 갈수록 마른 벌집이 되고 아래는 물기 머금은 둥근 거품이에요. K1 은 색상환을 다 돌고, 누르면 아래에서 고운 거품을 새로 쳐 올려요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-foam-lather","type":"code","name":"foam-lather","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Wetness=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Wetness","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1524,"detail":0.0833,"edges":0.3017,"complexity":2.5679,"coverage":1,"colour":0.1471,"drift":0.0328},"knobResponse":[0.1783,0.2037,0.1967,0.1202]},{"slug":"fogged-mirror","title":"Fogged Mirror","family":"halloween","round":45,"note":"촛불 하나가 밝힌 방의 긴 타원 거울에 입김이 테두리부터 번져 뿌옇게 덮이면, 보이지 않는 손가락이 거울 안쪽에서 BOO 나 이가 너무 많은 웃는 얼굴을 한 획씩 써요. 획마다 검은 유리가 드러나고 물방울이 줄을 그으며 흘러내리다가, 안개가 걷히면 내 뒤에 선 마른 형체가 1초 남짓 비치고 사라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fogged-mirror","type":"code","name":"fogged-mirror","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fog=0..1, Drips=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fog","min":0,"max":1},{"name":"Drips","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1202,"detail":0.0275,"edges":0.4164,"complexity":0.4171,"coverage":0.9271,"colour":0.208,"drift":0.2105},"knobResponse":[0.0521,0.0584,0.079,0.0692]},{"slug":"force-chains","title":"Force Chains","family":"particle","round":52,"note":"교차한 편광판 사이에 세운 원판 175개를 위의 피스톤과 양옆 벽이 번갈아 누르면, 하중을 지는 원판만 회색에서 흰색과 노랑을 지나 빨강과 파랑으로 물든 등색선을 띠고 갈라지는 사슬로 이어져서, 미는 쪽이 바뀔 때마다 위아래에서 옆으로 길을 바꿔요. K3 은 누르는 힘, K4 는 원판 크기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-force-chains","type":"code","name":"force-chains","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Analyser=0..1, Speed=0.2..3, Load=-1..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Analyser","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Load","min":-1,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5359,"detail":0.1998,"edges":0.5849,"complexity":2.4049,"coverage":0.6696,"colour":0.2157,"drift":0.0976},"knobResponse":[0.3352,0.272,0.2863,0.3662]},{"slug":"ford-circles","title":"Ford Circles","family":"number","round":28,"note":"세운 왼쪽 가장자리가 실수선이고, 분수 p/q 마다 반지름 1/(2q²) 인 원이 그 자리에 기대 서요. 화면은 황금비로 끝없이 들어가고, 맞닿은 두 원 사이의 중간수 자리에 더 작은 원이 자꾸 나와요. K3 이 과녁을 √2, √3, e, π 로 바꾸고, 누르면 스턴-브로코 나무를 따라 과녁까지 내려가는 길이 켜져요.","why":"원이 겹겹이라 패널이 꽉 차요(채움 0.80).","block":1,"ramped":false,"layer":{"id":"layer-ford-circles","type":"code","name":"ford-circles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Target=0..4, Fill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Target","min":0,"max":4},{"name":"Fill","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6649,"detail":0.0489,"edges":0.4057,"complexity":1.3917,"coverage":0.8005,"colour":0.1799,"drift":0.1998},"knobResponse":[0.1431,0.2105,0.195,0.7368]},{"slug":"fork-hologram","title":"Fork Hologram","family":"wave","round":82,"note":"위상이 감긴 소용돌이 열 개쯤이 떠다니는 빛과 비스듬한 평면파가 만든 가는 세로 줄무늬에서, 소용돌이마다 줄이 전하보다 하나 많은 갈래로 갈라지고, 반대 전하끼리 만나면 갈래가 합쳐지거나 사라졌다가 새 쌍으로 다시 생겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fork-hologram","type":"code","name":"fork-hologram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Charge=3..7, Carrier=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Charge","min":3,"max":7},{"name":"Carrier","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2929,"detail":0.3261,"edges":0.4139,"complexity":2.5971,"coverage":0.7608,"colour":0.2517,"drift":0.0262},"knobResponse":[0.1836,0.5134,0.3631,0.3477]},{"slug":"fortune-sweep","title":"Fortune's Sweep","family":"algo","round":37,"note":"금색 쓸기 선이 1초에 22줄씩 내려가고, 선 위로 포천의 해변선이 지나간 자리부터 보로노이 그림이 확정돼요. 해변선은 사이트 하나에 포물선 호 하나씩 이어진 목걸이라서, 선이 사이트를 지나면 호가 가시처럼 돋고 세 사이트를 지나는 빈 원이 선에 닿으면 가운데 호가 사라지며 꼭짓점이 금색 점으로 남아요. 지난 그림은 40% 밝기로 아래에서 기다려요. K4 는 가중치를 걸어 모서리를 쌍곡선으로 휘고, 누르면 새 사이트로 바로 다시 쓸어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-fortune-sweep","type":"code","name":"fortune-sweep","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sites=16..48, Weights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sites","min":16,"max":48},{"name":"Weights","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.3617,"detail":0.032,"edges":0.4248,"complexity":0.6651,"coverage":1,"colour":0.1845,"drift":0.1987},"knobResponse":[0.2392,0.1674,0.1095,0.0757]},{"slug":"four-vertex","title":"Four-Vertex Theorem","family":"line","round":53,"note":"세로로 선 매끈한 닫힌 곡선이 천천히 모양을 바꾸면, 곡률 중심이 그리는 축폐선이 그 안에서 금빛 별로 돌고, 별의 첨점은 곡률이 가장 크거나 작은 흰 꼭짓점과 점선으로 이어져 둘씩 태어나고 사라져도 넷 아래로는 줄지 않아요. K3 은 반지름을 휘는 물결의 수, K4 는 곡선이 오목하게 패이는 정도이고, 단추를 누르면 다음 물결이 잠깐 부풀어 제비꼬리가 한꺼번에 열렸다 닫혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-four-vertex","type":"code","name":"four-vertex","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Terms=2..6, Bend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Terms","min":2,"max":6},{"name":"Bend","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.3612,"detail":0.065,"edges":0.7134,"complexity":0.5747,"coverage":0.2289,"colour":0.1611,"drift":0.0493},"knobResponse":[0.0544,0.0726,0.079,0.1237]},{"slug":"fox-colorings","title":"Fox Colorings","family":"topology","round":78,"note":"패널 높이의 닫힌 땋기로 세운 매듭의 호마다 mod p 이름을 붙여, 교차마다 위 호의 두 배가 아래 두 호의 합이 되는 색칠을 하나씩 걸어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fox-colorings","type":"code","name":"fox-colorings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knot=0..1, Prime=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knot","min":0,"max":1},{"name":"Prime","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1168,"detail":0.0669,"edges":0.6766,"complexity":0.5269,"coverage":0.2169,"colour":0.2577,"drift":0.1236},"knobResponse":[0.1074,0.0695,0.2175,0.0529]},{"slug":"foxfire","title":"Foxfire","family":"fungi","round":19,"note":"밤 숲 바닥 단면에서 뽕나무버섯 균사가 그루터기와 통나무, 흙 속을 기어가며 갈라지고 실을 따라 연둣빛 펄스가 흘러요. 버섯 무리가 돋았다 시들며 숨 쉬듯 빛나고 포자가 위로 떠올라요. K1 을 누르면 피어 있는 갓이 한꺼번에 포자를 뿜어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-foxfire","type":"code","name":"foxfire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Spores=0..1, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spores","min":0,"max":1},{"name":"Damp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0552,"detail":0.062,"edges":0.4422,"complexity":2.0011,"coverage":0.1963,"colour":0.1249,"drift":0.0326},"knobResponse":[0.0328,0.0383,0.0467,0.0368]},{"slug":"fput-recurrence","title":"FPUT Recurrence","family":"physics","round":42,"note":"1955년의 질량 31개짜리 사슬이 위아래로 걸린 줄처럼 떨어요. 처음엔 에너지가 다 1번 모드에 있어 자홍 렌즈 하나로 보이다가, 높은 모드로 번지면서 마디가 늘어난 제 색 고리들이 차례로 부풀고, 31초 뒤 147번 흔들린 끝에 98% 가 1번 모드로 돌아와요. K4 를 0 으로 내리면 선형 사슬이 되어 렌즈가 끝내 그대로예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fput-recurrence","type":"code","name":"fput-recurrence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Amplitude=1..1.9, Alpha=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Amplitude","min":1,"max":1.9},{"name":"Alpha","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.0874,"detail":0.0555,"edges":0.8174,"complexity":0.1527,"coverage":0.4112,"colour":0.2328,"drift":0.1726},"knobResponse":[0.0868,0.1144,0.0646,0.2031]},{"slug":"fractal-percolation","title":"Fractal Percolation","family":"fractal","round":48,"note":"위아래로 쌓인 두 정사각형이 넷으로 쪼개질 때마다 조각이 확률 p 로 남고 나머지는 꺼지기를 낱 LED 까지 되풀이하고, 아래 줄에서 오른 빛이 위 줄에 닿으면 판을 건너는 덩어리가 민트로 켜진 뒤 남은 정사각형 한 쌍으로 두 배 확대해 들어가요. K3 이 p 이고, K1 을 누르면 구멍을 닫고 새로 깎아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fractal-percolation","type":"code","name":"fractal-percolation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Keep=0.88..0.99, Levels=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Keep","min":0.88,"max":0.99},{"name":"Levels","min":0,"max":1}],"start":[0,2,0.88,0.06],"measures":{"motion":1.1042,"detail":0.1052,"edges":0.9252,"complexity":0.1809,"coverage":0.7671,"colour":0.2486,"drift":0.2995},"knobResponse":[0.1604,0.1785,0.1179,0.1183]},{"slug":"fractran","title":"FRACTRAN","family":"number","round":75,"note":"콘웨이의 PRIMEGAME 이 2, 3, 5, 7 의 지수를 구슬 기둥으로 오르내리며 분수 열넷 가운데 맞는 첫 분수를 밝히고, n 이 2 의 거듭제곱이 될 때마다 2 기둥에 구슬 p 개만 남긴 채 소수 p 를 맨 위에 적어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-fractran","type":"code","name":"fractran","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Start=0..3, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Start","min":0,"max":3},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.5136,"detail":0.0898,"edges":0.6742,"complexity":0.4175,"coverage":0.2767,"colour":0.1316,"drift":0.1231},"knobResponse":[0.0531,0.0903,0.1132,0.0542]},{"slug":"franklin-involution","title":"Franklin's Involution","family":"number","round":78,"note":"서로 다른 부분의 분할이 가장 작은 줄과 비탈을 맞바꿔 짝을 찾아 아래로 날아가고, 오각수에서만 계단 사다리꼴 하나가 홀로 남아 ±1 을 받아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-franklin-involution","type":"code","name":"franklin-involution","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, N=5..16, Gap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"N","min":5,"max":16},{"name":"Gap","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.4172,"detail":0.0431,"edges":0.6909,"complexity":0.0737,"coverage":0.3132,"colour":0.3305,"drift":0.1854},"knobResponse":[0.1363,0.1625,0.1208,0.0849]},{"slug":"frenkel-kontorova","title":"Frenkel-Kontorova","family":"sim","round":70,"note":"우물 12개가 두른 바닥 위 용수철 사슬에 공이 남거나 모자라 생긴 꼬임이 미는 힘에 고리를 돌고, 위 113줄 기록에서 꼬임은 비스듬한 자홍 띠로, 크림색 공의 세계선은 띠마다 한 우물씩 비켜 가는 계단으로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-frenkel-kontorova","type":"code","name":"frenkel-kontorova","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Drive=0..3, Misfit=0.86..1.2, Substrate=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Drive","min":0,"max":3},{"name":"Misfit","min":0.86,"max":1.2},{"name":"Substrate","min":1,"max":4}],"start":[0,2,0.86,1],"measures":{"motion":0.9856,"detail":0.1251,"edges":0.5212,"complexity":1.7026,"coverage":0.4943,"colour":0.1728,"drift":0.0379},"knobResponse":[0.0854,0.1755,0.1885,0.1467]},{"slug":"frieze-letters","title":"Frieze Letters","family":"type","round":76,"note":"글자 b 하나로 짠 띠 무늬 일곱 군이 콘웨이의 이름 차례로 세로로 서고, 띠마다 박자에 맞춰 제 대칭인 미끄럼, 접기, 반 바퀴를 해 보이고 제자리로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-frieze-letters","type":"code","name":"frieze-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Glyph=0..1, Marks=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Glyph","min":0,"max":1},{"name":"Marks","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.418,"detail":0.2076,"edges":0.9971,"complexity":0.0765,"coverage":0.2249,"colour":0.2875,"drift":0.1112},"knobResponse":[0.1119,0.1462,0.1961,0.0538]},{"slug":"frost","title":"Frost","family":"fractal","round":17,"note":"밤 유리창에 서리 고사리가 아래 틀과 창틀에서 자라 들어와요. 가지는 대각선으로 곧게 뻗어 깃털처럼 곁가지를 내며 반짝이고, 유리 너머로 가로등과 눈발이 흐리게 비치다가 방이 데워지면 가운데부터 녹아 다시 자라요. K1 을 누르면 입김이 가운데를 닦아요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-frost","type":"code","name":"frost","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Rime=0..1, Glitter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rime","min":0,"max":1},{"name":"Glitter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0377,"detail":0.1373,"edges":0.4636,"complexity":2.383,"coverage":0.4303,"colour":0.1004,"drift":0.0382},"knobResponse":[0.0509,0.1276,0.1564,0.0602]},{"slug":"funicular","title":"Funicular","family":"rail","round":27,"note":"해 질 녘 산비탈에서 계단꼴 객차 둘이 케이블 하나에 매달려 오르내려요. 호숫가 마을의 역을 떠난 빨간 객차가 오르는 동안 꼭대기 기관실의 큰 바퀴가 돌며 파란 객차가 내려오고, 둘은 중턱의 압트 교행 구간에서 갈라진 선로로 비켜 지나가요. K1 을 끝까지 돌리면 창이 켜진 밤이 되고, 누르면 객차가 바로 떠나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-funicular","type":"code","name":"funicular","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Grade=0..1, Snow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grade","min":0,"max":1},{"name":"Snow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0963,"detail":0.0901,"edges":0.4693,"complexity":1.617,"coverage":0.9811,"colour":0.2158,"drift":0.0259},"knobResponse":[0.2342,0.0427,0.0962,0.1569]},{"slug":"galilean-moons","title":"Galilean Moons","family":"celestial","round":22,"note":"목성의 네 위성을 관측 도표로 그려요. 위쪽 접안렌즈에서는 줄무늬 목성이 돌고 이오의 그림자가 원반을 지나가며, 아래 도표에서는 위성마다 제 사인 곡선을 그리며 날짜가 위로 올라와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-galilean-moons","type":"code","name":"galilean-moons","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sky=0..1, Speed=0.5..24, Power=0..1, Seeing=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sky","min":0,"max":1},{"name":"Speed","min":0.5,"max":24},{"name":"Power","min":0,"max":1},{"name":"Seeing","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0779,"detail":0.0747,"edges":0.5632,"complexity":0.743,"coverage":0.7778,"colour":0.1926,"drift":0.0306},"knobResponse":[0.5122,0.1178,0.1493,0.0539]},{"slug":"galileos-frets","title":"Galileo's Frets","family":"rhythm","round":78,"note":"세 홈에서 공이 함께 굴러 내려가고, 프렛이 제곱수 자리에 놓인 가운데 홈만 고른 박으로 덜컥여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-galileos-frets","type":"code","name":"galileos-frets","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Law=1..3, Frets=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Law","min":1,"max":3},{"name":"Frets","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2342,"detail":0.0637,"edges":0.8331,"complexity":0.0999,"coverage":0.4752,"colour":0.2688,"drift":0.1073},"knobResponse":[0.1471,0.0584,0.0419,0.0797]},{"slug":"galperin-billiard","title":"Galperin Billiard","family":"physics","round":57,"note":"무거운 블록이 레일을 내려와 바닥 벽 위의 가벼운 블록에 부딪히고, 블록끼리든 벽이든 부딪힐 때마다 셈판에 점이 하나씩 켜져서 질량비 100, 10,000, 1,000,000 에서 31, 314, 3141 로 읽혀요. 위의 에너지 원에서는 두 속도가 한 점이 되어 부딪힐 때마다 현을 하나씩 그으며 원의 왼쪽 끝에서 오른쪽 끝까지 지그재그로 원판을 쓸고, 각 arctan √(m/M) 의 쐐기에 들어가면 멈춰요. K3 은 자릿수 k(1~3), K4 는 몰린 부딪힘을 늘려 보여 주는 슬로 모션 초(0~8)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-galperin-billiard","type":"code","name":"galperin-billiard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Digits=1..3, Warp=0..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Digits","min":1,"max":3},{"name":"Warp","min":0,"max":8}],"start":[0,2,1,0.06],"measures":{"motion":0.151,"detail":0.0347,"edges":0.5009,"complexity":0.3385,"coverage":0.249,"colour":0.1861,"drift":0.2355},"knobResponse":[0.0674,0.1434,0.2269,0.1456]},{"slug":"galton","title":"Galton Board","family":"data","round":2,"note":"깔때기에서 떨어진 공이 못마다 동전 던지듯 왼쪽이나 오른쪽으로 튀어 칸에 쌓이고, 종 모양이 서요. 칸 색은 가운데에서 표준편차 몇 개만큼 떨어졌는지를 보여 줘요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-galton","type":"code","name":"galton","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rate=30..240, Bias=-0.3..0.3, Rows=8..15","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rate","min":30,"max":240},{"name":"Bias","min":-0.3,"max":0.3},{"name":"Rows","min":8,"max":15}],"start":[0,30,0,8],"measures":{"motion":0.2909,"detail":0.0577,"edges":0.7232,"complexity":0.5234,"coverage":0.2361,"colour":0.1843,"drift":0.0246},"knobResponse":[0.0536,0.0477,0.0979,0.0715]},{"slug":"gargoyle","title":"Gargoyle","family":"halloween","round":49,"note":"폭풍 속 성당 처마의 가고일이 입으로 물줄기를 패널 아래 웅덩이까지 쏟고, 번개가 칠 때마다 검게 드러났다가 눈에 독한 초록 불이 켜져요. K3 은 비, K4 는 번개가 치는 잦기이고, 단추를 누르면 바로 번개가 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gargoyle","type":"code","name":"gargoyle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Lightning=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rain","min":0,"max":1},{"name":"Lightning","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9825,"detail":0.0606,"edges":0.4454,"complexity":0.4401,"coverage":0.936,"colour":0.1221,"drift":0.2038},"knobResponse":[0.0799,0.0531,0.0669,0.0851]},{"slug":"gaussian-free-field","title":"Gaussian Free Field","family":"noise","round":52,"note":"패널의 격자점마다 가우스 무작위 높이를 둔 자유장이 0 위는 주황 땅, 0 아래는 보라 바다로 칠해지고, 흰 해안선이 섬 안의 호수와 호수 안의 섬으로 겹겹이 닫힌 고리가 되어 1~2초마다 지도를 새로 그려요. K3 을 올리면 테두리 왼쪽과 오른쪽의 높이가 갈려 바닥에서 꼭대기까지 오르는 해안선 하나, SLE(4) 곡선이 서고, K4 는 해안선 아래 흐림의 폭이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gaussian-free-field","type":"code","name":"gaussian-free-field","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Boundary=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Boundary","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4085,"detail":0.0882,"edges":0.349,"complexity":2.2565,"coverage":0.9674,"colour":0.466,"drift":0.3687},"knobResponse":[0.296,0.3457,0.2297,0.1853]},{"slug":"gaussian-moat","title":"Gaussian Moat","family":"number","round":31,"note":"LED 하나가 가우스 정수 하나라 가우스 소수가 옅은 점으로 깔리고, 1 + i 에서 걸음 √k 안의 소수로만 번지는 물길이 산호처럼 가지를 쳐요. 물길이 해자에 막히면 기슭이 깜박이고 k 가 커져 건너가요. K1 을 누르면 k 를 바로 한 칸 올려요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-gaussian-moat","type":"code","name":"gaussian-moat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Step=1.5..4.5, Reach=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Step","min":1.5,"max":4.5},{"name":"Reach","min":0,"max":1}],"start":[0,2,1.5,0.06],"measures":{"motion":0.0332,"detail":0.138,"edges":0.7904,"complexity":0.3035,"coverage":0.2952,"colour":0.1811,"drift":0.1107},"knobResponse":[0.0371,0.0267,0.0437,0.056]},{"slug":"gaussian-periods","title":"Gaussian Periods","family":"number","round":53,"note":"k 를 n 으로 나눈 나머지마다 LED 하나가 가우스 주기 η(k) 자리에 켜져서, 열한 개의 돌린 델토이드가 k mod 11 로 물든 점의 햇살로 서요. 점마다 η(uk) 로 미끄러지면 햇살이 흩어졌다가 같은 점 집합으로 다시 서고, 조각들의 색만 서로 바뀌어요. K3 은 (n, ω) 여덟 그림이고, K4 는 곱하는 단위 u 예요. 0 은 색 무리를 섞고, 1 은 무리를 제자리에 두어 조각마다 저 혼자 다시 서고, 2 는 조각을 통째로 돌려요. 단추를 누르면 다음 그림으로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gaussian-periods","type":"code","name":"gaussian-periods","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Figure=0..7, Unit=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Figure","min":0,"max":7},{"name":"Unit","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":4.9103,"detail":0.3241,"edges":1,"complexity":0.385,"coverage":0.3067,"colour":0.4274,"drift":0.1045},"knobResponse":[0.1965,0.2562,0.2353,0.2055]},{"slug":"gaussian-zeros","title":"Gaussian Zeros","family":"noise","round":77,"note":"가우스 해석 함수의 영점이 위 절반에 색상환을 두른 검은 점으로 고르게 떠다니고, 아래 절반의 같은 밀도 푸아송 점은 뭉쳐서 검은 구멍을 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gaussian-zeros","type":"code","name":"gaussian-zeros","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=0..1, Focus=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":0,"max":1},{"name":"Focus","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3263,"detail":0.1184,"edges":0.4357,"complexity":2.5673,"coverage":0.9761,"colour":0.3537,"drift":0.1284},"knobResponse":[0.2224,0.2717,0.2936,0.3132]},{"slug":"gear-train","title":"Gear Train","family":"machine","round":8,"note":"패널 발치의 크랭크가 색 톱니바퀴를 돌려요. 바퀴마다 아래 바퀴와 톱니를 맞물려 꼭대기까지 이어지고, 작은 바퀴일수록 빨리 돌아요. K4 를 올리면 모든 바퀴가 톱니 하나씩 딸깍 걸려 나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-gear-train","type":"code","name":"gear-train","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gears=4..9, Tick=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gears","min":4,"max":9},{"name":"Tick","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.8362,"detail":0.0922,"edges":0.4218,"complexity":1.1517,"coverage":0.8876,"colour":0.5762,"drift":0.1048},"knobResponse":[0.3786,0.1249,0.2931,0.0655]},{"slug":"geyser","title":"Geyser","family":"volcano","round":26,"note":"눈 덮인 지열 지대의 간헐천을 땅속까지 잘라 봐요. 화도에 기포가 차면 청록 웅덩이가 유리 돔으로 부풀다 흰 물기둥으로 터지고, 김 구름이 바람에 흘러가요. K1 은 정오에서 오로라 밤까지 빛을 바꾸고, 누르면 바로 분출해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-geyser","type":"code","name":"geyser","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Power=0..1, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Power","min":0,"max":1},{"name":"Wind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1931,"detail":0.0478,"edges":0.2475,"complexity":2.0465,"coverage":1,"colour":0.26,"drift":0.0438},"knobResponse":[0.2681,0.0644,0.048,0.0484]},{"slug":"ghost-ship","title":"Ghost Ship","family":"halloween","round":46,"note":"누더기 돛의 유령선이 너울에 앞뒤로 기울며 안개 속을 떠가고, 초록 등불이 흔들리며 이따금 선체 너머로 달이 비쳐요. K3 은 너울 높이, K4 는 안개이고, K1 을 누르면 안개 속으로 사라졌다 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ghost-ship","type":"code","name":"ghost-ship","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Swell=1..4, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Swell","min":1,"max":4},{"name":"Fog","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3375,"detail":0.0455,"edges":0.3255,"complexity":0.759,"coverage":0.9394,"colour":0.1111,"drift":0.0466},"knobResponse":[0.0323,0.0916,0.0798,0.0664]},{"slug":"giant-component","title":"Giant Component","family":"data","round":60,"note":"점 672개에 무작위 변이 하나씩 더해지며 성분마다 제 색을 입다가, 변이 점 수의 절반을 넘자 크림색 거대 성분이 패널을 덮어요. 아래 그래프는 가장 큰 성분의 몫을 이론 곡선 위에 그리고, Choice 를 올리면 그 곡선이 절벽처럼 솟아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-giant-component","type":"code","name":"giant-component","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Choice=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":-1,"max":1},{"name":"Choice","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2029,"detail":0.2656,"edges":0.9913,"complexity":0.1602,"coverage":0.3826,"colour":0.1542,"drift":0.1443},"knobResponse":[0.0885,0.1217,0.2249,0.0917]},{"slug":"gibbs-phenomenon","title":"Gibbs Phenomenon","family":"wave","round":36,"note":"사각파 한 주기가 가로로 놓이고, 아래로 내려갈수록 푸리에 부분합의 항이 늘어 맨 위 1항에서 맨 아래 32항까지 25줄마다 두 배가 돼요. 합이 파형을 넘어선 곳은 흰 금색으로 타서 점프마다 양옆에 뿔이 서고, 뿔은 아래로 갈수록 점프에 붙지만 높이는 언제나 점프의 8.95% 예요. K3 은 사각파를 톱니파를 거쳐 삼각파로 바꿔 점프와 함께 뿔을 지우고, K1 을 누르면 맨 아래 줄이 256항까지 달리며 그 합의 그래프가 금색 눈금에 닿아요.","why":"아치가 겹친 결이 패널을 채워요(채움 0.87).","block":1,"ramped":false,"layer":{"id":"layer-gibbs-phenomenon","type":"code","name":"gibbs-phenomenon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Fejer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Fejer","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5169,"detail":0.0632,"edges":0.2237,"complexity":1.7176,"coverage":0.871,"colour":0.3287,"drift":0.2332},"knobResponse":[0.1974,0.2792,0.2184,0.2064]},{"slug":"gilbreath-table","title":"Gilbreath Table","family":"number","round":32,"note":"맨 윗줄은 소수 2, 3, 5, 7, …이고, 그 아래 줄마다 윗줄 이웃끼리 뺀 차의 절댓값이 내려와요. 소수 간격이 분홍과 흰빛으로 남은 위 열 줄은 붙박혀 있고, 그 아래는 0 과 2 가 만드는 삼각형 무늬로 표를 따라 내려가요. 왼쪽 끝 금빛 1 의 열은 1만 줄 아래에서도 끊기지 않아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-gilbreath-table","type":"code","name":"gilbreath-table","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=0..1, Zoom=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":0,"max":1},{"name":"Zoom","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5182,"detail":0.0975,"edges":0.6797,"complexity":0.1987,"coverage":0.9794,"colour":0.3745,"drift":0.1585},"knobResponse":[0.3124,0.3276,0.151,0.2734]},{"slug":"gilded-cream","title":"Gilded Cream","family":"cosmetic","round":35,"note":"금박 조각 여섯 개가 든 아이보리 크림을 옆에서 본 단면이 제빵사의 반죽처럼 두 배로 늘어나 제 위로 접혀요. 접을 때마다 조각이 길게 늘어 금빛 결이 되고, 다섯 번 접으면 서른두 겹의 가는 금선이 반짝임만 남기고 크림에 녹아든 뒤 새 조각이 떨어져요. K3 은 한 번에 세 겹이나 네 겹으로 접게 하고, K1 은 크림을 색상환 한 바퀴로 물들이며 누르면 한 번을 네 배 빠르게 접어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-gilded-cream","type":"code","name":"gilded-cream","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fold=2..4, Gold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fold","min":2,"max":4},{"name":"Gold","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2739,"detail":0.0073,"edges":0.2093,"complexity":0.5765,"coverage":1,"colour":0.1255,"drift":0.0414},"knobResponse":[0.2092,0.0648,0.051,0.0463]},{"slug":"giraffe","title":"Giraffe","family":"mammal","round":23,"note":"우산 아카시아의 납작한 수관 밑에서 그물무늬기린이 보라색 혀로 잔가지를 감아 잎을 훑고, 소등쪼기새가 목을 타고 뛰어다녀요. 가끔 앞다리를 A 자로 벌리고 목을 내려 웅덩이 물을 마시면 물에 동그란 물결이 퍼져요. K3 을 돌리면 무늬가 마사이기린이나 로스차일드기린의 것으로 바뀌고, 끝에는 흰 기린이 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-giraffe","type":"code","name":"giraffe","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sun=0..1, Speed=0.2..3, Coat=0..3, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sun","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coat","min":0,"max":3},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.123,"detail":0.074,"edges":0.4044,"complexity":1.9181,"coverage":0.9853,"colour":0.3367,"drift":0.0426},"knobResponse":[0.2454,0.0494,0.078,0.0609]},{"slug":"glass-patterns","title":"Glass Patterns","family":"noise","round":46,"note":"흩어진 점마다 같은 일차 사상으로 세 번 옮긴 사본을 이어 그려서, 잡음 속에서 x' = Ax 의 흐름이 동심원과 나선, 별, 안장으로 차례로 떠올라요. 위 띠는 대각합–행렬식 평면에서 A 의 자리예요. K3 은 점 수, K4 는 옮기는 거리 ε 이고, K1 을 누르면 다음 꼴로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-glass-patterns","type":"code","name":"glass-patterns","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dots=320..800, Step=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dots","min":320,"max":800},{"name":"Step","min":0,"max":1}],"start":[0,2,320,0.06],"measures":{"motion":1.2073,"detail":0.1021,"edges":0.8095,"complexity":0.2342,"coverage":0.2548,"colour":0.1697,"drift":0.055},"knobResponse":[0.0375,0.0969,0.152,0.0523]},{"slug":"glassblower","title":"Glassblower","family":"glass","round":27,"note":"어두운 스윙 피트 위 발판에서 가퍼가 블로파이프 끝의 유리 덩어리를 진자처럼 흔들면, 덩어리가 아래로 늘어나 긴 화병이 되며 노랑에서 주황을 지나 진홍으로 식어요. 글로리 홀에서 다시 달궈 불고 또 흔든 뒤 잘라 내면 바닥의 컬릿 더미에 떨어져 부서져요. K1 이 코발트나 호박 같은 유리 색을 고르고, 버튼은 다시 달구기와 불기예요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-glassblower","type":"code","name":"glassblower","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glass=0..1, Speed=0.2..3, Length=-1..1, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glass","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":-1,"max":1},{"name":"Heat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2176,"detail":0.046,"edges":0.1956,"complexity":1.533,"coverage":0.4076,"colour":0.1924,"drift":0.0806},"knobResponse":[0.0366,0.0488,0.0315,0.0412]},{"slug":"glitter-fall","title":"Glitter Fall","family":"cosmetic","round":29,"note":"검은 화면 위로 분홍 글리터가 흔들리는 줄기로 쏟아지고, 육각 조각 하나하나가 제 박자로 돌다가 면이 빛을 향할 때 반짝여요. 바닥에 쌓인 더미는 바닥 틈으로 모래시계처럼 빠져요. K1 은 색상환을 다 돌고, 누르면 더미 윗층이 공중으로 튀어 올라요.","why":"반짝이가 점 하나 크기예요.","block":1,"ramped":false,"layer":{"id":"layer-glitter-fall","type":"code","name":"glitter-fall","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Amount=1..3, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Amount","min":1,"max":3},{"name":"Size","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.3817,"detail":0.0894,"edges":0.4622,"complexity":1.3664,"coverage":0.3835,"colour":0.1675,"drift":0.0908},"knobResponse":[0.0974,0.131,0.1719,0.0961]},{"slug":"glyph-rain","title":"Glyph Rain","family":"type","round":1,"note":"3×5 글자가 줄마다 떨어지며 바뀌어요. 비가 지나간 글자는 옛 단말기의 초록 형광처럼 몇 초 남아 흐려져서, 아무 말도 하지 않는 글이 화면을 채워요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-glyph-rain","type":"code","name":"glyph-rain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Fall=0.3..6, Density=0..1, Mutate=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Fall","min":0.3,"max":6},{"name":"Density","min":0,"max":1},{"name":"Mutate","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2257,"detail":0.0998,"edges":0.7469,"complexity":0.2343,"coverage":0.2152,"colour":0.1998,"drift":0.0956},"knobResponse":[0.0655,0.0718,0.1045,0.0664]},{"slug":"gold-leaf","title":"Gold Leaf","family":"cosmetic","round":33,"note":"맑은 세럼에 구겨진 금박 조각 마흔 개가 떠서 위아래 두 대류 칸을 따라 천천히 돌 뿐 가라앉지 않아요. 조각이 뒤집힐 때마다 빛을 향한 면이 흰 금빛으로 번쩍이고 돌아선 면은 짙은 금으로 내려가며, 먼 조각은 작고 흐려요. K1 은 색상환을 다 돌아 금박을 장밋빛 금이나 푸른 박으로 바꾸고, 누르면 세럼을 저어 조각이 느린 소용돌이로 돌며 다섯 배 빨리 뒤집혀요.","why":"금박이 좋은데 조각이 작고 느려요.","block":1,"ramped":false,"layer":{"id":"layer-gold-leaf","type":"code","name":"gold-leaf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flakes=40..120, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flakes","min":40,"max":120},{"name":"Size","min":0,"max":1}],"start":[0,2,40,0.06],"measures":{"motion":0.1468,"detail":0.0417,"edges":0.5435,"complexity":1.0218,"coverage":0.4003,"colour":0.1903,"drift":0.1193},"knobResponse":[0.0888,0.0967,0.0947,0.1201]},{"slug":"goldbach-comet","title":"Goldbach Comet","family":"number","round":33,"note":"짝수 n 을 두 소수의 합으로 쓰는 가짓수를 매끈한 예측값으로 나눠 가로로 찍고, n 은 아래로 커져요. n 이 3 이나 5 나 7 로 나뉘는지에 따라 여덟 줄기가 색으로 갈라지고, 아래로 갈수록 줄기가 가늘어지며 52만까지 가면 처음부터 다시 흘러요. K3 은 7 부터 소수 하나씩 줄기를 접어 한 줄로 모으고, K1 을 누르면 8초 동안 다 접었다 펴요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-goldbach-comet","type":"code","name":"goldbach-comet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Correction=0..1, Smear=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Correction","min":0,"max":1},{"name":"Smear","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.5227,"detail":0.1448,"edges":0.6539,"complexity":1.6402,"coverage":0.5247,"colour":0.2628,"drift":0.0876},"knobResponse":[0.139,0.1117,0.2621,0.1127]},{"slug":"golomb-ruler","title":"Golomb Ruler","family":"number","round":66,"note":"14 눈금 최적 Golomb 자의 눈금 쌍 91개가 저마다 다른 크기의 호로 겹쳐 서고, 캘리퍼가 길이 1부터 127까지 훑으며 길이마다 호 하나를 켜거나 오른쪽 길이 자에 빈칸을 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-golomb-ruler","type":"code","name":"golomb-ruler","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ruler=0..3, Shape=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ruler","min":0,"max":3},{"name":"Shape","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1027,"detail":0.1161,"edges":0.4688,"complexity":1.8229,"coverage":0.573,"colour":0.2653,"drift":0.2539},"knobResponse":[0.1063,0.1173,0.1575,0.1788]},{"slug":"golomb-trominoes","title":"Golomb Trominoes","family":"cells","round":56,"note":"64 × 64 판 둘이 한 칸씩 빠진 채 3 LED 짜리 L 트로미노로 덮여요. 깜박이는 빈칸이 한 LED 씩 걸을 때마다 그 사이 트로미노가 흰빛으로 다시 깔리고, 바탕 색은 빈칸을 둘러싼 증명의 L 자 껍질을 따라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-golomb-trominoes","type":"code","name":"golomb-trominoes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lift=0..4, Cell=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lift","min":0,"max":4},{"name":"Cell","min":1,"max":4}],"start":[0,2,0,1],"measures":{"motion":0.023,"detail":0.3554,"edges":0.9342,"complexity":0.3206,"coverage":1,"colour":0.518,"drift":0.0082},"knobResponse":[0.4161,0.0515,0.2793,0.3508]},{"slug":"gosset-polytope","title":"Gosset Polytope","family":"geometry","round":28,"note":"E8 의 근 240개와 그 사이 모서리 6720개, 고셋의 4₂₁ 다면체를 8차원에서 두 창에 비춰요. 위 창은 30개씩 고리 여덟이 서는 콕서터 평면에서 열려 E7, E6, D5, D4, D6 의 평면을 지나 돌아오고, 아래 창은 몇 평면 앞서가요. 누르면 둘 다 콕서터 평면으로 돌아가요.","why":"점 무늬가 작고 거의 안 움직여요(움직임 0.10).","block":1,"ramped":false,"layer":{"id":"layer-gosset-polytope","type":"code","name":"gosset-polytope","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Edges=-1..1, Plane=1..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Edges","min":-1,"max":1},{"name":"Plane","min":1,"max":5}],"start":[0,2,0,1],"measures":{"motion":0.1027,"detail":0.0626,"edges":0.2381,"complexity":1.7381,"coverage":0.5762,"colour":0.1523,"drift":0.0443},"knobResponse":[0.101,0.0579,0.4228,0.087]},{"slug":"granular-demon","title":"Granular Demon","family":"particle","round":59,"note":"바닥을 흔드는 키 큰 상자를 창 난 벽으로 나누면 240알이 저절로 한 칸에 모여요. 찬 칸은 바닥의 하늘색 더미, 뜨거운 칸은 뚜껑까지 날아다니는 분홍 줄이고, 벽이 들리면 다시 퍼져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-granular-demon","type":"code","name":"granular-demon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shaking=130..260, Boxes=2..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shaking","min":130,"max":260},{"name":"Boxes","min":2,"max":5}],"start":[0,2,130,2],"measures":{"motion":2.2353,"detail":0.0674,"edges":0.4722,"complexity":0.8616,"coverage":0.7457,"colour":0.1627,"drift":0.0506},"knobResponse":[0.099,0.0883,0.1616,0.0825]},{"slug":"granular-leidenfrost","title":"Granular Leidenfrost","family":"particle","round":70,"note":"바닥이 쳐 올리는 상자에서 320알이 차가운 결정 덩어리로 뭉쳐 뜨거운 알갱이 기체 위에 뜨고, 흔들기를 줄이면 바닥에 내려앉고 키우면 뚜껑에 눌리며, 알을 덜 비탄성으로 하면 결정이 녹아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-granular-leidenfrost","type":"code","name":"granular-leidenfrost","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Shaking=0.5..3, Restitution=0.88..0.98, Grains=320..440","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Shaking","min":0.5,"max":3},{"name":"Restitution","min":0.88,"max":0.98},{"name":"Grains","min":320,"max":440}],"start":[0,2,0.88,320],"measures":{"motion":3.0313,"detail":0.168,"edges":0.6544,"complexity":1.9555,"coverage":0.6406,"colour":0.3083,"drift":0.1129},"knobResponse":[0.1987,0.352,0.3535,0.2128]},{"slug":"grave-hand","title":"Grave Hand","family":"halloween","round":43,"note":"크고 낮은 주황 달 아래 묘비와 갓 덮은 흙무더기가 검게 서 있고, 흙이 들썩이며 초록 빛 금이 가더니 뼈만 남은 손이 흙덩이를 튀기며 솟아나와요. 손은 달 앞에서 팔꿈치를 굽혀 허공을 더듬고 손가락을 쥐었다 폈다 하다가 세 번에 걸쳐 끌려 들어가요. K3 은 손을 셋까지 늘리고 K4 는 땅안개를 달 아래쪽까지 올려요. K1 을 누르면 흙 속에 있는 손이 모두 한꺼번에 튀어나와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-grave-hand","type":"code","name":"grave-hand","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Hands=1..3, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hands","min":1,"max":3},{"name":"Fog","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2892,"detail":0.0299,"edges":0.4105,"complexity":1.0695,"coverage":0.5738,"colour":0.2984,"drift":0.0577},"knobResponse":[0.0879,0.0451,0.031,0.0445]},{"slug":"graveyard-fog","title":"Graveyard Fog","family":"halloween","round":42,"note":"가는 초승달 아래 검은 비석과 삐뚤어진 쇠울타리 사이로 땅안개 세 겹이 서로 다른 빠르기로 흘러가고, 독한 초록 도깨비불이 오르내리며 둘레의 안개를 물들여요. 안개에는 LED 한 알씩 엇갈린 고운 결이 있어요. K3 은 도깨비불을 4개에서 14개로 늘리고, K4 는 안개를 십자가 가로대 위까지 올려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-graveyard-fog","type":"code","name":"graveyard-fog","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wisps=4..14, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wisps","min":4,"max":14},{"name":"Fog","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0456,"detail":0.0983,"edges":0.0704,"complexity":2.0907,"coverage":0.921,"colour":0.117,"drift":0.0548},"knobResponse":[0.0865,0.0564,0.0424,0.1739]},{"slug":"greenhill-column","title":"Greenhill Column","family":"physics","round":61,"note":"바닥에 박힌 기둥 여덟 개가 자라다가 흰 눈금으로 찍은 제 임계 높이를 넘으면 제 무게에 꺾여 옆으로 눕고, 끝이 수평 아래로 내려가면 줄어들었다가 다시 일어서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-greenhill-column","type":"code","name":"greenhill-column","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=3..64, Top weight=0..40","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":3,"max":64},{"name":"Top weight","min":0,"max":40}],"start":[0,2,3,0.06],"measures":{"motion":0.5878,"detail":0.0407,"edges":0.2458,"complexity":0.6838,"coverage":0.4803,"colour":0.216,"drift":0.1815},"knobResponse":[0.1021,0.1248,0.0889,0.0764]},{"slug":"gridfonts","title":"Gridfonts","family":"type","round":66,"note":"호프스태터의 gridfont 처럼 글자 아홉이 희미한 점 격자를 잇는 짧은 선분으로만 서고, 노브가 스타일을 바꾸면 모든 글자가 같은 규칙으로 획을 거뒀다가 새로 그어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-gridfonts","type":"code","name":"gridfonts","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Style=0..6, Grid=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Style","min":0,"max":6},{"name":"Grid","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0461,"detail":0.052,"edges":0.4604,"complexity":0.331,"coverage":0.2668,"colour":0.1721,"drift":0.0453},"knobResponse":[0.0804,0.0772,0.1425,0.0747]},{"slug":"grim-reaper","title":"Grim Reaper","family":"halloween","round":48,"note":"두 눈에 독한 초록 불을 켠 두건 사신이 해진 옷자락을 날리며 창백한 보름달 앞을 떠가고, 머리 위로 큰 낫을 휘두를 때마다 날이 번뜩이며, 지나가는 자리의 무덤 촛불은 꺼졌다가 등 뒤에서 다시 켜져요. K3 은 무덤 수, K4 는 안개이고, K1 을 누르면 바로 휘둘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-grim-reaper","type":"code","name":"grim-reaper","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Graves=6..30, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Graves","min":6,"max":30},{"name":"Fog","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.347,"detail":0.0359,"edges":0.3909,"complexity":0.2416,"coverage":0.989,"colour":0.1975,"drift":0.2578},"knobResponse":[0.0927,0.1212,0.0466,0.046]},{"slug":"grimoire","title":"Grimoire","family":"halloween","round":51,"note":"탑 방 독서대 위에 펼친 마법서의 책장을 보이지 않는 바람이 넘기면, 종이가 휘어 넘어가며 촛불을 받아 빛나요. 새로 펼친 면마다 독한 초록 인장이 한 획씩 그려지고, 그 글자들이 하나씩 떨어져 나와 초록 불티와 연기 꼬리를 끌며 패널 위로 올라가요. K3 은 바람, K4 는 인장이 타는 밝기이고, 단추를 누르면 돌풍이 책장을 몰아 넘겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-grimoire","type":"code","name":"grimoire","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2495,"detail":0.0417,"edges":0.243,"complexity":1.5612,"coverage":0.9356,"colour":0.1766,"drift":0.0424},"knobResponse":[0.0422,0.0512,0.0434,0.0448]},{"slug":"guilloche","title":"Guilloché","family":"line","round":16,"note":"장미 기관으로 깎은 은판의 보리알 띠와 물결 띠가 패널 높이의 타원으로 서고, 등불이 돌면 그 쪽을 향한 홈만 금빛으로 번쩍여요. K1 을 누르면 칼끝이 귀퉁이에서 가운데로 들어오며 판을 새 무늬로 다시 깎아요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-guilloche","type":"code","name":"guilloche","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Metal=0..1, Light=0..4, Lobes=12..36, Phasing=0..0.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Metal","min":0,"max":1},{"name":"Light","min":0,"max":4},{"name":"Lobes","min":12,"max":36},{"name":"Phasing","min":0,"max":0.5}],"start":[0,2,12,0.06],"measures":{"motion":0.3271,"detail":0.2382,"edges":0.6848,"complexity":2.494,"coverage":1,"colour":0.0828,"drift":0.1447},"knobResponse":[0.1324,0.1841,0.2378,0.2082]},{"slug":"hadwiger-nelson","title":"Hadwiger-Nelson","family":"cells","round":45,"note":"일곱 색 정육각형 유리 타일이 천천히 흐르며 도는 위로 길이 1 인 막대와 모저 방추 같은 단위 도형이 굴러다니고, 빛으로 그은 변의 두 끝은 늘 다른 색 칸에 앉아요. K3 으로 육각형을 아이즈벨의 창 밖으로 줄이거나 키우면 두 끝이 같은 색에 닿은 변이 빨갛게 번쩍여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hadwiger-nelson","type":"code","name":"hadwiger-nelson","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Figures=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":-1,"max":1},{"name":"Figures","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9476,"detail":0.1022,"edges":0.6243,"complexity":0.5058,"coverage":0.8925,"colour":0.4528,"drift":0.1929},"knobResponse":[0.3239,0.3241,0.3031,0.0939]},{"slug":"hair-gloss","title":"Hair Gloss","family":"cosmetic","round":34,"note":"판 전체에 윤기 나는 긴 머리카락 230가닥이 위에서 끝까지 늘어져 산들바람에 흔들려요. 가닥이 빛과 눈의 반벡터에 직각인 줄에 흰 광택 띠가 서고 그 아래로 머리색의 둘째 띠가 따라와 머리가 흔들릴 때마다 오르내리며, 9초마다 보이지 않는 빗이 내려가 빗살 자리를 가르고 지나간 자리를 더 매끄럽고 반짝이게 해요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-hair-gloss","type":"code","name":"hair-gloss","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wave=0..1, Shine=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wave","min":0,"max":1},{"name":"Shine","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1831,"detail":0.0305,"edges":0.0431,"complexity":2.5214,"coverage":0.9825,"colour":0.1258,"drift":0.1122},"knobResponse":[0.2098,0.1537,0.1722,0.1466]},{"slug":"hair-oil","title":"Hair Oil","family":"cosmetic","round":37,"note":"청록 머리결이 위에서 아래까지 흘러내리며 두 번 갈라져 끝에서는 스무 묶음이 되고, 그 위를 카지야-케이 광택 띠가 오르내려요. 금색 오일 방울이 위쪽에 떨어져 가닥을 따라 미끄러지다 갈림길에서 둘로 나뉘고, 방울이 지나간 가닥은 한 톤 짙어지며 광택이 여섯 배 날카로워진 채 13초에 반쯤 흐려져요. K3 은 1초에 떨어지는 방울을 4개까지 늘리고, 누르면 방울 12개가 위에서 한꺼번에 흘러내려요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-hair-oil","type":"code","name":"hair-oil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=0.5..4, Wave=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":0.5,"max":4},{"name":"Wave","min":-1,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.3092,"detail":0.0865,"edges":0.3007,"complexity":2.6843,"coverage":0.7924,"colour":0.1708,"drift":0.1096},"knobResponse":[0.1623,0.2029,0.0681,0.2493]},{"slug":"hairy-ball","title":"Hairy Ball","family":"noise","round":28,"note":"위에는 털 난 공, 아래에는 털 난 도넛이 빛을 받으며 돌아요. 공은 어떻게 빗어도 털이 갈 데 없는 가마가 하나나 둘 금빛으로 남고, 도넛은 한 바퀴 매끈하게 빗겨요. 귀퉁이의 2 와 0 은 둘의 오일러 지표예요. 누르면 둘 다 다시 빗어서 가마가 다른 자리로 뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-hairy-ball","type":"code","name":"hairy-ball","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=8..13, Comb=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":8,"max":13},{"name":"Comb","min":-1,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":1.5705,"detail":0.1196,"edges":0.4915,"complexity":1.6126,"coverage":0.5237,"colour":0.1866,"drift":0.0881},"knobResponse":[0.0995,0.1196,0.1223,0.076]},{"slug":"halftone","title":"Halftone","family":"print","round":2,"note":"떠도는 등불 넷이 비추는 저녁 하늘을 잉크마다 각도가 다른 망점으로 찍어요. 점은 농도만큼 자라고 줄며, K1 이 CMY, 리소, 벤데이, 신문 잉크를 골라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-halftone","type":"code","name":"halftone","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Inks=0..3, Speed=0.1..5, Screen=8..13, Turn=0..30","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Inks","min":0,"max":3},{"name":"Speed","min":0.1,"max":5},{"name":"Screen","min":8,"max":13},{"name":"Turn","min":0,"max":30}],"start":[0,2,8,0.06],"measures":{"motion":0.0294,"detail":0.0277,"edges":0.6406,"complexity":0.1753,"coverage":0.9983,"colour":0.4355,"drift":0.0403},"knobResponse":[0.2427,0.1303,0.1431,0.1473]},{"slug":"ham-sandwich","title":"Ham Sandwich","family":"topology","round":44,"note":"청록 빵 구름과 자홍 햄 구름이 서로를 돌며 늘었다 갈라졌다 합쳐지고, 굵은 칼 하나가 프레임마다 두 구름을 똑같이 반씩 나눠요. 칼 한쪽은 밝고 다른 쪽은 어두워서, 칼이 돌면 밝은 쪽이 통째로 뒤집혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ham-sandwich","type":"code","name":"ham-sandwich","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..6, Thin=0..1, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":6},{"name":"Thin","min":0,"max":1},{"name":"Scatter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4325,"detail":0.322,"edges":1,"complexity":0.1735,"coverage":0.5292,"colour":0.3956,"drift":0.3705},"knobResponse":[0.0726,0.342,0.1452,0.2773]},{"slug":"hammersley-lines","title":"Hammersley Lines","family":"algo","round":32,"note":"왼쪽 아래를 원점으로 점이 빗방울처럼 하나씩 떨어져 쌓여요. 원점에서 그 칸까지의 상자 안에서 오른쪽 위로 이어지는 가장 긴 점 사슬의 길이로 띠를 칠해서, 점마다 꺾이는 계단 등고선이 쌍곡선 xy = 일정 꼴로 모여요. 오른쪽 위 모서리까지 가장 긴 사슬은 금빛 길이에요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-hammersley-lines","type":"code","name":"hammersley-lines","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Points=200..1000, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Points","min":200,"max":1000},{"name":"Bands","min":0,"max":1}],"start":[0,2,200,0.06],"measures":{"motion":0.4589,"detail":0.1005,"edges":0.9193,"complexity":0.242,"coverage":0.9226,"colour":0.2106,"drift":0.1453},"knobResponse":[0.1723,0.2043,0.2559,0.3087]},{"slug":"hanging-chain","title":"Hanging Chain","family":"physics","round":58,"note":"구슬 32개짜리 사슬이 윗줄 가운데에 매달려 J0 베셀 모양으로 흔들리고, 뒤에 남는 긴 노출이 흔들린 자리를 채워 봉투를 그려요. Mode 를 5 로 돌리면 자유단에서 3%, 14%, 34%, 62% 높이에 노란 눈금이 서고, 봉투가 그 네 자리에서 조여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hanging-chain","type":"code","name":"hanging-chain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=1..5, Mix=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":1,"max":5},{"name":"Mix","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3331,"detail":0.0297,"edges":0.3478,"complexity":0.7957,"coverage":0.3324,"colour":0.1445,"drift":0.0482},"knobResponse":[0.0569,0.0622,0.0762,0.0808]},{"slug":"hanging-line","title":"Hanging Line","family":"type","round":67,"note":"김소월 「진달래꽃」 94 음절이 안상수체를 본떠 직선과 원으로 그린 자모로 한 자모씩 쳐지며 윗줄에 매달려 아랫단이 들쭉날쭉하고, Frame 노브를 올리면 음절마다 같은 13×13 네모 칸에 늘려 담겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hanging-line","type":"code","name":"hanging-line","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=1..2, Frame=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":1,"max":2},{"name":"Frame","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.6878,"detail":0.0986,"edges":0.9511,"complexity":0.128,"coverage":0.1312,"colour":0.1358,"drift":0.0958},"knobResponse":[0.0394,0.1027,0.1151,0.1354]},{"slug":"hanging-scroll","title":"Hanging Scroll","family":"paper","round":23,"note":"어두운 도코노마 벽의 못에 족자가 걸리고, 아래 굴대가 내려가며 비단 표구 속 상아빛 종이에 그린 먹 산수를 한 줄씩 드러내요. 안개 낀 봉우리 아래 소나무와 폭포, 초가와 쪽배가 있고 붉은 낙관이 찍혀 있어요. 외풍에 조금 흔들리다 아래부터 말려 올라가면 바람 맞는 대나무가 내려오고, 달 아래 홍매와 파도 위 학이 뒤를 이어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-hanging-scroll","type":"code","name":"hanging-scroll","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Painting=0..3, Ink=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Painting","min":0,"max":3},{"name":"Ink","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.177,"detail":0.0295,"edges":0.2326,"complexity":1.3758,"coverage":0.4677,"colour":0.1211,"drift":0.2049},"knobResponse":[0.0845,0.2,0.0646,0.0324]},{"slug":"hard-squares","title":"Hard Squares","family":"particle","round":58,"note":"서로 닿을 수 없는 입자가 LED 위에 켜졌다 꺼지는데, 활동도가 아래로 갈수록 e^6 배까지 커져서 위는 드문 기체로 반짝이고, 활동도가 3.796 을 넘는 104번 줄 아래에서는 청록과 금색 두 부분격자의 바둑판 결정으로 얼어요. 결정의 영역은 몇 분에 걸쳐 굵어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hard-squares","type":"code","name":"hard-squares","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gravity=6..16, Activity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gravity","min":6,"max":16},{"name":"Activity","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.3409,"detail":0.3257,"edges":0.4003,"complexity":0.1595,"coverage":0.5876,"colour":0.313,"drift":0.0265},"knobResponse":[0.1202,0.0768,0.0943,0.1439]},{"slug":"harmonograph","title":"Harmonograph","family":"line","round":1,"note":"단순한 비에서 조금씩 어긋난 진자 셋이 닫히지 않는 그림을 그리고, 멎어 가며 가운데로 감겨 들어가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-harmonograph","type":"code","name":"harmonograph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..4, Ratio=0..7, Damping=0.02..0.4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":4},{"name":"Ratio","min":0,"max":7},{"name":"Damping","min":0.02,"max":0.4}],"start":[0,2,0,0.06],"measures":{"motion":0.0325,"detail":0.0469,"edges":0.3334,"complexity":0.8432,"coverage":0.2444,"colour":0.1802,"drift":0.053},"knobResponse":[0.0712,0.0419,0.0758,0.0561]},{"slug":"harp","title":"Harp","family":"music","round":16,"note":"무대에 선 페달 하프가 패널 높이를 다 채우고, 보이지 않는 하프 주자가 뜯은 줄이 렌즈 꼴로 번졌다가 잦아들어요. K3 은 펼친화음, 굴린 화음, 하모닉스, 글리산도 가운데 하나를 고르고, K1 을 누르면 29줄을 다 훑는 글리산도가 올라갔다 내려와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-harp","type":"code","name":"harp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Tempo=0.5..3.5, Figure=0..3, Damp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Tempo","min":0.5,"max":3.5},{"name":"Figure","min":0,"max":3},{"name":"Damp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.151,"detail":0.0758,"edges":0.4257,"complexity":1.512,"coverage":0.8852,"colour":0.2261,"drift":0.0747},"knobResponse":[0.0708,0.0671,0.0617,0.0595]},{"slug":"hat-monotile","title":"Hat Monotile","family":"cells","round":51,"note":"13각형 타일 하나인 모자가 메타타일 치환이 감싸는 차례대로 덩이째 패널을 채우고, 거울에 비친 모자는 여덟에 하나꼴로 주황에 서요. 되풀이하지 않는 7,921장 조각 위로 창이 흘러가는 동안 색의 물결이 같은 모자들을 한 단계, 두 단계 큰 덩이로 다시 묶어요. K3 은 모자 크기, K4 는 같은 타일링의 변을 두 길이로 다시 재어 혜성에서 거북과 모자를 지나 갈매기표 모양까지 바꾸는 Tile(a, b) 예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hat-monotile","type":"code","name":"hat-monotile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=9..16, Shape=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":9,"max":16},{"name":"Shape","min":-1,"max":1}],"start":[0,2,9,0.06],"measures":{"motion":1.1786,"detail":0.3664,"edges":1,"complexity":0.3378,"coverage":0.6188,"colour":0.629,"drift":0.0817},"knobResponse":[0.4026,0.3923,0.4063,0.3702]},{"slug":"haunted-manor","title":"Haunted Manor","family":"halloween","round":42,"note":"보라 폭풍 아래 언덕 위에 첨탑이 굽은 낡은 저택과 죽은 나무가 서 있고, 비가 비스듬히 쏟아지다가 몇 초마다 갈래 친 번개가 내리쳐 하늘이 번쩍이고 집은 새까만 그림자가 돼요. 주황과 독한 초록 창이 깜빡이고, 창 하나에 사람 그림자가 지나가거나 덧문이 쾅 닫혀요. 젖은 땅이 아래층 창을 일렁이며 비춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-haunted-manor","type":"code","name":"haunted-manor","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Storm=0..1, Lights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Storm","min":0,"max":1},{"name":"Lights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6288,"detail":0.0353,"edges":0.6384,"complexity":0.7403,"coverage":0.7619,"colour":0.17,"drift":0.2715},"knobResponse":[0.0893,0.0581,0.0354,0.0321]},{"slug":"haunted-swing","title":"Haunted Swing","family":"halloween","round":44,"note":"보랏빛 밤에 옆에서 본 그네 틀에서 빈 판자 그네가 혼자 흔들려요. 가끔 초록 안개 손이 지나가는 그네를 뒤에서 밀고, 같은 가로대의 뒤 그네가 가만히 있다가 따라 흔들리기 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-haunted-swing","type":"code","name":"haunted-swing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Coupling=0.2..1, Haunt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coupling","min":0.2,"max":1},{"name":"Haunt","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.363,"detail":0.0399,"edges":0.626,"complexity":0.172,"coverage":0.5089,"colour":0.0969,"drift":0.046},"knobResponse":[0.0356,0.0447,0.0396,0.0256]},{"slug":"hawkes-process","title":"Hawkes Process","family":"rhythm","round":59,"note":"네 갈래 호크스 과정의 사건이 128줄을 따라 내려가고, 갈래마다 강도가 사건 때마다 부풀었다 잦아드는 띠로 채워져요. 자식 사건은 부모와 선으로 이어져서 무리 나무가 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hawkes-process","type":"code","name":"hawkes-process","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Branching=0.7..0.95, Decay=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Branching","min":0.7,"max":0.95},{"name":"Decay","min":2,"max":8}],"start":[0,2,0.7,2],"measures":{"motion":0.8669,"detail":0.0554,"edges":0.4465,"complexity":0.786,"coverage":0.4621,"colour":0.1293,"drift":0.1291},"knobResponse":[0.0527,0.1082,0.2793,0.0913]},{"slug":"head-wave","title":"Head Wave","family":"physics","round":81,"note":"느린 지각 밑 1.35배 빠른 맨틀의 경계를 타고 온 머리파가 곧은 원뿔 앞선으로 원형 앞선을 앞질러 올라와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-head-wave","type":"code","name":"head-wave","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=1.35..2.5, Height=2..50","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":1.35,"max":2.5},{"name":"Height","min":2,"max":50}],"start":[0,2,1.35,2],"measures":{"motion":1.7435,"detail":0.1971,"edges":0.1435,"complexity":1.9841,"coverage":0.8918,"colour":0.3956,"drift":0.0377},"knobResponse":[0.3029,0.2159,0.206,0.2492]},{"slug":"headless-rider","title":"Headless Rider","family":"halloween","round":48,"note":"큰 달 앞을 머리 없는 기수가 검은 그림자로 달리고, 말이 네 박자 습보로 다리를 모았다 뻗으며 흙먼지와 불티를 차올리는 사이 기수가 불붙은 호박을 높이 던져 앞길에서 터뜨려요. K3 은 나무 수, K4 는 달빛 안개이고, K1 을 누르면 바로 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-headless-rider","type":"code","name":"headless-rider","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Woods=0..1, Mist=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Woods","min":0,"max":1},{"name":"Mist","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.759,"detail":0.0482,"edges":0.4609,"complexity":0.2465,"coverage":0.8197,"colour":0.1505,"drift":0.0725},"knobResponse":[0.0773,0.0641,0.0497,0.0479]},{"slug":"heawood-torus","title":"Heawood Torus","family":"topology","round":36,"note":"세로로 긴 토러스가 천천히 돌며 헤우드의 지도를 보여 줘요. 일곱 나라가 저마다 나머지 여섯과 모두 맞닿아서, 구 위의 지도와 달리 이 지도는 일곱 색이 있어야 칠해져요. K3 은 구멍을 넓혀 굵은 관을 가는 고리로 만들고, K1 을 누르면 여섯 초 동안 일곱 수도와 그 사이 길 21개가 흰 선으로 그려져요.","why":"일곱 색으로 칠한 토러스가 돌아요. 색면이 커서 멀리서도 읽혀요.","block":0,"ramped":false,"layer":{"id":"layer-heawood-torus","type":"code","name":"heawood-torus","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hole=0..1, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hole","min":0,"max":1},{"name":"Tilt","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4823,"detail":0.0527,"edges":0.4488,"complexity":0.5038,"coverage":0.538,"colour":0.6204,"drift":0.3781},"knobResponse":[0.4775,0.281,0.1318,0.1492]},{"slug":"heesch-tiles","title":"Heesch Tiles","family":"cells","round":62,"note":"가장자리가 쉬지 않고 휘는 타일 하나가 틈도 겹침도 없이 패널을 덮어요. 짝지은 변은 헤슈가 붙인 이름 T, C, G, C3, C4 대로 서로 옮겨 붙고, 8초마다 다음 형이 위에서부터 한 장씩 덮어 오며, 돌거나 뒤집힌 복사본은 색이 달라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-heesch-tiles","type":"code","name":"heesch-tiles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Type=0..5, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Type","min":0,"max":5},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2034,"detail":0.0955,"edges":0.4513,"complexity":1.2,"coverage":0.8946,"colour":0.4574,"drift":0.1158},"knobResponse":[0.3386,0.2065,0.2554,0.2536]},{"slug":"hegselmann-krause","title":"Hegselmann-Krause","family":"sim","round":76,"note":"의견 400개가 ε 안의 이웃 평균으로 옮겨 가는 걸음을 위에서 아래로 적어, 흩어진 빛이 몇 갈래 강으로 모여 얼어붙어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hegselmann-krause","type":"code","name":"hegselmann-krause","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Epsilon=0.03..0.3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Epsilon","min":0.03,"max":0.3}],"start":[0,2,0,0.06],"measures":{"motion":0.0784,"detail":0.051,"edges":0.4377,"complexity":0.9178,"coverage":0.4662,"colour":0.186,"drift":0.1123},"knobResponse":[0.1128,0.0638,0.1258,0.1275]},{"slug":"hellschreiber","title":"Hellschreiber","family":"type","round":70,"note":"무선으로 온 글자가 한 열씩 아래에서 위로 종이 테이프에 두 벌 찍히고, 낱말 사이에서 잘린 띠가 양식지에 한 줄씩 붙으며, 수신기 시계가 어긋나면 글줄이 띠를 타고 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hellschreiber","type":"code","name":"hellschreiber","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Noise=0..1, Drift=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":0,"max":1},{"name":"Drift","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.478,"detail":0.1715,"edges":0.6347,"complexity":0.8955,"coverage":1,"colour":0.1406,"drift":0.096},"knobResponse":[0.1222,0.0523,0.1193,0.2024]},{"slug":"helter-skelter","title":"Helter Skelter","family":"fair","round":19,"note":"밤 장터의 헬터 스켈터가 128줄을 다 써요. 사람들이 탑 안 계단을 올라 작은 창에 비치고, 꼭대기에서 매트에 앉아 전구 체이스와 함께 탑을 돌아 미끄러져 내려온 뒤 매트를 들고 아래 문으로 돌아가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-helter-skelter","type":"code","name":"helter-skelter","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Bulbs=0..1, Speed=0.2..3, Turns=3..6, Stripes=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Bulbs","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":3,"max":6},{"name":"Stripes","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1978,"detail":0.0529,"edges":0.4142,"complexity":1.5797,"coverage":0.8591,"colour":0.2542,"drift":0.0688},"knobResponse":[0.0829,0.0365,0.0808,0.0347]},{"slug":"hex-theorem","title":"Hex Theorem","family":"cells","round":55,"note":"긴 대각선으로 세운 헥스 판에 칸이 하나씩 무작위로 차다가 한 색의 사슬이 제 두 변을 잇는 순간 그 사슬이 밝아지고, 판이 다 차면 진 색이 제 두 변에서 밀려 들어오다 사슬 앞에서 멈추는 사이 게일의 길이 두 색 사이 이음매를 따라 아래 꼭짓점에서 이긴 쪽 꼭짓점까지 하얗게 그어져요. K3 은 판의 한 변(7~15칸), K4 는 한 색이 칸을 가져갈 확률(0.25~0.75)이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hex-theorem","type":"code","name":"hex-theorem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=7..15, Bias=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":7,"max":15},{"name":"Bias","min":-1,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.1217,"detail":0.0977,"edges":0.72,"complexity":0.3967,"coverage":0.4082,"colour":0.3086,"drift":0.1603},"knobResponse":[0.1295,0.1334,0.1528,0.1015]},{"slug":"hexachordal-theorem","title":"Hexachordal Theorem","family":"rhythm","round":70,"note":"12박 고리의 여섯 온셋과 나머지 여섯이 위아래 고리에서 번갈아 울리고, 한 바퀴마다 온셋 하나가 옆으로 옮겨도 사이의 거리 막대는 늘 거울처럼 같아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hexachordal-theorem","type":"code","name":"hexachordal-theorem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pulses=12..20, Uneven=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pulses","min":12,"max":20},{"name":"Uneven","min":0,"max":3}],"start":[0,2,12,0.06],"measures":{"motion":0.2392,"detail":0.0729,"edges":0.8805,"complexity":0.3531,"coverage":0.2041,"colour":0.1574,"drift":0.0548},"knobResponse":[0.0535,0.0359,0.0907,0.0628]},{"slug":"hexagrammum-mysticum","title":"Hexagrammum Mysticum","family":"line","round":58,"note":"타원 위를 미끄러지는 여섯 점의 육각형 60개가 1초에 하나씩 그려져요. 변이 마주 보는 변과 만날 때까지 뻗어 세 점에 고리가 켜지면 그 셋을 지나는 파스칼 선이 하얗게 번쩍이고, 세 번째 육각형마다 같은 색 세 선이 만나는 슈타이너 점이 금빛으로 피어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hexagrammum-mysticum","type":"code","name":"hexagrammum-mysticum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=12..60, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":12,"max":60},{"name":"Spread","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.2964,"detail":0.0746,"edges":0.3901,"complexity":1.1529,"coverage":0.2916,"colour":0.1309,"drift":0.0816},"knobResponse":[0.0489,0.094,0.0872,0.1143]},{"slug":"hexatic-phase","title":"Hexatic Phase","family":"particle","round":37,"note":"단단한 원판 440개가 주기 경계 상자 안에서 사건 사슬 몬테카를로로 밀치고, 원판마다 둘레의 육각 격자가 가리키는 쪽에 따라 색을 입어요. 색상환 한 바퀴가 격자 회전 60도라서 결정 조각이 한 색 덩어리로 헤엄치고 합쳐지며 돌고, 이웃이 다섯인 원판은 흰 점, 일곱인 원판은 흰 고리로 결정 경계를 따라 줄지어요. K3 은 채움 몫을 0.68 의 액체에서 0.76 의 고체까지 올리고, 누르면 상자가 녹았다가 다시 굳어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-hexatic-phase","type":"code","name":"hexatic-phase","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=0.68..0.76, Cells=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":0.68,"max":0.76},{"name":"Cells","min":0,"max":1}],"start":[0,2,0.68,0.06],"measures":{"motion":2.3076,"detail":0.1862,"edges":0.5515,"complexity":2.0903,"coverage":0.6781,"colour":0.3428,"drift":0.1672},"knobResponse":[0.1472,0.2305,0.3425,0.068]},{"slug":"high-dive","title":"High Dive","family":"sport","round":23,"note":"밤의 실내 다이빙장을 옆에서 봐요. 다이버가 콘크리트 타워의 지그재그 계단을 올라 10 m 플랫폼 조명 아래 서고, 1.6초 동안 공중제비를 돌며 떨어져 물에 들어가면 물속에 기포 기둥이 오르고 전광판에 심판 일곱 명의 점수가 떠요. K3 이 앞으로 뛰기부터 세 바퀴 반과 비틀기까지 다이빙을 골라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-high-dive","type":"code","name":"high-dive","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Pool=0..1, Speed=0.2..3, Dive=0..4, Lights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Pool","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dive","min":0,"max":4},{"name":"Lights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3915,"detail":0.0721,"edges":0.2796,"complexity":1.8967,"coverage":0.7436,"colour":0.2296,"drift":0.0344},"knobResponse":[0.0986,0.0554,0.0399,0.1523]},{"slug":"high-striker","title":"High Striker","family":"fair","round":20,"note":"밤 장터의 하이 스트라이커가 128줄을 다 써요. 줄 선 사람들이 차례로 망치를 내리치면 퍽이 실제 중력으로 레일을 오르며 눈금을 켜다가 떨어지고, 세게 친 판이나 K1 을 누른 판에는 꼭대기 놋쇠 종이 울려 전구가 깜박이고 하늘이 밝아져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-high-striker","type":"code","name":"high-striker","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Bulbs=0..1, Speed=0.2..3, Strength=60..130, Gravity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Bulbs","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strength","min":60,"max":130},{"name":"Gravity","min":-1,"max":1}],"start":[0,2,60,0.06],"measures":{"motion":0.2551,"detail":0.0819,"edges":0.4794,"complexity":1.4989,"coverage":0.8211,"colour":0.2622,"drift":0.1521},"knobResponse":[0.0547,0.0439,0.0765,0.0768]},{"slug":"hill-regions","title":"Hill's Regions","family":"particle","round":64,"note":"두 질량을 위아래로 세운 회전 좌표계에서 입자 일곱이 야코비 상수의 영속도 곡선 안에 갇혀 돌아요. Jacobi 를 내리면 L1 부터 L3 까지 목이 차례로 열려서 입자가 작은 질량 쪽으로 건너가고 패널 위로 빠져나가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hill-regions","type":"code","name":"hill-regions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Jacobi=0..4, Mass=0.1..0.5, Trail=2..10","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Jacobi","min":0,"max":4},{"name":"Mass","min":0.1,"max":0.5},{"name":"Trail","min":2,"max":10}],"start":[0,2,0.1,2],"measures":{"motion":0.0735,"detail":0.0825,"edges":0.3959,"complexity":1.2103,"coverage":0.5044,"colour":0.1558,"drift":0.0355},"knobResponse":[0.0868,0.1786,0.1652,0.0627]},{"slug":"hinged-dissection","title":"Hinged Dissection","family":"geometry","round":41,"note":"한 변 62 LED 의 정삼각형이 Dudeney 의 네 조각으로 잘려 세 경첩에 매달려 있어요. 삼각형이 패널 높이만 한 사슬로 펼쳐졌다가 넓이가 같은 한 변 40.8 LED 의 정사각형으로 접히고, 다시 삼각형으로 돌아와요. K3 은 두 모양에서 3초까지 멈춰 서게 하고, K4 는 조각을 사슬 가운데에서 7 LED 까지 밀어내 떼어 놓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hinged-dissection","type":"code","name":"hinged-dissection","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hold=0..3, Gap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hold","min":0,"max":3},{"name":"Gap","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4714,"detail":0.0277,"edges":0.5373,"complexity":0.0578,"coverage":0.1906,"colour":0.2874,"drift":0.2526},"knobResponse":[0.1089,0.1832,0.1806,0.1188]},{"slug":"hitomezashi","title":"Hitomezashi","family":"line","round":43,"note":"가로줄과 세로줄마다 한 땀씩 걸러 뜬 실땀이 평직 천을 쪽빛과 물빛 두 색 영역으로 나눠요. 줄 하나의 비트가 뒤집히면 그 줄의 땀이 한 칸씩 옮겨 가고 줄 한쪽의 색이 물결처럼 바뀌어요. 금빛 불은 가장 새로 닫힌 고리를 따라 돌아요. K3 은 땀 길이를 6 LED 에서 10 LED 로 늘리고, K4 는 닫힌 고리를 모두 금빛으로 켜고 패널 밖으로 나가는 실을 3분의 1 밝기로 낮춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hitomezashi","type":"code","name":"hitomezashi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cell=6..10, Loops=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cell","min":6,"max":10},{"name":"Loops","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.5647,"detail":0.3122,"edges":0.9656,"complexity":0.0999,"coverage":0.7954,"colour":0.3504,"drift":0.2476},"knobResponse":[0.1793,0.3582,0.3708,0.0766]},{"slug":"hodograph","title":"Hodograph","family":"physics","round":66,"note":"해 하나를 이심률이 다른 천체 셋이 케플러의 박자로 돌며 같은 시간 부채를 쓸고, 아래에서는 한 원점에서 그은 속도 화살의 끝이 원점에서 반지름의 e 배만큼 비켜 선 원을 따라 돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hodograph","type":"code","name":"hodograph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Eccentricity=0.6..0.95, Bodies=3..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Eccentricity","min":0.6,"max":0.95},{"name":"Bodies","min":3,"max":6}],"start":[0,2,0.6,3],"measures":{"motion":0.5795,"detail":0.0478,"edges":0.4372,"complexity":0.9711,"coverage":0.3217,"colour":0.147,"drift":0.1019},"knobResponse":[0.0596,0.0807,0.0861,0.1174]},{"slug":"hofstadter-butterfly","title":"Hofstadter Butterfly","family":"fractal","round":30,"note":"자기장 속 격자 전자의 에너지 띠를 가로에, 자속을 세로에 놓았어요. 띠 사이 틈마다 홀 전도도의 정수로 칠해 날개가 서고, 같은 밀도의 줄이 날개를 따라 흘러요.","why":"나비 모양은 좋은데 결이 도해처럼 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-hofstadter-butterfly","type":"code","name":"hofstadter-butterfly","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=16..64, Coupling=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":16,"max":64},{"name":"Coupling","min":-1,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.216,"detail":0.0564,"edges":0.3637,"complexity":0.928,"coverage":0.7618,"colour":0.4337,"drift":0.1658},"knobResponse":[0.2654,0.1807,0.0682,0.2004]},{"slug":"holditch-ring","title":"Holditch Ring","family":"line","round":61,"note":"길이가 정해진 현이 키 큰 볼록 곡선을 따라 한 바퀴 미끄러지는 동안, 현을 a 와 b 로 나누는 점이 금빛 자취를 남기고 곡선과 자취 사이의 고리와 가운데의 반축 a, b 타원이 같은 넓이만큼 함께 차올라요. 바퀴마다 곡선이 달걀, 경기장, 방패 꼴로 바뀌어 고리 모양은 달라져도 타원은 그대로예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-holditch-ring","type":"code","name":"holditch-ring","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Split=0.25..0.5, Chord=36..44","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Split","min":0.25,"max":0.5},{"name":"Chord","min":36,"max":44}],"start":[0,2,0.25,36],"measures":{"motion":0.1008,"detail":0.0482,"edges":0.5264,"complexity":0.6187,"coverage":0.7142,"colour":0.1841,"drift":0.1047},"knobResponse":[0.0525,0.0455,0.0373,0.0468]},{"slug":"hopf-fibration","title":"Hopf Fibration","family":"topology","round":29,"note":"3차원 구면을 채운 원들을 입체 사영해 원근으로 그려요. 같은 위도의 밑점에서 온 원들이 겹겹의 토러스로 소용돌이치고, 가운데 세로선이 무한을 지나는 원이에요. K3 은 토러스 수(5~7)이고, K1 을 누르면 두 원만 남아 한 번 얽힌 것이 보여요.","why":"가는 선이 엉켜 덩어리로 보여요.","block":1,"ramped":false,"layer":{"id":"layer-hopf-fibration","type":"code","name":"hopf-fibration","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rings=5..7, Fibres=14..17","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rings","min":5,"max":7},{"name":"Fibres","min":14,"max":17}],"start":[0,2,5,14],"measures":{"motion":1.6067,"detail":0.0653,"edges":0.2066,"complexity":1.8736,"coverage":0.5881,"colour":0.1771,"drift":0.0635},"knobResponse":[0.0967,0.1134,0.1017,0.0832]},{"slug":"hopfield-letters","title":"Hopfield Letters","family":"type","round":77,"note":"글자 넷을 기억한 홉필드 망이 잡음에 묻힌 단서를 뉴런 하나씩 뒤집어 글자로 되돌리고, 글자를 더 넣으면 어느 글자도 아닌 섞인 상태로 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hopfield-letters","type":"code","name":"hopfield-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Load=0..1, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Load","min":0,"max":1},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2329,"detail":0.0739,"edges":0.9648,"complexity":0.0974,"coverage":0.8135,"colour":0.4478,"drift":0.2357},"knobResponse":[0.2909,0.215,0.19,0.1747]},{"slug":"horse-in-motion","title":"Horse in Motion","family":"film","round":27,"note":"양쪽에 퍼포레이션이 뚫린 필름이 영사기 게이트를 한 칸씩 끊어 내려가고, 램프가 비추는 가운데 칸에서 머이브리지의 경주마가 열두 장의 사진으로 달려요. 위아래 칸은 어둠 속에 흐리게 다음 차례를 기다려요. K3 이 그레이하운드와 앵무새, 달리는 사람의 필름으로 갈아 끼우고, 누르면 필름이 게이트에 걸려 타요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-horse-in-motion","type":"code","name":"horse-in-motion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Subject=0..3, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Subject","min":0,"max":3},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0766,"detail":0.056,"edges":0.3551,"complexity":1.5938,"coverage":0.6083,"colour":0.0988,"drift":0.0453},"knobResponse":[0.0878,0.0582,0.1145,0.1659]},{"slug":"hough-transform","title":"Hough Transform","family":"algo","round":60,"note":"위 정사각형에 점이 하나씩 내려앉을 때마다 그 점의 사인 곡선이 아래 누산기로 왼쪽부터 쓸려 들어가요. 한 직선 위 점들의 곡선이 모두 만나는 봉우리를 골라 그 직선을 위에 같은 색으로 다시 그어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hough-transform","type":"code","name":"hough-transform","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=2..6, Noise=0.3..0.9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":2,"max":6},{"name":"Noise","min":0.3,"max":0.9}],"start":[0,2,2,0.3],"measures":{"motion":0.3135,"detail":0.0699,"edges":0.3939,"complexity":1.1003,"coverage":0.4086,"colour":0.1456,"drift":0.0499},"knobResponse":[0.0603,0.0767,0.0904,0.0905]},{"slug":"hourglass","title":"Hourglass","family":"time","round":2,"note":"LED 하나가 모래 한 알이에요. 두 LED 목으로 흘러 위 더미는 가운데부터 꺼지고 아래에는 원뿔이 쌓이며, 위가 비면 유리가 반 바퀴 돌아 뒤집혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-hourglass","type":"code","name":"hourglass","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sand=0..1, Flow=0.5..4, Glass=0..1, Layers=1..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sand","min":0,"max":1},{"name":"Flow","min":0.5,"max":4},{"name":"Glass","min":0,"max":1},{"name":"Layers","min":1,"max":6}],"start":[0,2,0,1],"measures":{"motion":0.0687,"detail":0.0755,"edges":0.7242,"complexity":0.1856,"coverage":0.3468,"colour":0.2248,"drift":0.051},"knobResponse":[0.0656,0.0293,0.076,0.03]},{"slug":"howling-wolf","title":"Howling Wolf","family":"halloween","round":46,"note":"큰 보름달 앞 바위 언덕의 검은 늑대가 고개를 들어 울고, 초록 소리 고리가 퍼지면 먼 능선의 무리가 차례로 화답해요. K1 은 달 색, K3 은 화답하는 늑대 수, K4 는 구름과 바람이고, K1 을 누르면 바로 울어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-howling-wolf","type":"code","name":"howling-wolf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pack=2..6, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pack","min":2,"max":6},{"name":"Wind","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.2286,"detail":0.0366,"edges":0.2127,"complexity":0.7049,"coverage":0.664,"colour":0.2509,"drift":0.0242},"knobResponse":[0.1154,0.0316,0.018,0.0331]},{"slug":"huffman-tree","title":"Huffman Tree","family":"type","round":68,"note":"글의 기호를 세어 가장 가벼운 둘씩 묶은 나무가 꼭대기 뿌리까지 자라고, 그 갈래를 따라 글이 0과 1로 흘러 고정 길이 부호보다 짧은 비트 줄이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-huffman-tree","type":"code","name":"huffman-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Tie=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Tie","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.0764,"detail":0.0889,"edges":0.8168,"complexity":0.2122,"coverage":0.271,"colour":0.16,"drift":0.0736},"knobResponse":[0.0355,0.0503,0.0814,0.0392]},{"slug":"hunminjeongeum","title":"Hunminjeongeum","family":"type","round":65,"note":"해례본 제자해대로 기본자 ㄱ ㄴ ㅁ ㅅ ㅇ 에서 한 단 내려갈 때마다 새로 더한 획만 빛나며 자음 나무 다섯 열이 자라고, 아래에서는 ㆍ ㅡ ㅣ 가 모여 모음 여덟이 돼요","why":"","block":0,"ramped":false,"layer":{"id":"layer-hunminjeongeum","type":"code","name":"hunminjeongeum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Style=0..1, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Style","min":0,"max":1},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0957,"detail":0.082,"edges":0.6543,"complexity":0.4537,"coverage":0.2214,"colour":0.1608,"drift":0.0866},"knobResponse":[0.0414,0.1016,0.0278,0.0796]},{"slug":"huygens-clocks","title":"Huygens' Clocks","family":"rhythm","round":79,"note":"한 들보에 매단 긴 진자 시계 둘이 째깍일 때마다 번쩍이며 제 줄에 막대를 떨어뜨리고, 거의 같이 치던 째깍이 일곱 번쯤 흔들리는 사이 꼭 반 박자씩 엇갈려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-huygens-clocks","type":"code","name":"huygens-clocks","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Detune=-1..1, Coupling=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Detune","min":-1,"max":1},{"name":"Coupling","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6533,"detail":0.0424,"edges":0.5498,"complexity":0.2121,"coverage":0.2696,"colour":0.2269,"drift":0.081},"knobResponse":[0.0679,0.0478,0.0465,0.0421]},{"slug":"hydra-game","title":"Hydra Game","family":"algo","round":72,"note":"머리를 자를 때마다 한 칸 아래 마디에서 가지가 n 벌 돋아 히드라가 부채처럼 커져도, 위에 적힌 순서수는 매번 줄고 끝내 뿌리만 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-hydra-game","type":"code","name":"hydra-game","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hydra=1..5, Strategy=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hydra","min":1,"max":5},{"name":"Strategy","min":0,"max":3}],"start":[0,2,1,0.06],"measures":{"motion":0.4857,"detail":0.0446,"edges":0.3999,"complexity":0.8981,"coverage":0.3082,"colour":0.1783,"drift":0.1422},"knobResponse":[0.0408,0.0531,0.0596,0.0538]},{"slug":"hydrogen-orbital","title":"Hydrogen Orbital","family":"physics","round":40,"note":"수소 원자 고유 상태의 확률 밀도에서 뽑은 점 수천 개가 z 축을 세운 구름으로 16초에 한 바퀴 돌아요. 점은 서로 닿지 않는 LED 하나씩이고 파동 함수의 부호로 두 색을 칠해 마디 평면과 원뿔이 검게 남아요. K3 은 5g xz³ 에서 6f xz² 까지 열두 궤도를 고르고, K4 를 0 으로 내리면 9 LED 두께의 단면이 되어 지름 마디가 검은 고리로 보여요.","why":"궤도가 LED 한 알 크기의 점 구름이라 면으로 안 보여요.","block":1,"ramped":false,"layer":{"id":"layer-hydrogen-orbital","type":"code","name":"hydrogen-orbital","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Orbital=1..12, Slab=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Orbital","min":1,"max":12},{"name":"Slab","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.5238,"detail":0.3552,"edges":1,"complexity":0.4739,"coverage":0.1998,"colour":0.2586,"drift":0.1043},"knobResponse":[0.1235,0.0855,0.1373,0.0806]},{"slug":"hyperbolic-band","title":"Hyperbolic Band","family":"space","round":28,"note":"칠각형이 한 꼭짓점에 셋씩 모인 쌍곡 평면을 띠 모형으로 세웠어요. 패널 너비 64 LED 에 평면의 폭이 다 들어가고, 쪽매는 띠를 따라 끝없이 올라가며 양옆 가장자리에서 한없이 작아져요. K3 이 {8,3}, {5,4}, {4,5}, {3,7} 로 쪽매를 바꾸고, 누르면 반 바퀴 돌아 제 모습으로 내려앉아요.","why":"패널을 꽉 채우고 결이 복잡해요(복잡도 2.13).","block":1,"ramped":false,"layer":{"id":"layer-hyperbolic-band","type":"code","name":"hyperbolic-band","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tiling=0..4, Lines=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tiling","min":0,"max":4},{"name":"Lines","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4373,"detail":0.1076,"edges":0.286,"complexity":2.1332,"coverage":0.9802,"colour":0.6419,"drift":0.0932},"knobResponse":[0.5855,0.187,0.2223,0.3482]},{"slug":"iceberg","title":"Iceberg","family":"polar","round":26,"note":"물높이에서 자른 빙산이 9분의 1만 물 위에 내밀고 펭귄을 얹은 채 너울에 흔들리다, 판이 떨어져 물보라를 일으켜요. 물 아래 몸은 푸른 얼음 줄무늬와 탄산처럼 오르는 거품 줄기로 패널 바닥까지 내려가요. K1 은 백야의 해에서 오로라 뜬 극야로, 버튼은 판을 떼어 내요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-iceberg","type":"code","name":"iceberg","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Shape=0..1, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Swell","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1332,"detail":0.0357,"edges":0.189,"complexity":1.9213,"coverage":0.9971,"colour":0.3059,"drift":0.0544},"knobResponse":[0.1811,0.05,0.05,0.0489]},{"slug":"imaginary-geometry","title":"Imaginary Geometry","family":"noise","round":55,"note":"패널 아래 가운데 한 점에서 가우스 자유장의 흐름선 열세 개가 각도 부채꼴로 떠나 위 가운데 한 점까지 오르는데, 각도가 큰 선이 늘 왼쪽에 머물고 두 선이 한 LED 안으로 붙으면 하나로 같이 가다가 다시 갈라질 뿐 서로 건너지 않아요. 장이 천천히 흘러서 선들이 렌즈처럼 벌어졌다가 땋은 다발로 모여요. K3 은 선이 얼마나 굽이치는지 정하는 κ(0.5~3), K4 는 부채꼴의 각도 폭이고, 단추를 누르면 새 장에서 부채꼴이 다시 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-imaginary-geometry","type":"code","name":"imaginary-geometry","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Kappa=0.5..3, Spread=4..6.2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Kappa","min":0.5,"max":3},{"name":"Spread","min":4,"max":6.2}],"start":[0,2,0.5,4],"measures":{"motion":1.2251,"detail":0.1433,"edges":0.7882,"complexity":1.3379,"coverage":0.353,"colour":0.395,"drift":0.145},"knobResponse":[0.209,0.1565,0.1709,0.1838]},{"slug":"implosion","title":"Implosion","family":"construction","round":26,"note":"새벽 하늘 아래 스무 층 아파트에 장약 섬광이 층마다 타고 내려오면, 탑이 꺾이며 제자리로 주저앉고 회황색 먼지구름이 꼭대기까지 끓어올라요. 타임랩스로 비계 속에 새 탑이 서고, K1 을 누르면 바로 발파해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-implosion","type":"code","name":"implosion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Storeys=20..30, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Storeys","min":20,"max":30},{"name":"Wind","min":-1,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.3241,"detail":0.034,"edges":0.2245,"complexity":1.918,"coverage":0.9298,"colour":0.1876,"drift":0.0773},"knobResponse":[0.3233,0.0558,0.0577,0.0486]},{"slug":"in-the-flash","title":"In the Flash","family":"halloween","round":50,"note":"비 오는 밤 들판에 번개가 칠 때마다 키 크고 마른 형체가 한 걸음씩 가까이 서 있고, 움직이는 모습은 한 번도 보이지 않다가 끝내 얼굴이 눈앞을 채운 뒤 두 눈만 어둠에 남아요. K3 은 비, K4 는 다가오는 걸음 수이고, K1 을 누르면 바로 번개가 쳐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-in-the-flash","type":"code","name":"in-the-flash","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Approach=3..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rain","min":0,"max":1},{"name":"Approach","min":3,"max":8}],"start":[0,2,0,3],"measures":{"motion":0.5508,"detail":0.0144,"edges":0.1675,"complexity":0.2946,"coverage":0.4921,"colour":0.0573,"drift":0.3391},"knobResponse":[0.0339,0.0922,0.0431,0.1198]},{"slug":"incense","title":"Incense","family":"noise","round":15,"note":"향 연기가 실처럼 곧게 오르다 몇 줄 위에서 흔들리고, 곧 소용돌이로 흩어져 위로 퍼져요. 돌탑 위 역류 향꽂이에서는 무거운 연기가 돌을 타고 흘러내려 접시에 고여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-incense","type":"code","name":"incense","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sticks=1..3, Breeze=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sticks","min":1,"max":3},{"name":"Breeze","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2464,"detail":0.0379,"edges":0.3304,"complexity":1.0761,"coverage":0.3311,"colour":0.0945,"drift":0.0442},"knobResponse":[0.0522,0.0616,0.0686,0.0518]},{"slug":"indian-rope-trick","title":"Indian Rope Trick","family":"physics","round":64,"note":"세 마디 막대 사슬이 거꾸로 서서 패널 키를 다 채우고, 눈에 보이지 않을 만큼 작고 빠르게 떨리는 받침점 덕에 쓰러지지 않아요. 몇 초마다 톡 치면 흔들리다 수직으로 돌아오고, Shake 를 문턱 아래로 내리면 넘어져 받침 아래로 휘돌았다가 다시 세워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-indian-rope-trick","type":"code","name":"indian-rope-trick","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Shake=0..3, Links=3..6, Nudge=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Shake","min":0,"max":3},{"name":"Links","min":3,"max":6},{"name":"Nudge","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2513,"detail":0.0187,"edges":0.3205,"complexity":0.452,"coverage":0.145,"colour":0.1218,"drift":0.1037},"knobResponse":[0.0357,0.0881,0.0328,0.1237]},{"slug":"indras-pearls","title":"Indra's Pearls","family":"geometry","round":31,"note":"마스킷 조각의 클라인 군이 그리는 극한 집합이 두 흰 벽 사이로 128줄을 내려가요. 접한 원의 목걸이 사이로 진주가 세대마다 작아지고, μ 가 첨점 사이를 오가며 목이 조였다 풀리고 겹 소용돌이가 감겼다 풀려요. K1 을 누르면 진주가 세대 차례로 켜져요.","why":"패널을 꽉 채우고 고리가 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-indras-pearls","type":"code","name":"indras-pearls","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Zoom","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5032,"detail":0.058,"edges":0.429,"complexity":0.897,"coverage":1,"colour":0.18,"drift":0.2157},"knobResponse":[0.3262,0.2178,0.2586,0.2575]},{"slug":"infinity-series","title":"Infinity Series","family":"rhythm","round":38,"note":"페르 뇌르고르의 무한 수열이 네 줄 피아노 롤에 한 박에 1, 2, 4, 8음으로 떨어져 타격선에 닿아요. 박마다 네 줄이 함께 닿는데, 4음 줄은 1음 줄과 같은 음에, 2음과 8음 줄은 그 거울상에 닿아요. K3 은 한 박의 줄 수를 8 에서 40 으로 늘려 음을 길게 펴고, K4 는 수열의 더 먼 자리에서 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-infinity-series","type":"code","name":"infinity-series","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beat=8..40, Start=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beat","min":8,"max":40},{"name":"Start","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":1.2502,"detail":0.083,"edges":0.4948,"complexity":0.2954,"coverage":0.3381,"colour":0.176,"drift":0.0581},"knobResponse":[0.067,0.12,0.1058,0.141]},{"slug":"ink-traps","title":"Ink Traps","family":"type","round":70,"note":"신문 용지에 같은 글자를 위아래로 찍으면, 이음매에 잉크 트랩을 판 위 글자는 번진 잉크가 홈을 메워 그린 모양으로 남고 트랩 없는 아래 글자는 뾰족한 이음매부터 막혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ink-traps","type":"code","name":"ink-traps","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Letters=0..2, Spread=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Letters","min":0,"max":2},{"name":"Spread","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3084,"detail":0.0349,"edges":0.4938,"complexity":0.7243,"coverage":0.4998,"colour":0.2397,"drift":0.3553},"knobResponse":[0.1557,0.0581,0.1966,0.0911]},{"slug":"invasion-percolation","title":"Invasion Percolation","family":"sim","round":32,"note":"바닥 가운데 한 칸으로 들어온 침입 유체가 경계에서 문턱이 가장 낮은 칸을 하나씩 차지하며 위로 자라요. 차지한 차례대로 청록에서 보라로 물들고, 맨 윗줄과 끊겨 갇힌 방어 유체는 장미색으로 굳어요. 맨 윗줄에 닿으면 입구에서 거기까지 가장 짧은 통로가 금색으로 켜지고 새 문턱으로 다시 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-invasion-percolation","type":"code","name":"invasion-percolation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gravity=-1..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gravity","min":-1,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1366,"detail":0.0909,"edges":0.2189,"complexity":1.5161,"coverage":0.4669,"colour":0.1889,"drift":0.1552},"knobResponse":[0.0576,0.0663,0.1297,0.1267]},{"slug":"inverse-cascade","title":"Inverse Cascade","family":"noise","round":50,"note":"잔 소용돌이 잡음이 2초 만에 둥근 소용돌이로 모이고, 같은 쪽으로 도는 것끼리 감기며 합쳐져 점점 적고 커져요. 붉은 쪽과 남색 쪽이 도는 방향이에요. K3 은 처음 소용돌이의 크기, K4 는 가는 실을 지우는 점성이고, K1 을 누르면 새 잡음에서 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-inverse-cascade","type":"code","name":"inverse-cascade","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=-1..1, Viscosity=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":-1,"max":1},{"name":"Viscosity","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6482,"detail":0.1256,"edges":0.3553,"complexity":2.3404,"coverage":0.9857,"colour":0.3044,"drift":0.0747},"knobResponse":[0.2481,0.168,0.1569,0.1223]},{"slug":"inversions","title":"Inversions","family":"type","round":65,"note":"위아래로 쌓은 두 음절이 판째 반 바퀴 돌면 곰국이 논문으로 읽혀요. 라틴 글자는 MOM 이 WOW 가 되고 SWIMS 는 제자리로 와요","why":"","block":0,"ramped":false,"layer":{"id":"layer-inversions","type":"code","name":"inversions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..8, Weight=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":8},{"name":"Weight","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6508,"detail":0.0532,"edges":0.6361,"complexity":0.386,"coverage":0.3297,"colour":0.3701,"drift":0.2737},"knobResponse":[0.1796,0.2252,0.2528,0.2508]},{"slug":"ishihara-plate","title":"Ishihara Plate","family":"type","round":77,"note":"점으로 채운 판 두 장에 숫자가 제1형과 제2형 혼동선의 색으로 숨어 3초마다 바뀌고, 노브를 돌리면 그 눈에 맞는 판의 숫자가 바탕에 묻혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ishihara-plate","type":"code","name":"ishihara-plate","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Dichromacy=-1..1, Dots=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dichromacy","min":-1,"max":1},{"name":"Dots","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1337,"detail":0.324,"edges":0.9997,"complexity":0.5224,"coverage":0.4414,"colour":0.5708,"drift":0.0417},"knobResponse":[0.0604,0.085,0.1011,0.2438]},{"slug":"ising-interface","title":"Ising Interface","family":"noise","round":45,"note":"왼쪽은 위, 오른쪽은 아래로 붙잡힌 이징 자석이 임계 온도에서 청록과 남색으로 끓고, 바닥에서 꼭대기까지 건너가는 경계 하나가 프레임마다 밝은 실로 그려져요. 그 실을 크게 키우면 SLE(3) 이 되는 프랙털 곡선이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ising-interface","type":"code","name":"ising-interface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Temp=-0.15..0.3, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Temp","min":-0.15,"max":0.3},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.1333,"detail":0.0453,"edges":0.3666,"complexity":0.2595,"coverage":1,"colour":0.2647,"drift":0.0682},"knobResponse":[0.1415,0.1161,0.1525,0.0778]},{"slug":"isospectral-drums","title":"Isospectral Drums","family":"wave","round":39,"note":"모양이 다른 북 두 개가 위아래에서 같은 높이의 소리로 울려요. 반정사각형 일곱 장으로 지은 고든, 웹, 월퍼트의 북이라 고유값이 하나도 다르지 않고, 가운데 띠의 눈금이 그 고유값이에요. 북마다 제 노드선을 그리며 같은 박자로 떨어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-isospectral-drums","type":"code","name":"isospectral-drums","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=0..24, Beat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":0,"max":24},{"name":"Beat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2952,"detail":0.0452,"edges":0.3635,"complexity":0.7651,"coverage":0.3333,"colour":0.1729,"drift":0.0914},"knobResponse":[0.0911,0.0611,0.0587,0.04]},{"slug":"ivy","title":"Ivy","family":"growth","round":15,"note":"돌담을 타고 담쟁이가 꼭대기까지 올라요. 바람이 잎을 뒤집어 옅은 뒷면이 물결치고, 가을이면 잎이 노랑에서 진홍으로 물들어 떨어져요. 겨울에는 맨 줄기에 검푸른 열매가 남아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-ivy","type":"code","name":"ivy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Vines=2..6, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Vines","min":2,"max":6},{"name":"Wind","min":-1,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0893,"detail":0.1136,"edges":0.3366,"complexity":2.0732,"coverage":0.8558,"colour":0.304,"drift":0.0713},"knobResponse":[0.1737,0.0489,0.1412,0.1012]},{"slug":"izhikevich-network","title":"Izhikevich Network","family":"rhythm","round":63,"note":"이지케비치의 신경 세포 천 개가 쏜 스파이크가 2 ms 한 줄씩 위에서 내려와요. 흥분 세포는 하늘색, 억제 세포는 자홍색이고, 망이 함께 터질 때마다 가로 띠가 서서 8 Hz 리듬이 줄무늬로 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-izhikevich-network","type":"code","name":"izhikevich-network","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drive=-1.5..3, Inhibition=0.8..1.6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drive","min":-1.5,"max":3},{"name":"Inhibition","min":0.8,"max":1.6}],"start":[0,2,0,0.8],"measures":{"motion":3.1405,"detail":0.2201,"edges":1,"complexity":0.2115,"coverage":0.1929,"colour":0.2665,"drift":0.2134},"knobResponse":[0.1022,0.1979,0.2345,0.1599]},{"slug":"j-invariant","title":"J-Invariant","family":"fractal","round":29,"note":"클라인의 j 함수를 위 반평면에 칠해요. j 가 위쪽 값으로 보내는 삼각형은 옅은 금색, 아래쪽 값으로 보내는 삼각형은 짙은 파랑이라 같은 타일이 패널 아래 실수축으로 갈수록 잘게 되풀이되고, j 의 크기를 나눈 등고선 띠가 영점마다 흘러나와요. K3 을 돌리면 실수축 쪽으로 여덟 배까지 다가가고, K1 을 누르면 빛이 맨 위 타일부터 세대마다 아래로 번져요.","why":"가장 복잡한 화면 가운데 하나예요(복잡도 2.69).","block":1,"ramped":false,"layer":{"id":"layer-j-invariant","type":"code","name":"j-invariant","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=0..1, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":0,"max":1},{"name":"Bands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3718,"detail":0.0494,"edges":0.1733,"complexity":2.6926,"coverage":1,"colour":0.3996,"drift":0.1786},"knobResponse":[0.3542,0.2406,0.2621,0.0689]},{"slug":"jack-in-the-box","title":"Jack-in-the-Box","family":"halloween","round":51,"note":"주황 마름모를 두른 보라 깡통 상자의 손잡이가 저절로 돌다 뚜껑이 터지면, 용수철 끝의 호박 등 머리가 패널 위까지 솟았다가 출렁이며 흔들리고 천천히 상자로 돌아가 뚜껑이 닫혀요. K3 은 용수철의 단단함, K4 는 옆으로 흔들리는 정도이고, 단추를 누르면 바로 튀어나와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jack-in-the-box","type":"code","name":"jack-in-the-box","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spring=0..1, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spring","min":0,"max":1},{"name":"Wobble","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3939,"detail":0.0355,"edges":0.7221,"complexity":0.2437,"coverage":0.3539,"colour":0.2859,"drift":0.0966},"knobResponse":[0.0607,0.072,0.0508,0.0507]},{"slug":"jack-o-lantern","title":"Jack-o'-Lantern","family":"halloween","round":41,"note":"패널 아래 호박 등 속에서 촛불이 흔들리면 파낸 얼굴이 짙은 주황과 흰빛 사이를 오가며 깜빡여요. 구멍마다 빛줄기가 패널 위까지 뻗는데, 맑은 곳에서는 옅은 보라로 보이고 떠가는 안개 띠를 지날 때는 주황으로 타올라요. K3 은 파낸 얼굴 넷 가운데 하나를 고르고 K4 는 안개를 걷거나 짙게 하며, K1 을 누르면 촛불이 꺼져 얼굴이 숯불 빨강으로 식었다가 2.5초 만에 다시 붙어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jack-o-lantern","type":"code","name":"jack-o-lantern","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fire=0..1, Speed=0.2..3, Face=0..3, Fog=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fire","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Face","min":0,"max":3},{"name":"Fog","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4879,"detail":0.0529,"edges":0.8777,"complexity":0.1426,"coverage":0.6351,"colour":0.3633,"drift":0.1316},"knobResponse":[0.0829,0.1046,0.0764,0.1278]},{"slug":"jacobi-geodesics","title":"Jacobi Geodesics","family":"space","round":65,"note":"세 축이 다른 타원면이 패널 키로 서서 돌고, 배꼽점 하나에서 사방으로 쏜 측지선 36개가 몸을 감싸며 내려가 맞은편 배꼽점 한 점에 다시 모여요","why":"","block":0,"ramped":false,"layer":{"id":"layer-jacobi-geodesics","type":"code","name":"jacobi-geodesics","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Launch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Axes","min":0,"max":1},{"name":"Launch","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5615,"detail":0.0305,"edges":0.2087,"complexity":0.9746,"coverage":0.4731,"colour":0.1408,"drift":0.1338},"knobResponse":[0.0491,0.0811,0.0824,0.0519]},{"slug":"jacobs-ladder","title":"Jacob's Ladder","family":"light","round":6,"note":"두 막대가 가장 가까운 목에서 보랏빛 아크가 튀어, 벌어지는 V 를 타고 막대 끝까지 올라가 끊어져요. 위의 아크가 끝에 닿기 전에 목에서 다음 아크가 튀고, K4 를 올리면 지나간 아크가 사다리 가로대로 쌓여요.","why":"아크는 좋은데 전극이 사물로 같이 그려져요.","block":1,"ramped":false,"layer":{"id":"layer-jacobs-ladder","type":"code","name":"jacobs-ladder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Power=0.3..3, Spread=0..1, Exposure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Power","min":0.3,"max":3},{"name":"Spread","min":0,"max":1},{"name":"Exposure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8103,"detail":0.0208,"edges":0.2771,"complexity":0.702,"coverage":0.2778,"colour":0.0843,"drift":0.105},"knobResponse":[0.0479,0.0767,0.0696,0.0781]},{"slug":"jacquard","title":"Jacquard Loom","family":"textile","round":4,"note":"구멍 뚫린 카드가 한 장씩 내려와 날실을 들어 올리면 북이 씨실을 끌고 지나가고, 바디가 그 씨실을 쳐 넣어요. 아래로 짜여 내려가는 천에 카드 구멍이 적어 둔 다이아몬드가 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-jacquard","type":"code","name":"jacquard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.5..5, Card=1..4, Stripes=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.5,"max":5},{"name":"Card","min":1,"max":4},{"name":"Stripes","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.0063,"detail":0.2005,"edges":0.8201,"complexity":0.1835,"coverage":0.8529,"colour":0.5431,"drift":0.0411},"knobResponse":[0.3764,0.209,0.2197,0.1447]},{"slug":"jamo-assembly","title":"Jamo Assembly","family":"type","round":63,"note":"패널 가장자리에서 날아온 자모가 칸 모양대로 줄거나 늘며 한 블록에 잠겨, 모아쓰기 같은 낱말을 한 글자씩 모아 써요. 조각이 잠길 때마다 블록 옆의 코드 값이 U+AC00 에서 그만큼 올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jamo-assembly","type":"code","name":"jamo-assembly","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Flight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phrase","min":0,"max":7},{"name":"Flight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2782,"detail":0.0466,"edges":0.6988,"complexity":0.2383,"coverage":0.1407,"colour":0.1388,"drift":0.1083},"knobResponse":[0.0383,0.0797,0.2271,0.0529]},{"slug":"jelly","title":"Jelly","family":"physics","round":2,"note":"젤리마다 질량 18개를 용수철과 안쪽 압력으로 묶은 고리예요. 키 큰 병에 떨어져 눌린 채 쌓여 출렁이다가, 하나씩 통 튀어 올라 다른 젤리 위로 굴러떨어져요.","why":"덩어리 넷이 바닥에 쌓여 있는 시간이 길어요.","block":1,"ramped":false,"layer":{"id":"layer-jelly","type":"code","name":"jelly","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Gravity=-1..3, Softness=0..1, Count=4..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Gravity","min":-1,"max":3},{"name":"Softness","min":0,"max":1},{"name":"Count","min":4,"max":12}],"start":[0,2,0,4],"measures":{"motion":0.4127,"detail":0.0345,"edges":0.4341,"complexity":0.5229,"coverage":0.4923,"colour":0.4252,"drift":0.1653},"knobResponse":[0.2349,0.3804,0.1184,0.2314]},{"slug":"jelly-layers","title":"Jelly Layers","family":"cosmetic","round":40,"note":"투명한 젤리 매니큐어를 흰 바탕에 붓으로 한 겹씩 겹쳐 발라, 겹친 곳은 투과율이 곱해져 짙어지고 붓결은 몇 초 만에 평평해져요. 두 번 바르면 한 번은 패드가 가장 짙은 띠를 닦아 내고, 광택 창과 빛 띠는 늘 맨 위에 떠요. K3 은 한 겹의 짙기를 옅은 분홍에서 깊은 라즈베리까지 올리고, K4 는 광택을 무광 베일로 바꾸고, K1 을 누르면 다음 붓질이나 닦기가 바로 와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-jelly-layers","type":"code","name":"jelly-layers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=0.35..1.2, Matte=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":0.35,"max":1.2},{"name":"Matte","min":0,"max":1}],"start":[0,2,0.35,0.06],"measures":{"motion":0.053,"detail":0.0079,"edges":0.0069,"complexity":1.5162,"coverage":1,"colour":0.1911,"drift":0.0385},"knobResponse":[0.1664,0.0692,0.1547,0.0566]},{"slug":"johnson-mehl","title":"Johnson-Mehl","family":"cells","round":37,"note":"결정이 아무 때나 아무 데서 태어나 같은 빠르기로 원처럼 자라고, LED 마다 먼저 닿은 결정의 것이 돼요. 늦게 난 결정은 작고 둥글게 남아서 먼저 난 결정과 곧은 선이 아니라 쌍곡선 호에서 만나고, 한 상이 판을 다 채우면 다음 상이 그 위로 자라요. 위 12줄은 바뀐 몫을 아브라미 곡선과 나란히 그려요. K4 를 1로 돌리면 결정이 한꺼번에 태어나 경계가 곧은 보로노이가 되고, 누르면 다음 상이 바로 시작해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-johnson-mehl","type":"code","name":"johnson-mehl","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rate=4..80, Mode=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rate","min":4,"max":80},{"name":"Mode","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0659,"detail":0.0824,"edges":0.8775,"complexity":0.3635,"coverage":0.9103,"colour":0.4567,"drift":0.1875},"knobResponse":[0.3746,0.1973,0.3888,0.3417]},{"slug":"jordan-curve","title":"Jordan Curve","family":"topology","round":60,"note":"패널을 채운 구불구불한 닫힌 곡선 위로 탐침이 돌아다니며 패널 끝까지 반직선을 쏘고, 곡선을 건넌 곳에 금색 점을 찍어 세요. 그 수가 홀수면 안의 색, 짝수면 밖의 색이 탐침에서부터 번져 안과 밖이 맞물린 두 땅으로 드러나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-jordan-curve","type":"code","name":"jordan-curve","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tension=-1..1, Probes=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tension","min":-1,"max":1},{"name":"Probes","min":1,"max":4}],"start":[0,2,0,1],"measures":{"motion":0.3606,"detail":0.064,"edges":0.5302,"complexity":1.0767,"coverage":1,"colour":0.3592,"drift":0.0786},"knobResponse":[0.2209,0.2847,0.2184,0.1119]},{"slug":"josephus","title":"Josephus Problem","family":"rhythm","round":68,"note":"램프 n 개의 원을 손이 돌며 k 번째 박마다 하나씩 끄고, 아래 64줄 표에서 살아남는 자리가 톱니로 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-josephus","type":"code","name":"josephus","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Step=2..7, Circle=8..64","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Step","min":2,"max":7},{"name":"Circle","min":8,"max":64}],"start":[0,2,2,8],"measures":{"motion":0.2599,"detail":0.0789,"edges":0.7436,"complexity":0.7416,"coverage":0.4479,"colour":0.1382,"drift":0.059},"knobResponse":[0.0716,0.0544,0.1126,0.0634]},{"slug":"joukowsky-airfoil","title":"Joukowsky Airfoil","family":"physics","round":35,"note":"주콥스키 사상으로 원을 지나는 이상 흐름을 날개를 지나는 흐름으로 옮겼어요. 44줄 길이의 날개 위로 1초마다 맨 윗줄에서 놓은 염료 줄이 내려와 앞전의 붉은 정체점에서 갈라지고, 오른쪽 흡입면으로 간 반쪽이 뒷전에 12.6줄 먼저 닿아요. K3 은 받음각을 0도에서 15도로 올려 그 앞섬을 46줄까지 늘리고, K1 을 누르면 순환을 10초 동안 빼서 두 반쪽이 거의 같이 닿아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-joukowsky-airfoil","type":"code","name":"joukowsky-airfoil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Attack=0..15, Camber=0..0.12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Attack","min":0,"max":15},{"name":"Camber","min":0,"max":0.12}],"start":[0,2,0,0.06],"measures":{"motion":1.8048,"detail":0.0682,"edges":0.3096,"complexity":0.7976,"coverage":0.3578,"colour":0.2135,"drift":0.0573},"knobResponse":[0.061,0.1268,0.1391,0.1409]},{"slug":"kac-ring","title":"Kac Ring","family":"rhythm","round":44,"note":"64칸 고리를 도는 공이 표시된 변을 지날 때마다 밝고 어두운 색을 바꿔요. 한 줄이 한 걸음이라 128줄이 꼭 한 주기이고, 가운데 줄에서 고리가 통째로 뒤집혀요. 흰 선은 밝은 공의 몫, 점선은 그 몫이 1/2 로 가라앉는다는 예측이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kac-ring","type":"code","name":"kac-ring","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Marks=3..15, Dark=0..0.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Marks","min":3,"max":15},{"name":"Dark","min":0,"max":0.5}],"start":[0,2,3,0.06],"measures":{"motion":1.8966,"detail":0.1266,"edges":0.9572,"complexity":0.1495,"coverage":0.9688,"colour":0.4319,"drift":0.3012},"knobResponse":[0.2767,0.4506,0.3765,0.3765]},{"slug":"kaleidocycle","title":"Kaleidocycle","family":"space","round":43,"note":"이등변 사면체 여섯 개를 경첩으로 이은 고리가 쉬지 않고 제 몸을 뒤집으며 돌아요. 위 절반은 고리를 앞에서, 아래 절반은 뒤에서 본 모습이라 육각형으로 모인 면이 4분의 1 바퀴마다 금빛, 초록, 하늘색, 자홍 차례로 바뀌고, 가운데 구멍은 세 갈래 별로 열렸다 닫혀요. K3 은 사면체를 정사면체 8 개에서 12 개까지 짝수로 늘려 고리를 넓히고, K4 는 두 그림을 고리 축에서 70도까지 기울여 옆에서 보게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kaleidocycle","type":"code","name":"kaleidocycle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tetrahedra=6..12, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tetrahedra","min":6,"max":12},{"name":"Tilt","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.3713,"detail":0.0425,"edges":0.8245,"complexity":0.146,"coverage":0.4664,"colour":0.3304,"drift":0.1584},"knobResponse":[0.2044,0.1656,0.2092,0.1555]},{"slug":"kaleidoscope","title":"Kaleidoscope","family":"geometry","round":1,"note":"움직이는 선 세 벌이 유리 한 조각을 자르고 거울이 그 조각을 꽃으로 접어요. 조각 사이에 1 LED 검은 납선이 있어요.","why":"색 조각이 잘아서 무늬가 자잘해요.","block":1,"ramped":false,"layer":{"id":"layer-kaleidoscope","type":"code","name":"kaleidoscope","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.1..4, Segments=6..16, Twist=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.1,"max":4},{"name":"Segments","min":6,"max":16},{"name":"Twist","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.9384,"detail":0.1125,"edges":0.4099,"complexity":1.6131,"coverage":0.5499,"colour":0.359,"drift":0.2217},"knobResponse":[0.1659,0.2298,0.1535,0.1426]},{"slug":"kanizsa-letters","title":"Kanizsa Letters","family":"type","round":76,"note":"비스듬한 격자 위의 금빛 원판 32개가 팩맨처럼 돌다 하나씩 제자리로 돌면, 어느 LED 도 그리지 않은 테두리로 글자가 떠올랐다 흩어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kanizsa-letters","type":"code","name":"kanizsa-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gap=0.3..0.8, Period=5..14","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gap","min":0.3,"max":0.8},{"name":"Period","min":5,"max":14}],"start":[0,2,0.3,5],"measures":{"motion":0.1928,"detail":0.2196,"edges":0.9288,"complexity":0.1571,"coverage":0.4377,"colour":0.3466,"drift":0.1178},"knobResponse":[0.1759,0.1493,0.1333,0.0903]},{"slug":"kaprekar-routine","title":"Kaprekar's Routine","family":"type","round":63,"note":"네 자리 수의 숫자가 하나씩 날아와 내림차순으로 앉고, 그 줄이 반 바퀴 돌아 오름차순이 되어 빼져요. 차가 다음 줄이 되어 계산 종이가 아래로 이어지다가 6174 에서 금빛으로 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kaprekar-routine","type":"code","name":"kaprekar-routine","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Digits=4..7, Start=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Digits","min":4,"max":7},{"name":"Start","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.4626,"detail":0.0551,"edges":0.7647,"complexity":0.2265,"coverage":0.1759,"colour":0.1936,"drift":0.1328},"knobResponse":[0.0406,0.0845,0.0634,0.0508]},{"slug":"kari-culik","title":"Kari-Culik Tiles","family":"algo","round":35,"note":"카리의 왕 타일 14장이 되풀이 없이 판을 덮어요. 한 줄이 x 를 2 나 2/3 로 곱하는 긴 곱셈이라 위아래 변에는 비티 숫자가 파랑 마름모로, 옆 변에는 올림수가 초록이나 보라에서 금색까지의 마름모로 이어져요. K3 은 맨 윗줄의 x 를 바꿔 다른 타일링을 깔고, K1 을 누르면 3초 동안 타일이 4분의 1 칸씩 떨어져 한 장씩 보여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-kari-culik","type":"code","name":"kari-culik","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Start=0..1, Size=8..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Start","min":0,"max":1},{"name":"Size","min":8,"max":16}],"start":[0,2,0,8],"measures":{"motion":1.0596,"detail":0.333,"edges":1,"complexity":0.1114,"coverage":0.75,"colour":0.4775,"drift":0.0797},"knobResponse":[0.3661,0.4609,0.2299,0.3929]},{"slug":"karman-street","title":"Kármán Street","family":"sim","round":37,"note":"반대로 도는 점 소용돌이 두 줄이 반 간격씩 어긋난 채 128줄을 위에서 아래로 흘러가요. 왼쪽 줄은 아쿠아, 오른쪽 줄은 장밋빛 염료를 감아 나선을 만들고, 두 줄 사이 거리와 간격의 비가 폰 카르만의 0.2806 이면 거리가 버티며 두 염료가 금색으로 바뀌어요. 처음 비 0.34 에서는 보이지 않던 흔들림이 12~24초 만에 자라 소용돌이가 짝을 지어 흩어지고, 그 뒤에 새 거리가 깔려요. K4 는 그 비를 0.13 에서 0.53 까지 옮기고, 누르면 새 거리를 바로 깔아요.","why":"소용돌이가 작고 어두워요.","block":1,"ramped":false,"layer":{"id":"layer-karman-street","type":"code","name":"karman-street","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Vortices=4..8, Offset=-0.15..0.25","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Vortices","min":4,"max":8},{"name":"Offset","min":-0.15,"max":0.25}],"start":[0,2,4,0.06],"measures":{"motion":0.4917,"detail":0.0363,"edges":0.1472,"complexity":1.3625,"coverage":0.3791,"colour":0.1414,"drift":0.0598},"knobResponse":[0.1029,0.0901,0.0896,0.103]},{"slug":"kdv-solitons","title":"KdV Solitons","family":"wave","round":31,"note":"맨 윗줄이 지금의 물결이고 지난 줄이 아래로 흘러내려요. 자부스키와 크루스칼의 코사인이 반 초 만에 가파라지며 솔리톤 여덟으로 갈리고, 키 큰 솔리톤이 작은 것을 지나칠 때마다 마루가 옆으로 비켜요. K1 을 누르면 큰 솔리톤 하나가 떨어져 무리를 뚫고 달려요.","why":"어두운 바탕에 빛줄기가 엇갈려 지나가요. 잰 값이 프리셋과 두 번째로 가까워요.","block":0,"ramped":false,"layer":{"id":"layer-kdv-solitons","type":"code","name":"kdv-solitons","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dispersion=0..1, Start=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dispersion","min":0,"max":1},{"name":"Start","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5261,"detail":0.0597,"edges":0.2382,"complexity":1.5547,"coverage":0.8045,"colour":0.3345,"drift":0.2583},"knobResponse":[0.2224,0.1099,0.0581,0.2182]},{"slug":"kelvin-wake","title":"Kelvin Wake","family":"wave","round":34,"note":"고요한 물 위로 흰 거품 한 점이 아래에서 위로 올라가고, 그 뒤로 켈빈의 배 물결이 펼쳐져요. 물길을 가로지르는 굽은 가로 물마루와 비스듬한 짧은 발산 물결이 반각 19.47° 쐐기의 두 팔에서 만나 가장 밝은 첨점 줄을 이루고, 쐐기는 원천이 얼마나 빠르든 원천 뒤 90 LED 에서 패널 양옆에 닿아요. K3 은 원천을 빠르게 해 물결을 길게 늘이지만 쐐기의 각은 그대로예요.","why":"패널을 한 색으로 채워요(채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-kelvin-wake","type":"code","name":"kelvin-wake","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Velocity=1..1.7, Patch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Velocity","min":1,"max":1.7},{"name":"Patch","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.1485,"detail":0.0308,"edges":0.1674,"complexity":1.0448,"coverage":0.995,"colour":0.1633,"drift":0.0493},"knobResponse":[0.3266,0.0627,0.0628,0.0605]},{"slug":"kempe-chains","title":"Kempe Chains","family":"cells","round":49,"note":"떠다니는 나라들의 국경이 바뀌어도 지도는 네 색을 지켜요. 새 국경이 같은 색 둘을 붙이면 남은 색을 칠하고, 네 색이 다 둘러싸면 두 색의 켐프 사슬이 빛나며 색을 맞바꿔요. K3 은 나라 수, K4 는 나라 크기가 갈리는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kempe-chains","type":"code","name":"kempe-chains","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Countries=15..40, Sizes=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Countries","min":15,"max":40},{"name":"Sizes","min":0,"max":1}],"start":[0,2,15,0.06],"measures":{"motion":0.4174,"detail":0.06,"edges":0.9672,"complexity":0.091,"coverage":0.9353,"colour":0.6239,"drift":0.0616},"knobResponse":[0.5052,0.3067,0.3719,0.3523]},{"slug":"kettle","title":"Kettle","family":"kitchen","round":20,"note":"밤 부엌 조리대의 유리 전기 주전자가 128줄을 다 써요. 받침의 파란 LED 고리가 물을 밑에서 밝히는 동안 열판의 잔 기포가 떠올랐다 꺼지는 철을 지나 큰 기포가 들끓고, 김이 주둥이에서 패널 꼭대기까지 오르다가 스위치가 딸깍 꺼져요. K1 을 누르면 바로 켜거나 꺼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-kettle","type":"code","name":"kettle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Fill=1..1.7, Cold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fill","min":1,"max":1.7},{"name":"Cold","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2843,"detail":0.0449,"edges":0.2669,"complexity":1.5413,"coverage":0.6281,"colour":0.1671,"drift":0.1681},"knobResponse":[0.1034,0.0699,0.0403,0.056]},{"slug":"kibble-zurek-ions","title":"Kibble-Zurek Ions","family":"particle","round":64,"note":"패널 높이로 선 이온 30개의 사슬이 가로 가둠이 임계값 아래로 내려갈 때마다 지그재그로 꺾여요. 빨리 내릴수록 두 방향의 지그재그가 만나는 꼬임이 더 많이 얼고, 사슬 양옆으로 밀려 나가는 역사에 두 방향이 자홍과 초록으로, 꼬임이 노란 솔기로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kibble-zurek-ions","type":"code","name":"kibble-zurek-ions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Quench=0.2..3, Ions=30..40, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Quench","min":0.2,"max":3},{"name":"Ions","min":30,"max":40},{"name":"Heat","min":0,"max":1}],"start":[0,2,30,0.06],"measures":{"motion":0.5165,"detail":0.2031,"edges":0.9676,"complexity":0.3137,"coverage":0.2809,"colour":0.562,"drift":0.1864},"knobResponse":[0.2692,0.2626,0.2686,0.1597]},{"slug":"kinematogram","title":"Kinematogram","family":"type","round":80,"note":"패널 가득한 무작위 점 가운데 글자 안의 점만 위로, 바깥 점은 아래로 흘러서 어느 한 프레임에도 없는 낱말이 움직일 때만 서고, 점이 1초 멈추면 낱말도 점 사이로 사라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kinematogram","type":"code","name":"kinematogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Coherence=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":7},{"name":"Coherence","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.7154,"detail":0.264,"edges":1,"complexity":0.2447,"coverage":0.2064,"colour":0.1847,"drift":0.0521},"knobResponse":[0.0717,0.214,0.0989,0.2045]},{"slug":"kingfisher","title":"Kingfisher","family":"bird","round":20,"note":"강둑 단면이 오리나무 가지부터 강바닥 자갈까지 128줄을 다 써요. 물총새가 가지에서 머리를 까딱이며 물을 보다가 곧장 내리꽂혀 물보라와 거품 줄을 남기고, 피라미를 물고 올라와 가지에 두드린 뒤 삼켜요. K1 을 누르면 바로 뛰어들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-kingfisher","type":"code","name":"kingfisher","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Fish=6..60, Current=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fish","min":6,"max":60},{"name":"Current","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.0867,"detail":0.0496,"edges":0.2577,"complexity":2.0204,"coverage":0.9952,"colour":0.1732,"drift":0.0377},"knobResponse":[0.186,0.0476,0.0402,0.0555]},{"slug":"kingman-coalescent","title":"Kingman Coalescent","family":"data","round":39,"note":"64개체 모런 집단이 앞으로 살고, 패널은 지금 살아 있는 64개체의 가계도예요. 맨 아랫줄이 지금, 위로 갈수록 과거이고, 같은 조상의 자손이 붙어 서도록 열을 줄 세워서 좁은 블록이 위로 갈수록 합쳐지는 불꽃 그림이 돼요. 마지막 두 갈래가 만나는 데 걸리는 시간이 전체의 절반쯤이라 긴 이음매 하나가 위쪽을 가르고, 한 집안이 사라지면 공통 조상이 앞으로 뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-kingman-coalescent","type":"code","name":"kingman-coalescent","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Span=3..9, Speed=0.2..3, Width=1..4, Mutation=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Span","min":3,"max":9},{"name":"Speed","min":0.2,"max":3},{"name":"Width","min":1,"max":4},{"name":"Mutation","min":0,"max":1}],"start":[3,2,1,0.06],"measures":{"motion":1.2518,"detail":0.0417,"edges":0.3173,"complexity":1.0432,"coverage":0.967,"colour":0.4104,"drift":0.1027},"knobResponse":[0.1845,0.106,0.0643,0.2761]},{"slug":"kintsugi","title":"Kintsugi","family":"pottery","round":25,"note":"어두운 쪽빛 천 위의 청자 찻사발에 금이 가고, 조각들이 조금 벌어져 돌아요. 깨진 날에 붉은 옻과 금이 돈 다음 다시 붙어요. 위에 매달린 종이 등이 흔들리며 금빛 이음매에 반짝임을 지나가게 하고, K3 Mends 를 올릴수록 지나온 깨짐의 금빛 그물이 촘촘해져요. K1 을 누르면 사발이 바로 깨져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-kintsugi","type":"code","name":"kintsugi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glaze=0..1, Speed=0.2..3, Mends=2..8, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glaze","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mends","min":2,"max":8},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.1906,"detail":0.0509,"edges":0.2812,"complexity":2.0844,"coverage":0.9972,"colour":0.1903,"drift":0.136},"knobResponse":[0.0565,0.1068,0.0529,0.1171]},{"slug":"klein-sails","title":"Klein's Sails","family":"number","round":65,"note":"정수 격자가 쌍곡선을 따라 흐르고, 연분수 수렴분수를 꼭짓점 삼은 볼록 껍질 네 줄이 제 몸을 따라 미끄러지다 처음 그림으로 돌아와요","why":"","block":0,"ramped":false,"layer":{"id":"layer-klein-sails","type":"code","name":"klein-sails","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Number=0..5, Zoom=10..22","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":5},{"name":"Zoom","min":10,"max":22}],"start":[0,2,0,10],"measures":{"motion":0.2849,"detail":0.0834,"edges":0.4941,"complexity":1.038,"coverage":0.2246,"colour":0.136,"drift":0.0352},"knobResponse":[0.0458,0.0743,0.1422,0.0944]},{"slug":"knights-tour","title":"Knight's Tour","family":"algo","round":42,"note":"기사가 8×16 판을 Warnsdorff 규칙으로 돌며 칸 가운데를 잇는 한 LED 선을 남기고, 127번 뛰면 별 같은 그물이 다 짜여요. 마지막 칸에서 첫 칸으로 한 번에 뛸 수 있으면 금빛 선으로 닫히고, 아니면 두 끝 칸에 금빛 상자가 서요. K4 를 0.1 위로 돌리면 기사가 규칙을 어기고 아무 칸으로나 뛰다가 막혀서, 막힌 칸이 빨갛게 깜빡여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-knights-tour","type":"code","name":"knights-tour","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..12, Board=0..1, Stray=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":12},{"name":"Board","min":0,"max":1},{"name":"Stray","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.029,"detail":0.3132,"edges":0.848,"complexity":0.6559,"coverage":0.3475,"colour":0.3541,"drift":0.0377},"knobResponse":[0.1789,0.0496,0.2163,0.1825]},{"slug":"koebe-packing","title":"Koebe Packing","family":"cells","round":47,"note":"원마다 삼각분할의 이웃 원과만 맞닿은 세로 직사각형 원 배치예요. 1.2초마다 변이 뒤집히거나 원이 생기고 사라지면, 모든 원이 새 그래프가 허락하는 하나뿐인 배치로 부풀고 줄어들고 새 변이 흰빛으로 번쩍여요. K3 은 원 수, K4 는 그래프를 어두운 살로 보일지 흰 선으로 보일지예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-koebe-packing","type":"code","name":"koebe-packing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Circles=22..56, Graph=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Circles","min":22,"max":56},{"name":"Graph","min":0,"max":1}],"start":[0,2,22,0.06],"measures":{"motion":0.2073,"detail":0.1313,"edges":0.7425,"complexity":0.2586,"coverage":0.4982,"colour":0.5525,"drift":0.0981},"knobResponse":[0.3319,0.0922,0.2901,0.201]},{"slug":"kohonen-map","title":"Kohonen Map","family":"data","round":59,"note":"무작위로 엉킨 12×24 격자가 점 하나가 올 때마다 그쪽으로 끌려가며 하늘색에서 자홍으로 물든 천처럼 고리, 초승달, S 위에 펴져요. Lattice 노브를 끝까지 돌리면 288마디 사슬이 고리를 이리저리 접어 메워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kohonen-map","type":"code","name":"kohonen-map","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lattice=0..1, Radius=0.5..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lattice","min":0,"max":1},{"name":"Radius","min":0.5,"max":3}],"start":[0,2,0,0.5],"measures":{"motion":3.6399,"detail":0.0917,"edges":0.9607,"complexity":0.9588,"coverage":0.4369,"colour":0.2844,"drift":0.1914},"knobResponse":[0.0676,0.2116,0.1362,0.0924]},{"slug":"kolakoski","title":"Kolakoski","family":"number","round":35,"note":"제 런 길이 부호와 같은 1 과 2 의 수열이 열 단의 고드름으로 매달려요. 맨 아래 단은 3,000번 항부터 64항이 LED 하나씩 금색 1 과 보라 2 로 서고, 그 위 단마다 아래 단의 런을 만든 항이 런 너비로 앉아 같은 수열이 단마다 3분의 2 로 줄며 왼쪽으로 한 항씩 흘러요. K3 은 단을 16 까지 늘리고, K1 을 누르면 창이 10만 항 뒤로 건너뛰어 맨 위 눈금이 1 이 4 개 앞선 자리에서 2 가 46 개 앞선 자리로 옮겨요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-kolakoski","type":"code","name":"kolakoski","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bands=10..16, Falloff=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bands","min":10,"max":16},{"name":"Falloff","min":-1,"max":1}],"start":[0,2,10,0.06],"measures":{"motion":0.3357,"detail":0.1184,"edges":0.9202,"complexity":0.2363,"coverage":0.9144,"colour":0.3543,"drift":0.0962},"knobResponse":[0.3404,0.1812,0.286,0.2965]},{"slug":"kp-web","title":"KP Web","family":"wave","round":58,"note":"가는 빛줄기로 그린 KP 방정식의 선 솔리톤이 9초에 한 번씩 시간을 지나며, T 웹의 상자가 한쪽에 키 큰 줄기를 단 채 오므라들어 X 하나가 됐다가 반대쪽으로 다시 열려요. 쓸기마다 Gr(2,5) 와 Gr(3,6) 의 구멍 난 웹, Y, 두 가지 X 로 넘어가고, 색은 선의 높이를 따라 보라에서 물빛으로 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kp-web","type":"code","name":"kp-web","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Type=0..6, Angle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Type","min":0,"max":6},{"name":"Angle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1152,"detail":0.025,"edges":0.1986,"complexity":0.2838,"coverage":0.1749,"colour":0.115,"drift":0.1113},"knobResponse":[0.0354,0.0783,0.0683,0.0659]},{"slug":"kruskal-count","title":"Kruskal Count","family":"line","round":75,"note":"섞은 카드 52장을 뱀 꼴로 깔고 첫 열 장에서 저마다 색을 띤 사슬이 카드 값만큼 뛰어 내려가다 만나면 하나로 합쳐 하얘지고, 끝에 닿은 카드를 크게 뒤집어 보인 뒤 다시 섞어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-kruskal-count","type":"code","name":"kruskal-count","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Court=5..10, Decks=1..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Court","min":5,"max":10},{"name":"Decks","min":1,"max":2}],"start":[0,2,5,1],"measures":{"motion":0.2797,"detail":0.1131,"edges":0.6218,"complexity":0.2727,"coverage":0.5988,"colour":0.1947,"drift":0.1528},"knobResponse":[0.0605,0.094,0.0421,0.1573]},{"slug":"kuramoto-sivashinsky","title":"Kuramoto-Sivashinsky","family":"noise","round":37,"note":"쿠라모토-시바신스키 방정식을 패널 폭만 한 고리에서 한 열에 격자점 하나씩 풀고, 새 순간이 맨 위로 들어와 아래로 흘러서 128줄이 시공간 그림이 돼요. u 가 양인 청록 줄기와 음인 자홍 줄기가 흔들리고 갈라지고 합쳐지며 땋이고, u 가 0을 지나는 곳은 검게 비어요. K3 은 고리 길이를 22에서 66으로 늘려 두 줄기를 일곱 줄기로 만들고, K4 의 분산 항은 혼돈을 한쪽으로 기우는 펄스 열로 가라앉혀요. 누르면 앞면이 한 군데 패여요.","why":"청록과 자홍 줄이 쉬지 않고 꿈틀대요. 0718 의 굵은 줄무늬와 가까워요.","block":0,"ramped":false,"layer":{"id":"layer-kuramoto-sivashinsky","type":"code","name":"kuramoto-sivashinsky","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=22..66, Dispersion=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":22,"max":66},{"name":"Dispersion","min":-1,"max":1}],"start":[0,2,22,0.06],"measures":{"motion":2.1967,"detail":0.0813,"edges":0.1461,"complexity":1.9024,"coverage":0.8129,"colour":0.4992,"drift":0.2147},"knobResponse":[0.3397,0.3051,0.3397,0.3324]},{"slug":"lace-phantom","title":"Lace Phantom","family":"halloween","round":44,"note":"깨진 창의 레이스 커튼이 밤바람에 부풀고, 이따금 그 뒤에서 눈구멍과 벌린 입을 단 얼굴이 눌러 왔다가 가라앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lace-phantom","type":"code","name":"lace-phantom","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lace=-1..1, Haunt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lace","min":-1,"max":1},{"name":"Haunt","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3687,"detail":0.3103,"edges":0.1979,"complexity":0.4605,"coverage":0.5576,"colour":0.1002,"drift":0.0392},"knobResponse":[0.0592,0.1091,0.1119,0.0436]},{"slug":"laguerre-cells","title":"Laguerre Cells","family":"cells","round":70,"note":"점마다 무게를 단 파워 다이어그램을 뉴턴 걸음이 고쳐, 세 봉우리로 몰린 밀도를 칸마다 같은 질량으로 나눌 때까지 곧은 변이 미끄러지고, 넘친 칸은 보라로, 모자란 칸은 초록으로 기울어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-laguerre-cells","type":"code","name":"laguerre-cells","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cells=24..64, Contrast=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cells","min":24,"max":64},{"name":"Contrast","min":-1,"max":1}],"start":[0,2,24,0.06],"measures":{"motion":0.1532,"detail":0.0355,"edges":0.3566,"complexity":1.5636,"coverage":1,"colour":0.2106,"drift":0.1873},"knobResponse":[0.1902,0.1518,0.091,0.0662]},{"slug":"lakes-of-wada","title":"Lakes of Wada","family":"topology","round":34,"note":"섬 안의 두 호수와 바다가 차례로 1 LED 운하를 파요. 마른 땅이 파는 물에서 32, 16, 8, … LED 안에 들 때까지 차례마다 거리를 반으로 줄여 파고 서로 다른 물은 끝내 닿지 않아서, 다 판 섬은 하늘색 바다와 분홍, 연두 호수 사이에 가는 땅 벽만 남은 미로가 돼요. K3 은 호수를 다섯까지 늘리고, K1 을 누르면 섬이 잠기고 새 섬이 솟아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-lakes-of-wada","type":"code","name":"lakes-of-wada","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lakes=3..5, Wander=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lakes","min":3,"max":5},{"name":"Wander","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0225,"detail":0.2272,"edges":1,"complexity":0.1697,"coverage":0.5713,"colour":0.6325,"drift":0.1351},"knobResponse":[0.4015,0.1136,0.142,0.1216]},{"slug":"lambda-diagrams","title":"Lambda Diagrams","family":"line","round":74,"note":"처치 수 셈이 트롬프의 람다 그림으로 서서 정규 차례 베타 줄이기를 한 걸음씩 밟고, 끝에서 셈한 수만큼 이가 난 빗이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lambda-diagrams","type":"code","name":"lambda-diagrams","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Expression=0..6, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Expression","min":0,"max":6},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1651,"detail":0.0318,"edges":0.3577,"complexity":0.1912,"coverage":0.1656,"colour":0.1645,"drift":0.1598},"knobResponse":[0.0742,0.1781,0.2071,0.1108]},{"slug":"lamellar-cream","title":"Lamellar Cream","family":"cosmetic","round":40,"note":"크림을 직교 편광 현미경으로 본 그림이에요. 검은 바탕에서 라멜라 방울이 패널 위로 흐르며 맞붙고 가끔 합쳐지고, 방울마다 편광자 축을 따른 검은 몰타 십자와 간섭색을 띠며 큰 방울은 색 고리를 둘러요. K3 은 방울을 키워 2차의 파랑과 초록 고리를 꺼내고, K4 는 편광자 쌍을 돌려 십자를 방울이 아니라 편광자를 따라 돌게 해요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-lamellar-cream","type":"code","name":"lamellar-cream","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Turn=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Turn","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.582,"detail":0.1784,"edges":0.6166,"complexity":2.1131,"coverage":0.5915,"colour":0.1927,"drift":0.1439},"knobResponse":[0.0935,0.3456,0.3319,0.267]},{"slug":"langford-pairs","title":"Langford Pairs","family":"number","round":69,"note":"패널 높이의 블록 탑에 랭퍼드의 짝이 큰 것부터 놓였다 빠지며 짝마다 옆의 호로 이어지고, 찾은 배열은 왼쪽 선반으로 비켜나 5 LED 너비 탑으로 줄지어 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-langford-pairs","type":"code","name":"langford-pairs","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pairs=7..12, Rule=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pairs","min":7,"max":12},{"name":"Rule","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.9304,"detail":0.0961,"edges":0.7609,"complexity":0.3157,"coverage":0.3813,"colour":0.2873,"drift":0.2678},"knobResponse":[0.0993,0.126,0.1333,0.1042]},{"slug":"lantern-procession","title":"Lantern Procession","family":"halloween","round":46,"note":"등을 든 두건 행렬이 검은 밤의 언덕길을 올라 꼭대기 안개로 사라지고, 가끔 등이 꺼지면 초록 유령 등이 그 자리를 이어 걸어요. K3 은 걷는 사람 수, K4 는 안개이고, K1 을 누르면 등 하나가 유령 등이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lantern-procession","type":"code","name":"lantern-procession","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Walkers=8..24, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Walkers","min":8,"max":24},{"name":"Fog","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.1484,"detail":0.0104,"edges":0.0402,"complexity":0.4978,"coverage":0.2229,"colour":0.096,"drift":0.048},"knobResponse":[0.0444,0.04,0.0828,0.0659]},{"slug":"lap-pool","title":"Lap Pool","family":"sport","round":21,"note":"야외 25 m 수영장을 바로 위에서 내려다본 그림이 128줄을 다 써요. 색 수모를 쓴 사람들이 레인마다 제 속도로 오가다 벽에서 플립 턴을 하고, 뒤로 퍼지는 V자 물결이 빨강·하양·파랑 레인 로프를 흔들어요. 타일 바닥에는 햇빛이 만든 물결 그물이 흘러요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-lap-pool","type":"code","name":"lap-pool","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stroke=0..3, Speed=0.2..3, Swimmers=4..15, Sun=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stroke","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Swimmers","min":4,"max":15},{"name":"Sun","min":-1,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.3073,"detail":0.1425,"edges":0.4977,"complexity":2.1556,"coverage":0.9906,"colour":0.3817,"drift":0.0257},"knobResponse":[0.044,0.0596,0.0629,0.1105]},{"slug":"laser-speckle","title":"Laser Speckle","family":"noise","round":59,"note":"무작위 위상을 채운 동공의 푸리에 변환이 끓는 얼룩이 되고, 밝기는 위상자 합의 크기, 색은 그 위상이라 어두운 점마다 색이 한 바퀴 돌아요. 위쪽 창의 동공이 원판, 고리, 바늘구멍 둘로 바뀌면 알갱이 꼴도 바뀌고, 아래 막대가 e^-I 곡선을 따라가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-laser-speckle","type":"code","name":"laser-speckle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pupil=5..14, Looks=1..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pupil","min":5,"max":14},{"name":"Looks","min":1,"max":8}],"start":[0,2,5,1],"measures":{"motion":0.2295,"detail":0.0749,"edges":0.1897,"complexity":2.4913,"coverage":0.7139,"colour":0.3145,"drift":0.1505},"knobResponse":[0.1903,0.1794,0.1574,0.2263]},{"slug":"lattice-reduction","title":"Lattice Reduction","family":"geometry","round":72,"note":"흰 격자점은 그대로 선 채 가늘고 긴 평행사변형 타일이 b1 을 따라 미끄러지고 두 화살이 자리를 바꾸며, 짧고 곧은 기저의 타일로 줄어들어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lattice-reduction","type":"code","name":"lattice-reduction","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Skew=3..7, Spacing=11..22","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Skew","min":3,"max":7},{"name":"Spacing","min":11,"max":22}],"start":[0,2,3,11],"measures":{"motion":0.4963,"detail":0.0878,"edges":0.4751,"complexity":1.1062,"coverage":1,"colour":0.3582,"drift":0.1988},"knobResponse":[0.3456,0.1564,0.1665,0.161]},{"slug":"lava-lake","title":"Lava Lake","family":"volcano","round":27,"note":"화구 가장자리에서 용암 호수를 곧장 내려다봐요. 검은 지각 판들이 노랗게 벌어진 확장 균열에서 떨어져 나와 변환 단층을 끼고 위아래로 흘러가다, 계단진 화구 벽 밑에서 밝은 이음매를 그으며 가라앉아요. K1 은 틈을 주황 용암 강으로 넓히고, 누르면 큰 가스 거품이 터져 용암을 튀겨요.","why":"갈라진 용암 결이 잘고 느려요.","block":1,"ramped":false,"layer":{"id":"layer-lava-lake","type":"code","name":"lava-lake","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Heat=0..1, Speed=0.2..3, Plates=0..1, Spatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Heat","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Plates","min":0,"max":1},{"name":"Spatter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2026,"detail":0.1176,"edges":0.3894,"complexity":2.2223,"coverage":0.271,"colour":0.2444,"drift":0.0498},"knobResponse":[0.229,0.0729,0.0899,0.0472]},{"slug":"lava-lamp","title":"Lava Lamp","family":"sim","round":3,"note":"전구 위 웅덩이에서 데워진 왁스가 목을 늘이며 떨어져 나와 방울로 떠오르고, 위에서 식으면 다시 가라앉아요. 파란 물속에서 식은 왁스는 주황, 뜨거운 왁스는 노랑이에요.","why":"느리고 패널을 꽉 채워요(움직임 0.11, 채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-lava-lamp","type":"code","name":"lava-lamp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Heat=0.3..3, Wax=4..10, Stretch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Heat","min":0.3,"max":3},{"name":"Wax","min":4,"max":10},{"name":"Stretch","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.1138,"detail":0.0147,"edges":0.1844,"complexity":1.5488,"coverage":1,"colour":0.5657,"drift":0.068},"knobResponse":[0.5599,0.1621,0.1504,0.0519]},{"slug":"leaf-devil","title":"Leaf Devil","family":"halloween","round":43,"note":"보랏빛 밤 패널 발치에 주황과 노랑 낙엽이 더미로 쌓여 있다가, 회오리가 일어 잎을 끌어모아 128줄 높이의 흔들리는 깔때기로 감아올려요. 잎은 돌며 뒤집힐 때마다 반짝이고, 회오리가 흩어지면 지그재그로 팔랑이며 내려와 새 더미가 돼요. K3 은 잎을 150장에서 300장으로 늘리고, K4 는 옆바람으로 깔때기 꼭대기를 오른쪽으로 20 LED 까지 눕혀요. K1 을 누르면 돌풍이 더미를 한꺼번에 날려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-leaf-devil","type":"code","name":"leaf-devil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Leaves=150..300, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Leaves","min":150,"max":300},{"name":"Wind","min":0,"max":1}],"start":[0,2,150,0.06],"measures":{"motion":1.0577,"detail":0.0392,"edges":0.7479,"complexity":0.8004,"coverage":0.8864,"colour":0.2098,"drift":0.0706},"knobResponse":[0.097,0.0601,0.0795,0.0373]},{"slug":"leapfrogging-vortices","title":"Leapfrogging Vortices","family":"sim","round":53,"note":"두 연기 고리를 축을 지나는 단면으로 봐서, 고리마다 반대로 도는 염료 나선 한 쌍이 보여요. 뒤 고리가 좁아지며 앞 고리 사이로 빠르게 빠져나가 앞서고, 앞 고리는 넓어지며 느려져 뒤로 처지기를 되풀이하며 위로 올라가요. K3 은 작은 고리가 지나는 순간의 두 고리 너비 비로, 러브의 문턱 5.83 을 넘으면 한 번 빠져나간 고리가 돌아오지 않아요. K4 는 고리에 실린 염료의 양이고, 단추를 누르면 두 고리에 새 염료를 입혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-leapfrogging-vortices","type":"code","name":"leapfrogging-vortices","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=3..8, Dye=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":3,"max":8},{"name":"Dye","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.942,"detail":0.0667,"edges":0.336,"complexity":2.2701,"coverage":0.2487,"colour":0.1385,"drift":0.0843},"knobResponse":[0.0413,0.1192,0.1292,0.0656]},{"slug":"lempel-ziv","title":"Lempel-Ziv","family":"type","round":79,"note":"LZ77 부호기가 「잭이 지은 집」을 읽어 가며 앞에서 가장 길게 겹치는 구절을 비추고 그 거리의 색으로 베껴 와서, 쪽이 흰 새 글자와 절마다 하나씩 긴 색 띠로 짜여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lempel-ziv","type":"code","name":"lempel-ziv","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Window=0..1, Text=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Window","min":0,"max":1},{"name":"Text","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.2545,"detail":0.2062,"edges":0.9724,"complexity":0.1841,"coverage":0.3019,"colour":0.2708,"drift":0.2873},"knobResponse":[0.0321,0.106,0.0394,0.0733]},{"slug":"lensed-page","title":"Lensed Page","family":"type","round":82,"note":"뉴턴 『광학』의 첫 물음이 3×5 대문자로 패널을 타고 올라가며 가운데의 보이지 않는 점 질량을 지나고, 줄은 그 둘레로 휘며, 가까운 글자는 아인슈타인 고리 밖과 안에 두 번 서고 바로 뒤의 글자는 고리로 번져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lensed-page","type":"code","name":"lensed-page","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mass=13..29, Drift=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mass","min":13,"max":29},{"name":"Drift","min":0,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":0.8247,"detail":0.1634,"edges":0.6599,"complexity":1.4694,"coverage":0.4817,"colour":0.1723,"drift":0.0975},"knobResponse":[0.1406,0.1995,0.195,0.1699]},{"slug":"letter-melt","title":"Letter Melt","family":"type","round":69,"note":"MELT, 물, FLOW, 녹다, DRIP 이 보이지 않는 거푸집에 담긴 물로 위에 서 있다가, 거푸집이 글자 발끝부터 놓아 주면 획이 늘어지고 방울져 패널 끝까지 흘러내려 바닥에 고이고, 웅덩이에서 실줄기가 빨려 올라가 다음 낱말을 글자 위부터 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-melt","type":"code","name":"letter-melt","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":5},{"name":"Heat","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9629,"detail":0.0444,"edges":0.4857,"complexity":0.621,"coverage":0.2681,"colour":0.1863,"drift":0.1581},"knobResponse":[0.0856,0.1246,0.095,0.1458]},{"slug":"letter-mobile","title":"Letter Mobile","family":"type","round":75,"note":"네 글자 낱말을 잉크만큼 무게로 단 콜더식 모빌이 패널 높이로 걸려 돌고, 한 글자씩 바뀔 때마다 그 위 막대들이 기울었다가 고리를 새 균형점으로 옮겨 다시 수평이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-mobile","type":"code","name":"letter-mobile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..2, Sway=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":2},{"name":"Sway","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1522,"detail":0.0235,"edges":0.3907,"complexity":0.7374,"coverage":0.9749,"colour":0.164,"drift":0.0839},"knobResponse":[0.0654,0.0679,0.0606,0.0751]},{"slug":"letter-retracts","title":"Letter Retracts","family":"type","round":82,"note":"세로로 쌓은 굵은 대문자 셋이 구멍을 열지도 닫지도 않고 한 겹씩 뼈대로 가늘어진 뒤 끝을 한 LED 씩 잃어, 구멍 없는 글자는 한 점, 구멍 하나는 고리, 구멍 둘은 고리 둘로 줄고, 그 점과 고리에서 구멍 수가 같은 다음 낱말이 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-retracts","type":"code","name":"letter-retracts","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Set","min":0,"max":3},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0383,"detail":0.0453,"edges":0.9043,"complexity":0.0998,"coverage":0.3422,"colour":0.1312,"drift":0.0903},"knobResponse":[0.0576,0.1105,0.0857,0.0821]},{"slug":"letter-sand","title":"Letter Sand","family":"type","round":64,"note":"모래알로 지은 굵은 네 글자 낱말이 세로로 서 있다가 아래 글자부터 무너지고, 쌓인 더미는 글자 색 차례대로 층을 이뤄요. 더미에 팬 구덩이에서 가는 모래 기둥이 솟아 ROCK, SAND, DUNE, DUST, SILT, LOAM 가운데 다음 낱말을 다시 쌓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-letter-sand","type":"code","name":"letter-sand","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grain=1..3, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grain","min":1,"max":3},{"name":"Wind","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.2963,"detail":0.0685,"edges":0.4843,"complexity":0.588,"coverage":0.1953,"colour":0.2881,"drift":0.2333},"knobResponse":[0.1063,0.097,0.1513,0.0369]},{"slug":"levy-dust","title":"Lévy Dust","family":"fractal","round":76,"note":"레비 비행이 1초에 3,000 번 떨어뜨린 먼지를 전체, 4배, 16배 세 층으로 나란히 세워, 무리 속의 무리가 어느 배율에서나 닮아 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-levy-dust","type":"code","name":"levy-dust","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tail=-1..1, Cut=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tail","min":-1,"max":1},{"name":"Cut","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9403,"detail":0.1026,"edges":0.7373,"complexity":0.7366,"coverage":0.217,"colour":0.2073,"drift":0.1125},"knobResponse":[0.0655,0.0998,0.1629,0.1741]},{"slug":"lichtenberg","title":"Lichtenberg","family":"fractal","round":26,"note":"소다물을 바른 단풍나무 판의 위아래 전극에서 깃털 잔가지를 단 프랙탈 나무가 파란 플라스마와 주황 불씨를 달고 서로를 향해 타 들어가고, 만나면 아크가 번쩍여요. K1 이 판의 나무를 바꾸고, 누르면 다음 판이에요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-lichtenberg","type":"code","name":"lichtenberg","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wood=0..1, Speed=0.2..3, Pull=1..4, Lead=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wood","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pull","min":1,"max":4},{"name":"Lead","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2052,"detail":0.13,"edges":0.3965,"complexity":2.6118,"coverage":0.9587,"colour":0.1893,"drift":0.2406},"knobResponse":[0.4635,0.1257,0.0391,0.0652]},{"slug":"life","title":"Life","family":"automata","round":1,"note":"같은 여덟 이웃에 법칙이 여섯이에요. 세포가 나이만큼 색을 입어서 법칙마다 무엇이 남는지 보여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-life","type":"code","name":"life","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..4, Rule=0..5, Ghosts=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":4},{"name":"Rule","min":0,"max":5},{"name":"Ghosts","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6935,"detail":0.1138,"edges":0.7121,"complexity":0.3343,"coverage":0.2193,"colour":0.2429,"drift":0.1393},"knobResponse":[0.1027,0.1531,0.303,0.0806]},{"slug":"liftoff","title":"Liftoff","family":"flight","round":22,"note":"새벽 물 건너 발사대에서 로켓이 하얀 산소 김을 흘리며 서 있다가 김구름 속에 불을 붙이고 솟아올라요. 카메라가 따라 고개를 들면 하늘이 파랑에서 별 뜬 검정으로 바뀌고, Max-Q 와 단 분리를 지나 밝은 점이 되면 새 로켓이 발사대에 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-liftoff","type":"code","name":"liftoff","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Rocket=0..3, Speed=0.2..3, Stages=1..3, Time=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Rocket","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Stages","min":1,"max":3},{"name":"Time","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3231,"detail":0.0267,"edges":0.3728,"complexity":1.8839,"coverage":0.9986,"colour":0.2838,"drift":0.1066},"knobResponse":[0.0489,0.062,0.0431,0.4667]},{"slug":"lights-out","title":"Lights Out","family":"algo","round":75,"note":"패널 크기의 라이츠 아웃 판을 빛 쫓기로 풀어서, 앞선 줄이 내려가며 호박색 불을 하늘색 누르기 기록으로 바꾸고, 맨 윗줄을 고친 두 번째 쫓기가 마지막 불을 끄면 판을 만든 누르기가 그대로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lights-out","type":"code","name":"lights-out","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cells=1..4, Record=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cells","min":1,"max":4},{"name":"Record","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.4263,"detail":0.3224,"edges":0.9529,"complexity":0.2538,"coverage":0.4703,"colour":0.3017,"drift":0.3986},"knobResponse":[0.2462,0.3606,0.2654,0.1462]},{"slug":"linotype","title":"Linotype","family":"type","round":80,"note":"놋쇠 매트릭스가 채널에서 하나씩 떨어져 벨트를 타고 어셈블러에 줄을 이루고, 스페이스밴드가 올라가 줄을 폭에 맞추면 쇳물을 부어 뜬 거울 글자 슬러그가 갤리에 쌓이고, 매트릭스는 꼭대기 분배 막대를 따라 제 채널로 돌아가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-linotype","type":"code","name":"linotype","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Measure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Measure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.1742,"detail":0.1204,"edges":0.8979,"complexity":0.1321,"coverage":0.456,"colour":0.1182,"drift":0.1084},"knobResponse":[0.0448,0.1397,0.1196,0.1254]},{"slug":"lip-gloss","title":"Lip Gloss","family":"cosmetic","round":31,"note":"맑은 글로스가 위에서 부어져 옅은 벽을 타고 흘러내리고, 앞머리가 길이 다른 방울 줄기로 갈라져 끝마다 빛 한 점을 문 구슬이 맺혀요. 바닥에 닿은 구슬은 떨어지고 글로스는 얇아지며 맑아져요. K1 은 색상환을 다 돌고, 누르면 위에 새로 부어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-lip-gloss","type":"code","name":"lip-gloss","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pour=0..1, Shimmer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pour","min":0,"max":1},{"name":"Shimmer","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0402,"detail":0.004,"edges":0.0558,"complexity":1.0787,"coverage":1,"colour":0.1859,"drift":0.0271},"knobResponse":[0.1707,0.0957,0.1771,0.0458]},{"slug":"littlewood-roots","title":"Littlewood Roots","family":"fractal","round":31,"note":"계수가 다 ±1 인 13차 다항식 8192개의 근 106,496개가 단위원 둘레에 옅은 레이스로 번지고, 1의 거듭제곱근 자리마다 구멍이 나요. 그레이 부호로 계수 하나씩 뒤집는 지금 다항식의 근이 불티로 옮겨 다니며 레이스를 다시 밝혀요. K1 을 누르면 단위원이 번쩍여요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-littlewood-roots","type":"code","name":"littlewood-roots","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Degree=13..16, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Degree","min":13,"max":16},{"name":"Glow","min":0,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":0.2172,"detail":0.0303,"edges":0.1403,"complexity":0.6238,"coverage":0.2539,"colour":0.1322,"drift":0.0228},"knobResponse":[0.0566,0.0256,0.0365,0.0521]},{"slug":"loewner-trace","title":"Loewner Trace","family":"line","round":28,"note":"브라운 운동이 모는 슈람-뢰브너 곡선이 패널만 한 골짜기를 기어오르고, 그 곡선을 푸는 등각 사상의 격자가 곡선 끝을 돌아 휘어요. 화면은 곡선을 따라 끝없이 위로 흘러가요. K3 이 κ 를 4 에서 8 까지 올리면 곡선이 제 몸과 벽에 닿아 가둔 땅을 삼키고, 8 에서는 다 메워요. 누르면 새 브라운 경로로 다시 자라요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-loewner-trace","type":"code","name":"loewner-trace","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Kappa=4..8, Trace=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Kappa","min":4,"max":8},{"name":"Trace","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":2.6307,"detail":0.0738,"edges":0.5207,"complexity":1.219,"coverage":0.8893,"colour":0.2244,"drift":0.1264},"knobResponse":[0.1533,0.1433,0.1845,0.1423]},{"slug":"lonely-runner","title":"Lonely Runner","family":"rhythm","round":47,"note":"위아래로 이은 128줄 트랙에서 주자마다 제 레인을 정수 빠르기로 달리고, 위아래 128/k 줄 안에 아무도 없으면 그 구역이 밝아지고 막대가 하얗게 달아올라요. 처음 셋은 1, 2, 3 으로 달려서 경주마다 1.8초와 3.6초에 한꺼번에 외로워져요. K3 은 주자 수, K4 는 빠르기를 흩는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lonely-runner","type":"code","name":"lonely-runner","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Runners=3..8, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Runners","min":3,"max":8},{"name":"Scatter","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":1.2637,"detail":0.0251,"edges":0.4032,"complexity":0.3563,"coverage":0.4516,"colour":0.303,"drift":0.2999},"knobResponse":[0.1637,0.2381,0.1916,0.1739]},{"slug":"long-division","title":"Long Division","family":"type","round":65,"note":"1 을 소수로 나누는 손 나눗셈이 세로셈 계단으로 내려가다, 나머지가 처음 수로 돌아오면 금빛이 되고 순환마디 위에 선이 그어져요","why":"","block":0,"ramped":false,"layer":{"id":"layer-long-division","type":"code","name":"long-division","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Divisor=7..97, Base=10..16","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Divisor","min":7,"max":97},{"name":"Base","min":10,"max":16}],"start":[0,2,7,10],"measures":{"motion":0.1327,"detail":0.0878,"edges":0.6993,"complexity":0.389,"coverage":0.1396,"colour":0.1965,"drift":0.0965},"knobResponse":[0.0464,0.0616,0.082,0.0645]},{"slug":"longcase-clock","title":"Longcase Clock","family":"time","round":18,"note":"촛불 켠 밤 방에 128줄을 다 쓰는 괘종시계가 서 있어요. 줄의 유리문 안에서 황동 추가 1초에 한 번씩 흔들리고 무게추가 내려가며, 다이얼 아치의 달 원판이 돌고, 정시마다 꼭대기 종이 번쩍이며 울려요. K3 을 돌리면 촛불이 시계 왼쪽에서 앞을 지나 오른쪽으로 옮겨 가고, 벽에 진 그림자가 반대쪽으로 넘어가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-longcase-clock","type":"code","name":"longcase-clock","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wood=0..1, Speed=0..3, Candle=0..1, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wood","min":0,"max":1},{"name":"Speed","min":0,"max":3},{"name":"Candle","min":0,"max":1},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.144,"detail":0.0765,"edges":0.4175,"complexity":2.1824,"coverage":0.9202,"colour":0.2877,"drift":0.0825},"knobResponse":[0.0907,0.1391,0.1097,0.2042]},{"slug":"look-and-say","title":"Look and Say","family":"data","round":28,"note":"콘웨이의 보고 말하기 수열이 한 줄씩 제 위 줄을 소리 내어 읽으며 쪽을 내려와요. 줄이 한 걸음에 1.3배씩 길어지면 글자가 3×5 숫자에서 막대로, LED 하나에 숫자 하나로 작아지고, 콘웨이의 원소 92개가 저마다 제 색이에요. K3 이 씨앗을 3, 312, 311311, 고정점 22 로 바꿔요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-look-and-say","type":"code","name":"look-and-say","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Seed=1..5, Digits=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Seed","min":1,"max":5},{"name":"Digits","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.7275,"detail":0.2216,"edges":0.866,"complexity":0.242,"coverage":0.6191,"colour":0.2962,"drift":0.1823},"knobResponse":[0.1154,0.1635,0.2082,0.064]},{"slug":"loop-soup","title":"Loop Soup","family":"noise","round":58,"note":"한 LED 걸러 놓인 격자 위에서 닫힌 무작위 걸음이 하얀 머리로 제 몸을 그리고 7초 만에 사라지며, 길이가 한 옥타브 길어질 때마다 수가 반으로 줄어요. 한 자리를 나눠 쓰는 고리끼리는 같은 색 무리가 되고, c 를 1 에서 4 로 올리면 쉰 개쯤이던 무리가 잉크의 90% 를 가진 하나로 합쳐져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-loop-soup","type":"code","name":"loop-soup","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Log2 c=-2..2, Smallest=-1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Log2 c","min":-2,"max":2},{"name":"Smallest","min":-1,"max":4}],"start":[0,2,0,0.06],"measures":{"motion":0.0666,"detail":0.1296,"edges":0.9301,"complexity":0.2392,"coverage":0.2075,"colour":0.2724,"drift":0.1292},"knobResponse":[0.0828,0.083,0.2604,0.1349]},{"slug":"loose-powder","title":"Loose Powder","family":"cosmetic","round":29,"note":"꽃 무늬가 눌린 분홍 압축 파우더 위로 보이지 않는 퍼프가 그림자로만 내려와 자국을 내고, 들릴 때 하얀 가루 구름이 운모 반짝임과 함께 피어 위로 흘러가요. K3 을 올리면 무늬 비탈에 새틴 광이 돌고, 누르면 퍼프가 바로 내려와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-loose-powder","type":"code","name":"loose-powder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shimmer=1..5, Air=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shimmer","min":1,"max":5},{"name":"Air","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0756,"detail":0.0494,"edges":0.1592,"complexity":2.3434,"coverage":1,"colour":0.2039,"drift":0.0525},"knobResponse":[0.2504,0.0583,0.0484,0.0614]},{"slug":"lorem-ipsum","title":"Lorem Ipsum","family":"type","round":71,"note":"키케로의 문장이 작은 활자로 짜여 있다가 정렬 셈이 고른 글자만 남고, 잘린 글자는 줄에서 떨어져 바닥에 쌓이고 남은 글자가 Lorem ipsum 의 새 줄로 미끄러지면, 모자란 글자가 더미에서 뛰어오르거나 위에서 떨어져 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lorem-ipsum","type":"code","name":"lorem-ipsum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Passage=0..3, Gravity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Passage","min":0,"max":3},{"name":"Gravity","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5815,"detail":0.1433,"edges":0.9901,"complexity":0.124,"coverage":0.1488,"colour":0.1175,"drift":0.1423},"knobResponse":[0.0459,0.1754,0.1497,0.0588]},{"slug":"lorentz-gas","title":"Lorentz Gas","family":"particle","round":46,"note":"삼각 격자로 놓인 원판 사이로 입자 800개가 한 점에서 튕기며 퍼지고, 금빛 고리가 √t 로 크는 제곱평균 거리를 그려요. K4 가 원판을 줄이면 0.148 에서 통로가 열려 입자가 줄무늬로 내달리고, K1 을 누르면 새로 터져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lorentz-gas","type":"code","name":"lorentz-gas","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Particles=800..3000, Radius=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Particles","min":800,"max":3000},{"name":"Radius","min":0,"max":1}],"start":[0,2,800,0.06],"measures":{"motion":0.4279,"detail":0.0846,"edges":0.3101,"complexity":0.6478,"coverage":0.3867,"colour":0.1734,"drift":0.0595},"knobResponse":[0.0701,0.0455,0.0404,0.167]},{"slug":"lost-head","title":"Lost Head","family":"halloween","round":52,"note":"달 뜬 묘지에서 목 없는 해골이 묘비 위 머리를 하나씩 써 보며 너무 크거나 작은 머리, 모자 쓴 머리, 무는 머리와 호박을 으쓱하며 내려놓다가, 제 머리가 맞으면 눈구멍이 독한 초록으로 켜지고 춤을 춰요. 그러다 머리가 떨어져 굴러가요. K3 은 틀린 머리 수, K4 는 크기가 틀린 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-lost-head","type":"code","name":"lost-head","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tries=1..5, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tries","min":1,"max":5},{"name":"Size","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.9453,"detail":0.0638,"edges":0.5308,"complexity":0.2014,"coverage":0.8981,"colour":0.1323,"drift":0.0624},"knobResponse":[0.0646,0.0908,0.0776,0.0461]},{"slug":"lotion-ribbon","title":"Lotion Ribbon","family":"cosmetic","round":36,"note":"위에서 굵은 로션 줄기가 쏟아지며 가늘어지고, 닿는 자리에서 꿀처럼 똬리를 틀어 접힌 더미를 쌓아요. K3 은 로션의 무게라서 묽은 세럼은 작은 고리로 빨리 감기고 바디 버터는 25 LED 너비의 고리로 천천히 접혀요. K1 을 누르면 줄기가 끊기고, 더미가 가라앉은 뒤 새 줄기가 내려와요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-lotion-ribbon","type":"code","name":"lotion-ribbon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thick=-1..1, Gloss=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thick","min":-1,"max":1},{"name":"Gloss","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0659,"detail":0.0182,"edges":0.2668,"complexity":1.0681,"coverage":0.9585,"colour":0.134,"drift":0.0362},"knobResponse":[0.16,0.0263,0.0576,0.0386]},{"slug":"lotion-stitch","title":"Lotion Stitch","family":"cosmetic","round":40,"note":"위에서 내려다본 벨트에 윤기 나는 로션 줄기가 떨어지고, 벨트가 놓인 땀을 아래로 실어 날라 128줄에 최근 바느질이 쌓여요. K3 으로 벨트를 빠르게 하면 옮겨지는 코일이 엇갈린 고리와 W 모양 꺾임과 사행을 거쳐 곧은 줄이 되고, K4 는 로션을 굵게 해서 코일을 넓고 느리게 감아요.","why":"굵은 코일 하나가 좋은데 모양이 늘 같아요.","block":1,"ramped":false,"layer":{"id":"layer-lotion-stitch","type":"code","name":"lotion-stitch","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Belt=0.2..1.2, Thick=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Belt","min":0.2,"max":1.2},{"name":"Thick","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.4822,"detail":0.0594,"edges":0.2775,"complexity":0.8362,"coverage":0.3316,"colour":0.1426,"drift":0.0308},"knobResponse":[0.0586,0.186,0.1911,0.2087]},{"slug":"lunation","title":"Lunation","family":"celestial","round":16,"note":"망원 렌즈로 본 한 달을 빠르게 돌려요. 패널 너비만 한 달이 지구조에 비친 초승달에서 보름달로 차오르며 달의 바다와 크레이터를 드러내고, 하늘도 같이 밝아져요. K1 을 누르면 다음 보름에 개기월식이 들어 달이 구릿빛이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-lunation","type":"code","name":"lunation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Latitude=-90..90, Days=0.5..4, Zoom=0..1, Exposure=-2..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Latitude","min":-90,"max":90},{"name":"Days","min":0.5,"max":4},{"name":"Zoom","min":0,"max":1},{"name":"Exposure","min":-2,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.058,"detail":0.023,"edges":0.2973,"complexity":1.178,"coverage":0.7526,"colour":0.083,"drift":0.3482},"knobResponse":[0.0549,0.1588,0.1276,0.2614]},{"slug":"malfatti-circles","title":"Malfatti Circles","family":"geometry","round":81,"note":"천천히 모양을 바꾸는 삼각형 하나가 위아래로 두 번 서서, 위의 말파티 세 원보다 아래의 탐욕 세 원이 늘 더 넓게 덮어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-malfatti-circles","type":"code","name":"malfatti-circles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thin=0..1, More=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thin","min":0,"max":1},{"name":"More","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1546,"detail":0.0716,"edges":0.7194,"complexity":0.6355,"coverage":0.4214,"colour":0.251,"drift":0.1206},"knobResponse":[0.0912,0.111,0.0673,0.0376]},{"slug":"mamikon-theorem","title":"Mamikon's Theorem","family":"line","round":80,"note":"위 칸에서 길이가 정해진 선분이 타원에 닿은 채 한 바퀴 돌며 고리를 열두 색으로 칠하고, 아래 칸에서는 같은 선분을 한 점에 모아 같은 순간 같은 색으로 원판을 채워서, 타원을 네모나 가는 경기장 꼴로 바꿔도 두 넓이가 색마다 같아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mamikon-theorem","type":"code","name":"mamikon-theorem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Oval=0..3, Length=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Oval","min":0,"max":3},{"name":"Length","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0741,"detail":0.0345,"edges":0.4693,"complexity":0.9742,"coverage":0.3335,"colour":0.2724,"drift":0.153},"knobResponse":[0.0943,0.0847,0.0778,0.1099]},{"slug":"mandelbrot","title":"Mandel Dive","family":"fractal","round":2,"note":"망델브로 집합 전체가 서 있다가 가장자리의 한 점으로 끝없이 떨어져 들어가요. 처음 자리는 안테나 위의 미니 망델브로라서, 다 들어가면 처음과 같은 그림으로 녹아들어 다시 떨어져요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-mandelbrot","type":"code","name":"mandelbrot","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.25..4, Spot=0..3, Bands=1..3.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.25,"max":4},{"name":"Spot","min":0,"max":3},{"name":"Bands","min":1,"max":3.5}],"start":[0,2,0,1],"measures":{"motion":1.8353,"detail":0.0554,"edges":0.2209,"complexity":1.9032,"coverage":0.846,"colour":0.2924,"drift":0.4001},"knobResponse":[0.262,0.2907,0.2828,0.2216]},{"slug":"marble-run","title":"Marble Run","family":"toy","round":17,"note":"패널 높이의 구슬 굴리기 장난감이에요. 고양이눈 유리구슬이 깔때기를 돌고 지그재그 레일 셋과 나선, 실로폰을 지나 내려오면 옆의 나사 리프트가 다시 꼭대기로 올리고, 구슬이 지나는 플라스틱 조각에는 불이 들어와요. K1 을 누르면 구슬 여섯 개를 깔때기에 쏟아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-marble-run","type":"code","name":"marble-run","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paint=0..1, Speed=0.2..3, Marbles=6..28, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Marbles","min":6,"max":28},{"name":"Tilt","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.4936,"detail":0.087,"edges":0.6482,"complexity":0.8353,"coverage":0.464,"colour":0.2101,"drift":0.042},"knobResponse":[0.0707,0.0515,0.0698,0.0736]},{"slug":"marbling","title":"Marbling","family":"print","round":15,"note":"물 위에 떨어진 잉크 방울이 과녁처럼 번지고, 빗이 지나가면 깃털과 갈매기 무늬로 끌려가요. 종이를 들어 올리면 물이 비고 다음 판에 다시 방울이 떨어져요.","why":"검은 바탕에 원색 띠가 쉬지 않고 끌려가요. 복잡도 0.28, 움직임 1.65 로 프리셋이 서는 자리예요.","block":0,"ramped":false,"layer":{"id":"layer-marbling","type":"code","name":"marbling","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=3..8, Comb=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":3,"max":8},{"name":"Comb","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":1.6459,"detail":0.1305,"edges":0.9605,"complexity":0.2799,"coverage":0.6371,"colour":0.5767,"drift":0.3773},"knobResponse":[0.3451,0.3454,0.3519,0.2984]},{"slug":"marionette","title":"Marionette","family":"stage","round":25,"note":"작은 인형극 무대에서 어릿광대 꼭두각시가 팔로 스폿을 받으며 지그를 춰요. 머리와 두 손, 두 무릎, 등에 맨 실 일곱이 꼭대기 다리에서 인형사가 쥔 십자 조종대까지 올라가서, 조종대가 기울면 실이 따라 기울고 팔과 무릎이 끌려 올라가요. K4 가 스폿을 옆으로 옮기면 인형과 실의 그림자가 반대쪽 배경막에 서고, K1 을 누르면 인형이 무릎을 접고 높이 뛰었다가 인사해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-marionette","type":"code","name":"marionette","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Costume=0..1, Speed=0.2..3, Number=0..4, Spot=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Costume","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":4},{"name":"Spot","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7728,"detail":0.0499,"edges":0.328,"complexity":1.7055,"coverage":0.7031,"colour":0.18,"drift":0.1687},"knobResponse":[0.0905,0.1199,0.1924,0.0547]},{"slug":"mastermind","title":"Mastermind","family":"algo","round":71,"note":"1296 가지 암호가 6×6 블록 36개로 맨 위에 서고, 크누스의 미니맥스가 1296 개를 다 훑어 고른 수를 아래 판에 꽂을 때마다 아직 가능한 암호가 받을 답대로 물들었다가 온 답의 무리만 남아서, 다섯 수 안에 LED 하나로 줄어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mastermind","type":"code","name":"mastermind","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strategy=0..3, Codemaker=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strategy","min":0,"max":3},{"name":"Codemaker","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0379,"detail":0.0492,"edges":0.5257,"complexity":0.0949,"coverage":0.2524,"colour":0.1726,"drift":0.0785},"knobResponse":[0.0431,0.0919,0.0368,0.0455]},{"slug":"max-flow-min-cut","title":"Max-Flow Min-Cut","family":"algo","round":53,"note":"아래 원천 막대에서 위 싱크 막대까지 놓인 삼각 그물의 관을 펄스가 가장 짧은 증가 경로를 따라 하나씩 올라가며 청록 흐름으로 채우고, 가득 찬 관은 금색이 돼요. 길이 다 막히면 원천에서 아직 닿는 마디가 웅덩이처럼 차오르다 들쭉날쭉한 선에서 멈추고, 그 선을 건너는 관이 깜빡이며 싱크 막대가 그 관들의 용량으로 꼭 맞게 나뉘어요. K3 은 그물의 너비(7~13 마디), K4 는 관마다 제멋대로인 용량의 몫이고, 단추를 누르면 새 용량으로 다시 흘려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-max-flow-min-cut","type":"code","name":"max-flow-min-cut","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Columns=7..13, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Columns","min":7,"max":13},{"name":"Grain","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.2267,"detail":0.1285,"edges":0.5762,"complexity":1.2793,"coverage":0.4989,"colour":0.2167,"drift":0.1011},"knobResponse":[0.0661,0.0368,0.1344,0.0365]},{"slug":"maxwell-fish-eye","title":"Maxwell's Fish-Eye","family":"line","round":63,"note":"맥스웰의 물고기 눈 렌즈 안에서 한 점을 떠난 빛 24줄이 원을 그리며 휘고, 펄스의 고리가 부풀었다가 렌즈 반대편의 상 한 점으로 한꺼번에 오므라들어요. 원천이 떠돌면 상은 점선 원 r = R 너머에서 반대로 움직여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-maxwell-fish-eye","type":"code","name":"maxwell-fish-eye","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Source=-1..1, Profile=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Source","min":-1,"max":1},{"name":"Profile","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5726,"detail":0.0841,"edges":0.4726,"complexity":1.2809,"coverage":0.3074,"colour":0.1096,"drift":0.0657},"knobResponse":[0.0522,0.0987,0.1006,0.0935]},{"slug":"maya-numerals","title":"Maya Numerals","family":"type","round":73,"note":"다섯 자리 마야 숫자가 맨 아래 자리부터 하나씩 늘면서 점 다섯이 모여 막대 하나로 녹고, 다 찬 자리는 금빛 점 하나로 오그라들어 윗자리로 올라가며 조개 껍데기 0 을 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-maya-numerals","type":"code","name":"maya-numerals","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mode=0..1, Step=0..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":0,"max":1},{"name":"Step","min":0,"max":6}],"start":[0,2,0,0.06],"measures":{"motion":0.1292,"detail":0.0449,"edges":0.5033,"complexity":0.5225,"coverage":0.2779,"colour":0.1568,"drift":0.1203},"knobResponse":[0.1143,0.1005,0.0547,0.1227]},{"slug":"maze","title":"Maze","family":"algo","round":2,"note":"미로를 한 칸씩 파고 나면 입구에서 너비 우선 물결이 퍼져 복도마다 거리만큼 색을 입혀요. 가장 짧은 길이 밝게 그어지고, 미로가 부서진 자리에 다음 미로가 파여요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-maze","type":"code","name":"maze","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..4, Cell=2..4, Carver=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":4},{"name":"Cell","min":2,"max":4},{"name":"Carver","min":0,"max":3}],"start":[0,2,2,0.06],"measures":{"motion":0.0785,"detail":0.1747,"edges":0.9998,"complexity":0.1404,"coverage":0.6288,"colour":0.2889,"drift":0.1789},"knobResponse":[0.1257,0.2208,0.2744,0.1999]},{"slug":"mcmullen-carpet","title":"McMullen Carpet","family":"fractal","round":65,"note":"가로 m 칸, 세로 n 칸으로 나눈 칸 몇 개 안에 같은 나눔을 되풀이한 자기 아핀 카펫이 가로 m 배, 세로 n 배로 커지며 한 단마다 같은 그림으로 돌아와요","why":"","block":0,"ramped":false,"layer":{"id":"layer-mcmullen-carpet","type":"code","name":"mcmullen-carpet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pattern=0..5, Iso=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pattern","min":0,"max":5},{"name":"Iso","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6297,"detail":0.0468,"edges":0.3636,"complexity":0.1907,"coverage":0.7403,"colour":0.1516,"drift":0.2151},"knobResponse":[0.1243,0.2112,0.2369,0.096]},{"slug":"meander","title":"Meander","family":"line","round":30,"note":"패널 한가운데 세로로 난 길을 12번에서 32번 건너는 닫힌 곡선 하나예요. 한쪽 아치들이 길 위로 누웠다가 새 짝으로 펴져도 곡선은 늘 하나로 닫혀요.","why":"굵은 무지개 관이 좋은데 느려요(움직임 0.11).","block":1,"ramped":false,"layer":{"id":"layer-meander","type":"code","name":"meander","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Crossings=12..32, Hollow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Crossings","min":12,"max":32},{"name":"Hollow","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.1079,"detail":0.0446,"edges":0.5226,"complexity":0.7574,"coverage":0.4978,"colour":0.5487,"drift":0.1848},"knobResponse":[0.3105,0.2838,0.4218,0.1979]},{"slug":"medial-axis","title":"Medial Axis","family":"algo","round":57,"note":"닫힌 곡선을 따라 붙인 불이 안팎으로 같은 빠르기로 번져서, 거리의 톱니 띠가 반 띠씩 엇갈린 토막이 되어 곡선 안쪽과 바깥쪽으로 흘러가요. LED 마다 가장 가까운 곡선 위 점의 자리로 색을 칠해서, 그 점이 건너뛰는 중심축이 두 색 사이의 솔기로 서요. 처음에는 줄기에 갈래 하나가 붙은 키 큰 나무예요. K3 은 곡선에 물결을 하나씩 더하는데 5분의 1 LED 높이의 혹에서도 깊숙한 새 가지가 자라고, K4 는 앞선 사이 거리(6.7~14.2 LED)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-medial-axis","type":"code","name":"medial-axis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bumps=0..1, Width=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bumps","min":0,"max":1},{"name":"Width","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.8876,"detail":0.2032,"edges":0.1485,"complexity":2.5448,"coverage":0.9038,"colour":0.4206,"drift":0.0907},"knobResponse":[0.2809,0.3154,0.2401,0.2394]},{"slug":"menger-slices","title":"Menger Slices","family":"fractal","round":80,"note":"긴 대각선에 수직인 평면이 멩거 스펀지를 한 모서리에서 맞은편 모서리까지 훑어서 단면이 삼각형에서 육각형으로 자라고 첫 단계 구멍이 한순간 육각별이 되며, 아래에는 그 가운데 단면의 육각별 레이스가 서 있어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-menger-slices","type":"code","name":"menger-slices","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=3..5, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":3,"max":5},{"name":"Zoom","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2733,"detail":0.083,"edges":0.9756,"complexity":0.1979,"coverage":0.5388,"colour":0.1899,"drift":0.1433},"knobResponse":[0.0975,0.1115,0.0338,0.1361]},{"slug":"mesostic","title":"Mesostic","family":"type","round":75,"note":"소로의 『월든』을 맨 아래 줄에서 읽어 가다 케이지의 메조스틱 규칙이 허락하는 글자가 가운데에 오면 금빛 대문자로 세우고 둘레 낱말을 날개로 남겨서, 등뼈 낱말이 패널 가운데를 위에서 아래로 거듭 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mesostic","type":"code","name":"mesostic","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Rule=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Rule","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6551,"detail":0.1248,"edges":0.9735,"complexity":0.1619,"coverage":0.1426,"colour":0.1451,"drift":0.0572},"knobResponse":[0.0484,0.1138,0.1154,0.072]},{"slug":"metro-map","title":"Metro Map","family":"city","round":15,"note":"해리 벡 식 지하철 노선도예요. 색 노선 넷이 45도로 꺾이며 위아래로 달리고, 갈아타는 역은 흰 고리예요. 흰 열차가 역마다 섰다 떠나고 끝에서 되돌아가요. K1 을 누르면 급행이 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-metro-map","type":"code","name":"metro-map","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=4..7, Rush=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":4,"max":7},{"name":"Rush","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0316,"detail":0.0683,"edges":0.914,"complexity":0.1388,"coverage":0.2043,"colour":0.2301,"drift":0.035},"knobResponse":[0.0664,0.0514,0.0687,0.0629]},{"slug":"milk-ring","title":"Milk Ring","family":"cosmetic","round":38,"note":"우윳빛 크림 방울이 색을 띤 세럼에 떨어져 테두리가 밝은 소용돌이 고리가 돼요. 고리는 가라앉으며 부풀다 작은 방울 몇 개로 갈라지고, 그 방울이 다시 작은 고리가 되어 가는 크림 실에 매달린 나무처럼 패널 아래로 늘어져요. K3 은 한 고리가 갈라지는 방울 수를 셋에서 여섯으로 늘리고, K1 을 누르면 방울이 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-milk-ring","type":"code","name":"milk-ring","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=3..6, Gel=1..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":3,"max":6},{"name":"Gel","min":1,"max":5}],"start":[0,2,3,1],"measures":{"motion":0.0728,"detail":0.0206,"edges":0.212,"complexity":1.5604,"coverage":1,"colour":0.1167,"drift":0.0533},"knobResponse":[0.2862,0.0564,0.077,0.0544]},{"slug":"millefiori","title":"Millefiori","family":"glass","round":20,"note":"무라노 밀레피오리 접시 위로 시야가 천천히 미끄러지며, 1 LED 고리와 꽃잎으로 된 유리 막대 조각 수백 개가 어두운 유리에 촘촘히 박혀 지나가요. K1 을 누르면 새로 뽑은 막대로 만든 접시가 오른쪽에서 밀려 들어와요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-millefiori","type":"code","name":"millefiori","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..4, Speed=0.2..3, Canes=6..12, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":4},{"name":"Speed","min":0.2,"max":3},{"name":"Canes","min":6,"max":12},{"name":"Light","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":1.2091,"detail":0.3373,"edges":0.8101,"complexity":1.6267,"coverage":1,"colour":0.5579,"drift":0.0871},"knobResponse":[0.1882,0.3627,0.3509,0.1412]},{"slug":"mirror-curves","title":"Mirror Curves","family":"topology","round":58,"note":"4 × 8 점 판 위를 빛줄기가 45도로 달리다 거울에 튕겨 여덟 가닥의 교대 고리를 짜고, 1초쯤마다 거울 하나가 돌거나 자리를 옮겨 가닥이 합쳐지거나 갈라지면 새 색이 그 거울에서부터 가닥을 따라 퍼져요. K3 을 누르면 4초 동안 테두리만 남은 판이 gcd(4, 8) = 4 가닥으로 엮여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mirror-curves","type":"code","name":"mirror-curves","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Mirrors=0.5..1, Join=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Mirrors","min":0.5,"max":1},{"name":"Join","min":0,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.1626,"detail":0.3176,"edges":0.1951,"complexity":0.1695,"coverage":0.5,"colour":0.3194,"drift":0.0208},"knobResponse":[0.0759,0.0813,0.0562,0.0517]},{"slug":"mitosis","title":"Mitosis","family":"microbe","round":27,"note":"검은 바탕에 찍은 면역형광 사진 속 세포 배양이에요. DNA 는 파랑, 미세소관은 초록, 액틴은 빨강으로 물든 세포가 둥글게 말려 염색체를 두 방추극 사이에 세우고, 양쪽 극으로 끌어 나눈 뒤 빨간 수축 고리에서 잘록해져 둘이 돼요. K1 이 염료를 바꾸고, 누르면 가운데 세포가 바로 분열을 시작해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-mitosis","type":"code","name":"mitosis","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stain=0..1, Speed=0.2..3, Cells=9..17, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stain","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cells","min":9,"max":17},{"name":"Zoom","min":0,"max":1}],"start":[0,2,9,0.06],"measures":{"motion":0.3411,"detail":0.1419,"edges":0.8838,"complexity":0.8038,"coverage":0.2626,"colour":0.5399,"drift":0.2023},"knobResponse":[0.1544,0.1632,0.2075,0.2066]},{"slug":"miura-ori","title":"Miura-ori","family":"space","round":75,"note":"합동인 평행사변형으로 된 미우라 접기 판이 자유도 하나로 접혔다 펴지며, 면이 두 빛 사이에서 네 빛깔로 뒤집히고 판이 가로세로로 함께 줄어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-miura-ori","type":"code","name":"miura-ori","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sector=55..85, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sector","min":55,"max":85},{"name":"Light","min":0,"max":1}],"start":[0,2,55,0.06],"measures":{"motion":0.711,"detail":0.0923,"edges":0.6551,"complexity":0.2395,"coverage":0.9508,"colour":0.2499,"drift":0.3464},"knobResponse":[0.2388,0.4201,0.2929,0.4452]},{"slug":"mobius-energy","title":"Möbius Energy","family":"topology","round":48,"note":"공간을 비틀고 짜서 엉킨 매듭 관이 뫼비우스 에너지의 기울기를 따라 풀리며 매듭 꼴이 허락하는 만큼만 펴지고, 아래 띠에는 에너지가 떨어지는 자취가 그려져요. K3 은 세잎 매듭에서 8자 매듭, 오엽 매듭, 5₂ 매듭을 지나 풀린 고리까지 고르고, K4 는 구기는 세기이고, K1 을 누르면 바로 다시 구겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mobius-energy","type":"code","name":"mobius-energy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knot=0..4, Crumple=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knot","min":0,"max":4},{"name":"Crumple","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1874,"detail":0.0359,"edges":0.5566,"complexity":0.3706,"coverage":0.1735,"colour":0.187,"drift":0.1299},"knobResponse":[0.0473,0.0817,0.0842,0.0625]},{"slug":"mobius-loxodrome","title":"Möbius Loxodrome","family":"geometry","round":43,"note":"패널 위아래 바깥에 둔 두 고정점 사이로, 칸마다 밝은 톱니 물결이 비스듬히 그어진 체커판이 흘러요. 위의 고정점에서 나온 칸들이 두 점을 지나는 원을 따라 아래 고정점으로 빨려 들어가고, 축은 42초에 한 번 7도씩 기울었다 돌아와요. K3 을 올리면 쌍곡형 변환이 록소드롬형으로 바뀌어 칸의 줄이 이중 나선으로 감겨요. K4 는 고정점을 패널 끝까지 끌어와 칸들이 거기서 부채처럼 퍼져 나오게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mobius-loxodrome","type":"code","name":"mobius-loxodrome","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Twist=0..1, Poles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Twist","min":0,"max":1},{"name":"Poles","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7663,"detail":0.2144,"edges":0.1498,"complexity":2.2833,"coverage":0.9557,"colour":0.5271,"drift":0.0269},"knobResponse":[0.4067,0.3426,0.3284,0.3291]},{"slug":"mobius-type","title":"Möbius Type","family":"type","round":79,"note":"패널 높이로 선 종이 띠가 천천히 돌고, 가운데 찍힌 THE OTHER SIDE OF THIS LINE IS THIS LINE 은 띠를 두 바퀴 돌아야 제 첫 글자를 만나요. 반 꼬임을 짝수로 돌리면 THIS LINE HAS A BACK 이 한 바퀴에 닫히고 뒷면은 빈 종이예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mobius-type","type":"code","name":"mobius-type","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Twists=1..4, Paper=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Twists","min":1,"max":4},{"name":"Paper","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1383,"detail":0.0375,"edges":0.6297,"complexity":0.7232,"coverage":0.4278,"colour":0.1426,"drift":0.1944},"knobResponse":[0.0534,0.1191,0.1175,0.0461]},{"slug":"modular-hyperbola","title":"Modular Hyperbola","family":"number","round":81,"note":"소수 p 로 나눈 곱셈표를 톱니로 칠해서, 흰 날이 모듈러 쌍곡선 xy ≡ c 를 그리며 판을 옮겨 다녀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-modular-hyperbola","type":"code","name":"modular-hyperbola","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Prime=-3..4, Band=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Prime","min":-3,"max":4},{"name":"Band","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3421,"detail":0.3364,"edges":0.7689,"complexity":2.3909,"coverage":0.9008,"colour":0.2238,"drift":0.0402},"knobResponse":[0.1585,0.4526,0.3684,0.4372]},{"slug":"moffatt-eddies","title":"Moffatt Eddies","family":"sim","round":63,"note":"28도 쐐기가 패널을 채우고, 모서리로 갈수록 2.005배씩 작아지며 도는 방향이 번갈아 바뀌는 모팻 소용돌이가 흰 분리 유선 사이에 쌓여요. 추적 입자가 소용돌이마다 돌고, 화면은 3초에 소용돌이 하나씩 모서리로 파고들어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-moffatt-eddies","type":"code","name":"moffatt-eddies","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Angle=28..100, Truth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Angle","min":28,"max":100},{"name":"Truth","min":0,"max":1}],"start":[0,2,28,0.06],"measures":{"motion":1.178,"detail":0.084,"edges":0.6213,"complexity":0.9132,"coverage":0.54,"colour":0.1947,"drift":0.0724},"knobResponse":[0.0774,0.1394,0.2077,0.0548]},{"slug":"moire-rings","title":"Moire Rings","family":"wave","round":1,"note":"동심원 두 벌이 서로 지나가고, 어긋나는 자리에 아무도 그리지 않은 무늬가 생겨요.","why":"고리 무늬 둘이 겹쳐 간섭 무늬를 만들어요. 0707 의 과녁처럼 또렷하고(가장자리 1.00) 단순해요(복잡도 0.18).","block":0,"ramped":false,"layer":{"id":"layer-moire-rings","type":"code","name":"moire-rings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.1..6, Rings=5..16, Spread=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.1,"max":6},{"name":"Rings","min":5,"max":16},{"name":"Spread","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":1.5703,"detail":0.2108,"edges":1,"complexity":0.1822,"coverage":0.7502,"colour":0.4676,"drift":0.1626},"knobResponse":[0.2556,0.2849,0.3431,0.2821]},{"slug":"monge-transport","title":"Monge Transport","family":"algo","round":61,"note":"한쪽 반의 도형에 모인 입자 더미가 다른 반 도형의 자리와 아무렇게나 짝지어졌다가, 거리 합이 짧아지는 쌍마다 목적지를 맞바꿔 엇갈림이 풀린 뒤 한꺼번에 광선을 따라 미끄러져 새 도형으로 내려앉아요. 입자 색은 처음 도형에서의 각도라서 도착한 색 바퀴가 옮김대로 다시 놓여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-monge-transport","type":"code","name":"monge-transport","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Particles=150..400, Exponent=1..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Particles","min":150,"max":400},{"name":"Exponent","min":1,"max":2}],"start":[0,2,150,1],"measures":{"motion":0.3863,"detail":0.0385,"edges":0.6061,"complexity":0.6759,"coverage":0.2502,"colour":0.2956,"drift":0.3779},"knobResponse":[0.1121,0.2402,0.0602,0.0409]},{"slug":"mood-tint","title":"Mood Tint","family":"cosmetic","round":34,"note":"판 전체가 열에 색이 바뀌는 짙은 보라 코팅이에요. 보이지 않는 손끝이 누른 자리마다 지문 결이 든 옅은 난초색 타원이 피고, 열이 퍼지며 결부터 흐려지고 이웃 자국과 엉겨 붙었다가 다시 보라 속으로 줄어들어요. K1 을 누르면 손바닥 하나가 1.1초 동안 눌러요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-mood-tint","type":"code","name":"mood-tint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Warmth=-1..1, Blend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Warmth","min":-1,"max":1},{"name":"Blend","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0548,"detail":0.0134,"edges":0.483,"complexity":0.652,"coverage":1,"colour":0.1889,"drift":0.0997},"knobResponse":[0.4028,0.1176,0.1081,0.0933]},{"slug":"morley-triangle","title":"Morley Triangle","family":"geometry","round":42,"note":"큰 삼각형이 정삼각형에 가까운 꼴에서 가늘고 둔한 꼴까지 쉬지 않고 모양을 바꾸는데, 각을 삼등분한 선이 변 옆에서 만나는 세 점은 늘 정삼각형이라 금빛으로 칠한 그 삼각형은 돌며 크기만 바뀌어요. K4 를 올리면 바깥각 삼등분선이 만드는 큰 정삼각형이 뒤에 나타나고, 그 변이 안쪽 정삼각형과 늘 나란해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-morley-triangle","type":"code","name":"morley-triangle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wander=0..1, Exterior=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wander","min":0,"max":1},{"name":"Exterior","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3452,"detail":0.0243,"edges":1,"complexity":0.0704,"coverage":0.436,"colour":0.2815,"drift":0.2936},"knobResponse":[0.1485,0.1674,0.1396,0.0445]},{"slug":"moth-lamp","title":"Moth Lamp","family":"insect","round":20,"note":"벽돌집 처마 밑 사슬에 매달린 옛 등이 흔들리고, 나방이 어둠에서 나선을 그리며 날아와 등을 돌다가 유리와 불빛 든 벽돌에 날개를 펴고 앉아요. K1 을 누르면 박쥐가 빛 속으로 날아들어 나방 한 마리를 채 가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-moth-lamp","type":"code","name":"moth-lamp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Moths=12..120, Breeze=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Moths","min":12,"max":120},{"name":"Breeze","min":-1,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.1073,"detail":0.0382,"edges":0.2646,"complexity":2.2012,"coverage":0.2737,"colour":0.0944,"drift":0.0456},"knobResponse":[0.0525,0.0467,0.0451,0.0578]},{"slug":"motility-clusters","title":"Motility Clusters","family":"particle","round":50,"note":"스스로 헤엄치는 원판 1,434개가 밀어내기만 하는데도 서로 막혀 옅은 덩어리로 뭉치고, 안쪽을 보는 가장자리 원판이 헤엄치는 방향의 색으로 덩어리를 두르는 동안 흐린 기체가 그 사이를 달리고 덩어리끼리 합쳐져요. K3 은 페클레 수, K4 는 원판이 덮는 몫이고, K1 을 누르면 고른 기체로 흩어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-motility-clusters","type":"code","name":"motility-clusters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pe=-1..1, Packing=0.55..0.72","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pe","min":-1,"max":1},{"name":"Packing","min":0.55,"max":0.72}],"start":[0,2,0,0.55],"measures":{"motion":2.1227,"detail":0.1283,"edges":0.4244,"complexity":1.7585,"coverage":0.7263,"colour":0.3317,"drift":0.1865},"knobResponse":[0.2286,0.2646,0.3301,0.3674]},{"slug":"mouse-tale","title":"Mouse's Tale","family":"type","round":65,"note":"루이스 캐럴의 생쥐 이야기가 책에 찍힌 꼬리 모양 그대로 패널을 타고 내려가요. 아래로 갈수록 글자가 5×7 에서 점으로 작아지고, 꼬리는 천천히 흔들려요","why":"","block":0,"ramped":false,"layer":{"id":"layer-mouse-tale","type":"code","name":"mouse-tale","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sway=1..3, Taper=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sway","min":1,"max":3},{"name":"Taper","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.5174,"detail":0.1092,"edges":1,"complexity":0.1464,"coverage":0.1729,"colour":0.236,"drift":0.0469},"knobResponse":[0.0671,0.1021,0.0765,0.0779]},{"slug":"moving-sofa","title":"Moving Sofa","family":"geometry","round":34,"note":"폭 14 LED 의 ㄇ자 복도를 해머슬리 소파가 오른쪽 다리로 올라와 모퉁이를 돌고, 위를 건너 왼쪽 다리로 내려가요. 모퉁이마다 안쪽 모서리가 소파의 금빛 반원 홈 안을 지나가고, 소파 뒤에 옅게 붙어 온 띠가 벽에 깎여 나가 소파 모양만 남아요. K3 은 홈의 반지름을 0 의 반원판에서 넓이 2 인 소파까지 바꿔요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-moving-sofa","type":"code","name":"moving-sofa","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Hole=-1..1, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hole","min":-1,"max":1},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3083,"detail":0.0578,"edges":0.2742,"complexity":0.3757,"coverage":0.3481,"colour":0.1671,"drift":0.1766},"knobResponse":[0.06,0.1158,0.0644,0.0648]},{"slug":"multiple-master","title":"Multiple Master","family":"type","round":73,"note":"굵기와 폭의 끝에 둔 마스터 넷의 점을 섞어 MASTER 를 짓고, 아래 설계 공간 정사각형에서 그 자리가 노브 둘레를 천천히 떠돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-multiple-master","type":"code","name":"multiple-master","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Weight=-1..1, Width=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Weight","min":-1,"max":1},{"name":"Width","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0232,"detail":0.0651,"edges":0.7348,"complexity":0.3207,"coverage":0.2362,"colour":0.1346,"drift":0.0364},"knobResponse":[0.054,0.0515,0.0824,0.1179]},{"slug":"multiplicative-cascade","title":"Multiplicative Cascade","family":"fractal","round":56,"note":"판을 가로세로 번갈아 열세 번 반씩 나눈 무게가 8 × 8 칸마다 민트와 보라 조각으로, LED 하나하나는 반짝이는 밝기로 보이고, 무게가 큰 반쪽부터 LED 까지 한 단씩 바뀌며 질량이 반쪽 사이를 오가요. Spread 를 올리면 판이 거의 꺼지고 몇 점의 불꽃만 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-multiplicative-cascade","type":"code","name":"multiplicative-cascade","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=0.4..1.6, Couple=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":0.4,"max":1.6},{"name":"Couple","min":-1,"max":1}],"start":[0,2,0.4,0.06],"measures":{"motion":0.0951,"detail":0.1173,"edges":0.32,"complexity":2.7161,"coverage":0.9744,"colour":0.3505,"drift":0.1655},"knobResponse":[0.3847,0.1422,0.2695,0.2036]},{"slug":"multiplicative-chaos","title":"Multiplicative Chaos","family":"noise","round":70,"note":"로그 상관 가우스장을 깊은 파랑 부조로 깔고 그 지수로 만든 카안의 측도를 금빛으로 띄우면, γ 가 오를수록 질량이 장의 가장 높은 몇 LED 로 모여 흰 점이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-multiplicative-chaos","type":"code","name":"multiplicative-chaos","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gamma=1..2.5, Cutoff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gamma","min":1,"max":2.5},{"name":"Cutoff","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2485,"detail":0.3458,"edges":0.7865,"complexity":2.3585,"coverage":0.7528,"colour":0.4307,"drift":0.0703},"knobResponse":[0.3086,0.2078,0.0886,0.2452]},{"slug":"mummy","title":"Mummy","family":"halloween","round":45,"note":"패널 높이만 한 미라가 팔을 내밀고 손을 늘어뜨린 채 보라 무덤에서 비틀거리고, 붕대 끝이 바람에 펄럭여요. 몇 초마다 가슴의 붕대 한 줄이 풀려 꼬이며 날아가고, 그 자리에 속이 빈 초록 빛이 드러났다가 붕대가 다시 감겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mummy","type":"code","name":"mummy","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Wind=0..1, Torch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Torch","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3511,"detail":0.0606,"edges":0.3583,"complexity":0.5069,"coverage":0.3198,"colour":0.1397,"drift":0.0926},"knobResponse":[0.0355,0.0967,0.0488,0.0341]},{"slug":"murmuration","title":"Murmuration","family":"halloween","round":50,"note":"노을 진 하늘에서 까마귀 떼가 찌르레기처럼 접혔다 펼쳐지며 돌다가, 모두 날아들어 커다란 해골이 되고 턱을 떨구며 눈을 번뜩인 뒤 흩어져요. K3 은 까마귀 수, K4 는 떼가 짓는 모양이고, K1 을 누르면 바로 모여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-murmuration","type":"code","name":"murmuration","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flock=0..1, Shape=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flock","min":0,"max":1},{"name":"Shape","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.752,"detail":0.0663,"edges":0.6189,"complexity":0.2337,"coverage":0.7192,"colour":0.4564,"drift":0.2922},"knobResponse":[0.3073,0.1826,0.0494,0.0872]},{"slug":"mushroom-billiard","title":"Mushroom Billiard","family":"particle","round":79,"note":"반원 갓 아래로 곧은 줄기가 패널 밑까지 내려간 버섯 당구대에서 공 360개가 튀어요. 갓 중심에서 제 길까지 거리가 줄기 반폭보다 먼 공은 금빛으로 갓만 돌고, 나머지는 하늘색으로 줄기와 갓을 다 헤매요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-mushroom-billiard","type":"code","name":"mushroom-billiard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stem=0.3..0.9, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stem","min":0.3,"max":0.9},{"name":"Trail","min":0,"max":1}],"start":[0,2,0.3,0.06],"measures":{"motion":2.2607,"detail":0.1169,"edges":0.6098,"complexity":0.8241,"coverage":0.2387,"colour":0.23,"drift":0.0455},"knobResponse":[0.0843,0.1136,0.1355,0.0898]},{"slug":"music-box","title":"Music Box","family":"halloween","round":49,"note":"원통의 핀이 빗살을 튕기면 해골 발레리나가 돌다가, 태엽이 풀려 음악이 늘어지면 우리를 보고 멈춰 눈구멍이 초록으로 빛나고, 보이지 않는 손이 열쇠를 감아 다시 시작해요. K3 은 곡 셋 가운데 하나를, K4 는 태엽을 감은 만큼이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-music-box","type":"code","name":"music-box","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Velvet=0..1, Speed=0.2..3, Tune=0..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Velvet","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tune","min":0,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1782,"detail":0.0682,"edges":0.7127,"complexity":0.1466,"coverage":0.725,"colour":0.2988,"drift":0.089},"knobResponse":[0.0697,0.0754,0.0603,0.0453]},{"slug":"napier-bones","title":"Napier's Bones","family":"type","round":80,"note":"네이피어 막대 다섯이 위에서 하나씩 떨어져 1617 을 세우고, 곱수 67 의 7 과 6 이 가리키는 줄이 차례로 켜져 대각선을 오른쪽부터 받아올림과 함께 더한 부분곱 둘과 그 합 108339 가 아래에 적히면, 막대가 떨어져 나가고 다음 문제가 내려와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-napier-bones","type":"code","name":"napier-bones","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Problem=0..5, Bands=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Problem","min":0,"max":5},{"name":"Bands","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0854,"detail":0.0894,"edges":0.4963,"complexity":0.1419,"coverage":0.567,"colour":0.08,"drift":0.1053},"knobResponse":[0.053,0.1645,0.0564,0.0388]},{"slug":"needlepoint","title":"Needlepoint","family":"textile","round":19,"note":"슬레이트 틀의 인쇄 캔버스를 바늘이 오른쪽 위 구석부터 바스켓위브로 한 대각선씩 메워 가요. 앵무새 쿠션이나 검은 바탕의 베를린 장미, 알파벳 샘플러가 다 차면 틀이 굴러 새 캔버스를 감아 와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-needlepoint","type":"code","name":"needlepoint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Wool=0..1, Speed=0.2..3, Design=0..2, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Wool","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Design","min":0,"max":2},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1581,"detail":0.3325,"edges":0.8053,"complexity":1.8885,"coverage":0.6687,"colour":0.2513,"drift":0.043},"knobResponse":[0.1114,0.0649,0.1048,0.0607]},{"slug":"neon-alley","title":"Neon Alley","family":"city","round":16,"note":"밤 골목의 벽에 유리관을 구부린 네온 그림 간판이 지붕부터 젖은 길까지 걸려서, 관이 하나씩 켜지고 화살표가 달리고 지친 관 하나가 지직거려요. K1 을 누르면 정전이 됐다가 간판이 하나씩 다시 켜지고, K2 를 누르면 간판이 새로 걸려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-neon-alley","type":"code","name":"neon-alley","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pace=0..4, Wear=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pace","min":0,"max":4},{"name":"Wear","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7208,"detail":0.1177,"edges":0.5393,"complexity":0.4294,"coverage":0.2587,"colour":0.5724,"drift":0.1545},"knobResponse":[0.2671,0.0583,0.0882,0.0858]},{"slug":"neon-spreading","title":"Neon Spreading","family":"type","round":79,"note":"천천히 도는 흰 선 격자가 세로로 쌓인 큰 글자 셋을 지날 때만 선이 색을 띠고, 선 사이 LED 는 다 꺼져 있는데도 눈이 글자 안을 그 색의 옅은 막으로 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-neon-spreading","type":"code","name":"neon-spreading","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pitch=4..9, Fill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pitch","min":4,"max":9},{"name":"Fill","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.8708,"detail":0.2853,"edges":0.8034,"complexity":1.2133,"coverage":0.5927,"colour":0.197,"drift":0.0322},"knobResponse":[0.0813,0.2758,0.2679,0.0455]},{"slug":"night-flight","title":"Night Flight","family":"city","round":22,"note":"여객기 창으로 내려다본 밤 도시예요. 1 LED 가로등이 바둑판 길과 대로, 강 위 다리를 따라 레이스처럼 이어지고, 고속도로에는 흰 전조등과 빨간 미등이 흘러요. 도시는 초록 항법등과 흰 섬광등이 달린 날개 끝을 지나 왼쪽 아래로 천천히 미끄러져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-night-flight","type":"code","name":"night-flight","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamps=0..1, Speed=0.2..3, Grid=0..1, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamps","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grid","min":0,"max":1},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3475,"detail":0.3276,"edges":0.2578,"complexity":1.0097,"coverage":0.5044,"colour":0.2424,"drift":0.0667},"knobResponse":[0.0508,0.1119,0.0511,0.1477]},{"slug":"nine-fold-seal","title":"Nine-fold Seal","family":"type","round":69,"note":"주홍 인주로 찍은 세로 인영에 한글 여덟 음절이 오른쪽 줄부터 내리읽히고, 가로획마다 한 LED 선으로 겹겹이 접혀 칸을 메웠다가 몇 초마다 민 글자로 펴진 뒤 다음 글로 다시 접혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-nine-fold-seal","type":"code","name":"nine-fold-seal","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Ink=0..1, Speed=0.2..3, Plain=0..1, Press=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Ink","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Plain","min":0,"max":1},{"name":"Press","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0832,"detail":0.2165,"edges":1,"complexity":2.379,"coverage":1,"colour":0.3919,"drift":0.2293},"knobResponse":[0.2853,0.0641,0.0721,0.0605]},{"slug":"nixie","title":"Nixie","family":"circuit","round":21,"note":"회로판 소켓에 선 닉시관 속, 육각 그물 뒤에 겹겹이 선 숫자 철사 가운데 하나가 네온 주황으로 빛나요. 숫자가 돌다가 하나씩 멈추고, Mode 노브를 돌리면 주파수 계수기나 시계가 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-nixie","type":"code","name":"nixie","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gas=0..1, Speed=0.2..3, Rows=1..3, Mode=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gas","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rows","min":1,"max":3},{"name":"Mode","min":0,"max":3}],"start":[0,2,1,0.06],"measures":{"motion":0.4696,"detail":0.0533,"edges":0.238,"complexity":1.7971,"coverage":0.5829,"colour":0.1892,"drift":0.1676},"knobResponse":[0.0576,0.0717,0.1676,0.0732]},{"slug":"noborigama","title":"Noborigama","family":"pottery","round":26,"note":"밤 언덕의 오름가마를 세로로 잘라 봐요. 불이 그릇 쌓인 칸들을 타고 올라 아래 칸은 희고 위 칸은 붉으며, 장작을 넣을 때마다 감시 구멍에서 불길이, 굴뚝에서 검은 연기와 불티가 나와요. K1 은 소성 날짜를 바꾸고, 누르면 모든 구멍에 한꺼번에 불을 넣어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-noborigama","type":"code","name":"noborigama","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Firing=-1..1, Speed=0.2..3, Chambers=3..6, Draft=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Firing","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Chambers","min":3,"max":6},{"name":"Draft","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.141,"detail":0.0581,"edges":0.3934,"complexity":1.5788,"coverage":0.9717,"colour":0.2311,"drift":0.0397},"knobResponse":[0.0974,0.0413,0.0659,0.0443]},{"slug":"nodal-domains","title":"Nodal Domains","family":"noise","round":54,"note":"같은 파장의 평면파 40개를 무작위 방향으로 겹친 베리의 무작위 파동을 0 근처에서 잘라, 부호가 같은 이웃끼리 이어진 마디 영역마다 납작한 한 색을 칠해요. 0 위의 영역은 작을 때 장미색이다가 커지면 주황을 지나 금색이 되고 0 아래는 파랑 보라에서 청록으로 가며, 가장 큰 영역은 옅은 하늘색으로 패널을 가로지르고, 파동마다 위상이 제 빠르기로 돌아서 안장점에서 영역이 이어지고 끊길 때마다 흰 불꽃이 튀어요. K3 은 파장, K4 는 자르는 높이예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-nodal-domains","type":"code","name":"nodal-domains","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=0..1, Level=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wavenumber","min":0,"max":1},{"name":"Level","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3691,"detail":0.2893,"edges":0.861,"complexity":1.3149,"coverage":0.8785,"colour":0.6244,"drift":0.0352},"knobResponse":[0.4669,0.3447,0.4004,0.4803]},{"slug":"noordzij-cube","title":"Noordzij Cube","family":"type","round":82,"note":"펜이 nano, bone, ego 를 한 획씩 쓰고, 노브 둘이 넓은 펜촉의 병진과 뾰족한 펜의 팽창 사이와 대비의 양을 옮겨서 같은 뼈대의 모든 획 굵기를 다시 칠해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-noordzij-cube","type":"code","name":"noordzij-cube","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Model=0..1, Hairline=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Model","min":0,"max":1},{"name":"Hairline","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0602,"detail":0.0805,"edges":0.6975,"complexity":0.8378,"coverage":0.3372,"colour":0.3654,"drift":0.2511},"knobResponse":[0.1715,0.1763,0.0574,0.0468]},{"slug":"ogham","title":"Ogham","family":"type","round":68,"note":"선돌 모서리를 줄기 삼아 오검 글이 아래에서 위로 한 획씩 새겨지고, 옆의 라틴 글자가 획 수를 세어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ogham","type":"code","name":"ogham","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Turn=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Turn","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.164,"detail":0.0423,"edges":0.2795,"complexity":1.2395,"coverage":0.6764,"colour":0.0804,"drift":0.0437},"knobResponse":[0.0601,0.0613,0.0613,0.0962]},{"slug":"old-well","title":"Old Well","family":"halloween","round":50,"note":"달빛 아래 잘라 본 돌우물에 두레박이 내려가 검은 물에 닿으면, 물이 독한 초록으로 빛나며 두 눈이 뜨고 창백한 손이 올라와 두레박을 물속으로 끌고 가요. 감아올린 두레박에 그 손이 매달려 오기도 해요. K3 은 달의 자리, K4 는 물 위 안개이고, K1 을 누르면 손잡이를 놓아 두레박이 바로 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-old-well","type":"code","name":"old-well","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Moon=0..1, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Moon","min":0,"max":1},{"name":"Fog","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1312,"detail":0.0408,"edges":0.2457,"complexity":0.5075,"coverage":0.8029,"colour":0.1255,"drift":0.0802},"knobResponse":[0.06,0.0468,0.0499,0.0422]},{"slug":"oloid","title":"Oloid","family":"space","round":47,"note":"서로의 중심을 지나는 두 원의 볼록 껍질이 곧은 괘선 하나로 바닥을 짚으며 흔들흔들 굴러오고, 굴러간 겉이 전개도 그대로 바닥에 찍혀 두 색 뱀이 맞물린 띠로 패널 위로 멀어져요. K3 은 카메라 기울기, K4 는 자국이 바래는 빠르기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-oloid","type":"code","name":"oloid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Fade=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Fade","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2675,"detail":0.0235,"edges":0.4693,"complexity":0.2507,"coverage":0.3681,"colour":0.2837,"drift":0.0431},"knobResponse":[0.153,0.1039,0.1344,0.0769]},{"slug":"one-bit","title":"One Bit","family":"pixel","round":17,"note":"달밤 바닷가 벼랑에 선 등대를 두 색과 Bayer 순서 디더링만으로 그린 1비트 화면이에요. 빛줄기가 돌고 구름이 달 앞을 지나고 안개 둑이 바다 위에서 오르내려도 한 프레임에 뒤집히는 픽셀은 열 개 안팎이에요. K1 이 앰버 단말기, 게임보이, 매킨토시, 전자잉크, 플레이데이트의 두 색을 골라요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-one-bit","type":"code","name":"one-bit","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Time=0.2..3, Fog=0..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Time","min":0.2,"max":3},{"name":"Fog","min":0,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0337,"detail":0.3203,"edges":1,"complexity":0.0918,"coverage":0.242,"colour":0.3801,"drift":0.0416},"knobResponse":[0.2143,0.057,0.0812,0.0548]},{"slug":"op-stripes","title":"Op Stripes","family":"wave","round":1,"note":"브리짓 라일리 식의 두 색 가로줄이에요. 밑으로 지나가는 넓은 부풂 둘이 줄 간격을 벌려서 평평한 패널이 부푸는 것처럼 보여요.","why":"굵은 줄무늬가 거의 안 움직여요(움직임 0.06).","block":1,"ramped":false,"layer":{"id":"layer-op-stripes","type":"code","name":"op-stripes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Drift=0.1..6, Stripes=14..26, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Drift","min":0.1,"max":6},{"name":"Stripes","min":14,"max":26},{"name":"Swell","min":0,"max":1}],"start":[0,2,14,0.06],"measures":{"motion":0.0622,"detail":0.0792,"edges":1,"complexity":0.0654,"coverage":1,"colour":0.6118,"drift":0.0499},"knobResponse":[0.4596,0.1655,0.1894,0.1993]},{"slug":"optical-kerning","title":"Optical Kerning","family":"type","round":72,"note":"낱말 다섯이 상자 사이를 같게 띄워 섰다가 글자 사이 흰 자리가 다 같은 넓이가 될 때까지 옆으로 미끄러지고, 틈마다 넓이를 말하던 빛이 한 색으로 모여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-optical-kerning","type":"code","name":"optical-kerning","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tracking=-1..1, Depth=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tracking","min":-1,"max":1},{"name":"Depth","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1278,"detail":0.0837,"edges":0.6066,"complexity":0.6528,"coverage":0.4051,"colour":0.2213,"drift":0.1788},"knobResponse":[0.0822,0.1737,0.1035,0.1471]},{"slug":"orb-weaver","title":"Orb Weaver","family":"halloween","round":43,"note":"보라 몸에 주황 십자가 박힌 왕거미가 128줄을 다 쓰는 둥근 그물을 짜요. 다리실을 띄워 걸고 틀을 친 뒤 방사실을 하나씩 내고, 임시 나선을 거쳐 끈끈한 나선을 바깥에서 안으로 감는데, 긴 아래쪽에서는 오가며 되돌아 채워요. 다 짠 그물에 주황 이슬이 맺혀 반짝이다 돌풍에 찢겨 날아가면 새 그물이 시작돼요. K3 은 방사실을 20개에서 44개로 늘리고, K4 는 바람으로 그물을 6 LED 까지 흔들며, K1 을 누르면 바로 찢어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-orb-weaver","type":"code","name":"orb-weaver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Radii=20..44, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Radii","min":20,"max":44},{"name":"Wind","min":0,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.2322,"detail":0.0987,"edges":0.5353,"complexity":1.1946,"coverage":0.3357,"colour":0.0806,"drift":0.0427},"knobResponse":[0.0472,0.0275,0.0912,0.1028]},{"slug":"order-k-voronoi","title":"Order-k Voronoi","family":"cells","round":76,"note":"떠도는 사이트 열 개에서 LED 마다 가장 가까운 k 개의 모임으로 칠한 차수 k 보로노이 그림이 서고, 아래 막대가 차수마다 영역 수를 세요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-order-k-voronoi","type":"code","name":"order-k-voronoi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Order=1..17, Sites=10..18, Drift=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Order","min":1,"max":17},{"name":"Sites","min":10,"max":18},{"name":"Drift","min":0,"max":1}],"start":[0,2,10,0.06],"measures":{"motion":0.0279,"detail":0.0429,"edges":0.1617,"complexity":1.1635,"coverage":0.9165,"colour":0.5501,"drift":0.0244},"knobResponse":[0.4215,0.2313,0.2691,0.0946]},{"slug":"origami","title":"Origami","family":"paper","round":26,"note":"어두운 호두나무 탁자의 램프 아래에서 청록 종이 한 장이 아홉 단계로 한 주름씩 접혀 종이학이 돼요. 학은 날개를 한 번 친 뒤 다시 펼쳐지고, 펼친 종이에는 산접기와 골접기의 주름 무늬가 남아요. K1 이 세이가이하 무늬 종이와 금박 같은 종이를 고르고, 누르면 학이 바로 펼쳐져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-origami","type":"code","name":"origami","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Sheets=1..3, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sheets","min":1,"max":3},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2431,"detail":0.0239,"edges":0.722,"complexity":0.6298,"coverage":0.2643,"colour":0.177,"drift":0.2549},"knobResponse":[0.2136,0.2519,0.2517,0.0599]},{"slug":"ostwald-ripening","title":"Ostwald Ripening","family":"sim","round":57,"note":"수백 개의 방울이 묽은 용액에 멈춰 선 채 물질을 주고받아서, 평균 반지름보다 작은 방울은 자홍으로 점점 빨리 줄다가 꺼지고 큰 방울은 초록으로 부풀어요. 용액은 작은 방울 둘레에서 옅은 자홍으로, 큰 방울 둘레에서 옅은 초록으로 빛나고, 그 사이를 용질 알갱이가 작은 방울에서 큰 방울로 흘러가요. 방울이 처음의 18% 아래로 줄면 빈자리에 새 무리가 맺혀요. K3 은 새 무리의 방울 수(200~500), K4 는 처음 반지름이 고르지 않은 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ostwald-ripening","type":"code","name":"ostwald-ripening","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drops=200..500, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drops","min":200,"max":500},{"name":"Spread","min":0,"max":1}],"start":[0,2,200,0.06],"measures":{"motion":0.3344,"detail":0.0919,"edges":0.4066,"complexity":1.7547,"coverage":0.46,"colour":0.2135,"drift":0.0942},"knobResponse":[0.1151,0.1039,0.2008,0.1811]},{"slug":"outer-billiards","title":"Outer Billiards","family":"geometry","round":30,"note":"정오각형 밖의 평면을 점마다 꼭짓점 대칭 뛰기 몇 번 만에 제자리로 오는지로 칠했어요. 십각형과 오각형 목걸이가 둘레를 감고, 흰 점 하나가 제 궤도를 뛰어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-outer-billiards","type":"code","name":"outer-billiards","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=5..12, Zoom=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":5,"max":12},{"name":"Zoom","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.5156,"detail":0.1148,"edges":0.7368,"complexity":0.7773,"coverage":0.9999,"colour":0.6754,"drift":0.0832},"knobResponse":[0.5981,0.1953,0.4355,0.388]},{"slug":"palimpsest","title":"Palimpsest","family":"type","round":68,"note":"긁어낸 아르키메데스의 글 위에 직각으로 쓴 그리스어 기도문을 비추는 빛의 띠를 노브로 바꾸면, 평범한 빛에서 거의 사라진 옛 글이 자외선에서 어둡게 살아나고 의사색에서 붉게 갈라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-palimpsest","type":"code","name":"palimpsest","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Band=0..1, Speed=0.2..3, Page=0..3, Ink=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Band","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Page","min":0,"max":3},{"name":"Ink","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1376,"detail":0.0877,"edges":0.1782,"complexity":2.6742,"coverage":1,"colour":0.1535,"drift":0.0588},"knobResponse":[0.2125,0.0897,0.0919,0.0947]},{"slug":"pancakes","title":"Pancakes","family":"kitchen","round":21,"note":"길든 철판을 위에서 내려다봐요. 국자로 부은 반죽이 퍼지고 기포가 올라와 터지며 구멍을 남기는 동안, 뒤집개가 하나씩 뒤집어 노릇한 면을 보이고 다 익은 것을 숯색 접시에 쌓아요. K1 을 누르면 가장 많이 익은 것부터 바로 뒤집거나 접시로 옮겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pancakes","type":"code","name":"pancakes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Batter=0..1, Speed=0.2..3, Pancakes=6..12, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Batter","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pancakes","min":6,"max":12},{"name":"Heat","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2802,"detail":0.2275,"edges":0.2381,"complexity":2.2758,"coverage":0.9979,"colour":0.2408,"drift":0.1011},"knobResponse":[0.1406,0.1266,0.1876,0.1386]},{"slug":"paper-lantern-ghost","title":"Paper Lantern Ghost","family":"halloween","round":50,"note":"비 오는 보라 밤에 처마의 종이 등이 흔들리다 외눈을 뜨고, 이음매가 찢어져 붉은 혀를 늘어뜨리며 웃어요. 그 아래로 외눈 종이우산이 외다리로 웅덩이를 튀기며 뛰어다녀요. K3 은 비, K4 는 우산이 뛰는 높이예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-paper-lantern-ghost","type":"code","name":"paper-lantern-ghost","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Hop=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rain","min":0,"max":1},{"name":"Hop","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.4718,"detail":0.0887,"edges":0.6739,"complexity":0.4158,"coverage":0.8692,"colour":0.2711,"drift":0.1026},"knobResponse":[0.0989,0.1248,0.0626,0.0651]},{"slug":"parallel-transport","title":"Parallel Transport","family":"space","round":68,"note":"도는 구 위에서 금빛 화살을 돌리지 않고 고리를 따라 옮기면, 한 바퀴 뒤 흰 처음 화살 옆에 고리가 두른 넓이만큼 돌아서 서고, 아래 다이얼이 그 넓이를 내내 더해 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-parallel-transport","type":"code","name":"parallel-transport","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Loop=0..3, Size=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Loop","min":0,"max":3},{"name":"Size","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1882,"detail":0.0419,"edges":0.3666,"complexity":0.9362,"coverage":0.3621,"colour":0.1117,"drift":0.0547},"knobResponse":[0.0452,0.0586,0.1086,0.0534]},{"slug":"party-lights","title":"Party Lights","family":"halloween","round":49,"note":"주황과 보라, 독한 초록, 뼈처럼 흰 전구 줄이 어두운 현관 벽에 처지며 빛을 달리고 반짝이고 숨 쉬듯 켜고 박자에 번쩍이며, 바람이 줄을 그네처럼 흔들면 종이 박쥐들이 실에 매달려 빙글 돌아요. K3 은 전구 줄 수, K4 는 바람이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-party-lights","type":"code","name":"party-lights","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Warmth=-1..1, Speed=0.2..3, Strands=3..7, Gust=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Warmth","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":3,"max":7},{"name":"Gust","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2517,"detail":0.0425,"edges":0.2816,"complexity":0.5989,"coverage":0.5355,"colour":0.1816,"drift":0.0855},"knobResponse":[0.0669,0.0544,0.1598,0.0688]},{"slug":"paternoster","title":"Paternoster","family":"machine","round":19,"note":"옛 사무실 건물의 파테르노스터를 기계실에서 피트까지 잘라 보여요. 나무 칸들이 오른쪽으로 오르고 왼쪽으로 내려오며 꼭대기와 바닥의 사슬 바퀴를 넘어가고, 층마다 사람이 지나가는 칸에 올라타고 내려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-paternoster","type":"code","name":"paternoster","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Floors=3..6, Busy=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Floors","min":3,"max":6},{"name":"Busy","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1311,"detail":0.0811,"edges":0.4174,"complexity":0.5845,"coverage":0.8893,"colour":0.2319,"drift":0.047},"knobResponse":[0.1087,0.0733,0.147,0.0325]},{"slug":"paul-trap","title":"Paul Trap","family":"particle","round":61,"note":"세로축을 따라 늘어선 이온 열여섯 개가 RF q 0.3 에서 지그재그로 서고, q 를 올리면 둥근 점 한 줄로 펴졌다가 0.908 을 넘으면 옆으로 번지며 덫 밖으로 날아가요. 빛나지 않는 불순물 이온 둘이 결정에 어두운 틈을 내요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-paul-trap","type":"code","name":"paul-trap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ions=16..40, RF q=0.3..0.95","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ions","min":16,"max":40},{"name":"RF q","min":0.3,"max":0.95}],"start":[0,2,16,0.3],"measures":{"motion":0.0942,"detail":0.0126,"edges":0.1045,"complexity":0.637,"coverage":0.2057,"colour":0.0778,"drift":0.0178},"knobResponse":[0.0325,0.0318,0.0832,0.0398]},{"slug":"pearcey-cusp","title":"Pearcey Cusp","family":"wave","round":54,"note":"LED 마다 피어시 적분을 셈한 파동장이 패널 위쪽의 밝은 초점에서 아래로 첨점 모양으로 열리고, 그 안에 밝은 점 격자와 정확한 영점 76개가 서는데, 영점은 위상이 감기는 쪽에 따라 분홍과 호박색 점으로 찍히고 물마루는 빛이 가는 대로 아래로 흘러요. K3 은 파수를 올려 무늬를 광선의 첨점 곡선 쪽으로 촘촘하게 하고, K4 는 t³ 항으로 첨점을 옆으로 기울여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pearcey-cusp","type":"code","name":"pearcey-cusp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=-1..1, Tilt=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wavenumber","min":-1,"max":1},{"name":"Tilt","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.384,"detail":0.0526,"edges":0.1171,"complexity":2.2537,"coverage":0.9107,"colour":0.1877,"drift":0.1309},"knobResponse":[0.1581,0.1039,0.1218,0.1151]},{"slug":"pearl-sheen","title":"Pearl Sheen","family":"cosmetic","round":30,"note":"펄 안료를 부은 면이 새틴 결로 흘러내려요. 누운 결은 로즈이고 기운 결은 박막 간섭으로 금빛 쪽으로 넘어가며, 긴 반사띠가 면을 가로질러요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-pearl-sheen","type":"code","name":"pearl-sheen","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shift=0..1, Sheen=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shift","min":0,"max":1},{"name":"Sheen","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0507,"detail":0.0087,"edges":0,"complexity":1.7213,"coverage":1,"colour":0.1379,"drift":0.0591},"knobResponse":[0.2049,0.0688,0.0476,0.2033]},{"slug":"peaucellier-linkage","title":"Peaucellier Linkage","family":"line","round":42,"note":"굵은 막대 일곱 개로 짠 포슬리에 반전기가 두 고정 축에 매달려 흔들려요. 크랭크가 마름모의 한 꼭짓점을 주 축을 지나는 원 위로 밀면 맞은편 꼭짓점이 패널 높이의 빛나는 곧은 레일을 오르내려요. K3 은 레일을 주 축에서 51 LED 에서 34 LED 까지 끌어당기고, K4 를 0.08 위로 돌리면 크랭크 축이 비켜나 흰 자취가 레일을 벗어나 원호를 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-peaucellier-linkage","type":"code","name":"peaucellier-linkage","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Arms=0..1, Offset=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Arms","min":0,"max":1},{"name":"Offset","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7241,"detail":0.0522,"edges":0.7187,"complexity":0.3299,"coverage":0.146,"colour":0.1947,"drift":0.1464},"knobResponse":[0.0631,0.1027,0.1212,0.0548]},{"slug":"peel-off","title":"Peel-Off","family":"cosmetic","round":33,"note":"보랏빛 젤 막이 진줏빛 살결을 덮고, 위에서부터 벗겨지는 막이 옅은 안쪽을 드러낸 원통으로 말려 128줄을 내려가요. 막이 아래로 빠지면 젖은 새 막이 위에서 흘러내려 반무광으로 마르고, K3 은 그 막을 비치는 얇은 막에서 거의 불투명한 막까지 두껍게 해요. K1 은 색상환을 다 돌고, 누르면 바로 벗기기 시작해요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-peel-off","type":"code","name":"peel-off","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Thickness=0..1, Curl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Thickness","min":0,"max":1},{"name":"Curl","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2317,"detail":0.0136,"edges":0.1088,"complexity":2.1892,"coverage":1,"colour":0.193,"drift":0.226},"knobResponse":[0.1816,0.2118,0.0647,0.0647]},{"slug":"peg-light","title":"Peg Light","family":"toy","round":18,"note":"1967년 Lite-Brite 처럼 검은 판의 엇갈린 구멍에 색 페그를 하나씩 꽂아 로켓, 돛배, 화분, 물고기, 집, 광대 그림을 채워요. 다 차면 4초 머문 뒤 페그가 위에서부터 쓸려 빠지고 다음 종이가 올라가요. K1 을 누르면 판을 비우고 같은 그림을 처음부터 다시 꽂아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-peg-light","type":"code","name":"peg-light","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Bulb=0..1, Speed=0.2..3, Picture=0..5, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Bulb","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Picture","min":0,"max":5},{"name":"Glow","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0352,"detail":0.2377,"edges":0.8627,"complexity":0.6614,"coverage":0.1604,"colour":0.2171,"drift":0.0512},"knobResponse":[0.0548,0.0566,0.1395,0.0943]},{"slug":"pendulum-wave","title":"Pendulum Wave","family":"physics","round":24,"note":"길이가 조금씩 다른 진자 줄을 위에서 내려다봐요. 한꺼번에 놓은 추들이 한 줄로 흔들리다가 뱀처럼 휘고, 세 줄, 두 줄로 엇갈렸다가 28초 만에 다시 한 줄로 모여요. K1 이 강철에서 놋쇠와 구리를 지나 무지개 유리구슬까지 추를 바꾸고, K4 를 올리면 추가 지나간 자리에 빛 꼬리가 남아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-pendulum-wave","type":"code","name":"pendulum-wave","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Finish=0..1, Speed=0.2..3, Pendulums=16..24, Trails=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Finish","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pendulums","min":16,"max":24},{"name":"Trails","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":0.7632,"detail":0.0304,"edges":0.1868,"complexity":1.4841,"coverage":0.886,"colour":0.0797,"drift":0.0334},"knobResponse":[0.1242,0.0438,0.0523,0.0491]},{"slug":"penney-game","title":"Penney's Game","family":"data","round":69,"note":"동전이 맨 위 줄에 오른쪽에서 한 칸씩 밀려 들어오다 A 나 B 의 세 수가 오른쪽 끝 세 칸을 채우면 그 판이 한 줄 내려가서, 이긴 세 수가 두 사람이 고른 줄 밑에 한 기둥으로 쌓이고 옆의 긴 막대가 콘웨이의 수가 매긴 눈금으로 다가가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-penney-game","type":"code","name":"penney-game","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, A=0..7, Rival=0..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"A","min":0,"max":7},{"name":"Rival","min":0,"max":6}],"start":[0,2,0,0.06],"measures":{"motion":0.4026,"detail":0.1084,"edges":0.9994,"complexity":0.0845,"coverage":0.2584,"colour":0.2286,"drift":0.0283},"knobResponse":[0.0915,0.0665,0.0752,0.0703]},{"slug":"penrose","title":"Penrose","family":"geometry","round":25,"note":"굵은 마름모와 가는 마름모의 펜로즈 타일링이 다섯 겹 대칭의 가운데로 끝없이 들어가요. 가운데서 꽃잎 다섯 장 꼴로 열리는 빛의 고리가 지나가면 타일이 황금비만큼 작은 타일로 나뉘고, 굵은 마름모 다섯이 모인 별은 금색이에요. Glow 를 올리면 유리가 어두워져 고리 뒤만 밝고, K1 을 누르면 연과 화살(P2)로 바뀌어요.","why":"타일 한 칸이 작아서 잘게 보여요(촘촘함 0.26).","block":1,"ramped":false,"layer":{"id":"layer-penrose","type":"code","name":"penrose","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=7..15, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":7,"max":15},{"name":"Glow","min":0,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":1.7979,"detail":0.2641,"edges":0.8556,"complexity":1.1732,"coverage":0.804,"colour":0.583,"drift":0.0983},"knobResponse":[0.4132,0.358,0.3898,0.2306]},{"slug":"penrose-diagram","title":"Penrose Diagram","family":"space","round":60,"note":"끝없는 평평한 시공간을 패널 꼴 그대로인 삼각형에 접어 넣었어요. 지금 면이 과거 무한대에서 미래 무한대로 오르는 동안, r = 0 에서 떠난 금빛 펄스가 가속하는 관찰자의 거울에 튕겨 돌아오거나 지평선 너머 미래 널 무한대로 빠져나가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-penrose-diagram","type":"code","name":"penrose-diagram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grid=0..2, Accel=-2..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grid","min":0,"max":2},{"name":"Accel","min":-2,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1551,"detail":0.1171,"edges":0.9251,"complexity":0.1697,"coverage":0.2999,"colour":0.1713,"drift":0.0412},"knobResponse":[0.056,0.0351,0.0761,0.0366]},{"slug":"penrose-room","title":"Penrose Room","family":"physics","round":33,"note":"거울로 된 펜로즈의 방에서 빛 한 점이 떠돌고, 수백 개의 광선이 반사하며 복도와 위아래 반타원을 밝히는 동안 양옆 방은 캄캄해요. 빛이 반타원을 지나 옆방으로 건너가면 밝은 곳과 어두운 곳이 뒤바뀌어요. K3 은 복도 벽을 초점에서 4 LED 까지 옮겨 어둠에 빛이 새게 하고, K1 을 누르면 빛이 바로 건너가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-penrose-room","type":"code","name":"penrose-room","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Offset=-4..4, Bounces=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Offset","min":-4,"max":4},{"name":"Bounces","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1329,"detail":0.0175,"edges":0.0753,"complexity":1.6655,"coverage":0.6752,"colour":0.1329,"drift":0.3645},"knobResponse":[0.1321,0.1111,0.1163,0.0615]},{"slug":"pentagon-tilings","title":"Pentagon Tilings","family":"cells","round":57,"note":"볼록 오각형 하나의 복사본이 얇은 검은 줄눈을 두고 평면을 덮고, 타일마다 돌아간 각도와 뒤집힘에 따라 색이 달라요. K3 은 라인하르트의 1형, 카이로 타일링(4형), 5형, 마저리 라이스의 13형, 2015년의 15형을 차례로 고르고, 바뀔 때 새 타일이 한 장씩 들어와요. 1형에서는 오각형 모양이 32/Speed 초에 한 바퀴 바뀌어도 타일링이 그대로 이어지고, K4 는 타일 한 장의 넓이를 12×12 에서 28×28 LED 까지 키워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pentagon-tilings","type":"code","name":"pentagon-tilings","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Type=0..4, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Type","min":0,"max":4},{"name":"Size","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7935,"detail":0.1433,"edges":0.4476,"complexity":1.0511,"coverage":0.8837,"colour":0.4538,"drift":0.1235},"knobResponse":[0.3678,0.2701,0.3156,0.2919]},{"slug":"pentomino-cover","title":"Pentomino Cover","family":"algo","round":34,"note":"6×10 직사각형을 크누스의 춤추는 링크가 열두 펜토미노로 채워요. 고를 수가 가장 적은 칸부터 조각을 놓고 막히면 빼서 아래쪽 조각들이 쉴 새 없이 들고 나며 윤곽만 잠깐 남기고, 다 덮이면 2초 동안 빛이 비스듬히 쓸고 판 아래에 눈금이 하나 늘어요. K3 은 판을 5×12, 4×15, 해가 둘뿐인 3×20 으로 바꿔요.","why":"색 블록 열두 개가 판을 덮었다 풀었다 해요. 0514 처럼 굵은 블록이에요.","block":0,"ramped":false,"layer":{"id":"layer-pentomino-cover","type":"code","name":"pentomino-cover","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Board=0..3, Shuffle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Board","min":0,"max":3},{"name":"Shuffle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.8284,"detail":0.0833,"edges":0.9414,"complexity":0.2159,"coverage":0.603,"colour":0.4009,"drift":0.2078},"knobResponse":[0.2347,0.2072,0.3116,0.2483]},{"slug":"percolation","title":"Percolation","family":"cells","round":30,"note":"LED 마다 정해 둔 난수가 p 보다 작으면 열리고, 이어진 자리끼리 제 색의 클러스터가 돼요. p 가 오르다 한 클러스터가 위아래 128줄을 이으면 금빛으로 켜지고 가장 짧은 길이 그어져요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-percolation","type":"code","name":"percolation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Window=0.04..0.2, Small=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Window","min":0.04,"max":0.2},{"name":"Small","min":-1,"max":1}],"start":[0,2,0.04,0.06],"measures":{"motion":0.076,"detail":0.3535,"edges":0.6496,"complexity":2.5378,"coverage":0.6081,"colour":0.3525,"drift":0.1555},"knobResponse":[0.2138,0.2514,0.1582,0.0547]},{"slug":"peregrine-soliton","title":"Peregrine Soliton","family":"wave","round":44,"note":"고른 너울 위로 물마루 하나가 난데없이 너울의 세 배로 솟았다가 가라앉아요. 위쪽 띠는 그 물결의 시공간 기록이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-peregrine-soliton","type":"code","name":"peregrine-soliton","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Family=-1..1, Swell=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Family","min":-1,"max":1},{"name":"Swell","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3681,"detail":0.0209,"edges":0.5771,"complexity":0.0714,"coverage":0.5838,"colour":0.2288,"drift":0.0691},"knobResponse":[0.1304,0.0516,0.0557,0.0772]},{"slug":"perfume-tears","title":"Perfume Tears","family":"cosmetic","round":40,"note":"향수 잔 안쪽 벽을 가까이서 봐요. 알코올이 날아가며 생긴 마랑고니 응력이 바닥의 액체를 얇은 막으로 끌어올리고, 막이 모인 윤기 나는 테가 반지름의 9배 간격으로 부풀어 다리를 끄는 눈물로 미끄러져 내려요. K3 은 테를 굵게 해 눈물을 다섯 줄에서 세 줄의 큰 방울로 바꾸고, 누르면 잔을 휘저어 새 막을 입혀요.","why":"눈물 줄이 가늘고 바탕이 패널을 채워요(채움 0.79).","block":1,"ramped":false,"layer":{"id":"layer-perfume-tears","type":"code","name":"perfume-tears","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rim=0..1, Warmth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rim","min":0,"max":1},{"name":"Warmth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1468,"detail":0.0263,"edges":0.2563,"complexity":1.2316,"coverage":0.7892,"colour":0.1324,"drift":0.0443},"knobResponse":[0.1294,0.0465,0.0512,0.1098]},{"slug":"permutation-poem","title":"Permutation Poem","family":"type","round":81,"note":"구절 하나의 낱말 차례를 모두 내려 쓰고, 새 줄마다 이웃한 두 낱말이 흰빛으로 미끄러져 자리를 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-permutation-poem","type":"code","name":"permutation-poem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..3, Order=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phrase","min":0,"max":3},{"name":"Order","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.7557,"detail":0.1836,"edges":0.9999,"complexity":0.305,"coverage":0.237,"colour":0.1749,"drift":0.0366},"knobResponse":[0.0831,0.0964,0.2079,0.1166]},{"slug":"perron-tree","title":"Perron Tree","family":"geometry","round":29,"note":"키 120 LED 삼각형을 2^n 조각으로 잘라 페론처럼 한 단씩 겹쳐 밀면, 모든 방향을 품은 채 넓이가 30% 로 줄어든 나무가 돼요. 흰 바늘이 모든 방향을 돌며 싹에서 싹으로 건너뛰어요. K3 은 단 수(32~256 조각)이고 K1 을 누르면 삼각형부터 다시 지어요.","why":"검은 바탕에 무지개 빛살이 모였다 퍼져요. 패널의 72% 가 꺼져 있어서 빛살이 또렷해요.","block":0,"ramped":false,"layer":{"id":"layer-perron-tree","type":"code","name":"perron-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=5..8, Slide=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":5,"max":8},{"name":"Slide","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.2474,"detail":0.037,"edges":0.3794,"complexity":1.0174,"coverage":0.2747,"colour":0.1818,"drift":0.2212},"knobResponse":[0.075,0.1981,0.1861,0.1179]},{"slug":"persistence-barcode","title":"Persistence Barcode","family":"topology","round":51,"note":"고리를 따라 흩은 점마다 원판이 자라 고리를 삼키는 동안 아래에서는 그 성장의 바코드가 훑는 선 뒤로 켜지고, 고리 구멍의 긴 주황 막대와 그 구멍을 두른 고리가 같은 색으로 빛나다 구멍이 닫히면 함께 꺼져요. K3 은 점이 원에서 흩어지는 정도, K4 는 점을 뽑는 원의 수(하나, 둘, 셋)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-persistence-barcode","type":"code","name":"persistence-barcode","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Rings=1..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":0,"max":1},{"name":"Rings","min":1,"max":3}],"start":[0,2,0,1],"measures":{"motion":0.1144,"detail":0.0445,"edges":0.7451,"complexity":0.1576,"coverage":0.5181,"colour":0.1784,"drift":0.1563},"knobResponse":[0.0594,0.0757,0.092,0.1101]},{"slug":"phantom-jam","title":"Phantom Jam","family":"sim","round":51,"note":"패널 가장자리의 키 큰 고리 도로를 차들이 앞차와의 간격만 보고 달리면 사고도 공사도 없이 정체가 생겨, 차는 앞으로 가는데 정체는 뒤로 밀려나요. 트랙 안의 시공간 그림에서 차의 선은 한쪽으로, 빨간 정체 줄무늬는 반대쪽으로 기울어요. K3 은 차 수(22~44), K4 는 운전자가 간격에 맞춰 속도를 고치는 민감도 a 이고, 단추를 누르면 출발선 가까운 차가 급정거해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-phantom-jam","type":"code","name":"phantom-jam","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cars=22..44, Sensitivity=0.5..2.5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cars","min":22,"max":44},{"name":"Sensitivity","min":0.5,"max":2.5}],"start":[0,2,22,0.5],"measures":{"motion":0.9389,"detail":0.1182,"edges":0.4636,"complexity":1.3296,"coverage":0.4722,"colour":0.2289,"drift":0.1114},"knobResponse":[0.0559,0.0933,0.1632,0.0768]},{"slug":"phase-spiral","title":"Phase Spiral","family":"sim","round":60,"note":"한 줄 위에서 서로 끌어당기는 면 3072개의 위치를 가로로, 속도를 세로로 찍어요. 차가운 띠가 무너지며 두 팔 나선으로 감기고, 감길수록 팔이 가늘어지는 동안 가운데 하얀 핵이 가라앉아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-phase-spiral","type":"code","name":"phase-spiral","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=0.1..1.2, Lumps=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":0.1,"max":1.2},{"name":"Lumps","min":0,"max":1}],"start":[0,2,0.1,0.06],"measures":{"motion":2.0334,"detail":0.1461,"edges":0.7081,"complexity":1.0491,"coverage":0.3042,"colour":0.3113,"drift":0.1311},"knobResponse":[0.1038,0.1468,0.2578,0.1439]},{"slug":"phasor-noise","title":"Phasor Noise","family":"noise","round":82,"note":"같은 가보르 커널을 더한 복소 장을 위 반에는 허수부로, 아래 반에는 위상만으로 그려서, 소용돌이와 안장을 따라 지문처럼 휘는 줄무늬가 위에서는 군데군데 흐려지고 아래에서는 같은 대비로 갈라지며 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-phasor-noise","type":"code","name":"phasor-noise","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Frequency=8..11, Profile=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Frequency","min":8,"max":11},{"name":"Profile","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.4899,"detail":0.1252,"edges":0.4366,"complexity":2.3092,"coverage":0.5932,"colour":0.1825,"drift":0.1341},"knobResponse":[0.1115,0.2995,0.1868,0.1064]},{"slug":"photochromic","title":"Photochromic","family":"cosmetic","round":38,"note":"LED 마다 맨 폴리시이거나 펄 조각인 옅은 매니큐어 위로 보이지 않는 UV 손전등이 구불구불 쓸고 지나가면, 지나간 자리가 순식간에 짙은 보석 색으로 바뀌었다가 몇 초에 걸쳐 다시 옅어져요. K3 은 펄 조각을 한 LED 에서 네 LED 너비로 키워 굵은 글리터로 바꾸고, K1 을 누르면 지난번과 반대쪽으로 한 번 더 쓸어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-photochromic","type":"code","name":"photochromic","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flakes=1..4, Fade=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flakes","min":1,"max":4},{"name":"Fade","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1311,"detail":0.2098,"edges":0.7508,"complexity":1.4701,"coverage":0.9752,"colour":0.1059,"drift":0.3646},"knobResponse":[0.1323,0.3042,0.2265,0.1945]},{"slug":"photon-disk","title":"Photon Disk","family":"type","round":70,"note":"어두운 유리 원판이 돌다가 줄에 필요한 글자가 12시 창을 지나는 순간 섬광이 그 글자를 하얗게 멈춰 세우고, 렌즈를 지난 빛이 위 필름 띠에 한 자씩 글줄을 쌓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-photon-disk","type":"code","name":"photon-disk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Lens=1..2.25","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Text","min":0,"max":3},{"name":"Lens","min":1,"max":2.25}],"start":[0,2,0,1],"measures":{"motion":0.9592,"detail":0.0688,"edges":0.4781,"complexity":0.5937,"coverage":0.7453,"colour":0.1343,"drift":0.0584},"knobResponse":[0.0503,0.0615,0.065,0.0779]},{"slug":"pin-art","title":"Pin Art","family":"toy","round":22,"note":"핀 아트 장난감을 앞에서 봐요. 엇갈린 격자의 강철 핀 4096개가 패널을 채우고, 뒤에서 펼친 손이 눌러 들어오면 밀려 나온 핀만 비스듬한 등빛을 받아 빛나요. 장난감을 기울이면 핀이 물결치며 평평해지고 열쇠가 다음으로 눌러 들어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pin-art","type":"code","name":"pin-art","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Metal=0..1, Speed=0.2..3, Object=0..4, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Metal","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Object","min":0,"max":4},{"name":"Light","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0617,"detail":0.3463,"edges":0.9544,"complexity":1.3204,"coverage":0.7864,"colour":0.2041,"drift":0.3573},"knobResponse":[0.1597,0.2367,0.0944,0.0463]},{"slug":"pint","title":"Pint","family":"cells","round":18,"note":"탭이 패널 높이만 한 파인트 잔에 맥주를 따르면, 뿌연 맥주가 바닥부터 맑아지고 기포 줄이 오르는 동안 거품 머리가 밝은 테두리의 다각형 셀로 굵어져요. 누군가 다섯 모금에 나눠 마시며 잔에 레이싱 고리를 남기고, 바닥이 보이면 다시 따라요. K1 은 라거에서 앰버 에일, 레드 에일을 지나 스타우트까지 맥주를 바꾸고, 스타우트는 크림빛 서지가 바닥부터 검게 가라앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pint","type":"code","name":"pint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Beer=0..1, Speed=0.2..3, Fizz=4..20, Head=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Beer","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fizz","min":4,"max":20},{"name":"Head","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.1411,"detail":0.0425,"edges":0.5054,"complexity":1.0501,"coverage":0.678,"colour":0.3448,"drift":0.1113},"knobResponse":[0.1725,0.2433,0.0546,0.0641]},{"slug":"pinwheel-tiling","title":"Pinwheel Tiling","family":"geometry","round":32,"note":"다리가 1 과 2 인 직각삼각형 타일링 속으로 끝없이 들어가요. 3.6초마다 타일마다 이음매가 옅게 나타나 다섯 조각으로 갈라지고, 그 가운데 하나는 부모에서 26.6° 돌아가 있어요. 타일을 긴 다리의 방향으로 칠해서, 같은 색 무리가 서로 다른 각도로 기운 것이 보여요.","why":"삼각형이 잘고 패널을 다 채워요.","block":1,"ramped":false,"layer":{"id":"layer-pinwheel-tiling","type":"code","name":"pinwheel-tiling","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=13..40, Paint=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":13,"max":40},{"name":"Paint","min":0,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":2.1331,"detail":0.1861,"edges":0.7085,"complexity":1.6658,"coverage":0.856,"colour":0.5245,"drift":0.1667},"knobResponse":[0.362,0.3049,0.2869,0.2296]},{"slug":"pipe-organ","title":"Pipe Organ","family":"music","round":24,"note":"어두운 성당의 파이프오르간 정면이 패널을 채워요. 보이지 않는 오르가니스트가 여덟 화음 코랄을 되풀이하면, 소리 나는 파이프마다 입에서 빛이 켜지고 몸통을 따라 정상파 띠가 올라가요. 가운데 가장 긴 파이프가 가장 낮은 음이에요. K1 이 플루트의 파랑, 프린시펄의 은빛, 리드의 금빛과 빨강 사이에서 음전을 고르고, K1 을 누르면 파이프 열아홉이 다 울려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pipe-organ","type":"code","name":"pipe-organ","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stops=0..1, Tempo=0.2..3, Voices=1..6, Tremulant=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stops","min":0,"max":1},{"name":"Tempo","min":0.2,"max":3},{"name":"Voices","min":1,"max":6},{"name":"Tremulant","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1017,"detail":0.1071,"edges":0.5078,"complexity":2.0828,"coverage":0.7769,"colour":0.1713,"drift":0.0578},"knobResponse":[0.0627,0.0467,0.0469,0.0424]},{"slug":"pit-pendulum","title":"Pit and Pendulum","family":"halloween","round":49,"note":"횃불 켠 지하 감옥에서 커다란 초승달 칼날이 벽에 그림자를 휘두르며 한 번 지날 때마다 돌 침대 쪽으로 내려오고, 쥐들이 모여들다 손 한 뼘 위에서 횃불이 잦아들면 쇠사슬이 칼날을 어둠 속으로 끌어올려요. K3 은 한 번 지날 때 내려오는 깊이, K4 는 횃불이 닿는 거리예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pit-pendulum","type":"code","name":"pit-pendulum","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Descent=3..12, Torch=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Descent","min":3,"max":12},{"name":"Torch","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.467,"detail":0.0443,"edges":0.561,"complexity":0.2314,"coverage":0.7215,"colour":0.3226,"drift":0.122},"knobResponse":[0.2235,0.0975,0.0758,0.1337]},{"slug":"pivot-walk","title":"Pivot Walk","family":"sim","round":42,"note":"정사각 격자 위의 자기 회피 걸음 80걸음이 아쿠아에서 분홍으로 물든 빛 사슬로 떠 있고, 피벗 알고리즘이 고른 점에서 한쪽 팔을 90도나 180도 휘둘러 돌리거나 접어 넘겨요. K3 은 사슬을 160걸음까지 늘려 격자를 붐비게 하고, K4 는 꺾일 때마다 값을 매겨 사슬을 머리핀처럼 곧게 접어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pivot-walk","type":"code","name":"pivot-walk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=80..160, Stiff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":80,"max":160},{"name":"Stiff","min":0,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":0.8312,"detail":0.0373,"edges":0.5081,"complexity":0.3132,"coverage":0.1302,"colour":0.233,"drift":0.1532},"knobResponse":[0.0557,0.104,0.1579,0.1024]},{"slug":"plait","title":"Plait","family":"textile","round":15,"note":"세 가닥이 바깥 가닥부터 가운데 위로 넘어가며 땋여 내려가요. 밑으로 들어가는 가닥은 어둡고, 다 땋으면 리본을 묶고 다음 가닥이 내려와요. K3 이 일곱 가닥 납작 땋기까지 가요.","why":"굵은 세 가닥이 땋였다 풀려요. 잰 값 일곱이 프리셋과 가장 가까운 패턴이에요.","block":0,"ramped":false,"layer":{"id":"layer-plait","type":"code","name":"plait","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Tension=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":3,"max":7},{"name":"Tension","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":1.0033,"detail":0.0467,"edges":0.1711,"complexity":1.4043,"coverage":0.7414,"colour":0.4415,"drift":0.2976},"knobResponse":[0.2929,0.2273,0.2358,0.2751]},{"slug":"plancherel-growth","title":"Plancherel Growth","family":"data","round":45,"note":"영 도형이 무작위 수의 RSK 끼워 넣기로 마름모 칸을 하나씩 얻으며 왼쪽 가운데 모서리에서 오른쪽으로 자라요. 처음부터 그려 둔 로건-셰프와 베르시크-케로프의 극한 곡선 쪽으로 차오르고, 칸 색이 들어온 차례라서 색 띠가 같은 곡선을 작게 겹쳐 놓은 꼴이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-plancherel-growth","type":"code","name":"plancherel-growth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=3..6, Curve=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":3,"max":6},{"name":"Curve","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0444,"detail":0.0937,"edges":0.9992,"complexity":0.2243,"coverage":0.2569,"colour":0.3661,"drift":0.2665},"knobResponse":[0.0558,0.0775,0.1391,0.0494]},{"slug":"platycosms","title":"Platycosms","family":"space","round":71,"note":"닫혀 있지만 평평한 우주를 날면 큐브마다 같은 세 팔 잭의 사본이 보이고, 처음 여는 4분의 1 바퀴 공간에서는 z 로 한 칸 지날 때마다 사본이 4분의 1 바퀴씩 돌아 있어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-platycosms","type":"code","name":"platycosms","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Space=0..3, Heading=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Space","min":0,"max":3},{"name":"Heading","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6245,"detail":0.0429,"edges":0.1361,"complexity":1.2399,"coverage":0.2591,"colour":0.1174,"drift":0.1203},"knobResponse":[0.0365,0.1009,0.1004,0.1283]},{"slug":"player-piano","title":"Player Piano","family":"music","round":15,"note":"자동 피아노의 구멍 뚫린 종이 두루마리가 내려와요. 구멍이 트래커 바를 지날 때마다 발치의 건반이 눌려 빛나요. 곡은 패턴이 그 자리에서 지어서, 화음은 가로줄로, 펼친 화음은 사선으로 읽혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-player-piano","type":"code","name":"player-piano","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=0.5..3.5, Hands=2..5, Pedal=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":0.5,"max":3.5},{"name":"Hands","min":2,"max":5},{"name":"Pedal","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.3229,"detail":0.0822,"edges":0.6181,"complexity":0.1256,"coverage":0.9461,"colour":0.1765,"drift":0.0751},"knobResponse":[0.0626,0.0796,0.0519,0.0503]},{"slug":"plucked-letters","title":"Plucked Letters","family":"type","round":80,"note":"곧은 획만으로 된 HYMN 이 둘씩 두 줄로 서서 획마다 두 핀 사이의 줄이 되고, 글자마다 긴 줄부터 짧은 줄 차례로 뜯기면 번쩍인 줄의 세모가 두 꺾임으로 갈라져 핀까지 달려갔다가 뒤집혀 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-plucked-letters","type":"code","name":"plucked-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Pluck=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":7},{"name":"Pluck","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4282,"detail":0.0514,"edges":0.637,"complexity":0.5822,"coverage":0.2003,"colour":0.1617,"drift":0.0784},"knobResponse":[0.0586,0.0535,0.1017,0.0308]},{"slug":"pole-vault","title":"Pole Vault","family":"sport","round":26,"note":"밤 경기장에서 카메라가 장대를 든 선수를 따라 달리고, 활처럼 휜 장대를 타고 거꾸로 오른 선수가 패널 꼭대기 가까운 가로대를 넘어 매트에 떨어지면 심판이 흰 깃발이나 빨간 깃발을 들어요. K3 이 가로대를 5.00 m 에서 6.20 m 까지 올리고, 누르면 다음 선수가 바로 달려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pole-vault","type":"code","name":"pole-vault","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Bar=5..6.2, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bar","min":5,"max":6.2},{"name":"Wind","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.7696,"detail":0.0793,"edges":0.2827,"complexity":0.9294,"coverage":0.6904,"colour":0.1943,"drift":0.0642},"knobResponse":[0.0451,0.0895,0.0561,0.043]},{"slug":"pollards-rho","title":"Pollard's Rho","family":"algo","round":81,"note":"x² + c 를 숨은 소인수로 나눈 나머지가 세로로 선 ρ 를 그리고, 그 위를 쫓는 거북이와 토끼가 만나면 gcd 가 1 에서 그 소인수로 뛰어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pollards-rho","type":"code","name":"pollards-rho","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Number=0..7, Constant=1..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Number","min":0,"max":7},{"name":"Constant","min":1,"max":6}],"start":[0,2,0,1],"measures":{"motion":0.1802,"detail":0.0868,"edges":0.7772,"complexity":0.3335,"coverage":0.193,"colour":0.1932,"drift":0.0856},"knobResponse":[0.0507,0.0718,0.0804,0.0606]},{"slug":"poltergeist","title":"Poltergeist","family":"halloween","round":45,"note":"기름등 하나가 흔들리는 응접실에서 책이 선반을 떠나 새처럼 퍼덕이며 날고, 접시와 의자도 초록 자국을 끌며 떠다녀요. 5초쯤 뒤 모두 한꺼번에 떨어지면 방이 흔들리고 등불이 잦아들었다가 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-poltergeist","type":"code","name":"poltergeist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fury=1..5, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fury","min":1,"max":5},{"name":"Lamp","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.6173,"detail":0.0348,"edges":0.4085,"complexity":0.3353,"coverage":0.9466,"colour":0.3788,"drift":0.2391},"knobResponse":[0.0347,0.079,0.0371,0.0901]},{"slug":"polya-orchard","title":"Pólya's Orchard","family":"space","round":45,"note":"가운데 등불 빛이 정수 격자 위 나무 48그루 사이로 새어 나가 패널 끝까지 닿는 가는 빛살이 돼요. 줄기가 문턱 1/R 까지 굵어지면 빛살이 여덟 개씩 꺼지고, 마지막 여덟은 과수원 바로 밖의 격자점 (4,1) 쪽을 가리켜요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-polya-orchard","type":"code","name":"polya-orchard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Trunk=0.45..0.95, Walk=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Trunk","min":0.45,"max":0.95},{"name":"Walk","min":0,"max":1}],"start":[0,2,0.45,0.06],"measures":{"motion":0.0713,"detail":0.0697,"edges":0.6282,"complexity":0.6251,"coverage":0.3033,"colour":0.2519,"drift":0.2064},"knobResponse":[0.0802,0.2383,0.0499,0.0695]},{"slug":"polya-urn","title":"Pólya Urn","family":"data","round":38,"note":"폴리아 항아리 64개가 한 열에 하나씩 나란히 공을 뽑아요. 로그 시계를 따라 위에서는 크게 흔들리다 아래로 가며 저마다 다른 섞임 비율로 굳고, 한 판이 끝나면 열들이 굳은 비율대로 줄을 서서 고르게 퍼진 극한을 곧은 그러데이션으로 보여 줘요. K3 은 처음 공을 늘려 열들을 가운데 섞임으로 모으고, K4 는 한 번에 더하는 공을 늘려 바코드를 두 색으로 갈라요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-polya-urn","type":"code","name":"polya-urn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Balls=1..8, Added=1..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Balls","min":1,"max":8},{"name":"Added","min":1,"max":8}],"start":[0,2,1,1],"measures":{"motion":0.0395,"detail":0.0065,"edges":0.0554,"complexity":1.2351,"coverage":1,"colour":0.4287,"drift":0.1821},"knobResponse":[0.3523,0.0975,0.0619,0.0708]},{"slug":"polynomial-amoeba","title":"Polynomial Amoeba","family":"topology","round":64,"note":"두 변수 다항식의 영점을 두 좌표의 절댓값 로그로 옮긴 아메바가 통통한 불가사리에서 가는 열대 사다리로 천천히 줄었다 부풀어요. 뉴턴 다각형의 안쪽 점 셋에 맞는 구멍 셋이 위아래로 쌓여 차례로 열리고 닫히고, 금빛 실이 아메바가 줄어드는 열대 곡선을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-polynomial-amoeba","type":"code","name":"polynomial-amoeba","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lift=-1..1, Phase=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lift","min":-1,"max":1},{"name":"Phase","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0535,"detail":0.0378,"edges":0.493,"complexity":0.3484,"coverage":0.2824,"colour":0.1971,"drift":0.2648},"knobResponse":[0.1498,0.1433,0.2533,0.0838]},{"slug":"polytope-slices","title":"Polytope Slices","family":"space","round":41,"note":"천천히 기우는 4차원 정다포체가 세로로 쌓인 초평면 세 장을 위에서부터 지나가요. 단면마다 4차원 칸의 색을 입은 입체가 돌면서 점에서 자라고, 꼭짓점 층을 지날 때마다 모양을 바꾸다 사라져요. K3 은 정24포체, 테서랙트, 정16포체, 정5포체를 고르고, K4 는 초평면을 칸 쪽에서 꼭짓점 쪽으로 기울여 정24포체의 가운데 단면을 육팔면체에서 마름모십이면체로 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-polytope-slices","type":"code","name":"polytope-slices","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Polytope=0..3, Tilt=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Polytope","min":0,"max":3},{"name":"Tilt","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0849,"detail":0.0942,"edges":0.9098,"complexity":0.1234,"coverage":0.3802,"colour":0.2925,"drift":0.379},"knobResponse":[0.2195,0.2306,0.2519,0.1928]},{"slug":"poncelet-porism","title":"Poncelet Porism","family":"line","round":41,"note":"꼭짓점은 세로로 긴 타원에, 변은 안쪽 작은 타원에 닿는 삼각형 셋이 같이 미끄러져 돌아요. 안쪽 타원이 가까운 끝에서는 꼭짓점이 1초에 7.5 LED 로 기고 먼 끝에서는 39 LED 로 달리는데, 어디서 출발한 삼각형이든 늘 닫혀요. K3 은 사각형과 {5/2}, {7/2}, {7/3}, {8/3} 별로 바꾸고, K4 를 1 로 돌리면 두 원의 중심이 겹쳐 정다각형을 늘인 꼴로 돌아요. K1 을 누르면 두 원이 반 바퀴 돌아 꼭짓점이 몰리는 끝이 반대편으로 가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-poncelet-porism","type":"code","name":"poncelet-porism","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Centre=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":5},{"name":"Centre","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.203,"detail":0.0507,"edges":0.6256,"complexity":0.6557,"coverage":0.4223,"colour":0.4028,"drift":0.1814},"knobResponse":[0.2031,0.1803,0.2827,0.2014]},{"slug":"pop-up-book","title":"Pop-up Book","family":"paper","round":21,"note":"탁자에 펼친 팝업북에서 성과 숲, 등대, 도시가 종이 카드 여러 겹으로 일어서고, 그동안 달이 홈을 따라 가고 사슴이 고개를 숙여요. 페이지가 넘어가면 장면이 가운데 접힌 선으로 납작하게 눕고, 넘어오는 페이지에서 다음 장면이 일어나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-pop-up-book","type":"code","name":"pop-up-book","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spread=0..3, Speed=0.2..3, Layers=4..6, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spread","min":0,"max":3},{"name":"Speed","min":0.2,"max":3},{"name":"Layers","min":4,"max":6},{"name":"Lamp","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.2969,"detail":0.0558,"edges":0.4541,"complexity":0.5762,"coverage":0.9872,"colour":0.1893,"drift":0.1346},"knobResponse":[0.1392,0.0773,0.0475,0.1266]},{"slug":"popcorn","title":"Popcorn","family":"kitchen","round":19,"note":"영화관 팝콘 수레가 128줄을 다 써요. 케틀에서 낟알이 터져 뛰고 넘쳐 떨어지다가 케틀이 기울어 한 배치를 더미에 쏟고, K1 을 누르면 스쿱이 더미를 떠 가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-popcorn","type":"code","name":"popcorn","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Heat=0.2..3, Batch=6..16, Heap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Heat","min":0.2,"max":3},{"name":"Batch","min":6,"max":16},{"name":"Heap","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2278,"detail":0.0649,"edges":0.5093,"complexity":0.7081,"coverage":0.9514,"colour":0.2616,"drift":0.0636},"knobResponse":[0.0358,0.0496,0.0725,0.0766]},{"slug":"population-pyramid","title":"Population Pyramid","family":"data","round":25,"note":"가상의 나라의 인구 피라미드가 한 살에 한 줄씩 움직여요. 왼쪽이 남자, 오른쪽이 여자이고, 10년마다 태어난 세대가 제 색 띠로 해마다 한 줄씩 올라가요. 1995년의 베이비붐 띠가 위로 올라가 2060년에 위가 무거운 항아리꼴이 되면, 1820년의 뾰족한 삼각형으로 돌아가 240년을 다시 지나요. K3 을 내리면 아래가 좁아져 거꾸로 선 피라미드가 되고, K1 을 누르면 그해가 전쟁이나 유행병이 되어 패인 홈이 위로 올라가요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-population-pyramid","type":"code","name":"population-pyramid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..1, Speed=0.25..6, Births=-1..1, Migration=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":1},{"name":"Speed","min":0.25,"max":6},{"name":"Births","min":-1,"max":1},{"name":"Migration","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1321,"detail":0.0783,"edges":0.6662,"complexity":0.212,"coverage":0.4183,"colour":0.3565,"drift":0.1142},"knobResponse":[0.1688,0.1844,0.07,0.0935]},{"slug":"potters-wheel","title":"Potter's Wheel","family":"pottery","round":24,"note":"밤의 도자기 공방에서 녹색 갓 램프 아래 물레가 돌아요. 두 손이 흙덩이를 가운데로 모아 벽을 끌어올리면 그릇이 76~92줄 높이로 자라고, 물레 자국이 램프 쪽에서 반짝이며 옆으로 흘러가요. 다 빚은 병과 항아리는 줄로 잘려 선반에 올라가 젖은 흙빛에서 하얗게 말라 가요. K1 이 흙을 테라코타에서 검은 흙까지 바꾸고, K1 을 누르면 그릇이 주저앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-potters-wheel","type":"code","name":"potters-wheel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Clay=0..1, Speed=0.2..3, Pots=6..20, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Clay","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pots","min":6,"max":20},{"name":"Lamp","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.6649,"detail":0.0524,"edges":0.2558,"complexity":1.7276,"coverage":0.8999,"colour":0.2006,"drift":0.0739},"knobResponse":[0.0662,0.0422,0.05,0.1325]},{"slug":"powder-burst","title":"Powder Burst","family":"cosmetic","round":37,"note":"어두운 스튜디오 바닥의 파우더 케이크가 6.3초마다 좌우를 번갈아 맞아 터지고, 마젠타 파우더가 둥근 머리를 이고 4초쯤 만에 패널 꼭대기 언저리까지 솟아요. 머리는 고리로 말리며 버섯 꼴이 되고, 가장자리에서 고운 먼지가 말려 나가고 무거운 알갱이는 포물선을 그리며 떨어지고, 운모가 가끔 반짝여요. K3 은 머리를 패널보다 넓게 키워 위로 빠져나가게 하고, K4 는 운모를 한 번에 1,460조각까지 늘려요. 누르면 바로 케이크를 쳐요.","why":"검은 바탕의 자홍 구름이 좋은데 모양이 흐릿해요(가장자리 0.05).","block":1,"ramped":false,"layer":{"id":"layer-powder-burst","type":"code","name":"powder-burst","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Force=0..1, Shimmer=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Force","min":0,"max":1},{"name":"Shimmer","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.285,"detail":0.0166,"edges":0.0495,"complexity":1.3583,"coverage":0.4791,"colour":0.3931,"drift":0.3981},"knobResponse":[0.3053,0.2228,0.1341,0.0525]},{"slug":"prandtl-membrane","title":"Prandtl's Membrane","family":"type","round":75,"note":"비틀린 막대의 단면인 낱말마다 프란틀의 막을 씌워 부풀리면, 막이 4초마다 숨 쉬듯 부풀었다 가라앉고 응력에 따라 등성이는 파랗게, 테두리와 안쪽 모서리는 주황과 노랑으로 달아올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-prandtl-membrane","type":"code","name":"prandtl-membrane","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Twist=0.2..3, Word=0..3, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Twist","min":0.2,"max":3},{"name":"Word","min":0,"max":3},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0468,"detail":0.0421,"edges":0.2612,"complexity":1.2114,"coverage":0.5996,"colour":0.5715,"drift":0.1227},"knobResponse":[0.3827,0.3118,0.3423,0.0613]},{"slug":"prince-ruperts-cube","title":"Prince Rupert's Cube","family":"geometry","round":40,"note":"가운데가 정사각형으로 뚫린 정육면체가 천천히 돌고, 그보다 1.06066 배 큰 정육면체가 밑에서 올라와 그 굴을 벽에 딱 붙어 지나가요. K1 을 0 위로 돌리면 지나가던 정육면체가 굴 어귀에 걸려 붉게 빛나며 두드리고, K4 는 굴의 방향을 긴 대각선 쪽으로 돌려 굴을 √6 − √2 까지 좁혀요.","why":"큰 색면이 좋은데 입체 퍼즐이라 무엇을 보는지 설명이 있어야 해요.","block":1,"ramped":false,"layer":{"id":"layer-prince-ruperts-cube","type":"code","name":"prince-ruperts-cube","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Fit=-1..1, Speed=0.2..3, Tilt=0..1, Bore=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Fit","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":0,"max":1},{"name":"Bore","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2252,"detail":0.0228,"edges":0.4539,"complexity":0.321,"coverage":0.2784,"colour":0.1731,"drift":0.1972},"knobResponse":[0.1587,0.1741,0.0803,0.1549]},{"slug":"print-gallery","title":"Print Gallery","family":"fractal","round":58,"note":"두 배씩 커지는 사각 고리 넷에 체커를 깐 드로스테 그림을 드 스밋과 렌스트라의 사상으로 비틀어, 네 빛깔 고리가 나선 팔 넷으로 이어지고 흰 액자는 나선 선 하나가 돼요. 5.6초마다 10.2배 확대와 59도 회전을 마치면 LED 하나 다르지 않은 같은 그림으로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-print-gallery","type":"code","name":"print-gallery","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=16..256, Unwind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":16,"max":256},{"name":"Unwind","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":2.1371,"detail":0.126,"edges":0.6593,"complexity":0.6183,"coverage":0.9229,"colour":0.4682,"drift":0.1907},"knobResponse":[0.3459,0.3261,0.3464,0.3498]},{"slug":"promotion","title":"Promotion","family":"algo","round":74,"note":"8×16 칸 표준 영 타블로에서 1 이 빠진 흰 구멍이 오른쪽과 아래 이웃 가운데 작은 수를 끌어당기며 오른쪽 아래 모서리로 미끄러지고 그 자리에 128 이 들어가기를 되풀이해서, 128번째에 모든 칸이 처음 수로 돌아와 번쩍여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-promotion","type":"code","name":"promotion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=-1..2, Levels=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":-1,"max":2},{"name":"Levels","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0482,"detail":0.1424,"edges":0.8812,"complexity":0.1807,"coverage":0.8191,"colour":0.5896,"drift":0.0361},"knobResponse":[0.4167,0.0649,0.3047,0.1092]},{"slug":"proscenium","title":"Proscenium","family":"stage","round":23,"note":"금박 프로시니엄 아래 붉은 벨벳 막이 플라이로 올라가면 달빛 바다나 숲, 밤 도시, 눈 내리는 마을을 그린 배경막이 드러나고, 브리지 조명의 빛줄기가 연무를 갈라요. 발레리나가 팔로 스폿을 받으며 도약해 무대를 건너고, 막이 내리면 막 앞에서 인사해요. 맨 아래에는 실크해트를 쓴 사람이 섞인 앞줄 관객의 뒤통수가 있어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-proscenium","type":"code","name":"proscenium","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gel=0..1, Speed=0.2..3, Scene=0..3, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gel","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scene","min":0,"max":3},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1444,"detail":0.0876,"edges":0.3879,"complexity":1.7658,"coverage":0.8713,"colour":0.2563,"drift":0.0949},"knobResponse":[0.0636,0.1625,0.077,0.1771]},{"slug":"pulse-bars","title":"Pulse Bars","family":"rhythm","round":1,"note":"음악 없는 하이파이 미터예요. 작은 드럼 머신이 혼자 치고 막대는 그 소리를 듣는 듯 춤춰요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-pulse-bars","type":"code","name":"pulse-bars","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Tempo=90..180, Bars=8..32, Decay=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Tempo","min":90,"max":180},{"name":"Bars","min":8,"max":32},{"name":"Decay","min":0,"max":1}],"start":[0,90,8,0.06],"measures":{"motion":0.7885,"detail":0.0861,"edges":0.9999,"complexity":0.1776,"coverage":0.2209,"colour":0.2463,"drift":0.1392},"knobResponse":[0.0897,0.0556,0.0615,0.0607]},{"slug":"pumpkin-carving","title":"Pumpkin Carving","family":"halloween","round":47,"note":"밤 탁자 위 큰 호박을 칼날이 한 조각씩 도려내 눈과 코와 이빨 난 입을 내고, 성냥불로 촛불이 붙으면 얼굴이 금빛으로 일렁이며 탁자에 빛이 번져요. 촛불이 꺼지면 호박이 돌아 새 얼굴을 깎아요. K3 은 얼굴이 사나운 정도, K4 는 빛이 번지는 거리예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pumpkin-carving","type":"code","name":"pumpkin-carving","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Warmth=-1..1, Speed=0.2..3, Fierce=0..1, Spill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Warmth","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fierce","min":0,"max":1},{"name":"Spill","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2082,"detail":0.0243,"edges":0.2464,"complexity":0.2244,"coverage":0.6689,"colour":0.4453,"drift":0.0568},"knobResponse":[0.0767,0.066,0.073,0.0698]},{"slug":"pumpkin-drop","title":"Pumpkin Drop","family":"halloween","round":52,"note":"구름 낀 보라 밤에 촛불 켠 호박 등이 도르래 틀 꼭대기까지 감겨 올라가 흔들리다 놓여 128줄을 떨어지고, 땅에서 터져 조각과 씨를 흩뿌려요. 초는 굴러 나가 연기를 피우며 꺼지고, 다음 호박이 들어와 불을 켜요. K3 은 바람, K4 는 호박 크기이고, K1 을 누르면 매달린 호박을 바로 놓아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pumpkin-drop","type":"code","name":"pumpkin-drop","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Flame=0..1, Speed=0.2..3, Wind=0..1, Size=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Flame","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":0,"max":1},{"name":"Size","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1522,"detail":0.0251,"edges":0.3346,"complexity":0.5423,"coverage":0.9732,"colour":0.1929,"drift":0.1447},"knobResponse":[0.0342,0.0693,0.0419,0.088]},{"slug":"pumpkin-vine","title":"Pumpkin Vine","family":"halloween","round":47,"note":"보랏빛 밤 언덕에서 호박 덩굴이 128줄을 감아 오르며 잎을 펼치고 덩굴손을 감고, 마디의 작은 호박이 부풀어 아래부터 하나씩 호박 등으로 켜져요. 다 자라면 시들어 사라지고 새 덩굴이 자라요. K3 은 덩굴 수, K4 는 감기는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-pumpkin-vine","type":"code","name":"pumpkin-vine","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spell=0..1, Speed=0.2..3, Vines=1..3, Curl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spell","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Vines","min":1,"max":3},{"name":"Curl","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0579,"detail":0.0293,"edges":0.4367,"complexity":0.7474,"coverage":0.974,"colour":0.4569,"drift":0.3473},"knobResponse":[0.1395,0.1093,0.0659,0.0529]},{"slug":"quadratic-reciprocity","title":"Quadratic Reciprocity","family":"number","round":59,"note":"홀수 소수 64개의 르장드르 기호가 LED 하나에 한 쌍씩 잔 결로 깔린 표 둘을 십자가가 대각선을 따라 훑으며 한 쌍과 거울쌍을 견주고, 두 소수가 다 4로 나눠 3 남는 쌍만 초록으로 남아요. 위 표는 자연순이라 초록이 격자무늬로 흩어지고, 아래 표는 4로 나눠 1 남는 소수를 앞에 둬서 초록이 34×34 구석 한 칸에 모여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quadratic-reciprocity","type":"code","name":"quadratic-reciprocity","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..5, Start=0..400, Law=0.25..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":5},{"name":"Start","min":0,"max":400},{"name":"Law","min":0.25,"max":1}],"start":[0,2,0,0.25],"measures":{"motion":0.032,"detail":0.3336,"edges":0.8903,"complexity":0.4799,"coverage":1,"colour":0.2813,"drift":0.0297},"knobResponse":[0.1738,0.0533,0.336,0.0431]},{"slug":"quantum-walk","title":"Quantum Walk","family":"sim","round":79,"note":"하다마르 동전을 단 양자 걸음이 한 걸음에 한 줄씩 시공간 도표를 써 내려가요. 동전이 L 인 쪽의 확률이 원뿔을 채우며 겹겹의 어두운 호로 갈라지고 두 앞머리 ±t/√2 가 하얗게 빛나다가, 가운데로 고전 걸음의 √t 금빛 점선이 내려와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quantum-walk","type":"code","name":"quantum-walk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Measure=0..1, Coin=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Measure","min":0,"max":1},{"name":"Coin","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0653,"detail":0.2127,"edges":0.8034,"complexity":1.0607,"coverage":0.4719,"colour":0.4591,"drift":0.378},"knobResponse":[0.2908,0.2271,0.2592,0.2987]},{"slug":"question-mark","title":"Question Mark Function","family":"number","round":55,"note":"민코프스키의 물음표 함수가 속을 채운 계단으로 서서 황금비 점 1/φ 를 향해 끝없이 확대되고 한 주기마다 그래프 전체의 사본 안으로 들어가 이음매 없이 돌아오는 동안, 계단에는 패리 분수에서 꺾이는 이분 높이선이 붙고 아래 두 줄에는 그 점의 연분수 자릿수와 ?(x) 의 이진 자릿수가 같은 길이의 덩어리로 맞물려 흘러가요. K3 은 확대해 들어가는 이차 무리수 여섯, K4 는 표시하는 패리 나무의 단 수(3~7)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-question-mark","type":"code","name":"question-mark","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Point=0..5, Depth=3..7","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Point","min":0,"max":5},{"name":"Depth","min":3,"max":7}],"start":[0,2,0,3],"measures":{"motion":0.4067,"detail":0.0603,"edges":0.5728,"complexity":0.6613,"coverage":0.516,"colour":0.2092,"drift":0.0557},"knobResponse":[0.1262,0.0936,0.0953,0.0863]},{"slug":"quipu","title":"Quipu","family":"type","round":78,"note":"주 끈에 늘어뜨린 끈마다 10진 자리 매듭으로 수를 적고, 끈이 셀 때마다 바뀐 값이 주 끈을 달려 끝의 합 끈에 더해져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quipu","type":"code","name":"quipu","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cords=5..8, Step=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cords","min":5,"max":8},{"name":"Step","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.1644,"detail":0.1015,"edges":0.9704,"complexity":0.1354,"coverage":0.2153,"colour":0.1832,"drift":0.0299},"knobResponse":[0.0649,0.0412,0.1565,0.0391]},{"slug":"quousque-tandem","title":"Quousque Tandem","family":"type","round":70,"note":"캐즐런 견본처럼 키케로의 글줄 하나를 크기만 줄여 왼쪽 정렬로 쌓아, 위는 읽히는 큰 글자이고 아래는 1 LED 보다 작은 글자의 회색 결이 되며, 줄마다 윗줄 크기로 자라는 확대가 끝없이 돌아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-quousque-tandem","type":"code","name":"quousque-tandem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=0.7..0.9, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":0.7,"max":0.9},{"name":"Weight","min":0,"max":1}],"start":[0,2,0.7,0.06],"measures":{"motion":1.2978,"detail":0.2148,"edges":0.1725,"complexity":0.7449,"coverage":0.9348,"colour":0.1479,"drift":0.1172},"knobResponse":[0.1877,0.214,0.1904,0.1525]},{"slug":"rabbit-ears","title":"Rabbit Ears","family":"glitch","round":19,"note":"옛 TV 가 토끼 귀 안테나로 늦은 밤 일기예보를 잡아요. 신호가 흔들리면 진행자와 지도가 색을 잃고 눈 속으로 사라졌다가 블랭킹 띠와 함께 굴러 돌아오고, 오른쪽에는 고스트가 따라붙어요. K1 을 누르면 TV 를 쳐서 그림이 한 바퀴 굴러요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rabbit-ears","type":"code","name":"rabbit-ears","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tint=0..1, Speed=0.2..3, Signal=0..1, Ghost=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tint","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Signal","min":0,"max":1},{"name":"Ghost","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.2448,"detail":0.1335,"edges":0.365,"complexity":2.3725,"coverage":0.9855,"colour":0.1077,"drift":0.2857},"knobResponse":[0.1208,0.2747,0.0525,0.0711]},{"slug":"rabi-chevron","title":"Rabi Chevron","family":"wave","round":77,"note":"가로는 이조, 세로는 펄스 길이로 두 준위 원자가 들뜰 확률을 칠해, 라비 셰브런의 겹겹 V 가 쉬지 않고 위로 흘러가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rabi-chevron","type":"code","name":"rabi-chevron","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Span=0..1, Damping=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Span","min":0,"max":1},{"name":"Damping","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.2224,"detail":0.0733,"edges":0.0896,"complexity":1.2279,"coverage":1,"colour":0.3557,"drift":0.032},"knobResponse":[0.2961,0.1552,0.1242,0.1121]},{"slug":"radon-transform","title":"Radon Transform","family":"algo","round":67,"note":"빛줄기가 1초에 반 바퀴를 돌며 센 광자로 아래 칸에 거친 사이노그램을 채우고, 램프 필터로 거른 투영이 위 칸에 제 각도로 번져 쌓이면 별 모양 줄무늬 속에서 타원이 떠올랐다가 두 칸이 함께 어두워져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-radon-transform","type":"code","name":"radon-transform","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Angles=0..64, Filter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Angles","min":0,"max":64},{"name":"Filter","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5081,"detail":0.0813,"edges":0.2348,"complexity":2.3335,"coverage":0.9242,"colour":0.2511,"drift":0.3748},"knobResponse":[0.24,0.2141,0.0853,0.1229]},{"slug":"rainstorm","title":"Rainstorm","family":"weather","round":2,"note":"빗줄기가 128줄을 다 떨어져 물웅덩이에 고리를 남기고, 가끔 갈라진 번개가 구름을 찢으며 쏟아지는 비를 한순간 밝혀요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rainstorm","type":"code","name":"rainstorm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rain=0.2..3, Wind=-1..1, Storm=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rain","min":0.2,"max":3},{"name":"Wind","min":-1,"max":1},{"name":"Storm","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.22,"detail":0.0685,"edges":0.8841,"complexity":0.6564,"coverage":0.3785,"colour":0.0656,"drift":0.2647},"knobResponse":[0.0545,0.1279,0.1012,0.1302]},{"slug":"ramsey-fringes","title":"Ramsey Fringes","family":"wave","round":79,"note":"가로가 두 펄스 사이의 빈 시간, 세로가 이조인 램지 무늬예요. 왼쪽 끝 라비 선에서 열린 쌍곡선이 오른쪽으로 갈수록 가운데 공명 줄로 좁아지고, 두 펄스의 위상이 돌며 무늬가 한 칸씩 흘러가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ramsey-fringes","type":"code","name":"ramsey-fringes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Free=-1..1, Pulse=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Free","min":-1,"max":1},{"name":"Pulse","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.409,"detail":0.0908,"edges":0.1478,"complexity":1.765,"coverage":0.964,"colour":0.2949,"drift":0.0644},"knobResponse":[0.2524,0.1847,0.131,0.1804]},{"slug":"random-organization","title":"Random Organization","family":"sim","round":56,"note":"원판 83개가 오른쪽은 아래로, 왼쪽은 위로 밀렸다 돌아오고, 그동안 서로 닿은 원판만 금색으로 빛났다가 주기 끝에 조금씩 튕겨 나가요. 1분쯤 지나면 아무도 닿지 않는 자리를 찾아 청록으로 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-random-organization","type":"code","name":"random-organization","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strain=1..4, Density=0.2..0.35","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strain","min":1,"max":4},{"name":"Density","min":0.2,"max":0.35}],"start":[0,2,1,0.2],"measures":{"motion":3.2667,"detail":0.0848,"edges":0.6378,"complexity":0.6754,"coverage":0.3738,"colour":0.1906,"drift":0.1203},"knobResponse":[0.0739,0.1962,0.2107,0.2637]},{"slug":"randu-planes","title":"RANDU Planes","family":"number","round":60,"note":"IBM 의 RANDU 가 낸 연속한 세 수가 정육면체 속 점 구름으로 구르다가, 시선이 평면 9x − 6y + z = n 을 따라 지나는 순간 열다섯 색의 가로줄 열다섯 개로 접혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-randu-planes","type":"code","name":"randu-planes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Generator=0..3, Points=1.8..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Generator","min":0,"max":3},{"name":"Points","min":1.8,"max":8}],"start":[0,2,0,1.8],"measures":{"motion":2.1593,"detail":0.1518,"edges":0.8612,"complexity":0.5041,"coverage":0.2062,"colour":0.2649,"drift":0.0681},"knobResponse":[0.0715,0.1191,0.1157,0.0454]},{"slug":"rational-tangles","title":"Rational Tangles","family":"topology","round":74,"note":"두 가닥 밧줄이 위는 덮개로 닫히고 아래는 풀린 4가닥 plat 으로 세로로 걸려, 콘웨이의 엉킴 춤에서 T 마다 가운데 두 끝이 실제로 한 번 꼬이고 R 마다 네 끝이 한 칸씩 돌며 분수 p/q 가 바뀌고, 끝을 닫아 2다리 매듭의 이름을 단 뒤 다시 풀어 0 으로 돌아가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rational-tangles","type":"code","name":"rational-tangles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=6..14, Rope=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":6,"max":14},{"name":"Rope","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.358,"detail":0.074,"edges":0.6397,"complexity":0.3735,"coverage":0.2026,"colour":0.2527,"drift":0.2063},"knobResponse":[0.0923,0.1293,0.0974,0.1191]},{"slug":"rauzy-fractal","title":"Rauzy Fractal","family":"fractal","round":28,"note":"트리보나치 치환의 라우지 프랙탈이 세 크기의 제 사본으로 판을 덮고, 그 고정점으로 끝없이 들어가요. 타일은 자라 한 크기 위가 되고, 가운데서 퍼지는 고리가 가장 큰 타일을 세 조각으로 나눠요. 누르면 조각 셋이 저마다의 벡터로 미끄러져 같은 테두리 안에 다시 맞물려요.","why":"색 조각이 패널을 빈틈없이 채워요(채움 1.00).","block":1,"ramped":false,"layer":{"id":"layer-rauzy-fractal","type":"code","name":"rauzy-fractal","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Depth=1..4, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Depth","min":1,"max":4},{"name":"Glow","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2887,"detail":0.0655,"edges":0.9038,"complexity":0.1892,"coverage":0.9988,"colour":0.5834,"drift":0.167},"knobResponse":[0.5259,0.2583,0.0944,0.2959]},{"slug":"rayleigh-taylor","title":"Rayleigh-Taylor","family":"sim","round":58,"note":"무거운 유체가 가벼운 유체 위에 얹혀 있고, 판 가운데 경계의 잔물결이 0.54초마다 e 배로 자라 3초쯤 버섯 갓으로 말려요. 무거운 손가락은 바닥으로, 가벼운 거품은 천장으로 6초 안팎에 닿고, 8.6초에 다 섞인 기둥이 1초 동안 새 층으로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rayleigh-taylor","type":"code","name":"rayleigh-taylor","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Modes=3..9, Viscosity=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Modes","min":3,"max":9},{"name":"Viscosity","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.629,"detail":0.0442,"edges":0.2874,"complexity":1.4144,"coverage":1,"colour":0.368,"drift":0.3399},"knobResponse":[0.3012,0.1067,0.0587,0.0337]},{"slug":"reaction-diffusion","title":"Reaction Diffusion","family":"sim","round":1,"note":"두 물질이 번지고 먹고 먹히며 산호와 미로와 점박이를 길러요. K3 가 종을 바꿔요.","why":"무늬는 굵은데 아주 느려요(움직임 0.06).","block":1,"ramped":false,"layer":{"id":"layer-reaction-diffusion","type":"code","name":"reaction-diffusion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.5..4, Species=0..5, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.5,"max":4},{"name":"Species","min":0,"max":5},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0572,"detail":0.0825,"edges":0.3087,"complexity":2.0894,"coverage":0.7212,"colour":0.4058,"drift":0.1337},"knobResponse":[0.314,0.2095,0.2824,0.2879]},{"slug":"reeb-graph","title":"Reeb Graph","family":"topology","round":46,"note":"구멍 g 개의 사슬 곡면이 수직축으로 돌고, 수평 평면이 훑어 올라가며 자른 고리마다 점 하나로 줄어든 자취가 레브 그래프가 돼요. K3 은 구멍을 둘에서 여섯까지, K4 는 곡면을 기울여 그래프 모양을 바꾸는데 임계점의 수는 늘 2 − 2g 예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-reeb-graph","type":"code","name":"reeb-graph","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Holes=2..6, Tilt=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Holes","min":2,"max":6},{"name":"Tilt","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.4553,"detail":0.0378,"edges":0.6727,"complexity":0.2652,"coverage":0.3868,"colour":0.1965,"drift":0.2996},"knobResponse":[0.0567,0.1232,0.0619,0.075]},{"slug":"reed-solomon","title":"Reed-Solomon","family":"data","round":74,"note":"낱말이 진짜 버전 1 QR 부호로 짜인 뒤 모듈이 긁히거나 얼룩지면, 디코더가 신드롬으로 틀린 코드워드를 찾아 고칠 수 있는 만큼이면 되돌리고 넘치면 빨갛게 남겨요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-reed-solomon","type":"code","name":"reed-solomon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Damage=8..60, Data=9..19","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Damage","min":8,"max":60},{"name":"Data","min":9,"max":19}],"start":[0,2,8,9],"measures":{"motion":0.0547,"detail":0.1334,"edges":0.9195,"complexity":0.0797,"coverage":0.3297,"colour":0.2632,"drift":0.2953},"knobResponse":[0.0874,0.0898,0.0503,0.1338]},{"slug":"renyi-parking","title":"Rényi Parking","family":"data","round":35,"note":"128줄이 저마다 60 LED 길이의 거리이고, 6 LED 짜리 차가 아무 데나 와서 들어갈 틈이 있을 때만 서요. 거리는 위에서 빈 채로 들어와 내려가며 차고, 바닥에 닿으면 차 길이만 한 틈이 하나도 없이 72% 쯤 막혀요. 먼저 온 차는 하늘색, 마지막 틈에 끼어든 차는 금색이며 옆 눈금이 바닥을 떠난 거리 128개의 평균을 예측값 0.722 의 금색 눈금에 대 보고, K3 은 차 길이를 6~15 LED 로 바꾸고 K1 을 누르면 차가 다 왼쪽으로 밀려 줄마다 채운 몫만 한 막대가 돼요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-renyi-parking","type":"code","name":"renyi-parking","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Length=6..15, Lattice=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Length","min":6,"max":15},{"name":"Lattice","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":1.1003,"detail":0.1839,"edges":0.8784,"complexity":0.1342,"coverage":0.3299,"colour":0.3078,"drift":0.0658},"knobResponse":[0.1481,0.1885,0.1964,0.2206]},{"slug":"rice-planting","title":"Rice Planting","family":"farm","round":26,"note":"물 댄 논을 위에서 내려다봐요. 밀짚모자를 쓴 일꾼들이 못줄을 따라 뒷걸음질하며 모를 한 포기씩 꽂고, 앞쪽 거울 물에는 구름과 모춤, 백로가 있어요. K1 은 아침 안개에서 노을까지 돌리고, 누르면 남은 모를 한꺼번에 꽂고 줄을 넘겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rice-planting","type":"code","name":"rice-planting","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Planters=4..8, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Planters","min":4,"max":8},{"name":"Wind","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0782,"detail":0.0601,"edges":0.318,"complexity":2.2267,"coverage":1,"colour":0.2886,"drift":0.0509},"knobResponse":[0.2048,0.0848,0.0585,0.1025]},{"slug":"rice-terraces","title":"Rice Terraces","family":"farm","round":25,"note":"세운 패널 아래 끝에서 숲이 선 능선까지 물 댄 다랑논이 등고선처럼 휘어 쌓이고, 논마다 해 뜨는 하늘을 비춰요. 위로 갈수록 층이 얇아지고 노을빛이 짙어지며, 구름 반사가 거울 논들을 가로질러 흘러가고 가까운 논에서는 농부가 물소를 몰아 논을 갈아요. K1 을 돌리면 모가 줄지어 서고 초록으로 덮였다가 누렇게 익고, K1 을 누르면 맨 위 물꼬가 열려 물이 둑을 하나씩 넘어 내려가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-rice-terraces","type":"code","name":"rice-terraces","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Season=0..1, Speed=0.2..3, Terraces=12..24, Hour=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Season","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Terraces","min":12,"max":24},{"name":"Hour","min":0,"max":1}],"start":[0,2,12,0.06],"measures":{"motion":0.0809,"detail":0.0942,"edges":0.423,"complexity":2.2579,"coverage":1,"colour":0.1716,"drift":0.0563},"knobResponse":[0.1151,0.0688,0.1253,0.4152]},{"slug":"richardson-dividers","title":"Richardson Dividers","family":"fractal","round":60,"note":"통계적으로 자기 닮은 무작위 곡선을 디바이더가 정한 벌림으로 걸으며 같은 길이의 현으로 다각형을 놓아요. 벌림이 23 LED 에서 0.93 LED 로 줄 때마다 (log s, log L) 점이 아래 로그-로그 그림의 기울기 1 − D 직선 위에 쌓여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-richardson-dividers","type":"code","name":"richardson-dividers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Roughness=-1..1, Cutoff=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Roughness","min":-1,"max":1},{"name":"Cutoff","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0618,"detail":0.0439,"edges":0.7385,"complexity":0.4024,"coverage":0.1278,"colour":0.097,"drift":0.0211},"knobResponse":[0.025,0.0227,0.0833,0.0349]},{"slug":"riemann-function","title":"Riemann's Function","family":"fractal","round":62,"note":"리만의 미분 불가능 함수를 복소평면에 옮긴 곡선 φ(t) 가 펜 끝에서 나선 꽃이 달린 하트로 그려지고, 아래 확대경이 그 위의 유리수 한 점으로 파고들어요. p 와 q 가 다 홀수인 점에서는 곡선이 작은 장미꼴을 줄줄이 달고 가로로 곧게 지나가고, 다른 점에서는 직각으로 꺾여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-riemann-function","type":"code","name":"riemann-function","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Point=0..1, Depth=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Point","min":0,"max":1},{"name":"Depth","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.578,"detail":0.0618,"edges":0.646,"complexity":0.7695,"coverage":0.2342,"colour":0.1794,"drift":0.105},"knobResponse":[0.0776,0.0901,0.1113,0.0515]},{"slug":"ripple-tank","title":"Ripple Tank","family":"sim","round":1,"note":"빗방울이 떨어진 자리마다 고리가 퍼지고 벽에 부딪혀 되돌아와 서로 겹쳐요.","why":"고리가 LED 한 알 굵기라 멀리서는 가늘어요.","block":1,"ramped":false,"layer":{"id":"layer-ripple-tank","type":"code","name":"ripple-tank","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Rain=0.5..6, Damping=0..1, Drop=2.5..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Rain","min":0.5,"max":6},{"name":"Damping","min":0,"max":1},{"name":"Drop","min":2.5,"max":6}],"start":[0,2,0,2.5],"measures":{"motion":4.7512,"detail":0.0907,"edges":0.3794,"complexity":1.2184,"coverage":0.4445,"colour":0.2076,"drift":0.234},"knobResponse":[0.0799,0.2629,0.1082,0.1339]},{"slug":"risset-rhythm","title":"Risset Rhythm","family":"rhythm","round":50,"note":"다섯 옥타브의 템포를 가로로 깐 이진 자가 4초마다 두 배로 줌아웃하며 패널 아래 한 점으로 오그라들어서, 레인마다 눈금이 재생선을 치는 빠르기가 끝없이 빨라지는데 한 번 두 배가 되면 그림이 처음과 똑같아요. K3 은 밝기 종의 폭, K4 는 이웃 층의 템포 비이고, K1 을 누르면 끝없이 느려져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-risset-rhythm","type":"code","name":"risset-rhythm","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spread=-1..1, Ratio=2..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spread","min":-1,"max":1},{"name":"Ratio","min":2,"max":4}],"start":[0,2,0,2],"measures":{"motion":1.5178,"detail":0.0602,"edges":0.37,"complexity":0.4663,"coverage":0.4439,"colour":0.2034,"drift":0.0406},"knobResponse":[0.1066,0.0932,0.0804,0.0638]},{"slug":"rivers-of-white","title":"Rivers of White","family":"type","round":64,"note":"『두 도시 이야기』 첫 문단이 3×5 픽셀 글자로 양쪽 맞춤되어 패널을 채우고, 늘어난 낱말 사이가 줄마다 겹쳐 생긴 흰 강이 하늘색으로 빛나며 아래로 흘러요. 글줄 폭이 64 LED 와 54 LED 사이를 오가면 줄이 다시 갈리면서 강이 끊기고 다시 이어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rivers-of-white","type":"code","name":"rivers-of-white","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fit=0..1, Space=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fit","min":0,"max":1},{"name":"Space","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.345,"detail":0.2252,"edges":0.8342,"complexity":0.8533,"coverage":0.4249,"colour":0.2108,"drift":0.1562},"knobResponse":[0.0331,0.2089,0.1588,0.1866]},{"slug":"rose-criterion","title":"Rose Criterion","family":"noise","round":68,"note":"광자를 하나씩 쌓아 원판 50개가 대비 × 지름 차례로 낟알 위로 떠오르고, 금빛 쌍곡선이 k = 5 경계를 그어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rose-criterion","type":"code","name":"rose-criterion","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Exposure=0..1, Read noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Exposure","min":0,"max":1},{"name":"Read noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6536,"detail":0.2435,"edges":0.566,"complexity":2.2998,"coverage":0.4837,"colour":0.2531,"drift":0.2545},"knobResponse":[0.1212,0.1693,0.117,0.1706]},{"slug":"rotor-router","title":"Rotor-Router","family":"sim","round":45,"note":"두 샘에서 번갈아 나온 칩이 LED 마다 놓인 화살표를 따라 걷다가 빈 LED 에 멈춰서, 두 원이 만나 허리가 차오르는 땅콩 모양으로 자라요. 화살표는 방향마다 제 색으로 칠해지고, 땅콩이 양옆에 닿으면 가장자리부터 녹아 다시 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rotor-router","type":"code","name":"rotor-router","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Join=0..1, Random=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Join","min":0,"max":1},{"name":"Random","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9934,"detail":0.087,"edges":0.9599,"complexity":0.2854,"coverage":0.4224,"colour":0.3691,"drift":0.3095},"knobResponse":[0.2001,0.3518,0.2468,0.151]},{"slug":"rule-scroll","title":"Rule Scroll","family":"automata","round":1,"note":"64칸 한 줄이 이웃을 보고 다음 줄을 써 내려가요. 8비트 숫자 하나가 삼각형이 될지 잡음이 될지 정해요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-rule-scroll","type":"code","name":"rule-scroll","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..4, Rule=0..11, Noise=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":4},{"name":"Rule","min":0,"max":11},{"name":"Noise","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.3184,"detail":0.3747,"edges":0.8011,"complexity":0.6155,"coverage":0.494,"colour":0.4373,"drift":0.0401},"knobResponse":[0.2576,0.1939,0.2319,0.0376]},{"slug":"ruled-hyperboloid","title":"Ruled Hyperboloid","family":"space","round":80,"note":"위아래 같은 원 둘을 곧은 막대로 이은 탑이 천천히 돌며 비틀려서, 막대가 원통에서 허리 잘록한 쌍곡면을 지나 한 점에서 만나는 이중 원뿔로 닫혔다 열리고, 반대로 비튼 막대와 겹쳐 슈호프 탑의 격자가 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ruled-hyperboloid","type":"code","name":"ruled-hyperboloid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Rods=16..48, Ruling=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rods","min":16,"max":48},{"name":"Ruling","min":-1,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":1.7728,"detail":0.1367,"edges":0.6464,"complexity":1.3956,"coverage":0.3874,"colour":0.194,"drift":0.2359},"knobResponse":[0.1021,0.2641,0.1844,0.0941]},{"slug":"runge-phenomenon","title":"Runge Phenomenon","family":"wave","round":43,"note":"종 모양 곡선 1/(1 + 25x²) 이 패널에 세로로 서고, 보간점이 그 위에 구슬로 앉아요. 같은 간격의 점이 3개에서 21개로 늘수록 그 점을 다 지나는 다항식이 위아래 끝에서 분홍과 금빛 혀를 패널 가장자리까지 내밀다가, 점이 체비쇼프 자리로 미끄러지면 곡선이 종 위에 내려앉아요. K3 은 가장 많은 점을 41개까지 늘리고, K4 를 올리면 점이 처음부터 체비쇼프 쪽에 앉아 혀가 나오지 않아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-runge-phenomenon","type":"code","name":"runge-phenomenon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Nodes=21..41, Chebyshev=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Nodes","min":21,"max":41},{"name":"Chebyshev","min":0,"max":1}],"start":[0,2,21,0.06],"measures":{"motion":0.3623,"detail":0.0453,"edges":0.6934,"complexity":0.1067,"coverage":0.6605,"colour":0.2225,"drift":0.2038},"knobResponse":[0.0721,0.1903,0.121,0.0829]},{"slug":"ruppert-refinement","title":"Ruppert Refinement","family":"cells","round":72,"note":"자홍 바늘로 가득한 다각형 삼각 분할에 외심과 선분의 가운데 점을 하나씩 꽂아, 가장 작은 각이 기준을 넘을 때까지 바늘이 초록과 파랑 삼각형으로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ruppert-refinement","type":"code","name":"ruppert-refinement","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bound=20..33, Domain=0..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bound","min":20,"max":33},{"name":"Domain","min":0,"max":5}],"start":[0,2,20,0.06],"measures":{"motion":0.0303,"detail":0.0845,"edges":0.6582,"complexity":0.653,"coverage":0.8325,"colour":0.5824,"drift":0.0523},"knobResponse":[0.4284,0.2842,0.0721,0.2915]},{"slug":"rutherford-shadow","title":"Rutherford Shadow","family":"physics","round":60,"note":"같은 에너지의 입자 빔이 아래에서 올라와 3분의 1 높이의 핵에 밀려 저마다 쿨롱 쌍곡선을 그리고, 어떤 궤도도 들어가지 못하는 포물선이 핵 위에 날카로운 그림자로 남아요. 그림자 가장자리에는 궤도가 몰려 빛나고, 정면으로 온 몇 개는 금색으로 되튀어 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-rutherford-shadow","type":"code","name":"rutherford-shadow","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Charge=1..6, Attract=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Charge","min":1,"max":6},{"name":"Attract","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.6677,"detail":0.1113,"edges":0.5013,"complexity":1.46,"coverage":0.2954,"colour":0.2307,"drift":0.0765},"knobResponse":[0.0922,0.1217,0.1084,0.1184]},{"slug":"sandpile","title":"Sandpile","family":"automata","round":21,"note":"한 칸에 모래알이 넷 모이면 이웃 넷에 하나씩 넘기는 쟁반에 모래가 한 줌씩 떨어져요. 사태가 떨어진 자리에서 빛나는 고리로 번지며 네 색 레이스를 다시 쓰고, 쟁반이 다 차면 기울어 모래를 쏟아요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-sandpile","type":"code","name":"sandpile","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..4, Speed=0.2..3, Sources=1..5, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":4},{"name":"Speed","min":0.2,"max":3},{"name":"Sources","min":1,"max":5},{"name":"Scatter","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.6394,"detail":0.335,"edges":0.8978,"complexity":0.6311,"coverage":0.8294,"colour":0.2844,"drift":0.1509},"knobResponse":[0.2234,0.3094,0.3442,0.2665]},{"slug":"satin-fold","title":"Satin Fold","family":"cosmetic","round":30,"note":"한 점에 잡힌 연한 새틴이 부채꼴 주름으로 흔들리고, 광택이 주름을 따라 긴 줄로 서요. 금색 실 하나가 천을 건너며 주름마다 휘어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-satin-fold","type":"code","name":"satin-fold","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Folds=1..5, Gold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Folds","min":1,"max":5},{"name":"Gold","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.094,"detail":0.0124,"edges":0.0787,"complexity":1.2735,"coverage":1,"colour":0.1403,"drift":0.1604},"knobResponse":[0.1121,0.2232,0.0933,0.0521]},{"slug":"sato-tate","title":"Sato-Tate","family":"number","round":51,"note":"타원곡선의 점을 mod p 로 세어 얻은 a_p/(2√p) 자리에 소수가 빗방울로 떨어지고, 바닥의 막대가 희미한 반원 (2/π)√(1−x²) 을 채워요. 한 겹이 차면 눈금이 반으로 줄고 다음 겹이 같은 반원을 다시 쌓아 다섯 겹의 돔이 돼요. K3 은 곡선 셋 가운데 하나를, K4 는 막대 수를 골라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sato-tate","type":"code","name":"sato-tate","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Curve=0..1, Bins=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Curve","min":0,"max":1},{"name":"Bins","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.4296,"detail":0.09,"edges":0.7697,"complexity":0.3712,"coverage":0.3366,"colour":0.3777,"drift":0.1242},"knobResponse":[0.1935,0.1887,0.1711,0.0589]},{"slug":"sator-square","title":"Sator Square","family":"type","round":71,"note":"돌판에 새긴 SATOR 다섯 줄을 가로, 세로, 거꾸로, 아래에서 위로 읽는 빛 넷이 늘 같은 글자 위를 지나 가운데 N 에서 만나고, 글자들이 가장 짧게 짝지은 길로 날아가 패널 높이의 PATERNOSTER 십자가와 네 끝의 A, O 가 되었다가 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sator-square","type":"code","name":"sator-square","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Assign=0..2, Weather=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Assign","min":0,"max":2},{"name":"Weather","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.171,"detail":0.0405,"edges":0.2522,"complexity":1.0846,"coverage":0.253,"colour":0.097,"drift":0.1512},"knobResponse":[0.0511,0.1526,0.0781,0.0516]},{"slug":"scarecrow-crows","title":"Scarecrow Crows","family":"halloween","round":43,"note":"보라에서 주황으로 내려오는 해 질 녘 하늘에 큰 달이 낮게 뜨고, 밀짚모자를 쓴 허수아비가 검은 그림자로 서서 바람에 흔들려요. 까마귀가 팔과 모자에 내려앉아 깡충 뛰거나 울다가, 허수아비 고개가 홱 돌아가면 한꺼번에 날아올라 위를 돌고 하나씩 돌아와요. K3 은 까마귀를 8마리에서 20마리로 늘려 자리를 못 찾은 까마귀가 지평선에서 땅을 쪼게 하고, K4 는 고개를 3초마다 돌려요. K1 을 누르면 바로 고개를 돌려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-scarecrow-crows","type":"code","name":"scarecrow-crows","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Crows=8..20, Nerves=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Crows","min":8,"max":20},{"name":"Nerves","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.3729,"detail":0.0581,"edges":0.5416,"complexity":0.2416,"coverage":0.785,"colour":0.4251,"drift":0.063},"knobResponse":[0.1462,0.0549,0.0539,0.0535]},{"slug":"scheidegger-rivers","title":"Scheidegger Rivers","family":"line","round":34,"note":"체크무늬로 놓인 LED 마다 물을 왼쪽 아래나 오른쪽 아래로 무작위로 보내는 샤이데거의 강 그물이에요. 모인 물의 로그로 밝혀서 위의 실개천이 아래로 갈수록 굵은 줄기로 합쳐지고, 바닥의 출구마다 다른 색으로 물든 강을 따라 빗방울이 흘러내리며, 가끔 한 자리가 방향을 바꾸면 큰 강이 옆 유역으로 넘어가 옛 물길이 마르고 새 물길이 줄마다 차올라요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-scheidegger-rivers","type":"code","name":"scheidegger-rivers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=-1..1, Capture=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":-1,"max":1},{"name":"Capture","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.094,"detail":0.1271,"edges":0.515,"complexity":1.5978,"coverage":0.922,"colour":0.2023,"drift":0.0432},"knobResponse":[0.1672,0.0593,0.2285,0.1968]},{"slug":"schlieren-texture","title":"Schlieren Texture","family":"physics","round":72,"note":"교차한 편광판 사이 네마틱 막에서 ±1/2 전위마다 검은 붓자국 둘이 나와 편광판이 돌면 서로 반대로 돌고, 반대 부호 전위가 만나 사라지는 동안 둘째 차수 간섭색이 띠를 이뤄요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-schlieren-texture","type":"code","name":"schlieren-texture","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Order=-1..1, Speed=0.2..3, Defects=10..30, Uncross=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Order","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Defects","min":10,"max":30},{"name":"Uncross","min":0,"max":1}],"start":[0,2,10,0.06],"measures":{"motion":0.2495,"detail":0.0396,"edges":0.0602,"complexity":2.502,"coverage":0.9719,"colour":0.6294,"drift":0.2854},"knobResponse":[0.3735,0.2438,0.2772,0.6384]},{"slug":"schwarz-lantern","title":"Schwarz Lantern","family":"geometry","round":36,"note":"꼭짓점이 모두 원기둥 위에 있는 삼각형 랜턴이 패널 높이만큼 서서 돌고, 띠가 3개에서 40개로 늘었다 줄어요. 접힐수록 아코디언처럼 반짝이고, 왼쪽 막대가 넓이를 원기둥의 1.88배까지 올려요. K3 은 한 고리의 꼭짓점 수를 5에서 12로 바꿔 같은 띠 40개를 매끈한 기둥으로 남기고, K1 을 누르면 단번에 가장 구겨진 꼴로 접혔다가 천천히 풀려요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-schwarz-lantern","type":"code","name":"schwarz-lantern","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=5..12, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":5,"max":12},{"name":"Light","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":2.2095,"detail":0.1257,"edges":0.8296,"complexity":0.2813,"coverage":0.7377,"colour":0.3317,"drift":0.1973},"knobResponse":[0.2726,0.2005,0.2242,0.2083]},{"slug":"seam-carving","title":"Seam Carving","family":"algo","round":59,"note":"원과 고리로 된 그림 위로 누적 에너지 지도가 쓸려 내려간 뒤, 가장 싼 이음매가 패널 높이만큼 빛나고 빠져서 그림이 64열에서 44열로 좁아져도 원은 둥글게 남아요. 그다음 이음매를 하나씩 겹쳐 넣어 다시 64열로 자라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-seam-carving","type":"code","name":"seam-carving","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Carve=20..40, Forward=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Carve","min":20,"max":40},{"name":"Forward","min":0,"max":1}],"start":[0,2,20,0.06],"measures":{"motion":0.1478,"detail":0.0468,"edges":0.4553,"complexity":0.8543,"coverage":0.8225,"colour":0.2557,"drift":0.2013},"knobResponse":[0.2022,0.1777,0.0432,0.0491]},{"slug":"searchlights","title":"Searchlights","family":"light","round":7,"note":"밤 도시의 지붕 뒤에서 탐조등 세 대가 가장자리가 또렷한 빛기둥을 천천히 휘둘러요. 기둥 둘이 겹친 자리는 하얗게 타고, K1 을 누르면 하늘을 가로지르는 비행기를 모든 기둥이 붙잡았다가 놓아줘요.","why":"빛기둥은 좋은데 도시 실루엣이 장면을 만들어요.","block":1,"ramped":false,"layer":{"id":"layer-searchlights","type":"code","name":"searchlights","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Sweep=0.2..4, Lights=3..7, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Sweep","min":0.2,"max":4},{"name":"Lights","min":3,"max":7},{"name":"Haze","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1662,"detail":0.0601,"edges":0.9751,"complexity":0.5201,"coverage":0.2833,"colour":0.1361,"drift":0.3569},"knobResponse":[0.0557,0.2929,0.2085,0.0855]},{"slug":"sedimenting-cloud","title":"Sedimenting Cloud","family":"particle","round":65,"note":"점성 유체 속 입자 구름이 한 덩이로 가라앉으며 안에서 뒤집히고 꼬리를 흘리다 고리가 되어 흩어져요. 위는 정면도, 아래는 위에서 본 평면도예요","why":"","block":0,"ramped":false,"layer":{"id":"layer-sedimenting-cloud","type":"code","name":"sedimenting-cloud","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Particles=300..600, View=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Particles","min":300,"max":600},{"name":"View","min":0,"max":1}],"start":[0,2,300,0.06],"measures":{"motion":0.1452,"detail":0.0345,"edges":0.5307,"complexity":0.5573,"coverage":0.1468,"colour":0.1561,"drift":0.0499},"knobResponse":[0.0478,0.0551,0.0625,0.0399]},{"slug":"seifert-surface","title":"Seifert Surface","family":"topology","round":59,"note":"세로로 그린 닫힌 땋임 매듭의 교차를 방향대로 풀면 자이페르트 원으로 갈라지고, 원마다 원판이 깊이를 두고 쌓인 뒤 교차마다 반 바퀴 꼬인 띠가 이어서 경계가 그 매듭인 곡면이 돼요. 원판의 한 면은 파랑, 다른 면은 금색이라 띠마다 꼬임을 지나며 색이 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-seifert-surface","type":"code","name":"seifert-surface","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knot=0..7, Tilt=40..80","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knot","min":0,"max":7},{"name":"Tilt","min":40,"max":80}],"start":[0,2,0,40],"measures":{"motion":0.2142,"detail":0.0491,"edges":0.6412,"complexity":0.2227,"coverage":0.6556,"colour":0.2397,"drift":0.3277},"knobResponse":[0.0509,0.2063,0.217,0.0936]},{"slug":"semaphore","title":"Semaphore","family":"type","round":79,"note":"빨강 노랑 깃발 둘을 든 흰 점이 위에서 내려오며 글자마다 멈춰 두 팔을 시계의 여덟 방향 가운데 두 곳으로 뻗고, 지나간 자세가 대문자와 나란히 남아 낱말이 패널 높이로 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-semaphore","type":"code","name":"semaphore","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Guide=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":7},{"name":"Guide","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1316,"detail":0.0434,"edges":0.5796,"complexity":0.3348,"coverage":0.1427,"colour":0.1799,"drift":0.0884},"knobResponse":[0.0334,0.0835,0.1629,0.028]},{"slug":"senbazuru","title":"Senbazuru","family":"paper","round":22,"note":"붉은 옻칠 고리에 실로 꿴 종이학이 줄줄이 매달려 금박 학 아래로 주황에서 초록, 파랑을 지나 보라와 분홍까지 띠를 이루고, 실 끝에는 금 구슬과 비단 술이 달려요. 어두운 절 방에 외풍이 불면 줄이 흔들리고 학이 실을 축으로 돌면서 접힌 면이 하나씩 등불을 받아 번쩍여요. K1 을 누르면 돌풍이 불어 학 하나가 떨어져 나뭇잎처럼 바닥으로 내려앉아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-senbazuru","type":"code","name":"senbazuru","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Breeze=0.2..3, Strands=8..16, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Breeze","min":0.2,"max":3},{"name":"Strands","min":8,"max":16},{"name":"Light","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.5463,"detail":0.1059,"edges":0.4439,"complexity":2.0626,"coverage":0.7211,"colour":0.2483,"drift":0.1023},"knobResponse":[0.0684,0.1034,0.1073,0.1606]},{"slug":"sequins","title":"Sequins","family":"textile","round":23,"note":"뒤집히는 스팽글을 촘촘히 단 쿠션이 패널을 채워요. 은빛 비늘이 엇갈린 줄로 겹쳐 있고, 보이지 않는 손끝이 지나가면 스팽글이 차례로 모서리를 보이며 넘어가 하트, 별, 고양이 얼굴, 번개, 파도를 분홍 면으로 그려요. 손바닥이 위에서 아래로 쓸면 다시 은빛이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-sequins","type":"code","name":"sequins","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drawing=0..4, Lamp=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drawing","min":0,"max":4},{"name":"Lamp","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1482,"detail":0.3266,"edges":0.6744,"complexity":1.7886,"coverage":0.647,"colour":0.0886,"drift":0.2495},"knobResponse":[0.0553,0.0492,0.2354,0.1678]},{"slug":"serum-drip","title":"Serum Drip","family":"cosmetic","round":39,"note":"위 끝에서 흘러드는 금빛 세럼 실이 목이 졸리고 부풀어 구슬을 꿴 줄이 되고, 가는 실이 끊기며 큰 방울과 작은 위성 방울이 바닥의 웅덩이로 떨어져요. 세로 홈이 진 벽이 구슬마다 크게 비쳐요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-serum-drip","type":"code","name":"serum-drip","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Viscosity=-1..1, Flow=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Viscosity","min":-1,"max":1},{"name":"Flow","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1144,"detail":0.0191,"edges":0.1005,"complexity":1.4238,"coverage":1,"colour":0.2611,"drift":0.048},"knobResponse":[0.2045,0.0526,0.0374,0.0514]},{"slug":"serum-fingers","title":"Serum Fingers","family":"cosmetic","round":38,"note":"유리판 두 장 사이 진한 크림에 묽은 세럼을 밑에서 밀어 넣으면, 둥근 손가락이 부풀고 갈라지며 위로 다투어 올라가요. LED 는 세럼이 닿을 때 한 번만 바뀌고, 한 손가락이 꼭대기에 닿으면 크림이 가는 손가락부터 다시 덮고 새로 밀어요. K3 은 표면 장력을 낮춰 굵은 손가락 셋을 가는 손가락 열둘로 바꾸고, K1 을 누르면 크림이 바로 다시 덮어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-serum-fingers","type":"code","name":"serum-fingers","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fingers=-1..1, Inlet=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fingers","min":-1,"max":1},{"name":"Inlet","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0418,"detail":0.0193,"edges":0.1667,"complexity":0.987,"coverage":1,"colour":0.3588,"drift":0.2509},"knobResponse":[0.1449,0.1034,0.0454,0.0842]},{"slug":"serum-gel","title":"Serum Gel","family":"cosmetic","round":29,"note":"연보라 젤 속에 진주와 캡슐, 기포가 떠서 천천히 흔들리고, 뒤쪽 벽에는 젤 표면을 지난 빛이 부드러운 그물로 어른거려요. K3 은 구슬 수를 여덟에서 마흔까지 바꾸고, 누르면 젤이 크게 출렁이며 구슬이 늘어났다 줄어들며 흔들리다 가라앉아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-serum-gel","type":"code","name":"serum-gel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beads=8..40, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beads","min":8,"max":40},{"name":"Wobble","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.1786,"detail":0.0286,"edges":0.0792,"complexity":2.417,"coverage":1,"colour":0.2132,"drift":0.1307},"knobResponse":[0.3676,0.1568,0.0763,0.0849]},{"slug":"server-rack","title":"Server Rack","family":"circuit","round":18,"note":"앞에서 본 42U 서버 랙이 패널을 채워요. 맨 위 스위치로 들어온 트래픽이 서버를 타고 내려가며 드라이브 불을 켜고, 백업이 스토리지 선반의 드라이브를 차례로 채워요. K4 를 올리면 바닥 타일에서 올라온 푸른 냉기 빛이 아래쪽 앞판을 물들여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-server-rack","type":"code","name":"server-rack","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Load=0..1, Aisle=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Load","min":0,"max":1},{"name":"Aisle","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3413,"detail":0.1038,"edges":0.3523,"complexity":1.287,"coverage":0.6285,"colour":0.2245,"drift":0.0981},"knobResponse":[0.0421,0.0369,0.0435,0.0677]},{"slug":"setting-mist","title":"Setting Mist","family":"cosmetic","round":31,"note":"왼쪽 밖에서 세팅 미스트가 1초에 한 번쯤 뿜어져, 얇은 원뿔이 3분의 1초 만에 구름으로 부풀고 소용돌이를 말며 흘러가다 가라앉아요. 짙은 물빛 바탕에 굵은 방울이 부드럽게 반짝여요. K1 은 색상환을 다 돌고, 누르면 크게 두 번 뿜어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-setting-mist","type":"code","name":"setting-mist","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spray=0..1, Droplets=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spray","min":0,"max":1},{"name":"Droplets","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1908,"detail":0.0088,"edges":0.0593,"complexity":1.291,"coverage":1,"colour":0.0895,"drift":0.1077},"knobResponse":[0.1473,0.1003,0.1667,0.0634]},{"slug":"seven-shuffles","title":"Seven Shuffles","family":"algo","round":29,"note":"카드 한 벌을 옆에서 본 무지개 막대 더미를 리플 셔플로 섞어요. 한 번 섞을 때마다 그러데이션이 2, 4, 8 갈래로 엇갈려 끼다가 일곱 번쯤에 색종이처럼 흩어지고, 그다음 기수 정렬로 되돌려 다시 시작해요. K4 를 끝까지 돌리면 완벽한 파로 셔플이 되어 32장은 다섯 번 만에 처음 순서로 돌아와요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-seven-shuffles","type":"code","name":"seven-shuffles","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cards=32..128, Neatness=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cards","min":32,"max":128},{"name":"Neatness","min":0,"max":1}],"start":[0,2,32,0.06],"measures":{"motion":3.42,"detail":0.1826,"edges":0.5208,"complexity":0.0962,"coverage":0.5604,"colour":0.575,"drift":0.2123},"knobResponse":[0.3602,0.3179,0.3253,0.2206]},{"slug":"shadow-play","title":"Shadow Play","family":"stage","round":26,"note":"등잔 불빛을 받은 흰 막에 와양 쿨릿 가죽 인형의 레이스 그림자가 비쳐요. 기사가 거인과 싸워 던져 버리면 구눙안이 떨며 쓸고 들어와 다음 장을 열고, K1 을 돌리면 막 뒤로 돌아가 금빛과 빨강, 남색 칠이 보여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-shadow-play","type":"code","name":"shadow-play","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs View=0..1, Speed=0.2..3, Lamp=0..1, Flicker=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"View","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lamp","min":0,"max":1},{"name":"Flicker","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.0562,"detail":0.0589,"edges":0.3798,"complexity":1.779,"coverage":0.627,"colour":0.1416,"drift":0.2084},"knobResponse":[0.2162,0.1484,0.1028,0.0596]},{"slug":"shannon-approximations","title":"Shannon's Approximations","family":"type","round":67,"note":"커서가 『오만과 편견』 첫머리로 센 섀넌의 근사 영어를 16자 21줄 쪽에 덮어 치고, 책에 있는 낱말은 청록으로, 책에서 나란히 선 낱말 쌍은 금빛으로 켜져서 Order 를 올릴수록 흐린 잡음이 낱말로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-shannon-approximations","type":"code","name":"shannon-approximations","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=0..5, Blackout=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":0,"max":5},{"name":"Blackout","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0341,"detail":0.1853,"edges":1,"complexity":0.2756,"coverage":0.3778,"colour":0.0993,"drift":0.0244},"knobResponse":[0.0594,0.0303,0.2475,0.0874]},{"slug":"shapley-folkman","title":"Shapley-Folkman","family":"geometry","round":66,"note":"모양 하나를 1, 2, 4, 8 개 더해 그 수로 나눈 민코프스키 평균이 띠 넷으로 쌓이고, 오목한 만이 띠마다 절반씩 메워지며 흐린 볼록 껍질에 다가가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-shapley-folkman","type":"code","name":"shapley-folkman","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..4, Hull=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":4},{"name":"Hull","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2143,"detail":0.0512,"edges":0.502,"complexity":0.3593,"coverage":0.4293,"colour":0.3465,"drift":0.1635},"knobResponse":[0.1799,0.1546,0.1977,0.0732]},{"slug":"sheet-ghosts","title":"Sheet Ghosts","family":"halloween","round":41,"note":"흰 머리에서 연보라 밑단으로 물든 침대보 유령들이 독한 초록빛을 두르고 세운 패널을 흔들흔들 올라가요. 밑단은 물결치고 몸은 흔들림 뒤로 끌리며, 겹치는 데서는 서로 비쳐 보여요. K3 은 유령을 3 에서 6 까지 늘리고 K4 는 바람이라 몸이 기울고 밑단이 날리며, K1 을 누르면 모두 3.2배로 부풀며 달려들었다가 사라지고 새 유령이 스며 나와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sheet-ghosts","type":"code","name":"sheet-ghosts","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glow=0..1, Speed=0.2..3, Ghosts=3..6, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glow","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ghosts","min":3,"max":6},{"name":"Wind","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.481,"detail":0.0312,"edges":0.2298,"complexity":1.0453,"coverage":0.6411,"colour":0.1958,"drift":0.3699},"knobResponse":[0.0661,0.2767,0.3362,0.4311]},{"slug":"sheet-mask","title":"Sheet Mask","family":"cosmetic","round":35,"note":"세럼에 젖은 시트 마스크가 위에서 내려와 진줏빛 살결에 닿는 대로 맑은 청록으로 비치고, 공기가 갇힌 자리는 흰 공기 방울 여섯 개로 볼록 솟아요. 보이지 않는 손바닥이 4.2초 동안 위에서 아래로 쓸며 방울을 양옆 끝으로 밀어내면, 매끈해진 시트 위로 떠도는 빛 한 점이 섬유 결에 부서져 반짝여요. K3 은 방울을 20개까지 늘리고 크게 부풀리며, K1 은 색상환을 다 돌고 누르면 손바닥이 0.8초 만에 한 번에 눌러 펴요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-sheet-mask","type":"code","name":"sheet-mask","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bubbles=6..20, Weave=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bubbles","min":6,"max":20},{"name":"Weave","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.0942,"detail":0.0264,"edges":0.0175,"complexity":2.3054,"coverage":1,"colour":0.109,"drift":0.1087},"knobResponse":[0.2121,0.1814,0.0787,0.0461]},{"slug":"shimmer-oil","title":"Shimmer Oil","family":"cosmetic","round":36,"note":"보이지 않는 손끝이 마이카가 든 베리빛 바디 오일을 저으면, 납작한 조각들이 늘어난 자리에서는 일어서고 돌기만 하는 자리에서는 누운 채라 소용돌이 자체가 진주빛 실크 결로 보여요. K3 은 젓는 힘이라 1 에서는 소용돌이가 서로 말려 들며 결이 촘촘히 접혀요. K1 을 누르면 다른 손끝이 내려와 20 LED 쯤의 나선을 감아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-shimmer-oil","type":"code","name":"shimmer-oil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stir=0..1, Mica=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stir","min":0,"max":1},{"name":"Mica","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1227,"detail":0.0154,"edges":0,"complexity":1.6312,"coverage":1,"colour":0.1493,"drift":0.0939},"knobResponse":[0.4877,0.1036,0.0703,0.0773]},{"slug":"shoot-em-up","title":"Shoot 'em Up","family":"pixel","round":24,"note":"세로로 흐르는 아케이드 슈팅 게임이 혼자 돌아요. 섬과 해안, 들판과 빨간 지붕 마을이 아래로 흘러가고, 흰 전투기가 노란 탄을 쏘며 S 자로 들어오는 편대와 포탑을 돌리는 포함을 떨어뜨려요. 화면 위 3분의 1을 덮는 보스가 내려와 고리와 나선 탄막을 뿌리다 연쇄 폭발로 부서져요. K1 이 열대 바다에서 붉은 협곡, 밤 도시, 우주 정거장까지 판을 바꾸고, K1 을 누르면 폭탄이 터져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-shoot-em-up","type":"code","name":"shoot-em-up","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Stage=0..1, Speed=0.2..3, Waves=1..5, Bullets=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Stage","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Waves","min":1,"max":5},{"name":"Bullets","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":1.2251,"detail":0.0672,"edges":0.7429,"complexity":0.308,"coverage":0.995,"colour":0.3654,"drift":0.1128},"knobResponse":[0.2583,0.2156,0.0612,0.0985]},{"slug":"shoreline","title":"Shoreline","family":"ocean","round":17,"note":"드론으로 곧장 내려다본 해변이에요. 비스듬히 밀려온 너울이 모래톱 위에서 하얗게 부서지고 골에서 다시 일어나 기슭에서 한 번 더 부서진 뒤, 레이스 같은 거품 끝을 단 채 모래를 타고 올라갔다 물러나며 젖은 모래의 어두운 윤기를 남겨요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-shoreline","type":"code","name":"shoreline","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Water=0..1, Speed=0.2..3, Height=1..3, Tide=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Water","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Height","min":1,"max":3},{"name":"Tide","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1312,"detail":0.0226,"edges":0.2179,"complexity":0.5021,"coverage":1,"colour":0.3833,"drift":0.0432},"knobResponse":[0.2028,0.0707,0.0565,0.1108]},{"slug":"silencio","title":"Silencio","family":"type","round":67,"note":"곰링어의 silencio 열네 낱말이 책등처럼 돌아누워 다섯 단 세 줄로 서고, 가운데 빈 자리가 옆 칸으로 옮겨 가면 그 칸의 낱말은 끝 글자부터 잦아들고 떠난 칸의 낱말은 첫 글자부터 다시 켜져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-silencio","type":"code","name":"silencio","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Hush=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":4},{"name":"Hush","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0347,"detail":0.0734,"edges":0.5117,"complexity":0.3027,"coverage":0.284,"colour":0.0951,"drift":0.0342},"knobResponse":[0.0476,0.0328,0.1224,0.0474]},{"slug":"simpson-paradox","title":"Simpson's Paradox","family":"data","round":63,"note":"무리마다 오르는 점구름 셋이 시소처럼 기울면, 점 전체에 맞춘 흰 최소제곱 직선이 수평을 지나 거꾸로 내려가요. 맨 아래 막대가 무리 기울기와 합친 기울기의 부호를 견줘 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-simpson-paradox","type":"code","name":"simpson-paradox","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Groups=3..5, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Groups","min":3,"max":5},{"name":"Spread","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.7418,"detail":0.0506,"edges":0.4399,"complexity":0.4834,"coverage":0.1335,"colour":0.1541,"drift":0.092},"knobResponse":[0.0415,0.0784,0.0658,0.0336]},{"slug":"simulated-annealing","title":"Simulated Annealing","family":"sim","round":77,"note":"도시 80개를 잇는 엉킨 순회가 메트로폴리스 규칙으로 식으며 엇갈림을 풀고, 짝홀 규칙으로 채운 안쪽이 한 덩어리가 되면 도시가 날아가 다시 녹아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-simulated-annealing","type":"code","name":"simulated-annealing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Cities=80..150, Floor=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Cities","min":80,"max":150},{"name":"Floor","min":0,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":1.5585,"detail":0.0738,"edges":0.4663,"complexity":1.293,"coverage":0.5013,"colour":0.2017,"drift":0.0861},"knobResponse":[0.1144,0.103,0.1317,0.0922]},{"slug":"sinai-walk","title":"Sinai's Walk","family":"noise","round":57,"note":"무작위 퍼텐셜이 들쭉날쭉한 능선으로 패널을 내려가는 지형에서, 줄마다 제 동전을 가진 자리를 걷개 3,000개가 log t 로 가는 시계를 따라 걸어요. 골짜기마다 log t 깊이까지 웅덩이가 차오르고, 걷개는 저를 담은 웅덩이 바닥에서 빛나다가 웅덩이가 능선을 넘쳐 더 깊은 골짜기와 합쳐지면 다 같이 넘어가요. K3 은 치우침이라 0 이면 시나이의 되돌아오는 걸음이고 올리면 지형이 기울어 걷개가 t^κ 로 덫을 하나씩 거쳐 내려가며, K4 는 자리마다 log ρ 의 퍼짐 σ(1.2~2.4)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sinai-walk","type":"code","name":"sinai-walk","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bias=0..1, Disorder=1.2..2.4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bias","min":0,"max":1},{"name":"Disorder","min":1.2,"max":2.4}],"start":[0,2,0,1.2],"measures":{"motion":0.3782,"detail":0.0475,"edges":0.4516,"complexity":0.3886,"coverage":0.3889,"colour":0.143,"drift":0.0579},"knobResponse":[0.059,0.0539,0.0963,0.0861]},{"slug":"siteswap","title":"Siteswap","family":"rhythm","round":41,"note":"공 세 개가 패널 아래 두 손 사이를 포물선으로 오가요. 첫 패턴 51 에서는 5 로 던진 공이 꼭대기까지 올랐다가 반대 손에 떨어지고, 1 은 손 사이를 낮게 건너가요. K3 을 돌리면 공이 7개까지 늘거나 하나씩 패널 밑으로 떨어지고, K4 를 1 로 올리면 공마다 제 아치를 꼬리로 다 그려요. K1 을 누르면 다음 패턴으로 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-siteswap","type":"code","name":"siteswap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Balls=3..7, Tail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Balls","min":3,"max":7},{"name":"Tail","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.5928,"detail":0.0334,"edges":0.5727,"complexity":0.5374,"coverage":0.2049,"colour":0.2864,"drift":0.1571},"knobResponse":[0.1083,0.1105,0.258,0.0456]},{"slug":"sitnikov-problem","title":"Sitnikov Problem","family":"space","round":77,"note":"타원 궤도를 도는 두 별의 축 위로 셋째 몸 64개를 한꺼번에 던지면 매끈한 물결이 휘다가 몇 초 만에 찢겨 흩어지고, 궤도면에는 모저의 기호가 열마다 적혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-sitnikov-problem","type":"code","name":"sitnikov-problem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ellipse=-1..1, Spread=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ellipse","min":-1,"max":1},{"name":"Spread","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7908,"detail":0.0297,"edges":0.4517,"complexity":0.3337,"coverage":0.1229,"colour":0.1073,"drift":0.1239},"knobResponse":[0.0393,0.0997,0.0976,0.0769]},{"slug":"skein","title":"Skein","family":"bird","round":23,"note":"해 진 뒤 하늘을 올려다보면 기러기 떼가 V 자로 패널 위쪽, 북쪽으로 날아가요. 지친 선두가 한쪽 줄로 물러나면 다른 기러기가 앞에 서고, 커다란 보름달 앞을 지날 때는 새카만 실루엣이 돼요. 뒤따라온 작은 떼가 꼬리에 붙기도 해요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-skein","type":"code","name":"skein","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Geese=7..31, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Geese","min":7,"max":31},{"name":"Wind","min":-1,"max":1}],"start":[0,2,7,0.06],"measures":{"motion":0.2572,"detail":0.0301,"edges":0.4436,"complexity":1.9214,"coverage":0.9745,"colour":0.3836,"drift":0.0616},"knobResponse":[0.2529,0.0352,0.0331,0.0516]},{"slug":"skull-swap","title":"Skull Swap","family":"halloween","round":50,"note":"달 뜬 묘지에서 춤추던 해골 둘이 제 머리를 들어 서로 던져 남의 목에 끼우고, 눈구멍을 돌려 마주 보며 어깨를 으쓱한 뒤 도로 던져요. K3 은 머리가 나는 높이와 도는 수, K4 는 바꾸기 사이에 추는 박자 수이고, K1 을 누르면 바로 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-skull-swap","type":"code","name":"skull-swap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Toss=0..1, Dance=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Toss","min":0,"max":1},{"name":"Dance","min":2,"max":8}],"start":[0,2,0,2],"measures":{"motion":0.9759,"detail":0.1109,"edges":0.6361,"complexity":0.3414,"coverage":0.8278,"colour":0.1986,"drift":0.0566},"knobResponse":[0.0913,0.1313,0.0947,0.1237]},{"slug":"skydiver","title":"Skydiver","family":"flight","round":25,"note":"강하장 위로 점프기가 지나가며 문에서 다이버들을 내보내요. 다이버들은 구름층을 뚫고 내려가 손을 잡아 고리를 만들었다가 흩어지고, 저마다 색 램에어 캐노피를 펴서 나선을 그리며 들판의 착지 원으로 내려와요. K1 을 끝까지 돌리면 해가 지평선에 걸린 노을 점프가 되고, K1 을 누르면 다음 비행기가 바로 들어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-skydiver","type":"code","name":"skydiver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Divers=5..12, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Divers","min":5,"max":12},{"name":"Wind","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.1475,"detail":0.0297,"edges":0.3609,"complexity":0.7202,"coverage":0.9986,"colour":0.3312,"drift":0.0468},"knobResponse":[0.1943,0.0707,0.0554,0.0919]},{"slug":"sled-dogs","title":"Sled Dogs","family":"polar","round":27,"note":"드론처럼 바로 위에서 본 개썰매 팀이 둘씩 갱라인에 매여 해빙 위를 달려 올라가요. 낮은 해가 개마다 긴 파란 그림자를 비스듬히 뒤로 던지고, 바람이 깎은 사스트루기 사이로 압력 능선과 다시 언 리드가 발밑을 흘러가요. K1 은 금빛 해에서 오로라 뜬 달밤으로 가고, 누르면 머셔가 외쳐 팀이 방향을 틀어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-sled-dogs","type":"code","name":"sled-dogs","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Dogs=8..14, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dogs","min":8,"max":14},{"name":"Wind","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.9731,"detail":0.0564,"edges":0.2725,"complexity":2.1928,"coverage":0.9989,"colour":0.1125,"drift":0.1372},"knobResponse":[0.4249,0.2371,0.2343,0.1374]},{"slug":"slime-drip","title":"Slime Drip","family":"halloween","round":44,"note":"보라 돌 턱 밑에서 초록 점액이 늘어져 목이 가늘어지다 끊기고, 방울이 패널 끝까지 떨어져 거품 이는 웅덩이에 철퍽 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-slime-drip","type":"code","name":"slime-drip","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Drips=5..12, Viscosity=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Drips","min":5,"max":12},{"name":"Viscosity","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.4493,"detail":0.0402,"edges":0.389,"complexity":0.101,"coverage":0.3514,"colour":0.311,"drift":0.1365},"knobResponse":[0.137,0.0749,0.1396,0.0839]},{"slug":"slinky","title":"Slinky","family":"toy","round":21,"note":"슬링키가 패널 높이만큼 지그재그로 꺾인 계단을 한 칸씩 뒤집히며 내려가요. 코일이 활처럼 휘어 아래 칸으로 쏟아지고, 내려앉은 칸마다 계단등이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-slinky","type":"code","name":"slinky","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spring=0..1, Speed=0.2..3, Rise=6..12, Lamp=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spring","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Rise","min":6,"max":12},{"name":"Lamp","min":-1,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.1152,"detail":0.057,"edges":0.2572,"complexity":1.8838,"coverage":0.9943,"colour":0.1312,"drift":0.056},"knobResponse":[0.1557,0.043,0.0908,0.2999]},{"slug":"smale-horseshoe","title":"Smale Horseshoe","family":"fractal","round":54,"note":"가운데 정사각형을 옆으로 누르고 위로 늘인 띠를 꺾어 다시 덮는 스메일 말굽이 한 번씩 접힐 때마다, 위로 오르는 금빛 가닥과 내려가는 하늘색 가닥 32개가 정사각형을 세로로 가로지르고 위에서는 겹친 아치로, 아래에서는 겹친 U 자로 돌아요. 가로 띠와 겹치는 곳이 하얗게 빛나는 불변 칸토어 집합이고, K3 은 세로 가닥과 가로 띠 가운데 무엇을 보일지, K4 는 한 번 접을 때 누르는 비율 λ 예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-smale-horseshoe","type":"code","name":"smale-horseshoe","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Strands=-1..1, Squeeze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Strands","min":-1,"max":1},{"name":"Squeeze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.9103,"detail":0.2159,"edges":0.8687,"complexity":0.1209,"coverage":0.4757,"colour":0.3518,"drift":0.3378},"knobResponse":[0.1237,0.2874,0.187,0.2058]},{"slug":"smalti","title":"Smalti","family":"glass","round":19,"note":"라벤나 갈라 플라키디아의 별 궁륭과 기도하는 사도를 어두운 줄눈의 유리와 금 테세라로 128줄에 짜요. 등불이 벽을 오르내리면 저마다 조금씩 기운 금 큐브가 빛의 각도를 만날 때마다 번쩍여요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-smalti","type":"code","name":"smalti","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Tesserae=2..4, Gold=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tesserae","min":2,"max":4},{"name":"Gold","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0438,"detail":0.2001,"edges":1,"complexity":2.3202,"coverage":0.4186,"colour":0.2372,"drift":0.1208},"knobResponse":[0.0652,0.0785,0.082,0.0729]},{"slug":"snow-monkeys","title":"Snow Monkeys","family":"mammal","round":25,"note":"눈 내리는 지고쿠다니의 해 질 녘, 일본원숭이들이 김 오르는 노천 온천에 어깨까지 잠겨 머리에 눈을 얹은 채 졸거나 서로 털을 골라 줘요. 바위 위의 어미가 물로 걸어 들어오고, 덩어리진 김은 눈 덮인 삼나무 비탈을 지나 패널 꼭대기까지 피어올라요. K1 을 끝까지 돌리면 밤이 되어 석등이 김을 주황으로 물들이고, K1 을 누르면 새끼가 물보라를 일으키며 뛰어들어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-snow-monkeys","type":"code","name":"snow-monkeys","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Monkeys=3..14, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Monkeys","min":3,"max":14},{"name":"Wind","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2849,"detail":0.086,"edges":0.3721,"complexity":2.5086,"coverage":0.9682,"colour":0.1461,"drift":0.1151},"knobResponse":[0.1114,0.1216,0.0428,0.1209]},{"slug":"soap-film","title":"Soap Film","family":"cosmetic","round":39,"note":"고리에 건 세안 거품의 막이 세로로 서서 빠져요. 위로 갈수록 얇아서 뉴턴의 색 띠가 가로로 쌓여 가라앉고, 옆에서 얇은 막이 기둥으로 올라오고, 위에서 검은 막이 내려와요. 다 얇아지면 막이 터지고 새 막이 아래에서 올라와요.","why":"무지개 막이 화려한데 결이 복잡해요(복잡도 2.34).","block":1,"ramped":false,"layer":{"id":"layer-soap-film","type":"code","name":"soap-film","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Light=0..1, Swirl=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Light","min":0,"max":1},{"name":"Swirl","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2419,"detail":0.0368,"edges":0.0854,"complexity":2.3422,"coverage":0.754,"colour":0.6118,"drift":0.3785},"knobResponse":[0.4809,0.5345,0.3525,0.1517]},{"slug":"solenoid","title":"Solenoid","family":"fractal","round":57,"note":"흐린 유리 같은 솔리드 토러스가 세로로 서서 12초에 한 바퀴 돌고, 그 안에서 닫힌 줄 한 가닥이 16번 감겨 두 다발, 네 다발, 여덟 쌍으로 갈라져요. 줄마다 검은 테가 있어서 앞을 지나는 줄이 뒤의 줄을 끊어요. K3 은 단계 k 를 1 에서 7 까지 바꿔 줄을 2가닥에서 128가닥까지 둘로 가르고, K4 는 축소 비율 λ 를 0.49 에서 0.22 까지 줄여 쌍을 한 줄로 붙여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-solenoid","type":"code","name":"solenoid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Level=-3..3, Lambda=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Level","min":-3,"max":3},{"name":"Lambda","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":3.2823,"detail":0.3196,"edges":1,"complexity":0.8784,"coverage":0.4957,"colour":0.3857,"drift":0.3565},"knobResponse":[0.1838,0.3355,0.2289,0.1985]},{"slug":"sorting","title":"Sorting","family":"algo","round":2,"note":"막대 64개를 알고리즘 하나가 한 번에 한 동작씩 줄 세워요. 비교하는 막대는 희게, 바꾸는 막대는 붉게 켜지고, 다 서면 위에서 아래로 훑어 확인한 뒤 다시 섞어요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-sorting","type":"code","name":"sorting","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0..5, Algorithm=0..7, Rows=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0,"max":5},{"name":"Algorithm","min":0,"max":7},{"name":"Rows","min":2,"max":8}],"start":[0,2,0,2],"measures":{"motion":1.5282,"detail":0.0322,"edges":0.8211,"complexity":0.0601,"coverage":0.5078,"colour":0.3589,"drift":0.1727},"knobResponse":[0.2105,0.2338,0.2297,0.1743]},{"slug":"sorting-network","title":"Sorting Network","family":"line","round":33,"note":"실 열여섯 가닥이 이웃끼리 한 쌍씩 자리를 바꿔 128줄 만에 순서가 거꾸로 되고, 다음 네트워크가 이어받아 실마다 패널을 사인 곡선으로 가로질러요. 균일한 무작위 정렬 네트워크라 바꾼 자리를 찍은 점이 가운데로 반원 꼴로 몰려요. K3 은 실을 32가닥까지 늘리고, K1 을 누르면 실 하나만 8초 동안 밝혀 그 곡선을 보여 줘요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-sorting-network","type":"code","name":"sorting-network","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wires=16..32, Bubble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wires","min":16,"max":32},{"name":"Bubble","min":0,"max":1}],"start":[0,2,16,0.06],"measures":{"motion":1.187,"detail":0.1748,"edges":0.7005,"complexity":1.5147,"coverage":0.5118,"colour":0.2962,"drift":0.1325},"knobResponse":[0.1544,0.2402,0.3244,0.2291]},{"slug":"sparks","title":"Sparks","family":"particle","round":1,"note":"불꽃마다 흰빛에서 식어 가는 색이 제 나이를 보여 줘요. 꽃불 세 가지가 느슨한 박자로 터져요.","why":"불꽃이 작고 패널이 거의 비어요(채움 0.16).","block":1,"ramped":false,"layer":{"id":"layer-sparks","type":"code","name":"sparks","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Spread=0..1, Rate=0.6..5, Gravity=-1..1, Trail=0.3..1.8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Spread","min":0,"max":1},{"name":"Rate","min":0.6,"max":5},{"name":"Gravity","min":-1,"max":1},{"name":"Trail","min":0.3,"max":1.8}],"start":[0,2,0,0.3],"measures":{"motion":0.3313,"detail":0.0372,"edges":0.402,"complexity":0.7208,"coverage":0.1596,"colour":0.1435,"drift":0.1348},"knobResponse":[0.034,0.0885,0.063,0.0577]},{"slug":"specimen-jar","title":"Specimen Jar","family":"halloween","round":47,"note":"보랏빛 선반 위 표본 병의 독한 초록 액체 속에서 핏발 선 눈알이 오르내리며 두리번거리다, 몇 초마다 돌아서 유리 쪽으로 다가와 동공을 열고 나를 똑바로 봐요. K3 은 거품, K4 는 응시가 잦은 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-specimen-jar","type":"code","name":"specimen-jar","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Stare=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bubbles","min":0,"max":1},{"name":"Stare","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3174,"detail":0.0624,"edges":0.4802,"complexity":0.5507,"coverage":0.6646,"colour":0.2382,"drift":0.087},"knobResponse":[0.0956,0.0751,0.0813,0.0622]},{"slug":"specimen-shelf","title":"Specimen Shelf","family":"halloween","round":52,"note":"두 선반의 표본 병 셋에 뜬 눈알 가운데 하나가 돌아 나를 보면, 다른 눈들이 그 눈을 흘끗 보고 차례로 따라 돌았다가 다 함께 딴 데를 보고 위로 굴러 깜빡여요. 선반을 두드리면 액체가 출렁이며 빛나요. K3 은 거품, K4 는 두드리는 잦기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-specimen-shelf","type":"code","name":"specimen-shelf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Knock=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bubbles","min":0,"max":1},{"name":"Knock","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2883,"detail":0.0682,"edges":0.4417,"complexity":0.511,"coverage":0.8309,"colour":0.2555,"drift":0.0607},"knobResponse":[0.1525,0.0933,0.0649,0.0383]},{"slug":"spectrogram","title":"Spectrogram","family":"data","round":17,"note":"새벽 합창의 스펙트로그램이 폭포처럼 내려와요. 휘파람과 떨림, 짹 소리와 뻐꾸기의 두 음이 바람과 먼 찻길로 얼룩진 바닥 위에 밝게 그려지고, K3 을 누르면 손뼉 소리에 새들이 잠시 입을 다물어요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-spectrogram","type":"code","name":"spectrogram","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Map=0..1, Scroll=0.5..4, Birds=0..1, Gain=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Map","min":0,"max":1},{"name":"Scroll","min":0.5,"max":4},{"name":"Birds","min":0,"max":1},{"name":"Gain","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.9689,"detail":0.133,"edges":0.3961,"complexity":2.4228,"coverage":0.9799,"colour":0.4061,"drift":0.0801},"knobResponse":[0.3109,0.1622,0.1596,0.4388]},{"slug":"sperner-lemma","title":"Sperner's Lemma","family":"topology","round":38,"note":"세운 삼각형을 작은 방으로 나누고, 꼭짓점마다 연속 사상이 가장 많이 줄이는 좌표의 번호를 붙여 파랑, 빨강, 초록 영토로 칠해요. 흰 걸음이 밑변의 1-2 문으로 들어와 방마다 다른 문으로 나가다가 세 번호를 다 가진 무지개 방에서 멈추고, 그 방은 사상의 고정점 위에 있어요. K3 은 사상을 고정점 둘레로 비틀어 영토 경계를 감고, K4 는 고정점을 늘려 무지개 방을 홀수 개로 늘려요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-sperner-lemma","type":"code","name":"sperner-lemma","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Mesh=12..28, Speed=0.2..3, Swirl=0..1, Ripple=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Mesh","min":12,"max":28},{"name":"Speed","min":0.2,"max":3},{"name":"Swirl","min":0,"max":1},{"name":"Ripple","min":0,"max":1}],"start":[12,2,0,0.06],"measures":{"motion":0.0411,"detail":0.0869,"edges":0.6362,"complexity":0.5552,"coverage":0.4564,"colour":0.2811,"drift":0.0451},"knobResponse":[0.0654,0.0563,0.0533,0.0518]},{"slug":"spider-drop","title":"Spider Drop","family":"halloween","round":41,"note":"주황 보름달 앞에 보라 거미줄이 걸려 있고, 가운데 앉은 초록 거미가 실을 타고 패널 아래 두 모서리 거미줄 사이까지 떨어져요. 실이 팽팽해지면 튀어 오르며 빙글 돌고 거미줄이 출렁인 뒤, 실을 감으며 다시 올라가요. K3 을 올리면 작은 거미가 둘 더 매달리고 K4 는 바람으로 거미를 20 LED 까지 흔들며, K1 을 누르면 거미가 바로 떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-spider-drop","type":"code","name":"spider-drop","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Colour=0..1, Speed=0.2..3, Spiders=1..3, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Colour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spiders","min":1,"max":3},{"name":"Wind","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3564,"detail":0.1246,"edges":0.8602,"complexity":0.4765,"coverage":0.3192,"colour":0.2426,"drift":0.0556},"knobResponse":[0.0985,0.0606,0.0835,0.048]},{"slug":"sponge-blend","title":"Sponge Blend","family":"cosmetic","round":31,"note":"옅은 바탕에 산호색 줄 하나가 그어지고, 보이지 않는 촉촉한 스펀지가 줄을 따라 1초에 여섯 번쯤 두드려 고운 구멍 자국을 찍으며 색을 바깥으로 펴요. 15초쯤이면 선이 넓은 점묘 그러데이션이 되고, 닦아 내고 다시 그어요. K1 은 색상환을 다 돌고, 누르면 새 줄을 그어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-sponge-blend","type":"code","name":"sponge-blend","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Coverage=0..1, Grain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coverage","min":0,"max":1},{"name":"Grain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0318,"detail":0.1277,"edges":0.0012,"complexity":1.8672,"coverage":1,"colour":0.1441,"drift":0.0382},"knobResponse":[0.095,0.0521,0.043,0.0383]},{"slug":"spray-stencil","title":"Spray Stencil","family":"type","round":72,"note":"「취급주의」를 오린 철판 위로 분무기가 지그재그로 내려가며 물감을 뿌리고, 판이 걷히면 다리 자리를 틈으로 남긴 글자가 골판지 상자에 패널 높이로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-spray-stencil","type":"code","name":"spray-stencil","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Plate=0..3, Overspray=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Plate","min":0,"max":3},{"name":"Overspray","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5288,"detail":0.0408,"edges":0.2215,"complexity":1.528,"coverage":1,"colour":0.3581,"drift":0.2321},"knobResponse":[0.225,0.2049,0.0745,0.0414]},{"slug":"sprout","title":"Sprout","family":"growth","round":1,"note":"한 LED 씩 자라는 픽셀 들꽃밭이에요. 키 큰 접시꽃 둘이 패널 위쪽까지 올라가 꽃대 아래부터 피어요. 시든 꽃잎은 한 점씩 떨어져 발치에 쌓이고, 시드는 포기 곁에서 새 싹이 올라와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-sprout","type":"code","name":"sprout","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Grow=0.25..6, Branches=3..14, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Grow","min":0.25,"max":6},{"name":"Branches","min":3,"max":14},{"name":"Wind","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0426,"detail":0.1141,"edges":0.9949,"complexity":0.1635,"coverage":0.1685,"colour":0.2652,"drift":0.0313},"knobResponse":[0.0448,0.119,0.1279,0.0982]},{"slug":"square-peg","title":"Square Peg","family":"topology","round":49,"note":"구불거리며 비틀리는 닫힌 곡선 위에 네 꼭짓점을 얹은 정사각형을 프레임마다 다 찾아 그리면, 정사각형이 둘씩 태어나고 사라져도 그 수는 늘 홀수예요. K3 은 찾는 직사각형의 가로세로 비, K4 는 곡선이 휘는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-square-peg","type":"code","name":"square-peg","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ratio=1..3, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ratio","min":1,"max":3},{"name":"Wobble","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2706,"detail":0.0627,"edges":0.8513,"complexity":0.1257,"coverage":0.5291,"colour":0.2477,"drift":0.1322},"knobResponse":[0.0846,0.1151,0.1378,0.1615]},{"slug":"square-wheels","title":"Square Wheels","family":"physics","round":41,"note":"세 줄의 길 위로 홈이 파인 정사각형 바퀴가 굴러가요. 길은 바퀴 한 변 길이로 자른 뒤집힌 현수선 둔덕이라, 바퀴를 길에 내려놓기만 하는데도 흰 축은 흐린 가로줄을 벗어나지 않아요. K3 은 변 수를 4 에서 8 까지 바꾸고 길도 그 바퀴에 맞춰요. K4 를 올리면 둔덕이 펴지면서 축이 출렁이기 시작해, 평평한 길에서 정사각형 축은 4.7 LED 까지 떠요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-square-wheels","type":"code","name":"square-wheels","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sides=4..8, Road=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sides","min":4,"max":8},{"name":"Road","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":1.4157,"detail":0.2236,"edges":0.9704,"complexity":0.1378,"coverage":0.427,"colour":0.3987,"drift":0.2852},"knobResponse":[0.2243,0.2227,0.2381,0.2086]},{"slug":"square-word","title":"Square Word","family":"type","round":78,"note":"한 줄로 쓴 영어 낱말 둘의 글자가 미끄러져 네모 칸에 들어가, 쉬빙의 방체 서법대로 한자 같은 네모 글자 둘이 위아래로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-square-word","type":"code","name":"square-word","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Weight=1.5..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phrase","min":0,"max":7},{"name":"Weight","min":1.5,"max":4}],"start":[0,2,0,1.5],"measures":{"motion":0.2543,"detail":0.0778,"edges":0.847,"complexity":0.1835,"coverage":0.2508,"colour":0.2887,"drift":0.1551},"knobResponse":[0.0491,0.1001,0.0631,0.0476]},{"slug":"squared-rectangle","title":"Squared Rectangle","family":"cells","round":53,"note":"저항 그물의 전선마다 전압 강하를 높이로, 전류를 너비로 삼은 타일이 세로 직사각형 하나를 빈틈없이 메운 채 전도도를 따라 늘고 줄며 미끄러지다가, 몇 초마다 전도도가 모두 1로 돌아와 정사각형들로 딱 맞아떨어지고 이음매가 하얗게 번쩍여요. K3 은 타일 수(13~20), K4 는 전도도가 1에서 벗어나는 폭이고, 단추를 누르면 바로 정사각형으로 맞아떨어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-squared-rectangle","type":"code","name":"squared-rectangle","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tiles=13..20, Wander=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tiles","min":13,"max":20},{"name":"Wander","min":-1,"max":1}],"start":[0,2,13,0.06],"measures":{"motion":0.7434,"detail":0.0564,"edges":0.5334,"complexity":0.0509,"coverage":0.8388,"colour":0.417,"drift":0.1753},"knobResponse":[0.4428,0.1319,0.1958,0.1798]},{"slug":"stable-marriage","title":"Stable Marriage","family":"algo","round":54,"note":"위 16명과 아래 16명 사이의 지연 수락에서 청혼마다 128줄을 가로지르는 선이 날아가 받아들여지면 남고 밀려나면 가운데서 끊기며, 위쪽 안정 매칭이 서면 아래쪽이 같은 목록으로 청혼해서 선 끝의 순위 색이 뒤집히고 두 안정 매칭이 다른 쌍만 번갈아 바뀌는데, K3 은 모두가 한 순위를 나누는 정도, K4 는 아예 받지 않는 상대의 몫이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stable-marriage","type":"code","name":"stable-marriage","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Agreement=0..1, Choosy=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Agreement","min":0,"max":1},{"name":"Choosy","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1867,"detail":0.154,"edges":0.6571,"complexity":1.4407,"coverage":0.4418,"colour":0.3151,"drift":0.1728},"knobResponse":[0.1476,0.1509,0.1814,0.175]},{"slug":"stadium-billiard","title":"Stadium Billiard","family":"physics","round":28,"note":"공 이백 개가 방향을 1000분의 3 라디안 안에서만 달리해 한 점에서 흰 구슬 하나로 떠나요. 패널만 한 부니모비치 경기장의 둥근 끝이 구슬을 무지개 선으로 늘이고 접어서, 몇 초 만에 공들이 기체처럼 판을 채워요. K3 을 돌리면 탁자가 원이 되어 공이 흩어지지 않고, 누르면 새 무리가 떠나요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-stadium-billiard","type":"code","name":"stadium-billiard","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Round=0..1, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Round","min":0,"max":1},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.3616,"detail":0.0707,"edges":0.5768,"complexity":0.586,"coverage":0.1863,"colour":0.2492,"drift":0.1225},"knobResponse":[0.0382,0.064,0.0378,0.0449]},{"slug":"stained-glass","title":"Stained Glass","family":"glass","round":18,"note":"고딕 첨두 창이 세운 패널을 다 채워요. 뾰족한 머리의 장미창과 몸통의 생명나무가 검은 납선에 끼운 보석빛 유리 조각으로 짜여 있고, 창 뒤로 해가 지나가면 그 쪽 조각이 희게 타오르고 구름 그림자가 지나가면 어두워져요. K3 은 유리를 자른 크기라서, 돌리면 테두리 네모와 마름모가 잘아지고 장미 꽃잎이 여덟 장에서 열두 장이 돼요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-stained-glass","type":"code","name":"stained-glass","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Glass=0..1, Speed=0.2..3, Pieces=1..4, Clouds=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Glass","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pieces","min":1,"max":4},{"name":"Clouds","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0274,"detail":0.1501,"edges":0.9911,"complexity":1.9492,"coverage":0.4248,"colour":0.2313,"drift":0.0531},"knobResponse":[0.1334,0.0459,0.0844,0.0693]},{"slug":"star-trails","title":"Star Trails","family":"celestial","round":12,"note":"삼각대에 세운 카메라가 셔터를 열어 둔 사이 하늘이 돌아서, 별마다 북극 둘레에 제 색의 호를 그려요. 능선 아래에는 랜턴을 켠 텐트가 있고, 가끔 떨어지는 별똥별은 궤적만큼 사진에 남아요. K1 을 누르면 별똥별이 하나 더 떨어져요.","why":"거의 멈춘 사진이에요(움직임 0.02).","block":1,"ramped":false,"layer":{"id":"layer-star-trails","type":"code","name":"star-trails","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Facing=-1..1, Speed=0.2..3, Latitude=-1..1, Exposure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Facing","min":-1,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Latitude","min":-1,"max":1},{"name":"Exposure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.019,"detail":0.0909,"edges":0.5036,"complexity":1.5537,"coverage":0.563,"colour":0.1007,"drift":0.036},"knobResponse":[0.2496,0.0367,0.1859,0.2144]},{"slug":"steiner-chain","title":"Steiner Chain","family":"geometry","round":39,"note":"위에서는 고리 안의 같은 원 여섯이 통째로 돌고, 아래는 그 사슬을 반전한 그림이라 원이 넓은 쪽을 지나며 부풀고 좁은 쪽에서 줄어요. 원마다 위아래가 같은 색이고, 어디서 시작해도 사슬이 닫히는 슈타이너의 포리즘이 접점의 흰 불꽃으로 보여요.","why":"원 안의 결이 잘아요.","block":1,"ramped":false,"layer":{"id":"layer-steiner-chain","type":"code","name":"steiner-chain","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Circles=6..12, Speed=0.2..3, Turns=1..4, Offset=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Circles","min":6,"max":12},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":1,"max":4},{"name":"Offset","min":0,"max":1}],"start":[6,2,1,0.06],"measures":{"motion":0.3441,"detail":0.0929,"edges":0.4245,"complexity":1.7706,"coverage":0.6096,"colour":0.2864,"drift":0.1304},"knobResponse":[0.1921,0.201,0.172,0.0934]},{"slug":"steiner-deltoid","title":"Steiner Deltoid","family":"line","round":73,"note":"외접원을 도는 점의 심슨 선이 패널 높이를 가로지르고, 그 자취가 쌓여 삼각형 세 변에 붙은 세 뿔 델토이드가 떠올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-steiner-deltoid","type":"code","name":"steiner-deltoid","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Trail=0.5..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":1},{"name":"Trail","min":0.5,"max":4}],"start":[0,2,0,0.5],"measures":{"motion":0.3235,"detail":0.0808,"edges":0.2438,"complexity":1.8841,"coverage":0.4056,"colour":0.1102,"drift":0.0706},"knobResponse":[0.0649,0.0768,0.0891,0.0685]},{"slug":"steiner-symmetrization","title":"Steiner Symmetrization","family":"line","round":69,"note":"초승달, 구멍 난 달걀, 일곱 뿔 별, 떨어진 두 덩이, 빗이 한 LED 현의 빗금으로 그려지고, 현마다 제 박자로 미끄러져 가운데가 흐린 축에 오고 틈으로 갈렸던 현은 한 줄로 붙은 뒤, 빗금이 새 축으로 돌아 다시 미끄러지는 동안 아래 막대가 같은 넓이 원의 눈금까지 줄어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-steiner-symmetrization","type":"code","name":"steiner-symmetrization","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Axes=0..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Shape","min":0,"max":5},{"name":"Axes","min":0,"max":8}],"start":[0,2,0,0.06],"measures":{"motion":0.361,"detail":0.0844,"edges":0.9018,"complexity":0.2283,"coverage":0.3259,"colour":0.2893,"drift":0.1841},"knobResponse":[0.1362,0.1111,0.1448,0.0596]},{"slug":"steiner-tree","title":"Steiner Tree","family":"geometry","round":75,"note":"단자를 잇는 가장 짧은 망이 120도로 만나는 슈타이너 점을 두고 서서, 더 짧은 망이 나타나면 뒤집히며 옛 망을 호박색으로 지우고, 발치 막대가 최소 신장 트리와의 길이 비를 √3/2 바닥에 대어 읽어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-steiner-tree","type":"code","name":"steiner-tree","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Terminals=4..7, Scatter=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Terminals","min":4,"max":7},{"name":"Scatter","min":0,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.0616,"detail":0.0546,"edges":0.2069,"complexity":0.9352,"coverage":0.2381,"colour":0.117,"drift":0.0648},"knobResponse":[0.0527,0.0761,0.0972,0.0813]},{"slug":"stit-tessellation","title":"STIT Tessellation","family":"cells","round":54,"note":"패널이 한 칸에서 시작해, 칸마다 둘레에 비례하는 빠르기로 기다리다 그 칸을 지나는 무작위 직선에 둘로 잘리고, 새 선분은 하얗게 번쩍이며 옛 선분에 T 자로 닿을 뿐 가로지르지 않아요. 칸이 제 밀도에 이르면 화면이 떠도는 한 점으로 다이빙하고, 잘림이 같은 법칙을 되찾을 만큼만 이어져서 칸은 끝없이 다가오며 갈라져요. K3 은 축을 따르는 선의 몫이라 1 이면 몬드리안 과정이고, K4 는 패널에 서는 칸의 수예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stit-tessellation","type":"code","name":"stit-tessellation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Cells=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Axes","min":0,"max":1},{"name":"Cells","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.7782,"detail":0.0565,"edges":0.8121,"complexity":0.2984,"coverage":0.964,"colour":0.4942,"drift":0.134},"knobResponse":[0.4518,0.2186,0.2541,0.2601]},{"slug":"stochastic-resonance","title":"Stochastic Resonance","family":"rhythm","round":46,"note":"이중 우물 속 입자 60개가 약한 밀기와 잡음으로 우물을 건너고, 어느 우물에 있는지 적은 기록이 공명 잡음에서 박자 맞춘 보라와 호박색 띠가 돼요. K3 은 잡음(0 이 공명), K4 는 밀기 세기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stochastic-resonance","type":"code","name":"stochastic-resonance","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Noise=-1..1, Drive=0.55..0.95","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Noise","min":-1,"max":1},{"name":"Drive","min":0.55,"max":0.95}],"start":[0,2,0,0.55],"measures":{"motion":0.6379,"detail":0.0925,"edges":0.9858,"complexity":0.1411,"coverage":0.8834,"colour":0.5195,"drift":0.1272},"knobResponse":[0.4364,0.2917,0.1781,0.0586]},{"slug":"stokes-drift","title":"Stokes Drift","family":"wave","round":57,"note":"깊이 109 LED 의 물 단면에 파장 256 LED 의 깊은 물 파도가 오른쪽으로 지나가고, 선형 파도의 속도장을 따라 적분한 입자마다 작은 궤도가 꼭 닫히지 않아서 수면에서 곧게 내린 물감 선 네 개가 윗부분부터 앞으로 기울어요. 기운 모양은 e^(2kz) 곡선이라 14 LED 내려갈 때마다 반으로 줄고, 아래쪽 점들은 거의 제자리에 있어요. K3 은 가파름 ak(0.15~0.4)이고, K4 는 입자가 속도를 읽는 자리라 0 은 제 자리에서 읽는 에어리 파도, 1 은 궤도 중심에서 읽는 게르스트너의 트로코이드 파도여서 궤도가 닫히고 물감 선이 흔들리기만 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stokes-drift","type":"code","name":"stokes-drift","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Steepness=0.15..0.4, Gerstner=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Steepness","min":0.15,"max":0.4},{"name":"Gerstner","min":0,"max":1}],"start":[0,2,0.15,0.06],"measures":{"motion":0.9726,"detail":0.0852,"edges":0.4627,"complexity":0.9205,"coverage":0.188,"colour":0.1898,"drift":0.0896},"knobResponse":[0.0601,0.1102,0.1274,0.065]},{"slug":"stormer-trap","title":"Størmer Trap","family":"particle","round":54,"note":"패널을 가로질러 눕힌 자기 쌍극자의 장에서 대전 입자 48개가 위아래 끝까지 서는 희미한 자기력선 고리를 감아 돌며 가운데 가까운 거울점에서 되튀고, 양전하는 한쪽으로 음전하는 반대쪽으로 축을 돌며 천천히 떠돌다가 손실 원뿔에 든 몇 개만 가운데 작은 구에 닿아 번쩍이는데, K3 은 에너지를, K4 는 적도에서의 피치각을 정해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-stormer-trap","type":"code","name":"stormer-trap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Energy=0..1, Pitch=0..90","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Energy","min":0,"max":1},{"name":"Pitch","min":0,"max":90}],"start":[0,2,0,0.06],"measures":{"motion":0.3519,"detail":0.0685,"edges":0.324,"complexity":1.4202,"coverage":0.2922,"colour":0.1285,"drift":0.0544},"knobResponse":[0.0516,0.0887,0.0898,0.0857]},{"slug":"strange-eigenmode","title":"Strange Eigenmode","family":"sim","round":54,"note":"한 변 1 인 토러스에 푼 물감을 반 주기는 행이 옆으로, 반 주기는 열이 위아래로 미끄러지는 피어험버트의 사인 흐름이 줄무늬로 늘이고 접는데, 매 프레임 밝기를 되돌려 놓아서 보라에서 옅은 청록으로 빛나는 줄무늬가 3초마다 똑같은 모양으로 돌아오는 동안 참 세기는 주기마다 39% 로 줄어요. K3 은 젓는 세기, K4 는 확산이고, K1 을 누르면 새 물감을 부어 다시 저어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-strange-eigenmode","type":"code","name":"strange-eigenmode","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Stir=-1..1, Diffusion=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stir","min":-1,"max":1},{"name":"Diffusion","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6277,"detail":0.0452,"edges":0.2118,"complexity":2.219,"coverage":0.5118,"colour":0.2008,"drift":0.2314},"knobResponse":[0.1459,0.2614,0.2476,0.2971]},{"slug":"string-art","title":"String Art","family":"type","round":76,"note":"핀 187개를 두른 틀에 실 한 가닥이 탐욕 셈으로 고른 현을 하나씩 걸어, 12초에 걸쳐 청록 A 가 실의 겹침으로 짜이고 실, K, & 가 뒤를 이어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-string-art","type":"code","name":"string-art","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Spacing=2..8, Round=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spacing","min":2,"max":8},{"name":"Round","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.0569,"detail":0.0449,"edges":0.3137,"complexity":1.2839,"coverage":0.4198,"colour":0.1634,"drift":0.3416},"knobResponse":[0.032,0.1009,0.04,0.0366]},{"slug":"structure-ascii","title":"Structure ASCII","family":"type","round":68,"note":"큰 A, S, &, 글 이 안쪽 테두리만 어둡게 켠 채 흔들리다 다음 글자로 녹아들고, 외곽선이 지나는 5×8 칸마다 그 조각에 획이 가장 가까운 아스키 문자를 골라 빗금과 밑줄이 이어진 윤곽을 그려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-structure-ascii","type":"code","name":"structure-ascii","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Cell=0..3","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Set","min":0,"max":3},{"name":"Cell","min":0,"max":3}],"start":[0,2,0,0.06],"measures":{"motion":0.1276,"detail":0.0664,"edges":1,"complexity":0.1004,"coverage":0.2024,"colour":0.1993,"drift":0.0877},"knobResponse":[0.0485,0.0526,0.0475,0.0505]},{"slug":"subpixel","title":"Subpixel","family":"type","round":66,"note":"a 와 g 의 TrueType 윤곽이 여섯 배로 키운 픽셀 격자 위를 픽셀 몇 분의 일씩 미끄러지고, 밑의 격자는 매 프레임 다시 래스터화돼 RGB 서브픽셀 줄무늬와 색 번짐으로 뛰어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-subpixel","type":"code","name":"subpixel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Letters=0..2, Speed=0.2..3, Mode=0..3, Hint=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Letters","min":0,"max":2},{"name":"Speed","min":0.2,"max":3},{"name":"Mode","min":0,"max":3},{"name":"Hint","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.2208,"detail":0.0659,"edges":0.492,"complexity":0.7062,"coverage":0.4448,"colour":0.4077,"drift":0.2226},"knobResponse":[0.2289,0.1625,0.1909,0.033]},{"slug":"sugar-scrub","title":"Sugar Scrub","family":"cosmetic","round":32,"note":"장밋빛 오일 밤 위에 설탕 결정 칠백 알쯤이 떠 있고, 보이지 않는 손끝이 지름 26 LED 원을 그리며 지나간 자리에 분홍빛 광택 고리가 남아요. 손끝에 끌린 알갱이는 구르며 하얀 십자로 반짝이고 녹아 작아져요. 10초마다 새 한 숟갈이 더미로 얹혔다가 다음 원에 쓸려 퍼져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-sugar-scrub","type":"code","name":"sugar-scrub","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Grain=-1..1, Oil=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Grain","min":-1,"max":1},{"name":"Oil","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0841,"detail":0.0638,"edges":0.1575,"complexity":2.6755,"coverage":1,"colour":0.1376,"drift":0.0416},"knobResponse":[0.1741,0.077,0.0995,0.1983]},{"slug":"sunglint","title":"Sunglint","family":"ocean","round":20,"note":"절벽에서 해를 마주 보면 수평선 아래로 윤슬 길이 내려오며 넓어져 패널을 채우고, 밀려오는 잔물결 줄마다 반짝임이 실려요. K1 을 누르면 돛단배가 빛 속을 검은 그림자로 가로질러요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-sunglint","type":"code","name":"sunglint","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Sun=0..1, Speed=0.2..3, Chop=0..1, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Sun","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Chop","min":0,"max":1},{"name":"Wind","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5376,"detail":0.3357,"edges":0.4835,"complexity":2.2983,"coverage":0.8569,"colour":0.0799,"drift":0.0378},"knobResponse":[0.1189,0.329,0.2477,0.3023]},{"slug":"swarmalators","title":"Swarmalators","family":"particle","round":47,"note":"위상이 비슷한 점끼리 더 끌리고 모두에게서 밀리는 점 150개짜리 무리 둘이 위아래로 서서, 색이 고리를 한 바퀴 도는 무지개 고리가 돼요. 결합이 천천히 오르내리면 위 고리는 타원으로 눌렸다 쪼개지고, 아래 고리에서는 점들이 고리를 따라 돌아요. K3 은 결합 K, K4 는 그 흔들림의 폭이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-swarmalators","type":"code","name":"swarmalators","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Coupling=-1..0.5, Tour=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Coupling","min":-1,"max":0.5},{"name":"Tour","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.551,"detail":0.0942,"edges":1,"complexity":0.2226,"coverage":0.2864,"colour":0.5645,"drift":0.1437},"knobResponse":[0.2718,0.1243,0.1551,0.083]},{"slug":"swatch-row","title":"Swatch Row","family":"cosmetic","round":30,"note":"보이지 않는 손가락이 아이보리 카드에 크림 안료를 한 줄씩 끌어 색조표를 채워요. 줄마다 한 단계씩 밝거나 짙고, K1 하나로 어떤 색 라인으로든 바뀌어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-swatch-row","type":"code","name":"swatch-row","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Range=-1..1, Finish=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Range","min":-1,"max":1},{"name":"Finish","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1965,"detail":0.0215,"edges":0.0463,"complexity":1.8772,"coverage":1,"colour":0.2018,"drift":0.0306},"knobResponse":[0.1202,0.0645,0.0452,0.0494]},{"slug":"syllable-odometer","title":"Syllable Odometer","family":"type","round":66,"note":"자모 바퀴 셋이 주행 기록계처럼 받침부터 돌며 한글 11,172 음절을 세고, 완성형 2,350 에 든 음절은 꽉 찬 호박색으로, 빠진 음절은 속 빈 보라 윤곽으로 지나가며 아래 지도를 채워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-syllable-odometer","type":"code","name":"syllable-odometer","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Initial=0..18, Skip=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Initial","min":0,"max":18},{"name":"Skip","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6463,"detail":0.0694,"edges":0.3599,"complexity":0.186,"coverage":0.2966,"colour":0.1732,"drift":0.0996},"knobResponse":[0.0578,0.0724,0.0603,0.0595]},{"slug":"taffy-cream","title":"Taffy Cream","family":"cosmetic","round":37,"note":"라일락 크림과 아이보리 크림이 높은 통을 채우고, 보이지 않는 핀 셋이 둘씩 서로를 한 바퀴씩 돌며 태피처럼 잡아당겨요. 두 크림의 경계가 윤기 있는 주름으로 늘어나 한 주기에 13배쯤 길어지며 겹이 늘고 가늘어지다 파스텔로 섞이면, 아이보리 테를 두른 새 덩이가 핀이 지날 길에 놓여요. K3 은 핀을 다섯까지 늘리고, 누르면 새 덩이를 바로 놓아요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-taffy-cream","type":"code","name":"taffy-cream","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Pins=3..5, Gloss=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Pins","min":3,"max":5},{"name":"Gloss","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1992,"detail":0.0229,"edges":0.0398,"complexity":1.5866,"coverage":1,"colour":0.2145,"drift":0.034},"knobResponse":[0.174,0.088,0.0927,0.0503]},{"slug":"talbot-carpet","title":"Talbot Carpet","family":"wave","round":32,"note":"좁은 슬릿 격자를 지난 빛의 세기를, 격자에서 멀어지는 거리를 세로로 두고 그려요. 슬릿 상이 한 탤벗 길이마다 그대로, 반 길이마다 반 주기 옆으로 되살아나고, 그 사이 분수 거리에서는 둘과 넷으로 갈라진 상과 곧은 빛줄기가 엇갈려요. 남색 골과 청록 바닥, 흰 방울이 1 LED 망점 위에서 1초에 15줄씩 올라가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-talbot-carpet","type":"code","name":"talbot-carpet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Slit=0..1, Periods=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Slit","min":0,"max":1},{"name":"Periods","min":1,"max":4}],"start":[0,2,0,1],"measures":{"motion":0.9679,"detail":0.2277,"edges":0.1425,"complexity":1.3191,"coverage":0.9648,"colour":0.1367,"drift":0.088},"knobResponse":[0.1564,0.1417,0.1324,0.1293]},{"slug":"talking-board","title":"Talking Board","family":"halloween","round":47,"note":"두 촛불 사이 검보라 판 위를 하트 포인터가 스스로 미끄러져 글자에 멈추면, 유리창 아래 글자가 초록으로 켜지고 판 위에 HELLO 나 GOODBYE 같은 말이 한 자씩 적혀요. K3 은 촛불의 일렁임, K4 는 포인터 둘레 빛이에요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-talking-board","type":"code","name":"talking-board","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Flicker=0..1, Aura=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Flicker","min":0,"max":1},{"name":"Aura","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1577,"detail":0.0504,"edges":0.4811,"complexity":0.3955,"coverage":0.7725,"colour":0.1949,"drift":0.0733},"knobResponse":[0.0575,0.051,0.0657,0.0732]},{"slug":"tally-count","title":"Tally Count","family":"type","round":74,"note":"기호 1~4 아래 칠판 칸 넷에 표를 하나씩 읽을 때마다 분필 한 획이 正 의 획순대로 그어져, 다섯 표마다 正 하나가 닫히며 칸이 막대처럼 아래로 겨루고, 끝나면 1등 칸이 빛나고 맨 아래 선이 1등이 처음부터 끝까지 앞섰는지 말해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tally-count","type":"code","name":"tally-count","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Closeness=0..1, Size=7..15","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Closeness","min":0,"max":1},{"name":"Size","min":7,"max":15}],"start":[0,2,0,7],"measures":{"motion":0.0659,"detail":0.1174,"edges":0.771,"complexity":0.6007,"coverage":0.2554,"colour":0.1993,"drift":0.0864},"knobResponse":[0.0558,0.0397,0.0717,0.0732]},{"slug":"tamsel","title":"Tamsel","family":"pixel","round":85,"note":"밤거리 가스등에 불을 붙이는 견습 점등꾼이 받침 위에 한 손은 허리에, 한 손은 갈고리 끝에 불씨를 매단 놋쇠 장대에 얹고 서서 숨 쉬고 깜빡여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tamsel","type":"code","name":"tamsel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Gel","min":0,"max":1},{"name":"Stand","min":0,"max":3},{"name":"Detail","min":0,"max":1},{"name":"Edition","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0282,"detail":0.0739,"edges":0.7504,"complexity":0.1761,"coverage":0.5022,"colour":0.2325,"drift":0.0077},"knobResponse":[0.0167,0.0248,0.3056,0.0888]},{"slug":"taylor-unmixing","title":"Taylor Unmixing","family":"sim","round":61,"note":"끈적한 유체에 떨어뜨린 염료 일곱 방울이 쿠에트 흐름에 비스듬한 가는 줄로 늘어나 패널을 몇 바퀴 감았다가, 벽이 되돌아가면 처음 자리의 고리 안으로 둥글게 돌아와요. 확산을 올리면 위아래로 번진 흐린 얼룩으로 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-taylor-unmixing","type":"code","name":"taylor-unmixing","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Turns=2..8, Diffusion=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":2,"max":8},{"name":"Diffusion","min":0,"max":1}],"start":[0,2,2,0.06],"measures":{"motion":0.6612,"detail":0.0451,"edges":0.1585,"complexity":1.9428,"coverage":0.691,"colour":0.2693,"drift":0.2092},"knobResponse":[0.1311,0.1754,0.1626,0.0959]},{"slug":"teletext","title":"Teletext","family":"type","round":78,"note":"디코더가 쪽 번호를 돌려 100 쪽을 찾고, 색이 바뀌는 자리마다 빈칸이 생기는 모자이크 하위 쪽 셋이 2.5초마다 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-teletext","type":"code","name":"teletext","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Page=1..5, Speed=0.2..3, Size=0..1, Reception=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Page","min":1,"max":5},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":0,"max":1},{"name":"Reception","min":0,"max":1}],"start":[1,2,0,0.06],"measures":{"motion":0.1635,"detail":0.0962,"edges":1,"complexity":0.062,"coverage":0.3473,"colour":0.6199,"drift":0.3756},"knobResponse":[0.4155,0.2111,0.3795,0.2189]},{"slug":"tennis-racket","title":"Tennis Racket","family":"sim","round":49,"note":"가운데 축으로 돌던 T자 손잡이가 몇 초마다 반 바퀴씩 뒤집히고, 아래 구에서는 각운동량이 분리선을 따라 한쪽 끝에서 반대쪽 끝으로 건너가요. K3 은 어느 주축 가까이에서 던질지, K4 는 그 축에서 얼마나 비껴 던질지이고, 단추를 누르면 다시 던져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tennis-racket","type":"code","name":"tennis-racket","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Axis=-1..1, Nudge=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Axis","min":-1,"max":1},{"name":"Nudge","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4329,"detail":0.0508,"edges":0.9029,"complexity":0.141,"coverage":0.3983,"colour":0.2014,"drift":0.0914},"knobResponse":[0.0954,0.0589,0.0798,0.0708]},{"slug":"tensegrity","title":"Tensegrity","family":"physics","round":71,"note":"서로 닿지 않는 막대 15개가 팽팽한 케이블 그물에 걸려 패널 높이의 탑으로 서서 16초에 한 바퀴 천천히 돌고, Load 를 올리면 꼭대기의 추가 탑을 17% 짧게 누르며 위쪽을 74도 더 비틀어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tensegrity","type":"code","name":"tensegrity","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Struts=3..6, Load=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Struts","min":3,"max":6},{"name":"Load","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.3934,"detail":0.0806,"edges":0.5939,"complexity":1.0678,"coverage":0.3024,"colour":0.1564,"drift":0.0513},"knobResponse":[0.0608,0.1126,0.1149,0.1101]},{"slug":"terrell-rotation","title":"Terrell Rotation","family":"space","round":57,"note":"정육면체와 위경선 그물을 두른 구가 바둑판으로 놓인 판이 바늘구멍 카메라 앞을 빛의 절반 넘는 빠르기로 위로 미끄러지고, LED 마다 판을 먼저 떠나 지금 카메라에 닿는 빛이 그리는 모습을 보여 줘요. 정육면체는 납작해지지 않고 아랫면을 보이며 돌아 보이고, 구는 테두리가 둥근 채로 그물의 극만 위로 돌아가요. 빛이 다가오는 쪽에서 떠난 아래는 보라 쪽으로, 멀어지는 쪽에서 떠난 위는 초록 쪽으로 옮겨 가요. K3 은 빛에 대한 속도 β(0.5~0.95)라 카메라 바로 앞의 정육면체가 0.5 에서 30도, 0.9 에서 64도 돌아 보이고, K4 는 카메라와 판 사이 거리(2~8칸)라 가까우면 시야가 위아래 54도라 가까운 줄의 테가 휘고 멀면 19도라 모든 정육면체가 거의 같은 각도 arcsin β 로 돌아 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-terrell-rotation","type":"code","name":"terrell-rotation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beta=0.5..0.95, Distance=2..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beta","min":0.5,"max":0.95},{"name":"Distance","min":2,"max":8}],"start":[0,2,0.5,2],"measures":{"motion":2.7089,"detail":0.1244,"edges":0.7026,"complexity":1.1776,"coverage":0.5154,"colour":0.1984,"drift":0.1346},"knobResponse":[0.1189,0.221,0.2271,0.2255]},{"slug":"test-card","title":"Test Card","family":"glitch","round":1,"note":"텔레비전 컬러 바를, 수직 동기를 잃어 가는 수상기가 보여 주는 대로 그려요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-test-card","type":"code","name":"test-card","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Bursts=0.2..6, Damage=0.15..1, Roll=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Bursts","min":0.2,"max":6},{"name":"Damage","min":0.15,"max":1},{"name":"Roll","min":0,"max":1}],"start":[0,2,0.15,0.06],"measures":{"motion":0.2635,"detail":0.0837,"edges":0.7844,"complexity":0.0808,"coverage":0.8476,"colour":0.6265,"drift":0.0606},"knobResponse":[0.3578,0.0535,0.0933,0.3676]},{"slug":"tetromino-well","title":"Tetromino Well","family":"algo","round":10,"note":"세운 패널이 너비 10칸, 높이 21칸의 테트리스 우물이에요. 지치지 않는 플레이어가 꼭대기에 기다리는 다음 조각을 보며 패널의 3분의 2 높이까지 쌓고, 오른쪽 한 줄을 비워 두었다가 긴 막대가 오면 네 줄을 한꺼번에 지워요. K1 을 누르면 긴 막대가 다음 조각으로 와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-tetromino-well","type":"code","name":"tetromino-well","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Headroom=6..18, Garbage=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Headroom","min":6,"max":18},{"name":"Garbage","min":0,"max":1}],"start":[0,2,6,0.06],"measures":{"motion":0.2184,"detail":0.0909,"edges":0.7088,"complexity":0.1224,"coverage":0.6512,"colour":0.4389,"drift":0.0999},"knobResponse":[0.2488,0.0464,0.2189,0.2009]},{"slug":"thermal","title":"Thermal","family":"flight","round":24,"note":"여름 오후의 밭 위에서 흰 글라이더가 열기류를 타고 타원을 그리며 맴돌아 올라가요. 말똥가리 둘이 더 좁게 같이 돌고, 꼭대기의 적운은 자라며 바닥이 어두워져요. 구름 바닥에 닿은 글라이더는 다음 열기류로 미끄러져 가고 아래에서 새 글라이더가 들어와요. K1 을 누르면 윈치가 글라이더 하나를 끌어올려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-thermal","type":"code","name":"thermal","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hour=0..1, Speed=0.2..3, Gliders=1..4, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hour","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gliders","min":1,"max":4},{"name":"Wind","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0272,"detail":0.0308,"edges":0.2402,"complexity":1.2348,"coverage":0.9999,"colour":0.3714,"drift":0.0371},"knobResponse":[0.1132,0.0554,0.0527,0.073]},{"slug":"thomson-kink","title":"Thomson Kink","family":"wave","round":61,"note":"가운데 줄을 오르내리던 전하가 거꾸로 돌거나 멈출 때마다 빛의 속도로 퍼지는 껍질이 생기고, 껍질 사이마다 그때의 속도로 지금 있을 자리에서 뻗은 곧은 역선이 분홍 꺾임으로 이어져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-thomson-kink","type":"code","name":"thomson-kink","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lines=12..32, Velocity=0.3..0.9","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lines","min":12,"max":32},{"name":"Velocity","min":0.3,"max":0.9}],"start":[0,2,12,0.3],"measures":{"motion":1.4922,"detail":0.0536,"edges":0.539,"complexity":0.846,"coverage":0.8963,"colour":0.1807,"drift":0.1066},"knobResponse":[0.1162,0.1317,0.1166,0.1513]},{"slug":"thomson-problem","title":"Thomson Problem","family":"physics","round":34,"note":"천천히 도는 구 위에서 같은 전하 100개가 서로 밀어 거의 삼각형인 격자로 앉아요. 이웃이 여섯인 전하는 가운데가 옅은 하늘색으로, 오일러 공식이 늘 열둘을 남기는 다섯 이웃 전하는 금색으로 빛나고, 일곱 이웃 전하가 생기면 자홍색이에요. K3 을 480 까지 올리면 열둘이 5-7-5 흉터로 자라고, K1 을 누르면 전하가 흩어졌다가 다시 격자로 앉아요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-thomson-problem","type":"code","name":"thomson-problem","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Charges=100..480, Heat=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Charges","min":100,"max":480},{"name":"Heat","min":0,"max":1}],"start":[0,2,100,0.06],"measures":{"motion":0.1033,"detail":0.027,"edges":0.1646,"complexity":0.9152,"coverage":0.2589,"colour":0.1371,"drift":0.0297},"knobResponse":[0.0593,0.055,0.0527,0.0511]},{"slug":"three-disk-scattering","title":"Three-Disk Scattering","family":"fractal","round":78,"note":"원판 셋 사이를 튀다 나가는 점들 아래로, 출발마다 나가는 틈의 색을 칠한 지도가 끝없이 튀는 궤도 쪽으로 확대되며 띠 속의 띠를 보여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-three-disk-scattering","type":"code","name":"three-disk-scattering","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Gap=0.4..4, Bounces=3..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Gap","min":0.4,"max":4},{"name":"Bounces","min":3,"max":12}],"start":[0,2,0.4,3],"measures":{"motion":0.2688,"detail":0.0373,"edges":0.7407,"complexity":0.5293,"coverage":0.7748,"colour":0.5349,"drift":0.1648},"knobResponse":[0.2861,0.1933,0.1665,0.052]},{"slug":"three-gaps","title":"Three Gaps","family":"number","round":30,"note":"원 위에 α 씩 돌아가며 점을 찍으면 이웃 간격은 많아야 세 가지예요. 줄마다 점을 하나씩 더해 간격을 길이 등급으로 칠하고, α 가 분수에 닿으면 아래쪽이 줄무늬로 무너져요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-three-gaps","type":"code","name":"three-gaps","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Alpha=0..1, Points=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Alpha","min":0,"max":1},{"name":"Points","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1477,"detail":0.1059,"edges":0.725,"complexity":0.2583,"coverage":0.9968,"colour":0.6429,"drift":0.149},"knobResponse":[0.4559,0.1669,0.3074,0.2544]},{"slug":"tissot-indicatrix","title":"Tissot's Indicatrix","family":"space","round":55,"note":"도는 구 위에 같은 크기로 깐 작은 원들을 메르카토르 지도에 옮기면 원은 원 그대로지만 위아래 끝으로 갈수록 부풀어서, 위도 80도의 원은 적도의 원보다 거의 여섯 배 넓어요. 투영의 축이 25도 기운 채 열려서 구의 극이 위 가장자리 안에 앉고, 원들은 휜 길을 따라 돌며 위아래 끝에 다가갈 때 부풀었다 가운데로 오며 줄어요. K3 은 축의 기울기(25~90도), K4 는 메르카토르에서 등적 투영으로 섞는 정도이고, 다 섞으면 원이 넓이가 같은 납작한 타원이 되며 한 색이 돼요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tissot-indicatrix","type":"code","name":"tissot-indicatrix","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Tilt=25..90, Blend=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Tilt","min":25,"max":90},{"name":"Blend","min":0,"max":1}],"start":[0,2,25,0.06],"measures":{"motion":0.7992,"detail":0.1355,"edges":0.5856,"complexity":1.5719,"coverage":0.5442,"colour":0.1192,"drift":0.0625},"knobResponse":[0.0588,0.1671,0.1912,0.2193]},{"slug":"toner-pad","title":"Toner Pad","family":"cosmetic","round":35,"note":"섬유 400가닥이 아무렇게나 엇갈린 흰 솜 패드에 장밋빛 토너가 3.2초마다 한 방울씩 떨어져요. 젖는 앞은 잘 빨아올리는 섬유를 따라 손가락처럼 먼저 뻗고, 젖은 곳은 반투명해져 뒤의 빛을 토너 색으로 받으며 그 안의 섬유가 어둡게 드러나요. 패치는 가장자리부터 말라 흰 솜으로 돌아가요. K3 은 한 방울이 적시는 넓이를 1800 LED 에서 5400 LED 로 늘리고, K1 을 누르면 아직 젖은 곳을 피해 한 방울이 바로 떨어져요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-toner-pad","type":"code","name":"toner-pad","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Toner=0..1, Fibre=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Toner","min":0,"max":1},{"name":"Fibre","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0391,"detail":0.0359,"edges":0.0818,"complexity":1.8818,"coverage":1,"colour":0.1257,"drift":0.1404},"knobResponse":[0.0571,0.1234,0.1866,0.1574]},{"slug":"topologists-sine-curve","title":"Topologist's Sine Curve","family":"topology","round":73,"note":"sin(1/x) 의 흔들림이 아래 극한 선분으로 갈수록 촘촘해져 가장자리가 밝은 띠로 합쳐지고, 곡선을 따라 내려가는 구슬은 점점 빨리 흔들릴 뿐 선분에 닿지 못해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-topologists-sine-curve","type":"code","name":"topologists-sine-curve","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zoom=0..1, Measure=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zoom","min":0,"max":1},{"name":"Measure","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.9526,"detail":0.0885,"edges":0.3974,"complexity":1.1709,"coverage":0.3977,"colour":0.2422,"drift":0.0717},"knobResponse":[0.0922,0.1188,0.238,0.0806]},{"slug":"toussaint-wilczek","title":"Toussaint-Wilczek","family":"particle","round":55,"note":"초록과 자홍 두 종의 입자가 판 가득 뿌려져 걷다가 서로 만나면 짝지어 사라지고, 처음 우연히 더 많았던 쪽이 남은 자리마다 같은 색 영역이 걸음 수의 제곱근으로 넓어지며, 그 사이 이음매는 어둡게 남아 입자가 사라지는 자리에서 잿빛으로 반짝여요. K3 은 처음 뿌리는 밀도(LED 마다 80~320), K4 는 A 가 B 보다 많은 몫이라 올리면 자홍이 사라지고 초록이 판을 채워요. 단추를 누르면 새로 뿌려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-toussaint-wilczek","type":"code","name":"toussaint-wilczek","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=80..320, Excess=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":80,"max":320},{"name":"Excess","min":0,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":3.4684,"detail":0.3444,"edges":0.6629,"complexity":1.2513,"coverage":0.6627,"colour":0.521,"drift":0.22},"knobResponse":[0.3754,0.3816,0.244,0.3428]},{"slug":"tower-crane","title":"Tower Crane","family":"construction","round":24,"note":"해 질 녘 올라가는 콘크리트 건물 옆에 노란 타워크레인이 서서, 마당의 벽판과 철근 다발, 거푸집, 콘크리트 버킷을 차례로 꼭대기 층에 올려요. 붐이 원근 속에서 돌며 짧아졌다 길어지고, 버킷이 바닥을 부으면 건물이 한 층 자라 새 층 창에 불이 들어와요. K1 을 끝까지 돌리면 밤이 되어 투광등이 켜져요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-tower-crane","type":"code","name":"tower-crane","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Dusk=0..1, Speed=0.2..3, Floors=9..13, Wind=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Dusk","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Floors","min":9,"max":13},{"name":"Wind","min":-1,"max":1}],"start":[0,2,9,0.06],"measures":{"motion":0.1573,"detail":0.0705,"edges":0.403,"complexity":1.4462,"coverage":0.9851,"colour":0.2925,"drift":0.0434},"knobResponse":[0.3747,0.0499,0.0453,0.0999]},{"slug":"tower-stair","title":"Tower Stair","family":"halloween","round":51,"note":"둥근 돌탑을 잘라 보인 나선 계단을 두건 쓴 사람이 촛불을 들고 오르면, 불빛이 굽은 벽을 비추며 그의 커다란 그림자를 벽에 드리워요. 꼭대기에서 바람이 촛불을 끄면 어둠 속 창에 초록 눈 둘이 뜨고, 촛불은 계단 아래에서 다시 켜져요. K3 은 계단이 감기는 바퀴 수(3~8), K4 는 불빛이 닿는 거리이고, 단추를 누르면 그 자리에서 촛불이 꺼져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tower-stair","type":"code","name":"tower-stair","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Turns=3..8, Reach=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":3,"max":8},{"name":"Reach","min":-1,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.2621,"detail":0.0492,"edges":0.2821,"complexity":1.2358,"coverage":0.985,"colour":0.1804,"drift":0.1729},"knobResponse":[0.0937,0.0804,0.108,0.0818]},{"slug":"train-window","title":"Train Window","family":"space","round":17,"note":"달리는 기차 창밖이 층층이 흘러요. 먼 구름과 산은 느리게, 들판과 농가는 빠르게 지나가고 전차선 기둥은 휙 스쳐요. 깎은 비탈이 다가오면 터널이 창을 검게 덮고 나트륨등이 줄을 그으며 지나가요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-train-window","type":"code","name":"train-window","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Time=0..1, Speed=0.2..3, Hills=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Time","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Hills","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6601,"detail":0.0493,"edges":0.717,"complexity":0.2041,"coverage":0.8669,"colour":0.2389,"drift":0.3599},"knobResponse":[0.2716,0.0947,0.2843,0.1097]},{"slug":"trajan-helix","title":"Trajan Helix","family":"type","round":74,"note":"대리석 기둥이 천천히 돌고 발치에서 꼭대기까지 감긴 나선 띠에 트라야누스 기둥 받침의 비문이 빨간 로마 대문자로 새겨져 있어서, 앞에서 제 너비로 읽히던 글자가 가장자리에서 좁아지다 뒤로 넘어가며 글줄이 띠를 따라 끝없이 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-trajan-helix","type":"code","name":"trajan-helix","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paint=0..1, Turn=0.2..3, Turns=5..9, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paint","min":0,"max":1},{"name":"Turn","min":0.2,"max":3},{"name":"Turns","min":5,"max":9},{"name":"Light","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.3116,"detail":0.0348,"edges":0.1539,"complexity":1.4771,"coverage":0.7596,"colour":0.1718,"drift":0.0112},"knobResponse":[0.0496,0.0641,0.0878,0.3546]},{"slug":"tree-peano-curve","title":"Tree Peano Curve","family":"line","round":56,"note":"한 줄로 이어진 곡선이 LED 8192개를 한 번씩 다 지나며 왼쪽 아래 모서리에서 왼쪽 위 모서리까지 판을 메우고, 메운 순서대로 초록에서 파랑을 거쳐 자홍으로 물든 위를 옅은 앞선과 짧은 꼬리가 곡선을 따라 흘러요. 8초마다 고리 지운 걸음이 하얀 줄로 새 나무를 그리고, 새 곡선이 모서리에서부터 다시 차올라요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tree-peano-curve","type":"code","name":"tree-peano-curve","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bands=1..8, Stretch=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bands","min":1,"max":8},{"name":"Stretch","min":-1,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.3401,"detail":0.022,"edges":0.3283,"complexity":0.9535,"coverage":0.993,"colour":0.336,"drift":0.3792},"knobResponse":[0.3794,0.5046,0.1343,0.2557]},{"slug":"trick-or-treat","title":"Trick or Treat","family":"halloween","round":48,"note":"보라 하늘 아래 좁은 골목이 소실점으로 올라가고, 홑이불 유령과 빗자루 든 마녀, 고양이 셋이 손전등을 휘두르며 걸어가다 노란 빛이 쏟아지는 문 앞에서 사탕을 받고 점점 작아져요. K3 은 불 켠 집의 몫, K4 는 바람이고, K1 을 누르면 불 켠 집의 문이 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-trick-or-treat","type":"code","name":"trick-or-treat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lights=0.5..1, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lights","min":0.5,"max":1},{"name":"Wind","min":0,"max":1}],"start":[0,2,0.5,0.06],"measures":{"motion":0.3583,"detail":0.0448,"edges":0.294,"complexity":0.575,"coverage":0.8706,"colour":0.1771,"drift":0.0693},"knobResponse":[0.0692,0.1054,0.0595,0.0592]},{"slug":"trip-let","title":"Trip-let","family":"type","round":63,"note":"글자 셋을 밀어 낸 기둥의 교집합으로 깎은 블록이 비스듬한 빛줄기 속에서 제 대각선을 축으로 3분의 1 바퀴씩 돌아요. 축 하나가 빛과 나란해질 때마다 바닥의 긴 그림자가 덩어리에서 G, E, B 로 차례로 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-trip-let","type":"code","name":"trip-let","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Letters=0..5, Haze=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Letters","min":0,"max":5},{"name":"Haze","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.246,"detail":0.0368,"edges":0.745,"complexity":0.5108,"coverage":0.8704,"colour":0.1399,"drift":0.1035},"knobResponse":[0.0995,0.0996,0.0657,0.1578]},{"slug":"truchet","title":"Truchet","family":"geometry","round":1,"note":"타일마다 같은 사분원 둘이 있어요. 한 장을 90도 돌리면 길 둘이 하나로 이어지거나 하나가 둘로 끊겨요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-truchet","type":"code","name":"truchet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Flip Rate=0..5, Tile=8..20, Thickness=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Flip Rate","min":0,"max":5},{"name":"Tile","min":8,"max":20},{"name":"Thickness","min":0,"max":1}],"start":[0,2,8,0.06],"measures":{"motion":0.3464,"detail":0.1313,"edges":0.5615,"complexity":1.2014,"coverage":0.7147,"colour":0.3084,"drift":0.0597},"knobResponse":[0.1766,0.0939,0.1747,0.1431]},{"slug":"tukey-depth","title":"Tukey Depth","family":"data","round":58,"note":"점 30 개가 천천히 떠다니고, LED 마다 그 자리를 품는 반평면이 가장 적게 담는 점의 수로 칠해져 한 점씩 깊어지는 볼록 다각형이 겹겹이 서요. 8초마다 점 둘이 160 LED 밖으로 날아가면 바깥 다각형이 쐐기처럼 끌려가고 주황 평균은 11 LED 밀려나지만, 흰 고리의 터키 중앙값은 2.6 LED 만 움직여요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tukey-depth","type":"code","name":"tukey-depth","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Outliers=0..0.4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Points","min":30,"max":90},{"name":"Outliers","min":0,"max":0.4}],"start":[0,2,30,0.06],"measures":{"motion":0.2276,"detail":0.0365,"edges":0.8553,"complexity":0.1282,"coverage":0.3174,"colour":0.1699,"drift":0.0821},"knobResponse":[0.0816,0.0799,0.0558,0.0644]},{"slug":"tunnel","title":"Tunnel","family":"space","round":1,"note":"가운데서 떨어진 거리로 나누면 평평한 체크무늬가 날아 들어가는 관이 돼요.","why":"굵고 빨라요. 다만 체크무늬 터널은 데모의 단골이에요.","block":1,"ramped":false,"layer":{"id":"layer-tunnel","type":"code","name":"tunnel","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=-3..8, Twist=-1..1, Tiles=8..24","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":-3,"max":8},{"name":"Twist","min":-1,"max":1},{"name":"Tiles","min":8,"max":24}],"start":[0,2,0,8],"measures":{"motion":2.5151,"detail":0.0531,"edges":0.4689,"complexity":0.9004,"coverage":0.8993,"colour":0.486,"drift":0.3919},"knobResponse":[0.376,0.2448,0.256,0.2505]},{"slug":"turntables","title":"Turntables","family":"music","round":18,"note":"DJ 의 턴테이블 두 대가 믹서 띠를 사이에 두고 위아래로 서요. 판은 가만히 있는 방 불빛 아래에서 돌며 홈을 드러내고, DJ 는 기다리는 판을 손으로 잡았다가 킥에 맞춰 놓고 크로스페이더를 넘겨요. K2 Pitch 를 0 에 두면 플래터 테두리의 안쪽 스트로브 점이 멈춰 서요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-turntables","type":"code","name":"turntables","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Pitch=-8..8, Scratch=0..1, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Pitch","min":-8,"max":8},{"name":"Scratch","min":0,"max":1},{"name":"Light","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2259,"detail":0.0842,"edges":0.4014,"complexity":1.294,"coverage":0.7108,"colour":0.1698,"drift":0.051},"knobResponse":[0.0432,0.0432,0.0448,0.0571]},{"slug":"tutte-embedding","title":"Tutte Embedding","family":"algo","round":43,"note":"세로로 긴 볼록 다각형에 바깥 면을 박은 그물에서 안쪽 매듭이 엉킴으로 던져지고, 서로 엇갈린 실이 주황으로 켜져요. 매듭마다 이웃의 평균 자리로 옮겨 가면 3.5초쯤에 엇갈림이 다 꺼지고 면이 모두 볼록해지며, 테두리 매듭이 다각형을 따라 돌아 그물이 쉬지 않고 흘러요. K3 은 매듭을 90개에서 210개까지 늘리고, K4 는 끊었던 실을 이어 면을 다 삼각형으로 만들며, K1 을 누르면 다시 엉켜요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-tutte-embedding","type":"code","name":"tutte-embedding","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Knots=90..210, Triangles=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Knots","min":90,"max":210},{"name":"Triangles","min":0,"max":1}],"start":[0,2,90,0.06],"measures":{"motion":0.5625,"detail":0.1039,"edges":0.6844,"complexity":0.856,"coverage":0.2732,"colour":0.1519,"drift":0.1175},"knobResponse":[0.0933,0.2212,0.1823,0.1191]},{"slug":"twindragon","title":"Twindragon","family":"fractal","round":71,"note":"체크무늬로 켜진 LED 하나하나가 −1+i 진법으로 적힌 가우스 정수이고, 512 개씩 묶인 쌍둥이 용 타일이 저마다 흐린 빛깔로 패널을 덮은 채, 모든 타일에서 같은 수를 세는 밝은 창이 지나가며 자리올림마다 135도씩 돈 작은 쌍둥이 용들로 모양을 바꿔요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-twindragon","type":"code","name":"twindragon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Digits=9..12, Split=1..8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Digits","min":9,"max":12},{"name":"Split","min":1,"max":8}],"start":[0,2,9,1],"measures":{"motion":0.1054,"detail":0.3099,"edges":0.1858,"complexity":0.4006,"coverage":0.5,"colour":0.1924,"drift":0.1219},"knobResponse":[0.0816,0.1242,0.1346,0.1023]},{"slug":"twist-writhe","title":"Twist and Writhe","family":"topology","round":56,"note":"세 번 꼬인 고리 리본이 납작한 원에서 8자를 지나 키 큰 초나선으로 감기는 동안, 아래 막대에서 꼬임수 Tw 가 줄어든 만큼 뒤틀림수 Wr 가 늘어 둘의 합은 늘 같은 정수 눈금에 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-twist-writhe","type":"code","name":"twist-writhe","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Lk=3..6, Coil=3..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Lk","min":3,"max":6},{"name":"Coil","min":3,"max":6}],"start":[0,2,3,3],"measures":{"motion":0.2285,"detail":0.0397,"edges":0.775,"complexity":0.2545,"coverage":0.1469,"colour":0.1783,"drift":0.1548},"knobResponse":[0.0582,0.122,0.0593,0.0995]},{"slug":"type-mosaic","title":"Type Mosaic","family":"type","round":63,"note":"도는 네 면 프리즘에 붙은 큰 돋을새김 글자가 TYPE 을 한 자씩 넘기는데, 그림 전체가 3×5 작은 글자로 짜여 있어요. 칸마다 밝기에 맞는 잉크의 글자를 골라서 빛이 돌면 획 위의 글자가 8 과 M 에서 ? 와 : 로 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-type-mosaic","type":"code","name":"type-mosaic","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Cell=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":4},{"name":"Cell","min":0,"max":2}],"start":[0,2,0,0.06],"measures":{"motion":0.8581,"detail":0.2558,"edges":1,"complexity":0.2121,"coverage":0.2295,"colour":0.243,"drift":0.2554},"knobResponse":[0.0811,0.1865,0.2432,0.2151]},{"slug":"typewriter","title":"Typewriter","family":"type","round":18,"note":"수동 타자기가 시 두 편을 3×5 픽셀 글자로 한 자씩 쳐요. 칠 때마다 활자대가 리본을 지나 튀어 올라 글자를 찍고 종이가 한 칸 왼쪽으로 밀리며, 줄 끝에서 벨이 번쩍이면 캐리지가 오른쪽으로 돌아오며 종이를 한 줄 올려요. K4 를 돌리면 리본이 닳아 글자가 옅어지고, 빨간 반쪽으로 치는 낱말이 늘어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-typewriter","type":"code","name":"typewriter","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Spacing=1..2, Ribbon=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Spacing","min":1,"max":2},{"name":"Ribbon","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.4854,"detail":0.1156,"edges":0.8353,"complexity":0.7724,"coverage":0.9016,"colour":0.0948,"drift":0.1684},"knobResponse":[0.084,0.1398,0.167,0.0481]},{"slug":"ulam-sequence","title":"Ulam Sequence","family":"number","round":54,"note":"울람 수열을 1초에 80 항씩 세면서 코드가 스스로 찾은 숨은 진동수 α 로 각 항을 원에 감아 가로로 펼치면, 항들은 cos(αa) \u003c 0 인 절반에만 두 봉우리로 쌓이고 다른 절반은 분홍으로 표시한 2, 3, 47, 69 넷만 남긴 채 비어요. 새 항은 아래 더미로 떨어지고, K3 은 씨앗을 바꾸고 K4 는 α 를 비틀어 띠를 감아 버려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ulam-sequence","type":"code","name":"ulam-sequence","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Seed=0..5, Detune=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Seed","min":0,"max":5},{"name":"Detune","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2015,"detail":0.0673,"edges":0.8089,"complexity":0.3845,"coverage":0.1525,"colour":0.1636,"drift":0.0156},"knobResponse":[0.0546,0.0534,0.101,0.1704]},{"slug":"universal-cover","title":"Universal Cover","family":"topology","round":55,"note":"아래 8자 고리를 점이 한 걸음에 한 바퀴씩 도는 동안 위의 네 갈래 나무에서는 그 올림이 같은 글자의 변을 걷고, 나무는 걸음마다 올림을 새 뿌리로 삼아 미끄러지며 다시 자라요. 뿌리까지 줄인 낱말은 빛나는 길과 블록 띠로 남아 걸음마다 반 글자씩 길어져요. K3 은 마지막 글자를 되돌리는 확률(0.25~0.85), K4 는 그리는 나무의 단 수(1.5~6.5)예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-universal-cover","type":"code","name":"universal-cover","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Return=0.25..0.85, Depth=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Return","min":0.25,"max":0.85},{"name":"Depth","min":-1,"max":1}],"start":[0,2,0.25,0.06],"measures":{"motion":1.0419,"detail":0.0684,"edges":0.6889,"complexity":0.5487,"coverage":0.1908,"colour":0.182,"drift":0.0463},"knobResponse":[0.0471,0.0708,0.0595,0.0593]},{"slug":"v-cut-letters","title":"V-Cut Letters","family":"type","round":77,"note":"V 끌로 돌에 판 LVX 세 글자가 세로로 서고, 낮은 빛이 12초에 한 바퀴 돌며 홈의 평평한 벽을 하나씩 밝혔다 그늘에 넣어 글자가 빛으로만 읽혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-v-cut-letters","type":"code","name":"v-cut-letters","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wall=30..70, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wall","min":30,"max":70},{"name":"Light","min":0,"max":1}],"start":[0,2,30,0.06],"measures":{"motion":0.0335,"detail":0.0336,"edges":0.3082,"complexity":1.2827,"coverage":1,"colour":0.072,"drift":0.0719},"knobResponse":[0.0507,0.0692,0.0377,0.1383]},{"slug":"vampire-coffin","title":"Vampire Coffin","family":"halloween","round":46,"note":"납골당에 선 관 뚜껑이 삐걱 열려 초록 안개와 빨간 눈을 내보이다 활짝 열리며 박쥐 떼를 쏟아내고 쾅 닫혀요. K3 은 박쥐 수, K4 는 안개 양이고, K1 을 누르면 바로 열려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-vampire-coffin","type":"code","name":"vampire-coffin","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Bats=24..72, Mist=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bats","min":24,"max":72},{"name":"Mist","min":0,"max":1}],"start":[0,2,24,0.06],"measures":{"motion":0.3318,"detail":0.0475,"edges":0.2821,"complexity":0.5932,"coverage":0.8711,"colour":0.1969,"drift":0.1254},"knobResponse":[0.0516,0.0994,0.0347,0.0448]},{"slug":"veech-octagon","title":"Veech Octagon","family":"topology","round":62,"note":"위의 정팔각형과 아래의 이중 정오각형 위를 직선 넷씩이 같은 방향으로 달리다가, 한 변으로 나가면 그 변에 붙은 변으로 다시 들어와요. 대부분의 방향에서는 선이 면을 고르게 채우고, K3 이 주기 방향에 닿으면 선이 닫히며 면이 하늘색과 보라 원기둥 둘로 갈라져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-veech-octagon","type":"code","name":"veech-octagon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Direction=45..135, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Direction","min":45,"max":135},{"name":"Trail","min":0,"max":1}],"start":[0,2,45,0.06],"measures":{"motion":0.054,"detail":0.0773,"edges":0.6109,"complexity":0.8473,"coverage":0.5614,"colour":0.1756,"drift":0.0143},"knobResponse":[0.1008,0.0657,0.1241,0.0965]},{"slug":"veiled-lady","title":"Veiled Lady","family":"fungi","round":20,"note":"동트기 전 열대 숲 바닥을 손전등으로 비춘 망태버섯 타임랩스예요. 낙엽 속 흰 알이 터져 대가 패널 높이만큼 솟고, 올리브색 갓 밑에서 흰 레이스 망사가 낙엽 가까이까지 내려와요. 파리가 꼬였던 버섯이 시들어 쓰러지면 옆에서 다음 알이 부풀고, K1 을 돌리면 손전등이 UV 로 바뀌어 망사가 청록으로 빛나요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-veiled-lady","type":"code","name":"veiled-lady","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Torch=0..1, Speed=0.2..3, Veil=0..1, Rain=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Torch","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Veil","min":0,"max":1},{"name":"Rain","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1497,"detail":0.0791,"edges":0.3662,"complexity":1.7099,"coverage":0.5698,"colour":0.1244,"drift":0.0576},"knobResponse":[0.0782,0.0485,0.0482,0.0673]},{"slug":"velvet-nap","title":"Velvet Nap","family":"cosmetic","round":34,"note":"판 전체가 에메랄드 무광 벨벳이고, 보이지 않는 손끝 둘이 천천히 글씨를 쓰듯 결을 쓸어요. 빛 쪽으로 밀린 결은 짙고 깊은 색으로, 빛을 따라 누운 결은 옅은 은빛으로 남아 서로 겹쳐 덮이고, 7초마다 손바닥이 22 LED 너비 띠를 위에서 아래로 쓸어 결을 한 방향으로 눕혀요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-velvet-nap","type":"code","name":"velvet-nap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Width=0..1, Pile=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Width","min":0,"max":1},{"name":"Pile","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0497,"detail":0.0465,"edges":0.1077,"complexity":1.9034,"coverage":1,"colour":0.202,"drift":0.1599},"knobResponse":[0.6367,0.0934,0.1478,0.2049]},{"slug":"voderberg-tiling","title":"Voderberg Tiling","family":"cells","round":59,"note":"꼭지각 12도의 가는 삼각형에서 나온 보데르베르크의 9각 타일 두 장이 가운데서 한 장을 감싸고, 다시 두 장을 감싼 뒤, 같은 타일이 두 팔 나선으로 한 장씩 자라 패널을 덮어요. 화면이 물러나면 나선 전체가 돌고 빛의 물결이 팔을 따라 밖으로 흘러요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-voderberg-tiling","type":"code","name":"voderberg-tiling","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Size=16..44, Arms=2..6","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Size","min":16,"max":44},{"name":"Arms","min":2,"max":6}],"start":[0,2,16,2],"measures":{"motion":1.9356,"detail":0.1452,"edges":0.7012,"complexity":1.7048,"coverage":0.8497,"colour":0.434,"drift":0.3913},"knobResponse":[0.222,0.3186,0.2625,0.2904]},{"slug":"void-and-cluster","title":"Void and Cluster","family":"noise","round":62,"note":"백색 잡음으로 뿌린 점 1,516개가 가장 빽빽한 뭉치에서 가장 큰 빈자리로 하나씩 옮겨 가며 고르게 퍼져요. 다 퍼진 점에는 순위가 매겨지고, 문턱이 내려갔다 오르면 점이 순위대로 떠났다 돌아와요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-void-and-cluster","type":"code","name":"void-and-cluster","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Density=-1..1, Sigma=1.5..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Density","min":-1,"max":1},{"name":"Sigma","min":1.5,"max":4}],"start":[0,2,0,1.5],"measures":{"motion":0.1264,"detail":0.3309,"edges":0.9985,"complexity":0.4769,"coverage":0.1767,"colour":0.2092,"drift":0.1884},"knobResponse":[0.1082,0.1136,0.1954,0.1104]},{"slug":"voronoi","title":"Voronoi","family":"cells","round":2,"note":"흐름을 타고 도는 씨앗마다 가장 가까운 LED 를 제 유리 색으로 칠하고, 조각 사이에 1 LED 납선이 서요. K4 로 거리를 재는 법을 바꾸면 조각 가운데 둥근 유리가 원에서 마름모를 지나 정사각형이 돼요.","why":"색 칸이 쉬지 않고 갈라지고 합쳐져요. 움직임 2.10, 가장자리 1.00, 복잡도 0.21 로 프리셋의 잰 값과 거의 같아요.","block":0,"ramped":false,"layer":{"id":"layer-voronoi","type":"code","name":"voronoi","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..6, Cells=20..60, Metric=0..2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":6},{"name":"Cells","min":20,"max":60},{"name":"Metric","min":0,"max":2}],"start":[0,2,20,0.06],"measures":{"motion":2.0975,"detail":0.1621,"edges":1,"complexity":0.2058,"coverage":0.8378,"colour":0.5986,"drift":0.1196},"knobResponse":[0.4827,0.3489,0.3517,0.1477]},{"slug":"vortex-sheet","title":"Vortex Sheet","family":"sim","round":55,"note":"패널을 세로로 가르는 와류 시트를 사이에 두고 왼쪽 물은 아래로, 오른쪽 물은 위로 흐르면, 시트의 작은 물결이 자라 두 갈래 나선으로 말려 들며 청록과 보라 두 물을 점점 얇은 겹으로 감아 넣어요. K3 은 크라스니의 덩이 δ(0.15~0.5)라 작을수록 나선이 촘촘히 감기고, K4 는 패널에 쌓는 파장 수(1~4)예요. 단추를 누르면 새 물결로 다시 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-vortex-sheet","type":"code","name":"vortex-sheet","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Blob=0.15..0.5, Waves=1..4","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Blob","min":0.15,"max":0.5},{"name":"Waves","min":1,"max":4}],"start":[0,2,0.15,1],"measures":{"motion":0.6705,"detail":0.0853,"edges":0.755,"complexity":0.7161,"coverage":1,"colour":0.2081,"drift":0.0897},"knobResponse":[0.1768,0.1002,0.07,0.0943]},{"slug":"voss-dice","title":"Voss Dice","family":"noise","round":73,"note":"이진 카운터의 비트가 바뀐 주사위만 다시 굴려 1/f 잡음을 만들고, 그 합을 백색 잡음과 갈색 잡음 사이에 나란히 흘려 내려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-voss-dice","type":"code","name":"voss-dice","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Dice=4..8, Hold=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Dice","min":4,"max":8},{"name":"Hold","min":-1,"max":1}],"start":[0,2,4,0.06],"measures":{"motion":0.9587,"detail":0.0834,"edges":0.759,"complexity":0.184,"coverage":0.2937,"colour":0.125,"drift":0.0744},"knobResponse":[0.0484,0.1033,0.1412,0.0956]},{"slug":"vuza-canon","title":"Vuza Canon","family":"rhythm","round":55,"note":"72박 주기에서 열두 성부가 같은 여섯 음 리듬 {0, 8, 16, 18, 26, 34} 를 저마다 다른 박에서 시작해 한 줄에 한 박씩 위로 흘러가고, 어느 줄에도 음이 꼭 하나만 켜져서 박을 하나도 겹치거나 빼지 않고 시간을 덮어요. 지금 줄에 닿는 음은 하얗게 번쩍이고 주기가 바뀌는 줄에는 점선이 그어져요. K3 은 캐넌을 바꿔서 역할을 바꾼 여섯 성부, 24박마다 되풀이하는 타일링, 계단 하나로 가는 가장 단순한 타일링을 보여 주고, K4 는 한 성부를 골라 그 음마다 패널을 가로지르는 선을 그어 리듬을 자처럼 읽게 해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-vuza-canon","type":"code","name":"vuza-canon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Canon=0..3, Focus=0..12","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Canon","min":0,"max":3},{"name":"Focus","min":0,"max":12}],"start":[0,2,0,0.06],"measures":{"motion":1.0428,"detail":0.0999,"edges":0.3597,"complexity":0.1,"coverage":0.2434,"colour":0.188,"drift":0.0816},"knobResponse":[0.0402,0.0726,0.1195,0.0412]},{"slug":"waggle-dance","title":"Waggle Dance","family":"insect","round":24,"note":"관찰 벌통의 벌집 한 장이 패널 높이로 서요. 위에 봉한 꿀, 그 아래 여덟 색 꽃가루 띠와 애벌레 방이 있고, 벌 여든 마리가 기어 다녀요. 아래쪽 빈 벌집에서는 꽃가루를 단 벌이 몸을 흔들며 8 자 춤을 추고 따르는 벌들이 둘러서요. 춤의 각도가 해에서 본 꽃밭의 방향이라 K4 를 돌리면 모든 춤이 같이 돌아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-waggle-dance","type":"code","name":"waggle-dance","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Bees=80..240, Sun=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Bees","min":80,"max":240},{"name":"Sun","min":-1,"max":1}],"start":[0,2,80,0.06],"measures":{"motion":0.2561,"detail":0.1412,"edges":0.4465,"complexity":2.5302,"coverage":0.7323,"colour":0.2225,"drift":0.0504},"knobResponse":[0.1684,0.0666,0.1239,0.0576]},{"slug":"walsh-functions","title":"Walsh Functions","family":"wave","round":67,"note":"위에는 ±1 로만 된 2차원 Walsh 함수 64장의 표가 서고, 아래 추상 그림은 그 계수를 지그재그로 하나씩 더하며 8×8 블록에서 또렷해지는 동안 더해지는 타일이 위에서 빛나요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-walsh-functions","type":"code","name":"walsh-functions","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Order=0..2, Drop=0..63","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Order","min":0,"max":2},{"name":"Drop","min":0,"max":63}],"start":[0,2,0,0.06],"measures":{"motion":0.0796,"detail":0.1162,"edges":0.8289,"complexity":0.6061,"coverage":0.7721,"colour":0.2904,"drift":0.1251},"knobResponse":[0.1921,0.0706,0.0866,0.0779]},{"slug":"warp","title":"Warp","family":"space","round":15,"note":"별 사이를 워프로 날아요. 별은 앞쪽에서 얼음빛 파랑이고, 옆으로 지나가며 자홍 줄로 늘어나요. K1 을 누르면 워프에서 빠져 멈췄다가 흰 빛과 함께 다시 들어가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-warp","type":"code","name":"warp","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Warp=0.2..4, Stars=420..1400, Steer=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Warp","min":0.2,"max":4},{"name":"Stars","min":420,"max":1400},{"name":"Steer","min":-1,"max":1}],"start":[0,2,420,0.06],"measures":{"motion":2.077,"detail":0.0623,"edges":0.3496,"complexity":0.991,"coverage":0.2025,"colour":0.1354,"drift":0.0642},"knobResponse":[0.0455,0.0994,0.1476,0.0712]},{"slug":"waterfall","title":"Waterfall","family":"weather","round":14,"note":"강이 벼랑 끝을 넘어 패널 높이를 다 떨어져 소에 닿아요. 벼랑 끝에서 청록 유리 같던 물은 떨어지며 하얘지고, 소에서 오르는 안개에 무지개 한 토막이 서요. K3 바람을 끝까지 돌리면 돌풍이 물줄기를 찢어 물보라로 날려 올리고, K1 을 누르면 통나무 하나가 벼랑 끝을 넘어와요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-waterfall","type":"code","name":"waterfall","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Wind=-1..1, Spate=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Wind","min":-1,"max":1},{"name":"Spate","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.6549,"detail":0.0595,"edges":0.3161,"complexity":1.514,"coverage":0.9639,"colour":0.146,"drift":0.0724},"knobResponse":[0.0442,0.112,0.1828,0.287]},{"slug":"weaire-phelan","title":"Weaire-Phelan","family":"space","round":54,"note":"A15 격자의 보로노이 칸 48개로 쌓은 키 큰 거품 기둥이 천천히 돌며, 청록 오각형만 두른 십이면체와 금색 육각형 둘을 낀 십사면체가 흰 모서리 아래 맞물린 위어-펠런 구조를 보여 주는데, K3 을 올리면 기둥 위쪽부터 같은 부피의 켈빈 깎은 팔면체가 보라 정사각형을 달고 들어서고 K4 는 칸을 제 자리 쪽으로 줄여 틈을 벌려요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-weaire-phelan","type":"code","name":"weaire-phelan","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Kelvin=0..1, Gap=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Kelvin","min":0,"max":1},{"name":"Gap","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5969,"detail":0.0787,"edges":0.8466,"complexity":0.5443,"coverage":0.5818,"colour":0.2374,"drift":0.0597},"knobResponse":[0.118,0.1957,0.207,0.2228]},{"slug":"weaver","title":"Weaver","family":"bird","round":22,"note":"강 위로 뻗은 아카시아 가지 끝에서 수컷 마을베짜기새가 둥지를 지어요. 갈대 잎을 찢어 문 초록 띠를 벽에 꿰어 당기면 둥지가 고리에서 둥근 방으로, 다시 아래로 열린 입구로 한 가닥씩 자라고, 묵은 띠는 짚 색으로 바래요. K1 을 누르면 암컷이 날아와 둥지를 살피고, 다 지은 둥지가 퇴짜를 맞으면 수컷이 끊어 강에 떨어뜨리고 새 고리부터 다시 지어요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-weaver","type":"code","name":"weaver","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Plumage=0..2, Speed=0.2..3, Nests=3..9, Sky=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Plumage","min":0,"max":2},{"name":"Speed","min":0.2,"max":3},{"name":"Nests","min":3,"max":9},{"name":"Sky","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.1278,"detail":0.0716,"edges":0.3689,"complexity":2.2916,"coverage":0.9985,"colour":0.2367,"drift":0.0436},"knobResponse":[0.0466,0.0543,0.0568,0.2018]},{"slug":"web-tremor","title":"Web Tremor","family":"halloween","round":47,"note":"달 아래 키 큰 거미줄에 나방이 걸려 버둥댈 때마다 빛이 실을 타고 세로줄로는 빠르게, 나선으로는 느리게 퍼지고, 허브의 거미가 달려가 나방을 흰 고치로 감고 돌아와요. K3 은 나방의 몸부림, K4 는 그물이 처지는 정도예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-web-tremor","type":"code","name":"web-tremor","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Struggle=0..1, Sag=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Struggle","min":0,"max":1},{"name":"Sag","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.5269,"detail":0.0644,"edges":0.5533,"complexity":0.4866,"coverage":0.6885,"colour":0.1269,"drift":0.0951},"knobResponse":[0.072,0.0714,0.0623,0.0732]},{"slug":"werewolf","title":"Werewolf","family":"halloween","round":49,"note":"구름이 걷힌 보름달 앞 바위 위에서 남자가 등을 굽히고 팔이 앞다리로 늘어나 늑대가 되어 울부짖고, 구름이 다시 달을 덮으면 남자로 돌아와요. K3 은 구름, K4 는 달의 크기예요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-werewolf","type":"code","name":"werewolf","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Moon=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Clouds","min":0,"max":1},{"name":"Moon","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1085,"detail":0.038,"edges":0.3264,"complexity":0.2377,"coverage":0.6294,"colour":0.2043,"drift":0.065},"knobResponse":[0.0663,0.0874,0.0692,0.1205]},{"slug":"wheel-cypher","title":"Wheel Cypher","family":"type","round":80,"note":"윤이 나는 원판 25 장을 쌓은 원통에서 원판이 위에서부터 하나씩 돌아 25 글자 평문이 호박색 한 줄로 서고, 몇 칸 옆 줄이 보라색 암호문으로 켜지며 양옆 쪽지에 두 글이 적혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wheel-cypher","type":"code","name":"wheel-cypher","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Message=0..5, Line=1..5","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Message","min":0,"max":5},{"name":"Line","min":1,"max":5}],"start":[0,2,0,1],"measures":{"motion":0.3465,"detail":0.2066,"edges":0.4818,"complexity":2.4715,"coverage":0.9503,"colour":0.1051,"drift":0.0748},"knobResponse":[0.0909,0.1093,0.0749,0.1867]},{"slug":"whipped-soap","title":"Whipped Soap","family":"cosmetic","round":36,"note":"보이지 않는 별 깍지가 휘핑 바디 솝을 한 송이씩 짜는데, 한 바퀴가 앞 바퀴에 반쯤 얹히며 뾰족하게 솟아요. 쟁반이 두 칸 네 줄로 차면 긁개가 거품을 말아 아래로 밀어 내요. K3 은 깍지의 별 꼭짓점 수라서 굵은 골 두세 줄이 가는 골 네다섯 줄로 바뀌고, K1 을 누르면 쟁반을 바로 밀어요.","why":"","block":4,"ramped":false,"layer":{"id":"layer-whipped-soap","type":"code","name":"whipped-soap","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ridges=5..10, Swirl=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ridges","min":5,"max":10},{"name":"Swirl","min":-1,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.0309,"detail":0.0537,"edges":0.3642,"complexity":1.1069,"coverage":0.9764,"colour":0.1274,"drift":0.0699},"knobResponse":[0.1534,0.0635,0.0442,0.1089]},{"slug":"whitney-graustein","title":"Whitney-Graustein","family":"topology","round":69,"note":"접선 방향을 무지개빛으로 두른 닫힌 곡선이 멈추지 않고 모양을 바꾸며 감은 수대로 칸을 칠하고, Turns 를 돌리면 작은 고리가 뾰족점으로 조여 사라지거나 뾰족점에서 고리가 태어나며 위 다이얼의 회전수가 바뀌어요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-whitney-graustein","type":"code","name":"whitney-graustein","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Turns=-2..3, Wobble=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Turns","min":-2,"max":3},{"name":"Wobble","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.2309,"detail":0.0449,"edges":1,"complexity":0.1622,"coverage":0.4121,"colour":0.1865,"drift":0.0946},"knobResponse":[0.084,0.0914,0.1103,0.0535]},{"slug":"wigner-cat","title":"Wigner Cat","family":"wave","round":59,"note":"켜 매질을 지나는 결맞은 빛의 위그너 함수가 위상 평면에서 돌며 2, 3, 4덩이 고양이 상태로 갈라졌다 반대쪽 한 덩이로 모여요. 양수는 장밋빛, 음수는 하늘색이라 덩이 사이 간섭 무늬가 두 색으로 번갈아 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wigner-cat","type":"code","name":"wigner-cat","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Decoherence=0..1, Amplitude=2..3.2","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Decoherence","min":0,"max":1},{"name":"Amplitude","min":2,"max":3.2}],"start":[0,2,0,2],"measures":{"motion":0.2173,"detail":0.0208,"edges":0.1215,"complexity":0.9875,"coverage":0.2578,"colour":0.1028,"drift":0.0519},"knobResponse":[0.0455,0.0544,0.1018,0.0382]},{"slug":"wilkinson-polynomial","title":"Wilkinson's Polynomial","family":"algo","round":66,"note":"(x − 1)…(x − 20) 의 근 스무 개가 세로 실수축에 구슬로 서고, x¹⁹ 계수를 2⁻²³ 너머까지 건드리면 위쪽 열 개가 둘씩 만나 옆으로 날아가며 분홍 활을 남겨요. 계수를 살짝 흔든 다항식들의 근이 둘레에 반짝이는 성운을 이뤄요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wilkinson-polynomial","type":"code","name":"wilkinson-polynomial","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Phase=0..1, Cloud=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Phase","min":0,"max":1},{"name":"Cloud","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.4256,"detail":0.1031,"edges":0.3715,"complexity":2.203,"coverage":0.2825,"colour":0.1357,"drift":0.0676},"knobResponse":[0.0449,0.0948,0.0734,0.0897]},{"slug":"wireworld","title":"Wireworld","family":"automata","round":16,"note":"구리선 회로를 전자가 파란 머리와 주황 꼬리로 달려요. 둘레 12, 18, 24, 30칸 클록 넷의 신호가 다이오드와 지연선을 지나 XOR 과 OR 게이트에서 만나고, 아래 램프 셋이 그 답을 깜박여요. K1 을 누르면 네 줄에 전자 여섯 개씩이 박자를 맞춰 들어가요.","why":"","block":5,"ramped":false,"layer":{"id":"layer-wireworld","type":"code","name":"wireworld","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Palette=0..3, Speed=0..4, Pulses=1..3, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Palette","min":0,"max":3},{"name":"Speed","min":0,"max":4},{"name":"Pulses","min":1,"max":3},{"name":"Glow","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.2605,"detail":0.0895,"edges":0.7694,"complexity":0.461,"coverage":0.3111,"colour":0.2355,"drift":0.0855},"knobResponse":[0.0911,0.0637,0.0514,0.0736]},{"slug":"witch-moon","title":"Witch Moon","family":"halloween","round":42,"note":"보랏빛 밤하늘 위쪽에 주황 보름달이 크게 떠 있고, 가장자리가 달빛에 은빛으로 빛나는 구름이 그 앞을 흘러가요. 아래에서는 앙상한 나뭇가지가 흔들리고, 빗자루를 탄 마녀가 초록 불티를 흘리며 3.7초에 달 한가운데를 지나가요. K4 를 올리면 마녀가 넷까지 V 자로 날아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-witch-moon","type":"code","name":"witch-moon","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Flights=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Clouds","min":0,"max":1},{"name":"Flights","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1513,"detail":0.0426,"edges":0.2622,"complexity":0.7664,"coverage":0.7549,"colour":0.2827,"drift":0.0541},"knobResponse":[0.0817,0.0492,0.0566,0.0225]},{"slug":"wongoji","title":"Wongoji","family":"type","round":64,"note":"윤동주의 「서시」를 펜이 세로 원고지에 한 획씩 써요. 한글은 패턴이 자모에서 조합한 9×11 글꼴이고, 칸은 위에서 아래로, 줄은 오른쪽에서 왼쪽으로 차서 한 장이 차면 쪽이 넘어가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-wongoji","type":"code","name":"wongoji","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Paper=0..1, Speed=0.2..3, Brush=0..1, Hand=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Paper","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Brush","min":0,"max":1},{"name":"Hand","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.3254,"detail":0.1342,"edges":0.9882,"complexity":0.1178,"coverage":0.2372,"colour":0.1805,"drift":0.0963},"knobResponse":[0.7702,0.03,0.0493,0.0454]},{"slug":"woodpecker","title":"Woodpecker","family":"bird","round":21,"note":"새벽 숲의 자작나무 줄기가 128줄을 다 쓰고, 오색딱따구리가 뻣뻣한 꽁지로 버티며 껑충껑충 오르다 멈춰 머리가 흐려지도록 두드려 부스러기를 튀기고 구멍을 내요. 꼭대기에 닿으면 물결치듯 날아 밑동으로 내려가 다시 오르고, K1 을 누르면 다음 걸음 뒤에 바로 두드려요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-woodpecker","type":"code","name":"woodpecker","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Tree=0..2, Speed=0.2..3, Birds=1..4, Light=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Tree","min":0,"max":2},{"name":"Speed","min":0.2,"max":3},{"name":"Birds","min":1,"max":4},{"name":"Light","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.092,"detail":0.0823,"edges":0.3471,"complexity":2.5826,"coverage":0.9376,"colour":0.1398,"drift":0.0454},"knobResponse":[0.1005,0.0437,0.0473,0.1346]},{"slug":"word-bokeh","title":"Word Bokeh","family":"type","round":78,"note":"낱말 꼴로 뚫은 조리개 너머의 빛 스물하나가 초점에서 벗어난 만큼 그 낱말로 부풀고, 초점면 뒤의 빛은 바로, 앞의 빛은 뒤집혀 서요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-word-bokeh","type":"code","name":"word-bokeh","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Stop=1.4..2.8","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Word","min":0,"max":1},{"name":"Stop","min":1.4,"max":2.8}],"start":[0,2,0,1.4],"measures":{"motion":0.4117,"detail":0.1019,"edges":0.8295,"complexity":0.4245,"coverage":0.2344,"colour":0.3641,"drift":0.3684},"knobResponse":[0.2826,0.2726,0.225,0.2398]},{"slug":"word-ladder","title":"Word Ladder","family":"type","round":63,"note":"루이스 캐럴의 Doublets 사다리가 HEAD 에서 TAIL 까지 128줄을 내려가요. 가로대마다 한 글자만 획을 따라 흘러 바뀌고, 바뀐 자리가 흰빛으로 켜져 사다리를 따라 지그재그로 내려가요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-word-ladder","type":"code","name":"word-ladder","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Ladder=0..11, Weight=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Ladder","min":0,"max":11},{"name":"Weight","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1293,"detail":0.0767,"edges":0.7991,"complexity":0.4368,"coverage":0.2688,"colour":0.1738,"drift":0.1227},"knobResponse":[0.0327,0.0584,0.0765,0.1131]},{"slug":"word-search","title":"Word Search","family":"type","round":82,"note":"10×16 칸 대문자 격자에 숨은 타이포 낱말 열둘을 흰 커서가 칸마다 여덟 방향으로 더듬어 찾고, 찾은 낱말마다 제 색 캡슐이 둘러져 남다가 다 찾으면 격자가 흩어지고 새 판이 찍혀요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-word-search","type":"code","name":"word-search","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Puzzle=0..5, Fill=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Puzzle","min":0,"max":5},{"name":"Fill","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0396,"detail":0.2078,"edges":0.9832,"complexity":0.159,"coverage":0.3271,"colour":0.1389,"drift":0.0359},"knobResponse":[0.0508,0.1244,0.1387,0.0828]},{"slug":"wythoff-nim","title":"Wythoff Nim","family":"algo","round":28,"note":"위토프 게임의 스프라그-그런디 값 표를 모서리로 세웠어요. 지는 자리(값 0)는 황금비 두 줄을 따라 금빛이고, 값 0, 1, 2 가 차례로 쓸고 지나가며 저마다의 두 줄에서 번쩍였다 표로 가라앉아요. 누르면 흰 말이 떨어져 이기는 수로 모서리까지 게임을 해요.","why":"","block":3,"ramped":false,"layer":{"id":"layer-wythoff-nim","type":"code","name":"wythoff-nim","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Zoom=1..4, Glow=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Zoom","min":1,"max":4},{"name":"Glow","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.0944,"detail":0.0878,"edges":0.5187,"complexity":1.051,"coverage":0.875,"colour":0.3599,"drift":0.0676},"knobResponse":[0.2558,0.0431,0.2303,0.1714]},{"slug":"yard-sale","title":"Yard-Sale Model","family":"data","round":62,"note":"공정한 동전으로 거래하는 64명의 재산이 위의 로렌츠 곡선을 대각선에서 처지게 하고, 정렬한 막대를 한 사람에게 몰아요. 맨 아래의 지니 계수는 1 을 향해 오르다가 K4 로 세금을 올리면 그 아래에서 멈춰요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-yard-sale","type":"code","name":"yard-sale","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Fraction=0.2..0.6, Tax=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Fraction","min":0.2,"max":0.6},{"name":"Tax","min":0,"max":1}],"start":[0,2,0.2,0.06],"measures":{"motion":0.0729,"detail":0.0329,"edges":0.637,"complexity":0.1293,"coverage":0.3962,"colour":0.2042,"drift":0.071},"knobResponse":[0.0929,0.0456,0.0669,0.0505]},{"slug":"ybc-7289","title":"YBC 7289","family":"type","round":81,"note":"등불 아래 점토판 YBC 7289 의 정사각형과 쐐기 숫자가 서고, 아래 점토에 1;30 에서 시작한 평균 셈이 한 줄씩 눌려 써지며 √2 와 맞는 자리가 청록으로 켜져요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-ybc-7289","type":"code","name":"ybc-7289","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Lamp=0..1, Speed=0.2..3, Start=0..5, Places=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Lamp","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Start","min":0,"max":5},{"name":"Places","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.0273,"detail":0.0548,"edges":0.5828,"complexity":0.6551,"coverage":0.9775,"colour":0.1714,"drift":0.0231},"knobResponse":[0.1016,0.0468,0.044,0.0315]},{"slug":"zagier-windmill","title":"Zagier's Windmills","family":"number","round":57,"note":"소수 p 가 p 칸짜리 풍차로 서요. 가운데 정사각형 둘레에 직사각형 날개 넷이 돌아가며 붙고, 자기에의 사상은 바깥선을 그대로 둔 채 가운데 정사각형을 새로 잘라 내고, 날개 바꾸기는 날개마다 4분의 1 바퀴 돌려 눕혀요. 두 사상을 번갈아 밟은 걸음은 날개가 정사각형인 풍차에서 멈추고, 그 풍차가 넓이를 더하면 p 인 두 정사각형으로 미끄러져 모이며, 아래 로그 눈금의 (y, z) 평면에는 p 의 풍차가 모두 제 쌍곡선 위의 점으로 찍히고 걸어온 지그재그 길이 남아요. K3 은 13부터 113까지 순환을 여는 소수이고, K4 는 풍차를 1~2.5배로 키워요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zagier-windmill","type":"code","name":"zagier-windmill","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Prime=1..13, Zoom=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Prime","min":1,"max":13},{"name":"Zoom","min":0,"max":1}],"start":[0,2,1,0.06],"measures":{"motion":0.1077,"detail":0.0489,"edges":0.6146,"complexity":0.37,"coverage":0.3927,"colour":0.1564,"drift":0.1221},"knobResponse":[0.0825,0.0913,0.109,0.1131]},{"slug":"zeldovich-pancakes","title":"Zeldovich Pancakes","family":"space","round":40,"note":"입자 3만 2768개가 젤도비치 근사로 움직여, 고른 안개에서 얇은 팬케이크가 켜지고 벽과 실과 매듭으로 된 우주 거대 구조가 돼요. 벽에 삼켜진 물질은 장밋빛이라 첫 팬케이크가 D = 1/max λ1 에서 켜지는 것이 보이고, K4 를 올리면 만난 흐름이 붙지 않고 지나가 매듭이 마름모로 부풀어요. K1 을 누르면 새 무작위 퍼텐셜이 바로 스며 들어요.","why":"빛나는 그물이 좋은데 아주 느리고 점점 흐려져요(움직임 0.05).","block":1,"ramped":false,"layer":{"id":"layer-zeldovich-pancakes","type":"code","name":"zeldovich-pancakes","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Scale=1.8..3.4, Cross=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Scale","min":1.8,"max":3.4},{"name":"Cross","min":0,"max":1}],"start":[0,2,1.8,0.06],"measures":{"motion":0.054,"detail":0.0516,"edges":0.1927,"complexity":1.591,"coverage":0.7338,"colour":0.1524,"drift":0.1057},"knobResponse":[0.115,0.0501,0.0952,0.0369]},{"slug":"zen-garden","title":"Zen Garden","family":"line","round":18,"note":"곧장 내려다본 마른 돌 정원이에요. 갈퀴 자국이 이끼 두른 돌 둘레에서 고리로 휘고, 갈퀴가 15줄 띠씩 줄을 다시 그으며 떨어진 단풍잎을 거둬 가요. K1 을 돌리면 아침 해가 저녁 해로 옮겨 가며 돌 그림자와 고리의 밝은 쪽이 따라 돌아요.","why":"","block":2,"ramped":false,"layer":{"id":"layer-zen-garden","type":"code","name":"zen-garden","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Light=0..1, Speed=0.2..3, Stones=3..5, Wind=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Light","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Stones","min":3,"max":5},{"name":"Wind","min":0,"max":1}],"start":[0,2,3,0.06],"measures":{"motion":0.0392,"detail":0.2481,"edges":0.4637,"complexity":1.6255,"coverage":0.96,"colour":0.1203,"drift":0.0759},"knobResponse":[0.1756,0.245,0.2327,0.2481]},{"slug":"zermelo-navigation","title":"Zermelo Navigation","family":"line","round":66,"note":"바닥 항구에서 0.5초마다 배가 지금까지 닿을 수 있는 곳의 앞선이 떠나, 소용돌이나 제트 물살에 휘고 접히며 패널 끝까지 올라가요. 가장 빠른 길 여섯 줄에 흰 점이 실려 가고, 물이 배보다 빨리 들어오는 가장자리에는 끝내 닿지 못하는 그림자가 빗금으로 남아요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zermelo-navigation","type":"code","name":"zermelo-navigation","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Current=0..2.5, Shape=0..1, Harbour=-1..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Current","min":0,"max":2.5},{"name":"Shape","min":0,"max":1},{"name":"Harbour","min":-1,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":2.4524,"detail":0.1348,"edges":0.6115,"complexity":1.5311,"coverage":0.5705,"colour":0.2766,"drift":0.059},"knobResponse":[0.1395,0.1397,0.1485,0.1091]},{"slug":"zeta-loops","title":"Zeta Loops","family":"line","round":29,"note":"리만 제타 함수를 임계선 위에서 t 를 올리며 그려요. 실수축이 패널 위로 서 있고, 밝은 머리가 고리를 돌다가 영점마다 원점을 정확히 지나며 원점에서 고리가 퍼져요. K3 으로 임계선에서 벗어나면 고리가 원점을 비껴가고, K1 을 누르면 머리가 다음 영점까지 달려가요.","why":"선 하나가 어두운 판에 작아요(채움 0.17).","block":1,"ramped":false,"layer":{"id":"layer-zeta-loops","type":"code","name":"zeta-loops","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Sigma=-0.25..0.25, Trail=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Sigma","min":-0.25,"max":0.25},{"name":"Trail","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":0.1356,"detail":0.0457,"edges":0.4182,"complexity":0.8175,"coverage":0.1691,"colour":0.1955,"drift":0.0901},"knobResponse":[0.0373,0.0539,0.0648,0.0438]},{"slug":"zombie-shamble","title":"Zombie Shamble","family":"halloween","round":51,"note":"지평선 너머 독한 초록 빛을 등진 좀비 떼가 안개 낀 시골길을 비틀대며 다가오고, 가장 가까운 것은 패널을 채운 뒤 안개 속으로 부서져요. K3 은 좀비 수, K4 는 안개의 높이와 짙기이고, 단추를 누르면 모든 고개가 들려 초록 눈으로 우리를 봐요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zombie-shamble","type":"code","name":"zombie-shamble","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Horde=5..18, Fog=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Horde","min":5,"max":18},{"name":"Fog","min":0,"max":1}],"start":[0,2,5,0.06],"measures":{"motion":0.2236,"detail":0.1201,"edges":0.0317,"complexity":2.0049,"coverage":0.9416,"colour":0.1449,"drift":0.077},"knobResponse":[0.15,0.0416,0.0584,0.0897]},{"slug":"zonal-jets","title":"Zonal Jets","family":"wave","round":52,"note":"북쪽으로 갈수록 코리올리 힘이 커지는 판에서 잔 소용돌이를 흔들면 에너지가 큰 규모로 올라가다 막혀, 동쪽으로 흐르는 붉은 띠와 서쪽으로 흐르는 푸른 띠가 패널 위아래로 줄지어 서요. 흐름선의 굽이와 띠 사이 소용돌이는 물이 흐르는 쪽을 거슬러 서쪽으로 미끄러져요. K3 은 띠의 수를 정하는 β, K4 는 휘젓는 세기이고, K1 을 누르면 새로 시작해요.","why":"","block":0,"ramped":false,"layer":{"id":"layer-zonal-jets","type":"code","name":"zonal-jets","visible":true,"opacity":1,"blend":"normal","role":"paint","maskInvert":false,"ramp":{"stops":[{"position":0,"color":"#000000","alpha":1},{"position":1,"color":"#ffffff","alpha":1}],"mode":"linear","wrap":false},"recolor":false,"knobsAnnotationRaw":"// @knobs Hue=0..1, Speed=0.2..3, Beta=-1..1, Stir=0..1","matrixAnnotationRaw":"// @matrix 64x128"},"matrix":{"width":64,"height":128},"knobs":[{"name":"Hue","min":0,"max":1},{"name":"Speed","min":0.2,"max":3},{"name":"Beta","min":-1,"max":1},{"name":"Stir","min":0,"max":1}],"start":[0,2,0,0.06],"measures":{"motion":1.6984,"detail":0.1034,"edges":0.3215,"complexity":2.5641,"coverage":1,"colour":0.5239,"drift":0.091},"knobResponse":[0.4219,0.2215,0.3123,0.148]}],"families":{"algo":{"label":"알고리즘","color":"#e0c060"},"automata":{"label":"셀룰러 오토마타","color":"#9be15d"},"bird":{"label":"새","color":"#778800"},"body":{"label":"몸","color":"#bb5566"},"celestial":{"label":"천체","color":"#ffffaa"},"cells":{"label":"보로노이·셀","color":"#5fd0d0"},"chemistry":{"label":"화학·실험","color":"#00bb00"},"circuit":{"label":"전자 회로","color":"#2e7d32"},"city":{"label":"도시","color":"#22ff00"},"construction":{"label":"공사·건설","color":"#ffee00"},"cosmetic":{"label":"화장품 팝업","color":"#f2c6c2"},"data":{"label":"데이터 그림","color":"#7fe08a"},"fair":{"label":"놀이공원","color":"#ffffff"},"farm":{"label":"농사·밭","color":"#449911"},"film":{"label":"필름·영화","color":"#ff0000"},"flight":{"label":"비행","color":"#9944ee"},"fractal":{"label":"프랙탈","color":"#a3a0ff"},"fungi":{"label":"버섯·균사","color":"#00ff88"},"geometry":{"label":"기하·대칭","color":"#c77dff"},"glass":{"label":"유리","color":"#b0002a"},"glitch":{"label":"글리치","color":"#b0b8c8"},"growth":{"label":"자라남","color":"#d4c094"},"halloween":{"label":"할로윈","color":"#7f00ff"},"insect":{"label":"곤충","color":"#b4e61e"},"kitchen":{"label":"부엌","color":"#ff5500"},"light":{"label":"빛","color":"#7ef0d0"},"line":{"label":"선·궤적","color":"#ff7a45"},"machine":{"label":"기계·톱니","color":"#4a2cff"},"mammal":{"label":"짐승","color":"#998844"},"microbe":{"label":"미생물","color":"#aa00aa"},"mineral":{"label":"광물·결정","color":"#886688"},"music":{"label":"음악·악기","color":"#a0705a"},"noise":{"label":"노이즈·흐름","color":"#5ec8ff"},"number":{"label":"수론","color":"#00aaff"},"ocean":{"label":"바다","color":"#1f7fb8"},"paper":{"label":"종이","color":"#996600"},"particle":{"label":"입자","color":"#ffb02e"},"physics":{"label":"물리·스프링","color":"#ff9db0"},"pixel":{"label":"픽셀 아트","color":"#ffd166"},"polar":{"label":"얼음·극지","color":"#00ffff"},"pottery":{"label":"도자기","color":"#b05030"},"print":{"label":"망점·인쇄","color":"#f0a0e0"},"rail":{"label":"철도","color":"#00bb66"},"rhythm":{"label":"리듬·펄스","color":"#ff4d4d"},"sim":{"label":"시뮬레이션","color":"#3fe0a8"},"space":{"label":"공간·원근","color":"#e8e05a"},"sport":{"label":"운동·경기","color":"#337777"},"stage":{"label":"무대·공연","color":"#ff0066"},"textile":{"label":"직물·짜임","color":"#e04ad8"},"time":{"label":"시계·시간","color":"#ff8f5a"},"topology":{"label":"위상·매듭","color":"#80ff40"},"toy":{"label":"장난감","color":"#dd11ff"},"type":{"label":"글자","color":"#ff5fa2"},"volcano":{"label":"화산","color":"#bb2200"},"wave":{"label":"물결·간섭","color":"#4f7dff"},"weather":{"label":"날씨·자연","color":"#8fc0ff"}},"shelf":{"date":"2026-10-25","about":"1–39판 298개를 창작자의 기본 프리셋과 같은 잣대로 재서 여섯 묶음으로 나눴어요. 프리셋은 화면이 단순하고(복잡도 가운데값 0.22) 쉬지 않고 움직이는데(움직임 0.66), 15판부터 나온 250개는 복잡도 1.3–1.6, 움직임 0.21 이에요. 나눈 뒤에 들어온 40판 열 개도 같은 잣대로 보고 넣었어요.","groups":[{"key":"new","label":"아직 안 추린 것","why":"추린 뒤에 들어온 패턴이에요. 아직 어느 묶음에도 넣지 않았어요.","open":true,"patterns":["ferrow","tamsel","alphabet-lineage","cantor-scalogram","crofton-cell","exclusion-process","fork-hologram","lensed-page","letter-retracts","noordzij-cube","phasor-noise","word-search","baudot-tape","beading-letters","cornsweet-letters","dehn-twist","head-wave","malfatti-circles","modular-hyperbola","permutation-poem","pollards-rho","ybc-7289","coupling-from-the-past","doyle-spiral","kinematogram","linotype","mamikon-theorem","menger-slices","napier-bones","plucked-letters","ruled-hyperboloid","wheel-cypher","beam-letters","ekg-sequence","huygens-clocks","lempel-ziv","mobius-type","mushroom-billiard","neon-spreading","quantum-walk","ramsey-fringes","semaphore","chain-fountain","floating-letters","fox-colorings","franklin-involution","galileos-frets","quipu","square-word","teletext","three-disk-scattering","word-bokeh","brazil-nut","cardinal-vowels","fifteen-puzzle","gaussian-zeros","hopfield-letters","ishihara-plate","rabi-chevron","simulated-annealing","sitnikov-problem","v-cut-letters","anagram","beatty-rhythm","benford-law","cistercian-numerals","frieze-letters","hegselmann-krause","kanizsa-letters","levy-dust","order-k-voronoi","string-art","coded-aperture","euler-strokes","fractran","kruskal-count","letter-mobile","lights-out","mesostic","miura-ori","prandtl-membrane","steiner-tree","autostereogram","brick-factory","eye-chart","flag-hoist","lambda-diagrams","promotion","rational-tangles","reed-solomon","tally-count","trajan-helix","abracadabra","airy-beam","damask","durer-alphabet","ehrenfest-urn","maya-numerals","multiple-master","steiner-deltoid","topologists-sine-curve","voss-dice","autogram","biliteral-cipher","clothesline","coxeter-frieze","hydra-game","lattice-reduction","optical-kerning","ruppert-refinement","schlieren-texture","spray-stencil","benton-pantograph","book-from-the-sky","catoptric-anamorphosis","lorem-ipsum","mastermind","platycosms","apollonius-problem","sator-square","tensegrity","twindragon","eight-principles-of-yong","frenkel-kontorova","granular-leidenfrost","hellschreiber","hexachordal-theorem","ink-traps","laguerre-cells","multiplicative-chaos","photon-disk","quousque-tandem","aharonov-bohm","boustrophedon","calculator-words","caustic-letters","langford-pairs","letter-melt","nine-fold-seal","penney-game","steiner-symmetrization","whitney-graustein","composing-stick","delaunay-flips","fibonacci-word","huffman-tree","josephus","ogham","palimpsest","parallel-transport","rose-criterion","structure-ascii","artin-braids","blinking-vortex","braille-relief","distance-field","dupin-cyclide","hanging-line","radon-transform","shannon-approximations","silencio","walsh-functions","barrier-grid","etaoin-shrdlu","golomb-ruler","gridfonts","hodograph","shapley-folkman","subpixel","syllable-odometer","wilkinson-polynomial","zermelo-navigation","anamorphosis","foam-coarsening","hunminjeongeum","inversions","jacobi-geodesics","klein-sails","long-division","mcmullen-carpet","mouse-tale","sedimenting-cloud","ammann-beenker","broad-nib","counterforms","hill-regions","indian-rope-trick","kibble-zurek-ions","letter-sand","polynomial-amoeba","rivers-of-white","wongoji","excursion-sets","izhikevich-network","jamo-assembly","kaprekar-routine","maxwell-fish-eye","moffatt-eddies","simpson-paradox","trip-let","type-mosaic","word-ladder","abrikosov-lattice","balanced-rhythms","berggren-tree","busy-beaver","feynman-checkerboard","heesch-tiles","riemann-function","veech-octagon","void-and-cluster","yard-sale","art-gallery","binary-lens","canard-explosion","crackling-noise","greenhill-column","holditch-ring","monge-transport","paul-trap","taylor-unmixing","thomson-kink","cornu-spiral","eulers-officers","giant-component","hough-transform","jordan-curve","penrose-diagram","phase-spiral","randu-planes","richardson-dividers","rutherford-shadow","clebsch-surface","granular-demon","hawkes-process","kohonen-map","laser-speckle","quadratic-reciprocity","seam-carving","seifert-surface","voderberg-tiling","wigner-cat","beckett-gray","hanging-chain","hard-squares","hexagrammum-mysticum","kp-web","loop-soup","mirror-curves","print-gallery","rayleigh-taylor","tukey-depth","bicycle-tracks","galperin-billiard","medial-axis","ostwald-ripening","pentagon-tilings","sinai-walk","solenoid","stokes-drift","terrell-rotation","zagier-windmill","andrews-curves","bloch-oscillations","dead-leaves","elliptic-law","erdos-discrepancy","golomb-trominoes","multiplicative-cascade","random-organization","tree-peano-curve","twist-writhe","buffon-noodle","burrows-wheeler","hex-theorem","imaginary-geometry","question-mark","tissot-indicatrix","toussaint-wilczek","universal-cover","vortex-sheet","vuza-canon","arcsine-law","nodal-domains","pearcey-cusp","smale-horseshoe","stable-marriage","stit-tessellation","stormer-trap","strange-eigenmode","ulam-sequence","weaire-phelan","barycentric-subdivision","belt-trick","catenoid-helicoid","costas-array","elastica","four-vertex","gaussian-periods","leapfrogging-vortices","max-flow-min-cut","squared-rectangle","anscombes-quartet","banshee","creaking-door","de-bruijn-sequence","force-chains","gaussian-free-field","lost-head","pumpkin-drop","specimen-shelf","zonal-jets","bat-form","calabi-yau","grimoire","hat-monotile","jack-in-the-box","persistence-barcode","phantom-jam","sato-tate","tower-stair","zombie-shamble","bak-sneppen","diffusion-front","in-the-flash","inverse-cascade","motility-clusters","murmuration","old-well","paper-lantern-ghost","risset-rhythm","skull-swap","curlicue","durer-unfolding","gargoyle","kempe-chains","music-box","party-lights","pit-pendulum","square-peg","tennis-racket","werewolf","barn-owl","bone-pile","chebyshev-bias","double-gyre","flashing-ratchet","fractal-percolation","grim-reaper","headless-rider","mobius-energy","trick-or-treat","conways-soldiers","koebe-packing","lonely-runner","oloid","pumpkin-carving","pumpkin-vine","specimen-jar","swarmalators","talking-board","web-tremor","belfry","brillouin-zones","ghost-ship","glass-patterns","howling-wolf","lantern-procession","lorentz-gas","reeb-graph","stochastic-resonance","vampire-coffin","candy-corn","corn-maze","fogged-mirror","hadwiger-nelson","ising-interface","mummy","plancherel-growth","poltergeist","polya-orchard","rotor-router","ballistic-annihilation","black-cat","bulgarian-solitaire","crystal-ball","ham-sandwich","haunted-swing","kac-ring","lace-phantom","peregrine-soliton","slime-drip","bone-jig","grave-hand","hitomezashi","kaleidocycle","leaf-devil","mobius-loxodrome","orb-weaver","runge-phenomenon","scarecrow-crows","tutte-embedding","bat-emergence","candle-vigil","fput-recurrence","graveyard-fog","haunted-manor","knights-tour","morley-triangle","peaucellier-linkage","pivot-walk","witch-moon","cauldron","eyes-in-the-dark","hinged-dissection","jack-o-lantern","polytope-slices","poncelet-porism","sheet-ghosts","siteswap","spider-drop","square-wheels"]},{"key":"pick","label":"먼저 볼 후보","why":"프리셋이 서는 자리에 서는 것이에요. 큰 모양 몇 개가 쉬지 않고 움직이고, 글자나 사물이 없어서 한두 걸음 떨어져도 무엇이 움직이는지 보여요. 패널에 먼저 올려 볼 것들이에요.","open":true,"patterns":["marbling","constant-width","voronoi","pentomino-cover","moire-rings","kuramoto-sivashinsky","plait","domain-warp","heawood-torus","perron-tree","figure-eight-orbit","kdv-solitons","bokeh"]},{"key":"near","label":"하나가 모자란 추상","why":"추상이고 패널에서 읽히지만 하나가 모자라요. 거의 안 움직이거나, 패널을 꽉 채우거나, 데모에서 자주 본 것이에요. 칸마다 모자란 것을 적었어요.","open":false,"patterns":["bauhaus","fire","tunnel","aurora","reaction-diffusion","op-stripes","meander","jelly","ripple-tank","kaleidoscope","penrose","rauzy-fractal","hyperbolic-band","pinwheel-tiling","gibbs-phenomenon","zeta-loops","karman-street","dyson-gas","steiner-chain","lava-lamp","indras-pearls","j-invariant","bath-fizz","soap-film","crackle-polish","powder-burst","gold-leaf","glitter-fall","borromean-rings","flock","euclid-pulse","sparks","jacobs-ladder","searchlights","star-trails","curve-shortening","hofstadter-butterfly","ford-circles","gosset-polytope","cloud-chamber","kelvin-wake","hopf-fibration","lava-lake","prince-ruperts-cube","brownian-frontier","zeldovich-pancakes","continuum-random-tree","hydrogen-orbital","lotion-stitch","perfume-tears"]},{"key":"scene","label":"사물·장면 그림","why":"사물이나 장소를 그린 픽셀 그림이에요. 무엇인지는 바로 보이지만 한 번 보고 나면 더 볼 것이 없어요. 64칸 폭에 물건을 그리느라 결이 잘고, 바탕까지 칠해서 패널을 꽉 채워요. 15–27판이 거의 다 여기 있고, 프리셋 48개에는 이런 그림이 없어요.","open":false,"patterns":["center-pivot","climbing-wall","fluoroscope","funicular","glassblower","horse-in-motion","mitosis","sled-dogs","dark-field","geyser","iceberg","implosion","lichtenberg","noborigama","origami","pole-vault","rice-planting","shadow-play","eruption","excavation","ferris-wheel","kintsugi","marionette","rice-terraces","skydiver","snow-monkeys","breath","emergence","flying-trapeze","pipe-organ","potters-wheel","shoot-em-up","thermal","tower-crane","waggle-dance","axon","bait-ball","elephant-toothpaste","final-approach","giraffe","hanging-scroll","high-dive","proscenium","sequins","skein","bowling-lane","circulation","flame-test","flipdot","galilean-moons","liftoff","night-flight","pin-art","senbazuru","weaver","bread-mould","chemical-garden","fiddlehead","lap-pool","nixie","pancakes","pop-up-book","slinky","woodpecker","agate","change-ringing","chromatography","high-striker","kettle","kingfisher","moth-lamp","veiled-lady","cyanotype","dripstone","dust-motes","foxfire","helter-skelter","needlepoint","paternoster","popcorn","rabbit-ears","smalti","bismuth","drop-tower","longcase-clock","peg-light","pint","server-rack","stained-glass","turntables","typewriter","zen-garden","ant-farm","brushstrokes","circuit-board","crossroads","marble-run","one-bit","shoreline","train-window","abyss","domino-run","drying-mud","fireflies","harp","lunation","neon-alley","analemma","cam-wave","datamosh","incense","ivy","metro-map","player-piano","waterfall","balloon-box","tetromino-well","gear-train","jacquard","aquarium","climber","cloth","day-cycle","flip-clock","hourglass","rainstorm","sprout"]},{"key":"diagram","label":"수학·데이터 도해","why":"수학이나 데이터를 설명하는 그림이에요. 숫자와 눈금, 한 LED 굵기의 선이 많아서 패널에서는 뭉개지고, 무엇을 보는지 알려면 설명을 읽어야 해요.","open":false,"patterns":["borsuk-ulam","brachistochrone","explicit-formula","isospectral-drums","kingman-coalescent","anderson-localization","bernoulli-convolutions","infinity-series","polya-urn","sperner-lemma","antoine-necklace","fortune-sweep","johnson-mehl","catastrophe-machine","elliptic-chords","schwarz-lantern","joukowsky-airfoil","kolakoski","renyi-parking","lakes-of-wada","moving-sofa","thomson-problem","bertrand-paradox","dandelin-spheres","goldbach-comet","penrose-room","sorting-network","arnold-tongues","gilbreath-table","hammersley-lines","invasion-percolation","boys-surface","gaussian-moat","littlewood-roots","outer-billiards","three-gaps","seven-shuffles","hairy-ball","loewner-trace","look-and-say","stadium-billiard","wythoff-nim","population-pyramid","pendulum-wave","contour","galton","sorting"]},{"key":"cosmetic","label":"옅은 화장품 질감","why":"화장품 팝업용 질감이에요. 연분홍과 흰 바탕이 패널을 다 채워서(채움 가운데값 1.00) LED 에서는 밝은 판 하나로 보여요. 광택이나 눌린 자국 같은 표면 결은 64×128 에서 남지 않아요. 진한 색이 굵은 여섯은 위 묶음에 있어요.","open":false,"patterns":["jelly-layers","blotting-paper","serum-drip","couette-shimmer","milk-ring","photochromic","serum-fingers","embossed-glow","hair-oil","taffy-cream","blooming-gel","lotion-ribbon","shimmer-oil","whipped-soap","gilded-cream","sheet-mask","toner-pad","cat-eye","hair-gloss","mood-tint","velvet-nap","cleansing-balm","essence-drop","peel-off","chrome-powder","clay-mask","cushion-mesh","sugar-scrub","foam-lather","lip-gloss","setting-mist","sponge-blend","bi-phase","pearl-sheen","satin-fold","swatch-row","cream-swirl","loose-powder","serum-gel"]},{"key":"grain","label":"잔 결과 흔한 데모","why":"LED 한두 알 크기의 결이 화면을 덮거나, 생성 미술에서 너무 자주 본 것이에요. 가까이서는 촘촘하지만 한 걸음만 물러나도 잡음처럼 보여요.","open":false,"patterns":["defect-turbulence","lamellar-cream","hexatic-phase","chimera-state","kari-culik","scheidegger-rivers","talbot-carpet","cat-map","ballistic-deposition","percolation","aztec-diamond","sandpile","millefiori","sunglint","frost","spectrogram","chladni","guilloche","wireworld","warp","dragon","halftone","mandelbrot","maze","big-type","glyph-rain","harmonograph","life","pulse-bars","rule-scroll","test-card","truchet"]}]}}</script>
+<script type="application/json" id="code-0">{"ferrow":"// ===== Patternflow pattern =====\n// Title:   Ferrow\n// Family:  pixel\n// Idea:    A hand-pixelled figure of Ferrow, an old sentinel robot that has kept the last gate of a fallen citadel alone for two hundred years, standing on a display stand that fills the panel: bone-white enamel plates over a gunmetal frame, two exhaust stacks behind the shoulder, an antenna swept back from the ear, amber eyes in a dark visor, a plum tabard at the waist, and a greatsword as tall as he is carried on the shoulder, its fuller glowing like iron just out of the forge. He breathes, his eyes glance aside and blink, and every 6.8 s he lifts the sword off his shoulder to stand it upright at his hip, raises it once more, turns it over in his hand and drives its point into the stand, sinking into his knees as his outline and the stand's gold ring flash white and sparks fly; he leans on it while his stacks vent clouds of steam, then shoulders it again.\n// Author:  patternflow-lab\n// Date:    2026-11-01\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 86\n// Round:   86\n// ===============================\n// @matrix 64x128\n// @knobs Motion=0..1, Stand=0..3, Effect=0..1, Edition=0..1\n//\n// Knob 1: Motion. How he moves: below 0.25 he plants the sword every 6.8 s; from 0.25 he is restless and plants it every 3.4 s; from 0.5 he stands guard with the sword held upright at his hip and his eyes flared white; from 0.75 he is on standby, leaning on the planted sword with his head down a pixel and his eyes down to an ember line, and only breathes.\n// Knob 2: Stand. What he stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.\n// Knob 3: Effect. What comes off him: steam clouds after each bite and sparks where the point goes in below 0.25; from 0.25 a charge that lights his gunmetal a live blue, with his rim, eyes and fuller, surging brighter now and then, and long arcs forking off his outline; from 0.5 an overheat, the gunmetal glowing orange and hotter on each in-breath, his eyes burning yellow and steam on every breath; from 0.75 none.\n// Knob 4: Edition. The paint: bone-white enamel below 0.25, the second-player black and teal from 0.25, a gold and chrome limited plating from 0.5, and from 0.75 the unpainted grey prototype.\n// Buttons: K1 tap makes him plant the sword now; K2 tap sends the case light along him; K3 tap toggles the detail cut, his head, chest and sword hand at exactly twice the size; K4 tap makes the sword's point wink.\n\nconst W = 64, H = 128;\n// Each part is a grid, one character per LED and \".\" where it is clear, drawn\n// in ORDER. Materials run light to dark: enamel a b c d, gunmetal g h i j,\n// tabard p q r s, blade steel m n o. C I R O are the shadow-side bounce next to\n// the rim light z. f u v are the hot amber of the fuller and the eyes, x the\n// dark of the visor, w the specular. U V X N are the stand, S T the steam.\nconst PARTS = {\n  base: { x: 6, y: 111, rows: [\n    \".............NNNNNNNNNNNNNNNNNNNNNNNNNN.............\",\n    \"......NNNNNNNUUUUUUUUUUUUUUUUUUUUUUUUUUNNNNNNN......\",\n    \"...NNNUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUNNN...\",\n    \".NNUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUNN.\",\n    \"NUUUXXXXUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUN\",\n    \"XNNUXXXXXXXXXXXXXXXXXXXXXXXXXXUUUUUUUUUUUUUUUUUUUNNV\",\n    \"XXXNNNUUUUUUUUUUUUUUUUUUUUXXXXXXXXXXXXXXXXXXXXXXXVVV\",\n    \"XXXXXXNNNNNNNUUUUUUUUUUUUUUUUUUUUUUUUUUNNNNNNNVVVVVV\",\n    \"XXXXXXXVVVVVVNNNNNNNNNNNNNNNNNNNNNNNNNNVVVVVVVVVVVVV\",\n    \"XXXXXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\",\n    \"XXXXXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\",\n    \"..XXXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV..\",\n    \".......VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV.......\",\n    \".................VVVVVVVVVVVVVVVVVV.................\",\n  ] },\n  pack: { x: 8, y: 27, rows: [\n    \"..........z....\",\n    \"......zxxxh....\",\n    \"......zIIhhh...\",\n    \"....z.zIIhhh...\",\n    \"zxxxg.zIIhhh...\",\n    \"zIIhggjjihihh..\",\n    \"zIIhggjjihihh..\",\n    \"zIIhgg.zIIhihh.\",\n    \"zIIhgg.zIIhihh.\",\n    \".zIIgggjjihhgg.\",\n    \".zIIhggjjiihhgg\",\n    \".ziihggjjiihhgg\",\n    \".jjihhgg.......\",\n    \".jjihhgg.......\",\n    \".j.............\",\n  ] },\n  blade: { x: 7, y: 2, rows: [\n    \"z..........................................\",\n    \"zOOn.......................................\",\n    \".zOOoo.....................................\",\n    \".zOOnoooo..................................\",\n    \".zOOnnoooooo...............................\",\n    \"..zOOnnoooooo..............................\",\n    \"..zOOnnnoooooo.............................\",\n    \"...zOOnnnoooooo............................\",\n    \"...zmnnnnnoooooo...........................\",\n    \"...zmmnnnnnoooooo..........................\",\n    \"....zmmnnnnnoooooo.........................\",\n    \"....zmmmnnnnnoooooo........................\",\n    \".....zmmmnnnnnoooooo.......................\",\n    \"......zmmmnnonnoooooo......................\",\n    \".......zmmmoonnnoooooo.....................\",\n    \"........zmmnonnnnoooooo....................\",\n    \".........zmnmnnnuuoooooo...................\",\n    \"..........zOmmnnuuuoooooo..................\",\n    \"...........zmmmnnuuuoooooo.................\",\n    \"............mmmmnnuufoooooo................\",\n    \".............mmmmnnfffooooooo..............\",\n    \"..............mmmmnnfffooooooo.............\",\n    \"...............mmmmnnfffooooooo............\",\n    \"................mmmmnnfffooooooo...........\",\n    \".................mmmmnnfffooooooo..........\",\n    \"..................mmmmnnfffooooooo.........\",\n    \"...................mmmmnnfffooooooo........\",\n    \"...................mmmmmnnfffooooooo.......\",\n    \"....................mmmmmnnfffooooooo......\",\n    \".....................mmmmmnnfffooooooo.....\",\n    \"......................mmmmmnnfffooooooo....\",\n    \".......................mmmmmnnfffooooooo...\",\n    \"........................mmmmmnnfffooooooo..\",\n    \".........................mmmmmnnfffooooooo.\",\n    \"..........................mmmmmnnfnnooooooo\",\n    \"...........................mmmmmnnnnnooooo.\",\n    \"............................mmnnnnnnnnooo..\",\n    \".............................mmmmnnnnnno...\",\n    \"..............................mmmmmnnnn....\",\n    \"...............................mmmmmnn.....\",\n    \"................................mmmmm......\",\n    \".................................mmm.......\",\n    \"..................................m........\",\n  ] },\n  legfar: { x: 35, y: 75, rows: [\n    \"..jhg.................\",\n    \".jihhg................\",\n    \"jjihhgg...............\",\n    \"jjihhgg...............\",\n    \"jjiihhgg..............\",\n    \".jjihhgh..............\",\n    \".jjiihhhg.............\",\n    \".jjiihhgg.............\",\n    \"..jjiihhgg............\",\n    \"..jjiihhgg............\",\n    \"...jjihhgg...z........\",\n    \"...jcccaaaaaaa........\",\n    \"....cccaaaaaaaa.......\",\n    \"....cccbbbbbbbb.......\",\n    \"....cccbbbbbbbbb......\",\n    \".....ccbbbbbbbbb......\",\n    \".....ccbbbbbbbb.......\",\n    \".....ccbbbbbbb........\",\n    \".....zcbbbbbbb........\",\n    \"....zCCcccabbbb.......\",\n    \"....zCCcccabbbb.......\",\n    \"....zCCcccabbbb.......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbbb......\",\n    \".....zCCccabbbb.......\",\n    \"......zCCcabbbb.......\",\n    \"......zCCcabbbb.......\",\n    \"......zCCdccccc.......\",\n    \".......zCCccccg.......\",\n    \".......zCCccccg.......\",\n    \".......zIIihhgg.......\",\n    \"..zbbbbbbbbaaaaaaaa...\",\n    \"..zCCccccccbbbbbbbbb..\",\n    \"..zCCccccccbbbbbbbbb..\",\n    \"..cccccccccbbbbbbbbbb.\",\n    \"..cccccccccbbbbbbbbbbb\",\n    \".ccccccccccbbbbbbbbbbb\",\n    \".ccccccccccbbbbbbbbbbb\",\n    \".iiiiiiiiiihhhhhhhhhhh\",\n    \".jjjjjjjjjjjjjjjjjjjjj\",\n  ] },\n  legnear: { x: 14, y: 75, rows: [\n    \"............jhg.....\",\n    \"...........jihhg....\",\n    \"..........jjihhgg...\",\n    \"..........jjihhgg...\",\n    \"..........jjihhgg...\",\n    \"..........jjihhgg...\",\n    \"..........jjjiiih...\",\n    \"..........zIIiihh...\",\n    \"..........zIhhhhh...\",\n    \".........zIIhhgh....\",\n    \".........zIIhhghh...\",\n    \".......zCCaaaaawb...\",\n    \".......zCCaaaaabb...\",\n    \".......zCCbbbbbccb..\",\n    \".......zCCbbbbbccb..\",\n    \"........zCbbbbbcbb..\",\n    \"........zCbbbbbcb...\",\n    \"........zCbbbbcc....\",\n    \"........zCbbbbcc....\",\n    \"......zCCcccabccbb..\",\n    \"......zCCcccabccbb..\",\n    \"......zCCcccabcbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbbb..\",\n    \"......zCCcccabbbb...\",\n    \".......zCCccabbbb...\",\n    \".......zCCccabbbb...\",\n    \".......zCCddccccc...\",\n    \"........zCCdcccc....\",\n    \"........zCCdcccc....\",\n    \"........zIIihhgg....\",\n    \".zbbbbbbbaaaaaaaaa..\",\n    \".zCCcccccbbbbbbbbb..\",\n    \".zCCcccccbbbbbbbbbb.\",\n    \".zCCcccccbbbbbbbbbb.\",\n    \"cccccccccbbbbbbbbbbb\",\n    \"cccccccccbbbbbbbbbbb\",\n    \"iiiiiiiiihhhhhhhhhhh\",\n    \"jjjjjjjjjjjjjjjjjjjj\",\n  ] },\n  spine: { x: 28, y: 59, rows: [\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"zIIjiiihh\",\n    \"zIIjjjjjj\",\n    \"zIIihhhgg\",\n    \"zIIihhhgg\",\n    \"zIIjjjjjj\",\n    \"zIIihhhgg\",\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n  ] },\n  hips: { x: 18, y: 67, rows: [\n    \"..zIIgggggggggggggggggggggg....\",\n    \"..zIIiiiiihhhhhhhhhhggggggg....\",\n    \".jjjiiiiihhhhhhhhhhhhggggggg...\",\n    \"dddbbbbbbbbbbbhcccaaaaaaaaaa...\",\n    \"dddbbbbbbbbbbb.cccaaaaaaaaaa...\",\n    \"dddcccccccccdd.cccbbbbbbbbbbb..\",\n    \"dddcccccccccdd.cccbbbbbbbbbbb..\",\n    \"dddcccccccccdd.cccbbbbbbbbbbb..\",\n    \"dddcccccccccd...ccbbbbbbbbbbbb.\",\n    \"zCCcccccccccd...ccbbbbbbbbbbbb.\",\n    \"zCCcccccccccd...ccbbbbbbbbbbbbb\",\n    \".zCCccccccccd...ccbbbbbbbbbbbbb\",\n    \"...zCCddddddd...ccccccccccc....\",\n    \"....zCCdddddd...cccccccc.......\",\n    \".....z.........................\",\n  ] },\n  tabard: { x: 31, y: 70, rows: [\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".rrqrqqppp.\",\n    \".zRqrqqppp.\",\n    \".zRqrqqppp.\",\n    \".zRqrqqppp.\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"rrrqrqqpppp\",\n    \"zRRqrqqpppp\",\n  ] },\n  tabtip: { x: 30, y: 85, rows: [\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \".rrrqrqqqppp.\",\n    \"rrrrqrrqqpppp\",\n    \"rrrrqrrqqpppp\",\n    \"rrrrqrrqqpppp\",\n    \"rr..zRRqq..pp\",\n    \"r....zRq....p\",\n    \"......z......\",\n  ] },\n  torso: { x: 17, y: 39, rows: [\n    \"........jjjiihhhhhgghhh.........\",\n    \".bbbbbbbjjjiihhhhhgggggbbaaaaa..\",\n    \".bbbbbbbbjjjjiiiiiggggabbbawaa..\",\n    \".bbbbbbbbjjjjiiiiiggggabbbaaaaa.\",\n    \".dddccccccccccciabbbbbbbccbbbbb.\",\n    \"ddddccccccccccciabbbbbbbcbbbbbb.\",\n    \"ddddccjjjjjjccciabbbbbbbbbbbbbbb\",\n    \"ddddccccccccccciabbbbbbbbbbcbbbb\",\n    \"ddddccccccccccciabbbbbcccbccbbb.\",\n    \".dddccjjjjjjccciabbbbccccbccdbb.\",\n    \".dddccccccccccciabbbbbbcbbccdb..\",\n    \".ddddddddddddddicccccccccccddd..\",\n    \"..dddddddddddddicccccccccccdd...\",\n    \"..zCCddddddddddiccccccccccccd...\",\n    \".....zIIiiiiihhhhhhhgggggg......\",\n    \".....zIIjjjjjjjjjjjjjjjjjj......\",\n    \".....zIIiiiiihhhhhhhgggggg......\",\n    \"......zIIiiiiihhhhhhggggg.......\",\n    \"......zIIjjjjjjjjjjjjjjjj.......\",\n    \"......zIIiiiiihhhhhhggggg.......\",\n    \".......zIIiiiihhhhhggggg........\",\n    \".......zIIiiiihhhhhggggg........\",\n  ] },\n  neck: { x: 28, y: 35, rows: [\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"jjiihhhgg\",\n    \"zIijiiihh\",\n    \"jjjjiiihh\",\n    \"jjiihhhgg\",\n  ] },\n  paulfar: { x: 42, y: 36, rows: [\n    \".....a..........\",\n    \"...aaaaaaaaa....\",\n    \"..caaaaaaawaa...\",\n    \"cccaaaaaaaaaaa..\",\n    \"cccbbbbbbbbbbb..\",\n    \".ccbbbbbbbbbbbb.\",\n    \".ccbbbbbbbbbbbbb\",\n    \"..cbbbbbbbbbbbbb\",\n    \"..cbbbbbbbbbbbbb\",\n    \"...ccbbbbbbbbbbb\",\n    \"...ccbbbbbbbbbb.\",\n    \"...ccbbbbbbbbbb.\",\n    \"....jiiiiiiiiii.\",\n    \"....jjiiiiiiiii.\",\n    \".....jjjjj......\",\n    \".....z..........\",\n  ] },\n  armfar: { x: 48, y: 47, rows: [\n    \"..cccbb....\",\n    \".dcccbbb...\",\n    \"ddcccbbba..\",\n    \"ddcccbbba..\",\n    \"dddddcbba..\",\n    \"zCCddccbaa.\",\n    \"zCCcdccbaa.\",\n    \"zCCccccbaa.\",\n    \".zCCccccaa.\",\n    \".zCCccccaa.\",\n    \".zCCcbccaa.\",\n    \"..zCCbbbaa.\",\n    \"..zCCbbbaaa\",\n    \"..zCCbbbaaa\",\n    \"..zCCbbbaaa\",\n    \"...zCbbbaa.\",\n    \"....zbbba..\",\n    \".....zbb...\",\n  ] },\n  paulnear: { x: 4, y: 36, rows: [\n    \".........aaaaaaabb.....\",\n    \"........baaaaaaawbb....\",\n    \"......bbbaaaaaaaabbb...\",\n    \".....zbbbaaaaaaaaaaaa..\",\n    \"...zCbbbbaaaaaaaaaaaaa.\",\n    \"...zCbbbbbbbbbbbbbbbbbb\",\n    \"..zCCccccccccccbbbbbbbb\",\n    \"..zCCccccccccccbbbbbbbb\",\n    \".zCCdccccccccccbbbbbbbb\",\n    \".zCCdccccccccccbbbbbbb.\",\n    \"zCCddddddddddddddddddd.\",\n    \"zCCddccccccccccbbbbbbb.\",\n    \"zCCddccccccccccbbbbbbb.\",\n    \".zIIiiiiiiiiihhhhhhhhh.\",\n    \".zIIiiiiiiiiiiiiiii....\",\n    \".zIIjjjjjjjjjjjjj......\",\n    \"......jjjjjjjj.........\",\n    \"...........j...........\",\n  ] },\n  armnear: { x: 4, y: 49, rows: [\n    \".......hhh.........\",\n    \"......jihhg........\",\n    \".....jjihhgg.......\",\n    \".....zIIhhgg.......\",\n    \".....zIIhhgg.......\",\n    \"....zIIhhgg........\",\n    \"....zIIhhgg........\",\n    \"...zIIhhgg.........\",\n    \"...zIIhhgg.........\",\n    \"...zIIhhgg.........\",\n    \"..zIIhhgg..........\",\n    \"..zIIhhgg..........\",\n    \".zIaaagg...........\",\n    \".zaaaaaa...........\",\n    \".zbaaaaaa..........\",\n    \"zCbbaaaaaa.........\",\n    \"zCCbbbaaaaa........\",\n    \"zCCcbbbaaaaa.......\",\n    \".zCCccbbaaaaa......\",\n    \".zCCcccbbaaaaa.....\",\n    \"..zCCcccbbbaajjhhg.\",\n    \"....zCCccbbbjijhhgg\",\n    \".....zCCcccbjijhhgg\",\n    \"......zCCcccjijhhgg\",\n    \".......zCCccjijhhgg\",\n    \".........zCCjijhhgg\",\n    \"..........zCIjjhhg.\",\n    \"............z......\",\n  ] },\n  head: { x: 19, y: 6, rows: [\n    \".......z.....................\",\n    \"........zCCca................\",\n    \".........zCCaaaa.............\",\n    \"..........zCbbbbbbb..........\",\n    \"............zbbbbbbb.........\",\n    \"....bbbbaaaaaabbbbbbbw.......\",\n    \"...bbbbbaaaaaaaaaaaaaaaaa....\",\n    \"..bbbbbbaaaaaaaaaaaaaaaaaa...\",\n    \".bbbbbbbaaaaaaaaaaaaaaaaaa...\",\n    \".bbbbbbbbbbbbbbbbbbbbbbbbbb..\",\n    \".ddccccccccccbbbbbbbbbbbbbbb.\",\n    \".ddccccccccccbbbbbbbbbbbbbbb.\",\n    \"dddccccccccaaabbbbbbbbbbbaaa.\",\n    \"dddccccccccbbbaaabbbbbaaabbdd\",\n    \"dddccccccccdddbbbaaaaabbbddxx\",\n    \"zCCcchcccccxxxdddbbbbbdddxxxx\",\n    \"zCCiihhhcccxxxxxxdddddxxxxxxx\",\n    \"zCCiihghcccxxxuuwxxxxxxxuwxxx\",\n    \"zCCiihghcccxxxufffuxxxuffuxxx\",\n    \"zCIiihhhhccxxxxufuuxxxuuuxxxx\",\n    \".zCIiiiicccxxxxxxxxxxxxxxxxxx\",\n    \".zCIiiiicccxxxxxxxxxxxxxxxxxx\",\n    \".zCIiiiicccccbbbbbbbbbbbbbbbb\",\n    \".ddccicccccccbbbbbbbbbbbbbbb.\",\n    \".ddccccccccccbbbbbbdbbdbbdbb.\",\n    \".ddccccccccccbbbbbbdbbdbbdbb.\",\n    \"..dccccccccccbbbbbbdbbdbbdb..\",\n    \"..dccccccccccbbbbbbdbbdbbdb..\",\n    \"...ccccccccccbbbbbbbbbbbbb...\",\n    \"...ddddddddddcccccccccccc....\",\n    \"....zCCddddddccccccccccc.....\",\n    \"........zCCddcccccccccc......\",\n    \"...........d.................\",\n  ] },\n  hilt: { x: 40, y: 35, rows: [\n    \"...........z.......\",\n    \"..........gg.......\",\n    \".........gghh......\",\n    \"........gghh.......\",\n    \".......gghh........\",\n    \"......gghh.........\",\n    \".....gghh..........\",\n    \"....gghh...........\",\n    \"...gghh............\",\n    \"..gghh..sr.........\",\n    \".gghh...ssr........\",\n    \"gghh.....ssr.......\",\n    \"..h.......ssr......\",\n    \"...........ssr.....\",\n    \"............sss....\",\n    \".............sss...\",\n    \"..............sshh.\",\n    \"...............hhgw\",\n    \"...............hhgg\",\n    \"...............hhhh\",\n    \"................hh.\",\n  ] },\n  fistfar: { x: 47, y: 42, rows: [\n    \"..ihhg..\",\n    \".jihhgg.\",\n    \"jjihhhwg\",\n    \"jjihhhgg\",\n    \"jjihhhgg\",\n    \"jjjjhhgg\",\n    \"jjihhhgg\",\n    \".jihhgg.\",\n    \"..ihhh..\",\n  ] },\n  torso_u: { x: 38, y: 47, rows: [\n    \".bbb.....\",\n    \"bbbb...c.\",\n    \"..b....c.\",\n    \".......dd\",\n  ] },\n  paulfar_u: { x: 45, y: 45, rows: [\n    \".b.\",\n    \"bb.\",\n    \"bb.\",\n    \".i.\",\n    \".ii\",\n    \"..j\",\n  ] },\n  chest_u: { x: 41, y: 43, rows: [\n    \"bb.....\",\n    \"b......\",\n    \"...cb..\",\n    \".......\",\n    \"..b....\",\n    \".......\",\n    \".......\",\n    \".......\",\n    \".....dd\",\n  ] },\n  armfar_m: { x: 49, y: 48, rows: [\n    \"..jhg..........\",\n    \".jjihgg........\",\n    \"jjjiihhhgg.....\",\n    \"zIIiihhhhbba...\",\n    \"zjjiiihhcbbaa..\",\n    \".jjjiiiccbbaaa.\",\n    \"..zIIjcccccbbaa\",\n    \"....zIcccccbaaa\",\n    \".....zcccbbaaaa\",\n    \".....dcccbbaaa.\",\n    \".....dcccbbaaa.\",\n    \"....ddcccbbaa..\",\n    \".....dcccbbaa..\",\n    \".....dcccbba...\",\n    \"......cccbb....\",\n    \"........c......\",\n  ] },\n  headrim: { x: 19, y: 11, rows: [\n    \"....z\",\n    \"...z.\",\n    \"..z..\",\n    \".z...\",\n    \".z...\",\n    \".zCC.\",\n    \".zCC.\",\n    \"zCC..\",\n    \"zCC..\",\n    \"zCC..\",\n  ] },\n  blade_m: { x: 52, y: 4, rows: [\n    \"....z....\",\n    \"...zOO...\",\n    \"...zOO...\",\n    \"..zOOoo..\",\n    \"..zOOoo..\",\n    \".zmnoooo.\",\n    \".zmnoooo.\",\n    \"zmmnooooo\",\n    \"zmmnooooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"nmmnuoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnfoooo\",\n    \"nmmnooooo\",\n    \"nmmnooooo\",\n    \"nmmnooooo\",\n  ] },\n  hilt_m: { x: 50, y: 52, rows: [\n    \"iiigggggggggg\",\n    \"zIIhhhhhhhhhh\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....zRR.....\",\n    \".....zRR.....\",\n    \".....zRR.....\",\n    \".....zhr.....\",\n    \".....zgg.....\",\n    \"....zhggh....\",\n    \".....zhh.....\",\n    \"......z......\",\n  ] },\n  fist_m: { x: 52, y: 56, rows: [\n    \"...jhg...\",\n    \"..zIhgg..\",\n    \".zIIhhgw.\",\n    \"zIIihhggg\",\n    \"zIIjhhggg\",\n    \"zIIijjggg\",\n    \".zIIhhjg.\",\n    \"..zIhgg..\",\n    \"...zhg...\",\n  ] },\n  armfar_b: { x: 49, y: 48, rows: [\n    \"..jhg..........\",\n    \".jiiihg........\",\n    \"jjijjihhgg.....\",\n    \"zIIijihhhbba...\",\n    \"zIIijjhhcbbaa..\",\n    \".zIIjjiccbbaaa.\",\n    \"..zIIjcccbbaaaa\",\n    \"....zIcccbbaaaa\",\n    \".....zcccbbaaaa\",\n    \".....dcccbbaaa.\",\n    \".....dcccbbaaa.\",\n    \"....ddcccbbaa..\",\n    \".....dcccbbaa..\",\n    \".....dcccbba...\",\n    \"......cccbb....\",\n    \"........c......\",\n  ] },\n  blade_b: { x: 52, y: 69, rows: [\n    \"zOOoooooo\",\n    \"zOOoooooo\",\n    \"zmmnooooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnfoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnuoooo\",\n    \"zmmnooooo\",\n    \"zmmnooooo\",\n    \"nmmnooooo\",\n    \"nmmnooooo\",\n    \".mmnoooo.\",\n    \".mmnoooo.\",\n    \"..mnooo..\",\n    \"..mnooo..\",\n    \"...noo...\",\n    \"...noo...\",\n    \"....o....\",\n    \"....o....\",\n  ] },\n  hilt_b: { x: 50, y: 46, rows: [\n    \"......h......\",\n    \".....hgg.....\",\n    \"....hhggh....\",\n    \".....hhh.....\",\n    \".....shr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....ssr.....\",\n    \".....zRR.....\",\n    \".....zRR.....\",\n    \"zIIgggggggggg\",\n    \"zIIhhhhhhhhhh\",\n  ] },\n  fist_b: { x: 52, y: 56, rows: [\n    \"...jhg...\",\n    \"..zIhgg..\",\n    \".zIIhhgw.\",\n    \"zIIihhggg\",\n    \"zIIjhhggg\",\n    \"zIIijjggg\",\n    \".zIIhhjg.\",\n    \"..zIhgg..\",\n    \"...zhg...\",\n  ] },\n};\n// The three poses: the sword on the shoulder, held upright, and planted.\nconst ORDER = [\"base\", \"pack\", \"blade\", \"legfar\", \"legnear\", \"spine\", \"hips\", \"tabard\", \"tabtip\", \"torso\", \"neck\", \"paulfar\", \"armfar\", \"paulnear\", \"armnear\", \"head\", \"hilt\", \"fistfar\"];\nconst ORDER_M = [\"base\", \"pack\", \"legfar\", \"legnear\", \"spine\", \"hips\", \"tabard\", \"tabtip\", \"torso\", \"torso_u\", \"neck\", \"paulfar\", \"paulfar_u\", \"chest_u\", \"armfar_m\", \"paulnear\", \"armnear\", \"head\", \"headrim\", \"blade_m\", \"hilt_m\", \"fist_m\"];\nconst ORDER_B = [\"base\", \"pack\", \"legfar\", \"legnear\", \"spine\", \"hips\", \"tabard\", \"tabtip\", \"torso\", \"torso_u\", \"neck\", \"paulfar\", \"paulfar_u\", \"chest_u\", \"armfar_b\", \"paulnear\", \"armnear\", \"head\", \"headrim\", \"blade_b\", \"hilt_b\", \"fist_b\"];\n// Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the tabard's hem, which swings sideways, 4 the planted blade, which stays but still takes the case light.\nconst GROUP = {\"base\": 0, \"pack\": 1, \"blade\": 1, \"legfar\": 0, \"legnear\": 0, \"spine\": 0, \"hips\": 0, \"tabard\": 0, \"tabtip\": 3, \"torso\": 1, \"neck\": 1, \"paulfar\": 1, \"armfar\": 1, \"paulnear\": 1, \"armnear\": 1, \"head\": 2, \"hilt\": 1, \"fistfar\": 1, \"armfar_m\": 1, \"blade_m\": 1, \"hilt_m\": 1, \"fist_m\": 1, \"armfar_b\": 1, \"blade_b\": 4, \"hilt_b\": 4, \"fist_b\": 1, \"torso_u\": 1, \"paulfar_u\": 1, \"chest_u\": 1, \"headrim\": 2, \"smear_up\": 1, \"smear_flip\": 1};\nconst PAL = { a: 0xf2e2c0, b: 0xd8c4a2, c: 0xa7978f, d: 0x6f6684, g: 0x93a3c2, h: 0x5d6890, i: 0x3e4374, j: 0x2b2a56, p: 0xc87a96, q: 0x96507e, r: 0x683768, s: 0x3f1f56, m: 0xe4eef5, n: 0xa8bad4, o: 0x6a7aa6, f: 0xffd884, u: 0xff9b30, v: 0xd2552e, x: 0x2a2450, z: 0x8cccff, w: 0xfffaf0, C: 0xa7978f, I: 0x48538a, R: 0x683768, O: 0x6a7aa6, U: 0x48538a, V: 0x2f2f62, X: 0x2a2450, N: 0xd6b075, S: 0xe6e2de, E: 0xff9b30, F: 0xffd884, W: 0xfffaf0 };\n// Knob 4: the editions, each a hand-picked repaint of some materials.\nconst EDITIONS = [\n  {  },\n  { a: 0xb4b9cf, b: 0x7f86a6, c: 0x575c82, d: 0x3b3d66, C: 0x575c82, p: 0x6fc7b5, q: 0x3b9590, r: 0x226670, s: 0x1b4560, R: 0x226670 },\n  { a: 0xffe7a3, b: 0xe1b45e, c: 0xb07a6a, d: 0x6e4a6e, C: 0xb07a6a, g: 0xe8eef6, h: 0xa7b3c8, i: 0x6c7896, j: 0x3d4568, I: 0x6c7896 },\n  { a: 0xe6e2df, b: 0xc4c0be, c: 0x999593, d: 0x706c6a, C: 0x999593, g: 0xbbb7b4, h: 0x8a8684, i: 0x625f5d, j: 0x464341, I: 0x625f5d, p: 0xb0acaa, q: 0x8a8684, r: 0x625f5d, s: 0x464341, R: 0x625f5d, m: 0xede7e3, n: 0xbbb5b1, o: 0x86807d, O: 0x86807d, f: 0xede7e3, u: 0xbbb5b1, v: 0x86807d, x: 0x403d3b },\n];\n// Knob 2: the stands.\nconst STANDS = [\n  { U: 0xb2815f, V: 0x8d5541, X: 0x67332f, N: 0xe0c29b },\n  { U: 0xd5d7dd, V: 0xa9abb2, X: 0x797c84, N: 0xe1e2e8 },\n  {  },\n  { U: 0x00658c, V: 0x00bcd9, X: 0x0084a8, N: 0xc1f8f9 },\n];\n// Knob 3: what the frame does to the steel. Steam and off leave it; the charge\n// turns the gunmetal, the rim, the eyes and the fuller a live blue that surges\n// brighter now and then; the overheat runs the gunmetal orange hot, brighter\n// than the enamel, and hotter again on each in-breath.\n// Z is the arcs, a shade apart from the charged rim.\nconst CHARGE = [\n  { g: 0x86d4ff, h: 0x4a90f0, i: 0x3058c0, j: 0x283090, I: 0x3a64d0, z: 0xd8f4ff, O: 0x5a90d8, Z: 0x6fd0ff, u: 0x40c8ff, f: 0xa8ecff, v: 0x3a78e0, E: 0x40c8ff, F: 0xa8ecff },\n  { g: 0xd0f4ff, h: 0x90d0ff, i: 0x5088f0, j: 0x3840b0, I: 0x6a98f8, z: 0xf0fcff, O: 0x80b8f8, Z: 0xa8e8ff, u: 0x80e0ff, f: 0xd8f8ff, v: 0x4a90f0, E: 0x80e0ff, F: 0xd8f8ff },\n];\nconst HEAT = [\n  { g: 0xffe08a, h: 0xffa040, i: 0xd8602c, j: 0x8a3038, I: 0xc05a40, E: 0xffd060, F: 0xfffaf0 },\n  { g: 0xfff0b0, h: 0xffc060, i: 0xf07a34, j: 0xa83a3a, I: 0xd8703c, E: 0xffd060, F: 0xfffaf0 },\n];\n// The case light: what a glossy character turns into while the band passes.\nconst UP = {\"n\": \"m\", \"o\": \"n\", \"O\": \"n\", \"h\": \"g\", \"i\": \"h\", \"I\": \"h\", \"j\": \"i\"};\n// The eyes, x, y and colour, painted over the visor each frame so they can\n// look aside, half shut, shut to an ember line, or flare. E F W are their own\n// letters, so each effect can repaint them apart from the fuller.\nconst EYES = [[33, 23, \"E\"], [34, 23, \"E\"], [35, 23, \"W\"], [43, 23, \"E\"], [44, 23, \"W\"],\n  [33, 24, \"E\"], [34, 24, \"F\"], [35, 24, \"F\"], [36, 24, \"F\"], [37, 24, \"E\"], [41, 24, \"E\"], [42, 24, \"F\"], [43, 24, \"F\"], [44, 24, \"E\"],\n  [34, 25, \"E\"], [35, 25, \"F\"], [36, 25, \"E\"], [37, 25, \"E\"], [41, 25, \"E\"], [42, 25, \"E\"], [43, 25, \"E\"]];\nconst FLARE = { E: \"F\", F: \"W\", W: \"W\" };\n// The wink on the sword's point: x, y and what the LED turns into.\nconst GLINT = [[10, 5, \"w\"], [9, 4, \"w\"], [11, 5, \"w\"]];\n// Where the planted point bites the stand, and the glow it throws on the rim.\nconst BITE_X = 56, BITE_Y = 116;\n// What does not sink with him.\nconst FIRM = { base: 1, legfar: 1, legnear: 1 };\nconst SPILL = [[53, 118, \"f\"], [54, 118, \"w\"], [55, 118, \"w\"], [56, 118, \"w\"], [57, 118, \"f\"], [54, 119, \"f\"], [55, 119, \"f\"], [56, 119, \"f\"]];\n// A ring running out along the stand from the bite, a step at a time.\nconst SHOCK = [4, 9, 15, 22, 30, 38];\n// The flash at the moment of the bite, for its first two fifteenths of a second.\nconst FLASH = [[56, 111, \"f\"], [56, 112, \"w\"], [56, 113, \"w\"], [56, 114, \"w\"], [53, 116, \"w\"], [54, 116, \"w\"], [55, 116, \"w\"], [57, 116, \"w\"], [58, 116, \"w\"], [51, 116, \"f\"], [52, 116, \"f\"], [59, 116, \"f\"], [60, 116, \"f\"], [54, 114, \"f\"], [58, 114, \"f\"], [53, 113, \"u\"], [59, 113, \"u\"], [56, 110, \"u\"]];\n// The two exhaust mouths and how late each puffs after the other. A cloud\n// swells as it drifts up and away to the left, then shrinks away. S is its own\n// letter so no repaint reaches it.\nconst STACKS = [[16, 27, 0], [10, 30, 0.2]];\nconst PUFF = [\n  [\"SS\", \"SS\"],\n  [\".SSS.\", \"SSSSS\", \"SSSSS\", \".SSS.\"],\n  [\"..SSS..\", \".SSSSS.\", \"SSSSSSS\", \"SSSSSSS\", \".SSSSS.\", \"..SSS..\"],\n  [\"..SSSS..\", \".SSSSSS.\", \"SSSSSSSS\", \"SSSSSSSS\", \".SSSSSS.\", \"..SSSS..\"],\n  [\".SSS.\", \"SSSSS\", \"SSSSS\", \".SSS.\"],\n  [\".SS.\", \"SSSS\", \".SS.\"],\n];\n\nconst { floor, min, max, abs, cos, sin, PI } = Math;\n// The events run on a fixed loop of exactly eight breaths, so they always meet\n// the breath at the same phase. Blinks come 2 to 3.3 s apart and never while\n// the head is moving; the case light every 6.8 s, taking 2.4 s to cross, at a\n// phase where no breath step meets its edge; the glint on the point every 3 or\n// more, always while the sword is on the shoulder. The sword comes down every\n// 6.8 s and the eyes glance aside between. None falls between 1.5 and 2.5 s,\n// where the still is taken.\nconst CYCLE = 27.2;\nconst BLINKS = [0.6, 3.3, 6.4, 9.0, 12.0, 14.3, 17.6, 20.1, 23.4, 25.8];\nconst SWEEPS = [4.3, 11.1, 17.9, 24.7];\nconst GLINTS = [3.0, 8.0, 15.8, 22.0];\nconst PLANTS = [3.4, 10.2, 17.0, 23.8];\nconst PLANTS_KEEN = [1.25, 4.65, 8.05, 11.45, 14.85, 18.25, 21.65, 25.05];\nconst SCANS = [[7.2, -2, 1.1], [8.8, 2, 0.8], [14.0, 2, 1.0], [15.4, -2, 1.0], [21.0, -2, 1.1], [22.6, 2, 0.8]];\nconst SWEEP_LEN = 2.4;\nconst GLINT_LEN = 0.17;\n// The big move: the sword comes off the shoulder upright, bites the stand\n// point first at LIFT, is leant on until DOWN, and goes back up the same way.\n// Each knob 1 stop has a pose it rests in between: shouldered, shouldered,\n// held upright on guard, and planted on standby.\n// Before each swing he winds up for two steps: the shouldered sword lifts off\n// the shoulder, and the upright one rises before it is turned and driven down.\nconst LIFT = 10 / 15, DOWN = 40 / 15, PLANT_LEN = 46 / 15;\nconst WIND = { blade: 1, hilt: 1, fistfar: 1, armfar: 1, blade_m: 1, hilt_m: 1, fist_m: 1, armfar_m: 1 };\nconst REST = [0, 0, 1, 2];\n// One breath is 3.4 s: the chest rises a pixel, the head follows a quarter\n// second later, and the tabard's hem swings a pixel sideways a beat after\n// that; both ends of each move are held longer than the moves between them.\nconst BREATH = 3.4;\n// The detail cut's top left corner, in figure LEDs.\nconst CUT_X = 16, CUT_Y = 6;\n\nfunction since(list, t, len) {\n  const u = t % CYCLE;\n  for (let i = 0; i \u003c list.length; i++) {\n    const d = u - list[i];\n    if (d >= 0 && d \u003c len) return d;\n  }\n  return -1;\n}\n\nfunction hash(n) {\n  n = Math.imul(n ^ (n >>> 16), 0x45d9f3b);\n  n = Math.imul(n ^ (n >>> 16), 0x45d9f3b);\n  return (n ^ (n >>> 16)) >>> 0;\n}\n\nfunction lut(ed, stand, fx, tier) {\n  const t = new Int32Array(128).fill(-1);\n  const put = (p) => {\n    for (const ch in p) t[ch.charCodeAt(0)] = p[ch];\n  };\n  put(PAL);\n  put(EDITIONS[ed]);\n  put(STANDS[stand]);\n  if (fx === 1) put(CHARGE[tier]);\n  if (fx === 2) put(HEAT[tier]);\n  return t;\n}\n\nfunction blit(buf, part, dx, dy, sweep, band) {\n  const rows = part.rows;\n  for (let j = 0; j \u003c rows.length; j++) {\n    const y = part.y + j + dy;\n    if (y \u003c 0 || y >= H) continue;\n    const r = rows[j];\n    for (let i = 0; i \u003c r.length; i++) {\n      const ch = r.charCodeAt(i);\n      if (ch === 46) continue;\n      const x = part.x + i + dx;\n      if (x \u003c 0 || x >= W) continue;\n      let c = ch;\n      if (sweep) {\n        const s = x + y * 0.5 - band;\n        if (s >= 0 && s \u003c 5) {\n          const up = UP[r[i]];\n          if (up) c = up.charCodeAt(0);\n        }\n      }\n      buf[y * W + x] = c;\n    }\n  }\n}\n\n// Into clear LEDs only, so it passes behind the figure.\nfunction under(buf, x, y, ch) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const i = y * W + x;\n  if (!buf[i]) buf[i] = ch.charCodeAt(0);\n}\n\nfunction over(buf, x, y, ch) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  buf[y * W + x] = ch.charCodeAt(0);\n}\n\n// Seconds since the sword started down, or -1.\nfunction plantSince(p, t, motion) {\n  const list = motion === 0 ? PLANTS : motion === 1 ? PLANTS_KEEN : null;\n  let d = list ? since(list, t, PLANT_LEN) : -1;\n  const b = t - p.plantAt;\n  if (b >= 0 && b \u003c PLANT_LEN) d = b;\n  return d;\n}\n\n// After the bite the stacks vent four clouds each while he leans on the sword;\n// on the overheat they also puff through every breath.\nfunction steam(buf, t, heavy, bite) {\n  const life = 1.8;\n  const at = (x0, y0, age) => {\n    if (age \u003c 0 || age >= life) return;\n    const shape = PUFF[min(5, floor(age / life * 6))];\n    const cx = floor(x0 - age * 6 + 0.5), cy = floor(y0 - 1 - age * 6 + 0.5);\n    const x1 = cx - (shape[0].length >> 1), y1 = cy - shape.length + 1;\n    for (let j = 0; j \u003c shape.length; j++) {\n      for (let i = 0; i \u003c shape[j].length; i++) if (shape[j][i] !== \".\") under(buf, x1 + i, y1 + j, shape[j][i]);\n    }\n  };\n  for (let s = 0; s \u003c STACKS.length; s++) {\n    const [x0, y0, lag] = STACKS[s];\n    if (bite >= 0) for (let n = 0; n \u003c 4; n++) at(x0, y0, t - (bite + 0.25 + n * 0.3 + lag * 0.6));\n    if (heavy) {\n      const phases = [1.3, 2.15, 3.0, 0.45];\n      for (let f = 0; f \u003c phases.length; f++) {\n        const a = phases[f] + lag;\n        at(x0, y0, t - (a + floor((t - a) / BREATH) * BREATH));\n      }\n    }\n  }\n}\n\nfunction sparks(buf, tt0, tt, seed) {\n  // Embers skid out along the stand top, most of them to the left.\n  for (let n = 0; n \u003c 6; n++) {\n    const h = hash(seed * 17 + n + 99);\n    const age = tt - tt0, life = 0.3 + (h & 7) / 30;\n    if (age \u003c 0 || age >= life) continue;\n    const v = (40 + ((h >>> 3) & 31)) * (n \u003c 4 ? -1 : 1);\n    const x = floor(BITE_X + v * age * (1 - age) + 0.5), y = BITE_Y + 1 - ((h >>> 9) & 1);\n    if (x >= 0 && x \u003c W && buf[y * W + x]) over(buf, x, y, age \u003c 0.15 ? \"w\" : \"f\");\n  }\n  for (let n = 0; n \u003c 14; n++) {\n    const h = hash(seed * 31 + n);\n    const ang = -PI * (0.35 + 0.42 * (h & 1023) / 1023);\n    const sp = 55 + ((h >>> 10) & 31), life = 0.4 + ((h >>> 15) & 15) / 30;\n    const age = tt - tt0;\n    if (age \u003c 0 || age >= life) continue;\n    const at = (q) => [floor(BITE_X + cos(ang) * sp * q + 0.5), floor(BITE_Y + sin(ang) * sp * q + 55 * q * q + 0.5)];\n    const [x, y] = at(age);\n    if (y > BITE_Y + 2) continue;\n    const [px, py] = at(max(0, age - 1 / 15));\n    const steps = max(abs(x - px), abs(y - py));\n    for (let k = 1; k \u003c steps; k++) over(buf, px + floor((x - px) * k / steps + 0.5), py + floor((y - py) * k / steps + 0.5), age \u003c 0.35 ? \"f\" : \"u\");\n    over(buf, x, y, age \u003c 0.3 ? \"w\" : \"f\");\n  }\n}\n\n// The arcs for two fifteenths of a second, worked out once from where the\n// outline is when they start.\nfunction arcs(buf, slot) {\n  const out = [];\n  const h = hash(slot * 7 + 3);\n  if (h % 3 !== 0) return out;\n  const count = 1 + ((h >>> 4) & 1);\n  for (let a = 0; a \u003c count; a++) {\n    const g = hash(h + a * 101);\n    const y0 = 22 + (g % 88), left = (g >>> 8) & 1;\n    let x = -1;\n    if (left) { for (let i = 0; i \u003c W; i++) if (buf[y0 * W + i]) { x = i; break; } }\n    else { for (let i = W - 1; i >= 0; i--) if (buf[y0 * W + i]) { x = i; break; } }\n    if (x \u003c 0) continue;\n    // A jagged run outward, never level for two steps, with a fork off its\n    // second step that kicks the other way.\n    let y = y0, fx = 0, fy = 0;\n    const len = 7 + ((g >>> 10) % 6), step = left ? -1 : 1;\n    const put = (px, py, ch) => {\n      if (py >= 0 && py \u003c H && px >= 0 && px \u003c W && !buf[py * W + px]) out.push([px, py, ch]);\n    };\n    for (let k = 1; k \u003c= len; k++) {\n      x += step;\n      y += (g >>> (12 + k)) & 1 ? 1 : -1;\n      put(x, y, k \u003c len ? \"w\" : \"Z\");\n      if (k === 3) { fx = x; fy = y; }\n    }\n    const kick = (g >>> 13) & 1 ? -1 : 1;\n    put(fx + step, fy + kick * 2, \"w\");\n    put(fx + step * 2, fy + kick * 3, \"Z\");\n    put(fx + step * 3, fy + kick * 4, \"Z\");\n  }\n  return out;\n}\n\nexport function setup(params) {\n  params.t = 0;\n  params.buf = new Uint8Array(W * H);\n  params.key = -1;\n  params.sweepAt = -10;\n  params.glintAt = -10;\n  params.plantAt = -10;\n  params.arcSlot = -1;\n  params.arcPix = [];\n  params.motion = 0;\n  params.stand = 2;\n  params.fx = 0;\n  params.zoom = false;\n  params.ed = 0;\n  params.tick = -1;\n  params.now = [0, 2, 0, 0, false];\n}\n\nexport function update(dt, input, params) {\n  if (!params.buf) setup(params);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  params.t += min(dt || 0, 0.1);\n  params.motion = min(3, max(0, floor(k[0] * 4)));\n  params.stand = min(3, max(0, floor(k[1])));\n  params.fx = min(3, max(0, floor(k[2] * 4)));\n  params.ed = min(3, max(0, floor(k[3] * 4)));\n  const b = input.btnPressed;\n  if (b && b[0] && plantSince(params, params.t, params.motion) \u003c 0) params.plantAt = params.t;\n  if (b && b[1]) params.sweepAt = params.t;\n  if (b && b[2]) params.zoom = !params.zoom;\n  if (b && b[3]) params.glintAt = params.t;\n}\n\nexport function draw(display, params) {\n  const p = params;\n  if (!p.buf) setup(p);\n  // Everything steps at 15 a second, two of the Lab's frames, so no LED can\n  // hold a state for a single frame.\n  const tick = floor(p.t * 15 + 0.25), t = tick / 15;\n  // Knobs and the cut are taken at the step too.\n  if (tick !== p.tick) {\n    p.tick = tick;\n    p.now = [p.motion, p.stand, p.fx, p.ed, p.zoom];\n  }\n  const [motion, stand, fx, ed, zoom] = p.now;\n  const buf = p.buf;\n  buf.fill(0);\n\n  const u = (((t - 1.5) % BREATH) + BREATH) % BREATH;\n  const dy = [0, u >= 1.1 && u \u003c 2.8 ? -1 : 0, u >= 1.35 && u \u003c 3.05 ? -1 : 0, 0, 0];\n  const dx = [0, 0, 0, u >= 1.45 && u \u003c 3.15 ? -1 : 0, 0];\n\n  // Shouldered, upright or planted.\n  const poseAt = (q) => {\n    const e = plantSince(p, q, motion);\n    return e \u003c 0 ? REST[motion] : e \u003c 2 / 15 ? REST[motion] === 2 ? 2 : 0 : e \u003c LIFT || e >= DOWN ? 1 : 2;\n  };\n  const d = plantSince(p, t, motion);\n  const pose = poseAt(t);\n  const sd = d >= LIFT && d \u003c DOWN ? d - LIFT : -1;\n  // He sinks into his knees a pixel as he swings, and two as the point bites;\n  // only the legs, the stand and the planted sword stay. On standby the head\n  // hangs a pixel.\n  const sink = d >= 0 && d \u003c 4 / 15 ? 1 : sd >= 0 && sd \u003c 3 / 15 ? 2 : sd >= 0 && sd \u003c 6 / 15 ? 1 : 0;\n  const wind = (d >= 0 && d \u003c 2 / 15) || (d >= LIFT - 2 / 15 && d \u003c LIFT) ? -3 : 0;\n  dy[1] += sink;\n  dy[3] += sink;\n  dy[2] += sink + (motion === 3 && d \u003c 0 ? 1 : 0);\n\n  let sw = since(SWEEPS, t, SWEEP_LEN);\n  if (t >= p.sweepAt && t - p.sweepAt \u003c SWEEP_LEN) sw = t - p.sweepAt;\n  const sweep = sw >= 0;\n  const band = -8 + (sw / SWEEP_LEN) * (W + H * 0.5 + 16);\n\n  // The case light passes over the steel above the stand; the legs and the stand keep still.\n  const order = pose === 0 ? ORDER : pose === 1 ? ORDER_M : ORDER_B;\n  for (let n = 0; n \u003c order.length; n++) {\n    const name = order[n], g = GROUP[name];\n    blit(buf, PARTS[name], dx[g] + (WIND[name] && wind ? 1 : 0), dy[g] + (g === 0 && !FIRM[name] ? sink : 0) + (WIND[name] ? wind : 0), sweep && g !== 0, band);\n  }\n\n  // The eyes: clear the visor behind them, then paint them where they look.\n  const hy = dy[2];\n  for (let y = 23; y \u003c= 25; y++) {\n    for (let x = 31; x \u003c= 46; x++) {\n      const i = (y + hy) * W + x, c = buf[i];\n      if (c === 117 || c === 102 || c === 119) buf[i] = 120;\n    }\n  }\n  // On standby the eyes are down to the ember line between the shutters.\n  const db = since(BLINKS, t, 0.3);\n  const lid = motion === 3 && d \u003c 0 ? 2 : db \u003c 0 ? 0 : db \u003c 0.08 || db >= 0.2 ? 1 : 2;\n  let look = 0;\n  if (d \u003c 0 && motion !== 3) {\n    const u2 = t % CYCLE;\n    for (let s = 0; s \u003c SCANS.length; s++) if (u2 >= SCANS[s][0] && u2 \u003c SCANS[s][0] + SCANS[s][2]) look = SCANS[s][1];\n  }\n  const mood = (d >= 0 && d \u003c LIFT + 1) || motion === 2 ? FLARE : null;\n  for (let e = 0; e \u003c EYES.length; e++) {\n    const [x, y, c] = EYES[e];\n    if (lid === 1 && y === 23) continue;\n    if (lid === 2 && y !== 24) continue;\n    over(buf, x + look, y + hy, lid === 2 ? \"v\" : mood ? mood[c] : c);\n  }\n\n  let dg = since(GLINTS, t, GLINT_LEN);\n  if (t >= p.glintAt && t - p.glintAt \u003c GLINT_LEN) dg = t - p.glintAt;\n  if (dg >= 0 && pose === 0) {\n    for (let i = 0; i \u003c GLINT.length; i++) {\n      const g = GLINT[i], at = (g[1] + dy[1]) * W + g[0];\n      if (buf[at]) buf[at] = g[2].charCodeAt(0);\n    }\n  }\n\n  if (fx === 0 || fx === 2) steam(buf, t, fx === 2 && motion !== 3, sd >= 0 ? t - sd : -1);\n  if (fx === 1) {\n    const slot = tick >> 1;\n    if (slot !== p.arcSlot) {\n      p.arcSlot = slot;\n      p.arcPix = arcs(buf, slot);\n    }\n    for (let i = 0; i \u003c p.arcPix.length; i++) under(buf, p.arcPix[i][0], p.arcPix[i][1], p.arcPix[i][2]);\n  }\n  if (fx !== 3 && sd >= 0 && sd \u003c 0.9) {\n    const t0 = t - sd;\n    sparks(buf, t0, t, floor(t0 * 10 + 0.5));\n    // His whole rim flashes white as it bites.\n    const k = floor(sd * 15 + 0.5);\n    if (k \u003c 3) for (let i = 0; i \u003c W * 104; i++) if (buf[i] === 122) buf[i] = 119;\n    // The stand's gold ring answers the bite: white, then amber.\n    if (sd \u003c 5 / 15) {\n      const ring = sd \u003c 3 / 15 ? 119 : 102;\n      for (let i = 104 * W; i \u003c H * W; i++) if (buf[i] === 78) buf[i] = ring;\n    }\n    if (sd \u003c 0.3) for (let i = 0; i \u003c SPILL.length; i++) over(buf, SPILL[i][0], SPILL[i][1], sd \u003c 0.15 ? SPILL[i][2] : \"u\");\n    const r = SHOCK[floor(sd * 15 + 0.5)];\n    if (r) {\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const x = BITE_X + s * r;\n        if (x >= 0 && x \u003c W && buf[117 * W + x]) over(buf, x, 117, \"w\");\n        if (x - s >= 0 && x - s \u003c W && buf[117 * W + x - s]) over(buf, x - s, 117, \"f\");\n      }\n    }\n    if (sd \u003c 0.14) for (let i = 0; i \u003c FLASH.length; i++) over(buf, FLASH[i][0], FLASH[i][1], FLASH[i][2]);\n  }\n\n  const tier = fx === 2 ? (u >= 1.1 && u \u003c 2.8 ? 1 : 0) : fx === 1 ? (hash((tick >> 1) * 13 + 5) % 7 === 0 ? 1 : 0) : 0;\n  const key = ed * 64 + stand * 16 + fx * 4 + tier;\n  if (key !== p.key) {\n    p.key = key;\n    p.lut = lut(ed, stand, fx, tier);\n  }\n  const L = p.lut;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const ch = zoom ? buf[(CUT_Y + (y >> 1)) * W + CUT_X + (x >> 1)] : buf[y * W + x];\n      const c = ch ? L[ch] : -1;\n      if (c \u003c 0) display.setPixel(x, y, 0, 0, 0);\n      else display.setPixel(x, y, (c >> 16) & 255, (c >> 8) & 255, c & 255);\n    }\n  }\n}\n","tamsel":"// ===== Patternflow pattern =====\n// Title:   Tamsel\n// Family:  pixel\n// Idea:    A hand-pixelled figure of Tamsel, a fourteen-year-old apprentice lamplighter, standing on a display stand that fills the panel: plum ponytail under a teal cap, long teal work coat, tall plum boots, one hand on her hip and the other on a brass lighting pole taller than she is, its hook hanging a little cage of flame over her head. She breathes, blinks, and now and then the case light runs across the gloss.\n// Author:  patternflow-lab\n// Date:    2026-11-01\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 85\n// Round:   85\n// ===============================\n// @matrix 64x128\n// @knobs Gel=0..1, Stand=0..3, Detail=0..1, Edition=0..1\n//\n// Knob 1: Gel. The colour of the rim light down her left edges and of the bounce it throws into the shadows next to it: sky blue at 0, magenta from 0.25, green from 0.5, amber from 0.75.\n// Knob 2: Stand. What she stands on: a turned wood plinth at 0, white marble from 1, black acrylic with a gold rim from 2, and from 3 an acrylic disc lit from its edge.\n// Knob 3: Detail. Below 0.5 the whole figure; from 0.5 her head and chest at exactly twice the size, the way a box shows a close-up.\n// Knob 4: Edition. The paint: the standard colours below 0.25, the second-player colours from 0.25, a gold and silver limited plating from 0.5, and from 0.75 the unpainted grey prototype.\n// Buttons: K1 tap sends the case light across her; K2 tap makes the brass on her hook wink.\n\nconst W = 64, H = 128;\n// Each part is a grid, one character per LED and \".\" where it is clear, drawn\n// in ORDER. Materials run light to dark: skin a b c d, hair and boots h i j k,\n// coat and cap p q r s, brass m n o. U V X N M are the stand, z the rim light,\n// w the specular, f g the flame, e the whites of the eyes, x the pupils.\nconst PARTS = {\n  base: { x: 6, y: 110, rows: [\n    \"....................NNNNNNNNNNN....................\",\n    \".........NNNNNNNNNNNUUUUUUUUUUNNNNNNNNNNNN.........\",\n    \".....NNNNUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUNNwN.....\",\n    \"..NNNUUUUUUUUUUXXXXXXXXXXUUUUUUUUUUUUUUUUUUUUUNNN..\",\n    \".NUUUUUUUUUUUXXXXXXXXXXXXXXUUUUUUUUUUUUUUUUUUUUUUN.\",\n    \"VNUUUUUUUUUUUUXXXXXXXXXXXXUUUUUUUUUXXXXXXXXXXUUXXNV\",\n    \"VVMMMUUUUUUUUUUUUUUUUUUUUUUUUUUUUUXXXXXXXXXXXXMMMVV\",\n    \"VVVVVMMMMUUUUUUUUUUUUUUUUUUUUUUUUUUXXXXXXXMMMMVVVVV\",\n    \"VVVVVVVVVMMMMMMMMMMMUUUUUUUUUUUMMMMMMMMMMMVVVVVVwVV\",\n    \"VVVVVVVVVVVVVVVVVVVVMMMMMMMMMMMVVVVVVVVVVVVVVVVVVVV\",\n    \"XXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXX\",\n    \"..XXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXXX..\",\n    \".....XXXXVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXXXX.....\",\n    \".........XXXXXXXXXXXVVVVVVVVVVVXXXXXXXXXXX.........\",\n    \"....................XXXXXXXXXXX....................\",\n  ] },\n  staff: { x: 54, y: 3, rows: [\n    \"...nnnw...\",\n    \"..nn..mmm.\",\n    \"onm.....mm\",\n    \"onm.....nm\",\n    \"onm.....nm\",\n    \"onm.....om\",\n    \"onm.....o.\",\n    \"onm.....o.\",\n    \"onm.....o.\",\n    \"onm...onno\",\n    \"onm...offo\",\n    \"onm...offo\",\n    \"onm...ogfo\",\n    \"onm...oggo\",\n    \"onm...onno\",\n    \"onm....oo.\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"onm.......\",\n    \"oom.......\",\n    \"ooo.......\",\n  ] },\n  hairback: { x: 3, y: 8, rows: [\n    \".............zJ................\",\n    \"...........zJJjjj..............\",\n    \"..........zJJjjjjj.............\",\n    \".........zJJjjjjjjjjj..........\",\n    \"........zJJjjjjiiijjjjjj.......\",\n    \"........zJJjjjjiiijjjjjjjj.....\",\n    \".......zJJjjjjiiiijjjjjjjjj....\",\n    \".......zJJjjjjiiijjjjjjjjjjj...\",\n    \"......zJJjjjjiiiijjjjjjjjjjjj..\",\n    \"......zJJjjjiiiijjjjjjjjjjjjj..\",\n    \".....zJJjjjhhiijjjjjjjjjjjjjjj.\",\n    \"....zKKjjjjhhiijjjjjjjjjjjjjjj.\",\n    \"....zKKkjjhhiijjjjjjjjjjjjjjjj.\",\n    \"...zKKkkjhhiiijjjjjjjjjjjjjjjj.\",\n    \"...zKKkjjhiiijjjjjjjjjjjjjjjjjj\",\n    \"..zKKkkjjiiijjjjjjjjjjjjjjjjjjj\",\n    \"..zKKkkjjiiijjjjjjjjjjjjjjjjjjj\",\n    \".zKKkkjjiiikjjjjjjjjjjjjjjjjjjj\",\n    \".zKKkkjhiiikkjjjjjjjjjjjjjjjjj.\",\n    \".zKKkjjhiikkkkjjjjjjjjjjjjjjjj.\",\n    \".zKKkjhhiikkkkkjjjjjjjjjjjjjjj.\",\n    \".zKKkjhii.zKKkkkjjjjjjjjjjjjjj.\",\n    \".zKKjjhii..zKKkkjjjjjjjjjjjjj..\",\n    \"zKKkjjii...zKKkkkjjjjjjjjjjjj..\",\n    \"zKKkjjii....zKKkkkjjjjjjjjjj...\",\n    \"zKKjjji......zKKkkkjjjjjjjj....\",\n    \"zKKjjii.......zKKkkkjjjjjj.....\",\n    \"zKKjji..........zKKkkjjj.......\",\n    \"zKJjji.............zk..........\",\n    \"zKJjj..........................\",\n    \"zJJjj..........................\",\n    \".jjj...........................\",\n  ] },\n  tailtip: { x: 3, y: 34, rows: [\n    \".jjj..\",\n    \"zKjjj.\",\n    \"zKKji.\",\n    \"zKKji.\",\n    \"zKKji.\",\n    \"zKKji.\",\n    \".zKJi.\",\n    \".zKJi.\",\n    \"..zJi.\",\n    \"..zJi.\",\n    \"..zJJ.\",\n    \"...zJ.\",\n    \"....zk\",\n    \".....z\",\n  ] },\n  armfar: { x: 38, y: 44, rows: [\n    \".qqqp...............\",\n    \"qqqqpp..............\",\n    \"qqqqqpp.............\",\n    \"qqqqqqpp............\",\n    \"qqqqqqqp............\",\n    \".qrrqqqqq......bbbb.\",\n    \".qrrrqqqqp..ssbbaaaa\",\n    \"..rrrqqqqpssssbbaaaa\",\n    \"...rrrqqqqsssbcccaab\",\n    \"....rrrqqqsssbbcbbbb\",\n    \"....rrrqqqssssccbbbb\",\n    \".....rrrqqqsssccccc.\",\n    \"......rrrrrrrr......\",\n    \".......rrrrr........\",\n    \"........rrr.........\",\n  ] },\n  legs: { x: 23, y: 80, rows: [\n    \"..jjjjj.....jjjjj................\",\n    \".jjjjjjj...jjjjjjj...............\",\n    \"jjjjjjjjj..jjjjjjj...............\",\n    \"jjjjjjjjj.jjjjjjjjj..............\",\n    \"jjjjjjjjj.jjjjjjjjj..............\",\n    \"kkkjjjjjj..kkjjjjjj..............\",\n    \"kkkjjjjjj..kkjjjjjjj.............\",\n    \"zKKjjjjii..kkjjjjjij.............\",\n    \"zKKjjjjii...zKJjjjii.............\",\n    \"zKKjjjjii...zKJjjjiij............\",\n    \"ziiiiiiii....ziiiiiij............\",\n    \"zKKkkkkkk....zKKkkkkij...........\",\n    \"zKKjjjhiw....zKKjjjiij...........\",\n    \"zKKjjjhii.....zKJjjjii...........\",\n    \"zKKjjjhii.....zKJjjjiii..........\",\n    \"zKKjjjhii.....zKJjjjjii..........\",\n    \"zKKjjjhii......zKJjjjii..........\",\n    \"zKKjjjhii......zKJjjjjii.........\",\n    \"zKKjjjhii.......zKJjjjii.........\",\n    \".zKJjjhi........zKJjjhii.........\",\n    \".zKJjjhi........zKJjjhhwi........\",\n    \".zKJjjhi.........zKJjjhii........\",\n    \".zKJjjhi.........zKJjjhii........\",\n    \".zKJjjji..........zJJjhhii.......\",\n    \".zKJjjji..........zKJjjhii.......\",\n    \".zKJjjji..........zKJjjhii.......\",\n    \".zKJjjji...........zJJjjji.......\",\n    \".zKJjjji...........zKJjjjii......\",\n    \".zKJjjji...........zKJjjjji......\",\n    \".zKJjjjj............zJJjjji......\",\n    \".zJJjjjjjii.........zJJjjjjj.....\",\n    \"..jjjjjjiiiii........jjjjjj......\",\n    \".jjjjjjjjiiijj.......jjjjjjjiii..\",\n    \".jjjjjjjjjjjjj.......jjjjjjiiiiij\",\n    \"..kkkkjjjkkkk........jjjjjjjjiijj\",\n    \"......kkk............kkjjjjjjjjkk\",\n    \".......................kkkkkkkk..\",\n  ] },\n  skirt: { x: 13, y: 63, rows: [\n    \".........rrrrrqqqqqqqqqqqqqqqq......\",\n    \".........rrrrrqqqqqqqqqqqqqqqq......\",\n    \".........rrrrrqqqqqqqqqqqqqqqq......\",\n    \"........rrrrrrqqqqqqqqqqqqqppp......\",\n    \"........rrrrrrqqqqqqqqqqqqqpppq.....\",\n    \".......rrrrrrrqqqqqqqqqqqqqpppq.....\",\n    \".......rrrrrrrqqqqqqqqqqqqqpppq.....\",\n    \".......zRRrrrrqqqqrqqqqqqqqpppp.....\",\n    \"......zRRrrrrrqqqqrqqqqqqqqppppq....\",\n    \"......zRRrrrrrqqqqrqqqqqqqqqpppq....\",\n    \".....zRRrrrrrrqqqqrqqqqqqqqqpppp....\",\n    \".....zRRrrrrrrqqqqrqqqqqqqqqpppp....\",\n    \".....zRRrrrrrrqqqqrrqqqqqqqqppppq...\",\n    \"....zRRrrrrrrrqqqqrrqqqqqqqqppppq...\",\n    \"....zRRrrrrrrrqqqqrrqqqqqqqqqpppp...\",\n    \"....zRRrrrrrrrqqqqrrqqqqqqqqqpppp...\",\n    \"...zRRrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"...zRRrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"..zRRrrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"..zRRrrrrrrrrqqqqqrrqqqqqqqqqppppp..\",\n    \"..zRRrrrrrrrrqqqqqrrqqqqqqqqqqppppp.\",\n    \".zRRrrrrrrrrrqqqqqrrqqqqqqqqqqppppp.\",\n    \".zRRrrrrrrrrrqqqqqrrqqqqqqqqqqppppp.\",\n    \"zTTssssssssssssqqqrrqqqqqqqqqqppppp.\",\n    \"...............ssssssssssssssqpppppp\",\n    \".............................ssqqqqq\",\n  ] },\n  torso: { x: 19, y: 39, rows: [\n    \"..........zQQqq...........\",\n    \"......zQQqqqqqppppp.......\",\n    \".....zRRrqqqpppppppp......\",\n    \"....zRRrrqqqppppppppp.....\",\n    \"....zRRrrqqqqppppppppppp..\",\n    \".....zRRrqqqqqpppppqpppp..\",\n    \".rrrrrrrrqqqqqqqqqqqppppp.\",\n    \".rrrrrrrrqqqqqqqqqqqppppp.\",\n    \".rrrrrqssssssssssssqpppppp\",\n    \"rrrrrrqqqqqqqqqqqrpqpppppp\",\n    \"rrrrrrqqqqqqqqqqqrpqqppppp\",\n    \"rrrrrrrqqqqqqqqqqrpqqppppp\",\n    \"rrrrrrrqqqqqqqqqqrpqqppppp\",\n    \".rrrrrrqqqqqqqqqqrpqqpppp.\",\n    \".rrrrrrqqqqqqqqqqrpqqpppp.\",\n    \".zRRrrrqqqqqqqqqqrpqqpppp.\",\n    \".zRRrrrqqqqqqqqqqrpqqpppp.\",\n    \".zRRrrrqqqqqqqqqqqrpqpppp.\",\n    \"..zRRrrrqqqqqqqqqqrpqpppp.\",\n    \"..zRRrrrqqqqqqqqqqrpqpppp.\",\n    \"..zRRrrrqqqqqqqqqqrpqppp..\",\n    \"..zRRrrrqqqqqqqqqqrpqppp..\",\n    \"..zRRrrrqqqqqqqqqqrpqppp..\",\n    \"...zRRrrqqqqqqqqqqrpqppp..\",\n    \"...rrrrrqqqqqqqqqqqqqppp..\",\n    \"...rrrrrqqqqqqqqqqqqqppp..\",\n    \"...rrrrrqqqqqqqqqqqqqppp..\",\n  ] },\n  belt: { x: 22, y: 63, rows: [\n    \"kkkkkkkkkjjjjnnnjjjjjj\",\n    \"kkkkkkkkkiiiinwoiiiiii\",\n    \".kkkkkkkkkkkknookkkkk.\",\n  ] },\n  armnear: { x: 5, y: 44, rows: [\n    \"...............zQQ..\",\n    \"..............zppqq.\",\n    \"............zppppqqq\",\n    \"...........zppppqqqq\",\n    \"..........zpppqqqqqq\",\n    \"........zppppqqqqqqq\",\n    \".......zpppqqrrqqqq.\",\n    \"......zpppqqrrrqqq..\",\n    \"....zppppqqrrrqqq...\",\n    \"...zpppqqqrrrqq.....\",\n    \"..zpppqqqrrrqq......\",\n    \".zQQqqqqrrrr........\",\n    \"zQQqqqrrrrr.........\",\n    \"zQQqqrrrq...........\",\n    \"zQQqqrrqqq..........\",\n    \".zQQqrqqqqq.........\",\n    \"..zRRqqqqsss........\",\n    \"...zRRqqssqqq.......\",\n    \"....zRRqssqqqs......\",\n    \"......zTTssqssbbb...\",\n    \".......zTTsssbbaaaa.\",\n    \"........zTTsbbbaaaaa\",\n    \".........zTTbbbaaab.\",\n    \"...........zccbbbbb.\",\n    \"............zccccc..\",\n    \"..............ccc...\",\n  ] },\n  neck: { x: 29, y: 35, rows: [\n    \"cccccc\",\n    \"cccccc\",\n    \"dddddd\",\n    \"dddddc\",\n    \"cccccc\",\n    \"cccccc\",\n    \"cccccc\",\n    \"cccccc\",\n  ] },\n  head: { x: 26, y: 16, rows: [\n    \".......bbbbbbb.......\",\n    \".....bbbbbbbbbbb.....\",\n    \"....bbbbbbbbbbbbb....\",\n    \"...bbbbbbbbbbbbbbb...\",\n    \"..cccbbbbccbbbccbcc..\",\n    \".cccccbccbbbbbbbbbbb.\",\n    \".cccccbbbbbbbbbbbbba.\",\n    \"ccccccbbbbbbbbbxxxbaa\",\n    \"ccccccbxxxxbbbxbbbxaa\",\n    \"ccccccxbbbbbbbbbbbbaa\",\n    \"ccccccbxxxxbbbbxxxbaa\",\n    \"ccccccbaxxabbbbxxabaa\",\n    \"cccccccaxxgbbbbxxgaaa\",\n    \"cccccccagggbbbbgggaaa\",\n    \".cccccccggbbbbbbgbaa.\",\n    \".cccccccbbbbbbbbbbaaa\",\n    \"..ccccccbbbbbbbbbbbc.\",\n    \"...ccccccbbbbbbbbbb..\",\n    \"....ccccccbbbbbdbb...\",\n    \".....ccccccbcddbb....\",\n    \".......cccccccccc....\",\n    \".........ccccccc.....\",\n  ] },\n  hairfront: { x: 16, y: 4, rows: [\n    \".........zQQqqqqqqppp..............\",\n    \".....zQQqqqqqqqqppppppppp..........\",\n    \"...zRRqqqqqqqqqpppppppppppp........\",\n    \"..zRRrqqqqqqqqqppppppppppppp.......\",\n    \".rrrrrqqqqqqqqqpppppppppppppp......\",\n    \"rrrrrrqqqqqqqqqqppppppppppppqq.....\",\n    \"rrrrrrrrrqqqqqqqqqqppppppqqqqq.....\",\n    \"rrrrrrrrrrrrrrqqqqqqqqqqqqqqqq.....\",\n    \"rrrrrrrrrrrrrrqqqqqqqqpppppppppppp.\",\n    \"rrrrrrrrrrrrrrqqqqqqqqppppppppppqqq\",\n    \".ssssssssssssskkkkkkkkkkkkkkkkkqqqq\",\n    \"..............kkkkkkkkkkkkkkkkkssss\",\n    \"...............jjjjjjjjjjjjjjjj....\",\n    \"........k......jjjjjjjjjjiiiiii....\",\n    \"........kkjjjii.jjjjjjjjjihhhii....\",\n    \"........kkjjjii.jjjjjjjjjiiiiii....\",\n    \"........kkjjjii..jj..jjj..i..ii....\",\n    \"........kkjjjii.......j...i........\",\n    \"........kkjjjii....................\",\n    \"........kkjjjii....................\",\n    \"........kkjjjii....................\",\n    \".........kjjji.....................\",\n    \".........kjjji.....................\",\n    \".........kjjji.....................\",\n    \".........kkjji.....................\",\n    \".........kkjji.....................\",\n    \".........kkjji.....................\",\n    \".........kkjji.....................\",\n    \"..........kjj......................\",\n    \"..........kjj......................\",\n    \"..........jjj......................\",\n    \"...........jj......................\",\n  ] },\n};\nconst ORDER = [\"base\", \"staff\", \"hairback\", \"tailtip\", \"armfar\", \"legs\", \"skirt\", \"torso\", \"belt\", \"armnear\", \"neck\", \"head\", \"hairfront\"];\n// Which breath each part follows: 0 stays, 1 the chest, 2 the head a beat later, 3 the ponytail's end.\nconst GROUP = {\"base\": 0, \"staff\": 0, \"hairback\": 2, \"tailtip\": 3, \"armfar\": 1, \"legs\": 0, \"skirt\": 0, \"torso\": 1, \"belt\": 0, \"armnear\": 1, \"neck\": 1, \"head\": 2, \"hairfront\": 2};\n// The eyes half shut and shut, laid over the head.\nconst LIDS = {\n  half: { x: 33, y: 26, rows: [\n    \"bbbb....bbb\",\n    \"xxxx....xxx\",\n  ] },\n  shut: { x: 33, y: 26, rows: [\n    \"bbbb....bbb\",\n    \"bbbb....bbb\",\n    \"bbbb....bbb\",\n    \"xxxx....xxx\",\n    \"bbbb....bbb\",\n  ] },\n};\nconst PAL = { a: 0xf9e1d1, b: 0xe9b9a8, c: 0xcb8b86, d: 0xa0606b, h: 0xe3a3c6, i: 0xb267a9, j: 0x764492, k: 0x423276, p: 0x9edfc6, q: 0x50ada2, r: 0x267b80, s: 0x005362, m: 0xf7e8b3, n: 0xd6b075, o: 0x9e7a60, U: 0x5f74a3, V: 0x464c7f, X: 0x3b2f61, f: 0xffefaf, g: 0xfdae3a, w: 0xfffaf0, z: 0x8cccff, e: 0xe2dcec, N: 0xd6b075, M: 0xf7e8b3, x: 0x3b2f61, K: 0x423276, R: 0x267b80, T: 0x005362, J: 0x764492, Q: 0x50ada2 };\n// Knob 4: the editions, each a hand-picked repaint of some materials.\nconst EDITIONS = [\n  {  },\n  { p: 0xfcb6a4, q: 0xdf6f71, r: 0xab4660, s: 0x752d4f, h: 0x90c3d9, i: 0x2e89b8, j: 0x005d97, k: 0x1c3c73, K: 0x1c3c73, R: 0xab4660, T: 0x752d4f, J: 0x005d97, Q: 0xdf6f71 },\n  { p: 0xeae8e0, q: 0xadb7c0, r: 0x77828e, s: 0x4c5564, h: 0xf2e2a9, i: 0xd7b06d, j: 0xaf7c4d, k: 0x7e4d38, a: 0xf8dec6, b: 0xe1b198, c: 0xbc8374, d: 0x8f5a58, K: 0x7e4d38, R: 0x77828e, T: 0x4c5564, J: 0xaf7c4d, Q: 0xadb7c0 },\n  { a: 0xe6e2df, b: 0xc4c0be, c: 0x999593, d: 0x706c6a, h: 0xb9b5b3, i: 0x84807e, j: 0x5c5957, k: 0x403d3b, p: 0xd5d1ce, q: 0xa19d9b, r: 0x726f6d, s: 0x4e4b49, m: 0xede7e3, n: 0xbbb5b1, o: 0x86807d, f: 0xede7e3, g: 0xbbb5b1, e: 0xdbd6d4, x: 0x494644, K: 0x403d3b, R: 0x726f6d, T: 0x4e4b49, J: 0x5c5957, Q: 0xa19d9b },\n];\n// Knob 2: the stands.\nconst STANDS = [\n  { U: 0xb2815f, V: 0x8d5541, X: 0x67332f, N: 0xcea378, M: 0xe0c29b },\n  { U: 0xd5d7dd, V: 0xa9abb2, X: 0x797c84, N: 0xb5b5c0, M: 0xe1e2e8 },\n  {  },\n  { U: 0x00658c, V: 0x00bcd9, X: 0x0084a8, N: 0x7de1ed, M: 0xc1f8f9 },\n];\n// Knob 1: the gels on the rim light, with the shadow-side bounce they tint.\nconst GELS = [\n  {  },\n  { z: 0xfb6acd, K: 0x74266e, R: 0x7b4c89, T: 0x5f376b, J: 0x9f3d88, Q: 0x9f87b9 },\n  { z: 0x81ef7e, K: 0x004d41, R: 0x297554, T: 0x005742, J: 0x006c6f, Q: 0x5ab788 },\n  { z: 0xffbf5d, K: 0x7c343b, R: 0x866139, T: 0x6e3f2a, J: 0xa04657, Q: 0x98a76d },\n];\n// The wink on the hook: x, y and what the LED turns into.\nconst GLINT = [[60, 3, \"w\"], [59, 3, \"w\"], [61, 4, \"w\"]];\n// The case light: what a glossy character turns into while the band passes.\nconst UP = {\"j\": \"i\", \"J\": \"i\", \"i\": \"h\", \"k\": \"j\", \"K\": \"j\", \"n\": \"m\", \"o\": \"n\", \"N\": \"M\"};\n\nconst { floor, min, max } = Math;\n// The events run on a fixed 25 s loop. Blinks come 2.2 to 4.2 s apart, the\n// case light every 7.8 to 9.4 s, taking 2.4 s to cross, the glint on the hook every 6 or more; none\n// falls between 1.5 and 2.5 s, where the still is taken.\nconst CYCLE = 25;\nconst BLINKS = [0.9, 3.4, 6.1, 8.3, 11.9, 14.6, 16.9, 20.4, 23.1];\nconst SWEEPS = [4.6, 12.4, 20.2];\nconst GLINTS = [3.0, 9.6, 15.8, 22.0];\nconst SWEEP_LEN = 2.4;\nconst GLINT_LEN = 0.17;\n// One breath is 3.2 s: the chest rises a pixel, the head follows a quarter\n// second later and the ponytail's end a tenth after that, and both ends of the\n// breath are held longer than the moves between them.\nconst BREATH = 3.2;\n// The detail cut's top left corner, in figure LEDs.\nconst CUT_X = 20, CUT_Y = 3;\n\nfunction since(list, t, len) {\n  const u = t % CYCLE;\n  for (let i = 0; i \u003c list.length; i++) {\n    const d = u - list[i];\n    if (d >= 0 && d \u003c len) return d;\n  }\n  return -1;\n}\n\nfunction lut(ed, stand, gel) {\n  const t = new Int32Array(128).fill(-1);\n  const put = (p) => {\n    for (const ch in p) t[ch.charCodeAt(0)] = p[ch];\n  };\n  put(PAL);\n  put(EDITIONS[ed]);\n  put(STANDS[stand]);\n  put(GELS[gel]);\n  return t;\n}\n\nfunction blit(buf, part, dx, dy, sweep, band) {\n  const rows = part.rows;\n  for (let j = 0; j \u003c rows.length; j++) {\n    const y = part.y + j + dy;\n    if (y \u003c 0 || y >= H) continue;\n    const r = rows[j];\n    for (let i = 0; i \u003c r.length; i++) {\n      const ch = r.charCodeAt(i);\n      if (ch === 46) continue;\n      const x = part.x + i + dx;\n      if (x \u003c 0 || x >= W) continue;\n      let c = ch;\n      if (sweep) {\n        const s = x + y * 0.5 - band;\n        if (s >= 0 && s \u003c 6) {\n          const up = UP[r[i]];\n          if (up) c = up.charCodeAt(0);\n        }\n      }\n      buf[y * W + x] = c;\n    }\n  }\n}\n\nexport function setup(params) {\n  params.t = 0;\n  params.buf = new Uint8Array(W * H);\n  params.key = -1;\n  params.sweepAt = -10;\n  params.glintAt = -10;\n  params.gel = 0;\n  params.stand = 2;\n  params.zoom = false;\n  params.ed = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.buf) setup(params);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  params.t += min(dt || 0, 0.1);\n  params.gel = min(3, max(0, floor(k[0] * 4)));\n  params.stand = min(3, max(0, floor(k[1])));\n  params.zoom = k[2] >= 0.5;\n  params.ed = min(3, max(0, floor(k[3] * 4)));\n  const b = input.btnPressed;\n  if (b && b[0]) params.sweepAt = params.t;\n  if (b && b[1]) params.glintAt = params.t;\n}\n\nexport function draw(display, params) {\n  const p = params;\n  if (!p.buf) setup(p);\n  const t = p.t;\n  const key = p.ed * 16 + p.stand * 4 + p.gel;\n  if (key !== p.key) {\n    p.key = key;\n    p.lut = lut(p.ed, p.stand, p.gel);\n  }\n  const buf = p.buf;\n  buf.fill(0);\n\n  const u = (((t - 1.5) % BREATH) + BREATH) % BREATH;\n  const off = [0, u >= 1.1 && u \u003c 2.7 ? -1 : 0, u >= 1.35 && u \u003c 2.95 ? -1 : 0, u >= 1.45 && u \u003c 3.05 ? -1 : 0];\n\n  let sw = since(SWEEPS, t, SWEEP_LEN);\n  if (t - p.sweepAt \u003c SWEEP_LEN) sw = t - p.sweepAt;\n  const sweep = sw >= 0;\n  const band = -8 + (sw / SWEEP_LEN) * (W + H * 0.5 + 16);\n\n  // The case light passes over the gloss above the stand; the boots and the stand keep still.\n  for (let n = 0; n \u003c ORDER.length; n++) {\n    const name = ORDER[n];\n    blit(buf, PARTS[name], 0, off[GROUP[name]], sweep && name !== \"legs\" && name !== \"base\", band);\n  }\n\n  const db = since(BLINKS, t, 0.3);\n  if (db >= 0) blit(buf, db \u003c 0.08 || db >= 0.2 ? LIDS.half : LIDS.shut, 0, off[2], false, 0);\n\n  let dg = since(GLINTS, t, GLINT_LEN);\n  if (t - p.glintAt \u003c GLINT_LEN) dg = t - p.glintAt;\n  if (dg >= 0) {\n    for (let i = 0; i \u003c GLINT.length; i++) {\n      const g = GLINT[i], at = g[1] * W + g[0];\n      if (buf[at]) buf[at] = g[2].charCodeAt(0);\n    }\n  }\n\n  const L = p.lut;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const ch = p.zoom ? buf[(CUT_Y + (y >> 1)) * W + CUT_X + (x >> 1)] : buf[y * W + x];\n      const c = ch ? L[ch] : -1;\n      if (c \u003c 0) display.setPixel(x, y, 0, 0, 0);\n      else display.setPixel(x, y, (c >> 16) & 255, (c >> 8) & 255, c & 255);\n    }\n  }\n}\n","alphabet-lineage":"// ===== Patternflow pattern =====\n// Title:   Alphabet Lineage\n// Family:  type\n// Idea:    A four letter Latin word stacked down the tall panel starts as Proto-Sinaitic pictures, an ox head, a house, water, a human head, and every letter's strokes bend through Phoenician, written right to left, turn over like a card to face the other way as Greek, and settle as Roman capitals with thick and thin strokes and serifs, the letters one after another so the column can hold four eras at once.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the alphabet's descent from Proto-Sinaitic (Wadi el-Hol and Serabit el-Khadim, c. 1850 BCE; read by Alan Gardiner, The Egyptian origin of the Semitic alphabet, 1916) through Phoenician (c. 1050 BCE) and archaic Greek (c. 750 BCE) to Roman inscriptional capitals (1st century); letter shapes drawn for this pattern, pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Lag=0..1\n//\n// Knob 1: Hue. Turns the four era colours round the wheel together. At 0 the pictographs are gold, Phoenician purple, Greek azure and the Roman capitals warm white.\n// Knob 2: Speed. At 2 a letter holds each era 1.2 to 2.6 s and takes 1.8 s to bend into the next, and a whole history with its 1.4 s rewind takes 13.4 s; every time goes as 2 / Speed.\n// Knob 3: Word. 0 ROMA, 1 AMOR, 2 ARMA, 3 DONA, 4 BONA, 5 MORA, Latin words that between them use all seven letters drawn here: A, B, D, M, N, O and R.\n// Knob 4: Lag. How far each letter runs behind the one above, in eras: 0.06 at the opening, so the word changes almost as one; at 1 the column shows four eras at once, the top letter a Roman capital while the bottom one is still a picture.\n\n// Each letter is a few strokes, and each stroke is a polyline in every era,\n// on a 10 by 10 grid with y down. A stroke is resampled to the same number\n// of points by arc length in every era, so one era's stroke bends into the\n// next point by point. A stroke that is not there in an era has alpha 0 and\n// borrows its shape from the next era that has it.\n//\n// Between two eras a letter may also turn. The ox head lies down on its\n// side as Phoenician aleph and stands up again, upside down, as alpha; the\n// Greek delta lies on its side to round into D. When Greek settled on\n// writing left to right, letters that face a way turned to face the other:\n// Phoenician beth, mem, nun and resh look left, Greek beta, mu, nu and rho\n// look right. So between Phoenician and Greek every letter except the ox\n// head turns over about its upright axis, like a card. The morph bends the\n// stroke toward the next era's shape seen from before the turn, and turns\n// it on the way; at the end of the morph the turn is complete and the\n// stroke is the next era's.\n//\n// The pen is round and a little thinner each era back. The Roman capitals\n// get the shading of a broad edged brush held at 30 degrees, thick where a\n// stroke runs across the edge and thin along it (Edward Catich, The Origin\n// of the Serif, 1968), and short serifs fade in at their feet.\n//\n// Phoenician and archaic Greek shapes and stroke directions were checked\n// against the Unicode reference glyphs in Noto Sans Phoenician and Noto\n// Sans Old Italic; the coordinates are drawn here, not copied.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, abs, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst K = 36;\n\n// Era colours at Hue 0 (h, s), widths of the round pen in grid units.\nconst ERA = [[0.12, 0.7], [0.82, 0.62], [0.56, 0.7], [0.09, 0.16]];\nconst PEN = [0.3, 0.34, 0.37, 0.4];\n// Seconds at Speed 2: hold in each era, the bend between, the rewind.\nconst HOLD = [1.6, 1.2, 1.2, 2.6], BEND = 1.8, BACK = 1.4;\nconst CYCLE = HOLD[0] + HOLD[1] + HOLD[2] + HOLD[3] + 3 * BEND + BACK;\n\nconst WORDS = [\"ROMA\", \"AMOR\", \"ARMA\", \"DONA\", \"BONA\", \"MORA\"];\n\n// Per letter: the turn between eras 0-1, 1-2, 2-3 as [degrees clockwise,\n// mirrored], and the strokes as [alpha per era, shape per era]. A shape is\n// \"x,y x,y ...\"; a closed stroke ends where it starts; \"\" borrows.\nconst LETTERS = {\n  // ʾalp, the ox head, muzzle down -> aleph on its side -> alpha -> A.\n  A: {\n    turn: [[90, 0], [90, 0], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"3,3.2 3.4,6 4.1,8.2 5,9.1 5.9,8.2 6.6,6 7,3.2\",\n        \"7.9,1.3 4.5,3.7 1,6.3 5.4,6.2 9.7,6.1\",\n        \"8.4,9.5 6.7,5 5,0.6 3.3,5 1.6,9.5\",\n        \"9,9.4 7,4.9 5,0.4 3,4.9 1,9.4\",\n      ]],\n      [[1, 1, 1, 1], [\n        \"0.6,0.8 1.4,2.4 2.6,3.3 5,3.7 7.4,3.3 8.6,2.4 9.4,0.8\",\n        \"3.6,0.6 4.8,5 6.1,9.4\",\n        \"7.1,5.6 2.9,6.4\",\n        \"7.2,6.5 2.8,6.5\",\n      ]],\n      [[1, 0, 0, 0], [\"4.1,5 4.3,5.2\", \"\", \"\", \"\"]],\n      [[1, 0, 0, 0], [\"5.9,5 5.7,5.2\", \"\", \"\", \"\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"-0.2,9.4 2.4,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"7.6,9.4 10.2,9.4\"]],\n    ],\n  },\n  // bayt, the plan of a house with its door in the front wall -> beth ->\n  // beta -> B.\n  B: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"6,8.6 8.6,8.6 8.6,1.4 1.4,1.4 1.4,8.6 4,8.6\",\n        \"6.9,5 1.2,4.6 5.8,0.6 6.6,2.6 6.9,5 6.4,7.6 4.4,9 1.8,9.4\",\n        \"2.4,4.8 6.4,4.2 7.4,2.4 6.2,0.8 2.4,0.6 2.4,9.4 7,9.2 8.2,7.2 7,5.2 2.4,4.8\",\n        \"2.2,4.7 5.6,4.6 6.8,3.8 7,2.5 6.6,1.3 5.4,0.6 2.2,0.6 2.2,9.4 6,9.4 7.6,8.6 8,7 7.4,5.5 5.8,4.8 2.2,4.7\",\n      ]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,0.6 2.4,0.6\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,9.4 2.4,9.4\"]],\n    ],\n  },\n  // dalt, a door with its leaf -> daleth -> delta -> D, the delta laid on\n  // its side as western Greek and Latin wrote it.\n  D: {\n    turn: [[0, 0], [0, 1], [90, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"2.4,0.8 7.6,0.8 7.6,9.2 2.4,9.2 2.4,0.8\",\n        \"4.6,0.8 1.6,6 6.4,6 4.6,0.8\",\n        \"5,0.8 0.8,9.2 9.2,9.2 5,0.8\",\n        \"2.2,0.6 5,0.6 7.4,1.8 8.6,3.8 8.8,5 8.6,6.2 7.4,8.2 5,9.4 2.2,9.4 2.2,0.6\",\n      ]],\n      [[1, 1, 0, 0], [\"5.6,2.2 6.4,5 5.6,7.8\", \"6.4,6 8.2,9.2\", \"9.2,9.2 9.2,9.2\", \"\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,0.6 2.4,0.6\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,9.4 2.4,9.4\"]],\n    ],\n  },\n  // mem, water -> mem with its tail -> mu, long left leg -> M.\n  M: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"0.4,4 1.6,6 2.8,4 4,6 5.2,4 6.4,6 7.6,4 8.8,6 9.6,4.6\",\n        \"1.1,0.6 3,3 4.7,1.3 6.4,3 9,0.8 8.4,4.8 6.6,8 4,9.6\",\n        \"0.9,9.4 3,0.6 5.4,5.9 7.7,0.6 9.6,5.2\",\n        \"1,9.4 2.1,0.6 5,9.4 7.9,0.6 9,9.4\",\n      ]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"-0.2,9.4 2,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"8,9.4 10.2,9.4\"]],\n    ],\n  },\n  // nun, a snake -> nun -> nu, long left leg -> N.\n  N: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"1.4,1.4 2.4,0.6 3.4,1.2 3.6,2.8 5.4,3.4 7.4,2.6 8,4.2 6.6,6 4.6,7 4.4,8.6 6,9.6\",\n        \"1.8,0.6 3.8,3.6 7.4,1.2 6.4,5.6 3.2,9.6\",\n        \"1.2,9.4 3.2,0.6 6.4,6.4 8.8,0.6\",\n        \"1.6,9.4 1.6,0.6 8.4,9.4 8.4,0.6\",\n      ]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.6,9.4 2.6,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"7.4,0.6 9.4,0.6\"]],\n    ],\n  },\n  // ʿayin, an eye -> ayin -> omicron -> O.\n  O: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"0.4,5 1.8,3.4 3.4,2.5 5,2.2 6.6,2.5 8.2,3.4 9.6,5 8.2,6.6 6.6,7.5 5,7.8 3.4,7.5 1.8,6.6 0.4,5\",\n        \"circle 5,5 3.4\",\n        \"circle 5,5 3.9\",\n        \"circle 5,5 4.5\",\n      ]],\n      [[1, 0, 0, 0], [\"circle 5,5 1.3\", \"circle 5,5 0.2\", \"\", \"\"]],\n    ],\n  },\n  // rōš, a head in profile looking left -> resh -> rho -> R, whose leg\n  // Latin kept to tell it from its own P.\n  R: {\n    turn: [[0, 0], [0, 1], [0, 0]],\n    strokes: [\n      [[1, 1, 1, 1], [\n        \"5.8,9.6 5.8,6.8 7.2,5 7.6,3 6.6,1.2 4.4,0.6 2.4,1.6 1.2,3.4 2.2,3.9 2,4.8 2.8,5.8 4.2,6.2 5.8,6.8\",\n        \"7.8,9.6 6.4,4.4 5.2,0.6 1.4,3.6 6.4,4.4\",\n        \"2.4,9.4 2.4,0.6 6,0.6 7.6,1.6 7.8,3 6.8,4.6 2.4,5\",\n        \"2.2,9.4 2.2,0.6 5.4,0.6 7,1.2 7.6,2.6 7,4 5.4,4.8 2.2,4.8\",\n      ]],\n      [[0, 0, 1, 1], [\"5.8,6.8 5.8,6.8\", \"6.4,4.4 6.4,4.4\", \"4.2,4.9 4.2,4.9\", \"4.4,4.8 6.4,7 8.6,9.4\"]],\n      [[1, 0, 0, 0], [\"3.4,2.6 3.6,2.8\", \"\", \"\", \"\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,0.6 2.4,0.6\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"0.8,9.4 3.6,9.4\"]],\n      [[0, 0, 0, 1], [\"\", \"\", \"\", \"7.8,9.4 10,9.4\"]],\n    ],\n  },\n};\n\nfunction parse(text) {\n  if (text.startsWith(\"circle\")) {\n    const [, c, r] = text.split(\" \"), [x, y] = c.split(\",\").map(Number), rr = Number(r), pts = [];\n    // Starts at the left, as the eye does, and runs clockwise.\n    for (let i = 0; i \u003c= 24; i++) pts.push([x - rr * cos((i / 24) * 2 * PI), y - rr * sin((i / 24) * 2 * PI)]);\n    return pts;\n  }\n  return text.split(\" \").map((t) => t.split(\",\").map(Number));\n}\n\n// K points evenly along the polyline.\nfunction resample(pts) {\n  const L = [0];\n  for (let i = 1; i \u003c pts.length; i++) L.push(L[i - 1] + Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]));\n  const total = L[L.length - 1], out = [];\n  let j = 1;\n  for (let k = 0; k \u003c K; k++) {\n    const s = (total * k) / (K - 1);\n    while (j \u003c pts.length - 1 && L[j] \u003c s) j++;\n    const seg = L[j] - L[j - 1] || 1, t = total ? cl((s - L[j - 1]) / seg, 0, 1) : 0;\n    out.push([pts[j - 1][0] + (pts[j][0] - pts[j - 1][0]) * t, pts[j - 1][1] + (pts[j][1] - pts[j - 1][1]) * t]);\n  }\n  return out;\n}\n\n// The turn between two eras, about the middle of the grid, and back.\nfunction turn(pts, deg, mir, back) {\n  const a = ((back ? -deg : deg) * PI) / 180, c = cos(a), s = sin(a);\n  return pts.map(([x, y]) => {\n    let dx = x - 5, dy = y - 5;\n    if (mir && !back) dx = -dx;\n    let rx = dx * c - dy * s, ry = dx * s + dy * c;\n    if (mir && back) rx = -rx;\n    return [5 + rx, 5 + ry];\n  });\n}\n\nconst closed = (p) => Math.hypot(p[0][0] - p[K - 1][0], p[0][1] - p[K - 1][1]) \u003c 1e-6;\nconst gap = (a, b) => a.reduce((s, p, i) => s + (p[0] - b[i][0]) ** 2 + (p[1] - b[i][1]) ** 2, 0);\n\n// The target turned to face the source the nearest way: reversed if open,\n// and for a closed stroke also started at the best point.\nfunction align(src, tgt) {\n  let best = tgt, bg = gap(src, tgt);\n  const rev = tgt.slice().reverse();\n  if (gap(src, rev) \u003c bg) {\n    best = rev;\n    bg = gap(src, rev);\n  }\n  if (closed(tgt)) {\n    const ring = tgt.slice(0, K - 1);\n    for (const dir of [ring, ring.slice().reverse()])\n      for (let sft = 0; sft \u003c K - 1; sft++) {\n        const c = [];\n        for (let i = 0; i \u003c K - 1; i++) c.push(dir[(i + sft) % (K - 1)]);\n        c.push(c[0]);\n        const g = gap(src, c);\n        if (g \u003c bg) {\n          bg = g;\n          best = c;\n        }\n      }\n  }\n  return best;\n}\n\n// Every letter's strokes for every era and every bend.\nfunction build() {\n  const out = {};\n  for (const ch in LETTERS) {\n    const L = LETTERS[ch], strokes = [];\n    for (const [alpha, shapes] of L.strokes) {\n      const g = shapes.map((t) => (t ? resample(parse(t)) : null));\n      for (let e = 1; e \u003c 4; e++) if (!g[e] && g[e - 1]) g[e] = turn(g[e - 1], L.turn[e - 1][0], L.turn[e - 1][1], false);\n      for (let e = 2; e >= 0; e--) if (!g[e] && g[e + 1]) g[e] = turn(g[e + 1], L.turn[e][0], L.turn[e][1], true);\n      // For each bend, the next era's shape seen from before the turn.\n      const to = [0, 1, 2].map((e) => align(g[e], turn(g[e + 1], L.turn[e][0], L.turn[e][1], true)));\n      strokes.push({ alpha, g, to });\n    }\n    out[ch] = { turn: L.turn, strokes };\n  }\n  return out;\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n}\n\nconst ease = (u) => u * u * (3 - 2 * u);\n\n// The era position 0..3 of a letter whose own clock reads t seconds.\nfunction eraAt(t) {\n  if (t \u003c= 0) return 0;\n  t %= CYCLE;\n  let x = 0;\n  for (let e = 0; e \u003c 3; e++) {\n    if (t \u003c HOLD[e]) return e;\n    t -= HOLD[e];\n    if (t \u003c BEND) return e + t / BEND;\n    t -= BEND;\n  }\n  if (t \u003c HOLD[3]) return 3;\n  t -= HOLD[3];\n  x = 3 * (1 - ease(t / BACK));\n  return x;\n}\n\nexport function setup(params) {\n  params.s = { glyphs: build(), clock: 0, hue: 0, word: 0, lag: 0.06, ink: new Float32Array(N), owner: new Int8Array(N) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.clock += cl(dt || 0, 0, 0.1) * (speed / 2);\n  S.hue = k[0] || 0;\n  S.word = round(cl(k[2] || 0, 0, WORDS.length - 1));\n  S.lag = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n}\n\n// Distance from (px, py) to the segment a-b.\nfunction seg(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n  const t = L2 > 1e-9 ? cl(((px - ax) * dx + (py - ay) * dy) / L2, 0, 1) : 0;\n  const ex = px - ax - t * dx, ey = py - ay - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// Ink a segment with a round pen of radius w and a soft halo.\nfunction stamp(S, band, ax, ay, bx, by, w, a) {\n  const x0 = max(0, floor(min(ax, bx) - w - 3)), x1 = min(W - 1, floor(max(ax, bx) + w + 3));\n  const y0 = max(0, floor(min(ay, by) - w - 3)), y1 = min(H - 1, floor(max(ay, by) + w + 3));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const d = seg(x + 0.5, y + 0.5, ax, ay, bx, by);\n      const v = a * max(cl(w + 0.5 - d, 0, 1), 0.34 * exp(-((d - w) * (d - w)) / 4.5));\n      const i = y * W + x;\n      if (v > S.ink[i]) {\n        S.ink[i] = v;\n        S.owner[i] = band;\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  S.ink.fill(0);\n  const word = WORDS[S.word], step = HOLD[1] + BEND;\n  // Grid unit in LEDs and the 32 row band of each letter.\n  const U = 3, colours = [];\n  for (let n = 0; n \u003c 4; n++) {\n    const G = S.glyphs[word[n]], yc = n * 32 + 16, xc = 33;\n    const x = eraAt(S.clock - n * S.lag * step);\n    const e = min(2, floor(x)), u = ease(x - e);\n    const [deg, mir] = G.turn[e];\n    const a = ((deg * u) * PI) / 180, ca = cos(a), sa = sin(a);\n    const flip = mir ? cos(PI * u) : 1;\n    const shade = mir ? 0.5 + 0.5 * abs(flip) : 1;\n    // Roman shading comes in over the last bend.\n    const roman = e === 2 ? u : 0;\n    const pen = PEN[e] + (PEN[e + 1] - PEN[e]) * u;\n    const c0 = hsv(S.hue + ERA[e][0], ERA[e][1], 1), c1 = hsv(S.hue + ERA[e + 1][0], ERA[e + 1][1], 1);\n    colours.push(c0.map((v, i) => (v + (c1[i] - v) * u) * 255 * shade));\n    for (const st of G.strokes) {\n      const al = st.alpha[e] + (st.alpha[e + 1] - st.alpha[e]) * u;\n      if (al \u003c 0.01) continue;\n      const src = st.g[e], tgt = st.to[e];\n      let px = 0, py = 0;\n      for (let i = 0; i \u003c K; i++) {\n        let gx = src[i][0] + (tgt[i][0] - src[i][0]) * u - 5, gy = src[i][1] + (tgt[i][1] - src[i][1]) * u - 5;\n        gx *= flip;\n        const rx = gx * ca - gy * sa, ry = gx * sa + gy * ca;\n        const qx = xc + rx * U, qy = yc + ry * U;\n        if (i > 0) {\n          // A broad edge at 30 degrees: thick across it, thin along it.\n          const dx = qx - px, dy = qy - py, L = Math.hypot(dx, dy) || 1;\n          const nib = abs((dx / L) * 0.5 + (dy / L) * 0.866);\n          const w = (pen + roman * (0.22 + 0.5 * nib - pen)) * U;\n          stamp(S, n, px, py, qx, qy, w, al);\n        }\n        px = qx;\n        py = qy;\n      }\n    }\n    // The era rail at the left: four ticks and where the letter is.\n    for (let t = 0; t \u003c 4; t++) stamp(S, n, 6, yc - 10.5 + 7 * t, 6, yc - 10.5 + 7 * t, 0.2, 0.35);\n    stamp(S, n, 6, yc - 10.5 + 7 * x, 6, yc - 10.5 + 7 * x, 0.9, 1);\n    // The writing direction at the right: left for Phoenician, then turned.\n    const dirA = e === 0 ? u : 1, f = mir ? flip : e === 0 ? 1 : -1;\n    const ax = 57 + 2.5 * f, bx = 57 - 2.5 * f;\n    stamp(S, n, ax, yc - 3.5, bx, yc, 0.35, 0.8 * dirA);\n    stamp(S, n, bx, yc, ax, yc + 3.5, 0.35, 0.8 * dirA);\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const v = S.ink[i], c = colours[S.owner[i]];\n    display.setPixel(i % W, (i / W) | 0, round(c[0] * v), round(c[1] * v), round(c[2] * v));\n  }\n}\n","cantor-scalogram":"// ===== Patternflow pattern =====\n// Title:   Cantor Scalogram\n// Family:  data\n// Idea:    The wavelet transform of the Cantor staircase fills the tall panel, position down the 128 rows and log scale across the 64 columns, brightness its modulus and hue the phase of a complex Morlet wavelet, so the modulus branches into a tree of cones exactly as the middle-thirds Cantor set does while the view zooms in by three and slides one level along the scale axis back to the same picture.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: continuous wavelet transform (Alex Grossmann and Jean Morlet, 1984); wavelet transform of fractal signals, the Cantor staircase and the tree of its modulus maxima (Alain Arneodo, Guy Grasseau and Matthias Holschneider, 1988); the middle-thirds Cantor set (Georg Cantor, 1883); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=1..8, Omega=3..8\n//\n// Knob 1: Hue. Turns the phase wheel: at 0 a phase of 0 is cyan, at 0.5 it is red, and the hue goes once round the wheel for every turn of the phase.\n// Knob 2: Speed. At 2 the view zooms in by three every 6 s while the tree slides 21 columns towards the coarse side; 60 s at 0.2, 4 s at 3.\n// Knob 3: Noise. Complex noise on every coefficient, 0.1 times Noise^0.85 of the lit threshold at the coarsest column and 1.54 times that at the finest: at 1 it is a dim static under the cones and 28% of the LEDs are lit, at 8 the fine branches sink into it and 55% are lit.\n// Knob 4: Omega. The Morlet wavelet's centre frequency, 3 to 8 radians per unit of its width. At 3 the cones are smooth and the hue turns 2.8 radians a row at the finest column; from 5 the two halves of each branch cancel between them, so each cone opens into a striped oval.\n\n// Rows are the position b, columns the scale a, 21 columns to a factor of\n// 3, from a = 0.243 on the left to 0.009 on the right. The Morlet wavelet\n// psi(t) = exp(-t^2 / 2) (exp(i w t) - exp(-w^2 / 2)) is taken against the\n// Cantor measure mu, the derivative of the staircase F:\n//\n//   T(a, b) = (1/a) * integral psi((x - b) / a) dmu(x),\n//\n// which is -1/a times the transform of F itself with psi' as wavelet. The\n// staircase rises as |x - x0|^alpha at each point of the set, alpha =\n// log 2 / log 3, so T grows as a^(alpha - 1) on its maxima, and every\n// column is multiplied by a^(1 - alpha). Then the measure's own symmetry,\n// mu on [0, 1/3] being half of mu shrunk by 3, makes the scaled T at\n// (a/3, b/3) equal to the scaled T at (a, b): zooming in by 3 about b = 0 and moving 21 columns gives\n// the picture back, and the loop has no seam. The mass of [2/3, 1] is 3.95\n// wavelet widths from the bottom row at the end of the loop.\n//\n// At scale a the measure is cut at the stage k where the intervals are\n// 1/5.5 to 1/16.5 of a, each interval a point mass at its centre. The\n// spread of the measure inside an interval, variance (3^-k)^2 / 8, is put\n// back with the second derivative of psi, so the sum changes by under 0.1%\n// when k steps. Only the masses within 4a of the panel count, 8 to 64 of\n// them and 410 to 1860 terms a column, and down the rows each mass runs by\n// recurrence: the Gaussian by two products and the phase by one rotation.\n//\n// The 72% of LEDs with the smallest modulus stay at 24 or under, drawn as\n// the log of the modulus over a range of e^4; the rest climb from 25 to\n// 255. The hue is the phase. Noise on the coefficients is what lights the\n// gaps of the set, where the staircase is flat and its transform is all\n// but zero.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, round, sqrt, sin, cos, exp, log, pow, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst LN3 = log(3);\nconst ALPHA = log(2) / LN3;\n\n// Rows: position b from -0.04 to 1.04 at the start of the loop.\nconst B0 = -0.04, DB = 1.08 / H;\n// Columns: scale a from AMAX at column 0 down by 3 every PER columns.\nconst AMAX = 0.243, PER = 21;\n// The level of point masses keeps a / 3^-k in [RMIN, 3 RMIN).\nconst RMIN = 5.5, KMAX = 9;\n// Histogram of the modulus for the exposure.\nconst HB = 512;\n// Share of LEDs left under the lit threshold.\nconst DARK = 0.72;\n// Under the threshold the brightness is the log of the modulus, over e^LOGR.\nconst LOGR = 4;\n// Noise on the coefficients at Noise 1, as a share of the threshold.\nconst NOISE = 0.1;\n\n// Centres of the 2^k intervals of the k-th stage of the Cantor set, sorted.\nconst CENTRES = [];\nfor (let k = 0; k \u003c= KMAX; k++) {\n  const n = 1 \u003c\u003c k, w = pow(3, -k), arr = new Float64Array(n);\n  for (let j = 0; j \u003c n; j++) {\n    let x = 0, s = 1 / 3;\n    for (let i = k - 1; i >= 0; i--) {\n      if ((j >> i) & 1) x += 2 * s;\n      s /= 3;\n    }\n    arr[j] = x + w / 2;\n  }\n  CENTRES.push(arr);\n}\nconst firstAtLeast = (arr, x) => {\n  let lo = 0, hi = arr.length;\n  while (lo \u003c hi) {\n    const m = (lo + hi) >> 1;\n    if (arr[m] \u003c x) lo = m + 1;\n    else hi = m;\n  }\n  return lo;\n};\n\n// A small generator of its own, seeded once from Math.random, for the\n// 16384 noise draws a frame; two uniforms make a triangle of variance 1.\nlet seed = 1;\nconst uni = () => {\n  seed ^= seed \u003c\u003c 13;\n  seed ^= seed >>> 17;\n  seed ^= seed \u003c\u003c 5;\n  return (seed >>> 0) / 4294967296;\n};\nconst tri = () => (uni() + uni() - 1) * 2.449;\n\nexport function setup(params) {\n  seed = (Math.random() * 4294967295) | 1;\n  params.s = {\n    u: 0,\n    hue: 0,\n    noise: 1,\n    omega: 3,\n    re: new Float64Array(W * H),\n    im: new Float64Array(W * H),\n    mod: new Float64Array(W * H),\n    hist: new Uint32Array(HB),\n    // Complex noise on every coefficient, refreshed a little every frame.\n    noiseRI: new Float32Array(W * H * 2).map(tri),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.noise = cl(k[2] == null ? 1 : k[2], 1, 8);\n  S.omega = cl(k[3] == null ? 3 : k[3], 3, 8);\n  S.u = (S.u + (d * speed) / 12) % 1;\n  // The noise drifts: each value keeps exp(-dt / 0.15 s) of itself.\n  const keep = exp(-d / 0.15), fresh = sqrt(1 - keep * keep), nz = S.noiseRI;\n  for (let i = 0; i \u003c nz.length; i++) nz[i] = nz[i] * keep + fresh * tri();\n}\n\n// Adds the transform of the Cantor measure at one column into re, im.\nfunction column(S, c) {\n  const z = pow(3, -S.u), om = S.omega, kap = exp(-om * om / 2);\n  const a = AMAX * pow(3, -c / PER) * z;\n  const db = DB * z, b0 = (B0 + 0.5 * DB) * z;\n  const k = cl(ceil(log(RMIN / a) / LN3), 0, KMAX);\n  const r = a * pow(3, k), v2 = 1 / (16 * r * r), norm = pow(r, -ALPHA);\n  const reach = 4 * a, xs = CENTRES[k];\n  const delta = db / a, D = exp(-delta * delta), cw = cos(om * delta), sw = sin(om * delta);\n  const re = S.re, im = S.im, off = c;\n  for (let n = 0; n \u003c H; n++) re[n * W + off] = im[n * W + off] = 0;\n  const end = b0 + (H - 1) * db + reach;\n  for (let j = firstAtLeast(xs, b0 - reach); j \u003c xs.length && xs[j] \u003c= end; j++) {\n    const x = xs[j];\n    const n0 = max(0, ceil((x - reach - b0) / db)), n1 = min(H - 1, floor((x + reach - b0) / db));\n    let t = (x - (b0 + n0 * db)) / a;\n    let G = exp(-t * t / 2), Q = exp(t * delta - delta * delta / 2);\n    let zr = cos(om * t), zi = sin(om * t);\n    for (let n = n0; n \u003c= n1; n++) {\n      const tt = t * t;\n      const p = 1 + v2 * (tt - 1 - om * om), q = -2 * v2 * om * t;\n      const kk = kap * (1 + v2 * (tt - 1));\n      re[n * W + off] += G * (zr * p - zi * q - kk);\n      im[n * W + off] += G * (zr * q + zi * p);\n      G *= Q;\n      Q *= D;\n      t -= delta;\n      const tr = zr * cw + zi * sw;\n      zi = zi * cw - zr * sw;\n      zr = tr;\n    }\n  }\n  for (let n = 0; n \u003c H; n++) {\n    re[n * W + off] *= norm;\n    im[n * W + off] *= norm;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  for (let c = 0; c \u003c W; c++) column(S, c);\n  const re = S.re, im = S.im, mod = S.mod, hist = S.hist, N = W * H;\n  // Exposure from the staircase alone: the lit threshold is the modulus that\n  // DARK of the LEDs stay under, full brightness the top 0.5%.\n  let top = 0;\n  for (let p = 0; p \u003c N; p++) {\n    const m = sqrt(re[p] * re[p] + im[p] * im[p]);\n    mod[p] = m;\n    if (m > top) top = m;\n  }\n  hist.fill(0);\n  const hs = (HB - 1) / (top || 1);\n  for (let p = 0; p \u003c N; p++) hist[floor(mod[p] * hs)]++;\n  let mf = 0, mt = top;\n  for (let i = 0, acc = 0; i \u003c HB; i++) {\n    acc += hist[i];\n    if (!mf && acc >= DARK * N) mf = (i + 1) / hs;\n    if (acc >= 0.995 * N) {\n      mt = (i + 1) / hs;\n      break;\n    }\n  }\n  mt = max(mt, mf * 1.05);\n  const nz = S.noiseRI, hue = S.hue + 0.5;\n  for (let c = 0; c \u003c W; c++) {\n    // The noise grows as a^-(alpha - 1/2) towards fine scales, as white\n    // noise in the staircase would against the Cantor part.\n    const sig = NOISE * mf * pow(S.noise, 0.85) * pow(3, (c / PER) * (ALPHA - 0.5));\n    const cmax = 3 * sig;\n    for (let n = 0; n \u003c H; n++) {\n      const p = n * W + c;\n      let nr = nz[2 * p] * sig, ni = nz[2 * p + 1] * sig;\n      const nm = sqrt(nr * nr + ni * ni);\n      if (nm > cmax) {\n        nr *= cmax / nm;\n        ni *= cmax / nm;\n      }\n      const zr = re[p] + nr, zi = im[p] + ni;\n      const m = sqrt(zr * zr + zi * zi);\n      // Under the threshold the LED stays under 24; over it, it climbs.\n      let v, sat;\n      if (m \u003c mf) {\n        v = m > 0 ? 24.4 * cl(1 + log(m / mf) / LOGR, 0, 1) : 0;\n        // The more of the coefficient is noise, the deeper its colour.\n        sat = 0.3 + (0.65 * nm) / (nm + mod[p] + 1e-9);\n      } else {\n        const x = min(1, (m - mf) / (mt - mf));\n        v = 25 + 230 * pow(x, 0.8);\n        sat = 0.85 - 0.4 * x * x;\n      }\n      // Hue: the phase, once round the wheel per turn.\n      let h = atan2(zi, zr) / TAU + hue;\n      h = (h - floor(h)) * 6;\n      const i = floor(h), fr = h - i;\n      const P = v * (1 - sat), Q = v * (1 - sat * fr), T = v * (1 - sat * (1 - fr));\n      let R, G, B;\n      if (i === 0) (R = v), (G = T), (B = P);\n      else if (i === 1) (R = Q), (G = v), (B = P);\n      else if (i === 2) (R = P), (G = v), (B = T);\n      else if (i === 3) (R = P), (G = Q), (B = v);\n      else if (i === 4) (R = T), (G = P), (B = v);\n      else (R = v), (G = P), (B = Q);\n      if (m >= mf) {\n        // A lit LED sits on a grey of 25, so none of its channels is as dim\n        // as the floor.\n        const k = (v - 25) / v;\n        R = 25 + R * k;\n        G = 25 + G * k;\n        B = 25 + B * k;\n      }\n      display.setPixel(c, n, round(R), round(G), round(B));\n    }\n  }\n}\n","crofton-cell":"// ===== Patternflow pattern =====\n// Title:   Crofton Cell\n// Family:  cells\n// Idea:    Isotropic Poisson lines drift, are born and die across the tall panel and cut it into convex cells tinted by their number of sides, while the one cell that holds the fixed point in the middle, the Crofton cell, is lit as a pale incircle in gold corners under a dashed outer circle, so when the Big knob keeps every line at least r away from that point the cell swells, gains sides and its gold corners thin round the disc, as Kendall conjectured.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Poisson line tessellation and its zero cell (Roger E. Miles, Random polygons determined by random lines in a plane, 1964); D. G. Kendall's conjecture that large zero cells are nearly round (1940s), proved for the plane by Igor Kovalenko (1997) and in general by Daniel Hug, Matthias Reitzner and Rolf Schneider (2004); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=16..56, Big=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 triangles are teal, quadrilaterals azure, pentagons violet, hexagons pink and cells of seven sides or more green, and the Crofton cell is a pale disc in gold corners.\n// Knob 2: Speed. At 2 a line slides along its normal at up to 3 LEDs a second, turns at up to 0.05 radians a second and lives 10 s on average, so at the opening about 1.6 lines a second are born where the panel shows them and as many die. Everything goes as Speed / 2.\n// Knob 3: Lines. The mean number of lines that cross the panel, 16 to 56: the panel shows about 52 cells at 16, 190 at 36 and 390 at 56.\n// Knob 4: Big. No line may come nearer the fixed point than r = 20 Big^0.6 LEDs, which is the Poisson process conditioned on the zero cell holding that disc: 3.7 LEDs at the opening 0.06, 8.7 at 0.25, 13.2 at 0.5 and 20 at 1. With 56 lines the zero cell has 4.95 sides on average at 0, 5.9 at the opening and 8.5 at 1, and its incircle grows from 0.36 to 0.65 of the radius of its outer circle.\n\n// A line is (theta, p): the points x with x . (cos theta, sin theta) = p,\n// p >= 0, measured from the fixed point O in the middle of the panel. The\n// isotropic Poisson line process is a Poisson point process in (theta, p)\n// with uniform density, and by Crofton's formula the lines that hit a convex\n// set K number perimeter(K) times that density on average. So the panel\n// keeps every line with p \u003c R, R past the panel's corners, uniformly in\n// theta and p: the panel's perimeter of 384 LEDs against the circle's 2 pi R\n// says how many of those cross it.\n//\n// Each line slides in p and turns in theta at its own constant rate, which\n// moves the points of (theta, p) without squeezing them, so the law stays\n// the Poisson one. A line whose p passes 0 is the same line seen from the\n// other side, (theta + pi, -p). At p = R it turns back. Lines are also born\n// uniformly at a constant rate and each dies at a constant rate, a spatial\n// birth and death process whose resting law is the same Poisson process.\n//\n// The zero cell is the cell that contains O. Conditioning the process on\n// the zero cell holding the disc of radius r round O is the same as\n// keeping only the lines with p >= r, since a Poisson process on a set and\n// on its complement are independent. So Big only hides lines: a line that\n// slides in to p = r dies at the point where it touches the disc, and one\n// that slides out is born there. Miles found the zero cell has pi^2 / 2 =\n// 4.93 sides on average where a typical cell has 4. Kendall's question\n// was what a large zero cell looks like, and the answer is a disc: with r\n// large against the mean spacing of the lines, many lines lie just past r\n// and the cell is a many sided polygon hugging the circle. It comes slowly:\n// with l lines per LED of p per radian, the cell's corners stand out past\n// the disc by about (l r)^(-2/3) of r, so on 64 LEDs the cell gets to 8 or\n// 9 sides, rounder than its neighbours but still a polygon.\n//\n// Two LEDs are in the same cell when no line separates them, so each LED's\n// cell is the set of lines it lies beyond, hashed. A cell's polygon is the\n// square of side 2R clipped by the half plane of every line on that cell's\n// side; its edges give the number of sides. The zero cell's largest\n// inscribed disc comes from the three edges that pin it.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, sin, cos, abs, atan2, exp, pow, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst OX = 32, OY = 64;\n// Lines are kept while they pass within R of O; the corners are 71.6 away.\nconst R = 76;\n// Lines crossing the panel per line kept: perimeter over 2 pi R.\nconst CROSS = 384 / (TAU * R);\n// Mean life, the speed limits, all at Speed 2.\nconst LIFE = 10, VP = 3, VT = 0.05;\nconst MAXL = 160;\nconst SLOTS = 2048;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n}\n\nfunction poisson(mu) {\n  const L = exp(-mu);\n  let k = 0, prod = Math.random();\n  while (prod > L && k \u003c MAXL) {\n    k++;\n    prod *= Math.random();\n  }\n  return k;\n}\n\nfunction newLine(S, p) {\n  if (S.n >= MAXL) return;\n  const i = S.n++;\n  S.th[i] = Math.random() * TAU;\n  S.p[i] = p == null ? Math.random() * R : p;\n  S.v[i] = (Math.random() * 2 - 1) * VP;\n  S.w[i] = (Math.random() * 2 - 1) * VT;\n  S.life[i] = -log(1 - Math.random()) * LIFE;\n  S.key[i] = (Math.random() * 4294967296) >>> 0 | 1;\n  S.glow[i] = 0;\n  S.vis[i] = 0;\n}\n\nfunction kill(S, i) {\n  // A dying line that the panel shows leaves a fading ghost.\n  if (S.vis[i] && S.p[i] \u003c 73 && S.ghosts.length \u003c 8) S.ghosts.push([cos(S.th[i]), sin(S.th[i]), S.p[i], 1]);\n  const j = --S.n;\n  for (const a of [S.th, S.p, S.v, S.w, S.life, S.key, S.glow, S.vis]) a[i] = a[j];\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, th: new Float64Array(MAXL), p: new Float64Array(MAXL), v: new Float64Array(MAXL), w: new Float64Array(MAXL),\n    life: new Float64Array(MAXL), key: new Uint32Array(MAXL), glow: new Float32Array(MAXL), vis: new Uint8Array(MAXL),\n    ghosts: [], sparks: [], started: false, hue: 0, r: 4, mu: 20,\n    hash: new Uint32Array(N), dmin: new Float32Array(N), near: new Int16Array(N), cell: new Int16Array(N),\n    skey: new Uint32Array(SLOTS), sused: new Uint8Array(SLOTS), sid: new Int16Array(SLOTS),\n    rep: new Int32Array(SLOTS), sides: new Uint8Array(SLOTS), area: new Float32Array(SLOTS),\n    px: new Float64Array(96), py: new Float64Array(96), pl: new Int16Array(96), qx: new Float64Array(96), qy: new Float64Array(96), ql: new Int16Array(96),\n    zero: null,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 16, 0.06];\n  const d = cl(dt || 0, 0, 0.1) * cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.hue = k[0] || 0;\n  S.mu = cl(k[2] == null ? 16 : k[2], 16, 56) / CROSS;\n  S.r = 20 * pow(cl(k[3] == null ? 0.06 : k[3], 0, 1), 0.6);\n  if (!S.started) {\n    S.started = true;\n    for (let m = poisson(S.mu); m > 0; m--) newLine(S);\n    for (let i = 0; i \u003c S.n; i++) S.vis[i] = S.p[i] >= S.r ? 1 : 0;\n  }\n  // Births at the resting rate, plus a quick catch up when the knob moves.\n  const births = (S.mu / LIFE + max(0, S.mu - S.n) / 0.6) * d;\n  let extra = (max(0, S.n - S.mu) / 0.6) * d;\n  for (let b = births; b > 0; b--) if (Math.random() \u003c b) {\n    newLine(S);\n    S.glow[S.n - 1] = 1;\n  }\n  for (; extra > 0; extra--) if (Math.random() \u003c extra && S.n > 0) kill(S, floor(Math.random() * S.n));\n  for (let i = S.n - 1; i >= 0; i--) {\n    let p = S.p[i] + S.v[i] * d;\n    S.th[i] += S.w[i] * d;\n    if (p \u003c 0) {\n      p = -p;\n      S.th[i] += PI;\n      S.v[i] = -S.v[i];\n    }\n    if (p > R) {\n      p = 2 * R - p;\n      S.v[i] = -S.v[i];\n    }\n    S.p[i] = p;\n    S.glow[i] = max(0, S.glow[i] - d * 1.6);\n    S.life[i] -= d;\n    if (S.life[i] \u003c= 0) {\n      kill(S, i);\n      continue;\n    }\n    // Big hides the lines nearer than r: they die and are born touching the disc.\n    const vis = p >= S.r ? 1 : 0;\n    if (vis !== S.vis[i]) {\n      if (S.sparks.length \u003c 24) S.sparks.push([OX + S.r * cos(S.th[i]), OY + S.r * sin(S.th[i]), 1]);\n      if (vis) S.glow[i] = 0.8;\n      S.vis[i] = vis;\n    }\n  }\n  for (const g of S.ghosts) g[3] -= d * 2;\n  S.ghosts = S.ghosts.filter((g) => g[3] > 0);\n  for (const s of S.sparks) s[2] -= d * 2.2;\n  S.sparks = S.sparks.filter((s) => s[2] > 0);\n}\n\n// Clip the square of side 2R by the lines on one side, sign per line from\n// the LED at rep, or every line on O's side when rep \u003c 0. Leaves the polygon\n// in S.px, S.py with edge labels in S.pl (-1 for the square) and returns its\n// vertex count.\nfunction polygon(S, act, rep) {\n  let px = S.px, py = S.py, pl = S.pl, qx = S.qx, qy = S.qy, ql = S.ql;\n  px[0] = -R; py[0] = -R; px[1] = R; py[1] = -R; px[2] = R; py[2] = R; px[3] = -R; py[3] = R;\n  pl[0] = pl[1] = pl[2] = pl[3] = -1;\n  let n = 4;\n  const rx = rep \u003c 0 ? 0 : (rep % W) + 0.5 - OX, ry = rep \u003c 0 ? 0 : floor(rep / W) + 0.5 - OY;\n  for (let j = 0; j \u003c act.n; j++) {\n    const a = act.a[j], b = act.b[j], p = act.p[j];\n    // Keep s (a x + b y - p) >= 0.\n    const s = a * rx + b * ry - p > 0 ? 1 : -1;\n    let m = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const i2 = i + 1 === n ? 0 : i + 1;\n      const f1 = s * (a * px[i] + b * py[i] - p), f2 = s * (a * px[i2] + b * py[i2] - p);\n      if (f1 >= 0) {\n        qx[m] = px[i]; qy[m] = py[i]; ql[m] = pl[i]; m++;\n        if (f2 \u003c 0) {\n          const t = f1 / (f1 - f2);\n          qx[m] = px[i] + t * (px[i2] - px[i]); qy[m] = py[i] + t * (py[i2] - py[i]); ql[m] = j; m++;\n        }\n      } else if (f2 >= 0) {\n        const t = f1 / (f1 - f2);\n        qx[m] = px[i] + t * (px[i2] - px[i]); qy[m] = py[i] + t * (py[i2] - py[i]); ql[m] = pl[i]; m++;\n      }\n      if (m > 90) break;\n    }\n    [px, qx] = [qx, px];\n    [py, qy] = [qy, py];\n    [pl, ql] = [ql, pl];\n    n = m;\n    if (n \u003c 3) break;\n  }\n  S.px = px; S.py = py; S.pl = pl; S.qx = qx; S.qy = qy; S.ql = ql;\n  return n;\n}\n\n// The largest disc in the convex polygon S.px, S.py: centre and radius from\n// the three edges it touches, tried over every three.\nfunction incircle(S, n) {\n  const ex = [], ey = [], ec = [];\n  for (let i = 0; i \u003c n; i++) {\n    const i2 = i + 1 === n ? 0 : i + 1;\n    const dx = S.px[i2] - S.px[i], dy = S.py[i2] - S.py[i], L = sqrt(dx * dx + dy * dy);\n    if (L \u003c 1e-6) continue;\n    // The square runs clockwise on the panel (y down), so the inward\n    // normal is the edge turned a quarter to the right.\n    const nx = -dy / L, ny = dx / L;\n    ex.push(nx); ey.push(ny); ec.push(nx * S.px[i] + ny * S.py[i]);\n  }\n  const m = ex.length;\n  let best = [0, 0, 0];\n  for (let i = 0; i \u003c m; i++)\n    for (let j = i + 1; j \u003c m; j++)\n      for (let k = j + 1; k \u003c m; k++) {\n        // n . x - rho = c for the three: inside means n . x >= c + rho.\n        const a1 = ex[i], b1 = ey[i], c1 = ec[i], a2 = ex[j], b2 = ey[j], c2 = ec[j], a3 = ex[k], b3 = ey[k], c3 = ec[k];\n        const det = a1 * (b2 * -1 - -1 * b3) - b1 * (a2 * -1 - -1 * a3) + -1 * (a2 * b3 - b2 * a3);\n        if (abs(det) \u003c 1e-9) continue;\n        const dx = c1 * (b2 * -1 - -1 * b3) - b1 * (c2 * -1 - -1 * c3) + -1 * (c2 * b3 - b2 * c3);\n        const dy = a1 * (c2 * -1 - -1 * c3) - c1 * (a2 * -1 - -1 * a3) + -1 * (a2 * c3 - c2 * a3);\n        const dr = a1 * (b2 * c3 - c2 * b3) - b1 * (a2 * c3 - c2 * a3) + c1 * (a2 * b3 - b2 * a3);\n        const x = dx / det, y = dy / det, rho = dr / det;\n        if (!(rho > best[2])) continue;\n        let ok = true;\n        for (let q = 0; q \u003c m && ok; q++) if (ex[q] * x + ey[q] * y \u003c ec[q] + rho - 1e-7) ok = false;\n        if (ok) best = [x, y, rho];\n      }\n  return best;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { hash, dmin, near, cell, skey, sused, sid, rep, sides } = S;\n  // The lines the panel shows.\n  const act = { n: 0, a: [], b: [], p: [], key: [], glow: [] };\n  for (let i = 0; i \u003c S.n; i++)\n    if (S.vis[i] && S.p[i] \u003c 73) {\n      act.a.push(cos(S.th[i])); act.b.push(sin(S.th[i])); act.p.push(S.p[i]); act.key.push(S.key[i]); act.glow.push(S.glow[i]);\n      act.n++;\n    }\n  hash.fill(0);\n  dmin.fill(99);\n  near.fill(-1);\n  for (let j = 0; j \u003c act.n; j++) {\n    const a = act.a[j], b = act.b[j], key = act.key[j];\n    for (let y = 0; y \u003c H; y++) {\n      let dd = a * (0.5 - OX) + b * (y + 0.5 - OY) - act.p[j];\n      for (let x = 0, i = y * W; x \u003c W; x++, i++, dd += a) {\n        if (dd > 0) hash[i] ^= key;\n        const ad = dd \u003c 0 ? -dd : dd;\n        if (ad \u003c dmin[i]) {\n          dmin[i] = ad;\n          near[i] = j;\n        }\n      }\n    }\n  }\n  // Cells: hash every LED's line set into a table.\n  sused.fill(0);\n  let cells = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const h = hash[i];\n    let s = Math.imul(h, 2654435761) >>> 21;\n    while (sused[s] && skey[s] !== h) s = (s + 1) & (SLOTS - 1);\n    if (!sused[s]) {\n      sused[s] = 1;\n      skey[s] = h;\n      sid[s] = cells;\n      rep[cells] = i;\n      cells++;\n    }\n    cell[i] = sid[s];\n  }\n  for (let c = 0; c \u003c cells; c++) {\n    const n = polygon(S, act, rep[c]);\n    let e = 0, ar = 0;\n    for (let i = 0; i \u003c n; i++) {\n      if (S.pl[i] >= 0) e++;\n      const i2 = i + 1 === n ? 0 : i + 1;\n      ar += S.px[i] * S.py[i2] - S.px[i2] * S.py[i];\n    }\n    sides[c] = e;\n    S.area[c] = abs(ar) / 2;\n  }\n  // The zero cell, every line on O's side.\n  const zn = polygon(S, act, -1);\n  const [cx, cy, rin] = incircle(S, zn);\n  let rout = 0, zs = 0;\n  for (let i = 0; i \u003c zn; i++) {\n    rout = max(rout, sqrt((S.px[i] - cx) ** 2 + (S.py[i] - cy) ** 2));\n    if (S.pl[i] >= 0) zs++;\n  }\n  S.zero = { sides: zs, rin, rout };\n  const icx = cx + OX, icy = cy + OY;\n\n  const hue = S.hue;\n  // Hue by number of sides, a little brighter the larger the cell.\n  const tone = new Float32Array(cells * 3);\n  for (let c = 0; c \u003c cells; c++) {\n    const n = sides[c], h = n \u003c= 3 ? 0.47 : n === 4 ? 0.6 : n === 5 ? 0.74 : n === 6 ? 0.88 : 0.24;\n    const col = hsv(hue + h, 0.7, 0.32 + 0.26 * cl(log(1 + S.area[c]) / log(3000), 0, 1));\n    tone[c * 3] = col[0] * 255; tone[c * 3 + 1] = col[1] * 255; tone[c * 3 + 2] = col[2] * 255;\n  }\n  const gold = hsv(hue + 0.12, 0.8, 1).map((v) => v * 255);\n  const pale = hsv(hue + 0.55, 0.2, 0.95).map((v) => v * 255);\n  for (let i = 0; i \u003c N; i++) {\n    const x = i % W, y = (i / W) | 0, px = x + 0.5, py = y + 0.5;\n    const c = cell[i];\n    let r, g, b;\n    if (hash[i] === 0) {\n      const q = sqrt((px - icx) ** 2 + (py - icy) ** 2);\n      const t = cl(q - rin + 0.5, 0, 1);\n      r = pale[0] + (gold[0] - pale[0]) * t;\n      g = pale[1] + (gold[1] - pale[1]) * t;\n      b = pale[2] + (gold[2] - pale[2]) * t;\n    } else {\n      r = tone[c * 3]; g = tone[c * 3 + 1]; b = tone[c * 3 + 2];\n    }\n    // The lines themselves are dark seams; a new line flashes white.\n    const dm = dmin[i];\n    const seam = cl((dm - 0.3) / 0.45, 0, 1);\n    r *= seam; g *= seam; b *= seam;\n    if (near[i] >= 0) {\n      const gl = act.glow[near[i]];\n      if (gl > 0) {\n        const f = gl * exp(-dm * dm * 1.5) * 255;\n        r += f; g += f; b += f;\n      }\n    }\n    // Dying lines fade out where they stood.\n    for (const gh of S.ghosts) {\n      const dd = abs(gh[0] * (px - OX) + gh[1] * (py - OY) - gh[2]);\n      if (dd \u003c 1.2) {\n        const f = gh[3] * (1 - dd / 1.2) * 150;\n        r += f; g += f; b += f;\n      }\n    }\n    // Where a line touches the forbidden disc it dies or is born.\n    for (const sp of S.sparks) {\n      const dd = (px - sp[0]) ** 2 + (py - sp[1]) ** 2;\n      if (dd \u003c 9) {\n        const f = sp[2] * (1 - dd / 9) * 255;\n        r += f; g += f * 0.9; b += f * 0.7;\n      }\n    }\n    // The disc no line may enter, a faint ring round O.\n    if (S.r > 1.5) {\n      const fr = 1 - abs(sqrt((px - OX) ** 2 + (py - OY) ** 2) - S.r) / 0.6;\n      if (fr > 0) {\n        r *= 1 - 0.35 * fr; g *= 1 - 0.3 * fr; b *= 1 - 0.15 * fr;\n      }\n    }\n    // The incircle of the zero cell, solid, and its outer circle round the\n    // same centre, dashed, over everything.\n    const q = sqrt((px - icx) ** 2 + (py - icy) ** 2);\n    const ri = 1 - abs(q - rin) / 0.75;\n    if (ri > 0 && rin > 1) {\n      r += (255 - r) * ri; g += (255 - g) * ri; b += (255 - b) * ri;\n    }\n    const ro = 1 - abs(q - rout) / 0.7;\n    if (ro > 0 && floor(((atan2(py - icy, px - icx) + PI) / TAU) * 40) % 2 === 0) {\n      r += (255 - r) * ro * 0.55; g += (255 - g) * ro * 0.55; b += (255 - b) * ro * 0.55;\n    }\n    // O itself, a dark point.\n    if (abs(px - OX) \u003c 1 && abs(py - OY) \u003c 1) r = g = b = 0;\n    display.setPixel(x, y, min(255, r) | 0, min(255, g) | 0, min(255, b) | 0);\n  }\n}\n","exclusion-process":"// ===== Patternflow pattern =====\n// Title:   Exclusion Process\n// Family:  particle\n// Idea:    Particles enter a line of 64 sites across the panel at rate alpha, each hops one site right at rate 1 only when that site is empty and leaves the last site at rate beta, and the tall panel is the space-time diagram with the newest row at the top, so every particle draws its own coloured thread up and to the right, a jam stands as a block of steep threads whose holes run back to the left, and at the opening rates, equal and below one half, the front between a sparse stream and a jam wanders to and fro.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: totally asymmetric simple exclusion process (Frank Spitzer, Interaction of Markov processes, 1970; first written down for ribosomes on messenger RNA by Carolyn MacDonald, Julian Gibbs and Allen Pipkin, 1968), its exact phase diagram with open ends (Bernard Derrida, Eytan Domany and David Mukamel, 1992; Gunter Schütz and Eytan Domany, 1993); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Alpha=0.25..1, Beta=0.25..1\n//\n// Knob 1: Hue. Turns the band of thread colours round the wheel. At 0 the particles take hues from cyan through azure and violet to pink, each 0.618 of the band on from the one that entered before it, so neighbouring threads never share a colour; at 0.5 the band runs from red through yellow to green.\n// Knob 2: Speed. At 2 the diagram takes 16 new rows a second at the top, each row one unit of the process's time, in which a particle with an empty site ahead hops once on average, so the 128 rows hold the last 8 s; 80 s at 0.2, 5.3 s at 3.\n// Knob 3: Alpha. The rate at which a particle enters an empty first site. At the opening 0.25, equal to beta, a stream at density 0.25 meets a jam at density 0.75 and the front between them wanders about 10 sites over the 128 rows; any alpha above beta (with beta below 1/2) is the high-density phase, where the jam fills the line at density 1 - beta and its front backs out of the left end, a quarter of a site a row at alpha 0.5.\n// Knob 4: Beta. The rate at which the particle on the last site leaves. Above alpha (and alpha below 1/2) it is the low-density phase, a free stream at density alpha with no jam; with alpha and beta both above 1/2 it is the maximal-current phase, density 1/2 in the middle of the line and a quarter of a particle through every bond per row, however much higher the two rates go.\n\n// Each site holds at most one particle. In every unit of time each of\n// the 65 bonds (the entry, the 63 between sites and the exit) is tried\n// once on average, in random order: a particle crosses a bond inside the\n// line when the site beyond it is empty, comes in through the entry with\n// probability alpha when site 0 is empty and goes out through the exit\n// with probability beta. That is random sequential update, the process in\n// continuous time sampled once a row.\n//\n// Derrida, Domany and Mukamel solved the stationary state exactly. The\n// current through the line is alpha (1 - alpha) when alpha \u003c beta and\n// alpha \u003c 1/2, beta (1 - beta) in the mirror case, and 1/4 when both pass\n// 1/2. On alpha = beta \u003c 1/2 the two densities alpha and 1 - beta carry\n// the same current J = alpha (1 - alpha), so the front between them, a\n// shock, has no drift and walks at random. Its variance grows by\n// 2 J / (1 - 2 alpha) a unit of time: 0.75 at the opening, and here it\n// wanders 9.8 sites (root mean square) in the 128 rows the panel holds.\n//\n// Every particle gets a number when it comes in and keeps it, and its\n// colour comes from that number. Particles never pass one another, so\n// neighbours on the line always hold consecutive numbers, and consecutive\n// numbers sit 0.618 of the hue band apart, wrapped. A row stores which particle sits on each\n// site at the end of the row, and dimly every site a particle passed\n// through during the row, so a particle that hopped three sites leaves a\n// short step instead of a gap and its thread stays joined.\n//\n// Before the first frame the line starts as a step between the two\n// densities the ends ask for, runs 120 units to settle and then fills all\n// 128 rows, so the panel opens full.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Time units of the process per row, rows per second at Speed 1.\nconst DT = 1, RATE = 8;\n// Time run before the first row is kept, and the hue band the ids fill.\nconst SETTLE = 120, BAND = 0.42, PHI = 0.6180339887;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h), f = h - i, p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6];\n}\n\nexport function setup(params) {\n  params.s = {\n    occ: new Int32Array(W),\n    hist: new Int32Array(N),\n    trail: new Int32Array(N),\n    head: 0,\n    next: 1,\n    acc: 0,\n    alpha: 0.25,\n    beta: 0.25,\n    hue: 0,\n    ready: false,\n    pal: new Uint8Array(256 * 3),\n    palHue: -1,\n  };\n}\n\n// One row: DT units of random sequential update over the W + 1 bonds.\nfunction row(S, keep) {\n  const occ = S.occ, a = S.alpha, b = S.beta;\n  let hi = 0, ti = 0;\n  if (keep) {\n    S.head = (S.head + 1) % H;\n    hi = S.head * W;\n    for (let x = 0; x \u003c W; x++) S.trail[hi + x] = occ[x];\n    ti = hi;\n  }\n  const tries = (W + 1) * DT;\n  for (let n = 0; n \u003c tries; n++) {\n    const k = floor(Math.random() * (W + 1));\n    if (k === 0) {\n      if (occ[0] === 0 && Math.random() \u003c a) {\n        occ[0] = S.next++;\n        if (keep) S.trail[ti] = occ[0];\n      }\n    } else if (k === W) {\n      if (occ[W - 1] !== 0 && Math.random() \u003c b) occ[W - 1] = 0;\n    } else if (occ[k - 1] !== 0 && occ[k] === 0) {\n      occ[k] = occ[k - 1];\n      occ[k - 1] = 0;\n      if (keep) S.trail[ti + k] = occ[k];\n    }\n  }\n  if (keep) for (let x = 0; x \u003c W; x++) S.hist[hi + x] = occ[x];\n}\n\nfunction start(S) {\n  // A step between the two densities the boundaries ask for, then let it settle.\n  const left = S.alpha \u003c 0.5 ? S.alpha : 0.5, right = S.beta \u003c 0.5 ? 1 - S.beta : 0.5;\n  for (let x = W - 1; x >= 0; x--) S.occ[x] = Math.random() \u003c (x \u003c W / 2 ? left : right) ? S.next++ : 0;\n  for (let t = 0; t \u003c SETTLE; t++) row(S, false);\n  for (let r = 0; r \u003c H; r++) row(S, true);\n  S.ready = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.25, 0.25], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.alpha = cl(k[2] == null ? 0.25 : k[2], 0, 1);\n  S.beta = cl(k[3] == null ? 0.25 : k[3], 0, 1);\n  if (!S.ready) start(S);\n  S.acc += d * speed * RATE;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    row(S, true);\n  }\n}\n\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  for (let i = 0; i \u003c 256; i++) {\n    const f = (i * PHI) % 1;\n    const c = hsv(S.hue + 0.47 + f * BAND, 0.75, 1);\n    S.pal[i * 3] = round(c[0] * 255);\n    S.pal[i * 3 + 1] = round(c[1] * 255);\n    S.pal[i * 3 + 2] = round(c[2] * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  palette(S);\n  const pal = S.pal;\n  for (let y = 0; y \u003c H; y++) {\n    const r = ((S.head - y) % H + H) % H, o = r * W;\n    const fade = 1 - 0.35 * (y / (H - 1));\n    for (let x = 0; x \u003c W; x++) {\n      const id = S.hist[o + x], tr = S.trail[o + x];\n      let v = 0, c = 0;\n      if (id) { c = id & 255; v = fade; }\n      else if (tr) { c = tr & 255; v = fade * 0.45; }\n      if (v > 0) display.setPixel(x, y, round(pal[c * 3] * v), round(pal[c * 3 + 1] * v), round(pal[c * 3 + 2] * v));\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n  }\n}\n","fork-hologram":"// ===== Patternflow pattern =====\n// Title:   Fork Hologram\n// Family:  wave\n// Idea:    The tall panel is the fork grating you record when a beam with phase singularities meets a tilted plane wave, fine near-vertical fringes that split into l + 1 tines wherever a vortex of charge l sits, and some ten vortices of charge 1 to 7 and both signs drift over it, pull their opposites in, annihilate or leave the difference, and are born again in pairs, so forks open, merge and vanish, the crowded side of each fork tinted blue and the thinned side green.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: fork grating, the interferogram of a beam with a screw dislocation of charge l and a tilted plane wave (V. Yu. Bazhenov, M. V. Vasnetsov and M. S. Soskin, Laser beams with screw dislocations in their wavefronts, 1990), made as a binary computer-generated hologram (N. R. Heckenberg, R. McDuff, C. P. Smith and A. G. White, 1992); wave dislocations (John Nye and Michael Berry, 1974); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Charge=3..7, Carrier=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the plain grating is pale aqua, the side of a fork where the extra fringes crowd in is blue and the side where they thin out is green; at 0.3 the grating is lilac with red and blue.\n// Knob 2: Speed. At 2 the vortices drift 0.5 to 4 LEDs a second, faster as an opposite closes in, new pairs are born one every 0.6 to 1.8 s while fewer than ten vortices are left, and the fringes slide sideways 0.12 of a period a second; every time goes as 2 / Speed.\n// Knob 3: Charge. The highest charge a new pair carries: half the pairs carry it and the rest 1 up to it, so at the opening 3 the forks have 2, 3 or 4 tines and at 7 up to 8. A vortex of charge 2 or more sheds a unit vortex of its own sign, a charge 2 about every 12 s and a charge 3 every 6 s.\n// Knob 4: Carrier. The fringe period, 3.3 LEDs at the opening 0.06, 19 fringes across the panel, doubling by 0.68 and 9.4 LEDs at 1, where every tine of a fork stands apart. The fringes always lean 14 degrees.\n\n// A beam whose phase winds by 2 pi l round a point, l times atan2 about it,\n// meets a plane wave tilted by a carrier k. Where they add, the intensity\n// follows the phase difference\n//\n//   phi = 2 pi (k . r) + sum over vortices of l_j atan2(y - y_j, x - x_j),\n//\n// and the fringes are its level lines. Round a vortex phi gains 2 pi l, so\n// l more fringes cross a circle on one side of it than on the other: the\n// fork. The phases are multiplied as unit complex numbers and one atan2\n// per LED gives phi, so 10 vortices cost no more than one. The phase\n// gradient comes alongside in closed form: where it is longer than the\n// carrier the fringes crowd (blue at the opening), where shorter they thin\n// (green). At each core the beam is dark, so the fringes fade to the mean\n// within about sqrt(0.7 l) LEDs.\n//\n// Each fringe is drawn the way Heckenberg's binary holograms were cut, a\n// hard step from dark to bright, with the grey interferogram left in at\n// 35%: a triangle wave of phi runs 0 to 0.17 across a dark fringe and 0.83\n// to 1 across a bright one. The step keeps the fringes sharp; the ramp\n// keeps every LED a little different from the LED above it.\n//\n// The vortices move overdamped: opposite charges pull together and like\n// charges push apart, as 1 / r, with a slow random heading each. Opposite\n// charges that meet add up, equal ones annihilate and unequal ones leave\n// the difference. Total charge stays 0, since pairs are born as +l and -l.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, exp, pow, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Pairs kept on the panel, the margin past every edge the vortices may\n// wander into, the carrier's tilt as ky / k, the grey share of a fringe,\n// the period in LEDs at Carrier 0, the dark core's size per unit of charge.\nconst PAIRS = 5, MARGIN = 6, SLANT = 0.25, RAMP = 0.35, P0 = 3.09, CORE = 0.7;\n\nfunction vortex(x, y, l, vx, vy) {\n  return { x, y, l, vx, vy, wx: 0, wy: 0, kick: 1, age: 0 };\n}\n\nfunction charge(top) {\n  // Half the pairs carry the top charge, the rest anything from 1 up.\n  return Math.random() \u003c 0.5 ? top : 1 + floor(Math.random() * top);\n}\n\nfunction birth(S, x, y, top) {\n  const l = charge(top), a = Math.random() * TAU, v = 7;\n  S.v.push(vortex(x + cos(a) * 0.4, y + sin(a) * 0.4, l, cos(a) * v, sin(a) * v));\n  S.v.push(vortex(x - cos(a) * 0.4, y - sin(a) * 0.4, -l, -cos(a) * v, -sin(a) * v));\n}\n\nfunction seed(S, top) {\n  S.v = [];\n  for (let i = 0; i \u003c PAIRS; i++) {\n    const l = charge(top);\n    S.v.push(vortex(6 + Math.random() * 52, 6 + Math.random() * 116, l, 0, 0));\n    S.v.push(vortex(6 + Math.random() * 52, 6 + Math.random() * 116, -l, 0, 0));\n  }\n  for (const p of S.v) p.kick = 0;\n}\n\nexport function setup(params) {\n  params.s = { v: null, t: 0, hue: 0, top: 3, f: 0.31, wait: 0, slide: 0 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.top = round(cl(k[2] == null ? 3 : k[2], 3, 7));\n  S.f = 1 / (P0 * pow(2, 1.6 * cl(k[3] == null ? 0.06 : k[3], 0, 1)));\n  if (!S.v) seed(S, S.top);\n  const h = (d * speed) / 2;\n  S.t += h;\n  S.slide += h * 0.12;\n  const V = S.v;\n  // Overdamped motion: opposite charges pull together, like charges push\n  // apart, both as 1/r, and every vortex wanders on a slow random heading.\n  for (const p of V) {\n    let fx = 0, fy = 0;\n    for (const q of V) {\n      if (q === p) continue;\n      const dx = p.x - q.x, dy = p.y - q.y, r2 = dx * dx + dy * dy + 4;\n      const s = Math.sign(p.l * q.l) * sqrt(abs(p.l * q.l));\n      fx += (s * dx) / r2;\n      fy += (s * dy) / r2;\n    }\n    p.wx += (Math.random() - 0.5) * 6 * h - p.wx * 0.4 * h;\n    p.wy += (Math.random() - 0.5) * 6 * h - p.wy * 0.4 * h;\n    p.kick *= exp(-h * 1.6);\n    const ux = 9 * fx + p.wx + p.vx * p.kick, uy = 9 * fy + p.wy + p.vy * p.kick;\n    const sp = sqrt(ux * ux + uy * uy), cap = 9 / max(9, sp);\n    p.x += ux * cap * h;\n    p.y += uy * cap * h;\n    if (p.x \u003c -MARGIN) { p.x = -MARGIN; p.wx = abs(p.wx); }\n    if (p.x > W + MARGIN) { p.x = W + MARGIN; p.wx = -abs(p.wx); }\n    if (p.y \u003c -MARGIN) { p.y = -MARGIN; p.wy = abs(p.wy); }\n    if (p.y > H + MARGIN) { p.y = H + MARGIN; p.wy = -abs(p.wy); }\n    p.age += h;\n  }\n  // Opposite charges that meet add up: equal ones annihilate, unequal ones\n  // leave one vortex with the difference.\n  for (let i = 0; i \u003c V.length; i++)\n    for (let j = i + 1; j \u003c V.length; j++) {\n      const a = V[i], b = V[j];\n      if (a.l * b.l >= 0) continue;\n      const dx = a.x - b.x, dy = a.y - b.y;\n      if (dx * dx + dy * dy > 1.2) continue;\n      const l = a.l + b.l;\n      if (l === 0) {\n        V.splice(j, 1);\n        V.splice(i, 1);\n      } else {\n        const keep = abs(a.l) > abs(b.l) ? a : b;\n        keep.l = l;\n        V.splice(keep === a ? j : i, 1);\n      }\n      i = -1;\n      break;\n    }\n  // A vortex of charge 2 or more is unstable and now and then sheds a unit one.\n  for (let i = V.length - 1; i >= 0; i--) {\n    const p = V[i];\n    if (abs(p.l) > 1 && p.age > 2 && Math.random() \u003c h * 0.08 * (abs(p.l) - 1)) {\n      const s = Math.sign(p.l), a = Math.random() * TAU;\n      p.l -= s;\n      p.age = 0;\n      const q = vortex(p.x, p.y, s, cos(a) * 6, sin(a) * 6);\n      p.vx = -cos(a) * 6 / abs(p.l);\n      p.vy = -sin(a) * 6 / abs(p.l);\n      p.kick = 1;\n      V.push(q);\n    }\n  }\n  // New pairs are born out of nothing, a pair at a time.\n  S.wait -= h;\n  if (V.length \u003c 2 * PAIRS && S.wait \u003c= 0) {\n    birth(S, 8 + Math.random() * 48, 10 + Math.random() * 108, S.top);\n    S.wait = 0.6 + Math.random() * 1.2;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.v) return;\n  const V = S.v, n = V.length, f = S.f;\n  const ky = SLANT * f, kx = sqrt(f * f - ky * ky);\n  const px = new Float64Array(n), py = new Float64Array(n), pl = new Int8Array(n);\n  for (let j = 0; j \u003c n; j++) {\n    px[j] = V[j].x;\n    py[j] = V[j].y;\n    pl[j] = V[j].l;\n  }\n  const base = S.hue + 0.5, shift = S.slide;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      // The vortex phases multiplied as unit complex numbers, one atan2 at the end;\n      // the phase gradient in cycles per LED alongside, for the colour.\n      let re = 1, im = 0, gx = kx, gy = ky, c = 1;\n      for (let j = 0; j \u003c n; j++) {\n        const l = pl[j], dx = x - px[j], dy = y - py[j], r2 = dx * dx + dy * dy + 1e-6, ir = 1 / sqrt(r2);\n        const ux = dx * ir, uy = (l > 0 ? dy : -dy) * ir;\n        for (let m = l > 0 ? l : -l; m > 0; m--) {\n          const t = re * ux - im * uy;\n          im = re * uy + im * ux;\n          re = t;\n        }\n        const w = l / (TAU * r2);\n        gx -= dy * w;\n        gy += dx * w;\n        c *= r2 / (r2 + CORE * (l > 0 ? l : -l));\n      }\n      let u = kx * x + ky * y + shift + atan2(im, re) / TAU;\n      u -= floor(u);\n      const tri = 1 - abs(2 * u - 1);\n      const v = 0.5 + (RAMP * tri + (tri > 0.5 ? 1 - RAMP : 0) - 0.5) * c;\n      // Hue and saturation from how crowded the fringes are against the carrier.\n      const g = sqrt(gx * gx + gy * gy) / f - 1, ag = min(1, 4 * abs(g));\n      let h = base + (g > 0 ? 0.17 : -0.13) * ag;\n      const s = (0.3 + 0.5 * ag) * c;\n      h = (h - floor(h)) * 6;\n      const i = floor(h), q = h - i, lo = v * (1 - s), dn = v * (1 - s * q), up = v * (1 - s * (1 - q));\n      let r, gg, b;\n      if (i === 0) { r = v; gg = up; b = lo; }\n      else if (i === 1) { r = dn; gg = v; b = lo; }\n      else if (i === 2) { r = lo; gg = v; b = up; }\n      else if (i === 3) { r = lo; gg = dn; b = v; }\n      else if (i === 4) { r = up; gg = lo; b = v; }\n      else { r = v; gg = lo; b = dn; }\n      display.setPixel(x, y, round(r * 255), round(gg * 255), round(b * 255));\n    }\n  }\n}\n","lensed-page":"// ===== Patternflow pattern =====\n// Title:   Lensed Page\n// Family:  type\n// Idea:    A tall column of Newton's first Query from Opticks, set in 3 by 5 capitals, climbs past an invisible point mass in the middle of the panel, and every LED reads the page through the point-lens equation, so the lines bow into arcs round the mass, letters near it show twice, once outside the Einstein ring and once turned over inside it, and the letters right behind it spread into the ring itself.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the point-mass gravitational lens and its ring (Orest Chwolson, 1924; Albert Einstein, 1936); text from Isaac Newton, Opticks (1704), Query 1, public domain; 3 by 5 capitals drawn for this pattern; pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mass=13..29, Drift=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the ink is pale sky blue on dark blue paper, the turned-over images inside the ring are lilac, and the ink pales to white across the ring; at 0.5 the ink is peach and the inner images green.\n// Knob 2: Speed. At 2 the page climbs 5 rows a second, a line every 1.4 s and the whole 98-row page, the query and the signature, in 19.6 s, and a Drift swing takes 10 s; every time goes as 2 / Speed.\n// Knob 3: Mass. The Einstein radius in LEDs, 13 at the opening and 29 at the top, where the ring is 58 LEDs across. A letter t LEDs off the line of sight shows twice, outside the ring at (t + sqrt(t^2 + 4 E^2)) / 2 and turned over inside it at (sqrt(t^2 + 4 E^2) - t) / 2 on the far side; a line 40 LEDs from the mass is pushed 4.2 LEDs outward at 13 and 21 at 29.\n// Knob 4: Drift. Swings the mass sideways across the column, 24 LEDs times Drift each way: 1.4 at the opening 0.06, so the ring stays in the middle, and 24 at 1, where the ring runs off the side of the panel and the dark beyond the page's edge shows inside it, turned over, as a black disc.\n\n// Put the mass at the origin of the sky and the page far behind it. Light\n// that reaches the LED at angle theta from the mass passed the page at\n//\n//   beta = theta - thetaE^2 theta / |theta|^2,\n//\n// the point-lens equation (Chwolson 1924, Einstein 1936). So each LED\n// looks up the page at beta, and nothing is scattered or added up. A page\n// point at distance b from the line of sight has two images, both on the\n// line through the mass, at (b + sqrt(b^2 + 4 thetaE^2)) / 2 outside the\n// Einstein ring and (b - sqrt(b^2 + 4 thetaE^2)) / 2 inside it, on the\n// other side and turned over; the point right behind the mass is the whole\n// ring. Lensing keeps surface brightness, so the LED takes the page's\n// level as it is, bilinear between page LEDs, and a magnified letter is\n// bigger, never brighter. Inside the ring the page is shrunk: an LED at r\n// from the mass covers 1 + thetaE^2 / r^2 page LEDs radially, so it reads\n// a box-blurred copy of the page that wide instead of aliasing.\n//\n// The page is one LED to the page LED far from the mass: 16 characters of\n// 4 LEDs to a line, lines 7 rows apart, centred, the query wrapped by words\n// and the signature after it, then the same page again below. Past the\n// column's two sides there is no page, and that dark is what shows in the\n// middle of the ring, where the inner image reaches far out sideways.\n\nconst W = 64, H = 128;\nconst { floor, abs, sin, log2, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Isaac Newton, Opticks (1704), the first of the Queries.\nconst TEXT = \"QU. 1. DO NOT BODIES ACT UPON LIGHT AT A DISTANCE, AND BY THEIR ACTION BEND ITS RAYS; AND IS NOT THIS ACTION (CAETERIS PARIBUS) STRONGEST AT THE LEAST DISTANCE?\";\nconst SIGN = \"NEWTON 1704\";\n\n// Capitals, figures and stops, 3 wide and 5 tall, rows top to bottom.\nconst GLYPHS = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101110011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101111\", V: \"101101101101010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\",\n  0: \"111101101101111\", 1: \"010110010010111\", 4: \"101101111001001\", 7: \"111001010010010\",\n  \".\": \"000000000000010\", \",\": \"000000000010100\", \";\": \"000010000010100\", \"?\": \"110001010000010\",\n  \"(\": \"001010010010001\", \")\": \"100010010010100\", \" \": \"000000000000000\",\n};\n\n// Characters per line, LEDs per character and per line, page ground level.\nconst COLS = 16, ADV = 4, PITCH = 7, GROUND = 0.09, LEVELS = 5;\n\nfunction wrap(text) {\n  const lines = [];\n  let line = \"\";\n  for (const word of text.split(\" \")) {\n    if (line && line.length + 1 + word.length > COLS) {\n      lines.push(line);\n      line = word;\n    } else line = line ? line + \" \" + word : word;\n  }\n  if (line) lines.push(line);\n  return lines;\n}\n\n// The page: one copy of the query and the signature, PITCH rows a line,\n// 64 wide, repeating down. Level 1 is ink, GROUND the paper.\nfunction page() {\n  const lines = [...wrap(TEXT), \"\", SIGN, \"\"];\n  const ph = lines.length * PITCH, p = new Float32Array(W * ph).fill(GROUND);\n  lines.forEach((text, li) => {\n    const x0 = floor((W - (ADV * text.length - 1)) / 2);\n    for (let c = 0; c \u003c text.length; c++) {\n      const g = GLYPHS[text[c]] || GLYPHS[\" \"];\n      for (let r = 0; r \u003c 5; r++)\n        for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") p[(li * PITCH + 1 + r) * W + x0 + c * ADV + q] = 1;\n    }\n  });\n  return { p, ph };\n}\n\n// Box-blurred copies of the page, 2^L LEDs wide, for LEDs that see a wide\n// patch of it (the demagnified image inside the ring).\nfunction mips(p, ph) {\n  const out = [p];\n  for (let L = 1; L \u003c LEVELS; L++) {\n    const s = 1 \u003c\u003c L, a = new Float32Array(W * ph), b = new Float32Array(W * ph);\n    for (let y = 0; y \u003c ph; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let t = 0;\n        for (let i = 0; i \u003c s; i++) {\n          const xx = x + i - (s >> 1);\n          t += xx >= 0 && xx \u003c W ? p[y * W + xx] : 0;\n        }\n        a[y * W + x] = t / s;\n      }\n    for (let y = 0; y \u003c ph; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let t = 0;\n        for (let i = 0; i \u003c s; i++) t += a[(((y + i - (s >> 1)) % ph) + ph) % ph * W + x];\n        b[y * W + x] = t / s;\n      }\n    out.push(b);\n  }\n  return out;\n}\n\n// Bilinear sample: x off the page is dark, y wraps.\nfunction sample(p, ph, x, y) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  const ya = ((y0 % ph) + ph) % ph, yb = ya + 1 === ph ? 0 : ya + 1;\n  const a0 = x0 >= 0 && x0 \u003c W ? p[ya * W + x0] : 0, a1 = x0 + 1 >= 0 && x0 + 1 \u003c W ? p[ya * W + x0 + 1] : 0;\n  const b0 = x0 >= 0 && x0 \u003c W ? p[yb * W + x0] : 0, b1 = x0 + 1 >= 0 && x0 + 1 \u003c W ? p[yb * W + x0 + 1] : 0;\n  return (a0 + (a1 - a0) * fx) * (1 - fy) + (b0 + (b1 - b0) * fx) * fy;\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nexport function setup(params) {\n  const { p, ph } = page();\n  params.s = { mip: mips(p, ph), ph, scroll: 20, swing: 0, hue: 0, mass: 13, drift: 0.06 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 13, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.mass = cl(k[2] == null ? 13 : k[2], 13, 29);\n  S.drift = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.scroll = (S.scroll + d * speed * 2.5) % S.ph;\n  S.swing = (S.swing + (d * speed * TAU) / 20) % TAU;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { mip, ph } = S, e2 = S.mass * S.mass;\n  const lx = W / 2 + S.drift * 24 * sin(S.swing), ly = H / 2;\n  // Ink is the page colour outside the ring and turned inside it, paling to\n  // white at the ring; the paper keeps the page colour everywhere.\n  const out = hsv(S.hue + 0.56, 0.5, 1), inn = hsv(S.hue + 0.86, 0.5, 1), paper = hsv(S.hue + 0.56, 0.65, 1);\n  const rim = [], inner = [];\n  for (let i = 0; i \u003c= 10; i++) {\n    rim.push(hsv(S.hue + 0.56, 0.05 * i, 1));\n    inner.push(hsv(S.hue + 0.86, 0.05 * i, 1));\n  }\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      // Point lens: the LED at theta from the mass sees the page at\n      // beta = theta (1 - thetaE^2 / |theta|^2).\n      const tx = x - lx, ty = y - ly, r2 = tx * tx + ty * ty + 1e-6, k = 1 - e2 / r2;\n      const sx = lx + tx * k, sy = ly + ty * k + S.scroll;\n      // How many LEDs of page the LED spans radially: 1 + thetaE^2 / r^2.\n      const span = 1 + e2 / r2, lev = cl(log2(span) - 1, 0, LEVELS - 1.001), L0 = floor(lev), fl = lev - L0;\n      let v = sample(mip[L0], ph, sx, sy);\n      if (fl > 0) v += (sample(mip[L0 + 1], ph, sx, sy) - v) * fl;\n      // Outer images keep the page colour, the inverted inner images turn,\n      // and the ring between them goes white.\n      const t = (r2 - e2) / (r2 + e2), ink = cl((v - GROUND) / (1 - GROUND), 0, 1);\n      const c = t > 0 ? (abs(t) \u003c 0.2 ? rim[round(abs(t) * 50)] : out) : abs(t) \u003c 0.2 ? inner[round(abs(t) * 50)] : inn;\n      const s = 255 * v;\n      display.setPixel(x, y, round((paper[0] + (c[0] - paper[0]) * ink) * s), round((paper[1] + (c[1] - paper[1]) * ink) * s), round((paper[2] + (c[2] - paper[2]) * ink) * s));\n    }\n  }\n}\n","letter-retracts":"// ===== Patternflow pattern =====\n// Title:   Letter Retracts\n// Family:  type\n// Idea:    Three bold capitals stacked down the tall panel thin layer by layer to their skeletons without ever opening or closing a hole, then lose their free ends one LED at a time, so each letter shrinks onto its homotopy type, a point for X, T or Y, one loop round the counter for O, A or D and two loops for B, coloured by that hole count, and from those few LEDs the next word of the same classes grows.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: deformation retract and homotopy type (Karol Borsuk, 1931); parallel thinning in two subiterations (T. Y. Zhang and C. Y. Suen, 1984), in the version of Zicheng Guo and Richard W. Hall (1989); simple points (Shigeru Yokoi, Jun-ichiro Toriwaki and Teruo Fukumura, 1975); capitals drawn for this pattern; pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Weight=0..1\n//\n// Knob 1: Hue. Turns the three class colours round the wheel together. At 0 a letter with no hole is green, with one hole sky blue and with two holes magenta; at 0.5 they are violet, red-orange and green.\n// Knob 2: Speed. At 2 a letter loses one layer of thinning every 0.16 s and one LED off each free end every 0.1 s, so BOX retracts in 3.3 s and BAG in 6.6 s; every time goes as 2 / Speed.\n// Knob 3: Set. Four lists of words whose letters keep the same hole counts, so each word grows out of the last one's points and loops: 0 BOX, BAT, BAG, BOY (two, one, none); 1 DOG, ROT, PAL, DOT (one, one, none); 2 KEY, LEG, YET, ZEN (none); 3 ROD, POD, PRO, ODD (one each).\n// Knob 4: Weight. Stroke width, 7 LEDs at 0 to 11.5 at 1 (7.5 at the opening 0.06): the bolder the letter, the more layers it loses before its skeleton shows, 11 for B at the opening and 17 at 1.\n\n// Each letter is drawn as round-ended strokes in a 48 by 40 box and lit\n// where an LED centre is within half the weight of a stroke. Then it is\n// taken apart and every LED remembers the step at which it went:\n//\n// 1. Thinning, Guo and Hall's two subiterations, each one step, shown\n//    1.6 times as long as a pruning step. A pixel goes when it has one\n//    run of neighbours, two or three neighbouring pairs and does not face\n//    the side the subiteration keeps; that peels the strokes from both\n//    sides down to one LED wide, keeps every hole and keeps every free\n//    end.\n// 2. Pruning. At each step every pixel that is simple for 8-connected\n//    letters on 4-connected ground, Yokoi's connectivity number 1, is\n//    taken, rechecked as it goes. On a one-LED skeleton only the free\n//    ends are simple, so every branch loses one LED a step. A pixel on\n//    a loop is never simple, since taking it would join the hole to the\n//    ground; a single pixel is not either.\n//\n// What is left cannot shrink further without changing the topology: one\n// pixel, one loop, or two loops sharing an arc. The number of holes, the\n// 4-connected pieces of ground the letter closes off, is counted once for\n// the colour and is the same at every step.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Glyph strokes in a unit box, v downwards: [x0, y0, x1, y1] segments and\n// [cx, cy, rx, ry, from, to] elliptic arcs in degrees (0 right, 90 down).\n// The first number of each entry is the glyph's width in the box.\nconst GLYPHS = {\n  A: [1, [0, 1, 0.5, 0], [0.5, 0, 1, 1], [0.15, 0.7, 0.85, 0.7]],\n  B: [0.9, [0, 0, 0, 1], [0, 0, 0.58, 0], [0.58, 0.235, 0.34, 0.235, -90, 90], [0.58, 0.47, 0, 0.47], [0, 0.47, 0.62, 0.47], [0.62, 0.735, 0.38, 0.265, -90, 90], [0.62, 1, 0, 1]],\n  D: [0.9, [0, 0, 0, 1], [0, 0, 0.42, 0], [0.42, 0.5, 0.58, 0.5, -90, 90], [0.42, 1, 0, 1]],\n  E: [0.78, [0, 0, 0, 1], [0, 0, 1, 0], [0, 0.5, 0.85, 0.5], [0, 1, 1, 1]],\n  G: [0.95, [0.5, 0.5, 0.5, 0.5, 25, 310], [0.52, 0.56, 1, 0.56], [1, 0.56, 0.953, 0.711]],\n  K: [0.88, [0, 0, 0, 1], [1, 0, 0, 0.64], [0.32, 0.435, 1, 1]],\n  L: [0.72, [0, 0, 0, 1], [0, 1, 1, 1]],\n  N: [0.9, [0, 1, 0, 0], [0, 0, 1, 1], [1, 1, 1, 0]],\n  O: [0.95, [0.5, 0.5, 0.5, 0.5, 0, 360]],\n  P: [0.85, [0, 0, 0, 1], [0, 0, 0.52, 0], [0.52, 0.28, 0.48, 0.28, -90, 90], [0.52, 0.56, 0, 0.56]],\n  R: [0.9, [0, 0, 0, 1], [0, 0, 0.5, 0], [0.5, 0.27, 0.46, 0.27, -90, 90], [0.5, 0.54, 0, 0.54], [0.42, 0.54, 1, 1]],\n  T: [0.95, [0, 0, 1, 0], [0.5, 0, 0.5, 1]],\n  X: [0.95, [0, 0, 1, 1], [1, 0, 0, 1]],\n  Y: [0.95, [0, 0, 0.5, 0.52], [1, 0, 0.5, 0.52], [0.5, 0.52, 0.5, 1]],\n  Z: [0.85, [0, 0, 1, 0], [1, 0, 0, 1], [0, 1, 1, 1]],\n};\n\nconst SETS = [\n  [\"BOX\", \"BAT\", \"BAG\", \"BOY\"],\n  [\"DOG\", \"ROT\", \"PAL\", \"DOT\"],\n  [\"KEY\", \"LEG\", \"YET\", \"ZEN\"],\n  [\"ROD\", \"POD\", \"PRO\", \"ODD\"],\n];\n\n// Letter boxes: 48 wide by 40 tall, three down the panel.\nconst BW = 48, BH = 40, BX = 3, BY = [2, 44, 86];\n// The sign of each letter's homotopy type stands at this column.\nconst SX = 57.5;\nconst KEEP = 32767;\n\n// Segments of a glyph in LED coordinates for a stroke radius r.\nfunction segmentsOf(ch, r) {\n  const g = GLYPHS[ch], gw = g[0];\n  const w = (BW - 2 * r) * gw, h = BH - 2 * r, ox = (BW - w) / 2, oy = r;\n  const P = (u, v) => [ox + u * w, oy + v * h];\n  const out = [];\n  for (let i = 1; i \u003c g.length; i++) {\n    const s = g[i];\n    if (s.length === 4) out.push([...P(s[0], s[1]), ...P(s[2], s[3])]);\n    else {\n      const n = max(8, round(abs(s[5] - s[4]) / 7.5));\n      let prev = null;\n      for (let j = 0; j \u003c= n; j++) {\n        const t = ((s[4] + ((s[5] - s[4]) * j) / n) * PI) / 180;\n        const q = P(s[0] + s[2] * cos(t), s[1] + s[3] * sin(t));\n        if (prev) out.push([...prev, ...q]);\n        prev = q;\n      }\n    }\n  }\n  return out;\n}\n\nfunction rasterize(ch, r) {\n  const segs = segmentsOf(ch, r), img = new Uint8Array(BW * BH), r2 = r * r;\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c BW; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      for (const [x0, y0, x1, y1] of segs) {\n        const dx = x1 - x0, dy = y1 - y0, L = dx * dx + dy * dy;\n        const t = L > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / L, 0, 1) : 0;\n        const ex = px - x0 - t * dx, ey = py - y0 - t * dy;\n        if (ex * ex + ey * ey \u003c= r2) {\n          img[y * BW + x] = 1;\n          break;\n        }\n      }\n    }\n  return img;\n}\n\n// Neighbours of (x, y) in the box, outside counts as ground.\nconst at = (img, x, y) => (x \u003c 0 || y \u003c 0 || x >= BW || y >= BH ? 0 : img[y * BW + x]);\n\n// Yokoi's 8-connectivity number: 1 for a simple pixel or a free end.\nfunction simple(img, x, y) {\n  const n = [at(img, x + 1, y), at(img, x + 1, y - 1), at(img, x, y - 1), at(img, x - 1, y - 1), at(img, x - 1, y), at(img, x - 1, y + 1), at(img, x, y + 1), at(img, x + 1, y + 1)];\n  let c = 0;\n  for (let k = 0; k \u003c 8; k += 2) {\n    const a = 1 - n[k], b = 1 - n[k + 1], d = 1 - n[(k + 2) & 7];\n    c += a - a * b * d;\n  }\n  return c === 1;\n}\n\n// Pieces of 4-connected ground that do not reach the box edge.\nfunction holes(img) {\n  const seen = new Uint8Array(BW * BH), stack = [];\n  let count = 0;\n  for (let s = 0; s \u003c BW * BH; s++) {\n    if (img[s] || seen[s]) continue;\n    let edge = false;\n    stack.push(s);\n    seen[s] = 1;\n    while (stack.length) {\n      const p = stack.pop(), x = p % BW, y = (p / BW) | 0;\n      if (x === 0 || y === 0 || x === BW - 1 || y === BH - 1) edge = true;\n      for (const [nx, ny] of [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]) {\n        if (nx \u003c 0 || ny \u003c 0 || nx >= BW || ny >= BH) continue;\n        const q = ny * BW + nx;\n        if (!img[q] && !seen[q]) {\n          seen[q] = 1;\n          stack.push(q);\n        }\n      }\n    }\n    if (!edge) count++;\n  }\n  return count;\n}\n\n// Takes a letter apart: the step each pixel goes at, KEEP for what stays.\nfunction retract(ch, r) {\n  const img = rasterize(ch, r), N = BW * BH;\n  const gone = new Int16Array(N).fill(-1);\n  for (let p = 0; p \u003c N; p++) if (img[p]) gone[p] = KEEP;\n  const kind = holes(img);\n  let step = 0;\n  const mark = [];\n  // Thinning, Guo and Hall.\n  for (let pass = 0, any = 0; pass \u003c 200; pass++) {\n    const iter = pass & 1;\n    if (!iter) any = 0;\n    mark.length = 0;\n    for (let y = 0; y \u003c BH; y++)\n      for (let x = 0; x \u003c BW; x++) {\n        if (!img[y * BW + x]) continue;\n        const p2 = at(img, x, y - 1), p3 = at(img, x + 1, y - 1), p4 = at(img, x + 1, y), p5 = at(img, x + 1, y + 1);\n        const p6 = at(img, x, y + 1), p7 = at(img, x - 1, y + 1), p8 = at(img, x - 1, y), p9 = at(img, x - 1, y - 1);\n        const C = (!p2 & (p3 | p4)) + (!p4 & (p5 | p6)) + (!p6 & (p7 | p8)) + (!p8 & (p9 | p2));\n        const N1 = (p9 | p2) + (p3 | p4) + (p5 | p6) + (p7 | p8), N2 = (p2 | p3) + (p4 | p5) + (p6 | p7) + (p8 | p9);\n        const n = min(N1, N2);\n        const m = iter === 0 ? (p6 | p7 | !p9) & p8 : (p2 | p3 | !p5) & p4;\n        if (C === 1 && n >= 2 && n \u003c= 3 && m === 0) mark.push(y * BW + x);\n      }\n    if (!mark.length) {\n      if (iter === 1 && !any) break;\n      continue;\n    }\n    any = 1;\n    step++;\n    for (const p of mark) {\n      img[p] = 0;\n      gone[p] = step;\n    }\n  }\n  const thin = step;\n  // Pruning: every simple pixel of the step before goes, if still simple.\n  for (;;) {\n    mark.length = 0;\n    for (let p = 0; p \u003c N; p++) if (img[p] && simple(img, p % BW, (p / BW) | 0)) mark.push(p);\n    if (!mark.length) break;\n    step++;\n    let took = 0;\n    for (const p of mark)\n      if (simple(img, p % BW, (p / BW) | 0)) {\n        img[p] = 0;\n        gone[p] = step;\n        took++;\n      }\n    if (!took) {\n      step--;\n      break;\n    }\n  }\n  let point = -1;\n  if (!kind) for (let p = 0; p \u003c N; p++) if (gone[p] === KEEP) point = p;\n  return { gone, kind, thin, last: step, point, end: SLOW * thin + step - thin };\n}\n\n// A thinning layer takes SLOW times as long as a pruning step.\nconst SLOW = 1.6;\nconst stepAt = (L, tau) => (tau \u003c SLOW * L.thin ? tau / SLOW : L.thin + tau - SLOW * L.thin);\n\nfunction wordOf(text, r) {\n  const letters = [...text].map((ch) => retract(ch, r));\n  return { text, letters, last: max(...letters.map((l) => l.end)) };\n}\n\nconst hsv = (h, s, v) => {\n  h = ((h % 1) + 1) % 1;\n  const i = floor(h * 6), f = h * 6 - i;\n  const p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6];\n};\n// Class hues: no hole green, one hole sky blue, two holes magenta.\nconst HUES = [0.3, 0.56, 0.86];\n\n// Phases of one word, in steps: grow from the points and loops, stand,\n// retract, rest, then cross to the next word's points and loops.\nconst STAND = 10, REST = 12, CROSS = 6;\n\nexport function setup(params) {\n  params.s = { set: -1, weight: -1, index: 0, word: null, next: null, phase: \"stand\", t: 0, clock: 0, hue: 0 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const set = round(cl(k[2] || 0, 0, 3));\n  const r = round((3.5 + 2.25 * cl(k[3] == null ? 0.06 : k[3], 0, 1)) * 4) / 4;\n  const list = SETS[set];\n  if (set !== S.set) {\n    S.set = set;\n    S.index = 0;\n    S.weight = r;\n    S.word = wordOf(list[0], r);\n    S.next = wordOf(list[1], r);\n    S.phase = \"stand\";\n    S.t = 0;\n  } else if (r !== S.weight) {\n    S.weight = r;\n    S.word = wordOf(list[S.index], r);\n    S.next = wordOf(list[(S.index + 1) % list.length], r);\n  }\n  S.clock += d * speed;\n  let left = d * speed * 5;\n  // Walk the phases with the steps this frame has.\n  while (left > 0) {\n    const w = S.word;\n    if (S.phase === \"grow\") {\n      const go = min(left * 1.5, S.t);\n      S.t -= go;\n      left -= go / 1.5;\n      if (S.t \u003c= 0) (S.phase = \"stand\"), (S.t = 0);\n    } else if (S.phase === \"stand\") {\n      const go = min(left, STAND - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= STAND) (S.phase = \"retract\"), (S.t = 0);\n    } else if (S.phase === \"retract\") {\n      const go = min(left, w.last - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= w.last) (S.phase = \"rest\"), (S.t = 0);\n    } else if (S.phase === \"rest\") {\n      const go = min(left, REST - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= REST) (S.phase = \"cross\"), (S.t = 0);\n    } else {\n      const go = min(left, CROSS - S.t);\n      S.t += go;\n      left -= go;\n      if (S.t >= CROSS) {\n        S.index = (S.index + 1) % list.length;\n        S.word = S.next;\n        S.next = wordOf(list[(S.index + 1) % list.length], S.weight);\n        S.phase = \"grow\";\n        S.t = S.word.last;\n      }\n    }\n  }\n}\n\n// One word at retraction step tau, faded by f, into the frame.\nfunction paint(frame, word, tau, f, S, glow) {\n  const pulse = 0.75 + 0.25 * sin(S.clock * 4);\n  for (let li = 0; li \u003c 3; li++) {\n    const L = word.letters[li], hue = HUES[L.kind] + S.hue, oy = BY[li];\n    const body = hsv(hue, 0.85, 1), ghost = hsv(hue, 0.45, 0.2), tip = hsv(hue, 0.25, 1);\n    const st = stepAt(L, tau), pruning = st > L.thin;\n    for (let y = 0; y \u003c BH; y++)\n      for (let x = 0; x \u003c BW; x++) {\n        const g = L.gone[y * BW + x];\n        if (g \u003c 0) continue;\n        let c, a;\n        if (g === KEEP) {\n          // What stays: brighter once nothing else is left.\n          const done = st >= L.last;\n          c = done ? hsv(hue, 0.6, glow ? pulse : 1) : body;\n          a = 1;\n        } else if (g > st + 1) {\n          c = body;\n          // A soft depth: pixels that go late are brighter.\n          a = 0.62 + (0.38 * min(g, L.thin + 1)) / (L.thin + 1);\n        } else if (g > st) {\n          // The layer or end that goes next, fading out.\n          c = pruning ? tip : body;\n          a = 0.2 + 0.8 * (g - st);\n        } else {\n          c = ghost;\n          a = 1;\n        }\n        const p = ((oy + y) * W + BX + x) * 3;\n        frame[p] += c[0] * a * f;\n        frame[p + 1] += c[1] * a * f;\n        frame[p + 2] += c[2] * a * f;\n      }\n    // Beside the letter, the sign of what it retracts to: a dot, a ring, or\n    // two rings that touch. Dim until the letter gets there.\n    {\n      const there = st >= L.last, c = hsv(hue, 0.55, 1), sy = oy + BH / 2;\n      const a0 = (there ? (glow ? pulse : 1) : 0.3) * f;\n      for (let y = -6; y \u003c= 6; y++)\n        for (let x = -4; x \u003c= 4; x++) {\n          const px = floor(SX) + x + 0.5 - SX, py = y;\n          let a = 0;\n          if (L.kind === 0) a = max(0, 1 - sqrt(px * px + py * py) / 1.6);\n          else if (L.kind === 1) a = max(0, 1 - abs(sqrt(px * px + py * py) - 3.2) / 0.7);\n          else {\n            const d1 = abs(sqrt(px * px + (py + 2.6) ** 2) - 2.6), d2 = abs(sqrt(px * px + (py - 2.6) ** 2) - 2.6);\n            a = max(0, 1 - min(d1, d2) / 0.7);\n          }\n          if (!a) continue;\n          const p = ((sy + y) * W + floor(SX) + x) * 3;\n          frame[p] += c[0] * a * a0;\n          frame[p + 1] += c[1] * a * a0;\n          frame[p + 2] += c[2] * a * a0;\n        }\n    }\n    // A point is one LED, so it gets a halo once it is all that is left.\n    if (L.point >= 0 && st >= L.last) {\n      const px = L.point % BW, py = (L.point / BW) | 0, c = hsv(hue, 0.5, 1);\n      for (let dy = -3; dy \u003c= 3; dy++)\n        for (let dx = -3; dx \u003c= 3; dx++) {\n          const d = sqrt(dx * dx + dy * dy);\n          if (!d || d > 3.2) continue;\n          const a = 0.5 * (1 - d / 3.4) * (glow ? pulse : 1) * f, p = ((oy + py + dy) * W + BX + px + dx) * 3;\n          frame[p] += c[0] * a;\n          frame[p + 1] += c[1] * a;\n          frame[p + 2] += c[2] * a;\n        }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.word) return;\n  const frame = (S.frame = S.frame || new Float32Array(W * H * 3));\n  frame.fill(0);\n  if (S.phase === \"grow\") paint(frame, S.word, S.t, 1, S, false);\n  else if (S.phase === \"stand\") paint(frame, S.word, 0, 1, S, false);\n  else if (S.phase === \"retract\") paint(frame, S.word, S.t, 1, S, false);\n  else if (S.phase === \"rest\") paint(frame, S.word, S.word.last, 1, S, true);\n  else {\n    const f = S.t / CROSS;\n    paint(frame, S.word, S.word.last, 1 - f, S, true);\n    paint(frame, S.next, S.next.last, f, S, true);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3;\n      display.setPixel(x, y, round(min(1, frame[p]) * 255), round(min(1, frame[p + 1]) * 255), round(min(1, frame[p + 2]) * 255));\n    }\n}\n","noordzij-cube":"// ===== Patternflow pattern =====\n// Title:   Noordzij Cube\n// Family:  type\n// Idea:    A pen writes three lowercase words down the panel stroke by stroke, and the width at every point of every stroke comes from Gerrit Noordzij's two kinds of contrast, the broad nib's translation, thick or thin by the stroke's direction against the nib, and the pointed pen's expansion, swelling on the downstrokes, so turning the knobs moves the whole page across his cube on one unchanged skeleton.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the theory of the stroke and its cube of contrast, translation, expansion and the amount of contrast (Gerrit Noordzij, De streek, 1985; The stroke: theory of writing, 2005); lowercase skeletons drawn for this pattern, pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Model=0..1, Hairline=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel. At 0 every stroke runs from cyan where the pen comes down to violet where it lifts, deep where the ink is thick and pale in a hairline.\n// Knob 2: Speed. At 2 the pen moves 44 LEDs a second, a page of three words takes 17 to 19 s and holds for 2.5 s before it fades; at 0.2 the pen is ten times slower.\n// Knob 3: Model. Where the page stands between translation at 0, a broad nib held at 30 degrees, thickest across the nib and thinnest along it, and expansion at 1, a pointed pen that swells on every downstroke and runs thin up and across. The skeleton and the order of the strokes never change.\n// Knob 4: Hairline. The thinnest stroke as a share of the thickest, which is 4.8 LEDs, the amount of contrast read the other way: at the opening 0.06 a hairline is the floor of 0.8 LED; at 1 every stroke is 4.8 LEDs and translation and expansion give the same letters, the edge of the cube where there is no contrast to tell them apart.\n\n// Noordzij reads every contrast in written letters as the trace of a pen.\n// A broad nib moved without turning, translation, leaves its full width\n// where it travels across its edge and a hairline where it travels along\n// it, so the thick and thin of a letter follow the direction of each stroke\n// and the angle of the nib. A pointed flexible nib, expansion, is thin until\n// it is pressed, and the hand presses on the way down, so the thick falls on\n// the downstrokes and swells in and out. His cube sets these two models on\n// one edge, the amount of contrast on another, and interrupted against\n// running construction on the third. Here the third stays interrupted: the\n// pen lifts between the strokes of a letter and the letters do not join.\n//\n// Every letter is one centreline, written in order and in one direction.\n// Each point of it carries both widths, worked out once: the broad nib's\n// |sin(direction - 30 degrees)| and the pointed pen's pressure, the share of\n// the stroke's motion that runs down, smoothed forwards and backwards over\n// 3.2 LEDs so it comes and goes. Model blends the two, Hairline sets how\n// thin the thinnest is, and a round soft-edged pen of that width inks the\n// line. Nothing about the letters changes but those two numbers.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Skeleton lowercase in a box 7 wide, y down from the x-line at 0 to the\n// base line at 10, ascender to -6.5 and descender to 16.5: the strokes in\n// the order and direction a hand writes them. M moves, L draws a line, and\n// E cx cy rx ry a0 a1 an arc of an ellipse from angle a0 to a1 in degrees\n// (0 right, 90 down), so a falling angle runs anticlockwise on the panel.\nconst GLYPHS = {\n  a: \"E3.5 5 3.5 5 330 30|M7 0L7 10\",\n  b: \"M0 -6.5L0 10|E3.5 5 3.5 5 205 515\",\n  e: \"M0.2 5L7 5E3.5 5 3.5 5 0 -318\",\n  g: \"E3.5 5 3.5 5 330 30|M7 0L7 12.5E3.5 12.5 3.5 4 0 165\",\n  n: \"M0 0L0 10|E3.5 3.6 3.5 3.6 180 360L7 10\",\n  o: \"E3.5 5 3.5 5 290 -66\",\n};\nconst PAGES = [\n  [\"nano\", \"bone\", \"ego\"],\n  [\"oboe\", \"nag\", \"eon\"],\n];\n// LEDs per unit across and down, the space between letters in LEDs, the\n// thickest stroke, the nib angle and the length over which a pointed pen's\n// pressure comes and goes, in LEDs.\nconst KX = 1.38, KY = 2.1, GAP = 6.5, THICK = 4.8, NIB = (30 * PI) / 180, SWELL = 3.2;\n\nfunction parse(src) {\n  return src.split(\"|\").map((s) => {\n    const tk = s.match(/[MLE]|-?[\\d.]+/g), pts = [];\n    for (let i = 0; i \u003c tk.length; ) {\n      const c = tk[i++];\n      if (c === \"M\" || c === \"L\") pts.push([+tk[i++], +tk[i++]]);\n      else {\n        const [cx, cy, rx, ry, a0, a1] = tk.slice(i, i + 6).map(Number);\n        i += 6;\n        const n = ceil(abs(a1 - a0) / 6);\n        for (let j = 0; j \u003c= n; j++) {\n          const a = ((a0 + ((a1 - a0) * j) / n) * PI) / 180;\n          pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n        }\n      }\n    }\n    return pts;\n  });\n}\nconst FONT = {};\nfor (const c in GLYPHS) FONT[c] = parse(GLYPHS[c]);\n\n// A stroke in LEDs, cut into steps of at most an LED. For each point:\n// tr, the width a broad nib at NIB leaves, |sin(direction - nib)|, and ex,\n// the pressure on a pointed pen: how much the stroke runs down, smoothed\n// along it forwards and backwards so it swells in and out.\nfunction stroke(pts) {\n  const P = [];\n  for (let i = 0; i \u003c pts.length; i++) {\n    if (!i) {\n      P.push(pts[0]);\n      continue;\n    }\n    const [qx, qy] = P[P.length - 1], [px, py] = pts[i], n = ceil(sqrt((px - qx) ** 2 + (py - qy) ** 2));\n    for (let j = 1; j \u003c= n; j++) P.push([qx + ((px - qx) * j) / n, qy + ((py - qy) * j) / n]);\n  }\n  const n = P.length, xy = new Float32Array(2 * n), cum = new Float32Array(n), tr = new Float32Array(n), ex = new Float32Array(n);\n  const raw = new Float32Array(n), fw = new Float32Array(n);\n  for (let i = 0; i \u003c n; i++) {\n    xy[2 * i] = P[i][0];\n    xy[2 * i + 1] = P[i][1];\n    if (i) cum[i] = cum[i - 1] + sqrt((P[i][0] - P[i - 1][0]) ** 2 + (P[i][1] - P[i - 1][1]) ** 2);\n    const a = P[max(0, i - 1)], b = P[min(n - 1, i + 1)], dx = b[0] - a[0], dy = b[1] - a[1], L = sqrt(dx * dx + dy * dy) || 1;\n    // The direction with y up, as the nib angle is measured.\n    tr[i] = abs(sin(atan2(-dy, dx) - NIB));\n    raw[i] = max(0, dy / L);\n  }\n  for (let i = 0, f = 0; i \u003c n; i++) {\n    const k = 1 - exp(-(i ? cum[i] - cum[i - 1] : 1) / SWELL);\n    f += (raw[i] - f) * k;\n    fw[i] = f;\n  }\n  for (let i = n - 1, f = 0; i >= 0; i--) {\n    const k = 1 - exp(-(i \u003c n - 1 ? cum[i + 1] - cum[i] : 1) / SWELL);\n    f += (raw[i] - f) * k;\n    ex[i] = min(fw[i], f) ** 0.8;\n  }\n  return { xy, cum, tr, ex, len: cum[n - 1] };\n}\n\n// One page: each word on a line of its own, centred, the lines spread\n// evenly down the panel by their ascenders and descenders.\nfunction layout(words) {\n  const lines = words.map((w) => ({\n    w,\n    up: /b/.test(w) ? 6.5 : 0,\n    down: /g/.test(w) ? 6.5 : 0,\n    width: w.length * 7 * KX + (w.length - 1) * GAP,\n  }));\n  const tall = lines.reduce((s, l) => s + (10 + l.up + l.down) * KY, 0), gap = (H - tall) / (lines.length + 1);\n  const strokes = [], guides = [];\n  let y = gap;\n  for (const l of lines) {\n    const top = y + l.up * KY;\n    let x = (W - 1 - l.width) / 2;\n    for (const c of l.w) {\n      for (const pts of FONT[c]) strokes.push(stroke(pts.map(([u, v]) => [x + u * KX, top + v * KY])));\n      x += 7 * KX + GAP;\n    }\n    guides.push(Math.round(top), Math.round(top + 10 * KY));\n    y += (10 + l.up + l.down) * KY + gap;\n  }\n  return { strokes, guides };\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nexport function setup(params) {\n  params.nc = {\n    page: -1, strokes: [], guides: [], si: 0, d: 0, mode: \"lift\", lift: 0, liftT: 0.1, from: [32, -6], to: [32, -6], pen: [32, -6], timer: 0, fade: 1, started: false,\n    hue: 0, speed: 2, model: 0, hair: 0.06,\n    cov: new Float32Array(N), fat: new Float32Array(N), pos: new Float32Array(N), out: new Float32Array(N * 3),\n  };\n}\n\nfunction nextPage(B) {\n  B.page = (B.page + 1) % PAGES.length;\n  const L = layout(PAGES[B.page]);\n  B.strokes = L.strokes;\n  B.guides = L.guides;\n  B.si = 0;\n  B.d = 0;\n  B.fade = 1;\n  startLift(B);\n}\n\nfunction startLift(B) {\n  const s = B.strokes[B.si];\n  B.mode = \"lift\";\n  B.from = [B.pen[0], B.pen[1]];\n  B.to = [s.xy[0], s.xy[1]];\n  B.lift = 0;\n  B.liftT = max(0.08, sqrt((B.to[0] - B.from[0]) ** 2 + (B.to[1] - B.from[1]) ** 2) / (3 * rate(B)));\n}\n\nconst rate = (B) => 22 * B.speed;\n\n// The point at distance d along a stroke.\nfunction at(s, d) {\n  const n = s.cum.length;\n  if (d >= s.len) return [s.xy[2 * n - 2], s.xy[2 * n - 1]];\n  let i = 0;\n  while (i \u003c n - 2 && s.cum[i + 1] \u003c d) i++;\n  const f = (d - s.cum[i]) / max(1e-6, s.cum[i + 1] - s.cum[i]);\n  return [s.xy[2 * i] + (s.xy[2 * i + 2] - s.xy[2 * i]) * f, s.xy[2 * i + 1] + (s.xy[2 * i + 3] - s.xy[2 * i + 1]) * f];\n}\n\nfunction step(B, dt) {\n  if (B.mode === \"write\") {\n    const s = B.strokes[B.si];\n    B.d += rate(B) * dt;\n    B.pen = at(s, B.d);\n    if (B.d >= s.len) {\n      B.si++;\n      if (B.si \u003c B.strokes.length) startLift(B);\n      else (B.mode = \"hold\"), (B.timer = 2.5);\n    }\n  } else if (B.mode === \"lift\") {\n    B.lift = min(1, B.lift + dt / B.liftT);\n    const e = B.lift * B.lift * (3 - 2 * B.lift);\n    B.pen = [B.from[0] + (B.to[0] - B.from[0]) * e, B.from[1] + (B.to[1] - B.from[1]) * e];\n    if (B.lift >= 1) (B.mode = \"write\"), (B.d = 0);\n  } else if (B.mode === \"hold\") {\n    B.timer -= (dt * B.speed) / 2;\n    if (B.timer \u003c= 0) (B.mode = \"fade\"), (B.timer = 0.8);\n  } else {\n    B.timer -= dt;\n    B.fade = max(0, B.timer / 0.8);\n    if (B.timer \u003c= 0) nextPage(B);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.nc) setup(params);\n  const B = params.nc, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  B.hue = k[0] || 0;\n  B.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  B.model = cl(k[2] || 0, 0, 1);\n  B.hair = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (!B.started) {\n    // The panel opens 13.5 s into the page: at Speed 2 the pen has written\n    // all but the last word.\n    B.started = true;\n    nextPage(B);\n    for (let i = 0; i \u003c 405; i++) step(B, 1 / 30);\n  }\n  step(B, dt);\n}\n\n// The width of a stroke at a point: the two models blended by Model, the\n// result laid between the hairline and the thickest stroke.\nfunction width(B, s, i) {\n  const f = (1 - B.model) * s.tr[i] + B.model * s.ex[i], w = max(0.8, THICK * (B.hair + (1 - B.hair) * f));\n  return [w, w / THICK];\n}\n\n// Ink one piece of a stroke with a round pen whose radius runs from ra to\n// rb along it, its edge softened over one LED. fat keeps how thick the\n// stroke is there and pos how far along it, from 0 to 1, for the colour.\nfunction piece(B, ax, ay, bx, by, ra, rb, fa, fb, ua, ub) {\n  const r = max(ra, rb) + 1;\n  const x0 = max(0, floor(min(ax, bx) - r)), x1 = min(W - 1, ceil(max(ax, bx) + r));\n  const y0 = max(0, floor(min(ay, by) - r)), y1 = min(H - 1, ceil(max(ay, by) + r));\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1e-9, { cov, fat, pos } = B;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const t = cl(((x - ax) * dx + (y - ay) * dy) / L2, 0, 1), ex = x - ax - t * dx, ey = y - ay - t * dy;\n      const c = cl(ra + (rb - ra) * t - sqrt(ex * ex + ey * ey) + 0.5, 0, 1);\n      const p = y * W + x;\n      if (c > cov[p]) {\n        cov[p] = c;\n        fat[p] = fa + (fb - fa) * t;\n        pos[p] = ua + (ub - ua) * t;\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const B = params.nc;\n  if (!B || !B.started) return;\n  const { cov, fat } = B;\n  cov.fill(0);\n  const done = B.mode === \"write\" ? B.si + 1 : B.si;\n  for (let k = 0; k \u003c done && k \u003c B.strokes.length; k++) {\n    const s = B.strokes[k], lim = k === B.si && B.mode === \"write\" ? B.d : 1e9;\n    let [wa, fa] = width(B, s, 0);\n    for (let i = 0; i + 1 \u003c s.cum.length && s.cum[i] \u003c lim; i++) {\n      let [wb, fb] = width(B, s, i + 1), bx = s.xy[2 * i + 2], by = s.xy[2 * i + 3];\n      if (s.cum[i + 1] > lim) {\n        const f = (lim - s.cum[i]) / (s.cum[i + 1] - s.cum[i]);\n        bx = s.xy[2 * i] + (bx - s.xy[2 * i]) * f;\n        by = s.xy[2 * i + 1] + (by - s.xy[2 * i + 1]) * f;\n      }\n      piece(B, s.xy[2 * i], s.xy[2 * i + 1], bx, by, wa / 2, wb / 2, fa, fb, s.cum[i] / s.len, min(lim, s.cum[i + 1]) / s.len);\n      wa = wb;\n      fa = fb;\n    }\n  }\n  // Each stroke runs from cyan where the pen comes down to violet where it\n  // lifts, so the colour shows the way it was written; thick ink is deep,\n  // a hairline pale.\n  const { out, pos } = B, F = B.fade, rule = new Uint8Array(H);\n  for (const g of B.guides) if (g >= 0 && g \u003c H) rule[g] = 1;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const c = cov[p] * F, bg = rule[y] && x % 3 === 0 ? (34 / 255) * F : 0;\n      let r = bg * 0.7, g = bg * 0.8, b = bg;\n      if (c > 0) {\n        const [ir, ig, ib] = hsv(B.hue + 0.48 + 0.24 * pos[p], 0.2 + 0.7 * fat[p], 1);\n        r += (ir - r) * c;\n        g += (ig - g) * c;\n        b += (ib - b) * c;\n      }\n      out[p * 3] = r;\n      out[p * 3 + 1] = g;\n      out[p * 3 + 2] = b;\n    }\n  // The pen: a white point as wide as the stroke it is writing, dim and\n  // small while it is lifted between strokes.\n  if (B.mode === \"write\" || B.mode === \"lift\") {\n    const s = B.strokes[min(B.si, B.strokes.length - 1)];\n    let i = 0;\n    while (i \u003c s.cum.length - 1 && s.cum[i + 1] \u003c= B.d) i++;\n    const rr = B.mode === \"write\" ? width(B, s, i)[0] / 2 + 0.4 : 1;\n    const v = B.mode === \"write\" ? 1 : 0.6, [px, py] = B.pen;\n    for (let y = max(0, floor(py - rr - 1)); y \u003c= min(H - 1, ceil(py + rr + 1)); y++)\n      for (let x = max(0, floor(px - rr - 1)); x \u003c= min(W - 1, ceil(px + rr + 1)); x++) {\n        const c = cl(rr - sqrt((x - px) ** 2 + (y - py) ** 2) + 0.5, 0, 1), p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) out[p + j] += (v - out[p + j]) * c;\n      }\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), out[p * 3] * 255, out[p * 3 + 1] * 255, out[p * 3 + 2] * 255);\n}\n","phasor-noise":"// ===== Patternflow pattern =====\n// Title:   Phasor Noise\n// Family:  noise\n// Idea:    One set of Gabor kernels, little wave packets turned by a field with a whirl and a saddle drifting through it, is summed into a complex field and shown twice: on top as Gabor noise, its imaginary part, whose stripes fade to flat wherever the kernels cancel, and below as phasor noise, a profile of its phase alone, the same curving bands at full contrast everywhere and broken only at the points where the sum is zero.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: phasor noise (Thibault Tricard, Semyon Efremov, Cédric Zanni, Fabrice Neyret, Jonàs Martínez and Sylvain Lefebvre, Procedural phasor noise, 2019), built on sparse convolution Gabor noise (Ares Lagae, Sylvain Lefebvre, George Drettakis and Philip Dutré, Procedural noise using sparse Gabor convolution, 2009); pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Frequency=8..11, Profile=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. Each band takes its colour from the way it runs: at 0 level bands are sea green, slanting ones azure and upright ones violet.\n// Knob 2: Speed. At 2 the bands travel one period every 3.3 s, each kernel circles its place every 9 s and the direction field turns once in 50 s; all of it goes as Speed / 2.\n// Knob 3: Frequency. Stripes across the 64 LEDs of the panel: 8 is a period of 8 LEDs, 11 a period of 5.8. The kernels keep their size, 6.5 LEDs to one standard deviation, so at 11 each holds 1.4 times as many stripes.\n// Knob 4: Profile. The wave the phase is drawn with in the lower half, blended between a sine at 0, a triangle at 0.33, a square at 0.67 and a sawtooth at 1, whose sharp side shows which way each band's phase runs. The upper half is Gabor noise at every setting.\n\n// A Gabor kernel is a Gaussian times a complex plane wave,\n//\n//   g_i(x) = exp(-|x - x_i|^2 / (2 s^2)) exp(i (k_i . (x - x_i) + phi_i)),\n//\n// and the sum G(x) of a few hundred of them, scattered on a jittered grid,\n// is complex noise with the frequency and orientation of its kernels. Lagae\n// and his co-authors showed Im G, Gabor noise: wherever the kernels around a\n// point happen to cancel, |G| is small and the stripes fade out. Tricard and\n// his co-authors kept the phase and threw the amplitude away, profile(arg G):\n// stripes of one contrast everywhere, with the same orientation and period,\n// broken only where G = 0, the points the phase winds round. Both halves of\n// the panel here are the same 64 x 63 window of the same G, so every place\n// the upper stripes fade to flat is a fork or an end in the lower ones.\n//\n// The kernel direction comes from a field with a whirl and a saddle in it,\n// theta = theta0 + the angle round the whirl - the angle round the saddle.\n// Round the whirl the wave vectors point outwards (rings), across (spokes)\n// or in between (spirals) as theta0 turns; spokes and spirals spread apart\n// as they go out, and phasor noise can only keep its period by forking.\n//\n// Each kernel is separable, the Gaussian and the wave both, so it is two\n// short complex rows, one along x and one along y, multiplied pixel by pixel.\n\nconst W = 64, H = 128, FH = 63, LOW = 65;\nconst { floor, min, max, round, sqrt, sin, cos, exp, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Kernel size and reach in LEDs, and the grid the kernels sit on.\nconst SIG = 6.5, R = 18, STEP = 8;\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const ks = [];\n  for (let y = -R; y \u003c FH + R; y += STEP)\n    for (let x = -R; x \u003c W + R; x += STEP)\n      ks.push({\n        hx: x + (Math.random() - 0.5) * STEP * 0.8,\n        hy: y + (Math.random() - 0.5) * STEP * 0.8,\n        ph: Math.random() * TAU,\n        wa: Math.random() * TAU,\n        wr: 0.8 + 1.2 * Math.random(),\n        ws: Math.random() \u003c 0.5 ? -1 : 1,\n        cx: 0, cy: 0, kx: 0, ky: 0,\n      });\n  params.s = {\n    ks, t: 0, hue: 0, freq: 8, prof: 0.06,\n    gr: new Float32Array(W * FH), gi: new Float32Array(W * FH), u: [0, 0], th: new Float32Array(W * FH),\n    xr: new Float32Array(2 * R + 2), xi: new Float32Array(2 * R + 2), out: new Float32Array(W * H * 3),\n  };\n}\n\n// A whirl and a saddle, each on a slow loop of its own.\nfunction poles(t) {\n  return [24 + 8 * sin(0.071 * t), 20 + 6 * cos(0.053 * t + 1), 40 + 8 * sin(0.062 * t + 2), 46 + 6 * cos(0.047 * t + 0.5)];\n}\n\n// The kernel direction at (x, y) as a unit complex number,\n// e^(i theta0) (z - whirl) / |z - whirl| times the conjugate for the saddle.\nfunction dir(P, c0, s0, x, y, o) {\n  const ar = x - P[0], ai = y - P[1], br = x - P[2], bi = -(y - P[3]);\n  const pr = ar * br - ai * bi, pi = ar * bi + ai * br;\n  const qr = pr * c0 - pi * s0, qi = pr * s0 + pi * c0, m = sqrt(qr * qr + qi * qi) || 1;\n  o[0] = qr / m;\n  o[1] = qi / m;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.freq = cl(k[2] == null ? 8 : k[2], 8, 11);\n  S.prof = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.t += (d * speed) / 2;\n}\n\nfunction field(S) {\n  const t = S.t, P = poles(t), th0 = (TAU * t) / 50 + 0.4, c0 = cos(th0), s0 = sin(th0), kk = (TAU * S.freq) / W;\n  const { gr, gi, xr, xi, u } = S;\n  gr.fill(0);\n  gi.fill(0);\n  const a = 1 / (2 * SIG * SIG), drift = (TAU * t) / 3.3;\n  for (const K of S.ks) {\n    const w = ((TAU * t) / 9) * K.ws + K.wa;\n    const cx = K.hx + K.wr * cos(w), cy = K.hy + K.wr * sin(w);\n    dir(P, c0, s0, cx, cy, u);\n    const kx = kk * u[0], ky = kk * u[1];\n    const x0 = max(0, Math.ceil(cx - R)), x1 = min(W - 1, floor(cx + R));\n    const y0 = max(0, Math.ceil(cy - R)), y1 = min(FH - 1, floor(cy + R));\n    if (x0 > x1 || y0 > y1) continue;\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x - cx, e = exp(-a * dx * dx), p = kx * dx;\n      xr[x - x0] = e * cos(p);\n      xi[x - x0] = e * sin(p);\n    }\n    for (let y = y0; y \u003c= y1; y++) {\n      const dy = y - cy, e = exp(-a * dy * dy), p = ky * dy + K.ph - drift;\n      const yr = e * cos(p), yi = e * sin(p);\n      let o = y * W + x0;\n      for (let x = x0; x \u003c= x1; x++, o++) {\n        const ar = xr[x - x0], ai = xi[x - x0];\n        gr[o] += ar * yr - ai * yi;\n        gi[o] += ar * yi + ai * yr;\n      }\n    }\n  }\n  // cos 2 theta at every LED, which way its stripes run, for the colour.\n  const T = S.th;\n  for (let y = 0, o = 0; y \u003c FH; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      dir(P, c0, s0, x, y, u);\n      T[o] = u[0] * u[0] - u[1] * u[1];\n    }\n}\n\n// Brightness of a band at height v of its wave; the lowest seventh is black.\nconst lum = (v) => (v \u003c 0.14 ? 0 : ((v - 0.14) / 0.86) ** 2);\n\n// The wave drawn from the phase: 1 on the crest of sin, 0 in the trough.\nfunction profile(ph, m) {\n  const s = 0.5 + 0.5 * sin(ph);\n  if (m \u003c= 0) return s;\n  let u = ph / TAU - 0.25;\n  u -= floor(u);\n  const tri = Math.abs(2 * u - 1), sq = cl(0.5 + 2.6 * sin(ph), 0, 1), saw = 1 - u;\n  const z = m * 3, i = min(2, floor(z)), f = z - i;\n  const A = [s, tri, sq, saw];\n  return A[i] + (A[i + 1] - A[i]) * f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  field(S);\n  const { gr, gi, out } = S, n = W * FH;\n  let e = 0;\n  for (let i = 0; i \u003c n; i++) e += gr[i] * gr[i] + gi[i] * gi[i];\n  const rms = sqrt(e / n) || 1, hb = S.hue + 0.55;\n  out.fill(0);\n  for (let i = 0; i \u003c n; i++) {\n    const h = hb + 0.16 * S.th[i];\n    const g = cl(gi[i] / (1.5 * rms), -1, 1) * 0.5 + 0.5;\n    const p = profile(atan2(gi[i], gr[i]), S.prof);\n    hsv(h, 0.75 - 0.35 * g, lum(g), out, i * 3);\n    hsv(h, 0.75 - 0.35 * p, lum(p), out, (i + LOW * W) * 3);\n  }\n  for (let i = 0; i \u003c W * H; i++) display.setPixel(i % W, floor(i / W), round(out[i * 3] * 255), round(out[i * 3 + 1] * 255), round(out[i * 3 + 2] * 255));\n}\n","word-search":"// ===== Patternflow pattern =====\n// Title:   Word Search\n// Family:  type\n// Idea:    A word search of 160 capitals, 10 across and 16 down the tall panel, hides twelve words of type vocabulary in all eight directions among random letters, and a white cursor reads it cell by cell the plain way, sending a probe out in each of the eight directions from every letter that starts a word still unfound, until a probe runs a whole word and a rounded capsule in that word's colour closes round it and stays; when all twelve are ringed the grid dissolves and the next puzzle types itself in.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: word search puzzle (Norman E. Gibat, Selenby Digest, Norman, Oklahoma, 1968), solved by the plain search that tries all eight directions from every cell; capitals 5 by 7 drawn for this pattern; pattern round 82\n// Round:   82\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Puzzle=0..5, Fill=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the grid is pale blue-grey, the probe reads in pale gold, a failed letter flashes rose, and the capsules come in cyan, violet, rose, azure, magenta and on, each 0.382 of a 0.62 band on from the one before.\n// Knob 2: Speed. At 2 each comparison takes 0.03 s and each find holds the search 0.4 s, so the opening puzzle types in for 1 s, has all twelve words ringed by 20 s, holds 1.6 s and dissolves in 1.2 s; at 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Puzzle. Which of six lists of twelve words is hidden: 0 SERIF, KERN, GLYPH, BOWL, STEM, SPUR, EAR, TAIL, LEADING, BASELINE, COUNTER and ASCENDER; 1 more parts of a letter, APEX to XHEIGHT; 2 words of the page, TRACKING to HYPHEN; 3 classes of type, ROMAN to MONO; 4 metal type, SORT to FURNITURE; 5 accents and marks, ACUTE to MACRON. Each new puzzle on a list is laid again from its own seed.\n// Knob 4: Fill. How a found word is marked. At 0 and the opening 0.06 a capsule outline one LED wide, which for words across and down runs in the gaps between the letters; at 0.5 the capsule is filled at 40% of its colour, and at 1 it is solid at 80% with the word's letters cut out of it dark while every letter outside the found words dims to half.\n\n// Placing: the words go in longest first, each at the first of 400 random\n// starts where every cell is empty or already holds the same letter. Each\n// word tries a direction of its own for the first 200 starts, three\n// eighths of a turn on from the word before, so a grid has words running\n// backwards, upwards and along both diagonals. The cells left over get\n// random letters, and a word that the filler happens to spell again is\n// found wherever the search reaches it first.\n//\n// Searching: the cursor visits the cells in reading order. A cell whose\n// letter starts no word still unfound costs one step. From any other cell\n// the probe tries east, then each direction clockwise; it reads one letter\n// a step, keeps the words whose next letter matches and stops at the first\n// letter that matches none, which flashes. When a word runs out on a match\n// it is found. Directions that leave the grid at once cost nothing.\n//\n// The capsule round a word is the set of LEDs at distance 3 from the\n// segment joining its first and last letter centres, measured with the\n// vertical squeezed by 3/4. So the outline sits on the gap row 4 LEDs\n// above and below a word that runs across, on the gap column 3 LEDs either\n// side of a word that runs down, and the ends round off between the two.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// 10 columns by 16 rows of 5 by 7 capitals, 6 LEDs apart across and 8 down.\nconst COLS = 10, ROWS = 16, CELLS = COLS * ROWS, CW = 6, CH = 8, X0 = 2, Y0 = 1;\n// Clockwise from east, the order the search tries them in.\nconst DIRS = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]];\n// Seconds at Speed 2: one comparison, the pause on a find, the hold when\n// every word is found, the dissolve and the typing in of the next grid.\nconst STEP = 0.03, FIND = 0.4, HOLD = 1.6, MELT = 1.2, TYPE = 1.0;\n// Capsule radius across the word, in LEDs; down the panel it is 4/3 of it.\nconst R = 3, SY = 0.75;\n\nconst LISTS = [\n  [\"SERIF\", \"KERN\", \"GLYPH\", \"BOWL\", \"STEM\", \"SPUR\", \"EAR\", \"TAIL\", \"LEADING\", \"BASELINE\", \"COUNTER\", \"ASCENDER\"],\n  [\"APEX\", \"VERTEX\", \"SPINE\", \"ARM\", \"LEG\", \"LOOP\", \"LINK\", \"CROSSBAR\", \"SHOULDER\", \"TERMINAL\", \"DESCENDER\", \"XHEIGHT\"],\n  [\"TRACKING\", \"MEASURE\", \"GUTTER\", \"INDENT\", \"WIDOW\", \"ORPHAN\", \"RAG\", \"RIVER\", \"JUSTIFY\", \"MARGIN\", \"COLUMN\", \"HYPHEN\"],\n  [\"ROMAN\", \"ITALIC\", \"GOTHIC\", \"SLAB\", \"SCRIPT\", \"GROTESK\", \"DIDONE\", \"UNCIAL\", \"TEXTURA\", \"FRAKTUR\", \"ANTIQUA\", \"MONO\"],\n  [\"SORT\", \"QUOIN\", \"CHASE\", \"GALLEY\", \"FORME\", \"PLATEN\", \"PUNCH\", \"MATRIX\", \"SLUG\", \"LIGATURE\", \"COMPOSE\", \"FURNITURE\"],\n  [\"ACUTE\", \"GRAVE\", \"TILDE\", \"CEDILLA\", \"OGONEK\", \"UMLAUT\", \"CARET\", \"DAGGER\", \"PILCROW\", \"ASTERISK\", \"OBELUS\", \"MACRON\"],\n];\n\n// Capitals 5 wide and 7 tall, top row first.\nconst FONT = (\n  \".###. #...# #...# ##### #...# #...# #...#|####. #...# #...# ####. #...# #...# ####.|.###. #...# #.... #.... #.... #...# .###.|\" +\n  \"####. #...# #...# #...# #...# #...# ####.|##### #.... #.... ####. #.... #.... #####|##### #.... #.... ####. #.... #.... #....|\" +\n  \".###. #...# #.... #.### #...# #...# .####|#...# #...# #...# ##### #...# #...# #...#|.###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.|\" +\n  \"..### ...#. ...#. ...#. ...#. #..#. .##..|#...# #..#. #.#.. ##... #.#.. #..#. #...#|#.... #.... #.... #.... #.... #.... #####|\" +\n  \"#...# ##.## #.#.# #.#.# #...# #...# #...#|#...# #...# ##..# #.#.# #..## #...# #...#|.###. #...# #...# #...# #...# #...# .###.|\" +\n  \"####. #...# #...# ####. #.... #.... #....|.###. #...# #...# #...# #.#.# #..#. .##.#|####. #...# #...# ####. #.#.. #..#. #...#|\" +\n  \".#### #.... #.... .###. ....# ....# ####.|##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..|#...# #...# #...# #...# #...# #...# .###.|\" +\n  \"#...# #...# #...# #...# #...# .#.#. ..#..|#...# #...# #...# #.#.# #.#.# #.#.# .#.#.|#...# #...# .#.#. ..#.. .#.#. #...# #...#|\" +\n  \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..|##### ....# ...#. ..#.. .#... #.... #####\"\n)\n  .split(\"|\")\n  .map((g) => g.split(\" \").map((row) => [...row].map((c) => c === \"#\")));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h), f = h - i, p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6];\n}\n\nfunction rng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nconst code = (ch) => ch.charCodeAt(0) - 65;\nconst inGrid = (c, r) => c >= 0 && c \u003c COLS && r >= 0 && r \u003c ROWS;\n\nfunction puzzle(list, gen) {\n  const rand = rng(list * 7919 + gen * 104729 + 17);\n  const grid = new Int8Array(CELLS).fill(-1);\n  const words = LISTS[list].slice().sort((a, b) => b.length - a.length);\n  const turn = floor(rand() * 8), laid = [];\n  for (const [n, w] of words.entries()) {\n    for (let tries = 0; tries \u003c 400; tries++) {\n      // Each word tries its own direction first, so all eight turn up.\n      const d = DIRS[tries \u003c 200 ? (turn + n * 3) % 8 : floor(rand() * 8)], c0 = floor(rand() * COLS), r0 = floor(rand() * ROWS);\n      const c1 = c0 + d[0] * (w.length - 1), r1 = r0 + d[1] * (w.length - 1);\n      if (!inGrid(c1, r1)) continue;\n      let ok = true;\n      for (let i = 0; i \u003c w.length && ok; i++) {\n        const g = grid[(r0 + d[1] * i) * COLS + c0 + d[0] * i];\n        if (g >= 0 && g !== code(w[i])) ok = false;\n      }\n      if (!ok) continue;\n      for (let i = 0; i \u003c w.length; i++) grid[(r0 + d[1] * i) * COLS + c0 + d[0] * i] = code(w[i]);\n      laid.push(w);\n      break;\n    }\n  }\n  for (let i = 0; i \u003c CELLS; i++) if (grid[i] \u003c 0) grid[i] = floor(rand() * 26);\n  return { grid, words: laid.map((w) => w.split(\"\").map(code)) };\n}\n\nexport function setup(params) {\n  params.s = {\n    list: -1, gen: 0, grid: null, words: [], left: [], found: [],\n    phase: 0, t: 0, acc: 0, wait: 0,\n    cell: 0, dir: -1, k: 0, live: [], miss: -1, next: false,\n    seen: new Uint8Array(CELLS),\n    capIn: new Int8Array(N), capOut: new Int8Array(N),\n    hue: 0, fill: 0.06,\n    rgb: new Uint8Array(N * 3),\n    melt: null,\n  };\n  const S = params.s;\n  const rand = rng(99);\n  S.melt = new Float32Array(N);\n  for (let i = 0; i \u003c N; i++) S.melt[i] = rand();\n}\n\nfunction begin(S, list, gen) {\n  const p = puzzle(list, gen);\n  S.list = list;\n  S.gen = gen;\n  S.grid = p.grid;\n  S.words = p.words;\n  S.left = p.words.map((_, i) => i);\n  S.found = [];\n  S.phase = 0;\n  S.t = 0;\n  S.acc = 0;\n  S.wait = 0;\n  S.cell = 0;\n  S.dir = -1;\n  S.k = 0;\n  S.live = [];\n  S.miss = -1;\n  S.next = false;\n  S.seen.fill(0);\n  S.capIn.fill(0);\n  S.capOut.fill(0);\n}\n\nconst centre = (c, r) => [X0 + c * CW + 2, Y0 + r * CH + 3];\n\n// Mark the capsule round a found word in the two LED maps.\nfunction capsule(S, f) {\n  const [ax, ay] = centre(f.c, f.r), [bx, by] = centre(f.c + f.d[0] * (f.n - 1), f.r + f.d[1] * (f.n - 1));\n  const ux = bx - ax, uy = (by - ay) * SY, uu = ux * ux + uy * uy || 1;\n  const x0 = max(0, min(ax, bx) - 5), x1 = min(W - 1, max(ax, bx) + 5), y0 = max(0, min(ay, by) - 6), y1 = min(H - 1, max(ay, by) + 6);\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x - ax, py = (y - ay) * SY;\n      const t = cl((px * ux + py * uy) / uu, 0, 1);\n      const ex = px - t * ux, ey = py - t * uy, d = sqrt(ex * ex + ey * ey);\n      const p = y * W + x;\n      if (abs(d - R) \u003c 0.5) S.capOut[p] = f.i + 1;\n      else if (d \u003c R) S.capIn[p] = f.i + 1;\n    }\n}\n\n// The cells a probe from the cursor has read so far.\nfunction cellAt(S, i) {\n  const c = (S.cell % COLS) + DIRS[S.dir][0] * i, r = floor(S.cell / COLS) + DIRS[S.dir][1] * i;\n  return inGrid(c, r) ? r * COLS + c : -1;\n}\n\nfunction nextDir(S) {\n  S.k = 0;\n  S.miss = -1;\n  for (S.dir++; S.dir \u003c 8; S.dir++) {\n    S.live = S.left.filter((w) => S.words[w][0] === S.grid[S.cell]);\n    if (S.live.length && cellAt(S, 1) >= 0) return;\n  }\n  S.seen[S.cell] = 1;\n  S.cell++;\n  S.dir = -1;\n}\n\n// One comparison of the plain search.\nfunction tick(S) {\n  if (S.next) {\n    S.next = false;\n    nextDir(S);\n    if (S.dir \u003c 0) return;\n  }\n  if (S.cell >= CELLS || S.left.length === 0) {\n    S.phase = 2;\n    S.t = 0;\n    return;\n  }\n  if (S.dir \u003c 0) {\n    // On a new cell: does any word left start with its letter?\n    if (S.left.some((w) => S.words[w][0] === S.grid[S.cell])) nextDir(S);\n    else {\n      S.seen[S.cell] = 1;\n      S.cell++;\n    }\n    return;\n  }\n  const at = cellAt(S, S.k + 1);\n  const live = at \u003c 0 ? [] : S.live.filter((w) => S.words[w].length > S.k + 1 && S.words[w][S.k + 1] === S.grid[at]);\n  if (!live.length) {\n    S.miss = at;\n    S.next = true;\n    return;\n  }\n  S.k++;\n  S.live = live;\n  const done = live.find((w) => S.words[w].length === S.k + 1);\n  if (done != null) {\n    const f = { i: S.found.length, w: done, c: S.cell % COLS, r: floor(S.cell / COLS), d: DIRS[S.dir], n: S.k + 1 };\n    S.found.push(f);\n    S.left = S.left.filter((w) => w !== done);\n    capsule(S, f);\n    S.wait = FIND;\n    S.live = live.filter((w) => w !== done);\n    if (!S.live.length) S.next = true;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const list = round(cl(k[2] || 0, 0, LISTS.length - 1));\n  S.fill = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (list !== S.list) begin(S, list, 0);\n  const step = (d * speed) / 2;\n  S.t += step;\n  if (S.wait > 0) S.wait = max(0, S.wait - step);\n  if (S.phase === 0) {\n    if (S.t >= TYPE) {\n      S.phase = 1;\n      S.t = 0;\n    }\n  } else if (S.phase === 1) {\n    if (S.wait > 0) return;\n    S.acc += step;\n    while (S.acc >= STEP && S.phase === 1 && S.wait \u003c= 0) {\n      S.acc -= STEP;\n      tick(S);\n    }\n  } else if (S.phase === 2) {\n    if (S.t >= HOLD) {\n      S.phase = 3;\n      S.t = 0;\n    }\n  } else if (S.t >= MELT) begin(S, S.list, S.gen + 1);\n}\n\nfunction put(rgb, p, c, v) {\n  rgb[p * 3] = round(c[0] * v * 255);\n  rgb[p * 3 + 1] = round(c[1] * v * 255);\n  rgb[p * 3 + 2] = round(c[2] * v * 255);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.grid) return;\n  const rgb = S.rgb, h = S.hue, f = S.fill;\n  rgb.fill(0);\n  const wordCol = S.found.map((w) => hsv(h + 0.5 + ((w.i * 0.381966) % 1) * 0.62, 0.7, 1));\n  const fresh = S.wait > 0 ? S.found.length - 1 : -1;\n  // Capsules: a fill under the letters as Fill rises, and the outline.\n  for (let p = 0; p \u003c N; p++) {\n    const o = S.capOut[p], i = S.capIn[p];\n    if (o) put(rgb, p, wordCol[o - 1], o - 1 === fresh ? 1 : 0.85);\n    else if (i && f > 0.02) put(rgb, p, wordCol[i - 1], 0.8 * f);\n  }\n  const inWord = new Int8Array(CELLS).fill(-1);\n  for (const w of S.found) for (let j = 0; j \u003c w.n; j++) inWord[(w.r + w.d[1] * j) * COLS + w.c + w.d[0] * j] = w.i;\n  const probe = new Int8Array(CELLS);\n  if (S.phase === 1 && S.dir >= 0) {\n    for (let j = 1; j \u003c= S.k; j++) probe[cellAt(S, j)] = 1;\n    if (S.miss >= 0) probe[S.miss] = 2;\n  }\n  const base = hsv(h + 0.58, 0.28, 1), dim = hsv(h + 0.6, 0.4, 1);\n  const hit = hsv(h + 0.14, 0.45, 1), miss = hsv(h + 0.93, 0.6, 1), white = [1, 1, 1];\n  const knock = cl((f - 0.45) / 0.45, 0, 1), rest = 1 - 0.5 * f;\n  const typed = S.phase === 0 ? (S.t / TYPE) * (CELLS + 20) : 1e9;\n  const melt = S.phase === 3 ? S.t / MELT : -1;\n  for (let ci = 0; ci \u003c CELLS; ci++) {\n    if (ci > typed) continue;\n    const c = ci % COLS, r = floor(ci / COLS), g = FONT[S.grid[ci]];\n    let col = base, v = 0.55 * rest;\n    if (inWord[ci] >= 0) {\n      col = wordCol[inWord[ci]];\n      v = inWord[ci] === fresh ? 1 : 1 - 0.85 * knock;\n      if (inWord[ci] !== fresh && knock \u003c 0.5) col = col.map((x) => x + (1 - x) * 0.35);\n    } else if (S.phase === 1 && ci === S.cell) {\n      col = white;\n      v = 1;\n    } else if (probe[ci] === 1) {\n      col = hit;\n      v = 1;\n    } else if (probe[ci] === 2) {\n      col = miss;\n      v = 0.9;\n    } else if (S.seen[ci]) {\n      col = dim;\n      v = 0.32 * rest;\n    }\n    const x0 = X0 + c * CW, y0 = Y0 + r * CH;\n    for (let y = 0; y \u003c 7; y++)\n      for (let x = 0; x \u003c 5; x++) if (g[y][x]) put(rgb, (y0 + y) * W + x0 + x, col, v);\n  }\n  // The cursor's box in the gaps round its cell.\n  if (S.phase === 1 && S.cell \u003c CELLS) {\n    const x0 = X0 + (S.cell % COLS) * CW - 1, y0 = Y0 + floor(S.cell / COLS) * CH - 1;\n    for (let x = x0; x \u003c= x0 + 6; x++)\n      for (const y of [y0, y0 + 8]) if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(rgb, y * W + x, white, 0.6);\n    for (let y = y0; y \u003c= y0 + 8; y++)\n      for (const x of [x0, x0 + 6]) if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(rgb, y * W + x, white, 0.6);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    if (melt >= 0 && S.melt[p] \u003c melt) display.setPixel(p % W, floor(p / W), 0, 0, 0);\n    else display.setPixel(p % W, floor(p / W), rgb[p * 3], rgb[p * 3 + 1], rgb[p * 3 + 2]);\n  }\n}\n","baudot-tape":"// ===== Patternflow pattern =====\n// Title:   Baudot Tape\n// Family:  type\n// Idea:    Five-hole teleprinter tape runs up the whole height of the panel, each character arriving down the line as five pulses that set the punch at the bottom, punched as one row of holes with the small feed hole between the third and the fourth, and typed beside its row as it is punched, so the message reads down the panel next to its own code and passes under the reader at the top; line noise flips a pulse now and then, and when the pulse it flips belongs to a shift code the rest of the line comes out in the wrong shift, 1234567890 as QWERTYUIOP.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the five-unit code of Emile Baudot (1870s), rearranged by Donald Murray for a keyboard and punched tape (1901), in the letters and figures of International Telegraph Alphabet No. 2; 5 by 7 capitals and 3 by 5 tags drawn for this pattern, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Message=0..2, Noise=0..1\n//\n// Knob 1: Hue. Turns the paper, the ink and the marks round the wheel together. At 0 the tape is cream, the typed characters pale azure, the line hits pink and the punch's selectors gold; at 0.25 the tape is pale green and the ink violet, at 0.5 pale blue tape with peach ink, at 0.75 lilac tape with green ink.\n// Knob 2: Speed. Characters a second, 1.5 times the knob: 3 at 2, so a row takes 0.33 s and the tape climbs 24 LEDs a second; 0.3 at 0.2 and 4.5 at 3. Each character spends half its time arriving, a pulse at a time, and the rest punched and moving up one row of 8 LEDs.\n// Knob 3: Message. 0 the teleprinter test line THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 1234567890, 1 the RYRY test, R 01010 and Y 10101 in turn so the tape is a checkerboard, 2 a telegram, ARRIVE FRIDAY 10.45 STOP MEET TRAIN; after each the next one follows. Every message opens with a letters shift. Turning it starts the new message on the next row.\n// Knob 4: Noise. The chance a character takes a line hit that flips one of its five pulses, 0.6 times the knob: 3.6% at the opening 0.06, 15% at 0.25, 60% at 1. A hit row gets a pink tick in the margin and a pink ring round the flipped hole, and whatever the receiver types wrong is pink. A hit on the figures shift before 1234567890 leaves the receiver in letters, and the digits come out QWERTYUIOP; a hit on the letters shift that opens the RYRY test leaves it in figures, and it comes out 464646.\n\n// ITA2 sends a character as five pulses, each mark or space; a punched\n// tape keeps them as five holes across one row, bit 1 on the left, with\n// a smaller feed hole between bit 3 and bit 4 that the sprocket pulls the\n// tape by. Thirty-two codes are not enough for letters and figures, so\n// two of them are shifts: 11011 puts the receiver in figures and 11111\n// back in letters, and every other code means a letter or a figure by\n// which shift came last. Space 00100, carriage return 00010 and line feed\n// 01000 mean the same in both. The figures drawn here are the digits, on\n// the top row of letters Q W E R T Y U I O P, and the marks on A B C K L\n// M N S V X Z; J in figures rings the bell, drawn as a bell, and D F G H\n// in figures get no figure here and are drawn as an empty box.\n//\n// The receiver keeps only the shift, so a single flipped pulse in a shift\n// code changes how everything after it reads, up to the next shift code.\n// Each row is decoded as it is punched, by the receiver's own shift, and\n// compared with what was sent: what does not match is typed in pink.\n//\n// The tape climbs: rows are punched at the bottom, under the punch at row\n// 106, and a row that has climbed twelve rows stops under the reader at\n// row 10, whose pins drop through the holes they find.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, round, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Letters shift, bit 1 first.\nconst LT = {\n  A: \"11000\", B: \"10011\", C: \"01110\", D: \"10010\", E: \"10000\", F: \"10110\", G: \"01011\", H: \"00101\", I: \"01100\",\n  J: \"11010\", K: \"11110\", L: \"01001\", M: \"00111\", N: \"00110\", O: \"00011\", P: \"01101\", Q: \"11101\", R: \"01010\",\n  S: \"10100\", T: \"00001\", U: \"11100\", V: \"01111\", W: \"11001\", X: \"10111\", Y: \"10101\", Z: \"10001\",\n};\n// Figures shift on the same codes; \"*\" is the bell, \"#\" an empty box.\nconst FG = {\n  Q: \"1\", W: \"2\", E: \"3\", R: \"4\", T: \"5\", Y: \"6\", U: \"7\", I: \"8\", O: \"9\", P: \"0\",\n  A: \"-\", B: \"?\", C: \":\", K: \"(\", L: \")\", M: \".\", N: \",\", S: \"'\", V: \"=\", X: \"/\", Z: \"+\", J: \"*\",\n  D: \"#\", F: \"#\", G: \"#\", H: \"#\",\n};\nconst SP = 4, CR = 2, LF = 8, FIGS = 27, LTRS = 31, NUL = 0;\nconst C2L = [], C2F = [], F2C = {};\nfor (const ch in LT) {\n  const c = parseInt(LT[ch], 2);\n  C2L[c] = ch;\n  C2F[c] = FG[ch];\n  if (FG[ch] !== \"#\" && FG[ch] !== \"*\") F2C[FG[ch]] = c;\n}\n\nconst MSG = [\n  \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 1234567890\",\n  \"RYRYRYRYRYRYRYRYRYRYRYRY\",\n  \"ARRIVE FRIDAY 10.45 STOP MEET TRAIN\",\n];\n\n// 5 by 7 capitals, figures and marks: seven rows, each a base-32 digit\n// whose five bits are the row's LEDs, left first.\nconst BIG = {\n  A: \"ehhvhhh\", B: \"uhhuhhu\", C: \"ehggghe\", D: \"uhhhhhu\", E: \"vgguggv\", F: \"vgguggg\", G: \"ehgjhhe\", H: \"hhhvhhh\",\n  I: \"e44444e\", J: \"72222ic\", K: \"hikokih\", L: \"ggggggv\", M: \"hrllhhh\", N: \"hhpljhh\", O: \"ehhhhhe\", P: \"uhhuggg\",\n  Q: \"ehhhlid\", R: \"uhhukih\", S: \"fgge11u\", T: \"v444444\", U: \"hhhhhhe\", V: \"hhhhha4\", W: \"hhhllla\", X: \"hha4ahh\",\n  Y: \"hha4444\", Z: \"v1248gv\", 0: \"ehjlphe\", 1: \"4c4444e\", 2: \"eh1248v\", 3: \"v2421he\", 4: \"26aiv22\", 5: \"vgu11he\",\n  6: \"68guhhe\", 7: \"v124888\", 8: \"ehhehhe\", 9: \"ehhf12c\", \".\": \"00000cc\", \",\": \"0000c48\", \"-\": \"000v000\",\n  \"?\": \"eh12404\", \"'\": \"4480000\", \":\": \"0cc0cc0\", \"(\": \"2488842\", \")\": \"8422248\", \"/\": \"01248g0\", \"=\": \"00v0v00\",\n  \"+\": \"044v440\", \"#\": \"0eaaae0\", \"*\": \"4eeev04\",\n};\n// 3 by 5 letters for the tags of the codes that type nothing: five rows,\n// each an octal digit.\nconst SMALL = { C: \"74447\", F: \"74644\", G: \"74557\", I: \"72227\", L: \"44447\", R: \"65655\", T: \"72222\" };\n\n// Geometry: row pitch, the punch and reader rows, the five hole columns\n// and the feed hole's, the tape's edges, the typed column.\nconst RP = 8, YP = 106, YR = 10, HX = [8, 14, 20, 32, 38], FX = 26, TX0 = 3, TX1 = 43, GX = 51;\nconst KEEP = 20;\n\n// A message as rows: what is punched and what the row should type.\nfunction encode(text) {\n  const rows = [{ code: LTRS, want: \"LTR\" }];\n  let fig = false;\n  for (const ch of text) {\n    if (ch === \" \") rows.push({ code: SP, want: \" \" });\n    else if (LT[ch]) {\n      if (fig) rows.push({ code: LTRS, want: \"LTR\" }), (fig = false);\n      rows.push({ code: parseInt(LT[ch], 2), want: ch });\n    } else if (F2C[ch] != null) {\n      if (!fig) rows.push({ code: FIGS, want: \"FIG\" }), (fig = true);\n      rows.push({ code: F2C[ch], want: ch });\n    }\n  }\n  rows.push({ code: CR, want: \"CR\" }, { code: LF, want: \"LF\" }, { code: NUL, want: \"\" }, { code: NUL, want: \"\" });\n  return rows;\n}\nconst ENC = MSG.map(encode);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// The receiver: the row as it came down the line, decoded in the shift it\n// is in.\nfunction receive(S, sent, n) {\n  let flip = 0;\n  if (Math.random() \u003c S.noise) flip = 1 \u003c\u003c floor(Math.random() * 5);\n  const code = sent.code ^ flip;\n  let key;\n  if (code === LTRS) (S.fig = false), (key = \"LTR\");\n  else if (code === FIGS) (S.fig = true), (key = \"FIG\");\n  else if (code === SP) key = \" \";\n  else if (code === CR) key = \"CR\";\n  else if (code === LF) key = \"LF\";\n  else if (code === NUL) key = \"\";\n  else key = S.fig ? C2F[code] : C2L[code];\n  return { code, flip, key, bad: key !== sent.want, n, age: 0 };\n}\n\nfunction queue(S, m) {\n  S.m = ((m % MSG.length) + MSG.length) % MSG.length;\n  S.q = ENC[S.m].slice();\n}\n\nfunction next(S) {\n  if (!S.q.length) queue(S, S.m + 1);\n  S.cur = S.q.shift();\n  S.curRx = null;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, noise: 0.1, knob: -1, m: 0, q: [], rows: [], cur: null, curRx: null, fig: false,\n    ph: 0, T: 0, base: 0, buf: new Float32Array(N * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.noise = 0.6 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const km = round(cl(k[2] || 0, 0, 2));\n  if (km !== S.knob) {\n    if (S.knob \u003c 0) {\n      // A fresh tape opens on the end of the message before, already\n      // punched and typed, with the receiver in letters.\n      const before = ENC[(km + MSG.length - 1) % MSG.length];\n      const tail = before.slice(before.length - 15);\n      tail.forEach((r, i) => S.rows.push(receive(S, r, i - tail.length)));\n      for (const r of S.rows) r.age = 9;\n      queue(S, km);\n      next(S);\n    } else queue(S, km);\n    S.knob = km;\n  }\n  const rate = 1.5 * speed, was = S.ph;\n  S.ph += d * rate;\n  for (const r of S.rows) r.age += d;\n  // Half way through its time the row is punched and typed.\n  if (!S.curRx) S.curRx = receive(S, S.cur, S.base);\n  if (was \u003c 0.5 && S.ph >= 0.5) {\n    S.curRx.age = 0;\n    S.rows.push(S.curRx);\n    if (S.rows.length > KEEP) S.rows.shift();\n  }\n  // Then the tape moves up one row, from 0.55 to 0.95 of the time.\n  if (S.ph >= 1) {\n    S.ph -= 1;\n    S.base++;\n    next(S);\n  }\n  S.T = S.base + smooth((S.ph - 0.55) / 0.4);\n}\n\nfunction px(buf, x, y, c, a) {\n  if (a \u003c= 0 || x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  if (a > 1) a = 1;\n  buf[p] += (c[0] - buf[p]) * a;\n  buf[p + 1] += (c[1] - buf[p + 1]) * a;\n  buf[p + 2] += (c[2] - buf[p + 2]) * a;\n}\n\n// A disc (or a ring of width w) centred on (x, y).\nfunction disc(buf, x, y, r, c, a, w) {\n  for (let Y = floor(y - r - 1); Y \u003c= y + r + 1; Y++)\n    for (let X = floor(x - r - 1); X \u003c= x + r + 1; X++) {\n      const e = sqrt((X + 0.5 - x) ** 2 + (Y + 0.5 - y) ** 2);\n      const cov = w ? cl(w / 2 + 0.5 - abs(e - r), 0, 1) : cl(r + 0.5 - e, 0, 1);\n      px(buf, X, Y, c, a * cov);\n    }\n}\n\n// A glyph of rows (base-32 for the capitals, octal for the tags) with its\n// top at a fractional row, the fraction shared between two LED rows.\n// Bold doubles each lit LED to the right, as a typewheel's heavy face.\nfunction glyph(buf, rows, base, wide, x0, top, c, a, bold) {\n  const y0 = floor(top), f = top - y0;\n  for (let r = 0; r \u003c rows.length; r++) {\n    const bits = parseInt(rows[r], base);\n    for (let j = 0; j \u003c wide; j++)\n      if ((bits >> (wide - 1 - j)) & 1)\n        for (let b = 0; b \u003c= bold; b++) {\n          px(buf, x0 + j + b, y0 + r, c, a * (1 - f));\n          px(buf, x0 + j + b, y0 + r + 1, c, a * f);\n        }\n  }\n}\n\nfunction typed(buf, key, top, c, a) {\n  if (!key || key === \" \") return;\n  if (BIG[key]) return glyph(buf, BIG[key], 32, 5, GX, top, c, a, 1);\n  // A tag: two or three small letters, centred on the capitals' column.\n  const w = key.length * 4 - 1;\n  let x = GX + 3 - floor(w / 2);\n  for (const ch of key) glyph(buf, SMALL[ch], 8, 3, x, top + 1, c, a, 0), (x += 4);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, h = S.hue;\n  buf.fill(0);\n  const paper = hsv(h + 0.13, 0.3, 0.72), ink = hsv(h + 0.55, 0.42, 1), dim = hsv(h + 0.55, 0.3, 0.55);\n  const hit = hsv(h + 0.95, 0.65, 1), gold = hsv(h + 0.12, 0.7, 1), steel = [0.42, 0.44, 0.48], white = [1, 1, 1];\n\n  // The paper, a little darker at its edges.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = TX0; x \u003c= TX1; x++) {\n      const e = min(x - TX0, TX1 - x), v = e === 0 ? 0.62 : e === 1 ? 0.85 : 1, p = (y * W + x) * 3;\n      buf[p] = paper[0] * v;\n      buf[p + 1] = paper[1] * v;\n      buf[p + 2] = paper[2] * v;\n    }\n\n  // The punched rows climbing, their holes, their line hits, and beside\n  // each the character it typed.\n  const black = [0, 0, 0];\n  let under = null;\n  for (const r of S.rows) {\n    const y = YP - (S.T - r.n) * RP;\n    if (y \u003c -RP || y > H + RP) continue;\n    if (abs(y - YR) \u003c 0.5) under = r;\n    disc(buf, FX + 0.5, y + 0.5, 1.05, black, 1);\n    for (let b = 0; b \u003c 5; b++) {\n      const on = (r.code >> (4 - b)) & 1;\n      if (on) disc(buf, HX[b] + 0.5, y + 0.5, 2.1, black, 1);\n      if ((r.flip >> (4 - b)) & 1) disc(buf, HX[b] + 0.5, y + 0.5, 2.8, hit, 1, 1.1);\n    }\n    // A line hit also gets a pink tick in the margin beside its row.\n    if (r.flip) for (let dy = -2; dy \u003c= 3; dy++) for (let x = TX1 + 2; x \u003c= TX1 + 3; x++) px(buf, x, round(y) + dy, hit, 0.85);\n    const fresh = smooth(1 - r.age * 4), tag = r.key.length > 1;\n    const base = r.bad ? hit : tag ? dim : ink;\n    const c = [base[0] + (1 - base[0]) * fresh, base[1] + (1 - base[1]) * fresh, base[2] + (1 - base[2]) * fresh];\n    typed(buf, r.key, y - 3, c, 1);\n  }\n\n  // The punch: two steel bars across the tape, and between them the row\n  // being received, each mark pulse lighting its selector as it arrives.\n  for (let x = TX0 - 2; x \u003c= TX1 + 2; x++) {\n    px(buf, x, YP - 3, steel, 1);\n    px(buf, x, YP + 4, steel, 1);\n    px(buf, x, YR - 3, steel, 1);\n    px(buf, x, YR + 4, steel, 1);\n  }\n  for (const yy of [YP - 3, YP + 4, YR - 3, YR + 4]) {\n    px(buf, TX0 - 3, yy, steel, 0.6);\n    px(buf, TX1 + 3, yy, steel, 0.6);\n  }\n  if (S.curRx && S.ph \u003c 0.5) {\n    for (let b = 0; b \u003c 5; b++) {\n      const at = 0.07 + 0.07 * b;\n      if (S.ph >= at && (S.curRx.code >> (4 - b)) & 1) disc(buf, HX[b] + 0.5, YP + 0.5, 0.9, gold, smooth((S.ph - at) / 0.05));\n    }\n  }\n  // The punch fires: a flash round the new holes.\n  const last = S.rows[S.rows.length - 1];\n  if (last && last.age \u003c 0.25) {\n    const y = YP - (S.T - last.n) * RP, a = 1 - last.age / 0.25;\n    for (let b = 0; b \u003c 5; b++) if ((last.code >> (4 - b)) & 1) disc(buf, HX[b] + 0.5, y + 0.5, 2.4, white, a, 0.8);\n  }\n\n  // The reader: a pin over each hole column, dropped through where it\n  // finds a hole, resting on the paper where it does not.\n  for (let b = 0; b \u003c 5; b++) {\n    const through = under && (under.code >> (4 - b)) & 1;\n    disc(buf, HX[b] + 0.5, YR + 0.5, through ? 1.1 : 0.7, through ? gold : steel, 1);\n  }\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","beading-letters":"// ===== Patternflow pattern =====\n// Title:   Beading Letters\n// Family:  type\n// Idea:    A three-letter word stacked down the panel in capitals 37 rows tall is poured stroke by stroke as round glossy threads of liquid, and every thread then does what Plateau and Rayleigh showed a cylinder of liquid must do: a ripple about nine and a half radii long grows on it from almost nothing, the strokes neck and pinch off roughly in the order they were poured, and each breaks into evenly spaced drops with a small satellite between them that ring and round off, so the word stands as a dotted, dot-matrix version of itself until the drops run off the bottom and the next word is poured.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Plateau-Rayleigh instability (Joseph Plateau, 1873; Lord Rayleigh, 1878), with the viscous term of Weber's long-wave equation (Constantin Weber, 1931) and the ringing of a drop in Rayleigh's lowest shape mode (Lord Rayleigh, 1879) damped at the rate Horace Lamb gave for a viscous drop; capitals drawn for this pattern as lines and elliptical arcs, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Thickness=1.5..2.5, Viscosity=0..1\n//\n// Knob 1: Hue. The liquid's colour, turned round the wheel from cyan at 0: violet at 0.25, red at 0.5, yellow green at 0.75. The highlight on every thread and drop stays white, and the caustic beside it is the liquid's colour paled.\n// Knob 2: Speed. At 2 DEW is poured in 1.7 s, its first stroke breaks at 2.3 s and its last at 3.6 s, the dotted word holds 2 s, and at 5.6 s the drops let go and run off the bottom while INK is poured from 5.8 s. Every time goes as 2 / Speed, ten times slower at 0.2 and one and a half times faster at 3.\n// Knob 3: Thickness. The thread's radius in LEDs, from 1.5 at the opening (a thread 3 LEDs across) to 2.5. The fastest ripple is 14.4 LEDs long at 1.5 and 24 at 2.5, so the stem of the D breaks into four drops at 1.5 and keeps only its two corner drops at 2.5, and a drop from the middle of a stroke grows from 5.5 LEDs across to about 9.5. A thicker thread is also slower, as the radius to the power 1.5: at 2.5 everything takes 2.15 times as long.\n// Knob 4: Viscosity. The Ohnesorge number, the liquid's viscosity against its surface tension at this size, from 0 to 1. The fastest ripple is 9.02 radii long at 0, 9.6 at the opening 0.06 and 16.1 at 1, so a thicker liquid breaks into fewer, bigger drops, 2.7 times more slowly, and its threads draw out into thin filaments between bulbs before they snap. At the opening a drop rings about once every 0.83 s and the ringing falls by e in 1.7 s; from about 0.8 the drops creep round without ringing.\n\n// Plateau measured it and Rayleigh explained it: a long cylinder of liquid\n// held only by surface tension is unstable. Any ripple r = r0 (1 + a cos kz)\n// longer than the thread's circumference (k r0 \u003c 1) lowers the surface area\n// at fixed volume, so it grows, as a = a0 exp(sigma t). Rayleigh's growth\n// rate for an inviscid thread, in units of tau = sqrt(rho r0^3 / gamma), is\n//   sigma^2 = x (1 - x^2) I1(x) / I0(x),   x = k r0,\n// largest at x = 0.697, a wavelength of 9.02 radii, with sigma = 0.343.\n// Viscosity enters through Weber's long-wave equation, which adds a damping\n// term 3 Oh x^2 sigma to the left; here that term is added to Rayleigh's\n// exact right-hand side, so Oh = 0 gives Rayleigh's numbers back.\n//\n// Each stroke of a letter is a thread of length L with free ends. Its modes\n// are cos(2 pi n s / L), with a crest at both ends (a free end gathers\n// liquid), and of the whole numbers n the stroke takes the one whose sigma\n// is largest: the fastest ripple that fits. Its crests are where the drops\n// form, so a stroke always ends in a drop and every corner of a letter, where\n// strokes meet, gets one drop that all of them feed; it forms as soon as the\n// first of them breaks, as a bulb on the ends of the others. The ripple grows\n// from a small random a0, 0.012 to 0.03, from the moment the liquid is laid,\n// so the word pinches roughly in the order it was poured. The volume per\n// wavelength is kept: r0 shrinks as a grows, and each drop gets the volume of\n// the thread it came from, a free end the volume of a whole wavelength. With\n// viscosity the profile is sharpened into bulbs on thin filaments.\n//\n// After a pinch each drop starts stretched along its stroke and relaxes as a\n// spheroid of fixed volume, ringing in Rayleigh's lowest shape mode, omega^2\n// = 8 gamma / (rho R^3), damped at Lamb's rate 5 nu / R^2. A small satellite\n// is left where each neck broke.\n//\n// Every thread and drop is drawn as a body of revolution: for each LED the\n// nearest point of the stroke, its arc length s and the side the LED is on\n// give a surface normal, which a light from the upper left shades with a\n// white highlight and a glow on the far side, as light passes through.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sqrt, sin, cos, exp, log, pow, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst WORDS = [\"DEW\", \"INK\", \"OIL\", \"SEA\", \"WET\", \"SAP\", \"TAR\", \"GEL\"];\n// Letters 37 rows tall, 8 units of 4.625 LEDs, at rows 3, 45.5 and 88.\nconst LH = 37, U = LH / 8, TOP = 3, PITCH = 42.5;\n// Model seconds (real seconds at Speed 2).\nconst POUR = 1.2, JUMP = 0.05, HOLD = 2.0, NEXT = 0.25, FALL = 520, TAU0 = 0.15, R0REF = 1.5;\nconst HUE0 = 0.5;\n\n// Strokes: a start point, then \"L\" x y for a line or \"A\" cx cy rx ry a0 a1\n// for an elliptical arc in degrees (y down); \"Z\" closes the stroke.\n// All joins between strokes are at stroke ends.\nconst GLYPHS = {\n  D: [10, [[0, 0, \"L\", 0, 8], [0, 0, \"L\", 5, 0, \"A\", 5, 4, 5, 4, -90, 90, \"L\", 0, 8]]],\n  E: [9, [[0, 0, \"L\", 0, 4], [0, 4, \"L\", 0, 8], [0, 0, \"L\", 9, 0], [0, 4, \"L\", 7, 4], [0, 8, \"L\", 9, 8]]],\n  W: [11, [[0, 0, \"L\", 2.75, 8], [2.75, 8, \"L\", 5.5, 1.5], [5.5, 1.5, \"L\", 8.25, 8], [8.25, 8, \"L\", 11, 0]]],\n  I: [6, [[0, 0, \"L\", 3, 0], [3, 0, \"L\", 6, 0], [3, 0, \"L\", 3, 8], [0, 8, \"L\", 3, 8], [3, 8, \"L\", 6, 8]]],\n  N: [9, [[0, 8, \"L\", 0, 0], [0, 0, \"L\", 9, 8], [9, 8, \"L\", 9, 0]]],\n  K: [9, [[0, 0, \"L\", 0, 4.5], [0, 4.5, \"L\", 0, 8], [0, 4.5, \"L\", 9, 0], [0, 4.5, \"L\", 9, 8]]],\n  O: [10, [[10, 4, \"A\", 5, 4, 5, 4, 0, 360, \"Z\"]]],\n  L: [8, [[0, 0, \"L\", 0, 8], [0, 8, \"L\", 8, 8]]],\n  S: [9, [[8.397, 1, \"A\", 4.5, 2, 4.5, 2, -30, -270, \"A\", 4.5, 6, 4.5, 2, -90, 150]]],\n  A: [10, [[0, 8, \"L\", 1.5625, 5.5], [1.5625, 5.5, \"L\", 5, 0], [5, 0, \"L\", 8.4375, 5.5], [8.4375, 5.5, \"L\", 10, 8], [1.5625, 5.5, \"L\", 8.4375, 5.5]]],\n  T: [10, [[0, 0, \"L\", 5, 0], [5, 0, \"L\", 10, 0], [5, 0, \"L\", 5, 8]]],\n  P: [9, [[0, 0, \"L\", 0, 4.6], [0, 4.6, \"L\", 0, 8], [0, 0, \"L\", 5, 0, \"A\", 5, 2.3, 4, 2.3, -90, 90, \"L\", 0, 4.6]]],\n  R: [9, [[0, 0, \"L\", 0, 4.6], [0, 4.6, \"L\", 0, 8], [0, 0, \"L\", 5, 0, \"A\", 5, 2.3, 4, 2.3, -90, 90], [5, 4.6, \"L\", 0, 4.6], [5, 4.6, \"L\", 9, 8]]],\n  G: [10, [[8.83, 1.429, \"A\", 5, 4, 5, 4, -40, -360], [10, 4, \"L\", 6, 4]]],\n};\n\n// ---- Rayleigh's growth rate with Weber's viscous term.\nfunction besselRatio(x) {\n  let t0 = 1, t1 = x / 2, i0 = 0, i1 = 0;\n  const h = (x * x) / 4;\n  for (let k = 0; k \u003c 10; k++) {\n    i0 += t0;\n    i1 += t1;\n    t0 *= h / ((k + 1) * (k + 1));\n    t1 *= h / ((k + 1) * (k + 2));\n  }\n  return i1 / i0;\n}\n\nfunction growth(x, oh) {\n  if (x >= 1) return 0;\n  const f = x * (1 - x * x) * besselRatio(x), b = 3 * oh * x * x;\n  return (-b + sqrt(b * b + 4 * f)) / 2;\n}\n\n// ---- Stroke geometry, in LEDs.\nfunction strokeOf(cmd, ox, oy) {\n  const xs = [ox + cmd[0] * U], ys = [oy + cmd[1] * U];\n  let closed = false;\n  for (let i = 2; i \u003c cmd.length; ) {\n    const c = cmd[i];\n    if (c === \"L\") {\n      xs.push(ox + cmd[i + 1] * U);\n      ys.push(oy + cmd[i + 2] * U);\n      i += 3;\n    } else if (c === \"A\") {\n      const cx = cmd[i + 1], cy = cmd[i + 2], rx = cmd[i + 3], ry = cmd[i + 4], a0 = (cmd[i + 5] * PI) / 180, a1 = (cmd[i + 6] * PI) / 180;\n      const steps = max(4, ceil((abs(a1 - a0) * sqrt((rx * rx + ry * ry) / 2) * U) / 0.8));\n      for (let k = 0; k \u003c= steps; k++) {\n        const a = a0 + ((a1 - a0) * k) / steps;\n        xs.push(ox + (cx + rx * cos(a)) * U);\n        ys.push(oy + (cy + ry * sin(a)) * U);\n      }\n      i += 7;\n    } else {\n      closed = true;\n      i++;\n    }\n  }\n  // Drop repeated points, measure arc length.\n  const px = [xs[0]], py = [ys[0]], ps = [0];\n  for (let k = 1; k \u003c xs.length; k++) {\n    const d = sqrt((xs[k] - px[px.length - 1]) ** 2 + (ys[k] - py[py.length - 1]) ** 2);\n    if (d \u003c 1e-4) continue;\n    px.push(xs[k]);\n    py.push(ys[k]);\n    ps.push(ps[ps.length - 1] + d);\n  }\n  return { px, py, ps, L: ps[ps.length - 1], closed };\n}\n\n// Point and unit tangent at arc length s.\nfunction at(st, s, o) {\n  const { px, py, ps } = st;\n  let i = 0;\n  while (i \u003c ps.length - 2 && ps[i + 1] \u003c s) i++;\n  const len = ps[i + 1] - ps[i], u = cl((s - ps[i]) / len, 0, 1);\n  o[0] = px[i] + (px[i + 1] - px[i]) * u;\n  o[1] = py[i] + (py[i + 1] - py[i]) * u;\n  o[2] = (px[i + 1] - px[i]) / len;\n  o[3] = (py[i + 1] - py[i]) / len;\n  return o;\n}\n\nfunction wordOf(index) {\n  const text = WORDS[index], strokes = [];\n  for (let l = 0; l \u003c text.length; l++) {\n    const [w, cmds] = GLYPHS[text[l]];\n    const ox = 32 - (w * U) / 2, oy = TOP + l * PITCH;\n    for (const c of cmds) {\n      const st = strokeOf(c, ox, oy);\n      st.letter = l;\n      st.eps = 0.012 + 0.018 * Math.random();\n      st.envP = TAU * Math.random();\n      strokes.push(st);\n    }\n  }\n  return { index, strokes, beads: [], sats: [], S0: 0, Td: 1e9 };\n}\n\n// ---- Timing and drops for the current knobs: the mode each stroke takes,\n// when it pinches, and the drops it leaves.\nfunction plan(S, wd) {\n  const r0 = S.r0, oh = S.oh, tau = TAU0 * pow(r0 / R0REF, 1.5);\n  let total = 0;\n  for (const st of wd.strokes) total += st.L;\n  const v = total / POUR, tmp = [0, 0, 0, 0];\n  // The fastest growth an endless thread could have, for the floor below.\n  let smax = 0;\n  for (let x = 0.02; x \u003c 1; x += 0.01) smax = max(smax, growth(x, oh));\n  let t = wd.S0;\n  wd.beads = [];\n  wd.sats = [];\n  const nodes = [];\n  for (const st of wd.strokes) {\n    let best = -1, bn = st.closed ? 2 : 1;\n    for (let n = st.closed ? 2 : 1; n \u003c 40; n++) {\n      const g = growth((TAU * n * r0) / st.L, oh);\n      if (g > best) {\n        best = g;\n        bn = n;\n      }\n      if ((TAU * n * r0) / st.L >= 1) break;\n    }\n    st.n = bn;\n    st.k = (TAU * bn) / st.L;\n    // A stroke too short for a fast ripple (at 2.5 LEDs the serif of the I\n    // has k r0 >= 1 for every n) still balls up into its end drops, here at\n    // no less than 0.6 of the fastest rate.\n    st.sig = max(best, 0.6 * smax);\n    st.tau = tau;\n    st.v = v;\n    st.r0 = r0;\n    st.t0 = t;\n    st.t1 = t + st.L / v;\n    // A slow swell 2.7 wavelengths long lets some crests grow ahead of others.\n    st.envK = TAU / (2.7 * 9.6 * r0);\n    st.tp = max(st.t1 + 0.2, t + st.L / (2 * v) + (tau * log(1 / st.eps)) / st.sig);\n    t = st.t1 + JUMP;\n    const vol = PI * r0 * r0 * (st.L / bn);\n    const first = st.closed ? 0 : 1;\n    for (let k = first; k \u003c bn; k++) {\n      at(st, (k * st.L) / bn, tmp);\n      wd.beads.push({ x: tmp[0], y: tmp[1], tx: tmp[2], ty: tmp[3], V: vol, act: st.tp, e0: 0.5 });\n    }\n    for (let k = 0; k \u003c bn; k++) {\n      at(st, ((k + 0.5) * st.L) / bn, tmp);\n      wd.sats.push({ x: tmp[0], y: tmp[1], act: st.tp + 0.04, fall: 0 });\n    }\n    if (!st.closed)\n      for (const e of [0, 1]) {\n        at(st, e * st.L, tmp);\n        let node = null;\n        for (const nd of nodes) if (nd.letter === st.letter && abs(nd.x - tmp[0]) \u003c 0.6 && abs(nd.y - tmp[1]) \u003c 0.6) node = nd;\n        if (!node) {\n          node = { letter: st.letter, x: tmp[0], y: tmp[1], tx: tmp[2], ty: tmp[3], V: 0, act: 1e9, m: 0, e0: 0.2 };\n          nodes.push(node);\n        }\n        node.V += vol / 2;\n        node.m++;\n        node.act = min(node.act, st.tp);\n      }\n  }\n  // A free end gathers the liquid of the end it retracts from.\n  for (const nd of nodes) {\n    if (nd.m === 1) nd.V *= 2;\n    wd.beads.push(nd);\n  }\n  let last = 0;\n  for (const st of wd.strokes) last = max(last, st.tp);\n  for (const b of wd.beads) {\n    b.R = Math.cbrt((3 * b.V) / (4 * PI));\n    const q = r0 / b.R;\n    b.w = sqrt(8 * q * q * q) / tau;\n    b.g = (5 * oh * q * q) / tau;\n    b.fall = b.fall || 0;\n    last = max(last, b.act);\n  }\n  wd.Td = last + HOLD;\n  wd.v = v;\n  wd.Q = 1 + 2 * oh;\n  // Means of the sharpened profile c' over a period, for the volume.\n  let m1 = 0, m2 = 0;\n  for (let i = 0; i \u003c 64; i++) {\n    const c = 2 * pow((1 + cos((TAU * (i + 0.5)) / 64)) / 2, wd.Q) - 1;\n    m1 += c / 64;\n    m2 += (c * c) / 64;\n  }\n  wd.m1 = m1;\n  wd.m2 = m2;\n}\n\n// ---- For every LED near a stroke, the nearest point of up to two strokes.\nfunction buildMap(S, wd) {\n  const reach = (S.reach = 2.2 * S.r0 + 1.2);\n  const { sj, sd, ss, sdx, sdy, stx, sty, scap } = S;\n  sj.fill(-1);\n  wd.strokes.forEach((st, j) => {\n    const { px, py, ps } = st, last = px.length - 2;\n    for (let i = 0; i \u003c= last; i++) {\n      const ax = px[i], ay = py[i], len = ps[i + 1] - ps[i];\n      const tx = (px[i + 1] - ax) / len, ty = (py[i + 1] - ay) / len;\n      const x0 = max(0, floor(min(ax, px[i + 1]) - reach)), x1 = min(W - 1, ceil(max(ax, px[i + 1]) + reach));\n      const y0 = max(0, floor(min(ay, py[i + 1]) - reach)), y1 = min(H - 1, ceil(max(ay, py[i + 1]) + reach));\n      for (let y = y0; y \u003c= y1; y++)\n        for (let x = x0; x \u003c= x1; x++) {\n          const qx = x + 0.5 - ax, qy = y + 0.5 - ay;\n          let t = qx * tx + qy * ty, cap = 0;\n          if (t \u003c 0) {\n            if (!st.closed && i === 0) cap = 1;\n            t = 0;\n          } else if (t > len) {\n            if (!st.closed && i === last) cap = 1;\n            t = len;\n          }\n          let dx = qx - tx * t, dy = qy - ty * t;\n          const d = sqrt(dx * dx + dy * dy);\n          if (d > reach) continue;\n          if (d > 1e-6) {\n            dx /= d;\n            dy /= d;\n          } else {\n            dx = -ty;\n            dy = tx;\n          }\n          const p = (y * W + x) * 2;\n          let k = -1;\n          if (sj[p] === j) k = d \u003c sd[p] ? p : -2;\n          else if (sj[p + 1] === j) k = d \u003c sd[p + 1] ? p + 1 : -2;\n          else if (sj[p] \u003c 0) k = p;\n          else if (sj[p + 1] \u003c 0) k = p + 1;\n          else k = sd[p] > sd[p + 1] ? (d \u003c sd[p] ? p : -2) : d \u003c sd[p + 1] ? p + 1 : -2;\n          if (k \u003c 0) continue;\n          sj[k] = j;\n          sd[k] = d;\n          ss[k] = ps[i] + t;\n          sdx[k] = dx;\n          sdy[k] = dy;\n          stx[k] = tx;\n          sty[k] = ty;\n          scap[k] = cap;\n        }\n    }\n  });\n  let n = 0;\n  for (let p = 0; p \u003c N; p++) if (sj[p * 2] >= 0) S.active[n++] = p;\n  S.nActive = n;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, r0: 1.5, oh: 0.06, m: 0, idx: 0, cur: null, old: null, reach: 4.5,\n    sj: new Int16Array(N * 2), sd: new Float32Array(N * 2), ss: new Float32Array(N * 2),\n    sdx: new Float32Array(N * 2), sdy: new Float32Array(N * 2), stx: new Float32Array(N * 2),\n    sty: new Float32Array(N * 2), scap: new Int8Array(N * 2), active: new Int32Array(N), nActive: 0,\n    K: new Float32Array(N), C: new Float32Array(N), NX: new Float32Array(N), NY: new Float32Array(N), NZ: new Float32Array(N),\n    CA: new Float32Array(N), CB: new Float32Array(N),\n    base: [0, 0, 0], tmp: [0, 0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1.5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const r0 = cl(k[2] == null ? 1.5 : k[2], 1.5, 2.5), oh = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const newR = abs(r0 - S.r0) > 0.004, newOh = abs(oh - S.oh) > 0.002;\n  if (newR) S.r0 = r0;\n  if (newOh) S.oh = oh;\n  if (!S.cur) {\n    S.cur = wordOf(S.idx);\n    S.cur.S0 = 0;\n    plan(S, S.cur);\n    buildMap(S, S.cur);\n  } else if (newR || newOh) {\n    plan(S, S.cur);\n    if (newR) buildMap(S, S.cur);\n  }\n  S.m += (d * S.speed) / 2;\n  const cur = S.cur;\n  if (S.m >= cur.Td) {\n    // The drops let go and run off the bottom; the next word is poured.\n    for (const b of cur.beads) b.fall = cur.Td + 0.35 * Math.random();\n    for (const b of cur.sats) b.fall = cur.Td + 0.35 * Math.random();\n    S.old = cur;\n    S.idx = (S.idx + 1) % WORDS.length;\n    const nw = wordOf(S.idx);\n    nw.S0 = cur.Td + NEXT;\n    plan(S, nw);\n    buildMap(S, nw);\n    S.cur = nw;\n  }\n  if (S.old && S.m > S.old.Td + 1.2) S.old = null;\n}\n\n// The radius of stroke st at arc length s, and its slope, at model time t.\nfunction profile(wd, st, s, t, o) {\n  let a = st.eps * exp((st.sig * (t - st.t0 - s / st.v)) / st.tau);\n  a *= 1 + 0.15 * sin(st.envK * s + st.envP);\n  if (a > 1) a = 1;\n  const ph = st.k * s, base = (1 + cos(ph)) / 2, bq = pow(base, wd.Q - 1);\n  const c = 2 * base * bq - 1, den = st.r0 / sqrt(1 + 2 * a * wd.m1 + a * a * wd.m2);\n  o[0] = den * (1 + a * c);\n  o[1] = den * a * -wd.Q * bq * sin(ph) * st.k;\n}\n\nfunction wobble(b, t) {\n  const e0 = b.e0, w = b.w, g = b.g;\n  if (g \u003c w * 0.999) {\n    const wd = sqrt(w * w - g * g);\n    return e0 * exp(-g * t) * (cos(wd * t) + (g / wd) * sin(wd * t));\n  }\n  const r = sqrt(max(1e-9, g * g - w * w)), r1 = -g + r, r2 = -g - r;\n  return (e0 * (r1 * exp(r2 * t) - r2 * exp(r1 * t))) / (r1 - r2);\n}\n\n// A spheroid of semi-axes a along (tx, ty) and b across and up, into the\n// buffers: the topmost surface wins each LED.\nfunction spheroid(S, cx, cy, tx, ty, a, b) {\n  const { K, C, NX, NY, NZ } = S, ext = max(a, b) + 1;\n  const x0 = max(0, floor(cx - ext)), x1 = min(W - 1, ceil(cx + ext)), y0 = max(0, floor(cy - ext)), y1 = min(H - 1, ceil(cy + ext));\n  const ia = 1 / (a * a), ib = 1 / (b * b);\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const qx = x + 0.5 - cx, qy = y + 0.5 - cy, u = qx * tx + qy * ty, w = -qx * ty + qy * tx;\n      const q = u * u * ia + w * w * ib, sq = sqrt(q), gx = u * ia, gy = w * ib, g = sqrt(gx * gx + gy * gy);\n      const c = g \u003c 1e-9 ? 1 : cl(0.5 - ((sq - 1) * sq) / g, 0, 1);\n      if (c \u003c= 0) continue;\n      const h = q \u003c 1 ? b * sqrt(1 - q) : 0, key = h + c, p = y * W + x;\n      if (c > C[p]) C[p] = c;\n      if (key \u003c= K[p]) continue;\n      K[p] = key;\n      let nx = gx * tx - gy * ty, ny = gx * ty + gy * tx, nz = h * ib;\n      const l = sqrt(nx * nx + ny * ny + nz * nz) || 1;\n      NX[p] = nx / l;\n      NY[p] = ny / l;\n      NZ[p] = nz / l;\n    }\n}\n\nfunction drops(S, wd, t) {\n  for (const b of wd.beads) {\n    if (t \u003c b.act) continue;\n    let e = cl(wobble(b, t - b.act), -0.45, 1), tx = b.tx, ty = b.ty, y = b.y;\n    if (b.fall && t > b.fall) {\n      const f = t - b.fall;\n      y += 0.5 * FALL * f * f;\n      e = min(0.6, FALL * f * 0.004);\n      tx = 0;\n      ty = 1;\n    }\n    if (y - b.R * 2 > H) continue;\n    spheroid(S, b.x, y, tx, ty, b.R * (1 + e), b.R / sqrt(1 + e));\n  }\n  const rs = 0.4 * S.r0;\n  for (const sa of wd.sats) {\n    if (t \u003c sa.act) continue;\n    let y = sa.y;\n    if (sa.fall && t > sa.fall) y += 0.5 * FALL * (t - sa.fall) ** 2;\n    if (y - 2 > H) continue;\n    const grow = cl((t - sa.act) / 0.15, 0, 1);\n    spheroid(S, sa.x, y, 1, 0, rs * grow + 0.01, rs * grow + 0.01);\n  }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The light: from the upper left and in front.\nconst LX = -0.45, LY = -0.6, LZ = 0.66, LN = sqrt(LX * LX + LY * LY + LZ * LZ);\nconst lx = LX / LN, ly = LY / LN, lz = LZ / LN, HN = sqrt(lx * lx + ly * ly + (lz + 1) ** 2);\nconst hx = lx / HN, hy = ly / HN, hz = (lz + 1) / HN, LP = sqrt(lx * lx + ly * ly);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cur) return;\n  const { K, C, NX, NY, NZ, sj, sd, ss, sdx, sdy, stx, sty, scap, active } = S;\n  const t = S.m, wd = S.cur, reach = S.reach, pr = [0, 0], head = S.tmp;\n  K.fill(-1);\n  C.fill(0);\n\n  // Where each stroke of the current word stands: 0 not poured yet, 1 being\n  // poured (head = arc length reached), 2 a thread, 3 broken into drops.\n  for (const st of wd.strokes) {\n    st.state = t \u003c st.t0 ? 0 : t \u003c st.t1 ? 1 : t \u003c st.tp ? 2 : 3;\n    if (st.state === 1) {\n      st.head = (t - st.t0) * st.v;\n      at(st, st.head, head);\n      st.hx = head[0];\n      st.hy = head[1];\n    }\n  }\n\n  for (let a = 0; a \u003c S.nActive; a++) {\n    const p = active[a], X = (p % W) + 0.5, Y = floor(p / W) + 0.5;\n    for (let q = p * 2; q \u003c p * 2 + 2; q++) {\n      const j = sj[q];\n      if (j \u003c 0) break;\n      const st = wd.strokes[j];\n      if (st.state === 0 || st.state === 3) continue;\n      let s = ss[q], dist = sd[q], dx = sdx[q], dy = sdy[q], cap = scap[q];\n      if (st.state === 1 && s > st.head) {\n        if (s - st.head > reach) continue;\n        dx = X - st.hx;\n        dy = Y - st.hy;\n        dist = sqrt(dx * dx + dy * dy);\n        if (dist > reach) continue;\n        if (dist > 1e-6) {\n          dx /= dist;\n          dy /= dist;\n        }\n        s = st.head;\n        cap = 1;\n      }\n      profile(wd, st, s, t, pr);\n      const r = pr[0], dr = cap ? 0 : pr[1];\n      if (r \u003c 0.03) continue;\n      const c = min(1, r - dist + 0.5);\n      if (c \u003c= 0) continue;\n      const h = dist \u003c r ? sqrt(r * r - dist * dist) : 0, key = h + c;\n      if (c > C[p]) C[p] = c;\n      if (key \u003c= K[p]) continue;\n      K[p] = key;\n      const ct = min(1, dist / r);\n      let nx = -dr * stx[q] + ct * dx, ny = -dr * sty[q] + ct * dy, nz = h / r;\n      const l = sqrt(nx * nx + ny * ny + nz * nz) || 1;\n      NX[p] = nx / l;\n      NY[p] = ny / l;\n      NZ[p] = nz / l;\n    }\n  }\n  drops(S, wd, t);\n  if (S.old) drops(S, S.old, t);\n\n  // The caustic: light through each thread or drop comes to a focus on the\n  // dark ground beyond it, down and to the right, brightest behind the\n  // thickest liquid. Shifted 1.5 and 2 LEDs, then softened once.\n  const { CA, CB } = S;\n  CA.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    const c = C[p];\n    if (c \u003c= 0) continue;\n    const x = p % W, y = floor(p / W) + 2;\n    if (y >= H || x + 2 >= W) continue;\n    const w = c * (0.09 + 0.28 * NZ[p]) * 0.5;\n    CA[y * W + x + 1] += w;\n    CA[y * W + x + 2] += w;\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W;\n    let v = CA[p] * 0.6;\n    if (x > 0) v += CA[p - 1] * 0.1;\n    if (x \u003c W - 1) v += CA[p + 1] * 0.1;\n    if (p >= W) v += CA[p - W] * 0.1;\n    if (p \u003c N - W) v += CA[p + W] * 0.1;\n    CB[p] = min(0.4, v);\n  }\n\n  const base = hsv(S.hue + HUE0, 0.8, 1, S.base);\n  const kr = base[0] * 0.8 + 0.2, kg = base[1] * 0.8 + 0.2, kb = base[2] * 0.8 + 0.2;\n  for (let p = 0; p \u003c N; p++) {\n    const c = C[p], ca = CB[p] * (1 - c);\n    let r = ca * kr, g = ca * kg, b = ca * kb;\n    if (c > 0) {\n      const nx = NX[p], ny = NY[p], nz = NZ[p];\n      const diff = max(0, nx * lx + ny * ly + nz * lz);\n      const sh = max(0, nx * hx + ny * hy + nz * hz), spec = pow(sh, 28);\n      const back = max(0, -(nx * lx + ny * ly) / LP) * (1 - nz);\n      const v = 0.22 + 0.62 * diff + 0.5 * back;\n      r += c * (base[0] * v + spec);\n      g += c * (base[1] * v + spec);\n      b += c * (base[2] * v + spec);\n    }\n    display.setPixel(p % W, floor(p / W), floor(cl(r, 0, 1) * 255), floor(cl(g, 0, 1) * 255), floor(cl(b, 0, 1) * 255));\n  }\n}\n","cornsweet-letters":"// ===== Patternflow pattern =====\n// Title:   Cornsweet Letters\n// Family:  type\n// Idea:    Three bold letters stacked down the tall panel are filled with exactly the ground's own colour and differ from it only along their outlines, where a sharp step falls back to the ground level within 4.5 LEDs inside and 6 outside, so a letter whose step is lighter on the inside looks lighter than the ground and one whose step is darker looks darker, and as each letter's step turns over, a third of a turn after the one above, the same untouched interiors seem to brighten, vanish into the ground and darken.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Craik-O'Brien-Cornsweet illusion (Vernon O'Brien, 1958; Kenneth Craik, 1966; Tom Cornsweet, 1970), with letters drawn for this pattern as round-ended strokes, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Cover=0..1\n//\n// Knob 1: Hue. The ground's hue, letters and all, since the letters are the ground. At 0 a slate azure, at 0.25 violet, at 0.5 a terracotta brown, at 0.75 green.\n// Knob 2: Speed. How fast each letter's step turns from lighter inside to darker inside and back: one turn in 12 s at 1, 6 s at the opening 2, 60 s at 0.2 and 4 s at 3. The letters are a third of a turn apart, so at any moment one of them is near its lightest and another near its darkest.\n// Knob 3: Word. LIT, DIM, LUX (the unit of illuminance) and NIT (the unit of luminance), a quarter of the knob each.\n// Knob 4: Cover. Lays a dark band over the outlines, the way a pencil laid along the edge of Cornsweet's figure takes the illusion away. Nothing up to 0.1, then the band grows until at 1 it covers the whole profile, 4.5 LEDs in and 6 out, and leaves the inner strips of each stroke next to the open ground, the same colour on both sides of the band.\n\n// The illusion carries the names of O'Brien, Craik and Cornsweet. Take a\n// uniform field, and along a border put a sharp step that falls back on\n// both sides to the field's own level: lighter just inside, darker just\n// outside. The inside then looks lighter all the way across, though away\n// from the border it sends out exactly the light the outside does. Cover\n// the border and both sides look the same.\n//\n// Here the border is a letter's outline. Each LED's distance to it comes\n// from a distance transform of the letter drawn five times finer than the\n// panel. The profile is a parabola in that distance, a (1 - d/w)^2 with\n// w = 4.5 LEDs inside and 6 outside, so it reaches the ground level exactly\n// and the LEDs past it are the ground's own colour, bit for bit, inside the\n// letter or not. The height a of the step turns as a cosine: positive, the\n// letter looks lighter; zero, it is gone; negative, it looks darker. Where\n// two letters' outer profiles meet in the gap between them they add.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Ground level, the step's half height at its largest, and how far the\n// profile reaches inside and outside (LEDs).\nconst G = 118, C = 88, WIN = 4.5, WOUT = 6;\nconst SS = 5; // the distance grid has SS x SS cells per LED\nconst HUE0 = 0.55, SAT = 0.62, COVER = 26;\n\n// Letters as strokes on a unit box, x right and y down. \"a\" is an arc:\n// [cx, cy, rx, ry, from, to] in degrees, 0 to the right, 90 down.\nconst GLYPHS = {\n  L: [[0, 0, 0, 1], [0, 1, 1, 1]],\n  I: [[0.5, 0, 0.5, 1]],\n  T: [[0, 0, 1, 0], [0.5, 0, 0.5, 1]],\n  D: [[0, 0, 0, 1], [0, 0, 0.42, 0], [0, 1, 0.42, 1], [\"a\", 0.42, 0.5, 0.58, 0.5, -90, 90]],\n  M: [[0, 1, 0, 0], [0, 0, 0.5, 0.62], [0.5, 0.62, 1, 0], [1, 0, 1, 1]],\n  U: [[0, 0, 0, 0.5], [\"a\", 0.5, 0.5, 0.5, 0.5, 180, 0], [1, 0.5, 1, 0]],\n  X: [[0, 0, 1, 1], [1, 0, 0, 1]],\n  N: [[0, 1, 0, 0], [0, 0, 1, 1], [1, 1, 1, 0]],\n};\nconst WORDS = [\"LIT\", \"DIM\", \"LUX\", \"NIT\"];\n// Strokes 14 LEDs thick with round ends, letters 36 rows tall and 52 wide\n// with 6 rows between them and 4 above the first and below the last.\nconst RAD = 7, X0 = 13, X1 = 51, LH = 36, GAP = 6, TOP0 = 4;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, word: 0, cover: 0.06, t: 0, built: -1, n: 3,\n    dist: [0, 1, 2].map(() => new Float32Array(N)), inside: [0, 1, 2].map(() => new Uint8Array(N)),\n    lut: new Uint8Array(256 * 3), lh: -1, c: [0, 0, 0],\n  };\n}\n\n// Letter k's strokes as panel segments [x0, y0, x1, y1].\nfunction strokes(ch, k) {\n  const segs = [];\n  const top = TOP0 + k * (LH + GAP) + RAD, bot = TOP0 + k * (LH + GAP) + LH - RAD;\n  const px = (u) => X0 + (X1 - X0) * u, py = (v) => top + (bot - top) * v;\n  for (const s of GLYPHS[ch]) {\n    if (s[0] === \"a\") {\n      const [, cx, cy, rx, ry, a0, a1] = s, n = 12;\n      for (let j = 0; j \u003c n; j++) {\n        const t0 = ((a0 + ((a1 - a0) * j) / n) * PI) / 180, t1 = ((a0 + ((a1 - a0) * (j + 1)) / n) * PI) / 180;\n        segs.push([px(cx + rx * cos(t0)), py(cy + ry * sin(t0)), px(cx + rx * cos(t1)), py(cy + ry * sin(t1))]);\n      }\n    } else segs.push([px(s[0]), py(s[1]), px(s[2]), py(s[3])]);\n  }\n  return segs;\n}\n\nfunction segDist(x, y, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l2 = dx * dx + dy * dy;\n  const t = l2 > 0 ? cl(((x - s[0]) * dx + (y - s[1]) * dy) / l2, 0, 1) : 0;\n  const ex = x - s[0] - t * dx, ey = y - s[1] - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// One pass of the squared Euclidean distance transform along a line: the\n// lower envelope of parabolas (Felzenszwalb and Huttenlocher, 2004).\nfunction edt1(f, n, d, v, z) {\n  let k = 0;\n  v[0] = 0;\n  z[0] = -1e20;\n  z[1] = 1e20;\n  for (let q = 1; q \u003c n; q++) {\n    let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);\n    while (s \u003c= z[k]) {\n      k--;\n      s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);\n    }\n    k++;\n    v[k] = q;\n    z[k] = s;\n    z[k + 1] = 1e20;\n  }\n  k = 0;\n  for (let q = 0; q \u003c n; q++) {\n    while (z[k + 1] \u003c q) k++;\n    d[q] = (q - v[k]) * (q - v[k]) + f[v[k]];\n  }\n}\n\nfunction edt(grid, gw, gh) {\n  const n = max(gw, gh), f = new Float64Array(n), d = new Float64Array(n), v = new Int32Array(n), z = new Float64Array(n + 1);\n  for (let x = 0; x \u003c gw; x++) {\n    for (let y = 0; y \u003c gh; y++) f[y] = grid[y * gw + x];\n    edt1(f, gh, d, v, z);\n    for (let y = 0; y \u003c gh; y++) grid[y * gw + x] = d[y];\n  }\n  for (let y = 0; y \u003c gh; y++) {\n    for (let x = 0; x \u003c gw; x++) f[x] = grid[y * gw + x];\n    edt1(f, gw, d, v, z);\n    for (let x = 0; x \u003c gw; x++) grid[y * gw + x] = d[x];\n  }\n}\n\n// For each letter, every LED's distance to its outline and which side the\n// LED is on. Each letter gets its own field over its rows and 8 more above\n// and below, so where two outer profiles overlap they can add.\nfunction build(S) {\n  const word = WORDS[S.word], INF = 1e12, gw = W * SS, h = SS >> 1;\n  S.n = word.length;\n  for (let k = 0; k \u003c word.length; k++) {\n    const segs = strokes(word[k], k), D = S.dist[k], IN = S.inside[k];\n    D.fill(1e9);\n    IN.fill(0);\n    const y0 = max(0, TOP0 + k * (LH + GAP) - 8), y1 = min(H, TOP0 + k * (LH + GAP) + LH + 8), gh = (y1 - y0) * SS;\n    const toIn = new Float64Array(gw * gh), toOut = new Float64Array(gw * gh), ins = new Uint8Array(gw * gh);\n    for (let gy = 0; gy \u003c gh; gy++)\n      for (let gx = 0; gx \u003c gw; gx++) {\n        const x = (gx + 0.5) / SS, y = y0 + (gy + 0.5) / SS;\n        let dmin = 1e9;\n        for (const s of segs) {\n          const dd = segDist(x, y, s);\n          if (dd \u003c dmin) dmin = dd;\n        }\n        const i = gy * gw + gx, inn = dmin \u003c= RAD ? 1 : 0;\n        ins[i] = inn;\n        toIn[i] = inn ? 0 : INF;\n        toOut[i] = inn ? INF : 0;\n      }\n    edt(toIn, gw, gh);\n    edt(toOut, gw, gh);\n    for (let y = y0; y \u003c y1; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const g = ((y - y0) * SS + h) * gw + x * SS + h, i = y * W + x;\n        IN[i] = ins[g];\n        // From the cell's centre to the nearest cell on the other side,\n        // less half a cell: the distance to the outline between them.\n        D[i] = (sqrt(ins[g] ? toOut[g] : toIn[g]) - 0.5) / SS;\n      }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.word = min(WORDS.length - 1, floor(cl(k[2] || 0, 0, 1) * WORDS.length));\n  S.cover = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.t += d * S.speed;\n  if (S.t > 1200) S.t -= 1200;\n  if (S.built !== S.word) {\n    S.built = S.word;\n    build(S);\n  }\n}\n\n// One colour for everything: the ground's hue and saturation at each level.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let v = 0; v \u003c 256; v++) {\n    hsv(S.hue + HUE0, SAT, v / 255, S.c);\n    S.lut[v * 3] = round(S.c[0] * 255);\n    S.lut[v * 3 + 1] = round(S.c[1] * 255);\n    S.lut[v * 3 + 2] = round(S.c[2] * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const L = S.lut, n = S.n;\n  // Each letter's step height, a third of a turn behind the letter above.\n  const amp = [0, 0, 0];\n  for (let k = 0; k \u003c n; k++) amp[k] = C * cos(2 * PI * (S.t / 12 - k / 3));\n  const cv = max(0, S.cover - 0.1) / 0.9, cin = cv * WIN, cout = cv * WOUT;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let v = G, covered = false;\n      for (let k = 0; k \u003c n; k++) {\n        const dd = S.dist[k][i];\n        if (dd >= WOUT) continue;\n        if (S.inside[k][i]) {\n          if (dd \u003c cin) covered = true;\n          else if (dd \u003c WIN) v += amp[k] * (1 - dd / WIN) * (1 - dd / WIN);\n        } else if (dd \u003c cout) covered = true;\n        else v -= amp[k] * (1 - dd / WOUT) * (1 - dd / WOUT);\n      }\n      const o = (covered ? COVER : round(cl(v, 0, 255))) * 3;\n      display.setPixel(x, y, L[o], L[o + 1], L[o + 2]);\n    }\n}\n","dehn-twist":"// ===== Patternflow pattern =====\n// Title:   Dehn Twist\n// Family:  topology\n// Idea:    A shaded torus turns slowly in the upper half carrying a gold closed curve, and below it the flat square with opposite sides glued shows the same curve as straight segments; a thin green annulus round the tube lights up, its inside is dragged one full turn round the tube while its cut edge lets the curve's ends slide apart and meet again, and the curve relaxes to a straight one of class (p, q + p), so on the square it gains p more slanted segments and on the torus it winds p more times round the tube, until after a few twists it twists back as many times and the next curve takes its place.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dehn twist (Max Dehn, 1938), and Lickorish's theorem that Dehn twists generate the mapping class group of a closed orientable surface (W. B. R. Lickorish, 1962), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Curve=0..5, Twists=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the torus and the square are blue, the curve gold and the annulus green; at 0.25 the torus is magenta, the curve green and the annulus blue, at 0.5 the torus is amber and the curve blue, at 0.75 the torus is green and the curve pink.\n// Knob 2: Speed. At 2 a twist takes 2.5 s: 0.3 s for the annulus to light, 1.1 s of drag, 0.15 s to glue, 0.55 s to relax and 0.4 s held; every time goes as 2 / Speed, so 25 s a twist at 0.2 and 1.7 s at 3. The torus turns once in 30 s at 2.\n// Knob 3: Curve. The class (p, q) the curve starts from, p times round the long way and q times round the tube: 0 (1, 0), 1 (2, 1), 2 (1, -2), 3 (3, 1), 4 (2, -3), 5 (3, -1). After it has climbed and come back the next one on the list takes its place. Turning the knob starts the new curve at once.\n// Knob 4: Twists. How many twists the curve climbs before it twists back, and which way. From 0 to 1 each twist drags the annulus up the square and takes (p, q) to (p, q + p): 2 twists up to a third, 3 up to two thirds and 4 beyond. Below 0 it drags the other way, (p, q) to (p, q - p), with the same counts by the knob's size. A climb also stops early when the next curve would cut the square into more than 10 segments.\n\n// The torus is the square [0,1) x [0,1) with its left edge glued to its\n// right and its top to its bottom. U runs across the square and once round\n// the long way of the torus; V runs up the square and once round the tube.\n// A straight line through the square with slope q/p closes up after going\n// p times across and q times up: a simple closed curve of class (p, q)\n// whenever p and q have no common factor. On the square it crosses the\n// side edges p times and the top edge |q| times, so it is cut into p + |q|\n// segments.\n//\n// A meridian is a circle U = a, once round the tube. The Dehn twist about\n// it cuts the torus along that circle, turns one side a full turn and\n// glues it back: on the annulus a \u003c= U \u003c a + w it is\n//\n//   (U, V) -> (U, V + g((U - a) / w)),  g rising smoothly from 0 to 1,\n//\n// and the identity everywhere else. Each time the curve crosses the\n// annulus it is carried once round the tube, so (p, q) becomes (p, q + p);\n// the inverse twist gives (p, q - p). The meridian (0, 1) itself is left\n// alone, so every curve here has p >= 1. In the matrix picture the twist\n// is [[1, 0], [1, 1]] acting on (p, q).\n//\n// While the twist is under way the drag goes as s from 0 to 1: inside the\n// annulus V moves by s g, outside it does not, so the curve stays whole at\n// the annulus' left edge and comes apart at its right edge, where the cut\n// is, by s of a turn. At s = 1 the ends meet again. The green stripes on\n// the annulus are lines of the surface itself, V - s g constant, so they\n// shear into helices while it turns.\n//\n// The twisted curve is then pulled straight. Written as V(tau) over\n// tau in [0, 1) with U = p tau + c1, the twisted curve has\n// V(tau + k/p) - V(tau) = k q / p + k for k = 1, ..., p - 1, and so has\n// the straight line of class (p, q + p). Every mix of the two keeps that,\n// and none of those differences is a whole number, so the straight-line\n// homotopy between them passes only through simple curves of the class.\n//\n// The torus is ray marched once, at load: the view is orthographic and\n// fixed, so each LED keeps its hit point, normal and (U, V) for good, and\n// the turning only shifts U. The curve is drawn as a chain of 1600 dots,\n// each tested against the torus' depth; the parts on the far side show\n// faintly through.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, atan2, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst fr = (x) => x - floor(x);\n\n// The torus: radii, centre on the panel, the view's elevation above its\n// equator, and the camera's up and toward-viewer axes in torus space.\nconst RB = 21, RS = 9, CX = 32, CY = 28.5, EL = (56 * PI) / 180, TOP = 58;\nconst EY = [0, sin(EL), cos(EL)], EZ = [0, -cos(EL), sin(EL)];\n// The square: side, left and top edge.\nconst SQ = 56, SX = 4, SY = 67;\n// The annulus' width in U, the samples along the curve, and the most\n// segments a climb may cut the square into.\nconst AW = 0.1, NS = 1600, MAXSEG = 10;\nconst CURVES = [[1, 0], [2, 1], [1, -2], [3, 1], [2, -3], [3, -1]];\n// Seconds at Speed 2.\nconst PRE = 0.3, DRAG = 1.1, GLUE = 0.15, RELAX = 0.55, POST = 0.4, FADE = 0.35, SPIN = 1 / 30;\n\n// Light from the upper left, toward the viewer, in torus space.\nconst LIGHT = (() => {\n  const c = [-0.45, 0.62, 0.64], n = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);\n  return [c[0] / n, (c[1] * EY[1] + c[2] * EZ[1]) / n, (c[1] * EY[2] + c[2] * EZ[2]) / n];\n})();\nconst HALF = (() => {\n  const h = [LIGHT[0] + EZ[0], LIGHT[1] + EZ[1], LIGHT[2] + EZ[2]], n = sqrt(h[0] * h[0] + h[1] * h[1] + h[2] * h[2]);\n  return [h[0] / n, h[1] / n, h[2] / n];\n})();\n\n// Ray march the torus once: for each LED of the upper part, whether it\n// sees the torus, and where.\nconst TH = new Uint8Array(W * TOP), TU = new Float32Array(W * TOP), TV = new Float32Array(W * TOP);\nconst TZ = new Float32Array(W * TOP), TL = new Float32Array(W * TOP);\nfor (let py = 0; py \u003c TOP; py++)\n  for (let px = 0; px \u003c W; px++) {\n    const X = px + 0.5 - CX, Y = CY - (py + 0.5), i = py * W + px;\n    let t = 45;\n    for (let k = 0; k \u003c 200 && t > -45; k++) {\n      const x = X, y = Y * EY[1] + t * EZ[1], z = Y * EY[2] + t * EZ[2];\n      const rho = sqrt(x * x + y * y), q = rho - RB, d = sqrt(q * q + z * z) - RS;\n      if (d \u003c 0.002) {\n        const nx = (x - (RB * x) / rho) / RS, ny = (y - (RB * y) / rho) / RS, nz = z / RS;\n        const lam = max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]);\n        const sp = max(0, nx * HALF[0] + ny * HALF[1] + nz * HALF[2]);\n        TH[i] = 1;\n        TU[i] = atan2(y, x) / TAU;\n        TV[i] = fr((atan2(z, q) + PI / 2) / TAU);\n        TZ[i] = y * EZ[1] + z * EZ[2];\n        TL[i] = 0.2 + 0.68 * lam + 0.32 * sp ** 24;\n        break;\n      }\n      t -= d;\n    }\n  }\n\n// Small figures for the class label, rows of three bits, top first.\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n  \"-\": \"000000111000000\", \"(\": \"010100100100010\", \")\": \"010001001001010\", \",\": \"000000000010100\",\n};\n\nfunction hsv(h, s, v) {\n  h = fr(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// A soft dot of radius r into a coverage buffer, kept to rows y0..y1 and\n// columns x0..x1.\nfunction dot(A, x, y, r, a, x0, x1, y0, y1) {\n  const ax = max(x0, floor(x - r - 0.5)), bx = min(x1, floor(x + r + 0.5));\n  const ay = max(y0, floor(y - r - 0.5)), by = min(y1, floor(y + r + 0.5));\n  for (let yy = ay; yy \u003c= by; yy++)\n    for (let xx = ax; xx \u003c= bx; xx++) {\n      const dx = xx + 0.5 - x, dy = yy + 0.5 - y, c = cl(r + 0.5 - sqrt(dx * dx + dy * dy), 0, 1) * a, j = yy * W + xx;\n      if (c > A[j]) A[j] = c;\n    }\n}\n\nfunction begin(S, ci) {\n  S.ci = ((ci % CURVES.length) + CURVES.length) % CURVES.length;\n  S.p = CURVES[S.ci][0];\n  S.q = CURVES[S.ci][1];\n  S.c1 = 0.1;\n  S.c2 = 0.5 / S.p;\n  S.m = 0;\n  S.up = true;\n}\n\n// What comes after a twist: another the same way, the way back, or the\n// next curve.\nfunction plan(S) {\n  if (S.up) {\n    const d = S.n >= 0 ? 1 : -1, q2 = S.q + d * S.p;\n    if ((S.m === 0 || Math.sign(S.m) === d) && abs(S.m) \u003c abs(S.n) && S.p + abs(q2) \u003c= MAXSEG) return go(S, d);\n    S.up = false;\n  }\n  if (S.m !== 0) return go(S, -Math.sign(S.m));\n  S.mode = \"out\";\n  S.tm = 0;\n}\n\nfunction go(S, d) {\n  S.dir = d;\n  S.mode = \"pre\";\n  S.tm = 0;\n  // The annulus goes where the torus' left side will be halfway through\n  // the drag. Seen from the front a meridian is a vertical line and a turn\n  // round it hides; seen from the side it is an ellipse 18 LEDs wide.\n  S.a = fr(0.5 - (S.spin + SPIN * (PRE + DRAG / 2)) - AW / 2);\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, spin: 0.08, ci: -1, knob: -1, n: 2, mode: \"pre\", tm: 0, s: 0, lam: 0, hl: 0, fade: 1, glow: 0,\n    p: 1, q: 0, c1: 0, c2: 0, a: 0, dir: 1, m: 0, up: true, c2n: 0, c2a: 0, c2b: 0,\n    buf: new Float32Array(N * 3), A: new Float32Array(N), B: new Float32Array(N),\n    cu: new Float32Array(NS), cv: new Float32Array(NS), P: [0, 0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3), t4 = cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  S.n = (t4 \u003c 0 ? -1 : 1) * min(4, 2 + floor(abs(t4) * 3));\n  const kc = round(cl(k[2] || 0, 0, 5));\n  if (kc !== S.knob) {\n    S.knob = kc;\n    S.fade = 1;\n    S.glow = 0;\n    begin(S, kc);\n    plan(S);\n  }\n  const h = (d * speed) / 2;\n  S.spin = fr(S.spin + SPIN * h);\n  S.tm += h;\n  S.glow = max(0, S.glow - h * 3);\n  if (S.mode === \"pre\") {\n    S.hl = smooth(S.tm / PRE);\n    if (S.tm >= PRE) (S.mode = \"drag\"), (S.tm -= PRE);\n  }\n  if (S.mode === \"drag\") {\n    S.s = smooth(S.tm / DRAG);\n    if (S.tm >= DRAG) (S.mode = \"glue\"), (S.tm -= DRAG), (S.s = 1), (S.glow = 1);\n  }\n  if (S.mode === \"glue\" && S.tm >= GLUE) {\n    S.mode = \"relax\";\n    S.tm -= GLUE;\n    // The straight line the twisted curve relaxes to: same class plus the\n    // twist, at the offset that matches the twisted curve on average.\n    let mean = 0;\n    for (let i = 0; i \u003c NS; i++) {\n      const x = S.p * (i / NS) + S.c1 - S.a, kk = floor(x), f = x - kk;\n      mean += kk + (f \u003c AW ? smooth(f / AW) : 1);\n    }\n    S.c2n = S.c2 + S.dir * (mean / NS - S.p / 2);\n  }\n  if (S.mode === \"relax\") {\n    S.lam = smooth(S.tm / RELAX);\n    if (S.tm >= RELAX) {\n      S.q += S.dir * S.p;\n      S.c2 = S.c2a = fr(S.c2n);\n      // The held line then slides round the tube back to its home offset,\n      // 0.5 / p up to a multiple of 1 / p, which leaves the curve's set of\n      // strands the same: a pure translation, so the class does not move.\n      let e = (0.5 - S.c2a * S.p) % 1;\n      if (e > 0.5) e -= 1;\n      if (e \u003c -0.5) e += 1;\n      S.c2b = S.c2a + e / S.p;\n      S.m += S.dir;\n      S.mode = \"post\";\n      S.tm -= RELAX;\n      S.s = 0;\n      S.lam = 0;\n    }\n  }\n  if (S.mode === \"post\") {\n    S.hl = 1 - smooth(S.tm / POST);\n    S.c2 = S.c2a + (S.c2b - S.c2a) * smooth(S.tm / POST);\n    if (S.tm >= POST) {\n      S.hl = 0;\n      plan(S);\n    }\n  }\n  if (S.mode === \"out\") {\n    S.fade = 1 - smooth(S.tm / FADE);\n    if (S.tm >= FADE) {\n      begin(S, S.ci + 1);\n      S.mode = \"in\";\n      S.tm = 0;\n    }\n  }\n  if (S.mode === \"in\") {\n    S.fade = smooth(S.tm / FADE);\n    if (S.tm >= FADE) {\n      S.fade = 1;\n      plan(S);\n    }\n  }\n}\n\n// The curve as NS points (U, V), U unwrapped.\nfunction trace(S) {\n  const { p, q, c1, c2, a, dir } = S, cu = S.cu, cv = S.cv;\n  const drag = S.mode === \"drag\" || S.mode === \"glue\", relax = S.mode === \"relax\";\n  for (let i = 0; i \u003c NS; i++) {\n    const tau = i / NS, U = p * tau + c1;\n    let V = q * tau + c2;\n    const x = U - a, kk = floor(x), f = x - kk, g = f \u003c AW ? smooth(f / AW) : 1;\n    if (drag) V += dir * S.s * (f \u003c AW ? g : 0);\n    else if (relax) {\n      const vt = V + dir * (kk + g), vn = (q + dir * p) * tau + S.c2n;\n      V = vt + (vn - vt) * S.lam;\n    }\n    cu[i] = U;\n    cv[i] = V;\n  }\n}\n\nfunction label(buf, text, cy, c) {\n  let w = 0;\n  for (const ch of text) w += (ch === \"(\" || ch === \")\" || ch === \",\" ? 3 : 4);\n  let x = round(32 - (w - 1) / 2);\n  for (const ch of text) {\n    const g = GLYPH[ch], gw = ch === \"(\" || ch === \")\" || ch === \",\" ? 2 : 3;\n    // Narrow glyphs keep the middle and one side of their three columns.\n    const cols = ch === \"(\" || ch === \",\" ? [0, 1] : ch === \")\" ? [1, 2] : [0, 1, 2];\n    for (let r = 0; r \u003c 5; r++)\n      for (let j = 0; j \u003c gw; j++)\n        if (g[r * 3 + cols[j]] === \"1\") {\n          const p = ((cy + r) * W + x + j) * 3;\n          buf[p] = c[0];\n          buf[p + 1] = c[1];\n          buf[p + 2] = c[2];\n        }\n    x += gw + 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, A = S.A, B = S.B, P = S.P, h = S.hue;\n  buf.fill(0);\n  A.fill(0);\n  B.fill(0);\n  trace(S);\n  const torus = hsv(h + 0.6, 0.6, 0.78), curve = hsv(h + 0.13, 0.55, 1), ann = hsv(h + 0.36, 0.7, 1);\n  const lng = hsv(h + 0.83, 0.35, 0.62), mer = hsv(h + 0.36, 0.55, 0.62);\n  const spin = S.spin;\n\n  // The curve on the torus, front and back, and on the square. A dot\n  // within 0.4 LED of the last one drawn adds nothing and is skipped.\n  let lx = -9, ly = -9, lf = -1, mx0 = -9, my0 = -9;\n  for (let i = 0; i \u003c NS; i++) {\n    const U = S.cu[i], V = S.cv[i];\n    const t = TAU * (U + spin), ph = TAU * V - PI / 2, rr = RB + RS * cos(ph);\n    const x = rr * cos(t), y = rr * sin(t), z = RS * sin(ph);\n    P[0] = CX + x;\n    P[1] = CY - (y * EY[1] + z * EY[2]);\n    P[2] = y * EZ[1] + z * EZ[2];\n    const facing = cos(ph) * sin(t) * EZ[1] + sin(ph) * EZ[2];\n    const ix = floor(P[0]), iy = floor(P[1]), j = iy * W + ix;\n    const front = ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c TOP && TH[j] ? P[2] >= TZ[j] - 1.6 : facing > 0;\n    const fb = front ? 1 : 0;\n    if (fb !== lf || (P[0] - lx) ** 2 + (P[1] - ly) ** 2 > 0.16) {\n      dot(front ? A : B, P[0], P[1], front ? 1.25 : 0.9, 1, 0, W - 1, 0, TOP - 1);\n      lx = P[0];\n      ly = P[1];\n      lf = fb;\n    }\n    const qx = SX + fr(U) * SQ, qy = SY + SQ - fr(V) * SQ;\n    if ((qx - mx0) ** 2 + (qy - my0) ** 2 > 0.16) {\n      dot(A, qx, qy, 1.15, 1, SX, SX + SQ - 1, SY, SY + SQ - 1);\n      mx0 = qx;\n      my0 = qy;\n    }\n  }\n\n  // The torus.\n  const drag = S.mode === \"drag\" || S.mode === \"glue\" ? S.s : S.mode === \"relax\" || S.mode === \"post\" ? 1 : 0;\n  for (let i = 0; i \u003c W * TOP; i++) {\n    if (!TH[i]) continue;\n    const l = TL[i], o = i * 3;\n    let r = torus[0] * l, g = torus[1] * l, b = torus[2] * l;\n    if (S.hl > 0) {\n      const f = fr(TU[i] - spin - S.a);\n      if (f \u003c AW) {\n        const vm = TV[i] - S.dir * drag * smooth(f / AW), e = fr(vm * 6), st = cl(1.3 - min(e, 1 - e) * 9.4, 0, 1);\n        const edge = cl(1.4 - min(f, AW - f) * 2 * PI * RB * 1.2, 0, 1);\n        const m = S.hl * (0.3 + 0.7 * max(st, edge)), lv = 0.35 + 0.65 * l;\n        r += (ann[0] * lv - r) * m;\n        g += (ann[1] * lv - g) * m;\n        b += (ann[2] * lv - b) * m;\n      }\n    }\n    const back = B[i] * (1 - A[i]) * 0.3 * S.fade, a = A[i] * S.fade, lc = 0.55 + 0.45 * min(1, l);\n    r += (curve[0] - r) * back;\n    g += (curve[1] - g) * back;\n    b += (curve[2] - b) * back;\n    r += (curve[0] * lc - r) * a;\n    g += (curve[1] * lc - g) * a;\n    b += (curve[2] * lc - b) * a;\n    buf[o] = r;\n    buf[o + 1] = g;\n    buf[o + 2] = b;\n  }\n\n  // The square: its ground, the annulus as a strip, the curve, and the\n  // glued edges, side edges in the meridian's colour with one arrow each,\n  // top and bottom in the longitude's colour with two.\n  for (let y = SY; y \u003c SY + SQ; y++)\n    for (let x = SX; x \u003c SX + SQ; x++) {\n      const i = y * W + x, o = i * 3, U = (x + 0.5 - SX) / SQ, V = (SY + SQ - y - 0.5) / SQ;\n      let r = torus[0] * 0.2, g = torus[1] * 0.2, b = torus[2] * 0.2;\n      if (S.hl > 0) {\n        const f = fr(U - S.a);\n        if (f \u003c AW) {\n          const vm = V - S.dir * drag * smooth(f / AW), e = fr(vm * 6), st = cl(1.2 - min(e, 1 - e) * 9.3, 0, 1);\n          const edge = cl(1.3 - min(f, AW - f) * SQ, 0, 1);\n          const m = S.hl * (0.3 + 0.7 * max(st, edge));\n          r += (ann[0] * 0.55 - r) * m;\n          g += (ann[1] * 0.55 - g) * m;\n          b += (ann[2] * 0.55 - b) * m;\n        }\n      }\n      const a = A[i] * S.fade;\n      r += (curve[0] - r) * a;\n      g += (curve[1] - g) * a;\n      b += (curve[2] - b) * a;\n      buf[o] = r;\n      buf[o + 1] = g;\n      buf[o + 2] = b;\n    }\n  const put = (x, y, c) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    buf[o] = c[0];\n    buf[o + 1] = c[1];\n    buf[o + 2] = c[2];\n  };\n  for (let y = SY - 1; y \u003c= SY + SQ; y++) put(SX - 1, y, mer), put(SX + SQ, y, mer);\n  for (let x = SX; x \u003c SX + SQ; x++) put(x, SY - 1, lng), put(x, SY + SQ, lng);\n  const my = SY + SQ / 2 - 2, mx = SX + SQ / 2 - 2;\n  for (const ex of [SX - 1, SX + SQ])\n    for (let k = 1; k \u003c= 2; k++) put(ex - k, my + k, mer), put(ex + k, my + k, mer);\n  for (const ey of [SY - 1, SY + SQ])\n    for (const dx of [0, 3])\n      for (let k = 1; k \u003c= 2; k++) put(mx + dx - k, ey - k, lng), put(mx + dx - k, ey + k, lng);\n\n  // Where the cut closes, a flash on each meeting point.\n  if (S.glow > 0 && S.mode !== \"out\") {\n    for (let k = 0; k \u003c S.p; k++) {\n      const U = S.a + AW + k, tau = (U - S.c1 - floor((U - S.c1) / S.p) * S.p) / S.p, ii = floor(tau * NS) % NS;\n      const V = S.cv[ii];\n      const t = TAU * (U + spin), ph = TAU * V - PI / 2, rr = RB + RS * cos(ph);\n      const x = rr * cos(t), y = rr * sin(t), z = RS * sin(ph);\n      const facing = cos(ph) * sin(t) * EZ[1] + sin(ph) * EZ[2];\n      const pts = [[SX + fr(U) * SQ, SY + SQ - fr(V) * SQ]];\n      if (facing > 0) pts.push([CX + x, CY - (y * EY[1] + z * EY[2])]);\n      for (const [px, py] of pts)\n        for (let dy = -2; dy \u003c= 2; dy++)\n          for (let dx = -2; dx \u003c= 2; dx++) {\n            const X = floor(px) + dx, Y = floor(py) + dy;\n            if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n            const o = (Y * W + X) * 3, m = S.glow * cl(2.4 - sqrt(dx * dx + dy * dy), 0, 1);\n            buf[o] += (1 - buf[o]) * m;\n            buf[o + 1] += (1 - buf[o + 1]) * m;\n            buf[o + 2] += (1 - buf[o + 2]) * m;\n          }\n    }\n  }\n\n  // The class: the new one from the moment the ends meet.\n  const shown = S.mode === \"glue\" || S.mode === \"relax\" ? S.q + S.dir * S.p : S.q;\n  const lc = hsv(h + 0.13, 0.25, 0.75 + 0.25 * S.glow);\n  label(buf, \"(\" + S.p + \",\" + shown + \")\", 58, [lc[0] * S.fade, lc[1] * S.fade, lc[2] * S.fade]);\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","head-wave":"// ===== Patternflow pattern =====\n// Title:   Head Wave\n// Family:  physics\n// Idea:    A cross-section of two-layer ground stands the height of the panel, a slow crust over a mantle 1.35 times faster with a flat boundary across row 64, and a source just above the boundary at the left edge sends out pulses whose first arrivals, worked out exactly by Fermat's principle, run as banded fronts: circles in the crust, wider circles bent through the boundary in the mantle, and beside them a straight conical front in the mantle's colour that the boundary leaks back up into the crust at the critical angle of 47.8 degrees, arriving first over a wedge that reaches 33 rows up at the right edge.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: head waves and the crust-mantle boundary found from them (Andrija Mohorovicic, 1909); first arrivals by Fermat's principle (Pierre de Fermat, 1662), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=1.35..2.5, Height=2..50\n//\n// Knob 1: Hue. Turns both layers round the wheel together. At 0 the crust and every front that stayed in it are sea green and the mantle with the head wave it sends up is rose; at 0.5 the crust is red and the mantle green.\n// Knob 2: Speed. How many bands leave the source a second: half the knob, so one a second at the opening 2, a front crossing the crust at 4.4 LEDs a second and the mantle at 1.35 times that; 0.1 a second at 0.2 and 1.5 at 3.\n// Knob 3: Ratio. The mantle's speed over the crust's, from 1.35, about the ratio between crust and upper mantle, to 2.5. The critical angle asin(1/ratio) falls from 47.8 to 23.6 degrees, so the conical front tips from a diagonal towards flat, the wedge where it leads grows from 11% of the panel to 25% and reaches the top row at the right edge, and the mantle's bands widen from 5.9 to 11 LEDs.\n// Knob 4: Height. How far above the boundary the source sits, 2 to 50 LEDs. At the opening 2 the head wave leads from 2.2 LEDs out along the boundary and its wedge reaches 33 rows up at the right edge; at 20 it leads only from 22 LEDs out and reaches 6 rows up; at 50 it meets the boundary 55 LEDs out and hardly shows.\n// Buttons: Any tap moves the source 16 LEDs to the right, from the left edge through 16, 32 and 48 to the right edge and back.\n\n// Everything is measured in LEDs, and time in LEDs of travel through the\n// slow layer, so the crust's speed is 1 and the mantle's is r. A pulse\n// reaches each point first along the path of least time (Fermat), and there\n// are three candidates.\n//\n// Direct: the straight line from the source, T = distance. Its fronts are\n// circles.\n//\n// Refracted, for points below the boundary: down to some point m on the\n// boundary, then on to the point at speed r. T(m) = |s - m| + |m - p| / r is\n// convex in m, so a few Newton steps find the minimum, and setting its\n// derivative to zero is Snell's law, sin(i) = sin(t) / r.\n//\n// Head wave, for points above the boundary: down to the boundary at the\n// critical angle ic = asin(1/r), along the boundary at speed r, and back up\n// at ic. With hs the source's height and hr the point's height above the\n// boundary and dx the distance across,\n//\n//   T = dx / r + (hs + hr) cos(ic),\n//\n// which is a plane: the conical front. It exists once dx is at least\n// (hs + hr) tan(ic), and it arrives first wherever it beats the circle.\n// Mohorovicic read exactly this from the Kupa valley earthquake of\n// 8 October 1909: beyond some distance a faster phase overtook the direct\n// one, and the distance gave him the depth of a faster layer underneath.\n//\n// The travel time is worked out once whenever the source, the ratio or the\n// height change. Each frame only reads it: an LED's light is a sawtooth of\n// (t - T) over one period, bright as a front arrives and fading until the\n// next, and the source never stops, so every LED is always somewhere in a\n// band.\n//\n// A band climbs to its crest over its width. When its front runs along a\n// row or a column the whole climb falls between neighbours in one\n// direction; when it runs diagonally the climb splits between the row and\n// the column. So each LED's band is drawn as tall as it can be with no step\n// between neighbours above 39.5 levels: diagonal fronts, the head wave among\n// them, stand at full height and fronts square to the panel at about two\n// thirds of it. The drop at the back of each band is the only hard step.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The boundary's row, the band width in the crust (LEDs), the largest step\n// between two neighbouring LEDs a band may climb, and its full height.\nconst YB = 64, P = 4.4, CAP = 39.5, TOP = 255;\nconst SRC_X = [0.5, 16, 32, 48, 63.5];\n// Crust, then mantle (and the head wave, which spent its fast stretch there).\nconst HUES = [0.47, 0.91];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, ratio: 1.35, height: 2, src: 0, tau: 0, key: \"\",\n    ph: new Float32Array(N), amp: new Float32Array(N), fast: new Uint8Array(N),\n    lut: new Uint8Array(2 * 256 * 3), lh: -1, c: [0, 0, 0],\n  };\n}\n\n// First arrivals (in band periods) and each LED's band height.\nfunction solve(S) {\n  const r = S.ratio, xs = SRC_X[S.src], hs = S.height, ys = YB - hs;\n  const ci = sqrt(1 - 1 / (r * r)), ti = 1 / sqrt(r * r - 1);\n  const PH = S.ph, A = S.amp, F = S.fast;\n  for (let y = 0; y \u003c H; y++) {\n    const py = y + 0.5;\n    let m = xs;\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5, i = y * W + x, dx = abs(px - xs);\n      // t is the travel time, (gx, gy) the size of its slope along the row\n      // and down the column.\n      let t, gx, gy;\n      if (py \u003c YB) {\n        const dy = py - ys, rr = sqrt(dx * dx + dy * dy) + 1e-6, hr = YB - py;\n        t = rr;\n        gx = dx / rr;\n        gy = abs(dy) / rr;\n        F[i] = 0;\n        if (dx >= (hs + hr) * ti) {\n          const th = dx / r + (hs + hr) * ci;\n          if (th \u003c t) {\n            t = th;\n            gx = 1 / r;\n            gy = ci;\n            F[i] = 1;\n          }\n        }\n      } else {\n        // Newton on the crossing point, started from the last LED's.\n        const dz = py - YB, a = min(xs, px), b = max(xs, px);\n        m = cl(m, a, b);\n        for (let k = 0; k \u003c 6; k++) {\n          const d1 = sqrt((m - xs) * (m - xs) + hs * hs), d2 = sqrt((px - m) * (px - m) + dz * dz);\n          const g = (m - xs) / d1 - (px - m) / (r * d2);\n          const gp = (hs * hs) / (d1 * d1 * d1) + (dz * dz) / (r * d2 * d2 * d2);\n          m = cl(m - g / gp, a, b);\n        }\n        const d1 = sqrt((m - xs) * (m - xs) + hs * hs), d2 = sqrt((px - m) * (px - m) + dz * dz) + 1e-6;\n        t = d1 + d2 / r;\n        gx = abs(px - m) / (r * d2);\n        gy = dz / (r * d2);\n        F[i] = 1;\n      }\n      PH[i] = t / P;\n      A[i] = min(TOP, (CAP * P) / max(gx, gy, 1e-6));\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1.35, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.ratio = cl(k[2] == null ? 1.35 : k[2], 1.35, 2.5);\n  S.height = cl(k[3] == null ? 2 : k[3], 2, 50);\n  const b = input.btnPressed;\n  if (b && (b[0] || b[1] || b[2] || b[3])) S.src = (S.src + 1) % SRC_X.length;\n  S.tau += d * S.speed * 0.5;\n  if (S.tau > 1000) S.tau -= 1000;\n  const key = S.ratio.toFixed(3) + \"/\" + S.height.toFixed(2) + \"/\" + S.src;\n  if (key !== S.key) {\n    S.key = key;\n    solve(S);\n  }\n}\n\n// One ramp per layer, indexed by the LED's level: saturated in the fading\n// tail of a band, paler at the crest.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let z = 0; z \u003c 2; z++)\n    for (let v = 0; v \u003c 256; v++) {\n      const a = v / 255;\n      hsv(S.hue + HUES[z], 0.9 - 0.5 * a * a * a, a, S.c);\n      const o = (z * 256 + v) * 3;\n      S.lut[o] = round(S.c[0] * 255);\n      S.lut[o + 1] = round(S.c[1] * 255);\n      S.lut[o + 2] = round(S.c[2] * 255);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const PH = S.ph, A = S.amp, F = S.fast, Lut = S.lut, tau = S.tau;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let u = tau - PH[i];\n      u -= floor(u);\n      const o = (F[i] * 256 + round(A[i] * (1 - u))) * 3;\n      display.setPixel(x, y, Lut[o], Lut[o + 1], Lut[o + 2]);\n    }\n}\n","malfatti-circles":"// ===== Patternflow pattern =====\n// Title:   Malfatti Circles\n// Family:  geometry\n// Idea:    One slowly morphing triangle is drawn twice down the tall panel, the upper copy holding Malfatti's three circles, each touching two sides and the other two circles, and the lower copy the greedy three, the incircle and then each time the largest circle that still fits, with two bars and percentages between them for the share of the triangle each three cover, so the greedy bar stays ahead, by 14 points of the triangle when it is a 23 degree wedge and by a single point when it passes through equilateral.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Malfatti's problem (Gian Francesco Malfatti, 1803); the greedy arrangement beating his circles (H. Lob and H. W. Richmond, 1930) and proved best in every triangle (V. A. Zalgaller and G. A. Los', 1994), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Thin=0..1, More=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together. At 0 Malfatti's circles and their bar are azure and the greedy ones rose pink; at 0.25 violet and yellow; at 0.5 red orange and green.\n// Knob 2: Speed. At 2 the triangle goes from its thinnest to equilateral in 6 s and back in 6 more, and its thin end comes in turn as a wedge leaning over the right end of the base, a flat isosceles triangle, a wedge leaning left and the flat one again, 48 s for the round. Every time goes as 2 / Speed, so 60 s from thin to equilateral at 0.2 and 4 s at 3.\n// Knob 3: Thin. How low the apex comes at the thin end of the morph: 26 rows above the 61 LED base at 0, a wedge whose sharpest corner is 23 degrees, where the greedy three cover 69.8% against Malfatti's 55.9%, or a flat triangle of 99 degrees at the top, 73.7% against 64.7%; at 1 it comes to 7 rows, a 6.6 degree wedge with 39.1% against 23.1%, or 154 degrees at the top with 39.9% against 30.0%.\n// Knob 4: More. Goes on placing circles greedily after the first three, in both copies and in a paler shade: none up to 0.1 (the opening is 0.06), 3 at 0.25, 16 at 0.5, 36 at 0.75 and 60 at 1, so the gaps each first three leave fill with ever smaller circles. The bars and numbers keep counting the first three only.\n\n// In 1803 Malfatti asked how to cut three cylindrical columns out of a\n// triangular prism of marble with the least waste, and took for granted that\n// the answer was three circles in the triangle, each tangent to the other two\n// and to two of the sides. Those circles have a closed form. With a, b, c the\n// sides opposite A, B, C, s the semiperimeter, r the inradius and d, e, f the\n// distances from the incentre to A, B and C, the circle in the corner at A\n// has radius\n//\n//   r_A = r / (2 (s - a)) * (s - r - (e + f - d))\n//\n// and the others go round the same way. Its centre is the vertex pulled\n// towards the incentre by r_A / r, which makes it tangent to both sides at A.\n// Checked numerically on the triangles this pattern passes through and on\n// ten random ones, with corners from 3.6 to 154 degrees: the distances\n// between centres equal the sums of the radii, and each circle stands its\n// own radius off both sides at its corner, to within 1e-13 LEDs.\n//\n// Lob and Richmond showed in 1930 that the circles were not the answer: in\n// an equilateral triangle the incircle with two small circles in two corners\n// covers 73.9% against Malfatti's 72.9%, and in a thin triangle the gap is\n// wide. Zalgaller and Los' proved in 1994 that the greedy choice is the best\n// one in every triangle: the incircle, then the largest circle left, then the\n// largest left again.\n//\n// After the incircle the free space is three corners, each bounded by two\n// sides and the incircle. The largest circle in the corner at A is the image\n// of the incircle under the homothety at A with ratio\n//\n//   q_A = (1 - sin(A/2)) / (1 + sin(A/2)),\n//\n// and placing it leaves a smaller corner (the next circle shrinks by q_A\n// again) and two cusps, each between two tangent circles and a side. A cusp,\n// like every gap after that, is bounded by three mutually tangent things, and\n// its largest circle touches all three, with Descartes' curvature\n//\n//   k = k1 + k2 + k3 + 2 sqrt(k1 k2 + k2 k3 + k3 k1),   a side counting 0.\n//\n// So the greedy keeps a list of gaps, each with the radius of its best\n// circle, and takes the largest each time; the circle placed splits its gap\n// into three. The same list, started from Malfatti's circles (their middle\n// gap, three corners and three cusps), continues the upper copy when K4 asks\n// for more.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Each copy's base runs from x = 1.5 to 62.5 on its bottom row.\nconst BX0 = 1.5, BX1 = 62.5, BASE = BX1 - BX0, HEQ = (BASE * sqrt(3)) / 2;\nconst TOPS = [{ base: 56, bar: 60, num: 58 }, { base: 126, bar: 67, num: 65 }];\nconst BAR0 = 1, BARLEN = 42;\n// The two colours' places on the wheel, before the hue knob.\nconst HUES = [0.56, 0.9];\n\n// 3 by 5 digits, rows top to bottom, bit 2 the left column.\nconst DIG = [\n  [7, 5, 5, 5, 7], [2, 6, 2, 2, 7], [7, 1, 7, 4, 7], [7, 1, 7, 1, 7], [5, 5, 7, 1, 1],\n  [7, 4, 7, 1, 7], [7, 4, 7, 5, 7], [7, 1, 1, 2, 2], [7, 5, 7, 5, 7], [7, 5, 7, 1, 7],\n];\nconst PCT = [5, 1, 2, 4, 5];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, thin: 0, more: 0,\n    buf: new Float32Array(W * H * 3),\n    col: [[0, 0, 0], [0, 0, 0]], pale: [[0, 0, 0], [0, 0, 0]],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.thin = cl(k[2] || 0, 0, 1);\n  const m = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.more = m \u003c 0.1 ? 0 : round(60 * ((m - 0.1) / 0.9) ** 1.6);\n  S.t += (d * speed) / 2;\n}\n\n// The triangle at model time t: base fixed, the apex walking. m is 1 at the\n// thin end and 0 at equilateral; the apex's side goes round once in 48 s.\nfunction triangle(t, thin) {\n  const m = 0.5 + 0.5 * cos((TAU * t) / 12);\n  const side = cos((TAU * t) / 48);\n  const hmin = 26 - 19 * thin;\n  const h = HEQ - m * (HEQ - hmin);\n  const ax = (BX0 + BX1) / 2 + m * 30 * side;\n  return [[ax, -h], [BX0, 0], [BX1, 0]];\n}\n\n// A side as a line with its inward unit normal: inside is n . p - c >= 0.\nfunction sideLine(P, Q, R) {\n  let nx = -(Q[1] - P[1]), ny = Q[0] - P[0];\n  const l = hypot(nx, ny);\n  nx /= l;\n  ny /= l;\n  let c = nx * P[0] + ny * P[1];\n  if (nx * R[0] + ny * R[1] - c \u003c 0) {\n    nx = -nx;\n    ny = -ny;\n    c = -c;\n  }\n  return { line: true, nx, ny, c };\n}\n\n// Everything about one triangle: sides, inradius, Malfatti's three, and the\n// corner ratios the greedy uses.\nfunction solve(V) {\n  const [A, B, C] = V;\n  const a = hypot(B[0] - C[0], B[1] - C[1]), b = hypot(C[0] - A[0], C[1] - A[1]), c = hypot(A[0] - B[0], A[1] - B[1]);\n  const s = (a + b + c) / 2, area = sqrt(max(1e-9, s * (s - a) * (s - b) * (s - c))), r = area / s;\n  const I = [(a * A[0] + b * B[0] + c * C[0]) / (2 * s), (a * A[1] + b * B[1] + c * C[1]) / (2 * s)];\n  const dist = (P) => hypot(P[0] - I[0], P[1] - I[1]);\n  const d = dist(A), e = dist(B), f = dist(C);\n  const rad = [\n    (r / (2 * (s - a))) * (s - r - (e + f - d)),\n    (r / (2 * (s - b))) * (s - r - (f + d - e)),\n    (r / (2 * (s - c))) * (s - r - (d + e - f)),\n  ];\n  const mal = rad.map((rr, i) => ({ x: V[i][0] + (I[0] - V[i][0]) * (rr / r), y: V[i][1] + (I[1] - V[i][1]) * (rr / r), r: rr }));\n  // Each side by the vertex it faces: lines[0] is BC.\n  const lines = [sideLine(B, C, A), sideLine(C, A, B), sideLine(A, B, C)];\n  const q = V.map((P) => {\n    const sh = r / dist(P);\n    return (1 - sh) / (1 + sh);\n  });\n  return { V, area, r, I, mal, lines, q };\n}\n\n// The largest circle tangent to three mutually tangent things (at most one\n// of them a side): its radius from Descartes, its centre from two of the\n// three, choosing of the two crossings the one that also touches the third.\nfunction soddy(o) {\n  const k = o.map((x) => (x.line ? 0 : 1 / x.r));\n  const kk = k[0] + k[1] + k[2] + 2 * sqrt(max(0, k[0] * k[1] + k[1] * k[2] + k[2] * k[0]));\n  const rho = 1 / kk;\n  const circ = o.filter((x) => !x.line), ln = o.find((x) => x.line);\n  const third = ln || o[2];\n  let pts;\n  if (ln) {\n    // Points rho inside the side, at r1 + rho from the circle.\n    const C1 = circ[0], R = C1.r + rho, off = ln.nx * C1.x + ln.ny * C1.y - (ln.c + rho);\n    const h2 = R * R - off * off;\n    if (h2 \u003c 0) return null;\n    const fx = C1.x - ln.nx * off, fy = C1.y - ln.ny * off, hh = sqrt(h2);\n    pts = [[fx - ln.ny * hh, fy + ln.nx * hh], [fx + ln.ny * hh, fy - ln.nx * hh]];\n    // Of the two, the one that touches the other circle.\n    const C2 = circ[1], want = C2.r + rho;\n    const e0 = abs(hypot(pts[0][0] - C2.x, pts[0][1] - C2.y) - want), e1 = abs(hypot(pts[1][0] - C2.x, pts[1][1] - C2.y) - want);\n    const p = e0 \u003c e1 ? pts[0] : pts[1];\n    return { x: p[0], y: p[1], r: rho };\n  }\n  const C1 = o[0], C2 = o[1], R1 = C1.r + rho, R2 = C2.r + rho;\n  const dx = C2.x - C1.x, dy = C2.y - C1.y, D = hypot(dx, dy);\n  const ax = (D * D + R1 * R1 - R2 * R2) / (2 * D), h2 = R1 * R1 - ax * ax;\n  if (h2 \u003c 0 || D \u003c= 0) return null;\n  const ux = dx / D, uy = dy / D, hh = sqrt(h2), mx = C1.x + ux * ax, my = C1.y + uy * ax;\n  pts = [[mx - uy * hh, my + ux * hh], [mx + uy * hh, my - ux * hh]];\n  const want = third.r + rho;\n  const e0 = abs(hypot(pts[0][0] - third.x, pts[0][1] - third.y) - want), e1 = abs(hypot(pts[1][0] - third.x, pts[1][1] - third.y) - want);\n  const p = e0 \u003c e1 ? pts[0] : pts[1];\n  return { x: p[0], y: p[1], r: rho };\n}\n\n// A gap's best circle: in a corner the next image of its circle under the\n// homothety at the vertex, otherwise the Soddy circle.\nfunction best(T, g) {\n  if (g.corner >= 0) {\n    const P = T.V[g.corner], q = T.q[g.corner], c = g.o[0];\n    return { x: P[0] + (c.x - P[0]) * q, y: P[1] + (c.y - P[1]) * q, r: c.r * q };\n  }\n  return soddy(g.o);\n}\n\nfunction addGap(list, T, corner, o) {\n  const g = { corner, o, c: null };\n  g.c = best(T, g);\n  if (g.c && g.c.r > 0.05) list.push(g);\n}\n\n// Takes the largest gap n times, splitting it each time. Returns the circles.\nfunction grow(T, gaps, n) {\n  const out = [];\n  for (let k = 0; k \u003c n && gaps.length; k++) {\n    let bi = 0;\n    for (let i = 1; i \u003c gaps.length; i++) if (gaps[i].c.r > gaps[bi].c.r) bi = i;\n    const g = gaps[bi], c = g.c;\n    gaps[bi] = gaps[gaps.length - 1];\n    gaps.pop();\n    out.push(c);\n    if (g.corner >= 0) {\n      // A corner leaves a smaller corner and the two cusps on its sides.\n      const v = g.corner, old = g.o[0];\n      addGap(gaps, T, v, [c]);\n      addGap(gaps, T, -1, [old, c, T.lines[(v + 1) % 3]]);\n      addGap(gaps, T, -1, [old, c, T.lines[(v + 2) % 3]]);\n    } else {\n      const [p, q, r] = g.o;\n      addGap(gaps, T, -1, [p, q, c]);\n      addGap(gaps, T, -1, [q, r, c]);\n      addGap(gaps, T, -1, [p, r, c]);\n    }\n  }\n  return out;\n}\n\n// The greedy from an empty triangle: the incircle and then grow().\nfunction greedy(T, n) {\n  const inc = { x: T.I[0], y: T.I[1], r: T.r }, gaps = [];\n  for (let v = 0; v \u003c 3; v++) addGap(gaps, T, v, [inc]);\n  return [inc].concat(grow(T, gaps, n - 1));\n}\n\n// After Malfatti's three: the middle, three corners and three cusps.\nfunction afterMalfatti(T, n) {\n  const [mA, mB, mC] = T.mal, gaps = [];\n  addGap(gaps, T, -1, [mA, mB, mC]);\n  for (let v = 0; v \u003c 3; v++) addGap(gaps, T, v, [T.mal[v]]);\n  addGap(gaps, T, -1, [mA, mB, T.lines[2]]);\n  addGap(gaps, T, -1, [mB, mC, T.lines[0]]);\n  addGap(gaps, T, -1, [mC, mA, T.lines[1]]);\n  return grow(T, gaps, n);\n}\n\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\n// A disc lit at `fill` inside, rising towards a rim line at `rim`.\nfunction disc(buf, oy, c, col, fill, rim) {\n  const cx = c.x, cy = c.y + oy, r = c.r;\n  if (r \u003c 0.7) {\n    add(buf, round(cx), round(cy), col, (fill + rim) * r * 0.9);\n    return;\n  }\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const e = hypot(x - cx, y - cy), u = e / r;\n      const inside = cl(r + 0.5 - e, 0, 1);\n      if (inside \u003c= 0) continue;\n      const ring = cl(1.2 - abs(e - r + 0.7), 0, 1);\n      add(buf, x, y, col, inside * (fill * (0.7 + 0.3 * u * u) * (1 - ring) + rim * ring));\n    }\n}\n\n// The triangle: its inside a faint grey, its sides a pale line.\nfunction shape(buf, T, oy, ink) {\n  const V = T.V.map((P) => [P[0], P[1] + oy]);\n  const y0 = max(0, floor(min(V[0][1], V[1][1], V[2][1])) - 1), y1 = min(H - 1, Math.ceil(max(V[0][1], V[1][1], V[2][1])) + 1);\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let dmin = 1e9, dseg = 1e9;\n      for (let i = 0; i \u003c 3; i++) {\n        const L = T.lines[i];\n        dmin = min(dmin, L.nx * x + L.ny * (y - oy) - L.c);\n        const P = V[(i + 1) % 3], Q = V[(i + 2) % 3], dx = Q[0] - P[0], dy = Q[1] - P[1];\n        const tt = cl(((x - P[0]) * dx + (y - P[1]) * dy) / (dx * dx + dy * dy), 0, 1);\n        dseg = min(dseg, hypot(P[0] + tt * dx - x, P[1] + tt * dy - y));\n      }\n      const inside = cl(dmin + 0.5, 0, 1), edge = cl(1.1 - dseg, 0, 1);\n      add(buf, x, y, ink, 0.13 * inside * (1 - edge) + 0.62 * edge);\n    }\n}\n\nfunction digit(buf, ch, x0, y0, col) {\n  const g = ch === \"%\" ? PCT : DIG[ch];\n  for (let j = 0; j \u003c 5; j++) for (let i = 0; i \u003c 3; i++) if (g[j] & (4 >> i)) add(buf, x0 + i, y0 + j, col, 1);\n}\n\n// A bar of the covered share, over a faint track for the whole triangle,\n// and the share in tenths of a percent at the right.\nfunction bar(buf, row, numRow, share, col, pale) {\n  const len = share * BARLEN;\n  for (let x = BAR0; x \u003c BAR0 + BARLEN; x++) {\n    const f = cl(BAR0 + len - x, 0, 1);\n    for (let y = row - 1; y \u003c= row + 1; y++) add(buf, x, y, col, 0.12 + 0.83 * f);\n  }\n  const tenths = round(share * 1000), s = String(floor(tenths / 10)).padStart(2, \" \");\n  let x = 46;\n  for (const ch of s) {\n    if (ch !== \" \") digit(buf, +ch, x, numRow, pale);\n    x += 4;\n  }\n  add(buf, x, numRow + 4, pale, 1);\n  digit(buf, tenths % 10, x + 2, numRow, pale);\n  digit(buf, \"%\", x + 6, numRow, pale);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, col = S.col, pale = S.pale;\n  buf.fill(0);\n  for (let i = 0; i \u003c 2; i++) {\n    hsv(S.hue + HUES[i], 0.85, 1, col[i]);\n    hsv(S.hue + HUES[i], 0.35, 1, pale[i]);\n  }\n  const T = solve(triangle(S.t, S.thin));\n  const ink = [0.85, 0.85, 0.9];\n  const greedyAll = greedy(T, 3 + S.more), malMore = afterMalfatti(T, S.more);\n  const sets = [T.mal, greedyAll.slice(0, 3)];\n  const extra = [malMore, greedyAll.slice(3)];\n  for (let i = 0; i \u003c 2; i++) {\n    const L = TOPS[i], oy = L.base;\n    shape(buf, T, oy, ink);\n    for (const c of sets[i]) disc(buf, oy, c, col[i], 0.42, 1);\n    for (const c of extra[i]) disc(buf, oy, c, pale[i], 0.45, 0.85);\n    let a = 0;\n    for (const c of sets[i]) a += PI * c.r * c.r;\n    bar(buf, L.bar, L.num, a / T.area, col[i], pale[i]);\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n}\n","modular-hyperbola":"// ===== Patternflow pattern =====\n// Title:   Modular Hyperbola\n// Family:  number\n// Idea:    The multiplication table of the integers mod a prime p fills the panel, column x + 1 times row y, and every LED stands on one sawtooth of the residues, white where the product is a running residue c and falling through a cubehelix ramp to black just before it comes round to c again, so the hard white edges trace the modular hyperbola xy = c (mod p): at p = 127, 32 true hyperbolas nested round the top left corner and their mirror round the bottom left, with checks along the middle row and the last column where x and y are near p/2, and, with the tooth narrowed to two residues, a scatter of points that lands a fair share in every patch of the table.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the modular hyperbola xy = c (mod p), whose points in a box are counted with Kloosterman sums (Hendrik Kloosterman, 1926) and Weil's bound on them (Andre Weil, 1948); cubehelix colour ramp (Dave Green, 2011), pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Prime=-3..4, Band=0..1\n//\n// Knob 1: Hue. Where the cubehelix ramp starts its turn round the colour wheel. At 0 a tooth climbs from black through violet, blue, teal and green to pale pink and white; at 0.25 through brown, mauve and sky blue; at 0.5 through moss, rose and lilac; at 0.75 through navy, green and salmon. The top of every tooth is white whatever the hue.\n// Knob 2: Speed. c climbs through all p residues in 12 / Speed seconds whatever the prime: 6 s at the opening 2, 60 s at 0.2 and 4 s at 3. At p = 127 and Speed 2 that is 21 residues a second.\n// Knob 3: Prime. -3 is 13, -2 is 31, -1 is 61, the opening 0 is 127, 1 is 251, 2 is 509, 3 is 1021 and 4 is 2039, each the largest prime under a power of two. At 127 the 128 rows hold every residue once with the zero row at the top and again at the bottom, and the lower half is the upper half upside down. At 13 the table repeats as a 13 by 13 tile, and at 2039 the product stays under p over 59% of the panel, so the top left is plain hyperbolas.\n// Knob 4: Band. How much of each tooth is lit: p - Band^2 (p - 2) residues of the p. The whole tooth at 0 and at the opening 0.06, three quarters at 0.5, and at 1 only the residues c and c + 1, so what is left is the hyperbola itself; at p = 127 that is one LED in every column for each of the two.\n\n// The integers mod a prime p, multiplied. LED (x, y) holds the residue\n// (x + 1) y mod p: columns count 1 to 64 and rows 0 to 127, so the top row\n// is the row of zeros. A running residue c, a real number, lights every LED\n// by how far its residue r has to go back to reach c:\n//\n//   t = 1 - ((r - c) mod p) / p\n//\n// t is 1 on the residue just above c and falls to 0 on the one just below,\n// so wherever the residue steps from c - 1 to c the picture steps from black\n// to white. Those steps are the modular hyperbola xy = c (mod p).\n//\n// Each tooth is the band between two hyperbolas xy = c + kp and\n// xy = c + (k + 1)p. Row y is a sawtooth in x of y/p cycles an LED, and\n// column x one of (x + 1)/p cycles down, so at p = 127 the whole upper\n// half stays under half a cycle an LED both ways and its 32 teeth are true\n// hyperbolas, nested round the top left corner. Near y = p/2 a row is\n// almost two LEDs a cycle and reads as a check; near p/3 every third LED\n// lines up; and the rows round each fraction a/b with a small b repeat\n// every b LEDs, the Farey fractions in order down the panel. The table is the same read\n// across, so at p = 127 the last column, x + 1 = 64 = (p + 1) / 2, is a\n// check too: 64 is the inverse of 2 mod 127, and the column holds y/2.\n//\n// Row p - y holds -xy. At p = 127 row 127 - y is row y with the residue\n// negated, so the lower half is the upper half upside down, with the ramp\n// run backwards and c read as -c.\n//\n// c climbs through the residues, a full turn in 12 / Speed seconds. Near\n// the corner the hyperbolas spread out smoothly; elsewhere every whole step\n// of c moves the white set to a new scatter of points. Counting the points\n// of xy = c in a box of X columns and Y rows comes down to Kloosterman sums\n// (Hendrik Kloosterman, 1926), and Weil's bound on them (Andre Weil, 1948),\n// no bigger than 2 sqrt(p), keeps every box within a few sqrt(p) log^2 p of\n// its fair share XY / p. Band narrows the lit part of the tooth until only\n// that scatter is left.\n//\n// The ramp is Dave Green's cubehelix (2011): brightness rises from black to\n// white while the colour turns round a helix about the grey line, so all\n// three channels change along the tooth. A hue wheel scaled by brightness\n// was measured too: every LED then has one channel at 0, deflate packs the\n// frame in 1.91 bytes a pixel instead of 2.39, and the colour runs to 0.56.\n\nconst W = 64, H = 128;\nconst { floor, round, cos, sin, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The largest prime under 2^k, for k = 4 to 11.\nconst PRIMES = [13, 31, 61, 127, 251, 509, 1021, 2039];\n// Cubehelix: turns of the helix over the ramp, its width, and a gamma that\n// keeps the dark third of the tooth short.\nconst ROT = 1.2, AMP = 1.0, GAMMA = 1.25;\n\nfunction helix(l, s, o) {\n  l = pow(l, GAMMA);\n  const phi = 2 * PI * (s / 3 - ROT * l), a = (AMP * l * (1 - l)) / 2, c = cos(phi), sn = sin(phi);\n  o[0] = l + a * (-0.14861 * c + 1.78277 * sn);\n  o[1] = l + a * (-0.29227 * c - 0.90649 * sn);\n  o[2] = l + a * (1.97294 * c);\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    c: 0, p: 127, hue: 0, speed: 2, band: 0.06,\n    lut: new Uint8Array(256 * 3), lh: -1, o: [0, 0, 0],\n    m: new Int32Array(W * H), mp: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.p = PRIMES[cl(round(k[2] || 0), -3, 4) + 3];\n  S.band = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.c += (d * S.speed * S.p) / 12;\n  S.c -= floor(S.c / S.p) * S.p;\n}\n\n// The 256 steps of the tooth's ramp, rebuilt when Hue turns. The 0.37\n// keeps the opening hue off a red start.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let i = 0; i \u003c 256; i++) {\n    helix(i / 255, 3 * (S.hue + 0.37), S.o);\n    for (let j = 0; j \u003c 3; j++) S.lut[i * 3 + j] = round(cl(S.o[j], 0, 1) * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const p = S.p, M = S.m, L = S.lut;\n  // The table itself changes only with the prime.\n  if (S.mp !== p) {\n    S.mp = p;\n    for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) M[y * W + x] = ((x + 1) * y) % p;\n  }\n  // The lit part of the tooth, in residues: p at Band 0, 2 at Band 1.\n  const fp = (1 - S.band * S.band * (1 - 2 / p)) * p, c = S.c;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = M[y * W + x] - c;\n      if (r \u003c 0) r += p;\n      const t = r \u003c fp ? 1 - r / fp : 0;\n      const i = round(t * 255) * 3;\n      display.setPixel(x, y, L[i], L[i + 1], L[i + 2]);\n    }\n}\n","permutation-poem":"// ===== Patternflow pattern =====\n// Title:   Permutation Poem\n// Family:  type\n// Idea:    A short phrase is written out in every order of its words, one line under the next in 3 by 5 capitals with each word in its own colour, so the 21 lines on the panel weave into a block of the same few words; each new line starts as a copy of the one above, the words that move slide into their new places in white, and the page steps up a line, and in the Steinhaus-Johnson-Trotter order that move is always two neighbouring words passing each other, while in I AM THAT I AM a quarter of those passes trade an I for an I or an AM for an AM and leave the line exactly as it was.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Brion Gysin's permutation poems (I AM THAT I AM, 1960); Steinhaus-Johnson-Trotter order (Hale Trotter, 1962; Selmer Johnson, 1963); Heap's algorithm (B. R. Heap, 1963); next permutation in lexicographic order (Narayana Pandita, 14th century); 3 by 5 capitals drawn for this pattern, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..3, Order=0..2\n//\n// Knob 1: Hue. Turns the words' colours round the wheel together. At 0 the opening phrase has I in azure, AM in pink and THAT in yellow green, and a phrase of four different words runs blue violet, rose, yellow and sea green; the words that are moving are always near white.\n// Knob 2: Speed. 0.75 x Speed new lines a second: 1.5 at the opening 2, so a line takes 0.67 s, half of it the words sliding, a fifth held while the white fades, and the last 0.3 the page stepping up 6 rows. One line every 6.7 s at 0.2 and 2.25 a second at 3.\n// Knob 3: Phrase. 0 I AM THAT I AM (5 words, 120 orders, 30 different lines), 1 RUB OUT THE WORD (24 orders, all different), 2 TO BE OR NOT TO BE (720 orders, 180 different lines), 3 VENI VIDI VICI (6 orders, so the page repeats every 6 lines). Turning it rewrites the whole page at once.\n// Knob 4: Order. 0, the opening, is Steinhaus-Johnson-Trotter: every line is the one above with two neighbouring words swapped, and the last word of the phrase zigzags across the page. 1 is Heap's order: one swap a line, but the two words can stand far apart and slide over the ones between. 2 is lexicographic order, the phrase's own word order taken as the alphabet: the tail of the line turns round, so up to all the words move at once.\n\n// Gysin wrote out every arrangement of the words of a phrase, one under the\n// next, so that the page reads as a block of the same words in shifting\n// places. This pattern does the same with the phrase's words as tokens\n// 0..n-1 in the order the phrase gives them, and lists the n! orders of the\n// tokens, not the orders of the words: where a word comes twice, two lines\n// can read the same.\n//\n// Steinhaus-Johnson-Trotter (the plain changes of English bell ringing)\n// lists them so that each order is the one before with two neighbours\n// swapped. Even's way of running it gives every token a direction, left to\n// start with; the largest token that points at a smaller neighbour swaps\n// with it, and every token larger than it turns round. The largest token\n// of all moves on every line but one in n, so it crosses the line from end\n// to end and back: the zigzag thread down the page. After n! - 1 swaps the\n// order is the phrase with its first two words swapped, one swap from the\n// start, so the list closes into a loop.\n//\n// Heap's algorithm also makes each order from the last with one swap, but\n// of any two positions. The next permutation in lexicographic order finds\n// the last place i where token[i] \u003c token[i+1], swaps token[i] with the\n// smallest larger token after it and reverses everything after i.\n//\n// In I AM THAT I AM the tokens are I0 AM1 THAT2 I3 AM4. A swap of I0 with\n// I3 or AM1 with AM4 changes the tokens but not the words, and the new line\n// reads like the one above. Over a full turn that is 30 of the 120 lines in\n// Steinhaus-Johnson-Trotter order, 26 in Heap's and 12 in lexicographic\n// order; in TO BE OR NOT TO BE it is 144, 91 and 48 of the 720.\n//\n// The capitals are drawn on a grid five rows tall: I one column wide, N\n// four, M and W five, the rest three, one column between letters and three\n// between words. Lines stand 6 rows apart, so 21 whole lines and the foot of\n// a 22nd fill the 128 rows. Every order of a phrase is the same width, and\n// the block is centred on the panel.\n//\n// The page dims towards the top. Drawn at one brightness, every line is\n// the same bytes as some line above it, and the frame deflates to 0.055\n// bytes a pixel, a hair above the lowest pattern on the study's map.\n\nconst W = 64, H = 128, PITCH = 6, GH = 5, GAP = 3, LINES = 23;\nconst BOTTOM = H - GH; // top row of the newest line\nconst { floor, round, min } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nconst GLYPHS = {\n  A: \".#./#.#/###/#.#/#.#\", B: \"##./#.#/##./#.#/##.\", C: \".##/#../#../#../.##\",\n  D: \"##./#.#/#.#/#.#/##.\", E: \"###/#../##./#../###\", F: \"###/#../##./#../#..\",\n  G: \".##/#../#.#/#.#/.##\", H: \"#.#/#.#/###/#.#/#.#\", I: \"#/#/#/#/#\",\n  J: \"..#/..#/..#/#.#/.#.\", K: \"#.#/#.#/##./#.#/#.#\", L: \"#../#../#../#../###\",\n  M: \"#...#/##.##/#.#.#/#...#/#...#\", N: \"#..#/##.#/#.##/#..#/#..#\",\n  O: \".#./#.#/#.#/#.#/.#.\", P: \"##./#.#/##./#../#..\", Q: \".#./#.#/#.#/##./.##\",\n  R: \"##./#.#/##./#.#/#.#\", S: \".##/#../.#./..#/##.\", T: \"###/.#./.#./.#./.#.\",\n  U: \"#.#/#.#/#.#/#.#/###\", V: \"#.#/#.#/#.#/#.#/.#.\", W: \"#...#/#...#/#.#.#/##.##/#...#\",\n  X: \"#.#/#.#/.#./#.#/#.#\", Y: \"#.#/#.#/.#./.#./.#.\", Z: \"###/..#/.#./#../###\",\n};\n// Each glyph as its width and the list of lit cells (dx, dy).\nconst FONT = {};\nfor (const ch in GLYPHS) {\n  const rows = GLYPHS[ch].split(\"/\"), cells = [];\n  rows.forEach((r, dy) => [...r].forEach((c, dx) => c === \"#\" && cells.push(dx, dy)));\n  FONT[ch] = { w: rows[0].length, cells };\n}\n\n// I AM THAT I AM is Exodus 3:14 in the King James Bible and Gysin's\n// phrase; TO BE OR NOT TO BE is Hamlet's and VENI VIDI VICI Caesar's.\n// Each word gets a colour of its own, shared where a word comes twice.\nconst PHRASES = [\"I AM THAT I AM\", \"RUB OUT THE WORD\", \"TO BE OR NOT TO BE\", \"VENI VIDI VICI\"].map((text) => {\n  const words = text.split(\" \");\n  const kinds = [...new Set(words)];\n  const widths = words.map((w) => [...w].reduce((s, c) => s + FONT[c].w + 1, -1));\n  return { words, kind: words.map((w) => kinds.indexOf(w)), kinds: kinds.length, widths };\n});\n\n// The three orders, each as the full list of token orders from the phrase.\nfunction sjt(n) {\n  const p = [...Array(n).keys()], d = Array(n).fill(-1), out = [p.slice()];\n  for (;;) {\n    let m = -1;\n    for (let i = 0; i \u003c n; i++) {\n      const j = i + d[i];\n      if (j >= 0 && j \u003c n && p[j] \u003c p[i] && (m \u003c 0 || p[i] > p[m])) m = i;\n    }\n    if (m \u003c 0) return out;\n    const v = p[m], j = m + d[m];\n    [p[m], p[j]] = [p[j], p[m]];\n    [d[m], d[j]] = [d[j], d[m]];\n    for (let i = 0; i \u003c n; i++) if (p[i] > v) d[i] = -d[i];\n    out.push(p.slice());\n  }\n}\nfunction heap(n) {\n  const a = [...Array(n).keys()], c = Array(n).fill(0), out = [a.slice()];\n  let i = 1;\n  while (i \u003c n) {\n    if (c[i] \u003c i) {\n      const j = i % 2 === 0 ? 0 : c[i];\n      [a[j], a[i]] = [a[i], a[j]];\n      out.push(a.slice());\n      c[i]++;\n      i = 1;\n    } else c[i++] = 0;\n  }\n  return out;\n}\nfunction lex(n) {\n  const a = [...Array(n).keys()], out = [a.slice()];\n  for (;;) {\n    let i = n - 2;\n    while (i >= 0 && a[i] > a[i + 1]) i--;\n    if (i \u003c 0) return out;\n    let j = n - 1;\n    while (a[j] \u003c a[i]) j--;\n    [a[i], a[j]] = [a[j], a[i]];\n    for (let l = i + 1, r = n - 1; l \u003c r; l++, r--) [a[l], a[r]] = [a[r], a[l]];\n    out.push(a.slice());\n  }\n}\nconst ORDERS = [sjt, heap, lex];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const q = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  for (let k = 0; k \u003c 3; k++) o[k] = v * (1 - s + s * q[k]);\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, phrase: -1, order: -1, list: null,\n    k: LINES - 3, u: 0, buf: new Float32Array(W * H * 3), o: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ph = cl(round(k[2] || 0), 0, 3), od = cl(round(k[3] == null ? 0.06 : k[3]), 0, 2);\n  if (ph !== S.phrase || od !== S.order) {\n    S.phrase = ph;\n    S.order = od;\n    S.list = ORDERS[od](PHRASES[ph].words.length);\n  }\n  S.u += d * 0.75 * S.speed;\n  while (S.u >= 1) {\n    S.u -= 1;\n    S.k++;\n  }\n}\n\n// Where each token's word starts, for the order on line m of the list.\nfunction places(S, m, left, out) {\n  const P = PHRASES[S.phrase], perm = S.list[((m % S.list.length) + S.list.length) % S.list.length];\n  let x = left;\n  for (const t of perm) {\n    out[t] = x;\n    x += P.widths[t] + GAP;\n  }\n  return out;\n}\n\n// The page dims row by row towards the top, to 45% on row 0, so the\n// oldest lines recede.\nconst FADE = new Float32Array(H);\nfor (let y = 0; y \u003c H; y++) FADE[y] = 0.45 + (0.55 * y) / (H - 1);\n\nfunction word(S, t, x0, y0, r, g, b) {\n  const B = S.buf, w = PHRASES[S.phrase].words[t];\n  let x = x0;\n  for (const ch of w) {\n    const f = FONT[ch], c = f.cells;\n    for (let i = 0; i \u003c c.length; i += 2) {\n      const px = round(x) + c[i], py = y0 + c[i + 1];\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const q = (py * W + px) * 3, v = FADE[py];\n      B[q] += r * v;\n      B[q + 1] += g * v;\n      B[q + 2] += b * v;\n    }\n    x += f.w + 1;\n  }\n}\n\n// A step is one new line: the words slide for the first half, the white\n// fades until 0.7, and the page steps up 6 rows in the rest.\nconst SLIDE = 0.5, HOLD = 0.7;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.list) return;\n  const P = PHRASES[S.phrase], n = P.words.length, B = S.buf, o = S.o;\n  B.fill(0);\n  const width = P.widths.reduce((s, v) => s + v, 0) + GAP * (n - 1);\n  const left = floor((W - width) / 2);\n  const u = S.u, slide = smooth(u / SLIDE);\n  const glow = u \u003c SLIDE ? 1 : u \u003c HOLD ? 1 - (u - SLIDE) / (HOLD - SLIDE) : 0;\n  const lift = u \u003c HOLD ? 0 : round(PITCH * smooth((u - HOLD) / (1 - HOLD)));\n  // One colour a word, spread round the wheel from a start picked so that\n  // at Hue 0 no word is red or orange; orange dimmed at the top of the page\n  // reads as brown.\n  const cols = [], base = P.kinds === 4 ? 0.68 : 0.58;\n  for (let i = 0; i \u003c P.kinds; i++) {\n    hsv(S.hue + base + i / P.kinds, 0.55, 230, o);\n    cols.push([o[0], o[1], o[2]]);\n  }\n  const a = new Array(n), b = new Array(n);\n  // Line S.k is the newest; while the page steps up, line S.k + 1 comes in\n  // under it as a copy, its words still in S.k's places.\n  const newest = lift > 0 ? S.k + 1 : S.k;\n  for (let m = newest; m > newest - LINES; m--) {\n    const y0 = BOTTOM - PITCH * (S.k - m) - lift;\n    if (y0 \u003c= -GH || y0 >= H) continue;\n    if (m === S.k) {\n      places(S, m - 1, left, a);\n      places(S, m, left, b);\n    } else places(S, m > S.k ? S.k : m, left, b);\n    for (let t = 0; t \u003c n; t++) {\n      const c = cols[P.kind[t]];\n      if (m === S.k && a[t] !== b[t]) {\n        const x = a[t] + (b[t] - a[t]) * slide, wv = 0.8 * glow;\n        word(S, t, x, y0, c[0] + (255 - c[0]) * wv, c[1] + (255 - c[1]) * wv, c[2] + (255 - c[2]) * wv);\n      } else word(S, t, b[t], y0, c[0], c[1], c[2]);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, B[q]), min(255, B[q + 1]), min(255, B[q + 2]));\n    }\n}\n","pollards-rho":"// ===== Patternflow pattern =====\n// Title:   Pollard's Rho\n// Family:  algo\n// Idea:    The sequence x -> x^2 + c taken modulo a hidden prime factor p of n stands up the panel as the Greek letter rho, a tail of numbered beads climbing from x0 = 2 at the bottom into a loop of beads at the top, and a tortoise and a hare chase each other along it, one bead and two beads a beat after Floyd or one bead a beat with the tortoise jumping to the hare at powers of two after Brent, while the readout beside the tail shows what the algorithm itself sees, the two values modulo n and their difference, and the gcd in the middle of the loop stays 1 until the two land on the same bead, when it jumps to p, the loop flashes and n is written as its two factors before the next number.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pollard's rho method of factorisation (John M. Pollard, 1975), with Floyd's cycle finding (credited to Robert W. Floyd) and Brent's (Richard P. Brent, 1980); numerals and letters drawn for this pattern on a 3 by 5 grid, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Number=0..7, Constant=1..6\n//\n// Knob 1: Hue. Turns the three colours round the wheel together. At 0 the beads are azure, the tortoise green and the hare orange; at 0.5 the beads are orange-red, the tortoise magenta and the hare blue.\n// Knob 2: Speed. One evaluation of f takes 0.44 / Speed seconds: 0.22 s at the opening 2, so a Floyd beat (three evaluations) takes 0.66 s and a Brent beat 0.22 s. At 0.2 a Floyd beat takes 6.6 s, at 3 it takes 0.44 s. A found factor is held 3.2 s at Speed 2.\n// Knob 3: Number. Which n the pattern starts from: 0 is 5893 = 71 x 83, then 6319, 8051 = 83 x 97, 4307, 4331, 6497, 2911 and 7031. Each number is factored by Floyd and then by Brent, and then the next one comes. With c = 1, 4307 = 59 x 73 fails: both primes close their loops on the same beat, the gcd is n itself, and the pattern tries again with c = 2.\n// Knob 4: Constant. The c in x^2 + c, 1 to 6. A new c is a new sequence and a new rho: for 5893 the rho modulo 83 has a tail of 4 and a loop of 5 at c = 1, 2 and 4 at c = 2, 5 and 5 at c = 4, and at c = 5 the factor that turns up first is 71, with a tail of 2 and a loop of 6.\n\n// Pollard's idea: take a map that looks random, f(x) = x^2 + c, and walk\n// x0, x1 = f(x0), x2 = f(x1), ... modulo n. Modulo an unknown prime factor p\n// of n the same walk is a walk on only p values, so after about sqrt(p)\n// steps it must come back to a value it has seen, and from there it goes\n// round the same loop for ever. Drawn out, the walk modulo p is a tail and a\n// loop: the letter rho. Modulo n nothing has repeated yet, but two terms\n// that sit on the same bead of the rho differ by a multiple of p, so\n// gcd(|x_i - x_j|, n) is p.\n//\n// The algorithm cannot see the rho, only the values modulo n. It finds the\n// loop without storing the walk by running two pointers. Floyd's tortoise\n// takes one step and his hare two each beat; once both are on the loop the\n// hare gains one bead a beat and lands on the tortoise's bead at the first\n// beat i that is at least the tail's length and a multiple of the loop's.\n// Brent's hare takes one step a beat and his tortoise waits, jumping to the\n// hare after 1, 2, 4, 8, ... steps; it costs one evaluation of f a beat\n// against Floyd's three, which is what Brent's 1980 paper gains. Here time\n// runs by evaluations, so the two methods race fairly on the same number.\n//\n// The beads are x_i mod p, which the panel knows and the algorithm does\n// not; the readout T and H are x_t and x_h mod n, and D is their difference.\n// The hare lights each bead as it first reaches it. Every product here is\n// below 8051^2, about 6.5e7, so ordinary doubles are exact.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst TAU = 2 * PI;\n\nconst NUMS = [5893, 6319, 8051, 4307, 4331, 6497, 2911, 7031];\nconst X0 = 2;\n// The rho: loop centre and radius, the stem down its left side to YB.\nconst CX = 32, CY = 31, R = 24, SX = CX - R, YB = 122;\n// Model seconds: one evaluation of f, the start, and the hold after a find.\nconst EVAL = 0.22, INTRO = 0.5, HOLD = 3.2, MOVE = 0.6;\nconst HUE_BEAD = 0.55, HUE_T = 0.33, HUE_H = 0.09;\n\n// ---- Glyphs on a 3 by 5 grid, rows top to bottom.\nconst GL = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\",\n  4: \"101101111001001\", 5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001001010010\",\n  8: \"111101111101111\", 9: \"111101111001111\",\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", L: \"100100100100111\", N: \"101111111101101\", O: \"010101101101010\",\n  R: \"110101110101101\", T: \"111010010010010\", X: \"101101010101101\", Y: \"101101010010010\",\n  \"+\": \"000010111010000\", \"=\": \"000111000111000\", \"*\": \"000101010101000\", \"|\": \"010010010010010\",\n  \"-\": \"000000111000000\", \" \": \"000000000000000\",\n};\n\nfunction gcd(a, b) {\n  while (b) {\n    const t = a % b;\n    a = b;\n    b = t;\n  }\n  return a;\n}\n\nfunction smallestFactor(n) {\n  for (let d = 2; d * d \u003c= n; d++) if (n % d === 0) return d;\n  return n;\n}\n\n// One run of the method on (n, c): the states beat by beat, and the rho of\n// the prime it finds (or, when it fails, of the smaller prime).\nfunction plan(n, c, brent) {\n  const xs = [X0 % n];\n  const x = (i) => {\n    while (xs.length \u003c= i) {\n      const v = xs[xs.length - 1];\n      xs.push((v * v + c) % n);\n    }\n    return xs[i];\n  };\n  const beats = [{ t: 0, h: 0, d: 0 }];\n  let d = 1;\n  if (!brent) {\n    for (let i = 1; d === 1 && i \u003c 400; i++) {\n      d = gcd(abs(x(i) - x(2 * i)), n);\n      beats.push({ t: i, h: 2 * i, d });\n    }\n  } else {\n    let pw = 1, lam = 1, t = 0, h = 1;\n    for (let k = 0; k \u003c 800; k++) {\n      d = gcd(abs(x(t) - x(h)), n);\n      beats.push({ t, h, d });\n      if (d > 1) break;\n      if (pw === lam) {\n        t = h;\n        pw *= 2;\n        lam = 0;\n      }\n      h++;\n      lam++;\n    }\n  }\n  const p = d > 1 && d \u003c n ? d : smallestFactor(n);\n  const seen = new Map(), lab = [];\n  let v = X0 % p, i = 0;\n  while (!seen.has(v)) {\n    seen.set(v, i);\n    lab.push(v);\n    v = (v * v + c) % p;\n    i++;\n  }\n  const mu = seen.get(v), lam = i - mu;\n  const tailSp = mu > 0 ? (YB - CY) / mu : 99, loopSp = lam > 1 ? 2 * R * sin(PI / lam) : 99;\n  return {\n    n, c, brent, xs, beats, d, p, q: n / p, mu, lam, lab, fail: d === n,\n    rt: cl(tailSp / 2 - 0.4, 1.5, 5), rl: cl(loopSp / 2 - 0.4, 1.5, 5),\n    beat: brent ? EVAL : 3 * EVAL,\n  };\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, num: -1, c: -1, idx: 0, cc: 1, brent: false,\n    run: null, m: 0, buf: new Float32Array(N * 3),\n    cb: [0, 0, 0], ct: [0, 0, 0], ch: [0, 0, 0], pos: [0, 0],\n  };\n}\n\nfunction start(S) {\n  S.run = plan(NUMS[S.idx], S.cc, S.brent);\n  S.m = 0;\n}\n\n// After a run: a failure tries the next c with the same method; a Floyd find\n// hands the number to Brent; a Brent find moves on to the next number.\nfunction next(S) {\n  const P = S.run;\n  if (P.fail) S.cc++;\n  else if (!P.brent) S.brent = true;\n  else {\n    S.brent = false;\n    S.idx = (S.idx + 1) % NUMS.length;\n    S.cc = S.c;\n  }\n  start(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const num = round(cl(k[2] || 0, 0, 7)), c = round(cl(k[3] == null ? 1 : k[3], 1, 6));\n  if (num !== S.num || c !== S.c) {\n    S.num = num;\n    S.c = c;\n    S.idx = num;\n    S.cc = c;\n    S.brent = false;\n    start(S);\n  }\n  const P = S.run, end = INTRO + (P.beats.length - 1) * P.beat;\n  // The hold after a find runs at no less than Speed 1, so a slow knob\n  // still moves on to the next number within 6.4 s.\n  S.m += d * (S.m > end ? max(1, S.speed) : S.speed) * 0.5;\n  if (S.m > end + HOLD) next(S);\n}\n\n// ---- Drawing into a float RGB buffer.\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] = c[0] * a;\n  buf[p + 1] = c[1] * a;\n  buf[p + 2] = c[2] * a;\n}\n\nfunction disc(buf, cx, cy, r, c, a) {\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const e = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      add(buf, x, y, c, a * cl(r + 0.5 - e, 0, 1));\n    }\n}\n\nfunction ring(buf, cx, cy, r, c, a, w) {\n  for (let y = floor(cy - r - 2); y \u003c= cy + r + 2; y++)\n    for (let x = floor(cx - r - 2); x \u003c= cx + r + 2; x++) {\n      const e = abs(sqrt((x - cx) ** 2 + (y - cy) ** 2) - r);\n      add(buf, x, y, c, a * cl(w + 0.5 - e, 0, 1));\n    }\n}\n\nconst textWidth = (s, sc) => s.length * 4 * sc - sc;\n\n// mode 0 adds light, mode 1 punches the glyph dark out of what is there.\nfunction text(buf, s, x0, y0, sc, c, a, mode) {\n  for (let k = 0; k \u003c s.length; k++) {\n    const g = GL[s[k]];\n    if (!g) continue;\n    for (let gy = 0; gy \u003c 5; gy++)\n      for (let gx = 0; gx \u003c 3; gx++) {\n        if (g[gy * 3 + gx] !== \"1\") continue;\n        for (let yy = 0; yy \u003c sc; yy++)\n          for (let xx = 0; xx \u003c sc; xx++) {\n            const x = x0 + k * 4 * sc + gx * sc + xx, y = y0 + gy * sc + yy;\n            if (mode) put(buf, x, y, c, a);\n            else add(buf, x, y, c, a);\n          }\n      }\n  }\n}\n\n// A point on the rho at fractional node u: the tail up the stem, then the\n// loop, entered at its leftmost point going up and round clockwise.\nfunction along(P, u, o) {\n  if (u \u003c P.mu) {\n    o[0] = SX;\n    o[1] = YB - ((YB - CY) * u) / P.mu;\n  } else {\n    const a = PI + (TAU * (u - P.mu)) / P.lam;\n    o[0] = CX + R * cos(a);\n    o[1] = CY + R * sin(a);\n  }\n  return o;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.run) return;\n  const P = S.run, buf = S.buf, pos = S.pos;\n  buf.fill(0);\n  const CB = hsv(S.hue + HUE_BEAD, 0.75, 1, S.cb), CT = hsv(S.hue + HUE_T, 0.8, 1, S.ct), CH = hsv(S.hue + HUE_H, 0.85, 1, S.ch);\n  const white = [1, 1, 1], pale = [0.82, 0.86, 0.95];\n\n  // Where the run is: beat k, the share f of it gone, the movement eased.\n  const nb = P.beats.length, tm = S.m - INTRO;\n  let k = 0, f = 1;\n  if (tm >= 0) {\n    k = min(nb - 1, 1 + floor(tm / P.beat));\n    f = k === nb - 1 && tm >= (nb - 1) * P.beat ? 1 : (tm - (k - 1) * P.beat) / P.beat;\n  }\n  const e = smooth(f / MOVE), b0 = P.beats[max(0, k - 1)], b1 = P.beats[k];\n  const tu = k === 0 ? 0 : b0.t + (b1.t - b0.t) * e, hu = k === 0 ? 0 : b0.h + (b1.h - b0.h) * e;\n  const shown = k === 0 ? P.beats[0] : f >= MOVE ? b1 : b0;\n  const found = k === nb - 1 && f >= MOVE;\n  const since = found ? S.m - INTRO - (nb - 2) * P.beat - MOVE * P.beat : -1;\n  const flash = found ? cl(1 - since / 0.7, 0, 1) : 0;\n\n  // The string: the loop, and the stem when there is a tail.\n  const loopA = 0.2 + (found ? 0.25 + 0.55 * flash : 0);\n  ring(buf, CX, CY, R, found ? white : CB, loopA, 0.45);\n  if (P.mu > 0) for (let y = CY; y \u003c= YB; y++) add(buf, SX, y, CB, 0.22);\n\n  // The beads, lit once the hare has reached them, each with x_i mod p.\n  const nodes = P.mu + P.lam;\n  for (let i = 0; i \u003c nodes; i++) {\n    along(P, i, pos);\n    const x = pos[0], y = pos[1], r = i \u003c P.mu ? P.rt : P.rl;\n    if (hu + 1e-6 >= i) {\n      disc(buf, x, y, r, CB, 0.82);\n      const s = String(P.lab[i]);\n      if (r >= 4.4) text(buf, s, round(x - textWidth(s, 1) / 2), round(y - 2.5), 1, CB, 0.05, 1);\n    } else ring(buf, x, y, r - 0.5, CB, 0.3, 0.45);\n  }\n\n  // The meeting bead flashes white with a ring running out from it.\n  if (found) {\n    along(P, P.beats[nb - 1].t, pos);\n    const r = P.beats[nb - 1].t \u003c P.mu ? P.rt : P.rl;\n    disc(buf, pos[0], pos[1], r + 1, white, 0.9 * flash);\n    if (since \u003c 1.2) ring(buf, pos[0], pos[1], r + 3 + since * 26, white, 0.7 * (1 - since / 1.2), 0.6);\n  }\n\n  // Tortoise and hare: rings round their beads.\n  along(P, tu, pos);\n  ring(buf, pos[0], pos[1], P.rl + 2.2, CT, 1, 0.55);\n  along(P, hu, pos);\n  ring(buf, pos[0], pos[1], P.rl + 3.8, CH, 1, 0.55);\n\n  // The gcd in the middle of the loop.\n  const g = shown.d || 1;\n  text(buf, \"GCD\", CX - 5, CY - 13, 1, pale, 0.55, 0);\n  if (P.fail && found) {\n    // n itself is four digits wide and reaches the rings on the loop, so it\n    // gets a dark field one LED round it to stay whole.\n    const s = String(g), x0 = CX - textWidth(s, 2) / 2;\n    for (let y = CY - 5; y \u003c= CY + 6; y++) for (let x = x0 - 1; x \u003c= x0 + textWidth(s, 2); x++) put(buf, x, y, white, 0);\n    text(buf, s, x0, CY - 4, 2, white, 0.5 + 0.5 * flash, 0);\n  } else {\n    const s = String(g), sc = 3;\n    text(buf, s, round(CX - textWidth(s, sc) / 2), CY - 5, sc, found ? CB : pale, found ? 0.6 + 0.4 * flash : 0.5, 0);\n    if (found) text(buf, s, round(CX - textWidth(s, sc) / 2), CY - 5, sc, white, 0.6 * flash, 0);\n  }\n\n  // The readout beside the stem: what the algorithm sees modulo n.\n  const RX = 20;\n  const ns = String(P.n);\n  text(buf, ns, RX + 23 - textWidth(ns, 2) / 2, 66, 2, pale, 0.85, 0);\n  // f(x) = x^2 + c, the 2 a small raised one.\n  text(buf, \"X\", RX + 6, 81, 1, pale, 0.7, 0);\n  add(buf, RX + 10, 79, pale, 0.7);\n  add(buf, RX + 11, 79, pale, 0.7);\n  add(buf, RX + 11, 80, pale, 0.7);\n  add(buf, RX + 10, 81, pale, 0.7);\n  add(buf, RX + 10, 82, pale, 0.7);\n  add(buf, RX + 11, 82, pale, 0.7);\n  text(buf, \"+\" + P.c, RX + 13, 81, 1, pale, 0.7, 0);\n  const evals = (k === 0 ? 0 : f >= MOVE ? k : k - 1) * (P.brent ? 1 : 3);\n  text(buf, P.brent ? \"BRENT\" : \"FLOYD\", RX + 2, 90, 1, pale, 0.75, 0);\n  const es = String(evals);\n  text(buf, es, RX + 44 - textWidth(es, 1), 90, 1, pale, 0.6, 0);\n  const xt = P.xs[shown.t], xh = P.xs[shown.h];\n  text(buf, \"T\", RX + 2, 100, 1, CT, 1, 0);\n  text(buf, String(xt), RX + 44 - textWidth(String(xt), 1), 100, 1, CT, 0.95, 0);\n  text(buf, \"H\", RX + 2, 107, 1, CH, 1, 0);\n  text(buf, String(xh), RX + 44 - textWidth(String(xh), 1), 107, 1, CH, 0.95, 0);\n  text(buf, \"D\", RX + 2, 114, 1, pale, 0.75, 0);\n  const ds = String(abs(xt - xh));\n  text(buf, ds, RX + 44 - textWidth(ds, 1), 114, 1, pale, 0.75, 0);\n  if (found) {\n    const s = P.fail ? \"FAIL C+1\" : \"=\" + P.p + \"*\" + P.q;\n    text(buf, s, RX + 44 - textWidth(s, 1), 122, 1, P.fail ? CH : CB, 0.7 + 0.3 * flash, 0);\n  }\n\n  for (let p = 0; p \u003c N; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n}\n","ybc-7289":"// ===== Patternflow pattern =====\n// Title:   YBC 7289\n// Family:  type\n// Idea:    The upper half of the tall panel is the face of the tablet YBC 7289 under a swaying lamp, a square with both diagonals pressed into clay and its numbers in cuneiform wedges, 30 by a side, 1;24,51,10 along the diagonal and 42;25,35 below it, and on the clay below, the averaging x -> (x + 2/x)/2 is written out wedge by wedge from 1;30, one step to a line in sexagesimal places, each place lighting turquoise once it is the square root of 2's own place, so 1;30 and 1;25 light only their 1, 1;24,51,10,35 lights four places and the tablet's number with them, and 1;24,51,10,7 lights all five.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: YBC 7289, Yale Babylonian Collection, Old Babylonian (about 1800 to 1600 BCE); the averaging method for square roots as later written down by Heron of Alexandria (1st century); wedges drawn for this pattern as pyramids pressed into a height field, pattern round 81\n// Round:   81\n// ===============================\n// @matrix 64x128\n// @knobs Lamp=0..1, Speed=0.2..3, Start=0..5, Places=0..1\n//\n// Knob 1: Lamp. Where the lamp stands around the tablet, a full turn over the range; it is always 15 degrees above the clay and sways 29 degrees either way. At 0 it is on the left and a little above, so a wedge's left wall falls into shadow and its right wall catches the light; at 0.25 it is below, at 0.5 on the right, where the bright and dark walls of every wedge change sides, and at 0.75 above.\n// Knob 2: Speed. At 2 a wedge is pressed every 0.06 s and each agreeing place lights 0.12 s after the one before, so the four lines from 1;30 are written and checked in 7.9 s and stand 3.5 s before the clay is smoothed over 1.2 s, a round of 13.1 s; the lamp sways once in 7 s. Every time goes as 2 / Speed.\n// Knob 3: Start. The first guess: 0 is 1;30 (3/2), 1 is 1;20 (4/3), 2 is 2, 3 is 1, 4 is 1;24 (7/5), 5 is 1;40 (5/3). 1;30 and 1;20 both give 1;25 next, and 2 and 1 both give 1;30, since x and 2/x always lead to the same average; 1;24 agrees in two places at once and needs only three lines. A new start opens on its lines already written, then smooths them and writes them again.\n// Knob 4: Places. How many places after the point each step keeps before the next is worked out: all of them below 0.125 (the opening 0.06), so the lines run on until one holds five places that all agree; 4 from 0.125, 3 from 0.375, 2 from 0.625 and 1 from 0.875. Cut to 3, every start lands on 1;24,51,10, the tablet's own number, the next step gives it back unchanged, and the tablet's number lights; cut to 2 or 1 the lines settle on 1;24,51 or 1;24 and the tablet stays dark.\n\n// YBC 7289 carries a square with its two diagonals. One side is marked 30;\n// along a diagonal stands 1;24,51,10 and under it 42;25,35. In base 60,\n// 1;24,51,10 is 1 + 24/60 + 51/60^2 + 10/60^3 = 1.4142130, the square root\n// of 2 to about six decimal places, and 42;25,35 is 30 times it: the\n// diagonal of the square of side 30. Halving 1;24,51,10 gives 0;42,25,35,\n// so multiplying by 30 is halving and moving one place up.\n//\n// The method drawn below takes a guess x for the root of 2 and averages it\n// with 2/x. When x is too big 2/x is too small by about as much, so the\n// average lands far closer, and each step about doubles the places that\n// are right. From 3/2: 17/12 = 1;25, then 577/408 = 1;24,51,10,35,... and\n// 665857/470832 = 1;24,51,10,7,46,6,9,... where the root is\n// 1;24,51,10,7,46,6,4,44. The iterates are kept as exact fractions (BigInt)\n// and their places read off one by one, so a place lights only when it is\n// the root's own place, not a rounding of it. 1;25 is nearer the root than\n// 1;24 but its 25 is not the root's 24, so line two lights only its 1.\n//\n// Places cuts each step to so many places before the next, as anyone\n// working by hand must. Cut to three, the steps from every start reach\n// 1;24,51,10 and stop there: the average of 1;24,51,10 and 2 over it is\n// the root plus about 1e-13, whose first three places are 1;24,51,10 again.\n//\n// Numerals: a place from 1 to 59 is its tens as corner wedges\n// (Winkelhaken) on the left, stacked in a column (four as two and two,\n// five as three and two), and its units as upright wedges in rows of three\n// on the right. Places stand a gap apart and a zero place is a wider gap.\n// Nothing marks where the whole part ends: the semicolon in 1;24,51,10 is\n// the modern reader's, and the wedges are only 1, 24, 51 and 10.\n//\n// Each wedge is a triangular pyramid pressed into a height field: a\n// triangle outline and its deepest point, the stylus's corner. The upright\n// wedge is a broad head with a tail; the corner wedge a short triangle\n// pointing left. The LEDs average 16 samples each of the surface normal,\n// and the light is a lamp at azimuth and elevation, scaled so flat clay\n// keeps one brightness: walls facing the lamp glow, walls facing away go\n// dark, and the deeper the floor the darker. The lamp sways, so the light\n// moves in every wedge on the panel while the stylus works on one.\n//\n// An agreeing place lights in two ways at once: its wedges turn turquoise\n// with the light spilling 4 LEDs round each, and a soft tile fills the box\n// of the place, so the agreeing run of a line reads as one highlighted span.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, PI, hypot, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Clay, its shadow floor, and the colour an agreeing place lights.\nconst CLAY = [168, 132, 92];\nconst AMB = 0.16, OCC = 0.85;\nconst GLOW = [45, 230, 220];\n\n// Wedge sizes in LEDs. A size is the cell an upright wedge or a corner\n// wedge sits in, c wide and r tall, and the width w of the wedge inside it.\n// The tablet writes small, so its 42;25,35 fits under the diagonal; the\n// worked lines write a size up.\nconst SMALL = { c: 3, r: 4, w: 2.6, x0: 0.2, tu: 1 }, LARGE = { c: 4, r: 4, w: 3, x0: 0, tu: 0 };\nconst DEPTH = 1.1, SS = 4, HALO = 4, PLACE_GAP = 3, ZERO_GAP = 6;\n\n// Timing in model seconds; Speed 2 runs one model second a second.\nconst T_WEDGE = 0.06, T_PLACE = 0.08, T_PAUSE = 0.25, T_CHECK = 0.12, T_AFTER = 0.3, T_HOLD = 3.5, T_SMOOTH = 1.2, T_REST = 0.5;\n\nconst STARTS = [[3n, 2n], [4n, 3n], [2n, 1n], [1n, 1n], [7n, 5n], [5n, 3n]];\n// How many places after the point a step keeps, by Places.\nconst KEEP = [Infinity, 4, 3, 2, 1];\nconst PLACES = 8;\n// The lamp sways SWAY radians either side of where Lamp sets it, once in SWAY_T model seconds.\nconst SWAY = 0.5, SWAY_T = 7, EL = (15 * PI) / 180;\n\n// ---- Exact arithmetic.\nfunction isqrt(n) {\n  if (n \u003c 2n) return n;\n  let x = n, y = (x + 1n) / 2n;\n  while (y \u003c x) {\n    x = y;\n    y = (x + n / x) / 2n;\n  }\n  return x;\n}\nfunction sexagesimal(p, q, n) {\n  const out = [Number(p / q)];\n  let r = p % q;\n  for (let k = 0; k \u003c n; k++) {\n    r *= 60n;\n    out.push(Number(r / q));\n    r %= q;\n  }\n  return out;\n}\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\nconst ROOT = (() => {\n  let v = isqrt(2n * 60n ** BigInt(2 * PLACES));\n  const d = [];\n  for (let k = 0; k \u003c= PLACES; k++) {\n    d.unshift(Number(v % 60n));\n    v /= 60n;\n  }\n  return d;\n})();\n\n// ---- Wedges as pyramids. Each returns its footprint on the LEDs: for every\n// LED it touches, the change it makes to the averaged normal, the share of\n// the LED inside it, the mean depth and how much of its glow reaches it.\nfunction pyramid(tri, P0) {\n  const edges = [];\n  for (let i = 0; i \u003c 3; i++) {\n    const A = tri[(i + 1) % 3], B = tri[(i + 2) % 3], C = tri[i];\n    let nx = -(B[1] - A[1]), ny = B[0] - A[0];\n    const l = hypot(nx, ny);\n    nx /= l;\n    ny /= l;\n    if (nx * (C[0] - A[0]) + ny * (C[1] - A[1]) \u003c 0) {\n      nx = -nx;\n      ny = -ny;\n    }\n    const d0 = nx * (P0[0] - A[0]) + ny * (P0[1] - A[1]);\n    const s = DEPTH / d0, nz = 1 / sqrt(1 + s * s);\n    edges.push({ ax: A[0], ay: A[1], nx, ny, d0, Nx: s * nx * nz, Ny: s * ny * nz, Nz: nz });\n  }\n  const x0 = floor(min(tri[0][0], tri[1][0], tri[2][0])), x1 = ceil(max(tri[0][0], tri[1][0], tri[2][0]));\n  const y0 = floor(min(tri[0][1], tri[1][1], tri[2][1])), y1 = ceil(max(tri[0][1], tri[1][1], tri[2][1]));\n  const out = [];\n  const w = 1 / (SS * SS);\n  for (let y = max(0, y0 - HALO); y \u003c min(H, y1 + HALO); y++)\n    for (let x = max(0, x0 - HALO); x \u003c min(W, x1 + HALO); x++) {\n      let dx = 0, dy = 0, dz = 0, cov = 0, dep = 0;\n      for (let sy = 0; sy \u003c SS; sy++)\n        for (let sx = 0; sx \u003c SS; sx++) {\n          const px = x + (sx + 0.5) / SS, py = y + (sy + 0.5) / SS;\n          let best = 2, k = -1;\n          for (let i = 0; i \u003c 3; i++) {\n            const e = edges[i], u = (e.nx * (px - e.ax) + e.ny * (py - e.ay)) / e.d0;\n            if (u \u003c 0) {\n              k = -1;\n              break;\n            }\n            if (u \u003c best) {\n              best = u;\n              k = i;\n            }\n          }\n          if (k \u003c 0) continue;\n          const e = edges[k];\n          dx += e.Nx * w;\n          dy += e.Ny * w;\n          dz += (e.Nz - 1) * w;\n          cov += w;\n          dep += best * DEPTH * w;\n        }\n      // The glow of an agreeing place spills a little onto the clay round\n      // each wedge, falling off over HALO LEDs from its outline.\n      let far = 0;\n      for (const e of edges) far = max(far, -(e.nx * (x + 0.5 - e.ax) + e.ny * (y + 0.5 - e.ay)));\n      const halo = max(cov, 0.75 * cl(1 - far / HALO, 0, 1));\n      if (cov > 0 || halo > 0) out.push(y * W + x, dx, dy, dz, cov, dep, halo);\n    }\n  return Float32Array.from(out);\n}\n// An upright wedge: broad head at the top, tail down to a point.\nconst upright = (x, y, z) =>\n  pyramid([[x + z.x0, y + 0.1], [x + z.x0 + z.w, y + 0.1], [x + z.x0 + z.w / 2, y + z.r - 0.1]], [x + z.x0 + z.w / 2, y + 1.2]);\n// A corner wedge: a short triangle pointing left, deepest near its point.\nconst corner = (x, y, z) =>\n  pyramid([[x + z.x0, y + 1.5], [x + z.x0 + z.w, y + 0.05], [x + z.x0 + z.w, y + 2.95]], [x + z.x0 + 1.1, y + 1.5]);\n\n// ---- Numerals. A place's wedges in writing order, tens first, from the\n// place's left edge x and the line's middle row ym.\nfunction placeWidth(v, z) {\n  if (v === 0) return ZERO_GAP - PLACE_GAP;\n  const t = floor(v / 10), u = v % 10;\n  const tw = t === 0 ? 0 : (t \u003c= 3 ? 1 : 2) * z.c;\n  const uw = min(u, 3) * z.c;\n  return tw + uw + (t && u ? z.tu : 0) - (z.c - z.w - z.x0 > 0.5 ? 1 : 0);\n}\nfunction placeWedges(v, x, ym, z) {\n  const out = [];\n  const t = floor(v / 10), u = v % 10;\n  const cols = t === 0 ? [] : t \u003c= 3 ? [t] : t === 4 ? [2, 2] : [3, 2];\n  cols.forEach((n, c) => {\n    const top = round(ym - (n * z.r - 1) / 2);\n    for (let i = 0; i \u003c n; i++) out.push({ kind: 1, x: x + c * z.c, y: top + i * z.r });\n  });\n  const ux = x + cols.length * z.c + (t && u ? z.tu : 0);\n  const rows = ceil(u / 3), top = round(ym - (rows * z.r - 1) / 2);\n  for (let r = 0; r \u003c rows; r++) for (let i = 0; i \u003c min(3, u - 3 * r); i++) out.push({ kind: 0, x: ux + i * z.c, y: top + r * z.r });\n  return out;\n}\n// A number from its places, left edge x: the wedges, each tagged with its\n// place and its size.\nfunction numberWedges(digits, x, ym, z) {\n  const wedges = [];\n  digits.forEach((v, k) => {\n    for (const w of placeWedges(v, round(x), ym, z)) wedges.push(Object.assign(w, { place: k, z }));\n    x += placeWidth(v, z) + PLACE_GAP;\n  });\n  return wedges;\n}\nconst numberWidth = (digits, z) => digits.reduce((s, v) => s + placeWidth(v, z) + PLACE_GAP, -PLACE_GAP);\n\n// The soft tile of light under an agreeing place: its wedges' box, full\n// strength POOL inside and fading out over 1.5 LEDs.\nconst POOL = 0.6;\nfunction pool(wedges) {\n  let x0 = 99, y0 = 999, x1 = -99, y1 = -999;\n  for (const w of wedges) {\n    x0 = min(x0, w.x + w.z.x0);\n    x1 = max(x1, w.x + w.z.x0 + w.z.w);\n    y0 = min(y0, w.y);\n    y1 = max(y1, w.y + (w.kind ? 3 : w.z.r - 0.1));\n  }\n  const out = [];\n  for (let y = max(0, floor(y0) - 2); y \u003c min(H, ceil(y1) + 2); y++)\n    for (let x = max(0, floor(x0) - 2); x \u003c min(W, ceil(x1) + 2); x++) {\n      const dx = max(x0 - x - 0.5, x + 0.5 - x1, 0), dy = max(y0 - y - 0.5, y + 0.5 - y1, 0);\n      const v = POOL * smooth((1.5 - hypot(dx, dy)) / 1.5);\n      if (v > 0) out.push(y * W + x, v);\n    }\n  return Float32Array.from(out);\n}\nfunction places(wedges) {\n  const by = new Map();\n  for (const w of wedges) {\n    if (!by.has(w.place)) by.set(w.place, []);\n    by.get(w.place).push(w);\n  }\n  return by;\n}\n\nfunction makeItem(w) {\n  return { fp: w.kind ? corner(w.x, w.y, w.z) : upright(w.x, w.y, w.z), place: w.place, at: 0, glowAt: Infinity };\n}\n\n// ---- The tablet face, upper half: grooves of the square and its diagonals\n// in a static normal field, a ruled line under it, and its three numbers as\n// items that never fade.\nconst SQ = { cx: 32, cy: 33, r: 30.5 };\nfunction grooves(st, stD) {\n  const { cx, cy, r } = SQ;\n  const V = [[cx - r, cy], [cx, cy - r], [cx + r, cy], [cx, cy + r]];\n  const segs = [[V[0], V[1]], [V[1], V[2]], [V[2], V[3]], [V[3], V[0]], [V[0], V[2]], [V[1], V[3]], [[1, 67.5], [63, 67.5]]];\n  const hw = 0.95, dg = 0.55, s = dg / hw, nz = 1 / sqrt(1 + s * s), w = 1 / (SS * SS);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      for (let sy = 0; sy \u003c SS; sy++)\n        for (let sx = 0; sx \u003c SS; sx++) {\n          const px = x + (sx + 0.5) / SS, py = y + (sy + 0.5) / SS;\n          let bd = 9, ux = 0, uy = 0;\n          for (const [A, B] of segs) {\n            const dx = B[0] - A[0], dy = B[1] - A[1];\n            const t = cl(((px - A[0]) * dx + (py - A[1]) * dy) / (dx * dx + dy * dy), 0, 1);\n            const qx = px - (A[0] + t * dx), qy = py - (A[1] + t * dy), d = hypot(qx, qy);\n            if (d \u003c bd) {\n              bd = d;\n              ux = d > 1e-6 ? qx / d : 0;\n              uy = d > 1e-6 ? qy / d : 0;\n            }\n          }\n          if (bd >= hw) continue;\n          // The groove's wall tilts towards its middle line.\n          st[p * 3] += -s * ux * nz * w;\n          st[p * 3 + 1] += -s * uy * nz * w;\n          st[p * 3 + 2] += (nz - 1) * w;\n          stD[p] += dg * (1 - bd / hw) * w;\n        }\n      // The clay is a low pillow, 1.5 degrees at the edges.\n      st[p * 3] += 0.026 * ((x + 0.5 - 32) / 32);\n      st[p * 3 + 1] += 0.026 * ((y + 0.5 - 64) / 64);\n    }\n}\n\n// The tablet's wedges, and the tiles of light under its 1;24,51,10.\nfunction tabletItems() {\n  const items = [], pools = [];\n  const { cx, cy } = SQ;\n  // 30 by the upper left side, 1;24,51,10 above the level diagonal, 42;25,35 below it.\n  const groups = [\n    { digits: [30], x: 26, ym: 16, tag: 0 },\n    { digits: [1, 24, 51, 10], x: cx - numberWidth([1, 24, 51, 10], SMALL) / 2, ym: cy - 6, tag: 1 },\n    { digits: [42, 25, 35], x: cx - numberWidth([42, 25, 35], SMALL) / 2, ym: cy + 7, tag: 2 },\n  ];\n  for (const g of groups) {\n    const wedges = numberWedges(g.digits, g.x, g.ym, SMALL);\n    for (const w of wedges) {\n      const it = makeItem(w);\n      it.tag = g.tag;\n      items.push(it);\n    }\n    if (g.tag === 1) for (const ws of places(wedges).values()) pools.push(pool(ws));\n  }\n  return { items, pools };\n}\n\n// ---- The worked lines, lower half.\nconst LINE_X = 2, LINE_W = 61, LOW_TOP = 69, LOW_BOT = 127;\n\n// The steps from a start, each cut to `keep` places after the point. A\n// line holds as many places as fit across the panel. The lines stop when\n// one holds five places and all agree with the root, or when a cut step\n// gives back the line before it.\nfunction plan(start, keep) {\n  let [p, q] = STARTS[start];\n  const lines = [];\n  let before = null;\n  for (let i = 0; i \u003c 6; i++) {\n    const d = sexagesimal(p, q, PLACES);\n    let n = 1;\n    while (n \u003c d.length && numberWidth(d.slice(0, n + 1), LARGE) \u003c= LINE_W) n++;\n    while (n > 1 && d[n - 1] === 0) n--;\n    const shown = d.slice(0, n);\n    let agree = 0;\n    while (agree \u003c n && shown[agree] === ROOT[agree]) agree++;\n    lines.push({ shown, agree });\n    const same = before && before[0] === p && before[1] === q;\n    if ((agree === n && n >= 5) || same) break;\n    before = [p, q];\n    [p, q] = [p * p + 2n * q * q, 2n * p * q];\n    if (keep \u003c Infinity) {\n      const unit = 60n ** BigInt(keep);\n      [p, q] = [(p * unit) / q, unit];\n    }\n    const g = gcd(p, q);\n    p /= g;\n    q /= g;\n  }\n  const pitch = min(14, floor((LOW_BOT - LOW_TOP) / lines.length));\n  const top = LOW_TOP + (LOW_BOT - LOW_TOP - pitch * lines.length) / 2;\n  const items = [], pools = [];\n  let t = 0.3, sync = Infinity;\n  lines.forEach((L, i) => {\n    const ym = top + pitch * (i + 0.5);\n    const wedges = numberWedges(L.shown, LINE_X, ym, LARGE), byPlace = places(wedges);\n    let last = -1;\n    for (const w of wedges) {\n      if (w.place !== last && last >= 0) t += T_PLACE;\n      last = w.place;\n      const it = makeItem(w);\n      it.at = t;\n      it.line = i;\n      it.agree = w.place \u003c L.agree;\n      items.push(it);\n      t += T_WEDGE;\n    }\n    t += T_PAUSE;\n    for (let k = 0; k \u003c L.agree; k++) {\n      for (const it of items) if (it.line === i && it.place === k) it.glowAt = t;\n      pools.push({ fp: pool(byPlace.get(k)), glowAt: t });\n      if (k === 3 && sync === Infinity) sync = t;\n      t += T_CHECK;\n    }\n    t += T_AFTER;\n  });\n  return { items, pools, end: t + T_HOLD, sync };\n}\n\nexport function setup(params) {\n  const st = new Float32Array(N * 3), stD = new Float32Array(N);\n  grooves(st, stD);\n  params.s = {\n    t: 0, clock: 0, start: -1, keep: -1, lampA: 0,\n    st, stD,\n    dn: new Float32Array(N * 3), dD: new Float32Array(N), glow: new Float32Array(N),\n    plan: null,\n  };\n  const T = tabletItems();\n  params.s.tablet = T.items;\n  params.s.tabletPools = T.pools;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.lampA = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const start = cl(round(k[2] || 0), 0, STARTS.length - 1);\n  const keep = KEEP[cl(round(4 * (k[3] == null ? 0.06 : k[3])), 0, 4)];\n  // A new start, or a new cut, opens on its lines already written, 3.2\n  // model seconds before the clay is smoothed and they are written again.\n  if (start !== S.start || keep !== S.keep) {\n    S.start = start;\n    S.keep = keep;\n    S.plan = plan(start, keep);\n    S.t = S.plan.end - 3.2;\n  }\n  S.t += (d * speed) / 2;\n  S.clock += (d * speed) / 2;\n  if (S.t > S.plan.end + T_SMOOTH + T_REST) S.t = 0;\n}\n\nfunction light(S, fp, g) {\n  const gl = S.glow;\n  for (let i = 0; i \u003c fp.length; i += 2) gl[fp[i]] = max(gl[fp[i]], fp[i + 1] * g);\n}\n\nfunction stamp(S, it, scale, glow) {\n  const fp = it.fp, dn = S.dn, dD = S.dD, gl = S.glow;\n  for (let i = 0; i \u003c fp.length; i += 7) {\n    const p = fp[i];\n    dn[p * 3] += fp[i + 1] * scale;\n    dn[p * 3 + 1] += fp[i + 2] * scale;\n    dn[p * 3 + 2] += fp[i + 3] * scale;\n    dD[p] += fp[i + 5] * scale;\n    if (glow > 0) gl[p] = max(gl[p], fp[i + 6] * glow);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.plan) return;\n  const P = S.plan, t = S.t;\n  S.dn.fill(0);\n  S.dD.fill(0);\n  S.glow.fill(0);\n  const fade = 1 - smooth((t - P.end) / T_SMOOTH);\n  const sync = smooth((t - P.sync) / 0.4) * fade;\n  for (const it of S.tablet) stamp(S, it, 1, it.tag === 1 ? sync : 0);\n  if (sync > 0) for (const fp of S.tabletPools) light(S, fp, sync);\n  for (const pl of P.pools) if (t >= pl.glowAt) light(S, pl.fp, smooth((t - pl.glowAt) / 0.25) * fade);\n  for (const it of P.items) {\n    if (t \u003c it.at) continue;\n    const press = smooth((t - it.at) / 0.06) * fade;\n    stamp(S, it, press, it.agree ? smooth((t - it.glowAt) / 0.25) * fade : 0);\n  }\n  // The lamp, its azimuth counted anticlockwise from the right with up as\n  // up: at Lamp 0 it stands on the left and a little above.\n  const az = PI - 0.35 + 2 * PI * S.lampA + SWAY * sin((2 * PI * S.clock) / SWAY_T);\n  const Lx = cos(EL) * cos(az), Ly = -cos(EL) * sin(az), Lz = sin(EL);\n  const st = S.st, stD = S.stD, dn = S.dn, dD = S.dD, gl = S.glow;\n  for (let p = 0; p \u003c N; p++) {\n    const nx = st[p * 3] + dn[p * 3], ny = st[p * 3 + 1] + dn[p * 3 + 1], nz = 1 + st[p * 3 + 2] + dn[p * 3 + 2];\n    const b = cl((nx * Lx + ny * Ly + nz * Lz) / Lz, 0, 2.2);\n    const sh = (AMB + (1 - AMB) * b) * (1 - OCC * cl(stD[p] + dD[p], 0, 1));\n    let r = CLAY[0] * sh, g = CLAY[1] * sh, bl = CLAY[2] * sh;\n    const gw = cl(gl[p], 0, 1) * 0.9;\n    if (gw > 0) {\n      const lit = 0.45 + 0.4 * min(1, sh);\n      r += (GLOW[0] * lit - r) * gw;\n      g += (GLOW[1] * lit - g) * gw;\n      bl += (GLOW[2] * lit - bl) * gw;\n    }\n    display.setPixel(p % W, floor(p / W), cl(round(r), 0, 255), cl(round(g), 0, 255), cl(round(bl), 0, 255));\n  }\n}\n","coupling-from-the-past":"// ===== Patternflow pattern =====\n// Title:   Coupling from the Past\n// Family:  noise\n// Idea:    Two Ising magnets, one started all up on the top half and one all down on the bottom, run forward from time -T to 0 on the same random numbers while the sites where they still disagree glow pink and dissolve; a run that ends with any left starts again from twice as far back, reusing the numbers for its last stretch, and once the two meet the picture at time 0 is an exact sample, which a check run from twice as far back again lands on LED for LED.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: coupling from the past (James Propp and David Wilson, 1996) on the Ising model (Wilhelm Lenz, 1920) with heat-bath updates, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beta=0.32..0.43, Field=-1..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. At 0 an up spin is pale ice blue, a down spin deep indigo and a site where the two chains disagree pink, bright on the top half and deeper on the bottom; at 0.25 they are lilac, purple and yellow, at 0.5 peach, indigo and green, at 0.75 pale green, teal and blue. The down spins keep to the deep arc from teal to purple, since a deep orange reads brown.\n// Knob 2: Speed. How fast a run goes from -T to 0. At 2 the first run, 8 sweeps, takes 0.45 s and each doubling 1.37 times longer, so 64 sweeps take 1.15 s and 1024 take 4 s; a sample holds 2 s and a failed run pauses 0.4 s. Every time goes as 2 / Speed.\n// Knob 3: Beta. The inverse temperature, in units of the coupling. At the opening 0.32 the chains meet after 35 to 60 sweeps, so the run from -64 is the first that works and a sample comes 4.4 s in, fine grain with small islands; at 0.36 they need 80 to 130 sweeps and at 0.4 about 200 to 370; at 0.43, just short of the critical 0.4407, they need 1000 to 2100, a sample takes 17 to 43 s and is a few big domains. Turning it starts a fresh run.\n// Knob 4: Field. An outside field, up to the right, of 0.6 k|k| in units of the coupling: 0.002 at the opening 0.06, too weak to see at Beta 0.32, though at 0.43 it acts on all 3968 spins at once and most samples come out more up than down. At 1 or -1 nine spins in ten or more point its way and the chains meet in 13 to 22 sweeps at any Beta. Turning it starts a fresh run.\n\n// The Ising model on a 64 by 62 torus: each site a spin +1 or -1, and each\n// pair of neighbours adds -1 to the energy if they agree and +1 if they do\n// not, with -h for every spin up and +h for every spin down. The heat-bath\n// update visits a site, sums its four neighbours s, and sets it up with\n// probability 1 / (1 + exp(-2 beta (s + h))) whatever it was before. One\n// sweep visits every site once in a fixed order.\n//\n// Coupling from the past (Propp and Wilson, 1996): feed the same uniform\n// random number u(t, x) to every chain, so a sweep is one fixed map from\n// configurations to configurations. The update is monotone: a chain that\n// is up wherever another is up stays so after the sweep. So the chain\n// started all up at time -T stays above every other start, and the chain\n// started all down below it. If those two agree everywhere at time 0, every\n// start agrees with them, and the state at 0 is the end of a chain that has\n// run since minus infinity: an exact sample of the Gibbs distribution, not\n// an approximation. If they do not, start again from -2T. The random\n// numbers for -T..0 must be the same as last time, or the sample is biased,\n// so u is a hash of (run seed, t, x) and is never stored.\n//\n// The top half is the chain from all up, the bottom the chain from all\n// down, each 64 by 62. Where they disagree the top one is always up and the\n// bottom one down, by monotonicity, and those sites take the disagreement\n// colour. Between the halves, framed by a dark row on each side, two rows\n// are the timeline from -T at the left to 0 at the right: lit in the\n// disagreement colour while the chains differ and in the up colour once\n// they have met, with a dark notch where each earlier run started, at -T/2,\n// -T/4 and on. After a sample the same seed runs once more from twice as\n// far back. That check run lands on the same sample: its chains are held\n// between the first run's two from -T on, so they have met by the time the\n// first run's did, the gold notch, and from there they replay its last\n// stretch sweep for sweep. When it lands on the stored sample LED for LED,\n// the whole timeline turns gold while it holds. A run that fails with 48\n// sites or fewer still apart rings each of them while it pauses.\n\nconst W = 64, LH = 62, N = W * LH, BOT = 66, LINE = 63;\nconst { floor, round, exp, pow, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Seconds at Speed 2: the first run, the growth of a run's length with each\n// doubling, the hold on a sample and the pause on a run that failed.\nconst T0 = 8, D0 = 0.45, GROW = 0.45, HOLD = 2, FAIL = 0.4, TMAX = 1 \u003c\u003c 16;\n\n// Neighbours on the torus. A sweep visits the sites in index order.\nconst NB = new Int32Array(N * 4);\nfor (let y = 0; y \u003c LH; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const i = y * W + x;\n    NB[i * 4] = y * W + ((x + 1) % W);\n    NB[i * 4 + 1] = y * W + ((x + W - 1) % W);\n    NB[i * 4 + 2] = ((y + 1) % LH) * W + x;\n    NB[i * 4 + 3] = ((y + LH - 1) % LH) * W + x;\n  }\n\n// Murmur3's finaliser, a bijection on 32 bits.\nfunction mix(h) {\n  h ^= h >>> 16;\n  h = Math.imul(h, 0x85ebca6b);\n  h ^= h >>> 13;\n  h = Math.imul(h, 0xc2b2ae35);\n  return (h ^ (h >>> 16)) >>> 0;\n}\n// u(seed, t, x): a key for the sweep at time t, mixed with the site. The\n// same three numbers give the same u in every run that passes through t.\nconst keyOf = (seed, t) => mix(seed ^ Math.imul(t, 0x9e3779b1));\nconst uOf = (key, i) => mix(key ^ Math.imul(i + 1, 0x27d4eb2f));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i].map((c) => round(c * 255));\n}\n\n// A run of length T at Speed 2 lasts D0 (T / T0)^GROW seconds.\nconst span = (T) => D0 * pow(T / T0, GROW);\n\nfunction fresh(S) {\n  S.run++;\n  S.seed = mix(S.base + Math.imul(S.run, 0x632be5ab)) | 0;\n  S.T = T0;\n  S.check = false;\n  S.metFirst = null;\n  begin(S);\n}\n\n// Both chains to their extremes at time -T.\nfunction begin(S) {\n  S.up.fill(1);\n  S.dn.fill(-1);\n  S.t = -S.T;\n  S.dis = N;\n  S.met = null;\n  S.acc = 0;\n  S.phase = \"run\";\n  S.wait = 0;\n  S.same = false;\n}\n\n// One sweep from time t to t + 1 on both chains with the same u.\nfunction sweep(S) {\n  const a = S.up, b = S.dn, thr = S.thr, key = keyOf(S.seed, S.t), one = S.dis === 0;\n  for (let i = 0; i \u003c N; i++) {\n    const u = uOf(key, i), j = i * 4;\n    a[i] = u \u003c thr[a[NB[j]] + a[NB[j + 1]] + a[NB[j + 2]] + a[NB[j + 3]] + 4] ? 1 : -1;\n    if (!one) b[i] = u \u003c thr[b[NB[j]] + b[NB[j + 1]] + b[NB[j + 2]] + b[NB[j + 3]] + 4] ? 1 : -1;\n  }\n  S.t++;\n  if (one) b.set(a);\n  else {\n    let d = 0;\n    for (let i = 0; i \u003c N; i++) if (a[i] !== b[i]) d++;\n    S.dis = d;\n    if (!d) S.met = S.t;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    up: new Int8Array(N), dn: new Int8Array(N), thr: new Float64Array(9), sample: new Int8Array(N),\n    base: floor(Math.random() * 2147483647), run: 0, seed: 0, T: T0, t: -T0, dis: N, met: null, metFirst: null,\n    check: false, same: false, acc: 0, phase: \"run\", wait: 0, beta: -1, field: -9, hue: 0, speed: 2, flash: 0,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const beta = cl(k[2] || 0, 0.32, 0.43), k4 = cl(k[3] == null ? 0.06 : k[3], -1, 1), field = 0.6 * k4 * abs(k4);\n  if (abs(beta - S.beta) > 1e-4 || abs(field - S.field) > 1e-4) {\n    S.beta = beta;\n    S.field = field;\n    // Probability of up, as a 32-bit threshold, for each neighbour sum s.\n    for (let s = -4; s \u003c= 4; s++) S.thr[s + 4] = floor(4294967296 / (1 + exp(-2 * beta * (s + field))));\n    fresh(S);\n  }\n  const rate = S.speed / 2;\n  S.flash = max(0, S.flash - d * 2.5 * rate);\n  if (S.phase !== \"run\") {\n    S.wait -= d * rate;\n    if (S.wait > 0) return;\n    if (S.phase === \"fail\") {\n      S.T = min(TMAX, S.T * 2);\n      begin(S);\n    } else if (!S.check) {\n      // The same seed from twice as far back: the check run.\n      const met = S.met;\n      S.T *= 2;\n      begin(S);\n      S.check = true;\n      S.metFirst = met;\n    } else fresh(S);\n    return;\n  }\n  // Sweeps owed this frame; a long run gets more of them each second.\n  S.acc += (d * rate * S.T) / span(S.T);\n  let n = floor(S.acc);\n  S.acc -= n;\n  // Past 24 sweeps a frame the run would cost more than 2 ms a frame.\n  n = min(n, 24, -S.t);\n  for (let i = 0; i \u003c n; i++) sweep(S);\n  if (S.t >= 0) {\n    if (S.dis === 0) {\n      S.phase = \"hold\";\n      S.wait = HOLD;\n      S.flash = 1;\n      if (S.check) {\n        let same = true;\n        for (let i = 0; i \u003c N; i++) if (S.sample[i] !== S.up[i]) same = false;\n        S.same = same;\n      } else S.sample.set(S.up);\n    } else {\n      S.phase = \"fail\";\n      S.wait = FAIL;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // Up is a pale tint of the hue. Down stays in the deep cool arc from teal\n  // to violet as the hue goes round, since a deep orange or yellow reads\n  // brown on the panel; the disagreement takes the hue's far side.\n  const h = S.hue + 0.55;\n  const UP = hsv(h, 0.3, 0.88), DN = hsv(0.675 + 0.175 * Math.sin(2 * Math.PI * S.hue), 0.85, 0.45);\n  const XT = hsv(h + 0.37, 0.65, 1), XB = hsv(h + 0.37, 0.95, 0.8);\n  const a = S.up, b = S.dn, f = S.flash * 0.3;\n  const lift = (c) => [round(c[0] + (255 - c[0]) * f), round(c[1] + (255 - c[1]) * f), round(c[2] + (255 - c[2]) * f)];\n  const U = lift(UP), D = lift(DN);\n  for (let y = 0; y \u003c LH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, sa = a[i];\n      if (sa !== b[i]) {\n        display.setPixel(x, y, XT[0], XT[1], XT[2]);\n        display.setPixel(x, y + BOT, XB[0], XB[1], XB[2]);\n      } else {\n        const c = sa > 0 ? U : D;\n        display.setPixel(x, y, c[0], c[1], c[2]);\n        display.setPixel(x, y + BOT, c[0], c[1], c[2]);\n      }\n    }\n\n  // The rings round the sites a failed run left apart, pulsing twice.\n  if (S.phase === \"fail\" && S.dis \u003c= 48) {\n    const v = 0.5 + 0.5 * Math.cos((1 - S.wait / FAIL) * 4 * Math.PI);\n    for (let i = 0; i \u003c N; i++) {\n      if (a[i] === b[i]) continue;\n      const x0 = i % W, y0 = floor(i / W);\n      for (let k = -2; k \u003c= 2; k++)\n        for (const [dx, dy] of [[k, -2], [k, 2], [-2, k], [2, k]]) {\n          const x = (x0 + dx + W) % W, y = (y0 + dy + LH) % LH, j = y * W + x;\n          const ct = a[j] !== b[j] ? XT : a[j] > 0 ? U : D, cb = a[j] !== b[j] ? XB : a[j] > 0 ? U : D;\n          display.setPixel(x, y, round(ct[0] + (255 - ct[0]) * v), round(ct[1] + (255 - ct[1]) * v), round(ct[2] + (255 - ct[2]) * v));\n          display.setPixel(x, y + BOT, round(cb[0] + (255 - cb[0]) * v), round(cb[1] + (255 - cb[1]) * v), round(cb[2] + (255 - cb[2]) * v));\n        }\n    }\n  }\n\n  // The timeline, -T at the left edge and 0 at the right, between two dark\n  // rows. The x of time t is W (1 + t / T).\n  const T = S.T, X = (t) => min(W - 1, floor(W * (1 + t / T)));\n  const ahead = hsv(h, 0.45, 0.17), gold = hsv(h + 0.6, 0.75, 1), notch = [0, 0, 0];\n  const now = S.phase === \"run\" ? X(S.t) : W;\n  const met = S.met === null ? W : X(S.met);\n  for (let x = 0; x \u003c W; x++) {\n    let c = x >= now ? ahead : x \u003c met ? XB : UP;\n    if (S.same && S.phase === \"hold\") c = gold;\n    // Earlier runs started at -T/2, -T/4, ... down to -T0.\n    for (let q = T / 2; q >= T0; q /= 2) if (x === X(-q)) c = notch;\n    if (S.metFirst !== null && x === X(S.metFirst)) c = gold;\n    if (x === now) c = [255, 255, 255];\n    display.setPixel(x, LINE - 1, 0, 0, 0);\n    display.setPixel(x, LINE, c[0], c[1], c[2]);\n    display.setPixel(x, LINE + 1, c[0], c[1], c[2]);\n    display.setPixel(x, LINE + 2, 0, 0, 0);\n  }\n}\n","doyle-spiral":"// ===== Patternflow pattern =====\n// Title:   Doyle Spiral\n// Family:  cells\n// Idea:    A Doyle spiral, a packing of discs in which every disc touches six others and each is its neighbour turned and scaled by one of two fixed complex numbers, streams out of a dark pole in the middle of the tall panel and past its edges, every disc coloured by which of its 5 to 10 spiral arms it sits on, so the arms turn round the pole while the discs grow.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Doyle spirals, named for Peter Doyle (Alan F. Beardon, Tomasz Dubejko and Kenneth Stephenson, Spiral hexagonal circle packings in the plane, 1994); H. S. M. Coxeter's loxodromic sequences of tangent spheres (1968), whose plane case is the (2, 3) spiral; pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Arms=5..10, Poles=0..1\n//\n// Knob 1: Hue. Turns the arm colours round the wheel together. At 0 the five arms of the opening spiral are azure, violet, rose, gold and green, a fifth of the wheel apart; each disc is pale in the middle, fully coloured at its rim and lit from the side that faces the pole.\n// Knob 2: Speed. At 2 every disc takes 4.2 s to move out into the place of its neighbour along one family of arms, 1.41 times as far from the pole and 25 degrees further clockwise in the opening spiral, so the packing is the same again and only the colours have stepped on by one arm. 42 s at 0.2, 2.8 s at 3.\n// Knob 3: Arms. How many coloured arms, q - p of the pair (p, q): 5 is (8, 13), 6 (11, 17), 7 (12, 19), 8 (13, 21), 9 (14, 23), 10 (17, 27). The more arms, the smaller the discs: a disc 60 LEDs from the pole has a radius of 16.4 LEDs at 5 and 7.9 at 10, and between 4 and 6 LEDs from the pole 32% of the LEDs are lit at 5 and 4% at 10. Neighbouring arms are 1/5 of the wheel apart at 5, then 2/6, 2/7, 2/8, 2/9 and 3/10, so they stay apart.\n// Knob 4: Poles. A Moebius map brings the spiral's second pole, at infinity at 0, in from below. At the opening 0.06 it is 1006 rows under the first, which sits at row 62 and bends the packing only slightly; from 0.59 the second pole is on the panel, and at 1 the two stand at rows 34 and 94, the discs coming out of the upper one and spiralling into the lower.\n\n// Put the pole at 0 in the complex plane. A Doyle spiral has a disc\n// centred on A^m B^n for every pair of integers m, n, with radius r times\n// the distance of its centre from 0. Multiplying by A or by B maps the\n// packing onto itself, so if the disc at 1 touches the discs at A and B\n// and those two touch each other,\n//\n//   |1 - A| = r (1 + |A|),  |1 - B| = r (1 + |B|),  |A - B| = r (|A| + |B|),\n//\n// then every disc touches six: those at z A, z B, z B/A and back. The\n// packing closes on itself in the plane when A^p = B^q, and then the discs\n// lie on q arms one way, p arms the other and q - p arms the third. Write\n// A = a e^(it) and B = a^(p/q) e^(i(pt + 2 pi)/q), which makes A^p = B^q,\n// take r from the first equation and solve the other two for a and t with\n// Newton, the way Robin Houston's doyle-spiral code does. Newton starts\n// from the hexagonal lattice that log A and log B would make if the discs\n// were all one size.\n//\n// In log z every disc is the same shape, the log of the disc of radius r\n// round 1, moved to m log A + n log B. So one table over a single cell of\n// that lattice tells every LED which disc it is in and where in it. Disc\n// (m, n) and disc (m + p, n - q) are the same disc, and the arm a disc sits\n// on among the q - p is (m + n) mod (q - p). Moving every disc out by one\n// step of B is the packing again, so the motion runs on without a seam.\n//\n// The edges stay hard: every LED within 0.55 LED of a rim is off, so two\n// discs never light neighbouring LEDs, and inside a disc the brightest\n// channel changes by under 6 of 255 an LED, 7 only where rounding meets.\n// Hue and saturation change from LED to LED as much as they like, which is\n// what keeps the frame from packing small.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, atan2, log, exp, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// (p, q) for 5 to 10 coloured arms.\nconst PAIRS = [[8, 13], [11, 17], [12, 19], [13, 21], [14, 23], [17, 27]];\n// The table over one lattice cell is L by L.\nconst L = 192;\n// LEDs kept dark inside every rim.\nconst RIM = 0.55;\n\n// The two tangencies besides the first, as differences of r, and r.\nfunction tangency(a, t, p, q) {\n  const b = pow(a, p / q), s = (p * t + TAU) / q;\n  const ax = a * cos(t), ay = a * sin(t), bx = b * cos(s), by = b * sin(s);\n  const r = sqrt((1 - ax) ** 2 + ay * ay) / (1 + a);\n  return [sqrt((1 - bx) ** 2 + by * by) / (1 + b) - r, sqrt((ax - bx) ** 2 + (ay - by) ** 2) / (a + b) - r, r];\n}\n\nfunction solve(p, q) {\n  // log A has length 2 pi / |q e^(i pi/3) - p| in the lattice of equal discs.\n  const len = TAU / sqrt(p * p - p * q + q * q);\n  const th = PI / 2 - atan2(q * sin(PI / 3), q * cos(PI / 3) - p);\n  let a = exp(len * cos(th)), t = len * sin(th);\n  for (let it = 0; it \u003c 40; it++) {\n    const f = tangency(a, t, p, q), h = 1e-7, fa = tangency(a + h, t, p, q), ft = tangency(a, t + h, p, q);\n    const j00 = (fa[0] - f[0]) / h, j01 = (ft[0] - f[0]) / h, j10 = (fa[1] - f[1]) / h, j11 = (ft[1] - f[1]) / h;\n    const det = j00 * j11 - j01 * j10, da = (j11 * f[0] - j01 * f[1]) / det, dt = (j00 * f[1] - j10 * f[0]) / det;\n    a -= da;\n    t -= dt;\n    if (da * da + dt * dt \u003c 1e-26) break;\n  }\n  // log A = ur + i ui, log B = vr + i vi.\n  return { p, q, ur: log(a), ui: t, vr: (log(a) * p) / q, vi: (p * t + TAU) / q, r: tangency(a, t, p, q)[2], code: null };\n}\n\n// For each point (al, be) of the cell, al log A + be log B in log z: which\n// corner's disc it is in (0..15 for m, n offsets -1..2), how far out in\n// that disc as a share of its radius, the disc's distance from the pole\n// over the point's, and the direction from the disc's centre, measured\n// from the line out of the pole.\nfunction build(P) {\n  const n = L * L;\n  P.code = new Uint8Array(n);\n  P.s = new Float32Array(n);\n  P.e = new Float32Array(n);\n  P.cs = new Float32Array(n);\n  P.sn = new Float32Array(n);\n  for (let j = 0; j \u003c L; j++)\n    for (let i = 0; i \u003c L; i++) {\n      const al = (i + 0.5) / L, be = (j + 0.5) / L, k = j * L + i;\n      let best = 1e9;\n      for (let dn = -1; dn \u003c= 2; dn++)\n        for (let dm = -1; dm \u003c= 2; dm++) {\n          const dr = (al - dm) * P.ur + (be - dn) * P.vr, di = (al - dm) * P.ui + (be - dn) * P.vi;\n          if (dr \u003c -2 || dr > 2) continue;\n          // z over the disc's centre is e^(dr + i di); the disc is |that - 1| \u003c r.\n          const ex = exp(dr), x = ex * cos(di) - 1, y = ex * sin(di), h = sqrt(x * x + y * y) || 1e-9, s = h / P.r;\n          if (s >= best) continue;\n          best = s;\n          P.code[k] = (dn + 1) * 4 + dm + 1;\n          P.e[k] = 1 / ex;\n          P.cs[k] = x / h;\n          P.sn[k] = y / h;\n        }\n      P.s[k] = best;\n    }\n}\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    pairs: PAIRS.map(([p, q]) => solve(p, q)), pi: -1, kappa: -1,\n    fa: new Int32Array(N), col: new Int32Array(N), B0: new Float32Array(N), G: new Float32Array(N),\n    tb: 0, on: 0, hue: 0, out: new Float32Array(N * 3),\n  };\n}\n\n// Per LED: where it falls in the lattice, and how many LEDs one unit of\n// relative distance is there. With poles P1 and P2 the map is\n// z = (w - P1)(P2 - P1) / (P2 - w), which is w - P1 when P2 is at infinity.\nfunction tables(S, P, kappa) {\n  const px = 32, p1 = 64 - 30 * kappa, p2 = kappa \u003c 1e-4 ? 0 : 64 + 30 * kappa + (64 * (1 - kappa)) / kappa;\n  const det = P.ur * P.vi - P.ui * P.vr;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, wx = x + 0.5 - px, wy = y + 0.5 - p1, d1 = sqrt(wx * wx + wy * wy) + 1e-6;\n      let lr = log(d1), th = atan2(wy, wx), g = d1;\n      if (kappa >= 1e-4) {\n        const ex = px - x - 0.5, ey = p2 - y - 0.5, d2 = sqrt(ex * ex + ey * ey) + 1e-6, D = p2 - p1;\n        lr += log(D / d2);\n        th += PI / 2 - atan2(ey, ex);\n        g = (d1 * d2) / D;\n      }\n      const a = (lr * P.vi - th * P.vr) / det, fa = floor(a);\n      S.fa[i] = fa;\n      S.col[i] = min(L - 1, floor((a - fa) * L));\n      S.B0[i] = (P.ur * th - P.ui * lr) / det;\n      S.G[i] = g;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const pi = round(cl(k[2] == null ? 5 : k[2], 5, 10)) - 5, kappa = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const P = S.pairs[pi];\n  if (!P.code) build(P);\n  if (pi !== S.pi || kappa !== S.kappa) {\n    S.pi = pi;\n    S.kappa = kappa;\n    tables(S, P, kappa);\n  }\n  // One step of B every 4.2 s at Speed 2. A whole step is the same\n  // packing with every disc one further along, so the count moves instead.\n  S.tb += d * speed * 0.12;\n  while (S.tb >= 1) {\n    S.tb -= 1;\n    S.on -= 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.pi \u003c 0) return;\n  const P = S.pairs[S.pi], out = S.out, arms = P.q - P.p, r = P.r;\n  // Neighbouring arms are this many steps of 1/arms apart on the wheel.\n  const stride = max(1, round(arms / 4)) / arms;\n  out.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const b = S.B0[i] - S.tb, fb = floor(b), li = min(L - 1, floor((b - fb) * L)) * L + S.col[i], s = P.s[li];\n    if (s >= 1) continue;\n    // The disc's radius in LEDs, and how far this LED is inside its rim.\n    const R = S.G[i] * P.e[li] * r, dd = R * (1 - s);\n    if (dd \u003c RIM) continue;\n    const c = P.code[li], m = S.fa[i] + (c & 3) - 1, n = fb + (c >> 2) - 1 + S.on;\n    const arm = (((m + n) % arms) + arms) % arms;\n    const lean = cl(R * s * P.cs[li], -12, 12);\n    const v = 0.9 - 0.017 * (7 - min(dd, 7)) - 0.006 * lean;\n    hsv(S.hue + 0.55 + arm * stride + 0.04 * s * P.sn[li], 0.35 + 0.6 * s, v, out, i * 3);\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(out[i * 3] * 255), round(out[i * 3 + 1] * 255), round(out[i * 3 + 2] * 255));\n}\n","kinematogram":"// ===== Patternflow pattern =====\n// Title:   Kinematogram\n// Family:  type\n// Idea:    The whole tall panel is random dots at one even density, and a word of large capitals stacked down it exists only as motion: the dots inside the letters drift up while the dots around them drift down, so any single frame is plain noise, and every few seconds the dots stop for a moment and the word is gone until they move again.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random-dot kinematogram, a region of random dots displaced against its surround (Oliver Braddick, A short-range process in apparent motion, Vision Research, 1974), with motion coherence, the share of dots that carry the signal (William Newsome and Edmond Paré, 1988); capitals drawn for this pattern, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Coherence=0..1\n//\n// Knob 1: Hue. Turns the three dot colours round the wheel together. At 0 they are pale teal, azure and pale gold; at 0.5 rose, amber and pale blue.\n// Knob 2: Speed. At 2 the dots drift 10 LEDs a second, live 1.2 s on average, and the motion runs 3.6 s and stops for 1 s; every time goes as 2 / Speed.\n// Knob 3: Word. 0 SEE, 1 MOVE, 2 NOW, 3 GO, 4 HIDE, 5 STOP, 6 LOOK, 7 FLY, stacked one letter above the next down the 128 rows: 56 rows a letter for GO, 37 for three letters and 28 for four.\n// Knob 4: Coherence. The share of dots that drift with their sheet; the rest each go their own way at the same speed. The share is the knob to the power 0.25: half at the opening 0.06, where the word still reads, 84% at 0.5, all at 1, and none at 0, where nothing tells the letters from the ground and the word is gone even while the dots move.\n\n// Braddick showed his observers two frames of random dots in which one\n// region of the second frame was the first frame's dots moved a little.\n// Each frame alone is noise; shown one after the other, the moved region\n// stands out as a shape. Here that runs on: two sheets of dots, each\n// covering the whole panel at the same density and wrapping round its\n// edges, one drifting up and one drifting down. The panel shows the up sheet\n// inside the letters and the down sheet everywhere else. A dot that drifts\n// out of a letter is no longer shown, and the up sheet's dots that were\n// hidden below the letter come in at its lower edge, so the density inside\n// and outside stays the same in every frame.\n//\n// Every dot lives a while and is born again at a random place, so no dot's\n// path runs long enough to trace a letter's outline in a still. Coherence\n// is the share of dots that drift with their sheet; each of the others\n// drifts at the same speed in a direction of its own. Which dots are which\n// is drawn once at birth, so the knob changes where the dots go but never\n// how many there are.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, cos, sin, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Dots in each sheet, drift in LEDs per second at Speed 2, mean life,\n// and the run and the stop of the motion, in seconds at Speed 2.\nconst DOTS = 1900, V = 10, LIFE = 1.2, RUN = 3.6, STOP = 1;\n\nconst WORDS = [\"SEE\", \"MOVE\", \"NOW\", \"GO\", \"HIDE\", \"STOP\", \"LOOK\", \"FLY\"];\n\n// Capitals as polylines on a grid 4 wide and 6 tall, y down.\nconst STROKES = {\n  S: \"4,1 3,0 1,0 0,1 0,2 1,3 3,3 4,4 4,5 3,6 1,6 0,5\",\n  E: \"4,0 0,0 0,6 4,6|0,3 3,3\",\n  M: \"0,6 0,0 2,3 4,0 4,6\",\n  O: \"1,0 3,0 4,1 4,5 3,6 1,6 0,5 0,1 1,0\",\n  V: \"0,0 2,6 4,0\",\n  N: \"0,6 0,0 4,6 4,0\",\n  W: \"0,0 1,6 2,2 3,6 4,0\",\n  G: \"4,1 3,0 1,0 0,1 0,5 1,6 3,6 4,5 4,3 2,3\",\n  H: \"0,0 0,6|4,0 4,6|0,3 4,3\",\n  I: \"2,0 2,6|1,0 3,0|1,6 3,6\",\n  D: \"0,0 0,6 2.4,6 4,4.4 4,1.6 2.4,0 0,0\",\n  T: \"0,0 4,0|2,0 2,6\",\n  P: \"0,6 0,0 3,0 4,1 4,2 3,3 0,3\",\n  L: \"0,0 0,6 4,6\",\n  K: \"0,0 0,6|4,0 0,4|1.5,3 4,6\",\n  F: \"4,0 0,0 0,6|0,3 3,3\",\n  Y: \"0,0 2,3 4,0|2,3 2,6\",\n};\n\n// The letters of a word as a mask over the panel, 1 inside a stroke.\nfunction maskOf(word, out) {\n  out.fill(0);\n  const n = word.length, ch = H / n;\n  const gap = n \u003c= 2 ? 8 : n === 3 ? 6 : 4, lh = ch - gap, lw = n \u003c= 2 ? 50 : 54, T = n \u003c= 2 ? 11 : n === 3 ? 9 : 7;\n  for (let k = 0; k \u003c n; k++) {\n    const x0 = (W - lw) / 2 + T / 2, y0 = k * ch + gap / 2 + T / 2, ux = (lw - T) / 4, uy = (lh - T) / 6;\n    const segs = [];\n    for (const line of STROKES[word[k]].split(\"|\")) {\n      const p = line.split(\" \").map((t) => t.split(\",\").map(Number)).map(([gx, gy]) => [x0 + gx * ux, y0 + gy * uy]);\n      for (let i = 1; i \u003c p.length; i++) segs.push([p[i - 1][0], p[i - 1][1], p[i][0], p[i][1]]);\n    }\n    const r2 = (T / 2) * (T / 2);\n    for (let y = max(0, floor(k * ch)); y \u003c min(H, floor((k + 1) * ch) + 1); y++)\n      for (let x = 0; x \u003c W; x++) {\n        const px = x + 0.5, py = y + 0.5;\n        for (const s of segs) {\n          const dx = s[2] - s[0], dy = s[3] - s[1], L2 = dx * dx + dy * dy || 1e-9;\n          const t = cl(((px - s[0]) * dx + (py - s[1]) * dy) / L2, 0, 1), ex = px - s[0] - t * dx, ey = py - s[1] - t * dy;\n          if (ex * ex + ey * ey \u003c= r2) {\n            out[y * W + x] = 1;\n            break;\n          }\n        }\n      }\n  }\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nfunction sheet() {\n  const s = {\n    x: new Float32Array(DOTS), y: new Float32Array(DOTS), age: new Float32Array(DOTS), life: new Float32Array(DOTS),\n    u: new Float32Array(DOTS), dx: new Float32Array(DOTS), dy: new Float32Array(DOTS), c: new Uint8Array(DOTS),\n  };\n  for (let i = 0; i \u003c DOTS; i++) {\n    born(s, i);\n    s.age[i] = Math.random() * s.life[i];\n  }\n  return s;\n}\n\nfunction born(s, i) {\n  s.x[i] = Math.random() * W;\n  s.y[i] = Math.random() * H;\n  s.age[i] = 0;\n  s.life[i] = LIFE * (0.4 + 1.2 * Math.random());\n  s.u[i] = Math.random();\n  const a = Math.random() * TAU;\n  s.dx[i] = cos(a);\n  s.dy[i] = sin(a);\n  s.c[i] = floor(Math.random() * 3);\n}\n\n// Move a sheet on by d seconds at Speed 2, its signal going (vx, vy).\nfunction drift(s, d, vx, vy, share) {\n  for (let i = 0; i \u003c DOTS; i++) {\n    if (s.age[i] >= s.life[i]) born(s, i);\n    let x = s.x[i], y = s.y[i];\n    if (s.u[i] \u003c share) {\n      x += vx * d;\n      y += vy * d;\n    } else {\n      x += s.dx[i] * V * d;\n      y += s.dy[i] * V * d;\n    }\n    s.x[i] = x - floor(x / W) * W;\n    s.y[i] = y - floor(y / H) * H;\n    s.age[i] += d;\n  }\n}\n\nexport function setup(params) {\n  params.s = { up: sheet(), down: sheet(), mask: new Uint8Array(N), ink: new Uint8Array(N), word: -1, clock: 0, share: 0.5, hue: 0 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const w = round(cl(k[2] || 0, 0, 7));\n  if (w !== S.word) {\n    S.word = w;\n    maskOf(WORDS[w], S.mask);\n  }\n  S.share = pow(cl(k[3] == null ? 0.06 : k[3], 0, 1), 0.25);\n  const step = (d * speed) / 2;\n  // The motion runs, then stops dead: nothing moves and nothing ages.\n  const was = S.clock % (RUN + STOP);\n  S.clock = (S.clock + step) % ((RUN + STOP) * 1000);\n  const run = min(step, max(0, RUN - was));\n  if (run > 0) {\n    drift(S.up, run, 0, -V, S.share);\n    drift(S.down, run, 0, V, S.share);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const ink = S.ink, mask = S.mask;\n  ink.fill(0);\n  // The down sheet shows outside the letters, the up sheet inside them.\n  for (const [s, inside] of [[S.down, 0], [S.up, 1]]) {\n    for (let i = 0; i \u003c DOTS; i++) {\n      const p = (floor(s.y[i]) % H) * W + (floor(s.x[i]) % W);\n      if (mask[p] === inside) ink[p] = s.c[i] + 1;\n    }\n  }\n  const pal = [[0, 0, 0], hsv(S.hue + 0.47, 0.5, 0.8), hsv(S.hue + 0.6, 0.6, 0.82), hsv(S.hue + 0.13, 0.4, 0.82)].map((c) => c.map((v) => round(v * 255)));\n  for (let i = 0; i \u003c N; i++) {\n    const c = pal[ink[i]];\n    display.setPixel(i % W, floor(i / W), c[0], c[1], c[2]);\n  }\n}\n","linotype":"// ===== Patternflow pattern =====\n// Title:   Linotype\n// Family:  type\n// Idea:    Brass matrices drop one at a time from a magazine of channels and ride a belt into the assembler, where the line builds up with a steel spaceband in every word space; the spacebands are driven up until the line fills the measure, metal is pumped against it, and the slug, its face the line in mirror image, drops onto a galley of earlier slugs while the matrices are lifted to the distributor bar and slide along it until each falls back into its own channel.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Linotype line-casting machine (Ottmar Mergenthaler, 1886), its magazine, assembler, spacebands, mould and distributor bar; the first verse of the Gospel of John in the King James Version (1611) and the Gettysburg Address (Abraham Lincoln, 1863); capitals drawn for this pattern, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Measure=0..1\n//\n// Knob 1: Hue. Turns the brass of the matrices and the magazine and the steel of the frame, the spacebands and the slugs round the wheel together. At 0 the matrices are gold and the steel blue-grey, at 0.25 green and mauve, at 0.5 blue and a warm grey, at 0.75 pink and green-grey. The molten metal stays a warm white.\n// Knob 2: Speed. At 2 a matrix reaches the assembler every 0.13 s, the next line's matrices already falling while the last one is justified, and a line of 13 goes from its first matrix to the mould in 2.6 s; the lift, 1 s, and the distributor run alongside the next line. Every time goes as 2 / Speed, ten times slower at 0.2 and one and a half times faster at 3.\n// Knob 3: Text. 0 the first verse of John, which at the opening measure justifies every line with word spaces of 5 to 10 LEDs; 1 the pangram pack my box with five dozen liquor jugs, whose first line comes in at 59 LEDs and barely needs its spacebands; 2 ETAOIN SHRDLU CMFWYP VBGKQJ, the first four columns of the keyboard's lowercase keys, which operators ran a finger down to fill out a line they meant to throw away, and which draws only on the 24 channels at the left; 3 the Gettysburg Address to all men are created equal. Turning it starts the machine over on the new text, the galley already holding slugs of its opening lines.\n// Knob 4: Measure. The width of the line and of the slug: 60 LEDs, 15 matrices of 4, up to 0.16, then 56, 52 to 0.83 and 48. At 48 the Gettysburg Address sets BROUGHT on a line of its own, which has no word space for a spaceband and is quadded left, and ETAOIN SHRDLU comes apart into four lines of one word.\n\n// The machine is drawn standing, top to bottom: the distributor bar with\n// its box at the right, the magazine of 29 channels, the belt, the\n// assembler with the spaceband box at its right end, the mould, and the\n// galley. Pressing a key lets one matrix out of the foot of its channel. It\n// falls onto the belt, rides it down to its end above the assembler and\n// drops in at the right, so the line grows to the left. A spaceband\n// is a long double wedge, thin at the top; when the line is full the\n// spacebands are driven up, their thick feet come into the line, and every\n// word space opens by the same amount until the line fills the measure.\n// The line drops to the mould, metal fills the mould behind it from left to\n// right, and the slug that comes out carries the whole line in relief. Its\n// face reads in mirror image, as type does: that is what the galley shows,\n// newest at the top, each slug pushing the earlier ones down. The\n// spacebands go back to their box; the matrices are lifted to the top,\n// passing behind the machine, fed one at a time from the right end of the\n// line onto the distributor bar, and slide left along it until they come\n// over their own channel and fall in. On the real bar a matrix falls where\n// the teeth in its V notch stop finding ribs to hang on; here it simply\n// falls at its channel.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Capitals 5 rows tall, drawn for this pattern; M and W are 5 wide, N 4.\nconst FONT = {\n  A: \".#.|#.#|###|#.#|#.#\", B: \"##.|#.#|##.|#.#|##.\", C: \".##|#..|#..|#..|.##\", D: \"##.|#.#|#.#|#.#|##.\",\n  E: \"###|#..|##.|#..|###\", F: \"###|#..|##.|#..|#..\", G: \".##|#..|#.#|#.#|.##\", H: \"#.#|#.#|###|#.#|#.#\",\n  I: \"###|.#.|.#.|.#.|###\", J: \"..#|..#|..#|#.#|.#.\", K: \"#.#|#.#|##.|#.#|#.#\", L: \"#..|#..|#..|#..|###\",\n  M: \"#...#|##.##|#.#.#|#...#|#...#\", N: \"#..#|##.#|#.##|#..#|#..#\", O: \".#.|#.#|#.#|#.#|.#.\",\n  P: \"##.|#.#|##.|#..|#..\", Q: \".#.|#.#|#.#|##.|.##\", R: \"##.|#.#|##.|#.#|#.#\", S: \".##|#..|.#.|..#|##.\",\n  T: \"###|.#.|.#.|.#.|.#.\", U: \"#.#|#.#|#.#|#.#|###\", V: \"#.#|#.#|#.#|#.#|.#.\", W: \"#...#|#...#|#.#.#|##.##|#...#\",\n  X: \"#.#|#.#|.#.|#.#|#.#\", Y: \"#.#|#.#|.#.|.#.|.#.\", Z: \"###|..#|.#.|#..|###\",\n  \".\": \".|.|.|.|#\", \",\": \"..|..|..|.#|#.\", \"-\": \"...|...|###|...|...\",\n};\nconst GL = {};\nfor (const c in FONT) {\n  const rows = FONT[c].split(\"|\");\n  GL[c] = { w: rows[0].length, px: rows.map((r) => [...r].map((q) => q === \"#\")) };\n}\n\n// The magazine's channels, left to right, in the order of the Linotype\n// keyboard's lowercase keys, etaoin shrdlu cmfwyp vbgkqj, then x and z, the\n// full point, the comma and the hyphen. Each starts with more matrices the\n// more often its letter comes in English, 18 for E down to 3 for Q, J, X and\n// Z, one LED of the channel for each.\nconst ORDER = \"ETAOINSHRDLUCMFWYPVBGKQJXZ.,-\";\nconst BASE = [18, 14, 13, 12, 11, 11, 10, 10, 10, 8, 8, 6, 6, 6, 6, 6, 5, 5, 4, 5, 5, 4, 3, 3, 3, 3, 6, 6, 5];\nconst CI = {};\nfor (let i = 0; i \u003c ORDER.length; i++) CI[ORDER[i]] = i;\nconst chX = (i) => 2 * i + 1;\n\n// Texts, with | where a word may be broken by a hyphen.\nconst TEXTS = [\n  \"IN THE BE|GIN|NING WAS THE WORD, AND THE WORD WAS WITH GOD, AND THE WORD WAS GOD.\",\n  \"PACK MY BOX WITH FIVE DOZ|EN LIQ|UOR JUGS.\",\n  \"ETAOIN SHRDLU CMFWYP VBGKQJ\",\n  \"FOUR SCORE AND SEV|EN YEARS AGO OUR FA|THERS BROUGHT FORTH ON THIS CON|TI|NENT, A NEW NA|TION, CON|CEIVED IN LIB|ER|TY, AND DED|I|CAT|ED TO THE PROP|O|SI|TION THAT ALL MEN ARE CRE|AT|ED E|QUAL.\",\n];\n\n// Geometry, rows from the top.\nconst BOXX = 59, BAR = 9, HANG = 10, MAG0 = 18, MAG1 = 35, ESC = 36;\nconst ENT = 61, LINE = 63, RAIL = 70, MOULD = 76, CAV = 83, GAL = 93, SLUG = 7;\nconst SLOPE = 0.22, GMIN = 1, RISE = 3, LIP = 8;\n// Machine seconds at Speed 2.\nconst DT = 0.13, G = 400, VB = 90, TSB = 0.2, TJ = 0.6, TD = 0.35, TP = 0.3, TH = 0.35, TL = 1.0;\nconst VF = 45, VBAR = 80, TCH = 0.12, TE = 0.3, COOL = 1.5, TAU = 0.05;\nconst MOLTEN = [1, 0.92, 0.62], HOT_B = [0.78, 0.72, 0.6], HOT_S = [0.5, 0.45, 0.38], HOT_F = [1, 0.97, 0.86];\n\nconst wOf = (s) => {\n  let w = 0;\n  for (const c of s) if (GL[c]) w += GL[c].w + 1;\n  return w;\n};\n\n// Line breaking over the whole text at once: a line may end at a word space\n// or at a | with a hyphen, and the breaks are the ones whose word spaces\n// come out nearest 5 LEDs, a hyphen costing as much as a space 4.5 LEDs off.\n// The last line costs nothing, and is quadded when the text ends a sentence.\nfunction breakLines(text, M) {\n  const fr = [];\n  for (const word of text.split(\" \")) {\n    const parts = word.split(\"|\");\n    parts.forEach((p, j) => fr.push({ s: p, end: j === parts.length - 1 }));\n  }\n  const n = fr.length, best = new Array(n + 1).fill(Infinity), from = new Array(n + 1).fill(-1);\n  best[0] = 0;\n  for (let a = 0; a \u003c n; a++) {\n    if (best[a] === Infinity) continue;\n    let w = 0, gaps = 0;\n    for (let b = a + 1; b \u003c= n; b++) {\n      const f = fr[b - 1];\n      w += wOf(f.s);\n      if (b - 1 > a && fr[b - 2].end) gaps++;\n      const hy = !f.end, width = w + gaps * GMIN + (hy ? wOf(\"-\") : 0);\n      if (width > M && b > a + 1) break;\n      let cost;\n      if (b === n) cost = 0;\n      else if (gaps === 0) cost = 4 * (M - width) * (M - width) + 400;\n      else {\n        const g = (M - width + gaps * GMIN) / gaps - 5;\n        cost = gaps * g * g + (hy ? 20 : 0);\n      }\n      if (best[a] + cost \u003c best[b]) {\n        best[b] = best[a] + cost;\n        from[b] = a;\n      }\n    }\n  }\n  const cuts = [];\n  for (let b = n; b > 0; b = from[b]) cuts.unshift([from[b], b]);\n  return cuts.map(([a, b], k) => {\n    const words = [];\n    let cur = \"\";\n    for (let i = a; i \u003c b; i++) {\n      cur += fr[i].s;\n      if (fr[i].end) {\n        words.push(cur);\n        cur = \"\";\n      }\n    }\n    if (cur) words.push(cur + \"-\");\n    return setLine(words, M, k === cuts.length - 1 && /\\.$/.test(text));\n  });\n}\n\n// A line's matrices and spacebands, and where each stands once the line is\n// justified to the measure: the spare width shared out between the word\n// spaces as evenly as whole LEDs allow. A line left unjustified, the last\n// of a sentence or a line of one word, is quadded left.\nfunction setLine(words, M, last) {\n  const items = [];\n  words.forEach((wd, k) => {\n    if (k) items.push({ sp: true, w: GMIN });\n    for (const c of wd) if (GL[c]) items.push({ ch: c, ci: CI[c], w: GL[c].w + 1 });\n  });\n  const gaps = words.length - 1, letters = items.reduce((s, it) => s + (it.sp ? 0 : it.w), 0);\n  const just = !last && gaps > 0, spare = M - letters;\n  let x = ENT - M, g = 0;\n  for (const it of items) {\n    it.fx = x;\n    if (it.sp) {\n      it.fw = just ? floor(((g + 1) * spare) / gaps) - floor((g * spare) / gaps) : GMIN;\n      g++;\n    } else it.fw = it.w;\n    x += it.fw;\n  }\n  return { items, just };\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The schedule of one line through the machine, all in absolute machine\n// time from its first matrix reaching the assembler at `start`.\nfunction schedule(S, n, start) {\n  const src = S.lines[n % S.lines.length];\n  const items = src.items.map((it, k) => {\n    const m = { ...it, a: start + k * DT };\n    if (it.sp) m.r = m.a - TSB;\n    else {\n      m.x0 = cl(chX(it.ci) - floor(it.w / 2), 0, ENT - it.w);\n      const yb = LINE - LIP - SLOPE * (ENT - it.w - m.x0);\n      m.tf = sqrt((2 * max(0, yb - ESC)) / G);\n      m.r = m.a - TAU - m.tf - (ENT - it.w - m.x0) / VB;\n    }\n    return m;\n  });\n  const L = { n, items, just: src.just, aEnd: items[items.length - 1].a };\n  L.j0 = L.aEnd + 0.08;\n  L.j1 = L.j0 + TJ;\n  L.d1 = L.j1 + TD;\n  L.p1 = L.d1 + TP;\n  L.l0 = L.p1 + TH;\n  L.l1 = L.l0 + TL;\n  L.end = L.l1;\n  for (const m of items) {\n    if (m.sp) continue;\n    m.tin = L.l1 + (BOXX - (m.fx + m.w)) / VF;\n    m.tout = m.tin + 0.08;\n    m.xc = max(0, chX(m.ci) - floor(m.w / 2));\n    m.tdrop = m.tout + max(0, BOXX - m.w - m.xc) / VBAR;\n    m.back = m.tdrop + TCH;\n    L.end = max(L.end, m.back);\n  }\n  return L;\n}\n\nfunction start(S) {\n  S.lines = breakLines(TEXTS[S.text], S.M);\n  S.active = [];\n  S.slugs = [];\n  // The machine opens as if it had been running: cold slugs of the text's\n  // opening lines in the galley, one line on the distributor bar, one at\n  // the mould and the next coming down into the assembler.\n  const nl = S.lines.length;\n  for (let n = 0; n \u003c 5; n++) S.slugs.push({ L: schedule(S, n % nl, -100 + n), tE: -100 + n, hot: -100 });\n  S.t = 0;\n  let t0 = -5.2;\n  for (let n = 5; n \u003c 8; n++) {\n    const L = schedule(S, n, t0);\n    S.active.push(L);\n    t0 = L.d1;\n  }\n  S.next = 8;\n  for (const L of S.active) if (L.l0 \u003c= 0) S.slugs.push({ L, tE: L.l0, hot: L.d1 });\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, text: 0, M: 60, key: \"\", buf: new Float32Array(N * 3), c: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const text = round(cl(k[2] || 0, 0, 3)), M = 60 - 4 * round(3 * cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  const key = text + \":\" + M;\n  if (key !== S.key) {\n    S.key = key;\n    S.text = text;\n    S.M = M;\n    start(S);\n  }\n  const t0 = S.t;\n  S.t += (d * speed) / 2;\n  // Keep the next line scheduled ahead; a slug joins the galley when ejected.\n  while (S.active[S.active.length - 1].d1 \u003c S.t + 3) {\n    const last = S.active[S.active.length - 1];\n    S.active.push(schedule(S, S.next++, last.d1));\n  }\n  for (const L of S.active) if (L.l0 > t0 && L.l0 \u003c= S.t) S.slugs.push({ L, tE: L.l0, hot: L.d1 });\n  S.active = S.active.filter((L) => L.end > S.t - 0.5);\n  while (S.slugs.length > 7) S.slugs.shift();\n}\n\n// Drawing into a float buffer, 0..1.\nfunction paint(S, x, y, c, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, b = S.buf;\n  if (a == null || a >= 1) {\n    b[p] = c[0];\n    b[p + 1] = c[1];\n    b[p + 2] = c[2];\n  } else {\n    b[p] += (c[0] - b[p]) * a;\n    b[p + 1] += (c[1] - b[p + 1]) * a;\n    b[p + 2] += (c[2] - b[p + 2]) * a;\n  }\n}\n\n// A matrix: a thin brass plate, its ears top and bottom, the letter between.\nfunction matrix(S, ch, x, y, a) {\n  const g = GL[ch], C = S.col;\n  x = round(x);\n  y = round(y);\n  for (let i = 0; i \u003c g.w; i++) {\n    paint(S, x + i, y, C.ear, a);\n    paint(S, x + i, y + 6, C.ear, a);\n    for (let r = 0; r \u003c 5; r++) paint(S, x + i, y + 1 + r, g.px[r][i] ? C.brass : C.plate, a);\n  }\n}\n\n// A spaceband: a long steel double wedge, a thin stem above the line and\n// its thick foot below it. `w` is its width across the line, `rise` how far\n// it has been driven up: the foot comes up into the line and pushes the\n// words apart.\nfunction band(S, x, y, w, rise) {\n  const C = S.col, top = round(y - 5 - rise), x0 = round(x);\n  for (let r = 0; r \u003c 15; r++) {\n    const ww = r \u003c 5 ? 1 : min(w, round(1 + ((r - 4) * (w - 1)) / 7)), Y = top + r, inLine = Y >= y && Y \u003c y + 7;\n    for (let i = 0; i \u003c ww; i++) paint(S, x0 + floor((w - ww) / 2) + i, Y, C.band, inLine ? 0.5 : 0.9);\n  }\n}\n\n// Where each matrix of a line stands across the assembler at time t:\n// packed against the entrance as they come, then spread to the measure.\nfunction across(L, t, out) {\n  const it = L.items, n = it.length;\n  let x = ENT;\n  for (let k = n - 1; k >= 0; k--) {\n    const u = cl((t - (it[k].a - 2 * TAU)) / TAU, 0, 1);\n    x -= it[k].w * u;\n    out[k] = x;\n  }\n  if (t > L.j0) {\n    const p = ease((t - L.j0) / (L.j1 - L.j0));\n    for (let k = 0; k \u003c n; k++) out[k] += (it[k].fx - out[k]) * p;\n  }\n  return out;\n}\n\n// A slug: one bar of type metal the width of the measure, its face the\n// line in relief and in mirror image. Fresh from the mould it is pale and\n// warm, and it cools to the grey of the galley.\nfunction slug(S, L, y, heat) {\n  const C = S.col, c = S.c, x0 = ENT - S.M, x1 = ENT - 1;\n  for (let r = 0; r \u003c SLUG; r++) {\n    const base = r === 0 || r === SLUG - 1 ? C.shoulder : C.body, hot = r === 0 || r === SLUG - 1 ? HOT_S : HOT_B;\n    for (let q = 0; q \u003c 3; q++) c[q] = base[q] + (hot[q] - base[q]) * heat;\n    for (let x = x0; x \u003c= x1; x++) paint(S, x, y + r, c);\n  }\n  for (let q = 0; q \u003c 3; q++) c[q] = C.face[q] + (HOT_F[q] - C.face[q]) * heat;\n  for (const m of L.items) {\n    if (m.sp) continue;\n    const g = GL[m.ch];\n    for (let i = 0; i \u003c g.w; i++) for (let r = 0; r \u003c 5; r++) if (g.px[r][i]) paint(S, x0 + x1 - (m.fx + i), y + 1 + r, c);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.active) return;\n  const t = S.t, b = S.buf, hue = S.hue;\n  b.fill(0);\n  S.col = {\n    brass: hsv(hue + 0.13, 0.55, 1, [0, 0, 0]),\n    ear: hsv(hue + 0.12, 0.6, 0.62, [0, 0, 0]),\n    plate: hsv(hue + 0.12, 0.6, 0.12, [0, 0, 0]),\n    fill: hsv(hue + 0.12, 0.6, 0.7, [0, 0, 0]),\n    steel: hsv(hue + 0.58, 0.25, 0.3, [0, 0, 0]),\n    band: hsv(hue + 0.58, 0.15, 0.85, [0, 0, 0]),\n    body: hsv(hue + 0.58, 0.1, 0.36, [0, 0, 0]),\n    shoulder: hsv(hue + 0.58, 0.12, 0.22, [0, 0, 0]),\n    face: hsv(hue + 0.58, 0.06, 0.9, [0, 0, 0]),\n  };\n  const C = S.col, pos = [];\n\n  // Lines lifted back to the top, behind everything, dim while they rise.\n  for (const L of S.active) {\n    if (t \u003c L.l0 || t > L.end) continue;\n    const y = t \u003c L.l1 ? MOULD + (1 - MOULD) * ease((t - L.l0) / TL) : 1, a = t \u003c L.l1 ? 0.5 : 1;\n    const shift = t > L.l1 ? VF * (t - L.l1) : 0;\n    for (const m of L.items) if (!m.sp && t \u003c m.tin) matrix(S, m.ch, m.fx + shift, y, a);\n  }\n\n  // The frame: distributor bar and box, magazine walls, belt, rail.\n  for (let x = 0; x \u003c BOXX; x++) paint(S, x, BAR, C.steel);\n  for (let y = 0; y \u003c= BAR; y++) for (let x = BOXX; x \u003c W; x++) paint(S, x, y, y === 0 || y === BAR || x === BOXX ? C.steel : [0, 0, 0]);\n  for (let i = 0; i \u003c= ORDER.length; i++) for (let y = MAG0; y \u003c= MAG1; y++) paint(S, 2 * i, y, C.steel);\n  for (let x = 0; x \u003c= ENT - 4; x++) paint(S, x, LINE - LIP + 7 - SLOPE * (ENT - 4 - x), C.steel, 0.8);\n  for (let x = ENT - S.M - 1; x \u003c= ENT; x++) paint(S, x, RAIL, C.steel);\n  for (let y = 44; y \u003c= 54; y++) for (let x = 61; x \u003c W; x++) paint(S, x, y, y === 44 || x === 61 ? C.steel : [0, 0, 0]);\n  // The mould's jaws, warm while the metal is in.\n  let glow = 0;\n  for (const L of S.active) if (t >= L.d1) glow = max(glow, t \u003c L.l0 ? 1 : exp(-(t - L.l0) / 0.4));\n  for (let y = CAV - 1; y \u003c= CAV + SLUG; y++)\n    for (const x of [ENT - S.M - 1, ENT]) {\n      paint(S, x, y, C.steel);\n      paint(S, x, y, MOLTEN, glow * 0.8);\n    }\n\n  // Magazine fills: each channel's matrices stacked from its escapement.\n  const count = BASE.slice();\n  for (const L of S.active)\n    for (const m of L.items) if (!m.sp && t >= m.r && t \u003c (m.back ?? 1e9)) count[m.ci]--;\n  for (let i = 0; i \u003c ORDER.length; i++)\n    for (let r = 0; r \u003c min(MAG1 - MAG0 + 1, max(0, count[i])); r++) paint(S, chX(i), MAG1 - r, r === count[i] - 1 ? C.brass : C.fill);\n\n  for (const L of S.active) {\n    across(L, t, pos);\n    const yLine = t \u003c L.j1 ? LINE : t \u003c L.d1 ? LINE + (MOULD - LINE) * ease((t - L.j1) / TD) : MOULD;\n    const rise = L.just ? RISE * ease((t - L.j0) / TJ) : 0;\n    for (let k = 0; k \u003c L.items.length; k++) {\n      const m = L.items[k];\n      if (t \u003c m.r) continue;\n      if (m.sp) {\n        if (t \u003c m.a) band(S, ENT - GMIN, 49 + (LINE - 49) * ((t - m.r) / TSB), GMIN, 0);\n        else if (t \u003c L.l0) {\n          const w = t \u003c L.j0 ? GMIN : GMIN + (m.fw - GMIN) * ease((t - L.j0) / TJ);\n          band(S, pos[k], yLine, round(w), rise);\n        } else if (t \u003c L.l0 + 0.4) band(S, pos[k] + 120 * (t - L.l0), yLine, m.fw, rise);\n        continue;\n      }\n      if (t \u003c m.a) {\n        // Falling from the escapement, riding the belt to its end above the\n        // entrance, then dropping into the line once the line has moved up.\n        const tf = t - m.r;\n        if (tf \u003c m.tf) matrix(S, m.ch, m.x0, ESC + 0.5 * G * tf * tf, 1);\n        else if (t \u003c m.a - TAU) {\n          const x = m.x0 + VB * (tf - m.tf);\n          matrix(S, m.ch, x, LINE - LIP - SLOPE * (ENT - m.w - x), 1);\n        } else {\n          const u = (t - (m.a - TAU)) / TAU;\n          matrix(S, m.ch, ENT - m.w, LINE - LIP * (1 - u * u), 1);\n        }\n      } else if (t \u003c L.l0) matrix(S, m.ch, pos[k], yLine, 1);\n      else if (t >= m.tout && t \u003c m.back) {\n        // Along the distributor bar to its channel, then down into it.\n        const x = max(m.xc, BOXX - m.w - VBAR * (t - m.tout));\n        const y = t \u003c m.tdrop ? HANG : HANG + (MAG0 - HANG) * ((t - m.tdrop) / TCH);\n        matrix(S, m.ch, x, y, 1);\n      }\n    }\n    // The cast: metal pumped into the mould behind the line, left to right.\n    if (t >= L.d1 && t \u003c L.l0) {\n      const x0 = ENT - S.M, f = (t - L.d1) / TP;\n      if (f \u003c 1) {\n        const xe = x0 + S.M * f;\n        for (let y = CAV; y \u003c CAV + SLUG; y++) for (let x = x0; x \u003c xe; x++) paint(S, x, y, MOLTEN);\n      } else slug(S, L, CAV, 1);\n    }\n  }\n\n  // The galley: the newest slug at the top, each pushing the earlier down.\n  const sl = S.slugs.filter((s) => s.tE \u003c= t);\n  for (let i = sl.length - 1; i >= 0; i--) {\n    let y = CAV + (GAL - CAV) * ease((t - sl[i].tE) / TE);\n    for (let j = i + 1; j \u003c sl.length; j++) y += SLUG * ease((t - sl[j].tE) / TE);\n    if (y \u003c H) slug(S, sl[i].L, y, exp(-max(0, t - sl[i].hot - TP) / COOL));\n  }\n\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), round(cl(b[p * 3], 0, 1) * 255), round(cl(b[p * 3 + 1], 0, 1) * 255), round(cl(b[p * 3 + 2], 0, 1) * 255));\n}\n","mamikon-theorem":"// ===== Patternflow pattern =====\n// Title:   Mamikon's Theorem\n// Family:  line\n// Idea:    In the top square a segment of fixed length runs round an oval, always tangent to it at one end, and the ring it sweeps fills in twelve colours by the segment's angle, while in the bottom square the same segment, carried to one fixed point, sweeps a disk in the same colours at the same moments, so that every wedge of the ring, fan-shaped where the oval turns sharply and a long thin sliver where it is flat, has the area of its slice of the disk, and the whole ring has the disk's area whatever the oval.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Mamikon's theorem on tangent sweeps and tangent clusters (Mamikon Mnatsakanian, 1959), pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Oval=0..3, Length=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 the twelve wedges run from teal, where the segment starts at the top of the oval, through azure and violet to pink; at 0.5 from red through gold to green. The oval's outline and the segment stay near white.\n// Knob 2: Speed. One turn of the segment takes 9 / Speed seconds: 4.5 s at the opening 2, 45 s at 0.2 and 3 s at 3. The ring fills in one turn, holds full for a fifth of a turn, drains in the next turn and stays empty for an eighth of one.\n// Knob 3: Oval. The curve, with the disk below left as it is: 0 an ellipse twice as wide as it is tall, 1 a triangle with rounded corners, 2 a square with rounded corners, 3 a thin stadium, and the shapes between are their Minkowski blends, so every setting is a convex oval. Round the triangle the ring is three fans, round the square a pinwheel of four quarter disks, round the stadium two half disks, and each has the area of the disk.\n// Knob 4: Length. The segment, 20 LEDs long at 0 and 16 to 25 across the range (20.3 at the opening 0.06); the disk's radius is the same length. The oval is scaled so that it and its ring fill the top square, so a longer segment means a smaller oval in a wider ring.\n\n// Let a segment of length L touch a curve at one end and point along the\n// curve's tangent. Run that end round a closed convex curve once: the\n// segment sweeps the ring between the curve and the path of its far end,\n// the tangent sweep. Now carry every one of those segments, unturned, so\n// that its touching end sits at one point: they fill a disk of radius L,\n// the tangent cluster. Mamikon's theorem says the two have the same area,\n// so the ring has area pi L^2 whatever the curve. A wedge of the ring made\n// while the tangent turns through d theta has area L^2 d theta / 2, the\n// same as the slice of the disk for that d theta: a point at distance t\n// along the tangent at angle theta covers t dt d theta in both. That is\n// why the colours here go by the tangent's angle, twelve wedges of 30\n// degrees, and the brightness by t / L. Where the curve is flat the\n// segment slides along itself and sweeps nothing, and the disk below\n// waits.\n//\n// The ovals are kept as support functions: h(theta) is how far the\n// tangent line with outward normal (cos theta, sin theta) is from the\n// centre, the touching point is h n + h' n', and the tangent direction is\n// n' = (-sin theta, cos theta). A point Q lies on that tangent line when\n// g(theta) = Q . n - h(theta) is 0, and g' = Q . n' - h' is exactly how far\n// Q is along the tangent from the touching point. So for each LED outside\n// the oval the forward tangent is the root where g goes from negative to\n// positive, found on 128 angles and polished by Newton's method, and g' at\n// that root is t. Blending two support functions linearly is a Minkowski\n// blend of the two shapes, and stays convex.\n//\n// The segment's clock runs partly by the tangent's angle and partly by arc\n// length, so it turns at the corners and slides along the sides instead\n// of jumping across them; the fill below keeps step because both halves\n// fill by the same angle.\n\nconst W = 64, H = 128, TOP = 64;\nconst { floor, min, max, round, sqrt, sin, cos, atan2, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst F = 256; // angles in the fine tables: the segment's run and the outline\nconst C = 2; // every C-th of them is searched for an LED's tangent\nconst M = F / C;\nconst TH0 = -PI / 2; // the run starts at the top, the segment pointing right\nconst WEDGES = 12;\nconst GHOST = 0.26;\nconst SLIDE = 0.45; // share of the segment's clock that goes by arc length\nconst BOX = 60;\nconst DX = 32, DY = 96; // the disk's centre\n// One cycle, in turns: fill, hold full, drain, hold empty.\nconst FILL = 1, FULL = 0.2, DRAIN = 1, EMPTY = 0.125, CYCLE = FILL + FULL + DRAIN + EMPTY;\n\nconst TRI = [[0, -1], [0.866, 0.5], [-0.866, 0.5]];\nconst SQR = [[-0.72, -0.72], [0.72, -0.72], [0.72, 0.72], [-0.72, 0.72]];\nconst SHAPES = [{ a: 1, b: 0.5 }, { v: TRI, r: 0.16 }, { v: SQR, r: 0.12 }, { v: [[-1, 0], [1, 0]], r: 0.14 }];\n\n// h and h' of one shape at the normal (c, s).\nfunction sup1(sh, c, s, o) {\n  if (sh.v) {\n    let best = -1e9, bi = 0;\n    for (let i = 0; i \u003c sh.v.length; i++) {\n      const d = sh.v[i][0] * c + sh.v[i][1] * s;\n      if (d > best) {\n        best = d;\n        bi = i;\n      }\n    }\n    o[0] = best + sh.r;\n    o[1] = sh.v[bi][1] * c - sh.v[bi][0] * s;\n  } else {\n    const h = sqrt(sh.a * sh.a * c * c + sh.b * sh.b * s * s);\n    o[0] = h;\n    o[1] = ((sh.b * sh.b - sh.a * sh.a) * s * c) / h;\n  }\n}\n\nconst ta = [0, 0], tb = [0, 0];\nfunction sup(S, c, s, o) {\n  sup1(SHAPES[S.si], c, s, ta);\n  sup1(SHAPES[S.si + 1], c, s, tb);\n  o[0] = (1 - S.sw) * ta[0] + S.sw * tb[0];\n  o[1] = (1 - S.sw) * ta[1] + S.sw * tb[1];\n}\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// An antialiased line of width w into a coverage buffer of the given width, max-blended.\nfunction line(buf, bw, bh, x0, y0, x1, y1, w, a) {\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-9, e = w / 2 + 0.5;\n  const ya = max(0, floor(min(y0, y1) - e)), yb = min(bh - 1, floor(max(y0, y1) + e));\n  const xa = max(0, floor(min(x0, x1) - e)), xb = min(bw - 1, floor(max(x0, x1) + e));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / L2, 0, 1);\n      const ex = px - t * dx, ey = py - t * dy, c = a * cl(e - sqrt(ex * ex + ey * ey), 0, 1);\n      const i = y * bw + x;\n      if (c > buf[i]) buf[i] = c;\n    }\n}\n\nfunction dot(buf, bw, bh, x0, y0, r, a) {\n  for (let y = max(0, floor(y0 - r - 1)); y \u003c= min(bh - 1, floor(y0 + r + 1)); y++)\n    for (let x = max(0, floor(x0 - r - 1)); x \u003c= min(bw - 1, floor(x0 + r + 1)); x++) {\n      const ex = x + 0.5 - x0, ey = y + 0.5 - y0, c = a * cl(r + 0.5 - sqrt(ex * ex + ey * ey), 0, 1), i = y * bw + x;\n      if (c > buf[i]) buf[i] = c;\n    }\n}\n\nexport function setup(params) {\n  const S = {\n    ph: 0, hue: 0, L: 20, oval: 0, key: \"\", hkey: \"\", si: 0, sw: 0, sig: 1, ox: 32, oy: 32,\n    cs: new Float32Array(F + 1), sn: new Float32Array(F + 1), hh: new Float32Array(F + 1),\n    px: new Float32Array(F + 1), py: new Float32Array(F + 1), m: new Float32Array(F + 1),\n    u: new Float32Array(W * H), t: new Float32Array(W * H), rim: new Float32Array(W * TOP),\n    col: new Float32Array(W * H * 3), out: new Float32Array(W * H * 3), seg: new Float32Array(W * H),\n    o: [0, 0],\n  };\n  for (let j = 0; j \u003c= F; j++) {\n    const th = TH0 + (TAU * j) / F;\n    S.cs[j] = cos(th);\n    S.sn[j] = sin(th);\n  }\n  params.s = S;\n}\n\nfunction extent(S, sig, L) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let j = 0; j \u003c F; j++) {\n    const ax = sig * S.px[j], ay = sig * S.py[j], bx = ax - L * S.sn[j], by = ay + L * S.cs[j];\n    x0 = min(x0, ax, bx);\n    x1 = max(x1, ax, bx);\n    y0 = min(y0, ay, by);\n    y1 = max(y1, ay, by);\n  }\n  S.bx = (x0 + x1) / 2;\n  S.by = (y0 + y1) / 2;\n  return max(x1 - x0, y1 - y0);\n}\n\n// Everything that depends on the oval and the length: the scale, the\n// segment's run, and for every LED its tangent angle and distance.\nfunction build(S) {\n  const L = S.L, o = S.o;\n  const v = cl(S.oval, 0, 3);\n  S.si = min(2, floor(v));\n  S.sw = v - S.si;\n  for (let j = 0; j \u003c= F; j++) {\n    const c = S.cs[j], s = S.sn[j];\n    sup(S, c, s, o);\n    S.hh[j] = o[0];\n    S.px[j] = o[0] * c - o[1] * s;\n    S.py[j] = o[0] * s + o[1] * c;\n  }\n  let lo = 0, hi = BOX;\n  for (let it = 0; it \u003c 24; it++) {\n    const mid = (lo + hi) / 2;\n    if (extent(S, mid, L) \u003c= BOX) lo = mid;\n    else hi = mid;\n  }\n  const sig = (S.sig = lo);\n  extent(S, sig, L);\n  S.ox = 32 - S.bx;\n  S.oy = 32 - S.by;\n  // The touching points in LEDs, and the segment's clock along them.\n  let per = 0;\n  for (let j = 0; j \u003c= F; j++) {\n    S.px[j] = sig * S.px[j] + S.ox;\n    S.py[j] = sig * S.py[j] + S.oy;\n    if (j) per += sqrt((S.px[j] - S.px[j - 1]) ** 2 + (S.py[j] - S.py[j - 1]) ** 2);\n  }\n  S.m[0] = 0;\n  for (let j = 1; j \u003c= F; j++) {\n    const ds = sqrt((S.px[j] - S.px[j - 1]) ** 2 + (S.py[j] - S.py[j - 1]) ** 2);\n    S.m[j] = S.m[j - 1] + (1 - SLIDE) / F + (SLIDE * ds) / (per || 1);\n  }\n  for (let j = 0; j \u003c= F; j++) S.m[j] /= S.m[F];\n\n  // The top square: each LED outside the oval, its forward tangent.\n  S.rim.fill(0);\n  for (let j = 0; j \u003c F; j++) line(S.rim, W, TOP, S.px[j], S.py[j], S.px[j + 1], S.py[j + 1], 1.1, 1);\n  for (let y = 0; y \u003c TOP; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, qx = x + 0.5 - S.ox, qy = y + 0.5 - S.oy;\n      S.u[p] = -1;\n      let jp = F - C, gp = qx * S.cs[jp] + qy * S.sn[jp] - sig * S.hh[jp], k = -1, g = 0;\n      for (let i = 0; i \u003c M; i++) {\n        const j = i * C;\n        g = qx * S.cs[j] + qy * S.sn[j] - sig * S.hh[j];\n        if (gp \u003c 0 && g >= 0) {\n          k = i;\n          break;\n        }\n        gp = g;\n      }\n      if (k \u003c 0) continue;\n      const a0 = TH0 + (TAU * (k - 1)) / M, a1 = a0 + TAU / M;\n      let th = a0 + ((TAU / M) * -gp) / (g - gp), t = 0;\n      for (let it = 0; it \u003c 3; it++) {\n        const c = cos(th), s = sin(th);\n        sup(S, c, s, o);\n        const gg = qx * c + qy * s - sig * o[0];\n        t = qy * c - qx * s - sig * o[1];\n        if (it === 2 || t \u003c 1e-4) break;\n        const tn = th - gg / t;\n        if (tn \u003c a0 || tn > a1) break;\n        th = tn;\n      }\n      if (t \u003c 0 || t > L + 1) continue;\n      let u = (th - TH0) / TAU;\n      u -= floor(u);\n      S.u[p] = u;\n      S.t[p] = t;\n    }\n  // The bottom square: the tangent cluster, a disk of radius L.\n  for (let y = TOP; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, dx = x + 0.5 - DX, dy = y + 0.5 - DY, d = sqrt(dx * dx + dy * dy);\n      S.u[p] = -1;\n      if (d > L + 1) continue;\n      let u = atan2(dy, dx) / TAU;\n      u -= floor(u);\n      S.u[p] = u;\n      S.t[p] = d;\n    }\n}\n\nfunction paint(S) {\n  const L = S.L;\n  for (let p = 0; p \u003c W * H; p++) {\n    const u = S.u[p];\n    if (u \u003c 0) {\n      S.col[p * 3] = S.col[p * 3 + 1] = S.col[p * 3 + 2] = 0;\n      continue;\n    }\n    const t = S.t[p], aa = cl(L - t + 0.5, 0, 1), tau = cl(t / L, 0, 1), wedge = floor(u * WEDGES);\n    hsv(S.hue + 0.48 + 0.42 * u, 0.8, (wedge & 1 ? 0.68 : 1) * (0.42 + 0.58 * tau) * aa, S.col, p * 3);\n  }\n}\n\n// Where the segment is at a fraction q of its clock: its angle as a\n// fraction of the turn, and its touching point.\nfunction at(S, q) {\n  let a = 0, b = F;\n  while (b - a > 1) {\n    const c = (a + b) >> 1;\n    if (S.m[c] \u003c= q) a = c;\n    else b = c;\n  }\n  const f = cl((q - S.m[a]) / (S.m[a + 1] - S.m[a] || 1), 0, 1);\n  S.phi = (a + f) / F;\n  S.qx = S.px[a] + (S.px[a + 1] - S.px[a]) * f;\n  S.qy = S.py[a] + (S.py[a + 1] - S.py[a]) * f;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.oval = cl(k[2] || 0, 0, 3);\n  S.L = 20 * pow(1.25, cl(k[3] == null ? 0.06 : k[3], -1, 1));\n  S.ph = (S.ph + (d * speed) / 9) % CYCLE;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.oval + \"|\" + S.L;\n  if (key !== S.key) {\n    S.key = key;\n    build(S);\n    S.hkey = \"\";\n  }\n  if (S.hkey !== key + \"|\" + S.hue) {\n    S.hkey = key + \"|\" + S.hue;\n    paint(S);\n  }\n  const ph = S.ph, L = S.L;\n  let mode;\n  if (ph \u003c FILL) {\n    mode = 0;\n    at(S, ph);\n  } else if (ph \u003c FILL + FULL) {\n    mode = 1;\n    at(S, 0);\n  } else if (ph \u003c FILL + FULL + DRAIN) {\n    mode = 2;\n    at(S, ph - FILL - FULL);\n  } else {\n    mode = 3;\n    at(S, 0);\n  }\n  const phi = S.phi, out = S.out, col = S.col;\n  for (let p = 0; p \u003c W * H; p++) {\n    const u = S.u[p];\n    let f = 0;\n    if (u >= 0) {\n      if (mode === 1) f = 1;\n      else if (mode === 3) f = GHOST;\n      else if (mode === 0) {\n        const lag = phi - u;\n        f = lag >= 0 ? 1 + (lag \u003c 0.04 ? 0.6 * (1 - lag / 0.04) : 0) : GHOST;\n      } else f = u \u003c phi ? GHOST : 1;\n    }\n    out[p * 3] = col[p * 3] * f;\n    out[p * 3 + 1] = col[p * 3 + 1] * f;\n    out[p * 3 + 2] = col[p * 3 + 2] * f;\n  }\n  // The oval's outline, pale over the ring.\n  for (let p = 0; p \u003c W * TOP; p++) {\n    const r = S.rim[p] * 0.9;\n    if (r \u003c= 0) continue;\n    out[p * 3] = max(out[p * 3], r * 0.86);\n    out[p * 3 + 1] = max(out[p * 3 + 1], r * 0.92);\n    out[p * 3 + 2] = max(out[p * 3 + 2], r);\n  }\n  // The segment, above at the oval and below at the disk's centre.\n  const th = TH0 + TAU * phi, tx = -sin(th), ty = cos(th), seg = S.seg;\n  seg.fill(0);\n  line(seg, W, H, S.qx, S.qy, S.qx + L * tx, S.qy + L * ty, 1.3, 1);\n  dot(seg, W, H, S.qx, S.qy, 1.4, 1);\n  line(seg, W, H, DX, DY, DX + L * tx, DY + L * ty, 1.3, 1);\n  dot(seg, W, H, DX, DY, 1.4, 1);\n  for (let p = 0; p \u003c W * H; p++) {\n    const a = seg[p];\n    if (a > 0) {\n      out[p * 3] += (1 - out[p * 3]) * a;\n      out[p * 3 + 1] += (1 - out[p * 3 + 1]) * a;\n      out[p * 3 + 2] += (1 - out[p * 3 + 2]) * a;\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(out[p * 3], 0, 1) * 255), round(cl(out[p * 3 + 1], 0, 1) * 255), round(cl(out[p * 3 + 2], 0, 1) * 255));\n}\n","menger-slices":"// ===== Patternflow pattern =====\n// Title:   Menger Slices\n// Family:  fractal\n// Idea:    A plane square to the long diagonal of a Menger sponge sweeps from corner to corner and back, every LED kept or cut by the base-3 digit test, so the section grows from a point into a triangle and a hexagon whose biggest hole turns from a triangle into a six-pointed star and on into a triangle the other way up, while below it the centre section holds the lace of stars still and every hole is coloured by the level that cut it.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Menger sponge (Karl Menger, 1926), cut across its long diagonal by the planes x + y + z = c, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=3..5, Zoom=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the kept sponge is pale cream, pinker near the corner the plane starts from and paler lime near the far one, and the holes run from dark teal for the first cut through blue, indigo and purple to magenta for the fifth. The holes skip orange and yellow, which read brown and olive when dark.\n// Knob 2: Speed. At 2 the plane takes 12 s from corner to corner and 24 s there and back, and first crosses the centre 5 s in; 120 s a way at 0.2 and 8 s at 3.\n// Knob 3: Depth. How many levels are cut, 3 to 5, the next level fading in as the knob turns between whole numbers. The upper view puts 43 LEDs on the cube's edge, so a third-level hole, a cube a 27th of the edge, is 1.6 LEDs; a fourth-level one is 0.53 LEDs and comes through as single LEDs in a moire, whole only in the lower view with Zoom turned up.\n// Knob 4: Zoom. The lower view. Up to 0.1 it is the whole centre section; past it the view magnifies about the section's right corner, the edge midpoint (1, 0, 1/2), up to 9 times at 1. At 0.55 it is 3 times and the lace comes back one level down, each hole in the next level's colour: the small cube at (2, 0, 1)/3 is cut through its own centre just as the whole cube is.\n\n// Karl Menger's sponge keeps a point of the unit cube when, at no place of\n// the base-3 expansions of its coordinates, two of the three digits are 1.\n// Each level cuts the cube into 27 and takes out the 7 whose position has\n// two or three 1s: the centre and the middle of each face. Every LED here\n// is that test, run on the point of the plane under it, level by level\n// until a level cuts it or the depth runs out.\n//\n// The planes x + y + z = c stand square to the diagonal from (0, 0, 0) to\n// (1, 1, 1). The section is a point at c = 0, a triangle up to c = 1, a\n// hexagon from 1 to 2, a triangle the other way up to 3. At c = 3/2 the\n// hole the first level cuts is a six-pointed star: the centre cube gives a\n// hexagon, and the three face cubes below the plane and the three above it\n// each add a triangle, all six the same size only there. Below 3/2 the\n// three from above shrink away and the hole becomes a triangle; further\n// down it opens into three lobes, the face cubes' own hexagons, and towards\n// the corner it is three small triangles. Above 3/2 the same happens the\n// other way up. The same holds inside every kept small cube the plane cuts\n// through its centre, which is why the centre section is a lace of stars.\n//\n// In the plane, u runs across the panel along (1, -1, 0) / sqrt 2 and w up\n// it along (-1, -1, 2) / sqrt 6, from where the diagonal pierces it.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, sqrt, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst R2 = sqrt(2), R6 = sqrt(6);\n\n// Upper view: rows 0..70, the moving section; row 71 the gauge; lower\n// view: rows 72..127, the centre section.\nconst TOP = 71, GAUGE = 71, SCALE_T = 43, SCALE_B = 44;\nconst CXT = 31.5, CYT = 35.5, CXB = 31.5, CYB = 99.5;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The level at which (x, y, z) is cut away, 0 if it is kept to depth K,\n// -1 outside the cube.\nfunction cut(x, y, z, K) {\n  if (x \u003c 0 || y \u003c 0 || z \u003c 0 || x >= 1 || y >= 1 || z >= 1) return -1;\n  for (let k = 1; k \u003c= K; k++) {\n    x *= 3; y *= 3; z *= 3;\n    const a = floor(x), b = floor(y), c = floor(z);\n    if ((a === 1 ? 1 : 0) + (b === 1 ? 1 : 0) + (c === 1 ? 1 : 0) >= 2) return k;\n    x -= a; y -= b; z -= c;\n  }\n  return 0;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, depth: 3, zoom: 0, hole: [], kept: [0, 0, 0], tmp: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.depth = cl(k[2] == null ? 3 : k[2], 3, 5);\n  S.zoom = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.t += (d * speed) / 2;\n}\n\n// Hole colours by level, dark for the first cut and a little lighter for\n// each finer one. Their hues go round a wheel with orange and yellow (0.03\n// to 0.2) cut out, since dark they read brown and olive on the panel.\nconst wheel = (h) => 0.2 + (h - floor(h)) * 0.83;\nfunction palette(S) {\n  for (let k = 1; k \u003c= 5; k++) S.hole[k] = hsv(wheel(S.hue + 0.36 + 0.13 * (k - 1)), 0.88, 0.3 + 0.05 * (k - 1), [0, 0, 0]);\n}\n\nfunction keptColour(S, c, w) {\n  return hsv(S.hue + 0.1 + 0.08 * (c - 1.5), 0.22 + 0.12 * w, 0.95, S.kept);\n}\n\nfunction put(display, x, y, c) {\n  display.setPixel(x, y, round(c[0]), round(c[1]), round(c[2]));\n}\n\n// One view: the plane x + y + z = cc, a point u across and w up from where\n// the diagonal pierces it, magnified m times about (vu, 0).\nfunction view(display, S, y0, y1, cx, cy, sc, cc, m, vu) {\n  const D = S.depth, K = ceil(D - 1e-6), f = D - (K - 1), b = cc / 3, mix = S.tmp;\n  for (let j = y0; j \u003c y1; j++) {\n    const w = (cy - j) / sc / m;\n    const kc = keptColour(S, cc, w);\n    for (let i = 0; i \u003c W; i++) {\n      const u = vu + ((i - cx) / sc - vu) / m;\n      const lev = cut(b + u / R2 - w / R6, b - u / R2 - w / R6, b + (2 * w) / R6, K);\n      if (lev \u003c 0) display.setPixel(i, j, 0, 0, 0);\n      else if (lev === 0) put(display, i, j, kc);\n      else if (lev \u003c K || f >= 1) put(display, i, j, S.hole[lev]);\n      else {\n        // The deepest level fades in as Depth turns past a whole number.\n        const h = S.hole[lev];\n        mix[0] = kc[0] + (h[0] - kc[0]) * f;\n        mix[1] = kc[1] + (h[1] - kc[1]) * f;\n        mix[2] = kc[2] + (h[2] - kc[2]) * f;\n        put(display, i, j, mix);\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  // The plane sweeps from corner to corner and back, 12 s a way at Speed 2,\n  // starting at c = 1/4.\n  const ph = (S.t / 12 + 1 / 12) % 2, c = 3 * (ph \u003c 1 ? ph : 2 - ph);\n  view(display, S, 0, TOP, CXT, CYT, SCALE_T, c, 1, 0);\n  // The gauge: the long diagonal from (0, 0, 0) at the left to (1, 1, 1)\n  // at the right, the plane a bright tick on it, the centre a dim one.\n  const tick = round((c / 3) * 62), g = hsv(S.hue + 0.1, 0.2, 0.22, [0, 0, 0]), hi = keptColour(S, c, 0);\n  for (let i = 0; i \u003c W; i++) put(display, i, GAUGE, i === tick || i === tick + 1 ? hi : i === 31 || i === 32 ? S.hole[3] : g);\n  const z = cl((S.zoom - 0.1) / 0.9, 0, 1);\n  view(display, S, GAUGE + 1, H, CXB, CYB, SCALE_B, 1.5, pow(9, z), 1 / R2);\n}\n","napier-bones":"// ===== Patternflow pattern =====\n// Title:   Napier's Bones\n// Family:  type\n// Idea:    Napier's multiplying rods fall down the tall panel one after another, the index rod and four rods headed by the digits of a number such as 1617, every square split by its diagonal into the tens and units of a product, and for each digit of the multiplier the row it names lights across the rods while the rest dim, the diagonals are added from right to left with each carry stepping over to the next, and the partial products and then their sum are written underneath before the rods fall away for the next problem.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Napier's bones (John Napier, Rabdologiæ, 1617), digits drawn for this pattern on a 3 by 5 grid, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Problem=0..5, Bands=0..1\n//\n// Knob 1: Hue. The colour of the rods. At 0 they are slate blue with pale digits, and the heads, the digits being added and the answer are gold; at 0.5 the rods are brown like boxwood and the gold turns blue, at 0.75 they are green and it turns pink.\n// Knob 2: Speed. At 2 each rod takes 0.45 s to fall, 0.12 s after the one before; each digit of the multiplier takes 2.1 s, 0.3 s to light its row, 0.32 s for each of the five diagonals and 0.2 s to rest; the rule takes 0.3 s and each column of the sum 0.26 s, and the answer stands 1.8 s before the rods fall out in 0.6 s. 1617 x 67 takes 9.5 s, 1089 x 9 takes 5.5 s and 1550 x 128 takes 11.6 s. Every time goes as 2 / Speed.\n// Knob 3: Problem. 0 is 1617 x 67, the year of Rabdologiæ by the 67 years since Napier's birth in 1550; 1 is 1550 x 128, that year by the panel's height; 2 is 1089 x 9 = 9801 and 3 is 2178 x 4 = 8712, the only four-digit numbers that a multiple turns back to front; 4 is 3367 x 33 = 111111 and 5 is 2439 x 41 = 99999. Each problem is followed by the next, and turning the knob starts the one it points at from the top.\n// Knob 4: Bands. Gives each diagonal of the lattice a hue of its own, on the wood and on the digits: the units half of a rod and the tens half of the rod to its right, the two that are added together, share one. Nothing at 0, too faint to see at the opening 0.06, and at 1 five hues a tenth of the wheel apart, so the diagonals read as stripes down all nine rows.\n\n// Each rod is headed by a digit d, and its k-th square holds k times d, the\n// tens above the diagonal and the units below it. Lay the index rod and the\n// rods for 1617 side by side and row 7 reads 0/7 4/2 0/7 4/9: 7 x 1, 7 x 6,\n// 7 x 1, 7 x 7. The units of one rod and the tens of the rod to its right\n// lie between the same two diagonals and count the same power of ten, so\n// adding along the diagonals from the right, carrying as you go, gives\n// 9, 7 + 4 = 11, 2 + 0 + 1 = 3, 7 + 4 = 11 and 0 + 1 = 1: 1617 x 7 = 11319,\n// with no multiplying done. A multiplier of more digits reads one row for\n// each digit, from its last, and the partial products are added each one\n// place to the left of the one before.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// 3 by 5 digits, five rows of three bits, the left LED the high bit.\nconst DIGIT = [\"75557\", \"26227\", \"71747\", \"71717\", \"55711\", \"74717\", \"74757\", \"71122\", \"75757\", \"75717\"].map((s) => s.split(\"\").map(Number));\nconst TIMES = [5, 2, 5];\n\n// Multiplicand and multiplier.\nconst PROBLEMS = [\n  [\"1617\", \"67\"],\n  [\"1550\", \"128\"],\n  [\"1089\", \"9\"],\n  [\"2178\", \"4\"],\n  [\"3367\", \"33\"],\n  [\"2439\", \"41\"],\n];\n\n// Rods: the index rod 8 LEDs wide, then four rods 13 wide, one dark LED\n// between. Each is 101 rows: a head, nine squares of 10 rows, edges.\nconst X0 = [0, 9, 23, 37, 51], RW = [8, 13, 13, 13, 13];\n// The diagonal of a square, from its lower left corner to its upper right:\n// the row it crosses in each column 1..11.\nconst DIAG = [0, 9, 8, 7, 7, 6, 5, 4, 3, 3, 2, 1];\nconst ROWS = 101, WORK = 102;\n\n// Seconds at Speed 2.\nconst DROP = 0.45, STAG = 0.12, T1 = 1.0, LIGHT = 0.3, BAND = 0.32, REST = 0.2, ROW = LIGHT + 5 * BAND + REST;\nconst RULE = 0.3, COL = 0.26, HOLD = 1.8, FALL = 0.6;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\nconst mix = (a, b, u) => [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, a[2] + (b[2] - a[2]) * u];\n\n// The reading of one problem: for each multiplier digit, right to left,\n// the five diagonals of its row with the carry each takes in and the digit\n// it leaves; then the columns of the partial products added the same way.\nfunction plan(a, b) {\n  const A = a.split(\"\").map(Number), M = b.split(\"\").map(Number).reverse();\n  const parts = M.map((k) => {\n    const bands = [];\n    let carry = 0;\n    for (let j = 0; j \u003c 5; j++) {\n      // Diagonal j: the units of the rod for 10^j and the tens of the rod for 10^(j-1).\n      const u = j \u003c= 3 ? (k * A[3 - j]) % 10 : 0, t = j >= 1 ? floor((k * A[4 - j]) / 10) : 0, s = u + t + carry;\n      bands.push({ cin: carry, d: s % 10 });\n      carry = floor(s / 10);\n    }\n    let len = 5;\n    while (len > 1 && bands[len - 1].d === 0) len--;\n    return { k, bands, len };\n  });\n  const total = String(Number(a) * Number(b)), cols = [];\n  let carry = 0;\n  for (let e = 0; e \u003c total.length; e++) {\n    let s = carry;\n    parts.forEach((p, i) => {\n      const j = e - i;\n      if (j >= 0 && j \u003c p.len) s += p.bands[j].d;\n    });\n    cols.push({ cin: carry, d: s % 10 });\n    carry = floor(s / 10);\n  }\n  const n = parts.length, sum = n > 1 ? T1 + n * ROW : 0, end = n > 1 ? sum + RULE + cols.length * COL : T1 + ROW;\n  return { A, parts, cols, n, sum, end, length: end + HOLD + FALL };\n}\n\nexport function setup(params) {\n  params.s = { buf: new Float32Array(N * 3), tau: 0, pi: 0, P: plan(...PROBLEMS[0]), knob: -1, hue: 0, bands: 0.06 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.bands = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3), kp = round(cl(k[2] || 0, 0, PROBLEMS.length - 1));\n  if (kp !== S.knob) {\n    S.knob = kp;\n    S.pi = kp;\n    S.P = plan(...PROBLEMS[kp]);\n    S.tau = 0;\n  }\n  S.tau += (d * speed) / 2;\n  if (S.tau >= S.P.length) {\n    S.tau -= S.P.length;\n    S.pi = (S.pi + 1) % PROBLEMS.length;\n    S.P = plan(...PROBLEMS[S.pi]);\n  }\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  if (a >= 1) {\n    buf[p] = c[0];\n    buf[p + 1] = c[1];\n    buf[p + 2] = c[2];\n  } else {\n    buf[p] += (c[0] - buf[p]) * a;\n    buf[p + 1] += (c[1] - buf[p + 1]) * a;\n    buf[p + 2] += (c[2] - buf[p + 2]) * a;\n  }\n}\n\nfunction glyph(buf, g, x, y, c, a) {\n  for (let r = 0; r \u003c g.length; r++) for (let i = 0; i \u003c 3; i++) if ((g[r] >> (2 - i)) & 1) put(buf, x + i, y + r, c, a);\n}\n\nconst scale = (c, f) => [c[0] * f, c[1] * f, c[2] * f];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, P = S.P, tau = S.tau, h = S.hue + 0.58, acc = h + 0.55;\n  buf.fill(0);\n  const C = {\n    body: hsv(h, 0.5, 0.17), edge: hsv(h, 0.4, 0.38), line: hsv(h, 0.35, 0.3), dig: hsv(h, 0.12, 0.78),\n    head: hsv(acc, 0.55, 1), lit: hsv(h, 0.45, 0.45), white: [1, 1, 1], fill: hsv(acc, 0.65, 0.3), gold: hsv(acc, 0.5, 1),\n    done: hsv(acc, 0.25, 0.9), pale: hsv(h, 0.15, 0.92), rule: hsv(h, 0.3, 0.55), sum: hsv(acc, 0.6, 1),\n  };\n  // Bands: each diagonal of the lattice in a hue of its own, on the wood\n  // and on its digits.\n  const tint = [0, 1, 2, 3, 4].map((b) => mix(C.body, hsv(acc + 0.1 * b, 0.75, 0.5), S.bands));\n  const ink = [0, 1, 2, 3, 4].map((b) => mix(C.dig, hsv(acc + 0.1 * b, 0.6, 0.95), S.bands));\n\n  // Which row is lit and which diagonal is being added. While\n  // a row is read the others dim, and so do all of them while the partial\n  // products are added.\n  let row = -1, light = 0, part = -1, band = -1;\n  for (let i = 0; i \u003c P.n; i++) {\n    const r0 = T1 + i * ROW;\n    if (tau >= r0 && tau \u003c r0 + ROW + 0.15) {\n      row = P.parts[i].k;\n      part = i;\n      light = smooth((tau - r0) / LIGHT) * (1 - smooth((tau - r0 - ROW + REST) / (REST + 0.15)));\n      band = tau - r0 \u003c LIGHT ? -1 : floor((tau - r0 - LIGHT) / BAND);\n    }\n  }\n  const out = P.length - FALL;\n  const adding = P.n > 1 ? smooth((tau - P.sum) / RULE) * (1 - smooth((tau - P.end) / 0.4)) : 0;\n  const dim = 1 - 0.45 * max(light, adding);\n\n  for (let r = 0; r \u003c 5; r++) {\n    // Each rod falls in from above, one after another, and falls out below.\n    const uin = cl((tau - STAG * r) / DROP, 0, 1), uout = cl((tau - out - STAG * r * 0.25) / (FALL * 0.8), 0, 1);\n    if (uin \u003c= 0 || uout >= 1) continue;\n    const oy = round(-(ROWS + 2) * (1 - uin * uin) + (H + 2) * uout * uout);\n    const x0 = X0[r], w = RW[r], dgt = r ? P.A[r - 1] : 0, place = 4 - r;\n    for (let sq = 0; sq \u003c= 10; sq++) {\n      const lit = sq === row ? light : 0, f = sq === row ? 1 : dim;\n      // The two halves of a square: units at this rod's place, tens one up.\n      let cu = r && sq ? tint[place] : C.body, ct = r && sq ? tint[min(4, place + 1)] : C.body;\n      cu = mix(scale(cu, f), C.lit, lit);\n      ct = mix(scale(ct, f), C.lit, lit);\n      if (lit && band === place) cu = mix(cu, C.fill, lit);\n      if (lit && band === place + 1) ct = mix(ct, C.fill, lit);\n      const ln = mix(scale(C.line, f), C.edge, lit), ed = scale(C.edge, sq ? f : 1);\n      for (let ly = 0; ly \u003c 10; ly++) {\n        const ry = sq * 10 + ly, y = ry + oy;\n        if (ry >= ROWS) break;\n        if (y \u003c 0 || y >= H) continue;\n        for (let lx = 0, p = (y * W + x0) * 3; lx \u003c w; lx++, p += 3) {\n          let c;\n          if (lx === 0 || lx === w - 1 || ry === 0 || ry === 100) c = ed;\n          else if (ly === 0 || (r && sq && ly === DIAG[lx])) c = ln;\n          else c = r && sq && ly \u003c DIAG[lx] ? ct : cu;\n          buf[p] = c[0];\n          buf[p + 1] = c[1];\n          buf[p + 2] = c[2];\n        }\n      }\n    }\n    // The digits: the head's at row 3, the squares' from their row 1. A\n    // tens digit of 0 is drawn half as bright.\n    if (r) glyph(buf, DIGIT[dgt], x0 + 5, oy + 3, C.head, 1);\n    else glyph(buf, TIMES, x0 + 2, oy + 4, C.head, 1);\n    for (let sq = 1; sq \u003c= 9; sq++) {\n      const y = sq * 10 + oy + 1, lit = sq === row ? light : 0, f = sq === row ? 1 : dim;\n      if (!r) {\n        glyph(buf, DIGIT[sq], x0 + 2, y + 2, mix(scale(C.dig, f), C.gold, lit), 1);\n        continue;\n      }\n      const v = sq * dgt, t = floor(v / 10), u = v % 10;\n      const tc = band === place + 1 ? C.gold : band > place + 1 ? C.done : C.white;\n      const uc = band === place ? C.gold : band > place ? C.done : C.white;\n      glyph(buf, DIGIT[t], x0 + 2, y, mix(scale(ink[min(4, place + 1)], t ? f : f * 0.5), tc, lit), 1);\n      glyph(buf, DIGIT[u], x0 + 8, y + 4, mix(scale(ink[place], f), uc, lit), 1);\n    }\n    // A carry steps from the units of this rod to its tens, the next diagonal.\n    if (row > 0 && r && band === place + 1 && band \u003c= 4 && P.parts[part].bands[band].cin) {\n      const f = smooth((tau - T1 - part * ROW - LIGHT - band * BAND) / (BAND * 0.45));\n      const cx = round(x0 + 9 - 6 * f), cy = row * 10 + 10 + oy;\n      put(buf, cx, cy, C.gold, light);\n      put(buf, cx + 1, cy, C.gold, light);\n    }\n  }\n\n  // Underneath: the multiplier at the left, the digit being read in gold,\n  // then the partial products as they are read, then their sum.\n  const fade = 1 - smooth((tau - out) / (FALL * 0.7));\n  const xOf = (e) => 60 - 4 * e, mul = PROBLEMS[S.pi][1];\n  const shown = fade * smooth((tau - 0.6) / 0.3);\n  glyph(buf, TIMES, 1, WORK + 1, C.rule, shown);\n  for (let j = 0; j \u003c mul.length; j++) glyph(buf, DIGIT[+mul[j]], 5 + 4 * j, WORK, mix(C.pale, C.gold, part === mul.length - 1 - j ? light : 0), shown);\n  for (let i = 0; i \u003c P.n; i++) {\n    const p = P.parts[i], r0 = T1 + i * ROW, y = WORK + 6 * i, single = P.n === 1;\n    for (let j = 0; j \u003c p.len; j++) {\n      const at = r0 + LIGHT + (j + 0.5) * BAND;\n      if (tau \u003c at) break;\n      const flash = 1 - smooth((tau - at) / 0.35);\n      let c = mix(single ? C.sum : C.pale, C.white, flash);\n      if (P.n > 1 && tau >= P.sum + RULE) {\n        const e = i + j, ce = floor((tau - P.sum - RULE) / COL);\n        if (ce === e) c = C.gold;\n      }\n      glyph(buf, DIGIT[p.bands[j].d], xOf(i + j), y, c, fade);\n    }\n  }\n  if (P.n > 1 && tau >= P.sum) {\n    const yr = WORK + 6 * P.n, len = round(26 * smooth((tau - P.sum) / RULE));\n    for (let x = 0; x \u003c len; x++) put(buf, 62 - x, yr, C.rule, fade);\n    for (let e = 0; e \u003c P.cols.length; e++) {\n      const at = P.sum + RULE + (e + 0.5) * COL;\n      if (tau \u003c at) break;\n      const flash = 1 - smooth((tau - at) / 0.35);\n      glyph(buf, DIGIT[P.cols[e].d], xOf(e), yr + 2, mix(C.sum, C.white, flash), fade);\n      // The carry into the next column, on the rule.\n      const nx = P.cols[e + 1];\n      if (nx && nx.cin && tau \u003c at + COL) {\n        const f = smooth((tau - at) / (COL * 0.5)), cx = round(xOf(e) + 1 - 4 * f);\n        put(buf, cx, yr, C.gold, fade);\n        put(buf, cx + 1, yr, C.gold, fade);\n      }\n    }\n  }\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","plucked-letters":"// ===== Patternflow pattern =====\n// Title:   Plucked Letters\n// Family:  type\n// Idea:    A four-letter word of straight strokes stands two over two down the tall panel, every stroke a string pinned between bright points where strokes meet or end, and the strings are plucked letter by letter, each letter rolled as a chord from its longest stroke to its shortest, so that each string flashes, splits its triangle into two kinks that run to the pins, come back upside down and ring away, the long strokes swinging slowly and the short ones buzzing.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: d'Alembert's travelling-wave solution of the vibrating string (Jean le Rond d'Alembert, 1747), capitals drawn for this pattern as straight strokes, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Pluck=0..1\n//\n// Knob 1: Hue. Turns the strings' colours round the wheel. At 0 the longest strings are violet and the shortest cyan, with azure between; at 0.5 the longest are a yellow green and the shortest a warm red. The pins, the kinks and the flash of a fresh pluck stay near white.\n// Knob 2: Speed. The clock of everything. At 2 a wave runs 75 LEDs a second, so a 52-LED stroke swings once in 1.4 s and the 8-LED half of a serif in 0.2 s, a string's swing falls to 37% in 1.5 s, a letter's notes are 0.12 s apart and the next letter comes 0.5 s after the last note: HYMN's 15 strings come round every 3.9 s, the last 1.1 s of it a rest. Every time goes as 2 / Speed.\n// Knob 3: Word. 0 HYMN, 1 WAVE, 2 KITE, 3 LYNX, 4 ZEAL, 5 FLAX, 6 TWIN, 7 AXLE, all letters of straight strokes only. Turning it sets the new word at rest and starts it from its first letter.\n// Knob 4: Pluck. Where along each string it is pulled: at 0 the middle, at the opening 0.06 at 0.47 of its length, and at 1 at 0.06 of it, close to a pin. From the middle the two kinks part and the string's flat top widens as it sinks, until the string lies straight and the triangle comes back upside down; from near a pin the kinks come in close pairs, each pair a steep step, and the two steps run opposite ways along the string, pass through each other and turn over at the pins.\n\n// A string pinned at x = 0 and x = l, pulled aside into a triangle with\n// its peak at p l and let go, moves by d'Alembert's solution of the wave\n// equation: y(x, t) = (F(x - c t) + F(x + c t)) / 2, where F is the\n// triangle extended to the whole line as an odd function of period 2 l.\n// Half the triangle runs left and half runs right; each half reaches a\n// pin, where the odd extension sends back the same shape upside down. So\n// the string is never a sine. It is straight lines between at most four\n// kinks, at x = +-c t +- p l reduced into the string, and that is how it is\n// drawn: the kinks are worked out exactly each frame, the string is the\n// polyline through them, and each kink is a bright bead. The wave speed\n// c is the same on every string, so the period 2 l / c goes as the length\n// and the frequency as 1 / l. The swing dies away by one exponential for\n// every string, which scales the shape and leaves its corners sharp.\n//\n// The capitals are drawn on a grid four units wide and eight tall, with\n// straight strokes only. A stroke is cut wherever another stroke's end\n// lands on it or crosses it, so the crossbar of H makes four strings of\n// its two stems, and every cut and every end is a pin.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, exp, log, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst LETTERS = {\n  A: \"0 8 2 0|2 0 4 8|0.75 5 3.25 5\",\n  E: \"4 0 0 0|0 0 0 8|0 8 4 8|0 4 3.4 4\",\n  F: \"4 0 0 0|0 0 0 8|0 4 3.4 4\",\n  H: \"0 0 0 8|4 0 4 8|0 4 4 4\",\n  I: \"2 0 2 8|0.6 0 3.4 0|0.6 8 3.4 8\",\n  K: \"0 0 0 8|4 0 0 5|1.6 3 4 8\",\n  L: \"0 0 0 8|0 8 4 8\",\n  M: \"0 8 0 0|0 0 2 5|2 5 4 0|4 0 4 8\",\n  N: \"0 8 0 0|0 0 4 8|4 8 4 0\",\n  T: \"0 0 4 0|2 0 2 8\",\n  V: \"0 0 2 8|2 8 4 0\",\n  W: \"0 0 1 8|1 8 2 3|2 3 3 8|3 8 4 0\",\n  X: \"0 0 4 8|4 0 0 8\",\n  Y: \"0 0 2 4|4 0 2 4|2 4 2 8\",\n  Z: \"0 0 4 0|4 0 0 8|0 8 4 8\",\n};\nconst WORDS = [\"HYMN\", \"WAVE\", \"KITE\", \"LYNX\", \"ZEAL\", \"FLAX\", \"TWIN\", \"AXLE\"];\n\n// A letter's box: 22 by 52 LEDs, two over two.\nconst UX = 5.5, UY = 6.5;\nconst CELLS = [[5, 6], [37, 6], [5, 70], [37, 70]];\n\n// At Speed 2, in seconds: the wave speed in LEDs a second, the ring-down,\n// the flash, the notes of a letter, the gap to the next letter, the rest.\nconst WAVE = 75, RING = 1.5, FLASH = 0.16, NOTE = 0.12, NEXT = 0.5, REST = 1.1;\nconst PIN = [1, 0.97, 0.9];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Strings and pins of a word.\nfunction build(S, word) {\n  const strings = [], pins = [], seen = {};\n  const pin = (x, y) => {\n    const k = round(x * 8) + \",\" + round(y * 8);\n    if (!seen[k]) {\n      seen[k] = 1;\n      pins.push([x, y]);\n    }\n  };\n  for (let li = 0; li \u003c word.length && li \u003c 4; li++) {\n    const strokes = LETTERS[word[li]].split(\"|\").map((s) => s.split(\" \").map(Number));\n    const [cx, cy] = CELLS[li], mine = [];\n    for (const a of strokes) {\n      // Where the other strokes meet this one, as fractions along it.\n      const cuts = [0, 1];\n      const dx = a[2] - a[0], dy = a[3] - a[1];\n      for (const b of strokes) {\n        if (b === a) continue;\n        const ex = b[2] - b[0], ey = b[3] - b[1], den = dx * ey - dy * ex;\n        if (abs(den) \u003c 1e-9) continue;\n        const fx = b[0] - a[0], fy = b[1] - a[1];\n        const ta = (fx * ey - fy * ex) / den, tb = (fx * dy - fy * dx) / den;\n        if (ta > 1e-6 && ta \u003c 1 - 1e-6 && tb > -1e-6 && tb \u003c 1 + 1e-6) cuts.push(ta);\n      }\n      cuts.sort((p, q) => p - q);\n      for (let i = 1; i \u003c cuts.length; i++) {\n        if (cuts[i] - cuts[i - 1] \u003c 1e-6) continue;\n        const ax = cx + (a[0] + dx * cuts[i - 1]) * UX, ay = cy + (a[1] + dy * cuts[i - 1]) * UY;\n        const bx = cx + (a[0] + dx * cuts[i]) * UX, by = cy + (a[1] + dy * cuts[i]) * UY;\n        const l = sqrt((bx - ax) ** 2 + (by - ay) ** 2);\n        mine.push({ ax, ay, bx, by, l, ex: (bx - ax) / l, ey: (by - ay) / l, t: 1e9, sign: mine.length & 1 ? 1 : -1, rank: 0, li });\n        pin(ax, ay);\n        pin(bx, by);\n      }\n    }\n    // A letter is a chord rolled from its lowest note, the longest string.\n    mine.sort((p, q) => q.l - p.l);\n    for (const s of mine) strings.push(s);\n  }\n  let lmin = 1e9, lmax = 0;\n  for (const s of strings) {\n    lmin = min(lmin, s.l);\n    lmax = max(lmax, s.l);\n  }\n  for (const s of strings) s.rank = (log(s.l) - log(lmin)) / (log(lmax / lmin) || 1);\n  // The score: when each string is plucked, in seconds at Speed 2.\n  const score = [];\n  let at = 0, li = -1;\n  for (let i = 0; i \u003c strings.length; i++) {\n    if (i) at += strings[i].li !== li ? NEXT : NOTE;\n    li = strings[i].li;\n    score.push(at);\n  }\n  S.strings = strings;\n  S.pins = pins;\n  S.score = score;\n  S.cycle = at + REST;\n  S.clk = 0;\n  S.next = 0;\n}\n\nexport function setup(params) {\n  params.s = { buf: new Float32Array(W * H * 3), hue: 0, word: -1, p: 0.47, clk: 0, next: 0, strings: [], pins: [], score: [], cycle: 1, c: [0, 0, 0], g: [0, 0, 0], w: [0, 0, 0], xs: new Float32Array(8), ys: new Float32Array(8) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const wi = round(cl(k[2] || 0, 0, WORDS.length - 1));\n  S.p = 0.5 - 0.44 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (wi !== S.word) {\n    S.word = wi;\n    build(S, WORDS[wi]);\n  }\n  const step = (d * speed) / 2;\n  for (const s of S.strings) s.t += step;\n  // Pluck every string whose time came in this step.\n  let left = step;\n  while (left > 0) {\n    const due = S.score[S.next] - S.clk;\n    if (due > left) {\n      S.clk += left;\n      break;\n    }\n    S.clk += due;\n    left -= due;\n    const s = S.strings[S.next];\n    s.t = left;\n    s.sign = -s.sign;\n    S.next++;\n    if (S.next >= S.score.length) {\n      // The rest after the word, then from the top.\n      S.next = 0;\n      S.clk -= S.cycle;\n    }\n  }\n}\n\nfunction seg(S, x0, y0, x1, y1, w, c) {\n  const buf = S.buf, len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, Math.ceil(len / 6));\n  for (let i = 0; i \u003c n; i++) {\n    const ax = x0 + ((x1 - x0) * i) / n, ay = y0 + ((y1 - y0) * i) / n, bx = x0 + ((x1 - x0) * (i + 1)) / n, by = y0 + ((y1 - y0) * (i + 1)) / n;\n    const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1e-9, e = w / 2 + 0.5;\n    for (let y = max(0, floor(min(ay, by) - e)); y \u003c= min(H - 1, floor(max(ay, by) + e)); y++)\n      for (let x = max(0, floor(min(ax, bx) - e)); x \u003c= min(W - 1, floor(max(ax, bx) + e)); x++) {\n        const px = x + 0.5 - ax, py = y + 0.5 - ay, t = cl((px * dx + py * dy) / L2, 0, 1);\n        const ex = px - t * dx, ey = py - t * dy, a = cl(e - sqrt(ex * ex + ey * ey), 0, 1);\n        if (a \u003c= 0) continue;\n        const p = (y * W + x) * 3;\n        if (c[0] * a > buf[p]) buf[p] = c[0] * a;\n        if (c[1] * a > buf[p + 1]) buf[p + 1] = c[1] * a;\n        if (c[2] * a > buf[p + 2]) buf[p + 2] = c[2] * a;\n      }\n  }\n}\n\nfunction bead(S, x0, y0, r, c) {\n  const buf = S.buf;\n  for (let y = max(0, floor(y0 - r - 1)); y \u003c= min(H - 1, floor(y0 + r + 1)); y++)\n    for (let x = max(0, floor(x0 - r - 1)); x \u003c= min(W - 1, floor(x0 + r + 1)); x++) {\n      const ex = x + 0.5 - x0, ey = y + 0.5 - y0, a = cl(r + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (a \u003c= 0) continue;\n      const p = (y * W + x) * 3;\n      buf[p] += (c[0] - buf[p]) * a;\n      buf[p + 1] += (c[1] - buf[p + 1]) * a;\n      buf[p + 2] += (c[2] - buf[p + 2]) * a;\n    }\n}\n\n// The odd, 2l-periodic extension of the plucked triangle, peak 1 at x = q.\nfunction tri(x, l, q) {\n  x -= floor(x / (2 * l)) * 2 * l;\n  if (x > l) return -tri(2 * l - x, l, q);\n  return x \u003c q ? x / q : (l - x) / (l - q);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  S.buf.fill(0);\n  const c = S.c, xs = S.xs, ys = S.ys, ghost = S.g, white = S.w;\n  for (const s of S.strings) {\n    const env = exp(-s.t / RING), fl = exp(-s.t / FLASH);\n    hsv(S.hue + 0.5 + 0.24 * s.rank, 0.78 - 0.6 * fl, min(1, 0.56 + 0.3 * env + 0.4 * fl), c);\n    const l = s.l, q = S.p * l, amp = s.sign * min(0.13 * l, 6) * env;\n    const nx = -s.ey, ny = s.ex;\n    if (abs(amp) \u003c 0.04) {\n      seg(S, s.ax, s.ay, s.bx, s.by, 2.2, c);\n      continue;\n    }\n    // The rest line, faint under the moving string.\n    hsv(S.hue + 0.5 + 0.24 * s.rank, 0.7, 0.16, ghost);\n    seg(S, s.ax, s.ay, s.bx, s.by, 1.6, ghost);\n    // The kinks inside the string: +-ct +- pl, reduced mod 2l.\n    const ct = (s.t * WAVE) % (2 * l);\n    let n = 0;\n    xs[n++] = 0;\n    for (const k of [ct + q, ct - q, -ct + q, -ct - q]) {\n      const x = k - floor(k / (2 * l)) * 2 * l;\n      if (x > 1e-3 && x \u003c l - 1e-3) xs[n++] = x;\n    }\n    xs[n++] = l;\n    // Sort the few vertices in place.\n    for (let i = 1; i \u003c n; i++)\n      for (let j = i; j > 0 && xs[j] \u003c xs[j - 1]; j--) {\n        const t = xs[j];\n        xs[j] = xs[j - 1];\n        xs[j - 1] = t;\n      }\n    for (let i = 0; i \u003c n; i++) ys[i] = (amp * (tri(xs[i] - ct, l, q) + tri(xs[i] + ct, l, q))) / 2;\n    for (let i = 1; i \u003c n; i++)\n      seg(S, s.ax + s.ex * xs[i - 1] + nx * ys[i - 1], s.ay + s.ey * xs[i - 1] + ny * ys[i - 1], s.ax + s.ex * xs[i] + nx * ys[i], s.ay + s.ey * xs[i] + ny * ys[i], 2.2, c);\n    // The kinks as beads, while the swing is still worth watching.\n    white[0] = white[1] = min(1, 1.6 * env);\n    white[2] = white[0] * 0.92 + 0.08;\n    if (env > 0.2) for (let i = 1; i \u003c n - 1; i++) bead(S, s.ax + s.ex * xs[i] + nx * ys[i], s.ay + s.ey * xs[i] + ny * ys[i], 1 + 1.3 * fl, white);\n  }\n  for (const p of S.pins) bead(S, p[0], p[1], 0.9, PIN);\n  const buf = S.buf;\n  for (let i = 0; i \u003c W * H; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","ruled-hyperboloid":"// ===== Patternflow pattern =====\n// Title:   Ruled Hyperboloid\n// Family:  space\n// Idea:    Two equal circles, one above the other, are joined by straight rods; the top circle twists against the bottom, so the rods stand as a cylinder, pull in to a hyperboloid with a waist, close to a double cone through one point and open again, while the rods twisted the other way, the surface's second ruling, cross them into the lattice of a Shukhov tower that fills the panel's height and slowly turns.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hyperboloid of one sheet swept by a straight line turned about an axis it does not meet (Christopher Wren, 1669), built in straight bars by Vladimir Shukhov from 1896, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rods=16..48, Ruling=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the first ruling is azure, the second violet and the waist ring pale gold; at 0.5 the rulings are orange and green and the waist ring pale blue.\n// Knob 2: Speed. At 2 the twist breathes from cylinder to cone and back in 12 s and the tower turns once in 20 s; every time goes as 2 / Speed.\n// Knob 3: Rods. Rods in each ruling, 16 at the opening and up to 48: 32 to 96 straight lines in all.\n// Knob 4: Ruling. How the two rulings share the light. At 0 both are full; the opening 0.06 dims the second to 94%. At 1 only the first ruling is left, the rods twisted one way, and at -1 only the second, the same surface twisted the other way.\n\n// Join a circle of radius R at the bottom to an equal one at the top by a\n// straight rod from angle phi below to angle phi + theta above. At\n// theta = 0 the rods stand upright and sweep a cylinder. For 0 \u003c theta \u003c pi\n// every rod passes the axis at the distance R cos(theta / 2), at mid\n// height, and together they sweep a hyperboloid of one sheet whose waist\n// is that circle. At theta = pi each rod goes straight through the axis and\n// the rods meet at one point: a double cone. Rods from phi to phi - theta\n// sweep the very same surface, so the hyperboloid holds two families of\n// straight lines, its two rulings, and through each of its points passes\n// one line of each. Shukhov's towers are this: two sets of straight bars,\n// leaning opposite ways, joined where they cross.\n//\n// At theta = 0 and at theta = pi the two rulings fall on the same lines,\n// so the lattice closes to a single set of rods at both ends of the breath.\n//\n// The tower is seen in perspective from four fifths of the way up its\n// height, so the top circle shows its underside and the bottom one its top.\n// The near rods are bright and the far ones dim, each rod shaded along its\n// length by how near each part of it comes.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, sin, cos, sqrt, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\nconst ONE = [1, 1, 1];\n\n// Radius 1, half height HH, eye at distance D from the axis, the view\n// tilted down by TILT radians.\nconst HH = 1.85, D = 7, TILT = 0.16;\nconst CT = cos(TILT), ST = sin(TILT);\n\n// Fit both circles into the panel, rows 1.5 to 126.5 and columns 2 to 62.\nlet K = 1, CX = 32, CY = 64;\n{\n  let y0 = 1e9, y1 = -1e9, x1 = 0;\n  for (let i = 0; i \u003c 360; i++) {\n    const a = (i * TAU) / 360, x = cos(a), z = sin(a);\n    for (const y of [-HH, HH]) {\n      const yc = y * CT - z * ST, s = 1 / (D - (y * ST + z * CT));\n      y0 = min(y0, yc * s);\n      y1 = max(y1, yc * s);\n      x1 = max(x1, x * s);\n    }\n  }\n  K = min(125 / (y1 - y0), 30 / x1);\n  CY = 1.5 + K * y1 + (125 - K * (y1 - y0)) / 2;\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// Add colour c times a to the four LEDs around (x, y), bilinear.\nfunction splat(buf, x, y, c, a) {\n  x -= 0.5;\n  y -= 0.5;\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++) {\n    const yy = iy + j;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = j ? fy : 1 - fy;\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = a * wy * (i ? fx : 1 - fx), p = (yy * W + xx) * 3;\n      buf[p] += c[0] * w;\n      buf[p + 1] += c[1] * w;\n      buf[p + 2] += c[2] * w;\n    }\n  }\n}\n\n// How near a point is: 0 at the far side of the circle, 1 at the near side,\n// and the light it gets from that.\nconst shade = (z) => {\n  const d = cl((z + 1) / 2, 0, 1);\n  return 0.16 + 0.84 * d * sqrt(d);\n};\n\n// A straight piece of the world from (ax, ay, az) to (bx, by, bz), drawn as\n// a line one LED thick, each step lit by its own nearness.\nconst P = [0, 0];\nfunction project(x, y, z) {\n  const s = 1 / (D - (y * ST + z * CT));\n  P[0] = CX + K * x * s;\n  P[1] = CY - K * (y * CT - z * ST) * s;\n}\nfunction piece(buf, ax, ay, az, bx, by, bz, c, a) {\n  project(ax, ay, az);\n  const sx = P[0], sy = P[1];\n  project(bx, by, bz);\n  const len = sqrt((P[0] - sx) ** 2 + (P[1] - sy) ** 2), n = max(1, ceil(len * 1.6)), step = len / n;\n  for (let k = 0; k \u003c= n; k++) {\n    const t = k / n, z = az + (bz - az) * t;\n    project(ax + (bx - ax) * t, ay + (by - ay) * t, z);\n    splat(buf, P[0], P[1], c, a * shade(z) * step * (k === 0 || k === n ? 0.5 : 1));\n  }\n}\n\n// A horizontal circle of radius r at height y.\nfunction ring(buf, r, y, c, a) {\n  if (r \u003c 0.02) {\n    project(0, y, 0);\n    splat(buf, P[0], P[1], c, a * 2);\n    return;\n  }\n  const n = max(8, ceil(r * 40));\n  for (let i = 0; i \u003c n; i++) {\n    const a0 = (i * TAU) / n, a1 = ((i + 1) * TAU) / n;\n    piece(buf, r * cos(a0), y, r * sin(a0), r * cos(a1), y, r * sin(a1), c, a);\n  }\n}\n\nexport function setup(params) {\n  // The breath opens on a waist, a third of the way from cylinder to cone.\n  params.s = { buf: new Float32Array(W * H * 3), mask: new Float32Array(W * H * 3), breath: 1.16, spin: 0.3, hue: 0, rods: 16, w1: 1, w2: 0.94 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.rods = round(cl(k[2] || 16, 16, 48));\n  const r = cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  S.w1 = min(1, 1 + r);\n  S.w2 = min(1, 1 - r);\n  S.breath = (S.breath + (d * speed * TAU) / 24) % TAU;\n  S.spin = (S.spin + (d * speed * TAU) / 40) % TAU;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf;\n  buf.fill(0);\n  const theta = PI * (0.5 - 0.5 * cos(S.breath));\n  const c1 = hsv(S.hue + 0.57, 0.7, 1), c2 = hsv(S.hue + 0.78, 0.6, 1), cw = hsv(S.hue + 0.13, 0.4, 1);\n  const n = S.rods, lit = 1.35;\n\n  for (let i = 0; i \u003c n; i++) {\n    const p = S.spin + (i * TAU) / n, bx = cos(p), bz = sin(p);\n    if (S.w1 > 0.004) piece(buf, bx, -HH, bz, cos(p + theta), HH, sin(p + theta), c1, lit * S.w1);\n    if (S.w2 > 0.004) piece(buf, bx, -HH, bz, cos(p - theta), HH, sin(p - theta), c2, lit * S.w2);\n  }\n\n  // The two circles the rods hang between, and the waist they pull in to.\n  const pale = [(c1[0] + c2[0]) * 0.5, (c1[1] + c2[1]) * 0.5, (c1[2] + c2[2]) * 0.5];\n  ring(buf, 1, HH, pale, 0.7);\n  ring(buf, 1, -HH, pale, 0.7);\n\n  // The waist ring is laid over the rods rather than added to them, so it\n  // keeps its own colour where the lattice is thickest.\n  const m = S.mask;\n  m.fill(0);\n  ring(m, cos(theta / 2), 0, ONE, 2.2);\n  for (let i = 0; i \u003c W * H; i++) {\n    const a = cl(m[i * 3], 0, 1), p = i * 3;\n    display.setPixel(\n      i % W,\n      floor(i / W),\n      round(cl(buf[p] + (cw[0] * a * 1.6 - buf[p]) * a, 0, 1) * 255),\n      round(cl(buf[p + 1] + (cw[1] * a * 1.6 - buf[p + 1]) * a, 0, 1) * 255),\n      round(cl(buf[p + 2] + (cw[2] * a * 1.6 - buf[p + 2]) * a, 0, 1) * 255),\n    );\n  }\n}\n","wheel-cypher":"// ===== Patternflow pattern =====\n// Title:   Wheel Cypher\n// Family:  type\n// Idea:    A cylinder of 25 polished discs stands up the panel, each with its own scrambled alphabet painted round the rim; one disc at a time from the top turns until a 25-letter message reads down one line in amber, the line a set number of letters round then lights in violet as the ciphertext, a clerk's slip down each side carries the plaintext and the ciphertext, and the discs spin away for the next message.\n// Author:  patternflow-lab\n// Date:    2026-10-31\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: wheel cypher (Thomas Jefferson, about 1795), reinvented as Étienne Bazeries's cylinder (1891) and issued as the US Army M-94 of 25 aluminium discs (1922); the 25 alphabets are scrambled for this pattern from a fixed seed, not the M-94's, and the 3 by 4 capitals are drawn for it, pattern round 80\n// Round:   80\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Message=0..5, Line=1..5\n//\n// Knob 1: Hue. Tints the metal and turns the two lit lines with it. At 0 the metal is steel blue, the plaintext amber and the ciphertext violet; at 0.25 the metal is mauve, the lines green and red orange; at 0.5 the metal is bronze, the lines azure and green; at 0.75 the metal is sage, the lines magenta and cyan. The paint on the letters stays white and the slips stay cream.\n// Knob 2: Speed. At 2 a disc turns in 0.3 s, so the 25 are set in 7.5 s; after a 0.5 s pause the ciphertext is read off at 0.06 s a letter, the finished message holds 3 s and the discs spin away in 1.3 s, a message every 13.9 s. Every time goes as 2 / Speed.\n// Knob 3: Message. 0 ANYOTHERLINEISACIPHERTEXT, 1 TURNEACHWHEELUNTILITREADS, 2 ATTACKATDAWNHOLDTHEBRIDGE, 3 MEETMEATTHEMILLATMIDNIGHT, 4 SENDMOREMENTOTHEEASTRIDGE, 5 NOWISTHETIMEFORALLGOODMEN, and after each the next. A fresh start opens for 3.3 s on the message before, set and enciphered. Turning it sets the new message at once from the top disc, from wherever the discs stand.\n// Knob 4: Line. How many letters round from the plaintext the ciphertext lies, to the right, 1 to 5. The whole cylinder stands turned by half that, so the two lines face the front from either side: at the opening 1 they are the two lines next to the front, both one LED to a glyph column; at 5 they stand 2.5 letters either side, 35 degrees round, where the letters are foreshortened to 0.82. Turning it turns the whole cylinder there in about 0.3 s.\n\n// Each disc carries the 26 capitals round its rim in its own order. Turn\n// the discs, one by one, until the message reads along one line of the\n// cylinder; every other line of 25 letters is then a ciphertext of it, and\n// the sender copies one. The receiver, with the same discs in the same\n// order on the spindle, sets that ciphertext along a line and looks round\n// the cylinder for the one line that reads. Here the order of the discs is\n// fixed and the line is the knob.\n//\n// The cylinder is drawn as it would look: a letter cell 6.04 LEDs wide at\n// the front, and each LED column covering the stretch of rim between the\n// angles its two edges see, so letters thin as the cosine towards the\n// sides and blur into the rim's grain at its edges. Ink is averaged over\n// that stretch exactly, from a running sum round each disc.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, asin, sin, cos, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// The cylinder: 25 discs of 5 rows, 4 of letters and a chamfer, from row 1;\n// the axis through the middle of LED column 31, radius 25 LEDs, so a letter\n// cell at the front is 6.04 LEDs wide and a glyph column 1.007.\nconst DISCS = 25, PITCH = 5, TOP = 1, R = 25, XC = 31.5, CELL = (2 * PI) / 26, SLOTS = 26 * 12;\n\n// Capitals 3 wide and 4 tall, rows from the top.\nconst GLYPHS = {\n  A: [\".#.\", \"#.#\", \"###\", \"#.#\"], B: [\"##.\", \"###\", \"#.#\", \"###\"], C: [\".##\", \"#..\", \"#..\", \".##\"],\n  D: [\"##.\", \"#.#\", \"#.#\", \"##.\"], E: [\"###\", \"##.\", \"#..\", \"###\"], F: [\"###\", \"#..\", \"##.\", \"#..\"],\n  G: [\".##\", \"#..\", \"#.#\", \".##\"], H: [\"#.#\", \"###\", \"#.#\", \"#.#\"], I: [\"###\", \".#.\", \".#.\", \"###\"],\n  J: [\"..#\", \"..#\", \"#.#\", \".#.\"], K: [\"#.#\", \"##.\", \"#.#\", \"#.#\"], L: [\"#..\", \"#..\", \"#..\", \"###\"],\n  M: [\"###\", \"###\", \"#.#\", \"#.#\"], N: [\"##.\", \"#.#\", \"#.#\", \"#.#\"], O: [\".#.\", \"#.#\", \"#.#\", \".#.\"],\n  P: [\"###\", \"#.#\", \"###\", \"#..\"], Q: [\".#.\", \"#.#\", \"#.#\", \".##\"], R: [\"###\", \"#.#\", \"##.\", \"#.#\"],\n  S: [\".##\", \"#..\", \"..#\", \"##.\"], T: [\"###\", \".#.\", \".#.\", \".#.\"], U: [\"#.#\", \"#.#\", \"#.#\", \"###\"],\n  V: [\"#.#\", \"#.#\", \"#.#\", \".#.\"], W: [\"#.#\", \"#.#\", \"###\", \"###\"], X: [\"#.#\", \".#.\", \".#.\", \"#.#\"],\n  Y: [\"#.#\", \"#.#\", \".#.\", \".#.\"], Z: [\"###\", \"..#\", \".#.\", \"###\"],\n};\nconst ABC = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\n// Six messages of exactly 25 letters, one per disc.\nconst MESSAGES = [\n  \"ANYOTHERLINEISACIPHERTEXT\", \"TURNEACHWHEELUNTILITREADS\", \"ATTACKATDAWNHOLDTHEBRIDGE\",\n  \"MEETMEATTHEMILLATMIDNIGHT\", \"SENDMOREMENTOTHEEASTRIDGE\", \"NOWISTHETIMEFORALLGOODMEN\",\n];\n\n// The 25 alphabets, shuffled by a fixed generator so every run has the same\n// cylinder. ALPHA[d][j] is the letter at place j round disc d, POS[d][c] the\n// place of letter c.\nconst ALPHA = [], POS = [];\n{\n  let a = 1922;\n  const rnd = () => {\n    a = (a + 0x6d2b79f5) | 0;\n    let t = Math.imul(a ^ (a >>> 15), 1 | a);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n  for (let d = 0; d \u003c DISCS; d++) {\n    const p = ABC.split(\"\");\n    for (let i = 25; i > 0; i--) {\n      const j = floor(rnd() * (i + 1));\n      const t = p[i];\n      p[i] = p[j];\n      p[j] = t;\n    }\n    ALPHA.push(p);\n    const q = {};\n    p.forEach((c, j) => (q[c] = j));\n    POS.push(q);\n  }\n}\n\n// Round each disc the ink of glyph row r in twelfths of a cell, summed so\n// any stretch of the rim can be averaged in two lookups. A cell runs from\n// twelfth 0 to 12 with the letter centred, its three columns at 3..9.\nconst INK = [];\nfor (let d = 0; d \u003c DISCS; d++)\n  for (let r = 0; r \u003c 4; r++) {\n    const P = new Float32Array(SLOTS + 1);\n    for (let s = 0; s \u003c SLOTS; s++) {\n      const j = floor(s / 12), k = s % 12, g = GLYPHS[ALPHA[d][j]][r];\n      P[s + 1] = P[s] + (k >= 3 && k \u003c 9 && g[floor((k - 3) / 2)] === \"#\" ? 1 : 0);\n    }\n    INK.push(P);\n  }\nconst inkAt = (P, s) => {\n  const turns = floor(s / SLOTS), u = s - turns * SLOTS, i = floor(u);\n  return turns * P[SLOTS] + P[i] + (P[i + 1] - P[i]) * (u - i);\n};\n\n// Small integer hash for the grain of metal, paint and paper.\nfunction hash(a, b) {\n  let h = Math.imul(a ^ 0x9e3779b9, 0x85ebca6b) ^ Math.imul(b + 0x632be5ab, 0xc2b2ae35);\n  h ^= h >>> 15;\n  h = Math.imul(h, 0x2c1b3c6d);\n  h ^= h >>> 12;\n  return (h >>> 0) / 4294967296;\n}\n// Grain in three steps, -0.5, 0 or 0.5: as rough to the eye as smooth\n// noise, and far fewer distinct values on the panel.\nconst grain = (a, b) => floor(hash(a, b) * 3) / 2 - 0.5;\n\n// The rim is polished, so at angle th from the front it shows the room at\n// 2 th: a lamp-lit wall drawn as two waves in that angle, 3.1 and 9.7 to a\n// radian, under a little diffuse light from the lamp up on the left. Each\n// disc sits a hair off true and its reflection jogs by up to 0.15 radian\n// against its neighbours. The rim's four rows of letters fall from a bright\n// top bevel to a dark bottom one, LATHE varies each row's turning a little,\n// and the fifth row is the chamfer between two discs.\nconst ENV = [0.38, 0.22, 3.1, 0.4, 0.16, 9.7, 1.3], DIFF = 0.12, JOG = 0.15, LATHE = 0.1;\nconst BEVEL = [1.15, 1, 0.86, 0.72, 0.4], CHAMFER = 0.5, CAP = [0.6, 0.55, 0.35];\n// The letters are stamped and filled with white paint, which is matte: it\n// takes the lamp, not the reflections. PGRAIN is its unevenness.\nconst MATTE = 0.85, PGRAIN = 0.17;\n// The slips: paper level, its fibre, the rules, the shadow of the cylinder\n// on the column beside it, and pencil lead.\nconst PAPER = 0.7, FIBRE = 0.22, RULE = 0.2, SHADOW = 0.35, LEAD = 0.09;\n\n// Each LED column's stretch of the rim in cells from the front, its centre,\n// how much of it the cylinder covers, the paint's light there, and per disc\n// the light on the metal.\nconst COL = [], LIGHT = new Float32Array(DISCS * W);\nfor (let x = 0; x \u003c W; x++) {\n  const s0 = (x - XC) / R, s1 = (x + 1 - XC) / R, sc = (x + 0.5 - XC) / R;\n  const cover = cl(min(x + 1, XC + R) - max(x, XC - R), 0, 1);\n  if (cover \u003c= 0) {\n    COL.push(null);\n    continue;\n  }\n  const th = asin(cl(sc, -1, 1));\n  COL.push({ a0: asin(cl(s0, -1, 1)) / CELL, a1: asin(cl(s1, -1, 1)) / CELL, ac: th / CELL, cover, matte: MATTE + (1 - MATTE) * cos(th - 0.35) });\n  for (let d = 0; d \u003c DISCS; d++) {\n    const f = 2 * th + JOG * (hash(d, 77) - 0.5) * 2;\n    const env = ENV[0] + ENV[1] * sin(ENV[2] * f + ENV[3]) + ENV[4] * sin(ENV[5] * f + ENV[6]);\n    LIGHT[d * W + x] = (1 - DIFF) * env + DIFF * cos(th - 0.35);\n  }\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\n// Seconds at Speed 2: a disc's turn, the pause before the ciphertext, one\n// cipher letter, the hold on a finished message, the spin away.\nconst TURN = 0.3, PAUSE = 0.5, CIPH = 0.06, HOLD = 3, SPIN = 1.3, OPEN = 3.3;\n\nconst wrap = (v) => ((v % 26) + 26) % 26;\nconst shortest = (from, to) => {\n  let d = wrap(to - from);\n  if (d > 13) d -= 26;\n  return d;\n};\n\nfunction setMessage(S, m) {\n  S.m = ((m % MESSAGES.length) + MESSAGES.length) % MESSAGES.length;\n  S.msg = MESSAGES[S.m];\n  S.target = [];\n  for (let d = 0; d \u003c DISCS; d++) S.target.push(POS[d][S.msg[d]]);\n}\n\nfunction beginSet(S) {\n  S.phase = \"set\";\n  S.i = 0;\n  S.tau = 0;\n  S.set = 0;\n  S.ciph = 0;\n  S.from = S.phi[0];\n}\n\nexport function setup(params) {\n  const S = { phi: new Float32Array(DISCS), blur: new Float32Array(DISCS), spin0: new Float32Array(DISCS), spinD: new Float32Array(DISCS) };\n  S.knob = -1;\n  S.line = 1;\n  S.turn = -1;\n  S.dturn = 0;\n  S.hue = 0;\n  S.speed = 2;\n  S.buf = new Float32Array(W * H * 3);\n  params.s = S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.line = round(cl(k[3] == null ? 1 : k[3], 1, 5));\n  // The whole cylinder sits turned by half the line, so the plaintext and\n  // the ciphertext stand either side of the front; a new line turns it there.\n  const turn0 = S.turn;\n  S.turn = S.turn \u003c 0 ? S.line / 2 : S.turn + (S.line / 2 - S.turn) * min(1, (d * S.speed) / 2 / 0.12);\n  S.dturn = abs(S.turn - turn0) * (turn0 \u003c 0 ? 0 : 1);\n  const km = round(cl(k[2] || 0, 0, 5));\n  if (km !== S.knob) {\n    if (S.knob \u003c 0) {\n      // A fresh start opens on the message before, set and enciphered.\n      setMessage(S, km - 1);\n      for (let i = 0; i \u003c DISCS; i++) S.phi[i] = S.target[i];\n      S.phase = \"hold\";\n      S.tau = HOLD - OPEN;\n      S.set = DISCS;\n      S.ciph = DISCS;\n      S.next = km;\n    } else {\n      setMessage(S, km);\n      S.next = null;\n      beginSet(S);\n    }\n    S.knob = km;\n  }\n  const old = Float32Array.from(S.phi);\n  S.tau += (d * S.speed) / 2;\n  if (S.phase === \"set\") {\n    const delta = shortest(S.from, S.target[S.i]);\n    S.phi[S.i] = S.from + delta * smooth(S.tau / TURN);\n    if (S.tau >= TURN) {\n      S.phi[S.i] = S.target[S.i];\n      S.set = ++S.i;\n      S.tau = 0;\n      if (S.i >= DISCS) S.phase = \"pause\";\n      else S.from = S.phi[S.i];\n    }\n  } else if (S.phase === \"pause\") {\n    if (S.tau >= PAUSE) {\n      S.phase = \"cipher\";\n      S.tau = 0;\n    }\n  } else if (S.phase === \"cipher\") {\n    S.ciph = min(DISCS, floor(S.tau / CIPH) + 1);\n    if (S.tau >= CIPH * DISCS) {\n      S.phase = \"hold\";\n      S.tau = 0;\n    }\n  } else if (S.phase === \"hold\") {\n    if (S.tau >= HOLD) {\n      S.phase = \"spin\";\n      S.tau = 0;\n      // The slip keeps this ciphertext in lead until the next is inked over it.\n      S.old = \"\";\n      for (let i = 0; i \u003c DISCS; i++) S.old += ALPHA[i][wrap(S.target[i] + S.line)];\n      S.set = 0;\n      S.ciph = 0;\n      for (let i = 0; i \u003c DISCS; i++) {\n        S.spin0[i] = S.phi[i];\n        // Each disc flicked by hand: 4 to 11 letters either way.\n        S.spinD[i] = (Math.random() \u003c 0.5 ? -1 : 1) * (4 + Math.random() * 7);\n      }\n    }\n  } else if (S.phase === \"spin\") {\n    for (let i = 0; i \u003c DISCS; i++) {\n      const u = cl((S.tau / SPIN) * 1.25 - (i / DISCS) * 0.25, 0, 1);\n      S.phi[i] = S.spin0[i] + S.spinD[i] * (1 - pow(1 - u, 3));\n    }\n    if (S.tau >= SPIN) {\n      setMessage(S, S.next == null ? S.m + 1 : S.next);\n      S.next = null;\n      beginSet(S);\n    }\n  }\n  for (let i = 0; i \u003c DISCS; i++) S.blur[i] = abs(S.phi[i] - old[i]) + S.dturn;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf;\n  buf.fill(0);\n  const h = S.hue + 0.58;\n  const metal = hsv(h, 0.16, 1), paint = hsv(h + 0.5, 0.06, 1), amber = hsv(h + 0.5, 0.75, 1), violet = hsv(h + 0.22, 0.6, 1);\n  const line = S.line;\n\n  for (let d = 0; d \u003c DISCS; d++) {\n    const y0 = TOP + d * PITCH, phi = S.phi[d] + S.turn, blur = S.blur[d] * 12;\n    const plain = d \u003c S.set, ciph = d \u003c S.ciph;\n    const jp = S.target[d], jc = wrap(jp + line), lathe = [];\n    for (let r = 0; r \u003c PITCH; r++) lathe.push(1 + LATHE * (hash(d * 8 + r, 999) - 0.5));\n    for (let x = 0; x \u003c W; x++) {\n      const C = COL[x];\n      if (!C) continue;\n      const sL = (C.a0 + phi + 0.5) * 12, sR = (C.a1 + phi + 0.5) * 12 + blur, span = max(1e-6, sR - sL);\n      const uc = C.ac + phi, j = wrap(round(uc)), slot = floor(wrap(uc + 0.5) * 12);\n      const litP = plain && j === jp, litC = ciph && j === jc;\n      for (let r = 0; r \u003c PITCH; r++) {\n        const p = ((y0 + r) * W + x) * 3;\n        let b = LIGHT[d * W + x] * BEVEL[r] * lathe[r];\n        if (r === 4) b *= 1 + CHAMFER * grain(d * 8 + 4, slot);\n        let cr = metal[0] * b, cg = metal[1] * b, cb = metal[2] * b;\n        if (r \u003c 4) {\n          const P = INK[d * 4 + r], ink = (inkAt(P, sR) - inkAt(P, sL)) / span;\n          if (litP || litC) {\n            // A lit line: its cells washed in the colour, its letters in it.\n            const g = litP ? amber : violet, wash = 0.35;\n            cr += (g[0] * wash * b - cr * wash) + (g[0] - cr) * ink;\n            cg += (g[1] * wash * b - cg * wash) + (g[1] - cg) * ink;\n            cb += (g[2] * wash * b - cb * wash) + (g[2] - cb) * ink;\n          } else if (ink > 0) {\n            const v = C.matte * (1 + PGRAIN * grain(d * 8 + r + 9000, slot));\n            cr += (paint[0] * v - cr) * ink;\n            cg += (paint[1] * v - cg) * ink;\n            cb += (paint[2] * v - cb) * ink;\n          }\n        }\n        buf[p] = cr * C.cover;\n        buf[p + 1] = cg * C.cover;\n        buf[p + 2] = cb * C.cover;\n      }\n    }\n  }\n\n  // The end plates: one row on top, the bottom plate and its foot below.\n  for (const [y, k] of [[0, CAP[0]], [H - 2, CAP[1]], [H - 1, CAP[2]]])\n    for (let x = 0; x \u003c W; x++) {\n      const C = COL[x];\n      if (!C) continue;\n      const b = LIGHT[x] * k * (1 + CHAMFER * grain(y + 31, x)) * C.cover, p = (y * W + x) * 3;\n      buf[p] = metal[0] * b;\n      buf[p + 1] = metal[1] * b;\n      buf[p + 2] = metal[2] * b;\n    }\n\n  // The clerk's slips: the plaintext written down the left one from the\n  // start, each letter inked amber once its disc is set, and the ciphertext\n  // written down the right one in violet as it is read off.\n  const paper = hsv(0.11, 0.14, PAPER), lead = [LEAD, LEAD, LEAD * 1.1];\n  for (const [x0, x1] of [[0, 5], [57, 63]])\n    for (let y = 0; y \u003c H; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const p = (y * W + x) * 3, rule = (y - TOP) % PITCH === 4 ? 1 - RULE : 1;\n        // The column against the cylinder lies in its shadow.\n        const f = (x === 5 || x === 57 ? SHADOW : 1) * rule * (1 + FIBRE * grain(x * 131 + 7, y));\n        buf[p] = paper[0] * f;\n        buf[p + 1] = paper[1] * f;\n        buf[p + 2] = paper[2] * f;\n      }\n  // Ink takes the grain of the paper it lies on.\n  const glyph = (ch, x0, y0, c) => {\n    const g = GLYPHS[ch];\n    for (let r = 0; r \u003c 4; r++)\n      for (let i = 0; i \u003c 3; i++)\n        if (g[r][i] === \"#\") {\n          const x = x0 + i, y = y0 + r, p = (y * W + x) * 3, f = 1 + FIBRE * grain(x * 131 + 7, y);\n          buf[p] = c[0] * f;\n          buf[p + 1] = c[1] * f;\n          buf[p + 2] = c[2] * f;\n        }\n  };\n  for (let d = 0; d \u003c DISCS; d++) {\n    const y0 = TOP + d * PITCH;\n    glyph(S.msg[d], 1, y0, d \u003c S.set ? amber : lead);\n    if (d \u003c S.ciph) glyph(ALPHA[d][wrap(S.target[d] + line)], 59, y0, violet);\n    else if (S.old) glyph(S.old[d], 59, y0, lead);\n  }\n\n  for (let i = 0; i \u003c W * H; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","beam-letters":"// ===== Patternflow pattern =====\n// Title:   Beam Letters\n// Family:  type\n// Idea:    One electron beam writes a few short words stacked down the tall screen the way an oscilloscope in XY mode writes text, along the strokes of a single-stroke font at a limited slew rate and blanked as it jumps from one stroke to the next, so the phosphor glows hottest where the beam slows into corners, turns and stroke ends and stays dimmer along long fast strokes, the glow fades behind the spot, and the writing order shows as a bright sweep running line by line through the words until, with the beam fast enough, the text stands steady with a faint refresh shimmer.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: single-stroke fonts for vector displays and plotters after the Hershey fonts (Allen V. Hershey, U.S. Naval Weapons Laboratory, 1967), with letters drawn for this pattern as lines and arcs; phosphor persistence on a cathode-ray tube driven in XY mode; pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Phosphor=0..1, Speed=0.2..3, Persistence=0..1, Focus=0..1\n//\n// Knob 1: Phosphor. P31, the green of oscilloscopes, below 0.25; then P7, the radar phosphor whose blue-white flash leaves a long yellow-green afterglow; P11 blue from 0.5; P4, the white of black-and-white television, from 0.75.\n// Knob 2: Speed. How many steps of the beam's path go by a second. At 2 the beam's top speed is 3360 LEDs a second and LET THERE BE LIGHT is written 2.25 times a second, so a bright sweep runs line by line through words that stay readable behind it; at 3 the top speed is 66500 LEDs a second, the text is rewritten 44 times a second and stands steady; at 0.2 the beam crawls at 105 LEDs a second and takes 14 s over the four lines. Between those three the rate goes evenly in its logarithm. A message holds for 8 s, or one pass if that is longer.\n// Knob 3: Persistence. The phosphor's time constant: 0.1 s at 0, 0.32 s at a quarter, 1 s at a half, 3.2 s at three quarters and 10 s at 1. At the opening the line the beam left 0.3 s ago gives 5% of the light it gave as it was written; at a half the oldest line keeps 64% and the text stands nearly evenly; from three quarters on the light takes seconds to build and the old message stays under the new one, at 1 for longer than a message holds, so two or three lie over each other.\n// Knob 4: Focus. The spot's size, a Gaussian 0.55 LEDs wide (one sigma) up to the opening 0.06, growing to 2.4 LEDs at 1, where the lines bloom into soft bars and the letters only just read.\n\n// A vector display draws nothing but lines: the deflection plates steer one\n// spot, and the spot lights the phosphor wherever it goes while the beam is\n// on. Text on such a screen is a display list, letter after letter of short\n// polylines, and the beam is switched off (blanked) while it jumps from the\n// end of one stroke to the start of the next. Here each letter is a few\n// strokes of lines and arcs on a grid 24 units high, in the spirit of\n// Hershey's single-stroke Roman, and each line of a message is scaled to its\n// own width, as a stroke font can be.\n//\n// The deflection cannot move the spot at any speed. The beam has a top speed\n// and a top acceleration, so it slows down into every corner, the more the\n// sharper the turn, and comes to rest at both ends of a stroke, where it\n// waits a moment for the beam to switch. The beam current is constant, so\n// the energy a stretch of phosphor takes is the time the spot spends on it:\n// long fast strokes are faint, turns and stroke ends glow, and a dot is a\n// spot that only waits. The path is sampled once at equal steps of beam\n// time, and the Speed knob only says how many of those steps a second take.\n//\n// The phosphor stores the energy and gives it back as light, its store\n// decaying as exp(-t / tau), so the light it gives is the store over tau. A\n// short second component flashes for 0.035 s where the beam has just been:\n// on most phosphors a hotter, whiter tint, on P7 its blue. When the beam\n// writes the whole list many times within tau the screen shows the steady\n// average, the same brightness at every speed; when it writes slower than\n// tau only the last stretch glows and the writing order is there to read.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, exp, cos, sin, acos, hypot, ceil, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- The font. [advance width, strokes] on a grid 24 high, y down. M starts\n// a stroke, L draws to a point, A cx,cy,rx,ry,from,to draws an arc in\n// degrees (0 at the right, 90 at the bottom) on from the pen.\nconst GLYPHS = {\n  A: [16, \"M0,24 L8,0 L16,24 M3,16 L13,16\"],\n  B: [14, \"M0,24 L0,0 L8,0 A8,5.5,5.5,5.5,-90,90 L0,11 M8,11 A8,17.5,6,6.5,-90,90 L0,24\"],\n  C: [15, \"A8,12,8,12,-40,-320\"],\n  D: [15, \"M0,0 L0,24 L4,24 A4,12,11,12,90,-90 L0,0\"],\n  E: [13, \"M13,0 L0,0 L0,24 L13,24 M0,12 L10,12\"],\n  F: [13, \"M13,0 L0,0 L0,24 M0,12 L10,12\"],\n  G: [16, \"A8,12,8,12,-40,-360 L9,12\"],\n  H: [14, \"M0,0 L0,24 M14,0 L14,24 M0,12 L14,12\"],\n  I: [0, \"M0,0 L0,24\"],\n  J: [11, \"M11,0 L11,18 A5.5,18,5.5,6,0,180\"],\n  K: [14, \"M0,0 L0,24 M14,0 L0,16 M4.5,11 L14,24\"],\n  L: [12, \"M0,0 L0,24 L12,24\"],\n  M: [18, \"M0,24 L0,0 L9,24 L18,0 L18,24\"],\n  N: [15, \"M0,24 L0,0 L15,24 L15,0\"],\n  O: [16, \"A8,12,8,12,-90,270\"],\n  P: [14, \"M0,24 L0,0 L8,0 A8,6,6,6,-90,90 L0,12\"],\n  Q: [16, \"A8,12,8,12,-90,270 M10,18 L16,25\"],\n  R: [14, \"M0,24 L0,0 L8,0 A8,6,6,6,-90,90 L0,12 M7,12 L14,24\"],\n  S: [14, \"A7,6,6.5,6,-25,-270 A7,18,7,6,-90,155\"],\n  T: [14, \"M0,0 L14,0 M7,0 L7,24\"],\n  U: [14, \"M0,0 L0,17 A7,17,7,7,180,0 L14,0\"],\n  V: [16, \"M0,0 L8,24 L16,0\"],\n  W: [20, \"M0,0 L5,24 L10,6 L15,24 L20,0\"],\n  X: [14, \"M0,0 L14,24 M14,0 L0,24\"],\n  Y: [14, \"M0,0 L7,12 L14,0 M7,12 L7,24\"],\n  Z: [14, \"M0,0 L14,0 L0,24 L14,24\"],\n};\nconst GAP = 6;\n\n// The first words of four new ways to send words: Genesis 1:3, the first\n// telegraph line from Washington to Baltimore (Samuel Morse, 24 May 1844),\n// Alexander Graham Bell's first call to his assistant (10 March 1876), and\n// the first two letters of LOGIN that reached SRI from UCLA over the ARPANET\n// (29 October 1969) before the host there crashed.\nconst MESSAGES = [\n  [\"LET\", \"THERE\", \"BE\", \"LIGHT\"],\n  [\"WHAT\", \"HATH\", \"GOD\", \"WROUGHT\"],\n  [\"MR\", \"WATSON\", \"COME\", \"HERE\"],\n  [\"LO\"],\n];\nconst HOLD = 8;\n\n// Glyph strokes in its own units: an array of flat [x0, y0, x1, y1, ...].\nfunction glyphStrokes(src) {\n  const out = [];\n  let cur = null;\n  for (const tok of src.split(\" \")) {\n    const op = tok[0], a = tok.slice(1).split(\",\").map(Number);\n    if (op === \"M\") {\n      cur = [a[0], a[1]];\n      out.push(cur);\n    } else if (op === \"L\") cur.push(a[0], a[1]);\n    else {\n      const [cx, cy, rx, ry, a0, a1] = a, n = max(4, ceil(Math.abs(a1 - a0) / 15));\n      for (let i = 0; i \u003c= n; i++) {\n        const t = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, x = cx + rx * cos(t), y = cy + ry * sin(t);\n        if (i === 0 && cur && hypot(cur[cur.length - 2] - x, cur[cur.length - 1] - y) \u003c 0.01) continue;\n        if (i === 0 && !cur) {\n          cur = [];\n          out.push(cur);\n        }\n        cur.push(x, y);\n      }\n    }\n  }\n  return out;\n}\n\n// A message laid out on the panel: four lines 22 LEDs tall with 9 between,\n// or one line twice that, each line squeezed sideways to fit 60 LEDs.\nfunction layout(lines) {\n  const n = lines.length, capH = n === 1 ? 44 : floor((118 - (n - 1) * 9) / n), sy = capH / 24;\n  const strokes = [];\n  let y0 = (H - (n * capH + (n - 1) * 9)) / 2;\n  for (const line of lines) {\n    let uw = 0;\n    for (const ch of line) uw += GLYPHS[ch][0];\n    uw += GAP * (line.length - 1);\n    // A line too long for the width is squeezed, but to no less than 0.65\n    // of the font's own width; past that it is set smaller instead.\n    const sx = min(sy, 58 / uw), ly = min(sy, sx / 0.65), yl = y0 + ((sy - ly) * 24) / 2;\n    let ux = 0;\n    const x0 = (W - uw * sx) / 2;\n    for (const ch of line) {\n      for (const st of glyphStrokes(GLYPHS[ch][1])) {\n        const p = [];\n        for (let i = 0; i \u003c st.length; i += 2) p.push(x0 + (ux + st[i]) * sx, yl + st[i + 1] * ly);\n        strokes.push(p);\n      }\n      ux += GLYPHS[ch][0] + GAP;\n    }\n    y0 += capH + 9;\n  }\n  return strokes;\n}\n\n// ---- The beam. Units are LEDs and steps of beam time. The top speed is\n// VMAX LEDs a step and the deflection can stop from it within 3.5 LEDs;\n// a turn through angle a caps the speed at VMAX (1 - a / pi)^1.5, so a right\n// angle at 35% and the apex of the A at 10%. The beam rests DWELL steps on\n// at each end of a stroke, and a blanked jump runs at 1.7 VMAX and settles\n// for SETTLE steps.\nconst VMAX = 0.35, ACC = (VMAX * VMAX) / 7, VMIN = 0.02, DWELL = 8, VJUMP = 0.6, SETTLE = 3;\n\nfunction trace(strokes) {\n  const xs = [], ys = [];\n  let px = null, py = null;\n  const jump = (x1, y1) => {\n    const n = ceil(hypot(x1 - px, y1 - py) / VJUMP) + SETTLE;\n    for (let i = 0; i \u003c n; i++) {\n      xs.push(-1);\n      ys.push(-1);\n    }\n  };\n  for (const st of strokes) {\n    const n = st.length / 2;\n    if (px !== null) jump(st[0], st[1]);\n    const v = new Float64Array(n), len = new Float64Array(n);\n    for (let i = 0; i \u003c n - 1; i++) len[i] = hypot(st[2 * i + 2] - st[2 * i], st[2 * i + 3] - st[2 * i + 1]);\n    for (let i = 1; i \u003c n - 1; i++) {\n      const ax = st[2 * i] - st[2 * i - 2], ay = st[2 * i + 1] - st[2 * i - 1], bx = st[2 * i + 2] - st[2 * i], by = st[2 * i + 3] - st[2 * i + 1];\n      const c = (ax * bx + ay * by) / max(1e-9, hypot(ax, ay) * hypot(bx, by));\n      v[i] = VMAX * (1 - acos(cl(c, -1, 1)) / PI) ** 1.5;\n    }\n    for (let i = 1; i \u003c n; i++) v[i] = min(v[i], sqrt(v[i - 1] ** 2 + 2 * ACC * len[i - 1]));\n    for (let i = n - 2; i >= 0; i--) v[i] = min(v[i], sqrt(v[i + 1] ** 2 + 2 * ACC * len[i]));\n    for (let k = 0; k \u003c DWELL; k++) {\n      xs.push(st[0]);\n      ys.push(st[1]);\n    }\n    let s = 0;\n    for (let i = 0; i \u003c n - 1; i++) {\n      const l = len[i], v0 = v[i], v1 = v[i + 1];\n      if (l \u003c 1e-6) continue;\n      const vat = (q) => min(VMAX, sqrt(v0 * v0 + 2 * ACC * max(0, q)), sqrt(v1 * v1 + 2 * ACC * max(0, l - q)));\n      while (s \u003c l) {\n        const u = s / l;\n        xs.push(st[2 * i] + (st[2 * i + 2] - st[2 * i]) * u);\n        ys.push(st[2 * i + 1] + (st[2 * i + 3] - st[2 * i + 1]) * u);\n        s += max(VMIN, vat(s + 0.5 * vat(s)));\n      }\n      s -= l;\n    }\n    for (let k = 0; k \u003c DWELL; k++) {\n      xs.push(st[2 * n - 2]);\n      ys.push(st[2 * n - 1]);\n    }\n    px = st[2 * n - 2];\n    py = st[2 * n - 1];\n  }\n  // The retrace to the first stroke, blanked.\n  jump(strokes[0][0], strokes[0][1]);\n  return { xs: Float32Array.from(xs), ys: Float32Array.from(ys) };\n}\n\n// ---- Phosphors: the main glow's colour, the flash's colour and the flash's\n// share of the energy. Light is turned into a colour channel by channel as\n// 1 - exp(-light * weight), so a hot spot runs to white.\nconst PHOSPHORS = [\n  { m: [0.3, 1, 0.36], f: [0.75, 1, 0.8], ff: 0.35 }, // P31\n  { m: [0.55, 1, 0.12], f: [0.5, 0.72, 1], ff: 1.2 }, // P7\n  { m: [0.22, 0.6, 1.8], f: [0.9, 1.1, 1.8], ff: 0.35 }, // P11\n  { m: [0.82, 0.88, 1], f: [1, 1, 1], ff: 0.35 }, // P4\n];\nconst TAUF = 0.035, GAIN = 1700, CAP = 30000;\n// Steps a second: R0 at Speed 0.2, R2 at 2 and R3 at 3, evenly in the\n// logarithm between them.\nconst R0 = 300, R2 = 9600, R3 = 190000;\n\nexport function setup(params) {\n  params.s = {\n    paths: MESSAGES.map((m) => trace(layout(m))),\n    msg: 0, pos: 0, acc: 0, held: 0, sigma: 0.45,\n    E: new Float32Array(N), F: new Float32Array(N),\n    tm: new Float32Array(N), tf: new Float32Array(N), tmp: new Float32Array(N),\n    tau: 0.12, ph: PHOSPHORS[0],\n  };\n}\n\n// Separable Gaussian blur of a buffer in place: the spot.\nfunction blur(b, tmp, sigma) {\n  const r = max(1, ceil(sigma * 2.5)), k = [];\n  let sum = 0;\n  for (let i = -r; i \u003c= r; i++) {\n    const w = exp(-(i * i) / (2 * sigma * sigma));\n    k.push(w);\n    sum += w;\n  }\n  for (let i = 0; i \u003c k.length; i++) k[i] /= sum;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let a = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const xx = x + i;\n        if (xx >= 0 && xx \u003c W) a += b[y * W + xx] * k[i + r];\n      }\n      tmp[y * W + x] = a;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let a = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const yy = y + i;\n        if (yy >= 0 && yy \u003c H) a += tmp[yy * W + x] * k[i + r];\n      }\n      b[y * W + x] = a;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.ph = PHOSPHORS[min(3, floor(cl(k[0] || 0, 0, 1) * 4))];\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.tau = 0.1 * 100 ** cl(k[2] || 0, 0, 1);\n  // The spot is 0.55 LEDs up to the opening 0.06 and 2.4 LEDs at 1.\n  S.sigma = 0.55 + 1.85 * max(0, (cl(k[3] == null ? 0.06 : k[3], 0, 1) - 0.06) / 0.94) ** 1.3;\n  const R = speed \u003c= 2 ? R2 * (R0 / R2) ** ((2 - speed) / 1.8) : R2 * (R3 / R2) ** (speed - 2), tau = S.tau;\n  S.acc += d * R;\n  let n = floor(S.acc);\n  S.acc -= n;\n  S.held += d;\n  const tm = S.tm, tf = S.tf;\n  tm.fill(0);\n  tf.fill(0);\n  // Steps older than CAP are too faded to show: skip them unseen.\n  let skip = max(0, n - CAP);\n  n -= skip;\n  const q = 1 / R, rm = exp(1 / (R * tau)), rf = exp(1 / (R * TAUF)), ff = S.ph.ff;\n  let wm = q * exp(-(n - 1) / (R * tau)), wf = q * ff * exp(-(n - 1) / (R * TAUF));\n  let path = S.paths[S.msg];\n  const step = () => {\n    S.pos++;\n    if (S.pos >= path.xs.length) {\n      S.pos = 0;\n      if (S.held >= HOLD) {\n        S.held = 0;\n        S.msg = (S.msg + 1) % MESSAGES.length;\n        path = S.paths[S.msg];\n      }\n    }\n  };\n  while (skip-- > 0) step();\n  for (let i = 0; i \u003c n; i++) {\n    const x = path.xs[S.pos], y = path.ys[S.pos];\n    if (x >= 0) {\n      const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n      for (let j = 0; j \u003c 4; j++) {\n        const xx = x0 + (j & 1), yy = y0 + (j >> 1);\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const w = (j & 1 ? fx : 1 - fx) * (j >> 1 ? fy : 1 - fy), p = yy * W + xx;\n        tm[p] += wm * w;\n        tf[p] += wf * w;\n      }\n    }\n    wm *= rm;\n    wf *= rf;\n    step();\n  }\n  blur(tm, S.tmp, S.sigma);\n  blur(tf, S.tmp, S.sigma);\n  const dm = exp(-d / tau), df = exp(-d / TAUF), E = S.E, F = S.F;\n  for (let p = 0; p \u003c N; p++) {\n    E[p] = E[p] * dm + tm[p];\n    F[p] = F[p] * df + tf[p];\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const E = S.E, F = S.F, m = S.ph.m, f = S.ph.f, gm = GAIN / S.tau, gf = GAIN / TAUF;\n  for (let p = 0; p \u003c N; p++) {\n    const a = E[p] * gm, b = F[p] * gf;\n    display.setPixel(p % W, floor(p / W),\n      round(255 * (1 - exp(-(a * m[0] + b * f[0])))),\n      round(255 * (1 - exp(-(a * m[1] + b * f[1])))),\n      round(255 * (1 - exp(-(a * m[2] + b * f[2])))));\n  }\n}\n","ekg-sequence":"// ===== Patternflow pattern =====\n// Title:   EKG Sequence\n// Family:  data\n// Idea:    The EKG sequence is computed term by term and runs down the panel one term to a row with each value plotted across, scaled so the newest n sits two thirds of the way over: most terms hug the line a = n, and each odd prime p arrives as the run 2p, p, 3p, a stroke out to the faint guide a = n/2, where the prime is written in gold, and across to a = 3n/2, so that as the count goes on the opening fan of three rays from the top corner straightens into three upright lines with the primes listed down the left in order.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the EKG sequence (Jeffrey Lagarias, Eric Rains and Neil Sloane, 2002; OEIS A064413), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Zoom=1..4, Links=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the trace is azure, the primes gold and the guides a dim azure; at 0.5 the trace is orange and the primes blue.\n// Knob 2: Speed. New terms a second, 4 for each unit: 8 at the opening 2, so near n = 1,000 a prime arrives about every 1.5 s; 0.8 at 0.2 and 12 at 3. After 50,000 terms (the last prime to arrive is 25,771) the count starts again.\n// Knob 3: Zoom. Terms to a row: 1 at the opening, so the panel holds 128, up to 4 at the end (512). The panel opens full with the first 128 x Zoom terms, and at 1 the run 1, 2, 4, 6, 3, 9, 12, 8, 10, 5, 15 fans out from the top left corner.\n// Knob 4: Links. Colours each step of the trace by the smallest prime its two terms share, fully at 1 and hardly at the opening 0.06: 2 azure, 3 magenta, a larger prime below the square root of the term lime, and one above it white. For p of 5 or more the strokes 2p to p to 3p of each spike are white; the lime steps are the short runs through 5, 7, 29 and the like that weave the line near a = n.\n\n// a(1) = 1, a(2) = 2, and a(n) is the smallest number not used yet that\n// shares a factor greater than 1 with a(n - 1). Lagarias, Rains and Sloane\n// named it for its graph, which looks like an electrocardiogram, and\n// proved that every positive integer turns up in it. Most terms sit a\n// little above n; they conjectured n (1 + 1/(3 log n)), and near\n// n = 10,000 the middle of the terms here runs at 1.037 n. Each odd prime p\n// comes as the run 2p, p, 3p: 2p is an even number near n, p is then the\n// smallest unused number sharing a factor with it, and 3p the smallest\n// unused multiple of p after that, so the graph drops to about n/2 and\n// jumps to about 3n/2. They saw this for every prime they computed, and it\n// was proved later. In the 50,000 terms here it holds for all 2,837 odd\n// primes, and the primes arrive in increasing order.\n//\n// The code keeps a used flag for every number and, for each prime p, the\n// least m with p m unused; m only moves up, since numbers are only ever\n// added to the used set. The next term is the least p m over the primes of\n// the last term, read off a table of smallest prime factors.\n//\n// Each row of the panel holds a term (or Zoom terms), the newest at the\n// bottom, and the value runs across with 0 on column 2 and the newest n on\n// column 42. So the guides a = n/2, n and 3n/2 are rays from the point\n// n = 0 above the panel, and they lean less as n grows.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, max, abs, round, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Terms before the count starts again, and the numbers the code keeps\n// track of: in the first 50,000 terms the largest is 77,313 and the largest\n// candidate looked at 103,084.\nconst NMAX = 50000, LIM = 120000;\n// Columns: the value 0 sits on column X0 and the newest n on X0 + XS.\nconst X0 = 2, XS = 40;\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001011001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001010010\", \"111101111101111\", \"111101111001111\"];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\n// Smallest prime factor of every number up to LIM.\nfunction sieve() {\n  const s = new Int32Array(LIM + 1);\n  for (let i = 2; i \u003c= LIM; i++) if (!s[i]) for (let j = i; j \u003c= LIM; j += i) if (!s[j]) s[j] = i;\n  return s;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 8, zoom: 1, links: 0.06, acc: 0, ready: false,\n    spf: sieve(), a: new Int32Array(NMAX + 2), link: new Int32Array(NMAX + 2),\n    used: new Uint8Array(LIM + 1), ptr: new Int32Array(LIM + 1), n: 0,\n    buf: new Float32Array(N * 3), cols: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], c: [0, 0, 0],\n  };\n}\n\nfunction restart(S) {\n  S.used.fill(0);\n  S.ptr.fill(0);\n  S.a[1] = 1;\n  S.a[2] = 2;\n  S.used[1] = S.used[2] = 1;\n  S.link[2] = 2;\n  S.n = 2;\n}\n\n// a(n + 1): for each prime p of a(n), the smallest multiple of p not yet\n// used (ptr[p] only ever moves up, since used only fills), and the least\n// of these. link is the smallest prime the two terms share.\nfunction next(S) {\n  const spf = S.spf, used = S.used, ptr = S.ptr, prev = S.a[S.n];\n  let x = prev, best = Infinity;\n  while (x > 1) {\n    const p = spf[x];\n    while (x % p === 0) x /= p;\n    let m = ptr[p] || 1;\n    while (p * m \u003c= LIM && used[p * m]) m++;\n    ptr[p] = m;\n    if (p * m \u003c best) best = p * m;\n  }\n  if (best > LIM || S.n >= NMAX) {\n    S.ready = false;\n    return;\n  }\n  x = prev;\n  let lk = 0;\n  while (x > 1 && !lk) {\n    const p = spf[x];\n    while (x % p === 0) x /= p;\n    if (best % p === 0) lk = p;\n  }\n  S.n++;\n  S.a[S.n] = best;\n  S.link[S.n] = lk;\n  used[best] = 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = 4 * cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.zoom = cl(k[2] == null ? 1 : k[2], 1, 4);\n  S.links = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (!S.ready) fill(S);\n  S.acc += d * S.rate;\n  while (S.acc >= 1) {\n    next(S);\n    if (!S.ready) fill(S);\n    S.acc -= 1;\n  }\n}\n\n// Open, and start again, with the panel full: the first 128 x Zoom terms.\nfunction fill(S) {\n  restart(S);\n  while (S.n \u003c round(H * S.zoom)) next(S);\n  S.ready = true;\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] = max(buf[o], c[0] * a);\n  buf[o + 1] = max(buf[o + 1], c[1] * a);\n  buf[o + 2] = max(buf[o + 2], c[2] * a);\n}\n\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0), 1);\n  for (let s = 0; s \u003c= n; s++) put(buf, round(x0 + ((x1 - x0) * s) / n), round(y0 + ((y1 - y0) * s) / n), c, a);\n}\n\nfunction digits(buf, v, x, y, c, a) {\n  const t = String(v);\n  for (let i = 0; i \u003c t.length; i++) {\n    const g = DIG[t.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") put(buf, x + i * 4 + q, y + r, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const buf = S.buf, n = S.n, z = S.zoom, A = S.a, spf = S.spf;\n  const [base, three, lime, gold, white] = S.cols;\n  hsv(0.58 + S.hue, base);\n  hsv(0.86 + S.hue, three);\n  hsv(0.3 + S.hue, lime);\n  hsv(0.13 + S.hue, gold);\n  white[0] = white[1] = white[2] = 1;\n  buf.fill(0);\n  const X = (v) => X0 + (XS * v) / n, Y = (i) => H - 1 - (n - i) / z;\n  // The guides a = n/2, n, 3n/2, dotted on every other term.\n  for (let y = 0; y \u003c H; y++) {\n    const m = n - (H - 1 - y) * z;\n    if (m \u003c 1 || floor(m / z) % 2) continue;\n    for (const f of [0.5, 1, 1.5]) put(buf, round(X(f * m)), y, base, 0.3);\n  }\n  const first = max(1, ceil(n - (H - 1) * z) - 1), c = S.c;\n  for (let i = first + 1; i \u003c= n; i++) {\n    const lk = S.link[i], u = S.links, tint = lk === 2 ? base : lk === 3 ? three : lk * lk > A[i] ? white : lime;\n    for (let q = 0; q \u003c 3; q++) c[q] = base[q] * (1 - u) + tint[q] * u;\n    line(buf, round(X(A[i - 1])), round(Y(i - 1)), round(X(A[i])), round(Y(i)), c, 0.8 + 0.2 * u);\n  }\n  // Each prime: a gold tip and its value beside it.\n  let lastRow = -99;\n  for (let i = max(1, first); i \u003c= n; i++) {\n    const v = A[i];\n    if (v \u003c 2 || spf[v] !== v) continue;\n    const x = round(X(v)), y = round(Y(i));\n    put(buf, x, y, white, 1);\n    put(buf, x - 1, y, gold, 1);\n    put(buf, x + 1, y, gold, 1);\n    // A label that would touch the one above moves down, by 3 rows at most.\n    const w = String(v).length * 4 - 1, ly = max(y - 2, lastRow + 6);\n    if (x - 3 - w \u003c 0 || ly > y + 1) continue;\n    digits(buf, v, x - 3 - w, ly, gold, 0.9);\n    lastRow = ly;\n  }\n  put(buf, round(X(A[n])), H - 1, white, 1);\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","huygens-clocks":"// ===== Patternflow pattern =====\n// Title:   Huygens' Clocks\n// Family:  rhythm\n// Idea:    Two long pendulum clocks hang from one beam that can sway a little, each flashing as its escapement kicks it through the bottom of the swing and dropping that tick as a bar into its own lane of a falling record, so the two lanes start out ticking almost together, the beam rocks, and over six or seven swings the right clock's ticks slide until they fall exactly halfway between the left one's and the beam goes still: Huygens's anti-phase sympathy, or, with the clocks detuned past the lock, a slow slip of beats.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Huygens's odd sympathy of pendulum clocks (Christiaan Huygens, 1665), modelled as pendulums with an escapement kick on a moving support after Bennett, Schatz, Rockwood and Wiesenfeld (Huygens's clocks, Proc. R. Soc. A, 2002), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Detune=-1..1, Coupling=0..1\n//\n// Knob 1: Hue. Turns both clocks round the wheel together. At 0 the left clock and its lane are amber and the right one azure; at 0.5 the left is blue and the right orange-red.\n// Knob 2: Speed. How fast the model runs: half the knob in model seconds a second, so a swing takes 1 s at the opening 2, 10 s at 0.2 and 0.67 s at 3. The record falls 9 rows a model second and holds the last 6.4 swings.\n// Knob 3: Detune. The two clocks' own rates, 1 - 0.15 x knob and 1 + 0.15 x knob of the common rate, so at 1 the right clock runs 35% faster. At 0 they lock half a swing apart. At the opening coupling they still lock at 0.3 (rates 9% apart), the right clock's ticks a third of a swing after the left's (before them at -0.3), and the faster clock swings half as wide as the other; from about 0.33 the lock breaks and the two lanes' ticks slip round each other in beats, once in 13 s just past the edge and faster from there.\n// Knob 4: Coupling. How much each bob weighs against the beam, 0.4 x the square root of the knob: 0.098 at the opening 0.06, where the clocks come from a tenth of a swing apart to half a swing in 7 s. At 0 the beam is too heavy to move and the clocks keep their first offset for good; at 1 (0.4) they are half a swing apart within 3 s.\n// Buttons: Any tap holds the right pendulum at the end of its next swing to the right for 0.3 to 0.8 model seconds and lets it go, as the pattern does by itself every 24 model seconds, and the clocks find their way back.\n\n// Huygens noticed in 1665 that two of his pendulum clocks hung from the\n// same beam ended up swinging in opposite directions, and came back to it\n// after he disturbed one. Bennett, Schatz, Rockwood and Wiesenfeld rebuilt\n// the experiment in 2002 and explained it with a model of pendulums kept\n// going by escapement kicks, mounted on a support that can move. This\n// pattern runs a model of that kind; its numbers are mine, picked so the\n// lock comes within a few swings.\n//\n// In units of the rod length, with x the beam's sideways place and mu the\n// mass of one bob over the beam's:\n//\n//   theta_i'' = -w_i^2 sin(theta_i) - b theta_i' - x'' cos(theta_i)\n//   (1 + 2 mu) x'' + mu sum_i (theta_i'' cos(theta_i) - theta_i'^2 sin(theta_i))\n//       = -k x - c x'\n//\n// with b = 0.6 the pendulums' own damping, k = 4 and c = 5 the beam's\n// spring and damping, and w = 2 pi so a swing takes one model second. Each\n// time a pendulum passes the bottom going right its escapement kicks it,\n// theta' += 0.32, and the beam takes the recoil. That is the tick, and it\n// keeps the swing at about 0.17 radians, 9 or 10 LEDs either side.\n//\n// Swinging together, the two bobs push the beam back and forth and its\n// damping takes energy out of that motion. Swinging against each other\n// they push it equally both ways and it stays put, so that is the motion\n// that costs the clocks nothing, and the escapements keep it going while\n// the rest dies away. The beam's sway is drawn in the middle strip of the\n// record: a wobble while the clocks tick near together, a straight line\n// once they alternate.\n//\n// The clocks start from the same side, the right one let go 0.08 s after\n// the left. Each tick flashes the bob and drops a bar into that clock's\n// lane of the record below, where row y is the time (y - 70) / 9 model\n// seconds ago. Ticking together, the bars of the two lanes lie side by\n// side like the rungs of a ladder; at half a swing apart each bar of one\n// lane falls exactly between two of the other's.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, sqrt, sin, cos, PI, tanh } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// The model's constants: the common rate, the pendulums' damping, the\n// escapement's kick, the beam's spring and damping, and the time step.\nconst W0 = TAU, B = 0.6, EPS = 0.32, KB = 4, CB = 5, H_STEP = 1 / 600;\n// Drawing: pivots, rod length in LEDs, the record's top row and its pace.\nconst PX = [16, 48], PY = 3, LEN = 56, R0 = 70, VS = 9, BOB = 3.6;\nconst HUES = [0.11, 0.55];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, det: 0, mu: 0.1,\n    th: [0.19, 0.19], om: [0, 0], X: 0, V: 0, t: 0,\n    hold: 0.08, pending: 0, next: 24,\n    ticks: [[], []], flash: [0, 0],\n    hist: new Float32Array(256), hn: 0, ht: 0,\n    buf: new Float32Array(W * H * 3), c: [[0, 0, 0], [0, 0, 0]],\n  };\n}\n\nfunction step(S, h) {\n  const w0 = W0 * (1 - S.det / 2), w1 = W0 * (1 + S.det / 2), w = [w0, w1], mu = S.mu, th = S.th, om = S.om;\n  const held = S.hold > 0;\n  // The pendulums' forces apart from the beam, then the beam's acceleration\n  // with the pendulums' reaction solved in, then the pendulums'.\n  const f0 = -w[0] * w[0] * sin(th[0]) - B * om[0], f1 = -w[1] * w[1] * sin(th[1]) - B * om[1];\n  let num = -KB * S.X - CB * S.V, den = 1 + 2 * mu;\n  num -= mu * (f0 * cos(th[0]) - om[0] * om[0] * sin(th[0]));\n  den -= mu * cos(th[0]) * cos(th[0]);\n  if (!held) {\n    num -= mu * (f1 * cos(th[1]) - om[1] * om[1] * sin(th[1]));\n    den -= mu * cos(th[1]) * cos(th[1]);\n  }\n  const a = num / den;\n  S.V += a * h;\n  S.X += S.V * h;\n  const p0 = th[0], p1 = th[1], q1 = om[1];\n  om[0] += (f0 - a * cos(th[0])) * h;\n  th[0] += om[0] * h;\n  if (held) {\n    om[1] = 0;\n    S.hold -= h;\n  } else {\n    om[1] += (f1 - a * cos(th[1])) * h;\n    th[1] += om[1] * h;\n    // A hold waits for the end of a swing to the right.\n    if (S.pending > 0 && q1 > 0 && om[1] \u003c= 0) {\n      S.hold = S.pending;\n      S.pending = 0;\n    }\n  }\n  S.t += h;\n  const pr = [p0, p1];\n  for (let i = 0; i \u003c 2; i++) {\n    if (pr[i] \u003c 0 && th[i] >= 0 && om[i] > 0) {\n      om[i] += EPS;\n      S.V -= (mu / (1 + 2 * mu)) * EPS;\n      S.ticks[i].push(S.t);\n      if (S.ticks[i].length > 24) S.ticks[i].shift();\n      S.flash[i] = 1;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.det = 0.3 * cl(k[2] || 0, -1, 1);\n  S.mu = 0.4 * sqrt(cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  const b = input.btnPressed;\n  if (b && (b[0] || b[1] || b[2] || b[3])) S.pending = 0.3 + 0.5 * Math.random();\n  if (S.t >= S.next) {\n    S.next = S.t + 24;\n    S.pending = 0.45 + 0.3 * Math.random();\n  }\n  const sim = d * S.speed * 0.5;\n  let n = Math.ceil(sim / H_STEP);\n  const h = n > 0 ? sim / n : 0;\n  while (n-- > 0) {\n    step(S, h);\n    // The beam's place, one sample per half row of the record.\n    if (S.t >= S.ht) {\n      S.ht = S.t + 0.5 / VS;\n      S.hist[S.hn] = S.X;\n      S.hn = (S.hn + 1) % S.hist.length;\n    }\n  }\n  for (let i = 0; i \u003c 2; i++) S.flash[i] = max(0, S.flash[i] - sim * 5);\n}\n\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\n// A line one LED wide, each LED lit by its distance to the segment.\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  for (let y = max(0, floor(min(y0, y1)) - 1); y \u003c= min(H - 1, Math.ceil(max(y0, y1)) + 1); y++)\n    for (let x = max(0, floor(min(x0, x1)) - 1); x \u003c= min(W - 1, Math.ceil(max(x0, x1)) + 1); x++) {\n      const t = cl(((x - x0) * dx + (y - y0) * dy) / l2, 0, 1), ex = x0 + t * dx - x, ey = y0 + t * dy - y;\n      add(buf, x, y, c, a * cl(1.1 - sqrt(ex * ex + ey * ey), 0, 1));\n    }\n}\n\nfunction disc(buf, cx, cy, r, c, a) {\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const e = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      add(buf, x, y, c, a * cl(r + 0.5 - e, 0, 1));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, C = S.c, white = [1, 1, 1], warm = [1, 0.85, 0.65];\n  buf.fill(0);\n  hsv(S.hue + HUES[0], C[0]);\n  hsv(S.hue + HUES[1], C[1]);\n  const off = S.X * LEN;\n  // The beam, with a stud every 4 LEDs so its sway shows.\n  for (let x = 1; x \u003c W - 1; x++) {\n    const u = x - off, stud = u - 4 * floor(u / 4) \u003c 1 ? 0.3 : 0;\n    add(buf, x, 0, warm, 0.3);\n    add(buf, x, 1, warm, 0.5 + stud);\n    add(buf, x, 2, warm, 0.3);\n  }\n  // The record: two lanes, the ticks falling down them from the clocks, and\n  // between them the beam's swing over the same time.\n  for (let i = 0; i \u003c 2; i++) {\n    const x0 = PX[i] - 11, x1 = PX[i] + 11, c = C[i];\n    for (let y = R0; y \u003c H; y++) for (let x = x0; x \u003c= x1; x++) add(buf, x, y, c, 0.08);\n    // Each tick a bar two rows deep with a short glow above it, on the\n    // side of the present, falling at VS rows a second of model time.\n    for (const tk of S.ticks[i]) {\n      const yy = R0 + (S.t - tk) * VS;\n      if (yy > H + 1) continue;\n      const fade = 1 - (0.4 * (yy - R0)) / (H - R0);\n      for (let y = floor(yy) - 5; y \u003c= floor(yy) + 2; y++) {\n        if (y \u003c R0 || y >= H) continue;\n        const core = cl(min(y + 1, yy + 2) - max(y, yy), 0, 1), glow = y \u003c yy ? 0.45 * Math.exp((y + 1 - yy) / 1.6) : 0;\n        const a = (0.88 * core + glow * (1 - core)) * fade;\n        for (let x = x0; x \u003c= x1; x++) add(buf, x, y, c, a);\n      }\n    }\n  }\n  // The beam's sway down the middle strip, squashed so the largest sway at\n  // the start just fills it.\n  const nh = S.hist.length;\n  for (let y = R0; y \u003c H; y++) {\n    const back = round((y - R0) * 2);\n    if (back >= nh) break;\n    const xv = S.hist[(S.hn - 1 - back + nh * 4) % nh];\n    const px = 31.5 + 2.6 * tanh(xv * 90);\n    const ix = floor(px), fr = px - ix;\n    add(buf, ix, y, warm, 0.6 * (1 - fr));\n    add(buf, ix + 1, y, warm, 0.6 * fr);\n  }\n  // The two clocks.\n  for (let i = 0; i \u003c 2; i++) {\n    const px = PX[i] + off, th = S.th[i], bx = px + LEN * sin(th), by = PY + LEN * cos(th), f = S.flash[i];\n    line(buf, px, PY, bx, by, C[i], 0.6 + 0.4 * f);\n    disc(buf, bx, by, BOB, C[i], 1);\n    disc(buf, bx, by, BOB + 1.5 * f, white, 0.8 * f);\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n}\n","lempel-ziv":"// ===== Patternflow pattern =====\n// Title:   Lempel-Ziv\n// Family:  type\n// Idea:    An LZ77 encoder walks a text set in tiny capitals sixteen to a row, and at each step it lights the longest earlier stretch that the coming letters repeat, copies it forward letter by letter in a colour set by how far back it was (the hue climbs with the logarithm of the distance) and writes the one new letter after it in white, so the cumulative rhyme of the House That Jack Built turns into a white phrase and one long band per verse whose colour moves from azure to magenta as the verses grow, letters beyond the sliding window dim, and a counter at the foot keeps the bytes of text against the bytes of code.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: LZ77, the sliding-window universal compressor (Jacob Ziv and Abraham Lempel, A Universal Algorithm for Sequential Data Compression, 1977); texts: This Is the House That Jack Built and The Twelve Days of Christmas (traditional), Charles Dickens's A Tale of Two Cities (1859), Gertrude Stein's Sacred Emily (1913); 3 by 5 capitals drawn for this pattern; pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Window=0..1, Text=0..1\n//\n// Knob 1: Hue. Turns the distance colours round the wheel. At 0 a copy from 1 letter back is yellow-green, from 3 back green, 10 back cyan, 35 back (the second verse of the House copying the first) azure, 300 back violet and 2000 back rose; literals stay white.\n// Knob 2: Speed. At 2 a literal takes 0.03 s and a copy lights its source for 0.09 s and then copies 143 letters a second, so the first verse of the House is written in 1.7 s and all 1970 letters in 25 s, after which the page holds for 3 s and starts again; everything goes as the knob, ten times slower at 0.2.\n// Knob 3: Window. How far back the encoder may look, shrinking as the knob turns: 4096 letters at 0, 1024 at a quarter, 256 at a half, 32 at three quarters and 8 at 1. Letters further back than the window dim. The House codes to 371 bytes at 4096 (19% of its 1970), 345 at 1024, where every verse is still in reach and the distance field is 2 bits shorter, 846 at 256, 1967 at 32, and 3114 at 8, more than the text.\n// Knob 4: Text. This Is the House That Jack Built below 0.25, Stein's rose line (35 letters, ten tokens, one of them a copy of 23 letters from 10 back) to 0.5, The Twelve Days of Christmas (2357 letters, 154 tokens) to 0.75, then the opening of A Tale of Two Cities (416 letters, 96 tokens, 81%).\n\n// LZ77 reads the text once from the front. At each position it looks back\n// through the window, the last letters it has already passed, for the\n// longest run that matches the letters coming next, and sends one token: how\n// far back that run starts, how long it is, and the one letter after it. The\n// decoder rebuilds the text by copying length letters from distance back,\n// a letter at a time, so a run may overlap itself: in Stein's line, from the\n// O of the second ROSE the encoder copies 23 letters from 10 back, OSE IS A\n// ROSE IS A ROSE, reading letters it is itself writing. A text that repeats\n// itself turns into a few long copies; a text that does not turns into short\n// ones and literals.\n//\n// Here the page is 16 letters a row, each letter 3 by 5 LEDs on a pitch of\n// 4 by 6, 20 rows on the panel and the page scrolling up as it fills. Every\n// letter keeps the token that wrote it: white for the literal, and for a copy\n// a hue from the logarithm of the distance, so all the letters one verse of\n// the House copies from the verse before take the same colour, and a verse\n// reads as a white phrase and a long band. The counter at the foot is the\n// plain text in bytes, an arrow, the tokens in bytes (each token log2 W bits\n// of distance, 8 of length and 8 for the letter) and the ratio. With a small\n// window the code comes out longer than the text.\n\nconst W = 64, H = 128, N = W * H, COLS = 16, ROWS = 20, MAXLEN = 255, LOOK = 0.18, STEP = 0.014, LIT = 0.06;\nconst { floor, min, max, round, log2, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- 3 by 5 capitals, five rows of three bits each, the left LED the\n// high bit.\nconst FONT = {\n  A: \"25755\", B: \"65656\", C: \"34443\", D: \"65556\", E: \"74647\", F: \"74644\", G: \"34553\",\n  H: \"55755\", I: \"72227\", J: \"11152\", K: \"55655\", L: \"44447\", M: \"57755\", N: \"65555\",\n  O: \"25552\", P: \"65644\", Q: \"25573\", R: \"65655\", S: \"34216\", T: \"72222\", U: \"55557\",\n  V: \"55552\", W: \"55775\", X: \"55255\", Y: \"55222\", Z: \"71247\",\n  0: \"75557\", 1: \"26227\", 2: \"61247\", 3: \"61216\", 4: \"55711\", 5: \"74616\", 6: \"34757\",\n  7: \"71122\", 8: \"75757\", 9: \"75716\",\n  \".\": \"00002\", \",\": \"00024\", \"'\": \"22000\", \"-\": \"00700\", \";\": \"02024\", \"%\": \"51245\", \">\": \"42124\",\n};\n\n// ---- The texts.\nfunction house() {\n  const noun = [\"THE HOUSE THAT JACK BUILT.\", \"THE MALT\", \"THE RAT\", \"THE CAT\", \"THE DOG\", \"THE COW WITH THE CRUMPLED HORN\", \"THE MAIDEN ALL FORLORN\", \"THE MAN ALL TATTERED AND TORN\", \"THE PRIEST ALL SHAVEN AND SHORN\", \"THE COCK THAT CROWED IN THE MORN\", \"THE FARMER SOWING HIS CORN\"];\n  const verb = [\"\", \"THAT LAY IN\", \"THAT ATE\", \"THAT KILLED\", \"THAT WORRIED\", \"THAT TOSSED\", \"THAT MILKED\", \"THAT KISSED\", \"THAT MARRIED\", \"THAT WAKED\", \"THAT KEPT\"];\n  const out = [];\n  for (let k = 0; k \u003c noun.length; k++) {\n    let v = \"THIS IS \" + noun[k];\n    for (let j = k; j >= 1; j--) v += \", \" + verb[j] + \" \" + noun[j - 1];\n    out.push(v);\n  }\n  return out.join(\" \");\n}\nfunction twelveDays() {\n  const ord = [\"FIRST\", \"SECOND\", \"THIRD\", \"FOURTH\", \"FIFTH\", \"SIXTH\", \"SEVENTH\", \"EIGHTH\", \"NINTH\", \"TENTH\", \"ELEVENTH\", \"TWELFTH\"];\n  const gift = [\"A PARTRIDGE IN A PEAR TREE.\", \"TWO TURTLE DOVES,\", \"THREE FRENCH HENS,\", \"FOUR CALLING BIRDS,\", \"FIVE GOLD RINGS,\", \"SIX GEESE A-LAYING,\", \"SEVEN SWANS A-SWIMMING,\", \"EIGHT MAIDS A-MILKING,\", \"NINE LADIES DANCING,\", \"TEN LORDS A-LEAPING,\", \"ELEVEN PIPERS PIPING,\", \"TWELVE DRUMMERS DRUMMING,\"];\n  const out = [];\n  for (let k = 0; k \u003c 12; k++) {\n    let v = \"ON THE \" + ord[k] + \" DAY OF CHRISTMAS MY TRUE LOVE GAVE TO ME \";\n    for (let j = k; j >= 1; j--) v += gift[j] + \" \";\n    out.push(v + (k ? \"AND \" : \"\") + gift[0]);\n  }\n  return out.join(\" \");\n}\nconst TEXTS = [\n  house(),\n  \"ROSE IS A ROSE IS A ROSE IS A ROSE.\",\n  twelveDays(),\n  \"IT WAS THE BEST OF TIMES, IT WAS THE WORST OF TIMES, IT WAS THE AGE OF WISDOM, IT WAS THE AGE OF FOOLISHNESS, IT WAS THE EPOCH OF BELIEF, IT WAS THE EPOCH OF INCREDULITY, IT WAS THE SEASON OF LIGHT, IT WAS THE SEASON OF DARKNESS, IT WAS THE SPRING OF HOPE, IT WAS THE WINTER OF DESPAIR, WE HAD EVERYTHING BEFORE US, WE HAD NOTHING BEFORE US, WE WERE ALL GOING DIRECT TO HEAVEN, WE WERE ALL GOING DIRECT THE OTHER WAY\",\n];\n\n// The longest match for text[p...] that starts within win letters back,\n// the nearest one among equals. It may run on past p into the letters it\n// is copying, and it leaves at least one letter for the literal.\nfunction longest(t, p, win) {\n  let bestL = 0, bestD = 0;\n  const lim = min(MAXLEN, t.length - 1 - p);\n  for (let d = 1; d \u003c= min(win, p); d++) {\n    const s = p - d;\n    let l = 0;\n    while (l \u003c lim && t.charCodeAt(s + l) === t.charCodeAt(p + l)) l++;\n    if (l > bestL) {\n      bestL = l;\n      bestD = d;\n      if (l === lim) break;\n    }\n  }\n  return [bestD, bestL];\n}\n\nexport function setup(params) {\n  params.s = { ti: -1, buf: new Float32Array(N * 3) };\n}\n\nfunction restart(S, ti) {\n  const n = TEXTS[ti].length;\n  S.ti = ti;\n  S.text = TEXTS[ti];\n  S.kind = new Uint8Array(n);\n  S.dist = new Uint16Array(n);\n  S.born = new Float32Array(n);\n  S.lit = new Float32Array(n);\n  S.litD = new Uint16Array(n);\n  S.p = 0;\n  S.tok = null;\n  S.tokens = 0;\n  S.bits = 0;\n  S.top = 0;\n  S.scroll = 0;\n  S.t = 0;\n  S.done = -1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.wbits = round(12 - 9 * cl(k[2] || 0, 0, 1));\n  const ti = min(3, floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 4));\n  if (ti !== S.ti) restart(S, ti);\n  S.t += d;\n  const f = S.speed, t = S.text, n = t.length;\n  // A lit source letter fades over about 0.4 s once it has been read.\n  const fade = exp(-d / 0.4);\n  for (let i = 0; i \u003c n; i++) if (S.lit[i] > 0) S.lit[i] *= fade;\n  let budget = d * f;\n  while (budget > 0) {\n    if (S.p >= n) {\n      // The page holds for 3 s, then starts over.\n      if (S.done \u003c 0) S.done = S.t;\n      if (S.t - S.done > 3) restart(S, ti);\n      break;\n    }\n    if (!S.tok) {\n      const [dist, len] = longest(t, S.p, 1 \u003c\u003c S.wbits);\n      // Time in units of the knob: LOOK to show the source, STEP a copied\n      // letter, LIT for the literal.\n      S.tok = { dist, len, j: 0, look: len ? LOOK : 0, lit: LIT, carry: 0 };\n      S.tokens++;\n      S.bits += S.wbits + 16;\n      for (let i = S.p - dist; len && i \u003c min(S.p, S.p - dist + len); i++) {\n        S.lit[i] = 1;\n        S.litD[i] = dist;\n      }\n    }\n    const T = S.tok;\n    if (T.look > 0) {\n      const use = min(budget, T.look);\n      T.look -= use;\n      budget -= use;\n      continue;\n    }\n    if (T.j \u003c T.len) {\n      T.carry += budget;\n      budget = 0;\n      while (T.carry >= STEP && T.j \u003c T.len) {\n        T.carry -= STEP;\n        const src = S.p - T.dist;\n        S.kind[S.p] = 2;\n        S.dist[S.p] = T.dist;\n        S.born[S.p] = S.t;\n        S.lit[src] = 1.6;\n        S.litD[src] = T.dist;\n        S.p++;\n        T.j++;\n      }\n      if (T.j >= T.len) budget = T.carry;\n      continue;\n    }\n    const use = min(budget, T.lit);\n    T.lit -= use;\n    budget -= use;\n    if (T.lit \u003c= 0) {\n      S.kind[S.p] = 1;\n      S.born[S.p] = S.t;\n      S.p++;\n      S.tok = null;\n    }\n  }\n  // Scroll so the row being written is on the page.\n  const row = floor(min(S.p, n - 1) / COLS);\n  if (row >= S.top + ROWS) S.top = row - ROWS + 1;\n  S.scroll += (S.top * 6 - S.scroll) * min(1, d * 10);\n}\n\nfunction put(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] = max(buf[o], c[0] * a);\n  buf[o + 1] = max(buf[o + 1], c[1] * a);\n  buf[o + 2] = max(buf[o + 2], c[2] * a);\n}\n\nfunction glyph(buf, ch, x, y, c, a, y1) {\n  const g = FONT[ch];\n  if (!g) return;\n  for (let r = 0; r \u003c 5; r++) {\n    if (y + r >= y1) break;\n    const bits = g.charCodeAt(r) - 48;\n    for (let b = 0; b \u003c 3; b++) if (bits & (4 >> b)) put(buf, x + b, y + r, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.text) return;\n  const buf = S.buf, t = S.text, win = 1 \u003c\u003c S.wbits, white = [1, 1, 1];\n  buf.fill(0);\n  const hueOf = (dist) => S.hue + 0.25 + 0.065 * log2(dist);\n  const r0 = max(0, floor(S.scroll / 6)), end = S.done >= 0 ? cl(1 - (S.t - S.done - 2.5) / 0.5, 0, 1) : 1;\n  let above = 0, aboveD = 0;\n  for (let i = 0; i \u003c S.p; i++) if (S.lit[i] > 0.05 && floor(i / COLS) \u003c r0 && S.lit[i] > above) {\n    above = S.lit[i];\n    aboveD = S.litD[i];\n  }\n  for (let i = r0 * COLS; i \u003c min(t.length, (r0 + ROWS + 1) * COLS); i++) {\n    const x = (i % COLS) * 4, y = floor(i / COLS) * 6 - round(S.scroll);\n    if (y >= 120 || y + 5 \u003c 0) continue;\n    const lit = S.lit[i];\n    // A source letter's cell fills with the copy's colour while it is read.\n    if (lit > 0.05 && i \u003c S.p) {\n      const c = hsv(hueOf(S.litD[i]), 0.9, 1);\n      for (let yy = y; yy \u003c min(120, y + 6); yy++) for (let xx = x; xx \u003c x + 4; xx++) put(buf, xx, yy, c, min(0.45, 0.3 * lit) * end);\n    }\n    if (i >= S.p) continue;\n    const ch = t[i], age = S.t - S.born[i], flash = max(0, 1 - age / 0.35);\n    const inWin = S.p - i \u003c= win ? 1 : 0.32;\n    let c;\n    if (S.kind[i] === 2) {\n      const h = hsv(hueOf(S.dist[i]), 0.72, 1);\n      c = [h[0] + (1 - h[0]) * 0.4 * flash, h[1] + (1 - h[1]) * 0.4 * flash, h[2] + (1 - h[2]) * 0.4 * flash];\n    } else c = [0.85, 0.85, 0.85];\n    const a = (lit > 0.05 ? 1 : inWin) * end;\n    glyph(buf, ch, x, y, c, a, 120);\n  }\n  // A source above the top edge lights the edge in its colour.\n  if (above > 0.05) {\n    const c = hsv(hueOf(aboveD), 0.9, 1);\n    for (let x = 0; x \u003c W; x++) put(buf, x, 0, c, min(1, above) * 0.8 * end);\n  }\n  // The cursor: a bar under the next letter.\n  if (S.p \u003c t.length) {\n    const x = (S.p % COLS) * 4, y = floor(S.p / COLS) * 6 - round(S.scroll) + 5;\n    if (y \u003c 120) for (let b = 0; b \u003c 3; b++) put(buf, x + b, y, white, 0.7);\n  }\n  // The counter: plain bytes > coded bytes, and the ratio.\n  const plain = S.p, coded = Math.ceil(S.bits / 8), pct = plain ? round((100 * coded) / plain) : 0;\n  const left = plain + \">\" + coded, right = pct + \"%\";\n  for (let j = 0; j \u003c left.length; j++) glyph(buf, left[j], j * 4, 122, left[j] === \">\" ? [0.5, 0.5, 0.5] : white, 0.8, 128);\n  const pc = hsv(S.hue + 0.25 + 0.065 * 8, 0.6, 1);\n  for (let j = 0; j \u003c right.length; j++) glyph(buf, right[j], W - (right.length - j) * 4 + 1, 122, pc, 0.9, 128);\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","mobius-type":"// ===== Patternflow pattern =====\n// Title:   Möbius Type\n// Family:  type\n// Idea:    A paper band stands up the height of the panel and turns slowly in 3D with a line of capitals printed along its middle; with one or three half-twists the band has one side, so the sentence THE OTHER SIDE OF THIS LINE IS THIS LINE runs round twice before it meets its own start and every piece of the band carries ink on its back as well, while with two or four the band has two sides, THIS LINE HAS A BACK closes after one lap and the back is bare paper, and a bright reading mark runs along the line so the eye can follow it round.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the one-sided band (August Ferdinand Möbius and Johann Benedict Listing, 1858), capitals on a 5 by 7 grid drawn for this pattern, pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Twists=1..4, Paper=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel. At 0 it is azure, 0.25 purple, 0.5 orange, 0.75 green; the paper stays grey and the reading mark white.\n// Knob 2: Speed. At 2 the band turns once round the upright in 24 s, 15 degrees a second, and the reading mark moves on 2.5 letters a second, so it takes 16.4 s to read the 41 letters of the one-sided line twice round and 8.4 s for the 21 of the two-sided one. At 0.2 both go ten times slower, at 3 half as fast again.\n// Knob 3: Twists. Half-twists in the band, to the nearest whole number: 1 at the opening, Möbius's band, one side and one edge; 2, a full twist, two sides and two edges linked once; 3, one side again, its one edge tied in a trefoil; 4, two sides.\n// Knob 4: Paper. How thin the paper is. At 0 it is card and only the face toward you shows. At 1 the paper itself is 45% darker and the far face's letters show through it mirrored, at about two thirds the light of the ink facing you: on a two-sided band the bare back shows the line from behind, on a one-sided band the other lap's letters lie mirrored between the letters facing you.\n\n// The band's middle line is a stadium standing in the plane of the panel:\n// two uprights 60 LEDs long at x = +-19 joined by half circles of radius 19,\n// 239.4 LEDs round. A point on the band is c(s) + v d(s), s the arc length\n// along the middle and v from -12 to 12 across. The direction across, d,\n// turns about the middle line: d = cos(a) N + sin(a) Z, N the outward\n// normal in the plane, Z out of it, and a = pi/2 + k pi s / P for k\n// half-twists in the length P, so at the start of the line, halfway up the\n// right upright, the band stands straight out of the plane. After one lap d has turned by k pi, so with\n// k odd it comes back as -d: the face you set out on has become the other\n// one, and only a second lap brings you back to your start. That is the one\n// side of Möbius's band, and the line printed along it is 2P long, ink on\n// both faces of every piece of paper. With k even d comes back as itself,\n// the line closes after one lap and the back is a second face of its own.\n//\n// Seen from the face whose normal is n = ds x dv, the letters stand up\n// along +v. Seen from the other face of the same piece of paper the line\n// is the next lap, s + P along with v turned over, so its letters stand up\n// the right way to a reader on that side. Through thin paper the far face's\n// ink shows from behind, as a mirror image.\n//\n// The picture is drawn by splatting: 640 by 56 points of the band are\n// turned, put in perspective from a camera 260 LEDs away, and kept only\n// where they are nearest the camera; an LED is the mean of the near points\n// that land in it, so the letters are box-filtered where the paper is seen\n// at a slant. Which face is toward the camera decides which lap's letters\n// that point shows, and the light falls on that face.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, max, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst R = 19, D = 30, HW = 12, P = 4 * D + 2 * PI * R;\nconst NS = 640, NV = 56, DC = 260, TILT = 0.24, EPS = 1.6;\nconst CAP = 0.7 * 2 * HW, HUE0 = 0.57;\nconst LINES = [\"THIS LINE HAS A BACK \", \"THE OTHER SIDE OF THIS LINE IS THIS LINE \"];\n// The light, from the upper left and in front, in camera space.\nconst LX = -0.45, LY = 0.55, LZ = 0.7, LN = sqrt(LX * LX + LY * LY + LZ * LZ);\n\n// Capitals on a 5 by 7 grid, rows from the top.\nconst GLYPHS = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\",\n  B: \"####. #...# #...# ####. #...# #...# ####.\",\n  C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\",\n  E: \"##### #.... #.... ####. #.... #.... #####\",\n  F: \"##### #.... #.... ####. #.... #.... #....\",\n  H: \"#...# #...# #...# ##### #...# #...# #...#\",\n  I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\",\n  L: \"#.... #.... #.... #.... #.... #.... #####\",\n  N: \"#...# ##..# ##..# #.#.# #..## #..## #...#\",\n  O: \".###. #...# #...# #...# #...# #...# .###.\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\",\n  T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\",\n};\n// Each line as 35 dots a letter, 0 for a space.\nconst BITS = LINES.map((line) => {\n  const b = new Uint8Array(line.length * 35);\n  for (let i = 0; i \u003c line.length; i++) {\n    const g = GLYPHS[line[i]];\n    if (!g) continue;\n    const rows = g.split(\" \");\n    for (let r = 0; r \u003c 7; r++) for (let c = 0; c \u003c 5; c++) b[i * 35 + r * 5 + c] = rows[r][c] === \"#\" ? 1 : 0;\n  }\n  return b;\n});\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The middle line at arc length s: position, unit tangent, curvature.\nfunction stadium(s, o) {\n  let x, y, tx, ty, k = 0;\n  if (s \u003c D) [x, y, tx, ty] = [R, s, 0, 1];\n  else if (s \u003c D + PI * R) {\n    const a = (s - D) / R;\n    [x, y, tx, ty, k] = [R * cos(a), D + R * sin(a), -sin(a), cos(a), 1 / R];\n  } else if (s \u003c 3 * D + PI * R) [x, y, tx, ty] = [-R, D - (s - D - PI * R), 0, -1];\n  else if (s \u003c 3 * D + 2 * PI * R) {\n    const a = PI + (s - 3 * D - PI * R) / R;\n    [x, y, tx, ty, k] = [R * cos(a), -D + R * sin(a), -sin(a), cos(a), 1 / R];\n  } else [x, y, tx, ty] = [R, -D + (s - 3 * D - 2 * PI * R), 0, 1];\n  o[0] = x; o[1] = y; o[2] = tx; o[3] = ty; o[4] = k;\n}\n\n// The row of the 5 by 7 grid at each of the NV steps across, read with the\n// letters standing up along +v (ROWS[0]) or along -v (ROWS[1]); -1 off the\n// letters.\nconst ROWS = [0, 1].map((flip) => {\n  const r = new Int32Array(NV);\n  for (let j = 0; j \u003c NV; j++) {\n    const v = (-HW + ((j + 0.5) * 2 * HW) / NV) * (flip ? -1 : 1), row = floor((CAP / 2 - v) / (CAP / 7));\n    r[j] = row >= 0 && row \u003c 7 ? row * 5 : -1;\n  }\n  return r;\n});\n\n// For each of the NS stations along the band: the middle point c, the\n// direction across d and the normal n0 + v n1 (12 numbers), for k\n// half-twists; and where the line's letters fall on each face there.\nfunction build(k) {\n  const g = new Float32Array(NS * 12), st = [0, 0, 0, 0, 0], da = (k * PI) / P;\n  const odd = k % 2, len = LINES[odd].length, adv = (odd ? 2 * P : P) / len;\n  const cell = [new Int32Array(NS), new Int32Array(NS)], letter = [new Int32Array(NS), new Int32Array(NS)];\n  for (let i = 0; i \u003c NS; i++) {\n    const s = ((i + 0.5) * P) / NS;\n    stadium(s, st);\n    const [x, y, tx, ty, kap] = st, nx = ty, ny = -tx, a = PI / 2 + da * s, ca = cos(a), sa = sin(a);\n    const dx = ca * nx, dy = ca * ny, dz = sa;\n    // ds at v is T + v (kap cos a T + a' (-sin a N + cos a Z)), dv is d.\n    const ax = kap * ca * tx - da * sa * nx, ay = kap * ca * ty - da * sa * ny, az = da * ca;\n    const o = i * 12;\n    g[o] = x; g[o + 1] = y; g[o + 2] = 0;\n    g[o + 3] = dx; g[o + 4] = dy; g[o + 5] = dz;\n    g[o + 6] = ty * dz; g[o + 7] = -tx * dz; g[o + 8] = tx * dy - ty * dx;\n    g[o + 9] = ay * dz - az * dy; g[o + 10] = az * dx - ax * dz; g[o + 11] = ax * dy - ay * dx;\n    // Lap 0 is the line at s on the face n points to; lap 1 is s + P,\n    // on the other face, and only a one-sided band has it.\n    for (let lap = 0; lap \u003c 2; lap++) {\n      const u = (s + lap * P) / adv, li = floor(u) % len, col = floor((u - floor(u)) * 6 - 0.5);\n      letter[lap][i] = li;\n      cell[lap][i] = col >= 0 && col \u003c 5 && (odd || !lap) ? li * 35 + col : -1;\n    }\n  }\n  return { g, cell, letter, odd, len };\n}\n\nexport function setup(params) {\n  params.s = {\n    k: 1, geo: build(1), view: new Float32Array(NS * 12), lam: new Float32Array(NS * 2), turn: -0.65, read: 0, hue: 0, paper: 0.06,\n    z: new Float32Array(N), pix: new Int32Array(NS * NV), zs: new Float32Array(NS * NV), acc: new Float32Array(N * 4), ink: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1] == null ? 2 : kv[1], 0.2, 3);\n  const k = round(cl(kv[2] == null ? 1 : kv[2], 1, 4));\n  S.paper = cl(kv[3] == null ? 0.06 : kv[3], 0, 1);\n  if (k !== S.k) {\n    S.k = k;\n    S.geo = build(k);\n  }\n  S.turn += (d * speed * 2 * PI) / 48;\n  S.read += d * speed * 1.25;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { g, cell, letter, odd, len } = S.geo, bits = BITS[odd];\n  const zb = S.z, acc = S.acc, vw = S.view, lam = S.lam, pix = S.pix, zs = S.zs, ink = hsv(S.hue + HUE0, 0.8, 1, S.ink);\n  // Camera: turn about the upright, then tip the top toward the camera by\n  // TILT, so the band is seen a little from above.\n  const cp = cos(S.turn), sp = sin(S.turn), ct = cos(TILT), stl = sin(TILT);\n  const m00 = cp, m02 = sp, m10 = sp * stl, m11 = ct, m12 = -cp * stl, m20 = -sp * ct, m21 = stl, m22 = cp * ct;\n  for (let i = 0; i \u003c NS * 12; i += 3) {\n    const x = g[i], y = g[i + 1], z = g[i + 2];\n    vw[i] = m00 * x + m02 * z;\n    vw[i + 1] = m10 * x + m11 * y + m12 * z;\n    vw[i + 2] = m20 * x + m21 * y + m22 * z;\n  }\n  // The light on each face at each station.\n  for (let i = 0; i \u003c NS; i++) {\n    const o = i * 12, nx = vw[o + 6], ny = vw[o + 7], nz = vw[o + 8];\n    const l = (nx * LX + ny * LY + nz * LZ) / (LN * sqrt(nx * nx + ny * ny + nz * nz) + 1e-9);\n    lam[i * 2] = max(0, l);\n    lam[i * 2 + 1] = max(0, -l);\n  }\n  zb.fill(-1e9);\n  acc.fill(0);\n  const dv = (2 * HW) / NV;\n  for (let i = 0, q = 0; i \u003c NS; i++) {\n    const o = i * 12, cx = vw[o], cy = vw[o + 1], cz = vw[o + 2], dx = vw[o + 3], dy = vw[o + 4], dz = vw[o + 5];\n    for (let j = 0; j \u003c NV; j++, q++) {\n      const v = -HW + (j + 0.5) * dv, Z = cz + v * dz, f = DC / (DC - Z);\n      const px = floor(32 + (cx + v * dx) * f), py = floor(64 - (cy + v * dy) * f);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) {\n        pix[q] = -1;\n        continue;\n      }\n      const p = py * W + px;\n      pix[q] = p;\n      zs[q] = Z;\n      if (Z > zb[p]) zb[p] = Z;\n    }\n  }\n  const show = S.paper, thin = 1 - 0.45 * show, pr = 0.9 * thin, pg = 0.9 * thin, pb = 0.95 * thin;\n  const rowP = ROWS[0], rowN = ROWS[1];\n  for (let i = 0, q = 0; i \u003c NS; i++) {\n    const o = i * 12, cx = vw[o], cy = vw[o + 1], dx = vw[o + 3], dy = vw[o + 4];\n    const c0 = cell[0][i], c1 = cell[1][i];\n    for (let j = 0; j \u003c NV; j++, q++) {\n      const p = pix[q];\n      if (p \u003c 0) continue;\n      const Z = zs[q];\n      if (Z \u003c zb[p] - EPS) continue;\n      // Which face looks at the camera: the line's lap 0 is on the face\n      // n points to, lap 1 (turned over) on the other.\n      const v = -HW + (j + 0.5) * dv;\n      const nx = vw[o + 6] + v * vw[o + 9], ny = vw[o + 7] + v * vw[o + 10], nz = vw[o + 8] + v * vw[o + 11];\n      const front = nx * -(cx + v * dx) + ny * -(cy + v * dy) + nz * (DC - Z) >= 0;\n      const l = lam[i * 2 + (front ? 0 : 1)];\n      const nc = front ? c0 : c1, nr = front ? rowP[j] : rowN[j], fc = front ? c1 : c0, fr = front ? rowN[j] : rowP[j];\n      const near = nc >= 0 && nr >= 0 ? bits[nc + nr] : 0;\n      // The far face's ink seen through the paper, mirrored.\n      const far = !near && fc >= 0 && fr >= 0 ? bits[fc + fr] : 0;\n      const q4 = p * 4;\n      acc[q4] += 1;\n      if (near) {\n        const il = 0.42 + 0.58 * l, h = glow(S.read, letter[front ? 0 : 1][i], len), a = il * (1 - h), w = il * h;\n        acc[q4 + 1] += ink[0] * a + w;\n        acc[q4 + 2] += ink[1] * a + w;\n        acc[q4 + 3] += ink[2] * a + w;\n      } else {\n        const pl = 0.09 + 0.3 * l, sh = far * show, il = (0.26 + 0.4 * l) * sh, a = pl * (1 - sh);\n        acc[q4 + 1] += pr * a + ink[0] * il;\n        acc[q4 + 2] += pg * a + ink[1] * il;\n        acc[q4 + 3] += pb * a + ink[2] * il;\n      }\n    }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const n = acc[p * 4], q4 = p * 4;\n    if (n > 0) display.setPixel(p % W, floor(p / W), round(cl(acc[q4 + 1] / n, 0, 1) * 255), round(cl(acc[q4 + 2] / n, 0, 1) * 255), round(cl(acc[q4 + 3] / n, 0, 1) * 255));\n    else display.setPixel(p % W, floor(p / W), 0, 0, 0);\n  }\n}\n\n// The reading mark: white on the letter it has reached, fading over the\n// three behind it.\nfunction glow(read, li, len) {\n  let u = (read - li) % len;\n  if (u \u003c 0) u += len;\n  return u \u003c 4 ? (1 - u / 4) ** 1.5 : 0;\n}\n","mushroom-billiard":"// ===== Patternflow pattern =====\n// Title:   Mushroom Billiard\n// Family:  particle\n// Idea:    A mushroom-shaped billiard stands up the panel, a half disc of radius 30 on top of a straight stem that runs down to the floor, and 360 balls bounce in it with short trails, gold where a ball's chord passes the cap's centre further off than half the stem's width, so that it circles the cap for ever tangent to its caustic and never finds the way down, and blue for every other ball, which wanders the stem and the cap alike, the two kinds parted exactly by that one distance.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: mushroom billiards (Leonid Bunimovich, Mushrooms and other billiards with divided phase space, Chaos 11, 2001), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Stem=0.3..0.9, Trail=0..1\n//\n// Knob 1: Hue. Turns both kinds round the wheel together. At 0 the regular balls run from amber on the caustics just outside the border to lemon on the ones nearest the rim, and the chaotic ones are azure; at 0.5 the regular balls are blue and the chaotic ones orange.\n// Knob 2: Speed. At 2 a ball flies 40 LEDs a second, so one going straight down would run the stem's 95 rows in 2.4 s; at 0.2 it flies 4 and at 3, 60. In a two-minute run at 2 every chaotic ball went down the stem and no regular one did, its |L| drifting by less than a trillionth of an LED.\n// Knob 3: Stem. The stem's half width as a share of the cap's radius: 9 LEDs (an 18 LED stem) at the opening 0.3, 18 at 0.6, 27 at 0.9, where the cap is left only a 3 LED brim each side. The border moves with it, and a regular ball whose caustic is now inside it turns blue at once and will find the stem; one that the narrower stem shuts out turns gold.\n// Knob 4: Trail. How long a path stays lit. At the opening 0.06 a ball draws a streak about 5 LEDs long; at 1 a path fades over 1.55 s, too faint to see alone, and the paths add up to a haze in which the regular balls' chords make a gold band round the rim that never comes inside the dotted border.\n// Buttons: K1 tap throws every ball again, two in five regular, each kind spread evenly over its own part of the table's phase space.\n\n// A ball in a disc keeps the distance L from the centre to the line it\n// flies along: a bounce off the circle turns its heading but not that line's\n// distance, so every chord is tangent to one circle of radius |L|, its\n// caustic. A bounce off a mirror through the centre turns L into -L. The cap\n// here is a half disc whose flat side is such a mirror, so in the cap |L| is\n// kept too. The stem hangs from the middle of the flat side, |x| \u003c a.\n//\n// Leonid Bunimovich saw what that does. A ball's line meets the flat side\n// at a distance |L| / |sin phi| from the centre, never closer than |L|. If\n// |L| > a it never meets the opening, never goes down the stem, and circles\n// the cap for ever: a regular, integrable orbit. If |L| \u003c a the lines turn\n// round from bounce to bounce and sooner or later one crosses the opening;\n// down in the stem the walls and the floor scatter it, and it comes back up\n// with a new L that is again smaller than a, since it came up through the\n// opening. Those balls are chaotic and wander everywhere. The phase space is\n// split in two by the one number |L| = a: a sharp border, with no chains of\n// smaller islands round the regular part as most billiards with both kinds\n// of motion have.\n//\n// The kind of a ball is decided by exactly that: in the cap and |L| > a is\n// regular, anything else is chaotic. The balls start two in five regular,\n// spread evenly over the cap's positions and headings with |L| > a, and the\n// rest spread evenly over the positions and headings of the whole table\n// with |L| \u003c a in the cap, so each kind starts in its own invariant measure\n// and the picture has nothing left to settle into. Every bounce is worked out exactly: the\n// arc, the flat underside of the cap on both sides of the stem, the stem's\n// walls and its floor, each a mirror.\n\nconst W = 64, H = 128, N = W * H;\nconst CX = 32, CY = 31.5, R = 30, HS = 95, EPS = 1e-9;\nconst { min, max, floor, ceil, sqrt, exp, cos, sin, abs, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// 360 balls, two in five regular at a throw. VEL LEDs a second per unit of\n// Speed. The table's outline and the dotted border circle |L| = a in the\n// cap sit just above the 24/255 an LED needs to count as lit.\nconst NB = 360, REG = 0.4, VEL = 20;\nconst RIM = 0.11, BORDER = 0.12;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// Inside the table, at least m from its walls (m \u003c 0: within -m outside).\nfunction inside(a, x, y, m) {\n  if (y >= 0) return x * x + y * y \u003c= (R - m) * (R - m) && (y >= m || abs(x) \u003c= a - m);\n  return y >= -HS + m && abs(x) \u003c= a - m;\n}\n\n// Where along (dx, dy) a ball at (x, y) meets the next wall, and the\n// wall's normal there. The ball's own y >= 0 means it is in the cap.\nconst HIT = [0, 0, 0];\nfunction hit(a, x, y, dx, dy) {\n  let t = Infinity, nx = 0, ny = 0;\n  // The arc: the far root of |p + t d| = R, landing on the upper half.\n  const b = x * dx + y * dy, c = x * x + y * y - R * R, d = b * b - c;\n  if (d >= 0) {\n    const u = -b + sqrt(d);\n    if (u > EPS && y + u * dy >= 0) (t = u), (nx = x + u * dx), (ny = y + u * dy);\n  }\n  if (dy \u003c 0) {\n    // The cap's flat underside, a \u003c= |x| \u003c= R on the line y = 0.\n    if (y >= 0) {\n      const u = -y / dy, hx = abs(x + u * dx);\n      if (u > EPS && u \u003c t && hx >= a) (t = u), (nx = 0), (ny = 1);\n    }\n    // The floor of the stem.\n    const u = (-HS - y) / dy;\n    if (u > EPS && u \u003c t && abs(x + u * dx) \u003c= a) (t = u), (nx = 0), (ny = 1);\n  }\n  // The stem's walls, x = +-a below the flat side.\n  if (dx !== 0) {\n    const u = ((dx > 0 ? a : -a) - x) / dx, hy = y + u * dy;\n    if (u > EPS && u \u003c t && hy \u003c= 0 && hy >= -HS) (t = u), (nx = 1), (ny = 0);\n  }\n  const n = sqrt(nx * nx + ny * ny) || 1;\n  HIT[0] = t;\n  HIT[1] = nx / n;\n  HIT[2] = ny / n;\n}\n\n// A new ball of the given kind, spread evenly over that kind's part of the\n// phase space: position even over the area, heading even over the circle.\nfunction throwBall(P, i, regular) {\n  const a = P.a, capA = (PI * R * R) / 2, stemA = 2 * a * HS;\n  for (let k = 0; k \u003c 20000; k++) {\n    let x, y;\n    if (regular || Math.random() * (capA + stemA) \u003c capA) {\n      x = (Math.random() * 2 - 1) * R;\n      y = Math.random() * R;\n      if (x * x + y * y > (R - 0.3) * (R - 0.3)) continue;\n    } else {\n      x = (Math.random() * 2 - 1) * (a - 0.3);\n      y = -Math.random() * (HS - 0.3);\n    }\n    const th = Math.random() * 2 * PI, dx = cos(th), dy = sin(th), L = abs(x * dy - y * dx);\n    if (y >= 0 && L > a !== regular) continue;\n    P.x[i] = x;\n    P.y[i] = y;\n    P.dx[i] = dx;\n    P.dy[i] = dy;\n    return;\n  }\n  P.x[i] = 0;\n  P.y[i] = -HS / 2;\n  P.dx[i] = 0.6;\n  P.dy[i] = 0.8;\n}\n\nfunction throwAll(P) {\n  for (let i = 0; i \u003c NB; i++) throwBall(P, i, i \u003c NB * REG);\n}\n\n// The kind and colour of ball i: regular balls by where their caustic lies\n// between the border and the rim, chaotic ones all one colour.\nfunction paint(P, i) {\n  const x = P.x[i], y = P.y[i], L = abs(x * P.dy[i] - y * P.dx[i]), a = P.a;\n  if (y >= 0 && L > a) hsv(P.hue + 0.1 + 0.07 * ((L - a) / (R - a)), 0.9, 1, P.col, i * 3);\n  else hsv(P.hue + 0.57, 0.8, 1, P.col, i * 3);\n}\n\n// Lights the LEDs a ball passes between (x0, y0) and (x1, y1), each once,\n// w0 at the start fading up to w1 at the end.\nfunction trail(P, i, x0, y0, x1, y1, w0, w1) {\n  const n = max(1, ceil(sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) / 0.6)), buf = P.buf, c = i * 3;\n  const cr = P.col[c], cg = P.col[c + 1], cb = P.col[c + 2];\n  for (let j = 1; j \u003c= n; j++) {\n    const t = j / n, X = floor(CX + x0 + (x1 - x0) * t), Y = floor(CY - (y0 + (y1 - y0) * t));\n    const p = cl(Y, 0, H - 1) * W + cl(X, 0, W - 1);\n    if (p === P.lastp) continue;\n    P.lastp = p;\n    const w = w0 + (w1 - w0) * t, q = p * 3;\n    buf[q] += cr * w;\n    buf[q + 1] += cg * w;\n    buf[q + 2] += cb * w;\n  }\n}\n\n// Ball i flies s LEDs, bouncing off the walls as a mirror.\nfunction fly(P, i, s, w0, w1) {\n  const a = P.a;\n  let x = P.x[i], y = P.y[i], dx = P.dx[i], dy = P.dy[i], done = 0;\n  for (let k = 0; k \u003c 32 && done \u003c s; k++) {\n    hit(a, x, y, dx, dy);\n    const bounce = HIT[0] \u003c s - done, t = bounce ? HIT[0] : s - done;\n    const x1 = x + t * dx, y1 = y + t * dy;\n    trail(P, i, x, y, x1, y1, w0 + ((w1 - w0) * done) / s, w0 + ((w1 - w0) * (done + t)) / s);\n    x = x1;\n    y = y1;\n    done += t;\n    if (bounce) {\n      const nx = HIT[1], ny = HIT[2], d = dx * nx + dy * ny;\n      dx -= 2 * d * nx;\n      dy -= 2 * d * ny;\n      const n = sqrt(dx * dx + dy * dy);\n      dx /= n;\n      dy /= n;\n    }\n  }\n  P.x[i] = x;\n  P.y[i] = y;\n  P.dx[i] = dx;\n  P.dy[i] = dy;\n  // Rounding can, very rarely, slip a ball out past a corner of the stem;\n  // it is thrown again, into the stem's kind.\n  if (!inside(a, x, y, -0.05)) throwBall(P, i, false);\n}\n\n// The outline of the table and the border circle |L| = a in the cap.\nfunction table(P) {\n  const a = P.a, m = P.rim;\n  m.fill(0);\n  const put = (x, y, v) => {\n    const p = cl(floor(CY - y), 0, H - 1) * W + cl(floor(CX + x), 0, W - 1);\n    if (v > m[p]) m[p] = v;\n  };\n  const o = 0.7;\n  for (let k = 0; k \u003c= 600; k++) {\n    const t = (k / 600) * PI;\n    put((R + o) * cos(t), (R + o) * sin(t), RIM);\n  }\n  for (let x = a + o; x \u003c= R + o; x += 0.5) put(x, -o, RIM), put(-x, -o, RIM);\n  for (let y = -o; y >= -HS - o; y -= 0.5) put(a + o, y, RIM), put(-a - o, y, RIM);\n  for (let x = -a - o; x \u003c= a + o; x += 0.5) put(x, -HS - o, RIM);\n  // The border, dotted: no regular ball's chord comes inside it.\n  for (let k = 0; k \u003c= 40; k++) {\n    const t = (k / 40) * PI;\n    put(a * cos(t), a * sin(t), BORDER);\n  }\n}\n\nexport function setup(params) {\n  const F64 = (n) => new Float64Array(n);\n  params.s = {\n    x: F64(NB), y: F64(NB), dx: F64(NB), dy: F64(NB),\n    col: new Float32Array(NB * 3), buf: new Float32Array(N * 3), img: new Float32Array(N * 3),\n    rim: new Float32Array(N), a: 0.3 * R, hue: 0, lastp: -1, tint: [0, 0, 0],\n  };\n  table(params.s);\n  throwAll(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0.3, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0] || 0;\n  const v = VEL * cl(k[1] == null ? 2 : k[1], 0.2, 3), tr = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const tau = 0.05 + 1.5 * tr * tr * tr, f = exp(-d / tau), B = min(1, 0.09 / tau);\n  hsv(P.hue + 0.57, 0.5, 1, P.tint, 0);\n\n  // A new stem width squeezes or spreads the balls in the stem with it.\n  const a = R * cl(k[2] == null ? 0.3 : k[2], 0.3, 0.9);\n  if (abs(a - P.a) > 1e-6) {\n    const s = a / P.a;\n    for (let i = 0; i \u003c NB; i++) if (P.y[i] \u003c 0) P.x[i] *= s;\n    P.a = a;\n    table(P);\n  }\n  if (input.btnPressed && input.btnPressed[0]) throwAll(P);\n\n  const buf = P.buf;\n  for (let q = 0; q \u003c N * 3; q++) buf[q] *= f;\n  if (d > 0)\n    for (let i = 0; i \u003c NB; i++) {\n      paint(P, i);\n      P.lastp = -1;\n      fly(P, i, v * d, B * f, B);\n    }\n  for (let q = 0; q \u003c N * 3; q++) if (buf[q] > 1.2) buf[q] = 1.2;\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const img = P.img, buf = P.buf, m = P.rim, t = P.tint;\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    img[q] = max(buf[q], t[0] * m[p]);\n    img[q + 1] = max(buf[q + 1], t[1] * m[p]);\n    img[q + 2] = max(buf[q + 2], t[2] * m[p]);\n  }\n  for (let i = 0; i \u003c NB; i++) {\n    paint(P, i);\n    const q = (cl(floor(CY - P.y[i]), 0, H - 1) * W + cl(floor(CX + P.x[i]), 0, W - 1)) * 3, c = i * 3;\n    img[q] = max(img[q], P.col[c]);\n    img[q + 1] = max(img[q + 1], P.col[c + 1]);\n    img[q + 2] = max(img[q + 2], P.col[c + 2]);\n  }\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3)\n    display.setPixel(p % W, (p / W) | 0, round(cl(img[q], 0, 1) * 255), round(cl(img[q + 1], 0, 1) * 255), round(cl(img[q + 2], 0, 1) * 255));\n}\n","neon-spreading":"// ===== Patternflow pattern =====\n// Title:   Neon Spreading\n// Family:  type\n// Idea:    A lattice of thin white lines turns slowly over the black panel, and wherever its lines pass through the three big round letters of a word stacked down the panel those stretches of line are drawn in a dimmer colour, nothing else, so the eye spreads the colour into a glowing veil filling each letter between the lines, though every LED between them is dark; the letters shrink to their spines and swell into the next word in the next colour.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: neon colour spreading (Harrie van Tuijl, A new visual illusion: neonlike color spreading and complementary color induction between subjective contours, Acta Psychologica, 1975), after the chromatic spreading Dario Varin described in 1971; round-stroke capitals drawn for this pattern, pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pitch=4..9, Fill=0..1\n//\n// Knob 1: Hue. Turns the colours of the words round the wheel, which skips red-orange. At 0 the words go cyan HUE, violet FOG, rose AIR and green SEE; at 0.5 rose, green, cyan and blue. The lines stay white.\n// Knob 2: Speed. At 2 the lattice turns 4 degrees a second, so it comes back to itself every 22.5 s, and a word holds 4 s, shrinks to its spines in 0.9 s and the next one swells in 0.9 s. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Pitch. LEDs between the lattice's lines: 4 at the opening, where a stroke 9 LEDs wide holds two or three lines each way and the veil fills it, up to 9, where a stroke holds one line or none and the colour stays on its segments.\n// Knob 4: Fill. A real fill of the letters for comparison, painted between the lines in the word's colour: none up to 0.1, so at the opening 0.06 no LED inside a letter is lit but the line segments; 5% of full at 0.25, 13% at 0.5 and 30% at 1.\n// Buttons: K1 tap shrinks the word now and brings the next.\n\n// Every LED of the panel is on a line of the lattice or dark, until Fill\n// paints the letters. The lattice is two families of parallel lines, at\n// angles th and th + 90 degrees through the panel's centre, Pitch apart. An\n// LED's light goes by its distance d from the nearest line, 1.3 - 1.6 d:\n// full within 0.19 LEDs of the line, half at 0.5, dark from 0.81, a little\n// sharper than plain coverage so that a turning line keeps its weight.\n// The word is a distance field: the distance from each LED to the spines\n// of its letters, round strokes drawn as polylines and elliptic arcs, and a\n// letter covers the LEDs nearer its spine than half the stroke.\n// Where a line crosses a letter it changes from white at 74% to the word's\n// colour at 58% of its brightest channel; a coloured stretch is dimmer than\n// the white line and brighter than the black between, which is what the\n// spreading needs. The edge of the letter falls across a line within one\n// LED, so the colour starts and stops on the letter's outline, and the eye\n// carries it across the dark gaps to that outline.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n// Three letters down the panel, each in a box 56 by 36, 4 apart; strokes 9\n// LEDs wide.\nconst BX = 4, BW = 56, BH = 36, BY = [6, 46, 86], WT = 9;\nconst HOLD = 4, OUT = 0.9, IN = 0.9, HUE0 = 0.427;\nconst WHITE = 0.74, SEG = 0.58;\nconst WORDS = [\"HUE\", \"FOG\", \"AIR\", \"SEE\"], HUES = [0, 0.317, 0.524, 0.732];\n\n// Points of an elliptic arc in the unit box, y down, angles in degrees\n// (0 right, 90 down).\nfunction arc(cx, cy, rx, ry, a0, a1, n = 10) {\n  const out = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    out.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return out;\n}\n// The spines, as polylines in the unit box.\nconst GLYPHS = {\n  H: [[[0, 0], [0, 1]], [[1, 0], [1, 1]], [[0, 0.5], [1, 0.5]]],\n  U: [[[0, 0], [0, 0.45], ...arc(0.5, 0.45, 0.5, 0.55, 180, 0, 12), [1, 0]]],\n  E: [[[1, 0], [0, 0], [0, 1], [1, 1]], [[0, 0.5], [0.82, 0.5]]],\n  F: [[[1, 0], [0, 0], [0, 1]], [[0, 0.5], [0.8, 0.5]]],\n  O: [arc(0.5, 0.5, 0.5, 0.5, 0, 360, 24)],\n  G: [[...arc(0.5, 0.5, 0.5, 0.5, -40, -360, 20), [1, 0.5], [1, 0.62]], [[1, 0.55], [0.58, 0.55]]],\n  A: [[[0, 1], [0.5, 0], [1, 1]], [[0.24, 0.62], [0.76, 0.62]]],\n  I: [[[0.5, 0], [0.5, 1]], [[0.22, 0], [0.78, 0]], [[0.22, 1], [0.78, 1]]],\n  R: [[[0, 1], [0, 0], [0.68, 0], ...arc(0.68, 0.25, 0.32, 0.25, -90, 90, 10), [0, 0.5]], [[0.5, 0.5], [1, 1]]],\n  S: [[...arc(0.5, 0.25, 0.5, 0.25, -20, -270, 12), ...arc(0.5, 0.75, 0.5, 0.25, -90, 160, 12)]],\n};\n\n// The word's distance field: each LED's distance to the nearest spine.\nfunction field(word, out) {\n  const segs = [];\n  const r = WT / 2, sx = BW - 2 * r, sy = BH - 2 * r;\n  for (let c = 0; c \u003c word.length; c++)\n    for (const line of GLYPHS[word[c]]) {\n      const pts = line.map(([x, y]) => [BX + r + x * sx, BY[c] + r + y * sy]);\n      for (let i = 0; i + 1 \u003c pts.length; i++) segs.push([...pts[i], ...pts[i + 1]]);\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let best = 1e9;\n      for (const [x0, y0, x1, y1] of segs) {\n        const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n        const t = l2 > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / l2, 0, 1) : 0;\n        const ex = px - x0 - t * dx, ey = py - y0 - t * dy, d2 = ex * ex + ey * ey;\n        if (d2 \u003c best) best = d2;\n      }\n      out[y * W + x] = sqrt(best);\n    }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n// The wheel without red-orange, which reads brown when dim: 0 to 1 runs from\n// yellow through green, cyan, blue and violet to rose.\nconst wheel = (h) => 0.15 + 0.82 * (h - floor(h));\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, pitch: 4, fill: 0.06, th: 0.21, t: 0, ph: 1, wi: 0, btn: false,\n    dist: new Float32Array(N), col: [0, 0, 0],\n  });\n  field(WORDS[0], S.dist);\n  return S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.pitch = cl(k[2] == null ? 4 : k[2], 4, 9);\n  S.fill = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && S.ph !== 2) (S.ph = 2), (S.t = 0);\n  S.btn = btn;\n  const d = (d0 * S.speed) / 2;\n  S.th += (d * 4 * PI) / 180;\n  S.t += d;\n  // Phases: 1 the word holds, 2 it shrinks to its spines, 0 the next swells.\n  if (S.ph === 1 && S.t >= HOLD) (S.ph = 2), (S.t = 0);\n  if (S.ph === 2 && S.t >= OUT) {\n    S.wi = (S.wi + 1) % WORDS.length;\n    field(WORDS[S.wi], S.dist);\n    S.ph = 0;\n    S.t = 0;\n  }\n  if (S.ph === 0 && S.t >= IN) (S.ph = 1), (S.t = 0);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const dist = S.dist, col = hsv(wheel(S.hue + HUE0 + HUES[S.wi]), 1, 1, S.col);\n  // Half the stroke: whole while the word holds, down to nothing at its\n  // spines between words.\n  const r = (WT / 2) * (S.ph === 1 ? 1 : S.ph === 2 ? 1 - ease(S.t / OUT) : ease(S.t / IN));\n  const c = cos(S.th), s = sin(S.th), pt = S.pitch, fill = (0.3 * max(0, S.fill - 0.1)) / 0.9;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x - 32, py = y - 64;\n      const u = (px * c + py * s) / pt, v = (py * c - px * s) / pt;\n      const du = abs(u - round(u)) * pt, dv = abs(v - round(v)) * pt;\n      const line = cl(1.3 - 1.6 * min(du, dv), 0, 1);\n      // How much of this LED the letter covers, with a one-LED edge.\n      const m = r > 0 ? cl(r - dist[y * W + x] + 0.5, 0, 1) : 0;\n      const wl = line * WHITE * (1 - m), cs = line * SEG * m, f = fill * m * (1 - line);\n      display.setPixel(x, y, round(cl(wl + col[0] * (cs + f), 0, 1) * 255), round(cl(wl + col[1] * (cs + f), 0, 1) * 255), round(cl(wl + col[2] * (cs + f), 0, 1) * 255));\n    }\n}\n","quantum-walk":"// ===== Patternflow pattern =====\n// Title:   Quantum Walk\n// Family:  sim\n// Idea:    Space runs across the panel, two lattice sites to an LED, and time down it, one step a row, as a Hadamard walk started with its coin on L writes its space-time diagram: the chance of finding the walker at each site with its coin on L fills a cone whose edges, the two ballistic fronts near plus and minus t over root 2, glow white where the walker is most likely found, cut through by nested dark arcs where that half of the wave cancels itself, and once the diagram is written a gold dotted line traces down the middle at the classical walk's square root of t, before the panel fades and the walk starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: discrete-time quantum walk (Yakir Aharonov, Luiz Davidovich and Nicim Zagury, 1993), the Hadamard walk on the line (Andris Ambainis, Eric Bach, Ashwin Nayak, Ashvin Vishwanath and John Watrous, 2001), its limit law (Norio Konno, 2002), the walk with a measured coin (Todd Brun, Hilary Carteret and Andris Ambainis, 2003), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Measure=0..1, Coin=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the probability is azure and the classical line gold, at 0.25 violet with green, at 0.5 red-orange with blue.\n// Knob 2: Speed. Steps a second, 33 for each unit: 66 at the opening 2, so a diagram of 127 steps is written in 1.9 s, then held 5.5 s, the gold line tracing down in the first 2.5 s of it, faded in 0.3 s and left dark for 0.4 s. At 0.2 a diagram takes 19 s, at 3 it takes 1.3 s.\n// Knob 3: Measure. The chance p that the coin is measured after each flip, 10^(3 (knob - 1)): none at 0, 0.0056 at 0.25, 0.032 at 0.5, 0.18 at 0.75 and every step at 1. The arcs fade from about row 1/p on (row 31 at 0.5, row 6 at 0.75) and the cone gives way to a bell; at 1 it is the classical walk, whose standard deviation on the last row is sqrt(127) = 11.3 sites, 5.6 LEDs.\n// Knob 4: Coin. The coin is [[cos q, sin q], [sin q, -cos q]] and its fronts run at cos q sites a step. Within 0.12 of the middle (it opens at 0.06) it is Hadamard's, cos q = 0.707, and the fronts leave the panel on row 90; at -1 cos q = 0.96 and they leave on row 67; at -0.5 it is 0.82 (row 78), at 0.5 it is 0.53 (row 120), and at 1 it is 0.3, and the fronts end 19 LEDs either side of the middle.\n// Buttons: K1 tap starts the walk again with the next starting coin: L (the opening), (L + iR)/sqrt 2, then R. K2 tap changes what the colour shows: the chance of the walker at a site with its coin on L (the opening), with its coin on R, or at the site at all.\n\n// The walker sits on a site x of the line and carries a coin, a qubit with\n// the states L and R. A step flips the coin with the Hadamard matrix\n// (1/sqrt 2) [[1, 1], [1, -1]] and then moves the L part one site left and\n// the R part one site right. After t steps the walker is only ever on sites\n// of the parity of t, so each row here keeps one site of each LED's pair.\n//\n// A classical walker with a fair coin spreads as sqrt(t). This one spreads\n// as t: Ambainis and his coauthors found the chance pile up in two peaks\n// near x = -t / sqrt 2 and x = t / sqrt 2, and Konno found the limit law of\n// x / t, which lives between -cos q and cos q for the coin of K4. Started\n// with its coin on L the walk drifts left; started in (L + iR)/sqrt 2 it is\n// symmetric.\n//\n// Each row is scaled to its own largest value, so the late rows show as\n// well as the first. Scaled plainly, the narrow peaks would leave the rest\n// of a row dark, so the colour climbs as the square to full at 4% of that\n// value, and white shows where the position probability passes 12% of its\n// largest. The L part of the wave alone falls nearly to zero along nested\n// arcs, where the two travelling waves it is made of cancel. The R part has\n// its own arcs between them, and in the sum they fill each other in (K2 tap\n// shows all three).\n//\n// K3 measures the coin after each flip with chance p. The walker is then in\n// a mixed state, held here as its density matrix over sites and coin, up\n// to 256 by 256. A measurement multiplies every entry between L and R by\n// 1 - p, and the rest of a step is the flip and the shift as before. At\n// p = 1 nothing quantum is left and the walk is classical: a fair coin for\n// Hadamard's, and for other coins a walk that keeps its direction with\n// chance cos^2 q, whose standard deviation comes close to sqrt(t) cot q, the\n// gold line.\n\nconst W = 64, H = 128, N = W * H, K = H + 2, D = 2 * K;\nconst { floor, max, sqrt, log, round, pow, abs, SQRT1_2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Rows a second per unit of Speed, and the hold, fade and dark gap after a\n// diagram is written, in seconds.\nconst RATE = 33, HOLD = 5.5, FADE = 0.3, GAP = 0.4, TRACE = 2.5;\n// The brightness ramp: full at KNEE of the row's largest value, as the\n// square below it; white from WKNEE of the row's largest probability.\nconst KNEE = 0.04, GAM = 2, WKNEE = 0.12;\n// Weights of the walks started in |L> and in |R> for the three starts.\nconst STARTS = [[1, 0], [0.5, 0.5], [0, 1]];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 66, p: 0, c: SQRT1_2, s: SQRT1_2, view: 0, start: 0,\n    t: 0, acc: 0, phase: 0, clock: 0,\n    a1: new Float64Array(K), b1: new Float64Array(K), a2: new Float64Array(K), b2: new Float64Array(K),\n    mixed: false, r: null, r2: null,\n    PL: new Float32Array(N), PR: new Float32Array(N), mL: new Float32Array(H), mR: new Float32Array(H),\n    mS: new Float32Array(H), cot: new Float32Array(H),\n    buf: new Float32Array(N * 3), col: [0, 0, 0], gold: [0, 0, 0],\n  };\n  begin(params.s);\n}\n\nfunction begin(S) {\n  S.t = 0;\n  S.acc = 0;\n  S.phase = 0;\n  S.clock = 0;\n  for (const a of [S.a1, S.b1, S.a2, S.b2]) a.fill(0);\n  S.a1[0] = 1;\n  S.b2[0] = 1;\n  S.mixed = false;\n  S.PL.fill(0);\n  S.PR.fill(0);\n  record(S);\n}\n\n// Row t of the panel holds the walk after t steps. Its active sites are\n// x = 2k - t for k = 0..t; LED j holds the sites 2(j - 32) and 2(j - 32) + 1,\n// exactly one of which is active, so k = j - 32 + ceil(t / 2).\nfunction record(S) {\n  const t = S.t, o = t * W, sh = (t + 1) >> 1, [w1, w2] = STARTS[S.start];\n  let mL = 0, mR = 0, mS = 0;\n  for (let k = 0; k \u003c= t; k++) {\n    let l, r;\n    if (S.mixed) {\n      l = S.r[2 * k * D + 2 * k];\n      r = S.r[(2 * k + 1) * D + 2 * k + 1];\n    } else {\n      l = w1 * S.a1[k] * S.a1[k] + w2 * S.a2[k] * S.a2[k];\n      r = w1 * S.b1[k] * S.b1[k] + w2 * S.b2[k] * S.b2[k];\n    }\n    if (l > mL) mL = l;\n    if (r > mR) mR = r;\n    if (l + r > mS) mS = l + r;\n    const j = k - sh + 32;\n    if (j >= 0 && j \u003c W) {\n      S.PL[o + j] = l;\n      S.PR[o + j] = r;\n    }\n  }\n  S.mL[t] = mL;\n  S.mR[t] = mR;\n  S.mS[t] = mS;\n  S.cot[t] = S.c / S.s;\n}\n\n// One step of a real walk: the coin [[c, s], [s, -c]] on (L, R), then L\n// moves one site left and R one site right.\nfunction walk(a, b, t, c, s) {\n  for (let k = t; k >= 0; k--) {\n    const A = a[k], B = b[k];\n    a[k] = c * A + s * B;\n    b[k + 1] = s * A - c * B;\n  }\n  b[0] = 0;\n}\n\nfunction step(S) {\n  const t = S.t, c = S.c, s = S.s, [w1, w2] = STARTS[S.start];\n  if (S.p > 0 && !S.mixed) {\n    if (!S.r) {\n      S.r = new Float64Array(D * D);\n      S.r2 = new Float64Array(D * D);\n    }\n    // The real part of the density matrix; the imaginary part never\n    // reaches the diagonal, so it is left out.\n    const n = 2 * (t + 1), r = S.r, a1 = S.a1, b1 = S.b1, a2 = S.a2, b2 = S.b2;\n    for (let i = 0; i \u003c n; i++) {\n      const h = i >> 1, p1 = i & 1 ? b1[h] : a1[h], p2 = i & 1 ? b2[h] : a2[h];\n      for (let j = 0; j \u003c n; j++) {\n        const g = j >> 1;\n        r[i * D + j] = w1 * p1 * (j & 1 ? b1[g] : a1[g]) + w2 * p2 * (j & 1 ? b2[g] : a2[g]);\n      }\n    }\n    S.mixed = true;\n  }\n  if (!S.mixed) {\n    if (w1) walk(S.a1, S.b1, t, c, s);\n    if (w2) walk(S.a2, S.b2, t, c, s);\n  } else {\n    // rho -> (1 - p) C rho C + p (the same with the coin measured), which\n    // scales every entry between L and R by 1 - p, then the shift.\n    const r = S.r, q = S.r2, e = 1 - S.p, n2 = 2 * (t + 2), z = 2 * (t + 1);\n    for (let i = 0; i \u003c n2; i++) {\n      q[D + i] = q[i * D + 1] = 0;\n      q[z * D + i] = q[i * D + z] = 0;\n    }\n    for (let k1 = 0; k1 \u003c= t; k1++) {\n      const i0 = 2 * k1 * D, i1 = i0 + D, L1 = 2 * k1, R1 = L1 + 3;\n      for (let k2 = k1; k2 \u003c= t; k2++) {\n        const j0 = 2 * k2, w = r[i0 + j0], x = r[i0 + j0 + 1], y = r[i1 + j0], zz = r[i1 + j0 + 1];\n        const u0 = c * w + s * y, u1 = c * x + s * zz, v0 = s * w - c * y, v1 = s * x - c * zz;\n        const L2 = j0, R2 = j0 + 3;\n        q[L1 * D + L2] = q[L2 * D + L1] = u0 * c + u1 * s;\n        q[L1 * D + R2] = q[R2 * D + L1] = (u0 * s - u1 * c) * e;\n        q[R1 * D + L2] = q[L2 * D + R1] = (v0 * c + v1 * s) * e;\n        q[R1 * D + R2] = q[R2 * D + R1] = v0 * s - v1 * c;\n      }\n    }\n    S.r = q;\n    S.r2 = r;\n  }\n  S.t = t + 1;\n}\n\nfunction knobs(S, k) {\n  S.hue = k[0] || 0;\n  S.rate = RATE * cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const m = cl(k[2] || 0, 0, 1);\n  S.p = m \u003c= 0 ? 0 : pow(10, 3 * (m - 1));\n  // The peak speed |c| = cos(theta): 1/sqrt(2), Hadamard's, within 0.12 of\n  // the middle, out to 0.96 at -1 and in to 0.3 at +1.\n  const g = cl(k[3] == null ? 0.06 : k[3], -1, 1), u = max(0, abs(g) - 0.12) / 0.88;\n  S.c = g \u003c 0 ? SQRT1_2 + u * (0.96 - SQRT1_2) : SQRT1_2 - u * (SQRT1_2 - 0.3);\n  S.s = sqrt(1 - S.c * S.c);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, d = cl(dt || 0, 0, 0.1), bp = input.btnPressed || [];\n  knobs(S, input.knobValues || [0, 2, 0, 0.06]);\n  if (bp[1]) S.view = (S.view + 1) % 3;\n  if (bp[0]) {\n    S.start = (S.start + 1) % 3;\n    begin(S);\n  }\n  S.clock += d;\n  if (S.phase === 0) {\n    S.acc += d * S.rate;\n    while (S.acc >= 1 && S.t \u003c H - 1) {\n      step(S);\n      record(S);\n      S.acc -= 1;\n    }\n    if (S.t >= H - 1) {\n      S.phase = 1;\n      S.clock = 0;\n    }\n  } else if (S.phase === 1 && S.clock >= HOLD) {\n    S.phase = 2;\n    S.clock = 0;\n  } else if (S.phase === 2 && S.clock >= FADE) {\n    S.phase = 3;\n    S.clock = 0;\n  } else if (S.phase === 3 && S.clock >= GAP) begin(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, col = hsv(0.55 + S.hue, S.col), gold = hsv(0.12 + S.hue, S.gold), lw = log(1 / WKNEE);\n  buf.fill(0);\n  const fade = S.phase === 2 ? 1 - S.clock / FADE : S.phase === 3 ? 0 : 1;\n  const traced = S.phase === 0 ? -1 : S.phase === 1 ? (H * S.clock) / TRACE : H;\n  if (fade > 0)\n    for (let y = 0; y \u003c= S.t; y++) {\n      const m = S.view === 0 ? S.mL[y] : S.view === 1 ? S.mR[y] : S.mS[y], ms = S.mS[y];\n      if (!(m > 0)) continue;\n      const pen = S.phase === 0 && y === S.t ? 0.6 : 0;\n      for (let x = 0; x \u003c W; x++) {\n        const i = y * W + x, P = S.view === 0 ? S.PL[i] : S.view === 1 ? S.PR[i] : S.PL[i] + S.PR[i], v = P / m;\n        const lev = v >= KNEE ? 1 : pow(v / KNEE, GAM);\n        // White where the walker is most likely found, from the position\n        // probability whatever the view.\n        const vs = (S.PL[i] + S.PR[i]) / ms;\n        const wh = max(vs > WKNEE ? (0.9 * log(vs / WKNEE)) / lw : 0, pen * lev), o = i * 3;\n        buf[o] = (col[0] * lev * (1 - wh) + wh) * fade;\n        buf[o + 1] = (col[1] * lev * (1 - wh) + wh) * fade;\n        buf[o + 2] = (col[2] * lev * (1 - wh) + wh) * fade;\n      }\n      // The classical walk's standard deviation, sqrt(t) cot(theta) sites,\n      // traced down the diagram once it is written.\n      if (y % 2 || y > traced) continue;\n      const sd = sqrt(y) * S.cot[y];\n      for (const sg of [-1, 1]) {\n        const x = 32 + floor((sg * sd) / 2);\n        if (x \u003c 0 || x >= W) continue;\n        const o = (y * W + x) * 3;\n        buf[o] = gold[0] * fade;\n        buf[o + 1] = gold[1] * fade;\n        buf[o + 2] = gold[2] * fade;\n      }\n    }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","ramsey-fringes":"// ===== Patternflow pattern =====\n// Title:   Ramsey Fringes\n// Family:  wave\n// Idea:    Every row is a two-level atom at its own detuning and every column a longer dark gap between two short pulses, so Ramsey's formula fans out into hyperbolic fringes that open from the single-pulse line on the left and close in on resonance to the right, a central fringe 2.9 rows from crest to dark at the right edge inside a pedestal that fills the panel, while the relative phase of the two pulses slides every fringe on by one place each turn.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ramsey's method of separated oscillatory fields (Norman F. Ramsey, 1950), pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Free=-1..1, Pulse=0..1\n//\n// Knob 1: Hue. Turns the colour ramp round the wheel. At 0 an atom left in its ground state is deep violet and the ramp climbs through rose to a pale peach at full excitation; at 0.5 it runs from a dark green to a pale azure.\n// Knob 2: Speed. How fast the phase of the second pulse turns against the first: 0.17 turns a second for each unit, so one turn in 2.9 s at the opening 2, 29 s at 0.2 and 2 s at 3. Each turn moves every fringe on by one place.\n// Knob 3: Free. The longest free time, at the right edge: 22 over the Rabi frequency at the opening 0, the length of 14 pi/2 pulses, and 1.5 times shorter or longer at the ends (9.3 and 21). At the opening the central fringe at the right edge falls from its crest to dark in 2.9 rows, while the pedestal falls off to a crest of P = 0.04 at the top and bottom rows; at 1 the central fringe takes 1.9 rows and the fringes crowd towards the right.\n// Knob 4: Pulse. The area of each pulse, from the optimal pi/2 at 0 to pi at 1; the opening 0.06 is 0.53 pi. At 0.5 the fringes lose half their depth on resonance, and at pi the two pulses flip the atom and flip it back whatever the gap, so the middle row stays dark and the fringes live only in two lobes above and below.\n\n// In Rabi's method the atom crossed one oscillating field, and the width of\n// the line was set by the time it spent in it. Ramsey split the field in\n// two: a short pulse of length tau, a free time T with no field at all, and\n// a second short pulse. During the free time the atom's superposition keeps\n// the phase of its own transition while the field keeps the phase of the\n// oscillator, and the second pulse turns their difference Delta T into\n// population. With Rabi frequency Omega, detuning Delta and\n// W = sqrt(Omega^2 + Delta^2), the chance of finding the atom excited is\n//\n//   P = 4 (Omega/W)^2 sin^2(W tau/2)\n//       [cos(W tau/2) cos(chi/2) - (Delta/W) sin(W tau/2) sin(chi/2)]^2,\n//   chi = Delta T - phi,\n//\n// where phi is the phase of the second pulse against the first. The bracket\n// is one sinusoid in chi/2, R cos(chi/2 + beta), so P swings between 0 and\n// a crest set by the pulses alone: the pedestal, whose width is set by the\n// short pulses, about 1/tau. The fringes on top of it are spaced 2 pi / T\n// in detuning, so the longer the free time, the narrower the central\n// fringe. With pulses of area Omega tau = pi/2 the crest on resonance\n// reaches 1.\n//\n// Here the rows are the detuning, from +3.2 Omega at the top to -3.2 Omega\n// at the bottom, 0.05 Omega a row, and the columns the free time, from 0 at\n// the left to Tmax at the right. At T = 0 and phi = 0 the two pulses are\n// one pulse of area pi, and the left column is Rabi's line for it. The\n// fringes are the curves Delta T = phi + 2 pi n, hyperbolas that run out of\n// the left edge and crowd towards the middle row. On resonance chi does not\n// depend on T, so the middle rows are one even colour that brightens and\n// darkens as phi turns, while every other row runs through its fringes\n// along the free time.\n//\n// Brightness is a triangle wave of the fringe phase chi/2 + beta: dark where\n// P is 0, and at the crest the polar angle of the atom's Bloch vector there,\n// 2 asin(sqrt(Pmax)), as a share of pi. With pi/2 pulses on resonance that\n// is the Bloch angle exactly at every LED, since P = cos^2 makes\n// asin(sqrt(P)) a straight ramp; elsewhere the triangle keeps the crest and\n// the zeros and draws a straight ramp between them. So every fringe rises\n// and falls at one even slope instead of the sharp-bottomed sin^2.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, sin, cos, asin, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Detuning at the top and bottom rows, and the longest free time at the\n// opening, both in units of the Rabi frequency.\nconst DMAX = 3.2, T0 = 22;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    phi: 0, hue: 0, speed: 2, tmax: T0, area: PI / 2,\n    crest: new Float32Array(H), beta: new Float32Array(H),\n    lut: new Uint8Array(257 * 3), lh: -1, c: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.tmax = T0 * Math.pow(1.5, cl(k[2] || 0, -1, 1));\n  S.area = (PI / 2) * (1 + cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  S.phi += d * S.speed * 0.17 * TAU;\n  if (S.phi > TAU * 1000) S.phi -= TAU * 1000;\n}\n\n// Violet ground, rose in the middle, pale peach at full excitation.\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let i = 0; i \u003c= 256; i++) {\n    const p = i / 256;\n    hsv(S.hue + 0.72 + 0.38 * p, 0.9 - 0.55 * p * p * p, 0.08 + 0.92 * p, S.c);\n    S.lut[i * 3] = round(S.c[0] * 255);\n    S.lut[i * 3 + 1] = round(S.c[1] * 255);\n    S.lut[i * 3 + 2] = round(S.c[2] * 255);\n  }\n}\n\nconst dlOf = (y) => (DMAX * (63.5 - y)) / 64;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const L = S.lut, tau = S.area;\n  // Per row the pulses fix the crest (as a Bloch angle over pi) and the\n  // phase beta they add to the fringes.\n  for (let y = 0; y \u003c H; y++) {\n    const dl = dlOf(y), w = sqrt(1 + dl * dl), a = (w * tau) / 2, sa = sin(a), ca = cos(a), b = (dl / w) * sa;\n    const r = (2 / w) * sa * sqrt(ca * ca + b * b);\n    S.crest[y] = (2 / PI) * asin(cl(r \u003c 0 ? -r : r, 0, 1));\n    S.beta[y] = atan2(b, ca);\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const A = S.crest[y], dl = dlOf(y), be = S.beta[y];\n    for (let x = 0; x \u003c W; x++) {\n      const T = (S.tmax * x) / (W - 1);\n      // The fringe phase in half turns, folded to the nearest crest.\n      let u = ((dl * T - S.phi) / 2 + be) / PI;\n      u -= floor(u + 0.5);\n      const i = round(A * (1 - 2 * (u \u003c 0 ? -u : u)) * 256) * 3;\n      display.setPixel(x, y, L[i], L[i + 1], L[i + 2]);\n    }\n  }\n}\n","semaphore":"// ===== Patternflow pattern =====\n// Title:   Semaphore\n// Family:  type\n// Idea:    A signaller, a white point with two arms each holding a square red and yellow flag, comes down the tall panel from the top edge, stops once for each letter of a word and swings its arms to that letter's pair of the eight clock directions, and every pose it leaves behind stays as a glyph with the decoded capital beside it, drawn in strokes of the same eight directions, so the word reads down the panel's height before the signaller drops off the bottom and the next word comes down over the last one.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: flag semaphore, each letter a pair of arm directions in 45 degree steps as the observer sees them; N over D as Gerald Holtom drew them into the nuclear disarmament symbol (1958); capitals drawn for this pattern in strokes of the same eight directions, pattern round 79\n// Round:   79\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..7, Guide=0..1\n//\n// Knob 1: Hue. The panel's own colour, for the arms and the capitals; the flags stay red and yellow. At 0 the arms are azure and the capitals pale azure, at 0.25 violet, at 0.5 a red orange, at 0.75 green; the signaller itself is always near white.\n// Knob 2: Speed. At 2 a letter takes 1 s, 0.45 s of swing and 0.55 s held while its capital comes up beside it, and the finished word stands 1.6 s: HELLO takes 6.6 s and SOS 4.6 s. Every time goes as 2 / Speed, 10 s a letter at 0.2 and 0.67 s at 3.\n// Knob 3: Word. 0 HELLO, 1 FLAG, 2 SOS, 3 WAVE, 4 SEND, 5 QUIZ, 6 YACHT, 7 KNOT, and after each word the next; in SEND the N and the D stand one over the other. A word fills the 128 rows whatever its length: 42.7 rows a letter for three letters, 32 for four, 25.6 for five, with arms 18.3, 13.8 and 11 LEDs long, flags 7.7, 5.8 and 4.6 LEDs square, and capitals 32, 26 and 21 rows tall. Turning it starts the new word at once from the top, over what was laid of the last.\n// Knob 4: Guide. The clock face behind every pose: the eight spokes the arms can take, and at the end of each the outline of the square its flag would fill. Nothing at 0, too faint to see at the opening 0.06, and at 1 half as bright as an arm, so every pose reads as two of eight.\n\n// In flag semaphore a letter is the pair of directions the two arms point\n// in, each one of eight, 45 degrees apart. As the observer sees them on a\n// clock face, A to G hold one arm at 6 and send the other round from 7:30\n// to 4:30; H to N (with no J) hold one at 7:30; O to S at 9; T, U and Y at\n// 10:30; and J, V, W, X and Z are what is left. That is 26 of the 28 pairs\n// of eight directions. CODE below is that table, written as clock times.\n//\n// Which arm makes which direction is left out: the observer sees only\n// directions, and so does the code. Between letters the two arms swing to\n// the new pair along whichever matching of old to new needs the least\n// turning, each the short way round, so an arm that holds its direction\n// holds still: A to B moves one arm 45 degrees. Before a word and after it\n// the arms rest, both pointing down at 6.\n//\n// The capitals are drawn on a grid four units wide and six tall with\n// strokes at 0, 45 and 90 degrees only, the arms' own eight directions:\n// round letters are octagons, and N, V, X and Y bend to stay on the grid.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nconst CLOCK = { \"6\": 0, \"7:30\": 1, \"9\": 2, \"10:30\": 3, \"12\": 4, \"1:30\": 5, \"3\": 6, \"4:30\": 7 };\nconst CODE = {\n  A: \"6 7:30\", B: \"6 9\", C: \"6 10:30\", D: \"6 12\", E: \"6 1:30\", F: \"6 3\", G: \"6 4:30\",\n  H: \"7:30 9\", I: \"7:30 10:30\", K: \"7:30 12\", L: \"7:30 1:30\", M: \"7:30 3\", N: \"7:30 4:30\",\n  O: \"9 10:30\", P: \"9 12\", Q: \"9 1:30\", R: \"9 3\", S: \"9 4:30\",\n  T: \"10:30 12\", U: \"10:30 1:30\", Y: \"10:30 3\",\n  J: \"12 3\", V: \"12 4:30\", W: \"1:30 3\", X: \"1:30 4:30\", Z: \"3 4:30\",\n};\nconst POSE = {};\nfor (const c in CODE) POSE[c] = CODE[c].split(\" \").map((t) => CLOCK[t]);\nconst REST = [0, 0];\n\n// Direction k of the eight, k = 0 at 6 o'clock and on clockwise as the\n// observer sees it, as a unit vector on the panel (y down). A fractional k\n// is an arm on its way between two.\nconst dirOf = (k) => {\n  const a = PI + (k * PI) / 4;\n  return [sin(a), -cos(a)];\n};\n\n// Capitals: polylines through points xy of the 4 by 6 grid, y down.\nconst STROKES = {\n  A: \"06 02 20 42 46|04 44\", B: \"06 00 30 41 42 33 03|33 44 45 36 06\", C: \"41 30 10 01 05 16 36 45\",\n  D: \"00 20 42 44 26 06 00\", E: \"40 00 06 46|03 33\", F: \"40 00 06|03 33\", G: \"41 30 10 01 05 16 36 45 43 23\",\n  H: \"00 06|40 46|03 43\", I: \"10 30|20 26|16 36\", J: \"40 45 36 16 05\", K: \"00 06|40 13 46|03 13\",\n  L: \"00 06 46\", M: \"06 00 22 40 46\", N: \"06 00|01 45|40 46\", O: \"10 30 41 45 36 16 05 01 10\",\n  P: \"06 00 30 41 42 33 03\", Q: \"10 30 41 45 36 16 05 01 10|24 46\", R: \"06 00 30 41 42 33 03|23 45 46\",\n  S: \"41 30 10 01 02 13 33 44 45 36 16 05\", T: \"00 40|20 26\", U: \"00 05 16 36 45 40\", V: \"00 04 26 44 40\",\n  W: \"00 06 24 46 40\", X: \"00 01 45 46|40 41 05 06\", Y: \"00 01 23 41 40|23 26\", Z: \"00 40 41 05 06 46\",\n};\nconst SEGS = {};\nfor (const c in STROKES) {\n  const s = [];\n  for (const line of STROKES[c].split(\"|\")) {\n    const p = line.split(\" \").map((t) => [+t[0], +t[1]]);\n    for (let i = 1; i \u003c p.length; i++) s.push([p[i - 1][0], p[i - 1][1], p[i][0], p[i][1]]);\n  }\n  SEGS[c] = s;\n}\n\nconst WORDS = [\"HELLO\", \"FLAG\", \"SOS\", \"WAVE\", \"SEND\", \"QUIZ\", \"YACHT\", \"KNOT\"];\n\n// Seconds at Speed 2: the swing, a letter, the finished word's stand.\nconst SWING = 0.45, LETTER = 1, STAND = 1.6, DIM = 0.3, OLD = 0.3;\nconst RED = [1, 0.07, 0.04], YEL = [1, 0.8, 0], WHITE = [1, 1, 1];\n\n// Where a word of n letters puts things: slot height, arm, flag, the\n// hub's x, the capital's grid unit, its left edge and stroke.\nfunction layout(n) {\n  const h = H / n, r = 0.43 * h, u = n \u003c= 3 ? 5.4 : n === 4 ? 4.3 : 3.5;\n  const hx = r + 2.5, cx = (hx + r + 65) / 2 - 2 * u;\n  return { n, h, r, s: 0.42 * r, hx, u, cx, sw: 0.68 * u + 0.2, aw: 0.08 * r + 0.9 };\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nfunction paint(buf, x, y, c, a) {\n  if (a \u003c= 0 || x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  if (a > 1) a = 1;\n  buf[p] += (c[0] - buf[p]) * a;\n  buf[p + 1] += (c[1] - buf[p + 1]) * a;\n  buf[p + 2] += (c[2] - buf[p + 2]) * a;\n}\n\n// A line of width w from (x0, y0) to (x1, y1), its edge a pixel soft.\nfunction line(buf, x0, y0, x1, y1, w, c, a) {\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-9, e = w / 2 + 0.5;\n  for (let y = max(0, floor(min(y0, y1) - e)); y \u003c= min(H - 1, floor(max(y0, y1) + e)); y++)\n    for (let x = max(0, floor(min(x0, x1) - e)); x \u003c= min(W - 1, floor(max(x0, x1) + e)); x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / L2, 0, 1);\n      const ex = px - t * dx, ey = py - t * dy;\n      paint(buf, x, y, c, a * cl(e - sqrt(ex * ex + ey * ey), 0, 1));\n    }\n}\n\n// The flag on an arm from the hub (x, y) in direction d: a square of side\n// s on the staff's clockwise side, its outer edge at the arm's tip, split\n// on the diagonal from the staff's inner corner, red on the staff's side.\nfunction flag(buf, x, y, d, r, s, a) {\n  const px = -d[1], py = d[0], x0 = x + d[0] * (r - s), y0 = y + d[1] * (r - s);\n  const xs = [x0, x0 + d[0] * s, x0 + d[0] * s + px * s, x0 + px * s], ys = [y0, y0 + d[1] * s, y0 + d[1] * s + py * s, y0 + py * s];\n  for (let Y = max(0, floor(min(...ys))); Y \u003c= min(H - 1, floor(max(...ys))); Y++)\n    for (let X = max(0, floor(min(...xs))); X \u003c= min(W - 1, floor(max(...xs))); X++) {\n      let nr = 0, ny = 0;\n      for (let j = 0; j \u003c 3; j++)\n        for (let i = 0; i \u003c 3; i++) {\n          const qx = X + (i + 0.5) / 3 - x0, qy = Y + (j + 0.5) / 3 - y0, u = qx * d[0] + qy * d[1], v = qx * px + qy * py;\n          if (u \u003c 0 || u > s || v \u003c 0 || v > s) continue;\n          if (u >= v) nr++;\n          else ny++;\n        }\n      if (nr) paint(buf, X, Y, RED, (a * nr) / 9);\n      if (ny) paint(buf, X, Y, YEL, (a * ny) / 9);\n    }\n}\n\n// The outline of a flag's square, for the clock face.\nfunction ghost(buf, x, y, d, r, s, c, a) {\n  const px = -d[1], py = d[0], x0 = x + d[0] * (r - s), y0 = y + d[1] * (r - s);\n  const xs = [x0, x0 + d[0] * s, x0 + d[0] * s + px * s, x0 + px * s], ys = [y0, y0 + d[1] * s, y0 + d[1] * s + py * s, y0 + py * s];\n  for (let Y = max(0, floor(min(...ys))); Y \u003c= min(H - 1, floor(max(...ys))); Y++)\n    for (let X = max(0, floor(min(...xs))); X \u003c= min(W - 1, floor(max(...xs))); X++) {\n      const qx = X + 0.5 - x0, qy = Y + 0.5 - y0, u = qx * d[0] + qy * d[1], v = qx * px + qy * py;\n      const e = min(u, s - u, v, s - v);\n      paint(buf, X, Y, c, a * cl(1 - abs(e) * 1.4, 0, 1));\n    }\n}\n\n// The clock face behind a pose: the eight spokes, and at the end of each\n// the outline of the square a flag would fill there.\nfunction guide(buf, L, x, y, c, a) {\n  if (a \u003c= 0.004) return;\n  for (let k = 0; k \u003c 8; k++) {\n    const d = dirOf(k);\n    line(buf, x + d[0] * 2.5, y + d[1] * 2.5, x + d[0] * L.r, y + d[1] * L.r, 1, c, a);\n    ghost(buf, x, y, d, L.r, L.s, c, a);\n  }\n}\n\n// A pose: arms at directions (fractional k) a0 and a1 from the hub.\nfunction pose(buf, L, x, y, a0, a1, arm, alpha, live) {\n  for (const k of [a0, a1]) {\n    const d = dirOf(k);\n    line(buf, x, y, x + d[0] * L.r, y + d[1] * L.r, L.aw, arm, alpha);\n    flag(buf, x, y, d, L.r, L.s, alpha * (live ? 1 : 0.85));\n  }\n  // The signaller's body is a white point; a laid glyph keeps a dot.\n  if (live) for (let dy = -2; dy \u003c= 2; dy++) for (let dx = -2; dx \u003c= 2; dx++) paint(buf, floor(x) + dx, floor(y) + dy, WHITE, alpha * cl(2.3 - sqrt(dx * dx + dy * dy), 0, 1));\n  else paint(buf, floor(x), floor(y), arm, alpha);\n}\n\nfunction capital(buf, L, ch, top, c, a) {\n  const segs = SEGS[ch];\n  if (!segs || a \u003c= 0) return;\n  const u = L.u, x0 = L.cx, e = L.sw / 2 + 0.5;\n  for (let y = max(0, floor(top - e)); y \u003c= min(H - 1, floor(top + 6 * u + e)); y++)\n    for (let x = max(0, floor(x0 - e)); x \u003c= min(W - 1, floor(x0 + 4 * u + e)); x++) {\n      const gx = (x + 0.5 - x0) / u, gy = (y + 0.5 - top) / u;\n      let dmin = 1e9;\n      for (const s of segs) {\n        const dx = s[2] - s[0], dy = s[3] - s[1], L2 = dx * dx + dy * dy, px = gx - s[0], py = gy - s[1];\n        const t = cl((px * dx + py * dy) / L2, 0, 1), ex = px - t * dx, ey = py - t * dy, dd = ex * ex + ey * ey;\n        if (dd \u003c dmin) dmin = dd;\n      }\n      paint(buf, x, y, c, a * cl(e - sqrt(dmin) * u, 0, 1));\n    }\n}\n\n// A word's laid glyphs: the first `count`, each pose with its capital at\n// alpha a, those whose slot starts above row `cut` left out.\nfunction glyphs(buf, S, word, count, a, cut, col) {\n  const L = layout(word.length);\n  for (let k = 0; k \u003c count; k++) {\n    const top = k * L.h, f = a * cl((top - cut) / 4 + 1, 0, 1);\n    if (f \u003c= 0) continue;\n    const ch = word[k], p = POSE[ch], y = top + L.h / 2;\n    guide(buf, L, L.hx, y, col.guide, f * S.guide);\n    pose(buf, L, L.hx, y, p[0], p[1], col.arm, f, false);\n    capital(buf, L, ch, y - 3 * L.u, col.cap, f);\n  }\n}\n\n// The arms' matching from one pair to the next that turns them least,\n// each the short way round: [from, turn, from, turn] in eighths of a turn.\nfunction swing(p, q) {\n  const turn = (a, b) => {\n    let d = (((b - a) % 8) + 8) % 8;\n    if (d > 4) d -= 8;\n    return d;\n  };\n  const s1 = abs(turn(p[0], q[0])) + abs(turn(p[1], q[1])), s2 = abs(turn(p[0], q[1])) + abs(turn(p[1], q[0]));\n  return s1 \u003c= s2 ? [p[0], turn(p[0], q[0]), p[1], turn(p[1], q[1])] : [p[0], turn(p[0], q[1]), p[1], turn(p[1], q[0])];\n}\n\nfunction start(S, wi, oldWord, oldCount, dimmed) {\n  S.wi = ((wi % WORDS.length) + WORDS.length) % WORDS.length;\n  S.word = WORDS[S.wi];\n  S.old = oldWord;\n  S.oldCount = oldCount;\n  S.dimmed = !!dimmed;\n  S.tau = 0;\n}\n\nexport function setup(params) {\n  params.s = { buf: new Float32Array(N * 3), tau: 0, wi: 0, word: WORDS[0], old: \"\", oldCount: 0, dimmed: true, knob: -1, guide: 0, hue: 0 };\n  start(params.s, 0, WORDS[WORDS.length - 1], WORDS[WORDS.length - 1].length, true);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.guide = cl(k[3] == null ? 0.06 : k[3], 0, 1) * 0.5;\n  const kw = round(cl(k[2] || 0, 0, 7));\n  if (kw !== S.knob) {\n    // A fresh start opens on the word before, already sent; a turn of the\n    // knob keeps what is laid of the word in hand.\n    const before = WORDS[(kw + WORDS.length - 1) % WORDS.length];\n    if (S.knob \u003c 0) start(S, kw, before, before.length, true);\n    else start(S, kw, S.word, min(S.word.length, floor(S.tau / LETTER)), false);\n    S.knob = kw;\n  }\n  S.tau += (d * speed) / 2;\n  const n = S.word.length;\n  if (S.tau >= n * LETTER + STAND) start(S, S.wi + 1, S.word, n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, tau = S.tau, word = S.word, n = word.length, L = layout(n);\n  buf.fill(0);\n  const col = { arm: hsv(S.hue + 0.55, 0.8, 0.95), cap: hsv(S.hue + 0.55, 0.6, 1), guide: hsv(S.hue + 0.55, 0.25, 1) };\n  const pale = hsv(S.hue + 0.55, 0.3, 1);\n\n  // Where the signaller is: k is the letter in hand, n while it leaves.\n  const k = min(n, floor(tau / LETTER)), u = tau - k * LETTER, e = smooth(u / SWING);\n  const sy = ((k - 1) * (1 - e) + k * e + 0.5) * L.h;\n  const from = k === 0 ? REST : POSE[word[k - 1]], to = k \u003c n ? POSE[word[k]] : REST, m = swing(from, to);\n\n  // The last word, dimmed as this one starts, wiped where this one has come.\n  const fade = S.dimmed ? OLD : OLD + (1 - OLD) * (1 - smooth(tau / DIM));\n  if (S.old) glyphs(buf, S, S.old, S.oldCount, fade, k \u003c n ? sy + L.h / 2 : H + 99, col);\n  glyphs(buf, S, word, k, 1, -99, col);\n\n  // The letter in hand: its capital comes up while the pose is held.\n  if (k \u003c n) {\n    const ch = word[k], c = smooth((u - SWING) / (LETTER - SWING));\n    capital(buf, L, ch, sy - 3 * L.u, col.cap, c);\n  }\n  guide(buf, L, L.hx, sy, col.guide, S.guide * 1.3);\n  pose(buf, L, L.hx, sy, m[0] + m[1] * e, m[2] + m[3] * e, pale, 1, true);\n\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","chain-fountain":"// ===== Patternflow pattern =====\n// Title:   Chain Fountain\n// Family:  physics\n// Idea:    A bead chain drawn out of a pile in a pot by the weight of its own falling end rises in an arch above the pot before it falls to a growing heap on the floor, an inverted catenary half as high as the drop below it, its beads running round the path and the links between them coloured by their tension, until the pile runs out, the tail whips up and over, the pot fills again, and the end tips over the rim and the speed builds and the arch climbs off the rim to its height.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the chain fountain (Steve Mould, 2013), explained by John Biggins and Mark Warner (Understanding the chain fountain, Proceedings of the Royal Society A, 2014), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drop=67..75, Push=0.26..0.29\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the beads are cyan, the links between them pink where the chain is most taut at the top of the arch, the glow round it blue and the pot and floor pale lavender lines; at 0.5 the beads are coral red with green links at the top and an amber glow.\n// Knob 2: Speed. How fast the film runs. At 2 it is nine times slower than life at a centimetre to the LED: the chain runs at 3.8 m/s, 42 LEDs a second on the panel, and one run from the end tipping over to the tail landing takes 17 s, 19 s with the refill. Ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Drop. The bottom of the pot above the floor, 67 to 75 LEDs, which moves the rim from row 43 up to row 35. The fall from the pile to the floor goes from 70 to 78 LEDs, the speed from 3.8 to 4.0 m/s and the arch from 35 to 39 LEDs high, its top from row 16 to row 4.\n// Knob 4: Push. Biggins and Warner's alpha, the share of lambda v^2 with which the pile pushes up on the chain, 0.26 to 0.29, the floor's beta kept equal to it. The arch stands at 0.50 of the drop at 0.26, 0.57 at 0.275 and 0.65 at 0.29, where its top reaches row 6; with Drop also at 75 it runs 7 rows off the top of the panel.\n// Buttons: K1 tap pulls the end over the rim again and starts the chain from rest.\n\n// A chain running along its own length at speed v on a fixed path carries\n// a momentum flux lambda v^2 (lambda its mass per LED) besides its tension\n// T, and T - lambda v^2 obeys the equations of a chain hanging still. So in\n// steady flow the path is a catenary, and since T - lambda v^2 is negative\n// here it stands up as an arch: x = XT + a asinh(s / a) and\n// y = top + sqrt(a^2 + s^2) - a in arc length s from the top, with\n// T - lambda v^2 = -lambda g (a + depth below the top).\n//\n// Biggins and Warner closed it at the two ends. A link lifted from the pile\n// pivots, the pile pushes up on it, and the tension just above the pile is\n// (1 - alpha) lambda v^2 rather than lambda v^2. At the floor the tension\n// is beta lambda v^2. Down the fall h2 from the pickup to the floor that\n// gives g h2 = (1 - alpha - beta) v^2, and up the rise h1 to the top\n// h1 = alpha v^2 / g - a; as a goes to 0 this is their\n// h1 / h2 = alpha / (1 - alpha - beta). This pattern takes a = 3 LEDs and\n// beta = alpha, a landing link pivoting as a lifted one does, and keeps\n// alpha between 0.26 and 0.29 because there the arch stands half to two\n// thirds of the drop high and reaches the top third of the panel; with\n// alpha at 0.15 it would stand 12 LEDs over a 70 LED drop.\n//\n// Out of steady flow one equation runs the speed, for the length l in\n// flight: l dv/dt = g (drop from its upper end to its lower end), less\n// (1 - alpha) v^2 while the pile feeds it, plus beta v^2 once the end is\n// down. The arch stands at alpha v^2 / g - a for the speed of the moment,\n// or lies on the rim while that is lower. When the pile runs out nothing is\n// picked up and the free tail speeds up as it runs up, over and down. The\n// heap on the floor rises as it grows and shortens the fall, so the arch\n// sinks a few LEDs through a run.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sqrt, asinh, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// One LED is a centimetre and g is 981 LEDs per second squared; the film\n// runs TIME simulated seconds to the second at Speed 1.\nconst GRAV = 981, TIME = 1 / 18;\n// The floor row, the pot (inner columns PL..PR, DEPTH rows deep, the pile\n// at most PILE rows), the column where the chain turns over, the catenary\n// parameter a at the top, the chain's length and the beads' spacing.\nconst FLOOR = 124, PL = 9, PR = 27, DEPTH = 14, PILE = 10, XT = 28, A = 3;\nconst LC = 500, BEAD = 7, SUB = 4;\n// Seconds at Speed 2 the chain lies on the floor, and the pot refills.\nconst REST = 0.6, REFILL = 1;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, drop: 67, alpha: 0.26, ph: 0, pt: 0, M: 0, D: 0, v: 0, ytop: 0, fill: 1, btn: false,\n    buf: new Float32Array(N * 3), line: new Float32Array(N), ten: new Float32Array(N), glow: new Float32Array(N),\n    cc: [0, 0, 0], hc: [0, 0, 0], pc: [0, 0, 0], rc: [0, 0, 0], P: [0, 0], started: false,\n  });\n  return S;\n}\n\n// The pot and the pile for the current drop and what is left in the pile.\nfunction pot(S) {\n  S.ybot = FLOOR - S.drop;\n  S.yrim = S.ybot - DEPTH;\n  const left = S.ph === 3 ? LC * S.fill : S.ph >= 1 ? 0 : cl(LC - S.M, 0, LC);\n  S.ypile = S.ybot - PILE * (left / LC);\n}\n// The heap on the floor: a mound of height sqrt(3 x area / 8) and twice\n// that half width, its area 0.45 LED^2 for each LED of chain.\nconst heapH = (d) => sqrt((3 * 0.45 * d) / 8);\n\n// The path from the pickup in the pile, up over the top and down to the\n// floor: one inverted catenary, x = XT + a asinh(sig / a) and\n// y = ytop + sqrt(a^2 + sig^2) - a, sig the arc length from the top.\nfunction path(S) {\n  pot(S);\n  S.yland = FLOOR - heapH(S.D);\n  S.s1 = sqrt((S.ypile - S.ytop + A) ** 2 - A * A);\n  S.s2 = sqrt((S.yland - S.ytop + A) ** 2 - A * A);\n  S.len = S.s1 + S.s2;\n}\nfunction at(S, s, o) {\n  const sg = s - S.s1;\n  o[0] = XT + A * asinh(sg / A);\n  o[1] = S.ytop + sqrt(A * A + sg * sg) - A;\n  return o;\n}\n// Where the arch stands: alpha v^2 / g - a above the pickup, or on the rim.\nconst top = (S) => min(S.yrim - 1, S.ypile - max(0, (S.alpha * S.v * S.v) / GRAV - A));\n\n// Steady flow with a share u of the chain already on the floor.\nfunction steady(S, u) {\n  S.ph = 0;\n  S.landed = true;\n  S.D = u * LC;\n  S.M = S.D + 100;\n  for (let i = 0; i \u003c 6; i++) {\n    path(S);\n    S.v = sqrt((GRAV * (S.yland - S.ypile)) / (1 - 2 * S.alpha));\n    S.ytop = top(S);\n    path(S);\n    S.M = S.D + S.len;\n  }\n}\n\n// From rest: the end pulled over the rim, hanging 30 LEDs below it.\nfunction start(S) {\n  S.ph = 0;\n  S.pt = 0;\n  S.v = 0;\n  S.D = 0;\n  S.landed = false;\n  S.M = 0;\n  pot(S);\n  S.ytop = S.yrim - 1;\n  path(S);\n  S.M = S.s1 + sqrt((S.yrim + 30 - S.ytop + A) ** 2 - A * A);\n}\n\n// One step of the speed for the chain in flight, its upper end the pickup\n// or, once the pile is empty, the tail; beta is alpha.\nfunction step(S, h) {\n  const al = S.alpha, P = S.P;\n  path(S);\n  const tail = S.ph === 1 ? S.M - LC : 0;\n  // Once the end is down, the chain in flight spans the whole path, taking\n  // from the heap or adding to it as the path changes length.\n  if (!S.landed && S.M - S.D >= S.len) S.landed = true;\n  if (S.landed) S.D = max(0, S.M - S.len);\n  const landed = S.landed, lo = S.M - S.D;\n  const yEnd = at(S, lo, P)[1], yUp = tail > 0 ? at(S, tail, P)[1] : S.ypile;\n  const acc = (GRAV * (yEnd - yUp) - (S.ph === 0 ? (1 - al) : 0) * S.v * S.v + (landed ? al * S.v * S.v : 0)) / max(4, lo - tail);\n  S.v = max(0, S.v + acc * h);\n  if (S.ph === 1) S.v = min(S.v, 2.5 * S.vss);\n  S.M += S.v * h;\n  if (S.ph === 0) {\n    S.ytop = top(S);\n    if (S.M >= LC) S.ph = 1;\n  } else if (S.M - LC >= S.len - 0.5) {\n    S.ph = 2;\n    S.pt = 0;\n    S.D = LC;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.drop = cl(k[2] || 67, 67, 75);\n  S.alpha = cl(k[3] == null ? 0.26 : k[3], 0.26, 0.29);\n  S.vss = sqrt((GRAV * (S.drop + PILE)) / (1 - 2 * S.alpha));\n  // The film opens on a fountain already running, 10% of its chain on the\n  // floor; every one after starts from rest.\n  if (!S.started) {\n    S.started = true;\n    steady(S, 0.1);\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn) start(S);\n  S.btn = btn;\n  S.dts = d * S.speed * TIME;\n  if (S.ph \u003c= 1) {\n    for (let i = 0; i \u003c SUB; i++) step(S, S.dts / SUB);\n  } else {\n    S.pt += d * S.speed * 0.5;\n    if (S.ph === 2 && S.pt > REST) (S.ph = 3), (S.pt = 0);\n    if (S.ph === 3) {\n      S.fill = min(1, S.pt / REFILL);\n      S.D = LC * (1 - S.fill);\n      if (S.pt > REFILL) start(S);\n    }\n  }\n  path(S);\n}\n\n// Adds v to an LED buffer at a point between LEDs, shared by the four round it.\nfunction splat(L, x, y, v) {\n  const i = floor(x - 0.5), j = floor(y - 0.5), fx = x - 0.5 - i, fy = y - 0.5 - j;\n  for (let q = 0; q \u003c 4; q++) {\n    const a = i + (q & 1), b = j + (q >> 1);\n    if (a \u003c 0 || a >= W || b \u003c 0 || b >= H) continue;\n    const w = (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy), p = b * W + a;\n    if (v * w > L[p]) L[p] = v * w;\n  }\n}\n// A bead: a disc 4.4 LEDs across with a soft edge out to 6.4.\nfunction bead(L, x, y, v) {\n  const x0 = floor(x - 3.5), y0 = floor(y - 3.5);\n  for (let j = y0; j \u003c= y0 + 7; j++)\n    for (let i = x0; i \u003c= x0 + 7; i++) {\n      if (i \u003c 0 || i >= W || j \u003c 0 || j >= H) continue;\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, r = sqrt(dx * dx + dy * dy), w = v * cl(3.2 - r, 0, 1), p = j * W + i;\n      if (w > L[p]) L[p] = w;\n    }\n}\n// A halo of radius 4 round a point of the chain.\nfunction halo(G, x, y) {\n  const cx = round(x - 0.5), cy = round(y - 0.5);\n  for (let dy = -4; dy \u003c= 4; dy++)\n    for (let dx = -4; dx \u003c= 4; dx++) {\n      const a = cx + dx, b = cy + dy, r2 = dx * dx + dy * dy;\n      if (a \u003c 0 || a >= W || b \u003c 0 || b >= H || r2 > 16) continue;\n      const g = 0.24 * (1 - r2 / 25), p = b * W + a;\n      if (g > G[p]) G[p] = g;\n    }\n}\n\nfunction put(buf, x, y, c, k) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] = max(buf[p], c[0] * k);\n  buf[p + 1] = max(buf[p + 1], c[1] * k);\n  buf[p + 2] = max(buf[p + 2], c[2] * k);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { buf, line: L, ten: T, glow: G, cc, hc, pc, rc, P } = S;\n  buf.fill(0);\n  L.fill(0);\n  T.fill(0);\n  G.fill(0);\n  hsv(S.hue + 0.5, 0.7, 1, cc);\n  hsv(S.hue + 0.62, 0.8, 1, hc);\n  hsv(S.hue + 0.75, 0.25, 1, pc);\n  hsv(S.hue + 0.85, 0.55, 1, rc);\n  // The floor, and the pot as two walls and a bottom.\n  for (let x = 0; x \u003c W; x++) put(buf, x, FLOOR + 1, pc, 0.3);\n  const yb = round(S.ybot), yr = round(S.yrim);\n  for (let y = yr; y \u003c= yb; y++) put(buf, PL - 1, y, pc, 0.45), put(buf, PR + 1, y, pc, 0.45);\n  for (let x = PL - 1; x \u003c= PR + 1; x++) put(buf, x, yb + 1, pc, 0.45);\n  // The pile and the heap on the floor: beads lying in rows.\n  const lie = (x, y) => bead(L, x, y, 0.42 + 0.12 * (((x * 7 + y * 3) | 0) % 3));\n  for (let y = S.ybot - 1.5, r = 0; y > S.ypile - 1; y -= 3, r++) for (let x = PL + 1.5 + 2 * (r & 1); x \u003c PR; x += 4) lie(x, y);\n  const hh = heapH(S.D);\n  if (hh > 0.8) {\n    const xl = XT + A * asinh(S.s2 / A);\n    for (let y = FLOOR - 1.5, r = 0; y > FLOOR - hh; y -= 3, r++) {\n      const half = 2 * hh * sqrt(max(0, 1 - (FLOOR - y) / hh));\n      for (let x = xl - half + 2 * (r & 1); x \u003c= xl + half; x += 4) lie(x, y);\n    }\n  }\n  // The chain in flight: its line in a colour that runs with its tension,\n  // T = v^2 - g (a + depth below the top), highest at the top and down to\n  // beta v^2 at the floor, and a halo round it.\n  const t0 = S.ph === 1 ? S.M - LC : 0, t1 = S.ph \u003c= 1 ? min(S.M - S.D, S.len) : 0;\n  const tmax = max(1, S.v * S.v - GRAV * A);\n  for (let s = max(0, t0), i = 0; s \u003c t1; s += 0.5, i++) {\n    at(S, s, P);\n    const t = cl((S.v * S.v - GRAV * (A + P[1] - S.ytop)) / tmax, 0, 1);\n    splat(L, P[0], P[1], 0.35);\n    splat(T, P[0], P[1], t);\n    if (!(i & 1)) halo(G, P[0], P[1]);\n  }\n  // Beads every BEAD LEDs of chain, each smeared back over the way it moved\n  // this frame.\n  const smear = min(BEAD, S.v * S.dts);\n  for (let m = BEAD * ceil(S.D / BEAD); m \u003c= min(S.M, LC); m += BEAD) {\n    const s = S.M - m;\n    if (s \u003c 0 || s > S.len) continue;\n    for (let q = 2; q >= 0; q--) {\n      const sq = s - (smear * q) / 3;\n      if (sq \u003c 0) continue;\n      at(S, sq, P);\n      bead(L, P[0], P[1], 1 - 0.3 * q);\n    }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const v = L[p], g = G[p];\n    if (v \u003c= 0 && g \u003c= 0) continue;\n    const t = T[p], o = p * 3, wh = 0.6 * max(0, v - 0.75);\n    // Slack in the chain's colour, taut toward the second colour.\n    for (let q = 0; q \u003c 3; q++) buf[o + q] = max(buf[o + q], (cc[q] * (1 - t) + rc[q] * t) * v + wh, hc[q] * g);\n  }\n  // At the left edge, h1 above the pickup and h2 below it while the chain\n  // runs, and a tick at the steady height alpha v^2 / g - a.\n  if (S.ph \u003c= 1) {\n    const yp = round(S.ypile), ya = round(S.ytop), yl = round(S.yland);\n    for (let y = ya; y \u003c yp; y++) put(buf, 1, y, rc, 0.8), put(buf, 2, y, rc, 0.45);\n    for (let y = yp; y \u003c= yl; y++) put(buf, 1, y, cc, 0.55), put(buf, 2, y, cc, 0.3);\n    const ys = round(S.ypile - max(0, (S.alpha * (S.yland - S.ypile)) / (1 - 2 * S.alpha) - A));\n    put(buf, 3, ys, rc, 1);\n    put(buf, 4, ys, rc, 0.6);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = (p - x) / W;\n    display.setPixel(x, y, round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n  }\n}\n","floating-letters":"// ===== Patternflow pattern =====\n// Title:   Floating Letters\n// Family:  type\n// Idea:    The letters of a word, cut from one board lighter than water, drop one by one into a pool across the middle of the panel, splash, bob and turn until each rests where its centre of buoyancy stands straight under its centre of gravity, the O level, the T on its side, the E on its back beside an A that stays upright, while a curve over each letter draws its potential energy against its angle with a dot that rolls into a valley; then the board soaks up water, the letters ride lower, some roll to new angles, and they sink before the next word drops.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Archimedes, On Floating Bodies (c. 250 BC); the metacentre (Pierre Bouguer, Traité du navire, 1746), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Density=0.2..0.8, Swell=0..1\n//\n// Knob 1: Hue. Turns the letters and the water round the wheel together. At 0 the letters run from amber to lime over blue water; at 0.25 from green to sea green over violet; at 0.5 from blue to violet over amber.\n// Knob 2: Speed. Simulated seconds to the second, 0.7 for each unit: 1.4 at the opening 2, where a word takes 14 s from the first drop to the last letter sinking. Ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Density. The board's density against water, 0.2 to 0.8, which is also the share of each letter under the waterline, and which moves the valleys of every energy curve. At 0.2 the O floats level, the T lies on its side about 20 degrees off flat, the E on its back, the L tips about 15 or about 70 degrees and the A floats upright. At 0.5 the O turns to 45 degrees like a square log, the T lies flat and the L stands on its corner. At 0.8 every curve is the one at 0.2 turned through 180 degrees and a fifth of each letter shows above the water.\n// Knob 4: Swell. A swell running left to right on a 48 LED wavelength, 12 LEDs from crest to trough at 1 and 0.7 at the opening 0.06; past 0.57 its crests break white. A big swell rocks the letters and can knock one out of a shallow valley into another.\n// Buttons: K1 tap soaks the board at once, and the next word follows.\n\n// Each letter is a 15 by 15 bitmap cut from a board of density rho, water\n// being 1, and floats as a rigid body in the plane of the panel. Its weight,\n// rho g for each cell, acts at its centre of gravity G. Each cell under the\n// surface is pushed up by g times the part of it that is under; together\n// that is the weight of the water displaced, acting at the centroid of the\n// wet cells, the centre of buoyancy B. While B is off the vertical through\n// G the two forces turn the letter. It rests where B stands straight under\n// G and a small turn carries B past G's vertical to the side that turns it\n// back, Bouguer's metacentre above G. Those rests are the valleys of the\n// potential energy, the weight times the height of G less the work the\n// water does holding the letter up, and a letter keeps the valley it lands\n// in. Water drag on each wet cell, in proportion to its speed, damps the\n// bobbing. G is the white dot on each letter and B the pale one below it.\n//\n// The valleys depend on where the ink is, not how much. The E has 147\n// cells and the A 138; both drop upright, the E rolls onto its back and the\n// A stays upright in a valley shallower than the one upside down that it\n// never reaches. They depend on rho only through rho and 1 - rho, so the\n// curve at 0.8 is the one at 0.2 turned through 180 degrees. The square\n// glyph matters: one row taller and the O lies on its side at every\n// density, as a long log does.\n//\n// The tank is the panel's 64 columns, so the water rises by what the\n// letters displace, 1.1 LEDs for TEA at 0.2. Letters keep an LED apart, each\n// cell beside another letter's pushing both along the line between their\n// centres. After 8 simulated seconds the board soaks: rho climbs at 0.12 a\n// second, the letters ride lower and some roll after their valleys (a T\n// from about 70 degrees to about 110, an L onto its corner), then fast past\n// 0.95, and they sink.\n\nconst W = 64, H = 128, N = W * H, G = 15;\nconst { floor, round, min, max, sqrt, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The still waterline, gravity in LEDs per simulated second squared, water\n// drag per wet cell, the push between letters and from the panel's sides.\nconst WL = 62, GRAV = 40, DRAG = 2.4, PUSH = 30, WALL = 60, SUB = 6;\n// Swell: 48 LED wavelength, deep water, so omega = sqrt(g k).\nconst KW = (2 * PI) / 48, OMW = sqrt(GRAV * KW);\n// Simulated seconds: release of the first letter, gap between letters, when\n// the board starts to soak, how fast rho rises, and when to give up waiting.\nconst T0 = 0.5, GAP = 0.55, SOAK = 8, SOAKR = 0.12, TMAX = 26;\nconst HANG = 34, HUE0 = 0.13;\n// The energy curves: 48 angles, drawn in rows CY0 to CY1.\nconst NA = 48, CY0 = 11, CY1 = 25;\n\nconst WORDS = [\"TEA\", \"LOT\", \"BUOY\", \"FLY\", \"OIL\", \"SINK\", \"KEY\"];\n\n// 15 by 15, stroke 3, drawn for this pattern.\nconst GL = {\n  T: `\n###############\n###############\n###############\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......`,\n  E: `\n###############\n###############\n###############\n###............\n###............\n###............\n#############..\n#############..\n#############..\n###............\n###............\n###............\n###############\n###############\n###############`,\n  A: `\n..###########..\n.#############.\n###############\n###.........###\n###.........###\n###.........###\n###.........###\n###############\n###############\n###############\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###`,\n  L: `\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###............\n###############\n###############\n###############`,\n  O: `\n..###########..\n.#############.\n###############\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###############\n.#############.\n..###########..`,\n  B: `\n#############..\n##############.\n##############.\n###........###.\n###........###.\n###........###.\n###############\n###############\n###############\n###.........###\n###.........###\n###.........###\n###############\n##############.\n#############..`,\n  U: `\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###.........###\n###############\n.#############.\n..###########..`,\n  Y: `\n###.........###\n####.......####\n#####.....#####\n.#####...#####.\n..#####.#####..\n...#########...\n....#######....\n.....#####.....\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......`,\n  S: `\n..###########..\n.#############.\n###############\n###............\n###............\n###............\n###############\n###############\n###############\n............###\n............###\n............###\n###############\n.#############.\n..###########..`,\n  I: `\n..###########..\n..###########..\n..###########..\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n......###......\n..###########..\n..###########..\n..###########..`,\n  N: `\n###.........###\n####........###\n#####.......###\n######......###\n#######.....###\n########....###\n###.#####...###\n###..#####..###\n###...#####.###\n###....########\n###.....#######\n###......######\n###.......#####\n###........####\n###.........###`,\n  K: `\n###.........###\n###.......#####\n###......######\n###....######..\n###..#######...\n###.######.....\n########.......\n#######........\n#########......\n###..#####.....\n###...######...\n###.....#####..\n###......######\n###........####\n###.........###`,\n  F: `\n###############\n###############\n###############\n###............\n###............\n###............\n############...\n############...\n############...\n###............\n###............\n###............\n###............\n###............\n###............`,\n};\n\n// Each glyph once: its cells about the centre of gravity, the moment of\n// inertia per unit density, and a bitmap with a clear border to sample.\nconst GLYPH = {};\nfor (const ch in GL) {\n  const rows = GL[ch].trim().split(\"\\n\");\n  const xs = [], ys = [];\n  for (let j = 0; j \u003c G; j++) for (let i = 0; i \u003c G; i++) if (rows[j][i] === \"#\") xs.push(i + 0.5), ys.push(j + 0.5);\n  const n = xs.length;\n  let cx = 0, cy = 0;\n  for (let k = 0; k \u003c n; k++) (cx += xs[k]), (cy += ys[k]);\n  cx /= n;\n  cy /= n;\n  const dx = new Float32Array(n), dy = new Float32Array(n), bm = new Uint8Array((G + 2) * (G + 2));\n  let I = n / 6, R = 0;\n  for (let k = 0; k \u003c n; k++) {\n    dx[k] = xs[k] - cx;\n    dy[k] = ys[k] - cy;\n    I += dx[k] * dx[k] + dy[k] * dy[k];\n    R = max(R, sqrt(dx[k] * dx[k] + dy[k] * dy[k]) + 0.8);\n    bm[(ys[k] + 0.5) * (G + 2) + xs[k] + 0.5] = 1;\n  }\n  GLYPH[ch] = { n, cx, cy, dx, dy, I, R, bm };\n}\n\n// The potential energy of a letter at each of NA angles in still water,\n// scaled to 0..1: the height of its centre of gravity times its weight,\n// less the work the water does holding it up. The draft at each angle is\n// found by halving until the letter displaces its own weight.\nfunction curve(g, rho) {\n  const out = new Float32Array(NA), n = g.n, want = rho * n;\n  let lo = 1e9, hi = -1e9;\n  for (let k = 0; k \u003c NA; k++) {\n    const a = -PI + (2 * PI * k) / NA, c = cos(a), s = sin(a);\n    let y0 = -12, y1 = 12;\n    for (let it = 0; it \u003c 22; it++) {\n      const yc = (y0 + y1) / 2;\n      let f = 0;\n      for (let q = 0; q \u003c n; q++) f += cl(yc + g.dx[q] * s + g.dy[q] * c + 0.5, 0, 1);\n      if (f > want) y1 = yc;\n      else y0 = yc;\n    }\n    const yc = (y0 + y1) / 2;\n    let U = -want * yc;\n    for (let q = 0; q \u003c n; q++) {\n      const y = yc + g.dx[q] * s + g.dy[q] * c, t = y + 0.5;\n      if (t > 0) U += (t * t - (y > 0.5 ? (y - 0.5) * (y - 0.5) : 0)) / 2;\n    }\n    out[k] = U;\n    lo = min(lo, U);\n    hi = max(hi, U);\n  }\n  for (let k = 0; k \u003c NA; k++) out[k] = hi > lo ? (out[k] - lo) / (hi - lo) : 0;\n  return out;\n}\n\n// 3 by 5 capitals for the word written plainly at the top.\nconst SMALL = {\n  A: \"### #.# ### #.# #.#\", B: \"##. #.# ##. #.# ##.\", E: \"### #.. ##. #.. ###\", F: \"### #.. ##. #.. #..\",\n  I: \"### .#. .#. .#. ###\", K: \"#.# ##. #.. ##. #.#\", L: \"#.. #.. #.. #.. ###\", N: \"##. #.# #.# #.# #.#\",\n  O: \"### #.# #.# #.# ###\", S: \"### #.. ### ..# ###\", T: \"### .#. .#. .#. .#.\", U: \"#.# #.# #.# #.# ###\",\n  Y: \"#.# #.# .#. .#. .#.\",\n};\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, rho: 0.2, swell: 0.06, t: 0, tw: 0, wi: -1, B: [], drops: [], rise: 0,\n    rip: new Float32Array(W), ripv: new Float32Array(W), surf: new Float32Array(W), sf: new Float32Array(W + 1), foam: new Float32Array(W), curves: new Map(),\n    grid: new Uint8Array(W * (H + 64)), buf: new Float32Array(N * 3), btn: false,\n    lc: [0, 0, 0], wc: [0, 0, 0],\n  });\n  word(S);\n  return S;\n}\n\nfunction word(S) {\n  S.wi = (S.wi + 1) % WORDS.length;\n  S.tw = 0;\n  S.soaked = false;\n  const w = WORDS[S.wi], n = w.length;\n  S.B = [...w].map((ch, i) => ({\n    ch, g: GLYPH[ch], x: ((i + 0.5) * W) / n, y: HANG, a: 0, vx: 0, vy: 0, w: 0, fx: 0, fy: 0, tq: 0,\n    rho: S.rho, on: T0 + GAP * i, free: false, wet: false, gone: false, bx: 0, by: 0, sub: 0, hue: i * 0.035,\n  }));\n}\n\n// The surface: the still level, raised by the water the letters displace\n// across the 64 LED tank, the swell, and the ripples splashes leave. Set\n// once a step at every whole x and read between.\nfunction level(S) {\n  const sf = S.sf, a = S.swell * 6, ph = OMW * S.t;\n  for (let x = 0; x \u003c= W; x++) sf[x] = WL - S.rise + a * sin(KW * x - ph) + S.rip[min(x, W - 1)];\n}\nfunction surface(S, x) {\n  if (x \u003c= 0) return S.sf[0];\n  if (x >= W) return S.sf[W];\n  const i = floor(x), f = x - i;\n  return S.sf[i] * (1 - f) + S.sf[i + 1] * f;\n}\n\nfunction splash(S, x, v, n) {\n  for (let k = 0; k \u003c n; k++) {\n    const sp = v * (0.25 + 0.35 * Math.random()), an = -PI / 2 + (Math.random() - 0.5) * 1.6;\n    S.drops.push({ x: x + (Math.random() - 0.5) * 12, y: WL - S.rise - 1, vx: cos(an) * sp, vy: sin(an) * sp });\n  }\n  const i = cl(round(x), 1, W - 2);\n  for (let d = -6; d \u003c= 6; d++) if (i + d >= 0 && i + d \u003c W) S.ripv[i + d] += v * 0.05 * (1 - abs(d) / 7);\n}\n\n// Another letter's cell on this LED or the four beside it: its index + 1.\nfunction touch(S, grid, gx, gy, me) {\n  for (const [ox, oy] of NB) {\n    const x = gx + ox, y = gy + oy;\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H + 64) continue;\n    const o = grid[y * W + x];\n    if (o && o !== me) return o;\n  }\n  return 0;\n}\nconst NB = [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]];\n\nfunction step(S, h) {\n  S.t += h;\n  S.tw += h;\n  const grid = S.grid;\n  grid.fill(0);\n  // Ripples: a damped wave along the surface.\n  const rip = S.rip, rv = S.ripv;\n  for (let i = 0; i \u003c W; i++) {\n    const l = rip[i > 0 ? i - 1 : 0], r = rip[i \u003c W - 1 ? i + 1 : W - 1];\n    rv[i] += h * (400 * (l + r - 2 * rip[i]) - 20 * rip[i] - 3 * rv[i]);\n  }\n  for (let i = 0; i \u003c W; i++) rip[i] = cl(rip[i] + h * rv[i], -4, 4);\n  level(S);\n  const B = S.B;\n  let disp = 0;\n  for (let bi = 0; bi \u003c B.length; bi++) {\n    const b = B[bi];\n    if (b.gone) continue;\n    if (!b.free) {\n      if (S.tw \u003c b.on) continue;\n      b.free = true;\n      b.a = (Math.random() - 0.5) * 0.5;\n      b.w = (Math.random() - 0.5) * 2;\n      b.vx = (Math.random() - 0.5) * 4;\n    }\n    // Soaking, rho climbs slowly to just under 1 and then fast.\n    b.rho = S.soaked ? min(2.4, b.rho + SOAKR * h * (b.rho \u003c 0.95 ? 1 : 6)) : S.rho;\n    const g = b.g, n = g.n, m = b.rho * n, c = cos(b.a), s = sin(b.a);\n    let fx = 0, fy = m * GRAV, tq = 0, sub = 0, sx = 0, sy = 0;\n    for (let k = 0; k \u003c n; k++) {\n      const rx = g.dx[k] * c - g.dy[k] * s, ry = g.dx[k] * s + g.dy[k] * c;\n      const px = b.x + rx, py = b.y + ry;\n      const vx = b.vx - b.w * ry, vy = b.vy + b.w * rx;\n      let Fx = 0, Fy = 0;\n      const f = cl(py - surface(S, px) + 0.5, 0, 1);\n      if (f > 0) {\n        Fx -= DRAG * f * vx;\n        Fy -= GRAV * f + DRAG * f * vy;\n        sub += f;\n        sx += f * px;\n        sy += f * py;\n      } else {\n        Fx -= 0.02 * vx;\n        Fy -= 0.02 * vy;\n      }\n      if (px \u003c 0.5) Fx += WALL * (0.5 - px);\n      else if (px > W - 0.5) Fx -= WALL * (px - W + 0.5);\n      // Letters keep one LED apart: a cell next to another letter's pushes\n      // both along the line between their centres.\n      const gx = round(px - 0.5), gy = round(py - 0.5) + 32;\n      const o = touch(S, grid, gx, gy, bi + 1);\n      if (o) {\n        const q = B[o - 1];\n        let nx = b.x - q.x, ny = b.y - q.y;\n        const d = sqrt(nx * nx + ny * ny) || 1;\n        nx /= d;\n        ny /= d;\n        const P = PUSH - 2 * min(0, (b.vx - q.vx) * nx + (b.vy - q.vy) * ny);\n        Fx += P * nx;\n        Fy += P * ny;\n        q.fx -= P * nx;\n        q.fy -= P * ny;\n        q.tq += (py - q.y) * P * nx - (px - q.x) * P * ny;\n      }\n      if (gx >= 0 && gx \u003c W && gy >= 0 && gy \u003c H + 64) grid[gy * W + gx] = bi + 1;\n      fx += Fx;\n      fy += Fy;\n      tq += rx * Fy - ry * Fx;\n    }\n    b.sub = sub;\n    disp += sub;\n    if (sub > 0) (b.bx = sx / sub), (b.by = sy / sub);\n    // First touch of the water throws a splash as big as the letter is fast.\n    if (sub > 0 && !b.wet) {\n      b.wet = true;\n      splash(S, b.x, abs(b.vy), round(cl(abs(b.vy) / 4, 4, 16)));\n    }\n    b.fx += fx;\n    b.fy += fy;\n    b.tq += tq;\n  }\n  S.rise = disp / W;\n  for (const b of B) {\n    if (!b.free || b.gone) continue;\n    const m = b.rho * b.g.n, I = b.rho * b.g.I;\n    b.vx += (h * b.fx) / m;\n    b.vy += (h * b.fy) / m;\n    b.w += (h * b.tq) / I;\n    b.x += h * b.vx;\n    b.y += h * b.vy;\n    b.a += h * b.w;\n    b.a -= 2 * PI * floor((b.a + PI) / (2 * PI));\n    b.fx = b.fy = b.tq = 0;\n    if (b.y > H + b.g.R) b.gone = true;\n  }\n  for (const d of S.drops) {\n    d.vy += GRAV * h;\n    d.x += d.vx * h;\n    d.y += d.vy * h;\n    if (d.vy > 0 && d.y > surface(S, d.x)) d.gone = true;\n  }\n  S.drops = S.drops.filter((d) => !d.gone && d.x > -2 && d.x \u003c W + 2);\n  if (!S.soaked && S.tw > SOAK) S.soaked = true;\n  if (B.every((b) => b.gone) || S.tw > TMAX) word(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.rho = cl(k[2] == null ? 0.2 : k[2], 0.2, 0.8);\n  S.swell = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && !S.soaked) {\n    S.soaked = true;\n    for (const b of S.B) if (!b.free) b.gone = true;\n  }\n  S.btn = btn;\n  const h = (d * S.speed * 0.7) / SUB;\n  for (let i = 0; i \u003c SUB; i++) step(S, h);\n}\n\n// A letter's energy curve at its density, from the cache; flat once it is\n// heavier than water, when every angle is the same to it.\nfunction curveOf(S, b) {\n  const q = round(min(b.rho, 1) * 50), key = b.ch + q;\n  let c = S.curves.get(key);\n  if (!c) S.curves.set(key, (c = q >= 50 ? new Float32Array(NA) : curve(b.g, q / 50)));\n  return c;\n}\n\nfunction put(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] = r;\n  buf[p + 1] = g;\n  buf[p + 2] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, lc = S.lc, wc = S.wc;\n  hsv(S.hue + 0.6, 0.85, 1, wc);\n  const surf = S.surf, foam = S.foam;\n  level(S);\n  // The swell's height over its length is Swell / 4; past 1 in 7, at\n  // Swell 0.57, its crests break white.\n  const br = cl((S.swell - 0.57) / 0.3, 0, 1);\n  for (let x = 0; x \u003c W; x++) {\n    surf[x] = surface(S, x + 0.5);\n    foam[x] = br * max(0, -sin(KW * (x + 0.5) - OMW * S.t));\n  }\n  // Sky dark, water a tint that fades with depth, the surface a line.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3, dpt = y + 0.5 - surf[x];\n      let v = 0, wh = 0;\n      if (dpt > -0.5) v = dpt \u003c 0.5 ? 0.7 * (dpt + 0.5) : dpt \u003c 1.5 ? 0.7 : 0.11 + 0.3 * max(0, 1 - dpt / 50) ** 2;\n      if (dpt > -0.5 && dpt \u003c 2.5) wh = foam[x] * (dpt \u003c 0.5 ? dpt + 0.5 : 1) * (1 - max(0, dpt - 0.5) / 2);\n      buf[p] = wc[0] * v * (1 - wh) + wh;\n      buf[p + 1] = wc[1] * v * (1 - wh) + wh;\n      buf[p + 2] = wc[2] * v * (1 - wh) + wh;\n    }\n  // The letters, each LED sampled from the glyph turned back; under the\n  // surface seen dimmer through the water.\n  for (const b of S.B) {\n    if (b.gone) continue;\n    const g = b.g, c = cos(b.a), s = sin(b.a), R = g.R;\n    hsv(S.hue + HUE0 + b.hue, 0.8, 1, lc);\n    const x0 = max(0, floor(b.x - R)), x1 = min(W - 1, floor(b.x + R)), y0 = max(0, floor(b.y - R)), y1 = min(H - 1, floor(b.y + R));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const X = x + 0.5 - b.x, Y = y + 0.5 - b.y;\n        const u = X * c + Y * s + g.cx + 0.5, v = -X * s + Y * c + g.cy + 0.5;\n        if (u \u003c 0 || v \u003c 0 || u >= G + 1 || v >= G + 1) continue;\n        const i = floor(u), j = floor(v), fu = u - i, fv = v - j, o = j * (G + 2) + i;\n        let a = (g.bm[o] * (1 - fu) + g.bm[o + 1] * fu) * (1 - fv) + (g.bm[o + G + 2] * (1 - fu) + g.bm[o + G + 3] * fu) * fv;\n        if (a \u003c= 0.05) continue;\n        a = a >= 0.9 ? 1 : a * a * (3 - 2 * a);\n        const p = (y * W + x) * 3, dpt = y + 0.5 - surf[x];\n        const k = dpt > 0 ? 0.5 - 0.3 * min(1, dpt / 50) : 1;\n        for (let q = 0; q \u003c 3; q++) buf[p + q] = buf[p + q] * (1 - a * (dpt > 0 ? 0.6 : 1)) + lc[q] * k * a;\n      }\n  }\n  // G and B: the centre of gravity white, the centre of buoyancy in the\n  // water's colour, which settles straight under it.\n  for (const b of S.B) {\n    if (!b.free || b.gone) continue;\n    put(buf, floor(b.x), floor(b.y), 1, 1, 1);\n    if (b.sub > 0.5) put(buf, floor(b.bx), floor(b.by), 0.4 + 0.6 * wc[0], 0.4 + 0.6 * wc[1], 0.4 + 0.6 * wc[2]);\n  }\n  for (const d of S.drops) put(buf, floor(d.x), floor(d.y), 0.5 + 0.5 * wc[0], 0.5 + 0.5 * wc[1], 0.5 + 0.5 * wc[2]);\n  // At the top, the word written plainly, and over each letter's place its\n  // potential energy against its angle, -180 to 180 degrees, with a dot\n  // where the letter is now: it rolls into a valley as the letter settles.\n  const B = S.B, n = B.length, cw = floor(W / n);\n  for (let i = 0; i \u003c n; i++) {\n    const b = B[i], cu = curveOf(S, b), x0 = floor((i * W) / n) + floor((W / n - cw) / 2) + 1, wd = cw - 2;\n    hsv(S.hue + HUE0 + b.hue, 0.45, 0.7, lc);\n    let py = -1;\n    for (let x = 0; x \u003c wd; x++) {\n      const t = (x / (wd - 1)) * NA, k0 = floor(t) % NA, f = t - floor(t);\n      const u = cu[k0] * (1 - f) + cu[(k0 + 1) % NA] * f, y = round(CY1 - u * (CY1 - CY0));\n      const ya = py \u003c 0 ? y : y > py ? py + 1 : y, yb = py \u003c 0 ? y : y \u003c py ? py - 1 : y;\n      for (let yy = min(ya, yb, y); yy \u003c= max(ya, yb, y); yy++) put(buf, x0 + x, yy, lc[0], lc[1], lc[2]);\n      py = y;\n    }\n    put(buf, x0 + floor((wd - 1) / 2), CY1 + 2, lc[0] * 0.6, lc[1] * 0.6, lc[2] * 0.6);\n    const t = ((b.a + PI) / (2 * PI)) * NA, k0 = floor(t) % NA, f = t - floor(t);\n    const u = cu[k0] * (1 - f) + cu[(k0 + 1) % NA] * f;\n    const bx = x0 + round(((b.a + PI) / (2 * PI)) * (wd - 1)), by = round(CY1 - u * (CY1 - CY0)) - 1;\n    put(buf, bx, by, 1, 1, 1);\n    put(buf, bx, by - 1, 1, 1, 1);\n  }\n  const w = WORDS[S.wi], lx = floor((W - (w.length * 4 - 1)) / 2);\n  hsv(S.hue + HUE0, 0.6, 0.75, lc);\n  for (let i = 0; i \u003c w.length; i++) {\n    const rows = SMALL[w[i]].split(\" \");\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (rows[r][q] === \"#\") put(buf, lx + i * 4 + q, 2 + r, lc[0], lc[1], lc[2]);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = (p - x) / W;\n    display.setPixel(x, y, round(cl(buf[p * 3], 0, 1) * 255), round(cl(buf[p * 3 + 1], 0, 1) * 255), round(cl(buf[p * 3 + 2], 0, 1) * 255));\n  }\n}\n","fox-colorings":"// ===== Patternflow pattern =====\n// Title:   Fox Colorings\n// Family:  topology\n// Idea:    A knot stands the full height of the panel as a closed braid, its crossings stacked down the middle and its strands coming back up round the right side, each under-strand broken where it passes beneath, and every arc between two undercrossings is coloured by a label mod p so that at each crossing twice the over arc equals the sum of the two under arcs; the colourings are found by Gaussian elimination mod p and walked one basis step at a time, the arcs that change dipping dark and coming back in their new colour, and the count p^d and the knot's determinant stand at the top, so a knot whose determinant p does not divide sits in a single colour.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fox colourings of knot diagrams (Ralph Fox; Richard H. Crowell and Ralph H. Fox, Introduction to Knot Theory, 1963), Alexander's theorem that every knot is a closed braid (James Waddell Alexander, A lemma on systems of knotted curves, 1923), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knot=0..1, Prime=0..1\n//\n// Knob 1: Hue. Turns the p label colours round the wheel; label a sits a/p of a turn on from label 0, which is azure at 0.\n// Knob 2: Speed. At 2 a colouring lasts 1.9 seconds, the change taking the first 0.55 of them; 0.2 is ten times slower, 3 half as fast again. Three faint bright bands run round the knot the way it is drawn, each going round in 9 seconds at 2.\n// Knob 3: Knot. Thirteen stations: the trefoil s1^3 (determinant 3), the figure-eight s1 s2^-1 s1 s2^-1 (5), 5_1 = s1^5 (5), 5_2 (7), 6_1 on four strands (9), 6_2 (11), 6_3 (13), 7_1 = s1^7 (7), the square knot s1^3 s2^-3 (9, and 27 colourings mod 3, one more dimension than any prime knot here), a four-strand knot of determinant 15 = 3 x 5, the torus knot T(3,4) = 8_19 (3), 9_1 = s1^9 (9) and T(3,5) = 10_124 (1, colourable by no prime at all).\n// Knob 4: Prime. The modulus p, five stations: 3, 5, 7, 11, 13. The knot has colourings other than the p constant ones exactly when p divides its determinant; then they number p^2 for every knot here but the square knot, which has 3^3 = 27.\n\n// Cut a knot diagram at its undercrossings and it falls into arcs, as many\n// as it has crossings. Fox's colouring gives each arc a label in Z/p so that\n// at every crossing 2 x (over arc) = (under arc in) + (under arc out) mod p.\n// The constant labellings always pass; the knot is p-colourable when some\n// other one does, and that happens exactly when p divides the determinant,\n// the absolute value of any (n-1) by (n-1) minor of the n by n matrix of\n// these equations. The solutions are a vector space over Z/p of dimension\n// d >= 1, so there are p^d colourings. Here the equations are solved by\n// Gaussian elimination mod p with arc 0 held at 0, which leaves the d - 1\n// non-constant directions; the constant vector is the last. The walk runs\n// through all p^d colourings in a modular Gray code, adding one basis vector\n// at each step, so only the arcs where that vector is not 0 change, and\n// every crossing is valid in every colouring it rests on.\n//\n// Alexander showed in 1923 that every knot is the closure of a braid. The\n// braid runs down the panel, one crossing to a band; s_i crosses the\n// strands at places i and i + 1, the one moving right in front for s_i and\n// behind for its inverse. Each place j then returns up the right side, the\n// leftmost on the outside, so the closing arcs never cross.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\nconst KNOTS = [\n  [2, [1, 1, 1]],\n  [3, [1, -2, 1, -2]],\n  [2, [1, 1, 1, 1, 1]],\n  [3, [1, 1, 1, 2, -1, 2]],\n  [4, [1, 1, 2, -1, -3, 2, -3]],\n  [3, [1, 1, 1, -2, 1, -2]],\n  [3, [1, 1, -2, 1, -2, -2]],\n  [2, [1, 1, 1, 1, 1, 1, 1]],\n  [3, [1, 1, 1, -2, -2, -2]],\n  [4, [1, 1, 2, -1, 2, 2, 3, -2, 3]],\n  [3, [1, 2, 1, 2, 1, 2, 1, 2]],\n  [2, [1, 1, 1, 1, 1, 1, 1, 1, 1]],\n  [3, [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]],\n];\nconst PRIMES = [3, 5, 7, 11, 13];\n// Strand radius and the dark margin an over-strand cuts round itself.\nconst RAD = 1.45, GAP = 1.6;\n// Seconds a colouring lasts at Speed 1, and the share of it the change takes.\nconst STEP = 3.8, DIP = 0.29;\nconst HUE0 = 0.55;\n\nconst GLYPH = {\n  0: \"### #.# #.# #.# ###\", 1: \".#. ##. .#. .#. ###\", 2: \"### ..# ### #.. ###\", 3: \"### ..# .## ..# ###\", 4: \"#.# #.# ### ..# ..#\",\n  5: \"### #.. ### ..# ###\", 6: \"### #.. ### #.# ###\", 7: \"### ..# ..# .#. .#.\", 8: \"### #.# ### #.# ###\", 9: \"### #.# ### ..# ###\",\n  \"=\": \"... ### ... ### ...\", d: \"..# ..# ### #.# ###\", e: \"### #.# ### #.. ###\", t: \".#. ### .#. .#. .##\",\n};\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  o[1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  o[2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n  return o;\n}\n\n// Arcs of the closed braid: piece (l, j) is the strand at place j between\n// crossing l - 1 and crossing l, and level n is level 0 again. Pieces are\n// joined where a strand passes a crossing untouched or in front.\nfunction arcsOf(k, w) {\n  const n = w.length, par = new Int32Array(n * k).map((_, i) => i);\n  const find = (a) => (par[a] === a ? a : (par[a] = find(par[a])));\n  const id = (l, j) => (l % n) * k + j;\n  const eqs = [];\n  for (let t = 0; t \u003c n; t++) {\n    const g = w[t], i = abs(g) - 1;\n    for (let j = 0; j \u003c k; j++) if (j !== i && j !== i + 1) par[find(id(t, j))] = find(id(t + 1, j));\n    const oi = g > 0 ? id(t, i) : id(t, i + 1), oo = g > 0 ? id(t + 1, i + 1) : id(t + 1, i);\n    par[find(oi)] = find(oo);\n    eqs.push([oi, g > 0 ? id(t, i + 1) : id(t, i), g > 0 ? id(t + 1, i) : id(t + 1, i + 1)]);\n  }\n  const roots = [], arc = new Int32Array(n * k);\n  for (let a = 0; a \u003c n * k; a++) {\n    const r = find(a);\n    if (!roots.includes(r)) roots.push(r);\n    arc[a] = roots.indexOf(r);\n  }\n  // Each crossing as a row: 2 over - under in - under out.\n  const M = eqs.map(([o, a, b]) => {\n    const row = new Array(roots.length).fill(0);\n    row[arc[o]] += 2;\n    row[arc[a]] -= 1;\n    row[arc[b]] -= 1;\n    return row;\n  });\n  return { arc, M, na: roots.length, id };\n}\n\n// The determinant: a minor of the crossing matrix, by Bareiss's fraction-free\n// elimination, which keeps every entry a whole number.\nfunction determinant(M) {\n  const A = M.slice(1).map((r) => r.slice(1)), n = A.length;\n  let prev = 1, sign = 1;\n  for (let c = 0; c \u003c n; c++) {\n    let p = c;\n    while (p \u003c n && A[p][c] === 0) p++;\n    if (p === n) return 0;\n    if (p !== c) {\n      [A[p], A[c]] = [A[c], A[p]];\n      sign = -sign;\n    }\n    for (let r = c + 1; r \u003c n; r++) {\n      for (let q = c + 1; q \u003c n; q++) A[r][q] = (A[r][q] * A[c][c] - A[r][c] * A[c][q]) / prev;\n      A[r][c] = 0;\n    }\n    prev = A[c][c];\n  }\n  return abs(sign * (n ? A[n - 1][n - 1] : 1));\n}\n\nconst mod = (a, p) => ((a % p) + p) % p;\nfunction inverse(a, p) {\n  let r = 1;\n  for (let e = p - 2, b = a; e > 0; e >>= 1, b = (b * b) % p) if (e & 1) r = (r * b) % p;\n  return r;\n}\n\n// The colourings mod p as a basis: the non-constant directions found with\n// arc 0 held at 0, then the constant vector.\nfunction colourings(M, na, p) {\n  const A = M.map((r) => r.map((v) => mod(v, p)));\n  A.push(new Array(na).fill(0).map((_, i) => (i === 0 ? 1 : 0)));\n  const pivots = [];\n  let row = 0;\n  for (let c = 0; c \u003c na && row \u003c A.length; c++) {\n    let r = row;\n    while (r \u003c A.length && A[r][c] === 0) r++;\n    if (r === A.length) continue;\n    [A[r], A[row]] = [A[row], A[r]];\n    const iv = inverse(A[row][c], p);\n    for (let q = 0; q \u003c na; q++) A[row][q] = (A[row][q] * iv) % p;\n    for (let r2 = 0; r2 \u003c A.length; r2++) {\n      if (r2 === row || !A[r2][c]) continue;\n      const f = A[r2][c];\n      for (let q = 0; q \u003c na; q++) A[r2][q] = mod(A[r2][q] - f * A[row][q], p);\n    }\n    pivots.push(c);\n    row++;\n  }\n  const basis = [];\n  for (let f = 0; f \u003c na; f++) {\n    if (pivots.includes(f)) continue;\n    const v = new Array(na).fill(0);\n    v[f] = 1;\n    pivots.forEach((c, r) => (v[c] = mod(-A[r][f], p)));\n    basis.push(v);\n  }\n  basis.push(new Array(na).fill(1));\n  return basis;\n}\n\n// The path of the knot, sampled every quarter LED or so, in the order it is\n// drawn: down the braid, round the closing arc on the right, down again\n// from the next place, until it comes back to place 0.\nfunction layout(k, w) {\n  const n = w.length;\n  const yt = [], yb = [];\n  for (let j = 0; j \u003c k; j++) {\n    yt.push(10 + 4 * j);\n    yb.push(124 - 4 * j);\n  }\n  const y0 = yt[k - 1] + 5, y1 = yb[k - 1] - 5, band = (y1 - y0) / n;\n  // Wide crossings where there is height for them, narrower where many share it.\n  const sp = min([0, 0, 22, 13, 9][k], max(9, round(band * 1.25))), rs = [0, 0, 11, 8, 6][k], gap = [0, 0, 12, 11, 9][k];\n  const width = (k - 1) * sp + gap + (k - 1) * rs, x0 = round(2 + (59 - width) / 2);\n  const xb = [], xr = [];\n  for (let j = 0; j \u003c k; j++) {\n    xb.push(x0 + j * sp);\n    xr.push(x0 + (k - 1) * sp + gap + (k - 1 - j) * rs);\n  }\n  return { xb, xr, yt, yb, y0, y1, band };\n}\n\nfunction build(S, ki) {\n  const [k, w] = KNOTS[ki], n = w.length;\n  const { arc, M, na, id } = arcsOf(k, w);\n  S.ki = ki;\n  S.M = M;\n  S.na = na;\n  S.det = determinant(M);\n  const L = layout(k, w), xs = [], ys = [], as = [], fl = [];\n  const add = (x, y, a, f) => {\n    xs.push(x);\n    ys.push(y);\n    as.push(a);\n    fl.push(f);\n  };\n  const line = (xa, ya, xb, yb, a) => {\n    const m = max(1, Math.ceil(Math.hypot(xb - xa, yb - ya) * 3));\n    for (let i = 0; i \u003c m; i++) add(xa + ((xb - xa) * i) / m, ya + ((yb - ya) * i) / m, a, 0);\n  };\n  const turn = (cx, cy, r, a0, a1, a) => {\n    for (let i = 0; i \u003c 12; i++) {\n      const t = a0 + ((a1 - a0) * i) / 12;\n      add(cx + r * cos(t), cy + r * sin(t), a, 0);\n    }\n  };\n  const R = 3;\n  let j = 0;\n  do {\n    for (let t = 0; t \u003c n; t++) {\n      const g = w[t], i = abs(g) - 1, ya = L.y0 + t * L.band;\n      if (j !== i && j !== i + 1) {\n        line(L.xb[j], ya, L.xb[j], ya + L.band, arc[id(t, j)]);\n        continue;\n      }\n      const jj = j === i ? i + 1 : i, over = g > 0 ? j === i : j === i + 1;\n      const m = Math.ceil(L.band * 5);\n      for (let s = 0; s \u003c m; s++) {\n        const u = s / m;\n        // 1: in front through this crossing; 2: in front near its middle, where it cuts the gap.\n        const f = over ? (abs(u - 0.5) \u003c 0.3 ? 2 : 1) : 0;\n        add(L.xb[j] + (L.xb[jj] - L.xb[j]) * ease(u), ya + u * L.band, over || u \u003c 0.5 ? arc[id(t, j)] : arc[id(t + 1, jj)], f);\n      }\n      j = jj;\n    }\n    // Round the right side and back to the top of the braid at place j.\n    const a = arc[id(0, j)], xl = L.xb[j], xr = L.xr[j], yt = L.yt[j], yb = L.yb[j];\n    line(xl, L.y1, xl, yb - R, a);\n    turn(xl + R, yb - R, R, PI, PI / 2, a);\n    line(xl + R, yb, xr - R, yb, a);\n    turn(xr - R, yb - R, R, PI / 2, 0, a);\n    line(xr, yb - R, xr, yt + R, a);\n    turn(xr - R, yt + R, R, 0, -PI / 2, a);\n    line(xr - R, yt, xl + R, yt, a);\n    turn(xl + R, yt + R, R, -PI / 2, -PI, a);\n    line(xl, yt + R, xl, L.y0, a);\n  } while (j !== 0);\n  // Distance along the knot, for the brightening that runs round it.\n  const ss = [0];\n  for (let i = 1; i \u003c xs.length; i++) ss.push(ss[i - 1] + Math.hypot(xs[i] - xs[i - 1], ys[i] - ys[i - 1]));\n  S.len = ss[ss.length - 1];\n  // Rasterise: every sample, then a dark margin round each over-strand near\n  // its crossing, then the over-strands again on top.\n  const { pa, pd, ps } = S;\n  pa.fill(-1);\n  pd.fill(9);\n  const stamp = (i, r, dark) => {\n    const fx = xs[i], fy = ys[i];\n    for (let y = Math.ceil(fy - r); y \u003c= floor(fy + r); y++)\n      for (let x = Math.ceil(fx - r); x \u003c= floor(fx + r); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const dd = (x - fx) * (x - fx) + (y - fy) * (y - fy);\n        if (dd > r * r) continue;\n        const p = y * W + x;\n        if (dark) {\n          pa[p] = -1;\n          pd[p] = 9;\n        } else if (pa[p] !== as[i] || dd \u003c pd[p]) {\n          pa[p] = as[i];\n          pd[p] = dd;\n          ps[p] = ss[i];\n        }\n      }\n  };\n  for (let i = 0; i \u003c xs.length; i++) stamp(i, RAD, false);\n  for (let i = 0; i \u003c xs.length; i++) if (fl[i] === 2) stamp(i, RAD + GAP, true);\n  for (let i = 0; i \u003c xs.length; i++) if (fl[i]) stamp(i, RAD, false);\n}\n\n// Label of each arc in colouring m of the walk: the digits of m in base p\n// turned into a modular Gray code, digit i the coefficient of basis vector i.\nfunction labels(S, m, out) {\n  const { basis, p } = S, d = basis.length;\n  out.fill(0);\n  let rest = mod(m, S.count);\n  const dig = [];\n  for (let i = 0; i \u003c d; i++) {\n    dig.push(rest % p);\n    rest = floor(rest / p);\n  }\n  for (let i = 0; i \u003c d; i++) {\n    const g = mod(dig[i] - (i + 1 \u003c d ? dig[i + 1] : 0), p);\n    if (g) for (let a = 0; a \u003c S.na; a++) out[a] = (out[a] + g * basis[i][a]) % p;\n  }\n  return out;\n}\n\nfunction text(S) {\n  const tx = S.tx;\n  tx.fill(0);\n  const put = (s, x, y, v) => {\n    for (const ch of s) {\n      const g = GLYPH[ch].split(\" \");\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\" && x + q \u003c W) tx[(y + r) * W + x + q] = v;\n      x += 4;\n    }\n    return x;\n  };\n  // p, raised d, \"=\", the count; the determinant at the right.\n  let x = put(String(S.p), 1, 2, 2);\n  x = put(String(S.basis.length), x, 0, 1);\n  x = put(\"=\", x, 2, 1);\n  put(String(S.count), x, 2, 2);\n  const ds = \"det\" + S.det;\n  put(ds, W - 4 * ds.length, 2, 1);\n}\n\nexport function setup(params) {\n  params.s = {\n    ki: -1, pi: -1, p: 3, hue: 0, speed: 2, w: 0, wave: 0, basis: [], count: 1, det: 1, M: [], na: 0, len: 1,\n    pa: new Int16Array(N), pd: new Float32Array(N), ps: new Float32Array(N), tx: new Uint8Array(N),\n    la: new Int32Array(16), lb: new Int32Array(16), col: new Float32Array(48), tmp: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ki = min(KNOTS.length - 1, floor(cl(k[2] || 0, 0, 1) * KNOTS.length));\n  const pi = min(PRIMES.length - 1, floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * PRIMES.length));\n  if (ki !== S.ki || pi !== S.pi) {\n    if (ki !== S.ki) build(S, ki);\n    S.pi = pi;\n    S.p = PRIMES[pi];\n    S.basis = colourings(S.M, S.na, S.p);\n    S.count = S.p ** S.basis.length;\n    // Open on a colouring that is not constant when there is one, settled.\n    S.w = (S.basis.length > 1 ? 1 : 0) + DIP;\n    text(S);\n  }\n  S.w += (d * S.speed) / STEP;\n  S.wave += (d * S.speed) / 18;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.ki \u003c 0) return;\n  const { pa, pd, ps, tx, col, la, lb, p } = S;\n  const m = floor(S.w), fr = S.w - m, u = fr / DIP;\n  labels(S, m, la);\n  labels(S, m - 1, lb);\n  // Colour of each arc: its label's hue, and while the colouring changes,\n  // the arcs that change dip dark and turn at the bottom of the dip.\n  for (let a = 0; a \u003c S.na; a++) {\n    let lab = la[a], v = 1;\n    if (u \u003c 1 && la[a] !== lb[a]) {\n      v = 1 - 0.85 * sin(PI * u);\n      if (u \u003c 0.5) lab = lb[a];\n    }\n    const c = hsv(S.hue + HUE0 + lab / p, 0.85, v, S.tmp);\n    col[a * 3] = c[0];\n    col[a * 3 + 1] = c[1];\n    col[a * 3 + 2] = c[2];\n  }\n  const ph = S.wave - floor(S.wave), L = S.len;\n  for (let i = 0; i \u003c N; i++) {\n    const a = pa[i], x = i % W, y = (i - x) / W;\n    if (a >= 0) {\n      // Brighter down the middle of a strand, and a little brighter where the\n      // slow wave round the knot is passing.\n      const wv = 0.82 + 0.18 * cos(2 * PI * (ps[i] / L - ph) * 3);\n      const b = (1 - 0.45 * (pd[i] / (RAD * RAD))) * wv;\n      display.setPixel(x, y, round(col[a * 3] * b), round(col[a * 3 + 1] * b), round(col[a * 3 + 2] * b));\n    } else if (tx[i]) {\n      const v = tx[i] === 2 ? 235 : 150;\n      display.setPixel(x, y, v, v, v);\n    } else display.setPixel(x, y, 0, 0, 0);\n  }\n}\n","franklin-involution":"// ===== Patternflow pattern =====\n// Title:   Franklin's Involution\n// Family:  number\n// Idea:    Every partition of n into distinct parts stands in turn as a Ferrers diagram of square dots in the top third, coloured by whether it has an even or an odd number of parts, over a faint lattice of every dot place a partition of n can reach, and Franklin's move flies its smallest row onto the slope of its largest rows, or the slope down into a new smallest row, leaving fading trails, to build its partner of the other colour in the bottom third, while the middle third counts the two colours level and writes Euler's series one coefficient at a time, until at a pentagonal n one staircase-trapezoid has no move to make and stands framed above the sign it gives the series.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler's pentagonal number theorem (Leonhard Euler, 1750) and Fabian Franklin's involution on partitions into distinct parts (Sur le développement du produit infini (1 - x)(1 - x^2)(1 - x^3)..., Comptes Rendus, 1881), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, N=5..16, Gap=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel, always opposite. At 0 partitions with an even number of parts are azure and odd ones amber; at 0.5 the two swap.\n// Knob 2: Speed. A partition takes 2.4 / Speed seconds: 1.2 s at the opening 2, 12 s at 0.2, 0.8 s at 3. The moved dots leave one after another, the last 0.3 of that time after the first, and each takes 0.42 of it to land; their trails keep a third of their light after a step.\n// Knob 3: N. The n the walk starts from, 5 to 16; it goes on to n + 1 after the last partition of n and back to N after 16. At the opening 5, (5) and (4, 1) turn into each other and then (3, 2) has no move, which gives x^5 its +1; n = 6 then comes out even, two pairs, and n = 7 ends on (4, 3). At 16 a pass is 32 partitions, 38 s.\n// Knob 4: Gap. The gap between dots as a share of their spacing: one LED at the opening 0.06, so the rows read as rows of square dots; at 0.5 the dots are five eighths of the spacing, at 1 a quarter.\n\n// Euler: (1 - x)(1 - x^2)(1 - x^3)... = 1 - x - x^2 + x^5 + x^7 - x^12 -\n// x^15 + ..., the exponents the pentagonal numbers k(3k - 1)/2 and\n// k(3k + 1)/2 with sign (-1)^k. Multiplied out, the product counts each\n// partition of n into distinct parts with +1 if it has an even number of\n// parts and -1 if odd, so the theorem says those two counts are equal\n// except at a pentagonal n.\n//\n// Franklin pairs them off. In the Ferrers diagram (largest part on top)\n// let s be the smallest part and sigma the slope, the number of top rows\n// that each fall short of the one above by exactly one dot. If s \u003c= sigma,\n// take the smallest row away and put one of its dots at the end of each of\n// the s largest rows; if s > sigma, take the last dot from each of the sigma\n// largest rows and lay them down as a new smallest row. The number of parts\n// changes by one and doing it twice gives back the partition. It fails only\n// when the slope runs down to the smallest row and shares its last dot,\n// with s = sigma = k or s = sigma + 1 = k + 1, the partitions (2k - 1, ...,\n// k) and (2k, ..., k + 1) of k(3k - 1)/2 and k(3k + 1)/2: (3, 2) for 5,\n// (4, 3) for 7, (5, 4, 3) for 12, (6, 5, 4) for 15.\n//\n// Each partition comes on top once, its partner straight after it, so a\n// pair is seen both ways round, and the lone one, if n has one, comes last.\n// The pair shares one dot spacing, the largest that fits both in a third\n// of the panel, up to 14 LEDs: 12 for (5) and (4, 1), 4 for (13) and (12, 1).\n// Behind each diagram every dot place that some partition of n uses is lit\n// faintly, brighter the more partitions use it (the first place is in all\n// of them, the end of the row (n) in one) and tinted by the share of those\n// with an even number of parts.\n\nconst W = 64, H = 128, TOP = 1, BOT = 85, REG = 42, NMAX = 16, UR = 6, UC = NMAX + 1;\nconst { floor, min, max, round, PI, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Digits and signs, 3 by 5, drawn for this pattern.\nconst GL = {\n  0: \"### #.# #.# #.# ###\", 1: \".#. ##. .#. .#. ###\", 2: \"### ..# ### #.. ###\", 3: \"### ..# .## ..# ###\",\n  4: \"#.# #.# ### ..# ..#\", 5: \"### #.. ### ..# ###\", 6: \"### #.. ### #.# ###\", 7: \"### ..# .#. .#. .#.\",\n  8: \"### #.# ### #.# ###\", 9: \"### #.# ### ..# ###\", \"+\": \"... .#. ### .#. ...\", \"-\": \"... ... ### ... ...\",\n};\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0] * 255;\n  o[1] = v[1] * 255;\n  o[2] = v[2] * 255;\n  return o;\n}\n\n// ---- Partitions -----------------------------------------------------------\n\n// Partitions of n into distinct parts, largest first, (n) first of all.\nfunction partitions(n) {\n  const out = [];\n  const rec = (rem, top, cur) => {\n    if (!rem) return void out.push(cur.slice());\n    for (let a = min(rem, top); a >= 1; a--) {\n      cur.push(a);\n      rec(rem - a, a - 1, cur);\n      cur.pop();\n    }\n  };\n  rec(n, n, []);\n  return out;\n}\n\n// Franklin's move on l: the partner and which dots go where, [row, column]\n// in l to [row, column] in the partner; null for the lone partition, with\n// the dots that block it.\nfunction franklin(l) {\n  const k = l.length, s = l[k - 1];\n  let sg = 1;\n  while (sg \u003c k && l[sg] === l[sg - 1] - 1) sg++;\n  const slope = [], low = [];\n  for (let i = 0; i \u003c sg; i++) slope.push([i, l[i] - 1]);\n  for (let j = 0; j \u003c s; j++) low.push([k - 1, j]);\n  if (s \u003c= sg) {\n    if (sg === k && s === k) return { m: null, slope, low };\n    const m = l.slice(0, k - 1);\n    for (let i = 0; i \u003c s; i++) m[i]++;\n    return { m, moves: low.map(([r, c]) => [[r, c], [c, l[c]]]) };\n  }\n  if (sg === k && s === sg + 1) return { m: null, slope, low };\n  const m = l.slice();\n  for (let i = 0; i \u003c sg; i++) m[i]--;\n  m.push(sg);\n  return { m, moves: slope.map(([r, c]) => [[r, c], [k, r]]) };\n}\n\n// The walk through n: each pair both ways round, then the lone one.\nfunction walk(n) {\n  const seen = new Set(), out = [];\n  let lone = null;\n  for (const l of partitions(n)) {\n    if (seen.has(l.join())) continue;\n    const f = franklin(l);\n    if (!f.m) {\n      lone = { l, f };\n      continue;\n    }\n    seen.add(l.join());\n    seen.add(f.m.join());\n    out.push({ l, f }, { l: f.m, f: franklin(f.m) });\n  }\n  if (lone) out.push(lone);\n  return out;\n}\n\n// Euler's coefficients: (-1)^k at the pentagonal numbers k(3k -+ 1)/2.\nconst COEF = new Int8Array(NMAX + 1);\nfor (let k = 1; k \u003c 5; k++) for (const e of [(k * (3 * k - 1)) / 2, (k * (3 * k + 1)) / 2]) if (e \u003c= NMAX) COEF[e] = k % 2 ? -1 : 1;\n\n// ---- State ----------------------------------------------------------------\n\nexport function setup(params) {\n  params.s = {\n    N: -1, n: 0, steps: [], i: 0, u: 0, e: 0, o: 0, lone: -1, hue: 0, speed: 2, gap: 0.06, t: 0,\n    buf: new Float32Array(W * H * 3), ca: [0, 0, 0], cb: [0, 0, 0],\n    use: new Float32Array(UR * UC), even: new Float32Array(UR * UC), q: 1, trail: new Float32Array(W * H * 3),\n  };\n}\n\n// How many partitions of n use each dot place, row r and column c, and\n// how many of those have an even number of parts.\nfunction usage(S, n) {\n  S.use.fill(0);\n  S.even.fill(0);\n  const P = partitions(n);\n  for (const l of P)\n    for (let r = 0; r \u003c l.length; r++)\n      for (let c = 0; c \u003c l[r]; c++) {\n        S.use[r * UC + c]++;\n        if (l.length % 2 === 0) S.even[r * UC + c]++;\n      }\n  S.q = P.length;\n}\n\nfunction begin(S, n) {\n  S.n = n;\n  S.steps = walk(n);\n  usage(S, n);\n  S.i = 0;\n  S.u = 0;\n  S.e = S.o = 0;\n  S.lone = -1;\n  count(S);\n}\n\n// The partition on top is counted as it comes up.\nfunction count(S) {\n  const st = S.steps[S.i];\n  if (st.l.length % 2) S.o++;\n  else S.e++;\n  if (!st.f.m) S.lone = st.l.length % 2;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.gap = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const N = cl(round(k[2] == null ? 5 : k[2]), 5, NMAX);\n  if (N !== S.N) {\n    S.N = N;\n    begin(S, N);\n  }\n  S.t += d;\n  S.u += (d * S.speed) / 2.4;\n  // The trail keeps a third of its light after a step.\n  const keep = Math.exp((-d * S.speed) / 2.2), tr = S.trail;\n  for (let i = 0; i \u003c tr.length; i++) tr[i] *= keep;\n  while (S.u >= 1) {\n    S.u -= 1;\n    if (++S.i >= S.steps.length) begin(S, S.n >= max(NMAX, S.N) ? S.N : S.n + 1);\n    else count(S);\n  }\n}\n\n// ---- Drawing --------------------------------------------------------------\n\nfunction rect(S, x, y, w, h, c, a) {\n  const b = S.buf;\n  for (let yy = max(0, round(y)); yy \u003c min(H, round(y) + h); yy++)\n    for (let xx = max(0, round(x)); xx \u003c min(W, round(x) + w); xx++) {\n      const i = (yy * W + xx) * 3;\n      b[i] = c[0] * a;\n      b[i + 1] = c[1] * a;\n      b[i + 2] = c[2] * a;\n    }\n}\n\nfunction text(S, s, x, y, sc, c, a) {\n  for (const ch of s) {\n    const g = GL[ch].split(\" \");\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\") rect(S, x + q * sc, y + r * sc, sc, sc, c, a);\n    x += 4 * sc;\n  }\n}\n\n// Lay a dot into the trail, keeping the brighter of old and new.\nfunction glow(S, x, y, w, c, a) {\n  const t = S.trail;\n  for (let yy = max(0, round(y)); yy \u003c min(H, round(y) + w); yy++)\n    for (let xx = max(0, round(x)); xx \u003c min(W, round(x) + w); xx++)\n      for (let q = 0, i = (yy * W + xx) * 3; q \u003c 3; q++) t[i + q] = max(t[i + q], c[q] * a);\n}\n\nconst mix = (c, w, o) => ((o[0] = c[0] + (255 - c[0]) * w), (o[1] = c[1] + (255 - c[1]) * w), (o[2] = c[2] + (255 - c[2]) * w), o);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.steps.length) return;\n  S.buf.set(S.trail);\n  const st = S.steps[S.i], l = st.l, f = st.f, m = f.m, u = S.u;\n  const ca = hsv(S.hue + 0.58, S.ca), cb = hsv(S.hue + 0.08, S.cb);\n  const col = (p) => (p.length % 2 ? cb : ca);\n  const fade = ease(u / 0.1) * (1 - ease((u - 0.94) / 0.06));\n\n  // One spacing for the pair, so the moved dots keep their size.\n  const wide = max(l[0], m ? m[0] : 0), tall = max(l.length, m ? m.length : 0);\n  const p = max(2, min(14, floor(62 / wide), floor((REG - 2) / tall)));\n  const ds = p \u003c= 2 ? 1 : cl(round(p * (1 - 0.75 * S.gap)), 1, p - 1);\n  const left = round((W - (wide * p - (p - ds))) / 2);\n  const ytop = (rows, y0) => y0 + round((REG - (rows * p - (p - ds))) / 2);\n  const yl = ytop(l.length, TOP), ym = m ? ytop(m.length, BOT) : 0;\n  const at = (y0, r, c) => [left + c * p, y0 + r * p];\n\n  // The middle third. Along the top, Euler's series so far: a cell for\n  // each m up to n, in the even colour for +x^m, the odd one for -x^m, grey\n  // for none, the cell for n blinking until its walk is done. Below, n on\n  // the left and even minus odd so far on the right, then a pip for each\n  // partition counted, even above, odd below.\n  const white = [210, 210, 210], grey = [55, 55, 55];\n  for (let j = 1; j \u003c= S.n; j++) {\n    const c = j \u003c S.n || S.i === S.steps.length - 1 ? COEF[j] : 2;\n    if (c === 2 && sin(S.t * 6) \u003c 0) continue;\n    rect(S, (j - 1) * 4, 46, 3, 3, c > 0 && c \u003c 2 ? ca : c \u003c 0 ? cb : c === 2 ? white : grey, 1);\n  }\n  text(S, String(S.n), 1, 53, 3, white, 1);\n  const dif = S.e - S.o, ds2 = dif > 0 ? \"+\" + dif : String(dif);\n  text(S, ds2, W - (4 * ds2.length - 1) * 3, 53, 3, dif > 0 ? ca : dif \u003c 0 ? cb : white, 1);\n  const pip = min(6, floor(W / Math.ceil(S.steps.length / 2)));\n  for (let j = 0; j \u003c S.e; j++) rect(S, j * pip, 71, pip - 1, pip - 1, ca, 1);\n  for (let j = 0; j \u003c S.o; j++) rect(S, j * pip, 78, pip - 1, pip - 1, cb, 1);\n  if (S.lone >= 0) {\n    // The pip with no partner flashes white.\n    const j = (S.lone ? S.o : S.e) - 1, w = 0.5 + 0.5 * sin(S.t * 6);\n    rect(S, j * pip, S.lone ? 78 : 71, pip - 1, pip - 1, mix(S.lone ? cb : ca, w, [0, 0, 0]), 1);\n  }\n\n  // Under each diagram, faintly, every dot place some partition of n\n  // reaches: the brighter the more partitions use it, tinted from the odd\n  // colour to the even one by the share of them with an even number of parts.\n  const faint = [0, 0, 0];\n  const lattice = (y0) => {\n    for (let r = 0; r \u003c UR; r++)\n      for (let c = 0; c \u003c UC; c++) {\n        const k = S.use[r * UC + c];\n        if (!k) continue;\n        const [x, y] = at(y0, r, c);\n        if (x >= W || y \u003c y0 - 1 || y + ds > (y0 \u003c BOT ? TOP + REG : H)) continue;\n        const w = S.even[r * UC + c] / k, a = (0.05 + 0.13 * (k / S.q)) * fade;\n        for (let q = 0; q \u003c 3; q++) faint[q] = ca[q] * w + cb[q] * (1 - w);\n        rect(S, x, y, ds, ds, faint, a);\n      }\n  };\n  lattice(yl);\n  if (m) lattice(ym);\n\n  const hl = [0, 0, 0];\n  if (!m) {\n    // The lone partition: its smallest row and its slope lit, the dot they\n    // share flashing, a frame round it, and the sign it gives below.\n    const mark = new Set([...f.slope, ...f.low].map(([r, c]) => r * 64 + c));\n    const shared = (l.length - 1) * 64 + l[l.length - 1] - 1;\n    for (let r = 0; r \u003c l.length; r++)\n      for (let c = 0; c \u003c l[r]; c++) {\n        const [x, y] = at(yl, r, c), key = r * 64 + c;\n        const w = key === shared ? 0.5 + 0.5 * sin(S.t * 6) : mark.has(key) ? 0.45 : 0;\n        rect(S, x, y, ds, ds, mix(col(l), w, hl), fade);\n      }\n    const fx0 = left - 3, fy0 = yl - 3, fw = l[0] * p - (p - ds) + 6, fh = l.length * p - (p - ds) + 6;\n    for (const [x, y, w, h] of [[fx0, fy0, fw, 1], [fx0, fy0 + fh - 1, fw, 1], [fx0, fy0, 1, fh], [fx0 + fw - 1, fy0, 1, fh]]) rect(S, x, y, w, h, white, fade);\n    const sg = l.length % 2 ? \"-1\" : \"+1\", a = ease((u - 0.25) / 0.2) * fade;\n    text(S, sg, round((W - 7 * 6) / 2), BOT + 10, 6, col(l), a);\n  } else {\n    // Dots that stay, top and bottom.\n    const from = new Set(f.moves.map(([a]) => a[0] * 64 + a[1])), to = new Set(f.moves.map(([, b]) => b[0] * 64 + b[1]));\n    const n = f.moves.length;\n    const v = f.moves.map((_, j) => ease((u - 0.14 - (n > 1 ? (0.3 * j) / (n - 1) : 0)) / 0.42));\n    for (let r = 0; r \u003c l.length; r++)\n      for (let c = 0; c \u003c l[r]; c++) {\n        const [x, y] = at(yl, r, c);\n        if (!from.has(r * 64 + c)) rect(S, x, y, ds, ds, col(l), fade);\n        // A dot about to move is lit; once gone it leaves a dim ghost.\n        else rect(S, x, y, ds, ds, mix(col(l), 0.45, hl), fade * (v[f.moves.findIndex(([a]) => a[0] === r && a[1] === c)] > 0 ? 0.22 : 1));\n      }\n    for (let r = 0; r \u003c m.length; r++)\n      for (let c = 0; c \u003c m[r]; c++) if (!to.has(r * 64 + c)) rect(S, ...at(ym, r, c), ds, ds, col(m), fade);\n    // The moved dots in flight, bowing out to the right on the way down.\n    // Each leaves its path in the trail, which fades over about a step.\n    f.moves.forEach(([a, b], j) => {\n      const [x0, y0] = at(yl, a[0], a[1]), [x1, y1] = at(ym, b[0], b[1]), w = v[j];\n      if (w \u003c= 0) return;\n      const x = x0 + (x1 - x0) * w + sin(PI * w) * (6 + 2 * j), y = y0 + (y1 - y0) * w;\n      const k = mix(col(m), 0.45, hl);\n      if (w \u003c 1) glow(S, x, y, ds, k, 0.4);\n      rect(S, x, y, ds, ds, k, fade);\n    });\n  }\n\n  const b = S.buf;\n  for (let i = 0; i \u003c W * H; i++) display.setPixel(i % W, floor(i / W), round(b[i * 3]), round(b[i * 3 + 1]), round(b[i * 3 + 2]));\n}\n","galileos-frets":"// ===== Patternflow pattern =====\n// Title:   Galileo's Frets\n// Family:  rhythm\n// Idea:    Three grooves run down an inclined plane, each with its own frets and its own ball, all released together from the top: the middle groove's frets sit at the squares 1, 4, 9, 16 so its ball bumps over them on an even beat, the outer two sit at other powers so their beats speed up or slow down, and beside each groove its strikes stand as stripes on a strip of time against the dotted lines of an even metronome.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Galileo's law of fall and the law of odd numbers (Galileo Galilei, Two New Sciences, 1638), the frets on the inclined plane as Stillman Drake read them (The Role of Music in Galileo's Experiments, Scientific American, June 1975), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Law=1..3, Frets=0..1\n//\n// Knob 1: Hue. Turns the three grooves round the wheel together. At 0 the left one is azure, Galileo's in the middle green and the right one magenta.\n// Knob 2: Speed. How steep the plane is. The acceleration goes as the knob, so a fall takes 4 s at 2 (with 8 frets Galileo's groove strikes every 0.5 s), 12.6 s at 0.2 and 3.3 s at 3.\n// Knob 3: Law. The exponent p of the left groove's frets, which sit at (n/N)^p of the plane; the right groove takes 4 - p. At the opening 1, even spacing, whose first strike comes 1.41 s into a 4 s fall and whose last two are 0.26 s apart, against the cubes on the right, which strike first 0.18 s in and last 0.73 s after the one before. At 2 all three grooves are Galileo's and strike together on the beat; at 3 the outer two have swapped.\n// Knob 4: Frets. How many frets each groove has: 8 at the opening, 10, 12 and 14 at the quarters, 16 at the end.\n\n// A ball rolling from rest down a plane covers x = a t^2 / 2, so in equal\n// times it covers distances in the ratio of the odd numbers 1, 3, 5, 7, and\n// after n beats it has gone n^2. Drake read Galileo's working notes as an\n// experiment done by ear: gut frets tied round the plane, the ball bumping\n// over each, the frets moved until the bumps came on an even beat, and their\n// distances then measured from the start, which came out as the squares.\n//\n// Here the three grooves share one plane, so their balls fall together, and\n// they differ only in where their frets are: fret n of N at (n/N)^p of the\n// plane's 128 rows. The ball crosses it at (n/N)^(p/2) of the time of the\n// fall, and only p = 2 makes that n/N, the beat. Beside each groove is a\n// strip of time, 128 rows for the length of the fall, with the metronome's\n// N even marks down its left edge and carried across it as dotted lines.\n// Stretch n of the groove, fret n - 1 to fret n, and stretch n of the strip,\n// strike n - 1 to strike n, are one piece of the fall, once as a distance\n// and once as a time. In Galileo's groove the stretches grow 1, 3, 5, 7\n// and their times are all equal, so its stripes lie on the dotted lines;\n// with even frets the times shrink, with the cubes they grow. A white mark\n// runs down the metronome at an even pace while the ball runs down the\n// groove ever faster, and both get to the bottom together.\n\n// Each lane is 21 LEDs: the groove between walls 8 apart, then the\n// metronome's column and the strip of time.\nconst W = 64, H = 128, N = W * H, LANES = 3, LW = 21, GR = 8, REST = 0.35;\nconst { floor, min, max, round, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst HUES = [0.57, 0.31, 0.87];\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, law: 1, nf: 8, t: 0, T: 4,\n    flash: [new Float32Array(17), new Float32Array(17), new Float32Array(17)],\n    buf: new Float32Array(N * 3), col: [0, 0, 0],\n  };\n}\n\n// Exponents of the three grooves' frets: Law, Galileo's 2, and 4 - Law.\nconst laws = (S) => [S.law, 2, 4 - S.law];\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.law = cl(k[2] == null ? 1 : k[2], 1, 3);\n  S.nf = 8 + round(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 8);\n  // The acceleration goes as Speed, so the time of a fall as 1/sqrt(Speed).\n  S.T = 4 * sqrt(2 / S.speed);\n  const u0 = S.t / S.T;\n  S.t += d;\n  const u1 = S.t / S.T, P = laws(S);\n  for (const f of S.flash) for (let n = 0; n \u003c f.length; n++) f[n] = max(0, f[n] - d * 4);\n  // A fret struck between the last frame and this one flashes.\n  for (let L = 0; L \u003c LANES; L++)\n    for (let n = 1; n \u003c= S.nf; n++) {\n      const tn = (n / S.nf) ** (P[L] / 2);\n      if (tn > u0 && tn \u003c= u1) S.flash[L][n] = 1;\n    }\n  if (S.t >= S.T + REST) S.t = 0;\n}\n\nfunction add(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  buf[p] += c[0] * a;\n  buf[p + 1] += c[1] * a;\n  buf[p + 2] += c[2] * a;\n}\n\nfunction band(buf, x0, x1, y0, y1, c, a) {\n  for (let y = max(0, y0); y \u003c= min(H - 1, y1); y++) for (let x = x0; x \u003c= x1; x++) add(buf, x, y, c, a);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, col = S.col, nf = S.nf, u = min(1, S.t / S.T), by = (H - 1) * u * u, P = laws(S);\n  buf.fill(0);\n  const white = [1, 1, 1];\n  for (let L = 0; L \u003c LANES; L++) {\n    const ox = L * LW, p = P[L], fl = S.flash[L], gr = ox + GR, mx = gr + 2, sx = gr + 4, ex = ox + LW - 1, bx = ox + GR / 2;\n    hsv(S.hue + HUES[L], col);\n    // The stretches of the groove and of the strip: the strip's shaded\n    // alternately, and both lit while the ball is in that stretch.\n    let g0 = 0, s0 = 0;\n    for (let n = 1; n \u003c= nf; n++) {\n      const g1 = round((H - 1) * (n / nf) ** p), s1 = round((H - 1) * (n / nf) ** (p / 2)), f = fl[n];\n      const now = u \u003c 1 && by \u003c g1 && by >= g0;\n      band(buf, ox + 1, gr - 1, g0 + 1, g1 - 1, col, now ? 0.5 : 0.03);\n      band(buf, sx, ex, s0 + 1, s1 - 1, col, (n % 2 ? 0.26 : 0.08) + (now ? 0.4 : 0));\n      // The fret, and the strike in the strip, flash white as the ball\n      // bumps over it.\n      band(buf, ox, gr, g1, g1, col, 0.6 + 0.4 * f);\n      band(buf, ox, gr, g1, g1, white, 0.7 * f);\n      band(buf, sx, ex, s1, s1, col, 0.6 + 0.4 * f);\n      band(buf, sx, ex, s1, s1, white, 0.7 * f);\n      g0 = g1;\n      s0 = s1;\n    }\n    band(buf, ox, ox, 0, H - 1, col, 0.25);\n    band(buf, gr, gr, 0, H - 1, col, 0.25);\n    // The metronome down the strip's left edge: N even marks, and time\n    // running down past them at an even pace.\n    const ty = round((H - 1) * u);\n    band(buf, mx, mx + 1, 0, ty, white, 0.1);\n    for (let n = 1; n \u003c= nf; n++) {\n      const y = round(((H - 1) * n) / nf);\n      band(buf, mx, mx + 1, y, y, white, 0.45);\n      // Carried across the strip as a dotted line, so a strike on the beat\n      // lies on it.\n      for (let x = sx + 1; x \u003c= ex; x += 2) add(buf, x, y, white, 0.3);\n    }\n    band(buf, mx, mx + 1, ty, ty, white, 1);\n    // The ball, and a streak over the ground it covered in the last 6% of\n    // the fall's time.\n    const v = 2 * (H - 1) * u, tail = min(by, v * 0.06);\n    for (let y = floor(by - tail); y \u003c= by; y++) add(buf, bx, y, white, 0.2 + 0.4 * (1 - (by - y) / max(1, tail)));\n    const yb = round(by);\n    band(buf, bx - 1, bx + 1, yb - 1, yb, white, 0.7);\n    band(buf, bx, bx, yb - 1, yb, white, 0.3);\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","quipu":"// ===== Patternflow pattern =====\n// Title:   Quipu\n// Family:  type\n// Idea:    Pendant cords hang the full height from a primary cord across the top, each holding a number tied in decimal place clusters, thousands at the top and units nearest the free end, single knots counted out for the upper places, a long knot of two to nine turns or a figure-eight for the units and bare cord for zero, with the digit written in small figures beside each cluster; the cords count up at their own rates, knots flash as they are tied and fade as a carry unties them, and each change runs along the primary cord to the pale cord at the end of the group, which always comes back to their sum.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: khipu of the Inka as Leland Locke read their decimal knots and sum cords (L. Leland Locke, The Ancient Quipu or Peruvian Knot Record, 1923), with the knot types of Marcia and Robert Ascher (Code of the Quipu, 1981), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cords=5..8, Step=0..1\n//\n// Knob 1: Hue. Turns the three cord colours round the wheel together. At 0 they are azure, amber and rose; the sum cord stays a pale cream whatever the knob says.\n// Knob 2: Speed. How often the cords count. At 2 the four data cords of the opening tick 0.7 to 2.2 times a second, 5.6 ticks a second in all reaching the sum; 0.2 is ten times slower, 3 half as fast again. A cord jumps from 40% to full strength when it ticks, and the extra light falls to 37% in 0.8 s.\n// Knob 3: Cords. Pendants on the primary cord, 5 to 8, the last always the sum of the others. With 4 data cords each counts up to 2499 and wraps to the remainder, with 7 up to 1428, so the sum never needs a fifth place. Up to 7 the cords are 2 LEDs thick; 8 only fit at 1.\n// Knob 4: Step. What one tick adds to a data cord, five stations: 1, 10, 100, 111, 1111. At 1 the long knot grows a turn a tick and every tenth tick unties it and ties a ten; at 10 the units hold still and the tens count; at 100 the hundreds count and a thousand is tied every tenth tick; at 111 the units, tens and hundreds each take a knot every tick; at 1111 all four places do, and with 4 data cords a cord passes 2499 every two or three ticks and wraps.\n\n// A khipu records a number on a pendant cord in clusters of knots, one\n// cluster for each decimal place, the places at the same height on every\n// cord so that they read across as rows. Locke showed this in 1912 and set\n// it out in the 1923 monograph, along with cords whose values are the sums\n// of a group of pendants. The Aschers' notation names three knots: s, the\n// single overhand knot, one for each unit of a place above the units; L,\n// the long knot, a coil of 2 to 9 turns that holds the units digit, so the\n// units place can be told from the others even where the places of\n// neighbouring cords do not line up; and\n// E, the figure-eight, for a units digit of 1, since a long knot of one\n// turn is just a single knot. A place holding zero is a stretch of bare\n// cord.\n//\n// Here a single knot is a bead one LED wider than the cord on each side\n// and 2 rows tall, with a row of bare cord between beads; a long knot is a\n// coil of turns 2 rows apart, each slanting across the cord, bright in\n// front and dim behind; a figure-eight is two loops stacked on the cord,\n// washed toward white. The four places start at rows 8, 37,\n// 66 and 96, so nine single knots (26 rows) fit in each. Each data cord\n// ticks on its own clock. Its change runs along the primary cord at 80\n// LEDs a second (at Speed 2) and the sum cord adds it on arrival, so the\n// sum is exact whenever nothing is on its way.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Top row of each place's cluster: units, tens, hundreds, thousands.\nconst TIER = [96, 66, 37, 8];\nconst P10 = [1, 10, 100, 1000];\nconst STEPS = [1, 10, 100, 111, 1111];\n// Ticks a second at Speed 1 for each data cord.\nconst RATE = [0.5, 0.85, 0.35, 1.1, 0.65, 0.95, 0.42];\n// LEDs a second a change runs along the primary cord at Speed 1.\nconst RUN = 40;\n// Category hues of the data cords, before the Hue knob.\nconst CAT = [0.56, 0.11, 0.9];\n// Seconds a knot takes to be tied or untied, and for a cord's glow to fall\n// to a third.\nconst TT = 0.3, GLOW = 0.8;\nconst BLACK = [0, 0, 0];\n\nconst FONT = [\n  \"### #.# #.# #.# ###\", \".#. ##. .#. .#. ###\", \"### ..# ### #.. ###\", \"### ..# .## ..# ###\", \"#.# #.# ### ..# ..#\",\n  \"### #.. ### ..# ###\", \"### #.. ### #.# ###\", \"### ..# ..# .#. .#.\", \"### #.# ### #.# ###\", \"### #.# ### ..# ###\",\n].map((s) => s.split(\" \"));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [\n    255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p),\n    255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p),\n    255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p),\n  ];\n}\n\nconst newCord = (v, rate, x) => ({ v, pv: v, tc: 9, glow: 0, acc: Math.random(), rate, x, end: 116 + floor(Math.random() * 7), ph: floor(Math.random() * 3) });\n\nfunction build(S, n) {\n  S.n = n;\n  S.cw = n \u003c= 7 ? 2 : 1;\n  S.cap = floor(9999 / (n - 1));\n  S.cords = [];\n  S.sparks = [];\n  // Each cord needs its beads (x - 1 to x + cw) and its figures (x + cw + 2\n  // to x + cw + 4) and a dark LED either side of them.\n  const span = 63 - (S.cw + 5);\n  let total = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const x = 1 + round((i * span) / (n - 1));\n    if (i \u003c n - 1) {\n      const v = floor(Math.random() * (S.cap + 1));\n      total += v;\n      S.cords.push(newCord(v, RATE[i], x));\n    } else S.cords.push(newCord(total, 0, x));\n  }\n}\n\nexport function setup(params) {\n  params.s = { n: 0, cw: 2, cap: 0, hue: 0, speed: 2, step: 1, cords: [], sparks: [], buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const n = cl(floor((k[2] == null ? 5 : k[2]) + 0.25), 5, 8);\n  if (n !== S.n) build(S, n);\n  S.step = STEPS[min(4, floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 5))];\n  const C = S.cords, sum = C[n - 1], fade = exp(-d / GLOW);\n  for (let i = 0; i \u003c n; i++) {\n    const c = C[i];\n    c.tc += d;\n    c.glow *= fade;\n    if (i === n - 1) break;\n    c.acc += d * S.speed * c.rate;\n    while (c.acc >= 1) {\n      c.acc -= 1;\n      c.pv = c.v;\n      c.v = (c.v + S.step) % (S.cap + 1);\n      c.tc = 0;\n      c.glow = 1;\n      // A wrap carries a negative amount.\n      S.sparks.push({ i, x: c.x, delta: c.v - c.pv });\n    }\n  }\n  const run = RUN * S.speed * d;\n  S.sparks = S.sparks.filter((sp) => {\n    sp.x += run;\n    if (sp.x \u003c sum.x) return true;\n    sum.pv = sum.v;\n    sum.v += sp.delta;\n    sum.tc = 0;\n    sum.glow = 1;\n    return false;\n  });\n}\n\n// Strength of the cord being drawn, set before each part of it.\nlet GAIN = 1;\n\nfunction put(buf, x, y, c, b, w) {\n  b *= GAIN;\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || b \u003c 0) return;\n  const o = (y * W + x) * 3;\n  buf[o] = (c[0] + (255 - c[0]) * w) * b;\n  buf[o + 1] = (c[1] + (255 - c[1]) * w) * b;\n  buf[o + 2] = (c[2] + (255 - c[2]) * w) * b;\n}\n\nfunction bar(buf, x0, x1, y, c, b, w) {\n  for (let x = x0; x \u003c= x1; x++) put(buf, x, y, c, b, w);\n}\n\n// How a knot that is there, being tied or being untied, is drawn: its\n// strength and how far it is washed toward white. A new knot flashes\n// nearly white for the first third of its tying.\nfunction look(k, d, pd, u) {\n  if (k \u003c d && k \u003c pd) return [1, 0.15];\n  if (k \u003c d) return u \u003c 0.35 ? [1.15, 0.85] : [1, 0.15 + 0.7 * (1 - u)];\n  if (k \u003c pd) return [0.9 * (1 - u), 0.1];\n  return null;\n}\n\n// The units: a figure-eight for 1, a long knot of d turns for 2 to 9.\nfunction units(buf, x, cw, d, pd, u, c) {\n  const y0 = TIER[0], xr = x + cw;\n  if (d === 1 || pd === 1) {\n    // Steady, being tied, or fading under the long knot that replaces it.\n    const [b, w] = d !== 1 ? [0.9 * (1 - u), 0.1] : pd === 1 ? [1, 0.2] : u \u003c 0.35 ? [1.15, 0.85] : [1, 0.2 + 0.65 * (1 - u)];\n    for (let r = 0; r \u003c 5; r++) {\n      if (r % 2) {\n        put(buf, x - 1, y0 + r, c, b, w);\n        put(buf, xr, y0 + r, c, b, w);\n        bar(buf, x, xr - 1, y0 + r, BLACK, 1, 0);\n      } else bar(buf, x, xr - 1, y0 + r, c, b, r === 2 ? 0.7 : max(w, 0.35));\n    }\n  }\n  // Each turn of a long knot slants across the cord: its front a bright\n  // row from the left, its back a dim row to the right.\n  const ld = d >= 2 ? d : 0, lp = pd >= 2 ? pd : 0, m = max(ld, lp);\n  for (let t = 0; t \u003c m; t++) {\n    const lk = look(t, ld, lp, u);\n    if (!lk) continue;\n    const y = y0 + 2 * t;\n    bar(buf, x - 1, xr - 1, y, c, lk[0], lk[1]);\n    put(buf, xr, y, BLACK, 1, 0);\n    put(buf, x - 1, y + 1, BLACK, 1, 0);\n    bar(buf, x, xr, y + 1, c, lk[0] * 0.5, lk[1]);\n  }\n}\n\nfunction digit(buf, x, y, dg, c, b) {\n  const g = FONT[dg];\n  for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\") put(buf, x + q, y + r, c, b, 0.25);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const { buf, cords, n, cw } = S;\n  buf.fill(0);\n  GAIN = 1;\n  // The primary cord, three rows of plied cotton.\n  const pc = hsv(0.09, 0.3, 1);\n  for (let y = 2; y \u003c= 4; y++) for (let x = 0; x \u003c W; x++) put(buf, x, y, pc, (x + 2 * y) % 3 === 0 ? 0.32 : 0.55, 0);\n  for (let i = 0; i \u003c n; i++) {\n    const cd = cords[i], x = cd.x, xr = x + cw;\n    const col = i === n - 1 ? hsv(0.12, 0.18, 1) : hsv(S.hue + CAT[i % 3], 0.8, 1);\n    // The pendant, hitched over the primary cord, plied in a slant, and\n    // fraying at its free end. It dims at rest and brightens as it changes.\n    GAIN = 0.4 + 0.6 * cd.glow;\n    put(buf, x - 1, 1, col, 0.6, 0);\n    put(buf, xr, 1, col, 0.6, 0);\n    for (let y = 1; y \u003c= cd.end; y++) for (let c = 0; c \u003c cw; c++) put(buf, x + c, y, col, (y + c + cd.ph) % 3 === 0 ? 0.5 : 0.8, 0);\n    for (let y = cd.end + 1; y \u003c= cd.end + 3; y++) {\n      put(buf, x - 1, y, col, 0.5 - 0.1 * (y - cd.end), 0);\n      put(buf, xr, y, col, 0.5 - 0.1 * (y - cd.end), 0);\n    }\n    // Knots and figures stay near full strength.\n    GAIN = 0.85 + 0.15 * cd.glow;\n    const u = min(1, cd.tc / TT), v = cd.v, pv = cd.pv;\n    for (let q = 3; q >= 0; q--) {\n      const dd = floor(v / P10[q]) % 10, pd = floor(pv / P10[q]) % 10;\n      if (q > 0) {\n        for (let kk = 0; kk \u003c max(dd, pd); kk++) {\n          const lk = look(kk, dd, pd, u);\n          if (!lk) continue;\n          const y = TIER[q] + 3 * kk;\n          bar(buf, x - 1, xr, y, col, lk[0], lk[1]);\n          bar(buf, x - 1, xr, y + 1, col, lk[0], lk[1]);\n        }\n      } else units(buf, x, cw, dd, pd, u, col);\n      // The written digit beside the cluster, from the leading place down.\n      if (v >= P10[q] || q === 0) digit(buf, xr + 2, TIER[q], dd, col, dd === pd || u >= 1 ? 0.8 : 1);\n    }\n  }\n  GAIN = 1;\n  // Changes on their way to the sum cord, a bright head with a short tail.\n  for (const sp of S.sparks) {\n    const col = hsv(S.hue + CAT[sp.i % 3], 0.8, 1), hx = round(sp.x);\n    for (let t = 0; t \u003c 5; t++) for (let y = 2; y \u003c= 4; y++) put(buf, hx - t, y, col, t ? 0.8 - 0.15 * t : 1, t ? 0 : 0.6);\n  }\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, round(buf[p])), min(255, round(buf[p + 1])), min(255, round(buf[p + 2])));\n}\n","square-word":"// ===== Patternflow pattern =====\n// Title:   Square Word\n// Family:  type\n// Idea:    Two English words stand as an ordinary line of letters, one in each half of the panel, and then their letters glide and squeeze into the boxes of a square character the way Xu Bing writes English, left to right, top to bottom, outside to inside, so the panel holds two square characters one above the other, a phrase read top to bottom like vertical writing, before it fades and the next phrase is written.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Square Word Calligraphy (Xu Bing, An Introduction to Square Word Calligraphy, 1994-96); the single-stroke letters and the box templates drawn here, pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Weight=1.5..4\n//\n// Knob 1: Hue. Turns every letter round the wheel together. At 0 the top word runs from gold through yellow to green, 0.07 of the wheel a letter, and the bottom word from azure through blue and violet to magenta, so letters that touch in the square stay apart by colour; at 0.5 the two words swap.\n// Knob 2: Speed. At 2 a phrase takes 8.4 s: the letters are written in a line in 1.3 s, stand 0.7 s, glide into the square over 2.4 s, the two characters hold 3.2 s and fade out over 0.8 s. At 0.2 it all runs ten times slower, at 3 one and a half times faster.\n// Knob 3: Phrase. Which of the eight phrases is written first, to the nearest whole number: 0 LOOK UP, 1 HELLO WORLD, 2 GOOD LUCK, 3 ON AIR, 4 LONG LIFE, 5 ART NOW, 6 OPEN BOOK, 7 READ ME. The others follow in that order.\n// Knob 4: Weight. The pen, 1.5 LEDs wide at the opening up to 4. As a letter goes into the square its strokes thicken by 30% and the upright ones by up to 70%, the way a brush lays a down stroke heavier than a cross stroke; at 4 the O of a line letter fills in, while the O squeezed into HELLO's 19 LED box keeps a hole a few LEDs wide.\n// Buttons: K1 tap fades the phrase and writes the next one.\n\n// A letter is a few polylines on an 8 by 8 grid. Laid into a box of any\n// shape it stretches with it, but its stroke stays the pen's width in\n// LEDs, so the E of HELLO, squeezed into a quarter of the square, keeps\n// three bars and two gaps. A template divides the 58 LED square into\n// boxes in reading order, left to right, top to bottom, outside to\n// inside, which is Xu Bing's rule: a two by two grid, a tall box at the\n// left with one over two at the right, a roof over two, one over two\n// over two, two over three, two tall boxes and a stack, two over one,\n// one over one, and the enclosure, where an O or a U takes the whole\n// square and the next letter sits inside it. Each word was given the\n// template that suits its letters by hand: A as a roof, W wide on top or\n// at the bottom, the long upright of an L, B or R as the left side, O\n// round N and U round P. The narrowest box is the I of LIFE, 12 LEDs\n// across; the L, L and O of HELLO get 19 by 29. Letters keep 1 + 0.7\n// times the pen's width from the edge of their box.\n\nconst W = 64, H = 128, N = W * H, SQ = 58, X0 = 3, Y0 = [3, 67];\nconst { floor, round, min, max, abs, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n// Seconds at Speed 2.\nconst WRITE = 1.3, LINE = 0.7, GLIDE = 2.4, HOLD = 3.2, FADE = 0.8, CYCLE = WRITE + LINE + GLIDE + HOLD + FADE;\nconst HUE0 = 0.12;\n\n// x right, y down, 0..8.\nconst FONT = {\n  A: [[0, 8, 4, 0, 8, 8], [1.5, 5, 6.5, 5]],\n  B: [[0, 0, 0, 8], [0, 0, 5, 0, 7, 1, 7, 3, 5, 4, 0, 4], [5, 4, 7.5, 5, 8, 6.5, 7.5, 7.5, 5.5, 8, 0, 8]],\n  C: [[8, 1.5, 6, 0, 2, 0, 0, 2, 0, 6, 2, 8, 6, 8, 8, 6.5]],\n  D: [[0, 0, 0, 8, 4.5, 8, 8, 5, 8, 3, 4.5, 0, 0, 0]],\n  E: [[8, 0, 0, 0, 0, 8, 8, 8], [0, 4, 6, 4]],\n  F: [[8, 0, 0, 0, 0, 8], [0, 4, 6, 4]],\n  G: [[8, 1.5, 6, 0, 2, 0, 0, 2, 0, 6, 2, 8, 6, 8, 8, 6, 8, 4.5, 4.5, 4.5]],\n  H: [[0, 0, 0, 8], [8, 0, 8, 8], [0, 4, 8, 4]],\n  I: [[4, 0, 4, 8], [1.5, 0, 6.5, 0], [1.5, 8, 6.5, 8]],\n  J: [[3, 0, 8, 0, 8, 6, 6, 8, 2, 8, 0, 6]],\n  K: [[0, 0, 0, 8], [8, 0, 0, 5], [2.6, 3.4, 8, 8]],\n  L: [[0, 0, 0, 8, 8, 8]],\n  M: [[0, 8, 0, 0, 4, 5, 8, 0, 8, 8]],\n  N: [[0, 8, 0, 0, 8, 8, 8, 0]],\n  O: [[2, 0, 6, 0, 8, 2, 8, 6, 6, 8, 2, 8, 0, 6, 0, 2, 2, 0]],\n  P: [[0, 8, 0, 0, 6, 0, 8, 1.5, 8, 3, 6, 4.5, 0, 4.5]],\n  Q: [[2, 0, 6, 0, 8, 2, 8, 6, 6, 8, 2, 8, 0, 6, 0, 2, 2, 0], [4.5, 5, 8, 8.5]],\n  R: [[0, 8, 0, 0, 6, 0, 8, 1.5, 8, 3, 6, 4.5, 0, 4.5], [4, 4.5, 8, 8]],\n  S: [[8, 1.5, 6.5, 0, 1.5, 0, 0, 1.5, 0, 2.5, 1.5, 4, 6.5, 4, 8, 5.5, 8, 6.5, 6.5, 8, 1.5, 8, 0, 6.5]],\n  T: [[0, 0, 8, 0], [4, 0, 4, 8]],\n  U: [[0, 0, 0, 6, 2, 8, 6, 8, 8, 6, 8, 0]],\n  V: [[0, 0, 4, 8, 8, 0]],\n  W: [[0, 0, 2, 8, 4, 3, 6, 8, 8, 0]],\n  X: [[0, 0, 8, 8], [8, 0, 0, 8]],\n  Y: [[0, 0, 4, 4], [8, 0, 4, 4, 4, 8]],\n  Z: [[0, 0, 8, 0, 0, 8, 8, 8]],\n};\n\n// Boxes [x0, y0, x1, y1] in the unit square, in reading order.\nconst T3 = 1 / 3, T6 = 2 / 3;\nconst TPL = {\n  tb: [[0, 0, 1, 0.45], [0, 0.45, 1, 1]],\n  \"o@\": [[0, 0, 1, 1], [0.24, 0.24, 0.76, 0.76]],\n  \"u@\": [[0, 0, 1, 1], [0.24, 0.02, 0.76, 0.74]],\n  \"roof\": [[0, 0, 1, 0.42], [0, 0.42, 0.5, 1], [0.5, 0.42, 1, 1]],\n  \"lr/b\": [[0, 0, 0.5, 0.56], [0.5, 0, 1, 0.56], [0, 0.56, 1, 1]],\n  g4: [[0, 0, 0.5, 0.5], [0.5, 0, 1, 0.5], [0, 0.5, 0.5, 1], [0.5, 0.5, 1, 1]],\n  \"l|t/lr\": [[0, 0, 0.38, 1], [0.38, 0, 1, 0.48], [0.38, 0.48, 0.69, 1], [0.69, 0.48, 1, 1]],\n  \"ll|tb\": [[0, 0, 0.32, 1], [0.32, 0, 0.52, 1], [0.52, 0, 1, 0.5], [0.52, 0.5, 1, 1]],\n  \"lr/lmr\": [[0, 0, 0.5, 0.5], [0.5, 0, 1, 0.5], [0, 0.5, T3, 1], [T3, 0.5, T6, 1], [T6, 0.5, 1, 1]],\n  \"t/lr/lr\": [[0, 0, 1, 0.34], [0, 0.34, 0.5, 0.67], [0.5, 0.34, 1, 0.67], [0, 0.67, 0.5, 1], [0.5, 0.67, 1, 1]],\n};\n\nconst PHRASES = [\n  [[\"LOOK\", \"g4\"], [\"UP\", \"u@\"]],\n  [[\"HELLO\", \"lr/lmr\"], [\"WORLD\", \"t/lr/lr\"]],\n  [[\"GOOD\", \"g4\"], [\"LUCK\", \"l|t/lr\"]],\n  [[\"ON\", \"o@\"], [\"AIR\", \"roof\"]],\n  [[\"LONG\", \"l|t/lr\"], [\"LIFE\", \"ll|tb\"]],\n  [[\"ART\", \"roof\"], [\"NOW\", \"lr/b\"]],\n  [[\"OPEN\", \"g4\"], [\"BOOK\", \"l|t/lr\"]],\n  [[\"READ\", \"l|t/lr\"], [\"ME\", \"tb\"]],\n];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The practice grid behind each character: the square's outline and a\n// dashed cross through its middle, as in a copybook.\nconst GRID = new Uint8Array(N);\nfor (const y0 of Y0) {\n  for (let i = -1; i \u003c= SQ; i++) {\n    for (const [x, y] of [[X0 + i, y0 - 1], [X0 + i, y0 + SQ], [X0 - 1, y0 + i], [X0 + SQ, y0 + i]])\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) GRID[y * W + x] = 2;\n    if (i >= 0 && i \u003c SQ && (i & 3) \u003c 2) {\n      GRID[(y0 + SQ / 2) * W + X0 + i] = 1;\n      GRID[(y0 + i) * W + X0 + SQ / 2] = 1;\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 1, wt: 1.5, st: -1, n: 0, t: 0, btn: false,\n    cov: new Float32Array(N), id: new Uint8Array(N), pal: [], words: [],\n  };\n  for (let i = 0; i \u003c 13; i++) params.s.pal.push([0, 0, 0]);\n  return params.s;\n}\n\n// The letters of a phrase with their two boxes, the line and the square.\nfunction build(S) {\n  const ph = PHRASES[(S.st + S.n) % PHRASES.length];\n  S.words = ph.map(([word, tpl], k) => {\n    const n = word.length, boxes = TPL[tpl], lw = 8.5, lh = 20, adv = 12.4;\n    const lx = 32 - (adv * (n - 1) + lw) / 2, ly = Y0[k] + SQ / 2 - lh / 2;\n    return [...word].map((ch, j) => {\n      const b = boxes[j];\n      return {\n        g: FONT[ch], j, k,\n        line: [lx + adv * j, ly, lx + adv * j + lw, ly + lh],\n        sq: [X0 + b[0] * SQ, Y0[k] + b[1] * SQ, X0 + b[2] * SQ, Y0[k] + b[3] * SQ],\n      };\n    });\n  });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.wt = cl(k[3] == null ? 1.5 : k[3], 1.5, 4);\n  const st = round(cl(k[2] || 0, 0, PHRASES.length - 1));\n  if (st !== S.st) {\n    S.st = st;\n    S.n = 0;\n    S.t = 0;\n    build(S);\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && S.t \u003c CYCLE - FADE) S.t = CYCLE - FADE;\n  S.btn = btn;\n  S.t += d * S.rate;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    S.n++;\n    build(S);\n  }\n}\n\n// One stroke segment, lit by the pixel centre's distance to it.\nfunction seg(S, ax, ay, bx, by, w, c) {\n  const { cov, id } = S, r = w / 2 + 0.5;\n  const x0 = max(0, floor(min(ax, bx) - r)), x1 = min(W - 1, floor(max(ax, bx) + r));\n  const y0 = max(0, floor(min(ay, by) - r)), y1 = min(H - 1, floor(max(ay, by) + r));\n  const dx = bx - ax, dy = by - ay, ll = dx * dx + dy * dy || 1e-9;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay, u = cl((px * dx + py * dy) / ll, 0, 1);\n      const ex = px - u * dx, ey = py - u * dy, v = r - sqrt(ex * ex + ey * ey);\n      if (v \u003c= 0) continue;\n      const p = y * W + x, cv = v > 1 ? 1 : v;\n      if (cv > cov[p]) {\n        cov[p] = cv;\n        id[p] = c;\n      }\n    }\n}\n\n// A letter in box b; m is how far it has gone into the square (heavier\n// down strokes), u how much of it has been written, by length.\nfunction letter(S, L, b, m, u, c) {\n  const w = S.wt, sx = (b[2] - b[0]) / 8, sy = (b[3] - b[1]) / 8;\n  let total = 0;\n  if (u \u003c 1) for (const s of L.g) for (let i = 2; i \u003c s.length; i += 2) total += Math.hypot((s[i] - s[i - 2]) * sx, (s[i + 1] - s[i - 1]) * sy);\n  let left = u * total;\n  for (const s of L.g)\n    for (let i = 2; i \u003c s.length; i += 2) {\n      const ax = b[0] + s[i - 2] * sx, ay = b[1] + s[i - 1] * sy;\n      let bx = b[0] + s[i] * sx, by = b[1] + s[i + 1] * sy;\n      const len = Math.hypot(bx - ax, by - ay);\n      if (u \u003c 1) {\n        if (left \u003c= 0) return;\n        if (left \u003c len) {\n          const f = left / len;\n          bx = ax + (bx - ax) * f;\n          by = ay + (by - ay) * f;\n        }\n        left -= len;\n      }\n      const vert = len > 0 ? abs(by - ay) / len : 0;\n      seg(S, ax, ay, bx, by, w * (1 + m * (0.3 + 0.4 * vert * vert)), c);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.words.length) return;\n  const { cov, id, pal } = S, t = S.t, w = S.wt;\n  cov.fill(0);\n  const pad = w * 0.7 + 1;\n  let grid = 0;\n  for (const word of S.words)\n    for (const L of word) {\n      const { j, k } = L;\n      // Written stroke by stroke in the line, letter after letter.\n      const wu = cl((t - j * 0.18 - k * 0.1) / 0.4, 0, 1);\n      // Then each letter glides into its box, one after another.\n      const gu = ease((t - WRITE - LINE - k * 0.3 - j * 0.2) / 1.3);\n      grid = max(grid, gu);\n      const q = L.sq, a = L.line;\n      const sb = [q[0] + pad, q[1] + pad, q[2] - pad, q[3] - pad];\n      const b = [0, 1, 2, 3].map((i) => a[i] + (sb[i] - a[i]) * gu);\n      letter(S, L, b, gu, wu, 1 + k * 6 + j);\n    }\n  const fade = 1 - cl((t - (CYCLE - FADE)) / FADE, 0, 1);\n  for (let k = 0; k \u003c 2; k++)\n    for (let j = 0; j \u003c 6; j++) hsv(HUE0 + S.hue + k * 0.5 + j * 0.07, 0.9, fade, pal[1 + k * 6 + j]);\n  const gc = hsv(HUE0 + S.hue + 0.75, 0.6, 1, [0, 0, 0]);\n  const gl = grid * fade;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = (p - x) / W, c = cov[p];\n    let r = 0, g = 0, bl = 0;\n    if (c > 0) {\n      const col = pal[id[p]];\n      r = col[0] * c;\n      g = col[1] * c;\n      bl = col[2] * c;\n    }\n    const gv = GRID[p] ? (GRID[p] === 2 ? 0.22 : 0.16) * gl * (1 - c) : 0;\n    display.setPixel(x, y, round(r + gc[0] * gv), round(g + gc[1] * gv), round(bl + gc[2] * gv));\n  }\n}\n","teletext":"// ===== Patternflow pattern =====\n// Title:   Teletext\n// Family:  type\n// Idea:    A sixteen-column teletext page decoded byte by byte the way the Mullard SAA5050 drew one, letters and 2 by 3 mosaics in seven colours where every colour change spends a cell as a space, rolls its header through the magazine until page 100 comes round, then flips through a carousel of three subpages, diagonal mosaic stripes over an index, double-height block numerals and a ringed disc, each written in from the top as it arrives.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: teletext as the BBC's Ceefax (from 1974) and ITV's ORACLE broadcast it, the Level 1 page of World System Teletext with its spacing attributes and 2 by 3 mosaic characters as the Mullard SAA5050 character generator drew them, and the four coloured prompts of Fastext; a 3 by 5 font drawn for this pattern; pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Page=1..5, Speed=0.2..3, Size=0..1, Reception=0..1\n//\n// Knob 1: Page. The page asked for: 100 at 1, then 200, 300, 400 and 500. Turning it sends the decoder looking again: the old page stays up while the header rolls through the magazine to the new number.\n// Knob 2: Speed. Pages going past a second, 20 for each unit: 40 at the opening 2, so the magazine of 100 pages comes round every 2.5 s and brings the next subpage; 4 a second at 0.2, where page 100 takes 12 s to come, and 60 at 3.\n// Knob 3: Size. The decoder's size key: below 1/3 the whole page, then the top half at double height, and from 2/3 the bottom half.\n// Knob 4: Reception. The share of bytes hit by noise, 0.45 times the square of the knob: 0.16% at the opening 0.06, 2.8% at 0.25, 11% at 0.5, 45% at 1. A hit flips one to three of a byte's eight bits. An odd number fails the parity check and the byte is dropped, leaving a space; two get through as a wrong character, and when that is a spacing attribute the rest of its row changes colour, size or mode.\n// Buttons: K1 tap is the reveal key: concealed text on the page shows, or hides again.\n\n// A page here is 16 columns by 21 rows of 4 by 6 LED cells, one byte a\n// cell; the SAA5050 drew 40 by 24 cells of 6 by 10 dots. Bytes 0x20 to\n// 0x7f are characters. Bytes below 0x20 are spacing attributes: each\n// changes the colour, the mode or the size for the rest of its row and is\n// itself shown as a space in the background colour. That is where teletext\n// art gets its gaps: two mosaics of different colours side by side always\n// have a cell between them. A row starts as white letters on black. 0x01\n// to 0x07 switch to letters and 0x11 to 0x17 to mosaics in red, green,\n// yellow, blue, magenta, cyan and white. In mosaic mode a byte with 0x20 set\n// is a 2 by 3 block of sixels, one bit each (0x01 top left, 0x02 top right,\n// 0x04 and 0x08 the middle, 0x10 and 0x40 the bottom), drawn here as 2 by 2\n// LEDs, or one LED with a gap left and below once 0x1a (separated) has\n// been sent. 0x1d makes the foreground colour the background and 0x1c goes\n// back to black. 0x0d makes the rest of the row double height, and the row\n// under it then shows the lower halves. 0x1e (hold) shows the last mosaic\n// again in place of the space an attribute leaves. Background, hold,\n// separated, contiguous, conceal, steady and normal size act in their own\n// cell; the colours, flash, double height and release from the next cell.\n//\n// Every byte goes out with an odd parity bit. Noise that flips an odd\n// number of the eight bits is caught and the byte dropped; an even number\n// gets through as another character, which is how a weak signal used to\n// turn the rest of a row green or into graphics. The magazine goes round\n// for ever, and the decoder's header shows each page number as it passes\n// until the one asked for comes; each time it comes again it brings the\n// next subpage.\n\nconst W = 64, H = 128, COLS = 16, ROWS = 21, CW = 4, CH = 6, Y0 = 1, N = ROWS * COLS;\nconst { floor, min, round, sin, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Attribute bytes: A(c) letters and G(c) mosaics in colour c.\nconst A = (c) => c, G = (c) => 0x10 + c;\nconst FLASH = 0x08, STEADY = 0x09, NORMAL = 0x0c, DOUBLE = 0x0d, CONCEAL = 0x18;\nconst CONTIG = 0x19, SEP = 0x1a, BLACKBG = 0x1c, NEWBG = 0x1d, HOLD = 0x1e, RELEASE = 0x1f;\nconst RED = 1, GREEN = 2, YELLOW = 3, BLUE = 4, MAGENTA = 5, CYAN = 6, WHITE = 7;\n\n// 3 by 5 letters for 0x20 to 0x7f in the English set (0x23 is a pound sign,\n// 0x5b to 0x5e arrows and a half, 0x5f #, 0x7b to 0x7e quarters, a double\n// bar and a division sign, 0x7f a block). Each digit is a row, top first,\n// 4 the left LED and 1 the right; lower case has a sixth row for descenders.\nconst FONT = (\n  \"0 22202 55 34647 36236 51245 25253 22 12221 42224 0525 0272 00024 007 00002 11244 \" +\n  \"75557 26227 71747 71317 55711 74717 74757 71222 75757 75717 0202 02024 12421 0707 42124 71202 \" +\n  \"25743 25755 65656 34443 65556 74647 74644 34553 55755 72227 11152 55655 44447 57755 65555 25552 \" +\n  \"65644 25563 65655 34216 72222 55557 55552 55775 55255 55222 71247 24742 45123 21712 27222 57575 \" +\n  \"007 00357 44656 00343 11353 02563 12722 035316 44655 20222 101152 44565 62227 00775 00655 00252 \" +\n  \"065644 035311 00344 00326 22723 00553 00552 00577 00525 055316 00623 44131 55555 66131 20702 77777\"\n)\n  .split(\" \")\n  .map((s) => [0, 1, 2, 3, 4, 5].map((i) => +(s[i] || 0)));\n\n// ---- Building pages -------------------------------------------------------\n\nconst blank = () => new Uint8Array(N).fill(0x20);\n\n// Bytes and strings into row r from column c.\nfunction put(p, r, c, ...items) {\n  for (const it of items) {\n    if (typeof it === \"number\") p[r * COLS + c++] = it;\n    else for (const ch of it) p[r * COLS + c++] = ch.charCodeAt(0);\n  }\n}\n\n// The mosaic byte for six sixels in reading order.\nconst MOS = [0x01, 0x02, 0x04, 0x08, 0x10, 0x40];\nfunction mosaic(bits) {\n  let b = 0x20;\n  for (let i = 0; i \u003c 6; i++) if (bits & (1 \u003c\u003c i)) b |= MOS[i];\n  return b;\n}\n\n// Paint a picture f(sx, sy) -> colour (0 for none), in sixels, into rows\n// r0..r1 and columns c0..c1 the way a teletext artist had to: one colour to\n// a cell and a cell for every change of colour. An empty cell before a new\n// colour takes the attribute for nothing; a lit one is lost to it, and\n// that is the gap. `pre` gives bytes to start each row with.\nfunction paint(p, r0, r1, c0, c1, f, pre) {\n  for (let r = r0; r \u003c= r1; r++) {\n    let c = c0, fg = -1;\n    for (const b of pre ? pre(r) : []) {\n      p[r * COLS + c++] = b;\n      if (b > 0x10 && b \u003c 0x18) fg = b - 0x10;\n    }\n    const want = [], bits = [];\n    for (let k = c; k \u003c= c1; k++) {\n      const n = [0, 0, 0, 0, 0, 0, 0, 0], sc = [];\n      for (let i = 0; i \u003c 6; i++) sc.push(f(2 * k + (i & 1), 3 * r + (i >> 1)));\n      for (const v of sc) n[v]++;\n      let best = 0;\n      for (let v = 1; v \u003c 8; v++) if (n[v] && (!best || n[v] > n[best])) best = v;\n      let b = 0;\n      sc.forEach((v, i) => (b |= best && v === best ? 1 \u003c\u003c i : 0));\n      want.push(best);\n      bits.push(b);\n    }\n    for (let k = c; k \u003c= c1; k++) {\n      const i = k - c, w = want[i], nx = want[i + 1] || 0;\n      if (w && w !== fg) (p[r * COLS + k] = G(w)), (fg = w);\n      else if (!w && nx && nx !== fg) (p[r * COLS + k] = G(nx)), (fg = nx);\n      else p[r * COLS + k] = mosaic(w ? bits[i] : 0);\n    }\n  }\n}\n\n// Big numerals: the 3 by 5 font with every dot sw by sh sixels, from\n// sixel (x0, y0), a digit every `pitch` sixels, each in its own colour.\nfunction bigDigits(s, x0, y0, sw, sh, pitch, colours) {\n  return (sx, sy) => {\n    const d = floor((sx - x0) / pitch), cx = floor((sx - x0 - d * pitch) / sw), cy = floor((sy - y0) / sh);\n    if (sx \u003c x0 || cy \u003c 0 || cy > 4 || d >= s.length || cx > 2) return 0;\n    return (FONT[s.charCodeAt(d) - 32][cy] >> (2 - cx)) & 1 ? colours[d % colours.length] : 0;\n  };\n}\n\n// The title band: a background across the row and a double-height word.\nfunction title(p, bg, fg, word, sub) {\n  put(p, 1, 0, A(bg), NEWBG, A(fg), DOUBLE, word);\n  put(p, 1, 11, NORMAL, A(WHITE), sub);\n}\n\n// Fastext prompts along the bottom: the four other pages in red, green,\n// yellow and cyan.\nfunction prompts(p, page) {\n  let c = 0, k = 0;\n  for (let q = 1; q \u003c= 5; q++) if (q !== page) put(p, 20, (c += 4) - 4, A([RED, GREEN, YELLOW, CYAN][k++]), q + \"00\");\n}\n\n// ---- The pages ------------------------------------------------------------\n// Each page is its subpages in the order the magazine sends them.\n\nconst PAGES = [\n  [\n    // 100, 1/3: stripes over an index of the other pages.\n    (p) => {\n      title(p, BLUE, YELLOW, \"LIGHT\", \"1/3\");\n      paint(p, 3, 10, 0, 15, (x, y) => ((x + y) % 8 \u003c 6 ? [MAGENTA, GREEN, WHITE, YELLOW][floor((x + y) / 8) % 4] : 0));\n      [\"WAVE\", \"COLOUR\", \"NUMBER\", \"SHAPE\"].forEach((w, i) => put(p, 12 + 2 * i, 0, A(YELLOW), w, A(CYAN)));\n      for (let i = 0; i \u003c 4; i++) put(p, 12 + 2 * i, 13, i + 2 + \"01\");\n      prompts(p, 1);\n    },\n    // 2/3: the round in double-height block numerals.\n    (p) => {\n      title(p, MAGENTA, WHITE, \"P100\", \"2/3\");\n      put(p, 4, 0, A(WHITE), \"PATTERN ROUND\");\n      for (let r = 10; r \u003c= 18; r += 2) paint(p, r, r, 0, 15, bigDigits(\"78\", 6, 30, 4, 6, 14, [MAGENTA, GREEN]), () => [DOUBLE]);\n      prompts(p, 1);\n    },\n    // 3/3: a ringed disc and a question with its answer concealed.\n    (p) => {\n      title(p, GREEN, BLUE, \"SHAPE\", \"3/3\");\n      put(p, 4, 0, A(WHITE), \"WHAT COLOUR?\");\n      paint(p, 6, 16, 0, 15, (x, y) => {\n        const d = (x - 16) * (x - 16) + (y - 34) * (y - 34);\n        return d \u003c 144 ? (d \u003c 49 ? YELLOW : RED) : 0;\n      });\n      put(p, 18, 0, A(CYAN), \"ANSWER\", A(RED), CONCEAL, \"RED\");\n      prompts(p, 1);\n    },\n  ],\n  [\n    // 200: three waves, then a field of separated dots.\n    (p) => {\n      title(p, CYAN, RED, \"WAVE\", \"1/2\");\n      paint(p, 4, 19, 0, 15, (x, y) => {\n        for (let i = 0; i \u003c 3; i++) if (Math.abs(y - 20 - 14 * i - 6 * sin(x / 4 + i)) \u003c 2.6) return [YELLOW, MAGENTA, GREEN][i];\n        return 0;\n      });\n      prompts(p, 2);\n    },\n    (p) => {\n      title(p, RED, CYAN, \"WAVE\", \"2/2\");\n      paint(p, 3, 19, 0, 15, (x, y) => ((x + floor(y / 6) * 3) % 8 \u003c 3 ? (y \u003c 34 ? CYAN : YELLOW) : 0), () => [SEP]);\n      prompts(p, 2);\n    },\n  ],\n  [\n    // 300: colour bars, then each colour behind its opposite, the bands\n    // that hold graphics run on without a gap where the hatch turns white.\n    (p) => {\n      title(p, BLUE, WHITE, \"COLOUR\", \"1/2\");\n      for (let r = 3; r \u003c 19; r++) {\n        [WHITE, YELLOW, CYAN, GREEN, MAGENTA, RED, BLUE].forEach((k, i) => put(p, r, 2 * i, A(k), NEWBG));\n        put(p, r, 14, BLACKBG);\n      }\n      prompts(p, 3);\n    },\n    (p) => {\n      title(p, YELLOW, BLUE, \"COLOUR\", \"2/2\");\n      [RED, GREEN, YELLOW, CYAN, BLUE, MAGENTA].forEach((k, i) => {\n        for (let r = 3 + 2 * i; r \u003c 5 + 2 * i; r++) {\n          const pre = i & 1 ? [G(k), NEWBG, HOLD] : [G(k), NEWBG];\n          paint(p, r, r, 0, 15, (x, y) => ((x + y) % 4 \u003c 2 ? (x \u003c 18 ? 7 - k : WHITE) : 0), () => pre);\n        }\n      });\n      prompts(p, 3);\n    },\n  ],\n  [\n    // 400: numerals, one a subpage, the second in separated mosaics.\n    (p) => {\n      title(p, RED, YELLOW, \"NUMBER\", \"1/3\");\n      paint(p, 4, 18, 0, 15, bigDigits(\"1\", 10, 12, 4, 9, 14, [YELLOW]));\n      prompts(p, 4);\n    },\n    (p) => {\n      title(p, RED, YELLOW, \"NUMBER\", \"2/3\");\n      paint(p, 4, 18, 0, 15, bigDigits(\"2\", 10, 12, 4, 9, 14, [CYAN]), () => [SEP]);\n      prompts(p, 4);\n    },\n    (p) => {\n      title(p, RED, YELLOW, \"NUMBER\", \"3/3\");\n      paint(p, 4, 18, 0, 15, bigDigits(\"3\", 10, 12, 4, 9, 14, [MAGENTA]));\n      prompts(p, 4);\n    },\n  ],\n  [\n    // 500: a triangle on a block, then rings.\n    (p) => {\n      title(p, MAGENTA, GREEN, \"SHAPE\", \"1/2\");\n      paint(p, 3, 19, 0, 15, (x, y) => (y - 9 > Math.abs(x - 16) * 1.6 && y \u003c 60 ? (y \u003c 34 ? CYAN : RED) : 0));\n      prompts(p, 5);\n    },\n    (p) => {\n      title(p, BLUE, CYAN, \"SHAPE\", \"2/2\");\n      paint(p, 3, 19, 0, 15, (x, y) => {\n        const d = hypot(x - 16, y - 34);\n        return floor(d / 3) % 2 === 0 && d \u003c 16 ? [YELLOW, MAGENTA, YELLOW, GREEN, WHITE, BLUE][floor(d / 3)] : 0;\n      });\n      prompts(p, 5);\n    },\n  ],\n].map((subs) =>\n  subs.map((make) => {\n    const p = blank();\n    make(p);\n    return p;\n  }),\n);\n\nconst NAME = \"PATTERN\";\n// The magazine was at its page 52 when the set was switched on.\nconst START = 52;\n\n// ---- Reception ------------------------------------------------------------\n\n// A byte with its odd parity bit as bit 7.\nfunction parity(b) {\n  let n = 0;\n  for (let i = 0; i \u003c 7; i++) n += (b >> i) & 1;\n  return n & 1 ? b : b | 0x80;\n}\n\n// One byte through the noise; -1 when the parity check catches it.\nfunction receive(b, q) {\n  if (q \u003c= 0 || Math.random() >= q) return b;\n  const u = Math.random(), n = u \u003c 0.5 ? 1 : u \u003c 0.85 ? 2 : 3;\n  let v = parity(b), used = 0;\n  for (let k = 0; k \u003c n; ) {\n    const bit = 1 \u003c\u003c floor(Math.random() * 8);\n    if (!(used & bit)) (used |= bit), (v ^= bit), k++;\n  }\n  return n & 1 ? -1 : v & 0x7f;\n}\n\n// ---- State ----------------------------------------------------------------\n\nexport function setup(params) {\n  params.s = {\n    want: -1, pos: 0, found: false, cycles: 0, wr: ROWS, mem: blank(), head: new Uint8Array(COLS).fill(0x20),\n    size: 0, q: 0, speed: 2, reveal: false, flash: 0, dblRow: false, code: new Uint8Array(W * H),\n  };\n}\n\n// A header going past: the page asked for, the page passing, the service.\nfunction header(S, n) {\n  const h = S.head;\n  put(h, 0, 0, \"P\" + (S.want + 1) + \"00\", A(GREEN), S.want + 1 + String(n).padStart(2, \"0\"), A(YELLOW));\n  for (let i = 0; i \u003c NAME.length; i++) {\n    const b = receive(NAME.charCodeAt(i), S.q);\n    if (b >= 0) h[9 + i] = b;\n  }\n}\n\n// The page asked for comes round: the decoder clears its page and writes\n// the subpage in, each byte through the noise.\nfunction arrive(S) {\n  const subs = PAGES[S.want], src = subs[S.cycles % subs.length], m = S.mem;\n  for (let i = COLS; i \u003c N; i++) {\n    const b = receive(src[i], S.q);\n    m[i] = b \u003c 0 ? 0x20 : b;\n  }\n  S.wr = 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [1, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const page = cl(round(k[0] == null ? 1 : k[0]), 1, 5) - 1;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const z = cl(k[2] || 0, 0, 1);\n  S.size = z \u003c 1 / 3 ? 0 : z \u003c 2 / 3 ? 1 : 2;\n  const rx = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.q = 0.45 * rx * rx;\n  if (input.btnPressed && input.btnPressed[0]) S.reveal = !S.reveal;\n  if (page !== S.want) {\n    S.want = page;\n    S.found = false;\n    header(S, START);\n  }\n  S.flash += d;\n  const before = floor(S.pos);\n  S.pos += d * S.speed * 20;\n  for (let i = before + 1; i \u003c= floor(S.pos); i++) {\n    const n = (START + i) % 100;\n    if (n === 0) {\n      // The page address is Hamming coded, so only a heavier hit loses it.\n      if (Math.random() >= S.q * S.q) {\n        S.found = true;\n        header(S, n);\n        arrive(S);\n      }\n      S.cycles++;\n    } else if (!S.found) header(S, n);\n  }\n  // The rows come in over 8 page slots, top first.\n  if (S.wr \u003c ROWS) S.wr = min(ROWS, S.wr + d * S.speed * 20 * (ROWS / 8));\n}\n\n// ---- Drawing --------------------------------------------------------------\n\n// One cell: mode 0 a space, 1 a mosaic, 2 a letter; half 1 is the lower\n// half of a double-height cell.\nfunction cell(code, x0, y0, fg, bg, b, mode, sep, dbl, half) {\n  for (let yy = 0; yy \u003c CH; yy++) {\n    const y = y0 + yy, gy = dbl ? (yy + half * CH) >> 1 : yy;\n    for (let xx = 0; xx \u003c CW; xx++) {\n      let on = false;\n      if (mode === 1) {\n        on = (b & MOS[(gy >> 1) * 2 + (xx >> 1)]) !== 0;\n        if (on && sep) on = (xx & 1) === 1 && (dbl ? (yy + half * CH) % 4 !== 3 : (gy & 1) === 0);\n      } else if (mode === 2 && xx \u003c 3) on = ((FONT[b - 32][gy] >> (2 - xx)) & 1) === 1;\n      code[y * W + x0 + xx] = on ? fg : bg;\n    }\n  }\n}\n\n// Decode one row of bytes and draw it; true when it went double height.\nfunction row(S, bytes, r, code) {\n  let fg = WHITE, bg = 0, gfx = false, sep = false, hold = false, held = 0x20, heldSep = false;\n  let dbl = false, conceal = false, flash = false, any = false;\n  const y0 = Y0 + r * CH, lit = S.flash % 1 \u003c 0.75, last = r === 0 || r === ROWS - 1;\n  const show = (c, mode, b, s) => {\n    const m = (conceal && !S.reveal) || (flash && !lit) || b === 0x20 ? 0 : mode;\n    cell(code, c * CW, y0, fg, bg, b, m, s, dbl, 0);\n    if (dbl) cell(code, c * CW, y0 + CH, fg, bg, b, m, s, true, 1);\n    else if (S.dblRow) cell(code, c * CW, y0 + CH, fg, bg, b, 0, false, false, 0);\n  };\n  for (let c = 0; c \u003c COLS; c++) {\n    const b = bytes[c] & 0x7f;\n    if (b >= 0x20) {\n      if (gfx && b & 0x20) {\n        held = b;\n        heldSep = sep;\n        show(c, 1, b, sep);\n      } else show(c, 2, b, false);\n      continue;\n    }\n    // Set-at: these act in this cell.\n    if (b === STEADY) flash = false;\n    else if (b === NORMAL) {\n      if (dbl) held = 0x20;\n      dbl = false;\n    } else if (b === CONCEAL) conceal = true;\n    else if (b === CONTIG) sep = false;\n    else if (b === SEP) sep = true;\n    else if (b === BLACKBG) bg = 0;\n    else if (b === NEWBG) bg = fg;\n    else if (b === HOLD) hold = true;\n    if (hold && gfx) show(c, 1, held, heldSep);\n    else show(c, 0, 0x20, false);\n    // Set-after: these act from the next cell.\n    if (b >= 1 && b \u003c= 7) {\n      if (gfx) held = 0x20;\n      (gfx = false), (fg = b), (conceal = false);\n    } else if (b >= 0x11 && b \u003c= 0x17) {\n      if (!gfx) held = 0x20;\n      (gfx = true), (fg = b - 0x10), (conceal = false);\n    } else if (b === FLASH) flash = true;\n    else if (b === DOUBLE && !last) {\n      if (!dbl) held = 0x20;\n      dbl = any = true;\n    } else if (b === RELEASE) hold = false;\n  }\n  return any;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const code = S.code;\n  code.fill(0);\n  S.dblRow = false;\n  row(S, S.head, 0, code);\n  for (let r = 1; r \u003c S.wr && r \u003c ROWS; r++) {\n    const bytes = S.mem.subarray(r * COLS, r * COLS + COLS);\n    // A row with double height in it covers the row under it as well.\n    S.dblRow = r \u003c ROWS - 1 && bytes.some((b) => (b & 0x7f) === DOUBLE);\n    if (row(S, bytes, r, code)) r++;\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const sy = S.size === 0 ? y : S.size === 1 ? y >> 1 : 64 + (y >> 1);\n    for (let x = 0; x \u003c W; x++) {\n      const v = code[sy * W + x];\n      display.setPixel(x, y, v & 1 ? 255 : 0, v & 2 ? 255 : 0, v & 4 ? 255 : 0);\n    }\n  }\n}\n","three-disk-scattering":"// ===== Patternflow pattern =====\n// Title:   Three-Disk Scattering\n// Family:  fractal\n// Idea:    Three hard discs stand in the top half with a few points bouncing between them and leaving through the three gaps, and the bottom half maps every start from the top disc, one LED each, coloured by the gap it leaves through and lit by its bounces, zooming slowly towards a start on an orbit that bounces for ever, so the bands between colours split into thinner bands again and again while the points launched from that LED run round the orbit longer the deeper the zoom goes.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: chaotic scattering off three discs (Bruno Eckhardt, Fractal properties of scattering singularities, 1987; Pierre Gaspard and Stuart Rice, Scattering from a classically chaotic repellor, 1989), pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gap=0.4..4, Bounces=3..12\n//\n// Knob 1: Hue. Turns the three exit colours round the wheel together, a third apart. At 0 the gap at the bottom is gold, the one to the upper right teal and the one to the upper left violet; at 1/3 each colour moves on one gap. Starts still bouncing after 40 bounces are white.\n// Knob 2: Speed. At 2 the zoom takes 20.4 s to go 4 decades deep and holds there, then fades back to the whole map and the next trapped start, 24 s in all, and the points fly 40 LEDs a second. At 0.2 it all runs ten times slower, at 3 one and a half times faster.\n// Knob 3: Gap. The gap between neighbouring discs in disc radii, 0.4 to 4 in steps of 0.05, so the centres stand R = 2.4a to 6a apart. At 0.4 the discs nearly touch, most starts bounce several times and the map is mostly thin bands; at 4 most starts leave at once or after one bounce and the bands narrow to a few strips across broad fields.\n// Knob 4: Bounces. How many bounces beyond the fewest on the map a start needs to reach full brightness, 3 at the opening up to 12. At 3 a start that bounced three times more than the quickest is at full brightness and one that bounced once more at two thirds; at 12 only the bands next to the trapped curves are bright, and the fields that leave at once stay at 42%.\n\n// A point moves in straight lines and bounces off three hard discs of\n// radius a whose centres stand R apart at the corners of a triangle. For\n// R > 2a almost every start leaves through one of the three gaps, but a\n// Cantor set of starts bounces for ever: the repeller of this open\n// billiard. Eckhardt coded it by the order in which the discs are hit\n// and found its dimension (1987); Gaspard and Rice took it as a model of\n// a molecule breaking apart and computed its escape rate, dimension,\n// entropy and Lyapunov exponent (1989).\n//\n// The bottom half maps the starts on disc 0, the top disc, in Birkhoff's\n// coordinates, in which the billiard keeps area: s across, the angle\n// round the disc from the point nearest the middle, -108 to 108 degrees,\n// and p down, the sine of the angle between the ray and the disc's\n// normal, -1 to 1. Each LED traces its ray up to 40 bounces and takes\n// the colour of the gap its last direction faces and a brightness from\n// its bounces. The starts that never leave lie on curves; beside each\n// curve lie bands that leave after more and more bounces, and inside\n// each band the same again. The zoom heads 4 decades deep towards a\n// start on a periodic orbit: the triangle orbit through the three points\n// nearest the middle (s = 0, p = 1/2 or -1/2), or the to and fro between\n// disc 0 and one of the others (s = 30 or -30 degrees, p = 0). Near the\n// to and fro the bands repeat each time the zoom gains the orbit's\n// stretch per bounce, (g + 1) + sqrt((g + 1)^2 - 1) for a gap of g\n// radii: 2.38 at the opening gap of 0.4, 9.9 at R = 6a, the ratio most\n// papers on the three discs use.\n//\n// The map is rebuilt at the current zoom a few rows a frame, as many as\n// 6000 bounces of work allow, and shown resampled from the last finished\n// one meanwhile. The points in the top half start from the LED the zoom\n// heads to, at a random spot inside it, so the deeper the zoom the longer\n// they run round the orbit before they leave.\n\nconst W = 64, H = 128, MY = 64, MS = 64, MAXB = 40, BUDGET = 6000, DEPTH = 4, ZOOM = 20.4, REST = 3.6, SM = 0.6 * Math.PI;\n// Trapped starts on disc 0: the orbit round the triangle both ways, and\n// the orbit to and fro between disc 0 and each of the others.\nconst TG = [[0, 0.5], [Math.PI / 6, 0], [0, -0.5], [-Math.PI / 6, 0]];\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst HUE0 = 0.14;\n\nfunction hsv(h, s, v, o, i0) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[i0] = round((i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255);\n  o[i0 + 1] = round((i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255);\n  o[i0 + 2] = round((i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255);\n}\n\n// Disc k sits at angle 90 + 120 k degrees, d = R / sqrt 3 from the middle;\n// exit k is the gap opposite disc k, which faces the direction U_k.\nfunction geometry(S, gap) {\n  const R = gap + 2, d = R / sqrt(3);\n  S.gap = gap;\n  S.d = d;\n  S.C = [];\n  S.U = [];\n  for (let k = 0; k \u003c 3; k++) {\n    const a = PI / 2 + (k * TAU) / 3;\n    S.C.push(d * cos(a), d * sin(a));\n    S.U.push(-cos(a), -sin(a));\n  }\n  // The billiard half frames the three discs: 62 LEDs across them.\n  S.scale = 62 / (sqrt(3) * d + 2);\n  S.oy = 32 + (d / 4) * S.scale;\n}\n\n// Where a ray leaving disc 0 goes: exit * 64 + bounces, or 3 * 64 + MAXB\n// if it is still bouncing after MAXB. A ray that hits no disc has left,\n// through the gap whose direction is nearest its own.\nfunction trace(S, px, py, vx, vy) {\n  const C = S.C, U = S.U;\n  let last = 0;\n  for (let n = 0; n \u003c MAXB; n++) {\n    let tb = 1e9, kb = -1;\n    for (let k = 0; k \u003c 3; k++) {\n      if (k === last) continue;\n      const ox = px - C[2 * k], oy = py - C[2 * k + 1], b = ox * vx + oy * vy;\n      if (b >= 0) continue;\n      const disc = b * b - (ox * ox + oy * oy - 1);\n      if (disc \u003c= 0) continue;\n      const t = -b - sqrt(disc);\n      if (t \u003c tb) {\n        tb = t;\n        kb = k;\n      }\n    }\n    if (kb \u003c 0) {\n      const e0 = U[0] * vx + U[1] * vy, e1 = U[2] * vx + U[3] * vy, e2 = U[4] * vx + U[5] * vy;\n      return (e0 >= e1 && e0 >= e2 ? 0 : e1 >= e2 ? 1 : 2) * 64 + n;\n    }\n    px += vx * tb;\n    py += vy * tb;\n    const nx = px - C[2 * kb], ny = py - C[2 * kb + 1], dn = 2 * (vx * nx + vy * ny);\n    vx -= dn * nx;\n    vy -= dn * ny;\n    last = kb;\n  }\n  return 3 * 64 + MAXB;\n}\n\n// A start (s, p) on disc 0: s the angle round the disc from the point\n// nearest the middle, counterclockwise, p the sine of the angle between\n// the ray and the disc's outward normal there.\nfunction ray(S, s, p, o) {\n  const a = -PI / 2 + s, nx = cos(a), ny = sin(a), c = sqrt(max(0, 1 - p * p));\n  o[0] = S.C[0] + nx;\n  o[1] = S.C[1] + ny;\n  o[2] = nx * c - ny * p;\n  o[3] = nx * p + ny * c;\n  return o;\n}\nconst RAY = [0, 0, 0, 0];\nconst start = (S, s, p) => {\n  const r = ray(S, s, p, RAY);\n  return trace(S, r[0], r[1], r[2], r[3]);\n};\n\nfunction newMap() {\n  return { v: new Uint8Array(MS * MS), view: [0, 0, 1, 1], row: 0, nmin: 0 };\n}\n\nfunction computeRow(S, M, j) {\n  const [cb, cp, hb, hp] = M.view, ph = cp + hp * ((j + 0.5) / (MS / 2) - 1);\n  let cost = 0;\n  for (let i = 0; i \u003c MS; i++) {\n    const r = start(S, cb + hb * ((i + 0.5) / (MS / 2) - 1), ph);\n    M.v[j * MS + i] = r;\n    cost += (r & 63) + 1;\n  }\n  return cost;\n}\n\nfunction finish(M) {\n  let n = MAXB;\n  for (let i = 0; i \u003c M.v.length; i++) n = min(n, M.v[i] & 63);\n  M.nmin = n;\n}\n\nfunction view(S) {\n  const z = Math.pow(10, -S.z), [tb, tp] = TG[S.ti % TG.length];\n  return [tb * (1 - z), tp * (1 - z), SM * z, z];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 1, gap: -1, bref: 3, z: 0, zt: 0, ti: 0, fade: 0,\n    full: newMap(), shown: newMap(), build: newMap(), parts: [],\n    trail: new Float32Array(W * MY * 3), bg: new Float32Array(W * MY), gm: new Uint8Array(W * MY),\n    pal: new Uint8Array(4 * 64 * 3), gc: new Uint8Array(9),\n  };\n  for (let i = 0; i \u003c 4; i++) params.s.parts.push({ on: false, wait: 0.3 + i * 0.6 });\n  return params.s;\n}\n\n// The discs, with the arc of disc 0 the map starts from drawn brighter, a\n// dashed line across each gap and a mark where each exit leaves the frame,\n// drawn once per geometry. gm holds which exit a LED marks.\nfunction backdrop(S) {\n  const { bg, gm, C, scale, oy } = S;\n  bg.fill(0);\n  gm.fill(0);\n  for (let y = 0; y \u003c MY; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const wx = (x + 0.5 - 32) / scale, wy = (oy - y - 0.5) / scale, p = y * W + x;\n      for (let k = 0; k \u003c 3; k++) {\n        const dx = wx - C[2 * k], dy = wy - C[2 * k + 1], r = Math.hypot(dx, dy) * scale, e = 1 - abs(r - scale);\n        if (r \u003c scale) bg[p] = max(bg[p], 0.16);\n        // The arc |s| \u003c SM of disc 0, s measured from straight down.\n        const lit = k === 0 && abs(Math.atan2(dx, -dy)) \u003c SM ? 1 : 0.55;\n        if (e > 0) bg[p] = max(bg[p], lit * e);\n      }\n    }\n  for (let k = 0; k \u003c 3; k++) {\n    const i = (k + 1) % 3, j = (k + 2) % 3, ax = C[2 * i], ay = C[2 * i + 1], bx = C[2 * j], by = C[2 * j + 1];\n    const L = Math.hypot(bx - ax, by - ay), steps = floor(L * scale * 2);\n    for (let s = 0; s \u003c= steps; s++) {\n      const u = s / steps, along = u * L;\n      if (along \u003c 1.25 || along > L - 1.25) continue;\n      const x = floor(32 + (ax + (bx - ax) * u) * scale), y = floor(oy - (ay + (by - ay) * u) * scale);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c MY && floor((along * scale) / 2) % 2 === 0) gm[y * W + x] = k + 1;\n    }\n    // Out from the middle of the gap in its direction to the frame.\n    let x = 32 + ((ax + bx) / 2) * scale, y = oy - ((ay + by) / 2) * scale;\n    while (x >= 0 && x \u003c W && y >= 0 && y \u003c MY) {\n      x += S.U[2 * k] * 0.5;\n      y -= S.U[2 * k + 1] * 0.5;\n    }\n    // A bar 2 LEDs deep and 7 long along the edge it reaches.\n    const side = x \u003c 0 || x >= W;\n    x = cl(floor(x), 0, W - 1);\n    y = cl(floor(y), 0, MY - 1);\n    for (let a = -3; a \u003c= 3; a++)\n      for (let b = 0; b \u003c 2; b++) {\n        const tx = side ? (x === 0 ? b : W - 1 - b) : x + a, ty = side ? y + a : MY - 1 - b;\n        if (tx >= 0 && tx \u003c W && ty >= 0 && ty \u003c MY) gm[ty * W + tx] = 4 + k;\n      }\n  }\n}\n\nfunction launch(S, P) {\n  // From the LED of the map the zoom is heading to: a random start\n  // inside it.\n  const [cb, cp, hb, hp] = view(S), [tb, tp] = TG[S.ti % TG.length];\n  const fx = floor(((tb - cb) / hb + 1) * (MS / 2)), fy = floor(((tp - cp) / hp + 1) * (MS / 2));\n  const s = cb + hb * ((fx + Math.random()) / (MS / 2) - 1), p = cp + hp * ((fy + Math.random()) / (MS / 2) - 1);\n  const r = ray(S, s, p, RAY);\n  P.x = r[0];\n  P.y = r[1];\n  P.vx = r[2];\n  P.vy = r[3];\n  P.last = 0;\n  P.g = (start(S, s, p) >> 6) % 3;\n  P.on = true;\n}\n\n// Moves a point dist along its path, splatting each piece into the trail.\nfunction fly(S, P, dist) {\n  const C = S.C;\n  while (dist > 1e-9) {\n    let tb = dist, kb = -1;\n    for (let k = 0; k \u003c 3; k++) {\n      if (k === P.last) continue;\n      const ox = P.x - C[2 * k], oy = P.y - C[2 * k + 1], b = ox * P.vx + oy * P.vy;\n      if (b >= 0) continue;\n      const disc = b * b - (ox * ox + oy * oy - 1);\n      if (disc \u003c= 0) continue;\n      const t = -b - sqrt(disc);\n      if (t \u003c tb) {\n        tb = t;\n        kb = k;\n      }\n    }\n    const nx0 = P.x + P.vx * tb, ny0 = P.y + P.vy * tb;\n    line(S, P.x, P.y, nx0, ny0, P.g);\n    P.x = nx0;\n    P.y = ny0;\n    dist -= tb;\n    if (kb >= 0) {\n      const nx = P.x - C[2 * kb], ny = P.y - C[2 * kb + 1], dn = 2 * (P.vx * nx + P.vy * ny);\n      P.vx -= dn * nx;\n      P.vy -= dn * ny;\n      P.last = kb;\n    }\n  }\n}\n\nfunction line(S, ax, ay, bx, by, g) {\n  const sc = S.scale, oy = S.oy, x0 = 32 + ax * sc, y0 = oy - ay * sc, x1 = 32 + bx * sc, y1 = oy - by * sc;\n  const n = max(1, Math.ceil(Math.hypot(x1 - x0, y1 - y0) * 2));\n  for (let s = 1; s \u003c= n; s++) {\n    const x = x0 + ((x1 - x0) * s) / n - 0.5, y = y0 + ((y1 - y0) * s) / n - 0.5, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    for (const [dx, dy, w] of [[0, 0, (1 - fx) * (1 - fy)], [1, 0, fx * (1 - fy)], [0, 1, (1 - fx) * fy], [1, 1, fx * fy]]) {\n      const px = ix + dx, py = iy + dy;\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= MY) continue;\n      const p = (py * W + px) * 3 + g;\n      if (w > S.trail[p]) S.trail[p] = w;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.bref = cl(k[3] == null ? 3 : k[3], 3, 12);\n  const gap = round(cl(k[2] == null ? 0.4 : k[2], 0.4, 4) * 20) / 20;\n  if (gap !== S.gap) {\n    geometry(S, gap);\n    backdrop(S);\n    const F = S.full;\n    F.view = [0, 0, SM, 1];\n    for (let j = 0; j \u003c MS; j++) computeRow(S, F, j);\n    finish(F);\n    S.shown.v.set(F.v);\n    S.shown.view = F.view.slice();\n    S.shown.nmin = F.nmin;\n    S.build.row = 0;\n    S.build.view = view(S);\n    for (const P of S.parts) P.on = false;\n  }\n  // The zoom: DEPTH decades in towards a trapped start over ZOOM seconds,\n  // a hold, then a fade back to the whole map and the next trapped start.\n  S.zt += d * S.rate;\n  if (S.zt >= ZOOM + REST) {\n    S.zt -= ZOOM + REST;\n    S.ti++;\n  }\n  const u = cl(S.zt / ZOOM, 0, 1);\n  S.z = DEPTH * u * u * (3 - 2 * u);\n  S.fade = min(1, S.zt / 0.4, (ZOOM + REST - S.zt) / 0.6);\n  // Build the map at the current view a few rows a frame.\n  const B = S.build;\n  if (B.row === 0) B.view = view(S);\n  let cost = 0;\n  while (B.row \u003c MS && cost \u003c BUDGET) cost += computeRow(S, B, B.row++);\n  if (B.row >= MS) {\n    finish(B);\n    const t = S.shown;\n    S.shown = B;\n    S.build = t;\n    S.build.row = 0;\n  }\n  // The points.\n  const tr = S.trail, decay = exp(-d * S.rate * 1.6);\n  for (let i = 0; i \u003c tr.length; i++) tr[i] *= decay;\n  for (const P of S.parts) {\n    if (!P.on) {\n      P.wait -= d * S.rate;\n      if (P.wait \u003c= 0) launch(S, P);\n      continue;\n    }\n    fly(S, P, (d * S.rate * 40) / S.scale);\n    const qx = 32 + P.x * S.scale, qy = S.oy - P.y * S.scale;\n    if (qx \u003c -2 || qx > W + 2 || qy \u003c -2 || qy > MY + 2) {\n      P.on = false;\n      P.wait = 0.3 + Math.random() * 0.5;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.gap \u003c 0) return;\n  const { pal, gc, trail, bg, gm } = S;\n  for (let g = 0; g \u003c 3; g++) {\n    hsv(HUE0 + S.hue + g / 3, 1, 1, gc, g * 3);\n    for (let n = 0; n \u003c= MAXB; n++) {\n      const u = min(1, n / S.bref);\n      hsv(HUE0 + S.hue + g / 3, 0.92 - 0.3 * (n / MAXB), 0.42 + 0.58 * Math.pow(u, 0.8), pal, (g * 64 + n) * 3);\n    }\n  }\n  for (let n = 0; n \u003c= MAXB; n++) {\n    const q = (3 * 64 + n) * 3;\n    pal[q] = pal[q + 1] = pal[q + 2] = 255;\n  }\n  // The billiard.\n  for (let y = 0; y \u003c MY; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, b = bg[p] * 200;\n      let r = b, g = b, bl = b;\n      if (gm[p]) {\n        const c = ((gm[p] - 1) % 3) * 3, f = gm[p] > 3 ? 0.9 : 0.45;\n        r = max(r, gc[c] * f);\n        g = max(g, gc[c + 1] * f);\n        bl = max(bl, gc[c + 2] * f);\n      }\n      for (let k = 0; k \u003c 3; k++) {\n        const t = trail[p * 3 + k];\n        if (t > 0.02) {\n          r = max(r, gc[k * 3] * t);\n          g = max(g, gc[k * 3 + 1] * t);\n          bl = max(bl, gc[k * 3 + 2] * t);\n        }\n      }\n      display.setPixel(x, y, round(r), round(g), round(bl));\n    }\n  // The heads, white.\n  for (const P of S.parts) {\n    if (!P.on) continue;\n    const x = floor(32 + P.x * S.scale), y = floor(S.oy - P.y * S.scale);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c MY) display.setPixel(x, y, 255, 255, 255);\n  }\n  // The map, sampled from the last finished build at the current view.\n  const V = view(S), M = S.shown, F = S.full, [cb, cp, hb, hp] = M.view;\n  for (let j = 0; j \u003c MS; j++) {\n    const ph = V[1] + V[3] * ((j + 0.5) / (MS / 2) - 1);\n    for (let i = 0; i \u003c MS; i++) {\n      const b = V[0] + V[2] * ((i + 0.5) / (MS / 2) - 1);\n      const si = floor(((b - cb) / hb + 1) * (MS / 2)), sj = floor(((ph - cp) / hp + 1) * (MS / 2));\n      let v;\n      if (si >= 0 && si \u003c MS && sj >= 0 && sj \u003c MS) v = M.v[sj * MS + si];\n      else {\n        const fi = cl(floor((b / SM + 1) * (MS / 2)), 0, MS - 1), fj = cl(floor((ph + 1) * (MS / 2)), 0, MS - 1);\n        v = F.v[fj * MS + fi];\n      }\n      const g = v >> 6, n = g === 3 ? MAXB : max(0, (v & 63) - M.nmin), q = (g * 64 + n) * 3, f = S.fade;\n      display.setPixel(i, MY + j, round(pal[q] * f), round(pal[q + 1] * f), round(pal[q + 2] * f));\n    }\n  }\n  // Ticks round the LED the zoom is heading to.\n  const [tb, tp] = TG[S.ti % TG.length], tx = floor(((tb - V[0]) / V[2] + 1) * (MS / 2)), ty = MY + floor(((tp - V[1]) / V[3] + 1) * (MS / 2));\n  for (const [dx, dy] of [[-3, 0], [-4, 0], [3, 0], [4, 0], [0, -3], [0, -4], [0, 3], [0, 4]]) {\n    const x = tx + dx, y = ty + dy;\n    if (x >= 0 && x \u003c W && y >= MY && y \u003c H) display.setPixel(x, y, 255, 255, 255);\n  }\n}\n","word-bokeh":"// ===== Patternflow pattern =====\n// Title:   Word Bokeh\n// Family:  type\n// Idea:    Points of light at different depths seen through a lens whose aperture is cut in the shape of a word, so every light out of focus is drawn as the word, upright behind the plane of focus and turned 180 degrees in front of it, while the focus pulls slowly through the scene and each light shrinks to a point and swells into the word again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: bokeh (Japanese boke, blur; spelled with an h and brought into English by Mike Johnston's Photo Techniques, 1997), the thin-lens circle of confusion, the shaped aperture, pattern round 78\n// Round:   78\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..1, Stop=1.4..2.8\n//\n// Knob 1: Hue. Turns the three colours of the lights round the wheel together. At 0 they are sky blue, magenta and golden yellow, and where words cross their light adds, to near white where all three do.\n// Knob 2: Speed. The focus pull. One cycle, near to far and back, takes 12 s at 2: the words stand upright, shrink to points, open out turned over 6 s later, and come back. 120 s at 0.2, 8 s at 3.\n// Knob 3: Word. The word cut in the aperture, a fifth of the knob each: BOKE, LUX, BLUR, GLOW, LENS.\n// Knob 4: Stop. The f-number. The blur goes as the aperture diameter, F/N, so it halves from f/1.4 to f/2.8: at the ends of the pull the largest word stands 14 LEDs tall at f/1.4 (BOKE is then 46 wide), 10 at f/2 and 7 at f/2.8.\n\n// Thin lens, focal length F, aperture diameter A = F/N, focused at depth f.\n// A point at depth d comes to focus in front of the sensor or behind it, and\n// the cone of light through the aperture cuts the sensor in a copy of the\n// aperture, the circle of confusion, of diameter about A F |1/d - 1/f|. The\n// sign matters. For a point behind the plane of focus (d > f) the rays meet\n// before the sensor and cross, so the copy on the sensor is turned 180\n// degrees, and the lens has already turned the whole picture 180 degrees: the\n// light is drawn upright, the word as it reads from behind the lens. For a\n// point in front of it (d \u003c f) the rays have not met yet and the light is\n// drawn turned 180 degrees. Every light here gets the signed scale\n// s = K (1/f - 1/d) / N, LEDs per cell of the word, and is drawn as the word\n// scaled by s about its own centre; a negative s turns it over by itself.\n// Each LED is lit by how much of its square the scaled word's ink covers,\n// read exactly from a summed-area table of the 5 by 7 letters, so a word 1.6\n// LEDs to the cell keeps clean strokes and a light in focus folds into one\n// LED.\n//\n// The 21 lights lie within 1/3 either side of the middle of the scene in\n// inverse depth (1/d), and the focus swings to 1 either side, so the ends of\n// the pull are beyond every light: at the near end every light is behind the\n// plane of focus and upright, at the far end every one is in front and\n// turned, and at f/1.4 each is a word 7 to 14 LEDs tall. The focus offset\n// goes as sin^2.3 of the phase, so it lingers in the middle, where it passes\n// the lights one by one while they are small and turns each over as it goes\n// by. Below 0.7 LEDs to the cell a light keeps all its power as its word\n// shrinks, so near focus the words burn out into short bright bars.\n\nconst W = 64, H = 128, N = W * H, CH = 7, NL = 21;\nconst { floor, min, max, abs, sin, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// 5 by 7 capitals, drawn for this pattern.\nconst FONT = {\n  B: \"####. #...# #...# ####. #...# #...# ####.\",\n  O: \".###. #...# #...# #...# #...# #...# .###.\",\n  K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\",\n  E: \"##### #.... #.... ####. #.... #.... #####\",\n  L: \"#.... #.... #.... #.... #.... #.... #####\",\n  U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  G: \".###. #...# #.... #.### #...# #...# .###.\",\n  W: \"#...# #...# #...# #.#.# #.#.# ##.## #...#\",\n  N: \"#...# ##..# #.#.# #..## #...# #...# #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\",\n};\nconst WORDS = [\"BOKE\", \"LUX\", \"BLUR\", \"GLOW\", \"LENS\"];\n\n// A word as an aperture: its width in cells, its ink area, and the table\n// F(i, j) = ink in cells [0, i) x [0, j), from which the ink in any\n// rectangle comes by bilinear reads, exactly.\nfunction aperture(word) {\n  const w = word.length * 6 - 1, F = new Float32Array((w + 1) * (CH + 1));\n  const ink = (i, j) => {\n    const c = floor(i / 6), q = i % 6;\n    return q \u003c 5 && FONT[word[c]].split(\" \")[j][q] === \"#\" ? 1 : 0;\n  };\n  for (let j = 1; j \u003c= CH; j++)\n    for (let i = 1; i \u003c= w; i++) F[j * (w + 1) + i] = ink(i - 1, j - 1) + F[(j - 1) * (w + 1) + i] + F[j * (w + 1) + i - 1] - F[(j - 1) * (w + 1) + i - 1];\n  return { w, F, area: F[CH * (w + 1) + w] };\n}\nconst APS = WORDS.map(aperture);\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h);\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = v[0];\n  o[1] = v[1];\n  o[2] = v[2];\n  return o;\n}\n\n// Inverse depths about the middle of the scene: the lights lie between\n// -SPREAD and +SPREAD, the focus swings between -PULL and +PULL.\nconst SPREAD = 1 / 3, PULL = 1, K = 1.5, SHAPE = 2.3, HUES = [0.53, 0.86, 0.13];\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, word: 0, stop: 1.4, ph: PI / 6,\n    x: new Float32Array(NL), y: new Float32Array(NL), z: new Float32Array(NL), g: new Float32Array(NL), c: new Uint8Array(NL),\n    buf: new Float32Array(N * 3), cu: new Float32Array(W + 1), cv: new Float32Array(H + 1), rgb: [0, 0, 0],\n  });\n  // Columns, rows and depths each spread evenly, then paired at random, so\n  // the words do not pile up in one place or one plane.\n  const shuffle = () => {\n    const a = [];\n    for (let i = 0; i \u003c NL; i++) a.splice(floor(Math.random() * (i + 1)), 0, i);\n    return a;\n  };\n  const cols = shuffle(), rows = shuffle();\n  for (let i = 0; i \u003c NL; i++) {\n    S.x[i] = 8 + ((W - 16) * (cols[i] + Math.random())) / NL;\n    S.y[i] = 5 + ((H - 10) * (rows[i] + Math.random())) / NL;\n    S.z[i] = -SPREAD + (2 * SPREAD * (i + Math.random())) / NL;\n    S.g[i] = 0.75 + 0.25 * Math.random();\n    S.c[i] = i % 3;\n  }\n  return S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.word = min(WORDS.length - 1, floor(cl(k[2] || 0, 0, 1) * WORDS.length));\n  S.stop = cl(k[3] == null ? 1.4 : k[3], 1.4, 2.8);\n  // 12 s a cycle at Speed 2.\n  S.ph += (d * S.speed * PI) / 12;\n}\n\n// Ink of the aperture in [0, u) x [0, v), u and v in cells.\nfunction inkTo(F, w, u, v) {\n  u = cl(u, 0, w);\n  v = cl(v, 0, CH);\n  const i = min(w - 1, floor(u)), j = min(CH - 1, floor(v)), a = u - i, b = v - j, r = w + 1;\n  const f00 = F[j * r + i], f10 = F[j * r + i + 1], f01 = F[(j + 1) * r + i], f11 = F[(j + 1) * r + i + 1];\n  return f00 + a * (f10 - f00) + b * (f01 - f00) + a * b * (f11 - f10 - f01 + f00);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, ap = APS[S.word], F = ap.F, w = ap.w, cu = S.cu, cv = S.cv, col = S.rgb;\n  buf.fill(0);\n  const sn = sin(S.ph), focus = PULL * (sn \u003c 0 ? -1 : 1) * abs(sn) ** SHAPE, gain = (K * 1.4) / S.stop;\n  for (let n = 0; n \u003c NL; n++) {\n    let s = gain * (focus - S.z[n]);\n    if (abs(s) \u003c 0.04) s = s \u003c 0 ? -0.04 : 0.04;\n    const as = abs(s), lx = S.x[n], ly = S.y[n];\n    // Surface brightness: even over a word of 0.7 LEDs to the cell and\n    // more, overdriven 1.8 times so the strokes stay whole after clamping.\n    // Below that the light keeps its whole power and spreads it less, so a\n    // small word burns out and a light in focus is one bright LED.\n    const lum = S.g[n] * 1.8 * max(1, 0.45 / (s * s));\n    hsv(S.hue + HUES[S.c[n]], col);\n    const x0 = max(0, floor(lx - (w * as) / 2)), x1 = min(W - 1, floor(lx + (w * as) / 2));\n    const y0 = max(0, floor(ly - (CH * as) / 2)), y1 = min(H - 1, floor(ly + (CH * as) / 2));\n    // Cell coordinates of each LED edge; a negative s runs them backwards,\n    // which is the 180 degree turn.\n    for (let x = x0; x \u003c= x1 + 1; x++) cu[x - x0] = (x - lx) / s + w / 2;\n    for (let y = y0; y \u003c= y1 + 1; y++) cv[y - y0] = (y - ly) / s + CH / 2;\n    const s2 = s * s * lum;\n    for (let y = y0; y \u003c= y1; y++) {\n      let va = cv[y - y0], vb = cv[y - y0 + 1];\n      if (va > vb) (vb = va), (va = cv[y - y0 + 1]);\n      for (let x = x0; x \u003c= x1; x++) {\n        let ua = cu[x - x0], ub = cu[x - x0 + 1];\n        if (ua > ub) (ub = ua), (ua = cu[x - x0 + 1]);\n        const c = (inkTo(F, w, ub, vb) - inkTo(F, w, ua, vb) - inkTo(F, w, ub, va) + inkTo(F, w, ua, va)) * s2;\n        if (c \u003c= 0.001) continue;\n        const p = (y * W + x) * 3;\n        buf[p] += c * col[0];\n        buf[p + 1] += c * col[1];\n        buf[p + 2] += c * col[2];\n      }\n    }\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(buf[i * 3], 0, 1) * 255), round(cl(buf[i * 3 + 1], 0, 1) * 255), round(cl(buf[i * 3 + 2], 0, 1) * 255));\n}\n","brazil-nut":"// ===== Patternflow pattern =====\n// Title:   Brazil Nut\n// Family:  particle\n// Idea:    A bed of 540 small discs in seven coloured strata fills the panel nearly to the top with one large pale disc on its floor, and a Monte Carlo shakes it six times a second, lifting the whole packing and letting every disc settle by random steps that may never go up, so the small discs that slip into the gap opening under the large one ratchet it up through the strata, stirring them in its wake, until it reaches the top after about 52 seconds and the column tips over end to end and starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Brazil nut effect, size segregation by shaking in the Monte Carlo of Anthony Rosato, Katherine Strandburg, Friedrich Prinz and Robert Swendsen (1987), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Amplitude=-1..1, Size=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the strata run from sea green on the floor through cyan and azure to violet at the top, every other one pale, and the large disc is pale gold; at 0.5 they run from rose through orange and yellow to lime and the large disc is pale blue.\n// Knob 2: Speed. Shakes a second, 3 for each unit: 6 at the opening 2, 0.6 at 0.2 and 9 at 3. Each shake is the same Monte Carlo whatever the speed, so the climb takes about 315 shakes: 52 seconds at 2, 35 seconds at 3, nearly 9 minutes at 0.2.\n// Knob 3: Amplitude. How far each shake lifts the packing, 6 x 1.6^Amplitude LEDs: 3.75 at -1, 6 at the opening 0 (1.7 small diameters), 9.6 at 1. A bigger lift opens a deeper gap under the large disc and it climbs faster: about 100 seconds at -1, 52 at 0, 31 at 1.\n// Knob 4: Size. The large disc's radius, 7 x 1.45^Size rounded to half an LED: 5 at -1, 7 at the opening, 10 at 1, against small radii of 1.6 to 1.95. The climb takes about 58, 52 and 49 seconds. A new size fills a new column once the knob has rested 0.3 seconds.\n// Buttons: K1 tap tips the column over now. A large disc on the floor then lands on top and the column tips back after 2.5 seconds.\n\n// Anthony Rosato, Katherine Strandburg, Friedrich Prinz and Robert Swendsen,\n// \"Why the Brazil nuts are on top: size segregation of particulate matter\n// by shaking\", Physical Review Letters 58 (1987), found the effect in a\n// Monte Carlo of hard discs under gravity, with no other force. A shake\n// lifts the whole packing by the amplitude, and then the discs settle by\n// random trial moves that are kept only if they overlap nothing and do not\n// go up. As the packing falls back, a gap opens under a large disc, and\n// small discs slip into its edges before the large disc can fall the whole\n// way. It cannot go back down past them, so each shake leaves it a little\n// higher: a ratchet, with no convection and no air.\n//\n// The moves here are this pattern's own. A shake lifts every disc by A and\n// then runs ceil(20 + 5 A) sweeps, 50 at the opening, enough for the packing\n// to settle. In a sweep each disc is tried once, in order of height from\n// the floor up, so a whole column can drop a step in one sweep: a step\n// sideways by up to 0.6 LEDs and down by 0.3 to 0.6, else straight down by\n// 0.6, else down by 0.15, each kept only if the disc then overlaps nothing.\n// No disc ever moves up except in the lift. The sides wrap round, so the\n// large disc never stalls against a wall, and overlaps are found through a\n// grid of 12 by 32 cells. The 540 small discs have radii 1.6 to 1.95 LEDs,\n// spread so the packing does not freeze into a crystal.\n//\n// The picture glides from one settled packing to the next while the Monte\n// Carlo works out the one after, and rises 0.15 A and falls back in each\n// shake, so the shaking shows without the packing jumping 6 LEDs six times\n// a second. The small discs are coloured by the seventh of the packing's\n// height they started in. Once no small disc lies above the large one it\n// holds 2.5 seconds, the column turns end over end about the middle row in\n// 1.4 seconds, the strata are recoloured from the new floor while it is\n// edge-on, and the packing falls 90 sweeps onto the floor in 1.2 seconds.\n// After 900 shakes without the large disc reaching the top it tips anyway.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, round, cos, sin, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The sides wrap round: x is taken modulo the width, and a difference in x\n// is the shorter way round.\nconst wrap = (x) => x - W * floor(x / W);\nconst near = (d) => d - W * round(d / W);\n\nconst P = {\n  RMIN: 1.6, RMAX: 1.95, TOP: 137, DELTA: 0.6, CS: 5, GX: 12, GY: 32,\n  BANDS: 7, HOLD: 2.5, TIP: 1.4, FALL: 1.2, LIMIT: 900,\n};\nconst CX = W / P.GX;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nfunction build(S) {\n  const R = S.R, nb = S.nb;\n  const xs = [], ys = [], rs = [];\n  // Big discs side by side on the floor.\n  for (let b = 0; b \u003c nb; b++) {\n    xs.push(((b + 0.5) * W) / nb);\n    ys.push(R + 0.2);\n    rs.push(R);\n  }\n  const per = floor(W / (2 * P.RMAX + 0.15)), dx = W / per, dy = dx * 0.87;\n  for (let row = 0; ; row++) {\n    const y = P.RMAX + 0.1 + row * dy;\n    if (y > P.TOP) break;\n    for (let q = 0; q \u003c per; q++) {\n      const x = (q + (row & 1 ? 0.5 : 0)) * dx;\n      let ok = true;\n      for (let b = 0; b \u003c nb; b++) {\n        const ex = near(x - xs[b]), ey = y - ys[b];\n        if (ex * ex + ey * ey \u003c (R + P.RMAX + 0.2) ** 2) ok = false;\n      }\n      if (!ok) continue;\n      xs.push(wrap(x + (random() - 0.5) * 0.1));\n      ys.push(y);\n      rs.push(P.RMIN + random() * (P.RMAX - P.RMIN));\n    }\n  }\n  const n = xs.length;\n  S.n = n;\n  S.x = Float64Array.from(xs);\n  S.y = Float64Array.from(ys);\n  S.r = Float64Array.from(rs);\n  S.band = new Float32Array(n);\n  S.cell = new Int32Array(P.GX * P.GY + 1);\n  S.item = new Int32Array(n);\n  S.ci = new Int32Array(n);\n  for (let k = 0; k \u003c 120; k++) sweep(S);\n  S.ay = null;\n  colour(S, false);\n}\n\n// Strata by starting height: seven bands of the packing's height, bottom\n// to top. After a tip the bands are the mirror of the old ones.\nfunction colour(S, flip) {\n  let top = 0;\n  for (let i = S.nb; i \u003c S.n; i++) top = max(top, S.ay ? S.ay[i] : S.y[i]);\n  for (let i = S.nb; i \u003c S.n; i++) {\n    const b = min(P.BANDS - 1, floor(((S.ay ? S.ay[i] : S.y[i]) / (top + 0.01)) * P.BANDS));\n    S.band[i] = flip ? P.BANDS - 1 - b : b;\n  }\n}\n\nfunction grid(S) {\n  const { cell, item, ci, n, nb } = S;\n  cell.fill(0);\n  for (let i = nb; i \u003c n; i++) {\n    const cx = cl(floor(S.x[i] / CX), 0, P.GX - 1), cy = cl(floor(S.y[i] / P.CS), 0, P.GY - 1);\n    ci[i] = cy * P.GX + cx;\n    cell[ci[i] + 1]++;\n  }\n  for (let c = 0; c \u003c P.GX * P.GY; c++) cell[c + 1] += cell[c];\n  const fill = S.fill || (S.fill = new Int32Array(P.GX * P.GY));\n  fill.fill(0);\n  for (let i = nb; i \u003c n; i++) item[cell[ci[i]] + fill[ci[i]]++] = i;\n}\n\n// Would disc i overlap anything at (px, py)?\nfunction hits(S, i, px, py) {\n  const ri = S.r[i];\n  if (py \u003c ri) return true;\n  const { x, y, r, nb, cell, item } = S;\n  for (let b = 0; b \u003c nb; b++) {\n    if (b === i) continue;\n    const ex = near(px - x[b]), ey = py - y[b], s = ri + r[b];\n    if (ex * ex + ey * ey \u003c s * s) return true;\n  }\n  const reach = ceil((ri + P.RMAX + 1.5 * P.DELTA) / P.CS);\n  const cx = floor(wrap(px) / CX), cy = floor(py / P.CS);\n  for (let gy = max(0, cy - reach); gy \u003c= min(P.GY - 1, cy + reach); gy++)\n    for (let g = cx - reach; g \u003c= cx + reach; g++) {\n      const c = gy * P.GX + (g + P.GX) % P.GX;\n      for (let k = cell[c]; k \u003c cell[c + 1]; k++) {\n        const j = item[k];\n        if (j === i) continue;\n        const ex = near(px - x[j]), ey = py - y[j], s = ri + r[j];\n        if (ex * ex + ey * ey \u003c s * s) return true;\n      }\n    }\n  return false;\n}\n\nfunction sweep(S) {\n  grid(S);\n  const { x, y, n } = S, d = P.DELTA;\n  // Each disc once a sweep, from the lowest up, so a whole column can drop\n  // a step in one sweep. Insertion sort: the order barely changes.\n  const ord = S.ord && S.ord.length === n ? S.ord : (S.ord = new Int32Array(n).map((_, i) => i));\n  for (let k = 1; k \u003c n; k++) {\n    const t = ord[k], ty = y[t];\n    let j = k - 1;\n    while (j >= 0 && y[ord[j]] > ty) {\n      ord[j + 1] = ord[j];\n      j--;\n    }\n    ord[j + 1] = t;\n  }\n  for (let k = 0; k \u003c n; k++) {\n    const i = ord[k];\n    // A step down and to the side; if that is blocked, straight down.\n    const dx = d * (2 * random() - 1), dy = -d * (0.5 + 0.5 * random());\n    if (!hits(S, i, x[i] + dx, y[i] + dy)) {\n      x[i] = wrap(x[i] + dx);\n      y[i] += dy;\n    } else if (!hits(S, i, x[i], y[i] - d)) y[i] -= d;\n    else if (!hits(S, i, x[i], y[i] - d * 0.25)) y[i] -= d * 0.25;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, A: 6, R: 7, want: 7, rest: 0, fresh: true, nb: 1, mode: 0, shakes: 0, hold: -1, done: 0, owed: 0, K: 50, tip: 0, btn: false,\n    img: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n  build(params.s);\n  settled(params.s, true);\n}\n\n// Keep the last two settled packings: the picture glides from one to the\n// next while the Monte Carlo works out the one after.\nfunction settled(S, both) {\n  if (!S.ax || S.ax.length !== S.n) {\n    S.ax = new Float64Array(S.n);\n    S.ay = new Float64Array(S.n);\n    S.bx = new Float64Array(S.n);\n    S.by = new Float64Array(S.n);\n    both = true;\n  }\n  if (both) {\n    S.bx.set(S.x);\n    S.by.set(S.y);\n  } else {\n    S.bx.set(S.ax);\n    S.by.set(S.ay);\n  }\n  S.ax.set(S.x);\n  S.ay.set(S.y);\n}\n\n// A big disc is on top once no small disc sits above it within its width.\nfunction surfaced(S) {\n  for (let b = 0; b \u003c S.nb; b++)\n    for (let i = S.nb; i \u003c S.n; i++) if (S.y[i] > S.y[b] && abs(near(S.x[i] - S.x[b])) \u003c S.r[b]) return false;\n  return true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.A = 6 * 1.6 ** cl(k[2] || 0, -1, 1);\n  const R = round(7 * 1.45 ** cl(k[3] == null ? 0.06 : k[3], -1, 1) * 2) / 2;\n  if (R !== S.want) {\n    S.want = R;\n    S.rest = 0;\n  } else S.rest += d;\n  // A new size fills a new column, once the knob has rested 0.3 seconds.\n  if (R !== S.R && (S.rest > 0.3 || S.fresh)) {\n    S.R = R;\n    build(S);\n    settled(S, true);\n    S.mode = 0;\n    S.shakes = 0;\n    S.hold = -1;\n    S.done = 0;\n  }\n  S.fresh = false;\n  const b = !!(input.btnPressed && input.btnPressed[0]);\n  if (b && !S.btn && S.mode === 0) {\n    S.mode = 1;\n    S.tip = 0;\n  }\n  S.btn = b;\n  if (S.mode === 0) {\n    // Shaking: each shake lifts the whole packing by A and lets it settle\n    // through K sweeps, K growing with A.\n    S.K = ceil(20 + 5 * S.A);\n    S.owed += d * 3 * S.speed * S.K;\n    while (S.owed >= 1) {\n      if (S.done === 0) for (let i = 0; i \u003c S.n; i++) S.y[i] += S.A;\n      sweep(S);\n      S.owed -= 1;\n      if (++S.done >= S.K) {\n        S.done = 0;\n        settled(S, false);\n        if (S.hold \u003c 0 && (surfaced(S) || ++S.shakes > P.LIMIT)) S.hold = 0;\n      }\n    }\n    if (S.hold >= 0 && (S.hold += d) > P.HOLD) {\n      S.mode = 1;\n      S.tip = 0;\n    }\n  } else if (S.mode === 1) {\n    // Tipping: the column turns over end to end about its middle row.\n    // Edge-on at the halfway point, the column changes its colours unseen.\n    if (S.tip \u003c 0.5 && S.tip + d / P.TIP >= 0.5) colour(S, true);\n    S.tip += d / P.TIP;\n    if (S.tip >= 1) {\n      for (let i = 0; i \u003c S.n; i++) S.y[i] = H - S.ay[i];\n      S.x.set(S.ax);\n      S.mode = 2;\n      S.owed = 0;\n      S.done = 0;\n    }\n  } else {\n    // Falling back onto the floor, no lift, then shaking again.\n    S.owed += (d * 90) / P.FALL;\n    while (S.owed >= 1 && S.mode === 2) {\n      sweep(S);\n      S.owed -= 1;\n      if (++S.done >= 90) {\n        settled(S, true);\n        S.mode = 0;\n        S.done = 0;\n        S.owed = 0;\n        S.shakes = 0;\n        S.hold = -1;\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const img = S.img, c = S.c;\n  img.fill(0);\n  const disc = (cx, cy, rad, sq, R, G, B) => {\n    if (cx - rad \u003c 0) one(cx + W, cy, rad, sq, R, G, B);\n    if (cx + rad > W) one(cx - W, cy, rad, sq, R, G, B);\n    one(cx, cy, rad, sq, R, G, B);\n  };\n  const one = (cx, cy, rad, sq, R, G, B) => {\n    const x0 = max(0, floor(cx - rad - 1)), x1 = min(W - 1, ceil(cx + rad));\n    const ry = max(0.3, rad * sq), r2 = (rad + 0.2) * (rad + 0.2), s2 = (ry + 0.2) * (ry + 0.2);\n    for (let px = x0; px \u003c= x1; px++) {\n      const ex = px + 0.5 - cx;\n      for (let row = max(0, floor(H - cy - ry - 1)); row \u003c= min(H - 1, ceil(H - cy + ry)); row++) {\n        const ey = H - (row + 0.5) - cy, q = (ex * ex) / r2 + (ey * ey) / s2;\n        if (q >= 1) continue;\n        const w = 1 - 0.6 * q, p = (row * W + px) * 3;\n        img[p] = max(img[p], R * w);\n        img[p + 1] = max(img[p + 1], G * w);\n        img[p + 2] = max(img[p + 2], B * w);\n      }\n    }\n  };\n  // Where each disc is drawn: gliding between settled packings with the\n  // shake's bump while shaking, squashed about row 64 while tipping, as\n  // it is while falling.\n  let u = 0, bump = 0, sq = 1;\n  if (S.mode === 0) {\n    const ph = cl((S.done + S.owed) / S.K, 0, 1);\n    u = ph * ph * (3 - 2 * ph);\n    bump = 0.15 * S.A * sin(PI * ph);\n  } else if (S.mode === 1) {\n    u = 1;\n    sq = cos(PI * S.tip);\n  }\n  const X = (i) => (S.mode === 2 ? S.x[i] : wrap(S.bx[i] + near(S.ax[i] - S.bx[i]) * u));\n  const Y = (i) => {\n    if (S.mode === 2) return S.y[i];\n    if (S.mode === 1) return H / 2 + (S.ay[i] - H / 2) * sq;\n    return S.by[i] + (S.ay[i] - S.by[i]) * u + bump;\n  };\n  for (let i = S.nb; i \u003c S.n; i++) {\n    // Even bands full, odd bands pale, so a stratum that has been stirred\n    // shows as speckle in the next one's tint.\n    const b = S.band[i];\n    hsv(S.hue + 0.45 + 0.055 * b, b & 1 ? 0.4 : 0.82, 1, c);\n    disc(X(i), Y(i), S.r[i], abs(sq), c[0], c[1], c[2]);\n  }\n  hsv(S.hue + 0.12, 0.5, 1, c);\n  for (let b = 0; b \u003c S.nb; b++) disc(X(b), Y(b), S.r[b], abs(sq), c[0], c[1], c[2]);\n  for (let row = 0; row \u003c H; row++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (row * W + x) * 3;\n      display.setPixel(x, row, round(img[p] * 255), round(img[p + 1] * 255), round(img[p + 2] * 255));\n    }\n}\n","cardinal-vowels":"// ===== Patternflow pattern =====\n// Title:   Cardinal Vowels\n// Family:  type\n// Idea:    Daniel Jones's vowel chart stands up on the tall panel with its sixteen cardinal vowels in pairs at their eight places, a point that stands for the tongue glides from place to place across it, and above it, between phonetic brackets, the vowel nearest the tongue is drawn with an x-height of 28 LEDs and melts into the next one as the tongue crosses over, while a lip knob turns every letter into its rounded partner, i into y, a into ɶ, ɯ into u.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the cardinal vowels (Daniel Jones, An Outline of English Phonetics, 1918) and the vowel quadrilateral of the International Phonetic Alphabet, pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cardinal=0..8, Lips=0..1\n//\n// Knob 1: Hue. Turns every colour together. At 0 the spread-lip letters are cyan, the rounded ones pink, the chart's lines slate blue and the tongue warm white; the big letter turns from cyan through blue and violet to pink as the lips round. At 0.5 the spread-lip letters are red and the rounded ones green.\n// Knob 2: Speed. How fast the tongue wanders. At 2 it glides to a new place in about 0.8 s and rests 0.7 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Cardinal. 0 lets the tongue wander by itself. 1 to 8 holds it on the place of Jones's primary vowel of that number, in his order round the edge of the chart: 1 close front, down the front to 4 open front, across the floor to 5 open back, and up the back to 8 close back. Between two numbers it stands between the two places, and the big letter is half one and half the other; between 0 and 1 it is pulled from where it wanders toward vowel 1.\n// Knob 4: Lips. Rounds the lips: below 0.1 every letter is the spread-lip one (i e ɛ a ɑ ʌ ɤ ɯ), above 0.9 the rounded one (y ø œ ɶ ɒ ɔ o u), and in between the big letter morphs from one to the other and the small pairs on the chart trade brightness. The number in the top left corner is Jones's: 1 to 8 for his primary vowels, 9 to 16 for the secondary ones.\n\n// Daniel Jones fixed eight reference vowels round the edge of the space the\n// tongue can reach: 1 [i] with the tongue as high and as far forward as it\n// goes without friction, 5 [ɑ] as low and as far back, and between them, on\n// the front and back edges, vowels at equal steps of sound. Those are his\n// primary cardinal vowels, i e ɛ a ɑ ɔ o u. The secondary ones, 9 to 16,\n// take the same tongue and the other lips: y ø œ ɶ ɒ ʌ ɤ ɯ. He recorded\n// them himself for the gramophone, in 1917 and again in 1956. The chart the\n// International Phonetic Alphabet prints is his quadrilateral, close at the\n// top and open at the bottom, front at the left and back at the right, with\n// each place holding a pair, the unrounded letter left of its dot and the\n// rounded one right of it.\n//\n// On the panel the chart stands 62 LEDs high and 42 wide at the top, its\n// front edge slanting in to half that at the floor as on the IPA chart. The\n// big letter is the vowel whose dot is nearest the tongue. When the tongue\n// is about as near two dots, the letter is drawn from the blend of the two\n// letters' distance fields, so one letter melts into the other instead of\n// switching, and Lips blends each letter's field with its rounded\n// partner's in the same way. Inside the chart each dot has a faint pool of\n// light that fades out where another dot becomes nearer, so the pools are\n// the regions that name the same vowel.\n//\n// Every glyph is drawn here: the big letters as strokes (straight runs,\n// ellipse arcs and Catmull-Rom curves) whose distance fields are worked out\n// once, the small ones as 5-row pixel letters, and the figures as 3 by 5\n// pixel figures.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, exp, abs, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The chart: close at TY, open at BY; the front edge runs from FX0 to FX1,\n// the back edge stands at BX.\nconst TY = 60, BY = 121, FX0 = 12, FX1 = 33, BX = 54;\n// The big letter: x-height XH from row TOP, in rows 0..BH-1.\nconst XH = 28, TOP = 13, BH = 52, HW = 2.3;\n\n// --- Big letters, as strokes in x-height units (y down, 0 top, 1 baseline).\nfunction arc(cx, cy, rx, ry, a0, a1) {\n  const n = max(4, round(abs(a1 - a0) * 6)), p = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n;\n    p.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return p;\n}\nfunction curve(...c) {\n  const p = [];\n  for (let i = 0; i + 1 \u003c c.length; i++) {\n    const a = c[max(0, i - 1)], b = c[i], d = c[i + 1], e = c[min(c.length - 1, i + 2)];\n    for (let s = 0; s \u003c 6; s++) {\n      const t = s / 6, t2 = t * t, t3 = t2 * t;\n      const f = (k) => 0.5 * (2 * b[k] + (d[k] - a[k]) * t + (2 * a[k] - 5 * b[k] + 4 * d[k] - e[k]) * t2 + (3 * b[k] - a[k] - 3 * d[k] + e[k]) * t3);\n      p.push([f(0), f(1)]);\n    }\n  }\n  p.push(c[c.length - 1]);\n  return p;\n}\nconst line = (...p) => p;\nconst mirror = (strokes, w) => strokes.map((s) => s.map(([x, y]) => [w - x, y]));\nconst O = arc(0.42, 0.5, 0.42, 0.5, 0, 2 * PI);\nconst SCRIPT_A = [curve([0.78, 0.22], [0.5, 0.0], [0.16, 0.12], [0.04, 0.5], [0.16, 0.88], [0.5, 1.0], [0.78, 0.78]), line([0.8, 0], [0.8, 1])];\n\n// [name, width in x-height units, strokes]\nconst BIG = {\n  i: [0.4, [line([0.2, 0], [0.2, 1]), line([0.2, -0.33], [0.2, -0.3])]],\n  e: [0.86, [line([0.06, 0.5], [0.84, 0.5]), curve([0.84, 0.5], [0.76, 0.18], [0.44, 0.0], [0.12, 0.16], [0.03, 0.52], [0.16, 0.87], [0.48, 1.0], [0.8, 0.86])]],\n  \"ɛ\": [0.86, [curve([0.82, 0.14], [0.5, 0.0], [0.2, 0.08], [0.16, 0.32], [0.46, 0.5], [0.12, 0.62], [0.06, 0.86], [0.42, 1.0], [0.84, 0.86]), line([0.46, 0.5], [0.58, 0.5])]],\n  a: [0.86, [curve([0.12, 0.12], [0.42, 0.0], [0.72, 0.1], [0.78, 0.4], [0.78, 1.0]), curve([0.78, 0.5], [0.36, 0.48], [0.05, 0.68], [0.14, 0.95], [0.44, 1.0], [0.78, 0.84])]],\n  \"ɑ\": [0.9, SCRIPT_A],\n  \"ʌ\": [0.9, [line([0.02, 1], [0.45, 0], [0.88, 1])]],\n  \"ɤ\": [0.9, [curve([0.02, 0.0], [0.26, 0.38], [0.5, 0.72], [0.57, 0.92], [0.45, 1.01], [0.33, 0.92], [0.4, 0.72], [0.64, 0.38], [0.88, 0.0])]],\n  \"ɯ\": [0.92, [line([0.04, 0], [0.04, 0.62]), arc(0.25, 0.62, 0.21, 0.38, PI, 0), line([0.46, 0], [0.46, 0.62]), arc(0.67, 0.62, 0.21, 0.38, PI, 0), line([0.88, 0], [0.88, 1])]],\n  y: [0.9, [line([0.02, 0], [0.47, 0.98]), curve([0.88, 0], [0.47, 0.98], [0.34, 1.24], [0.12, 1.34])]],\n  \"ø\": [0.9, [O, line([-0.04, 1.1], [0.88, -0.1])]],\n  \"œ\": [1.42, [arc(0.36, 0.5, 0.34, 0.5, 0, 2 * PI), line([0.7, 0.5], [1.4, 0.5]), curve([1.4, 0.5], [1.32, 0.18], [1.05, 0.0], [0.76, 0.14], [0.7, 0.5], [0.76, 0.86], [1.06, 1.0], [1.38, 0.86])]],\n  \"ɶ\": [1.34, [curve([0.72, 0.0], [0.3, 0.04], [0.04, 0.5], [0.3, 0.96], [0.72, 1.0]), line([1.32, 0], [0.72, 0], [0.72, 1], [1.32, 1]), line([0.72, 0.5], [1.2, 0.5])]],\n  \"ɒ\": [0.9, mirror(SCRIPT_A, 0.84)],\n  \"ɔ\": [0.84, [curve([0.08, 0.14], [0.42, 0.0], [0.78, 0.28], [0.8, 0.5], [0.78, 0.72], [0.42, 1.0], [0.06, 0.86])]],\n  o: [0.84, [O]],\n  u: [0.84, [line([0.04, 0], [0.04, 0.62]), arc(0.42, 0.62, 0.38, 0.38, PI, 0), line([0.8, 0], [0.8, 1])]],\n};\n\n// --- Small letters, 5 rows of x-height (rows 2..6 of 9: two above for the\n// dot of i and the slash of ø, two below for the tail of y).\nconst SMALL = {\n  i: [\".#.\", \"...\", \"##.\", \".#.\", \".#.\", \".#.\", \"###\"],\n  e: [\".###.\", \"#...#\", \"#####\", \"#....\", \".###.\"],\n  \"ɛ\": [\".####\", \"#....\", \".###.\", \"#....\", \".####\"],\n  a: [\".###.\", \"....#\", \".####\", \"#...#\", \".####\"],\n  \"ɑ\": [\".##.#\", \"#..##\", \"#...#\", \"#..##\", \".##.#\"],\n  \"ʌ\": [\"..#..\", \".#.#.\", \".#.#.\", \"#...#\", \"#...#\"],\n  \"ɤ\": [\"#...#\", \".#.#.\", \"..#..\", \".#.#.\", \"..#..\"],\n  \"ɯ\": [\"#.#.#\", \"#.#.#\", \"#.#.#\", \"#.#.#\", \".#.##\"],\n  y: [\"#...#\", \"#...#\", \".#.#.\", \".#.#.\", \"..#..\", \".#...\", \"#....\"],\n  \"ø\": [\"....#\", \".###.\", \"#..##\", \"#.#.#\", \"##..#\", \".###.\", \"#....\"],\n  \"œ\": [\".##.##.\", \"#..#..#\", \"#..####\", \"#..#...\", \".##.###\"],\n  \"ɶ\": [\".######\", \"#..#...\", \"#..####\", \"#..#...\", \".######\"],\n  \"ɒ\": [\"#.##.\", \"##..#\", \"#...#\", \"##..#\", \"#.##.\"],\n  \"ɔ\": [\".###.\", \"....#\", \"....#\", \"....#\", \".###.\"],\n  o: [\".###.\", \"#...#\", \"#...#\", \"#...#\", \".###.\"],\n  u: [\"#...#\", \"#...#\", \"#...#\", \"#..##\", \".##.#\"],\n};\n// Rows above the x-height for each small letter that reaches up.\nconst RISE = { i: 2, \"ø\": 1 };\n\n// 3 by 5 figures, drawn for this pattern.\nconst FIG = [\"####.##.##.####\", \".#.##..#..#.###\", \"###..#####..###\", \"###..#.##..####\", \"#.##.####..#..#\", \"####..###..####\", \"####..####.####\", \"###..#..#.#..#.\", \"####.#####.####\", \"####.####..####\"];\n\n// The eight places in Jones's order, as (backness, openness), with the\n// spread-lip and rounded letters and their cardinal numbers.\nconst PLACES = [\n  [0, 0, \"i\", \"y\", 1, 9],\n  [0, 1 / 3, \"e\", \"ø\", 2, 10],\n  [0, 2 / 3, \"ɛ\", \"œ\", 3, 11],\n  [0, 1, \"a\", \"ɶ\", 4, 12],\n  [1, 1, \"ɑ\", \"ɒ\", 5, 13],\n  [1, 2 / 3, \"ʌ\", \"ɔ\", 14, 6],\n  [1, 1 / 3, \"ɤ\", \"o\", 15, 7],\n  [1, 0, \"ɯ\", \"u\", 16, 8],\n];\nconst px = (b, v) => FX0 + v * (FX1 - FX0) + b * (BX - FX0 - v * (FX1 - FX0));\nconst py = (v) => TY + v * (BY - TY);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i, p = v * (1 - s), q = v * (1 - s * f), t = v * (1 - s * (1 - f));\n  const c = i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n  o[0] = c[0];\n  o[1] = c[1];\n  o[2] = c[2];\n  return o;\n}\n\nfunction segDist(x, y, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((x - ax) * dx + (y - ay) * dy) / l, 0, 1) : 0;\n  const ex = ax + dx * t - x, ey = ay + dy * t - y;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// The distance from every LED of the big box to a letter's strokes, in LEDs.\nfunction field(name) {\n  const [w, strokes] = BIG[name], x0 = W / 2 - (w * XH) / 2, f = new Float32Array(W * BH);\n  const segs = [];\n  for (const s of strokes) for (let i = 0; i + 1 \u003c s.length; i++) segs.push([x0 + s[i][0] * XH, TOP + s[i][1] * XH, x0 + s[i + 1][0] * XH, TOP + s[i + 1][1] * XH]);\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let d = 1e9;\n      for (const g of segs) d = min(d, segDist(x + 0.5, y + 0.5, g[0], g[1], g[2], g[3]));\n      f[y * W + x] = d;\n    }\n  return f;\n}\n\nexport function setup(params) {\n  const F = {};\n  for (const name of Object.keys(BIG)) F[name] = field(name);\n  // Each LED inside the chart: its nearest place and how near the next.\n  const cell = new Int8Array(W * H).fill(-1), pool = new Float32Array(W * H);\n  for (let y = TY; y \u003c= BY; y++) {\n    const v = (y - TY) / (BY - TY), xf = FX0 + v * (FX1 - FX0);\n    for (let x = Math.ceil(xf); x \u003c= BX; x++) {\n      let d1 = 1e9, d2 = 1e9, k1 = 0;\n      PLACES.forEach((p, k) => {\n        const d = Math.hypot(px(p[0], p[1]) - x, py(p[1]) - y);\n        if (d \u003c d1) (d2 = d1), (d1 = d), (k1 = k);\n        else if (d \u003c d2) d2 = d;\n      });\n      cell[y * W + x] = k1;\n      pool[y * W + x] = 1 - (2 * d1) / (d1 + d2);\n    }\n  }\n  params.s = {\n    F, cell, pool, b: 0, v: 0, fb: 0, fv: 0, gb: 0, gv: 0, at: 0, go: 1, rest: 0, trail: [], hue: 0, speed: 1, hand: 0, lips: 0,\n    rgb: new Float32Array(W * H * 3),\n  };\n  pick(params.s);\n}\n\n// The next place to glide to: another cardinal vowel, or now and then a\n// point between them.\nfunction pick(S) {\n  S.fb = S.b;\n  S.fv = S.v;\n  if (Math.random() \u003c 0.25) {\n    S.gb = 0.15 + 0.7 * Math.random();\n    S.gv = 0.1 + 0.8 * Math.random();\n  } else {\n    let k;\n    do k = floor(Math.random() * 8);\n    while (PLACES[k][0] === S.gb && PLACES[k][1] === S.gv);\n    S.gb = PLACES[k][0];\n    S.gv = PLACES[k][1];\n  }\n  const d = Math.hypot((S.gb - S.fb) * 0.7, S.gv - S.fv);\n  S.go = 0.45 + 0.5 * d;\n  S.at = 0;\n}\n\n// Where knob 3 puts the tongue: along the edge through the places 1..8.\nfunction edge(c) {\n  const k = min(6, floor(c - 1)), f = c - 1 - k, a = PLACES[k], b = PLACES[k + 1];\n  return [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  S.hand = cl(k[2] || 0, 0, 8);\n  S.lips = sm(0.1, 0.9, cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  // The wander.\n  if (S.rest > 0) {\n    S.rest -= d * S.speed;\n    if (S.rest \u003c= 0) pick(S);\n  } else {\n    S.at += (d * S.speed) / S.go;\n    if (S.at >= 1) (S.at = 1), (S.rest = 0.7);\n  }\n  const e = sm(0, 1, S.at);\n  let b = S.fb + (S.gb - S.fb) * e, v = S.fv + (S.gv - S.fv) * e;\n  if (S.hand > 0) {\n    // The hand: pulled from the wander toward vowel 1 below 1, along the\n    // edge above it, and eased so a turned knob glides rather than jumps.\n    const [hb, hv] = edge(max(1, S.hand)), f = min(1, S.hand), a = 1 - exp(-d * 12);\n    b += (hb - b) * f;\n    v += (hv - v) * f;\n    S.b += (b - S.b) * a;\n    S.v += (v - S.v) * a;\n  } else (S.b = b), (S.v = v);\n  S.trail.push([px(S.b, S.v), py(S.v)]);\n  if (S.trail.length > 36) S.trail.shift();\n}\n\nfunction add(rgb, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  rgb[o] = max(rgb[o], c[0] * a);\n  rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n  rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n}\n\nfunction small(rgb, name, x, y, c, a) {\n  const rows = SMALL[name], rise = RISE[name] || 0;\n  for (let r = 0; r \u003c rows.length; r++)\n    for (let i = 0; i \u003c rows[r].length; i++) if (rows[r][i] === \"#\") add(rgb, x + i, y - rise + r, c, a);\n}\n\nfunction figure(rgb, n, x, y, c, a) {\n  const s = String(n);\n  for (let j = 0; j \u003c s.length; j++) {\n    const g = FIG[+s[j]];\n    for (let r = 0; r \u003c 5; r++) for (let i = 0; i \u003c 3; i++) if (g[r * 3 + i] === \"#\") add(rgb, x + j * 4 + i, y + r, c, a);\n  }\n}\n\nfunction seg(rgb, x0, y0, x1, y1, c, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0), 1);\n  for (let i = 0; i \u003c= n; i++) add(rgb, round(x0 + ((x1 - x0) * i) / n), round(y0 + ((y1 - y0) * i) / n), c, a);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, hue = S.hue, lips = S.lips;\n  rgb.fill(0);\n  const cu = hsv(0.5 + hue, 0.85, 1, [0, 0, 0]), cr = hsv(0.9 + hue, 0.7, 1, [0, 0, 0]), lineC = hsv(0.62 + hue, 0.45, 1, [0, 0, 0]);\n  // The letter's colour turns the short way round the wheel, through blue.\n  const cl2 = hsv(0.5 + 0.4 * lips + hue, 0.85 - 0.15 * lips, 1, [0, 0, 0]);\n  const tx = px(S.b, S.v), ty = py(S.v);\n  // The two places nearest the tongue.\n  let d1 = 1e9, d2 = 1e9, k1 = 0, k2 = 1;\n  PLACES.forEach((p, k) => {\n    const d = Math.hypot(px(p[0], p[1]) - tx, py(p[1]) - ty);\n    if (d \u003c d1) (d2 = d1), (k2 = k1), (d1 = d), (k1 = k);\n    else if (d \u003c d2) (d2 = d), (k2 = k);\n  });\n  const m = 0.5 * sm(0.3, 0.5, d1 / (d1 + d2));\n  // The pools.\n  for (let p = 0; p \u003c W * H; p++) {\n    const k = S.cell[p];\n    if (k \u003c 0) continue;\n    const a = (k === k1 ? 0.3 : 0.13) * S.pool[p];\n    rgb[p * 3] = cl2[0] * a;\n    rgb[p * 3 + 1] = cl2[1] * a;\n    rgb[p * 3 + 2] = cl2[2] * a;\n  }\n  // The chart's lines: the edge, the close-mid and open-mid lines, the\n  // central line.\n  const L = 0.42, L2 = 0.22;\n  seg(rgb, FX0, TY, BX, TY, lineC, L);\n  seg(rgb, BX, TY, BX, BY, lineC, L);\n  seg(rgb, FX1, BY, BX, BY, lineC, L);\n  seg(rgb, FX0, TY, FX1, BY, lineC, L);\n  for (const v of [1 / 3, 2 / 3]) seg(rgb, round(px(0, v)), round(py(v)), BX, round(py(v)), lineC, L2);\n  seg(rgb, round(px(0.5, 0)), TY, round(px(0.5, 1)), BY, lineC, L2);\n  // The pairs.\n  PLACES.forEach((p, k) => {\n    const x = round(px(p[0], p[1])), y = round(py(p[1]));\n    const near = k === k1 ? 1 : k === k2 ? 2 * m : 0;\n    add(rgb, x, y, [1, 1, 1], 0.6 + 0.4 * near);\n    const wl = SMALL[p[2]][SMALL[p[2]].length - 1].length;\n    const au = 0.16 + (0.56 + 0.28 * near) * (1 - lips), ar = 0.16 + (0.56 + 0.28 * near) * lips;\n    const wu = [0, 0, 0], wr = [0, 0, 0];\n    for (let c = 0; c \u003c 3; c++) (wu[c] = cu[c] + (1 - cu[c]) * 0.5 * near * (1 - lips)), (wr[c] = cr[c] + (1 - cr[c]) * 0.5 * near * lips);\n    small(rgb, p[2], x - 2 - wl, y - 2, wu, au);\n    small(rgb, p[3], x + 2, y - 2, wr, ar);\n  });\n  // The tongue and where it has been.\n  for (let i = 0; i \u003c S.trail.length; i++) {\n    const [x, y] = S.trail[i];\n    add(rgb, floor(x), floor(y), [1, 0.85, 0.65], 0.12 + (0.35 * i) / S.trail.length);\n  }\n  const tc = hsv(0.1 + hue, 0.3, 1, [0, 0, 0]);\n  for (let j = -2; j \u003c= 2; j++)\n    for (let i = -2; i \u003c= 2; i++) {\n      const r = Math.hypot(i + floor(tx) + 0.5 - tx, j + floor(ty) + 0.5 - ty);\n      add(rgb, floor(tx) + i, floor(ty) + j, tc, cl(1.6 - r, 0, 1) + 0.25 * exp(-r));\n    }\n  // The big letter: the nearest place's letter, blended toward the next\n  // nearest by m and toward its rounded partner by lips.\n  const P1 = PLACES[k1], P2 = PLACES[k2], F = S.F;\n  const a1 = F[P1[2]], b1 = F[P1[3]], a2 = F[P2[2]], b2 = F[P2[3]];\n  // A blend of two fields thins out where the letters part, so the stroke\n  // swells by up to 1.25 LEDs halfway.\n  const thick = 5 * max(m * (1 - m), lips * (1 - lips));\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let d = a1[p];\n      if (lips > 0) d += (b1[p] - d) * lips;\n      if (m > 0) d += (a2[p] + (b2[p] - a2[p]) * lips - d) * m;\n      d -= thick;\n      const core = cl(HW + 0.5 - d, 0, 1), glow = 0.2 * exp(-max(0, d - HW) / 2.2);\n      add(rgb, x, y, cl2, core + (1 - core) * glow);\n    }\n  // Phonetic brackets round it, and Jones's number for it.\n  const bc = lineC, BT = 5, BB = 48;\n  seg(rgb, 3, BT, 3, BB, bc, 0.55);\n  seg(rgb, 3, BT, 6, BT, bc, 0.55);\n  seg(rgb, 3, BB, 6, BB, bc, 0.55);\n  seg(rgb, 60, BT, 60, BB, bc, 0.55);\n  seg(rgb, 57, BT, 60, BT, bc, 0.55);\n  seg(rgb, 57, BB, 60, BB, bc, 0.55);\n  const n = lips \u003c 0.5 ? P1[4] : P1[5];\n  figure(rgb, n, 8, 7, [1, 1, 1], 0.6);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, round(rgb[o] * 255)), min(255, round(rgb[o + 1] * 255)), min(255, round(rgb[o + 2] * 255)));\n    }\n}\n","fifteen-puzzle":"// ===== Patternflow pattern =====\n// Title:   Fifteen Puzzle\n// Family:  type\n// Idea:    Two fifteen puzzles stand one above the other and take the same slides at the same moment, the top one scrambled from the solved order and the bottom one by the same scramble from Sam Loyd's order with 14 and 15 exchanged, and as a solver brings the top board home row by row the bottom board follows it exactly and ends at 1 to 13, 15, 14, while a number on the empty square of each board, the count of pairs out of order plus how many rows the empty square stands above the bottom, steps down by twos and stays even on top and odd below.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the fifteen puzzle (Noyes Palmer Chapman, 1874; the craze of 1880), the parity proof that half the arrangements cannot be reached (William Woolsey Johnson and William E. Story, American Journal of Mathematics, 1879), Sam Loyd's 14-15 puzzle, pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scramble=0..1, Swap=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the tiles are azure, the exchanged pair pink, the count under the top board's empty square green and the one under the bottom board's pink; at 0.33 the tiles are pink and the pair yellow-green, at 0.5 the tiles orange (brown away from home) and the pair teal.\n// Knob 2: Speed. Slides a second, twice the knob: 4 at the opening 2, each tile crossing its 16 LEDs in a quarter of a second; 0.4 at 0.2, where every slide can be followed, and 6 at 3. The shuffle between puzzles runs three times as fast, between 6 and 14 slides a second.\n// Knob 3: Scramble. How many random slides mix the boards before each solve: 40 at the opening 0, which the solver takes 38 to 94 slides to undo (68 as a rule, 17 s at the opening speed); 120 at 1, where a solve takes 66 to 110 (90). The solver's way home is longer than the scramble because it places the tiles in its own order. A turn takes effect at the next shuffle.\n// Knob 4: Swap. Which two numbers the bottom board has exchanged, in five steps: 14 and 15 (Loyd's) at the opening, then 1 and 2, 8 and 12, 4 and 13, and 1 and 15. The pair is pink on both boards; whatever the solver does, the bottom board ends with the pair crossed and its number at 1, 1, 7, 17 or 27, never 0.\n\n// The fifteen puzzle has 16! / 2 arrangements anyone can reach and as many\n// that nobody can. Johnson and Story proved it in 1879 in the second volume\n// of the American Journal of Mathematics. Read the tiles row by row, skip\n// the empty square, and count the pairs that stand in the wrong order: the\n// inversions. A slide along a row changes nothing in that reading. A slide\n// up or down lifts one tile past the three others between its two cells,\n// which changes the count by 1 or 3, and moves the empty square one row.\n// So the inversions plus the empty square's height above the bottom row\n// change by an even number at every slide, and their parity never changes.\n// The solved board has 0 and 0. Loyd's board, solved with 14 and 15\n// exchanged, has one inversion and the empty square at the bottom: odd. It\n// can be brought to 1 to 13, 15, 14 and no closer. Story showed the other\n// half: every arrangement with the even parity can be reached.\n//\n// The panel is two boards of 16 tiles 16 LEDs square, the top one 0 to 63\n// and the bottom one 64 to 127. A move is the cell the empty square goes\n// to; both boards take every move. The bottom board is drawn as the top\n// board with the pair's labels exchanged, and that is the same thing as\n// playing the same moves from the exchanged start: moves act on cells, not\n// on labels. The number on each empty square is its board's inversions plus\n// its height. On top it walks down through even numbers to 0, below through\n// odd ones to the pair's own count, 1 for Loyd's.\n//\n// The solve is a real search, not the scramble undone. The top board is\n// solved in nine steps, the usual order a person learns: tile 1, tile 2,\n// tiles 3 and 4 together, 5, 6, 7 and 8, then the left column (9 and 13),\n// the next one (10 and 14), and the last 2 by 2 corner. Each step is a\n// breadth-first search over the cells of the tiles it places and of the\n// empty square, the placed tiles fixed and the others anonymous, so each\n// step is as short as it can be (the whole is not). At most 16^4 states.\n// Tiles in their own cells are lit; tiles away from home are dim. When the\n// top board arrives it flashes, and the bottom board's pair blinks. Then\n// the next scramble plays in view, three times as fast: a random walk of\n// the empty square that never steps straight back.\n\nconst W = 64, H = 128, C = 16;\nconst { floor, min, max, round, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Tile figures, 5 by 9 and drawn for this pattern; the 1 is 3 wide, so the\n// six two-figure numbers are 9 LEDs wide on a 14 LED face.\nconst BIG = [\n  \".###. #...# #...# #...# #...# #...# #...# #...# .###.\",\n  \".#. ##. .#. .#. .#. .#. .#. .#. ###\",\n  \".###. #...# ....# ....# ...#. ..#.. .#... #.... #####\",\n  \".###. #...# ....# ....# ..##. ....# ....# #...# .###.\",\n  \"...#. ..##. .#.#. #..#. #..#. ##### ...#. ...#. ...#.\",\n  \"##### #.... #.... ####. ....# ....# ....# #...# .###.\",\n  \"..##. .#... #.... ####. #...# #...# #...# #...# .###.\",\n  \"##### ....# ...#. ...#. ..#.. ..#.. .#... .#... .#...\",\n  \".###. #...# #...# #...# .###. #...# #...# #...# .###.\",\n  \".###. #...# #...# #...# .#### ....# ....# ...#. .##..\",\n].map((g) => g.split(\" \"));\n// The count under the empty square, 3 by 5.\nconst SMALL = [\n  \"### #.# #.# #.# ###\", \".#. ##. .#. .#. ###\", \"### ..# ### #.. ###\", \"### ..# .## ..# ###\", \"#.# #.# ### ..# ..#\",\n  \"### #.. ### ..# ###\", \"### #.. ### #.# ###\", \"### ..# ..# .#. .#.\", \"### #.# ### #.# ###\", \"### #.# ### ..# ###\",\n].map((g) => g.split(\" \"));\n\nconst SWAPS = [[14, 15], [1, 2], [8, 12], [4, 13], [1, 15]];\nconst GROUPS = [[1], [2], [3, 4], [5], [6], [7, 8], [9, 13], [10, 14], [11, 12, 15]];\nconst NB = [];\nfor (let c = 0; c \u003c 16; c++) {\n  const r = c >> 2, k = c & 3, a = [];\n  if (r > 0) a.push(c - 4);\n  if (r \u003c 3) a.push(c + 4);\n  if (k > 0) a.push(c - 1);\n  if (k \u003c 3) a.push(c + 1);\n  NB.push(a);\n}\n\nconst SEEN = new Uint8Array(65536), PAR = new Int32Array(65536), Q = new Int32Array(65536);\n\n// The nine searches. A state is the empty square's cell and the cells of\n// the step's tiles, four bits each.\nfunction solve(board) {\n  const b = Int8Array.from(board), moves = [], locked = new Uint8Array(16);\n  for (const g of GROUPS) {\n    const m = g.length;\n    let start = b.indexOf(0), want = 0;\n    for (let i = 0; i \u003c m; i++) {\n      start |= b.indexOf(g[i]) \u003c\u003c (4 + 4 * i);\n      want |= (g[i] - 1) \u003c\u003c (4 + 4 * i);\n    }\n    const mask = ((1 \u003c\u003c (4 * m)) - 1) \u003c\u003c 4;\n    SEEN.fill(0);\n    let head = 0, tail = 0, goal = -1;\n    Q[tail++] = start;\n    SEEN[start] = 1;\n    PAR[start] = -1;\n    while (head \u003c tail) {\n      const k = Q[head++];\n      if ((k & mask) === want) {\n        goal = k;\n        break;\n      }\n      const e = k & 15;\n      for (const n of NB[e]) {\n        if (locked[n]) continue;\n        let k2 = n;\n        for (let i = 0; i \u003c m; i++) {\n          const p = (k >> (4 + 4 * i)) & 15;\n          k2 |= (p === n ? e : p) \u003c\u003c (4 + 4 * i);\n        }\n        if (!SEEN[k2]) {\n          SEEN[k2] = 1;\n          PAR[k2] = k;\n          Q[tail++] = k2;\n        }\n      }\n    }\n    if (goal \u003c 0) break;\n    const path = [];\n    for (let k = goal; PAR[k] !== -1; k = PAR[k]) path.push(k & 15);\n    for (let j = path.length - 1; j >= 0; j--) {\n      const n = path[j], e = b.indexOf(0);\n      b[e] = b[n];\n      b[n] = 0;\n      moves.push(n);\n    }\n    for (const t of g) locked[t - 1] = 1;\n  }\n  return moves;\n}\n\n// A random walk of the empty square that never steps straight back.\nfunction scramble(b, k) {\n  let e = b.indexOf(0), prev = -1;\n  const mv = [];\n  for (let i = 0; i \u003c k; i++) {\n    const opts = NB[e].filter((n) => n !== prev);\n    const n = opts[floor(Math.random() * opts.length) % opts.length];\n    mv.push(n);\n    prev = e;\n    e = n;\n  }\n  return mv;\n}\n\nfunction apply(b, n) {\n  const e = b.indexOf(0);\n  b[e] = b[n];\n  b[n] = 0;\n}\n\n// Inversions of the 15 tiles read row by row, plus the empty square's\n// height above the bottom row; lab exchanges a pair's labels first.\nfunction parityCount(b, pa, pb) {\n  let inv = 0, e = 0;\n  const lab = (v) => (v === pa ? pb : v === pb ? pa : v);\n  for (let i = 0; i \u003c 16; i++) {\n    const vi = lab(b[i]);\n    if (!vi) {\n      e = i;\n      continue;\n    }\n    for (let j = i + 1; j \u003c 16; j++) {\n      const vj = lab(b[j]);\n      if (vj && vj \u003c vi) inv++;\n    }\n  }\n  return inv + 3 - (e >> 2);\n}\n\nexport function setup(params) {\n  params.s = {\n    b: Int8Array.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0]),\n    phase: \"init\", list: [], i: 0, u: 0, timer: 0, t: 0, hue: 0, rate: 4, k: 40, sw: 0,\n    buf: new Float32Array(W * H * 3), c0: [0, 0, 0], c1: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.rate = 2 * cl(kv[1] == null ? 2 : kv[1], 0.2, 3);\n  S.k = round(40 + 80 * cl(kv[2] || 0, 0, 1));\n  S.sw = min(SWAPS.length - 1, floor(cl(kv[3] == null ? 0.06 : kv[3], 0, 1) * SWAPS.length));\n  S.t += d;\n  if (S.phase === \"init\") {\n    for (const n of scramble(S.b, S.k)) apply(S.b, n);\n    S.list = solve(S.b);\n    S.phase = \"wait\";\n    S.timer = 0.5;\n  }\n  if (S.phase === \"wait\") {\n    S.timer -= d;\n    if (S.timer \u003c= 0) {\n      S.phase = \"solve\";\n      S.i = 0;\n      S.u = 0;\n    }\n  } else if (S.phase === \"solve\" || S.phase === \"mix\") {\n    S.u += d * (S.phase === \"mix\" ? cl(3 * S.rate, 6, 14) : S.rate);\n    while (S.u >= 1 && S.i \u003c S.list.length) {\n      apply(S.b, S.list[S.i++]);\n      S.u -= 1;\n    }\n    if (S.i >= S.list.length) {\n      S.u = 0;\n      if (S.phase === \"solve\") {\n        S.phase = \"cheer\";\n        S.timer = 2.4;\n      } else {\n        S.list = solve(S.b);\n        S.phase = \"wait\";\n        S.timer = 0.7;\n      }\n    }\n  } else if (S.phase === \"cheer\") {\n    S.timer -= d;\n    if (S.timer \u003c= 0) {\n      S.phase = \"mix\";\n      S.list = scramble(S.b, S.k);\n      S.i = 0;\n      S.u = 0;\n    }\n  }\n}\n\nfunction put(buf, x, y, c, f) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] = c[0] * f;\n  buf[o + 1] = c[1] * f;\n  buf[o + 2] = c[2] * f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { buf, b, c0, c1 } = S, hT = 0.58 + S.hue, hP = hT + 0.33, [pa, pb] = SWAPS[S.sw];\n  const sliding = (S.phase === \"solve\" || S.phase === \"mix\") && S.i \u003c S.list.length;\n  const from = sliding ? S.list[S.i] : -1, to = sliding ? b.indexOf(0) : -1, u = sliding ? ease(S.u) : 0;\n  // The empty square after this slide, and the boards' two counts there.\n  const after = Int8Array.from(b);\n  if (sliding) apply(after, from);\n  const hole = after.indexOf(0);\n  const cheer = S.phase === \"cheer\" ? 2.4 - S.timer : -1;\n\n  // The trays: dark, with a frame round each board.\n  const tray = hsv(hT, 0.5, 0.05, [0, 0, 0]), rim = hsv(hT, 0.35, 0.22, [0, 0, 0]);\n  for (let y = 0; y \u003c H; y++) {\n    const yb = y & 63;\n    for (let x = 0; x \u003c W; x++) put(buf, x, y, x === 0 || x === W - 1 || yb === 0 || yb === 63 ? rim : tray, 255);\n  }\n\n  for (let board = 0; board \u003c 2; board++) {\n    const oy = board * 64;\n    // The count, under the empty square.\n    const n = board ? parityCount(after, pa, pb) : parityCount(after, 0, 0);\n    hsv(board ? hP : hT - 0.25, 0.65, sliding ? 0.75 * u : 0.75, c0);\n    const s = String(n), hx = (hole & 3) * C, hy = oy + (hole >> 2) * C, tw = s.length * 4 - 1;\n    for (let j = 0; j \u003c s.length; j++) {\n      const g = SMALL[+s[j]];\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r][q] === \"#\") put(buf, hx + 8 - (tw >> 1) + 4 * j + q, hy + 6 + r, c0, 255);\n    }\n\n    for (let cell = 0; cell \u003c 16; cell++) {\n      const top = b[cell];\n      if (!top) continue;\n      const lab = board && top === pa ? pb : board && top === pb ? pa : top;\n      const moving = cell === from;\n      const cx = cell & 3, cy = cell >> 2;\n      let px = cx * C, py = cy * C, home = lab === cell + 1 ? 1 : 0;\n      if (moving) {\n        px = round(px + ((to & 3) - cx) * C * u);\n        py = round(py + ((to >> 2) - cy) * C * u);\n        home = home * (1 - u) + (lab === to + 1 ? u : 0);\n      }\n      py += oy;\n      const pair = lab === pa || lab === pb;\n      let v = 0.4 + 0.5 * home, sat = 0.62 - 0.12 * home, white = 0;\n      if (cheer >= 0) {\n        if (!board) {\n          const w = cheer - 0.08 * (cx + cy);\n          white = w > 0 && w \u003c 0.7 ? 0.6 * Math.sin((PI * w) / 0.7) : 0;\n        } else if (pair) {\n          const blink = 0.5 + 0.5 * cos(2 * PI * 2.5 * cheer);\n          v = 0.25 + 0.75 * blink;\n          sat = 0.75 - 0.5 * blink;\n        }\n      }\n      hsv(pair ? hP : hT, sat, v, c0);\n      for (let i = 0; i \u003c 3; i++) c0[i] = c0[i] + (1 - c0[i]) * white;\n      // Face 14 by 14 with a one-LED bevel, figures cut dark into it.\n      for (let y = 1; y \u003c 15; y++)\n        for (let x = 1; x \u003c 15; x++) {\n          const f = y === 1 || x === 1 ? 1.35 : y === 14 || x === 14 ? 0.55 : 1;\n          c1[0] = min(1, c0[0] * f);\n          c1[1] = min(1, c0[1] * f);\n          c1[2] = min(1, c0[2] * f);\n          put(buf, px + x, py + y, c1, 255);\n        }\n      const s2 = String(lab), wd = s2.length === 1 ? BIG[lab][0].length : 3 + 1 + BIG[lab - 10][0].length;\n      let x0 = px + 1 + ((14 - wd + 1) >> 1);\n      for (let j = 0; j \u003c s2.length; j++) {\n        const g = BIG[+s2[j]];\n        for (let r = 0; r \u003c 9; r++) for (let q = 0; q \u003c g[r].length; q++) if (g[r][q] === \"#\") put(buf, x0 + q, py + 3 + r, c0, 255 * 0.1);\n        x0 += g[0].length + 1;\n      }\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, round(buf[o]), round(buf[o + 1]), round(buf[o + 2]));\n}\n","gaussian-zeros":"// ===== Patternflow pattern =====\n// Title:   Gaussian Zeros\n// Family:  noise\n// Idea:    The zeros of the planar Gaussian analytic function fill the upper half, each a black point ringed by the colour wheel of the function's phase, and drift as its random coefficients turn, while the lower half draws Poisson points of the same density with the same marks and the same speed, so the upper half stays an even foam of cells while the lower one piles its points into clumps and leaves dark holes between them.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the zeros of the planar Gaussian analytic function (Mikhail Sodin and Boris Tsirelson, Random complex zeroes, 2004; J. Ben Hough, Manjunath Krishnapur, Yuval Peres and Bálint Virág, Zeros of Gaussian Analytic Functions and Determinantal Point Processes, 2009), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=0..1, Focus=0..1\n//\n// Knob 1: Hue. Adds a turn to every phase before it is painted, so each wheel turns round its black point. At 0 phase 0 is red, a third of a turn green and two thirds blue; at 0.5 phase 0 is cyan. The ground stays deep indigo.\n// Knob 2: Speed. How fast the coefficients turn: at 2 each of the three Gaussians in a coefficient turns at 0.3 to 0.9 radians a second, and a zero moves 0.48 units, 2.4 LEDs, a second on average. The Poisson points wander at the same mean speed. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Scale. LEDs to one unit of the plane, 5 at 0 and 3.5 at 1. Each half is 64 by 63 LEDs: 12.8 by 12.6 units and 51 zeros on average at 0, 18.3 by 18 units and 105 zeros at 1, where the upper half turns into a fine, even weave and the holes in the lower one stand out the most.\n// Knob 4: Focus. How far a mark spreads, rho = 4.4 - 2.6 Focus LEDs: 4.24 at the opening 0.06, where a lone mark's brightest ring sits 3 LEDs from its point and neighbouring zeros, 6.2 LEDs apart on average, run together into a foam; 3.1 at 0.5; 1.8 at 1, where every point is a small separate wheel and the two halves are the two point patterns bare.\n\n// The planar Gaussian analytic function is\n//\n//   f(z) = sum_n xi_n z^n / sqrt(n!),\n//\n// the xi_n independent standard complex Gaussians. E f(z) conj f(w) =\n// exp(z conj w), so |f(z)|^2 exp(-|z|^2) has the same law at every z, and\n// the zeros of f form a point process that no translation or rotation of\n// the plane changes, with 1/pi zeros to each unit of area. They are not\n// independent. A zero makes the function small around it, which leaves\n// little room for another, so the zeros keep apart and spread far more\n// evenly than Poisson points of the same density. Counted in Node over 40\n// runs of 30 s, a sample every 3 s, a half of this panel holds 51.3 zeros\n// with a spread of 1.7 against 51.7 and 6.1 Poisson points, a zero's\n// nearest neighbour is 1.23 units away on average against 0.88 (0.886 in\n// theory), and 3.0% of zeros have a neighbour within 0.6 units against\n// 30.8% of Poisson points (1 - exp(-0.36) = 30.2%).\n//\n// The upper half is the window of the plane round z = 0, 64 by 63 LEDs at\n// 5 LEDs a unit. f is summed by Horner to |z|^2 + 4.5|z| + 8 terms, past\n// which the terms are negligible, on every other LED. A cell of that grid\n// holds a zero when arg f winds once round it; far from 0, arg f turns by\n// Im(h conj z) over a step h even where there is no zero, so each step is\n// read against that turn. Newton, on f(z) exp(-z conj z0) so that the\n// growth of f does not throw it, puts the zero in place. Each coefficient\n// is the sum of three standard complex Gaussians turning at their own\n// rates, over sqrt 3: again a standard complex Gaussian at every moment,\n// so at every frame f is exactly a GAF, and the zeros drift and dodge.\n//\n// The colour is the phase seen from the zero itself. Translating a GAF,\n// g(w) = exp(-w conj a - |a|^2/2) f(a + w), gives a GAF again, and its\n// phase arg f(a + w) - Im(w conj a) loses the fast background turn that\n// arg f has far from 0, the turn that would otherwise stripe the corners.\n// Round each zero a the pattern takes g's Taylor series to w^5 and paints\n// its phase as the wheel; every wheel runs the same way round, as the zeros\n// of an analytic function must. A mark multiplies the brightness field by\n// 1 - exp(-d^2 / rho^2), black at the point and brightest where the field\n// is 0.4. Where marks overlap their wheels vote, and wheels that disagree\n// cancel towards white, drawing pale seams between the cells.\n//\n// The lower half holds 215 points on a 26 by 26 unit torus, uniform and\n// each moving on its own with a velocity that turns slowly, which keeps\n// them a Poisson process of density 1/pi in the window. They get the same\n// marks with a plain wheel each.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, sin, cos, atan2, log, round, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// The GAF fills rows 0 .. HG - 1 and the Poisson points rows HP .. H - 1.\n// f is evaluated on every other LED, MG LEDs past the GAF's edges so that\n// zeros just outside still mark the LEDs near them.\nconst HG = 63, HP = 65, MG = 6;\nconst GW = (W + 2 * MG) / 2 + 1, GH = floor((HG + 2 * MG) / 2) + 2;\n// Terms kept of the series, turning Gaussians per coefficient, Taylor\n// terms kept round a zero.\nconst NMAX = 270, NJ = 3, NT = 6;\n// The Poisson torus in units, centred on the lower half: wider than the\n// half at the smallest Scale by more than any mark reaches.\nconst TW = 26, TH = 26;\n// Poisson speed per unit of time, matched to the zeros' mean speed.\nconst VP = 0.39;\n\nfunction gauss() {\n  return sqrt(-2 * log(max(1e-12, Math.random()))) * cos(TAU * Math.random());\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const g = new Float64Array(NMAX * NJ * 2), om = new Float64Array(NMAX * NJ);\n  for (let i = 0; i \u003c NMAX * NJ; i++) {\n    // A standard complex Gaussian: E|g|^2 = 1, each part variance 1/2.\n    g[2 * i] = gauss() * Math.SQRT1_2;\n    g[2 * i + 1] = gauss() * Math.SQRT1_2;\n    om[i] = (Math.random() \u003c 0.5 ? -1 : 1) * (0.3 + 0.6 * Math.random());\n  }\n  // 1 / sqrt(n!)\n  const isf = new Float64Array(NMAX);\n  let lf = 0;\n  for (let n = 0; n \u003c NMAX; n++) {\n    if (n > 0) lf += log(n);\n    isf[n] = exp(-lf / 2);\n  }\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, ppu: 5, rho: 4.2,\n    g, om, isf, c: new Float64Array(NMAX * 2),\n    ar: new Float32Array(GW * GH), zx: [], zy: [],\n    e: new Float32Array(W * H),\n    wr: new Float32Array(W * H), wi: new Float32Array(W * H), ws: new Float32Array(W * H),\n    G: new Float64Array(NT * 2), px: [], py: [], pvx: [], pvy: [], pth: [],\n    bg: [0, 0, 0], col: [0, 0, 0],\n  });\n  // Uniform points of density 1/pi on the torus, round(TW TH / pi) = 215\n  // of them, each placed and moved on its own: in a window a quarter of the\n  // torus or less that is a Poisson process to within the count.\n  const n = round((TW * TH) / PI);\n  for (let i = 0; i \u003c n; i++) {\n    S.px.push(Math.random() * TW);\n    S.py.push(Math.random() * TH);\n    S.pvx.push(gauss());\n    S.pvy.push(gauss());\n    S.pth.push(TAU * Math.random());\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.ppu = 5 - 1.5 * cl(k[2] || 0, 0, 1);\n  S.rho = 4.4 - 2.6 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const ds = d * S.speed * 0.5;\n  S.t += ds;\n  // Each Poisson point wanders with a velocity that turns slowly, and on\n  // its own, so the points stay a Poisson process.\n  const a = exp(-0.4 * ds), b = sqrt(1 - a * a);\n  for (let i = 0; i \u003c S.px.length; i++) {\n    S.pvx[i] = S.pvx[i] * a + gauss() * b;\n    S.pvy[i] = S.pvy[i] * a + gauss() * b;\n    S.px[i] = (S.px[i] + S.pvx[i] * VP * ds + TW) % TW;\n    S.py[i] = (S.py[i] + S.pvy[i] * VP * ds + TH) % TH;\n    S.pth[i] += 0.5 * ds * S.pvx[i];\n  }\n}\n\nconst terms = (r2) => min(NMAX, floor(r2 + 4.5 * sqrt(r2) + 8));\n\n// f(z) and f'(z) by Horner.\nconst F = [0, 0, 0, 0];\nfunction evalF(c, x, y) {\n  let fr = 0, fi = 0, dr = 0, di = 0;\n  for (let n = terms(x * x + y * y) - 1; n >= 0; n--) {\n    const t1 = dr * x - di * y + fr, t2 = dr * y + di * x + fi;\n    dr = t1;\n    di = t2;\n    const a = fr * x - fi * y + c[2 * n], b = fr * y + fi * x + c[2 * n + 1];\n    fr = a;\n    fi = b;\n  }\n  F[0] = fr;\n  F[1] = fi;\n  F[2] = dr;\n  F[3] = di;\n}\n\n// Round a zero a: the Taylor coefficients T_m = f^(m)(a) / m! by repeated\n// synthetic division, then those of the GAF seen from a,\n// g(w) = exp(-w conj a) f(a + w), G_m = sum_l T_(m-l) (-conj a)^l / l!,\n// whose phase is arg f(a + w) - Im(w conj a).\nconst BUF = new Float64Array(NMAX * 2), T = new Float64Array(NT * 2);\nfunction local(c, ax, ay, G) {\n  const N = terms(ax * ax + ay * ay);\n  for (let n = 0; n \u003c 2 * N; n++) BUF[n] = c[n];\n  for (let m = 0; m \u003c NT; m++) {\n    // Divide by (z - a) in place: the quotient lands in BUF[0 .. N - 2 - m]\n    // and the remainder is T_m.\n    let rr = 0, ri = 0;\n    for (let n = N - 1 - m; n >= 0; n--) {\n      const a = rr * ax - ri * ay + BUF[2 * n], b = rr * ay + ri * ax + BUF[2 * n + 1];\n      BUF[2 * n] = rr;\n      BUF[2 * n + 1] = ri;\n      rr = a;\n      ri = b;\n    }\n    T[2 * m] = rr;\n    T[2 * m + 1] = ri;\n  }\n  let sc = 0;\n  for (let m = 1; m \u003c NT; m++) {\n    let gr = 0, gi = 0, pr = 1, pi = 0;\n    for (let l = 0; l \u003c= m; l++) {\n      if (l > 0) {\n        const qr = (-pr * ax - pi * ay) / l, qi = (pr * ay - pi * ax) / l;\n        pr = qr;\n        pi = qi;\n      }\n      gr += T[2 * (m - l)] * pr - T[2 * (m - l) + 1] * pi;\n      gi += T[2 * (m - l)] * pi + T[2 * (m - l) + 1] * pr;\n    }\n    G[2 * m] = gr;\n    G[2 * m + 1] = gi;\n    sc = max(sc, sqrt(gr * gr + gi * gi));\n  }\n  // Only the phase is used, so scale freely.\n  G[0] = G[1] = 0;\n  for (let m = 2; m \u003c 2 * NT; m++) G[m] /= sc || 1;\n  return G.slice();\n}\n\n// One mark at (qx, qy), rho LEDs across: the factor 1 - exp(-d^2 / rho^2)\n// on e, and a vote for the hue, a unit vector weighted exp(-d^2 / 2 rho^2):\n// the phase of the zero's own series G, or for a Poisson point a plain\n// wheel turned by th.\nfunction stamp(S, qx, qy, y0, y1, G, th) {\n  const { e, wr, wi, ws, ppu, rho } = S, ct = cos(th), st = sin(th);\n  const R = 2.3 * rho, ir = 1 / (rho * rho);\n  for (let py = max(y0, floor(qy - R)); py \u003c= min(y1, floor(qy + R) + 1); py++)\n    for (let px = max(0, floor(qx - R)); px \u003c= min(W - 1, floor(qx + R) + 1); px++) {\n      const dx = px - qx, dy = py - qy, d2 = dx * dx + dy * dy, p = py * W + px;\n      if (d2 * ir > 5) continue;\n      const E = exp(-d2 * ir);\n      e[p] *= 1 - E;\n      let a, b;\n      if (G) {\n        const ux = dx / ppu, uy = dy / ppu;\n        let sr = 0, si = 0;\n        for (let m = NT - 1; m >= 1; m--) {\n          const qa = sr * ux - si * uy + G[2 * m], qb = sr * uy + si * ux + G[2 * m + 1];\n          sr = qa;\n          si = qb;\n        }\n        a = sr * ux - si * uy;\n        b = sr * uy + si * ux;\n      } else {\n        a = dx * ct - dy * st;\n        b = dx * st + dy * ct;\n      }\n      const n = sqrt(a * a + b * b), w = sqrt(E);\n      if (n > 0) {\n        wr[p] += (w * a) / n;\n        wi[p] += (w * b) / n;\n      }\n      ws[p] += w;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { g, om, isf, c, ar, ppu, e, wr, wi, ws, bg, col } = S, t = S.t;\n  // The coefficients at time t, each a sum of NJ complex Gaussians turning\n  // at their own rates, which is again a standard complex Gaussian.\n  const sn = 1 / sqrt(NJ);\n  for (let n = 0; n \u003c NMAX; n++) {\n    let re = 0, im = 0;\n    for (let j = 0; j \u003c NJ; j++) {\n      const q = n * NJ + j, a = om[q] * t, ca = cos(a), sa = sin(a);\n      re += g[2 * q] * ca - g[2 * q + 1] * sa;\n      im += g[2 * q] * sa + g[2 * q + 1] * ca;\n    }\n    c[2 * n] = re * sn * isf[n];\n    c[2 * n + 1] = im * sn * isf[n];\n  }\n  // f on the grid, z = 0 in the middle of the upper half.\n  const cx = (W - 1) / 2, cy = (HG - 1) / 2, st = 2 / ppu, x0 = (-MG - cx) / ppu, y0 = (-MG - cy) / ppu;\n  for (let j = 0; j \u003c GH; j++) {\n    const y = y0 + j * st;\n    for (let i = 0; i \u003c GW; i++) {\n      const x = x0 + i * st, r2 = x * x + y * y;\n      let fr = 0, fi = 0;\n      for (let n = terms(r2) - 1; n >= 0; n--) {\n        const a = fr * x - fi * y + c[2 * n], b = fr * y + fi * x + c[2 * n + 1];\n        fr = a;\n        fi = b;\n      }\n      ar[j * GW + i] = atan2(fi, fr);\n    }\n  }\n  // The zeros: grid cells round which arg f winds once. Each step is read\n  // against the step the background makes, Im(h conj z), which far from 0\n  // is too big to read a winding off plain differences. Newton finishes.\n  const step = (p, q, xa, ya, xb, yb) => {\n    const bk = ((yb - ya) * (xa + xb) - (xb - xa) * (ya + yb)) / 2;\n    let dd = ar[q] - ar[p] - bk;\n    dd -= TAU * round(dd / TAU);\n    return dd + bk;\n  };\n  const zx = [], zy = [], zg = [];\n  for (let j = 0; j \u003c GH - 1; j++)\n    for (let i = 0; i \u003c GW - 1; i++) {\n      const p = j * GW + i, xa = x0 + i * st, ya = y0 + j * st, xb = xa + st, yb = ya + st;\n      const w = step(p, p + 1, xa, ya, xb, ya) + step(p + 1, p + 1 + GW, xb, ya, xb, yb) + step(p + 1 + GW, p + GW, xb, yb, xa, yb) + step(p + GW, p, xa, yb, xa, ya);\n      if (w \u003c PI) continue;\n      let x = xa + st / 2, y = ya + st / 2;\n      for (let it = 0; it \u003c 4; it++) {\n        // Newton on f(z) exp(-z conj z0), which has f's zeros without its\n        // growth: the step is -1 / (f'/f - conj z0).\n        evalF(c, x, y);\n        const m2 = F[0] * F[0] + F[1] * F[1];\n        if (!(m2 > 0)) break;\n        const lr = (F[2] * F[0] + F[3] * F[1]) / m2 - x, li = (F[3] * F[0] - F[2] * F[1]) / m2 + y, l2 = lr * lr + li * li;\n        if (!(l2 > 0)) break;\n        x -= lr / l2;\n        y += li / l2;\n      }\n      if (!(abs(x - xa - st / 2) \u003c 2 * st && abs(y - ya - st / 2) \u003c 2 * st)) continue;\n      let dup = false;\n      for (let k = 0; k \u003c zx.length; k++) if ((zx[k] - x) ** 2 + (zy[k] - y) ** 2 \u003c 0.01) dup = true;\n      if (dup) continue;\n      zx.push(x);\n      zy.push(y);\n      zg.push(local(c, x, y, S.G));\n    }\n  S.zx = zx;\n  S.zy = zy;\n  e.fill(1);\n  wr.fill(0);\n  wi.fill(0);\n  ws.fill(0);\n  for (let k = 0; k \u003c zx.length; k++) stamp(S, cx + zx[k] * ppu, cy + zy[k] * ppu, 0, HG - 1, zg[k], 0);\n  const sx = cx - (TW / 2) * ppu, sy = (HP + H - 1) / 2 - (TH / 2) * ppu;\n  for (let k = 0; k \u003c S.px.length; k++) stamp(S, sx + S.px[k] * ppu, sy + S.py[k] * ppu, HP, H - 1, null, S.pth[k]);\n  const hue0 = S.hue;\n  hsv(0.7, 0.65, 0.15, bg);\n  for (let py = 0; py \u003c H; py++) {\n    if (py >= HG && py \u003c HP) {\n      for (let px = 0; px \u003c W; px++) display.setPixel(px, py, 0, 0, 0);\n      continue;\n    }\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, ee = e[p];\n      // Black at the point, the wheel brightest where e = 0.4, the ground\n      // beyond 0.85. Where wheels overlap their votes cancel towards white.\n      const u = ee \u003c 0.4 ? 0 : max(0, 1 - (ee - 0.4) / 0.45);\n      const ring = ee \u003c 0.4 ? sqrt(ee / 0.4) : u * sqrt(u);\n      const k = ring * min(1, ws[p] * 1.2), core = min(1, ee / 0.3) * (1 - k);\n      const coh = ws[p] > 1e-4 ? sqrt(wr[p] * wr[p] + wi[p] * wi[p]) / ws[p] : 0;\n      hsv(atan2(wi[p], wr[p]) / TAU + hue0, 0.95 * coh, 1, col);\n      display.setPixel(px, py, round((bg[0] * core + col[0] * k) * 255), round((bg[1] * core + col[1] * k) * 255), round((bg[2] * core + col[2] * k) * 255));\n    }\n  }\n}\n","hopfield-letters":"// ===== Patternflow pattern =====\n// Title:   Hopfield Letters\n// Family:  type\n// Idea:    A Hopfield network of 1,536 neurons, each a 2 by 2 block of LEDs, holds the letters A, T, O and M in its Hebbian weights, and every few seconds it is handed one of them buried under noise and turns its neurons over one at a time, each flip lighting up as it happens, until the energy, traced underneath, can fall no further and the letter stands clean; store more letters and the same descent ends in a blurred blend that is none of them.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hopfield network (John Hopfield, 1982), its storage capacity 0.138 N (Daniel Amit, Hanoch Gutfreund and Haim Sompolinsky, 1985), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Load=0..1, Noise=0..1\n//\n// Knob 1: Hue. Turns both states round the wheel. At 0 a neuron at +1 is gold and one at -1 a dim navy, at 0.25 green on plum, at 0.5 blue on a dim olive, at 0.75 magenta on a dim green.\n// Knob 2: Speed. Neuron updates a second, 512 for each unit: 1,024 at the opening 2, so one sweep through all 1,536 neurons takes 1.5 s; 0.2 takes 15 s a sweep and 3 takes 1 s. Once no neuron's field points against it the state stands for 1.6 s / Speed, 0.8 s at the opening, before the next cue.\n// Knob 3: Load. How many letters the weights hold, 4 at 0 and 10 at 1, added in the order A T O M H E K R S X. Four come back every time from a cue with 26.5% of its neurons wrong. The fifth, H, agrees with M on 90% of the neurons, and with five stored neither M nor H is a valley any more: M's cue ends a dozen neurons or so short of M, and H's cue mostly in a blend that overlaps M by 0.89 and H by 0.90. With six T still comes back 87% of the time and A 43%, from seven no cue finds its letter, and from eight every cue ends in a blend lower in energy than any stored letter. The labels under the bars show which letters are stored.\n// Knob 4: Noise. The share of a cue's neurons set wrong, 25% at 0 rising to 50% at 1; at the opening 0.06 it is 26.5%. At 50% the cue is pure noise and says nothing of the letter asked for, so the network falls into whichever valley is nearest: a stored letter, its negative (the ground lit and the letter dark), or a blend.\n// Buttons: K1 tap hands the network its next cue at once.\n\n// John Hopfield's network (PNAS, 1982) is N neurons that are each +1 or\n// -1 and a symmetric weight between every pair. To store letters xi^1 ...\n// xi^P it takes the Hebb rule, W_ij = (1/N) sum over mu of xi_i^mu xi_j^mu,\n// with W_ii = 0. A neuron updates by taking the sign of its field\n// h_i = sum_j W_ij s_j, and since the weights are symmetric every flip\n// lowers (or keeps) the energy E = -1/2 sum_ij W_ij s_i s_j, so updating\n// one neuron at a time must end in a state no single flip can improve:\n// a valley of E. The stored letters are valleys when they are few and\n// unlike each other, and a corrupted letter rolls down into its own.\n//\n// With the Hebb rule the field never needs the N by N weights: with\n// M_mu = sum_j xi_j^mu s_j, the state's overlap with letter mu,\n// N h_i = sum_mu xi_i^mu M_mu - P s_i, the last term taking the diagonal\n// out. A flip of neuron i changes every M_mu by 2 s_i xi_i^mu, so an\n// update costs P steps and the energy is E/N = -1/2 sum_mu m_mu^2 + P/2N\n// with m_mu = M_mu / N. The bars under the picture are the m_mu, and the\n// trace above them is E/N, which falls in steps between cues and never\n// rises while the network is left alone.\n//\n// Daniel Amit, Hanoch Gutfreund and Haim Sompolinsky (Physical Review\n// Letters, 1985) found that random patterns stay retrievable up to\n// P = 0.138 N, 212 patterns for these 1,536 neurons. Letters are not\n// random: they share a ground and many strokes. Here M and H agree on 90%\n// of their neurons (overlap 0.79), and R on 81% with each of E and K.\n// Sitting on letter mu, a neuron where every other stored letter\n// disagrees with mu feels a field of 1 minus the sum of mu's overlaps\n// with them, so once that sum passes 1 such a neuron turns against the\n// letter and the letter stops being a valley. Four letters, 0.26% of N,\n// are recalled every time; at seven no stored letter is a valley any\n// more, and blends of several letters, spurious valleys nobody stored,\n// take their place.\n\nconst W = 64, H = 128, GW = 32, GH = 48, N = GW * GH, CS = 2;\nconst { floor, round, min, max, abs, sqrt, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst LIST = \"ATOMHEKRSX\";\n// Rows of the panel under the network: the energy trace, the bars, the labels.\nconst TR0 = 98, TR1 = 109, BAR0 = 112, BAR1 = 121, LAB = 122, TN = 60;\n\n// The letters as strokes in a 10 by 16 box, drawn for this pattern, then\n// set at neuron resolution as every neuron within 3 neurons of a stroke.\nconst arc = (cx, cy, rx, ry, a0, a1, n) => {\n  const o = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    o.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return o;\n};\nconst STROKES = {\n  A: [[[0, 16], [5, 0], [10, 16]], [[2.2, 10.5], [7.8, 10.5]]],\n  T: [[[0, 0], [10, 0]], [[5, 0], [5, 16]]],\n  O: [arc(5, 8, 5, 8, 0, 360, 24)],\n  M: [[[0, 16], [0, 0], [5, 9], [10, 0], [10, 16]]],\n  H: [[[0, 0], [0, 16]], [[10, 0], [10, 16]], [[0, 8], [10, 8]]],\n  E: [[[10, 0], [0, 0], [0, 16], [10, 16]], [[0, 8], [8, 8]]],\n  K: [[[0, 0], [0, 16]], [[10, 0], [0, 9]], [[3.5, 6.5], [10, 16]]],\n  R: [[[0, 16], [0, 0], [5, 0], ...arc(5, 4, 5, 4, -90, 90, 8), [0, 8]], [[4, 8], [10, 16]]],\n  S: [[...arc(5, 4, 5, 4, -20, -270, 12), ...arc(5, 12, 5, 4, -90, 160, 12)]],\n  X: [[[0, 0], [10, 16]], [[10, 0], [0, 16]]],\n};\n// The same ten as 3 by 5 labels under the bars.\nconst SMALL = {\n  A: \".#. #.# ### #.# #.#\", T: \"### .#. .#. .#. .#.\", O: \"### #.# #.# #.# ###\", M: \"#.# ### ### #.# #.#\",\n  H: \"#.# #.# ### #.# #.#\", E: \"### #.. ### #.. ###\", K: \"#.# #.# ##. #.# #.#\", R: \"##. #.# ##. #.# #.#\",\n  S: \".## #.. .#. ..# ##.\", X: \"#.# #.# .#. #.# #.#\",\n};\n\nfunction segDist(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const t = l ? cl(((px - ax) * dx + (py - ay) * dy) / l, 0, 1) : 0;\n  const x = ax + t * dx - px, y = ay + t * dy - py;\n  return sqrt(x * x + y * y);\n}\n\nfunction letter(ch) {\n  const out = new Int8Array(N), HW = 3, M = 3, sx = (GW - 2 * M - 2 * HW) / 10, sy = (GH - 2 * M - 2 * HW) / 16;\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      let d = 1e9;\n      for (const pl of STROKES[ch])\n        for (let i = 0; i + 1 \u003c pl.length; i++) {\n          const a = pl[i], b = pl[i + 1];\n          d = min(d, segDist(x + 0.5, y + 0.5, M + HW + a[0] * sx, M + HW + a[1] * sy, M + HW + b[0] * sx, M + HW + b[1] * sy));\n        }\n      out[y * GW + x] = d \u003c= HW ? 1 : -1;\n    }\n  return out;\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  const L = [...LIST].map(letter), K = L.length;\n  // Overlaps between the letters, for the energy each letter sits at.\n  const C = new Float32Array(K * K);\n  for (let a = 0; a \u003c K; a++)\n    for (let b = 0; b \u003c K; b++) {\n      let c = 0;\n      for (let p = 0; p \u003c N; p++) c += L[a][p] * L[b][p];\n      C[a * K + b] = c / N;\n    }\n  params.s = {\n    L, K, C, P: 4, s: new Int8Array(N), M: new Int32Array(K), flash: new Float32Array(N),\n    order: new Uint16Array(N), at: N, total: 0, hold: -1, cue: -1, budget: 0,\n    speed: 2, hue: 0, noise: 0.265, trace: new Float32Array(TN), tclock: 0, tn: 0, prev: false,\n    ink: [0, 0, 0], gnd: [0, 0, 0],\n  };\n  for (let i = 0; i \u003c N; i++) params.s.order[i] = i;\n}\n\nfunction overlaps(S) {\n  for (let m = 0; m \u003c S.K; m++) {\n    let v = 0;\n    const x = S.L[m];\n    for (let p = 0; p \u003c N; p++) v += x[p] * S.s[p];\n    S.M[m] = v;\n  }\n}\n\n// The next stored letter, with a share of its neurons set wrong.\nfunction kick(S) {\n  S.cue = (S.cue + 1) % S.P;\n  const x = S.L[S.cue];\n  for (let p = 0; p \u003c N; p++) {\n    const v = Math.random() \u003c S.noise ? -x[p] : x[p];\n    if (v !== S.s[p]) S.flash[p] = 0.5;\n    S.s[p] = v;\n  }\n  overlaps(S);\n  S.at = N;\n  S.hold = -1;\n}\n\nfunction energy(S) {\n  let e = 0;\n  for (let m = 0; m \u003c S.P; m++) e += (S.M[m] / N) * (S.M[m] / N);\n  return -0.5 * e + S.P / (2 * N);\n}\n\nfunction stable(S) {\n  const s = S.s, P = S.P;\n  for (let i = 0; i \u003c N; i++) {\n    let h = -P * s[i];\n    for (let m = 0; m \u003c P; m++) h += S.L[m][i] * S.M[m];\n    if (h * s[i] \u003c 0) return false;\n  }\n  return true;\n}\n\nfunction step(S) {\n  if (S.at >= N) {\n    // A new sweep in a fresh random order.\n    S.at = 0;\n    const o = S.order;\n    for (let i = N - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1)), t = o[i];\n      o[i] = o[j];\n      o[j] = t;\n    }\n  }\n  const i = S.order[S.at++], s = S.s, P = S.P;\n  let h = -P * s[i];\n  for (let m = 0; m \u003c P; m++) h += S.L[m][i] * S.M[m];\n  const v = h > 0 ? 1 : h \u003c 0 ? -1 : s[i];\n  if (v !== s[i]) {\n    for (let m = 0; m \u003c S.K; m++) S.M[m] += 2 * v * S.L[m][i];\n    s[i] = v;\n    S.flash[i] = 1;\n    S.total++;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.noise = 0.25 + 0.25 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const P = 4 + round(cl(k[2] || 0, 0, 1) * 6);\n  if (P !== S.P) {\n    S.P = P;\n    S.cue = S.cue % P;\n    S.hold = -1;\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (S.cue \u003c 0 || (btn && !S.prev)) kick(S);\n  S.prev = btn;\n  for (let p = 0; p \u003c N; p++) S.flash[p] = max(0, S.flash[p] - d * 3.5);\n  if (S.hold >= 0) {\n    S.hold -= d;\n    if (S.hold \u003c 0) kick(S);\n  } else {\n    S.budget += d * S.speed * 512;\n    const before = S.total;\n    while (S.budget >= 1) {\n      S.budget -= 1;\n      step(S);\n    }\n    // No flip this frame: if no neuron's field opposes it, the state is a\n    // valley, and it stands for 1.6 s / Speed before the next cue.\n    if (S.total === before && stable(S)) S.hold = 1.6 / S.speed;\n  }\n  // The energy, ten samples a second, the newest at the right.\n  S.tclock += d;\n  while (S.tclock >= 0.1) {\n    S.tclock -= 0.1;\n    S.trace.copyWithin(0, 1);\n    S.trace[TN - 1] = energy(S);\n    S.tn = min(TN, S.tn + 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const ink = hsv(S.hue + 0.13, 0.85, 1, S.ink), gnd = hsv(S.hue + 0.64, 0.75, 0.3, S.gnd);\n  const ir = ink[0] * 255, ig = ink[1] * 255, ib = ink[2] * 255, gr = gnd[0] * 255, gg = gnd[1] * 255, gb = gnd[2] * 255;\n  // The network: +1 in the letter colour, -1 in the dim ground, a neuron\n  // that has just flipped flaring towards white.\n  for (let y = 0; y \u003c 96; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = floor(y / CS) * GW + floor(x / CS), f = S.flash[p] * S.flash[p];\n      let r, g, b;\n      if (S.s[p] > 0) (r = ir), (g = ig), (b = ib);\n      else (r = gr), (g = gg), (b = gb);\n      display.setPixel(x, y, round(r + (255 - r) * f), round(g + (255 - g) * f), round(b + (255 - b) * f));\n    }\n  for (let y = 96; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n  // The energy trace: 0 at the top row, and the deepest stored letter's\n  // own energy three quarters of the way down, marked by a dotted line.\n  let el = 0;\n  for (let a = 0; a \u003c S.P; a++) {\n    let e = 0;\n    for (let b = 0; b \u003c S.P; b++) e += S.C[a * S.K + b] * S.C[a * S.K + b];\n    el = min(el, -0.5 * e + S.P / (2 * N));\n  }\n  const span = TR1 - TR0, ey = (e) => TR0 + cl((-e / -el) * 0.75, 0, 1) * span;\n  const yl = round(ey(el));\n  for (let x = 2; x \u003c W - 2; x += 3) display.setPixel(x, yl, round(gr * 1.6), round(gg * 1.6), round(gb * 1.6));\n  let last = -1;\n  for (let i = TN - S.tn; i \u003c TN; i++) {\n    const x = 2 + i, y = round(ey(S.trace[i]));\n    const a = last \u003c 0 ? y : last, lo = min(a, y), hi = max(a, y);\n    for (let yy = lo; yy \u003c= hi; yy++) display.setPixel(x, yy, round(ir), round(ig), round(ib));\n    for (let yy = hi + 1; yy \u003c= TR1; yy++) display.setPixel(x, yy, round(gr * 0.8), round(gg * 0.8), round(gb * 0.8));\n    last = y;\n  }\n  // One bar per letter in LIST: its overlap with the state, |m| tall, in\n  // the letter colour when m > 0 and in the ground colour lifted when the\n  // state leans to the letter's negative. Letters not stored are grey.\n  for (let m = 0; m \u003c S.K; m++) {\n    const x0 = 2 + m * 6, stored = m \u003c S.P, v = S.M[m] / N, hgt = round(abs(v) * (BAR1 - BAR0 + 1));\n    for (let y = BAR1 - hgt + 1; y \u003c= BAR1; y++)\n      for (let x = x0; x \u003c x0 + 4; x++) {\n        if (!stored) display.setPixel(x, y, 46, 46, 46);\n        else if (v > 0) display.setPixel(x, y, round(ir), round(ig), round(ib));\n        else display.setPixel(x, y, round(min(255, gr * 2.6)), round(min(255, gg * 2.6)), round(min(255, gb * 2.6)));\n      }\n    const g = SMALL[LIST[m]].split(\" \"), cue = stored && m === S.cue;\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++)\n        if (g[r][q] === \"#\") {\n          if (cue) display.setPixel(x0 + q, LAB + r, 255, 255, 255);\n          else if (stored) display.setPixel(x0 + q, LAB + r, round(ir * 0.8), round(ig * 0.8), round(ib * 0.8));\n          else display.setPixel(x0 + q, LAB + r, 60, 60, 60);\n        }\n  }\n}\n","ishihara-plate":"// ===== Patternflow pattern =====\n// Title:   Ishihara Plate\n// Family:  type\n// Idea:    Two colour-vision plates stand one above the other, each a disc of about 370 dots on black, from single LEDs to 21-LED blots, where the dots inside a numeral differ from the dots around it only along a line of colours one kind of dichromat cannot tell apart, the protan line in the top plate and the deutan line in the bottom one; every 3 s a plate is repainted dot by dot and a new numeral comes up through the same dots, and turned towards a simulated protan or deutan eye the plate built on that eye's line loses its numeral into a field of yellow and blue.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: pseudo-isochromatic plates (Shinobu Ishihara, Tests for Colour-Blindness, 1917), dichromat simulation (Françoise Viénot, Hans Brettel and John Mollon, 1999), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Tint=0..1, Speed=0.2..3, Dichromacy=-1..1, Dots=0..1\n//\n// Knob 1: Tint. Adds the same blue to every dot, 0.55 of full in linear light at 1. At 0 the grounds are green and azure and the numerals yellow, amber, red and magenta; at 1 the greens turn teal, the yellows cream and the reds pink. Blue is kept by both simulations and added to figure and ground alike, so a numeral that vanishes still vanishes.\n// Knob 2: Speed. A plate holds its numeral 6 / Speed seconds, 3 s at the opening 2, with the bottom plate half a period behind the top; 30 s at 0.2 and 2 s at 3. When a new numeral comes, every dot of the plate draws a new colour and brightness and takes them at its own moment within the first quarter of the period (0.75 s at the opening), dimming to 15% for 0.1 s either side.\n// Knob 3: Dichromacy. 0 is normal vision; towards -1 the colours slide to what a protanope would see, towards +1 a deuteranope, mixed in linear light. At -1 the top numeral has exactly its ground's colours and is gone, while the bottom one is still there as darker olive dots; at +1 the bottom numeral is gone and the top one keeps a slightly brighter yellow that its blue dots mostly hide. At -0.5 the top numeral is half faded and the bottom one still reads.\n// Knob 4: Dots. Every dot's radius times 1 at 0 up to 1.9 at 1, in 13 steps, each a new deal of both plates. At 0 a plate holds about 220 single LEDs, 55 five-LED crosses, 36 three-by-three squares and 60 larger dots of 13 and 21 LEDs; at 1 about 270 dots, 200 of them still single LEDs and the rest 9 to 61 LEDs, and the numeral's strokes widen from 7.2 to 9.5 LEDs, about one big dot across, so the numeral starts to break up.\n\n// Shinobu Ishihara's plates hide a numeral in a disc of dots. The dots\n// inside it and the dots around it are drawn from colours a colour-normal\n// eye sees as different hues, red and orange against green, but that a\n// dichromat sees as the same, and their brightness is varied from dot to\n// dot so lightness gives nothing away. A protanope lacks the L cones and a\n// deuteranope the M cones, so two colours whose cone signals differ only in\n// L, or only in M, look alike to them: those differences are the protan and\n// deutan confusion lines.\n//\n// Here every dot draws a ground colour from a palette of five and a\n// brightness from 0.8 to 1 (in linear light). A dot inside the numeral\n// moves its colour along the plate's confusion line, the change of L alone\n// in the top plate and of M alone in the bottom one, until its red reaches\n// 0.95 or its green 0.02, so the greens turn yellow, amber or red and the\n// azures magenta. Figure and ground then differ in L alone, or in M alone,\n// and nowhere else.\n//\n// The simulation is the single-plane method of Viénot, Brettel and Mollon\n// (1999): convert to cone signals, rebuild the missing cone's signal from\n// the other two so that black, white and the blue primary keep their\n// colour, and convert back. A difference in L alone vanishes under the\n// protan rebuild, a difference in M alone under the deutan one, so at the\n// knob's end each numeral dot takes exactly the colour of a ground dot with\n// the same palette entry and brightness, and the two sets are drawn alike.\n// The cone matrix is the RGB-to-LMS matrix the common simulators use, and\n// the two rebuilds come out as L = 2.0234 M - 2.5258 S and\n// M = 0.4942 L + 1.2483 S.\n//\n// The dots are thrown at the disc on whole LEDs, largest first, and one\n// stays only if none of its LEDs touches another dot's side by side, so a\n// dark seam runs between every two and the plate is busy with small edges.\n\nconst W = 64, H = 128, R = 32;\nconst { floor, round, min, max, abs, sqrt, pow, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Linear RGB to cone signals L, M, S, and back.\nconst A = [17.8824, 43.5161, 4.11935, 3.45565, 27.1554, 3.86714, 0.0299566, 0.184309, 1.46709];\nfunction inv3(m) {\n  const [a, b, c, d, e, f, g, h, i] = m, x = e * i - f * h, y = f * g - d * i, z = d * h - e * g, det = a * x + b * y + c * z;\n  return [x / det, (c * h - b * i) / det, (b * f - c * e) / det, y / det, (a * i - c * g) / det, (c * d - a * f) / det, z / det, (b * g - a * h) / det, (a * e - b * d) / det];\n}\nconst AI = inv3(A);\nconst mul = (m, v) => [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];\n// The missing cone's signal rebuilt from the other two so that white and\n// the blue primary keep their colour.\nfunction plane(miss) {\n  const w = mul(A, [1, 1, 1]), b = mul(A, [0, 0, 1]), o = miss === 0 ? 1 : 0;\n  // u w[o] + v w[2] = w[miss], u b[o] + v b[2] = b[miss]\n  const det = w[o] * b[2] - w[2] * b[o];\n  return [(w[miss] * b[2] - w[2] * b[miss]) / det, (w[o] * b[miss] - w[miss] * b[o]) / det];\n}\nconst PROT = plane(0), DEUT = plane(1);\n// Confusion directions: a change of L alone (protan) or M alone (deutan).\nconst DL = mul(AI, [1, 0, 0]), DM = mul(AI, [0, -1, 0]);\n\nfunction simulate(c, kind, amt, o) {\n  if (amt \u003c= 0) {\n    o[0] = c[0], o[1] = c[1], o[2] = c[2];\n    return o;\n  }\n  const lms = mul(A, c);\n  if (kind \u003c 0) lms[0] = PROT[0] * lms[1] + PROT[1] * lms[2];\n  else lms[1] = DEUT[0] * lms[0] + DEUT[1] * lms[2];\n  const s = mul(AI, lms);\n  for (let k = 0; k \u003c 3; k++) o[k] = c[k] + (s[k] - c[k]) * amt;\n  return o;\n}\n\n// The ground colours of each plate in linear RGB, greens and azures. The\n// protan line raises red and barely lowers green, so the top plate's\n// greens turn yellow and amber; the deutan line takes 0.41 of green away\n// for each unit of red, so the bottom plate's turn red and orange.\nconst GROUND = [\n  [[0, 1, 0.005], [0, 0.5, 0.005], [0, 0.13, 1], [0, 0.75, 0.005], [0, 0.2, 1]],\n  [[0, 0.42, 0.005], [0, 0.6, 0.005], [0, 0.42, 1], [0, 0.45, 0.8], [0, 0.55, 0.005]],\n];\nconst FR = 0.95, DIP = 0.1;\n\n// Numerals as strokes in a 6 by 10 box, drawn for this pattern.\nconst arc = (cx, cy, rx, ry, a0, a1, n) => {\n  const o = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    o.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return o;\n};\nconst DIGITS = [\n  [arc(3, 5, 3, 5, 0, 360, 24)],\n  [[[1, 2.2], [3.2, 0], [3.2, 10]]],\n  [[...arc(3, 3, 3, 3, 195, 375, 10), [0, 10], [6, 10]]],\n  [[...arc(3, 2.6, 2.8, 2.6, 200, 450, 10), ...arc(3, 7.3, 3, 2.7, -90, 160, 10)]],\n  [[[4.4, 10], [4.4, 0], [0, 7], [6, 7]]],\n  [[[5.6, 0], [1, 0], [0.5, 4.3], ...arc(3, 6.8, 3, 3.2, -125, 150, 12)]],\n  [[...arc(3.5, 5.5, 2.8, 5.5, -55, -175, 7), ...arc(3, 7, 3, 3, 180, 540, 16)]],\n  [[[0, 0], [6, 0], [2.2, 10]]],\n  [arc(3, 2.5, 2.6, 2.5, 90, 450, 16), arc(3, 7.3, 3, 2.7, -90, 270, 18)],\n  [[...arc(3, 3, 3, 3, 0, 360, 16), ...arc(2.5, 4.5, 3.5, 5.5, 0, 100, 6)]],\n];\n\nfunction segDist(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const t = l ? cl(((px - ax) * dx + (py - ay) * dy) / l, 0, 1) : 0;\n  const x = ax + t * dx - px, y = ay + t * dy - py;\n  return sqrt(x * x + y * y);\n}\n\n// Is the point (x, y), relative to the plate's centre, inside digit d?\nfunction inDigit(d, x, y, hw) {\n  const sx = 5, sy = 4.5, ox = -3 * sx, oy = -5 * sy;\n  let best = 1e9;\n  for (const pl of DIGITS[d])\n    for (let i = 0; i + 1 \u003c pl.length; i++) {\n      const a = pl[i], b = pl[i + 1];\n      best = min(best, segDist(x, y, ox + a[0] * sx, oy + a[1] * sy, ox + b[0] * sx, oy + b[1] * sy));\n    }\n  return best \u003c= hw;\n}\n\nconst RADII = [2.3, 2.0, 1.5, 1.0, 1.0, 0.5];\nconst TRIES = [60, 200, 1500, 9000, 9000, 9000];\nfunction newPlate(cy, kind, sc) {\n  const own = new Int16Array(W * 64).fill(-1), dots = [];\n  for (let c = 0; c \u003c RADII.length; c++) {\n    const r = RADII[c] * sc, rr = r * r, ri = floor(r), cells = [];\n    for (let dy = -ri; dy \u003c= ri; dy++) for (let dx = -ri; dx \u003c= ri; dx++) if (dx * dx + dy * dy \u003c= rr) cells.push(dx, dy);\n    for (let k = 0; k \u003c TRIES[c]; k++) {\n      const cx = floor(Math.random() * 64), cyy = floor(Math.random() * 64);\n      let ok = true;\n      for (let i = 0; i \u003c cells.length && ok; i += 2) {\n        const x = cx + cells[i], y = cyy + cells[i + 1], ex = x + 0.5 - 32, ey = y + 0.5 - 32;\n        if (ex * ex + ey * ey > R * R) ok = false;\n        else\n          for (const [ax, ay] of NB) {\n            const u = x + ax, v = y + ay;\n            if (u >= 0 && u \u003c 64 && v >= 0 && v \u003c 64 && own[v * W + u] >= 0) {\n              ok = false;\n              break;\n            }\n          }\n      }\n      if (!ok) continue;\n      const n = dots.length;\n      for (let i = 0; i \u003c cells.length; i += 2) own[(cyy + cells[i + 1]) * W + cx + cells[i]] = n;\n      dots.push({ x: cx + 0.5 - 32, y: cyy + 0.5 - 32, now: [0, 0, 1], old: [0, 0, 1], at: 0 });\n    }\n  }\n  return { dots, own, cy, kind, digit: -1, clock: 0, hw: 3.6 + 1.3 * (sc - 1) };\n}\nconst NB = [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]];\n\n// A new numeral: every dot draws a new colour from the palette and a new\n// brightness, inside the numeral or not, and takes them at its own moment\n// in the first quarter of the period.\nfunction setNumeral(P, digit, spread) {\n  P.digit = digit;\n  for (const d of P.dots) {\n    const t = d.old;\n    d.old = d.now;\n    d.now = t;\n    t[0] = inDigit(digit, d.x, d.y, P.hw) ? 1 : 0;\n    t[1] = floor(Math.random() * 5);\n    t[2] = 0.8 + 0.2 * Math.random();\n    d.at = Math.random() * spread;\n  }\n  P.clock = 0;\n}\n\nexport function setup(params) {\n  params.s = { plates: null, size: -1, period: 3, tint: 0, dich: 0, c: [0, 0, 0], o: [0, 0, 0] };\n}\n\nfunction build(S, size) {\n  S.size = size;\n  const sc = 1 + 0.9 * size;\n  S.plates = [newPlate(0, -1, sc), newPlate(64, 1, sc)];\n  for (const P of S.plates) {\n    setNumeral(P, floor(Math.random() * 10), 0);\n    setNumeral(P, P.digit, 0);\n  }\n  S.plates[1].clock = -S.period / 2;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.tint = cl(k[0] || 0, 0, 1);\n  S.period = 6 / cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.dich = cl(k[2] || 0, -1, 1);\n  const size = floor(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 12.99) / 12;\n  if (size !== S.size) build(S, size);\n  for (const P of S.plates) {\n    P.clock += d;\n    if (P.clock >= S.period) {\n      let n = floor(Math.random() * 9);\n      if (n >= P.digit) n++;\n      setNumeral(P, n, min(0.8, S.period * 0.25));\n    }\n  }\n}\n\nconst toByte = (v) => round(255 * pow(cl(v, 0, 1), 1 / 2.2));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.plates) return;\n  const c = S.c, o = S.o, amt = abs(S.dich), kind = S.dich \u003c 0 ? -1 : 1;\n  for (const P of S.plates) {\n    const dir = P.kind \u003c 0 ? DL : DM, cols = [];\n    for (const d of P.dots) {\n      // A dot being repainted dims to 15% and comes back in its new colour.\n      const u = abs(P.clock - d.at) / DIP, [fig, gi, l0] = P.clock >= d.at ? d.now : d.old, g = GROUND[P.kind \u003c 0 ? 0 : 1][gi];\n      const lum = u \u003c 1 ? l0 * (0.15 + 0.85 * u * u) : l0;\n      // As far along the line as the red target, or as the green allows.\n      const t = fig ? min((FR - g[0]) / dir[0], (g[1] - 0.02) / -dir[1]) : 0;\n      c[0] = (g[0] + t * dir[0]) * lum;\n      c[1] = (g[1] + t * dir[1]) * lum;\n      c[2] = (g[2] + t * dir[2] + 0.55 * S.tint) * lum;\n      simulate(c, kind, amt, o);\n      cols.push(toByte(o[0]), toByte(o[1]), toByte(o[2]));\n    }\n    for (let y = 0; y \u003c 64; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const n = P.own[y * W + x];\n        if (n \u003c 0) display.setPixel(x, P.cy + y, 0, 0, 0);\n        else display.setPixel(x, P.cy + y, cols[n * 3], cols[n * 3 + 1], cols[n * 3 + 2]);\n      }\n  }\n}\n","rabi-chevron":"// ===== Patternflow pattern =====\n// Title:   Rabi Chevron\n// Family:  wave\n// Idea:    Every column is a two-level atom driven at its own detuning, every row a pulse length, and the brightness the chance of finding the atom excited, so Rabi's formula draws its chevron: on resonance in the middle the population swings all the way up and back four times down each sweep, while off resonance it swings faster and less deep, bending the fringes into nested V's that stream up the panel as the sweep of pulse lengths repeats.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rabi oscillations (Isidor Isaac Rabi, 1937), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Span=0..1, Damping=0..1\n//\n// Knob 1: Hue. Turns the colour ramp round the wheel. At 0 the ground state is deep indigo and the ramp climbs through teal and green to a pale yellow at full excitation, the way a physics plot would draw it; at 0.15 the ground turns violet and the top green, and at 0.5 the ramp runs from a dark brown through red and magenta to periwinkle.\n// Knob 2: Speed. How fast the sweep runs: 16 rows a second for each unit, so 32 at the opening 2. A row is a twentieth of the Rabi period on resonance, so the middle columns swing 1.6 times a second and the 80 rows of one sweep pass in 2.5 s; 3.2 rows a second at 0.2, 48 at 3.\n// Knob 3: Span. The detuning at the panel's left and right edges, from 2.5 times the Rabi frequency at 0 to 5 times at 1. At the opening 2.5 the edge columns swing 2.69 times as fast as the middle and only 14% of the way up; at 5, 5.1 times as fast and 4% of the way, and the chevron narrows to a spike.\n// Knob 4: Damping. Dephasing at the rate 0.6 Damping^2 times the Rabi frequency, which pulls each swing towards its mean. At the opening 0.06 a sweep keeps 95% of its depth to the end; at 0.3 the last fringes keep 26%, at 0.5 2%, and at 1 every column settles within one period to half its peak, so the panel shows the power-broadened Lorentzian line, a soft column 2 Rabi frequencies wide.\n\n// A two-level atom starts in its ground state and is driven by a field of\n// Rabi frequency Omega, detuned by Delta from the transition. Rabi worked\n// out in 1937, for a spin in a steady magnetic field with a weak second\n// field turning round it, that after a time t the chance of finding it\n// flipped is\n//\n//   P(Delta, t) = Omega^2 / (Omega^2 + Delta^2) sin^2(W t / 2),\n//   W = sqrt(Omega^2 + Delta^2).\n//\n// On resonance it swings all the way to 1 and back at Omega. Detuned, it\n// swings faster, at the generalised Rabi frequency W, and never higher than\n// Omega^2 / W^2, a Lorentzian in Delta. Plotted against detuning and pulse\n// length the fringes are the curves W t = 2 pi n, hyperbolas that sit flat\n// for short pulses and bend into ever deeper V's for long ones: the chevron\n// that experiments on qubits and trapped ions measure to find the resonance\n// and the length of a pi pulse.\n//\n// Here x is Delta, from -D to +D in units of Omega (D = 2.5 to 5 by Span),\n// and y is the pulse length, a sweep of 80 rows from Omega t = 0 to 8 pi\n// (four full swings on resonance). The sweeps follow one another down the\n// panel like the repeated scans of a real experiment, and the whole record\n// scrolls up, so every LED sees the fringes run past it: a new sweep comes\n// in at the bottom, dark for the shortest pulses, and the seam where the\n// last one ends and the next begins rises with it. The swing is damped by\n// exp(-gamma t) about its mean, P = A (1 - exp(-gamma t) cos W t) / 2, a\n// plain dephasing envelope rather than the full Bloch equations. Brightness\n// follows P^0.7 so the faint, fast fringes far off resonance still show.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// Rows to one Rabi period on resonance, and periods in one sweep.\nconst P0 = 20, NP = 4, LS = P0 * NP;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = { g: 0, hue: 0, speed: 2, D: 2.5, gam: 0, lut: new Uint8Array(257 * 3), lh: -1, c: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.D = 2.5 + 2.5 * cl(k[2] || 0, 0, 1);\n  const dm = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.gam = 0.6 * dm * dm;\n  S.g += d * S.speed * 16;\n  if (S.g > LS * 1000) S.g -= LS * 1000;\n}\n\nfunction ramp(S) {\n  if (S.lh === S.hue) return;\n  S.lh = S.hue;\n  for (let i = 0; i \u003c= 256; i++) {\n    const p = Math.pow(i / 256, 0.7);\n    hsv(S.hue + 0.66 - 0.5 * p, 0.95 - 0.35 * p * p, 0.13 + 0.87 * p, S.c);\n    S.lut[i * 3] = round(S.c[0] * 255);\n    S.lut[i * 3 + 1] = round(S.c[1] * 255);\n    S.lut[i * 3 + 2] = round(S.c[2] * 255);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const L = S.lut, D = S.D, gam = S.gam;\n  for (let y = 0; y \u003c H; y++) {\n    const g = y + S.g, ph = g - floor(g / LS) * LS, t = (ph / P0) * TAU, e = exp(-gam * t);\n    for (let x = 0; x \u003c W; x++) {\n      const dl = ((x - 31.5) / 32) * D, r2 = 1 + dl * dl, wr = sqrt(r2);\n      const P = (0.5 / r2) * (1 - e * cos(wr * t));\n      const i = round(P * 256) * 3;\n      display.setPixel(x, y, L[i], L[i + 1], L[i + 2]);\n    }\n  }\n}\n","simulated-annealing":"// ===== Patternflow pattern =====\n// Title:   Simulated Annealing\n// Family:  sim\n// Idea:    A closed tour through 80 random cities starts as a hot tangle of crossing lines that jumps every frame, and as the temperature falls under the Metropolis rule the crossings undo themselves, the inside of the loop (filled by the even-odd rule) closes into one region, and the tour settles into a ring that no longer crosses itself with its colours flowing round it, until the cities fly to new places and melt it again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: simulated annealing (Scott Kirkpatrick, C. Daniel Gelatt and Mario Vecchi, 1983) with the Metropolis rule (Nicholas Metropolis, Arianna Rosenbluth, Marshall Rosenbluth, Augusta Teller and Edward Teller, 1953), on the travelling salesman problem, pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cities=80..150, Floor=0..1\n//\n// Knob 1: Hue. Turns the loop's colours round the wheel. At 0 the tour runs from cyan through blue and violet to pink and back again, so the ring has no seam; at 0.5 it runs from red through orange and yellow to green.\n// Knob 2: Speed. Stretches the clock of the whole cycle. At 2 one cycle is 18 s: 0.8 s hot while the cities fly to their new places, 12 s of cooling and 5.2 s held at the floor, with 60,000 tries a second (2,000 a frame). At 0.2 everything is ten times slower, at 3 one and a half times faster, and a cycle always gets the same 1.08 million tries.\n// Knob 3: Cities. 80 to 150 cities. A new count scatters new cities and starts from a random tour at once. The city spacing, the square root of the area per city, is 9.4 LEDs for 80 and 6.9 for 150, and the temperatures are counted in it.\n// Knob 4: Floor. The temperature the cooling ends at and holds, 0.01 city spacings times 50 to the power of the knob: 0.013 at the opening 0.06, 0.07 at 0.5 and 0.5 at 1. Cooling always starts at 4 spacings. Up to about 0.5 the ring freezes with no crossings; at 1 it stays a warm liquid that keeps about 20 crossings of 80 cities and flickers as they come and go.\n\n// The travelling salesman wants the shortest closed tour through all the\n// cities. Kirkpatrick, Gelatt and Vecchi (Science, 1983) treated the tour's\n// length L as the energy of a physical system and cooled it: propose a\n// small change, and keep it by the rule of Metropolis and his coauthors\n// (1953), always if it makes the tour shorter and with probability\n// exp(-dL / T) if it makes it longer by dL. At a high temperature T almost\n// every change is kept and the tour is a random tangle. Cooled slowly, the\n// tour has time to find its way down, and cold it stops at a short tour\n// that no single change can shorten. Cooled at once (a quench), it freezes\n// in the first dent it meets: on the same 80 cities a 2-opt descent from a\n// random order ends 2.6% to 9.5% longer than this anneal, 6.6% on average.\n//\n// The change here is the 2-opt move (Shen Lin, 1965): cut two edges of the\n// tour, a-b and c-d, and join a-c and b-d, which reverses the path between\n// them.\n// If two edges cross, the move that uncrosses them always shortens the\n// tour (the two diagonals of a quadrilateral are longer than either pair of\n// its opposite sides), so a tour that no 2-opt move can shorten never\n// crosses itself, and the cold ring on the panel is a simple polygon.\n//\n// The picture shows that through the inside of the loop: each row is\n// filled between alternate crossings of the tour (the even-odd rule). A\n// tangled tour fills as a patchwork that flickers; once the tour stops\n// crossing itself the fill becomes one region with the loop as its edge,\n// a meander that interlocks with the outside. The loop is coloured by place\n// along the tour, so while it is tangled neighbouring colours are scattered\n// over the whole panel, and as it orders they sort into one gradient.\n// The line on row 125 is the temperature on a log scale from 0.01 to 4\n// city spacings, warm white when hot and pale blue when cold.\n\nconst W = 64, H = 128, NP = W * H;\nconst X0 = 2.5, X1 = 61.5, Y0 = 2.5, Y1 = 121.5, GY = 125;\nconst { floor, round, min, max, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Seconds at Speed 2.\nconst HOT = 0.8, CYCLE = 18, COOL = 12, TRIES = 60000;\nconst T0 = 4, T1 = 0.01, SPAN = 0.45;\n\nfunction hsv(h, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const v = i === 0 ? [1, f, 0] : i === 1 ? [1 - f, 1, 0] : i === 2 ? [0, 1, f] : i === 3 ? [0, 1 - f, 1] : i === 4 ? [f, 0, 1] : [1, 0, 1 - f];\n  o[k] = v[0];\n  o[k + 1] = v[1];\n  o[k + 2] = v[2];\n}\n\nfunction scatter(S, glide) {\n  const n = S.n;\n  for (let i = 0; i \u003c n; i++) {\n    S.ox[i] = glide ? S.x[i] : 0;\n    S.oy[i] = glide ? S.y[i] : 0;\n    S.tx[i] = X0 + Math.random() * (X1 - X0);\n    S.ty[i] = Y0 + Math.random() * (Y1 - Y0);\n    if (!glide) (S.x[i] = S.tx[i]), (S.y[i] = S.ty[i]);\n  }\n  S.glide = glide ? 0 : 1;\n}\n\nfunction start(S, n) {\n  S.n = n;\n  S.x = new Float32Array(n);\n  S.y = new Float32Array(n);\n  S.ox = new Float32Array(n);\n  S.oy = new Float32Array(n);\n  S.tx = new Float32Array(n);\n  S.ty = new Float32Array(n);\n  S.tour = new Int32Array(n);\n  for (let i = 0; i \u003c n; i++) S.tour[i] = i;\n  // A random order: the first tour is a tangle.\n  for (let i = n - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = S.tour[i];\n    S.tour[i] = S.tour[j];\n    S.tour[j] = t;\n  }\n  S.col = new Float32Array(n * 3);\n  S.unit = sqrt(((X1 - X0) * (Y1 - Y0)) / n);\n  scatter(S, false);\n  S.tc = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, hue: 0, rate: 1, floor: T1, tc: 0, phi: 0, T: T0, acc: new Float32Array(NP * 3), cur: new Float32Array(NP * 3),\n    bl: new Float32Array(NP * 3), tmp: new Float32Array(NP * 3), xs: new Float32Array(400), ca: [0, 0, 0], cb: [0, 0, 0],\n  };\n}\n\nfunction dist(S, a, b) {\n  const dx = S.x[a] - S.x[b], dy = S.y[a] - S.y[b];\n  return sqrt(dx * dx + dy * dy);\n}\n\n// Tries 2-opt reversals at temperature T (in pixels) by the Metropolis rule.\nfunction anneal(S, tries, T) {\n  const n = S.n, tour = S.tour, half = n >> 1;\n  for (let k = 0; k \u003c tries; k++) {\n    let i = floor(Math.random() * n), j = floor(Math.random() * n);\n    if (i > j) {\n      const t = i;\n      i = j;\n      j = t;\n    }\n    if (j - i \u003c 2 || (i === 0 && j === n - 1)) continue;\n    const a = tour[i], b = tour[i + 1], c = tour[j], d = tour[(j + 1) % n];\n    const dL = dist(S, a, c) + dist(S, b, d) - dist(S, a, b) - dist(S, c, d);\n    if (dL > 0 && Math.random() >= exp(-dL / T)) continue;\n    // Reverse positions i+1..j, or the rest of the ring if that is shorter:\n    // both give the same closed tour.\n    let lo = i + 1, hi = j, len = j - i;\n    if (len > half) (lo = j + 1), (hi = i + n), (len = n - len);\n    for (let s = 0; s \u003c len >> 1; s++) {\n      const p = (lo + s) % n, q = (hi - s) % n, t = tour[p];\n      tour[p] = tour[q];\n      tour[q] = t;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  const n = round(cl(k[2] == null ? 80 : k[2], 80, 150));\n  S.floor = T1 * Math.pow(50, cl(k[3] == null ? 0.06 : k[3], 0, 1));\n  if (n !== S.n) start(S, n);\n  const dc = d * S.rate;\n  S.tc += dc;\n  S.phi += dc / 12;\n  if (S.tc >= CYCLE) {\n    S.tc -= CYCLE;\n    scatter(S, true);\n  }\n  // The cities fly to their new places while the tour is hot.\n  if (S.glide \u003c 1) {\n    S.glide = min(1, S.glide + dc / HOT);\n    const e = S.glide * S.glide * (3 - 2 * S.glide);\n    for (let i = 0; i \u003c S.n; i++) {\n      S.x[i] = S.ox[i] + (S.tx[i] - S.ox[i]) * e;\n      S.y[i] = S.oy[i] + (S.ty[i] - S.oy[i]) * e;\n    }\n  }\n  const u = cl((S.tc - HOT) / COOL, 0, 1);\n  S.T = T0 * Math.pow(S.floor / T0, u) * S.unit;\n  anneal(S, round(TRIES * dc), S.T);\n}\n\n// Plots a line with two-pixel anti-aliasing, keeping the brighter colour.\nfunction line(S, x0, y0, x1, y1, ca, cb, lv) {\n  const cur = S.cur, dx = x1 - x0, dy = y1 - y0;\n  const steep = Math.abs(dy) > Math.abs(dx);\n  const len = steep ? Math.abs(dy) : Math.abs(dx);\n  const steps = max(1, Math.ceil(len));\n  for (let s = 0; s \u003c= steps; s++) {\n    const t = s / steps, x = x0 + dx * t - 0.5, y = y0 + dy * t - 0.5;\n    const r = (ca[0] + (cb[0] - ca[0]) * t) * lv, g = (ca[1] + (cb[1] - ca[1]) * t) * lv, b = (ca[2] + (cb[2] - ca[2]) * t) * lv;\n    let px, py, f, ox, oy;\n    if (steep) (py = round(y)), (px = floor(x)), (f = x - px), (ox = 1), (oy = 0);\n    else (px = round(x)), (py = floor(y)), (f = y - py), (ox = 0), (oy = 1);\n    for (let h = 0; h \u003c 2; h++) {\n      const qx = px + ox * h, qy = py + oy * h, w = h ? f : 1 - f;\n      if (qx \u003c 0 || qx >= W || qy \u003c 0 || qy >= H) continue;\n      const o = (qy * W + qx) * 3;\n      if (r * w > cur[o]) cur[o] = r * w;\n      if (g * w > cur[o + 1]) cur[o + 1] = g * w;\n      if (b * w > cur[o + 2]) cur[o + 2] = b * w;\n    }\n  }\n}\n\n// A box blur of radius R across and then down.\nfunction blur(src, dst, tmp) {\n  const R = 5, k = 1 / (2 * R + 1);\n  for (let y = 0; y \u003c H; y++)\n    for (let c = 0; c \u003c 3; c++) {\n      let sum = 0;\n      for (let x = -R; x \u003c= R; x++) if (x >= 0 && x \u003c W) sum += src[(y * W + x) * 3 + c];\n      for (let x = 0; x \u003c W; x++) {\n        tmp[(y * W + x) * 3 + c] = sum * k;\n        const xa = x - R, xb = x + R + 1;\n        if (xa >= 0) sum -= src[(y * W + xa) * 3 + c];\n        if (xb \u003c W) sum += src[(y * W + xb) * 3 + c];\n      }\n    }\n  for (let x = 0; x \u003c W; x++)\n    for (let c = 0; c \u003c 3; c++) {\n      let sum = 0;\n      for (let y = -R; y \u003c= R; y++) if (y >= 0 && y \u003c H) sum += tmp[(y * W + x) * 3 + c];\n      for (let y = 0; y \u003c H; y++) {\n        dst[(y * W + x) * 3 + c] = sum * k;\n        const ya = y - R, yb = y + R + 1;\n        if (ya >= 0) sum -= tmp[(ya * W + x) * 3 + c];\n        if (yb \u003c H) sum += tmp[(yb * W + x) * 3 + c];\n      }\n    }\n}\n\nconst FILL = 0.2;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const n = S.n, tour = S.tour, col = S.col, cur = S.cur, acc = S.acc, xs = S.xs;\n  const h0 = 0.47 + S.hue;\n  // Colour by place along the tour, there and back so the ring has no seam.\n  for (let p = 0; p \u003c n; p++) hsv(h0 + SPAN * (0.5 - 0.5 * cos(2 * PI * (p / n + S.phi))), col, p * 3);\n  cur.fill(0);\n  // The tour.\n  const ca = S.ca, cb = S.cb;\n  for (let p = 0; p \u003c n; p++) {\n    const q = p + 1 === n ? 0 : p + 1, a = tour[p], b = tour[q];\n    for (let c = 0; c \u003c 3; c++) (ca[c] = col[p * 3 + c]), (cb[c] = col[q * 3 + c]);\n    line(S, S.x[a], S.y[a], S.x[b], S.y[b], ca, cb, 0.85);\n  }\n  // The colour of the nearby loop, blurred, to fill the inside with.\n  blur(cur, S.bl, S.tmp);\n  const bl = S.bl;\n  // The inside of the loop, by the even-odd rule, row by row.\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5;\n    let m = 0;\n    for (let p = 0; p \u003c n; p++) {\n      const a = tour[p], b = tour[p + 1 === n ? 0 : p + 1];\n      const ya = S.y[a], yb = S.y[b];\n      if ((ya \u003c= yc && yc \u003c yb) || (yb \u003c= yc && yc \u003c ya)) {\n        const x = S.x[a] + ((yc - ya) * (S.x[b] - S.x[a])) / (yb - ya);\n        let q = m++;\n        while (q > 0 && xs[q - 1] > x) (xs[q] = xs[q - 1]), q--;\n        xs[q] = x;\n      }\n    }\n    for (let q = 0; q + 1 \u003c m; q += 2) {\n      const x0 = max(0, Math.ceil(xs[q] - 0.5)), x1 = min(W - 1, floor(xs[q + 1] - 0.5));\n      for (let x = x0; x \u003c= x1; x++) {\n        const o = (y * W + x) * 3, r = bl[o], g = bl[o + 1], b = bl[o + 2], top = max(r, g, b);\n        const f = top > 1e-4 ? FILL / top : 0;\n        cur[o] = max(cur[o], top > 1e-4 ? r * f : FILL * col[0]);\n        cur[o + 1] = max(cur[o + 1], top > 1e-4 ? g * f : FILL * col[1]);\n        cur[o + 2] = max(cur[o + 2], top > 1e-4 ? b * f : FILL * col[2]);\n      }\n    }\n  }\n  // The cities, pale versions of their colour.\n  for (let p = 0; p \u003c n; p++) {\n    const a = tour[p], x = floor(S.x[a]), y = floor(S.y[a]), o = (y * W + x) * 3;\n    for (let c = 0; c \u003c 3; c++) cur[o + c] = 0.55 + 0.45 * col[p * 3 + c];\n  }\n  // The temperature, on a log scale from T1 to T0 city spacings.\n  const hot = cl(log(S.T / S.unit / T1) / log(T0 / T1), 0, 1), g = hot * W;\n  for (let x = 0; x \u003c W; x++) {\n    const o = (GY * W + x) * 3, w = 0.8 * (x \u003c g ? 1 : x \u003c g + 1 ? g - x : 0);\n    cur[o] = max(cur[o], w * (0.45 + 0.55 * hot));\n    cur[o + 1] = max(cur[o + 1], w * (0.7 + 0.1 * hot));\n    cur[o + 2] = max(cur[o + 2], w * (1 - 0.45 * hot));\n  }\n  // A short afterglow while it is hot, so the tangle reads as a web.\n  const keep = 0.55 * hot;\n  for (let i = 0; i \u003c NP * 3; i++) acc[i] = acc[i] * keep + cur[i] * (1 - keep);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, round(acc[o] * 255)), min(255, round(acc[o + 1] * 255)), min(255, round(acc[o + 2] * 255)));\n    }\n}\n","sitnikov-problem":"// ===== Patternflow pattern =====\n// Title:   Sitnikov Problem\n// Family:  space\n// Idea:    Two equal stars swing round each other on ellipses in a plane seen edge-on across the middle of the panel, and 64 massless bodies on the axis through their centre, each drawn in a column of its own, are thrown up together at speeds a hair apart, so they rise and fall through the plane as one smooth wave that bends and then tears into scattered points, each colouring the plane under it with the number of whole turns the stars made between its last two crossings, Moser's symbol, until the next wave goes up; on circles the wave only winds into more crests and never tears.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sitnikov problem (Kirill Sitnikov, 1960), its symbolic dynamics (Jürgen Moser, Stable and Random Motions in Dynamical Systems, 1973), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ellipse=-1..1, Spread=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 a body that has not yet come back to the plane is cyan, and one whose last half swing took s whole turns of the stars is azure for 0, violet for 1, pink for 2, rose for 3, orange for 4 and lime for 5; at 0.5 the wave goes up red and the symbols run orange, lime and green.\n// Knob 2: Speed. Time runs at 2 units a second for each unit of the knob, so at 2 the stars go round once in 1.57 seconds (their period is 2 pi), at 0.2 once in 15.7 seconds and at 3 once in 1.05 seconds.\n// Knob 3: Ellipse. The eccentricity e of the stars' orbit, 0.3 (1 + Ellipse): 0 at -1, 0.3 at the opening 0, 0.6 at 1. At 0.3 each star swings between 0.35 and 0.65 from the centre, and a quarter of the opening wave has torn 4.7 seconds after it goes up, half of it by 8.4. At e = 0.15 a quarter has torn by 11.7 seconds and half by 15.7; at 0.6 by 6.4 and 7.8. At e = 0 the wave only winds into more and more crests and never tears in its 20 seconds, and each body's energy holds to 8 decimals.\n// Knob 4: Spread. How far apart the 64 launch speeds are, 0.005 to 0.305 of the escape speed 2, centred on 0.86 of it. At the opening 0.06 the speeds run from 1.697 to 1.743, so the wave goes up nearly flat. At 1 they run from 1.415 to 2.025 and the wave is steep from the start: its slow left end keeps a smooth arc, and its right end, at the escape speed and past it, runs off the top and is sent up again and again.\n// Buttons: K1 tap sends up a new wave the next time the stars are at r = 1/2, within one turn. A new wave also goes up by itself every 80 units of time (about 13 turns, 20 seconds at the opening Speed) and when Ellipse or Spread has rested 0.3 seconds at a new value.\n\n// Two stars of mass 1/2 each move on Kepler ellipses of eccentricity e about\n// their centre of mass, with G = 1, the semi-major axis of their relative\n// orbit 1 and so a period of 2 pi. Each is r(t) = (1 - e cos E) / 2 from the\n// centre, where E - e sin E = t (Kepler's equation, solved by Newton's\n// method each step). A third body of no mass on the line through the centre\n// at right angles to the plane feels both stars at the distance\n// sqrt(z^2 + r^2), and their pulls along the line add up to\n//\n//   z'' = -z / (z^2 + r(t)^2)^(3/2).\n//\n// Kirill Sitnikov used this set-up in 1960 to show that the three-body\n// problem has oscillatory motions, swings that go out further and further\n// and still come back. For e = 0, r = 1/2 is fixed, the energy\n// v^2 / 2 - 1 / sqrt(z^2 + 1/4) is conserved and every bounded body swings\n// periodically, the period growing with the amplitude. For e > 0 the pull\n// beats with the stars and energy changes at every pass through the plane.\n// Jürgen Moser (1973) counted s_k, the whole turns of the stars between the\n// k-th and (k+1)-th time a body crosses the plane, and showed that for\n// small e > 0 there is a whole number m such that every sequence of\n// s_k >= m, chosen like coin tosses, is the record of some orbit: the motion\n// is as random as any sequence of symbols.\n//\n// The picture: 64 bodies, one in each column, leave the plane together at\n// the moment the stars are r = 1/2 apart, so a launch speed of 2 is the\n// escape speed whatever e is. Their speeds rise from left to right by equal\n// steps, so they start as one curve. Height on the panel is\n// 62 tanh(z / 2.2) rows from the middle, so a body far out still shows near\n// the edge. A body is a small cross with a glow; neighbours within 4 rows of\n// each other are joined, and the joined curve leaves a fading trail, so a\n// body that has fallen out of step with both neighbours is a lone point. Its\n// colour is its last symbol s, and the plane edge-on, rows 63 and 64, shows\n// under each column the last symbol written there, flashing as it is\n// written. The two stars are drawn at their positions seen from the side,\n// 34 LEDs to a unit, the nearer one larger. A body moving out past z = 5\n// with positive energy has escaped and is sent up again from the plane.\n// RK4 takes steps of at most 0.03 r^(3/2), 0.01 at e = 0, so a body still\n// gets several steps across the plane at the stars' closest approach.\n\nconst W = 64, H = 128, N = W * H, MID = 63.5, NB = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, round, PI, atan2, tanh } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst P = { F0: 0.86, RATE: 2, CYCLE: 80, DECAY: 0.76, ZS: 2.2, ZOUT: 5, LINK: 4, BR: 1.8 };\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Eccentric anomaly of the primaries at time t: E - e sin E = t.\nfunction anomaly(t, e) {\n  const M = t - TAU * floor(t / TAU);\n  let E = M + (sin(M) >= 0 ? 0.85 : -0.85) * e;\n  for (let k = 0; k \u003c 8; k++) E -= (E - e * sin(E) - M) / (1 - e * cos(E));\n  return E;\n}\nconst radius = (t, e) => (1 - e * cos(anomaly(t, e))) / 2;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, since: 0, e: 0.3, sp: 0.023, hue: 0, speed: 2, pending: false,\n    z: new Float64Array(NB), v: new Float64Array(NB), f: new Float64Array(NB),\n    tc: new Float64Array(NB), sym: new Int8Array(NB),\n    yy: new Float64Array(NB),\n    acc: new Float32Array(N * 3), c: [0, 0, 0], want: [0.3, 0.023], rest: 0,\n    flash: new Float32Array(NB), btn: false,\n  };\n  const S = params.s;\n  S.t = PI / 2 - S.e;\n  launch(S);\n}\n\n// The wave leaves the plane when the primaries are half their mean\n// distance apart, r = 1/2, so the launch speed 2f is f of the escape speed\n// whatever e is.\nfunction launch(S) {\n  for (let i = 0; i \u003c NB; i++) {\n    S.f[i] = P.F0 + S.sp * (i / (NB - 1) - 0.5);\n    S.z[i] = 0;\n    S.v[i] = 2 * S.f[i];\n    S.tc[i] = S.t;\n    S.sym[i] = -1;\n  }\n  S.since = 0;\n  S.pending = false;\n}\n\nfunction relaunchOne(S, i) {\n  S.z[i] = 0;\n  S.v[i] = 2 * S.f[i];\n  S.tc[i] = S.t;\n  S.sym[i] = -1;\n}\n\nconst acc = (z, r) => -z / ((z * z + r * r) * sqrt(z * z + r * r));\n\nfunction step(S, h) {\n  const e = S.e, t = S.t, r0 = radius(t, e), r1 = radius(t + h / 2, e), r2 = radius(t + h, e);\n  const z = S.z, v = S.v;\n  for (let i = 0; i \u003c NB; i++) {\n    const Z = z[i], V = v[i];\n    const a1 = acc(Z, r0);\n    const z2 = Z + (h / 2) * V, v2 = V + (h / 2) * a1, a2 = acc(z2, r1);\n    const z3 = Z + (h / 2) * v2, v3 = V + (h / 2) * a2, a3 = acc(z3, r1);\n    const z4 = Z + h * v3, v4 = V + h * a3, a4 = acc(z4, r2);\n    const zn = Z + (h / 6) * (V + 2 * v2 + 2 * v3 + v4);\n    const vn = V + (h / 6) * (a1 + 2 * a2 + 2 * a3 + a4);\n    if ((Z \u003c 0 && zn >= 0) || (Z > 0 && zn \u003c= 0)) {\n      const tx = t + (h * abs(Z)) / max(1e-12, abs(Z) + abs(zn));\n      S.sym[i] = min(9, floor((tx - S.tc[i]) / TAU));\n      S.tc[i] = tx;\n      S.flash[i] = 1;\n    }\n    z[i] = zn;\n    v[i] = vn;\n  }\n  S.t += h;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const e = 0.3 * (1 + cl(k[2] || 0, -1, 1)), sp = 0.005 + 0.3 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  if (abs(e - S.want[0]) > 1e-6 || abs(sp - S.want[1]) > 1e-6) {\n    S.want = [e, sp];\n    S.rest = 0;\n  } else S.rest += d;\n  if ((abs(e - S.e) > 1e-6 || abs(sp - S.sp) > 1e-6) && (S.rest > 0.3 || S.since === 0)) {\n    S.e = e;\n    S.sp = sp;\n    S.t = PI / 2 - e;\n    launch(S);\n  }\n  const b = !!(input.btnPressed && input.btnPressed[0]);\n  if (b && !S.btn) S.pending = true;\n  S.btn = b;\n  for (let i = 0; i \u003c NB; i++) S.flash[i] *= 0.88;\n  let T = d * S.speed * P.RATE;\n  while (T > 1e-9) {\n    const r = radius(S.t, S.e);\n    let h = min(0.01, 0.03 * r * sqrt(r), T);\n    if (S.pending) {\n      // The next wave goes as the primaries come round to r = 1/2.\n      const ph = PI / 2 - S.e, nxt = ph + TAU * ceil((S.t - ph) / TAU + 1e-9);\n      if (S.t + h >= nxt) {\n        h = nxt - S.t;\n        if (h > 1e-9) step(S, h);\n        S.t = nxt;\n        T -= h;\n        launch(S);\n        continue;\n      }\n    }\n    step(S, h);\n    T -= h;\n  }\n  S.since += d * S.speed * P.RATE;\n  if (S.since > P.CYCLE) S.pending = true;\n  const r = radius(S.t, S.e);\n  for (let i = 0; i \u003c NB; i++) {\n    const z = S.z[i], vz = S.v[i];\n    // Past the edge of the panel, moving out with positive energy: gone.\n    if (abs(z) > P.ZOUT && z * vz > 0 && (vz * vz) / 2 - 1 / sqrt(z * z + r * r) > 0) relaunchOne(S, i);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const A = S.acc, c = S.c, y = S.yy;\n  for (let p = 0; p \u003c N * 3; p++) A[p] *= P.DECAY;\n  const put = (x, yy, r, g, b) => {\n    if (yy \u003c 0 || yy >= H || x \u003c 0 || x >= W) return;\n    const p = (yy * W + x) * 3;\n    if (A[p] \u003c r) A[p] = r;\n    if (A[p + 1] \u003c g) A[p + 1] = g;\n    if (A[p + 2] \u003c b) A[p + 2] = b;\n  };\n  for (let i = 0; i \u003c NB; i++) y[i] = MID - 62 * tanh(S.z[i] / P.ZS);\n  for (let i = 0; i \u003c NB; i++) {\n    const s = S.sym[i];\n    hsv(S.hue + 0.5 + (s \u003c 0 ? 0 : 0.12 * (s + 1)), 0.8, 1, c);\n    const R = P.BR, y0 = y[i];\n    if (y0 \u003c -R || y0 > H + R) continue;\n    // A body still in step with a neighbour leaves its glow behind; one on\n    // its own leaves only a short tail.\n    const linked = (i > 0 && abs(y0 - y[i - 1]) \u003c= P.LINK) || (i \u003c NB - 1 && abs(y0 - y[i + 1]) \u003c= P.LINK);\n    const g = linked ? 1 : 0.4;\n    for (let yy = floor(y0 - R); yy \u003c= ceil(y0 + R); yy++)\n      for (let x = i - 2; x \u003c= i + 2; x++) {\n        const q = ((x - i) * (x - i) + (yy - y0) * (yy - y0)) / (R * R);\n        if (q \u003c 1) {\n          const w = (0.6 - q * 0.45) * g;\n          put(x, yy, c[0] * w, c[1] * w, c[2] * w);\n        }\n      }\n    if (i \u003c NB - 1 && abs(y0 - y[i + 1]) \u003c= P.LINK) {\n      const m = (y0 + y[i + 1]) / 2;\n      for (let yy = round(min(y0, m)); yy \u003c= round(max(y0, m)); yy++) put(i, yy, c[0], c[1], c[2]);\n      for (let yy = round(min(y[i + 1], m)); yy \u003c= round(max(y[i + 1], m)); yy++) put(i + 1, yy, c[0], c[1], c[2]);\n    }\n  }\n  const E = anomaly(S.t, S.e), e = S.e;\n  const r = (1 - e * cos(E)) / 2;\n  const nu = 2 * atan2(sqrt(1 + e) * sin(E / 2), sqrt(1 - e) * cos(E / 2));\n  const px = [32 + 34 * r * cos(nu), 32 - 34 * r * cos(nu)], depth = [sin(nu), -sin(nu)];\n  for (let yy = 0; yy \u003c H; yy++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (yy * W + x) * 3;\n      let R = A[p], G = A[p + 1], B = A[p + 2];\n      if (yy === 63 || yy === 64) {\n        // The plane edge-on: under each body the last symbol it wrote.\n        const s = S.sym[x];\n        if (s \u003c 0) {\n          R = max(R, 0.12);\n          G = max(G, 0.12);\n          B = max(B, 0.16);\n        } else {\n          hsv(S.hue + 0.5 + 0.12 * (s + 1), 0.8, 0.3 + 0.7 * S.flash[x], c);\n          R = max(R, c[0]);\n          G = max(G, c[1]);\n          B = max(B, c[2]);\n        }\n      }\n      for (let j = 0; j \u003c 2; j++) {\n        const rad = 1.6 + 0.7 * depth[j], dx = x + 0.5 - px[j], dy = yy - MID;\n        const q = dx * dx + dy * dy;\n        if (q \u003c rad * rad) {\n          const w = 1 - (q / (rad * rad)) * 0.5;\n          R = max(R, w);\n          G = max(G, w * 0.92);\n          B = max(B, w * 0.75);\n        }\n      }\n      display.setPixel(x, yy, min(255, round(R * 255)), min(255, round(G * 255)), min(255, round(B * 255)));\n    }\n  for (let i = 0; i \u003c NB; i++) {\n    const yy = round(y[i]);\n    if (yy \u003c 0 || yy >= H) continue;\n    hsv(S.hue + 0.5 + (S.sym[i] \u003c 0 ? 0 : 0.12 * (S.sym[i] + 1)), 0.45, 1, c);\n    for (const [dx, dy] of [[0, -1], [0, 1], [-1, 0], [1, 0]]) {\n      const X = i + dx, Y = yy + dy;\n      if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) display.setPixel(X, Y, round(c[0] * 255), round(c[1] * 255), round(c[2] * 255));\n    }\n    display.setPixel(i, yy, 255, 255, 255);\n  }\n}\n","v-cut-letters":"// ===== Patternflow pattern =====\n// Title:   V-Cut Letters\n// Family:  type\n// Idea:    LVX stands up the panel in three Roman capitals cut into stone with a V chisel, each stroke a groove whose flat walls meet in a sharp line down its middle, and a low light walks round the stone so the walls flip between lit and shadowed one facet at a time while the uncut surface keeps one dim tone, and the letters are read only from how the light falls on the planes.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: V-cut letter carving of Roman inscriptions, with the roof of a polygon as its straight skeleton (Oswin Aichholzer, Franz Aurenhammer, David Alberts and Bernd Gärtner, 1995), pattern round 77\n// Round:   77\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wall=30..70, Light=0..1\n//\n// Knob 1: Hue. The colour of the light, with the sky's fill in the shaded walls opposite it on the wheel: at 0 a pale gold sun and navy shade on blue-grey stone; 0.25 green light and purple shade, 0.5 blue moonlight and amber shade on warm grey, 0.75 pink light and green shade.\n// Knob 2: Speed. How fast the light walks round the stone: at 2 one turn in 12 s, so a wall swings from its brightest to its darkest in 6 s; at 0.2 a turn takes 2 minutes, at 3 eight seconds.\n// Knob 3: Wall. How steep the chisel's walls stand, in degrees from the surface: 30 at the opening, a shallow cut, 2.9 LEDs deep under the 10 LED stems, where a light square across a stroke leaves the lower 28% of the lit wall in the lip's shadow; at 50 a V of 80 degrees between its walls, twice as deep; at 70 the groove is 13.7 LEDs deep, the lip shades 79% of the lit wall and the letters are mostly dark cuts with a bright edge.\n// Knob 4: Light. How high the light stands above the stone, from 15 degrees at 0 to 75 at 1: 18 at the opening 0.06, raking, lower than the 30 degree walls, so the wall turned away goes into shade; at 45 (0.5) that wall keeps a quarter of the light; at 75, steeper than any wall the knob allows, the lip throws no shadow, and with the opening's 30 degree walls both sides of a groove stay lit and the letters go pale.\n\n// A letter cut with a V chisel is a groove whose two walls are planes that\n// slope down from the outline at the same angle and meet along a line. For\n// a stroke whose outline is a convex polygon, the depth under a point is\n// the slope times its distance to the nearest edge of the outline: every\n// edge carries one plane, and two planes meet where a point is equally far\n// from two edges. Those meeting lines are the straight skeleton of the\n// polygon, which Aichholzer, Aurenhammer, Alberts and Gärtner defined in\n// 1995 by moving every edge inward at the same speed; lifted, it is a roof\n// whose planes all slope at one angle. For a convex outline it is the same\n// as the medial axis. A long stroke has a sharp line down its middle and a\n// hip at each end, and in a triangular serif three facets meet at one\n// deepest point. Where two strokes cross, the chisel takes away both, so\n// the deeper cut wins.\n//\n// Each LED is four samples. A sample inside a stroke takes the normal of\n// the plane of its nearest edge; the light, at a fixed height and walking\n// round, lights it by Lambert's cosine, and the sky gives the shaded walls a\n// little of the opposite colour. The light is then followed from the LED's\n// centre across the depth field toward the lamp: where the stone in between\n// stands higher than the ray, the lip of the groove casts its shadow. The\n// uncut stone is not lit by the moving light at all, so the letters are\n// only what the facets do.\n//\n// The capitals are polygons drawn for this pattern, after the Roman\n// inscriptional capital: thick strokes down and down to the right, thin\n// ones across and down to the left, a pointed V that dips a row below the\n// line, and wedge serifs cut shallower than the stems. In Roman\n// inscriptions U is V, so the word is LVX, light.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, tan, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst RAD = PI / 180;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Where line ab meets line cd.\nfunction meet(a, b, c, d) {\n  const r = [b[0] - a[0], b[1] - a[1]], s = [d[0] - c[0], d[1] - c[1]];\n  const t = ((c[0] - a[0]) * s[1] - (c[1] - a[1]) * s[0]) / (r[0] * s[1] - r[1] * s[0]);\n  return [a[0] + t * r[0], a[1] + t * r[1]];\n}\n// A slanted stroke as a parallelogram from top centre to bottom centre,\n// cut level at both ends, w LEDs wide across.\nfunction bar(xa, ya, xb, yb, w) {\n  const hw = ((w / 2) * Math.hypot(xb - xa, yb - ya)) / Math.abs(yb - ya);\n  return [[xa - hw, ya], [xa + hw, ya], [xb + hw, yb], [xb - hw, yb]];\n}\n\n// The letters in a box 39 LEDs tall, y down from the cap line.\nconst L = [\n  [[10, 0], [20, 0], [20, 38], [10, 38]],\n  [[4, 0], [26, 0], [21, 4], [9, 4]],\n  [[10, 32], [48, 32], [48, 38], [10, 38]],\n  [[41, 32], [50, 24], [50, 38], [41, 38]],\n  [[3, 38], [10, 33], [10, 38]],\n];\nconst vOL = [4, 0], vIL = [15, 0], vOR = [50, 0], vIR = [43, 0], vA = [27, 39];\nconst vIL2 = [vIL[0] + vA[0] - vOL[0], vIL[1] + vA[1]], vIR2 = [vIR[0] + vA[0] - vOR[0], vIR[1] + vA[1]];\nconst V = [\n  [vOL, vIL, meet(vIL, vIL2, vOR, vA), vA],\n  [vIR, vOR, vA, meet(vIR, vIR2, vOL, vA)],\n  [[-1, 0], [21, 0], [18, 4], [6, 4]],\n  [[38, 0], [55, 0], [48, 4], [40, 4]],\n];\nconst X = [\n  bar(10, 0, 44, 38, 10),\n  bar(40, 0, 12, 38, 6),\n  [[0, 0], [21, 0], [19, 4], [8, 4]],\n  [[31, 0], [47, 0], [41, 4], [33.5, 4]],\n  [[11.5, 34], [18.5, 34], [23, 38], [4, 38]],\n  [[35, 34], [46, 34], [55, 38], [31, 38]],\n];\nconst WORD = [[L, 3], [V, 45], [X, 87]];\n\n// Every polygon as its edges: a point and the inward unit normal.\nfunction build() {\n  const polys = [];\n  for (const [letter, top] of WORD) {\n    let x0 = 1e9, x1 = -1e9;\n    for (const p of letter) for (const q of p) (x0 = min(x0, q[0])), (x1 = max(x1, q[0]));\n    const dx = 31.5 - (x0 + x1) / 2;\n    for (const p of letter) {\n      const pts = p.map((q) => [q[0] + dx, q[1] + top]);\n      let cx = 0, cy = 0;\n      for (const q of pts) (cx += q[0] / pts.length), (cy += q[1] / pts.length);\n      const edges = [];\n      let bx0 = 1e9, bx1 = -1e9, by0 = 1e9, by1 = -1e9;\n      for (let i = 0; i \u003c pts.length; i++) {\n        const a = pts[i], b = pts[(i + 1) % pts.length];\n        let nx = a[1] - b[1], ny = b[0] - a[0];\n        const l = Math.hypot(nx, ny);\n        (nx /= l), (ny /= l);\n        if (nx * (cx - a[0]) + ny * (cy - a[1]) \u003c 0) (nx = -nx), (ny = -ny);\n        edges.push([a[0], a[1], nx, ny]);\n        (bx0 = min(bx0, a[0])), (bx1 = max(bx1, a[0])), (by0 = min(by0, a[1])), (by1 = max(by1, a[1]));\n      }\n      polys.push({ edges, bx0, bx1, by0, by1 });\n    }\n  }\n  return polys;\n}\n\n// Distance in from the outline at (x, y) and the inward normal of the\n// nearest edge, the deepest stroke winning; 0 outside every stroke.\nfunction sample(polys, x, y, out) {\n  let best = 0, nx = 0, ny = 0;\n  for (const P of polys) {\n    if (x \u003c P.bx0 || x > P.bx1 || y \u003c P.by0 || y > P.by1) continue;\n    let d = 1e9, ex = 0, ey = 0;\n    for (const e of P.edges) {\n      const v = (x - e[0]) * e[2] + (y - e[1]) * e[3];\n      if (v \u003c d) (d = v), (ex = e[2]), (ey = e[3]);\n    }\n    if (d > best) (best = d), (nx = ex), (ny = ey);\n  }\n  out[0] = best;\n  out[1] = nx;\n  out[2] = ny;\n}\n\nconst SUB = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]];\n\nexport function setup(params) {\n  const polys = build(), n = W * H, o = [0, 0, 0];\n  const sd = new Float32Array(n * 4), sx = new Float32Array(n * 4), sy = new Float32Array(n * 4), dc = new Float32Array(n);\n  const grain = new Float32Array(n);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      for (let k = 0; k \u003c 4; k++) {\n        sample(polys, x + SUB[k][0], y + SUB[k][1], o);\n        sd[p * 4 + k] = o[0];\n        sx[p * 4 + k] = o[1];\n        sy[p * 4 + k] = o[2];\n      }\n      sample(polys, x + 0.5, y + 0.5, o);\n      dc[p] = o[0];\n      // A fixed grain in the stone, a few percent either way.\n      let h = (x * 374761393 + y * 668265263) | 0;\n      h = Math.imul(h ^ (h >>> 13), 1274126177);\n      grain[p] = 0.94 + 0.12 * (((h ^ (h >>> 16)) >>> 0) / 4294967296);\n    }\n  params.s = { sd, sx, sy, dc, grain, phi: 2.2, hue: 0, wall: 30, elev: 18, lc: [0, 0, 0], kc: [0, 0, 0], fc: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 30, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.wall = cl(k[2] == null ? 30 : k[2], 30, 70);\n  S.elev = 15 + 60 * cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  S.phi += (d * 2 * PI * speed) / 24;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { sd, sx, sy, dc, grain, lc, kc, fc } = S;\n  const sl = tan(S.wall * RAD), th = S.elev * RAD, ct = cos(th), st = sin(th), tt = st / ct, nrm = 1 / sqrt(1 + sl * sl);\n  const lx = cos(S.phi), ly = sin(S.phi);\n  // The light's colour, the sky's fill and the uncut stone's tone.\n  hsv(0.12 + S.hue, 0.46, 1.1, lc);\n  hsv(0.62 + S.hue, 0.65, 0.13, kc);\n  hsv(0.62 + S.hue, 0.16, 0.26, fc);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, g = grain[p];\n      // The lip's shadow, followed from the centre toward the light.\n      let shade = 1;\n      const D = sl * dc[p];\n      if (D > 0) {\n        let m = 1e9;\n        for (let j = 1; j \u003c 40; j++) {\n          const rise = j * 0.75 * tt;\n          if (rise > D + 0.6) break;\n          const qx = x + 0.5 + lx * j * 0.75, qy = y + 0.5 + ly * j * 0.75;\n          const ix = floor(qx), iy = floor(qy);\n          const dq = ix \u003c 0 || ix >= W || iy \u003c 0 || iy >= H ? 0 : sl * dc[iy * W + ix];\n          m = min(m, rise - (D - dq));\n        }\n        shade = cl(0.5 + m / 1.2, 0, 1);\n      }\n      let r = 0, gg = 0, b = 0;\n      for (let k = 0; k \u003c 4; k++) {\n        const i = p * 4 + k;\n        if (sd[i] \u003c= 0) {\n          r += fc[0];\n          gg += fc[1];\n          b += fc[2];\n          continue;\n        }\n        const nl = max(0, (sl * ct * (sx[i] * lx + sy[i] * ly) + st) * nrm) * shade;\n        r += lc[0] * nl + kc[0];\n        gg += lc[1] * nl + kc[1];\n        b += lc[2] * nl + kc[2];\n      }\n      const f = (255 / 4) * g;\n      display.setPixel(x, y, min(255, floor(r * f)), min(255, floor(gg * f)), min(255, floor(b * f)));\n    }\n}\n","anagram":"// ===== Patternflow pattern =====\n// Title:   Anagram\n// Family:  type\n// Idea:    A word stands down one side of the tall panel a letter to a band, LISTEN from top to bottom, and its letters, each in a colour of its own, glide across to the other side along S-shaped paths to their places in the next word of the set, SILENT, leaving their paths drawn behind them and a faint copy of the old word where they set out, so that every pair of letters whose order the new word reverses crosses once, a white spark marks each crossing as it happens and a counter at the top counts them to the number of inversions between the two words, 5 from LISTEN to SILENT and 9 on to ENLIST.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: anagrams; the number of inversions between two orderings as a distance (Maurice Kendall, A New Measure of Rank Correlation, Biometrika, 1938); the 5 by 7 capitals and figures of Photon Disk (pattern round 70), copied from autogram.js and redrawn as strokes through their dots so they scale; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Set=0..7, Weight=0..1\n//\n// Knob 1: Hue. Turns every letter's colour round the wheel together. The letters of a set's first word are spread evenly round the wheel at 75% saturation, starting from orange at 0: in LISTEN the L is orange, the I yellow-green, the S green, the T sky blue, the E violet and the N pink.\n// Knob 2: Speed. At 2 a word holds for 1.8 s and the letters take 2.4 s to cross, 4.2 s a word; at 0.2 a word takes 42 s and at 3 2.8 s.\n// Knob 3: Set. Which anagrams: 0 LISTEN SILENT ENLIST TINSEL INLETS, 1 STARE TEARS RATES ASTER, 2 EVIL VILE LIVE VEIL, 3 SPOT STOP POTS TOPS POST OPTS, 4 LEAST SLATE STEAL TALES STALE, 5 HEART EARTH HATER, 6 PETAL PLATE PLEAT LEAPT, 7 RETAINS RETINAS NASTIER STEARIN. The letters grow to fill their bands: 4 LEDs between dots for four letters, 2.7 for six, 2.3 for seven. The crossings per step run from 1 (VEIL to EVIL) to 17 (RETINAS to NASTIER, of the 21 possible).\n// Knob 4: Weight. The stroke through the dots: 0.68 of the dot pitch wide at 0 (1.9 LEDs in LISTEN), 1.52 at 1 (4.2 LEDs), where the dots of a letter run together into a heavy face and the bars of an E nearly close up.\n\n// Two letters cross between word A and word B exactly when B puts them in\n// the other order, because every letter moves on the same clock: its height\n// is y0 + (y1 - y0) e(s), with one e for all, so the gap between two letters\n// is a straight line in e and changes sign once or not at all. The crossings\n// of one step are the inversions of the permutation from A to B, Kendall's\n// distance between the two orderings; the most there can be is n(n-1)/2,\n// when B is A backwards. Where k paths pass through one point, as the L, I\n// and S of LISTEN do on the way to SILENT, that point is k(k-1)/2 crossings\n// and the counter jumps by that many at once.\n\nconst W = 64, H = 128, TOP = 1, BOT = 127;\nconst { floor, round, min, max, sqrt, exp, sin, asin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => u * u * (3 - 2 * u);\n// The inverse of smooth on 0..1.\nconst unsmooth = (e) => 0.5 - sin(asin(1 - 2 * e) / 3);\nconst T_MOVE = 2.4, T_HOLD = 1.8, HUE0 = 0.07;\n\n// Every set is spelt with letters that differ, so each letter is one thing\n// with one path.\nconst SETS = [\n  [\"LISTEN\", \"SILENT\", \"ENLIST\", \"TINSEL\", \"INLETS\"],\n  [\"STARE\", \"TEARS\", \"RATES\", \"ASTER\"],\n  [\"EVIL\", \"VILE\", \"LIVE\", \"VEIL\"],\n  [\"SPOT\", \"STOP\", \"POTS\", \"TOPS\", \"POST\", \"OPTS\"],\n  [\"LEAST\", \"SLATE\", \"STEAL\", \"TALES\", \"STALE\"],\n  [\"HEART\", \"EARTH\", \"HATER\"],\n  [\"PETAL\", \"PLATE\", \"PLEAT\", \"LEAPT\"],\n  [\"RETAINS\", \"RETINAS\", \"NASTIER\", \"STEARIN\"],\n];\n\n// Photon Disk's 5 x 7 face, the letters these words need and the figures,\n// rows from the top (copied from autogram.js).\nconst G57 = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", E: \"##### #.... #.... ####. #.... #.... #####\",\n  H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  L: \"#.... #.... #.... #.... #.... #.... #####\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\",\n  O: \".###. #...# #...# #...# #...# #...# .###.\", P: \"####. #...# #...# ####. #.... #.... #....\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\", S: \".#### #.... #.... .###. ....# ....# ####.\",\n  T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", V: \"#...# #...# #...# #...# #...# .#.#. ..#..\",\n  0: \".###. #...# #..## #.#.# ##..# #...# .###.\", 1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  2: \".###. #...# ....# ...#. ..#.. .#... #####\", 3: \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\",\n  6: \"..##. .#... #.... ####. #...# #...# .###.\", 7: \"##### ....# ...#. ..#.. .#... .#... .#...\",\n  8: \".###. #...# #...# .###. #...# #...# .###.\", 9: \".###. #...# #...# .#### ....# ...#. .##..\",\n};\nfor (const k in G57) G57[k] = G57[k].replace(/ /g, \"\");\n\n// A letter as strokes through its dots: runs along a row or a column, and a\n// diagonal step where two dots touch only at a corner. A dot with no\n// neighbour is a stroke of no length.\nconst STROKES = {};\nfor (const k of \"AEHILNOPRSTV\") {\n  const g = G57[k], on = (x, y) => x >= 0 && x \u003c 5 && y >= 0 && y \u003c 7 && g[y * 5 + x] === \"#\", s = [], used = new Set();\n  for (let y = 0; y \u003c 7; y++)\n    for (let x = 0; x \u003c 5; x++) {\n      if (!on(x, y)) continue;\n      if (on(x + 1, y) && !on(x - 1, y)) {\n        let e = x;\n        while (on(e + 1, y)) e++;\n        s.push([x, y, e, y]);\n        for (let q = x; q \u003c= e; q++) used.add(q + \",\" + y);\n      }\n      if (on(x, y + 1) && !on(x, y - 1)) {\n        let e = y;\n        while (on(x, e + 1)) e++;\n        s.push([x, y, x, e]);\n        for (let q = y; q \u003c= e; q++) used.add(x + \",\" + q);\n      }\n      for (const dx of [-1, 1])\n        if (on(x + dx, y + 1) && !on(x + dx, y) && !on(x, y + 1)) s.push([x, y, x + dx, y + 1]), used.add(x + \",\" + y), used.add(x + dx + \",\" + (y + 1));\n    }\n  for (let y = 0; y \u003c 7; y++) for (let x = 0; x \u003c 5; x++) if (on(x, y) && !used.has(x + \",\" + y)) s.push([x, y, x, y]);\n  STROKES[k] = s;\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The layout of a set: n bands, the dot pitch, the two columns.\nfunction begin(S, set) {\n  const words = SETS[set], n = words[0].length, bh = (BOT - TOP) / n;\n  const c = min(4.1, (bh - 3.5) / 6.4), xl = 2.5 + 2.6 * c;\n  Object.assign(S, { set, words, n, bh, c, xl, xr: W - xl, wi: 0, side: 0, phase: 0, pt: 0, s: 0, move: null, last: null, fade: 0, count: 0 });\n  S.letters = [...words[0]];\n  S.col = S.letters.map(() => [0, 0, 0]);\n  S.at = S.letters.map((_, i) => i);\n}\nconst bandY = (S, b) => TOP + (b + 0.5) * S.bh;\nconst sideX = (S, side) => (side ? S.xr : S.xl);\n\n// The step from the word on show to the next: where each letter goes and\n// where on its way it crosses another.\nfunction plan(S) {\n  const B = S.words[(S.wi + 1) % S.words.length], to = S.letters.map((ch) => B.indexOf(ch));\n  const from = S.at.slice(), xa = sideX(S, S.side), xb = sideX(S, 1 - S.side), cross = [];\n  for (let i = 0; i \u003c S.n; i++)\n    for (let j = i + 1; j \u003c S.n; j++) {\n      const d0 = from[i] - from[j], d1 = to[i] - to[j];\n      if (d0 * d1 >= 0) continue;\n      const e = d0 / (d0 - d1), s = unsmooth(e);\n      cross.push({ s, i, j, x: xa + (xb - xa) * s, y: bandY(S, from[i]) + (to[i] - from[i]) * S.bh * e, at: -1 });\n    }\n  cross.sort((a, b) => a.s - b.s);\n  return { from, to, xa, xb, cross };\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, hw: 1, set: -1, buf: new Float32Array(W * H * 3), t: 0 };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const set = cl(round(k[2] || 0), 0, SETS.length - 1);\n  if (set !== S.set) {\n    const first = S.set \u003c 0;\n    begin(S, set);\n    // The Lab opens with the letters already a third of the way across.\n    if (first) (S.phase = 1), (S.move = plan(S)), (S.pt = 0.36 * T_MOVE * (2 / S.speed));\n  }\n  S.hw = S.c * (0.34 + 0.42 * cl(k[3] || 0, 0, 1));\n  for (let i = 0; i \u003c S.n; i++) hsv(S.hue + HUE0 + i / S.n, 0.75, 1, S.col[i]);\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  if (S.phase === 0 && S.pt >= T_HOLD * sc) {\n    S.phase = 1;\n    S.pt = 0;\n    S.last = S.move;\n    S.move = plan(S);\n  }\n  if (S.phase === 1) {\n    S.s = smooth(cl(S.pt / (T_MOVE * sc), 0, 1));\n    S.fade = cl(1 - S.pt / (0.45 * T_MOVE * sc), 0, 1);\n    let n = 0;\n    for (const x of S.move.cross) if (S.s >= x.s) (n++), x.at \u003c 0 && (x.at = S.t);\n    S.count = n;\n    if (S.pt >= T_MOVE * sc) {\n      S.phase = 0;\n      S.pt = 0;\n      S.s = 1;\n      S.at = S.move.to.slice();\n      S.side = 1 - S.side;\n      S.wi = (S.wi + 1) % S.words.length;\n    }\n  }\n}\n\n// A stroke of half-width hw lit at a, with a glow round it; the brighter\n// of what is there and what it brings wins, channel by channel.\nfunction seg(S, x0, y0, x1, y1, hw, c, a, glow) {\n  const R = hw + (glow ? 4 : 1.5), b = S.buf, dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  const ax = max(0, floor(min(x0, x1) - R)), bx = min(W - 1, floor(max(x0, x1) + R));\n  const ay = max(0, floor(min(y0, y1) - R)), by = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = l2 > 0 ? cl((px * dx + py * dy) / l2, 0, 1) : 0;\n      const dd = sqrt((px - u * dx) ** 2 + (py - u * dy) ** 2) - hw;\n      let v = dd \u003c -0.5 ? 1 : dd \u003c 0.5 ? 0.5 - dd : 0;\n      if (glow) v += glow * exp(-max(0, dd) / 1.3);\n      v *= a;\n      if (v \u003c= 0.004) continue;\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) b[kk + q] = max(b[kk + q], c[q] * min(1, v));\n    }\n}\n\nfunction letter(S, ch, cx, cy, c, a) {\n  const p = S.c;\n  for (const s of STROKES[ch]) seg(S, cx + (s[0] - 2) * p, cy + (s[1] - 3) * p, cx + (s[2] - 2) * p, cy + (s[3] - 3) * p, S.hw, c, a, 0.18);\n}\n\n// Letter i's place on the step m at progress s.\nfunction where(S, m, i, s) {\n  return [m.xa + (m.xb - m.xa) * s, bandY(S, m.from[i]) + (m.to[i] - m.from[i]) * S.bh * smooth(s)];\n}\n\n// The paths of a step up to progress s, lit at a.\nfunction paths(S, m, s, a) {\n  const steps = 48;\n  for (let i = 0; i \u003c S.n; i++) {\n    let [px, py] = where(S, m, i, 0);\n    for (let k = 1; k \u003c= steps; k++) {\n      const u = (k / steps) * s;\n      if (u \u003c= 0) break;\n      const [x, y] = where(S, m, i, u);\n      seg(S, px, py, x, y, 0.45, S.col[i], a, 0);\n      (px = x), (py = y);\n    }\n  }\n}\n\n// The word a step set out from, faint where it stood.\nfunction ghost(S, m, a) {\n  for (let i = 0; i \u003c S.n; i++) letter(S, S.letters[i], m.xa, bandY(S, m.from[i]), S.col[i], a);\n}\n\nfunction sparks(S, m, a, now) {\n  const white = [1, 1, 1];\n  for (const x of m.cross) {\n    if (x.at \u003c 0) continue;\n    const age = now - x.at, f = exp(-age / 0.35);\n    seg(S, x.x, x.y, x.x, x.y, 0.7 + 1.6 * f, white, a * (0.75 + 0.25 * f), 0.5 * f);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.letters) return;\n  const b = S.buf;\n  for (let i = 0; i \u003c W * H; i++) (b[i * 3] = 0.01), (b[i * 3 + 1] = 0.008), (b[i * 3 + 2] = 0.02);\n  // The step before, fading as the letters set out again: its paths, its\n  // sparks and the faint copy of the word it left.\n  if (S.last && S.phase === 1 && S.fade > 0) {\n    paths(S, S.last, 1, 0.55 * S.fade);\n    sparks(S, S.last, 0.8 * S.fade, S.t + 9);\n    ghost(S, S.last, 0.22 * S.fade);\n  }\n  if (S.move) {\n    paths(S, S.move, S.phase === 1 ? S.s : 1, 0.55);\n    ghost(S, S.move, 0.22);\n  }\n  if (S.move) sparks(S, S.move, 1, S.t);\n  // The letters themselves.\n  for (let i = 0; i \u003c S.n; i++) {\n    let x, y;\n    if (S.phase === 1) [x, y] = where(S, S.move, i, S.s);\n    else (x = sideX(S, S.side)), (y = bandY(S, S.at[i]));\n    letter(S, S.letters[i], x, y, S.col[i], 1);\n  }\n  // The count of crossings so far, at the top between the columns, on a\n  // dark patch so the letters passing under it do not hide it.\n  const num = String(S.phase === 1 ? S.count : S.move ? S.move.cross.length : 0);\n  const x0 = round(W / 2 - (num.length * 6 - 1) / 2), y0 = 2;\n  for (let y = y0 - 1; y \u003c= y0 + 7; y++)\n    for (let x = x0 - 1; x \u003c= x0 + num.length * 6 - 1; x++) {\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) b[kk + q] *= 0.25;\n    }\n  for (let n = 0; n \u003c num.length; n++) {\n    const g = G57[num[n]];\n    for (let r = 0; r \u003c 7; r++)\n      for (let q = 0; q \u003c 5; q++) if (g[r * 5 + q] === \"#\") {\n        const kk = ((y0 + r) * W + x0 + n * 6 + q) * 3;\n        b[kk] = b[kk + 1] = b[kk + 2] = 0.95;\n      }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(b[kk], 0, 1) * 255), round(cl(b[kk + 1], 0, 1) * 255), round(cl(b[kk + 2], 0, 1) * 255));\n    }\n}\n","beatty-rhythm":"// ===== Patternflow pattern =====\n// Title:   Beatty Rhythm\n// Family:  rhythm\n// Idea:    Two voices play a score of ticks that falls down the panel, voice A on every tick floor(k alpha) and voice B on every tick floor(k beta) with 1/alpha + 1/beta = 1, in two lanes side by side where each tick fills as it reaches the playhead, and beside them the reason stands as a picture, the square lattice cut along the line of slope alpha - 1 with its lines x = i in A's colour and y = j in B's, which the line crosses exactly once in every tick, filling each cell it enters in the colour of the line it crossed, until a fraction for alpha sends the line through a lattice point, where both voices strike at once and the tick before goes unstruck.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Beatty's theorem (Samuel Beatty, 1926; Lord Rayleigh, 1894), pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Alpha=0..1, Ticks=0..1\n//\n// Knob 1: Hue. Turns the two voices round the wheel together, always opposite and at full strength. At 0 voice A is magenta and voice B green; at 1/6 red and cyan, at 0.25 orange and azure, at 0.5 the opening pair swapped.\n// Knob 2: Speed. Ticks a second, 1.5 for each unit: 3 at the opening 2, so the score falls 15 LEDs a second at 5 rows a tick; 0.3 ticks a second at 0.2 and 4.5 at 3.\n// Knob 3: Alpha. Eight stations, an eighth of the knob each: the golden ratio 1.618 (beta = 2.618, A strikes 61.8% of the ticks), then 8/5, the square root of 2 (beta = 3.414), 7/5, e - 1 = 1.718 (beta = 2.392), 12/7, pi - 2 = 1.142 (beta = 8.062) and 8/7. Each fraction p/q sits after the number it is near, and there the line meets a lattice point every p ticks: both voices strike ticks p, 2p, 3p and nobody strikes p - 1, 2p - 1, ... At pi - 2 voice B strikes every 8th tick fifteen times running and then 9 ticks after; at 8/7 it strikes every 8th tick for ever, and every 8th tick is a double. Alpha stands at the top left in A's colour and beta at the top right in B's.\n// Knob 4: Ticks. Rows to a tick, 5 at the opening (24 ticks on the 120 rows under the labels) up to 12 (10 ticks). A lattice cell spans two ticks, 10 to 24 rows, and is always 20 LEDs wide.\n\n// Beatty's theorem: if alpha > 1 is irrational and 1/alpha + 1/beta = 1,\n// the numbers floor(k alpha) and floor(k beta), k = 1, 2, 3, ..., take every\n// whole number once between them. Rayleigh stated it in The Theory of Sound\n// (1894) and Beatty set it as a problem in the American Mathematical Monthly\n// (1926).\n//\n// The picture is the lattice proof. Take the line from the origin in the\n// direction (1/alpha, 1/beta) and call t = x + y its time: it crosses the\n// line x = i at t = i alpha and the line y = j at t = j beta. Up to time\n// N + 1 it has crossed floor((N + 1)/alpha) + floor((N + 1)/beta) lines,\n// and the two fractional parts add to exactly 1 because the two quotients\n// add to N + 1 and neither is whole, so that is N lines: one more for every\n// tick, never two, never none. Each tick of the score is the stretch of\n// the line from t = n to n + 1, and the lane that lights is the kind of\n// line crossed in it. On the panel t runs up and w = x - t/alpha, how far\n// a point is ahead of the line in x at the same t, runs across, so the line\n// stands upright in the middle of the ribbon and the square lattice leans:\n// its x lines rise to the left, its y lines to the right.\n\nconst W = 64, H = 128, PY = 76, TOP = 8, CX = 42, LW = 9;\nconst { floor, ceil, min, max, round, sqrt, PI, E } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst PHI = (1 + sqrt(5)) / 2;\n\n// The stations of the Alpha knob: each irrational number, then a fraction\n// close to it, where the theorem breaks.\nconst ST = [\n  { a: PHI, la: \"φ\", lb: \"φ+1\" },\n  { p: 8, q: 5, la: \"8/5\", lb: \"8/3\" },\n  { a: sqrt(2), la: \"√2\", lb: \"2+√2\" },\n  { p: 7, q: 5, la: \"7/5\", lb: \"7/2\" },\n  { a: E - 1, la: \"e-1\", lb: \"2.39\" },\n  { p: 12, q: 7, la: \"12/7\", lb: \"12/5\" },\n  { a: PI - 2, la: \"π-2\", lb: \"8.06\" },\n  { p: 8, q: 7, la: \"8/7\", lb: \"8\" },\n];\n\n// 3 by 5 figures and signs, drawn for this pattern; φ, π and √ are wider.\nconst GL = {\n  0: \"### #.# #.# #.# ###\", 1: \".#. ##. .#. .#. ###\", 2: \"### ..# ### #.. ###\", 3: \"### ..# .## ..# ###\",\n  4: \"#.# #.# ### ..# ..#\", 5: \"### #.. ### ..# ###\", 6: \"### #.. ### #.# ###\", 7: \"### ..# ..# .#. .#.\",\n  8: \"### #.# ### #.# ###\", 9: \"### #.# ### ..# ###\", \".\": \"... ... ... ... .#.\", \"/\": \"..# ..# .#. #.. #..\",\n  \"+\": \"... .#. ### .#. ...\", \"-\": \"... ... ### ... ...\", e: \".#. #.# ### #.. .##\",\n  \"φ\": \"..#.. .###. #.#.# .###. ..#..\", \"π\": \"..... ##### .#.#. .#.#. .#..#\", \"√\": \"..### ..#.. #.#.. ##... .#...\",\n};\n\nfunction hsv(h, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const v = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  o[0] = round(v[0] * 255);\n  o[1] = round(v[1] * 255);\n  o[2] = round(v[2] * 255);\n  return o;\n}\n\nconst cdiv = (a, b) => floor((a + b - 1) / b);\n\n// How many multiples of alpha (voice A) and of beta (voice B) have floor n.\nfunction hits(S, n) {\n  const s = S.st;\n  if (n \u003c 1) return [0, 0];\n  if (s.p) {\n    const p = s.p, q = s.q, r = p - q;\n    return [cdiv((n + 1) * q, p) - cdiv(n * q, p), cdiv((n + 1) * r, p) - cdiv(n * r, p)];\n  }\n  return [ceil((n + 1) * S.ia) - ceil(n * S.ia), ceil((n + 1) * S.ib) - ceil(n * S.ib)];\n}\n\nexport function setup(params) {\n  params.s = {\n    T: 40, hue: 0, speed: 2, k: -1, st: ST[0], ia: 1 / PHI, ib: 1 - 1 / PHI, R: 6, S: 20,\n    id: new Int32Array(W * H), code: new Uint8Array(W * H), ca: [0, 0, 0], cb: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ki = min(ST.length - 1, floor(cl(k[2] || 0, 0, 1) * ST.length));\n  if (ki !== S.k) {\n    S.k = ki;\n    S.st = ST[ki];\n    const a = S.st.p ? S.st.p / S.st.q : S.st.a;\n    S.ia = 1 / a;\n    S.ib = 1 - 1 / a;\n  }\n  S.R = 5 + round(cl(k[3] == null ? 0.06 : k[3], 0, 1) * 7);\n  S.T += d * S.speed * 1.5;\n}\n\n// Cell (i, j) of the square lattice, x in [i, i+1) and y in [j, j+1), is on\n// the walk when the times the line spends in its column and in its row meet.\n// Returns 0 when it is not, else when and how it was entered: 1 across a\n// line x = i (voice A), 2 across y = j (voice B), 3 through a corner.\nfunction cell(S, i, j) {\n  if (i \u003c 0 || j \u003c 0) return [0, 0];\n  const s = S.st;\n  if (s.p) {\n    const r = s.p - s.q;\n    // i alpha \u003c (j + 1) beta and j beta \u003c (i + 1) alpha, times q r / p.\n    if (!(i * r \u003c (j + 1) * s.q && j * s.q \u003c (i + 1) * r)) return [0, 0];\n    const ta = i * r, tb = j * s.q;\n    return [ta > tb ? 1 : ta \u003c tb ? 2 : 3, (max(ta, tb) * s.p) / (s.q * r)];\n  }\n  const ta = i / S.ia, tb = j / S.ib;\n  if (!(ta \u003c (j + 1) / S.ib && tb \u003c (i + 1) / S.ia)) return [0, 0];\n  return [ta > tb ? 1 : 2, max(ta, tb)];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { id, code, R } = S, T = S.T, sw = S.S;\n  code.fill(0);\n  id.fill(0);\n  const cells = new Map();\n  const tlo = T - (H - PY) / R - 2, ib0 = floor(tlo * S.ia) - 4, jb0 = floor(tlo * S.ib) - 4;\n  // Every LED's cell of the lattice, visited or not, as 1 + a key; the\n  // line is w = 0, between columns CX - 1 and CX.\n  for (let py = TOP; py \u003c H; py++) {\n    const t = T + (PY - py - 0.5) / R;\n    if (t \u003c= 0) continue;\n    for (let px = 0; px \u003c W; px++) {\n      const w = (px - CX + 0.5) / sw, x = w + t * S.ia, y = t * S.ib - w;\n      const i = floor(x), j = floor(y), key = (i - ib0) * 1024 + (j - jb0);\n      if (!cells.has(key)) cells.set(key, cell(S, i, j));\n      id[py * W + px] = key + 1;\n    }\n  }\n  // 0 off the walk, 1 a cell the walk has entered, 2 one it has yet to enter.\n  const state = (v) => {\n    if (!v) return 0;\n    const c = cells.get(v - 1);\n    return !c[0] ? 0 : c[1] \u003c= T ? 1 : 2;\n  };\n  for (let py = TOP; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, v = id[p];\n      if (!v) continue;\n      const c = cells.get(v - 1), st = state(v), r = px \u003c W - 1 ? id[p + 1] : 0, dn = py \u003c H - 1 ? id[p + W] : 0;\n      if (st === 1) {\n        // Entered: filled in the colour of the voice that crossed into it,\n        // with a dark seam where it meets the next cell.\n        if (!((r !== v && state(r) === 1) || (dn !== v && state(dn) === 1))) code[p] = c[0] === 3 ? (px \u003c CX ? 1 : 2) : c[0];\n        continue;\n      }\n      // Not yet entered: only the lattice lines round it, a line x = i in\n      // voice A's colour and a line y = j in B's, and the line of the walk.\n      for (const q of [r, dn]) {\n        if (!q || q === v || state(q) === 1 || (st !== 2 && state(q) !== 2)) continue;\n        code[p] = floor((q - 1) / 1024) !== floor((v - 1) / 1024) ? 1 : 2;\n      }\n      if (st === 2 && px === CX) code[p] = c[0] === 3 ? 2 : c[0];\n    }\n  // The two voices side by side at the left: one block per tick, voice A\n  // in the outer lane, B in the inner one. A struck block throws a line to\n  // the point where the walk crosses into its next cell.\n  const n0 = floor(T - (H - PY) / R) - 1, n1 = ceil(T + (PY - TOP) / R) + 1;\n  for (let n = max(1, n0); n \u003c= n1; n++) {\n    const [a, b] = hits(S, n);\n    const yb = round(PY - (n - T) * R), ya = yb - R + 1;\n    // Not yet struck: an outline; struck: filled. A tick neither voice\n    // strikes, which only a rational alpha leaves, is a box round both lanes.\n    const done = n \u003c= T;\n    for (let py = max(TOP, ya); py \u003c min(H, yb); py++) {\n      const edge = py === ya || py === yb - 1;\n      for (let px = 0; px \u003c 2 * LW; px++) {\n        const c = px \u003c LW ? 1 : 2, on = c === 1 ? a : b, side = px === 0 || px === 2 * LW - 1;\n        if ((on && (done || edge || side || px === LW - 1 || px === LW)) || (!a && !b && (edge || side))) code[py * W + px] = c;\n      }\n    }\n    const age = T - n;\n    if (age >= 0 && age \u003c 0.7) {\n      const x1 = round(2 * LW + (CX - 2 * LW) * (1 - age / 0.7));\n      for (const [v, inv, c] of [[a, S.ia, 1], [b, S.ib, 2]]) {\n        if (!v) continue;\n        const te = ceil(n * inv - 1e-9) / inv, py = round(PY - (te - T) * R - 0.5);\n        if (py >= TOP && py \u003c H) for (let px = 2 * LW; px \u003c x1; px++) code[py * W + px] = c;\n      }\n    }\n  }\n  // alpha and beta, top left and top right.\n  const label = (s, x0, cc, right) => {\n    const gl = [...s].map((ch) => GL[ch].split(\" \"));\n    let wd = -1;\n    for (const g of gl) wd += g[0].length + 1;\n    let x = right ? W - 1 - wd : x0;\n    for (const g of gl) {\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c g[r].length; q++) if (g[r][q] === \"#\") code[(1 + r) * W + x + q] = cc;\n      x += g[0].length + 1;\n    }\n  };\n  label(S.st.la, 1, 1, false);\n  label(S.st.lb, 0, 2, true);\n  const ca = hsv(S.hue + 5 / 6, S.ca), cb = hsv(S.hue + 1 / 3, S.cb);\n  for (let p = 0; p \u003c W * H; p++) {\n    const c = code[p], x = p % W, y = (p - x) / W;\n    if (c === 1) display.setPixel(x, y, ca[0], ca[1], ca[2]);\n    else if (c === 2) display.setPixel(x, y, cb[0], cb[1], cb[2]);\n    else display.setPixel(x, y, 0, 0, 0);\n  }\n}\n","benford-law":"// ===== Patternflow pattern =====\n// Title:   Benford's Law\n// Family:  data\n// Idea:    The panel is a logarithmic ruler from 1 at the bottom to 10 at the top, cut into nine bands as tall as Benford's shares, 30.1% of the height for the leading digit 1 down to 4.6% for 9, and the powers 2, 4, 8, 16, ... land on it one after another, each a step of log10 2 further up that wraps at the top, so the landings spread evenly up the ruler and each band's bar, its count over its share, swings wildly for the first powers and closes onto one dotted line by the thousandth, while a ratio such as the square root of 10 lands on two bands only and never gets there.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Benford's law (Simon Newcomb, 1881; Frank Benford, 1938), equidistribution of n x mod 1 (Hermann Weyl, 1916); 5 by 7 figures from Photon Disk (pattern round 70), copied from autogram.js; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=0..8, Digit=1..2\n//\n// Knob 1: Hue. Turns the band colours round the wheel together. At 0 the band of 1 is cyan and the bands go azure, blue, violet, magenta, rose, orange and yellow to lime for 9; at 0.5 the band of 1 is red, 2 orange, 3 yellow and 9 blue violet. With Digit at 2 the ten second digits run from cyan for 0 to yellow for 9.\n// Knob 2: Speed. The count speeds up as it goes: at 2 the first power lands at 0.6 s, the tenth at 2.8 s, the hundredth at 6.4 s, the thousandth at 10.4 s and the 3000th at 12.3 s; the bars hold 2.5 s, drain in 0.8 s and the count starts again from the first power. At 0.2 all ten times slower, at 3 in two thirds of the time. The readout changes at most eight times a second.\n// Knob 3: Ratio. The common ratio a, in nine steps: 2, 3, 7, 1.1, pi, 1.01, then 10^(1/5) = 1.585, 10^(1/3) = 2.154 and 10^(1/2) = 3.162. For the first six log10 a is irrational and the bars close on the line. The first 1000 powers of 2 count 301, 176, 125, 97, 79, 69, 56, 52 and 45 against Benford's 301, 176, 125, 97, 79, 67, 58, 51 and 46, and after 3000 every bar is within 1.1% of the line, under a third of an LED. pi^2 = 9.87 sits just under 10, so the powers of pi run 3, 9, 3, 9 for eight steps and then walk down in two slow lines, each crossing the decade in about 350 powers: the band of 4 is still empty after 100. 1.01 climbs about a row every two powers and takes 231 for a decade, so after 300 the band of 1 is still half again too long. The last three come back to the same leading digits every 5, 3 and 2 powers: 10^(1/5) lands only on 1, 1, 2, 3 and 6, 10^(1/3) on 1, 2 and 4, the square root of 10 on 1 and 3, and their bars never reach the line. A new ratio starts the count again.\n// Knob 4: Digit. 1 counts the first digit, 2 the second. For the second digit each band of the ruler splits into ten slivers, 90 in all, from 5.3 rows for 10 to 0.6 rows for 99, coloured by the second digit, whose shares run from 12.0% for 0 to 8.5% for 9; Newcomb gave both tables in 1881. The second-digit bars of the first 100 powers of 2 are within 25% of the line and within 2% after 3000. Both counts run all the time, so the knob switches without starting over.\n// Buttons: K1 tap starts the count again from the first power.\n\n// Each power multiplies by a, which adds log10 a to the number's logarithm.\n// Its mantissa, the logarithm mod 1, is the height on the ruler, so a power\n// lands log10 a mod 1 of the ruler above the one before and wraps at the\n// top. When log10 a is irrational Weyl's theorem says the landings fill the\n// ruler evenly, and a band then gets its share of them, its height,\n// log10(1 + 1/d) for the first digit d. A band's bar is its count over the\n// number of powers over that share, 26 LEDs to 1, so a digit that keeps the\n// law ends its bar on the dotted line 26 LEDs in, and one past 2.2 times\n// its share runs off the right edge, which then shows white. Across\n// the right half the newest 28 landings stand from right to left, one\n// column each: a staircase for 1.1, a ramp for 1.01, two falling lines for\n// pi, and level rows for the last three ratios.\n\nconst W = 64, H = 128, X0 = 6, UNIT = 26, NEND = 3000, TRAIL = 28;\nconst { floor, min, max, abs, exp, log10, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The ratios a, by the knob. A fraction p/q is a = 10^(p/q), whose powers\n// come back to the same mantissas every q steps.\nconst RATIOS = [\n  { name: \"2\", l: log10(2) },\n  { name: \"3\", l: log10(3) },\n  { name: \"7\", l: log10(7) },\n  { name: \"1.1\", l: log10(1.1) },\n  { name: \"pi\", l: log10(PI) },\n  { name: \"1.01\", l: log10(1.01) },\n  { name: \"10^(1/5)\", p: 1, q: 5 },\n  { name: \"10^(1/3)\", p: 1, q: 3 },\n  { name: \"10^(1/2)\", p: 1, q: 2 },\n];\n\n// 3 by 5 figures drawn for this pattern, rows from the top.\nconst F35 = [\"### #.# #.# #.# ###\", \".#. ##. .#. .#. ###\", \"##. ..# .#. #.. ###\", \"##. ..# .#. ..# ##.\", \"#.# #.# ### ..# ..#\",\n  \"### #.. ##. ..# ##.\", \".## #.. ### #.# ###\", \"### ..# .#. .#. .#.\", \"### #.# ### #.# ###\", \"### #.# ### ..# ##.\"].map((f) => f.replace(/ /g, \"\"));\n// The figures 0 to 9 of Photon Disk's 5 by 7 face (copied from autogram.js).\nconst F57 = [\n  \".###. #...# #..## #.#.# ##..# #...# .###.\", \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", \".###. #...# ....# ...#. ..#.. .#... #####\",\n  \"##### ...#. ..#.. ...#. ....# #...# .###.\", \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", \"##### #.... ####. ....# ....# #...# .###.\",\n  \"..##. .#... #.... ####. #...# #...# .###.\", \"##### ....# ...#. ..#.. .#... .#... .#...\", \".###. #...# #...# .###. #...# #...# .###.\",\n  \".###. #...# #...# .#### ....# ...#. .##..\",\n].map((f) => f.replace(/ /g, \"\"));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Row y (0 at the top) holds the mantissas from 1 at the bottom to 10 at the\n// top: its centre is the number 10^((127.5 - y) / 128). Each row belongs to\n// the first digit and the second digit of that number.\nconst ROW1 = new Int8Array(H), ROW2 = new Int8Array(H);\nfor (let y = 0; y \u003c H; y++) {\n  const v = pow(10, (127.5 - y) / 128);\n  ROW1[y] = floor(v);\n  ROW2[y] = floor(v * 10) % 10;\n}\n// The law: the first digit d has share log10(1 + 1/d); the second digit e\n// the sum over d of log10(1 + 1/(10d + e)), 12.0% for 0 down to 8.5% for 9.\nconst SHARE1 = [0], SHARE2 = [];\nfor (let d = 1; d \u003c= 9; d++) SHARE1.push(log10(1 + 1 / d));\nfor (let e = 0; e \u003c= 9; e++) {\n  let s = 0;\n  for (let d = 1; d \u003c= 9; d++) s += log10(1 + 1 / (10 * d + e));\n  SHARE2.push(s);\n}\n// Band d runs from row TOP1[d] to row TOP1[d - 1] - 1 (TOP1[0] = 128).\nconst BOT1 = [], TOP1 = [];\nfor (let d = 1; d \u003c= 9; d++) {\n  let a = H, b = -1;\n  for (let y = 0; y \u003c H; y++) if (ROW1[y] === d) (a = min(a, y)), (b = max(b, y));\n  TOP1[d] = a;\n  BOT1[d] = b;\n}\n\nfunction mantissa(R, n) {\n  if (R.q) return ((n * R.p) % R.q) / R.q;\n  const t = n * R.l;\n  return t - floor(t);\n}\n\nfunction restart(S) {\n  S.c1.fill(0);\n  S.c2.fill(0);\n  S.n = 0;\n  S.t = 0;\n  S.phase = 0;\n  S.pt = 0;\n  S.flash.length = 0;\n  S.shown = -1;\n  S.last = null;\n  S.label = null;\n  S.drain = 1;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, ratio: -1, digit: 1, btn: false, time: 0,\n    c1: new Float64Array(10), c2: new Float64Array(10), n: 0, t: 0, phase: 0, pt: 0, drain: 1,\n    flash: [], shown: -1, label: 0, labelT: -1, rgb: [0, 0, 0], col: [0, 0, 0],\n    out: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\n// One power: count its first and second digits, and flash its row.\nfunction land(S, n) {\n  const R = RATIOS[S.ratio], m = mantissa(R, n), v = pow(10, m);\n  const d1 = min(9, floor(v + 1e-9)), d2 = floor(v * 10 + 1e-9) % 10;\n  S.c1[d1]++;\n  S.c2[d2]++;\n  const y = cl(127 - floor(m * 128), 0, H - 1);\n  S.flash.push({ y, t: S.time, d1, d2 });\n  if (S.flash.length > TRAIL) S.flash.shift();\n  S.last = { n, y, v };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const ratio = cl(round(k[2] || 0), 0, RATIOS.length - 1);\n  S.digit = cl(round(k[3] == null ? 1 : k[3]), 1, 2);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (ratio !== S.ratio || (btn && !S.btn)) {\n    S.ratio = ratio;\n    restart(S);\n  }\n  S.btn = btn;\n  S.time += d;\n  const sp = S.speed / 2;\n  if (S.phase === 0) {\n    // The count speeds up: n = 2.5 (2^(t / 1.2) - 1) at Speed 2, so the\n    // first powers come about a second apart and the 3000th at 12.3 s.\n    S.t += d * sp;\n    S.drain = min(1, S.drain + d * 3);\n    const want = min(NEND, floor(2.5 * (pow(2, S.t / 1.2) - 1)));\n    while (S.n \u003c want) land(S, ++S.n);\n    if (S.n >= NEND) (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    S.pt += d * sp;\n    if (S.pt > 2.5) (S.phase = 2), (S.pt = 0);\n  } else {\n    S.pt += d * sp;\n    S.drain = max(0, 1 - S.pt / 0.6);\n    if (S.pt > 0.8) restart(S), (S.drain = 0);\n  }\n  // The readout follows the newest power, at most eight times a second.\n  if (S.last && S.last.n !== S.shown && S.time - S.labelT >= 0.125) {\n    S.shown = S.last.n;\n    S.labelT = S.time;\n    S.label = S.last;\n  }\n}\n\nfunction put(o, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const k = (y * W + x) * 3;\n  o[k] = c[0] * a;\n  o[k + 1] = c[1] * a;\n  o[k + 2] = c[2] * a;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.out, col = S.col, n = max(1, S.n), two = S.digit === 2;\n  const share = two ? SHARE2 : SHARE1, cnt = two ? S.c2 : S.c1;\n  const glow = S.phase === 1 ? 0.5 + 0.5 * Math.sin(S.pt * 6) : 0;\n  // Flash strength per row.\n  // Flash strength per row: the newest four powers, each fading in 0.15 s.\n  const fl = new Float32Array(H), F = S.flash;\n  for (let i = F.length - 1, r = 0; i >= 0 && r \u003c 4; i--, r++) fl[F[i].y] = max(fl[F[i].y], exp(-r / 2 - (S.time - F[i].t) / 0.15));\n  for (let y = 0; y \u003c H; y++) {\n    const cls = two ? ROW2[y] : ROW1[y];\n    const hue = two ? S.hue + 0.5 + cls * 0.074 : S.hue + 0.5 + (cls - 1) * 0.094;\n    const ratio = S.n > 0 ? cnt[cls] / n / share[cls] : 0;\n    const fx = X0 + UNIT * ratio * S.drain;\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      let r = 0, g = 0, b = 0;\n      if (x >= X0) {\n        if (x + 1 \u003c= fx) {\n          // The bar, its last column brightest.\n          const edge = x + 2 > fx ? 1 : 0;\n          hsv(hue, edge ? 0.45 : 0.72, edge ? 1 : 0.86, col);\n        } else if (x \u003c fx) {\n          const f = fx - x;\n          hsv(hue, 0.45, 0.18 + 0.82 * f, col);\n        } else hsv(hue, 0.35, 0.13, col);\n        (r = col[0]), (g = col[1]), (b = col[2]);\n        if (fl[y] > 0) {\n          const a = 0.7 * fl[y];\n          r += (1 - r) * a;\n          g += (1 - g) * a;\n          b += (1 - b) * a;\n        }\n      }\n      o[k] = r;\n      o[k + 1] = g;\n      o[k + 2] = b;\n    }\n    // A bar past the edge of the panel ends in a white column.\n    if (X0 + UNIT * ratio * S.drain > W) put(o, W - 1, y, [1, 1, 1], 0.9);\n    // Benford's line: where every bar ends when the digits keep the law.\n    if (y % 2 === 0) {\n      const k = (y * W + X0 + UNIT) * 3, a = 0.55 + 0.45 * glow;\n      o[k] = max(o[k], a);\n      o[k + 1] = max(o[k + 1], a);\n      o[k + 2] = max(o[k + 2], a);\n    }\n  }\n  // The ruler: a tick at each digit 1 to 9 and the digit beside its band.\n  for (let d = 1; d \u003c= 9; d++) {\n    const yb = BOT1[d], yt = TOP1[d], mid = floor((yb + yt) / 2) - 2;\n    hsv(S.hue + 0.5 + (d - 1) * 0.094, two ? 0 : 0.5, 1, col);\n    for (let x = 0; x \u003c X0 - 1; x++) put(o, x, yb, col, 0.35);\n    const f = F35[d];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (f[r * 3 + q] === \"#\") put(o, 1 + q, mid + r, col, 0.95);\n  }\n  // The orbit: the newest 28 powers from right to left, one column each, at\n  // the rows they landed on.\n  const F2 = S.flash, fade = S.phase === 2 ? S.drain : 1;\n  for (let i = F2.length - 1, j = 0; i >= 0; i--, j++) {\n    const f = F2[i], x = W - 2 - j;\n    if (x \u003c= X0 + UNIT + 1) break;\n    const c = two ? f.d2 : f.d1;\n    hsv(two ? S.hue + 0.5 + c * 0.074 : S.hue + 0.5 + (c - 1) * 0.094, 0.3, 1, col);\n    put(o, x, f.y, col, fade * (1 - (0.6 * j) / TRAIL));\n  }\n  // The newest power's first four digits, beside the row it landed on.\n  if (S.label && S.phase !== 2) {\n    const v = floor(S.label.v * 1000 + 1e-6), s = [floor(v / 1000), -1, floor(v / 100) % 10, floor(v / 10) % 10, v % 10];\n    const top = cl(S.label.y - 3, 1, H - 8), x1 = W - 4;\n    const wid = 4 * 6 + 2;\n    for (let y = top - 1; y \u003c= top + 7; y++) for (let x = x1 - wid; x \u003c= x1 + 1; x++) put(o, x, y, [0, 0, 0], 0);\n    const lv = S.label.v;\n    hsv(two ? S.hue + 0.5 + (floor(lv * 10 + 1e-9) % 10) * 0.074 : S.hue + 0.5 + (min(9, floor(lv + 1e-9)) - 1) * 0.094, 0.25, 1, col);\n    let x = x1 - wid + 1;\n    for (const c of s) {\n      if (c \u003c 0) {\n        put(o, x, top + 6, col, 1);\n        x += 2;\n        continue;\n      }\n      const f = F57[c];\n      for (let r = 0; r \u003c 7; r++) for (let q = 0; q \u003c 5; q++) if (f[r * 5 + q] === \"#\") put(o, x + q, top + r, col, 1);\n      x += 6;\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(o[k], 0, 1) * 255), round(cl(o[k + 1], 0, 1) * 255), round(cl(o[k + 2], 0, 1) * 255));\n    }\n}\n","cistercian-numerals":"// ===== Patternflow pattern =====\n// Title:   Cistercian Numerals\n// Family:  type\n// Idea:    One Cistercian cipher stands the full height of the panel, a single stave 122 rows long carrying the units in its top right corner, the tens top left, the hundreds bottom right and the thousands bottom left, and it counts, each corner swinging shut against the stave like a door and opening again on its next figure, so when it counts by one the units corner flaps four times a second, the tens every 2.5 s and the hundreds hardly ever, while a small readout in Arabic figures beside the middle of the stave says the same number.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the ciphers of the Cistercian monks, from the 13th century, in the forms David A. King tabulates in The Ciphers of the Monks (2001); the Fibonacci numbers mod 10000 (Pisano period 15000); 5 by 7 figures from Photon Disk (pattern round 70), copied from autogram.js; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Count=0..3, Weight=0..1\n//\n// Knob 1: Hue. Turns the four corner colours round the wheel together. At 0 the units are gold, the tens lime, the hundreds aquamarine and the thousands blue, 0.17 of a turn apart; the stave is the units colour washed nearly white.\n// Knob 2: Speed. How often the number changes. Counting by one it steps 4 times a second at 2, 0.4 at 0.2 and 6 at 3; the other counts step 1.2 times a second at 2 (0.12 at 0.2, 1.8 at 3) because all four corners turn at once. A corner takes 0.3 s to swing shut and open, never more than 85% of a step.\n// Knob 3: Count. What is counted: 0 counts by one from a random number whose four figures are all 1 to 9, 1 the Fibonacci numbers mod 10000, 2 the 1229 primes below 10000 and 3 the squares 1 to 9801. Each wraps round at its end; a new count starts at a random place in it.\n// Knob 4: Weight. The stroke: 3.3 LEDs wide at 0, 6 at 0.5 and 8.6 at 1, each with a glow about 2 LEDs deep, so at 1 the narrow angle of a 3, 4 or 5 fills in where it meets the stave.\n\n// Each corner is a box QW LEDs wide and QH tall against one end of the stave.\n// In the box of the units, u runs from the stave out to the right (0..1) and\n// v from the top end of the stave down (0..1). The nine figures in the\n// convention the modern tables take from King (2001):\n//   1 a bar along the top            (0,0)-(1,0)\n//   2 a bar along the bottom         (0,1)-(1,1)\n//   3 a diagonal down, away          (0,0)-(1,1)\n//   4 a diagonal up, away            (0,1)-(1,0)\n//   5 = 1 + 4, a closed triangle\n//   6 the outer upright              (1,0)-(1,1)\n//   7 = 1 + 6, 8 = 2 + 6, 9 = 1 + 2 + 6, a closed square against the stave.\n// The manuscripts do not all draw them alike; this pattern keeps the\n// convention above throughout. The tens are the units mirrored left to\n// right, the hundreds the units mirrored top to bottom (their 1 runs along\n// the foot of the stave), the thousands both. A blank corner is a 0; the\n// bare stave is 0.\n\nconst W = 64, H = 128, SX = 32, Y0 = 3, Y1 = 125, QW = 26, QH = 40;\nconst { floor, round, min, max, abs, sqrt, cos, sin, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst HUE0 = 0.12, HSTEP = 0.17, FLIP = 0.3;\n\nconst B1 = [0, 0, 1, 0], B2 = [0, 1, 1, 1], D3 = [0, 0, 1, 1], D4 = [0, 1, 1, 0], U6 = [1, 0, 1, 1];\nconst FIGURE = [[], [B1], [B2], [D3], [D4], [B1, D4], [U6], [B1, U6], [B2, U6], [B1, B2, U6]];\n// Which way u and v run for units, tens, hundreds and thousands.\nconst SIDE = [1, -1, 1, -1], END = [0, 0, 1, 1];\n\n// The figures 0 to 9 of Photon Disk's 5 x 7 face, rows from the top\n// (copied from autogram.js).\nconst FIG = [\n  \".###. #...# #..## #.#.# ##..# #...# .###.\", \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  \".###. #...# ....# ...#. ..#.. .#... #####\", \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", \"##### #.... ####. ....# ....# #...# .###.\",\n  \"..##. .#... #.... ####. #...# #...# .###.\", \"##### ....# ...#. ..#.. .#... .#... .#...\",\n  \".###. #...# #...# .###. #...# #...# .###.\", \".###. #...# #...# .#### ....# ...#. .##..\",\n].map((f) => f.replace(/ /g, \"\"));\n// The readout's left edge for thousands, hundreds, tens and units, and its top row.\nconst RX = [15, 21, 38, 44], RY = 61;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The primes below 10000 by the sieve of Eratosthenes.\nconst PRIMES = [];\n{\n  const comp = new Uint8Array(10000);\n  for (let n = 2; n \u003c 10000; n++) {\n    if (comp[n]) continue;\n    PRIMES.push(n);\n    for (let m = n * n; m \u003c 10000; m += n) comp[m] = 1;\n  }\n}\n\n// A new count of kind k at a random place in it.\nfunction start(S, k) {\n  S.kind = k;\n  if (k === 0) {\n    S.val = 0;\n    for (let p = 0; p \u003c 4; p++) S.val = S.val * 10 + 1 + floor(Math.random() * 9);\n  } else if (k === 1) {\n    (S.fa = 0), (S.fb = 1);\n    for (let i = floor(Math.random() * 400) + 12; i > 0; i--) [S.fa, S.fb] = [S.fb, (S.fa + S.fb) % 10000];\n    S.val = S.fb;\n  } else if (k === 2) {\n    S.pi = 30 + floor(Math.random() * (PRIMES.length - 60));\n    S.val = PRIMES[S.pi];\n  } else {\n    S.sq = 10 + floor(Math.random() * 80);\n    S.val = S.sq * S.sq;\n  }\n}\nfunction step(S) {\n  if (S.kind === 0) S.val = (S.val % 9999) + 1;\n  else if (S.kind === 1) ([S.fa, S.fb] = [S.fb, (S.fa + S.fb) % 10000]), (S.val = S.fb);\n  else if (S.kind === 2) (S.pi = (S.pi + 1) % PRIMES.length), (S.val = PRIMES[S.pi]);\n  else (S.sq = (S.sq % 99) + 1), (S.val = S.sq * S.sq);\n}\n// Hand the number to the four corners; a corner whose figure changed swings.\nfunction show(S, quiet) {\n  for (let p = 0, v = S.val; p \u003c 4; p++, v = floor(v / 10)) {\n    const d = v % 10;\n    if (d === S.dig[p]) continue;\n    S.old[p] = quiet ? d : S.dig[p];\n    S.dig[p] = d;\n    S.t[p] = quiet ? 9 : 0;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, kind: -1, hw: 1.67, acc: 0, val: 0, fa: 0, fb: 1, pi: 0, sq: 1,\n    dig: [0, 0, 0, 0], old: [0, 0, 0, 0], t: [9, 9, 9, 9],\n    buf: new Float32Array(W * H * 3), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], pale: [0, 0, 0],\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.hw = 1.67 + 2.6 * cl(k[3] || 0, 0, 1);\n  const kind = cl(round(k[2] || 0), 0, 3);\n  if (kind !== S.kind) {\n    const first = S.kind \u003c 0;\n    start(S, kind);\n    show(S, first);\n    S.acc = 0;\n  }\n  const rate = (S.kind === 0 ? 2 : 0.6) * S.speed;\n  S.flip = min(FLIP, 0.85 / rate);\n  S.acc += d * rate;\n  for (let p = 0; p \u003c 4; p++) S.t[p] += d;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    step(S);\n    show(S, false);\n  }\n}\n\n// Paint a segment of half-width hw with a glow round it, keeping the\n// brighter of what is there and what it brings, channel by channel.\nfunction seg(S, x0, y0, x1, y1, c, a) {\n  const hw = S.hw, R = hw + 6, b = S.buf;\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  const ax = max(0, floor(min(x0, x1) - R)), bx = min(W - 1, floor(max(x0, x1) + R));\n  const ay = max(0, floor(min(y0, y1) - R)), by = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = l2 > 0 ? cl((px * dx + py * dy) / l2, 0, 1) : 0;\n      const dd = sqrt((px - u * dx) ** 2 + (py - u * dy) ** 2) - hw;\n      const v = a * (dd \u003c -0.5 ? 1 : dd \u003c 0.5 ? 0.5 - dd : 0) + a * 0.26 * exp(-max(0, dd) / 1.6);\n      if (v \u003c= 0.004) continue;\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) b[kk + q] = max(b[kk + q], c[q] * min(1, v));\n    }\n}\n\n// One corner: figure f of place p, its far side at fraction w of full width\n// (1 open, 0 shut against the stave), lit at a.\nfunction corner(S, p, f, w, c, a) {\n  const sx = SIDE[p] * QW * w, top = END[p] === 0;\n  for (const s of FIGURE[f]) {\n    const x0 = SX + s[0] * sx, x1 = SX + s[2] * sx;\n    const y0 = top ? Y0 + s[1] * QH : Y1 - s[1] * QH, y1 = top ? Y0 + s[3] * QH : Y1 - s[3] * QH;\n    seg(S, x0, y0, x1, y1, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const b = S.buf;\n  for (let i = 0; i \u003c W * H; i++) (b[i * 3] = 0.008), (b[i * 3 + 1] = 0.01), (b[i * 3 + 2] = 0.022);\n  for (let p = 0; p \u003c 4; p++) hsv(S.hue + HUE0 + p * HSTEP, 0.72, 1, S.col[p]);\n  hsv(S.hue + HUE0, 0.16, 0.92, S.pale);\n  // The stave first, so the corners' colours win where they meet it.\n  seg(S, SX, Y0, SX, Y1, S.pale, 1);\n  const hot = [0, 0, 0];\n  for (let p = 0; p \u003c 4; p++) {\n    const ph = S.t[p] / S.flip, c = S.col[p];\n    if (ph \u003c 0.5) {\n      // The old figure swings shut: its width goes as the cosine of the turn.\n      const w = cos(PI * ph);\n      corner(S, p, S.old[p], w, c, 0.35 + 0.65 * w);\n    } else {\n      // The new one swings open, white hot at first and cooling in about 0.25 s.\n      const w = ph >= 1 ? 1 : sin(PI * (ph - 0.5)), heat = exp(-max(0, S.t[p] - 0.5 * S.flip) / 0.12);\n      for (let q = 0; q \u003c 3; q++) hot[q] = c[q] + (1 - c[q]) * 0.6 * heat;\n      corner(S, p, S.dig[p], w, hot, 0.35 + 0.65 * w);\n    }\n  }\n  // The readout: thousands, hundreds | tens, units, each in its corner's\n  // colour, flashing as the corner turns.\n  for (let i = 0; i \u003c 4; i++) {\n    const p = 3 - i, f = FIG[S.dig[p]], c = S.col[p], fl = exp(-S.t[p] / 0.25);\n    for (let r = 0; r \u003c 7; r++)\n      for (let q = 0; q \u003c 5; q++) {\n        if (f[r * 5 + q] !== \"#\") continue;\n        const kk = ((RY + r) * W + RX[i] + q) * 3;\n        for (let z = 0; z \u003c 3; z++) b[kk + z] = 0.25 + 0.75 * (c[z] + (1 - c[z]) * (0.35 + 0.65 * fl));\n      }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(b[kk], 0, 1) * 255), round(cl(b[kk + 1], 0, 1) * 255), round(cl(b[kk + 2], 0, 1) * 255));\n    }\n}\n","frieze-letters":"// ===== Patternflow pattern =====\n// Title:   Frieze Letters\n// Family:  type\n// Idea:    Seven strips run down the panel, each one glyph repeated in one of the seven frieze groups the textbook way, b, d, p and q, every glyph coloured by how it sits, and on each beat every strip makes one of its own symmetries, sliding down by its period, gliding, folding pairs of cells over the mirror between them, mirroring across its axis or turning pairs half round, so that it lands exactly where it began, while a caption names one strip at a time by the group its pixels really have, in Conway's words and orbifold signature, so that with a symmetric glyph such as A or H strips built in different ways end as the same frieze under the same name.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the seven frieze groups with John Conway's names and orbifold signatures (John H. Conway, Heidi Burgiel and Chaim Goodman-Strauss, The Symmetries of Things, 2008), shown the textbook way with b, d, p and q; 5 by 7 glyphs, Hangul included, and 3 by 5 caption letters drawn for this pattern, pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Glyph=0..1, Marks=-1..1\n//\n// Knob 1: Hue. Turns the four colours round the wheel together. A glyph's colour says how it sits: at 0 the glyph as drawn (b) is azure, mirrored left to right (d) pink, upside down (p) yellow and turned half round (q) green. Ways of sitting that look alike take the first one's colour, so A and its mirror are both azure and the upside-down A is yellow.\n// Knob 2: Speed. A beat lasts 3 / Speed seconds, 1.5 s at the opening 2: every strip makes its motion in the first 0.9 s and holds for 0.6 s. 15 s at 0.2, 1 s at 3. The caption moves to the next strip every two beats.\n// Knob 3: Glyph. Ten glyphs, a tenth of the knob each: b, F, R, J, ㄱ and 가 have no symmetry of their own and give seven different friezes. N has a half-turn: hop and spinning hop draw the same strip, and so do step and sidle, five pictures in four groups. E has a mirror across: hop is sidle, step is spinning hop and jump is spinning jump, four pictures in three groups. A has a mirror down its middle: hop and step are one picture, sidle, spinning hop and spinning sidle another, and only two groups are left, jump and spinning jump. H has both, and all seven strips are spinning jump.\n// Knob 4: Marks. The symmetry of each strip as the pixels have it, in grey under the glyphs: a line across the strip at each mirror across it, a small diamond at each half-turn centre, a line down the axis for a mirror along it and a dotted line for a glide. Off at -1, 35% grey at the opening 0.06, 90% at 1. At any setting the mirror, centre or axis a strip is moving about flashes white while it moves.\n// Buttons: K1 tap starts the next beat at once.\n\nconst W = 64, H = 128, GW = 5, GH = 7, CH = 12, TOPY = -3, FBOT = 112;\nconst { floor, min, max, round, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\n// The glyphs, 5 by 7, drawn for this pattern.\nconst GLYPHS = [\n  \"#.... #.... #.##. ##..# #...# #...# ####.\", // b\n  \"##### #.... #.... ####. #.... #.... #....\", // F\n  \"####. #...# #...# ####. #.#.. #..#. #...#\", // R\n  \"..### ...#. ...#. ...#. ...#. #..#. .##..\", // J\n  \"##### ....# ....# ....# ....# ...#. ..#..\", // ㄱ\n  \"...#. ##.#. .#.#. .#.## .#.#. #..#. ...#.\", // 가\n  \"#...# #...# ##..# #.#.# #..## #...# #...#\", // N, a half-turn\n  \"##### #.... #.... ####. #.... #.... #####\", // E, a mirror across\n  \".###. #...# #...# ##### #...# #...# #...#\", // A, a mirror along\n  \"#...# #...# #...# ##### #...# #...# #...#\", // H, both\n].map((s) => s.replace(/ /g, \"\").split(\"\").map((c) => c === \"#\"));\n\n// The four ways a glyph can sit: as drawn, mirrored left to right (b to d),\n// upside down (b to p), turned half round (b to q).\nconst I = 0, V = 1, M = 2, R = 3;\n// Doing one after another is t ^ u: the four form the Klein group, V M = R.\nfunction variant(g, t) {\n  const o = new Array(GW * GH);\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      const sx = t & 1 ? GW - 1 - x : x, sy = t & 2 ? GH - 1 - y : y;\n      o[y * GW + x] = g[sy * GW + sx];\n    }\n  return o;\n}\n\n// The seven friezes, each strip running down the panel. A cell holds one\n// glyph, or two in the jumps, the second the first mirrored across the\n// strip's axis. The textbook runs its friezes across the page; here they run\n// down, so b to d is the mirror along the axis and b to p the mirror across\n// it, and the textbook's sidle, b d b d, is b p b p. seq gives how the glyph\n// sits in a cell by its place in the period, and ops the motions the strip\n// makes, one a beat, in turn. Each is a symmetry of the strip, so it ends\n// where it began: T slides the strip down n cells, G mirrors it across its\n// axis as it slides, A mirrors it across its axis, Mp folds each pair of\n// cells over the mirror between them and Rp turns each pair half round about\n// the centre between them.\nconst FRIEZES = [\n  { name: \"HOP\", sig: \"∞∞\", seq: [I], ops: [[\"T\", 1]] },\n  { name: \"STEP\", sig: \"∞×\", seq: [I, V], ops: [[\"G\", 1]] },\n  { name: \"SIDLE\", sig: \"*∞∞\", seq: [I, M], ops: [[\"Mp\"], [\"T\", 2]] },\n  { name: \"SPINNING HOP\", sig: \"22∞\", seq: [I, R], ops: [[\"Rp\"], [\"T\", 2]] },\n  { name: \"SPINNING SIDLE\", sig: \"2*∞\", seq: [I, M, V, R], ops: [[\"Mp\"], [\"Rp\"], [\"G\", 2], [\"T\", 4]] },\n  { name: \"JUMP\", sig: \"∞*\", seq: [I], twin: true, ops: [[\"A\"], [\"T\", 1]] },\n  { name: \"SPINNING JUMP\", sig: \"*22∞\", seq: [I, M], twin: true, ops: [[\"A\"], [\"Mp\"], [\"Rp\"], [\"T\", 2]] },\n];\nconst COLX = [0, 8, 16, 24, 32, 40, 53];\nconst colW = (f) => (FRIEZES[f].twin ? 2 * GW + 1 : GW);\n// Slot j, counted down from the top, holds the cell with place -j.\nconst seqAt = (f, k) => {\n  const s = FRIEZES[f].seq;\n  return s[((k % s.length) + s.length) % s.length];\n};\nconst tauAt = (f, j) => seqAt(f, -j);\n\n// 3 by 5 capitals for the caption, N and M wider, and the orbifold signs.\nconst CAP = {\n  H: \"#.# #.# ### #.# #.#\", O: \".#. #.# #.# #.# .#.\", P: \"##. #.# ##. #.. #..\", S: \".## #.. .#. ..# ##.\",\n  T: \"### .#. .#. .#. .#.\", E: \"### #.. ##. #.. ###\", I: \"### .#. .#. .#. ###\", D: \"##. #.# #.# #.# ##.\",\n  L: \"#.. #.. #.. #.. ###\", N: \"#..# ##.# #.## #..# #..#\", G: \".## #.. #.# #.# .##\", J: \"..# ..# ..# #.# .#.\",\n  U: \"#.# #.# #.# #.# ###\", M: \"#...# ##.## #.#.# #...# #...#\", 2: \"##. ..# .#. #.. ###\",\n  \"∞\": \"..... .#.#. #.#.# .#.#. .....\", \"*\": \"..#.. #.#.# .###. #.#.# ..#..\", \"×\": \"... #.# .#. #.# ...\", \" \": \". . . . .\",\n};\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - i;\n  const c = [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i];\n  for (let q = 0; q \u003c 3; q++) o[q] = v * (1 - s + s * c[q]);\n  return o;\n}\n\n// Four cells of a frieze, a whole period of every one, as a bitmap laid out\n// like slots 0 to 3, so the marks found in it fall where the cells are drawn.\nfunction periodMap(f, vars) {\n  const cw = colW(f), L = 4 * CH, b = new Uint8Array(L * cw);\n  for (let m = 0; m \u003c 4; m++) {\n    const t = tauAt(f, m);\n    const put = (v, x0) => {\n      for (let y = 0; y \u003c GH; y++) for (let x = 0; x \u003c GW; x++) if (v[y * GW + x]) b[(m * CH + y) * cw + x0 + x] = 1;\n    };\n    put(vars[t], 0);\n    if (FRIEZES[f].twin) put(vars[t ^ V], GW + 1);\n  }\n  return b;\n}\n\n// Which of the seven groups a frieze of this glyph really has, found from\n// the pixels: a symmetric glyph adds symmetry, and two constructions can\n// end in the same frieze. Also where its mirrors and half-turn centres are.\nfunction analyse(f, vars) {\n  const cw = colW(f), L = 4 * CH, b = periodMap(f, vars);\n  const at = (y, x) => b[(((y % L) + L) % L) * cw + x];\n  const test = (fn) => {\n    for (let y = 0; y \u003c L; y++) for (let x = 0; x \u003c cw; x++) if (at(y, x) !== fn(y, x)) return false;\n    return true;\n  };\n  const axis = test((y, x) => at(y, cw - 1 - x));\n  const mir = [], rot = [];\n  for (let h = 0; h \u003c 2 * L; h++) {\n    if (test((y, x) => at(h - y, x))) mir.push(h);\n    if (test((y, x) => at(h - y, cw - 1 - x))) rot.push(h);\n  }\n  let glide = false;\n  for (let s = 1; s \u003c L && !axis && !glide; s++) glide = test((y, x) => at(y + s, cw - 1 - x));\n  const g = axis && mir.length ? 6 : axis ? 5 : mir.length && rot.length ? 4 : mir.length ? 2 : rot.length ? 3 : glide ? 1 : 0;\n  return { g, axis, glide, mir, rot };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, gi: -1, marks: 0.5, ph: 0, vars: null, cls: [0, 1, 2, 3], an: [],\n    buf: new Float32Array(W * H * 3), pal: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const gi = min(GLYPHS.length - 1, floor(cl(k[2] || 0, 0, 1) * GLYPHS.length));\n  if (gi !== S.gi) {\n    S.gi = gi;\n    S.vars = [I, V, M, R].map((t) => variant(GLYPHS[gi], t));\n    // Ways of sitting that look the same share a colour: b, d, p and q are\n    // four, A and its mirror are one.\n    S.cls = [I, V, M, R].map((t) => {\n      for (let u = 0; u \u003c t; u++) if (S.vars[u].every((v, i) => v === S.vars[t][i])) return u;\n      return t;\n    });\n    S.an = FRIEZES.map((_, f) => analyse(f, S.vars));\n  }\n  S.marks = (cl(k[3] == null ? 0.06 : k[3], -1, 1) + 1) / 2;\n  if (input.btnPressed && input.btnPressed[0]) S.ph = floor(S.ph) + 1;\n  S.ph += (d * S.speed) / 3;\n}\n\n// One glyph through an affine motion: the LED at p shows the glyph's pixel\n// at A^-1 (p - c), counted from the glyph's centre, c being where that\n// centre has got to.\nfunction glyph(S, src, a, b, c, d, cx, cy, col) {\n  const det = a * d - b * c || 1e-3, buf = S.buf;\n  for (let y = max(0, floor(cy - 5)); y \u003c= min(FBOT - 1, floor(cy + 5)); y++)\n    for (let x = max(0, floor(cx - 5)); x \u003c= min(W - 1, floor(cx + 5)); x++) {\n      const px = x + 0.5 - cx, py = y + 0.5 - cy;\n      const gx = floor((d * px - b * py) / det + GW / 2), gy = floor((-c * px + a * py) / det + GH / 2);\n      if (gx \u003c 0 || gx >= GW || gy \u003c 0 || gy >= GH || !src[gy * GW + gx]) continue;\n      const q = (y * W + x) * 3;\n      buf[q] = col[0];\n      buf[q + 1] = col[1];\n      buf[q + 2] = col[2];\n    }\n}\n\nfunction mark(S, x, y, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= FBOT) return;\n  const q = (y * W + x) * 3;\n  S.buf[q] = S.buf[q + 1] = S.buf[q + 2] = max(S.buf[q], a);\n}\n\n// The gaps (j, j + 1) where the cell below is the cell above under op t:\n// M for a mirror across the strip, R for a half-turn. Taken top down so no\n// cell is in two pairs.\nfunction pairs(f, t, j0, j1) {\n  const out = [];\n  for (let j = j0; j \u003c j1; j++) if ((tauAt(f, j) ^ tauAt(f, j + 1)) === t) out.push(j++);\n  return out;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.vars) return;\n  const b = S.buf;\n  b.fill(0);\n  // A beat: every strip makes its next motion in the first 60%, then holds.\n  const beat = floor(S.ph), u = S.ph - beat, e = ease(min(1, u / 0.6)), fl = sin(PI * min(1, u / 0.6));\n  const hl = floor(beat / 2) % FRIEZES.length;\n  for (let c = 0; c \u003c 4; c++) hsv(S.hue + [0.58, 0.9, 0.14, 0.36][c], 0.75, 1, S.pal[c]);\n  const ma = 0.9 * S.marks ** 1.5;\n  for (let f = 0; f \u003c FRIEZES.length; f++) {\n    const fr = FRIEZES[f], an = S.an[f], x0 = COLX[f], cw = colW(f), ax = x0 + cw / 2;\n    const op = fr.ops[beat % fr.ops.length], kind = op[0], n = op[1] || 0;\n    const yc = (j) => TOPY + j * CH + GH / 2;\n    const gx = fr.twin ? [x0 + GW / 2, x0 + GW + 1 + GW / 2] : [x0 + GW / 2];\n    const mp = kind === \"Mp\" ? pairs(f, M, -5, 16) : [];\n    const rp = kind === \"Rp\" ? pairs(f, fr.twin ? M : R, -5, 16) : [];\n    // Marks of the strip's real symmetry, under the glyphs: mirrors across\n    // it as lines, half-turn centres as small diamonds, a mirror along the\n    // axis as a line down it and a glide as a dotted one. The ones the\n    // motion uses light up while it moves.\n    const axf = kind === \"A\" || kind === \"G\" ? fl : 0;\n    for (let y = 0; y \u003c FBOT; y++) {\n      if (an.axis || (an.glide && y % 3 === 0)) mark(S, floor(ax), y, ma);\n      if (axf && (kind === \"A\" || y % 3 === 0)) mark(S, floor(ax), y, axf);\n    }\n    for (let j = -1; j \u003c= 12; j++) {\n      const yk = TOPY + j * CH, m = ((j % 4) + 4) % 4;\n      for (const h of an.mir) {\n        const r = floor(h / 2) - m * CH;\n        if (r >= 0 && r \u003c CH) for (let x = x0 - 1; x \u003c= x0 + cw; x++) mark(S, x, yk + r, ma);\n      }\n      for (const h of an.rot) {\n        const r = floor(h / 2) - m * CH;\n        if (r >= 0 && r \u003c CH) for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) mark(S, floor(ax) + dx, yk + r + dy, ma);\n      }\n    }\n    const gapY = TOPY + GH + (CH - GH - 1) / 2;\n    for (const j of mp) for (let x = x0 - 1; x \u003c= x0 + cw; x++) mark(S, x, gapY + j * CH, fl);\n    for (const j of rp) for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) mark(S, floor(ax) + dx, gapY + j * CH + dy, fl);\n    // The glyphs. Each one's colour is the look it lands in, from halfway.\n    const draw1 = (t, t2, c0x, c0y, A, c1x, c1y) => glyph(S, S.vars[t], A[0], A[1], A[2], A[3], c1x, c1y, S.pal[S.cls[e \u003c 0.5 ? t : t2]]);\n    const sc = cos(PI * e), sn = sin(PI * e);\n    for (let j = -n - 1; j \u003c= 12; j++) {\n      const t0 = tauAt(f, j);\n      for (let g = 0; g \u003c gx.length; g++) {\n        const t = g ? t0 ^ V : t0, cx = gx[g], cy = yc(j);\n        if (kind === \"T\") draw1(t, t, cx, cy, [1, 0, 0, 1], cx, cy + n * CH * e);\n        else if (kind === \"G\") draw1(t, t ^ V, cx, cy, [sc, 0, 0, 1], ax + (cx - ax) * sc, cy + n * CH * e);\n        else if (kind === \"A\") draw1(t, t ^ V, cx, cy, [sc, 0, 0, 1], ax + (cx - ax) * sc, cy);\n        else if (kind === \"Mp\") {\n          const p = mp.indexOf(j) >= 0 ? j : mp.indexOf(j - 1) >= 0 ? j - 1 : null;\n          if (p === null) draw1(t, t, cx, cy, [1, 0, 0, 1], cx, cy);\n          else {\n            const ym = gapY + p * CH + 0.5;\n            draw1(t, t ^ M, cx, cy, [1, 0, 0, sc], cx, ym + (cy - ym) * sc);\n          }\n        } else {\n          const p = rp.indexOf(j) >= 0 ? j + 1 : rp.indexOf(j - 1) >= 0 ? j - 1 : null;\n          if (p === null) draw1(t, t, cx, cy, [1, 0, 0, 1], cx, cy);\n          else {\n            // Turned about its own centre while the centre runs straight to\n            // its partner's place: the same end as the half-turn about the\n            // point between them, kept inside the strip.\n            const tx = fr.twin ? gx[1 - g] : cx, ty = yc(p);\n            draw1(t, t ^ R, cx, cy, [sc, -sn, sn, sc], cx + (tx - cx) * e, cy + (ty - cy) * e);\n          }\n        }\n      }\n    }\n  }\n  // The caption: the group of one strip at a time, read from what its\n  // pixels do, under a bar over the strip it names.\n  const an = S.an[hl], fr = FRIEZES[an.g], ink = 0.85;\n  for (let x = COLX[hl]; x \u003c COLX[hl] + colW(hl); x++) for (let y = FBOT + 1; y \u003c FBOT + 3; y++) b.fill(ink, (y * W + x) * 3, (y * W + x) * 3 + 3);\n  const text = (s, y0) => {\n    const gl = [...s].map((ch) => CAP[ch].split(\" \"));\n    let wd = -1;\n    for (const g of gl) wd += g[0].length + 1;\n    let x = floor((W - wd) / 2);\n    for (const g of gl) {\n      for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c g[r].length; q++) if (g[r][q] === \"#\") b.fill(ink, ((y0 + r) * W + x + q) * 3, ((y0 + r) * W + x + q) * 3 + 3);\n      x += g[0].length + 1;\n    }\n  };\n  text(fr.name, FBOT + 5);\n  text(fr.sig, FBOT + 11);\n  for (let p = 0; p \u003c W * H; p++) {\n    const x = p % W, y = (p - x) / W;\n    display.setPixel(x, y, round(cl(b[p * 3], 0, 1) * 255), round(cl(b[p * 3 + 1], 0, 1) * 255), round(cl(b[p * 3 + 2], 0, 1) * 255));\n  }\n}\n","hegselmann-krause":"// ===== Patternflow pattern =====\n// Title:   Hegselmann-Krause\n// Family:  sim\n// Idea:    Four hundred opinions spread over the panel's 64 columns each move, step after step, to the mean of all the opinions within epsilon of their own, and a pen writes the steps down the 128 rows on a clock that slows, so the even wash at the top, every opinion coloured by where it started, gathers into funnels that freeze in about nine steps into six or seven bright rivers some 2.6 epsilon apart, the odd straggler between them, before a fresh set of opinions is written over them from the top.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: bounded confidence model (Rainer Hegselmann and Ulrich Krause, 2002), pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Epsilon=0.03..0.3\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 an opinion that starts at 0 is cyan, one that starts at 0.5 blue violet and one at 1 rose, and a river wears the colour of the mean start of the opinions in it; at 0.5 the same run goes red, orange, lime and teal. Twenty faint stripes, every twentieth of the starting range, run down the wash and pinch together where it gathers.\n// Knob 2: Speed. The pen writes 12 rows a second times the knob: at 2 a run fills the panel in 5.3 s and holds 1.2 s, at 0.2 it takes 53 s and holds 12 s, at 3 it takes 3.6 s.\n// Knob 3: Tilt. Asymmetric confidence: an agent listens epsilon x (1 + Tilt) to its right and epsilon x (1 - Tilt) to its left, the window still 2 epsilon wide. At 0 the symmetric model, whose mean opinion stays at 0.50. At 0.5, with epsilon 0.06, the funnels lean right, a run moves for 16 steps instead of 9 and ends in 4.8 rivers instead of 6.6, and the mean opinion drifts to 0.65. At 1 an agent hears only the opinions at or right of its own, up to 2 epsilon away, and in 277 runs of 300 everyone streams into one river at the right edge.\n// Knob 4: Epsilon. The confidence bound, 0.03 to 0.3, opening at 0.06. Over 300 runs of 400 agents a run ends in 13.0 clusters at 0.03 (1/(2 epsilon) is 16.7), 6.6 at 0.06 (8.3), 3.9 at 0.1 (5), 2.6 at 0.15 (3.3) and 1.9 at 0.2, where 9% of runs reach consensus; at 0.25 96% do, at 0.3 all. A change starts a new run.\n// Buttons: K1 tap starts a new run from the top.\n\n// Each step every agent moves to the mean of the opinions within epsilon of\n// its own, its own included, all at once. Opinions freeze in finite time:\n// once neighbouring clusters are more than epsilon apart nothing moves\n// again. The rule of thumb says about 1/(2 epsilon) clusters. Random starts\n// give fewer: over 300 runs of 400 agents they sat 2.56 epsilon apart at\n// epsilon 0.06 and 2.65 at 0.03, where evenly spaced starts sit about 2.2\n// apart, near the 2 epsilon that Vincent Blondel, Julien Hendrickx and John\n// Tsitsiklis conjectured for them (2009).\n//\n// Step s is drawn on row A ln(1 + s / 6), interpolated between steps, so the\n// first steps, where most of the gathering happens, get the most rows. A\n// grey tick in both margin columns marks each step, and a white one the end\n// of the last step that moves an opinion by more than a tenth of an LED.\n\nconst W = 64, H = 128, N = 400, MAXSTEP = 400;\nconst { floor, min, max, abs, exp, sqrt, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// One run: N opinions drawn uniformly from [0, 1], then the model's steps\n// until no opinion moves. The order of the opinions never changes, so a\n// sorted start stays sorted and each step is one sweep of a sliding window.\nfunction simulate(epsL, epsR) {\n  const x0 = new Float64Array(N);\n  for (let i = 0; i \u003c N; i++) x0[i] = Math.random();\n  x0.sort();\n  const traj = [Float32Array.from(x0)];\n  let x = x0, last = 0;\n  for (let s = 0; s \u003c MAXSTEP; s++) {\n    const y = new Float64Array(N);\n    let lo = 0, hi = 0, sum = 0, move = 0;\n    for (let i = 0; i \u003c N; i++) {\n      while (hi \u003c N && x[hi] \u003c= x[i] + epsR + 1e-12) sum += x[hi++];\n      while (x[lo] \u003c x[i] - epsL - 1e-12) sum -= x[lo++];\n      y[i] = sum / (hi - lo);\n      move = max(move, abs(y[i] - x[i]));\n    }\n    x = y;\n    traj.push(Float32Array.from(y));\n    if (move > 0.0015) last = s + 1;\n    if (move \u003c 1e-9) break;\n  }\n  return { x0: Float32Array.from(x0), traj, steps: last };\n}\n\nfunction newRun(S) {\n  const r = simulate(S.eps * (1 - S.tilt), S.eps * (1 + S.tilt));\n  S.run = r;\n  // The clock slows down the panel: step s sits on row A ln(1 + s / 6), A\n  // chosen so the last step that moves lands on row 96 at the latest and the\n  // first step takes at most 16 rows.\n  S.A = min(16 / Math.log(1 + 1 / 6), 96 / Math.log(1 + max(1, r.steps) / 6));\n  S.pen = 0;\n  S.hold = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, tilt: -1, eps: -1, btn: false,\n    img: new Float32Array(W * H * 2), old: new Float32Array(W * H * 2), rgb: new Float32Array(3),\n    w: new Float32Array(W), wx: new Float32Array(W), wb: new Float32Array(W), drawn: 0, run: null,\n  };\n  return params.s;\n}\n\n// Draw row y of the run into img.\nfunction drawRow(S, y) {\n  const { traj, x0 } = S.run, t = 6 * (exp(y / S.A) - 1), s = floor(t), f0 = t - s, f = f0 * f0 * (3 - 2 * f0);\n  const a = traj[min(s, traj.length - 1)], b = traj[min(s + 1, traj.length - 1)];\n  const { w, wx, wb } = S;\n  w.fill(0);\n  wx.fill(0);\n  wb.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const p = a[i] + (b[i] - a[i]) * f, u = 1 + p * 61, c = floor(u), g = u - c;\n    const br = 0.4 + 0.6 * (0.5 + 0.5 * cos(x0[i] * PI * 40));\n    w[c] += 1 - g;\n    wx[c] += (1 - g) * x0[i];\n    wb[c] += (1 - g) * br;\n    w[c + 1] += g;\n    wx[c + 1] += g * x0[i];\n    wb[c + 1] += g * br;\n  }\n  const o = S.img, rho = W / N;\n  for (let c = 0; c \u003c W; c++) {\n    let best = 0, bh = 0, bb = 0;\n    for (let d = -4; d \u003c= 4; d++) {\n      const cc = c + d;\n      if (cc \u003c 0 || cc >= W || w[cc] \u003c 0.03) continue;\n      const r = w[cc] * rho, hw = max(0, 0.45 * sqrt(r) - 0.35);\n      const cov = cl(hw + 0.5 - abs(d), 0, 1) * cl(w[cc] / 0.25, 0, 1);\n      const v = cov * (0.3 + 0.7 * (1 - exp(-r / 1.5)));\n      if (v > best) (best = v), (bh = wx[cc] / w[cc]), (bb = wb[cc] / w[cc]);\n    }\n    const k = (y * W + c) * 2;\n    o[k] = best * bb;\n    o[k + 1] = bh;\n  }\n  // A tick in both margins on each row where a step falls, a bright one on\n  // the row where the run freezes.\n  const t1 = 6 * (exp((y + 1) / S.A) - 1);\n  if (floor(t1) > s) {\n    const v = s \u003c S.run.steps && floor(t1) >= S.run.steps ? 0.9 : s \u003c S.run.steps ? 0.3 : 0;\n    for (const c of [0, W - 1]) if (v > 0) (o[(y * W + c) * 2] = v), (o[(y * W + c) * 2 + 1] = -1);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const tilt = cl(k[2] || 0, 0, 1), eps = cl(k[3] == null ? 0.06 : k[3], 0.03, 0.3);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.run) {\n    S.tilt = tilt;\n    S.eps = eps;\n    newRun(S);\n    for (let y = 0; y \u003c H; y++) drawRow(S, y);\n    S.old.set(S.img);\n    newRun(S);\n    S.pen = 48;\n    for (let y = 0; y \u003c 48; y++) drawRow(S, y);\n    S.drawn = 48;\n  }\n  if (abs(tilt - S.tilt) > 0.02 || abs(eps - S.eps) > 0.004 || (btn && !S.btn)) {\n    S.tilt = tilt;\n    S.eps = eps;\n    S.old.set(S.img);\n    newRun(S);\n    S.drawn = 0;\n  }\n  S.btn = btn;\n  const rate = 12 * S.speed;\n  if (S.pen \u003c H) S.pen = min(H, S.pen + d * rate);\n  else {\n    S.hold += d;\n    if (S.hold > 2.4 / S.speed) {\n      S.old.set(S.img);\n      newRun(S);\n      S.drawn = 0;\n    }\n  }\n  while (S.drawn \u003c floor(S.pen)) drawRow(S, S.drawn++);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.run) return;\n  const o = S.img, ol = S.old, pen = floor(S.pen), c = S.rgb;\n  for (let y = 0; y \u003c H; y++) {\n    // The newest rows come in brighter and settle in about 10 rows; below\n    // the pen the last run stays, dimmed.\n    const now = y \u003c pen, buf = now ? o : ol, lift = now ? 1 + 0.6 * exp(-(pen - 1 - y) / 4) : 0.38;\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 2, v = buf[k] * lift;\n      if (v \u003c= 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      hsv(S.hue + 0.5 + 0.48 * buf[k + 1], buf[k + 1] \u003c 0 ? 0 : 0.78, cl(v, 0, 1), c, 0);\n      display.setPixel(x, y, floor(c[0] * 255), floor(c[1] * 255), floor(c[2] * 255));\n    }\n  }\n}\n","kanizsa-letters":"// ===== Patternflow pattern =====\n// Title:   Kanizsa Letters\n// Family:  type\n// Idea:    Thirty-two pac-man discs on a 4 by 8 lattice turn at random over a fine diagonal grating, and only when every one swings its cut into line does a letter of EDGE LIGHT stand out in front of them, a surface the colour of the background whose edges the eye draws between the cuts while the grating inside it slips half a period so its lines end on those edges, though no LED ever draws an edge; then the discs let go, spin, turn about and line up into the next letter.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: illusory contours from notched discs (Gaetano Kanizsa, Margini quasi-percettivi in campi con stimolazione omogenea, 1955) and from line ends (Walter Ehrenstein, 1941); abutting gratings (Rüdiger von der Heydt, Esther Peterhans and Günter Baumgartner, 1984); the support ratio (Thomas Shipley and Philip Kellman, 1992); letters on a 3 by 7 grid of cells drawn here, pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gap=0.3..0.8, Period=5..14\n//\n// Knob 1: Hue. Turns both colours round the wheel. At 0 the discs are golden yellow and the grating slate blue; at 0.5 the discs are sky blue and the grating a muted gold.\n// Knob 2: Speed. At 2 a letter takes 7.2 s: the discs swing into line one by one over 2.6 s, each swing 0.45 s, the letter holds 2.4 s, they let go over 1.2 s and spin free for 1 s. A free disc turns at 0.2 to 0.55 turns a second and turns about every 1.7 s on average. At 0.2 it all runs ten times slower.\n// Knob 3: Gap. The share of each letter edge left between the discs for the eye to fill in, one minus Shipley and Kellman's support ratio. A disc's radius is 8 (1 - Gap) LEDs on the 16 LED lattice: 5.6 at 0.3, where 70% of every edge is cut and the letter is plain; 3.2 at 0.6; 1.6 at 0.8, where the cuts are too small to see and the letter stands on the grating's line ends alone.\n// Knob 4: Period. LEDs along a row between grating lines, 5 to 14; the lines run at 45 degrees, 3.5 to 9.9 LEDs apart. Inside the letter they shift by half a period rounded to a whole LED, 3 LEDs at 5 and 7 at 14, and each LED is lit by its distance to the nearest line so that the shift leaves the grating's mean light as it was.\n// Buttons: K1 tap lets the letter go at once and moves on to the next.\n\n// A letter fills cells of the lattice, so every disc sits on a corner of\n// four cells and the letter covers 0 to 4 of its quarters. The quarters it\n// covers are the disc's cut: one quarter at an outer corner, two side by\n// side along an edge, three at an inner corner, two opposite where the\n// letter steps diagonally. A disc the letter does not touch is whole. While\n// the discs spin free each wears one open quarter, a pac-man, so the lattice\n// reads the same whatever letter is coming; as a disc swings into line its\n// mouth turns into the cut the letter asks of it. The letter's own surface\n// is the grating shifted by half a period. It shows through every cut.\n\nconst W = 64, H = 128, N = W * H, TAU = 2 * Math.PI, Q = Math.PI / 2;\nconst { floor, round, min, max, abs, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\n// The lattice: discs on the corners of 16 LED cells, 4 across and 8 down,\n// the first at (8, 8). A letter fills 3 by 7 of the cells.\nconst CELL = 16, OX = 8, OY = 8, NX = 4, NY = 8;\n// Seconds at Speed 2: the discs swing into line one by one, the letter\n// holds, they let go, they spin free.\nconst SETTLE = 2.6, HOLD = 2.4, LETGO = 1.2, FREE = 1, SWING = 0.45, HUE0 = 0.12;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// E D G E L I G H T, rows of 3 cells from the top.\nconst FONT = {\n  E: \"### #.. #.. ### #.. #.. ###\",\n  D: \"##. #.# #.# #.# #.# #.# ##.\",\n  G: \"### #.. #.. #.# #.# #.# ###\",\n  L: \"#.. #.. #.. #.. #.. #.. ###\",\n  I: \"### .#. .#. .#. .#. .#. ###\",\n  H: \"#.# #.# #.# ### #.# #.# #.#\",\n  T: \"### .#. .#. .#. .#. .#. .#.\",\n};\nconst WORD = \"EDGELIGHT\";\nconst cellOf = (g, r, c) => r >= 0 && r \u003c 7 && c >= 0 && c \u003c 3 && g[r * 3 + c] === \"#\";\n\n// Which quarters of each disc the letter covers: quarter k spans the\n// directions k x 90 to (k + 1) x 90 degrees, y down, so 0 is the cell to the\n// lower right, 1 lower left, 2 upper left, 3 upper right.\nfunction notches(ch) {\n  const g = FONT[ch].replace(/ /g, \"\"), out = [];\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c NX; i++) out.push([cellOf(g, j, i), cellOf(g, j, i - 1), cellOf(g, j - 1, i - 1), cellOf(g, j - 1, i)]);\n  return { g, out };\n}\n\nfunction newDisc(i) {\n  return {\n    x: OX + (i % NX) * CELL, y: OY + floor(i / NX) * CELL, th: Math.random() * TAU,\n    om: 1.2 + 2.2 * Math.random(), dir: Math.random() \u003c 0.5 ? -1 : 1, spin: 0,\n    o: [0, 0, 0, 0], from: [0, 0, 0, 0], to: [0, 0, 0, 0], on: 0, off: 0, ft: 0, th0: 0, mode: 0,\n  };\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, gap: 0.3, per: 5, started: false, btn: false, D: [], li: 0, ph: 0, t: 0, sh: 0,\n    g: \"\", cov: new Uint8Array(N), out: new Float32Array(N * 3), lc: [0, 0, 0], dc: [0, 0, 0],\n  });\n  for (let i = 0; i \u003c NX * NY; i++) S.D.push(newDisc(i));\n  return S;\n}\n\n// The mouth a disc wears while it spins free before a letter: one quarter\n// open, one of the quarters the letter will cover if it covers any.\nfunction freeMouth(want) {\n  const ks = [0, 1, 2, 3].filter((k) => want[k]);\n  const k = ks.length ? ks[floor(Math.random() * ks.length)] : floor(Math.random() * 4);\n  return [0, 1, 2, 3].map((q) => (q === k ? 1 : 0));\n}\n\nfunction letter(S, k) {\n  S.li = ((k % WORD.length) + WORD.length) % WORD.length;\n  const { g, out } = notches(WORD[S.li]);\n  S.g = g;\n  S.want = out;\n}\n// Where the letter's own grating lies; set as the discs start to swing in,\n// when the grating is whole again.\nfunction surface(S) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) S.cov[y * W + x] = cellOf(S.g, floor((y - OY) / CELL), floor((x - OX) / CELL)) ? 1 : 0;\n}\n\n// Phases: 0 the discs swing into line one by one, 1 the letter holds, 2 they\n// let go, their mouths turning to the next letter's, 3 they spin free.\nfunction phase(S, p) {\n  S.ph = p;\n  S.t = 0;\n  if (p === 0) surface(S);\n  S.D.forEach((d, i) => {\n    if (p === 0) {\n      d.on = 0.2 + Math.random() * (SETTLE - SWING - 0.4);\n      d.mode = 0;\n      d.from = d.o.slice();\n      d.to = S.want[i].map((b) => (b ? 1 : 0));\n    }\n    if (p === 2) {\n      d.off = Math.random() * 0.6;\n      d.ft = 0;\n      d.from = d.o.slice();\n    }\n  });\n  if (p === 2) {\n    // The next letter is chosen as the discs let go.\n    letter(S, S.li + 1);\n    S.D.forEach((d, i) => (d.to = freeMouth(S.want[i])));\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.3, 5], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.gap = cl(k[2] == null ? 0.3 : k[2], 0.3, 0.8);\n  S.per = cl(k[3] == null ? 5 : k[3], 5, 14);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started) {\n    letter(S, 0);\n    S.D.forEach((d, i) => (d.o = freeMouth(S.want[i])));\n    phase(S, 0);\n    S.started = true;\n  } else if (btn && !S.btn && S.ph \u003c 2) phase(S, 2);\n  S.btn = btn;\n  const d = (d0 * S.speed) / 2;\n  S.t += d;\n  // A free disc turns at its own pace and now and then turns about.\n  for (const c of S.D) {\n    if (Math.random() \u003c d * 0.6) c.dir = -c.dir;\n    c.spin += cl(c.dir - c.spin, -d * 5, d * 5);\n  }\n  let lined = 0;\n  if (S.ph === 0) {\n    for (const c of S.D) {\n      if (c.mode === 0) {\n        c.th += c.om * c.spin * d;\n        if (S.t >= c.on) (c.mode = 1), (c.th0 = wrap(c.th));\n      }\n      if (c.mode === 1) {\n        const u = ease((S.t - c.on) / SWING);\n        c.th = c.th0 * (1 - u);\n        for (let q = 0; q \u003c 4; q++) c.o[q] = c.from[q] + (c.to[q] - c.from[q]) * u;\n        if (S.t - c.on >= SWING) (c.mode = 2), (c.th = 0);\n      }\n      if (c.mode === 2) lined++;\n    }\n    if (S.t >= SETTLE) phase(S, 1);\n  } else if (S.ph === 1) {\n    lined = S.D.length;\n    if (S.t >= HOLD) phase(S, 2);\n  } else {\n    for (const c of S.D) {\n      if (S.ph === 2 && S.t \u003c c.off) {\n        lined++;\n        continue;\n      }\n      // Let go: the spin picks up over 0.3 s and the mouth turns into the\n      // free one over 0.4 s.\n      c.ft += d;\n      c.th += c.om * c.spin * d * min(1, c.ft / 0.3);\n      const e = ease(c.ft / 0.4);\n      for (let q = 0; q \u003c 4; q++) c.o[q] = c.from[q] + (c.to[q] - c.from[q]) * e;\n    }\n    if (S.ph === 2 && S.t >= LETGO) phase(S, 3);\n    else if (S.ph === 3 && S.t >= FREE) phase(S, 0);\n  }\n  // The grating inside the letter slides half a period once more than half\n  // the discs are in line, and back as they let go.\n  const goal = ease((lined / S.D.length - 0.5) / 0.5);\n  S.sh += cl(goal - S.sh, -d / 0.5, d / 0.5);\n}\n\n// A grating of lines x - y = 0 mod P, one LED wide, each LED lit by its\n// distance along x - y from the nearest line, so that a shift by any amount\n// leaves the mean light of the grating the same.\nfunction line(x, y, P, s) {\n  const g = x - y + s, m = ((g % P) + P) % P;\n  return cl(1 - min(m, P - m), 0, 1);\n}\n\n// Is the direction b (radians, y down) in a disc's open mouth?\nfunction inMouth(o, b) {\n  b = ((b % TAU) + TAU) % TAU;\n  const k = floor(b / Q), f = b / Q - k;\n  // Quarter k is open over the middle o of its width.\n  return o[k] > 0 && abs(f - 0.5) \u003c= o[k] / 2;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const o = S.out, P = S.per, sh = round((S.sh * P) / 2), cov = S.cov, lc = S.lc, dc = S.dc;\n  hsv(S.hue + HUE0 + 0.5, 0.45, 0.55, lc);\n  hsv(S.hue + HUE0, 0.75, 1, dc);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, v = line(x, y, P, cov[i] ? sh : 0);\n      o[i * 3] = v * lc[0];\n      o[i * 3 + 1] = v * lc[1];\n      o[i * 3 + 2] = v * lc[2];\n    }\n  const R = (CELL / 2) * (1 - S.gap), R2 = R * R;\n  for (const c of S.D) {\n    const x0 = max(0, floor(c.x - R - 1)), x1 = min(W - 1, floor(c.x + R)), y0 = max(0, floor(c.y - R - 1)), y1 = min(H - 1, floor(c.y + R));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        // 3 x 3 samples: on the disc and outside its mouth is disc colour,\n        // in the mouth the letter's own grating shows through.\n        let body = 0, mouth = 0;\n        for (let sy = 0; sy \u003c 3; sy++)\n          for (let sx = 0; sx \u003c 3; sx++) {\n            const px = x + (sx + 0.5) / 3 - c.x, py = y + (sy + 0.5) / 3 - c.y;\n            if (px * px + py * py > R2) continue;\n            body++;\n            if (inMouth(c.o, atan2(py, px) - c.th)) mouth++;\n          }\n        if (!body) continue;\n        const i = (y * W + x) * 3, g = line(x, y, P, sh), a = body / 9, m = mouth / body;\n        for (let q = 0; q \u003c 3; q++) o[i + q] = a * (m * g * lc[q] + (1 - m) * dc[q]) + (1 - a) * o[i + q];\n      }\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), round(cl(o[i * 3], 0, 1) * 255), round(cl(o[i * 3 + 1], 0, 1) * 255), round(cl(o[i * 3 + 2], 0, 1) * 255));\n}\n","levy-dust":"// ===== Patternflow pattern =====\n// Title:   Lévy Dust\n// Family:  fractal\n// Idea:    A Lévy flight jumps from landing to landing, each jump in a uniform random direction with a length whose chance of passing l falls as l to the power -alpha, three thousand landings a second that fade over half a minute, and the panel shows the dust they leave three times over, the whole flight in the top third, a window a quarter as wide round a typical landing in the middle third and a quarter as wide again in the bottom third, each window framed in the tier above, so the clusters within clusters and the long empty jumps between them look alike at 1x, 4x and 16x while each long jump flashes as a white streak.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lévy flights and the stable laws (Paul Lévy, 1937); Lévy dust, the landing points of a Rayleigh-Lévy flight, of dimension alpha (Benoit Mandelbrot, 1977; The Fractal Geometry of Nature, 1982); the truncated Lévy flight (Rosario Mantegna and H. Eugene Stanley, 1994); pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tail=-1..1, Cut=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a landing is cyan, blue or violet by when it landed, the hue swinging from cyan to violet and back every 66,000 landings (22 s at Speed 2), and the newest few hundred are near white; the frame in the top tier and the dotted line under it are pale gold, the frame in the middle tier and its line pale green. At 0.5 the dust runs from red through orange and yellow to green inside blue and violet frames.\n// Knob 2: Speed. Landings a second, 1500 times the knob: 3000 at 2, 300 at 0.2, 4500 at 3. A landing dims by a factor e every 30,000 landings after it, 10 s at 2, and goes dark after 105,000, 35 s at 2 and 350 s at 0.2. At every speed the middle tier picks a new window every 3.2 s and the bottom tier every 1.6 s.\n// Knob 3: Tail. Sets alpha = 1.5 - 0.5 x Tail, the exponent of the jump law and the dimension of the dust. At the opening 0 alpha is 1.5: the top tier spans about 75 shortest jumps an LED (38 to 181 over 20 s) and the bottom tier about 4.7, and about 2 jumps a second leave a streak. At 1 alpha is 1 and the long jumps rule: the top tier spans about 360 an LED, the clusters sit far apart and 7 streaks flash a second. At -1 alpha is 2, where the flight falls back towards Brownian motion: the top tier spans 18 an LED, the dust closes into a smudge, and the bottom tier at about 1.1 an LED shows single jumps, where the self-similarity stops.\n// Knob 4: Cut. The longest jump, cut off sharply as in Mantegna and Stanley's truncated flight: 3000 x 60^-Cut shortest jumps, 2350 at the opening 0.06, 390 at 0.5 and 50 at 1. Above the cut the flight adds up like a Brownian walk, so a tier much wider than the cut stops looking like the tiers below it: at 1 the top tier spans about 2,000 (32 an LED) and shows a cloud of small clusters, the middle tier about 500 and the bottom tier 130, near the cut, where the grain of single jumps shows. A new Tail or Cut acts on new landings, so the old dust takes about 35 s to turn over at Speed 2.\n\nconst W = 64, TH = 42, RING = 131072, ZOOM = 4, DWELL = 1.6, LIFE = 30000;\nconst WW = 16, WH = 10.5; // a deeper tier's window in the tier above, in LEDs: 64 / 4 by 42 / 4\nconst TOP = [0, 43, 86]; // tiers on rows 0..41, 43..84, 86..127; dotted lines on 42 and 85\nconst HUES = 32, AGES = 16;\nconst { floor, round, min, max, abs, exp, log, cos, sin, hypot, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const c = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[o] = c[0];\n  out[o + 1] = c[1];\n  out[o + 2] = c[2];\n}\n\nexport function setup(params) {\n  params.s = {\n    px: new Float64Array(RING), py: new Float64Array(RING), n: 0, hx: 0, hy: 0,\n    alpha: 1.5, speed: 2, hue: 0, cut: 3000, acc: 0, t: 0, dt: 0, lutHue: NaN,\n    // view[T] = [cx, cy, world units per LED]; tiers 1 and 2 glide to aim[T].\n    view: [[0, 0, 1], [0, 0, 1], [0, 0, 1]], aim: [[0, 0], [0, 0], [0, 0]], clock: 0,\n    fit: [0, 0, 1], fitTimer: 0, fresh: true, gain: [0, 0, 0],\n    acc4: new Float32Array(W * 128 * 4), lut: new Float32Array(HUES * AGES * 3), streaks: [],\n  };\n  return params.s;\n}\n\n// One landing: a Pareto length, P(L > l) = l^-alpha for 1 \u003c= l, cut off at\n// S.cut and drawn by inverting that law, in a uniform direction. This is\n// Mandelbrot's Rayleigh-Lévy flight, and for alpha below 2 its landings make\n// a dust of dimension alpha. Measured on 40,000 landings at the opening cut,\n// the share of pairs closer than r grows as r^1.22 to r^1.25 at alpha 1.25,\n// r^1.39 to r^1.44 at 1.5 and r^1.55 to r^1.62 at 1.75 for r from 8 to 64:\n// the correlation dimension sits at alpha or a little under it.\nfunction jump(S) {\n  const L = (1 - random() * (1 - S.cut ** -S.alpha)) ** (-1 / S.alpha);\n  const a = random() * 2 * PI;\n  S.hx += L * cos(a);\n  S.hy += L * sin(a);\n  const i = S.n % RING;\n  S.px[i] = S.hx;\n  S.py[i] = S.hy;\n  S.n++;\n  return L;\n}\n\n// A landing's weight by how many landings came after it. It is dropped below\n// 0.03, 105,000 landings on, well inside the ring of 131,072.\nconst weight = (S, age) => exp(-age / LIFE);\n\n// Tier 0 holds the whole dust: centred on the weighted median, and wide\n// enough that 85% of the weight lies inside. Every fourth landing is enough.\nfunction fitTop(S) {\n  const n = min(S.n, RING), xs = [], ys = [], rs = [];\n  let tot = 0;\n  for (let a = 0; a \u003c n; a += 4) {\n    const w = weight(S, a);\n    if (w \u003c 0.03) break;\n    const i = (S.n - 1 - a) % RING;\n    xs.push([S.px[i], w, S.py[i]]);\n    ys.push([S.py[i], w]);\n    tot += w;\n  }\n  const quant = (arr, q) => {\n    arr.sort((p, r) => p[0] - r[0]);\n    let c = 0;\n    for (const e of arr) if ((c += e[1]) >= tot * q) return e[0];\n    return arr[arr.length - 1][0];\n  };\n  const cy = quant(ys, 0.5), cx = quant(xs, 0.5);\n  for (const [x, w, y] of xs) rs.push([max(abs(x - cx) / 31, abs(y - cy) / 20), w]);\n  S.fit = [cx, cy, max(0.05, quant(rs, 0.85) * 1.05)];\n}\n\n// A landing picked at random by weight from those that put a window of a\n// deeper tier wholly inside tier T: a typical point of the dust there, so\n// the window shows what a typical cluster holds rather than the densest.\nfunction pick(S, T) {\n  const v = S.view[T], mx = (W / 2 - WW / 2) * v[2], my = (TH / 2 - WH / 2) * v[2];\n  const n = min(S.n, RING);\n  let tot = 0, got = -1;\n  for (let a = 0; a \u003c n; a++) {\n    const w = weight(S, a);\n    if (w \u003c 0.03) break;\n    const i = (S.n - 1 - a) % RING;\n    if (abs(S.px[i] - v[0]) > mx || abs(S.py[i] - v[1]) > my) continue;\n    tot += w;\n    if (random() * tot \u003c w) got = i;\n  }\n  return got \u003c 0 ? [v[0], v[1]] : [S.px[got], S.py[got]];\n}\n\n// Where a deeper tier's window sits in the tier above, in that tier's LEDs.\nconst inParent = (S, T) => [(S.view[T][0] - S.view[T - 1][0]) / S.view[T - 1][2] + W / 2, (S.view[T][1] - S.view[T - 1][1]) / S.view[T - 1][2] + TH / 2];\n// Whether the window a deeper tier is gliding to has left the window the\n// tier above is gliding to, which tier 0's own drift can do.\nconst outside = (S, T) => {\n  const p = T === 1 ? S.view[0] : S.aim[1], s = S.view[T - 1][2];\n  const x = (S.aim[T][0] - p[0]) / s, y = (S.aim[T][1] - p[1]) / s;\n  return abs(x) > W / 2 - WW / 2 + 1.5 || abs(y) > TH / 2 - WH / 2 + 1.5;\n};\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.dt = d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.alpha = 1.5 - 0.5 * cl(k[2], -1, 1);\n  S.cut = 3000 * 60 ** -cl(k[3], 0, 1);\n  S.t += d;\n  // The first frame opens on a dust already 3.5 lifetimes deep.\n  if (S.n === 0) {\n    for (let i = 0; i \u003c min(RING - 1, 3.5 * LIFE); i++) jump(S);\n    fitTop(S);\n    S.view[0] = S.fit.slice();\n  }\n  S.acc += d * 1500 * S.speed;\n  while (S.acc >= 1) {\n    S.acc--;\n    const x0 = S.hx, y0 = S.hy, L = jump(S);\n    if (L > 1.5 * S.view[0][2]) S.streaks.push([x0, y0, S.hx, S.hy, S.t]);\n  }\n  while (S.streaks.length && (S.streaks.length > 32 || S.t - S.streaks[0][4] > 0.6)) S.streaks.shift();\n  // The flight never ends, so now and then everything shifts back near 0.\n  if (abs(S.hx) + abs(S.hy) > 1e9) {\n    const ox = S.hx, oy = S.hy;\n    for (let i = 0; i \u003c RING; i++) (S.px[i] -= ox), (S.py[i] -= oy);\n    for (const v of S.view) (v[0] -= ox), (v[1] -= oy);\n    for (const a of S.aim) (a[0] -= ox), (a[1] -= oy);\n    for (const s of S.streaks) (s[0] -= ox), (s[1] -= oy), (s[2] -= ox), (s[3] -= oy);\n    S.fit[0] -= ox;\n    S.fit[1] -= oy;\n    S.hx = S.hy = 0;\n  }\n  S.fitTimer -= d;\n  if (S.fitTimer \u003c= 0) (S.fitTimer = 0.25), fitTop(S);\n  const v0 = S.view[0];\n  if (S.fresh) (v0[0] = S.fit[0]), (v0[1] = S.fit[1]), (v0[2] = S.fit[2]);\n  else {\n    const a = 1 - exp(-d / 0.7), b = 1 - exp(-d / 1.2);\n    v0[0] += (S.fit[0] - v0[0]) * a;\n    v0[1] += (S.fit[1] - v0[1]) * a;\n    v0[2] = exp(log(v0[2]) + (log(S.fit[2]) - log(v0[2])) * b);\n  }\n  // Tier 1 picks a new window every 2 x DWELL seconds and tier 2 picks one\n  // inside it at once; halfway between, tier 2 alone picks again. Either\n  // picks at once when tier 0's drift has pushed its window out.\n  S.clock += d;\n  const both = S.fresh || S.clock >= 2 * DWELL || outside(S, 1);\n  const deep = both || (S.clock >= DWELL && S.clock - d \u003c DWELL) || outside(S, 2);\n  if (both) {\n    S.clock = 0;\n    S.aim[1] = pick(S, 0);\n  }\n  if (deep) {\n    // Picked inside the window tier 1 is gliding to.\n    const v1 = S.view[1], keep = [v1[0], v1[1], v1[2]];\n    v1[0] = S.aim[1][0];\n    v1[1] = S.aim[1][1];\n    v1[2] = v0[2] / ZOOM;\n    S.aim[2] = pick(S, 1);\n    if (!S.fresh) (v1[0] = keep[0]), (v1[1] = keep[1]), (v1[2] = keep[2]);\n  }\n  const g = S.fresh ? 1 : 1 - exp(-d / 0.25);\n  for (let T = 1; T \u003c 3; T++) {\n    const v = S.view[T], a = S.aim[T];\n    v[0] += (a[0] - v[0]) * g;\n    v[1] += (a[1] - v[1]) * g;\n    v[2] = S.view[T - 1][2] / ZOOM;\n  }\n  S.fresh = false;\n}\n\n// Every landing still lit, added into each tier it falls in: colour times\n// weight in the first three slots of an LED, weight in the fourth.\nfunction bin(S, A) {\n  const lut = S.lut;\n  A.fill(0);\n  const n = min(S.n, RING), P = 2.2 * LIFE;\n  for (let a = 0; a \u003c n; a++) {\n    const w = weight(S, a);\n    if (w \u003c 0.03) break;\n    const nb = S.n - 1 - a, i = nb % RING;\n    const hq = floor((0.5 - 0.5 * cos((2 * PI * nb) / P)) * (HUES - 1) + 0.5);\n    const q = (hq * AGES + min(AGES - 1, floor(Math.sqrt(a / (4 * LIFE)) * AGES))) * 3;\n    for (let T = 0; T \u003c 3; T++) {\n      const v = S.view[T];\n      const x = floor((S.px[i] - v[0]) / v[2] + W / 2), y = floor((S.py[i] - v[1]) / v[2] + TH / 2);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= TH) continue;\n      const o = ((TOP[T] + y) * W + x) * 4;\n      A[o] += lut[q] * w;\n      A[o + 1] += lut[q + 1] * w;\n      A[o + 2] += lut[q + 2] * w;\n      A[o + 3] += w;\n    }\n  }\n}\n\nfunction line(A, T, x0, y0, x1, y1, f) {\n  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n  for (let i = 0; i \u003c= n; i++) {\n    const x = round(x0 + ((x1 - x0) * i) / n), y = round(y0 + ((y1 - y0) * i) / n);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= TH) continue;\n    const o = ((TOP[T] + y) * W + x) * 4;\n    A[o] += f;\n    A[o + 1] += f;\n    A[o + 2] += f;\n    A[o + 3] += f;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const A = S.acc4;\n  if (S.lutHue !== S.hue) {\n    // A landing's hue follows when it landed, swinging 0.3 round the wheel\n    // and back, cyan through blue to violet at Hue 0; fresh landings are\n    // whitened.\n    for (let h = 0; h \u003c HUES; h++)\n      for (let a = 0; a \u003c AGES; a++) {\n        const fresh = 1 - a / (AGES - 1);\n        hsv(S.hue + 0.5 + (0.3 * h) / (HUES - 1), 0.8 - 0.6 * fresh ** 8, 1, S.lut, (h * AGES + a) * 3);\n      }\n    S.lutHue = S.hue;\n  }\n  bin(S, A);\n  // A long jump leaves a white streak for 0.6 s.\n  for (const [x0, y0, x1, y1, t] of S.streaks) {\n    const f = 0.6 * (1 - (S.t - t) / 0.6);\n    if (f \u003c= 0) continue;\n    for (let T = 0; T \u003c 3; T++) {\n      const v = S.view[T];\n      if (hypot(x1 - x0, y1 - y0) / v[2] \u003c 6) continue;\n      line(A, T, (x0 - v[0]) / v[2] + W / 2, (y0 - v[1]) / v[2] + TH / 2, (x1 - v[0]) / v[2] + W / 2, (y1 - v[1]) / v[2] + TH / 2, f);\n    }\n  }\n  // Each tier's gain follows the mean weight of its lit LEDs, so an LED of\n  // average weight shows at 70% in every tier: a window a quarter as wide\n  // holds about 4^-alpha of the weight, 1/8 at alpha 1.5.\n  for (let T = 0; T \u003c 3; T++) {\n    let sum = 0, cnt = 0;\n    for (let p = TOP[T] * W; p \u003c (TOP[T] + TH) * W; p++) if (A[p * 4 + 3] > 0) (sum += A[p * 4 + 3]), cnt++;\n    const g = 1.2 / max(0.05, sum / max(1, cnt));\n    S.gain[T] = S.gain[T] > 0 ? exp(log(S.gain[T]) + (log(g) - log(S.gain[T])) * (1 - exp(-S.dt / 0.4))) : g;\n  }\n  for (let T = 0; T \u003c 3; T++)\n    for (let y = 0; y \u003c TH; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const o = ((TOP[T] + y) * W + x) * 4, wt = A[o + 3];\n        if (wt \u003c= 0) {\n          display.setPixel(x, TOP[T] + y, 0, 0, 0);\n          continue;\n        }\n        const f = (255 * (1 - exp(-S.gain[T] * wt))) / wt;\n        display.setPixel(x, TOP[T] + y, A[o] * f, A[o + 1] * f, A[o + 2] * f);\n      }\n  // The newest landing, white, in every tier it falls in.\n  for (let T = 0; T \u003c 3; T++) {\n    const v = S.view[T], x = floor((S.hx - v[0]) / v[2] + W / 2), y = floor((S.hy - v[1]) / v[2] + TH / 2);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c TH) display.setPixel(x, TOP[T] + y, 255, 255, 255);\n  }\n  // The frames: in tier 0 where tier 1 looks, in tier 1 where tier 2 looks,\n  // each in the colour of the dotted line above the tier it shows.\n  const fc = [[], []];\n  hsv(S.hue + 0.13, 0.55, 0.85, fc[0], 0);\n  hsv(S.hue + 0.33, 0.55, 0.85, fc[1], 0);\n  for (let T = 0; T \u003c 2; T++) {\n    const col = fc[T], [ux, uy] = inParent(S, T + 1);\n    const x0 = round(ux - WW / 2) - 1, x1 = round(ux + WW / 2), y0 = round(uy - WH / 2) - 1, y1 = round(uy + WH / 2);\n    const put = (x, y) => {\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c TH) display.setPixel(x, TOP[T] + y, col[0] * 255, col[1] * 255, col[2] * 255);\n    };\n    for (let x = x0; x \u003c= x1; x++) put(x, y0), put(x, y1);\n    for (let y = y0 + 1; y \u003c y1; y++) put(x0, y), put(x1, y);\n    for (let x = 0; x \u003c W; x++) {\n      const on = (x & 1) === 0;\n      display.setPixel(x, TOP[T + 1] - 1, on ? col[0] * 150 : 0, on ? col[1] * 150 : 0, on ? col[2] * 150 : 0);\n    }\n  }\n}\n","order-k-voronoi":"// ===== Patternflow pattern =====\n// Title:   Order-k Voronoi\n// Family:  cells\n// Idea:    Ten sites drift slowly and every LED takes the colour of the set of its k nearest sites, the mean of their hues, so the panel splits into the regions of the order-k Voronoi diagram with pale lines where the k-th and the (k+1)-th nearest swap, neighbouring regions sharing all but one site and shading into each other, from the ordinary Voronoi diagram at k = 1 to the farthest-point diagram at k = n - 1, whose few unbounded regions meet in a tree that the centre of the smallest circle round the sites lies on, while a bar chart along the bottom counts the regions of every order in the whole plane and on the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: higher-order Voronoi diagrams and the farthest-point diagram (Michael Shamos and Dan Hoey, 1975); the count of their regions (D. T. Lee, 1982); 3 x 5 figures drawn for this pattern; pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Order=1..17, Sites=10..18, Drift=0..1\n//\n// Knob 1: Hue. Turns the site colours round the wheel together: n hues evenly spaced from Hue + 0.05, so at 0 the ten sites are red-orange, gold, chartreuse, green, sea green, sky blue, blue, violet, magenta and rose at full brightness. A region's colour is the mean of its sites' hues at 30 to 75% saturation, paler where its sites pull in opposite directions; at k = 1 each region is its site's own colour.\n// Knob 2: Order. k, the size of the nearest set, held at n - 1 above it. At 1 the ordinary Voronoi diagram, ten regions. At the opening 2 a region is a pair of sites whose cells touch, 3n - 3 - h of them: 21 to 23 over a minute for the opening ten sites as their hull has 6 to 4 corners. At 4 there are 26 to 34, the tallest bar nine tenths of the time (3 has it the rest), and since each site lies in just one region at least 16 of them hold no site at all. At n - 1, 9 at the opening, the farthest-point diagram: one unbounded region for each corner of the hull, 4 to 6 as the sites drift, meeting in a tree; the smallest circle round all the sites is dotted white and its centre, which lies on the tree, is a white star.\n// Knob 3: Sites. n, 10 to 18; each whole step adds a site on its own path. At the first moment the chart's bars, orders 1 to n - 1, read 10 21 28 31 27 24 16 11 6 with 10 sites, of which the panel holds 10 19 23 25 22 14 9 5 3, and 18 44 63 79 89 96 95 95 88 75 64 56 43 34 24 16 7 with 18, of which it holds 18 38 49 57 61 67 67 61 55 46 37 26 22 18 16 11 5. The tallest bar is seven LEDs high.\n// Knob 4: Drift. How fast the sites run their Lissajous paths: 0.56 LEDs a second on average at 0, 0.68 at the opening 0.06 and 2.6 at 1. The counts in the chart step by one or two as regions are born and die, and the white bar moves with the order.\n\nconst W = 64, H = 128, NMAX = 18, STRIP = 114; // the chart takes rows 114..127\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, hypot, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (e0, e1, x) => {\n  const t = cl((x - e0) / (e1 - e0), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// 3 x 5 figures, drawn for this pattern, rows from the top.\nconst FIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001010010010\", \"111101111101111\", \"111101111001111\"];\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n}\n\nexport function setup(params) {\n  // Each site runs a slow Lissajous path that keeps it 3 LEDs inside the\n  // panel and clear of the chart. The first ten centres take one band each\n  // of the height, shuffled, so the opening ten spread down the panel.\n  const band = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n  for (let i = 9; i > 0; i--) {\n    const j = floor(random() * (i + 1));\n    [band[i], band[j]] = [band[j], band[i]];\n  }\n  const path = [];\n  for (let i = 0; i \u003c NMAX; i++) {\n    const ax = 4 + random() * 9, ay = 4 + random() * 8, room = STRIP - 6 - 2 * ay;\n    path.push({\n      cx: 3 + ax + random() * (58 - 2 * ax), cy: 3 + ay + room * (i \u003c 10 ? (band[i] + random()) / 10 : random()), ax, ay,\n      wx: 0.06 + random() * 0.08, wy: 0.05 + random() * 0.07, px: random() * 2 * PI, py: random() * 2 * PI,\n    });\n  }\n  params.s = {\n    path, t: 0, n: 10, k: 2, hue: 0, sx: new Float64Array(NMAX), sy: new Float64Array(NMAX),\n    plane: new Int32Array(NMAX), panel: new Int32Array(NMAX),\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 10, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.n = cl(round(kv[2]), 3, NMAX);\n  S.k = cl(round(kv[1]), 1, S.n - 1);\n  S.t += d * (0.8 + 3 * cl(kv[3], 0, 1));\n  for (let i = 0; i \u003c NMAX; i++) {\n    const p = S.path[i];\n    S.sx[i] = p.cx + p.ax * sin(p.wx * S.t + p.px);\n    S.sy[i] = p.cy + p.ay * sin(p.wy * S.t + p.py);\n  }\n}\n\n// The number of i-sets for every i: sets of i sites that a line cuts off\n// from the rest, which are the unbounded regions of the order-i diagram.\n// Sweeping a direction u round the circle, the i sites furthest along u\n// change only when u is square to a line through two sites.\nfunction isets(S, e) {\n  const n = S.n, ang = [];\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) if (i !== j) ang.push((atan2(S.sy[j] - S.sy[i], S.sx[j] - S.sx[i]) + 2.5 * PI) % (2 * PI));\n  ang.sort((a, b) => a - b);\n  const seen = [];\n  for (let i = 0; i \u003c n; i++) seen.push(new Set());\n  const ord = [];\n  for (let s = 0; s \u003c ang.length; s++) {\n    const a = (ang[s] + (s + 1 \u003c ang.length ? ang[s + 1] : ang[0] + 2 * PI)) / 2, ux = cos(a), uy = sin(a);\n    ord.length = 0;\n    for (let i = 0; i \u003c n; i++) ord.push(i);\n    ord.sort((p, q) => S.sx[q] * ux + S.sy[q] * uy - (S.sx[p] * ux + S.sy[p] * uy));\n    let m = 0;\n    for (let i = 1; i \u003c n; i++) seen[i].add((m |= 1 \u003c\u003c ord[i - 1]));\n  }\n  for (let i = 1; i \u003c n; i++) e[i] = seen[i].size;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { n, k, sx, sy } = S;\n  // The regions of the order-j diagram in the whole plane, for every j:\n  // 2jn - j^2 - n + 1 less the i-sets for every i below j (D. T. Lee, 1982).\n  // Against a brute-force count, the distinct j-nearest sets round every\n  // crossing of two bisectors, it agreed for 319 random sets of 5 to 14\n  // sites and for 60 moments of this drift at 10, 14 and 18 sites; the one\n  // random set it missed had three sites on a line. Points in convex\n  // position give j(n - j) + 1, and j = 2 gives 3n - 3 - h for h corners\n  // of the hull, the number of Delaunay edges: an order-2 region is a pair\n  // of sites whose Voronoi cells touch.\n  const e = new Int32Array(NMAX);\n  isets(S, e);\n  let sum = 0;\n  for (let j = 1; j \u003c n; j++) {\n    S.plane[j] = 2 * j * n - j * j - n + 1 - sum;\n    sum += e[j];\n  }\n  // Site colours: n hues evenly round the wheel, so their unit vectors sum\n  // to nothing. A region takes the direction of the sum over its k sites,\n  // so two regions that share k - 1 sites differ by one vector in k, and in\n  // the farthest-point diagram the region that leaves out site p takes the\n  // hue opposite p's. Saturation follows the length of the sum against\n  // sqrt(k (n - k) / (n - 1)), its root mean square over random k-sets.\n  const hx = [], hy = [];\n  for (let i = 0; i \u003c n; i++) (hx[i] = cos(2 * PI * (i / n + S.hue + 0.05))), (hy[i] = sin(2 * PI * (i / n + S.hue + 0.05)));\n  const ref = sqrt((k * (n - k)) / (n - 1));\n  const cache = new Map();\n  const colour = (m) => {\n    let c = cache.get(m);\n    if (c) return c;\n    let x = 0, y = 0;\n    for (let i = 0; i \u003c n; i++) if (m & (1 \u003c\u003c i)) (x += hx[i]), (y += hy[i]);\n    const z = hypot(x, y) / ref;\n    c = hsv(atan2(y, x) / (2 * PI), 0.3 + 0.45 * smooth(0, 1.4, z), 1);\n    cache.set(m, c);\n    return c;\n  };\n  const d2 = new Float64Array(NMAX), id = new Int32Array(NMAX);\n  // Every prefix of the sorted list is the region of one order, so one pass\n  // counts the regions with an LED centre on the panel for every order.\n  const sets = [];\n  for (let j = 0; j \u003c n; j++) sets.push(new Set());\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      // All n distances, sorted by insertion: n is at most 18.\n      for (let i = 0; i \u003c n; i++) {\n        const v = (x + 0.5 - sx[i]) ** 2 + (y + 0.5 - sy[i]) ** 2;\n        let j = i;\n        while (j > 0 && d2[j - 1] > v) (d2[j] = d2[j - 1]), (id[j] = id[j - 1]), j--;\n        d2[j] = v;\n        id[j] = i;\n      }\n      let m = 0;\n      for (let j = 0; j \u003c k; j++) m |= 1 \u003c\u003c id[j];\n      let q = 0;\n      for (let j = 1; j \u003c n; j++) sets[j].add((q |= 1 \u003c\u003c id[j - 1]));\n      // The region ends where the k-th and the (k+1)-th nearest swap: the\n      // distance to the bisector of those two sites.\n      const a = id[k - 1], b = id[k];\n      const edge = (d2[k] - d2[k - 1]) / (2 * hypot(sx[a] - sx[b], sy[a] - sy[b]));\n      const c = colour(m);\n      const v = 0.76 + 0.24 * smooth(0, 7, edge), line = 1 - smooth(0.3, 1.1, edge);\n      let r = c[0] * v, g = c[1] * v, bl = c[2] * v;\n      r += (0.95 - r) * line;\n      g += (0.95 - g) * line;\n      bl += (0.95 - bl) * line;\n      // Under the chart the diagram goes on at a twelfth.\n      const f = y \u003c STRIP ? 255 : 21;\n      display.setPixel(x, y, r * f, g * f, bl * f);\n    }\n  for (let j = 1; j \u003c n; j++) S.panel[j] = sets[j].size;\n  // The farthest-point diagram: the smallest circle round all the sites,\n  // dotted, and its centre, which lies on the tree.\n  if (k === n - 1) {\n    const [cx, cy, R] = enclosing(S);\n    const steps = round(2 * PI * R);\n    for (let i = 0; i \u003c steps; i += 2) {\n      const x = round(cx + R * cos((2 * PI * i) / steps) - 0.5), y = round(cy + R * sin((2 * PI * i) / steps) - 0.5);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c STRIP) display.setPixel(x, y, 235, 235, 235);\n    }\n    const x = round(cx - 0.5), y = round(cy - 0.5);\n    for (let dy = -2; dy \u003c= 2; dy++)\n      for (let dx = -2; dx \u003c= 2; dx++) {\n        const r = max(abs(dx), abs(dy));\n        if (r === 1 || x + dx \u003c 0 || x + dx >= W || y + dy \u003c 0 || y + dy >= STRIP) continue;\n        if (r === 0) display.setPixel(x, y, 255, 255, 255);\n        else if (dx === 0 || dy === 0 || abs(dx) === abs(dy)) display.setPixel(x + dx, y + dy, 255, 255, 255);\n      }\n  }\n  // The sites, white with a dark rim.\n  for (let i = 0; i \u003c n; i++) {\n    const x = floor(sx[i]), y = floor(sy[i]);\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) display.setPixel(x + dx, y + dy, 20, 20, 30);\n    display.setPixel(x, y, 255, 255, 255);\n  }\n  // The chart: one bar for each order 1 to n - 1, as tall as its count of\n  // regions in the whole plane, the part that has an LED on the panel\n  // brighter, the bar of this order white with its count above it.\n  let fmax = 1;\n  for (let j = 1; j \u003c n; j++) fmax = max(fmax, S.plane[j]);\n  const bw = floor(60 / (n - 1)), x0 = floor((W - bw * (n - 1)) / 2);\n  for (let j = 1; j \u003c n; j++) {\n    const hp = max(1, round((7 * S.plane[j]) / fmax)), hv = min(hp, round((7 * S.panel[j]) / fmax)), on = j === k;\n    for (let r = 0; r \u003c hp; r++)\n      for (let c = 0; c \u003c bw - 1; c++) {\n        const lit = r \u003c hv;\n        const col = on ? (lit ? [255, 255, 255] : [120, 120, 130]) : lit ? [110, 125, 150] : [45, 50, 64];\n        display.setPixel(x0 + (j - 1) * bw + c, 127 - r, col[0], col[1], col[2]);\n      }\n  }\n  const txt = String(S.plane[k]), tw = txt.length * 4 - 1;\n  const tx = cl(round(x0 + (k - 1) * bw + (bw - 1) / 2 - tw / 2), 1, W - 1 - tw);\n  for (let c = 0; c \u003c txt.length; c++) {\n    const f = FIG[txt.charCodeAt(c) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (f[r * 3 + q] === \"1\") display.setPixel(tx + c * 4 + q, 115 + r, 255, 255, 255);\n  }\n}\n\n// The smallest circle holding every site: it passes through two sites on a\n// diameter or through three, so try every pair and triple. 18 sites make\n// 816 triples.\nfunction enclosing(S) {\n  const { n, sx, sy } = S;\n  let best = [0, 0, 1e9];\n  const holds = (cx, cy, r) => {\n    for (let i = 0; i \u003c n; i++) if ((sx[i] - cx) ** 2 + (sy[i] - cy) ** 2 > r * r + 1e-6) return false;\n    return true;\n  };\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      const cx = (sx[i] + sx[j]) / 2, cy = (sy[i] + sy[j]) / 2, r = hypot(sx[i] - sx[j], sy[i] - sy[j]) / 2;\n      if (r \u003c best[2] && holds(cx, cy, r)) best = [cx, cy, r];\n      for (let l = j + 1; l \u003c n; l++) {\n        const ax = sx[j] - sx[i], ay = sy[j] - sy[i], bx = sx[l] - sx[i], by = sy[l] - sy[i], dd = 2 * (ax * by - ay * bx);\n        if (abs(dd) \u003c 1e-9) continue;\n        const ux = (by * (ax * ax + ay * ay) - ay * (bx * bx + by * by)) / dd, uy = (ax * (bx * bx + by * by) - bx * (ax * ax + ay * ay)) / dd;\n        const R = hypot(ux, uy);\n        if (R \u003c best[2] && holds(sx[i] + ux, sy[i] + uy, R)) best = [sx[i] + ux, sy[i] + uy, R];\n      }\n    }\n  return best;\n}\n","string-art":"// ===== Patternflow pattern =====\n// Title:   String Art\n// Family:  type\n// Idea:    One thread is strung from pin to pin round the edge of the panel, each next pin picked greedily as the one whose straight chord best fills what the glyph still lacks and least lights what lies outside it, so a bold A, the Hangul syllable 실 (thread), a K and an ampersand come up one after another out of about four hundred lines of light on black, each strung in 12 s, held, faded and strung again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: computational string art, one continuous thread whose next pin is the greedy choice of the chord that most lowers the error against the picture (Petros Vrellis, A New Way to Knit, 2016); antialiased lines (Xiaolin Wu, 1991); the frame a superellipse (Gabriel Lamé, 1818); glyphs drawn here, the 실 included, pattern round 76\n// Round:   76\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spacing=2..8, Round=0..1\n//\n// Knob 1: Hue. Turns the thread colour round the wheel. At 0 the A is strung in cyan and its last threads have turned 0.14 of the wheel toward blue; each glyph after it starts 0.13 further round, so at 0 the 실 runs blue to violet, the K violet to pink and the ampersand pink to coral.\n// Knob 2: Speed. At 2 a glyph is strung in 12.3 s, slowly at first and last and about 54 threads a second in the middle, holds 3 s and fades in 1.2 s, 16.5 s a glyph. At 0.2 it is ten times slower and each thread can be seen running from its pin to the next.\n// Knob 3: Spacing. LEDs of frame between neighbouring pins, 2 to 8 in whole steps: 187 pins at 2, 94 at 4, 47 at 8. A glyph takes 2.25 threads a pin, 421 at 2 and 106 at 8, and fewer pins mean heavier threads, each twice as bright at 8 as at 2, so the A turns from a dense weave into a coarse lattice of separate lines.\n// Knob 4: Round. The shape of the frame the pins stand on, the superellipse |x/a|^n + |y/b|^n = 1 through the edges of the panel with n = 2 + 40 (1 - Round)^3: at 0.06 n is 35, a rectangle with its corners rounded by about an LED; at 0.5 n is 7; at 1 it is the ellipse inside the panel, Vrellis's round loom stretched to 64 by 128, 153 pins and the corners left dark. Turning Spacing or Round strings the glyph again from its first thread.\n// Buttons: K1 tap fades the glyph and starts the next.\n\n// The greedy step. Each LED has a target, 3.5 units of thread light times\n// how much of it the glyph covers, and the light the threads have left so\n// far. Adding a thread of light a along a chord changes the squared error by\n// a w (2 r - a w) at each LED it crosses with weight w, r the shortfall\n// there. Outside the glyph the target is 0, so a thread there only adds\n// error, counted 0.6 times. The chord from the current pin with the largest\n// gain per LED of length wins; a chord is used once. The target is set\n// above what 421 threads can give, so the glyph keeps drawing threads to\n// itself to the end instead of filling up and spilling. What shows is\n// (1 - exp(-light))^1.3 per colour channel, so one stray thread stays dim\n// and fifteen crossing on a stroke come near full brightness.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5, AX = 31.5, BY = 63.5;\nconst { floor, round, max, abs, sqrt, exp, pow, cos, sin, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Threads per pin; light a thread leaves per LED step with 188 pins; the\n// light the glyph asks for; the weight of light outside it; the display curve.\nconst PER_PIN = 2.25, ALPHA = 0.2, PIN0 = 188, TGT = 3.5, LAM = 0.6, GAM = 1.3;\n// Seconds at Speed 2: the first thread running out from its pin, the whole\n// build, the hold, the fade. HUE0 is the A's hue at Hue 0, cyan.\nconst T0 = 0.6, TB = 12.3, HOLD = 3, CUT = 1.2, HUE0 = 0.52;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Glyph primitives: [\"p\", x, y, x, y, ...] a filled polygon, [\"s\", x0, y0,\n// x1, y1, r] a stroke with round ends, [\"a\", cx, cy, R, r, from, to] an arc\n// of a ring, angles in degrees with y down (90 is the bottom).\nconst GLYPHS = [\n  // A\n  [\n    [\"p\", 25, 6, 39, 6, 18, 122, 4, 122],\n    [\"p\", 25, 6, 39, 6, 60, 122, 46, 122],\n    [\"p\", 12, 80, 52, 80, 52, 92, 12, 92],\n  ],\n  // 실\n  [\n    [\"s\", 24, 9, 6, 58, 6],\n    [\"s\", 18, 27, 40, 58, 6],\n    [\"p\", 46, 5, 58, 5, 58, 66, 46, 66],\n    [\"p\", 6, 72, 58, 72, 58, 81, 6, 81],\n    [\"p\", 48, 72, 58, 72, 58, 101, 48, 101],\n    [\"p\", 6, 92, 58, 92, 58, 101, 6, 101],\n    [\"p\", 6, 92, 16, 92, 16, 122, 6, 122],\n    [\"p\", 6, 113, 59, 113, 59, 122, 6, 122],\n  ],\n  // K\n  [\n    [\"p\", 5, 6, 19, 6, 19, 122, 5, 122],\n    [\"p\", 15, 62, 44, 6, 60, 6, 15, 90],\n    [\"p\", 27, 62, 37, 50, 61, 122, 45, 122],\n  ],\n  // &\n  [\n    [\"a\", 30, 25, 13, 5.5, 0, 360],\n    [\"s\", 21, 35, 59, 121, 6],\n    [\"s\", 39, 35, 9.5, 87, 5.5],\n    [\"a\", 28, 94, 20, 6, -30, 200],\n    [\"s\", 45.3, 84, 57, 68, 5.5],\n  ],\n];\n\nfunction inPoly(pr, x, y) {\n  let c = false;\n  for (let i = 1, j = pr.length - 2; i \u003c pr.length; j = i, i += 2) {\n    const xi = pr[i], yi = pr[i + 1], xj = pr[j], yj = pr[j + 1];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) c = !c;\n  }\n  return c;\n}\nfunction inside(g, x, y) {\n  for (const pr of g) {\n    if (pr[0] === \"p\" && inPoly(pr, x, y)) return true;\n    if (pr[0] === \"s\") {\n      const [, x0, y0, x1, y1, r] = pr, dx = x1 - x0, dy = y1 - y0;\n      const t = cl(((x - x0) * dx + (y - y0) * dy) / (dx * dx + dy * dy), 0, 1);\n      if ((x - x0 - t * dx) ** 2 + (y - y0 - t * dy) ** 2 \u003c r * r) return true;\n    }\n    if (pr[0] === \"a\") {\n      const [, cx, cy, R, r, a0, a1] = pr, d = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      if (abs(d - R) \u003c r) {\n        let a = (atan2(y - cy, x - cx) * 180) / PI;\n        while (a \u003c a0) a += 360;\n        if (a \u003c= a1) return true;\n      }\n    }\n  }\n  return false;\n}\n// Coverage of each LED by the glyph, 4 x 4 samples.\nfunction mask(g) {\n  const m = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let c = 0;\n      for (let j = 0; j \u003c 4; j++) for (let i = 0; i \u003c 4; i++) if (inside(g, x + (i + 0.5) / 4, y + (j + 0.5) / 4)) c++;\n      m[y * W + x] = c / 16;\n    }\n  return m;\n}\n\n// The frame is the superellipse |x/a|^n + |y/b|^n = 1 through the panel's\n// edges. norm() is its left side to the power 1/n, 1 on the frame.\nfunction norm(u, v, n) {\n  u = abs(u);\n  v = abs(v);\n  const m = max(u, v);\n  return m > 0 ? m * pow(pow(u / m, n) + pow(v / m, n), 1 / n) : 0;\n}\n// Pins every `sp` LEDs of arc round the frame, on LED centres.\nfunction pins(sp, n) {\n  const M = 1440, xs = [], ys = [], arc = [0];\n  for (let k = 0; k \u003c= M; k++) {\n    const f = (2 * PI * k) / M, c = cos(f), s = sin(f), r = 1 / norm(c / AX, s / BY, n);\n    xs.push(CX + r * c);\n    ys.push(CY + r * s);\n    if (k) arc.push(arc[k - 1] + sqrt((xs[k] - xs[k - 1]) ** 2 + (ys[k] - ys[k - 1]) ** 2));\n  }\n  const P = [];\n  for (let s = sp / 2, k = 0; s \u003c arc[M]; s += sp) {\n    while (arc[k + 1] \u003c s) k++;\n    const u = (s - arc[k]) / (arc[k + 1] - arc[k] || 1);\n    const x = cl(round(xs[k] + u * (xs[k + 1] - xs[k])), 0, W - 1), y = cl(round(ys[k] + u * (ys[k + 1] - ys[k])), 0, H - 1);\n    const q = P[P.length - 1];\n    if (!q || q.x !== x || q.y !== y) P.push({ x, y });\n  }\n  if (P.length > 1 && P[0].x === P[P.length - 1].x && P[0].y === P[P.length - 1].y) P.pop();\n  return P;\n}\n\n// Walk a chord LED by LED along its long axis, splitting each step between\n// the two LEDs either side of it (Xiaolin Wu, 1991). u is how much of the\n// chord, from a.\nfunction walk(a, b, u, fn) {\n  const dx = b.x - a.x, dy = b.y - a.y, n = max(abs(dx), abs(dy)), m = floor(n * u);\n  const sx = dx \u003c 0 ? -1 : 1, sy = dy \u003c 0 ? -1 : 1;\n  if (abs(dx) >= abs(dy))\n    for (let k = 0; k \u003c= m; k++) {\n      const x = a.x + sx * k, y = a.y + (dy * k) / n, yi = floor(y), f = y - yi;\n      fn(x + yi * W, 1 - f);\n      if (f > 1e-6 && yi + 1 \u003c H) fn(x + (yi + 1) * W, f);\n    }\n  else\n    for (let k = 0; k \u003c= m; k++) {\n      const y = a.y + sy * k, x = a.x + (dx * k) / n, xi = floor(x), f = x - xi;\n      fn(xi + y * W, 1 - f);\n      if (f > 1e-6 && xi + 1 \u003c W) fn(xi + 1 + y * W, f);\n    }\n}\n\nfunction newGlyph(S, gi) {\n  S.gi = ((gi % GLYPHS.length) + GLYPHS.length) % GLYPHS.length;\n  S.mask = mask(GLYPHS[S.gi]);\n  S.P = pins(S.sp, S.n);\n  // Fewer pins, fewer and heavier threads.\n  S.nt = round(PER_PIN * S.P.length);\n  S.al = ALPHA * sqrt(PIN0 / S.P.length);\n  S.acc.fill(0);\n  S.rgb.fill(0);\n  Object.assign(S, { laid: 0, used: new Set(), t: 0, phase: 0, fade: 1, at: 0, u: 0 });\n  // The thread is tied on at the pin nearest the bottom left corner.\n  let best = 1e9;\n  S.P.forEach((p, i) => {\n    const d = (p.x - 8) ** 2 + (p.y - H) ** 2;\n    if (d \u003c best) (best = d), (S.at = i);\n  });\n  S.next = choose(S);\n}\n\n// The greedy step: from the pin the thread is on, the chord whose light most\n// lowers the squared error against the glyph, per LED of its length. Light\n// outside the glyph counts LAM times. A chord whose middle lies within 2.5\n// LEDs of the frame would only hug the frame, and none is used twice.\nfunction choose(S) {\n  const P = S.P, a = P[S.at], acc = S.acc, m = S.mask, al = S.al;\n  let best = -1e18, bi = -1;\n  for (let j = 0; j \u003c P.length; j++) {\n    const b = P[j], key = S.at \u003c j ? S.at * 4096 + j : j * 4096 + S.at;\n    if (j === S.at || S.used.has(key)) continue;\n    const mx = (a.x + b.x) / 2 - CX, my = (a.y + b.y) / 2 - CY;\n    if ((1 - norm(mx / AX, my / BY, S.n)) * AX \u003c 2.5) continue;\n    let sc = 0;\n    walk(a, b, 1, (i, w) => {\n      const c = m[i], r = TGT * c - acc[i];\n      sc += (c + LAM * (1 - c)) * w * (2 * r - al * w);\n    });\n    sc /= sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);\n    if (sc > best) (best = sc), (bi = j);\n  }\n  return bi;\n}\n\n// Thread k's colour: the glyph's hue, turning 0.14 round the wheel from the\n// first thread to the last.\nconst tint = (S, k, o) => hsv(S.hue + HUE0 + S.gi * 0.13 + (0.14 * k) / S.nt, 0.6, 1, o);\n\nfunction lay(S) {\n  const a = S.P[S.at], b = S.P[S.next], col = S.tc;\n  tint(S, S.laid, col);\n  walk(a, b, 1, (i, w) => {\n    const l = S.al * w, k = i * 3;\n    S.acc[i] += l;\n    S.rgb[k] += l * col[0];\n    S.rgb[k + 1] += l * col[1];\n    S.rgb[k + 2] += l * col[2];\n  });\n  S.used.add(S.at \u003c S.next ? S.at * 4096 + S.next : S.next * 4096 + S.at);\n  S.at = S.next;\n  S.laid++;\n  S.next = choose(S);\n}\n\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst tone = (a) => pow(1 - exp(-a), GAM);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, sp: 2, n: 40, rk: 0, started: false, btn: false, gi: 0,\n    acc: new Float32Array(N), rgb: new Float32Array(N * 3), part: new Float32Array(N), tc: [1, 1, 1], pc: [1, 1, 1],\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const sp = round(cl(k[2] == null ? 2 : k[2], 2, 8)), rk = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started || sp !== S.sp || abs(rk - S.rk) > 0.02) {\n    S.sp = sp;\n    S.rk = rk;\n    S.n = 2 + 40 * (1 - rk) ** 3;\n    newGlyph(S, S.gi);\n    S.started = true;\n  } else if (btn && !S.btn && S.phase \u003c 2) (S.phase = 2), (S.t = 0);\n  S.btn = btn;\n  S.t += (d * S.speed) / 2;\n  if (S.phase === 0) {\n    // The first thread runs out over T0, then the rest follow on an S-curve.\n    const want = max(S.nt * ease((S.t - T0) / (TB - T0)), cl(S.t / T0, 0, 1));\n    while (S.laid + 1 \u003c= want && S.laid \u003c S.nt && S.next >= 0) lay(S);\n    S.u = cl(want - S.laid, 0, 1);\n    if (S.laid >= S.nt || S.next \u003c 0) (S.phase = 1), (S.t = 0);\n  } else if (S.phase === 1) {\n    if (S.t >= HOLD) (S.phase = 2), (S.t = 0);\n  } else {\n    S.fade = cl(1 - S.t / CUT, 0, 1);\n    if (S.t >= CUT) newGlyph(S, S.gi + 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, f = S.fade, part = S.part, tc = S.tc;\n  part.fill(0);\n  // The thread being laid, as far as it has got.\n  if (S.phase === 0 && S.next >= 0 && S.u > 0) {\n    tint(S, S.laid, tc);\n    walk(S.P[S.at], S.P[S.next], S.u, (i, w) => (part[i] += S.al * w));\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const kk = i * 3, p = part[i];\n    display.setPixel(i % W, floor(i / W), round(tone(rgb[kk] + p * tc[0]) * f * 255), round(tone(rgb[kk + 1] + p * tc[1]) * f * 255), round(tone(rgb[kk + 2] + p * tc[2]) * f * 255));\n  }\n  // The pins.\n  hsv(S.hue + HUE0 + S.gi * 0.13, 0.15, 0.3, S.pc);\n  const pc = S.pc;\n  for (const p of S.P) display.setPixel(p.x, p.y, round(pc[0] * 255), round(pc[1] * 255), round(pc[2] * 255));\n  // Below Speed 1 a thread takes long enough to follow, and the point it has\n  // reached shows as a bright needle.\n  const nd = cl((1 - S.speed) / 0.5, 0, 1);\n  if (nd > 0 && S.phase === 0 && S.next >= 0 && S.u > 0) {\n    const a = S.P[S.at], b = S.P[S.next], x = round(a.x + (b.x - a.x) * S.u), y = round(a.y + (b.y - a.y) * S.u);\n    const v = 255 * nd * f;\n    display.setPixel(x, y, round(v * (0.6 + 0.4 * tc[0])), round(v * (0.6 + 0.4 * tc[1])), round(v * (0.6 + 0.4 * tc[2])));\n  }\n}\n","coded-aperture":"// ===== Patternflow pattern =====\n// Title:   Coded Aperture\n// Family:  type\n// Idea:    A glowing word shines through a card punched with a modified uniformly redundant array onto a detector where photons land one by one as an unreadable jumble of overlapping shadows, and correlating that jumble with the array's decoding pattern brings the word up out of the noise as the counts pile up, until the 6 s exposure ends and the detector is cleared.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: coded aperture imaging with random arrays of pinholes (Robert H. Dicke, 1968; J. G. Ables, 1968), uniformly redundant arrays (E. E. Fenimore and T. M. Cannon, 1978), modified uniformly redundant arrays from quadratic residues (S. R. Gottesman and E. E. Fenimore, 1989), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Rate=0.2..3, Mask=0..2, Word=0..3\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the word, the light in the holes and the decoded word are pale gold and the photons on the detector cyan.\n// Knob 2: Rate. Photons a second through the coded card, 1500 per unit: 3000 at 2, 300 at 0.2, 4500 at 3, on top of a detector background of 1 count per element a second. Every exposure lasts 6 s and holds its result 1.2 s, so the rate sets how clear the word comes up: at the end it stands 3.8 noise widths above the empty sky at 2, 0.9 at 0.2 and 4.7 at 3.\n// Knob 3: Mask. 0 is the MURA for p = 17, 144 holes of 289. 1 is a random card about half open, the kind Dicke and Ables proposed, decoded by balanced correlation; even without noise its shadows do not cancel, so 15 of STAR's 34 elements come out under half bright and a ghost in the sky reaches 38%. 2 is one pinhole in the middle. Every hole passes the same light, so in the same 6 s the pinhole gathers 123 photons among 1740 background counts, and the word ends 1.5 noise widths clear against 2.6 for the random card and 3.8 for the MURA.\n// Knob 4: Word. What shines above the card: STAR, CRAB, VELA or LUX, in 3 by 5 letters on the 17 by 17 sky. The fewer the lit elements, the clearer the decoded word: LUX, 27 elements, ends at 4.7 where STAR, 34, ends at 3.8.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Geometry. The sky, the card and the detector are all 17 by 17\n// elements, one element 3 LEDs wide and 2 tall, so each band is 51 by 34.\n// From the top: the word (sky rows 5 to 11 only), the card, the detector,\n// and the decoded sky.\nconst P = 17, C = 8, NE = P * P;\nconst CW = 3, CH = 2, X0 = 6, BW = P * CW, BH = P * CH;\nconst Y_OBJ = 0, OBJ_R0 = 5, OBJ_R1 = 11, Y_MASK = 18, Y_DET = 56, Y_DEC = 94;\nconst EXPO = 6, HOLD = 1.2, CYCLE = EXPO + HOLD;\n// Detector background, counts per element per second, the same for every\n// mask: the cosmic-ray and radioactive counts an X-ray detector sees.\nconst BKG = 1;\n// The pattern opens 0.6 s into an exposure, so that 2 s in the word\n// already stands about 2.5 noise widths clear.\nconst T0 = 0.6;\n\n// ---- Letters, 3 by 5, on sky rows 6 to 10.\nconst FONT = {\n  S: [\".##\", \"#..\", \".#.\", \"..#\", \"##.\"], T: [\"###\", \".#.\", \".#.\", \".#.\", \".#.\"],\n  A: [\".#.\", \"#.#\", \"###\", \"#.#\", \"#.#\"], R: [\"##.\", \"#.#\", \"##.\", \"#.#\", \"#.#\"],\n  C: [\".##\", \"#..\", \"#..\", \"#..\", \".##\"], B: [\"##.\", \"#.#\", \"##.\", \"#.#\", \"##.\"],\n  V: [\"#.#\", \"#.#\", \"#.#\", \"#.#\", \".#.\"], E: [\"###\", \"#..\", \"##.\", \"#..\", \"###\"],\n  L: [\"#..\", \"#..\", \"#..\", \"#..\", \"###\"], U: [\"#.#\", \"#.#\", \"#.#\", \"#.#\", \"###\"],\n  X: [\"#.#\", \"#.#\", \".#.\", \"#.#\", \"#.#\"],\n};\nconst WORDS = [\"STAR\", \"CRAB\", \"VELA\", \"LUX\"];\n\nfunction sky(word) {\n  const O = new Uint8Array(NE), n = word.length, c0 = floor((P - (4 * n - 1)) / 2);\n  for (let k = 0; k \u003c n; k++)\n    for (let r = 0; r \u003c 5; r++) for (let c = 0; c \u003c 3; c++) if (FONT[word[k]][r][c] === \"#\") O[(6 + r) * P + c0 + 4 * k + c] = 1;\n  const lit = [];\n  for (let e = 0; e \u003c NE; e++) if (O[e]) lit.push(e);\n  return { O, lit };\n}\n\n// ---- The cards, in display coordinates with the centre at (C, C). A photon\n// from sky element s through hole h lands on detector element d = h - s + C\n// (mod 17, each axis): the shadow of the whole card, shifted, as when the\n// card is the 2 by 2 mosaic of one period. Decoding is the periodic\n// correlation dec(o) = sum over d of D(d) Q(d + o - C), and for the MURA\n// sum over x of M(x) Q(x + t) is 144 at t = 0 and exactly 0 everywhere else,\n// so a noiseless detector decodes to 144 times the sky. Q sums to 1, so a\n// flat background adds a flat offset.\nfunction cards() {\n  const q = new Int8Array(P).fill(-1);\n  for (let x = 1; x \u003c P; x++) q[(x * x) % P] = 1;\n  const mura = { M: new Uint8Array(NE), Q: new Int8Array(NE) };\n  for (let i = 0; i \u003c P; i++)\n    for (let j = 0; j \u003c P; j++) {\n      // Gottesman and Fenimore: row 0 closed, column 0 open, else open where\n      // both indices are residues or both are not.\n      const a = i === 0 ? 0 : j === 0 ? 1 : q[i] * q[j] === 1 ? 1 : 0;\n      const e = ((i + C) % P) * P + ((j + C) % P);\n      mura.M[e] = a;\n      mura.Q[e] = i === 0 && j === 0 ? 1 : a ? 1 : -1;\n    }\n  // Dicke's and Ables's random card: each element open with chance 1/2, from\n  // a fixed hash so the card is the same every time. Decoded with 2M - 1.\n  const rand = { M: new Uint8Array(NE), Q: new Int8Array(NE) };\n  for (let e = 0; e \u003c NE; e++) {\n    let h = (e * 2654435761 + 12345) >>> 0;\n    h ^= h >>> 15; h = Math.imul(h, 0x2c1b3c6d) >>> 0; h ^= h >>> 12; h = Math.imul(h, 0x297a2d39) >>> 0; h ^= h >>> 15;\n    rand.M[e] = (h >>> 0) % 1000 \u003c 498 ? 1 : 0;\n    rand.Q[e] = rand.M[e] ? 1 : -1;\n  }\n  const pin = { M: new Uint8Array(NE), Q: new Int8Array(NE) };\n  pin.M[C * P + C] = 1;\n  pin.Q[C * P + C] = 1;\n  return [mura, rand, pin].map((m) => {\n    const holes = [];\n    let sq = 0;\n    for (let e = 0; e \u003c NE; e++) {\n      if (m.M[e]) holes.push(e);\n      sq += m.Q[e];\n    }\n    return { ...m, holes, sq };\n  });\n}\nconst KMURA = 144;\n\nfunction gauss() {\n  const u = Math.random() || 1e-9, v = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * v);\n}\nfunction poisson(l) {\n  if (l \u003c= 0) return 0;\n  if (l > 30) return max(0, round(l + sqrt(l) * gauss()));\n  const L = exp(-l);\n  let k = 0, p = Math.random();\n  while (p > L) {\n    k++;\n    p *= Math.random();\n  }\n  return k;\n}\n\nfunction clear(S) {\n  // What the last exposure decoded fades out in about a quarter second.\n  if (S.view) {\n    S.oldDec.set(S.view);\n    S.oldA = 1;\n  }\n  S.D.fill(0);\n  S.dD.fill(0);\n  S.dec.fill(0);\n  S.cnt.fill(0);\n  S.nWord = 0;\n  S.nBkg = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    cards: cards(), mode: -1, word: -1, hue: 0, rate: 3000, t: 0, sky: null,\n    D: new Float32Array(NE), dD: new Float32Array(NE), dec: new Float32Array(NE),\n    cnt: new Float32Array(BW * BH), flash: new Float32Array(BW * BH), hole: new Float32Array(NE), spark: new Float32Array(NP),\n    nWord: 0, nBkg: 0, rgb: new Float32Array(NP * 3), wrap: new Int32Array(3 * P),\n    view: new Float32Array(NE), oldDec: new Float32Array(NE), oldA: 0,\n  });\n  for (let x = 0; x \u003c 3 * P; x++) S.wrap[x] = x % P;\n}\n\nfunction land(S, d, flash) {\n  S.D[d]++;\n  S.dD[d]++;\n  const di = floor(d / P), dj = d - di * P;\n  const led = (di * CH + floor(Math.random() * CH)) * BW + dj * CW + floor(Math.random() * CW);\n  S.cnt[led]++;\n  S.flash[led] = min(1.6, S.flash[led] + flash);\n}\n\nfunction spark(S, x, y) {\n  const i = y * W + x;\n  S.spark[i] = min(1.2, S.spark[i] + 0.7);\n}\n\nfunction expose(S, dt) {\n  const card = S.cards[S.mode], lit = S.sky.lit, holes = card.holes;\n  // Equal exposure: every hole passes the same flux, so the photon count\n  // scales with the number of holes.\n  const n = poisson((S.rate * dt * holes.length) / KMURA);\n  for (let k = 0; k \u003c n; k++) {\n    const s = lit[floor(Math.random() * lit.length)], h = holes[floor(Math.random() * holes.length)];\n    const si = floor(s / P), sj = s - si * P, hi = floor(h / P), hj = h - hi * P;\n    land(S, ((hi - si + C + P) % P) * P + ((hj - sj + C + P) % P), 1);\n    S.hole[h] = min(1, S.hole[h] + 0.5);\n    // One photon in three is drawn in flight, in the gaps above and below\n    // the card, over the element it left and the hole it went through.\n    if (Math.random() \u003c 0.33) {\n      spark(S, X0 + sj * CW + floor(Math.random() * CW), Y_MASK - 4 + floor(Math.random() * 4));\n      spark(S, X0 + hj * CW + floor(Math.random() * CW), Y_DET - 4 + floor(Math.random() * 4));\n    }\n  }\n  S.nWord += n;\n  const b = poisson(BKG * NE * dt);\n  for (let k = 0; k \u003c b; k++) land(S, floor(Math.random() * NE), 0.8);\n  S.nBkg += b;\n  // Fold this frame's counts into the decoded sky.\n  const Q = card.Q, wrap = S.wrap, dec = S.dec;\n  for (let d = 0; d \u003c NE; d++) {\n    const c = S.dD[d];\n    if (!c) continue;\n    S.dD[d] = 0;\n    const di = floor(d / P), dj = d - di * P;\n    for (let oi = 0; oi \u003c P; oi++) {\n      const row = wrap[di + oi - C + P] * P, base = oi * P;\n      for (let oj = 0; oj \u003c P; oj++) dec[base + oj] += c * Q[row + wrap[dj + oj - C + P]];\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.rate = 1500 * cl(k[1], 0.2, 3);\n  const mode = cl(round(k[2]), 0, 2), word = cl(round(k[3]), 0, 3);\n  if (mode !== S.mode || word !== S.word) {\n    if (S.mode \u003c 0) S.t = T0;\n    S.mode = mode;\n    S.word = word;\n    S.sky = sky(WORDS[word]);\n    clear(S);\n    if (S.t > 0) {\n      // Open on an exposure already under way: replay the time since it began.\n      const was = S.t;\n      S.t = 0;\n      while (S.t \u003c was) {\n        expose(S, min(0.1, was - S.t));\n        S.t += 0.1;\n      }\n      S.t = was;\n      S.flash.fill(0);\n    }\n  }\n  const fade = exp(-d / 0.12), hf = exp(-d / 0.08);\n  for (let i = 0; i \u003c S.flash.length; i++) S.flash[i] *= fade;\n  for (let i = 0; i \u003c NE; i++) S.hole[i] *= hf;\n  for (let i = 0; i \u003c NP; i++) S.spark[i] *= hf;\n  S.t += d;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    clear(S);\n  }\n  S.oldA *= exp(-d / 0.12);\n  if (S.t \u003c EXPO) expose(S, d);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.sky) return;\n  const rgb = S.rgb, card = S.cards[S.mode], O = S.sky.O;\n  const gold = hsv(0.12 + S.hue, 0.38, 1), cyan = hsv(0.52 + S.hue, 0.55, 1), night = hsv(0.62 + S.hue, 0.5, 0.035);\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += c[0] * a;\n    rgb[o + 1] += c[1] * a;\n    rgb[o + 2] += c[2] * a;\n  };\n  // The word, with a soft glow round it.\n  for (let r = OBJ_R0; r \u003c= OBJ_R1; r++)\n    for (let j = 0; j \u003c P; j++)\n      for (let y = 0; y \u003c CH; y++)\n        for (let x = 0; x \u003c CW; x++) {\n          const px = X0 + j * CW + x, py = Y_OBJ + (r - OBJ_R0) * CH + y;\n          let g = 0;\n          for (let dr = -1; dr \u003c= 1; dr++)\n            for (let dj = -1; dj \u003c= 1; dj++) {\n              const rr = r + dr, jj = j + dj;\n              if (rr >= 0 && rr \u003c P && jj >= 0 && jj \u003c P && O[rr * P + jj]) g += dr || dj ? 0.05 : 0;\n            }\n          put(px, py, O[r * P + j] ? gold : night, O[r * P + j] ? 0.95 : 1);\n          put(px, py, gold, g);\n        }\n  // The card: dark, the holes lit from above, flickering as photons pass.\n  const plate = hsv(0.6 + S.hue, 0.25, 0.05), lightC = hsv(0.12 + S.hue, 0.3, 1);\n  for (let e = 0; e \u003c NE; e++) {\n    const i = floor(e / P), j = e - i * P;\n    for (let y = 0; y \u003c CH; y++)\n      for (let x = 0; x \u003c CW; x++) {\n        const px = X0 + j * CW + x, py = Y_MASK + i * CH + y;\n        if (card.M[e]) put(px, py, lightC, (y === 0 ? 0.42 : 0.3) + 0.35 * S.hole[e]);\n        else put(px, py, plate, 1);\n      }\n  }\n  // The detector: counts per LED, and each new photon a flash.\n  // Linear in counts, so the overlapping shadows show through the grain:\n  // the mean LED reaches 0.4 at the end of an exposure through the MURA.\n  const ref = (S.rate * EXPO + BKG * NE * EXPO) / (BW * BH);\n  for (let y = 0; y \u003c BH; y++)\n    for (let x = 0; x \u003c BW; x++) {\n      const i = y * BW + x, v = (S.cnt[i] / ref) * 0.4, f = S.flash[i];\n      put(X0 + x, Y_DET + y, cyan, v);\n      put(X0 + x, Y_DET + y, [1, 1, 1], 0.5 * f);\n    }\n  // The decoded sky: counts per sky element, the background's flat offset\n  // taken off, stretched so the word reaches 1 at the end of an exposure.\n  const full = (S.rate * EXPO * card.holes.length) / KMURA / S.sky.lit.length;\n  const off = (S.nBkg / NE) * card.sq;\n  for (let e = 0; e \u003c NE; e++) {\n    const i = floor(e / P), j = e - i * P;\n    const v = (S.view[e] = cl((S.dec[e] - off) / full, 0, 1.3));\n    const u = max(v, S.oldDec[e] * S.oldA);\n    for (let y = 0; y \u003c CH; y++)\n      for (let x = 0; x \u003c CW; x++) {\n        put(X0 + j * CW + x, Y_DEC + i * CH + y, night, 1);\n        put(X0 + j * CW + x, Y_DEC + i * CH + y, gold, 0.85 * u);\n      }\n  }\n  // The exposure clock: a thread under the detector that runs out over the\n  // 6 s and stays full while the decoded word holds.\n  const run = min(1, S.t / EXPO) * BW;\n  for (let x = 0; x \u003c run; x++) put(X0 + x, Y_DET + BH + 1, cyan, 0.3);\n  for (let p = 0; p \u003c NP; p++) if (S.spark[p] > 0.01) put(p % W, floor(p / W), p \u003c Y_MASK * W ? gold : lightC, 0.6 * S.spark[p]);\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3;\n    display.setPixel(p % W, floor(p / W), min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n  }\n}\n","euler-strokes":"// ===== Patternflow pattern =====\n// Title:   Euler Strokes\n// Family:  type\n// Idea:    A pen writes a word stacked down the panel letter by letter, each letter a graph of stroke ends, corners and junctions, in exactly as many strokes as Euler's count of its odd vertices allows, following a Hierholzer route: the unwritten skeleton is faintly tinted with the stroke each piece will belong to, the odd vertices glow before the pen reaches them, each pen lift leaves a faint dashed trail, and beside each letter a digit and a row of pips keep its stroke count.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the seven bridges of Königsberg and the odd-vertex count (Leonhard Euler, Solutio problematis ad geometriam situs pertinentis, 1736), the construction of an Euler path (Carl Hierholzer, 1873), one-stroke drawing (한붓그리기), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Order=0..1\n//\n// Knob 1: Hue. Turns every colour together. At 0 the first stroke of a letter is cyan, the second magenta, the third gold, the fourth green; the marks where strokes start and end are warm white on odd vertices and rose on even ones, and fresh ink is white hot for about 0.7 s.\n// Knob 2: Speed. At 2 the pen writes 34 LEDs a second, travels with the pen up at 90 and rests 0.12 s on each touch and lift. PATH takes 10.5 to 10.8 s in the Euler order and 12.6 s in school order, then holds for 1.8 s and fades for 0.9 s before it is written again. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. PATH (1, 2, 2 and 3 strokes), 다리 (bridge: 3 and 2), EULER (2, 1, 1, 2, 1) or 한붓 (one brush: 6 and 6), the counts in the Euler order. Each letter is a vertex and edge list in the code; the word stacks one letter per cell down the 128 rows.\n// Knob 4: Order. Below 0.5 the pen takes the fewest strokes, max(1, odd/2) for each connected piece, on a Hierholzer route that pairs the spare odd vertices with short pen-up hops, and each pass picks a new route of the same count (H has 11, 붓 32 seen in 3000 passes). Above 0.5 it follows school stroke order instead (ball and stick print for the Latin letters, 필순 for Hangul), and the counts grow: PATH 10 against 8, 다리 8 against 5, EULER 12 against 7, 한붓 14 against 12. A ring stays where each stroke touched down or lifted. Rose rings sit on even vertices: in the Euler order only a closed piece (the ring of ㅎ) touches one, in school order P, A, E, ㄷ, ㄹ and ㅂ do too.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, sin, cos, exp, abs, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters as graphs. v is the vertex list (x, y pairs, y down) in a box\n// 10 by 14 for a Latin capital and 14 by 14 for a Hangul syllable. An edge is\n// [a, b] or [a, b, points between]; c is the school stroke order, each stroke\n// a list of edges, ~i for edge i run from b to a.\nconst arc = (cx, cy, rx, ry, a0, a1, n) => {\n  const o = [];\n  for (let i = 1; i \u003c n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n;\n    o.push(cx + rx * cos(a), cy + ry * sin(a));\n  }\n  return o;\n};\nconst bowl = () => [5.5, 0, ...arc(5.5, 3.75, 4, 3.75, -PI / 2, PI / 2, 10), 5.5, 7.5];\nconst GLYPHS = {\n  // P: the stem's top has degree 2, the joint 3, the foot 1. One stroke.\n  P: { v: [1.5, 0, 1.5, 7.5, 1.5, 14], e: [[0, 1], [1, 2], [0, 1, bowl()]], c: [[0, 1], [2]] },\n  // A: apex 2, feet 1, the crossbar's ends 3. Two strokes.\n  A: { v: [5, 0, 0.5, 14, 9.5, 14, 2.11, 9, 7.89, 9], e: [[0, 3], [3, 1], [0, 4], [4, 2], [3, 4]], c: [[0, 1], [2, 3], [4]] },\n  // T: three ends and a junction of 3. Two strokes.\n  T: { v: [0.5, 0, 5, 0, 9.5, 0, 5, 14], e: [[0, 1], [1, 2], [1, 3]], c: [[2], [0, 1]] },\n  // H: four ends and two junctions, six odd vertices. Three strokes.\n  H: { v: [1, 0, 1, 7, 1, 14, 9, 0, 9, 7, 9, 14], e: [[0, 1], [1, 2], [3, 4], [4, 5], [1, 4]], c: [[0, 1], [2, 3], [4]] },\n  // E: three bar ends and the middle junction are odd, the corners even. Two strokes.\n  E: { v: [9, 0, 1, 0, 1, 7, 8, 7, 1, 14, 9, 14], e: [[1, 0], [1, 2], [2, 4], [2, 3], [4, 5]], c: [[1, 2], [0], [3], [4]] },\n  U: { v: [1, 0, 9, 0], e: [[0, 1, [1, 9.5, ...arc(5, 9.5, 4, 4.5, PI, 0, 12), 9, 9.5]]], c: [[0]] },\n  L: { v: [1.5, 0, 1.5, 14, 9, 14], e: [[0, 1], [1, 2]], c: [[0, 1]] },\n  // R: the leg leaves from the joint, which takes degree 4. One stroke.\n  R: { v: [1.5, 0, 1.5, 7.5, 1.5, 14, 9.5, 14], e: [[0, 1], [1, 2], [0, 1, bowl()], [1, 3]], c: [[0, 1], [2, 3]] },\n  // 다: ㄷ is an open path (1), ㅏ a stem with a branch (2).\n  다: {\n    v: [7.2, 2.2, 1, 2.2, 1, 11.8, 7.6, 11.8, 10.4, 0, 10.4, 7, 10.4, 14, 13.4, 7],\n    e: [[0, 1], [1, 2], [2, 3], [4, 5], [5, 6], [5, 7]],\n    c: [[~0], [1, 2], [3, 4], [5]],\n  },\n  // 리: ㄹ is one zigzag (1, written as 3), ㅣ a line (1).\n  리: {\n    v: [1, 1.2, 7.4, 1.2, 7.4, 7, 1, 7, 1, 12.8, 7.8, 12.8, 11, 0, 11, 14],\n    e: [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [6, 7]],\n    c: [[0, 1], [~2], [3, 4], [5]],\n  },\n  // 한: ㅎ is three pieces (tick, bar, ring), ㅏ two strokes, ㄴ one.\n  한: {\n    v: [4.3, 0.2, 4.3, 1.5, 1, 2.4, 7.6, 2.4, 4.3, 3.5, 4.3, 8.1, 10.6, 0, 10.6, 4.6, 10.6, 9.2, 13.4, 4.6, 1.6, 10.2, 1.6, 13.6, 13, 13.6],\n    e: [[0, 1], [2, 3], [4, 5, arc(4.3, 5.8, 2.6, 2.3, -PI / 2, -1.5 * PI, 10)], [5, 4, arc(4.3, 5.8, 2.6, 2.3, PI / 2, -PI / 2, 10)], [6, 7], [7, 8], [7, 9], [10, 11], [11, 12]],\n    c: [[0], [1], [2, 3], [4, 5], [6], [7, 8]],\n  },\n  // 붓: ㅂ has four odd vertices (2, written as 4), ㅜ 2, ㅅ 2.\n  붓: {\n    v: [2.5, 0.3, 2.5, 2.7, 2.5, 5.2, 11.5, 0.3, 11.5, 2.7, 11.5, 5.2, 0.5, 7.2, 7, 7.2, 13.5, 7.2, 7, 9.6, 7, 10.3, 2.6, 13.8, 5.4, 11.57, 11.4, 13.8],\n    e: [[0, 1], [1, 2], [3, 4], [4, 5], [1, 4], [2, 5], [6, 7], [7, 8], [7, 9], [10, 12], [12, 11], [12, 13]],\n    c: [[0, 1], [2, 3], [4], [5], [6, 7], [8], [9, 10], [11]],\n  },\n};\nconst WORDS = [[\"P\", \"A\", \"T\", \"H\"], [\"다\", \"리\"], [\"E\", \"U\", \"L\", \"E\", \"R\"], [\"한\", \"붓\"]];\nconst STROKE_HUE = [0, 0.36, 0.62, 0.8, 0.2, 0.5, 0.27, 0.9];\n\n// 3 by 5 digits for the counts.\nconst DIGITS = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7292, 0x7bef, 0x7bcf];\n\n// Pen speeds in LEDs per second and rests in seconds, at Speed 2.\nconst V_DOWN = 34, V_UP = 90, REST = 0.12, HOLD = 1.8, FADE = 0.9;\n\n// ---- Euler's count and Hierholzer's route. Each connected piece with 2k odd\n// vertices is drawn in k strokes: k - 1 pen-up hops pair off all but two odd\n// vertices, the walk starts at one of those two, and Hierholzer's splice\n// finds a walk that uses every edge once. The hops are where it lifts.\nfunction* matchings(a) {\n  if (!a.length) {\n    yield [];\n    return;\n  }\n  const [x, ...rest] = a;\n  for (let i = 0; i \u003c rest.length; i++) {\n    const y = rest[i], others = rest.filter((_, j) => j !== i);\n    for (const m of matchings(others)) yield [[x, y], ...m];\n  }\n}\n\nfunction eulerOrder(g) {\n  const nv = g.v.length / 2, deg = new Array(nv).fill(0), par = [...Array(nv).keys()];\n  const find = (x) => (par[x] === x ? x : (par[x] = find(par[x])));\n  for (const [a, b] of g.e) {\n    deg[a]++;\n    deg[b]++;\n    par[find(a)] = find(b);\n  }\n  const key = (i) => g.v[2 * i + 1] + 0.6 * g.v[2 * i];\n  const dist = (a, b) => hypot(g.v[2 * a] - g.v[2 * b], g.v[2 * a + 1] - g.v[2 * b + 1]);\n  const comps = new Map();\n  for (let i = 0; i \u003c nv; i++) if (deg[i]) (comps.get(find(i)) || comps.set(find(i), []).get(find(i))).push(i);\n  const list = [...comps.values()].sort((A, B) => min(...A.map(key)) - min(...B.map(key)));\n  const strokes = [];\n  for (const C of list) {\n    const odd = C.filter((i) => deg[i] & 1);\n    let s = C.reduce((a, b) => (key(a) \u003c= key(b) ? a : b)), hops = [];\n    if (odd.length) {\n      let best = Infinity;\n      for (const si of odd)\n        for (const ti of odd) {\n          if (si === ti) continue;\n          for (const m of matchings(odd.filter((x) => x !== si && x !== ti))) {\n            let c = 0.15 * key(si) + 0.8 * Math.random();\n            for (const [a, b] of m) c += dist(a, b);\n            if (c \u003c best) (best = c), (s = si), (hops = m);\n          }\n        }\n    }\n    // The piece's edges and the hops, with each vertex's list shuffled so\n    // each pass can take another route of the same count.\n    const ids = [], ends = [];\n    g.e.forEach((e, i) => {\n      if (find(e[0]) === find(C[0])) ids.push(i), ends.push([e[0], e[1]]);\n    });\n    for (const [a, b] of hops) ids.push(-1), ends.push([a, b]);\n    const adj = new Map();\n    ends.forEach(([a, b], j) => {\n      for (const x of [a, b]) (adj.get(x) || adj.set(x, []).get(x)).push(j);\n    });\n    for (const l of adj.values())\n      for (let i = l.length - 1; i > 0; i--) {\n        const j = floor(Math.random() * (i + 1));\n        [l[i], l[j]] = [l[j], l[i]];\n      }\n    const used = new Uint8Array(ends.length), ptr = new Map(), stack = [[s, -1]], walk = [];\n    while (stack.length) {\n      const [v, j] = stack[stack.length - 1], l = adj.get(v) || [];\n      let p = ptr.get(v) || 0, moved = false;\n      while (p \u003c l.length) {\n        const jj = l[p++];\n        if (used[jj]) continue;\n        used[jj] = 1;\n        stack.push([ends[jj][0] === v ? ends[jj][1] : ends[jj][0], jj]);\n        moved = true;\n        break;\n      }\n      ptr.set(v, p);\n      if (!moved) {\n        stack.pop();\n        if (j >= 0) walk.push([j, v]);\n      }\n    }\n    walk.reverse();\n    let at = s, cur = [];\n    for (const [j, to] of walk) {\n      if (ids[j] \u003c 0) {\n        if (cur.length) strokes.push(cur);\n        cur = [];\n      } else cur.push(ends[j][0] === at && ends[j][1] === to ? ids[j] : ~ids[j]);\n      at = to;\n    }\n    if (cur.length) strokes.push(cur);\n  }\n  return strokes;\n}\n\n// ---- Layout: one letter per cell down the panel, its count beside it.\nfunction layout(S) {\n  const word = WORDS[S.word], n = word.length, ch = H / n, hangul = word[0].charCodeAt(0) > 255;\n  const bw = hangul ? 14 : 10, bh = 14, CWID = 15, GAP = 5;\n  // Latin capitals may stretch up to 1.4 times wider than tall.\n  const sy = min((W - 4 - CWID - GAP) / bw, (ch - (n > 3 ? 7 : 10)) / bh), sx = min((W - 4 - CWID - GAP) / bw, sy * (hangul ? 1 : 1.4));\n  const gw = bw * sx, x0 = (W - gw - GAP - CWID) / 2;\n  S.r = 0.85 + 0.28 * sy;\n  S.glyphs = word.map((name, gi) => {\n    const g = GLYPHS[name], y0 = gi * ch + (ch - bh * sy) / 2;\n    const P = (x, y) => [x0 + x * sx, y0 + y * sy];\n    const vx = [], deg = new Array(g.v.length / 2).fill(0);\n    for (let i = 0; i \u003c g.v.length; i += 2) vx.push(P(g.v[i], g.v[i + 1]));\n    const edges = g.e.map(([a, b, mid]) => {\n      const pts = [...vx[a]];\n      for (let i = 0; mid && i \u003c mid.length; i += 2) pts.push(...P(mid[i], mid[i + 1]));\n      pts.push(...vx[b]);\n      deg[a]++;\n      deg[b]++;\n      return pts;\n    });\n    return { g, vx, edges, deg, cx: x0 + gw + GAP, cy: gi * ch + ch / 2 };\n  });\n}\n\nfunction strokePts(G, refs) {\n  const out = [];\n  for (const ref of refs) {\n    const id = ref >= 0 ? ref : ~ref, e = G.edges[id], n = e.length / 2;\n    for (let i = 0; i \u003c n; i++) {\n      const k = ref >= 0 ? i : n - 1 - i;\n      if (out.length && i === 0) continue;\n      out.push(e[2 * k], e[2 * k + 1]);\n    }\n  }\n  return out;\n}\n\n// Which vertex a stroke starts or ends on.\nfunction vertexAt(G, x, y) {\n  let best = -1, bd = 0.5;\n  G.vx.forEach(([vx, vy], i) => {\n    const d = hypot(vx - x, vy - y);\n    if (d \u003c bd) (bd = d), (best = i);\n  });\n  return best;\n}\n\nfunction track(pts) {\n  const cum = [0];\n  for (let i = 2; i \u003c pts.length; i += 2) cum.push(cum[cum.length - 1] + hypot(pts[i] - pts[i - 2], pts[i + 1] - pts[i - 1]));\n  return { pts, cum, len: cum[cum.length - 1] };\n}\n\nfunction newPass(S) {\n  S.moves = [];\n  S.counts = [];\n  S.marks = [];\n  S.ghost.fill(0);\n  let px = null, py = null;\n  S.glyphs.forEach((G, gi) => {\n    const strokes = S.mode ? G.g.c : eulerOrder(G.g);\n    S.counts[gi] = strokes.length;\n    S.marks[gi] = new Set();\n    strokes.forEach((refs, k) => {\n      const pts = strokePts(G, refs), n = pts.length;\n      if (px !== null) S.moves.push({ up: true, gi, ...track([px, py, pts[0], pts[1]]) });\n      const sv = vertexAt(G, pts[0], pts[1]), ev = vertexAt(G, pts[n - 2], pts[n - 1]);\n      S.moves.push({ up: false, gi, k, sv, ev, ...track(pts) });\n      // The unwritten skeleton, faintly tinted with the stroke each piece\n      // will belong to, so the route shows before the pen takes it.\n      for (let i = 2; i \u003c n; i += 2) capsule(S.ghost, null, pts[i - 2], pts[i - 1], pts[i], pts[i + 1], S.r, 1, 0, S.gk, k);\n      S.marks[gi].add(sv).add(ev);\n      px = pts[n - 2];\n      py = pts[n - 1];\n    });\n  });\n  S.mi = 0;\n  S.u = 0;\n  S.done = 0;\n  S.hold = -1;\n  S.ink.fill(0);\n  S.hot.fill(0);\n  S.touched = S.glyphs.map((G) => new Float32Array(G.vx.length).fill(-1));\n  S.lit = S.glyphs.map(() => []);\n  S.pen = [S.moves[0].pts[0], S.moves[0].pts[1], false];\n  S.started = -1;\n}\n\nconst dur = (m) => (m.up ? m.len / V_UP : REST + m.len / V_DOWN + REST);\n\nfunction posAt(m, s) {\n  const { pts, cum } = m;\n  let i = 1;\n  while (i \u003c cum.length - 1 && cum[i] \u003c s) i++;\n  const u = cum[i] > cum[i - 1] ? cl((s - cum[i - 1]) / (cum[i] - cum[i - 1]), 0, 1) : 1;\n  return [pts[2 * i - 2] + (pts[2 * i] - pts[2 * i - 2]) * u, pts[2 * i - 1] + (pts[2 * i + 1] - pts[2 * i - 1]) * u];\n}\n\n// Ink the move from arc length a to b: a capsule per piece for strokes, faint\n// dashes for pen-up hops.\nfunction inkSpan(S, m, a, b) {\n  if (b \u003c= a) return;\n  if (m.up) {\n    // Dashes two LEDs long with two LEDs between them.\n    for (let s = floor(a) + 1; s \u003c= b; s++) {\n      const [x, y] = posAt(m, s);\n      if (s > 2 && s \u003c m.len - 2 && s % 4 \u003c 2) capsule(S.ink, [0.3, 0.31, 0.36], x, y, x, y, 0.5, 1, 0);\n    }\n    return;\n  }\n  const col = S.strokeCol[m.k % 8];\n  const { pts, cum } = m;\n  for (let i = 1; i \u003c cum.length; i++) {\n    const s0 = max(a, cum[i - 1]), s1 = min(b, cum[i]);\n    if (s1 \u003c s0 || cum[i] \u003c= cum[i - 1]) continue;\n    const [x0, y0] = posAt(m, s0), [x1, y1] = posAt(m, s1);\n    capsule(S.ink, col, x0, y0, x1, y1, S.r, 1, 0.42);\n    capsule(S.hot, null, x0, y0, x1, y1, S.r, 1, 0.6);\n  }\n}\n\n// A round-ended segment: a solid core of radius r and a soft glow around it.\n// With col null it writes one channel (the ghost, with the stroke index in\n// kb, or the hot ink).\nfunction capsule(buf, col, ax, ay, bx, by, r, a, glow, kb, kv) {\n  const R = r + (glow ? 5 : 1), dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n  for (let y = max(0, floor(min(ay, by) - R)); y \u003c= min(H - 1, floor(max(ay, by) + R)); y++)\n    for (let x = max(0, floor(min(ax, bx) - R)); x \u003c= min(W - 1, floor(max(ax, bx) + R)); x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay, t = L2 > 0 ? cl((px * dx + py * dy) / L2, 0, 1) : 0;\n      const d = hypot(px - t * dx, py - t * dy), core = cl(r + 0.5 - d, 0, 1), e = max(0, d - r);\n      const v = a * max(core, glow * exp(-e * e * 0.16));\n      if (v \u003c= 0.004) continue;\n      const p = y * W + x;\n      if (!col) {\n        if (v > buf[p]) (buf[p] = v), kb && (kb[p] = kv);\n      } else for (let c = 0; c \u003c 3; c++) buf[3 * p + c] = max(buf[3 * p + c], col[c] * v * (core > 0.5 ? 1 : 0.85));\n    }\n}\n\nexport function setup(params) {\n  params.s = { word: -1, mode: 0, hue: -1, t: 0, ink: new Float32Array(NP * 3), ghost: new Float32Array(NP), gk: new Uint8Array(NP), hot: new Float32Array(NP), rgb: new Float32Array(NP * 3), strokeCol: [] };\n}\n\nfunction touch(S, gi, v) {\n  if (v >= 0 && S.touched[gi][v] \u003c 0) S.touched[gi][v] = S.t;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  if (k[0] !== S.hue) {\n    S.hue = k[0];\n    S.strokeCol = STROKE_HUE.map((h) => hsv(0.5 + S.hue + h, 0.58, 1));\n  }\n  const word = cl(round(k[2]), 0, 3), mode = k[3] >= 0.5 ? 1 : 0;\n  if (word !== S.word || mode !== S.mode) {\n    const relayout = word !== S.word;\n    S.word = word;\n    S.mode = mode;\n    if (relayout) layout(S);\n    newPass(S);\n  }\n  const step = (d * cl(k[1], 0.2, 3)) / 2, cool = exp(-d * 1.4);\n  S.t += step;\n  // Fresh ink is white hot and cools to its colour in about 0.7 s of real\n  // time, so a faster pen drags a longer hot tail.\n  for (let p = 0; p \u003c NP; p++) S.hot[p] *= cool;\n  if (S.hold >= 0) {\n    S.hold += step;\n    if (S.hold > HOLD + FADE) newPass(S);\n    return;\n  }\n  S.u += step;\n  for (let guard = 0; guard \u003c 64 && S.mi \u003c S.moves.length; guard++) {\n    const m = S.moves[S.mi];\n    if (!m.up && S.started !== S.mi) {\n      S.started = S.mi;\n      touch(S, m.gi, m.sv);\n      S.lit[m.gi][m.k] = 1;\n    }\n    const T = dur(m), s = m.up ? S.u * V_UP : cl((S.u - REST) * V_DOWN, 0, m.len);\n    inkSpan(S, m, S.done, min(s, m.len));\n    S.done = max(S.done, min(s, m.len));\n    const [x, y] = posAt(m, S.done);\n    S.pen = [x, y, !m.up];\n    if (S.u \u003c T) break;\n    if (!m.up) touch(S, m.gi, m.ev);\n    S.u -= T;\n    S.done = 0;\n    S.mi++;\n  }\n  if (S.mi >= S.moves.length) S.hold = 0;\n}\n\n// Soft disc or ring added on top of the frame.\nfunction spot(rgb, x, y, r, col, a, ring) {\n  const R = r + 2;\n  for (let j = max(0, floor(y - R)); j \u003c= min(H - 1, floor(y + R)); j++)\n    for (let i = max(0, floor(x - R)); i \u003c= min(W - 1, floor(x + R)); i++) {\n      const dd = hypot(i + 0.5 - x, j + 0.5 - y);\n      const v = a * (ring ? cl(1 - abs(dd - r) / 0.8, 0, 1) : cl(r + 0.5 - dd, 0, 1) + 0.35 * exp(-max(0, dd - r) * 0.9) * (dd > r ? 1 : 0));\n      if (v \u003c= 0) continue;\n      const o = 3 * (j * W + i);\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = max(rgb[o + c], col[c] * v);\n    }\n}\n\nfunction digit(rgb, n, x, y, col, z) {\n  const bits = DIGITS[n % 10];\n  for (let r = 0; r \u003c 5; r++)\n    for (let c = 0; c \u003c 3; c++)\n      if ((bits >> (14 - r * 3 - c)) & 1)\n        for (let j = 0; j \u003c z; j++)\n          for (let i = 0; i \u003c z; i++) {\n            const X = round(x) + c * z + i, Y = round(y) + r * z + j;\n            if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) for (let q = 0; q \u003c 3; q++) rgb[3 * (Y * W + X) + q] = col[q];\n          }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.glyphs) return;\n  const { rgb, ink, ghost, gk, hot, strokeCol } = S;\n  const fade = S.hold > HOLD ? cl((S.hold - HOLD) / FADE, 0, 1) : 0, keep = 1 - fade;\n  const bg = hsv(0.62 + S.hue, 0.6, 0.035), gc = hsv(0.6 + S.hue, 0.25, 0.2);\n  for (let p = 0; p \u003c NP; p++) {\n    const g = ghost[p], o = 3 * p, sc = strokeCol[gk[p] % 8];\n    for (let c = 0; c \u003c 3; c++) rgb[o + c] = max(bg[c] + g * (0.4 * gc[c] + 0.28 * sc[c]), ink[o + c] * keep) + 0.6 * hot[p];\n  }\n  const warm = hsv(0.12 + S.hue, 0.25, 1), rose = hsv(0.97 + S.hue, 0.5, 1), pale = hsv(0.6 + S.hue, 0.12, 0.85), pulse = 0.5 + 0.5 * sin(TAU * 1.3 * S.t);\n  const next = S.moves[S.mi];\n  S.glyphs.forEach((G, gi) => {\n    // The vertices where the plan's strokes start or end glow until the pen\n    // touches them, then keep a ring: warm on an odd vertex, rose on an even\n    // one. In the Euler order every mark but one per closed piece is odd.\n    for (const v of S.marks[gi]) {\n      const [x, y] = G.vx[v], col = G.deg[v] & 1 ? warm : rose;\n      if (S.touched[gi][v] >= 0) {\n        spot(rgb, x, y, 2.4, col, 0.6 * keep * min(1, (S.t - S.touched[gi][v]) * 4 + 0.2), true);\n        continue;\n      }\n      const after = next && next.up ? S.moves[S.mi + 1] : next, soon = after && !after.up && after.gi === gi && after.sv === v ? 1 : 0;\n      spot(rgb, x, y, 2.2, col, (0.4 + 0.35 * pulse + 0.35 * soon) * keep + 0.2 * fade);\n    }\n    // The count: a digit and a pip for each stroke, lit as the stroke starts.\n    const z = H / S.glyphs.length >= 30 ? 3 : 2, n = S.counts[gi], cols = min(4, n), rows = Math.ceil(n / 4), top = G.cy - (5 * z + 3 + rows * 4 - 1) / 2;\n    digit(rgb, n, G.cx + 7.5 - 1.5 * z, top, S.mode ? rose : pale, z);\n    for (let q = 0; q \u003c n; q++) {\n      const px = G.cx + (q % 4) * 4 + (4 - cols) * 2, py = top + 5 * z + 3 + floor(q / 4) * 4, on = S.lit[gi][q] && keep > 0;\n      const col = on ? S.strokeCol[q % 8] : gc;\n      for (let j = 0; j \u003c 3; j++)\n        for (let i = 0; i \u003c 3; i++) {\n          const X = round(px) + i, Y = round(py) + j;\n          if (X \u003c W && Y \u003c H) for (let c = 0; c \u003c 3; c++) rgb[3 * (Y * W + X) + c] = col[c] * (on ? keep : 0.9);\n        }\n    }\n  });\n  if (S.hold \u003c 0) {\n    const [x, y, down] = S.pen, m = S.moves[S.mi], lc = down && m ? S.strokeCol[m.k % 8] : pale;\n    // The pen tip lights the paper round it in the colour it writes.\n    for (let j = max(0, floor(y - 22)); j \u003c= min(H - 1, floor(y + 22)); j++)\n      for (let i = 0; i \u003c W; i++) {\n        const dx = i + 0.5 - x, dy = j + 0.5 - y, v = 0.2 * exp(-(dx * dx + dy * dy) / 130);\n        if (v \u003c 0.01) continue;\n        const o = 3 * (j * W + i);\n        for (let c = 0; c \u003c 3; c++) rgb[o + c] += lc[c] * v;\n      }\n    spot(rgb, x, y, down ? 1.2 : 1.7, [1, 1, 1], down ? 1 : 0.8, !down);\n  }\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, floor(p / W), min(255, rgb[3 * p] * 255) | 0, min(255, rgb[3 * p + 1] * 255) | 0, min(255, rgb[3 * p + 2] * 255) | 0);\n}\n","fractran":"// ===== Patternflow pattern =====\n// Title:   FRACTRAN\n// Family:  number\n// Idea:    Conway's PRIMEGAME runs as a bead machine: the exponents of 2, 3, 5 and 7 stand as columns of beads that pump up and down in sawtooth loops while beads rise out of them and fall back in, the first of the fourteen fractions that keeps n whole lights at each step, and whenever n is a bare power of two the machine stops with p beads in the 2 column alone and writes the prime p into the record at the top.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: FRACTRAN and PRIMEGAME (John Horton Conway, 1987, \"FRACTRAN: A Simple Universal Programming Language for Arithmetic\"), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Start=0..3, Trail=0..1\n//\n// Knob 1: Hue. Turns every colour together: at 0 the 2 column is gold, 3 cyan, 5 violet and 7 green, the fractions and the state lamps 11 to 29 blue and the record warm white.\n// Knob 2: Speed. Steps a second, 2 times 60 to the power (Speed - 0.2) / 1.8: 120 at 2, where 2, 3, 5 and 7 enter the record at 0.2, 1.2, 3.5 and 7.7 s; 2 at 0.2, slow enough to follow every fraction and every bead; 1170 at 3, where 29 arrives at 37 s. On a prime the machine waits for its beads to land and 30 steps more, 0.55 s at 2.\n// Knob 3: Start. Where a run begins: n = 2 at 0, then 2^11, 2^19 or 2^29, the states PRIMEGAME is in when it finds those primes, with the primes up to them already in the record. The higher the start, the taller the sawtooth: from 2^29 the 2 and 5 columns climb to 31 beads before 31 arrives at 73 s, and the beads thin from 5 rows to 2. A run ends 3 s after 2^41 and starts again.\n// Knob 4: Trail. How long the light stays, 0.05 times 30 to the power Trail seconds. At 0.06 a flying bead leaves almost nothing behind and the tubes show single beads; from 0.4 up each bead draws a full tail, and at 1 the tails last 1.5 s and pile up into lit tubes as bright as their traffic, the fractions glow by how often they fire, and each column keeps a ghost of its last peak that sinks a bead a second.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, exp, pow, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The machine. n is held as its exponents over the ten primes the\n// program uses, never as a number. 2, 3, 5 and 7 are the registers; 11 to 29\n// never go above 1 and act as the program's state.\nconst PR = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29];\nconst FR = [[17, 91], [78, 85], [19, 51], [23, 38], [29, 33], [77, 29], [95, 23], [77, 19], [1, 17], [11, 13], [13, 11], [15, 2], [1, 7], [55, 1]];\nfunction vec(n) {\n  const e = new Int8Array(10);\n  for (let i = 0; i \u003c 10; i++) while (n % PR[i] === 0) (n /= PR[i]), e[i]++;\n  return e;\n}\nconst NUM = FR.map((f) => vec(f[0])), DEN = FR.map((f) => vec(f[1]));\n// Run in Node from n = 2, 2^p first appears at step 19, 69, 281, 710, 2375,\n// 3893, 8102, 11361, 19268, 36981, 45680, 75417 and 101354 for p = 2 to 41.\nconst PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41];\nconst STARTS = [1, 11, 19, 29];\n\n// ---- Digits, 3 by 5.\nconst DIG = [\"###.#.#.#.#.###\", \".#.##..#..#.###\", \"###..#####..###\", \"###..#.##..####\", \"#.##.####..#..#\", \"####..###..####\", \"####..####.####\", \"###..#..#.#..#.\", \"####.#####.####\", \"####.####..####\"];\nconst textW = (s) => 4 * s.length - 1;\n\n// ---- Layout. The record of primes in two lines at the top, the fourteen\n// fractions in two rows of seven, numerator over denominator, the state\n// lamps 11 to 29, then the four register columns standing on row 120.\nconst REC_Y = [1, 7];\nconst FR_Y = [15, 31];\nconst ST_Y = 47;\nconst COL_X = [8, 24, 40, 56], FLOOR = 120, CEIL = 56;\nconst frX = (k) => 4.5 + 9 * (k % 7);\nconst frY = (k) => FR_Y[k \u003c 7 ? 0 : 1];\nconst stX = (j) => 6.5 + 10 * j;\nconst recPlace = (() => {\n  const out = [];\n  for (const [line, from, to] of [[0, 0, 7], [1, 7, 13]]) {\n    const items = PRIMES.slice(from, to).map(String);\n    let x = floor((W - (items.reduce((s, t) => s + textW(t), 0) + 3 * (items.length - 1))) / 2);\n    for (const t of items) {\n      out.push([x, REC_Y[line]]);\n      x += textW(t) + 3;\n    }\n  }\n  return out;\n})();\n\nfunction reset(S) {\n  const p = STARTS[S.start];\n  S.e = new Int32Array(10);\n  S.e[0] = p;\n  S.found = PRIMES.filter((q) => q \u003c= p && p > 1).length;\n  S.flights = [];\n  S.inc = new Int32Array(10);\n  S.heat.fill(0);\n  S.scan.fill(0);\n  S.ghost = new Float32Array(4);\n  S.acc = 0;\n  S.pause = 0;\n  S.flash = 0;\n  S.end = 0;\n  S.peak = max(12, p + 1);\n  S.pitch = min(5, (FLOOR - CEIL) / S.peak);\n  S.glow.fill(0);\n  S.last = -1;\n}\n\nexport function setup(params) {\n  params.s = { start: -1, hue: 0, rate: 100, trail: 0.06, heat: new Float32Array(14), scan: new Float32Array(14), glow: new Float32Array(NP * 3), rgb: new Float32Array(NP * 3), sheat: new Float32Array(6), gain: 1, hgain: 1, last: -1, dur: 0.3 };\n}\n\n// A bead in flight runs up or down its own column: up from the top of the\n// stack and out of the column's head when a denominator takes it, down from\n// the head onto the stack when a numerator gives it.\nfunction flight(S, j, y0, y1) {\n  if (S.flights.length > 240) {\n    if (y1 > y0) S.inc[j]--;\n    return;\n  }\n  S.flights.push({ j, y0, y1, u: 0 });\n}\n\nfunction step(S) {\n  const e = S.e;\n  let k = 0;\n  for (; k \u003c 14; k++) {\n    let ok = true;\n    for (let j = 0; j \u003c 10 && ok; j++) if (e[j] \u003c DEN[k][j]) ok = false;\n    if (ok) break;\n    // Tried and passed over: its bar flickers.\n    S.scan[k] = min(1, S.scan[k] + 0.35);\n  }\n  S.heat[k] = min(1.6, S.heat[k] + S.hgain);\n  S.last = k;\n  for (let j = 0; j \u003c 10; j++) {\n    e[j] -= DEN[k][j];\n    if (j \u003c 4) for (let d = 0; d \u003c DEN[k][j]; d++) flight(S, j, FLOOR - S.pitch * (e[j] + d + 0.5), CEIL - 2);\n  }\n  for (let j = 0; j \u003c 10; j++) {\n    for (let n = 0; n \u003c NUM[k][j]; n++) {\n      e[j]++;\n      if (j \u003c 4) {\n        S.inc[j]++;\n        flight(S, j, CEIL - 2, FLOOR - S.pitch * (e[j] - 0.5));\n      }\n    }\n  }\n  let bare = e[0] >= 2;\n  for (let j = 1; j \u003c 10 && bare; j++) if (e[j]) bare = false;\n  if (bare) {\n    S.found = PRIMES.indexOf(e[0]) + 1;\n    S.flash = 1;\n    // Hold until every bead has landed, then a beat more, so the 2 column\n    // stands alone with its p beads.\n    S.pause = S.dur + cl(30 / S.rate, 0.25, 1.5);\n    if (e[0] >= PRIMES[PRIMES.length - 1]) S.end = 3;\n  }\n  for (let j = 0; j \u003c 4; j++) if (e[j] + 1 > S.peak) S.peak = e[j] + 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const h = S.hue;\n  S.cols = [hsv(0.11 + h, 0.6, 1), hsv(0.5 + h, 0.6, 1), hsv(0.8 + h, 0.5, 1), hsv(0.32 + h, 0.6, 1), hsv(0.61 + h, 0.5, 1)];\n  S.rate = 2 * pow(60, (cl(k[1], 0.2, 3) - 0.2) / 1.8);\n  S.trail = cl(k[3], 0, 1);\n  const start = cl(round(k[2]), 0, 3);\n  if (start !== S.start) {\n    S.start = start;\n    reset(S);\n  }\n  const tau = 0.05 * pow(30, S.trail);\n  // A longer trail lays each pass down fainter, so a path's brightness is\n  // its traffic, not how long the light stays. At the shortest trail a bead\n  // leaves almost nothing behind it and the tubes show single beads.\n  S.gain = min(1, 0.35 / tau) * (0.12 + 0.88 * min(1, S.trail / 0.4));\n  const htau = max(0.1, tau, 0.6 / S.rate), fade = exp(-d / tau), hfade = exp(-d / htau);\n  S.hgain = min(1, 0.12 / htau);\n  for (let i = 0; i \u003c NP * 3; i++) S.glow[i] *= fade;\n  for (let i = 0; i \u003c 14; i++) S.heat[i] *= hfade;\n  const sfade = exp(-d / 0.06);\n  for (let i = 0; i \u003c 14; i++) S.scan[i] *= sfade;\n  for (let j = 0; j \u003c 6; j++) S.sheat[j] = S.e[4 + j] > 0 ? 1 : S.sheat[j] * exp(-d / 0.08);\n  S.flash *= exp(-d / 0.6);\n  // A flight takes 0.3 s at speed, up to 0.6 s when the steps come slower.\n  const dur = (S.dur = cl(2.2 / S.rate, 0.3, 0.6));\n  const live = [];\n  S.busy = [0, 0, 0, 0];\n  for (const f of S.flights) S.busy[f.j]++;\n  for (const f of S.flights) {\n    const u0 = f.u;\n    f.u = min(1, f.u + d / dur);\n    trace(S, f, u0, f.u);\n    if (f.u >= 1) {\n      if (f.y1 > f.y0) S.inc[f.j]--;\n    } else live.push(f);\n  }\n  S.flights = live;\n  if (S.end > 0) {\n    S.end -= d;\n    if (S.end \u003c= 0) reset(S);\n  } else if (S.pause > 0) S.pause -= d;\n  else {\n    S.acc += S.rate * d;\n    for (let guard = 0; S.acc >= 1 && guard \u003c 200; guard++) {\n      S.acc--;\n      step(S);\n      if (S.pause > 0 || S.end > 0) {\n        S.acc = 0;\n        break;\n      }\n    }\n  }\n  S.pitch += (min(5, (FLOOR - CEIL) / S.peak) - S.pitch) * (1 - exp(-d / 0.4));\n  for (let j = 0; j \u003c 4; j++) {\n    const c = shown(S, j);\n    S.ghost[j] = max(c, S.ghost[j] - d * (1 + 40 * (1 - S.trail) * (1 - S.trail)));\n  }\n}\n\n// The beads a column shows. Below 10 steps a second a given bead joins the\n// stack when its flight lands; faster than that a flight outlasts many\n// steps, so the stack shows the register as it is and the flights are the\n// traffic through it.\nconst shown = (S, j) => S.e[j] - (S.rate \u003c 10 ? S.inc[j] : 0);\n\n// Falling beads speed up, rising ones slow down, like a ball thrown up.\nconst fly = (f, u) => f.y0 + (f.y1 - f.y0) * (f.y1 > f.y0 ? u * u : u * (2 - u));\n\nfunction trace(S, f, u0, u1) {\n  const a = fly(f, u0), b = fly(f, u1), col = S.cols[f.j];\n  const lo = round(min(a, b)), hi = round(max(a, b)), x = COL_X[f.j];\n  for (let y = lo; y \u003c= hi; y++) {\n    if (y \u003c 0 || y >= H) continue;\n    const w = S.gain * min(1, 14 / S.busy[f.j]) * (0.12 + 0.33 * (f.y1 > f.y0 ? (y - lo + 1) / (hi - lo + 1) : (hi - y + 1) / (hi - lo + 1)));\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const o = (y * W + x + dx) * 3, ww = dx ? 0.5 * w : w;\n      S.glow[o] += col[0] * ww;\n      S.glow[o + 1] += col[1] * ww;\n      S.glow[o + 2] += col[2] * ww;\n    }\n  }\n}\n\nfunction put(S, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  S.rgb[o] += c[0] * a;\n  S.rgb[o + 1] += c[1] * a;\n  S.rgb[o + 2] += c[2] * a;\n}\n\nfunction text(S, s, x, y, c, a) {\n  for (let i = 0; i \u003c s.length; i++) {\n    const g = DIG[s.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"#\") put(S, x + 4 * i + q, y + r, c, a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.e) return;\n  const h = S.hue, rgb = S.rgb;\n  const cols = S.cols, ink = hsv(0.58 + h, 0.45, 1), warm = hsv(0.1 + h, 0.5, 1);\n  rgb.fill(0);\n  // The record.\n  for (let i = 0; i \u003c S.found; i++) {\n    const [x, y] = recPlace[i], t = String(PRIMES[i]), lastOne = i === S.found - 1;\n    if (lastOne && S.flash > 0.02) for (let yy = y - 1; yy \u003c= y + 5; yy++) for (let xx = x - 1; xx \u003c= x + textW(t); xx++) put(S, xx, yy, cols[0], 0.35 * S.flash);\n    text(S, t, x, y, lastOne ? [1, 1, 1] : warm, lastOne ? 0.75 + 0.25 * S.flash : 0.6);\n  }\n  // The fractions.\n  for (let k = 0; k \u003c 14; k++) {\n    const x = frX(k), y = frY(k), hk = min(1, max(S.heat[k], k === S.last ? 0.55 : 0)), [a, b] = FR[k].map(String);\n    if (hk > 0.02) for (let yy = y - 1; yy \u003c= y + 13; yy++) for (let xx = floor(x - 4); xx \u003c= floor(x + 4); xx++) put(S, xx, yy, ink, 0.16 * hk);\n    const lv = 0.2 + 0.8 * hk;\n    text(S, a, round(x - textW(a) / 2), y, ink, lv);\n    for (let xx = round(x - 3.5); xx \u003c round(x + 3.5); xx++) put(S, xx, y + 6, ink, min(1, lv * 0.8 + 0.6 * S.scan[k]));\n    text(S, b, round(x - textW(b) / 2), y + 8, ink, lv);\n  }\n  // The state lamps.\n  for (let j = 0; j \u003c 6; j++) {\n    const on = S.e[4 + j] > 0;\n    text(S, String(PR[4 + j]), round(stX(j) - 3.5), ST_Y, on ? [1, 1, 1] : cols[4], on ? 0.95 : 0.22 + 0.5 * S.sheat[j]);\n  }\n  // The columns: a rod, the ghost of the last peak, and the beads.\n  const pitch = S.pitch, bh = max(0.8, pitch - 1.4);\n  for (let j = 0; j \u003c 4; j++) {\n    const c = cols[j], cx = COL_X[j], n = shown(S, j);\n    for (let y = CEIL; y \u003c= FLOOR; y++) put(S, cx, y, c, 0.12);\n    text(S, String(PR[j]), cx - 1, FLOOR + 2, c, 0.7);\n    const top = S.ghost[j];\n    for (let i = 0; i \u003c Math.ceil(top); i++) {\n      const lit = i \u003c n, yc = FLOOR - pitch * (i + 0.5), a = lit ? 1 : 0.45 * min(1, top - i);\n      const glow = j === 0 && S.flash > 0.02 && lit ? S.flash : 0;\n      for (let y = floor(yc - bh / 2 - 1); y \u003c= floor(yc + bh / 2 + 1); y++) {\n        const cov = cl(min(y + 1, yc + bh / 2) - max(y, yc - bh / 2), 0, 1);\n        if (cov \u003c= 0) continue;\n        for (let dx = -5; dx \u003c= 5; dx++) {\n          const u = dx / 5.6, shade = 0.3 + 0.7 * sqrt(1 - u * u) - 0.25 * (y + 0.5 - yc) / (bh / 2 + 0.5);\n          put(S, cx + dx, y, c, a * cov * cl(shade, 0, 1) * 0.85);\n          if (glow) put(S, cx + dx, y, [1, 1, 1], 0.5 * glow * cov);\n        }\n      }\n    }\n  }\n  // Beads in flight: a small bright bead at the head of each trail.\n  // A crowded column dims its heads, so fast traffic reads as a lit tube in\n  // the column's colour rather than as white.\n  const busy = [0, 0, 0, 0];\n  for (const f of S.flights) busy[f.j]++;\n  for (const f of S.flights) {\n    const y = fly(f, f.u), c = S.cols[f.j], a = min(1, 14 / busy[f.j]);\n    const core = [0.5 + 0.5 * c[0], 0.5 + 0.5 * c[1], 0.5 + 0.5 * c[2]];\n    for (let dy = 0; dy \u003c 2; dy++) for (let dx = -2; dx \u003c= 2; dx++) put(S, COL_X[f.j] + dx, round(y) + dy - 1, abs(dx) \u003c 2 ? core : c, a * (abs(dx) \u003c 2 ? 0.85 : 0.5));\n  }\n  // The trails keep their colour: a pixel's glow is held under 0.7 of full,\n  // hue kept, so heavy traffic makes a coloured tube and not a white one.\n  for (let p = 0; p \u003c NP * 3; p += 3) {\n    const g = S.glow, m = max(g[p], g[p + 1], g[p + 2]), q = m > 0.7 ? 0.7 / m : 1;\n    rgb[p] += g[p] * q;\n    rgb[p + 1] += g[p + 1] * q;\n    rgb[p + 2] += g[p + 2] * q;\n  }\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3;\n    display.setPixel(p % W, floor(p / W), min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n  }\n}\n","kruskal-count":"// ===== Patternflow pattern =====\n// Title:   Kruskal Count\n// Family:  line\n// Idea:    A shuffled deck is laid down the panel in a snake of rows, a chain of its own colour starts on each of the first ten cards and a reading head sweeps the deck from top to bottom, so every chain it passes hops forward by the value of its card, chains that land on the same card merge and pale together, and at the bottom the card where they end is turned up large before the deck is shuffled again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Kruskal count (Martin Kruskal, 1970s), as Martin Gardner gave it in Mathematical Games (Scientific American, 1978), analysed by Jeffrey Lagarias, Eric Rains and Robert Vanderbei (The Kruskal Count, 2001), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Court=5..10, Decks=1..2\n//\n// Knob 1: Hue. Turns the ten chain colours round the wheel together; at 0 the first card's chain is cyan and the rest follow in steps of a tenth of the wheel.\n// Knob 2: Speed. At 2 the head reads 10.4 cards a second (20.8 with two decks), so a deal takes 5 s, the turned-up card stays 2.2 s and the shuffle 0.8 s: a new deal every 8 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Court. What a jack, queen or king counts, from 5 as in Gardner's telling to 10 as in blackjack; with one deck a court card shows its count where the suit would be. The mean jump grows from 5.4 to 6.5 cards and fewer chains meet: with one deck all ten merge in 58% of deals at 5 and 28% at 10.\n// Knob 4: Decks. One deck of 52 cards in 13 rows of 4 with suits, or from 1.5 two decks of 104 in 13 rows of 8 with the suit shown only by the colour of the rank. All ten chains merge in 94% of two-deck deals at Court 5. Turning it deals again.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, PI, sin, cos } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Card faces. Ranks in a 3 by 5 font, one number a row with the high\n// bit on the left: A, 2 to 9, J, Q, K. Ten is a one-column 1 and a 0 (the\n// table below), so \"10\" fits in 5 columns.\nconst RANK = [\n  [2, 5, 7, 5, 5], [6, 1, 2, 4, 7], [6, 1, 2, 1, 6], [5, 5, 7, 1, 1], [7, 4, 6, 1, 6], [3, 4, 6, 5, 2], [7, 1, 2, 2, 2], [2, 5, 2, 5, 2], [2, 5, 3, 1, 6],\n  null, [1, 1, 1, 5, 2], [2, 5, 5, 6, 3], [5, 6, 4, 6, 5],\n];\nconst ZERO = [2, 5, 5, 5, 2];\n// Suits on 5 by 5: spades, hearts, diamonds, clubs.\nconst SUIT = [\n  [4, 14, 31, 31, 4],\n  [10, 31, 31, 14, 4],\n  [4, 14, 31, 14, 4],\n  [14, 14, 31, 21, 4],\n];\nconst RED = [false, true, true, false];\n\n// A rank's glyphs as [bits, width, dx]: 10 is a narrow 1 and a 0.\nconst GLYPHS = [null];\nfor (let r = 1; r \u003c= 13; r++) GLYPHS.push(r === 10 ? [[[1, 1, 1, 1, 1], 1, 0], [ZERO, 3, 2]] : [[RANK[r - 1], 3, 0]]);\n\nconst valueOf = (r, court) => (r > 10 ? court : r);\n\n// ---- The deal and the sweep. A chain is a token on a card. The head reads\n// the cards in order; when it reaches a token the token jumps forward by\n// that card's value, and if a token already waits where it lands the two\n// become one. Every token is always ahead of the head, so a chain can only\n// meet another on a card the other has not left yet. A token whose jump\n// would leave the deck stays: its card is that chain's last card. Counted\n// in Node with this code over 100000 deals, every chain's last card the\n// same as walking it alone: with one deck and Court 5 all ten chains end\n// on one card in 58.5% of deals, and the trick itself, the magician's\n// chain from the first card against yours from a card you pick among the\n// first ten, works in 85.4%. At Court 10 it is 28.4% and 72.2%; with two\n// decks at Court 5, 93.8% and 97.9%.\nconst CHAINS = 10;\nconst DEAL = 5.0, SHOW = 2.2, SHUFFLE = 0.8;\n\nfunction deal(S) {\n  const n = 52 * S.decks, cards = [];\n  for (let k = 0; k \u003c S.decks; k++) for (let s = 0; s \u003c 4; s++) for (let r = 1; r \u003c= 13; r++) cards.push({ r, s });\n  for (let i = n - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = cards[i];\n    cards[i] = cards[j];\n    cards[j] = t;\n  }\n  S.n = n;\n  S.cards = cards;\n  S.cols = S.decks === 1 ? 4 : 8;\n  // The token on each card, and the chains that have stood on it (null for\n  // a card no chain has reached).\n  S.tok = new Array(n).fill(null);\n  S.trail = new Array(n).fill(null);\n  for (let i = 0; i \u003c CHAINS; i++) {\n    S.tok[i] = { members: [i], id: i };\n    S.trail[i] = S.tok[i].members.slice();\n  }\n  S.arcs = [];\n  S.flights = [];\n  S.bursts = [];\n  S.head = -1;\n  S.phase = 0;\n  S.t = 0;\n  S.final = null;\n}\n\n// Where a card sits: a snake of 13 rows, left to right then right to left.\nfunction place(C, i) {\n  const row = floor(i / C), q = i % C, col = row % 2 ? C - 1 - q : q;\n  const cw = W / C, ch = H / 13, fw = cw - 2;\n  const x = col * cw + 1, y = round(row * ch + (ch - 7) / 2);\n  return { x, y, w: fw, cx: x + fw / 2 - 0.5, cy: y + 3 };\n}\nconst PLACES = { 4: [], 8: [] };\nfor (let i = 0; i \u003c 52; i++) PLACES[4].push(place(4, i));\nfor (let i = 0; i \u003c 104; i++) PLACES[8].push(place(8, i));\nconst cell = (S, i) => PLACES[S.cols][i];\n\n// A hop's path: a quadratic curve from card centre to card centre, bowed\n// up (or to the right for a straight drop) by 0.3 of its length.\nfunction bez(a, b, u) {\n  const dx = b.cx - a.cx, dy = b.cy - a.cy, L = sqrt(dx * dx + dy * dy) || 1;\n  let px = dy / L, py = -dx / L;\n  if (py > 0) ((px = -px), (py = -py));\n  const k = 0.3 * L, mx = (a.cx + b.cx) / 2 + px * k, my = (a.cy + b.cy) / 2 + py * k, v = 1 - u;\n  return [v * v * a.cx + 2 * v * u * mx + u * u * b.cx, v * v * a.cy + 2 * v * u * my + u * u * b.cy, L];\n}\n// Its LEDs in order, each once.\nfunction arcPixels(a, b) {\n  const L = bez(a, b, 0)[2], steps = Math.ceil(L * 1.6) + 2, out = [];\n  let last = -1;\n  for (let s = 0; s \u003c= steps; s++) {\n    const [x, y] = bez(a, b, s / steps), xi = round(x), yi = round(y);\n    if (xi \u003c 0 || yi \u003c 0 || xi >= W || yi >= H) continue;\n    const q = yi * W + xi;\n    if (q !== last) (out.push(q), (last = q));\n  }\n  return out;\n}\n\nfunction step(S) {\n  const h = ++S.head;\n  if (h >= S.n) return;\n  const tk = S.tok[h];\n  if (!tk) return;\n  const t = h + valueOf(S.cards[h].r, S.court);\n  if (t >= S.n) return;\n  S.tok[h] = null;\n  const dur = min(0.4, valueOf(S.cards[h].r, S.court) * S.dt0 * 0.9);\n  const flight = { from: h, to: t, members: tk.members.slice(), age: 0, dur };\n  S.flights.push(flight);\n  S.arcs.push({ members: flight.members, pts: arcPixels(cell(S, h), cell(S, t)), flight });\n  const there = S.tok[t];\n  if (there) {\n    there.members = there.members.concat(tk.members).sort((a, b) => a - b);\n    S.bursts.push({ at: t, age: -dur, members: there.members.slice() });\n  } else S.tok[t] = { members: tk.members.slice(), id: tk.id };\n  S.trail[t] = S.tok[t].members.slice();\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, court: 5, decks: 1, dt0: DEAL / 52, rgb: new Float32Array(NP * 3) };\n  deal(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.court = cl(round(k[2]), 5, 10);\n  const decks = cl(k[3], 1, 2) >= 1.5 ? 2 : 1;\n  if (decks !== S.decks) ((S.decks = decks), deal(S));\n  S.dt0 = DEAL / S.n;\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  for (const f of S.flights) f.age += g;\n  for (const b of S.bursts) b.age += g;\n  S.flights = S.flights.filter((f) => f.age \u003c f.dur);\n  S.bursts = S.bursts.filter((b) => b.age \u003c 0.6);\n  if (S.phase === 0) {\n    while (S.t >= S.dt0 && S.head \u003c S.n - 1) {\n      S.t -= S.dt0;\n      step(S);\n    }\n    if (S.head >= S.n - 1 && !S.flights.length) {\n      // Where the chains ended, the card holding most of them first.\n      const ends = [];\n      for (let i = 0; i \u003c S.n; i++) if (S.tok[i]) ends.push({ at: i, members: S.tok[i].members });\n      ends.sort((a, b) => b.members.length - a.members.length || a.at - b.at);\n      S.final = ends;\n      S.phase = 1;\n      S.t = 0;\n    }\n  } else if (S.phase === 1 && S.t >= SHOW) ((S.phase = 2), (S.t = 0));\n  else if (S.phase === 2 && S.t >= SHUFFLE) deal(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0.004) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a);\n    rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n    rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n  const set = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = c[0] * a;\n    rgb[o + 1] = c[1] * a;\n    rgb[o + 2] = c[2] * a;\n  };\n  const bits = (rows, w, x, y, c, a, sc, plot) => {\n    for (let r = 0; r \u003c rows.length; r++)\n      for (let i = 0; i \u003c w; i++)\n        if ((rows[r] >> (w - 1 - i)) & 1) for (let v = 0; v \u003c sc; v++) for (let u = 0; u \u003c sc; u++) plot(x + i * sc + u, y + r * sc + v, c, a);\n  };\n\n  const chainCol = [];\n  for (let i = 0; i \u003c CHAINS; i++) chainCol.push(hsv(S.hue + 0.5 + i / CHAINS, 0.85, 1));\n  // A group's colour: its members' mean, paled towards white as it grows.\n  const memo = new Map();\n  const groupCol = (m) => {\n    const key = m.key || (m.key = m.join(\",\"));\n    if (memo.has(key)) return memo.get(key);\n    const c = [0, 0, 0];\n    for (const i of m) for (let q = 0; q \u003c 3; q++) c[q] += chainCol[i][q] / m.length;\n    const top = max(c[0], c[1], c[2], 1e-3), w = (m.length - 1) / (CHAINS - 1);\n    const out = c.map((v) => (v / top) * (1 - w * 0.75) + w * 0.75);\n    memo.set(key, out);\n    return out;\n  };\n  const ivory = [1, 0.93, 0.8], dim = S.phase === 1 ? 1 - 0.55 * ease(S.t / 0.4) : 1;\n  const fade = S.phase === 2 ? 1 - ease(S.t / SHUFFLE) : 1;\n  const redC = hsv(0.98, 0.6, 0.95), blackC = hsv(0.6, 0.18, 0.8);\n\n  // ---- Cards.\n  for (let i = 0; i \u003c S.n; i++) {\n    const p = cell(S, i), card = S.cards[i];\n    const tk = S.tok[i], tr = S.trail[i];\n    let face = ivory, fa = 0.13, ink = 0.8, dark = false;\n    if (tr && fade > 0) {\n      face = groupCol(tr);\n      fa = 0.13 + (0.55 - 0.13) * fade;\n      if (tk) ((fa = 0.13 + (0.85 - 0.13) * fade), (dark = fade > 0.5));\n    }\n    const f0 = face[0] * fa * dim, f1 = face[1] * fa * dim, f2 = face[2] * fa * dim;\n    for (let y = 0; y \u003c 7; y++)\n      for (let x = y === 0 || y === 6 ? 1 : 0, x1 = y === 0 || y === 6 ? p.w - 1 : p.w; x \u003c x1; x++) {\n        const o = ((p.y + y) * W + p.x + x) * 3;\n        (rgb[o] = f0), (rgb[o + 1] = f1), (rgb[o + 2] = f2);\n      }\n    // While shuffling the faces flicker through other ranks.\n    const r = S.phase === 2 && Math.random() \u003c 0.5 ? 1 + floor(Math.random() * 13) : card.r;\n    const inkC = dark ? [0, 0, 0] : S.cols === 8 && RED[card.s] ? redC : ivory;\n    const gl = GLYPHS[r], wide = r === 10 ? 5 : 3;\n    const rx = S.cols === 4 ? p.x + 2 : p.x + floor((p.w - wide) / 2);\n    for (const [rows, w, dx] of gl) bits(rows, w, rx + dx, p.y + 1, inkC, dark ? 1 : ink * dim, 1, dark ? set : put);\n    if (S.cols === 4) {\n      // Beside the rank the suit, or on a court card what it counts, in the\n      // suit's colour.\n      const sc = dark ? [0, 0, 0] : RED[card.s] ? redC : blackC, sa = dark ? 1 : 0.85 * dim, plot = dark ? set : put;\n      if (card.r \u003c= 10) bits(SUIT[card.s], 5, p.x + 8, p.y + 1, sc, sa, 1, plot);\n      else if (S.court === 10) for (const [rows, w, dx] of GLYPHS[10]) bits(rows, w, p.x + 7 + dx, p.y + 1, sc, sa, 1, plot);\n      else bits(RANK[S.court - 1], 3, p.x + 9, p.y + 1, sc, sa, 1, plot);\n    }\n  }\n\n  // ---- The hops so far, thin arcs that bow up, and the head.\n  const arcA = 0.7 * fade * dim;\n  for (const arc of S.arcs) {\n    const c = groupCol(arc.members), f = arc.flight, pts = arc.pts;\n    const upto = f.age \u003c f.dur ? round(ease(f.age / f.dur) * pts.length) : pts.length;\n    for (let s = 0; s \u003c upto; s++) {\n      const o = pts[s] * 3;\n      rgb[o] = max(rgb[o], c[0] * arcA);\n      rgb[o + 1] = max(rgb[o + 1], c[1] * arcA);\n      rgb[o + 2] = max(rgb[o + 2], c[2] * arcA);\n    }\n  }\n  for (const f of S.flights) {\n    const a = cell(S, f.from), b = cell(S, f.to), c = groupCol(f.members), u = ease(f.age / f.dur);\n    for (let tail = 0; tail \u003c 5; tail++) {\n      const [x, y] = bez(a, b, max(0, u - tail * 0.05));\n      const xi = round(x - 0.5), yi = round(y - 0.5), al = tail ? 0.6 - tail * 0.1 : 1;\n      put(xi, yi, c, al), put(xi + 1, yi, c, al), put(xi, yi + 1, c, al), put(xi + 1, yi + 1, c, al);\n    }\n  }\n  if (S.phase === 0 && S.head >= 0 && S.head \u003c S.n) {\n    const p = cell(S, S.head);\n    for (let x = -1; x \u003c= p.w; x++) (put(p.x + x, p.y - 1, ivory, 0.6), put(p.x + x, p.y + 7, ivory, 0.6));\n    for (let y = 0; y \u003c 7; y++) (put(p.x - 1, p.y + y, ivory, 0.6), put(p.x + p.w, p.y + y, ivory, 0.6));\n  }\n  // Two chains meeting: a ring opens round the card.\n  for (const b of S.bursts) {\n    if (b.age \u003c 0) continue;\n    const p = cell(S, b.at), c = groupCol(b.members), R = 2 + b.age * 22, a = 1 - b.age / 0.6;\n    for (let s = 0; s \u003c 48; s++) put(round(p.cx + R * cos((s / 48) * 2 * PI)), round(p.cy + R * 0.8 * sin((s / 48) * 2 * PI)), c, a);\n  }\n\n  // ---- The card the chains came to, turned up large: rank and suit, and a\n  // dot for each of the ten chains, lit in its colour if it ended here.\n  if (S.phase >= 1 && S.final && S.final.length) {\n    const top = S.final[0], card = S.cards[top.at], c = groupCol(top.members);\n    const grow = S.phase === 1 ? ease(S.t / 0.35) : 1 - ease(S.t / 0.4);\n    const cw = round(36 * grow), chh = round(52 * grow), x0 = 32 - (cw >> 1), y0 = 64 - (chh >> 1);\n    // The ends themselves pulse on the deck.\n    for (const e of S.final) {\n      const p = cell(S, e.at), ec = groupCol(e.members), a = 0.5 + 0.5 * sin(S.t * 9);\n      for (let x = -1; x \u003c= p.w; x++) (put(p.x + x, p.y - 1, ec, a), put(p.x + x, p.y + 7, ec, a));\n      for (let y = 0; y \u003c 7; y++) (put(p.x - 1, p.y + y, ec, a), put(p.x + p.w, p.y + y, ec, a));\n    }\n    if (cw > 4 && chh > 4) {\n      for (let y = 0; y \u003c chh; y++)\n        for (let x = 0; x \u003c cw; x++) {\n          const edge = x === 0 || y === 0 || x === cw - 1 || y === chh - 1;\n          if ((x === 0 || x === cw - 1) && (y === 0 || y === chh - 1)) continue;\n          set(x0 + x, y0 + y, edge ? c : ivory, edge ? 1 : 0.16);\n        }\n      if (grow > 0.95) {\n        const r = card.r, wide = r === 10 ? 5 : 3, ink = RED[card.s] ? redC : ivory;\n        for (const [rows, w, dx] of GLYPHS[r]) bits(rows, w, x0 + ((cw - wide * 4) >> 1) + dx * 4, y0 + 4, ink, 1, 4, set);\n        bits(SUIT[card.s], 5, x0 + ((cw - 15) >> 1), y0 + 27, RED[card.s] ? redC : blackC, 1, 3, set);\n        for (let i = 0; i \u003c CHAINS; i++) {\n          const on = top.members.includes(i), dx = x0 + 4 + (i % 5) * 6, dy = y0 + chh - 8 + floor(i / 5) * 3;\n          for (let v = 0; v \u003c 2; v++) for (let u = 0; u \u003c 4; u++) set(dx + u, dy + v, on ? chainCol[i] : ivory, on ? 1 : 0.12);\n        }\n      }\n    }\n  }\n\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","letter-mobile":"// ===== Patternflow pattern =====\n// Title:   Letter Mobile\n// Family:  type\n// Idea:    A hanging mobile in the manner of Calder whose weights are the four letters of a word, each weighing its ink, hangs the full height of the panel with every bar balanced by moments and turning slowly on its thread before a lit wall that takes its shadow, and when one letter changes, as in a word ladder, every bar above it tips and its hanging point slides to the new balance.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Alexander Calder's first mobiles (1931-32, named by Marcel Duchamp), the law of the lever (Archimedes, On the Equilibrium of Planes, 3rd century BC), word ladders (Lewis Carroll's Doublets, 1879), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..2, Sway=0..1\n//\n// Knob 1: Hue. Turns the painted plates round the wheel together: at 0 they are Calder's yellow, blue, red and white, top to bottom. The wires stay steel; the wall is a grey that turns with the plates, blue-grey at 0.\n// Knob 2: Speed. One clock for the turning, the swing and the word: at 2 one letter changes every 3.6 s, the bars turn round on their threads once in 30 to 44 s while a draft rocks each to and fro every 7 to 11 s, and the mobile swings once in 3.3 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. Which word ladder the mobile climbs, one letter at a time and back down: 0 is Carroll's own first, HEAD HEAL TEAL TELL TALL TAIL, from 752 LEDs of ink to 501; 1 is FILL FILM FIRM FORM WORM WARM, light letters turning heavy, 467 to 860; 2 is WOMB TOMB TOME TIME TILE TILL, heavy turning light, 905 to 448.\n// Knob 4: Sway. How far the whole mobile swings from its hook: at 0.06 the bottom letters move 2.5 LEDs either way, at 1 they move 23.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, round, min, max, sqrt, sin, cos, abs, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters. Skeletons in a box one cap height tall (y down), width w,\n// drawn with a round pen 4 LEDs wide into plates 22 LEDs tall. Straight\n// strokes snap to LED edges so stems come out exactly 4 wide; curves don't.\n// A letter weighs its ink, the LEDs its plate lights facing you:\n// I 84, L 119, T 126, F 145, A 172, E 180, H 196, O 198, D 204, R 206,\n// B 225, W 240, M 242.\nfunction arc(cx, cy, rx, ry, a0, a1, n) {\n  const s = [];\n  for (let i = 0; i \u003c n; i++) {\n    const t0 = a0 + ((a1 - a0) * i) / n, t1 = a0 + ((a1 - a0) * (i + 1)) / n;\n    s.push([cx + rx * cos(t0), cy + ry * sin(t0), cx + rx * cos(t1), cy + ry * sin(t1), 1]);\n  }\n  return s;\n}\nconst HP = PI / 2;\nconst SK = {\n  A: [0.72, [[0, 1, 0.36, 0], [0.36, 0, 0.72, 1], [0.13, 0.64, 0.59, 0.64]]],\n  B: [0.56, [[0, 0, 0, 1], [0, 0, 0.3, 0], ...arc(0.3, 0.235, 0.22, 0.235, -HP, HP, 6), [0.3, 0.47, 0, 0.47], [0, 0.47, 0.32, 0.47], ...arc(0.32, 0.735, 0.24, 0.265, -HP, HP, 6), [0.32, 1, 0, 1]]],\n  D: [0.62, [[0, 0, 0, 1], [0, 0, 0.22, 0], ...arc(0.22, 0.5, 0.4, 0.5, -HP, HP, 10), [0.22, 1, 0, 1]]],\n  E: [0.52, [[0, 0, 0, 1], [0, 0, 0.52, 0], [0, 0.5, 0.44, 0.5], [0, 1, 0.52, 1]]],\n  F: [0.52, [[0, 0, 0, 1], [0, 0, 0.52, 0], [0, 0.5, 0.44, 0.5]]],\n  H: [0.62, [[0, 0, 0, 1], [0.62, 0, 0.62, 1], [0, 0.5, 0.62, 0.5]]],\n  I: [0, [[0, 0, 0, 1]]],\n  L: [0.5, [[0, 0, 0, 1], [0, 1, 0.5, 1]]],\n  M: [0.82, [[0, 1, 0, 0], [0, 0, 0.41, 0.66], [0.41, 0.66, 0.82, 0], [0.82, 0, 0.82, 1]]],\n  O: [0.72, arc(0.36, 0.5, 0.36, 0.5, 0, 2 * PI, 16)],\n  R: [0.58, [[0, 0, 0, 1], [0, 0, 0.3, 0], ...arc(0.3, 0.25, 0.24, 0.25, -HP, HP, 6), [0.3, 0.5, 0, 0.5], [0.26, 0.5, 0.58, 1]]],\n  T: [0.66, [[0, 0, 0.66, 0], [0.33, 0, 0.33, 1]]],\n  W: [0.94, [[0, 0, 0.21, 1], [0.21, 1, 0.47, 0.32], [0.47, 0.32, 0.73, 1], [0.73, 1, 0.94, 0]]],\n};\nconst GH = 22, PEN = 2, SC = GH - 2 * PEN;\n\nfunction glyph(ch) {\n  const [w, segs] = SK[ch], bw = ceil(w * SC + 2 * PEN) + 1, bits = new Uint8Array(bw * GH);\n  let x0 = bw, x1 = -1;\n  for (let j = 0; j \u003c GH; j++)\n    for (let i = 0; i \u003c bw; i++) {\n      const px = i + 0.5, py = j + 0.5;\n      let on = 0;\n      for (const [sx, sy, ex, ey, curved] of segs) {\n        const sn = (v) => (curved ? PEN + v * SC : floor(PEN + v * SC));\n        const ax = sn(sx), ay = sn(sy), dx = sn(ex) - ax, dy = sn(ey) - ay, l2 = dx * dx + dy * dy;\n        const t = l2 ? cl(((px - ax) * dx + (py - ay) * dy) / l2, 0, 1) : 0;\n        const qx = ax + t * dx - px, qy = ay + t * dy - py;\n        if (qx * qx + qy * qy \u003c= (PEN + 0.01) * (PEN + 0.01)) {\n          on = 1;\n          break;\n        }\n      }\n      if (on) (bits[j * bw + i] = 1), (x0 = min(x0, i)), (x1 = max(x1, i));\n    }\n  // Trimmed to the ink, with a running sum per row for area sampling.\n  const gw = x1 - x0 + 1, g = new Uint8Array(gw * GH), cum = new Float32Array((gw + 1) * GH);\n  let ink = 0;\n  for (let j = 0; j \u003c GH; j++)\n    for (let i = 0; i \u003c gw; i++) {\n      const b = bits[j * bw + i + x0];\n      g[j * gw + i] = b;\n      ink += b;\n      cum[j * (gw + 1) + i + 1] = cum[j * (gw + 1) + i] + b;\n    }\n  return { ch, gw, g, cum, ink };\n}\nconst GLYPHS = {};\nconst glyphOf = (ch) => GLYPHS[ch] || (GLYPHS[ch] = glyph(ch));\n\n// ---- Word ladders: one letter changes at a time, each step a word.\nconst LADDERS = [\n  [\"HEAD\", \"HEAL\", \"TEAL\", \"TELL\", \"TALL\", \"TAIL\"],\n  [\"FILL\", \"FILM\", \"FIRM\", \"FORM\", \"WORM\", \"WARM\"],\n  [\"WOMB\", \"TOMB\", \"TOME\", \"TIME\", \"TILE\", \"TILL\"],\n];\n\n// ---- The mobile. Three bars in a chain, as Calder hung most of his: bar 0\n// carries letter 0 on its left end and everything below on its right, bar 1\n// carries that rest on its left and letter 1 on its right, bar 2 carries\n// letters 2 and 3. Facing you the chain zigzags so the word reads down the\n// panel. Each bar hangs from a loop D LEDs above it.\n// Bar k: length and the thread below each end. The top bar's hook hangs on\n// a thread 10 rows long from the top edge at x 31.\nconst BAR = [\n  { len: 28, drop: [3, 28] },\n  { len: 26, drop: [28, 3] },\n  { len: 32, drop: [10, 10] },\n];\nconst HOOK = [31, 10], D = 7;\n\n// Weights on each end of bar k, given the four letters' ink. A sub-mobile\n// weighs the sum of what hangs below it; wire and thread weigh nothing.\nfunction loads(ink) {\n  const w2 = ink[2] + ink[3], w1 = ink[1] + w2;\n  return [[ink[0], w1], [w1, ink[1]], [ink[2], ink[3]]];\n}\n\n// The law of the lever: the hook divides the bar so that left weight times\n// left arm equals right weight times right arm, so it sits at the fraction\n// WR / (WL + WR) of the bar from the left end.\n// Checked in Node over all three ladders, 21 words at rest just before the\n// next change: every bar's net moment is under 1e-12 (LEDs of ink times\n// LEDs of arm) and its tilt under 1.8 degrees. HEAD weighs H 196, E 180,\n// A 172, D 204; its top bar hangs 20.70 LEDs from the H and 7.30 from the\n// 556 below (196 x 20.70 = 556 x 7.30), its bottom bar 17.36 from the A and\n// 14.64 from the D.\nconst balance = ([wl, wr]) => wr / (wl + wr);\n\n// Turning: each bar turns round on its thread at its own rate, the bottom\n// one fastest, and a draft rocks it back and forth on top of that. Per bar:\n// angle at the start, seconds a turn at Speed 2 (signed), the draft's swing\n// and its period.\nconst TURN = [[-0.3, 44, 0.35, 9], [0.35, -36, 0.35, 7], [-0.6, 30, 0.35, 11]];\n\n// Lamp up and to the left in front of the mobile, the wall 26 LEDs behind\n// the threads.\nconst LX = -80, LY = -120, LZ = 300, WZ = -26;\n// A word holds 3.6 s at Speed 2; a changing letter spins round in 0.7 s and\n// swaps when it has turned a quarter (ss(0.3264) = 0.25); the hooks start to\n// slide 0.3 s after the swap and take 1.4 s.\nconst STEP = 3.6, FLIP = 0.7, SWAP = 0.3264, SLIDE_AT = 0.3, SLIDE = 1.4;\n\nfunction startWord(S, ladder) {\n  S.ladder = ladder;\n  S.step = 0;\n  S.dir = 1;\n  const word = LADDERS[ladder][0];\n  S.letters = [0, 1, 2, 3].map((i) => ({ g: glyphOf(word[i]), next: null, flip: -1 }));\n  const L = loads(S.letters.map((l) => l.g.ink));\n  S.bars = BAR.map((b, k) => ({ f: balance(L[k]), f0: 0, slide: -1, a: 0, av: 0 }));\n  S.clock = STEP - 2.1;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, sway: 0.06, ladder: -1, fb: new Float32Array(NP * 3), sh: new Float32Array(NP), tmp: new Float32Array(NP), wall: null };\n}\n\nfunction ink(S) {\n  return S.letters.map((l) => l.g.ink);\n}\n\nfunction nextWord(S) {\n  const lad = LADDERS[S.ladder];\n  if (S.step + S.dir \u003c 0 || S.step + S.dir >= lad.length) S.dir = -S.dir;\n  const from = lad[S.step], to = lad[S.step + S.dir];\n  S.step += S.dir;\n  for (let i = 0; i \u003c 4; i++)\n    if (from[i] !== to[i]) {\n      S.letters[i].next = glyphOf(to[i]);\n      S.letters[i].flip = 0;\n    }\n}\n\n// The bar's tilt a about its hook. With the hook D above the bar, the weights\n// hanging from the ends at arms aL, aR turn it by\n//   (WR aR - WL aL) cos a - (WL + WR) D sin a,\n// so a bar out of balance by a moment M settles at tan a = M / (W D), and a\n// balanced bar hangs level.\nfunction torque(b, len, [wl, wr]) {\n  const al = b.f * len, ar = (1 - b.f) * len;\n  return { tq: (wr * ar - wl * al) * cos(b.a) - (wl + wr) * D * sin(b.a), I: wl * (al * al + D * D) + wr * (ar * ar + D * D) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.sway = cl(k[3], 0, 1);\n  const ladder = cl(round(k[2]), 0, 2);\n  if (ladder !== S.ladder) startWord(S, ladder);\n  const step = (d * cl(k[1], 0.2, 3)) / 2;\n  S.t += step;\n  S.clock += step;\n  if (S.clock >= STEP) {\n    S.clock -= STEP;\n    nextWord(S);\n  }\n  // A letter that changes spins once round on its thread and comes back as\n  // the new letter; its weight changes a quarter turn in.\n  let changed = false;\n  for (const l of S.letters) {\n    if (l.flip \u003c 0) continue;\n    const was = l.flip;\n    l.flip += step / FLIP;\n    if (was \u003c SWAP && l.flip >= SWAP && l.next) {\n      l.g = l.next;\n      l.next = null;\n      changed = true;\n    }\n    if (l.flip >= 1) l.flip = -1;\n  }\n  const L = loads(ink(S));\n  // Only the bars whose balance moved: the changed letter's and those above.\n  if (changed) S.bars.forEach((b, i) => abs(balance(L[i]) - b.f) > 1e-9 && (b.slide = 0));\n  // The hooks slide to the new balance once the bars have tipped.\n  S.bars.forEach((b, i) => {\n    if (b.slide \u003c 0) return;\n    if (b.slide \u003c SLIDE_AT && b.slide + step >= SLIDE_AT) b.f0 = b.f;\n    b.slide += step;\n    if (b.slide >= SLIDE_AT) {\n      const u = ss((b.slide - SLIDE_AT) / SLIDE);\n      b.f = b.f0 + (balance(L[i]) - b.f0) * u;\n      if (u >= 1) b.slide = -1;\n    }\n  });\n  // Tilts, in four substeps. G and DAMP set the swing: when HEAD turns to\n  // HEAL the bottom bar tips to 35 degrees in 0.9 s, swings back past level\n  // to 6 degrees 1.3 s later and is within 1.5 degrees a second after that.\n  const G = 400, DAMP = 2.6, n = 4, h = step / n;\n  for (let s = 0; s \u003c n; s++)\n    S.bars.forEach((b, i) => {\n      const { tq, I } = torque(b, BAR[i].len, L[i]);\n      b.av += (G * tq / I - DAMP * b.av) * h;\n      b.a += b.av * h;\n      if (abs(b.a) > 0.75) (b.a = 0.75 * Math.sign(b.a)), (b.av = 0);\n    });\n}\n\n// ---- Geometry: points in LEDs, x right, y down, z towards you.\nfunction layout(S) {\n  const t = S.t, phi = (0.012 + 0.2 * S.sway) * sin((2 * PI * t) / 3.3);\n  // The whole mobile swings about the top of its thread.\n  const sw = (p) => [HOOK[0] + (p[0] - HOOK[0]) * cos(phi) - p[1] * sin(phi), (p[0] - HOOK[0]) * sin(phi) + p[1] * cos(phi), p[2]];\n  const lines = [], plates = [];\n  let piv = [HOOK[0], HOOK[1], 0];\n  lines.push({ p: [HOOK[0], -1, 0], q: piv, c: 0, glint: 0 });\n  for (let k = 0; k \u003c 3; k++) {\n    const B = BAR[k], b = S.bars[k], [th0, per, amp, dp] = TURN[k];\n    const th = th0 + (2 * PI * t) / per + amp * sin((2 * PI * t) / dp), ex = cos(th), ez = sin(th), ca = cos(b.a), sa = sin(b.a);\n    const bx = ca * ex, by = sa, bz = ca * ez;\n    // Hook, then the bar's own point under it, then the ends.\n    const hp = [piv[0] - sa * ex * D, piv[1] + ca * D, piv[2] - sa * ez * D];\n    const al = b.f * B.len, ar = (1 - b.f) * B.len;\n    const le = [hp[0] - bx * al, hp[1] - by * al, hp[2] - bz * al], re = [hp[0] + bx * ar, hp[1] + by * ar, hp[2] + bz * ar];\n    // The hook glints while it slides along the bar.\n    const sl = b.slide >= SLIDE_AT ? sin(PI * cl((b.slide - SLIDE_AT) / SLIDE, 0, 1)) : 0;\n    lines.push({ p: piv, q: hp, c: 1, glint: sl }, { p: le, q: re, c: 1, glint: 0 });\n    const ends = [le, re];\n    for (let side = 0; side \u003c 2; side++) {\n      const e = ends[side], drop = B.drop[side], lo = [e[0], e[1] + drop, e[2]];\n      lines.push({ p: e, q: lo, c: 0, glint: 0 });\n      const li = k === 0 ? (side === 0 ? 0 : -1) : k === 1 ? (side === 1 ? 1 : -1) : 2 + side;\n      if (li \u003c 0) piv = lo;\n      else {\n        const l = S.letters[li], fl = l.flip >= 0 ? 2 * PI * ss(l.flip) : 0;\n        plates.push({ top: lo, th: th + fl, l, pos: li });\n      }\n    }\n  }\n  for (const L of lines) (L.p = sw(L.p)), (L.q = sw(L.q));\n  for (const P of plates) P.top = sw(P.top);\n  return { lines, plates };\n}\n\n// Where a point lands on the wall, seen from the lamp.\nfunction onWall(p) {\n  const s = (WZ - LZ) / (p[2] - LZ);\n  return [LX + s * (p[0] - LX), LY + s * (p[1] - LY)];\n}\n\n// A line laid down as samples a third of an LED apart, each shared among the\n// four LEDs round it.\nfunction put(buf, X, Y, v) {\n  if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) buf[Y * W + X] += v;\n}\nfunction splatLine(buf, x0, y0, x1, y1, a) {\n  const n = max(2, ceil(sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)) * 3)), w = a / 3;\n  for (let i = 0; i \u003c= n; i++) {\n    const x = x0 + ((x1 - x0) * i) / n - 0.5, y = y0 + ((y1 - y0) * i) / n - 0.5, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    put(buf, ix, iy, w * (1 - fx) * (1 - fy));\n    put(buf, ix + 1, iy, w * fx * (1 - fy));\n    put(buf, ix, iy + 1, w * (1 - fx) * fy);\n    put(buf, ix + 1, iy + 1, w * fx * fy);\n  }\n}\n\n// Ink in glyph row j left of column u.\nfunction inkTo(g, j, u) {\n  if (u \u003c= 0) return 0;\n  const gw = g.gw;\n  if (u >= gw) return g.cum[j * (gw + 1) + gw];\n  const i = floor(u);\n  return g.cum[j * (gw + 1) + i] + (u - i) * g.g[j * gw + i];\n}\n\n// Shadows: every plate, wire and thread, cast by the lamp on the wall.\nfunction castShadows(sh, lines, plates) {\n  sh.fill(0);\n  for (const L of lines) {\n    const a = onWall(L.p), b = onWall(L.q);\n    splatLine(sh, a[0], a[1], b[0], b[1], 0.9);\n  }\n  for (const P of plates) {\n    const g = P.l.g, gw = g.gw, ex = cos(P.th), ez = sin(P.th), nx = -ez, nz = ex, T = P.top;\n    let x0 = W, x1 = 0, y0 = H, y1 = 0;\n    for (let k = 0; k \u003c 4; k++) {\n      const u = (k & 1 ? 0.5 : -0.5) * gw, c = onWall([T[0] + u * ex, T[1] + (k & 2 ? GH : 0), T[2] + u * ez]);\n      x0 = min(x0, c[0]);\n      x1 = max(x1, c[0]);\n      y0 = min(y0, c[1]);\n      y1 = max(y1, c[1]);\n    }\n    const nT = nx * (T[0] - LX) + nz * (T[2] - LZ), Dz = WZ - LZ;\n    for (let y = max(0, floor(y0)); y \u003c= min(H - 1, ceil(y1)); y++)\n      for (let x = max(0, floor(x0)); x \u003c= min(W - 1, ceil(x1)); x++) {\n        // The ray from the lamp to this LED of the wall, met with the plate.\n        const Dx = x + 0.5 - LX, Dy = y + 0.5 - LY, den = nx * Dx + nz * Dz;\n        if (abs(den) \u003c 1e-6) continue;\n        const s = nT / den, qx = LX + s * Dx - T[0], qy = LY + s * Dy - T[1], qz = LZ + s * Dz - T[2];\n        const u = floor(qx * ex + qz * ez + gw / 2), v = floor(qy);\n        if (u >= 0 && u \u003c gw && v >= 0 && v \u003c GH && g.g[v * gw + u]) sh[y * W + x] = 1;\n      }\n  }\n}\n\n// Soften the shadow edge by one LED (the lamp is not a point) and lay the\n// wall, under a spot aimed a little above the middle.\nfunction paintWall(S) {\n  const { fb, sh, tmp } = S;\n  if (!S.wall) {\n    S.wall = new Float32Array(NP);\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const r2 = (x - 30) * (x - 30) + (y - 52) * (y - 52) * 0.55;\n        S.wall[y * W + x] = 0.105 + 0.13 * exp(-r2 / 2600);\n      }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (sh[p] * 2 + (x > 0 ? sh[p - 1] : sh[p]) + (x \u003c W - 1 ? sh[p + 1] : sh[p])) / 4;\n    }\n  const wallC = hsv(0.58 + S.hue, 0.16, 1), wall = S.wall;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, s = min(1, (tmp[p] * 2 + (y > 0 ? tmp[p - W] : tmp[p]) + (y \u003c H - 1 ? tmp[p + W] : tmp[p])) / 4);\n      const v = wall[p] * (1 - 0.62 * s);\n      fb[p * 3] = wallC[0] * v;\n      fb[p * 3 + 1] = wallC[1] * v;\n      fb[p * 3 + 2] = wallC[2] * v;\n    }\n}\n\nfunction paintLine(fb, cov, p, q, wgt, col) {\n  splatLine(cov, p[0], p[1], q[0], q[1], wgt);\n  const xa = max(0, floor(min(p[0], q[0])) - 2), xb = min(W - 1, ceil(max(p[0], q[0])) + 2);\n  const ya = max(0, floor(min(p[1], q[1])) - 2), yb = min(H - 1, ceil(max(p[1], q[1])) + 2);\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const pi = y * W + x, a = min(1, cov[pi]);\n      if (a \u003c= 0) continue;\n      cov[pi] = 0;\n      for (let ch = 0; ch \u003c 3; ch++) fb[pi * 3 + ch] += (col[ch] - fb[pi * 3 + ch]) * a;\n    }\n}\n\n// A plate, foreshortened by its turn: each LED takes the share of the glyph\n// it covers, so a plate turned edge-on thins to its edge and turned past it\n// shows its back, the letter mirrored.\nfunction paintPlate(fb, g, T, th, base) {\n  const gw = g.gw, ex = cos(th), ez = sin(th), c = abs(ex) \u003c 0.07 ? (ex \u003c 0 ? -0.07 : 0.07) : ex, ac = abs(c);\n  // Lit by the lamp on whichever face it turns to it.\n  const cx = T[0], lx = LX - cx, ly = LY - T[1] - GH / 2, lz = LZ - T[2], ll = sqrt(lx * lx + ly * ly + lz * lz);\n  const shade = 0.5 + 0.5 * abs((-ez * lx + ex * lz) / ll), c0 = base[0] * shade, c1 = base[1] * shade, c2 = base[2] * shade;\n  const half = (gw / 2) * ac, xa = max(0, floor(cx - half)), xb = min(W - 1, ceil(cx + half));\n  const ya = max(0, floor(T[1])), yb = min(H - 1, ceil(T[1] + GH));\n  for (let x = xa; x \u003c= xb; x++) {\n    let u0 = (x - cx) / c + gw / 2, u1 = (x + 1 - cx) / c + gw / 2;\n    if (u0 > u1) {\n      const t = u0;\n      u0 = u1;\n      u1 = t;\n    }\n    for (let y = ya; y \u003c= yb; y++) {\n      // Rows blend where the plate sits between LEDs.\n      const v = y - T[1], j0 = floor(v), fv = v - j0;\n      let a = 0;\n      if (j0 >= 0 && j0 \u003c GH) a += (1 - fv) * (inkTo(g, j0, u1) - inkTo(g, j0, u0));\n      if (j0 + 1 >= 0 && j0 + 1 \u003c GH) a += fv * (inkTo(g, j0 + 1, u1) - inkTo(g, j0 + 1, u0));\n      a = min(1, a * ac);\n      if (a \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      fb[o] += (c0 - fb[o]) * a;\n      fb[o + 1] += (c1 - fb[o + 1]) * a;\n      fb[o + 2] += (c2 - fb[o + 2]) * a;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.letters) return;\n  const { fb, sh, tmp } = S;\n  const { lines, plates } = layout(S);\n  castShadows(sh, lines, plates);\n  paintWall(S);\n  // The mobile, far things first.\n  const items = [];\n  for (const L of lines) items.push({ z: (L.p[2] + L.q[2]) / 2, L, P: null });\n  for (const P of plates) items.push({ z: P.top[2], L: null, P });\n  items.sort((a, b) => a.z - b.z);\n  const steel = [0.62, 0.64, 0.68], thread = [0.36, 0.36, 0.38];\n  const pal = [hsv(0.14 + S.hue, 0.85, 1), hsv(0.6 + S.hue, 0.8, 1), hsv(0.995 + S.hue, 0.85, 1), hsv(0.6 + S.hue, 0.07, 1)];\n  tmp.fill(0);\n  for (const it of items) {\n    if (it.L) {\n      const { p, q, c, glint } = it.L;\n      paintLine(fb, tmp, p, q, c ? 1.15 : 0.8, glint ? steel.map((v) => v + (1 - v) * glint) : c ? steel : thread);\n    } else paintPlate(fb, it.P.l.g, it.P.top, it.P.th, pal[it.P.pos]);\n  }\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, fb[p * 3] * 255) | 0, min(255, fb[p * 3 + 1] * 255) | 0, min(255, fb[p * 3 + 2] * 255) | 0);\n}\n","lights-out":"// ===== Patternflow pattern =====\n// Title:   Lights Out\n// Family:  algo\n// Idea:    A random board of Lights Out the size of the panel is solved by light chasing: a front runs down pressing the cell below every lit cell, the lights turn into a record of presses behind it, the leftover on the bottom row is looked up as a set of presses on the top row, and a second chase runs the last lights off the bottom, leaving the record of what was pressed.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lights Out (Tiger Electronics, 1995), the sigma-plus game as linear algebra over GF(2) (Klaus Sutner, 1989), light chasing and the kernel (Marlow Anderson and Todd Feil, Turning Lights Out with Linear Algebra, 1998), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cells=1..4, Record=0..1\n//\n// Knob 1: Hue. Turns the board round the wheel: at 0 the lights are amber, the record of presses is sky blue and a press flashes white.\n// Knob 2: Speed. At 2 a board is built in 0.6 s, the first chase runs down 127 rows in 2.4 s, the bottom row is looked up in 0.7 s and the second chase takes 2.0 s, 7.7 s a board in all. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Cells. Cell size in LEDs: 1 is a board of 64 by 128 cells, 2 is 32 by 64, 3 is 21 by 42, 4 is 16 by 32. Every one of these boards has a kernel of 0, so any pattern of lights has exactly one solution.\n// Knob 4: Record. How long a press stays on the board. At 0.06 and below the record stays until the board is done, and when the second chase ends it is the one solution, cell for cell the random presses that built the board. Turned up, the record fades, at 1 within 0.2 s, and only the lights and the flashes of the chase are left, as on the toy.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst WHITE = [1, 1, 1];\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The game. Pressing a cell toggles it and its four neighbours. The\n// board is a vector over GF(2) and a set of presses x lights A x, where A is\n// the w h by w h matrix of the pluses; solving the board is solving A x = b.\nfunction press(B, w, h, x, y) {\n  const i = y * w + x;\n  B[i] ^= 1;\n  if (x > 0) B[i - 1] ^= 1;\n  if (x \u003c w - 1) B[i + 1] ^= 1;\n  if (y > 0) B[i - w] ^= 1;\n  if (y \u003c h - 1) B[i + w] ^= 1;\n}\n\n// ---- Light chasing. Pressing the cell below every lit cell of a row clears\n// that row and touches nothing above it, so chasing row 0 to row h - 2 leaves\n// lights only on the bottom row. Chasing is linear: the leftover is the sum\n// of what each top-row press alone would leave. Column j of the chase matrix\n// is the bottom row that pressing top cell j and chasing leaves; to clear a\n// leftover r, press the top-row set t with C t = r and chase again.\n// Worked in Node for the four boards here (64x128, 32x64, 21x42, 16x32):\n// C has full rank, so the kernel of A is 0 and every board is solvable. Three\n// rows less is another story: 64x125 has a kernel of dimension 36, and 5x5,\n// the toy, has 2.\nfunction chaseMatrix(w, h) {\n  const C = [], B = new Uint8Array(w * h);\n  for (let j = 0; j \u003c w; j++) {\n    B.fill(0);\n    press(B, w, h, j, 0);\n    for (let y = 0; y \u003c h - 1; y++) for (let x = 0; x \u003c w; x++) if (B[y * w + x]) press(B, w, h, x, y + 1);\n    C.push(B.slice((h - 1) * w));\n  }\n  return C;\n}\n\n// Gaussian elimination over GF(2) for C t = r; free columns, if a board ever\n// has any, are left unpressed.\nfunction solveTop(C, r, w) {\n  const M = [];\n  for (let i = 0; i \u003c w; i++) {\n    const row = new Uint8Array(w + 1);\n    for (let j = 0; j \u003c w; j++) row[j] = C[j][i];\n    row[w] = r[i];\n    M.push(row);\n  }\n  const piv = [];\n  let k = 0;\n  for (let c = 0; c \u003c w && k \u003c w; c++) {\n    let p = -1;\n    for (let i = k; i \u003c w; i++) if (M[i][c]) { p = i; break; }\n    if (p \u003c 0) continue;\n    const tmp = M[k]; M[k] = M[p]; M[p] = tmp;\n    for (let i = 0; i \u003c w; i++) if (i !== k && M[i][c]) for (let q = c; q \u003c= w; q++) M[i][q] ^= M[k][q];\n    piv.push(c);\n    k++;\n  }\n  const t = new Uint8Array(w);\n  for (let i = 0; i \u003c piv.length; i++) t[piv[i]] = M[i][w];\n  return t;\n}\n\n// ---- One board's life, in seconds at Speed 2.\nconst PH = [\"build\", \"hold\", \"chase1\", \"resid\", \"correct\", \"chase2\", \"solved\", \"fade\", \"dark\"];\nconst DUR = { build: 0.6, hold: 0.3, chase1: 2.4, resid: 0.7, correct: 0.35, chase2: 2.0, solved: 0.6, fade: 0.5, dark: 0.25 };\n\nfunction sizeOf(S, c) {\n  if (!S.cache[c]) {\n    const w = floor(W / c), h = floor(H / c);\n    S.cache[c] = { c, w, h, ox: floor((W - w * c) / 2), oy: floor((H - h * c) / 2), C: chaseMatrix(w, h) };\n  }\n  return S.cache[c];\n}\n\nfunction newBoard(S, c) {\n  const z = sizeOf(S, c), n = z.w * z.h;\n  S.z = z;\n  S.L = new Uint8Array(n);\n  S.R = new Uint8Array(n);\n  S.age = new Float32Array(n).fill(99);\n  S.fl = new Float32Array(n);\n  S.fk = new Uint8Array(n);\n  // The board is made the way the toy makes one: by pressing. Each cell is\n  // pressed with probability one half, so the lights are a uniform draw from\n  // the boards that can be solved (here all 2^(w h) of them).\n  const g = [];\n  for (let i = 0; i \u003c n; i++) if (Math.random() \u003c 0.5) g.push(i);\n  for (let i = g.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = g[i];\n    g[i] = g[j];\n    g[j] = t;\n  }\n  S.g = g;\n  S.gi = 0;\n  S.ph = 0;\n  S.u = 0;\n  S.row = 0;\n  S.t = null;\n}\n\n// Chase rows up to (not including) row `to`: press below each lit cell.\nfunction chaseTo(S, to) {\n  const { w, h } = S.z, L = S.L;\n  for (; S.row \u003c min(to, h - 1); S.row++) {\n    const y = S.row;\n    for (let x = 0; x \u003c w; x++)\n      if (L[y * w + x]) {\n        const i = (y + 1) * w + x;\n        press(L, w, h, x, y + 1);\n        mark(S, i);\n      }\n  }\n}\n\n// A press goes into the record (presses are counted mod 2, so a second press\n// on a cell takes the first back) and flashes: white when it adds to the\n// record, rose when it cancels an earlier press.\nfunction mark(S, i) {\n  S.R[i] ^= 1;\n  S.age[i] = 0;\n  S.fl[i] = 1;\n  S.fk[i] = S.R[i] ? 1 : 2;\n}\n\nfunction enter(S, ph) {\n  S.ph = ph;\n  S.u = 0;\n  const { w, h } = S.z;\n  if (PH[ph] === \"chase1\" || PH[ph] === \"chase2\") S.row = 0;\n  if (PH[ph] === \"resid\") S.t = solveTop(S.z.C, S.L.subarray((h - 1) * w), w);\n  if (PH[ph] === \"correct\")\n    for (let x = 0; x \u003c w; x++)\n      if (S.t[x]) {\n        press(S.L, w, h, x, 0);\n        mark(S, x);\n      }\n}\n\nexport function setup(params) {\n  params.s = { cache: {}, hue: 0, rec: 0.06, cells: 1, rgb: new Float32Array(NP * 3) };\n  newBoard(params.s, 1);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.rec = cl(k[3], 0, 1);\n  const c = cl(round(k[2]), 1, 4);\n  if (c !== S.cells) {\n    S.cells = c;\n    newBoard(S, c);\n  }\n  // step is board time: seconds at Speed 2.\n  const step = (d * cl(k[1], 0.2, 3)) / 2, n = S.L.length, ff = exp(-step * 14);\n  for (let i = 0; i \u003c n; i++) {\n    S.age[i] += step;\n    S.fl[i] *= ff;\n  }\n  S.u += step;\n  for (let guard = 0; guard \u003c 16; guard++) {\n    const name = PH[S.ph], T = DUR[name], u = cl(S.u / T, 0, 1);\n    const { w, h } = S.z;\n    if (name === \"build\") {\n      const to = floor(S.g.length * u);\n      for (; S.gi \u003c to; S.gi++) {\n        const i = S.g[S.gi];\n        press(S.L, w, h, i % w, floor(i / w));\n        S.fl[i] = max(S.fl[i], 0.55);\n        S.fk[i] = 0;\n      }\n    } else if (name === \"chase1\" || name === \"chase2\") chaseTo(S, floor(u * (h - 1) + 1e-9));\n    if (S.u \u003c T) break;\n    S.u -= T;\n    if (name === \"dark\") newBoard(S, S.cells);\n    else enter(S, S.ph + 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { c, w, h, ox, oy } = S.z, rgb = S.rgb;\n  const lit = hsv(0.11 + S.hue, 0.78, 0.86), rec = hsv(0.56 + S.hue, 0.72, 0.72), undo = hsv(0.94 + S.hue, 0.6, 1);\n  const name = PH[S.ph], u = cl(S.u / DUR[name], 0, 1);\n  // The fade at the end of a board, and a blink on the leftover bottom row.\n  const all = name === \"fade\" ? 1 - u : name === \"dark\" ? 0 : 1;\n  const blink = name === \"resid\" ? 0.35 + 0.65 * (0.5 + 0.5 * cos(u * 4 * PI)) : 1;\n  // Record fade per second of press age: 0 up to Record 0.06, 30 at 1.\n  const rate = (30 * max(0, S.rec - 0.06)) / 0.94;\n  rgb.fill(0);\n  const g = c >= 3 ? 1 : 0;\n  for (let j = 0; j \u003c h; j++)\n    for (let i = 0; i \u003c w; i++) {\n      const q = j * w + i;\n      let r = 0, gg = 0, b = 0;\n      if (S.L[q]) {\n        const a = j === h - 1 && name === \"resid\" ? blink : 1;\n        r = lit[0] * a;\n        gg = lit[1] * a;\n        b = lit[2] * a;\n      } else if (S.R[q]) {\n        const a = exp(-rate * S.age[q]);\n        r = rec[0] * a;\n        gg = rec[1] * a;\n        b = rec[2] * a;\n      }\n      const f = cl(S.fl[q], 0, 1), fc = S.fk[q] === 2 ? undo : WHITE;\n      r = (r + (fc[0] - r) * f) * all;\n      gg = (gg + (fc[1] - gg) * f) * all;\n      b = (b + (fc[2] - b) * f) * all;\n      if (r + gg + b \u003c= 0) continue;\n      for (let yy = 0; yy \u003c c - g; yy++)\n        for (let xx = 0; xx \u003c c - g; xx++) {\n          const o = ((oy + j * c + yy) * W + ox + i * c + xx) * 3;\n          rgb[o] = r;\n          rgb[o + 1] = gg;\n          rgb[o + 2] = b;\n        }\n    }\n  // The lookup: a thin line rises from the leftover row to the top row,\n  // where the presses it found land.\n  if (name === \"resid\" && u > 0.45) {\n    const y = floor(oy + (h * c - 1) * (1 - (u - 0.45) / 0.55));\n    for (let x = ox; x \u003c ox + w * c; x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] = max(rgb[o], 0.5);\n      rgb[o + 1] = max(rgb[o + 1], 0.5);\n      rgb[o + 2] = max(rgb[o + 2], 0.5);\n    }\n  }\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n","mesostic":"// ===== Patternflow pattern =====\n// Title:   Mesostic\n// Family:  type\n// Idea:    A reader slides through a stretch of Thoreau's Walden in the bottom line until the next letter of a spine word that Cage's mesostic rule allows comes to the centre, the letter locks as a gold capital, the words the rule lets stand stay as its wings and the rest fade, and the page climbs a line, so the spine word reads down the middle of the panel again and again.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: John Cage's mesostics (from the late 1960s; Writing through Finnegans Wake, 1978) and his 50% and 100% rules, written through Henry David Thoreau's Walden (1854); letters from the MatrixLight6 pixel font of trip5's Matrix-Fonts (CC-BY), as the device's firmware carries it; pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Rule=0..1\n//\n// Knob 1: Hue. Turns the capitals and the wings round the wheel together: at 0 the capitals are gold and the wing text pale sky blue.\n// Knob 2: Speed. At 2 the reader slides for 0.45 to 0.95 s depending on how much text it passes over, the capital locks in 0.4 s and the page climbs a line in 0.35 s: a new line every 1.28 s on average with THOREAU. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. The spine: THOREAU, WALDEN, MUREAU (Cage's 1970 piece made from Thoreau's Journal, MUsic and thoREAU) or SILENCE (Cage's 1961 book). The page opens on the first 17 lines of the mesostic; turning it leaves a blank line and the reader starts a new mesostic from where it is.\n// Knob 4: Rule. Below 0.5 a 50% mesostic: between two capitals the second capital's letter does not appear. From 0.5 a 100% mesostic: the first capital's letter does not appear there either, so the wings are shorter and more letters are passed over. Turning it leaves a blank line like Word.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The source. Three passages of Walden (1854), from the chapter \"Where\n// I Lived, and What I Lived For\", in the order the chapter has them, quoted\n// as printed. The reader drops the punctuation, turns hyphens into spaces\n// and reads in lower case: 304 words.\nconst WALDEN = [\n  \"I went to the woods because I wished to live deliberately, to front only the essential facts of life, and see if I could not learn what it had to teach, and not, when I came to die, discover that I had not lived. I did not wish to live what was not life, living is so dear; nor did I wish to practise resignation, unless it was quite necessary. I wanted to live deep and suck out all the marrow of life, to live so sturdily and Spartan-like as to put to rout all that was not life, to cut a broad swath and shave close, to drive life into a corner, and reduce it to its lowest terms, and, if it proved to be mean, why then to get the whole and genuine meanness of it, and publish its meanness to the world; or if it were sublime, to know it by experience, and be able to give a true account of it in my next excursion.\",\n  \"Our life is frittered away by detail. An honest man has hardly need to count more than his ten fingers, or in extreme cases he may add his ten toes, and lump the rest. Simplicity, simplicity, simplicity! I say, let your affairs be as two or three, and not a hundred or a thousand; instead of a million count half a dozen, and keep your accounts on your thumb-nail.\",\n  \"Time is but the stream I go a-fishing in. I drink at it; but while I drink I see the sandy bottom and detect how shallow it is. Its thin current slides away, but eternity remains. I would drink deeper; fish in the sky, whose bottom is pebbly with stars. I cannot count one. I know not the first letter of the alphabet.\",\n];\nconst WORDS = WALDEN.join(\" \").toLowerCase().replace(/-/g, \" \").replace(/[^a-z ]/g, \"\").split(/ +/).filter((w) => w.length > 0);\nconst N = WORDS.length;\nconst mod = (g) => ((g % N) + N) % N;\nconst word = (g) => WORDS[mod(g)];\n\nconst SPINES = [\"THOREAU\", \"WALDEN\", \"MUREAU\", \"SILENCE\"];\n\n// ---- Letters: MatrixLight6, the 6-row pixel font in the device's\n// firmware/patternflow/src/fonts/. Each glyph is its width, its first row\n// (0 for capitals and ascenders, 1 for the x-height, 2 for a's short bowl)\n// and one base-32 digit per row, the high bit on the left. Capitals are 5\n// rows tall; lower case runs 4 rows from row 1 with descenders on row 5.\nconst B32 = \"0123456789abcdefghijklmnopqrstuv\";\nconst UP = \"3025755 3065656 3025452 3065556 3074747 3074744 4068b97 4099f99 1011111 3011152 3055655 3044447 50allhh 409db99 4069996 3065644 40699a5 3065655 3034216 3072222 3055552 3055522 50lllla 3055255 3055222 3071247\";\nconst LO = \"32353 3044656 313443 3011353 313563 3012722 3135312 3044655 1010111 30101152 3044565 1011111 51qlll 316555 312552 3165564 3135531 316544 313436 3027221 315553 315552 51llla 315225 3155312 317127\";\nconst glyph = (code) => ({ w: +code[0], top: +code[1], rows: [...code.slice(2)].map((c) => B32.indexOf(c)) });\nconst CAPS = UP.split(\" \").map(glyph), SMALL = LO.split(\" \").map(glyph);\nconst gOf = (ch, cap) => (cap ? CAPS : SMALL)[ch.charCodeAt(0) - 97];\n// Width of a run of text with its trailing 1 LED gap; a space adds 2 more,\n// so words stand 3 LEDs apart.\nfunction runW(s) {\n  let x = 0;\n  for (const ch of s) x += ch === \" \" ? 2 : gOf(ch, false).w + 1;\n  return x;\n}\n// A capital stands on the middle of the panel, x 31.5.\nconst capX = (w) => round(31.5 - w / 2);\n\n// ---- The reading strip: the whole source in one line of lower case, words\n// 3 LEDs apart. wordX0 is where each word starts; the strip repeats every\n// TOTAL LEDs, so the reading can run round the source.\nconst wordW = WORDS.map((w) => runW(w) - 1);\nconst wordX0 = [];\nlet TOTAL = 0;\nfor (let i = 0; i \u003c N; i++) (wordX0.push(TOTAL), (TOTAL += wordW[i] + 3));\nconst wordX = (g) => floor(g / N) * TOTAL + wordX0[mod(g)];\nfunction readPoint(g, c) {\n  const w = word(g);\n  let x = wordX(g);\n  for (let j = 0; j \u003c c; j++) x += gOf(w[j], false).w + 1;\n  return x + gOf(w[c], false).w / 2;\n}\n\n// ---- The mesostic. Lines go through the source in order, one capital\n// each, the capital in its own word, and every word shown whole: a line is\n// [left wing words] prefix CAPITAL suffix [right wing words]. Cage's rules\n// are about the text between two capitals, the right wing of one line and\n// the left wing of the next:\n//   50%: the second capital's letter does not appear there;\n//   100%: nor does the first capital's letter.\n// Text between the two wings may be passed over, as Cage passed it over.\n// A word can carry the capital only where its own prefix and suffix keep\n// the rule (the suffix lies before the next capital, so it may not hold the\n// next spine letter) and where both fit their half of the panel. Wings take\n// whole words outward until a word holds a forbidden letter or the half is\n// full; when both wings want the same words in a short gap they split it.\n// Checked in Node over 3000 lines for each spine and rule: no line breaks\n// its rule, and THOREAU at 50% sets 49 capitals a pass through the 304\n// words on average, 35 at 100%.\nfunction newGen(spine, full, from) {\n  return { spine, full, k: 0, from, cur: null };\n}\nfunction pick(G, k, from) {\n  const S = G.spine, L = S.length;\n  const s = S[k % L].toLowerCase(), sp = S[(k + L - 1) % L].toLowerCase(), sn = S[(k + 1) % L].toLowerCase();\n  for (let g = from; g \u003c from + 4 * N; g++) {\n    const w = word(g), c = w.indexOf(s);\n    if (c \u003c 0) continue;\n    const pre = w.slice(0, c), suf = w.slice(c + 1);\n    if (suf.includes(sn)) continue;\n    if (G.full && ((k > 0 && pre.includes(sp)) || suf.includes(s))) continue;\n    const cw = gOf(s, true).w, cx = capX(cw);\n    if (runW(pre) > cx || runW(suf) - 1 > W - (cx + cw + 1)) continue;\n    return { g, c, k, s, cx, cw, pre, suf, left: [], right: [] };\n  }\n  return null;\n}\nconst holds = (w, F) => F.some((f) => w.includes(f));\nfunction extendLeft(line, lo, F) {\n  const out = [];\n  let txt = line.pre.length ? \" \" + line.pre : \" \";\n  for (let g = line.g - 1; g >= lo; g--) {\n    const w = word(g);\n    if (holds(w, F) || runW(w + txt) > line.cx) break;\n    out.unshift(g);\n    txt = \" \" + w + txt;\n  }\n  return out;\n}\nfunction extendRight(line, hi, F) {\n  const out = [];\n  let txt = line.suf;\n  for (let g = line.g + 1; g \u003c= hi; g++) {\n    const w = word(g), t = txt + \" \" + w;\n    if (holds(w, F) || runW(t) - 1 > W - (line.cx + line.cw + 1)) break;\n    out.push(g);\n    txt = t;\n  }\n  return out;\n}\n// The next finished line: it needs the capital after it to know where its\n// right wing must stop.\nfunction nextLine(G) {\n  if (!G.cur) {\n    G.cur = pick(G, 0, G.from);\n    G.cur.left = extendLeft(G.cur, G.from, [G.cur.s]);\n  }\n  const cur = G.cur, nx = pick(G, cur.k + 1, cur.g + 1);\n  const F = G.full ? [nx.s, cur.s] : [nx.s];\n  let right = extendRight(cur, nx.g - 1, F), left = extendLeft(nx, cur.g + 1, F);\n  if (right.length && left.length && left[0] \u003c= right[right.length - 1]) {\n    const mid = floor((left[0] + right[right.length - 1]) / 2);\n    right = right.filter((g) => g \u003c= mid);\n    left = left.filter((g) => g > mid);\n  }\n  cur.right = right;\n  nx.left = left;\n  G.cur = nx;\n  return layout(cur);\n}\n\n// Glyphs of a finished line, placed outward from the capital.\nfunction layout(line) {\n  const out = [{ gl: gOf(line.s, true), x: line.cx, cap: true }];\n  const lt = line.left.map(word).join(\" \") + (line.left.length ? \" \" : \"\") + line.pre;\n  const rt = line.suf + (line.right.length ? \" \" : \"\") + line.right.map(word).join(\" \");\n  let x = line.cx;\n  for (let i = lt.length - 1; i >= 0; i--) {\n    if (lt[i] === \" \") x -= 2;\n    else {\n      const gl = gOf(lt[i], false);\n      x -= gl.w + 1;\n      out.push({ gl, x, cap: false });\n    }\n  }\n  x = line.cx + line.cw + 1;\n  for (const ch of rt) {\n    if (ch === \" \") x += 2;\n    else {\n      const gl = gOf(ch, false);\n      out.push({ gl, x, cap: false });\n      x += gl.w + 1;\n    }\n  }\n  const lastG = line.right.length ? line.right[line.right.length - 1] : line.g;\n  return { glyphs: out, s: line.s, rp: readPoint(line.g, line.c), end: lastG + 1, blank: false };\n}\n\n// ---- Page. Eighteen slots of 7 rows (6 for the font, 1 between), rows 1\n// to 126; the bottom slot is the reading strip, the 17 above hold the\n// finished lines, the newest lowest.\nconst PITCH = 7, SLOTS = 18;\nconst slotY = (j) => 1 + PITCH * j;\n\nfunction start(S) {\n  S.gen = newGen(SPINES[S.word], S.full, 0);\n  S.page = [];\n  for (let i = 0; i \u003c SLOTS - 1; i++) S.page.push(nextLine(S.gen));\n  S.next = nextLine(S.gen);\n  S.from = S.page[S.page.length - 1].rp;\n  S.phase = 0;\n  S.t = 0;\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, word: 0, full: false, seen: false, page: null, rgb: new Float32Array(NP * 3) };\n  start(params.s);\n}\n\n// Phase 0 slides the strip from the last capital to the next, 1 locks the\n// capital and fades the passed-over text, 2 climbs the page a line.\nfunction phaseDur(S) {\n  if (S.phase === 0) return 0.45 + 0.5 * min(1, (S.next.rp - S.from) / 600);\n  return S.phase === 1 ? 0.4 : 0.35;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const wd = cl(round(k[2]), 0, 3), full = cl(k[3], 0, 1) >= 0.5;\n  if (!S.seen) {\n    // The first frame opens on the mesostic the knobs ask for.\n    S.seen = true;\n    if (wd !== S.word || full !== S.full) ((S.word = wd), (S.full = full), start(S));\n  }\n  if (wd !== S.word || full !== S.full) {\n    S.word = wd;\n    S.full = full;\n    // A new mesostic from where the reading stands, after a blank line. The\n    // line on its way is dropped unless it is already locking.\n    if (S.phase === 1) S.page.push(S.next);\n    const last = S.page[S.page.length - 1];\n    S.gen = newGen(SPINES[wd], full, last.end);\n    S.page.push({ blank: true, glyphs: [], rp: last.rp, end: last.end });\n    while (S.page.length > SLOTS + 1) S.page.shift();\n    S.next = nextLine(S.gen);\n    S.from = last.rp;\n    S.phase = 2;\n    S.t = 0;\n  }\n  S.t += (d * S.speed) / 2;\n  for (let guard = 0; guard \u003c 8; guard++) {\n    const T = phaseDur(S);\n    if (S.t \u003c T) break;\n    S.t -= T;\n    if (S.phase === 0) S.phase = 1;\n    else if (S.phase === 1) {\n      S.page.push(S.next);\n      while (S.page.length > SLOTS + 1) S.page.shift();\n      S.from = S.next.rp;\n      S.next = nextLine(S.gen);\n      S.phase = 2;\n    } else S.phase = 0;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0.004) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a);\n    rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n    rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n  // A glyph at x (fractional while the strip slides, split over two\n  // columns) with its top on row y.\n  const stamp = (gl, x, y, c, a) => {\n    const xi = floor(x), f = x - xi;\n    for (let r = 0; r \u003c gl.rows.length; r++) {\n      const bits = gl.rows[r], yy = y + gl.top + r;\n      for (let i = 0; i \u003c gl.w; i++)\n        if ((bits >> (gl.w - 1 - i)) & 1) {\n          if (f \u003c 0.01) put(xi + i, yy, c, a);\n          else (put(xi + i, yy, c, a * (1 - f)), put(xi + i + 1, yy, c, a * f));\n        }\n    }\n  };\n  const gold = hsv(0.12 + S.hue, 0.85, 1), sky = hsv(0.56 + S.hue, 0.5, 0.88), white = [1, 0.97, 0.9];\n  const T = phaseDur(S), u = cl(S.t / T, 0, 1);\n  const climb = S.phase === 2 ? ease(u) : 1, shift = round(PITCH * (1 - climb));\n\n  // ---- Finished lines. The newest is lowest; each line dims a little with\n  // every slot it has climbed, to 55% at the top.\n  const n = S.page.length;\n  for (let j = 0; j \u003c n; j++) {\n    const line = S.page[j];\n    if (line.blank) continue;\n    const slot = SLOTS - 2 - (n - 1 - j), y = slotY(slot) + shift;\n    if (y \u003c -6 || y >= H) continue;\n    const age = 0.55 + 0.45 * cl(y / slotY(SLOTS - 2), 0, 1);\n    for (const g of line.glyphs) stamp(g.gl, g.x, y, g.cap ? gold : sky, age);\n  }\n\n  // ---- The reading strip in the bottom slot. Its text is dim, brighter\n  // under the reading point in the middle, and the letters the spine wants\n  // next glint gold as they pass.\n  const yS = slotY(SLOTS - 1) + shift;\n  let rp, sa;\n  if (S.phase === 0) (rp = S.from + (S.next.rp - S.from) * ease(u)), (sa = 1);\n  else if (S.phase === 1) (rp = S.next.rp), (sa = 1 - ease(u));\n  else (rp = S.from), (sa = climb);\n  if (sa > 0) {\n    const off = 31.5 - rp, view = rp - 31.5;\n    let g = floor(view / TOTAL) * N;\n    while (wordX(g + 1) \u003c= view) g++;\n    const want = S.next.s;\n    for (; wordX(g) + off \u003c W; g++) {\n      const w = word(g);\n      let x = wordX(g) + off;\n      for (const ch of w) {\n        const gl = gOf(ch, false), dx = x + gl.w / 2 - 31.5;\n        const a = sa * (0.3 + 0.4 * exp(-(dx * dx) / 120));\n        stamp(gl, x, yS, ch === want ? gold : sky, ch === want ? a * 1.2 : a);\n        x += gl.w + 1;\n      }\n    }\n  }\n  // The line that is locking fades in over the strip, its capital flashing\n  // white and cooling to gold.\n  if (S.phase === 1) {\n    const e = ease(u), cap = [0, 1, 2].map((q) => white[q] + (gold[q] - white[q]) * ease(u * 1.4));\n    for (const g of S.next.glyphs) stamp(g.gl, g.x, yS, g.cap ? cap : sky, g.cap ? 0.5 + 0.5 * min(1, u * 4) : e);\n  }\n\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","miura-ori":"// ===== Patternflow pattern =====\n// Title:   Miura-ori\n// Family:  space\n// Idea:    A Miura-ori sheet of congruent parallelograms, bigger than the panel, folds and opens again on its one degree of freedom, seen in 3D from a little below, so its facets split into four kinds that flip between a warm key light, a cool fill, both and neither as the fold deepens, its mountain and valley creases show as light and dark lines, and at the deepest fold the sheet has shrunk across and down at once until its edges come into view on all four sides.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Miura-ori (Koryo Miura, 1970; \"Method of packaging and deployment of large membranes in space\", 1985), its closed-form rigid folding and in-plane Poisson ratio (Mark Schenk and Simon Guest, 2013), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sector=55..85, Light=0..1\n//\n// Knob 1: Hue. The colour of the two lights, which keep opposite hues. At 0 the key is amber and the fill blue, so a facet that faces both is cream, one that faces only the key amber, only the fill blue, and neither almost black; at 0.5 the key is sky blue and the fill salmon.\n// Knob 2: Speed. At 2 the sheet folds from almost flat to its deepest fold in 4 s and opens again in 4 s; 40 s each way at 0.2 and 2.7 s at 3.\n// Knob 3: Sector. The sector angle alpha, the acute angle between each parallelogram's 12 and 10 LED sides, from 55 to 85 degrees. At 55 the deepest fold shrinks the sheet to 57% across and 67% down, and halfway there it shrinks 0.66% across for every 1% down. At 70 it goes to 78% and 52%. At 85 the facets are nearly rectangles, the sheet only shortens, to 51%, and the creases run as straight bands.\n// Knob 4: Light. Walks both lights once round the sheet. The key stands 45 degrees up and the fill 15 degrees up a quarter turn round from it; at 0.06 the key comes from the top of the panel and the fill from its right.\n\nconst W = 64, H = 128, SW = 128, SH = 256, NS = SW * SH;\nconst { floor, ceil, round, sqrt, cos, sin, acos, min, max, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst DEG = PI / 180;\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- The fold. A Miura-ori is a translational surface, P(i, j) = A(i) + B(j),\n// with A a zigzag in the (v, z) plane whose steps are\n//   eb(i) = (0, b cos psi, +-b sin psi)\n// and B a zigzag in the (u, v) plane whose steps are\n//   ea(j) = (a sin g, +-a cos g, 0).\n// Every facet is then a parallelogram with sides eb(i) and ea(j), so its\n// sides stay b and a whatever psi is, and its angle stays alpha (or pi -\n// alpha, the same parallelogram turned over) while eb.ea = +-ab cos alpha,\n// that is cos psi cos g = cos alpha. psi = 0 is the flat sheet (g = alpha)\n// and psi = alpha the sheet folded flat into a packet (g = 0); psi is the\n// fold's one degree of freedom. It is Schenk and Guest's closed form with\n// sin psi = sin theta sin alpha, theta the angle between each facet and the\n// sheet's plane. u runs across the panel, v down it, z out of the sheet\n// towards the eye. Checked in Node for alpha from 55 to 85 degrees by 1 and\n// psi from 0 to alpha in 400 steps, 12,431 shapes of 187 facets: every side\n// stays 12 or 10 to within 6e-14, every corner's cosine stays cos alpha to\n// within 2e-15, every facet stays flat to within 3e-14, and the four angles\n// round each inside vertex add to 2 pi to within 6e-15.\n// 17 facets down and 11 across: flat, the sheet is 191 rows by 90 LEDs on\n// the panel; at the deepest fold at 55 degrees it is 125 by 52.\nconst M = 17, N = 11, NV = (M + 1) * (N + 1);\nconst B_LEN = 12, A_LEN = 10;\nfunction sheet(alpha, psi, out) {\n  const g = acos(cl(cos(alpha) / cos(psi), -1, 1));\n  const bv = B_LEN * cos(psi), bz = B_LEN * sin(psi), au = A_LEN * sin(g), av = A_LEN * cos(g);\n  const u0 = (N * au) / 2, v0 = (M * bv + av) / 2;\n  let k = 0;\n  for (let i = 0; i \u003c= M; i++)\n    for (let j = 0; j \u003c= N; j++) {\n      out[k++] = j * au - u0;\n      out[k++] = i * bv + (j & 1) * av - v0;\n      out[k++] = (i & 1) * bz - bz / 2;\n    }\n  return g;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, alpha: 55 * DEG, light: 0.06,\n    P: new Float64Array(NV * 3), sx: new Float32Array(NV), sy: new Float32Array(NV),\n    key: new Float32Array(3), fill: new Float32Array(3),\n    id: new Int16Array(NS), mark: new Uint8Array(NS),\n    col: new Float32Array(M * N * 3), mv: new Int8Array(M * N * 2),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 55, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.alpha = cl(k[2], 55, 85) * DEG;\n  S.light = cl(k[3], 0, 1);\n  S.t += (d * S.speed) / 2;\n}\n\nconst TILT = 24 * DEG; // how far the eye leans from straight above\nconst FOLD = 8; // seconds a fold and an opening at Speed 2\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { P, sx, sy, id, mark, col, mv, key, fill } = S;\n  const f = 0.5 - 0.5 * cos((2 * PI * S.t) / FOLD);\n  // psi runs from 3% to 100% of its deepest, 0.9 alpha or 60 degrees,\n  // whichever is less: at 55 degrees the facets fold up to 68 degrees from\n  // the sheet's plane.\n  const psi = min(S.alpha * 0.9, PI / 3) * (0.03 + 0.97 * f);\n  sheet(S.alpha, psi, P);\n  const ct = cos(TILT), st = sin(TILT);\n  // Vertices on the sample grid, two samples per LED each way. The eye looks\n  // down at the sheet leaning TILT towards the bottom of the panel, so z\n  // lifts a point up the screen.\n  for (let k = 0, q = 0; k \u003c NV; k++, q += 3) {\n    sx[k] = (W / 2 + P[q]) * 2;\n    sy[k] = (H / 2 + P[q + 1] * ct - P[q + 2] * st) * 2;\n  }\n  // Lights, in sheet coordinates: the key from the Light knob's side, 45\n  // degrees up; the fill a quarter turn round from it, 15 degrees up. A\n  // facet's four kinds (its row tilting up or down the sheet, its column\n  // left or right) take these two lights four ways.\n  const az = 2 * PI * (S.light + 0.69), e1 = 45 * DEG, e2 = 15 * DEG;\n  const az2 = az + PI / 2, k1x = cos(e1) * cos(az), k1y = cos(e1) * sin(az), k1z = sin(e1), k2x = cos(e2) * cos(az2), k2y = cos(e2) * sin(az2), k2z = sin(e2);\n  hsv(0.1 + S.hue, 0.7, 1, key, 0);\n  hsv(0.58 + S.hue, 0.9, 0.75, fill, 0);\n  id.fill(-1);\n  for (let i = 0; i \u003c M; i++)\n    for (let j = 0; j \u003c N; j++) {\n      const v0 = i * (N + 1) + j, v1 = v0 + 1, v3 = v0 + N + 1, v2 = v3 + 1, fi = i * N + j;\n      // Normal from the sides at P(i, j), turned to the front of the sheet (+z).\n      const q0 = v0 * 3, q1 = v1 * 3, q3 = v3 * 3;\n      const ax = P[q3] - P[q0], ay = P[q3 + 1] - P[q0 + 1], az3 = P[q3 + 2] - P[q0 + 2], bx = P[q1] - P[q0], by = P[q1 + 1] - P[q0 + 1], bz = P[q1 + 2] - P[q0 + 2];\n      let nx = ay * bz - az3 * by, ny = az3 * bx - ax * bz, nz = ax * by - ay * bx;\n      const nl = sqrt(nx * nx + ny * ny + nz * nz) || 1;\n      (nx /= nl), (ny /= nl), (nz /= nl);\n      if (nz \u003c 0) (nx = -nx), (ny = -ny), (nz = -nz);\n      // The back of the sheet shows where the turned normal points away from the eye.\n      const sgn = ny * st + nz * ct >= 0 ? 1 : -1;\n      const d1 = max(0, sgn * (nx * k1x + ny * k1y + nz * k1z)), d2 = max(0, sgn * (nx * k2x + ny * k2y + nz * k2z)), back = sgn \u003c 0 ? 0.5 : 1;\n      for (let c = 0; c \u003c 3; c++) col[fi * 3 + c] = back * (0.1 + key[c] * d1 + fill[c] * d2);\n      // Mountain or valley for the crease to the next facet down (side 0)\n      // and across (side 1): a mountain when that facet's far corner lies\n      // below this facet's plane.\n      if (i + 1 \u003c M) {\n        const q = (v3 + N + 1) * 3;\n        mv[fi * 2] = (P[q] - P[q3]) * nx + (P[q + 1] - P[q3 + 1]) * ny + (P[q + 2] - P[q3 + 2]) * nz \u003c 0 ? 1 : 2;\n      }\n      if (j + 1 \u003c N) {\n        const q = (v1 + 1) * 3;\n        mv[fi * 2 + 1] = (P[q] - P[q1]) * nx + (P[q + 1] - P[q1 + 1]) * ny + (P[q + 2] - P[q1 + 2]) * nz \u003c 0 ? 1 : 2;\n      }\n      // Rasterize. Seen from straight above, the folded sheet is a height\n      // field over (u, v), and a ray from the eye leaning towards +v meets\n      // larger v first, so drawing the rows in order down the sheet leaves\n      // the nearest facet on top (checked against a depth buffer: the same\n      // frames).\n      const X0 = sx[v0], Y0 = sy[v0];\n      const ux = sx[v1] - X0, uy = sy[v1] - Y0, wx = sx[v3] - X0, wy = sy[v3] - Y0;\n      const det = ux * wy - uy * wx;\n      if (abs(det) \u003c 1e-6) continue;\n      const xmin = max(0, floor(min(X0, sx[v1], sx[v2], sx[v3]))), xmax = min(SW - 1, ceil(max(X0, sx[v1], sx[v2], sx[v3])));\n      const ymin = max(0, floor(min(Y0, sy[v1], sy[v2], sy[v3]))), ymax = min(SH - 1, ceil(max(Y0, sy[v1], sy[v2], sy[v3])));\n      const inv = 1 / det, da = wy * inv, db = -uy * inv;\n      for (let y = ymin; y \u003c= ymax; y++) {\n        const ry = y + 0.5 - Y0, rx = xmin + 0.5 - X0;\n        // The sample as a + b along the two sides is inside when both lie in\n        // 0..1; along a row each is linear in x, so the row's run is solved\n        // for, not searched.\n        const a0 = (rx * wy - ry * wx) * inv, b0 = (ux * ry - uy * rx) * inv;\n        let lo = 0, hi = xmax - xmin;\n        for (let e = 0; e \u003c 2; e++) {\n          const v0 = e ? b0 : a0, dv = e ? db : da;\n          if (abs(dv) \u003c 1e-12) {\n            if (v0 \u003c 0 || v0 > 1) hi = -1;\n          } else {\n            const t0 = -v0 / dv, t1 = (1 - v0) / dv;\n            lo = max(lo, ceil(t0 \u003c t1 ? t0 : t1));\n            hi = min(hi, floor(t0 \u003c t1 ? t1 : t0));\n          }\n        }\n        for (let k = y * SW + xmin + lo, e = y * SW + xmin + hi; k \u003c= e; k++) id[k] = fi;\n      }\n    }\n  // Lines: a sample whose right or lower neighbour belongs to another facet\n  // is on a crease (1 mountain, 2 valley) or on an edge where one part of\n  // the sheet passes in front of another (3).\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      const p = y * SW + x, a = id[p];\n      mark[p] = 0;\n      if (a \u003c 0) continue;\n      let t = 0;\n      for (let side = 0; side \u003c 2; side++) {\n        if (side === 0 ? x + 1 >= SW : y + 1 >= SH) continue;\n        const b = id[side === 0 ? p + 1 : p + SW];\n        if (b === a || b \u003c 0) continue;\n        const lo = min(a, b), d = abs(a - b);\n        let m = 3;\n        if (d === N) m = mv[lo * 2];\n        else if (d === 1 && ((a / N) | 0) === ((b / N) | 0)) m = mv[lo * 2 + 1];\n        if (m > t) t = m;\n      }\n      mark[p] = t;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      for (let s = 0; s \u003c 4; s++) {\n        const p = (2 * y + (s >> 1)) * SW + 2 * x + (s & 1), a = id[p];\n        if (a \u003c 0) continue;\n        let cr = col[a * 3], cg = col[a * 3 + 1], cb = col[a * 3 + 2];\n        const m = mark[p];\n        if (m === 1) (cr = 0.45 + 0.55 * cr), (cg = 0.45 + 0.55 * cg), (cb = 0.45 + 0.55 * cb);\n        else if (m >= 2) (cr *= 0.2), (cg *= 0.2), (cb *= 0.2);\n        (r += cr), (g += cg), (b += cb);\n      }\n      display.setPixel(x, y, round(min(255, 63.75 * r)), round(min(255, 63.75 * g)), round(min(255, 63.75 * b)));\n    }\n}\n","prandtl-membrane":"// ===== Patternflow pattern =====\n// Title:   Prandtl's Membrane\n// Family:  type\n// Idea:    A bar whose cross-section is a word is twisted, and each letter is Prandtl's film stretched over a hole of its shape and blown up from below, so the letters breathe as lit pillows and hollow letters rise as plateaus round a flat plate, coloured by the shear stress, which is zero along each crest, runs hot along the rims and hottest in the inside corners.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: torsion of prismatic bars (Adhémar Barré de Saint-Venant, 1855), the membrane analogy (Ludwig Prandtl, 1903), thin-walled tubes (Rudolf Bredt, 1896), the Shortley-Weller boundary stencil (George Shortley and Royal Weller, 1938), successive over-relaxation (David Young, 1950), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Twist=0.2..3, Word=0..3, Lamp=0..1\n//\n// Knob 1: Hue. Turns the stress colours round the wheel: at 0 the crests, where the stress is zero, are blue, the rims run from magenta through red to orange, and the hottest places, inside corners and the outer walls of the hollow letters, burn yellow-orange. The plates in the holes take the blue, dim.\n// Knob 2: Twist. How hard the bar is twisted, which is how hard the film is blown up. Each breath, one every 4 s, swings the twist from 40% to 100% of the knob. At 2 the film stands at 56 degrees at the rim of the 14 LED bar of ㅜ at the top of a breath and 31 at the bottom, and the colour reaches its hot end at a stress of 12.7. At 0.2 the film over that bar tilts 9 degrees at most and the colours stay blue and violet; at 3 the same rim stands at 66 degrees and runs yellow.\n// Knob 3: Word. The cross-section: the syllable 숨 (breath) the height of the panel, then LIT, AIR and HOT, three capitals 56 by 38 LEDs stacked. A letter with a hole is a hollow section, and the hole is a flat plate the film lifts: at the same twist HOT carries four times the torque of LIT.\n// Knob 4: Lamp. How high the lamp stands as it walks round the word once in 12 s: 19 degrees at 0.06, low enough that each stroke is lit on one side and shaded on the other, with a pale glint halfway down the flank that faces the lamp; 75 degrees at 1, where the film is lit almost evenly, the glint rides the crests and mostly the colours move.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, cos, sin, min, max, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Letters, as unions of convex polygons in LEDs. The capitals sit in a\n// box 56 wide and 38 tall, stems 13 thick and bars 7 to 11, at rows 3, 46\n// and 89; the syllable 숨 fills the panel, ㅅ in rows 2 to 46, ㅜ in 51 to\n// 81 and ㅁ, a hollow box with walls 14 to 15 thick, in 85 to 126. Corners\n// are left sharp: the film is flat at an outside corner and infinitely steep\n// at an inside one, and both should show.\nconst R = (a, b, c, d) => [[a, b], [c, b], [c, d], [a, d]];\nconst TOP = [[0, 9], [9, 0], [47, 0], [56, 9], [56, 11], [0, 11]];\nconst LAT = {\n  L: [R(0, 0, 13, 38), R(13, 27, 56, 38)],\n  I: [R(6, 0, 50, 11), R(21, 11, 35, 27), R(6, 27, 50, 38)],\n  T: [R(0, 0, 56, 11), R(21, 11, 35, 38)],\n  A: [TOP, R(0, 11, 13, 38), R(43, 11, 56, 38), R(13, 20, 43, 29)],\n  R: [R(0, 0, 13, 38), [[13, 0], [47, 0], [56, 9], [56, 11], [13, 11]], R(43, 11, 56, 18), [[13, 18], [56, 18], [56, 21], [49, 28], [13, 28]], [[30, 28], [43, 28], [56, 36], [56, 38], [43, 38]]],\n  H: [R(0, 0, 13, 38), R(43, 0, 56, 38), R(13, 14, 43, 24)],\n  O: [TOP, [[0, 27], [56, 27], [56, 29], [47, 38], [9, 38], [0, 29]], R(0, 11, 13, 27), R(43, 11, 56, 27)],\n};\nconst SUM = [\n  [[23, 2], [41, 2], [18, 46], [0.5, 46]], // ㅅ, left stroke\n  [[19, 30], [27, 17], [63.5, 38], [63.5, 46], [46, 46]], // ㅅ, right stroke\n  R(0.5, 51, 63.5, 65), R(24, 65, 40, 81), // ㅜ\n  R(3, 85, 61, 99), R(3, 112, 61, 126), R(3, 99, 18, 112), R(46, 99, 61, 112), // ㅁ\n];\nconst WORDS = [\"숨\", \"LIT\", \"AIR\", \"HOT\"];\n\nfunction wordPolys(word) {\n  if (word === \"숨\") return SUM;\n  const out = [];\n  [...word].forEach((ch, i) => {\n    for (const poly of LAT[ch]) out.push(poly.map(([x, y]) => [x + 4, y + 3 + 43 * i]));\n  });\n  return out;\n}\n\n// Each convex polygon as its edge lines, outward normal (nx, ny) and offset,\n// so the largest n.p - c over the edges is negative inside and positive out.\nfunction edgesOf(poly) {\n  let cx = 0, cy = 0;\n  for (const [x, y] of poly) (cx += x / poly.length), (cy += y / poly.length);\n  return poly.map(([x0, y0], i) => {\n    const [x1, y1] = poly[(i + 1) % poly.length];\n    let nx = y1 - y0, ny = x0 - x1;\n    const l = sqrt(nx * nx + ny * ny);\n    (nx /= l), (ny /= l);\n    if (nx * (cx - x0) + ny * (cy - y0) > 0) (nx = -nx), (ny = -ny);\n    return [nx, ny, nx * x0 + ny * y0];\n  });\n}\n\n// ---- The film. Saint-Venant's stress function phi solves lap(phi) = -2\n// (twist and shear modulus taken as 1) inside the section with phi = 0 on\n// its outline, the shear stress is |grad phi| and the torque is twice the\n// volume under phi. Prandtl saw the same equation in a film stretched over a\n// hole of that shape and blown up from below. It is solved on a grid of half\n// LEDs, 128 by 256 nodes at ((i + 1/2)/2, (j + 1/2)/2), by successive\n// over-relaxation, ten sweeps a frame until no node moves by more than 0.01,\n// so a new word inflates as the solver relaxes: 116 to 144 sweeps, half a\n// second. Next to the outline a node uses the Shortley-Weller stencil with\n// its true distance to the edge along each grid line, so a slanted outline is\n// not a staircase. A hole makes a hollow section: phi is constant round the\n// hole, a weightless flat plate the film lifts, and the plate settles where\n// the pressure on its area balances the film's pull round its rim. That is\n// the condition that the stress circulates round the hole twice the hole's\n// area, the one Bredt's formula for thin tubes rests on.\n//\n// Checked in Node with this solver: on a circle of radius 20 the film peaks\n// at 199.79 against a^2/2 = 200, phi is within 0.18 of (a^2 - r^2)/2\n// everywhere, and the largest stress is 19.98 against a = 20, at the rim. On\n// a 40 by 8 strip the largest stress is at the middle of a long side, 7.50\n// at the node a quarter LED in from the edge, where the strip's 2y gives 7.5.\n// In a square tube 40 across with walls 6 the plate stands at 108.7 against\n// 102 from Bredt's thin-wall formula, and the stress in the middle of a wall\n// is 17.6 against Bredt's 17.0. The walls of 숨's ㅁ are too thick for Bredt:\n// its plate stands at 268, and across the bottom wall the stress climbs from\n// 6 at the plate to 31 at the outline.\nconst FW = 128, FH = 256, NN = FW * FH, HS = 0.5;\nfunction buildFilm(word) {\n  // Each polygon is measured only over its own box and 2 LEDs round it;\n  // everywhere else is plainly outside.\n  const d = new Float32Array(NN).fill(2);\n  for (const poly of wordPolys(word)) {\n    const e = edgesOf(poly).flat(), ne = e.length, xs = poly.map((q) => q[0]), ys = poly.map((q) => q[1]);\n    const i0 = max(0, floor((min(...xs) - 2) / HS)), i1 = min(FW - 1, floor((max(...xs) + 2) / HS));\n    const j0 = max(0, floor((min(...ys) - 2) / HS)), j1 = min(FH - 1, floor((max(...ys) + 2) / HS));\n    for (let j = j0; j \u003c= j1; j++)\n      for (let i = i0; i \u003c= i1; i++) {\n        const x = (i + 0.5) * HS, y = (j + 0.5) * HS;\n        let m = -1e9;\n        for (let k = 0; k \u003c ne; k += 3) {\n          const v = e[k] * x + e[k + 1] * y - e[k + 2];\n          if (v > m) m = v;\n        }\n        if (m \u003c d[j * FW + i]) d[j * FW + i] = m;\n      }\n  }\n  // 0 outside, 1 film, 2 + k hole k: a gap no path from the panel's edge reaches.\n  const type = new Int16Array(NN), seen = new Uint8Array(NN), stack = new Int32Array(4 * NN + 8);\n  for (let p = 0; p \u003c NN; p++) if (d[p] \u003c 0) type[p] = 1;\n  const fill = (starts, mark) => {\n    let top = 0, n = 0;\n    for (const p of starts) stack[top++] = p;\n    while (top) {\n      const p = stack[--top];\n      if (seen[p] || type[p] === 1) continue;\n      seen[p] = 1;\n      type[p] = mark;\n      n++;\n      const x = p % FW;\n      if (x > 0) stack[top++] = p - 1;\n      if (x \u003c FW - 1) stack[top++] = p + 1;\n      if (p >= FW) stack[top++] = p - FW;\n      if (p \u003c NN - FW) stack[top++] = p + FW;\n    }\n    return n;\n  };\n  const rim = [];\n  for (let i = 0; i \u003c FW; i++) rim.push(i, NN - FW + i);\n  for (let j = 0; j \u003c FH; j++) rim.push(j * FW, j * FW + FW - 1);\n  fill(rim, 0);\n  const area = [];\n  for (let p = 0; p \u003c NN; p++) if (!seen[p] && type[p] !== 1) area.push(fill([p], 2 + area.length) * HS * HS);\n  const holes = area.length;\n  // Film nodes and their stencils. A neighbour slot points into V: a film\n  // node's own index, NN for the outline (0), or NN + 1 + k for hole k's rim.\n  const cells = [];\n  for (let p = 0; p \u003c NN; p++) if (type[p] === 1) cells.push(p);\n  const n = cells.length, idx = new Int32Array(n * 4), cof = new Float32Array(n * 5), th = new Float32Array(n * 4);\n  const links = Array.from({ length: holes }, () => []);\n  const OFF = [-1, 1, -FW, FW];\n  for (let c = 0; c \u003c cells.length; c++) {\n    const p = cells[c];\n    for (let k = 0; k \u003c 4; k++) {\n      const q = p + OFF[k];\n      if (type[q] === 1) (idx[c * 4 + k] = q), (th[c * 4 + k] = 1);\n      else {\n        const t = cl(d[p] / (d[p] - d[q]), 0.08, 1);\n        th[c * 4 + k] = t;\n        if (type[q] >= 2) (idx[c * 4 + k] = NN + 1 + type[q] - 2), links[type[q] - 2].push(c, t);\n        else idx[c * 4 + k] = NN;\n      }\n    }\n    // Shortley-Weller: d2/dx2 ~ 2/(a b (a+b)) (b uL + a uR - (a+b) u), a, b the arms.\n    for (let ax = 0; ax \u003c 2; ax++) {\n      const a = th[c * 4 + ax * 2], b = th[c * 4 + ax * 2 + 1];\n      cof[c * 5 + ax * 2] = 2 / (a * (a + b));\n      cof[c * 5 + ax * 2 + 1] = 2 / (b * (a + b));\n      cof[c * 5 + 4] += 2 / (a * b);\n    }\n  }\n  for (let k = 0; k \u003c holes; k++) {\n    let corr = 0;\n    for (let i = 1; i \u003c links[k].length; i += 2) corr += 0.5 - links[k][i];\n    area[k] += corr * HS * HS;\n  }\n  return { cells: Int32Array.from(cells), idx, cof, th, links, area, holes, type, V: new Float32Array(NN + 1 + holes), n, settled: false, sweeps: 0, gx: new Float32Array(NN), gy: new Float32Array(NN), lgx: new Float32Array(W * H), lgy: new Float32Array(W * H), lin: new Uint8Array(W * H), lplate: new Uint8Array(W * H) };\n}\n\n// One sweep. The node update is the stencil solved for its centre, with the\n// -2 on the right scaled by h^2. Each hole's plate then moves to the height\n// where the film's pull round its rim, sum (K - phi)/theta over the links,\n// balances twice its area.\nfunction sweep(F, w) {\n  const { cells, idx, cof, V, n } = F, src = 2 * HS * HS;\n  let change = 0;\n  for (let c = 0; c \u003c n; c++) {\n    const p = cells[c], i4 = c * 4, i5 = c * 5;\n    const g = (cof[i5] * V[idx[i4]] + cof[i5 + 1] * V[idx[i4 + 1]] + cof[i5 + 2] * V[idx[i4 + 2]] + cof[i5 + 3] * V[idx[i4 + 3]] + src) / cof[i5 + 4];\n    const dv = w * (g - V[p]);\n    V[p] += dv;\n    if (abs(dv) > change) change = abs(dv);\n  }\n  for (let k = 0; k \u003c F.holes; k++) {\n    const L = F.links[k];\n    let s = 0, inv = 0;\n    for (let i = 0; i \u003c L.length; i += 2) (s += V[cells[L[i]]] / L[i + 1]), (inv += 1 / L[i + 1]);\n    const K = (2 * F.area[k] + s) / inv, dv = w * (K - V[NN + 1 + k]);\n    V[NN + 1 + k] += dv;\n    if (abs(dv) > change) change = abs(dv);\n  }\n  return change;\n}\n\n// Slope of the film at each node, from the parabola through the node and its\n// two neighbours on each axis at their true distances (the outline or the\n// plate counting as a neighbour at its crossing).\nfunction slopes(F) {\n  const { cells, idx, th, V, n, gx, gy } = F;\n  for (let c = 0; c \u003c n; c++) {\n    const p = cells[c], u = V[p];\n    for (let ax = 0; ax \u003c 2; ax++) {\n      const a = th[c * 4 + ax * 2] * HS, b = th[c * 4 + ax * 2 + 1] * HS, uL = V[idx[c * 4 + ax * 2]], uR = V[idx[c * 4 + ax * 2 + 1]];\n      const g = (a * a * uR - b * b * uL + (b * b - a * a) * u) / (a * b * (a + b));\n      if (ax) gy[p] = g;\n      else gx[p] = g;\n    }\n  }\n  // Each LED takes the mean slope of the film nodes among its four.\n  const { type, lgx, lgy, lin, lplate } = F;\n  for (let q = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      let sx = 0, sy = 0, m = 0, pl = 0;\n      for (let s = 0; s \u003c 4; s++) {\n        const p = (2 * y + (s >> 1)) * FW + 2 * x + (s & 1);\n        if (type[p] === 1) (sx += gx[p]), (sy += gy[p]), m++;\n        else if (type[p] >= 2) pl++;\n      }\n      (lgx[q] = m ? sx / m : 0), (lgy[q] = m ? sy / m : 0), (lin[q] = m), (lplate[q] = pl);\n    }\n}\n\nconst BREATH = 4; // seconds a breath, fifteen a minute at rest\nconst LAMP_TURN = 12;\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, twist: 2, word: -1, lamp: 0.06, film: null, films: [], rgb: new Float32Array(3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.twist = cl(k[1], 0.2, 3);\n  S.lamp = cl(k[3], 0, 1);\n  const word = cl(round(k[2]), 0, 3);\n  if (word !== S.word) {\n    S.word = word;\n    if (!S.films[word]) S.films[word] = buildFilm(WORDS[word]);\n    S.film = S.films[word];\n  }\n  const F = S.film;\n  if (!F.settled) {\n    let ch = 0;\n    for (let i = 0; i \u003c 10; i++) ch = sweep(F, 1.92);\n    F.sweeps += 10;\n    slopes(F);\n    if (ch \u003c 1e-2 || F.sweeps > 1500) F.settled = true;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.film) return;\n  const F = S.film, { lgx, lgy, lin, lplate } = F, rgb = S.rgb;\n  // The twist swings between 40% and 100% of the knob's on every breath.\n  const breath = 0.5 - 0.5 * cos((2 * PI * S.t) / BREATH);\n  const P = (S.twist / 2) * (0.4 + 0.6 * breath);\n  const Z = 0.12 * P; // film height per unit of phi\n  const az = (2 * PI * S.t) / LAMP_TURN + 0.6, el = ((15 + 60 * S.lamp) * PI) / 180;\n  const lx = cos(el) * cos(az), ly = cos(el) * sin(az), lz = sin(el);\n  let hx = lx, hy = ly, hz = lz + 1;\n  const hl = sqrt(hx * hx + hy * hy + hz * hz);\n  (hx /= hl), (hy /= hl), (hz /= hl);\n  const kt = P / 11; // the stress at which the colour reaches the hot end is 11 / P\n  const plate = 0.6 * (0.5 + 0.5 * lz);\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const n = lin[p];\n      if (n) {\n        const gx = lgx[p], gy = lgy[p], ax = -Z * gx, ay = -Z * gy, inv = 1 / sqrt(ax * ax + ay * ay + 1);\n        const dif = (ax * lx + ay * ly + lz) * inv, nh = (ax * hx + ay * hy + hz) * inv;\n        let spec = nh > 0.6 ? nh * nh : 0;\n        spec *= spec * spec * spec;\n        spec *= spec * spec; // nh^24\n        const tau = min(1.2, sqrt(gx * gx + gy * gy) * kt);\n        const v = (0.4 + 0.3 * (1 + dif)) * (0.6 + 0.6 * tau) + 0.7 * spec * n * 0.25;\n        hsv(0.62 + S.hue + 0.45 * min(1.15, tau), 1 - 0.3 * spec, v > 1 ? 1 : v, rgb, 0);\n        display.setPixel(x, y, round(255 * rgb[0]), round(255 * rgb[1]), round(255 * rgb[2]));\n      } else if (lplate[p]) {\n        hsv(0.62 + S.hue, 1, plate * lplate[p] * 0.25, rgb, 0);\n        display.setPixel(x, y, round(255 * rgb[0]), round(255 * rgb[1]), round(255 * rgb[2]));\n      } else display.setPixel(x, y, 0, 0, 0);\n    }\n}\n","steiner-tree":"// ===== Patternflow pattern =====\n// Title:   Steiner Tree\n// Family:  geometry\n// Idea:    Four to seven terminals stand on a zigzag of equilateral triangles or wander the panel; the minimum spanning tree joins them in faint dashes and the shortest network in bright lines that meet three at a time at 120 degrees in pink Steiner points, and when another network becomes shorter the tree flips to it while the old one fades out amber; a bar at the foot reads the length ratio of the two trees against the conjectured floor of root 3 over 2.\n// Author:  patternflow-lab\n// Date:    2026-10-30\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Euclidean Steiner tree problem (Jakob Steiner's name; Vojtěch Jarník and Miloš Kössler, 1934), Steiner minimal trees and the root 3 over 2 ratio conjecture (E. N. Gilbert and H. O. Pollak, 1968), full Steiner topologies (Z. A. Melzak, 1961), the iteration for a fixed topology (Warren D. Smith, 1992), pattern round 75\n// Round:   75\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Terminals=4..7, Scatter=0..1\n//\n// Knob 1: Hue. Turns every colour together: at 0 the Steiner tree is cyan with faint rings spreading from it every 6 LEDs, its Steiner points pink, the terminals warm white, the spanning tree dashed blue grey and a tree just left behind amber.\n// Knob 2: Speed. How fast the terminals move. At 2 each wobbles round its place on the strip by 3.5% of the triangle side (2.1 LEDs for four terminals), once in 9 to 20 s, the strip sways 2.5 LEDs across, and free terminals wander at up to about 6 LEDs a second. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Terminals. 4 to 7. Each frame tries 40 of the full Steiner topologies (3, 15, 105 or 945 in all) from a cold start with 15 of Smith's steps, keeps the near misses for 3 s with 10 more steps a frame, and tries both swaps across every inner edge of the tree on show. A shorter candidate takes over, and if the picture changes the old tree fades out amber over 1.2 s.\n// Knob 4: Scatter, applied as its square. At 0 the terminals sit on a zigzag strip of equilateral triangles down the panel, side 60 LEDs for four terminals and 32 for seven. Four make a 60 degree rhombus whose two Steiner trees are mirror images of one length, root 7 over 3 (0.882) of the spanning tree, so the wobble flips the tree back and forth about 8 times a minute. Five and seven split into equilateral stars that share terminals: at rest the ratio is exactly root 3 over 2, and with the wobble it reads 0.867 to 0.904. At 1 they wander the whole panel, the ratio stays above 0.95 nine tenths of the time and seven terminals flip 27 times a minute.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, sin, cos, exp, abs, hypot, PI } = Math;\nconst TAU = 2 * PI, FLOOR = sqrt(3) / 2;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Full Steiner topologies. Terminals are nodes 0..n-1 and Steiner\n// points n..2n-3, each of degree 3. Terminal k joins the topology of the\n// first k by splitting one of its 2k - 3 edges, so there are 3, 15, 105 and\n// 945 for n = 4 to 7. A degenerate tree, a Steiner point sitting on a\n// terminal or two on one spot, is a full topology with a zero-length edge,\n// so the shortest over all full topologies is the Steiner minimal tree.\nconst TOPS = {};\nfunction topologies(n) {\n  if (TOPS[n]) return TOPS[n];\n  const out = [];\n  const rec = (edges, ins, k) => {\n    if (k === n) return void out.push(prep(n, edges, ins));\n    const s = n + k - 2;\n    for (let i = 0; i \u003c edges.length; i++) {\n      const [u, v] = edges[i], ne = edges.slice();\n      ne[i] = [u, s];\n      ne.push([s, v], [s, k]);\n      rec(ne, [...ins, [s, u, v, k]], k + 1);\n    }\n  };\n  rec([[0, n], [1, n], [2, n]], [], 3);\n  return (TOPS[n] = out);\n}\n\n// Adjacency and an order from the first Steiner point outwards, for the\n// elimination in smith().\nfunction prep(n, edges, ins) {\n  const N = 2 * n - 2, adj = Array.from({ length: N }, () => []);\n  edges.forEach(([a, b], e) => {\n    adj[a].push([b, e]);\n    adj[b].push([a, e]);\n  });\n  const order = [n], par = new Int8Array(N).fill(-1), seen = new Uint8Array(N);\n  seen[n] = 1;\n  for (let i = 0; i \u003c order.length; i++)\n    for (const [b] of adj[order[i]])\n      if (b >= n && !seen[b]) {\n        seen[b] = 1;\n        par[b] = order[i];\n        order.push(b);\n      }\n  return { n, edges, ins, adj, order, par };\n}\n\n// A cold start: each Steiner point at the centroid of the three it was\n// inserted between.\nfunction initPos(T, X) {\n  const n = T.n;\n  X[2 * n] = (X[0] + X[2] + X[4]) / 3;\n  X[2 * n + 1] = (X[1] + X[3] + X[5]) / 3;\n  for (const [s, u, v, k] of T.ins)\n    for (let c = 0; c \u003c 2; c++) X[2 * s + c] = (X[2 * u + c] + X[2 * v + c] + X[2 * k + c]) / 3;\n}\n\n// Smith's iteration for a fixed topology: weight every edge by 1/length and\n// solve the tree's linear system exactly, from the leaves of the Steiner\n// points up and back down. The total length is convex in the Steiner points\n// and each step can only shorten it. Returns the length after iters steps.\nconst WB = new Float64Array(16), AA = new Float64Array(16), BX = new Float64Array(16), BY = new Float64Array(16);\nfunction smith(T, X, iters) {\n  const { n, edges, adj, order, par } = T;\n  let L = 0;\n  for (let it = 0; ; it++) {\n    L = 0;\n    for (let e = 0; e \u003c edges.length; e++) {\n      const a = edges[e][0], b = edges[e][1], d = hypot(X[2 * a] - X[2 * b], X[2 * a + 1] - X[2 * b + 1]);\n      L += d;\n      WB[e] = 1 / max(d, 1e-4);\n    }\n    if (it === iters) return L;\n    for (let i = order.length - 1; i >= 0; i--) {\n      const c = order[i];\n      let D = 0, bx = 0, by = 0, ap = 0;\n      for (const [b, e] of adj[c]) {\n        const w = WB[e];\n        if (b \u003c n) (D += w), (bx += w * X[2 * b]), (by += w * X[2 * b + 1]);\n        else if (b === par[c]) (D += w), (ap = w);\n        else (D += w * (1 - AA[b])), (bx += w * BX[b]), (by += w * BY[b]);\n      }\n      AA[c] = ap / D;\n      BX[c] = bx / D;\n      BY[c] = by / D;\n    }\n    for (const c of order) {\n      const p = par[c];\n      X[2 * c] = (p >= 0 ? AA[c] * X[2 * p] : 0) + BX[c];\n      X[2 * c + 1] = (p >= 0 ? AA[c] * X[2 * p + 1] : 0) + BY[c];\n    }\n  }\n}\n\n// The two other topologies across inner edge e: swap one neighbour of each\n// end. Both ends start at the edge's middle, nudged towards their new pairs.\nfunction swaps(T, X) {\n  const { n, edges } = T, out = [];\n  edges.forEach(([s1, s2], e) => {\n    if (s1 \u003c n || s2 \u003c n) return;\n    const nb = (s, o) => T.adj[s].filter(([q]) => q !== o);\n    const [[a], [b, eb]] = nb(s1, s2), [[c, ec], [d, ed]] = nb(s2, s1);\n    for (const [x, ex, y] of [[c, ec, d], [d, ed, c]]) {\n      // s1 keeps a and takes x from s2; s2 keeps y and takes b.\n      const ne = edges.map((p) => p.slice());\n      ne[eb] = [s2, b];\n      ne[ex] = [s1, x];\n      const T2 = prep(n, ne, T.ins), X2 = X.slice();\n      const mx = (X[2 * s1] + X[2 * s2]) / 2, my = (X[2 * s1 + 1] + X[2 * s2 + 1]) / 2;\n      for (const [s, p, q] of [[s1, a, x], [s2, b, y]]) {\n        const ux = (X[2 * p] + X[2 * q]) / 2 - mx, uy = (X[2 * p + 1] + X[2 * q + 1]) / 2 - my, l = hypot(ux, uy) || 1;\n        X2[2 * s] = mx + (0.4 * ux) / l;\n        X2[2 * s + 1] = my + (0.4 * uy) / l;\n      }\n      out.push([T2, X2]);\n    }\n  });\n  return out;\n}\n\n// The tree as drawn: edges shorter than 0.8 LED are contracted, and the key\n// lists for every edge left the terminals on its far side from terminal 0.\n// A change of topology that leaves the key alone does not show.\nfunction drawnKey(T, X) {\n  const { n, edges } = T, N = 2 * n - 2, par = [...Array(N).keys()];\n  const find = (x) => (par[x] === x ? x : (par[x] = find(par[x])));\n  const len = (e) => hypot(X[2 * e[0]] - X[2 * e[1]], X[2 * e[0] + 1] - X[2 * e[1] + 1]);\n  for (const e of edges) if (len(e) \u003c 0.8) par[find(e[0])] = find(e[1]);\n  const keep = edges.filter((e) => len(e) >= 0.8), ks = [];\n  for (const [a, b] of keep) {\n    let m = 0;\n    const seen = new Set([find(a), find(b)]), st = [find(b)];\n    while (st.length) {\n      const c = st.pop();\n      for (let t = 0; t \u003c n; t++) if (find(t) === c) m |= 1 \u003c\u003c t;\n      for (const [p, q] of keep) {\n        const fp = find(p), fq = find(q), o = fp === c ? fq : fq === c ? fp : -1;\n        if (o >= 0 && !seen.has(o)) seen.add(o), st.push(o);\n      }\n    }\n    if (m & 1) m = ((1 \u003c\u003c n) - 1) & ~m;\n    ks.push(m);\n  }\n  return ks.sort((x, y) => x - y).join(\",\");\n}\n\nfunction mst(n, X) {\n  const inT = new Uint8Array(n), d = new Float64Array(n).fill(1e9), from = new Int8Array(n).fill(-1), E = [];\n  d[0] = 0;\n  let L = 0;\n  for (let it = 0; it \u003c n; it++) {\n    let u = -1;\n    for (let i = 0; i \u003c n; i++) if (!inT[i] && (u \u003c 0 || d[i] \u003c d[u])) u = i;\n    inT[u] = 1;\n    L += d[u];\n    if (from[u] >= 0) E.push([from[u], u]);\n    for (let v = 0; v \u003c n; v++)\n      if (!inT[v]) {\n        const dd = hypot(X[2 * u] - X[2 * v], X[2 * u + 1] - X[2 * v + 1]);\n        if (dd \u003c d[v]) (d[v] = dd), (from[v] = u);\n      }\n  }\n  return { L, E };\n}\n\n// ---- Where the terminals are. On the strip, terminal i sits on a zigzag of\n// equilateral triangles of side a down the middle of the panel; free, it\n// follows two sines in x and two in y over the whole panel.\nfunction place(S, scatter) {\n  const n = S.n, a = min(60, 192 / (n - 1)), sep = (a * sqrt(3)) / 2, t = S.tau;\n  const sx = 32 + 2.5 * sin(0.043 * t), sy = 58 + 3 * sin(0.031 * t + 1);\n  for (let i = 0; i \u003c n; i++) {\n    const f = S.freq[i];\n    const wx = 0.035 * a * sin(f[0] * t + f[4]), wy = 0.035 * a * sin(f[1] * t + f[5]);\n    const lx = sx + (i % 2 ? 0.5 : -0.5) * sep + wx, ly = sy + (i - (n - 1) / 2) * (a / 2) + wy;\n    const fx = 32 + 26 * (0.62 * sin(f[2] * t + f[6]) + 0.38 * sin(f[3] * t * 1.7 + f[7])), fy = 58 + 50 * (0.62 * sin(f[3] * t + f[7]) + 0.38 * sin(f[2] * t * 1.3 + f[4]));\n    S.X[2 * i] = cl(lx + (fx - lx) * scatter, 3, 61);\n    S.X[2 * i + 1] = cl(ly + (fy - ly) * scatter, 4, 110);\n  }\n}\n\nfunction resolve(S) {\n  // Every topology from a cold start, the shortest kept and polished.\n  let best = null;\n  for (const T of topologies(S.n)) {\n    const X = S.X.slice();\n    initPos(T, X);\n    const L = smith(T, X, 15);\n    if (!best || L \u003c best[2]) best = [T, X, L];\n  }\n  S.T = best[0];\n  S.X = best[1];\n  S.L = smith(S.T, S.X, 60);\n  S.key = drawnKey(S.T, S.X);\n  S.sweep = 0;\n}\n\nexport function setup(params) {\n  const freq = [];\n  for (let i = 0; i \u003c 7; i++) {\n    const r = () => Math.random();\n    freq.push([TAU / (9 + 11 * r()), TAU / (9 + 11 * r()), 0.05 + 0.05 * r(), 0.05 + 0.05 * r(), TAU * r(), TAU * r(), TAU * r(), TAU * r()]);\n  }\n  params.s = { n: 0, tau: 0, t: 0, freq, X: null, T: null, L: 0, M: 1, pool: [], old: null, oldT: -9, boost: 0, sg: new Float64Array(80), F: new Float32Array(NP), rgb: new Float32Array(NP * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.t += d;\n  S.tau += (d * cl(k[1], 0.2, 3)) / 2;\n  const n = cl(round(k[2]), 4, 7), scatter = cl(k[3], 0, 1) ** 2;\n  if (n !== S.n) {\n    S.n = n;\n    S.X = new Float64Array(2 * (2 * n - 2));\n    place(S, scatter);\n    resolve(S);\n    S.old = null;\n    S.pool = [];\n  }\n  place(S, scatter);\n  S.L = smith(S.T, S.X, 4);\n  // Candidates: the swaps across each inner edge, warm; a share of all\n  // topologies, cold; and the near misses of earlier sweeps, warm. Smith's\n  // steps only shorten, so a candidate shorter than the polished tree on\n  // show is truly shorter.\n  let cand = null;\n  const better = (T, X, L) => {\n    if (L \u003c S.L * (1 - 2e-4) && (!cand || L \u003c cand[2])) cand = [T, X, L];\n  };\n  for (const [T2, X2] of swaps(S.T, S.X)) better(T2, X2, smith(T2, X2, 12));\n  for (const q of S.pool) {\n    q.X.set(S.X.subarray(0, 2 * n));\n    q.L = smith(q.T, q.X, 10);\n    q.age += d;\n    better(q.T, q.X, q.L);\n  }\n  S.pool = S.pool.filter((q) => q.age \u003c 3 && q.L \u003c S.L * 1.03 && q.T !== S.T);\n  const all = topologies(n), per = min(all.length, 40);\n  for (let i = 0; i \u003c per; i++) {\n    const T = all[(S.sweep + i) % all.length], X = S.X.slice();\n    initPos(T, X);\n    const L = smith(T, X, 15);\n    better(T, X, L);\n    // A cold start a little longer than the tree on show may still be the\n    // shorter one once it settles, so it stays in the pool for 3 s.\n    if (L \u003c S.L * 1.03 && T !== S.T && S.pool.length \u003c 8 && !S.pool.some((q) => q.T === T)) S.pool.push({ T, X, L, age: 0 });\n  }\n  S.sweep = (S.sweep + per) % all.length;\n  if (cand) {\n    const key = drawnKey(cand[0], cand[1]);\n    if (key !== S.key) {\n      // A visible flip: keep the old tree to fade out.\n      S.old = segs(S.T, S.X);\n      S.oldT = S.t;\n      S.boost = 1;\n    }\n    S.T = cand[0];\n    S.X = cand[1];\n    S.L = smith(S.T, S.X, 6);\n    S.key = key;\n  }\n  S.mst = mst(n, S.X);\n  S.M = S.mst.L;\n  S.boost *= exp(-d * 2.5);\n}\n\nfunction segs(T, X) {\n  const out = [];\n  for (const [a, b] of T.edges) {\n    const ax = X[2 * a], ay = X[2 * a + 1], bx = X[2 * b], by = X[2 * b + 1];\n    if (hypot(bx - ax, by - ay) > 0.05) out.push([ax, ay, bx, by]);\n  }\n  return out;\n}\n\n// Soft line, added.\nfunction line(rgb, ax, ay, bx, by, col, a, w, dash) {\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy, L = sqrt(L2), R = w + 1.5;\n  for (let y = max(0, floor(min(ay, by) - R)); y \u003c= min(H - 1, floor(max(ay, by) + R)); y++) {\n    // Only the stretch of the row the segment can reach.\n    let x0 = min(ax, bx), x1 = max(ax, bx);\n    if (abs(dy) > 1e-6) {\n      const t0 = cl((y + 0.5 - R - ay) / dy, 0, 1), t1 = cl((y + 0.5 + R - ay) / dy, 0, 1);\n      x0 = ax + min(t0, t1) * dx;\n      x1 = ax + max(t0, t1) * dx;\n      if (x0 > x1) [x0, x1] = [x1, x0];\n    }\n    for (let x = max(0, floor(x0 - R)); x \u003c= min(W - 1, floor(x1 + R)); x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay, t = L2 > 0 ? cl((px * dx + py * dy) / L2, 0, 1) : 0;\n      if (dash && (t * L) % 4 > 2) continue;\n      const dd = hypot(px - t * dx, py - t * dy), v = a * cl(w + 0.5 - dd, 0, 1);\n      if (v \u003c= 0) continue;\n      const o = 3 * (y * W + x);\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = max(rgb[o + c], col[c] * v);\n    }\n  }\n}\n\n// A disc laid over what is there.\nfunction spot(rgb, x, y, r, col, a) {\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - r - 1)); i \u003c= min(W - 1, floor(x + r + 1)); i++) {\n      const v = a * cl(r + 0.5 - hypot(i + 0.5 - x, j + 0.5 - y), 0, 1);\n      if (v \u003c= 0) continue;\n      const o = 3 * (j * W + i);\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = rgb[o + c] * (1 - v) + col[c] * v;\n    }\n}\n\n// Field brightness by distance from the tree, in steps of 0.05 LED.\nconst RING = new Float32Array(3000).map((_, i) => {\n  const dd = i / 20, ring = Math.pow(0.5 + 0.5 * cos((TAU * dd) / 6), 6) * 0.17 * exp(-dd / 26);\n  return max(dd > 2 ? ring : 0, 0.3 * exp((-dd * dd) / 5));\n});\n\n// 3 by 5 digits for the ratio.\nconst DIGITS = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7292, 0x7bef, 0x7bcf];\nfunction digit(rgb, n, x, y, col) {\n  for (let r = 0; r \u003c 5; r++)\n    for (let c = 0; c \u003c 3; c++)\n      if ((DIGITS[n] >> (14 - r * 3 - c)) & 1) {\n        const o = 3 * ((y + r) * W + x + c);\n        for (let q = 0; q \u003c 3; q++) rgb[o + q] = col[q];\n      }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const { rgb } = S, h0 = 0.5 + S.hue;\n  const tree = hsv(h0, 0.5, 1), glowC = hsv(h0 + 0.03, 0.75, 1), pink = hsv(h0 + 0.42, 0.5, 1), warm = hsv(h0 + 0.6, 0.15, 1), amber = hsv(h0 + 0.6, 0.75, 1), mstC = hsv(h0 + 0.1, 0.3, 0.62), bg = hsv(h0 + 0.12, 0.7, 0.03);\n  const sg = segs(S.T, S.X), ns = sg.length, SG = S.sg, core = [];\n  sg.forEach(([ax, ay, bx, by], i) => {\n    const dx = bx - ax, dy = by - ay;\n    SG.set([ax, ay, dx, dy, 1 / (dx * dx + dy * dy)], 5 * i);\n  });\n  // Distance from each LED to the tree: a glow along it and faint rings\n  // every 6 LEDs that spread out from it, looked up by distance. It is\n  // worked exactly on every second LED each way and within 3.5 LEDs of the\n  // tree, and read off its four exact neighbours everywhere else.\n  const F = S.F, dist = (px, py) => {\n    let m = 1e9;\n    for (let i = 0; i \u003c 5 * ns; i += 5) {\n      const ex0 = px - SG[i], ey0 = py - SG[i + 1], dx = SG[i + 2], dy = SG[i + 3];\n      let t = (ex0 * dx + ey0 * dy) * SG[i + 4];\n      t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n      const ex = ex0 - t * dx, ey = ey0 - t * dy, q = ex * ex + ey * ey;\n      if (q \u003c m) m = q;\n    }\n    return sqrt(m);\n  };\n  for (let y = 0; y \u003c H; y += 2) for (let x = 0; x \u003c W; x += 2) F[y * W + x] = dist(x + 0.5, y + 0.5);\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    const y0 = y & ~1, y1 = y0 + 2 \u003c H ? y0 + 2 : y0, fy = y & 1 ? 0.5 : 0;\n    for (let x = 0; x \u003c W; x++, p++) {\n      let dd = F[p];\n      if ((x | y) & 1) {\n        const x0 = x & ~1, x1 = x0 + 2 \u003c W ? x0 + 2 : x0, fx = x & 1 ? 0.5 : 0;\n        const a = F[y0 * W + x0], b = F[y0 * W + x1], c = F[y1 * W + x0], e = F[y1 * W + x1];\n        dd = min(a, b, c, e) \u003c 3.5 ? dist(x + 0.5, y + 0.5) : (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + e * fx) * fy;\n      }\n      const v = RING[min(RING.length - 1, (dd * 20) | 0)], o = 3 * p;\n      rgb[o] = bg[0] + glowC[0] * v;\n      rgb[o + 1] = bg[1] + glowC[1] * v;\n      rgb[o + 2] = bg[2] + glowC[2] * v;\n      // The tree's own line, 1.7 LEDs wide, laid on after the dashes.\n      if (dd \u003c 1.35) core.push(p, 1.35 - dd);\n    }\n  }\n  // The minimum spanning tree, dashed and faint.\n  for (const [a, b] of S.mst.E) line(rgb, S.X[2 * a], S.X[2 * a + 1], S.X[2 * b], S.X[2 * b + 1], mstC, 1, 0.45, true);\n  // A tree just left behind fades out amber.\n  const age = S.t - S.oldT;\n  if (S.old && age \u003c 1.2) for (const [ax, ay, bx, by] of S.old) line(rgb, ax, ay, bx, by, amber, 0.9 * (1 - age / 1.2), 0.7);\n  const bright = [0, 1, 2].map((c) => tree[c] + (1 - tree[c]) * 0.7 * S.boost);\n  for (let i = 0; i \u003c core.length; i += 2) {\n    const o = 3 * core[i], v = min(1, core[i + 1]);\n    for (let c = 0; c \u003c 3; c++) rgb[o + c] = rgb[o + c] * (1 - v) + bright[c] * v;\n  }\n  // Steiner points that stand apart from every terminal are pink dots.\n  for (let s = S.n; s \u003c 2 * S.n - 2; s++) {\n    const x = S.X[2 * s], y = S.X[2 * s + 1];\n    let near = 1e9;\n    for (let i = 0; i \u003c S.n; i++) near = min(near, hypot(x - S.X[2 * i], y - S.X[2 * i + 1]));\n    if (near > 1.2) spot(rgb, x, y, 1.5, pink, cl(near - 1.2, 0, 1));\n  }\n  for (let i = 0; i \u003c S.n; i++) spot(rgb, S.X[2 * i], S.X[2 * i + 1], 1.9, warm, 1);\n  // The ratio: a bar from root 3 over 2 at the left to 1 at the right, and\n  // the number above it.\n  // Smith's steps reach a degenerate tree slowly, so where the spanning tree\n  // is already the shortest the length can stand 0.04% above it: read 1.\n  const r = S.M > 0 ? min(1, S.L / S.M) : 1, fill = cl((r - FLOOR) / (1 - FLOOR), 0, 1);\n  for (let x = 3; x \u003c= 60; x++) {\n    const u = (x - 3) / 57, on = u \u003c= fill;\n    for (let y = 121; y \u003c= 124; y++) {\n      const o = 3 * (y * W + x), v = on ? 0.85 : 0.12;\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = (on ? tree : mstC)[c] * v;\n    }\n  }\n  for (let y = 119; y \u003c= 126; y++) for (let c = 0; c \u003c 3; c++) rgb[3 * (y * W + 2) + c] = pink[c];\n  const txt = r.toFixed(3);\n  let cx = 3;\n  for (const ch of txt) {\n    if (ch === \".\") {\n      for (let c = 0; c \u003c 3; c++) rgb[3 * (117 * W + cx) + c] = warm[c] * 0.85;\n      cx += 2;\n      continue;\n    }\n    digit(rgb, +ch, cx, 113, warm);\n    cx += 4;\n  }\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, floor(p / W), min(255, rgb[3 * p] * 255) | 0, min(255, rgb[3 * p + 1] * 255) | 0, min(255, rgb[3 * p + 2] * 255) | 0);\n}\n","autostereogram":"// ===== Patternflow pattern =====\n// Title:   Autostereogram\n// Family:  type\n// Idea:    A three-letter word stacked down the panel in capitals 42 LEDs wide and 38 tall is hidden in coloured random dots as a wall-eyed single-image stereogram, every LED copying the dot one period to its left except where a letter pulls that copy 2 LEDs nearer, so the dots look like nothing but noise until a band sweeps down and shows each LED against the LED one whole period to its left, dark where they agree and white where they differ, and the word appears letter by letter in that comparison, glows, fades, and a wipe of fresh dots brings the next word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random-dot stereogram (Béla Julesz, Bell System Technical Journal, 1960), single-image random-dot stereogram (Christopher Tyler and Maureen Clarke, made 1979, published at SPIE Stereoscopic Displays and Applications, 1990), after the wallpaper effect (David Brewster, 1844), pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Depth=-3..3, Period=11..15, Reveal=0..1\n//\n// Knob 1: Hue. Turns the four dot colours round the wheel together over a ground that stays deep indigo. At 0 they are teal, azure, violet and pale gold; at 0.5 rose, amber, lime and blue. The comparison stays warm white.\n// Knob 2: Depth. How many LEDs nearer than the period a letter's dots copy, rounded: at 2 (the opening) the word floats in front of the dots for a wall-eyed viewer, at -3 it sinks 3 LEDs behind them, and at 0 the dots are a plain wallpaper with nothing hidden, so the sweep finds no word.\n// Knob 3: Period. The wallpaper's repeat, 11 to 15 LEDs: 5.8 repeats across the 64 LEDs at 11, 4.3 at 15. A wider period needs the eyes to diverge further and widens the random strip down the left edge.\n// Knob 4: Reveal. Up to 0.1 (the opening 0.06) the comparison shows only in the band, 24 rows tall, that sweeps down at 40 rows a second, 3.8 s a sweep, once for each word; between sweeps the dots carry no trace of the word. Above 0.1 the comparison also shows over the whole panel at that strength: at 0.55 the dots are half dimmed and the word stands half white all the time, at 1 the dots are gone and only the comparison is left.\n\n// A random-dot stereogram hides a shape in dots that carry no outline at\n// all: the shape exists only as a shift between what the left eye and the\n// right eye see. Julesz made them as pairs; Tyler and Clarke put both views\n// in one picture. Each row starts with a strip of random dots one period\n// wide, and every later LED copies the LED one separation to its left. Where\n// the depth map is flat the separation is the period P and the row repeats\n// exactly. Inside a letter it is P - D, so for eyes diverged by P the dots\n// of the letter pair up at a different disparity and the letter stands out\n// D LEDs nearer (D > 0) or further (D \u003c 0).\n//\n// The comparison is the reveal: an LED that copied from P to its left\n// always equals the LED P to its left, and inside a letter it copied from\n// P - D, so it differs from the LED at P whenever the two dots were drawn\n// differently, 70% of the time here. Matching LEDs go dark, differing ones\n// light, and the letter appears without any free-viewing.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\n\n// Letter boxes: 42 x 38 LEDs from x = 19, three of them at rows 2, 45 and\n// 88. The box starts right of the widest separation (15 + 3), so a letter\n// never needs a dot left of the panel.\nconst BX = 19, BW = 42, BH = 38, TOPS = [2, 45, 88];\n// Timing in seconds: the wipe of new dots, the quiet before the sweep, the\n// sweep's speed in rows a second, the quiet after, and the glow's decay.\nconst WIPE = 0.5, PRE = 1.5, V = 40, POST = 2.0, TAU = 0.9, BAND = 24;\nconst LIT = 0.52; // share of dots that take one of the four colours\nconst SHADE = 0.025, SH2 = (2 * SHADE) / 255;\n\n// A bold 7 x 7 capital for each letter, drawn for this pattern. Each cell\n// is 6 x 5.43 LEDs; sampling the cells bilinearly and cutting at one half\n// rounds the corners and turns the stairs of A, S and Y into slopes.\nconst FONT = {\n  A: [\"..###..\", \".##.##.\", \"##...##\", \"##...##\", \"#######\", \"##...##\", \"##...##\"],\n  D: [\"#####..\", \"##..##.\", \"##...##\", \"##...##\", \"##...##\", \"##..##.\", \"#####..\"],\n  E: [\"#######\", \"##.....\", \"##.....\", \"######.\", \"##.....\", \"##.....\", \"#######\"],\n  F: [\"#######\", \"##.....\", \"##.....\", \"######.\", \"##.....\", \"##.....\", \"##.....\"],\n  H: [\"##...##\", \"##...##\", \"##...##\", \"#######\", \"##...##\", \"##...##\", \"##...##\"],\n  I: [\".#####.\", \"..###..\", \"..###..\", \"..###..\", \"..###..\", \"..###..\", \".#####.\"],\n  O: [\".#####.\", \"##...##\", \"##...##\", \"##...##\", \"##...##\", \"##...##\", \".#####.\"],\n  R: [\"######.\", \"##...##\", \"##...##\", \"######.\", \"##.##..\", \"##..##.\", \"##...##\"],\n  S: [\".#####.\", \"##...##\", \"##.....\", \".#####.\", \".....##\", \"##...##\", \".#####.\"],\n  T: [\"#######\", \"#######\", \"..###..\", \"..###..\", \"..###..\", \"..###..\", \"..###..\"],\n  Y: [\"##...##\", \"##...##\", \".##.##.\", \"..###..\", \"..###..\", \"..###..\", \"..###..\"],\n};\nconst WORDS = [\"SEE\", \"EYE\", \"AHA\", \"DOT\", \"HID\", \"FAR\", \"ODD\", \"TOE\"];\n\nfunction cell(g, i, j) {\n  return i \u003c 0 || j \u003c 0 || i > 6 || j > 6 ? 0 : g[j][i] === \"#\" ? 1 : 0;\n}\n\n// The depth map of one word: 1 inside a letter, 0 elsewhere.\nfunction wordMask(word) {\n  const m = new Uint8Array(W * H), cw = BW / 7, ch = BH / 7;\n  for (let n = 0; n \u003c 3; n++) {\n    const g = FONT[word[n]], top = TOPS[n];\n    for (let y = top; y \u003c top + BH; y++)\n      for (let x = BX; x \u003c BX + BW; x++) {\n        const u = (x - BX + 0.5) / cw - 0.5, v = (y - top + 0.5) / ch - 0.5;\n        const i = floor(u), j = floor(v), fu = u - i, fv = v - j;\n        const a = cell(g, i, j) * (1 - fu) + cell(g, i + 1, j) * fu;\n        const b = cell(g, i, j + 1) * (1 - fu) + cell(g, i + 1, j + 1) * fu;\n        if (a * (1 - fv) + b * fv > 0.5) m[y * W + x] = 1;\n      }\n  }\n  return m;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// New random dots for a row: the dot each LED would take if it had nothing\n// to copy, and a shade for each LED's three channels. The shade is the\n// LED's own and is never copied. At 2.5% either way the eye cannot tell\n// it and the dots still fuse, but no copy is then the same three bytes as\n// its source. Without it a compressor finds every repeat and the study's\n// complexity reads 0.46 bytes an LED for a field that looks like noise;\n// with it, 1.78.\nfunction roll(S, y) {\n  const o = y * W;\n  for (let x = 0; x \u003c W; x++) {\n    S.R[o + x] = Math.random() \u003c LIT ? 1 + floor(Math.random() * 4) : 0;\n    for (let c = 0; c \u003c 3; c++) S.sh[(o + x) * 3 + c] = floor(Math.random() * 256);\n  }\n}\n\n// One row of the stereogram, left to right.\nfunction build(S, y) {\n  const o = y * W, P = S.P, D = S.D, m = S.masks[S.rowWord[y]], R = S.R, I = S.idx;\n  for (let x = 0; x \u003c W; x++) {\n    const sep = P - D * m[o + x];\n    I[o + x] = x \u003c sep ? R[o + x] : I[o + x - sep];\n  }\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    P: 11, D: 2, hue: 0, floor: 0, word: 0, ct: 0, wiped: H,\n    R: new Uint8Array(W * H), sh: new Uint8Array(W * H * 3), idx: new Uint8Array(W * H),\n    glow: new Float32Array(W * H), cover: new Float32Array(H), rowWord: new Uint8Array(H),\n    masks: WORDS.map(wordMask), pal: new Float32Array(15),\n  });\n  for (let y = 0; y \u003c H; y++) roll(S, y), build(S, y);\n  return S;\n}\n\nconst CYCLE = PRE + (H + BAND) / V + POST;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 11, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const D = round(cl(k[1] == null ? 2 : k[1], -3, 3)), P = round(cl(k[2] || 11, 11, 15));\n  S.floor = cl(((k[3] == null ? 0.06 : k[3]) - 0.1) / 0.9, 0, 1);\n  if (D !== S.D || P !== S.P) {\n    S.D = D;\n    S.P = P;\n    for (let y = 0; y \u003c H; y++) build(S, y);\n  }\n  S.ct += d;\n  if (S.ct >= CYCLE) {\n    S.ct = 0;\n    S.word = (S.word + 1) % WORDS.length;\n    S.wiped = 0;\n  }\n  // The wipe: rows take new dots and the new word as its front passes.\n  const front = min(H, floor((S.ct / WIPE) * H));\n  while (S.wiped \u003c front) {\n    const y = S.wiped++;\n    S.rowWord[y] = S.word;\n    roll(S, y);\n    build(S, y);\n  }\n  // The band: each row's share of comparison, with a 3-row soft edge, and\n  // never less than the Reveal floor.\n  const yb = -BAND / 2 + (S.ct - PRE) * V, half = BAND / 2, on = S.ct > PRE;\n  const fall = exp(-d / TAU), I = S.idx, G = S.glow;\n  for (let y = 0; y \u003c H; y++) {\n    const c = max(S.floor, on ? cl((half - abs(y + 0.5 - yb)) / 3, 0, 1) : 0);\n    S.cover[y] = c;\n    const o = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      let g = G[o + x] * fall;\n      if (c > 0 && x >= S.P && I[o + x] !== I[o + x - S.P] && c > g) g = c;\n      G[o + x] = g;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // The ground and the four dot colours, levels 0..255.\n  const pal = S.pal, h = S.hue;\n  hsv(0.7, 0.85, 0.2, pal, 0);\n  hsv(0.47 + h, 0.9, 0.62, pal, 3);\n  hsv(0.58 + h, 0.8, 0.66, pal, 6);\n  hsv(0.77 + h, 0.65, 0.62, pal, 9);\n  hsv(0.13 + h, 0.5, 0.66, pal, 12);\n  const I = S.idx, G = S.glow, sh = S.sh;\n  for (let y = 0; y \u003c H; y++) {\n    const dim = 1 - 0.9 * S.cover[y], o = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      const i = o + x, p = I[i] * 3, g = G[i], j = i * 3;\n      // Each channel within 2.5% either side of the dot's colour.\n      let r = pal[p] * (1 - SHADE + sh[j] * SH2) * 255 * dim;\n      let gg = pal[p + 1] * (1 - SHADE + sh[j + 1] * SH2) * 255 * dim;\n      let b = pal[p + 2] * (1 - SHADE + sh[j + 2] * SH2) * 255 * dim;\n      r += g * 255;\n      gg += g * 236;\n      b += g * 200;\n      display.setPixel(x, y, round(cl(r, 0, 255)), round(cl(gg, 0, 255)), round(cl(b, 0, 255)));\n    }\n  }\n}\n","brick-factory":"// ===== Patternflow pattern =====\n// Title:   Brick Factory\n// Family:  geometry\n// Idea:    The complete bipartite graph K(m,n) is drawn with straight edges, every crossing of two edges lit as a spark: its vertices are thrown about the panel and wander so crossings flare up and go out all over it, then the drawing relaxes into Zarankiewicz's, m vertices split about the middle of a horizontal line and n of a vertical one, where the live count at the foot of the panel falls to the number Z(m,n) beside it and holds there before the vertices are thrown again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Turán's brick factory problem (Pál Turán, met in a labour camp's brick yard in 1944, published in his A note of welcome, Journal of Graph Theory, 1977), the drawing and the number Z(m,n) of Kazimierz Zarankiewicz (1954), shown to be the crossing number when min(m,n) \u003c= 6 by Daniel Kleitman (1970); 5 by 7 figures from Photon Disk (pattern round 70); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, m=4..6, n=6..9\n//\n// Knob 1: Hue. Turns the edge colours round the wheel. Each of the m vertices on the horizontal line gives its edges one colour, the m colours spread over two thirds of the wheel, blues lifted towards white so they read beside gold: at the opening 0 and m = 4 teal, blue, rose and gold, at 0.5 red, lime, sea green and azure. The sparks stay white-gold.\n// Knob 2: Speed. At 2 the vertices fly to new places in 1.2 s, wander for 2.6 s, relax into Zarankiewicz's drawing in 3 s and hold it 2.6 s, 9.4 s a round. Every time scales as 2 / Speed: 94 s a round at 0.2, 6.3 s at 3.\n// Knob 3: m. The vertices on the horizontal line, the smaller side: 4 at the opening, split 2 and 2 about the middle, 5 split 3 and 2, 6 split 3 and 3.\n// Knob 4: n. The vertices on the vertical line: 6 at the opening, split 3 above the middle and 3 below, up to 9, split 5 and 4. Z(m,n) runs from 12 for the opening K(4,6), which wanders through 22 to 84 crossings, to 96 for K(6,9), which wanders through 180 to 380.\n// Buttons: K1 tap throws the vertices again at once.\n\n// K(m,n) has m vertices on one side and n on the other and an edge from\n// every vertex of one side to every vertex of the other. In 1944 Turán\n// asked how few crossings the rail tracks between m kilns and n storage\n// yards could have. Zarankiewicz's drawing puts one side on the x axis and\n// the other on the y axis, each split as evenly as it goes about the origin.\n// Two edges cross only when they lie in the same quadrant and their ends\n// are in opposite orders, so the count is the sum over the quadrants of\n// C(p,2) C(q,2), which comes to\n//   Z(m,n) = floor(m/2) floor((m-1)/2) floor(n/2) floor((n-1)/2).\n// Kleitman proved no drawing does better when the smaller side is 6 or\n// less. That none does for any m and n is Zarankiewicz's conjecture, still\n// open.\n//\n// Every frame tests each pair of edges that share no vertex, up to 1080\n// pairs for K(6,9), and remembers which pairs crossed, so a crossing that\n// appears or goes out can flare where it happened.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst TAU = 2 * PI;\n// The middle of the drawing, and the box the vertices are thrown into.\nconst OX = 31.5, OY = 58, BX0 = 4, BX1 = 59.5, BY0 = 4, BY1 = 112;\n// Fly, wander, relax, hold, in seconds at Speed 2.\nconst DUR = [1.2, 2.6, 3, 2.6];\nconst MAXE = 54, FLARE = 0.55;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// 5 x 7 figures and Z from Photon Disk (pattern round 70), rows from the\n// top. A 3 x 5 Z is a 2 whose middle bar has shrunk to one LED, and the\n// two could not be told apart on the panel.\nconst GLYPH = {\n  0: \".###. #...# #..## #.#.# ##..# #...# .###.\", 1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", 2: \".###. #...# ....# ...#. ..#.. .#... #####\",\n  3: \"##### ...#. ..#.. ...#. ....# #...# .###.\", 4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\",\n  6: \"..##. .#... #.... ####. #...# #...# .###.\", 7: \"##### ....# ...#. ..#.. .#... .#... .#...\", 8: \".###. #...# #...# .###. #...# #...# .###.\",\n  9: \".###. #...# #...# .#### ....# ...#. .##..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\",\n};\nfor (const k in GLYPH) GLYPH[k] = GLYPH[k].replace(/ /g, \"\");\n\nconst zar = (m, n) => floor(m / 2) * floor((m - 1) / 2) * floor(n / 2) * floor((n - 1) / 2);\n\n// Zarankiewicz's places: the m vertices on the horizontal line, more of them\n// on the left, and the n on the vertical line, more of them above.\nfunction targets(S) {\n  const { m, n } = S, pl = Math.ceil(m / 2), pr = m - pl, qu = Math.ceil(n / 2), qd = n - qu;\n  const hs = 27.5 / pl, vs = (OY - 6) / qu;\n  S.tA = [];\n  for (let i = pl; i >= 1; i--) S.tA.push([OX - hs * i, OY]);\n  for (let i = 1; i \u003c= pr; i++) S.tA.push([OX + hs * i, OY]);\n  S.tB = [];\n  for (let j = qu; j >= 1; j--) S.tB.push([OX, OY - vs * j]);\n  for (let j = 1; j \u003c= qd; j++) S.tB.push([OX, OY + vs * j]);\n}\n\n// New places at random: the box is cut into 3 by 5 cells, at most one\n// vertex to a cell (m + n is 15 at most), so the throw spreads over the\n// whole panel; each vertex gets its own slow wander. The vertical side\n// draws its cells first, so a change of n moves the whole throw.\nfunction throwVertices(S) {\n  const all = [...S.B, ...S.A], cells = [...Array(15).keys()];\n  for (let i = cells.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1));\n    [cells[i], cells[j]] = [cells[j], cells[i]];\n  }\n  const cw = (BX1 - BX0) / 3, ch = (BY1 - BY0) / 5;\n  all.forEach((v, i) => {\n    const c = cells[i], x = BX0 + ((c % 3) + 0.15 + 0.7 * Math.random()) * cw, y = BY0 + (floor(c / 3) + 0.15 + 0.7 * Math.random()) * ch;\n    v.fx = v.x;\n    v.fy = v.y;\n    v.rx = x;\n    v.ry = y;\n    v.p1 = Math.random() * TAU;\n    v.p2 = Math.random() * TAU;\n    v.f1 = 0.25 + Math.random() * 0.3;\n    v.f2 = 0.2 + Math.random() * 0.3;\n    v.delay = Math.random() * 0.35;\n  });\n  S.phase = 0;\n  S.pt = 0;\n}\n\n// Each side goes to its places in the order it already has: the vertices of\n// the horizontal side sorted left to right, the vertical side top to bottom,\n// so the paths into the drawing cross as little as they can.\nfunction assign(S) {\n  const a = S.A.map((v, i) => i).sort((i, j) => S.A[i].x - S.A[j].x);\n  a.forEach((i, k) => ((S.A[i].tx = S.tA[k][0]), (S.A[i].ty = S.tA[k][1])));\n  const b = S.B.map((v, i) => i).sort((i, j) => S.B[i].y - S.B[j].y);\n  b.forEach((i, k) => ((S.B[i].tx = S.tB[k][0]), (S.B[i].ty = S.tB[k][1])));\n}\n\nfunction build(S, m, n) {\n  S.m = m;\n  S.n = n;\n  targets(S);\n  const mk = () => ({ x: OX, y: OY, fx: OX, fy: OY, rx: OX, ry: OY, tx: OX, ty: OY, p1: 0, p2: 0, f1: 0, f2: 0, delay: 0, sx: OX, sy: OY });\n  S.A = Array.from({ length: m }, mk);\n  S.B = Array.from({ length: n }, mk);\n  throwVertices(S);\n  // The first frame lands them straight on their thrown places.\n  for (const v of [...S.A, ...S.B]) (v.x = v.fx = v.rx), (v.y = v.fy = v.ry);\n  S.phase = 1;\n  S.pt = 0;\n  S.was.fill(0);\n  S.quiet = true;\n  S.flares.length = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, m: 0, n: 0, hue: 0, speed: 2, phase: 1, pt: 0, btn: false, A: [], B: [], tA: [], tB: [],\n    was: new Uint8Array(MAXE * MAXE), lastX: new Float32Array(MAXE * MAXE), lastY: new Float32Array(MAXE * MAXE),\n    cx: new Float32Array(1200), cy: new Float32Array(1200), count: 0, bump: 0, flares: [], quiet: true,\n    acc: new Float32Array(W * H * 3), spark: new Float32Array(W * H), col: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// Where each vertex is in the current phase: flying out along a smooth path,\n// wandering about its thrown place, or easing into Zarankiewicz's place.\nfunction place(S, sc) {\n  const ph = S.phase, u = S.pt / (DUR[ph] * sc), t = S.t;\n  for (const v of [...S.A, ...S.B]) {\n    const wx = 5 * sin(t * v.f1 * TAU * 0.5 + v.p1) + 2 * sin(t * v.f2 * TAU + v.p2);\n    const wy = 7 * sin(t * v.f2 * TAU * 0.5 + v.p2) + 2.5 * sin(t * v.f1 * TAU + v.p1);\n    if (ph === 0) {\n      // Each vertex sets off up to 0.17 of the flight late; its wander\n      // grows in as it lands.\n      const e = smooth(cl((u - v.delay * 0.5) / (1 - 0.175), 0, 1)), k = smooth(e);\n      v.x = v.fx + (v.rx + wx * k - v.fx) * e;\n      v.y = v.fy + (v.ry + wy * k - v.fy) * e;\n    } else if (ph === 1) {\n      v.x = v.rx + wx;\n      v.y = v.ry + wy;\n      v.sx = v.x;\n      v.sy = v.y;\n    } else if (ph === 2) {\n      const e = smooth(cl((u - v.delay) / (1 - 0.35), 0, 1));\n      v.x = v.sx + (v.tx - v.sx) * e;\n      v.y = v.sy + (v.ty - v.sy) * e;\n    } else {\n      v.x = v.tx;\n      v.y = v.ty;\n    }\n    v.x = cl(v.x, BX0, BX1);\n    v.y = cl(v.y, BY0, BY1);\n  }\n}\n\n// Every pair of edges a_i b_j and a_k b_l with i != k and j != l; a pair\n// that shares a vertex never crosses in a straight drawing. Each end of one\n// edge is tested for the side of the other it lies on; the edges cross when\n// both pairs of ends lie on opposite sides. Where a pair last crossed is\n// kept, so a crossing that goes out flares where it was.\nfunction crossings(S) {\n  const { A, B, m, n, was, lastX, lastY, cx, cy } = S;\n  let c = 0;\n  for (let i = 0; i \u003c m; i++)\n    for (let j = 0; j \u003c n; j++) {\n      const ax = A[i].x, ay = A[i].y, ex = B[j].x - ax, ey = B[j].y - ay, e1 = i * n + j;\n      for (let k = i + 1; k \u003c m; k++)\n        for (let l = 0; l \u003c n; l++) {\n          if (l === j) continue;\n          const kx = A[k].x, ky = A[k].y, fx = B[l].x - kx, fy = B[l].y - ky;\n          const d1 = ex * (ky - ay) - ey * (kx - ax), d2 = ex * (B[l].y - ay) - ey * (B[l].x - ax);\n          const d3 = fx * (ay - ky) - fy * (ax - kx), d4 = fx * (B[j].y - ky) - fy * (B[j].x - kx);\n          const e2 = k * n + l, key = e1 * MAXE + e2;\n          const hit = d1 * d2 \u003c 0 && d3 * d4 \u003c 0;\n          if (hit) {\n            const s = d3 / (d3 - d4), x = ax + s * ex, y = ay + s * ey;\n            cx[c] = x;\n            cy[c] = y;\n            c++;\n            lastX[key] = x;\n            lastY[key] = y;\n          }\n          if (hit !== !!was[key] && !S.quiet && S.flares.length \u003c 400) S.flares.push({ x: lastX[key], y: lastY[key], age: 0, on: hit });\n          was[key] = hit ? 1 : 0;\n        }\n    }\n  S.quiet = false;\n  return c;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 6], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const m = round(cl(k[2], 4, 6)), n = round(cl(k[3], 6, 9)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (m !== S.m || n !== S.n) build(S, m, n);\n  if (btn && !S.btn) throwVertices(S);\n  S.btn = btn;\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  if (S.pt >= DUR[S.phase] * sc) {\n    S.pt = 0;\n    if (S.phase === 3) throwVertices(S);\n    else {\n      S.phase++;\n      if (S.phase === 2) assign(S);\n    }\n  }\n  place(S, sc);\n  const c = crossings(S);\n  if (c !== S.count) S.bump = 1;\n  S.count = c;\n  S.bump = max(0, S.bump - d / 0.35);\n  for (const f of S.flares) f.age += d / sc;\n  S.flares = S.flares.filter((f) => f.age \u003c FLARE);\n}\n\n// An antialiased line, added in: along the long axis each step lights the\n// LEDs across it by a tent 1.3 LEDs either side of the true line, measured\n// square to the line, so steep and shallow lines weigh the same.\nfunction line(acc, x0, y0, x1, y1, c, w) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0, lim = st ? H - 1 : W - 1, k = 1 / sqrt(1 + s * s);\n  for (let x = max(0, round(x0)); x \u003c= min(lim, round(x1)); x++) {\n    const y = y0 + (x - x0) * s;\n    for (let iy = floor(y - 1.8); iy \u003c= floor(y + 1.8); iy++) {\n      const e = 1 - (abs(iy + 0.5 - y) * k) / 1.3;\n      if (e > 0) add(acc, st ? iy : x, st ? x : iy, c, w * e * k * 1.3);\n    }\n  }\n}\nfunction add(acc, x, y, c, w) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  acc[k] += c[0] * w;\n  acc[k + 1] += c[1] * w;\n  acc[k + 2] += c[2] * w;\n}\n// A soft round light of radius r about x, y.\nfunction glow(acc, x, y, r, c, w) {\n  for (let py = floor(y - r); py \u003c= floor(y + r); py++)\n    for (let px = floor(x - r); px \u003c= floor(x + r); px++) {\n      const dd = sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2) / r;\n      if (dd \u003c 1) add(acc, px, py, c, w * (1 - dd) * (1 - dd));\n    }\n}\nfunction ring(acc, x, y, r, c, w) {\n  for (let py = floor(y - r - 1); py \u003c= floor(y + r + 1); py++)\n    for (let px = floor(x - r - 1); px \u003c= floor(x + r + 1); px++) {\n      const e = abs(sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2) - r);\n      if (e \u003c 1) add(acc, px, py, c, w * (1 - e));\n    }\n}\nfunction text(acc, str, x, y, c, w) {\n  for (const ch of str) {\n    const g = GLYPH[ch];\n    if (g) for (let i = 0; i \u003c 35; i++) if (g[i] === \"#\") add(acc, x + (i % 5), y + floor(i / 5), c, w);\n    x += 6;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.A.length) return;\n  const acc = S.acc, col = S.col, { A, B, m, n } = S;\n  acc.fill(0);\n  // The edges, coloured by their end on the horizontal side.\n  const pal = [];\n  for (let i = 0; i \u003c m; i++) {\n    const c = [0, 0, 0];\n    hsv(S.hue + 0.47 + (0.66 * i) / max(1, m - 1), 0.78, 1, c);\n    // Blue and violet are dim on the panel next to gold and teal: lift\n    // them towards white until their luminance is at least 0.45.\n    const lum = 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2], up = max(0, 0.45 - lum) * 0.7;\n    for (let q = 0; q \u003c 3; q++) c[q] += (1 - c[q]) * up;\n    pal.push(c);\n  }\n  for (let i = 0; i \u003c m; i++) for (let j = 0; j \u003c n; j++) line(acc, A[i].x, A[i].y, B[j].x, B[j].y, pal[i], 0.5);\n  // Sparks at the crossings, kept on a layer of their own where the\n  // brightest wins, so a knot of crossings reads as many points and not as\n  // one white blot. Then the flares of those that just came or went.\n  const hot = [1, 0.86, 0.55], white = [1, 1, 1], sp = S.spark;\n  sp.fill(0);\n  for (let c = 0; c \u003c S.count; c++) {\n    const x = S.cx[c], y = S.cy[c];\n    for (let py = floor(y - 1.5); py \u003c= floor(y + 1.5); py++)\n      for (let px = floor(x - 1.5); px \u003c= floor(x + 1.5); px++) {\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const dd = sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2), v = dd \u003c 0.75 ? 1 : 0.45 * max(0, 1 - (dd - 0.75) / 1.3);\n        if (v > sp[py * W + px]) sp[py * W + px] = v;\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const v = sp[p];\n    if (!v) continue;\n    const k = p * 3, wv = v > 0.9 ? 1 : 0;\n    acc[k] += hot[0] * v + 0.2 * wv;\n    acc[k + 1] += hot[1] * v + 0.3 * wv;\n    acc[k + 2] += hot[2] * v + 0.45 * wv;\n  }\n  for (const f of S.flares) {\n    const u = f.age / FLARE, fade = (1 - u) * (1 - u);\n    if (f.on) ring(acc, f.x, f.y, 1 + 5 * u, hot, 1.1 * fade);\n    else glow(acc, f.x, f.y, 2 + 3 * u, hot, 1.1 * fade);\n  }\n  // The vertices: the horizontal side large in its colour, the vertical\n  // side small and white.\n  for (let i = 0; i \u003c m; i++) {\n    glow(acc, A[i].x, A[i].y, 3.2, pal[i], 1.6);\n    glow(acc, A[i].x, A[i].y, 1.6, white, 0.9);\n  }\n  for (const v of B) glow(acc, v.x, v.y, 2.4, white, 1.3);\n  // The count at the foot, left, against Z(m,n), right. The count flashes\n  // when it changes and turns gold when it is down to Z.\n  const z = zar(m, n), at = S.count === z;\n  hsv(S.hue + 0.47, 0.25, 1, col);\n  const cc = at ? hot : col;\n  text(acc, String(S.count), 1, 119, cc, 0.75 + 0.25 * S.bump);\n  const zs = String(z);\n  text(acc, zs, 64 - 6 * zs.length, 119, at ? hot : col, at ? 0.95 : 0.6);\n  text(acc, \"Z\", 64 - 6 * zs.length - 9, 119, col, 0.3);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[k])) | 0, (255 * min(1, acc[k + 1])) | 0, (255 * min(1, acc[k + 2])) | 0);\n    }\n}\n","eye-chart":"// ===== Patternflow pattern =====\n// Title:   Eye Chart\n// Family:  type\n// Idea:    A back-lit letter chart stands the full height of the panel, eight rows of Sloan letters from one letter 25 LEDs tall down to five letters 5 LEDs tall with one LED to a stroke, each row 1.26 times the one below as on a logMAR chart, and lens after lens wipes across it as in a phoropter, blurring the chart by a disc as wide as the defocus that lens leaves, while a pointer reads down the rows letter by letter, marking blue the letters a noisy reader still tells apart from the ten letters blurred the same way and red the ones it takes for another, and stops at the row it fails, until the last lens of the series leaves the chart sharp, the black occluder sweeps across and a new chart goes up.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Snellen chart (Herman Snellen, Optotypi ad visum determinandum, 1862), the ten Sloan letters (Louise Sloan, 1959) and the logMAR chart's rows a tenth of a log unit apart (Ian Bailey and Jan Lovie, 1976), the letters drawn for this pattern on Sloan's 5 by 5 grid, pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Error=0.5..2.5, Speed=0.2..3, Glare=0..1, Duochrome=0..1\n//\n// Knob 1: Error. The eye's myopia, 0.5 to 2.5 diopters. One LED is one minute of arc and the pupil 3 mm, so each diopter left uncorrected blurs the chart by a disc 5.2 LEDs in radius. A series of lenses closes in on the error: at 0.5 they are 0, 0.25, 0.5, 0.75 and 0.5 diopters, blur radii 2.6, 1.3, 0, 1.3 and 0, and the bare eye reads down to the 10 or 7.9 LED row; at 2.5 the bare eye sees a disc 12.9 LEDs in radius and fails even the top letter, and the series takes 7 lenses.\n// Knob 2: Speed. At 2 a lens wipes in over 0.45 s, the reader looks for 0.35 s, spends 0.18 s on a letter and holds its result 0.8 s (2.2 s after the last lens), so a lens takes 3 to 4 s and a series of five about 22 s. At 0.2 all of it is ten times slower, at 3 two thirds as long.\n// Knob 3: Glare. A veil of light over the chart: at 0 the letters are black, at 1 they keep 35 percent of their contrast, and the reader sees that too. Through the right lens it still gets nine letters in ten on the 5 LED row, but a quarter diopter off it stops at the 7.9 LED row where it read to the bottom, and half a diopter off at the 12.6 or 15.8 row instead of the 10.\n// Knob 4: Duochrome. Up from 0.1 the light box turns red on the left half and green on the right, fully at 1. The eye focuses red behind green, half a diopter apart, so the red half is blurred as by a quarter diopter less myopia and the green as by a quarter more: red sharper while the lens is too weak, green sharper when it is too strong, both equally soft at the right one.\n// Buttons: K1 tap starts a new series on a new chart.\n\n// A letter is legible when what the eye sees of it is closer to that letter\n// than to any of the other nine. The reader here does that literally: it\n// blurs the patch of chart around the letter with the same disc, blurs each\n// of the ten Sloan letters alone at the same size and place, and takes the\n// one with the smallest difference, summed over the LEDs with exponent 4\n// (Minkowski pooling, as models of threshold vision add up small\n// differences), after adding noise to each distance. A sharp C and O differ\n// by one LED at the bottom row; blurred by a disc of radius 1.3 that LED is\n// spread over eight, and the reader starts to confuse them.\n//\n// The eye is myopic and does not accommodate, so a lens a quarter diopter\n// too strong blurs it as much as one a quarter too weak.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, pow, log, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Defocus blur: a disc of angular diameter pupil x diopters radians. With a\n// 3 mm pupil and one LED to a minute of arc, 5.16 LEDs of radius a diopter.\nconst KAPPA = 0.003 * (180 / PI) * 60 * 0.5;\nconst NOISE = 0.2;\n// Timings at Speed 2.\nconst T_FLIP = 0.45, T_LOOK = 0.35, T_LETTER = 0.18, T_HOLD = 0.8, T_LAST = 2.2;\n\n// ---- The ten Sloan letters. At the bottom row, 5 LEDs tall, each is a 5x5\n// bitmap, one LED to a stroke (16 is the left column, rows from the top).\n// The C is the Landolt ring with its gap to the right, one stroke wide, so C\n// and O differ by one LED there.\nconst SLOAN = \"CDHKNORSVZ\";\nconst BITS = [\n  14, 17, 16, 17, 14,\n  30, 17, 17, 17, 30,\n  17, 17, 31, 17, 17,\n  17, 18, 28, 18, 17,\n  17, 25, 21, 19, 17,\n  14, 17, 17, 17, 14,\n  30, 17, 30, 18, 17,\n  15, 16, 14, 1, 30,\n  17, 17, 17, 10, 4,\n  31, 2, 4, 8, 31,\n];\n// Bigger rows draw the same letters from shapes on the 5 by 5 grid, one unit\n// to a stroke: boxes, elliptical rings and straight bars.\nconst box = (u, v, x0, y0, x1, y1) => u >= x0 && u \u003c= x1 && v >= y0 && v \u003c= y1;\nfunction ring(u, v, cx, cy, ao, bo, ai, bi) {\n  const x = u - cx, y = v - cy;\n  return (x * x) / (ao * ao) + (y * y) / (bo * bo) \u003c= 1 && (x * x) / (ai * ai) + (y * y) / (bi * bi) >= 1;\n}\nfunction bar(u, v, ax, ay, bx, by, hw) {\n  const dx = bx - ax, dy = by - ay, t = cl(((u - ax) * dx + (v - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  const ex = u - ax - t * dx, ey = v - ay - t * dy;\n  return ex * ex + ey * ey \u003c= hw * hw;\n}\nconst O_ = (u, v) => ring(u, v, 2.5, 2.5, 2.5, 2.5, 1.5, 1.5);\nfunction inside(c, u, v) {\n  switch (c) {\n    case 0: return O_(u, v) && !(u > 2.5 && abs(v - 2.5) \u003c 0.5);\n    case 1: return box(u, v, 0, 0, 1, 5) || (u \u003c= 2.5 ? box(u, v, 0, 0, 2.5, 1) || box(u, v, 0, 4, 2.5, 5) : O_(u, v));\n    case 2: return box(u, v, 0, 0, 1, 5) || box(u, v, 4, 0, 5, 5) || box(u, v, 0, 2, 5, 3);\n    case 3: return box(u, v, 0, 0, 1, 5) || bar(u, v, 1, 3.2, 5, -0.4, 0.56) || bar(u, v, 2.4, 2.2, 5, 5.4, 0.56);\n    case 4: return box(u, v, 0, 0, 1, 5) || box(u, v, 4, 0, 5, 5) || bar(u, v, 0.6, 0, 4.4, 5, 0.6);\n    case 5: return O_(u, v);\n    case 6: return box(u, v, 0, 0, 1, 5) || (u \u003c= 2.5 ? box(u, v, 0, 0, 2.5, 1) || box(u, v, 0, 2, 2.5, 3) : ring(u, v, 2.5, 1.5, 2.5, 1.5, 1.5, 0.5)) || bar(u, v, 2.6, 2.8, 4.6, 5.3, 0.56);\n    case 7: return (ring(u, v, 2.5, 1.5, 2.5, 1.5, 1.5, 0.5) && !(u > 2.5 && v > 1.5)) || (ring(u, v, 2.5, 3.5, 2.5, 1.5, 1.5, 0.5) && !(u \u003c 2.5 && v \u003c 3.5));\n    case 8: return bar(u, v, 0.5, -1, 2.5, 5, 0.6) || bar(u, v, 4.5, -1, 2.5, 5, 0.6);\n    default: return box(u, v, 0, 0, 5, 1) || box(u, v, 0, 4, 5, 5) || bar(u, v, 4.3, 1, 0.7, 4, 0.6);\n  }\n}\n// Ink coverage of letter c, h LEDs tall, its corner at (x0, y0), into buf.\nfunction stamp(buf, bw, bh, c, x0, y0, h) {\n  if (h === 5) {\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 5; q++) {\n        const x = x0 + q, y = y0 + r;\n        if ((BITS[c * 5 + r] >> (4 - q)) & 1 && x >= 0 && x \u003c bw && y >= 0 && y \u003c bh) buf[y * bw + x] = 1;\n      }\n    return;\n  }\n  const k = 5 / h;\n  for (let y = max(0, floor(y0)); y \u003c min(bh, ceil(y0 + h)); y++)\n    for (let x = max(0, floor(x0)); x \u003c min(bw, ceil(x0 + h)); x++) {\n      let n = 0;\n      for (let j = 0; j \u003c 4; j++) {\n        const v = (y + (j + 0.5) / 4 - y0) * k;\n        if (v \u003c 0 || v > 5) continue;\n        for (let i = 0; i \u003c 4; i++) {\n          const u = (x + (i + 0.5) / 4 - x0) * k;\n          if (u >= 0 && u \u003c= 5 && inside(c, u, v)) n++;\n        }\n      }\n      if (n) buf[y * bw + x] = max(buf[y * bw + x], n / 16);\n    }\n}\n\n// ---- The chart: eight rows, logMAR 0.7 at the top to 0.0 at the bottom,\n// each 10^0.1 = 1.259 times the one below: 25.1, 19.9, 15.8, 12.6, 10, 7.9,\n// 6.3 and 5 LEDs. Letters stand one letter width apart as Bailey and Lovie\n// spaced them, so a row holds as many as fit, 1 at the top and 5 below 7\n// LEDs. Rows sit about 3 LEDs apart with the pointer's line in the gap.\nconst ROWS = (() => {\n  const hs = [];\n  for (let k = 7; k >= 0; k--) {\n    const h = 5 * pow(10, k / 10);\n    hs.push(abs(h - round(h)) \u003c 0.06 ? round(h) : h);\n  }\n  const gap = (125 - hs.reduce((a, b) => a + b, 0)) / 7, rows = [];\n  let y = 0;\n  for (let i = 0; i \u003c 8; i++) {\n    const h = hs[i], top = round(y), n = min(5, floor((62 / h + 1) / 2)), left = (W - (2 * n - 1) * h) / 2, xs = [];\n    for (let j = 0; j \u003c n; j++) xs.push(round(left + 2 * j * h));\n    rows.push({ h, top, n, xs, w: max(1, round(h)), mark: round(top + h + gap / 2 - 0.5) });\n    y += h + gap;\n  }\n  return rows;\n})();\n\n// ---- Disc blur. Each row of the disc is a span of the image row, summed\n// from prefix sums at fractional ends, so the disc grows smoothly with its\n// radius; rows near the rim come in with partial weight. Off the panel is\n// no ink.\nfunction kernel(r) {\n  const R = ceil(r + 0.5), dy = [], hw = [], wt = [];\n  let norm = 0;\n  for (let d = -R; d \u003c= R; d++) {\n    const w = d === 0 ? 1 : cl(r - abs(d) + 0.5, 0, 1);\n    if (w \u003c= 0) continue;\n    const h = sqrt(max(0, r * r - d * d));\n    dy.push(d), hw.push(h), wt.push(w);\n    norm += w * (2 * h + 1);\n  }\n  return { dy, hw, wt, inv: 1 / norm, R };\n}\nfunction prefix(src, w, h, pre) {\n  for (let y = 0; y \u003c h; y++) {\n    const o = y * (w + 1);\n    let a = 0;\n    pre[o] = 0;\n    for (let x = 0; x \u003c w; x++) pre[o + x + 1] = a += src[y * w + x];\n  }\n}\n// Ink of row y from 0 to t.\nfunction upto(src, pre, w, y, t) {\n  if (t \u003c= 0) return 0;\n  if (t >= w) return pre[y * (w + 1) + w];\n  const i = t | 0;\n  return pre[y * (w + 1) + i] + (t - i) * src[y * w + i];\n}\nfunction blurAt(src, pre, w, h, x, y, K) {\n  let s = 0;\n  for (let k = 0; k \u003c K.dy.length; k++) {\n    const yy = y + K.dy[k];\n    if (yy \u003c 0 || yy >= h) continue;\n    s += K.wt[k] * (upto(src, pre, w, yy, x + 1 + K.hw[k]) - upto(src, pre, w, yy, x - K.hw[k]));\n  }\n  return s * K.inv;\n}\n\nfunction gauss() {\n  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n}\n\n// A new chart: each row draws its letters without repeating one.\nfunction newChart(s) {\n  s.chart = ROWS.map((row) => {\n    const pool = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n    for (let i = 9; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [pool[i], pool[j]] = [pool[j], pool[i]];\n    }\n    return pool.slice(0, row.n);\n  });\n  s.ink.fill(0);\n  ROWS.forEach((row, i) => row.xs.forEach((x, j) => stamp(s.ink, W, H, s.chart[i][j], x, row.top, row.h)));\n  prefix(s.ink, W, H, s.pre);\n  s.tkey = -1;\n}\n\n// The lenses a series tries for an error E, in quarter diopters: none, half\n// of E, three quarters, then up a quarter at a time to E, one too strong,\n// and back to E.\nfunction plan(E) {\n  const q = (v) => round(v * 4) / 4, out = [0];\n  const push = (v) => out[out.length - 1] !== v && out.push(v);\n  push(q(E / 2));\n  push(q((3 * E) / 4));\n  for (let v = out[out.length - 1] + 0.25; v \u003c q(E) - 1e-6; v += 0.25) push(v);\n  push(q(E));\n  push(q(E) + 0.25);\n  push(q(E));\n  return out;\n}\n\n// A new series starts behind the occluder, the phoropter's black disc: a\n// new chart goes up and the first lens, none, wipes in from the dark.\nfunction newSeries(s) {\n  newChart(s);\n  s.Eplan = s.E;\n  s.lenses = plan(s.E);\n  s.li = 0;\n  s.L = 0;\n  s.best = -1;\n  clearMarks(s);\n  s.dark = true;\n  s.phase = \"flip\";\n  s.pt = 0;\n}\nfunction clearMarks(s) {\n  s.marks = ROWS.map((row) => new Array(row.n).fill(0));\n  s.ri = -1;\n  s.lj = -1;\n}\n\n// The blur radius a lens of power P leaves, on the red (-1), plain (0) or\n// green (+1) side.\nconst radius = (s, P, side) => KAPPA * abs(s.E - P + side * 0.25 * s.u);\n\n// The reader's answer for letter j of row ri. It looks at the letter's own\n// cell: its box, a LED above and below (the rows are 3 LEDs apart) and half\n// a letter to each side, where its neighbours' blur can reach in and crowd it.\nfunction read(s, ri, j) {\n  const row = ROWS[ri], h = row.h, x0 = row.xs[j], y0 = row.top;\n  const f = cl((32 - x0) / h, 0, 1);\n  const r = f * radius(s, s.L, -1) + (1 - f) * radius(s, s.L, 1);\n  const K = kernel(r), M = K.R + 1, n = ceil(h) + 2 * M, T = s.tpl;\n  const ex = min(M, ceil(h / 2)), wx = M - ex, wy = M - 1, ww = ceil(h) + 2 * ex, wh = ceil(h) + 2;\n  const key = ri * 100000 + round(r * 200);\n  if (s.tkey !== key) {\n    s.tkey = key;\n    for (let c = 0; c \u003c 10; c++) {\n      s.ink2.fill(0, 0, n * n);\n      stamp(s.ink2, n, n, c, M, M, h);\n      prefix(s.ink2, n, n, s.pre2);\n      for (let y = 0; y \u003c wh; y++) for (let x = 0; x \u003c ww; x++) T[c][y * ww + x] = blurAt(s.ink2, s.pre2, n, n, wx + x, wy + y, K);\n    }\n  }\n  const P = s.patch;\n  for (let y = 0; y \u003c wh; y++) for (let x = 0; x \u003c ww; x++) P[y * ww + x] = blurAt(s.ink, s.pre, W, H, x0 - M + wx + x, y0 - M + wy + y, K);\n  let best = 0, bs = 1e9;\n  for (let c = 0; c \u003c 10; c++) {\n    let d4 = 0;\n    for (let i = 0; i \u003c ww * wh; i++) {\n      const e = s.c * (P[i] - T[c][i]), e2 = e * e;\n      d4 += e2 * e2;\n    }\n    const score = sqrt(sqrt(d4)) + NOISE * gauss();\n    if (score \u003c bs) (bs = score), (best = c);\n  }\n  return best;\n}\n\nexport function setup(params) {\n  const s = (params.s = {\n    E: 0.5, c: 1, u: 0, L: 0, Lold: 0, pt: 0, phase: \"flip\", dark: true, btn: false,\n    ink: new Float32Array(W * H), pre: new Float32Array(H * (W + 1)),\n    ink2: new Float32Array(64 * 64), pre2: new Float32Array(64 * 65), patch: new Float32Array(64 * 64),\n    tpl: Array.from({ length: 10 }, () => new Float32Array(64 * 64)),\n    rgb: new Float32Array(W * H * 3), colK: new Array(W), colDark: new Uint8Array(W), started: false,\n  });\n  return s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0.5, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.E = cl(k[0] == null ? 0.5 : k[0], 0.5, 2.5);\n  const sc = 2 / cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  s.c = 1 - 0.65 * cl(k[2] || 0, 0, 1);\n  s.u = smooth((cl(k[3] == null ? 0.06 : k[3], 0, 1) - 0.1) / 0.9);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  // A new error or a tap closes the occluder for a new series.\n  if (!s.started) (s.started = true), newSeries(s);\n  else if (((btn && !s.btn) || abs(s.E - s.Eplan) > 0.1) && s.phase !== \"close\") (s.phase = \"close\"), (s.pt = 0);\n  s.btn = btn;\n  s.pt += d;\n  if (s.phase === \"close\") {\n    if (s.pt >= T_FLIP * sc) newSeries(s);\n  } else if (s.phase === \"flip\") {\n    if (s.pt >= T_FLIP * sc) (s.phase = \"look\"), (s.pt = 0), (s.Lold = s.L), (s.dark = false);\n  } else if (s.phase === \"look\") {\n    if (s.pt >= T_LOOK * sc) {\n      s.phase = \"read\";\n      s.pt = 0;\n      s.ri = s.li === 0 ? 0 : max(0, min(s.best, 6) - 1);\n      s.lj = 0;\n      s.marks[s.ri][0] = read(s, s.ri, 0) === s.chart[s.ri][0] ? 1 : 2;\n      s.best = -1;\n    }\n  } else if (s.phase === \"read\") {\n    if (s.pt >= T_LETTER * sc) {\n      s.pt = 0;\n      const row = ROWS[s.ri];\n      if (++s.lj >= row.n) {\n        // More than half right passes the row.\n        const right = s.marks[s.ri].filter((m) => m === 1).length;\n        if (right * 2 > row.n) s.best = s.ri;\n        if (right * 2 > row.n && s.ri \u003c 7) (s.ri++), (s.lj = 0);\n        else return void ((s.phase = \"hold\"), (s.lj = -1));\n      }\n      s.marks[s.ri][s.lj] = read(s, s.ri, s.lj) === s.chart[s.ri][s.lj] ? 1 : 2;\n    }\n  } else if (s.pt >= (s.li === s.lenses.length - 1 ? T_LAST : T_HOLD) * sc) {\n    if (s.li === s.lenses.length - 1) return void ((s.phase = \"close\"), (s.pt = 0));\n    s.li++;\n    s.Lold = s.L;\n    s.L = s.lenses[s.li];\n    const keep = s.best;\n    clearMarks(s);\n    s.best = keep;\n    s.phase = \"flip\";\n    s.pt = 0;\n  }\n  s.sc = sc;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.started) return;\n  const sc = s.sc || 1;\n  // A lens wipes in from the left: columns it has passed see the new one,\n  // the rest the old lens, or the dark of the occluder.\n  const moving = s.phase === \"flip\" || s.phase === \"close\";\n  const wipe = moving ? -6 + 76 * smooth(s.pt / (T_FLIP * sc)) : 999;\n  const Ks = [[kernel(radius(s, s.Lold, -1)), kernel(radius(s, s.Lold, 1))], [kernel(radius(s, s.L, -1)), kernel(radius(s, s.L, 1))]];\n  const red = [255, 36, 18], green = [40, 255, 70], white = [255, 246, 232], u = s.u, c = s.c, rgb = s.rgb;\n  for (let x = 0; x \u003c W; x++) {\n    const passed = x \u003c wipe;\n    s.colDark[x] = s.phase === \"close\" ? +passed : s.phase === \"flip\" && s.dark ? +!passed : 0;\n    s.colK[x] = Ks[passed || s.phase === \"close\" ? 1 : 0][x \u003c 32 ? 0 : 1];\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const vy = (y - 63.5) / 64;\n    for (let x = 0; x \u003c W; x++) {\n      if (s.colDark[x]) {\n        rgb.fill(0, (y * W + x) * 3, (y * W + x) * 3 + 3);\n        continue;\n      }\n      const b = blurAt(s.ink, s.pre, W, H, x, y, s.colK[x]);\n      const vx = (x - 31.5) / 32, lit = 0.8 * (1 - 0.13 * vx * vx - 0.1 * vy * vy) * (1 - c * b);\n      const tint = x \u003c 32 ? red : green, j = (y * W + x) * 3;\n      let dark = 1;\n      if (moving) dark = 1 - 0.6 * exp(-(((x - wipe) / 2.2) ** 2));\n      for (let q = 0; q \u003c 3; q++) rgb[j + q] = (white[q] + (tint[q] - white[q]) * u) * lit * dark;\n    }\n  }\n  // The pointer's line: blue under a letter read right, red under a\n  // mistake, amber under the letter being read.\n  ROWS.forEach((row, i) => {\n    row.xs.forEach((x0, j) => {\n      const m = s.marks[i][j], now = s.phase === \"read\" && i === s.ri && j === s.lj;\n      if (!m && !now) return;\n      const col = now && s.pt \u003c (T_LETTER * sc) / 2 ? [255, 150, 0] : m === 1 ? [20, 70, 255] : [235, 20, 40];\n      for (let x = x0; x \u003c min(W, x0 + row.w); x++) {\n        if (s.colDark[x]) continue;\n        const o = (row.mark * W + x) * 3;\n        rgb[o] = col[0], rgb[o + 1] = col[1], rgb[o + 2] = col[2];\n      }\n    });\n  });\n  // The row the eye reads to through this lens, pointed at from both sides.\n  if (s.best >= 0) {\n    const row = ROWS[s.best], m = round(row.top + row.h / 2 - 0.5);\n    for (const [dx, dy] of [[0, 0], [1, 0], [2, 0], [0, -1], [1, -1], [0, 1], [1, 1], [0, -2], [0, 2]])\n      for (const x of [dx, W - 1 - dx]) {\n        if (s.colDark[x]) continue;\n        const o = ((m + dy) * W + x) * 3;\n        rgb[o] = 20, rgb[o + 1] = 70, rgb[o + 2] = 255;\n      }\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const j = i * 3;\n    display.setPixel(i % W, (i / W) | 0, round(cl(rgb[j], 0, 255)), round(cl(rgb[j + 1], 0, 255)), round(cl(rgb[j + 2], 0, 255)));\n  }\n}\n","flag-hoist":"// ===== Patternflow pattern =====\n// Title:   Flag Hoist\n// Family:  type\n// Idea:    Words are spelled in the letter flags of the International Code of Signals, bent on one under another to a halyard that runs down the tall panel by its left edge, and each hoist is hauled up hand over hand into a night sky, flies there with every flag fluttering in a wave that grows towards its fly and turns its folds light and dark, shows the plain letter beside each flag while it is close up, and is hauled down for the next word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the letter flags of the International Code of Signals, which began as the British Board of Trade's Commercial Code of Signals (1857), its 26 letter flags as revised in 1931 and 1965; before it Frederick Marryat's Code of Signals for the Merchant Service (1817); 5 by 7 capitals from Photon Disk (pattern round 70); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Wind=3..8, Speed=0.2..3, Letters=3..6, Sky=0..1\n//\n// Knob 1: Wind. The wind in Beaufort force. At the opening 3, the gentle breeze in which light flags stand out, a fold runs down each flag about once a second, its steepest side turned 29 degrees, and the fly lifts and falls about 2 LEDs; at 8, a gale, the folds come 2.7 times a second at half the length, turned up to 45 degrees, the fly whips about 6 LEDs and the cloth bunches 7 percent shorter.\n// Knob 2: Speed. At 2 a hoist takes 2.6 s to go up in six hauls, flies close up for 4.5 s, takes 2.2 s to come down, and the next follows 0.4 s later, 9.7 s a word. Every time scales as 2 / Speed: 97 s a word at 0.2, 6.5 s at 3.\n// Knob 3: Letters. How many flags a hoist carries, one word of that length. At 3 (KEG, RIG, DRY, BAY, OAR, SKY) the flags are 31 LEDs deep and 40 long and the hoist reaches row 100; at 4 (QUAY, GOLD, DECK, BUOY and four more) 25 by 34; at 5 (OCEAN, YACHT, RIDGE and three more) 20 by 28; at 6 (ANCHOR, BRIDGE, VOYAGE and three more) 16 by 23, the hoist reaching row 110 to 113.\n// Knob 4: Sky. 0 is a moonless night, near black with a few faint stars; 1 is the blue hour, a deep blue sky going violet and then amber towards the foot of the panel. The opening 0.06 is night.\n// Buttons: K1 tap hauls the hoist down at once and sends up the next word.\n\n// A ship carries one flag for each letter, so a word that needs one letter\n// twice would take a substitute pennant in the second place. The words here\n// never repeat a letter. A hoist is read from the top down once it is\n// close up, hauled right up to the block, and that is when the plain\n// letters show.\n//\n// A flag in the wind is a sheet on which waves run from the hoist, where it\n// is held, to the fly, where it is free, growing as they go. The sheet's\n// folds stand out of the panel: each column of the flag tilts by the slope\n// of the fold there, which shortens it on the panel and turns it towards or\n// away from a light on the left. The folds also lift the fly a\n// little, so the top and bottom edges ripple.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst TAU = 2 * PI;\n\n// The halyard's column and where the flags' hoist edges start.\nconst HX = 3, X0 = 4, TOP = 2, GAP = 3;\n// Cloth colours, chosen to read on LEDs: white, red, blue, yellow, black.\n// Black cloth stays just above dark so the flag keeps its shape at night.\nconst CLOTH = [\n  [228, 226, 214],\n  [255, 8, 22],\n  [0, 40, 255],\n  [255, 196, 0],\n  [36, 34, 42],\n];\nconst Wt = 0, R = 1, B = 2, Y = 3, K = 4;\n// Swallowtailed flags, A and B: the notch reaches this far into the fly.\nconst NOTCH = 0.24;\n\n// Each flag as a function of u along the fly (0 at the hoist), v down the\n// hoist (0 at the top), and the flag's length and depth in LEDs for the\n// shapes that are square or round on the cloth.\nfunction distLine(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay;\n  return abs((px - ax) * dy - (py - ay) * dx) / sqrt(dx * dx + dy * dy);\n}\nconst FLAGS = {\n  A: (u) => (u \u003c 0.5 ? Wt : B),\n  B: () => R,\n  C: (u, v) => [B, Wt, R, Wt, B][min(4, floor(v * 5))],\n  D: (u, v) => (v \u003c 0.25 || v >= 0.75 ? Y : B),\n  E: (u, v) => (v \u003c 0.5 ? B : R),\n  F: (u, v) => (abs(u - 0.5) + abs(v - 0.5) \u003c 0.5 ? R : Wt),\n  G: (u) => (floor(u * 6) % 2 ? B : Y),\n  H: (u) => (u \u003c 0.5 ? Wt : R),\n  I: (u, v, l, d) => (((u - 0.5) * l) ** 2 + ((v - 0.5) * d) ** 2 \u003c (0.26 * d) ** 2 ? K : Y),\n  J: (u, v) => (v \u003c 1 / 3 || v >= 2 / 3 ? B : Wt),\n  K: (u) => (u \u003c 0.5 ? Y : B),\n  L: (u, v) => ((u \u003c 0.5) === (v \u003c 0.5) ? Y : K),\n  M: (u, v, l, d) => (min(distLine(u * l, v * d, 0, 0, l, d), distLine(u * l, v * d, 0, d, l, 0)) \u003c 0.1 * d ? Wt : B),\n  N: (u, v) => ((floor(u * 4) + floor(v * 4)) % 2 ? Wt : B),\n  O: (u, v) => (v \u003c u ? R : Y),\n  P: (u, v, l, d) => (abs(u - 0.5) * l \u003c d / 6 && abs(v - 0.5) * d \u003c d / 6 ? Wt : B),\n  Q: () => Y,\n  R: (u, v, l, d) => (abs(u - 0.5) * l \u003c 0.1 * d || abs(v - 0.5) \u003c 0.1 ? Y : R),\n  S: (u, v, l, d) => (abs(u - 0.5) * l \u003c d / 6 && abs(v - 0.5) * d \u003c d / 6 ? B : Wt),\n  T: (u) => [R, Wt, B][min(2, floor(u * 3))],\n  U: (u, v) => ((u \u003c 0.5) === (v \u003c 0.5) ? R : Wt),\n  V: (u, v, l, d) => (min(distLine(u * l, v * d, 0, 0, l, d), distLine(u * l, v * d, 0, d, l, 0)) \u003c 0.1 * d ? R : Wt),\n  W: (u, v, l, d) => {\n    const e = min(u * l, (1 - u) * l, v * d, (1 - v) * d);\n    return e \u003c d / 6 ? B : e \u003c d / 3 ? Wt : R;\n  },\n  X: (u, v, l, d) => (abs(u - 0.5) * l \u003c 0.1 * d || abs(v - 0.5) \u003c 0.1 ? B : Wt),\n  Y: (u, v, l, d) => (floor(((u * l + v * d) / (l + d)) * 10) % 2 ? R : Y),\n  Z: (u, v) => (u \u003c v && u \u003c 1 - v ? K : v \u003c u && v \u003c 1 - u ? Y : u > v && u > 1 - v ? B : R),\n};\n\n// Words of three to six letters with no letter twice.\nconst WORDS = {\n  3: [\"KEG\", \"RIG\", \"DRY\", \"BAY\", \"OAR\", \"SKY\"],\n  4: [\"QUAY\", \"GOLD\", \"DECK\", \"BUOY\", \"YARD\", \"BRIG\", \"TIDE\", \"WIND\"],\n  5: [\"OCEAN\", \"YACHT\", \"RIDGE\", \"BADGE\", \"BOARD\", \"DRIFT\"],\n  6: [\"ANCHOR\", \"BRIDGE\", \"VOYAGE\", \"YONDER\", \"GOLDEN\", \"BYGONE\"],\n};\n// Flag depth and length for each word length: the hoist runs from row 2 to\n// row 100 (three flags) or 110 to 113 (more), with 3 LEDs of halyard\n// between flags.\nconst SIZE = { 3: [31, 40], 4: [25, 34], 5: [20, 28], 6: [16, 23] };\n\n// 5 x 7 capitals from Photon Disk (pattern round 70), rows from the top.\nconst GLYPHS = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", B: \"####. #...# #...# ####. #...# #...# ####.\", C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\", E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\",\n  G: \".###. #...# #.... #.### #...# #...# .####\", H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  J: \"..### ...#. ...#. ...#. ...#. #..#. .##..\", K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  M: \"#...# ##.## #.#.# #.#.# #...# #...# #...#\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\",\n  P: \"####. #...# #...# ####. #.... #.... #....\", Q: \".###. #...# #...# #...# #.#.# #..#. .##.#\", R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\", X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\",\n};\nconst FONT = {};\nfor (const k in GLYPHS) FONT[k] = GLYPHS[k].replace(/ /g, \"\");\n\n// Steps along the cloth when a flag's folds are worked out.\nconst STEPS = 96;\n// The light comes from the left and the front.\nconst LX = -0.6, LZ = 0.8;\n\n// A few faint stars, fixed for the run.\nconst STARS = [];\nfor (let i = 0; i \u003c 26; i++) STARS.push([floor(Math.random() * W), floor(Math.random() * H), Math.random() * TAU, 0.5 + Math.random() * 0.5]);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, phase: -1, pt: 0, word: \"\", n: 3, next: { 3: 0, 4: 0, 5: 0, 6: 0 }, wind: 3, speed: 2, sky: 0.06, btn: false,\n    y: H, show: 0, flut: 0, acc: new Float32Array(W * H * 3),\n    cu: new Float32Array(W), cdy: new Float32Array(W), csh: new Float32Array(W), cdu: new Float32Array(W),\n    xs: new Float32Array(STEPS + 1), ys: new Float32Array(STEPS + 1), ss: new Float32Array(STEPS + 1),\n  };\n  return params.s;\n}\n\n// Phase 0 up, 1 close up, 2 down, 3 the pause before the next word.\nconst DUR = [2.6, 4.5, 2.2, 0.4];\nconst HAULS = 6;\n\nfunction hoistLength(S) {\n  const [d] = SIZE[S.n];\n  return S.n * d + (S.n - 1) * GAP;\n}\nfunction nextWord(S, n) {\n  S.n = n;\n  const list = WORDS[n];\n  S.word = list[S.next[n] % list.length];\n  S.next[n]++;\n  S.phase = 0;\n  S.pt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [3, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.wind = cl(k[0], 3, 8);\n  S.speed = cl(k[1], 0.2, 3);\n  const n = round(cl(k[2], 3, 6));\n  S.sky = cl(k[3], 0, 1);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (S.phase \u003c 0) nextWord(S, n);\n  if (btn && !S.btn && S.phase \u003c 2) (S.phase = 2), (S.pt = 0), (S.from = S.y);\n  S.btn = btn;\n  S.t += d;\n  // The flutter runs on its own clock so a change of wind never jumps it.\n  S.flut += d * (0.95 + 0.35 * (S.wind - 3));\n  const sc = 2 / S.speed;\n  S.pt += d;\n  const len = hoistLength(S);\n  if (S.phase === 0) {\n    // Hand over hand: the haul surges and slackens six times on the way.\n    const p = cl(S.pt / (DUR[0] * sc), 0, 1), q = p - (0.55 * sin(TAU * HAULS * p)) / (TAU * HAULS);\n    S.y = H + 2 + (TOP - H - 2) * smooth(q);\n    if (p >= 1) (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    S.y = TOP;\n    if (S.pt >= DUR[1] * sc) (S.phase = 2), (S.pt = 0), (S.from = TOP);\n  } else if (S.phase === 2) {\n    const p = cl(S.pt / (DUR[2] * sc), 0, 1), from = S.from ?? TOP;\n    S.y = from + (H + 2 - from) * (p * p * (1.6 - 0.6 * p));\n    if (p >= 1) (S.phase = 3), (S.pt = 0);\n  } else {\n    S.y = H + len + 2;\n    if (S.pt >= DUR[3] * sc) nextWord(S, n);\n  }\n  // The letters fade in once the hoist is close up and out as it starts down.\n  const want = S.phase === 1 ? 1 : 0;\n  S.show += (want - S.show) * min(1, d * (want ? 3 : 6));\n}\n\n// One flag: its columns first (where each u lands, how far its fold lifts\n// it, how it is lit), then every LED in its box, four samples each.\nfunction flag(S, acc, ch, top, d, l, ph) {\n  const wind = S.wind - 3, t = S.flut * TAU;\n  // The steepest fold, as dz/dx: 0.55 (29 degrees) in a gentle breeze, 1\n  // (45 degrees) in a gale, the folds getting shorter as the wind rises.\n  const lam = 0.95 - 0.09 * wind, amp = ((0.55 + 0.09 * wind) * lam) / TAU, lift = 1.5 + 0.6 * wind;\n  const cu = S.cu, cdy = S.cdy, csh = S.csh, cdu = S.cdu, xs = S.xs, ys = S.ys, ss = S.ss, N = STEPS;\n  // March along the cloth in small steps, adding up how far along the panel\n  // each step goes (its length times the cosine of its tilt).\n  let x = 0;\n  for (let i = 0; i \u003c= N; i++) {\n    const u = i / N, g = u ** 0.9, th = (TAU * u) / lam - t + ph;\n    // The slope of the fold, dz/dx, which tilts the column.\n    const slope = amp * g * (TAU / lam) * cos(th) + amp * 0.9 * max(u, 0.01) ** -0.1 * sin(th);\n    const tilt = atan(slope);\n    if (i > 0) x += (l / N) * cos(tilt);\n    xs[i] = x;\n    ys[i] = lift * g * sin(th - 0.9) + 0.4 * lift * u * u * sin(2 * th + 0.5);\n    // Lambert light on the tilted column, never black.\n    ss[i] = 0.3 + 0.78 * max(0, -sin(tilt) * LX + cos(tilt) * LZ);\n  }\n  const end = xs[N];\n  // Each LED column the flag reaches: the u at its centre by walking the\n  // table, and how much u one LED spans there.\n  let j = 0;\n  const cols = min(W - X0, floor(end) + 1);\n  for (let col = 0; col \u003c cols; col++) {\n    const xc = col + 0.5;\n    while (j \u003c N - 1 && xs[j + 1] \u003c xc) j++;\n    const f = cl((xc - xs[j]) / max(1e-6, xs[j + 1] - xs[j]), 0, 1);\n    cu[col] = (j + f) / N;\n    cdy[col] = ys[j] + (ys[j + 1] - ys[j]) * f;\n    csh[col] = ss[j] + (ss[j + 1] - ss[j]) * f;\n    cdu[col] = 1 / (N * max(1e-6, xs[j + 1] - xs[j]));\n  }\n  const fn = FLAGS[ch], notch = ch === \"A\" || ch === \"B\";\n  const y0 = max(0, floor(top - 8)), y1 = min(H - 1, floor(top + d + 8));\n  for (let c = 0; c \u003c cols; c++) {\n    const px = X0 + c, u = cu[c], du = cdu[c], dy = cdy[c], sh = csh[c];\n    // The fly edge, soft.\n    const aFly = cl(end - c, 0, 1);\n    for (let py = y0; py \u003c= y1; py++) {\n      const yy = py + 0.5 - top - dy;\n      const aEdge = cl(min(yy, d - yy) + 0.5, 0, 1);\n      if (aEdge \u003c= 0) continue;\n      // Four samples a quarter LED from the centre. A sample in the\n      // swallowtail's notch is sky, so it only thins the LED.\n      let r = 0, g = 0, b = 0, hits = 0;\n      for (let s = 0; s \u003c 4; s++) {\n        const su = cl(u + ((s & 1) - 0.5) * 0.5 * du, 0, 0.9999), sv = cl((yy + ((s >> 1) - 0.5) * 0.5) / d, 0, 0.9999);\n        if (notch && su > 1 - NOTCH * (1 - abs(2 * sv - 1))) continue;\n        const cc = CLOTH[fn(su, sv, l, d)];\n        r += cc[0];\n        g += cc[1];\n        b += cc[2];\n        hits++;\n      }\n      if (!hits) continue;\n      const a = (aEdge * aFly * hits) / 4, kk = (py * W + px) * 3, m = sh / 255 / hits;\n      acc[kk] += (r * m - acc[kk]) * a;\n      acc[kk + 1] += (g * m - acc[kk + 1]) * a;\n      acc[kk + 2] += (b * m - acc[kk + 2]) * a;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const acc = S.acc, sky = S.sky, sk = sky ** 1.5, t = S.t;\n  // The sky: night is near black with a blue breath at the top; the blue\n  // hour runs deep blue to violet to amber at the foot.\n  for (let y = 0; y \u003c H; y++) {\n    const v = y / (H - 1);\n    const nr = 0, ng = 2 + 4 * (1 - v), nb = 5 + 12 * (1 - v);\n    const hr = v \u003c 0.6 ? 20 + 60 * (v / 0.6) : 80 + 120 * ((v - 0.6) / 0.4);\n    const hg = v \u003c 0.6 ? 34 + 6 * (v / 0.6) : 40 + 50 * ((v - 0.6) / 0.4);\n    const hb = v \u003c 0.6 ? 120 - 20 * (v / 0.6) : 100 - 70 * ((v - 0.6) / 0.4);\n    const r = (nr + (hr - nr) * sk) / 255, g = (ng + (hg - ng) * sk) / 255, b = (nb + (hb - nb) * sk) / 255;\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      acc[k] = r;\n      acc[k + 1] = g;\n      acc[k + 2] = b;\n    }\n  }\n  const starA = 1 - smooth(sky * 1.6);\n  for (const [x, y, p, m] of STARS) {\n    const k = (y * W + x) * 3, v = starA * m * (0.13 + 0.07 * sin(t * 1.7 + p));\n    acc[k] = max(acc[k], v);\n    acc[k + 1] = max(acc[k + 1], v);\n    acc[k + 2] = max(acc[k + 2], v * 1.1);\n  }\n  // The halyard: a laid rope whose lay marks travel with the hoist.\n  const off = S.y;\n  for (let y = 0; y \u003c H; y++) {\n    const lay = (((floor(y - off) % 3) + 3) % 3) === 0 ? 0.62 : 0.42;\n    const k = (y * W + HX) * 3;\n    acc[k] = 0.92 * lay;\n    acc[k + 1] = 0.84 * lay;\n    acc[k + 2] = 0.68 * lay;\n  }\n  const [d, l] = SIZE[S.n];\n  const word = S.word;\n  for (let i = 0; i \u003c word.length; i++) {\n    const top = S.y + i * (d + GAP);\n    if (top > H + 8 || top + d \u003c -8) continue;\n    flag(S, acc, word[i], top, d, l, i * 1.7);\n    // The toggle and the snap that join each flag to the halyard.\n    for (const yy of [top, top + d - 1]) {\n      const iy = round(yy);\n      if (iy >= 0 && iy \u003c H) for (let x = HX; x \u003c= X0; x++) {\n        const k = (iy * W + x) * 3;\n        acc[k] = 0.75;\n        acc[k + 1] = 0.72;\n        acc[k + 2] = 0.66;\n      }\n    }\n  }\n  // The plain letters, two LEDs a dot, 9 LEDs clear of the fly.\n  if (S.show > 0.01) {\n    const a = smooth(S.show), lx = X0 + l + 9;\n    for (let i = 0; i \u003c word.length; i++) {\n      const g = FONT[word[i]], top = round(S.y + i * (d + GAP) + d / 2 - 7);\n      for (let gy = 0; gy \u003c 7; gy++)\n        for (let gx = 0; gx \u003c 5; gx++) {\n          if (g[gy * 5 + gx] !== \"#\") continue;\n          for (let q = 0; q \u003c 4; q++) {\n            const x = lx + gx * 2 + (q & 1), y = top + gy * 2 + (q >> 1);\n            if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n            const k = (y * W + x) * 3;\n            acc[k] += (0.94 - acc[k]) * a;\n            acc[k + 1] += (0.92 - acc[k + 1]) * a;\n            acc[k + 2] += (0.86 - acc[k + 2]) * a;\n          }\n        }\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[k])) | 0, (255 * min(1, acc[k + 1])) | 0, (255 * min(1, acc[k + 2])) | 0);\n    }\n}\n","lambda-diagrams":"// ===== Patternflow pattern =====\n// Title:   Lambda Diagrams\n// Family:  line\n// Idea:    Church-numeral arithmetic, SUCC 2, PLUS 2 3, TIMES 2 3, EXP 2 3, TIMES 4 4 and EXP 2 4, are drawn as Tromp's lambda diagrams, every abstraction a horizontal bar, every variable a vertical line hanging from the bar that binds it and every application a link joining the leftmost lines of function and argument, and they are reduced one normal-order beta step at a time, the redex's bar with its variables lighting warm white and its argument gold before the picture cross-fades to the next term laid out afresh to fit the panel, until the normal form, a staircase comb with one tooth for each count, holds while a pulse runs down it and the next expression begins.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: lambda calculus and Church numerals (Alonzo Church, An Unsolvable Problem of Elementary Number Theory, 1936), de Bruijn indices (Nicolaas Govert de Bruijn, 1972), lambda diagrams (John Tromp), pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Expression=0..6, Glow=0..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. At 0 the outermost bar and its variables are cyan and each deeper binder steps 0.09 round the wheel through blue and violet to magenta, links are pale, and a redex lights warm white and gold; at 0.5 the binders run red, orange, yellow and green and the redex lights pale blue and blue.\n// Knob 2: Speed. At 2 a step takes 1.25 s: 0.25 s showing the term, 0.55 s lighting the redex and 0.45 s cross-fading to the result. The step times scale as 2 / Speed, so at 0.2 a step takes 12.5 s and at 3 it takes 0.83 s; the 2.6 s hold on the normal form stays as it is.\n// Knob 3: Expression. 0 (the opening) runs the six expressions in turn; 1 to 6 repeats one: SUCC 2 (3 steps to 3), PLUS 2 3 (6 steps to 5), TIMES 2 3 (7 steps to 6), EXP 2 3 (16 steps to 8), TIMES 4 4 (11 steps to 16) and EXP 2 4 (32 steps to 16), whose widest term is 27 variables across, drawn at 2 LEDs a column.\n// Knob 4: Glow. A halo of the lines blurred over 5 x 5 LEDs is added on top, 0.35 times at 0, 0.48 at the opening 0.06 and 2.5 times at 1, where the lines swim in their own colour and the 1-LED lines of the big terms, a pitch of 2 apart, run together into bands.\n\n// A lambda term is variables, abstractions (lambda x. body) and\n// applications (f a). Church (1936) wrote the number n as the term that\n// applies f n times, lambda f. lambda x. f (f ... (f x)), and arithmetic as terms\n// that take numerals apart and put them together: PLUS m n f x = m f (n f x).\n// A beta step replaces (lambda x. body) a by the body with a in place of x;\n// normal order always takes the leftmost, outermost such redex, and reaches\n// the normal form whenever there is one.\n//\n// Terms are kept with de Bruijn indices: a variable is the number of\n// binders between it and its own, so no name ever needs renaming.\n//\n// Tromp's diagram lays a term out on a grid. Each variable takes a column\n// and is a vertical line from its binder's bar down to where it is used. An\n// abstraction is a bar on its own row across its body's columns. An\n// application puts function and argument side by side and joins their\n// leftmost lines one row below the deeper of the two, the function's line\n// carrying on down. The numeral n becomes two bars over a staircase of n\n// links: a comb.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Terms: { t: 0, i } a variable with its de Bruijn index (0 = the\n// nearest binder), { t: 1, b } an abstraction, { t: 2, f, a } an application.\nconst Var = (i) => ({ t: 0, i }), Lam = (b) => ({ t: 1, b }), App = (f, a) => ({ t: 2, f, a });\nconst ap = (...xs) => xs.reduce((f, a) => App(f, a));\nfunction num(n) {\n  let b = Var(0);\n  for (let k = 0; k \u003c n; k++) b = App(Var(1), b);\n  return Lam(Lam(b));\n}\nconst SUCC = Lam(Lam(Lam(App(Var(1), ap(Var(2), Var(1), Var(0)))))); // n f x. f (n f x)\nconst PLUS = Lam(Lam(Lam(Lam(ap(Var(3), Var(1), ap(Var(2), Var(1), Var(0))))))); // m n f x. m f (n f x)\nconst TIMES = Lam(Lam(Lam(App(Var(2), App(Var(1), Var(0)))))); // m n f. m (n f)\nconst EXP = Lam(Lam(App(Var(0), Var(1)))); // m n. n m, which is m to the n\nconst EXPRS = [\n  ap(SUCC, num(2)), ap(PLUS, num(2), num(3)), ap(TIMES, num(2), num(3)),\n  ap(EXP, num(2), num(3)), ap(TIMES, num(4), num(4)), ap(EXP, num(2), num(4)),\n];\n\nfunction shift(t, d, c) {\n  return t.t === 0 ? (t.i >= c ? Var(t.i + d) : t) : t.t === 1 ? Lam(shift(t.b, d, c + 1)) : App(shift(t.f, d, c), shift(t.a, d, c));\n}\nfunction subst(t, j, s) {\n  return t.t === 0 ? (t.i === j ? s : t) : t.t === 1 ? Lam(subst(t.b, j + 1, shift(s, 1, 0))) : App(subst(t.f, j, s), subst(t.a, j, s));\n}\n// One normal-order step, or null at the normal form.\nfunction step(t) {\n  if (t.t === 2) {\n    if (t.f.t === 1) return shift(subst(t.f.b, 0, shift(t.a, 1, 0)), -1, 0);\n    const f = step(t.f);\n    if (f) return App(f, t.a);\n    const a = step(t.a);\n    return a ? App(t.f, a) : null;\n  }\n  if (t.t === 1) {\n    const b = step(t.b);\n    return b ? Lam(b) : null;\n  }\n  return null;\n}\nconst nodes = (t) => (t.t === 0 ? 1 : t.t === 1 ? 1 + nodes(t.b) : 1 + nodes(t.f) + nodes(t.a));\n\n// ---- Layout in grid units. Segments: k 0 a bar (row r, columns c0..c1),\n// 1 a variable (column c, rows r0..r1), 2 a link (row r, columns c0..c1).\n// d is the depth of the binder a bar or variable belongs to. role marks the\n// first redex met in the walk, which is the normal-order one: 1 its bar and\n// the variables it binds, 2 its argument, 3 its link.\nfunction lay(t, c0, r0, env, ctx, redexLam) {\n  if (t.t === 0) {\n    const b = env[env.length - 1 - t.i] || { row: 0, d: 0, role: 0 };\n    const seg = { k: 1, c: c0, r0: b.row, r1: r0, d: b.d, role: ctx.role || b.role };\n    ctx.segs.push(seg);\n    return { w: 1, h: 0, left: seg };\n  }\n  if (t.t === 1) {\n    const bar = { k: 0, c0, c1: c0, r: r0, d: env.length, role: ctx.role || (redexLam ? 1 : 0) };\n    ctx.segs.push(bar);\n    env.push({ row: r0, d: env.length, role: redexLam ? 1 : 0 });\n    const B = lay(t.b, c0, r0 + 1, env, ctx, false);\n    env.pop();\n    bar.c1 = c0 + B.w - 1;\n    return { w: B.w, h: B.h + 1, left: B.left };\n  }\n  const redex = t.f.t === 1 && !ctx.found;\n  if (redex) ctx.found = true;\n  const F = lay(t.f, c0, r0, env, ctx, redex);\n  const outer = ctx.role;\n  if (redex) ctx.role = 2;\n  const A = lay(t.a, c0 + F.w, r0, env, ctx, false);\n  ctx.role = outer;\n  const h = max(F.h, A.h) + 1, row = r0 + h - 1;\n  F.left.r1 = row;\n  A.left.r1 = row;\n  ctx.segs.push({ k: 2, c0: F.left.c, c1: A.left.c, r: row, d: 0, role: redex ? 3 : outer });\n  return { w: F.w + A.w, h, left: F.left };\n}\n\n// The term in LED rectangles: the widest column pitch from 8 down to 2 that\n// fits 62 LEDs, a row pitch up to twice that (the panel is tall) and at most\n// 16 that fits 124, lines 2 LEDs thick from a pitch of 5. A bar reaches past\n// its outer columns by e, which leaves at least one dark LED between two\n// bars side by side on a row: none at pitch 2 and 3, 2 at pitch 7 and 8.\n// null if the term cannot fit at 2 x 2.\nfunction diagram(t) {\n  const ctx = { segs: [], role: 0, found: false };\n  const R = lay(t, 0, 0, [], ctx, false);\n  R.left.r1 = R.h; // the root's line runs on one row: the term's output\n  const w = R.w, h = R.h;\n  let gx = 8;\n  const ext = (g) => floor((g - (g >= 5 ? 2 : 1) - 1) / 2);\n  const span = (g) => (w - 1) * g + 2 * ext(g) + (g >= 5 ? 2 : 1);\n  while (gx > 2 && span(gx) > 62) gx--;\n  if (span(gx) > 62) return null;\n  const th = gx >= 5 ? 2 : 1, e = ext(gx);\n  let gy = min(16, 2 * gx);\n  while (gy > 2 && h * gy + th > 124) gy--;\n  if (h * gy + th > 124) return null;\n  const ox = round((W - span(gx)) / 2) + e, oy = round((H - h * gy - th) / 2);\n  const X = (c) => ox + c * gx, Y = (r) => oy + r * gy;\n  const rects = ctx.segs.map((s) =>\n    s.k === 0 ? [X(s.c0) - e, Y(s.r), X(s.c1) + e + th - 1, Y(s.r) + th - 1, s]\n    : s.k === 1 ? [X(s.c), Y(s.r0), X(s.c) + th - 1, Y(s.r1) + th - 1, s]\n    : [X(s.c0), Y(s.r), X(s.c1) + th - 1, Y(s.r) + th - 1, s]);\n  return { rects, redex: ctx.found, top: oy, bottom: Y(h) + th };\n}\n\n// Every term of one reduction, laid out, with a cap on steps and size so a\n// term that blows up is cut off rather than drawn.\nconst MAX_STEPS = 60, MAX_NODES = 600;\nfunction reduce(t0) {\n  const out = [];\n  for (let t = t0, n = 0; t && n \u003c= MAX_STEPS; t = step(t), n++) {\n    const dg = nodes(t) \u003c= MAX_NODES ? diagram(t) : null;\n    if (!dg) return null;\n    out.push(dg);\n    if (!dg.redex) return out;\n  }\n  return null;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, glow: 0.06, pick: -1, ex: -1, terms: null, k: 0, u: 0, phase: 0, pt: 0, fade: 1,\n    a: new Float32Array(W * H * 3), b: new Float32Array(W * H * 3), out: new Float32Array(W * H * 3), tmp: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\nfunction start(S, ex) {\n  for (let n = 0; n \u003c EXPRS.length; n++, ex = (ex + 1) % EXPRS.length) {\n    const terms = reduce(EXPRS[ex]);\n    if (terms) return void Object.assign(S, { ex, terms, k: 0, phase: 0, pt: 0 });\n  }\n}\n\n// Phases at Speed 2: 0 show the term 0.25 s, 1 light the redex 0.55 s, 2\n// cross-fade 0.45 s; at the normal form 3 hold 2.6 s and 4 fade out 0.5 s.\nconst T_SHOW = 0.25, T_HI = 0.55, T_MORPH = 0.45, T_HOLD = 2.6, T_OUT = 0.5;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  if (!S.terms) start(S, 0);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  S.glow = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const pick = round(cl(k[2] || 0, 0, 6));\n  if (pick !== S.pick) (S.pick = pick), start(S, pick ? pick - 1 : 0), (S.fade = 0);\n  const sc = 2 / S.speed;\n  S.pt += d;\n  S.fade = min(1, S.fade + d / 0.4);\n  const last = S.k >= S.terms.length - 1;\n  if (S.phase === 0 && S.pt >= T_SHOW * sc) (S.phase = last ? 3 : 1), (S.pt = 0);\n  else if (S.phase === 1 && S.pt >= T_HI * sc) (S.phase = 2), (S.pt = 0);\n  else if (S.phase === 2 && S.pt >= T_MORPH * sc) (S.k++, (S.phase = 0), (S.pt = 0));\n  else if (S.phase === 3 && S.pt >= T_HOLD) (S.phase = 4), (S.pt = 0);\n  else if (S.phase === 4 && S.pt >= T_OUT * min(sc, 1)) {\n    start(S, S.pick ? S.pick - 1 : (S.ex + 1) % EXPRS.length);\n    S.fade = 0;\n  }\n}\n\n// Paint one diagram into buf at weight w; hl lights its redex, pulse (a row)\n// runs a bright band down a held normal form.\nfunction paint(S, buf, dg, w, hl, pulse) {\n  const base = 0.52 + S.hue;\n  const roleCol = [null, hsv(base + 0.6, 0.3, 1), hsv(base + 0.62, 0.9, 1), [1, 1, 1]];\n  const link = hsv(base + 0.25, 0.15, 0.7);\n  for (const [x0, y0, x1, y1, s] of dg.rects) {\n    let c = s.k === 2 ? link : hsv(base + 0.09 * (s.d % 5), 0.78, 1);\n    if (hl > 0) {\n      const r = roleCol[s.role];\n      c = r ? [c[0] + (r[0] - c[0]) * hl, c[1] + (r[1] - c[1]) * hl, c[2] + (r[2] - c[2]) * hl] : [c[0] * (1 - 0.7 * hl), c[1] * (1 - 0.7 * hl), c[2] * (1 - 0.7 * hl)];\n    }\n    for (let y = max(0, y0); y \u003c= min(H - 1, y1); y++) {\n      const p = pulse == null ? w : w * (0.55 + 0.75 * exp(-(((y - pulse) / 7) ** 2)));\n      for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) {\n        const j = (y * W + x) * 3;\n        for (let q = 0; q \u003c 3; q++) if (c[q] * p > buf[j + q]) buf[j + q] = c[q] * p;\n      }\n    }\n  }\n}\n\n// A 5-wide box blur across and then down.\nfunction blur(src, dst, tmp) {\n  for (let y = 0; y \u003c H; y++)\n    for (let c = 0; c \u003c 3; c++) {\n      let s = 0;\n      for (let x = -2; x \u003c W + 2; x++) {\n        if (x + 2 \u003c W) s += src[(y * W + x + 2) * 3 + c];\n        if (x - 3 >= 0) s -= src[(y * W + x - 3) * 3 + c];\n        if (x >= 0 && x \u003c W) tmp[(y * W + x) * 3 + c] = s / 5;\n      }\n    }\n  for (let x = 0; x \u003c W; x++)\n    for (let c = 0; c \u003c 3; c++) {\n      let s = 0;\n      for (let y = -2; y \u003c H + 2; y++) {\n        if (y + 2 \u003c H) s += tmp[((y + 2) * W + x) * 3 + c];\n        if (y - 3 >= 0) s -= tmp[((y - 3) * W + x) * 3 + c];\n        if (y >= 0 && y \u003c H) dst[(y * W + x) * 3 + c] = s / 5;\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.terms) return;\n  const sc = 2 / S.speed, A = S.a, B = S.b, O = S.out;\n  A.fill(0);\n  B.fill(0);\n  const cur = S.terms[S.k], fade = smooth(S.fade);\n  if (S.phase === 0) paint(S, A, cur, fade, 0, null);\n  else if (S.phase === 1) paint(S, A, cur, fade, smooth(S.pt / (0.35 * T_HI * sc)), null);\n  else if (S.phase === 2) {\n    const u = smooth(S.pt / (T_MORPH * sc));\n    paint(S, A, cur, 1 - u, 1, null);\n    paint(S, B, S.terms[S.k + 1], u, 0, null);\n  } else {\n    // The pulse runs from the top bar to the end of the output line in 1.3 s, twice.\n    const pulse = cur.top - 10 + ((S.pt % 1.3) / 1.3) * (cur.bottom - cur.top + 20);\n    const out = S.phase === 4 ? 1 - smooth(S.pt / (T_OUT * min(sc, 1))) : 1;\n    paint(S, A, cur, out, 0, S.phase === 3 && S.pt \u003c 2.6 ? pulse : null);\n  }\n  for (let i = 0; i \u003c A.length; i++) A[i] += B[i];\n  blur(A, O, S.tmp);\n  const g = 0.35 + 2.15 * S.glow;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const j = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl((A[j] + g * O[j]) * 255, 0, 255)), round(cl((A[j + 1] + g * O[j + 1]) * 255, 0, 255)), round(cl((A[j + 2] + g * O[j + 2]) * 255, 0, 255)));\n    }\n}\n","promotion":"// ===== Patternflow pattern =====\n// Title:   Promotion\n// Family:  algo\n// Idea:    A random standard Young tableau of 8 by 16 cells fills the panel, its 128 entries rising along every row and down every column, each cell coloured by its entry and the gutters lit where the entries pass a quarter, a half and three quarters of 128 so three nested staircases show, and Schützenberger's promotion runs on it again and again: the 1 in the top-left corner lifts out as a white hole, the hole slides by jeu de taquin to the bottom-right corner, each step pulling in the smaller of its right and lower neighbours behind a short bright tail, every entry drops by one so the bands creep outward while the hole's path pushes them back, 128 goes into the corner, and a bar along the foot counts the promotions until, after exactly 128 of them, every cell is back where it started and the tableau flashes home.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: promotion of standard Young tableaux (Marcel-Paul Schützenberger, 1972) by jeu de taquin (Schützenberger, 1977), whose order on an a by b rectangle is exactly ab (Mark Haiman, 1992), the start of Brendon Rhoades's cyclic sieving for promotion (2010); the tableau drawn uniformly by the hook walk of Curtis Greene, Albert Nijenhuis and Herbert Wilf (1979); 3 by 5 digits copied from hydra-game.js (round 72); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=-1..2, Levels=0..1\n//\n// Knob 1: Hue. Turns the ramp round the wheel: at 0 the small entries in the top-left corner are azure, the middle ones violet and magenta, the large ones at the bottom-right orange and yellow; at 0.5 the ramp runs from red-orange through yellow and green to blue.\n// Knob 2: Speed. At 2 the 1 lifts out in 0.25 s, each slide of the hole takes 0.08 s on 8 LED cells (the glide is 100 LEDs a second at every size), 128 goes in over 0.25 s: a promotion of the 8 by 16 tableau takes 2.26 s and the way home 4.8 minutes. Every time scales as 2 / Speed: at 3 the way home takes 3.3 minutes, at 0.2 a promotion takes 23 s.\n// Knob 3: Size. The cell size, 8 LEDs at the opening 0: 8 by 16 cells, N = 128, 22 slides a promotion. At -1 cells of 4 LEDs, 16 by 32, N = 512, 46 slides and 20 minutes home; at 1 cells of 16 LEDs, 4 by 8, N = 32, 10 slides, 67 s home, each entry written in the cell; at 2 cells of 32 LEDs, 2 by 4, N = 8, 4 slides, 14 s home, the digits twice the size, and some of its 14 tableaux come home after 2 or 4 promotions, as cyclic sieving counts. A new size draws a new tableau.\n// Knob 4: Levels. How many bands the ramp is cut into: 4 at the opening 0.06, so three staircases, the edges of the Young diagrams of entries up to N/4, N/2 and 3N/4, stand in the lit gutters and the cells brighten and dim once a band; 8 at 0.5 (every 16 entries on 8 by 16); 16 at 1, where the 15 staircases nest close as contour lines of the tableau.\n// Buttons: K1 tap draws a new random tableau and starts the count again.\n\n// A standard Young tableau of a rectangular shape holds 1 to N once each,\n// increasing along rows and down columns. Promotion: take out the 1 at\n// the corner, and while the hole has a neighbour to its right or below,\n// move the smaller of the two into it; the hole ends at the far corner.\n// Take 1 from every entry and write N there. Haiman (1992) proved that on\n// an a by b rectangle doing this N = ab times gives back the tableau you\n// started from, for every tableau, though a single promotion moves only\n// one staircase of cells. The bar along the foot counts to N; a white dot\n// marks each cell that holds what it held at the start, and at N they all\n// light at once. A tableau can come home sooner, after a divisor of N, and\n// Rhoades (2010) counted how many do; on 8 by 16 a random one almost never.\n//\n// The cells holding 1 to m always form a Young diagram, a staircase from\n// the top-right edge to the bottom-left; the gutters on its edge are lit\n// for every m that is a multiple of N / Levels. A promotion turns the\n// diagram of 1 to m + 1 into that of 1 to m by taking off the corner\n// where the hole left it, so each staircase moves by at most a cell a\n// promotion: the falling entries push it out and the path pulls it in.\n//\n// The start is uniform among all tableaux of the shape: the hook walk\n// places N, N-1, ... 1 in turn, each by starting on a random free cell\n// and jumping to a random cell of its hook, to the right or below, until\n// it stands on a corner.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v, o, k) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// 3 by 5 digits, copied from hydra-game.js (round 72), rows top to bottom.\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001011001111\", \"101101111001001\",\n  \"111100111001111\", \"111100111101111\", \"111001010010010\", \"111101111101111\", \"111101111001111\"];\n\n// The hook walk (Greene, Nijenhuis and Wilf, 1979) on a rows of a cells.\nfunction randomTableau(a, b) {\n  const N = a * b, T = new Int16Array(N), len = new Int16Array(b).fill(a);\n  for (let n = N; n >= 1; n--) {\n    // A uniformly random cell of the shape still free.\n    let pick = floor(Math.random() * n), r = 0;\n    while (pick >= len[r]) pick -= len[r++];\n    let c = pick;\n    for (;;) {\n      const arm = len[r] - c - 1;\n      let leg = 0;\n      while (r + leg + 1 \u003c b && len[r + leg + 1] > c) leg++;\n      if (arm + leg === 0) break;\n      const m = floor(Math.random() * (arm + leg));\n      if (m \u003c arm) c += 1 + m;\n      else r += 1 + m - arm;\n    }\n    T[r * a + c] = n;\n    len[r]--;\n  }\n  return T;\n}\n\n// One promotion of T in place; returns the hole's path as cell indices.\nfunction promote(T, a, b) {\n  const N = a * b, path = [0];\n  let r = 0, c = 0;\n  for (;;) {\n    const right = c + 1 \u003c a ? T[r * a + c + 1] : 1e9, down = r + 1 \u003c b ? T[(r + 1) * a + c] : 1e9;\n    if (right === 1e9 && down === 1e9) break;\n    if (right \u003c down) T[r * a + c] = right, c++;\n    else T[r * a + c] = down, r++;\n    path.push(r * a + c);\n  }\n  for (let i = 0; i \u003c N; i++) T[i]--;\n  T[r * a + c] = N;\n  return path;\n}\n\nfunction newTableau(s) {\n  const cell = 8 * 2 ** s.size, a = W / cell, b = H / cell;\n  Object.assign(s, { cell, a, b, N: a * b, k: 0, phase: 0, pt: 0, j: 0, u: 0 });\n  s.T = randomTableau(a, b);\n  s.T0 = s.T.slice();\n  s.home = new Uint8Array(s.N).fill(1);\n  s.eh = new Float32Array((a - 1) * b);\n  s.ev = new Float32Array(a * (b - 1));\n  s.col = new Float32Array(s.N * 3);\n  startPromotion(s);\n}\n\n// Work out the promotion ahead, then let the animation walk through it.\nfunction startPromotion(s) {\n  s.next = s.T.slice();\n  s.path = promote(s.next, s.a, s.b);\n  s.Wk = s.T.slice();\n  s.phase = 0;\n  s.pt = 0;\n  s.j = 0;\n}\n\nexport function setup(params) {\n  const s = (params.s = { size: 0, hue: 0, speed: 2, levels: 4, flash: 0, btn: false });\n  newTableau(s);\n  return s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  s.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const size = round(cl(k[2] || 0, -1, 2)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (size !== s.size || (btn && !s.btn)) (s.size = size), newTableau(s);\n  s.btn = btn;\n  // Levels: 4 bands of N / 4 entries at the opening, 16 at 1.\n  s.levels = round(4 * 2 ** (2 * cl(k[3] == null ? 0.06 : k[3], 0, 1)));\n  const sc = 2 / s.speed, tRem = 0.25 * sc, tStep = 0.01 * s.cell * sc, tIns = 0.25 * sc;\n  const L = s.path.length - 1, total = tRem + L * tStep + tIns;\n  // The hole's staircase fades in 0.3 s at Speed 2, a comet's tail.\n  const fade = exp(-dt / (0.3 * sc));\n  for (let i = 0; i \u003c s.eh.length; i++) s.eh[i] *= fade;\n  for (let i = 0; i \u003c s.ev.length; i++) s.ev[i] *= fade;\n  s.flash = max(0, s.flash - dt / 1.4);\n  s.pt += dt;\n  // Phases: 0 the 1 lifts out, 1 the hole slides, 2 N goes in.\n  for (let guard = 0; guard \u003c 64; guard++) {\n    if (s.phase === 0 && s.pt >= tRem) (s.phase = 1), (s.pt -= tRem), (s.Wk[0] = -1);\n    else if (s.phase === 1 && s.pt >= tStep && s.j \u003c L) {\n      const from = s.path[s.j + 1], to = s.path[s.j];\n      s.Wk[to] = s.Wk[from];\n      s.Wk[from] = -1;\n      // Light the edge the hole crossed.\n      const a = s.a, lo = min(from, to);\n      if (abs(from - to) === 1) s.eh[floor(lo / a) * (a - 1) + (lo % a)] = 1;\n      else s.ev[lo] = 1;\n      s.j++;\n      s.pt -= tStep;\n    } else if (s.phase === 1 && s.j >= L) s.phase = 2;\n    else if (s.phase === 2 && s.pt >= tIns) {\n      s.pt -= tIns;\n      s.T = s.next;\n      s.k = (s.k + 1) % s.N;\n      let all = 1;\n      for (let i = 0; i \u003c s.N; i++) (s.home[i] = s.T[i] === s.T0[i] ? 1 : 0), (all &= s.home[i]);\n      if (all) s.flash = 1;\n      startPromotion(s);\n    } else break;\n  }\n  const done = s.phase === 0 ? s.pt : s.phase === 1 ? tRem + s.j * tStep + min(s.pt, tStep) : tRem + L * tStep + s.pt;\n  s.u = cl(done / total, 0, 1);\n  s.f = s.phase === 0 ? s.pt / tRem : s.phase === 1 ? s.pt / tStep : s.pt / tIns;\n}\n\n// The ramp: the hue runs 0.62 of the wheel from entry 1 to N, and the\n// brightness waves once over each band of N / Levels entries, at its\n// middle where the bands meet.\nfunction colourOf(s, x, out, k) {\n  const N = s.N, t = (x - 1) / (N - 1);\n  hsv(0.55 + s.hue + 0.62 * t, 0.8, 0.84 + 0.14 * sin((PI * (x - 1) * s.levels) / N), out, k);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { a, cell, N, Wk, col, path } = s, c1 = cell - 1, u = s.u;\n  const hole = [1, 0.97, 0.9];\n  // Every cell's colour; the entries fall by u on the way to the next\n  // tableau, so the bands flow outward while a promotion runs.\n  const band = s.band && s.band.length === N ? s.band : (s.band = new Int16Array(N)), bw = N / s.levels;\n  for (let i = 0; i \u003c N; i++) {\n    if (Wk[i] \u003c 0) (col[i * 3] = hole[0]), (col[i * 3 + 1] = hole[1]), (col[i * 3 + 2] = hole[2]), (band[i] = -1);\n    else colourOf(s, Wk[i] - u, col, i * 3), (band[i] = floor((Wk[i] - u - 1 + 1e-6) / bw));\n  }\n  const f = ease(s.f);\n  // The 1 lifting out turns white; N coming in comes out of white.\n  if (s.phase === 0) for (let q = 0; q \u003c 3; q++) col[q] += (hole[q] - col[q]) * f;\n  const corner = N - 1, ins = [0, 0, 0];\n  if (s.phase === 2) {\n    colourOf(s, N + 1 - u, ins, 0);\n    for (let q = 0; q \u003c 3; q++) col[corner * 3 + q] = hole[q] + (ins[q] - hole[q]) * f;\n  }\n  // The gliding cell: during a slide it leaves path[j+1] (now drawn as the\n  // hole) and moves over the hole at path[j].\n  let gx = -99, gy = -99, gc = null, gv = 0;\n  if (s.phase === 1 && s.j \u003c path.length - 1) {\n    const from = path[s.j + 1], to = path[s.j];\n    gc = [0, 0, 0];\n    colourOf(s, Wk[from] - u, gc, 0);\n    gv = Wk[from];\n    for (let q = 0; q \u003c 3; q++) col[from * 3 + q] = hole[q];\n    gx = ((from % a) + ((to % a) - (from % a)) * f) * cell;\n    gy = (floor(from / a) + (floor(to / a) - floor(from / a)) * f) * cell;\n  }\n  const fl = s.flash * 0.55, px = s.px || (s.px = new Float32Array(W * H * 3));\n  for (let y = 0; y \u003c H; y++) {\n    const row = floor(y / cell), iy = y - row * cell;\n    for (let x = 0; x \u003c W; x++) {\n      const cc = floor(x / cell), ix = x - cc * cell, i = row * a + cc;\n      let r = 0.025, g = 0.025, b = 0.05;\n      if (ix \u003c c1 && iy \u003c c1) (r = col[i * 3]), (g = col[i * 3 + 1]), (b = col[i * 3 + 2]);\n      else {\n        // A gutter on a band's edge is lit: the cells with entries up to a\n        // multiple of N / a form a Young diagram, and these are its edges.\n        const me = band[i], rt = ix === c1 && cc + 1 \u003c a ? band[i + 1] : me, dn = iy === c1 && row + 1 \u003c s.b ? band[i + a] : me;\n        const dg = ix === c1 && iy === c1 && cc + 1 \u003c a && row + 1 \u003c s.b ? band[i + a + 1] : me;\n        if (me >= 0 && ((rt >= 0 && rt !== me) || (dn >= 0 && dn !== me) || (dg >= 0 && dg !== me))) (r = 0.62), (g = 0.6), (b = 0.66);\n      }\n      // The gliding block, with soft edges where it sits between LEDs.\n      if (gc) {\n        const ox = cl(min(x + 1 - gx, gx + c1 - x), 0, 1), oy = cl(min(y + 1 - gy, gy + c1 - y), 0, 1), w = ox * oy;\n        if (w > 0) (r += (gc[0] - r) * w), (g += (gc[1] - g) * w), (b += (gc[2] - b) * w);\n      }\n      if (fl > 0) (r += (1 - r) * fl), (g += (1 - g) * fl), (b += (1 - b) * fl);\n      const k = (y * W + x) * 3;\n      px[k] = r;\n      px[k + 1] = g;\n      px[k + 2] = b;\n    }\n  }\n  const put = (x, y, r, g, b, w) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const k = (y * W + x) * 3;\n    px[k] += (r - px[k]) * w;\n    px[k + 1] += (g - px[k + 1]) * w;\n    px[k + 2] += (b - px[k + 2]) * w;\n  };\n  // The staircases the hole has left, through the cells' middles.\n  const lw = cell \u003c= 4 ? 1 : cell \u003c= 8 ? 2 : 3, off = round((c1 - lw) / 2), tc = [1, 0.93, 0.78], ta = 0.9;\n  for (let rr = 0; rr \u003c s.b; rr++)\n    for (let cc = 0; cc \u003c a; cc++) {\n      const x0 = cc * cell + off, y0 = rr * cell + off;\n      const eh = cc \u003c a - 1 ? s.eh[rr * (a - 1) + cc] : 0, ev = rr \u003c s.b - 1 ? s.ev[rr * a + cc] : 0;\n      if (eh > 0.01) for (let x = x0; x \u003c x0 + cell + lw; x++) for (let d = 0; d \u003c lw; d++) put(x, y0 + d, tc[0], tc[1], tc[2], ta * eh);\n      if (ev > 0.01) for (let y = y0; y \u003c y0 + cell + lw; y++) for (let d = 0; d \u003c lw; d++) put(x0 + d, y, tc[0], tc[1], tc[2], ta * ev);\n    }\n  // Entries written in the cells when they are 16 LEDs or more.\n  if (cell >= 16) {\n    const sz = cell >= 32 ? 2 : 1;\n    const write = (v, x0, y0) => {\n      const str = String(v), wdt = str.length * 4 * sz - sz;\n      let x = round(x0 + (c1 - wdt) / 2);\n      const y = round(y0 + (c1 - 5 * sz) / 2);\n      for (const ch of str) {\n        const bits = DIG[ch.charCodeAt(0) - 48];\n        for (let p = 0; p \u003c 15; p++)\n          if (bits[p] === \"1\")\n            for (let dy = 0; dy \u003c sz; dy++) for (let dx = 0; dx \u003c sz; dx++) put(x + (p % 3) * sz + dx, y + floor(p / 3) * sz + dy, 0.03, 0.02, 0.06, 0.88);\n        x += 4 * sz;\n      }\n    };\n    for (let i = 0; i \u003c N; i++) if (Wk[i] > 0 && !(gc && i === path[s.j + 1])) write(Wk[i], (i % a) * cell, floor(i / a) * cell);\n    if (gc) write(gv, gx, gy);\n  }\n  // A white dot in each cell that holds what it held at the start.\n  const dsz = cell \u003c= 4 ? 1 : 2;\n  for (let i = 0; i \u003c N; i++)\n    if (s.home[i] && Wk[i] > 0) {\n      const x0 = (i % a) * cell + c1 - dsz - (cell > 4 ? 1 : 0), y0 = floor(i / a) * cell + (cell > 4 ? 1 : 0);\n      for (let dy = 0; dy \u003c dsz; dy++) for (let dx = 0; dx \u003c dsz; dx++) put(x0 + dx, y0 + dy, 1, 1, 1, 0.95);\n    }\n  // The count: a bar along the bottom gutter, k + u of N, with a tick at\n  // each band.\n  const bar = ((s.k + u) / N) * W;\n  for (let x = 0; x \u003c W; x++) {\n    const w = cl(bar - x, 0, 1), tick = ((x + 1) % (W / a) === 0) ? 0.25 : 0;\n    put(x, H - 1, 1, 0.85, 0.55, max(w * 0.9, tick));\n  }\n  for (let i = 0; i \u003c W * H; i++)\n    display.setPixel(i % W, floor(i / W), round(cl(px[i * 3], 0, 1) * 255), round(cl(px[i * 3 + 1], 0, 1) * 255), round(cl(px[i * 3 + 2], 0, 1) * 255));\n}\n","rational-tangles":"// ===== Patternflow pattern =====\n// Title:   Rational Tangles\n// Family:  topology\n// Idea:    Two coloured ropes hang down the tall panel as a four-strand plat, capped at the top and loose at the bottom, and Conway's tangle dance plays on them: a twist T swaps the two middle ends at the foot so that the ropes really wind one more crossing in (x to x + 1), a rotate R carries all four ends one place round (x to -1/x), the fraction p/q in small figures changes with each call, and after a random string of calls the bottom ends close up into the two-bridge knot or link N(p/q), named by Schubert's classification, open again, and Conway's rule, rotate when positive and twist when negative, untangles the ropes back to 0.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rational tangles and their fractions (John H. Conway, \"An enumeration of knots and links, and some of their algebraic properties\", 1970) and the square dance of twists and rotations he used to show them; classification of two-bridge knots and links (Horst Schubert, \"Knoten mit zwei Brücken\", 1956); 3 by 5 capitals from Typewriter (pattern round 18) and 3 by 5 figures from Josephus (pattern round 68); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=6..14, Rope=-1..1\n//\n// Knob 1: Hue. Turns both ropes round the wheel together. At 0 rope A, the one capped on the left at [0], is cyan and rope B amber; at 0.5 A is red and B azure. Each rope keeps its colour through every call. A closed knot is one loop, so one rope takes the other's colour while the ends join; a closed link keeps both. The fraction is white, the calls grey, the undoing calls tinted like rope A, the name amber.\n// Knob 2: Speed. At 2 a call takes 0.75 s and a pause of 0.25 s, the ropes settle into the simplest picture in 0.45 s after one call in five, the ends close in 0.8 s, the knot holds for 2.6 s and opens in 0.8 s, and the dance waits 1.2 s at 0, so a dance lasts 21 s on average at Depth 6 and 36 s at 14. Everything scales as 2 / Speed: at 0.2 a call takes 7.5 s, at 3 half a second.\n// Knob 3: Depth. How many calls build the tangle, 6 to 14, drawn at random, T 65 times in 100, never R twice running and never R at 0, which would give 1/0, where a twist changes nothing. A dance is kept when it ends at p/q with |p| at least 3, holds at least 1 + floor((Depth - 6) / 4) calls of R (1 up to 9, 3 at 14) and never needs more than 12 crossings. At 6 the closure is a trefoil about two times in three and a figure-eight otherwise; at 10 it ranges over 4/1, 7/4, 10/7, 8/3, 13/8 and some thirty more. A crossing is 88 rows over the most crossings the dance will need, 16 at most: 16 at Depth 6, a median 14.7 at 8 and 10 and 12.6 at 12 and 14, 8.8 at the least. Conway's rule then undoes the tangle in 8 calls on average at Depth 6 and 14 at 14.\n// Knob 4: Rope. The rope's width, 3 x 2^Rope LEDs: 1.5 at -1, 3.1 at the opening 0.06 and 6 at 1, where the ropes nearly fill the 14 LEDs between neighbouring strands. The gap left where a rope passes under grows with it.\n// Buttons: K1 tap starts a new dance from 0.\n\n// A rational tangle is two strings in a ball with their four ends on the\n// boundary, NW, NE, SE and SW. Conway gave each one a fraction: [0] is two\n// arcs joining NW to NE and SW to SE, twisting the two right ends adds 1,\n// and turning the ball a quarter turn sends x to -1/x. Every rational tangle\n// is reached from [0] by twists and turns, and two are the same tangle\n// exactly when their fractions agree (Conway 1970; full proofs by Jay\n// Goldman and Louis Kauffman, 1997, and Kauffman and Sofia Lambropoulou,\n// 2004). Conway showed it with four people holding two ropes: on \"twist\"\n// the two on the right swap places, one passing under the other's rope; on\n// \"rotate\" all four step one place round; and to untangle any tangle, rotate\n// when its fraction is positive and twist when it is negative.\n// Closing NW to NE and SW to SE, the numerator closure, gives the\n// two-bridge link b(p, q); Schubert showed in 1956 that b(p, q) and b(p', q')\n// are the same unoriented link exactly when p = p' and q' = q or q q' = 1\n// mod p, and allowing mirror images, q' = -q or q q' = -1 as well.\n//\n// The panel draws the tangle as a plat: four lanes across the panel, ends 1\n// to 4 at the foot standing for NW, NE, SE and SW. The top is closed by caps,\n// 1-2 and 3-4 for [0], 2-3 inside 1-4 for [1/0]. Below come crossings, each\n// between lanes 2 and 3 (a horizontal twist, H) or lanes 1 and 2 (a vertical\n// twist, V, the twist of NW and NE). A T adds an H crossing at the foot, or\n// takes one away if the last crossing there was the opposite hand. An R\n// moves every end one place round the boundary: a crossing of lanes 2 and 3\n// becomes one of lanes 3 and 4, which on a rational tangle is the same as\n// one of lanes 1 and 2 (a flype), one of lanes 1 and 2 becomes one of 2 and\n// 3, every crossing keeps its hand and the caps swap. Worked through the\n// fractions that is x to -1/x. The picture is then the alternating one of\n// the regular continued fraction, all crossings of one sign alternating over\n// and under. A call that leaves a picture of another form, mostly a T just\n// after an R, is followed by the ropes settling into this one, their four\n// ends held still. Which hand counts as +1 is a convention;\n// the other choice would show every fraction as its negative, the mirror.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, sign, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst gcd = (a, b) => {\n  (a = abs(a)), (b = abs(b));\n  while (b) [a, b] = [b, a % b];\n  return a;\n};\n// The lanes' centres, the top of the crossings, the foot, the most crossings.\nconst X = [10.5, 24.5, 38.5, 52.5], YS = 28, YE = 116, MAXC = 12;\n// Seconds at Speed 2.\nconst T_MOVE = 0.75, T_SETTLE = 0.45, T_PAUSE = 0.25, T_CLOSE = 0.8, T_HOLD = 2.6, T_REST = 1.2;\n\n// ---- Fractions: p / q with q >= 0, 1/0 for infinity.\nfunction norm(p, q) {\n  if (q \u003c 0 || (q === 0 && p \u003c 0)) (p = -p), (q = -q);\n  const g = gcd(p, q) || 1;\n  return [p / g, q / g];\n}\nconst twist = ([p, q]) => (q === 0 ? [1, 0] : norm(p + q, q));\nconst turn = ([p, q]) => norm(-q, p);\n\n// ---- Diagrams: caps 0 or 1, and crossings from the top, each { p, o }:\n// p 1 between lanes 2 and 3, p 0 between lanes 1 and 2; o +1 when the\n// strand going down to the right passes over, -1 when it passes under.\n// The regular continued fraction, peeled from the foot: an H run of the\n// whole part while |x| >= 1, else a V run of the whole part of 1/x.\nfunction canon(p, q) {\n  const runs = [];\n  let caps;\n  for (;;) {\n    if (q === 0) {\n      caps = 1;\n      break;\n    }\n    if (p === 0) {\n      caps = 0;\n      break;\n    }\n    if (abs(p) >= q) {\n      const a = sign(p) * floor(abs(p) / q);\n      p -= a * q;\n      runs.push([1, a]);\n    } else {\n      const b = sign(p) * floor(q / abs(p));\n      q -= b * p;\n      runs.push([0, b]);\n    }\n  }\n  const steps = [];\n  for (let i = runs.length - 1; i >= 0; i--) {\n    const [t, a] = runs[i];\n    for (let k = 0; k \u003c abs(a); k++) steps.push({ p: t, o: t ? sign(a) : -sign(a) });\n  }\n  return { caps, steps };\n}\n// The literal moves on a picture.\nfunction litT(D) {\n  const st = D.steps.slice(), l = st[st.length - 1];\n  if (l && l.p === 1 && l.o === -1) st.pop();\n  else st.push({ p: 1, o: 1 });\n  return { caps: D.caps, steps: st };\n}\nconst litR = (D) => ({ caps: D.caps ^ 1, steps: D.steps.map((s) => ({ p: s.p ^ 1, o: s.o })) });\nconst same = (A, B) => A.caps === B.caps && A.steps.length === B.steps.length && A.steps.every((s, i) => s.p === B.steps[i].p && s.o === B.steps[i].o);\n// Which rope (0 or 1) runs in each lane below the last crossing.\nfunction ropesAtFoot(D) {\n  const r = D.caps ? [1, 0, 0, 1] : [0, 0, 1, 1];\n  for (const s of D.steps) [r[s.p], r[s.p + 1]] = [r[s.p + 1], r[s.p]];\n  return r;\n}\n\n// ---- Names of N(p/q), keyed by p and the least of q, -q, 1/q and -1/q\n// mod p, with Rolfsen's table numbers; \"^2_1\" is superscript 2, subscript 1.\nconst NAMES = {\n  \"2/1\": \"HOPF LINK\", \"3/1\": \"TREFOIL 3_1\", \"4/1\": \"SOLOMON 4^2_1\", \"5/1\": \"CINQUEFOIL 5_1\", \"5/2\": \"FIGURE-8 4_1\",\n  \"6/1\": \"LINK 6^2_1\", \"7/1\": \"KNOT 7_1\", \"7/2\": \"KNOT 5_2\", \"8/3\": \"WHITEHEAD 5^2_1\",\n  \"9/1\": \"KNOT 9_1\", \"9/2\": \"STEVEDORE 6_1\", \"10/3\": \"LINK 6^2_2\", \"11/2\": \"KNOT 7_2\", \"11/3\": \"KNOT 6_2\",\n  \"12/5\": \"LINK 6^2_3\", \"13/3\": \"KNOT 7_3\", \"13/5\": \"KNOT 6_3\", \"15/4\": \"KNOT 7_4\", \"17/5\": \"KNOT 7_5\",\n  \"19/7\": \"KNOT 7_6\", \"21/8\": \"KNOT 7_7\",\n};\nfunction inverse(q, p) {\n  for (let k = 1; k \u003c p; k++) if ((q * k) % p === 1) return k;\n  return 0;\n}\nfunction nameOf([p, q]) {\n  p = abs(p);\n  if (p === 0) return \"UNLINK\";\n  if (p === 1) return \"UNKNOT 0_1\";\n  const r = ((q % p) + p) % p, iv = inverse(r, p), c = min(r, p - r, iv, p - iv);\n  const key = p + \"/\" + c;\n  if (NAMES[key]) return NAMES[key];\n  // Unnamed here: the crossing number, the sum of the continued fraction.\n  let a = p, b = c, n = 0;\n  while (b) (n += floor(a / b)), ([a, b] = [b, a % b]);\n  return n + \"-CROSSING \" + (p % 2 ? \"KNOT\" : \"LINK\");\n}\n\n// ---- 3 x 5 capitals from Typewriter (copied from autogram.js), 3 x 5\n// figures from Josephus (copied from josephus.js), and a slash and a\n// lemniscate drawn here.\nconst G35 = {\n  A: \"010101111101101\", C: \"011100100100011\", D: \"110101101101110\", E: \"111100110100111\", F: \"111100110100100\",\n  G: \"011100101101011\", H: \"101101111101101\", I: \"111010010010111\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\", Q: \"010101101111011\",\n  R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\", U: \"101101101101011\", V: \"101101101010010\",\n  W: \"101101111111101\", \"-\": \"000000111000000\", \"/\": \"001001010100100\",\n};\nconst FIG = [0b111101101101111, 0b010110010010111, 0b111001111100111, 0b111001111001111, 0b101101111001001, 0b111100111001111, 0b111100111101111, 0b111001001001001, 0b111101111101111, 0b111101111001111];\nconst LEMNI = \".#.#.\" + \"#.#.#\" + \".#.#.\";\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The dance: the calls that build it and Conway's calls that undo it,\n// each with the picture before it (from), the literal picture after it (L)\n// and the alternating one (C). Ropes are labelled from the caps down, so a\n// new picture can swap the labels; f says which label rope A has, chosen so\n// that each rope keeps its colour: an R carries the end in lane i to lane\n// i + 1, and while the ropes settle no end moves.\nfunction step(m, x, D, f) {\n  const nx = m === \"T\" ? twist(x) : turn(x), L = m === \"T\" ? litT(D) : litR(D), C = canon(nx[0], nx[1]);\n  const a = ropesAtFoot(D), b = ropesAtFoot(L), c = ropesAtFoot(C);\n  const fL = m === \"R\" ? b[1] ^ a[0] ^ f : f, fC = c[0] ^ b[0] ^ fL;\n  return { m, x: nx, L, C, from: D, f0: f, fL, fC };\n}\nfunction plan(depth) {\n  let best = null;\n  for (let tries = 0; tries \u003c 60; tries++) {\n    let x = [0, 1], D = canon(0, 1), last = \"\", peak = 0, f = 0;\n    const build = [];\n    for (let i = 0; i \u003c depth; i++) {\n      // A turn of [0] would give 1/0, where a twist changes nothing and only\n      // a second turn, undoing the first, could follow.\n      let m = Math.random() \u003c 0.65 ? \"T\" : \"R\";\n      if (x[0] === 0 || last === \"R\") m = \"T\";\n      const c = step(m, x, D, f);\n      build.push(c);\n      peak = max(peak, c.L.steps.length, c.C.steps.length);\n      (x = c.x), (D = c.C), (f = c.fC), (last = m);\n    }\n    const undo = [];\n    for (let k = 0; k \u003c 60 && !(x[0] === 0 && x[1] === 1); k++) {\n      const c = step(x[1] === 0 || x[0] > 0 ? \"R\" : \"T\", x, D, f);\n      undo.push(c);\n      peak = max(peak, c.L.steps.length, c.C.steps.length);\n      (x = c.x), (D = c.C), (f = c.fC);\n    }\n    const end = build[build.length - 1].x, turns = build.filter((c) => c.m === \"R\").length;\n    const good = abs(end[0]) >= 3 && turns >= 1 + floor((depth - 6) / 4) && peak \u003c= MAXC;\n    best = { build, undo, peak, end };\n    if (good) break;\n  }\n  return best;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, depth: 6, width: 3.1, btn: false, started: false,\n    acc: new Float32Array(W * H * 3), buf: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\nfunction newDance(S) {\n  const P = (S.plan = plan(S.depth));\n  S.h = cl(88 / max(3, P.peak), 6, 16);\n  S.calls = [...P.build.map((c) => ({ ...c, undo: false })), { close: true }, ...P.undo.map((c) => ({ ...c, undo: true }))];\n  S.k = -1;\n  S.pt = 0;\n  S.x = [0, 1];\n  S.D = canon(0, 1);\n  S.f = 0;\n  S.said = \"\";\n  S.undoSaid = \"\";\n  S.stage = \"rest0\";\n}\n\n// Stages: a call (move, then settle), the closing, the hold, the opening,\n// the rest at 0. The stage clock is in seconds at Speed 2.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const depth = round(cl(k[2] == null ? 6 : k[2], 6, 14)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  S.width = 3 * 2 ** cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  if (!S.started || depth !== S.depth || (btn && !S.btn)) {\n    S.depth = depth;\n    S.started = true;\n    newDance(S);\n  }\n  S.btn = btn;\n  S.pt += (d * S.speed) / 2;\n  for (let guard = 0; guard \u003c 4; guard++) {\n    const c = S.calls[S.k];\n    if (S.stage === \"rest0\") {\n      if (S.pt \u003c (S.k \u003c 0 ? 0.6 : T_REST)) break;\n      if (S.k >= 0) return void newDance(S);\n      next(S);\n    } else if (S.stage === \"move\") {\n      if (S.pt \u003c T_MOVE) break;\n      S.pt -= T_MOVE;\n      S.x = c.x;\n      S.D = c.L;\n      S.f = c.fL;\n      S.stage = same(c.L, c.C) ? \"pause\" : \"settle\";\n    } else if (S.stage === \"settle\") {\n      if (S.pt \u003c T_SETTLE) break;\n      S.pt -= T_SETTLE;\n      S.D = c.C;\n      S.f = c.fC;\n      S.stage = \"pause\";\n    } else if (S.stage === \"pause\") {\n      if (S.pt \u003c T_PAUSE) break;\n      S.pt -= T_PAUSE;\n      next(S);\n    } else if (S.stage === \"close\") {\n      if (S.pt \u003c T_CLOSE) break;\n      (S.pt -= T_CLOSE), (S.stage = \"hold\");\n    } else if (S.stage === \"hold\") {\n      if (S.pt \u003c T_HOLD) break;\n      (S.pt -= T_HOLD), (S.stage = \"open\");\n    } else if (S.stage === \"open\") {\n      if (S.pt \u003c T_CLOSE) break;\n      S.pt -= T_CLOSE;\n      next(S);\n    } else break;\n  }\n}\n\nfunction next(S) {\n  S.k++;\n  const c = S.calls[S.k];\n  if (!c) return void ((S.stage = \"rest0\"), (S.pt = 0));\n  if (c.close) return void (S.stage = \"close\");\n  S.stage = \"move\";\n  if (c.undo) S.undoSaid += c.m;\n  else S.said += c.m;\n}\n\n// ---- Drawing. Ropes are drawn row by row: in a crossing the two strands\n// follow x = mid -+ d cos(theta t) down its height, so a whole crossing is\n// a half turn of the pair, and a twist that is still under way is the same\n// picture with theta short of pi, its foot still turning.\n\nfunction putRope(acc, x, y, xc, hw, col, lv, cut) {\n  const off = x + 0.5 - xc, cov = cl(hw + 0.5 - abs(off), 0, 1) * lv * cut;\n  if (cov \u003c= 0) return;\n  // Round: darker towards the edges; laid: a slanting strand every 3 rows.\n  const u = off / max(hw, 0.6), lay = 0.82 + 0.18 * cos(2 * PI * ((y + 0.5) / 3.2 + 0.35 * u));\n  const v = (1 - 0.45 * u * u) * lay, k = (y * W + x) * 3;\n  for (let q = 0; q \u003c 3; q++) acc[k + q] = acc[k + q] * (1 - cov) + col[q] * v * cov;\n}\nfunction strandRow(acc, y, xc, slope, w, col, lv, mask) {\n  const hw = (w / 2) * sqrt(1 + slope * slope);\n  for (let x = max(0, floor(xc - hw - 1)); x \u003c= min(W - 1, floor(xc + hw + 1)); x++) {\n    let cut = 1;\n    if (mask) cut = cl(abs(x + 0.5 - mask[0]) - mask[1] - mask[2] + 0.5, 0, 1);\n    putRope(acc, x, y, xc, hw, col, lv, cut);\n  }\n}\n// A capsule chain for the caps and cups: a half ellipse about (cx, cy)\n// bulging up (dir -1) or down (dir +1), drawn from angle a0 to a1.\nfunction arc(acc, cx, cy, rx, ry, dir, a0, a1, w, colA, colB) {\n  if (a1 \u003c= a0) return;\n  const n = 20, px = [], py = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const th = a0 + ((a1 - a0) * i) / n;\n    px.push(cx - rx * cos(th));\n    py.push(cy + dir * ry * sin(th));\n  }\n  const hw = w / 2, x0 = max(0, floor(min(...px) - hw - 1)), x1 = min(W - 1, floor(max(...px) + hw + 1));\n  const y0 = max(0, floor(min(...py) - hw - 1)), y1 = min(H - 1, floor(max(...py) + hw + 1));\n  const col = [0, 0, 0];\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      let dm = 1e9, tm = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const ax = px[i], ay = py[i], bx = px[i + 1] - ax, by = py[i + 1] - ay, l2 = bx * bx + by * by || 1;\n        const t = cl(((x + 0.5 - ax) * bx + (y + 0.5 - ay) * by) / l2, 0, 1), dd = (x + 0.5 - ax - t * bx) ** 2 + (y + 0.5 - ay - t * by) ** 2;\n        if (dd \u003c dm) (dm = dd), (tm = (i + t) / n);\n      }\n      const dist = sqrt(dm), cov = cl(hw + 0.5 - dist, 0, 1);\n      if (cov \u003c= 0) continue;\n      const g = (a0 + (a1 - a0) * tm) / PI;\n      for (let q = 0; q \u003c 3; q++) col[q] = colA[q] + (colB[q] - colA[q]) * g;\n      const u = dist / max(hw, 0.6), v = (1 - 0.45 * u * u) * (0.82 + 0.18 * cos(2 * PI * (tm * 9 + 0.35 * u))), k = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) acc[k + q] = acc[k + q] * (1 - cov) + col[q] * v * cov;\n    }\n}\n\n// One picture into acc: D the diagram, dx its sideways shift,\n// tw the share of a half turn the last crossing has made (1 when done),\n// cup how far the foot has closed, cols the two ropes' colours by lane.\nfunction picture(S, acc, D, dx, tw, cup, cols) {\n  const w = S.width, h = S.h, n = D.steps.length, gap = 0.9 + 0.25 * w;\n  const lane = X.map((v) => v + dx);\n  const caps = D.caps;\n  // Caps.\n  if (caps === 0) {\n    arc(acc, (lane[0] + lane[1]) / 2, YS, 7, 9, -1, 0, PI, w, cols[0], cols[0]);\n    arc(acc, (lane[2] + lane[3]) / 2, YS, 7, 9, -1, 0, PI, w, cols[1], cols[1]);\n  } else {\n    arc(acc, (lane[0] + lane[3]) / 2, YS, 21, 11, -1, 0, PI, w, cols[1], cols[1]);\n    arc(acc, (lane[1] + lane[2]) / 2, YS, 7, 5.5, -1, 0, PI, w, cols[0], cols[0]);\n  }\n  // Rope per lane, going down.\n  const rope = caps ? [1, 0, 0, 1] : [0, 0, 1, 1];\n  let y0 = YS;\n  const xs = lane.slice();\n  for (let i = 0; i \u003c n; i++) {\n    const s = D.steps[i], last = i === n - 1, th = last ? PI * tw : PI, hh = last ? h * max(tw, 0.001) : h;\n    const p = s.p, mid = (xs[p] + xs[p + 1]) / 2, half = (xs[p + 1] - xs[p]) / 2;\n    const ya = floor(y0), yb = floor(y0 + hh);\n    for (let y = max(0, ya); y \u003c min(H, yb); y++) {\n      const t = cl((y + 0.5 - y0) / hh, 0, 1), c = cos(th * t), sn = sin(th * t), sl = (half * th * sn) / hh;\n      for (let L = 0; L \u003c 4; L++) if (L !== p && L !== p + 1) strandRow(acc, y, xs[L], 0, w, cols[rope[L]], 1, null);\n      const xl = mid - half * c, xr = mid + half * c, hwo = (w / 2) * sqrt(1 + sl * sl);\n      // The strand from the left lane is in front when o is +1.\n      const lf = s.o > 0;\n      const [xu, su, cu, xo, so, co] = lf ? [xr, -sl, cols[rope[p + 1]], xl, sl, cols[rope[p]]] : [xl, sl, cols[rope[p]], xr, -sl, cols[rope[p + 1]]];\n      const near = abs(xl - xr) \u003c 2 * hwo + 2 * gap + 2;\n      strandRow(acc, y, xu, su, w, cu, near ? 0.85 : 1, near ? [xo, hwo, gap] : null);\n      strandRow(acc, y, xo, so, w, co, 1, null);\n    }\n    // After the crossing the lanes carry each other's ropes, and an\n    // unfinished twist leaves its two ends partway round.\n    const ce = cos(th);\n    xs[p] = mid - half * ce;\n    xs[p + 1] = mid + half * ce;\n    if (th > PI / 2) [rope[p], rope[p + 1]] = [rope[p + 1], rope[p]];\n    if (th > PI / 2) [xs[p], xs[p + 1]] = [xs[p + 1], xs[p]];\n    y0 += hh;\n  }\n  // Below the crossings straight down to the foot, then the cups.\n  const yf = cup > 0 ? YE : H;\n  for (let y = max(0, floor(y0)); y \u003c min(H, yf); y++) for (let L = 0; L \u003c 4; L++) strandRow(acc, y, xs[L], 0, w, cols[rope[L]], 1, null);\n  if (cup > 0) {\n    const e = smooth(cup), ytail = YE + (H - YE) * (1 - e);\n    for (let y = YE; y \u003c min(H, ytail); y++) for (let L = 0; L \u003c 4; L++) strandRow(acc, y, xs[L], 0, w, cols[rope[L]], 1, null);\n    for (const [l0, l1] of [[0, 1], [2, 3]]) {\n      const cx = (xs[l0] + xs[l1]) / 2, rx = (xs[l1] - xs[l0]) / 2, ca = cols[rope[l0]], cb = cols[rope[l1]];\n      arc(acc, cx, YE, rx, 8, 1, 0, (PI / 2) * e, w, ca, cb);\n      arc(acc, cx, YE, rx, 8, 1, PI - (PI / 2) * e, PI, w, ca, cb);\n    }\n  }\n}\n\n// ---- Text.\nfunction glyph(acc, ch, x, y, col) {\n  let bits = null;\n  if (ch >= \"0\" && ch \u003c= \"9\") {\n    const f = FIG[ch.charCodeAt(0) - 48];\n    bits = [];\n    for (let i = 14; i >= 0; i--) bits.push((f >> i) & 1);\n  } else if (G35[ch]) bits = [...G35[ch]].map(Number);\n  if (ch === \"~\") {\n    for (let i = 0; i \u003c 15; i++) if (LEMNI[i] === \"#\") dotPx(acc, x + (i % 5), y + 1 + floor(i / 5), col);\n    return 5;\n  }\n  if (bits) for (let i = 0; i \u003c 15; i++) if (bits[i]) dotPx(acc, x + (i % 3), y + floor(i / 3), col);\n  return 3;\n}\nfunction dotPx(acc, x, y, col) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const k = (y * W + x) * 3;\n  for (let q = 0; q \u003c 3; q++) acc[k + q] = col[q];\n}\n// \"_\" before a figure lowers it three rows, \"^\" raises it two; a lowered\n// figure right after a raised one stands under it.\nfunction text(acc, str, cx, y, col) {\n  let wd = 0;\n  for (let i = 0; i \u003c str.length; i++) {\n    const ch = str[i];\n    if (ch === \"_\" || ch === \"^\") continue;\n    if (str[i - 1] === \"_\" && str[i - 3] === \"^\") continue;\n    wd += (ch === \"~\" ? 5 : 3) + 1;\n  }\n  let x = round(cx - (wd - 1) / 2);\n  for (let i = 0; i \u003c str.length; i++) {\n    const ch = str[i];\n    if (ch === \"_\" || ch === \"^\") continue;\n    const dy = str[i - 1] === \"_\" ? 3 : str[i - 1] === \"^\" ? -2 : 0;\n    if (str[i - 1] === \"_\" && str[i - 3] === \"^\") x -= 4;\n    x += (ch === \" \" ? 3 : glyph(acc, ch, x, y + dy, col)) + 1;\n  }\n}\nconst fracText = ([p, q]) => (q === 0 ? \"~\" : (p \u003c 0 ? \"-\" : \"\") + abs(p) + \"/\" + q);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.plan) return;\n  const acc = S.acc, buf = S.buf;\n  acc.fill(0);\n  const A = hsv(S.hue + 0.5, 0.85, 1), B = hsv(S.hue + 0.11, 0.85, 1);\n  const c = S.calls[S.k], AB = [A, B], BA = [B, A];\n  let cols = S.f ? BA : AB;\n  const stage = S.stage;\n  if (stage === \"close\" || stage === \"hold\" || stage === \"open\") {\n    // A knot is one loop: one rope takes the other's colour as the ends join.\n    const D = S.D, r = ropesAtFoot(D), knot = r[0] !== r[1];\n    const e = stage === \"close\" ? smooth(S.pt / T_CLOSE) : stage === \"hold\" ? 1 : 1 - smooth(S.pt / T_CLOSE);\n    if (knot) cols = [cols[0], cols[1].map((v, i) => v + (cols[0][i] - v) * e)];\n    picture(S, acc, D, 0, 1, e, cols);\n  } else if (stage === \"move\" && c && c.m === \"T\") {\n    // A twist: the literal picture after it, its last crossing turning in,\n    // or the picture before it with its last crossing turning out.\n    const u = smooth(S.pt / T_MOVE);\n    cols = c.fL ? BA : AB;\n    if (c.L.steps.length > c.from.steps.length) picture(S, acc, c.L, 0, u, 0, cols);\n    else picture(S, acc, c.from, 0, 1 - u, 0, cols);\n  } else if (stage === \"move\" && c && c.m === \"R\") {\n    // A rotation: every end steps one lane round; the old picture slides\n    // off to the right as the new one comes in from the left.\n    const u = smooth(S.pt / T_MOVE);\n    picture(S, acc, c.from, 14 * u, 1, 0, c.f0 ? BA : AB);\n    buf.fill(0);\n    picture(S, buf, c.L, -14 * (1 - u), 1, 0, c.fL ? BA : AB);\n    for (let i = 0; i \u003c acc.length; i++) acc[i] += (buf[i] - acc[i]) * u;\n  } else if (stage === \"settle\") {\n    const u = smooth(S.pt / T_SETTLE);\n    picture(S, acc, c.L, 0, 1, 0, c.fL ? BA : AB);\n    buf.fill(0);\n    picture(S, buf, c.C, 0, 1, 0, c.fC ? BA : AB);\n    for (let i = 0; i \u003c acc.length; i++) acc[i] += (buf[i] - acc[i]) * u;\n  } else picture(S, acc, S.D, 0, 1, 0, cols);\n  // The fraction on the first line; the calls, or the name, on the second.\n  const white = [0.92, 0.92, 0.88];\n  const fx = stage === \"move\" ? (S.pt / T_MOVE > 0.5 ? c.x : S.x) : S.x;\n  text(acc, fracText(fx), 32, 1, white);\n  if (stage === \"close\" || stage === \"hold\" || stage === \"open\") {\n    const e = stage === \"close\" ? S.pt / T_CLOSE : stage === \"open\" ? 1 - S.pt / T_CLOSE : 1;\n    if (e > 0.5) text(acc, nameOf(S.x), 32, 8, [1, 0.85, 0.55]);\n  } else {\n    const said = S.undoSaid ? S.undoSaid.slice(-15) : S.said;\n    text(acc, said, 32, 8, S.undoSaid ? A.map((v) => 0.35 + 0.6 * v) : [0.75, 0.75, 0.75]);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(acc[k], 0, 1) * 255), round(cl(acc[k + 1], 0, 1) * 255), round(cl(acc[k + 2], 0, 1) * 255));\n    }\n}\n","reed-solomon":"// ===== Patternflow pattern =====\n// Title:   Reed-Solomon\n// Family:  data\n// Idea:    A word becomes a real version 1 QR code, 21 modules of 3 LEDs, its codewords standing above as columns of bits, data and error correction in two colours, the bits snaking into the symbol from the bottom right and the mask swept over them; then a scratch, a blot or a bite spoils part of it, the decoder lights the syndromes and finds the bad codewords by Berlekamp-Massey, Chien search and Forney's formula, and if they are at most half the error correction codewords the spoiled modules flash back, otherwise the count turns red.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Reed-Solomon codes (Irving S. Reed and Gustave Solomon, 1960) in a version 1 QR code (Masahiro Hara, Denso Wave, 1994), decoded with the Berlekamp-Massey algorithm (Elwyn Berlekamp, 1968; James Massey, 1969), Chien search (Robert Chien, 1964) and Forney's formula (G. David Forney, 1965), pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Damage=8..60, Data=9..19\n//\n// Knob 1: Hue. Turns data, error correction and damage round the wheel together, a quarter turn or more apart: cyan, violet and red at 0; red, yellow-green and cyan-blue at 0.5. Finders stay warm white, format bits pale gold.\n// Knob 2: Speed. At 2 a word takes 10.9 s: set and computed 1.2 s, placed 1.8 s, masked 0.6 s, held 0.6 s, spoiled 0.5 s, read 0.7 s, errors found 0.8 s, repaired 1 s, held 3.2 s, cleared 0.5 s. The first word opens with its bits placed, just before the mask. At 0.2 each step takes ten times as long, at 3 two thirds.\n// Knob 3: Damage. The spoiled area, 8 to 60 square modules, times a random 0.7 to 1.5 a word. A blot makes modules dark, a bite out of an edge and a scratch 1.2 modules wide make them light. At 8 a hurt mostly spoils 0 to 4 codewords and H, Q and M mend 996 in 1000. At 60 a blot 4.4 modules in radius spoils 2 to 11: H mends 74 percent, M 47, L 19. A scratch spoils only 2 to 7, crossing codewords 2 modules wide.\n// Knob 4: Data. How many of the 26 codewords carry the word, and so the level: 9 is H (17 error correction codewords, mends 8), 13 is Q (13, mends 6), 16 is M (10, mends 5), 19 is L (7, mends 3). A syndrome cell for each error correction codeword, a budget slot for each one it mends. A new level rebuilds the symbol at once.\n// Buttons: K1 tap spoils the finished symbol again with the next hurt.\n\n// A version 1 QR code holds 26 codewords of 8 bits. The first k carry the\n// word in alphanumeric mode, padded with 236 and 17; the other n = 26 - k are\n// the remainder of that polynomial times x^n divided by\n// g(x) = (x - a^0)...(x - a^(n-1)) over GF(256), a = 2, built on 0x11D. So\n// what is read, taken at a^0 ... a^(n-1), gives n syndromes that are all zero\n// unless something changed. From them Berlekamp-Massey finds the shortest\n// error locator, Chien search tries every position for its roots and\n// Forney's formula gives the value to XOR back: up to n / 2 codewords. The\n// QR standard trusts fewer at version 1 (2, 4, 6, 8 for L, M, Q, H) and\n// keeps the rest against misreading; their budget slots are dimmer.\n//\n// The decoder reads the symbol as a scanner does once it has found it: the\n// two copies of the 15 format bits, the nearest valid one (within 3 bits),\n// the mask it names, then the 208 data modules in zig-zag order.\n\nconst W = 64, H = 128, N = 21, SX = 1, SY = 38, CY = 11, TY = 1;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- GF(256) on 0x11D, a = 2.\nconst EXP = new Uint8Array(512), LOG = new Uint8Array(256);\nfor (let i = 0, x = 1; i \u003c 255; i++) {\n  EXP[i] = EXP[i + 255] = x;\n  LOG[x] = i;\n  x \u003c\u003c= 1;\n  if (x & 256) x ^= 0x11d;\n}\nconst mul = (a, b) => (a && b ? EXP[LOG[a] + LOG[b]] : 0);\nconst div = (a, b) => (a ? EXP[LOG[a] + 255 - LOG[b]] : 0);\n\n// Remainder of data(x) x^n mod g(x), highest power first.\nfunction rsRemainder(data, n) {\n  let g = [1];\n  for (let i = 0; i \u003c n; i++) {\n    const h = new Array(g.length + 1).fill(0);\n    for (let j = 0; j \u003c g.length; j++) (h[j] ^= g[j]), (h[j + 1] ^= mul(g[j], EXP[i]));\n    g = h;\n  }\n  const rem = new Array(n).fill(0);\n  for (const d of data) {\n    const f = d ^ rem.shift();\n    rem.push(0);\n    for (let i = 0; i \u003c n; i++) rem[i] ^= mul(g[i + 1], f);\n  }\n  return rem;\n}\n// The received polynomial at a^0 ... a^(n-1).\nconst syndromes = (cw, n) => Array.from({ length: n }, (_, j) => cw.reduce((v, c) => mul(v, EXP[j]) ^ c, 0));\n// Berlekamp-Massey: the shortest LFSR (error locator, lowest power first)\n// that generates the syndromes.\nfunction berlekamp(S) {\n  let C = [1], B = [1], L = 0, m = 1, b = 1;\n  for (let k = 0; k \u003c S.length; k++) {\n    let d = S[k];\n    for (let i = 1; i \u003c= L; i++) d ^= mul(C[i] || 0, S[k - i]);\n    if (!d) { m++; continue; }\n    const T = C.slice(), coef = div(d, b);\n    for (let i = 0; i \u003c B.length; i++) C[i + m] = (C[i + m] || 0) ^ mul(coef, B[i]);\n    if (2 * L \u003c= k) (L = k + 1 - L), (B = T), (b = d), (m = 1);\n    else m++;\n  }\n  return { C, L };\n}\n// Codeword i is the coefficient of x^(25 - i). Returns the syndromes, the\n// codewords found wrong, the mended codewords and whether it worked.\nfunction rsDecode(cw, n) {\n  const S = syndromes(cw, n), out = { S, errs: [], fixed: cw.slice(), ok: true };\n  if (S.every((v) => !v)) return out;\n  const { C, L } = berlekamp(S);\n  out.ok = false;\n  if (L > n >> 1) return out;\n  // Chien search: position p is wrong where the locator vanishes at a^-p.\n  const ps = [];\n  for (let p = 0; p \u003c 26; p++) {\n    let v = 0;\n    for (let i = 0; i \u003c C.length; i++) v ^= mul(C[i], EXP[(255 - ((p * i) % 255)) % 255]);\n    if (!v) ps.push(p);\n  }\n  out.errs = ps.map((p) => 25 - p);\n  if (ps.length !== L) return out;\n  // Forney: e = X Omega(1/X) / Lambda'(1/X), Omega = S Lambda mod x^n.\n  const Om = new Array(n).fill(0);\n  for (let i = 0; i \u003c n; i++) for (let j = 0; j \u003c= i && j \u003c C.length; j++) Om[i] ^= mul(C[j], S[i - j]);\n  for (const p of ps) {\n    const xi = EXP[(255 - p) % 255];\n    let om = 0, dl = 0;\n    for (let i = n - 1; i >= 0; i--) om = mul(om, xi) ^ Om[i];\n    for (let i = 1; i \u003c C.length; i += 2) dl ^= mul(C[i], EXP[(LOG[xi] * (i - 1)) % 255]);\n    if (!dl) return out;\n    out.fixed[25 - p] ^= mul(EXP[p], div(om, dl));\n  }\n  out.ok = syndromes(out.fixed, n).every((v) => !v);\n  return out;\n}\n\n// ---- The message, in alphanumeric mode.\nconst ALNUM = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:\";\nconst WORDS = [\"REED\", \"SOLOMON\", \"GALOIS\", \"SYNDROME\", \"LIGHT\", \"KNOB\", \"PATTERN\", \"ERASURE\"];\nfunction encode(word, k) {\n  const bits = [], put = (v, n) => { for (let i = n - 1; i >= 0; i--) bits.push((v >> i) & 1); };\n  put(2, 4);\n  put(word.length, 9);\n  for (let i = 0; i + 1 \u003c word.length; i += 2) put(45 * ALNUM.indexOf(word[i]) + ALNUM.indexOf(word[i + 1]), 11);\n  if (word.length % 2) put(ALNUM.indexOf(word[word.length - 1]), 6);\n  for (let i = 0; i \u003c 4 && bits.length \u003c 8 * k; i++) bits.push(0);\n  while (bits.length % 8) bits.push(0);\n  const out = [];\n  for (let i = 0; i \u003c bits.length; i += 8) out.push(bits.slice(i, i + 8).reduce((a, b) => (a \u003c\u003c 1) | b, 0));\n  for (let pad = 0xec; out.length \u003c k; pad ^= 0xec ^ 0x11) out.push(pad);\n  return out;\n}\n// What the data codewords say, read leniently: a wrong mode or length\n// gives question marks, a pair past 44 x 45 + 44 two of them.\nfunction parse(cw, k, len) {\n  let pos = 0;\n  const take = (n) => {\n    let v = 0;\n    for (let i = 0; i \u003c n; i++, pos++) v = (v \u003c\u003c 1) | (pos \u003c 8 * k ? (cw[pos >> 3] >> (7 - (pos & 7))) & 1 : 0);\n    return v;\n  };\n  const mode = take(4), count = take(9);\n  if (mode !== 2 || count > 25) return \"?\".repeat(len);\n  let s = \"\";\n  for (let i = 0; i \u003c count && pos \u003c 8 * k; i += 2) {\n    if (i + 1 === count) s += ALNUM[take(6)] || \"?\";\n    else {\n      const v = take(11);\n      s += v \u003c 2025 ? ALNUM[floor(v / 45)] + ALNUM[v % 45] : \"??\";\n    }\n  }\n  return s;\n}\n\n// ---- The symbol. Levels in the order of the Data knob, with the two bits\n// the format info gives each.\nconst LEVELS = [{ k: 9, bits: 2 }, { k: 13, bits: 3 }, { k: 16, bits: 0 }, { k: 19, bits: 1 }];\nconst STD = [8, 6, 4, 2];\nconst FN = new Uint8Array(N * N), BASE = new Uint8Array(N * N);\nconst setF = (x, y, v) => ((FN[y * N + x] = 1), (BASE[y * N + x] = v));\nfor (let i = 0; i \u003c N; i++) setF(6, i, +(i % 2 === 0)), setF(i, 6, +(i % 2 === 0));\nfor (const [cx, cy] of [[3, 3], [N - 4, 3], [3, N - 4]])\n  for (let dy = -4; dy \u003c= 4; dy++)\n    for (let dx = -4; dx \u003c= 4; dx++) {\n      const x = cx + dx, y = cy + dy, d = max(abs(dx), abs(dy));\n      if (x >= 0 && x \u003c N && y >= 0 && y \u003c N) setF(x, y, +(d !== 2 && d !== 4));\n    }\n// The 15 format bits, bit i at FMT[0][i] beside the top left finder and\n// again at FMT[1][i] split under the top right and beside the bottom left.\nconst FMT = [[], []];\nfor (let i = 0; i \u003c= 5; i++) FMT[0].push([8, i]);\nFMT[0].push([8, 7], [8, 8], [7, 8]);\nfor (let i = 9; i \u003c 15; i++) FMT[0].push([14 - i, 8]);\nfor (let i = 0; i \u003c 8; i++) FMT[1].push([N - 1 - i, 8]);\nfor (let i = 8; i \u003c 15; i++) FMT[1].push([8, N - 15 + i]);\nconst ISFMT = new Uint8Array(N * N);\nfor (const [x, y] of [...FMT[0], ...FMT[1]]) setF(x, y, 0), (ISFMT[y * N + x] = 1);\nsetF(8, N - 8, 1);\nfunction formatBits(level, mask) {\n  const data = (LEVELS[level].bits \u003c\u003c 3) | mask;\n  let rem = data;\n  for (let i = 0; i \u003c 10; i++) rem = (rem \u003c\u003c 1) ^ ((rem >> 9) * 0x537);\n  return ((data \u003c\u003c 10) | rem) ^ 0x5412;\n}\n// The data modules in placement order: two-module columns from the right,\n// up then down, skipping the timing column.\nconst ORDER = [];\nfor (let right = N - 1; right >= 1; right -= 2) {\n  if (right === 6) right = 5;\n  for (let vert = 0; vert \u003c N; vert++)\n    for (let j = 0; j \u003c 2; j++) {\n      const x = right - j, y = ((right + 1) & 2) === 0 ? N - 1 - vert : vert;\n      if (!FN[y * N + x]) ORDER.push(y * N + x);\n    }\n}\n// Which bit of the 208 each module carries (-1 for function modules).\nconst BITOF = new Int16Array(N * N).fill(-1);\nORDER.forEach((p, i) => (BITOF[p] = i));\n// The eight masks: a module flips where its expression is 0.\nfunction maskAt(m, p) {\n  const x = p % N, y = floor(p / N), a = (x * y) % 2, b = (x * y) % 3;\n  return +([(x + y) % 2, y % 2, x % 3, (x + y) % 3, (floor(x / 3) + floor(y / 2)) % 2, a + b, (a + b) % 2, (((x + y) % 2) + b) % 2][m] === 0);\n}\n\nfunction compose(cw, level, m) {\n  const mat = BASE.slice(), f = formatBits(level, m);\n  ORDER.forEach((p, i) => (mat[p] = ((cw[i >> 3] >> (7 - (i & 7))) & 1) ^ maskAt(m, p)));\n  for (let i = 0; i \u003c 15; i++) for (const c of FMT) mat[c[i][1] * N + c[i][0]] = (f >> i) & 1;\n  return mat;\n}\n// The standard's four penalties: runs of five or more, 2x2 blocks, finder\n// look-alikes with four light modules on a side, and imbalance of dark.\nfunction penalty(mat) {\n  let p = 0, dark = 0;\n  for (let pass = 0; pass \u003c 2; pass++)\n    for (let a = 0; a \u003c N; a++) {\n      const at = (b) => (b \u003c 0 || b >= N ? 0 : pass ? mat[b * N + a] : mat[a * N + b]);\n      let run = 1;\n      for (let b = 1; b \u003c= N; b++) {\n        if (b \u003c N && at(b) === at(b - 1)) run++;\n        else (p += run >= 5 ? run - 2 : 0), (run = 1);\n      }\n      // Runs of exactly 1, 1, 3, 1, 1; off the symbol counts as light.\n      for (let b = 0; b + 6 \u003c N; b++)\n        if (!at(b - 1) && at(b) && !at(b + 1) && at(b + 2) && at(b + 3) && at(b + 4) && !at(b + 5) && at(b + 6) && !at(b + 7)) {\n          if (!at(b - 2) && !at(b - 3) && !at(b - 4)) p += 40;\n          if (!at(b + 8) && !at(b + 9) && !at(b + 10)) p += 40;\n        }\n    }\n  for (let y = 0; y \u003c N; y++)\n    for (let x = 0; x \u003c N; x++) {\n      const v = mat[y * N + x];\n      dark += v;\n      if (x \u003c N - 1 && y \u003c N - 1 && v === mat[y * N + x + 1] && v === mat[(y + 1) * N + x] && v === mat[(y + 1) * N + x + 1]) p += 3;\n    }\n  return p + 10 * (Math.ceil(abs(dark * 20 - N * N * 10) / (N * N)) - 1);\n}\nfunction build(word, level) {\n  const k = LEVELS[level].k, data = encode(word, k), cw = data.concat(rsRemainder(data, 26 - k));\n  let best = 0, bp = 1e9;\n  for (let m = 0; m \u003c 8; m++) {\n    const p = penalty(compose(cw, level, m));\n    if (p \u003c bp) (bp = p), (best = m);\n  }\n  return { word, level, k, n: 26 - k, cw, mask: best, mat: compose(cw, level, best) };\n}\n// Read a symbol as a scanner does once it has found it.\nfunction readSymbol(mat) {\n  let f = null, fd = 99;\n  for (const c of FMT) {\n    let v = 0;\n    for (let i = 0; i \u003c 15; i++) v |= mat[c[i][1] * N + c[i][0]] \u003c\u003c i;\n    for (let g = 0; g \u003c 32; g++) {\n      let d = 0;\n      for (let x = v ^ formatBits(g >> 3, g & 7); x; x &= x - 1) d++;\n      if (d \u003c fd) (fd = d), (f = { l: g >> 3, m: g & 7 });\n    }\n  }\n  if (fd > 3) return null;\n  const cw = new Array(26).fill(0);\n  ORDER.forEach((p, i) => (cw[i >> 3] |= (mat[p] ^ maskAt(f.m, p)) \u003c\u003c (7 - (i & 7))));\n  return { level: f.l, mask: f.m, cw };\n}\n\n// ---- 5x7 capitals, digits and the alphanumeric mode's signs, drawn for\n// this pattern: seven base-32 digits a glyph, rows from the top, 16 the left\n// column.\nconst FONT_CH = ALNUM + \"?\";\nconst FONT =\n  \"ehjlphe4c4444eeh1248vv2421he26aiv22vgu11he68guhhev124888ehhehheehhf12cehhvhhhuhhuhhu\" +\n  \"ehggghesihhhisvgguggvvggugggehgnhhfhhhvhhhe44444e72222ichikokihggggggvhrllhhhhhpljhh\" +\n  \"ehhhhheuhhugggehhhliduhhukihfgge11uv444444hhhhhhehhhhha4hhhlllahha4ahhhhha444v1248gv\" +\n  \"00000004fke5u4op248j304lel40044v440000v00000000cc01248g00cc0cc0eh12404\";\n\n// ---- Layout, top to bottom: the word, marks over the codewords found\n// wrong, the codeword columns, the symbol, the syndromes, the budget of\n// codewords the level mends, the count.\nconst MARK_Y = 9, SYN_Y = 105, SLOT_Y = 112, CNT_Y = 118;\nconst colX = (i, k) => 5 + 2 * i + (i >= k ? 3 : 0);\nconst PHASES = [\"write\", \"place\", \"mask\", \"hold0\", \"damage\", \"synd\", \"locate\", \"repair\", \"hold\", \"clear\"];\nconst DUR = [1.2, 1.8, 0.6, 0.6, 0.5, 0.7, 0.8, 1.0, 3.2, 0.5];\nconst FUNC = [235, 212, 175], FMTC = [255, 238, 150];\n\n// ---- Hurts, in modules: a scratch 1.2 wide and at most 30 long through\n// the middle, a blot with a wobbling rim, a bite centred just off an edge.\nfunction newHurt(s) {\n  const kind = s.kinds++ % 3, A = s.area * (0.7 + 0.8 * Math.random()), R = Math.random;\n  if (kind === 0) {\n    const len = min(A / 1.2, 30), th = R() * PI, cx = 6 + 9 * R(), cy = 6 + 9 * R(), dx = (cos(th) * len) / 2, dy = (sin(th) * len) / 2;\n    return { kind, ax: cx - dx, ay: cy - dy, bx: cx + dx, by: cy + dy, dark: 0 };\n  }\n  if (kind === 1) return { kind, cx: 3 + 15 * R(), cy: 3 + 15 * R(), r: sqrt(A / PI), ph: R() * 7, dark: 1 };\n  const u = 4 + 13 * R(), side = floor(R() * 4);\n  const [cx, cy] = [[u, -0.3], [N + 0.3, u], [u, N + 0.3], [-0.3, u]][side];\n  return { kind, cx, cy, r: sqrt((2 * A) / PI), ph: R() * 7, dark: 0 };\n}\nfunction inHurt(h, u, v, g) {\n  if (!h || g \u003c= 0) return false;\n  if (h.kind === 0) {\n    const bx = (h.bx - h.ax) * g, by = (h.by - h.ay) * g;\n    const t = cl(((u - h.ax) * bx + (v - h.ay) * by) / (bx * bx + by * by + 1e-9), 0, 1);\n    return hypot(u - h.ax - t * bx, v - h.ay - t * by) \u003c= 0.6;\n  }\n  const dx = u - h.cx, dy = v - h.cy, a = atan2(dy, dx);\n  const rim = h.kind === 1 ? 1 + 0.06 * sin(2 * a + 3 * h.ph) + 0.07 * sin(5 * a + h.ph) + 0.05 * sin(8 * a + 2 * h.ph) : 0.9 + 0.14 * abs(sin(5 * a + h.ph));\n  return hypot(dx, dy) \u003c= h.r * rim * g;\n}\n// The symbol with the hurt grown to g, and the codewords read from it with\n// the true mask, for the columns, the word and the count.\nfunction spoil(s, g) {\n  const sym = s.sym;\n  for (let p = 0; p \u003c N * N; p++) s.dmg[p] = inHurt(s.hurt, (p % N) + 0.5, floor(p / N) + 0.5, g) ? s.hurt.dark : sym.mat[p];\n  s.seen.fill(0);\n  ORDER.forEach((p, i) => (s.seen[i >> 3] |= (s.dmg[p] ^ maskAt(sym.mask, p)) \u003c\u003c (7 - (i & 7))));\n  s.hit = s.seen.reduce((a, v, i) => a + (v !== sym.cw[i]), 0);\n}\n\nfunction newWord(s, level, phase) {\n  const sym = build(WORDS[s.wi % WORDS.length], level);\n  Object.assign(s, { sym, dmg: sym.mat.slice(), seen: sym.cw.slice(), hurt: null, dec: null, hit: 0, ph: PHASES.indexOf(phase), pt: 0 });\n}\n\nexport function setup(params) {\n  params.s = { wi: 0, kinds: 1, area: 8, hue: 0, sc: 1, level: -1, btn: false, rgb: new Float32Array(W * H * 3) };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 8, 9], d = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  s.sc = 2 / cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  s.area = cl(k[2] == null ? 8 : k[2], 8, 60);\n  // Data 9, 13, 16, 19: the nearest level.\n  const data = cl(k[3] == null ? 9 : k[3], 9, 19);\n  let level = 0;\n  LEVELS.forEach((L, i) => abs(L.k - data) \u003c abs(LEVELS[level].k - data) && (level = i));\n  // The first word, and a new level, start with the bits in place and the\n  // mask about to be swept over them.\n  if (level !== s.level) (s.level = level), newWord(s, level, \"mask\");\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !s.btn && s.ph >= 3) Object.assign(s, { dmg: s.sym.mat.slice(), seen: s.sym.cw.slice(), dec: null, ph: 4, pt: 0, hurt: newHurt(s) });\n  s.btn = btn;\n  s.pt += d;\n  while (s.pt >= DUR[s.ph] * s.sc) {\n    s.pt -= DUR[s.ph] * s.sc;\n    if (++s.ph === PHASES.length) {\n      s.wi++;\n      newWord(s, s.level, \"write\");\n    }\n    const ph = PHASES[s.ph];\n    if (ph === \"damage\") s.hurt = newHurt(s);\n    if (ph === \"synd\") {\n      spoil(s, 1);\n      // The decoder reads the spoiled symbol on its own.\n      const r = readSymbol(s.dmg);\n      if (!r) s.dec = { fmt: false, ok: false, good: false, S: [], errs: [] };\n      else {\n        const dec = rsDecode(r.cw, 26 - LEVELS[r.level].k);\n        dec.fmt = true;\n        dec.good = dec.ok && r.level === s.sym.level && dec.fixed.every((v, i) => v === s.sym.cw[i]);\n        s.dec = dec;\n      }\n    }\n  }\n  if (PHASES[s.ph] === \"damage\") spoil(s, ease(s.pt / (DUR[s.ph] * s.sc)));\n}\n\nfunction put(rgb, x, y, c) {\n  const o = (y * W + x) * 3;\n  if (x >= 0 && x \u003c W) (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n}\nfunction glyph(rgb, ch, x0, y0, col) {\n  const g = FONT_CH.indexOf(ch);\n  for (let r = 0; r \u003c 7 && g >= 0; r++) for (let c = 0; c \u003c 5; c++) if ((parseInt(FONT[g * 7 + r], 32) >> (4 - c)) & 1) put(rgb, x0 + c, y0 + r, col);\n}\nfunction fill(rgb, x0, y0, w, h, col) {\n  for (let y = y0; y \u003c y0 + h; y++) for (let x = x0; x \u003c x0 + w; x++) put(rgb, x, y, col);\n}\nconst sc3 = (c, f) => [c[0] * f, c[1] * f, c[2] * f];\nconst mix = (a, b, f) => [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f, a[2] + (b[2] - a[2]) * f];\n\nexport function draw(display, params, time) {\n  const s = params.s;\n  if (!s || !s.sym) return;\n  const rgb = s.rgb, sym = s.sym, K = sym.k, n = sym.n, t = n >> 1;\n  const u = s.pt / (DUR[s.ph] * s.sc), at = s.ph, T = time || 0;\n  // Data, error correction and damage stay a quarter of the wheel or more\n  // apart whatever the hue: cyan, violet and red at 0.\n  const DATA = hsv(0.5 + s.hue, 0.75, 255), ECC = hsv(0.75 + s.hue, 0.6, 255), RED = hsv(0.02 + s.hue, 0.88, 255), WHITE = [255, 255, 255];\n  const good = s.dec && s.dec.good, fail = s.dec && !s.dec.good && at >= 6;\n  rgb.fill(0);\n\n  // The word: typed in while it is encoded, then read from what the\n  // codewords say, red where that is wrong.\n  const word = sym.word;\n  let shown = word;\n  if (at >= 4 && !(at >= 7 && good && (at > 7 || u > 0.5))) shown = parse(s.seen, K, word.length).slice(0, 10);\n  const tx = round((W - (6 * shown.length - 1)) / 2);\n  for (let i = 0; i \u003c shown.length; i++) {\n    if (at === 0 && u \u003c ((i + 1) / word.length) * 0.33) break;\n    // Once the decoder gives up, none of it can be trusted.\n    glyph(rgb, shown[i], tx + 6 * i, TY, shown[i] === word[i] && !fail ? [235, 235, 225] : RED);\n  }\n\n  // The codeword columns, 8 bits each, data then error correction.\n  const flashFix = at === 7 && good ? exp(-(((u - 0.45) / 0.15) ** 2)) : 0;\n  for (let i = 0; i \u003c 26; i++) {\n    if (at === 0 && u \u003c (i \u003c K ? 0.33 + (0.34 * i) / K : 0.67 + (0.33 * (i - K)) / n)) continue;\n    const x = colX(i, K), base = i \u003c K ? DATA : ECC;\n    const v = at >= 4 && !(at >= 7 && good && u > 0.45) && !(at > 7 && good) ? s.seen[i] : sym.cw[i];\n    for (let b = 0; b \u003c 8; b++) {\n      const bit = (v >> (7 - b)) & 1, wrong = bit !== ((sym.cw[i] >> (7 - b)) & 1);\n      let col = wrong ? sc3(RED, bit ? 1 : 0.3) : sc3(base, bit ? 1 : 0.16);\n      if (at === 1) {\n        const head = (u * 208) | 0, idx = i * 8 + b;\n        if (idx \u003c head && idx > head - 6) col = mix(col, WHITE, 1 - (head - idx) / 6);\n      }\n      if (flashFix && ((s.seen[i] ^ sym.cw[i]) >> (7 - b)) & 1) col = mix(col, WHITE, flashFix);\n      fill(rgb, x, CY + 3 * b, 1, 2, col);\n    }\n  }\n  // Marks over the codewords the decoder finds.\n  if (s.dec && at >= 6 && at \u003c= 8) {\n    const errs = s.dec.errs;\n    errs.forEach((i, j) => {\n      if (at === 6 && u \u003c (j + 1) / (errs.length + 1)) return;\n      fill(rgb, colX(i, K), MARK_Y, 1, 1, fail ? RED : [255, 210, 60]);\n    });\n  }\n\n  // The symbol, 3 LEDs to a module.\n  const fade = at === 9 ? 1 - u : 1, fnIn = at === 0 ? 0 : at === 1 ? cl(u * 5, 0, 1) : 1;\n  const hurtG = at === 4 ? ease(u) : at >= 5 ? 1 : 0;\n  const heal = good ? (at === 7 ? ease((u - 0.2) / 0.5) : at > 7 ? 1 : 0) : 0;\n  const pulse = fail ? 0.75 + 0.25 * sin(T * 6) : 1;\n  for (let my = 0; my \u003c N; my++)\n    for (let mx = 0; mx \u003c N; mx++) {\n      const p = my * N + mx, bi = BITOF[p], isF = FN[p];\n      let v = sym.mat[p], col;\n      if (isF) {\n        if (fnIn \u003c= 0) continue;\n        const fmt = ISFMT[p];\n        // The format bits arrive with the mask they name.\n        if (fmt && at \u003c 2) continue;\n        if (fmt && at === 2 && mx + my > u * 42) continue;\n        col = sc3(fmt ? FMTC : FUNC, fnIn);\n      } else {\n        const ci = bi >> 3;\n        col = ci \u003c K ? DATA : ECC;\n        if (at === 0) continue;\n        if (at === 1) {\n          const head = (u * 208) | 0;\n          if (bi >= head) continue;\n          v = (sym.cw[ci] >> (7 - (bi & 7))) & 1;\n          if (bi > head - 6) col = mix(col, WHITE, 1 - (head - bi) / 6), (v = 1);\n        } else if (at === 2) {\n          const front = u * 42 - (mx + my);\n          if (front \u003c 0) v = (sym.cw[ci] >> (7 - (bi & 7))) & 1;\n          else if (maskAt(sym.mask, p) && front \u003c 3) col = mix(col, WHITE, 1 - front / 3), (v = 1);\n        }\n      }\n      if (!v) col = [0, 0, 0];\n      const wrongMod = !isF && s.dmg[p] !== sym.mat[p];\n      for (let dy = 0; dy \u003c 3; dy++)\n        for (let dx = 0; dx \u003c 3; dx++) {\n          const x = SX + 3 * mx + dx, y = SY + 3 * my + dy;\n          let c = col;\n          if (hurtG > 0 && inHurt(s.hurt, (x - SX + 0.5) / 3, (y - SY + 0.5) / 3, hurtG)) {\n            const hc = sc3(RED, (s.hurt.dark ? 1 : 0.38) * pulse);\n            c = mix(hc, col, heal);\n          }\n          put(rgb, x, y, wrongMod && flashFix ? mix(c, WHITE, flashFix) : c);\n        }\n    }\n\n  // Syndromes: one cell each, dark when zero.\n  const cw = min(7, floor(62 / n)), sx = round((W - cw * n + 1) / 2);\n  for (let j = 0; j \u003c n; j++) {\n    let col = [26, 26, 32];\n    const S = s.dec && s.dec.fmt ? s.dec.S[j] || 0 : 0;\n    const on = s.dec && at >= 5 && at \u003c= 8 && !(at === 5 && u \u003c j / n) && !(good && (at > 7 || (at === 7 && u > 0.35 + (0.5 * j) / n)));\n    if (on && s.dec.fmt && S) col = hsv(S / 255, 0.55, 255);\n    else if (on && !s.dec.fmt) col = sc3(RED, 0.4 + 0.3 * sin(T * 6));\n    fill(rgb, sx + cw * j, SYN_Y, cw - 1, 4, col);\n  }\n  // The budget: one slot for each codeword the code can mend; the slots\n  // the standard holds back against misreading are dimmer.\n  const sw = t > 6 ? 5 : 7, bx = round((W - (sw + 2) * t + 2) / 2), found = s.dec ? s.dec.errs.length : 0;\n  for (let j = 0; j \u003c t; j++) {\n    let col = j \u003c STD[sym.level] ? [44, 44, 52] : [34, 16, 40];\n    if (s.dec && at >= 6 && at \u003c= 8) {\n      if (fail) col = sc3(RED, pulse);\n      else if (j \u003c found && !(at === 6 && u \u003c (j + 1) / (found + 1))) col = [255, 210, 60];\n    }\n    fill(rgb, bx + (sw + 2) * j, SLOT_Y, sw, 3, col);\n  }\n  // The count: codewords spoiled over codewords the code can mend.\n  const cnt = `${at >= 4 && at \u003c= 8 ? s.hit : 0}/${t}`, cx = round((W - (6 * cnt.length - 1)) / 2);\n  const ccol = at \u003c 4 || at > 8 || !s.hit ? [120, 120, 120] : s.hit > t || fail ? RED : good && at >= 7 ? [120, 255, 140] : [235, 235, 225];\n  for (let i = 0; i \u003c cnt.length; i++) glyph(rgb, cnt[i], cx + 6 * i, CNT_Y, ccol);\n\n  for (let i = 0; i \u003c W * H; i++) {\n    const j = i * 3;\n    display.setPixel(i % W, (i / W) | 0, round(cl(rgb[j] * fade, 0, 255)), round(cl(rgb[j + 1] * fade, 0, 255)), round(cl(rgb[j + 2] * fade, 0, 255)));\n  }\n}\n","tally-count":"// ===== Patternflow pattern =====\n// Title:   Tally Count\n// Family:  type\n// Idea:    Four candidates numbered 1 to 4 head four columns of a chalkboard, ballots drawn from a sealed box are read out one at a time and each adds one chalk stroke to its candidate's column, written in the order of the character 正 so that every five votes close one 正 and the stacks of them race down the tall panel like bars, a column flashes when its candidate takes the lead, a thin trace along the bottom follows the lead of the final winner over the runner-up through the count as in Bertrand's ballot problem, and at the end the winner's column glows, the trace says whether the winner led all the way, and the board is wiped for the next count.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tally marks in the character 正, five strokes to a mark, as vote counters in Korea, China and Japan keep them; the ballot problem (William Allen Whitworth, 1878; Joseph Bertrand, 1887); 5 by 7 figures from Photon Disk (pattern round 70); pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Closeness=0..1, Size=7..15\n//\n// Knob 1: Hue. Turns the four chalk colours round the wheel together. At 0 candidate 1 writes in light cyan, 2 in lilac, 3 in salmon and 4 in light green, a quarter turn apart at 60% saturation; at 0.5 they are salmon, light green, light cyan and lilac.\n// Knob 2: Speed. A full count takes 10 s at 2, 100 s at 0.2 and 6.7 s at 3, whatever the number of ballots, and a stroke is written in 0.18 s at 2. The winner then glows for 3 s and the eraser takes 1.2 s, both scaled by 2 / Speed within 1.5 to 6 s and 0.6 to 2.4 s.\n// Knob 3: Closeness. How close the hidden shares are. Each count draws four shares from a Dirichlet(2, 2, 2, 2) and mixes them toward 25% each by this much. At 0 the winner takes 34 to 58% of the ballots (median 44%), the lead changes hands about 3 times and the winner leads all the way in 23% of counts; at 0.5 it takes 33% and leads all the way in 12%; at 1 all four shares are 25%, the columns finish within a few marks of each other, the lead changes about 12 times at Size 7 and the winner leads all the way in 2% of counts. A change of more than 0.08 starts a new count.\n// Knob 4: Size. The height of a 正 in LEDs, 7 to 15 in odd steps. At 7 two marks share a row of the 16 LED column, 12 rows deep, so a column holds 120 votes and a count reads 265 ballots at Closeness 0 and 455 at 1; at 9 one mark a row, 9 rows, 45 votes and about 100 ballots; at 15 five rows of marks 13 wide with 2 LED strokes, 25 votes and about 55 ballots. The winner's column always ends within a few votes of full. A new size starts a new count.\n// Buttons: K1 tap wipes the board and starts a new count.\n\n// The ballot problem: if A gets p votes and B gets q \u003c p, and every order of\n// reading them is equally likely, the chance that A is strictly ahead of B\n// after every ballot is (p - q) / (p + q). Whitworth stated it in 1878 and\n// Bertrand published it in 1887 (Comptes Rendus 105). Here the four\n// candidates' votes are all drawn before the count starts, a sealed box, and\n// then read in a uniformly shuffled order, so for the two who finish first\n// and second the theorem holds as stated: ballots for the other two only\n// stretch the trace sideways. The trace is the lead of the final winner over\n// the final runner-up after each ballot; the winner led all the way when it\n// stays above the zero line from that pair's first ballot on.\n//\n// The five strokes of 正 in their written order: the top bar, the centre\n// stem, the short bar right of the stem at half height, the short stem at\n// the lower left, the long bottom bar. One vote is one stroke.\n\nconst W = 64, H = 128, NC = 4, CW = 16;\n// The tally runs from row TOP to BOT; the trace of the lead sits on row\n// ZERO and swings AMP rows either way.\nconst TOP = 16, BOT = 113, ZERO = 121, AMP = 5;\nconst { floor, round, min, max, abs, sqrt, exp, log, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst T_COUNT = 10, T_STROKE = 0.18, T_END = 3, T_WIPE = 1.2, HUE0 = 0.55;\n\nconst ZHENG = [\n  [0.15, 0, 0.85, 0],\n  [0.5, 0, 0.5, 1],\n  [0.5, 0.5, 0.85, 0.5],\n  [0.15, 0.5, 0.15, 1],\n  [0, 1, 1, 1],\n];\n\n// The figures 1 to 4 of Photon Disk's 5 x 7 face (copied from autogram.js),\n// rows from the top.\nconst FIG = [\n  \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  \".###. #...# ....# ...#. ..#.. .#... #####\",\n  \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\",\n].map((f) => f.replace(/ /g, \"\"));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// A shares vector from a Dirichlet(2, 2, 2, 2): each a sum of two\n// exponentials, normalised.\nconst expo = () => -log(1 - Math.random() * 0.999999);\nfunction shares(close) {\n  const d = [];\n  let s = 0;\n  for (let c = 0; c \u003c NC; c++) s += d[c] = expo() + expo();\n  for (let c = 0; c \u003c NC; c++) d[c] = (1 - close) * (d[c] / s) + close / NC;\n  return d;\n}\n\n// The layout of one size: marks per row, rows, and the cell pitch.\nfunction layout(size) {\n  const g = size \u003c= 7 ? 1 : 2, per = size \u003c= 7 ? 2 : 1, pitch = size + g;\n  const rows = floor((BOT - TOP + g) / pitch);\n  // A mark is as wide as it is tall up to 13 LEDs, which leaves at least\n  // 3 LEDs between neighbouring columns.\n  const mw = min(size, 13), wid = per * mw + (per - 1) * g;\n  return { size, mw, g, per, pitch, rows, cap: rows * per * 5, ox: floor((CW - wid) / 2), sw: size \u003c= 9 ? 1 : size \u003c= 13 ? 1.5 : 2 };\n}\n\n// A new count: draw the shares, the votes, a uniformly shuffled order, and\n// the lead path of the final first over the final second.\nfunction newCount(S, prefill) {\n  const L = (S.L = layout(S.size));\n  let tally;\n  for (let tries = 0; tries \u003c 30; tries++) {\n    S.share = shares(S.close);\n    const top = max(...S.share), n = round((L.cap * 0.96) / top);\n    tally = [0, 0, 0, 0];\n    for (let i = 0; i \u003c n; i++) {\n      let u = Math.random(), c = 0;\n      while (c \u003c NC - 1 && u >= S.share[c]) u -= S.share[c++];\n      tally[c]++;\n    }\n    for (let c = 0; c \u003c NC; c++) tally[c] = min(tally[c], L.cap);\n    const sorted = tally.slice().sort((a, b) => b - a);\n    if (sorted[0] > sorted[1]) break;\n  }\n  const seq = [];\n  for (let c = 0; c \u003c NC; c++) for (let i = 0; i \u003c tally[c]; i++) seq.push(c);\n  for (let i = seq.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1));\n    [seq[i], seq[j]] = [seq[j], seq[i]];\n  }\n  let win = 0;\n  for (let c = 1; c \u003c NC; c++) if (tally[c] > tally[win]) win = c;\n  let run = -1;\n  for (let c = 0; c \u003c NC; c++) if (c !== win && (run \u003c 0 || tally[c] > tally[run])) run = c;\n  const lead = new Int16Array(seq.length);\n  let d = 0, ok = true, seen = false, peak = 1;\n  for (let i = 0; i \u003c seq.length; i++) {\n    if (seq[i] === win) (d++), (seen = true);\n    else if (seq[i] === run) (d--), (seen = true);\n    lead[i] = d;\n    if (seen && d \u003c= 0) ok = false;\n    peak = max(peak, abs(d));\n  }\n  Object.assign(S, { seq, final: tally, win, run, lead, ok, peak, n: seq.length, read: 0, next: 0, phase: 0, pt: 0, leader: -1 });\n  S.p = tally[win];\n  S.q = tally[run];\n  S.tally = [0, 0, 0, 0];\n  S.active = [];\n  S.flash.fill(0);\n  S.lit.fill(0);\n  S.chalk.fill(0);\n  if (prefill) {\n    const k = floor(S.n * prefill);\n    for (let i = 0; i \u003c k; i++) commit(S, true);\n    S.read = k;\n  }\n}\n\n// Where stroke j of candidate c goes, in LED coordinates of pixel centres.\nfunction strokeAt(S, c, j, out) {\n  const L = S.L, m = floor(j / 5), k = j % 5, r = floor(m / L.per), col = m % L.per;\n  const x0 = c * CW + L.ox + col * (L.mw + L.g) + 0.5, y0 = TOP + r * L.pitch + 0.5, ex = L.mw - 1, ey = L.size - 1, z = ZHENG[k];\n  out[0] = x0 + round(z[0] * ex);\n  out[1] = y0 + round(z[1] * ey);\n  out[2] = x0 + round(z[2] * ex);\n  out[3] = y0 + round(z[3] * ey);\n  return out;\n}\n\n// Read the next ballot: one stroke for its candidate, and a flash when the\n// lead changes hands.\nfunction commit(S, silent) {\n  const c = S.seq[S.next], j = S.tally[c]++;\n  const st = strokeAt(S, c, j, [0, 0, 0, 0]);\n  if (silent) bake(S, st, c, 1);\n  else S.active.push({ st, c, t: 0 });\n  let best = 0, ties = 0;\n  for (let k = 1; k \u003c NC; k++) if (S.tally[k] > S.tally[best]) best = k;\n  for (let k = 0; k \u003c NC; k++) if (S.tally[k] === S.tally[best]) ties++;\n  // A change of leader flashes the new leader's column once it has a\n  // whole 正; the swaps among the first few ballots would only flicker.\n  if (ties === 1 && best !== S.leader) {\n    if (S.leader >= 0 && !silent && S.tally[best] >= 5) S.flash[best] = 1;\n    S.leader = best;\n  }\n  if (!silent) S.lit[c] = min(1, S.lit[c] + 0.35);\n  S.next++;\n}\n\n// Chalk: a line of width sw through pixel centres, its grain fixed per LED.\nfunction chalkLine(buf, st, u, sw, col, grain, k0) {\n  const x0 = st[0], y0 = st[1], x1 = x0 + (st[2] - x0) * u, y1 = y0 + (st[3] - y0) * u;\n  const hw = sw / 2, dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy;\n  const ax = max(0, floor(min(x0, x1) - hw - 1)), bx = min(W - 1, floor(max(x0, x1) + hw + 1));\n  const ay = max(0, floor(min(y0, y1) - hw - 1)), by = min(H - 1, floor(max(y0, y1) + hw + 1));\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = l2 > 0 ? cl((px * dx + py * dy) / l2, 0, 1) : 0;\n      const d = sqrt((px - t * dx) ** 2 + (py - t * dy) ** 2), cov = cl(hw + 0.5 - d, 0, 1);\n      if (cov \u003c= 0) continue;\n      const i = y * W + x, a = cov * grain[i] * k0, kk = i * 3;\n      for (let q = 0; q \u003c 3; q++) buf[kk + q] = max(buf[kk + q], col[q] * a);\n    }\n}\nfunction bake(S, st, c, u) {\n  chalkLine(S.chalk, st, u, S.L.sw, S.col[c], S.grain, 1);\n}\n// A finished stroke throws a little dust round itself, which settles in\n// about a second: the front where a column is being written hazes over.\nfunction puff(S, st, c) {\n  const ax = max(0, floor(min(st[0], st[2]) - 4)), bx = min(W - 1, floor(max(st[0], st[2]) + 4));\n  const ay = max(0, floor(min(st[1], st[3]) - 4)), by = min(H - 1, floor(max(st[1], st[3]) + 4));\n  const dx = st[2] - st[0], dy = st[3] - st[1], l2 = dx * dx + dy * dy || 1;\n  for (let y = ay; y \u003c= by; y++)\n    for (let x = ax; x \u003c= bx; x++) {\n      const px = x + 0.5 - st[0], py = y + 0.5 - st[1], t = cl((px * dx + py * dy) / l2, 0, 1);\n      const d2 = (px - t * dx) ** 2 + (py - t * dy) ** 2, i = y * W + x;\n      S.dust[i] = min(0.5, S.dust[i] + 0.09 * exp(-d2 / 5) * S.grain[i]);\n      S.dustC[i] = c;\n    }\n}\n\nexport function setup(params) {\n  const grain = new Float32Array(W * H);\n  for (let i = 0; i \u003c grain.length; i++) grain[i] = 0.74 + 0.26 * Math.random();\n  params.s = {\n    hue: 0, speed: 2, close: 0, size: 7, started: false, btn: false, grain,\n    chalk: new Float32Array(W * H * 3), out: new Float32Array(W * H * 3), dust: new Float32Array(W * H), dustC: new Uint8Array(W * H),\n    flash: new Float32Array(NC), lit: new Float32Array(NC), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\n    wipeY: -1, t: 0,\n  };\n  return params.s;\n}\n\nfunction paint(S) {\n  for (let c = 0; c \u003c NC; c++) hsv(S.hue + HUE0 + c * 0.25, 0.6, 1, S.col[c]);\n}\n\n// Phases: 0 counting, 1 the winner glows, 2 the eraser comes down.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 7], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  const close = cl(k[2] || 0, 0, 1), size = 7 + 2 * round((cl(k[3] == null ? 7 : k[3], 7, 15) - 7) / 2);\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  paint(S);\n  if (!S.started || size !== S.size || abs(close - S.close) > 0.08) {\n    // The Lab opens on a count 40% of the way through.\n    S.close = close;\n    S.size = size;\n    newCount(S, S.started ? 0.12 : 0.4);\n    S.started = true;\n  } else if (btn && !S.btn) (S.phase = 2), (S.pt = 0), (S.wipeY = 0);\n  S.btn = btn;\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  for (let c = 0; c \u003c NC; c++) (S.flash[c] *= exp(-d / 0.45)), (S.lit[c] *= exp(-d / 0.25));\n  const settle = exp(-d / 0.9);\n  for (let i = 0; i \u003c W * H; i++) S.dust[i] *= settle;\n  if (S.phase === 0) {\n    const rate = S.n / (T_COUNT * sc);\n    S.read = min(S.n, S.read + d * rate);\n    while (S.next \u003c S.n && S.next \u003c S.read) commit(S, false);\n    const ds = T_STROKE * sc;\n    for (const a of S.active) a.t += d / ds;\n    S.active = S.active.filter((a) => (a.t >= 1 ? (bake(S, a.st, a.c, 1), puff(S, a.st, a.c), false) : true));\n    if (S.next >= S.n && !S.active.length) (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    if (S.pt >= cl(T_END * sc, 1.5, 6)) (S.phase = 2), (S.pt = 0), (S.wipeY = 0);\n  } else {\n    // The eraser: what it passes keeps a smear of dust that fades.\n    const dur = cl(T_WIPE * sc, 0.6, 2.4), y1 = min(H, (S.pt / dur) * (H + 12));\n    const ch = S.chalk;\n    for (let y = 0; y \u003c min(H, floor(y1)); y++) {\n      const f = y >= S.wipeY ? 0.16 : exp(-d / 0.5);\n      for (let x = 0; x \u003c W; x++) {\n        const kk = (y * W + x) * 3;\n        ch[kk] *= f;\n        ch[kk + 1] *= f;\n        ch[kk + 2] *= f;\n      }\n    }\n    S.wipeY = max(S.wipeY, floor(y1));\n    if (S.pt >= dur + 0.5) newCount(S, 0);\n  }\n}\n\nfunction fill(o, x0, y0, x1, y1, c, a) {\n  for (let y = max(0, y0); y \u003c= min(H - 1, y1); y++)\n    for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) {\n      const kk = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) o[kk + q] = max(o[kk + q], c[q] * a);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.out, ch = S.chalk, col = S.col;\n  const wipe = S.phase === 2, glow = S.phase === 1 ? 0.5 + 0.5 * sin(S.pt * 5) : 0;\n  // The board, with a faint tint behind a column that just took the lead or won.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3, c = floor(x / CW);\n      const inside = y >= TOP - 2 && y \u003c= BOT;\n      let tint = inside ? 0.2 * S.flash[c] : 0;\n      if (S.phase === 1 && c === S.win && inside) tint = max(tint, 0.1 + 0.1 * glow);\n      const du = S.dust[y * W + x], dc = col[S.dustC[y * W + x]];\n      o[kk] = 0.02 + col[c][0] * tint + dc[0] * du;\n      o[kk + 1] = 0.055 + col[c][1] * tint + dc[1] * du;\n      o[kk + 2] = 0.045 + col[c][2] * tint + dc[2] * du;\n    }\n  // Chalk on the board; the winner's marks brighten while it glows.\n  const boost = S.phase === 1 ? 1 + 0.25 * glow : 1;\n  for (let i = 0; i \u003c W * H; i++) {\n    const kk = i * 3, b = S.phase === 1 && floor((i % W) / CW) === S.win ? boost : 1;\n    o[kk] = max(o[kk], ch[kk] * b);\n    o[kk + 1] = max(o[kk + 1], ch[kk + 1] * b);\n    o[kk + 2] = max(o[kk + 2], ch[kk + 2] * b);\n  }\n  // Strokes being written: the line so far, its tip a little brighter.\n  const tip = [0, 0, 0];\n  for (const a of S.active) {\n    const u = cl(a.t, 0, 1);\n    chalkLine(o, a.st, u, S.L.sw, col[a.c], S.grain, 1);\n    for (let q = 0; q \u003c 3; q++) tip[q] = 0.5 + 0.5 * col[a.c][q];\n    const st = a.st, tx = st[0] + (st[2] - st[0]) * u, ty = st[1] + (st[3] - st[1]) * u;\n    chalkLine(o, [tx, ty, tx, ty], 1, S.L.sw + 0.4, tip, S.grain, 1);\n  }\n  // The candidates' numbers, 기호 1 to 4, in boxes that light as a ballot is read.\n  for (let c = 0; c \u003c NC; c++) {\n    const x0 = c * CW + 2, x1 = c * CW + 13, cc = col[c];\n    const lit = S.lit[c], won = S.phase >= 1 && c === S.win ? 1 : 0;\n    fill(o, x0, 1, x1, 13, cc, 0.14 + 0.5 * lit + 0.25 * won * (S.phase === 1 ? glow : 1));\n    for (let x = x0; x \u003c= x1; x++) fill(o, x, 1, x, 1, cc, 0.7), fill(o, x, 13, x, 13, cc, 0.7);\n    fill(o, x0, 1, x0, 13, cc, 0.7);\n    fill(o, x1, 1, x1, 13, cc, 0.7);\n    const f = FIG[c];\n    for (let r = 0; r \u003c 7; r++)\n      for (let q = 0; q \u003c 5; q++) if (f[r * 5 + q] === \"#\") fill(o, c * CW + 5 + q, 4 + r, c * CW + 5 + q, 4 + r, [1, 1, 1], 0.9 + 0.1 * lit);\n    // Led all the way: a second frame round the winner's box.\n    if (S.phase === 1 && c === S.win && S.ok && glow > 0.3) {\n      for (let x = x0 - 1; x \u003c= x1 + 1; x++) fill(o, x, 0, x, 0, [1, 1, 1], 0.9), fill(o, x, 14, x, 14, [1, 1, 1], 0.9);\n      fill(o, x0 - 1, 0, x0 - 1, 14, [1, 1, 1], 0.9);\n      fill(o, x1 + 1, 0, x1 + 1, 14, [1, 1, 1], 0.9);\n    }\n  }\n  // The ballot path: zero line dotted, the winner's lead above, the\n  // runner-up's below, one column per ballot read.\n  if (!wipe || S.pt \u003c 0.3) {\n    for (let x = 0; x \u003c W; x += 2) fill(o, x, ZERO, x, ZERO, [0.5, 0.5, 0.5], 0.42);\n    const n = min(S.next, S.n), cw = col[S.win], cr = col[S.run], sy = AMP / S.peak;\n    let py = ZERO;\n    for (let i = 0; i \u003c n; i++) {\n      const x = floor((i * W) / S.n), y = round(ZERO - S.lead[i] * sy);\n      const c = S.lead[i] > 0 ? cw : S.lead[i] \u003c 0 ? cr : [1, 1, 1];\n      const a = S.phase === 1 ? (S.ok ? 0.75 + 0.25 * glow : 0.75) : 0.75;\n      for (let yy = min(py, y); yy \u003c= max(py, y); yy++) fill(o, x, yy, x, yy, c, a);\n      py = y;\n    }\n    // Not led all the way: where the runner-up drew level or went ahead.\n    if (S.phase === 1 && !S.ok) {\n      let seen = false, was = false;\n      for (let i = 0; i \u003c n; i++) {\n        if (S.seq[i] === S.win || S.seq[i] === S.run) seen = true;\n        const down = seen && S.lead[i] \u003c= 0;\n        if (down && was === false) {\n          const x = floor((i * W) / S.n);\n          fill(o, x, ZERO - 2, x, ZERO + 2, [1, 1, 1], 0.4 + 0.6 * glow);\n        }\n        if (seen) was = down;\n      }\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const kk = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(o[kk], 0, 1) * 255), round(cl(o[kk + 1], 0, 1) * 255), round(cl(o[kk + 2], 0, 1) * 255));\n    }\n}\n","trajan-helix":"// ===== Patternflow pattern =====\n// Title:   Trajan Helix\n// Family:  type\n// Idea:    A marble column fills the height of the panel and turns slowly under a raking lamp while a helical band winds round it from foot to top, the way the frieze winds round Trajan's Column, but the band carries the column's own base inscription in Roman capitals cut and painted red, full width where the band faces you, squeezed thin toward the column's edges and gone behind it, so as the column turns and the view climbs the line slides along the helix and reads on without end, SENATVS POPVLVSQVE ROMANVS and on to SIT EGESTVS, while the band itself creeps slowly up like a barber's pole and the letters lost from the stone pass as a broken patch with their restoration ghosted in.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the base inscription of Trajan's Column (CIL VI 960, the column dedicated in AD 113 and attributed to Apollodorus of Damascus), the model of the Roman capital, with stroke weights after Edward Catich's flat-brush account in The Origin of the Serif (1968) and the red letters after Pliny's minium for inscriptions (Natural History 33.122); capitals drawn for this pattern as strokes, pattern round 74\n// Round:   74\n// ===============================\n// @matrix 64x128\n// @knobs Paint=0..1, Turn=0.2..3, Turns=5..9, Light=0..1\n//\n// Knob 1: Paint. The colour in the cut letters: at 0 minium, a vermilion red; 0.1 gold, 0.3 green, 0.6 blue, 0.8 purple, and back to red at 1. The marble stays marble and the lost letters stay bare.\n// Knob 2: Turn. How fast the column turns: at 2 the front of the column moves 12 LEDs a second, a letter and two thirds, a full turn takes 13.1 s, the band creeps up half a pitch a turn (12.8 rows at the opening 5 turns) and the whole inscription, 172 letters and 34 stops, passes in 1 minute 53 s; at 0.2 a letter goes by every 6 s and the inscription takes 19 minutes, at 3 two and a half letters go by a second.\n// Knob 3: Turns. How many turns of the band stand on the panel: 5 at the start, a pitch of 25.6 rows with 13.6 rows of plain marble between the turns; at 9 the pitch is 14.2 rows and the turns almost touch, 2.2 rows apart, so the panel is a screw of text as the real frieze is a screw of figures.\n// Knob 4: Light. Where the lamp stands round the column, 30 degrees above it: at the opening 0.06 it rakes in from 57 degrees to the left, so the left of the shaft is lit, the right falls into shadow and every cut letter shows a lit wall and a dark one; at 0.5 the lamp is in front and the column goes flat; at 1 it rakes from 65 degrees to the right and the shading turns over.\n\n// The column is a cylinder of radius 25 LEDs seen from far off, so the LED\n// x across the shaft is R sin(beta) for the angle beta round from the front,\n// and a stroke on the stone shrinks by cos(beta) as it turns toward the edge.\n// The band is a helix: its top edge stands at Y0 - P beta / 2 pi, P the\n// pitch, and the text coordinate along it is the arc R (beta - 2 pi m) for\n// the m-th turn counted up from the panel's foot. Turning the column by phi\n// slides the text along the band by R phi. Turning alone would make the\n// band climb a whole pitch a turn, the barber's pole, and the panel would\n// show the same stretch of stone for ever; so the view climbs too, half a\n// pitch a turn, new stone and the next words come in at the top, and the\n// band still creeps up by the other half. Every letter is fixed to the\n// stone.\n//\n// The capitals are strokes (straight or elliptic arcs) in a box 8 LEDs tall.\n// Their weights follow a flat brush held with its edge 20 degrees above the\n// horizontal, Catich's account of how the letters were laid out before the\n// cutting: uprights and down-right strokes come out thick (1.8 LEDs), the\n// horizontals and down-left strokes thin (0.85), and the N's uprights are\n// set thin by hand as on the stone. Each LED's coverage comes from its\n// distance to the strokes, measured on the stone and turned into LEDs\n// through the squeeze cos(beta), so letters thin out smoothly at the edges.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, asin, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nfunction hsv(h, s, v) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nconst CX = 32, R = 25;\n// The band: 12 rows, a shadowed seam on top, the letters 8 rows tall from\n// row 2, a lit lip at the bottom.\nconst BAND = 12, CAP = 8, TOP = 2, Y0 = 118;\nconst HAIR = 0.85, THICK = 1.8, GAP = 1.7;\nconst ELEV = (30 * PI) / 180, FOLLOW = 0.5;\n\n// ---- The capitals, in units of the cap height, y down. [\"l\", x0, y0, x1,\n// y1, wt] a straight stroke, [\"a\", cx, cy, rx, ry, from, to, wt] an\n// elliptic arc between two angles in degrees (0 right, 90 down), [\"d\", x,\n// y] the stop between words. wt left out takes the brush's weight for the\n// stroke's direction; 0 is a hairline. Serifs are short hairlines at the\n// ends of the stems. Only the 19 letters the inscription uses are drawn.\nconst s0 = (x, y, a = 0.11) => [\"l\", x - a, y, x + a, y, 0];\nconst GLYPHS = {\n  A: [0.86, [[\"l\", 0.43, 0, 0.05, 1], [\"l\", 0.43, 0, 0.82, 1], [\"l\", 0.21, 0.64, 0.66, 0.64, 0], s0(0.05, 1), s0(0.82, 1)]],\n  B: [0.58, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.32, 0, 0], [\"a\", 0.32, 0.24, 0.2, 0.24, -90, 90], [\"l\", 0.1, 0.48, 0.34, 0.48, 0],\n    [\"a\", 0.34, 0.74, 0.22, 0.26, -90, 90], [\"l\", 0.1, 1, 0.34, 1, 0], s0(0.04, 0, 0.06), s0(0.04, 1, 0.06)]],\n  C: [0.82, [[\"a\", 0.46, 0.5, 0.44, 0.5, -48, -312], [\"l\", 0.76, 0.06, 0.76, 0.2, 0]]],\n  D: [0.88, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.42, 0, 0], [\"l\", 0.1, 1, 0.42, 1, 0], [\"a\", 0.42, 0.5, 0.42, 0.5, -90, 90], s0(0.04, 0, 0.06), s0(0.04, 1, 0.06)]],\n  E: [0.5, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.47, 0, 0], [\"l\", 0.1, 0.5, 0.42, 0.5, 0], [\"l\", 0.1, 1, 0.5, 1, 0],\n    [\"l\", 0.47, 0, 0.47, 0.12, 0], [\"l\", 0.5, 1, 0.5, 0.86, 0], s0(0.04, 0, 0.06), s0(0.04, 1, 0.06)]],\n  F: [0.5, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.48, 0, 0], [\"l\", 0.1, 0.5, 0.42, 0.5, 0], [\"l\", 0.48, 0, 0.48, 0.12, 0], s0(0.04, 0, 0.06), s0(0.12, 1, 0.14)]],\n  G: [0.86, [[\"a\", 0.46, 0.5, 0.44, 0.5, -48, -340], [\"l\", 0.84, 0.56, 0.84, 0.96], [\"l\", 0.76, 0.06, 0.76, 0.2, 0]]],\n  I: [0.24, [[\"l\", 0.12, 0, 0.12, 1], s0(0.12, 0), s0(0.12, 1)]],\n  L: [0.5, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 1, 0.5, 1, 0], [\"l\", 0.5, 1, 0.5, 0.86, 0], s0(0.12, 0, 0.14), s0(0.04, 1, 0.06)]],\n  M: [1.0, [[\"l\", 0.15, 0, 0.05, 1], [\"l\", 0.15, 0, 0.5, 1], [\"l\", 0.85, 0, 0.5, 1], [\"l\", 0.85, 0, 0.95, 1], s0(0.05, 1), s0(0.95, 1)]],\n  N: [0.82, [[\"l\", 0.08, 0, 0.08, 1, 0], [\"l\", 0.74, 0, 0.74, 1, 0], [\"l\", 0.08, 0, 0.74, 1], s0(0.08, 1), s0(0.74, 0)]],\n  O: [0.94, [[\"a\", 0.47, 0.5, 0.46, 0.5, 0, 360]]],\n  P: [0.56, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.32, 0, 0], [\"a\", 0.32, 0.26, 0.22, 0.26, -90, 90], [\"l\", 0.1, 0.52, 0.32, 0.52, 0], s0(0.04, 0, 0.06), s0(0.12, 1, 0.14)]],\n  Q: [0.94, [[\"a\", 0.47, 0.5, 0.46, 0.5, 0, 360], [\"l\", 0.52, 0.94, 1.1, 1.1]]],\n  R: [0.66, [[\"l\", 0.1, 0, 0.1, 1], [\"l\", 0.1, 0, 0.32, 0, 0], [\"a\", 0.32, 0.25, 0.22, 0.25, -90, 90], [\"l\", 0.1, 0.5, 0.32, 0.5, 0],\n    [\"l\", 0.3, 0.5, 0.62, 1], s0(0.04, 0, 0.06), s0(0.12, 1, 0.14), s0(0.66, 1, 0.06)]],\n  S: [0.5, [[\"l\", 0.44, 0.06, 0.44, 0.18, 0], [\"a\", 0.26, 0.25, 0.2, 0.25, -30, -270], [\"a\", 0.24, 0.75, 0.22, 0.25, -90, 90], [\"l\", 0.06, 0.82, 0.06, 0.94, 0]]],\n  T: [0.72, [[\"l\", 0, 0, 0.72, 0, 0], [\"l\", 0.36, 0, 0.36, 1], [\"l\", 0, 0, 0, 0.12, 0], [\"l\", 0.72, 0, 0.72, 0.12, 0], s0(0.36, 1, 0.14)]],\n  V: [0.84, [[\"l\", 0.04, 0, 0.42, 1], [\"l\", 0.8, 0, 0.42, 1], s0(0.04, 0), s0(0.8, 0)]],\n  X: [0.74, [[\"l\", 0.06, 0, 0.68, 1], [\"l\", 0.66, 0, 0.08, 1], s0(0.06, 0), s0(0.66, 0), s0(0.08, 1), s0(0.68, 1)]],\n  \"·\": [0.2, [[\"d\", 0.1, 0.55]]],\n};\n\n// The inscription, its six lines run together, stops between the words as\n// on the stone. Square brackets mark the letters lost with a piece of the\n// last line, read here TANT[IS OPER]IBVS; editions differ by a letter at\n// either end of the gap (TAN[TIS OPE]RIBVS in one).\nconst TEXT =\n  \"SENATVS·POPVLVSQVE·ROMANVS·IMP·CAESARI·DIVI·NERVAE·F·NERVAE·TRAIANO·AVG·GERM·DACICO·PONTIF·MAXIMO·TRIB·POT·XVII·IMP·VI·COS·VI·P·P·\" +\n  \"AD·DECLARANDVM·QVANTAE·ALTITVDINIS·MONS·ET·LOCVS·TANT[IS·OPER]IBVS·SIT·EGESTVS\";\n\n// The brush: weight 1 for an upright, about 0.95 down-right, 0.13\n// down-left, 0 across.\nconst NIB = (-20 * PI) / 180;\nconst brush = (dx, dy) => cl((abs(sin(atan2(dy, dx) - NIB)) - 0.34) / 0.6, 0, 1);\n\n// Each glyph as segments in LEDs: x0, y0, x1, y1, half width.\nfunction build(parts) {\n  const seg = [];\n  const push = (x0, y0, x1, y1, wt) => {\n    const w = wt == null ? brush(x1 - x0, y1 - y0) : wt;\n    seg.push(x0 * CAP, y0 * CAP, x1 * CAP, y1 * CAP, (HAIR + (THICK - HAIR) * w) / 2);\n  };\n  for (const p of parts) {\n    if (p[0] === \"l\") push(p[1], p[2], p[3], p[4], p[5]);\n    else if (p[0] === \"d\") seg.push(p[1] * CAP, p[2] * CAP, p[1] * CAP, p[2] * CAP, 0.7);\n    else {\n      const [, cx, cy, rx, ry, a0, a1, wt] = p, n = max(3, round(abs(a1 - a0) / 20));\n      for (let i = 0; i \u003c n; i++) {\n        const t0 = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, t1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * PI) / 180;\n        push(cx + rx * cos(t0), cy + ry * sin(t0), cx + rx * cos(t1), cy + ry * sin(t1), wt);\n      }\n    }\n  }\n  return new Float32Array(seg);\n}\n\n// Lay the text out along the band: each letter's start, width, segments and\n// whether it is lost. A wider gap closes the round before it starts again.\nfunction layout() {\n  const shapes = {};\n  for (const ch in GLYPHS) shapes[ch] = build(GLYPHS[ch][1]);\n  const letters = [];\n  let x = 0, lost = false;\n  for (const ch of TEXT) {\n    if (ch === \"[\" || ch === \"]\") {\n      lost = ch === \"[\";\n      continue;\n    }\n    const w = GLYPHS[ch][0] * CAP;\n    letters.push({ x, w, seg: shapes[ch], lost });\n    x += w + GAP;\n  }\n  const len = x + 14;\n  // at[i]: the first letter whose right edge passes arc i, for a quick find.\n  const at = new Int16Array(floor(len) + 1);\n  for (let i = 0, k = 0; i \u003c= floor(len); i++) {\n    while (k \u003c letters.length && letters[k].x + letters[k].w \u003c i) k++;\n    at[i] = min(k, letters.length - 1);\n  }\n  // The lost stretch, a little wider than its letters.\n  let lost0 = Infinity, lost1 = -Infinity;\n  for (const g of letters) if (g.lost) (lost0 = min(lost0, g.x - 1.2)), (lost1 = max(lost1, g.x + g.w + 1.2));\n  return { letters, len, at, lost0, lost1 };\n}\n\n// Marble: a vein field on the stone, 160 columns round by 256 rows,\n// periodic both ways, from wrapped value noise and a sine through it.\nconst TW = 160, TH = 256;\nfunction marble() {\n  const tex = new Float32Array(TW * TH);\n  const oct = [[10, 16, 1], [20, 32, 0.5], [40, 64, 0.25]].map(([nx, ny, a]) => {\n    const g = new Float32Array(nx * ny);\n    for (let i = 0; i \u003c g.length; i++) g[i] = Math.random();\n    return { nx, ny, a, g };\n  });\n  const sm = (u) => u * u * (3 - 2 * u);\n  for (let y = 0; y \u003c TH; y++)\n    for (let x = 0; x \u003c TW; x++) {\n      let n = 0;\n      for (const o of oct) {\n        const fx = (x / TW) * o.nx, fy = (y / TH) * o.ny, ix = floor(fx), iy = floor(fy), ux = sm(fx - ix), uy = sm(fy - iy);\n        const a = o.g[(iy % o.ny) * o.nx + (ix % o.nx)], b = o.g[(iy % o.ny) * o.nx + ((ix + 1) % o.nx)];\n        const c = o.g[((iy + 1) % o.ny) * o.nx + (ix % o.nx)], d = o.g[((iy + 1) % o.ny) * o.nx + ((ix + 1) % o.nx)];\n        n += o.a * (a + (b - a) * ux + (c - a + (d - c - b + a) * ux) * uy);\n      }\n      const m = abs(sin(TAU * (2 * x / TW + y / TH) + 5 * n));\n      tex[y * TW + x] = (1 - m) ** 6 * 0.55 + n * 0.12;\n    }\n  return tex;\n}\n\nexport function setup(params) {\n  const L = layout();\n  params.s = { L, tex: marble(), phi: 0, shift: 0, band: 0, climb: 0, paint: 0, turn: 2, turns: 5, light: 0.06, rough: new Float32Array(64) };\n  for (let i = 0; i \u003c 64; i++) params.s.rough[i] = Math.random();\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 5, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.paint = cl(k[0] || 0, 0, 1);\n  s.turn = cl(k[1] == null ? 2 : k[1], 0.2, 3);\n  s.turns = cl(k[2] == null ? 5 : k[2], 5, 9);\n  s.light = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  // 6 LEDs a second of arc at the front for each unit of Turn. The turn\n  // slides the text along the band; the view climbs FOLLOW of the band's\n  // rise, so the band itself creeps up the rest, a barber pole slowed down.\n  const dphi = (6 * s.turn * dt) / R, P = H / s.turns;\n  s.phi = (s.phi + dphi) % TAU;\n  s.shift = (s.shift + R * dphi) % s.L.len;\n  s.band += ((1 - FOLLOW) * P * dphi) / TAU;\n  s.climb = (s.climb + (FOLLOW * P * dphi) / TAU) % TH;\n}\n\n// Coverage of the letters at one LED: (u, v) its place on the band in LEDs,\n// sq the squeeze cos(beta). Returns coverage and the outward direction of\n// the nearest stroke edge (for the walls of the cut) in out.\nfunction ink(L, u, v, sq, out) {\n  const { letters, at } = L;\n  const pad = 2 / sq + 1;\n  let best = 0, nx = 0, ny = 0;\n  const i0 = at[cl(floor(u - pad), 0, at.length - 1)], i1 = at[cl(floor(u + pad), 0, at.length - 1)];\n  for (let i = i0; i \u003c= i1; i++) {\n    const g = letters[i], seg = g.seg, lu = u - g.x, lv = v;\n    for (let j = 0; j \u003c seg.length; j += 5) {\n      const ax = seg[j], ay = seg[j + 1], bx = seg[j + 2] - ax, by = seg[j + 3] - ay, hw = seg[j + 4];\n      const bb = bx * bx + by * by, t = bb > 0 ? cl(((lu - ax) * bx + (lv - ay) * by) / bb, 0, 1) : 0;\n      let dx = lu - ax - t * bx, dy = lv - ay - t * by;\n      const d = sqrt(dx * dx + dy * dy);\n      if (d - hw > pad) continue;\n      if (d > 1e-4) (dx /= d), (dy /= d);\n      else (dx = 0), (dy = 0);\n      // The gradient of the distance in LEDs on the panel: across the\n      // squeeze an arc step is sq LEDs wide.\n      const gx = dx / sq, gl = sqrt(gx * gx + dy * dy) || 1;\n      const c = min(0.5 - (d - hw) / gl, (2 * hw) / gl, 1);\n      if (c > best) (best = c), (nx = dx), (ny = dy), (out[2] = g.lost ? 1 : 0), (out[3] = d / hw);\n    }\n  }\n  out[0] = nx;\n  out[1] = ny;\n  return best;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const L = s.L, tex = s.tex, P = H / s.turns, phi = s.phi;\n  const al = ((-65 + 130 * s.light) * PI) / 180, ce = cos(ELEV), se = sin(ELEV);\n  // The light and the half vector for a little sheen.\n  const lx = sin(al) * ce, lz = cos(al) * ce, hx = lx, hy = -se, hz = lz + 1, hl = sqrt(hx * hx + hy * hy + hz * hz);\n  const paint = hsv(0.02 + s.paint, 0.86, 1);\n  const out = [0, 0, 0, 0];\n  const climb = s.climb, band = s.band, shift = s.shift;\n  for (let x = 0; x \u003c W; x++) {\n    const sx = (x + 0.5 - CX) / R, edge = cl(R - abs(x + 0.5 - CX) + 0.5, 0, 1);\n    const beta = asin(cl(sx, -1, 1)), sq = max(0.05, cos(beta));\n    const nX = sin(beta), nZ = cos(beta);\n    const lam = max(0, nX * lx + nZ * lz), spec = max(0, (nX * hx + nZ * hz) / hl) ** 30;\n    const shade = 0.13 + 0.92 * lam;\n    // The lamp's pull along the surface, for the walls of the cuts.\n    const tu = sin(al - beta) * ce, tv = -se;\n    const us = frac((beta + phi) / TAU) * TW;\n    const qb = (P * beta) / TAU + band;\n    for (let y = 0; y \u003c H; y++) {\n      const sb = 14 + (y / H) * 8;\n      if (edge \u003c= 0) {\n        display.setPixel(x, y, 5, 7, round(sb));\n        continue;\n      }\n      // The stone under this LED.\n      const ys = y - climb, vy = ((floor(ys) % TH) + TH) % TH;\n      const vein = tex[vy * TW + (floor(us) % TW)];\n      let r = 236 - 70 * vein, gr = 230 - 66 * vein, b = 218 - 50 * vein;\n      // Which turn of the band, and where in it.\n      const q = y + 0.5 - Y0 + qb, m = floor(q / P), v = q - m * P;\n      let k = shade, lr = 0, lg = 0, lb = 0, c = 0;\n      if (v \u003c BAND) {\n        // The band is a shallow sunk ribbon: shadow under its top edge, a\n        // lit lip at its foot.\n        k *= v \u003c 1 ? 0.5 + 0.2 * (1 - se) : v >= BAND - 1 ? 1.18 : 0.86;\n        let u = R * (beta - TAU * m) + shift;\n        u = ((u % L.len) + L.len) % L.len;\n        // The broken patch where the piece is lost: rough, darker stone.\n        if (u > L.lost0 && u \u003c L.lost1) k *= 0.5 + 0.22 * s.rough[(floor(u * 0.7) + 7 * floor(v * 0.6)) & 63];\n        c = ink(L, u, v - TOP, sq, out);\n        if (c > 0) {\n          // A wall of the cut facing the lamp is lit, the one facing away\n          // dark; the stroke's middle is the floor of the V. A lost letter\n          // is only the restorer's pale outline on the broken patch.\n          const kk = shade * (1 - 0.55 * (out[0] * tu + out[1] * tv) * cl(out[3], 0, 1));\n          if (out[2]) (lr = r * 1.05 * shade), (lg = gr * 1.05 * shade), (lb = b * 1.08 * shade), (c *= 0.75);\n          else (lr = 255 * paint[0] * kk), (lg = 255 * paint[1] * kk), (lb = 255 * paint[2] * kk);\n        }\n      }\n      r = r * k + 120 * spec;\n      gr = gr * k + 118 * spec;\n      b = b * k + 112 * spec;\n      if (c > 0) (r += (lr - r) * c), (gr += (lg - gr) * c), (b += (lb - b) * c);\n      const sky = 1 - edge;\n      display.setPixel(x, y, round(cl(r * edge + 5 * sky, 0, 255)), round(cl(gr * edge + 7 * sky, 0, 255)), round(cl(b * edge + sb * sky, 0, 255)));\n    }\n  }\n}\n","abracadabra":"// ===== Patternflow pattern =====\n// Title:   Abracadabra\n// Family:  type\n// Idea:    The fever charm from Serenus Sammonicus stands down all 128 rows as eleven lines of ABRACADABRA, one letter shorter each line, and a fever runs down through it again and again, writing each line hot as it passes, while the one letter each line leaves out flares, burns, cools to ash and crumbles to a faint scorch, until only the last A carries the heat off the foot of the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the ABRACADABRA cone in Quintus Serenus Sammonicus, Liber Medicinalis (usually dated to the early 3rd century AD), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Form=0..2, Cooling=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together: at 0 the fever is hot pink going white where it is hottest, the written lines a pale teal, the letter each line leaves out burns amber, and its ash is a grey blue.\n// Knob 2: Speed. The fever crosses one line a beat: 0.6 s at 2, so it goes down the 128 rows in 6.6 s and comes round again every 8.4 s; ten times slower at 0.2 and half again as fast at 3.\n// Knob 3: Form. Which end of the line loses its letter, rounded to 0, 1 or 2. 0 drops the last letter, the staircase whose left column reads eleven A's; 1 drops the first, the mirrored staircase; 2 drops the last and the first in turn, the centred cone that ends on the A in the middle of the word. Every letter stays in its own column, so the three forms end on an A.\n// Knob 4: Cooling. How long the heat stays behind the fever: at 0.06 a line is back to ink a beat or so after it was written and the ash of a left-out letter has crumbled to its scorch 3 to 5 beats after it caught; at 1 the cone stays pink about 4 beats behind the front and the ash crumbles over 6 to 17 beats, so about a third of it is still there when the next fever comes round.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters. The word needs five: A B R C D. Eleven letters must fit 64\n// columns, so each is 4 wide on a 5 LED pitch (54 columns, 5 spare on each\n// side) and 9 tall, one stroke wide. A line has 11.64 rows, so the eleven\n// lines fill the 128 rows with 2 or 3 dark rows between them.\nconst GLYPH = {\n  A: [\".##.\", \"#..#\", \"#..#\", \"#..#\", \"####\", \"#..#\", \"#..#\", \"#..#\", \"#..#\"],\n  B: [\"###.\", \"#..#\", \"#..#\", \"#..#\", \"###.\", \"#..#\", \"#..#\", \"#..#\", \"###.\"],\n  R: [\"###.\", \"#..#\", \"#..#\", \"#..#\", \"###.\", \"#.#.\", \"#..#\", \"#..#\", \"#..#\"],\n  C: [\".##.\", \"#..#\", \"#...\", \"#...\", \"#...\", \"#...\", \"#...\", \"#..#\", \".##.\"],\n  D: [\"###.\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"###.\"],\n};\nconst WORD = \"ABRACADABRA\", N = 11, GW = 4, GH = 9, X0 = 5, PX = 5, LH = H / N;\nconst TOP = [];\nfor (let i = 0; i \u003c N; i++) TOP.push(round(i * LH + (LH - GH) / 2));\n// Rows 1, 13, 25, 36, 48, 60, 71, 83, 94, 106, 118: the last line ends on row 126.\n\n// Every place in the 11 by 11 grid: line i, column j holds WORD[j], always in\n// the same column, so a line that loses its first letter does not shift.\n// pix lists the lit LEDs of each place; rnd is a fixed number per LED that\n// sets when that LED of an ash letter crumbles.\nconst CELL = [];\nfor (let i = 0; i \u003c N; i++)\n  for (let j = 0; j \u003c N; j++) {\n    const g = GLYPH[WORD[j]], pix = [];\n    for (let r = 0; r \u003c GH; r++)\n      for (let c = 0; c \u003c GW; c++) if (g[r][c] === \"#\") pix.push((TOP[i] + r) * W + X0 + PX * j + c);\n    CELL.push({ i, j, pix });\n  }\nfunction hash(n) {\n  let h = Math.imul(n ^ 0x9e3779b9, 0x85ebca6b) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nconst RND = new Float32Array(NP);\nfor (let p = 0; p \u003c NP; p++) RND[p] = hash(p + 17);\n\n// ---- The forms. Line i keeps the columns a..b of the word. L[j] is the line\n// on which column j is left out, the line its letter burns on; the column\n// that is never left out gets 11, below the last line. Staircase: line i\n// keeps 0..10-i, so L = 11, 10, 9, ..., 1 and the letters burn in the order\n// A R B A D A C A R B, the word backwards, with the first A left to carry the\n// last of the heat. Mirrored: line i keeps i..10. Cone: the last and the\n// first in turn, line i keeps floor(i/2)..10-ceil(i/2), and the middle A,\n// column 5, is left.\nconst FORMS = [0, 1, 2].map((f) => {\n  const L = new Int8Array(N).fill(N);\n  for (let i = N - 1; i >= 0; i--) {\n    const a = f === 0 ? 0 : f === 1 ? i : floor(i / 2), b = f === 0 ? N - 1 - i : f === 1 ? N - 1 : N - 1 - Math.ceil(i / 2);\n    for (let j = 0; j \u003c N; j++) if (j \u003c a || j > b) L[j] = i;\n  }\n  let last = 0;\n  for (let j = 0; j \u003c N; j++) if (L[j] === N) last = j;\n  return { L, last };\n});\n// Checked: every form keeps 11 - i letters on line i (66 in all), burns one\n// letter on each of lines 1..10, and leaves an A: column 0, 10 or 5.\nfor (const F of FORMS) {\n  for (let i = 0; i \u003c N; i++) {\n    let k = 0, burn = 0;\n    for (let j = 0; j \u003c N; j++) (k += i \u003c F.L[j] ? 1 : 0), (burn += i === F.L[j] ? 1 : 0);\n    if (k !== N - i || burn !== (i ? 1 : 0)) throw new Error(\"Abracadabra form is off at line \" + i);\n  }\n  if (WORD[F.last] !== \"A\") throw new Error(\"Abracadabra does not end on an A\");\n}\n\n// ---- Time, in beats. The fever's front is at row (beat - 0.5) * 11.64, so\n// it crosses one line a beat, enters the top half a beat into the cycle and\n// leaves the foot at 11.5. The cycle is 14 beats; the last 2.5 are the heat\n// leaving under the last A and the ash crumbling. A fresh start comes in at\n// beat 2.6, with the first two lines already written and burning.\nconst CYCLE = 14, ENTER = 0.5, START = 2.6;\nconst INLINE = new Uint8Array(H);\nfor (const t of TOP) for (let r = 0; r \u003c GH; r++) INLINE[t + r] = 1;\nconst lineOf = (y) => {\n  // The line the front is going to at row y: the gap above a line counts as that line's.\n  for (let i = 0; i \u003c N; i++) if (y \u003c= TOP[i] + GH - 1) return i;\n  return N;\n};\n\nexport function setup(params) {\n  params.s = {\n    beat: START, hue: 0, form: 0, cool: 0.06, t: 0,\n    rgb: new Float32Array(NP * 3), glow: new Float32Array(NP), tmp: new Float32Array(NP),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3);\n  S.form = cl(round(k[2]), 0, 2);\n  S.cool = cl(k[3], 0, 1);\n  // One beat is 1.2 / Speed seconds: 0.6 s at 2.\n  S.beat += (d * speed) / 1.2;\n  S.t += d;\n}\n\nfunction blur(src, tmp) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (2 * src[p] + (x > 0 ? src[p - 1] : 0) + (x \u003c W - 1 ? src[p + 1] : 0)) / 4;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      src[p] = (2 * tmp[p] + (y > 0 ? tmp[p - W] : 0) + (y \u003c H - 1 ? tmp[p + W] : 0)) / 4;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, glow } = S, F = FORMS[S.form];\n  const tau = ((S.beat % CYCLE) + CYCLE) % CYCLE, Y = (tau - ENTER) * LH;\n  const hF = 0.9 + S.hue;\n  const inkF = hsv(hF + 0.58, 0.45, 0.74), ember = hsv(hF, 0.85, 1), white = hsv(hF, 0.1, 1);\n  const flare = hsv(hF + 0.2, 0.15, 1), flame = hsv(hF + 0.2, 0.75, 1);\n  const ash = hsv(hF + 0.72, 0.3, 0.34), speck = hsv(hF + 0.04, 0.7, 0.9), scorch = hsv(hF + 0.72, 0.3, 0.125);\n  // The heat in a written letter falls by a factor e every tk beats; an LED of\n  // ash lasts 2.4 + ta * (0.3 + its own number 0..1) beats after it caught.\n  const tk = 0.8 + 3.2 * S.cool, ta = 1.5 + 10 * S.cool;\n  // Embers flicker 12 times a second, each LED on its own.\n  const fl = floor(S.t * 12);\n  rgb.fill(0);\n  glow.fill(0);\n  const put = (p, c, v) => {\n    rgb[p * 3] = c[0] * v, rgb[p * 3 + 1] = c[1] * v, rgb[p * 3 + 2] = c[2] * v;\n  };\n  // Beats since the front last passed row y: this cycle's pass, or the last one's.\n  const since = (y) => {\n    const s = (Y - y) / LH;\n    return s \u003c 0 ? s + CYCLE : s;\n  };\n\n  for (const C of CELL) {\n    const Lj = F.L[C.j];\n    if (C.i > Lj) continue;\n    if (C.i \u003c Lj) {\n      // A kept letter: written hot as the front goes through it row by row,\n      // then cooling back to ink, which fades from 100% to 64% over the\n      // cycle (e every 5 beats), so the lines the fever has just written\n      // stand out from the ones it is coming to.\n      for (const p of C.pix) {\n        const s = since(floor(p / W));\n        const h = s \u003c 0.12 ? s / 0.12 : exp(-(s - 0.12) / tk), m = 0.62 + 0.38 * exp(-s / 5);\n        const ink = [inkF[0] * m, inkF[1] * m, inkF[2] * m];\n        let c;\n        if (h > 0.55) {\n          const u = (h - 0.55) / 0.45;\n          c = [ember[0] + (white[0] - ember[0]) * u, ember[1] + (white[1] - ember[1]) * u, ember[2] + (white[2] - ember[2]) * u];\n        } else {\n          const u = h / 0.55;\n          c = [ink[0] + (ember[0] - ink[0]) * u, ink[1] + (ember[1] - ink[1]) * u, ink[2] + (ember[2] - ink[2]) * u];\n        }\n        put(p, c, 255);\n        glow[p] += h;\n      }\n      continue;\n    }\n    // The letter this line leaves out burns in a colour of its own, a fifth\n    // of the wheel past the fever (amber at Hue 0): white for 0.4 beat as the\n    // front reaches it, a flickering flame for a beat, then by beat 2.4 it\n    // cools to ash, turning back round the wheel through the fever's pink so\n    // it never passes through a dim orange. Each LED then crumbles at its own\n    // time, lighting once more as it goes and leaving a scorch at 32 of 255\n    // that the next fever burns again.\n    for (const p of C.pix) {\n      const s = since(floor(p / W)), r = RND[p], life = 2.4 + ta * (0.3 + r);\n      if (s > life) put(p, scorch, 255);\n      else if (s \u003c 0.4) {\n        put(p, flare, 255);\n        glow[p] += 2;\n      } else if (s \u003c 1.4) {\n        const f = 0.45 + 0.55 * hash(p * 31 + fl);\n        put(p, flame, 255 * f);\n        glow[p] += 1.4 * f;\n      } else if (s \u003c 2.4) {\n        const u = s - 1.4;\n        put(p, hsv(hF + 0.2 - 0.48 * u, 0.75 - 0.45 * u, 1 - 0.66 * u), 255);\n        glow[p] += 0.6 * (1 - u);\n      } else if (s > life - 0.3) {\n        put(p, speck, 255 * (0.5 + 0.5 * hash(p * 7 + fl)));\n        glow[p] += 0.4;\n      } else put(p, ash, 255);\n    }\n  }\n\n  // ---- The front: a drop of heat in every column still carrying it, which\n  // is every column whose letter has not yet been left out above this row.\n  // It shows only in the dark rows between lines (inside a line the letter\n  // itself lights row by row), and the survivor's runs on off the foot.\n  const lf = lineOf(Y);\n  if (Y > -2 && Y \u003c H + 2)\n    for (let j = 0; j \u003c N; j++) {\n      if (F.L[j] \u003c lf) continue;\n      const cx = X0 + PX * j + 1.5;\n      for (let dy = -4; dy \u003c= 1; dy++) {\n        const y = floor(Y) + dy;\n        if (y \u003c 0 || y >= H || INLINE[y]) continue;\n        const v = dy > 0 ? 0.5 : exp(dy / 1.6);\n        for (const x of [floor(cx), floor(cx) + 1]) {\n          const p = y * W + x;\n          glow[p] += 1.2 * v;\n          rgb[p * 3] = max(rgb[p * 3], white[0] * 255 * v);\n          rgb[p * 3 + 1] = max(rgb[p * 3 + 1], white[1] * 255 * v);\n          rgb[p * 3 + 2] = max(rgb[p * 3 + 2], white[2] * 255 * v);\n        }\n      }\n    }\n\n  // ---- The heat off the foot: once the front has left row 127 the last of\n  // the fever spreads along the foot under the last A and fades in 2 beats.\n  const sb = (Y - H) / LH;\n  if (sb > 0 && sb \u003c 3) {\n    const xs = X0 + PX * F.last + 1.5, wdt = 4 + 12 * sb, a = exp(-sb / 1.1) * 3;\n    for (let y = H - 14; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const v = a * exp(-(((x + 0.5 - xs) / wdt) ** 2)) * exp(-(H - 0.5 - y) / (1.5 + 2.5 * sb));\n        if (v > 0.02) glow[y * W + x] += v;\n      }\n  }\n\n  // Heat glows round itself in the fever's colour.\n  blur(glow, S.tmp);\n  blur(glow, S.tmp);\n  for (let p = 0; p \u003c NP; p++) {\n    const g = min(1.6, glow[p]) * 140, o = p * 3;\n    if (g \u003c 1) continue;\n    rgb[o] += ember[0] * g, rgb[o + 1] += ember[1] * g, rgb[o + 2] += ember[2] * g;\n  }\n\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3, r = rgb[o], g = rgb[o + 1], b = rgb[o + 2];\n    if (r \u003c 1 && g \u003c 1 && b \u003c 1) continue;\n    display.setPixel(p % W, (p - (p % W)) / W, min(255, r) | 0, min(255, g) | 0, min(255, b) | 0);\n  }\n}\n","airy-beam":"// ===== Patternflow pattern =====\n// Title:   Airy Beam\n// Family:  wave\n// Idea:    A finite-energy Airy beam enters at the top and runs down the panel, its main lobe and the side lobes beside it bending together along parabolas while the field's phase runs along them as a green and blue tint, and a small bead drifting back and forth near the top blocks a lobe that grows back further down.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the nonspreading Airy wave packet (Michael Berry and Nandor Balazs, 1979), finite-energy accelerating Airy beams (Georgios Siviloglou, John Broky, Aristide Dogariu and Demetrios Christodoulides, 2007), self-healing Airy beams (John Broky, Georgios Siviloglou, Aristide Dogariu and Demetrios Christodoulides, 2008), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Truncation=0.04..0.4, Tilt=-1..1\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the beam is cyan with near-white peaks, and the field's phase tints each lobe a little towards green or towards azure, the two sides of a lobe boundary always opposite. The bead is a pale stone in any hue.\n// Knob 2: Speed. The tint follows the phase turning once a second at 2 (a tenth of that at 0.2, 1.5 at 3), so green and azure run down the lobes. The bead's drift to and fro across the beam takes 9 s at 2, 90 s at 0.2 and 6 s at 3.\n// Knob 3: Truncation. The a of the launch field Ai(s) exp(a s). At 0.04 the main lobe keeps a third of its peak to the bottom row and side lobes fill everything to its left down the whole panel. At 0.15 the far lobes fade first and the bottom row's brightest point is a tenth of the top's. At 0.4 the main lobe has lost 99.7% of its light by the bottom row and what is left there is a wide glow. The brightness is set row by row against the free beam, so the spreading shows as lobes dissolving rather than as the panel going dark.\n// Knob 4: Tilt. The launch angle v = -1.25 + 1.25 Tilt, a factor exp(i v s) at launch, which shears the whole beam by v xi. At the opening 0.06 the main lobe enters at x 28, swings left to x 22 at row 38 and bends right to x 54 at the bottom. At -1 it falls to x 26 at row 80 and turns back to x 34, like a ball thrown upward. At 1 it is launched straight and bends 63 LEDs, leaving the panel at row 121.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Units. The paraxial equation i dphi/dxi + (1/2) d2phi/ds2 = 0 in\n// s = x / x0 across and xi = z / (k x0^2) down. One LED is 1/4 of s, and the\n// 128 rows run xi from 0 at row 0 (the launch plane) to 8.\nconst X0 = 4, XI = 8, DXI = XI / H;\n// The beam is worked on N points one LED apart, s from S0 = -96 to 32. At\n// any tilt the panel sees the untilted beam only between s = -13.6 and 22.2.\n// At a = 0.04 the launch field at -96 is down to 0.8% of the main lobe, and\n// the spectrum at the grid's highest wavenumber, 4 pi, to 0.2%.\nconst N = 512, S0 = -96, MASK = N - 1;\n\n// ---- FFT, radix 2, in place, the sum with exp(+2 pi i m j / N) and no 1/N.\nconst REV = new Uint16Array(N);\nfor (let i = 0, b = Math.log2(N); i \u003c N; i++) {\n  let r = 0;\n  for (let k = 0; k \u003c b; k++) r |= ((i >> k) & 1) \u003c\u003c (b - 1 - k);\n  REV[i] = r;\n}\nconst TC = new Float64Array(N / 2), TS = new Float64Array(N / 2);\nfor (let i = 0; i \u003c N / 2; i++) (TC[i] = cos((2 * PI * i) / N)), (TS[i] = sin((2 * PI * i) / N));\nfunction ifft(re, im) {\n  for (let i = 0; i \u003c N; i++) {\n    const j = REV[i];\n    if (j > i) {\n      let t = re[i];\n      (re[i] = re[j]), (re[j] = t);\n      t = im[i];\n      (im[i] = im[j]), (im[j] = t);\n    }\n  }\n  for (let len = 2; len \u003c= N; len \u003c\u003c= 1) {\n    const half = len >> 1, step = N / len;\n    for (let i = 0; i \u003c N; i += len)\n      for (let k = 0; k \u003c half; k++) {\n        const c = TC[k * step], s = TS[k * step], a = i + k, b = a + half;\n        const xr = re[b] * c - im[b] * s, xi = re[b] * s + im[b] * c;\n        (re[b] = re[a] - xr), (im[b] = im[a] - xi), (re[a] += xr), (im[a] += xi);\n      }\n  }\n}\n// Wavenumber of FFT bin m.\nconst KM = new Float64Array(N);\nfor (let m = 0; m \u003c N; m++) KM[m] = (2 * PI * (m \u003c N / 2 ? m : m - N) * X0) / N;\n\n// ---- The free-space propagator over d rows on this grid: the inverse FFT of\n// exp(-i k^2 d DXI / 2), divided by N. Convolving a field with KR/KI[d] is\n// the same as one FFT step of split-step propagation, exactly.\nconst KR = new Float32Array(H * N), KI = new Float32Array(H * N);\n{\n  const re = new Float64Array(N), im = new Float64Array(N);\n  for (let d = 1; d \u003c H; d++) {\n    for (let m = 0; m \u003c N; m++) {\n      const ph = (-KM[m] * KM[m] * d * DXI) / 2;\n      (re[m] = cos(ph) / N), (im[m] = sin(ph) / N);\n    }\n    ifft(re, im);\n    KR.set(re, d * N);\n    KI.set(im, d * N);\n  }\n}\n\n// ---- The free beam for truncation a, every row. The launch field\n// Ai(s) exp(a s) has the spectrum exp(a^3/3) exp(-a k^2) exp(i (k^3/3 - a^2 k))\n// (shift the contour of Ai's integral by i a), and each plane wave picks up\n// exp(-i k^2 xi / 2) on the way down. Checked against a power series of Ai\n// at a = 0.04: row 0 gives 0.355028 at s = 0, 0.514561 at -1, -0.335979 at\n// -3 and 0.026987 at -10, all within 1e-5; row 64 agrees with a direct\n// O(N^2) transform of row 0 to five places.\nfunction freeBeam(S, a) {\n  const re = new Float64Array(N), im = new Float64Array(N), c = (X0 / N) * exp((a * a * a) / 3);\n  for (let r = 0; r \u003c H; r++) {\n    const xi = r * DXI;\n    for (let m = 0; m \u003c N; m++) {\n      const k = KM[m], amp = c * exp(-a * k * k), ph = (k * k * k) / 3 - a * a * k + k * S0 - (k * k * xi) / 2;\n      (re[m] = amp * cos(ph)), (im[m] = amp * sin(ph));\n    }\n    ifft(re, im);\n    let peak = 0;\n    for (let j = 0; j \u003c N; j++) peak = max(peak, re[j] * re[j] + im[j] * im[j]);\n    S.FR.set(re, r * N);\n    S.FI.set(im, r * N);\n    S.RM[r] = peak;\n  }\n  S.a = a;\n}\n\n// Main lobe of Ai at s = -1.0188, the first maximum.\nconst A1 = -1.0188;\n// The bead: its row, its half width in LEDs, and its drift about the main\n// lobe, from 6 LEDs right of it to 11 left. Set squarely on the main lobe at\n// a = 0.04 it leaves the lobe 20% of the free beam's intensity 8 rows below,\n// 47% by row 60 and 62% by row 80: the side lobes feed it back. It never\n// heals all the way, since the bead keeps what it took.\nconst OBS_ROW = 22, OBS_W = 2.6, OBS_MID = -2.5, OBS_AMP = 8.5, OBS_T = 9;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, a: -1, v: 0,\n    FR: new Float32Array(H * N), FI: new Float32Array(H * N), RM: new Float32Array(H),\n    I: new Float32Array(W * H), C: new Float32Array(W * H), rgb: new Float32Array(W * H * 3),\n    ub: new Int32Array(16), ur: new Float32Array(16), ui: new Float32Array(16), GR: new Float32Array(W + 1), GI: new Float32Array(W + 1),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.04, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.t += (d * cl(k[1], 0.2, 3)) / 2;\n  // Steps of 0.0025 in a, so a knob held still never rebuilds the beam. A\n  // rebuild is 128 FFTs, about 13 ms in Node; the propagator table above is\n  // as many again, once at load. A frame after that is about 1.4 ms.\n  const a = Math.round(cl(k[2], 0.04, 0.4) * 400) / 400;\n  if (a !== S.a) freeBeam(S, a);\n  S.v = -1.25 + 1.25 * cl(k[3], -1, 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.a \u003c 0) return;\n  const { FR, FI, RM, I, C, rgb, ub, ur, ui, GR, GI, v } = S;\n  // The main lobe runs along s = A1 + v xi + xi^2 / 4 in the panel's frame.\n  // The middle of its range across the panel sits at x = 38.\n  let lo = A1, hi = A1;\n  for (let r = 0; r \u003c H; r++) {\n    const xi = r * DXI, s = A1 + v * xi + (xi * xi) / 4;\n    (lo = min(lo, s)), (hi = max(hi, s));\n  }\n  const sL = (lo + hi) / 2 - 38 / X0;\n  // The beam's own grid point under LED x of row r is x + off(r): the tilt\n  // is the shear s -> s + v xi of the untilted beam.\n  const off = (r) => (sL - S0) * X0 - v * r * DXI * X0;\n\n  // ---- The bead and the light it takes out, on the beam's grid.\n  const xio = OBS_ROW * DXI, xm = (A1 + v * xio + (xio * xio) / 4 - sL) * X0;\n  const co = xm + OBS_MID + OBS_AMP * sin((2 * PI * S.t) / OBS_T);\n  const jc = co + off(OBS_ROW);\n  let nb = 0;\n  for (let j = Math.ceil(jc - OBS_W - 0.5); j \u003c= floor(jc + OBS_W + 0.5); j++) {\n    const b = cl(OBS_W + 0.5 - Math.abs(j - jc), 0, 1);\n    if (b \u003c= 0) continue;\n    const q = OBS_ROW * N + (j & MASK);\n    (ub[nb] = j), (ur[nb] = b * FR[q]), (ui[nb] = b * FI[q]), nb++;\n  }\n\n  // ---- The field at every LED: the free beam minus what the bead took out,\n  // carried down by the propagator, on the 65 grid points under the row,\n  // then linear between the two either side of each LED.\n  const wc = cos(2 * PI * S.t), ws = sin(2 * PI * S.t);\n  for (let r = 0; r \u003c H; r++) {\n    const o = off(r), jb = floor(o), f = o - jb, d = r - OBS_ROW, kb = d * N;\n    for (let e = 0; e \u003c= W; e++) {\n      const j = jb + e, q = r * N + (j & MASK);\n      let pr = FR[q], pi = FI[q];\n      if (d > 0)\n        for (let n = 0; n \u003c nb; n++) {\n          const kk = kb + ((j - ub[n]) & MASK), kr = KR[kk], ki = KI[kk];\n          pr -= kr * ur[n] - ki * ui[n];\n          pi -= kr * ui[n] + ki * ur[n];\n        }\n      else if (d === 0) {\n        const b = 1 - cl(OBS_W + 0.5 - Math.abs(j - jc), 0, 1);\n        (pr *= b), (pi *= b);\n      }\n      (GR[e] = pr), (GI[e] = pi);\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const fr = GR[x] + f * (GR[x + 1] - GR[x]), fi = GI[x] + f * (GI[x + 1] - GI[x]);\n      const ii = fr * fr + fi * fi, p = r * W + x;\n      I[p] = ii;\n      C[p] = ii > 1e-12 ? (fr * wc + fi * ws) / sqrt(ii) : 0;\n    }\n  }\n\n  // ---- Light. Brightness is intensity over the geometric mean of 0.25 and\n  // the free beam's brightest point in that row, to the power 0.55: a row\n  // whose free beam peaks 100 times below 0.25 is drawn as if 10 times\n  // below. The tint is cos(phase - 2 pi t), 0.05 of the wheel either way.\n  for (let r = 0; r \u003c H; r++) {\n    const ref = sqrt(0.25 * RM[r]);\n    for (let x = 0; x \u003c W; x++) {\n      const p = r * W + x, val = min(1, Math.pow(I[p] / ref, 0.55));\n      hsv(0.5 + S.hue + 0.05 * C[p], 1 - 0.55 * val * val, val, rgb, p * 3);\n    }\n  }\n  // The bead: a pale stone, lit on top by the light that falls on it from\n  // three rows up.\n  for (let y = OBS_ROW - 2; y \u003c= OBS_ROW + 1; y++)\n    for (let x = floor(co - OBS_W - 1); x \u003c= co + OBS_W + 1; x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const dx = (x + 0.5 - co) / (OBS_W + 0.6), dy = (y + 0.5 - (OBS_ROW - 0.2)) / 1.9, rr = dx * dx + dy * dy;\n      if (rr > 1) continue;\n      const lit = min(1, sqrt(I[max(0, OBS_ROW - 3) * W + x] / 0.15)), sh = 0.3 + 0.25 * (1 - rr) + 0.45 * lit * (dy \u003c 0 ? 1 : 0.4);\n      hsv(0.08 + S.hue, 0.15, sh, rgb, (y * W + x) * 3);\n    }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p % W, floor(p / W), (rgb[p * 3] * 255) | 0, (rgb[p * 3 + 1] * 255) | 0, (rgb[p * 3 + 2] * 255) | 0);\n}\n","damask":"// ===== Patternflow pattern =====\n// Title:   Damask\n// Family:  type\n// Idea:    A cloth of one ivory thread woven at one LED per crossing carries a big word in warp-faced satin on a weft-faced satin ground, so only the light tells letter from ground, and as a low lamp walks round the table the word flips from brighter than the cloth to darker than it and back.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: damask weave (figure in warp-faced satin on a weft-faced satin ground of the same thread), five-end satin, anisotropic thread sheen (James Kajiya and Timothy Kay, 1989), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Lamp=0..1\n//\n// Knob 1: Hue. The colour of the one thread, always pale: linen ivory at 0, mint at 0.25, a cold blue at 0.5 and rose at 0.75.\n// Knob 2: Speed. How fast the lamp walks round the table: once in 64 s at 2, so the word turns from light to dark every 16 s; 43 s at 3 and over ten minutes at 0.2. The low swells under the cloth keep the same clock.\n// Knob 3: Word. What the cloth says: LUX, the Hangul syllable 빛 (light), NOX, or 밤 (night). Each word is woven with the stem width that makes it 10 to 11% of the cloth: 4.0 LEDs for LUX, 3.3 to 3.5 for the others.\n// Knob 4: Lamp. How high the lamp stands: at 0.06 it rakes the cloth from 8 degrees up, the word is sharp and every swell in the cloth shows; towards 1 it climbs to 68 degrees, both threads catch the light alike, the swells flatten out and the word sinks into the cloth.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, sqrt, cos, sin, tan, min, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The weave. The warp runs down the panel (one end per column), the weft\n// across (one pick per row), and each LED is one crossing: lit by whichever\n// thread lies on top there. The ground is a five-end weft-faced satin with\n// move number 2: the warp comes up where (y + 2x) mod 5 = 0, once in every\n// five crossings of each row and each column, and never next to another\n// binding point across or down (the four neighbours give 1, 2, 3, 4 mod 5).\n// The figure is the back of the same cloth: at every crossing the other\n// thread is on top, so the word is warp-faced satin whose weft binding points\n// sit exactly where the ground's warp binding points would be.\nconst groundWarp = (x, y) => (y + 2 * x) % 5 === 0;\n\n// ---- Letters, as strokes in a box one cap height tall: [x0, y0, x1, y1, w],\n// w the weight (1 a stem, 0.72 a hairline, 0.62 a serif). The capitals are\n// a plain roman with thick and thin strokes and bar serifs; the Hangul is one\n// weight.\nfunction arc(cx, cy, rx, ry, a0, a1, n, w0, w1) {\n  const out = [];\n  for (let i = 0; i \u003c n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n, b = a0 + ((a1 - a0) * (i + 1)) / n, m = (a + b) / 2;\n    out.push([cx + rx * cos(a), cy + ry * sin(a), cx + rx * cos(b), cy + ry * sin(b), w0 + (w1 - w0) * abs(cos(m))]);\n  }\n  return out;\n}\nconst SERIF = 0.62, HAIR = 0.72;\nconst GLYPH = {\n  L: { w: 0.78, s: [[0.17, 0, 0.17, 1, 1], [0.17, 0.985, 0.9, 0.985, HAIR], [0, 0.015, 0.36, 0.015, SERIF], [0, 0.985, 0.2, 0.985, SERIF], [0.9, 1, 0.92, 0.8, SERIF]] },\n  U: {\n    w: 0.96,\n    s: [[0.17, 0, 0.17, 0.64, 1], [0.83, 0, 0.83, 0.64, HAIR], [0, 0.015, 0.36, 0.015, SERIF], [0.68, 0.015, 1, 0.015, SERIF], ...arc(0.5, 0.64, 0.33, 0.345, 0, PI, 8, HAIR, 1)],\n  },\n  X: { w: 0.98, s: [[0.1, 0, 0.9, 1, 1], [0.88, 0, 0.12, 1, HAIR], [-0.04, 0.015, 0.3, 0.015, SERIF], [0.72, 0.015, 1.04, 0.015, SERIF], [-0.04, 0.985, 0.28, 0.985, SERIF], [0.7, 0.985, 1.04, 0.985, SERIF]] },\n  N: { w: 0.96, s: [[0.13, 0, 0.13, 1, HAIR], [0.13, 0, 0.87, 1, 1], [0.87, 0, 0.87, 1, HAIR], [-0.02, 0.015, 0.16, 0.015, SERIF], [0.7, 0.015, 1.02, 0.015, SERIF], [-0.02, 0.985, 0.3, 0.985, SERIF]] },\n  O: { w: 1, s: arc(0.5, 0.5, 0.4, 0.49, 0, 2 * PI, 20, HAIR, 1) },\n};\n// Hangul syllables in a box 1 wide and 1.75 tall: the initial ㅂ top left,\n// the vowel on the right, the final consonant under both.\nconst B = [[0.1, 0.04, 0.1, 0.86, 1], [0.58, 0.04, 0.58, 0.86, 1], [0.1, 0.45, 0.58, 0.45, 1], [0.08, 0.86, 0.6, 0.86, 1]];\nconst HANGUL = {\n  빛: [...B, [0.86, 0, 0.86, 1.02, 1], [0.5, 1.04, 0.5, 1.2, 1], [0.14, 1.24, 0.86, 1.24, 1], [0.5, 1.28, 0.12, 1.71, 1], [0.38, 1.45, 0.88, 1.71, 1]],\n  밤: [...B, [0.8, 0, 0.8, 1.02, 1], [0.8, 0.46, 0.98, 0.46, 1], [0.16, 1.16, 0.84, 1.16, 1], [0.84, 1.16, 0.84, 1.7, 1], [0.84, 1.7, 0.16, 1.7, 1], [0.16, 1.7, 0.16, 1.16, 1]],\n};\n\n// Each word as strokes in panel LEDs. LUX and NOX stand one letter above\n// another, caps 28 tall from rows 8, 50 and 92; a Hangul syllable is 48 wide\n// and 84 tall, centred.\nfunction wordStrokes(word) {\n  const out = [];\n  if (HANGUL[word]) {\n    const s = 48, x0 = 32 - s / 2, y0 = 64 - (1.75 * s) / 2;\n    for (const [a, b, c, d, w] of HANGUL[word]) out.push([x0 + a * s, y0 + b * s, x0 + c * s, y0 + d * s, w]);\n    return out;\n  }\n  const cap = 28;\n  [...word].forEach((ch, i) => {\n    const g = GLYPH[ch], x0 = 32 - (g.w * cap) / 2, y0 = 8 + 42 * i;\n    for (const [a, b, c, d, w] of g.s) out.push([x0 + a * cap, y0 + b * cap, x0 + c * cap, y0 + d * cap, w]);\n  });\n  return out;\n}\n\nfunction segDist(px, py, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l2 = dx * dx + dy * dy;\n  const t = l2 > 0 ? cl(((px - s[0]) * dx + (py - s[1]) * dy) / l2, 0, 1) : 0;\n  const ex = px - s[0] - t * dx, ey = py - s[1] - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// A crossing is figure when its centre lies within half a stroke's width of\n// the stroke. The stem width is found by halving until the word covers its\n// share of the 8192 crossings (SHARE), so each word keeps about the same\n// balance of figure and ground whatever its stroke length. Done once per word,\n// the first time the Word knob lands on it: 2 to 15 ms in Node.\nconst WORDS = [\"LUX\", \"빛\", \"NOX\", \"밤\"];\nconst SHARE = [0.104, 0.115, 0.104, 0.115];\nfunction figureMask(word, share) {\n  const st = wordStrokes(word), near = new Float32Array(NP).fill(1e9);\n  // For each crossing, the stem width at which it would just fall inside.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 1e9;\n      for (const s of st) r = min(r, segDist(x + 0.5, y + 0.5, s) / s[4]);\n      near[y * W + x] = r;\n    }\n  let lo = 0.5, hi = 12;\n  for (let k = 0; k \u003c 30; k++) {\n    const mid = (lo + hi) / 2;\n    let n = 0;\n    for (let p = 0; p \u003c NP; p++) if (near[p] \u003c mid / 2) n++;\n    if (n / NP > share) hi = mid;\n    else lo = mid;\n  }\n  const m = new Uint8Array(NP);\n  for (let p = 0; p \u003c NP; p++) m[p] = near[p] \u003c lo / 2 ? 1 : 0;\n  return m;\n}\nconst MASKS = [];\n\n// Which thread is on top at each crossing: 1 warp, 0 weft.\nfunction topThreads(mask) {\n  const t = new Uint8Array(NP);\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) t[y * W + x] = groundWarp(x, y) ? 1 - mask[y * W + x] : mask[y * W + x];\n  return t;\n}\n\n// Linen is not even: each warp end and each weft pick has its own lustre,\n// between 0.95 and 1, so the floats show faint streaks along their threads.\nfunction hash(n) {\n  let h = Math.imul(n ^ 0x9e3779b9, 0x85ebca6b) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nconst WARP = Float32Array.from({ length: W }, (_, x) => 0.95 + 0.05 * hash(x + 11));\nconst WEFT = Float32Array.from({ length: H }, (_, y) => 0.95 + 0.05 * hash(y + 977));\n\n// ---- The lamp. It stands 300 LEDs from the middle of the cloth and walks\n// round it; its elevation at the middle is set by the Lamp knob. A float\n// lying along T, seen from straight above and lit from the unit direction L,\n// shines as (1 - (T.L)^2)^(P/2) (Kajiya and Kay's fibre highlight with the\n// eye overhead, where T.V = 0), times a peak level of 232. P is 4 here, so\n// the sheen is the square of 1 - (T.L)^2. A warp float (T down the\n// panel) is brightest with the lamp to its side, a weft float with the lamp\n// above or below the panel, so the two systems trade places every quarter\n// turn of the lamp.\nconst R = 300, PEAK = 232;\n// The lamp starts 28.1 degrees short of due right of the cloth and walks\n// 5.625 degrees a second at Speed 2, so at 5 s it stands square to the\n// warp. Checked over every crossing and frame from 2 s to 8 s: the lamp is\n// never more than 30.5 degrees off square, and with the swell below a weft\n// float never rises above 17.6 of 255 (under the 24 that counts as lit), a\n// warp float never falls below 92, and the word stays bright on a dark\n// ground. The two sheens are equal where dx^2 = dy^2: a straight line at 45\n// degrees through the foot of the lamp, which crosses the cloth from the\n// bottom right corner at 10.7 s to the top left at 15.3 s and passes the\n// middle at 13 s. The word vanishes along that line and comes back dark.\nconst A0 = (-28.125 * PI) / 180, RATE = (5.625 * PI) / 180;\n\n// ---- The swell. The cloth is not quite flat: two low swells run under it,\n// like a tablecloth lifting in a draught. Each is [direction in radians from\n// the x axis, wavelength in LEDs, speed in LEDs a second at Speed 2, the\n// steepest slope it gives]. A tilt changes how much light the cloth takes\n// from the lamp: with the surface normal (-gx, -gy, 1) and D the way to the\n// lamp, the light goes as N.D / D.z = 1 - (gx dx + gy dy) / hz. With the\n// lamp 8 degrees up, D runs about 7.3 LEDs across for each one up, so a\n// slope of 0.03 toward it dims or brightens the threads by 22%; with the\n// lamp 68 degrees up, by 1%, so the swell shows only in raking light, as\n// folds do. At Speed 2 the swells pass each crossing every 6 and 5.6 s,\n// and from 2 s to 8 s they scale the light by 0.62 to 1.39.\nconst SWELL = [[0.15, 36, 6, 0.03], [0.9, 28, 5, 0.02]].map(([a, l, v, g]) => ({ ux: cos(a), uy: sin(a), k: (2 * PI) / l, w: (2 * PI * v) / l, g }));\n\nexport function setup(params) {\n  params.s = { a: A0, t: 0, hue: 0, word: 0, lamp: 0.06, top: null, wordShown: -1 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const clock = (d * cl(k[1], 0.2, 3)) / 2;\n  S.a += RATE * clock;\n  S.t += clock;\n  S.word = cl(round(k[2]), 0, 3);\n  S.lamp = cl(k[3], 0, 1);\n  if (S.wordShown !== S.word) {\n    if (!MASKS[S.word]) MASKS[S.word] = figureMask(WORDS[S.word], SHARE[S.word]);\n    S.top = topThreads(MASKS[S.word]);\n    S.wordShown = S.word;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.top) return;\n  const top = S.top;\n  // Elevation 8 degrees at Lamp 0.06, 68 at 1.\n  const elev = ((4 + 64 * S.lamp) * PI) / 180, hz = R * tan(elev);\n  const lx = 32 + R * cos(S.a), ly = 64 - R * sin(S.a);\n  const c = hsv(0.115 + S.hue, 0.36, 1);\n  for (let y = 0; y \u003c H; y++) {\n    const dy = ly - (y + 0.5);\n    for (let x = 0; x \u003c W; x++) {\n      const dx = lx - (x + 0.5), inv = 1 / (dx * dx + dy * dy + hz * hz);\n      let gx = 0, gy = 0;\n      for (const w of SWELL) {\n        const q = w.g * cos(w.k * (w.ux * x + w.uy * y) - w.w * S.t);\n        gx += q * w.ux;\n        gy += q * w.uy;\n      }\n      const lit = 1 - (gx * dx + gy * dy) / hz;\n      const p = y * W + x;\n      // T.L squared: dy^2 / |D|^2 for a warp float, dx^2 / |D|^2 for a weft.\n      let s, f;\n      if (top[p]) (s = 1 - dy * dy * inv), (f = WARP[x]);\n      else (s = 1 - dx * dx * inv), (f = WEFT[y]);\n      const v = PEAK * f * s * s * (lit > 0 ? lit : 0);\n      display.setPixel(x, y, round(v * c[0]), round(v * c[1]), round(v * c[2]));\n    }\n  }\n}\n","durer-alphabet":"// ===== Patternflow pattern =====\n// Title:   Dürer's Alphabet\n// Family:  type\n// Idea:    Two ruled squares stand one above the other, and in each in turn a Roman capital is constructed by Dürer's method, its stems a tenth of the square, a travelling pen ruling the stem edges and sweeping compass arcs for the bowls and serif brackets, then ivory ink runs through the body, the paper lights up around it, and the plate holds while the next letter is drawn in the other square.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Roman capitals constructed with ruler and compass in a square, Underweysung der Messung (Albrecht Dürer, 1525), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Letter=0..12, Stem=0.1..0.2\n//\n// Knob 1: Hue. Turns the plate round the wheel: at 0 the ink is ivory, the construction lines pale teal and the paper deep blue; at 0.5 the ink is pale blue, the lines salmon and the paper dark amber.\n// Knob 2: Speed. At 2 a letter takes 8 s: 4 s of ruler and compass, 1.6 s for the ink to run through the body, 1 s for the paper, so each finished plate stands about 9 s. At 0.2 it is ten times slower.\n// Knob 3: Letter. Which of the thirteen capitals A C D E H I L M N O T V X comes first; the rest follow in that order and wrap round. At 0 the panel opens on a finished A with the C being ruled below it.\n// Knob 4: Stem. The thick stroke as a share of the square's side. At 0.1 it is Dürer's tenth, 5.9 LEDs; at 0.2 the letters are twice as heavy, and the thin strokes, the serif brackets and the bowls' counters follow.\n\nconst W = 64, H = 128, SH = 64, NL = 4096;\nconst { floor, round, min, max, sqrt, sin, cos, tan, acos, atan2, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The square. Each sheet is 64 rows; its square runs from LED centre\n// 2.5 to 61.5, so the outline sits on whole LEDs and the side is 59. Letters\n// are written in units of a tenth of the side (u right, v down, 0..10): one\n// unit is 5.9 LEDs, and at Stem 0.1 one unit is the thick stroke, the\n// proportion Dürer gives. The thin stroke is a third of the thick one, which\n// is how Alan Hoenig's METAFONT reading of the rules has it (TUGboat 11:3).\n// The centres of the bowls and the serif brackets are this pattern's own.\nconst S0 = 2.5, UN = 5.9;\nconst toX = (u) => S0 + u * UN;\n\n// Clip the infinite line through a and b to the square: a ruler line.\nfunction ruled(a, b) {\n  const d = [b[0] - a[0], b[1] - a[1]];\n  let t0 = -1e9, t1 = 1e9;\n  for (let k = 0; k \u003c 2; k++) {\n    if (abs(d[k]) \u003c 1e-9) continue;\n    const p = (0 - a[k]) / d[k], q = (10 - a[k]) / d[k];\n    t0 = max(t0, min(p, q));\n    t1 = min(t1, max(p, q));\n  }\n  return { k: 0, a: [a[0] + d[0] * t0, a[1] + d[1] * t0], b: [a[0] + d[0] * t1, a[1] + d[1] * t1] };\n}\n\n// ---- The capitals. Each is a union of convex polygons (k 0), rings (k 1:\n// inside one disk, outside its hole disks, on the right side of its clip\n// lines) and serif brackets (k 2: the kite between the corner, the two\n// tangent points and the compass centre, less the compass disk). Building a\n// letter also lists its construction: ruler lines (k 0) and compass arcs\n// (k 1), in the order they are drawn.\nfunction build(ch, w) {\n  const t = w / 3, r = 0.6 + 0.25 * w, P = [], G = [], ends = new Set();\n  const poly = (pts) => P.push({ k: 0, pts });\n  const edgeAt = (e, v) => e[0][0] + ((e[1][0] - e[0][0]) * (v - e[0][1])) / (e[1][1] - e[0][1]);\n  const hwOf = (dx, th) => (th / 2) * sqrt(dx * dx + 100) / 10;\n  // A straight stroke over the full height: centre ut on the cap line, ub on\n  // the base line, th thick across. Thick ones are ruled along both edges,\n  // thin ones along the middle.\n  const stroke = (ut, ub, th, v0 = 0, v1 = 10) => {\n    const hw = (th / 2) * sqrt((ub - ut) ** 2 + (v1 - v0) ** 2) / (v1 - v0);\n    const s = { L: [[ut - hw, v0], [ub - hw, v1]], R: [[ut + hw, v0], [ub + hw, v1]], c: [[ut, v0], [ub, v1]] };\n    poly([s.L[0], s.R[0], s.R[1], s.L[1]]);\n    if (th > 0.6 * w) G.push(ruled(s.L[0], s.L[1]), ruled(s.R[0], s.R[1]));\n    else G.push(ruled(s.c[0], s.c[1]));\n    return s;\n  };\n  // A horizontal thin bar, ruled along its middle.\n  const bar = (u0, u1, v0, v1) => {\n    poly([[u0, v0], [u1, v0], [u1, v1], [u0, v1]]);\n    G.push(ruled([0, (v0 + v1) / 2], [10, (v0 + v1) / 2]));\n  };\n  // A serif on stroke s: end 1 its foot on the base line, 0 its head on the\n  // cap line; sides 1 left, 2 right, 3 both. A thin bar runs along the line\n  // and a quarter-round bracket joins it to each edge. On a slanted stroke\n  // the acute side's bracket comes out longer, tangent length r / tan(half\n  // the angle).\n  const serif = (s, end, sides) => {\n    const vb = end ? s.L[1][1] : s.L[0][1], vq = end ? vb - t : vb + t;\n    let bl = max(edgeAt(s.L, vb), edgeAt(s.L, vq)), br = min(edgeAt(s.R, vb), edgeAt(s.R, vq));\n    for (let side = 0; side \u003c 2; side++) {\n      if (!(sides & (side + 1))) continue;\n      const e = side ? s.R : s.L, p = [edgeAt(e, vq), vq], d1 = [side ? 1 : -1, 0];\n      let d2 = end ? [e[0][0] - e[1][0], e[0][1] - e[1][1]] : [e[1][0] - e[0][0], e[1][1] - e[0][1]];\n      const n = Math.hypot(d2[0], d2[1]);\n      d2 = [d2[0] / n, d2[1] / n];\n      // A very acute corner would throw the bracket far out, so its\n      // tangent length stops at 1.9 units and the radius shrinks to match.\n      const h = acos(cl(d1[0] * d2[0] + d1[1] * d2[1], -1, 1)) / 2, tl = min(r / tan(h), 1.9), rr = tl * tan(h), pc = tl / cos(h);\n      const bx = d1[0] + d2[0], by = d1[1] + d2[1], bn = Math.hypot(bx, by);\n      const c = [p[0] + (bx / bn) * pc, p[1] + (by / bn) * pc], T1 = [p[0] + d1[0] * tl, p[1]], T2 = [p[0] + d2[0] * tl, p[1] + d2[1] * tl];\n      P.push({ k: 2, kite: [p, T1, c, T2], c, r: rr });\n      const a1 = atan2(T1[1] - c[1], T1[0] - c[0]);\n      let da = atan2(T2[1] - c[1], T2[0] - c[0]) - a1;\n      da -= 2 * PI * round(da / (2 * PI));\n      G.push({ k: 1, c, r: rr, a0: a1, a1: a1 + da });\n      if (side) br = T1[0];\n      else bl = T1[0];\n    }\n    poly([[bl, min(vb, vq)], [br, min(vb, vq)], [br, max(vb, vq)], [bl, max(vb, vq)]]);\n    ends.add(end);\n  };\n  const circ = (c, R) => G.push({ k: 1, c, r: R, a0: -PI / 2, a1: 1.5 * PI });\n  // The O and the C: a disk of radius 5 less two disks of radius 5 - w whose\n  // centres sit w - t either side of the middle along an axis leaning 20\n  // degrees to the left, so the ring is t thick at 11 and 5 o'clock and w\n  // thick at 2 and 8.\n  const ring = (clip) => {\n    const e = w - t, ax = [-sin(0.35), -cos(0.35)], h1 = [5 + ax[0] * e, 5 + ax[1] * e, 5 - w], h2 = [5 - ax[0] * e, 5 - ax[1] * e, 5 - w];\n    P.push({ k: 1, o: [5, 5, 5], h: [h1, h2], clip });\n    G.push(ruled([5 - ax[0] * 5, 5 - ax[1] * 5], [5 + ax[0] * 5, 5 + ax[1] * 5]));\n    circ([5, 5], 5), circ([h1[0], h1[1]], h1[2]), circ([h2[0], h2[1]], h2[2]);\n  };\n  let s, s2;\n  switch (ch) {\n    case \"A\": {\n      const kt = 5.2, kh = hwOf(3.2, w), ut = kt - kh + hwOf(-3.4, t);\n      s2 = stroke(ut, 1.6, t), s = stroke(kt, 8.4, w);\n      const v0 = 6.3, v1 = 6.3 + t, at = (e, v) => edgeAt(e, v);\n      poly([[at(s2.c, v0), v0], [at(s.c, v0), v0], [at(s.c, v1), v1], [at(s2.c, v1), v1]]);\n      G.push(ruled([0, v0 + t / 2], [10, v0 + t / 2]));\n      serif(s2, 1, 3), serif(s, 1, 3);\n      break;\n    }\n    case \"C\":\n      ring([[-1, 0, 8.6]]);\n      break;\n    case \"D\": {\n      s = stroke(1.4 + w / 2, 1.4 + w / 2, w);\n      const c = 4.4, hc = 9.4 - w - (5 - t);\n      bar(1.4 + w, c, 0, t), bar(1.4 + w, c, 10 - t, 10);\n      P.push({ k: 1, o: [c, 5, 5], h: [[hc, 5, 5 - t]], clip: [[1, 0, -c]] });\n      circ([c, 5], 5), circ([hc, 5], 5 - t);\n      serif(s, 0, 1), serif(s, 1, 1);\n      break;\n    }\n    case \"E\": {\n      const x = 1.6 + w;\n      s = stroke(1.6 + w / 2, 1.6 + w / 2, w);\n      bar(x, 8.2, 0, t), bar(x, 7.4, 4.85 - t / 2, 4.85 + t / 2), bar(x, 8.6, 10 - t, 10);\n      poly([[8.2 - t, 0], [8.2, 0], [8.2, 1.8], [8.2 - t, 1.8]]);\n      poly([[7.4 - t, 4.15], [7.4, 4.15], [7.4, 5.55], [7.4 - t, 5.55]]);\n      poly([[8.6 - t, 8.2], [8.6, 8.2], [8.6, 10], [8.6 - t, 10]]);\n      serif(s, 0, 1), serif(s, 1, 1);\n      break;\n    }\n    case \"H\":\n      s = stroke(1.5 + w / 2, 1.5 + w / 2, w), s2 = stroke(8.5 - w / 2, 8.5 - w / 2, w);\n      bar(1.5 + w, 8.5 - w, 4.7, 4.7 + t);\n      serif(s, 0, 3), serif(s, 1, 3), serif(s2, 0, 3), serif(s2, 1, 3);\n      break;\n    case \"I\":\n      s = stroke(5, 5, w);\n      serif(s, 0, 3), serif(s, 1, 3);\n      break;\n    case \"L\":\n      s = stroke(1.8 + w / 2, 1.8 + w / 2, w);\n      bar(1.8 + w, 8.6, 10 - t, 10);\n      poly([[8.6 - t, 8.0], [8.6, 8.0], [8.6, 10], [8.6 - t, 10]]);\n      serif(s, 0, 3), serif(s, 1, 1);\n      break;\n    case \"M\": {\n      s = stroke(1.6, 1.2, t);\n      stroke(2.0, 5.0, w), stroke(8.0, 5.0, t);\n      s2 = stroke(8.4, 8.8, w);\n      serif(s, 1, 3), serif(s2, 1, 3), serif(s, 0, 1), serif(s2, 0, 2);\n      break;\n    }\n    case \"N\": {\n      s = stroke(1.6, 1.6, t), s2 = stroke(8.4, 8.4, t);\n      const hk = hwOf(6, w);\n      stroke(1.6 - t / 2 + hk, 8.4 + t / 2 - hk, w);\n      serif(s, 1, 3), serif(s, 0, 1), serif(s2, 0, 3);\n      break;\n    }\n    case \"O\":\n      ring([]);\n      break;\n    case \"T\":\n      bar(0.9, 9.1, 0, t);\n      poly([[0.9, 0], [0.9 + t, 0], [0.9 + t, 1.8], [0.9, 1.8]]);\n      poly([[9.1 - t, 0], [9.1, 0], [9.1, 1.8], [9.1 - t, 1.8]]);\n      s = stroke(5, 5, w, t, 10);\n      serif(s, 1, 3);\n      break;\n    case \"V\": {\n      const kb = 4.8, hk = hwOf(2.9, w);\n      s = stroke(1.9, kb, w), s2 = stroke(8.1, kb + hk - hwOf(-3.3, t), t);\n      serif(s, 0, 3), serif(s2, 0, 3);\n      break;\n    }\n    case \"X\":\n      s = stroke(2.0, 8.0, w), s2 = stroke(7.6, 2.4, t);\n      serif(s, 0, 3), serif(s, 1, 3), serif(s2, 0, 3), serif(s2, 1, 3);\n      break;\n  }\n  // The serif heights are ruled first, right across the square.\n  const pre = [];\n  if (ends.has(0)) pre.push(ruled([0, t], [10, t]));\n  if (ends.has(1)) pre.push(ruled([0, 10 - t], [10, 10 - t]));\n  return { P, G: pre.concat(G) };\n}\n\n// Each piece becomes a box, a list of half-planes a u + b v + c >= 0, a disk\n// it must be in, and disks it must stay out of.\nfunction compile(P) {\n  const half = (pts) => {\n    let area = 0;\n    for (let i = 0; i \u003c pts.length; i++) {\n      const a = pts[i], b = pts[(i + 1) % pts.length];\n      area += a[0] * b[1] - b[0] * a[1];\n    }\n    const sg = area > 0 ? 1 : -1, hp = [];\n    for (let i = 0; i \u003c pts.length; i++) {\n      const a = pts[i], b = pts[(i + 1) % pts.length], du = b[0] - a[0], dv = b[1] - a[1];\n      hp.push(-dv * sg, du * sg, (dv * a[0] - du * a[1]) * sg);\n    }\n    return hp;\n  };\n  return P.map((q) => {\n    let pts = q.pts || q.kite, o = null, out = [];\n    if (q.k === 1) {\n      pts = [[q.o[0] - q.o[2], q.o[1] - q.o[2]], [q.o[0] + q.o[2], q.o[1] + q.o[2]]];\n      o = [q.o[0], q.o[1], q.o[2] ** 2];\n      out = q.h.map((h) => [h[0], h[1], h[2] ** 2]);\n    } else if (q.k === 2) out = [[q.c[0], q.c[1], q.r * q.r]];\n    const us = pts.map((p) => p[0]), vs = pts.map((p) => p[1]);\n    let hp = q.k === 1 ? [] : half(pts);\n    if (q.k === 1) for (const c of q.clip) hp.push(c[0], c[1], c[2]);\n    return { u0: min(...us), u1: max(...us), v0: min(...vs), v1: max(...vs), hp, o, out };\n  });\n}\n\nfunction inside(Q, u, v) {\n  next: for (const q of Q) {\n    if (u \u003c q.u0 || u > q.u1 || v \u003c q.v0 || v > q.v1) continue;\n    const hp = q.hp;\n    for (let i = 0; i \u003c hp.length; i += 3) if (hp[i] * u + hp[i + 1] * v + hp[i + 2] \u003c -1e-12) continue next;\n    if (q.o && (u - q.o[0]) ** 2 + (v - q.o[1]) ** 2 > q.o[2]) continue;\n    for (const h of q.out) if ((u - h[0]) ** 2 + (v - h[1]) ** 2 \u003c h[2]) continue next;\n    return true;\n  }\n  return false;\n}\n\n// Distance in 1 and 1.414 steps over the 64 x 64 sheet, from every LED\n// already at 0. With a mask it only walks inside the mask, a geodesic:\n// Dijkstra with a binary heap.\nconst STEPS = [[1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1], [1, 1, 1.414], [-1, 1, 1.414], [1, -1, 1.414], [-1, -1, 1.414]];\nfunction distance(d, mask) {\n  const heap = [], key = (i) => d[heap[i]];\n  const push = (p) => {\n    heap.push(p);\n    for (let i = heap.length - 1; i > 0; ) {\n      const j = (i - 1) >> 1;\n      if (key(j) \u003c= key(i)) break;\n      const tmp = heap[i];\n      heap[i] = heap[j], heap[j] = tmp, i = j;\n    }\n  };\n  const pop = () => {\n    const top = heap[0], last = heap.pop();\n    if (heap.length) {\n      heap[0] = last;\n      for (let i = 0; ; ) {\n        const a = 2 * i + 1, b = a + 1;\n        let m = i;\n        if (a \u003c heap.length && key(a) \u003c key(m)) m = a;\n        if (b \u003c heap.length && key(b) \u003c key(m)) m = b;\n        if (m === i) break;\n        const tmp = heap[i];\n        heap[i] = heap[m], heap[m] = tmp, i = m;\n      }\n    }\n    return top;\n  };\n  const done = new Uint8Array(NL);\n  for (let p = 0; p \u003c NL; p++) if (d[p] === 0) push(p);\n  while (heap.length) {\n    const p = pop();\n    if (done[p]) continue;\n    done[p] = 1;\n    const x = p & 63, y = p >> 6;\n    for (let k = 0; k \u003c 8; k++) {\n      const xx = x + STEPS[k][0], yy = y + STEPS[k][1], c = STEPS[k][2];\n      if (xx \u003c 0 || yy \u003c 0 || xx > 63 || yy > 63) continue;\n      const q = yy * 64 + xx;\n      if ((mask && !mask[q]) || d[p] + c >= d[q]) continue;\n      d[q] = d[p] + c;\n      push(q);\n    }\n  }\n}\n\n// ---- One letter on a 64 x 64 sheet: ink coverage from 4 x 4 samples an\n// LED, when the ink reaches each LED (geodesic from the top left of the\n// body, 0..1), when the paper lights (by distance from the letter, 0..1),\n// and the construction lines with the moment the pen passes each LED.\n// A letter is worked out the first time it is needed, 5 to 10 ms in Node\n// once warm, and kept until Stem moves; the first frame works out two.\nconst SEQ = \"ACDEHILMNOTVX\";\nfunction letter(ch, w) {\n  const { P, G } = build(ch, w), Q = compile(P);\n  const cov = new Float32Array(NL), mask = new Uint8Array(NL);\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c 64; x++) {\n      let n = 0;\n      for (let j = 0; j \u003c 4; j++)\n        for (let i = 0; i \u003c 4; i++) if (inside(Q, (x + (i + 0.5) / 4 - S0) / UN, (y + (j + 0.5) / 4 - S0) / UN)) n++;\n      cov[y * 64 + x] = n / 16;\n      mask[y * 64 + x] = n >= 6 ? 1 : 0;\n    }\n  // Ink: from the masked LED nearest the top left.\n  const fill = new Float32Array(NL).fill(1e9);\n  let seed = -1, best = 1e9;\n  for (let p = 0; p \u003c NL; p++) if (mask[p] && (p >> 6) + 0.5 * (p & 63) \u003c best) (best = (p >> 6) + 0.5 * (p & 63)), (seed = p);\n  fill[seed] = 0;\n  distance(fill, mask);\n  let fm = 0;\n  for (let p = 0; p \u003c NL; p++) if (mask[p] && fill[p] > fm) fm = fill[p];\n  for (let p = 0; p \u003c NL; p++) {\n    if (!cov[p] || mask[p]) continue;\n    const x = p & 63, y = p >> 6;\n    let b = 1e9;\n    for (let j = -1; j \u003c= 1; j++) for (let i = -1; i \u003c= 1; i++) if (x + i >= 0 && x + i \u003c 64 && y + j >= 0 && y + j \u003c 64 && mask[(y + j) * 64 + x + i]) b = min(b, fill[(y + j) * 64 + x + i] + 1);\n    fill[p] = b;\n  }\n  for (let p = 0; p \u003c NL; p++) fill[p] = cov[p] ? min(1, fill[p] / (fm + 1)) : 1;\n  // Paper: distance from the body.\n  const gd = new Float32Array(NL);\n  for (let p = 0; p \u003c NL; p++) gd[p] = mask[p] ? 0 : 1e9;\n  distance(gd, null);\n  let gm = 0;\n  for (let p = 0; p \u003c NL; p++) if (inPaper(p) && gd[p] > gm) gm = gd[p];\n  for (let p = 0; p \u003c NL; p++) gd[p] = min(1, gd[p] / gm);\n  // Construction: each element gets a share of the 4 s of 0.6 plus its\n  // length over 2.5 units, so the O's outer circle takes 1.35 s at Speed 2.\n  let tot = 0;\n  const len = G.map((g) => (g.k ? g.r * abs(g.a1 - g.a0) : Math.hypot(g.b[0] - g.a[0], g.b[1] - g.a[1])));\n  len.forEach((l) => (tot += 0.6 + l / 2.5));\n  const gw = new Float32Array(NL), gt = new Float32Array(NL).fill(2);\n  let acc = 0;\n  G.forEach((g, i) => {\n    g.t0 = acc / tot;\n    acc += 0.6 + len[i] / 2.5;\n    g.t1 = acc / tot;\n    const n = max(2, round((len[i] * UN) / 0.3));\n    for (let k = 0; k \u003c= n; k++) {\n      const tt = g.t0 + ((g.t1 - g.t0) * k) / n;\n      splat(at(g, k / n), (q, wt) => {\n        if (wt \u003c 0.05) return;\n        if (wt > gw[q]) gw[q] = wt;\n        if (tt \u003c gt[q]) gt[q] = tt;\n      });\n    }\n  });\n  return { cov, fill, gd, gw, gt, G };\n}\n\n// Where element g is at s (0..1), in sheet LEDs.\nfunction at(g, s) {\n  if (g.k === 0) return [toX(g.a[0] + (g.b[0] - g.a[0]) * s), toX(g.a[1] + (g.b[1] - g.a[1]) * s)];\n  const a = g.a0 + (g.a1 - g.a0) * s;\n  return [toX(g.c[0] + g.r * cos(a)), toX(g.c[1] + g.r * sin(a))];\n}\n\n// A point split over its four nearest LEDs of the sheet, by area.\nfunction splat([px, py], f) {\n  const fx = px - 0.5, fy = py - 0.5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i, yy = iy + j;\n      if (xx >= 0 && yy >= 0 && xx \u003c 64 && yy \u003c 64) f(yy * 64 + xx, (i ? ax : 1 - ax) * (j ? ay : 1 - ay));\n    }\n}\n\n// The paper: LEDs 2..61 of the sheet, the square and its outline.\nconst inPaper = (p) => (p & 63) >= 2 && (p & 63) \u003c= 61 && p >> 6 >= 2 && p >> 6 \u003c= 61;\n\n// Paper grain: value noise on a 5 LED lattice, 0.75..1.25, the same under\n// every letter.\nconst GRAIN = new Float32Array(NL);\n{\n  const hs = (x, y) => {\n    let h = (x * 374761393 + y * 668265263) >>> 0;\n    h = Math.imul(h ^ (h >>> 13), 1274126177) >>> 0;\n    return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n  };\n  for (let p = 0; p \u003c NL; p++) {\n    const fx = (p & 63) / 5, fy = (p >> 6) / 5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n    const a = hs(ix, iy), b = hs(ix + 1, iy), c = hs(ix, iy + 1), d = hs(ix + 1, iy + 1);\n    GRAIN[p] = 0.75 + 0.5 * ((a + (b - a) * ax) * (1 - ay) + (c + (d - c) * ax) * ay);\n  }\n}\n\n// The frame every sheet keeps: the square and its two diagonals.\nconst FRAME = new Float32Array(NL);\nfor (const g of [ruled([0, 0], [10, 0]), ruled([0, 0], [0, 10]), ruled([10, 0], [10, 10]), ruled([0, 10], [10, 10]), ruled([0, 0], [10, 10]), ruled([10, 0], [0, 10])]) {\n  const n = round((Math.hypot(g.b[0] - g.a[0], g.b[1] - g.a[1]) * UN) / 0.3);\n  for (let k = 0; k \u003c= n; k++) splat(at(g, k / n), (q, wt) => (FRAME[q] = max(FRAME[q], wt)));\n}\n\n// ---- Time, in seconds at Speed 2. A letter's turn is 8 s in one sheet:\n// the old plate there goes dark in 0.8 s, from the paper's edge in to the\n// letter; 4 s of construction; the ink runs 1.6 s; the paper lights in 1 s.\n// Turns alternate between the sheets, so a finished plate stands through\n// the other sheet's whole turn. A fresh start is 2.2 s into turn 1, the\n// lower sheet, with turn 0's letter standing finished in the upper one, so\n// at Speed 2 the ink and paper of the lower plate (2.6..5.2 s) and the\n// darkening of the upper (5.8..6.6 s) both fall in the study's 2..8 s, and\n// almost every LED that changes there changes once: the study measures\n// drift 0.247 at motion 0.048, and motion over those 6 s adds up to only\n// 1.17 times the drift.\nconst TURN = 8, ER = 0.8, CN = 4, F0 = 4.8, FN = 1.6, G0 = 6.4, GN = 1, START = TURN + 2.2;\nconst L_FRAME = 0.2, L_GUIDE = 0.42, L_PAPER = 0.17;\n\nexport function setup(params) {\n  params.s = { tau: START, hue: 0, first: 0, w: 1, cache: {}, rgb: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.tau += (d * cl(k[1], 0.2, 3)) / 2;\n  S.first = cl(round(k[2]), 0, 12);\n  const w = round(cl(k[3], 0.1, 0.2) * 400) / 40;\n  if (w !== S.w) (S.w = w), (S.cache = {});\n}\n\nfunction get(S, n) {\n  if (n \u003c 0) return null;\n  const ch = SEQ[(S.first + n) % SEQ.length];\n  return S.cache[ch] || (S.cache[ch] = letter(ch, S.w));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, h = S.hue;\n  const ink = hsv(0.11 + h, 0.3, 1), line = hsv(0.5 + h, 0.55, 1), paper = hsv(0.62 + h, 0.75, 1), frame = hsv(0.56 + h, 0.35, 1), pen = hsv(0.13 + h, 0.15, 1);\n  rgb.fill(0);\n  const n = floor(S.tau / TURN);\n  for (let sh = 0; sh \u003c 2; sh++) {\n    const oy = sh * SH * W;\n    // Which letter this sheet shows and how far along it is.\n    let L, ph, erase = 0;\n    if (n % 2 === sh) {\n      ph = S.tau - n * TURN;\n      if (ph \u003c ER) (L = get(S, n - 2)), (erase = ph / ER), (ph = TURN);\n      else L = get(S, n);\n    } else (L = get(S, n - 1)), (ph = TURN);\n    const cp = (ph - ER) / CN, fp = (ph - F0) / FN, gp = (ph - G0) / GN;\n    for (let p = 0; p \u003c NL; p++) {\n      const o = (oy + p) * 3;\n      let r = FRAME[p] * L_FRAME * frame[0], g = FRAME[p] * L_FRAME * frame[1], b = FRAME[p] * L_FRAME * frame[2];\n      if (L) {\n        // Erasing goes from the paper's edge in: far paper first, the letter last.\n        const keep = erase ? 1 - cl((erase - (1 - L.gd[p]) * 0.6) / 0.4, 0, 1) : 1;\n        if (keep > 0) {\n          const gl = L.gw[p] ? L.gw[p] * cl((cp - L.gt[p]) * CN * 20, 0, 1) * L_GUIDE : 0;\n          const pa = inPaper(p) ? cl((gp - L.gd[p] * 0.75) / 0.25, 0, 1) * L_PAPER * GRAIN[p] : 0;\n          const a = L.cov[p] ? L.cov[p] * cl((fp - L.fill[p] * 0.85) / 0.15, 0, 1) : 0;\n          r = ((1 - a) * (r + gl * line[0] + pa * paper[0]) + a * ink[0]) * keep + r * (1 - keep);\n          g = ((1 - a) * (g + gl * line[1] + pa * paper[1]) + a * ink[1]) * keep + g * (1 - keep);\n          b = ((1 - a) * (b + gl * line[2] + pa * paper[2]) + a * ink[2]) * keep + b * (1 - keep);\n        }\n      }\n      rgb[o] = r, rgb[o + 1] = g, rgb[o + 2] = b;\n    }\n    // The pen, while the construction is being drawn: a bright point at the\n    // tip and, for an arc, the compass needle in its centre.\n    if (L && !erase && cp > 0 && cp \u003c 1) {\n      const e = L.G.find((q) => cp >= q.t0 && cp \u003c q.t1);\n      if (e) {\n        const s = (cp - e.t0) / (e.t1 - e.t0), [px, py] = at(e, s);\n        dot(rgb, px, py + sh * SH, 1, pen);\n        if (e.k === 1 && e.r > 1.5) dot(rgb, toX(e.c[0]), toX(e.c[1]) + sh * SH, 0.55, pen);\n      }\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p & 63, p >> 6, min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n\n// A point of light split over the four nearest LEDs, with a faint ring.\nfunction dot(rgb, x, y, a, c) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  for (let j = -1; j \u003c= 2; j++)\n    for (let i = -1; i \u003c= 2; i++) {\n      const xx = ix + i, yy = iy + j;\n      if (xx \u003c 0 || yy \u003c 0 || xx >= W || yy >= H) continue;\n      const wx = i === 0 ? 1 - ax : i === 1 ? ax : 0, wy = j === 0 ? 1 - ay : j === 1 ? ay : 0;\n      const v = a * (wx * wy + 0.12);\n      const o = (yy * W + xx) * 3;\n      rgb[o] += c[0] * v, rgb[o + 1] += c[1] * v, rgb[o + 2] += c[2] * v;\n    }\n}\n","ehrenfest-urn":"// ===== Patternflow pattern =====\n// Title:   Ehrenfest Urn\n// Family:  particle\n// Idea:    N balls start in the upper of two chambers stacked down the panel and joined by a narrow neck, and every step one ball chosen at random darts through the neck to the other side, while a strip at the foot traces the count in the upper chamber falling from N to N/2 along its expected curve and then hovering inside the binomial spread, with the time spent at each count piling up beside it into the binomial bell, and the chambers flash each time the count comes back to the state the fourth knob watches.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ehrenfest urn model (Paul and Tatjana Ehrenfest, 1907), its mean recurrence times (Mark Kac, 1947), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Balls=8..200, Watch=0..1\n//\n// Knob 1: Hue. Turns the two chambers' colours round the wheel together, nearly half a wheel apart: at 0 the balls in the upper chamber are gold and those in the lower one azure, and a ball changes colour as it goes through the neck.\n// Knob 2: Speed. Steps a second, 5 times Speed times the square root of N / 8: 10 at 2 with 8 balls, so the all-up state, 256 steps apart on average, comes back about every 26 s; 50 at 2 with 200 balls. A step's flight takes 1.8 steps' time, between 0.12 and 0.5 s.\n// Knob 3: Balls. N, 8 to 200. Turning it starts again with every ball in the upper chamber. At 8 the count drops to 4 within a second and swings by 1.4 either side; at 200 the distance to 100 halves every 69 steps, 1.4 s at Speed 2, and the count swings by 7, and the all-up state would take 2^200 steps to come back.\n// Knob 4: Watch. Which count the flash watches, from N (every ball up, the start) below 0.08 down to N/2 at 1. Kac's mean return time to count k is 2^N / C(N, k) steps: 256 for k = 8 of 8, 9.1 for k = 6 and 3.7 for k = 4, so the flash goes from rare to nearly every step. A dotted line on the trace marks the count, and a tick above the trace each visit.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, exp, abs, pow, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The vessel. Two rounded chambers 62 by 44 LEDs, the upper from row 1\n// to 44 and the lower from 51 to 94, joined by a neck 6 LEDs wide (x 29 to\n// 34) and 6 rows long. The trace takes rows 96 to 126.\nconst CH = [\n  { x0: 1, y0: 51, x1: 62, y1: 94 }, // side 0: lower\n  { x0: 1, y0: 1, x1: 62, y1: 44 }, // side 1: upper\n];\nconst NX0 = 29, NX1 = 34, NECK = 31.5;\nconst MOUTH = [52.5, 43.5]; // the row a ball passes as it leaves each chamber\n\n// Wall brightness 0..1 per LED: the outline of each rounded rectangle (corner\n// radius 5), open where the neck meets it, and the neck's two sides.\nconst WALL = new Float32Array(NP);\nfunction rrect(px, py, c) {\n  const r = 5, cx = (c.x0 + c.x1) / 2, cy = (c.y0 + c.y1) / 2, hx = (c.x1 - c.x0) / 2 - r, hy = (c.y1 - c.y0) / 2 - r;\n  const qx = abs(px - cx) - hx, qy = abs(py - cy) - hy;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n}\nfor (let y = 0; y \u003c 96; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const px = x, py = y;\n    let v = 0;\n    for (const c of CH) v = max(v, 1 - abs(rrect(px, py, c)));\n    if (x >= NX0 && x \u003c= NX1 && y >= 43 && y \u003c= 52) v = 0;\n    if ((x === NX0 - 1 || x === NX1 + 1) && y >= 44 && y \u003c= 51) v = 1;\n    WALL[y * W + x] = cl(v, 0, 1);\n  }\n// The LEDs inside either chamber or the neck.\nconst INSIDE = new Uint8Array(NP);\nfor (let y = 0; y \u003c 96; y++)\n  for (let x = 0; x \u003c W; x++)\n    INSIDE[y * W + x] = WALL[y * W + x] \u003c= 0 && (rrect(x, y, CH[0]) \u003c 0 || rrect(x, y, CH[1]) \u003c 0 || (x >= NX0 && x \u003c= NX1 && y > 44 && y \u003c 51)) ? 1 : 0;\n\n// ---- The trace. Count n of N maps to row TY1 - n / N * (TY1 - TY0): all up\n// on row 99, none up on row 126. 52 columns of history (x 0 to 51), then a\n// gap, then the time spent at each count as bars from x 54 to 63.\nconst TY0 = 99, TY1 = 126, TCOLS = 52, HX = 54, HW = 10, RUG = 97;\nconst rowOf = (n, N) => TY1 - (n / N) * (TY1 - TY0);\n\n// log C(N, k), for the binomial law the count settles to: C(N, k) / 2^N.\nfunction logC(N, k) {\n  let s = 0;\n  for (let i = 1; i \u003c= k; i++) s += log(N - k + i) - log(i);\n  return s;\n}\n\nfunction gauss() {\n  // Box-Muller from the seeded Math.random.\n  const u = 1 - Math.random(), v = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * v);\n}\n\nfunction reset(S, N) {\n  S.N = N;\n  S.n = N;\n  S.x = new Float32Array(N), S.y = new Float32Array(N), S.vx = new Float32Array(N), S.vy = new Float32Array(N);\n  S.side = new Uint8Array(N).fill(1);\n  // A flight: start time, length, and the four points start, mouth, other mouth, end.\n  S.ft = new Float32Array(N).fill(-1), S.fd = new Float32Array(N), S.fp = new Float32Array(N * 8);\n  const c = CH[1];\n  for (let i = 0; i \u003c N; i++) {\n    S.x[i] = c.x0 + 4 + Math.random() * (c.x1 - c.x0 - 8);\n    S.y[i] = c.y0 + 4 + Math.random() * (c.y1 - c.y0 - 8);\n  }\n  // Radius 3.3 at N = 8, 1.25 at 200.\n  S.r = 3.3 * pow(8 / N, 0.3);\n  // Steps per trace column: 2 at N = 8, 10 at N = 200, so the 52 columns\n  // hold 104 and 520 steps, a little over 5 relaxation times at 200.\n  S.per = max(1, round(2 * sqrt(N / 8)));\n  S.cols = [];\n  S.cur = { mn: N, mx: N, last: N, hit: 1, g: 0 };\n  S.steps = 0;\n  S.g = 0;\n  S.time = new Float64Array(N + 1);\n  S.time[N] = 1;\n  // The law the count settles to, C(N, k) / 2^N, summed into trace rows.\n  S.law = new Float64Array(H);\n  const l2 = N * log(2);\n  for (let k = 0; k \u003c= N; k++) S.law[round(rowOf(k, N))] += exp(logC(N, k) - l2);\n  S.lawMax = 0;\n  for (let y = TY0; y \u003c= TY1; y++) S.lawMax = max(S.lawMax, S.law[y]);\n  S.flash = 1;\n}\n\nfunction step(S) {\n  const N = S.N, i = floor(Math.random() * N);\n  const from = S.side[i], to = 1 - from;\n  S.side[i] = to;\n  S.n += to ? 1 : -1;\n  // Fly from wherever the ball is now through the neck to a random place in\n  // the other chamber. A ball still flying that has not yet passed the\n  // middle of the neck turns round inside the chamber it is in.\n  const p = ballAt(S, i, S.clock), c = CH[to], ox = NECK + (Math.random() - 0.5) * (NX1 - NX0 - 1.5);\n  const f = S.fp, o = i * 8, here = p[1] \u003c 48 ? 1 : 0;\n  f[o] = p[0], f[o + 1] = p[1];\n  if (here === to) (f[o + 2] = f[o + 4] = p[0]), (f[o + 3] = f[o + 5] = p[1]);\n  else (f[o + 2] = f[o + 4] = ox), (f[o + 3] = MOUTH[here]), (f[o + 5] = MOUTH[to]);\n  f[o + 6] = c.x0 + 4 + Math.random() * (c.x1 - c.x0 - 8);\n  f[o + 7] = c.y0 + 4 + Math.random() * (c.y1 - c.y0 - 8);\n  S.ft[i] = S.clock;\n  S.fd[i] = S.fly;\n  // The trace and the clock of counts.\n  const cur = S.cur, n = S.n;\n  cur.mn = min(cur.mn, n), cur.mx = max(cur.mx, n), cur.last = n;\n  S.time[n]++;\n  if (n === S.kw) (cur.hit = 1), (S.flash = 1);\n  S.steps++;\n  if (S.steps % S.per === 0) {\n    S.cols.push(cur);\n    if (S.cols.length > TCOLS - 1) S.cols.shift();\n    S.g++;\n    S.cur = { mn: n, mx: n, last: n, hit: 0, g: S.g };\n  }\n}\n\n// Where ball i is drawn at time `at`: on its flight path, or resting in its chamber.\nfunction ballAt(S, i, at) {\n  const t0 = S.ft[i];\n  if (t0 \u003c 0) return [S.x[i], S.y[i], -1];\n  const u = cl((at - t0) / S.fd[i], 0, 1), e = u * u * (3 - 2 * u), f = S.fp, o = i * 8;\n  const l1 = sqrt((f[o + 2] - f[o]) ** 2 + (f[o + 3] - f[o + 1]) ** 2), l2 = abs(f[o + 5] - f[o + 3]);\n  const l3 = sqrt((f[o + 6] - f[o + 4]) ** 2 + (f[o + 7] - f[o + 5]) ** 2), L = l1 + l2 + l3;\n  let d = e * L, k = 0;\n  if (d > l1) (d -= l1), (k = 2);\n  if (k === 2 && d > l2) (d -= l2), (k = 4);\n  const seg = k === 0 ? l1 : k === 2 ? l2 : l3, a = seg > 0 ? d / seg : 1;\n  // The third value says how far through the neck it is, 0 before, 1 after\n  // (and 1 all along for a ball turning round on its own side).\n  const thr = l1 + l2 === 0 || k === 4 ? 1 : k === 2 ? a : 0;\n  return [f[o + k] + (f[o + k + 2] - f[o + k]) * a, f[o + k + 1] + (f[o + k + 3] - f[o + k + 1]) * a, thr, u];\n}\n\nexport function setup(params) {\n  params.s = { clock: 0, acc: 0.6, hue: 0, rate: 10, fly: 0.18, kw: 8, rgb: new Float32Array(NP * 3) };\n  reset(params.s, 8);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), N = cl(round(k[2]), 8, 200), w = cl(k[3], 0, 1);\n  if (N !== S.N) reset(S, N);\n  S.kw = N - round((max(0, w - 0.08) / 0.92) * (N / 2));\n  S.rate = 5 * speed * sqrt(N / 8);\n  S.fly = cl(1.8 / S.rate, 0.12, 0.5);\n  S.clock += d;\n  S.flash *= exp(-d / 0.3);\n  // A gentle jiggle for every ball at rest: velocities relax in 0.6 s and\n  // run at about 5 LEDs a second, and the walls turn them back.\n  const sig = 9.1 * sqrt(d), r = S.r;\n  for (let i = 0; i \u003c N; i++) {\n    if (S.ft[i] >= 0) {\n      if (S.clock - S.ft[i] \u003c S.fd[i]) continue;\n      // Landed: rest where the flight ended.\n      S.x[i] = S.fp[i * 8 + 6], S.y[i] = S.fp[i * 8 + 7], S.ft[i] = -1;\n    }\n    S.vx[i] += -S.vx[i] * (d / 0.6) + sig * gauss();\n    S.vy[i] += -S.vy[i] * (d / 0.6) + sig * gauss();\n    S.x[i] += S.vx[i] * d, S.y[i] += S.vy[i] * d;\n    const c = CH[S.side[i]], a0 = c.x0 + 1.5 + r, a1 = c.x1 - 1.5 - r, b0 = c.y0 + 1.5 + r, b1 = c.y1 - 1.5 - r;\n    if (S.x[i] \u003c a0) (S.x[i] = a0), (S.vx[i] = abs(S.vx[i]));\n    if (S.x[i] > a1) (S.x[i] = a1), (S.vx[i] = -abs(S.vx[i]));\n    if (S.y[i] \u003c b0) (S.y[i] = b0), (S.vy[i] = abs(S.vy[i]));\n    if (S.y[i] > b1) (S.y[i] = b1), (S.vy[i] = -abs(S.vy[i]));\n  }\n  S.acc += d * S.rate;\n  for (let s = 0; s \u003c 40 && S.acc >= 1; s++) (S.acc -= 1), step(S);\n}\n\n// A ball: a disc of radius r with a brighter middle and a halo that falls\n// from a fifth of its brightness at the rim to nothing a radius and a half out.\nfunction disc(rgb, x, y, r, c, a) {\n  const R = 2.5 * r + 1;\n  for (let j = max(0, floor(y - R)); j \u003c= min(H - 1, floor(y + R)); j++)\n    for (let i = max(0, floor(x - R)); i \u003c= min(W - 1, floor(x + R)); i++) {\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, dd = sqrt(dx * dx + dy * dy);\n      const core = cl(r + 0.5 - dd, 0, 1) * (1 + 0.5 * exp(-(dd * dd) / (0.3 * r * r)));\n      const v = a * max(core, 0.2 * cl(1 - (dd - r) / (1.5 * r), 0, 1) ** 2);\n      if (v \u003c= 0.5) continue;\n      const o = (j * W + i) * 3;\n      rgb[o] += c[0] * v, rgb[o + 1] += c[1] * v, rgb[o + 2] += c[2] * v;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, N } = S;\n  const hT = 0.12 + S.hue, hB = hT + 0.45;\n  // Walls, band and mean line are only tinted (saturation 0.2 to 0.3): at Hue 0.5\n  // the lower colour is orange, and a dim orange would read brown.\n  const up = hsv(hT, 0.78, 1), lo = hsv(hB, 0.78, 1), pale = hsv(hT, 0.12, 1), band = hsv(hB, 0.3, 1);\n  rgb.fill(0);\n\n  // ---- Walls, flashing white on a visit to the watched count, and the\n  // inside of both chambers lit to 40 with them.\n  const fl = S.flash, wc = hsv(hB, 0.2 * (1 - fl), 1), wv = 62 + 170 * fl, fv = 40 * fl;\n  for (let p = 0; p \u003c 96 * W; p++) {\n    const v = WALL[p];\n    if (v > 0) rgb[p * 3] = wc[0] * wv * v, rgb[p * 3 + 1] = wc[1] * wv * v, rgb[p * 3 + 2] = wc[2] * wv * v;\n    else if (fv > 1 && INSIDE[p]) rgb[p * 3] = pale[0] * fv, rgb[p * 3 + 1] = pale[1] * fv, rgb[p * 3 + 2] = pale[2] * fv;\n  }\n  // ---- Balls.\n  const r = S.r;\n  for (let i = 0; i \u003c N; i++) {\n    const b = ballAt(S, i, S.clock);\n    if (b[2] \u003c 0) {\n      disc(rgb, b[0], b[1], r, S.side[i] ? up : lo, 235);\n      continue;\n    }\n    // In flight: brighter, with the colour turning in the neck and two\n    // fading copies behind it.\n    const to = S.side[i], t = b[2], c0 = to ? lo : up, c1 = to ? up : lo;\n    const c = [c0[0] + (c1[0] - c0[0]) * t, c0[1] + (c1[1] - c0[1]) * t, c0[2] + (c1[2] - c0[2]) * t];\n    // The copies are paled towards white so a dim one does not read brown.\n    for (let k = 2; k >= 0; k--) {\n      const q = ballAt(S, i, S.clock - k * 0.025), a = 0.3 * k;\n      const ck = [c[0] + (1 - c[0]) * a, c[1] + (1 - c[1]) * a, c[2] + (1 - c[2]) * a];\n      disc(rgb, q[0], q[1], r * (1 - 0.2 * k), ck, 255 * pow(0.5, k));\n    }\n  }\n\n  // ---- The trace. The binomial spread first: rows within one standard\n  // deviation sqrt(N)/2 of N/2 at 30, within two at 18.\n  const sd = sqrt(N) / 2, m = N / 2;\n  for (let y = TY0 - 1; y \u003c= TY1 + 1; y++) {\n    const n = ((TY1 - y) / (TY1 - TY0)) * N, z = abs(n - m) / sd;\n    const v = z \u003c= 1 ? 30 : z \u003c= 2 ? 18 : 0;\n    if (!v) continue;\n    for (let x = 0; x \u003c TCOLS; x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] += band[0] * v, rgb[o + 1] += band[1] * v, rgb[o + 2] += band[2] * v;\n    }\n  }\n  const put = (x, y, c, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * v), rgb[o + 1] = max(rgb[o + 1], c[1] * v), rgb[o + 2] = max(rgb[o + 2], c[2] * v);\n  };\n  // The mean N/2, dashed, and the watched count, dotted.\n  const ym = round(rowOf(m, N)), yk = round(rowOf(S.kw, N));\n  for (let x = 0; x \u003c TCOLS; x++) {\n    if (x % 4 \u003c 2) put(x, ym, band, 120);\n    if (x % 3 === 0) put(x, yk, pale, 110);\n  }\n  const cols = S.cols.concat([S.cur]);\n  // The expected count from the start, N/2 + (N/2)(1 - 2/N)^t, dim, for the\n  // columns still on the trace since the start.\n  for (let x = 0; x \u003c cols.length; x++) {\n    const t = (cols[x].g + 1) * S.per, e = m + m * pow(1 - 2 / N, t);\n    if (e - m \u003c 0.5) continue;\n    put(x, round(rowOf(e, N)), pale, 70);\n  }\n  let prev = cols.length ? cols[0].mx : N;\n  for (let x = 0; x \u003c cols.length; x++) {\n    const c = cols[x], a = round(rowOf(max(c.mx, prev), N)), b = round(rowOf(min(c.mn, prev), N));\n    for (let y = a; y \u003c= b; y++) put(x, y, up, 255);\n    if (c.hit) (put(x, RUG, pale, 255), put(x, RUG - 1, pale, 140));\n    prev = c.last;\n  }\n  // The time spent at each count, against the binomial law (bright dots).\n  let tot = 0;\n  for (let k = 0; k \u003c= N; k++) tot += S.time[k];\n  const rows = new Float64Array(H);\n  for (let k = 0; k \u003c= N; k++) rows[round(rowOf(k, N))] += S.time[k] / tot;\n  for (let y = TY0; y \u003c= TY1; y++) {\n    const len = min(HW, (rows[y] / S.lawMax) * (HW - 2)), want = (S.law[y] / S.lawMax) * (HW - 2);\n    for (let x = 0; x \u003c len - 0.3; x++) put(HX + x, y, up, 70 + 110 * min(1, len - x));\n    if (want >= 0.5) put(HX + round(want), y, pale, 230);\n  }\n\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3, R = rgb[o], G = rgb[o + 1], B = rgb[o + 2];\n    if (R \u003c 1 && G \u003c 1 && B \u003c 1) continue;\n    display.setPixel(p % W, (p - (p % W)) / W, min(255, R) | 0, min(255, G) | 0, min(255, B) | 0);\n  }\n}\n","maya-numerals":"// ===== Patternflow pattern =====\n// Title:   Maya Numerals\n// Family:  type\n// Idea:    A number five places tall is counted up in Maya numerals, the lowest place at the bottom: each new dot slides in from the right, five dots slide together and melt into a bar, and a place that fills (twenty, or eighteen in the Long Count's second place) collapses into a gold dot that climbs to the place above and leaves a shell for zero behind, so carries ripple up the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Maya place-value numerals in base 20, a dot for one, a bar for five and a shell for zero, the places written one above the other (Dresden Codex); the Long Count, whose second place counts to 18 (worked out from the Dresden Codex by Ernst Förstemann, 1880s); pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mode=0..1, Step=0..6\n//\n// Knob 1: Hue. Turns the signs round the wheel: at 0 the dots and bars are jade, the shells ivory and a dot on its way up a place gold. The faint rules between the places take the jade.\n// Knob 2: Speed. At 2 a dot slides in in 0.30 s, five dots melt into a bar in 0.40 s, a full place collapses in 0.36 s and its dot climbs in 0.42 s. Counting by one runs 1.7 numbers a second, so the second place moves about every 12 s. The opening carry is through three places at 4.8 s, or reaches 13.0.0.0.0 at 6.0 s in the Long Count. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Mode. 0 is plain base 20: every place carries at 20, four bars. It opens on 12.7.19.19.17 (top to bottom) and three counts later the carry runs up to 12.8.0.0.0. 1 is the Long Count of days: kin 20, winal 18 (18 winals of 20 days make a tun of 360 days), then 20 for the tun, katun and baktun. The winal carries when a third dot joins its three bars. It opens on 12.19.19.17.16, four days before 13.0.0.0.0, the day the Long Count reached on 21 December 2012 in the GMT correlation, and the carry runs up four places. Turning it starts the count again from that mode's opening.\n// Knob 4: Step. How much each addition adds, from 0 to 6: 1, 13, 20, 260, 360, 365 or 584. The step is written in the mode's places and its bars and dots slide in one at a time, lowest place first, each fusing and carrying as it lands. 260 is 13.0 in both modes; 360 is 18.0 in base 20 but 1.0.0 in the Long Count, one dot in the third place; 365 is 18.5 against 1.0.5; 584, the Venus period of the Dresden Codex's Venus table, is 1.9.4 against 1.11.4. At Speed 2 a step of 13 adds 0.38 times a second and 584 adds 0.22 times, moving the third place every 4.5 s.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nconst ss = (a, b, v) => ease((v - a) / (b - a));\nconst lerp = (a, b, u) => a + (b - a) * u;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Layout. Five places, the lowest at the bottom, each a cell 25.6 rows\n// tall. A numeral is bars stacked from the bottom of the glyph, one slot\n// each, and a row of up to four dots in the slot above them; the glyph is\n// centred in its cell. Zero is a shell.\nconst P = 5, CELL = H / P, CX = 32;\nconst BL = 38, BT = 4.4, SP = 6, DR = 2.8, DS = 9.5;\nconst cyOf = (p) => H - CELL * (p + 0.5);\nconst slotY = (p, n, k) => cyOf(p) + ((n - 1) / 2 - k) * SP;\nconst dotX = (i, d) => CX + (i - (d - 1) / 2) * DS;\n\n// Sprites: kind 0 dot, 1 bar, 2 shell.\nconst DOT = 0, BAR = 1, SHELL = 2;\n\n// Sprites carry a position, a size s (a bar's length as a share of BL), an\n// alpha a and g, how far the sign is tinted gold and glows.\nfunction staticPlace(out, p, b, d, a) {\n  const n = b + (d > 0 ? 1 : 0);\n  if (n === 0) out.push({ k: SHELL, x: CX, y: cyOf(p), s: 1, a, g: 0 });\n  for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: slotY(p, n, k), s: 1, a, g: 0 });\n  for (let i = 0; i \u003c d; i++) out.push({ k: DOT, x: dotX(i, d), y: slotY(p, n, b), s: 1, a, g: 0 });\n}\n\n// ---- Counting. Radix of each place: 20, or in the Long Count 20 for the\n// kin, 18 for the winal (18 winals of 20 days make a tun of 360), then 20.\nconst RADIX = [[20, 20, 20, 20, 20], [20, 18, 20, 20, 20]];\nconst STEPS = [1, 13, 20, 260, 360, 365, 584];\n// Openings, lowest place first. Base 20: 12.7.19.19.17, three counts before\n// a carry runs up three places to 12.8.0.0.0. Long Count: 12.19.19.17.16,\n// four days before 13.0.0.0.0. Counted through at Speed 2 (op times below),\n// the first lands at 4.76 s and the second at 6.00 s.\n// The steps are written in each mode's places when an addition starts:\n// 584 = 1.9.4 in base 20 (400 + 180 + 4) and 1.11.4 in the Long Count\n// (360 + 220 + 4); 365 = 18.5 against 1.0.5. Counted over 120 s at Speed 2,\n// base 20 makes 202 additions of 1 and 26 of 584; 360 makes 37 in base 20,\n// six signs each, and 202 in the Long Count, one dot each.\nconst OPEN = [[17, 19, 19, 7, 12], [16, 17, 19, 19, 12]];\n\n// Op durations in seconds at Speed 2.\nconst DUR = { side: 0.3, bar: 0.36, climb: 0.42, fuse: 0.4, carry: 0.36, pause: 0.16 };\nconst opDur = (op) => (op.k === \"in\" ? (op.from === \"below\" ? DUR.climb : op.sign === BAR ? DUR.bar : DUR.side) : DUR[op.k]);\n\nfunction reset(S) {\n  const o = OPEN[S.mode];\n  S.b = o.map((v) => floor(v / 5));\n  S.d = o.map((v) => v % 5);\n  S.q = [];\n  S.cur = null;\n  S.u = 0;\n}\n\nfunction addition(S) {\n  const R = RADIX[S.mode];\n  let n = STEPS[S.step];\n  for (let p = 0; p \u003c P && n > 0; p++) {\n    const dg = n % R[p];\n    n = floor(n / R[p]);\n    for (let i = 0; i \u003c floor(dg / 5); i++) S.q.push({ k: \"in\", p, sign: BAR, from: \"side\" });\n    for (let i = 0; i \u003c dg % 5; i++) S.q.push({ k: \"in\", p, sign: DOT, from: \"side\" });\n  }\n  S.q.push({ k: \"pause\" });\n}\n\n// What happens when an op ends: the place takes the sign, and anything it\n// sets off goes to the front of the queue.\nfunction finish(S, op) {\n  const p = op.p, R = RADIX[S.mode];\n  if (op.k === \"pause\") return;\n  if (p >= P) return;\n  const val = () => S.b[p] * 5 + S.d[p];\n  if (op.k === \"in\") {\n    if (op.sign === BAR) S.b[p]++;\n    else S.d[p]++;\n    if (S.d[p] === 5) S.q.unshift({ k: \"fuse\", p });\n    else if (val() >= R[p]) S.q.unshift({ k: \"carry\", p });\n  } else if (op.k === \"fuse\") {\n    S.d[p] -= 5;\n    S.b[p]++;\n    if (val() >= R[p]) S.q.unshift({ k: \"carry\", p });\n  } else if (op.k === \"carry\") {\n    const v = val() - R[p];\n    S.b[p] = floor(v / 5);\n    S.d[p] = v % 5;\n    S.q.unshift({ k: \"in\", p: p + 1, sign: DOT, from: \"below\" });\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, mode: 0, step: 0, b: null, d: null, q: [], cur: null, u: 0,\n    rgb: new Float32Array(NP * 3), sig: new Float32Array(NP * 3), hot: new Float32Array(NP * 3), tmp: new Float32Array(NP * 3), blr: new Float32Array(NP * 3), blh: new Float32Array(NP * 3),\n  };\n  reset(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const mode = round(cl(k[2], 0, 1)), step = cl(round(k[3]), 0, 6);\n  S.step = step;\n  if (mode !== S.mode) {\n    S.mode = mode;\n    reset(S);\n  }\n  S.u += (d * cl(k[1], 0.2, 3)) / 2;\n  for (let guard = 0; guard \u003c 64; guard++) {\n    if (!S.cur) {\n      if (!S.q.length) addition(S);\n      S.cur = S.q.shift();\n    }\n    const T = opDur(S.cur);\n    if (S.u \u003c T) break;\n    S.u -= T;\n    finish(S, S.cur);\n    S.cur = null;\n  }\n}\n\n// ---- Sprites for the frame.\nfunction sprites(S) {\n  const out = [], op = S.cur, u = op ? S.u / opDur(op) : 0;\n  for (let p = 0; p \u003c P; p++) {\n    const b = S.b[p], d = S.d[p];\n    if (!op || op.p !== p || op.k === \"pause\") {\n      staticPlace(out, p, b, d, 1);\n      continue;\n    }\n    const e = ease(u);\n    if (op.k === \"in\") {\n      const nb = op.sign === BAR ? b + 1 : b, nd = op.sign === BAR ? d : d + 1;\n      const n0 = b + (d > 0 ? 1 : 0), n1 = nb + (nd > 0 ? 1 : 0);\n      if (b + d === 0) out.push({ k: SHELL, x: CX, y: cyOf(p), s: 1 - 0.3 * e, a: 1 - e, g: 0 });\n      for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: lerp(slotY(p, n0, k), slotY(p, n1, k), e), s: 1, a: 1, g: 0 });\n      for (let i = 0; i \u003c d; i++)\n        out.push({ k: DOT, x: lerp(dotX(i, d), dotX(i, nd), e), y: lerp(slotY(p, n0, b), slotY(p, n1, nb), e), s: 1, a: 1, g: 0 });\n      // The newcomer.\n      const tx = op.sign === BAR ? CX : dotX(d, nd), ty = slotY(p, n1, b);\n      if (op.from === \"below\") {\n        // Climbing from the middle of the place below, with a fading tail.\n        const sy = cyOf(p - 1);\n        for (let tr = 4; tr >= 0; tr--) {\n          const mm = ease(u - tr * 0.06);\n          out.push({ k: DOT, x: lerp(CX, tx, mm), y: lerp(sy, ty, mm), s: 1 - tr * 0.12, a: tr ? 0.35 - tr * 0.06 : 1, g: 1 - 0.6 * ss(0.7, 1, u) });\n        }\n      } else {\n        const sx = W + (op.sign === BAR ? BL / 2 + 2 : DR + 2), mm = 1 - (1 - u) * (1 - u) * (1 - u);\n        out.push({ k: op.sign, x: lerp(sx, tx, mm), y: ty, s: 1, a: 1, g: 0.35 * (1 - u) });\n      }\n    } else if (op.k === \"fuse\") {\n      const n = b + 1;\n      for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: slotY(p, n, k), s: 1, a: 1, g: 0 });\n      // The five slide together until they touch (a chain 26 LEDs long),\n      // melt into one rod as thick as a dot, and the rod draws out to a bar.\n      const y = slotY(p, n, b), m = ss(0, 0.45, u), gap = lerp(DS, 2 * DR * 0.92, m), fade = 1 - ss(0.38, 0.6, u);\n      for (let i = 0; i \u003c 5; i++) out.push({ k: DOT, x: CX + (i - 2) * gap, y, s: 1, a: fade, g: 0.7 * m });\n      const melt = ss(0.35, 0.6, u), draw = ss(0.55, 1, u), chain = (8 * DR * 0.92 + 2 * DR) / BL;\n      if (melt > 0) out.push({ k: BAR, x: CX, y, s: lerp(chain, 1, draw), th: lerp(2 * DR, BT, draw), a: melt, g: 0.7 * (1 - draw) });\n    } else if (op.k === \"carry\") {\n      // b, d still hold the place before the carry is taken out.\n      const R = RADIX[S.mode][p], v = b * 5 + d - R, rb = floor(v / 5), rd = v % 5;\n      const n = b + (d > 0 ? 1 : 0), ga = ease(u / 0.55), cy = cyOf(p);\n      const gone = 1 - ss(0.4, 0.6, u);\n      for (let k = 0; k \u003c b; k++) out.push({ k: BAR, x: CX, y: lerp(slotY(p, n, k), cy, ga), s: 1 - 0.85 * ga, a: gone, g: ga });\n      for (let i = 0; i \u003c d; i++) out.push({ k: DOT, x: lerp(dotX(i, d), CX, ga), y: lerp(slotY(p, n, b), cy, ga), s: 1 - 0.4 * ga, a: gone, g: ga });\n      const pop = ss(0.4, 0.65, u);\n      if (pop > 0) out.push({ k: DOT, x: CX, y: cy, s: pop, a: 1, g: 1 });\n      const back = ss(0.55, 1, u);\n      if (back > 0) {\n        staticPlace(out, p, rb, rd, back);\n      }\n    }\n  }\n  // A carry off the top place climbs off the panel.\n  if (op && op.k === \"in\" && op.p >= P) {\n    for (let tr = 4; tr >= 0; tr--) {\n      const mm = ease(u - tr * 0.06);\n      out.push({ k: DOT, x: CX, y: lerp(cyOf(P - 1), -8, mm), s: 1 - tr * 0.12, a: tr ? 0.35 - tr * 0.06 : 1, g: 1 });\n    }\n  }\n  return out;\n}\n\n// ---- Drawing the signs, lit from the upper left.\nconst LX = -0.45, LY = -0.6, LZ = 0.66;\n\nfunction bead(buf, x, y, r, col, a) {\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - r - 1)); i \u003c= min(W - 1, floor(x + r + 1)); i++) {\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, dd = sqrt(dx * dx + dy * dy), cov = cl(r + 0.5 - dd, 0, 1) * a;\n      if (cov \u003c= 0) continue;\n      const nx = dx / (r + 0.3), ny = dy / (r + 0.3), nz = sqrt(max(0, 1 - nx * nx - ny * ny));\n      const lam = max(0, nx * LX + ny * LY + nz * LZ), spec = Math.pow(lam, 12);\n      const v = 0.28 + 0.72 * lam;\n      const o = (j * W + i) * 3;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = max(buf[o + c], cov * (col[c] * v + 0.6 * spec));\n    }\n}\n\nfunction rod(buf, x, y, len, th, col, a) {\n  const r = th / 2, hx = max(0, len / 2 - r);\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - hx - r - 1)); i \u003c= min(W - 1, floor(x + hx + r + 1)); i++) {\n      const dx0 = i + 0.5 - x, dy = j + 0.5 - y, dx = dx0 - cl(dx0, -hx, hx), dd = sqrt(dx * dx + dy * dy), cov = cl(r + 0.5 - dd, 0, 1) * a;\n      if (cov \u003c= 0) continue;\n      const nx = dx / (r + 0.3), ny = dy / (r + 0.3), nz = sqrt(max(0, 1 - nx * nx - ny * ny));\n      const lam = max(0, nx * LX + ny * LY + nz * LZ), spec = Math.pow(lam, 12);\n      const v = 0.28 + 0.72 * lam;\n      const o = (j * W + i) * 3;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = max(buf[o + c], cov * (col[c] * v + 0.5 * spec));\n    }\n}\n\n// The shell: an oval 21 by 12, pointed a little at the ends, with a rim,\n// a long curved slit through the middle and short teeth along both lips,\n// like a cowrie turned over. Ivory, lit from the upper left.\nfunction shell(buf, x, y, sc, col, a) {\n  const rx = 10.5 * sc, ry = 5.9 * sc;\n  for (let j = max(0, floor(y - ry - 1)); j \u003c= min(H - 1, floor(y + ry + 1)); j++)\n    for (let i = max(0, floor(x - rx - 1)); i \u003c= min(W - 1, floor(x + rx + 1)); i++) {\n      const u = (i + 0.5 - x) / rx, v = (j + 0.5 - y) / ry, au = abs(u), q = Math.pow(Math.pow(au, 1.7) + Math.pow(abs(v), 2), 1 / 2);\n      if (q > 1.1) continue;\n      const rimD = abs(q - 1) * ry * 1.1;\n      let val = cl(1.15 - rimD, 0, 1);\n      if (q \u003c 1) {\n        // Body, brighter up and left.\n        val = max(val, 0.2 + 0.28 * cl(0.5 - 0.5 * u - 0.9 * v, 0, 1));\n        // The slit: a gentle arc through the middle, dark.\n        const sv = 0.06 - 0.12 * u * u, ds = abs(v - sv) * ry;\n        if (au \u003c 0.82) {\n          if (ds \u003c 0.55) val *= 0.15;\n          // Teeth: one-LED ticks across each lip, every third column.\n          else if (ds \u003c 2 && (((i - round(x)) % 3) + 3) % 3 === 1) val = max(val, 0.85 * a);\n        }\n      }\n      val *= a * cl((1.1 - q) * 8, 0, 1);\n      const o = (j * W + i) * 3;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = max(buf[o + c], val * col[c]);\n    }\n}\n\n// A 5-tap binomial blur, across and then down, over rows y0..y1 only.\nfunction blur(src, tmp, out, y0, y1) {\n  const R = W * 3;\n  y0 = max(0, y0);\n  y1 = min(H - 1, y1);\n  for (let y = max(0, y0 - 2); y \u003c= min(H - 1, y1 + 2); y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const p = (y * W + x) * 3 + c;\n        tmp[p] = (6 * src[p] + 4 * ((x > 0 ? src[p - 3] : 0) + (x \u003c W - 1 ? src[p + 3] : 0)) + (x > 1 ? src[p - 6] : 0) + (x \u003c W - 2 ? src[p + 6] : 0)) / 16;\n      }\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const p = (y * W + x) * 3 + c;\n        out[p] = (6 * tmp[p] + 4 * ((y > 0 ? tmp[p - R] : 0) + (y \u003c H - 1 ? tmp[p + R] : 0)) + (y > 1 ? tmp[p - 2 * R] : 0) + (y \u003c H - 2 ? tmp[p + 2 * R] : 0)) / 16;\n      }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, sig, hot, tmp, blr, blh } = S;\n  const jade = hsv(0.4 + S.hue, 0.6, 1), gold = hsv(0.13 + S.hue, 0.5, 1), ivory = hsv(0.11 + S.hue, 0.18, 0.95);\n  sig.fill(0);\n  hot.fill(0);\n  // Rows the moving signs cover, so the wide glow is worked only there.\n  let h0 = H, h1 = -1;\n  for (const sp of sprites(S)) {\n    if (sp.a \u003c= 0.01) continue;\n    const g = cl(sp.g, 0, 1);\n    const col = [lerp(jade[0], gold[0], g), lerp(jade[1], gold[1], g), lerp(jade[2], gold[2], g)];\n    // Signs on the move also go into the hot buffer, which glows wider.\n    for (const [buf, a] of g > 0.02 ? [[sig, sp.a], [hot, sp.a * g]] : [[sig, sp.a]]) {\n      if (sp.k === DOT) bead(buf, sp.x, sp.y, DR * sp.s, col, a);\n      else if (sp.k === BAR) rod(buf, sp.x, sp.y, max(BT, BL * sp.s), sp.th || BT, col, a);\n      else shell(buf, sp.x, sp.y, sp.s, ivory, a);\n    }\n    if (g > 0.02) (h0 = min(h0, floor(sp.y) - 4)), (h1 = max(h1, floor(sp.y) + 4));\n  }\n  blur(sig, tmp, blr, 0, H - 1);\n  blh.fill(0);\n  if (h1 >= 0) {\n    blur(hot, tmp, blh, h0 - 4, h1 + 4);\n    hot.fill(0);\n    blur(blh, tmp, hot, h0 - 6, h1 + 6);\n  }\n  const bg = hsv(0.4 + S.hue, 0.5, 0.05);\n  for (let y = 0; y \u003c H; y++) {\n    const line = abs(((y + 0.5) % CELL) - 0.5) \u003c 0.6 && y > 2 ? 0.07 : 0;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3;\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = bg[c] + line * jade[c] + 0.85 * sig[o + c] + 0.45 * blr[o + c] + 1.4 * hot[o + c];\n    }\n  }\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n","multiple-master":"// ===== Patternflow pattern =====\n// Title:   Multiple Master\n// Family:  type\n// Idea:    The word MASTER is stored as four master outlines, light and black at condensed and extended width, all with the same points in the same order, and the big word on top is the instance made by blending the four point lists bilinearly at the weight and width of the knobs, while it wanders slowly round the knob point on the design-space square below, whose corners hold the four masters of one letter at a time.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Multiple Master fonts (Adobe, 1991; the first faces Myriad MM and Minion MM, 1992), the axis tags wght and wdth of OpenType Font Variations (2016), letters and masters drawn for this pattern, pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Weight=-1..1, Width=-1..1\n//\n// Knob 1: Hue. Turns the picture round the wheel: at 0 the word is pale azure, the design space blue and the instance dot gold.\n// Knob 2: Speed. How fast the instance wanders round the knob point and the corners change letter: at 2 the slowest part of the wander comes round in 14 s and each letter holds the corners 3 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Weight. Where the knob point sits on the weight axis, light at -1 and black at 1; the instance wanders up to 0.24 of the axis either side of it and folds back at the ends. The stems go from 1.6 LEDs to 4.1 at black condensed and 5.6 at black extended, the counters of A, R and S close up and the vertex of M lifts off the base line.\n// Knob 4: Width. The same on the width axis, condensed at -1 and extended at 1: the letters and the space between them stretch together, the top line from 29 LEDs of ink at light condensed to 55 at light extended and 58 at black extended.\n// Buttons: K3 tap leans the word 8 degrees, or stands it up again: a slant axis, whose ends differ by a shear alone.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The masters. Master m is weight (m >> 1) and width (m & 1): 0 light\n// condensed, 1 light extended, 2 black condensed, 3 black extended. Units are\n// the cap height, y up from the base line. Each letter is drawn by one\n// function from the master's numbers below, so all four come out with the\n// same contours of the same point counts; the code checks that and stops if\n// they do not. Pieces overlap (an E is a stem and three arms) and fill by\n// the nonzero rule, as OpenType variable outlines may; Type 1 MM outlines\n// could not overlap.\nconst SV = [0.072, 0.076, 0.185, 0.255]; // vertical stem\nconst SB = [0.05, 0.085, 0.042, 0.072]; // side bearing\n// Body width of each letter at the four masters, and how much of the side\n// bearing it keeps on the left and right (open sides take less).\nconst BW = {\n  M: [0.48, 0.88, 0.64, 0.94],\n  A: [0.4, 0.78, 0.52, 0.84],\n  S: [0.34, 0.62, 0.5, 0.7],\n  T: [0.36, 0.68, 0.44, 0.74],\n  E: [0.3, 0.56, 0.42, 0.62],\n  R: [0.38, 0.66, 0.5, 0.74],\n};\nconst SIDE = { M: [1, 1], A: [0.25, 0.25], S: [0.8, 0.8], T: [0.3, 0.3], E: [1, 0.6], R: [1, 0.45] };\n\nconst rect = (x0, y0, x1, y1) => [x0, y0, x1, y0, x1, y1, x0, y1];\n// A ring between two superellipses from angle a0 to a1 (degrees), n points\n// along each edge: the bowls of S and R.\nfunction ring(cx, cy, rxo, ryo, rxi, ryi, a0, a1, n, ex) {\n  const o = [], e = 2 / ex;\n  const pt = (rx, ry, a) => {\n    const c = cos((a * PI) / 180), s = sin((a * PI) / 180);\n    o.push(cx + rx * Math.sign(c) * abs(c) ** e, cy + ry * Math.sign(s) * abs(s) ** e);\n  };\n  for (let i = 0; i \u003c n; i++) pt(rxo, ryo, a0 + ((a1 - a0) * i) / (n - 1));\n  for (let i = n - 1; i >= 0; i--) pt(rxi, ryi, a0 + ((a1 - a0) * i) / (n - 1));\n  return o;\n}\n// The horizontal width of a stroke of perpendicular thickness t that rises\n// dy over dx: t * length / dy, solved with the stroke's own width in dx.\nfunction slantW(t, dx0, k, dy) {\n  let hx = t;\n  for (let i = 0; i \u003c 4; i++) {\n    const dx = dx0 - k * hx;\n    hx = (t * sqrt(dx * dx + dy * dy)) / dy;\n  }\n  return hx;\n}\n\nfunction design(ch, m) {\n  const w = m >> 1, bw = BW[ch][m], sv = SV[m], sh = sv * (w ? 0.84 : 0.92), td = sv * 0.96;\n  const c = [];\n  if (ch === \"M\") {\n    // Vertex on the base line when light; lifted 0.15 at black condensed so\n    // the two notches keep some light.\n    const vx = bw / 2, vy = [0, 0, 0.15, 0.05][m], hx = slantW(td, vx, 0, 1 - vy);\n    c.push(rect(0, 0, sv, 1), rect(bw - sv, 0, bw, 1));\n    c.push([0, 1, hx, 1, vx + hx / 2, vy, vx - hx / 2, vy]);\n    c.push([bw, 1, bw - hx, 1, vx - hx / 2, vy, vx + hx / 2, vy]);\n  } else if (ch === \"A\") {\n    // Flat apex ft wide; the bar drops as the weight rises so the counter\n    // above it is the last thing to close.\n    const ft = [0.05, 0.06, 0.12, 0.16][m], yb = [0.27, 0.27, 0.12, 0.2][m];\n    const dx = bw / 2 - ft / 2, hx = slantW(td, dx, 0, 1);\n    c.push([0, 0, hx, 0, dx + hx, 1, dx, 1]);\n    c.push([bw, 0, bw - hx, 0, bw - dx - hx, 1, bw - dx, 1]);\n    const yt = yb + sh * 0.9;\n    c.push(rect(dx * yt, yb, bw - dx * yt, yt));\n  } else if (ch === \"S\") {\n    // Two rings of superellipses, the upper a little narrower, meeting in the\n    // spine at y = 0.53, with the terminals cut at a0 degrees.\n    const mid = 0.53, a0 = [34, 30, 44, 38][m], ex = [2.2, 2.3, 2.7, 2.8][m];\n    const ryU = (1 - mid + sh / 2) / 2, ryL = (mid + sh / 2) / 2, rxU = bw * 0.47, rxL = bw * 0.5;\n    c.push(ring(bw / 2, 1 - ryU, rxU, ryU, rxU - sv, ryU - sh, a0, 270, 16, ex));\n    c.push(ring(bw / 2, ryL, rxL, ryL, rxL - sv, ryL - sh, 90, a0 - 180, 16, ex));\n  } else if (ch === \"T\") {\n    c.push(rect(0, 1 - sh, bw, 1), rect(bw / 2 - sv / 2, 0, bw / 2 + sv / 2, 1));\n  } else if (ch === \"E\") {\n    const mE = 0.52;\n    c.push(rect(0, 0, sv, 1), rect(0, 1 - sh, bw, 1), rect(0, 0, bw, sh), rect(0, mE - sh / 2, bw * 0.88, mE + sh / 2));\n  } else if (ch === \"R\") {\n    const yl = [0.44, 0.44, 0.4, 0.41][m], bowlR = bw * [0.93, 0.9, 0.94, 0.92][m];\n    const bx = sv + 0.4 * (bowlR - 2 * sv), rxo = bowlR - bx, ryo = (1 - yl) / 2, ex = [2.2, 2.3, 2.7, 2.8][m];\n    c.push(rect(0, 0, sv, 1), rect(0, 1 - sh, bx, 1), rect(0, yl, bx, yl + sh));\n    c.push(ring(bx, yl + ryo, rxo, ryo, rxo - sv, ryo - sh, 90, -90, 14, ex));\n    const top = yl + sh, lx = bx - 0.3 * td, hx = slantW(td, bw - lx, 1, top);\n    c.push([lx, top, lx + hx, top, bw, 0, bw - hx, 0]);\n  }\n  // Every contour counter-clockwise (y up), so overlapping pieces add.\n  for (const p of c) {\n    let a = 0;\n    for (let i = 0; i \u003c p.length; i += 2) {\n      const j = (i + 2) % p.length;\n      a += p[i] * p[j + 1] - p[j] * p[i + 1];\n    }\n    if (a \u003c 0) for (let i = 0, j = p.length - 2; i \u003c j; i += 2, j -= 2) [p[i], p[i + 1], p[j], p[j + 1]] = [p[j], p[j + 1], p[i], p[i + 1]];\n  }\n  const sb = SB[m];\n  return { pts: c.map((p) => Float32Array.from(p)), bw, l: sb * SIDE[ch][0], r: sb * SIDE[ch][1] };\n}\n\nconst GLYPH = {};\nfor (const ch of \"MASTER\") {\n  const ms = [0, 1, 2, 3].map((m) => design(ch, m));\n  // Same contours, same point counts, in all four masters.\n  for (const g of ms) {\n    if (g.pts.length !== ms[0].pts.length) throw new Error(\"Multiple Master: contour count differs in \" + ch);\n    g.pts.forEach((p, i) => {\n      if (p.length !== ms[0].pts[i].length) throw new Error(\"Multiple Master: point count differs in \" + ch);\n    });\n  }\n  GLYPH[ch] = ms;\n}\nconst LINES = [\"MAS\", \"TER\"];\n\n// ---- Size. The widest line at any master, with the full slant added, sets\n// the cap height: MAS at black extended is 2.65 caps of ink, plus 0.14 of\n// lean, so 62 LEDs hold a cap height of 22.\nconst SLANT = 0.14;\nfunction inkWidth(line, m) {\n  let a = 0;\n  for (const ch of line) a += GLYPH[ch][m].l + GLYPH[ch][m].bw + GLYPH[ch][m].r;\n  return a - GLYPH[line[0]][m].l - GLYPH[line[line.length - 1]][m].r;\n}\nlet widest = 0;\nfor (const line of LINES) for (let m = 0; m \u003c 4; m++) widest = max(widest, inkWidth(line, m));\nconst CAP = floor(62 / (widest + SLANT));\nconst BASE = [5 + CAP, 14 + 2 * CAP];\n\n// ---- The design-space square: width across, weight down, corners at\n// (SQ_X0, SQ_Y0) and (SQ_X0 + SQ, SQ_Y0 + SQ); the master glyphs sit\n// outside each corner, 11 LEDs high.\nconst SQ = 32, SQ_X0 = 16, SQ_Y0 = BASE[1] + 21, MCAP = 11;\n// A 3 by 5 pixel font for the four letters of the axis names.\nconst TINY = {\n  W: [\"#.#\", \"#.#\", \"###\", \"###\", \"#.#\"],\n  D: [\"##.\", \"#.#\", \"#.#\", \"#.#\", \"##.\"],\n  T: [\"###\", \".#.\", \".#.\", \".#.\", \".#.\"],\n  H: [\"#.#\", \"#.#\", \"###\", \"#.#\", \"#.#\"],\n  G: [\".##\", \"#..\", \"#.#\", \"#.#\", \".##\"],\n};\nfor (const k in TINY) TINY[k] = TINY[k].join(\"\");\n\n// ---- Fill with anti-aliased coverage. Five sub-rows a row; on each, the\n// crossings with every edge are sorted and walked with the nonzero rule,\n// and each span adds its exact horizontal overlap with every LED.\nconst SUB = 5, EDGE = new Float32Array(5 * 1200), XS = new Float32Array(256), DS = new Int8Array(256), ROW = new Float32Array(W);\nfunction fill(cov, polys, wgt) {\n  let ne = 0, ylo = 1e9, yhi = -1e9;\n  for (const p of polys)\n    for (let i = 0; i \u003c p.length; i += 2) {\n      const j = (i + 2) % p.length, y0 = p[i + 1], y1 = p[j + 1];\n      if (y0 === y1) continue;\n      const o = ne * 5;\n      EDGE[o] = p[i], EDGE[o + 1] = y0, EDGE[o + 2] = p[j], EDGE[o + 3] = y1, EDGE[o + 4] = y1 > y0 ? 1 : -1;\n      ne++;\n      ylo = min(ylo, y0, y1), yhi = max(yhi, y0, y1);\n    }\n  const r0 = max(0, floor(ylo)), r1 = min(H - 1, ceil(yhi));\n  for (let r = r0; r \u003c= r1; r++) {\n    ROW.fill(0);\n    for (let s = 0; s \u003c SUB; s++) {\n      const ys = r + (s + 0.5) / SUB;\n      let n = 0;\n      for (let e = 0; e \u003c ne; e++) {\n        const o = e * 5, y0 = EDGE[o + 1], y1 = EDGE[o + 3];\n        if (y0 \u003c y1 ? ys \u003c y0 || ys >= y1 : ys \u003c y1 || ys >= y0) continue;\n        const x = EDGE[o] + ((ys - y0) * (EDGE[o + 2] - EDGE[o])) / (y1 - y0);\n        let k = n++;\n        while (k > 0 && XS[k - 1] > x) (XS[k] = XS[k - 1]), (DS[k] = DS[k - 1]), k--;\n        XS[k] = x, DS[k] = EDGE[o + 4];\n      }\n      let wind = 0, xa = 0;\n      for (let k = 0; k \u003c n; k++) {\n        const was = wind;\n        wind += DS[k];\n        if (was === 0 && wind !== 0) xa = XS[k];\n        else if (was !== 0 && wind === 0) span(xa, XS[k]);\n      }\n    }\n    const o = r * W;\n    for (let x = 0; x \u003c W; x++) if (ROW[x] > 0) cov[o + x] = min(1, cov[o + x] + (ROW[x] / SUB) * wgt);\n  }\n}\nfunction span(a, b) {\n  a = max(0, a), b = min(W, b);\n  if (b \u003c= a) return;\n  const ia = floor(a), ib = floor(b);\n  if (ia === ib) return void (ROW[ia] += b - a);\n  ROW[ia] += ia + 1 - a;\n  for (let i = ia + 1; i \u003c ib; i++) ROW[i] += 1;\n  if (ib \u003c W) ROW[ib] += b - ib;\n}\n\n// One glyph at the blend c (four master weights) into panel polygons: x0 is\n// the left of its body, base the base line, cap the cap height in LEDs.\nfunction place(ch, c, x0, base, cap, lean, out) {\n  const g = GLYPH[ch];\n  for (let k = 0; k \u003c g[0].pts.length; k++) {\n    const a = g[0].pts[k], b = g[1].pts[k], d = g[2].pts[k], e = g[3].pts[k];\n    const p = new Float32Array(a.length);\n    for (let i = 0; i \u003c a.length; i += 2) {\n      const x = c[0] * a[i] + c[1] * b[i] + c[2] * d[i] + c[3] * e[i];\n      const y = c[0] * a[i + 1] + c[1] * b[i + 1] + c[2] * d[i + 1] + c[3] * e[i + 1];\n      p[i] = x0 + (x + lean * (y - 0.5)) * cap;\n      p[i + 1] = base - y * cap;\n    }\n    out.push(p);\n  }\n}\nconst mix = (c, ch, key) => c[0] * GLYPH[ch][0][key] + c[1] * GLYPH[ch][1][key] + c[2] * GLYPH[ch][2][key] + c[3] * GLYPH[ch][3][key];\n\nexport function setup(params) {\n  params.s = {\n    ph: 2.1, lc: 0, u: 0.5, v: 0.5, u0: 0.5, v0: 0.5, hue: 0, lean: 0, leanT: 0,\n    trail: [], word: new Float32Array(N), map: new Float32Array(N), rgb: new Float32Array(N * 3),\n  };\n}\n\n// Reflect into the square, so the wander folds back at an edge.\nconst fold = (x) => cl(x \u003c 0 ? -x : x > 1 ? 2 - x : x, 0, 1);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3);\n  S.u0 = (cl(k[2], -1, 1) + 1) / 2;\n  S.v0 = (cl(k[3], -1, 1) + 1) / 2;\n  if (input.btnPressed && input.btnPressed[2]) S.leanT = 1 - S.leanT;\n  S.lean += cl(S.leanT - S.lean, -d * 2, d * 2);\n  // The wander: two sines an axis at unrelated rates, 0.24 of the square at\n  // most each way, so it never closes into a figure. 0.42 rad/s a unit of\n  // Speed: the slowest term comes round in 14 s at 2.\n  S.ph += d * speed * 0.42;\n  const A = 0.24, p = S.ph;\n  S.u = fold(S.u0 + A * (0.62 * sin(0.71 * p + 0.3) + 0.38 * sin(1.37 * p + 2.1)));\n  S.v = fold(S.v0 + A * (0.62 * sin(0.53 * p + 1.7) + 0.38 * sin(1.19 * p + 0.6)));\n  S.trail.push(S.u, S.v);\n  if (S.trail.length > 72) S.trail.splice(0, 2);\n  S.lc += (d * speed) / 6;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { word, map, rgb } = S, u = S.u, v = S.v;\n  const c = [(1 - u) * (1 - v), (1 - u) * v, u * (1 - v), u * v];\n  const lean = SLANT * ss(0, 1, S.lean);\n  const hue = 0.54 + S.hue;\n  const ink = hsv(hue, 0.4, 1), guide = hsv(hue, 0.7, 0.17), blue = hsv(hue + 0.06, 0.62, 1), gold = hsv(hue + 0.58, 0.68, 1);\n  const li = floor(S.lc) % 6, lf = S.lc - floor(S.lc), fresh = ss(0, 0.08, lf);\n  const letter = \"MASTER\"[li], before = \"MASTER\"[(li + 5) % 6];\n\n  // ---- The instance: two lines, centred on their ink.\n  word.fill(0);\n  const ticks = [];\n  for (let L = 0; L \u003c 2; L++) {\n    const line = LINES[L], polys = [];\n    let ink0 = 0;\n    for (const ch of line) ink0 += mix(c, ch, \"l\") + mix(c, ch, \"bw\") + mix(c, ch, \"r\");\n    ink0 -= mix(c, line[0], \"l\") + mix(c, line[2], \"r\");\n    let x = (W - ink0 * CAP) / 2 - mix(c, line[0], \"l\") * CAP;\n    ticks.push([L, x]);\n    for (let i = 0; i \u003c 3; i++) {\n      const ch = line[i], l = mix(c, ch, \"l\"), bw = mix(c, ch, \"bw\"), r = mix(c, ch, \"r\");\n      place(ch, c, x + l * CAP, BASE[L], CAP, lean, polys);\n      if (L * 3 + i === li) ticks.push([L, x + (l + bw / 2) * CAP, 1]);\n      x += (l + bw + r) * CAP;\n      ticks.push([L, x]);\n    }\n    fill(word, polys, 1);\n  }\n\n  // ---- The masters of one letter at the four corners, the incoming letter\n  // fading over the first 0.24 s at Speed 2.\n  map.fill(0);\n  const corner = (ch, wgt) => {\n    for (let m = 0; m \u003c 4; m++) {\n      const g = GLYPH[ch][m], cm = [0, 0, 0, 0];\n      cm[m] = 1;\n      const right = m & 1, low = m >> 1, polys = [];\n      const x0 = right ? SQ_X0 + SQ + 3 : SQ_X0 - 3 - g.bw * MCAP;\n      const base = low ? SQ_Y0 + SQ + 3 + MCAP : SQ_Y0 - 3;\n      place(ch, cm, x0, base, MCAP, lean, polys);\n      fill(map, polys, wgt * (0.5 + 0.5 * c[m]));\n    }\n  };\n  corner(letter, fresh);\n  if (fresh \u003c 1) corner(before, 1 - fresh);\n\n  rgb.fill(0);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], col[0] * a), rgb[o + 1] = max(rgb[o + 1], col[1] * a), rgb[o + 2] = max(rgb[o + 2], col[2] * a);\n  };\n  // Cap line and base line of each line of type.\n  for (let L = 0; L \u003c 2; L++)\n    for (let x = 0; x \u003c W; x++) {\n      add(x, BASE[L], guide, 1);\n      add(x, BASE[L] - CAP - 1, guide, 1);\n    }\n  // Side-bearing ticks under the base line, and a gold dot under the letter\n  // the corners show.\n  for (const [L, x, mark] of ticks) {\n    const xi = round(x - 0.5), y = BASE[L] + 2;\n    if (mark) {\n      add(xi, y + 1, gold, 1), add(xi + 1, y + 1, gold, 1), add(xi, y + 2, gold, 0.5), add(xi + 1, y + 2, gold, 0.5);\n    } else for (let j = 0; j \u003c 3; j++) add(xi, y + j, blue, 0.32);\n  }\n  // The square, its quarter lines, and pale lines from the instance to each\n  // master, as bright as that master's share of the blend.\n  for (let i = 0; i \u003c= SQ; i++)\n    for (const q of [0, 1, 2, 3, 4]) {\n      const a = q === 0 || q === 4 ? 0.42 : 0.13;\n      add(SQ_X0 + i, SQ_Y0 + (q * SQ) / 4, blue, a);\n      add(SQ_X0 + (q * SQ) / 4, SQ_Y0 + i, blue, a);\n    }\n  // Axis names as the OpenType variation tags spell them: wdth across the\n  // top, wght down the left side.\n  const label = (s, x, y, dx, dy) => {\n    for (let i = 0; i \u003c s.length; i++)\n      for (let b = 0; b \u003c 15; b++) if (TINY[s[i]][b] === \"#\") add(x + i * dx + (b % 3), y + i * dy + floor(b / 3), blue, 0.5);\n  };\n  label(\"WDTH\", SQ_X0 + SQ / 2 - 7, SQ_Y0 - 7, 4, 0);\n  label(\"WGHT\", SQ_X0 - 9, SQ_Y0 + SQ / 2 - 11, 0, 6);\n  const px = SQ_X0 + v * SQ, py = SQ_Y0 + u * SQ;\n  for (let m = 0; m \u003c 4; m++) {\n    const cx = SQ_X0 + (m & 1) * SQ, cy = SQ_Y0 + (m >> 1) * SQ, n = ceil(max(abs(cx - px), abs(cy - py)));\n    for (let i = 1; i \u003c n; i++) add(round(px + ((cx - px) * i) / n), round(py + ((cy - py) * i) / n), gold, 0.08 + 0.25 * c[m]);\n  }\n  // The knob point: a small cross.\n  const kx = round(SQ_X0 + S.v0 * SQ), ky = round(SQ_Y0 + S.u0 * SQ);\n  for (let j = -2; j \u003c= 2; j++) if (j) add(kx + j, ky, gold, 0.4), add(kx, ky + j, gold, 0.4);\n  // Trail, oldest dimmest, then the instance itself.\n  const T = S.trail, nt = T.length / 2;\n  for (let i = 0; i \u003c nt; i++) add(round(SQ_X0 + T[i * 2 + 1] * SQ), round(SQ_Y0 + T[i * 2] * SQ), gold, 0.1 + 0.5 * (i / nt));\n  for (let j = -1; j \u003c= 1; j++)\n    for (let i = -1; i \u003c= 1; i++) {\n      const dx = round(px) + i + 0.5 - px, dy = round(py) + j + 0.5 - py;\n      add(round(px) + i, round(py) + j, gold, cl(1.25 - 0.55 * sqrt(dx * dx + dy * dy), 0, 1));\n    }\n\n  // ---- Ink over everything.\n  for (let p = 0; p \u003c N; p++) {\n    const o = p * 3, a = word[p], b = map[p];\n    if (a > 0) for (let q = 0; q \u003c 3; q++) rgb[o + q] = rgb[o + q] * (1 - a) + ink[q] * a;\n    if (b > 0) for (let q = 0; q \u003c 3; q++) rgb[o + q] = max(rgb[o + q], ink[q] * b);\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","steiner-deltoid":"// ===== Patternflow pattern =====\n// Title:   Steiner Deltoid\n// Family:  line\n// Idea:    A point runs round the circumcircle of a slowly changing triangle, the feet of its perpendiculars to the three side lines stand on one straight line drawn the full height of the panel, and the fading trace of those Simson lines piles up into a bright three-cusped deltoid that turns and slides as the triangle changes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Simson line (William Wallace, 1799), Steiner's deltoid as the envelope of the Simson lines (Jakob Steiner, 1856), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..1, Trail=0.5..4\n//\n// Knob 1: Hue. Turns every colour together: at 0 the traces run teal to blue round the deltoid, the triangle and its circle are pale gold, its feet gold, and the point and the current Simson line near white.\n// Knob 2: Speed. How fast the point runs round the circle: one turn in 5 s at 2, 3.3 s at 3 and 50 s at 0.2. The triangle changes shape on the same clock.\n// Knob 3: Shape. How far the triangle strays from equilateral. At 0 its corners swing up to 14 degrees each way round the circle and the deltoid barely leaves the middle; at 1 they swing up to 46, the triangle goes obtuse, the orthocentre leaves it, and the deltoid rides up to 13.5 LEDs up and down the panel.\n// Knob 4: Trail. How long the earlier Simson lines stay, in turns of the point: at 0.5 a line fades to 37% in half a turn and the deltoid is one bright edge among separate rays; at 4 the lines stay for 20 s at Speed 2, each laid fainter, and the inside of the deltoid, crossed by three lines a turn, glows over the outside, crossed by one.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, round, cos, sin, exp, min, max, abs, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The geometry, checked in Node for 200 random triangles with the point\n// at 2000 places round the circle each: the three feet are collinear (the\n// area they span stays under 1e-15 of R^2); the Simson line turns 180 degrees\n// the other way while the point goes once round; the line for the point\n// diametrically opposite a vertex is the opposite side; and the envelope's\n// nearest and farthest points lie R/2 and 3R/2 from the nine-point centre N\n// (to 1e-6), so the nine-point circle is the deltoid's incircle and its\n// cusps sit 1.5 R out. For one triangle, counting sign changes over 20,000\n// places of the point, each of 36 test points within R/2 of N lay on three\n// Simson lines a turn and each of 36 beyond 1.5 R on one. With the\n// circumcentre at 0 and R = 1, in complex numbers, N = (a + b + c) / 2 and\n// the line for p touches the deltoid at (a + b + c + 2p + abc / p^2) / 2,\n// which the code uses for the spark; that formula matched the intersection\n// of neighbouring lines to 1e-6.\n//\n// R is 18 LEDs, so the cusps lie 27 from N and the deltoid fits the 64\n// columns when N stands on the middle one. The view slides sideways to keep\n// it there: the circumcentre sits on row 64 at x = 32 - Hx / 2, where H is\n// the orthocentre's offset from it, and N rides up and down the panel with\n// Hy / 2. Over 5000 s at Shape 1 the circle reaches column 63.5 at most and\n// N stays within 13.5 rows of row 64.\nconst R = 18;\n// One turn of the point takes TURN seconds at Speed 2.\nconst TURN = 5;\n\n// The triangle at clock u (seconds at Speed 2). Three corners spaced a third\n// of a turn, each swinging round the circle on its own slow beat (47, 59 and\n// 71 s), and the whole triangle turning once in 200 s against the point, so\n// over the 2.5 s a trace lasts at the start the deltoid hardly moves and its\n// edge stays sharp. amp is the swing in radians: 0.25 at Shape 0, 0.8 at\n// Shape 1. A corner can never pass the next one: two neighbours close by at\n// most 2 * 0.8 rad, short of 2.09, and over 5000 s they never come closer\n// than 28 degrees.\nconst BEAT = [47, 59, 71], PH = [0.9, 2.6, 4.4];\nfunction triangle(u, amp, out) {\n  const rho = (-TAU * u) / 200;\n  let hx = 0, hy = 0;\n  for (let i = 0; i \u003c 3; i++) {\n    const a = rho + PI / 2 + (TAU * i) / 3 + amp * sin((TAU * u) / BEAT[i] + PH[i]);\n    out.ca[i] = cos(a);\n    out.sa[i] = sin(a);\n    hx += out.ca[i];\n    hy += out.sa[i];\n  }\n  // Orthocentre H = O + R (a + b + c); the circumcentre O keeps the\n  // nine-point centre N = O + R (a + b + c) / 2 on column 32.\n  out.ox = 32 - (R * hx) / 2;\n  out.oy = 64;\n  out.hx = hx;\n  out.hy = hy;\n  for (let i = 0; i \u003c 3; i++) (out.x[i] = out.ox + R * out.ca[i]), (out.y[i] = out.oy + R * out.sa[i]);\n  return out;\n}\nconst newTri = () => ({ ca: [0, 0, 0], sa: [0, 0, 0], x: [0, 0, 0], y: [0, 0, 0], ox: 0, oy: 0, hx: 0, hy: 0 });\n\n// Foot of the perpendicular from (px, py) to the line through corners i, j.\nfunction foot(T, i, j, px, py, o, k) {\n  const ux = T.x[i], uy = T.y[i], dx = T.x[j] - ux, dy = T.y[j] - uy;\n  const t = ((px - ux) * dx + (py - uy) * dy) / (dx * dx + dy * dy);\n  o[k] = ux + t * dx;\n  o[k + 1] = uy + t * dy;\n}\n\n// The Simson line of the point at angle th: the three feet into F (on BC,\n// CA, AB), and the line through the two farthest apart as n . q = c with n\n// a unit normal, into L.\nfunction simson(T, th, F, L) {\n  const px = T.ox + R * cos(th), py = T.oy + R * sin(th);\n  foot(T, 1, 2, px, py, F, 0);\n  foot(T, 2, 0, px, py, F, 2);\n  foot(T, 0, 1, px, py, F, 4);\n  let bi = 0, bj = 2, bd = -1;\n  for (const [i, j] of [[0, 2], [2, 4], [0, 4]]) {\n    const d = hypot(F[j] - F[i], F[j + 1] - F[i + 1]);\n    if (d > bd) (bd = d), (bi = i), (bj = j);\n  }\n  const dx = (F[bj] - F[bi]) / bd, dy = (F[bj + 1] - F[bi + 1]) / bd;\n  L[0] = -dy;\n  L[1] = dx;\n  L[2] = -dy * F[bi] + dx * F[bi + 1];\n  L[3] = px;\n  L[4] = py;\n}\n\n// Add a soft line n . q = c, w LEDs to each side, into a float RGB buffer.\n// It walks rows for a steep line and columns for a flat one, so a line\n// costs about 400 pixel visits, not 8192.\nfunction addLine(buf, nx, ny, c, w, amt, col) {\n  if (abs(nx) >= abs(ny)) {\n    const sp = w / abs(nx);\n    for (let y = 0; y \u003c H; y++) {\n      const xc = (c - ny * (y + 0.5)) / nx - 0.5;\n      for (let x = max(0, ceil(xc - sp)); x \u003c= min(W - 1, floor(xc + sp)); x++) {\n        const f = 1 - abs(nx * (x + 0.5) + ny * (y + 0.5) - c) / w;\n        if (f > 0) {\n          const o = (y * W + x) * 3;\n          buf[o] += amt * f * col[0], buf[o + 1] += amt * f * col[1], buf[o + 2] += amt * f * col[2];\n        }\n      }\n    }\n  } else {\n    const sp = w / abs(ny);\n    for (let x = 0; x \u003c W; x++) {\n      const yc = (c - nx * (x + 0.5)) / ny - 0.5;\n      for (let y = max(0, ceil(yc - sp)); y \u003c= min(H - 1, floor(yc + sp)); y++) {\n        const f = 1 - abs(nx * (x + 0.5) + ny * (y + 0.5) - c) / w;\n        if (f > 0) {\n          const o = (y * W + x) * 3;\n          buf[o] += amt * f * col[0], buf[o + 1] += amt * f * col[1], buf[o + 2] += amt * f * col[2];\n        }\n      }\n    }\n  }\n}\n\n// Soft segment and dot, brightest-wins, into the 0..255 frame.\nfunction seg(rgb, x0, y0, x1, y1, w, col) {\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy || 1e-9;\n  const xa = max(0, floor(min(x0, x1) - w)), xb = min(W - 1, ceil(max(x0, x1) + w));\n  const ya = max(0, floor(min(y0, y1) - w)), yb = min(H - 1, ceil(max(y0, y1) + w));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const qx = x + 0.5 - x0, qy = y + 0.5 - y0, t = cl((qx * dx + qy * dy) / l2, 0, 1);\n      const f = 1 - hypot(qx - t * dx, qy - t * dy) / w;\n      if (f > 0) put(rgb, y * W + x, f, col);\n    }\n}\nfunction dot(rgb, cx, cy, r, col) {\n  for (let y = max(0, floor(cy - r)); y \u003c= min(H - 1, ceil(cy + r)); y++)\n    for (let x = max(0, floor(cx - r)); x \u003c= min(W - 1, ceil(cx + r)); x++) {\n      const f = 1 - hypot(x + 0.5 - cx, y + 0.5 - cy) / r;\n      if (f > 0) put(rgb, y * W + x, min(1, 1.6 * f), col);\n    }\n}\nfunction ring(rgb, cx, cy, rad, w, col) {\n  for (let y = max(0, floor(cy - rad - w)); y \u003c= min(H - 1, ceil(cy + rad + w)); y++)\n    for (let x = max(0, floor(cx - rad - w)); x \u003c= min(W - 1, ceil(cx + rad + w)); x++) {\n      const f = 1 - abs(hypot(x + 0.5 - cx, y + 0.5 - cy) - rad) / w;\n      if (f > 0) put(rgb, y * W + x, f, col);\n    }\n}\nfunction put(rgb, p, f, col) {\n  const o = p * 3;\n  rgb[o] = max(rgb[o], f * col[0]);\n  rgb[o + 1] = max(rgb[o + 1], f * col[1]);\n  rgb[o + 2] = max(rgb[o + 2], f * col[2]);\n}\n\n// ---- The trace. Every time the point passes a multiple of STEP (6 degrees,\n// 60 lines a turn) that place's Simson line is laid into ACC, LINE strong,\n// and the buffer fades by exp(-u / tau), tau the Trail knob in turns. The\n// lines are kept apart like threads in string art: near the deltoid\n// neighbours overlap and add up to a bright edge, farther out they part, 3\n// degrees apart, and run as separate rays to the panel's ends. Being tied\n// to the point's angle, not to frames, the trace is the same at any frame\n// rate and speed.\nconst STEP = (6 * PI) / 180, LINE = 0.5, LW = 0.75;\nfunction deposit(S, T, th0, th1) {\n  const F = S.F, L = S.L;\n  for (let k = floor(th0 / STEP) + 1; k * STEP \u003c= th1; k++) {\n    const th = k * STEP;\n    simson(T, th, F, L);\n    // The trace's colour runs from its hue to 0.16 past it and back once a\n    // turn, so each arc of the deltoid keeps its own tint.\n    const col = hsv(0.47 + S.hue + 0.08 * (1 - cos(th)), 0.75, 1);\n    addLine(S.acc, L[0], L[1], L[2], LW, LINE * (0.5 / S.trail) ** 0.7, col);\n  }\n}\n\nfunction advance(S, du) {\n  const T = triangle(S.u, S.amp, S.T);\n  const th1 = S.th + (TAU * du) / TURN;\n  const fade = exp(-du / (S.trail * TURN)), acc = S.acc;\n  for (let i = 0; i \u003c NP * 3; i++) acc[i] *= fade;\n  deposit(S, T, S.th, th1);\n  S.th = th1;\n  S.u += du;\n}\n\nexport function setup(params) {\n  params.s = {\n    u: 0, th: 0, hue: 0, amp: 0.25, trail: 0.5, warm: false,\n    acc: new Float32Array(NP * 3), rgb: new Float32Array(NP * 3), tmp: new Float32Array(NP * 3),\n    T: newTri(), F: new Float64Array(6), L: new Float64Array(5),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.5], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.amp = 0.25 + 0.55 * cl(k[2], 0, 1);\n  S.trail = cl(k[3], 0.5, 4);\n  if (!S.warm) {\n    // First frame: run the last three trail lengths (at most 60 s) at 30\n    // steps a second, so the deltoid is already built when the panel opens.\n    // 90 lines and 10 to 20 ms in Node at Trail 0.5; 720 lines and about\n    // 60 ms at 4, most of it fading the buffer 1800 times.\n    const back = min(60, 3 * S.trail * TURN);\n    S.u = -back;\n    S.th = (-TAU * back) / TURN;\n    for (let i = 0, n = round(back * 30); i \u003c n; i++) advance(S, 1 / 30);\n    S.u = 0;\n    S.th = 0;\n    S.warm = true;\n  }\n  advance(S, (d * cl(k[1], 0.2, 3)) / 2);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.warm) return;\n  const T = triangle(S.u, S.amp, S.T), F = S.F, L = S.L, rgb = S.rgb, acc = S.acc;\n  // The trace, through 1 - exp(-acc) per channel, so where lines pile up the\n  // colour runs to white.\n  for (let i = 0; i \u003c NP * 3; i++) rgb[i] = 255 * (1 - exp(-acc[i]));\n\n  const gold = hsv(0.12 + S.hue, 0.38, 1), grey = hsv(0.12 + S.hue, 0.2, 1), pale = hsv(0.47 + S.hue, 0.18, 1);\n  const sc = (c, v) => [c[0] * v, c[1] * v, c[2] * v];\n  // The three side lines, run off the panel both ways: the feet often land\n  // on them outside the triangle.\n  const side = [], dim = sc(grey, 50);\n  for (const [i, j] of [[1, 2], [2, 0], [0, 1]]) {\n    const dx = T.x[j] - T.x[i], dy = T.y[j] - T.y[i], l = hypot(dx, dy);\n    side.push([-dy / l, dx / l, (-dy * T.x[i] + dx * T.y[i]) / l]);\n  }\n  const lines = S.tmp.fill(0);\n  for (const [nx, ny, c] of side) addLine(lines, nx, ny, c, 0.9, 1, dim);\n  for (let i = 0; i \u003c NP * 3; i++) rgb[i] = max(rgb[i], min(dim[i % 3], lines[i]));\n  ring(rgb, T.ox, T.oy, R, 0.9, sc(gold, 95));\n  for (const [i, j] of [[0, 1], [1, 2], [2, 0]]) seg(rgb, T.x[i], T.y[i], T.x[j], T.y[j], 1, sc(gold, 210));\n\n  // The point, its perpendiculars, the feet and its Simson line.\n  simson(T, S.th, F, L);\n  const px = L[3], py = L[4];\n  for (let k = 0; k \u003c 3; k++) seg(rgb, px, py, F[2 * k], F[2 * k + 1], 0.8, sc(gold, 95));\n  const line = S.tmp.fill(0);\n  addLine(line, L[0], L[1], L[2], 1.1, 1, sc(pale, 235));\n  for (let i = 0; i \u003c NP * 3; i++) if (line[i] > rgb[i]) rgb[i] = line[i];\n  for (let k = 0; k \u003c 3; k++) dot(rgb, F[2 * k], F[2 * k + 1], 1.8, sc(gold, 255));\n  dot(rgb, px, py, 2.4, [255, 255, 255]);\n  // Where the line touches the deltoid: (a + b + c + 2p + abc / p^2) / 2.\n  const ar = T.ca[0] * T.ca[1] - T.sa[0] * T.sa[1], ai = T.ca[0] * T.sa[1] + T.sa[0] * T.ca[1];\n  const br = ar * T.ca[2] - ai * T.sa[2], bi = ar * T.sa[2] + ai * T.ca[2];\n  const tr = br * cos(-2 * S.th) - bi * sin(-2 * S.th), ti = br * sin(-2 * S.th) + bi * cos(-2 * S.th);\n  const tx = T.ox + (R * (T.hx + 2 * cos(S.th) + tr)) / 2, ty = T.oy + (R * (T.hy + 2 * sin(S.th) + ti)) / 2;\n  dot(rgb, tx, ty, 1.6, [255, 255, 255]);\n\n  for (let p = 0; p \u003c NP; p++) display.setPixel(p % W, (p / W) | 0, min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","topologists-sine-curve":"// ===== Patternflow pattern =====\n// Title:   Topologist's Sine Curve\n// Family:  topology\n// Idea:    The graph of sin(1/x) stands on the panel with x running down to the limit segment drawn across near the bottom, its swings packing tighter until they merge into a band that is bright at both edges and dim in the middle by the arcsine law, while a slow zoom toward x = 0 draws new swings out of the band and a bead walks down the curve, swinging faster and faster, and never reaches the segment.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: topologist's sine curve (Lynn Arthur Steen and J. Arthur Seebach Jr., Counterexamples in Topology, 1970), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Zoom=0..1, Measure=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel: at 0 the curve is aqua where it swings right on its way down and violet where it swings left, the band where the two can no longer be told apart is their periwinkle mix, the segment is pale gold and the bead leaves a gold trail.\n// Knob 2: Speed. At 2 a walk takes about 9 s and the zoom breathes in and out once every 30 s; at 0.2 both are ten times slower, at 3 half as fast again.\n// Knob 3: Zoom. How near x = 0 the top of the panel is: at 0 the panel shows x from 0.16 down to 0, at 1 from 0.005, where the band takes nearly the whole height. The slow zoom then goes four times nearer and back.\n// Knob 4: Measure. What a LED's brightness counts. At 0 it is how much of its row's stretch of x the curve spends in that LED, which in the band is the arcsine law, bright edges and a dim middle. At 1 it is how much curve length passes through the LED, and the band fills flat.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sqrt, sin, cos, asin, exp, log, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The panel. The curve's x runs down the panel, x = X at the top edge\n// and x = 0 on row 121 (Y = 121.5), where the limit segment {0} x [-1, 1]\n// lies across. Its value sin(1/x) runs across: -1 at column 4.5, +1 at 59.5.\nconst YS = 121.5, CX = 32, AMP = 27.5;\nconst colOf = (s) => CX + AMP * s;\n\n// In the band a row holds so many swings that the share of it the curve\n// spends in each column is the arcsine law: (asin s1 - asin s0) / pi for the\n// column's stretch s0..s1. Column 4, which only half meets the curve, gets\n// 0.061 of the row, 5.25 times the 0.0116 of a middle column, and column 5\n// gets 3.9 times. Across, every swing crosses each column twice.\nconst ARC = new Float32Array(W), OVL = new Float32Array(W);\nfor (let c = 0; c \u003c W; c++) {\n  const s0 = cl((c - CX) / AMP, -1, 1), s1 = cl((c + 1 - CX) / AMP, -1, 1);\n  ARC[c] = (asin(s1) - asin(s0)) / PI;\n  OVL[c] = (s1 - s0) * AMP;\n}\n\n// ---- One row, exactly. Between turning points, u = 1/x walks one way and\n// sin u is monotone, with inverse u = k pi + asin((-1)^k s) on the k-th\n// piece. Every crossing of a column boundary is then an exact x, so the\n// share of the row's x in each column, and the chord length through it, are\n// sums of differences: a box filter with no samples to alias. Odd pieces,\n// where the curve swings left on its way down, are also kept apart in L.\nfunction rowExact(j, ulo, uhi, span, yScale, M, L, A) {\n  const k0 = floor(ulo / PI + 0.5), k1 = floor(uhi / PI + 0.5), o = j * W;\n  for (let k = k0; k \u003c= k1; k++) {\n    const ua = max(ulo, (k - 0.5) * PI), ub = min(uhi, (k + 0.5) * PI);\n    if (ub \u003c= ua) continue;\n    const sg = k & 1 ? -1 : 1, cb = colOf(sin(ub)), dir = cb >= colOf(sin(ua)) ? 1 : -1;\n    let p = colOf(sin(ua)), xp = 1 / ua;\n    for (let guard = 0; guard \u003c 70; guard++) {\n      let q = dir > 0 ? floor(p) + 1 : ceil(p) - 1, last = false;\n      if (dir > 0 ? q >= cb : q \u003c= cb) (q = cb), (last = true);\n      const xq = last ? 1 / ub : 1 / (k * PI + asin(cl((sg * (q - CX)) / AMP, -1, 1)));\n      const c = floor((p + q) / 2), dx = abs(xp - xq);\n      if (c >= 0 && c \u003c W) {\n        M[o + c] += dx / span;\n        if (sg \u003c 0) L[o + c] += dx / span;\n        A[o + c] += sqrt((q - p) ** 2 + (dx * yScale) ** 2);\n      }\n      if (last) break;\n      (p = q), (xp = xq);\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, tz: 0, walk: 0, hue: 0, zoom: 0, meas: 0.06, X: 0.16, dt: 0, prevU: 0,\n    M: new Float32Array(N), L: new Float32Array(N), A: new Float32Array(N), T: new Float32Array(N), tmp: new Float32Array(N), F: new Float32Array(N * 3),\n    C: [0, 1, 2].map(() => new Float32Array(N)), O: [0, 1, 2].map(() => new Float32Array(N)),\n  };\n}\n\n// ---- Time, in seconds at Speed 2. The bead's share of the way from the\n// segment, q = x / X, is (1 - t / 8)^1.25: it comes down the panel at a\n// walker's pace, 19 rows a second at first and slower near the end, and\n// would touch the segment at 8 s. It cannot: there sin(1/x) has no limit,\n// so its swings come without bound, past the frame rate for the last second\n// or so, and the walk stops 0.4 LED short, in the band. A new one starts 0.8 s\n// later. The zoom divides X by up to 4 and back over 30 s.\nconst TW = 8, PW = 1.25, Q_END = 0.4 / YS, PAUSE = 0.8, TZ = 30;\nconst WALK = TW * (1 - Q_END ** (1 / PW));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const e = (d * cl(k[1], 0.2, 3)) / 2;\n  S.hue = k[0];\n  S.zoom = cl(k[2], 0, 1);\n  S.meas = cl(k[3], 0, 1);\n  S.tz += e;\n  S.walk += e;\n  S.dt = e;\n  if (S.walk > WALK + PAUSE) (S.walk -= WALK + PAUSE), (S.prevU = 0);\n  S.X = 0.16 * 10 ** (-1.5 * S.zoom) * exp(-log(4) * 0.5 * (1 - cos((2 * PI * S.tz) / TZ)));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { M, L, A, T, tmp, F, C, O } = S, [CR, CG, CB] = C, X = S.X, span = X / YS, yScale = YS / X;\n  M.fill(0), L.fill(0), A.fill(0);\n  // ---- The curve, row by row down to the segment's row.\n  for (let j = 0; j \u003c= 121; j++) {\n    const xb = X * (1 - j / YS), xa = max(0, X * (1 - (j + 1) / YS));\n    const ulo = 1 / xb, uhi = xa > 0 ? 1 / xa : Infinity;\n    if (uhi - ulo \u003c 10 * PI) rowExact(j, ulo, uhi, span, yScale, M, L, A);\n    else {\n      // More than five whole swings: the arcsine law, half of it swinging\n      // each way, and the chord length of two crossings a swing.\n      const f = (xb - xa) / span, sw = min(40, (uhi - ulo) / (2 * PI)), o = j * W;\n      for (let c = 4; c \u003c 60; c++) (M[o + c] += f * ARC[c]), (L[o + c] += 0.5 * f * ARC[c]), (A[o + c] += 2 * sw * OVL[c]);\n    }\n  }\n  // ---- Colour. Brightness from the measure: a share of 1/22 of the row\n  // reads 0.63. The curve swings right on its way down in aqua and left in\n  // violet, so a visible swing shows both, and in the band, where each row\n  // holds as much of one as of the other, they mix to periwinkle. Both hues\n  // drift by depth, ln(0.16 / x), so the colour travels with the zoom.\n  // The bright edges belong to the measure of x, not to the curve's length:\n  // counted by length (Measure 1), every swing crosses each column twice,\n  // nearly level, and a band row is the same all across. Checked on row 116\n  // of the opening view: 255 at the edges and 97 in the middle at Measure 0,\n  // 255 all across at Measure 1.\n  const m = S.meas, h0 = S.hue;\n  for (let y = 0; y \u003c H; y++) {\n    const dh = 0.03 * cl(log(0.16 / (X * max(1e-6, 1 - (y + 0.5) / YS))), -2, 6);\n    const ca = hsv(0.47 + h0 + dh, 0.85, 1), cv = hsv(0.71 + h0 + dh, 0.7, 1);\n    for (let x = 0, p = y * W; x \u003c W; x++, p++) {\n      if (!(M[p] > 0)) {\n        CR[p] = CG[p] = CB[p] = 0;\n        continue;\n      }\n      const v = (1 - m) * (1 - exp(-22 * M[p])) + m * (1 - exp(-1.3 * A[p])), l = L[p] / M[p];\n      CR[p] = v * (ca[0] + (cv[0] - ca[0]) * l);\n      CG[p] = v * (ca[1] + (cv[1] - ca[1]) * l);\n      CB[p] = v * (ca[2] + (cv[2] - ca[2]) * l);\n    }\n  }\n  // Glow: a 5-tap blur across and down of each channel, added at 0.7.\n  for (let i = 0; i \u003c 3; i++) blur(C[i], tmp, O[i]);\n\n  // ---- The bead. Its path since the last frame is sampled in u, every 0.1\n  // rad at most, into a trail that fades in 0.3 s; once it swings faster\n  // than the frame, the samples spread across the row, a smear as wide as\n  // the band.\n  const w = S.walk, fade = exp(-S.dt / 0.3);\n  for (let p = 0; p \u003c N; p++) T[p] *= fade;\n  let head = null;\n  if (w \u003c WALK) {\n    const q = (1 - w / TW) ** PW, u = 1 / (q * X), u0 = S.prevU > 0 && S.prevU \u003c u ? S.prevU : u - 1e-3;\n    const n = min(400, max(2, ceil((u - u0) / 0.1)));\n    for (let i = 1; i \u003c= n; i++) {\n      const ui = u0 + ((u - u0) * i) / n;\n      dep(T, colOf(sin(ui)), YS * (1 - 1 / (ui * X)), 1.6 / n + 0.02);\n    }\n    S.prevU = u;\n    head = [colOf(sin(u)), YS * (1 - q)];\n  }\n  // The trail is added on top in gold.\n  const seg = hsv(0.13 + h0, 0.35, 1), gold = hsv(0.12 + h0, 0.6, 1), [OR, OG, OB] = O;\n  for (let p = 0; p \u003c N; p++) {\n    const tr = min(1, T[p]);\n    F[p * 3] = min(1, CR[p] + 0.7 * OR[p] + gold[0] * tr);\n    F[p * 3 + 1] = min(1, CG[p] + 0.7 * OG[p] + gold[1] * tr);\n    F[p * 3 + 2] = min(1, CB[p] + 0.7 * OB[p] + gold[2] * tr);\n  }\n  // ---- The limit segment on row 121, closed at both ends, and a faint\n  // glow on the rows either side.\n  for (let x = 4; x \u003c 60; x++) {\n    const end = x === 4 || x === 59;\n    for (const [dy, a] of [[-1, 0.18], [0, end ? 1 : 0.85], [1, 0.25], [2, 0.08]]) add(F, x, 121 + dy, seg, a);\n  }\n  // The bead itself: white, with a soft halo 1.5 LEDs across.\n  if (head)\n    for (let j = -3; j \u003c= 3; j++)\n      for (let i = -3; i \u003c= 3; i++) {\n        const x = floor(head[0]) + i, y = floor(head[1]) + j, dx = x + 0.5 - head[0], dy = y + 0.5 - head[1];\n        add(F, x, y, [1, 0.97, 0.9], 1.3 * exp(-(dx * dx + dy * dy) / 1.1));\n      }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), (F[p * 3] * 255) | 0, (F[p * 3 + 1] * 255) | 0, (F[p * 3 + 2] * 255) | 0);\n}\n\n// Light added on top of the frame buffer, held to 1.\nfunction add(F, x, y, c, a) {\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  (F[o] = min(1, F[o] + c[0] * a)), (F[o + 1] = min(1, F[o + 1] + c[1] * a)), (F[o + 2] = min(1, F[o + 2] + c[2] * a));\n}\n\n// A point of the bead's path, split over its four nearest LEDs.\nfunction dep(T, x, y, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i, yy = iy + j;\n      if (xx >= 0 && yy >= 0 && xx \u003c W && yy \u003c H) T[yy * W + xx] += a * (i ? ax : 1 - ax) * (j ? ay : 1 - ay);\n    }\n}\n\nfunction blur(src, tmp, out) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (6 * src[p] + 4 * ((x > 0 ? src[p - 1] : 0) + (x \u003c W - 1 ? src[p + 1] : 0)) + (x > 1 ? src[p - 2] : 0) + (x \u003c W - 2 ? src[p + 2] : 0)) / 16;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      out[p] = (6 * tmp[p] + 4 * ((y > 0 ? tmp[p - W] : 0) + (y \u003c H - 1 ? tmp[p + W] : 0)) + (y > 1 ? tmp[p - 2 * W] : 0) + (y \u003c H - 2 ? tmp[p + 2 * W] : 0)) / 16;\n    }\n}\n","voss-dice":"// ===== Patternflow pattern =====\n// Title:   Voss Dice\n// Family:  noise\n// Idea:    A row of dice stands for the bits of a binary counter and at every step the dice whose bits changed are rerolled, so die k rerolls every 2^k steps and their sum is pink 1/f noise, drawn flowing down the panel between white noise (all the dice rerolled every step) on the left and brown noise (a walk stepped by one die) on the right.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Richard F. Voss's dice for 1/f noise, as Martin Gardner gave it with white and brown music in Mathematical Games (Scientific American, April 1978), pattern round 73\n// Round:   73\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dice=4..8, Hold=-1..1\n//\n// Knob 1: Hue. Turns the dice and the middle and right traces round the wheel together: at 0 the middle trace and the dice's flashes are pink and the right trace brown. The left trace stays near white.\n// Knob 2: Speed. Steps a second: 6 at 2, 0.6 at 0.2, 9 at 3. Each step moves the traces down 2 rows.\n// Knob 3: Dice. How many dice, 4 to 8, the same for all three traces. The slowest die of the middle trace rerolls every 8 steps with 4 dice and every 128 with 8, so each die more adds an octave at the low end. From 5 dice up the faces shrink from 14 to 7 LEDs.\n// Knob 4: Hold. How much longer each die holds its face than the one to its right. At the opening 0.06 it is exactly 2, Voss's counter; at -0.94 and below it is 1, every die rerolls every step and the middle trace turns white like the left; at 1 it is 3.8, die 1 rerolls every 3 or 4 steps and die 3 every 56, so the middle trace jitters by one die round levels that seldom move.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nconst roll = () => 1 + floor(Math.random() * 6);\n\n// ---- Faces on a 7 by 7 grid: pips one cell at columns and rows 1, 3, 5,\n// the four corner cells left dark to round the die. Drawn at 2 LEDs a cell\n// for 4 dice (14 LED faces) and 1 for 5 to 8.\nconst PIPS = [\n  [],\n  [[3, 3]],\n  [[1, 1], [5, 5]],\n  [[1, 1], [3, 3], [5, 5]],\n  [[1, 1], [5, 1], [1, 5], [5, 5]],\n  [[1, 1], [5, 1], [3, 3], [1, 5], [5, 5]],\n  [[1, 1], [5, 1], [1, 3], [5, 3], [1, 5], [5, 5]],\n];\n\n// ---- The three games. Every step:\n// white: all n dice rerolled, the sum taken;\n// pink: Voss's dice, die k rerolled when floor(step / r^k) changes, which for\n//   r = 2 is when bit k of the step count changes, so die 0 every step,\n//   die 1 every 2nd, die k every 2^k-th;\n// brown: a walk that moves by a die's roll less 3.5 (-2.5 to +2.5) and folds\n//   back at the ends of the window the other two are drawn in.\n// The window is the mean of n dice, 3.5n, plus and minus 2.6 standard\n// deviations (each die's variance is 35/12): of 4 to 24 for 4 dice that is\n// 5.1 to 22.9, of 8 to 48 for 8 dice 15.4 to 40.6. Values are kept as -1..1\n// across the window, so the history survives a change of Dice.\n// Checked over 400,000 steps: 1.875 dice reroll a step on average with 4\n// dice and 1.992 with 8, so the pink sum moves 2.56 and 2.61 a step against\n// 3.87 and 5.46 for the white; the brown always moves 1.5.\nconst HIST = 140;\n\nfunction windowOf(n) {\n  return [3.5 * n, 2.6 * sqrt((n * 35) / 12)];\n}\n\nfunction step(S) {\n  const n = S.n, r = S.r, t = ++S.count;\n  for (let k = 0; k \u003c n; k++) {\n    const p = pow(r, k);\n    if (floor(t / p) !== floor((t - 1) / p)) {\n      S.dice[k] = roll();\n      S.flash[k] = 1;\n    }\n  }\n  let pink = 0, white = 0;\n  for (let k = 0; k \u003c n; k++) (pink += S.dice[k]), (white += roll());\n  const [mean, half] = windowOf(n);\n  let b = S.brown + roll() - 3.5;\n  if (b > mean + half) b = 2 * (mean + half) - b;\n  if (b \u003c mean - half) b = 2 * (mean - half) - b;\n  S.brown = b;\n  const at = S.head = (S.head + 1) % HIST;\n  S.hw[at] = (white - mean) / half;\n  S.hp[at] = (pink - mean) / half;\n  S.hb[at] = (b - mean) / half;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 4, r: 2, count: 0, ph: 0, hue: 0, ready: false,\n    dice: new Int8Array(8).fill(1), flash: new Float32Array(8), brown: 14,\n    head: 0, hw: new Float32Array(HIST), hp: new Float32Array(HIST), hb: new Float32Array(HIST),\n    rgb: new Float32Array(N * 3),\n  };\n  for (let k = 0; k \u003c 8; k++) params.s.dice[k] = roll();\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), n = cl(round(k[2]), 4, 8);\n  // Hold ratio: 2^(k + 0.94), so the Lab's opening 0.06 gives exactly 2.\n  S.r = max(1, pow(2, cl(k[3], -1, 1) + 0.94));\n  if (n !== S.n) {\n    // Dice added come in rolled; the walk keeps its place in the window.\n    const [m0, h0] = windowOf(S.n), [m1, h1] = windowOf(n);\n    S.brown = m1 + ((S.brown - m0) / h0) * h1;\n    S.n = n;\n  }\n  if (!S.ready) {\n    // A full panel of history before the first frame: 140 steps.\n    S.brown = 3.5 * n;\n    for (let i = 0; i \u003c HIST; i++) step(S);\n    S.flash.fill(0);\n    S.ready = true;\n  }\n  S.ph += d * speed * 3;\n  while (S.ph >= 1) {\n    S.ph -= 1;\n    step(S);\n  }\n  // A reroll flash fades in a quarter of a second.\n  const f = exp(-d / 0.09);\n  for (let i = 0; i \u003c 8; i++) S.flash[i] *= f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, n } = S, hue = S.hue;\n  const pinkC = hsv(0.93 + hue, 0.5, 1), brownC = hsv(0.07 + hue, 0.82, 0.68), whiteC = hsv(0.6 + hue, 0.06, 0.92);\n  const ivory = hsv(0.93 + hue, 0.1, 0.78), hot = hsv(0.93 + hue, 0.65, 1);\n  rgb.fill(0);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || y \u003c 0 || x >= W || y >= H || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a), rgb[o + 1] = max(rgb[o + 1], c[1] * a), rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n\n  // ---- Dice row, the counter's bit lamps under it.\n  const cell = n \u003c= 4 ? 2 : 1, face = 7 * cell, pitch = floor(W / n), x0 = floor((W - pitch * n + pitch - face) / 2);\n  const bitsY = 2 + face + cell, top = bitsY + 2 * cell + 3;\n  for (let k = 0; k \u003c n; k++) {\n    // Die 0, the fastest, on the right, so the lamps read as the step count\n    // in binary.\n    const dx = x0 + (n - 1 - k) * pitch, fl = S.flash[k];\n    const col = [0, 1, 2].map((q) => ivory[q] + (hot[q] - ivory[q]) * fl);\n    const pips = PIPS[S.dice[k]];\n    for (let j = 0; j \u003c 7; j++)\n      for (let i = 0; i \u003c 7; i++) {\n        if ((i === 0 || i === 6) && (j === 0 || j === 6)) continue;\n        let pip = false;\n        for (const [pi, pj] of pips) if (pi === i && pj === j) pip = true;\n        const a = pip ? 0.05 * (1 - fl) : 0.9 + 0.1 * fl;\n        for (let v = 0; v \u003c cell; v++) for (let u = 0; u \u003c cell; u++) put(dx + i * cell + u, 2 + j * cell + v, col, a);\n      }\n    const bit = floor(S.count / pow(S.r, k)) & 1;\n    for (let u = cell; u \u003c face - cell; u++) for (let v = 0; v \u003c cell; v++) put(dx + u, bitsY + v, pinkC, bit ? 0.9 : 0.12);\n  }\n\n  // ---- Three traces, newest at the top, 2 rows a step, sliding down\n  // smoothly between steps. Each is a step plot: a bright line at the value\n  // with a dim fill back to the column's middle.\n  const R = 2, cols = [[0, S.hw, whiteC], [22, S.hp, pinkC], [44, S.hb, brownC]];\n  for (const [cx, hist, c] of cols) {\n    const mid = cx + 9.5;\n    let prev = null;\n    for (let y = top; y \u003c H; y++) {\n      const age = floor((y - top) / R - S.ph + 1);\n      if (age >= HIST) break;\n      const v = hist[(S.head - max(0, age) + HIST * 2) % HIST];\n      const x = mid + cl(v, -1, 1) * 9;\n      // Fill from the middle.\n      const a = min(x, mid), b = max(x, mid);\n      for (let i = floor(a); i \u003c= floor(b); i++) put(i, y, c, 0.2);\n      // The line, split over two LEDs by where it falls between them, and a\n      // horizontal run where the value changed since the row above.\n      const xi = floor(x - 0.5), fr = x - 0.5 - xi;\n      put(xi, y, c, 1 - fr), put(xi + 1, y, c, fr);\n      if (prev !== null && abs(prev - x) > 1) for (let i = round(min(prev, x)); i \u003c= round(max(prev, x)) - 1; i++) put(i, y, c, 0.85);\n      prev = x;\n    }\n  }\n\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, round(min(1, rgb[p * 3]) * 255), round(min(1, rgb[p * 3 + 1]) * 255), round(min(1, rgb[p * 3 + 2]) * 255));\n}\n","autogram":"// ===== Patternflow pattern =====\n// Title:   Autogram\n// Family:  type\n// Idea:    A sentence that counts its own letters fills the panel in 3 by 5 capitals, and a checker goes through it letter by letter, lighting every occurrence of that letter in reading order while a tally climbs towards the number the sentence claims, so the claim word and the bar under the text turn true when the tally reaches it; with Doubt turned up some claims are changed first, the check finds them false, and the sentence is rewritten again and again with the numbers it actually has, faster and faster, until it either comes true or is caught going round a loop of hundreds of sentences.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: autograms, named by Lee Sallows, the first of his printed in Douglas Hofstadter's Metamagical Themas column in Scientific American, January 1982; the three sentences here were found for this pattern; 3 by 5 capitals from Typewriter (pattern round 18) and 5 by 7 figures from Photon Disk (pattern round 70); pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sentence=0..2, Doubt=0..1\n//\n// Knob 1: Hue. Moves the two colours together along the part of the wheel away from red, which is kept for a false claim: at 0 the counted letters are cyan and the claims amber, at 0.5 blue-violet and green, at 1 magenta and sea green; the sentence and the dark ground take a tint of the same two.\n// Knob 2: Speed. At 2 the sentence is written in 1.8 s, 125 characters a second, and the checker takes 0.035 s an occurrence and 0.4 s a letter, so THIS SENTENCE HAS, 152 letters of 19 kinds, is checked in 13 s and held 3 s when true; the first rewrite takes 1.5 s and each after it 0.8 times as long, down to 240 a second. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Sentence. Which autogram comes first; the others follow in turn: 0 THIS SENTENCE HAS, 1 THIS PANEL SHOWS, 2 THESE LIGHTS SPELL. Turning it starts the new one at once.\n// Knob 4: Doubt. How many claims are changed, by 1 to 3, before a sentence is checked: none below 0.125, so the opening 0.06 shows the sentence as found, one at 0.25, two at 0.5, three at 0.75 and four at 1. A changed claim changes the letters of its own number word, so more claims than that come out false.\n\n// Each sentence lists, for every letter it uses, how many times that letter\n// appears in it, counting letters only, the S of each 'S included. The\n// three were found by a search for this pattern that starts from random\n// claims, writes the sentence, counts it and copies some of the counts back\n// into the claims, with restarts, until a sentence comes out true of itself;\n// setup counts each one again and stops if a claim is wrong.\n//\n// Copying every count back at once, which is what the rewrite here does,\n// almost never finds one. In 1200 tries from the first sentence with one\n// to four claims moved by 1 to 3, the rewriting was caught in a loop of\n// 453 sentences 1042 times, of 397 sentences 109 times and of 127\n// sentences 46 times, half of them within 760 rewrites and all within 1320,\n// and came true 3 times: twice as the sentence it started from, once as an\n// autogram nobody had written. From the second sentence the loops were 257,\n// 75, 306, 172, 21 and 12 sentences long (all within 2220 rewrites), from\n// the third 415, 94, 28 and 35. The chase gives up at 3000.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, abs, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nconst SENTENCES = [\n  \"THIS SENTENCE HAS THREE A'S, TWO C'S, TWO D'S, TWENTY-NINE E'S, TWO F'S, THREE G'S, NINE H'S, EIGHT I'S, ONE L, SIXTEEN N'S, SEVEN O'S, SIX R'S, TWENTY-SEVEN S'S, EIGHTEEN T'S, TWO U'S, FOUR V'S, SEVEN W'S, THREE X'S AND THREE Y'S.\",\n  \"THIS PANEL SHOWS THREE A'S, TWO D'S, TWENTY-THREE E'S, TWO F'S, TWO G'S, NINE H'S, SIX I'S, THREE L'S, ELEVEN N'S, EIGHT O'S, TWO P'S, SEVEN R'S, TWENTY-SIX S'S, TWENTY T'S, TWO U'S, THREE V'S, TEN W'S, THREE X'S AND FOUR Y'S.\",\n  \"THESE LIGHTS SPELL TWO A'S, TWO D'S, TWENTY-FIVE E'S, THREE F'S, TWO G'S, SEVEN H'S, SIX I'S, FOUR L'S, TEN N'S, SEVEN O'S, TWO P'S, SIX R'S, THIRTY S'S, SEVENTEEN T'S, TWO U'S, SEVEN V'S, SEVEN W'S, THREE X'S AND THREE Y'S.\",\n];\nconst ONES = [\"ZERO\", \"ONE\", \"TWO\", \"THREE\", \"FOUR\", \"FIVE\", \"SIX\", \"SEVEN\", \"EIGHT\", \"NINE\", \"TEN\", \"ELEVEN\", \"TWELVE\", \"THIRTEEN\", \"FOURTEEN\", \"FIFTEEN\", \"SIXTEEN\", \"SEVENTEEN\", \"EIGHTEEN\", \"NINETEEN\"];\nconst TENS = [\"\", \"\", \"TWENTY\", \"THIRTY\", \"FORTY\", \"FIFTY\", \"SIXTY\", \"SEVENTY\", \"EIGHTY\", \"NINETY\"];\nconst word = (n) => (n \u003c 20 ? ONES[n] : TENS[floor(n / 10)] + (n % 10 ? \"-\" + ONES[n % 10] : \"\"));\nconst NUMBER = {};\nfor (let n = 0; n \u003c 100; n++) NUMBER[word(n)] = n;\nconst AZ = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\n// ---- The sentence from its opening words and its claims, with where each\n// claim sits: the number word, the letter and its 'S.\nfunction build(pre, L, c) {\n  let text = pre + \" \";\n  const item = [];\n  L.forEach((l, i) => {\n    if (i === L.length - 1) text += \"AND \";\n    const a = text.length;\n    text += word(c[i]) + \" \" + l + (c[i] !== 1 ? \"'S\" : \"\");\n    item.push([a, text.length]);\n    text += i === L.length - 1 ? \".\" : i === L.length - 2 ? \" \" : \", \";\n  });\n  return { text, item };\n}\nfunction tally(text, L) {\n  const n = new Array(26).fill(0);\n  for (let i = 0; i \u003c text.length; i++) {\n    const k = text.charCodeAt(i) - 65;\n    if (k >= 0 && k \u003c 26) n[k]++;\n  }\n  return L.map((l) => n[l.charCodeAt(0) - 65]);\n}\n// Parse a sentence back into opening words and claims, then check it.\nconst BOOK = SENTENCES.map((s, si) => {\n  const re = /([A-Z]+(?:-[A-Z]+)?) ([A-Z])(?:'S)?(?=[,.]| AND)/g;\n  const L = [], c = [];\n  let m, first = -1;\n  while ((m = re.exec(s))) {\n    if (!(m[1] in NUMBER)) continue;\n    if (first \u003c 0) first = m.index;\n    L.push(m[2]), c.push(NUMBER[m[1]]);\n  }\n  const pre = s.slice(0, first - 1), b = build(pre, L, c), n = tally(s, L);\n  if (b.text !== s) throw new Error(`sentence ${si} does not rebuild`);\n  for (let i = 0; i \u003c L.length; i++) if (n[i] !== c[i]) throw new Error(`sentence ${si} has ${n[i]} ${L[i]}, not ${c[i]}`);\n  for (const ch of AZ) if (s.includes(ch) && !L.includes(ch)) throw new Error(`sentence ${si} does not list ${ch}`);\n  return { pre, L, c };\n});\n\n// ---- Faces. 3 x 5 capitals from Typewriter, one bit per LED, rows from\n// the top; 5 x 7 capitals and figures from Photon Disk, and three signs.\nconst G35 = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\", \".\": \"000000000000010\", \",\": \"000000000010100\",\n  \"-\": \"000000111000000\", \"'\": \"010010000000000\",\n};\nconst G57 = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", C: \".###. #...# #.... #.... #.... #...# .###.\", D: \"####. #...# #...# #...# #...# #...# ####.\",\n  E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\", G: \".###. #...# #.... #.### #...# #...# .####\",\n  H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\", P: \"####. #...# #...# ####. #.... #.... #....\",\n  R: \"####. #...# #...# ####. #.#.. #..#. #...#\", S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\",\n  U: \"#...# #...# #...# #...# #...# #...# .###.\", V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\",\n  X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\", Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", 0: \".###. #...# #..## #.#.# ##..# #...# .###.\",\n  1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", 2: \".###. #...# ....# ...#. ..#.. .#... #####\", 3: \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\", 6: \"..##. .#... #.... ####. #...# #...# .###.\",\n  7: \"##### ....# ...#. ..#.. .#... .#... .#...\", 8: \".###. #...# #...# .###. #...# #...# .###.\", 9: \".###. #...# #...# .#### ....# ...#. .##..\",\n  \"\u003c\": \"...#. ..#.. .#... #.... .#... ..#.. ...#.\", \">\": \".#... ..#.. ...#. ....# ...#. ..#.. .#...\", \"=\": \"..... ..... ##### ..... ##### ..... .....\",\n};\nfor (const k in G57) G57[k] = G57[k].replace(/ /g, \"\");\n\nconst blend = (c1, c2, u) => [c1[0] + (c2[0] - c1[0]) * u, c1[1] + (c2[1] - c1[1]) * u, c1[2] + (c2[2] - c1[2]) * u];\nconst T_TYPE = 0.008, T_IN = 0.1, T_OCC = 0.035, T_V = 0.3, T_TRUE = 3, T_LOOP = 4, T_R0 = 1.5, T_RMIN = 1 / 240, MAXR = 3000;\n\nfunction wrap(s, text) {\n  // Break at spaces, or after a hyphen; 16 letters of 4 LEDs a line.\n  const pos = new Int16Array(text.length * 2).fill(-1);\n  let col = 0, line = 0, i = 0;\n  while (i \u003c text.length) {\n    let j = i;\n    while (j \u003c text.length && text[j] !== \" \" && !(j > i && text[j - 1] === \"-\")) j++;\n    if (col > 0 && col + (j - i) > 16) (line++), (col = 0);\n    for (let k = i; k \u003c j; k++) (pos[k * 2] = col++), (pos[k * 2 + 1] = line);\n    if (text[j] === \" \") (col++), j++;\n    i = j;\n  }\n  s.pos = pos;\n  s.lines = line + 1;\n}\n\nfunction setText(s, c) {\n  const b = BOOK[s.si], { text, item } = build(b.pre, b.L, c);\n  s.claim = c.slice();\n  s.text = text;\n  s.item = item;\n  s.count = tally(text, b.L);\n  s.itemOf = new Int8Array(text.length).fill(-1);\n  s.litAt = new Float32Array(text.length).fill(-9);\n  item.forEach(([a, e], i) => {\n    for (let k = a; k \u003c e; k++) s.itemOf[k] = i;\n  });\n  wrap(s, text);\n}\n\nfunction start(s, si, m) {\n  s.si = si;\n  s.m = m;\n  const b = BOOK[si], c = b.c.slice();\n  const vol = [];\n  b.L.forEach((l, i) => \"EFGHILNORSTUVWXY\".includes(l) && vol.push(i));\n  for (let k = 0; k \u003c m && vol.length; k++) {\n    const i = vol.splice(floor(Math.random() * vol.length), 1)[0];\n    let d = 0;\n    while (!d || c[i] + d \u003c 1) d = (Math.random() \u003c 0.5 ? -1 : 1) * (1 + floor(Math.random() * 3));\n    c[i] += d;\n  }\n  setText(s, c);\n  s.changedAt = new Float32Array(s.text.length).fill(-9);\n  s.phase = 0; // 0 check, 1 true, 2 chase, 3 loop\n  s.t = 0;\n  s.li = 0;\n  s.sub = -1; // -1 writing, 0 intro, 1 count, 2 verdict\n  s.typed = 0;\n  s.k = 0;\n  s.done = new Int16Array(b.L.length).fill(-1);\n  s.occ = occ(s, 0);\n  s.round = 0;\n  s.seen = null;\n  s.born = s.clock;\n}\nfunction occ(s, li) {\n  const l = BOOK[s.si].L[li], o = [];\n  for (let i = 0; i \u003c s.text.length; i++) if (s.text[i] === l) o.push(i);\n  return o;\n}\nconst keyOf = (c) => c.join(\",\");\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.clock = 0;\n  s.kS = -1;\n  s.kM = -1;\n  s.fb = new Uint8ClampedArray(W * H * 3);\n  start(s, 0, 0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kn = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = kn[0] || 0;\n  const rate = cl(kn[1] == null ? 2 : kn[1], 0.2, 3) / 2;\n  const si = round(cl(kn[2] || 0, 0, 2)), m = round(cl(kn[3] == null ? 0.06 : kn[3], 0, 1) * 4);\n  if (si !== s.kS || m !== s.kM) {\n    s.kS = si;\n    s.kM = m;\n    start(s, si, m);\n  }\n  s.clock += dt;\n  s.t += dt * rate;\n  const L = BOOK[s.si].L;\n  for (let guard = 0; guard \u003c 24; guard++) {\n    if (s.phase === 0) {\n      if (s.sub === -1) {\n        const n = min(s.text.length - s.typed, floor(s.t / T_TYPE));\n        s.typed += n;\n        s.t -= n * T_TYPE;\n        if (s.typed \u003c s.text.length) break;\n        s.sub = 0;\n      } else if (s.sub === 0) {\n        if (s.t \u003c T_IN) break;\n        s.t -= T_IN;\n        s.sub = 1;\n      } else if (s.sub === 1) {\n        if (s.k >= s.occ.length) {\n          s.sub = 2;\n          s.done[s.li] = s.k;\n          continue;\n        }\n        if (s.t \u003c T_OCC) break;\n        s.t -= T_OCC;\n        s.litAt[s.occ[s.k++]] = s.clock;\n      } else {\n        if (s.t \u003c T_V) break;\n        s.t -= T_V;\n        s.li++;\n        if (s.li >= L.length) {\n          s.t = 0;\n          if (s.done.every((n, i) => n === s.claim[i])) s.phase = 1;\n          else (s.phase = 2), (s.seen = new Map([[keyOf(s.claim), 0]])), (s.round = 0);\n        } else (s.sub = 0), (s.k = 0), (s.occ = occ(s, s.li));\n      }\n    } else if (s.phase === 1 || s.phase === 3) {\n      // Caught in a loop, the rewriting goes on round it, 8 a second.\n      if (s.phase === 3 && s.period && s.t >= s.next) {\n        const prev = s.claim, c = s.count.slice();\n        setText(s, c);\n        s.changedAt = new Float32Array(s.text.length).fill(-9);\n        s.item.forEach(([a, e], i) => {\n          if (c[i] !== prev[i]) for (let k = a; k \u003c e; k++) s.changedAt[k] = s.clock;\n        });\n        s.next += 0.125;\n        continue;\n      }\n      if (s.t \u003c (s.phase === 1 ? T_TRUE : T_LOOP)) break;\n      start(s, (s.si + 1) % 3, s.m);\n    } else {\n      const d = max(T_RMIN, T_R0 * Math.pow(0.8, s.round));\n      if (s.t \u003c d) break;\n      s.t -= d;\n      // Rewrite every claim with the count it has.\n      const prev = s.claim, c = s.count.slice();\n      setText(s, c);\n      s.round++;\n      s.changedAt = new Float32Array(s.text.length).fill(-9);\n      s.item.forEach(([a, e], i) => {\n        if (c[i] !== prev[i]) for (let k = a; k \u003c e; k++) s.changedAt[k] = s.clock;\n      });\n      const key = keyOf(c);\n      if (s.count.every((n, i) => n === c[i])) (s.phase = 1), (s.t = 0), (s.verdict = \"TRUE\");\n      else if (s.seen.has(key)) (s.phase = 3), (s.t = 0), (s.next = 0.125), (s.period = s.round - s.seen.get(key));\n      else if (s.round >= MAXR) (s.phase = 3), (s.t = 0), (s.period = 0);\n      else s.seen.set(key, s.round);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const fb = s.fb, b = BOOK[s.si], L = b.L, nL = L.length;\n  // Both colours stay clear of red, which marks a false claim.\n  const hk = 0.11 + 0.34 * cl(s.hue, 0, 1), hc = hk + 0.41;\n  const CNT = hsv(hc, 0.8, 255), CLM = hsv(hk, 0.85, 255), TXT = hsv(hk, 0.3, 155), TONE = blend(TXT, CNT, 0.42), RED = [255, 34, 30], WHT = [255, 255, 255];\n  const BG = hsv(hc, 0.7, 10);\n  for (let i = 0; i \u003c W * H; i++) (fb[i * 3] = BG[0]), (fb[i * 3 + 1] = BG[1]), (fb[i * 3 + 2] = BG[2]);\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    fb[i] = c[0] * a;\n    fb[i + 1] = c[1] * a;\n    fb[i + 2] = c[2] * a;\n  };\n  const fadeIn = cl((s.clock - s.born) / 0.4, 0, 1);\n  const pitch = s.lines * 6 \u003c= 102 ? 6 : floor(102 / s.lines);\n  const checking = s.phase === 0, writing = checking && s.sub === -1, cur = checking && !writing ? s.li : -1;\n  // Which claims are known false.\n  const bad = new Uint8Array(nL);\n  for (let i = 0; i \u003c nL; i++) {\n    if (checking) bad[i] = s.done[i] >= 0 && (i \u003c s.li || s.sub === 2) && s.done[i] !== s.claim[i] ? 1 : 0;\n    else bad[i] = s.count[i] !== s.claim[i] ? 1 : 0;\n  }\n  const sweep = s.phase === 1 ? s.t * 60 : -99;\n  // ---- The sentence.\n  const shown = writing ? s.typed : s.text.length;\n  for (let ci = 0; ci \u003c shown; ci++) {\n    const ch = s.text[ci], g = G35[ch];\n    if (!g) continue;\n    const X = s.pos[ci * 2] * 4, Y = s.pos[ci * 2 + 1] * pitch;\n    const it = s.itemOf[ci], lit = s.litAt[ci];\n    let col = lit > -9 ? TONE : TXT;\n    if (it >= 0 && bad[it]) col = RED;\n    if (it === cur && cur >= 0) col = CLM;\n    if (checking && ch === L[cur] && lit > -9) {\n      const age = s.clock - lit;\n      col = blend(CNT, WHT, cl(1 - age / 0.15, 0, 1) * 0.8);\n      if (s.sub === 2) col = blend(col, TONE, cl(s.t / T_V, 0, 1));\n    }\n    if (writing && shown - ci \u003c 6) col = blend(col, WHT, 1 - (shown - ci) / 6);\n    const ch2 = s.clock - s.changedAt[ci];\n    if (ch2 \u003c 0.35) col = blend(col, WHT, 1 - ch2 / 0.35);\n    if (sweep > -99) {\n      const d = abs(Y - sweep + 20);\n      if (d \u003c 20) col = blend(col, CNT, (1 - d / 20) * 0.85);\n    }\n    for (let y = 0; y \u003c 5; y++)\n      for (let x = 0; x \u003c 3; x++) if (g.charCodeAt(y * 3 + x) === 49) put(X + x, Y + y, col, fadeIn);\n  }\n  // ---- The tally line: letter, count, sign, claim; or the round; or the\n  // verdict.\n  let line = [];\n  if (writing) line = [];\n  else if (checking) {\n    const n = s.sub === 2 ? s.done[cur] : s.k, c = s.claim[cur];\n    const sign = n \u003c c ? \"\u003c\" : n > c ? \">\" : \"=\";\n    const sc = s.sub === 2 ? (n === c ? CNT : RED) : n > c ? RED : WHT;\n    line = [[L[cur], TXT], [\" \", TXT], ...[...String(n).padStart(2, \" \")].map((d) => [d, CNT]), [sign, sc], ...[...String(c)].map((d) => [d, CLM])];\n  } else if (s.phase === 2) line = s.round ? [...\"ROUND \"].map((d) => [d, TXT]).concat([...String(s.round)].map((d) => [d, CLM])) : [...\"FALSE\"].map((d) => [d, RED]);\n  else if (s.phase === 1) line = [...\"TRUE\"].map((d) => [d, CNT]);\n  else if (s.period) line = [...\"LOOP \"].map((d) => [d, RED]).concat([...String(s.period)].map((d) => [d, CLM]));\n  else line = [...\"ROUND \"].map((d) => [d, TXT]).concat([...String(s.round)].map((d) => [d, RED]));\n  const x0 = floor((W - (line.length * 6 - 1)) / 2);\n  line.forEach(([d, col], k) => {\n    const g = G57[d];\n    if (!g) return;\n    for (let y = 0; y \u003c 7; y++) for (let x = 0; x \u003c 5; x++) if (g[y * 5 + x] === \"#\") put(x0 + k * 6 + x, 104 + y, col, fadeIn);\n  });\n  // ---- The bars: a dim column as tall as each claim, a bright one as tall\n  // as the count so far, half an LED a letter.\n  const bx = floor((W - (nL * 3 - 1)) / 2);\n  for (let i = 0; i \u003c nL; i++) {\n    const c = s.claim[i];\n    let n = s.count[i];\n    if (checking) n = i \u003c cur ? s.done[i] : i === cur ? (s.sub === 2 ? s.done[i] : s.k) : 0;\n    const hi = i === cur ? 1 : 0.75;\n    const fill = bad[i] || (checking && i === cur && n > c) ? RED : CNT;\n    if (writing && s.item[i][1] > s.typed) continue;\n    const top = Math.ceil(c / 2) - 1;\n    for (let r = 0; r \u003c 16; r++) {\n      const nn = cl(n / 2 - r, 0, 1);\n      let col = null, a = 0;\n      if (r === top) (col = n === c ? blend(CNT, WHT, 0.5) : n > c ? RED : CLM), (a = i === cur ? 1 : 0.8);\n      else if (nn > 0) (col = fill), (a = (0.35 + 0.65 * nn) * hi);\n      else if (r \u003c top) (col = CLM), (a = i === cur ? 0.16 : 0.09);\n      if (col) for (let x = 0; x \u003c 2; x++) put(bx + i * 3 + x, 127 - r, col, a * fadeIn);\n    }\n    if (c > 32 || n > 32) for (let x = 0; x \u003c 2; x++) put(bx + i * 3 + x, 111, RED, fadeIn);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, fb[i] | 0, fb[i + 1] | 0, fb[i + 2] | 0);\n    }\n}\n","biliteral-cipher":"// ===== Patternflow pattern =====\n// Title:   Biliteral Cipher\n// Family:  type\n// Idea:    A cover sentence is set in capitals ten LEDs wide, five to a line, each one in fount a or fount b, two founts that differ by a slant and a little weight the eye passes over; a reading light then goes along the letters one by one, writes a small a or b under each, and every five of those spell one letter of Bacon's 24-letter alphabet, set below in light until the hidden word is complete, holds, and the next sentence is typed.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Francis Bacon's biliteral cipher in De Augmentis Scientiarum (1623), with his own example, FUGE hidden in MANERE TE VOLO DONEC VENERO; the 5 by 7 capitals of Photon Disk (pattern round 70) doubled; pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Message=0..4, Tell=0..1\n//\n// Knob 1: Hue. The colour of the reading light, the a and b marks and the hidden word, cyan at 0, violet at 0.25, red at 0.5, yellow-green at 0.75; the cover letters take a pale tint from the opposite side of the wheel, ivory at 0.\n// Knob 2: Speed. At 2 a letter is typed every 0.07 s and read every 0.3 s, a hidden letter is set in 0.45 s and the finished word holds 3 s, so Bacon's sentence takes 13 s from first letter to the next sentence. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Message. Which sentence is set first; the rest follow in turn. 0 Bacon's MANERE TE VOLO DONEC VENERO hiding FUGE, 1 THE SEA IS CALM AND STILL TODAY hiding STORM, 2 SAY NOTHING TO ANYONE YET hiding TELL, 3 WE ARE ALL QUITE WELL HERE hiding HELP, 4 BURN THIS LETTER AT ONCE hiding KEEP. Turning it sets the new sentence at once.\n// Knob 4: Tell. How far fount b strays from fount a. At 0 they are the same LEDs and only the reading light knows; at the opening 0.06 a b letter leans 0.22 LED over its 14 rows and is 0.12 LED heavier, a change of a few levels on its edge LEDs; at 0.5 it leans 1.8 LEDs, is 1 LED heavier and the b letters read as a faint italic; at 1 it leans 3.6 LEDs and is 2 LEDs heavier, a bold italic, and the hidden word can be read off the page without the light.\n\n// Bacon's cipher writes each letter of the hidden word as five symbols,\n// a or b, A = aaaaa through Z = babbb, with I and J sharing abaaa and U and\n// V sharing baabb, and prints a cover text of at least five times as many\n// letters in two founts: each cover letter in fount a stands for a, each in\n// fount b for b. Letters past the last full group are nulls, set in either\n// fount and not read; here they are drawn a little dimmer. Bacon's own\n// example hides FUGE (flee) in MANERE TE VOLO DONEC VENERO (stay until I\n// come): 23 letters, 20 read, ERO left over.\n//\n// The cover letters here are the 5 by 7 capitals of Photon Disk drawn at\n// two LEDs a cell, 10 wide and 14 tall with 3 LEDs between them, so five\n// fill 62 of the 64 columns: one group of five to a line. Fount b is the\n// same bitmap sheared and thickened, sampled 4 x 4 times a LED, so at a\n// small Tell it differs from fount a only in how bright its edge LEDs are.\n// A dot halfway up the gap marks the end of a word, as Roman inscriptions\n// did, since a line of five has no room for word spaces.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, abs, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- 5 x 7 capitals from Photon Disk, rows from the top.\nconst G57 = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", B: \"####. #...# #...# ####. #...# #...# ####.\", C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\", E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\",\n  G: \".###. #...# #.... #.### #...# #...# .####\", H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  J: \"..### ...#. ...#. ...#. ...#. #..#. .##..\", K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  M: \"#...# ##.## #.#.# #.#.# #...# #...# #...#\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\",\n  P: \"####. #...# #...# ####. #.... #.... #....\", Q: \".###. #...# #...# #...# #.#.# #..#. .##.#\", R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\", X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\",\n};\nconst BITS = {};\nfor (const k in G57) {\n  const s = G57[k].replace(/ /g, \"\"), b = new Uint8Array(35);\n  for (let i = 0; i \u003c 35; i++) b[i] = s[i] === \"#\" ? 1 : 0;\n  BITS[k] = b;\n}\n// The marks, a 3 by 5 a and b drawn for this pattern.\nconst MARK = [\"....###.##.#.##\".replace(/\\./g, \"0\").replace(/#/g, \"1\"), \"#..#..##.#.###.\".replace(/\\./g, \"0\").replace(/#/g, \"1\")];\n// Bacon's alphabet of 24: J reads as I, V as U.\nconst ABC = \"ABCDEFGHIKLMNOPQRSTUWXYZ\";\nconst code = (ch) => ABC.indexOf(ch === \"J\" ? \"I\" : ch === \"V\" ? \"U\" : ch);\n\nconst MESSAGES = [\n  [\"MANERE TE VOLO DONEC VENERO\", \"FUGE\"],\n  [\"THE SEA IS CALM AND STILL TODAY\", \"STORM\"],\n  [\"SAY NOTHING TO ANYONE YET\", \"TELL\"],\n  [\"WE ARE ALL QUITE WELL HERE\", \"HELP\"],\n  [\"BURN THIS LETTER AT ONCE\", \"KEEP\"],\n];\n\n// ---- Layout: a letter is 10 x 14 LEDs in a cell 13 wide; a line is 22\n// rows, the letter, a blank row, the 5-row mark and two blank rows.\nconst CX = (c) => 1 + 13 * c, CY = (r) => 1 + 22 * r, HY = 112, RULE = 110;\nconst GW = 16, GOX = 3; // glyph raster: columns -3..12 of the cell\n\n// Coverage of one glyph in fount b at a given tell, 16 x 14 LEDs. Shear s\n// leans the top s/2 right and the foot s/2 left; weight w widens every\n// stroke by w, half to each side.\nfunction raster(ch, t) {\n  const bm = BITS[ch], out = new Float32Array(GW * 14);\n  const s = 3.6 * t, w = 2 * t;\n  const on = (x, y) => {\n    const c = floor(x / 2), r = floor(y / 2);\n    return c >= 0 && c \u003c 5 && r >= 0 && r \u003c 7 && bm[r * 5 + c] === 1;\n  };\n  for (let y = 0; y \u003c 14; y++)\n    for (let gx = 0; gx \u003c GW; gx++) {\n      let n = 0;\n      for (let j = 0; j \u003c 4; j++) {\n        const Y = y + (j + 0.5) / 4, sh = s * (0.5 - Y / 14);\n        for (let i = 0; i \u003c 4; i++) {\n          const x = gx - GOX + (i + 0.5) / 4 - sh;\n          if (on(x, Y) || (w > 0 && (on(x - w / 2, Y) || on(x + w / 2, Y)))) n++;\n        }\n      }\n      out[y * GW + gx] = n / 16;\n    }\n  return out;\n}\n\nfunction prepare(s, mi) {\n  const [cover, hidden] = MESSAGES[mi];\n  const letters = [], dots = [];\n  for (const ch of cover) {\n    if (ch === \" \") {\n      if (letters.length % 5) dots.push(letters.length - 1);\n    } else letters.push(ch);\n  }\n  const n = min(hidden.length, floor(letters.length / 5), 5);\n  const fount = letters.map(() => (Math.random() \u003c 0.5 ? 1 : 0));\n  for (let i = 0; i \u003c n; i++) {\n    const v = code(hidden[i]);\n    for (let k = 0; k \u003c 5; k++) fount[i * 5 + k] = (v >> (4 - k)) & 1;\n  }\n  // Read it back the way a decipherer would, so a wrong table cannot pass.\n  for (let i = 0; i \u003c n; i++) {\n    let v = 0;\n    for (let k = 0; k \u003c 5; k++) v = v * 2 + fount[i * 5 + k];\n    if (ABC[v] !== hidden[i]) throw new Error(`message ${mi} letter ${i} reads ${ABC[v]}`);\n  }\n  s.mi = mi;\n  s.letters = letters.slice(0, 25);\n  s.fount = fount;\n  s.dots = dots;\n  s.hidden = hidden.slice(0, n);\n  s.n = n;\n  s.phase = 0; // 0 type, 1 read, 2 set, 3 hold, 4 clear\n  s.t = 0;\n  s.typed = 0;\n  s.read = 0;\n  s.set = 0;\n  s.born = letters.map(() => -1);\n  s.markAt = letters.map(() => -1);\n  s.setAt = [-1, -1, -1, -1, -1];\n}\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.clock = 0;\n  s.knobMsg = -1;\n  s.cache = {};\n  s.tellKey = -1;\n  s.fb = new Uint8ClampedArray(W * H * 3);\n  prepare(s, 0);\n}\n\nconst T_TYPE = 0.07, T_READ = 0.3, T_SET = 0.45, T_HOLD = 3, T_CLEAR = 0.6;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  s.tell = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  const mi = round(cl(k[2] || 0, 0, 4));\n  if (mi !== s.knobMsg) {\n    s.knobMsg = mi;\n    prepare(s, mi);\n  }\n  s.clock += dt;\n  s.t += dt * rate;\n  const L = s.letters.length, R = s.n * 5;\n  for (let guard = 0; guard \u003c 40; guard++) {\n    if (s.phase === 0) {\n      if (s.t \u003c T_TYPE) break;\n      s.t -= T_TYPE;\n      s.born[s.typed++] = s.clock;\n      if (s.typed >= L) (s.phase = 1), (s.t = -0.25);\n    } else if (s.phase === 1) {\n      if (s.t \u003c T_READ) break;\n      s.t -= T_READ;\n      if (s.markAt[s.read] \u003c 0) s.markAt[s.read] = s.clock;\n      s.read++;\n      if (s.read % 5 === 0) (s.phase = 2), (s.setAt[s.read / 5 - 1] = s.clock);\n    } else if (s.phase === 2) {\n      if (s.t \u003c T_SET) break;\n      s.t -= T_SET;\n      s.set++;\n      s.phase = s.read >= R ? 3 : 1;\n    } else if (s.phase === 3) {\n      if (s.t \u003c T_HOLD) break;\n      s.t -= T_HOLD;\n      s.phase = 4;\n    } else {\n      if (s.t \u003c T_CLEAR) break;\n      prepare(s, (s.mi + 1) % MESSAGES.length);\n    }\n  }\n  // The mark under a letter is written 60% of the way through its reading.\n  if (s.phase === 1 && s.read \u003c R && s.t > 0.6 * T_READ && s.markAt[s.read] \u003c 0) s.markAt[s.read] = s.clock;\n}\n\nfunction glyphOf(s, ch, b) {\n  const key = b ? round(s.tell * 400) : 0;\n  if (b && key !== s.tellKey) (s.cache = {}), (s.tellKey = key);\n  const id = ch + (b ? \"b\" : \"a\");\n  if (!s.cache[id]) s.cache[id] = raster(ch, b ? key / 400 : 0);\n  return s.cache[id];\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const fb = s.fb;\n  const ha = 0.5 + s.hue;\n  const acc = hsv(ha, 0.85, 255), ink = hsv(ha + 0.6, 0.24, 225), bg = hsv(ha, 0.6, 7);\n  for (let i = 0; i \u003c W * H; i++) (fb[i * 3] = bg[0]), (fb[i * 3 + 1] = bg[1]), (fb[i * 3 + 2] = bg[2]);\n  const add = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n    const i = (y * W + x) * 3;\n    fb[i] = max(fb[i], c[0] * a);\n    fb[i + 1] = max(fb[i + 1], c[1] * a);\n    fb[i + 2] = max(fb[i + 2], c[2] * a);\n  };\n  const mix = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n    const i = (y * W + x) * 3;\n    fb[i] += (c[0] - fb[i]) * a;\n    fb[i + 1] += (c[1] - fb[i + 1]) * a;\n    fb[i + 2] += (c[2] - fb[i + 2]) * a;\n  };\n  const fade = s.phase === 4 ? 1 - cl(s.t / T_CLEAR, 0, 1) : 1;\n  const R = s.n * 5;\n  const reading = s.phase === 1 && s.t >= 0 && s.read \u003c R ? s.read : -1;\n  const p = reading >= 0 ? cl(s.t / T_READ, 0, 1) : 0;\n\n  // The reading light: a dim box behind the letter and a bright line\n  // crossing it left to right.\n  if (reading >= 0) {\n    const x0 = CX(reading % 5), y0 = CY(floor(reading / 5));\n    const env = sin(PI * cl(p * 1.15, 0, 1)) * 0.22 + 0.06;\n    for (let y = y0 - 1; y \u003c= y0 + 14; y++) for (let x = x0 - 2; x \u003c= x0 + 11; x++) add(x, y, acc, env);\n  }\n  // Cover letters.\n  for (let j = 0; j \u003c s.typed; j++) {\n    const c = j % 5, r = floor(j / 5), x0 = CX(c), y0 = CY(r);\n    const g = glyphOf(s, s.letters[j], s.fount[j]);\n    const age = s.clock - s.born[j], flash = cl(1 - age / 0.25, 0, 1);\n    let col = ink, lv = fade;\n    if (j >= R) lv *= 0.62;\n    // A group glows as its letter is set below; in the hold the b letters\n    // keep a tint.\n    const sa = j \u003c R ? s.setAt[floor(j / 5)] : -1;\n    let u = sa >= 0 ? 0.4 * cl(1 - (s.clock - sa) / 0.6, 0, 1) : 0;\n    if (s.phase === 3 && s.fount[j] && j \u003c R) u = max(u, 0.3);\n    if (u > 0) col = [ink[0] + (acc[0] - ink[0]) * u, ink[1] + (acc[1] - ink[1]) * u, ink[2] + (acc[2] - ink[2]) * u];\n    const scan = j === reading ? x0 - 1 + p * 12 : -99;\n    for (let y = 0; y \u003c 14; y++)\n      for (let gx = 0; gx \u003c GW; gx++) {\n        const v = g[y * GW + gx];\n        if (v \u003c= 0) continue;\n        const X = x0 + gx - GOX, Y = y0 + y;\n        mix(X, Y, col, v * lv);\n        if (flash > 0) mix(X, Y, [255, 255, 255], v * flash * 0.8);\n        const d = abs(X - scan);\n        if (d \u003c 1.5) mix(X, Y, [acc[0] * 0.5 + 127, acc[1] * 0.5 + 127, acc[2] * 0.5 + 127], v * (1 - d / 1.5));\n      }\n  }\n  if (reading >= 0) {\n    const x = round(CX(reading % 5) - 1 + p * 12), y0 = CY(floor(reading / 5));\n    for (let y = y0 - 1; y \u003c= y0 + 14; y++) add(x, y, acc, 0.55);\n  }\n  // Word dots in the gaps.\n  for (const j of s.dots)\n    if (j + 1 \u003c s.typed && j % 5 \u003c 4) {\n      const x = CX(j % 5) + 11, y = CY(floor(j / 5)) + 6;\n      add(x, y, ink, 0.5 * fade), add(x, y + 1, ink, 0.5 * fade);\n    }\n  // The a and b marks.\n  for (let j = 0; j \u003c R; j++) {\n    if (s.markAt[j] \u003c 0) continue;\n    const age = s.clock - s.markAt[j], m = MARK[s.fount[j]], x0 = CX(j % 5) + 3, y0 = CY(floor(j / 5)) + 15;\n    const grp = floor(j / 5), sa = s.setAt[grp];\n    let lv = cl(age / 0.12, 0, 1) * 0.78;\n    if (sa >= 0) lv = 0.78 + 0.22 * cl(1 - abs(s.clock - sa - 0.2) / 0.3, 0, 1);\n    for (let y = 0; y \u003c 5; y++) for (let x = 0; x \u003c 3; x++) if (m[y * 3 + x] === \"1\") add(x0 + x, y0 + y, acc, lv * fade);\n  }\n  // The rule over the hidden word, and the word.\n  for (let x = 2; x \u003c W - 2; x++) add(x, RULE, acc, 0.13 * fade);\n  for (let i = 0; i \u003c s.n; i++) {\n    if (s.setAt[i] \u003c 0) continue;\n    const age = s.clock - s.setAt[i], g = glyphOf(s, s.hidden[i], 0), x0 = CX(i);\n    const grow = cl(age / 0.3, 0, 1), flash = cl(1 - age / 0.5, 0, 1);\n    for (let y = 0; y \u003c 14; y++) {\n      if (y > grow * 14 + 0.5) continue;\n      for (let gx = 0; gx \u003c GW; gx++) {\n        const v = g[y * GW + gx];\n        if (v \u003c= 0) continue;\n        mix(x0 + gx - GOX, HY + y, acc, v * fade);\n        if (flash > 0) mix(x0 + gx - GOX, HY + y, [255, 255, 255], v * flash * 0.7 * fade);\n      }\n    }\n    // A soft glow under a freshly set letter.\n    if (flash > 0) for (let y = HY - 1; y \u003c= HY + 14; y++) for (let x = x0 - 1; x \u003c= x0 + 10; x++) add(x, y, acc, 0.12 * flash * fade);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, fb[i] | 0, fb[i + 1] | 0, fb[i + 2] | 0);\n    }\n}\n","clothesline":"// ===== Patternflow pattern =====\n// Title:   Clothesline\n// Family:  type\n// Idea:    Four ropes sag from wall to wall down the tall panel with ten letter cards pegged on them, 바람이 / 분다 / 살아야 / 겠다, and gusts cross the panel from the left so the cards swing on their pegs one after another like pendulums and twist on the line, the ropes lift and bob under them, and every card falls back to hanging straight once the gust has gone.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 72; the text is «Le vent se lève, il faut tenter de vivre» from Paul Valéry's Le Cimetière marin (1920) in the Korean it is usually given; the mean wind from the Beaufort scale (Francis Beaufort, 1805) by v = 0.836 B^(3/2) m/s; the Hangul syllables drawn as strokes for this pattern\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wind=2..7, Gust=0..1\n//\n// Knob 1: Hue. The card colour, the ink always cream: sea green at 0, azure at 0.25, blue violet at 0.5, magenta at 0.75 and rose red at 1, each card a little off its neighbours. The wheel skips orange, which on a dim card reads brown.\n// Knob 2: Speed. The time scale. At 2 a card left to itself swings once a second and a gust crosses the 64 columns in 1.6 s in a light breeze; at 1 everything is half as fast, at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Wind. The mean wind in Beaufort force. At the opening 2, a light breeze of 2.4 m/s, the cards lean 7 degrees and the gusts swing them to 20 or 35 and back past straight; at 4, 6.7 m/s, they lean 45 degrees; at 7, a near gale of 15.5 m/s, they fly 79 degrees out, almost flat, and the ropes pull from a 5-LED sag to 1.\n// Knob 4: Gust. Turbulence on top of the gust fronts. At 0 only the fronts, one every 1.5 to 3 s; at the opening 0.06 a little flutter; at 1 the fronts come twice as often and half as strong again, eddies throw neighbouring cards opposite ways and the cards twist round their pegs until some turn their backs, where the ink shows through mirrored.\n// Buttons: K1 tap sends a strong gust across the whole line.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sin, cos, exp, sqrt, tanh, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The cards' syllables, drawn as strokes in an 11 by 13 box, one unit\n// an LED: polylines, and ellipses [cx, cy, rx, ry] for the ㅇ. Each vowel\n// stands at column 8, each initial in columns 0 to 5 beside it.\nconst A_ = [[[8, 0], [8, 12]], [[8, 6], [10, 6]]];\nconst O_ = { e: [2.5, 6, 2.5, 3.6] };\nconst GLYPHS = {\n  바: [[[0, 1], [0, 11]], [[5, 1], [5, 11]], [[0, 6], [5, 6]], [[0, 11], [5, 11]], ...A_],\n  람: [[[0, 0], [5, 0], [5, 2], [0, 2], [0, 4], [5, 4]], [[8, 0], [8, 6]], [[8, 3], [10, 3]], [[1, 8], [9, 8], [9, 12], [1, 12], [1, 8]]],\n  이: [O_, [[8, 0], [8, 12]]],\n  분: [[[1, 0], [1, 4]], [[9, 0], [9, 4]], [[1, 2], [9, 2]], [[1, 4], [9, 4]], [[0, 6.5], [10, 6.5]], [[5, 6.5], [5, 8.5]], [[1, 10], [1, 12], [9, 12]]],\n  다: [[[5, 1], [0, 1], [0, 11], [5, 11]], ...A_],\n  살: [[[2.6, 0], [0, 5]], [[2.6, 0.5], [5.2, 5]], [[8, 0], [8, 6]], [[8, 3], [10, 3]], [[1, 8], [9, 8], [9, 10], [1, 10], [1, 12], [9, 12]]],\n  아: [O_, ...A_],\n  야: [O_, [[8, 0], [8, 12]], [[8, 4], [10, 4]], [[8, 8], [10, 8]]],\n  겠: [[[0, 0], [3.5, 0], [3.5, 5]], [[5, 3], [7, 3]], [[7, 0], [7, 6.5]], [[10, 0], [10, 7]], [[2.5, 8.5], [0.5, 12]], [[2.5, 8.5], [4.5, 12]], [[7.5, 8.5], [5.5, 12]], [[7.5, 8.5], [9.5, 12]]],\n};\n\n// Each glyph's distance field, 4 samples an LED over x -2..12 and y -2..14,\n// so a card turned to any angle samples its strokes smoothly.\nconst FS = 4, FX0 = -2, FY0 = -2, FW = 14 * FS + 1, FH = 16 * FS + 1;\nfunction segDist(px, py, ax, ay, bx, by) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy, t = l ? cl(((px - ax) * dx + (py - ay) * dy) / l, 0, 1) : 0;\n  const ex = px - ax - t * dx, ey = py - ay - t * dy;\n  return sqrt(ex * ex + ey * ey);\n}\nconst FIELD = {};\nfor (const key in GLYPHS) {\n  const F = new Float32Array(FW * FH);\n  for (let j = 0; j \u003c FH; j++)\n    for (let i = 0; i \u003c FW; i++) {\n      const x = FX0 + i / FS, y = FY0 + j / FS;\n      let d = 99;\n      for (const s of GLYPHS[key]) {\n        if (s.e) {\n          const [cx, cy, rx, ry] = s.e, ux = (x - cx) / rx, uy = (y - cy) / ry, r = sqrt(ux * ux + uy * uy);\n          // |r - 1| over the gradient of r: the distance to the ellipse near it.\n          const gx = ux / rx, gy = uy / ry, gl = sqrt(gx * gx + gy * gy);\n          d = min(d, gl > 1e-6 ? (abs(r - 1) * r) / gl : min(rx, ry));\n        } else for (let k = 1; k \u003c s.length; k++) d = min(d, segDist(x, y, s[k - 1][0], s[k - 1][1], s[k][0], s[k][1]));\n      }\n      F[j * FW + i] = d;\n    }\n  FIELD[key] = F;\n}\nfunction fieldAt(F, gx, gy) {\n  const fx = (gx - FX0) * FS, fy = (gy - FY0) * FS;\n  if (fx \u003c 0 || fy \u003c 0 || fx >= FW - 1 || fy >= FH - 1) return 99;\n  const i = floor(fx), j = floor(fy), u = fx - i, v = fy - j, o = j * FW + i;\n  return (F[o] * (1 - u) + F[o + 1] * u) * (1 - v) + (F[o + FW] * (1 - u) + F[o + FW + 1] * u) * v;\n}\n\n// ---- The line. Four ropes 32 rows apart, anchored at both walls with a\n// 5-LED sag; the cards 16 by 18, hung from a peg at the middle of the top.\nconst ROPES = [\n  { y: 5, cards: \"바람이\" },\n  { y: 37, cards: \"분다\" },\n  { y: 69, cards: \"살아야\" },\n  { y: 101, cards: \"겠다\" },\n];\nconst SAG = 5, CW = 8, CT = 1, CB = 19, GX = 5, GY = 4.5;\n// A card about its peg: centre of mass 10 LEDs down, J = I / m in LED^2.\nconst L = (CT + CB) / 2, J = (2 * CW) ** 2 / 12 + (CB - CT) ** 2 / 12 + L * L;\n// A swing of 1 s at small angles: g l / J = (2 pi)^2.\nconst G = (4 * PI * PI * J) / L;\n// Drag: tan(lean) = 0.022 v^2 for v in m/s, and 10 LED/s to a m/s.\nconst Q = 10, KD = (0.022 * G) / (Q * Q);\n\n// The rope hangs in a catenary, y = c cosh(x / c) about its lowest point:\n// a 5-LED sag over the 63 columns between the hooks makes c = 99, a pull\n// along the rope equal to the weight of 99 LEDs of it. A gust lifting it\n// shrinks the sag in the same shape, and tips it in a sine of the span.\nconst CC = 99, CH = Math.cosh(31.5 / CC) - 1;\nconst cat = (x) => (Math.cosh(31.5 / CC) - Math.cosh((x - 31.5) / CC)) / CH;\nconst tip = (x) => sin((2 * PI * x) / 63);\nfunction ropeY(r, x) {\n  return r.y + (SAG - r.b1) * cat(x) - r.b2 * tip(x);\n}\n\nexport function setup(params) {\n  const ropes = ROPES.map((R) => {\n    const n = [...R.cards].length, cards = [];\n    [...R.cards].forEach((ch, i) => {\n      const x = 32 + (i - (n - 1) / 2) * 20 + (Math.random() - 0.5) * 2;\n      cards.push({ ch, x, th: (Math.random() - 0.5) * 0.1, w: 0, ph: 0, pw: 0, dh: (Math.random() - 0.5) * 0.08 });\n    });\n    return { y: R.y, cards, b1: 0, v1: 0, a1: 0, b2: 0, v2: 0, a2: 0 };\n  });\n  params.s = { t: 0, ropes, gusts: [], next: 0.3, ph: [0, 1, 2, 3, 4, 5].map(() => Math.random() * 2 * PI), warm: false, hue: 0, speed: 2, B: 2, V: 24, gust: 0.06, F: new Float32Array(W * H * 3) };\n}\n\n// The wind across the panel, LED/s rightward, at sim time t.\nfunction windAt(S, x, y) {\n  const V = S.V, t = S.t;\n  let g = 0;\n  for (const q of S.gusts) {\n    const u = (x - q.x + 0.18 * (y - 64)) / q.s, v = (y - q.yc) / 90;\n    g += q.a * exp(-u * u - v * v);\n  }\n  const P = S.ph, k = S.gust;\n  // Turbulence: four drifting waves of different sizes.\n  const tu =\n    0.45 * sin(0.21 * (x - 0.8 * V * t) + 0.05 * y + P[0]) +\n    0.3 * sin(0.37 * (x - 0.8 * V * t) - 0.11 * y + 2.3 * t + P[1]) +\n    0.25 * sin(0.6 * x - 0.17 * y - 3.7 * t + P[2]) +\n    0.2 * sin(0.09 * y + 1.3 * t + P[3]);\n  return V * (1 + g + 1.6 * k * tu);\n}\n\nfunction step(S, h) {\n  S.t += h;\n  const V = S.V, k = S.gust;\n  // Gust fronts: born left of the panel every 1.5 to 3 s (twice as often at\n  // Gust 1), crossing at 0.9 V + 20 LED/s.\n  S.next -= h;\n  if (S.next \u003c= 0) {\n    S.next = (1.5 + Math.random() * 1.5) / (1 + k);\n    S.gusts.push({ x: -25, s: 8 + Math.random() * 5, a: (0.7 + Math.random() * 0.6) * (1 + 0.5 * k), yc: Math.random() * 128, c: 0.9 * V + 20 });\n  }\n  for (const q of S.gusts) q.x += q.c * h;\n  S.gusts = S.gusts.filter((q) => q.x \u003c 110);\n  for (const r of S.ropes) {\n    // The wind on its cards lifts the rope (the first mode) and tips it\n    // toward the side the gust has reached (the second); 0.9 and 1.6 Hz.\n    let l1 = 0, l2 = 0;\n    for (const c of r.cards) {\n      const py = ropeY(r, c.x), w = windAt(S, c.x, py + L);\n      c.wv = w;\n      c.wd = windAt(S, c.x + 6, py + L) - windAt(S, c.x - 6, py + L);\n      const f = (w * w) / (Q * Q) / 100;\n      l1 += f * cat(c.x);\n      l2 += f * tip(c.x);\n    }\n    const w1 = 2 * PI * 0.9, w2 = 2 * PI * 1.6;\n    r.a1 = -w1 * w1 * r.b1 - 0.5 * w1 * r.v1 + w1 * w1 * 4 * tanh(l1);\n    r.a2 = -w2 * w2 * r.b2 - 0.5 * w2 * r.v2 + w2 * w2 * 1.5 * tanh(l2 - 0.3 * l1);\n    r.v1 += r.a1 * h;\n    r.v2 += r.a2 * h;\n    r.b1 = min(SAG * 0.85, r.b1 + r.v1 * h);\n    r.b2 += r.v2 * h;\n    for (const c of r.cards) {\n      // The peg's own acceleration, down, changes the gravity the card feels.\n      const ay = -r.a1 * cat(c.x) - r.a2 * tip(c.x);\n      const ct = cos(c.th), st = sin(c.th), rel = c.wv - 0.5 * L * ct * c.w, F = KD * rel * abs(rel);\n      const acc = ((-(G - ay) * st + F * ct) * L) / J - 0.3 * c.w;\n      c.w += acc * h;\n      c.th += c.w * h;\n      // Twist about the peg: a gust front reaching one edge of the card\n      // before the other turns it, and a spring brings it back.\n      const target = cl(((0.5 * c.wd) / max(V, 1)) * (0.3 + 1.6 * k) * (0.7 + 0.08 * S.B) + c.dh, -1.5, 1.5);\n      c.pw += (16 * (target - c.ph) - 1.4 * c.pw) * h;\n      c.ph += c.pw * h;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kn[0] || 0;\n  S.speed = cl(kn[1], 0.2, 3);\n  S.B = cl(kn[2], 2, 7);\n  S.gust = cl(kn[3], 0, 1);\n  // Beaufort: v = 0.836 B^1.5 m/s.\n  S.V = 0.836 * S.B ** 1.5 * Q;\n  let T = d * (S.speed / 2);\n  if (input.btnPressed && input.btnPressed[0]) S.gusts.push({ x: -25, s: 12, a: 2.4, yc: 64, c: 0.9 * S.V + 20 });\n  // Start with the line already in the wind, 2.5 s in.\n  if (!S.warm) (S.warm = true), (T += 2.5);\n  const n = max(1, Math.ceil(T / (1 / 240)));\n  for (let i = 0; i \u003c n; i++) step(S, T / n);\n}\n\n// ---- Drawing.\nconst BG0 = [5, 7, 16], BG1 = [2, 3, 8];\nfunction blend(F, x, y, a, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  F[o] += (r - F[o]) * a;\n  F[o + 1] += (g - F[o + 1]) * a;\n  F[o + 2] += (b - F[o + 2]) * a;\n}\n\nfunction drawCard(S, F, r, c, ci) {\n  const px = c.x, py = ropeY(r, c.x), th = c.th, ct = cos(th), st = sin(th);\n  const cp = cos(c.ph), sx = max(0.06, abs(cp)), back = cp \u003c 0;\n  // The knob runs the cards from sea green through azure and violet to rose,\n  // past the oranges, which a dim card turns brown.\n  const hue = 0.42 + 0.56 * S.hue + ((ci * 0.37) % 1 - 0.5) * 0.07;\n  const card = hsv(hue, 0.78, back ? 0.3 : 0.5), ink = [1, 0.96, 0.86];\n  // Light from the upper left: a card turned away from it dims.\n  const lit = 0.55 + 0.45 * sx + 0.12 * st;\n  const Fg = FIELD[c.ch];\n  // Bounding box of the turned card and its peg.\n  let x0 = 99, x1 = -99, y0 = 99, y1 = -99;\n  for (const [u, v] of [[-CW, -3], [CW, -3], [-CW, CB], [CW, CB]]) {\n    const X = px + u * sx * ct + v * st, Y = py - u * sx * st + v * ct;\n    x0 = min(x0, X);\n    x1 = max(x1, X);\n    y0 = min(y0, Y);\n    y1 = max(y1, Y);\n  }\n  for (let Y = max(0, floor(y0) - 1); Y \u003c= min(H - 1, Math.ceil(y1) + 1); Y++)\n    for (let X = max(0, floor(x0) - 1); X \u003c= min(W - 1, Math.ceil(x1) + 1); X++) {\n      const dx = X - px, dy = Y - py, us = dx * ct - dy * st, v = dx * st + dy * ct;\n      // Coverage of the card, its edges antialiased in LEDs on the panel.\n      const cov = cl(CW * sx - abs(us) + 0.5, 0, 1) * cl(min(v - CT, CB - v) + 0.5, 0, 1);\n      if (cov > 0) {\n        const u = (back ? -us : us) / sx;\n        const dd = fieldAt(Fg, u + GX, v - GY);\n        // Ink: strokes 1.3 LEDs wide, faint and mirrored through the paper\n        // from behind.\n        const ik = cl(0.65 + 0.5 - dd * (0.6 + 0.4 * sx), 0, 1) * (back ? 0.18 : 1);\n        const shade = lit * (1 - 0.18 * max(0, (v - 12) / 7));\n        blend(F, X, Y, cov, (card[0] + (ink[0] - card[0]) * ik) * shade, (card[1] + (ink[1] - card[1]) * ik) * shade, (card[2] + (ink[2] - card[2]) * ik) * shade);\n      }\n      // The peg: a pale wooden clip 2.4 LEDs wide over the rope.\n      const pc = cl(1.2 - abs(us) + 0.5, 0, 1) * cl(min(v + 2.6, 3 - v) + 0.5, 0, 1);\n      if (pc > 0) blend(F, X, Y, pc, 0.82, 0.72, 0.55);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const F = S.F;\n  for (let y = 0, o = 0; y \u003c H; y++) {\n    const f = y / (H - 1);\n    for (let x = 0; x \u003c W; x++, o += 3) {\n      F[o] = (BG0[0] + (BG1[0] - BG0[0]) * f) / 255;\n      F[o + 1] = (BG0[1] + (BG1[1] - BG0[1]) * f) / 255;\n      F[o + 2] = (BG0[2] + (BG1[2] - BG0[2]) * f) / 255;\n    }\n  }\n  let ci = 0;\n  for (const r of S.ropes) {\n    // The rope, one LED thick, shared between the two rows it falls across.\n    for (let x = 0; x \u003c W; x++) {\n      const y = ropeY(r, x), iy = floor(y), f = y - iy;\n      blend(F, x, iy, 1 - f, 0.55, 0.5, 0.42);\n      blend(F, x, iy + 1, f, 0.55, 0.5, 0.42);\n    }\n    // Hooks in the walls.\n    blend(F, 0, r.y - 1, 1, 0.7, 0.7, 0.72);\n    blend(F, 63, r.y - 1, 1, 0.7, 0.7, 0.72);\n    for (const c of r.cards) drawCard(S, F, r, c, ci++);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(cl(F[o], 0, 1) * 255), round(cl(F[o + 1], 0, 1) * 255), round(cl(F[o + 2], 0, 1) * 255));\n}\n","coxeter-frieze":"// ===== Patternflow pattern =====\n// Title:   Conway-Coxeter Frieze\n// Family:  number\n// Idea:    A Conway-Coxeter frieze stands up the tall panel, its rows of whole numbers turned into columns between two columns of 1s and offset half a step into a lattice of diamonds, every diamond keeping ad - bc = 1 as the frieze drifts down past its glide; every 6 s the frieze dims, the triangulated polygon it comes from lights up with each vertex's count of triangles, one diagonal flips, and the frieze comes back recomputed with the numbers that changed flashing white.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: frieze patterns (H. S. M. Coxeter, \"Frieze patterns\", 1971), triangulated polygons and frieze patterns (John Conway and H. S. M. Coxeter, 1973), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sides=7..11, Chords=0..1\n//\n// Knob 1: Hue. Turns the numbers' colours round the wheel. At 0 the 2s are green, 3s teal, 4s cyan, 5s azure, 7s and 8s blue, 13s magenta, 21s red and 34s gold, each number on a diamond of its own colour at a fifth of the brightness; the 1s are white, the two border columns grey, and the flip is drawn in amber. At 0.5 the 2s are purple and the 8s yellow-green.\n// Knob 2: Speed. The frieze drifts down 1.5 Speed LEDs a second, 3 at the opening 2, so the heptagon's frieze, which repeats every 84 LEDs and mirrors itself left to right every 42, comes round in 28 s. A diagonal flips every 12 / Speed seconds: every 6 s at Speed 2, first at 4.2 s, every 60 s at 0.2 and 4 s at 3.\n// Knob 3: Sides. The polygon's n, 7 to 11, and the frieze's n - 1 columns. At the opening 7 there are 6 columns and the 42 triangulations of the heptagon give numbers up to 8; the largest number over all triangulations is a Fibonacci number, 13 for the octagon's 132, then 21, 34 and 55 for 11 sides and 4862 triangulations. Columns that can hold two digits are 7 LEDs wide, the rest 3. A new n starts from a fan and 4n random flips.\n// Knob 4: Chords. Every number in the frieze is m(i, j) for the chord from vertex i to vertex j. At 0 the numbers are coloured by value; at 1 by the direction of their chord, so parallel chords share a colour, and the numbers standing at one height are one family of parallel chords. Between the two the colours blend; at the opening 0.06 they are nearly all by value.\n\n// Coxeter (1971): a frieze is rows of numbers between a row of 0s and 1s\n// above and of 1s and 0s below, each row offset half a step, where every\n// diamond b over a, d over c holds ad - bc = 1. Conway and Coxeter (1973):\n// the friezes of positive whole numbers with n - 1 rows between the 0s are\n// the triangulations of an n-gon, the row after the 1s counting the\n// triangles at each vertex, its quiddity. The entries are m(i, j) for\n// vertices i and j, with m(i, i) = 0, m(i, i + 1) = 1 and\n// m(i, j + 1) = a_j m(i, j) - m(i, j - 1); m(i, j) = 1 exactly where i j is\n// a side or a diagonal of the triangulation, and m(i, j) = m(j, i + n), the\n// glide. Both were checked against every triangulation from 5 to 11 sides.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, cos, sin, log2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst STEP = 12; // LEDs between one entry and the next down a column\nconst CX = 31.5, CY = 63.5, RX = 24.5, RY = 50; // the polygon, an ellipse's n-gon\n\n// 3 x 5 digits, one octal digit a row from the top, 4 = left column.\nconst FONT = [0o75557, 0o26227, 0o71747, 0o71717, 0o55711, 0o74717, 0o74757, 0o71122, 0o75757, 0o75717];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- The triangulation: an n by n table of sides and diagonals. ----\nconst linked = (S, i, j) => S.adj[i * S.n + j] === 1;\nfunction link(S, i, j, v) {\n  S.adj[i * S.n + j] = v;\n  S.adj[j * S.n + i] = v;\n}\nfunction diagonals(S) {\n  const n = S.n, out = [];\n  for (let i = 0; i \u003c n; i++) for (let j = i + 2; j \u003c n; j++) if (!(i === 0 && j === n - 1) && linked(S, i, j)) out.push(i, j);\n  return out;\n}\n// The two triangles on diagonal i j: the vertices joined to both, one on\n// each side. In a triangulated convex polygon every three mutually joined\n// vertices bound a triangle.\nfunction apexes(S, i, j) {\n  const out = [];\n  for (let k = 0; k \u003c S.n; k++) if (k !== i && k !== j && linked(S, i, k) && linked(S, j, k)) out.push(k);\n  return out;\n}\nfunction flip(S, i, j) {\n  const [k, l] = apexes(S, i, j);\n  link(S, i, j, 0);\n  link(S, k, l, 1);\n  return [k, l];\n}\n\n// ---- The frieze from the triangulation, checked. ----\nfunction build(S) {\n  const n = S.n, a = new Int32Array(n), M = [];\n  for (let i = 0; i \u003c n; i++) for (let j = 0; j \u003c n; j++) a[i] += S.adj[i * n + j];\n  for (let i = 0; i \u003c n; i++) a[i] -= 1; // triangles at i: its sides and diagonals less one\n  for (let i = 0; i \u003c n; i++) {\n    const r = new Int32Array(n + 1);\n    r[1] = 1;\n    for (let k = 1; k \u003c n; k++) r[k + 1] = a[(i + k) % n] * r[k] - r[k - 1];\n    M.push(r);\n  }\n  // Every diamond: a = m(i, i + k) over d = m(i + 1, i + 1 + k), with\n  // b = m(i + 1, i + k) and c = m(i, i + k + 1) beside them; the 1s and 0s\n  // closing every column; every entry between them positive.\n  let ok = true, checked = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const R = M[i], Q = M[(i + 1) % n];\n    if (R[n - 1] !== 1 || R[n] !== 0) ok = false;\n    for (let k = 1; k \u003c= n - 2; k++, checked++) if (R[k] * Q[k] - Q[k - 1] * R[k + 1] !== 1) ok = false;\n    for (let k = 1; k \u003c n; k++) if (R[k] \u003c 1) ok = false;\n  }\n  return { a, M, ok, checked };\n}\n\n// A random triangulation: a fan from vertex 0, then 4n random flips.\nfunction fresh(S, n) {\n  S.n = n;\n  S.adj = new Uint8Array(n * n);\n  for (let i = 0; i \u003c n; i++) link(S, i, (i + 1) % n, 1);\n  for (let j = 2; j \u003c n - 1; j++) link(S, 0, j, 1);\n  for (let t = 0; t \u003c 4 * n; t++) {\n    const d = diagonals(S), q = 2 * floor((Math.random() * d.length) / 2);\n    flip(S, d[q], d[q + 1]);\n  }\n  const f = build(S);\n  S.a = f.a;\n  S.M = f.M;\n  S.checked = f.checked;\n  S.flash = new Float32Array(n * (n + 1)).fill(-99);\n  S.old = null;\n  S.neu = null;\n  S.pick = null;\n  // Fixed column widths: 3 LEDs, or 7 where two digits can come, columns\n  // 3 to n - 3 from the octagon on; the spare LEDs shared out as gaps.\n  const wd = [];\n  let used = 0;\n  for (let k = 1; k \u003c n; k++) {\n    const w = n >= 8 && k >= 3 && k \u003c= n - 3 ? 7 : 3;\n    wd.push(w);\n    used += w;\n  }\n  const gap = (W - used) / (n - 1);\n  S.colX = [];\n  let x = gap / 2;\n  for (let k = 0; k \u003c n - 1; k++) {\n    S.colX.push(x + wd[k] / 2);\n    x += wd[k] + gap;\n  }\n  // For each LED column, the frieze columns either side of it (1 to n - 1).\n  S.near = new Int8Array(2 * W);\n  for (let X = 0; X \u003c W; X++) {\n    let k = 1;\n    while (k \u003c n - 1 && S.colX[k] \u003c= X) k++;\n    S.near[2 * X] = X \u003c S.colX[0] ? 1 : k;\n    S.near[2 * X + 1] = X \u003c S.colX[0] ? 1 : min(k + 1, n - 1);\n  }\n  // Colour and flash of the 14 entries in view down each column.\n  S.EC = [];\n  for (let k = 0; k \u003c n; k++) S.EC.push(new Float32Array(14 * 5));\n  S.I0 = new Int32Array(n);\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, n: 0, chords: 0.06, t: 0, scroll: 0, cyc: 0.5, pick: null, flips: 0, bad: 0, buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.chords = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 7, 11));\n  if (n !== S.n) fresh(S, n);\n  S.t += d;\n  S.scroll += d * 1.5 * S.speed;\n  // The flip cycle, 12 / Speed seconds: the polygon fades in over the first\n  // 8 per cent, the diagonal flips at 20, the polygon fades out from 32 to 40\n  // and the changed numbers flash as the frieze comes back.\n  S.cyc += (d * S.speed) / 12;\n  if (S.cyc >= 1) {\n    // A new cycle picks the diagonal to flip, not the one the last flip\n    // made, which would only flip back.\n    S.cyc -= 1;\n    const dg = diagonals(S);\n    let q = 2 * floor((Math.random() * dg.length) / 2);\n    if (S.neu && dg.length > 2 && dg[q] === S.neu[0] && dg[q + 1] === S.neu[1]) q = (q + 2) % dg.length;\n    S.pick = [dg[q], dg[q + 1]];\n  }\n  if (S.pick && S.cyc >= 0.2) {\n    const [i, j] = S.pick, kl = flip(S, i, j), f = build(S);\n    S.pick = null;\n    if (f.ok) {\n      // The changed entries flash from the moment the frieze comes back.\n      const at = S.t + ((0.32 - S.cyc) * 12) / S.speed;\n      for (let r = 0; r \u003c n; r++) for (let c = 1; c \u003c n; c++) if (f.M[r][c] !== S.M[r][c]) S.flash[r * (n + 1) + c] = at;\n      S.a = f.a;\n      S.M = f.M;\n      S.old = [i, j];\n      S.neu = [min(kl[0], kl[1]), max(kl[0], kl[1])];\n      S.flips++;\n    } else {\n      // Never seen: a frieze that fails a diamond keeps the old triangulation.\n      link(S, kl[0], kl[1], 0);\n      link(S, i, j, 1);\n      S.bad++;\n    }\n    S.checked = f.checked;\n  }\n}\n\n// Additive soft line into the buffer, a splat every quarter LED.\nfunction line(buf, x0, y0, x1, y1, r, g, b) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), steps = max(1, round(len * 4));\n  for (let s = 0; s \u003c= steps; s++) {\n    const t = s / steps, x = x0 + (x1 - x0) * t, y = y0 + (y1 - y0) * t, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const X = ix + dx, Y = iy + dy;\n        if (X \u003c 0 || Y \u003c 0 || X >= W || Y >= H) continue;\n        const w = (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy) * 0.25, o = (Y * W + X) * 3;\n        buf[o] = max(buf[o], min(1, buf[o] + r * w));\n        buf[o + 1] = max(buf[o + 1], min(1, buf[o + 1] + g * w));\n        buf[o + 2] = max(buf[o + 2], min(1, buf[o + 2] + b * w));\n      }\n  }\n}\n\n// One 3 x 5 digit with its top left at (x, y).\nfunction digit(buf, d, x, y, r, g, b) {\n  const f = FONT[d];\n  for (let row = 0; row \u003c 5; row++) {\n    const Y = y + row;\n    if (Y \u003c 0 || Y >= H) continue;\n    const bits = (f >> (3 * (4 - row))) & 7;\n    for (let c = 0; c \u003c 3; c++)\n      if (bits & (4 >> c)) {\n        const X = x + c;\n        if (X \u003c 0 || X >= W) continue;\n        const o = (Y * W + X) * 3;\n        buf[o] = r;\n        buf[o + 1] = g;\n        buf[o + 2] = b;\n      }\n  }\n}\n// A number 1 to 99 centred on (cx, cy).\nfunction number(buf, v, cx, cy, r, g, b) {\n  const y = round(cy) - 2;\n  if (v \u003c 10) digit(buf, v, round(cx - 1.5), y, r, g, b);\n  else {\n    const x = round(cx - 3.5);\n    digit(buf, floor(v / 10) % 10, x, y, r, g, b);\n    digit(buf, v % 10, x + 4, y, r, g, b);\n  }\n}\n\nconst vx = (S, v) => CX + RX * cos((2 * PI * v) / S.n - PI / 2);\nconst vy = (S, v) => CY + RY * sin((2 * PI * v) / S.n - PI / 2);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) {\n    for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n    return;\n  }\n  const { buf, n, M, colX, EC, I0 } = S, c = S.cyc, tmp = [0, 0, 0], acc = [0, 0, 0];\n  // How far the polygon has come in: 0 on the frieze alone, 1 at full.\n  const sm = (e) => e * e * (3 - 2 * e);\n  const ov = c \u003c 0.08 ? sm(c / 0.08) : c \u003c 0.32 ? 1 : c \u003c 0.4 ? sm(1 - (c - 0.32) / 0.08) : 0, fr = 1 - 0.85 * ov;\n  const hue0 = S.hue + 0.12;\n  hsv(hue0, 0.75, 1, acc);\n\n  // ---- Each entry's colour. Column k holds m(i, i + k) at height\n  // i + k / 2 steps. By value: 1s white, the border's dimmer, the rest round\n  // the wheel by log2 of the value. By chord: hue from (i + j) mod n. ----\n  for (let k = 1; k \u003c n; k++) {\n    const i0 = (I0[k] = Math.ceil((-STEP - S.scroll) / STEP - k / 2)), e = EC[k];\n    for (let q = 0; q \u003c 14; q++) {\n      const i = i0 + q, r = ((i % n) + n) % n, v = M[r][k];\n      const edge = k === 1 || k === n - 1;\n      if (v === 1) tmp[0] = tmp[1] = tmp[2] = edge ? 0.6 : 1;\n      else hsv(hue0 + 0.2 * log2(v), 0.8, 1, tmp);\n      if (S.chords > 0) {\n        const t = tmp.slice();\n        hsv(hue0 + ((2 * r + k) % n) / n, 0.75, 1, tmp);\n        for (let z = 0; z \u003c 3; z++) tmp[z] = t[z] + (tmp[z] - t[z]) * S.chords;\n      }\n      // A changed number flashes white for 0.4 s and fades back over 1.2 s.\n      const age = S.t - S.flash[r * (n + 1) + k];\n      const wf = age >= 0 && age \u003c 1.6 ? (age \u003c 0.4 ? 1 : 1 - (age - 0.4) / 1.2) : 0;\n      for (let z = 0; z \u003c 3; z++) e[q * 4 + z] = tmp[z] + (1 - tmp[z]) * wf;\n      e[q * 4 + 3] = wf;\n      // How bright its diamond is: 0.2 of the colour, 0.1 for a 1 inside\n      // and 0.05 on the border.\n      e[56 + q] = v > 1 ? 0.2 : edge ? 0.083 : 0.1;\n    }\n  }\n\n  // ---- Tiles: every LED belongs to the nearest entry in a diamond metric,\n  // so each number sits on a diamond of its colour at 0.2, and LEDs on a\n  // boundary between two diamonds stay dark. ----\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) {\n      const a = S.near[2 * x], b = S.near[2 * x + 1], h = b > a ? (colX[b - 1] - colX[a - 1]) / 2 : 6;\n      let d1 = 9, d2 = 9, kb = 0, qb = 0;\n      for (const k of a === b ? [a] : [a, b]) {\n        const u = (y - S.scroll) / STEP - k / 2, i = round(u), dd = abs(x - colX[k - 1]) / h + (abs(u - i) * STEP) / (STEP / 2);\n        if (dd \u003c d1) (d2 = d1), (d1 = dd), (kb = k), (qb = i - I0[k]);\n        else if (dd \u003c d2) d2 = dd;\n      }\n      if (d2 - d1 \u003c 0.16 || qb \u003c 0 || qb > 13) {\n        buf[o] = buf[o + 1] = buf[o + 2] = 0;\n        continue;\n      }\n      const e = EC[kb], g = (e[56 + qb] + 0.3 * e[qb * 4 + 3]) * fr;\n      buf[o] = e[qb * 4] * g;\n      buf[o + 1] = e[qb * 4 + 1] * g;\n      buf[o + 2] = e[qb * 4 + 2] * g;\n    }\n\n  // ---- The numbers. ----\n  for (let k = 1; k \u003c n; k++) {\n    const e = EC[k];\n    for (let q = 0; q \u003c 14; q++) {\n      const i = I0[k] + q, r = ((i % n) + n) % n, y = (i + k / 2) * STEP + S.scroll, lv = fr + (1 - fr) * e[q * 4 + 3];\n      number(buf, M[r][k], colX[k - 1], y, e[q * 4] * lv, e[q * 4 + 1] * lv, e[q * 4 + 2] * lv);\n    }\n  }\n\n  // ---- In the flip, the polygon over the dimmed frieze: sides grey,\n  // diagonals white. The chosen diagonal pulses in the accent colour from\n  // 0.08 of the cycle, fades from 0.2 to 0.26, and the new one grows from\n  // one end to the other from 0.2 to 0.28. Each vertex carries its count of\n  // triangles, the quiddity, the four the flip changes in the accent. ----\n  if (ov > 0) {\n    for (let v = 0; v \u003c n; v++) line(buf, vx(S, v), vy(S, v), vx(S, (v + 1) % n), vy(S, (v + 1) % n), 0.6 * ov, 0.6 * ov, 0.6 * ov);\n    const hot = c \u003c 0.2 ? S.pick : null, grow = c >= 0.2 && c \u003c 0.28 ? S.neu : null;\n    for (let i = 0; i \u003c n; i++)\n      for (let j = i + 2; j \u003c n; j++) {\n        if ((i === 0 && j === n - 1) || !linked(S, i, j)) continue;\n        if (hot && hot[0] === i && hot[1] === j) {\n          const e = (c \u003c 0.08 ? 1 : 0.6 + 0.4 * cos((c - 0.08) * 160)) * ov;\n          line(buf, vx(S, i), vy(S, i), vx(S, j), vy(S, j), acc[0] * e, acc[1] * e, acc[2] * e);\n        } else if (grow && grow[0] === i && grow[1] === j) {\n          const g = (c - 0.2) / 0.08, x0 = vx(S, i), y0 = vy(S, i);\n          line(buf, x0, y0, x0 + (vx(S, j) - x0) * g, y0 + (vy(S, j) - y0) * g, acc[0] * ov, acc[1] * ov, acc[2] * ov);\n        } else line(buf, vx(S, i), vy(S, i), vx(S, j), vy(S, j), ov, ov, ov);\n      }\n    if (S.old && c >= 0.2 && c \u003c 0.26) {\n      const e = (1 - (c - 0.2) / 0.06) * ov, [i, j] = S.old;\n      line(buf, vx(S, i), vy(S, i), vx(S, j), vy(S, j), acc[0] * e, acc[1] * e, acc[2] * e);\n    }\n    for (let v = 0; v \u003c n; v++) {\n      const ang = (2 * PI * v) / n - PI / 2, lx = CX + (RX + 6) * cos(ang), ly = CY + (RY + 7) * sin(ang);\n      const touched = S.old && c >= 0.2 && c \u003c 0.4 && (v === S.old[0] || v === S.old[1] || v === S.neu[0] || v === S.neu[1]);\n      if (touched) number(buf, S.a[v], lx, ly, acc[0] * ov, acc[1] * ov, acc[2] * ov);\n      else number(buf, S.a[v], lx, ly, ov, ov, ov);\n    }\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(buf[o] * 255), round(buf[o + 1] * 255), round(buf[o + 2] * 255));\n}\n","hydra-game":"// ===== Patternflow pattern =====\n// Title:   Hydra Game\n// Family:  algo\n// Idea:    Hercules fights Kirby and Paris's hydra, a tree rooted at the bottom of the panel with glowing heads on writhing necks: at step n he cuts one head, and unless its neck grows from the root, the node one level further down grows n copies of the branch the head was cut from, which sprout from it in gold, so the hydra swells into a dense fan of hundreds or thousands of heads while its ordinal at the top, the sum of omega to the power of each branch's ordinal, falls at every cut, and the cuts come faster and faster until the last head drops and the root stands alone.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hydra game (Laurie Kirby and Jeff Paris, Accessible independence results for Peano arithmetic, Bulletin of the London Mathematical Society, 1982), a tree's ordinal in Cantor normal form (Georg Cantor), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hydra=1..5, Strategy=0..3\n//\n// Knob 1: Hue. Turns the hydra round the wheel. At 0 the necks are green, the heads pale mint and new growth gold; at 0.25 the necks are azure and new growth green, at 0.5 magenta with sky-blue growth, at 0.75 amber with pink growth.\n// Knob 2: Speed. Cuts a second, 0.9 Speed (1 + n / 8) at step n, so the cuts come faster as the hydra grows. At the opening 2 the hydra grows out of its root in the first second, the first cut falls at 1.6 s, step 40 at 9.3 s, and hydra 1 dies at step 1149 at 23.5 s; at 3 that death comes at 16 s, at 0.2 at 225 s. The dead root waits 3.5 s and the hydra grows again.\n// Knob 3: Hydra. Five starting hydras, by whole steps, with their deaths under the rightmost cut. 1: ω²+ω+1, a two-headed neck, a one-headed neck and a head on the root, 7 nodes; dead at step 1149, 576 nodes at its biggest. 2: ω^ω, one neck of three, dead at step 37 with 20 nodes at most. 3: ω²+ω·2, dead at step 445, 224 nodes. 4: ω²+ω+2, dead at step 5629, 2816 nodes. 5: ω²+ω·2+2, 10 nodes, dead at step 2302, 1153 nodes. Levels stand 50 LEDs apart for the hydras two necks high and 33 for the neck of three.\n// Knob 4: Strategy. Which head Hercules cuts, by whole steps: 0 the rightmost head, 1 the leftmost, 2 a random branch at every fork, 3 the deepest head, the rightmost of them. The order changes the length of the fight up to 234 times: hydra 4 dies at step 5629 cut from the right and at 24 from the deepest end; hydra 1 at 1149 from the right, 30 from the left and 23 from the deepest end, and 2000 random hunts on it took 17 to 441 steps. Hydras 2, 3 and 5 are symmetric enough that the leftmost cut takes as long as the rightmost. A hunt whose regrowth would pass 8000 nodes is called off and shown as MAX; in 2000 random hunts on hydra 5 that happened twice.\n// Buttons: K1 tap grows the hydra again from its root.\n\n// Kirby and Paris (1982): a hydra is a finite rooted tree and its heads are\n// the leaves. At step n Hercules cuts a head. If its neck grows from the\n// root, the head is simply gone; otherwise the node below that neck's own\n// node grows n copies of the branch the head was cut from. Every way of\n// choosing heads kills every hydra in finitely many steps, and Peano\n// arithmetic cannot prove it. The proof gives each node the ordinal o(v),\n// the sum of omega^o(c) over its children c in Cantor normal form, biggest\n// terms first. A cut lowers one term and adds n smaller ones, so the root's\n// ordinal falls at every step, and ordinals below epsilon_0 cannot fall\n// forever; the hydra needs all of them, more than Peano arithmetic reaches.\n//\n// The panel can draw a few thousand heads, which leaves the hydras below\n// omega^3 and the single neck of three. The rightmost cut on omega^2 with\n// nothing beside it, first met at step m, ends at step (m + 3) 2^(m + 1) - 3:\n// 13 for m = 1, 1149 for m = 6. Two such necks, omega^2 2, die at step\n// 557053 with 278528 nodes at their biggest.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sin, cos, exp, sqrt, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The root's children as brackets, each pair a node, an empty pair a head.\nconst HYDRAS = [\"(()())(())()\", \"((()))\", \"(())(()())(())\", \"(()())(())()()\", \"()(())(()())(())()\"];\nconst CAP = 8000;\nconst ROOT_X = 31.5, ROOT_Y = 124, TOP_Y = 24;\nconst HUE0 = 0.36;\n\nfunction mk(p, x, y, t) {\n  return { p, c: [], x, y, tx: x, ty: y, dx: 0, b: t, ph: Math.random() * 2 * PI, k: 1, h: 0 };\n}\nfunction clone(v, p, x, y, t) {\n  const u = mk(p, x, y, t);\n  for (const c of v.c) u.c.push(clone(c, u, x, y, t));\n  return u;\n}\nfunction size(v) {\n  let s = 1;\n  for (const c of v.c) s += size(c);\n  return s;\n}\nfunction height(v) {\n  let h = 0;\n  for (const c of v.c) h = max(h, height(c) + 1);\n  return (v.h = h);\n}\n\n// ---- Ordinals below epsilon_0: a list of [exponent, coefficient] terms,\n// exponents falling, each exponent an ordinal of the same kind; [] is 0.\nfunction cmpO(a, b) {\n  for (let i = 0; i \u003c a.length && i \u003c b.length; i++) {\n    const c = cmpO(a[i][0], b[i][0]);\n    if (c) return c;\n    if (a[i][1] !== b[i][1]) return a[i][1] - b[i][1];\n  }\n  return a.length - b.length;\n}\nfunction ord(v) {\n  if (!v.c.length) return [];\n  const ex = v.c.map(ord).sort((a, b) => cmpO(b, a)), out = [];\n  for (const e of ex) {\n    const l = out[out.length - 1];\n    if (l && !cmpO(l[0], e)) l[1]++;\n    else out.push([e, 1]);\n  }\n  return out;\n}\n\n// ---- The game.\nfunction restart(S, hy) {\n  S.hy = hy;\n  const root = mk(null, ROOT_X, ROOT_Y, S.t), st = [root];\n  for (const ch of HYDRAS[hy]) {\n    if (ch === \"(\") {\n      const v = mk(st[st.length - 1], ROOT_X, ROOT_Y, S.t);\n      st[st.length - 1].c.push(v);\n      st.push(v);\n    } else st.pop();\n  }\n  S.root = root;\n  S.nodes = size(root);\n  // Levels share the 100 rows above the root: 50 apart for a hydra two\n  // necks high, 33 for three.\n  S.sp = min(50, floor((ROOT_Y - TOP_Y) / height(root)));\n  S.n = 0;\n  S.acc = 0;\n  S.state = 0;\n  S.st = 0;\n  S.grow = 1;\n  S.dirty = true;\n  S.fx = [];\n  aim(S);\n}\n\n// The head Hercules cuts next, as the branch index taken at each fork.\nfunction aim(S) {\n  const path = [];\n  let v = S.root;\n  if (S.strat === 3) height(S.root);\n  while (v.c.length) {\n    const n = v.c.length;\n    let i = n - 1;\n    if (S.strat === 1) i = 0;\n    else if (S.strat === 2) i = floor(Math.random() * n);\n    else if (S.strat === 3) for (const want = v.h - 1; i > 0 && v.c[i].h !== want; i--);\n    path.push(i);\n    v = v.c[i];\n  }\n  S.path = path;\n  S.aim = path.length ? v : null;\n}\n\nfunction chop(S) {\n  const path = S.path;\n  let g = null, p = null, v = S.root;\n  for (let d = 0; d \u003c path.length; d++) (g = p), (p = v), (v = v.c[path[d]]);\n  const n = ++S.n;\n  p.c.splice(path[path.length - 1], 1);\n  S.nodes--;\n  S.dirty = true;\n  if (S.fx.length \u003c 28) S.fx.push({ cx: v.x + v.dx, cy: v.y, x: v.x + v.dx, y: v.y, vx: (Math.random() - 0.5) * 14, vy: -14, a: 0 });\n  if (g) {\n    const s = size(p);\n    if (S.nodes + n * s > CAP) {\n      S.state = 2;\n      S.st = 0;\n      return;\n    }\n    const at = path[path.length - 2] + 1, copies = [];\n    for (let j = 0; j \u003c n; j++) copies.push(clone(p, g, g.x + g.dx, g.y, S.t));\n    g.c = g.c.slice(0, at).concat(copies, g.c.slice(at));\n    S.nodes += n * s;\n  }\n  if (!S.root.c.length) {\n    S.state = 1;\n    S.st = 0;\n    S.aim = null;\n    return;\n  }\n  aim(S);\n}\n\n// Heads under each node, then a span of the 60 columns for each node in\n// proportion to its heads, levels S.sp apart up from the root. A node that\n// still carries necks keeps at least 4 heads' width, so a few branches stay\n// apart beside a fan of hundreds.\nfunction count(v) {\n  if (!v.c.length) return (v.k = v.w = 1);\n  let s = 0, w = 0;\n  for (const c of v.c) (s += count(c)), (w += c.w);\n  v.w = max(4, w);\n  return (v.k = s);\n}\nfunction place(S, v, a, b, d) {\n  v.tx = (a + b) / 2;\n  v.ty = ROOT_Y - d * S.sp;\n  let x = a, sw = 0;\n  for (const c of v.c) sw += c.w;\n  for (const c of v.c) {\n    const w = ((b - a) * c.w) / sw;\n    place(S, c, x, x + w, d + 1);\n    x += w;\n  }\n}\nfunction ease(S, v, e, d) {\n  v.x += (v.tx - v.x) * e;\n  v.y += (v.ty - v.y) * e;\n  // The necks writhe: a head sways up to 0.7 LED a level.\n  v.dx = d ? sin(S.t * 1.7 + v.ph) * 0.7 * d : 0;\n  for (const c of v.c) ease(S, c, e, d + 1);\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, speed: 2, strat: 0, hy: -1, A: new Float32Array(N * 3), O: new Uint8ClampedArray(N * 3), ordv: [], fx: [] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const hy = cl(round(k[2]), 1, 5) - 1, strat = cl(round(k[3]), 0, 3);\n  S.t += d;\n  if (hy !== S.hy || (input.btnPressed && input.btnPressed[0])) restart(S, hy);\n  if (strat !== S.strat) {\n    S.strat = strat;\n    if (S.state === 0) aim(S);\n  }\n  if (S.state === 0) {\n    if (S.grow > 0) S.grow -= d;\n    else {\n      S.acc += d * S.speed * 0.9 * (1 + S.n / 8);\n      for (let m = 0; S.acc >= 1 && S.state === 0; m++) {\n        if (m === 600) {\n          S.acc = 0;\n          break;\n        }\n        chop(S);\n        S.acc -= 1;\n      }\n    }\n  } else {\n    S.st += d;\n    if (S.st > (S.state === 1 ? 3.5 : 2)) restart(S, S.hy);\n  }\n  count(S.root);\n  place(S, S.root, 1.5, 61.5, 0);\n  ease(S, S.root, 1 - exp(-d * 7), 0);\n  if (S.dirty) {\n    S.ordv = ord(S.root);\n    S.heads = S.root.c.length ? S.root.k : 0;\n    S.dirty = false;\n  }\n  for (const f of S.fx) {\n    f.a += d;\n    f.vy += 70 * d;\n    f.x += f.vx * d;\n    f.y += f.vy * d;\n  }\n  S.fx = S.fx.filter((f) => f.a \u003c 1.6 && f.y \u003c H + 2);\n}\n\n// ---- Drawing into a light buffer, then 1 - exp(-light) per channel.\nfunction splat(A, x, y, r, g, b) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++) {\n    const yy = iy + j;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = j ? fy : 1 - fy;\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = wy * (i ? fx : 1 - fx), o = (yy * W + xx) * 3;\n      A[o] += r * w;\n      A[o + 1] += g * w;\n      A[o + 2] += b * w;\n    }\n  }\n}\n// A neck: it leaves its node straight up and bends over to the child,\n// 2.8 LEDs thick at the node and 1.4 at the head, in a faint glow, and a\n// wave of up to 1.1 LEDs runs up it at phase ph.\nfunction neck(A, x0, y0, x1, y1, col, w, thick, ph) {\n  const ky = y0 + (y1 - y0) * 0.6, n = 2 + floor(max(abs(x1 - x0), abs(y1 - y0)) * 1.25);\n  const r = col[0] * w, g = col[1] * w, b = col[2] * w;\n  for (let i = 1; i \u003c n; i++) {\n    const t = i / n, u = 1 - t, y = u * u * y0 + 2 * u * t * ky + t * t * y1;\n    let x = u * u * x0 + 2 * u * t * x0 + t * t * x1;\n    if (!thick) {\n      splat(A, x, y, r, g, b);\n      continue;\n    }\n    x += 1.1 * sin(PI * t) * sin(ph - 5 * t);\n    // Across the neck: the normal to the curve's tangent.\n    let tx = 2 * t * (x1 - x0), ty = 2 * u * (ky - y0) + 2 * t * (y1 - ky);\n    const l = sqrt(tx * tx + ty * ty) || 1, half = (2.8 - 1.4 * t) / 2;\n    tx /= l;\n    ty /= l;\n    for (let j = -1; j \u003c= 1; j++) {\n      const q = j ? 0.45 : 0.8;\n      splat(A, x - ty * half * j, y + tx * half * j, r * q, g * q, b * q);\n    }\n    // and its glow, 1.5 LEDs further out each side.\n    for (let j = -1; j \u003c= 1; j += 2) splat(A, x - ty * (half + 1.5) * j, y + tx * (half + 1.5) * j, r * 0.22, g * 0.22, b * 0.22);\n  }\n}\nfunction headDot(A, x, y, col, w) {\n  splat(A, x, y - 0.5, col[0] * w * 1.6, col[1] * w * 1.6, col[2] * w * 1.6);\n  const q = w * 0.45;\n  for (const [i, j] of [[-1.2, 0], [1.2, 0], [0, -1.6], [-0.9, -1.2], [0.9, -1.2]]) splat(A, x + i, y + j, col[0] * q, col[1] * q, col[2] * q);\n}\n// The neck colour, gold for a branch just grown and back to the hydra's in\n// a second.\nconst MIX = [0, 0, 0];\nfunction tint(C, age) {\n  const f = age \u003c 1 ? (1 - age) * (1 - age) : 0;\n  for (let i = 0; i \u003c 3; i++) MIX[i] = C.neck[i] + (C.gold[i] - C.neck[i]) * f;\n  return MIX;\n}\nconst BN = new Float32Array(64), BX = new Float32Array(64), BY = new Float32Array(64), BA = new Float32Array(64), BL = new Float32Array(64);\nfunction drawNode(S, A, C, v) {\n  const n = v.c.length;\n  if (!n) return;\n  const px = v.x + v.dx, py = v.y;\n  if (n \u003c= 48) {\n    for (const c of v.c) {\n      const cx = c.x + c.dx;\n      neck(A, px, py, cx, c.y, tint(C, S.t - c.b), 0.85, true, S.t * 2.3 + c.ph);\n      if (c.c.length) {\n        // A joint where the neck meets the next ones.\n        splat(A, cx, c.y, C.neck[0] * 0.7, C.neck[1] * 0.7, C.neck[2] * 0.7);\n        drawNode(S, A, C, c);\n      } else headDot(A, cx, c.y, C.head, 1);\n    }\n    return;\n  }\n  // Hundreds of necks from one node: one neck a column, as bright as the\n  // square root of the necks it stands for.\n  BN.fill(0);\n  BX.fill(0);\n  BY.fill(0);\n  BA.fill(0);\n  BL.fill(0);\n  for (const c of v.c) {\n    const cx = c.x + c.dx, j = cl(round(cx), 0, 63);\n    BN[j]++;\n    BX[j] += cx;\n    BY[j] += c.y;\n    BA[j] += S.t - c.b;\n    if (c.c.length) drawNode(S, A, C, c);\n    else BL[j]++;\n  }\n  for (let j = 0; j \u003c 64; j++) {\n    if (!BN[j]) continue;\n    const cx = BX[j] / BN[j], cy = BY[j] / BN[j], w = sqrt(BN[j]);\n    neck(A, px, py, cx, cy, tint(C, BA[j] / BN[j]), 0.55 * w, false, 0);\n    if (BL[j]) headDot(A, cx, cy, C.head, sqrt(BL[j]));\n  }\n}\n\n// ---- The 3 by 5 face for the counters, and a 5-wide omega.\nconst G = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n  n: \"000110101101101\", \"=\": \"000111000111000\", \"+\": \"000010111010000\", D: \"110101101101110\", E: \"111100110100111\",\n  A: \"010101111101101\", M: \"101111111101101\", X: \"101101010101101\",\n};\n// rows 00000 10001 10101 10101 01010\nconst OMEGA = \"0000010001101011010101010\";\nfunction put(O, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  O[o] = r;\n  O[o + 1] = g;\n  O[o + 2] = b;\n}\nfunction glyph(O, ch, x, y, col) {\n  const g = G[ch];\n  for (let i = 0; i \u003c 15; i++) if (g[i] === \"1\") put(O, x + (i % 3), y + floor(i / 3), col[0], col[1], col[2]);\n  return x + 4;\n}\nfunction text(O, s, x, y, col) {\n  for (const ch of s) x = glyph(O, ch, x, y, col);\n  return x;\n}\nfunction omega(O, x, y, col) {\n  for (let i = 0; i \u003c 25; i++) if (OMEGA[i] === \"1\") put(O, x + (i % 5), y + floor(i / 5), col[0], col[1], col[2]);\n  return x + 6;\n}\n// An ordinal in Cantor normal form, exponents raised 4 rows; returns the\n// end column, or 99 when the next term would pass the edge.\nfunction ordText(O, o, x, y, C) {\n  if (!o.length) return text(O, \"0\", x, y, C.txt);\n  for (let i = 0; i \u003c o.length; i++) {\n    const [e, c] = o[i];\n    if (i) {\n      if (x > 54) return 99;\n      x = glyph(O, \"+\", x, y, C.dim);\n    }\n    if (!e.length) {\n      x = text(O, String(c), x, y, C.txt);\n      continue;\n    }\n    x = omega(O, x, y, C.om);\n    if (!(e.length === 1 && !e[0][0].length && e[0][1] === 1)) x = ordText(O, e, x, y - 4, C);\n    if (c > 1) {\n      put(O, x, y + 2, C.dim[0], C.dim[1], C.dim[2]);\n      x = text(O, String(c), x + 2, y, C.txt);\n    }\n  }\n  return x;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.root) return;\n  const A = S.A, O = S.O, h = S.hue + HUE0;\n  const C = {\n    neck: hsv(h, 0.85, 0.9),\n    head: hsv(h + 0.04, 0.42, 1),\n    gold: hsv(h - 0.22, 0.55, 1.1),\n    txt: hsv(h + 0.04, 0.18, 0.85).map((c) => round(c * 255)),\n    dim: hsv(h, 0.3, 0.55).map((c) => round(c * 255)),\n    om: hsv(h, 0.6, 1).map((c) => round(c * 255)),\n  };\n  A.fill(0);\n  // The ground the root stands on.\n  for (let x = 0; x \u003c W; x++) {\n    const o = (127 * W + x) * 3, f = 0.1 * exp(-(((x - ROOT_X) / 22) ** 2));\n    A[o] += C.neck[0] * f;\n    A[o + 1] += C.neck[1] * f;\n    A[o + 2] += C.neck[2] * f;\n  }\n  // Called off for size: the hydra fades out.\n  const fade = S.state === 2 ? max(0, 1 - S.st / 1.5) : 1;\n  drawNode(S, A, C, S.root);\n  // The root, pulsing while it stands alone.\n  const rw = S.state === 1 ? 1.4 + 0.8 * sin(S.st * 5) : 1;\n  // Dead: a ring goes out from the root, 30 LEDs in 1.5 s.\n  if (S.state === 1 && S.st \u003c 1.5) {\n    const r = 3 + S.st * 20, q = 1.6 * (1 - S.st / 1.5);\n    for (let i = 0; i \u003c 80; i++) {\n      const a = (i / 80) * PI;\n      splat(A, S.root.x + r * cos(a), ROOT_Y - r * sin(a), C.head[0] * q, C.head[1] * q, C.head[2] * q);\n    }\n  }\n  for (let j = -1; j \u003c= 1; j++) for (let i = -1; i \u003c= 1; i++) splat(A, S.root.x + i, ROOT_Y + j, C.neck[0] * rw * (i || j ? 0.5 : 1.2), C.neck[1] * rw * (i || j ? 0.5 : 1.2), C.neck[2] * rw * (i || j ? 0.5 : 1.2));\n  // The next head, ringed while the cuts are slow enough to follow.\n  if (S.aim && S.state === 0 && S.grow \u003c= 0 && S.speed * 0.9 * (1 + S.n / 8) \u003c 6) {\n    const a = S.aim, ax = a.x + a.dx, w = 0.35 + 0.25 * sin(S.t * 14);\n    for (let i = 0; i \u003c 12; i++) splat(A, ax + 2.7 * cos((i * PI) / 6), a.y + 2.7 * sin((i * PI) / 6), w, w, w * 0.9);\n  }\n  // Each cut: a white flash where the neck was, and the head falling.\n  for (const f of S.fx) {\n    if (f.a \u003c 0.3) {\n      const q = (1 - f.a / 0.3) * 1.4, r = 1 + f.a * 9;\n      for (let i = 0; i \u003c 10; i++) splat(A, f.cx + r * cos(i * 0.63), f.cy + r * sin(i * 0.63), q * 0.5, q * 0.5, q * 0.42);\n    }\n    const q = max(0, 1 - f.a / 1.6) * 1.3;\n    splat(A, f.x, f.y, C.head[0] * q, C.head[1] * q, C.head[2] * q);\n  }\n  for (let p = 0; p \u003c N * 3; p++) O[p] = 255 * fade * (1 - exp(-1.25 * A[p]));\n  // Step and heads, the ordinal under them.\n  let x = text(O, \"n=\", 1, 1, C.dim);\n  text(O, String(S.n), x, 1, C.txt);\n  const right = S.state === 1 ? \"DEAD\" : S.state === 2 ? \"MAX\" : String(S.heads);\n  x = 64 - right.length * 4;\n  if (S.state === 0) {\n    const hc = C.head.map((c) => round(c * 230));\n    for (const [i, j] of [[0, 0], [1, 0], [0, 1], [1, 1]]) put(O, x - 4 + i, 2 + j, hc[0], hc[1], hc[2]);\n  }\n  text(O, right, x, 1, C.txt);\n  if (ordText(O, S.ordv, 1, 11, C) === 99) for (let i = 0; i \u003c 3; i++) put(O, 58 + i * 2, 15, C.dim[0], C.dim[1], C.dim[2]);\n  for (let p = 0, y = 0; y \u003c H; y++) for (let xx = 0; xx \u003c W; xx++, p += 3) display.setPixel(xx, y, O[p], O[p + 1], O[p + 2]);\n}\n","lattice-reduction":"// ===== Patternflow pattern =====\n// Title:   Lattice Reduction\n// Family:  geometry\n// Idea:    The points of a plane lattice stand still as white dots over the whole panel while the plane is tiled by the parallelogram of its current basis, which starts as long thin slivers, and Lagrange-Gauss reduction takes the basis apart one step at a time: b2 shears along b1 by the whole number of b1 nearest its projection, the tiles sliding until their corners land back on dots, the arrows trade colours when b2 has become the shorter and the two swap names, and when the projection is half of b1 or less the tiles are compact, flash, hold, and a new lattice starts skewed.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: reduction of binary quadratic forms, the two-dimensional lattice basis reduction (Joseph-Louis Lagrange, 1773; Carl Friedrich Gauss, Disquisitiones Arithmeticae, 1801), whose heir in any dimension is the LLL algorithm (Arjen Lenstra, Hendrik Lenstra and László Lovász, 1982), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Skew=3..7, Spacing=11..22\n//\n// Knob 1: Hue. Turns the tiles and the arrows round the wheel together. At 0 the tiles are teal, blue and violet, the cell at the centre green, b1 amber and b2 pink; at 0.5 the tiles go red, ochre and lime, the centre cell magenta, b1 blue and b2 spring green.\n// Knob 2: Speed. At 2 a shear takes 0.55 s, a swap 0.4 s and a pause of 0.2 s follows each, so a basis from 3 shears is reduced in 2.2 to 4.2 s and a new lattice comes every 6 to 8 s. Every time but the 2.6 s hold and the 0.5 s cross-fade scales as 2 / Speed: at 0.2 a shear takes 5.5 s, at 3 0.37 s.\n// Knob 3: Skew. How many shears, b2 += b1 and b1 += b2 by turns, each with the sign that lengthens, turn the reduced basis into the starting one. At the opening spacing: at 3 the longer vector is 3.5 to 4.9 spacings and the tiles 2.3 to 3.2 LEDs wide; at 5 about 10 spacings and one LED wide; at 7 up to 25 spacings, where a cap stops the word, and the tiles under a LED, a moire until the first shear. Gauss takes 2 or 3 shears at 3 and 4 at 7, each by 1 to 3 times b1, with a swap between most of them.\n// Knob 4: Spacing. The square root of one cell's area, 11 to 22 LEDs: 68 dots at 11, 17 at 22. The lattices come square, hexagonal, rectangular (sides 1.6 to 1) and random (60 to 90 degrees, sides up to 1.7 to 1) in turn, all of that area and turned at random.\n// Buttons: K1 tap starts a new lattice.\n\n// A lattice is every whole combination of two vectors. Many bases give the\n// same lattice: b1, b2 and b1, b2 - q b1 for any whole q, or the two swapped.\n// Lagrange (1773) and Gauss (1801) reduced a basis by alternating the two:\n// keep b1 the shorter, subtract from b2 the multiple of b1 nearest its\n// projection, and stop when that multiple is 0. Then |b1| \u003c= |b2| and\n// |b1 . b2| \u003c= |b1|^2 / 2, so the angle between them is 60 to 120 degrees\n// and b1 is a shortest vector of the lattice.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst smooth = (u) => u * u * (3 - 2 * u);\n// The lattice point everything turns about, at the panel's middle.\nconst OX = 31.5, OY = 63.5;\nconst HOLD = 2.6, FADE = 0.5, LOOK = 0.8, CAP = 26;\n\nfunction hsv(h, s, v, out) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The basis is R U: R the reduced basis the lattice was made from, U whole\n// numbers with determinant +-1, kept exactly so the basis never drifts off\n// the lattice.\nfunction basis(S) {\n  const R = S.R, U = S.U, b = S.b;\n  b[0] = R[0] * U[0] + R[2] * U[2];\n  b[1] = R[1] * U[0] + R[3] * U[2];\n  b[2] = R[0] * U[1] + R[2] * U[3];\n  b[3] = R[1] * U[1] + R[3] * U[3];\n}\nconst len2 = (x, y) => x * x + y * y;\n\nfunction newLattice(S) {\n  // The last frame stays to cross-fade from, black at the very start.\n  S.old.set(S.acc);\n  S.xf = 1;\n  const kind = S.kind++ % 4, a = S.spacing, th = Math.random() * PI;\n  let u, v, ang;\n  if (kind === 0) (u = a), (v = a), (ang = PI / 2);\n  else if (kind === 1) (u = v = a * sqrt(2 / sqrt(3))), (ang = PI / 3);\n  else if (kind === 2) (u = a / sqrt(1.6)), (v = a * sqrt(1.6)), (ang = PI / 2);\n  else {\n    ang = PI / 3 + Math.random() * (PI / 6);\n    const r = 1 + Math.random() * 0.7;\n    u = a / sqrt(r * sin(ang));\n    v = u * r;\n  }\n  const R = S.R;\n  R[0] = u * cos(th);\n  R[1] = u * sin(th);\n  R[2] = v * cos(th + ang);\n  R[3] = v * sin(th + ang);\n  // The word: shears of b2 along b1 and of b1 along b2 by turns, from a\n  // random first one, each with the sign that lengthens the vector it\n  // moves, stopping early if the longer vector would pass CAP spacings.\n  const U = S.U;\n  U.splice(0, 4, 1, 0, 0, 1);\n  basis(S);\n  for (let k = 0, w = Math.random() \u003c 0.5 ? 1 : 0; k \u003c S.skew; k++, w ^= 1) {\n    const b = S.b, d = b[0] * b[2] + b[1] * b[3], sg = d > 1e-9 ? 1 : d \u003c -1e-9 ? -1 : Math.random() \u003c 0.5 ? 1 : -1;\n    const V = U.slice();\n    if (w) (V[1] += sg * V[0]), (V[3] += sg * V[2]);\n    else (V[0] += sg * V[1]), (V[2] += sg * V[3]);\n    const nx = w ? R[0] * V[1] + R[2] * V[3] : R[0] * V[0] + R[2] * V[2], ny = w ? R[1] * V[1] + R[3] * V[3] : R[1] * V[0] + R[3] * V[2];\n    if (len2(nx, ny) > (CAP * a) ** 2) break;\n    U.splice(0, 4, ...V);\n    basis(S);\n  }\n  Object.assign(S, { phase: 0, pt: 0, op: null, steps: 0, ca: 1, cb: 2 });\n}\n\n// The next operation: a swap when b2 is the shorter, else the shear by q,\n// else none (reduced).\nfunction nextOp(S) {\n  const b = S.b, l1 = len2(b[0], b[1]), l2 = len2(b[2], b[3]);\n  if (l2 \u003c l1 * (1 - 1e-9)) return { swap: true };\n  // A projection of half of b1 or less is already reduced; testing that\n  // and not q = 0 keeps a tie, as in the hexagonal lattice, from flipping\n  // between q = 1 and q = -1 for ever.\n  const mu = (b[0] * b[2] + b[1] * b[3]) / l1;\n  return abs(mu) > 0.5 + 1e-7 ? { q: round(mu) } : null;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, skew: 3, spacing: 11, kind: 0, phase: 0, pt: 0, op: null, steps: 0, flash: 0, btn: false,\n    R: [9, 0, 0, 9], U: [1, 0, 0, 1], b: [9, 0, 0, 9], ca: 1, cb: 2, c: [0, 0, 0],\n    tile: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], acc: new Float32Array(W * H * 3), old: new Float32Array(W * H * 3), xf: 1,\n  };\n  return params.s;\n}\n\n// Phases: 0 cross-fading in and showing the skewed basis, 1 reducing, 2\n// the reduced basis held, then the next lattice.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 11], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const skew = round(cl(k[2], 3, 7)), spacing = cl(k[3], 11, 22), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (skew !== S.skew || abs(spacing - S.spacing) > 0.05 || !S.started || (btn && !S.btn))\n    (S.skew = skew), (S.spacing = spacing), (S.started = true), newLattice(S);\n  S.btn = btn;\n  const sc = 2 / S.speed;\n  S.t += d;\n  S.pt += d;\n  S.flash = max(0, S.flash - d / 0.7);\n  S.xf = max(0, S.xf - d / FADE);\n  if (S.phase === 0) {\n    if (S.pt >= FADE + LOOK * sc) (S.phase = 1), (S.pt = 0), (S.op = nextOp(S));\n  } else if (S.phase === 1) {\n    if (!S.op) return void ((S.phase = 2), (S.pt = 0), (S.flash = 1));\n    const dur = (S.op.swap ? 0.4 : 0.55) * sc;\n    if (S.pt >= dur + 0.2 * sc) {\n      const U = S.U;\n      if (S.op.swap) {\n        [U[0], U[1]] = [U[1], U[0]];\n        [U[2], U[3]] = [U[3], U[2]];\n        [S.ca, S.cb] = [S.cb, S.ca];\n      } else (U[1] -= S.op.q * U[0]), (U[3] -= S.op.q * U[2]);\n      basis(S);\n      S.steps++;\n      S.pt = 0;\n      S.op = nextOp(S);\n    }\n  } else if (S.pt >= HOLD) newLattice(S);\n}\n\nfunction put(acc, x, y, c, w) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  w = min(1, w);\n  for (let i = 0; i \u003c 3; i++) acc[k + i] += (c[i] - acc[k + i]) * w;\n}\nfunction line(acc, x0, y0, x1, y1, c, w) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0;\n  for (let x = max(0, round(x0)); x \u003c= min(st ? H - 1 : W - 1, round(x1)); x++) {\n    const y = y0 + (x - x0) * s, iy = floor(y), f = y - iy;\n    if (st) put(acc, iy, x, c, w * (1 - f)), put(acc, iy + 1, x, c, w * f);\n    else put(acc, x, iy, c, w * (1 - f)), put(acc, x, iy + 1, c, w * f);\n  }\n}\n// An arrow from the origin along x, y: a shaft 1.5 LEDs wide and a head 6\n// long, in colour c over a dark rim 1 LED wide that keeps it off the tiles.\nfunction arrow(acc, x, y, c) {\n  const l = sqrt(x * x + y * y);\n  if (l \u003c 1) return;\n  const ux = x / l, uy = y / l, hl = min(6, l * 0.5), hw = hl * 0.45, sl = l - hl, k = hl / sqrt(hl * hl + hw * hw);\n  const x0 = max(0, floor(min(OX, OX + x) - 4)), x1 = min(W - 1, floor(max(OX, OX + x) + 5));\n  const y0 = max(0, floor(min(OY, OY + y) - 4)), y1 = min(H - 1, floor(max(OY, OY + y) + 5));\n  for (let py = y0; py \u003c= y1; py++)\n    for (let px = x0; px \u003c= x1; px++) {\n      const dx = px - OX, dy = py - OY, al = dx * ux + dy * uy, ac = abs(-dx * uy + dy * ux);\n      const ds = (al \u003c 0 ? sqrt(al * al + ac * ac) : al > sl ? sqrt((al - sl) ** 2 + ac * ac) : ac) - 0.75;\n      const dh = max(sl - al, al - l, (ac - (hw * (l - al)) / hl) * k);\n      const dd = min(ds, dh);\n      if (dd > 1.6) continue;\n      const kk = (py * W + px) * 3, w = cl(0.5 - dd, 0, 1), m = 1 - 0.6 * cl(1.6 - dd, 0, 1);\n      for (let i = 0; i \u003c 3; i++) acc[kk + i] = acc[kk + i] * m * (1 - w) + c[i] * w;\n    }\n}\nfunction dot(acc, x, y, c, w) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  put(acc, ix, iy, c, w * min(1, 1.7 * (1 - fx) * (1 - fy)));\n  put(acc, ix + 1, iy, c, w * min(1, 1.7 * fx * (1 - fy)));\n  put(acc, ix, iy + 1, c, w * min(1, 1.7 * (1 - fx) * fy));\n  put(acc, ix + 1, iy + 1, c, w * min(1, 1.7 * fx * fy));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const acc = S.acc, b = S.b, c = S.c, tile = S.tile;\n  // The basis on screen: during a shear b2 slides along b1 by q b1.\n  let b1x = b[0], b1y = b[1], b2x = b[2], b2y = b[3], mix = 0;\n  if (S.phase === 1 && S.op) {\n    const sc = 2 / S.speed, u = smooth(cl(S.pt / ((S.op.swap ? 0.4 : 0.55) * sc), 0, 1));\n    if (S.op.swap) mix = u;\n    else (b2x -= u * S.op.q * b1x), (b2y -= u * S.op.q * b1y);\n  }\n  const det = b1x * b2y - b1y * b2x, l1 = sqrt(len2(b1x, b1y)), l2 = sqrt(len2(b2x, b2y));\n  // Tile heights across each family of edges, and how much edge they carry.\n  const h1 = abs(det) / l2, h2 = abs(det) / l1, e1 = cl((h1 - 1.2) / 2, 0, 1), e2 = cl((h2 - 1.2) / 2, 0, 1);\n  const fl = S.flash * S.flash;\n  for (let k = 0; k \u003c 3; k++) hsv(S.hue + [0.5, 0.6, 0.73][k], 0.72 - 0.2 * fl, [0.56, 0.66, 0.76][k] + 0.12 * fl, tile[k]);\n  hsv(S.hue + 0.38, 0.8 - 0.3 * fl, 0.85 + 0.15 * fl, tile[3]);\n  // Each LED's place in the tiling: s along b1, t along b2. Tiles are\n  // coloured by (ca i + cb j) mod 3, which keeps every tile's colour when\n  // the arrows swap and never gives two tiles that share an edge one colour.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - OX, dy = y - OY, s = (dx * b2y - dy * b2x) / det, t = (b1x * dy - b1y * dx) / det;\n      const i = floor(s), j = floor(t), fs = s - i, ft = t - j;\n      const col = i === 0 && j === 0 ? tile[3] : tile[(((S.ca * i + S.cb * j) % 3) + 3) % 3];\n      const ed = max(e1 * cl(1 - (min(fs, 1 - fs) * h1) / 0.7, 0, 1), e2 * cl(1 - (min(ft, 1 - ft) * h2) / 0.7, 0, 1));\n      const m = 1 - 0.7 * ed, k = (y * W + x) * 3;\n      acc[k] = col[0] * m;\n      acc[k + 1] = col[1] * m;\n      acc[k + 2] = col[2] * m;\n    }\n  // The lattice points, from the reduced basis R: they never move.\n  const R = S.R, rd = R[0] * R[3] - R[1] * R[2], white = [1, 1, 1];\n  let span = 0;\n  for (const [x, y] of [[-OX, -OY], [W - OX, -OY], [-OX, H - OY], [W - OX, H - OY]]) {\n    span = max(span, abs((x * R[3] - y * R[2]) / rd) + 1, abs((R[0] * y - R[1] * x) / rd) + 1);\n  }\n  span = min(60, ceilInt(span));\n  for (let m = -span; m \u003c= span; m++)\n    for (let n = -span; n \u003c= span; n++) {\n      const x = OX + m * R[0] + n * R[2], y = OY + m * R[1] + n * R[3];\n      if (x > -1 && x \u003c W && y > -1 && y \u003c H) dot(acc, x, y, white, 0.95);\n    }\n  // The arrows; during a swap their colours cross over.\n  const a1 = [0, 0, 0], a2 = [0, 0, 0];\n  hsv(S.hue + 0.1, 0.85, 1, a1);\n  hsv(S.hue + 0.92, 0.6, 1, a2);\n  const ma = [0, 1, 2].map((k) => a1[k] + (a2[k] - a1[k]) * mix), mb = [0, 1, 2].map((k) => a2[k] + (a1[k] - a2[k]) * mix);\n  // During a shear, the path of b2's tip along b1, through the dots.\n  if (S.phase === 1 && S.op && !S.op.swap) {\n    const c2 = mb.map((v) => v * 0.8);\n    line(acc, OX + b[2], OY + b[3], OX + b2x, OY + b2y, c2, 0.8);\n  }\n  arrow(acc, b2x, b2y, mb);\n  arrow(acc, b1x, b1y, ma);\n  dot(acc, OX, OY, white, 1);\n  const xf = smooth(S.xf), old = S.old;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      for (let i = 0; i \u003c 3; i++) acc[k + i] = min(1, acc[k + i]);\n      const r = acc[k] + (old[k] - acc[k]) * xf, gr = acc[k + 1] + (old[k + 1] - acc[k + 1]) * xf, bl = acc[k + 2] + (old[k + 2] - acc[k + 2]) * xf;\n      display.setPixel(x, y, (255 * r) | 0, (255 * gr) | 0, (255 * bl) | 0);\n    }\n}\nconst ceilInt = (v) => -floor(-v);\n","optical-kerning":"// ===== Patternflow pattern =====\n// Title:   Optical Kerning\n// Family:  type\n// Idea:    Five words whose letters have open and slanted sides, AVOW, LYNX, TOY, WAVE and FLY among them, stand in capitals 19 LEDs tall down the panel, the white between each pair of neighbours glows in a colour that says how much of it there is, and after each word is set with the same 2 LED space between every pair of letter boxes, so that A and V gape while H and I sit tight, its letters slide sideways until every gap holds the same area and the glows of the word turn one colour, a wave of new words running down the panel every 6.35 s.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 72, after letter spacing worked out by formula in David Kindersley's Optical Letter Spacing for New Printing Systems (1976 edition) and by method in Walter Tracy's Letters of Credit (1986)\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tracking=-1..1, Depth=-1..1\n//\n// Knob 1: Hue. Turns the glow palette round the wheel. At 0 a gap 1.5 LEDs or less across on average glows violet-blue, 3.6 cyan, 6 yellow-green and 7.5 or more amber; the letters stay warm white.\n// Knob 2: Speed. At 2 a word is set, shown for 1.15 s at box spacing, slides into its spacing in 1.5 s, holds 3 s and goes, 6.35 s in all, and each line starts 0.45 s after the one above; at 0.2 a word takes 64 s, at 3 it takes 4.2 s.\n// Knob 3: Tracking. The area every gap is spaced to, given as its width averaged over the 19 rows: 3.6 LEDs at 0, where every gap of all ten words meets it, H and I stand 3.6 apart and A tucks 0.3 under V; 2.4 at -1, where seven pairs, Y N, F L and T O among them, reach the 1 LED that letters may come to and stay a little wider than the rest; 5.4 at 1, AVOW then 57 LEDs wide. The settled glows are blue at -1, cyan at 0 and green at 1.\n// Knob 4: Depth. How far into an open side the white is counted, measured in from the letter's outermost point: 3.2 LEDs at the opening 0.06. At -1 only 1 LED counts, every pair is spaced almost by its boxes and A V stands 1.9 apart instead of tucking under. At 1 the 8 LEDs counted reach right into the throats of A, V, L and T: A goes 0.6 under V and the L's foot 3.4 under the Y's arm, and still L Y, L T and F L cannot shed enough white without touching, so their glows stay yellow-green while the rest settle cyan.\n\n// The white between two letters is counted row by row through the cap\n// height: the horizontal distance between their facing contours, except\n// that on each side the distance is counted only Depth LEDs in from that\n// letter's outermost point. Without that limit the open sides of A, L, T, V\n// and Y would count all their white and pull their neighbours in until they\n// touched. Every pair is then moved until its area meets the Tracking\n// target, never closer than 1 LED in any row.\n//\n// Pairs whose slants run parallel, V Y or A X, cannot meet any target this\n// way: the tips touch before the throats close. The words leave them out.\n\nconst W = 64, H = 128, CAP = 19, HW = 1.25, LINES = 5, PITCH = 25, TOP0 = 4, BOX = 2, CLEAR = 1;\nconst { floor, round, min, max, abs, exp, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The capitals, drawn for this pattern in a box 19 LEDs tall: \"r\" is a\n// filled rectangle x0, y0, x1, y1; \"s\" a stroke 2.5 LEDs wide along a\n// segment, cut flat at the top and bottom of the box; \"o\" an elliptical\n// ring 2.5 LEDs wide with its centre and the radii of its middle line.\nconst GLYPHS = {\n  A: [[\"s\", 6, -1, 1.2, 19.6], [\"s\", 6, -1, 10.8, 19.6], [\"r\", 2.4, 12, 9.6, 14.5]],\n  V: [[\"s\", 1.2, -0.6, 6, 20], [\"s\", 10.8, -0.6, 6, 20]],\n  O: [[\"o\", 6, 9.5, 4.75, 8.25]],\n  W: [[\"s\", 1.1, -0.5, 4.3, 19.6], [\"s\", 4.3, 19.6, 7.5, 3], [\"s\", 7.5, 3, 10.7, 19.6], [\"s\", 10.7, 19.6, 13.9, -0.5]],\n  L: [[\"r\", 0, 0, 2.5, 19], [\"r\", 0, 16.5, 10, 19]],\n  Y: [[\"s\", 1.2, -0.6, 6, 10], [\"s\", 10.8, -0.6, 6, 10], [\"r\", 4.75, 9, 7.25, 19]],\n  N: [[\"r\", 0, 0, 2.5, 19], [\"r\", 9.5, 0, 12, 19], [\"s\", 1.4, 0.4, 10.6, 18.6]],\n  X: [[\"s\", 1.2, -0.6, 10.8, 19.6], [\"s\", 10.8, -0.6, 1.2, 19.6]],\n  T: [[\"r\", 0, 0, 12, 2.5], [\"r\", 4.75, 0, 7.25, 19]],\n  E: [[\"r\", 0, 0, 2.5, 19], [\"r\", 0, 0, 10, 2.5], [\"r\", 0, 8.25, 9, 10.75], [\"r\", 0, 16.5, 10, 19]],\n  F: [[\"r\", 0, 0, 2.5, 19], [\"r\", 0, 0, 10, 2.5], [\"r\", 0, 8.25, 9, 10.75]],\n  I: [[\"r\", 0, 0, 2.5, 19]],\n  H: [[\"r\", 0, 0, 2.5, 19], [\"r\", 8.5, 0, 11, 19], [\"r\", 0, 8.25, 11, 10.75]],\n};\n// Line k takes words k and k + 5 in turn.\nconst WORDS = [\"AVOW\", \"LYNX\", \"TOY\", \"WAVE\", \"FLY\", \"YAWL\", \"HILT\", \"VOLT\", \"AWAY\", \"OVAL\"];\n\n// Signed distance from a point in the box to the letter's ink (negative inside).\nfunction dist(parts, x, y) {\n  let d = 1e9;\n  for (const p of parts) {\n    let e;\n    if (p[0] === \"r\") {\n      const dx = max(p[1] - x, x - p[3]), dy = max(p[2] - y, y - p[4]);\n      e = dx > 0 && dy > 0 ? hypot(dx, dy) : max(dx, dy);\n    } else if (p[0] === \"s\") {\n      const ax = p[1], ay = p[2], bx = p[3] - ax, by = p[4] - ay;\n      const t = cl(((x - ax) * bx + (y - ay) * by) / (bx * bx + by * by), 0, 1);\n      e = max(hypot(x - ax - t * bx, y - ay - t * by) - HW, -y, y - CAP);\n    } else {\n      const qx = (x - p[1]) / p[3], qy = (y - p[2]) / p[4], k0 = hypot(qx, qy), k1 = hypot(qx / p[3], qy / p[4]);\n      e = abs((k0 * (k0 - 1)) / max(k1, 1e-6)) - HW;\n    }\n    if (e \u003c d) d = e;\n  }\n  return d;\n}\n\n// Each letter's contour, row by row, measured once: where the ink starts\n// and ends in the row's middle, and from those its outermost points.\nfunction measure(ch) {\n  const parts = GLYPHS[ch], lf = new Float32Array(CAP), rt = new Float32Array(CAP);\n  for (let r = 0; r \u003c CAP; r++) {\n    let a = 99, b = -99;\n    for (let x = -3; x \u003c= 17; x += 0.02) if (dist(parts, x, r + 0.5) \u003c= 0) { if (a === 99) a = x; b = x; }\n    lf[r] = a;\n    rt[r] = b;\n  }\n  let L = 99, R = -99;\n  for (let r = 0; r \u003c CAP; r++) (L = min(L, lf[r])), (R = max(R, rt[r]));\n  const ld = new Float32Array(CAP), rd = new Float32Array(CAP);\n  for (let r = 0; r \u003c CAP; r++) (ld[r] = lf[r] - L), (rd[r] = R - rt[r]);\n  return { parts, L, w: R - L, ld, rd };\n}\n\n// The white counted between a left letter and a right letter whose\n// outermost points stand g apart, and the g that gives a wanted area.\nfunction area(A, B, g, D) {\n  let s = 0;\n  for (let r = 0; r \u003c CAP; r++) s += max(0, g + min(A.rd[r], D) + min(B.ld[r], D));\n  return s;\n}\nfunction solve(A, B, want, D) {\n  let lo = -12;\n  for (let r = 0; r \u003c CAP; r++) lo = max(lo, CLEAR - A.rd[r] - B.ld[r]);\n  if (area(A, B, lo, D) >= want) return lo;\n  let hi = 30;\n  for (let i = 0; i \u003c 28; i++) {\n    const m = (lo + hi) / 2;\n    if (area(A, B, m, D) \u003c want) lo = m;\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\nfunction setWord(s, k, word) {\n  const ln = s.lines[k];\n  ln.word = word;\n  ln.g = [];\n  ln.letters = [...word].map((ch) => s.m[ch]);\n  for (let i = 0; i + 1 \u003c ln.letters.length; i++) ln.g.push(BOX);\n}\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.m = {};\n  for (const ch in GLYPHS) s.m[ch] = measure(ch);\n  s.lines = [];\n  for (let k = 0; k \u003c LINES; k++) {\n    s.lines.push({ tau: 0.35 - 0.45 * k, n: 0 });\n    setWord(s, k, WORDS[k]);\n  }\n  s.glow = new Float32Array(W * H * 3);\n  s.tmp = new Float32Array(W * H * 3);\n  s.ink = new Float32Array(W * H);\n  s.D = 3.18;\n  s.want = 3.6 * CAP;\n  s.hue = 0;\n}\n\n// Phases of a line, in seconds at Speed 2.\nconst T_IN = 0.35, T_SLIDE = 1.5, T_HOLD = 3.0, T_OUT = 6.0, T_END = 6.35;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  const tr = cl(k[2] || 0, -1, 1), dp = cl(k[3] == null ? 0.06 : k[3], -1, 1);\n  s.want = (3.6 + (tr \u003c 0 ? 1.2 : 1.8) * tr) * CAP;\n  s.D = 3 * exp(dp * (dp \u003c 0 ? 1.0986 : 0.9808));\n  const follow = 1 - exp(-8 * dt);\n  for (let li = 0; li \u003c LINES; li++) {\n    const ln = s.lines[li];\n    ln.tau += dt * rate;\n    if (ln.tau >= T_END) {\n      ln.tau -= T_END;\n      ln.n++;\n      setWord(s, li, WORDS[(li + LINES * ln.n) % WORDS.length]);\n    }\n    const e = ease((ln.tau - T_SLIDE) / (T_HOLD - T_SLIDE));\n    for (let i = 0; i \u003c ln.g.length; i++) {\n      const target = BOX + (solve(ln.letters[i], ln.letters[i + 1], s.want, s.D) - BOX) * e;\n      ln.g[i] += (target - ln.g[i]) * (ln.tau \u003c T_HOLD ? 1 : follow);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const glow = s.glow, ink = s.ink, D = s.D;\n  glow.fill(0);\n  ink.fill(0);\n  const marks = [];\n  for (let li = 0; li \u003c LINES; li++) {\n    const ln = s.lines[li], top = TOP0 + li * PITCH, L = ln.letters;\n    // The first words are on the panel from the start; later ones fade in.\n    const fade = ln.n === 0 && ln.tau \u003c T_IN ? 1 : ln.tau \u003c T_IN ? ln.tau / T_IN : ln.tau > T_OUT ? 1 - (ln.tau - T_OUT) / (T_END - T_OUT) : 1;\n    let total = 0;\n    for (let i = 0; i \u003c L.length; i++) total += L[i].w + (i \u003c ln.g.length ? ln.g[i] : 0);\n    let x = 32 - total / 2;\n    const xs = [];\n    for (let i = 0; i \u003c L.length; i++) {\n      xs.push(x);\n      x += L[i].w + (i \u003c ln.g.length ? ln.g[i] : 0);\n    }\n    // Letters.\n    for (let i = 0; i \u003c L.length; i++) {\n      const g = L[i], ox = xs[i] - g.L;\n      const x0 = max(0, floor(xs[i] - 1)), x1 = min(W - 1, floor(xs[i] + g.w + 1));\n      for (let y = 0; y \u003c CAP; y++)\n        for (let px = x0; px \u003c= x1; px++) {\n          const c = cl(0.5 - dist(g.parts, px + 0.5 - ox, y + 0.5), 0, 1) * fade;\n          const j = (top + y) * W + px;\n          if (c > ink[j]) ink[j] = c;\n        }\n    }\n    // The counted white between each pair, and its colour.\n    for (let i = 0; i \u003c ln.g.length; i++) {\n      const A = L[i], B = L[i + 1], a = xs[i] + A.w, b = xs[i + 1];\n      const ar = area(A, B, b - a, D), mean = ar / CAP;\n      const sv = cl((mean - 1.5) / 6, 0, 1);\n      const col = hsv(0.7 + s.hue - 0.58 * sv, 0.9, 0.62 + 0.3 * sv);\n      const lv = fade;\n      for (let r = 0; r \u003c CAP; r++) {\n        const u0 = a - min(A.rd[r], D), u1 = b + min(B.ld[r], D);\n        if (u1 \u003c= u0) continue;\n        for (let px = max(0, floor(u0)); px \u003c= min(W - 1, floor(u1)); px++) {\n          const c = (min(px + 1, u1) - max(px, u0)) * lv;\n          if (c \u003c= 0) continue;\n          const j = ((top + r) * W + px) * 3;\n          glow[j] += col[0] * c;\n          glow[j + 1] += col[1] * c;\n          glow[j + 2] += col[2] * c;\n        }\n      }\n      // Under each gap a bar as long as the gap's mean width: its area\n      // laid out along one row.\n      let cx = 0, n = 0;\n      for (let r = 0; r \u003c CAP; r++) {\n        const u0 = a - min(A.rd[r], D), u1 = b + min(B.ld[r], D);\n        if (u1 > u0) (cx += (u0 + u1) / 2), n++;\n      }\n      marks.push([n ? cx / n : (a + b) / 2, top + CAP + 1, mean, col, fade]);\n    }\n  }\n  // Soften the glow: a 1-2-1 blur across and down.\n  const t = s.tmp;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const j = (y * W + x) * 3 + c;\n        t[j] = (2 * glow[j] + (x > 0 ? glow[j - 3] : 0) + (x \u003c W - 1 ? glow[j + 3] : 0)) / 4;\n      }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++)\n      for (let c = 0; c \u003c 3; c++) {\n        const j = (y * W + x) * 3 + c;\n        glow[j] = (2 * t[j] + (y > 0 ? t[j - W * 3] : 0) + (y \u003c H - 1 ? t[j + W * 3] : 0)) / 4;\n      }\n  for (const [cx, y, len, col, f] of marks) {\n    const u0 = cx - len / 2, u1 = cx + len / 2;\n    for (let px = max(0, floor(u0)); px \u003c= min(W - 1, floor(u1)); px++) {\n      const c = cl(min(px + 1, u1) - max(px, u0), 0, 1) * 0.9 * f;\n      const j = (y * W + px) * 3;\n      for (let q = 0; q \u003c 3; q++) glow[j + q] = max(glow[j + q], col[q] * c);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, j = i * 3, a = ink[i];\n      const r = glow[j] * 255 * (1 - a) + 242 * a, g = glow[j + 1] * 255 * (1 - a) + 234 * a, b = glow[j + 2] * 255 * (1 - a) + 218 * a;\n      display.setPixel(x, y, round(cl(r + 3, 0, 255)), round(cl(g + 3, 0, 255)), round(cl(b + 6, 0, 255)));\n    }\n}\n","ruppert-refinement":"// ===== Patternflow pattern =====\n// Title:   Ruppert Refinement\n// Family:  cells\n// Idea:    A polygon with notches and holes starts as the constrained Delaunay triangulation of its corners, a panel of magenta needles, and Ruppert's refinement mends it one point at a time: an encroached boundary segment is split at its midpoint, else the worst triangle shows its circumcircle and a point goes in at the centre, or the segment that centre would encroach is split instead, Lawson flips restore the Delaunay mesh, and each triangle wears the colour of its smallest angle until the domain is green, teal and blue.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Delaunay refinement (Jim Ruppert, \"A Delaunay refinement algorithm for quality 2-dimensional mesh generation\", J. Algorithms, 1995), Lawson flips (Charles L. Lawson, 1977), size limit as in Triangle (Jonathan Shewchuk, 1996), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bound=20..33, Domain=0..5\n//\n// Knob 1: Hue. Turns the angle colours round the wheel. At 0 needles are magenta, triangles halfway to the bound red, those just under it amber, and triangles past it green, then teal, then blue at 60 degrees; at 0.5 needles go green and the finished mesh magenta, red and orange.\n// Knob 2: Speed. Steps a second: 0.8 times Speed at first, and 1 + n / 24 times that after n new points, since later steps are smaller. At 2 the first steps come 1.6 a second and the opening domain is finished after 15 s; at 0.2 one step every 6 s, each circle in plain view.\n// Knob 3: Bound. The smallest angle a triangle may keep, 20 to 33 degrees. Triangles below it are coloured magenta to amber and get refined. Ruppert proved that the refinement stops for bounds up to 20.7 degrees when no two segments meet at less than 90, as in all six domains here; past 20.7 nothing is proved and above about 30 some inputs never finish, but these six do: 35 to 54 new points at 20, 58 to 166 at 33. Turning it up on a finished mesh starts the refinement again; turning it down only recolours it.\n// Knob 4: Domain. Which of six domains comes first: a slab with crenels top and bottom, a slab with slots and a diamond hole, an octagon with three small diamond holes at each end, a slab with notches 40 LEDs deep, a slab with a slot 63 LEDs tall, and a staircase. Each finished mesh holds 4 s and hands on to the next domain.\n// Buttons: K1 tap starts the next domain.\n\n// Ruppert (1995): start from a constrained Delaunay triangulation of the\n// input segments. While some segment has a vertex inside its diametral\n// circle (the circle it is a diameter of), split it at its midpoint.\n// Otherwise take a triangle whose smallest angle is below the bound and add\n// its circumcentre, unless that centre would encroach a segment: then split\n// the segment and leave the centre out. Each new point is joined to the\n// triangle (or the two triangles) it falls in and Lawson flips restore the\n// Delaunay property. The boundary sides are the segments and never flip.\n// The worst triangle goes first. Once none is below the bound, a triangle\n// whose circumcircle is wider than 22 LEDs is split the same way, a size\n// limit like Triangle's, so the open middle ends as a mesh too.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst DEG = PI / 180;\n\nconst NMAX = 700, TMAX = 2 * NMAX + 16;\n// Triangles with a circumradius under 1.1 LEDs are left alone; no domain\n// gets there even at 33 degrees.\nconst RMIN = 1.1, RMAX = 11, INTRO = 0.7, HOLD = 4, FADE = 0.6;\nconst FV = 0.84, FS = 0.88;\n\n// The domains in LEDs, outer ring first, then the holes. Every corner is 90\n// degrees or more. Most corners sit near the ends, so the first\n// triangulation is needles from end to end.\nconst rect = (x0, y0, x1, y1) => [x0, y0, x1, y0, x1, y1, x0, y1];\nconst diamond = (x, y, r) => [x, y - r, x + r, y, x, y + r, x - r, y];\n// A rectangle 3..60 by 3..124 with notches d deep cut into its top edge at\n// the x spans in top and into its bottom edge at those in bot.\nfunction notched(top, bot, d) {\n  const out = [3, 3];\n  for (let k = 0; k \u003c top.length; k += 2) out.push(top[k], 3, top[k], 3 + d, top[k + 1], 3 + d, top[k + 1], 3);\n  out.push(60, 3, 60, 124);\n  for (let k = bot.length - 2; k >= 0; k -= 2) out.push(bot[k + 1], 124, bot[k + 1], 124 - d, bot[k], 124 - d, bot[k], 124);\n  out.push(3, 124);\n  return out;\n}\n// Stairs: five steps 11 or 12 LEDs wide and 4 high down along the top and\n// five up along the bottom.\nconst STEPS = [3, 14, 26, 37, 49, 60];\nfunction stairs() {\n  const out = [3, 3];\n  for (let k = 0; k \u003c 5; k++) out.push(STEPS[k + 1], 3 + 4 * k, STEPS[k + 1], 7 + 4 * k);\n  out.length -= 2;\n  out.push(60, 124);\n  for (let k = 0; k \u003c 5; k++) out.push(STEPS[4 - k], 124 - 4 * k, STEPS[4 - k], 120 - 4 * k);\n  out.length -= 2;\n  return out;\n}\nconst DOMAINS = [\n  [notched([9, 16, 23, 30, 37, 44, 51, 56], [7, 13, 20, 27, 34, 41, 48, 55], 6)],\n  [notched([14, 19, 29, 34, 44, 49], [21, 26, 37, 42], 16), diamond(31.5, 32, 5)],\n  [[17, 3, 46, 3, 60, 17, 60, 110, 46, 124, 17, 124, 3, 110, 3, 17], diamond(19, 17, 3.5), diamond(31.5, 17, 3.5), diamond(44, 17, 3.5), diamond(19, 110, 3.5), diamond(31.5, 110, 3.5), diamond(44, 110, 3.5)],\n  [notched([10, 18, 45, 53], [22, 41], 40), rect(29, 16, 34, 28)],\n  [notched([20, 43], [8, 16, 47, 55], 8), rect(28, 32, 35, 95)],\n  [stairs()],\n];\n\nfunction hsv(h, s, v, out) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The colour of a smallest angle m: below the bound from magenta through red\n// to amber, from the bound to 60 degrees green through teal to blue.\nfunction angleHue(S, m) {\n  if (m \u003c S.bound) return S.hue + 0.84 + 0.27 * (m / S.bound);\n  return S.hue + 0.31 + 0.31 * cl((m - S.bound) / (PI / 3 - S.bound), 0, 1);\n}\n\n// ---- Predicates. Every stored triangle has orient > 0. ----\nconst orient = (P, a, b, c) =>\n  (P[2 * b] - P[2 * a]) * (P[2 * c + 1] - P[2 * a + 1]) - (P[2 * b + 1] - P[2 * a + 1]) * (P[2 * c] - P[2 * a]);\nfunction incircle(P, a, b, c, d) {\n  const dx = P[2 * d], dy = P[2 * d + 1];\n  const ax = P[2 * a] - dx, ay = P[2 * a + 1] - dy, bx = P[2 * b] - dx, by = P[2 * b + 1] - dy;\n  const cx = P[2 * c] - dx, cy = P[2 * c + 1] - dy;\n  const a2 = ax * ax + ay * ay, b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  return ax * (by * c2 - b2 * cy) - ay * (bx * c2 - b2 * cx) + a2 * (bx * cy - by * cx);\n}\nfunction angle(P, a, b, c) {\n  const ux = P[2 * b] - P[2 * a], uy = P[2 * b + 1] - P[2 * a + 1], vx = P[2 * c] - P[2 * a], vy = P[2 * c + 1] - P[2 * a + 1];\n  return atan2(abs(ux * vy - uy * vx), ux * vx + uy * vy);\n}\nfunction minAngle(S, t) {\n  const P = S.P, V = S.V, a = V[3 * t], b = V[3 * t + 1], c = V[3 * t + 2];\n  return min(angle(P, a, b, c), angle(P, b, c, a), angle(P, c, a, b));\n}\nfunction circum(P, a, b, c, out) {\n  const ax = P[2 * a], ay = P[2 * a + 1];\n  const bx = P[2 * b] - ax, by = P[2 * b + 1] - ay, cx = P[2 * c] - ax, cy = P[2 * c + 1] - ay;\n  const d = 2 * (bx * cy - by * cx), b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  const ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d;\n  out[0] = ax + ux;\n  out[1] = ay + uy;\n  out[2] = sqrt(ux * ux + uy * uy);\n}\n\n// ---- The starting triangulation: the holes bridged into the outer ring,\n// ears clipped, then Lawson flips to the constrained Delaunay one. ----\nfunction addPoint(S, x, y) {\n  const i = S.np++;\n  S.P[2 * i] = x;\n  S.P[2 * i + 1] = y;\n  S.pb[i] = S.t;\n  return i;\n}\nfunction build(S, d) {\n  const P = S.P, rings = [], edges = [];\n  S.np = 0;\n  for (const R of DOMAINS[d]) {\n    let ids = [], area = 0;\n    for (let k = 0; k \u003c R.length; k += 2) ids.push(addPoint(S, R[k], R[k + 1]));\n    for (let k = 0, n = R.length; k \u003c n; k += 2) area += R[k] * R[(k + 3) % n] - R[(k + 2) % n] * R[k + 1];\n    if ((area > 0) !== !rings.length) ids = ids.reverse();\n    rings.push(ids);\n    for (let k = 0; k \u003c ids.length; k++) edges.push(ids[k], ids[(k + 1) % ids.length]);\n  }\n  S.n0 = S.np;\n  let L = rings[0];\n  const holes = rings.slice(1).map((h) => {\n    let m = 0;\n    for (let k = 1; k \u003c h.length; k++) if (P[2 * h[k]] > P[2 * h[m]]) m = k;\n    return { h, m };\n  });\n  holes.sort((p, q) => P[2 * q.h[q.m]] - P[2 * p.h[p.m]]);\n  for (const { h, m } of holes) {\n    const v = h[m];\n    let best = -1, bd = 1e9;\n    for (let k = 0; k \u003c L.length; k++) {\n      const o = L[k], dd = (P[2 * o] - P[2 * v]) ** 2 + (P[2 * o + 1] - P[2 * v + 1]) ** 2;\n      if (dd >= bd) continue;\n      let ok = true;\n      for (let j = 0; j \u003c edges.length && ok; j += 2) {\n        const p = edges[j], q = edges[j + 1];\n        if (p === o || q === o || p === v || q === v) continue;\n        ok = !(orient(P, o, v, p) * orient(P, o, v, q) \u003c 0 && orient(P, p, q, o) * orient(P, p, q, v) \u003c 0);\n      }\n      if (ok) (best = k), (bd = dd);\n    }\n    const ring = h.slice(m).concat(h.slice(0, m + 1));\n    L = L.slice(0, best + 1).concat(ring, L.slice(best));\n  }\n  const tris = [];\n  while (L.length > 3) {\n    const n = L.length;\n    let found = -1;\n    for (let pass = 0; pass \u003c 2 && found \u003c 0; pass++)\n      for (let i = 0; i \u003c n && found \u003c 0; i++) {\n        const a = L[(i + n - 1) % n], v = L[i], b = L[(i + 1) % n];\n        if (orient(P, a, v, b) \u003c= 1e-9) continue;\n        const e = pass ? 1e-9 : -1e-9;\n        let ok = true;\n        for (let j = 0; j \u003c n && ok; j++) {\n          const p = L[j];\n          if (p === a || p === v || p === b) continue;\n          ok = !(orient(P, a, v, p) > e && orient(P, v, b, p) > e && orient(P, b, a, p) > e);\n        }\n        if (ok) found = i;\n      }\n    if (found \u003c 0) break;\n    tris.push(L[(found + n - 1) % n], L[found], L[(found + 1) % n]);\n    L.splice(found, 1);\n  }\n  if (L.length === 3) tris.push(...L);\n  link(S, tris);\n  for (let pass = 0, any = true; any && pass \u003c 100; pass++) {\n    any = false;\n    for (let e = 0; e \u003c 3 * S.T; e++) if (S.Nb[e] > ((e / 3) | 0) && illegal(S, e)) flip(S, e), (any = true);\n  }\n}\n// Nb[3t + i] is the triangle across t's side opposite its vertex i, -1 on\n// the boundary: the boundary sides are exactly the segments.\nfunction link(S, tris) {\n  const V = S.V, Nb = S.Nb, T = (S.T = tris.length / 3), seen = new Map();\n  for (let i = 0; i \u003c tris.length; i++) V[i] = tris[i];\n  Nb.fill(-1);\n  S.tb.fill(-9);\n  for (let e = 0; e \u003c 3 * T; e++) {\n    const t = (e / 3) | 0, b = V[3 * t + ((e + 1) % 3)], c = V[3 * t + ((e + 2) % 3)];\n    const key = min(b, c) * 4096 + max(b, c), o = seen.get(key);\n    if (o === undefined) seen.set(key, e);\n    else (Nb[e] = (o / 3) | 0), (Nb[o] = t);\n  }\n}\n\n// ---- Edges and flips. Edge e = 3t + i is t's side opposite vertex i. ----\nfunction quad(S, e, q) {\n  const V = S.V, t = (e / 3) | 0, i = e % 3, u = S.Nb[e];\n  if (u \u003c 0) return false;\n  let j = 0;\n  while (S.Nb[3 * u + j] !== t) j++;\n  q.splice(0, 6, V[e], V[3 * t + ((i + 1) % 3)], V[3 * t + ((i + 2) % 3)], V[3 * u + j], u, j);\n  return true;\n}\nfunction illegal(S, e) {\n  const q = S.q, P = S.P;\n  if (!quad(S, e, q)) return false;\n  const [a, b, c, d] = q;\n  return incircle(P, a, b, c, d) > 1e-6 && orient(P, a, b, d) > 0 && orient(P, d, c, a) > 0;\n}\n// t = a b c and u = d c b become t = a b d and u = d c a.\nfunction flip(S, e) {\n  const V = S.V, Nb = S.Nb, q = S.q;\n  quad(S, e, q);\n  const [a, b, c, d, u, j] = q, t = (e / 3) | 0, i = e % 3;\n  const nca = Nb[3 * t + ((i + 1) % 3)], nab = Nb[3 * t + ((i + 2) % 3)];\n  const nbd = Nb[3 * u + ((j + 1) % 3)], ndc = Nb[3 * u + ((j + 2) % 3)];\n  V.set([a, b, d], 3 * t);\n  Nb.set([nbd, u, nab], 3 * t);\n  V.set([d, c, a], 3 * u);\n  Nb.set([nca, t, ndc], 3 * u);\n  for (let k = 0; k \u003c 3; k++) {\n    if (nbd >= 0 && Nb[3 * nbd + k] === u) Nb[3 * nbd + k] = t;\n    if (nca >= 0 && Nb[3 * nca + k] === t) Nb[3 * nca + k] = u;\n  }\n  S.tb[t] = S.tb[u] = S.t;\n}\nconst repoint = (S, n, from, to) => {\n  for (let k = 0; n >= 0 && k \u003c 3; k++) if (S.Nb[3 * n + k] === from) S.Nb[3 * n + k] = to;\n};\nfunction setTri(S, t, a, b, c, na, nb, nc) {\n  S.V.set([a, b, c], 3 * t);\n  S.Nb.set([na, nb, nc], 3 * t);\n  S.tb[t] = S.t;\n}\n// Lawson: flip the side facing p while it is illegal, then the two sides\n// facing p of the triangles the flip made.\nfunction legalize(S, p, stack) {\n  for (let guard = 0; stack.length && guard \u003c 4000; guard++) {\n    const t = stack.pop();\n    let i = 0;\n    while (i \u003c 3 && S.V[3 * t + i] !== p) i++;\n    if (i === 3) continue;\n    const u = S.Nb[3 * t + i];\n    if (u >= 0 && illegal(S, 3 * t + i)) flip(S, 3 * t + i), stack.push(t, u);\n  }\n}\n// p inside t = a b c: three triangles round p.\nfunction insertIn(S, t, p) {\n  const V = S.V, Nb = S.Nb, a = V[3 * t], b = V[3 * t + 1], c = V[3 * t + 2];\n  const n0 = Nb[3 * t], n1 = Nb[3 * t + 1], n2 = Nb[3 * t + 2], t2 = S.T, t3 = S.T + 1;\n  S.T += 2;\n  setTri(S, t, a, b, p, t2, t3, n2);\n  setTri(S, t2, b, c, p, t3, t, n0);\n  setTri(S, t3, c, a, p, t, t2, n1);\n  repoint(S, n0, t, t2);\n  repoint(S, n1, t, t3);\n  legalize(S, p, [t, t2, t3]);\n}\n// p on side e of t (opposite a, from b to c). On a segment t splits in two;\n// inside, the triangle across splits too.\nfunction insertOn(S, e, p) {\n  const V = S.V, Nb = S.Nb, t = (e / 3) | 0, i = e % 3;\n  const a = V[e], b = V[3 * t + ((i + 1) % 3)], c = V[3 * t + ((i + 2) % 3)];\n  const nca = Nb[3 * t + ((i + 1) % 3)], nab = Nb[3 * t + ((i + 2) % 3)], u = Nb[e], t2 = S.T++;\n  if (u \u003c 0) {\n    setTri(S, t, a, b, p, -1, t2, nab);\n    setTri(S, t2, a, p, c, -1, nca, t);\n    repoint(S, nca, t, t2);\n    return legalize(S, p, [t, t2]);\n  }\n  let j = 0;\n  while (Nb[3 * u + j] !== t) j++;\n  const d = V[3 * u + j], nbd = Nb[3 * u + ((j + 1) % 3)], ndc = Nb[3 * u + ((j + 2) % 3)], u2 = S.T++;\n  setTri(S, t, a, b, p, u2, t2, nab);\n  setTri(S, t2, a, p, c, u, nca, t);\n  setTri(S, u, d, c, p, t2, u2, ndc);\n  setTri(S, u2, d, p, b, t, nbd, u);\n  repoint(S, nca, t, t2);\n  repoint(S, nbd, u, u2);\n  legalize(S, p, [t, t2, u, u2]);\n}\n\n// ---- Ruppert's tests. ----\nconst segEnds = (S, e) => [S.V[3 * ((e / 3) | 0) + ((e + 1) % 3)], S.V[3 * ((e / 3) | 0) + ((e + 2) % 3)]];\n// The longest segment with a point from p0 up to p1 inside its diametral\n// circle, or -1. Segments under 2.2 LEDs are not split again.\nfunction encroached(S, p0, p1) {\n  const P = S.P;\n  let best = -1, bl = 0;\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    if (S.Nb[e] >= 0) continue;\n    const [a, b] = segEnds(S, e), l = (P[2 * a] - P[2 * b]) ** 2 + (P[2 * a + 1] - P[2 * b + 1]) ** 2;\n    if (l \u003c 4 * RMIN * RMIN || l \u003c= bl) continue;\n    for (let p = p0; p \u003c p1; p++) {\n      const v = (P[2 * p] - P[2 * a]) * (P[2 * p] - P[2 * b]) + (P[2 * p + 1] - P[2 * a + 1]) * (P[2 * p + 1] - P[2 * b + 1]);\n      if (v \u003c -1e-7 && p !== a && p !== b) (bl = l), (best = e);\n    }\n  }\n  return best;\n}\n// The triangle with the smallest angle below the bound, or when there is\n// none the one with the widest circle past RMAX, or -1.\nfunction worst(S) {\n  let best = -1, bm = S.bound, br = RMAX;\n  for (let t = 0; t \u003c S.T; t++) {\n    const m = minAngle(S, t);\n    if (m >= bm) continue;\n    circum(S.P, S.V[3 * t], S.V[3 * t + 1], S.V[3 * t + 2], S.cc);\n    if (S.cc[2] >= RMIN) (best = t), (bm = m);\n  }\n  for (let t = 0; t \u003c S.T && best \u003c 0; t++) {\n    circum(S.P, S.V[3 * t], S.V[3 * t + 1], S.V[3 * t + 2], S.cc);\n    if (S.cc[2] > br) (best = t), (br = S.cc[2]);\n  }\n  return best;\n}\n// Walk from t toward point p: the triangle that holds it as { t }, the side\n// it lies on as { e }, or the segment in the way as { seg }.\nfunction locate(S, t, p) {\n  const P = S.P, V = S.V;\n  for (let g = 0; g \u003c 4 * S.T + 8; g++) {\n    let next = -1, on = -1;\n    for (let i = 0; i \u003c 3 && next \u003c 0; i++) {\n      const b = V[3 * t + ((i + 1) % 3)], c = V[3 * t + ((i + 2) % 3)];\n      const o = orient(P, b, c, p) / sqrt((P[2 * b] - P[2 * c]) ** 2 + (P[2 * b + 1] - P[2 * c + 1]) ** 2);\n      if (o \u003c -1e-7) next = i;\n      else if (o \u003c 1e-7) on = i;\n    }\n    const e = 3 * t + (next \u003c 0 ? on : next);\n    if (next \u003c 0 && on \u003c 0) return { t };\n    if (S.Nb[e] \u003c 0) return { seg: e };\n    if (next \u003c 0) return { e };\n    t = S.Nb[e];\n  }\n  return null;\n}\n\n// The next step, worked out before it is shown: { split } with the segment,\n// and the rejected centre when there is one, or { t } and its centre.\nfunction plan(S) {\n  const P = S.P, V = S.V, cc = S.cc;\n  if (S.np >= NMAX - 2) return null;\n  const seg = encroached(S, 0, S.np);\n  if (seg >= 0) return splitPlan(S, seg, null);\n  const t = worst(S);\n  if (t \u003c 0) return null;\n  circum(P, V[3 * t], V[3 * t + 1], V[3 * t + 2], cc);\n  const tri = [V[3 * t], V[3 * t + 1], V[3 * t + 2]], at = { t, tri, cx: cc[0], cy: cc[1], r: cc[2] };\n  // The centre waits in the next free slot while it is tested.\n  P[2 * S.np] = cc[0];\n  P[2 * S.np + 1] = cc[1];\n  const by = encroached(S, S.np, S.np + 1);\n  if (by >= 0) return splitPlan(S, by, at);\n  const where = locate(S, t, S.np);\n  if (!where) return null;\n  if (where.seg !== undefined) return splitPlan(S, where.seg, at);\n  return Object.assign(at, { where });\n}\nfunction splitPlan(S, e, from) {\n  const P = S.P, [a, b] = segEnds(S, e);\n  const mx = (P[2 * a] + P[2 * b]) / 2, my = (P[2 * a + 1] + P[2 * b + 1]) / 2;\n  return { split: e, a, b, mx, my, sr: sqrt((P[2 * a] - P[2 * b]) ** 2 + (P[2 * a + 1] - P[2 * b + 1]) ** 2) / 2, from };\n}\nfunction execute(S, pl) {\n  if (pl.split !== undefined) return insertOn(S, pl.split, addPoint(S, pl.mx, pl.my));\n  const p = addPoint(S, pl.cx, pl.cy);\n  if (pl.where.t !== undefined) insertIn(S, pl.where.t, p);\n  else insertOn(S, pl.where.e, p);\n}\n\nfunction restart(S, d) {\n  S.dom = d;\n  build(S, d);\n  Object.assign(S, { phase: 0, pt: 0, u: 0, pl: null });\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, bound: 20 * DEG, dom: -1, k4: -1, btn: false, n0: 0, np: 0, T: 0,\n    P: new Float64Array(2 * NMAX), pb: new Float32Array(NMAX),\n    V: new Int32Array(3 * TMAX), Nb: new Int32Array(3 * TMAX), tb: new Float32Array(TMAX),\n    phase: 0, pt: 0, u: 0, pl: null, q: [0, 0, 0, 0, 0, 0], cc: [0, 0, 0],\n    acc: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// Phases: 0 the corners' triangulation fades in, 1 refining, 2 holding the\n// finished mesh, 3 fading out to the next domain.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 20, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  const bound = cl(k[2], 20, 33) * DEG, k4 = floor(cl(k[3], 0, 5.999));\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (k4 !== S.k4) (S.k4 = k4), restart(S, k4);\n  else if (btn && !S.btn) restart(S, (S.dom + 1) % DOMAINS.length);\n  S.btn = btn;\n  if (abs(bound - S.bound) > 1e-6) {\n    S.bound = bound;\n    if (S.phase === 1 && S.u \u003c 0.5) S.pl = plan(S);\n    if (S.phase === 2) (S.phase = 1), (S.u = 0), (S.pl = plan(S));\n  }\n  S.t += d;\n  S.pt += d;\n  if (S.phase === 0) {\n    if (S.pt >= INTRO) (S.phase = 1), (S.pt = 0), (S.u = 0), (S.pl = plan(S));\n    return;\n  }\n  if (S.phase === 2) {\n    if (S.pt >= HOLD) (S.phase = 3), (S.pt = 0);\n    return;\n  }\n  if (S.phase === 3) {\n    if (S.pt >= FADE) restart(S, (S.dom + 1) % DOMAINS.length);\n    return;\n  }\n  const rate = 0.8 * S.speed * (1 + (S.np - S.n0) / 24);\n  let left = d * rate;\n  while (left > 0 && S.phase === 1) {\n    if (!S.pl) {\n      (S.phase = 2), (S.pt = 0);\n      break;\n    }\n    const step = min(left, 1 - S.u);\n    if (S.u \u003c 0.5 && S.u + step >= 0.5) execute(S, S.pl);\n    S.u += step;\n    left -= step;\n    if (S.u >= 1 - 1e-9) (S.u = 0), (S.pl = plan(S));\n  }\n}\n\n// ---- Drawing into acc, a float RGB buffer. ----\nfunction fill(S, t, c) {\n  const P = S.P, V = S.V, acc = S.acc, xs = [0, 0, 0], ys = [0, 0, 0];\n  for (let k = 0; k \u003c 3; k++) (xs[k] = P[2 * V[3 * t + k]]), (ys[k] = P[2 * V[3 * t + k] + 1]);\n  for (let y = max(0, ceil(min(ys[0], ys[1], ys[2]))); y \u003c= min(H - 1, floor(max(ys[0], ys[1], ys[2]))); y++) {\n    let lo = W, hi = -1;\n    for (let e = 0; e \u003c 3; e++) {\n      const ya = ys[e], yb = ys[(e + 1) % 3];\n      if ((ya - y) * (yb - y) > 0 || ya === yb) continue;\n      const x = xs[e] + ((y - ya) * (xs[(e + 1) % 3] - xs[e])) / (yb - ya);\n      (lo = min(lo, x)), (hi = max(hi, x));\n    }\n    for (let x = max(0, ceil(lo - 0.5)); x \u003c= min(W - 1, floor(hi + 0.5)); x++) acc.set(c, (y * W + x) * 3);\n  }\n}\n// Mode 0 darkens what is there by w, mode 1 moves it toward c by w.\nfunction put(acc, x, y, c, w, mode) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  w = min(1, w);\n  for (let i = 0; i \u003c 3; i++) acc[k + i] = mode ? acc[k + i] + (c[i] - acc[k + i]) * w : acc[k + i] * (1 - c[i] * w);\n}\nfunction line(acc, x0, y0, x1, y1, c, w, mode) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0;\n  for (let x = max(0, ceil(x0)); x \u003c= min(st ? H - 1 : W - 1, floor(x1)); x++) {\n    const y = y0 + (x - x0) * s, iy = floor(y), f = y - iy;\n    if (st) put(acc, iy, x, c, w * (1 - f), mode), put(acc, iy + 1, x, c, w * f, mode);\n    else put(acc, x, iy, c, w * (1 - f), mode), put(acc, x, iy + 1, c, w * f, mode);\n  }\n}\n// A circle: by rows where it runs steep, by columns where it runs flat.\nfunction ring(acc, cx, cy, r, c, w) {\n  if (!(r > 0.5 && r \u003c 1e4)) return;\n  const h = r * 0.7072;\n  for (let ax = 0; ax \u003c 2; ax++) {\n    const a0 = ax ? cx : cy, b0 = ax ? cy : cx, n = ax ? W : H;\n    for (let u = max(0, ceil(a0 - h)); u \u003c= min(n - 1, floor(a0 + h)); u++) {\n      const dv = sqrt(max(0, r * r - (u - a0) ** 2));\n      for (const v of [b0 - dv, b0 + dv]) {\n        const iv = floor(v), f = v - iv;\n        if (ax) put(acc, u, iv, c, w * (1 - f), 1), put(acc, u, iv + 1, c, w * f, 1);\n        else put(acc, iv, u, c, w * (1 - f), 1), put(acc, iv + 1, u, c, w * f, 1);\n      }\n    }\n  }\n}\nfunction dot(acc, x, y, c, w) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let k = 0; k \u003c 4; k++)\n    put(acc, ix + (k & 1), iy + (k >> 1), c, w * min(1, 1.6 * (k & 1 ? fx : 1 - fx) * (k >> 1 ? fy : 1 - fy)), 1);\n}\n// The line from point a to point b.\nconst edge = (S, a, b, c, w, mode) => line(S.acc, S.P[2 * a], S.P[2 * a + 1], S.P[2 * b], S.P[2 * b + 1], c, w, mode);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const P = S.P, V = S.V, Nb = S.Nb, acc = S.acc, c = S.c, pl = S.pl;\n  const white = [1, 1, 1], dark = [0.62, 0.62, 0.62];\n  acc.fill(0);\n  // Fills by smallest angle, all at one brightness; a triangle just made\n  // starts pale and takes its colour over 0.4 s.\n  for (let t = 0; t \u003c S.T; t++) {\n    const age = S.t - S.tb[t];\n    hsv(angleHue(S, minAngle(S, t)), FS * (1 - 0.5 * exp(-age / 0.3)), FV, c);\n    fill(S, t, c);\n  }\n  // Inner edges darken what they cross; the segments are pale lines.\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    const t = (e / 3) | 0, u = Nb[e];\n    if (u >= 0 && u \u003c t) continue;\n    const a = V[3 * t + ((e + 1) % 3)], b = V[3 * t + ((e + 2) % 3)];\n    edge(S, a, b, u >= 0 ? dark : white, u >= 0 ? 1 : 0.85, u \u003c 0);\n  }\n  // The step under way: before its midpoint the circle grows bright, after\n  // it the new point is in and the circle fades.\n  if (S.phase === 1 && pl) {\n    const g = S.u \u003c 0.5 ? 0.25 + 1.5 * S.u : 1 - 1.6 * (S.u - 0.5);\n    const from = pl.split !== undefined ? pl.from : pl;\n    if (from) {\n      for (let k = 0; k \u003c 3 && S.u \u003c 0.5; k++) edge(S, from.tri[k], from.tri[(k + 1) % 3], white, g, 1);\n      ring(acc, from.cx, from.cy, from.r, white, 0.8 * g);\n      if (S.u \u003c 0.5) dot(acc, from.cx, from.cy, pl.split !== undefined ? dark : white, g);\n    }\n    if (pl.split !== undefined) {\n      hsv(S.hue + 0.11, 0.5, 1, c);\n      ring(acc, pl.mx, pl.my, pl.sr, c, g);\n      if (S.u \u003c 0.5) dot(acc, pl.mx, pl.my, white, g);\n    }\n  }\n  // New points shine white for a moment.\n  for (let i = S.n0; i \u003c S.np; i++) {\n    const w = exp(-(S.t - S.pb[i]) / 0.5);\n    if (w > 0.02) dot(acc, P[2 * i], P[2 * i + 1], white, w);\n  }\n  const g = S.phase === 0 ? min(1, S.pt / 0.5) : S.phase === 3 ? max(0, 1 - S.pt / FADE) : 1;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * g * min(1, acc[k])) | 0, (255 * g * min(1, acc[k + 1])) | 0, (255 * g * min(1, acc[k + 2])) | 0);\n    }\n}\n","schlieren-texture":"// ===== Patternflow pattern =====\n// Title:   Schlieren Texture\n// Family:  physics\n// Idea:    A nematic liquid crystal film between crossed polarizers, its director a line field relaxing by Ginzburg-Landau dynamics, so that disclinations of strength +1/2 and -1/2 drift together and annihilate while new pairs are let in, each half-strength core sitting on two dark brushes and each whole-strength core on four, the brushes swinging round the cores as the polarizers turn, over Michel-Levy interference colours that band in the second order down the wedge of the film and step down through the first order into every melted core.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: disinclination lines and the elastic theory of nematic liquid crystals (F. C. Frank, \"On the theory of liquid crystals\", 1958), Ginzburg-Landau relaxation of a complex order parameter (Vitaly Ginzburg and Lev Landau, 1950), interference colour chart (Auguste Michel-Levy, 1888), pattern round 72\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Order=-1..1, Speed=0.2..3, Defects=10..30, Uncross=0..1\n//\n// Knob 1: Order. The film's retardation at its mean thickness, 850 + 650 Order nm. At the opening 0 it is 850 nm, and the wedge spreads it from about 620 nm at the top of the panel to 1080 nm at the bottom, the whole second order in bands: blue, cyan, green, yellow, orange, red and magenta. At -1 it is 200 nm, first-order grey and white; at -0.5, 525 nm, first-order orange and the violet of the sensitive tint; at 1, 1500 nm, the greens and pinks of the third order.\n// Knob 2: Speed. The polarizers turn at 0.03 Speed radians a second, 0.06 at the opening 2, and the brushes of a half-strength core turn twice as fast, a +1/2 core's with the polarizers and a -1/2 core's against them; crossed polarizers look the same after a quarter turn, 26 s at Speed 2, 17 s at 3. The film relaxes 10 Speed time units a second: at Speed 2 a lone pair of opposite cores 20 LEDs apart meets in about 3 s, 30 LEDs apart in about 11 s, 40 apart in 23 s.\n// Knob 3: Defects. The film opens with this many cores and keeps at least this many: when annihilation leaves fewer, new pairs are let in, 26 to 34 LEDs apart at the best of 14 spots away from the cores already there, up to three pairs at once and at most every 1.5 s, and the panel dissolves to them over 0.5 s. One pair in five is a +1 and a -1 with four brushes each, which come apart into half-strength cores within a few seconds. 10 at the opening, 30 at the top.\n// Knob 4: Uncross. Turns the analyzer away from crossed by 90 Uncross degrees: at 0 the polarizers are crossed and the brushes black, at the opening 0.06 they are 5.4 degrees off, at 0.5 the colours have paled and the brushes gone, and at 1 the polarizers are parallel, the brushes white and the colours turned to their pale complements.\n\n// The director n is a line field: n and -n are the same, so its angle theta\n// counts only modulo pi, and a loop round a core may turn it by half a turn,\n// a disclination of strength 1/2. The film is held as the complex order\n// parameter psi = S e^(2 i theta), whose phase counts modulo 2 pi: a\n// half-strength core is a single winding of psi, a whole-strength core a\n// double one, which splits because it costs twice the energy of two singles.\n// psi relaxes by d psi / dt = lap psi + a psi (1 - |psi|^2) with a = 0.15:\n// the order S is below 0.5 over 4 LEDs across a core and below 0.9 over 9.\n// Opposite cores attract and annihilate as the texture coarsens.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\nconst FADE = 0.5, GAIN = 1.4, AGL = 0.15, XI = 1 / sqrt(AGL);\n\n// ---- Michel-Levy colours: white light through a plate of retardation G\n// between crossed polarizers transmits sin^2(pi G / lambda) of each\n// wavelength. Summed against the CIE 1931 matching functions (the\n// multi-lobe fit of Chris Wyman, Peter-Pike Sloan and Peter Shirley, 2013)\n// from 400 to 700 nm and taken to sRGB, each channel divided by white's,\n// then saturated SAT times over for the panel and kept in linear light. One\n// entry each 2 nm up to 2400 nm. ----\nconst SAT = 3, GMAX = 2400, GSTEP = 2, GN = GMAX / GSTEP + 1, ML = new Float32Array(GN * 3);\n{\n  const g = (l, m, a, b) => exp(-0.5 * ((l - m) / (l \u003c m ? a : b)) ** 2);\n  const L = [], C = [];\n  for (let l = 400; l \u003c= 700; l += 10) {\n    L.push(l);\n    const x = 1.056 * g(l, 599.8, 37.9, 31) + 0.362 * g(l, 442, 16, 26.7) - 0.065 * g(l, 501.1, 20.4, 26.2);\n    const y = 0.821 * g(l, 568.8, 46.9, 40.5) + 0.286 * g(l, 530.9, 16.3, 31.1);\n    const z = 1.217 * g(l, 437, 11.8, 36) + 0.681 * g(l, 459, 26, 13.8);\n    C.push([3.2406 * x - 1.5372 * y - 0.4986 * z, -0.9689 * x + 1.8758 * y + 0.0415 * z, 0.0557 * x - 0.204 * y + 1.057 * z]);\n  }\n  const wh = [0, 0, 0];\n  for (const c of C) for (let k = 0; k \u003c 3; k++) wh[k] += c[k];\n  const enc = (v) => (v \u003c= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055);\n  const dec = (v) => (v \u003c= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4);\n  for (let i = 0; i \u003c GN; i++) {\n    const G = i * GSTEP, c = [0, 0, 0];\n    for (let j = 0; j \u003c L.length; j++) {\n      const s = sin((PI * G) / L[j]) ** 2;\n      for (let k = 0; k \u003c 3; k++) c[k] += C[j][k] * s;\n    }\n    for (let k = 0; k \u003c 3; k++) c[k] = enc(cl(c[k] / wh[k], 0, 1));\n    // Saturation (max - min) / max times SAT, hue and the brightest channel kept.\n    const mx = max(c[0], c[1], c[2]), mn = min(c[0], c[1], c[2]), sa = mx > 0 ? (mx - mn) / mx : 0, k2 = sa > 0 ? min(1, sa * SAT) / sa : 1;\n    for (let k = 0; k \u003c 3; k++) ML[i * 3 + k] = dec(mx - (mx - c[k]) * k2);\n  }\n}\n// Back to sRGB for the panel, 1024 steps of linear light.\nconst ENC = new Uint8Array(1025);\nfor (let i = 0; i \u003c= 1024; i++) {\n  const v = i / 1024;\n  ENC[i] = round(255 * (v \u003c= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055));\n}\n\n// The film's thickness, 1 at its mean: a wedge from 0.725 at the top to\n// 1.275 at the bottom and two shallow waves of 0.05 and 0.04 across it, so\n// the colours lie in wavy bands.\nconst D = new Float32Array(N);\nfor (let y = 0, p = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++, p++)\n    D[p] = 1 + 0.55 * ((y - 63.5) / 127) + 0.05 * sin(0.11 * x + 0.035 * y + 1) + 0.04 * sin(0.05 * y - 0.07 * x + 2);\n\n// A core of winding w (+-1 or +-2) at (cx, cy), multiplied into psi: its\n// phase, and its order melted to the profile of a relaxed core.\nfunction core(S, cx, cy, w) {\n  const { U, V } = S, n = abs(w);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const dx = x - cx, dy = y - cy, r2 = dx * dx + dy * dy;\n      const r = sqrt(r2) || 1e-6;\n      let c = dx / r, s = (w \u003c 0 ? -dy : dy) / r;\n      if (n === 2) (s = 2 * c * s), (c = 2 * c * c - 1);\n      // GL core profile, about r / sqrt(r^2 + 2 xi^2), n times over.\n      const f = (r / sqrt(r2 + 2 * XI * XI)) ** n;\n      const u = U[p], v = V[p];\n      U[p] = (u * c - v * s) * f;\n      V[p] = (u * s + v * c) * f;\n    }\n}\n\n// Where the cores are: winding of psi round each 2 by 2 square.\nfunction census(S) {\n  const { U, V, A } = S;\n  for (let p = 0; p \u003c N; p++) A[p] = atan2(V[p], U[p]);\n  const wrap = (d) => (d > PI ? d - TAU : d \u003c -PI ? d + TAU : d);\n  const list = [];\n  let count = 0;\n  for (let y = 0; y \u003c H - 1; y++)\n    for (let x = 0; x \u003c W - 1; x++) {\n      const p = y * W + x, a = A[p], b = A[p + 1], c = A[p + W + 1], d = A[p + W];\n      const w = round((wrap(b - a) + wrap(c - b) + wrap(d - c) + wrap(a - d)) / TAU);\n      if (w) {\n        list.push(x + 0.5, y + 0.5);\n        count += abs(w);\n      }\n    }\n  S.cores = list;\n  S.count = count;\n}\n\n// A spot for a pair: of 14 tries, the one furthest from the cores there.\nfunction spot(S, sep) {\n  let best = null, bd = -1;\n  for (let t = 0; t \u003c 14; t++) {\n    const an = Math.random() * PI, hx = 0.5 * sep * cos(an), hy = 0.5 * sep * sin(an);\n    const cx = 8 + abs(hx) + Math.random() * (48 - 2 * abs(hx)), cy = 8 + abs(hy) + Math.random() * (112 - 2 * abs(hy));\n    let d = 1e9;\n    for (let i = 0; i \u003c S.cores.length; i += 2)\n      for (const e of [-1, 1]) d = min(d, (S.cores[i] - cx - e * hx) ** 2 + (S.cores[i + 1] - cy - e * hy) ** 2);\n    if (d > bd) (bd = d), (best = [cx - hx, cy - hy, cx + hx, cy + hy]);\n  }\n  return best;\n}\n\nfunction pair(S) {\n  const w = Math.random() \u003c 0.2 ? 2 : 1, q = spot(S, 26 + Math.random() * 8);\n  core(S, q[0], q[1], w);\n  core(S, q[2], q[3], -w);\n}\n\n// Relax psi by time t in Euler steps of at most 0.2 (stable below 0.25),\n// walls with no flux through them.\nfunction relax(S, t) {\n  const n = Math.ceil(t / 0.2 - 1e-9);\n  if (n \u003c= 0) return;\n  const h = t / n;\n  let { U, V, U2, V2 } = S;\n  for (let k = 0; k \u003c n; k++) {\n    for (let y = 0, p = 0; y \u003c H; y++) {\n      const up = y > 0 ? -W : 0, dn = y \u003c H - 1 ? W : 0;\n      for (let x = 0; x \u003c W; x++, p++) {\n        const lf = x > 0 ? -1 : 0, rt = x \u003c W - 1 ? 1 : 0, u = U[p], v = V[p];\n        const lu = U[p + lf] + U[p + rt] + U[p + up] + U[p + dn] - 4 * u;\n        const lv = V[p + lf] + V[p + rt] + V[p + up] + V[p + dn] - 4 * v;\n        const g = AGL * (1 - u * u - v * v);\n        U2[p] = u + h * (lu + g * u);\n        V2[p] = v + h * (lv + g * v);\n      }\n    }\n    const tu = U, tv = V;\n    (U = U2), (V = V2), (U2 = tu), (V2 = tv);\n  }\n  S.U = U;\n  S.V = V;\n  S.U2 = U2;\n  S.V2 = V2;\n}\n\n// The opening film: n cores of alternating sign, no two closer than the\n// spacing allows, on a gently twisted background, relaxed 8 time units.\nfunction seed(S, n) {\n  const { U, V } = S;\n  const k1 = Math.random() * TAU, k2 = Math.random() * TAU;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const ph = 0.15 * sin(0.045 * x + 0.03 * y + k1) + 0.1 * sin(0.02 * x - 0.04 * y + k2);\n      U[p] = cos(ph);\n      V[p] = sin(ph);\n    }\n  const pts = [];\n  let dmin = 0.75 * sqrt(N / n), tries = 0;\n  while (pts.length \u003c 2 * n) {\n    const x = 6 + Math.random() * 52, y = 6 + Math.random() * 116;\n    if (++tries > 400) (dmin *= 0.9), (tries = 0);\n    let ok = true;\n    for (let i = 0; i \u003c pts.length && ok; i += 2) ok = (pts[i] - x) ** 2 + (pts[i + 1] - y) ** 2 >= dmin * dmin;\n    if (ok) pts.push(x, y);\n  }\n  for (let i = 0; i \u003c n; i++) core(S, pts[2 * i], pts[2 * i + 1], i & 1 ? -1 : 1);\n  relax(S, 8);\n  census(S);\n}\n\nexport function setup(params) {\n  params.s = {\n    U: new Float32Array(N), V: new Float32Array(N), U2: new Float32Array(N), V2: new Float32Array(N), A: new Float32Array(N),\n    LAST: new Uint8Array(N * 3), OLD: new Uint8Array(N * 3), fade: 9,\n    order: 0, speed: 2, want: 10, uncross: 0.06, phi: 0.3, t: 0, frame: 0, lastPair: -9, cores: [], count: 0, seeded: false,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 10, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.order = cl(k[0], -1, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.want = round(cl(k[2], 10, 30));\n  S.uncross = cl(k[3], 0, 1);\n  if (!S.seeded) {\n    seed(S, S.want + (S.want & 1));\n    S.seeded = true;\n  }\n  S.t += d;\n  S.fade += d;\n  S.phi += d * 0.03 * S.speed;\n  relax(S, d * 10 * S.speed);\n  if (++S.frame % 6 === 0) census(S);\n  if (S.count \u003c S.want && S.t - S.lastPair > 1.5) {\n    // Enough pairs at once to make up the count, three at most, and the\n    // panel dissolves from the last frame to the film with them over FADE\n    // seconds.\n    for (let m = min(3, Math.ceil((S.want - S.count) / 2)); m > 0; m--) {\n      pair(S);\n      census(S);\n    }\n    S.lastPair = S.t;\n    S.OLD.set(S.LAST);\n    S.fade = 0;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.seeded) {\n    for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, 0, 0, 0);\n    return;\n  }\n  const { U, V, OLD, LAST } = S, G0 = 850 + 650 * S.order, w0 = min(1, S.fade / FADE), w = w0 * w0 * (3 - 2 * w0);\n  // Polarizer at phi, analyzer at phi + 90 (1 - Uncross) degrees. A plate\n  // with its axis at theta passes cos^2(A - P) - sin 2(theta - P)\n  // sin 2(theta - A) times sin^2(pi G / lambda) of the light: with the\n  // polarizers crossed, sin^2 2(theta - P) of the colour, black where the\n  // director lies along either polarizer. Mixed in linear light, then\n  // encoded for the panel.\n  const P = S.phi, A = P + (PI / 2) * (1 - S.uncross);\n  const c2p = cos(2 * P), s2p = sin(2 * P), c2a = cos(2 * A), s2a = sin(2 * A), base = cos(A - P) ** 2;\n  for (let p = 0; p \u003c N; p++) {\n    const u = U[p], v = V[p], r = sqrt(u * u + v * v), Sq = min(1, r), iv = r > 1e-9 ? 1 / r : 0;\n    const c = u * iv, s = v * iv; // cos and sin of 2 theta\n    const kP = s * c2p - c * s2p, kA = s * c2a - c * s2a;\n    // Retardation d S: toward a core the colours step down through the\n    // orders to first-order grey, and the light fades as S^3 into it.\n    const G = G0 * D[p] * Sq;\n    const gi = min(GN - 2, G / GSTEP), i0 = floor(gi), f = gi - i0, o = i0 * 3;\n    const m = Sq * Sq * Sq * 1024 * GAIN, t = -kP * kA;\n    const R = (base + t * (ML[o] + f * (ML[o + 3] - ML[o]))) * m;\n    const Gc = (base + t * (ML[o + 1] + f * (ML[o + 4] - ML[o + 1]))) * m;\n    const B = (base + t * (ML[o + 2] + f * (ML[o + 5] - ML[o + 2]))) * m;\n    // Exposed GAIN times over: a channel past full scales the three down\n    // together, so the hue holds.\n    const q = max(1024, R, Gc, B) / 1024, o3 = p * 3;\n    let r8 = ENC[cl((R / q) | 0, 0, 1024)], g8 = ENC[cl((Gc / q) | 0, 0, 1024)], b8 = ENC[cl((B / q) | 0, 0, 1024)];\n    if (w \u003c 1) {\n      r8 = round(OLD[o3] + (r8 - OLD[o3]) * w);\n      g8 = round(OLD[o3 + 1] + (g8 - OLD[o3 + 1]) * w);\n      b8 = round(OLD[o3 + 2] + (b8 - OLD[o3 + 2]) * w);\n    }\n    LAST[o3] = r8;\n    LAST[o3 + 1] = g8;\n    LAST[o3 + 2] = b8;\n    display.setPixel(p & 63, p >> 6, r8, g8, b8);\n  }\n}\n","spray-stencil":"// ===== Patternflow pattern =====\n// Title:   Spray Stencil\n// Family:  type\n// Idea:    A grey metal stencil plate cut with the four syllables of 취급주의 (handle with care) one above the other lies on the side of a kraft cardboard crate, a spray nozzle sweeps down it in a zigzag and builds the paint out of soft particles, and when the plate slides off the letters stand on the crate with their bridges left as gaps, the counters of ㅇ, ㅁ and ㅂ held on by them; then the crate moves on and a fresh one comes under the next plate, 화기엄금 or 파손주의.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 72, after the stencilled handling marks on shipping crates, the syllables drawn for this pattern as a stencil face\n// Round:   72\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Plate=0..3, Overspray=0..1\n//\n// Knob 1: Hue. The paint: azure at 0, then violet, magenta, red at 0.4, orange, yellow and green round the wheel.\n// Knob 2: Speed. At 2 a crate takes 8.4 s: the plate slides on in 0.6 s, the nozzle sweeps it in 4 s, the plate slides off in 0.8 s, the letters hold 2.2 s and the crate moves on in 0.8 s. At 0.2 a crate takes 84 s, at 3 it takes 5.6 s.\n// Knob 3: Plate. 0 the three plates take turns, 취급주의, 화기엄금 (no open flame), 파손주의 (fragile); 1, 2 and 3 keep one of them. A new choice brings a fresh crate and plate at once.\n// Knob 4: Overspray. The nozzle's distance from the plate. At the opening 0.06 the droplets land with a standard deviation of 4 LEDs across the sweep and 3.2 down it, one in ten of them a finer mist spread 1.7 times wider, and the letters print crisp. At 1 the spread is 9.6 LEDs, nearly two in five are mist spread 3.2 times wider and dusting cuts the nozzle has not reached, and paint creeps under the plate's edges: of what lands on the plate 1 LED from a cut, 27 percent reaches the crate beneath, 3 LEDs out 13 percent, so the letters come up soft and haloed.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The stencil face. Each syllable is drawn in a box 52 LEDs wide and\n// 28 tall from cut-outs: [0, x0, y0, x1, y1] a rectangle, [1, xa, ya, xb, yb,\n// w] a slanted stroke w LEDs thick with flat ends, [2, cx, cy, rx, ry, t] an\n// elliptical ring t thick; and [3, x0, y0, x1, y1] a bridge, plate left\n// standing across a cut. Horizontal strokes are 3 to 4 LEDs, upright ones 5.\n// Every ring is bridged top and bottom, and the corners of ㄱ, ㄴ, ㅁ, ㅂ and\n// ㅍ, the peaks of ㅅ, ㅈ and ㅊ and the arms of ㅏ and ㅓ are cut apart by\n// 2 LEDs of plate, so no part of the plate is ringed by a cut and the inside\n// of ㅇ, ㅎ, ㅁ, ㅂ and ㅍ stays held to the rest: filled from its corner, LED\n// to LED across edges, each plate reaches all of its 5855 to 6056 LEDs. The\n// joins of ㅜ and ㅗ ring nothing and stay whole.\nconst SYL = {\n  취: [[0, 17, 0, 25, 3], [0, 5, 3, 37, 6.5], [1, 21, 8.5, 7, 16.5, 4.2], [1, 21, 8.5, 35, 16.5, 4.2], [3, 20, 8, 22, 17],\n    [0, 1, 18.5, 40, 22], [0, 18, 22, 23, 28], [0, 44, 0, 49, 28]],\n  급: [[0, 6, 0, 37, 3.5], [0, 39, 0, 44, 8.5], [0, 0, 10.5, 52, 13.5],\n    [0, 9, 15.5, 14, 28], [0, 38, 15.5, 43, 28], [0, 16, 20, 36, 23], [0, 16, 25, 36, 28]],\n  주: [[0, 7, 0, 45, 4], [1, 26, 6, 10, 15.5, 4.5], [1, 26, 6, 42, 15.5, 4.5], [3, 25, 5, 27, 16],\n    [0, 0, 17.5, 52, 21], [0, 23.5, 21, 28.5, 28]],\n  의: [[2, 20, 9, 14, 8.5, 4.5], [3, 19, 0, 21, 5.5], [3, 19, 12.5, 21, 18], [0, 1, 21, 40, 25], [0, 44, 0, 49, 28]],\n  화: [[0, 14, 0, 22, 2.5], [0, 5, 2.5, 31, 5.5], [2, 18, 11.5, 10, 4.8, 3.3], [3, 17, 6, 19, 10.5], [3, 17, 12.5, 19, 17],\n    [0, 15.5, 18, 20.5, 22.5], [0, 0, 22.5, 37, 26], [0, 41, 0, 46, 28], [0, 48, 11.5, 52, 15.5]],\n  기: [[0, 4, 3, 25, 7], [0, 27, 3, 32, 24], [0, 41, 0, 46, 28]],\n  엄: [[2, 15, 7.5, 12, 7.5, 4.5], [3, 14, 0, 16, 5], [3, 14, 10, 16, 15], [0, 29, 5.5, 35, 9.5], [0, 37, 0, 42, 15.5],\n    [0, 8, 17.5, 13, 28], [0, 37, 17.5, 42, 28], [0, 15, 17.5, 35, 21], [0, 15, 24.5, 35, 28]],\n  금: [[0, 6, 0, 37, 3.5], [0, 39, 0, 44, 8.5], [0, 0, 10.5, 52, 13.5],\n    [0, 9, 15.5, 14, 28], [0, 38, 15.5, 43, 28], [0, 16, 15.5, 36, 19], [0, 16, 24.5, 36, 28]],\n  파: [[0, 2, 1, 33, 5], [0, 2, 23, 33, 27], [1, 11, 7, 9, 21, 4.2], [1, 22, 7, 24, 21, 4.2], [0, 38, 0, 43, 28], [0, 45, 11.5, 51, 15.5]],\n  손: [[1, 26, 0, 11, 9.5, 4.2], [1, 26, 0, 41, 9.5, 4.2], [3, 25, 0, 27, 10], [0, 23.5, 9.5, 28.5, 14], [0, 0, 13.5, 52, 17],\n    [0, 8, 19, 13, 28], [0, 15, 24.5, 46, 28]],\n};\nconst PLATES = [[\"취\", \"급\", \"주\", \"의\"], [\"화\", \"기\", \"엄\", \"금\"], [\"파\", \"손\", \"주\", \"의\"]];\nconst SX = 6, SY = [3, 34, 65, 96];\n\nfunction inPrim(p, x, y) {\n  if (p[0] === 0 || p[0] === 3) return x >= p[1] && x \u003c p[3] && y >= p[2] && y \u003c p[4];\n  if (p[0] === 1) {\n    if (y \u003c p[2] || y >= p[4]) return false;\n    const dx = p[3] - p[1], dy = p[4] - p[2], c = p[1] + (dx * (y - p[2])) / dy;\n    return abs(x - c) \u003c (p[5] / 2) * (sqrt(dx * dx + dy * dy) / dy);\n  }\n  const qx = (x - p[1]) / p[3], qy = (y - p[2]) / p[4], qi = (x - p[1]) / (p[3] - p[5]), qj = (y - p[2]) / (p[4] - p[5]);\n  return qx * qx + qy * qy \u003c 1 && qi * qi + qj * qj >= 1;\n}\n\n// The plate: how much of each LED is cut away (0 to 1, from 4 by 4 samples),\n// and for the plate around the cuts, how far it is to the nearest cut.\nfunction makePlate(k) {\n  const hole = new Float32Array(N), far = new Float32Array(N).fill(99);\n  PLATES[k].forEach((ch, r) => {\n    const prims = SYL[ch], cuts = prims.filter((p) => p[0] !== 3), bridges = prims.filter((p) => p[0] === 3);\n    for (let y = 0; y \u003c 28; y++)\n      for (let x = -1; x \u003c 53; x++) {\n        let c = 0;\n        for (let j = 0; j \u003c 4; j++)\n          for (let i = 0; i \u003c 4; i++) {\n            const u = x + (i + 0.5) / 4, v = y + (j + 0.5) / 4;\n            if (cuts.some((p) => inPrim(p, u, v)) && !bridges.some((p) => inPrim(p, u, v))) c++;\n          }\n        const px = x + SX, py = y + SY[r];\n        if (c && px >= 0 && px \u003c W) hole[py * W + px] = c / 16;\n      }\n  });\n  for (let i = 0; i \u003c N; i++) if (hole[i] >= 0.5) far[i] = 0;\n  // Two chamfer passes give the distance to the nearest cut.\n  const step = (i, j, d) => { if (far[j] + d \u003c far[i]) far[i] = far[j] + d; };\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (x > 0) step(i, i - 1, 1);\n      if (y > 0) step(i, i - W, 1), x > 0 && step(i, i - W - 1, 1.41), x \u003c W - 1 && step(i, i - W + 1, 1.41);\n    }\n  for (let y = H - 1; y >= 0; y--)\n    for (let x = W - 1; x >= 0; x--) {\n      const i = y * W + x;\n      if (x \u003c W - 1) step(i, i + 1, 1);\n      if (y \u003c H - 1) step(i, i + W, 1), x > 0 && step(i, i + W - 1, 1.41), x \u003c W - 1 && step(i, i + W + 1, 1.41);\n    }\n  return { hole, far, paint: new Float32Array(N) };\n}\n\n// ---- Surfaces: value noise from a hash.\nconst hash = (a, b, c) => {\n  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  h = Math.imul(h ^ (h >>> 16), 2246822519);\n  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n};\nfunction vn(x, y, k) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);\n  const a = hash(x0, y0, k), b = hash(x0 + 1, y0, k), c = hash(x0, y0 + 1, k), d = hash(x0 + 1, y0 + 1, k);\n  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n}\n// Kraft board: the flutes of the corrugation run up the side 4 LEDs apart,\n// with fibre speckle and a tint that differs a little from crate to crate.\nfunction makeCrate(seed) {\n  const t = 0.93 + 0.14 * hash(seed, 7, 1), warm = 0.04 * (hash(seed, 9, 2) - 0.5);\n  const lum = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++)\n      lum[y * W + x] = t * (0.92 + 0.07 * vn(x / 9, y / 13, seed) + 0.05 * (hash(x, y, seed) - 0.5) + 0.035 * cos((2 * PI * x) / 4));\n  return { lum, warm, paint: new Float32Array(N) };\n}\n\nfunction gauss() {\n  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n}\n\n// Phases of a crate, in seconds at Speed 2.\nconst T_ON = 0.6, T_SPRAY = 4.0, T_OFF = 0.8, T_HOLD = 2.2, T_MOVE = 0.8;\nconst P_SPRAY = T_ON, P_OFF = P_SPRAY + T_SPRAY, P_HOLD = P_OFF + T_OFF, P_MOVE = P_HOLD + T_HOLD, P_END = P_MOVE + T_MOVE;\nconst DROPS = 26000; // droplets in one pass of the nozzle\nconst PRE = 0.35;\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.plates = [0, 1, 2].map(makePlate);\n  s.seed = 1;\n  s.crate = makeCrate(s.seed);\n  s.next = makeCrate(s.seed + 1);\n  s.mode = -1;\n  s.which = 0;\n  // The panel opens on a plate the nozzle is already a third of the way down.\n  s.t = P_SPRAY + PRE * T_SPRAY;\n  s.nx = -9;\n  s.ny = -9;\n  s.fresh = [];\n  s.hue = 0;\n  s.ov = 0.06;\n  s.buf = new Float32Array(N * 3);\n}\n\nfunction freshCrate(s) {\n  s.seed++;\n  s.crate = s.next;\n  s.next = makeCrate(s.seed + 1);\n}\n\nfunction spray(s, a, b) {\n  // The nozzle runs 13 sweeps across while it moves steadily down, from\n  // 6 LEDs above the panel to 6 below, so its path is a zigzag.\n  const ov = s.ov, sig = 3.6 + 6 * ov, plate = s.plates[s.which], hole = plate.hole, far = plate.far;\n  const pos = (p) => {\n    const q = p * 13, k = floor(q), f = q - k;\n    return [k % 2 ? 72 - 80 * f : -8 + 80 * f, -6 + 140 * p];\n  };\n  const n = round(DROPS * (b - a));\n  const ss = 0.5 + 0.6 * ov, reach = ss > 0.8 ? 2 : 1, bleed = 0.4 * ov * ov, bl = 0.4 + 2.2 * ov;\n  s.fresh.length = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const [px, py] = pos(a + ((b - a) * (i + Math.random())) / n);\n    const mist = Math.random() \u003c 0.08 + 0.3 * ov, r = mist ? sig * (1.6 + 1.6 * ov) : sig, m = mist ? 0.5 : 1;\n    const x = px + gauss() * r, y = py + gauss() * r * 0.8;\n    if (x \u003c -2 || x > W + 1 || y \u003c -2 || y > H + 1) continue;\n    if (i % 2 === 0 && s.fresh.length \u003c 240) s.fresh.push(x, y);\n    const x0 = floor(x), y0 = floor(y);\n    for (let yy = y0 - reach; yy \u003c= y0 + reach; yy++) {\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let xx = x0 - reach; xx \u003c= x0 + reach; xx++) {\n        if (xx \u003c 0 || xx >= W) continue;\n        const dx = xx + 0.5 - x, dy = yy + 0.5 - y, w = (m * exp(-(dx * dx + dy * dy) / (2 * ss * ss))) / (2 * PI * ss * ss);\n        const j = yy * W + xx, c = hole[j];\n        s.crate.paint[j] += w * (c + (1 - c) * bleed * exp(-far[j] / bl));\n        plate.paint[j] += w * (1 - c);\n      }\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const rate = cl(k[1] == null ? 2 : k[1], 0.2, 3) / 2;\n  s.ov = cl(k[3] == null ? 0.06 : k[3], 0, 1);\n  const mode = round(cl(k[2] || 0, 0, 3));\n  if (mode !== s.mode) {\n    // A new choice: fresh crate, and the plate slides on.\n    const first = s.mode \u003c 0;\n    s.mode = mode;\n    s.which = mode ? mode - 1 : 0;\n    if (first) spray(s, 0, PRE);\n    else {\n      freshCrate(s);\n      s.t = 0;\n    }\n  }\n  const t0 = s.t;\n  s.t += dt * rate;\n  s.fresh.length = 0;\n  if (s.t > P_SPRAY && t0 \u003c P_OFF) {\n    const a = cl((t0 - P_SPRAY) / T_SPRAY, 0, 1), b = cl((s.t - P_SPRAY) / T_SPRAY, 0, 1);\n    if (b > a) spray(s, a, b);\n    const q = b * 13, kk = floor(q), f = q - kk;\n    s.nx = kk % 2 ? 72 - 80 * f : -8 + 80 * f;\n    s.ny = -6 + 140 * b;\n  }\n  if (s.t >= P_END) {\n    s.t -= P_END;\n    freshCrate(s);\n    if (!s.mode) s.which = (s.which + 1) % 3;\n    // The plate is wiped between crates, but not clean.\n    const pp = s.plates[s.which].paint;\n    for (let i = 0; i \u003c N; i++) pp[i] *= 0.35;\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const t = s.t, plate = s.plates[s.which], hole = plate.hole, pp = plate.paint, buf = s.buf;\n  const paint = hsv(0.6 + s.hue, 0.88, 1);\n  // Plate offset: slides on from the right, off to the right.\n  const off = t \u003c P_SPRAY ? round(68 * (1 - ease(t / T_ON))) : t \u003c P_OFF ? 0 : round(68 * ease((t - P_OFF) / T_OFF));\n  const lift = t >= P_OFF && t \u003c P_HOLD ? 1 : 0;\n  // Crate move: the painted crate slides down and out, the fresh one follows.\n  const drop = t >= P_MOVE ? round(H * ease((t - P_MOVE) / T_MOVE)) : 0;\n  const kraft = [176, 121, 66];\n  for (let y = 0; y \u003c H; y++) {\n    const sy = y - drop, old = sy >= 0, cr = old ? s.crate : s.next, row = old ? sy : sy + H;\n    const seam = drop && (sy === 0 || sy === -1) ? 0.45 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const i = row * W + x, l = cr.lum[i] * seam;\n      let r = kraft[0] * l * (1 + cr.warm), g = kraft[1] * l, b = kraft[2] * l * (1 - cr.warm);\n      const a = 1 - exp(-1.4 * cr.paint[i]);\n      r += (paint[0] * 250 - r) * a;\n      g += (paint[1] * 250 - g) * a;\n      b += (paint[2] * 250 - b) * a;\n      // The plate over the crate, shifted right by off.\n      const px = x - off;\n      if (px >= 0 && px \u003c W && !drop) {\n        const j = y * W + px, c = hole[j];\n        // The cut's upper left edge throws a one-LED shadow into the hole.\n        const sh = c > 0 && ((px > 0 && hole[j - 1] \u003c 0.5) || (y > 0 && hole[j - W] \u003c 0.5)) ? 0.55 : 1;\n        const brush = 0.94 + 0.08 * hash(0, y, 5) + 0.03 * (hash(px, y, 3) - 0.5);\n        let mr = 100 * brush, mg = 100 * brush, mb = 98 * brush;\n        const pa = (1 - exp(-0.6 * pp[j])) * 0.45;\n        mr += (paint[0] * 150 - mr) * pa;\n        mg += (paint[1] * 150 - mg) * pa;\n        mb += (paint[2] * 150 - mb) * pa;\n        r = r * sh * c + mr * (1 - c);\n        g = g * sh * c + mg * (1 - c);\n        b = b * sh * c + mb * (1 - c);\n      } else if (lift && px >= -3 && px \u003c 0) {\n        // The lifted plate's shadow just left of its edge.\n        const d = 0.55 + 0.15 * (3 + px);\n        r *= d;\n        g *= d;\n        b *= d;\n      }\n      const o = (y * W + x) * 3;\n      buf[o] = r;\n      buf[o + 1] = g;\n      buf[o + 2] = b;\n    }\n  }\n  // The nozzle: a cloud of paint in the air over the sweep, and the droplets\n  // landing this frame.\n  if (t > P_SPRAY && t \u003c P_OFF) {\n    const rad = (3.6 + 6 * s.ov) * 1.3, amp = 0.26 + 0.34 * s.ov;\n    for (let y = max(0, floor(s.ny - 2 * rad)); y \u003c min(H, s.ny + 2 * rad); y++)\n      for (let x = max(0, floor(s.nx - 2 * rad)); x \u003c min(W, s.nx + 2 * rad); x++) {\n        const dx = x + 0.5 - s.nx, dy = y + 0.5 - s.ny, d2 = dx * dx + dy * dy;\n        const e = min(0.85, amp * exp(-d2 / (rad * rad)) + 0.8 * exp(-d2 / 1.6));\n        const o = (y * W + x) * 3;\n        for (let q = 0; q \u003c 3; q++) buf[o + q] += (min(255, paint[q] * 255 + 140 * e) - buf[o + q]) * e;\n      }\n    const f = s.fresh;\n    for (let i = 0; i \u003c f.length; i += 2) {\n      const x = floor(f[i]), y = floor(f[i + 1]);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      for (let q = 0; q \u003c 3; q++) buf[o + q] += (min(255, paint[q] * 255 + 110) - buf[o + q]) * 0.8;\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, round(cl(buf[o], 0, 255)), round(cl(buf[o + 1], 0, 255)), round(cl(buf[o + 2], 0, 255)));\n    }\n}\n","benton-pantograph":"// ===== Patternflow pattern =====\n// Title:   Benton Pantograph\n// Family:  type\n// Idea:    A stylus runs round the outline of a large pattern letter while a pantograph's bars carry its motion down to a cutter that engraves the same letter at a quarter of the size on a steel blank, slanted and condensed or extended by the knobs past what the plain pantograph would give, and the finished punches of BENTON, PUNCH, MATRIX and FAMILY stand in rows below.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Benton pantograph punch-cutter (Linn Boyd Benton, 1885), the pantograph (Christoph Scheiner, 1603), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Slant=0..0.45, Width=-1..1\n//\n// Knob 1: Hue. Turns the brass of the pattern and the punches round the wheel together with the steel blue of the bars; at 0 the pattern is brass and the cut metal pale gold.\n// Knob 2: Speed. At 2 the stylus runs 30 units a second round the outline (the cap height is 14 units), about 94 LEDs of the pattern, so tracing a B takes 3.0 s, BENTON 25.8 s and all four words 94 s; 0.2 is a tenth as fast, 3 half as fast again.\n// Knob 3: Slant. Leans the cut letter by this much of its height: 0 is upright, 0.45 leans the top 24 degrees to the right. The pattern stays upright; only the letter being cut and the punches cut after the turn take it.\n// Knob 4: Width. Condenses or extends the cut letter: -1 is 55% of the pattern's width, 0 as drawn, 1 is 145%. The punches in the rows keep the width they were cut at.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, min, max, sqrt, abs, sin, cos } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The pattern letters, a heavy gothic drawn as outlines: cap height 14\n// units, stems 3, y down from the cap line, x from the left side bearing.\n// Each glyph is [width, contour, hole, ...]; filled even-odd.\nconst GLYPH = {\n  B: [10.5, [0, 0, 7.8, 0, 10, 2, 10, 5.2, 8.7, 6.6, 10.5, 8.2, 10.5, 12, 8.5, 14, 0, 14], [3, 2.8, 6.8, 2.8, 7.2, 3.3, 7.2, 5, 6.8, 5.5, 3, 5.5], [3, 8.3, 7.2, 8.3, 7.6, 8.8, 7.6, 10.7, 7.2, 11.2, 3, 11.2]],\n  E: [9.5, [0, 0, 9.5, 0, 9.5, 2.8, 3, 2.8, 3, 5.6, 8.2, 5.6, 8.2, 8.4, 3, 8.4, 3, 11.2, 9.5, 11.2, 9.5, 14, 0, 14]],\n  N: [11, [0, 0, 3.2, 0, 8, 8.6, 8, 0, 11, 0, 11, 14, 7.8, 14, 3, 5.4, 3, 14, 0, 14]],\n  T: [11, [0, 0, 11, 0, 11, 2.8, 7, 2.8, 7, 14, 4, 14, 4, 2.8, 0, 2.8]],\n  O: [11.5, [3.2, 0, 8.3, 0, 11.5, 3.2, 11.5, 10.8, 8.3, 14, 3.2, 14, 0, 10.8, 0, 3.2], [4.3, 2.8, 7.2, 2.8, 8.5, 4.1, 8.5, 9.9, 7.2, 11.2, 4.3, 11.2, 3, 9.9, 3, 4.1]],\n  P: [10.3, [0, 0, 7.8, 0, 10.3, 2.4, 10.3, 6.4, 7.8, 8.8, 3, 8.8, 3, 14, 0, 14], [3, 2.8, 6.9, 2.8, 7.4, 3.3, 7.4, 5.5, 6.9, 6, 3, 6]],\n  U: [11, [0, 0, 3, 0, 3, 10.3, 3.9, 11.2, 7.1, 11.2, 8, 10.3, 8, 0, 11, 0, 11, 11, 8, 14, 3, 14, 0, 11]],\n  C: [11, [3.2, 0, 8, 0, 11, 3, 11, 4.6, 8, 4.6, 8, 4.1, 6.7, 2.8, 4.3, 2.8, 3, 4.1, 3, 9.9, 4.3, 11.2, 6.7, 11.2, 8, 9.9, 8, 9.4, 11, 9.4, 11, 11, 8, 14, 3.2, 14, 0, 10.8, 0, 3.2]],\n  H: [11, [0, 0, 3, 0, 3, 5.6, 8, 5.6, 8, 0, 11, 0, 11, 14, 8, 14, 8, 8.4, 3, 8.4, 3, 14, 0, 14]],\n  M: [13, [0, 0, 3.6, 0, 6.5, 7.5, 9.4, 0, 13, 0, 13, 14, 10, 14, 10, 5.5, 7.8, 11.5, 5.2, 11.5, 3, 5.5, 3, 14, 0, 14]],\n  A: [12, [4, 0, 8, 0, 12, 14, 8.9, 14, 8.1, 11, 3.9, 11, 3.1, 14, 0, 14], [4.6, 8.4, 7.4, 8.4, 6.2, 3.8, 5.8, 3.8]],\n  R: [10.8, [0, 0, 7.8, 0, 10.3, 2.4, 10.3, 6.2, 8.4, 8.2, 10.8, 14, 7.6, 14, 5.6, 8.8, 3, 8.8, 3, 14, 0, 14], [3, 2.8, 6.9, 2.8, 7.4, 3.3, 7.4, 5.5, 6.9, 6, 3, 6]],\n  I: [3, [0, 0, 3, 0, 3, 14, 0, 14]],\n  X: [12, [0, 0, 3.4, 0, 6, 4.6, 8.6, 0, 12, 0, 7.8, 7, 12, 14, 8.6, 14, 6, 9.4, 3.4, 14, 0, 14, 4.2, 7]],\n  F: [9.5, [0, 0, 9.5, 0, 9.5, 2.8, 3, 2.8, 3, 5.8, 8.2, 5.8, 8.2, 8.6, 3, 8.6, 3, 14, 0, 14]],\n  L: [9, [0, 0, 3, 0, 3, 11.2, 9, 11.2, 9, 14, 0, 14]],\n  Y: [12, [0, 0, 3.4, 0, 6, 5.2, 8.6, 0, 12, 0, 7.5, 8.6, 7.5, 14, 4.5, 14, 4.5, 8.6]],\n};\n// Arc length along each glyph's contours, for the stylus.\nconst PATH = {};\nfor (const ch in GLYPH) {\n  const cs = GLYPH[ch].slice(1), out = [];\n  let total = 0;\n  for (const c of cs) {\n    const n = c.length / 2, cum = [0];\n    for (let i = 0; i \u003c n; i++) {\n      const j = (i + 1) % n;\n      cum.push(cum[i] + sqrt((c[2 * j] - c[2 * i]) ** 2 + (c[2 * j + 1] - c[2 * i + 1]) ** 2));\n    }\n    out.push({ c, n, cum, len: cum[n] });\n    total += cum[n];\n  }\n  PATH[ch] = { cs: out, total };\n}\nfunction along(ch, d) {\n  // The point at distance d along contour after contour.\n  for (const k of PATH[ch].cs) {\n    if (d \u003c= k.len) {\n      let i = 0;\n      while (i \u003c k.n - 1 && k.cum[i + 1] \u003c d) i++;\n      const j = (i + 1) % k.n, f = (d - k.cum[i]) / max(1e-6, k.cum[i + 1] - k.cum[i]);\n      return [k.c[2 * i] + (k.c[2 * j] - k.c[2 * i]) * f, k.c[2 * i + 1] + (k.c[2 * j + 1] - k.c[2 * i + 1]) * f];\n    }\n    d -= k.len;\n  }\n  const k = PATH[ch].cs[PATH[ch].cs.length - 1];\n  return [k.c[0], k.c[1]];\n}\n\n// ---- The machine. The pattern's cap line at y = 5 and baseline at 49, so\n// a unit is 44/14 = 3.14 LEDs, centred on x = 36. The fixed pivot O at\n// (4, 90). Bars O-J of 52 and J-T of 50 LEDs, elbow to the right: over the\n// whole pattern J stays inside x 31..56, y 46..101. Collars at A on O-J and\n// D on J-T, a share s from O and from J, carry the links that meet at\n// P = O + s (T - O), the plain pantograph's point: a copy s times the size,\n// scaled about O, upright and as wide as drawn. Benton's machine added the\n// motions that condense, extend and slant; here they are a stage between P\n// and the cutter C, about the copy's baseline origin.\nconst PS = 44 / 14, PY = 5, PCX = 36, OX = 4, OY = 90, L1 = 52, L2 = 50;\nconst WORDS = [\"BENTON\", \"PUNCH\", \"MATRIX\", \"FAMILY\"];\n// Each word cut at its own ratio, so the collars slide between words: cap\n// heights 11.4, 9.7, 13.2 and 10.6 LEDs.\nconst RATIO = [0.26, 0.22, 0.3, 0.24];\nconst V = 30, SLIDE = 0.5, LIFT = 0.25, ROUT = 0.45, XFER = 0.6, HOLD = 1, SHIFT = 0.8;\n// The rows of finished punches: the last word above, baselines 112 and 126.\nconst ROWY = [112, 126];\n\n// ---- The timeline, in seconds at Speed 2: per letter the pattern slides\n// in, the stylus traces, the cutter clears round the letter, and the punch\n// goes to its row; per word a hold and the rows moving up.\nconst SEG = [];\nlet TOTAL = 0;\nWORDS.forEach((w, wi) => {\n  for (let li = 0; li \u003c w.length; li++) {\n    const ch = w[li], tr = PATH[ch].total / V + LIFT * (PATH[ch].cs.length - 1);\n    for (const [st, d] of [[\"slide\", SLIDE], [\"trace\", tr], [\"rout\", ROUT], [\"xfer\", XFER]]) {\n      SEG.push({ wi, li, st, t0: TOTAL, d });\n      TOTAL += d;\n    }\n  }\n  SEG.push({ wi, li: w.length, st: \"hold\", t0: TOTAL, d: HOLD });\n  TOTAL += HOLD;\n  SEG.push({ wi, li: w.length, st: \"shift\", t0: TOTAL, d: SHIFT });\n  TOTAL += SHIFT;\n});\n// A fresh start comes in as the O of BENTON slides in, with B, E, N and T\n// in the lower row and FAMILY above, all cut at the knobs as they are.\nconst START = (() => {\n  const g = SEG.find((s) => s.wi === 0 && s.li === 4 && s.st === \"slide\");\n  return g.t0 + 0.2 * g.d;\n})();\n\nfunction elbow(tx, ty) {\n  const dx = tx - OX, dy = ty - OY, d = sqrt(dx * dx + dy * dy);\n  const a = (L1 * L1 - L2 * L2 + d * d) / (2 * d), h = sqrt(max(0, L1 * L1 - a * a));\n  const ux = dx / d, uy = dy / d;\n  return [OX + a * ux - uy * h, OY + a * uy + ux * h];\n}\n\nexport function setup(params) {\n  params.s = {\n    tau: START, hue: 0, speed: 2, slant: 0, width: 1, dt: 0,\n    rec: {}, cov: new Float32Array(NP), rgb: new Float32Array(NP * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.slant = cl(k[2], 0, 0.45);\n  S.width = 1 + 0.45 * cl(k[3], -1, 1);\n  S.tau += (d * S.speed) / 2;\n  S.dt = d;\n  // A punch keeps the slant and width it was cut at, from the moment the\n  // cutter has cleared round it.\n  const g = seg(S.tau);\n  if (g.st === \"xfer\") S.rec[g.wi + \",\" + g.li] = [S.slant, S.width];\n}\n\nfunction seg(tau) {\n  const t = ((tau % TOTAL) + TOTAL) % TOTAL;\n  let lo = 0, hi = SEG.length - 1;\n  while (lo \u003c hi) {\n    const m = (lo + hi + 1) >> 1;\n    if (SEG[m].t0 \u003c= t) lo = m;\n    else hi = m - 1;\n  }\n  const g = SEG[lo];\n  return { ...g, e: cl((t - g.t0) / g.d, 0, 1), loc: t - g.t0 };\n}\n\n// ---- Drawing helpers.\nfunction add(rgb, p, c, v) {\n  rgb[p * 3] += c[0] * v, rgb[p * 3 + 1] += c[1] * v, rgb[p * 3 + 2] += c[2] * v;\n}\n// A line, sampled every half LED and spread over the four nearest LEDs.\nfunction line(rgb, x0, y0, x1, y1, c, v) {\n  const n = max(1, ceil(sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) * 2));\n  for (let i = 0; i \u003c= n; i++) {\n    const x = x0 + ((x1 - x0) * i) / n - 0.5, y = y0 + ((y1 - y0) * i) / n - 0.5;\n    const ix = floor(x), iy = floor(y), ax = x - ix, ay = y - iy, a = v / 2;\n    if (iy >= 0 && iy \u003c H) {\n      if (ix >= 0 && ix \u003c W) add(rgb, iy * W + ix, c, a * (1 - ax) * (1 - ay));\n      if (ix + 1 >= 0 && ix + 1 \u003c W) add(rgb, iy * W + ix + 1, c, a * ax * (1 - ay));\n    }\n    if (iy + 1 >= 0 && iy + 1 \u003c H) {\n      if (ix >= 0 && ix \u003c W) add(rgb, (iy + 1) * W + ix, c, a * (1 - ax) * ay);\n      if (ix + 1 >= 0 && ix + 1 \u003c W) add(rgb, (iy + 1) * W + ix + 1, c, a * ax * ay);\n    }\n  }\n}\nfunction dot(rgb, x, y, r, c, v) {\n  for (let j = max(0, floor(y - r - 1)); j \u003c= min(H - 1, floor(y + r + 1)); j++)\n    for (let i = max(0, floor(x - r - 1)); i \u003c= min(W - 1, floor(x + r + 1)); i++) {\n      const d = sqrt((i + 0.5 - x) ** 2 + (j + 0.5 - y) ** 2), a = cl(r + 0.5 - d, 0, 1);\n      if (a > 0) add(rgb, j * W + i, c, v * a);\n    }\n}\n// A glyph placed by its baseline origin (ox, oy), unit size u, width w and\n// slant k: unit point (x, y) goes to (ox + u (w x + k (14 - y)), oy - u (14 - y)).\nconst place = (x, y, ox, oy, u, w, k) => [ox + u * (w * x + k * (14 - y)), oy - u * (14 - y)];\nfunction contours(ch, ox, oy, u, w, k) {\n  return GLYPH[ch].slice(1).map((c) => {\n    const o = [];\n    for (let i = 0; i \u003c c.length; i += 2) o.push(...place(c[i], c[i + 1], ox, oy, u, w, k));\n    return o;\n  });\n}\n// Even-odd coverage of a set of contours, four sub-rows a row and exact\n// along each sub-row. Returns the box it wrote, cleared first.\nfunction fill(cov, cs) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (const c of cs)\n    for (let i = 0; i \u003c c.length; i += 2) (x0 = min(x0, c[i])), (x1 = max(x1, c[i])), (y0 = min(y0, c[i + 1])), (y1 = max(y1, c[i + 1]));\n  const bx0 = max(0, floor(x0)), bx1 = min(W - 1, floor(x1)), by0 = max(0, floor(y0)), by1 = min(H - 1, floor(y1));\n  for (let y = by0; y \u003c= by1; y++) for (let x = bx0; x \u003c= bx1; x++) cov[y * W + x] = 0;\n  const xs = [];\n  for (let y = by0; y \u003c= by1; y++)\n    for (let sub = 0; sub \u003c 4; sub++) {\n      const ys = y + (sub + 0.5) / 4;\n      xs.length = 0;\n      for (const c of cs) {\n        const n = c.length / 2;\n        for (let i = 0; i \u003c n; i++) {\n          const j = (i + 1) % n, ya = c[2 * i + 1], yb = c[2 * j + 1];\n          if ((ya \u003c= ys && yb > ys) || (yb \u003c= ys && ya > ys)) xs.push(c[2 * i] + ((ys - ya) * (c[2 * j] - c[2 * i])) / (yb - ya));\n        }\n      }\n      xs.sort((a, b) => a - b);\n      for (let i = 0; i + 1 \u003c xs.length; i += 2) {\n        const a = max(xs[i], bx0), b = min(xs[i + 1], bx1 + 1);\n        for (let x = floor(a); x \u003c b && x \u003c= bx1; x++) cov[y * W + x] += (min(x + 1, b) - max(x, a)) / 4;\n      }\n    }\n  return [bx0, bx1, by0, by1];\n}\n// Fills that stay put from frame to frame (the pattern at rest, punches in\n// their rows, the face being cleared) are kept by key and copied back.\nconst CACHE = new Map();\nfunction fillK(cov, key, cs) {\n  const hit = CACHE.get(key);\n  if (hit) {\n    const [x0, x1, y0, y1] = hit.r;\n    let i = 0;\n    for (let y = y0; y \u003c= y1; y++) for (let x = x0; x \u003c= x1; x++) cov[y * W + x] = hit.v[i++];\n    return hit.r;\n  }\n  const r = fill(cov, cs), v = new Float32Array(max(0, (r[1] - r[0] + 1) * (r[3] - r[2] + 1)));\n  let i = 0;\n  for (let y = r[2]; y \u003c= r[3]; y++) for (let x = r[0]; x \u003c= r[1]; x++) v[i++] = cov[y * W + x];\n  if (CACHE.size > 96) CACHE.clear();\n  CACHE.set(key, { r, v });\n  return r;\n}\nfunction outline(rgb, cs, c, v) {\n  for (const k of cs) {\n    const n = k.length / 2;\n    for (let i = 0; i \u003c n; i++) {\n      const j = (i + 1) % n;\n      line(rgb, k[2 * i], k[2 * i + 1], k[2 * j], k[2 * j + 1], c, v);\n    }\n  }\n}\n// The box a placed glyph needs, with a margin of m LEDs.\nfunction box(ch, ox, oy, u, w, k, m) {\n  const gw = GLYPH[ch][0];\n  return [ox - m, ox + u * (w * gw + k * 14) + m, oy - u * 14 - m, oy + m];\n}\n// A punch: a steel blank with the letter's face standing bright on it.\nfunction punch(S, ch, ox, oy, u, w, k, a, steel, face, still) {\n  const rgb = S.rgb, b = box(ch, ox, oy, u, w, k, 1.2);\n  for (let y = max(0, floor(b[2])); y \u003c= min(H - 1, floor(b[3])); y++)\n    for (let x = max(0, floor(b[0])); x \u003c= min(W - 1, floor(b[1])); x++) {\n      const edge = x === floor(b[0]) || y === floor(b[2]) ? 1.35 : x === floor(b[1]) || y === floor(b[3]) ? 0.6 : 1;\n      add(rgb, y * W + x, steel, 30 * edge * a);\n    }\n  const key = still ? [ch, ox, oy, u, w, k].map((v) => (typeof v === \"number\" ? v.toFixed(3) : v)).join() : null;\n  const cs = contours(ch, ox, oy, u, w, k), r = key ? fillK(S.cov, key, cs) : fill(S.cov, cs);\n  for (let y = r[2]; y \u003c= r[3]; y++)\n    for (let x = r[0]; x \u003c= r[1]; x++) {\n      const v = min(1, S.cov[y * W + x]);\n      if (v > 0) add(rgb, y * W + x, face, 200 * v * a);\n    }\n}\n\n// Where a word's punches stand in a row: unit size and each origin, the\n// blanks 1 LED apart and the row at most 62 LEDs.\nfunction rowLayout(S, wi) {\n  const w = WORDS[wi], u0 = RATIO[wi] * PS;\n  const kw = [];\n  let sum = 0;\n  for (let i = 0; i \u003c w.length; i++) {\n    const r = S.rec[wi + \",\" + i] || [S.slant, S.width];\n    kw.push(r);\n    sum += r[1] * GLYPH[w[i]][0] + r[0] * 14;\n  }\n  const u = min(u0, (62 - 3.4 * w.length + 1) / sum);\n  let x = (W - (u * sum + 3.4 * w.length - 1)) / 2 + 1.2;\n  const o = [];\n  for (let i = 0; i \u003c w.length; i++) {\n    o.push([x, kw[i][0], kw[i][1]]);\n    x += u * (kw[i][1] * GLYPH[w[i]][0] + kw[i][0] * 14) + 3.4;\n  }\n  return { u, o };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  const g = seg(S.tau), wi = g.wi, word = WORDS[wi];\n  const brass = hsv(0.115 + S.hue, 0.62, 1), hot = hsv(0.13 + S.hue, 0.22, 1), steel = hsv(0.6 + S.hue, 0.28, 1), dim = hsv(0.62 + S.hue, 0.5, 1);\n  const prevW = (wi + WORDS.length - 1) % WORDS.length;\n\n  // The ratio of the word being cut; the collars slide to the next one\n  // while the rows move up.\n  const nextR = RATIO[(wi + 1) % WORDS.length];\n  const s = g.st === \"shift\" ? RATIO[wi] + (nextR - RATIO[wi]) * ss(0, 1, g.e) : RATIO[wi];\n\n  // ---- The pattern: cap line and baseline, the letter filled dim with its\n  // outline, the part the stylus has passed bright.\n  for (const y of [PY - 1, PY + 44])\n    for (let x = 0; x \u003c W; x++) add(rgb, y * W + x, dim, x % 4 \u003c 2 ? 22 : 10);\n  const li = min(g.li, word.length - 1), ch = word[li], gw = GLYPH[ch][0];\n  let off = 0;\n  if (g.st === \"slide\") off = 46 * (1 - ss(0, 1, g.e));\n  else if (g.st === \"xfer\") off = -50 * ss(0, 1, g.e);\n  const showPattern = g.st !== \"hold\" && g.st !== \"shift\";\n  const pox = PCX - (gw * PS) / 2 + off, poy = PY + 44;\n  const P = (x, y) => place(x, y, pox, poy, PS, 1, 0);\n  let done = 0;\n  if (g.st === \"trace\") done = g.loc * V - 0;\n  else if (g.st === \"rout\" || g.st === \"xfer\") done = 1e9;\n  if (showPattern) {\n    const cs = contours(ch, pox, poy, PS, 1, 0);\n    const r = off === 0 ? fillK(S.cov, \"P\" + ch, cs) : fill(S.cov, cs);\n    for (let y = r[2]; y \u003c= r[3]; y++)\n      for (let x = r[0]; x \u003c= r[1]; x++) {\n        const v = min(1, S.cov[y * W + x]);\n        if (v > 0) add(rgb, y * W + x, brass, 62 * v);\n      }\n    outline(rgb, cs, brass, 120);\n    // Traced so far: the distance along the outline, less the lifts.\n    if (done > 0) {\n      let left = g.st === \"trace\" ? 0 : 1e9;\n      if (g.st === \"trace\") {\n        let t = g.loc;\n        for (const k of PATH[ch].cs) {\n          const need = k.len / V;\n          if (t \u003c= need) {\n            left += t * V;\n            break;\n          }\n          left += k.len;\n          t -= need + LIFT;\n          if (t \u003c 0) break;\n        }\n      }\n      let acc = 0;\n      for (const k of PATH[ch].cs) {\n        for (let i = 0; i \u003c k.n; i++) {\n          const a = k.cum[i], b = k.cum[i + 1];\n          if (acc + a >= left) break;\n          const j = (i + 1) % k.n, f = min(1, (left - acc - a) / max(1e-6, b - a));\n          const p0 = P(k.c[2 * i], k.c[2 * i + 1]), p1 = P(k.c[2 * j], k.c[2 * j + 1]);\n          line(rgb, p0[0], p0[1], p0[0] + (p1[0] - p0[0]) * f, p0[1] + (p1[1] - p0[1]) * f, hot, 150);\n        }\n        acc += k.len;\n      }\n      S.left = left;\n    }\n  }\n\n  // ---- The stylus T over the time of this letter.\n  const REST = [60, 30];\n  let T = REST, cutting = false;\n  const startPt = P(...along(ch, 0));\n  if (g.st === \"slide\") {\n    const m = ss(0, 1, g.e);\n    T = [REST[0] + (startPt[0] - REST[0]) * m, REST[1] + (startPt[1] - REST[1]) * m];\n  } else if (g.st === \"trace\") {\n    let t = g.loc, d = 0, lifted = null;\n    for (let c = 0; c \u003c PATH[ch].cs.length; c++) {\n      const k = PATH[ch].cs[c], need = k.len / V;\n      if (t \u003c= need) {\n        d += t * V;\n        break;\n      }\n      d += k.len;\n      t -= need;\n      if (c + 1 \u003c PATH[ch].cs.length && t \u003c= LIFT) {\n        lifted = [P(...along(ch, d - 1e-3)), P(...along(ch, d + 1e-3)), ss(0, 1, t / LIFT)];\n        break;\n      }\n      t -= LIFT;\n    }\n    if (lifted) T = [lifted[0][0] + (lifted[1][0] - lifted[0][0]) * lifted[2], lifted[0][1] + (lifted[1][1] - lifted[0][1]) * lifted[2]];\n    else (T = P(...along(ch, d))), (cutting = true);\n  } else if (g.st === \"rout\") {\n    // The cutter clears round the letter in six passes, top to bottom.\n    const pass = g.e * 6, i = floor(min(5.999, pass)), f = pass - i;\n    const xa = pox - 3, xb = pox + gw * PS + 3, y = PY - 2 + ((i + f) / 6) * 48;\n    T = [i % 2 ? xb + (xa - xb) * f : xa + (xb - xa) * f, y];\n    cutting = true;\n  } else if (g.st === \"xfer\") {\n    // From where the clearing ended, lifted, back to rest.\n    const end = [pox - off - 3, PY + 46], m = ss(0, 1, g.e);\n    T = [end[0] + (REST[0] - end[0]) * m, end[1] + (REST[1] - end[1]) * m];\n  }\n\n  // ---- Linkage geometry.\n  const J = elbow(T[0], T[1]);\n  const A = [OX + s * (J[0] - OX), OY + s * (J[1] - OY)], D = [J[0] + s * (T[0] - J[0]), J[1] + s * (T[1] - J[1])];\n  const Pp = [OX + s * (T[0] - OX), OY + s * (T[1] - OY)];\n  // The copy's baseline origin under the plain pantograph, and the stage.\n  const bo = [OX + s * (pox - off - OX), OY + s * (poy - OY)], u = s * PS;\n  const k = S.slant, w = S.width;\n  const stage = (x, y) => [bo[0] + w * (x - bo[0]) + k * (bo[1] - y), y];\n  const C = stage(Pp[0], Pp[1]);\n\n  // ---- The copy on its blank: the plain pantograph's copy as a faint\n  // ghost, the cut outline so far, then the face as the cutter clears.\n  if (g.st === \"slide\" || g.st === \"trace\" || g.st === \"rout\") {\n    const fadeIn = g.st === \"slide\" ? ss(0.3, 1, g.e) : 1;\n    const b = box(ch, bo[0], bo[1], u, w, k, 1.5);\n    const clearY = g.st === \"rout\" ? C[1] : g.st === \"trace\" ? -1 : -1;\n    for (let y = max(0, floor(b[2])); y \u003c= min(H - 1, floor(b[3])); y++)\n      for (let x = max(0, floor(b[0])); x \u003c= min(W - 1, floor(b[1])); x++) add(rgb, y * W + x, steel, (y + 0.5 \u003c clearY ? 16 : 34) * fadeIn);\n    outline(rgb, contours(ch, bo[0], bo[1], u, 1, 0), dim, 42 * fadeIn);\n    const cs = contours(ch, bo[0], bo[1], u, w, k);\n    if (g.st === \"rout\") {\n      const r = fillK(S.cov, [\"F\", ch, bo[0], bo[1], u, w, k].map((v) => (typeof v === \"number\" ? v.toFixed(3) : v)).join(), cs);\n      for (let y = r[2]; y \u003c= r[3]; y++)\n        for (let x = r[0]; x \u003c= r[1]; x++) {\n          const v = min(1, S.cov[y * W + x]) * (y + 0.5 \u003c clearY ? 1 : 0.25);\n          if (v > 0) add(rgb, y * W + x, hot, 170 * v);\n        }\n    }\n    if (g.st === \"trace\" || g.st === \"rout\") {\n      const left = g.st === \"rout\" ? 1e9 : S.left || 0;\n      let acc = 0;\n      for (let c = 0; c \u003c PATH[ch].cs.length; c++) {\n        const kk = PATH[ch].cs[c], pc = cs[c];\n        for (let i = 0; i \u003c kk.n; i++) {\n          const a = kk.cum[i], bb = kk.cum[i + 1];\n          if (acc + a >= left) break;\n          const j = (i + 1) % kk.n, f = min(1, (left - acc - a) / max(1e-6, bb - a));\n          line(rgb, pc[2 * i], pc[2 * i + 1], pc[2 * i] + (pc[2 * j] - pc[2 * i]) * f, pc[2 * i + 1] + (pc[2 * j + 1] - pc[2 * i + 1]) * f, hot, 190);\n        }\n        acc += kk.len;\n      }\n    }\n  }\n\n  // ---- Rows of finished punches. During the shift the upper row rises\n  // and fades and the lower row moves up into its place.\n  const shift = g.st === \"shift\" ? ss(0, 1, g.e) : 0;\n  {\n    const L = rowLayout(S, prevW);\n    for (let i = 0; i \u003c WORDS[prevW].length; i++) punch(S, WORDS[prevW][i], L.o[i][0], ROWY[0] - 16 * shift, L.u, L.o[i][2], L.o[i][1], 1 - shift, steel, brass, shift === 0);\n  }\n  {\n    const L = rowLayout(S, wi), n = g.st === \"hold\" || g.st === \"shift\" ? word.length : g.li;\n    for (let i = 0; i \u003c n; i++) punch(S, word[i], L.o[i][0], ROWY[1] - (ROWY[1] - ROWY[0]) * shift, L.u, L.o[i][2], L.o[i][1], 1, steel, brass, shift === 0);\n    if (g.st === \"xfer\") {\n      // The finished punch flies from the cutter to its place in the row.\n      const m = ss(0, 1, g.e), r = S.rec[wi + \",\" + g.li] || [k, w];\n      const tx = L.o[g.li][0], ty = ROWY[1];\n      const ox = bo[0] + (tx - bo[0]) * m, oy = bo[1] + (ty - bo[1]) * m - 10 * sin(m * Math.PI);\n      punch(S, ch, ox, oy, u + (L.u - u) * m, r[1], r[0], 1, steel, brass);\n    }\n  }\n\n  // ---- Bars, collars, pivot, stylus and cutter.\n  const bar = (p, q, v) => {\n    const dx = q[0] - p[0], dy = q[1] - p[1], l = sqrt(dx * dx + dy * dy) || 1, nx = (-dy / l) * 0.45, ny = (dx / l) * 0.45;\n    line(rgb, p[0] + nx, p[1] + ny, q[0] + nx, q[1] + ny, steel, v);\n    line(rgb, p[0] - nx, p[1] - ny, q[0] - nx, q[1] - ny, steel, v);\n  };\n  bar([OX, OY], J, 95);\n  bar(J, T, 95);\n  bar(A, Pp, 75);\n  bar(D, Pp, 75);\n  dot(rgb, A[0], A[1], 1.2, steel, 150);\n  dot(rgb, D[0], D[1], 1.2, steel, 150);\n  dot(rgb, J[0], J[1], 1.1, steel, 140);\n  // The pivot on its bracket.\n  for (let y = OY + 1; y \u003c= OY + 5; y++) {\n    const hw = (y - OY) * 0.8;\n    for (let x = max(0, floor(OX - hw)); x \u003c= min(W - 1, floor(OX + hw)); x++) add(rgb, y * W + x, steel, 55);\n  }\n  for (let x = 0; x \u003c= 9; x++) add(rgb, (OY + 6) * W + x, steel, x % 2 ? 90 : 45);\n  dot(rgb, OX, OY, 1.4, hot, 210);\n  // The stage: P where the plain pantograph would cut, a ring; the link to\n  // the cutter C.\n  if (abs(C[0] - Pp[0]) > 0.6) line(rgb, Pp[0], Pp[1], C[0], C[1], dim, 120);\n  dot(rgb, Pp[0], Pp[1], 1.1, steel, 120);\n  dot(rgb, T[0], T[1], 1.2, hot, 230);\n  line(rgb, T[0] - 3, T[1], T[0] + 3, T[1], hot, 60);\n  line(rgb, T[0], T[1] - 3, T[0], T[1] + 3, hot, 60);\n  if (cutting) {\n    dot(rgb, C[0], C[1], 0.9, hot, 255);\n    for (let i = 0; i \u003c 3; i++) {\n      const a = Math.random() * 6.283, r = 0.8 + Math.random() * 2.2;\n      dot(rgb, C[0] + cos(a) * r, C[1] + sin(a) * r, 0.3, hot, 160 * Math.random());\n    }\n  } else dot(rgb, C[0], C[1], 0.8, steel, 120);\n\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","book-from-the-sky":"// ===== Patternflow pattern =====\n// Title:   Book from the Sky\n// Family:  type\n// Idea:    A page of invented characters in vertical columns, each put together from stock radicals and parts in the frames real characters use, is printed over again a column at a time from right to left as a thin new sheet is drawn across it, so a page that looks like Chinese and cannot be read keeps renewing itself.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Book from the Sky (Xu Bing, 1987-1991), about 4,000 invented characters cut as pearwood movable type in a Song-style face; the page after Chinese thread-bound books (ruled columns read top to bottom, right to left, a wider top margin than bottom); pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Ink=0..1, Speed=0.2..3, Strokes=-1..1, Notes=0..1\n//\n// Knob 1: Ink. Paper and ink: at 0 black ink on ivory paper; 0.25 indigo, as in the blue trial impressions of Qing printing; 0.5 vermilion, as in the red ones; 0.75 a rubbing, white characters on black; 1 gold on indigo paper.\n// Knob 2: Speed. How fast the new sheet is drawn across and printed: at 2 a column every 2.4 s, a page in 13.4 s and a 2 s rest before the next sheet; ten times slower at 0.2, half again as fast at 3.\n// Knob 3: Strokes. How many parts a character is built from. At 0 a quarter of the characters have a part split in two again, 7% are one part with a dot added, and a character has 7 pen lines on average (a line runs from pen down to pen up, so 口 is one); at -1 nothing is split, 23% are one part, 5.8 lines; at 1 85% are split, 10.9 lines.\n// Knob 4: Notes. How much of the page is commentary set as two columns of small characters inside one column, four to a place, as Chinese books set their notes: about 7% of the 55 places at 0.06, none at 0, nearly all at 1. Turning Strokes or Notes sets the columns of the new sheet that are not printed yet again.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- Components, as stroke lists. Each is \"wh\" (its own grid, w by h\n// points) and strokes, each stroke a run of x,y digit pairs joined by\n// straight lines; a pair given twice is a dot. Placed in a box, a component\n// is stretched to it, so a 5 by 5 part fills a 5 by 9 half as a tall one.\nconst LEFT = {\n  // Radicals in their narrow left-hand forms, 3 by 9.\n  ren: \"39 2003 1218\", shui: \"39 0011 0314 0826\", shou: \"39 0222 101807 0624\", mu: \"39 0222 1018 1306 2424\",\n  kou: \"39 0323260603\", ri: \"39 0121270701 0424\", yan: \"39 1010 0121 0323 0525280805\", jin: \"39 1001 1021 0323 0525 1318 0827\",\n  wang: \"39 0121 0424 1117 0827\", tu: \"39 0323 1117 0827\", he: \"39 2001 0222 1118 1306 2424\", mu2: \"39 0020280800 0323 0525\",\n  fu: \"39 0008 00202112232415\", xin: \"39 1018 0203 2121\", shi: \"39 0121 1104 0525280805\",\n};\nconst TOP = {\n  // Heads, 9 by 3: grass, roof, bamboo, net, lid, person, mountain, cover.\n  cao: \"93 0181 2022 6062\", mian: \"93 4040 02018182\", zhu: \"93 2002 1131 2222 7052 6181 7272\", wang: \"93 0080820200 3032 5052\",\n  tou: \"93 4041 0282\", ren: \"93 4002 4082\", shan: \"93 0002 4042 8082 0282\", mi: \"93 02018182\",\n};\nconst BOT = {\n  // Feet, 9 by 3: heart, fire dots, legs, dish, one.\n  xin: \"93 0112 2021327281 5050 7070\", huo: \"93 0211 3132 5152 7182\", er: \"93 303102 50528281\", min: \"93 1070 1012 3032 5052 7072 0282\", yi: \"93 0181\",\n};\nconst GEN = {\n  // Parts that go anywhere, small grids stretched to their box.\n  kou: \"33 0020220200\", ri: \"35 0020240400 0222\", mu: \"37 0020260600 0222 0424\", tian: \"55 0040440400 2024 0242\",\n  wang: \"55 0040 0242 0444 2024\", tu: \"54 1131 0343 2023\", gong: \"53 1030 2022 0242\", shi: \"55 0242 2024\",\n  mu4: \"55 0141 2024 2204 2244\", da: \"55 0141 202204 2244\", ren: \"55 202104 2244\", nv: \"55 201244 312304 0242\",\n  zi: \"55 003021 212414 0242\", you: \"55 00403104 1144\", li: \"55 01414434 202204\", cun: \"55 0141 303424 1213\",\n  ge: \"55 0141 1044 3214 3030\", jin: \"55 4011 111304 1242 3234\", qian: \"55 1002 114132 2204 2244\", pu: \"55 1002 1141 3114 1244\",\n  huo: \"55 0112 4132 202204 2244\", mi: \"55 0011 4031 0242 2024 2204 2244\", he: \"55 4011 0242 2124 2204 2244\", shan: \"54 0103 2023 4143 0343\",\n  bai: \"46 2011 0131350501 0333\", ji: \"55 00404202044443\", yi: \"55 0040044443\", ji2: \"55 101304 1030334443\",\n  shi2: \"55 1030 0242 222414 1304 3344\", yang: \"57 1010 3030 0141 1333 0545 2126\", bei: \"57 0040440400 0242 1506 3546\", ding: \"54 0040 202313\",\n  gong2: \"47 0030320204343626\", chong: \"57 2025 0141434301 0646 4545\",\n};\nconst RIGHT = {\n  // Right-hand parts that need the whole 5 by 9 half: short-tailed bird, head.\n  zhui: \"59 2003 1218 3030 2141 2343 2545 2848 3138\", ye: \"59 0040 2011 1232361612 1434 1708 3748\",\n};\nconst NARROW = {\n  // Narrow right-hand parts, 3 by 9: knife, ear, seal.\n  dao: \"39 0105 202817\", fu: \"39 0008 00202112232415\", jie: \"39 0020202515 0008\",\n};\n// Enclosures drawn on the whole 9 by 9, with the box left inside them:\n// mouth, broad, cliff, walk, borders, corpse.\nconst ENC = [\n  [\"0080880800\", 2, 2, 5, 5], [\"4040 1181 111608\", 3, 3, 6, 6], [\"1080 101608\", 3, 2, 6, 7],\n  [\"0011 032316273888\", 3, 0, 6, 6], [\"0800808877\", 2, 2, 5, 7], [\"10707212 101608\", 3, 4, 6, 5],\n];\n\nfunction comp(s) {\n  const [wh, ...st] = s.trim().split(\" \");\n  return { w: +wh[0], h: +wh[1], st: st.map((t) => Array.from(t, Number)) };\n}\nconst set = (o) => Object.keys(o).map((k) => Object.assign(comp(o[k]), { k }));\nconst SL = set(LEFT), ST = set(TOP), SB = set(BOT), SG = set(GEN), SR = set(RIGHT), SN = set(NARROW);\nconst SE = ENC.map(([s, x, y, w, h]) => Object.assign(comp(\"99 \" + s), { box: [x, y, w, h], k: \"e\" + s.length }));\nconst one = (a) => a[floor(Math.random() * a.length)];\n\n// Real characters that a frame and stock parts would make (休, 林, 字, 因,\n// 古), 78 of them, drawn again when they come up: at Strokes 0 that is 3.3%\n// of the characters drawn. Only these are checked. The Kangxi dictionary\n// (1716) holds 47,035 characters and none of it is here, so a page can\n// still carry a real one, which Xu Bing made sure his 4,000 never were.\nconst REAL = new Set(\n  (\"LR:ren+mu4 LR:ren+zi LR:ren+cun LR:ren+shi LR:ren+bai LR:ren+ding LR:ren+ge LR:shui+gong LR:shui+shi LR:shui+yang \" +\n    \"LR:shui+ding LR:shui+mu4 LR:shui+bai LR:shou+ding LR:shou+gong LR:shou+zhui LR:mu+cun LR:mu+tu LR:mu+mu4 LR:mu+zhui \" +\n    \"LR:kou+tu LR:kou+ding LR:kou+shi LR:kou+zhui LR:yan+shi LR:yan+yang LR:yan+ding LR:yan+zhui LR:yan+cun LR:jin+shi \" +\n    \"LR:jin+ding LR:jin+zhui LR:ri+wang LR:tu+zhui LR:xin+zhui LR:shi+ding LR:he+zhui LR:wang+li LR2:nv+zi LR2:mu4+mu4 \" +\n    \"LR2:nv+nv LR2:ren+ren TB:mian+zi TB:mian+nv TB:cao+tian TB:ren+wang TB2:kou+kou TB2:ri+ri TB2:tu+tu TB2:huo+huo \" +\n    \"TB2:shi+kou TBb:ri+yi TBb:tian+xin TBb:mu4+huo TBb:kou+er TB:mian+mu4 LRn:he+dao LRn:gong+fu LRn:you+fu \" +\n    \"LR:shui+ri LR:kou+kou LR:ren+li E0:ren E0:da E0:mu4 E0:kou E0:wang E0:zi \" +\n    \"E1:mu4 E1:tu E2:ding E2:li E3:da E3:cun E3:li E3:shi E4:ren E4:kou\").split(\" \"),\n);\n\n// Bresenham into a bitmap gw wide.\nfunction line(g, gw, x0, y0, x1, y1) {\n  const dx = Math.abs(x1 - x0), dy = -Math.abs(y1 - y0), sx = x0 \u003c x1 ? 1 : -1, sy = y0 \u003c y1 ? 1 : -1;\n  let e = dx + dy;\n  for (;;) {\n    g[y0 * gw + x0] = 1;\n    if (x0 === x1 && y0 === y1) return;\n    const e2 = 2 * e;\n    if (e2 >= dy) (e += dy), (x0 += sx);\n    if (e2 \u003c= dx) (e += dx), (y0 += sy);\n  }\n}\n// Stroke component c into the box; returns its stroke count.\nfunction put(g, gw, c, bx, by, bw, bh) {\n  const sx = c.w > 1 ? (bw - 1) / (c.w - 1) : 0, sy = c.h > 1 ? (bh - 1) / (c.h - 1) : 0;\n  for (const s of c.st) {\n    let px = bx + round(s[0] * sx), py = by + round(s[1] * sy);\n    for (let i = 2; i \u003c s.length; i += 2) {\n      const qx = bx + round(s[i] * sx), qy = by + round(s[i + 1] * sy);\n      line(g, gw, px, py, qx, qy);\n      (px = qx), (py = qy);\n    }\n  }\n  return c.st.length;\n}\n\n// A part in a box: a stock part, or at the next level the box split in two.\n// Small parts are not blown up past two points bigger than their grid.\nfunction part(g, box, nest, keys, depth) {\n  const [x, y, w, h] = box;\n  if (depth \u003c 2 && Math.random() \u003c nest) {\n    keys.push(\"+\");\n    if (w >= 5 && (w >= h || h \u003c 5)) {\n      const lw = floor((w - 1) / 2);\n      return part(g, [x, y, lw, h], nest * 0.6, keys, depth + 1) + part(g, [x + lw + 1, y, w - lw - 1, h], nest * 0.6, keys, depth + 1);\n    }\n    if (h >= 5) {\n      const th = floor((h - 1) / 2);\n      return part(g, [x, y, w, th], nest * 0.6, keys, depth + 1) + part(g, [x, y + th + 1, w, h - th - 1], nest * 0.6, keys, depth + 1);\n    }\n  }\n  const pool = w >= 5 && h >= 9 && Math.random() \u003c 0.12 ? SR : SG;\n  let c = one(pool);\n  for (let i = 0; i \u003c 6 && (c.w > w + 1 || c.h > h + 1); i++) c = one(pool);\n  keys.push(c.k);\n  const bw = c.w \u003c 5 && w > c.w ? min(w, c.w + 2) : w, bh = c.h \u003c 5 && h > c.h ? min(h, c.h + 2) : h;\n  return put(g, 9, c, x + floor((w - bw) / 2), y + floor((h - bh) / 2), bw, bh);\n}\n\n// One invented character into the 9 by 9 bitmap g. u is Strokes moved to\n// 0..1. Frames and their shares at u = 0.5: one part 7%, left radical and\n// right part 36%, two halves 7%, left part and narrow right 6%, head and\n// body 16%, two stacked 6%, body and foot 8%, enclosure 14%.\nfunction makeChar(g, u) {\n  const nest = u \u003c 0.5 ? 0.6 * u : 0.3 + 1.4 * (u - 0.5);\n  const single = u \u003c 0.5 ? 0.22 - 0.3 * u : 0.07 - 0.1 * (u - 0.5);\n  for (let tries = 0; ; tries++) {\n    g.fill(0);\n    const keys = [];\n    let r = Math.random(), n = 0, f;\n    const sh = (1 - single) / 0.93;\n    if (r \u003c single) {\n      // Every stock part alone is a real character (木, 力, 米), so a single\n      // part gets one dot more where there is room for it.\n      (f = \"S\"), (n = part(g, [0, 0, 9, 9], 0, keys, 2) + 1);\n      for (const i of [10, 16, 64, 70, 4, 36, 44].sort(() => Math.random() - 0.5)) {\n        let free = true;\n        for (let dy = -9; dy \u003c= 9; dy += 9) for (let dx = -1; dx \u003c= 1; dx++) if (g[i + dy + dx]) free = false;\n        if (free) {\n          g[i] = 1;\n          break;\n        }\n      }\n    } else if ((r = (r - single) / sh) \u003c 0.36) {\n      const c = one(SL);\n      (f = \"LR\"), keys.push(c.k), (n = put(g, 9, c, 0, 0, 3, 9) + part(g, [4, 0, 5, 9], nest, keys, 0));\n    } else if (r \u003c 0.43) (f = \"LR2\"), (n = part(g, [0, 0, 4, 9], 0, keys, 2) + part(g, [5, 0, 4, 9], 0, keys, 2));\n    else if (r \u003c 0.49) {\n      n = part(g, [0, 0, 5, 9], nest, keys, 0);\n      const c = one(SN);\n      (f = \"LRn\"), keys.push(c.k), (n += put(g, 9, c, 6, 0, 3, 9));\n    } else if (r \u003c 0.65) {\n      const c = one(ST);\n      (f = \"TB\"), keys.push(c.k), (n = put(g, 9, c, 0, 0, 9, 3) + part(g, [0, 4, 9, 5], nest, keys, 0));\n    } else if (r \u003c 0.71) (f = \"TB2\"), (n = part(g, [0, 0, 9, 4], 0, keys, 2) + part(g, [0, 5, 9, 4], 0, keys, 2));\n    else if (r \u003c 0.79) {\n      n = part(g, [0, 0, 9, 5], nest, keys, 0);\n      const c = one(SB);\n      (f = \"TBb\"), keys.push(c.k), (n += put(g, 9, c, 0, 6, 9, 3));\n    } else {\n      const i = floor(Math.random() * SE.length), c = SE[i];\n      (f = \"E\" + i), (n = put(g, 9, c, 0, 0, 9, 9) + part(g, c.box, nest, keys, 0));\n    }\n    if (tries \u003c 8 && REAL.has(f + \":\" + keys.join(\"+\"))) continue;\n    return n;\n  }\n}\n\n// ---- The page. A frame from x 1 to 62 and y 10 to 122, five columns 11\n// wide with a rule between each, eleven characters a column on a 10-row\n// pitch: 55 places. The top margin is 10 rows and the bottom 5, the wider\n// one above as in Chinese books. Columns read right to left, so the\n// printing strips run from x 64 down to 0, split at the rules.\nconst TOPY = 10, BOTY = 122, RULES = [13, 25, 37, 49], EDGES = [64, 49, 37, 25, 13, 0];\nconst STRIP = new Uint8Array(W);\nfor (let x = 0; x \u003c W; x++) STRIP[x] = x >= 49 ? 0 : x >= 37 ? 1 : x >= 25 ? 2 : x >= 13 ? 3 : 4;\n\nfunction makePage(u, notes) {\n  const ink = new Uint8Array(N), halo = new Uint8Array(N);\n  for (let x = 1; x \u003c= 62; x++) ink[TOPY * W + x] = ink[BOTY * W + x] = 1;\n  for (let y = TOPY; y \u003c= BOTY; y++) {\n    ink[y * W + 1] = ink[y * W + 62] = 1;\n    for (const rx of RULES) ink[y * W + rx] = 1;\n  }\n  const g = new Uint8Array(81), sg = new Uint8Array(16);\n  let strokes = 0, chars = 0, note = false;\n  const start = 0.6 * notes, keep = 0.5 + 0.5 * notes;\n  for (let j = 0; j \u003c 5; j++)\n    for (let k = 0; k \u003c 11; k++) {\n      const x0 = 3 + 12 * j, y0 = 12 + 10 * k;\n      note = Math.random() \u003c (note ? keep : start);\n      if (note) {\n        // Four small characters, two side by side, two down.\n        for (let q = 0; q \u003c 4; q++) {\n          sg.fill(0);\n          let c = one(SG);\n          while (c.w > 5 || c.h > 5) c = one(SG);\n          put(sg, 4, c, 0, 0, 4, 4);\n          const ox = x0 + (q & 1 ? 0 : 5), oy = y0 + (q >> 1) * 5;\n          for (let i = 0; i \u003c 16; i++) if (sg[i]) ink[(oy + (i >> 2)) * W + ox + (i & 3)] = 1;\n        }\n        continue;\n      }\n      strokes += makeChar(g, u);\n      chars++;\n      // Song faces cut horizontals thin and verticals thick. An LED cannot\n      // be thinner than one, so a pixel that only runs sideways is inked\n      // lighter (2) and the uprights stay full (1).\n      for (let i = 0; i \u003c 81; i++) {\n        if (!g[i]) continue;\n        const gx = i % 9, gy = floor(i / 9);\n        const side = (gx > 0 && g[i - 1]) || (gx \u003c 8 && g[i + 1]), up = (gy > 0 && g[i - 9]) || (gy \u003c 8 && g[i + 9]);\n        ink[(y0 + gy) * W + x0 + gx] = side && !up ? 2 : 1;\n      }\n    }\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (!ink[p] && (ink[p - 1] || ink[p + 1] || ink[p - W] || ink[p + W])) halo[p] = 1;\n    }\n  return { ink, halo, t0: new Float32Array(5).fill(1e9), strokes, chars };\n}\n\n// Paper grain for two sheets, alternating, so each sheet keeps its own.\nconst GRAIN = [new Float32Array(N), new Float32Array(N)];\nfor (let s = 0; s \u003c 2; s++)\n  for (let p = 0; p \u003c N; p++) {\n    let h = Math.imul(p + 7919 * (s + 1), 2654435761) >>> 0;\n    h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0;\n    GRAIN[s][p] = ((h ^ (h >>> 13)) >>> 0) / 4294967296 - 0.5;\n  }\n\n// Paper and ink along Ink: black on ivory, indigo, vermilion, a rubbing\n// (the paper inked black, the cut strokes left white), gold on indigo.\nconst PAL = [\n  [[238, 229, 205], [24, 22, 24]],\n  [[238, 229, 205], [30, 52, 128]],\n  [[238, 229, 205], [192, 48, 26]],\n  [[26, 26, 30], [228, 222, 206]],\n  [[26, 36, 96], [224, 182, 92]],\n];\n// Each holds for 0.175 either side of its stop, so the knob rests on whole\n// palettes and only passes through the grey between dark and light paper.\nfunction palette(k) {\n  const f = cl(k, 0, 1) * 4, i = min(3, floor(f)), a = PAL[i], b = PAL[i + 1];\n  let t = cl((f - i - 0.35) / 0.3, 0, 1);\n  t = t * t * (3 - 2 * t);\n  return [0, 1].map((j) => a[j].map((v, c) => v + (b[j][c] - v) * t));\n}\n\n// Timing. The new sheet's edge moves 2.5 × Speed LEDs a second; a strip\n// is printed 0.4/Speed s after the sheet has covered it, the impression\n// running down the strip in 2/Speed s (0.2 s and 1 s at Speed 2). Fresh\n// ink is 10% further from the paper than dry ink and darkens the paper\n// beside it by 12% while wet; both dry off in about a second. The page\n// underneath shows through the sheet at 13%, and horizontals are inked\n// at 72%.\nconst FRESH = 0.1, WET = 0.12, DRY = 0.9, SPREAD = 0.4, GHOST = 0.13, THIN = 0.72;\n\nexport function setup(params) {\n  params.s = { t: 0, ready: false, e: 67, rest: 0, sheet: 0, pages: null, u: 0.5, notes: 0.06, speed: 2, ink: 0, key: \"\" };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.ink = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.u = (cl(k[2], -1, 1) + 1) / 2;\n  S.notes = cl(k[3], 0, 1);\n  if (!S.ready) {\n    // The page is full from the first frame: the sheet on top printed\n    // long ago, one under it showing through, and the next one waiting.\n    const older = makePage(S.u, S.notes), old = makePage(S.u, S.notes);\n    older.t0.fill(-1e3), old.t0.fill(-1e3);\n    S.pages = [older, old, makePage(S.u, S.notes)];\n    S.ready = true;\n    S.key = S.u.toFixed(2) + S.notes.toFixed(2);\n  }\n  const key = S.u.toFixed(2) + S.notes.toFixed(2);\n  if (key !== S.key) {\n    // Strokes or Notes turned: the columns of the new sheet not printed yet\n    // are set again, so the change shows from the next column on.\n    S.key = key;\n    const nw = S.pages[2], re = makePage(S.u, S.notes);\n    for (let s = 0; s \u003c 5; s++)\n      if (nw.t0[s] > 1e8)\n        for (let y = 0; y \u003c H; y++)\n          for (let x = EDGES[s + 1]; x \u003c EDGES[s]; x++) (nw.ink[y * W + x] = re.ink[y * W + x]), (nw.halo[y * W + x] = re.halo[y * W + x]);\n  }\n  S.t += d;\n  const [, , nw] = S.pages;\n  if (S.e > 0) {\n    // A page turn is a wipe 67 LEDs long, 13.4 s at Speed 2, longer than\n    // the six seconds the map measures over; motion comes from a column\n    // changing at a time, never the page at once.\n    S.e = max(0, S.e - d * 2.5 * S.speed);\n    for (let s = 0; s \u003c 5; s++) if (nw.t0[s] > 1e8 && S.e \u003c= EDGES[s + 1]) nw.t0[s] = S.t + 0.4 / S.speed;\n    if (S.e === 0) S.rest = 4 / S.speed;\n  } else if ((S.rest -= d) \u003c= 0) {\n    S.pages = [S.pages[1], nw, makePage(S.u, S.notes)];\n    S.sheet ^= 1;\n    S.e = 67;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const [older, old, nw] = S.pages, t = S.t, pass = 2 / S.speed;\n  const [paper, ink] = palette(S.ink);\n  const dr = ink[0] - paper[0], dg = ink[1] - paper[1], db = ink[2] - paper[2];\n  const ga = GRAIN[S.sheet], gb = GRAIN[S.sheet ^ 1];\n  const e = S.e, shadowX = e \u003c 64 ? Math.ceil(e) - 1 : -1;\n  for (let y = 0; y \u003c H; y++) {\n    const rowF = cl((y - TOPY) / (BOTY - TOPY), 0, 1) * pass;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, top = x >= e;\n      const pg = top ? nw : old, under = top ? old : older;\n      const gr = top ? gb[p] : ga[p];\n      // Paper, its grain, and the page under it.\n      let a = 0.035 * gr;\n      if (under.ink[p]) a += GHOST;\n      const ti = pg.t0[STRIP[x]] + rowF;\n      if (t >= ti) {\n        const age = t - ti;\n        if (pg.ink[p]) a = (pg.ink[p] === 2 ? THIN : 1) + FRESH * exp(-age / DRY);\n        else if (pg.halo[p]) a += WET * exp(-age / SPREAD);\n      }\n      const sh = x === shadowX ? 0.97 : 1;\n      const r = (paper[0] + dr * a) * sh, g = (paper[1] + dg * a) * sh, b = (paper[2] + db * a) * sh;\n      display.setPixel(x, y, cl(r, 0, 255) | 0, cl(g, 0, 255) | 0, cl(b, 0, 255) | 0);\n    }\n  }\n}\n","catoptric-anamorphosis":"// ===== Patternflow pattern =====\n// Title:   Catoptric Anamorphosis\n// Family:  type\n// Idea:    A word is drawn on the floor round a mirror cylinder, warped into rings that wrap the cylinder's foot, and only in the cylinder's reflection, seen from the one eye the drawing was traced for, does it stand up straight; the camera sways round that eye, so the word reads and smears while the rings on the floor stay strange.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: catoptric (cylinder mirror) anamorphosis (Jean-François Niceron, La Perspective curieuse, 1638), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..3, Away=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel, each letter a sixth of the wheel from the next: at 0 EYE is azure, violet and pink on grey paper.\n// Knob 2: Speed. The camera's sway and the turn of the words: at 2 the sway takes 14 s and a new word is drawn every 7 s; ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Word. The first word, then the others in turn: EYE, 눈 (eye), SEE, YOU.\n// Knob 4: Away. How far the camera wanders from the eye the floor was drawn for, on a figure of eight round the cylinder up to 60 degrees each way and up and down by 14 degrees. At the opening 0.06 it stays within 3.6 degrees and the word stands straight; at 0.3 it swings 18 degrees and the word slides round the mirror and leans; from 0.5 the word runs off the mirror's edge, while the rings on the floor only turn.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- The scene, in units of the cylinder's radius: the mirror stands on\n// the floor y = 0 round the axis x = z = 0, 3 high. The design eye E looks\n// at a point on the floor 1.6 in front of the axis, with a focal length of\n// 160 LEDs, so the cylinder fills rows 5 to 56, 36 LEDs across at its top\n// and 30 at its foot. The first frame traces the paper's grid (about 25 ms\n// in Node) and each word's first frame its ink (25 to 30 ms); after that a\n// frame is one ray per LED, off the mirror at most once, about 1.5 ms.\nconst RC = 1, HC = 3;\nconst E = [0, 6.2, 7.6], AIM = [0, 0, 1.6];\nconst F = 160;\n\n// ---- Letters as strokes in a unit box, y down: L a line, A an elliptic\n// arc (centre, radii, start and end angle in degrees, clockwise on screen).\nconst GLYPHS = {\n  E: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 0, 1, 0], [\"L\", 0, 0.5, 0.82, 0.5], [\"L\", 0, 1, 1, 1]],\n  Y: [[\"L\", 0, 0, 0.5, 0.5], [\"L\", 1, 0, 0.5, 0.5], [\"L\", 0.5, 0.5, 0.5, 1]],\n  S: [[\"A\", 0.5, 0.26, 0.5, 0.26, -25, -270], [\"A\", 0.5, 0.74, 0.5, 0.26, -90, 155]],\n  O: [[\"A\", 0.5, 0.5, 0.5, 0.5, 0, 360]],\n  U: [[\"L\", 0, 0, 0, 0.5], [\"A\", 0.5, 0.5, 0.5, 0.5, 180, 0], [\"L\", 1, 0.5, 1, 0]],\n  // 눈: ㄴ over ㅜ over ㄴ\n  \"눈\": [[\"L\", 0.1, 0, 0.1, 0.3], [\"L\", 0.1, 0.3, 0.9, 0.3], [\"L\", 0, 0.52, 1, 0.52], [\"L\", 0.5, 0.52, 0.5, 0.68], [\"L\", 0.1, 0.72, 0.1, 1], [\"L\", 0.1, 1, 0.9, 1]],\n};\nconst WORDS = [[\"E\", \"Y\", \"E\"], [\"눈\"], [\"S\", \"E\", \"E\"], [\"Y\", \"O\", \"U\"]];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A camera: position, forward, right and up, from its place and its aim.\nfunction camera(pos, aim, out) {\n  out.o = pos;\n  let fx = aim[0] - pos[0], fy = aim[1] - pos[1], fz = aim[2] - pos[2];\n  const l = sqrt(fx * fx + fy * fy + fz * fz);\n  fx /= l; fy /= l; fz /= l;\n  const rl = sqrt(fx * fx + fz * fz);\n  const rx = -fz / rl, rz = fx / rl;\n  out.fw = [fx, fy, fz];\n  out.rt = [rx, 0, rz];\n  out.up = [-rz * fy, rz * fx - rx * fz, rx * fy];\n  return out;\n}\n// The ray through LED (sx, sy) (fractional, from the top left) into D.\nconst D = [0, 0, 0];\nfunction ray(cam, sx, sy) {\n  const u = sx - W / 2, v = H / 2 - sy, fw = cam.fw, rt = cam.rt, up = cam.up;\n  const x = fw[0] * F + rt[0] * u + up[0] * v, y = fw[1] * F + rt[1] * u + up[1] * v, z = fw[2] * F + rt[2] * u + up[2] * v;\n  const l = 1 / sqrt(x * x + y * y + z * z);\n  D[0] = x * l; D[1] = y * l; D[2] = z * l;\n}\n// Where o + t D meets the cylinder's side (front), or -1.\nfunction hitCyl(ox, oy, oz, dx, dy, dz) {\n  const a = dx * dx + dz * dz, b = ox * dx + oz * dz, c = ox * ox + oz * oz - RC * RC, disc = b * b - a * c;\n  if (disc \u003c 0 || a \u003c 1e-12) return -1;\n  const t = (-b - sqrt(disc)) / a, y = oy + t * dy;\n  return t > 1e-6 && y >= 0 && y \u003c= HC ? t : -1;\n}\n// From E through LED (sx, sy): off the mirror and down to the floor. Writes\n// the floor point's angle round the axis (0 towards E) and radius to FP;\n// false if the ray misses the mirror or the reflection rises.\nconst FP = [0, 0];\nfunction design(cam, sx, sy) {\n  ray(cam, sx, sy);\n  const o = cam.o, t = hitCyl(o[0], o[1], o[2], D[0], D[1], D[2]);\n  if (t \u003c 0) return false;\n  const px = o[0] + t * D[0], py = o[1] + t * D[1], pz = o[2] + t * D[2];\n  const dn = D[0] * px + D[2] * pz; // normal (px, 0, pz) / RC\n  const rx = D[0] - 2 * dn * px, ry = D[1], rz = D[2] - 2 * dn * pz;\n  if (ry >= -1e-6) return false;\n  const s = -py / ry, qx = px + s * rx, qz = pz + s * rz;\n  FP[0] = atan2(qx, qz);\n  FP[1] = sqrt(qx * qx + qz * qz);\n  return true;\n}\n\n// ---- The floor drawing, kept in polar texels round the axis: angle\n// -126..126 degrees in 600 steps, radius 1..6.5 in 220.\nconst TH = 2.2, RA = 1, RB = 6.5, NT = 600, NR = 220;\nconst PAPER = 6.2; // the sheet under the drawing, out to radius 6.2\n// The word's place in E's picture: the rows whose reflection lands between\n// radius 1.32 and 6.0 straight in front, and 86% of the mirror's width,\n// which comes to rows 12.75 to 52.5 and columns 16.7 to 47.3.\nfunction region(cam) {\n  let v0 = 0, v1 = H;\n  for (let y = 0; y \u003c H; y += 0.25) {\n    if (!design(cam, W / 2, y)) continue;\n    if (FP[1] > 6.0) v0 = y + 0.25;\n    else if (FP[1] >= 1.32) v1 = y;\n  }\n  let half = 0;\n  const vm = (v0 + v1) / 2;\n  for (let x = W / 2; x \u003c W; x += 0.25) if (design(cam, x, vm)) half = x - W / 2;\n  return { u0: W / 2 - 0.86 * half, u1: W / 2 + 0.86 * half, v0, v1 };\n}\n\nfunction segDist(px, py, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - s[0]) * dx + (py - s[1]) * dy) / l, 0, 1) : 0;\n  const ex = s[0] + t * dx - px, ey = s[1] + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// The word as E should see it: ink coverage on a grid four to an LED over\n// the region, letters stacked from the top, and which letter each texel is.\nconst MS = 4;\nfunction wordMask(wi, reg) {\n  const word = WORDS[wi], n = word.length;\n  const MU = Math.ceil((reg.u1 - reg.u0) * MS) + 2, MV = Math.ceil((reg.v1 - reg.v0) * MS) + 2;\n  const mask = new Float32Array(MU * MV), id = new Uint8Array(MU * MV);\n  const gap = 2.5, cw = reg.u1 - reg.u0, ch = (reg.v1 - reg.v0 - (n - 1) * gap) / n;\n  const pen = n === 1 ? 3.4 : 2.6, hw = pen / 2;\n  for (let k = 0; k \u003c n; k++) {\n    const x0 = reg.u0, y0 = reg.v0 + k * (ch + gap), sx = cw - pen, sy = ch - pen;\n    const segs = [];\n    const P = (u, v) => [x0 + hw + u * sx, y0 + hw + v * sy];\n    for (const st of GLYPHS[word[k]]) {\n      if (st[0] === \"L\") segs.push([...P(st[1], st[2]), ...P(st[3], st[4])]);\n      else {\n        const [, cx, cy, rx, ry, a0, a1] = st, m = max(6, Math.ceil(abs(a1 - a0) / 8));\n        for (let i = 0; i \u003c m; i++) {\n          const b0 = ((a0 + ((a1 - a0) * i) / m) * PI) / 180, b1 = ((a0 + ((a1 - a0) * (i + 1)) / m) * PI) / 180;\n          segs.push([...P(cx + rx * cos(b0), cy + ry * sin(b0)), ...P(cx + rx * cos(b1), cy + ry * sin(b1))]);\n        }\n      }\n    }\n    // each stroke marks the texels within half a pen of it\n    for (const sg of segs) {\n      const xa = max(0, floor((min(sg[0], sg[2]) - hw - reg.u0) * MS) - 1), xb = min(MU - 1, Math.ceil((max(sg[0], sg[2]) + hw - reg.u0) * MS) + 1);\n      const ya = max(0, floor((min(sg[1], sg[3]) - hw - reg.v0) * MS) - 1), yb = min(MV - 1, Math.ceil((max(sg[1], sg[3]) + hw - reg.v0) * MS) + 1);\n      for (let my = ya; my \u003c= yb; my++)\n        for (let mx = xa; mx \u003c= xb; mx++) {\n          const o = my * MU + mx;\n          if (mask[o] >= 1) continue;\n          const cov = cl((hw - segDist(reg.u0 + (mx + 0.5) / MS, reg.v0 + (my + 0.5) / MS, sg)) * MS + 0.5, 0, 1);\n          if (cov > mask[o]) { mask[o] = cov; id[o] = k; }\n        }\n    }\n  }\n  return { mask, id, MU, MV, n };\n}\n\n// Trace a picture onto the floor: E's picture is cut into cells st LEDs\n// wide, each corner is sent off the mirror to the floor, and each cell's\n// two triangles are filled into the polar texels, every texel reading the\n// picture where its barycentric place falls in E's picture. look(u, v)\n// returns the picture there; skip(u, v) lets a cell with nothing in it go.\nfunction trace(cam, reg, st, look, put, skip) {\n  const nu = Math.ceil((reg.u1 - reg.u0) / st) + 1, nv = Math.ceil((reg.v1 - reg.v0) / st) + 1;\n  const A = new Float32Array(nu * nv), B = new Float32Array(nu * nv), ok = new Uint8Array(nu * nv);\n  for (let j = 0; j \u003c nv; j++)\n    for (let i = 0; i \u003c nu; i++)\n      if (design(cam, reg.u0 + i * st, reg.v0 + j * st)) {\n        const n = j * nu + i;\n        ok[n] = 1;\n        A[n] = ((FP[0] + TH) / (2 * TH)) * (NT - 1);\n        B[n] = ((FP[1] - RA) / (RB - RA)) * (NR - 1);\n      }\n  const tri = (a0, b0, u0, v0, a1, b1, u1, v1, a2, b2, u2, v2) => {\n    const det = (b1 - b2) * (a0 - a2) + (a2 - a1) * (b0 - b2);\n    if (abs(det) \u003c 1e-9) return;\n    const xa = max(0, Math.ceil(min(a0, a1, a2))), xb = min(NT - 1, floor(max(a0, a1, a2)));\n    const ya = max(0, Math.ceil(min(b0, b1, b2))), yb = min(NR - 1, floor(max(b0, b1, b2)));\n    for (let y = ya; y \u003c= yb; y++)\n      for (let x = xa; x \u003c= xb; x++) {\n        const w0 = ((b1 - b2) * (x - a2) + (a2 - a1) * (y - b2)) / det, w1 = ((b2 - b0) * (x - a2) + (a0 - a2) * (y - b2)) / det, w2 = 1 - w0 - w1;\n        if (w0 \u003c -1e-6 || w1 \u003c -1e-6 || w2 \u003c -1e-6) continue;\n        const u = w0 * u0 + w1 * u1 + w2 * u2, v = w0 * v0 + w1 * v1 + w2 * v2;\n        put(y * NT + x, u, v, look(u, v));\n      }\n  };\n  for (let j = 0; j + 1 \u003c nv; j++)\n    for (let i = 0; i + 1 \u003c nu; i++) {\n      const n = j * nu + i;\n      if (!ok[n] || !ok[n + 1] || !ok[n + nu] || !ok[n + nu + 1]) continue;\n      const u = reg.u0 + i * st, v = reg.v0 + j * st;\n      if (skip && skip(u, v, st)) continue;\n      tri(A[n], B[n], u, v, A[n + 1], B[n + 1], u + st, v, A[n + nu], B[n + nu], u, v + st);\n      tri(A[n + 1], B[n + 1], u + st, v, A[n + nu + 1], B[n + nu + 1], u + st, v + st, A[n + nu], B[n + nu], u, v + st);\n    }\n}\n\nfunction floorInk(wi, cam, reg) {\n  const wm = wordMask(wi, reg), ink = new Float32Array(NT * NR), lid = new Uint8Array(NT * NR);\n  const sample = (u, v) => {\n    const mx = (u - reg.u0) * MS - 0.5, my = (v - reg.v0) * MS - 0.5;\n    const ix = floor(mx), iy = floor(my);\n    if (ix \u003c 0 || iy \u003c 0 || ix >= wm.MU - 1 || iy >= wm.MV - 1) return 0;\n    const fx = mx - ix, fy = my - iy, o = iy * wm.MU + ix, m = wm.mask;\n    return (m[o] * (1 - fx) + m[o + 1] * fx) * (1 - fy) + (m[o + wm.MU] * (1 - fx) + m[o + wm.MU + 1] * fx) * fy;\n  };\n  trace(cam, reg, 0.25, sample, (o, u, v, c) => {\n    if (c \u003c= ink[o]) return;\n    ink[o] = c;\n    const mx = cl(round((u - reg.u0) * MS - 0.5), 0, wm.MU - 1), my = cl(round((v - reg.v0) * MS - 0.5), 0, wm.MV - 1);\n    lid[o] = wm.id[my * wm.MU + mx];\n  }, (u, v, st) => sample(u + st / 2, v + st / 2) === 0 && sample(u, v) === 0 && sample(u + st, v + st) === 0 && sample(u + st, v) === 0 && sample(u, v + st) === 0);\n  return { ink, lid };\n}\n\n// Niceron's craticule: a square grid laid over the word in E's picture, 6\n// cells across and 9 down, traced onto the paper with it, so the paper\n// carries the bent grid the drawing was made on.\nfunction craticule(cam, reg) {\n  const g = new Float32Array(NT * NR), cw = (reg.u1 - reg.u0) / 6, ch = (reg.v1 - reg.v0) / 9;\n  trace(cam, reg, 0.5, (u, v) => {\n    const a = abs((u - reg.u0) / cw - round((u - reg.u0) / cw)) * cw, b = abs((v - reg.v0) / ch - round((v - reg.v0) / ch)) * ch;\n    return cl(0.45 - min(a, b), 0, 0.25) * 4;\n  }, (o, u, v, c) => { if (c > g[o]) g[o] = c; });\n  return g;\n}\n\nexport function setup(params) {\n  const cam = camera(E, AIM, {}), reg = region(cam);\n  params.s = {\n    ph: 0, hue: 0, design: cam, reg, grid: craticule(cam, reg), cache: {}, k3: -1, word: 0, prev: -1, wipe: 1, next: 0,\n    cam: camera(E, AIM, {}), col: new Float32Array(9), away: 0.06,\n  };\n}\n\nfunction inkOf(S, wi) {\n  return S.cache[wi] || (S.cache[wi] = floorInk(wi, S.design, S.reg));\n}\n\nconst SWAY = 14, HOLD = 7, WIPE = 1.3; // seconds at Speed 2\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  const speed = cl(kv[1], 0.2, 3), k = (d * speed) / 2;\n  const k3 = cl(round(kv[2]), 0, WORDS.length - 1);\n  if (k3 !== S.k3) {\n    S.k3 = k3; S.word = k3; S.prev = -1; S.wipe = 1; S.next = HOLD;\n  }\n  S.next -= k;\n  if (S.next \u003c= 0) {\n    S.prev = S.word; S.word = (S.word + 1) % WORDS.length; S.wipe = 0; S.next = HOLD;\n  }\n  S.wipe = min(1, S.wipe + k / WIPE);\n  inkOf(S, S.word);\n  // The camera: round the axis by up to 60 degrees and up or down by up to\n  // 14, both scaled by Away, on a slow figure of eight through E.\n  S.away = cl(kv[3], 0, 1);\n  S.ph += (k * 2 * PI) / SWAY;\n  const az = S.away * (PI / 3) * sin(S.ph), el = S.away * 0.245 * sin(2 * S.ph + 0.6);\n  const r0 = sqrt(E[0] * E[0] + E[2] * E[2]), e0 = atan2(E[1], r0), L = sqrt(r0 * r0 + E[1] * E[1]);\n  const e1 = e0 + el, rr = L * cos(e1);\n  const pos = [rr * sin(az), L * sin(e1), rr * cos(az)];\n  const aim = [AIM[2] * sin(az), AIM[1], AIM[2] * cos(az)];\n  camera(pos, aim, S.cam);\n  for (let i = 0; i \u003c 3; i++) hsv(S.hue + 0.55 + i / 6, 0.85, 1, S.col, i * 3);\n}\n\n// ---- Shading. Ink on paper at a floor point: returns light in C.\nconst C = [0, 0, 0];\nfunction floorAt(S, x, z) {\n  const r = sqrt(x * x + z * z), th = atan2(x, z);\n  // bare floor: dark tiles a unit square, their joints a little lighter\n  const jx = abs(x - round(x)), jz = abs(z - round(z));\n  let br = 0.03, bg = 0.034, bb = 0.045;\n  if (min(jx, jz) \u003c 0.035) { br = 0.075; bg = 0.08; bb = 0.095; }\n  // the paper: a sheet out to PAPER, darker near the mirror's foot\n  if (r \u003c PAPER && abs(th) \u003c TH - 0.05) {\n    const edge = cl((PAPER - r) * 8, 0, 1) * cl((TH - 0.05 - abs(th)) * 20, 0, 1);\n    const occl = 1 - 0.55 * exp(-(r - RC) * 6);\n    br += (0.13 * occl - br) * edge; bg += (0.135 * occl - bg) * edge; bb += (0.15 * occl - bb) * edge;\n    const a = ((th + TH) / (2 * TH)) * (NT - 1), b = ((r - RA) / (RB - RA)) * (NR - 1);\n    const ia = floor(a), ib = floor(b);\n    if (ia >= 0 && ib >= 0 && ia \u003c NT - 1 && ib \u003c NR - 1) {\n      const fa = a - ia, fb = b - ib, o = ib * NT + ia;\n      const G = S.grid, gr = ((G[o] * (1 - fa) + G[o + 1] * fa) * (1 - fb) + (G[o + NT] * (1 - fa) + G[o + NT + 1] * fa) * fb) * edge;\n      br += 0.13 * gr; bg += 0.14 * gr; bb += 0.16 * gr;\n      // the new word wipes outwards from the mirror's foot over the old\n      const front = RC + S.wipe * (PAPER - RC + 0.4);\n      const mixNew = cl((front - r) * 3, 0, 1);\n      let ink = 0, id = 0;\n      for (let pass = 0; pass \u003c 2; pass++) {\n        const wi = pass ? S.prev : S.word, wgt = pass ? 1 - mixNew : mixNew;\n        if (wi \u003c 0 || wgt \u003c= 0) continue;\n        const T = S.cache[wi];\n        if (!T) continue;\n        const I = T.ink, c = (I[o] * (1 - fa) + I[o + 1] * fa) * (1 - fb) + (I[o + NT] * (1 - fa) + I[o + NT + 1] * fa) * fb;\n        if (c * wgt > ink) {\n          ink = c * wgt;\n          id = T.lid[I[o] > 0 ? o : I[o + 1] > 0 ? o + 1 : I[o + NT] > 0 ? o + NT : o + NT + 1];\n        }\n      }\n      if (ink > 0) {\n        const col = S.col, q = id * 3;\n        br += (col[q] * 0.95 - br) * ink; bg += (col[q + 1] * 0.95 - bg) * ink; bb += (col[q + 2] * 0.95 - bb) * ink;\n      }\n    }\n  }\n  C[0] = br; C[1] = bg; C[2] = bb;\n}\n// The room above, near black. From this eye no ray reaches it: the mirror\n// keeps a ray's fall, and the eye stands above the mirror's top.\nfunction skyAt() {\n  C[0] = 0.02; C[1] = 0.02; C[2] = 0.03;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const cam = S.cam, o = cam.o, ox = o[0], oy = o[1], oz = o[2];\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      ray(cam, px + 0.5, py + 0.5);\n      const dx = D[0], dy = D[1], dz = D[2];\n      let r = 0, g = 0, b = 0;\n      const tc = hitCyl(ox, oy, oz, dx, dy, dz);\n      // the top of the cylinder\n      const tt = dy \u003c 0 ? (HC - oy) / dy : -1;\n      const cx = ox + tt * dx, cz = oz + tt * dz;\n      if (tt > 0 && cx * cx + cz * cz \u003c= RC * RC && (tc \u003c 0 || tt \u003c tc)) {\n        const rr = sqrt(cx * cx + cz * cz);\n        const rim = cl((rr - 0.88) * 9, 0, 1);\n        r = 0.07 + 0.3 * rim; g = 0.075 + 0.3 * rim; b = 0.09 + 0.32 * rim;\n      } else if (tc > 0) {\n        // the mirror: reflect and look again, a little blue and dimmer,\n        // brighter where the ray grazes\n        const hx = ox + tc * dx, hy = oy + tc * dy, hz = oz + tc * dz;\n        const dn = dx * hx + dz * hz, rx = dx - 2 * dn * hx, ry = dy, rz = dz - 2 * dn * hz;\n        if (ry \u003c 0) floorAt(S, hx - (hy / ry) * rx, hz - (hy / ry) * rz);\n        else skyAt();\n        const k = 0.8 + 0.2 * Math.pow(1 - abs(dn), 4);\n        r = C[0] * k * 0.88; g = C[1] * k * 0.93; b = C[2] * k;\n      } else if (dy \u003c 0) {\n        const t = -oy / dy;\n        floorAt(S, ox + t * dx, oz + t * dz);\n        r = C[0]; g = C[1]; b = C[2];\n      } else {\n        skyAt();\n        r = C[0]; g = C[1]; b = C[2];\n      }\n      display.setPixel(px, py, (255 * cl(r, 0, 1)) | 0, (255 * cl(g, 0, 1)) | 0, (255 * cl(b, 0, 1)) | 0);\n    }\n}\n","lorem-ipsum":"// ===== Patternflow pattern =====\n// Title:   Lorem Ipsum\n// Family:  type\n// Idea:    Cicero's sentence from De finibus is set as a justified block of small type and turned letter by letter into the placeholder it became: an alignment computed at the start says which letters stay, the cut ones drop out of their lines and pile up at the foot of the panel, the kept ones slide into the new justified block, and the missing ones leap back out of the heap or fall in from above.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: lorem ipsum, from Cicero, De finibus bonorum et malorum 1.32-33 (45 BC), the source traced by Richard McClintock (Hampden-Sydney College); the alignment is a longest common subsequence by dynamic programming, the table of Robert Wagner and Michael Fischer's string-to-string correction (1974); pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Passage=0..3, Gravity=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together: at 0 the type is cream, letters on their way out turn slate blue and dim in the heap, and letters coming in are mint until they settle.\n// Knob 2: Speed. The clock of a turn. At 2 a turn takes 8.1 s: the cut letters fall from 0.35 s to about 2.7 s, the kept ones slide from 1.2 s to 2.6 s, the missing ones arrive from 2.4 s to about 4 s, and the new block holds 3.5 s before it turns back. The first turn starts 0.8 s in. Ten times slower at 0.2, half again as fast at 3.\n// Knob 3: Passage. Which sentence and the placeholder made from it: 0 Neque porro quisquam (1.32) and Lorem ipsum, 1 Ut enim ad minima (1.32) and Ut enim ad minim, 2 Quis autem vel eum (1.32) and Duis aute irure, 3 excepturi sint occaecati (1.33) and Excepteur sint occaecat. Turning it sends the block to the new sentence at the next turn.\n// Knob 4: Gravity. 240 LEDs/s² at 0, a third of that at -1, three times it at 1. A letter cut from the top line reaches the heap in about 0.9 s at 0, 1.6 s at -1 and 0.55 s at 1, and a letter leaping back out of the heap rises on the same gravity.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hsv = (h, s, v) => [5, 3, 1].map((n) => ((k) => 255 * v * (1 - s * max(0, min(k, 4 - k, 1))))((n + (h - floor(h)) * 6) % 6));\nconst mix = (a, b, t) => a.map((v, i) => v + (b[i] - v) * t);\n\n// ---- The type: 6 rows, the top one for ascenders, four for the x-height\n// and one for descenders; capitals stand on the top five. Rows from the top, comma between\n// rows, a missing row blank. Only the letters the eight passages use.\nconst FONT = {\n  a: \",.##,#.#,#.#,.##\", b: \"#..,##.,#.#,#.#,##.\", c: \",.##,#..,#..,.##\", d: \"..#,.##,#.#,#.#,.##\", e: \",.#.,###,#..,.##\",\n  f: \".##,.#.,###,.#.,.#.\", g: \",.##,#.#,#.#,.##,##.\", h: \"#..,##.,#.#,#.#,#.#\", i: \"#,,#,#,#\", l: \"#,#,#,#,#\",\n  m: \",####.,#.#.#,#.#.#,#.#.#\", n: \",##.,#.#,#.#,#.#\", o: \",.#.,#.#,#.#,.#.\", p: \",##.,#.#,#.#,##.,#..\", q: \",.##,#.#,#.#,.##,..#\",\n  r: \",#.#,##.,#..,#..\", s: \",.##,#..,..#,##.\", t: \".#.,###,.#.,.#.,..#\", u: \",#.#,#.#,#.#,.##\", v: \",#.#,#.#,#.#,.#.\",\n  x: \",#.#,.#.,.#.,#.#\", N: \"#..#,##.#,#.##,#..#,#..#\", L: \"#..,#..,#..,#..,###\", U: \"#.#,#.#,#.#,#.#,###\",\n  Q: \".##.,#..#,#..#,#..#,.##.,...#\", D: \"##.,#.#,#.#,#.#,##.\", E: \"###,#..,##.,#..,###\", \",\": \",,,,#,#\", \".\": \",,,,#\", \"?\": \"##.,..#,.#.,,.#.\",\n};\n// Each glyph in four turns (0 upright, 1 a quarter turn clockwise, 2 a\n// half, 3 a quarter back), with each column's top and bottom ink row, so a\n// letter lying on its side in the heap rests on its own strokes.\nconst GL = {};\nfor (const ch in FONT) {\n  const rows = FONT[ch].split(\",\"), w = max(...rows.map((r) => r.length));\n  const b0 = new Uint8Array(w * 6);\n  rows.forEach((r, y) => [...r].forEach((v, x) => (b0[y * w + x] = v === \"#\")));\n  GL[ch] = [0, 1, 2, 3].map((t) => {\n    const tw = t & 1 ? 6 : w, th = t & 1 ? w : 6, b = new Uint8Array(tw * th);\n    for (let y = 0; y \u003c 6; y++)\n      for (let x = 0; x \u003c w; x++) {\n        if (!b0[y * w + x]) continue;\n        const [nx, ny] = t === 0 ? [x, y] : t === 1 ? [5 - y, x] : t === 2 ? [w - 1 - x, 5 - y] : [y, w - 1 - x];\n        b[ny * tw + nx] = 1;\n      }\n    const top = new Int8Array(tw).fill(-1), bot = new Int8Array(tw).fill(-1);\n    for (let x = 0; x \u003c tw; x++)\n      for (let y = 0; y \u003c th; y++)\n        if (b[y * tw + x]) {\n          if (top[x] \u003c 0) top[x] = y;\n          bot[x] = y;\n        }\n    return { w: tw, h: th, b, top, bot };\n  });\n}\n\n// ---- The passages: Cicero's sentence, and the placeholder as it is set\n// today. The fourth starts in the middle of Cicero's sentence.\nconst PAIRS = [\n  [\n    \"Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem.\",\n    \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\",\n  ],\n  [\n    \"Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur?\",\n    \"Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\",\n  ],\n  [\n    \"Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?\",\n    \"Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\",\n  ],\n  [\n    \"excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga.\",\n    \"Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\",\n  ],\n];\n\n// The alignment: a longest common subsequence of the two strings, case\n// ignored, by the usual table filled from the ends (196 by 123 cells for\n// the first pair). Reading the table back gives \"=\" for a kept character,\n// \"-\" for one cut from a and \"+\" for one added from b; on a tie it cuts\n// before it adds, so a run of cuts stays together.\nfunction align(a, b) {\n  const n = a.length, m = b.length, L = new Int32Array((n + 1) * (m + 1)), M = m + 1;\n  const eq = (i, j) => a[i].toLowerCase() === b[j].toLowerCase();\n  for (let i = n - 1; i >= 0; i--)\n    for (let j = m - 1; j >= 0; j--) L[i * M + j] = eq(i, j) ? L[(i + 1) * M + j + 1] + 1 : max(L[(i + 1) * M + j], L[i * M + j + 1]);\n  const ops = [];\n  let i = 0, j = 0;\n  while (i \u003c n && j \u003c m) {\n    if (eq(i, j) && L[i * M + j] === L[(i + 1) * M + j + 1] + 1) ops.push(\"=\"), i++, j++;\n    else if (L[(i + 1) * M + j] >= L[i * M + j + 1]) ops.push(\"-\"), i++;\n    else ops.push(\"+\"), j++;\n  }\n  while (i++ \u003c n) ops.push(\"-\");\n  while (j++ \u003c m) ops.push(\"+\");\n  return ops;\n}\n\n// ---- Setting. Words are filled greedily into a 62 LED measure from x 1,\n// one LED between letters and three between words; every line but the\n// last is justified. The extra goes to the word spaces first, up to 4 more\n// each, then one LED at a time into the letter spaces from the left. A\n// line that would need more than that is left short, as a compositor would\n// have hyphenated it. Lines are 7 rows apart from y 2. Returns each\n// character's place, null for a space.\nconst MEAS = 62, X0 = 1, Y0 = 2, LP = 7;\nfunction layout(str) {\n  const words = [];\n  let at = 0;\n  for (const w of str.split(\" \")) words.push({ w, at }), (at += w.length + 1);\n  const wl = (w) => [...w].reduce((s, c) => s + GL[c][0].w + 1, -1);\n  const lines = [];\n  let cur = [], len = 0;\n  for (const wd of words) {\n    const add = wl(wd.w) + (cur.length ? 3 : 0);\n    if (cur.length && len + add > MEAS) lines.push(cur), (cur = []), (len = 0);\n    len += wl(wd.w) + (cur.length ? 3 : 0);\n    cur.push(wd);\n  }\n  lines.push(cur);\n  const pos = new Array(str.length).fill(null);\n  lines.forEach((ln, li) => {\n    const nat = ln.reduce((s, wd) => s + wl(wd.w), 0) + 3 * (ln.length - 1);\n    let extra = li \u003c lines.length - 1 ? MEAS - nat : 0;\n    const ws = new Array(ln.length).fill(0), lg = ln.map((wd) => new Array(wd.w.length).fill(0));\n    const nWs = ln.length - 1, nLg = ln.reduce((s, wd) => s + wd.w.length - 1, 0);\n    if (nWs) for (let k = 0; k \u003c nWs && extra > 0; k++) {\n      const give = min(4, floor(extra / (nWs - k)));\n      (ws[k] = give), (extra -= give);\n    }\n    for (let q = 0; q \u003c ln.length && extra > 0; q++) for (let c = 0; c \u003c ln[q].w.length - 1 && extra > 0; c++) lg[q][c]++, extra--;\n    let x = X0;\n    ln.forEach((wd, q) => {\n      for (let c = 0; c \u003c wd.w.length; c++) {\n        pos[wd.at + c] = { x, y: Y0 + li * LP, line: li };\n        x += GL[wd.w[c]][0].w + 1 + lg[q][c];\n      }\n      x += 2 + ws[q];\n    });\n  });\n  return pos;\n}\n\n// ---- Letters are bodies. Modes:\nconst LINE = 0, LOOSE = 1, FALL = 2, HEAP = 3, SLIDE = 4, DROP = 5, JUMP = 6, WAIT = 7;\n// Times in turn seconds (real seconds at Speed 2) after a turn starts.\nconst CUE = 0.35, CUT = 1.4, SLIDE_AT = 1.2, SLIDE_T = 1.0, IN_AT = 2.4, IN_SPREAD = 0.8, DONE = 4.6, HOLD = 3.5;\n// A heap letter fades after this long unless a later turn takes it back.\nconst LIFE = 28;\n\nexport function setup(params) {\n  params.s = { t: 0, ready: false, pair: 0, side: 0, text: \"\", line: [], bodies: [], next: 0, hue: 0, speed: 2, g: 240 };\n}\n\nfunction body(ch, x, y, mode) {\n  return { ch, rot: 0, x, y, vy: 0, mode, t0: 0, t1: 0, x0: x, y0: y, x1: x, y1: y, to: ch, landed: -9, fresh: false, spin: 0 };\n}\n\nfunction setText(S, str) {\n  const pos = layout(str);\n  S.text = str;\n  S.line = pos.map((p, i) => (p ? body(str[i], p.x, p.y, LINE) : null));\n  S.bodies = S.line.filter(Boolean);\n}\n\n// Start a turn from the text on the panel to str.\nfunction turn(S, str) {\n  const a = S.text, ops = align(a, str), pa = layout(a), pb = layout(str), t = S.t;\n  const nl = new Array(str.length).fill(null);\n  let nCut = 0, nIn = 0;\n  for (let k = 0, i = 0, j = 0; k \u003c ops.length; k++) {\n    if (ops[k] === \"-\" && pa[i]) nCut++;\n    if (ops[k] === \"+\" && pb[j]) nIn++;\n    if (ops[k] !== \"+\") i++;\n    if (ops[k] !== \"-\") j++;\n  }\n  let cut = 0, inn = 0;\n  for (let k = 0, i = 0, j = 0; k \u003c ops.length; k++) {\n    const o = ops[k];\n    if (o === \"=\") {\n      const b = S.line[i];\n      if (b && pb[j]) {\n        Object.assign(b, { mode: SLIDE, t0: t + SLIDE_AT + 0.03 * pa[i].line, x0: b.x, y0: b.y, x1: pb[j].x, y1: pb[j].y, to: str[j] });\n        b.t1 = b.t0 + SLIDE_T;\n        nl[j] = b;\n      }\n      i++, j++;\n    } else if (o === \"-\") {\n      const b = S.line[i];\n      // Cut letters go in reading order over CUT s, each turning towards\n      // the colour of the cut for CUE s before it falls.\n      if (b) Object.assign(b, { mode: LOOSE, t0: t + CUE + (CUT * cut++) / max(1, nCut - 1) });\n      i++;\n    } else {\n      if (pb[j]) {\n        const b = body(str[j], pb[j].x, -8, WAIT);\n        Object.assign(b, { t0: t + IN_AT + (IN_SPREAD * inn++) / max(1, nIn - 1), x1: pb[j].x, y1: pb[j].y });\n        nl[j] = b;\n        S.bodies.push(b);\n      }\n      j++;\n    }\n  }\n  S.text = str;\n  S.line = nl;\n  S.next = t + DONE + HOLD;\n}\n\n// Where a sprite at column x would come to rest on the surface.\nfunction restY(surf, sp, x) {\n  let y = 1e9;\n  for (let c = 0; c \u003c sp.w; c++) if (sp.bot[c] >= 0) y = min(y, surf[x + c] - 1 - sp.bot[c]);\n  return y;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.g = 240 * Math.pow(3, cl(k[3], -1, 1));\n  const pair = cl(round(k[2]), 0, 3);\n  const sd = (d * S.speed) / 2;\n  if (!S.ready) {\n    S.pair = pair;\n    setText(S, PAIRS[pair][0]);\n    S.next = 0.8;\n    S.ready = true;\n  }\n  S.t += sd;\n  const t = S.t, g = S.g;\n  if (t >= S.next) {\n    // Turn to the other side of the pair, or to Cicero's side of a new one.\n    if (pair !== S.pair) (S.pair = pair), (S.side = 0);\n    else S.side ^= 1;\n    turn(S, PAIRS[S.pair][S.side]);\n  }\n\n  // Timed modes.\n  const heap = S.bodies.filter((b) => b.mode === HEAP);\n  for (const b of S.bodies) {\n    if (b.mode === LOOSE && t >= b.t0) {\n      // A cut letter tips onto its side a third of the time each way.\n      const r = Math.random();\n      Object.assign(b, { mode: FALL, vy: 0, y0: b.y, spin: r \u003c 0.25 ? 1 : r \u003c 0.5 ? 3 : 0 });\n    } else if (b.mode === SLIDE) {\n      const u = cl((t - b.t0) / (b.t1 - b.t0), 0, 1), e = u * u * (3 - 2 * u);\n      b.x = b.x0 + (b.x1 - b.x0) * e;\n      b.y = b.y0 + (b.y1 - b.y0) * e;\n      if (u > 0.5) b.ch = b.to;\n      if (u >= 1) b.mode = LINE;\n    } else if (b.mode === WAIT && t >= b.t0) {\n      // A letter that is needed comes back out of the heap if one like it\n      // lies there, the highest first; otherwise it falls in from above.\n      let best = null;\n      for (const h of heap) if (h.mode === HEAP && h.ch.toLowerCase() === b.ch.toLowerCase() && (!best || h.y \u003c best.y)) best = h;\n      b.fresh = true;\n      if (best) {\n        best.mode = -1;\n        const dy = max(4, best.y - b.y1), T = sqrt((2 * dy) / g);\n        Object.assign(b, { mode: JUMP, x0: best.x, y0: best.y, x: best.x, y: best.y, rot: best.rot, t0: t, t1: t + T, vy: -g * T });\n      } else Object.assign(b, { mode: DROP, x: b.x1, y: -8 - 10 * Math.random(), vy: 0 });\n    } else if (b.mode === DROP) {\n      b.vy += g * sd;\n      b.y += b.vy * sd;\n      if (b.y >= b.y1) Object.assign(b, { y: b.y1, mode: LINE, landed: t });\n    } else if (b.mode === JUMP) {\n      const s = min(t - b.t0, b.t1 - b.t0), T = b.t1 - b.t0;\n      b.x = b.x0 + ((b.x1 - b.x0) * s) / T;\n      b.y = b.y0 + b.vy * s + 0.5 * g * s * s;\n      if (s > T * 0.4) b.rot = 0;\n      if (t >= b.t1) Object.assign(b, { x: b.x1, y: b.y1, mode: LINE, landed: t, rot: 0 });\n    }\n  }\n  S.bodies = S.bodies.filter((b) => b.mode !== -1 && !(b.mode === HEAP && t - b.landed > LIFE + 2));\n\n  // The heap. Resting letters are stacked from the bottom up on a surface\n  // of the highest ink in each column; one whose support has gone falls\n  // again. A falling letter lands on the surface, unless the column beside\n  // it lets it rest two rows lower, when it slides that way first.\n  const surf = new Float32Array(W).fill(H);\n  const rest = S.bodies.filter((b) => b.mode === HEAP).sort((p, q) => q.y - p.y);\n  for (const b of rest) {\n    const sp = GL[b.ch][b.rot], ry = restY(surf, sp, b.x);\n    if (b.y \u003c ry - 0.5) {\n      b.mode = FALL;\n      b.vy = 0;\n      continue;\n    }\n    b.y = ry;\n    for (let c = 0; c \u003c sp.w; c++) if (sp.top[c] >= 0) surf[b.x + c] = min(surf[b.x + c], ry + sp.top[c]);\n  }\n  const falling = S.bodies.filter((b) => b.mode === FALL).sort((p, q) => q.y - p.y);\n  for (const b of falling) {\n    if (b.spin && b.y - b.y0 > 4) (b.rot = b.spin), (b.spin = 0), (b.x = cl(round(b.x) - 1, 0, W - 6));\n    const sp = GL[b.ch][b.rot];\n    b.x = cl(round(b.x), 0, W - sp.w);\n    b.vy += g * sd;\n    b.y += b.vy * sd;\n    let ry = restY(surf, sp, b.x);\n    if (b.y \u003c ry) continue;\n    // Look one and two columns either way; step towards the lowest rest\n    // if it is 2 rows lower at one column or 3 at two.\n    let go = 0, low = ry;\n    for (const s of [-1, 1, -2, 2]) {\n      const nx = b.x + s;\n      if (nx \u003c 0 || nx > W - sp.w) continue;\n      const v = restY(surf, sp, nx);\n      if (v >= ry + 1 + abs(s) && v > low) (low = v), (go = s > 0 ? 1 : -1);\n    }\n    if (go) {\n      b.x += go;\n      b.y = ry;\n      b.vy *= 0.5;\n      continue;\n    }\n    Object.assign(b, { y: ry, vy: 0, mode: HEAP, landed: t });\n    for (let c = 0; c \u003c sp.w; c++) if (sp.top[c] >= 0) surf[b.x + c] = min(surf[b.x + c], ry + sp.top[c]);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const t = S.t, h = S.hue;\n  const cream = hsv(0.11 + h, 0.4, 0.95), slate = hsv(0.6 + h, 0.42, 0.8), mint = hsv(0.45 + h, 0.55, 1);\n  const buf = new Float32Array(W * H * 3);\n  const order = [LINE, SLIDE, LOOSE, HEAP, FALL, WAIT, DROP, JUMP];\n  for (const m of order)\n    for (const b of S.bodies) {\n      if (b.mode !== m || b.mode === WAIT) continue;\n      let c = cream, a = 1;\n      if (m === LOOSE) c = mix(cream, slate, cl(1 - (b.t0 - t) / CUE, 0, 1));\n      else if (m === FALL) c = slate;\n      else if (m === HEAP) {\n        const age = t - b.landed;\n        a = 1 - 0.45 * cl(age / 2, 0, 1);\n        if (age > LIFE) a *= cl(1 - (age - LIFE) / 2, 0, 1);\n        c = slate;\n      } else if (m === DROP || m === JUMP) c = mint;\n      else if (b.fresh && m === LINE) c = mix(mint, cream, cl((t - b.landed) / 1.5, 0, 1));\n      const sp = GL[b.ch][b.rot], bx = round(b.x), by = round(b.y);\n      for (let y = 0; y \u003c sp.h; y++) {\n        const py = by + y;\n        if (py \u003c 0 || py >= H) continue;\n        for (let x = 0; x \u003c sp.w; x++) {\n          const px = bx + x;\n          if (px \u003c 0 || px >= W || !sp.b[y * sp.w + x]) continue;\n          const p = (py * W + px) * 3;\n          buf[p] = c[0] * a, buf[p + 1] = c[1] * a, buf[p + 2] = c[2] * a;\n        }\n      }\n    }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p % W, floor(p / W), buf[p * 3] | 0, buf[p * 3 + 1] | 0, buf[p * 3 + 2] | 0);\n}\n","mastermind":"// ===== Patternflow pattern =====\n// Title:   Mastermind\n// Family:  algo\n// Idea:    All 1296 codes of four pegs in six colours stand as a 6 by 6 grid of 6 by 6 blocks at the top, and Knuth's minimax player plays real games on the board below: each guess splits the codes still possible into colours by the answer they would give, the answer comes, and every class but one fades out, so the grid empties to a single LED in at most five guesses.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Mastermind (Mordecai Meirowitz, 1970), minimax strategy (Donald E. Knuth, The Computer as Master Mind, 1976), expected size (Robert W. Irving, 1979), most parts (Barteld Kooi, 2005), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strategy=0..3, Codemaker=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the codes still possible are warm white, the six peg colours start from red, and the 14 answers each have their own colour.\n// Knob 2: Speed. Beats a second: 2 at 2, so one guess (search 1 beat, place 1, split 2, answer 1, fade 1.5) takes 3.25 s and a game about 17 s; 0.2 at 0.2, 3 at 3.\n// Knob 3: Strategy. How the codebreaker picks a guess from all 1296 codes. 0 Knuth's minimax: the guess whose largest answer class is smallest, 4.476 guesses a game over all 1296 secrets. 1 Irving's expected size: the smallest sum of squared class sizes, 4.395. 2 Kooi's most parts: the most answer classes, 4.373. Ties go to a code still possible, then the lowest. 3 A random code still possible, about 4.66. Turning it takes effect from the next guess.\n// Knob 4: Codemaker. 0 picks a secret at random and answers honestly. 1 cheats within the rules, behind a red shield: it keeps no secret and always gives the answer that leaves the most codes. Knuth's player still wins in 5 every time, Irving's in 5, Kooi's only in 6, the random one in 5 to 8.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\nconst mix = (a, b, u) => [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, a[2] + (b[2] - a[2]) * u];\n\n// ---- Codes. A code is four pegs in six colours, c = 216 p1 + 36 p2 + 6 p3 + p4,\n// so Knuth's 1122 is 7. The answer to guess g for secret s is b black pegs\n// (right colour, right place) and w white (right colour, wrong place), kept as\n// b * 5 + w. Of the 25 slots 14 occur; 3 black and 1 white cannot.\nconst N = 1296, DIG = new Uint8Array(N * 4), CNT = new Uint8Array(N * 6);\nfor (let c = 0; c \u003c N; c++)\n  for (let j = 0; j \u003c 4; j++) {\n    const d = floor(c / [216, 36, 6, 1][j]) % 6;\n    DIG[c * 4 + j] = d;\n    CNT[c * 6 + d]++;\n  }\nfunction answer(g, s) {\n  let b = 0, t = 0;\n  for (let j = 0; j \u003c 4; j++) if (DIG[g * 4 + j] === DIG[s * 4 + j]) b++;\n  for (let d = 0; d \u003c 6; d++) t += min(CNT[g * 6 + d], CNT[s * 6 + d]);\n  return b * 5 + t - b;\n}\nconst WIN = 20;\nconst ANS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 15, 20], CLS = new Int8Array(25).fill(-1);\nANS.forEach((a, i) => (CLS[a] = i));\n\n// The answer table, 1296 by 1296 bytes, built once on the first frame (about\n// 30 ms in Node, the only heavy frame): each guess's score is then |S| lookups.\nlet FB = null;\nfunction table() {\n  if (FB) return FB;\n  FB = new Uint8Array(N * N);\n  for (let g = 0; g \u003c N; g++)\n    for (let s = g; s \u003c N; s++) {\n      const a = answer(g, s);\n      FB[g * N + s] = a;\n      FB[s * N + g] = a;\n    }\n  return FB;\n}\n\n// ---- Strategies. Every guess is chosen over all 1296 codes, those already\n// ruled out too, by the sizes n_i of the classes it splits S into:\n// 0 Knuth (1976), the smallest largest n_i; 1 Irving (1979), the smallest\n// sum of n_i^2, which is the expected size of what is left; 2 Kooi (2005), the\n// most classes. Ties go to a code in S, then the lowest. 3 picks a random code\n// from S. Played offline against all 1296 secrets with this code: Knuth opens\n// 1122 and takes 5801 guesses, 4.476 a game, never more than 5 (1, 6, 62, 533\n// and 694 games of 1 to 5 guesses, as in Knuth's paper); Irving opens 1123,\n// 5696, 4.395, at most 6; Kooi opens 1123, 5668, 4.373, at most 6; random,\n// over ten seeds, 4.626 to 4.693 a game, at most 8.\nconst counts = new Int32Array(25);\nfunction score(strat, g, S, n) {\n  counts.fill(0);\n  const row = g * N;\n  for (let i = 0; i \u003c n; i++) counts[FB[row + S[i]]]++;\n  let v = 0;\n  if (strat === 0) for (let a = 0; a \u003c 25; a++) v = max(v, counts[a]);\n  else if (strat === 1) for (let a = 0; a \u003c 25; a++) v += counts[a] * counts[a];\n  else for (let a = 0; a \u003c 25; a++) v -= counts[a] > 0;\n  return v;\n}\n// The first guess of a game sees all 1296 codes, so it and its scores are the\n// same every game: kept after the first search.\nconst FIRST = [null, null, null];\n\n// A search in progress: the candidates are scored in slices of about 120,000\n// lookups a frame, half a millisecond in Node, so the first guess of a game\n// (1296 x 1296) spreads over 14 frames, inside its one beat at Speed 2.\nfunction search(strat) {\n  return { strat, g: 0, best: -1, bs: 0, bin: false, done: false, sc: new Float32Array(N) };\n}\nfunction step(G, q, budget) {\n  if (q.done) return;\n  const S = G.S, n = G.n;\n  if (q.strat === 3) {\n    q.best = S[floor(Math.random() * n)];\n    q.g = N;\n    q.done = true;\n    return;\n  }\n  if (n === N && FIRST[q.strat]) {\n    const f = FIRST[q.strat];\n    q.best = f.best;\n    q.bs = f.bs;\n    q.sc = f.sc;\n    q.g = N;\n    q.done = true;\n    return;\n  }\n  let work = 0;\n  while (q.g \u003c N && work \u003c budget) {\n    const g = q.g++, v = score(q.strat, g, S, n), inS = G.inS[g] === 1;\n    q.sc[g] = v;\n    if (q.best \u003c 0 || v \u003c q.bs || (v === q.bs && inS && !q.bin)) {\n      q.best = g;\n      q.bs = v;\n      q.bin = inS;\n    }\n    work += n;\n  }\n  if (q.g >= N) {\n    q.done = true;\n    if (n === N) FIRST[q.strat] = q;\n  }\n}\n\n// The codemaker. Honest: the answer for the secret. Cheating: the answer with\n// the most codes of S behind it, a random one of those on a tie, and 4 black\n// only once S is that one code. It never has to commit, since every answer it\n// gives fits some code still in S. Against it, in Node: Knuth 5 guesses and\n// Irving 5 in every one of 300 games, Kooi 6 in every one, random 5 to 8,\n// 6.25 on average over 2,000.\nfunction reply(G, g, adv) {\n  if (!adv) return FB[g * N + G.secret];\n  counts.fill(0);\n  for (let i = 0; i \u003c G.n; i++) counts[FB[g * N + G.S[i]]]++;\n  if (G.n === 1 && counts[WIN]) return WIN;\n  let top = 0, k = 0, pick = WIN;\n  for (let a = 0; a \u003c WIN; a++) top = max(top, counts[a]);\n  for (let a = 0; a \u003c WIN; a++) if (counts[a] === top && Math.random() * ++k \u003c 1) pick = a;\n  return pick;\n}\n\nfunction newGame(S) {\n  const G = {\n    secret: floor(Math.random() * N), S: new Int16Array(N), n: N, inS: new Uint8Array(N).fill(1),\n    rows: [], phase: \"choose\", ph: 0, q: null, g: -1, ans: -1,\n  };\n  for (let i = 0; i \u003c N; i++) G.S[i] = i;\n  G.q = search(S.strat);\n  return G;\n}\n// Keep the codes of S that give answer a to guess g.\nfunction cut(G, g, a) {\n  let m = 0;\n  for (let i = 0; i \u003c G.n; i++) {\n    const s = G.S[i];\n    if (FB[g * N + s] === a) G.S[m++] = s;\n    else G.inS[s] = 0;\n  }\n  G.n = m;\n}\nfunction settle(S, G) {\n  // The secret a cheating codemaker ends up with is the last code standing.\n  if (S.adv && G.n >= 1) G.secret = G.S[0];\n  G.rows.push({ g: G.g, ans: G.ans, rem: G.n });\n}\n\n// ---- Timing, in beats (Speed beats a second): search at least 1, place 1,\n// split 2, answer 1, fade 1.5; a solved board stays 3 beats, then 1.5 to clear.\nconst T = { choose: 1, place: 1, split: 2, answer: 1, fade: 1.5, reveal: 3, clear: 1.5 };\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, speed: 2, strat: 0, adv: 0, G: null, rgb: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.strat = cl(round(k[2]), 0, 3);\n  const adv = cl(round(k[3]), 0, 1);\n  table();\n  if (!S.G) {\n    // Open on a game in progress: the first guess is on the board and the\n    // 1296 codes are splitting by the answer they would give it.\n    S.adv = adv;\n    const G = (S.G = newGame(S));\n    while (!G.q.done) step(G, G.q, 1e9);\n    G.g = G.q.best;\n    G.ans = reply(G, G.g, adv);\n    G.phase = \"split\";\n  }\n  let G = S.G;\n  // Never left with no code standing; a fresh game if it ever were.\n  if (G.n === 0) G = S.G = newGame(S);\n  if (adv !== S.adv) {\n    S.adv = adv;\n    // An honest codemaker taking over needs a secret that fits every answer,\n    // the one on its way to the board too.\n    if (!adv) {\n      const fits = [];\n      for (let i = 0; i \u003c G.n; i++) if (G.phase === \"choose\" || FB[G.g * N + G.S[i]] === G.ans) fits.push(G.S[i]);\n      if (fits.length) G.secret = fits[floor(Math.random() * fits.length)];\n    }\n  }\n  if (G.phase === \"choose\" && G.q && G.q.strat !== S.strat && !G.q.done) G.q = search(S.strat);\n  if (G.phase === \"choose\") step(G, G.q, 120000);\n  G.ph += d * S.speed;\n  const end = T[G.phase];\n  if (G.ph \u003c end) return;\n  if (G.phase === \"choose\") {\n    if (!G.q.done) return;\n    G.g = G.q.best;\n    G.ans = reply(G, G.g, S.adv);\n    G.phase = \"place\";\n  } else if (G.phase === \"place\") G.phase = \"split\";\n  else if (G.phase === \"split\") G.phase = \"answer\";\n  else if (G.phase === \"answer\") G.phase = \"fade\";\n  else if (G.phase === \"fade\") {\n    cut(G, G.g, G.ans);\n    settle(S, G);\n    if (G.ans === WIN) G.phase = \"reveal\";\n    else {\n      G.phase = \"choose\";\n      G.q = search(S.strat);\n    }\n  } else if (G.phase === \"reveal\") G.phase = \"clear\";\n  else if (G.phase === \"clear\") {\n    S.G = newGame(S);\n    return;\n  }\n  G.ph = 0;\n}\n\n// ---- Layout. The grid: block row p1, block column p2, and inside a block row\n// p3 and column p4, one LED a code, blocks 6 LEDs with 3 dark between: 51 by\n// 51 at x 9, y 3. Bars of p1's colour run down the left, p2's along the top.\n// The board below, played from the near end as on a real one: the first\n// guess at the bottom (y 122), up to eight every 8 rows, each four 6 by 6\n// pegs, the key pegs in a 2 by 2 square and, at the right edge, how many\n// codes the answer left. The secret sits behind its shield at the far end,\n// y 57. A random player can need 8 guesses; Knuth's never more than 5.\nconst GX = 9, GY = 3, BP = 9, SY = 57, RY = 122, RP = 8, ROWS = 8, PX = 4, KX = 37;\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n};\nconst gx = (c) => GX + (floor(c / 36) % 6) * BP + (c % 6);\nconst gy = (c) => GY + floor(c / 216) * BP + (floor(c / 6) % 6);\n\nfunction put(rgb, x, y, c, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  rgb[p] += c[0] * v, rgb[p + 1] += c[1] * v, rgb[p + 2] += c[2] * v;\n}\nfunction peg(rgb, x, y, c, v) {\n  for (let j = 0; j \u003c 6; j++)\n    for (let i = 0; i \u003c 6; i++) {\n      const corner = (i === 0 || i === 5) && (j === 0 || j === 5);\n      put(rgb, x + i, y + j, c, corner ? v * 0.3 : v);\n    }\n}\nfunction number(rgb, n, xr, y, c, v) {\n  const s = String(n);\n  for (let i = 0; i \u003c s.length; i++) {\n    const g = GLYPH[s[s.length - 1 - i]], x = xr - 3 - 4 * i;\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") put(rgb, x + q, y + r, c, v);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.G) return;\n  const G = S.G, rgb = S.rgb, hue = S.hue, ph = G.ph;\n  rgb.fill(0);\n  const tone = hsv(0.12 + hue, 0.22, 0.85), ghost = hsv(0.62 + hue, 0.45, 0.115), white = [1, 1, 1];\n  const pegs = [0, 1, 2, 3, 4, 5].map((i) => hsv(0.02 + hue + i / 6, 0.85, 1));\n  const cls = ANS.map((a, i) => hsv(0.55 + hue + i * 0.382, 0.75, 1));\n  const kb = hsv(0.98 + hue, 0.8, 1), kw = hsv(0.6 + hue, 0.05, 1);\n  const live = G.phase === \"place\" || G.phase === \"split\" || G.phase === \"answer\" || G.phase === \"fade\";\n  const truth = live ? CLS[G.ans] : -1;\n\n  // The grid. While a guess is searched for, each code the search has scored\n  // shows how good a guess it would be: u is the best score so far over its\n  // own (for Kooi its parts over the most), and the LED runs from dim blue to\n  // gold as u^5, so only guesses near the best shine. When 1122 gets one white\n  // peg and leaves 256 codes, Knuth's best is a largest class of 44, met by 48\n  // codes, and half of all 1296 do no better than 57. The heat fades through\n  // the place beat.\n  const q = G.q, heat = (G.phase === \"choose\" || G.phase === \"place\") && q && q.strat \u003c 3;\n  const upto = G.phase === \"choose\" ? floor(min(ph / T.choose, q.g / N) * N) : N;\n  const keep = G.phase === \"place\" ? min(1, ph / 0.8) : 0;\n  for (let c = 0; c \u003c N; c++) {\n    let col;\n    if (!G.inS[c]) col = G.phase === \"clear\" ? mix(ghost, tone, min(1, ph / 1.2)) : ghost;\n    else if (G.phase === \"split\" || G.phase === \"answer\" || G.phase === \"fade\") {\n      const k = CLS[FB[G.g * N + c]], cc = cls[k];\n      if (G.phase === \"split\") col = mix(tone, cc, min(1, ph / 0.6));\n      else if (G.phase === \"answer\") col = k === truth ? mix(cc, white, 0.25 + 0.25 * sin(ph * PI * 4)) : cc;\n      else col = k === truth ? mix(cc, tone, min(1, ph / 1.2)) : mix(cc, ghost, min(1, ph / 1.2));\n    } else col = tone;\n    if (heat && c \u003c upto) {\n      const u = q.strat === 2 ? q.sc[c] / q.bs : q.bs / q.sc[c], u5 = u ** 5;\n      col = mix(hsv(0.62 + hue - 0.47 * u, 0.85 - 0.45 * u5, 0.14 + 0.86 * u5), col, keep);\n    }\n    put(rgb, gx(c), gy(c), col, 1);\n  }\n  for (let b = 0; b \u003c 6; b++) {\n    for (let j = 0; j \u003c 6; j++) {\n      put(rgb, 4, GY + b * BP + j, pegs[b], 0.5);\n      put(rgb, 5, GY + b * BP + j, pegs[b], 0.5);\n      put(rgb, GX + b * BP + j, 0, pegs[b], 0.5);\n    }\n  }\n  // The search front runs over all 1296 codes, ruled out or not, and the best\n  // guess so far shines. A random player rolls among S instead. Then the\n  // guess blinks until its answer is in.\n  if (G.phase === \"choose\" && q) {\n    if (q.strat \u003c 3) {\n      for (let i = 0; i \u003c 8; i++) if (upto - i >= 0 && upto - i \u003c N) put(rgb, gx(upto - i), gy(upto - i), white, 0.9 * (1 - i / 8));\n    } else for (let i = 0; i \u003c 6; i++) {\n      const c = G.S[floor(Math.random() * G.n)];\n      put(rgb, gx(c), gy(c), white, 0.8);\n    }\n    if (q.best >= 0 && upto > 60) put(rgb, gx(q.best), gy(q.best), white, 0.8);\n  } else if (live) put(rgb, gx(G.g), gy(G.g), white, 0.55 + 0.45 * sin(S.t * PI * 6));\n\n  // The board.\n  const fadeAll = G.phase === \"clear\" ? max(0, 1 - ph / 1.2) : 1;\n  const rows = G.rows.slice();\n  if (live) rows.push({ g: G.g, ans: G.ans, rem: -1, now: true });\n  const off = max(0, rows.length - ROWS);\n  for (let r = 0; r \u003c ROWS; r++) {\n    const y = RY - RP * r, R = rows[r + off];\n    if (!R) {\n      for (let j = 0; j \u003c 4; j++) for (let h = 0; h \u003c 4; h++) put(rgb, PX + 8 * j + 2 + (h & 1), y + 2 + (h >> 1), ghost, 1.3);\n      for (let h = 0; h \u003c 4; h++) put(rgb, KX + 3 * (h & 1), y + 3 * (h >> 1), ghost, 1.3);\n      continue;\n    }\n    // Pegs go in one by one through the place beat; keys through the answer.\n    const shown = R.now && G.phase === \"place\" ? floor(ph / 0.2) + 1 : 4;\n    for (let j = 0; j \u003c 4; j++) {\n      if (j \u003c shown) peg(rgb, PX + 8 * j, y, pegs[DIG[R.g * 4 + j]], 0.9 * fadeAll);\n      else for (let h = 0; h \u003c 4; h++) put(rgb, PX + 8 * j + 2 + (h & 1), y + 2 + (h >> 1), ghost, 1.3);\n    }\n    const keys = R.now ? (G.phase === \"answer\" ? min(4, floor(ph / 0.2)) : G.phase === \"fade\" ? 4 : 0) : 4;\n    const b = floor(R.ans / 5), w = R.ans % 5;\n    for (let h = 0; h \u003c 4; h++) {\n      const x = KX + 3 * (h & 1), yy = y + 3 * (h >> 1);\n      const kind = h \u003c keys ? (h \u003c b ? kb : h \u003c b + w ? kw : null) : null;\n      if (kind) for (let e = 0; e \u003c 4; e++) put(rgb, x + (e & 1), yy + (e >> 1), kind, fadeAll);\n      else put(rgb, x, yy, ghost, 1.3);\n    }\n    const rem = R.now ? (G.phase === \"fade\" && ph > 0.5 ? null : -1) : R.rem;\n    if (rem !== -1) number(rgb, rem === null ? countClass(G) : rem, 63, y + 1, tone, 0.75 * fadeAll);\n  }\n\n  // The secret: behind a hatched shield until it is found.\n  if (G.phase === \"reveal\" || G.phase === \"clear\") {\n    const open = G.phase === \"reveal\" ? min(1, ph / 0.5) : 1;\n    for (let j = 0; j \u003c 4; j++) peg(rgb, PX + 8 * j, SY, pegs[DIG[G.secret * 4 + j]], open * fadeAll);\n    if (G.phase === \"reveal\") put(rgb, gx(G.secret), gy(G.secret), white, 0.5 + 0.5 * sin(ph * PI * 3));\n  } else {\n    const sh = S.adv ? kb : ghost, v = S.adv ? 0.3 : 2.2;\n    for (let j = 0; j \u003c 6; j++) for (let x = PX; x \u003c PX + 30; x++) put(rgb, x, SY + j, sh, (x + j) % 4 === 0 ? v * 1.6 : v * 0.7);\n  }\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[p * 3], g = rgb[p * 3 + 1], b = rgb[p * 3 + 2];\n    if (r + g + b > 0) display.setPixel(p % W, floor(p / W), min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n\n// How many codes of S give the answer that came: shown as the fade runs.\nfunction countClass(G) {\n  let m = 0;\n  for (let i = 0; i \u003c G.n; i++) if (FB[G.g * N + G.S[i]] === G.ans) m++;\n  return m;\n}\n","platycosms":"// ===== Patternflow pattern =====\n// Title:   Platycosms\n// Family:  space\n// Idea:    You fly through a closed flat universe holding one three-armed jack, and every cube of space you look through shows a copy of it, turned by the gluing that brought you there: a quarter turn a step in the tetracosm, a half turn in the dicosm, the Hantzsche-Wendt screws in the didicosm, none in the 3-torus.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: flat 3-manifolds (Werner Nowacki, 1934; Walter Hantzsche and Hilmar Wendt, 1935), names after John Conway and Juan Pablo Rossetti (2003), the inside view after Jeffrey Weeks (The Shape of Space, 1985), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Space=0..3, Heading=0..1\n//\n// Knob 1: Hue. Turns the three arm colours round the wheel together: at 0 the long arm is green, the middle one azure and the short one pink, on a white hub.\n// Knob 2: Speed. How fast you fly: 0.44 cubes a second at 2, ten times slower at 0.2, half as fast again at 3.\n// Knob 3: Space. 0 the tetracosm, whose cube is glued top to bottom with a quarter turn; 1 the dicosm, glued with a half turn; 2 the didicosm, the Hantzsche-Wendt manifold, two cubes big, so only every other cube holds a copy, and each copy is turned a half turn about x, y or z or not at all; 3 the torocosm, the 3-torus, where every copy faces the same way.\n// Knob 4: Heading. The angle between your flight and the z axis, the axis of the turn, from 0 to 90 degrees. At the opening 0.06 you fly 5.4 degrees off it, so in the tetracosm each copy you pass is turned a quarter turn from the one before, one every 2.3 s; at 1 you fly along x, the copies in line ahead of you all face the same way, and each layer to your left and right is turned a quarter more.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst F = 60; // focal length in LEDs: 94 degrees of view top to bottom, 56 across\nconst FOG = 1.9; // brightness falls by e every 1.9 cubes\nconst TMAX = 5.5; // a ray gives up after 5.5 cubes, where the fog leaves 5%\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- The jack, in the fundamental cube [0,1]^3: a hub, three rods along\n// +x, +y and +z of lengths 0.27, 0.18 and 0.32, and a ball on each end. It\n// stays inside [0.265, 0.735]^3, and so does every copy in its own cube,\n// since all the gluings below turn or reflect about the cube's centre lines.\n// The slab |y| \u003c 0.265 (mod 1) never meets a copy, and the camera flies in it.\nconst HUB = [0.356, 0.356, 0.34], HR = 0.075, ROD = 0.028;\nconst ARM = [0.272, 0.176, 0.32], BALL = [0.06, 0.053, 0.066];\n\n// ---- The deck group. For a cube (i, j, k) of the lattice, deck() finds\n// the map g^-1 that takes it back onto the fundamental cube, a signed\n// permutation and a shift: p_ref[a] = SG[c][a] * q[SRC[c][a]] + TR[a], where\n// c is the returned rotation class, or -1 for a cube of the didicosm that\n// holds no copy. Classes: 0 none, 1..3 one to three quarter turns undone\n// about z, 4..6 the half turns about x, y and z of the didicosm.\nconst SRC = [[0, 1, 2], [1, 0, 2], [0, 1, 2], [1, 0, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]];\nconst SG = [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, -1, -1], [-1, 1, -1], [-1, -1, 1]];\nconst TR = [0, 0, 0];\nconst md = (a, n) => ((a % n) + n) % n;\n// Didicosm generators, scaled by 2 so they carry unit cubes to unit cubes:\n// alpha (x+1, 1-y, -z), beta (-x, y+1, 1-z), gamma (1-x, -y, z+1). Their\n// squares are the steps of 2 along x, y and z, and alpha beta gamma = 1.\n// The cube parity i+j+k is kept, so the copies sit on the even cubes only:\n// the manifold is two cubes big. Per parity class (i, j, k mod 2 as bits):\n// the coset's class, its shift s, and where it sends the cube (0, 0, 0).\nconst HW = [[0, [0, 0, 0], [0, 0, 0]], null, null, [5, [0, 1, 1], [-1, 1, 0]], null, [4, [1, 1, 0], [1, 0, -1]], [6, [1, 0, 1], [0, -1, 1]], null];\nfunction deck(m, i, j, k) {\n  if (m === 2) {\n    const e = HW[md(i, 2) | (md(j, 2) \u003c\u003c 1) | (md(k, 2) \u003c\u003c 2)];\n    if (!e) return -1;\n    const c = e[0], D = SG[c], s = e[1], h = e[2];\n    // g = T(v) h with v = cell - h(cube 0), so g^-1(q) = D (q - v - s).\n    TR[0] = -D[0] * (i - h[0] + s[0]); TR[1] = -D[1] * (j - h[1] + s[1]); TR[2] = -D[2] * (k - h[2] + s[2]);\n    return c;\n  }\n  TR[2] = -k;\n  // Tetracosm: a step up z turns a quarter about the cube's axis x = y = 1/2;\n  // dicosm a half; torocosm none. Undo k of them.\n  const r = m === 0 ? md(-k, 4) : m === 1 ? 2 * md(k, 2) : 0;\n  if (r === 0) { TR[0] = -i; TR[1] = -j; }\n  else if (r === 1) { TR[0] = j + 1; TR[1] = -i; }\n  else if (r === 2) { TR[0] = i + 1; TR[1] = j + 1; }\n  else { TR[0] = -j; TR[1] = i + 1; }\n  return r;\n}\n\n// ---- Drawing. The panel is a depth buffer: every copy within 5.5 cubes of\n// the camera is cut into four parts (the hub ball and the three arms, each\n// in its own box), each part's box is projected to the screen, clipped at\n// the camera plane, and only the LEDs inside that rectangle trace a ray\n// against the part, in the copy's own frame, keeping the nearest hit. About\n// 160 copies are in reach, and a frame takes about 1.2 ms in Node; tracing\n// every cube along every ray instead took 5 to 7 ms.\nconst N = W * H;\nconst DIR = new Float64Array(N * 3), DEPTH = new Float64Array(N), LAM = new Float64Array(N), PART = new Int8Array(N);\n// Part boxes in the fundamental cube: lo x y z, hi x y z.\nconst PB = [\n  [HUB[0] - HR, HUB[1] - HR, HUB[2] - HR, HUB[0] + HR, HUB[1] + HR, HUB[2] + HR],\n  [HUB[0], HUB[1] - BALL[0], HUB[2] - BALL[0], HUB[0] + ARM[0] + BALL[0], HUB[1] + BALL[0], HUB[2] + BALL[0]],\n  [HUB[0] - BALL[1], HUB[1], HUB[2] - BALL[1], HUB[0] + BALL[1], HUB[1] + ARM[1] + BALL[1], HUB[2] + BALL[1]],\n  [HUB[0] - BALL[2], HUB[1] - BALL[2], HUB[2], HUB[0] + BALL[2], HUB[1] + BALL[2], HUB[2] + ARM[2] + BALL[2]],\n];\nconst CAMP = new Float64Array(24), RECT = new Float64Array(4);\nconst NEAR = 0.01;\nfunction addPt(u, v, z) {\n  const sx = W / 2 + (F * u) / z, sy = H / 2 - (F * v) / z;\n  if (sx \u003c RECT[0]) RECT[0] = sx;\n  if (sx > RECT[1]) RECT[1] = sx;\n  if (sy \u003c RECT[2]) RECT[2] = sy;\n  if (sy > RECT[3]) RECT[3] = sy;\n}\n// The screen rectangle of box b of the copy whose map is class c, shift TR.\nfunction rect(S, b, c) {\n  const { cam, fw, rt, up } = S, src = SRC[c], sg = SG[c], bx = PB[b];\n  let front = 0;\n  for (let q = 0; q \u003c 8; q++) {\n    // p_ref -> world: q[SRC[a]] = SG[a] (p[a] - TR[a])\n    const p0 = sg[0] * (bx[q & 1 ? 3 : 0] - TR[0]), p1 = sg[1] * (bx[q & 2 ? 4 : 1] - TR[1]), p2 = sg[2] * (bx[q & 4 ? 5 : 2] - TR[2]);\n    const X = (src[0] === 0 ? p0 : p1) - cam[0], Y = (src[1] === 1 ? p1 : p0) - cam[1], Z = p2 - cam[2];\n    const z = X * fw[0] + Y * fw[1] + Z * fw[2];\n    CAMP[q * 3] = X * rt[0] + Y * rt[1] + Z * rt[2];\n    CAMP[q * 3 + 1] = X * up[0] + Y * up[1] + Z * up[2];\n    CAMP[q * 3 + 2] = z;\n    if (z >= NEAR) front++;\n  }\n  if (!front) return false;\n  RECT[0] = RECT[2] = 1e9; RECT[1] = RECT[3] = -1e9;\n  for (let q = 0; q \u003c 8; q++) if (CAMP[q * 3 + 2] >= NEAR) addPt(CAMP[q * 3], CAMP[q * 3 + 1], CAMP[q * 3 + 2]);\n  if (front \u003c 8)\n    for (let q = 0; q \u003c 8; q++)\n      for (let e = 1; e \u003c 8; e \u003c\u003c= 1) {\n        const r = q | e;\n        if (r === q) continue;\n        const za = CAMP[q * 3 + 2], zb = CAMP[r * 3 + 2];\n        if (za \u003c NEAR === zb \u003c NEAR) continue;\n        const f = (NEAR - za) / (zb - za);\n        addPt(CAMP[q * 3] + f * (CAMP[r * 3] - CAMP[q * 3]), CAMP[q * 3 + 1] + f * (CAMP[r * 3 + 1] - CAMP[q * 3 + 1]), NEAR);\n      }\n  return RECT[0] \u003c W && RECT[1] > 0 && RECT[2] \u003c H && RECT[3] > 0;\n}\n\n// Ray o + t d against a ball at the centre (cx, cy, cz).\nfunction ball(ox, oy, oz, dx, dy, dz, cx, cy, cz, r) {\n  const qx = ox - cx, qy = oy - cy, qz = oz - cz;\n  const b = qx * dx + qy * dy + qz * dz, disc = b * b - (qx * qx + qy * qy + qz * qz - r * r);\n  if (disc \u003c 0) return 1e9;\n  const t = -b - sqrt(disc);\n  return t > 1e-4 ? t : 1e9;\n}\n// Trace part b for the LEDs in RECT, in the copy's frame (class c, shift TR).\nfunction raster(S, b, c) {\n  const { cam } = S, src = SRC[c], sg = SG[c];\n  const s0 = src[0], s1 = src[1], g0 = sg[0], g1 = sg[1], g2 = sg[2];\n  const ox = g0 * cam[s0] + TR[0] - HUB[0], oy = g1 * cam[s1] + TR[1] - HUB[1], oz = g2 * cam[2] + TR[2] - HUB[2];\n  const x0 = max(0, floor(RECT[0])), x1 = min(W - 1, floor(RECT[1])), y0 = max(0, floor(RECT[2])), y1 = min(H - 1, floor(RECT[3]));\n  const L = b ? ARM[b - 1] : 0, w = b ? BALL[b - 1] : HR, R2 = ROD * ROD;\n  for (let py = y0; py \u003c= y1; py++)\n    for (let px = x0, p = py * W + x0; px \u003c= x1; px++, p++) {\n      const p3 = p * 3;\n      const dx = g0 * DIR[p3 + s0], dy = g1 * DIR[p3 + s1], dz = g2 * DIR[p3 + 2];\n      let best = DEPTH[p], nx = 0, ny = 0, nz = 0, hit = false;\n      // the ball: the hub, or the end of arm b\n      const ex = b === 1 ? L : 0, ey = b === 2 ? L : 0, ez = b === 3 ? L : 0;\n      let t = ball(ox, oy, oz, dx, dy, dz, ex, ey, ez, w);\n      if (t \u003c best) {\n        best = t; hit = true;\n        nx = (ox + t * dx - ex) / w; ny = (oy + t * dy - ey) / w; nz = (oz + t * dz - ez) / w;\n      }\n      if (b) {\n        // the rod round the arm's axis, from the hub to the ball\n        const up = b === 1 ? oy : ox, uq = b === 3 ? oy : oz, ua = b === 1 ? ox : b === 2 ? oy : oz;\n        const dp = b === 1 ? dy : dx, dq = b === 3 ? dy : dz, da = b === 1 ? dx : b === 2 ? dy : dz;\n        const A = dp * dp + dq * dq, B = up * dp + uq * dq, D = B * B - A * (up * up + uq * uq - R2);\n        if (D > 0) {\n          t = (-B - sqrt(D)) / A;\n          const s = ua + t * da;\n          if (t > 1e-4 && t \u003c best && s > 0 && s \u003c L) {\n            best = t; hit = true;\n            const np = (up + t * dp) / ROD, nq = (uq + t * dq) / ROD;\n            if (b === 1) { nx = 0; ny = np; nz = nq; } else if (b === 2) { nx = np; ny = 0; nz = nq; } else { nx = np; ny = nq; nz = 0; }\n          }\n        }\n      }\n      if (hit) {\n        DEPTH[p] = best; PART[p] = b;\n        LAM[p] = max(0, -(nx * dx + ny * dy + nz * dz));\n      }\n    }\n}\n\n// ---- The cube edges, faint lines of the lattice the copies sit in, as in\n// Weeks's Curved Spaces. Each edge line within 5.5 of the camera is clipped\n// at the camera plane and stepped one LED at a time on the screen, with the\n// distance found by perspective-correct interpolation, so a jack in front\n// hides it.\nconst EDGE = new Float32Array(N);\nfunction edge(S, ax, ay, az, bx, by, bz) {\n  const { cam, fw, rt, up } = S;\n  let X = ax - cam[0], Y = ay - cam[1], Z = az - cam[2];\n  let u0 = X * rt[0] + Y * rt[1] + Z * rt[2], v0 = X * up[0] + Y * up[1] + Z * up[2], z0 = X * fw[0] + Y * fw[1] + Z * fw[2];\n  X = bx - cam[0]; Y = by - cam[1]; Z = bz - cam[2];\n  let u1 = X * rt[0] + Y * rt[1] + Z * rt[2], v1 = X * up[0] + Y * up[1] + Z * up[2], z1 = X * fw[0] + Y * fw[1] + Z * fw[2];\n  if (z0 \u003c NEAR && z1 \u003c NEAR) return;\n  if (z0 \u003c NEAR) { const f = (NEAR - z0) / (z1 - z0); u0 += f * (u1 - u0); v0 += f * (v1 - v0); z0 = NEAR; }\n  else if (z1 \u003c NEAR) { const f = (NEAR - z1) / (z0 - z1); u1 += f * (u0 - u1); v1 += f * (v0 - v1); z1 = NEAR; }\n  const x0 = W / 2 + (F * u0) / z0, y0 = H / 2 - (F * v0) / z0, x1 = W / 2 + (F * u1) / z1, y1 = H / 2 - (F * v1) / z1;\n  if ((x0 \u003c 0 && x1 \u003c 0) || (x0 >= W && x1 >= W) || (y0 \u003c 0 && y1 \u003c 0) || (y0 >= H && y1 >= H)) return;\n  // walk only the part of the screen segment that lies on the panel\n  let s0 = 0, s1 = 1;\n  const dx = x1 - x0, dy = y1 - y0;\n  if (dx) { const a = (0 - x0) / dx, b = (W - x0) / dx; s0 = max(s0, min(a, b)); s1 = min(s1, max(a, b)); }\n  if (dy) { const a = (0 - y0) / dy, b = (H - y0) / dy; s0 = max(s0, min(a, b)); s1 = min(s1, max(a, b)); }\n  if (s0 >= s1) return;\n  const n = Math.ceil((s1 - s0) * sqrt(dx * dx + dy * dy) * 1.3) + 1;\n  for (let i = 0; i \u003c= n; i++) {\n    const sg = s0 + ((s1 - s0) * i) / n, px = floor(x0 + sg * dx), py = floor(y0 + sg * dy);\n    if (px \u003c 0 || py \u003c 0 || px >= W || py >= H) continue;\n    const w = (1 - sg) / z0 + sg / z1, lam = sg / z1 / w;\n    const uu = u0 + lam * (u1 - u0), vv = v0 + lam * (v1 - v0), zz = 1 / w;\n    const dist = sqrt(uu * uu + vv * vv + zz * zz), p = py * W + px;\n    if (dist \u003c DEPTH[p]) { const e = exp(-dist / FOG); if (e > EDGE[p]) EDGE[p] = e; }\n  }\n}\nfunction edges(S) {\n  const cam = S.cam, R = Math.ceil(TMAX);\n  EDGE.fill(0);\n  for (let ax = 0; ax \u003c 3; ax++) {\n    const a1 = (ax + 1) % 3, a2 = (ax + 2) % 3;\n    for (let b = floor(cam[a1]) - R; b \u003c= floor(cam[a1]) + R + 1; b++)\n      for (let c = floor(cam[a2]) - R; c \u003c= floor(cam[a2]) + R + 1; c++) {\n        const db = b - cam[a1], dc = c - cam[a2], d2 = db * db + dc * dc;\n        if (d2 >= TMAX * TMAX) continue;\n        const L = sqrt(TMAX * TMAX - d2), A = [0, 0, 0], B = [0, 0, 0];\n        A[ax] = cam[ax] - L; B[ax] = cam[ax] + L; A[a1] = B[a1] = b; A[a2] = B[a2] = c;\n        edge(S, A[0], A[1], A[2], B[0], B[1], B[2]);\n      }\n  }\n}\n\nexport function setup(params) {\n  params.s = { t: 0, s: 0, hue: 0, m: 0, head: 0.06, cam: [0.1, 0.1, 0.1], fw: [0, 0, 1], rt: [1, 0, 0], up: [0, 1, 0], col: new Float32Array(12) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  const speed = cl(kv[1], 0.2, 3);\n  S.m = cl(Math.round(kv[2]), 0, 3);\n  S.head = cl(kv[3], 0, 1);\n  S.t += d * speed / 2;\n  S.s += d * speed * 0.22;\n  // Flight in the plane y = 0.03, heading th off the z axis, looking 12.6\n  // degrees right of the flight and 9 up, the gaze swaying 9 degrees left\n  // and right and 6 up and down.\n  const th = S.head * PI / 2;\n  const cam = S.cam;\n  cam[0] = 0.04 + 0.03 * sin(S.t * 0.7) + S.s * sin(th);\n  cam[1] = 0.03 + 0.025 * sin(S.t * 0.53);\n  cam[2] = 0.1 + S.s * cos(th);\n  const yaw = th + 0.22 + 0.16 * sin(S.t * 0.41), pitch = 0.16 + 0.1 * sin(S.t * 0.29);\n  const fw = S.fw, rt = S.rt, up = S.up;\n  fw[0] = sin(yaw) * cos(pitch); fw[1] = sin(pitch); fw[2] = cos(yaw) * cos(pitch);\n  rt[0] = cos(yaw); rt[1] = 0; rt[2] = -sin(yaw);\n  up[0] = fw[1] * rt[2] - fw[2] * rt[1];\n  up[1] = fw[2] * rt[0] - fw[0] * rt[2];\n  up[2] = fw[0] * rt[1] - fw[1] * rt[0];\n  // hub white, then the x, y and z arms\n  const col = S.col;\n  col[0] = 0.95; col[1] = 0.93; col[2] = 0.88;\n  hsv(S.hue + 0.56, 0.8, 1, col, 3);\n  hsv(S.hue + 0.9, 0.7, 1, col, 6);\n  hsv(S.hue + 0.3, 0.85, 1, col, 9);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cam, fw, rt, up, col, m } = S;\n  for (let py = 0, p = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++, p++) {\n      const sx = (px + 0.5 - W / 2) / F, sy = (H / 2 - py - 0.5) / F;\n      const dx = fw[0] + rt[0] * sx + up[0] * sy, dy = fw[1] + rt[1] * sx + up[1] * sy, dz = fw[2] + rt[2] * sx + up[2] * sy;\n      const l = 1 / sqrt(dx * dx + dy * dy + dz * dz);\n      DIR[p * 3] = dx * l; DIR[p * 3 + 1] = dy * l; DIR[p * 3 + 2] = dz * l;\n    }\n  DEPTH.fill(TMAX);\n  const ci = floor(cam[0]), cj = floor(cam[1]), ck = floor(cam[2]), R = Math.ceil(TMAX) + 1, RR = (TMAX + 0.87) * (TMAX + 0.87);\n  for (let a = -R; a \u003c= R; a++)\n    for (let b = -R; b \u003c= R; b++)\n      for (let c = -R; c \u003c= R; c++) {\n        const i = ci + a, j = cj + b, k = ck + c;\n        const vx = i + 0.5 - cam[0], vy = j + 0.5 - cam[1], vz = k + 0.5 - cam[2];\n        if (vx * vx + vy * vy + vz * vz > RR || vx * fw[0] + vy * fw[1] + vz * fw[2] \u003c -0.87) continue;\n        const cls = deck(m, i, j, k);\n        if (cls \u003c 0) continue;\n        for (let part = 0; part \u003c 4; part++) if (rect(S, part, cls)) raster(S, part, cls);\n      }\n  edges(S);\n  for (let p = 0; p \u003c N; p++) {\n    const e = EDGE[p] * 0.3;\n    let r = e * 0.55, g = e * 0.7, b = e;\n    const t = DEPTH[p];\n    if (t \u003c TMAX) {\n      const lam = LAM[p], fog = exp(-t / FOG);\n      const sh = (0.28 + 0.72 * lam) * fog, spec = lam > 0.9 ? (lam - 0.9) * 4 * fog : 0;\n      const cc = PART[p] * 3;\n      r = col[cc] * sh + spec; g = col[cc + 1] * sh + spec; b = col[cc + 2] * sh + spec;\n    }\n    display.setPixel(p % W, (p / W) | 0, (255 * cl(r, 0, 1)) | 0, (255 * cl(g, 0, 1)) | 0, (255 * cl(b, 0, 1)) | 0);\n  }\n}\n","apollonius-problem":"// ===== Patternflow pattern =====\n// Title:   Problem of Apollonius\n// Family:  geometry\n// Idea:    Three white circles drift over the panel and the up to eight circles that touch all three are drawn round them, each coloured by which of the three it touches from inside and which from outside, with a bright point at every touch; when two white circles cross or one nests in another, the eight merge in pairs and fade to four or none, and come back when they part.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: problem of Apollonius (Apollonius of Perga, c. 200 BC; solved by François Viète, 1600), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pair=0..4, Size=-1..1\n//\n// Knob 1: Hue. Turns the eight colours round the wheel together. Opposite signatures sit opposite on the wheel: at 0 the circle touching all three from outside is gold and the one holding all three is blue.\n// Knob 2: Speed. How fast the white circles drift: at 2 each centre's x and y run on sines of 37 to 71 seconds and each radius breathes on 19 to 31, at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Pair. 0 shows all eight. 1 to 4 light one of the four sign systems: its two circles stay bright with a faint wash inside, the rest dim to a fifth, and a line runs through the two centres and the radical centre of the white circles, the white point every system's line passes through.\n// Knob 4: Size. Scales the white circles by 2 to this power: at -1 they are 2.7 to 7.7 LEDs in radius and all eight are there 91% of the time; at 0.06, where it opens, 5.6 to 16, and 61%; at 1 11 to 31, and 13%, the rest mostly four.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, q, p, p, t, v][i], [t, v, v, q, p, p][i], [p, p, t, v, v, q][i]];\n}\n\n// ---- The three given circles. Radius at Size 0, breathing 18% on period\n// rp; the centre's x swings across the panel's width and its y through its\n// own band, y0 +- ay, each on its own sine and kept a radius from the edge.\n// Periods in seconds at Speed 2.\nconst GIVEN = [\n  { r: 9, y0: 34, ay: 30, px: 47, py: 61, ph: [0.3, 1.9], rp: 23 },\n  { r: 13, y0: 64, ay: 36, px: 59, py: 43, ph: [2.2, 0.4], rp: 31 },\n  { r: 6.5, y0: 94, ay: 30, px: 37, py: 71, ph: [4.1, 3.3], rp: 19 },\n];\n\n// ---- Solving. Circle i is (xi, yi, ri). A circle (x, y, r) touching it\n// satisfies (x - xi)^2 + (y - yi)^2 = (r + si ri)^2, si = +1 outside it and -1\n// on the other side of its rim. Subtracting circle 1's equation from 2's and\n// 3's leaves two equations linear in x, y and r; two of the three unknowns are\n// solved as linear in the third (the one whose 2 by 2 is largest, so three\n// centres in a row do not break it) and put into circle 1's equation, which\n// leaves a quadratic. s1 is held at +1: a root with r \u003c 0 is the circle of\n// radius -r for the opposite signs, so four sign systems give up to eight.\n// The roots come back in order of r, and each system fills two slots.\n// Checked over 30 minutes at Speed 2 and each of Size -1, 0.06, 0.5 and 1:\n// the worst miss of a found circle against the three was 3.7e-9 LEDs, every\n// touch point lay within 4e-11 of both rims, and each system's two centres\n// stood in line with the radical centre to within 2e-12 radians.\n// The count is 8, 4 or 0 and nothing else: 400,000 random triples gave 8 when\n// no two cross or all three do, 4 when one or two pairs cross, 0 when one\n// circle sits inside another and the third outside it. Eight is not always\n// one of each signature: with the centres near a line a system's two roots\n// can both be positive, two circles of one signature and none of its\n// opposite. At the opening Size, of the frames with eight, 40% held all eight\n// signatures.\nfunction solve(C, k, out) {\n  const s = [1, k & 1 ? -1 : 1, k & 2 ? -1 : 1];\n  const K = (i) => C[i][0] * C[i][0] + C[i][1] * C[i][1] - C[i][2] * C[i][2];\n  const M = [1, 2].map((j) => [2 * (C[j][0] - C[0][0]), 2 * (C[j][1] - C[0][1]), 2 * (s[j] * C[j][2] - s[0] * C[0][2]), K(j) - K(0)]);\n  let best = -1, f = 0;\n  for (let g = 0; g \u003c 3; g++) {\n    const p = (g + 1) % 3, q = (g + 2) % 3, d = abs(M[0][p] * M[1][q] - M[1][p] * M[0][q]);\n    if (d > best) (best = d), (f = g);\n  }\n  const p = (f + 1) % 3, q = (f + 2) % 3, det = M[0][p] * M[1][q] - M[1][p] * M[0][q];\n  out.n = 0;\n  if (abs(det) \u003c 1e-9) return;\n  // u = U0 + U1 t, t the free unknown.\n  const U0 = [0, 0, 0], U1 = [0, 0, 0];\n  U1[f] = 1;\n  U0[p] = (M[1][q] * M[0][3] - M[0][q] * M[1][3]) / det;\n  U1[p] = (M[0][q] * M[1][f] - M[1][q] * M[0][f]) / det;\n  U0[q] = (M[0][p] * M[1][3] - M[1][p] * M[0][3]) / det;\n  U1[q] = (M[1][p] * M[0][f] - M[0][p] * M[1][f]) / det;\n  const ex = U0[0] - C[0][0], ey = U0[1] - C[0][1], er = U0[2] + C[0][2];\n  const A = U1[0] * U1[0] + U1[1] * U1[1] - U1[2] * U1[2];\n  const B = 2 * (ex * U1[0] + ey * U1[1] - er * U1[2]);\n  const Cc = ex * ex + ey * ey - er * er;\n  const roots = [];\n  if (abs(A) \u003c 1e-12 * (abs(B) + abs(Cc) + 1e-30)) {\n    if (abs(B) > 1e-30) roots.push(-Cc / B);\n  } else {\n    const disc = B * B - 4 * A * Cc;\n    if (disc \u003c 0) return;\n    const sq = sqrt(disc), qq = -0.5 * (B + (B \u003c 0 ? -sq : sq));\n    roots.push(qq / A);\n    if (qq !== 0) roots.push(Cc / qq);\n  }\n  const sol = roots.map((t) => [U0[0] + U1[0] * t, U0[1] + U1[1] * t, U0[2] + U1[2] * t]).filter((u) => isFinite(u[2]) && abs(u[2]) > 1e-9 && abs(u[2]) \u003c 1e9);\n  sol.sort((a, b) => a[2] - b[2]);\n  for (const u of sol) {\n    const r = u[2], sg = r > 0 ? 1 : -1;\n    // Signature: bit i set when the circle touches circle i from its inner side.\n    let sig = 0;\n    for (let i = 0; i \u003c 3; i++) if (s[i] * sg \u003c 0) sig |= 4 >> i;\n    out.c[out.n++] = { x: u[0], y: u[1], r: abs(r), sig };\n  }\n}\n\n// The worst miss of a found circle against the three it should touch, in\n// LEDs: the distance between centres against r + ri or |r - ri|.\nfunction miss(C, c) {\n  let worst = 0;\n  for (let i = 0; i \u003c 3; i++) {\n    const d = sqrt((c.x - C[i][0]) ** 2 + (c.y - C[i][1]) ** 2);\n    worst = max(worst, min(abs(d - (c.r + C[i][2])), abs(d - abs(c.r - C[i][2]))));\n  }\n  return worst;\n}\n\nexport function setup(params) {\n  params.s = {\n    // The clock starts 7 s in, where all eight stand for the next 17 s.\n    t: 7, hue: 0, pair: 0, size: 0,\n    // Eight slots, two to a sign system: the circle last seen and how lit it is.\n    slot: Array.from({ length: 8 }, () => ({ c: null, on: false, a: 0 })),\n    C: [[0, 0, 1], [0, 0, 1], [0, 0, 1]], rc: null, worst: 0, count: 0,\n    rgb: new Float32Array(W * H * 3), out: { n: 0, c: [null, null] },\n  };\n}\n\nfunction place(S) {\n  const sc = 2 ** S.size;\n  for (let i = 0; i \u003c 3; i++) {\n    const g = GIVEN[i], r = g.r * sc * (1 + 0.18 * sin((2 * PI * S.t) / g.rp + g.ph[0]));\n    const mx = W / 2 - r - 1, lo = max(r + 1, g.y0 - g.ay), hi = max(lo, min(H - 1 - r, g.y0 + g.ay));\n    S.C[i][0] = W / 2 + max(0, mx) * sin((2 * PI * S.t) / g.px + g.ph[0]);\n    S.C[i][1] = (lo + hi) / 2 + ((hi - lo) / 2) * sin((2 * PI * S.t) / g.py + g.ph[1]);\n    S.C[i][2] = r;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.pair = cl(round(k[2]), 0, 4);\n  S.size = cl(k[3], -1, 1);\n  S.t += d * cl(k[1], 0.2, 3) * 0.5;\n  place(S);\n  let count = 0;\n  for (let sys = 0; sys \u003c 4; sys++) {\n    solve(S.C, sys, S.out);\n    for (let j = 0; j \u003c 2; j++) {\n      const sl = S.slot[2 * sys + j];\n      // One root: the second slot is the circle that just became a line.\n      const c = S.out.n === 2 ? S.out.c[j] : S.out.n === 1 && j === 0 ? S.out.c[0] : null;\n      sl.on = !!c;\n      if (c) {\n        sl.c = c;\n        count++;\n        S.worst = max(S.worst, miss(S.C, c));\n      }\n      // Fades: in over 0.4 s, out over 0.7 s, whatever the Speed.\n      sl.a = sl.on ? min(1, sl.a + d / 0.4) : max(0, sl.a - d / 0.7);\n    }\n  }\n  S.count = count;\n  // The radical centre: the point with equal power to all three circles,\n  // where r = 0 on every system's line of centres.\n  const C = S.C, a1 = 2 * (C[1][0] - C[0][0]), b1 = 2 * (C[1][1] - C[0][1]), a2 = 2 * (C[2][0] - C[0][0]), b2 = 2 * (C[2][1] - C[0][1]);\n  const K = (i) => C[i][0] * C[i][0] + C[i][1] * C[i][1] - C[i][2] * C[i][2], dd = a1 * b2 - a2 * b1;\n  S.rc = abs(dd) > 1e-6 ? [((K(1) - K(0)) * b2 - (K(2) - K(0)) * b1) / dd, (a1 * (K(2) - K(0)) - a2 * (K(1) - K(0))) / dd] : null;\n}\n\n// ---- Drawing. Additive light into a float buffer.\nfunction put(rgb, px, py, c, v) {\n  if (px \u003c 0 || px >= W || py \u003c 0 || py >= H || v \u003c= 0) return;\n  const p = 3 * (py * W + px);\n  rgb[p] += c[0] * v, rgb[p + 1] += c[1] * v, rgb[p + 2] += c[2] * v;\n}\n\n// An anti-aliased ring 1 LED wide, clipped to the panel. Rows the circle\n// does not reach are skipped, and in each row only the columns near the two\n// crossings are visited.\nfunction ring(rgb, cx, cy, r, c, v) {\n  const y0 = max(0, floor(cy - r - 1)), y1 = min(H - 1, floor(cy + r + 1));\n  for (let py = y0; py \u003c= y1; py++) {\n    const dy = py + 0.5 - cy, ro = r + 1, ri = r - 1;\n    const xo = ro * ro - dy * dy;\n    if (xo \u003c 0) continue;\n    const wo = sqrt(xo), wi = ri > 0 && ri * ri - dy * dy > 0 ? sqrt(ri * ri - dy * dy) : 0;\n    for (const sgn of [-1, 1]) {\n      const a = sgn \u003c 0 ? cx - wo : cx + wi, b = sgn \u003c 0 ? cx - wi : cx + wo;\n      const xa = max(0, floor(a)), xb = min(W - 1, floor(b));\n      for (let px = xa; px \u003c= xb; px++) {\n        const dx = px + 0.5 - cx, e = abs(sqrt(dx * dx + dy * dy) - r);\n        if (e \u003c 1) put(rgb, px, py, c, v * (1 - e));\n      }\n    }\n  }\n}\n\nfunction dot(rgb, x, y, c, v, rad) {\n  for (let py = floor(y - rad - 1); py \u003c= floor(y + rad + 1); py++)\n    for (let px = floor(x - rad - 1); px \u003c= floor(x + rad + 1); px++) {\n      const e = sqrt((px + 0.5 - x) ** 2 + (py + 0.5 - y) ** 2);\n      if (e \u003c rad + 0.5) put(rgb, px, py, c, v * min(1, rad + 0.5 - e));\n    }\n}\n\nfunction disc(rgb, cx, cy, r, c, v) {\n  const y0 = max(0, floor(cy - r)), y1 = min(H - 1, floor(cy + r));\n  for (let py = y0; py \u003c= y1; py++) {\n    const dy = py + 0.5 - cy, w = r * r - dy * dy;\n    if (w \u003c= 0) continue;\n    const hw = sqrt(w), xa = max(0, floor(cx - hw + 0.5)), xb = min(W - 1, floor(cx + hw - 0.5));\n    for (let px = xa; px \u003c= xb; px++) put(rgb, px, py, c, v);\n  }\n}\n\nfunction line(rgb, x0, y0, x1, y1, c, v) {\n  const n = max(abs(x1 - x0), abs(y1 - y0)) | 0;\n  for (let i = 0; i \u003c= n; i++) {\n    const u = n ? i / n : 0;\n    put(rgb, floor(x0 + (x1 - x0) * u), floor(y0 + (y1 - y0) * u), c, v);\n  }\n}\n\n// Hue of a signature: the pair from one quadratic, sig and 7 - sig, opposite.\nconst SIGHUE = [0, 1, 2, 3, 7, 6, 5, 4];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.C) return;\n  const rgb = S.rgb, C = S.C;\n  rgb.fill(0);\n  const white = [1, 1, 1];\n\n  // A highlighted system: its line of centres, from edge to edge.\n  if (S.pair && S.rc) {\n    const a = S.slot[2 * (S.pair - 1)], b = S.slot[2 * (S.pair - 1) + 1], ends = [a, b].filter((q) => q.a > 0 && q.c);\n    const far = ends.length ? ends.reduce((u, q) => (abs(q.c.x - S.rc[0]) + abs(q.c.y - S.rc[1]) > abs(u.c.x - S.rc[0]) + abs(u.c.y - S.rc[1]) ? q : u)) : null;\n    if (far) {\n      let ux = far.c.x - S.rc[0], uy = far.c.y - S.rc[1];\n      const L = sqrt(ux * ux + uy * uy);\n      if (L > 1e-6) {\n        (ux /= L), (uy /= L);\n        line(rgb, S.rc[0] - ux * 300, S.rc[1] - uy * 300, S.rc[0] + ux * 300, S.rc[1] + uy * 300, white, 0.16);\n      }\n    }\n  }\n\n  // The solutions, then the given circles over them, then the touches.\n  const touch = [];\n  for (let q = 0; q \u003c 8; q++) {\n    const sl = S.slot[q];\n    if (sl.a \u003c= 0 || !sl.c) continue;\n    const c = sl.c, col = hsv(0.13 + S.hue + SIGHUE[c.sig] / 8, 0.78, 1);\n    const lit = S.pair && floor(q / 2) !== S.pair - 1 ? 0.2 : 1;\n    ring(rgb, c.x, c.y, c.r, col, 0.95 * sl.a * lit);\n    if (S.pair && lit === 1) {\n      // The lit pair: a faint wash inside each, and its centre.\n      disc(rgb, c.x, c.y, c.r, col, 0.11 * sl.a);\n      dot(rgb, c.x, c.y, col, 0.9 * sl.a, 0.7);\n    }\n    for (let i = 0; i \u003c 3; i++) {\n      const dx = C[i][0] - c.x, dy = C[i][1] - c.y, dd = sqrt(dx * dx + dy * dy);\n      if (dd \u003c 1e-9) continue;\n      // From the centre toward circle i, unless circle i holds this one.\n      const out = C[i][2] > c.r && dd \u003c C[i][2] ? -1 : 1;\n      touch.push([c.x + (out * c.r * dx) / dd, c.y + (out * c.r * dy) / dd, col, sl.a * lit]);\n    }\n  }\n  for (let i = 0; i \u003c 3; i++) ring(rgb, C[i][0], C[i][1], C[i][2], white, 0.62);\n  for (const [x, y, col, a] of touch) {\n    dot(rgb, x, y, col, 0.9 * a, 1.1);\n    dot(rgb, x, y, white, 0.8 * a, 0.45);\n  }\n  if (S.rc && S.pair) dot(rgb, S.rc[0], S.rc[1], white, 0.9, 0.8);\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[3 * p], g = rgb[3 * p + 1], b = rgb[3 * p + 2];\n    if (r + g + b > 0.004) display.setPixel(p % W, (p / W) | 0, min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n","sator-square":"// ===== Patternflow pattern =====\n// Title:   Sator Square\n// Family:  type\n// Idea:    The 25 letters of the word square found at Pompeii, cut in a stone tablet, are read by four lights at once (across, down, backwards and up, always standing on the same letter), then fly by the shortest matching to their places in Felix Grosser's Paternoster cross, which stands the full height of the panel with A and O at the four ends, hold while two lights read PATERNOSTER down and across to meet at the N, and fly home.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sator square (Pompeii, before AD 79; Dura-Europos), Paternoster cross (Felix Grosser, 1926), the assignment problem (Harold Kuhn, 1955), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Assign=0..2, Weather=0..1\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the letters glow gold and the four letters of the cross's ends, A and O, glow pale azure on grey stone.\n// Knob 2: Speed. One round of reading, flight, cross and flight home takes 14 s at 2, 9.3 s at 3 and 140 s at 0.2.\n// Knob 3: Assign. Which letter flies to which place of its kind. 0 is the matching with the least total travel, 537.6 LEDs for the 25 flights; 1 sends the k-th A of the square, read across, to the k-th A of the cross, read down and then across, 864.9 LEDs; 2 is the matching with the most travel, 1083.3 LEDs, so the flights cross over each other.\n// Knob 4: Weather. How long the tablet has stood out: at 0.06 the cuts are fresh; towards 1 the groove edges crumble and the stone pits and greys with lichen, and every letter keeps its own worn patches all through its flight.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, round, min, max, exp, sqrt, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters. Only eight are needed: S A T O R E P N. Three cuts of each:\n// 9 by 9 with 2 LED strokes for the tablet, 5 by 7 for the cross's upright,\n// 3 by 5 for its arm. The upright and the arm both need the same N, which\n// sits at the crossing in the 5 by 7 cut, so the 3 by 5 set has no N.\nconst BIG = {\n  S: [\".#######.\", \"##.....##\", \"##.......\", \"##.......\", \".#######.\", \".......##\", \".......##\", \"##.....##\", \".#######.\"],\n  A: [\"...###...\", \"..##.##..\", \"..##.##..\", \".##...##.\", \".##...##.\", \".#######.\", \"##.....##\", \"##.....##\", \"##.....##\"],\n  T: [\"#########\", \"#########\", \"...###...\", \"...###...\", \"...###...\", \"...###...\", \"...###...\", \"...###...\", \"...###...\"],\n  O: [\"..#####..\", \".##...##.\", \"##.....##\", \"##.....##\", \"##.....##\", \"##.....##\", \"##.....##\", \".##...##.\", \"..#####..\"],\n  R: [\"#######..\", \"##....##.\", \"##.....##\", \"##....##.\", \"#######..\", \"##..##...\", \"##...##..\", \"##....##.\", \"##.....##\"],\n  E: [\"#########\", \"##.......\", \"##.......\", \"##.......\", \"#######..\", \"##.......\", \"##.......\", \"##.......\", \"#########\"],\n  P: [\"#######..\", \"##....##.\", \"##.....##\", \"##....##.\", \"#######..\", \"##.......\", \"##.......\", \"##.......\", \"##.......\"],\n  N: [\"##.....##\", \"###....##\", \"####...##\", \"##.##..##\", \"##..##.##\", \"##...####\", \"##....###\", \"##.....##\", \"##.....##\"],\n};\nconst MID = {\n  A: [\".###.\", \"#...#\", \"#...#\", \"#####\", \"#...#\", \"#...#\", \"#...#\"],\n  P: [\"####.\", \"#...#\", \"#...#\", \"####.\", \"#....\", \"#....\", \"#....\"],\n  T: [\"#####\", \"..#..\", \"..#..\", \"..#..\", \"..#..\", \"..#..\", \"..#..\"],\n  E: [\"#####\", \"#....\", \"#....\", \"####.\", \"#....\", \"#....\", \"#####\"],\n  R: [\"####.\", \"#...#\", \"#...#\", \"####.\", \"#.#..\", \"#..#.\", \"#...#\"],\n  N: [\"#...#\", \"##..#\", \"#.#.#\", \"#..##\", \"#...#\", \"#...#\", \"#...#\"],\n  O: [\".###.\", \"#...#\", \"#...#\", \"#...#\", \"#...#\", \"#...#\", \".###.\"],\n  S: [\".####\", \"#....\", \"#....\", \".###.\", \"....#\", \"....#\", \"####.\"],\n};\nconst SMALL = {\n  A: [\".#.\", \"#.#\", \"###\", \"#.#\", \"#.#\"],\n  P: [\"##.\", \"#.#\", \"##.\", \"#..\", \"#..\"],\n  T: [\"###\", \".#.\", \".#.\", \".#.\", \".#.\"],\n  E: [\"###\", \"#..\", \"##.\", \"#..\", \"###\"],\n  R: [\"##.\", \"#.#\", \"##.\", \"#.#\", \"#.#\"],\n  O: [\".#.\", \"#.#\", \"#.#\", \"#.#\", \".#.\"],\n  S: [\".##\", \"#..\", \".#.\", \"..#\", \"##.\"],\n};\nconst bits = (set) => {\n  const o = {};\n  for (const k in set) o[k] = Uint8Array.from(set[k].join(\"\"), (c) => (c === \"#\" ? 1 : 0));\n  return o;\n};\nconst BIGB = bits(BIG), MIDB = bits(MID), SMALLB = bits(SMALL);\n\n// ---- The tablet. Rows SATOR AREPO TENET OPERA ROTAS read the same across\n// and down, and the same backwards: the square is left as it is by the half\n// turn and by reflection in either diagonal. Letters 9 by 9 on a 12 LED\n// pitch round (32.5, 64.5), on a slab 61 by 63 from (2, 33).\nconst SQUARE = [\"SATOR\", \"AREPO\", \"TENET\", \"OPERA\", \"ROTAS\"];\nconst SQ = [];\nfor (let r = 0; r \u003c 5; r++) for (let c = 0; c \u003c 5; c++) SQ.push({ ch: SQUARE[r][c], x: 32.5 + (c - 2) * 12, y: 64.5 + (r - 2) * 12 });\nconst SX0 = 2, SX1 = 63, SY0 = 33, SY1 = 96;\n\n// The four readings as paths over the 25 cells: across (rows left to\n// right), down (columns top to bottom), backwards (from the last letter) and\n// up (columns from the bottom right). Whatever step k the four lights are\n// on, they stand on the same letter; at k = 12 they meet on the N. A cell is\n// first lit at the least of its four indices, so every cell is lit by k = 12.\nconst PATHS = [(k) => k, (k) => (k % 5) * 5 + floor(k / 5), (k) => 24 - k, (k) => 24 - ((k % 5) * 5 + floor(k / 5))];\nconst FIRST = new Float32Array(25).fill(99);\nfor (const f of PATHS) for (let k = 0; k \u003c 25; k++) FIRST[f(k)] = min(FIRST[f(k)], k);\n\n// ---- Grosser's cross. A-PATERNOSTER-O down the middle, 13 letters 5 by 7\n// on rows 128/13 apart, so it stands the whole height; the same 13 across\n// row 64 in the 3 by 5 cut on a 5 LED pitch, sharing the N. 21 letters make\n// PATERNOSTER twice; the A and O left over (alpha and omega) end the arms.\nconst CROSS = \"APATERNOSTERO\";\nconst SLOT = [];\nfor (let j = 0; j \u003c 13; j++) SLOT.push({ ch: CROSS[j], x: 32.5, y: floor(((j + 0.5) * H) / 13) + 0.5, w: 5, h: 7, bm: MIDB, k: j, ao: j === 0 || j === 12 });\nfor (let i = 0; i \u003c 13; i++)\n  if (i !== 6) SLOT.push({ ch: CROSS[i], x: i \u003c 6 ? 27.5 - 5 * (5 - i) : 37.5 + 5 * (i - 7), y: 64.5, w: 3, h: 5, bm: SMALLB, k: i, ao: i === 0 || i === 12 });\n\n// The count, checked here so the cross can never be built from letters the\n// square does not have: square S2 A4 T4 O4 R4 E4 P2 N1; PATERNOSTER twice\n// with one N is P2 A2 T4 E4 R4 N1 O2 S2, 21 letters, and A2 O2 are left.\n{\n  const n = {};\n  for (const q of SQ) n[q.ch] = (n[q.ch] || 0) + 1;\n  for (const s of SLOT) n[s.ch]--;\n  for (const k in n) if (n[k] !== 0) throw new Error(\"Sator count is off at \" + k);\n}\n\n// ---- Which letter goes to which place of its kind. Up to four of a kind,\n// so every permutation is tried (24 at most). Totals of the 25 straight\n// distances, centre to centre: least 537.6 LEDs, reading order 864.9, most\n// 1083.3.\nfunction perms(n) {\n  if (n === 1) return [[0]];\n  const out = [];\n  for (const p of perms(n - 1)) for (let i = 0; i \u003c n; i++) out.push([...p.slice(0, i), n - 1, ...p.slice(i)]);\n  return out;\n}\nconst dist = (q, s) => sqrt((SQ[q].x - SLOT[s].x) ** 2 + (SQ[q].y - SLOT[s].y) ** 2);\nconst ASSIGN = [0, 1, 2].map((mode) => {\n  const a = new Int8Array(25);\n  for (const ch of \"SATORENP\") {\n    const from = [], to = [];\n    SQ.forEach((q, i) => q.ch === ch && from.push(i));\n    SLOT.forEach((s, i) => s.ch === ch && to.push(i));\n    if (mode === 1) {\n      from.forEach((q, i) => (a[q] = to[i]));\n      continue;\n    }\n    let best = null, bv = mode === 0 ? 1e9 : -1;\n    for (const p of perms(from.length)) {\n      let v = 0;\n      p.forEach((j, i) => (v += dist(from[i], to[j])));\n      if (mode === 0 ? v \u003c bv : v > bv) (bv = v), (best = p);\n    }\n    best.forEach((j, i) => (a[from[i]] = to[j]));\n  }\n  return a;\n});\n\n// ---- Time, in seconds at Speed 2. The tablet 5 s (lights read from 0.6 s,\n// 6.25 letters a second), out 2 s, the cross 5 s (read from 0.5 s, 5.2\n// letters a second), home 2 s. Each flight takes 1 s and starts 0.04 s after\n// the one before it in reading order. A fresh start comes in 3.4 s into the\n// tablet, at reading step 17.5, so the cross is up within 2.2 s.\nconst T_SQ = 5, T_OUT = 2, T_CR = 5, T_BACK = 2, CYCLE = T_SQ + T_OUT + T_CR + T_BACK;\nconst READ0 = 0.6, READ_RATE = 6.25, CREAD0 = 0.5, CREAD_RATE = 5.2, FLY = 1, STAG = 0.04, START = 3.4;\n\n// ---- Stone: grain, pits and lichen, fixed for the tablet.\nfunction hash(x, y, s) {\n  let h = (x * 374761393 + y * 668265263 + s * 2147483647) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nfunction vnoise(x, y, sc, s) {\n  const fx = x / sc, fy = y / sc, ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  const sx = ax * ax * (3 - 2 * ax), sy = ay * ay * (3 - 2 * ay);\n  const a = hash(ix, iy, s), b = hash(ix + 1, iy, s), c = hash(ix, iy + 1, s), d = hash(ix + 1, iy + 1, s);\n  return (a + (b - a) * sx) * (1 - sy) + (c + (d - c) * sx) * sy;\n}\nconst GRAIN = new Float32Array(NP), PIT = new Float32Array(NP), LICH = new Float32Array(NP), CHIP = new Float32Array(NP);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x;\n    GRAIN[p] = 0.55 * hash(x, y, 1) + 0.45 * vnoise(x, y, 5, 2) - 0.5;\n    PIT[p] = hash(x, y, 3);\n    LICH[p] = 0.65 * vnoise(x, y, 7, 4) + 0.35 * vnoise(x, y, 2.5, 5);\n    CHIP[p] = hash(x, y, 6);\n  }\n// Carved grooves of the 25 cells, lit from the upper left: the wall under\n// an upper or left edge faces away from the light, the wall above a lower\n// or right edge faces it. 0 stone, 1 shadow wall, 2 lit wall, 3 floor.\nconst CUT = new Uint8Array(NP), NEAR = new Uint8Array(NP);\nfor (const q of SQ) {\n  const bm = BIGB[q.ch], x0 = round(q.x - 4.5), y0 = round(q.y - 4.5);\n  const m = (i, j) => (i \u003c 0 || j \u003c 0 || i > 8 || j > 8 ? 0 : bm[j * 9 + i]);\n  for (let j = 0; j \u003c 9; j++)\n    for (let i = 0; i \u003c 9; i++) {\n      const p = (y0 + j) * W + x0 + i;\n      if (!m(i, j)) {\n        if (m(i - 1, j) || m(i, j - 1) || m(i + 1, j) || m(i, j + 1)) NEAR[p] = 1;\n        continue;\n      }\n      const ul = !m(i - 1, j) || !m(i, j - 1) || !m(i - 1, j - 1), lr = !m(i + 1, j) || !m(i, j + 1) || !m(i + 1, j + 1);\n      CUT[p] = ul && !lr ? 1 : lr && !ul ? 2 : 3;\n    }\n}\n\nexport function setup(params) {\n  params.s = {\n    tau: START, hue: 0, speed: 2, mode: 0, wx: 0.06, dt: 0,\n    lr: new Float32Array(NP), lg: new Float32Array(NP), lb: new Float32Array(NP),\n    tr: new Float32Array(NP), tg: new Float32Array(NP), tb: new Float32Array(NP), tmp: new Float32Array(NP),\n    rgb: new Float32Array(NP * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.mode = cl(round(k[2]), 0, 2);\n  S.wx = cl(k[3], 0, 1);\n  S.tau += (d * S.speed) / 2;\n  S.dt = d;\n}\n\n// Bilinear sample of a bitmap at bitmap coordinates.\nfunction samp(bm, bw, bh, fx, fy) {\n  const ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy;\n  let v = 0;\n  if (iy >= 0 && iy \u003c bh) {\n    if (ix >= 0 && ix \u003c bw) v += bm[iy * bw + ix] * (1 - ax) * (1 - ay);\n    if (ix + 1 >= 0 && ix + 1 \u003c bw) v += bm[iy * bw + ix + 1] * ax * (1 - ay);\n  }\n  if (iy + 1 >= 0 && iy + 1 \u003c bh) {\n    if (ix >= 0 && ix \u003c bw) v += bm[(iy + 1) * bw + ix] * (1 - ax) * ay;\n    if (ix + 1 >= 0 && ix + 1 \u003c bw) v += bm[(iy + 1) * bw + ix + 1] * ax * ay;\n  }\n  return v;\n}\n\n// One letter of light into the light buffer: the tablet cut, scaled to w by\n// h, fading into the cross cut by mix, worn by letter q's own patches.\nfunction letter(S, q, a, b, bw, bh, mix, cx, cy, w, h, col, inten, home) {\n  const x0 = max(0, floor(cx - w / 2)), x1 = min(W - 1, ceil(cx + w / 2) - 1);\n  const y0 = max(0, floor(cy - h / 2)), y1 = min(H - 1, ceil(cy + h / 2) - 1);\n  const wx = S.wx, sub = w \u003c 8.5 ? 2 : 1;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      let va = 0, vb = 0;\n      for (let sy = 0; sy \u003c sub; sy++)\n        for (let sx = 0; sx \u003c sub; sx++) {\n          const u = (x + (sx + 0.5) / sub - (cx - w / 2)) / w, v = (y + (sy + 0.5) / sub - (cy - h / 2)) / h;\n          if (mix \u003c 1) va += samp(a, 9, 9, u * 9 - 0.5, v * 9 - 0.5);\n          if (mix > 0) vb += samp(b, bw, bh, u * bw - 0.5, v * bh - 0.5);\n        }\n      let val = (va * (1 - mix) + vb * mix) / (sub * sub);\n      if (val \u003c 0.02) continue;\n      const u = (x + 0.5 - (cx - w / 2)) / w, v = (y + 0.5 - (cy - h / 2)) / h;\n      const n = vnoise(u * 4 + q * 7.3, v * 4, 1, 40 + q);\n      val *= 1 - 0.8 * wx * ss(0.3, 0.6, n);\n      val *= inten;\n      const p = y * W + x;\n      // At home the light lies in the groove: least on the wall in shadow.\n      if (home) val *= CUT[p] === 1 ? 0.5 : CUT[p] === 2 ? 1 : 0.78;\n      if (col[0] * val > S.lr[p]) S.lr[p] = col[0] * val;\n      if (col[1] * val > S.lg[p]) S.lg[p] = col[1] * val;\n      if (col[2] * val > S.lb[p]) S.lb[p] = col[2] * val;\n    }\n}\n\nfunction blur(src, tmp, out) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      tmp[p] = (6 * src[p] + 4 * ((x > 0 ? src[p - 1] : 0) + (x \u003c W - 1 ? src[p + 1] : 0)) + (x > 1 ? src[p - 2] : 0) + (x \u003c W - 2 ? src[p + 2] : 0)) / 16;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      out[p] = (6 * tmp[p] + 4 * ((y > 0 ? tmp[p - W] : 0) + (y \u003c H - 1 ? tmp[p + W] : 0)) + (y > 1 ? tmp[p - 2 * W] : 0) + (y \u003c H - 2 ? tmp[p + 2 * W] : 0)) / 16;\n    }\n}\n\nfunction spot(rgb, x, y, rad, a, col) {\n  const r = ceil(rad * 2.2);\n  for (let j = max(0, floor(y - r)); j \u003c= min(H - 1, ceil(y + r)); j++)\n    for (let i = max(0, floor(x - r)); i \u003c= min(W - 1, ceil(x + r)); i++) {\n      const dx = i + 0.5 - x, dy = j + 0.5 - y, v = a * exp(-(dx * dx + dy * dy) / (rad * rad));\n      const p = (j * W + i) * 3;\n      rgb[p] += col[0] * v, rgb[p + 1] += col[1] * v, rgb[p + 2] += col[2] * v;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, lr, lg, lb } = S, wx = S.wx, assign = ASSIGN[S.mode];\n  const tc = ((S.tau % CYCLE) + CYCLE) % CYCLE;\n  const gold = hsv(0.115 + S.hue, 0.6, 1), azure = hsv(0.55 + S.hue, 0.42, 1), warm = hsv(0.1 + S.hue, 0.25, 1);\n\n  // Where each letter is: p is its flight, 0 at home in the tablet, 1 in\n  // the cross.\n  const fly = new Float32Array(25);\n  let gone = 0;\n  for (let q = 0; q \u003c 25; q++) {\n    let p = 0;\n    if (tc >= T_SQ && tc \u003c T_SQ + T_OUT) p = ss(0, 1, (tc - T_SQ - STAG * q) / FLY);\n    else if (tc >= T_SQ + T_OUT && tc \u003c T_SQ + T_OUT + T_CR) p = 1;\n    else if (tc >= T_SQ + T_OUT + T_CR) p = 1 - ss(0, 1, (tc - T_SQ - T_OUT - T_CR - STAG * q) / FLY);\n    fly[q] = p;\n    gone += p / 25;\n  }\n\n  // ---- Stone, dimmed to 38% while the letters' light is away.\n  const dim = 1 - 0.62 * gone;\n  rgb.fill(0);\n  const stone = [0.82, 0.86, 0.93], moss = [0.72, 0.8, 0.55];\n  for (let y = SY0; y \u003c SY1; y++)\n    for (let x = SX0; x \u003c SX1; x++) {\n      const p = y * W + x;\n      let v = 62 * (1 + 0.32 * GRAIN[p]);\n      if (y === SY0 || x === SX0) v *= 1.45;\n      else if (y === SY1 - 1 || x === SX1 - 1) v *= 0.55;\n      const c = CUT[p];\n      if (c) {\n        const chip = CHIP[p] \u003c 0.45 * wx;\n        v *= chip ? 0.6 : c === 1 ? 0.3 : c === 2 ? 1.9 : 0.55;\n      } else if (NEAR[p] && CHIP[p] \u003c 0.4 * wx) v *= 0.45;\n      if (PIT[p] \u003c 0.1 * wx) v *= 0.35;\n      const l = ss(1 - 0.55 * wx, 1.05 - 0.55 * wx, LICH[p]) * min(1, wx * 2);\n      v *= dim;\n      const o = p * 3;\n      rgb[o] = v * (stone[0] + (moss[0] - stone[0]) * l);\n      rgb[o + 1] = v * (stone[1] + (moss[1] - stone[1]) * l);\n      rgb[o + 2] = v * (stone[2] + (moss[2] - stone[2]) * l);\n    }\n\n  // ---- The cross's own faint body of light, there as far as its letters\n  // have arrived: a band 8 LEDs wide down the middle and one across row 64.\n  const body = gone * gone * 34;\n  if (body > 0.5)\n    for (let y = 0; y \u003c H; y++) {\n      const by = exp(-(((y + 0.5 - 64.5) / 2.6) ** 2)), sh = 0.86 + 0.14 * sin(y * 0.35 - tc * 5);\n      for (let x = 0; x \u003c W; x++) {\n        const v = body * max(exp(-(((x + 0.5 - 32.5) / 4) ** 2)) * sh, by);\n        if (v \u003c 0.5) continue;\n        const o = (y * W + x) * 3;\n        rgb[o] += gold[0] * v, rgb[o + 1] += gold[1] * v, rgb[o + 2] += gold[2] * v;\n      }\n    }\n\n  // ---- Light. Trails fade in about 0.07 s.\n  const decay = exp(-S.dt / 0.07);\n  for (let p = 0; p \u003c NP; p++) (lr[p] *= decay), (lg[p] *= decay), (lb[p] *= decay);\n\n  const inSq = tc \u003c T_SQ, inCr = tc >= T_SQ + T_OUT && tc \u003c T_SQ + T_OUT + T_CR;\n  const step = (tc - READ0) * READ_RATE;\n  const cstep = (tc - T_SQ - T_OUT - CREAD0) * CREAD_RATE;\n  for (let q = 0; q \u003c 25; q++) {\n    const from = SQ[q], to = SLOT[assign[q]], p = fly[q];\n    let glow = 1;\n    if (inSq) glow = max(1 - ss(0, 0.6, tc), ss(FIRST[q], FIRST[q] + 1.2, step));\n    if (p \u003c= 0) {\n      letter(S, q, BIGB[from.ch], null, 9, 9, 0, from.x, from.y, 9, 9, gold, 0.1 + 0.72 * glow, true);\n      continue;\n    }\n    // A quadratic arc, bowed a fifth of its length to the left of the way\n    // out, so the 25 flights turn together.\n    const dx = to.x - from.x, dy = to.y - from.y, cx = (from.x + to.x) / 2 - 0.2 * dy, cy = (from.y + to.y) / 2 + 0.2 * dx;\n    const e = p, f = 1 - e;\n    const px = f * f * from.x + 2 * e * f * cx + e * e * to.x, py = f * f * from.y + 2 * e * f * cy + e * e * to.y;\n    const w = 9 + (to.w - 9) * e, h = 9 + (to.h - 9) * e;\n    const mix = ss(0.35, 0.8, e);\n    const ao = to.ao ? e : 0;\n    const col = [gold[0] + (azure[0] - gold[0]) * ao, gold[1] + (azure[1] - gold[1]) * ao, gold[2] + (azure[2] - gold[2]) * ao];\n    let inten = 0.95;\n    if (inCr) {\n      const fl = exp(-((cstep - to.k) ** 2) / 0.6);\n      inten = 0.78 + 0.4 * fl + (to.ao ? 0.14 * sin(tc * 3.1) : 0);\n    }\n    letter(S, q, BIGB[from.ch], to.bm[to.ch], to.w, to.h, mix, px, py, w, h, col, inten);\n  }\n\n  blur(lr, S.tmp, S.tr), blur(lg, S.tmp, S.tg), blur(lb, S.tmp, S.tb);\n  for (let p = 0; p \u003c NP; p++) {\n    const o = p * 3;\n    rgb[o] += 235 * lr[p] + 150 * S.tr[p];\n    rgb[o + 1] += 235 * lg[p] + 150 * S.tg[p];\n    rgb[o + 2] += 235 * lb[p] + 150 * S.tb[p];\n  }\n\n  // ---- The reading lights: four on the tablet, two on the cross.\n  if (inSq && step > -0.5 && step \u003c 25) {\n    const k = floor(step), fr = step - k;\n    for (const f of PATHS) {\n      const a = SQ[f(cl(k, 0, 24))], b = SQ[f(cl(k + 1, 0, 24))];\n      const sameLine = k >= 0 && k \u003c 24 && (k % 5 !== 4);\n      const m = sameLine ? ss(0.25, 0.75, fr) : 0;\n      const fade = (k \u003c 0 ? ss(-0.5, 0, step) : 1) * (sameLine || k >= 24 ? 1 : 1 - ss(0.55, 0.95, fr)) * (k > 0 && k % 5 === 0 ? ss(0, 0.2, fr) : 1);\n      spot(rgb, a.x + (b.x - a.x) * m, a.y + (b.y - a.y) * m, 4.2, 150 * fade, warm);\n    }\n  }\n  if (inCr && cstep > -0.5 && cstep \u003c 13) {\n    const k = floor(cstep), fr = cstep - k, m = ss(0.2, 0.8, fr);\n    const up = (j) => SLOT[cl(j, 0, 12)], arm = (i) => SLOT[i === 6 ? 6 : i \u003c 6 ? 13 + i : 12 + i];\n    const fade = ss(-0.5, 0, cstep) * (1 - ss(12.4, 13, cstep));\n    const a = up(k), b = up(k + 1);\n    spot(rgb, 32.5, a.y + (b.y - a.y) * m, 3.2, 110 * fade, warm);\n    const c = arm(cl(k, 0, 12)), d = arm(cl(k + 1, 0, 12));\n    spot(rgb, c.x + (d.x - c.x) * m, 64.5, 2.4, 110 * fade, warm);\n  }\n\n  for (let p = 0; p \u003c NP; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","tensegrity":"// ===== Patternflow pattern =====\n// Title:   Tensegrity\n// Family:  physics\n// Idea:    A tower of struts that never touch one another stands the height of the panel, held up by a net of cables in tension and turning slowly, and a weight on its top squeezes it shorter and twists it, because in a tensegrity compression and twist come together.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tensegrity (Kenneth Snelson, 1948; named by R. Buckminster Fuller), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Struts=3..6, Load=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the struts run from aqua at the foot to blue at the top, the cables are a dim pink and the weight is pale stone.\n// Knob 2: Speed. How fast the tower turns and how fast its own time runs: at 2 one turn in 16 seconds, at 0.2 one in 160 seconds with a plucked cable swinging in slow motion, at 3 one in 11 seconds.\n// Knob 3: Struts. Struts per stage, 3 to 6, five stages each time: 15 struts and 93 cables at 3, 30 and 186 at 6. Turning it builds the new tower and settles it before the next frame, which costs up to 7 ms.\n// Knob 4: Load. A weight on a guide up the axis, pressing on the top: 0 to 700 units, 42 at the start, which leaves the tower 1% shorter and its top turned 5.5 degrees. At 1 the 3-strut tower is 17% shorter and its top has turned 74 degrees further round; the 6-strut one 16% and 92.5 degrees.\n// Buttons: K1 tap plucks one of the longer cables on the near side: it swings as a string for two seconds at a pitch set by its tension, and if the tower is still its two ends are kicked so the whole tower shivers.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, atan2, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [[v, q, p, p, t, v][i], [t, v, v, q, p, p][i], [p, p, t, v, v, q][i]];\n}\n\n// ---- The tower. Stage k is a tensegrity prism: n struts from its bottom\n// n-gon to its top n-gon, strut i from bottom node i to top node i + 1, a\n// side cable from bottom node i to top node i, and a ring of cables round\n// each n-gon. The prism alone settles with its top turned pi/2 - pi/n against\n// its bottom along the side cables, so pi/2 + pi/n along the struts. Run on\n// its own with this code's springs from 20 or 70 degrees round, cables 10%\n// short, it came to 30.0000, 45.0000, 54.0000 and 60.0000 degrees for n = 3,\n// 4, 5 and 6 (from 5 degrees too for 3 and 4; 5 and 6 went slack from there).\n// Stages overlap by a quarter of their height: stage k + 1's bottom n-gon\n// sits below stage k's top one, turned pi/n so its nodes fall between, and\n// hangs from it by a zigzag of 2n saddle cables; bottom-to-bottom and\n// top-to-top cables between the two stages pull the other way. Stacked, the\n// stages twist less than a lone prism: 20 to 24 degrees for n = 3, 33 to 38\n// for 4, 41 to 46 for 5, 46 to 52 for 6. No two struts share a node, and the\n// closest two pass 8.4 units apart at n = 3, 3.4 at n = 6 (3.0 under Load 1).\n// Units: the bare tower stands 143 to 150 units tall and is drawn 121 LEDs.\nconst STAGES = 5, HS = 34, OV = 9, R0 = 24, R1 = 17;\nconst ALL = 0.08; // every cable 8% shorter than the span it is built on: the prestress\nconst EA = 1800; // cable stiffness: tension = EA * stretch / rest length\nconst FMAX = 700; // the weight at Load 1, shared out over the top nodes\nconst KICK = 40; // a pluck, units a second sideways at each end of the cable\nconst HSUB = 1 / 120; // physics step while it runs, seconds of the tower's own time\n\nfunction build(n) {\n  const P = [], fix = [], struts = [], cables = [], B = [], T = [], stage = [];\n  const alpha = PI / 2 - PI / n;\n  let phi = 0;\n  for (let k = 0; k \u003c STAGES; k++) {\n    const r = R0 + ((R1 - R0) * k) / (STAGES - 1), zb = k * (HS - OV), zt = zb + HS;\n    B.push([]);\n    T.push([]);\n    for (let i = 0; i \u003c n; i++) {\n      const a = phi + (2 * PI * i) / n;\n      B[k].push(P.length / 3);\n      P.push(r * cos(a), zb, r * sin(a));\n      fix.push(k === 0);\n    }\n    for (let i = 0; i \u003c n; i++) {\n      const a = phi + alpha + (2 * PI * i) / n;\n      T[k].push(P.length / 3);\n      P.push(r * cos(a), zt, r * sin(a));\n      fix.push(false);\n    }\n    for (let i = 0; i \u003c n; i++) {\n      struts.push(B[k][i], T[k][(i + 1) % n]);\n      stage.push(k);\n      cables.push(B[k][i], T[k][i]);\n      cables.push(B[k][i], B[k][(i + 1) % n], T[k][i], T[k][(i + 1) % n]);\n    }\n    phi += alpha + PI / n;\n  }\n  for (let k = 0; k + 1 \u003c STAGES; k++)\n    for (let j = 0; j \u003c n; j++) {\n      cables.push(B[k + 1][j], T[k][j], B[k + 1][j], T[k][(j + 1) % n]);\n      cables.push(B[k + 1][j], B[k][j], T[k][j], T[k + 1][j]);\n    }\n  const N = P.length / 3, x = Float64Array.from(P);\n  const len = (a, b) => sqrt((x[3 * a] - x[3 * b]) ** 2 + (x[3 * a + 1] - x[3 * b + 1]) ** 2 + (x[3 * a + 2] - x[3 * b + 2]) ** 2);\n  const SL = new Float64Array(struts.length / 2), CL = new Float64Array(cables.length / 2);\n  for (let q = 0; q \u003c SL.length; q++) SL[q] = len(struts[2 * q], struts[2 * q + 1]);\n  for (let q = 0; q \u003c CL.length; q++) CL[q] = len(cables[2 * q], cables[2 * q + 1]) * (1 - ALL);\n  return {\n    n, N, x, v: new Float64Array(3 * N), xp: new Float64Array(3 * N), f: new Float64Array(3 * N),\n    fix, struts, cables, SL, CL, ten: new Float64Array(CL.length), top: T[STAGES - 1], stage,\n  };\n}\n\n// One step: cables pull (tension only), the weight presses, velocities damp,\n// then the struts are put back to length, four passes.\nfunction step(m, load, damp, h) {\n  const { x, v, xp, f, cables, CL, ten, struts, SL, fix, N } = m;\n  f.fill(0);\n  const w = load / m.top.length;\n  for (const i of m.top) f[3 * i + 1] -= w;\n  for (let q = 0; q \u003c CL.length; q++) {\n    const a = 3 * cables[2 * q], b = 3 * cables[2 * q + 1];\n    const dx = x[b] - x[a], dy = x[b + 1] - x[a + 1], dz = x[b + 2] - x[a + 2], L = sqrt(dx * dx + dy * dy + dz * dz);\n    const t = L > CL[q] ? (EA * (L - CL[q])) / CL[q] : 0;\n    ten[q] = t;\n    if (!t) continue;\n    const s = t / L;\n    f[a] += dx * s, f[a + 1] += dy * s, f[a + 2] += dz * s;\n    f[b] -= dx * s, f[b + 1] -= dy * s, f[b + 2] -= dz * s;\n  }\n  const keep = 1 - damp * h;\n  for (let i = 0; i \u003c N; i++) {\n    if (fix[i]) continue;\n    for (let d = 3 * i; d \u003c 3 * i + 3; d++) {\n      xp[d] = x[d];\n      v[d] = (v[d] + h * f[d]) * keep;\n      x[d] += h * v[d];\n    }\n  }\n  for (let it = 0; it \u003c 4; it++)\n    for (let q = 0; q \u003c SL.length; q++) {\n      const ia = struts[2 * q], ib = struts[2 * q + 1], a = 3 * ia, b = 3 * ib;\n      const dx = x[b] - x[a], dy = x[b + 1] - x[a + 1], dz = x[b + 2] - x[a + 2], L = sqrt(dx * dx + dy * dy + dz * dz);\n      const wa = fix[ia] ? 0 : 1, wb = fix[ib] ? 0 : 1, e = (L - SL[q]) / L / (wa + wb);\n      x[a] += dx * e * wa, x[a + 1] += dy * e * wa, x[a + 2] += dz * e * wa;\n      x[b] -= dx * e * wb, x[b + 1] -= dy * e * wb, x[b + 2] -= dz * e * wb;\n    }\n  // The weight runs on a guide up the axis, so the top nodes' centre stays on\n  // it. Without the guide the tower bowed sideways and folded under 150 to\n  // 200 units, while only 5 units shorter; with it, 900 left every cable taut.\n  let gx = 0, gz = 0;\n  for (const i of m.top) (gx += x[3 * i] / m.top.length), (gz += x[3 * i + 2] / m.top.length);\n  for (const i of m.top) (x[3 * i] -= gx), (x[3 * i + 2] -= gz);\n  for (let i = 0; i \u003c N; i++) if (!fix[i]) for (let d = 3 * i; d \u003c 3 * i + 3; d++) v[d] = (x[d] - xp[d]) / h;\n}\n\n// Settling before the first frame: 1/30 s steps, damped near critical for\n// the tower's slowest sway, until no node moves 0.002 units in 50 steps.\n// The bare tower takes 600 to 650 steps, under its weight 400 to 1,300 more.\nfunction relax(m, load, damp) {\n  const was = Float64Array.from(m.x);\n  let s = 0;\n  for (; s \u003c 4000; s++) {\n    step(m, load, damp, 1 / 30);\n    if (s % 50 === 49) {\n      let moved = 0;\n      for (let d = 0; d \u003c was.length; d++) (moved = max(moved, abs(m.x[d] - was[d]))), (was[d] = m.x[d]);\n      if (moved \u003c 0.002) break;\n    }\n  }\n  m.v.fill(0);\n  return s + 1;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, turn: 0.6, n: 0, m: null, hue: 0, load: 0.06, lnow: 0.06, acc: 0, pl: -1, plT: -9,\n    span: [0, 1], rgb: new Float32Array(W * H * 3), z: new Float32Array(W * H), order: [],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), n = cl(round(k[2]), 3, 6);\n  S.load = cl(k[3], 0, 1);\n  if (n !== S.n) {\n    // A new tower: settle it bare to fix the scale, then under its weight,\n    // overdamped so it does not overshoot. At the start knobs the first frame\n    // runs 650 + 500 steps, 1.5 ms in Node.\n    S.n = n;\n    S.m = build(n);\n    S.steps = relax(S.m, 0, 1.2);\n    const x = S.m.x;\n    let lo = 1e9, hi = -1e9;\n    for (let i = 0; i \u003c S.m.N; i++) (lo = min(lo, x[3 * i + 1])), (hi = max(hi, x[3 * i + 1]));\n    S.span = [lo, hi];\n    S.lnow = S.load;\n    S.steps += relax(S.m, S.lnow * FMAX, 2.5);\n  }\n  const m = S.m;\n  if (input.btnPressed && input.btnPressed[0]) {\n    // Pluck one of the longer cables on the side facing the camera. Its ends\n    // are kicked apart only once the last pluck has died down: kicks every\n    // 0.3 s used to pump the tower until it folded.\n    const c = cos(S.turn), sn = sin(S.turn), pick = [];\n    let lmax = 0;\n    for (let q = 0; q \u003c m.CL.length; q++) lmax = max(lmax, m.CL[q]);\n    for (let q = 0; q \u003c m.CL.length; q++) {\n      const a = 3 * m.cables[2 * q], b = 3 * m.cables[2 * q + 1];\n      if (m.fix[a / 3] && m.fix[b / 3]) continue;\n      if ((m.x[a] + m.x[b]) * sn + (m.x[a + 2] + m.x[b + 2]) * c > 12 && m.CL[q] > 0.5 * lmax) pick.push(q);\n    }\n    const q = pick.length ? pick[floor(Math.random() * pick.length)] : 0;\n    const a = 3 * m.cables[2 * q], b = 3 * m.cables[2 * q + 1];\n    let ke = 0;\n    for (let j = 0; j \u003c m.v.length; j++) ke += m.v[j] * m.v[j];\n    const ux = m.x[b + 2] - m.x[a + 2], uz = m.x[a] - m.x[b], L = sqrt(ux * ux + uz * uz) || 1;\n    if (ke \u003c 0.5 * KICK * KICK)\n      for (const [j, sg] of [[a, 1], [b, -1]]) if (!m.fix[j / 3]) (m.v[j] += (sg * KICK * ux) / L), (m.v[j + 2] += (sg * KICK * uz) / L);\n    S.pl = q;\n    S.plT = S.t;\n  }\n  // The tower's own time; a turned Load knob reaches it over half a second.\n  const sim = d * speed * 0.5;\n  S.lnow += (S.load - S.lnow) * min(1, sim / 0.5);\n  S.t += sim;\n  S.turn += sim * ((2 * PI) / 16);\n  S.acc += sim;\n  for (let i = 0; S.acc >= HSUB && i \u003c 40; i++) {\n    step(m, S.lnow * FMAX, 1.2, HSUB);\n    S.acc -= HSUB;\n  }\n  if (S.acc > HSUB) S.acc = 0;\n}\n\n// ---- Drawing. Orthographic, the camera 10 degrees above the horizon, the\n// tower turning about its axis. Each LED keeps the depth of what it shows.\nconst TILT = 0.17, TC = cos(TILT), TS = sin(TILT);\n\n// A 1 LED line from (x0, y0) to (x1, y1), bowed sideways by bow LEDs at\n// its middle, each sample shared between the two LEDs it falls across.\nfunction cable(rgb, zb, x0, y0, z0, x1, y1, z1, bow, col, v) {\n  const ex = x1 - x0, ey = y1 - y0, L = sqrt(ex * ex + ey * ey) || 1, nx = -ey / L, ny = ex / L;\n  const along = abs(ex) >= abs(ey), steps = (max(abs(ex), abs(ey)) + abs(bow) * 2) | 0;\n  for (let i = 0; i \u003c= steps; i++) {\n    const u = steps ? i / steps : 0, o = bow * sin(PI * u);\n    const fx = x0 + ex * u + nx * o, fy = y0 + ey * u + ny * o, z = z0 + (z1 - z0) * u;\n    const g = along ? fy - 0.5 : fx - 0.5, g0 = floor(g), w1 = g - g0;\n    for (let e = 0; e \u003c 2; e++) {\n      const px = along ? floor(fx) : g0 + e, py = along ? g0 + e : floor(fy);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px, wv = (e ? w1 : 1 - w1) * v;\n      if (z > zb[p] - 0.8) continue;\n      for (let j = 0; j \u003c 3; j++) rgb[3 * p + j] = max(rgb[3 * p + j], col[j] * wv);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.m) return;\n  const m = S.m, x = m.x, rgb = S.rgb, zb = S.z, n = m.n;\n  rgb.fill(0);\n  zb.fill(1e9);\n  const scale = 121 / (S.span[1] - S.span[0]), yc = (S.span[0] + S.span[1]) / 2;\n  const c = cos(S.turn), s = sin(S.turn);\n  const N = m.N, sx = new Float32Array(N), sy = new Float32Array(N), sz = new Float32Array(N);\n  for (let i = 0; i \u003c N; i++) {\n    const X = x[3 * i] * c - x[3 * i + 2] * s, Z = x[3 * i] * s + x[3 * i + 2] * c, Y = x[3 * i + 1] - yc;\n    sx[i] = 32 + scale * X;\n    sy[i] = 64.5 - scale * (Y * TC - Z * TS);\n    sz[i] = -Z; // smaller is nearer\n  }\n\n  // The weight: a disc on the top nodes, its thickness growing with Load.\n  if (S.load > 0.001) {\n    let cx = 0, cy = 0, cz = 0, rr = 0;\n    for (const i of m.top) (cx += x[3 * i] / n), (cy += x[3 * i + 1] / n), (cz += x[3 * i + 2] / n);\n    for (const i of m.top) rr = max(rr, sqrt((x[3 * i] - cx) ** 2 + (x[3 * i + 2] - cz) ** 2));\n    const R = rr * 0.72, th = 1.5 + 9 * S.load, X0 = cx * c - cz * s, Z0 = cx * s + cz * c, Y0 = cy + 0.5 - yc;\n    const col = hsv(0.08 + S.hue, 0.18, 1);\n    // The guide the weight runs on, up the axis to the top edge.\n    const rx = round(32 + scale * X0 - 0.5);\n    for (let py = 0; py \u003c 64.5 - scale * ((Y0 + th) * TC - Z0 * TS); py++)\n      if (rx >= 0 && rx \u003c W) (rgb[3 * (py * W + rx)] = 0.3 * col[0]), (rgb[3 * (py * W + rx) + 1] = 0.3 * col[1]), (rgb[3 * (py * W + rx) + 2] = 0.3 * col[2]);\n    for (let py = 0; py \u003c 30; py++)\n      for (let px = 0; px \u003c W; px++) {\n        const X = (px + 0.5 - 32) / scale - X0;\n        if (abs(X) >= R) continue;\n        const hz = sqrt(R * R - X * X), up = (64.5 - (py + 0.5)) / scale;\n        // Top face: the point at height Y0 + th whose screen row this is.\n        const zt = ((Y0 + th) * TC - up) / TS - Z0;\n        let v = 0, depth = 0;\n        if (abs(zt) \u003c= hz) (v = 0.5 + 0.2 * (zt / hz)), (depth = -(Z0 + zt));\n        else {\n          const ys = (up + (Z0 + hz) * TS) / TC;\n          if (ys >= Y0 && ys \u003c= Y0 + th) (v = 0.3 + 0.18 * (hz / R)), (depth = -(Z0 + hz));\n        }\n        if (!v) continue;\n        const p = py * W + px;\n        zb[p] = depth;\n        rgb[3 * p] = col[0] * v, rgb[3 * p + 1] = col[1] * v, rgb[3 * p + 2] = col[2] * v;\n      }\n  }\n\n  // Struts, far ones first: a bar 2.4 LEDs across, brighter at the near end\n  // and down its middle, with a dark rim that cuts whatever passes behind.\n  const ns = m.SL.length, ord = S.order;\n  ord.length = ns;\n  for (let q = 0; q \u003c ns; q++) ord[q] = q;\n  const mid = (q) => sz[m.struts[2 * q]] + sz[m.struts[2 * q + 1]];\n  ord.sort((a, b) => mid(b) - mid(a));\n  const RAD = 1.2, HALO = 1.5, DEEP = R0 + 2;\n  for (const q of ord) {\n    const a = m.struts[2 * q], b = m.struts[2 * q + 1];\n    const x0 = sx[a], y0 = sy[a], x1 = sx[b], y1 = sy[b], z0 = sz[a], z1 = sz[b];\n    const ex = x1 - x0, ey = y1 - y0, ll = ex * ex + ey * ey || 1;\n    const col = hsv(0.47 + S.hue + 0.04 * m.stage[q], 0.62, 1);\n    const reach = RAD + HALO + 0.5;\n    const X0 = max(0, floor(min(x0, x1) - reach)), X1 = min(W - 1, floor(max(x0, x1) + reach));\n    const Y0 = max(0, floor(min(y0, y1) - reach)), Y1 = min(H - 1, floor(max(y0, y1) + reach));\n    for (let py = Y0; py \u003c= Y1; py++)\n      for (let px = X0; px \u003c= X1; px++) {\n        const u = cl(((px + 0.5 - x0) * ex + (py + 0.5 - y0) * ey) / ll, 0, 1);\n        const dx = px + 0.5 - x0 - ex * u, dy = py + 0.5 - y0 - ey * u, dd = sqrt(dx * dx + dy * dy);\n        if (dd > reach) continue;\n        const z = z0 + (z1 - z0) * u, p = py * W + px;\n        if (dd \u003c RAD + 0.5) {\n          if (z >= zb[p]) continue;\n          const cov = min(1, RAD + 0.5 - dd), lit = (0.42 + 0.58 * cl((DEEP - z) / (2 * DEEP), 0, 1)) * (1 - 0.35 * (dd / (RAD + 0.5)) ** 2);\n          for (let j = 0; j \u003c 3; j++) rgb[3 * p + j] = rgb[3 * p + j] * (1 - cov) + col[j] * lit * cov;\n          if (cov > 0.4) zb[p] = z;\n        } else if (z + 1.5 \u003c zb[p]) {\n          const k = 0.2 + 0.8 * min(1, (dd - RAD - 0.5) / HALO) ** 2;\n          for (let j = 0; j \u003c 3; j++) rgb[3 * p + j] *= k;\n          zb[p] = z + 1.5;\n        }\n      }\n  }\n\n  // Cables: 1 LED lines, brighter the harder they pull, hidden behind struts.\n  // A plucked one swings as a string for two seconds, at a pitch that goes\n  // with the square root of its tension over its length, its envelope dim.\n  const nc = m.CL.length, pc = hsv(0.92 + S.hue, 0.4, 1), fl = hsv(0.13 + S.hue, 0.3, 1);\n  let tmax = 1, tsum = 0, lsum = 0;\n  for (let q = 0; q \u003c nc; q++) (tmax = max(tmax, m.ten[q])), (tsum += m.ten[q]), (lsum += m.CL[q]);\n  const age = S.t - S.plT;\n  for (let q = 0; q \u003c nc; q++) {\n    const a = m.cables[2 * q], b = m.cables[2 * q + 1];\n    const lv = 0.26 + 0.34 * (m.ten[q] / tmax);\n    if (q !== S.pl || age > 2) {\n      cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], 0, pc, lv);\n      continue;\n    }\n    const pk = 1 - age / 2, col = [0, 1, 2].map((j) => pc[j] + (fl[j] - pc[j]) * pk), v = lv + pk * (1 - lv);\n    const amp = 3.2 * pk * pk, w = 2 * PI * 2.2 * sqrt(m.ten[q] / (tsum / nc + 1e-9)) * (lsum / nc / m.CL[q]);\n    cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], amp, col, v * 0.35);\n    cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], -amp, col, v * 0.35);\n    cable(rgb, zb, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], amp * cos(w * age), col, v);\n  }\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[3 * p], g = rgb[3 * p + 1], b = rgb[3 * p + 2];\n    if (r + g + b > 0.004) display.setPixel(p % W, (p / W) | 0, min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n","twindragon":"// ===== Patternflow pattern =====\n// Title:   Twindragon\n// Family:  fractal\n// Idea:    Every other LED is a Gaussian integer written in base -1+i, the panel is tiled with twindragons of 512 numbers each in its own dim hue, and a bright window counts through all of them at once, so its shape is always a few smaller twindragons that turn 135 degrees with every digit the count carries.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: base -1+i numeration (Walter Penney, 1965), twindragon (Chandler Davis and Donald Knuth, 1970), pattern round 71\n// Round:   71\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Digits=9..12, Split=1..8\n//\n// Knob 1: Hue. Turns every tile round the wheel together: at 0 the tiles are teal, blue and magenta, a little warmer towards the bottom, and the windows run from white at the newest number to the tile's own hue.\n// Knob 2: Speed. How fast the count runs: at 2 one pass through the 512 numbers of a tile takes 8 s, 64 numbers a second; at 0.2 ten times slower, at 3 one and a half times faster. A tile of more digits counts faster, so a pass only grows by the square root of 2 a digit, as the tile's width does: 22.6 s at 12.\n// Knob 3: Digits. K, the digits each number in a tile has, 9 to 12. A tile holds 2^K numbers and the panel's 4096 lattice LEDs hold exactly 4096 / 2^K tiles' worth, so every number shows 8 times at 9 (15 tiles touch the panel), 4 at 10, 2 at 11 and once at 12, where the pieces of six tiles add up to one. A digit more turns the tiles 135 degrees and makes them 1.41 times wider.\n// Knob 4: Split. How many windows share the bright 18.5%, spread evenly through the count. At 1, 2, 4 and 8 each window runs through its own half, quarter or eighth of the tile, all the same shape: the twindragon is two, four or eight smaller ones. At 3, 5, 6 and 7 the gap between windows is not a power of two, so they start at different places in the count and come out in different shapes.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Base -1+i (Penney, 1965). Every Gaussian integer a+bi has one finite\n// expansion sum d_k (-1+i)^k with digits 0 and 1. The low digit is (a+b) mod 2;\n// take it off and divide by -1+i: (a+bi)/(-1+i) = ((b-a) + (-a-b)i)/2.\n// Checked in Node: all 160,801 points with |a|, |b| \u003c= 200 end in at most 22\n// digits and read back to themselves; the 2^22 strings of up to 22 digits give\n// 2^22 different numbers, so none of those points has a second expansion; and\n// for K = 2..12 the 2^K numbers of K digits are pairwise incongruent mod\n// (-1+i)^K, so their copies moved by multiples of (-1+i)^K tile the lattice\n// with no point twice.\n//\n// z = q (-1+i)^K + r, with r the K low digits. r read as a binary number is\n// where z comes in the count; q names the tile.\n//\n// ---- On the panel z = a+bi sits at origin + (a-b, a+b), which is (1+i) z: the\n// lattice is exactly the LEDs with x+y even, the others stay off.\nconst OX = 32, OY = 64;\n\n// ---- Levels. Each lit LED has four dark neighbours, so the map's detail is\n// the mean lit level / 255 and its edges are the share of lit LEDs over 40.\n// The windows hold the first numbers at or above 18.5% of the count: 95 of\n// 512 at K = 9. The panel is a whole number of tiles' worth for every K from 9\n// to 12 (each number shows 2^(12-K) times), so 760 of the 4096 lattice LEDs\n// are bright on every frame. Those sit at 255 and the other 81.45% dim at 40:\n// detail = (0.8145 * 40 + 0.1855 * 255) / 255 = 0.313, edges = 0.186, inside\n// the map's cell of edges under 0.21 and detail 0.297..0.375. Dim at 40 is\n// still lit (over 24) and still a soft step (not over 40). Split and Digits\n// move the bright share only between 18.5% and 18.8%.\nconst DIM = 40, SHARE = 0.185;\n\nfunction layout(K) {\n  const P = 1 \u003c\u003c K, idx = new Int32Array(W * H).fill(-1), tile = new Int32Array(W * H);\n  const keys = new Map();\n  const ty = [], tc = [];\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - OX, dy = y - OY;\n      if ((dx + dy) & 1) continue;\n      let a = (dx + dy) / 2, b = (dy - dx) / 2, r = 0;\n      for (let k = 0; k \u003c K; k++) {\n        const d = (a + b) & 1;\n        if (d) r |= 1 \u003c\u003c k;\n        a -= d;\n        const na = (b - a) / 2;\n        b = (-a - b) / 2;\n        a = na;\n      }\n      const key = a * 4096 + b;\n      let t = keys.get(key);\n      if (t === undefined) {\n        t = keys.size;\n        keys.set(key, t);\n        ty.push([0, 0]);\n        tc.push((((a + b) % 3) + 3) % 3);\n      }\n      ty[t][0] += y;\n      ty[t][1]++;\n      idx[y * W + x] = r;\n      tile[y * W + x] = t;\n    }\n  // A tile's hue follows its middle row down the panel, plus a step of 0.16\n  // by (qa + qb) mod 3. A tile's six neighbours sit at q +-1, +-i and\n  // +-(1+i), and none of those changes qa + qb by a multiple of 3, so two tiles\n  // that touch never share a hue.\n  const hue = ty.map(([s, n], t) => 0.12 * (s / n / H) + 0.16 * tc[t]);\n  return { K, P, idx, tile, hue };\n}\n\nexport function setup(params) {\n  params.s = { t: 0, n: 0, L: null, hue: 0, split: 1 };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 9, 1], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), K = cl(round(k[2]), 9, 12);\n  S.split = cl(round(k[3]), 1, 8);\n  if (!S.L || S.L.K !== K) {\n    // Keep the place in the pass when the tile size changes.\n    const u = S.L ? S.n / S.L.P : 0.25;\n    S.L = layout(K);\n    S.n = u * S.L.P;\n  }\n  // 64 numbers a second at Speed 2 for K = 9, times sqrt 2 a digit more.\n  const rate = 32 * speed * Math.pow(sqrt(2), K - 9);\n  S.n = (S.n + d * rate) % S.L.P;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.L) return;\n  const { P, idx, tile, hue } = S.L, m = S.split, n = floor(S.n);\n  const cols = hue.map((h) => {\n    const c = hsv(0.48 + S.hue + h, 0.8, 1);\n    return [round(c[0] * DIM), round(c[1] * DIM), round(c[2] * DIM), 0.48 + S.hue + h];\n  });\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = idx[p];\n    if (r \u003c 0) continue;\n    const c = cols[tile[p]];\n    // How far back in the count this number is, as a share of the pass.\n    const ph = (((n - r) % P) + P) % P / P, f = ph * m - floor(ph * m);\n    const x = p % W, y = (p - x) / W;\n    if (f \u003c SHARE) {\n      // Bright: white at the newest number, the tile's own hue at the oldest,\n      // the brightest channel 255 all along.\n      const s = f / SHARE, b = hsv(c[3], 0.1 + 0.8 * s, 1);\n      display.setPixel(x, y, round(b[0] * 255), round(b[1] * 255), round(b[2] * 255));\n    } else display.setPixel(x, y, c[0], c[1], c[2]);\n  }\n}\n","eight-principles-of-yong":"// ===== Patternflow pattern =====\n// Title:   Eight Principles of Yong\n// Family:  type\n// Idea:    The character 永, eternity, stands the full height of the panel and a brush writes it in its five strokes in their standard order, and as it begins each of the eight basic strokes of regular script that the old teaching finds in it, the name of that method lights in red beside it: the dot, then the horizontal, the vertical and the hook in one stroke, the rising stroke turning into the long sweep, the short peck and the wave; the brush presses wider and lifts thinner, pauses and pools at its turns and runs dry in streaks toward the end of a long stroke, and when the character is done the eight light one after another before the ink fades and another is written.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Eight Principles of Yong (永字八法), the teaching of regular-script calligraphy that finds eight basic strokes in the one character 永, of traditional attribution (to Wang Xizhi in the 4th century, to the Sui monk Zhiyong and to others), with the eight under their old names 側 勒 努 趯 策 掠 啄 磔; the five strokes of 永 in their standard order; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Brush=-1..1, Ink=-1..1\n//\n// Knob 1: Hue. Turns ink, paper and names round the wheel together: at 0 gold ink on indigo paper with the names in vermilion, at 0.25 green ink on a dark plum paper, at 0.5 blue ink on dark olive with cyan names.\n// Knob 2: Speed. At 2 the character takes 6.7 s from the dot's first touch to the lift of the wave, the vertical alone about 1 s, then holds 2.3 s while the eight methods light in turn, 0.23 s each, and fades in 0.9 s, a round of 10.2 s; at 0.2 ten times slower, at 3 two thirds of that. A fresh start opens with the dot already down and the brush in the air.\n// Knob 3: Brush. The brush's size: at 0 the vertical comes out about 6.5 LEDs wide and the dot 8.4 where it presses, at -1 0.55 of that (the vertical 3.6) and at 1 1.45 (the vertical 9.5, wide enough to touch the name 努 beside it).\n// Knob 4: Ink. How much ink the brush carries and how fast it gives out across its 9 bristles. At the opening 0.06 a stroke starts full and the last third of the vertical, the tail of the sweep and the foot of the wave break into dry streaks; at -1 it starts with a fifth less and runs out 2.2 times faster, down to about a quarter of the bristles scratching; at 1 it hardly runs dry, the strokes swell by an eighth and the ink bleeds 3.2 LEDs into the paper over most of a second, nearly 5 where the brush rests.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The five strokes of 永 in their order, each a run of knots the brush\n// passes: x, y, brush radius in LEDs, the time to reach the knot from the\n// one before and the time the brush rests there pressing down (in beats, of\n// which Speed 2 plays 1.2 a second), and which of the eight methods the\n// stretch belongs to: 0 側 the dot, 1 勒 the horizontal, 2 努 the vertical,\n// 3 趯 the hook, 4 策 the rising stroke, 5 掠 the long sweep to the left, 6 啄\n// the short peck, 7 磔 the wave to the right. The second stroke carries three\n// methods and the third two, so five strokes hold all eight.\nconst STROKES = [\n  [[25.5, 4.5, 0.6, 0, 0, 0], [27.5, 6.5, 1.8, 0.1, 0, 0], [30.5, 10, 3.0, 0.14, 0, 0], [33.5, 14, 3.9, 0.14, 0, 0], [35, 16.5, 4.2, 0.1, 0.18, 0], [33.8, 18.2, 3.4, 0.08, 0, 0], [32.5, 17.6, 2.2, 0.06, 0, 0]],\n  [[14.5, 32.5, 0.7, 0, 0, 1], [16.5, 35, 2.6, 0.08, 0.1, 1], [20, 35, 2.4, 0.08, 0, 1], [26, 34, 2.3, 0.16, 0, 1], [32, 32.8, 2.3, 0.16, 0, 1], [35.5, 32.2, 2.2, 0.08, 0, 1], [37.5, 32, 2.0, 0.05, 0, 1],\n    [39.5, 34.8, 3.5, 0.08, 0.22, 2], [38.6, 40, 3.4, 0.08, 0, 2], [38, 55, 3.2, 0.22, 0, 2], [37.8, 72, 3.2, 0.24, 0, 2], [38, 90, 3.3, 0.24, 0, 2], [38.3, 104, 3.4, 0.2, 0, 2],\n    [38.4, 111, 3.8, 0.12, 0.25, 3], [35.5, 111.5, 3.0, 0.05, 0, 3], [31, 108, 2.0, 0.06, 0, 3], [27, 104.5, 1.0, 0.05, 0, 3], [24.5, 102.5, 0.25, 0.04, 0, 3]],\n  [[4.5, 63, 0.7, 0, 0, 4], [6.5, 65.5, 2.6, 0.08, 0.1, 4], [11, 63.5, 2.2, 0.08, 0, 4], [17, 60.5, 1.9, 0.1, 0, 4], [21.5, 58.3, 1.8, 0.07, 0, 4],\n    [24.5, 58.5, 2.6, 0.06, 0.18, 5], [24.6, 63, 2.9, 0.07, 0, 5], [23.6, 71, 3.0, 0.1, 0, 5], [21.5, 80, 2.8, 0.1, 0, 5], [18, 89, 2.4, 0.1, 0, 5], [13, 98, 1.9, 0.1, 0, 5], [7.5, 106, 1.2, 0.09, 0, 5], [3, 111, 0.5, 0.07, 0, 5], [1, 112.5, 0.15, 0.04, 0, 5]],\n  [[57, 41, 0.8, 0, 0, 6], [56, 43.5, 2.8, 0.07, 0.08, 6], [52.5, 47, 2.6, 0.06, 0, 6], [48.5, 51, 2.0, 0.05, 0, 6], [45, 54.5, 1.2, 0.04, 0, 6], [42.5, 56.5, 0.3, 0.03, 0, 6]],\n  [[42.5, 58.5, 0.6, 0, 0, 7], [44.2, 62.5, 1.3, 0.08, 0, 7], [46.6, 69, 1.9, 0.12, 0, 7], [49.2, 77, 2.6, 0.14, 0, 7], [51.6, 85, 3.3, 0.14, 0, 7], [53.8, 92, 4.0, 0.13, 0, 7], [55.6, 97, 4.5, 0.1, 0, 7], [57, 99.8, 4.7, 0.08, 0.25, 7], [59.6, 101.2, 3.4, 0.07, 0, 7], [61.6, 101.8, 2.0, 0.05, 0, 7], [63.2, 102, 0.6, 0.04, 0, 7]],\n];\n\n// The names of the eight methods, drawn for this pattern 13 LEDs square, and\n// where each stands beside its stroke, as diagrams of 永 often set them.\nconst NAMES = [\n  [\"..#..........\", \"..#.#####...#\", \".#..#...#.#.#\", \".#..#####.#.#\", \"##..#...#.#.#\", \".#..#####.#.#\", \".#..#...#.#.#\", \".#..#####.#.#\", \".#...#.#..#.#\", \".#..#...#...#\", \".#.#.....#..#\", \".#..........#\", \".#.........##\"],\n  [\".#.#...#.....\", \"#######.#....\", \".#.#....#....\", \".###.#######.\", \"...#....#...#\", \".#####..#...#\", \".#.#.#..#...#\", \".#####..#...#\", \"...#...#....#\", \"#######.....#\", \"...#...#....#\", \"...#..#..#..#\", \"...#.#....##.\"],\n  [\"..#...######.\", \"..#...#....#.\", \"#######...#..\", \".#..#..#.#...\", \".#.#....#....\", \"..##...#.#...\", \"##..#.#...##.\", \".....#.......\", \"############.\", \".....#.....#.\", \"....#......#.\", \"..##.....#.#.\", \"##........#..\"],\n  [\"..#...##.##..\", \"#####..#..#..\", \"..#...##.##..\", \".###...#..#..\", \".......#.##..\", \"#####.#.#....\", \"..#..#####...\", \".##.#.#..#...\", \"..#...####...\", \"..##..#..#...\", \".#..#.####...\", \".#..#.#......\", \"#....########\"],\n  [\".#.....#.....\", \"#####.#####..\", \"#....#..#....\", \".............\", \"#############\", \"......#......\", \".###########.\", \".#....#....#.\", \".#....#..###.\", \"......#......\", \"....#.#.#....\", \"..##..#..##..\", \"##....#....##\"],\n  [\".#.....#.....\", \".#..#######..\", \"####.........\", \".#...#####...\", \".#...#...#...\", \".###.#...#...\", \"##...#####...\", \".#.....#.....\", \".#...#.#.#...\", \".#..#..#..#..\", \".#.#...#...#.\", \".#.....#.....\", \"##....##.....\"],\n  [\".....########\", \".........#...\", \"........#...#\", \"####...#...#.\", \"#..#..#..##..\", \"#..#....##...\", \"#..#...#.#...\", \"#..#..#..##..\", \"#..#.#..##.#.\", \"####...#.#..#\", \"......#..#..#\", \".....#...#...\", \"........##...\"],\n  [\".......#...#.\", \"#####.####.##\", \"..#...#..#.#.\", \"..#....##..##\", \".#.....#...#.\", \".####.#...##.\", \"##..#.#######\", \".#..#...###..\", \".#..#..#.#.#.\", \".####.#..#..#\", \".........#...\", \".........#...\", \".........#...\"],\n];\nconst SPOT = [[11, 3], [1, 17], [22, 88], [10, 114], [1, 46], [1, 72], [50, 24], [47, 110]];\n\n// Paper: a fixed scatter of short fibres, and a grain per LED that roughens\n// the edge of every stroke.\nconst FIB = new Float32Array(N), GRAIN = new Float32Array(N);\n{\n  let s = 12345;\n  const rnd = () => ((s = (s * 1103515245 + 12345) >>> 0) / 4294967296);\n  for (let p = 0; p \u003c N; p++) GRAIN[p] = rnd() * 2 - 1;\n  for (let f = 0; f \u003c 170; f++) {\n    let x = rnd() * W, y = rnd() * H, a = rnd() * PI;\n    const len = 3 + rnd() * 6, v = 0.3 + rnd() * 0.7;\n    for (let k = 0; k \u003c len; k++, a += (rnd() - 0.5) * 0.5) {\n      x += cos(a);\n      y += sin(a);\n      const xi = floor(x), yi = floor(y);\n      if (xi >= 0 && xi \u003c W && yi >= 0 && yi \u003c H) FIB[yi * W + xi] = max(FIB[yi * W + xi], v);\n    }\n  }\n}\n\n// Bristles across the brush, and the beats a finished character holds and\n// takes to fade.\nconst NB = 9, HOLD = 2.8, FADE = 1.1;\n\n// Lays the strokes out as a timeline of brush samples a third of an LED\n// apart, with a little of a hand's wobble that differs from one writing to\n// the next.\nfunction build(S) {\n  const xs = [], ys = [], rs = [], ts = [], ds = [], ms = [], ss = [], ks = [], txs = [], tys = [];\n  const air = [];\n  let t = 0, px = 46, py = -6;\n  STROKES.forEach((knots, k) => {\n    const P = knots.map((q) => [q[0] + (Math.random() - 0.5) * 1.0, q[1] + (Math.random() - 0.5) * 1.0, q[2] * (0.94 + Math.random() * 0.12), q[3], q[4], q[5]]);\n    const dist = sqrt((P[0][0] - px) ** 2 + (P[0][1] - py) ** 2), at = 0.18 + dist / 150;\n    air.push([t, t + at, px, py, P[0][0], P[0][1], P[0][2]]);\n    t += at;\n    let s = 0, lx = P[0][0], ly = P[0][1];\n    const push = (x, y, r, tt, dw, m) => {\n      s += sqrt((x - lx) ** 2 + (y - ly) ** 2);\n      const dx = x - lx, dy = y - ly, L = sqrt(dx * dx + dy * dy);\n      if (L > 1e-3) txs.push(dx / L), tys.push(dy / L);\n      else txs.push(txs.length ? txs[txs.length - 1] : 1), tys.push(tys.length ? tys[tys.length - 1] : 0);\n      xs.push(x), ys.push(y), rs.push(r), ts.push(tt), ds.push(dw), ms.push(m), ss.push(s), ks.push(k);\n      lx = x;\n      ly = y;\n    };\n    push(P[0][0], P[0][1], P[0][2], t, P[0][4], P[0][5]);\n    t += P[0][4];\n    for (let i = 1; i \u003c P.length; i++) {\n      const a = P[max(0, i - 2)], b = P[i - 1], c = P[i], d = P[min(P.length - 1, i + 1)];\n      const L = sqrt((c[0] - b[0]) ** 2 + (c[1] - b[1]) ** 2), n = max(1, ceil(L / 0.33));\n      for (let j = 1; j \u003c= n; j++) {\n        const u = j / n, u2 = u * u, u3 = u2 * u;\n        const cr = (p0, p1, p2, p3) => 0.5 * (2 * p1 + (p2 - p0) * u + (2 * p0 - 5 * p1 + 4 * p2 - p3) * u2 + (3 * p1 - p0 - 3 * p2 + p3) * u3);\n        push(cr(a[0], b[0], c[0], d[0]), cr(a[1], b[1], c[1], d[1]), b[2] + (c[2] - b[2]) * u, t + c[3] * u, j === n ? c[4] : 0, c[5]);\n      }\n      t += c[3] + c[4];\n    }\n    px = P[P.length - 1][0];\n    py = P[P.length - 1][1];\n  });\n  S.n = xs.length;\n  S.x = Float32Array.from(xs), S.y = Float32Array.from(ys), S.r = Float32Array.from(rs), S.t = Float32Array.from(ts), S.d = Float32Array.from(ds);\n  S.m = Int8Array.from(ms), S.s = Float32Array.from(ss), S.k = Int8Array.from(ks), S.tx = Float32Array.from(txs), S.ty = Float32Array.from(tys);\n  S.air = air;\n  S.end = t;\n  // Each stroke's bristles: the ink level at which each one gives out, and\n  // a slow wobble along the stroke so the dry streaks break and rejoin.\n  S.theta = [];\n  S.wf = [];\n  S.wp = [];\n  for (let k = 0; k \u003c 5; k++) {\n    const th = [];\n    for (let b = 0; b \u003c NB; b++) th.push(0.08 + (0.84 * (b + Math.random())) / NB);\n    for (let b = NB - 1; b > 0; b--) {\n      const j = floor(Math.random() * (b + 1));\n      [th[b], th[j]] = [th[j], th[b]];\n    }\n    S.theta.push(th);\n    S.wf.push(Array.from({ length: NB }, () => 0.15 + Math.random() * 0.25));\n    S.wp.push(Array.from({ length: NB }, () => Math.random() * 6.3));\n  }\n  // The time each method starts, for its name.\n  S.mt = new Float32Array(8).fill(1e9);\n  for (let i = 0; i \u003c S.n; i++) if (S.t[i] \u003c S.mt[S.m[i]]) S.mt[S.m[i]] = S.t[i];\n}\n\nfunction fresh(S) {\n  S.T = 0;\n  S.i = 0;\n  S.dw = -1;\n  S.cov.fill(0);\n  S.bleed.fill(0);\n  S.mid.fill(-1);\n  S.t0.fill(-1);\n  build(S);\n}\n\nexport function setup(params) {\n  const S = (params.yong = {\n    cov: new Float32Array(N), bleed: new Float32Array(N), mid: new Int8Array(N), t0: new Float32Array(N),\n    hue: 0, speed: 2, brush: 0, ink: 0.06, started: false,\n  });\n  fresh(S);\n}\n\n// One brush sample pressed into the paper. grow is how far into its rest the\n// brush is, 0 to 1: a resting brush spreads and pools its ink.\nfunction stamp(S, i, grow) {\n  const k = S.k[i], s = S.s[i], q = S.ink, wet = max(0, q);\n  const rr = S.r[i] * (1 + 0.45 * S.brush) * (1 + 0.12 * wet) * (1 + 0.14 * grow);\n  if (rr \u003c 0.12) return;\n  const rate = 0.0055 * (1 - 0.6 * q) * (q \u003c 0 ? 1 - 0.3 * q : 1);\n  let L = 1.05 + 0.2 * q - s * rate;\n  if (grow > 0) L = max(L, 0.75 + 0.3 * grow);\n  const dens = cl(0.5 + 0.5 * L, 0.45, 1);\n  const hw = 3.2 * wet + 1.4 * grow * (0.25 + wet);\n  const cx = S.x[i], cy = S.y[i], nx = -S.ty[i], ny = S.tx[i];\n  const th = S.theta[k], wf = S.wf[k], wp = S.wp[k];\n  const R = rr + hw + 1;\n  const x0 = max(0, floor(cx - R)), x1 = min(W - 1, ceil(cx + R)), y0 = max(0, floor(cy - R)), y1 = min(H - 1, ceil(cy + R));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x - cx, dy = y - cy, dist = sqrt(dx * dx + dy * dy), p = y * W + x, d = dist - rr;\n      if (S.t0[p] \u003c 0 && d \u003c hw + 0.5) S.t0[p] = S.T;\n      const c = cl(0.6 - d + 0.35 * GRAIN[p], 0, 1);\n      if (c > 0) {\n        const u = (dx * nx + dy * ny) / rr;\n        const b = cl(floor((u + 1) * 0.5 * NB), 0, NB - 1);\n        const dep = cl((max(L, 0.3) + 0.28 * sin(s * wf[b] + wp[b]) - th[b]) * 5, 0, 1);\n        const v = c * dep * dens;\n        if (v > S.cov[p]) {\n          S.cov[p] = v;\n          S.mid[p] = S.m[i];\n        }\n      }\n      if (hw > 0.05 && d > -0.5 && d \u003c hw) {\n        const bv = (0.2 + 0.25 * wet) * cl(1 - (d + 0.6 * GRAIN[p] + 0.5 * FIB[p]) / hw, 0, 1);\n        if (bv > S.bleed[p]) S.bleed[p] = bv;\n      }\n    }\n}\n\nfunction advance(S, dt) {\n  S.T += dt * S.speed * 0.6;\n  const T = S.T;\n  if (S.dw >= 0) {\n    const g = min(1, (T - S.t[S.dw]) / S.d[S.dw]);\n    stamp(S, S.dw, g);\n    if (g >= 1) S.dw = -1;\n  }\n  while (S.i \u003c S.n && S.t[S.i] \u003c= T) {\n    const i = S.i++;\n    if (S.d[i] > 0) {\n      const g = min(1, (T - S.t[i]) / S.d[i]);\n      stamp(S, i, g);\n      if (g \u003c 1) {\n        S.dw = i;\n        break;\n      }\n    } else stamp(S, i, 0);\n  }\n  if (T > S.end + HOLD + FADE) fresh(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.yong) setup(params);\n  const S = params.yong, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.brush = cl(k[2], -1, 1);\n  S.ink = cl(k[3], -1, 1);\n  if (!S.started) {\n    // A fresh start opens with the dot written and the brush on its way to\n    // the horizontal.\n    S.started = true;\n    for (let j = 0; j \u003c 36; j++) advance(S, 1 / 30 / (S.speed * 0.6));\n  }\n  advance(S, dt);\n}\n\nexport function draw(display, params) {\n  const S = params.yong;\n  if (!S) return;\n  const T = S.T, h0 = 0.115 + S.hue;\n  const ink = hsv(h0, 0.72, 1, [0, 0, 0]), paper = hsv(h0 + 0.52, 0.78, 0.16, [0, 0, 0]), lab = hsv(h0 - 0.105, 0.78, 0.95, [0, 0, 0]);\n  const fade = T > S.end + HOLD ? cl(1 - (T - S.end - HOLD) / FADE, 0, 1) : 1;\n  // While the finished character holds, each method lights in turn.\n  const hiT = T - S.end - 0.3, hiM = hiT >= 0 && hiT \u003c 8 * 0.28 ? floor(hiT / 0.28) : -1, hiA = hiM >= 0 ? sin((PI * (hiT - hiM * 0.28)) / 0.28) : 0;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const f = 0.82 + 0.45 * FIB[p] + 0.06 * GRAIN[p];\n      let r = paper[0] * f, g = paper[1] * f, b = paper[2] * f;\n      const t0 = S.t0[p];\n      if (t0 >= 0) {\n        const age = T - t0, cv = S.cov[p], bl = S.bleed[p] * min(1, age / 0.9);\n        const a = max(cv, bl) * fade;\n        if (a > 0) {\n          r += (ink[0] - r) * a;\n          g += (ink[1] - g) * a;\n          b += (ink[2] - b) * a;\n          let wh = 0.5 * exp(-age / 0.35) * cv;\n          if (hiM >= 0 && S.mid[p] === hiM) wh += 0.55 * hiA * cv;\n          wh *= fade;\n          r += (255 - r) * wh;\n          g += (255 - g) * wh;\n          b += (255 - b) * wh;\n        }\n      }\n      display.setPixel(x, y, r, g, b);\n    }\n  // The names, each lighting as its method begins.\n  for (let m = 0; m \u003c 8; m++) {\n    const st = S.mt[m];\n    if (T \u003c st) continue;\n    const age = T - st;\n    let v = (0.62 + 0.38 * exp(-age / 0.6)) * min(1, age / 0.15) * fade;\n    if (m === hiM) v = min(1, v + 0.5 * hiA);\n    const G = NAMES[m], [ox, oy] = SPOT[m];\n    for (let gy = -1; gy \u003c= 13; gy++)\n      for (let gx = -1; gx \u003c= 13; gx++) {\n        const x = ox + gx, y = oy + gy;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const on = gy >= 0 && gy \u003c 13 && gx >= 0 && gx \u003c 13 && G[gy][gx] === \"#\";\n        if (on) display.setPixel(x, y, lab[0] * v + 40 * v * v, lab[1] * v + 40 * v * v, lab[2] * v + 40 * v * v);\n      }\n  }\n  // The brush between strokes, a faint ring where it will come down.\n  for (const a of S.air)\n    if (T >= a[0] && T \u003c a[1]) {\n      const u = (T - a[0]) / (a[1] - a[0]), e = u * u * (3 - 2 * u);\n      const bx = a[2] + (a[4] - a[2]) * e, by = a[3] + (a[5] - a[3]) * e, rr = 2.2 + 2 * (1 - e) + S.brush;\n      for (let y = max(0, floor(by - rr - 1)); y \u003c= min(H - 1, ceil(by + rr + 1)); y++)\n        for (let x = max(0, floor(bx - rr - 1)); x \u003c= min(W - 1, ceil(bx + rr + 1)); x++) {\n          const d = abs(sqrt((x - bx) ** 2 + (y - by) ** 2) - rr);\n          if (d \u003c 0.7) display.setPixel(x, y, 60 + ink[0] * 0.25, 60 + ink[1] * 0.25, 60 + ink[2] * 0.25);\n        }\n    }\n}\n","frenkel-kontorova":"// ===== Patternflow pattern =====\n// Title:   Frenkel-Kontorova\n// Family:  sim\n// Idea:    Balls joined by springs lie in a ring on a corrugated floor of 12 wells along the foot of the panel, with more or fewer balls than wells, so the chain bunches or stretches at kinks where it slips by one well, and a steady push drives those kinks round the ring while the panel above writes each moment as a row, oldest at the top, so every ball's worldline steps one well sideways each time a kink runs through it and the kinks cross the record as slanted bands, magenta where the chain is squeezed and green where it is stretched.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Frenkel-Kontorova model (Yakov Frenkel and Tatiana Kontorova, 1938), the damped chain of Kibble-Zurek Ions (pattern round 64), pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Drive=0..3, Misfit=0.86..1.2, Substrate=1..4\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the chain lying one ball to a well is blue, a squeezed kink magenta, a stretched kink green and the two marked balls cream; at 0.25 the chain is pink, squeezed kinks orange and stretched ones blue; at 0.5 the chain is a pale yellow with green and pink kinks.\n// Knob 2: Drive. The same push on every ball, 0.04 d + 0.1 d^2 times K = 1's strongest pull back into a well. At the opening 2 (0.48 of that pull) the two squeezed kinks run right at about 22 LEDs a second, round the ring in 2.9 s, and each ball steps one well right every 1.7 s; at 0.5 they creep, a ball stepping every 9 s; at 0 nothing moves but a shiver; at 3 the K = 1 chain tears loose and slides 3.2 wells a second, kinks and all.\n// Knob 3: Misfit. The chain's mean spacing over the well spacing, rounded to whole balls on the 12 wells. At 0.86 there are 14 balls, two too many, which bunch into two squeezed kinks that run with the push; at 0.945 13 balls and one such kink; at 1.03 twelve, one to a well, no kink and nothing moving until the whole chain tears loose; at 1.115 eleven, one ball short, and the stretched kink runs against the push at 22 LEDs a second; at 1.2 ten and two. A new count lays the chain out evenly and lets it settle into kinks.\n// Knob 4: Substrate. K, the depth of the wells against the springs, the floor V = K/4pi^2 (1 - cos 2 pi x) under springs of stiffness 1, drawn 3 + 1.25 K LEDs high. At 1 a squeezed kink is spread over four bonds and the opening push moves it easily; at 2.5 it sits mostly in one bond squeezed by 0.58 of a well and needs a push of 2 to move; at 3.25 the push of 2 cannot lift it over the next crest and the record stands still, and at 4 it takes a push of 3.\n// Buttons: K2 tap turns the push round, so the kinks turn back and their bands bend into a V.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// The ring: M wells P LEDs apart round the panel's width. Chain positions\n// are in wells, well j at x = j, drawn at column P j + P/2.\nconst M = 12, P = W / M, NMAX = 24;\n// The history: one row every ROW_T seconds in rows 0 to HR - 1, oldest on\n// top and newest at the bottom. The chain view under it: valley floors on\n// row YB.\nconst HR = 113, YB = 125, ROW_T = 1 / 12;\n// Simulation: TS time units a second in steps of DT, damping GAMMA.\nconst TS = 6, DT = 0.04, GAMMA = 0.3;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\nfunction gauss() {\n  return (Math.random() + Math.random() + Math.random() - 1.5) * 2;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, x: new Float64Array(NMAX), v: new Float64Array(NMAX), f: new Float64Array(NMAX),\n    K: 1, F: 0, dir: 1, temp: 0.001, hue: 0, rowT: 0, head: 0, started: false,\n    hist: new Float32Array(HR * W * 3), strain: new Float32Array(W), sm: new Float32Array(W),\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],\n  };\n  return params.s;\n}\n\nfunction load(S, n) {\n  S.n = n;\n  const a = M / n, off = Math.random();\n  for (let i = 0; i \u003c n; i++) (S.x[i] = off + i * a), (S.v[i] = 0);\n}\n\nfunction forces(S) {\n  const n = S.n, x = S.x, f = S.f, k = S.K / TAU;\n  for (let i = 0; i \u003c n; i++) {\n    const xl = i > 0 ? x[i - 1] : x[n - 1] - M, xr = i \u003c n - 1 ? x[i + 1] : x[0] + M;\n    f[i] = xr - 2 * x[i] + xl - k * sin(TAU * x[i]) + S.F;\n  }\n}\n\nfunction step(S, h) {\n  const n = S.n, x = S.x, v = S.v, f = S.f;\n  forces(S);\n  const kick = sqrt(2 * GAMMA * S.temp * h), g = 1 - GAMMA * h;\n  for (let i = 0; i \u003c n; i++) {\n    v[i] = (v[i] + f[i] * h) * g + kick * gauss();\n    x[i] += v[i] * h;\n  }\n  if (x[0] >= M) for (let i = 0; i \u003c n; i++) x[i] -= M;\n  else if (x[0] \u003c 0) for (let i = 0; i \u003c n; i++) x[i] += M;\n}\n\n// Strain of each column: the stretch of the bond over it, in wells, spread\n// over five columns so a kink reads as a band.\nfunction strainRow(S) {\n  const n = S.n, x = S.x, st = S.strain, sm = S.sm;\n  for (let i = 0; i \u003c n; i++) {\n    const xa = x[i], xb = i \u003c n - 1 ? x[i + 1] : x[0] + M, s = xb - xa - 1;\n    const c0 = P * xa + P / 2, c1 = P * xb + P / 2;\n    for (let c = Math.ceil(c0 - 0.5); c \u003c c1 - 0.5; c++) st[((c % W) + W) % W] = s;\n  }\n  for (let c = 0; c \u003c W; c++)\n    sm[c] = (st[(c + W - 2) % W] + 2 * st[(c + W - 1) % W] + 3 * st[c] + 2 * st[(c + 1) % W] + st[(c + 2) % W]) / 9;\n  return sm;\n}\n\n// The colour of a strain: blue where the chain lies one ball to a well,\n// green where it is stretched, magenta where it is squeezed.\nfunction strainColour(S, s, v, o) {\n  const a = cl((abs(s) - 0.04) / 0.32, 0, 1);\n  const h = s > 0 ? 0.64 + (0.42 - 0.64) * a : 0.64 + (0.88 - 0.64) * a;\n  return hsv(h + S.hue, 0.55 + 0.35 * a, v, o);\n}\n\n// One row of the history: the strain as a dim band, each ball's worldline\n// over it, and two balls, the first and the middle one, in cream so their\n// steps can be followed down the record.\nfunction record(S) {\n  S.head = (S.head + 1) % HR;\n  const row = S.head * W * 3, hist = S.hist, sm = strainRow(S), c = S.c;\n  for (let X = 0; X \u003c W; X++) {\n    const s = sm[X], a = cl((abs(s) - 0.04) / 0.32, 0, 1);\n    strainColour(S, s, 0.05 + 0.42 * a * a, c);\n    hist[row + X * 3] = c[0];\n    hist[row + X * 3 + 1] = c[1];\n    hist[row + X * 3 + 2] = c[2];\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const px = (((P * S.x[i] + P / 2 - 0.5) % W) + W) % W, X0 = floor(px), fr = px - X0;\n    const s = sm[X0], a = cl((abs(s) - 0.04) / 0.32, 0, 1), tracer = i === 0 || i === S.n >> 1;\n    strainColour(S, s, 1, c);\n    if (tracer) (c[0] = 1), (c[1] = 0.95), (c[2] = 0.8);\n    const v = tracer ? 1 : 0.45 + 0.55 * a;\n    for (const [X, w] of [[X0, 1 - fr], [(X0 + 1) % W, fr]]) {\n      const o = row + X * 3, k = w * v;\n      const m = tracer ? 0 : 0.65 - 0.35 * a;\n      hist[o] = max(hist[o], (m + (1 - m) * c[0]) * k);\n      hist[o + 1] = max(hist[o + 1], (m + (1 - m) * c[1]) * k);\n      hist[o + 2] = max(hist[o + 2], (m + (1 - m) * c[2]) * k);\n    }\n  }\n}\n\nfunction advance(S, d) {\n  const steps = max(1, round((d * TS) / DT)), h = (d * TS) / steps;\n  for (let k = 0; k \u003c steps; k++) step(S, h);\n  S.rowT += d;\n  while (S.rowT >= ROW_T) {\n    S.rowT -= ROW_T;\n    record(S);\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0.86, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.K = cl(kv[3], 1, 4);\n  if (input.btnPressed && input.btnPressed[1]) S.dir = -S.dir;\n  const dr = cl(kv[1], 0, 3);\n  S.F = (S.dir * (0.04 * dr + 0.1 * dr * dr)) / TAU;\n  const n = cl(round(M / cl(kv[2], 0.86, 1.2)), 10, 14);\n  if (n !== S.n) load(S, n);\n  if (!S.started) {\n    S.started = true;\n    for (let f = 0; f \u003c HR * 3; f++) advance(S, 1 / 30);\n  }\n  advance(S, d);\n}\n\nfunction surface(S, X) {\n  const u = (X + 0.5) / P - 0.5, A = 3 + 1.25 * S.K;\n  return YB - (A * (1 - cos(TAU * u))) / 2;\n}\n\nfunction plot(rgb, X, Y, r, g, b, a) {\n  if (Y \u003c 0 || Y >= H || a \u003c= 0) return;\n  X = ((X % W) + W) % W;\n  const o = (Y * W + X) * 3;\n  rgb[o] = max(rgb[o], r * a);\n  rgb[o + 1] = max(rgb[o + 1], g * a);\n  rgb[o + 2] = max(rgb[o + 2], b * a);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, c = S.c, c2 = S.c2, n = S.n, x = S.x;\n  rgb.fill(0);\n  // The floor: a ridge line over a dim fill down to the valley floors.\n  hsv(0.64 + S.hue, 0.55, 1, c2);\n  for (let X = 0; X \u003c W; X++) {\n    const ys = surface(S, X);\n    for (let Y = floor(ys) + 1; Y \u003c= YB + 2; Y++) plot(rgb, X, Y, c2[0], c2[1], c2[2], 0.3 - 0.15 * cl((Y - ys) / 8, 0, 1));\n    plot(rgb, X, floor(ys), c2[0], c2[1], c2[2], 0.55 + 0.45 * (1 - (ys - floor(ys))));\n  }\n  // Bonds between the balls, coloured by their stretch, then the balls.\n  const sm = strainRow(S);\n  const bx = (i) => P * x[i] + P / 2 - 0.5;\n  const by = (X) => surface(S, ((X % W) + W) % W) - 1.8;\n  for (let i = 0; i \u003c n; i++) {\n    const xa = bx(i), xb = i \u003c n - 1 ? bx(i + 1) : bx(0) + W, ya = by(xa), yb = by(xb);\n    strainColour(S, (xb - xa) / P - 1, 1, c);\n    const len = max(2, Math.ceil(abs(xb - xa) + abs(yb - ya)) * 2);\n    for (let k = 0; k \u003c= len; k++) {\n      const t = k / len;\n      plot(rgb, round(xa + (xb - xa) * t), round(ya + (yb - ya) * t), c[0], c[1], c[2], 0.8);\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const X = bx(i), Y = by(X);\n    strainColour(S, sm[((round(X) % W) + W) % W], 1, c);\n    if (i === 0 || i === n >> 1) (c[0] = 1), (c[1] = 0.95), (c[2] = 0.8);\n    for (let yy = floor(Y - 3); yy \u003c= Math.ceil(Y + 3); yy++)\n      for (let xx = floor(X - 3); xx \u003c= Math.ceil(X + 3); xx++) {\n        const e2 = (xx - X) * (xx - X) + (yy - Y) * (yy - Y), a = cl(2.2 - e2 / 2.4, 0, 1);\n        const w = cl(1 - e2 / 3, 0, 1);\n        plot(rgb, xx, yy, c[0] + (1 - c[0]) * w, c[1] + (1 - c[1]) * w, c[2] + (1 - c[2]) * w, a);\n      }\n  }\n  // The history, oldest row on top.\n  for (let r = 0; r \u003c HR; r++) {\n    const src = ((S.head + 1 + r) % HR) * W * 3, dst = r * W * 3;\n    for (let k = 0; k \u003c W * 3; k++) rgb[dst + k] = S.hist[src + k];\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = (Y * W + X) * 3;\n      display.setPixel(X, Y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n    }\n}\n","granular-leidenfrost":"// ===== Patternflow pattern =====\n// Title:   Granular Leidenfrost\n// Family:  particle\n// Idea:    A tall box of inelastic grains four LEDs across stands on a floor that strikes every grain landing on it, and past a strength of shaking the grains part into a cold cluster packed as a crystal, some twenty layers of grains, floating on a thin hot gas of grains the floor keeps throwing up, the way a drop rides its own vapour on a hot plate; gentler shaking lets the cluster settle into a bed on the floor, harder shaking presses it to the lid, and more elastic grains melt it into gas.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the granular Leidenfrost effect (Peter Eshuis, Ko van der Weele, Devaraj van der Meer and Detlef Lohse, \"Granular Leidenfrost Effect: Experiment and Theory of Floating Particle Clusters\", Physical Review Letters 95, 258001, 2005), named after the drop on a hot plate (Johann Gottlob Leidenfrost, 1756), pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Shaking=0.5..3, Restitution=0.88..0.98, Grains=320..440\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 a cold grain is teal (27, 133, 179) and the hotter it is the further it turns, through violet to a pale pink (255, 128, 181) with a glow round the hottest; heat runs on a log scale from a grain moving at 1/18 of the floor's speed to one moving at it. At 0.25 cold is purple and hot pale yellow, at 0.5 cold is rust and hot mint, at 0.75 cold is green and hot lavender.\n// Knob 2: Shaking. The floor's speed U is 52 LEDs a second times the knob, under a gravity of 40 LEDs a second squared, so U squared over g and a grain's width, the shaking strength, is 4 at 0.5, 68 at the opening 2 and 152 at 3. At 0.5 the grains lie as a bed on the floor 76 LEDs deep with only its bottom rows warm; at 2 the crystal's underside rides about 40 LEDs above the floor on the gas with its top near row 30; at 3 it floats from 60 LEDs up and is pressed toward the lid.\n// Knob 3: Restitution. The share of their closing speed two grains keep when they collide, 0.88 at the opening. More elastic grains lose less inside the crystal, so it warms and rises: at 0.93 it floats from 64 to 116 LEDs up, and at 0.98 it melts into a gas that thins from the lid down, its top grains moving at a third of the floor's speed.\n// Knob 4: Grains. 320 to 440 in tens, 20 to 27.5 layers of 16. A new count starts a fresh box with 85% of the grains packed in rows from 52 LEDs up and the rest scattered under them. A heavier crystal sinks onto a thinner gas: 440 grains float from 28 LEDs up and stand to 116.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, exp, log10 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Lengths in LEDs, time in the panel's seconds. z counts up from the floor,\n// the top edge of the bottom row, to the lid, the top edge of row 0. Grains\n// are hard disks of radius R, 16 to a layer across the 64 columns.\nconst ZTOP = H - 1, R = 2, D = 2 * R, NMAX = 440;\nconst GRAV = 40;\n// The floor is a sawtooth driver in the limit of a small, fast stroke: it\n// stays at z = 0 and always meets a grain moving up at U, so a grain\n// landing at speed v leaves at U + E_FLOOR (U + v), with up to 15% of that\n// impact turned sideways by the floor's roughness.\nconst U_PER = 52, E_FLOOR = 0.8, E_WALL = 0.9, ROUGH = 0.15;\n// A substep is at most 1/240 s and short enough that the fastest grain\n// moves at most 1.2 LEDs in it, under a third of its width.\nconst SUBSTEP = 1 / 240, REACH = 1.2;\n// Grains are drawn a little smaller than they are, so a packed cluster\n// shows as grains and not as a slab.\nconst RD = 1.6;\n\nexport function setup(params) {\n  params.s = {\n    n: 0, hue: 0, U: 0, e: 0.88,\n    x: new Float32Array(NMAX), z: new Float32Array(NMAX), vx: new Float32Array(NMAX), vz: new Float32Array(NMAX),\n    heat: new Float32Array(NMAX),\n    head: new Int32Array(16 * 33), next: new Int32Array(NMAX),\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// A fresh box: 85% of the grains packed in staggered rows from 52 LEDs up,\n// the rest scattered under them as a gas, so the first seconds already\n// show a cluster settling onto its gas rather than a heap waking up.\nfunction start(S, n) {\n  S.n = n;\n  const per = W / D;\n  let i = 0;\n  for (let r = 0; i \u003c n * 0.85; r++)\n    for (let c = 0; c \u003c per && i \u003c n; c++, i++) {\n      S.x[i] = R + c * D + (r & 1 ? R * 0.5 : 0);\n      S.z[i] = 52 + r * D * 0.9;\n      S.vx[i] = (Math.random() - 0.5) * 4;\n      S.vz[i] = 0;\n    }\n  for (; i \u003c n; i++) {\n    S.x[i] = R + Math.random() * (W - D);\n    S.z[i] = R + Math.random() * 44;\n    S.vx[i] = (Math.random() - 0.5) * 80;\n    S.vz[i] = (Math.random() - 0.5) * 80;\n  }\n  S.heat.fill(0);\n}\n\n// One substep. Grains collide as hard disks with restitution e along the\n// line of centres, found through a grid of cells one grain across; any\n// overlap left is pushed apart along the same line.\nfunction step(S, h) {\n  const { x, z, vx, vz, head, next, n, U, e } = S;\n  for (let i = 0; i \u003c n; i++) {\n    vz[i] -= GRAV * h;\n    x[i] += vx[i] * h;\n    z[i] += vz[i] * h;\n    if (z[i] \u003c R) {\n      z[i] = R;\n      const s = U - vz[i];\n      if (s > 0) {\n        vz[i] = U + E_FLOOR * s;\n        vx[i] += (Math.random() - 0.5) * 2 * ROUGH * s;\n      }\n    } else if (z[i] > ZTOP - R) {\n      z[i] = ZTOP - R;\n      if (vz[i] > 0) vz[i] = -E_WALL * vz[i];\n    }\n    if (x[i] \u003c R) (x[i] = R), (vx[i] = abs(vx[i]) * E_WALL);\n    else if (x[i] > W - R) (x[i] = W - R), (vx[i] = -abs(vx[i]) * E_WALL);\n  }\n  const CW = W / D, CH = 33;\n  head.fill(-1);\n  for (let i = 0; i \u003c n; i++) {\n    const c = cl(floor(z[i] / D), 0, CH - 1) * CW + cl(floor(x[i] / D), 0, CW - 1);\n    next[i] = head[c];\n    head[c] = i;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const cx = cl(floor(x[i] / D), 0, CW - 1), cz = cl(floor(z[i] / D), 0, CH - 1);\n    for (let gz = max(0, cz - 1); gz \u003c= min(CH - 1, cz + 1); gz++)\n      for (let gx = max(0, cx - 1); gx \u003c= min(CW - 1, cx + 1); gx++)\n        for (let j = head[gz * CW + gx]; j >= 0; j = next[j]) {\n          if (j \u003c= i) continue;\n          const dx = x[j] - x[i], dz = z[j] - z[i], d2 = dx * dx + dz * dz;\n          if (d2 >= D * D || d2 \u003c 1e-9) continue;\n          const d = sqrt(d2), nx = dx / d, nz = dz / d;\n          const vn = (vx[j] - vx[i]) * nx + (vz[j] - vz[i]) * nz;\n          if (vn \u003c 0) {\n            const J = (-(1 + e) * vn) / 2;\n            vx[i] -= J * nx;\n            vz[i] -= J * nz;\n            vx[j] += J * nx;\n            vz[j] += J * nz;\n          }\n          const o = (D - d) / 2;\n          x[i] -= o * nx;\n          z[i] -= o * nz;\n          x[j] += o * nx;\n          z[j] += o * nz;\n        }\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0.88, 320], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.U = U_PER * cl(kv[1] ?? 2, 0.5, 3);\n  S.e = cl(kv[2] ?? 0.88, 0.88, 0.98);\n  const n = round(cl(kv[3] ?? 320, 320, 440) / 10) * 10;\n  if (n !== S.n) start(S, n);\n  let vm = 0;\n  for (let i = 0; i \u003c S.n; i++) vm = max(vm, S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]);\n  const sub = min(48, max(1, ceil(d / SUBSTEP), ceil((d * (sqrt(vm) + 3 * S.U)) / REACH)));\n  for (let k = 0; k \u003c sub; k++) step(S, d / sub);\n  // Each grain's heat, its squared speed smoothed over 0.375 s.\n  const a = 1 - exp(-d / 0.375);\n  for (let i = 0; i \u003c S.n; i++) S.heat[i] += a * (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i] - S.heat[i]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, c = S.c, U2 = S.U * S.U;\n  rgb.fill(0);\n  for (let i = 0; i \u003c S.n; i++) {\n    // Heat on a log scale against the floor's speed: 0 for a grain moving\n    // at 1/18 of U or slower, 1 for one moving at U.\n    const heat = cl(log10(max(1e-6, S.heat[i] / U2)) / 2.5 + 1, 0, 1);\n    hsv(0.55 + S.hue + 0.38 * heat, 0.85 - 0.35 * heat, 1, c);\n    const px = S.x[i], py = ZTOP - S.z[i], gl = 0.4 * heat * heat, rr = RD + (gl > 0.02 ? 3 : 0.6), body = 0.7 + 0.3 * heat;\n    for (let y = max(0, floor(py - rr)); y \u003c= min(H - 1, floor(py + rr)); y++)\n      for (let x = max(0, floor(px - rr)); x \u003c= min(W - 1, floor(px + rr)); x++) {\n        const dd = sqrt((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2);\n        const v = body * cl(RD + 0.5 - dd, 0, 1) + gl * exp(-max(0, dd - RD) / 1.4), o = (y * W + x) * 3;\n        rgb[o] += c[0] * v;\n        rgb[o + 1] += c[1] * v;\n        rgb[o + 2] += c[2] * v;\n      }\n  }\n  // The floor, the bottom row, brighter the faster it strikes.\n  const fl = 0.25 + (0.2 * S.U) / (3 * U_PER);\n  for (let x = 0, o = (H - 1) * W * 3; x \u003c W; x++, o += 3) (rgb[o] += fl * 0.9), (rgb[o + 1] += fl * 0.9), (rgb[o + 2] += fl);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","hellschreiber":"// ===== Patternflow pattern =====\n// Title:   Hellschreiber\n// Family:  type\n// Idea:    A Hellschreiber receiver prints a radio message onto paper tape a column at a time and the tape is cut between words and pasted strip under strip on a slate form: each column of a letter comes in as tone on and off from the bottom up, and the turning helix prints it twice, one copy above the other, so when the receiver's clock runs slow or fast the line slides down or up the tape and wraps from one copy into the other while one whole copy can always be read, and noise, fading and static crashes print as speckle, pale letters and short dashes the eye reads past; when the seventh strip is full the form slides up a slot.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Hellschreiber (Rudolf Hell, patented 1929) and the Feld-Hell timing of 122.5 baud, 7 columns a letter and 2.5 letters a second, each column sent from the bottom up; bold 5 by 7 capitals drawn for this pattern; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Paper=0..1, Speed=0.2..3, Noise=0..1, Drift=-1..1\n//\n// Knob 1: Paper. Turns form, tape and ink round the wheel together: at 0 cream tape with navy ink on a slate blue form and a gold print head; at 0.25 pale mint tape with plum ink on a purple form; at 0.5 pale blue tape with olive ink on a brown form; at 0.75 pink tape with dark green ink on a green form.\n// Knob 2: Speed. Columns a second, 8.75 times the knob: Feld-Hell's 17.5 (2.5 letters) at 2, so a strip of nine letters takes 3.6 s; 1.75 at 0.2 and 26 at 3. The form slides up a slot in 0.45 s, faster above 2.\n// Knob 3: Noise. The band's noise against a signal of 1: 0.19 rms at 0, where 2% of the blank tape takes a grey speck, up to 0.56 at 1, where a quarter of it does and 29% of the ink drops out; with it the fading deepens from 12% to 57% and static crashes, 1.5 to 5 rows of solid ink, come from one in 170 columns to one in 15. Both copies are printed at the same instant, so every speck and crash is printed twice.\n// Knob 4: Drift. The receiver's clock against the sender's, from 4% fast at -1 to 4% slow at 1. At the opening 0.06 it is 0.24% slow and the line steps down one row about every strip, a whole copy over the seven strips of the form; at 1 it falls a whole copy every 25 columns, so the letters slant down the tape and each wraps from the lower copy into the upper one; turned below 0 the line climbs instead.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The face: 5 columns by 7 rows, rows from the top, drawn bold for\n// this pattern, the letters and figures the messages use. Feld-Hell sends a\n// letter as 7 columns, the glyph's 5 and 2 blank; a space here is 7 blank\n// columns. The upright strokes are two columns wide, so when the receiver\n// is out of phase and a glyph's lower rows land one column to the left of\n// its upper rows (the print's own slant, on a tape one LED a column), the\n// stroke still joins.\nconst FACE = {\n  A: \".###.##.####.#########.####.####.##\", B: \"####.##.####.######.##.####.######.\", C: \".######...##...##...##...##....####\",\n  D: \"####.##.####.####.####.####.######.\", E: \"#######...##...####.##...##...#####\", F: \"#######...##...####.##...##...##...\",\n  G: \".######...##...##.####.####.##.####\", H: \"##.####.####.#########.####.####.##\", I: \"####..##...##...##...##...##..####.\",\n  J: \"..###...##...##...##...####.##.###.\", K: \"##..###.######.###..####.##.####..#\", L: \"##...##...##...##...##...##...#####\",\n  M: \"#...###.########.#.##...##...##...#\", N: \"#...###..####.##.####..###...##...#\", O: \".###.##.####.####.####.####.##.###.\",\n  P: \"####.##.####.######.##...##...##...\", Q: \".###.##.####.####.#########.#..##.#\", R: \"####.##.####.######.####.##.####.##\",\n  S: \".######...##....###....##...######.\", T: \"#####.##...##...##...##...##...##..\", U: \"##.####.####.####.####.####.##.###.\",\n  V: \"##.####.####.####.####.##.###...#..\", W: \"#...##...##.#.##.#.########.###...#\", X: \"##.####.##.###...#...###.##.####.##\",\n  Y: \"##.####.##.###..##...##...##...##..\", Z: \"#####...##..##..##..##...##...#####\", 1: \".##..###...##...##...##...##..####.\",\n  2: \".###.##.##...##..##..##..##...#####\", 5: \"#######...####....##...####.##.###.\", 7: \"#####...##..##..##...##...##...##..\",\n  9: \".###.##.####.##.####...##..##..##..\", \".\": \"..........................##...##..\", \"-\": \"...............####................\",\n};\n\n// Each glyph as 5 column masks, bit r the row r counted from the bottom,\n// since every column is sent from the bottom up.\nconst GLYPH = {};\nfor (const k in FACE) {\n  const f = FACE[k], cols = [];\n  for (let c = 0; c \u003c 5; c++) {\n    let m = 0;\n    for (let r = 0; r \u003c 7; r++) if (f[(6 - r) * 5 + c] === \"#\") m |= 1 \u003c\u003c r;\n    cols.push(m);\n  }\n  GLYPH[k] = cols;\n}\n\n// ---- What is sent: the teleprinter test line, then the machine's own\n// numbers. A message starts a fresh strip of tape; inside one, a strip holds\n// whole words up to 9 letters and is cut in the space after the last.\nconst MESSAGES = [\"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG\", \"RUDOLF HELL 1929\", \"FELD-HELL 122.5 BAUD\", \"7 COLUMNS A LETTER\", \"2.5 CHARS A SECOND\"];\nconst CAP = 9;\n// The column stream of one round of the messages, and the plan of strips\n// as [first column, end column) in it: one blank column of tape before the\n// first glyph, one after the last. Messages are 14 blank columns apart.\nconst COLS = [], PLAN = [];\nfor (const msg of MESSAGES) {\n  const words = msg.split(\" \");\n  let line = [];\n  const flush = () => {\n    if (!line.length) return;\n    const start = COLS.length;\n    line.forEach((w, i) => {\n      if (i) for (let c = 0; c \u003c 7; c++) COLS.push(0);\n      for (const ch of w) {\n        for (const m of GLYPH[ch]) COLS.push(m);\n        COLS.push(0, 0);\n      }\n    });\n    PLAN.push([start - 1, COLS.length - 1]);\n    for (let c = 0; c \u003c 5; c++) COLS.push(0);\n    line = [];\n  };\n  for (const w of words) {\n    const n = line.reduce((a, x) => a + x.length + 1, 0) + w.length;\n    if (n > CAP) flush();\n    line.push(w);\n  }\n  flush();\n  for (let c = 0; c \u003c 7; c++) COLS.push(0);\n}\nconst L = COLS.length;\n\n// ---- The form: seven slots of 18 rows from row 1, each a strip of tape 16\n// rows high (a blank row, the 14 rows the helix prints, a blank row) and a\n// gap of 2 rows of form.\nconst SLOT = 18, TAPE = 16, SLOTS = 7;\n// Feld-Hell turns 17.5 columns a second, 2.5 letters of 7 columns.\nconst COLS_PER_S = 17.5;\n\nconst hash = (a, b) => {\n  let h = Math.imul(a, 374761393) + Math.imul(b, 668265263);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction gauss() {\n  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n}\n\nfunction newStrip(S) {\n  const [a, b] = PLAN[S.pi];\n  const base = S.cyc * L;\n  // The receiver keeps turning while the tape that is cut away runs out.\n  while (S.phi \u003c base + a) S.phi += S.rho;\n  S.strips.push({ id: S.made, x0: 1 + floor(hash(S.made, 7) * 3), end: base + b, len: 0, ink: new Float32Array(W * 7) });\n  S.made++;\n}\n\n// One turn of the helix: one column of tape, the signal from sender time\n// phi to phi + rho, its 7 rows printed twice, one copy above the other.\n// Row y of the column is what the helix hears a fraction (y + 1/2) / 7 of\n// the way through the turn; when rho is not 1 that drifts through the\n// sender's rows from turn to turn.\nfunction turn(S) {\n  const st = S.strips[S.strips.length - 1], rho = S.rho, k = st.len;\n  for (let y = 0; y \u003c 7; y++) {\n    const t = S.phi + (rho * (y + 0.5)) / 7, c = floor(t), r = floor((t - c) * 7);\n    const bit = (COLS[((c % L) + L) % L] >> r) & 1;\n    // Fading: a slow swell of two periods, 140 and 53 columns.\n    const fade = 1 - S.depth * (0.5 + 0.5 * sin((2 * PI * t) / 140 + 1.3 * sin((2 * PI * t) / 53)));\n    let a = bit * fade + S.sigma * gauss();\n    if (t >= S.c0 && t \u003c S.c1) a += S.ca;\n    st.ink[k * 7 + y] = cl((a - 0.3) / 0.45, 0, 1);\n  }\n  // A static crash: a burst of 1.5 to 5 rows, somewhere in the next turn.\n  if (Math.random() \u003c S.crash) {\n    S.c0 = S.phi + rho * (1 + Math.random());\n    S.c1 = S.c0 + 0.2 + 0.5 * Math.random();\n    S.ca = 0.8 + 0.6 * Math.random();\n  }\n  st.len++;\n  S.phi += rho;\n  // The strip is cut one blank column after its last glyph, or at the edge.\n  if (S.phi >= st.end || st.x0 + st.len >= W - 1) {\n    if (++S.pi === PLAN.length) (S.pi = 0), S.cyc++;\n    newStrip(S);\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    strips: [], made: 0, pi: 0, cyc: 0, phi: PLAN[0][0] - 0.06, rho: 1, acc: 0, scroll: 0, ready: false,\n    hue: 0, speed: 2, sigma: 0.2, crash: 0.01, depth: 0.1, c0: -1, c1: -1, ca: 0,\n    buf: new Float32Array(W * H * 3),\n  };\n  newStrip(params.s);\n  return params.s;\n}\n\nfunction knobs(S, k) {\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] ?? 2, 0.2, 3);\n  const n = cl(k[2] || 0, 0, 1), dr = cl(k[3] ?? 0.06, -1, 1);\n  S.sigma = 0.19 + 0.37 * n;\n  S.crash = 0.006 + 0.06 * n;\n  S.depth = 0.12 + 0.45 * n;\n  // The receiver's turn against the sender's column: up to 4% slow or fast.\n  S.rho = 1 + 0.04 * dr;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const d = cl(dt || 0, 0, 0.1);\n  knobs(S, input.knobValues || [0, 2, 0, 0.06]);\n  if (!S.ready) {\n    // The form opens with five strips already pasted.\n    S.ready = true;\n    while (S.strips.length \u003c 6) turn(S);\n  }\n  S.acc += (d * COLS_PER_S * S.speed) / 2;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    turn(S);\n  }\n  // When the seventh slot is full the form slides up a slot in 0.45 s and\n  // the top strip leaves it.\n  const target = max(0, S.strips.length - SLOTS);\n  S.scroll = min(target, S.scroll + d * 2.2 * max(1, S.speed / 2));\n  while (S.scroll >= 1) {\n    S.strips.shift();\n    S.scroll -= 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const h = S.hue, buf = S.buf;\n  const F = hsv(0.58 + h, 0.42, 0.4), R = hsv(0.58 + h, 0.32, 0.52), P = hsv(0.11 + h, 0.1, 0.97), I = hsv(0.66 + h, 0.8, 0.24);\n  const HD = hsv(0.12 + h, 0.55, 1);\n  // The form, with a ruled line in the middle of each gap.\n  const off = S.scroll * SLOT;\n  for (let y = 0; y \u003c H; y++) {\n    const ry = (((y + off - 17.5) % SLOT) + SLOT) % SLOT;\n    const C = ry \u003c 1 ? R : F;\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3;\n      buf[p] = C[0];\n      buf[p + 1] = C[1];\n      buf[p + 2] = C[2];\n    }\n  }\n  const last = S.strips.length - 1;\n  S.strips.forEach((st, j) => {\n    const Y = Math.round(1 + SLOT * (j - S.scroll));\n    if (Y > H || Y + TAPE + 1 \u003c 0) return;\n    const x1 = st.x0 + st.len;\n    // Shadow under and right of the pasted strip.\n    for (let y = Y + 1; y \u003c= Y + TAPE; y++)\n      for (let x = st.x0 + 1; x \u003c= x1; x++) {\n        if (y \u003c 0 || y >= H || x >= W) continue;\n        if (y === Y + TAPE || x === x1) {\n          const p = (y * W + x) * 3;\n          buf[p] *= 0.55;\n          buf[p + 1] *= 0.55;\n          buf[p + 2] *= 0.55;\n        }\n      }\n    for (let y = Y; y \u003c Y + TAPE; y++) {\n      if (y \u003c 0 || y >= H) continue;\n      const pr = Y + 14 - y, row = pr >= 0 && pr \u003c 14 ? pr % 7 : -1;\n      for (let x = st.x0; x \u003c x1; x++) {\n        const k = x - st.x0, ink = row >= 0 ? st.ink[k * 7 + row] : 0, f = 0.93 + 0.07 * hash(st.id * 64 + k, y - Y);\n        const p = (y * W + x) * 3;\n        buf[p] = P[0] * f * (1 - ink) + I[0] * ink;\n        buf[p + 1] = P[1] * f * (1 - ink) + I[1] * ink;\n        buf[p + 2] = P[2] * f * (1 - ink) + I[2] * ink;\n      }\n    }\n    if (j === last) {\n      // The print head at the next column: a bar over the tape, and the two\n      // points where the helix touches it, one turn's progress up the copy.\n      const hx = min(W - 1, x1), ph = floor(S.acc * 7);\n      for (let y = Y - 1; y \u003c= Y + TAPE; y++) {\n        if (y \u003c 0 || y >= H) continue;\n        const p = (y * W + hx) * 3, dot = y === Y + 14 - ph || y === Y + 7 - ph;\n        buf[p] = dot ? 1 : HD[0];\n        buf[p + 1] = dot ? 1 : HD[1];\n        buf[p + 2] = dot ? 1 : HD[2];\n      }\n    }\n  });\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * buf[p]) | 0, (255 * buf[p + 1]) | 0, (255 * buf[p + 2]) | 0);\n    }\n}\n","hexachordal-theorem":"// ===== Patternflow pattern =====\n// Title:   Hexachordal Theorem\n// Family:  rhythm\n// Idea:    Six onsets in a cycle of twelve pulses play in the upper ring and the other six, the complementary rhythm, in the lower one, so every pulse sounds in exactly one of them; each pair of onsets is a chord across its ring coloured by how many pulses apart they are, and between the rings the pairs are counted into bars, the first rhythm's standing up and the complement's hanging down, and once a cycle an onset steps onto the rest beside it, the chords and bars change and the bars stay mirror images, as the hexachordal theorem says they must.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hexachordal theorem, that six of the twelve pitch classes and the other six have the same interval content (Milton Babbitt, 1950s; David Lewin, Journal of Music Theory, 1959 and 1960), read as rhythm (Godfried Toussaint, The Geometry of Musical Rhythm, 2013); the opening set is 6-Z44 of Allen Forte's list (1973), the Schoenberg hexachord, whose complement is 6-Z19; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pulses=12..20, Uneven=0..3\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the first rhythm's onsets are pale amber and the complement's pale azure, and the distances 1 to 6 run yellow, green, sea green, azure, violet and pink; at 0.5 the onsets are pale blue and pale peach and the distances run blue, violet, rose, orange, yellow-green and sea green.\n// Knob 2: Speed. Pulses a second, twice the knob: 4 at 2, so a cycle of 12 takes 3 s and the rhythm moves once every 3 s; 0.4 at 0.2 (30 s a cycle), 6 at 3 (2 s). An onset that sounds swells, sends out a ring that widens to about 19 LEDs across as it fades, lights its chords and their blocks in the bars, and the light dies away in about 0.2 s.\n// Knob 3: Pulses. The length of the cycle in even steps, 12, 14, 16, 18 or 20, with half the pulses in each rhythm, so 6 to 10 columns for the distances 1 to n/2 and 15 to 45 pairs a rhythm. The theorem holds for any even cycle filled half and half: of the 924 ways to choose 6 pulses of 12, 552 have a complement that is no turn or mirror image of them, and the bars still match; of the 12,870 ways to choose 8 of 16, 10,768.\n// Knob 4: Uneven. Moves 0 to 3 onsets from the first rhythm to its complement, 5 against 7, 4 against 8 and 3 against 9 on twelve pulses, and the mirror breaks in the plainest way: the complement's bars grow by exactly 2 blocks a column for each onset moved, and the last column, the half cycle, by 1, the extra blocks drawn pale.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [(i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255, (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255, (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255];\n}\n\n// The first rhythm plays in the ring at the top, its complement in the ring\n// at the bottom, and between them each distance between two onsets of a\n// rhythm is a block in a bar: the first rhythm's bars stand up from the\n// middle row, the complement's hang down.\nconst RING = [[32, 20], [32, 108]], R = 15.5, UP = 59, DOWN = 68;\n\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\n\n// The interval vector: how many pairs of onsets lie each distance apart\n// round the cycle, distance being the shorter way, 1 to n/2. who is 1 for\n// the first rhythm, 0 for its complement.\nfunction pairsOf(memb, n, who) {\n  const m = n / 2, by = [];\n  for (let d = 0; d \u003c= m; d++) by.push([]);\n  for (let i = 0; i \u003c n; i++)\n    if (memb[i] === who)\n      for (let j = i + 1; j \u003c n; j++)\n        if (memb[j] === who) {\n          const d = min(j - i, n - j + i);\n          by[d].push([i, j]);\n        }\n  return by;\n}\n\nfunction rebuild(S) {\n  const n = S.n, m = n / 2, a = m - S.k;\n  S.memb = new Int8Array(n);\n  if (n === 12 && S.k === 0 && !S.opened) {\n    // The opening hexachord, x x x . . x x . . x . . as a rhythm. Its\n    // complement is no turn or mirror image of it, and has the same bars.\n    for (const s of [0, 1, 2, 5, 6, 9]) S.memb[s] = 1;\n    S.opened = true;\n  } else {\n    const idx = Array.from({ length: n }, (_, i) => i);\n    for (let i = n - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [idx[i], idx[j]] = [idx[j], idx[i]];\n    }\n    for (let i = 0; i \u003c a; i++) S.memb[idx[i]] = 1;\n  }\n  S.off = new Float32Array(n);\n  S.mt = new Float32Array(n).fill(-9);\n  S.flip = new Float32Array(n).fill(-9);\n  S.fl = new Float32Array(n);\n  S.last = -1;\n  count(S);\n  S.dA = S.vA.slice();\n  S.dB = S.vB.slice();\n}\n\nfunction count(S) {\n  S.pA = pairsOf(S.memb, S.n, 1);\n  S.pB = pairsOf(S.memb, S.n, 0);\n  S.vA = S.pA.map((l) => l.length);\n  S.vB = S.pB.map((l) => l.length);\n}\n\n// One move a cycle: an onset of the first rhythm and the rest beside it\n// change places, so one onset of each rhythm steps one pulse. The move that\n// changes the bars is taken where there is one, and never the one that\n// would undo the move before.\nfunction move(S) {\n  const n = S.n, cand = [];\n  for (let i = 0; i \u003c n; i++)\n    if (S.memb[i] === 1)\n      for (const j of [(i + 1) % n, (i + n - 1) % n])\n        if (S.memb[j] === 0 && !(S.last >= 0 && ((S.lastA === j && S.lastB === i) || (S.lastA === i && S.lastB === j)))) cand.push([i, j]);\n  if (!cand.length) return;\n  const before = S.vA.join();\n  const changing = cand.filter(([i, j]) => {\n    S.memb[i] = 0, S.memb[j] = 1;\n    const v = pairsOf(S.memb, n, 1).map((l) => l.length).join();\n    S.memb[i] = 1, S.memb[j] = 0;\n    return v !== before;\n  });\n  const pool = changing.length ? changing : cand;\n  const [i, j] = pool[floor(Math.random() * pool.length)];\n  S.memb[i] = 0;\n  S.memb[j] = 1;\n  // The dots slide the short way round, one pulse.\n  const dj = (i - j + n) % n === 1 ? 1 : -1;\n  S.off[j] = dj;\n  S.off[i] = -dj;\n  S.mt[i] = S.mt[j] = S.time;\n  S.last = 1;\n  S.lastA = j;\n  S.lastB = i;\n  count(S);\n}\n\n// Uneven moves onsets from the first rhythm to its complement, one change\n// of colour each.\nfunction balance(S) {\n  const n = S.n, want = n / 2 - S.k;\n  let a = 0;\n  for (let i = 0; i \u003c n; i++) a += S.memb[i];\n  while (a !== want) {\n    const from = a > want ? 1 : 0, opts = [];\n    for (let i = 0; i \u003c n; i++) if (S.memb[i] === from) opts.push(i);\n    const s = opts[floor(Math.random() * opts.length)];\n    S.memb[s] = 1 - from;\n    S.flip[s] = S.time;\n    a += from ? -1 : 1;\n  }\n  count(S);\n}\n\nexport function setup(params) {\n  params.hx = { n: 0, k: -1, P: 0, pulse: -1, time: 0, opened: false, buf: new Float32Array(N * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.hx) setup(params);\n  const S = params.hx, kv = input.knobValues || [0, 2, 12, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = 2 * round(cl(kv[2], 12, 20) / 2), k = round(cl(kv[3], 0, 3));\n  if (n !== S.n) {\n    S.n = n;\n    S.k = k;\n    rebuild(S);\n  } else if (k !== S.k) {\n    S.k = k;\n    balance(S);\n  }\n  S.time += dt;\n  S.P += dt * S.speed * 2;\n  const pulse = floor(S.P);\n  if (pulse !== S.pulse) {\n    S.pulse = pulse;\n    const s = pulse % S.n;\n    if (s === 0 && pulse > 0) move(S);\n    S.fl[s] = 1;\n  }\n  const decay = exp(-dt / cl(0.85 / (S.speed * 2), 0.14, 0.7)), ease = 1 - exp(-dt / 0.25);\n  for (let i = 0; i \u003c S.n; i++) S.fl[i] *= decay;\n  for (let d = 0; d \u003c S.vA.length; d++) {\n    S.dA[d] += (S.vA[d] - S.dA[d]) * ease;\n    S.dB[d] += (S.vB[d] - S.dB[d]) * ease;\n  }\n}\n\nfunction plot(buf, x, y, c, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = (y * W + x) * 3;\n  if (c[0] * a > buf[p]) buf[p] = c[0] * a;\n  if (c[1] * a > buf[p + 1]) buf[p + 1] = c[1] * a;\n  if (c[2] * a > buf[p + 2]) buf[p + 2] = c[2] * a;\n}\n\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5));\n  for (let i = 0; i \u003c= n; i++) plot(buf, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, c, a);\n}\n\nfunction disc(buf, cx, cy, r, c, a) {\n  for (let y = floor(cy - r - 1); y \u003c= cy + r + 1; y++)\n    for (let x = floor(cx - r - 1); x \u003c= cx + r + 1; x++) {\n      const d = sqrt((x - cx) ** 2 + (y - cy) ** 2);\n      plot(buf, x, y, c, a * cl(r + 0.5 - d, 0, 1));\n    }\n}\n\nfunction ring(buf, cx, cy, r, c, a) {\n  const n = max(24, floor(r * 7));\n  for (let i = 0; i \u003c n; i++) plot(buf, cx + r * cos((2 * PI * i) / n), cy + r * sin((2 * PI * i) / n), c, a);\n}\n\nfunction digit(buf, x, y, v, c, a) {\n  const s = String(v);\n  let w = 0;\n  for (const ch of s) w += ch === \"1\" && s.length > 1 ? 2 : 4;\n  let cx = x - floor((w - 1) / 2);\n  for (const ch of s) {\n    const g = DIG[+ch], narrow = ch === \"1\" && s.length > 1;\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\" && !(narrow && q !== 1)) plot(buf, cx + q - (narrow ? 1 : 0), y + r, c, a);\n    cx += narrow ? 2 : 4;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.hx;\n  if (!S || !S.memb) return;\n  const buf = S.buf, n = S.n, m = n / 2, h0 = S.hue, t = S.time;\n  buf.fill(0);\n  const cA = hsv(h0 + 0.11, 0.5, 1), cB = hsv(h0 + 0.58, 0.5, 1), grey = hsv(h0 + 0.6, 0.25, 0.32);\n  const cls = [];\n  for (let d = 0; d \u003c= m; d++) cls.push(hsv(h0 + 0.15 + (0.77 * (d - 1)) / max(1, m - 1), 0.78, 1));\n  // Where each step's dot is drawn: a dot that has just moved slides there\n  // over 0.35 s.\n  const pos = (s, which) => {\n    const u = cl((t - S.mt[s]) / 0.35, 0, 1), e = u * u * (3 - 2 * u), q = s + S.off[s] * (1 - e);\n    const a = -PI / 2 + (2 * PI * q) / n, C = RING[which];\n    return [C[0] + R * cos(a), C[1] + R * sin(a)];\n  };\n  const head = S.P - floor(S.P / n) * n;\n  for (let w = 0; w \u003c 2; w++) {\n    const who = w === 0 ? 1 : 0, C = RING[w], P = w === 0 ? S.pA : S.pB, col = w === 0 ? cA : cB;\n    // A soft light spreads from an onset as it sounds, so the beat answers\n    // between the two rings from across the room.\n    for (let s = 0; s \u003c n; s++)\n      if (S.memb[s] === who && S.fl[s] > 0.04) {\n        const [x, y] = pos(s, w), f = S.fl[s];\n        for (let yy = max(0, floor(y - 13)); yy \u003c= min(H - 1, y + 13); yy++)\n          for (let xx = max(0, floor(x - 13)); xx \u003c min(W, x + 13); xx++) {\n            const d2 = (xx - x) ** 2 + (yy - y) ** 2;\n            if (d2 \u003c 169) plot(buf, xx, yy, col, 0.3 * f * exp(-d2 / 45));\n          }\n      }\n    ring(buf, C[0], C[1], R, grey, 1);\n    // Every pair of onsets is a chord, coloured by its distance, and lights\n    // when either end of it sounds; the rest of the ring's chords brighten a\n    // little with it, so the ring that is playing reads at a glance.\n    let rf = 0;\n    for (let s = 0; s \u003c n; s++) if (S.memb[s] === who && S.fl[s] > rf) rf = S.fl[s];\n    for (let d = 1; d \u003c= m; d++)\n      for (const [i, j] of P[d]) {\n        const [x0, y0] = pos(i, w), [x1, y1] = pos(j, w), f = max(S.fl[i], S.fl[j]);\n        line(buf, x0, y0, x1, y1, cls[d], 0.26 + 0.2 * rf + 0.54 * f);\n      }\n    for (let s = 0; s \u003c n; s++) {\n      const [x, y] = pos(s, w), fu = cl((t - S.flip[s]) / 0.4, 0, 1);\n      if (S.memb[s] === who) {\n        const f = S.fl[s];\n        disc(buf, x, y, 2.1 + 1.2 * f, col, (0.62 + 0.38 * f) * (0.3 + 0.7 * fu));\n        if (f > 0.05) ring(buf, x, y, 3 + 7 * (1 - f), col, 0.8 * f);\n      } else plot(buf, x, y, grey, 1.6);\n    }\n    // The beat, going round both rings at once with a tail one pulse long.\n    for (let j = 0; j \u003c= 16; j++) {\n      const a = -PI / 2 + (2 * PI * (head - j / 16)) / n;\n      plot(buf, C[0] + (R + 3) * cos(a), C[1] + (R + 3) * sin(a), [255, 255, 255], 0.9 * (1 - j / 17));\n    }\n    {\n      const a = -PI / 2 + (2 * PI * head) / n;\n      disc(buf, C[0] + (R + 3) * cos(a), C[1] + (R + 3) * sin(a), 0.9, [255, 255, 255], 0.9);\n    }\n  }\n  // The bars. Each block is one pair of onsets, the pairs of a distance\n  // stacked in order of their first onset; a block lights with its chord.\n  const slot = floor(62 / m), bw = slot - 2, x00 = floor((W - slot * m) / 2) + floor((slot - bw) / 2);\n  const hu = max(1, min(3, floor(19 / (m + S.k))));\n  for (let d = 1; d \u003c= m; d++) {\n    const x0 = x00 + (d - 1) * slot;\n    digit(buf, x0 + floor((bw - 1) / 2), 61, d, grey, 1.9);\n    for (let w = 0; w \u003c 2; w++) {\n      const v = w === 0 ? S.dA[d] : S.dB[d], P = w === 0 ? S.pA[d] : S.pB[d], other = w === 0 ? S.dB[d] : S.dA[d];\n      for (let b = 0; b \u003c Math.ceil(v - 0.02); b++) {\n        const part = min(1, v - b), pr = P[b], f = pr ? max(S.fl[pr[0]], S.fl[pr[1]]) : 0;\n        // Where one rhythm has more pairs than the other, the extra blocks\n        // are drawn pale: with Uneven at k they come to 2k in every column\n        // but the last, where they are k.\n        const extra = b >= other - 0.02, c = extra ? hsv(h0 + 0.6, 0.12, 1) : cls[d];\n        const rows = hu >= 2 ? hu - 1 : 1;\n        for (let r = 0; r \u003c rows * part; r++) {\n          const y = w === 0 ? UP - b * hu - r : DOWN + b * hu + r;\n          for (let x = x0; x \u003c x0 + bw; x++) plot(buf, x, y, c, (extra ? 0.55 : 0.5) + 0.5 * f);\n        }\n      }\n      // The count itself at the end of the bar, the interval vector read\n      // off one digit a column.\n      const tip = max(0, v) * hu, cnt = w === 0 ? S.vA[d] : S.vB[d];\n      digit(buf, x0 + floor((bw - 1) / 2), w === 0 ? round(UP - tip - 5) : round(DOWN + tip + 1), cnt, cls[d], 0.55);\n    }\n  }\n  for (let p = 0, i = 0; p \u003c N; p++, i += 3) display.setPixel(p % W, (p / W) | 0, 3 + buf[i], 4 + buf[i + 1], 10 + buf[i + 2]);\n}\n","ink-traps":"// ===== Patternflow pattern =====\n// Title:   Ink Traps\n// Family:  type\n// Idea:    Each sheet of newsprint is printed with one capital or figure twice, the upper one with ink traps cut into its joints and the lower one as drawn, and the ink then soaks out from the strokes into the paper, furthest where two strokes meet at a sharp angle, so the plain letter's crotches fill and its counters close while the trapped letter's notches fill back to the joints as they were drawn; then the sheet feeds up and the next letter is printed.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: ink traps as Matthew Carter cut them into Bell Centennial, drawn for AT&T's telephone directories at 6 point on newsprint and released by Mergenthaler Linotype in 1978; the wicking front that advances as the square root of time (Edward W. Washburn, 1921); pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Letters=0..2, Spread=-1..1\n//\n// Knob 1: Hue. The colour of the paper, the ink staying black: telephone-directory yellow (182, 164, 69) at 0, green at 0.25, blue at 0.5, pink at 0.75.\n// Knob 2: Speed. At 2 a sheet takes 6.4 s: the ink soaks for 3 s, its edge moving out as the square root of the time, the sheet holds 2.6 s and feeds up in 0.8 s. At 0.2 a sheet takes 64 s, at 3 it takes 4.3 s.\n// Knob 3: Letters. Which letters come round: 0 M, W, N and V (3, 3, 2 and 1 traps), 1 K, A, X, Y and Z, 2 the figures 4, 7 and 1. A new set feeds a fresh sheet at once.\n// Knob 4: Spread. How far the ink soaks. At the opening 0.06 the edge of a stroke moves out 1.5 LEDs, the spread the traps are cut for: every trapped joint prints within a LED of where it was drawn and the plain M's joints fill 6 to 12 LEDs out. At -1 the edge moves 0.5 LED, the plain M's joints fill 3 to 6 LEDs and the traps stay open as notches 4 to 8 LEDs deep. From 0.5 (2.1 LEDs) the traps fill shut and both letters clog alike, and at 1 (2.7 to 3 LEDs) the M's sharpest joints fill 20 LEDs out. Turning it down feeds a fresh sheet.\n\n// Bell Centennial (Matthew Carter for AT&T, 1978) was cut for 6 point type\n// printed fast on newsprint. Ink spreads into newsprint, and where two\n// strokes meet at a sharp angle the paper between them is near ink on both\n// sides, so the joint fills first and the letter clogs. Carter cut notches\n// into those joints, ink traps, so that the spreading ink fills the notch\n// and the joint comes out the way it was drawn. At display size the traps\n// show; at 6 point they fill.\n//\n// Here the panel is a magnifier, and the letters are plain straight-sided\n// capitals drawn for it, not Bell Centennial's own. The ink is a\n// concentration that diffuses into the paper, faster along the fibres,\n// which lie along the rows, and the paper turns dark wherever the\n// concentration passes 0.12. The variance of\n// the spread grows in proportion to the time, so the edge of a stroke moves\n// out as the square root of the time, the way a liquid wicks into a porous\n// sheet (Washburn, 1921). A straight edge moves out about 1.18 standard\n// deviations; a sharp corner fills further, since both strokes feed it.\n//\n// Each trap is the joint's own wedge pushed back into the ink by\n// D = 1.6 * (edge advance) / sin(half the angle), its sides then running\n// back to the drawn edges over the same length D. If every edge moved out\n// by the same distance, a factor of 1 would print the joint exactly where\n// it was drawn. Diffusion fills a sharp corner further than that, and 1.6\n// was found by printing the eleven joints of M, W, N and A at the opening\n// spread: at 1 every trap fills shut and the joint prints like the plain\n// one, 12 LEDs out on the M; at 1.4 some print within 1.5 LEDs and some\n// fill shut; at 1.6 all eleven print within a LED of the drawn vertex,\n// against 3.4 to 13.3 LEDs out for the plain letter; at 1.8 the notches\n// stay open 1 to 4 LEDs deep.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sin, cos, tan, exp, round, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The letters, drawn as convex pieces in a box 50 LEDs wide and 58\n// tall, x to the right and y down: R is a rectangle, P any convex polygon.\nconst GW = 50, GH = 58, GX = 7, GY = [2, 68];\nconst P = (...c) => {\n  const p = [];\n  for (let i = 0; i \u003c c.length; i += 2) p.push([c[i], c[i + 1]]);\n  let a = 0;\n  for (let i = 0; i \u003c p.length; i++) {\n    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % p.length];\n    a += x0 * y1 - x1 * y0;\n  }\n  return { p, o: a > 0 ? 1 : -1 };\n};\nconst R = (x0, y0, x1, y1) => P(x0, y0, x1, y0, x1, y1, x0, y1);\nconst GLYPHS = {\n  M: [R(0, 0, 10, 58), R(40, 0, 50, 58), P(0, 0, 11, 0, 30.5, 50, 19.5, 50), P(39, 0, 50, 0, 30.5, 50, 19.5, 50)],\n  W: [P(0, 0, 9, 0, 17.5, 58, 8.5, 58), P(20.5, 0, 29.5, 0, 17.5, 58, 8.5, 58), P(20.5, 0, 29.5, 0, 41.5, 58, 32.5, 58), P(41, 0, 50, 0, 41.5, 58, 32.5, 58)],\n  N: [R(0, 0, 10, 58), R(40, 0, 50, 58), P(0, 0, 12, 0, 50, 58, 38, 58)],\n  V: [P(0, 0, 11, 0, 30.5, 58, 19.5, 58), P(39, 0, 50, 0, 30.5, 58, 19.5, 58)],\n  K: [R(0, 0, 10, 58), P(36, 0, 50, 0, 6, 41, 6, 28.5), P(13, 24, 24, 24, 50, 58, 37, 58)],\n  A: [P(19.5, 0, 30.5, 0, 11, 58, 0, 58), P(19.5, 0, 30.5, 0, 50, 58, 39, 58), R(9, 36, 41, 44)],\n  X: [P(0, 0, 11, 0, 50, 58, 39, 58), P(39, 0, 50, 0, 11, 58, 0, 58)],\n  Y: [P(0, 0, 11, 0, 30, 32, 20, 32), P(39, 0, 50, 0, 30, 32, 20, 32), R(20, 30, 30, 58)],\n  Z: [R(0, 0, 50, 10), R(0, 48, 50, 58), P(36, 10, 50, 10, 14, 48, 0, 48)],\n  4: [R(31, 0, 41, 58), P(28, 0, 41, 0, 13, 37, 0, 37), R(0, 35, 50, 44)],\n  7: [R(0, 0, 50, 10), P(43, 0, 55, 0, 26, 58, 14, 58)],\n  1: [R(26, 0, 37, 58), P(31, 0, 31, 11, 13, 22, 9, 15)],\n};\nconst SETS = [[\"M\", \"W\", \"N\", \"V\"], [\"K\", \"A\", \"X\", \"Y\", \"Z\"], [\"4\", \"7\", \"1\"]];\n\nfunction inPoly(q, x, y) {\n  const p = q.p, n = p.length;\n  for (let i = 0; i \u003c n; i++) {\n    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % n];\n    if (q.o * ((x1 - x0) * (y - y0) - (y1 - y0) * (x - x0)) \u003c -1e-9) return false;\n  }\n  return true;\n}\nfunction ink(g, x, y) {\n  if (x \u003c 0 || x > GW || y \u003c 0 || y > GH) return false;\n  for (const q of g) if (inPoly(q, x, y)) return true;\n  return false;\n}\n\n// The joints: where an edge of one piece crosses an edge of another on the\n// outline of the letter and the paper between them is a wedge narrower than\n// 84 degrees.\nfunction crotches(g) {\n  const out = [];\n  for (let i = 0; i \u003c g.length; i++)\n    for (let j = i + 1; j \u003c g.length; j++)\n      for (let a = 0; a \u003c g[i].p.length; a++)\n        for (let b = 0; b \u003c g[j].p.length; b++) {\n          const [ax, ay] = g[i].p[a], [ax1, ay1] = g[i].p[(a + 1) % g[i].p.length];\n          const [bx, by] = g[j].p[b], [bx1, by1] = g[j].p[(b + 1) % g[j].p.length];\n          const dax = ax1 - ax, day = ay1 - ay, dbx = bx1 - bx, dby = by1 - by;\n          const den = dax * dby - day * dbx;\n          if (abs(den) \u003c 1e-9) continue;\n          const t = ((bx - ax) * dby - (by - ay) * dbx) / den, s = ((bx - ax) * day - (by - ay) * dax) / den;\n          if (t \u003c -1e-6 || t > 1 + 1e-6 || s \u003c -1e-6 || s > 1 + 1e-6) continue;\n          const vx = ax + t * dax, vy = ay + t * day;\n          if (vx \u003c 0.5 || vx > GW - 0.5 || vy \u003c 0.5 || vy > GH - 0.5) continue;\n          let paper = 0, sx = 0, sy = 0;\n          for (let k = 0; k \u003c 96; k++) {\n            const th = ((k + 0.5) / 96) * 2 * PI, cx = cos(th), cy = sin(th);\n            if (!ink(g, vx + 1.5 * cx, vy + 1.5 * cy)) paper++, (sx += cx), (sy += cy);\n          }\n          const deg = (paper / 96) * 360;\n          if (deg \u003c 8 || deg > 84) continue;\n          if (out.some((c) => abs(c.x - vx) + abs(c.y - vy) \u003c 1.5)) continue;\n          const l = hypot(sx, sy);\n          out.push({ x: vx, y: vy, bx: sx / l, by: sy / l, a: (deg * PI) / 180 });\n        }\n  return out;\n}\n\n// ---- Paper: hash value noise, stretched along the rows the way newsprint\n// fibres lie along the web.\nconst hash = (a, b, c) => {\n  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  h = Math.imul(h ^ (h >>> 16), 2246822519);\n  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n};\nfunction vn(x, y, k) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);\n  const a = hash(x0, y0, k), b = hash(x0 + 1, y0, k), c = hash(x0, y0 + 1, k), d = hash(x0 + 1, y0 + 1, k);\n  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n}\nconst K0 = 0.16;\nfunction makeSheet(seed) {\n  const F = new Float32Array(N), kh = new Float32Array(N), kv = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) F[y * W + x] = cl(0.5 + 0.7 * (vn(x / 6, y / 1.4, seed) - 0.5) + 0.5 * (vn(x / 2.2, y / 0.9, seed + 7) - 0.5), 0, 1);\n  let mh = 0, mv = 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      kh[i] = x \u003c W - 1 ? K0 * 1.15 * (0.55 + 0.45 * (F[i] + F[i + 1])) : 0;\n      kv[i] = y \u003c H - 1 ? K0 * 0.85 * (0.55 + 0.45 * (F[i] + F[i + W])) : 0;\n      mh += kh[i];\n      mv += kv[i];\n    }\n  return { F, kh, kv, step: (mh + mv) / N };\n}\n\n// ---- Timing at Speed 2, in seconds. The ink: the standard deviation of\n// the spread the traps are cut for (1.28 LEDs, an edge advance of 1.5), the\n// concentration at which paper turns dark, and how many standard\n// deviations a straight edge moves out at that concentration.\nconst T_SOAK = 3, T_HOLD = 2.6, T_FEED = 0.8;\nconst TRAPK = 1.6, SIGN = 1.28, TAU = 0.12, ZT = 1.175;\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.sheets = [makeSheet(11), makeSheet(23)];\n  s.u = new Float32Array(N);\n  s.du = new Float32Array(N);\n  s.cr = {};\n  s.set = -1;\n  s.li = 0;\n  s.p = 0;\n  s.phase = 0;\n  s.age = 0;\n  s.done = 0;\n  s.struck = false;\n}\n\nfunction strike(s, ch) {\n  const g = GLYPHS[ch];\n  if (!s.cr[ch])\n    s.cr[ch] = crotches(g).map((c) => {\n      const D = (TRAPK * ZT * SIGN) / sin(c.a / 2);\n      return { ...c, t: tan(c.a / 2), D, Lr: D };\n    });\n  const cr = s.cr[ch], u = s.u;\n  u.fill(0);\n  for (let half = 0; half \u003c 2; half++) {\n    const oy = GY[half];\n    for (let y = 0; y \u003c GH + 1; y++)\n      for (let x = 0; x \u003c GW + 1; x++) {\n        let c = 0;\n        for (let j = 0; j \u003c 4; j++)\n          for (let i = 0; i \u003c 4; i++) {\n            const px = x + (i + 0.5) / 4, py = y + (j + 0.5) / 4;\n            if (!ink(g, px, py)) continue;\n            let trap = false;\n            if (half === 0)\n              for (const t of cr) {\n                const dx = px - t.x, dy = py - t.y, A = dx * t.bx + dy * t.by + t.D, w = abs(dx * t.by - dy * t.bx);\n                if (A > 0 && A \u003c t.D + t.Lr && w \u003c A * t.t - t.D * t.t * max(0, (A - t.D) / t.Lr)) {\n                  trap = true;\n                  break;\n                }\n              }\n            if (!trap) c++;\n          }\n        const X = GX + x, Y = oy + y;\n        if (X \u003c W && Y \u003c H) u[Y * W + X] = c / 16;\n      }\n  }\n  s.done = 0;\n  s.age = 0;\n  s.struck = true;\n}\n\nfunction diffuse(s, f) {\n  const { u, du } = s, sh = s.sheets[s.p], kh = sh.kh, kv = sh.kv;\n  du.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const a = u[i];\n    if (kh[i]) {\n      const q = kh[i] * (u[i + 1] - a) * f;\n      du[i] += q;\n      du[i + 1] -= q;\n    }\n    if (kv[i]) {\n      const q = kv[i] * (u[i + W] - a) * f;\n      du[i] += q;\n      du[i + W] -= q;\n    }\n  }\n  for (let i = 0; i \u003c N; i++) u[i] += du[i];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const rate = cl(k[1], 0.2, 3) / 2;\n  const set = round(cl(k[2] || 0, 0, 2));\n  const k4 = cl(k[3] || 0, -1, 1) - 0.06, sig = SIGN * exp(k4 * (k4 \u003c 0 ? 1 : 0.56));\n  if (!s.struck) {\n    s.set = set;\n    strike(s, SETS[set][0]);\n  }\n  if (set !== s.set && s.phase === 0) {\n    s.set = set;\n    s.li = -1;\n    s.phase = 1;\n    s.feed = 0;\n  }\n  if (s.phase === 0) {\n    s.age += dt * rate;\n    const want = sig * sig * min(1, s.age / T_SOAK), st = s.sheets[s.p].step;\n    let need = want - s.done, n = 0;\n    while (need > 1e-4 && n \u003c 16) {\n      const f = min(1, need / st);\n      diffuse(s, f);\n      s.done += f * st;\n      need -= f * st;\n      n++;\n    }\n    // A sheet soaked past what the knob now asks for cannot unsoak: feed\n    // a fresh one.\n    if (s.age > T_SOAK + T_HOLD || (s.age > 0.3 && sig * sig \u003c 0.7 * s.done)) (s.phase = 1), (s.feed = 0);\n  } else {\n    s.feed += (dt * rate) / T_FEED;\n    if (s.feed >= 1) {\n      s.phase = 0;\n      s.p ^= 1;\n      const L = SETS[s.set];\n      s.li = (s.li + 1) % L.length;\n      strike(s, L[s.li]);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.struck) return;\n  const paper = hsv(0.14 + s.hue, 0.62, 182), INK = [4, 4, 8];\n  const e = s.phase === 1 ? s.feed * s.feed * (3 - 2 * s.feed) : 0, off = round(e * H);\n  const A = s.sheets[s.p], B = s.sheets[s.p ^ 1], u = s.u;\n  for (let y = 0; y \u003c H; y++) {\n    const sy = y + off, old = sy \u003c H, row = old ? sy : sy - H, F = old ? A.F : B.F;\n    const seam = s.phase === 1 && (sy === H - 1 || sy === H) ? 0.6 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const i = row * W + x, f = F[i];\n      const pb = (0.93 + 0.12 * (f - 0.5)) * seam;\n      let d = 0;\n      if (old) {\n        const v = u[i] + 0.04 * (f - 0.5);\n        d = cl((v - (TAU - 0.05)) / 0.1, 0, 1);\n        d = d * d * (3 - 2 * d);\n      }\n      display.setPixel(x, y, round(paper[0] * pb * (1 - d) + INK[0] * d), round(paper[1] * pb * (1 - d) + INK[1] * d), round(paper[2] * pb * (1 - d) + INK[2] * d));\n    }\n  }\n}\n","laguerre-cells":"// ===== Patternflow pattern =====\n// Title:   Laguerre Cells\n// Family:  cells\n// Idea:    Points scattered over the panel each own a Laguerre cell, the LEDs where |x - p|^2 - w is least, and Newton steps on the Kantorovich dual move the weights w until every cell holds the same share of a density that glows in three soft bumps, so the cells shrink to a fine mesh where it is dense and swell where it is thin while their edges stay straight; each cell is tinted by its mass error, violet while it holds too much and green while it holds too little, and every few seconds the bumps move and the cells chase them again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: power diagrams (Franz Aurenhammer, 1987), the Laguerre-Voronoi diagram of the power distance; cells of prescribed mass found by minimising a convex function of the weights (Aurenhammer, Hoffmann and Aronov, 1998); the damped Newton method for semi-discrete optimal transport (Jun Kitagawa, Quentin Mérigot and Boris Thibert, 2019); pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cells=24..64, Contrast=-1..1\n//\n// Knob 1: Hue. Turns three colours round the wheel together, a settled cell in the middle and a cell holding too much and too little 0.24 either side: at 0 teal, violet and green, at 0.25 violet, red and cyan, at 0.5 red, chartreuse and violet.\n// Knob 2: Speed. Each frame the weights take a share of the full Newton step, 1.5 times Speed a second, so at 2 a cell's error falls by a factor e every 0.33 s: the opening Voronoi diagram, whose fullest cell holds four times its share, is within 5% at 1.5 s and 2% at 2 s. A density holds 6 s and turns into the next in 1.6 s, the first at 4.4 s, while its bumps drift 2 LEDs round. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Cells. 24 to 64 sites, scattered as the best of 24 random tries each; each whole step scatters a new set, starting from weights of 0. At 24 the largest settled cell is about 1,000 LEDs and the smallest under 100; at 64, 400 and 31.\n// Knob 4: Contrast. The densest LED against the thinnest: 3 to 1 at -1, 12 to 1 at the opening 0.06, 40 to 1 at 1. At -1 the 24 settled cells run from 173 to 510 LEDs, at 1 from 58 to 1,350, and the cells away from the bumps grow spikes that reach between them.\n\n// A power diagram gives each site p_i a weight w_i and each point x to the\n// site with the least power |x - p_i|^2 - w_i. Two cells meet on a straight\n// line, where the powers are equal, and raising w_i pushes that line away\n// from p_i by (dw)/(2|p_i - p_j|). With all weights equal it is the Voronoi\n// diagram. Aurenhammer, Hoffmann and Aronov showed that for any sites and\n// any masses there are weights that give every cell its mass, the minimum\n// of a convex function of the weights; that is the semi-discrete optimal\n// transport of the density onto the sites with the cost |x - p|^2.\n//\n// The gradient of the dual is each cell's missing mass, m - mass_i, and its\n// Hessian the matrix of edges: for cells i and j, the density along their\n// common edge over 2|p_i - p_j|. An LED within half an LED of an edge\n// splits its mass between the two cells by how far it lies across, which\n// makes the mass move smoothly with the weights and gives those edge sums.\n// Each frame conjugate gradients solve the Newton step and the weights take\n// a share of it, so the errors fall smoothly enough to watch.\n//\n// A cell need not hold its own site. On this panel with 24 sites, 11 lie\n// outside their settled cells at the opening density and 17 after the\n// first change; with 64 sites it is 48 to 53.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, cos, sin, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v, o, k) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst MAXC = 64;\n// Blocks of 8 by 8 LEDs, each with the sites that can own or border one of\n// its LEDs.\nconst B = 8, BX = W / B, BY = H / B;\n// Seconds at Speed 2: a density holds, then turns into the next.\nconst T_HOLD = 6, T_MORPH = 1.6, T_FIRST = 4.4;\n\nfunction newSites(s, n) {\n  s.n = n;\n  const X = s.px, Y = s.py;\n  // Best candidate: each new site the farthest of 24 tries from the others.\n  for (let i = 0; i \u003c n; i++) {\n    let bx = 0, by = 0, bd = -1;\n    for (let t = 0; t \u003c 24; t++) {\n      const x = 2 + Math.random() * (W - 4), y = 2 + Math.random() * (H - 4);\n      let d = 1e9;\n      for (let j = 0; j \u003c i; j++) d = min(d, (x - X[j]) ** 2 + (y - Y[j]) ** 2);\n      if (d > bd) (bd = d), (bx = x), (by = y);\n    }\n    X[i] = bx;\n    Y[i] = by;\n  }\n  s.w.fill(0);\n}\n\n// A density: three soft bumps, a log-density f from 0 to 1 that the\n// Contrast knob raises to a ratio of densest to thinnest.\nfunction newBumps() {\n  const b = [];\n  for (let k = 0; k \u003c 3; k++)\n    b.push({ x: 8 + Math.random() * (W - 16), y: 10 + Math.random() * (H - 20), r: 9 + Math.random() * 9, a: k ? 0.55 + 0.45 * Math.random() : 1, ph: Math.random() * 2 * PI });\n  return b;\n}\n\nexport function setup(params) {\n  const s = (params.s = {});\n  s.px = new Float64Array(MAXC);\n  s.py = new Float64Array(MAXC);\n  s.w = new Float64Array(MAXC);\n  s.mass = new Float64Array(MAXC);\n  s.err = new Float64Array(MAXC);\n  s.Hm = new Float64Array(MAXC * MAXC);\n  s.rho = new Float32Array(N);\n  s.f = new Float32Array(N);\n  s.own = new Uint8Array(N);\n  s.line = new Float32Array(N);\n  s.cand = new Uint8Array(BX * BY * MAXC);\n  s.cnt = new Uint8Array(BX * BY);\n  s.cg = [new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC)];\n  s.n = 0;\n  s.A = newBumps();\n  s.Bm = newBumps();\n  s.clock = 0;\n  s.next = T_FIRST;\n  s.morph = -1;\n  s.t = 0;\n}\n\nfunction density(s, lnR) {\n  const { rho, f } = s, A = s.A, Bm = s.Bm;\n  const m = s.morph \u003c 0 ? 0 : s.morph * s.morph * (3 - 2 * s.morph);\n  const bs = A.map((a, k) => {\n    const b = Bm[k], dr = 2;\n    return {\n      x: a.x + (b.x - a.x) * m + dr * cos(s.t * 0.3 + a.ph),\n      y: a.y + (b.y - a.y) * m + dr * sin(s.t * 0.22 + a.ph),\n      r: a.r + (b.r - a.r) * m,\n      a: a.a + (b.a - a.a) * m,\n    };\n  });\n  // Each bump is a product of a row and a column Gaussian, and exp(lnR f)\n  // is read from a table of 1025 steps.\n  const gx = s.gx || (s.gx = new Float32Array(3 * W)), gy = s.gy || (s.gy = new Float32Array(3 * H));\n  bs.forEach((b, k) => {\n    const q = 1 / (2 * b.r * b.r);\n    for (let x = 0; x \u003c W; x++) gx[k * W + x] = b.a * exp(-((x + 0.5 - b.x) ** 2) * q);\n    for (let y = 0; y \u003c H; y++) gy[k * H + y] = exp(-((y + 0.5 - b.y) ** 2) * q);\n  });\n  const lut = s.lut || (s.lut = new Float32Array(1025));\n  for (let j = 0; j \u003c= 1024; j++) lut[j] = exp((lnR * j) / 1024);\n  let tot = 0;\n  for (let y = 0; y \u003c H; y++) {\n    const a0 = gy[y], a1 = gy[H + y], a2 = gy[2 * H + y];\n    for (let x = 0; x \u003c W; x++) {\n      const v = min(1, a0 * gx[x] + a1 * gx[W + x] + a2 * gx[2 * W + x]), i = y * W + x;\n      f[i] = v;\n      tot += rho[i] = lut[round(v * 1024)];\n    }\n  }\n  return tot;\n}\n\n// Power distance |x - p|^2 - w for every LED: the owner, the runner-up and\n// how far the LED is from their common edge, in LEDs. An LED within half an\n// LED of the edge splits its mass between the two, so a cell's mass moves\n// smoothly with the weights, and the same LEDs give the derivatives.\nfunction assign(s) {\n  const { px, py, w, n, cand, cnt, rho, own, line, mass, Hm } = s;\n  let wmax = -1e9;\n  for (let i = 0; i \u003c n; i++) wmax = max(wmax, w[i]);\n  const r = B * 0.7072;\n  for (let by = 0; by \u003c BY; by++)\n    for (let bx = 0; bx \u003c BX; bx++) {\n      const cx = bx * B + B / 2, cy = by * B + B / 2, blk = by * BX + bx;\n      let U = 1e18;\n      const dc = s.cg[4];\n      for (let i = 0; i \u003c n; i++) {\n        const d = sqrt((px[i] - cx) ** 2 + (py[i] - cy) ** 2);\n        dc[i] = d;\n        U = min(U, (d + r) ** 2 - w[i]);\n      }\n      const reach = sqrt(max(0, U + wmax));\n      let c = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const lb = max(0, dc[i] - r) ** 2 - w[i];\n        if (lb - U \u003c 2 * (reach + dc[i] + r) + 1) cand[blk * MAXC + c++] = i;\n      }\n      cnt[blk] = c;\n    }\n  mass.fill(0, 0, n);\n  Hm.fill(0, 0, MAXC * MAXC);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const blk = (y >> 3) * BX + (x >> 3), c = cnt[blk], o = blk * MAXC;\n      const X = x + 0.5, Y = y + 0.5;\n      let b1 = 0, b2 = 0, d1 = 1e18, d2 = 1e18;\n      for (let k = 0; k \u003c c; k++) {\n        const i = cand[o + k], d = (X - px[i]) ** 2 + (Y - py[i]) ** 2 - w[i];\n        if (d \u003c d1) (d2 = d1), (b2 = b1), (d1 = d), (b1 = i);\n        else if (d \u003c d2) (d2 = d), (b2 = i);\n      }\n      const p = y * W + x, q = rho[p];\n      own[p] = b1;\n      let gap = 99;\n      if (c > 1) {\n        const sep = 2 * sqrt((px[b1] - px[b2]) ** 2 + (py[b1] - py[b2]) ** 2);\n        gap = (d2 - d1) / sep;\n        if (gap \u003c 0.5) {\n          const sh = 0.5 + gap, h = q / sep;\n          mass[b1] += q * sh;\n          mass[b2] += q * (1 - sh);\n          Hm[b1 * MAXC + b1] += h;\n          Hm[b2 * MAXC + b2] += h;\n          Hm[b1 * MAXC + b2] -= h;\n          Hm[b2 * MAXC + b1] -= h;\n        } else mass[b1] += q;\n      } else mass[b1] += q;\n      line[p] = gap;\n    }\n}\n\n// Newton on the Kantorovich dual: the gradient is each cell's missing mass,\n// the Hessian the matrix of edge densities just gathered. Conjugate\n// gradients solve H d = (m - mass); the weights move a damped share of d.\nfunction newton(s, m, step) {\n  const { n, Hm, w, mass, err } = s;\n  const [r, z, p, Ap] = s.cg;\n  let typ = 0, cntH = 0;\n  for (let i = 0; i \u003c n; i++) if (Hm[i * MAXC + i] > 0) (typ += Hm[i * MAXC + i]), cntH++;\n  typ = cntH ? typ / cntH : 1;\n  const eps = 1e-4 * typ;\n  for (let i = 0; i \u003c n; i++) {\n    err[i] = mass[i] / m - 1;\n    r[i] = m - mass[i];\n    // A cell with no edge in use yet gets a diagonal, so it grows back.\n    if (Hm[i * MAXC + i] \u003c= 0) Hm[i * MAXC + i] = 0.3 * typ;\n  }\n  const dw = s.dw || (s.dw = new Float64Array(MAXC));\n  dw.fill(0, 0, n);\n  const pre = (i) => 1 / (Hm[i * MAXC + i] + eps);\n  // The matrix as lists of each cell's neighbours, about six apiece.\n  const nb = s.nb || (s.nb = new Uint8Array(MAXC * MAXC)), nc = s.nc || (s.nc = new Uint8Array(MAXC));\n  for (let i = 0; i \u003c n; i++) {\n    let c = 0;\n    for (let j = 0; j \u003c n; j++) if (Hm[i * MAXC + j] !== 0) nb[i * MAXC + c++] = j;\n    nc[i] = c;\n  }\n  let rz = 0;\n  for (let i = 0; i \u003c n; i++) (z[i] = r[i] * pre(i)), (p[i] = z[i]), (rz += r[i] * z[i]);\n  const r0 = rz;\n  for (let it = 0; it \u003c 60 && rz > 1e-10 * r0; it++) {\n    let pAp = 0;\n    for (let i = 0; i \u003c n; i++) {\n      let v = eps * p[i];\n      const row = i * MAXC;\n      for (let k = 0; k \u003c nc[i]; k++) {\n        const j = nb[row + k];\n        v += Hm[row + j] * p[j];\n      }\n      Ap[i] = v;\n      pAp += p[i] * v;\n    }\n    if (pAp \u003c= 0) break;\n    const al = rz / pAp;\n    let rz2 = 0;\n    for (let i = 0; i \u003c n; i++) {\n      dw[i] += al * p[i];\n      r[i] -= al * Ap[i];\n      z[i] = r[i] * pre(i);\n      rz2 += r[i] * z[i];\n    }\n    const be = rz2 / rz;\n    rz = rz2;\n    for (let i = 0; i \u003c n; i++) p[i] = z[i] + be * p[i];\n  }\n  // No weight moves more than a third of a cell's mean area in one frame.\n  const lim = N / n / 3;\n  let mean = 0;\n  for (let i = 0; i \u003c n; i++) {\n    w[i] += cl(step * dw[i], -lim, lim);\n    mean += w[i];\n  }\n  mean /= n;\n  for (let i = 0; i \u003c n; i++) w[i] -= mean;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 24, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  s.hue = k[0] || 0;\n  const sp = cl(k[1], 0.2, 3), rate = sp / 2;\n  const n = round(cl(k[2], 24, 64));\n  const lnR = 2.4 + 1.3 * cl(k[3] || 0, -1, 1);\n  if (n !== s.n) newSites(s, n);\n  s.t += dt * rate;\n  // The density holds, then turns into the next one.\n  s.clock += dt * rate;\n  if (s.morph \u003c 0 && s.clock >= s.next) s.morph = 0;\n  if (s.morph >= 0) {\n    s.morph += (dt * rate) / T_MORPH;\n    if (s.morph >= 1) {\n      s.A = s.Bm;\n      s.Bm = newBumps();\n      s.morph = -1;\n      s.next = s.clock + T_HOLD;\n    }\n  }\n  const tot = density(s, lnR);\n  assign(s);\n  newton(s, tot / n, min(1, 1.5 * sp * dt));\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.n) return;\n  const { n, own, line, f, err, px, py } = s;\n  const col = s.col || (s.col = new Float64Array(MAXC * 3));\n  const h0 = 0.5 + s.hue;\n  for (let i = 0; i \u003c n; i++) {\n    const e = cl(err[i] * 3, -1, 1);\n    hsv(h0 + 0.24 * e, 0.55 + 0.3 * abs(e), 1, col, i * 3);\n  }\n  const F = s.F || (s.F = new Float32Array(N * 3));\n  for (let p = 0; p \u003c N; p++) {\n    const i = own[p], v = 55 + 150 * f[p], g = line[p], L = g \u003c 1 ? 1 - g : 0;\n    const o = p * 3, c = i * 3;\n    F[o] = col[c] * v * (1 - L) + 215 * L;\n    F[o + 1] = col[c + 1] * v * (1 - L) + 215 * L;\n    F[o + 2] = col[c + 2] * v * (1 - L) + 215 * L;\n  }\n  // The sites, dim: most of them end up outside their own cells.\n  for (let i = 0; i \u003c n; i++) {\n    const o = (floor(py[i]) * W + floor(px[i])) * 3;\n    F[o] = F[o + 1] = F[o + 2] = 150;\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, min(255, round(F[p * 3])), min(255, round(F[p * 3 + 1])), min(255, round(F[p * 3 + 2])));\n}\n","multiplicative-chaos":"// ===== Patternflow pattern =====\n// Title:   Multiplicative Chaos\n// Family:  noise\n// Idea:    A log-correlated Gaussian field X on the panel's 64 by 128 lattice, reaching a quarter of an LED, is drawn as a deep blue relief lit from the upper left, and its Gaussian multiplicative chaos exp(gamma X - gamma^2 E[X^2] / 2), each LED's share of the frame's mass, glows over it from rose through gold to white: at gamma 1 the glow is a gold lace over the high ground that holds half the mass on about 78 LEDs, and as gamma rises past the critical value 2 it drains onto one or two white points on the highest ground, while every mode of the field wanders slowly so the lace drifts, splits and gathers somewhere else.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Gaussian multiplicative chaos (Jean-Pierre Kahane, \"Sur le chaos multiplicatif\", Ann. Sci. Math. Québec 9, 1985), its critical gamma = sqrt(2d) and thick points as reviewed by Rémi Rhodes and Vincent Vargas (Probability Surveys 11, 2014), pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gamma=1..2.5, Cutoff=0..1\n//\n// Knob 1: Hue. Turns relief and glow round the wheel together: at 0 a deep blue relief under a glow that runs rose, orange, gold to white; at 0.25 a magenta relief under green, at 0.5 a yellow one under sky blue, at 0.75 a green one under magenta.\n// Knob 2: Speed. Every mode of the field wanders as its own Ornstein-Uhlenbeck process, smoothed in time. At 2 the longest wave, 128 rows, forgets itself in 8 s and the finest, with the octaves below the LED, in 1.6 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Gamma. From 1 to 2.5, critical at 2. Averaged over 20 fields: at 1 a third of the LEDs glow (each holds more than 0.14 of an even share), the brightest 1% hold 52% of the mass and half of it lies on 78 LEDs, where X is near gamma E[X^2]; at 1.6 9% glow, 1% hold 90% and half sits on 6 LEDs; at 2 5% glow and half sits on 3; at 2.4 2% glow and one or two LEDs hold half. Past 1.3 the mass stops following gamma E[X^2] up and freezes on the field's highest LEDs, which on this lattice stand at 1.47 E[X^2], short of the 2 E[X^2] the maximum tends to as a lattice grows.\n// Knob 4: Cutoff. The finest scale the field reaches, epsilon = 2^(6 (k - 0.06) - 2) LEDs: at the opening 0.06 a quarter of an LED, the two octaves below the LED drawn LED by LED, so relief and glow are grainy at every LED; at 0.39 one LED, the field blurred to its lattice modes and the lace turned into soft gold clouds; 4 LEDs at 0.72 and 12.5 at 1, where the field is a few hills and 95% of the LEDs glow a dim rust red, the measure close to even.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, exp, log, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- FFT, radix 2, in place, on rows of 64 and columns of 128.\nconst CT = new Float64Array(64), ST = new Float64Array(64);\nfor (let i = 0; i \u003c 64; i++) (CT[i] = cos((2 * PI * i) / 128)), (ST[i] = sin((2 * PI * i) / 128));\nfunction revTable(n) {\n  const r = new Int32Array(n), b = Math.log2(n);\n  for (let i = 0; i \u003c n; i++) {\n    let v = 0;\n    for (let k = 0; k \u003c b; k++) if (i & (1 \u003c\u003c k)) v |= 1 \u003c\u003c (b - 1 - k);\n    r[i] = v;\n  }\n  return r;\n}\nconst REV64 = revTable(64), REV128 = revTable(128);\nfunction fft(re, im, n, off, step, rev) {\n  for (let i = 0; i \u003c n; i++) {\n    const j = rev[i];\n    if (j > i) {\n      const a = off + i * step, b = off + j * step;\n      let t = re[a];\n      re[a] = re[b];\n      re[b] = t;\n      t = im[a];\n      im[a] = im[b];\n      im[b] = t;\n    }\n  }\n  for (let len = 2; len \u003c= n; len \u003c\u003c= 1) {\n    const half = len >> 1, ts = 128 / len;\n    for (let s = 0; s \u003c n; s += len)\n      for (let k = 0; k \u003c half; k++) {\n        const wr = CT[k * ts], wi = ST[k * ts];\n        const a = off + (s + k) * step, b = a + half * step;\n        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;\n        re[b] = re[a] - xr;\n        im[b] = im[a] - xi;\n        re[a] += xr;\n        im[a] += xi;\n      }\n  }\n}\nfunction fft2(re, im) {\n  for (let y = 0; y \u003c H; y++) fft(re, im, W, y * W, 1, REV64);\n  for (let x = 0; x \u003c W; x++) fft(re, im, H, x, W, REV128);\n}\n\n// ---- The field's modes on the 64 x 128 torus, so it wraps round left to\n// right and top to bottom. Mode (m, n) has the eigenvalue LA of minus the\n// lattice Laplacian and standard deviation sqrt(2 pi / (LA N)), the\n// discrete Gaussian free field scaled so its covariance goes as log(1 / r):\n// C(r) - C(2r) comes to 0.71, 0.71 and 0.68 for r = 1, 2 and 4 LEDs against\n// log 2 = 0.69, and E[X^2] to 4.99. In that normalisation the critical gamma\n// is sqrt(2d) = 2. The modes are complex, so one transform gives two\n// independent fields, its real and imaginary parts; the real one is drawn.\nconst LA = new Float64Array(N), AMP = new Float64Array(N), TAU = new Float64Array(N);\nfor (let n = 0; n \u003c H; n++)\n  for (let m = 0; m \u003c W; m++) {\n    const i = n * W + m, l = 4 - 2 * cos((2 * PI * m) / W) - 2 * cos((2 * PI * n) / H);\n    LA[i] = l;\n    AMP[i] = i ? sqrt((2 * PI) / (l * N)) : 0;\n  }\n// Each mode's time constant against the longest wave's: the finest lattice\n// mode turns over five times as fast, and so do the octaves below the LED.\nconst LMIN = 4 - 2 * cos((2 * PI) / H) - 2;\nfor (let i = 1; i \u003c N; i++) TAU[i] = (LMIN / LA[i]) ** 0.2;\nconst TAUF = (LMIN / 8) ** 0.2;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Standard normal deviates, drawn once and then picked at random. The table\n// is moved to mean 0 and variance 1: a table mean of 0.01 picked 8,192\n// times a frame would add up, through every mode at once, into a bump.\nconst NT = new Float64Array(8192);\nfunction fillNormals() {\n  let m = 0, v = 0;\n  for (let i = 0; i \u003c 8192; i += 2) {\n    const a = sqrt(-2 * log(1 - Math.random())), b = 2 * PI * Math.random();\n    NT[i] = a * cos(b);\n    NT[i + 1] = a * sin(b);\n    m += NT[i] + NT[i + 1];\n  }\n  m /= 8192;\n  for (let i = 0; i \u003c 8192; i++) v += (NT[i] -= m) ** 2;\n  v = sqrt(v / 8192);\n  for (let i = 0; i \u003c 8192; i++) NT[i] /= v;\n}\nconst gauss = () => NT[(Math.random() * 8192) | 0];\n\nexport function setup(params) {\n  fillNormals();\n  const S = (params.s = {\n    hue: 0, speed: 2, gam: 1, cut: 0, eps: -1, qd: -1, vl: 1, vf: 0,\n    zr: new Float64Array(N), zi: new Float64Array(N), ar: new Float64Array(N), ai: new Float64Array(N),\n    fz: new Float64Array(N), fa: new Float64Array(N),\n    Q: new Float64Array(N), Z: new Float64Array(N), R: new Float64Array(N), F: new Float64Array(N),\n    re: new Float64Array(N), im: new Float64Array(N), X: new Float64Array(N),\n    rel: new Float64Array(RT * 3), glo: new Float64Array(GT * 4), th: -1,\n  });\n  // Each mode starts in its stationary law: the filtered value has variance\n  // 2/3 and covariance 2/3 with the process it filters.\n  const start = (z, a) => {\n    for (let i = 0; i \u003c N; i++) {\n      z[i] = gauss();\n      a[i] = (2 / 3) * z[i] + 0.4714 * gauss();\n    }\n  };\n  start(S.zr, S.ar);\n  start(S.zi, S.ai);\n  start(S.fz, S.fa);\n  return S;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1] ?? 2, 0.2, 3);\n  S.gam = cl(k[2] ?? 1, 0, 3);\n  S.cut = cl(k[3] ?? 0.06, 0, 1);\n  // The cutoff epsilon in LEDs. Below one LED the lattice modes are all kept\n  // and the octaves between epsilon and the LED, log(1 / epsilon) of\n  // variance, are drawn as an independent normal at each LED: at a quarter\n  // of an LED they carry 1.39 of the field's 6.37. Above it the lattice\n  // modes are blurred by a Gaussian of width epsilon.\n  const eps = 2 ** (6 * (S.cut - 0.06) - 2);\n  if (eps !== S.eps) {\n    S.eps = eps;\n    const e2 = max(0, eps * eps - 1 / 16);\n    let v = 0;\n    for (let i = 1; i \u003c N; i++) {\n      const f = exp((-LA[i] * e2) / 2);\n      S.F[i] = AMP[i] * f * sqrt(1.5);\n      v += (AMP[i] * f) ** 2;\n    }\n    S.vl = v;\n    S.vf = max(0, log(1 / eps));\n  }\n  // Ornstein-Uhlenbeck steps seen through an exponential filter of half the\n  // time constant, which smooths each path in time; the filter leaves 2/3 of\n  // the variance, which F gives back. The longest wave's time constant is\n  // 8 s at Speed 2.\n  const qd = (d * S.speed) / (8 * 2);\n  if (qd !== S.qd) {\n    S.qd = qd;\n    for (let i = 1; i \u003c N; i++) {\n      const q = exp(-qd / TAU[i]);\n      S.Q[i] = q;\n      S.Z[i] = sqrt(1 - q * q);\n      S.R[i] = q * q;\n    }\n    const q = exp(-qd / TAUF);\n    S.fq = q;\n    S.fzz = sqrt(1 - q * q);\n    S.fr = q * q;\n  }\n  const { zr, zi, ar, ai, Q, Z, R, F, re, im, fz, fa, X } = S;\n  for (let i = 1; i \u003c N; i++) {\n    zr[i] = zr[i] * Q[i] + Z[i] * gauss();\n    zi[i] = zi[i] * Q[i] + Z[i] * gauss();\n    ar[i] = ar[i] * R[i] + zr[i] * (1 - R[i]);\n    ai[i] = ai[i] * R[i] + zi[i] * (1 - R[i]);\n    re[i] = ar[i] * F[i];\n    im[i] = ai[i] * F[i];\n  }\n  re[0] = im[0] = 0;\n  fft2(re, im);\n  const sf = sqrt(S.vf * 1.5), fq = S.fq, fzz = S.fzz, fr = S.fr;\n  for (let i = 0; i \u003c N; i++) {\n    fz[i] = fz[i] * fq + fzz * gauss();\n    fa[i] = fa[i] * fr + fz[i] * (1 - fr);\n    X[i] = re[i] + sf * fa[i];\n  }\n}\n\n// ---- Drawing. The relief: the field's height t = X / sd tints and lifts\n// it, and its slope toward the upper left (the sum of the two central\n// differences, halved) shades it. The glow: lm, the log of the LED's share\n// of the frame's mass against an even share, read from LO (e^-2, 0.14 of an\n// even share) to HI (e^3.5, 33 times one).\nconst KS = 0.4, KB = 0.16, LO = -2, HI = 3.5;\n// Relief colours over t from -3 to 3 in 64 steps; glow colours, with the\n// glow's own weight a and what is left of the relief k, over 256 steps.\nconst RT = 64, GT = 256;\nfunction tables(S) {\n  const c = [0, 0, 0];\n  for (let j = 0; j \u003c RT; j++) {\n    hsv(0.64 + S.hue - 0.03 * ((6 * j) / (RT - 1) - 3), 0.85, 1, c);\n    S.rel[j * 3] = c[0];\n    S.rel[j * 3 + 1] = c[1];\n    S.rel[j * 3 + 2] = c[2];\n  }\n  for (let j = 0; j \u003c GT; j++) {\n    const w = j / (GT - 1), a = min(1, 0.25 + 1.2 * w);\n    hsv(0.93 + S.hue + 0.22 * min(1, w * 1.25), 1 - w ** 4, 0.45 + 0.55 * w, c);\n    S.glo[j * 4] = 255 * a * c[0];\n    S.glo[j * 4 + 1] = 255 * a * c[1];\n    S.glo[j * 4 + 2] = 255 * a * c[2];\n    S.glo[j * 4 + 3] = 1 - 0.85 * a;\n  }\n  S.th = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.th !== S.hue) tables(S);\n  const X = S.X, g = S.gam, rel = S.rel, glo = S.glo, isd = 1 / sqrt(S.vl + S.vf), ts = (RT - 1) / 6;\n  // Each LED's share of the frame's mass: the log of the mean density is\n  // taken off, summed from the largest value down so it cannot overflow.\n  // The constant -g^2 E[X^2] / 2 of the chaos cancels in the share.\n  let mx = -1e9;\n  for (let i = 0; i \u003c N; i++) if (X[i] > mx) mx = X[i];\n  let sum = 0;\n  for (let i = 0; i \u003c N; i++) sum += exp(g * (X[i] - mx));\n  const off = g * mx + log(sum / N), gw = (GT - 1) / (HI - LO);\n  for (let y = 0; y \u003c H; y++) {\n    const r0 = y * W, ru = ((y + H - 1) & 127) * W, rd = ((y + 1) & 127) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const p = r0 + x, v = X[p];\n      const sh = (X[r0 + ((x + W - 1) & 63)] - X[r0 + ((x + 1) & 63)] + X[ru + x] - X[rd + x]) * 0.5;\n      const t = v * isd, tj = cl(((t + 3) * ts) | 0, 0, RT - 1) * 3;\n      const val = 255 * cl(0.38 + KB * t + KS * sh, 0.02, 1);\n      let r = rel[tj] * val, gg = rel[tj + 1] * val, b = rel[tj + 2] * val;\n      const lm = g * v - off;\n      if (lm > LO) {\n        const q = min(GT - 1, ((lm - LO) * gw) | 0) * 4, k = glo[q + 3];\n        r = r * k + glo[q];\n        gg = gg * k + glo[q + 1];\n        b = b * k + glo[q + 2];\n      }\n      display.setPixel(x, y, r > 255 ? 255 : r | 0, gg > 255 ? 255 : gg | 0, b > 255 ? 255 : b | 0);\n    }\n  }\n}\n","photon-disk":"// ===== Patternflow pattern =====\n// Title:   Photon Disk\n// Family:  type\n// Idea:    A dark glass disk with its letters cut clear in two rings turns anticlockwise in the lower half of the panel, and each time the glyph the line needs passes the window at twelve o'clock a short flash freezes it white for an instant and sends its light up through a lens that sizes the image onto a strip of brown film at the top, where the line builds up letter by letter in light while the film feeds up a line at a time.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lumitype phototypesetter, sold in the United States as the Photon (René Higonnet and Louis Moyroud, begun 1944, shown in France in September 1946), whose disk held eight rings of two 90-character fonts filmed at 12 sizes from 5 to 72 points; the first book set on it, Albro Gaul's The Wonderful World of Insects (1953); a 5 by 7 face drawn for this pattern; pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Lens=1..2.25\n//\n// Knob 1: Hue. The colour of the light the flash leaves on the film and of the letters in the glass: azure at 0, violet at 0.25, orange at 0.5, green at 0.75. The flash itself is white and the film stays a dark brown.\n// Knob 2: Speed. The disk turns 0.4 times the knob a second, 0.8 at the opening 2, and a letter waits for its glyph to come round, so the flash fires 1.2 times a second on the title and its 26 letters on four lines take 21 s with the line feeds and a rest of 1.6 s at the end. At 0.2 a turn takes 12.5 s, the letters in the disk stand sharp and the title takes three minutes; at 3 the rings smear and it takes 14 s.\n// Knob 3: Text. 0 the title of the first book set on the machine, THE WONDERFUL WORLD OF INSECTS; 1 the pangram THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG., 36 flashes; 2 the disk's own 40 glyphs in ring order, where each comes to the window just after the one before, so at 2 the outer ring's letters land about 20 a second and the strobe seems to hold the disk still while A to Z run through the window; 3 R. HIGONNET & L. MOYROUD 1946. A new text starts two lines further down the film.\n// Knob 4: Lens. The magnification, 1 to 2.25 in quarter steps, and the lens slides to where a thin lens gives it, the distance from disk to film divided 1 to m: halfway at 1, 15.5 rows above the window, with letters 7 LEDs tall and 9 to the line; 10.9 rows above it at 2.25, with letters 15.75 LEDs tall and 4 to the line, a long word broken with the hyphen from the inner ring. A new size starts the text over two lines down, and letters already on the film keep the size they were set at.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// 5 x 7 capitals, figures and four marks, drawn for this pattern, row by row\n// from the top.\nconst GLYPHS = {\n  A: \".###. #...# #...# ##### #...# #...# #...#\", B: \"####. #...# #...# ####. #...# #...# ####.\", C: \".###. #...# #.... #.... #.... #...# .###.\",\n  D: \"####. #...# #...# #...# #...# #...# ####.\", E: \"##### #.... #.... ####. #.... #.... #####\", F: \"##### #.... #.... ####. #.... #.... #....\",\n  G: \".###. #...# #.... #.### #...# #...# .####\", H: \"#...# #...# #...# ##### #...# #...# #...#\", I: \".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.\",\n  J: \"..### ...#. ...#. ...#. ...#. #..#. .##..\", K: \"#...# #..#. #.#.. ##... #.#.. #..#. #...#\", L: \"#.... #.... #.... #.... #.... #.... #####\",\n  M: \"#...# ##.## #.#.# #.#.# #...# #...# #...#\", N: \"#...# #...# ##..# #.#.# #..## #...# #...#\", O: \".###. #...# #...# #...# #...# #...# .###.\",\n  P: \"####. #...# #...# ####. #.... #.... #....\", Q: \".###. #...# #...# #...# #.#.# #..#. .##.#\", R: \"####. #...# #...# ####. #.#.. #..#. #...#\",\n  S: \".#### #.... #.... .###. ....# ....# ####.\", T: \"##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..\", U: \"#...# #...# #...# #...# #...# #...# .###.\",\n  V: \"#...# #...# #...# #...# #...# .#.#. ..#..\", W: \"#...# #...# #...# #.#.# #.#.# #.#.# .#.#.\", X: \"#...# #...# .#.#. ..#.. .#.#. #...# #...#\",\n  Y: \"#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..\", Z: \"##### ....# ...#. ..#.. .#... #.... #####\", 0: \".###. #...# #..## #.#.# ##..# #...# .###.\",\n  1: \"..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.\", 2: \".###. #...# ....# ...#. ..#.. .#... #####\", 3: \"##### ...#. ..#.. ...#. ....# #...# .###.\",\n  4: \"...#. ..##. .#.#. #..#. ##### ...#. ...#.\", 5: \"##### #.... ####. ....# ....# #...# .###.\", 6: \"..##. .#... #.... ####. #...# #...# .###.\",\n  7: \"##### ....# ...#. ..#.. .#... .#... .#...\", 8: \".###. #...# #...# .###. #...# #...# .###.\", 9: \".###. #...# #...# .#### ....# ...#. .##..\",\n  \".\": \"..... ..... ..... ..... ..... .##.. .##..\", \",\": \"..... ..... ..... ..... .##.. ..#.. .#...\",\n  \"&\": \".##.. #..#. #.#.. .#... #.#.# #..#. .##.#\", \"-\": \"..... ..... ..... ##### ..... ..... .....\",\n};\nconst FONT = {};\nfor (const k in GLYPHS) {\n  const s = GLYPHS[k].replace(/ /g, \"\"), b = new Uint8Array(35);\n  for (let i = 0; i \u003c 35; i++) b[i] = s[i] === \"#\" ? 1 : 0;\n  FONT[k] = b;\n}\n\n// The disk: centre and radius in LED units, two rings of glyphs with their\n// tops to the rim, the outer one the 26 capitals at radius 26 and the inner\n// one the figures and marks at radius 15. The window is at twelve o'clock.\nconst CX = 31.5, CY = 95.5, RD = 31.5, HUB = 8;\nconst RINGS = [\n  { chars: \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\", rc: 26 },\n  { chars: \"0123456789.,&-\", rc: 15 },\n];\nconst WHERE = {};\nRINGS.forEach((ring, r) => {\n  ring.n = ring.chars.length;\n  ring.g = [...ring.chars].map((ch, j) => ((WHERE[ch] = [r, j]), FONT[ch]));\n});\n\n// The film: a strip across the top 45 rows; the line being set has its foot\n// on row GB, between columns X0 and X0 + LW.\nconst FY1 = 44, GB = 41, X0 = 5, LW = 54;\n\n// The texts; the specimen of the disk's glyphs breaks its lines without a\n// hyphen.\nconst TEXTS = [\n  \"THE WONDERFUL WORLD OF INSECTS\",\n  \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.\",\n  \"ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789.,&-\",\n  \"R. HIGONNET & L. MOYROUD 1946\",\n];\nconst SPECIMEN = 2;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Every pixel of the disk with its radius, its angle in radians clockwise\n// from twelve o'clock, and which ring it can show.\nconst DISK = (() => {\n  const idx = [], ang = [], rad = [], ring = [];\n  for (let y = 64; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      if (r > RD + 0.5) continue;\n      let a = atan2(dx, -dy);\n      if (a \u003c 0) a += TAU;\n      idx.push(y * W + x), ang.push(a), rad.push(r);\n      ring.push(abs(r - RINGS[0].rc) \u003c 4.4 ? 0 : abs(r - RINGS[1].rc) \u003c 4.4 ? 1 : -1);\n    }\n  return { idx: Int32Array.from(idx), ang: Float32Array.from(ang), rad: Float32Array.from(rad), ring: Int8Array.from(ring) };\n})();\n\n// Glyph value at (col, row) in its own pixels, bilinear between the cells.\nfunction sample(g, col, row) {\n  if (col \u003c= -1 || col >= 5 || row \u003c= -1 || row >= 7) return 0;\n  const c0 = floor(col), r0 = floor(row), fc = col - c0, fr = row - r0;\n  let v = 0;\n  for (let k = 0; k \u003c 4; k++) {\n    const c = c0 + (k & 1), r = r0 + (k >> 1);\n    if (c \u003c 0 || c > 4 || r \u003c 0 || r > 6 || !g[r * 5 + c]) continue;\n    v += (k & 1 ? fc : 1 - fc) * (k >> 1 ? fr : 1 - fr);\n  }\n  return v;\n}\n\n// The glyph of ring r seen at a pixel of radius rr and disk angle b. The\n// angle off the glyph's centre line is under 0.23 radians, so sin and cos\n// are their first two terms.\nfunction diskGlyph(r, rr, b) {\n  const ring = RINGS[r], n = ring.n, jf = (b * n) / TAU, j = round(jf), d = ((jf - j) * TAU) / n, d2 = d * d;\n  const u = rr * d * (1 - d2 / 6), v = rr * (1 - d2 / 2) - ring.rc;\n  let k = j % n;\n  if (k \u003c 0) k += n;\n  return sample(ring.g[k], u + 2, 3 - v);\n}\n\n// A glyph at magnification m as coverage of the LEDs it falls on, 3 x 3\n// samples to an LED, kept once made.\nconst SCALED = {};\nfunction scaled(ch, m) {\n  const key = ch + m;\n  if (SCALED[key]) return SCALED[key];\n  const g = FONT[ch], w = ceil(5 * m), h = ceil(7 * m), cov = new Float32Array(w * h);\n  for (let py = 0; py \u003c h; py++)\n    for (let px = 0; px \u003c w; px++) {\n      let c = 0;\n      for (let sy = 0; sy \u003c 3; sy++)\n        for (let sx = 0; sx \u003c 3; sx++) {\n          const gx = floor((px + (sx + 0.5) / 3) / m), gy = floor((py + (sy + 0.5) / 3) / m);\n          if (gx \u003c 5 && gy \u003c 7 && g[gy * 5 + gx]) c++;\n        }\n      cov[py * w + px] = c / 9;\n    }\n  return (SCALED[key] = { w, h, cov });\n}\n\n// Lay a text out at magnification m: lines centred on the film, a word too\n// long for a line broken with a hyphen.\nfunction layout(text, m, plain) {\n  const adv = 6 * m, per = max(2, floor((LW + m) / adv)), lines = [], cut = plain ? per : per - 1, hy = plain ? \"\" : \"-\";\n  let cur = \"\";\n  for (let word of text.split(\" \")) {\n    while (word.length > per && !cur) lines.push(word.slice(0, cut) + hy), (word = word.slice(cut));\n    if (!cur) cur = word;\n    else if (cur.length + 1 + word.length \u003c= per) cur += \" \" + word;\n    else {\n      lines.push(cur), (cur = \"\");\n      while (word.length > per) lines.push(word.slice(0, cut) + hy), (word = word.slice(cut));\n      cur = word;\n    }\n  }\n  if (cur) lines.push(cur);\n  const out = [];\n  lines.forEach((line, k) => {\n    const x = round(X0 + (LW - (line.length * adv - m)) / 2);\n    [...line].forEach((ch, i) => out.push({ ch, line: k, x: x + i * adv }));\n  });\n  return { chars: out, lines: lines.length };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, phi: 0, prev: 0, hue: 0, speed: 2, text: 0, m: 1, job: null, jobs: 0, ci: 0, cur: 0,\n    state: \"seek\", wait: 0, film: 0, filmTo: 0, pen: X0, penTo: X0,\n    lit: [], flash: null, started: false, rgb: new Float32Array(W * H * 3),\n    c: [0, 0, 0], c2: [0, 0, 0], c3: [0, 0, 0],\n  };\n  return params.s;\n}\n\nfunction lp(m) {\n  return ceil(7 * m) + 3;\n}\n\n// Start the job over two blank lines on: a new layout at the knobs' size.\nfunction begin(S) {\n  S.job = layout(TEXTS[S.text], S.m, S.text === SPECIMEN);\n  S.ci = 0;\n  S.cur = 0;\n  S.jobs++;\n  S.filmTo += 2 * lp(S.m);\n  S.state = \"wait\";\n  S.wait = 0.4 * sqrt(2 / S.speed);\n}\n\nfunction advance(S, d) {\n  S.t += d;\n  S.prev = S.phi;\n  S.phi += d * TAU * 0.4 * S.speed;\n  const slow = sqrt(2 / S.speed);\n  // The film and the carriage ease to where they are sent.\n  S.film += (S.filmTo - S.film) * min(1, d / (0.09 * slow));\n  S.pen += (S.penTo - S.pen) * min(1, d / 0.025);\n  if (S.state === \"wait\") {\n    if ((S.wait -= d) > 0) return;\n    S.state = \"seek\";\n  }\n  if (S.state === \"hold\") {\n    if ((S.wait -= d) \u003c= 0) begin(S);\n    return;\n  }\n  const job = S.job;\n  if (S.ci >= job.chars.length) {\n    S.state = \"hold\";\n    S.wait = 1.6 * slow;\n    return;\n  }\n  const c = job.chars[S.ci];\n  if (c.line !== S.cur) {\n    // A new line: the film feeds up and the carriage goes back.\n    S.filmTo += (c.line - S.cur) * lp(S.m);\n    S.cur = c.line;\n    S.penTo = c.x;\n    S.state = \"wait\";\n    S.wait = 0.32 * slow;\n    return;\n  }\n  S.penTo = c.x;\n  if (c.ch === \" \") {\n    S.ci++;\n    return;\n  }\n  // The disk turns anticlockwise, phi radians so far, so glyph j stands at\n  // 2 pi j / n - phi clockwise from twelve and the letter after A comes\n  // to the window next.\n  const [r, j] = WHERE[c.ch], n = RINGS[r].n, off = (TAU * j) / n;\n  const a0 = (S.prev - off) / TAU, a1 = (S.phi - off) / TAU;\n  if (floor(a1) > floor(a0)) {\n    // The glyph crossed the window during this step: flash.\n    const at = floor(a1) * TAU + off;\n    S.flash = { t: S.t, r, j, phi: at, x: c.x, m: S.m };\n    S.lit.push({ ch: c.ch, x: c.x, fy: S.filmTo, m: S.m, t: S.t });\n    if (S.lit.length > 120) S.lit.shift();\n    S.ci++;\n    S.state = \"wait\";\n    S.wait = 0.01;\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1], 0.2, 3);\n  const text = cl(round(kv[2]), 0, 3), m = round(cl(kv[3], 1, 2.25) * 4) / 4;\n  if (!S.job || text !== S.text || m !== S.m) {\n    S.text = text, S.m = m;\n    begin(S);\n  }\n  if (!S.started) {\n    // Run the first copy through unseen, so the film opens with it set and\n    // the second copy a few letters in.\n    S.started = true;\n    for (let f = 0; f \u003c 2400 && !(S.jobs > 1 && S.ci > 6); f++) advance(S, 1 / 30);\n  }\n  advance(S, d);\n}\n\nfunction add(rgb, x, y, r, g, b, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  rgb[o] += r * a, rgb[o + 1] += g * a, rgb[o + 2] += b * a;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.job) return;\n  const rgb = S.rgb, c = S.c, c2 = S.c2, c3 = S.c3, t = S.t;\n  rgb.fill(0);\n  const light = hsv(0.55 + S.hue, 0.75, 1, c);\n\n  // The film: a dark strip with lighter edges.\n  const base = hsv(0.07, 0.45, 0.11, c2);\n  for (let y = 0; y \u003c= FY1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const edge = x === 1 || x === W - 2 ? 1.8 : 1;\n      add(rgb, x, y, base[0], base[1], base[2], edge);\n    }\n  // Exposed letters: white when the flash lands, cooling to the light.\n  for (const L of S.lit) {\n    const G = scaled(L.ch, L.m), top = round(GB - (S.film - L.fy) - 7 * L.m + 1);\n    if (top + G.h \u003c 0 || top > FY1) continue;\n    const w = exp(-(t - L.t) / 0.35);\n    const r0 = light[0] + (1 - light[0]) * w, g0 = light[1] + (1 - light[1]) * w, b0 = light[2] + (1 - light[2]) * w;\n    for (let py = 0; py \u003c G.h; py++) {\n      const y = top + py;\n      if (y \u003c 0 || y > FY1) continue;\n      for (let px = 0; px \u003c G.w; px++) {\n        const a = G.cov[py * G.w + px];\n        if (a) add(rgb, L.x + px, y, r0, g0, b0, a * 0.9);\n      }\n    }\n  }\n\n  // The disk.\n  // Each frame shows the disk over half the frame's turn, like a shutter\n  // open half the time.\n  const n = DISK.idx.length, span = 0.5 * (S.phi - S.prev), ns = cl(ceil((abs(span) * 28) / 1.2), 1, 6);\n  const glass = hsv(0.6 + S.hue, 0.3, 0.12, c3);\n  for (let q = 0; q \u003c n; q++) {\n    const p = DISK.idx[q], rr = DISK.rad[q], a = DISK.ang[q], ring = DISK.ring[q];\n    let r = glass[0], g = glass[1], b = glass[2];\n    if (rr > RD - 1) (r = 0.3), (g = 0.31), (b = 0.33);\n    else if (rr \u003c HUB) {\n      // The hub, with three bolts that turn with the disk.\n      let bolt = 0;\n      for (let k = 0; k \u003c 3; k++) {\n        const ba = (k * TAU) / 3 - S.phi, bx = CX + 4.6 * sin(ba), by = CY - 4.6 * cos(ba);\n        const x = (p % W) + 0.5, y = floor(p / W) + 0.5, e = (x - bx) * (x - bx) + (y - by) * (y - by);\n        bolt = max(bolt, cl(1.6 - e, 0, 1));\n      }\n      const v = 0.32 - 0.22 * bolt;\n      (r = v), (g = v * 1.02), (b = v * 1.06);\n    } else if (ring >= 0) {\n      let s = 0;\n      for (let k = 0; k \u003c ns; k++) s += diskGlyph(ring, rr, a + S.phi - (span * (k + 0.5)) / ns);\n      s /= ns;\n      r += s * (0.1 + 0.32 * light[0]), g += s * (0.1 + 0.32 * light[1]), b += s * (0.1 + 0.32 * light[2]);\n    }\n    rgb[p * 3] += r, rgb[p * 3 + 1] += g, rgb[p * 3 + 2] += b;\n  }\n\n  // The flash: the glyph at the window frozen white, a glow round it, and\n  // its light through the lens to the film.\n  const F = S.flash;\n  if (F) {\n    const age = t - F.t, e = exp(-age / 0.07), eb = exp(-age / 0.12);\n    if (e > 0.01) {\n      const rc = RINGS[F.r].rc, oy = CY - rc;\n      for (let y = floor(oy - 9); y \u003c= ceil(oy + 9); y++)\n        for (let x = 22; x \u003c 42; x++) {\n          const dx = x + 0.5 - CX, dy = y + 0.5 - CY, rr = sqrt(dx * dx + dy * dy);\n          let a = atan2(dx, -dy);\n          if (a \u003c 0) a += TAU;\n          const nn = RINGS[F.r].n, b = a + F.phi, jj = ((round((b * nn) / TAU) % nn) + nn) % nn;\n          const gv = abs(rr - rc) \u003c 4.4 && jj === F.j ? diskGlyph(F.r, rr, b) : 0;\n          const halo = exp(-(dx * dx + (y + 0.5 - oy) ** 2) / 22) * 0.35;\n          add(rgb, x, y, 1, 1, 1, gv * e * 1.2);\n          add(rgb, x, y, light[0], light[1], light[2], halo * e);\n        }\n    }\n    if (eb > 0.01) {\n      // Object 5 LEDs wide at the window, lens of half-width 7.5 where it\n      // gives magnification m for the outer ring, image 5m wide with its\n      // foot on the gate.\n      const m = F.m, o0 = CY - RINGS[0].rc, oy = CY - RINGS[F.r].rc, iy = GB + 1 - 3.5 * m, ix = F.x + 2.5 * m;\n      const ly = o0 - (o0 - iy) / (1 + m), ox = CX;\n      for (let y = floor(iy); y \u003c= ceil(oy); y++) {\n        const yc = y + 0.5;\n        let cx, hw;\n        if (yc >= ly) {\n          const u = (yc - ly) / (oy - ly);\n          (cx = ox), (hw = 7.5 + (2.5 - 7.5) * u);\n        } else {\n          const u = (ly - yc) / (ly - iy);\n          (cx = ox + (ix - ox) * u), (hw = 7.5 + (2.5 * m - 7.5) * u);\n        }\n        for (let x = floor(cx - hw - 1); x \u003c= ceil(cx + hw + 1); x++) {\n          const a = cl(hw + 0.5 - abs(x + 0.5 - cx), 0, 1);\n          add(rgb, x, y, light[0], light[1], light[2], a * eb * 0.45);\n        }\n      }\n    }\n  }\n\n  // The lens, at the height that gives the knob's magnification for the\n  // outer ring, and the carriage mark under the line.\n  {\n    const m = S.m, oy = CY - RINGS[0].rc, iy = GB + 1 - 3.5 * m, ly = oy - (oy - iy) / (1 + m);\n    const glow = F ? exp(-(t - F.t) / 0.12) : 0;\n    for (let x = 23; x \u003c= 40; x++) {\n      const u = (x + 0.5 - CX) / 8.5, hh = 1.6 * sqrt(max(0, 1 - u * u));\n      if (hh \u003c= 0) continue;\n      for (let y = floor(ly - hh); y \u003c= ceil(ly + hh); y++) {\n        const a = cl(hh + 0.5 - abs(y + 0.5 - ly), 0, 1);\n        add(rgb, x, y, 0.25 + 0.5 * light[0] * glow, 0.3 + 0.5 * light[1] * glow, 0.34 + 0.5 * light[2] * glow, a);\n      }\n    }\n    const px = round(S.pen);\n    for (let x = px; x \u003c px + 5 * m; x++) add(rgb, x, GB + 2, light[0], light[1], light[2], 0.45);\n  }\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, rgb[k] * 255) | 0, min(255, rgb[k + 1] * 255) | 0, min(255, rgb[k + 2] * 255) | 0);\n    }\n}\n","quousque-tandem":"// ===== Patternflow pattern =====\n// Title:   Quousque Tandem\n// Family:  type\n// Idea:    The opening line of Cicero's first speech against Catiline, the line Caslon's specimen sets in size after size, runs down the standing panel left aligned in a broad-nib roman, every other line leaning like the specimen's italic and each line a fixed fraction of the size of the one above, so the top lines read and the bottom closes up into a soft grey of type smaller than an LED, while the page zooms without end into its bottom left corner and every line grows into the size of the line above.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: William Caslon's specimen sheet dated 1734, its roman and italic in 14 sizes among 38 founts (Talbot Baines Reed's count, A History of the Old English Letter Foundries, 1887), which sets \"Quousque tandem abutere, Catilina, patientia nostra?\" from Cicero's first speech against Catiline (63 BC); the face here is drawn new with a broad nib, pattern round 70\n// Round:   70\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=0.7..0.9, Weight=0..1\n//\n// Knob 1: Hue. Turns the paper round the wheel with a near-black ink opposite it: cream paper (235, 216, 169) and a blue-black ink at 0, mint paper and a plum-black at 0.25, pale blue and a brown-black at 0.5, pink and a green-black at 0.75.\n// Knob 2: Speed. At 2 every line takes 2.5 s to grow into the line above, the page zooming 1.43 times at the opening ratio; 25 s at 0.2 and 1.7 s at 3. Roman and leaning lines swap places every period, so the picture comes round every two.\n// Knob 3: Ratio. Each line's size over the size of the line above. At the opening 0.7 the top line is 38 rows tall with capitals 24 LEDs high, 8 lines have capitals over 1.5 LEDs and the last 7 rows are the grey; at 0.8 the top line's capitals are 16 LEDs and 11 lines read; at 0.9 the capitals start at 8 LEDs, 17 lines read and the grey takes the last 21 rows.\n// Knob 4: Weight. The width of the nib: 0.089 em at the opening 0.06, where a stem is a tenth of an em, 3.5 LEDs in the top line; 0.083 em at 0 and 0.18 em at 1, where the letters go black, the counters close and the grey at the bottom darkens with them.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, log, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// ---- The face. Each letter is a skeleton in em units, y up from the\n// baseline, x from the letter's left edge, written with a broad nib held at\n// 30 degrees, so a stroke is thick across the nib and a hairline along it:\n// the slanted stress of an old-style roman, thin at eleven and five o'clock\n// in the o. Serifs and bars take a narrower nib (the number after a stroke).\n// Only the 19 letters and marks of the line are drawn.\nconst XH = 0.45, ASC = 0.74, DSC = 0.24, CAP = 0.665;\nfunction arc(cx, cy, rx, ry, a0, a1, n) {\n  const out = [];\n  n = n || max(6, ceil(abs(a1 - a0) / 9));\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    out.push(cx + rx * cos(a), cy + ry * sin(a));\n  }\n  return out;\n}\nconst S = 0.4;\nconst GLYPHS = {\n  \" \": [0.26],\n  o: [0.5, [arc(0.25, 0.225, 0.17, 0.215, 0, 360)]],\n  e: [0.45, [[0.08, 0.25, 0.4, 0.25], 0.6], [arc(0.235, 0.225, 0.16, 0.215, 8, 325)]],\n  a: [0.46, [[0.37, 0.06, ...arc(0.22, 0.3, 0.15, 0.13, 0, 145), 0.1, 0.34]], [[0.37, 0.26, ...arc(0.22, 0.13, 0.15, 0.13, 90, 300), 0.37, 0.08]], [[0.37, 0.06, 0.4, 0, 0.46, 0.02], S]],\n  n: [0.54, [[0.1, 0, 0.1, XH]], [[0.1, 0.33, ...arc(0.27, 0.29, 0.17, 0.15, 150, 0), 0.44, 0]], [[0.02, 0, 0.18, 0], S], [[0.36, 0, 0.52, 0], S], [[0.02, 0.42, 0.1, XH], S]],\n  m: [0.82, [[0.1, 0, 0.1, XH]], [[0.1, 0.33, ...arc(0.255, 0.29, 0.155, 0.15, 150, 0), 0.41, 0]], [[0.41, 0.33, ...arc(0.565, 0.29, 0.155, 0.15, 150, 0), 0.72, 0]],\n    [[0.02, 0, 0.18, 0], S], [[0.33, 0, 0.49, 0], S], [[0.64, 0, 0.8, 0], S], [[0.02, 0.42, 0.1, XH], S]],\n  u: [0.54, [[0.1, XH, ...arc(0.27, 0.16, 0.17, 0.16, 180, 360)]], [[0.44, XH, 0.44, 0]], [[0.44, 0, 0.52, 0], S], [[0.02, 0.42, 0.1, XH], S], [[0.36, 0.42, 0.44, XH], S]],\n  i: [0.28, [[0.13, 0, 0.13, XH]], [[0.04, 0, 0.22, 0], S], [[0.05, 0.42, 0.13, XH], S], [[0.12, 0.6, 0.145, 0.635]]],\n  l: [0.28, [[0.13, 0, 0.13, 0.72]], [[0.04, 0, 0.22, 0], S], [[0.05, 0.69, 0.13, 0.72], S]],\n  t: [0.32, [[0.12, 0.58, 0.12, 0.08, 0.15, 0.01, 0.22, 0, 0.29, 0.04]], [[0.02, 0.43, 0.27, 0.43], 0.6]],\n  d: [0.54, [[0.44, 0.37, ...arc(0.25, 0.225, 0.165, 0.215, 60, 300), 0.44, 0.07]], [[0.44, 0.72, 0.44, 0]], [[0.36, 0.69, 0.44, 0.72], S], [[0.44, 0, 0.52, 0], S]],\n  b: [0.54, [[0.1, 0.72, 0.1, 0]], [arc(0.29, 0.225, 0.16, 0.215, 120, -120)], [[0.02, 0.69, 0.1, 0.72], S]],\n  p: [0.54, [[0.1, XH, 0.1, -0.22]], [arc(0.29, 0.225, 0.16, 0.215, 120, -120)], [[0.02, 0.42, 0.1, XH], S], [[0.02, -0.22, 0.18, -0.22], S]],\n  q: [0.54, [[0.44, 0.37, ...arc(0.25, 0.225, 0.165, 0.215, 60, 300), 0.44, 0.07]], [[0.44, XH, 0.44, -0.22]], [[0.36, -0.22, 0.52, -0.22], S]],\n  r: [0.38, [[0.1, 0, 0.1, XH]], [[0.1, 0.32, 0.15, 0.4, 0.22, 0.445, 0.3, 0.45, 0.35, 0.42]], [[0.02, 0, 0.2, 0], S], [[0.02, 0.42, 0.1, XH], S]],\n  s: [0.4, [[...arc(0.2, 0.34, 0.12, 0.105, 15, 250), ...arc(0.2, 0.115, 0.135, 0.115, 90, -165)]]],\n  Q: [0.76, [arc(0.38, 0.33, 0.29, 0.335, 0, 360)], [[0.33, 0.02, 0.45, -0.06, 0.6, -0.13, 0.74, -0.16], 0.9]],\n  C: [0.68, [arc(0.38, 0.33, 0.28, 0.335, 42, 318)], [[0.585, 0.55, 0.6, 0.66], S]],\n  \",\": [0.24, [[0.1, 0.05, 0.09, -0.02, 0.05, -0.12]], [[0.08, 0.06, 0.11, 0.03]]],\n  \"?\": [0.42, [[...arc(0.21, 0.53, 0.13, 0.13, 160, -60), 0.21, 0.33, 0.21, 0.2]], [[0.2, 0.02, 0.225, 0.05]]],\n};\nconst LINE = \"Quousque tandem abutere, Catilina, patientia nostra? \";\n\n// ---- The strip: the line set once at E texels to the em, each texel an\n// ink count of 0..16 from a 4 by 4 supersample, kept as a summed-area table\n// two periods long. The ink over any box of the line, at any size, is then\n// four lookups, so a line a tenth of an LED high is as exact as a big one.\nconst E = 40, SS = 4, SH = Math.round((ASC + DSC) * E), BASE = ASC * E, K = E * SS;\nconst NIB = 0.088, NIB_A = (30 * PI) / 180, HAIR = 0.009, PAD = 0.08;\nconst DX = cos(NIB_A), DY = sin(NIB_A);\n\n// One letter at the 4x supersample, the nib stamped every eighth of a texel along\n// each stroke: a bar nib long and two hairlines wide, laid at 30 degrees.\nfunction glyphTile(ch, nib, hair) {\n  const g = GLYPHS[ch], TW = ceil((g[0] + 2 * PAD) * K), TH = SH * SS;\n  const t = new Uint8Array(TW * TH);\n  const stamp = (px, py, n) => {\n    const ex = DX * n + hair, ey = DY * n + hair;\n    const i0 = max(0, floor((px - ex + PAD) * K)), i1 = min(TW - 1, ceil((px + ex + PAD) * K));\n    const j0 = max(0, floor((ASC - py - ey) * K)), j1 = min(TH - 1, ceil((ASC - py + ey) * K));\n    for (let j = j0; j \u003c= j1; j++) {\n      const qy = ASC - (j + 0.5) / K - py;\n      for (let i = i0; i \u003c= i1; i++) {\n        const qx = (i + 0.5) / K - PAD - px;\n        if (abs(qx * DX + qy * DY) \u003c= n && abs(qx * DY - qy * DX) \u003c= hair) t[j * TW + i] = 1;\n      }\n    }\n  };\n  for (let s = 1; s \u003c g.length; s++) {\n    const pts = g[s][0], n = (nib / 2) * (g[s][1] || 1);\n    for (let p = 0; p + 3 \u003c pts.length; p += 2) {\n      const ax = pts[p], ay = pts[p + 1], bx = pts[p + 2], by = pts[p + 3];\n      const steps = max(1, ceil(sqrt((bx - ax) ** 2 + (by - ay) ** 2) * K * 2));\n      for (let q = 0; q \u003c= steps; q++) stamp(ax + ((bx - ax) * q) / steps, ay + ((by - ay) * q) / steps, n);\n    }\n  }\n  return { t, TW };\n}\n\nfunction buildStrip(weight) {\n  const nib = NIB * (0.94 + 1.1 * weight), hair = HAIR * (0.9 + 0.8 * weight);\n  let adv = 0;\n  const xs = [];\n  for (const ch of LINE) xs.push(adv), (adv += GLYPHS[ch][0]);\n  const P = round(adv * E), HW = P * SS, HH = SH * SS, hi = new Uint8Array(HW * HH), tiles = {};\n  LINE.split(\"\").forEach((ch, c) => {\n    if (ch === \" \") return;\n    const { t, TW } = tiles[ch] || (tiles[ch] = glyphTile(ch, nib, hair));\n    const o = round((xs[c] - PAD) * K);\n    for (let j = 0; j \u003c HH; j++)\n      for (let i = 0; i \u003c TW; i++) if (t[j * TW + i]) hi[j * HW + ((o + i + HW) % HW)] = 1;\n  });\n  const SW = 2 * P, SW1 = SW + 1, sat = new Int32Array((SH + 1) * SW1);\n  for (let r = 0; r \u003c SH; r++) {\n    let run = 0;\n    for (let c = 0; c \u003c SW; c++) {\n      const cc = c % P;\n      let n = 0;\n      for (let j = 0; j \u003c SS; j++) for (let i = 0; i \u003c SS; i++) n += hi[(r * SS + j) * HW + cc * SS + i];\n      run += n;\n      sat[(r + 1) * SW1 + c + 1] = sat[r * SW1 + c + 1] + run;\n    }\n  }\n  return { P, SW, sat };\n}\n\n// The ink above row v and left of column u, bilinear between the corners,\n// which is the exact area integral of ink that is constant over a texel.\nfunction satAt(st, u, v) {\n  const SW1 = st.SW + 1, sat = st.sat;\n  let iu = floor(u), iv = floor(v), fu = u - iu, fv = v - iv;\n  if (iu >= st.SW) (iu = st.SW - 1), (fu = 1);\n  if (iv >= SH) (iv = SH - 1), (fv = 1);\n  const o = iv * SW1 + iu, a = sat[o], b = sat[o + 1], c = sat[o + SW1], d = sat[o + SW1 + 1];\n  return (a + (b - a) * fu) * (1 - fv) + (c + (d - c) * fu) * fv;\n}\n\n// ---- The sheet. Line v (v = 0 the top line) fills rows 128 (1 - r^v) to\n// 128 (1 - r^(v+1)), its em that height over LEAD, its left edge 0.06 em in.\n// That is the picture of one page scaled by r about its bottom left corner\n// again and again, so moving every v down by one over a period zooms the\n// page by 1/r and each line takes the place and size of the line above.\nconst LEAD = 1.05, PERIOD = 2.5;\n// The grain: a checker of LEDs G levels lighter and darker over the whole\n// sheet, eased off where a soft step of the ink's own is already there so\n// the two never add up past a step of 40.\nconst G = 19.5, HARD = 60;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, w: -1, st: null, cache: {}, hue: 0, ratio: 0.7,\n    cov: new Float32Array(W * H), emRow: new Float32Array(H), F: new Float32Array(W + 1),\n    pc: [0, 0, 0], ic: [0, 0, 0],\n  };\n  return params.s;\n}\n\nexport function update(dt, input, params) {\n  const S0 = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0.7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S0.hue = kv[0] || 0;\n  const speed = cl(kv[1] ?? 2, 0.2, 3);\n  S0.ratio = cl(kv[2] ?? 0.7, 0.7, 0.9);\n  // The weight in sixteenths. A strip takes about 40 ms to build, so the\n  // last few are kept while the knob turns.\n  const w = round(cl(kv[3] ?? 0.06, 0, 1) * 16) / 16;\n  if (w !== S0.w) {\n    if (!S0.cache[w] && Object.keys(S0.cache).length >= 6) S0.cache = {};\n    S0.w = w;\n    S0.st = S0.cache[w] || (S0.cache[w] = buildStrip(w));\n  }\n  S0.t += (d * speed) / 2;\n}\n\nexport function draw(display, params) {\n  const S0 = params.s;\n  if (!S0 || !S0.st) return;\n  const st = S0.st, cov = S0.cov, emRow = S0.emRow, F = S0.F, P = st.P;\n  cov.fill(0);\n  emRow.fill(0);\n  const lr = log(S0.ratio), cyc = S0.t / PERIOD, ph = cyc % 1, n0 = floor(cyc);\n  const Y = (v) => H - H * exp(v * lr);\n  for (let k = 0; k \u003c 200; k++) {\n    const v = k - ph, top = Y(v), bot = Y(v + 1);\n    if (H - top \u003c 0.04) break;\n    if (bot \u003c= 0) continue;\n    const em = (bot - top) / LEAD, y0 = top + ((LEAD - 1) / 2) * em, sc = E / em, xl = 0.06 * em;\n    for (let y = max(0, floor(top)); y \u003c min(H, ceil(bot)); y++) {\n      const va = cl((y - y0) * sc, 0, SH), vb = cl((y + 1 - y0) * sc, 0, SH);\n      if (vb \u003c= va) continue;\n      if (em > emRow[y]) emRow[y] = em;\n      // Every other line leans 12 degrees for the italic: a texel row h\n      // above the baseline is read 0.21 h further left.\n      const sl = (k + n0) & 1 ? 0.21 * (BASE - (va + vb) / 2) : 0;\n      for (let x = 0; x \u003c= W; x++) F[x] = max(0, (x - xl) * sc - sl);\n      for (let x = 0, o = y * W; x \u003c W; x++) {\n        let u0 = F[x], u1 = F[x + 1];\n        if (u1 \u003c= u0) continue;\n        const wrap = floor(u0 / P) * P;\n        u0 -= wrap;\n        u1 -= wrap;\n        cov[o + x] += (satAt(st, u1, vb) - satAt(st, u0, vb) - satAt(st, u1, va) + satAt(st, u0, va)) / (16 * sc * sc);\n      }\n    }\n  }\n  // Type over 4 LEDs to the cap is drawn crisp, its coverage pushed toward\n  // ink or paper with a soft edge a quarter of an LED wide; under 1.5 LEDs\n  // it keeps its exact area, the grey of the small sizes.\n  for (let y = 0; y \u003c H; y++) {\n    const m = 1 + 3 * cl((emRow[y] * CAP - 1.5) / 2.5, 0, 1);\n    for (let x = 0, o = y * W; x \u003c W; x++) cov[o + x] = cl((min(1, cov[o + x]) - 0.5) * m + 0.5, 0, 1);\n  }\n  const pc = hsv(0.12 + S0.hue, 0.28, 0.92, S0.pc), ic = hsv(0.62 + S0.hue, 0.85, 0.075, S0.ic);\n  const con = 255 * (max(pc[0], pc[1], pc[2]) - max(ic[0], ic[1], ic[2])), hc = HARD / con;\n  const p0 = 255 * pc[0], p1 = 255 * pc[1], p2 = 255 * pc[2];\n  const d0 = 255 * ic[0] - p0, d1 = 255 * ic[1] - p1, d2 = 255 * ic[2] - p2;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const c = cov[o];\n      let gd = 0;\n      const nb = (e) => (e = abs(c - e)) \u003c hc && e > gd && (gd = e);\n      if (x > 0) nb(cov[o - 1]);\n      if (x \u003c W - 1) nb(cov[o + 1]);\n      if (y > 0) nb(cov[o - W]);\n      if (y \u003c H - 1) nb(cov[o + W]);\n      const a = G * max(0, 1 - (gd * con) / (2 * G)), g = (x + y) & 1 ? a : -a;\n      display.setPixel(x, y, cl(p0 + d0 * c + g, 0, 255) | 0, cl(p1 + d1 * c + g, 0, 255) | 0, cl(p2 + d2 * c + g, 0, 255) | 0);\n    }\n}\n","aharonov-bohm":"// ===== Patternflow pattern =====\n// Title:   Aharonov-Bohm\n// Family:  wave\n// Idea:    Plane waves run down the panel past a thin tube of magnetic flux a third of the way down, where no field reaches them, yet behind the tube the crests on the two sides of its shadow line come out shifted against each other by the flux in quanta and end at a torn seam, coloured by how far each crest has slipped behind the wave that would pass with no tube.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Aharonov-Bohm effect (Yakir Aharonov and David Bohm, 1959; Werner Ehrenberg and Raymond Siday, 1949), wavefront dislocations (Michael Berry, Robert Chambers, Mark Large, Colin Upstill and J. C. Walmsley, 1980), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wavelength=7..16, Flux=0.5..1.5\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 a crest that passes as if there were no tube is blue; at the opening flux of half a quantum the crests left of the shadow line come out a quarter wave ahead and turn green, those on the right a quarter wave behind and turn magenta, and a crest a whole wave out would be blue again.\n// Knob 2: Speed. How fast the crests run down: 8 LEDs a second at 2, 0.8 at 0.2 and 12 at 3.\n// Knob 3: Wavelength. The distance between crests, 7 LEDs at the opening, 16 at the top. A longer wave diffracts more: the band behind the tube where the two sides blend is about the square root of wavelength times distance wide, 25 LEDs across at the bottom row at 7 and 37 at 16.\n// Knob 4: Flux. The flux through the tube in flux quanta h/e. At 0.5 the two sides come out half a wave apart and the shadow line is an exact dark seam; at 1 the wave passes as if the tube were not there; at 1.5 it is half a wave again, the mirror image of 0.5. The wave only knows the flux modulo one quantum.\n\nconst W = 64, H = 128, N = W * H, HALF = W / 2;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, exp, pow, cbrt, atan2, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The tube sits on the corner between four LEDs, on the middle line, a third\n// of the way down.\nconst TX = 32, TY = 42;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Gamma on [1, 2] by Lanczos (g = 7, nine terms), good to about 1e-15.\nconst LZ = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7];\nfunction gamma(x) {\n  x -= 1;\n  let a = LZ[0];\n  const t = x + 7.5;\n  for (let i = 1; i \u003c 9; i++) a += LZ[i] / (x + i);\n  return sqrt(2 * PI) * pow(t, x + 0.5) * exp(-t) * a;\n}\n\n// Bessel functions J of orders nu0, nu0 + 1, ..., nu0 + M at z, for one\n// fractional part nu0 in [0, 1), by Miller's backward recurrence\n//   J(v - 1) = (2 v / z) J(v) - J(v + 1)\n// started from nothing well above z, then scaled by Neumann's sum\n//   (z / 2)^nu0 = sum over k of (nu0 + 2k) Gamma(nu0 + k) / k! J(nu0 + 2k),\n// whose weights w[k] depend on nu0 only.\nfunction weights(nu0, K) {\n  const w = new Float64Array(K + 1);\n  w[0] = gamma(nu0 + 1);\n  let g = w[0];\n  for (let k = 1; k \u003c= K; k++) {\n    w[k] = (nu0 + 2 * k) * g;\n    g = (g * (nu0 + k)) / (k + 1);\n  }\n  return w;\n}\nfunction besselRun(nu0, z, M, w, out) {\n  let fp = 0, f = 1e-30, sum = (M & 1) === 0 ? w[M >> 1] * f : 0;\n  out[M] = f;\n  for (let n = M; n >= 1; n--) {\n    const fm = ((2 * (nu0 + n)) / z) * f - fp;\n    fp = f;\n    f = fm;\n    out[n - 1] = f;\n    if (((n - 1) & 1) === 0) sum += w[(n - 1) >> 1] * f;\n    if (abs(f) > 1e200) {\n      for (let j = n - 1; j \u003c= M; j++) out[j] *= 1e-200;\n      (sum *= 1e-200), (fp *= 1e-200), (f *= 1e-200);\n    }\n  }\n  const sc = pow(z / 2, nu0) / sum;\n  for (let n = 0; n \u003c= M; n++) out[n] *= sc;\n}\n\n// The Aharonov-Bohm wave. Round the tube the vector potential circles with\n// A = a / r in units of the flux quantum, and the wave equation splits into\n// angular orders m, each with the radial Bessel function of order |m - a|.\n// With theta measured from the way the wave runs (down the panel), the\n// solution that is regular at the tube and whose incoming part is the plane\n// wave exp(i k x) is\n//   psi = sum over m of (-1)^m (-i)^|m - a| J_|m - a|(k r) exp(i m theta),\n// Aharonov and Bohm's series turned to face down the panel. At a = 0 it is\n// the plane wave to 1e-14; at a = 1/2 the orders m and 1 - m pair off and\n// cancel on theta = 0, so the shadow line is an exact zero.\n//\n// Which a? The flux F in quanta enters only as exp(2 pi i F) round a loop,\n// so F and F + 1 are the same physics, and a whole quantum can be taken out\n// by a gauge change. The picture takes one out, a = F - 1, so F = 1 is the\n// bare plane wave exactly, as F = 0 would be. Over the knob's range a runs\n// from -1/2 to 1/2: the two ends are both half a quantum, drawn in gauges a\n// quantum apart, and come out as mirror images, the same seam with the\n// colours of its sides swapped. The orders' sum is done for an LED and its\n// mirror across the shadow line at once, since they share r and differ only\n// in the sign of theta.\nconst MM = 260, ROWS = 32;\n\n// A field is worked out in a buffer of its own, ROWS rows a frame, while the\n// last finished one stays on the panel; the first appears after 4 frames.\nfunction newField() {\n  return { amp: new Float32Array(N), ph: new Float32Array(N), lag: new Float32Array(N), lam: 0, flux: 0, row: 0, a: 0, k: 0, nuP: 0, nuQ: 0, wP: null, wQ: null };\n}\nfunction begin(S, G, F, lam) {\n  const a = F - 1, fr = (x) => x - floor(x);\n  Object.assign(G, { lam, flux: F, row: 0, a, k: (2 * PI) / lam, nuP: fr(-a), nuQ: fr(a) });\n  G.wP = weights(G.nuP, MM);\n  G.wQ = weights(G.nuQ, MM);\n  const { fam, nn, cr, ci } = S;\n  for (let m = -MM; m \u003c= MM; m++) {\n    const d = m - a, j = m + MM, sg = m & 1 ? -1 : 1, nu = abs(d);\n    if (d >= 0) (fam[j] = 0), (nn[j] = round(d - G.nuP));\n    else (fam[j] = 1), (nn[j] = round(-d - G.nuQ));\n    cr[j] = sg * cos((PI * nu) / 2);\n    ci[j] = -sg * sin((PI * nu) / 2);\n  }\n}\nfunction rows(S, G, y0, y1) {\n  const { JP, JQ, fam, nn, cr, ci } = S, { amp, ph, lag, k, nuP, nuQ, wP, wQ } = G;\n  const put = (p, re, im, ox) => {\n    amp[p] = sqrt(re * re + im * im);\n    ph[p] = atan2(im, re);\n    // The slip behind the bare wave exp(i k x), in turns, -1/2 to 1/2.\n    const l = (ph[p] - ox) / (2 * PI);\n    lag[p] = l - round(l);\n  };\n  for (let y = y0; y \u003c y1; y++) {\n    const X = y + 0.5 - TY;\n    for (let x = HALF; x \u003c W; x++) {\n      const Y = x + 0.5 - TX, r = sqrt(X * X + Y * Y), th = atan2(Y, X), z = k * r;\n      let M = ceil(z + 8 * cbrt(z) + 16);\n      M = min(MM - 2, M + (M & 1));\n      besselRun(nuP, z, M + 1, wP, JP);\n      besselRun(nuQ, z, M + 1, wQ, JQ);\n      // A = sum c_m J cos(m theta), B = sum c_m J sin(m theta), both complex;\n      // psi(theta) = A + iB and psi(-theta) = A - iB.\n      let Ar = 0, Ai = 0, Br = 0, Bi = 0, cm = 1, sm = 0;\n      const c1 = cos(th), s1 = sin(th);\n      for (let m = 0; m \u003c= M; m++) {\n        let j = m + MM, J = fam[j] ? JQ[nn[j]] : JP[nn[j]];\n        (Ar += cr[j] * J * cm), (Ai += ci[j] * J * cm), (Br += cr[j] * J * sm), (Bi += ci[j] * J * sm);\n        if (m > 0) {\n          (j = MM - m), (J = fam[j] ? JQ[nn[j]] : JP[nn[j]]);\n          (Ar += cr[j] * J * cm), (Ai += ci[j] * J * cm), (Br -= cr[j] * J * sm), (Bi -= ci[j] * J * sm);\n        }\n        const t = cm * c1 - sm * s1;\n        sm = sm * c1 + cm * s1;\n        cm = t;\n      }\n      put(y * W + x, Ar - Bi, Ai + Br, k * X);\n      put(y * W + W - 1 - x, Ar + Bi, Ai - Br, k * X);\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, t: 0, cur: null, job: null, spare: [newField(), newField()],\n    JP: new Float64Array(MM + 2), JQ: new Float64Array(MM + 2),\n    fam: new Int8Array(2 * MM + 1), nn: new Int32Array(2 * MM + 1), cr: new Float64Array(2 * MM + 1), ci: new Float64Array(2 * MM + 1),\n    c: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 7, 0.5], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // A new field starts only when the wavelength or the flux has moved by a\n  // visible step; turning the knob again restarts it.\n  const lam = round(cl(k[2], 7, 16) * 20) / 20, flux = round(cl(k[3], 0.5, 1.5) * 200) / 200;\n  const aim = S.job || S.cur;\n  if (!aim || aim.lam !== lam || aim.flux !== flux) {\n    S.job = S.spare.find((G) => G !== S.cur);\n    begin(S, S.job, flux, lam);\n  }\n  if (S.job) {\n    const G = S.job, y1 = min(H, G.row + ROWS);\n    rows(S, G, G.row, y1);\n    G.row = y1;\n    if (y1 >= H) (S.cur = G), (S.job = null);\n  }\n  S.t += d;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cur) return;\n  const { amp, ph, lag, lam } = S.cur, c = S.c;\n  // Crests run down at 4 * Speed LEDs a second: the phase turns by k v t.\n  const wt = ((2 * PI) / lam) * 4 * S.speed * S.t, h0 = 0.62 + S.hue;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, A = amp[p];\n      const re = A * cos(ph[p] - wt);\n      const crest = re > 0 ? pow(re, 1.6) : 0;\n      const v = min(1, 0.07 * A + 0.93 * crest);\n      hsv(h0 + lag[p], 0.85 - 0.35 * crest * crest, v, c);\n      display.setPixel(x, y, (255 * c[0]) | 0, (255 * c[1]) | 0, (255 * c[2]) | 0);\n    }\n  // The tube itself, end on: a small white core.\n  for (let p = 0; p \u003c 4; p++) display.setPixel(31 + (p & 1), 41 + (p >> 1), 235, 235, 245);\n}\n","boustrophedon":"// ===== Patternflow pattern =====\n// Title:   Boustrophedon\n// Family:  type\n// Idea:    A point of light ploughs a field of twenty furrows line after line, turning under the cooled letters of its last pass and writing Hesiod's crane passage into the furrow behind it, mirrored on every line it ploughs back, so the eye follows the ox across the panel and down.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: boustrophedon, the archaic Greek way of writing as the ox turns (the law code of Gortyn, 5th century BC), reverse boustrophedon as in rongorongo; text from Hesiod, Works and Days 448-451, translated by Hugh G. Evelyn-White (1914); pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Way=-1..1, Words=0..2\n//\n// Knob 1: Hue. Turns the field and the letters round the wheel together: at 0 the furrows run from deep blue in the troughs to pale blue on the ridges, fresh letters are cream gold and cool to light blue over half a minute.\n// Knob 2: Speed. How fast the plough writes: 8 letters a second at 2, so a line of 15 takes under 2 s and the whole field of 300 about 40 s; 0.8 a second at 0.2, 12 at 3.\n// Knob 3: Way. How the plough turns at the end of a line, taken up at the start of the next one. At 0 boustrophedon: the plough turns and writes the next line right to left with every letter mirrored. At -1 every line runs left to right and the plough lifts and flies back to the left edge. At 1 reverse boustrophedon, as on the rongorongo tablets: the return lines are turned upside down, as if the field were turned round for each.\n// Knob 4: Words. How words are parted. At 0 by a column of three dots, the word divider of many archaic inscriptions; at 1 not at all, the letters run on as scriptio continua; at 2 by a blank, as we write now.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Capitals, 3 by 5, rows from the top. Archaic inscriptions were cut in\n// capitals with no small letters. Glyph 26 is the word divider, three dots in\n// a column; 27 is a blank.\nconst GLYPHS = [\n  \"010101111101101\", \"110101110101110\", \"011100100100011\", \"110101101101110\", \"111100110100111\",\n  \"111100110100100\", \"011100101101011\", \"101101111101101\", \"111010010010111\", \"001001001101010\",\n  \"101101110101101\", \"100100100100111\", \"101111111101101\", \"111101101101101\", \"010101101101010\",\n  \"110101110100100\", \"010101101110011\", \"110101110101101\", \"011100010001110\", \"111010010010010\",\n  \"101101101101111\", \"101101101101010\", \"101101111111101\", \"101101010101101\", \"101101010010010\",\n  \"111001010100111\", \"010000010000010\", \"000000000000000\",\n];\nconst FONT = GLYPHS.map((g) => Uint8Array.from(g, (c) => +c));\nconst DIV = 26, BLANK = 27;\n\n// Hesiod, Works and Days 448-451, in Evelyn-White's translation: \"Mark, when\n// you hear the voice of the crane who cries year by year from the clouds\n// above, for she gives the signal for ploughing and shows the season of rainy\n// winter; but she vexes the heart of the man who has no oxen.\" The stone has\n// no commas: only letters and word breaks are kept, and the end of the\n// sentence is one more word break before it starts again.\nconst SRC =\n  \"MARK WHEN YOU HEAR THE VOICE OF THE CRANE WHO CRIES YEAR BY YEAR FROM THE CLOUDS ABOVE FOR SHE GIVES THE SIGNAL FOR PLOUGHING AND SHOWS THE SEASON OF RAINY WINTER BUT SHE VEXES THE HEART OF THE MAN WHO HAS NO OXEN \";\n// The text as cells for each way of parting words, and where each cell came\n// from in SRC, so turning Words mid-line carries on from the same place.\nconst SEQ = [[], [], []], SPOS = [[], [], []];\nfor (let m = 0; m \u003c 3; m++)\n  for (let i = 0; i \u003c SRC.length; i++) {\n    const ch = SRC[i];\n    if (ch === \" \") {\n      if (m === 1) continue;\n      SEQ[m].push(m === 0 ? DIV : BLANK);\n    } else SEQ[m].push(ch.charCodeAt(0) - 65);\n    SPOS[m].push(i);\n  }\n\n// ---- The field. 15 letters a line, 4 LEDs a cell (3 and a gap), from x = 2;\n// 20 lines 6 rows apart from y = 4, the letter in the 5 rows of the furrow\n// and the ridge in the sixth. The furrows run on into the 4-row margins.\nconst NC = 15, NL = 20, CW = 4, LP = 6, X0 = 2, Y0 = 4, CELLS = NC * NL;\n// Across a furrow the ground climbs and falls by D a row, trough in the\n// middle of the letter, ridge between lines. Along it the soil is grained a\n// column at a time, so every pair of neighbours differs a little.\nconst LO = 6, D = 24;\nconst TRI = [2, 1, 0, 1, 2, 3];\nconst ROWB = new Float32Array(H), ROWT = new Float32Array(H);\nfor (let y = 0; y \u003c H; y++) {\n  const r = (((y - Y0) % LP) + LP) % LP;\n  ROWB[y] = LO + D * TRI[r];\n  ROWT[y] = TRI[r] / 3;\n}\nconst GRAIN = new Float32Array(W * H);\nfor (let p = 0; p \u003c W * H; p++) {\n  let h = (p * 2654435761) >>> 0;\n  h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0;\n  h = ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n  GRAIN[p] = (p % W) & 1 ? 20 + 10 * h : 6 * h;\n}\n\n// Letters give their own light, so cloud shadows pass them by. A fresh one\n// stands at C_NEW and sinks to C_OLD as it cools; each keeps a third of the\n// furrow's shape and most of its grain, so the strokes are not flat.\nconst C_NEW = 226, C_OLD = 216, TAU = 30, KEEP_SHAPE = 0.33, KEEP_GRAIN = 0.7;\n\n// Cells a second at Speed s; a turn costs one cell's time, the flight back\n// to the left edge three.\nconst RATE = 4;\n// Light of the share's point and of the turned soil behind it.\nconst SHARE = 220, WAKE = 60;\nconst turnLen = (way) => (way \u003c 0 ? 3 : 1);\n// Direction and orientation of grid line l written the given way:\n// orientation 0 upright, 1 mirrored, 2 turned 180 degrees. Rongorongo is\n// read from the bottom line up; here every way ploughs from the top down, so\n// only the turn at the end of a line changes.\nconst dirOf = (way, l) => (way !== 0 && way !== 1) || l % 2 === 0 ? 1 : -1;\nconst orientOf = (way, l) => (dirOf(way, l) > 0 ? 0 : way === 0 ? 1 : 2);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, ready: false, hue: 0, speed: 2, way: 0, words: 0,\n    line: 0, pos: 0, lineWay: 0, j: 0, cell: -1,\n    glyph: new Uint8Array(CELLS), orient: new Uint8Array(CELLS), birth: new Float32Array(CELLS),\n    // What lay in the cell under the plough before it got there.\n    oldG: 0, oldO: 0, oldB: 0,\n    rgb: new Float32Array(W * H * 3),\n  };\n}\n\n// Grid cell of in-line step i on grid line l, written in direction dir.\nconst cellAt = (l, i, dir) => l * NC + (dir > 0 ? i : NC - 1 - i);\n\n// The field the plough finds when it starts: the pass before, written the\n// same way, ending with the cells just before the opening words, its oldest\n// letters already cooled.\nfunction prefill(S) {\n  const seq = SEQ[S.words], P = seq.length, rate = RATE * S.speed;\n  const per = NC + turnLen(S.way);\n  for (let l = 0; l \u003c NL; l++) {\n    const dir = dirOf(S.way, l), o = orientOf(S.way, l);\n    for (let i = 0; i \u003c NC; i++) {\n      const k = l * NC + i, c = cellAt(l, i, dir);\n      S.glyph[c] = seq[(((k - CELLS) % P) + P) % P];\n      S.orient[c] = o;\n      S.birth[c] = -(NL * per - (l * per + i)) / rate;\n    }\n  }\n  S.j = 0;\n  S.lineWay = S.way;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.way = cl(round(k[2]), -1, 1);\n  const words = cl(round(k[3]), 0, 2);\n  if (words !== S.words) {\n    // Carry on from the same place in the sentence with the new parting.\n    const from = SPOS[S.words][S.j % SPOS[S.words].length];\n    const sp = SPOS[words];\n    let j = 0;\n    while (j \u003c sp.length && sp[j] \u003c from) j++;\n    S.j = j % sp.length;\n    S.words = words;\n  }\n  if (!S.ready) {\n    prefill(S);\n    S.ready = true;\n  }\n  S.t += d;\n  S.pos += d * RATE * S.speed;\n  const end = NC + turnLen(S.lineWay);\n  if (S.pos >= end) {\n    S.pos -= end;\n    S.line++;\n    S.lineWay = S.way;\n    S.cell = -1;\n  }\n  const l = S.line % NL, i = floor(S.pos);\n  if (i \u003c NC) {\n    const c = cellAt(l, i, dirOf(S.lineWay, l));\n    if (c !== S.cell) {\n      // The share reaches a new cell: what was there is turned under as the\n      // next letter of the text goes in.\n      S.cell = c;\n      S.oldG = S.glyph[c], S.oldO = S.orient[c], S.oldB = S.birth[c];\n      const seq = SEQ[S.words];\n      S.glyph[c] = seq[S.j % seq.length];\n      S.j = (S.j + 1) % seq.length;\n      S.orient[c] = orientOf(S.lineWay, l);\n      S.birth[c] = S.t;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const { rgb } = S, t = S.t, hue = S.hue;\n  const trough = hsv(0.66 + hue, 0.78, 1), ridge = hsv(0.55 + hue, 0.42, 1);\n  const fresh = hsv(0.12 + hue, 0.38, 1), cool = hsv(0.6 + hue, 0.5, 1);\n\n  // Cloud shadows drift over the soil, darkening it by up to 38%.\n  const cx = 0.07, cy = 0.045, wx = 0.035, wy = -0.06;\n  const ca = t * 0.9, cb = t * 0.7 + 1.7;\n\n  for (let y = 0; y \u003c H; y++) {\n    const base = ROWB[y], tt = ROWT[y];\n    let r0 = trough[0] + (ridge[0] - trough[0]) * tt, g0 = trough[1] + (ridge[1] - trough[1]) * tt, b0 = trough[2] + (ridge[2] - trough[2]) * tt;\n    const m = max(r0, g0, b0);\n    (r0 /= m), (g0 /= m), (b0 /= m);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      const cloud = 0.81 + 0.095 * (sin(cx * x + cy * y - ca) + sin(wx * x + wy * y + cb));\n      const v = (base + GRAIN[p]) * cloud;\n      rgb[p * 3] = r0 * v, rgb[p * 3 + 1] = g0 * v, rgb[p * 3 + 2] = b0 * v;\n    }\n  }\n\n  // The plough: where it is along the current line, and the column of the\n  // cell it is in that its share has reached.\n  const l = S.line % NL, dir = dirOf(S.lineWay, l), i = floor(S.pos), f = S.pos - i;\n  for (let c = 0; c \u003c CELLS; c++) {\n    const col = c % NC, row = floor(c / NC), x0 = X0 + col * CW, y0 = Y0 + row * LP;\n    const under = c === S.cell && i \u003c NC;\n    for (let q = 0; q \u003c 3; q++) {\n      // Under the plough, columns it has passed show the new letter and the\n      // rest the old one.\n      let g = S.glyph[c], o = S.orient[c], b = S.birth[c];\n      if (under) {\n        const u = dir > 0 ? (q + 0.5) / CW : (CW - 0.5 - q) / CW;\n        if (u >= f) (g = S.oldG), (o = S.oldO), (b = S.oldB);\n      }\n      const gl = FONT[g], age = t - b, w = exp(-age / TAU);\n      const lvl = C_OLD + (C_NEW - C_OLD) * w, glint = age \u003c 0.5 ? 40 * (1 - age / 0.5) : 0;\n      const cr = cool[0] + (fresh[0] - cool[0]) * w, cg = cool[1] + (fresh[1] - cool[1]) * w, cb2 = cool[2] + (fresh[2] - cool[2]) * w;\n      const cm = max(cr, cg, cb2);\n      for (let r = 0; r \u003c 5; r++) {\n        const sq = o === 0 ? q : 2 - q, sr = o === 2 ? 4 - r : r;\n        if (!gl[sr * 3 + sq]) continue;\n        const y = y0 + r, x = x0 + q, p = y * W + x;\n        const v = min(255, lvl + glint + KEEP_SHAPE * (ROWB[y] - LO) + KEEP_GRAIN * GRAIN[p]);\n        rgb[p * 3] = (cr / cm) * v, rgb[p * 3 + 1] = (cg / cm) * v, rgb[p * 3 + 2] = (cb2 / cm) * v;\n      }\n    }\n  }\n\n  // The point of the share, a warm light in the furrow, and the turned soil\n  // behind it glowing for a few cells. On the flight back to the left edge\n  // the share is lifted and dim.\n  let tx, ty, a = 1, wake = 1, wx0;\n  const yl = Y0 + l * LP + 2;\n  if (i \u003c NC) {\n    const col = dir > 0 ? i : NC - 1 - i;\n    tx = X0 + col * CW + (dir > 0 ? f * CW : (1 - f) * CW);\n    ty = yl;\n    wx0 = tx;\n  } else {\n    const u = (S.pos - NC) / turnLen(S.lineWay), sm = u * u * (3 - 2 * u);\n    const nl = (l + 1) % NL, xe = dir > 0 ? X0 + NC * CW : X0;\n    const xs = S.lineWay \u003c 0 ? X0 : dirOf(S.lineWay, nl) > 0 ? X0 : X0 + NC * CW;\n    const ny = Y0 + nl * LP + 2;\n    tx = xe + (xs - xe) * sm;\n    ty = yl + (ny - yl) * sm;\n    wx0 = xe;\n    wake = 1 - u;\n    if (S.lineWay \u003c 0) a = 0.35 + 0.65 * Math.abs(1 - 2 * u);\n  }\n  const lamp = hsv(0.1 + hue, 0.3, 1), soil = hsv(0.07 + hue, 0.55, 1);\n  for (let y = yl - 2; y \u003c= yl + 3; y++) {\n    const rw = y === yl + 3 ? 0.5 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const ahead = (x + 0.5 - wx0) * dir;\n      const v = WAKE * wake * rw * (ahead > 0 ? exp(-ahead * ahead) : exp(ahead / 7));\n      if (v \u003c 1) continue;\n      const p = (y * W + x) * 3;\n      rgb[p] += soil[0] * v, rgb[p + 1] += soil[1] * v, rgb[p + 2] += soil[2] * v;\n    }\n  }\n  const x0 = max(0, floor(tx - 9)), x1 = min(W - 1, floor(tx + 9)), y0 = max(0, floor(ty - 9)), y1 = min(H - 1, floor(ty + 9));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x + 0.5 - tx, dy = y + 0.5 - ty, r2 = dx * dx + dy * dy;\n      const v = a * (SHARE * exp(-r2 / 1.8) + 50 * exp(-r2 / 30));\n      const p = (y * W + x) * 3;\n      rgb[p] += lamp[0] * v, rgb[p + 1] += lamp[1] * v, rgb[p + 2] += lamp[2] * v;\n    }\n\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), min(255, rgb[p * 3]) | 0, min(255, rgb[p * 3 + 1]) | 0, min(255, rgb[p * 3 + 2]) | 0);\n}\n","calculator-words":"// ===== Patternflow pattern =====\n// Title:   Calculator Words\n// Family:  type\n// Idea:    A pocket calculator fills the panel and keys in a little sum, its keys lighting as they go down, then turns itself upside down so the answer on its seven-segment display reads as a word, 0.7734 as hELLO with the decimal point hanging at the top of the line, holds it, and turns back for the next riddle.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: upside-down calculator spelling on seven-segment displays (BEGHILOS, the 1970s pocket calculator pastime), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Words=0..3, Glow=0..1\n//\n// Knob 1: Hue. The colour of the display, with the operator keys and the body following it round the wheel: at 0 a blue-green vacuum fluorescent display over orange operator keys on a slate body; at 0.54 the red of the first LED calculators.\n// Knob 2: Speed. How fast the machine works: at 2 a key goes down every 0.22 s and the turn takes 1.3 s, so hELLO is keyed, turned, read and turned back in 7.7 s; at 0.2 it takes ten times as long, at 3 two thirds.\n// Knob 3: Words. Which riddles: 0 the classics (hELLO, BOSS, LOSE, GLOBE, GOOSE, EGGSHELL); 1 short words (hI, BEE, OIL, BIG, EGG, ShOE, SOIL); 2 long ones made by multiplying two numbers (LEGIBLE, SLEIGh, BOGGLE, OBLIGE, GIGGLE, SIZZLE, hOBBIES); 3 answers under 1, whose decimal point turns up at the top of the word (IGLOO, hELLO, SILO, SOLO, hOBO, BOO).\n// Knob 4: Glow. How much light the display spills: at 0 the unlit segments are almost gone and the digits stand sharp on dark glass; at the opening 0.06 the unlit segments show faintly as a ghost 8 in every place; at 1 the ghosts glow at half strength, a haze spreads round every lit digit, and the display's light falls over the body and the top rows of keys.\n// Buttons: any knob's button clears the calculator and starts the next riddle, when the calculator stands the right way up.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The riddles. Each is the sum the machine keys after C, written with *\n// and / for the keys x and the division sign; = follows. Read upside down,\n// a digit becomes the letter its segments make when turned: 0 O, 1 I, 2 Z,\n// 3 E, 4 h, 5 S, 7 L, 8 B, 9 G (a 9 with its tail turns into a 6 shape).\n// The order of the digits turns round as well, so 0.7734 reads hELLO.\n// Every answer was checked by turning the segment masks below, not by a\n// table of letters: the display is only ever drawn the right way up.\nconst SETS = [\n  // 0.7734 hELLO, 5508 BOSS, 3507 LOSE, 38079 GLOBE, 35009 GOOSE, and SHELL\n  // (77345) times 1000 plus 993, 77345993 EGGSHELL, the longest the 8 places\n  // hold.\n  [\"1-.2266\", \"68*81\", \"21*167\", \"9*4231\", \"13*2693\", \"155*499*1000+993\"],\n  // 14 hI, 338 BEE, 710 OIL, 918 BIG, 993 EGG, 3045 ShOE, 7105 SOIL.\n  [\"2*7\", \"13*26\", \"10*71\", \"27*34\", \"3*331\", \"35*87\", \"29*245\"],\n  // 3781937 LEGIBLE, 491375 SLEIGh, 379908 BOGGLE, 391780 OBLIGE, 379919\n  // GIGGLE, 372215 SIZZLE, 5318804 hOBBIES.\n  [\"967*3911\", \"125*3931\", \"519*732\", \"380*1031\", \"181*2099\", \"493*755\", \"4*1329701\"],\n  // 0.0791 IGLOO, 0.7734 hELLO, 0.715 SILO, 0.705 SOLO, 0.804 hOBO, 0.08 BOO.\n  [\".113*.7\", \"3.867/5\", \"1.43/2\", \"1.41/2\", \"4.02/5\", \".2*.4\"],\n];\n\n// ---- Seven segments, bit 0 to 6 for a to g: a the top bar, b and c the\n// right side from the top, d the bottom bar, e and f the left side from the\n// bottom, g the middle bar. A 6 keeps its top bar and a 9 its tail, a 7 has\n// no f: so a turned 7 is an L and not a 4 with a hook.\nconst SEG = { 0: 63, 1: 6, 2: 91, 3: 79, 4: 102, 5: 109, 6: 125, 7: 7, 8: 127, 9: 111, \"-\": 64 };\n// A digit is 5 LEDs wide and 11 tall, 1 LED strokes, with the corners left\n// dark so every segment stands apart; the decimal point sits one column to\n// the right of the bottom bar.\nconst SEGPX = [[], [], [], [], [], [], []];\nfor (let i = 1; i \u003c= 3; i++) SEGPX[0].push([i, 0]), SEGPX[3].push([i, 10]), SEGPX[6].push([i, 5]);\nfor (let j = 1; j \u003c= 4; j++) SEGPX[1].push([4, j]), SEGPX[5].push([0, j]), SEGPX[2].push([4, j + 5]), SEGPX[4].push([0, j + 5]);\nconst DIG_X = 5, DIG_P = 7, DIG_Y = 11;\n\n// ---- The keypad: 4 columns of 13 LEDs, 5 rows of 15, labels in 3 by 5.\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001001001001\", 8: \"111101111101111\", 9: \"111101111001111\",\n  C: \"011100100100011\", p: \"010111010000111\", \"%\": \"101001010100101\", d: \"010000111000010\", x: \"000101010101000\",\n  \"-\": \"000000111000000\", \"+\": \"000010111010000\", \"=\": \"000111000111000\", \".\": \"000000000000010\",\n};\nconst LAYOUT = [\n  [\"C\", \"p\", \"%\", \"d\"],\n  [\"7\", \"8\", \"9\", \"x\"],\n  [\"4\", \"5\", \"6\", \"-\"],\n  [\"1\", \"2\", \"3\", \"+\"],\n  [\"0\", null, \".\", \"=\"],\n];\nconst KEYS = [];\nLAYOUT.forEach((row, r) =>\n  row.forEach((id, c) => {\n    if (!id) return;\n    const wide = id === \"0\";\n    KEYS.push({ id, x: 3 + 15 * c, y: 32 + 19 * r, w: wide ? 28 : 13, kind: r === 0 ? 0 : c === 3 || id === \"=\" ? 2 : 1 });\n  }),\n);\nconst KEYIX = {};\nKEYS.forEach((k, i) => (KEYIX[k.id] = i));\n\n// Machine time is seconds at Speed 2.\nconst KEY = 0.22, HOLD = 0.8, TURN = 1.3, BACK = 1.1, PAUSE = 0.35;\n\n// ---- The arithmetic of a plain pocket calculator: an operator key works\n// out what is pending, left to right, and shows it.\nfunction fmt(v) {\n  if (!isFinite(v) || abs(v) >= 1e8) return \"E\";\n  const neg = v \u003c 0;\n  v = abs(v);\n  const ints = v \u003c 1 ? 1 : floor(Math.log10(v)) + 1;\n  let s = v.toFixed(max(0, 8 - ints));\n  if (s.indexOf(\".\") >= 0) s = s.replace(/0+$/, \"\").replace(/\\.$/, \"\");\n  return (neg ? \"-\" : \"\") + s;\n}\nfunction apply(a, op, b) {\n  return op === \"+\" ? a + b : op === \"-\" ? a - b : op === \"x\" ? a * b : b === 0 ? NaN : a / b;\n}\nfunction press(S, id) {\n  const c = S.calc;\n  if (id === \"C\") (c.acc = 0), (c.op = null), (c.entry = null), (c.disp = \"0\");\n  else if ((id >= \"0\" && id \u003c= \"9\") || id === \".\") {\n    if (c.entry === null) c.entry = id === \".\" ? \"0.\" : id;\n    else if (c.entry.replace(/\\D/g, \"\").length \u003c 8 && !(id === \".\" && c.entry.includes(\".\"))) c.entry += id;\n    c.disp = c.entry;\n  } else if (id === \"=\" || id === \"+\" || id === \"-\" || id === \"x\" || id === \"d\") {\n    if (c.entry !== null) {\n      c.acc = c.op ? apply(c.acc, c.op, Number(c.entry)) : Number(c.entry);\n      c.entry = null;\n      c.disp = fmt(c.acc);\n    }\n    c.op = id === \"=\" ? null : id;\n  }\n  if (KEYIX[id] !== undefined) S.pressed[KEYIX[id]] = S.clock;\n}\n\n// The display string, right aligned in 8 places, as segment masks with bit\n// 7 for the decimal point.\nfunction cells(disp) {\n  const out = new Uint8Array(8);\n  if (disp === \"E\") return (out[7] = 121), out;\n  let i = 7;\n  for (let j = disp.length - 1; j >= 0 && i >= 0; j--) {\n    const ch = disp[j];\n    if (ch === \".\") {\n      j--;\n      out[i--] = SEG[disp[j]] | 128;\n    } else out[i--] = SEG[ch];\n  }\n  return out;\n}\n\nfunction startRiddle(S) {\n  const list = SETS[S.set];\n  const expr = list[S.ri % list.length];\n  S.keys = [\"C\", ...expr.split(\"\").map((ch) => (ch === \"*\" ? \"x\" : ch === \"/\" ? \"d\" : ch)), \"=\"];\n  S.ki = 0;\n  S.mt = 0;\n  S.tEq = (S.keys.length - 1) * KEY;\n  S.read = 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, glow: 0.06, set: -1, ri: 0, keys: [], ki: 0, mt: 0, tEq: 0, read: 0, clock: 0,\n    theta: 0, calc: { acc: 0, op: null, entry: null, disp: \"0\" },\n    pressed: new Float32Array(KEYS.length).fill(-99),\n    face: new Float32Array(W * H * 3), halo: new Float32Array(W * 32), tmp: new Float32Array(W * 32),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.glow = cl(k[3], 0, 1);\n  const set = min(3, floor(cl(k[2], 0, 3)));\n  if (S.set \u003c 0) (S.set = set), startRiddle(S);\n  const step = (d * S.speed) / 2;\n  S.mt += step;\n  S.clock += step;\n  // Keys go down on the beat; a long frame may hold more than one.\n  while (S.ki \u003c S.keys.length && S.mt >= S.ki * KEY) press(S, S.keys[S.ki++]);\n  if (S.ki === S.keys.length && !S.read) S.read = 1.6 + 0.15 * S.calc.disp.replace(/\\D/g, \"\").length;\n  const t0 = S.tEq + HOLD, t1 = t0 + TURN, t2 = t1 + (S.read || 9), t3 = t2 + BACK;\n  // Over, then back the way it came.\n  S.theta = S.mt \u003c t1 ? PI * ease((S.mt - t0) / TURN) : PI * (1 - ease((S.mt - t2) / BACK));\n  let next = S.mt >= t3 + PAUSE;\n  if (input.btnPressed && input.btnPressed.some(Boolean) && S.theta === 0) next = true;\n  if (next) {\n    if (set !== S.set) (S.set = set), (S.ri = 0);\n    else S.ri++;\n    startRiddle(S);\n  }\n}\n\n// ---- Drawing the face, always the right way up, into a buffer of its own.\nfunction put(F, x, y, c, m) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (F[o] = c[0] * m), (F[o + 1] = c[1] * m), (F[o + 2] = c[2] * m);\n}\nfunction add(F, x, y, c, m) {\n  const o = (y * W + x) * 3;\n  (F[o] += c[0] * m), (F[o + 1] += c[1] * m), (F[o + 2] += c[2] * m);\n}\n\nfunction drawFace(S) {\n  const F = S.face, hd = 0.46 + S.hue, g = S.glow;\n  const body = hsv(hd + 0.15, 0.32, 0.15), bezel = hsv(hd + 0.15, 0.3, 0.06), glass = hsv(hd, 0.7, 0.035 + 0.1 * g);\n  const lit = hsv(hd, 0.55, 1), ghost = hsv(hd, 0.65, 0.07 + 0.45 * g), haze = hsv(hd, 0.8, 1);\n  F.fill(0);\n  // Body: a rounded slab 62 by 126 with a lit top edge and a dark bottom.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const cx = x + 0.5, cy = y + 0.5;\n      const qx = max(5 - cx, 0, cx - 59), qy = max(5 - cy, 0, cy - 123), a = cl(4.5 - sqrt(qx * qx + qy * qy), 0, 1);\n      if (a \u003c= 0) continue;\n      const sh = y \u003c= 1 ? 1.5 : y >= 126 ? 0.55 : x \u003c= 1 ? 1.2 : x >= 62 ? 0.75 : 1;\n      put(F, x, y, body, a * sh);\n    }\n  for (let y = 5; y \u003c= 27; y++) for (let x = 2; x \u003c= 61; x++) put(F, x, y, y === 27 ? body : bezel, y === 27 ? 1.35 : 1);\n  for (let y = 6; y \u003c= 26; y++) for (let x = 3; x \u003c= 60; x++) put(F, x, y, glass, 1);\n\n  // Display. The haze is the lit segments blurred twice by a 5-wide box.\n  const cs = cells(S.calc.disp), Hz = S.halo, T = S.tmp;\n  Hz.fill(0);\n  for (let i = 0; i \u003c 8; i++) {\n    const x0 = DIG_X + DIG_P * i;\n    for (let s = 0; s \u003c 7; s++) {\n      const on = (cs[i] >> s) & 1;\n      for (const [dx, dy] of SEGPX[s]) {\n        put(F, x0 + dx, DIG_Y + dy, on ? lit : ghost, 1);\n        if (on) Hz[(DIG_Y + dy - 4) * W + x0 + dx] = 1;\n      }\n    }\n    const dp = (cs[i] >> 7) & 1;\n    put(F, x0 + 5, DIG_Y + 10, dp ? lit : ghost, 1);\n    if (dp) Hz[(DIG_Y + 6) * W + x0 + 5] = 1;\n  }\n  for (let pass = 0; pass \u003c 2; pass++) {\n    for (let y = 0; y \u003c 32; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let j = -2; j \u003c= 2; j++) a += Hz[y * W + cl(x + j, 0, W - 1)];\n        T[y * W + x] = a / 5;\n      }\n    for (let y = 0; y \u003c 32; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let j = -2; j \u003c= 2; j++) a += T[cl(y + j, 0, 31) * W + x];\n        Hz[y * W + x] = a / 5;\n      }\n  }\n  const hz = 0.25 + 1.6 * g;\n  for (let y = 6; y \u003c= 26; y++) for (let x = 3; x \u003c= 60; x++) add(F, x, y, haze, hz * Hz[(y - 4) * W + x]);\n\n  // Keys: function keys pale, number keys dark, operator keys in colour.\n  // A key that goes down drops one row, loses its shadow and lights up,\n  // fading over a quarter of a second of machine time.\n  const face = [hsv(hd + 0.15, 0.1, 0.42), hsv(hd + 0.15, 0.2, 0.22), hsv(hd + 0.62, 0.8, 0.62)];\n  const glowc = [hsv(hd + 0.15, 0.05, 0.85), hsv(hd, 0.45, 0.7), hsv(hd + 0.62, 0.55, 1)];\n  const ink = [hsv(hd + 0.15, 0.3, 0.07), hsv(hd + 0.15, 0.05, 0.8), hsv(hd + 0.62, 0.15, 1)];\n  const white = [1, 1, 1];\n  for (let i = 0; i \u003c KEYS.length; i++) {\n    const K = KEYS[i], P = max(0, Math.exp(-(S.clock - S.pressed[i]) / 0.25)), dy = P > 0.35 ? 1 : 0, kd = K.kind;\n    const col = [0, 1, 2].map((j) => face[kd][j] + (glowc[kd][j] - face[kd][j]) * P);\n    if (!dy) for (let x = K.x + 1; x \u003c K.x + K.w - 1; x++) put(F, x, K.y + 15, body, 0.45);\n    for (let r = 0; r \u003c 15; r++)\n      for (let q = 0; q \u003c K.w; q++) {\n        if ((r === 0 || r === 14) && (q === 0 || q === K.w - 1)) continue;\n        put(F, K.x + q, K.y + dy + r, col, r === 0 ? 1.3 : r === 14 ? 0.62 : q === K.w - 1 ? 0.85 : 1);\n      }\n    const gl = GLYPH[K.id], gx = K.x + (K.w >> 1) - 1, gy = K.y + dy + 5;\n    const ic = [0, 1, 2].map((j) => ink[kd][j] + (white[j] - ink[kd][j]) * P * (kd === 0 ? 0.3 : 1));\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (gl[r * 3 + q] === \"1\") put(F, gx + q, gy + r, ic, 1);\n  }\n  // The display's light falls on the body and the top rows of keys below\n  // it, as a vacuum fluorescent display does in a dark room.\n  const sp = 0.3 * g * g + 0.1 * g;\n  if (sp > 0)\n    for (let y = 28; y \u003c 100; y++) {\n      const m = sp * Math.exp(-(y - 28) / 16);\n      for (let x = 1; x \u003c 63; x++) add(F, x, y, haze, m * (0.6 + 0.4 * sin((PI * (x - 1)) / 61)));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  drawFace(S);\n  const F = S.face, th = S.theta, c = cos(th), s = sin(th);\n  const out = (x, y, r, g, b) => display.setPixel(x, y, (255 * min(1, r)) | 0, (255 * min(1, g)) | 0, (255 * min(1, b)) | 0);\n  if (s \u003c 1e-6) {\n    // At rest, either way up, the face lands on the LEDs one for one: a half\n    // turn about the panel's centre sends LED (x, y) to (63 - x, 127 - y).\n    const up = c > 0;\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const o = ((up ? y : H - 1 - y) * W + (up ? x : W - 1 - x)) * 3;\n        out(x, y, F[o], F[o + 1], F[o + 2]);\n      }\n    return;\n  }\n  // Turning: the face shrinks just enough that its corners stay on the\n  // panel, and holds at 0.45 while it lies more than 63 degrees over, so it\n  // does not swell at 90 degrees; every LED takes four bilinear samples.\n  const f = s > 2 * abs(c) ? 143.11 : 64 * abs(c) + 128 * s, sc = 64 / f;\n  const ic = c / sc, is = s / sc;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      for (let k = 0; k \u003c 4; k++) {\n        const px = x + 0.25 + 0.5 * (k & 1) - 32, py = y + 0.25 + 0.5 * (k >> 1) - 64;\n        const u = ic * px + is * py + 31.5, v = -is * px + ic * py + 63.5;\n        const u0 = floor(u), v0 = floor(v), fu = u - u0, fv = v - v0;\n        for (let j = 0; j \u003c 4; j++) {\n          const uu = u0 + (j & 1), vv = v0 + (j >> 1);\n          if (uu \u003c 0 || uu >= W || vv \u003c 0 || vv >= H) continue;\n          const wgt = ((j & 1) ? fu : 1 - fu) * ((j >> 1) ? fv : 1 - fv), o = (vv * W + uu) * 3;\n          (r += F[o] * wgt), (g += F[o + 1] * wgt), (b += F[o + 2] * wgt);\n        }\n      }\n      out(x, y, r / 4, g / 4, b / 4);\n    }\n}\n","caustic-letters":"// ===== Patternflow pattern =====\n// Title:   Caustic Letters\n// Family:  type\n// Idea:    The panel is the floor of a pool lit from above, and the water surface is shaped so the light it bends spells a word: while a gust or a dropped stone roughens it the light runs in a net of bright caustic lines, and as the ripples calm the same light gathers into the word, until the next disturbance breaks it and brings the next word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: goal-based caustics (Marios Papas, Wojciech Jarosz, Wenzel Jakob, Szymon Rusinkiewicz, Wojciech Matusik and Tim Weyrich, Goal-Based Caustics, 2011), high-contrast computational caustic design (Yuliy Schwartzburg, Romain Testuz, Andrea Tagliasacchi and Mark Pauly, 2014); the Knothe-Rosenblatt rearrangement (Murray Rosenblatt, 1952; Herbert Knothe, 1957) stands in here for the optimal-transport map the 2014 paper solves for; pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ripple=1..3, Focus=-1..1\n//\n// Knob 1: Hue. Turns the water light round the wheel: at 0 the dim light is a deep azure and the brightest lines a pale aqua.\n// Knob 2: Speed. A word's whole cycle, from the gust through the calm to the next gust, takes 8 s at 2, 80 s at 0.2 and 5.3 s at 3; the waves travel faster or slower with it.\n// Knob 3: Ripple. How high the waves stand, as a multiple of the opening height. At 1 the net of caustic lines has round cells 15 to 20 LEDs across and the calm word lies nearly still; at 3 the lines fold into sharp-cornered shards and the word trembles even in the calm.\n// Knob 4: Focus. Where the floor lies against the depth the surface was shaped for. At 0 the word is sharp. At -1 the floor is at half that depth and the word is a soft glow half way from even light. At 1 it is half as deep again and the light overshoots: each stroke pinches to a thin bright line, and the rows of the map show as faint threads across the gaps between letters.\n// Buttons: any knob's button drops a stone, which breaks the word now and brings the next one.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Letters, as strokes of round-ended pen. Latin capitals are drawn in a\n// unit box and stacked down the panel like a hotel sign; the three jamo of\n// 빛 (ㅂ, ㅣ and the final ㅊ) are drawn straight onto the 64 by 128 panel.\nconst G_ARC = [];\nfor (let a = 40; a \u003c= 350; a += 15) G_ARC.push([0.5 + 0.5 * cos((a * PI) / 180), 0.5 - 0.5 * sin((a * PI) / 180)]);\nG_ARC.push([0.55, 0.5 - 0.5 * sin((350 * PI) / 180)]);\nconst LATIN = {\n  L: [26, [[[0, 0], [0, 1], [1, 1]]]],\n  I: [18, [[[0.5, 0], [0.5, 1]], [[0.1, 0], [0.9, 0]], [[0.1, 1], [0.9, 1]]]],\n  G: [34, [G_ARC]],\n  H: [32, [[[0, 0], [0, 1]], [[1, 0], [1, 1]], [[0, 0.5], [1, 0.5]]]],\n  T: [36, [[[0, 0], [1, 0]], [[0.5, 0], [0.5, 1]]]],\n  W: [46, [[[0, 0], [0.22, 1], [0.5, 0.32], [0.78, 1], [1, 0]]]],\n  A: [38, [[[0, 1], [0.5, 0], [1, 1]], [[0.21, 0.66], [0.79, 0.66]]]],\n  V: [38, [[[0, 0], [0.5, 1], [1, 0]]]],\n  E: [28, [[[1, 0], [0, 0], [0, 1], [1, 1]], [[0, 0.5], [0.85, 0.5]]]],\n};\nconst BIT = [\n  [[[9, 8], [9, 58]], [[38, 8], [38, 58]], [[9, 33], [38, 33]], [[9, 58], [38, 58]]],\n  [[[53, 5], [53, 70]]],\n  [[[25, 77], [37, 77]], [[9, 88], [54, 88]], [[31, 92], [9, 121]], [[25.5, 100], [55, 121]]],\n];\n\n// A word becomes a list of segments [x0, y0, x1, y1] in LEDs and a pen radius.\nfunction layout(word) {\n  if (word === \"빛\") return { r: 3.2, segs: BIT.flat().flatMap(segsOf((x, y) => [x, y])) };\n  const n = word.length, ch = 124 / n, r = n > 4 ? 2.5 : 2.8, gap = n > 4 ? 4.2 : 5;\n  const segs = [];\n  for (let i = 0; i \u003c n; i++) {\n    const [w, strokes] = LATIN[word[i]];\n    const top = 2 + i * ch + r + gap / 2, h = ch - 2 * r - gap, left = 32 - w / 2;\n    for (const pl of strokes) segs.push(...segsOf((x, y) => [left + x * w, top + y * h])(pl));\n  }\n  return { r, segs };\n}\nfunction segsOf(map) {\n  return (pl) => {\n    const out = [];\n    for (let k = 0; k + 1 \u003c pl.length; k++) {\n      const [a, b] = map(pl[k][0], pl[k][1]), [c, d] = map(pl[k + 1][0], pl[k + 1][1]);\n      out.push([a, b, c, d]);\n    }\n    return out;\n  };\n}\n\n// The light the floor should receive: the word's mask, softened by one pass\n// of a 1-2-1 blur, over a floor of 0.1 so some light lands everywhere.\nconst FLOOR = 0.1;\nfunction density(word) {\n  const { r, segs } = layout(word);\n  const d2 = new Float32Array(W * H).fill(1e9), m = new Float32Array(W * H), rho = new Float32Array(W * H);\n  // Each segment only looks at the LEDs inside its own box.\n  for (const [a, b, c, d] of segs) {\n    const ex = c - a, ey = d - b, l2 = ex * ex + ey * ey;\n    const x0 = max(0, floor(min(a, c) - r - 1)), x1 = min(W - 1, floor(max(a, c) + r + 1));\n    const y0 = max(0, floor(min(b, d) - r - 1)), y1 = min(H - 1, floor(max(b, d) + r + 1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x + 0.5, py = y + 0.5;\n        const t = l2 > 0 ? cl(((px - a) * ex + (py - b) * ey) / l2, 0, 1) : 0;\n        const qx = px - a - t * ex, qy = py - b - t * ey, q = qx * qx + qy * qy;\n        if (q \u003c d2[y * W + x]) d2[y * W + x] = q;\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++) m[p] = cl(r + 0.5 - sqrt(d2[p]), 0, 1);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let dy = -1; dy \u003c= 1; dy++)\n        for (let dx = -1; dx \u003c= 1; dx++) s += m[cl(y + dy, 0, H - 1) * W + cl(x + dx, 0, W - 1)] * (2 - (dx & 1)) * (2 - (dy & 1));\n      rho[y * W + x] = FLOOR + s / 16;\n    }\n  return rho;\n}\n\n// ---- Photons. Two by two per LED leave the surface evenly, each from a\n// fixed random point inside its own quarter of the LED; on a regular grid\n// the rows of photons landed as dashed lines across the dim floor. The waves\n// are summed on the 65 by 129 corners of the LEDs, and each photon reads the\n// push under it bilinearly from its cell (PC) at the offsets in PFG.\nconst PX = 128, PY = 256, NP = PX * PY, GW = W + 1, GH = H + 1;\nconst SU = new Float32Array(NP), SV = new Float32Array(NP);\nconst jit = (p, k) => {\n  let h = Math.imul(p ^ (k * 0x9e3779b9), 0x85ebca6b) >>> 0;\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst PC = new Int32Array(NP), PFG = new Float64Array(2 * NP);\nfor (let j = 0; j \u003c PY; j++)\n  for (let i = 0; i \u003c PX; i++) {\n    const p = j * PX + i, u = (i + jit(p, 1)) / 2, v = (j + jit(p, 2)) / 2;\n    const cx = min(W - 1, floor(u)), cy = min(H - 1, floor(v));\n    SU[p] = u, SV[p] = v, PC[p] = cy * GW + cx, PFG[2 * p] = u - cx, PFG[2 * p + 1] = v - cy;\n  }\n\n// ---- The Knothe-Rosenblatt map T from even light onto a density rho. The\n// height comes first: a photon's share of the way down the surface is\n// matched to the same share of rho's row sums. Then, inside the row it lands\n// in, its share across is matched to the same share of that row. Both are\n// inverse cumulative sums, read linearly inside an LED. T moves light only\n// down and then across, so it is not the cheapest map, the one the 2014\n// paper solves for by optimal transport, but it carries exactly rho.\nfunction knothe(rho) {\n  const Mc = new Float64Array(H + 1), C = new Float64Array(H * (W + 1));\n  for (let r = 0; r \u003c H; r++) {\n    let s = 0;\n    for (let c = 0; c \u003c W; c++) (C[r * (W + 1) + c] = s), (s += rho[r * W + c]);\n    C[r * (W + 1) + W] = s;\n    Mc[r + 1] = Mc[r] + s;\n  }\n  const TX = new Float32Array(NP), TY = new Float32Array(NP), M = Mc[H];\n  for (let p = 0; p \u003c NP; p++) {\n    const v = (SV[p] / H) * M;\n    let lo = 0, hi = H - 1;\n    while (lo \u003c hi) {\n      const mid = (lo + hi + 1) >> 1;\n      if (Mc[mid] \u003c= v) lo = mid;\n      else hi = mid - 1;\n    }\n    const r = lo, row = Mc[r + 1] - Mc[r], w = (SU[p] / W) * row, o = r * (W + 1);\n    let a = 0, b = W - 1;\n    while (a \u003c b) {\n      const mid = (a + b + 1) >> 1;\n      if (C[o + mid] \u003c= w) a = mid;\n      else b = mid - 1;\n    }\n    TY[p] = r + (v - Mc[r]) / row;\n    TX[p] = a + (w - C[o + a]) / rho[r * W + a];\n  }\n  return [TX, TY];\n}\n\nconst WORDS = [\"LIGHT\", \"빛\", \"WAVE\"];\n// A word's map takes about 20 ms, so each is made the first time it is needed.\nconst MAPS = [];\nconst mapOf = (i) => MAPS[i] || (MAPS[i] = knothe(density(WORDS[i])));\n\n// ---- Waves. A plane wave is a travelling sine on the surface; a photon is\n// pushed along the wave's direction by the surface slope, a cos(k.u - wt),\n// where a is set by f = a |k|, the fold number: past f = 1 neighbouring\n// photons cross and a caustic line is born. Deep-water dispersion,\n// w = sqrt(g k), lets long waves overtake short ones.\nconst GRAV = 25;\nfunction wave(dir, lambda, f) {\n  const k = (2 * PI) / lambda;\n  return { kx: k * cos(dir), ky: k * sin(dir), w: sqrt(GRAV * k), ph: Math.random() * 2 * PI, a: f / k, ex: cos(dir), ey: sin(dir) };\n}\nfunction gust() {\n  const d0 = Math.random() * 2 * PI, out = [];\n  for (let i = 0; i \u003c 4; i++) out.push(wave(d0 + (i - 1.5) * 0.75 + (Math.random() - 0.5) * 0.5, 10 + 14 * Math.random(), 1.1));\n  return out;\n}\n\nconst CYCLE = 8;\n\nfunction startCycle(S, drop) {\n  S.prev = S.word;\n  S.word = (S.word + 1) % WORDS.length;\n  S.ct = 0;\n  S.n++;\n  S.gust = gust();\n  // Every other word is broken by a drop instead of a gust: a ring of waves\n  // from one point, with a weaker gust under it.\n  S.drop = drop || S.n % 2 === 0;\n  S.dx = 10 + 44 * Math.random();\n  S.dy = 16 + 96 * Math.random();\n}\n\nexport function setup(params) {\n  const res = [];\n  for (let i = 0; i \u003c 3; i++) res.push(wave(0.6 + i * 2.1, 13 + 5 * i, 0.07));\n  params.s = {\n    t: 0, ct: 0.6, n: 0, word: 0, prev: 0, gust: gust(), drop: false, dx: 32, dy: 64, res,\n    hue: 0, speed: 2, ripple: 1, focus: 0.06,\n    key: \"\", B: new Float64Array(2 * NP),\n    GX: new Float64Array(GW * GH), GY: new Float64Array(GW * GH), E: new Float64Array((W + 2) * (H + 2)),\n    AX: new Float64Array(9), AY: new Float64Array(9),\n    CX: new Float64Array(9 * GW), SX: new Float64Array(9 * GW), CY: new Float64Array(9 * GH), SY: new Float64Array(9 * GH),\n    GR: new Float32Array(800), LUT: new Uint8Array(3072),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.ripple = cl(k[2], 1, 3);\n  S.focus = cl(k[3], -1, 1);\n  // Time runs in the seconds of Speed 2.\n  const step = (d * S.speed) / 2;\n  S.t += step;\n  S.ct += step;\n  if (S.ct >= CYCLE) startCycle(S, false);\n  if (input.btnPressed && input.btnPressed.some(Boolean) && S.ct > 0.5) startCycle(S, true);\n}\n\n// Wave q's push and its two tables of sines for this frame.\nfunction setWave(S, q, w, g) {\n  const { CX, SX, CY, SY, AX, AY } = S;\n  AX[q] = w.a * g * w.ex;\n  AY[q] = w.a * g * w.ey;\n  for (let i = 0; i \u003c GW; i++) (CX[q * GW + i] = cos(w.kx * i)), (SX[q * GW + i] = sin(w.kx * i));\n  for (let j = 0; j \u003c GH; j++) {\n    const b = w.ky * j - w.w * S.t + w.ph;\n    (CY[q * GH + j] = cos(b)), (SY[q * GH + j] = sin(b));\n  }\n}\n\n// The drop: a ring packet leaving the point at 20 LEDs a second, spreading\n// as it goes and weakening about as 1 / sqrt(r). GR holds its radial push.\nfunction addDrop(S, ct, amp) {\n  const { GX, GY, GR } = S;\n  const R = 20 * ct, sg = 3 + 1.6 * ct, kd = (2 * PI) / 9, ad = (2.6 / kd) * amp * exp(-ct / 2.2) * smooth(ct / 0.15);\n  for (let m = 0; m \u003c 800; m++) {\n    const r = m * 0.25, u = (r - R) / sg;\n    GR[m] = (ad * exp(-u * u) * sin(kd * (r - R))) / sqrt(1 + r / 12);\n  }\n  for (let j = 0; j \u003c GH; j++)\n    for (let i = 0; i \u003c GW; i++) {\n      const ux = i - S.dx, uy = j - S.dy, r = sqrt(ux * ux + uy * uy);\n      if (r \u003c 0.5) continue;\n      const g = GR[min(799, floor(r * 4))] / r;\n      GX[j * GW + i] += g * ux;\n      GY[j * GW + i] += g * uy;\n    }\n}\n\n// The push of the slope at each corner: cos(A + B) with A from the column\n// and B from the row, so the sines come from two short tables per wave.\nfunction sumWaves(S, nw) {\n  const { GX, GY, CX, SX, CY, SY, AX, AY } = S;\n  GX.fill(0);\n  GY.fill(0);\n  for (let q = 0; q \u003c nw; q++) {\n    const ax = AX[q], ay = AY[q], qx = q * GW;\n    for (let j = 0, o = 0; j \u003c GH; j++, o += GW) {\n      const cy = CY[q * GH + j], sy = SY[q * GH + j];\n      for (let i = 0; i \u003c GW; i++) {\n        const c = CX[qx + i] * cy - SX[qx + i] * sy;\n        GX[o + i] += ax * c;\n        GY[o + i] += ay * c;\n      }\n    }\n  }\n}\n\n// Land every photon and splat it bilinearly into E, which has a border of\n// one LED all round so the splat needs no tests.\nfunction splat(S, s) {\n  const { GX, GY, E, B } = S, EW = W + 2;\n  E.fill(0);\n  for (let p = 0; p \u003c NP; p++) {\n    const c = PC[p], f = PFG[2 * p], g = PFG[2 * p + 1], c2 = c + GW;\n    const dx = (GX[c] + (GX[c + 1] - GX[c]) * f) * (1 - g) + (GX[c2] + (GX[c2 + 1] - GX[c2]) * f) * g;\n    const dy = (GY[c] + (GY[c + 1] - GY[c]) * f) * (1 - g) + (GY[c2] + (GY[c2 + 1] - GY[c2]) * f) * g;\n    const fx = B[2 * p] + s * dx, fy = B[2 * p + 1] + s * dy;\n    const x0 = floor(fx), y0 = floor(fy);\n    if (x0 \u003c -1 || x0 >= W || y0 \u003c -1 || y0 >= H) continue;\n    const ax = fx - x0, ay = fy - y0, o = (y0 + 1) * EW + x0 + 1, by = 1 - ay;\n    E[o] += (1 - ax) * by;\n    E[o + 1] += ax * by;\n    E[o + EW] += (1 - ax) * ay;\n    E[o + EW + 1] += ax * ay;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const ct = S.ct, amp = S.ripple;\n\n  // The gust rises to its height at 0.9 s and dies away; the water is\n  // nearly still by 4.5 s.\n  const tau = 0.9, env = (ct / tau) * exp(1 - ct / tau);\n  let nw = 0;\n  if (env > 0.01) for (const w of S.gust) setWave(S, nw++, w, env * amp * (S.drop ? 0.3 : 1));\n  for (const w of S.res) setWave(S, nw++, w, amp);\n  sumWaves(S, nw);\n  if (S.drop && ct \u003c 6) addDrop(S, ct, amp);\n\n  // The floor at depth s of the shaped depth gets u + s (T(u) - u + slope\n  // push): s = 1 is in focus.\n  const s = 1 + 0.5 * S.focus;\n  // How much of the shaped relief shows through the waves: none while the\n  // gust stands above half its height, all of it once the water is still.\n  // The relief changes to the next word at 1 s, while none of it shows.\n  const calm = 1 - smooth(min(1, env / 0.5)), wi = ct \u003c 1 ? S.prev : S.word;\n  // Where each photon would land on still water, kept until the focus, the\n  // calm or the word changes.\n  const key = s + \",\" + calm + \",\" + wi, B = S.B, EW = W + 2;\n  if (key !== S.key) {\n    S.key = key;\n    const [TX, TY] = mapOf(wi), sc = s * calm;\n    for (let p = 0; p \u003c NP; p++) {\n      B[2 * p] = SU[p] + sc * (TX[p] - SU[p]) - 0.5;\n      B[2 * p + 1] = SV[p] + sc * (TY[p] - SV[p]) - 0.5;\n    }\n  }\n  splat(S, s);\n\n  // Tone map 1 - exp(-k E) through a table of 1024 steps of 1/16 photon:\n  // four photons an LED is even light, and the deep colour gives way to the\n  // pale one as the light piles up.\n  const deep = hsv(0.56 + S.hue, 0.85, 1), pale = hsv(0.47 + S.hue, 0.28, 1), LUT = S.LUT, E = S.E;\n  for (let m = 0; m \u003c 1024; m++) {\n    const b = 1 - exp(-0.13 * (m / 16)), w = b * b;\n    for (let ch = 0; ch \u003c 3; ch++) LUT[m * 3 + ch] = 255 * b * (deep[ch] + (pale[ch] - deep[ch]) * w);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0, p = (y + 1) * EW + 1; x \u003c W; x++, p++) {\n      const m = min(1023, (E[p] * 16) | 0) * 3;\n      display.setPixel(x, y, LUT[m], LUT[m + 1], LUT[m + 2]);\n    }\n}\n","langford-pairs":"// ===== Patternflow pattern =====\n// Title:   Langford Pairs\n// Family:  number\n// Idea:    A backtracking search stacks two blocks of each of n colours into a tower the height of the panel, placing the pairs from the largest down so that the two blocks of colour k have k blocks between them, with an arc beside the tower joining each pair, and every arrangement it finds slides aside onto a shelf of finished towers while the search goes on.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Langford's problem (C. Dudley Langford, Mathematical Gazette, 1958), solutions only for n ≡ 0 or 3 mod 4 (Roy O. Davies, 1959), Skolem sequences (Thoralf Skolem, 1957), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pairs=7..12, Rule=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 pairs 1, 2 and 3 are red, blue and yellow, the blocks Langford watched his son stack, and each larger pair is 0.58 of a turn on from the one before.\n// Knob 2: Speed. 40 steps a second at 2, where a step places a pair or takes one back; 4 at 0.2 and 60 at 3. After 2 s with nothing found the search doubles its pace every 1.5 s, up to 30,000 steps a second, so 9 gets through its 19,781 placements and fails about 15 s in; at each arrangement it finds it falls back to the knob's pace.\n// Knob 3: Pairs. n from 7 to 12, so the tower is 14 to 24 blocks of 128 / 2n rows. Counted once with its reversal, 7 has 26 arrangements, 8 has 150, 11 has 17,792 and 12 has 108,144; 9 and 10 have none, and their searches run out and fail. When a search has tried everything, n goes up by one, and 12 goes back to 7.\n// Knob 4: Rule. Below 0.5 Langford's rule, k blocks between the two of colour k. From 0.5 Skolem's, the two of colour k stand k places apart, so the two 1s touch; that works for n = 8 (252), 9 (1,328) and 12 (227,968), and fails for 7, 10 and 11.\n// Buttons: any knob's button gives up on this n and moves on to the next.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Layout. The search tower stands at the right, 10 LEDs wide, with the\n// arcs to its left and a progress line in the last column. Finished towers\n// are 5 LEDs wide, 7 apart, the newest at x 29 and the oldest falling off\n// the left edge.\nconst TX = 52, TW = 10, PBX = 63, SW = 5, SS = 7, S0 = 29, NMIN = 7, NMAX = 12;\nconst top = (n, i) => round((i * H) / (2 * n));\n\n// ---- The search. Pairs go in from n down to 1; pair k tries each place i\n// whose partner i + gap is free, from the top down. Langford's gap is k + 1 (k\n// blocks between), Skolem's is k. A reversed arrangement is the same one, so\n// pair n only tries the top half of its places; when it sits exactly in the\n// middle an arrangement and its reversal both turn up, and only the one that\n// reads smaller from the top is kept.\n// Enumerated this way: Langford 3:1, 4:1, 7:26, 8:150, 11:17792, 12:108144,\n// and none for 5, 6, 9, 10; Skolem 4:3, 5:5, 8:252, 9:1328, 12:227968.\nconst gap = (S, k) => k + 1 - S.rule;\nconst hiOf = (S, k) => {\n  const last = 2 * S.n - 1 - gap(S, k);\n  return k === S.n ? floor(last / 2) : last;\n};\n\nfunction fresh(S, n, rule) {\n  S.n = n;\n  S.rule = rule;\n  S.slot = new Int8Array(2 * n);\n  S.pos = new Int16Array(n + 2).fill(-1);\n  S.cur = new Int16Array(n + 2);\n  S.glow = new Float32Array(n + 2);\n  S.ghost = new Float32Array(n + 2);\n  S.gpos = new Int16Array(n + 2);\n  S.k = n;\n  S.found = 0;\n  S.stuck = 0;\n  S.acc = 0;\n  S.hold = 0;\n  S.end = -1;\n}\n\nfunction place(S, k, i) {\n  S.slot[i] = S.slot[i + gap(S, k)] = k;\n  S.pos[k] = i;\n  S.glow[k] = 1;\n}\nfunction unplace(S, k) {\n  const i = S.pos[k];\n  S.slot[i] = S.slot[i + gap(S, k)] = 0;\n  S.pos[k] = -1;\n  S.ghost[k] = 1;\n  S.gpos[k] = i;\n}\nfunction reversedFirst(S) {\n  const n = S.n, L = 2 * n, i = S.pos[n];\n  if (i !== L - 1 - gap(S, n) - i) return false;\n  for (let a = 0; a \u003c L; a++) if (S.slot[a] !== S.slot[L - 1 - a]) return S.slot[a] > S.slot[L - 1 - a];\n  return false;\n}\n\n// One step: place the next pair, or take one back. Returns 0 placed,\n// 1 taken back, 2 found, 3 found the reversal of one already kept, 4 done.\nfunction step(S) {\n  if (S.k === 0) {\n    unplace(S, 1);\n    S.k = 1;\n    return 1;\n  }\n  const k = S.k, g = gap(S, k), hi = hiOf(S, k), sl = S.slot;\n  for (let i = S.cur[k]; i \u003c= hi; i++) {\n    if (sl[i] || sl[i + g]) continue;\n    place(S, k, i);\n    S.cur[k] = i + 1;\n    if (k > 1) {\n      S.k = k - 1;\n      S.cur[k - 1] = 0;\n      return 0;\n    }\n    S.k = 0;\n    return reversedFirst(S) ? 3 : 2;\n  }\n  if (k === S.n) return 4;\n  unplace(S, k + 1);\n  S.k = k + 1;\n  return 1;\n}\n\n// How far through the tree the search is: pair n's place out of its range,\n// then pair n - 1's inside that, and so on four levels down.\nfunction progress(S) {\n  if (S.end >= 0) return 1;\n  let p = 0, w = 1;\n  for (let k = S.n; k > S.n - 4 && k >= 1; k--) {\n    const span = hiOf(S, k) + 1, at = S.pos[k] >= 0 ? S.pos[k] : min(span, S.cur[k]);\n    p += (w * at) / span;\n    w /= span;\n    if (S.pos[k] \u003c 0) break;\n  }\n  return cl(p, 0, 1);\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, speed: 2, kn: -1, krule: -1, shelf: [], flash: 0, rgb: new Float32Array(W * H * 3) };\n}\n\nfunction advance(S) {\n  fresh(S, S.n >= NMAX ? NMIN : S.n + 1, S.rule);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = cl(round(kv[2]), NMIN, NMAX), rule = kv[3] >= 0.5 ? 1 : 0;\n  if (n !== S.kn || rule !== S.krule) {\n    S.kn = n;\n    S.krule = rule;\n    fresh(S, n, rule);\n  }\n  // Time in the seconds of Speed 2.\n  const nom = (d * S.speed) / 2;\n  S.t += d;\n  const fade = exp(-d / 0.25), gfade = exp(-d / 0.12);\n  for (let k = 1; k \u003c= S.n; k++) (S.glow[k] *= fade), (S.ghost[k] *= gfade);\n  S.flash *= exp(-d / 0.3);\n  // The shelf eases toward its places; a tower that has left the panel goes.\n  S.shelf.forEach((tw, j) => (tw.x += (S0 - SS * j - tw.x) * (1 - exp(-d * 6))));\n  while (S.shelf.length && S.shelf[S.shelf.length - 1].x \u003c -SW - 1) S.shelf.pop();\n\n  if (input.btnPressed && input.btnPressed.some(Boolean)) return advance(S);\n  if (S.end >= 0) {\n    // The search has run out: 1.4 s to show it, then the next n.\n    S.end += nom;\n    if (S.end > 1.4) advance(S);\n    return;\n  }\n  if (S.hold > 0) {\n    S.hold -= nom;\n    return;\n  }\n  S.stuck += nom;\n  const rate = min(30000, 20 * S.speed * 2 ** (max(0, S.stuck - 2) / 1.5));\n  S.acc += d * rate;\n  let steps = floor(S.acc);\n  if (steps > 1000) (steps = 1000), (S.acc = 0);\n  else S.acc -= steps;\n  while (steps-- > 0) {\n    const r = step(S);\n    if (r === 2) {\n      S.found++;\n      S.shelf.unshift({ seq: Int8Array.from(S.slot), n: S.n, x: TX });\n      if (S.shelf.length > 8) S.shelf.length = 8;\n      S.hold = 0.35;\n      S.stuck = 0;\n      S.flash = 1;\n      S.acc = 0;\n      break;\n    }\n    if (r === 4) {\n      S.end = 0;\n      S.acc = 0;\n      break;\n    }\n  }\n}\n\n// A block from row y0 to y1 - 1 between columns x0 and x1 - 1, its last row\n// left dark as the seam to the next; the top row catches the light.\nfunction block(rgb, x0, x1, y0, y1, c, v) {\n  const last = y1 - 1 - (y1 - y0 > 3 ? 1 : 0);\n  for (let y = y0; y \u003c last; y++) {\n    const sh = v * (y === y0 ? 1 : y === last - 1 ? 0.58 : 0.8);\n    for (let x = max(0, x0); x \u003c min(W, x1); x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] += c[0] * sh;\n      rgb[o + 1] += c[1] * sh;\n      rgb[o + 2] += c[2] * sh;\n    }\n  }\n}\n\nfunction dot(rgb, x, y, c, a) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const px = x0 + i, py = y0 + j;\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const w = a * (i ? fx : 1 - fx) * (j ? fy : 1 - fy), o = (py * W + px) * 3;\n      rgb[o] += c[0] * w;\n      rgb[o + 1] += c[1] * w;\n      rgb[o + 2] += c[2] * w;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.slot) return;\n  const rgb = S.rgb;\n  rgb.fill(0);\n  // Pair k's colour steps 0.58 of a turn, so 1, 2 and 3 open red, blue and\n  // yellow and neighbours never share a hue.\n  const pal = [];\n  for (let k = 0; k \u003c= NMAX; k++) pal.push(hsv(S.hue + 0.58 * (k - 1), 0.78, 1));\n\n  // The shelf. A tower leaving the search narrows from 10 LEDs to 5 as it goes.\n  for (const tw of S.shelf) {\n    const u = cl((tw.x - S0) / (TX - S0), 0, 1), x0 = round(tw.x), w = round(SW + (TW - SW) * u);\n    for (let i = 0; i \u003c 2 * tw.n; i++) block(rgb, x0, x0 + w, top(tw.n, i), top(tw.n, i + 1), pal[tw.seq[i]], 0.72 + 0.23 * u);\n  }\n\n  // The search tower: placed blocks, the empty places as faint frames, and a\n  // pair just taken back fading where it stood.\n  const n = S.n, L = 2 * n, fl = S.flash;\n  const failing = S.end >= 0 && S.found === 0, blink = failing && (S.end * 3) % 1 \u003c 0.5;\n  const frame = failing ? [blink ? 0.75 : 0.25, 0.12, 0.08] : S.end >= 0 ? [0.4, 0.45, 0.5] : [0.11, 0.13, 0.17];\n  for (let i = 0; i \u003c L; i++) {\n    const y0 = top(n, i), y1 = top(n, i + 1), k = S.slot[i];\n    if (k) {\n      const g = S.glow[k] * 0.45 + fl * 0.3, c = pal[k];\n      block(rgb, TX, TX + TW, y0, y1, [c[0] + (1 - c[0]) * g, c[1] + (1 - c[1]) * g, c[2] + (1 - c[2]) * g], 1);\n      continue;\n    }\n    for (let y = y0; y \u003c y1 - 1; y++)\n      for (let x = TX; x \u003c TX + TW; x++) {\n        if (y !== y0 && y !== y1 - 2 && x !== TX && x !== TX + TW - 1) continue;\n        const o = (y * W + x) * 3;\n        rgb[o] += frame[0], rgb[o + 1] += frame[1], rgb[o + 2] += frame[2];\n      }\n  }\n  for (let k = 1; k \u003c= n; k++) {\n    const a = S.ghost[k];\n    if (a \u003c 0.03 || S.pos[k] >= 0) continue;\n    for (const i of [S.gpos[k], S.gpos[k] + gap(S, k)]) if (!S.slot[i]) block(rgb, TX + 2, TX + TW - 2, top(n, i), top(n, i + 1), pal[k], 0.45 * a);\n  }\n\n  // Arcs: each placed pair joined by half an ellipse bulging left from the\n  // centres of its two blocks, wider for larger k.\n  for (let k = 1; k \u003c= n; k++) {\n    const i = S.pos[k];\n    if (i \u003c 0) continue;\n    const j = i + gap(S, k), ya = (top(n, i) + top(n, i + 1) - 1) / 2, yb = (top(n, j) + top(n, j + 1) - 1) / 2;\n    const yc = (ya + yb) / 2, ry = (yb - ya) / 2, rx = 2.5 + (11 * (k - 1)) / (n - 1);\n    const len = PI * sqrt((rx * rx + ry * ry) / 2), m = Math.ceil(len * 2.5), c = pal[k];\n    const a = 0.5 * (0.75 + S.glow[k] * 0.5 + fl * 0.4);\n    for (let s = 0; s \u003c= m; s++) {\n      const th = -PI / 2 + (PI * s) / m;\n      dot(rgb, TX - 1.5 - rx * cos(th), yc + ry * sin(th), c, a);\n    }\n  }\n\n  // The progress line: how much of the tree lies behind the search.\n  const py = progress(S) * H;\n  for (let y = 0; y \u003c H; y++) {\n    const v = y \u003c py ? (failing ? 0.5 : 0.32) : 0.06, o = (y * W + PBX) * 3;\n    rgb[o] += v * (failing ? 1 : 0.8);\n    rgb[o + 1] += v * (failing ? 0.25 : 0.85);\n    rgb[o + 2] += v * (failing ? 0.15 : 1);\n  }\n\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), (255 * min(1, rgb[p * 3])) | 0, (255 * min(1, rgb[p * 3 + 1])) | 0, (255 * min(1, rgb[p * 3 + 2])) | 0);\n}\n","letter-melt":"// ===== Patternflow pattern =====\n// Title:   Letter Melt\n// Family:  type\n// Idea:    A word of liquid stands in an invisible mould at the top of the panel, the mould lets go from the feet of the letters up so the strokes sag, drip and run down the full height into a pool on the floor, and then threads drawn up out of the pool fill the mould of the next word, MELT, 물, FLOW, 녹다, DRIP, from the top of each letter down until it sets.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 69, after Letter Sand (pattern round 64), particle fluid by double density relaxation (Simon Clavet, Philippe Beaudoin and Pierre Poulin, 2005)\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..5, Heat=0..1\n//\n// Knob 1: Hue. Turns the liquid round the wheel. At 0 it is a teal body with a pale aqua rim, at 0.25 blue violet, at 0.5 rose, at 0.65 gold.\n// Knob 2: Speed. At 2 the fluid takes 60 steps a second and a word holds 1.8 s, melts in about 2.4 s and pours back in 2.9 s, so the five words come round in 36 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Word. 0 pours the five words in turn, MELT, 물, FLOW, 녹다 and DRIP. 1 to 5 hold one of them, and every pour goes back into that same mould.\n// Knob 4: Heat. Cold liquid is thick: at 0.06 the mould holds the word 1.8 s, the lower strokes sag for about a second before they drip, and the strokes hang in long threads on the way down. Hot liquid is thin and shivers in the mould: at 1 the mould lets go after 0.5 s and the letters fall apart in loose blobs that splash.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, round, PI, cos, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The fluid, in LEDs and simulation steps. One step is 1/60 s at Speed 2.\nconst SP = 1.4; // rest spacing of the particles\nconst HR = 3.0; // interaction radius\nconst GRAV = 0.025; // LEDs a step, a step\nconst RISE = 1.3; // how fast a poured thread climbs, LEDs a step\nconst POUR = 1.6; // seconds a pour draws particles for\nconst KS = 0.06; // stiffness against the rest density\nconst KN = 0.15; // near stiffness, which keeps particles apart and gives the surface its tension\nconst STROKE = 2.2; // stroke radius of the mould letters\nconst GX = Math.ceil(W / HR), GY = Math.ceil(H / HR);\n\n// Stroke centre lines in a unit box, y down. \"O\" is a stadium ring.\nconst LATIN = {\n  M: [[0, 1, 0, 0, 0.5, 0.55, 1, 0, 1, 1]],\n  E: [[1, 0, 0, 0, 0, 1, 1, 1], [0, 0.5, 0.8, 0.5]],\n  L: [[0, 0, 0, 1, 1, 1]],\n  T: [[0, 0, 1, 0], [0.5, 0, 0.5, 1]],\n  F: [[1, 0, 0, 0, 0, 1], [0, 0.47, 0.8, 0.47]],\n  O: \"ring\",\n  W: [[0, 0, 0.2, 1, 0.5, 0.45, 0.8, 1, 1, 0]],\n  D: [[0, 0, 0, 1, 0.45, 1, 1, 0.78, 1, 0.22, 0.45, 0, 0, 0]],\n  R: [[0, 1, 0, 0, 0.65, 0, 1, 0.14, 1, 0.34, 0.65, 0.48, 0, 0.48], [0.45, 0.48, 1, 1]],\n  I: [[0.5, 0, 0.5, 1], [0.1, 0, 0.9, 0], [0.1, 1, 0.9, 1]],\n  P: [[0, 1, 0, 0, 0.65, 0, 1, 0.15, 1, 0.37, 0.65, 0.52, 0, 0.52]],\n};\n// Hangul syllables drawn jamo by jamo in the same way.\nconst HANGUL = {\n  물: [\n    [0.18, 0, 0.82, 0, 0.82, 0.25, 0.18, 0.25, 0.18, 0],\n    [0, 0.42, 1, 0.42],\n    [0.5, 0.42, 0.5, 0.55],\n    [0.18, 0.66, 0.82, 0.66, 0.82, 0.83, 0.18, 0.83, 0.18, 1, 0.82, 1],\n  ],\n  녹: [[0.12, 0, 0.12, 0.25, 0.88, 0.25], [0.5, 0.34, 0.5, 0.5], [0, 0.5, 1, 0.5], [0.1, 0.67, 0.9, 0.67, 0.9, 1]],\n  다: [[0.5, 0.16, 0, 0.16, 0, 0.84, 0.5, 0.84], [0.8, 0, 0.8, 1], [0.8, 0.5, 1, 0.5]],\n};\nconst WORDS = [\"MELT\", \"물\", \"FLOW\", \"녹다\", \"DRIP\"];\n\n// Glyph boxes for a word: [char, x, y, w, h].\nfunction boxes(word) {\n  const n = [...word].length;\n  if (HANGUL[word[0]]) {\n    const w = n === 1 ? 56 : 29;\n    return [...word].map((c, i) => [c, n === 1 ? 4 : 2 + i * 31, 5, w, 44]);\n  }\n  return [...word].map((c, i) => [c, 1.5 + i * 16, 6, 13, 36]);\n}\n\n// The stroke segments of one glyph in its box, in LEDs.\nfunction segments(c, bx, by, bw, bh) {\n  const out = [], x0 = bx + STROKE, y0 = by + STROKE, sw = bw - 2 * STROKE, sh = bh - 2 * STROKE;\n  const g = LATIN[c] || HANGUL[c];\n  if (g === \"ring\") {\n    const r = sw / 2, cx = x0 + r, ya = y0 + r, yb = y0 + sh - r, pts = [];\n    for (let k = 0; k \u003c= 12; k++) pts.push(cx + r * cos(PI + (k * PI) / 12), ya + r * sin(PI + (k * PI) / 12));\n    for (let k = 0; k \u003c= 12; k++) pts.push(cx + r * cos((k * PI) / 12), yb + r * sin((k * PI) / 12));\n    pts.push(pts[0], pts[1]);\n    for (let i = 0; i + 3 \u003c pts.length; i += 2) out.push(pts[i], pts[i + 1], pts[i + 2], pts[i + 3]);\n    return out;\n  }\n  for (const pl of g)\n    for (let i = 0; i + 3 \u003c pl.length; i += 2) out.push(x0 + pl[i] * sw, y0 + pl[i + 1] * sh, x0 + pl[i + 2] * sw, y0 + pl[i + 3] * sh);\n  return out;\n}\n\nfunction segDist(px, py, s) {\n  let best = 1e9;\n  for (let i = 0; i \u003c s.length; i += 4) {\n    const ax = s[i], ay = s[i + 1], vx = s[i + 2] - ax, vy = s[i + 3] - ay;\n    const t = cl(((px - ax) * vx + (py - ay) * vy) / (vx * vx + vy * vy || 1), 0, 1);\n    const dx = px - ax - t * vx, dy = py - ay - t * vy;\n    best = min(best, dx * dx + dy * dy);\n  }\n  return sqrt(best);\n}\n\n// The mould of a word: its sites, a hexagonal lattice at the rest spacing\n// inside the strokes, read from the top row down, and the spouts under each\n// glyph that a pour draws its threads up through, one for every 16 LEDs of\n// width. Each spout keeps its sites top row first, so a pour fills each\n// letter from its top down.\nfunction mould(word) {\n  const xy = [], spouts = [], lists = [];\n  for (const [c, gx, gy, gw, gh] of boxes(word)) {\n    const m = max(1, round(gw / 16)), first = lists.length, segs = segments(c, gx, gy, gw, gh);\n    for (let k = 0; k \u003c m; k++) {\n      spouts.push(gx + (gw * (k + 0.5)) / m, gy + gh + 2);\n      lists.push([]);\n    }\n    for (let j = 0; ; j++) {\n      const y = 3 + j * SP * 0.866;\n      if (y > gy + gh) break;\n      if (y \u003c gy) continue;\n      for (let x = 0.5 + (j % 2) * SP * 0.5; x \u003c gx + gw; x += SP) {\n        if (x \u003c gx || segDist(x, y, segs) >= STROKE - 0.3) continue;\n        // The nearest spout of the glyph.\n        const k = first + min(m - 1, floor(((x - gx) / gw) * m));\n        lists[k].push(xy.length / 2);\n        xy.push(x, y);\n      }\n    }\n  }\n  const of = new Int32Array(xy.length / 2);\n  lists.forEach((l, k) => l.forEach((i) => (of[i] = k)));\n  return { xy: new Float64Array(xy), spouts: new Float64Array(spouts), lists: lists.map((l) => new Int32Array(l)), of, n: xy.length / 2 };\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nexport function setup(params) {\n  const MOULDS = WORDS.map(mould);\n  let most = 0;\n  for (const m of MOULDS) most = max(most, m.n);\n  const N = min(1500, most + 460), MP = N * 16;\n  // Rest density: what a particle in the middle of the lattice counts.\n  let rho0 = 0;\n  for (let j = -4; j \u003c= 4; j++)\n    for (let i = -4; i \u003c= 4; i++) {\n      const x = (i + (j % 2) * 0.5) * SP, y = j * SP * 0.866, r = sqrt(x * x + y * y);\n      if (r > 0 && r \u003c HR) rho0 += (1 - r / HR) ** 2;\n    }\n  params.s = {\n    N, MOULDS, rho0, word: -1, phase: 0, started: false,\n    // Doubles from the start, so the object keeps one shape.\n    pt: 0.5, acc: 0.5, hue: 0.5,\n    x: new Float64Array(N), y: new Float64Array(N), px: new Float64Array(N), py: new Float64Array(N),\n    vx: new Float64Array(N), vy: new Float64Array(N), st: new Uint8Array(N), site: new Int32Array(N),\n    rel: new Float64Array(N), kap: new Float64Array(N), tx: new Float64Array(N), ty: new Float64Array(N), rho: new Float64Array(N), rhn: new Float64Array(N),\n    pa: new Int32Array(MP), pb: new Int32Array(MP), pn: 0, qx: new Float64Array(MP), qy: new Float64Array(MP), qq: new Float64Array(MP),\n    cnt: new Int32Array(GX * GY + 1), fillc: new Int32Array(GX * GY), loose: new Int32Array(GX * GY), hd: new Uint8Array(N), idx: new Int32Array(N), cell: new Int32Array(N),\n    F: new Float32Array(W * H), V: new Float32Array(W * H), pal: new Float32Array(64 * 3), rim: new Float32Array(3),\n    nk: new Int32Array(8), arrived: 0, target: -1,\n  };\n  return params.s;\n}\n\n// Particle i takes site j of mould M in a given state, on a spring.\nfunction fix(S, i, M, j, state) {\n  S.st[i] = state;\n  S.site[i] = j;\n  S.kap[i] = 0.25;\n  S.tx[i] = M.xy[2 * j];\n  S.ty[i] = M.xy[2 * j + 1];\n}\n\n// Put word w in its mould and the rest of the particles in a pool on the\n// floor.\nfunction place(S, w) {\n  const M = S.MOULDS[w], per = floor((W - 1) / SP);\n  S.word = w;\n  for (let i = 0; i \u003c S.N; i++) {\n    if (i \u003c M.n) {\n      fix(S, i, M, i, 1);\n      S.x[i] = S.tx[i];\n      S.y[i] = S.ty[i];\n    } else {\n      const k = i - M.n, j = floor(k / per);\n      S.x[i] = 0.7 + (k % per) * SP + (j % 2) * SP * 0.5;\n      S.y[i] = H - 0.7 - j * SP * 0.866;\n      S.st[i] = 0;\n      S.kap[i] = 0;\n    }\n    S.vx[i] = S.vy[i] = 0;\n  }\n  S.phase = 0;\n  S.pt = 0;\n}\n\n// Counting sort of the particles into cells one interaction radius wide,\n// then every pair closer than the radius, each once, with its unit vector\n// and 1 - r/h, adding up both densities on the way. Returns the count.\nfunction neighbours(S) {\n  const { N, x, y, cnt, idx, cell, pa, pb, qx, qy, qq, rho, rhn, st, hd } = S;\n  cnt.fill(0);\n  // Particles the mould holds still skip each other: their springs keep\n  // them apart. While the mould lets go every pair counts.\n  for (let i = 0; i \u003c N; i++) hd[i] = (st[i] === 1 && S.phase !== 1) || st[i] === 3 ? 1 : 0;\n  rho.fill(0);\n  rhn.fill(0);\n  const loose = S.loose;\n  loose.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const c = cl(floor(y[i] / HR), 0, GY - 1) * GX + cl(floor(x[i] / HR), 0, GX - 1);\n    cell[i] = c;\n    cnt[c + 1]++;\n    if (!hd[i]) loose[c]++;\n  }\n  for (let c = 0; c \u003c GX * GY; c++) cnt[c + 1] += cnt[c];\n  const fill = S.fillc;\n  fill.set(cnt.subarray(0, GX * GY));\n  for (let i = 0; i \u003c N; i++) idx[fill[cell[i]]++] = i;\n  let n = 0;\n  const h2 = HR * HR, MP = pa.length;\n  for (let i = 0; i \u003c N; i++) {\n    const c = cell[i], cx = c % GX, cy = (c - cx) / GX, xi = x[i], yi = y[i], hi = hd[i];\n    let ri = 0, ni = 0;\n    for (let oy = 0; oy \u003c= 1; oy++)\n      for (let ox = -1; ox \u003c= 1; ox++) {\n        if (oy === 0 && ox \u003c 0) continue;\n        const nx = cx + ox, ny = cy + oy;\n        if (nx \u003c 0 || nx >= GX || ny >= GY) continue;\n        const cc = ny * GX + nx, own = cc === c;\n        if (hi && !loose[cc]) continue;\n        for (let k = cnt[cc], e = cnt[cc + 1]; k \u003c e; k++) {\n          const j = idx[k];\n          if (own && j \u003c= i) continue;\n          const dx = x[j] - xi, dy = y[j] - yi, r2 = dx * dx + dy * dy;\n          if (r2 >= h2 || n >= MP || (hi && hd[j])) continue;\n          const r = sqrt(r2) || 1e-4, q = 1 - r / HR, q2 = q * q, q3 = q2 * q;\n          pa[n] = i;\n          pb[n] = j;\n          qx[n] = dx / r;\n          qy[n] = dy / r;\n          qq[n++] = q;\n          ri += q2;\n          ni += q3;\n          rho[j] += q2;\n          rhn[j] += q3;\n        }\n      }\n    rho[i] += ri;\n    rhn[i] += ni;\n  }\n  return n;\n}\n\n// One step of the double density relaxation scheme: gravity, the pour's\n// steering, viscous impulses, a free step, the two densities and their\n// pressure displacements, the mould's springs, the walls, and velocity from\n// the change in position. Each part is a loop of its own with as few rare\n// branches as it can have.\nfunction step(S, visc, jit) {\n  const { N, st, vy } = S;\n  for (let i = 0; i \u003c N; i++) vy[i] += st[i] === 0 ? GRAV : 0;\n  if (S.phase === 2) steer(S);\n  viscosity(S, visc);\n  advance(S);\n  S.pn = neighbours(S);\n  relax(S);\n  if (S.phase === 1) melt(S);\n  springs(S, jit);\n  if (S.phase === 2) arrive(S);\n}\n\n// Drawn up: a thread rises at RISE LEDs a step to the spout under the\n// glyph, and from there each particle heads for its own site.\nfunction steer(S) {\n  const { N, st, x, y, vx, vy, site } = S, M = S.MOULDS[S.target];\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 2) continue;\n    const k = M.of[site[i]], spx = M.spouts[2 * k], spy = M.spouts[2 * k + 1];\n    let dvx, dvy;\n    if (y[i] > spy) {\n      dvx = cl((spx - x[i]) * 0.15, -0.8, 0.8);\n      dvy = -RISE;\n    } else {\n      const dx = M.xy[2 * site[i]] - x[i], dy = M.xy[2 * site[i] + 1] - y[i], d = sqrt(dx * dx + dy * dy) + 1e-6;\n      const sc = min(RISE, d * 0.25) / d;\n      dvx = dx * sc;\n      dvy = dy * sc;\n    }\n    vx[i] += (dvx - vx[i]) * 0.35;\n    vy[i] += (dvy - vy[i]) * 0.35;\n  }\n}\n\n// Viscous impulses between approaching neighbours, over last step's pairs.\nfunction viscosity(S, visc) {\n  const { pa, pb, qx, qy, qq, vx, vy } = S, n = S.pn;\n  for (let p = 0; p \u003c n; p++) {\n    const i = pa[p], j = pb[p], ux = qx[p], uy = qy[p];\n    const u = (vx[i] - vx[j]) * ux + (vy[i] - vy[j]) * uy;\n    if (u \u003c= 0) continue;\n    const I = qq[p] * (visc * u + 0.25 * u * u) * 0.5, ix = I * ux, iy = I * uy;\n    vx[i] -= ix;\n    vy[i] -= iy;\n    vx[j] += ix;\n    vy[j] += iy;\n  }\n}\n\nfunction advance(S) {\n  const { N, x, y, px, py, vx, vy } = S;\n  for (let i = 0; i \u003c N; i++) {\n    const f = min(1, 2.5 / sqrt(vx[i] * vx[i] + vy[i] * vy[i] + 1e-12));\n    vx[i] *= f;\n    vy[i] *= f;\n    px[i] = x[i];\n    py[i] = y[i];\n    x[i] += vx[i];\n    y[i] += vy[i];\n  }\n}\n\n// Double density relaxation: a pressure from each density, and every pair\n// pushed apart (or pulled together, near the surface) along its line.\nfunction relax(S) {\n  const { N, x, y, pa, pb, qx, qy, qq, rho, rhn, hd } = S, n = S.pn, rho0 = S.rho0;\n  for (let i = 0; i \u003c N; i++) {\n    const free = 1 - hd[i];\n    rho[i] = free * KS * (rho[i] - rho0);\n    rhn[i] = free * KN * rhn[i];\n  }\n  for (let p = 0; p \u003c n; p++) {\n    const i = pa[p], j = pb[p], q = qq[p];\n    const d = ((rho[i] + rho[j]) * q + (rhn[i] + rhn[j]) * q * q) * 0.5;\n    const dx = d * qx[p], dy = d * qy[p];\n    x[i] -= dx;\n    y[i] -= dy;\n    x[j] += dx;\n    y[j] += dy;\n  }\n}\n\n// The mould lets go: each held particle's spring weakens to nothing by its\n// release time, so the lower strokes sag before they drip.\nfunction melt(S) {\n  const { N, st, kap, rel } = S, t = S.pt;\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 1) continue;\n    const u = cl((rel[i] - t) / 0.9, 0, 1);\n    kap[i] = 0.25 * u * u;\n    if (u \u003c= 0) st[i] = 0;\n  }\n}\n\n// The springs, a shiver as hot as the liquid, the walls, and velocity.\nfunction springs(S, jit) {\n  const { N, x, y, px, py, vx, vy, kap, tx, ty } = S, j4 = jit * 4;\n  for (let i = 0; i \u003c N; i++) {\n    const k = kap[i];\n    const xi = x[i] + (tx[i] - x[i]) * k + (Math.random() - 0.5) * j4 * k;\n    const yi = y[i] + (ty[i] - y[i]) * k + (Math.random() - 0.5) * j4 * k;\n    x[i] = min(W - 0.5, max(0.5, xi));\n    y[i] = min(H - 0.5, max(0.5, yi));\n    vx[i] = x[i] - px[i];\n    vy[i] = y[i] - py[i];\n  }\n}\n\n// A drawn particle that reaches its site is held by the new mould.\nfunction arrive(S) {\n  const { N, st, x, y, site } = S, M = S.MOULDS[S.target];\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 2) continue;\n    const dx = M.xy[2 * site[i]] - x[i], dy = M.xy[2 * site[i] + 1] - y[i];\n    if (dx * dx + dy * dy \u003c 0.8) {\n      fix(S, i, M, site[i], 3);\n      S.arrived++;\n    }\n  }\n}\n\n// The free particle nearest the top of the pool under a spout.\nfunction pick(S, spx) {\n  const { N, st, x, y } = S;\n  let best = -1, bs = 1e9;\n  for (let i = 0; i \u003c N; i++) {\n    if (st[i] !== 0) continue;\n    const sc = abs(x[i] - spx) * 2 + y[i];\n    if (sc \u003c bs) {\n      bs = sc;\n      best = i;\n    }\n  }\n  return best;\n}\n\n// The cycle, one step at a time: the mould holds, lets go, and a pour fills\n// the next mould.\nfunction tick(S, sel, heat) {\n  const { N, st, y } = S;\n  S.pt += 1 / 60;\n  if (S.phase === 0 && S.pt > 1.9 - 1.4 * heat) {\n    // The mould lets go from the feet of the letters up.\n    S.phase = 1;\n    S.pt = 0;\n    const spread = 1.1 - 0.6 * heat;\n    for (let i = 0; i \u003c N; i++) if (st[i] === 1) S.rel[i] = 0.1 + spread * cl((52 - y[i]) / 47, 0, 1) + Math.random() * 0.3;\n  } else if (S.phase === 1 && S.pt > 1.6) {\n    let held = 0, high = 0;\n    for (let i = 0; i \u003c N; i++) {\n      if (st[i] === 1) held++;\n      else if (y[i] \u003c 80) high++;\n    }\n    if (!held && (high \u003c N * 0.03 || S.pt > 5)) {\n      // Pour: each spout of the next word draws its sites, top row first,\n      // from the particles near the top of the pool under it.\n      S.phase = 2;\n      S.pt = 0;\n      S.target = sel ? sel - 1 : (S.word + 1) % WORDS.length;\n      S.nk.fill(0);\n      S.arrived = 0;\n    }\n  } else if (S.phase === 2) {\n    const M = S.MOULDS[S.target], f = min(1, S.pt / POUR);\n    let done = true;\n    for (let k = 0; k \u003c M.lists.length; k++) {\n      const l = M.lists[k];\n      while (S.nk[k] \u003c f * l.length) {\n        const i = pick(S, M.spouts[2 * k]);\n        if (i \u003c 0) break;\n        st[i] = 2;\n        S.kap[i] = 0;\n        S.site[i] = l[S.nk[k]++];\n      }\n      if (S.nk[k] \u003c l.length) done = false;\n    }\n    if (done && (S.arrived >= M.n || S.pt > POUR + 4)) {\n      // Set: the new word stands in its mould.\n      for (let i = 0; i \u003c N; i++) if (st[i] >= 2) fix(S, i, M, S.site[i], 1);\n      S.word = S.target;\n      S.target = -1;\n      S.phase = 0;\n      S.pt = 0;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06];\n  const rate = cl(kv[1], 0.2, 3) / 2, sel = cl(round(kv[2]), 0, 5), heat = cl(kv[3], 0, 1);\n  S.hue = kv[0] || 0;\n  if (!S.started) {\n    S.started = true;\n    S.acc = 0;\n    place(S, sel ? sel - 1 : 0);\n    S.pt = 0.4;\n  }\n  const visc = 0.5 * (1 - heat) ** 2 + 0.08, jit = 0.02 + 0.12 * heat;\n  S.acc += cl(dt || 0, 0, 0.1) * rate * 60;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    tick(S, sel, heat);\n    step(S, visc, jit);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { F, V, x, y, vx, vy, N, pal, rim } = S;\n  F.fill(0);\n  V.fill(0);\n  // Splat every particle into a density field and a speed field.\n  const R = 2.1, R2 = R * R;\n  for (let i = 0; i \u003c N; i++) {\n    const cx = x[i], cy = y[i], sp = sqrt(vx[i] * vx[i] + vy[i] * vy[i]);\n    const x0 = max(0, floor(cx - R + 0.5)), x1 = min(W - 1, floor(cx + R - 0.5));\n    const y0 = max(0, floor(cy - R + 0.5)), y1 = min(H - 1, floor(cy + R - 0.5));\n    for (let Y = y0; Y \u003c= y1; Y++) {\n      const dy = Y + 0.5 - cy;\n      for (let X = x0; X \u003c= x1; X++) {\n        const dx = X + 0.5 - cx, d2 = dx * dx + dy * dy;\n        if (d2 >= R2) continue;\n        const w = (1 - d2 / R2) ** 2, o = Y * W + X;\n        F[o] += w;\n        V[o] += w * sp;\n      }\n    }\n  }\n  // The body runs from a deep shade inside to the lit colour near the\n  // surface; the rim is pale.\n  const h0 = 0.47 + S.hue;\n  for (let k = 0; k \u003c 64; k++) {\n    const u = k / 63;\n    hsv(h0 + 0.07 * u, 0.82 + 0.1 * u, 0.78 - 0.4 * u, pal, k * 3);\n  }\n  hsv(h0 - 0.03, 0.35, 1, rim, 0);\n  const LX = -0.45, LY = -0.89;\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = Y * W + X, f = F[o];\n      if (f \u003c 0.35) continue;\n      const a = cl((f - 0.35) / 0.55, 0, 1);\n      const gx = (X \u003c W - 1 ? F[o + 1] : f) - (X > 0 ? F[o - 1] : f);\n      const gy = (Y \u003c H - 1 ? F[o + W] : f) - (Y > 0 ? F[o - W] : f);\n      const gl = sqrt(gx * gx + gy * gy) + 1e-6;\n      // Outward normal and its light.\n      const lit = (-gx * LX - gy * LY) / gl, edge = cl(1 - (f - 0.9) / 1.3, 0, 1);\n      const spec = edge * cl(lit, 0, 1) ** 3 * cl(gl, 0, 1);\n      const deep = cl((f - 0.9) / 2.2, 0, 1), k = floor(deep * 63) * 3;\n      const foam = cl((V[o] / f - 0.6) * 0.6, 0, 0.5);\n      const sh = 0.75 + 0.25 * cl(lit, -1, 1) * edge;\n      // The lit side of the surface and fast liquid take the pale rim colour.\n      const m = max(spec, foam);\n      const r = (pal[k] * sh * (1 - m) + rim[0] * m) * a;\n      const g = (pal[k + 1] * sh * (1 - m) + rim[1] * m) * a;\n      const b = (pal[k + 2] * sh * (1 - m) + rim[2] * m) * a;\n      display.setPixel(X, Y, min(255, r) | 0, min(255, g) | 0, min(255, b) | 0);\n    }\n}\n","nine-fold-seal":"// ===== Patternflow pattern =====\n// Title:   Nine-fold Seal\n// Family:  type\n// Idea:    A tall vermilion seal impression of eight Hangul syllables, read down the right column and then the left, folds every horizontal stroke back and forth into serpentines of one-LED lines until each syllable's box is full, as the nine-fold seal script of official seals did, and every few seconds it unfolds to plain letters and refolds into the next text.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: jiudie zhuan (九疊篆), the nine-fold seal script of official seals from the Song dynasty on and of Joseon official seals, applied to Hangul; texts: the heading of the Hangul Hunminjeongeum in Worin seokbo (1459), its gloss \"the right sounds that teach\", and two old wishes for long life; pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Ink=0..1, Speed=0.2..3, Plain=0..1, Press=0..1\n//\n// Knob 1: Ink. Turns the ink round the colour wheel at a fixed brightness. At 0 it is seal vermilion, at 0.5 a cyan blue, and the paper stays a dim warm grey.\n// Knob 2: Speed. At 2 a text holds folded for 3 s (the first for 2.4 s) and the change to the next, unfold, swap and refold, takes 4 s more; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Plain. How far the strokes may fold: 0 folds them until every box is full, 0.5 stops every fold seven or eight lines out from its stroke, 1 shows the plain letters.\n// Knob 4: Press. How unevenly the seal is pressed. The pressure rocks round the seal once in 6 s, and the side it leaves prints with bare patches: none at 0, a few LEDs in a hundred at the opening 0.06, while at 1 one LED of ink in seven fails everywhere and the far corner prints almost bare.\n// Buttons: any button starts the change to the next text at once.\n\nconst W = 64, H = 128;\nconst { floor, round, ceil, min, max, abs, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The seal. A border two LEDs thick runs round the panel's edge, a\n// divider two thick splits it into two columns, and every box is 27 by 29\n// LEDs. Strokes lie on a lattice of nodes two LEDs apart, 14 across and 15\n// down a box, so any two strokes that do not join keep one LED of paper\n// between them. That one-LED rhythm of ink and paper is the whole look of\n// the nine-fold script.\nconst NI = 14, NJ = 15, N = NI * NJ;\n// The right column is read first, top to bottom, then the left.\nconst COLX = [34, 3], ROWY = [3, 34, 65, 96];\n\nconst TEXTS = [\"세종어제훈민정음\", \"가르치는바른소리\", \"만수무강하옵소서\", \"천년만년살고지고\"];\n\n// Jamo as strokes [u0, v0, u1, v1] in their region, 0 to 1, every stroke\n// level or upright, as seal script draws them. A fifth number marks a\n// ring: ㅇ is a ring with its corners cut, so it never reads as ㅁ.\n// Initials by their Unicode index; finals are looked up through FIN.\nconst CONS = {\n  0: [[0, 0, 1, 0], [1, 0, 1, 1]], // ㄱ\n  2: [[0, 0, 0, 1], [0, 1, 1, 1]], // ㄴ\n  3: [[0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 1, 1]], // ㄷ\n  5: [[0, 0, 1, 0], [1, 0, 1, 0.5], [0, 0.5, 1, 0.5], [0, 0.5, 0, 1], [0, 1, 1, 1]], // ㄹ\n  6: [[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1]], // ㅁ\n  7: [[0, 0, 0, 1], [1, 0, 1, 1], [0, 0.5, 1, 0.5], [0, 1, 1, 1]], // ㅂ\n  // ㅅ squared off the way seal script squares 人: a stem and two legs\n  // that step outward twice.\n  9: [[0.5, 0, 0.5, 0.3], [0.25, 0.3, 0.75, 0.3], [0.25, 0.3, 0.25, 0.65], [0.75, 0.3, 0.75, 0.65], [0, 0.65, 0.25, 0.65], [0.75, 0.65, 1, 0.65], [0, 0.65, 0, 1], [1, 0.65, 1, 1]], // ㅅ\n  11: [[0.1, 0, 0.9, 1, 1]], // ㅇ\n  12: [[0, 0, 1, 0], [0.5, 0, 0.5, 0.3], [0.25, 0.3, 0.75, 0.3], [0.25, 0.3, 0.25, 0.65], [0.75, 0.3, 0.75, 0.65], [0, 0.65, 0.25, 0.65], [0.75, 0.65, 1, 0.65], [0, 0.65, 0, 1], [1, 0.65, 1, 1]], // ㅈ\n  14: [[0.3, 0, 0.7, 0], [0, 0.22, 1, 0.22], [0.5, 0.22, 0.5, 0.45], [0.25, 0.45, 0.75, 0.45], [0.25, 0.45, 0.25, 0.72], [0.75, 0.45, 0.75, 0.72], [0, 0.72, 0.25, 0.72], [0.75, 0.72, 1, 0.72], [0, 0.72, 0, 1], [1, 0.72, 1, 1]], // ㅊ\n  18: [[0.3, 0, 0.7, 0], [0, 0.25, 1, 0.25], [0.15, 0.5, 0.85, 1, 1]], // ㅎ\n};\nconst FIN = { 1: 0, 4: 2, 7: 3, 8: 5, 16: 6, 17: 7, 19: 9, 21: 11, 22: 12, 23: 14, 27: 18 };\nconst VOW = {\n  0: [[0, 0, 0, 1], [0, 0.5, 0.75, 0.5]], // ㅏ\n  4: [[0.25, 0.5, 1, 0.5], [1, 0, 1, 1]], // ㅓ\n  5: [[0, 0.5, 0.4, 0.5], [0.4, 0, 0.4, 1], [1, 0, 1, 1]], // ㅔ\n  6: [[0.25, 0.33, 1, 0.33], [0.25, 0.67, 1, 0.67], [1, 0, 1, 1]], // ㅕ\n  8: [[0.5, 0, 0.5, 1], [0, 1, 1, 1]], // ㅗ\n  13: [[0, 0, 1, 0], [0.5, 0, 0.5, 1]], // ㅜ\n  18: [[0, 0.5, 1, 0.5]], // ㅡ\n  20: [[0.5, 0, 0.5, 1]], // ㅣ\n};\n\n// Regions [i0, j0, i1, j1] in nodes for the initial, the vowel and the final.\nfunction regions(V, T) {\n  if (V === 0 || V === 4 || V === 5 || V === 6 || V === 20) {\n    const wide = V === 5, ic = wide ? 6 : 7, iv = wide ? 8 : 9;\n    return T ? [[0, 0, ic, 7], [iv, 0, 13, 8], [1, 10, 12, 14]] : [[0, 1, ic, 13], [iv, 0, 13, 14], null];\n  }\n  return T ? [[1, 0, 12, 4], [0, 6, 13, 8], [1, 10, 12, 14]] : [[1, 0, 12, 7], [0, 9, 13, 13], null];\n}\n\n// One syllable: its plain strokes in LEDs, the corner LEDs of its rings, and\n// the fold runs. Folding gives every free node of the box to the nearest\n// level stroke straight above or below it, and the nodes a stroke gets lie\n// in rows 1, 2, 3 ... away from it. Each run of such nodes hangs from the row\n// before at one end, the right end and the left end taking turns, so the\n// stroke becomes one ribbon folded back and forth. Nodes no level stroke can\n// reach, beside an upright with nothing level over it, go the same way to\n// the nearest upright stroke left or right of them.\nfunction build(ch) {\n  const c = ch.charCodeAt(0) - 0xac00;\n  const L = floor(c / 588), V = floor(c / 28) % 21, T = c % 28;\n  const reg = regions(V, T);\n  const strokes = [], corners = [];\n  const busy = new Uint8Array(N), hOwn = new Int16Array(N).fill(-1), vOwn = new Int16Array(N).fill(-1);\n  const add = (shape, r) => {\n    if (!shape || !r) return;\n    const [a, b, c2, d] = r;\n    const mi = (u) => a + round(u * (c2 - a)), mj = (v) => b + round(v * (d - b));\n    for (const s of shape) {\n      const i0 = mi(s[0]), j0 = mj(s[1]), i1 = mi(s[2]), j1 = mj(s[3]);\n      if (s[4]) {\n        strokes.push({ o: 1, i0: i0 + 1, j0, i1: i1 - 1, j1: j0 });\n        strokes.push({ o: 0, i0, j0: j0 + 1, i1: i0, j1: j1 - 1 });\n        strokes.push({ o: 0, i0: i1, j0: j0 + 1, i1, j1: j1 - 1 });\n        strokes.push({ o: 1, i0: i0 + 1, j0: j1, i1: i1 - 1, j1 });\n        for (const [ci, cj, dx, dy] of [[i0, j0, 1, 1], [i1, j0, -1, 1], [i0, j1, 1, -1], [i1, j1, -1, -1]]) {\n          busy[ci + cj * NI] = 2;\n          corners.push(2 * ci + dx, 2 * cj + dy);\n        }\n      } else strokes.push({ o: j0 === j1 ? 1 : 0, i0: min(i0, i1), j0: min(j0, j1), i1: max(i0, i1), j1: max(j0, j1) });\n    }\n  };\n  add(CONS[L], reg[0]);\n  add(VOW[V], reg[1]);\n  if (T) add(CONS[FIN[T]], reg[2]);\n  strokes.forEach((s, k) => {\n    for (let j = s.j0; j \u003c= s.j1; j++)\n      for (let i = s.i0; i \u003c= s.i1; i++) {\n        busy[i + j * NI] = 1;\n        if (s.o) hOwn[i + j * NI] = k;\n        else vOwn[i + j * NI] = k;\n      }\n  });\n\n  // Claims: stroke, side (+1 below or right of it, -1 above or left) and\n  // distance, first for the level strokes, then for the upright ones.\n  const own = new Int16Array(N).fill(-1), side = new Int8Array(N), dist = new Int8Array(N), kind = new Uint8Array(N);\n  for (let n = 0; n \u003c N; n++) {\n    if (busy[n]) continue;\n    const i = n % NI, j = floor(n / NI);\n    let bd = 99;\n    for (let jj = j - 1; jj >= 0; jj--) {\n      const m = i + jj * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && hOwn[m] >= 0) (own[n] = hOwn[m]), (side[n] = 1), (bd = dist[n] = j - jj);\n      break;\n    }\n    for (let jj = j + 1; jj \u003c NJ; jj++) {\n      const m = i + jj * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && hOwn[m] >= 0 && jj - j \u003c bd) (own[n] = hOwn[m]), (side[n] = -1), (dist[n] = jj - j);\n      break;\n    }\n    if (own[n] >= 0) kind[n] = 1;\n  }\n  for (let n = 0; n \u003c N; n++) if (kind[n]) busy[n] = 3;\n  for (let n = 0; n \u003c N; n++) {\n    if (busy[n]) continue;\n    const i = n % NI, j = floor(n / NI);\n    let bd = 99;\n    for (let ii = i - 1; ii >= 0; ii--) {\n      const m = ii + j * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && vOwn[m] >= 0) (own[n] = vOwn[m]), (side[n] = 1), (bd = dist[n] = i - ii);\n      break;\n    }\n    for (let ii = i + 1; ii \u003c NI; ii++) {\n      const m = ii + j * NI;\n      if (!busy[m]) continue;\n      if (busy[m] === 1 && vOwn[m] >= 0 && ii - i \u003c bd) (own[n] = vOwn[m]), (side[n] = -1), (dist[n] = ii - i);\n      break;\n    }\n    if (own[n] >= 0) kind[n] = 2;\n  }\n\n  // Runs: [level, connector x, y, start x, y, end x, y], all in LEDs.\n  const runs = [];\n  let deepest = 0;\n  for (let n = 0; n \u003c N; n++) {\n    if (!kind[n]) continue;\n    const i = n % NI, j = floor(n / NI), lv = dist[n], sd = side[n], k = own[n], hz = kind[n] === 1;\n    // Only the first node of a run starts it.\n    const pi = hz ? i - 1 : i, pj = hz ? j : j - 1;\n    if (pi >= 0 && pj >= 0) {\n      const m = pi + pj * NI;\n      if (kind[m] === kind[n] && own[m] === k && side[m] === sd && dist[m] === lv) continue;\n    }\n    let e = hz ? i : j;\n    for (;;) {\n      const m = hz ? e + 1 + j * NI : i + (e + 1) * NI;\n      if ((hz ? e + 1 >= NI : e + 1 >= NJ) || kind[m] !== kind[n] || own[m] !== k || side[m] !== sd || dist[m] !== lv) break;\n      e++;\n    }\n    const lo = hz ? i : j;\n    // The turn falls at the far end and the near end in turn, row by row.\n    const atHi = (lv + (sd > 0 ? 1 : 0)) % 2 === 0;\n    const cA = atHi ? e : lo, cB = atHi ? lo : e;\n    if (hz) runs.push(lv, 2 * cA, 2 * j - sd, 2 * cA, 2 * j, 2 * cB, 2 * j);\n    else runs.push(lv, 2 * i - sd, 2 * cA, 2 * i, 2 * cA, 2 * i, 2 * cB);\n    deepest = max(deepest, lv);\n  }\n  const plain = [];\n  for (const s of strokes) plain.push(2 * s.i0, 2 * s.j0, 2 * s.i1, 2 * s.j1);\n  return { plain, corners, runs: Int16Array.from(runs), deepest };\n}\n\n// Seconds at Speed 2: the hold, the fold rate in rows a second, the lag of\n// each syllable behind the one before it, in rows, and the swap.\nconst HOLD = 3, RATE = 14, STAG = 0.8, FOLD = (NJ + 7 * STAG) / RATE, SWAP = 1;\n// Ink and paper levels, and how far the two dimmer channels wander per LED\n// (times -128..127). The brightest channel wanders by 3 at most, so two\n// neighbours of one kind never differ by more than 6.\nconst INK_V = 214, PAPER = [58, 40, 32], MOTTLE = 0.45, GRAIN = 0.24;\n\nfunction impression(S) {\n  // A new impression: the paper grain and the ink's mottle per LED, and the\n  // patches where ink fails to take, coarse blots with a fine speckle in them.\n  for (let p = 0; p \u003c W * H * 3; p++) S.grain[p] = floor(Math.random() * 256);\n  const GW = 24, GH = 46, g = new Float32Array(GW * GH);\n  for (let q = 0; q \u003c g.length; q++) g[q] = Math.random();\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const gx = x / 3, gy = y / 3, ix = floor(gx), iy = floor(gy), fx = gx - ix, fy = gy - iy;\n      const a = g[ix + iy * GW], b = g[ix + 1 + iy * GW], c = g[ix + (iy + 1) * GW], d = g[ix + 1 + (iy + 1) * GW];\n      const v = (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + d * fx) * fy;\n      S.blot[y * W + x] = 0.6 * v + 0.4 * Math.random();\n    }\n  // Spread the blot values evenly over 0..1 by rank, so Press means the\n  // share of ink that fails.\n  const order = Array.from(S.blot, (v, p) => p).sort((a, b) => S.blot[a] - S.blot[b]);\n  for (let r = 0; r \u003c order.length; r++) S.rank[order[r]] = r / order.length;\n}\n\nexport function setup(params) {\n  const S = (params.s = { ink: new Uint8Array(W * H), grain: new Uint8Array(W * H * 3), blot: new Float32Array(W * H), rank: new Float32Array(W * H) });\n  S.glyphs = TEXTS.map((t) => Array.from(t, build));\n  S.text = 0;\n  S.ph = 0;\n  // The first text holds 2.4 s, so the first change comes soon.\n  S.pt = HOLD - 2.4;\n  S.tau = 0;\n  S.hue = 0;\n  S.plain = 0;\n  S.press = 0.06;\n  S.F = new Float32Array(8);\n  S.q = 1;\n  impression(S);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3) / 2;\n  S.hue = k[0];\n  S.plain = cl(k[2], 0, 1);\n  S.press = cl(k[3], 0, 1);\n  S.tau += dt * sp;\n  S.pt += dt * sp;\n  if (S.ph === 0 && input.btnPressed && input.btnPressed.some(Boolean)) S.pt = HOLD;\n  if (S.ph === 0 && S.pt >= HOLD) (S.ph = 1), (S.pt = 0);\n  if (S.ph === 1 && S.pt >= FOLD) (S.ph = 2), (S.pt = 0);\n  if (S.ph === 2 && S.pt >= SWAP / 2 && !S.swapped) {\n    S.text = (S.text + 1) % TEXTS.length;\n    S.swapped = 1;\n    impression(S);\n  }\n  if (S.ph === 2 && S.pt >= SWAP) (S.ph = 3), (S.pt = 0), (S.swapped = 0);\n  if (S.ph === 3 && S.pt >= FOLD) (S.ph = 0), (S.pt = 0);\n  const u = S.pt * RATE, cap = (1 - S.plain) * NJ;\n  for (let i = 0; i \u003c 8; i++) {\n    let f = NJ;\n    if (S.ph === 1) f = NJ - max(0, u - i * STAG);\n    else if (S.ph === 2) f = 0;\n    else if (S.ph === 3) f = max(0, u - i * STAG);\n    S.F[i] = min(cl(f, 0, NJ), cap);\n  }\n  S.q = S.ph === 2 ? abs(1 - (2 * S.pt) / SWAP) : 1;\n}\n\nfunction line(ink, x0, y0, x1, y1, count) {\n  const dx = Math.sign(x1 - x0), dy = Math.sign(y1 - y0);\n  for (let s = 0; s \u003c count; s++) {\n    const x = x0 + dx * s, y = y0 + dy * s;\n    ink[y * W + x] = 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.glyphs) return;\n  const ink = S.ink;\n  ink.fill(0);\n  for (let x = 0; x \u003c W; x++) ink[x] = ink[W + x] = ink[(H - 2) * W + x] = ink[(H - 1) * W + x] = 1;\n  for (let y = 0; y \u003c H; y++) ink[y * W] = ink[y * W + 1] = ink[y * W + W - 2] = ink[y * W + W - 1] = 1;\n  for (let y = 2; y \u003c H - 2; y++) ink[y * W + 31] = ink[y * W + 32] = 1;\n\n  const text = S.glyphs[S.text], q = S.q;\n  for (let k = 0; k \u003c 8; k++) {\n    const g = text[k], ox = COLX[k >> 2], oy = ROWY[k & 3], F = S.F[k];\n    const pl = g.plain;\n    for (let s = 0; s \u003c pl.length; s += 4) {\n      const len = abs(pl[s + 2] - pl[s]) + abs(pl[s + 3] - pl[s + 1]) + 1;\n      line(ink, ox + pl[s], oy + pl[s + 1], ox + pl[s + 2], oy + pl[s + 3], round(q * len));\n    }\n    if (q > 0.6) for (let s = 0; s \u003c g.corners.length; s += 2) ink[(oy + g.corners[s + 1]) * W + ox + g.corners[s]] = 1;\n    const r = g.runs;\n    for (let s = 0; s \u003c r.length; s += 7) {\n      const u = F - (r[s] - 1);\n      if (u \u003c= 0) continue;\n      const len = abs(r[s + 5] - r[s + 3]) + abs(r[s + 6] - r[s + 4]) + 1;\n      const shown = min(len + 1, ceil(u * (len + 1)));\n      ink[(oy + r[s + 2]) * W + ox + r[s + 1]] = 1;\n      if (shown > 1) line(ink, ox + r[s + 3], oy + r[s + 4], ox + r[s + 5], oy + r[s + 6], shown - 1);\n    }\n  }\n\n  // Colour. Every ink LED has the same brightest channel and every paper LED\n  // the same level, so the picture has only hard steps; the sheen and the\n  // mottle move the other two channels only.\n  const hue = 0.025 + S.hue, full = hsv(hue, 0.8, 1), pale = hsv(hue, 0.38, 1);\n  let mi = 0;\n  for (let c = 1; c \u003c 3; c++) if (full[c] > full[mi]) mi = c;\n  const c1 = (mi + 1) % 3, c2 = (mi + 2) % 3;\n  const f1 = full[c1] * INK_V, f2 = full[c2] * INK_V, p1 = pale[c1] * INK_V - f1, p2 = pale[c2] * INK_V - f2;\n  // The pressure rocks round the seal; the side it has left prints thin.\n  const ang = (S.tau * 2 * PI) / 6, ca = cos(ang), sa = sin(ang), press = S.press;\n  // A sheen of pressure sweeps down the seal once every 5 s at Speed 2.\n  const band = ((S.tau / 5) % 1) * 230 - 40;\n  const rgb = [0, 0, 0];\n  const grain = S.grain, blot = S.rank;\n  for (let y = 0; y \u003c H; y++) {\n    const ny = (y - 63.5) / 64;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, j1 = grain[3 * p] - 128, j2 = grain[3 * p + 1] - 128, j3 = (grain[3 * p + 2] % 7) - 3;\n      let on = ink[p];\n      if (on) {\n        const t = 0.5 + 0.5 * (((x - 31.5) / 32) * ca + ny * sa);\n        if (blot[p] \u003c press * (0.15 + 0.85 * t * t)) on = 0;\n      }\n      if (on) {\n        const sh = max(0, 1 - abs(x * 0.5 + y - band) / 10);\n        const v = INK_V + j3;\n        rgb[mi] = v;\n        rgb[c1] = cl(f1 + p1 * sh + j1 * MOTTLE, 0, v) | 0;\n        rgb[c2] = cl(f2 + p2 * sh + (0.6 * j1 + 0.3 * j2) * MOTTLE, 0, v) | 0;\n        display.setPixel(x, y, rgb[0], rgb[1], rgb[2]);\n      } else {\n        const v = PAPER[0] + j3;\n        display.setPixel(x, y, v, cl(PAPER[1] + j1 * GRAIN, 0, v) | 0, cl(PAPER[2] + (0.6 * j1 + 0.3 * j2) * GRAIN, 0, v) | 0);\n      }\n    }\n  }\n}\n","penney-game":"// ===== Patternflow pattern =====\n// Title:   Penney's Game\n// Family:  data\n// Idea:    A fair coin is tossed into the top row from the right, each toss pushing the earlier ones left, until A's or B's triple fills the three slots at the right end; the finished game slides down a row, so the winning triples stack into a column under the two players' choices while a tall bar of wins settles onto the odds from Conway's leading numbers.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Penney's game (Walter Penney, Journal of Recreational Mathematics, 1969), its odds by John Horton Conway's leading numbers (Martin Gardner, Scientific American, 1974), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, A=0..7, Rival=0..6\n//\n// Knob 1: Hue. Turns all four colours round the wheel together: at 0 heads are gold and tails azure, A's wins pink and B's green.\n// Knob 2: Speed. Tosses a second: 10 at 2, 1 at 0.2, 15 at 3. A game of HHT against THH takes 6.5 tosses on average, so at 2 a new row comes down about once a second.\n// Knob 3: A. The triple A picks, in this order: HHT, THH, TTH, HTT, HTH, THT, HHH, TTT. The first four are a loop: each one is B's best reply to the one before it, and B's best reply to HTT is HHT again. Turning it starts the tally again.\n// Knob 4: Rival. B's triple, from the seven A left, ranked by its chance against A: 0 is the best reply, (not x2) x1 x2, which wins 2, 3 or 7 times to 1; 6 is the worst, from an even game against HHH or TTT down to losing 7 times to 1 against THH or HTT. Turning it starts the tally again.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Conway's leading numbers. A triple is three bits, oldest toss first,\n// heads 0 and tails 1. XY sets the bit worth 2^(L-1) when the last L tosses\n// of X are the first L of Y. B's odds against A are (AA - AB) : (BB - BA).\n// Checked against 200,000 simulated games for each of the eight A and its\n// best reply: the share B won came within 0.0013 of these numbers. This\n// pattern's own tally, run for an hour at Speed 3 (about 5,500 games a\n// matchup), came within one standard error on five matchups.\nconst N = 3, MASK = 7;\nconst corr = (X, Y) => {\n  let c = 0;\n  for (let L = N; L >= 1; L--) if ((X & ((1 \u003c\u003c L) - 1)) === Y >> (N - L)) c += 1 \u003c\u003c (L - 1);\n  return c;\n};\n// HHT, THH, TTH, HTT first: B's best reply to each is the next, and to HTT\n// it is HHT. Then HTH, THT, HHH and TTT.\nconst A_ORDER = [1, 4, 6, 3, 2, 5, 0, 7];\nfunction matchup(A, rank) {\n  const rivals = [];\n  for (let B = 0; B \u003c 8; B++) {\n    if (B === A) continue;\n    const a = corr(A, A) - corr(A, B), b = corr(B, B) - corr(B, A);\n    rivals.push({ B, a, b, p: a / (a + b) });\n  }\n  rivals.sort((u, v) => v.p - u.p || u.B - v.B);\n  const r = rivals[rank];\n  const g = (x, y) => (y ? g(y, x % y) : x);\n  const d = g(r.a, r.b);\n  // pB is B's chance of winning a game; the odds read A : B.\n  return { A, B: r.B, pB: r.p, oddsA: r.b / d, oddsB: r.a / d };\n}\n\n// ---- Type: digits and the letters A and B, 3 by 5.\nconst GLYPH = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\", 8: \"111101111101111\", 9: \"111101111001111\",\n  A: \"010101111101101\", B: \"110101110101110\",\n};\n\n// ---- Layout. The stream starts at row 14, one game every 5 rows: coins\n// 3 by 3 on a 4 LED pitch, an underline row and a gap. Each game is right\n// aligned on the window, the three slots at x = 44, 48 and 52 that the coin\n// has to match, so the triples that won stand in one column under A's and\n// B's own. 13 slots a row; a longer game shows its last 12 behind a mark.\nconst TOP = 14, PITCH = 5, XW = 52, SLOTS = 13, ROWS = 23;\nconst BX = 58, BW = 5, BY = TOP, BH = H - TOP;\nconst RATE = 5;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, key: \"\", m: null,\n    cur: [], games: [], aw: 0, bw: 0,\n    phase: 0, hold: 0, winner: -1, acc: 0, slide: 0, last: -9, won: -9,\n    rgb: new Float32Array(W * H * 3),\n  };\n}\n\n// One game from the first toss to the end, for filling the stream at once.\nfunction playOut(m) {\n  const g = [];\n  let w = 0;\n  for (;;) {\n    const c = Math.random() \u003c 0.5 ? 0 : 1;\n    g.push(c);\n    w = ((w \u003c\u003c 1) | c) & MASK;\n    if (g.length >= N && w === m.A) return { g, w: 0 };\n    if (g.length >= N && w === m.B) return { g, w: 1 };\n  }\n}\n\nfunction restart(S) {\n  S.games = [];\n  S.aw = S.bw = 0;\n  for (let i = 0; i \u003c ROWS; i++) {\n    const r = playOut(S.m);\n    S.games.push(r);\n    if (r.w) S.bw++;\n    else S.aw++;\n  }\n  S.cur = [];\n  S.phase = 0;\n  S.acc = 0;\n  S.slide = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const ai = cl(round(k[2]), 0, 7), ri = cl(round(k[3]), 0, 6), key = ai + \",\" + ri;\n  if (key !== S.key) {\n    S.key = key;\n    S.m = matchup(A_ORDER[ai], ri);\n    restart(S);\n  }\n  const m = S.m;\n  if (S.phase === 0) {\n    S.acc += d * RATE * S.speed;\n    while (S.acc >= 1 && S.phase === 0) {\n      S.acc -= 1;\n      const c = Math.random() \u003c 0.5 ? 0 : 1;\n      S.cur.push(c);\n      S.last = S.t;\n      const n = S.cur.length;\n      if (n >= N) {\n        const w = (S.cur[n - 3] \u003c\u003c 2) | (S.cur[n - 2] \u003c\u003c 1) | S.cur[n - 1];\n        if (w === m.A || w === m.B) {\n          S.winner = w === m.A ? 0 : 1;\n          if (S.winner) S.bw++;\n          else S.aw++;\n          S.phase = 1;\n          S.hold = 0;\n          S.won = S.t;\n        }\n      }\n    }\n  } else {\n    // The winning triple holds a moment, then the row goes down.\n    S.hold += d;\n    if (S.hold >= min(1.5, 0.7 / S.speed)) {\n      S.games.unshift({ g: S.cur, w: S.winner });\n      if (S.games.length > ROWS + 1) S.games.pop();\n      S.cur = [];\n      S.phase = 0;\n      S.acc = 0;\n      S.slide += PITCH;\n    }\n  }\n  S.slide = max(0, S.slide - d * PITCH * 6);\n}\n\nfunction put(rgb, x, y, c, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  rgb[p] += c[0] * v, rgb[p + 1] += c[1] * v, rgb[p + 2] += c[2] * v;\n}\n// A coin: a 3 by 3 disc with soft corners.\nfunction coin(rgb, x, y, c, v) {\n  for (let j = 0; j \u003c 3; j++) for (let i = 0; i \u003c 3; i++) put(rgb, x + i, y + j, c, i !== 1 && j !== 1 ? v * 0.35 : v);\n}\nfunction glyph(rgb, ch, x, y, c, v) {\n  const g = GLYPH[ch];\n  for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") put(rgb, x + q, y + r, c, v);\n}\nfunction number(rgb, n, xr, y, c, v) {\n  const s = String(n);\n  for (let i = 0; i \u003c s.length; i++) glyph(rgb, s[s.length - 1 - i], xr - 3 - 4 * i, y, c, v);\n}\n\n// One game's row with its top at y. live: the game still being tossed.\nfunction row(S, rgb, g, w, y, live, cols) {\n  if (y + 3 \u003c TOP - 1 || y >= H) return;\n  const n = g.length, show = n > SLOTS ? SLOTS - 1 : n, t = S.t;\n  for (let j = 0; j \u003c show; j++) {\n    const c = g[n - 1 - j], x = XW - 4 * j;\n    let v = j \u003c N ? 0.95 : 0.62;\n    if (live) {\n      v = j \u003c N ? 0.85 : 0.6;\n      if (j === 0) v = min(1, v + 0.6 * exp(-(t - S.last) * 8));\n    }\n    if (y >= TOP - 1) coin(rgb, x, y, c ? cols.T : cols.H, v);\n  }\n  if (n > SLOTS) for (let j = 0; j \u003c 3; j++) put(rgb, XW - 4 * (SLOTS - 1) + j, y + 1, cols.dim, 0.5);\n  if (w >= 0 && n >= N && y + 3 >= TOP) {\n    let v = 0.7;\n    if (live) v = 0.6 + 0.4 * (0.5 + 0.5 * Math.cos((t - S.won) * 18));\n    for (let x = XW - 8; x \u003c= XW + 2; x++) put(rgb, x, y + 3, w ? cols.B : cols.A, v);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.m) return;\n  const rgb = S.rgb, m = S.m, hue = S.hue;\n  rgb.fill(0);\n  const cols = {\n    H: hsv(0.14 + hue, 0.66, 1), T: hsv(0.57 + hue, 0.8, 1),\n    A: hsv(0.9 + hue, 0.62, 1), B: hsv(0.36 + hue, 0.72, 1),\n    dim: hsv(0.6 + hue, 0.1, 1), ink: hsv(0.6 + hue, 0.06, 1),\n  };\n\n  // Header: count, letter, triple, and the player's side of the odds.\n  for (let s = 0; s \u003c 2; s++) {\n    const y = 1 + 6 * s, c = s ? cols.B : cols.A, X = s ? m.B : m.A;\n    number(rgb, s ? S.bw : S.aw, 35, y, c, 0.75);\n    glyph(rgb, s ? \"B\" : \"A\", 38, y, c, 1);\n    for (let j = 0; j \u003c N; j++) coin(rgb, XW - 8 + 4 * j, y + 1, (X >> (N - 1 - j)) & 1 ? cols.T : cols.H, 1);\n    glyph(rgb, String(s ? m.oddsB : m.oddsA), 59, y, cols.ink, 0.9);\n  }\n\n  // The stream: the game being tossed at the top, the finished ones below.\n  const sl = round(S.slide);\n  row(S, rgb, S.cur, S.phase === 1 ? S.winner : -1, TOP - sl, true, cols);\n  for (let k = 0; k \u003c S.games.length; k++) {\n    const y = TOP + PITCH * (k + 1) - sl;\n    if (y >= H) break;\n    row(S, rgb, S.games[k].g, S.games[k].w, y, false, cols);\n  }\n\n  // The tally: A's share of the games from the top of the bar, B's below,\n  // and a white tick where Conway's numbers put the line.\n  const tot = S.aw + S.bw, ha = tot ? round((BH * S.aw) / tot) : 0;\n  for (let y = BY; y \u003c H; y++) {\n    const isA = y - BY \u003c ha, c = isA ? cols.A : cols.B;\n    for (let x = BX; x \u003c BX + BW; x++) put(rgb, x, y, c, 0.55);\n  }\n  const yt = BY + round(BH * (1 - m.pB));\n  for (let x = BX - 2; x \u003c W; x++) put(rgb, x, yt, cols.ink, x >= BX && x \u003c BX + BW ? 0.45 : 1);\n\n  for (let p = 0; p \u003c W * H; p++) {\n    const r = rgb[p * 3], g = rgb[p * 3 + 1], b = rgb[p * 3 + 2];\n    if (r + g + b > 0) display.setPixel(p % W, floor(p / W), min(255, 255 * r) | 0, min(255, 255 * g) | 0, min(255, 255 * b) | 0);\n  }\n}\n","steiner-symmetrization":"// ===== Patternflow pattern =====\n// Title:   Steiner Symmetrization\n// Family:  line\n// Idea:    An irregular shape drawn as a hatch of parallel one-LED chords slides every chord along itself, each at its own moment so a shear wave runs down the stack, until its midpoint sits on a faint axis and chords cut by a gap close into one, then the hatch turns to a new axis and slides again, while a faint circle marks the disc of the same area and a bar at the foot shrinks the perimeter toward the disc's.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Steiner symmetrization (Jakob Steiner, 1838), repeated symmetrizations converging to the disc (Wilhelm Gross, 1917, after Wilhelm Blaschke's selection theorem in Kreis und Kugel, 1916), symmetrization in a finite set of directions (Daniel Klain, 2012), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Axes=0..8\n//\n// Knob 1: Hue. Turns the hatch round the wheel. At 0 the chords run from azure to violet along the axis, with the bar in amber.\n// Knob 2: Speed. At 2 a symmetrization takes about 2.1 s: the chords slide for up to 1.4 s, rest 0.2 s and the hatch turns for 0.5 s, and a shape that has come round holds 1.3 s and fades into the next. At 0.2 ten times slower, at 3 two thirds as long.\n// Knob 3: Shape. 0 takes the five starting shapes in turn, a crescent, an egg with a hole, a seven pointed star, two blobs and a comb; 1 to 5 start from one of them every time.\n// Knob 4: Axes. 0 turns the axis by 68.75 degrees, the golden angle of a half turn, every time, so no axis comes back and the shape rounds into the disc. 1 to 8 use that many axes, evenly spaced and drawn faintly. One axis does all its work in the first slide. With a few the shape settles into one with a mirror for every axis that is still not the disc: with two axes the star stops at 1.24 times the disc's perimeter, with three at 1.03, and from four on it comes within 1%.\n\nconst W = 64, H = 128, OX = 32, OY = 64;\nconst { floor, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Chords one LED apart, s from -72 to 72 along the axis, at most MAXP\n// pieces each.\nconst K = 144, S0 = -72, MAXP = 8, MAXC = 16;\n// The golden angle of a half turn, pi (2 - phi) for the golden ratio phi:\n// 68.75 degrees, so no two axes are ever the same.\nconst GOLD = (PI * (3 - sqrt(5))) / 2;\nconst BAR = 60;\n\n// Shapes as rings of points; a point is inside when a ray from it crosses\n// the rings an odd number of times, so a ring inside another is a hole.\nfunction arc(cx, cy, h, b, n, out, back) {\n  // A circular arc from (cx, cy - h) to (cx, cy + h) bulging left by b.\n  const R = (h * h + b * b) / (2 * b), p0 = Math.asin(h / R), C = cx - b + R;\n  for (let i = 0; i \u003c= n; i++) {\n    const u = back ? 1 - i / n : i / n, p = -p0 + 2 * p0 * u;\n    out.push(C - R * cos(p), cy + R * sin(p));\n  }\n  return out;\n}\nfunction ellipse(cx, cy, rx, ry, n, out) {\n  for (let i = 0; i \u003c n; i++) out.push(cx + rx * cos((2 * PI * i) / n), cy + ry * sin((2 * PI * i) / n));\n  return out;\n}\nconst SHAPES = [\n  // A crescent between two arcs on the same chord.\n  () => [arc(52, 64, 56, 12, 40, arc(52, 64, 56, 40, 60, []), true).slice(0, -2)],\n  // An egg with a round hole off its centre.\n  () => [ellipse(32, 64, 29, 40, 72, []), ellipse(39, 54, 14, 14, 40, [])],\n  // A seven pointed star, stretched to the panel.\n  () => {\n    const out = [];\n    for (let i = 0; i \u003c 14; i++) {\n      const a = (PI * i) / 7 - PI / 2 + 0.2, r = i % 2 ? 15 : 30;\n      out.push(32 + r * cos(a), 64 + 1.55 * r * sin(a));\n    }\n    return [out];\n  },\n  // Two blobs apart.\n  () => [ellipse(22, 37, 17, 24, 48, []), ellipse(42, 92, 19, 21, 48, [])],\n  // A comb of three teeth on a spine.\n  () => [[12, 14, 60, 14, 60, 30, 26, 30, 26, 56, 60, 56, 60, 72, 26, 72, 26, 98, 60, 98, 60, 114, 12, 114]],\n];\n\nfunction perimeter(rings) {\n  let p = 0;\n  for (const r of rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const j = (i + 2) % r.length;\n      p += sqrt((r[j] - r[i]) ** 2 + (r[j + 1] - r[i + 1]) ** 2);\n    }\n  return p;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    rings: null, shape: -1, n: 0, phase: 1, pt: 0.5, phi: PI / 2, from: PI / 2, to: PI / 2,\n    P0: 1, P: 1, Pfrom: 1, Pto: 1, A: 1, prevP: 1, still: 0, fade: 1, dir: 1,\n    cross: new Float64Array(K * MAXC), nc: new Int32Array(K),\n    a0: new Float64Array(K * MAXP), b0: new Float64Array(K * MAXP), a1: new Float64Array(K * MAXP), b1: new Float64Array(K * MAXP),\n    cnt: new Int32Array(K), L: new Float64Array(K), del: new Float64Array(K), dur: new Float64Array(K), u: new Float64Array(K), sp: new Float64Array(K),\n    col: new Float64Array(3), tmp: new Float64Array(3), ax: new Float64Array(16),\n    next: null, prog: 0.5, hue: 0.5, axes: 0,\n  };\n  return params.s;\n}\n\n// The pieces of every chord at angle phi: the line s = const through the\n// rings, crossings sorted along t and taken in pairs.\nfunction cut(S, phi, a, b, cnt) {\n  const { cross, nc } = S, ca = cos(phi), sa = sin(phi);\n  nc.fill(0);\n  for (const r of S.rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const j = (i + 2) % r.length;\n      const x1 = r[i] - OX, y1 = r[i + 1] - OY, x2 = r[j] - OX, y2 = r[j + 1] - OY;\n      const s1 = x1 * ca + y1 * sa, s2 = x2 * ca + y2 * sa;\n      if (s1 === s2) continue;\n      const t1 = -x1 * sa + y1 * ca, t2 = -x2 * sa + y2 * ca;\n      const lo = min(s1, s2), hi = max(s1, s2);\n      // Chords with lo \u003c= s \u003c hi, so a vertex is counted once. Both ends\n      // are tested on the same s, or rounding counts a vertex twice.\n      for (let k = max(0, floor(lo - S0 - 0.5)); k \u003c K; k++) {\n        const s = S0 + k + 0.5;\n        if (s \u003c lo) continue;\n        if (s >= hi) break;\n        const t = t1 + ((s - s1) / (s2 - s1)) * (t2 - t1);\n        let m = nc[k];\n        if (m >= MAXC) continue;\n        const o = k * MAXC;\n        while (m > 0 && cross[o + m - 1] > t) {\n          cross[o + m] = cross[o + m - 1];\n          m--;\n        }\n        cross[o + m] = t;\n        nc[k]++;\n      }\n    }\n  for (let k = 0; k \u003c K; k++) {\n    const n = min(MAXP, nc[k] >> 1), o = k * MAXC;\n    cnt[k] = n;\n    for (let j = 0; j \u003c n; j++) {\n      a[k * MAXP + j] = cross[o + 2 * j];\n      b[k * MAXP + j] = cross[o + 2 * j + 1];\n    }\n  }\n}\n\n// The total length of the chord at s, for the ends of the new shape.\nfunction lengthAt(S, phi, s) {\n  const ca = cos(phi), sa = sin(phi), ts = [];\n  for (const r of S.rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const j = (i + 2) % r.length;\n      const x1 = r[i] - OX, y1 = r[i + 1] - OY, x2 = r[j] - OX, y2 = r[j + 1] - OY;\n      const s1 = x1 * ca + y1 * sa, s2 = x2 * ca + y2 * sa;\n      if (s1 === s2 || s \u003c min(s1, s2) || s >= max(s1, s2)) continue;\n      ts.push(-x1 * sa + y1 * ca + ((s - s1) / (s2 - s1)) * (-x2 * sa + y2 * ca + x1 * sa - y1 * ca));\n    }\n  ts.sort((p, q) => p - q);\n  let L = 0;\n  for (let i = 0; i + 1 \u003c ts.length; i += 2) L += ts[i + 1] - ts[i];\n  return L;\n}\n\n// Start a symmetrization about the axis through the centre at angle phi:\n// each chord's pieces now, and where they end, stacked in their order into\n// one chord centred on the axis. The new shape is a ring through the ends\n// of the centred chords for every run of chords that are not empty, so two\n// blobs no chord crosses stay two.\nfunction begin(S, phi) {\n  const { a0, b0, a1, b1, cnt, L, del, dur, u, sp } = S;\n  S.phi = S.from = S.to = phi;\n  cut(S, phi, a0, b0, cnt);\n  const ca = cos(phi), sa = sin(phi);\n  let lo = 1e9, hi = -1e9;\n  for (const r of S.rings)\n    for (let i = 0; i \u003c r.length; i += 2) {\n      const s = (r[i] - OX) * ca + (r[i + 1] - OY) * sa;\n      lo = min(lo, s);\n      hi = max(hi, s);\n    }\n  for (let k = 0; k \u003c K; k++) {\n    let len = 0;\n    for (let j = 0; j \u003c cnt[k]; j++) len += b0[k * MAXP + j] - a0[k * MAXP + j];\n    L[k] = len;\n    let at = -len / 2;\n    for (let j = 0; j \u003c cnt[k]; j++) {\n      const o = k * MAXP + j, l = b0[o] - a0[o];\n      a1[o] = at;\n      b1[o] = at + l;\n      at += l;\n    }\n    // The shear wave runs along the axis, the other way each time.\n    const w = cl((S0 + k + 0.5 - lo) / max(1, hi - lo), 0, 1);\n    del[k] = 0.45 * (S.dir > 0 ? w : 1 - w) + 0.08 * Math.random();\n    dur[k] = 0.7 * (0.8 + 0.4 * Math.random());\n    u[k] = 0;\n    sp[k] = 0;\n  }\n  S.dir = -S.dir;\n  // Runs of (s, length). A run's open end reaches past its last chord as\n  // far as the lengths' slope says, at most to the empty chord beside it.\n  const e = 1e-4, runs = [];\n  let run = null;\n  const end = (r, back) => {\n    const n = r.length, l0 = back ? r[n - 1] : r[1], l1 = n > 2 ? (back ? r[n - 3] : r[3]) : 0;\n    const d = n > 2 ? min(1, l0 / max(1e-3, l1 - l0)) : 0.5, s = (back ? r[n - 2] : r[0]) + (back ? d : -d);\n    if (back) r.push(s, 0);\n    else r.unshift(s, 0);\n  };\n  for (let k = 0; k \u003c K; k++) {\n    const s = S0 + k + 0.5;\n    if (s \u003c= lo + e || s >= hi - e) continue;\n    if (L[k] > 0) {\n      if (!run) run = [];\n      run.push(s, L[k]);\n    } else if (run) {\n      end(run, true);\n      runs.push(run);\n      run = null;\n    }\n  }\n  if (run) runs.push(run);\n  if (!runs.length) runs.push([]);\n  // The shape's own ends, measured exactly.\n  if (runs[0][0] !== undefined && runs[0][1] === 0) runs[0].splice(0, 2);\n  runs[0].unshift(lo + e, lengthAt(S, phi, lo + e));\n  for (let i = 1; i \u003c runs.length; i++) end(runs[i], false);\n  runs[runs.length - 1].push(hi - e, lengthAt(S, phi, hi - e));\n  // Keep the area the shape started with: sampling a curved edge at one LED\n  // loses a sliver every time, so the lengths are scaled back up.\n  let area = 0;\n  for (const r of runs) for (let i = 0; i + 3 \u003c r.length; i += 2) area += ((r[i + 2] - r[i]) * (r[i + 1] + r[i + 3])) / 2;\n  const f = area > 0 ? S.A / area : 1;\n  S.next = runs.map((r) => {\n    const ring = [];\n    for (let i = 0; i \u003c r.length; i += 2) ring.push(OX + r[i] * ca + ((f * r[i + 1]) / 2) * sa, OY + r[i] * sa - ((f * r[i + 1]) / 2) * ca);\n    for (let i = r.length - 2; i >= 0; i -= 2) ring.push(OX + r[i] * ca - ((f * r[i + 1]) / 2) * sa, OY + r[i] * sa + ((f * r[i + 1]) / 2) * ca);\n    return ring;\n  });\n  S.Pfrom = S.P;\n  S.Pto = perimeter(S.next);\n  S.phase = 0;\n  S.pt = 0;\n}\n\nfunction newShape(S, sel) {\n  S.shape = sel ? sel - 1 : (S.shape + 1) % SHAPES.length;\n  S.rings = SHAPES[S.shape]();\n  S.P0 = S.P = S.prevP = perimeter(S.rings);\n  S.n = 0;\n  S.still = 0;\n  S.pt = 0;\n  S.phi = S.from = S.to = PI / 2;\n  // The area, for the disc's perimeter, from the chords of the first cut.\n  cut(S, S.phi, S.a0, S.b0, S.cnt);\n  let A = 0;\n  for (let k = 0; k \u003c K; k++) for (let j = 0; j \u003c S.cnt[k]; j++) A += S.b0[k * MAXP + j] - S.a0[k * MAXP + j];\n  S.A = A;\n}\n\nconst ease = (x) => x * x * (3 - 2 * x);\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = kv[0] || 0;\n  const rate = cl(kv[1], 0.2, 3) / 2, sel = cl(Math.round(kv[2]), 0, 5), axes = cl(Math.round(kv[3]), 0, 8);\n  S.axes = axes;\n  if (!S.rings) newShape(S, sel);\n  const d = cl(dt || 0, 0, 0.1) * rate;\n  S.pt += d;\n  if (S.phase === 0) {\n    // Slide: each chord eases from its pieces to the centred chord.\n    let all = true, sum = 0;\n    for (let k = 0; k \u003c K; k++) {\n      const x = cl((S.pt - S.del[k]) / S.dur[k], 0, 1), e = ease(x);\n      S.sp[k] = d > 0 ? (e - S.u[k]) / d : 0;\n      S.u[k] = e;\n      sum += e;\n      if (x \u003c 1) all = false;\n    }\n    S.prog = sum / K;\n    S.P = S.Pfrom + (S.Pto - S.Pfrom) * S.prog;\n    if (all) {\n      S.rings = S.next;\n      S.P = S.Pto;\n      S.n++;\n      S.still = abs(S.prevP - S.P) \u003c 0.002 * S.P ? S.still + 1 : 0;\n      S.prevP = S.P;\n      S.phase = 1;\n      S.pt = 0;\n      S.sp.fill(0);\n    }\n  } else if (S.phase === 1 && S.pt > (S.n ? 0.2 : 0.15)) {\n    // Rest, then turn to the next axis, or let a round or settled shape go.\n    const disc = 2 * sqrt(PI * S.A);\n    if (S.n && (S.P \u003c disc * 1.006 || S.still >= 2 || S.n >= 12)) {\n      S.phase = 3;\n      S.pt = 0;\n    } else if (!S.n) begin(S, S.phi);\n    else {\n      S.from = S.phi;\n      S.to = S.phi + (axes ? PI / axes : GOLD);\n      S.phase = axes === 1 ? 2.5 : 2;\n      S.pt = 0;\n    }\n  } else if (S.phase === 2) {\n    const x = cl(S.pt / 0.5, 0, 1);\n    S.phi = S.from + (S.to - S.from) * ease(x);\n    if (x >= 1) begin(S, S.to % (2 * PI));\n  } else if (S.phase === 2.5) {\n    // One axis: nothing to turn to.\n    if (S.pt > 0.3) begin(S, S.phi);\n  } else if (S.phase === 3) {\n    // Hold the shape it settled into, then fade into a new one.\n    S.fade = S.pt \u003c 1.3 ? 1 : max(0, 1 - (S.pt - 1.3) / 0.3);\n    if (S.pt > 1.6) {\n      newShape(S, sel);\n      S.phase = 4;\n      S.pt = 0;\n    }\n  } else if (S.phase === 4) {\n    S.fade = min(1, S.pt / 0.3);\n    if (S.pt > 0.6) {\n      S.fade = 1;\n      begin(S, S.phi);\n    }\n  }\n  if (S.phase !== 0) S.prog = 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.rings) return;\n  const sliding = S.phase === 0, { a0, b0, a1, b1, cnt, u, sp } = S;\n  if (!sliding) cut(S, S.phi, a0, b0, cnt);\n  const ca = cos(S.phi), sa = sin(S.phi), h0 = 0.56 + S.hue, f = S.fade, col = S.col;\n  // Every axis of a finite set, drawn faintly; the current one a little\n  // brighter.\n  const na = S.axes || 1, rd = sqrt(S.A / PI), ax = S.ax;\n  for (let m = 1; m \u003c na; m++) {\n    ax[2 * m] = sin(S.phi + (PI * m) / na);\n    ax[2 * m + 1] = cos(S.phi + (PI * m) / na);\n  }\n  for (let Y = 0; Y \u003c H - 6; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const x = X + 0.5 - OX, y = Y + 0.5 - OY, s = x * ca + y * sa, t = -x * sa + y * ca;\n      const k = floor(s - S0);\n      let lit = 0, piece = 0;\n      if (k >= 0 && k \u003c K)\n        for (let j = 0; j \u003c cnt[k]; j++) {\n          const o = k * MAXP + j;\n          const A = sliding ? a0[o] + (a1[o] - a0[o]) * u[k] : a0[o], B = sliding ? b0[o] + (b1[o] - b0[o]) * u[k] : b0[o];\n          const c = min(t - A, B - t) + 0.5;\n          if (c > lit) {\n            lit = min(1, c);\n            piece = j;\n          }\n        }\n      if (lit > 0) {\n        // Hue runs along the axis, odd and even chords alternate in\n        // brightness, a moving chord flares and pieces cut apart by a gap\n        // keep their own tint until they meet.\n        const w = (s + 40) / 80, mv = sliding ? cl(abs(sp[k]) * 0.012 * (abs(a1[k * MAXP + piece] - a0[k * MAXP + piece]) + 4), 0, 1) : 0;\n        const tint = sliding && piece % 2 ? 0.22 * (1 - u[k]) : 0;\n        hsv(h0 + 0.16 * cl(w, 0, 1) + tint, 0.75 - 0.45 * mv, (k & 1 ? 0.9 : 0.56) + 0.12 * mv, col);\n        const g = lit * f * (abs(t) \u003c 0.5 ? 1.15 : 1);\n        display.setPixel(X, Y, min(255, col[0] * g) | 0, min(255, col[1] * g) | 0, min(255, col[2] * g) | 0);\n        continue;\n      }\n      // Outside: the axes, and the disc of the same area as a faint ring.\n      let v = 0;\n      if (abs(t) \u003c 0.5) v = 0.24;\n      else if (na > 1)\n        for (let m = 1; m \u003c na; m++) if (abs(-x * ax[2 * m] + y * ax[2 * m + 1]) \u003c 0.5) v = 0.13;\n      if (abs(sqrt(x * x + y * y) - rd) \u003c 0.5) v = max(v, 0.16);\n      if (v > 0) {\n        hsv(h0 + 0.08, 0.45, v * f, col);\n        display.setPixel(X, Y, col[0] | 0, col[1] | 0, col[2] | 0);\n      }\n    }\n  // The perimeter bar: full width is the starting shape's perimeter, the\n  // white tick the disc's 2 sqrt(pi A).\n  const len = (BAR * S.P) / S.P0, tick = 2 + (BAR * 2 * sqrt(PI * S.A)) / S.P0;\n  const bar = hsv(h0 + 0.5, 0.8, 0.95, S.tmp);\n  for (let X = 2; X \u003c 2 + BAR; X++) {\n    const c = cl(len - (X - 2), 0, 1);\n    for (let Y = 124; Y \u003c 126; Y++) {\n      if (c > 0) display.setPixel(X, Y, (bar[0] * c * f) | 0, (bar[1] * c * f) | 0, (bar[2] * c * f) | 0);\n      else display.setPixel(X, Y, 30 * f, 30 * f, 34 * f);\n    }\n  }\n  const T = floor(tick);\n  for (let Y = 122; Y \u003c 128; Y++) display.setPixel(T, Y, 255 * f, 255 * f, 255 * f);\n}\n","whitney-graustein":"// ===== Patternflow pattern =====\n// Title:   Whitney-Graustein\n// Family:  topology\n// Idea:    A closed curve drawn as a bright line coloured by the direction of its tangent keeps reshaping without ever stopping, so it never leaves its class of turning number, the regions it encloses shaded by their winding number and a dial counting how often the tangent turns, and a change of class has to pass through a cusp: a small loop pulled tight until it vanishes, or a kink born from one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Whitney-Graustein theorem (Hassler Whitney, On regular closed curves in the plane, 1937, crediting William Caspar Graustein), pattern round 69\n// Round:   69\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Turns=-2..3, Wobble=0..1\n//\n// Knob 1: Hue. Turns the colour wheel the tangent is painted with, and the region shades with it. At 0 a tangent pointing right is azure, regions of winding number 1 and 2 are violet and lilac, and regions of winding -1 are green.\n// Knob 2: Speed. At 2 the white marker runs round the curve in 4 s and a change of class takes 5 s, 2.4 of them on the way into and out of the cusp; 0.2 is ten times slower.\n// Knob 3: Turns. The turning number k, from -2 to 3, opening on 0, a figure eight. Each step of the knob is one change of class through one cusp, so a jump of three classes passes three.\n// Knob 4: Wobble. How far the curve strays from the plain shape of its class: three Fourier terms of the tangent angle, once, twice and three times round, reach 0.38, 0.28 and 0.18 radians at 0 and three times that at 1.\n// Buttons: a press moves the curve one class up (down from 3) through a cusp; a second press brings it back.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The curve. Its tangent angle is theta(t) = th0 + k t + p(t) for t\n// round the circle, so the tangent turns k times; p is periodic, three\n// Fourier terms whose sizes and phases drift. Its speed r(t) is solved\n// below so that the curve closes and never stops, so it stays regular and\n// every change of p is a regular homotopy: the class cannot change.\nconst NS = 600, DT = TAU / NS;\n// The plain shape of each class: theta = k t + b sin t. For k = 0 the\n// tangent swings 2.405 radians each way, the first zero of the Bessel\n// function J0, where the figure eight closes by itself.\nconst BASE = { \"-2\": 1.25, \"-1\": 0.5, 0: 2.405, 1: 0.5, 2: 1.25, 3: 1.6 };\nconst base = (k) => BASE[k] ?? 1.4;\n// Top strip for the dial and the number; the curve lives below it.\nconst TOP = 21, MARGIN = 3;\n\nfunction localTurn(S, d) {\n  // The kink, after the normal form (u^2, u^3 - s u) of a loop that is\n  // pulled tight into a cusp at s = 0 and smoothed away for s \u003c 0. Its\n  // tangent turns a full circle when s > 0 and not at all when s \u003c 0. The\n  // normal form's tangent only creeps back to straight, as 1/u; past\n  // |u| = 1.5 it is eased the rest of the way by |u| = 3, so the kink\n  // stays local.\n  const u = d / S.w, s = S.s;\n  let a = atan2(-2 * u, 3 * u * u - s);\n  const far = s > 0 && u > 0 ? TAU : 0;\n  if (s > 0 && u > 0) a += TAU;\n  const e = smooth((abs(u) - 1.5) / 1.5);\n  return a + (far - a) * e;\n}\n\nfunction build(S) {\n  const { kb, th0, b1, amp, ph, loop, mu, fade } = S;\n  const damp = S.damp;\n  // Wrapped Cauchy: (1 + rho) / (1 - rho), for the spread turn.\n  const q = (1 + S.rho) / (1 - S.rho);\n  const TH = S.TH;\n  let e0 = 0, e1 = 0, n = 0;\n  if (loop) {\n    e0 = localTurn(S, -PI);\n    e1 = localTurn(S, PI - 1e-9);\n    n = S.s > 0 ? 1 : 0;\n  }\n  for (let i = 0; i \u003c NS; i++) {\n    const t = i * DT;\n    let th = th0 + kb * t + b1 * sin(t) + damp * (amp[0] * sin(t + ph[0]) + amp[1] * sin(2 * t + ph[1]) + amp[2] * sin(3 * t + ph[2]));\n    if (loop) {\n      let d = t - S.t0;\n      d -= TAU * floor((d + PI) / TAU);\n      // The kink's turn, made exactly periodic.\n      let L = fade * (localTurn(S, d) - (e0 + ((e1 - e0 - TAU * n) * (d + PI)) / TAU));\n      // The same full turn as a wrapped Cauchy step: as rho falls to 0 it\n      // spreads evenly round the curve, where it is the turn of class k+1.\n      if (mu > 0) L += mu * (2 * Math.atan(q * Math.tan(d / 2)) + PI - L);\n      th += L;\n    }\n    TH[i] = th;\n  }\n  // Closure. The speed is r = exp(Re(conj(beta) e^(i theta))), positive\n  // for any beta, and beta minimises the convex sum of r over the samples:\n  // its gradient is the sum of r e^(i theta), the gap the curve would leave,\n  // and the minimum exists because the tangent points every way, or for\n  // k = 0 through more than a half turn. A few Newton steps from the last\n  // frame's beta find it.\n  const CS = S.CS, SN = S.SN;\n  for (let i = 0; i \u003c NS; i++) (CS[i] = cos(TH[i])), (SN[i] = sin(TH[i]));\n  let bu = S.bu, bv = S.bv;\n  for (let it = 0; it \u003c 12; it++) {\n    let gx = 0, gy = 0, hxx = 0, hxy = 0, hyy = 0;\n    for (let i = 0; i \u003c NS; i++) {\n      const c = CS[i], sn = SN[i], e = Math.exp(bu * c + bv * sn);\n      gx += e * c;\n      gy += e * sn;\n      hxx += e * c * c;\n      hxy += e * c * sn;\n      hyy += e * sn * sn;\n    }\n    const det = hxx * hyy - hxy * hxy;\n    let du = (hyy * gx - hxy * gy) / det, dv = (hxx * gy - hxy * gx) / det;\n    const st = sqrt(du * du + dv * dv);\n    if (st > 0.5) (du *= 0.5 / st), (dv *= 0.5 / st);\n    bu -= du;\n    bv -= dv;\n    if (st \u003c 1e-7) break;\n  }\n  // No closed curve has these tangents (a k = 0 curve whose tangent swings\n  // less than a half turn): report it and leave the last good curve alone.\n  let gx = 0, gy = 0;\n  for (let i = 0; i \u003c NS; i++) {\n    const e = Math.exp(bu * CS[i] + bv * SN[i]);\n    gx += e * CS[i];\n    gy += e * SN[i];\n  }\n  S.ok = Number.isFinite(bu) && Number.isFinite(bv) && abs(gx) + abs(gy) \u003c 1e-3 * NS;\n  if (!S.ok) return;\n  S.bu = bu;\n  S.bv = bv;\n  S.beta = sqrt(bu * bu + bv * bv);\n  let x = 0, y = 0;\n  const X = S.X, Y = S.Y;\n  for (let i = 0; i \u003c NS; i++) {\n    const r = Math.exp(bu * CS[i] + bv * SN[i]);\n    S.HT[i] = TH[i];\n    X[i] = x;\n    Y[i] = y;\n    x += r * CS[i] * DT;\n    y += r * SN[i] * DT;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    TH: new Float64Array(NS), HT: new Float64Array(NS), CS: new Float64Array(NS), SN: new Float64Array(NS), bu: 0, bv: 0, X: new Float64Array(NS), Y: new Float64Array(NS),\n    PX: new Float32Array(NS), PY: new Float32Array(NS),\n    rows: Array.from({ length: H }, () => []),\n    wind: new Int8Array(W * H),\n    kb: null, th0: 0, b1: 0, amp: [0, 0, 0], ph: [0, 0, 0],\n    loop: 0, mu: 0, rho: 0, damp: 1, fade: 0, s: 0, w: 0.4, t0: 0, phase: 0, pt: 0, dir: 0,\n    tau: 0, mark: 0, flash: 0, off: 0, hue: 0, wob: 0.3,\n    // Each harmonic of p drifts at its own pace.\n    rate: [0.11 + 0.05 * Math.random(), 0.17 + 0.05 * Math.random(), 0.23 + 0.05 * Math.random()],\n    seed: [Math.random() * TAU, Math.random() * TAU, Math.random() * TAU],\n  };\n}\n\n// Seconds at Speed 2 for easing the kink in, for the cusp, and for spreading\n// the new turn round the curve.\nconst EASE = 0.6, CUSP = 2.4, SPREAD = 2;\nconst S_MAX = 2;\n// The spread turn starts as wide as the kink: (1 - RHO) / (1 + RHO) = 0.2.\nconst RHO = 0.667;\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3) / 2;\n  S.hue = k[0];\n  S.wob = 0.5 + 1.0 * cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed.some(Boolean)) S.off = S.off ? 0 : 1;\n  const pick = cl(round(k[2]), -2, 3);\n  const target = S.off ? (pick \u003c 3 ? pick + 1 : pick - 1) : pick;\n  if (S.kb === null) (S.kb = target), (S.b1 = base(target));\n  S.tau += dt * sp;\n  // The marker goes round the curve once in 4 s at Speed 2.\n  S.mark = (S.mark + (dt * sp) / 4) % 1;\n  for (let m = 0; m \u003c 3; m++) {\n    S.amp[m] = S.wob * [0.75, 0.55, 0.35][m] * sin(S.rate[m] * TAU * S.tau * 0.5 + S.seed[m]);\n    S.ph[m] = S.seed[m] * 2 + S.tau * S.rate[m] * 1.3;\n  }\n  S.th0 += dt * sp * 0.05;\n\n  // Class changes, one step at a time.\n  if (!S.phase && target !== S.kb) {\n    S.dir = target > S.kb ? 1 : -1;\n    S.phase = 1;\n    S.pt = 0;\n    S.loop = 0;\n    build(S);\n    // The kink sits where the curve is farthest from its middle.\n    let cx = 0, cy = 0, best = -1;\n    for (let i = 0; i \u003c NS; i++) (cx += S.X[i]), (cy += S.Y[i]);\n    cx /= NS;\n    cy /= NS;\n    for (let i = 0; i \u003c NS; i += 3) {\n      const d = (S.X[i] - cx) ** 2 + (S.Y[i] - cy) ** 2;\n      if (d > best) (best = d), (S.t0 = i * DT);\n    }\n    // Next to class 0 the kink goes at t = 0, where the turn adds to the\n    // swing b1 sin t instead of cancelling it: a k = 0 curve needs its\n    // tangent to swing more than a half turn, or nothing closes it.\n    const lo = S.dir > 0 ? S.kb : S.kb - 1;\n    if (lo === 0 || lo === -1) S.t0 = 0;\n    S.loop = 1;\n    if (S.dir > 0) (S.fade = 0), (S.s = -S_MAX), (S.mu = 0), (S.rho = RHO);\n    else {\n      // Write the class-k curve as a class k-1 curve plus a full turn\n      // spread evenly round it, then gather that turn into a loop.\n      S.kb -= 1;\n      S.th0 -= PI - S.t0;\n      S.fade = 1;\n      S.s = S_MAX;\n      S.mu = 1;\n      S.rho = 0;\n    }\n  }\n  if (S.phase) {\n    S.pt += dt * sp;\n    // s runs from -S_MAX to S_MAX, slowest at the cusp so it can be seen.\n    const g = (u) => {\n      const v = 2 * cl(u, 0, 1) - 1;\n      return S_MAX * v * (0.2 + 0.8 * v * v);\n    };\n    const kLo = S.kb, kHi = S.kb + 1;\n    // Up runs the steps forward; down runs the same steps backward.\n    const p = S.dir > 0 ? S.pt : EASE + CUSP + SPREAD - S.pt;\n    // A bump grows, sharpens into a cusp, and a kink is born from it; the\n    // kink's full turn takes a wrapped Cauchy profile and spreads round the\n    // curve.\n    S.fade = cl(p / EASE, 0, 1);\n    S.s = g((p - EASE) / CUSP);\n    const v = cl((p - EASE - CUSP) / SPREAD, 0, 1);\n    S.mu = smooth(v / 0.3);\n    const spread = smooth((v - 0.3) / 0.7);\n    S.rho = RHO * (1 - spread);\n    S.b1 = base(kLo) + (base(kHi) - base(kLo)) * spread;\n    if (abs(S.s) \u003c 0.1 && S.fade > 0.99 && !S.mu) S.flash = 1;\n    if (S.pt >= EASE + CUSP + SPREAD) {\n      if (S.dir > 0) (S.kb += 1), (S.th0 += PI - S.t0);\n      S.loop = 0;\n      S.phase = 0;\n      S.mu = 0;\n      S.b1 = base(S.kb);\n    }\n  }\n  S.flash = max(0, S.flash - dt * 1.5);\n  // Where the wobble would push |beta| past 1.2, so that one stretch of the\n  // curve runs 11 times faster than another, or leaves nothing that closes,\n  // the wobble is turned down, and it comes back slowly.\n  S.damp = min(1, S.damp + dt * 0.3);\n  build(S);\n  for (let n = 0; n \u003c 12 && (!S.ok || S.beta > 1.2); n++) {\n    S.damp *= 0.8;\n    build(S);\n  }\n}\n\n// 3 by 5 digits and a minus.\nconst DIGITS = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\"];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.X || S.kb === null) return;\n  const { X, Y, HT: TH, PX, PY, rows, wind } = S;\n  // Fit the curve under the strip, a little taller than it is if there is room.\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c NS; i++) (x0 = min(x0, X[i])), (x1 = max(x1, X[i])), (y0 = min(y0, Y[i])), (y1 = max(y1, Y[i]));\n  const aw = W - 2 * MARGIN, ah = H - TOP - 2 * MARGIN;\n  const fx = aw / max(1e-6, x1 - x0), fy = ah / max(1e-6, y1 - y0);\n  const sx = min(fx, fy), sy = min(fy, sx * 1.8);\n  const cx = W / 2, cy = TOP + MARGIN + ah / 2, mx = (x0 + x1) / 2, my = (y0 + y1) / 2;\n  for (let i = 0; i \u003c NS; i++) {\n    PX[i] = cx + (X[i] - mx) * sx;\n    PY[i] = cy - (Y[i] - my) * sy;\n  }\n\n  // Winding numbers, row by row: each edge crossing the row's middle adds\n  // +1 going down the panel and -1 going up, counted from the left.\n  for (let y = 0; y \u003c H; y++) rows[y].length = 0;\n  for (let i = 0; i \u003c NS; i++) {\n    const j = (i + 1) % NS, ax = PX[i], ay = PY[i], bx = PX[j], by = PY[j];\n    if (ay === by) continue;\n    const dir = by > ay ? 1 : -1, lo = min(ay, by), hi = max(ay, by);\n    for (let y = Math.ceil(lo - 0.5); y + 0.5 \u003c hi && y \u003c H; y++) {\n      if (y \u003c 0 || y + 0.5 \u003c lo) continue;\n      rows[y].push(ax + ((y + 0.5 - ay) * (bx - ax)) / (by - ay), dir);\n    }\n  }\n  wind.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const r = rows[y];\n    if (!r.length) continue;\n    const idx = [];\n    for (let q = 0; q \u003c r.length; q += 2) idx.push(q);\n    idx.sort((a, b) => r[a] - r[b]);\n    let w = 0, q = 0;\n    for (let x = 0; x \u003c W; x++) {\n      while (q \u003c idx.length && r[idx[q]] \u003c x + 0.5) (w += r[idx[q] + 1]), q++;\n      wind[y * W + x] = w;\n    }\n  }\n  const hue0 = S.hue + 0.58;\n  const shade = (w) => {\n    if (!w) return null;\n    const a = min(3, abs(w));\n    return hsv(hue0 + (w > 0 ? 0.1 : -0.12) + 0.05 * a * Math.sign(w), 0.5, 0.16 + 0.12 * a);\n  };\n  const shades = {};\n  for (let w = -4; w \u003c= 4; w++) shades[w] = shade(w);\n  for (let y = TOP; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const c = shades[cl(wind[y * W + x], -4, 4)];\n      if (c) display.setPixel(x, y, c[0] * 255, c[1] * 255, c[2] * 255);\n    }\n\n  // The line, coloured by the direction it is drawn in.\n  const dirHue = (th) => atan2(sy * sin(th), sx * cos(th)) / TAU;\n  for (let i = 0; i \u003c NS; i++) {\n    const j = (i + 1) % NS, ax = PX[i], ay = PY[i], bx = PX[j], by = PY[j];\n    const c = hsv(hue0 + dirHue(TH[i]), 0.8, 1);\n    const steps = max(1, Math.ceil(2 * max(abs(bx - ax), abs(by - ay))));\n    for (let q = 0; q \u003c steps; q++) {\n      const u = q / steps;\n      display.setPixel(ax + (bx - ax) * u, ay + (by - ay) * u, c[0] * 255, c[1] * 255, c[2] * 255);\n    }\n  }\n\n  // The marker on the curve, and the dial: the colour wheel with a dot at\n  // the marker's tangent direction, which goes round k times while the\n  // marker goes round once.\n  const mi = floor(S.mark * NS) % NS, mth = TH[mi];\n  for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) display.setPixel(PX[mi] + dx, PY[mi] + dy, 255, 255, 255);\n  const DX = 11, DY = 10, DR = 7.5;\n  for (let y = 1; y \u003c 20; y++)\n    for (let x = 2; x \u003c 21; x++) {\n      const dx = x + 0.5 - DX, dy = y + 0.5 - DY, d = sqrt(dx * dx + dy * dy);\n      if (abs(d - DR) \u003c 0.75) {\n        const c = hsv(hue0 + atan2(-dy, dx) / TAU, 0.8, 0.55);\n        display.setPixel(x, y, c[0] * 255, c[1] * 255, c[2] * 255);\n      }\n    }\n  const ma = atan2(sy * sin(mth), sx * cos(mth));\n  const ddx = DX + DR * cos(ma), ddy = DY - DR * sin(ma);\n  for (let y = floor(ddy - 2); y \u003c= ddy + 2; y++)\n    for (let x = floor(ddx - 2); x \u003c= ddx + 2; x++) {\n      const d = sqrt((x + 0.5 - ddx) ** 2 + (y + 0.5 - ddy) ** 2);\n      if (d \u003c 1.7) display.setPixel(x, y, 255, 255, 255);\n    }\n  for (let y = floor(DY - 1); y \u003c= DY; y++) for (let x = floor(DX - 1); x \u003c= DX; x++) display.setPixel(x, y, 120, 120, 120);\n\n  // The turning number, doubled 3 by 5 digits.\n  const k = S.kb + (S.loop && (S.s > 0 || S.mu > 0) ? 1 : 0);\n  const lv = 150 + 105 * S.flash;\n  const dg = DIGITS[abs(k)] || DIGITS[0];\n  const ox = 40, oy = 5;\n  for (let b = 0; b \u003c 15; b++)\n    if (dg[b] === \"1\")\n      for (let e = 0; e \u003c 4; e++) display.setPixel(ox + 2 * (b % 3) + (e & 1), oy + 2 * floor(b / 3) + (e >> 1), lv, lv, lv);\n  if (k \u003c 0) for (let x = 31; x \u003c 37; x++) for (let e = 0; e \u003c 2; e++) display.setPixel(x, 9 + e, lv, lv, lv);\n\n  // The cusp flashes white, with a ring opening round it.\n  if (S.loop && S.flash > 0) {\n    const ci = floor(((S.t0 / TAU) % 1) * NS), px = PX[ci], py = PY[ci], rad = 2 + 7 * (1 - S.flash);\n    for (let y = floor(py - rad - 2); y \u003c= py + rad + 2; y++)\n      for (let x = floor(px - rad - 2); x \u003c= px + rad + 2; x++) {\n        const d = sqrt((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2);\n        const v = 255 * S.flash;\n        if (abs(d - rad) \u003c 0.7 || d \u003c 1.5) display.setPixel(x, y, v, v, v);\n      }\n  }\n}\n","composing-stick":"// ===== Patternflow pattern =====\n// Title:   Composing Stick\n// Family:  type\n// Idea:    Sorts fly one at a time from a type case whose lowercase boxes are sized by how often each letter is used into a composing stick, where the line reads left to right with every letter upside down (p shows as b, d as q) and is justified against the knee with em, en, thin and hair spaces, then turns over into the forme, where it reads right to left in mirror image (p as q), is inked and pressed onto a sheet at the foot of the panel, the only place it reads right, before the type flies back to its boxes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hand composition of movable type as Joseph Moxon set it out in Mechanick Exercises on the Whole Art of Printing (1683-84), with a simplified job case after the California job case (lowercase boxes sized by letter frequency, e the largest; capitals in equal boxes, J and U after Z); the pangram Sphinx of black quartz, judge my vow and the epitaph Benjamin Franklin wrote for himself (1728); an 8-row pixel face drawn for this pattern, in which b, d, p and q are one bitmap; pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Spacing=0..1\n//\n// Knob 1: Hue. The ink on the slab, the roller, the inked faces and the print: blue at 0, magenta at 0.25, orange at 0.5, green at 0.75. Metal, wood and paper keep their colours.\n// Knob 2: Speed. At 2 a sort leaves the case about every 0.3 s, and mind your p's and q's goes from case to sheet and back every 11 s, the Sphinx's three lines every 18 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Text. Each with its own measure, and the knee moves to it: 0 mind your p's and q's on 52 LEDs, 1 Sphinx of black quartz, judge my vow. on 60, 2 bob pop bid bud dub on 60, picked because in the stick bob reads pop and pop bob, and in the forme bid, bud and dub read as themselves, 3 The Body of B. Franklin, Printer on 56. Turning it starts the shop over on the new text.\n// Knob 4: Spacing. How a line is filled out to the measure: below 0.25 justified, each 3-em word space topped up with em, en, thin and hair spaces (the opening 0.06); to 0.5 letterspaced, one space between every two letters set as the letters go in and the rest in the word spaces; to 0.75 ragged, quads at the end; above that centred, quads at both ends. The last line is always quadded out. Hair spaces show as brass.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a.map((v, i) => v + (b[i] - v) * t);\nconst hsv = (h, s, v) => [5, 3, 1].map((n) => ((k) => 255 * v * (1 - s * max(0, min(k, 4 - k, 1))))((n + (h - floor(h)) * 6) % 6));\n\n// The face: 8 rows, 2 for ascenders, 4 for the x-height and 2 for\n// descenders; capitals stand on the upper 6. Rows top down, a missing row is\n// blank. b, d, p and q are one bitmap turned and mirrored.\nconst FONT = {\n  a: \",,.###,#..#,#..#,.###\", b: \"#...,#...,###.,#..#,#..#,###.\", c: \",,.##,#..,#..,.##\",\n  d: \"...#,...#,.###,#..#,#..#,.###\", e: \",,.##.,####,#...,.###\", f: \".##,.#.,###,.#.,.#.,.#.\",\n  g: \",,.###,#..#,#..#,.###,...#,.##.\", h: \"#...,#...,###.,#..#,#..#,#..#\", i: \"#,,#,#,#,#\",\n  j: \".#,,.#,.#,.#,.#,.#,#.\", k: \"#..,#..,#.#,##.,#.#,#.#\", l: \"#,#,#,#,#,#\",\n  m: \",,####.,#.#.#,#.#.#,#.#.#\", n: \",,###.,#..#,#..#,#..#\", o: \",,.##.,#..#,#..#,.##.\",\n  p: \",,###.,#..#,#..#,###.,#...,#...\", q: \",,.###,#..#,#..#,.###,...#,...#\", r: \",,#.##,##..,#...,#...\",\n  s: \",,.###,##..,..##,###.\", t: \",.#.,###,.#.,.#.,..#\", u: \",,#..#,#..#,#..#,.##.\",\n  v: \",,#.#,#.#,#.#,.#.\", w: \",,#...#,#.#.#,#.#.#,.#.#.\", x: \",,#..#,.##.,.##.,#..#\",\n  y: \",,#..#,#..#,#..#,.###,...#,.##.\", z: \",,####,..#.,.#..,####\",\n  \"'\": \"#,#\", \",\": \",,,,,#,#\", \".\": \",,,,,#\",\n  B: \"###.,#..#,###.,#..#,#..#,###.\", F: \"###,#..,##.,#..,#..,#..\", P: \"###.,#..#,#..#,###.,#...,#...\",\n  S: \".###,#...,.##.,...#,...#,###.\", T: \"###,.#.,.#.,.#.,.#.,.#.\",\n};\nconst GL = {};\nfor (const ch in FONT) {\n  const rows = FONT[ch].split(\",\"), w = max(...rows.map((r) => r.length)), bits = new Uint8Array(8 * w);\n  rows.forEach((r, y) => [...r].forEach((v, x) => (bits[y * w + x] = v === \"#\")));\n  GL[ch] = { w, bits };\n}\n\n// The body is 10 LEDs, so an em quad is 10 wide; the smaller spaces are its\n// fractions rounded to whole LEDs. A sort is its letter plus one LED of body.\nconst SPW = { em: 10, en: 5, thick: 3, thin: 2, hair: 1 };\nconst QUADS = [\"em\", \"en\", \"thin\", \"hair\"];\nconst LX = 2, BODY = 10, LINES = 3;\nconst STICK = 34, ROLL = 49, FORME = 55, SHEET = 93, PAPER0 = 90;\n\n// Each text with the measure its job is set to, in LEDs.\nconst TEXTS = [\n  [\"mind your p's and q's\", 52],\n  [\"Sphinx of black quartz, judge my vow.\", 60],\n  [\"bob pop bid bud dub\", 60],\n  [\"The Body of B. Franklin, Printer\", 56],\n];\n\n// The case. Lowercase on the left in four bands, each box about as big as\n// its letter is common; capitals on the right in equal boxes. A band gives\n// its rows, keys and inside widths; a divider follows every box.\nconst BANDS = [\n  [1, 4, [\"'\", \",\", \".\", \"k\", \"hair\", \"thin\", \"em\", \"fi\", \"fl\", \"ff\", \"ffi\"], [2, 2, 2, 4, 3, 4, 6, 2, 2, 2, 2]],\n  [6, 12, [\"j\", \"b\", \"c\", \"d\", \"e\", \"i\", \"s\", \"f\", \"g\"], [2, 2, 3, 4, 9, 4, 4, 3, 2]],\n  [14, 20, [\"z\", \"l\", \"m\", \"n\", \"h\", \"o\", \"y\", \"p\", \"w\", \"en\"], [2, 3, 3, 4, 4, 4, 3, 3, 3, 3]],\n  [22, 29, [\"x\", \"q\", \"v\", \"u\", \"t\", \"thick\", \"a\", \"r\"], [2, 2, 3, 3, 6, 6, 6, 6]],\n];\nconst CAPS = [\"1234567\", \"890$&?!\", \"ABCDEFG\", \"HIKLMNO\", \"PQRSTVW\", \"XYZJU;:\"];\nconst CASE_H = 31, CN = W * CASE_H;\n\nconst METAL = [206, 210, 218], WOOD = [150, 96, 48], FLOOR = [16, 10, 7], STEEL = [150, 158, 170], BED = [40, 44, 52];\nconst IRON = [70, 74, 84], FURN = [132, 92, 52], DARK = [18, 18, 22], PAPER = [196, 186, 160];\n// Pieces: body, edge and the shank's three rows; spaces by kind, hair spaces brass.\nconst BODYC = [86, 88, 96], SEAM = [50, 52, 58], SHANK = [[116, 120, 128], [28, 30, 34], [76, 80, 88]];\nconst SPC = { em: [36, 38, 44], en: [36, 38, 44], thick: [54, 56, 62], thin: [54, 56, 62], hair: [176, 132, 52] };\n\nfunction buildCase(S) {\n  const boxes = (S.boxes = []), at = (S.at = {});\n  const add = (key, x0, y0, x1, y1) => {\n    at[key] = boxes.length;\n    boxes.push({ x0, y0, x1, y1, cx: (x0 + x1 - 1) / 2, cy: (y0 + y1) / 2, fill: 0.4 + 0.25 * Math.random(), flash: 0 });\n  };\n  for (const [y0, y1, keys, ws] of BANDS) for (let i = 0, x = 1; i \u003c keys.length; x += ws[i++] + 1) add(keys[i], x, y0, x + ws[i], y1 + 1);\n  CAPS.forEach((row, r) => [...row].forEach((ch, c) => add(/[A-Z]/.test(ch) ? ch : \"c\" + r + c, 43 + 3 * c, 1 + 5 * r, 45 + 3 * c, 5 + 5 * r)));\n  // Each box holds a heap, higher in the middle, so a big box reads as a big mound.\n  S.owner = new Int16Array(CN).fill(-1);\n  S.heap = new Float32Array(CN);\n  boxes.forEach((b, i) => {\n    for (let y = b.y0; y \u003c b.y1; y++)\n      for (let x = b.x0; x \u003c b.x1; x++) {\n        S.owner[y * W + x] = i;\n        S.heap[y * W + x] = cl(1.5 - ((2 * x + 1 - b.x0 - b.x1) / (b.x1 - b.x0 + 1)) ** 2 - ((2 * y + 1 - b.y0 - b.y1) / (b.y1 - b.y0 + 1)) ** 2, 0, 1);\n      }\n  });\n  S.tex = Float32Array.from({ length: CN }, Math.random);\n  S.tone = Float32Array.from({ length: CN }, Math.random);\n}\n\nconst sortOf = (S, ch) => ({ ch, g: GL[ch], w: GL[ch].w + 1, box: S.at[ch] });\nconst spaceOf = (S, k, extra) => ({ sp: k, w: SPW[k], box: S.at[k], extra });\nconst widthOf = (ps) => ps.reduce((s, p) => s + p.w, 0);\nfunction split(n, out, S, extra = true) {\n  for (const k of QUADS) for (; n >= SPW[k]; n -= SPW[k]) out.push(spaceOf(S, k, extra));\n}\n\n// Greedy line breaks with a 3-em word space.\nfunction setText(S) {\n  const [text, M] = TEXTS[S.text];\n  S.M = M;\n  S.P0 = 32 - M / 2;\n  const lines = (S.lines = []);\n  let cur = [], cw = 0;\n  for (const w of text.split(\" \").map((w) => [...w].map((ch) => sortOf(S, ch)))) {\n    if (cur.length && cw + 3 + widthOf(w) > M) [cur, cw] = [(lines.push(cur), []), 0];\n    cw += (cur.length ? 3 : 0) + widthOf(w);\n    cur.push(w);\n  }\n  lines.push(cur);\n}\n\n// The line filled out to the measure by the Spacing knob's method. The last\n// line of a paragraph is never spread; it is quadded out.\nfunction justify(S, line, last) {\n  const mode = last && S.mode \u003c 2 ? 2 : S.mode, gaps = line.length - 1;\n  const slack = S.M - line.reduce((s, w) => s + widthOf(w), 0) - 3 * gaps;\n  const word = new Array(gaps).fill(0), letter = line.map((w) => new Array(w.length).fill(0));\n  let lead = 0, tail = 0;\n  if (mode === 0 && gaps) {\n    // Equal shares; the odd LEDs go first after punctuation, then from the left.\n    const q = floor(slack / gaps), punct = (i) => (/[,.]/.test(line[i].at(-1).ch) ? 1 : 0);\n    let r = slack - q * gaps;\n    word.fill(q);\n    for (const i of [...word.keys()].sort((a, b) => punct(b) - punct(a) || a - b)) if (r > 0) (word[i]++, r--);\n  } else if (mode === 1) {\n    // Letterspacing: the same space between every two letters, set as the\n    // letters are, and what is left in the word spaces.\n    const lg = line.reduce((s, w) => s + w.length - 1, 0), u = lg ? floor(slack / (lg + 2 * gaps)) : 0, r = slack - u * lg;\n    line.forEach((w, wi) => letter[wi].fill(u, 1));\n    for (let i = 0; i \u003c gaps; i++) word[i] = floor(r / gaps) + (i \u003c r % gaps ? 1 : 0);\n    if (!gaps) tail = r;\n  } else if (mode === 3) tail = slack - (lead = floor(slack / 2));\n  else tail = slack;\n  const out = [];\n  split(lead, out, S);\n  line.forEach((w, wi) => {\n    if (wi) {\n      out.push(spaceOf(S, \"thick\", false));\n      split(word[wi - 1], out, S);\n    }\n    w.forEach((p, j) => {\n      split(letter[wi][j], out, S, false);\n      out.push({ ...p });\n    });\n  });\n  split(tail, out, S);\n  return out;\n}\n\n// What a piece shows at column c, row r, the way it prints: 1 body, 2 face,\n// 3 the body's edge, 4 a space, which stands lower than the type.\nfunction cell(p, c, r) {\n  if (p.sp) return 4;\n  if (!c) return 3;\n  return r > 0 && r \u003c 9 && p.g.bits[(r - 1) * p.g.w + c - 1] ? 2 : 1;\n}\n\nfunction layout(ps) {\n  let x = 0;\n  return ps.map((p) => ({ p, x: (x += p.w) - p.w, gone: false }));\n}\n\n// The shop as it opens: the forme full and about to be inked, the last\n// sheet printed, and the first word of the next copy in the stick.\nfunction begin(S) {\n  setText(S);\n  S.just = S.lines.map((l, i) => justify(S, l, i === S.lines.length - 1));\n  S.forme = { lines: S.just.map(layout), phase: \"lock\", t: 0.25, inkY: 0, ink: 0, roll: ROLL };\n  S.sheet = { lines: S.forme.lines, P0: S.P0, x: 0, cut: H, press: -1 };\n  S.fl = [];\n  S.boxes.forEach((b) => (b.flash = 0));\n  newLine(S, 0);\n  const C = S.comp;\n  for (const p of C.ps) {\n    if (p.sp === \"thick\") break;\n    p.on = !p.extra;\n  }\n  targets(C);\n  C.ps.forEach((p) => (p.x = p.tx));\n}\n\nfunction newLine(S, li) {\n  S.comp = { li, ps: S.just[li].map((p) => ({ ...p, on: false, x: LX, tx: LX })), phase: \"set\", t: 0, busy: false };\n}\n\nfunction targets(C) {\n  let x = LX;\n  for (const p of C.ps) x += (p.tx = x, p.on ? p.w : 0);\n}\n\nconst fly = (S, x0, y0, x1, y1, T, col, land, ret) => S.fl.push({ x0, y0, x1, y1, t: 0, T, col, land, ret });\n\n// The compositor: sets the line sort by sort, then the spaces that justify\n// it, waits for the forme and slides the line in.\nfunction stepComp(S, d) {\n  const C = S.comp;\n  C.t -= d;\n  if (C.phase === \"set\" || C.phase === \"just\") {\n    if (C.busy || C.t > 0) return;\n    const p = C.ps.find((q) => !q.on && (C.phase === \"just\" || !q.extra));\n    if (!p) return C.phase === \"set\" ? (C.phase = \"just\") : Object.assign(C, { phase: \"tight\", t: 0.4 });\n    targets(C);\n    const b = S.boxes[p.box];\n    b.flash = 1;\n    b.fill = max(0.2, b.fill - 0.05);\n    C.busy = true;\n    fly(S, b.cx, b.cy, p.tx + p.w / 2, STICK + 4, p.sp ? 0.2 : 0.24, p.sp ? [120, 124, 132] : METAL, () => {\n      p.on = true;\n      targets(C);\n      p.x = p.tx;\n      Object.assign(C, { busy: false, t: 0.05 });\n    });\n  } else if (C.phase === \"tight\") {\n    if (C.t \u003c= 0) C.phase = \"wait\";\n  } else if (C.phase === \"wait\") {\n    if (S.forme.phase === \"fill\" && S.forme.lines.length === C.li) Object.assign(C, { phase: \"move\", t: 0.7, bits: lineBits(C.ps, S.M) });\n  } else if (C.t \u003c= 0) {\n    S.forme.lines.push(layout(C.ps));\n    newLine(S, (C.li + 1) % S.lines.length);\n  }\n}\n\n// A line as print-side codes, M by 10, hair spaces as 5.\nfunction lineBits(list, M) {\n  const bits = new Uint8Array(M * BODY);\n  let x = 0;\n  for (const p of list) {\n    for (let c = 0; c \u003c p.w; c++) for (let r = 0; r \u003c BODY; r++) if (x + c \u003c M) bits[r * M + x + c] = p.sp === \"hair\" ? 5 : cell(p, c, r);\n    x += p.w;\n  }\n  return bits;\n}\n\n// The forme's round, with each step's length at Speed 2.\nconst PH = { lock: 0.35, ink: 1.3, swap: 0.6, press: 0.9, hold: 0.7 };\nconst NEXT = { fill: \"lock\", lock: \"ink\", ink: \"swap\", swap: \"press\", press: \"hold\", hold: \"dist\" };\n\nfunction stepForme(S, d) {\n  const F = S.forme, SH = S.sheet;\n  F.t -= d;\n  const u = 1 - F.t / (PH[F.phase] || 1);\n  if (F.phase === \"ink\") {\n    // The roller runs down over the forme and back to the slab.\n    const bot = FORME + BODY * LINES - 2;\n    F.roll = u \u003c 0.55 ? ROLL + (bot - ROLL) * (u / 0.55) : bot + (ROLL - bot) * ((u - 0.55) / 0.45);\n    F.inkY = max(F.inkY, F.roll + 3);\n    F.ink = 1;\n  } else if (F.phase === \"swap\") {\n    // The last print slides out to the right, a fresh sheet in from the left.\n    SH.x = round(u \u003c 0.5 ? u * 132 : (u - 1) * 132);\n    if (u >= 0.5) SH.lines = null;\n  } else if (F.phase === \"press\") SH.press = SH.cut = PAPER0 - 3 + (H + 3 - PAPER0) * u;\n  else if (F.phase === \"dist\")\n    // Distribution: each piece goes back to its own box.\n    for (; F.t \u003c= 0; F.t += 0.045) {\n      let q = null, k = 0;\n      for (; k \u003c F.lines.length && !q; k++) q = F.lines[k].find((e) => !e.gone);\n      if (!q) {\n        if (!S.fl.some((f) => f.ret)) Object.assign(F, { lines: [], inkY: 0, ink: 0, phase: \"fill\", t: 0 });\n        break;\n      }\n      q.gone = true;\n      const b = S.boxes[q.p.box];\n      const back = () => {\n        b.flash = 0.7;\n        b.fill = min(0.95, b.fill + 0.05);\n      };\n      fly(S, 63 - S.P0 - q.x - q.p.w / 2, FORME + BODY * (k - 1) + 4, b.cx, b.cy, 0.32, q.p.sp ? [90, 94, 100] : mix(METAL, S.ink, 0.6), back, true);\n    }\n  if (F.phase === \"fill\" ? F.lines.length >= S.lines.length : F.phase !== \"dist\" && F.t \u003c= 0) {\n    if (F.phase === \"ink\") F.roll = ROLL;\n    if (F.phase === \"swap\") Object.assign(SH, { x: 0, lines: F.lines, P0: S.P0, cut: PAPER0 - 3 });\n    if (F.phase === \"press\") {\n      Object.assign(SH, { cut: H, press: -1 });\n      F.ink = 0.55;\n    }\n    F.phase = NEXT[F.phase];\n    F.t = PH[F.phase] || 0;\n  }\n}\n\nfunction put(F, x, y, c, a = 1) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  F[o] += (c[0] - F[o]) * a;\n  F[o + 1] += (c[1] - F[o + 1]) * a;\n  F[o + 2] += (c[2] - F[o + 2]) * a;\n}\n\nexport function setup(params) {\n  const S = (params.s = { text: -1, mode: -1, F: new Float32Array(N * 3), base: new Float32Array(N * 3) });\n  buildCase(S);\n  const B = S.base, g = (c, k) => c.map((v) => v * k);\n  // Case wood with a grain, the stick, the chase full of furniture.\n  for (let i = 0; i \u003c CN; i++) put(B, i % W, floor(i / W), S.owner[i] >= 0 ? FLOOR : g(WOOD, 0.8 + 0.25 * S.tone[i - (i % W) + (((i % W) * 7) % W)]));\n  for (let x = 0; x \u003c W; x++) {\n    put(B, x, STICK - 1, STEEL);\n    put(B, x, STICK + BODY + 3, g(STEEL, 0.85));\n    for (let y = STICK; y \u003c STICK + BODY + 3; y++) put(B, x, y, x \u003c LX ? STEEL : BED);\n  }\n  const top = FORME - 2, bot = FORME + BODY * LINES + 1;\n  for (let y = top; y \u003c= bot; y++)\n    for (let x = 0; x \u003c W; x++) put(B, x, y, y === top || y === bot || !x || x === W - 1 ? IRON : g(FURN, 0.75 + 0.2 * (((x * 5 + y * 11) % 7) / 7)));\n  S.paper = new Float32Array(W * (H - PAPER0));\n  for (let i = 0; i \u003c S.paper.length; i++) S.paper[i] = 1 - 0.12 * (floor(i / W) / (H - PAPER0)) - 0.05 * (abs((i % W) - 31.5) / 31.5);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0] || 0, 0, 1);\n  S.sp = cl(k[1] ?? 2, 0.2, 3) / 2;\n  S.ink = hsv(0.6 + S.hue, 0.85, 1);\n  const text = round(cl(k[2] || 0, 0, 3)), mode = min(3, floor(cl(k[3] ?? 0.06, 0, 1) * 4));\n  if (text !== S.text || mode !== S.mode) {\n    Object.assign(S, { text, mode });\n    begin(S);\n  }\n  const d = dt * S.sp;\n  for (const f of S.fl) if ((f.t += d) >= f.T && !f.done) (f.done = true), f.land();\n  S.fl = S.fl.filter((f) => !f.done);\n  stepComp(S, d);\n  stepForme(S, d);\n  for (const p of S.comp.ps) if (p.on) p.x += (p.tx - p.x) * min(1, d * 14);\n  for (const b of S.boxes) b.flash = max(0, b.flash - dt * 3);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.comp) return;\n  const F = S.F, ink = S.ink, FL = S.forme, SH = S.sheet, C = S.comp, M = S.M, P0 = S.P0;\n  F.set(S.base);\n  const colOf = (p, code, face) => (code === 2 ? face : code === 1 ? BODYC : code === 3 ? SEAM : SPC[p.sp]);\n\n  // The case: each box a heap of sorts as full as it is, lit when touched.\n  for (let i = 0; i \u003c CN; i++) {\n    const b = S.boxes[S.owner[i]];\n    if (!b) continue;\n    const h = S.heap[i], v = (40 + 90 * S.tone[i]) * (0.55 + 0.45 * h);\n    if (S.tex[i] \u003c b.fill * h) F.set([v, v * 1.02, v * 1.1], i * 3);\n    if (b.flash > 0) put(F, i % W, floor(i / W), [255, 226, 150], b.flash * 0.7);\n  }\n\n  // The knee, set to the measure, lights when the line is tight.\n  for (let y = STICK - 1; y \u003c STICK + BODY + 4; y++) for (let x = LX + M; x \u003c LX + M + 2; x++) put(F, x, y, C.phase === \"tight\" ? [240, 240, 228] : STEEL);\n  // Sorts in the stick, seen from the compositor's side: the line reads left\n  // to right and every face is upside down, the mirror of the print turned\n  // round. Below each face its shank, nick up, the nicks in one line.\n  if (C.phase !== \"move\")\n    for (const p of C.ps) {\n      if (!p.on) continue;\n      for (let c = 0, x = round(p.x); c \u003c p.w; c++, x++) {\n        if (x \u003c LX || x >= LX + M) continue;\n        for (let r = 0; r \u003c BODY; r++) put(F, x, STICK + r, colOf(p, cell(p, c, BODY - 1 - r), METAL));\n        for (let j = 0; j \u003c 3; j++) put(F, x, STICK + BODY + j, p.sp ? SPC[p.sp] : c ? SHANK[j] : SEAM, p.sp ? 1 - 0.1 * j : 1);\n      }\n    }\n\n  // The ink slab, and the roller resting on it or running over the forme.\n  for (let y = ROLL - 1; y \u003c ROLL + 4; y++) for (let x = 0; x \u003c W; x++) put(F, x, y, mix([0, 0, 0], ink, 0.42 + 0.1 * ((x * 3 + y * 5) % 4)));\n  const ry = round(FL.roll);\n  for (let x = 0; x \u003c W; x++) for (let j = 0; j \u003c 3; j++) put(F, x, ry + j, x \u003c 2 || x > 61 ? STEEL : mix([0, 0, 0], ink, 0.95 - 0.25 * j));\n  if (FL.phase === \"ink\") for (let x = 0; x \u003c W; x++) put(F, x, ry - 1, IRON);\n\n  // The forme: the lines seen from the face, mirrored and reading right to\n  // left, inked where the roller has passed. Slots past the text stay\n  // furniture; quoins at the foot open when it is locked.\n  const face = mix(METAL, ink, FL.ink);\n  for (let k = 0; k \u003c S.lines.length; k++) {\n    for (let y = FORME + BODY * k; y \u003c FORME + BODY * (k + 1); y++) for (let x = P0; x \u003c P0 + M; x++) put(F, x, y, DARK);\n    for (const q of FL.lines[k] || [])\n      if (!q.gone)\n        for (let c = 0; c \u003c q.p.w; c++)\n          for (let r = 0, y = FORME + BODY * k; r \u003c BODY; r++, y++) put(F, 63 - (P0 + q.x + c), y, colOf(q.p, cell(q.p, c, r), y \u003c FL.inkY ? face : METAL));\n  }\n  const locked = FL.phase !== \"fill\" && FL.phase !== \"dist\";\n  for (const qx of [18, 40]) for (let i = 0; i \u003c (locked ? 6 : 4); i++) put(F, qx + i, FORME + BODY * LINES, locked ? [200, 204, 210] : [110, 114, 120]);\n\n  // The line on its way from stick to forme turns over: upside down to the\n  // right way up, then mirrored, so for an instant it reads as it will print.\n  if (C.phase === \"move\") {\n    const s = cl(1 - C.t / 0.7, 0, 1), sy = cos(PI * cl(2 * s, 0, 1)), sx = cos(PI * cl(2 * s - 1, 0, 1));\n    const cx = LX + M / 2 + (32 - LX - M / 2) * s, cy = STICK + 5 + (FORME + BODY * C.li - STICK) * s;\n    const hw = (M / 2) * abs(sx), hh = (BODY / 2) * abs(sy), lit = 0.6 + 0.4 * abs(sx * sy);\n    const pal = [null, BODYC, METAL, SEAM, SPC.thick, SPC.hair].map((c) => c && c.map((v) => v * lit));\n    for (let y = floor(cy - hh); y \u003c cy + hh; y++)\n      for (let x = floor(cx - hw); x \u003c cx + hw; x++) {\n        const u = floor((x + 0.5 - cx) / (sx || 1e-3) + M / 2), v = floor((y + 0.5 - cy) / (sy || 1e-3) + BODY / 2);\n        const code = u >= 0 && u \u003c M && v >= 0 && v \u003c BODY ? C.bits[(BODY - 1 - v) * M + u] : 0;\n        if (code) put(F, x, y, pal[code]);\n      }\n  }\n\n  // The sheet, sliding in fresh before each impression; it takes the print\n  // as the cylinder passes, and only here does the line read right.\n  const tone = mix(PAPER, hsv(0.6 + S.hue, 0.95, 0.8), 0.94);\n  for (let i = 0; i \u003c S.paper.length; i++) {\n    const x = i % W, X = x + SH.x, g = S.paper[i], o = (PAPER0 * W + i - x + X) * 3;\n    if (!x || x === W - 1 || X \u003c 0 || X >= W) continue;\n    F[o] = PAPER[0] * g;\n    F[o + 1] = PAPER[1] * g;\n    F[o + 2] = PAPER[2] * g;\n  }\n  if (SH.lines)\n    SH.lines.forEach((line, k) => {\n      for (const q of line)\n        for (let c = 1; c \u003c q.p.w && !q.p.sp; c++)\n          for (let r = 1, y = SHEET + BODY * k + 1; r \u003c 9; r++, y++) if (y \u003c SH.cut && cell(q.p, c, r) === 2) put(F, SH.P0 + q.x + c + SH.x, y, tone);\n    });\n  if (SH.press >= 0) for (let x = 0; x \u003c W; x++) for (let j = 0; j \u003c 3; j++) put(F, x, round(SH.press) + j, [210 - 40 * j, 216 - 40 * j, 224 - 40 * j]);\n\n  // Sorts in flight, with a short trail.\n  for (const f of S.fl) {\n    const u = cl(f.t / f.T, 0, 1), e = u * u * (3 - 2 * u);\n    for (const [back, a] of [[0.08, 0.35], [0, 1]]) {\n      const ue = max(0, e - back);\n      const x = round(f.x0 + (f.x1 - f.x0) * ue), y = round(f.y0 + (f.y1 - f.y0) * ue - 6 * sin(PI * ue));\n      for (let j = 0; j \u003c 4; j++) put(F, x + (j & 1), y + (j >> 1), f.col, j > 1 ? a * 0.8 : a);\n    }\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, F[o], F[o + 1], F[o + 2]);\n}\n","delaunay-flips":"// ===== Patternflow pattern =====\n// Title:   Delaunay Flips\n// Family:  cells\n// Idea:    Points inside a rounded hull start in a bad triangulation, a fan from one corner or a sweep, and Lawson's flips take the worst illegal edge, draw the circle that has a fourth point inside it and swap the edge for the other diagonal, a dozen a second, until no triangle's circle holds a point, every triangle filled by its smallest angle from magenta slivers to teal near-equilateral ones; then the points drift and the flips keep coming.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lawson flips (Charles L. Lawson, 1977) toward the Delaunay triangulation (Boris Delaunay, 1934), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Circles=0..1\n//\n// Knob 1: Hue. Turns the colours round a wheel that skips red, orange and yellow. At 0 slivers, illegal edges and circles with a point inside are magenta, near-equilateral triangles, legal edges and empty circles teal, and the triangles between go violet and blue; at 0.25 slivers are green and good triangles blue, at 0.5 cyan and magenta, at 0.75 blue and green.\n// Knob 2: Speed. Flips 6 times Speed a second for 43 points and in proportion for more: at 2 the opening fan of 43 points needs 76 flips and is Delaunay 6.4 s after it is drawn; at 0.2 one flip every 0.83 s, each circle in plain view. In the drift that follows the points move 1.4 times Speed LEDs a second, less as they crowd, so 113 points move 0.62 of that.\n// Knob 3: Points. 30 to 90 points scattered inside, plus 13 to 23 fixed on the hull, so 43 points and 71 triangles at 30 and 113 points and 201 triangles at 90. Each whole step scatters a new set; the opening fan of 113 points took 324 flips, Delaunay 10.3 s after it was drawn at Speed 2.\n// Knob 4: Circles. Up to 0.08 only the circle under test and the fading circles of the last flips. Above it a growing share of all the triangles' circumcircles, all of them at 1: magenta while some point lies inside, teal when empty, so the bad start is a tangle of magenta circles and lines and the end is teal.\n// Buttons: K1 tap scatters a new set in the next bad triangulation.\n\n// Delaunay (1934): a triangulation of a point set where no point lies inside\n// any triangle's circumcircle. Lawson (1977): an edge shared by triangles\n// abc and dcb is illegal when d lies inside abc's circle, which is when the\n// angles at a and d add up past pi. Swapping it for ad raises the smallest\n// of the six angles, and flipping illegal edges in any order ends at the\n// Delaunay triangulation. The hull points never move, so the hull stays\n// convex and its edges are never flipped.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sg = (v) => (v \u003c 0 ? -1 : 1);\nconst frac = (v) => v - floor(v);\n// A colour wheel that skips red, orange and yellow (hue 0.98 round to 0.27),\n// which go maroon, brown and olive at the dim levels of the fills.\nconst wheel = (p) => 0.27 + 0.71 * p;\n\n// The hull: a superellipse |x/a|^3 + |y/b|^3 = 1 round the panel's middle,\n// of area AREA. Interior points keep 5 LEDs inside it.\nconst CX = 31.5, CY = 63.5, HA = 30.6, HB = 62.6, SP = 3, AREA = 6769;\nconst NMAX = 90 + 32, TMAX = 2 * NMAX;\nconst BUILD = 0.9, PROOF = 1.6, DRIFT = 10, ICEPS = 1e-6;\nconst inner = (x, y) => abs((x - CX) / (HA - 5)) ** SP + abs((y - CY) / (HB - 5)) ** SP \u003c 1;\n\nfunction hsv(h, s, v, out) {\n  h = frac(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Predicates. Every stored triangle has orient > 0. ----\nconst orient = (P, a, b, c) =>\n  (P[2 * b] - P[2 * a]) * (P[2 * c + 1] - P[2 * a + 1]) - (P[2 * b + 1] - P[2 * a + 1]) * (P[2 * c] - P[2 * a]);\n// > 0 when d lies inside the circle through a, b, c (orient(a, b, c) > 0).\nfunction incircle(P, a, b, c, d) {\n  const dx = P[2 * d], dy = P[2 * d + 1];\n  const ax = P[2 * a] - dx, ay = P[2 * a + 1] - dy, bx = P[2 * b] - dx, by = P[2 * b + 1] - dy;\n  const cx = P[2 * c] - dx, cy = P[2 * c + 1] - dy;\n  const a2 = ax * ax + ay * ay, b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  return ax * (by * c2 - b2 * cy) - ay * (bx * c2 - b2 * cx) + a2 * (bx * cy - by * cx);\n}\n// The angle at a in the triangle a, b, c.\nfunction angle(P, a, b, c) {\n  const ux = P[2 * b] - P[2 * a], uy = P[2 * b + 1] - P[2 * a + 1], vx = P[2 * c] - P[2 * a], vy = P[2 * c + 1] - P[2 * a + 1];\n  return atan2(abs(ux * vy - uy * vx), ux * vx + uy * vy);\n}\n// The circle through a, b, c: centre x, centre y, radius.\nfunction circum(P, a, b, c, out) {\n  const ax = P[2 * a], ay = P[2 * a + 1];\n  const bx = P[2 * b] - ax, by = P[2 * b + 1] - ay, cx = P[2 * c] - ax, cy = P[2 * c + 1] - ay;\n  const d = 2 * (bx * cy - by * cx), b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n  const ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d;\n  out[0] = ax + ux;\n  out[1] = ay + uy;\n  out[2] = sqrt(ux * ux + uy * uy);\n}\n\n// ---- A new point set: the hull points first, in order round it. ----\nfunction scatter(S) {\n  const P = S.P, n = S.n, nh = (S.nh = 8 + round(n / 6));\n  // Hull points evenly by arc length.\n  const M = 720, xs = [], ys = [], L = [0];\n  for (let i = 0; i \u003c= M; i++) {\n    const th = (i / M) * 2 * PI, c = cos(th), s = sin(th);\n    xs.push(CX + HA * sg(c) * abs(c) ** (2 / SP));\n    ys.push(CY + HB * sg(s) * abs(s) ** (2 / SP));\n    if (i) L.push(L[i - 1] + sqrt((xs[i] - xs[i - 1]) ** 2 + (ys[i] - ys[i - 1]) ** 2));\n  }\n  const off = Math.random();\n  for (let k = 0, j = 0; k \u003c nh; k++) {\n    const at = ((k + off) / nh) * L[M];\n    while (j \u003c M - 1 && L[j + 1] \u003c at) j++;\n    const f = (at - L[j]) / (L[j + 1] - L[j]);\n    P[2 * k] = xs[j] + (xs[j + 1] - xs[j]) * f;\n    P[2 * k + 1] = ys[j] + (ys[j + 1] - ys[j]) * f;\n  }\n  // Interior points by dart throwing, no two closer than dmin.\n  let dmin = (S.dmin = 0.72 * sqrt(AREA / (n + nh))), np = nh, tries = 0;\n  while (np \u003c nh + n) {\n    const x = 1 + Math.random() * 62, y = 1 + Math.random() * 126;\n    if (++tries > 3000) (dmin *= 0.9), (tries = 0);\n    if (!inner(x, y)) continue;\n    let ok = true;\n    for (let j = 0; j \u003c np && ok; j++) ok = (P[2 * j] - x) ** 2 + (P[2 * j + 1] - y) ** 2 >= dmin * dmin;\n    if (!ok) continue;\n    P[2 * np] = x;\n    P[2 * np + 1] = y;\n    S.th[np++] = Math.random() * 2 * PI;\n  }\n  S.np = np;\n}\n\n// ---- Bad triangulations, as flat lists of triangles. ----\n// A fan from hull point pv: the others by angle round it, a wedge between\n// each two neighbours, then a Graham scan along the fan's rim closes the\n// pockets between the rim and the hull.\nfunction fan(S, pv) {\n  const P = S.P, ids = [], tris = [];\n  const d2 = (i) => (P[2 * i] - P[2 * pv]) ** 2 + (P[2 * i + 1] - P[2 * pv + 1]) ** 2;\n  for (let i = 0; i \u003c S.np; i++) if (i !== pv) ids.push(i);\n  ids.sort((p, q) => -orient(P, pv, p, q) || d2(p) - d2(q));\n  for (let k = 0; k + 1 \u003c ids.length; k++) tris.push(pv, ids[k], ids[k + 1]);\n  const st = [ids[0], ids[1]];\n  for (let k = 2; k \u003c ids.length; k++) {\n    const q = ids[k];\n    for (let m = st.length; m >= 2 && orient(P, st[m - 2], st[m - 1], q) \u003c 0; m--) tris.push(st[m - 2], q, st.pop());\n    st.push(q);\n  }\n  return tris;\n}\n// A sweep: the points by distance from (qx, qy). Each new one lies outside\n// the hull of those before it and is joined to every hull edge it sees.\nfunction sweep(S, qx, qy) {\n  const P = S.P, ids = [];\n  const d2 = (i) => (P[2 * i] - qx) ** 2 + (P[2 * i + 1] - qy) ** 2;\n  for (let i = 0; i \u003c S.np; i++) ids.push(i);\n  ids.sort((p, q) => d2(p) - d2(q));\n  let hull = orient(P, ids[0], ids[1], ids[2]) > 0 ? ids.slice(0, 3) : [ids[0], ids[2], ids[1]];\n  const tris = hull.slice();\n  for (let k = 3; k \u003c ids.length; k++) {\n    const q = ids[k], m = hull.length, vis = hull.map((h, j) => orient(P, h, hull[(j + 1) % m], q) \u003c 0);\n    let s = 0, c = 0;\n    while (s \u003c m && !(vis[s] && !vis[(s + m - 1) % m])) s++;\n    if (s === m) continue;\n    for (; c \u003c m && vis[(s + c) % m]; c++) tris.push(hull[(s + c + 1) % m], hull[(s + c) % m], q);\n    const next = [hull[s], q];\n    for (let j = (s + c) % m; j !== s; j = (j + 1) % m) next.push(hull[j]);\n    hull = next;\n  }\n  return tris;\n}\n\n// Store the triangles and find each one's neighbours. Nb[3t + i] is the\n// triangle across t's side opposite its vertex i, or -1 on the hull.\nfunction link(S, tris) {\n  const V = S.V, Nb = S.Nb, T = (S.T = tris.length / 3), seen = new Map();\n  for (let i = 0; i \u003c tris.length; i++) V[i] = tris[i];\n  Nb.fill(-1);\n  for (let e = 0; e \u003c 3 * T; e++) {\n    const t = (e / 3) | 0, b = V[3 * t + ((e + 1) % 3)], c = V[3 * t + ((e + 2) % 3)];\n    const key = min(b, c) * 1024 + max(b, c), o = seen.get(key);\n    if (o === undefined) seen.set(key, e);\n    else (Nb[e] = (o / 3) | 0), (Nb[o] = t);\n  }\n}\n\n// Fans from the corners top left and bottom right take turns with sweeps\n// from the middle and from far above (which goes row by row).\nfunction restart(S) {\n  scatter(S);\n  const P = S.P, kind = S.cycle % 4;\n  if (kind % 2) link(S, kind === 1 ? sweep(S, CX, CY) : sweep(S, CX, -4000));\n  else {\n    const s = kind ? 1 : -1;\n    let pv = 0;\n    for (let i = 1; i \u003c S.nh; i++) if (s * ((P[2 * i] - P[2 * pv]) / HA + (P[2 * i + 1] - P[2 * pv + 1]) / HB) > 0) pv = i;\n    link(S, fan(S, pv));\n  }\n  Object.assign(S, { phase: 0, pt: 0, prog: 0, cand: -1, built: 0, flips: 0 });\n  S.rec.length = 0;\n}\n\n// ---- Edges and flips. Edge e = 3t + i is t's side opposite vertex i. ----\n// Into q: a (t's vertex i), b, c (the shared side), d across it, u, and\n// d's place j in u.\nfunction quad(S, e, q) {\n  const V = S.V, t = (e / 3) | 0, i = e % 3, u = S.Nb[e];\n  if (u \u003c 0) return false;\n  let j = 0;\n  while (S.Nb[3 * u + j] !== t) j++;\n  q[0] = V[e];\n  q[1] = V[3 * t + ((i + 1) % 3)];\n  q[2] = V[3 * t + ((i + 2) % 3)];\n  q[3] = V[3 * u + j];\n  q[4] = u;\n  q[5] = j;\n  return true;\n}\nfunction illegal(S, e) {\n  const q = S.q, P = S.P;\n  if (!quad(S, e, q)) return false;\n  const [a, b, c, d] = q;\n  return incircle(P, a, b, c, d) > ICEPS && orient(P, a, b, d) > 0 && orient(P, d, c, a) > 0;\n}\n// The illegal edge whose two opposite angles add up to the most.\nfunction pick(S) {\n  const P = S.P, q = S.q;\n  let best = -1, score = PI;\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    if (S.Nb[e] \u003c ((e / 3) | 0) || !illegal(S, e)) continue;\n    const s = angle(P, q[0], q[1], q[2]) + angle(P, q[3], q[2], q[1]);\n    if (s > score) (score = s), (best = e);\n  }\n  return best;\n}\n// t = a b c and u = d c b become t = a b d and u = d c a.\nfunction flip(S, e) {\n  const V = S.V, Nb = S.Nb, q = S.q;\n  quad(S, e, q);\n  const [a, b, c, d, u, j] = q, t = (e / 3) | 0, i = e % 3;\n  const nca = Nb[3 * t + ((i + 1) % 3)], nab = Nb[3 * t + ((i + 2) % 3)];\n  const nbd = Nb[3 * u + ((j + 1) % 3)], ndc = Nb[3 * u + ((j + 2) % 3)];\n  circum(S.P, a, b, c, S.cc);\n  S.rec.push({ a, d, b, c, t, u, at: S.t, cx: S.cc[0], cy: S.cc[1], r: S.cc[2] });\n  if (S.rec.length > 24) S.rec.shift();\n  V.set([a, b, d], 3 * t);\n  Nb.set([nbd, u, nab], 3 * t);\n  V.set([d, c, a], 3 * u);\n  Nb.set([nca, t, ndc], 3 * u);\n  for (let k = 0; k \u003c 3; k++) {\n    if (nbd >= 0 && Nb[3 * nbd + k] === u) Nb[3 * nbd + k] = t;\n    if (nca >= 0 && Nb[3 * nca + k] === t) Nb[3 * nca + k] = u;\n  }\n  S.flips++;\n}\n\n// ---- Drift: the interior points wander and push off close neighbours; a\n// step that would fold a triangle over is taken back. ----\nfunction drift(S, d) {\n  const P = S.P, Q = S.Q, V = S.V, v0 = 1.4 * S.speed * sqrt(43 / S.np), nh = S.nh, dm = S.dmin * 0.8;\n  Q.set(P);\n  for (let i = nh; i \u003c S.np; i++) {\n    const x = P[2 * i], y = P[2 * i + 1];\n    let th = S.th[i] + (Math.random() - 0.5) * 5 * sqrt(d);\n    if (!inner(x, y)) th = atan2(CY - y, CX - x) + Math.random() - 0.5;\n    S.th[i] = th;\n    Q[2 * i] += cos(th) * v0 * d;\n    Q[2 * i + 1] += sin(th) * v0 * d;\n  }\n  for (let e = 0; e \u003c 3 * S.T; e++) {\n    const t = (e / 3) | 0;\n    if (S.Nb[e] \u003c= t) continue;\n    const a = V[3 * t + ((e + 1) % 3)], b = V[3 * t + ((e + 2) % 3)];\n    const ex = P[2 * b] - P[2 * a], ey = P[2 * b + 1] - P[2 * a + 1], l = sqrt(ex * ex + ey * ey);\n    if (l >= dm || l \u003c 1e-6) continue;\n    const f = ((dm - l) / l) * 0.6 * d * S.speed;\n    if (a >= nh) (Q[2 * a] -= ex * f), (Q[2 * a + 1] -= ey * f);\n    if (b >= nh) (Q[2 * b] += ex * f), (Q[2 * b + 1] += ey * f);\n  }\n  for (let pass = 0, bad = true; bad; pass++) {\n    bad = false;\n    if (pass === 6) Q.set(P);\n    else\n      for (let t = 0; t \u003c S.T; t++) {\n        if (orient(Q, V[3 * t], V[3 * t + 1], V[3 * t + 2]) > 0.4) continue;\n        for (let k = 3 * t; k \u003c 3 * t + 3; k++) (Q[2 * V[k]] = P[2 * V[k]]), (Q[2 * V[k] + 1] = P[2 * V[k] + 1]);\n        bad = true;\n      }\n  }\n  P.set(Q);\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, circ: 0.06, n: 0, nh: 0, np: 0, cycle: 0, dmin: 8, btn: false,\n    P: new Float64Array(2 * NMAX), Q: new Float64Array(2 * NMAX), th: new Float64Array(NMAX),\n    V: new Int32Array(3 * TMAX), Nb: new Int32Array(3 * TMAX), T: 0,\n    phase: 0, pt: 0, prog: 0, cand: -1, built: 0, flips: 0, rec: [], q: [0, 0, 0, 0, 0, 0],\n    acc: new Float32Array(W * H * 3), fl: new Float32Array(TMAX), c: [0, 0, 0], cc: [0, 0, 0],\n  };\n  return params.s;\n}\n\n// Phases: 0 the bad triangulation drawn in, 1 flipping, 2 every circle\n// shown empty, 3 drifting with flips, then a new set.\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 30, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  S.circ = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 30, 90)), btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn && S.n) S.cycle++, restart(S);\n  S.btn = btn;\n  if (n !== S.n) (S.n = n), restart(S);\n  S.t += d;\n  S.pt += d;\n  if (S.phase === 0) {\n    S.built = min(S.T, floor((S.T * S.pt) / BUILD));\n    if (S.pt >= BUILD) (S.phase = 1), (S.pt = 0), (S.built = S.T);\n    return;\n  }\n  if (S.phase === 2) {\n    if (S.pt >= PROOF) (S.phase = 3), (S.pt = 0);\n    return;\n  }\n  if (S.phase === 3) {\n    if (S.pt >= DRIFT) return S.cycle++, restart(S);\n    drift(S, d);\n  }\n  if (S.cand >= 0 && !illegal(S, S.cand)) S.cand = -1;\n  if (S.cand \u003c 0) (S.cand = pick(S)), (S.prog = 0);\n  if (S.cand >= 0) S.prog += (6 * S.speed * S.np * d) / 43;\n  for (; S.prog >= 1 && S.cand >= 0; S.prog--) flip(S, S.cand), (S.cand = pick(S));\n  if (S.cand \u003c 0) {\n    S.prog = 0;\n    if (S.phase === 1) (S.phase = 2), (S.pt = 0);\n  }\n}\n\n// ---- Drawing into acc, a float RGB buffer. ----\nfunction put(acc, x, y, c, w, sum) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || w \u003c= 0) return;\n  const k = (y * W + x) * 3;\n  for (let i = 0; i \u003c 3; i++) acc[k + i] = sum ? acc[k + i] + c[i] * w : max(acc[k + i], c[i] * w);\n}\n// A line covering two LEDs across it, in proportion (Wu's way).\nfunction line(acc, x0, y0, x1, y1, c, w) {\n  const st = abs(x1 - x0) \u003c abs(y1 - y0);\n  if (st) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const s = x1 > x0 ? (y1 - y0) / (x1 - x0) : 0;\n  for (let x = max(0, ceil(x0)); x \u003c= min(st ? H - 1 : W - 1, floor(x1)); x++) {\n    const y = y0 + (x - x0) * s, iy = floor(y), f = y - iy;\n    if (st) put(acc, iy, x, c, w * (1 - f)), put(acc, iy + 1, x, c, w * f);\n    else put(acc, x, iy, c, w * (1 - f)), put(acc, x, iy + 1, c, w * f);\n  }\n}\n// A circle: by rows where it runs steep, by columns where it runs flat.\nfunction ring(acc, cx, cy, r, c, w) {\n  if (!(r > 0.5 && r \u003c 1e5)) return;\n  const h = r * 0.7072;\n  for (let y = max(0, ceil(cy - h)); y \u003c= min(H - 1, floor(cy + h)); y++) {\n    const dx = sqrt(max(0, r * r - (y - cy) ** 2));\n    for (const x of [cx - dx, cx + dx]) {\n      const ix = floor(x), f = x - ix;\n      put(acc, ix, y, c, w * (1 - f), 1), put(acc, ix + 1, y, c, w * f, 1);\n    }\n  }\n  for (let x = max(0, ceil(cx - h)); x \u003c= min(W - 1, floor(cx + h)); x++) {\n    const dy = sqrt(max(0, r * r - (x - cx) ** 2));\n    for (const y of [cy - dy, cy + dy]) {\n      const iy = floor(y), f = y - iy;\n      put(acc, x, iy, c, w * (1 - f), 1), put(acc, x, iy + 1, c, w * f, 1);\n    }\n  }\n}\n// Triangle t filled by rows through the LED centres.\nfunction fill(S, t, c) {\n  const P = S.P, V = S.V, acc = S.acc, xs = [], ys = [];\n  for (let k = 0; k \u003c 3; k++) xs.push(P[2 * V[3 * t + k]]), ys.push(P[2 * V[3 * t + k] + 1]);\n  for (let y = max(0, ceil(min(...ys))); y \u003c= min(H - 1, floor(max(...ys))); y++) {\n    let lo = W, hi = -1;\n    for (let e = 0; e \u003c 3; e++) {\n      const ya = ys[e], yb = ys[(e + 1) % 3];\n      if ((ya - y) * (yb - y) > 0 || ya === yb) continue;\n      const x = xs[e] + ((y - ya) * (xs[(e + 1) % 3] - xs[e])) / (yb - ya);\n      (lo = min(lo, x)), (hi = max(hi, x));\n    }\n    for (let x = max(0, ceil(lo)); x \u003c= min(W - 1, floor(hi)); x++) acc.set(c, (y * W + x) * 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const P = S.P, V = S.V, Nb = S.Nb, acc = S.acc, c = S.c, cc = S.cc, q = S.q, fl = S.fl;\n  const pw = frac(0.831 + S.hue), pc = frac(0.324 + S.hue), hw = wheel(pw), hc = wheel(pc);\n  const built = S.phase === 0 ? S.built : S.T;\n  acc.fill(0);\n  // The two triangles a flip has just made light up for a moment.\n  fl.fill(0);\n  for (const r of S.rec) fl[r.t] = fl[r.u] = max(fl[r.t], exp(-(S.t - r.at) / 0.3));\n  // Each triangle by its smallest angle m: below 10 degrees bright in the\n  // sliver colour, from 50 degrees dim in the near-equilateral one.\n  for (let t = 0; t \u003c built; t++) {\n    const a = V[3 * t], b = V[3 * t + 1], d = V[3 * t + 2];\n    const m = min(angle(P, a, b, d), angle(P, b, d, a), angle(P, d, a, b)), u = cl(m / 0.87, 0, 1);\n    hsv(wheel(pw + (pc - pw) * u), 0.8, 0.2 + 0.36 * (1 - u) * (1 - u), c);\n    for (let i = 0; i \u003c 3; i++) c[i] += fl[t] * 0.35;\n    fill(S, t, c);\n  }\n  // Edges: legal ones pale, illegal ones in the sliver colour, the hull dim.\n  for (let e = 0; e \u003c 3 * built; e++) {\n    const t = (e / 3) | 0, u = Nb[e];\n    if (u >= 0 && u \u003c t) continue;\n    const a = V[3 * t + ((e + 1) % 3)], b = V[3 * t + ((e + 2) % 3)];\n    if (u \u003c 0) hsv(hc, 0.4, 0.4, c);\n    else if (illegal(S, e)) hsv(hw, 0.55, 0.85, c);\n    else hsv(hc, 0.2, 0.32, c);\n    line(acc, P[2 * a], P[2 * a + 1], P[2 * b], P[2 * b + 1], c, 1);\n  }\n  // The circumcircles the Circles knob asks for.\n  const show = (S.circ - 0.08) / 0.92, dim = min(1, sqrt(71 / S.T));\n  for (let t = 0; t \u003c S.T && show > 0 && S.phase; t++) {\n    const w = dim * cl((show - frac(t * 0.618034 + 0.13)) / 0.04, 0, 1);\n    if (w \u003c= 0) continue;\n    const a = V[3 * t], b = V[3 * t + 1], d = V[3 * t + 2];\n    let hit = false;\n    for (let p = 0; p \u003c S.np && !hit; p++) hit = p !== a && p !== b && p !== d && incircle(P, a, b, d, p) > ICEPS;\n    circum(P, a, b, d, cc);\n    hsv(hit ? hw : hc, hit ? 0.5 : 0.45, hit ? 0.36 : 0.3, c);\n    ring(acc, cc[0], cc[1], cc[2], c, w);\n  }\n  // The Delaunay moment: every circle at once, every one of them empty.\n  if (S.phase === 2) {\n    hsv(hc, 0.4, 0.45 * sin((PI * S.pt) / PROOF) ** 2, c);\n    for (let t = 0; t \u003c S.T; t++) {\n      circum(P, V[3 * t], V[3 * t + 1], V[3 * t + 2], cc);\n      ring(acc, cc[0], cc[1], cc[2], c, 1);\n    }\n  }\n  // Flips just made: the old edge and its circle fade, the new edge flashes.\n  for (const r of S.rec) {\n    const age = S.t - r.at;\n    if (age > 1.5) continue;\n    hsv(hw, 0.5, 1, c);\n    line(acc, P[2 * r.b], P[2 * r.b + 1], P[2 * r.c], P[2 * r.c + 1], c, exp(-age / 0.25));\n    ring(acc, r.cx, r.cy, r.r, c, 0.45 * exp(-age / 0.3));\n    line(acc, P[2 * r.a], P[2 * r.a + 1], P[2 * r.d], P[2 * r.d + 1], [1, 1, 1], exp(-age / 0.45));\n  }\n  // The edge under test, its circle brightening toward the flip, and the\n  // point inside that circle.\n  if (S.cand >= 0 && quad(S, S.cand, q)) {\n    const g = 0.45 + 0.55 * S.prog;\n    circum(P, q[0], q[1], q[2], cc);\n    hsv(hw, 0.3, 1, c);\n    ring(acc, cc[0], cc[1], cc[2], c, g);\n    line(acc, P[2 * q[1]], P[2 * q[1] + 1], P[2 * q[2]], P[2 * q[2] + 1], c, 1);\n    ring(acc, P[2 * q[3]], P[2 * q[3] + 1], 2.2, c, 0.6 * g);\n  }\n  // The points, white inside and tinted on the hull.\n  for (let i = 0; i \u003c S.np; i++) {\n    const x = P[2 * i], y = P[2 * i + 1], ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    if (i \u003c S.nh) hsv(hc, 0.35, 0.8, c);\n    else c[0] = c[1] = c[2] = 1;\n    put(acc, ix, iy, c, min(1, 1.6 * (1 - fx) * (1 - fy)));\n    put(acc, ix + 1, iy, c, min(1, 1.6 * fx * (1 - fy)));\n    put(acc, ix, iy + 1, c, min(1, 1.6 * (1 - fx) * fy));\n    put(acc, ix + 1, iy + 1, c, min(1, 1.6 * fx * fy));\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[k])) | 0, (255 * min(1, acc[k + 1])) | 0, (255 * min(1, acc[k + 2])) | 0);\n    }\n}\n","fibonacci-word":"// ===== Patternflow pattern =====\n// Title:   Fibonacci Word\n// Family:  fractal\n// Idea:    A pen reads the Fibonacci word 0100101001001... and takes one step for every digit, turning a quarter turn at every 0, left in an even place and right in an odd one, so 144 crisp steps of 4 LEDs draw a self-avoiding curve of squares nested in squares over the coarse curve of the first 34 digits, which lies in a faint band 5 LEDs wide, each coarse step giving way to the 5 or 3 fine steps that 0 -> 01001 and 1 -> 010 make of it; the three copies of those 34 digits inside the 144 then light in turn, and the panel dives into the first with a quarter turn and a 1 + sqrt 2 zoom until it stands where the whole stood, mirrored, and the pen draws the whole over it again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Fibonacci word fractal and its odd-even drawing rule (Alexis Monnerot-Dumaine, 2009), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=12..15, Angle=-1..1\n//\n// Knob 1: Hue. Turns the colour that runs half the wheel along the word, first digit to last: at 0 sea green through blue and violet to rose, at 0.25 blue through magenta and orange to yellow, at 0.5 rose through amber and lime to sea green, at 0.75 yellow through green and cyan to blue. The coarse curve and the tape of digits on the right edge take the same colours.\n// Knob 2: Speed. The pen draws 70 LEDs of line a second for every unit, 140 at the opening 2, so the 144 steps of order 12 take 4.1 s and a whole cycle of drawing, the 1.8 s look at the three copies and the 2.2 s dive takes 8.1 s; at 0.2 the drawing alone takes 41 s, at 3 it takes 2.7 s and the look and the dive shorten by a fifth.\n// Knob 3: Order. How many digits the pen reads, the Fibonacci number F(n): 12 for 144 steps of 4 LEDs (48 by 112 LEDs), 13 for 233 steps of 2 LEDs in a square 56 by 58, 14 for 377 steps of 2 LEDs (56 by 82), 15 for 610 steps of 2 LEDs, 58 by 138, so 6 rows at the top and 5 at the bottom run off the panel. The coarse curve under the pen is always order n - 3, and the order keeps its shape every three: 12 and 15 are long, 13 square, 14 one and a half times as long as wide.\n// Knob 4: Angle. The turn at each 0. From -0.1 to 0.1 it is exactly 90 degrees and the line stays on the LED grid; it goes down to 60 degrees at -1, where the squares open into a wiggling line that still never touches itself, and up to 120 degrees at 1, where the curve folds over itself into a lattice of triangles and 36 of the 144 steps retrace an earlier one. Off 90 degrees the line is antialiased and the whole is turned and scaled to fit the panel.\n\n// The rule. The Fibonacci word is the limit of S(0) = 0, S(1) = 01,\n// S(n) = S(n-1) S(n-2); its k-th digit, k from 1, is 2 + floor(k phi) -\n// floor((k + 1) phi). Read it from k = 1: step forward, and on a 0 turn\n// left when k is even and right when k is odd. Counting k from 0 instead\n// gives the mirror image. At 90 degrees the first F(n) digits draw the\n// curve of order n; a scratch walk to 28,657 steps found no point visited\n// twice and no two points one lattice step apart unless they are\n// consecutive, which is why even a 1-LED step would stay a clean line.\n// Of the F(n) steps, F(n-1) turn and F(n-2) go straight.\n//\n// Self-similarity. The word is fixed by 0 -> 01, 1 -> 0, so three orders\n// up each digit becomes a block, 0 -> 01001 and 1 -> 010, and the curve of\n// order n is the curve of order n - 3 with every step replaced by its block.\n// It follows the coarse curve mirrored and 1 + sqrt 2 = 2.414 times larger:\n// a least-squares fit of the block ends to the coarse corners is a mirror\n// map of scale 2.420 at 2,584 -> 10,946 steps. Length grows by phi^3 =\n// 4.236 for that, so the dimension of the limit is 3 log phi /\n// log(1 + sqrt 2) = 1.6379. With a turn angle a the\n// fitted ratio follows 1 + cos a + sqrt((1 + cos a)^2 + 1): 3.30 at 60\n// degrees, 1.64 against 1.618 at 120, where 3 log phi / log of it would be\n// 3, more than a plane curve can hold, and the curve overlaps itself.\n//\n// Also S(n) = S(n-3) S(n-4) S(n-3) S(n-3) S(n-4): the first F(n-3) digits\n// come back at F(n-2) and F(n-1), mirrored where that offset is odd. Those\n// are the three copies the panel lights before the dive.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sign, sin, cos, pow, atan2, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The word to 987 digits, and the Fibonacci numbers with F(1) = F(2) = 1.\nconst WORD = (() => {\n  let a = [0], b = [0, 1];\n  while (b.length \u003c 987) [a, b] = [b, b.concat(a)];\n  return b;\n})();\nconst FIB = [0, 1];\nwhile (FIB.length \u003c 20) FIB.push(FIB[FIB.length - 1] + FIB[FIB.length - 2]);\n// Coarse step j becomes fine steps BLK[j] .. BLK[j + 1] - 1 three orders up.\nconst BLK = new Int32Array(WORD.length + 1);\nfor (let j = 0; j \u003c WORD.length; j++) BLK[j + 1] = BLK[j] + (WORD[j] ? 3 : 5);\n\n// The walk in world coordinates. At exactly 90 degrees the turns are done\n// on integers so the points land exactly on the LED grid.\nfunction walk(N, deg, P) {\n  if (deg === 90) {\n    const DX = [1, 0, -1, 0], DY = [0, 1, 0, -1];\n    let x = 0, y = 0, d = 0;\n    P[0] = 0, P[1] = 0;\n    for (let i = 0; i \u003c N; i++) {\n      x += DX[d], y += DY[d];\n      P[2 * i + 2] = x, P[2 * i + 3] = y;\n      if (WORD[i] === 0) d = (d + ((i + 1) % 2 === 0 ? 1 : 3)) % 4;\n    }\n    return;\n  }\n  const th = (deg * PI) / 180;\n  let x = 0, y = 0, a = 0;\n  P[0] = 0, P[1] = 0;\n  for (let i = 0; i \u003c N; i++) {\n    x += cos(a), y += sin(a);\n    P[2 * i + 2] = x, P[2 * i + 3] = y;\n    if (WORD[i] === 0) a += (i + 1) % 2 === 0 ? th : -th;\n  }\n}\n\n// A camera is screen = a * w' + b in complex numbers, w' the world point\n// with y times mir. On the grid a is s or i s with s whole and b whole; off\n// it, the rotation that lets the curve stand largest, kept unless another\n// beats it by 3%.\nfunction camera(P, N, mir, grid, keep) {\n  const tryRot = (c, s) => {\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (let i = 0; i \u003c= N; i++) {\n      const x = P[2 * i], y = mir * P[2 * i + 1], X = c * x - s * y, Y = s * x + c * y;\n      if (X \u003c x0) x0 = X;\n      if (X > x1) x1 = X;\n      if (Y \u003c y0) y0 = Y;\n      if (Y > y1) y1 = Y;\n    }\n    return [x0, x1 - x0, y0, y1 - y0];\n  };\n  if (grid) {\n    let [x0, bw, y0, bh] = tryRot(1, 0), c = 1, s = 0;\n    if (bw > bh) ([x0, bw, y0, bh] = tryRot(0, 1)), (c = 0), (s = 1);\n    // 138.5 rows lets order 15 take 2 LEDs a step and run 5 rows off each end.\n    const k = max(1, floor(min(60 / max(1, bw), 138.5 / max(1, bh))));\n    return { ar: k * c, ai: k * s, br: floor((60 - k * bw) / 2) - k * x0, bi: floor((127 - k * bh) / 2) - k * y0, mir, psi: s ? 90 : 0 };\n  }\n  let best = null;\n  for (let d = 0; d \u003c 180; d += 3) {\n    const r = (d * PI) / 180, c = cos(r), s = sin(r), [x0, bw, y0, bh] = tryRot(c, s);\n    const k = min(58 / max(1e-6, bw), 125 / max(1e-6, bh));\n    const cand = { k, c, s, x0, bw, y0, bh, psi: d };\n    if (!best || k > best.k) best = cand;\n    if (keep === d) keep = cand;\n  }\n  if (keep && typeof keep === \"object\" && keep.k >= best.k * 0.97) best = keep;\n  const { k, c, s, x0, bw, y0, bh, psi } = best;\n  return { ar: k * c, ai: k * s, br: 1 + (58 - k * bw) / 2 - k * x0, bi: (127 - k * bh) / 2 - k * y0, mir, psi };\n}\n\nfunction project(P, N, cam, X, Y) {\n  for (let i = 0; i \u003c= N; i++) {\n    const x = P[2 * i], y = cam.mir * P[2 * i + 1];\n    X[i] = cam.ar * x - cam.ai * y + cam.br;\n    Y[i] = cam.ai * x + cam.ar * y + cam.bi;\n  }\n}\n\n// Least-squares similarity z -> alpha z + beta (or alpha conj z + beta)\n// taking the points (ax, ay) onto (bx, by). Returns [ar, ai, br, bi, err].\n// With snap the turn of alpha is rounded to a quarter, so a curve on the\n// grid stays on it.\nfunction simFit(n, ax, ay, bx, by, conj, snap) {\n  let mx = 0, my = 0, nx = 0, ny = 0;\n  for (let j = 0; j \u003c n; j++) mx += ax(j), my += (conj ? -1 : 1) * ay(j), nx += bx(j), ny += by(j);\n  mx /= n, my /= n, nx /= n, ny /= n;\n  let sr = 0, si = 0, ss = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const u = ax(j) - mx, v = (conj ? -1 : 1) * ay(j) - my, p = bx(j) - nx, q = by(j) - ny;\n    sr += u * p + v * q, si += u * q - v * p, ss += u * u + v * v;\n  }\n  let ar = sr / max(1e-9, ss), ai = si / max(1e-9, ss);\n  if (snap) {\n    const r = hypot(ar, ai), q = (((round(atan2(ai, ar) / (PI / 2)) % 4) + 4) % 4);\n    (ar = r * [1, 0, -1, 0][q]), (ai = r * [0, 1, 0, -1][q]);\n  }\n  const br = nx - (ar * mx - ai * my), bi = ny - (ai * mx + ar * my);\n  let err = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const u = ax(j), v = (conj ? -1 : 1) * ay(j);\n    err += hypot(ar * u - ai * v + br - bx(j), ai * u + ar * v + bi - by(j));\n  }\n  return [ar, ai, br, bi, err];\n}\n\n// Everything the panel needs for one order, angle and mirror: the fine\n// curve on screen and the coarse curve of order n - 3 placed by the\n// similarity that best lays its corners on the ends of their blocks.\nfunction geometry(n, deg, mir, keepPsi) {\n  const N = FIB[n], Nc = FIB[n - 3], grid = deg === 90;\n  const P = new Float64Array(2 * N + 2);\n  walk(N, deg, P);\n  const cam = camera(P, N, mir, grid, keepPsi);\n  const X = new Float64Array(N + 1), Y = new Float64Array(N + 1);\n  project(P, N, cam, X, Y);\n  const fits = [false, true].map((cj) =>\n    simFit(Nc + 1, (j) => P[2 * j], (j) => P[2 * j + 1], (j) => X[BLK[j]], (j) => Y[BLK[j]], cj, grid));\n  const f = fits[0][4] \u003c fits[1][4] ? fits[0] : fits[1], cj = f === fits[1];\n  const GX = new Float64Array(Nc + 1), GY = new Float64Array(Nc + 1);\n  for (let j = 0; j \u003c= Nc; j++) {\n    const u = P[2 * j], v = (cj ? -1 : 1) * P[2 * j + 1];\n    GX[j] = f[0] * u - f[1] * v + f[2];\n    GY[j] = f[1] * u + f[0] * v + f[3];\n  }\n  // The band round the coarse curve: 2 LEDs each side when its steps are\n  // near 10 LEDs long, 1 when they are near 5.\n  const hw = cl(round(0.22 * hypot(GX[1] - GX[0], GY[1] - GY[0])), 1, 2);\n  return { n, N, Nc, deg, mir, grid, cam, X, Y, GX, GY, hw, step: hypot(cam.ar, cam.ai) };\n}\n\n// How bright the coarse curve waits under the pen, and its band. The band\n// stays above 40 of 255, so its rim is a hard edge and not a glow.\nconst GHOST = 0.72, BANDV = 0.19;\n\nconst angleOf = (k) => {\n  const a = abs(k);\n  return a \u003c= 0.1 ? 90 : 90 + (k > 0 ? 30 : -30) * min(1, (a - 0.1) / 0.9);\n};\n\nfunction startDraw(S, ghost) {\n  S.phase = 0, S.pen = 0, S.pt = 0, S.gl = ghost;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, phase: 0, pen: 0, pt: 0, gl: GHOST, zt: 0, c: [0, 0, 0],\n    acc: new Float32Array(W * H * 3), band: new Float32Array(W * H), bandU: new Float32Array(W * H),\n  });\n  S.g = geometry(12, 90, 1, -1);\n  startDraw(S, GHOST);\n}\n\n// The dive: the screen similarity that takes the coarse prefix as drawn now\n// onto where the next (mirrored) picture's coarse curve stands. A power of\n// it, about its fixed point, is the zoom.\nfunction startZoom(S) {\n  const g = S.g, nx = geometry(g.n, g.deg, -g.mir, g.cam.psi);\n  const f = simFit(g.Nc + 1, (j) => g.X[j], (j) => g.Y[j], (j) => nx.GX[j], (j) => nx.GY[j], false);\n  const [ar, ai, br, bi] = f, dr = 1 - ar, di = -ai, dd = dr * dr + di * di;\n  S.z = { next: nx, r: hypot(ar, ai), phi: atan2(ai, ar), cx: (br * dr + bi * di) / max(1e-9, dd), cy: (bi * dr - br * di) / max(1e-9, dd) };\n  S.phase = 2, S.zt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 12, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const n = cl(round(k[2]), 12, 15), deg = angleOf(cl(k[3], -1, 1));\n  const f = 0.55 + 0.225 * S.speed, g0 = S.g;\n  if (n !== g0.n) {\n    S.g = geometry(n, deg, g0.mir, -1);\n    startDraw(S, GHOST);\n  } else if (abs(deg - g0.deg) > 0.05 || (deg === 90) !== g0.grid) {\n    S.g = geometry(n, deg, g0.mir, g0.cam.psi);\n    if (S.phase === 2) startDraw(S, GHOST);\n  }\n  const g = S.g;\n  if (S.phase === 0) {\n    S.pen += (70 * S.speed * d) / max(0.05, g.step);\n    S.gl += (GHOST - S.gl) * min(1, d * 2.5);\n    if (S.pen >= g.N) (S.pen = g.N), (S.phase = 1), (S.pt = 0);\n  } else if (S.phase === 1) {\n    S.pt += (d * f) / 1.8;\n    if (S.pt >= 1) startZoom(S);\n  } else {\n    S.zt += (d * f) / 2.2;\n    if (S.zt >= 1) {\n      S.g = S.z.next;\n      startDraw(S, 1);\n    }\n  }\n}\n\n// Additive light, one LED per unit of line.\nfunction splat(acc, x, y, w, r, g, b) {\n  const i = floor(x), j = floor(y), fx = x - i, fy = y - j;\n  for (let q = 0; q \u003c 4; q++) {\n    const ii = i + (q & 1), jj = j + (q >> 1);\n    if (ii \u003c 0 || ii >= W || jj \u003c 0 || jj >= H) continue;\n    const ww = w * (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy), o = (jj * W + ii) * 3;\n    acc[o] += r * ww, acc[o + 1] += g * ww, acc[o + 2] += b * ww;\n  }\n}\nfunction lineAA(acc, x0, y0, x1, y1, r, g, b, upto) {\n  if ((x0 \u003c -2 && x1 \u003c -2) || (x0 > W + 1 && x1 > W + 1) || (y0 \u003c -2 && y1 \u003c -2) || (y0 > H + 1 && y1 > H + 1)) return;\n  const L = hypot(x1 - x0, y1 - y0), m = max(1, ceil((L * upto) / 0.45)), w = (L * upto) / m;\n  for (let u = 0; u \u003c m; u++) {\n    const t = ((u + 0.5) / m) * upto;\n    splat(acc, x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, w, r, g, b);\n  }\n}\n// On the grid: the LEDs from (x0, y0) toward (x1, y1), the far end left to\n// the next step, cut at the share upto.\nfunction lineGrid(acc, x0, y0, x1, y1, r, g, b, upto) {\n  const L = abs(x1 - x0) + abs(y1 - y0), sx = sign(x1 - x0), sy = sign(y1 - y0), m = upto >= 1 ? L : floor(L * upto + 1e-9) + 1;\n  for (let u = 0; u \u003c m; u++) {\n    const x = x0 + sx * u, y = y0 + sy * u;\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3;\n    acc[o] += r, acc[o + 1] += g, acc[o + 2] += b;\n  }\n}\n\n// Every LED within hw of a segment joins the band at level v, the highest\n// level keeping its colour u, so crossings do not add up.\nfunction bandSeg(S, x0, y0, x1, y1, hw, v, u) {\n  if (v \u003c= 0.01) return;\n  const B = S.band, U = S.bandU, r = hw + 0.45, dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy;\n  const xa = max(0, floor(min(x0, x1) - r)), xb = min(W - 1, ceil(max(x0, x1) + r));\n  const ya = max(0, floor(min(y0, y1) - r)), yb = min(H - 1, ceil(max(y0, y1) + r));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const t = L2 > 0 ? cl(((x - x0) * dx + (y - y0) * dy) / L2, 0, 1) : 0, ex = x0 + dx * t - x, ey = y0 + dy * t - y;\n      if (ex * ex + ey * ey \u003c= r * r) {\n        const p = y * W + x;\n        if (v > B[p]) (B[p] = v), (U[p] = u);\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.g) return;\n  const acc = S.acc, c = S.c, h0 = 0.42 + S.hue;\n  acc.fill(0);\n  S.band.fill(0);\n  const g = S.g, N = g.N, Nc = g.Nc;\n  const col = (u, v, white) => {\n    hsv(h0 + 0.5 * u, 0.78 * (1 - white), v, c);\n    return c;\n  };\n  if (S.phase === 2) {\n    // The dive: every point of the curve under the similarity's power.\n    const z = S.z, e = smooth(S.zt), rr = pow(z.r, e), ph = z.phi * e, er = rr * cos(ph), ei = rr * sin(ph);\n    const out = 1 - smooth(S.zt / 0.6), zx = (x, y) => z.cx + er * (x - z.cx) - ei * (y - z.cy), zy = (x, y) => z.cy + ei * (x - z.cx) + er * (y - z.cy);\n    // The old band rides the dive out; a new one grows round the first copy,\n    // which is the next picture's coarse curve.\n    const vo = BANDV * (1 - smooth(e / 0.35)), vn = BANDV * smooth(e / 0.5);\n    for (let j = 0; j \u003c Nc; j++) {\n      const ax = g.GX[j], ay = g.GY[j], bx = g.GX[j + 1], by = g.GY[j + 1];\n      bandSeg(S, zx(ax, ay), zy(ax, ay), zx(bx, by), zy(bx, by), g.hw, vo, (BLK[j] + BLK[j + 1]) / (2 * N));\n      const cx = g.X[j], cy = g.Y[j], dx = g.X[j + 1], dy = g.Y[j + 1];\n      bandSeg(S, zx(cx, cy), zy(cx, cy), zx(dx, dy), zy(dx, dy), z.next.hw * e, vn, (BLK[j] + BLK[j + 1]) / (2 * N));\n    }\n    let px = 0, py = 0;\n    for (let i = 0; i \u003c= N; i++) {\n      const dx = g.X[i] - z.cx, dy = g.Y[i] - z.cy, x = z.cx + er * dx - ei * dy, y = z.cy + ei * dx + er * dy;\n      if (i > 0) {\n        const j = i - 1, pre = j \u003c Nc;\n        const u = pre ? ((j + 0.5) / N) * (1 - e) + ((BLK[j] + BLK[j + 1]) / (2 * N)) * e : (j + 0.5) / N;\n        const v = pre ? 1 : 0.45 * out;\n        if (v > 0.01) {\n          const w = pre ? 0.55 * (1 - e) : 0;\n          col(u, v, w);\n          lineAA(acc, px, py, x, y, c[0], c[1], c[2], 1);\n        }\n      }\n      px = x, py = y;\n    }\n  } else {\n    // The coarse curve, each step fading as the pen finishes its block, and\n    // its band, which stays.\n    const rate = max(0.5, 70 / max(0.05, g.step)), rd = g.grid ? round : (v) => v;\n    for (let j = 0; j \u003c Nc; j++) bandSeg(S, rd(g.GX[j]), rd(g.GY[j]), rd(g.GX[j + 1]), rd(g.GY[j + 1]), g.hw, BANDV, (BLK[j] + BLK[j + 1]) / (2 * N));\n    for (let j = 0; j \u003c Nc; j++) {\n      const gone = (S.pen - BLK[j + 1]) / (0.3 * rate) + (S.phase === 1 ? 8 * S.pt : 0), a = S.gl * (1 - cl(gone, 0, 1));\n      if (a \u003c= 0.01) continue;\n      col((BLK[j] + BLK[j + 1]) / (2 * N), a, 0.15);\n      if (g.grid) lineGrid(acc, round(g.GX[j]), round(g.GY[j]), round(g.GX[j + 1]), round(g.GY[j + 1]), c[0], c[1], c[2], 1);\n      else lineAA(acc, g.GX[j], g.GY[j], g.GX[j + 1], g.GY[j + 1], c[0], c[1], c[2], 1);\n    }\n    // The fine curve up to the pen. In the look (phase 1) the three copies\n    // of the first F(n-3) digits light in turn and the rest dims.\n    const offs = [0, FIB[g.n - 2], FIB[g.n - 1]];\n    let spot = [0, 0, 0], dim = 1;\n    if (S.phase === 1) {\n      const p = S.pt;\n      spot = [0.33, 0.52, 0.71].map((m0) => max(0, 1 - abs(p - m0) / 0.11));\n      spot[0] = max(spot[0], smooth((p - 0.8) / 0.15));\n      dim = 1 - 0.55 * smooth((p - 0.1) / 0.12);\n    }\n    const last = S.phase === 0 ? floor(S.pen) : N - 1, frac = S.phase === 0 ? S.pen - last : 1;\n    for (let i = 0; i \u003c= min(last, N - 1); i++) {\n      let s = 0;\n      for (let q = 0; q \u003c 3; q++) if (i >= offs[q] && i \u003c offs[q] + Nc) s = max(s, spot[q]);\n      const v = dim + (1 - dim) * s;\n      col((i + 0.5) / N, v, 0.6 * s);\n      const up = i \u003c last ? 1 : frac;\n      if (up \u003c= 0) continue;\n      if (g.grid) lineGrid(acc, g.X[i], g.Y[i], g.X[i + 1], g.Y[i + 1], c[0], c[1], c[2], up);\n      else lineAA(acc, g.X[i], g.Y[i], g.X[i + 1], g.Y[i + 1], c[0], c[1], c[2], up);\n    }\n    if (S.phase !== 0) {\n      col(1, dim, 0);\n      if (g.grid) lineGrid(acc, g.X[N], g.Y[N], g.X[N], g.Y[N], c[0], c[1], c[2], 1);\n    } else {\n      // The pen: a white point with a glow of the colour it is laying down.\n      const i = min(last, N - 1), x = g.X[i] + (g.X[i + 1] - g.X[i]) * frac, y = g.Y[i] + (g.Y[i + 1] - g.Y[i]) * frac;\n      col((i + 0.5) / N, 1, 0.3);\n      const px = g.grid ? round(x) : x, py = g.grid ? round(y) : y;\n      splat(acc, px, py, 1.6, 1, 1, 1);\n      for (const [ox, oy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) splat(acc, px + ox, py + oy, 0.45, c[0], c[1], c[2]);\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    if (S.band[p] \u003c= 0) continue;\n    col(S.bandU[p], S.band[p], 0);\n    acc[3 * p] += c[0], acc[3 * p + 1] += c[1], acc[3 * p + 2] += c[2];\n  }\n  // The tape: the word itself down the right edge, two rows a digit, the\n  // digit being read on row 64. A 0 is two LEDs wide, a 1 one. Read digits\n  // are lit in their colour, the rest wait dim; in the dive it rewinds.\n  const tape = S.phase === 0 ? S.pen : S.phase === 1 ? N : N * (1 - smooth(S.zt));\n  for (let y = 0; y \u003c H; y++) {\n    const q = tape + (y - 64) / 2, k = floor(q);\n    if (k \u003c 0 || k >= N || q - k >= 0.5) continue;\n    const now = k === floor(tape) && S.phase === 0;\n    col((k + 0.5) / N, k \u003c tape ? 1 : 0.32, now ? 1 : 0.1);\n    for (let x = WORD[k] ? 63 : 62; x \u003c 64; x++) {\n      const o = (y * W + x) * 3;\n      acc[o] += c[0], acc[o + 1] += c[1], acc[o + 2] += c[2];\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, acc[o])) | 0, (255 * min(1, acc[o + 1])) | 0, (255 * min(1, acc[o + 2])) | 0);\n    }\n}\n","huffman-tree":"// ===== Patternflow pattern =====\n// Title:   Huffman Tree\n// Family:  type\n// Idea:    The symbols of a short text stand along the foot of the panel on dotted stems as tall as the logarithm of their counts, the two lightest nodes merge again and again into a parent that rises above them until one root stands at the top, every merge writing a 0 into the codes of the leaves under its left branch and a 1 under its right so the codes grow up the columns over the labels, and then the text streams down the tree into a bit string that comes out shorter than the fixed-length code under it.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: minimum-redundancy codes (David A. Huffman, 1952); coding the opening words of Charles Dickens's A Tale of Two Cities (1859), the perfect pangram Mr Jock, TV quiz PhD, bags few lynx, the first 100 digits of pi, and the first two lines of Yun Dong-ju's Seosi (1941) split into jamo; the 3 by 5 capitals of the Typewriter pattern (round 18), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Tie=0..2\n//\n// Knob 1: Hue. Turns the colours round the wheel: at 0 a 0 bit is azure, a 1 bit amber and the fixed-length strip rose; at 0.5 a 0 is red-orange, a 1 blue and the fixed strip green. Stems and labels keep a pale tint of the 0 colour.\n// Knob 2: Speed. At 2 the lightest merge takes 0.22 s and the root 0.48 s, so Dickens's 12 merges stand in 4.1 s, its 50 symbols stream in 7 s and the whole run with 3 s of totals and a 1 s fade lasts 15.7 s; at 0.2 it all takes ten times as long, at 3 two thirds as long.\n// Knob 3: Text. 0 Dickens, 13 symbols over 50 places, 169 bits against 200 at 4 bits a symbol; 1 the pangram, 27 symbols over 33 places, 148 against 165 at 5 bits, its 26 letters a level comb of 5 and 6 bit codes beside the space's 00; 2 the first 100 digits of pi, 332 against 400 at the 4 bits of binary-coded decimal, six digits taking 3 bits and four taking 4; 3 Seosi in jamo, 16 symbols over 58 places, 223 against 232.\n// Knob 4: Tie. Which of two equal weights merges first: 0 the older (leaves before merged nodes, earlier symbols first), 1 the newer, 2 a coin drawn anew each time the tree is rebuilt. The tree changes shape and the total never does: Dickens takes 169 bits under every rule while its longest code is 5 bits at 0 and 6 at 1, and the pangram's four 6-bit letters are M R J O at 0 and E W L Y at 1.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, exp, log2, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The 3 by 5 face, rows top to bottom, one bit per column: Typewriter's\n// capitals, the figures, and a space drawn as an open box.\nconst G3 = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\",\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001011001111\",\n  4: \"101101111001001\", 5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001010010010\",\n  8: \"111101111101111\", 9: \"111101111001111\",\n  \" \": \"000000000101111\", \"+\": \"000010111010000\", \"=\": \"000111000111000\", \"\u003c\": \"001010100010001\",\n};\n// Jamo drawn 5 by 5 for the Korean line, and its space.\nconst G5 = {\n  \"ㄱ\": \"1111100001000010000100001\", \"ㄲ\": \"1101101001010010100101001\", \"ㄴ\": \"1000010000100001000011111\",\n  \"ㄹ\": \"1111100001111111000011111\", \"ㅁ\": \"1111110001100011000111111\", \"ㅂ\": \"1000110001111111000111111\",\n  \"ㅅ\": \"0010000100010100101010001\", \"ㅇ\": \"0111010001100011000101110\", \"ㅈ\": \"1111100100001000101010001\",\n  \"ㅎ\": \"0010011111011101000101110\", \"ㅏ\": \"0100001000011100100001000\", \"ㅓ\": \"0001000010011100001000010\",\n  \"ㅜ\": \"0000011111001000010000100\", \"ㅡ\": \"0000000000111110000000000\", \"ㅣ\": \"0010000100001000010000100\",\n  \" \": \"0000000000000001000111111\",\n};\n\nconst TEXTS = [\n  // A Tale of Two Cities (1859), its first words, letters and spaces only.\n  \"IT WAS THE BEST OF TIMES IT WAS THE WORST OF TIMES\",\n  // A perfect pangram: every letter once, so 26 weights of 1 and the spaces.\n  \"MR JOCK TV QUIZ PHD BAGS FEW LYNX\",\n  // The first 100 digits of pi, 3 and 99 decimals.\n  \"3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067\",\n  // Yun Dong-ju, Seosi (1941): 죽는 날까지 하늘을 우러러 / 한 점 부끄럼이 없기를,\n  // split into the keys of the two-set keyboard (없 is ㅇ ㅓ ㅂ ㅅ, ㄲ one key).\n  \"ㅈㅜㄱㄴㅡㄴ ㄴㅏㄹㄲㅏㅈㅣ ㅎㅏㄴㅡㄹㅇㅡㄹ ㅇㅜㄹㅓㄹㅓ ㅎㅏㄴ ㅈㅓㅁ ㅂㅜㄲㅡㄹㅓㅁㅇㅣ ㅇㅓㅂㅅㄱㅣㄹㅡㄹ\",\n];\n\n// Rows. The text line, the Huffman strip and the fixed strip at the top, the\n// root under them; labels at the foot with the code band above them.\nconst LINE_Y = 1, HS_Y = 8, FS_Y = 16, STRIP_R = 7, ROOT_Y = 28;\n// Times in seconds at Speed 2.\nconst T0 = 0.3, TM = 0.32, PAUSE = 0.6, STREAM = 7, HOLD = 3, FADE = 1;\n\n// Huffman's construction. Symbols are counted in order of first appearance\n// and become leaves 0..k-1; each merge takes the two lightest nodes, the\n// first taken goes left (bit 0), and the parent joins the pool. Ties go by\n// the rule: 0 the older node first, 1 the newer, 2 a random key.\nfunction huffman(text, rule) {\n  const idx = new Map(), sym = [], seq = [];\n  for (const ch of text) {\n    if (!idx.has(ch)) idx.set(ch, sym.length), sym.push({ ch, w: 0 });\n    const i = idx.get(ch);\n    sym[i].w++;\n    seq.push(i);\n  }\n  const nodes = sym.map((s, i) => ({ w: s.w, leaf: i, a: -1, b: -1, up: -1, bit: 0, r: Math.random(), m: -1 }));\n  const pool = nodes.map((_, i) => i), merges = [];\n  const first = (i, j) => {\n    const p = nodes[i], q = nodes[j];\n    if (p.w !== q.w) return p.w \u003c q.w;\n    return rule === 0 ? i \u003c j : rule === 1 ? i > j : p.r \u003c q.r;\n  };\n  const take = () => {\n    let bi = 0;\n    for (let i = 1; i \u003c pool.length; i++) if (first(pool[i], pool[bi])) bi = i;\n    return pool.splice(bi, 1)[0];\n  };\n  while (pool.length > 1) {\n    const a = take(), b = take(), id = nodes.length;\n    nodes.push({ w: nodes[a].w + nodes[b].w, leaf: -1, a, b, up: -1, bit: 0, r: Math.random(), m: merges.length });\n    nodes[a].up = id, nodes[b].up = id, nodes[b].bit = 1;\n    merges.push(id);\n    pool.push(id);\n  }\n  const root = pool[0];\n  // Codes, read from the root: 0 for the left branch, 1 for the right.\n  const codes = sym.map((_, i) => {\n    let s = \"\";\n    for (let n = i; nodes[n].up >= 0; n = nodes[n].up) s = nodes[n].bit + s;\n    return s;\n  });\n  let total = 0, sigma = 0;\n  for (const i of seq) total += codes[i].length;\n  for (const id of merges) sigma += nodes[id].w;\n  return { sym, seq, nodes, merges, root, codes, total, sigma, maxLen: max(...codes.map((c) => c.length)) };\n}\n\nfunction prepare(S) {\n  const text = TEXTS[S.text], T = huffman(text, S.rule), k = T.sym.length, N = T.seq.length;\n  const big = S.text === 3, gw = big ? 5 : 3, m = (gw - 1) / 2;\n  // In-order leaves: the tree draws without crossings.\n  const order = [];\n  const walk = (n) => {\n    const q = T.nodes[n];\n    if (q.leaf >= 0) order.push(n);\n    else walk(q.a), walk(q.b);\n  };\n  walk(T.root);\n  const pitch = (W - 2 * m) / k, stagger = pitch \u003c gw + 1;\n  const band = max(T.maxLen, huffman(text, 0).maxLen, huffman(text, 1).maxLen);\n  const labelY = stagger ? 116 : 122, codeBottom = labelY - 2, Y0 = codeBottom - 2 * band + 1 - 3;\n  order.forEach((n, pos) => {\n    const q = T.nodes[n];\n    q.x = round(m + (pos + 0.5) * pitch - 0.5);\n    q.ly = stagger && pos % 2 === 0 ? 122 : labelY;\n  });\n  // Heights: a node of weight w stands log2(w) levels above the baseline,\n  // so the drop from the root to a leaf is log2(N / w), the leaf's ideal\n  // length in bits. Parents keep 2 rows above their children and never\n  // below an earlier merge, so the tree grows upwards in merge order.\n  let L = (Y0 - ROOT_Y) / log2(N);\n  for (let tries = 0; tries \u003c 40; tries++) {\n    for (const q of T.nodes) if (q.leaf >= 0) q.y = Y0 - round(log2(q.w) * L);\n    let prev = Y0;\n    for (const id of T.merges) {\n      const q = T.nodes[id], A = T.nodes[q.a], B = T.nodes[q.b];\n      q.x = (A.x + B.x) >> 1;\n      q.y = min(Y0 - round(log2(q.w) * L), A.y - 2, B.y - 2, prev);\n      prev = q.y;\n    }\n    if (T.nodes[T.root].y >= ROOT_Y) break;\n    L *= 0.97;\n  }\n  // Each leaf's ancestors from the leaf up, and where its bits go in the\n  // Huffman strip for every place in the text.\n  T.path = order.map(() => null);\n  for (let i = 0; i \u003c k; i++) {\n    const up = [];\n    for (let n = i; T.nodes[n].up >= 0; n = T.nodes[n].up) up.push(n);\n    T.path[i] = up;\n  }\n  T.pos = new Int32Array(N + 1);\n  for (let j = 0; j \u003c N; j++) T.pos[j + 1] = T.pos[j] + T.codes[T.seq[j]].length;\n  T.fb = ceil(log2(k));\n  T.fixed = T.fb * N;\n  T.cw = T.fixed \u003c= STRIP_R * 32 ? 2 : 1;\n  T.chars = [...text];\n  T.N = N, T.k = k, T.big = big, T.gw = gw, T.Y0 = Y0, T.codeBottom = codeBottom, T.L = L;\n  // A merge takes longer the heavier it is: the twigs go quickly, the\n  // trunk slowly, 0.6 to 1.5 times TM.\n  T.mS = [], T.mD = [], T.mT = [];\n  let at = T0;\n  for (const id of T.merges) {\n    const dur = TM * (0.5 + sqrt(T.nodes[id].w / N));\n    T.mS.push(at), T.mD.push(dur), T.mT.push(at + 0.8 * dur);\n    at += dur;\n  }\n  T.buildEnd = at;\n  T.ts = min(0.25, STREAM / N);\n  T.streamAt = T.buildEnd + PAUSE;\n  T.holdAt = T.streamAt + N * T.ts;\n  T.end = T.holdAt + HOLD + FADE;\n  S.T = T;\n  S.c = 0;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, c: 0, text: 0, rule: 0, hue: 0, speed: 2, T: null, buf: new Float32Array(W * H * 3) };\n  prepare(params.s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const text = cl(round(k[2]), 0, 3), rule = cl(round(k[3]), 0, 2);\n  if (text !== S.text || rule !== S.rule) {\n    S.text = text, S.rule = rule;\n    prepare(S);\n    return;\n  }\n  S.c += (d * S.speed) / 2;\n  if (S.c >= S.T.end) prepare(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const T = S.T, c = S.c, buf = S.buf, nodes = T.nodes;\n  buf.fill(0);\n  const h0 = 0.55 + S.hue;\n  const BIT = [hsv(h0, 0.8, 1), hsv(h0 + 0.58, 0.85, 1)];\n  const PALE = hsv(h0, 0.55, 1), FIX = hsv(h0 + 0.3, 0.55, 1);\n  const fade = c > T.end - FADE ? 1 - sm((c - (T.end - FADE)) / FADE) : 1;\n  const put = (x, y, col, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    buf[i] = max(buf[i], col[0] * v), buf[i + 1] = max(buf[i + 1], col[1] * v), buf[i + 2] = max(buf[i + 2], col[2] * v);\n  };\n  const vline = (x, y0, y1, col, v) => {\n    for (let y = min(y0, y1); y \u003c= max(y0, y1); y++) put(x, y, col, v);\n  };\n  const hline = (x0, x1, y, col, v) => {\n    for (let x = min(x0, x1); x \u003c= max(x0, x1); x++) put(x, y, col, v);\n  };\n  const glyph = (ch, x0, y0, col, v) => {\n    const g5 = T.big && G5[ch], g = g5 || G3[ch];\n    if (!g) return;\n    const gw = g5 ? 5 : 3;\n    if (x0 + gw > W) return;\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c gw; q++) if (g[r * gw + q] === \"1\") put(x0 + q, y0 + r, col, v);\n  };\n  const WHITE = [1, 1, 1];\n  const N = T.N, M = T.merges.length, wN = nodes[T.root].w;\n  const br = (w) => 0.42 + 0.58 * sqrt(w / wN);\n\n  // Merge clock: how many merges are done, which one runs and how far.\n  let done = 0;\n  while (done \u003c M && c >= T.mT[done]) done++;\n  let running = -1, u = 0;\n  if (c >= T0 && c \u003c T.buildEnd) {\n    running = done \u003c M && c >= T.mS[done] ? done : done - 1;\n    u = (c - T.mS[running]) / T.mD[running];\n  }\n  let front = T.Y0;\n  if (c >= T0) {\n    if (running >= 0) {\n      const prev = running > 0 ? nodes[T.merges[running - 1]].y : T.Y0;\n      front = round(prev + (nodes[T.merges[running]].y - prev) * sm(u / 0.45));\n    } else front = nodes[T.root].y;\n  }\n  const isDone = (id) => nodes[id].leaf >= 0 || nodes[id].m \u003c done;\n\n  // Leaves' dotted stems: the count on a log scale.\n  for (let i = 0; i \u003c T.k; i++) {\n    const q = nodes[i];\n    for (let y = T.Y0; y > q.y; y -= 2) put(q.x, y, PALE, 0.4);\n  }\n  // Faint lines a bit apart, counted down from where the root would stand:\n  // a leaf whose node sits between lines j and j + 1 has an ideal length\n  // log2(N / w) between j and j + 1 bits.\n  for (let j = 1; ; j++) {\n    const y = round(T.Y0 - (log2(N) - j) * T.L);\n    if (y > T.Y0) break;\n    for (let x = (j & 1) * 2; x \u003c W; x += 4) put(x, y, PALE, 0.14);\n  }\n  // Under each bar a faint light down to the higher child: the 0 side left\n  // of the parent, the 1 side right of it.\n  for (let j = 0; j \u003c done; j++) {\n    const q = nodes[T.merges[j]], A = nodes[q.a], B = nodes[q.b], low = min(A.y, B.y), hh = low - q.y;\n    const e = 1 - exp(-(c - T.mT[j]) / 0.3);\n    for (let y = q.y + 1; y \u003c low; y++) {\n      const v = e * 0.21 * (1 - (0.75 * (y - q.y)) / hh);\n      for (let x = A.x + 1; x \u003c B.x; x++) if (x !== q.x) put(x, y, BIT[x \u003c q.x ? 0 : 1], v);\n    }\n  }\n  // Edges. A merged node's stem and half bar take its bit's colour, brighter\n  // for heavier nodes; an unmerged node's stem grows white up to the front.\n  for (let n = 0; n \u003c nodes.length; n++) {\n    const q = nodes[n];\n    if (!isDone(n)) continue;\n    const p = q.up >= 0 ? nodes[q.up] : null;\n    if (p && p.m \u003c done) {\n      vline(q.x, q.y, p.y, BIT[q.bit], br(q.w));\n      hline(q.x, p.x, p.y, BIT[q.bit], br(q.w));\n      // Heavy branches run two LEDs wide, inwards and upwards.\n      if (q.leaf \u003c 0 && q.w * 5 >= wN) {\n        vline(q.x + (q.bit ? -1 : 1), q.y - 1, p.y, BIT[q.bit], 0.8 * br(q.w));\n        hline(q.x, p.x, p.y - 1, BIT[q.bit], 0.8 * br(q.w));\n      }\n    } else if (p && p.m === running) {\n      const top = min(q.y, front);\n      vline(q.x, q.y, top, WHITE, 0.95);\n      if (u > 0.45) {\n        const f = sm((u - 0.45) / 0.35), xe = round(q.x + (p.x - q.x) * f);\n        if (f > 0) hline(q.x, xe, p.y, BIT[q.bit], 1);\n      }\n    } else if (n !== T.root) {\n      if (front \u003c q.y) vline(q.x, q.y, front, PALE, 0.55);\n    }\n    // The node itself.\n    if (n === T.root && done === M) vline(q.x, q.y, q.y - 2, WHITE, 1);\n    put(q.x, q.y, WHITE, q.leaf >= 0 ? 0.9 : 0.7);\n  }\n  // A merge just done flashes its bar.\n  if (done > 0) {\n    const id = T.merges[done - 1], q = nodes[id], e = exp(-(c - T.mT[done - 1]) / 0.25);\n    if (e > 0.05) hline(nodes[q.a].x, nodes[q.b].x, q.y, WHITE, e);\n  }\n\n  // Codes over the labels, growing upwards a bit per merge above the leaf.\n  for (let i = 0; i \u003c T.k; i++) {\n    const q = nodes[i], up = T.path[i], len = up.length;\n    let vis = 0;\n    while (vis \u003c len && nodes[nodes[up[vis]].up].m \u003c done) vis++;\n    for (let j = 0; j \u003c vis; j++) {\n      // j counts from the leaf: the bit of up[j]; it sits j rows above the bottom.\n      const n = up[j], y = T.codeBottom - 2 * j;\n      const fresh = exp(-(c - T.mT[nodes[nodes[n].up].m]) / 0.3);\n      put(q.x, y, BIT[nodes[n].bit], 0.85);\n      if (fresh > 0.05) put(q.x, y, WHITE, fresh);\n    }\n    // The leaf's column down to its label.\n    vline(q.x, T.codeBottom + 1, q.ly - 1, PALE, 0.3);\n  }\n\n  // Streaming: the current symbol's path lights from the root down, and its\n  // bits go into the Huffman strip while its fixed code goes in below.\n  let cur = -1, cu = 0, wrote = 0, wroteF = 0;\n  if (c >= T.streamAt) {\n    const s = (c - T.streamAt) / T.ts;\n    cur = min(N - 1, floor(s));\n    cu = s >= N ? 1 : s - cur;\n    const leaf = T.seq[cur], len = T.codes[leaf].length;\n    const shown = min(len, 1 + floor(cu * 1.6 * len));\n    wrote = T.pos[cur] + shown;\n    wroteF = cur * T.fb + min(T.fb, 1 + floor(cu * 1.6 * T.fb));\n    // Path: up[len-1] is the root's child; edges from the root down.\n    const up = T.path[leaf], e = s >= N ? 0 : 1 - 0.5 * cu;\n    for (let j = len - 1; j >= len - shown; j--) {\n      const q = nodes[up[j]], p = nodes[q.up];\n      vline(q.x, q.y, p.y, WHITE, e);\n      hline(q.x, p.x, p.y, WHITE, e);\n    }\n    const lf = nodes[leaf];\n    if (shown === len) for (let j = 0; j \u003c len; j++) put(lf.x, T.codeBottom - 2 * j, WHITE, e);\n  }\n\n  // Labels.\n  for (let i = 0; i \u003c T.k; i++) {\n    const q = nodes[i], lit = cur >= 0 && T.seq[cur] === i && c \u003c T.holdAt;\n    glyph(T.sym[i].ch, q.x - (T.gw >> 1), q.ly, lit ? WHITE : PALE, lit ? 1 : 0.85);\n  }\n\n  // Strips: the Huffman strip fills with placeholders a merge at a time,\n  // w cells for a merge of weight w, and they come to the code's length;\n  // the fixed strip waits at N times the fixed length from the start.\n  const cw = T.cw, per = W / cw;\n  const cell = (y0, i, col, v) => {\n    const x = (i % per) * cw, y = y0 + floor(i / per);\n    for (let q = 0; q \u003c cw; q++) put(x + q, y, col, v);\n  };\n  let held = 0;\n  for (let j = 0; j \u003c done; j++) held += nodes[T.merges[j]].w;\n  const GREY = FIX;\n  let bit = 0;\n  for (let i = 0; i \u003c T.total; i++) {\n    if (i \u003c wrote) {\n      // Which bit of which symbol: walk the text alongside.\n      while (T.pos[bit + 1] \u003c= i) bit++;\n      const b = T.codes[T.seq[bit]][i - T.pos[bit]];\n      cell(HS_Y, i, BIT[b === \"1\" ? 1 : 0], i >= T.pos[cur] && c \u003c T.holdAt ? 1 : 0.8);\n    } else if (i \u003c held) cell(HS_Y, i, PALE, 0.25);\n  }\n  for (let i = 0; i \u003c T.fixed; i++) {\n    if (i \u003c wroteF) {\n      const j = floor(i / T.fb), b = (T.seq[j] >> (T.fb - 1 - (i % T.fb))) & 1;\n      cell(FS_Y, i, GREY, b ? 0.7 : 0.32);\n    } else cell(FS_Y, i, GREY, 0.22);\n  }\n\n  // The line: the text before the first merge, each merge's sum while the\n  // tree grows, the text running through while it streams, then the totals.\n  const P = T.big ? 6 : 4;\n  if (done === 0 && running \u003c 1) {\n    for (let j = 0; j * P \u003c W && j \u003c N; j++) glyph(T.chars[j], j * P + 1, LINE_Y, PALE, 0.6);\n  } else if (c \u003c T.streamAt) {\n    const id = T.merges[running >= 0 ? running : M - 1], q = nodes[id];\n    const parts = [[String(nodes[q.a].w), BIT[0]], [\"+\", PALE], [String(nodes[q.b].w), BIT[1]]];\n    if (running \u003c 0 || u >= 0.8) parts.push([\"=\", PALE], [String(q.w), WHITE]);\n    let len = 0;\n    for (const [s] of parts) len += s.length;\n    let x = (W - len * 4 + 1) >> 1;\n    for (const [s, col] of parts) for (const ch of s) glyph(ch, x, LINE_Y, col, 1), (x += 4);\n  } else if (c \u003c T.holdAt) {\n    const chars = T.chars;\n    for (let j = 0; j \u003c 16; j++) {\n      const at = cur - 3 + j;\n      if (at \u003c 0 || at >= N || j * P >= W) continue;\n      glyph(chars[at], j * P + 1, LINE_Y, at === cur ? WHITE : PALE, at === cur ? 1 : at \u003c cur ? 0.35 : 0.65);\n    }\n  } else {\n    const a = String(T.total), b = String(T.fixed), len = a.length + 1 + b.length;\n    let x = (W - len * 4 + 1) >> 1;\n    for (const ch of a) glyph(ch, x, LINE_Y, BIT[1], 1), (x += 4);\n    glyph(\"\u003c\", x, LINE_Y, WHITE, 1), (x += 4);\n    for (const ch of b) glyph(ch, x, LINE_Y, GREY, 0.8), (x += 4);\n  }\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * min(1, buf[i] * fade)) | 0, (255 * min(1, buf[i + 1] * fade)) | 0, (255 * min(1, buf[i + 2] * fade)) | 0);\n    }\n}\n","josephus":"// ===== Patternflow pattern =====\n// Title:   Josephus Problem\n// Family:  rhythm\n// Idea:    A circle of n lamps fills the top half and a hand goes round it one place a tick, each lamp it passes still lit a beat and every k-th beat an accent that puts that lamp out, so the beat thins into rests as the circle empties, with a roll inside the ring drawing that rhythm and the survivor's number coming up when one lamp is left, while the bottom half holds the table of every circle from 1 to 64 lamps, one row each, coloured by the order its places went out with the survivor white, so the survivors J(n,k) run down the panel as a sawtooth and the row of the circle on top lights as it plays.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Josephus problem (Flavius Josephus, The Jewish War, 1st century; counting-out puzzle in Claude Gaspard Bachet's Problèmes plaisans et délectables, 1612), closed form J(2^m + L) = 2L + 1 (Graham, Knuth and Patashnik, Concrete Mathematics, 1989, chapter 1), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Step=2..7, Circle=8..64\n//\n// Knob 1: Hue. Turns the colours of the places put out round the wheel: at 0 the first ones out are a deep blue and the later ones teal, green and gold up to the white survivor, with the lamps still lit a cool white; at 0.25 they run from rose through orange and yellow to green, at 0.5 from yellow-green through red and magenta to blue.\n// Knob 2: Speed. The counting tempo: at 2 the hand passes 2(2 + n/6) places a second while every lamp is lit, 6.7 on the opening circle of 8 and 25 on a circle of 64, and hurries by the square root of n over the lamps left as they go out, so the circle of 8 is down to one lamp in 2.1 s and the circle of 64 in 6.4 s, each survivor then holding 1.3 s. At 0.2 the circle of 8 takes 21 s, at 3 it takes 1.4 s.\n// Knob 3: Step. k, the beat that goes out, 2 to 7. At 2, the classic, every second lamp goes, a circle of 16 halves its beats every time round (xXxX, x.X., x...X...) and the survivor column climbs 2 places a row and drops back to place 1 at 4, 8, 16, 32 and 64; at 3 it climbs 3 a row and drops at 4, 6, 9, 14, 21, 31 and 47; at 7 there are 15 drops and the roll counts up 1 to 7 in a staircase. A new k redraws the table and starts the circle on top again.\n// Knob 4: Circle. The circle the top starts from, 8 to 64 lamps, and the row of the table that lights with it. After each survivor the next circle has one lamp more, so from 8 the top reaches 64 in 6 minutes at Speed 2, and after 64 it comes back to this one.\n\nconst W = 64, H = 128, NMAX = 64, TOP = 63;\nconst { floor, round, min, max, abs, sqrt, exp, atan2, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The circle: centre (32, 32) in LED units, lamps between radius 22 and\n// 30.5, the hand's marker just inside them, place 0 at twelve o'clock and\n// the places counting clockwise.\nconst CX = 32, CY = 32, R1 = 22, R2 = 30.5, HR0 = 18.8, HR1 = 21.2, BR = 17.5;\n// The rhythm roll inside the circle: one column per tick, newest on the\n// right, bars standing on row SB.\nconst SX0 = 14, SX1 = 49, SB = 43, SN = SX1 - SX0 + 1;\n// The hue of the first place out at knob 0, a deep blue.\nconst HUE0 = 0.7, WHITE = [1, 1, 1];\n\n// 3 x 5 digits, row by row from the top, three bits a row.\nconst FONT = [\n  0b111101101101111, 0b010110010010111, 0b111001111100111, 0b111001111001111, 0b101101111001001,\n  0b111100111001111, 0b111100111101111, 0b111001001001001, 0b111101111101111, 0b111101111001111,\n];\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Every pixel of the top square that a lamp or the hand can light, with its\n// angle as a fraction of a turn clockwise from twelve and its radius.\nconst RING = (() => {\n  const idx = [], ang = [], rad = [];\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      if (r \u003c BR || r > R2 + 0.6) continue;\n      let a = atan2(dx, -dy) / (2 * PI);\n      if (a \u003c 0) a += 1;\n      idx.push(y * W + x), ang.push(a), rad.push(r);\n    }\n  return { idx: Int32Array.from(idx), ang: Float32Array.from(ang), rad: Float32Array.from(rad) };\n})();\n\n// The table: for each circle n = 1..64 and each place, the turn at which it\n// went out, 0 first and n - 1 the survivor. Counting starts at place 0 as 1,\n// the k-th lamp counted goes out and counting goes on from the next lamp\n// still lit, the same walk the hand makes on top; its survivor is J(n, k),\n// with J(1) = 0 and J(n) = (J(n - 1) + k) mod n.\nfunction table(k) {\n  const ord = [], surv = new Int32Array(NMAX + 1);\n  for (let n = 1; n \u003c= NMAX; n++) {\n    const o = new Int32Array(n), on = new Uint8Array(n).fill(1);\n    let left = n, count = 0, r = 0;\n    for (let j = 0; left > 1; j++) {\n      const q = j % n;\n      if (on[q] && ++count === k) (on[q] = 0), (o[q] = r++), (count = 0), left--;\n    }\n    surv[n] = on.indexOf(1);\n    o[surv[n]] = n - 1;\n    ord[n] = o;\n  }\n  return { ord, surv };\n}\n\n// A fresh circle of n lamps, all lit, the hand just before place 0.\nfunction begin(S, n) {\n  S.n = n, S.alive.fill(0), S.alive.fill(1, 0, n), S.left = n, S.count = 0;\n  S.j = 0, S.ph = 0.55, S.phase = n > 1 ? 0 : 1, S.ht = 0, S.born = S.t;\n  S.flash.fill(0), S.gone.fill(-9);\n  roll(S, -1);\n}\n\nfunction roll(S, mark, c) {\n  S.roll[S.rh] = mark;\n  if (c) S.rollc[S.rh * 3] = c[0], S.rollc[S.rh * 3 + 1] = c[1], S.rollc[S.rh * 3 + 2] = c[2];\n  S.rh = (S.rh + 1) % SN;\n}\n\n// The colour of place i of circle m by the turn it went out at: the first\n// ones out a deep blue, then teal and green to gold for the last ones out,\n// rising in light, and the survivor white.\nfunction cellColour(S, m, i, o) {\n  const r = S.tab.ord[m][i];\n  if (r >= m - 1) return (o[0] = 1), (o[1] = 1), (o[2] = 1), o;\n  const u = m > 2 ? r / (m - 2) : 0;\n  return hsv(HUE0 + S.hue - 0.56 * u, 0.9 - 0.3 * u, 0.17 + 0.56 * pow(u, 1.8), o);\n}\n\n// The hand reaches place j mod n: a lit lamp is a beat, the k-th beat puts\n// it out; a lamp already out is a rest.\nfunction tick(S) {\n  const q = S.j % S.n;\n  S.j++;\n  if (!S.alive[q]) return roll(S, 0);\n  S.count++;\n  S.flash[q] = 1;\n  if (S.count \u003c S.k) return roll(S, S.count);\n  S.alive[q] = 0, S.gone[q] = S.t, S.count = 0, S.left--;\n  roll(S, 9, cellColour(S, S.n, q, S.c));\n  if (S.left \u003c= 1) (S.phase = 1), (S.ht = 0);\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, k: 2, n0: 8, n: 8, alive: new Uint8Array(NMAX), flash: new Float32Array(NMAX),\n    gone: new Float32Array(NMAX), left: 8, count: 0, j: 0, ph: 0, phase: 0, ht: 0, born: 0,\n    roll: new Int8Array(SN).fill(-2), rollc: new Float32Array(SN * 3), rh: 0,\n    fb: new Float32Array(W * H * 3), lamp: new Float32Array(NMAX * 3), burst: new Float32Array(NMAX), c: [0, 0, 0], pale: [0, 0, 0], tab: table(2),\n  });\n  begin(S, 8);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 8], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const k = cl(round(kv[2]), 2, 7), n0 = cl(round(kv[3]), 8, NMAX);\n  if (k !== S.k) (S.k = k), (S.tab = table(k)), begin(S, S.n);\n  if (n0 !== S.n0) (S.n0 = n0), begin(S, n0);\n  for (let i = 0; i \u003c S.n; i++) S.flash[i] *= exp(-d / 0.09);\n  if (S.phase === 0) {\n    // Ticks a second: more for a bigger circle, and faster as it empties.\n    let left = d;\n    while (left > 0 && S.phase === 0) {\n      const rate = S.speed * (2 + S.n / 6) * sqrt(S.n / S.left), need = (1 - S.ph) / rate;\n      if (need > left) {\n        S.ph += left * rate;\n        break;\n      }\n      left -= need, S.ph = 0;\n      tick(S);\n    }\n  } else if ((S.ht += d) > 0.7 + 1.2 / S.speed) {\n    // The next circle has one lamp more; after 64 the top goes back to the\n    // circle the Circle knob names.\n    begin(S, S.n \u003c NMAX ? S.n + 1 : S.n0);\n  }\n}\n\nfunction add(fb, p, r, g, b, a) {\n  fb[p * 3] += r * a, fb[p * 3 + 1] += g * a, fb[p * 3 + 2] += b * a;\n}\n\n// A number in doubled 3 x 5 digits, centred on column cx, its top on row y.\nfunction number(fb, v, cx, y, col, a) {\n  const str = String(v), x0 = round(cx - (str.length * 8 - 2) / 2);\n  for (let d = 0; d \u003c str.length; d++) {\n    const g = FONT[str.charCodeAt(d) - 48];\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++)\n        if ((g >> (14 - r * 3 - q)) & 1)\n          for (let e = 0; e \u003c 4; e++) add(fb, (y + r * 2 + (e >> 1)) * W + x0 + d * 8 + q * 2 + (e & 1), col[0], col[1], col[2], a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const fb = S.fb, c = S.c, n = S.n, t = S.t, lamp = S.lamp;\n  fb.fill(0);\n  // Lamps still lit are a cool white that the hue knob tints a little.\n  const pale = hsv(HUE0 + S.hue - 0.1, 0.14, 0.9, S.pale);\n  const fin = S.phase === 1, glow = fin ? 0.8 + 0.2 * Math.cos(S.ht * 9) : 0;\n  const fresh = cl((t - S.born) / 0.25, 0, 1);\n\n  // Lamp colours for this frame.\n  for (let i = 0; i \u003c n; i++) {\n    let r, g, b;\n    if (S.alive[i]) {\n      const f = S.flash[i], v = fin ? glow : (0.5 + 0.5 * f) * fresh;\n      r = fin ? 1 : pale[0] + (1 - pale[0]) * f, g = fin ? 0.97 : pale[1] + (1 - pale[1]) * f, b = fin ? 0.9 : pale[2] + (1 - pale[2]) * f;\n      r *= v, g *= v, b *= v;\n    } else {\n      cellColour(S, n, i, c);\n      const a = exp(-(t - S.gone[i]) / 0.22), dim = fin ? 0.7 : 0.42;\n      r = c[0] * dim + a, g = c[1] * dim + a * 0.95, b = c[2] * dim + a * 0.9;\n    }\n    lamp[i * 3] = r, lamp[i * 3 + 1] = g, lamp[i * 3 + 2] = b;\n    S.burst[i] = S.alive[i] ? 0 : exp(-(t - S.gone[i]) / 0.2);\n  }\n\n  // The lamps, as n wedges of the ring with a gap of about one LED between\n  // them, a lamp put out bursting inward for a moment, and the hand as a\n  // short bright mark just inside them.\n  const hand = fin ? -1 : (((S.j - 1 + S.ph) % n) + n) % n;\n  const I = RING.idx, A = RING.ang, RR = RING.rad;\n  for (let q = 0; q \u003c I.length; q++) {\n    const r = RR[q], p = I[q];\n    const u = A[q] * n + 0.5, i = floor(u) % n, f = u - floor(u);\n    const side = cl(min(f, 1 - f) * ((2 * PI * r) / n) - 0.1, 0, 1);\n    if (r >= R1 - 0.5) {\n      const a = side * cl(r - R1 + 0.5, 0, 1) * cl(R2 - r + 0.5, 0, 1);\n      if (a > 0) add(fb, p, lamp[i * 3], lamp[i * 3 + 1], lamp[i * 3 + 2], a);\n      continue;\n    }\n    if (S.burst[i] > 0.02) add(fb, p, 1, 0.95, 0.9, S.burst[i] * side * (0.35 + 0.65 * cl((r - BR) / (R1 - BR), 0, 1)));\n    if (hand >= 0 && r >= HR0 && r \u003c= HR1) {\n      let da = abs(A[q] - hand / n);\n      if (da > 0.5) da = 1 - da;\n      const a = cl(1.7 - da * 2 * PI * r, 0, 1);\n      if (a > 0) add(fb, p, 1, 1, 1, a * 0.9);\n    }\n  }\n\n  // The circle's size on top inside the ring, and once it is down to one\n  // lamp the survivor's place counted from 1, in white.\n  if (fin) number(fb, S.tab.surv[n] + 1, CX, 15, WHITE, glow);\n  else number(fb, n, CX, 15, pale, 0.55);\n\n  // The rhythm roll: a rest is a dot, a beat a bar as tall as its count, the\n  // k-th beat a full bar in the colour of the lamp it put out; a new circle\n  // leaves a dotted rule.\n  for (let s = 0; s \u003c SN; s++) {\n    const h = (S.rh + s) % SN, m = S.roll[h], x = SX0 + s, v = 0.3 + 0.7 * ((s + 1) / SN);\n    if (m === -2) continue;\n    if (m === -1) for (let y = SB - 12; y \u003c= SB; y += 2) add(fb, y * W + x, 0.35, 0.35, 0.4, v);\n    else if (m === 0) add(fb, SB * W + x, 0.4, 0.38, 0.36, v);\n    else if (m \u003c 9) {\n      const bh = 1 + round((10 * m) / S.k);\n      for (let y = SB - bh + 1; y \u003c= SB; y++) add(fb, y * W + x, pale[0], pale[1], pale[2], v * 0.8);\n    } else {\n      const rc = S.rollc;\n      for (let y = SB - 12; y \u003c= SB; y++) add(fb, y * W + x, rc[h * 3] * 0.6 + 0.4, rc[h * 3 + 1] * 0.6 + 0.4, rc[h * 3 + 2] * 0.6 + 0.4, v);\n    }\n  }\n\n  // The table: circle m on panel row 63 + m, place i in column i, the\n  // current row lit and filling in as the circle plays it, with the hand\n  // as a white cell.\n  for (let m = 1; m \u003c= NMAX; m++) {\n    const y = TOP + m, cur = m === n, gain = cur ? 1 : 0.9;\n    for (let i = 0; i \u003c m; i++) {\n      const p = y * W + i;\n      if (cur && S.alive[i] && !fin) {\n        add(fb, p, pale[0], pale[1], pale[2], 0.55 * fresh + 0.45 * S.flash[i]);\n        continue;\n      }\n      cellColour(S, m, i, c);\n      let a = gain;\n      if (cur && !fin) a += exp(-(t - S.gone[i]) / 0.22);\n      if (cur && fin && S.tab.surv[m] === i) a = 0.5 + 0.7 * glow;\n      add(fb, p, c[0], c[1], c[2], a);\n    }\n    if (cur) {\n      // The current row runs out to the right edge as a dotted line.\n      for (let x = m + 1; x \u003c W; x += 2) add(fb, y * W + x, pale[0], pale[1], pale[2], 0.35);\n      if (hand >= 0) add(fb, y * W + (round(hand) % m), 1, 1, 1, 1);\n    }\n  }\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, fb[k] * 255) | 0, min(255, fb[k + 1] * 255) | 0, min(255, fb[k + 2] * 255) | 0);\n    }\n}\n","ogham":"// ===== Patternflow pattern =====\n// Title:   Ogham\n// Family:  type\n// Idea:    A standing stone is seen corner-on with its edge running up the whole panel as the stemline, and an Ogham inscription is cut into it stroke by stroke from the bottom up, one to five strokes a letter, the B aicme on the right face, the H aicme on the left, the M aicme slanting across the edge from one face onto the other and the vowels notched on the edge itself, while a small Latin letter beside each group counts its strokes as they land (B, L, F, S, then N for five on the right) and the view climbs the stone with the chisel near the top, each cut a groove of a lit lower wall and a shaded upper one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Ogham alphabet of four aicmí of five letters as the Ogam tract of the Book of Ballymote sets it out (George Calder, Auraicept na n-Éces, 1917), its Old Irish letter names and the MAQI and MUCOI of the Primitive Irish memorial stones (Damian McManus, A Guide to Ogam, 1991); Typewriter's 3 by 5 capitals (pattern round 18); pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Turn=-1..1\n//\n// Knob 1: Hue. Turns the light round the wheel: at 0 the cuts are pale gold on blue-grey slate, at 0.5 pale blue on a brown sandstone, the gloss letters a whiter tint of the cuts.\n// Knob 2: Speed. Strokes cut a second: 5 at the opening 2, 0.8 at 0.2, 13.6 at 3. Every fresh stone has its first 100 rows (the whole B aicme of the alphabet) cut at 25 a second, in 0.9 s, so the writing stands the panel's height at once; at 2 the alphabet's 60 strokes are done at 12.9 s (74 s at 0.2, 5.3 s at 3), then the stone holds 3 s with its top in view and a fresh one is started.\n// Knob 3: Text. Which inscription, each on its own stone: 0 the twenty letters in their four aicmí, 60 strokes over 380 rows of stone; 1 the four aicme names BEITHE HUATHA MUINE AILME, 59 strokes of which 40 are vowel notches; 2 the formula words ANM MAQI MUCOI, 34 strokes; 3 the Old Irish names of the first aicme, BEITHE LUIS FERN SAIL NIN, 76 strokes over 460 rows.\n// Knob 4: Turn. Turns the stone about its upright axis, 13 degrees at the opening 0.06 so the left face shows wider, 40 degrees each way at the ends: at -1 the right face comes round to you and the left one shrinks to a sliver, at 1 the reverse, and the strokes on the turning face shorten while the slanting M strokes kink at the edge.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The alphabet. Four aicmí (\"families\") of five letters, each letter\n// one to five strokes: the B aicme to the right of the stemline as it is\n// read upward, the H aicme to the left, the M aicme slanting across it, the\n// vowels notched on it. On a stone the stemline is the arris itself. The\n// third letter is F as the manuscripts give fern; the oldest stones wrote V\n// with it.\nconst AICME = [\n  [\"B\", \"L\", \"F\", \"S\", \"N\"],\n  [\"H\", \"D\", \"T\", \"C\", \"Q\"],\n  [\"M\", \"G\", \"NG\", \"Z\", \"R\"],\n  [\"A\", \"O\", \"U\", \"E\", \"I\"],\n];\nconst WHERE = {};\nAICME.forEach((a, g) => a.forEach((L, i) => (WHERE[L] = [g, i + 1])));\n// The inscriptions, a word to a group of letters. The alphabet in aicme\n// order; the aicmí named after their first letters; the words of the\n// memorial stones, ANM (\"name\") that opens some and the MAQI (\"son of\") and\n// MUCOI (\"of the kin of\") of X MAQI Y MUCOI Z, without any names; the Old\n// Irish names of the first five letters.\nconst TEXTS = [\n  [\"BLFSN\", \"HDTCQ\", \"MGNGZR\", \"AOUEI\"],\n  [\"BEITHE\", \"HUATHA\", \"MUINE\", \"AILME\"],\n  [\"ANM\", \"MAQI\", \"MUCOI\"],\n  [\"BEITHE\", \"LUIS\", \"FERN\", \"SAIL\", \"NIN\"],\n];\nconst parse = (w) => {\n  const out = [];\n  for (let i = 0; i \u003c w.length; i++) {\n    if (w[i] === \"N\" && w[i + 1] === \"G\") out.push(\"NG\"), i++;\n    else out.push(w[i]);\n  }\n  return out;\n};\n\n// Typewriter's 3 by 5 capitals (pattern round 18), the letters the gloss needs.\nconst FONT = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\", E: \"111100110100111\",\n  F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\", I: \"111010010010111\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", Q: \"010101101111011\", R: \"110101110101101\",\n  S: \"011100010001110\", T: \"111010010010010\", U: \"101101101101011\", Z: \"111001010100111\",\n};\n\n// ---- The stone: a square pillar seen corner-on, its axis at column CX, its\n// half diagonal one of RS, a stone to each text; heights v in rows, the\n// view climbing the stone with the chisel a whole row at a time so every\n// cut lands on one row of LEDs.\nconst CX = 35.5, RS = [24, 22.5, 25.5, 23.5], CAM0 = -10, VOFF = 40;\nconst PITCH = 4, LGAP = 10, WGAP = 20, BASE = 9;\n// How far each aicme's strokes reach along a face, in face units (one\n// unit is one LED when the face is square to you), and the M slant.\nconst REACH = [16, 16, 9, 2.4], SLANT = 0.42, CUT = 0.62;\n// A fresh stone's first RUN rows are cut at RUSH strokes a second, so the\n// writing stands the panel's height within a second; then the chisel goes\n// at the Speed knob's pace with the view holding it LEAD rows below the top.\nconst RUN = 100, RUSH = 25, LEAD = 116;\n\nconst hash = (a, b, c) => {\n  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  h = Math.imul(h ^ (h >>> 16), 2246822519);\n  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;\n};\n\nfunction newStone(S, ti) {\n  const letters = [], cuts = [];\n  let v = BASE - LGAP, t = 0.3;\n  TEXTS[ti].forEach((word, wi) => {\n    if (wi) (v += WGAP - LGAP), (t += 1.4);\n    for (const L of parse(word)) {\n      const [g, n] = WHERE[L];\n      v += LGAP;\n      if (letters.length) t += 0.9;\n      const v0 = v, first = cuts.length;\n      for (let i = 0; i \u003c n; i++) {\n        if (i) v += PITCH;\n        cuts.push({ g, v, t0: t, li: letters.length });\n        t += 1;\n      }\n      letters.push({ L, g, n, mid: (v0 + v) / 2, first });\n    }\n  });\n  S.letters = letters;\n  S.cuts = cuts;\n  S.end = t + 0.4;\n  S.top = v + 20;\n  S.r = RS[ti];\n  S.side = S.r * Math.SQRT2;\n  // Each face's grain: coarse blotches, a finer mottle and single-LED\n  // speckle, and the jagged line of its top, highest at the edge.\n  const U = ceil(S.side) + 2, V = S.top + VOFF + 30;\n  S.U = U;\n  S.V = V;\n  S.tex = [0, 1].map((f) => {\n    const T = new Float32Array(U * V);\n    const val = (gx, gy, sc, k) => {\n      const x = gx / sc, y = gy / sc, x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n      const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);\n      const a = hash(x0, y0, k), b = hash(x0 + 1, y0, k), c = hash(x0, y0 + 1, k), d = hash(x0 + 1, y0 + 1, k);\n      return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;\n    };\n    const seed = ti * 4 + f * 2 + 1;\n    for (let y = 0; y \u003c V; y++)\n      for (let x = 0; x \u003c U; x++)\n        T[y * U + x] = 0.62 + 0.42 * val(x, y, 9, seed) + 0.26 * val(x, y, 3, seed + 40) + 0.2 * hash(x, y, seed + 80);\n    return T;\n  });\n  S.tops = [0, 1].map((f) => {\n    const T = new Float32Array(U);\n    for (let u = 0; u \u003c U; u++) T[u] = S.top - 12 * (u / S.side) ** 2 - 2.5 * hash(u >> 1, f, ti + 9);\n    return T;\n  });\n  S.t = 0;\n  S.cam = CAM0;\n  S.phase = 0;\n  S.parts = [];\n  S.ci = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = { ti: -1, hue: 0, rate: 5, turn: 0, dim: 1, emit: 0 });\n  S.Cov = new Float32Array(W * H);\n  S.Fre = new Float32Array(W * H);\n  S.Wl = new Float32Array(W * H);\n  S.F = new Float32Array(W * H * 3);\n  S.colF = new Int8Array(W);\n  S.colU = new Float32Array(W);\n}\n\n// The cut in progress: the last one whose time has come.\nfunction current(S) {\n  const c = S.cuts;\n  let i = S.ci || 0;\n  if (i >= c.length || c[i].t0 > S.t) i = 0;\n  while (i + 1 \u003c c.length && c[i + 1].t0 \u003c= S.t) i++;\n  S.ci = i;\n  return i;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.rate = 5 * exp(cl(k[1], 0.2, 3) - 2);\n  S.turn = cl(k[3] || 0, -1, 1);\n  const ti = round(cl(k[2] || 0, 0, 3));\n  if (ti !== S.ti) {\n    S.ti = ti;\n    newStone(S, ti);\n  }\n  // Carve, hold the finished stone with its top in view, darken, and\n  // start again on a fresh one.\n  let target;\n  if (S.phase === 0) {\n    const i = current(S), c = S.cuts[i], n = S.cuts[min(i + 1, S.cuts.length - 1)];\n    S.t += dt * (c.v \u003c RUN ? max(S.rate, RUSH) : S.rate);\n    S.dim = min(1, S.dim + dt / 0.5);\n    // The view aims between this cut and the next, so it climbs evenly.\n    const a = n === c ? 0 : cl((S.t - c.t0) / (n.t0 - c.t0), 0, 1);\n    target = c.v + (n.v - c.v) * a + REACH[2] * SLANT - LEAD;\n    if (S.t >= S.end) (S.phase = 1), (S.hold = 0);\n  } else {\n    target = S.top - 112;\n    S.hold += dt;\n    if (S.hold > 3) S.dim -= dt / 0.7;\n    if (S.dim \u003c= 0) {\n      S.dim = 0;\n      newStone(S, S.ti);\n    }\n  }\n  S.cam += (max(CAM0, target) - S.cam) * (1 - exp(-dt * 6));\n  // Stone dust off the chisel, in panel columns and stone rows.\n  const P = S.parts;\n  for (const p of P) {\n    p.x += p.vx * dt;\n    p.v += p.vv * dt;\n    p.vv -= 60 * dt;\n    p.life -= dt;\n  }\n  if (P.length && P[0].life \u003c= 0) S.parts = P.filter((p) => p.life > 0);\n  if (S.tip) {\n    S.emit += dt * 30;\n    while (S.emit >= 1) {\n      S.emit -= 1;\n      const sd = S.tip[2];\n      S.parts.push({ x: S.tip[0], v: S.tip[1], vx: sd * (6 + 14 * Math.random()) + 6 * (Math.random() - 0.5), vv: 4 + 14 * Math.random(), life: 0.3 + 0.4 * Math.random() });\n    }\n  }\n}\n\n// One straight piece of a cut as a capsule of radius rad. A cut is a groove\n// with two walls: under light from above, the lower wall faces up and is\n// lit (the cover buffer, its freshness alongside) and the upper wall a row\n// above it faces down into shade (the wall buffer).\nfunction seg(S, a, b, rad, fresh) {\n  const [ax, ay] = a, [bx, by] = b;\n  const x0 = max(0, floor(min(ax, bx) - rad - 1)), x1 = min(W - 1, ceil(max(ax, bx) + rad + 1));\n  const y0 = max(1, floor(min(ay, by) - rad - 1)), y1 = min(H - 1, ceil(max(ay, by) + rad + 1));\n  const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5 - ax, py = y + 0.5 - ay;\n      const u = L2 ? cl((px * dx + py * dy) / L2, 0, 1) : 0;\n      const ex = px - u * dx, ey = py - u * dy;\n      const c = cl(rad + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (c \u003c= 0) continue;\n      const o = y * W + x;\n      if (c > S.Cov[o]) S.Cov[o] = c;\n      if (c * fresh > S.Fre[o]) S.Fre[o] = c * fresh;\n      if (c > S.Wl[o - W]) S.Wl[o - W] = c;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cuts) return;\n  const { Cov, Fre, Wl, F, colF, colU } = S;\n  Cov.fill(0);\n  Fre.fill(0);\n  Wl.fill(0);\n  F.fill(0);\n  // The edge and the far corners across the panel, and how much of a face\n  // unit each face shows: cos(45 degrees + turn) on the right, cos(45 - turn)\n  // on the left.\n  const th = 0.7 * S.turn + 0.18 * (1 - S.turn * S.turn), r = S.r, side = S.side, ve = round(S.cam) + 64;\n  const sF = CX + r * sin(th), sR = CX + r * cos(th), sL = CX - r * cos(th);\n  const cs = [cos(PI / 4 + th), -cos(PI / 4 - th)];\n  const P = (f, u, v) => [sF + u * cs[f], 63.5 - (v - ve)];\n  // Each panel column: its face and how far along it.\n  for (let x = 0; x \u003c W; x++) {\n    const X = x + 0.5, f = X >= sF && X \u003c sR ? 0 : X \u003c sF && X >= sL ? 1 : -1;\n    colF[x] = f;\n    if (f >= 0) colU[x] = (X - sF) / cs[f];\n  }\n  const lit = (a) => 0.36 + 0.64 * max(0, (-0.55 * sin(a) + 0.8 * cos(a)) / 0.971);\n  const shade = [lit(th + PI / 4), lit(th - PI / 4)];\n  const hue = S.hue;\n  const stone = hsv(hue + 0.58, 0.3, 84), cutC = hsv(hue + 0.13, 0.42, 245), gloss = hsv(hue + 0.13, 0.18, 230);\n  const sky = hsv(hue + 0.62, 0.7, 1);\n  const Ye = (v) => 63.5 - (v - ve);\n\n  // ---- The cuts. Strokes start at the edge and run out along a face; an\n  // M stroke runs from the left face across the edge onto the right one.\n  const ci = S.phase === 0 ? current(S) : -1;\n  S.tip = null;\n  for (let i = 0; i \u003c S.cuts.length; i++) {\n    const c = S.cuts[i];\n    if (c.t0 > S.t) break;\n    const yc = Ye(c.v);\n    if (yc \u003c -12 || yc > H + 12) continue;\n    const p = cl((S.t - c.t0) / CUT, 0, 1);\n    const fresh = p \u003c 1 ? 1 : exp(-(S.t - c.t0 - CUT) / S.rate / 0.9);\n    const L = REACH[c.g], E = P(0, 0, c.v);\n    let tip, sd = 1;\n    if (c.g \u003c 2) {\n      tip = P(c.g, L * p, c.v);\n      sd = c.g ? -1 : 1;\n      seg(S, E, tip, 0.5, fresh);\n    } else if (c.g === 2) {\n      const a = P(1, L, c.v - L * SLANT), e = P(1, 0, c.v);\n      if (p \u003c= 0.5) {\n        tip = P(1, L * (1 - 2 * p), c.v - L * SLANT * (1 - 2 * p));\n        sd = -1;\n        seg(S, a, tip, 0.5, fresh);\n      } else {\n        tip = P(0, L * (2 * p - 1), c.v + L * SLANT * (2 * p - 1));\n        seg(S, a, e, 0.5, fresh);\n        seg(S, E, tip, 0.5, fresh);\n      }\n    } else {\n      tip = P(0, L * p, c.v);\n      seg(S, P(1, L * p, c.v), tip, 0.5, fresh);\n    }\n    if (i === ci && p \u003c 1) S.tip = [tip[0], ve + 63.5 - tip[1], sd];\n  }\n\n  // ---- Stone, sky and the cuts over them.\n  const top0 = S.tops;\n  for (let x = 0; x \u003c W; x++) {\n    const f = colF[x], u = colU[x], ui = f \u003c 0 ? 0 : min(S.U - 1, max(0, floor(u)));\n    // Lighter towards the edge, which stands nearest, and the edge itself\n    // catching the light along its whole height.\n    const e = abs(x + 0.5 - sF), edge = e \u003c 1.3 ? 0.45 * (1.3 - e) : 0, near = f \u003c 0 ? 0 : 1 - 0.3 * (u / side) ** 1.5;\n    for (let y = 0; y \u003c H; y++) {\n      const o = y * W + x;\n      const v = ve + 63 - y;\n      let R, G, B;\n      if (f \u003c 0 || v > top0[f][ui]) {\n        const s = 3 + 7 * (y / H);\n        R = sky[0] * s;\n        G = sky[1] * s;\n        B = sky[2] * s;\n      } else {\n        const vi = cl(floor(v) + VOFF, 0, S.V - 1);\n        const l = shade[f] * near * S.tex[f][vi * S.U + ui] + edge;\n        const c = Cov[o], w = Wl[o] * (1 - c), fr = Fre[o], fw = y \u003c H - 1 ? 0.5 * Fre[o + W] : 0;\n        const cc = (0.7 + 0.3 * shade[f]) * (1 - fr), cw = 0.4 * (0.7 + 0.3 * shade[f]) * (1 - fw);\n        R = stone[0] * l * (1 - c - w) + c * (cutC[0] * cc + 255 * fr) + w * (cutC[0] * cw + 200 * fw);\n        G = stone[1] * l * (1 - c - w) + c * (cutC[1] * cc + 255 * fr) + w * (cutC[1] * cw + 200 * fw);\n        B = stone[2] * l * (1 - c - w) + c * (cutC[2] * cc + 250 * fr) + w * (cutC[2] * cw + 200 * fw);\n      }\n      F[o * 3] = R;\n      F[o * 3 + 1] = G;\n      F[o * 3 + 2] = B;\n    }\n  }\n  const add = (x, y, c, a) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    F[o] += c[0] * a;\n    F[o + 1] += c[1] * a;\n    F[o + 2] += c[2] * a;\n  };\n\n  // ---- The chisel point and its dust.\n  if (S.tip) {\n    const tx = S.tip[0], ty = Ye(S.tip[1]), fl = 0.75 + 0.25 * Math.random();\n    for (let dy = -3; dy \u003c= 3; dy++)\n      for (let dx = -3; dx \u003c= 3; dx++) {\n        const d = sqrt((dx + 0.5 - (tx - floor(tx))) ** 2 + (dy + 0.5 - (ty - floor(ty))) ** 2);\n        const a = cl(1 - d / 3, 0, 1);\n        if (a > 0) add(tx + dx, ty + dy, [255, 245, 220], a * a * fl);\n      }\n  }\n  for (const p of S.parts) add(p.x, Ye(p.v), gloss, 0.8 * min(1, p.life / 0.3));\n\n  // ---- The gloss: beside each letter, the letter its strokes spell so\n  // far, so a five-stroke N reads B, L, F, S and then N as it is cut.\n  for (const Lt of S.letters) {\n    const yc = Ye(Lt.mid);\n    if (yc \u003c -4 || yc > H + 4) continue;\n    let done = 0, last = -1;\n    for (let j = 0; j \u003c Lt.n; j++) {\n      const c = S.cuts[Lt.first + j];\n      if (S.t >= c.t0 + CUT) (done = j + 1), (last = c.t0 + CUT);\n    }\n    if (!done) continue;\n    const key = AICME[Lt.g][done - 1], age = (S.t - last) / S.rate;\n    const a = done === Lt.n ? 0.75 + 0.25 * exp(-age / 0.6) : 1;\n    const col = done === Lt.n ? gloss : [255, 250, 240];\n    let x0 = 4 - ((key.length * 4 - 1) >> 1);\n    const y0 = round(yc - 3);\n    for (const ch of key) {\n      const b = FONT[ch];\n      for (let j = 0; j \u003c 15; j++) if (b[j] === \"1\") add(x0 + (j % 3), y0 + floor(j / 3), col, a);\n      x0 += 4;\n    }\n  }\n\n  const g0 = S.dim;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(min(255, F[o] * g0)), round(min(255, F[o + 1] * g0)), round(min(255, F[o + 2] * g0)));\n}\n","palimpsest":"// ===== Patternflow pattern =====\n// Title:   Palimpsest\n// Family:  type\n// Idea:    A parchment leaf carries two Greek texts at right angles, a prayer written across the page in brown iron-gall ink over a scraped-off treatise of Archimedes that runs down it, and the imaging band sweeps from plain light, where the old text is a faint ghost, to ultraviolet, where the parchment glows and the old ink shows dark, to the pseudocolour view that turns the old text red and leaves the prayer dark, while an X-ray beam rasters down the leaf and lights the iron of both inks behind it.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Archimedes Palimpsest (Archimedes' treatises copied in the 10th century, scraped and written over as a prayer book in 1229; multispectral imaging by Roger Easton, Keith Knox and William Christens-Barry and X-ray fluorescence imaging by Uwe Bergmann in the 2000s), Greek minuscule drawn for this pattern, pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Band=0..1, Speed=0.2..3, Page=0..3, Ink=-1..1\n//\n// Knob 1: Band. The light the leaf is seen in. 0 to 0.15 is plain light: ivory parchment, brown prayer, the old text an ochre ghost 8% darker than the page in red and 25% in blue. 0.4 to 0.6 is ultraviolet: the parchment glows blue and the iron in both inks puts the glow out, the prayer down to 42% of the page and the old text to 65%. 0.85 to 1 is pseudocolour: the red-light picture in the red channel and the ultraviolet one in green and blue, so the old text, pale in red and dark in ultraviolet, comes out red, and the prayer, dark in both, near black. Between, one picture fades into the next.\n// Knob 2: Speed. How fast the X-ray beam steps down the leaf, a spot running along it: 26 rows a second at 2, a pass every 6.5 s; 2.6 rows a second at 0.2. For about 16 rows behind the beam the leaf shows its iron map, both inks pale blue on near black, the scraped text as plain as the prayer.\n// Knob 3: Page. Which pair of texts, rounded to 0 to 3. 0: the Trisagion over the title of the Method. 1: the Lord's Prayer over the title and first words of the Measurement of a Circle. 2: Kyrie eleison over On Floating Bodies. 3: Glory to thee, our God over the Stomachion.\n// Knob 4: Ink. How much of the old ink the scraper left and how far both inks have bled into the parchment. At -1 the prayer's strokes spread 0.5 LED and the old text's 0.35, and even in ultraviolet the old text is a thin line at 75% of the page; at 1 they spread 0.8 and 0.95 LED and the old text shows ochre-brown in plain light, 21% darker than the page in red and 59% in blue.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Greek minuscule, at most 5 LEDs wide on 9 rows: 0 and 1 hold ascenders,\n// 2 to 6 the body, 7 and 8 descenders. Each glyph is its first inked row and\n// then its rows downward. No accents or breathings.\nconst FONT = {\n  α: [2, \".##.#\", \"#..#.\", \"#..#.\", \"#..#.\", \".##.#\"],\n  β: [0, \".##.\", \"#..#\", \"#..#\", \"###.\", \"#..#\", \"#..#\", \"###.\", \"#...\", \"#...\"],\n  γ: [2, \"#...#\", \".#.#.\", \".#.#.\", \"..#..\", \"..#..\", \".#.#.\", \"..#..\"],\n  δ: [0, \".###\", \"#...\", \".##.\", \"#..#\", \"#..#\", \"#..#\", \".##.\"],\n  ε: [2, \".###\", \"#...\", \"###.\", \"#...\", \".###\"],\n  ζ: [0, \"####\", \"..#.\", \".#..\", \"#...\", \"#...\", \"#...\", \".##.\", \"...#\", \"..#.\"],\n  η: [2, \"###.\", \"#..#\", \"#..#\", \"#..#\", \"#..#\", \"...#\", \"...#\"],\n  θ: [0, \".##.\", \"#..#\", \"#..#\", \"####\", \"#..#\", \"#..#\", \".##.\"],\n  ι: [2, \"#.\", \"#.\", \"#.\", \"#.\", \".#\"],\n  κ: [2, \"#..#\", \"#.#.\", \"##..\", \"#.#.\", \"#..#\"],\n  λ: [0, \"#....\", \"#....\", \".#...\", \".#...\", \"..#..\", \".#.#.\", \"#...#\"],\n  μ: [2, \"#..#.\", \"#..#.\", \"#..#.\", \"#..#.\", \"###.#\", \"#....\", \"#....\"],\n  ν: [2, \"#...#\", \"#...#\", \".#..#\", \".#.#.\", \"..#..\"],\n  ξ: [0, \"####\", \".#..\", \"..#.\", \".##.\", \"#...\", \"#...\", \".##.\", \"...#\", \"..#.\"],\n  ο: [2, \".##.\", \"#..#\", \"#..#\", \"#..#\", \".##.\"],\n  π: [2, \"#####\", \".#.#.\", \".#.#.\", \".#.#.\", \".#.#.\"],\n  ρ: [2, \".##.\", \"#..#\", \"#..#\", \"#..#\", \"###.\", \"#...\", \"#...\"],\n  σ: [2, \".####\", \"#..#.\", \"#..#.\", \"#..#.\", \".##..\"],\n  ς: [2, \".###\", \"#...\", \"#...\", \".##.\", \"...#\", \"..#.\"],\n  τ: [2, \"####\", \".#..\", \".#..\", \".#..\", \"..##\"],\n  υ: [2, \"#..#\", \"#..#\", \"#..#\", \"#..#\", \".##.\"],\n  φ: [0, \"..#..\", \"..#..\", \".###.\", \"#.#.#\", \"#.#.#\", \"#.#.#\", \".###.\", \"..#..\", \"..#..\"],\n  χ: [2, \"#...#\", \".#.#.\", \"..#..\", \".#.#.\", \"#...#\"],\n  ψ: [0, \"..#..\", \"..#..\", \"#.#.#\", \"#.#.#\", \"#.#.#\", \".###.\", \"..#..\", \"..#..\", \"..#..\"],\n  ω: [2, \"#...#\", \"#...#\", \"#.#.#\", \"#.#.#\", \".#.#.\"],\n};\nconst GLYPH = {};\nfor (const ch in FONT) {\n  const [top, ...rows] = FONT[ch];\n  const w = max(...rows.map((r) => r.length)), px = [];\n  rows.forEach((r, j) => {\n    for (let i = 0; i \u003c r.length; i++) if (r[i] === \"#\") px.push(i, top + j);\n  });\n  GLYPH[ch] = { w, px };\n}\n\n// The pairs of texts: a prayer written across the leaf over the title or\n// opening words of one of Archimedes' treatises running down it. The words\n// repeat until the leaf is full. A sigma that ends a word is written final.\nconst PAGES = [\n  [\"αγιοσ ο θεοσ αγιοσ ισχυροσ αγιοσ αθανατοσ ελεησον ημασ\", \"περι των μηχανικων θεωρηματων προσ ερατοσθενη εφοδοσ\"],\n  [\"πατερ ημων ο εν τοισ ουρανοισ αγιασθητω το ονομα σου ελθετω η βασιλεια σου\", \"κυκλου μετρησισ πασ κυκλοσ ισοσ εστι τριγωνω ορθογωνιω\"],\n  [\"κυριε ελεησον\", \"περι οχουμενων\"],\n  [\"δοξα σοι ο θεοσ ημων δοξα σοι\", \"στομαχιον\"],\n].map((pair) => pair.map((t) => t.split(\" \").map((w) => w.replace(/σ$/, \"ς\"))));\n\n// The prayer: 12 lines 10 LEDs apart, 60 LEDs long from x 2. The treatise:\n// 5 lines 12 LEDs apart, the first at the right, each 124 LEDs long from y 2,\n// its letters turned a quarter turn clockwise so it reads downward.\nconst LINE = 10, OVER_LINES = 12, UNDER_LINE = 12, UNDER_LINES = 5, SPACE = 3;\n// Plain light: the parchment's colour, how much of each channel the prayer's\n// ink takes at full strength, and the grain, a share of the page's level.\nconst VIS = [226, 208, 168], INK = [0.62, 0.72, 0.84], GRAIN = 0.08;\n\nfunction lay(words, len, lines, put) {\n  // The words run on without a break, as a scribe filled a line: a word\n  // that reaches the end of a line goes on at the start of the next.\n  const text = words.join(\" \") + \" \";\n  let i = 0, line = 0, pos = 0;\n  while (line \u003c lines) {\n    const ch = text[i++ % text.length];\n    if (ch === \" \") {\n      if (pos > 0) pos += SPACE;\n      continue;\n    }\n    const g = GLYPH[ch];\n    if (pos + g.w > len) (line++, (pos = 0));\n    if (line >= lines) break;\n    // Pen pressure: each letter its own weight.\n    put(g, line, pos, 0.8 + 0.2 * Math.random());\n    pos += g.w + 1;\n  }\n}\n\n// Separable Gaussian blur of src into dst, sigma in LEDs.\nfunction blur(src, dst, tmp, sigma) {\n  const r = Math.ceil(sigma * 2.5), k = [];\n  let sum = 0;\n  for (let i = -r; i \u003c= r; i++) (k.push(exp((-i * i) / (2 * sigma * sigma))), (sum += k[k.length - 1]));\n  for (let i = 0; i \u003c k.length; i++) k[i] /= sum;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let v = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const xx = x + i;\n        if (xx >= 0 && xx \u003c W) v += src[y * W + xx] * k[i + r];\n      }\n      tmp[y * W + x] = v;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let v = 0;\n      for (let i = -r; i \u003c= r; i++) {\n        const yy = y + i;\n        if (yy >= 0 && yy \u003c H) v += tmp[yy * W + x] * k[i + r];\n      }\n      dst[y * W + x] = v;\n    }\n}\n\n// Smooth value noise from a coarse random lattice, cell size c.\nfunction lattice(c) {\n  const gw = floor(W / c) + 2, gh = floor(H / c) + 2, g = new Float32Array(gw * gh), out = new Float32Array(N);\n  for (let i = 0; i \u003c g.length; i++) g[i] = Math.random() * 2 - 1;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const fx = x / c, fy = y / c, ix = floor(fx), iy = floor(fy), u = smooth(fx - ix), v = smooth(fy - iy);\n      const a = g[iy * gw + ix], b = g[iy * gw + ix + 1], d = g[(iy + 1) * gw + ix], e = g[(iy + 1) * gw + ix + 1];\n      out[y * W + x] = (a + (b - a) * u) * (1 - v) + (d + (e - d) * u) * v;\n    }\n  return out;\n}\n\n// Grain whose neighbours keep apart: white noise with its local mean taken\n// out twice, each time spread back evenly over -1..1 by rank, then cut into\n// three equal parts, -1, 0 and 1. It has no clumps, and two neighbours\n// differ by a whole step four times in five.\nfunction grain() {\n  let n = new Float32Array(N);\n  for (let p = 0; p \u003c N; p++) n[p] = Math.random();\n  const idx = new Int32Array(N);\n  for (let pass = 0; pass \u003c 2; pass++) {\n    const h = new Float32Array(N);\n    for (let p = 0; p \u003c N; p++) {\n      const x = p % W, y = floor(p / W);\n      h[p] = n[p] - 0.25 * (n[y * W + ((x + 1) % W)] + n[y * W + ((x + W - 1) % W)] + n[((y + 1) % H) * W + x] + n[((y + H - 1) % H) * W + x]);\n    }\n    for (let p = 0; p \u003c N; p++) idx[p] = p;\n    idx.sort((a, b) => h[a] - h[b]);\n    for (let r = 0; r \u003c N; r++) n[idx[r]] = ((r + 0.5) / N) * 2 - 1;\n  }\n  for (let p = 0; p \u003c N; p++) n[p] = n[p] > 1 / 3 ? 1 : n[p] \u003c -1 / 3 ? -1 : 0;\n  return n;\n}\n\nexport function setup(params) {\n  // The parchment: a slow mottle in 2% steps, fibres that drink the ink\n  // unevenly, and a leaf edge that has gone darker. The grain goes on in\n  // build(), where the ink is known.\n  const base = new Float32Array(N), vig = new Float32Array(N), fibre = new Float32Array(N);\n  const m1 = lattice(16), m2 = lattice(5), f = lattice(2);\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W);\n    const edge = min(x + 0.5, W - 0.5 - x, y + 0.5, H - 0.5 - y);\n    base[p] = round((0.9 + 0.06 * m1[p] + 0.035 * m2[p]) * 50) / 50;\n    vig[p] = 0.72 + 0.28 * smooth(edge / 4);\n    fibre[p] = 0.85 + 0.15 * f[p];\n  }\n  params.s = {\n    P: new Float32Array(N), base, vig, gr: grain(), fibre,\n    oMask: new Float32Array(N), uMask: new Float32Array(N), tmp: new Float32Array(N),\n    O: new Float32Array(N), U: new Float32Array(N), Fe: new Float32Array(N),\n    last: new Float32Array(N * 3), fade: 1,\n    page: -1, ink: 9, band: 0, speed: 2, T: 0, beam: -12,\n  };\n}\n\nfunction build(S, page, ink) {\n  const { oMask, uMask } = S;\n  if (page !== S.page) {\n    oMask.fill(0);\n    uMask.fill(0);\n    const [over, under] = PAGES[page];\n    lay(over, 60, OVER_LINES, (g, line, pos, wt) => {\n      for (let i = 0; i \u003c g.px.length; i += 2) {\n        const x = 2 + pos + g.px[i], y = 4 + line * LINE + g.px[i + 1];\n        if (x \u003c W && y \u003c H) oMask[y * W + x] = wt;\n      }\n    });\n    lay(under, 124, UNDER_LINES, (g, line, pos, wt) => {\n      const left = 51 - line * UNDER_LINE;\n      for (let i = 0; i \u003c g.px.length; i += 2) {\n        const x = left + 8 - g.px[i + 1], y = 2 + pos + g.px[i];\n        if (x >= 0 && y \u003c H) uMask[y * W + x] = wt;\n      }\n    });\n  }\n  const s = (ink + 1) / 2;\n  blur(oMask, S.O, S.tmp, 0.5 + 0.3 * s);\n  blur(uMask, S.U, S.tmp, 0.35 + 0.6 * s);\n  // The X-ray map sees the iron, not the colour: the old text's iron is\n  // still there where the scraper took the colour, and the beam is broader\n  // than a pen stroke.\n  const { O, U, Fe, tmp, fibre } = S;\n  const iron = 0.55 + 0.35 * s;\n  for (let p = 0; p \u003c N; p++) Fe[p] = oMask[p] + iron * uMask[p];\n  blur(Fe, Fe, tmp, 0.75);\n  for (let p = 0; p \u003c N; p++) {\n    O[p] = 1 - exp(-3.4 * O[p] * fibre[p]);\n    U[p] = 1 - exp(-2.8 * U[p] * fibre[p]);\n    Fe[p] = 1 - exp(-2.6 * Fe[p]);\n  }\n  // The grain, except on the flanks of a stroke, where the ink has\n  // soaked in and the step from page to ink is the texture.\n  const { P, base, vig, gr } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), o = O[p];\n    let d = 0;\n    if (x > 0) d = max(d, abs(o - O[p - 1]));\n    if (x \u003c W - 1) d = max(d, abs(o - O[p + 1]));\n    if (y > 0) d = max(d, abs(o - O[p - W]));\n    if (y \u003c H - 1) d = max(d, abs(o - O[p + W]));\n    P[p] = (base[p] + GRAIN * gr[p] * (1 - smooth(d / 0.5))) * vig[p];\n  }\n  S.page = page;\n  S.ink = ink;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.band = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.05, 3);\n  const page = cl(round(k[2]), 0, PAGES.length - 1);\n  const ink = cl(k[3], -1, 1);\n  if (page !== S.page || abs(ink - S.ink) > 0.015) {\n    if (S.page >= 0 && page !== S.page) S.fade = 0;\n    build(S, page, ink);\n  }\n  S.fade = min(1, S.fade + dt / 0.6);\n  S.T += dt;\n  // The beam steps down 13 rows a second per unit of Speed and starts again\n  // above the leaf once it has left the bottom.\n  S.beam += dt * 13 * S.speed;\n  if (S.beam > H + 30) S.beam -= H + 42;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (S.page \u003c 0) return;\n  const { P, O, U, Fe, gr, last, T } = S;\n  const s = (S.ink + 1) / 2;\n  // How much the old ink darkens each picture.\n  const aVis = 0.12 + 0.9 * s * s, aRed = 0.3 * aVis, qUV = 0.35 + 0.55 * s;\n  // Band weights: plain light, ultraviolet, pseudocolour.\n  const b = S.band;\n  const tU = smooth((b - 0.15) / 0.25), tP = smooth((b - 0.6) / 0.25);\n  const wV = 1 - tU, wP = tP, wU = tU - tP;\n  const beam = S.beam, spot = (T * 150) % (W + 20) - 10;\n  const fade = smooth(S.fade);\n  for (let y = 0; y \u003c H; y++) {\n    // The iron map behind the beam: full for 10 rows, then fading.\n    const d = beam - y;\n    const xr = d \u003c 0 ? exp(-d * d * 0.5) : d \u003c 10 ? 1 : exp(-(d - 10) / 6);\n    const line = abs(d) \u003c 2 ? 1 - abs(d) / 2 : 0;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, pa = P[p], o = O[p], u = U[p];\n      let r = 0, g = 0, bl = 0;\n      if (wV > 0) {\n        // Plain light: iron-gall brown absorbs blue more than red, and the\n        // faded old ink is a pale ochre.\n        r += wV * VIS[0] * pa * (1 - INK[0] * o) * (1 - 0.35 * aVis * u);\n        g += wV * VIS[1] * pa * (1 - INK[1] * o) * (1 - 0.6 * aVis * u);\n        bl += wV * VIS[2] * pa * (1 - INK[2] * o) * (1 - aVis * u);\n      }\n      // Ultraviolet: the parchment fluoresces; any iron left quenches it.\n      const F = pa * (1 - 0.88 * o) * (1 - qUV * u);\n      if (wU > 0) {\n        r += wU * (20 + 90 * F);\n        g += wU * (24 + 120 * F);\n        bl += wU * (40 + 200 * F);\n      }\n      if (wP > 0) {\n        // Pseudocolour: red light in red, ultraviolet in green and blue,\n        // both stretched the same way.\n        const R = cl((pa * (1 - 0.85 * o) * (1 - aRed * u) - 0.2) * 1.35, 0, 1);\n        const G = cl((F - 0.2) * 1.35, 0, 1);\n        r += wP * 216 * R;\n        g += wP * 196 * G;\n        bl += wP * 200 * G;\n      }\n      if (xr > 0.004) {\n        // X-ray fluorescence: iron in either ink, pale blue on near black.\n        // Counting noise: the map is speckled where there is little iron.\n        const fe = Fe[p], sn = (1 - fe) * gr[p];\n        const k2 = xr * (0.9 + 0.1 * pa);\n        r += k2 * (14 + 6 * sn + 112 * fe - r);\n        g += k2 * (22 + 9 * sn + 176 * fe - g);\n        bl += k2 * (44 + 16 * sn + 196 * fe - bl);\n      }\n      if (line > 0) {\n        const sp = abs(x - spot) \u003c 3 ? 1 - abs(x - spot) / 3 : 0;\n        r += line * (30 + 120 * sp);\n        g += line * (44 + 140 * sp);\n        bl += line * (52 + 150 * sp);\n      }\n      if (fade \u003c 1) {\n        r = last[p * 3] + (r - last[p * 3]) * fade;\n        g = last[p * 3 + 1] + (g - last[p * 3 + 1]) * fade;\n        bl = last[p * 3 + 2] + (bl - last[p * 3 + 2]) * fade;\n      } else {\n        last[p * 3] = r;\n        last[p * 3 + 1] = g;\n        last[p * 3 + 2] = bl;\n      }\n      display.setPixel(x, y, min(255, max(0, r)), min(255, max(0, g)), min(255, max(0, bl)));\n    }\n  }\n}\n","parallel-transport":"// ===== Patternflow pattern =====\n// Title:   Parallel Transport\n// Family:  space\n// Idea:    A lit globe turns on the upper half and a gold arrow is carried round a loop on it without ever turning, leaving ghost arrows behind and tinting the area its loop has swept, and when the loop closes the arrow stands beside its white starting self turned by exactly that area, which a dial on the lower half has been adding up all the way round.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: parallel transport (Tullio Levi-Civita, 1917), its holonomy as enclosed area by Gauss-Bonnet (Carl Friedrich Gauss, 1827; Pierre Ossian Bonnet, 1848), Foucault's pendulum (Léon Foucault, 1851), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Loop=0..3, Size=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together: at 0 the globe is blue, the arrow gold, the swept area rose and the area swept backwards sea green; the globe keeps to the hues from green to violet so it never dims to brown.\n// Knob 2: Speed. At 2 the arrow goes round its loop in 6 s, then holds 2.6 s and fades 0.6 s before it starts again; at 0.2 a lap takes 60 s, at 3 it takes 4 s.\n// Knob 3: Loop. 0 the triangle from the north pole down a meridian, along the equator and back up another, which turns the arrow by its angle at the pole; 1 a circle of latitude, which turns it by 2 pi (1 - sin latitude), the same as 2 pi sin latitude the other way, the turn of Foucault's pendulum in a sidereal day; 2 a small geodesic square, whose four corners are each a little over 90 degrees and turn it by their excess; 3 two circles touching at a point, the first run counterclockwise and the second clockwise, so their areas cancel.\n// Knob 4: Size. The triangle's angle at the pole from 10 to 170 degrees, 90 at the opening 0.06; the latitude from 8 degrees (turn 309.9) to 85 (turn 1.4), 48.85 at 0.06, the Pantheon in Paris, turn 88.9; the square's centre to corner from 2 degrees (turn 0.14) to 30 (turn 32.8), 8 at 0.06, turn 2.2; the two circles 11 and 33 degrees at -1 (turn -51.5), both 22 at 0.06 (turn 0), 33 and 11 at 1 (turn 51.5).\n\nconst W = 64, H = 128, TOP = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, acos, asin, exp, log, round, PI } = Math;\nconst TAU = 2 * PI, DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst fr = (x) => x - floor(x);\nconst wrap = (a) => a - TAU * round(a / TAU);\n\nfunction hsv(h, s, v, o) {\n  h = fr(h) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// Points and tangent vectors are plain [x, y, z] on the unit sphere, z north.\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst crs = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst nrm = (a) => {\n  const l = sqrt(dot(a, a)) || 1;\n  return [a[0] / l, a[1] / l, a[2] / l];\n};\nconst lin = (a, ka, b, kb) => [a[0] * ka + b[0] * kb, a[1] * ka + b[1] * kb, a[2] * ka + b[2] * kb];\nconst sph = (lat, lon) => [cos(lat) * cos(lon), cos(lat) * sin(lon), sin(lat)];\n\n// Parallel transport of a tangent vector v at a along the great circle to b.\n// It is the rotation about a x b that takes a to b, so it is exact for any\n// step; a loop sampled at 900 points is carried exactly round the geodesic\n// polygon through them.\nfunction carry(a, b, v) {\n  const d = dot(v, b) / (1 + dot(a, b));\n  return [v[0] - d * (a[0] + b[0]), v[1] - d * (a[1] + b[1]), v[2] - d * (a[2] + b[2])];\n}\n// Signed angle from u to v about the outward normal n, counterclockwise as\n// seen from outside the sphere.\nconst ang = (u, v, n) => atan2(dot(crs(u, v), n), dot(u, v));\n\n// Pieces of a loop: a great arc from a to b, or an arc of the small circle of\n// angular radius r about c, from x through the signed angle sweep.\nfunction gArc(a, b) {\n  const w = acos(cl(dot(a, b), -1, 1)), s = sin(w);\n  return { len: w, at: (t) => lin(a, sin((1 - t) * w) / s, b, sin(t * w) / s) };\n}\nfunction cArc(c, r, x, sweep) {\n  const e1 = nrm(lin(x, 1, c, -dot(x, c))), e2 = crs(c, e1);\n  return { len: abs(sweep) * sin(r), at: (t) => lin(c, cos(r), lin(e1, cos(sweep * t), e2, sin(sweep * t)), sin(r)) };\n}\n\n// Size runs -1..1 and opens at 0.06; pivot puts lo, mid, hi at -1, 0.06, 1.\nconst pivot = (u, lo, mid, hi) => (u \u003c 0.06 ? mid + ((lo - mid) * (0.06 - u)) / 1.06 : mid + ((hi - mid) * (u - 0.06)) / 0.94);\n\nconst KS = 900, NB = 720;\n\n// The loop, the arrow carried round it, the gauge it is measured against and\n// the area swept so far. The gauge at a point is the start arrow carried\n// back to the fan centre c and out again along great circles; the angle from\n// the gauge to the carried arrow is then the holonomy of the closed path\n// c, start, along the loop, here, c, which is the area of the fan from c over\n// the loop so far. At the end the gauge is the start arrow itself.\nfunction build(S, which, u) {\n  const N = [0, 0, 1];\n  let pieces, c, rb, want;\n  if (which === 0) {\n    const th = pivot(u, 10, 90, 170) * DEG, A = sph(0, -th / 2), B = sph(0, th / 2);\n    pieces = [gArc(N, A), gArc(A, B), gArc(B, N)];\n    c = nrm(lin(lin(N, 1, A, 1), 1, B, 1));\n    rb = acos(dot(c, A)), want = th;\n  } else if (which === 1) {\n    const ph = pivot(u, 8, 48.85, 85) * DEG;\n    pieces = [cArc(N, PI / 2 - ph, sph(ph, -0.6), TAU)];\n    c = N, rb = PI / 2 - ph, want = TAU * (1 - sin(ph));\n  } else if (which === 2) {\n    const rho = exp(pivot(u, log(2), log(8), log(30))) * DEG, la = 0.35;\n    c = sph(la, 0);\n    const e1 = [-sin(la), 0, cos(la)], e2 = crs(c, e1);\n    const V = (a) => lin(c, cos(rho), lin(e1, cos(a), e2, sin(a)), sin(rho));\n    const q = PI / 4, M = nrm(lin(V(3 * q), 1, V(5 * q), 1));\n    pieces = [gArc(M, V(5 * q)), gArc(V(5 * q), V(7 * q)), gArc(V(7 * q), V(q)), gArc(V(q), V(3 * q)), gArc(V(3 * q), M)];\n    rb = rho, want = 8 * Math.atan(1 / cos(rho)) - TAU;\n  } else {\n    const d = pivot(u, -0.5, 0, 0.5), r1 = 22 * DEG * (1 + d), r2 = 22 * DEG * (1 - d), P = sph(0.3, 0), E = [0, 1, 0];\n    const c1 = lin(P, cos(r1), E, sin(r1)), c2 = lin(P, cos(r2), E, -sin(r2)), F = cArc(c1, r1, P, -PI / 2).at(1);\n    // From the top of the first circle a quarter round to P, the second\n    // circle clockwise, then the rest of the first.\n    pieces = [cArc(c1, r1, F, PI / 2), cArc(c2, r2, P, -TAU), cArc(c1, r1, P, 1.5 * PI)];\n    c = P, rb = 2 * max(r1, r2), want = TAU * (cos(r2) - cos(r1));\n  }\n  let L = 0;\n  for (const p of pieces) L += p.len;\n  const ns = pieces.map((p) => max(4, round((KS * p.len) / L)));\n  const K = ns.reduce((a, b) => a + b, 0);\n  const P = new Float64Array(3 * (K + 1)), V = new Float64Array(3 * (K + 1));\n  const cum = new Float64Array(K + 1), psi = new Float64Array(K + 1), area = new Float64Array(K + 1);\n  let k = 0, prev = pieces[0].at(0);\n  P.set(prev, 0);\n  pieces.forEach((pc, i) => {\n    for (let j = 1; j \u003c= ns[i]; j++) {\n      const q = nrm(pc.at(j / ns[i]));\n      k++;\n      P.set(q, 3 * k);\n      cum[k] = cum[k - 1] + acos(cl(dot(prev, q), -1, 1));\n      prev = q;\n    }\n  });\n  const pt = (i) => [P[3 * i], P[3 * i + 1], P[3 * i + 2]];\n  const p0 = pt(0), t0 = nrm(lin(pt(1), 1, p0, -dot(pt(1), p0)));\n  // The arrow starts pointing back over the loop's right side, 135 degrees\n  // clockwise from the way it goes, so neither it nor the returned arrow lies\n  // along a leg at the openings.\n  let v = lin(t0, -Math.SQRT1_2, crs(p0, t0), -Math.SQRT1_2), g = carry(p0, c, v), ps = 0, ar = 0, last = 0;\n  V.set(v, 0);\n  // Azimuth bins about c remember which sample first swept them, how far\n  // from c the loop is there and which way it went.\n  const e1 = nrm(abs(c[2]) \u003c 0.9 ? crs([0, 0, 1], c) : crs([1, 0, 0], c)), e2 = crs(c, e1);\n  const bk = new Int32Array(NB).fill(-1), br = new Float32Array(NB), bs = new Int8Array(NB);\n  const azi = (p) => atan2(dot(p, e2), dot(p, e1));\n  for (let i = 0; i \u003c K; i++) {\n    const a = pt(i), b = pt(i + 1);\n    v = nrm(carry(a, b, v));\n    V.set(v, 3 * (i + 1));\n    const G = carry(c, b, g), x = ang(G, v, b);\n    ps += wrap(x - last), last = x, psi[i + 1] = ps;\n    const det = dot(c, crs(a, b));\n    ar += 2 * atan2(det, 1 + dot(c, a) + dot(a, b) + dot(b, c));\n    area[i + 1] = ar;\n    const da = acos(cl(dot(a, c), -1, 1)), db = acos(cl(dot(b, c), -1, 1));\n    if (da \u003c 2e-3 || db \u003c 2e-3) continue;\n    const za = azi(a), dz = wrap(azi(b) - za), sg = dz >= 0 ? 1 : -1;\n    const ia = floor(((za + PI) / TAU) * NB), n = round(abs(dz / TAU) * NB);\n    for (let j = 0; j \u003c= n; j++) {\n      const bb = (((ia + sg * j) % NB) + NB) % NB;\n      if (bk[bb] \u003c 0) (bk[bb] = i), (br[bb] = da + ((db - da) * j) / max(1, n)), (bs[bb] = sg);\n    }\n  }\n  Object.assign(S, { which, u, K, P, V, cum, psi, area, L, c, e1, e2, bk, br, bs, rb, want });\n  S.zoomT = max(1, (which === 2 ? 20 : 13) / (30 * sin(min(rb, PI / 2))));\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, which: -1, u: 0.06, s: 0, phase: 0, pt: 0, fresh: 1,\n    vlat: 0, vlon: 0, zoom: 1, buf: new Float32Array(W * H * 3), col: [0, 0, 0],\n  });\n  build(S, 0, 0.06);\n  return S;\n}\n\nfunction sampleAt(S, s) {\n  let lo = 0, hi = S.K;\n  while (hi - lo > 1) {\n    const m = (lo + hi) >> 1;\n    if (S.cum[m] \u003c= s) lo = m;\n    else hi = m;\n  }\n  const f = cl((s - S.cum[lo]) / max(1e-9, S.cum[hi] - S.cum[lo]), 0, 1), P = S.P, V = S.V, a = 3 * lo, b = 3 * hi;\n  const p = nrm([P[a] + (P[b] - P[a]) * f, P[a + 1] + (P[b + 1] - P[a + 1]) * f, P[a + 2] + (P[b + 2] - P[a + 2]) * f]);\n  let v = [V[a] + (V[b] - V[a]) * f, V[a + 1] + (V[b + 1] - V[a + 1]) * f, V[a + 2] + (V[b + 2] - V[a + 2]) * f];\n  v = nrm(lin(v, 1, p, -dot(v, p)));\n  return { p, v, k: lo, f, psi: S.psi[lo] + (S.psi[hi] - S.psi[lo]) * f, area: S.area[lo] + (S.area[hi] - S.area[lo]) * f };\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1] ?? 2, 0.2, 3);\n  const which = cl(round(kv[2] || 0), 0, 3), u = cl(kv[3] ?? 0.06, -1, 1);\n  if (which !== S.which || abs(u - S.u) > 0.002) build(S, which, u);\n  // A lap takes 12 / Speed seconds; the hold and the fade shorten more gently.\n  const slow = sqrt(2 / S.speed);\n  if (S.phase === 0) {\n    S.s += (S.speed / 12) * d;\n    if (S.s >= 1) (S.s = 1), (S.phase = 1), (S.pt = 0);\n  } else {\n    S.pt += d / slow;\n    if (S.pt > 3.2) (S.phase = 0), (S.s = 0);\n  }\n  // The view looks at a point between the fan centre and the arrow, from\n  // above the latitude it is at, north up; small loops are looked at whole\n  // and zoomed in until they are 13 LEDs across or more.\n  const now = sampleAt(S, S.s * S.L);\n  // Near the close it turns to the start point, so the two arrows face us.\n  const big = S.rb > 0.6 && S.which !== 3, w = big ? 1.3 + 3.7 * cl((S.s - 0.8) / 0.2, 0, 1) : S.which === 3 ? 0.8 * (1 - S.s) : 0;\n  const tv = nrm(lin(S.c, 1, now.p, w));\n  const tlat = cl(asin(tv[2]), -1.5, 1.5), tlon = atan2(tv[1], tv[0]) + (0.16 * sin(0.33 * S.t)) / S.zoom;\n  if (S.fresh) (S.vlat = tlat), (S.vlon = tlon), (S.zoom = S.zoomT), (S.fresh = 0);\n  const e = 1 - exp(-1.8 * d);\n  S.vlat += (tlat - S.vlat) * e;\n  S.vlon += wrap(tlon - S.vlon) * e;\n  S.zoom *= exp(log(S.zoomT / S.zoom) * e);\n  S.now = now;\n}\n\n// Additive drawing into the float buffer, clipped to the rows lo..hi-1.\nfunction splat(B, x, y, r, g, b, lo, hi) {\n  const i = floor(x - 0.5), j = floor(y - 0.5), fx = x - 0.5 - i, fy = y - 0.5 - j;\n  for (let q = 0; q \u003c 4; q++) {\n    const ii = i + (q & 1), jj = j + (q >> 1);\n    if (ii \u003c 0 || ii >= W || jj \u003c lo || jj >= hi) continue;\n    const w = (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy), k = (jj * W + ii) * 3;\n    B[k] += r * w, B[k + 1] += g * w, B[k + 2] += b * w;\n  }\n}\nfunction line(B, x0, y0, x1, y1, r, g, b, lo, hi) {\n  const len = sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)), n = max(1, ceil(len / 0.4)), w = max(len, 0.4) / n;\n  for (let i = 0; i \u003c n; i++) {\n    const f = (i + 0.5) / n;\n    splat(B, x0 + (x1 - x0) * f, y0 + (y1 - y0) * f, r * w, g * w, b * w, lo, hi);\n  }\n}\n\n// 3x5 glyphs, rows of three bits, 4 the left column.\nconst FONT = {\n  0: [7, 5, 5, 5, 7], 1: [2, 6, 2, 2, 7], 2: [7, 1, 7, 4, 7], 3: [7, 1, 3, 1, 7], 4: [5, 5, 7, 1, 1],\n  5: [7, 4, 7, 1, 7], 6: [7, 4, 7, 5, 7], 7: [7, 1, 1, 2, 2], 8: [7, 5, 7, 5, 7], 9: [7, 5, 7, 1, 7],\n  '-': [0, 0, 7, 0, 0], '.': [0, 0, 0, 0, 4], 'o': [2, 5, 2, 0, 0], ' ': [0, 0, 0, 0, 0],\n  T: [7, 2, 2, 2, 2], U: [5, 5, 5, 5, 7], R: [6, 5, 6, 5, 5], N: [6, 5, 5, 5, 5], A: [2, 5, 7, 5, 5], E: [7, 4, 6, 4, 7], '=': [0, 7, 0, 7, 0],\n};\nconst sc = (v) => (v \u003c 0.85 ? v : 0.85 + 0.15 * (1 - exp(-(v - 0.85) / 0.15)));\nconst gw = (ch) => (ch === '.' ? 1 : 3);\nfunction text(B, str, cx, y, r, g, b) {\n  let wd = -1;\n  for (const ch of str) wd += gw(ch) + 1;\n  let x = round(cx - wd / 2);\n  for (const ch of str) {\n    const gl = FONT[ch] || FONT[' '];\n    for (let row = 0; row \u003c 5; row++)\n      for (let col = 0; col \u003c gw(ch); col++)\n        if ((gl[row] >> (gw(ch) === 1 ? 2 : 2 - col)) & 1) {\n          const k = ((y + row) * W + x + col) * 3;\n          if (x + col >= 0 && x + col \u003c W) (B[k] += r), (B[k + 1] += g), (B[k + 2] += b);\n        }\n    x += gw(ch) + 1;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.now) return;\n  const B = S.buf, col = S.col, now = S.now, t = S.t;\n  B.fill(0);\n  const CX = 32, CY = 32, Rz = 30 * S.zoom;\n  const f = sph(S.vlat, S.vlon), rt = [-sin(S.vlon), cos(S.vlon), 0];\n  const up = [-sin(S.vlat) * cos(S.vlon), -sin(S.vlat) * sin(S.vlon), cos(S.vlat)];\n  const proj = (p) => [CX + Rz * dot(p, rt), CY - Rz * dot(p, up), dot(p, f)];\n  const fade = S.phase === 1 ? cl((3.2 - S.pt) / 0.6, 0, 1) : 1;\n  // Colours.\n  const bh = 0.3 + 0.55 * fr(S.hue + 0.52);\n  const body = hsv(bh, 0.7, 1, [0, 0, 0]), grid = hsv(bh, 0.3, 1, [0, 0, 0]);\n  const gold = hsv(S.hue + 0.13, 0.75, 1, [0, 0, 0]), pos = hsv(S.hue + 0.92, 0.6, 1, [0, 0, 0]), neg = hsv(S.hue + 0.45, 0.7, 1, [0, 0, 0]);\n  const pale = hsv(S.hue + 0.13, 0.2, 1, [0, 0, 0]);\n  // Graticule spacing: the coarsest of 30, 15, 10, 5, 2.5, 1 degrees that\n  // still leaves 9 LEDs between lines.\n  let gs = 30;\n  for (const g of [1, 2.5, 5, 10, 15, 30])\n    if (g * DEG * Rz >= 9) {\n      gs = g;\n      break;\n    }\n  const gr = gs * DEG;\n  // The globe, lit from the upper left; the swept fan tinted.\n  const Lx = -0.45, Ly = 0.5, Lz = 0.74, kNow = S.phase === 0 ? now.k : S.K;\n  const { c, e1, e2, bk, br, bs } = S;\n  for (let y = 0; y \u003c TOP; y++) {\n    const b = (CY - y - 0.5) / Rz;\n    for (let x = 0; x \u003c W; x++) {\n      const a = (x + 0.5 - CX) / Rz, q = a * a + b * b;\n      if (q >= 1) continue;\n      const z = sqrt(1 - q), edge = cl((1 - sqrt(q)) * Rz * 1.5, 0, 1);\n      const p = [a * rt[0] + b * up[0] + z * f[0], a * rt[1] + b * up[1] + z * f[1], a * rt[2] + b * up[2] + z * f[2]];\n      const sh = max(0, a * Lx + b * Ly + z * Lz), lit = 0.08 + 0.42 * sh * sh;\n      const lat = asin(cl(p[2], -1, 1)), lon = atan2(p[1], p[0]);\n      // Meridians close up toward the poles, so every second, fourth, ...\n      // one is dropped where they would come nearer than 9 LEDs.\n      const cg = gr * cos(lat) * Rz, mg = gr * (cg >= 9 ? 1 : min(64, 2 ** ceil(Math.log2(9 / max(cg, 0.01)))));\n      const dl = abs(lat / gr - round(lat / gr)) * gr * Rz, dm = abs(lon / mg - round(lon / mg)) * mg * cos(lat) * Rz;\n      const gl = max(0, 1 - dl / 0.8, 1 - dm / 0.8) * (0.07 + 0.1 * sh);\n      let tr = 0, tg = 0, tb = 0;\n      const zc = atan2(dot(p, e2), dot(p, e1)), bb = floor(((zc + PI) / TAU) * NB) % NB, kk = bk[bb];\n      if (kk >= 0 && kk \u003c kNow) {\n        const dd = acos(cl(dot(p, c), -1, 1)), m = cl((br[bb] - dd) * Rz + 0.5, 0, 1) * fade * (0.16 + 0.14 * sh);\n        const tc = bs[bb] > 0 ? pos : neg;\n        (tr = tc[0] * m), (tg = tc[1] * m), (tb = tc[2] * m);\n      }\n      const k = (y * W + x) * 3;\n      B[k] = (body[0] * lit + grid[0] * gl + tr) * edge;\n      B[k + 1] = (body[1] * lit + grid[1] * gl + tg) * edge;\n      B[k + 2] = (body[2] * lit + grid[2] * gl + tb) * edge;\n    }\n  }\n  // The loop: bright where the arrow has been, dim ahead of it.\n  const P = S.P, V = S.V;\n  let q0 = proj([P[0], P[1], P[2]]);\n  for (let i = 1; i \u003c= S.K; i++) {\n    const q1 = proj([P[3 * i], P[3 * i + 1], P[3 * i + 2]]);\n    if (q0[2] > 0 && q1[2] > 0) {\n      const w = (i \u003c= kNow ? 0.5 : 0.22) * (0.4 + 0.6 * fade);\n      line(B, q0[0], q0[1], q1[0], q1[1], pale[0] * w, pale[1] * w, pale[2] * w, 0, TOP);\n    }\n    q0 = q1;\n  }\n  // An arrow: a great-circle shaft 10 LEDs long and a head of two 4 LED barbs.\n  const Lr = 0.34 / S.zoom, Lh = 0.42 * Lr;\n  const arrow = (p, v, cc, w) => {\n    let a = proj(p);\n    if (a[2] \u003c= 0) return;\n    splat(B, a[0], a[1], cc[0] * w, cc[1] * w, cc[2] * w, 0, TOP);\n    for (let i = 1; i \u003c= 5; i++) {\n      const s = (Lr * i) / 5, b = proj(lin(p, cos(s), v, sin(s)));\n      if (b[2] > 0) line(B, a[0], a[1], b[0], b[1], cc[0] * w, cc[1] * w, cc[2] * w, 0, TOP);\n      a = b;\n    }\n    const tip = lin(p, cos(Lr), v, sin(Lr)), fw = lin(p, -sin(Lr), v, cos(Lr)), sd = crs(tip, fw), ta = proj(tip);\n    for (const sg of [-1, 1]) {\n      const dv = lin(fw, -cos(0.6), sd, sg * sin(0.6)), e = proj(lin(tip, cos(Lh), dv, sin(Lh)));\n      if (e[2] > 0 && ta[2] > 0) line(B, ta[0], ta[1], e[0], e[1], cc[0] * w, cc[1] * w, cc[2] * w, 0, TOP);\n    }\n  };\n  // Ghost arrows every 8 LEDs or so of loop, left as the arrow passes.\n  const nG = cl(round((S.L * Rz) / 8), 5, 16), sNow = S.s * S.L;\n  for (let j = 1; j \u003c nG; j++) {\n    const sj = (j * S.L) / nG;\n    if (sj > sNow) break;\n    const g = sampleAt(S, sj), w = 0.42 * fade * cl((sNow - sj) * Rz * 0.3, 0, 1);\n    arrow(g.p, g.v, gold, w);\n  }\n  const p0 = [P[0], P[1], P[2]], v0 = [V[0], V[1], V[2]], white = [0.85, 0.9, 1];\n  const hold = S.phase === 1 ? fade : 0;\n  arrow(p0, v0, white, 0.45 + 0.5 * hold);\n  arrow(now.p, now.v, gold, 1.15 * fade);\n  // At the close, an arc from the start arrow round to the returned one.\n  const turn = now.psi;\n  if (hold > 0) {\n    const ra = 0.62 * Lr, n0 = crs(p0, v0), n = max(8, ceil(abs(turn) * ra * Rz));\n    let a = null;\n    const blink = 0.75 + 0.25 * sin(t * 6);\n    for (let i = 0; i \u003c= n; i++) {\n      const al = (turn * i) / n, dir = lin(v0, cos(al), n0, sin(al)), b = proj(lin(p0, cos(ra), dir, sin(ra)));\n      const tc = turn >= 0 ? pos : neg, w = hold * blink;\n      if (a && a[2] > 0 && b[2] > 0) line(B, a[0], a[1], b[0], b[1], tc[0] * w, tc[1] * w, tc[2] * w, 0, TOP);\n      a = b;\n    }\n  }\n  // The dial: the area swept so far as a pie from twelve o'clock, positive\n  // counterclockwise, and the arrow's turn against the gauge as the needle.\n  const DX = 32, DY = 94, DR = 25, HUB = 9.5, A = S.phase === 0 ? now.area : S.area[S.K];\n  const tc = A >= 0 ? pos : neg;\n  for (let y = DY - DR - 2; y \u003c= DY + DR + 2; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - DX, dy = y + 0.5 - DY, r = sqrt(dx * dx + dy * dy);\n      if (r > DR + 1.5) continue;\n      const k = (y * W + x) * 3, ring = max(0, 1 - abs(r - DR) / 0.8) * 0.2;\n      (B[k] += ring * grid[0]), (B[k + 1] += ring * grid[1]), (B[k + 2] += ring * grid[2]);\n      if (r >= DR - 0.5 || r \u003c= HUB) continue;\n      const al = atan2(-dx, -dy), a1 = A >= 0 ? fr(al / TAU) * TAU : fr(-al / TAU) * TAU;\n      const m = cl((abs(A) - a1) * r + 0.5, 0, 1) * cl(r - HUB, 0, 1) * (0.14 + 0.3 * (r / DR)) * (0.5 + 0.5 * fade);\n      (B[k] += tc[0] * m), (B[k + 1] += tc[1] * m), (B[k + 2] += tc[2] * m);\n    }\n  const ray = (al, r0, r1, cc, w) =>\n    line(B, DX - sin(al) * r0, DY - cos(al) * r0, DX - sin(al) * r1, DY - cos(al) * r1, cc[0] * w, cc[1] * w, cc[2] * w, TOP, H);\n  for (let i = 0; i \u003c 12; i++) ray((i * PI) / 6, i % 3 ? DR - 2.5 : DR - 4, DR - 0.5, grid, i % 3 ? 0.35 : 0.6);\n  // Where this loop's turn will end.\n  const wt = S.want, wtc = wt >= 0 ? pos : neg;\n  ray(wt, DR - 1, DR + 2, wtc, 0.9);\n  ray(0, HUB + 1, DR - 2, white, 0.4 + 0.4 * hold);\n  const nd = S.phase === 0 ? turn : S.psi[S.K];\n  ray(nd, HUB + 1, DR - 2, gold, 1.1);\n  const tx = DX - sin(nd) * (DR - 2), ty = DY - cos(nd) * (DR - 2);\n  for (const sg of [-1, 1]) {\n    const bd = nd + PI + sg * 0.55;\n    line(B, tx, ty, tx - sin(bd) * 4.2, ty - cos(bd) * 4.2, gold[0] * 1.1, gold[1] * 1.1, gold[2] * 1.1, TOP, H);\n  }\n  // The turn in degrees in the hub, one decimal under 10.\n  const dg = (nd * 180) / PI;\n  let str = abs(dg) \u003c 9.95 ? (abs(dg) \u003c 0.05 ? '0.0' : dg.toFixed(1)) : String(round(dg));\n  str += 'o';\n  const tw = 0.75 + 0.25 * hold;\n  text(B, str, DX, DY - 2, tw, tw, tw);\n  text(B, 'TURN=AREA', DX, 122, pale[0] * 0.45, pale[1] * 0.45, pale[2] * 0.45);\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, floor(sc(B[o]) * 255), floor(sc(B[o + 1]) * 255), floor(sc(B[o + 2]) * 255));\n  }\n}\n","rose-criterion":"// ===== Patternflow pattern =====\n// Title:   Rose Criterion\n// Family:  noise\n// Idea:    A contrast-detail grid of fifty discs, five diameters across and ten contrasts down, is exposed photon by photon with Poisson counts and a little read noise, so the normalised picture starts as static, settles into grain and lets the discs rise out of it in order of contrast times diameter, while a faint line marks Rose's k = 5, the hyperbola C·d = const that sweeps from the top left corner toward the bottom right and stops where the dose runs out; then the exposure clears and builds again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rose's detection criterion k = C·sqrt(nA) (Albert Rose, \"The sensitivity performance of the human eye on an absolute scale\", J. Opt. Soc. Am. 38, 1948), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Exposure=0..1, Read noise=0..1\n//\n// Knob 1: Hue. The colour of the light: at 0 cyan grain with a gold k = 5 line, at 0.25 violet with a green line, at 0.5 coral with a blue line, at 0.75 lime with a magenta line.\n// Knob 2: Speed. How fast each exposure builds: at 2 the dose comes in over 3 s, holds 1.2 s and clears; at 0.2 it comes in over 30 s, at 3 over 2 s. The photon flux is the dose over that time.\n// Knob 3: Exposure. The dose a build stops at, in photons per LED: 25 at 0, 224 at 0.5, 2000 at 1. At 25 the k = 5 line stops at C·d = 1.15 with 7 of the 50 discs still in the grain; from 0.37 on every disc is seen, the last one (contrast 0.15, 9 LEDs) at 124 photons, and the rest of the dose only calms the grain.\n// Knob 4: Read noise. Gaussian noise each channel adds every time it reads its LED, 1 photon rms at 0 and 9 at 1. It adds to the shot noise, so the grain coarsens and the k = 5 line, drawn with it counted in, slows: at 1 the first disc needs 8 photons instead of 1.3, and at 25 photons 24 discs stay hidden.\n\n// Rose (1948): a disc of area A whose brightness differs by a fraction C\n// from a background that has caught n photons per unit area is seen when\n// k = C·sqrt(n·A), its excess count over the noise of the background count\n// in the same area, passes about 5. With A = pi·d²/4 the threshold is\n// C·d = 5 / sqrt(pi·n/4): at a given dose the seen and unseen discs of a\n// contrast-detail grid are split by a hyperbola, which moves out as 1/sqrt(n).\n//\n// Here A is the disc's own LED count (97, 69, 37, 21 and 9 for diameters\n// 11, 9, 7, 5 and 3) and n the photons per LED. Each LED keeps one count,\n// read by each of its three channels with its own read noise sigma, so one\n// read has variance n + sigma² and the line drawn is\n// C·sqrt(A)·n / sqrt(n + sigma²) = 5.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, log, cos, sin, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The grid: diameters across, contrasts down. Each disc is the LEDs whose\n// centres lie within d/2 of the centre of the LED at (COLX, ROWY), so every\n// disc in a column has the same shape and the same area.\nconst DIAM = [11, 9, 7, 5, 3];\nconst COLX = [6, 19, 32, 44, 57];\nconst ROWY = [6, 19, 32, 44, 57, 70, 83, 96, 108, 121];\nconst CONTRAST = ROWY.map((_, r) => 0.6 - 0.05 * r);\nconst K_ROSE = 5;\nconst CXS = COLX.map((x) => x + 0.5), CYS = ROWY.map((y) => y + 0.5);\n\n// The display: the count normalised by what the background should have\n// caught, so u = 1 on the background, then an exponential toe and a soft\n// shoulder, 1 - exp(-a·exp(BETA·(u - 1))). Equal steps of u read as equal\n// steps of brightness on the LEDs, and the background sits near L0 with\n// grain on both sides of it instead of piling up at black.\nconst L0 = 13, BETA = 6.5;\n// The gain runs out below this many expected photons, so the panel comes\n// up from black instead of blowing up the first few counts.\nconst FLOOR = 3.5;\n// How bright the k = 5 line is drawn.\nconst LINE = 150;\n// The tone curve, tabulated over t = BETA·(u - 1) in steps of 1/128.\nconst T0 = -10, TS = 128, TN = 15 * TS;\nconst TONE = new Float32Array(TN + 1);\nfor (let i = 0; i \u003c= TN; i++) TONE[i] = 1 - exp(-(L0 / 255) * exp(T0 + i / TS));\n\nfunction poisson(l, gauss) {\n  if (l \u003c= 0) return 0;\n  if (l > 15) return max(0, round(l + sqrt(l) * gauss()));\n  const u = Math.random();\n  let k = 0, p = exp(-l), s = p;\n  while (u > s && k \u003c 60) {\n    k++;\n    p *= l / k;\n    s += p;\n  }\n  return k;\n}\n\nexport function setup(params) {\n  const cidx = new Uint8Array(W * H);\n  const area = DIAM.map(() => 0);\n  DIAM.forEach((d, c) => {\n    const r2 = (d / 2) * (d / 2), R = d >> 1;\n    for (let i = -R; i \u003c= R; i++)\n      for (let j = -R; j \u003c= R; j++) {\n        if (i * i + j * j > r2) continue;\n        area[c]++;\n        ROWY.forEach((y, r) => (cidx[(y + j) * W + COLX[c] + i] = r + 1));\n      }\n  });\n  // Standard normal deviates, drawn once and picked at random at every read.\n  const norm = new Float32Array(4096);\n  for (let i = 0; i \u003c 4096; i += 2) {\n    const a = sqrt(-2 * log(1 - Math.random())), b = 2 * PI * Math.random();\n    norm[i] = a * cos(b);\n    norm[i + 1] = a * sin(b);\n  }\n  params.s = {\n    cidx, deff: area.map((a) => sqrt((4 * a) / PI)),\n    gauss: () => norm[(Math.random() * 4096) | 0],\n    count: new Float32Array(W * H), f: new Float32Array(W * H), dx: new Float32Array(W),\n    n: 0, hold: 0, stop: 25, sr: 1, hue: 0, lam: new Float32Array(11),\n    w: new Float32Array(3), lc: new Float32Array(3),\n  };\n  return params.s;\n}\n\n// The k = 5 threshold on C·d at dose n and read noise sr.\nconst lineK = (n, sr) => (n > 0 ? (K_ROSE * sqrt(n + sr * sr)) / (n * sqrt(PI / 4)) : 1e9);\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1] ?? 2, 0.2, 3);\n  S.stop = 25 * pow(80, cl(kv[2] || 0, 0, 1));\n  const rn = cl(kv[3] ?? 0.06, 0, 1);\n  S.sr = 1 + 8 * rn * rn;\n\n  if (S.n >= S.stop) {\n    S.hold += d * speed;\n    if (S.hold > 2.4) {\n      S.n = 0;\n      S.hold = 0;\n      S.count.fill(0);\n    }\n    return;\n  }\n  // Constant flux: the dose comes in over 6/speed seconds. A disc of\n  // contrast C catches 1 + C times the background's photons.\n  S.hold = 0;\n  const dn = min(S.stop - S.n, (S.stop * speed * d) / 6);\n  S.n += dn;\n  for (let k = 0; k \u003c= 10; k++) S.lam[k] = dn * (k ? 1 + CONTRAST[k - 1] : 1);\n  const cnt = S.count, ci = S.cidx, lam = S.lam, g = S.gauss;\n  for (let i = 0; i \u003c W * H; i++) cnt[i] += poisson(lam[ci[i]], g);\n}\n\n// Piecewise linear through the grid's centres, carried on past the ends.\nfunction interp(xs, ys, v) {\n  let i = 0;\n  while (i \u003c xs.length - 2 && v > xs[i + 1]) i++;\n  return ys[i] + ((v - xs[i]) * (ys[i + 1] - ys[i])) / (xs[i + 1] - xs[i]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const cnt = S.count, sr = S.sr, gauss = S.gauss, w = hsv(0.5 + S.hue, 0.55, 1, S.w);\n  const w0 = 255 * w[0], w1 = 255 * w[1], w2 = 255 * w[2];\n  // One read: t = BETA·(u - 1) as a row of the tone table.\n  const sc = (BETA * TS) / max(S.n, FLOOR), off = (-BETA - T0) * TS, rs = sr * sc;\n  const tone = (c) => {\n    const t = (c + rs * gauss() + off) | 0;\n    return TONE[t \u003c 0 ? 0 : t > TN ? TN : t];\n  };\n\n  // The line: where C(y)·d(x) crosses the k = 5 threshold, drawn on the seen side.\n  const K = lineK(S.n, sr), f = S.f, dx = S.dx;\n  for (let x = 0; x \u003c W; x++) dx[x] = max(0.3, interp(CXS, S.deff, x + 0.5));\n  for (let y = 0; y \u003c H; y++) {\n    const C = max(0.005, interp(CYS, CONTRAST, y + 0.5));\n    for (let x = 0; x \u003c W; x++) f[y * W + x] = C * dx[x] - K;\n  }\n  const lc = hsv(S.hue + 0.13, 0.75, 1, S.lc);\n  const l0 = lc[0] * LINE, l1 = lc[1] * LINE, l2 = lc[2] * LINE;\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, c = cnt[i] * sc;\n      // One count per LED, read once by each of its three channels.\n      let r = w0 * tone(c), g = w1 * tone(c), b = w2 * tone(c);\n      const v = f[i];\n      if (v >= 0 && ((x > 0 && f[i - 1] \u003c 0) || (x \u003c W - 1 && f[i + 1] \u003c 0) || (y > 0 && f[i - W] \u003c 0) || (y \u003c H - 1 && f[i + W] \u003c 0))) {\n        r = max(r, l0);\n        g = max(g, l1);\n        b = max(b, l2);\n      }\n      display.setPixel(x, y, r | 0, g | 0, b | 0);\n    }\n}\n","structure-ascii":"// ===== Patternflow pattern =====\n// Title:   Structure ASCII\n// Family:  type\n// Idea:    The outline of a big letter sways and melts from A to S to & to the Hangul syllable 글 behind a grid of character cells, lit only by a dim rim just inside its edge, and each cell the outline crosses takes the ASCII character whose strokes lie nearest the piece of outline inside it, so slashes, bars, underscores, parentheses and ticks join into the letter's contour, as in structure-based ASCII art; a fourth setting picks by ink instead, as tone-based ASCII art does.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Structure-based ASCII Art (Xuemiao Xu, Linling Zhang and Tien-Tsin Wong, SIGGRAPH 2010), pattern round 68\n// Round:   68\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Set=0..3, Cell=0..3\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the straight strokes are turquoise, curves and angles azure, corners and crossings green, dots and ticks lilac, and a rim 4 LEDs deep just inside the outline a dim blue (16, 19, 45), so the characters stand on the edge of a shape; at 0.5 the strokes are red.\n// Knob 2: Speed. At 2 a letter holds 4.5 s and melts into the next in 1.5 s, so the four take 24 s, while the drawing sways 0.12 radian (about 7 degrees) each way every 9 s. At 0.2 it all takes ten times as long, at 3 two thirds as long.\n// Knob 3: Set. The characters a cell may take, each set with the space. At 0 the 27 of the structure set (. , ' ` \" - _ = | / \\ ( ) \u003c > ^ v ~ o + L J 7 T Y V X); at 1 twelve of them (/ \\ | - _ . ' , ( ) \u003c >); at 2 only / \\ | and -. At 3 the tone ramp . : - = + * # % @, picked by how much of the cell the outline darkens, not by its shape.\n// Knob 4: Cell. The size of a character cell in LEDs: 5 by 8 at 0 (a grid of 12 by 16), 4 by 6 at 1 (16 by 21), 3 by 5 at 2 (21 by 25), and 7 by 11 at 3 (9 by 11), where each character is big enough to read.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The paper (Xu, Zhang and Wong 2010) compares a cell and a character with an\n// alignment-insensitive shape similarity and also deforms the drawing to suit\n// the characters. Here the drawing is never deformed, and the comparison is a\n// symmetric chamfer distance that lets the character slide by up to two LEDs\n// across (one in a 3 by 5 cell) and one up or down, at 0.12 for each LED of\n// slide; the character is still drawn in its own cell.\n\n// ---- The characters. Each is drawn as pen strokes in a unit cell, across\n// then down in tenths, so (0,0) is the top left corner and (10,10) the\n// bottom right; a stroke of one point is a dot. Strokes run to the cell's\n// edge where the character's line would go on into its neighbour, so two\n// slashes side by side meet. The second field is a class for colour:\n// 0 straight lines, 1 curves and angles, 2 corners and crossings, 3 dots.\nconst GLYPHS = [\n  [\" \", 3, []],\n  [\".\", 3, [[5, 10]]],\n  [\",\", 3, [[6, 8, 4, 10]]],\n  [\"'\", 3, [[5, 0, 5, 2]]],\n  [\"`\", 3, [[3, 0, 6, 3]]],\n  ['\"', 3, [[2, 0, 2, 2], [8, 0, 8, 2]]],\n  [\":\", 3, [[5, 3], [5, 8]]],\n  [\"-\", 0, [[0, 5, 10, 5]]],\n  [\"_\", 0, [[0, 10, 10, 10]]],\n  [\"=\", 0, [[0, 3, 10, 3], [0, 7, 10, 7]]],\n  [\"|\", 0, [[5, 0, 5, 10]]],\n  [\"/\", 0, [[0, 10, 10, 0]]],\n  [\"\\\\\", 0, [[0, 0, 10, 10]]],\n  [\"(\", 1, [[8, 0, 4, 2, 2, 5, 4, 8, 8, 10]]],\n  [\")\", 1, [[2, 0, 6, 2, 8, 5, 6, 8, 2, 10]]],\n  [\"\u003c\", 1, [[10, 0, 0, 5, 10, 10]]],\n  [\">\", 1, [[0, 0, 10, 5, 0, 10]]],\n  [\"^\", 1, [[0, 5, 5, 0, 10, 5]]],\n  [\"v\", 1, [[0, 4, 5, 10, 10, 4]]],\n  [\"~\", 1, [[0, 6, 3, 4, 7, 6, 10, 4]]],\n  [\"o\", 1, [[3, 4, 7, 4, 9, 6, 9, 8, 7, 10, 3, 10, 1, 8, 1, 6, 3, 4]]],\n  [\"+\", 2, [[0, 5, 10, 5], [5, 1, 5, 9]]],\n  [\"L\", 2, [[0, 0, 0, 10, 10, 10]]],\n  [\"J\", 2, [[10, 0, 10, 10, 0, 10]]],\n  [\"7\", 2, [[0, 0, 10, 0, 3, 10]]],\n  [\"T\", 2, [[0, 0, 10, 0], [5, 0, 5, 10]]],\n  [\"Y\", 2, [[0, 0, 5, 5, 10, 0], [5, 5, 5, 10]]],\n  [\"V\", 2, [[0, 0, 5, 10, 10, 0]]],\n  [\"X\", 2, [[0, 0, 10, 10], [10, 0, 0, 10]]],\n  [\"*\", 2, [[5, 2, 5, 8], [1, 3, 9, 7], [9, 3, 1, 7]]],\n  [\"#\", 2, [[3, 1, 3, 9], [7, 1, 7, 9], [0, 3, 10, 3], [0, 7, 10, 7]]],\n  [\"%\", 2, [[10, 0, 0, 10], [1, 1], [9, 9]]],\n  [\"@\", 2, [[10, 10, 0, 10, 0, 0, 10, 0, 10, 7, 4, 7, 4, 4, 7, 4]]],\n];\nconst GI = {};\nGLYPHS.forEach((g, i) => (GI[g[0]] = i));\nconst pick = (s) => Array.from(s, (c) => GI[c]);\n// The character sets, each with the space: 27 characters for structure, 12\n// of them, the four straight strokes, and a tone ramp of nine by ink.\nconst SETS = [\n  pick(\" .,'`\\\"-_=|/\\\\()\u003c>^v~o+LJ7TYVX\"),\n  pick(\" /\\\\|-_.',()\u003c>\"),\n  pick(\" /\\\\|-\"),\n  pick(\" .:-=+*#%@\"),\n];\nconst RAMP = SETS[3];\n\n// The cell sizes: width, height.\nconst CELLS = [\n  [5, 8],\n  [4, 6],\n  [3, 5],\n  [7, 11],\n];\n// The distance is capped at CAP LEDs; a shift of the character by one LED\n// across or down costs SHIFT.\nconst CAP = 3, SHIFT = 0.12;\n// The brightness and depth of the rim inside the letter.\nconst IN = 0.18, BAND = 4;\nconst SX = (cw) => (cw >= 4 ? 2 : 1), SY = 1;\n\n// Each character at each cell size: its bitmap, its lit LEDs, and the\n// distance from each LED of the cell and a border round it to the nearest\n// lit LED, so it can be compared shifted.\nfunction raster(strokes, cw, ch) {\n  const bm = new Uint8Array(cw * ch);\n  for (const pl of strokes) {\n    const P = [];\n    for (let i = 0; i \u003c pl.length; i += 2) P.push([(pl[i] / 10) * (cw - 1), (pl[i + 1] / 10) * (ch - 1)]);\n    if (P.length === 1) bm[round(P[0][1]) * cw + round(P[0][0])] = 1;\n    for (let i = 0; i + 1 \u003c P.length; i++) {\n      const [x0, y0] = P[i], [x1, y1] = P[i + 1];\n      const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n      for (let k = 0; k \u003c= n; k++) bm[floor(y0 + ((y1 - y0) * k) / n + 0.5) * cw + floor(x0 + ((x1 - x0) * k) / n + 0.5)] = 1;\n    }\n  }\n  return bm;\n}\nconst FONT = CELLS.map(([cw, ch]) => {\n  const bx = SX(cw), by = SY, ew = cw + 2 * bx, eh = ch + 2 * by;\n  return GLYPHS.map((g) => {\n    const bm = raster(g[2], cw, ch);\n    const ink = [];\n    for (let j = 0; j \u003c ch; j++) for (let i = 0; i \u003c cw; i++) if (bm[j * cw + i]) ink.push(i, j);\n    const dist = new Float32Array(ew * eh);\n    for (let b = 0; b \u003c eh; b++)\n      for (let a = 0; a \u003c ew; a++) {\n        let d = CAP * CAP;\n        for (let k = 0; k \u003c ink.length; k += 2) {\n          const dx = a - bx - ink[k], dy = b - by - ink[k + 1];\n          d = min(d, dx * dx + dy * dy);\n        }\n        dist[b * ew + a] = sqrt(d);\n      }\n    return { bm, ink, dist };\n  });\n});\n\n// ---- The big letters, as centre lines in a box 52 by 108 LEDs about the\n// panel's middle, y down; the outline is where the distance to the centre\n// line equals the stroke's half width.\nfunction arc(cx, cy, rx, ry, a0, a1, n) {\n  const pts = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;\n    pts.push(cx + rx * cos(a), cy + ry * sin(a));\n  }\n  return pts;\n}\nconst LETTERS = [\n  { r: 7, lines: [[-22, 52, 0, -50, 22, 52], [-12, 18, 12, 18]] },\n  { r: 7, lines: [[...arc(1, -28, 20, 24, -25, -270, 12), ...arc(0, 25, 22, 27, -90, 155, 12)]] },\n  { r: 6, lines: [[23, 52, -10, 0, ...arc(-3, -32, 12, 19, 130, 405, 12), -16, 8, ...arc(-4, 32, 20, 21, 210, 60, 10), 21, 18]] },\n  { r: 4.5, lines: [[-22, -52, 20, -52, 20, -31], [-27, -14, 27, -14], [-20, 5, 20, 5, 20, 26, -20, 26, -20, 47, 22, 47]] },\n];\nfor (const L of LETTERS) {\n  const s = [];\n  for (const pl of L.lines) for (let i = 0; i + 3 \u003c pl.length; i += 2) s.push(pl[i], pl[i + 1], pl[i + 2], pl[i + 3]);\n  L.seg = new Float32Array(s);\n}\n\nfunction lineDist(seg, x, y) {\n  let best = 1e9;\n  for (let i = 0; i \u003c seg.length; i += 4) {\n    const ax = seg[i], ay = seg[i + 1], bx = seg[i + 2] - ax, by = seg[i + 3] - ay;\n    const px = x - ax, py = y - ay, L = bx * bx + by * by;\n    let t = L > 0 ? (px * bx + py * by) / L : 0;\n    t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n    const dx = px - t * bx, dy = py - t * by, d = dx * dx + dy * dy;\n    if (d \u003c best) best = d;\n  }\n  return sqrt(best);\n}\n\nconst LW = W + 1, LH = H + 1, CW = 33, CH = 65;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, set: 0, cell: 0,\n    // The field on every second LED corner, then on every corner.\n    g: new Float32Array(CW * CH), f: new Float32Array(LW * LH),\n    // The outline's piece in each LED square: up to two segments.\n    sq: new Float32Array(W * H * 8), nsq: new Uint8Array(W * H),\n    // Per cell: its character, and a hash of the LEDs the outline crossed.\n    ch: new Int16Array(32 * 32), sig: new Int32Array(32 * 32),\n    dt: new Float32Array(32 * 32), segs: new Float32Array(400), tl: new Int16Array(200),\n    rgb: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.t += cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3) / 2;\n  S.set = cl(round(k[2]), 0, 3);\n  const c = cl(round(k[3]), 0, CELLS.length - 1);\n  if (c !== S.cell || S.set !== S.lastSet) { S.ch.fill(0); S.sig.fill(0); }\n  S.cell = c;\n  S.lastSet = S.set;\n}\n\n// One letter holds HOLD units of the clock, then melts into the next in MELT.\nconst HOLD = 4.5, MELT = 1.5, PER = HOLD + MELT;\n\nfunction field(S) {\n  const n = floor(S.t / PER), u = S.t - n * PER;\n  const A = LETTERS[n % LETTERS.length], B = LETTERS[(n + 1) % LETTERS.length];\n  const m = smooth((u - HOLD) / MELT);\n  const th = 0.12 * sin((2 * PI * S.t) / 9), cs = cos(th), sn = sin(th), sc = 1 / 0.9;\n  const g = S.g, f = S.f;\n  for (let j = 0; j \u003c CH; j++)\n    for (let i = 0; i \u003c CW; i++) {\n      const X = 2 * i - 32, Y = 2 * j - 64;\n      const x = (cs * X + sn * Y) * sc, y = (-sn * X + cs * Y) * sc;\n      let v = lineDist(A.seg, x, y) - A.r;\n      if (m > 0) v = (1 - m) * v + m * (lineDist(B.seg, x, y) - B.r);\n      g[j * CW + i] = v;\n    }\n  // In between, the mean of the neighbours on the coarse lattice.\n  for (let j = 0; j \u003c LH; j++) {\n    const j0 = j >> 1, j1 = (j + 1) >> 1;\n    for (let i = 0; i \u003c LW; i++) {\n      const i0 = i >> 1, i1 = (i + 1) >> 1;\n      f[j * LW + i] = 0.25 * (g[j0 * CW + i0] + g[j0 * CW + i1] + g[j1 * CW + i0] + g[j1 * CW + i1]);\n    }\n  }\n}\n\n// Marching squares on the LED corners: the outline's piece in each LED square.\nfunction contour(S) {\n  const f = S.f, sq = S.sq, nsq = S.nsq;\n  const P = new Float32Array(8);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const a = f[y * LW + x], b = f[y * LW + x + 1], c = f[(y + 1) * LW + x + 1], d = f[(y + 1) * LW + x];\n      const q = y * W + x, ia = a \u003c 0, ib = b \u003c 0, ic = c \u003c 0, id = d \u003c 0;\n      nsq[q] = 0;\n      if (ia === ib && ib === ic && ic === id) continue;\n      // Where the outline crosses the top, right, bottom and left edges.\n      let np = 0;\n      if (ia !== ib) { P[np++] = x + a / (a - b); P[np++] = y; }\n      if (ib !== ic) { P[np++] = x + 1; P[np++] = y + b / (b - c); }\n      if (id !== ic) { P[np++] = x + d / (d - c); P[np++] = y + 1; }\n      if (ia !== id) { P[np++] = x; P[np++] = y + a / (a - d); }\n      const o = q * 8;\n      for (let k = 0; k \u003c np; k++) sq[o + k] = P[k];\n      if (np === 8 && (a + b + c + d \u003c 0) !== ia) {\n        // A saddle: pair top with left and right with bottom.\n        sq[o + 2] = P[6]; sq[o + 3] = P[7]; sq[o + 4] = P[2]; sq[o + 5] = P[3]; sq[o + 6] = P[4]; sq[o + 7] = P[5];\n      }\n      nsq[q] = np >> 2;\n    }\n}\n\n// The chamfer distance between a character shifted by sx, sy and the\n// outline is the distance from each of its lit LEDs to the outline, plus\n// the distance from each LED the outline crosses to its nearest lit LED,\n// over the count of both, plus SHIFT for each LED of shift. The shifts of\n// each cell size, cheapest first: sx, sy, cost.\nconst SHIFTS = CELLS.map(([cw]) => {\n  const L = [];\n  for (let sy = -SY; sy \u003c= SY; sy++) for (let sx = -SX(cw); sx \u003c= SX(cw); sx++) L.push([sx, sy, SHIFT * (abs(sx) + abs(sy))]);\n  return L.sort((a, b) => a[2] - b[2]).flat();\n});\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  field(S);\n  contour(S);\n  const [cw, ch] = CELLS[S.cell], font = FONT[S.cell];\n  const cols = floor(W / cw), rows = floor(H / ch);\n  const ox = floor((W - cols * cw) / 2), oy = floor((H - rows * ch) / 2);\n  const set = SETS[S.set], tone = S.set === 3, shifts = SHIFTS[S.cell];\n  const bx = SX(cw), by = SY, ew = cw + 2 * bx, eh = ch + 2 * by;\n  const sq = S.sq, nsq = S.nsq, rgb = S.rgb, dT = S.dt, segs = S.segs, tl = S.tl;\n  const h0 = 0.47 + S.hue, f = S.f;\n  // A faint rim BAND LEDs deep inside the outline, so the characters stand\n  // on the edge of a shape.\n  hsv(h0 + 0.18, 0.65, IN, rgb);\n  const ir = rgb[0] | 0, ig = rgb[1] | 0, ib = rgb[2] | 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const c = 0.25 * (f[y * LW + x] + f[y * LW + x + 1] + f[(y + 1) * LW + x] + f[(y + 1) * LW + x + 1]);\n      if (c \u003c 0 && c > -BAND) display.setPixel(x, y, ir, ig, ib);\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++) {\n      const gx = ox + c * cw, gy = oy + r * ch, id = r * 32 + c;\n      // The outline's pieces in this cell, and the LEDs they cross.\n      let ns = 0, nt = 0;\n      for (let j = 0; j \u003c ch; j++)\n        for (let i = 0; i \u003c cw; i++) {\n          const q = (gy + j) * W + gx + i;\n          if (!nsq[q]) continue;\n          tl[nt++] = j * ew + i + by * ew + bx;\n          for (let k = 0; k \u003c nsq[q] * 4; k += 4) {\n            const o = q * 8 + k;\n            segs[ns++] = sq[o] - gx; segs[ns++] = sq[o + 1] - gy; segs[ns++] = sq[o + 2] - gx; segs[ns++] = sq[o + 3] - gy;\n          }\n        }\n      if (!nt) { S.ch[id] = 0; continue; }\n      // Only a cell whose crossed LEDs changed is matched again.\n      let sig = nt;\n      for (let k = 0; k \u003c nt; k++) sig = (sig * 31 + tl[k]) | 0;\n      if (sig === S.sig[id] && S.ch[id]) { paint(display, S, S.ch[id], font, gx, gy, cw, ch, h0); continue; }\n      S.sig[id] = sig;\n      // Distance from each LED centre of the cell and its border to the outline.\n      for (let b = 0; b \u003c eh; b++)\n        for (let a = 0; a \u003c ew; a++) {\n          const px = a - bx + 0.5, py = b - by + 0.5;\n          let best = CAP * CAP;\n          for (let i = 0; i \u003c ns; i += 4) {\n            const ax = segs[i], ay = segs[i + 1], ux = segs[i + 2] - ax, uy = segs[i + 3] - ay;\n            const vx = px - ax, vy = py - ay, L = ux * ux + uy * uy;\n            let t = L > 0 ? (vx * ux + vy * uy) / L : 0;\n            t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n            const dx = vx - t * ux, dy = vy - t * uy, d = dx * dx + dy * dy;\n            if (d \u003c best) best = d;\n          }\n          dT[b * ew + a] = sqrt(best);\n        }\n      let g = 0;\n      if (tone) {\n        // Tone: how much of the cell the outline darkens, on the ramp from the space.\n        let ink = 0;\n        for (let j = 0; j \u003c ch; j++) for (let i = 0; i \u003c cw; i++) ink += max(0, 1 - dT[(j + by) * ew + i + bx]);\n        g = RAMP[min(9, round((ink / (cw * ch)) * 22))];\n      } else {\n        // Each character of the set at every shift, the cell's last character\n        // first; a shift is given up as soon as its sum cannot win.\n        const prev = S.ch[id];\n        let bestC = 1e9, prevC = 1e9;\n        for (let k = -1; k \u003c set.length; k++) {\n          const gi = k \u003c 0 ? prev : set[k];\n          if (k >= 0 && gi === prev) continue;\n          const G = font[gi], ink = G.ink, dist = G.dist, n = ink.length / 2 + nt;\n          let cbest = 1e9;\n          for (let m = 0; m \u003c shifts.length; m += 3) {\n            const sx = shifts[m], sy = shifts[m + 1], pen = shifts[m + 2];\n            const lim = ((k \u003c 0 ? cbest : min(cbest, bestC)) - pen) * n;\n            if (lim \u003c= 0) break;\n            let cost = 0;\n            const io = (sy + by) * ew + sx + bx;\n            for (let i = 0; i \u003c ink.length && cost \u003c lim; i += 2) cost += dT[ink[i + 1] * ew + ink[i] + io];\n            const so = -sy * ew - sx;\n            for (let i = 0; i \u003c nt && cost \u003c lim; i++) cost += dist[tl[i] + so];\n            if (cost \u003c lim) cbest = cost / n + pen;\n          }\n          if (k \u003c 0) prevC = cbest;\n          if (cbest \u003c bestC) { bestC = cbest; g = gi; }\n        }\n        // Hold on to the last character unless a new one fits clearly better.\n        if (prevC \u003c bestC + 0.08) g = prev;\n      }\n      S.ch[id] = g;\n      if (g) paint(display, S, g, font, gx, gy, cw, ch, h0);\n    }\n}\n\nfunction paint(display, S, g, font, gx, gy, cw, ch, h0) {\n  const G = GLYPHS[g], bm = font[g].bm, rgb = S.rgb;\n  hsv(h0 + [0, 0.12, -0.1, 0.3][G[1]], G[1] === 3 ? 0.5 : 0.85, 1, rgb);\n  for (let j = 0; j \u003c ch; j++)\n    for (let i = 0; i \u003c cw; i++) if (bm[j * cw + i]) display.setPixel(gx + i, gy + j, rgb[0] | 0, rgb[1] | 0, rgb[2] | 0);\n}\n","artin-braids":"// ===== Patternflow pattern =====\n// Title:   Artin Braids\n// Family:  topology\n// Idea:    A strip at the top holds three to seven coloured points seen from above, and generators of the braid group swap neighbours by half turns about their midpoints, while below it their history scrolls down the panel as a braid, each crossing drawn with the strand that passed in front whole and the one behind broken.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: braid groups (Emil Artin, 1925), the braid group as the fundamental group of the configuration space of n points in the plane (Ralph Fox and Lee Neuwirth, 1962), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Word=0..4\n//\n// Knob 1: Hue. Turns the strands' colours round the wheel. Strand k sits 0.8 k / (n - 1) of a turn on from the first, so first and last never meet; at 0 the first is azure, and three strands are azure, rose and yellow-green.\n// Knob 2: Speed. A generator takes 1.25 seconds at 2, 12.5 at 0.2 and 0.83 at 3. The braid keeps its shape at any speed; only the scrolling changes.\n// Knob 3: Strands. 3 to 7 points. Turning it starts the braid again with every point at home.\n// Knob 4: Word. Which braid word plays, round and round, starting again with every point home when it is turned: 0 random generators and inverses; 1 the full twist (s1 s2 ... s(n-1))^n, a pure braid that brings every colour home after n(n-1) crossings; 2 the Borromean braid (s1 s2^-1)^3 on three neighbouring strands, the three moving along; 3 the braid relation as a loop, s1 s2 s1 followed by the inverse of s2 s1 s2, six crossings that are the trivial braid; 4 a random positive braid, every crossing the same hand.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The strip is rows 0 to BAND - 1; below it, one row of the space-time\n// picture per S.dt of braid time, the newest at the top.\nconst BAND = 30, CY = 14.5, ROWS = H - BAND, KEEP = ROWS + 3;\n// One generator takes a unit of braid time: the half turn runs over the\n// first 0.9 of it, nearly at an even pace, and the points rest for the rest.\n// An even turn makes x a cosine of time, so each crossing is a smooth S.\nconst TURN = 0.9;\nconst ease = (p) => 0.7 * cl(p, 0, 1) + 0.3 * smooth(p);\n// Seconds a generator takes at Speed 2.\nconst GEN = 1.25;\n\n// 3 by 5 digits for the generator's index, and a minus for an inverse.\nconst DIGITS = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\"];\n\n// Convention. Seen from above, the strip's lower edge is the side nearer\n// the viewer of the braid below, so a point lower in the strip is in front.\n// s_i turns the points at places i and i+1 (counted by x) half a turn\n// counterclockwise about their midpoint: the left one goes round by the\n// lower side, in front, and the right one by the upper side, behind. So in\n// s_i the strand moving right crosses over, and in its inverse, turning\n// clockwise, under. Places and generators count from 0 in the code and from\n// 1 on the panel.\n\n// The next letter of the word, as [place, +1 or -1].\nfunction nextLetter(S) {\n  const n = S.n, c = S.c++;\n  switch (S.word) {\n    case 1: // the full twist, (s1 s2 ... s(n-1))^n\n      return [c % (n - 1), 1];\n    case 2: { // the Borromean braid (s1 s2^-1)^3 on places j, j+1, j+2\n      const j = floor(c / 6) % (n - 2);\n      return c % 2 ? [j + 1, -1] : [j, 1];\n    }\n    case 3: { // s1 s2 s1 s2^-1 s1^-1 s2^-1 on places j, j+1, j+2\n      const j = floor(c / 6) % (n - 2), k = c % 6;\n      return [j + [0, 1, 0, 1, 0, 1][k], k \u003c 3 ? 1 : -1];\n    }\n    case 4: // a random positive braid\n      return [floor(Math.random() * (n - 1)), 1];\n    default: {\n      // Random, but never a letter straight after its own inverse.\n      let i, s;\n      do {\n        i = floor(Math.random() * (n - 1));\n        s = Math.random() \u003c 0.5 ? 1 : -1;\n      } while (S.last && i === S.last[0] && s === -S.last[1]);\n      return [i, s];\n    }\n  }\n}\n\nfunction reset(S, n, word) {\n  S.n = n;\n  S.word = word;\n  S.sp = W / n;\n  S.r = S.sp / 2;\n  // Rows a generator takes: the crossings keep about the same slope for any\n  // number of strands, about 1.7 LEDs across a row at the steepest.\n  S.dt = 1 / cl(round(S.sp * 1.15), 11, 26);\n  S.perm = Array.from({ length: n }, (_, k) => k);\n  S.c = 0;\n  S.last = null;\n  S.g0 = 0;\n  S.gen = nextLetter(S);\n  S.home = 0;\n  // Samples of every strand's x and depth, KEEP of them in a ring.\n  S.hx = new Float32Array(KEEP * n);\n  S.hz = new Float32Array(KEEP * n);\n  S.k = 0;\n  S.t = 0;\n  // Pre-fill: run the braid until the picture reaches the bottom.\n  while (S.k \u003c KEEP) push(S);\n  S.t = (S.k - 1) * S.dt;\n  S.nowX = new Float32Array(n);\n  S.nowZ = new Float32Array(n);\n}\n\nconst placeX = (S, k) => (k + 0.5) * S.sp;\n\n// Move the braid on to time t, finishing generators on the way.\nfunction advance(S, t) {\n  while (t >= S.g0 + 1) {\n    const [i] = S.gen;\n    const p = S.perm;\n    [p[i], p[i + 1]] = [p[i + 1], p[i]];\n    S.last = S.gen;\n    S.g0 += 1;\n    S.gen = nextLetter(S);\n    if (p.every((s, k) => s === k)) S.home = 1;\n  }\n}\n\n// Each strand's x and depth at time t (after advance).\nfunction state(S, t, X, Z) {\n  const { n, perm, gen, r } = S;\n  for (let k = 0; k \u003c n; k++) {\n    X[perm[k]] = placeX(S, k);\n    Z[perm[k]] = 0;\n  }\n  const [i, s] = gen;\n  const th = PI * ease((t - S.g0) / TURN);\n  const m = (placeX(S, i) + placeX(S, i + 1)) / 2;\n  const a = perm[i], b = perm[i + 1];\n  X[a] = m - r * cos(th);\n  X[b] = m + r * cos(th);\n  // Depth is how far below the strip's middle line a point is.\n  Z[a] = s * r * sin(th);\n  Z[b] = -s * r * sin(th);\n}\n\nfunction push(S) {\n  const t = S.k * S.dt, o = (S.k % KEEP) * S.n;\n  advance(S, t);\n  state(S, t, S.hx.subarray(o, o + S.n), S.hz.subarray(o, o + S.n));\n  S.k++;\n}\n\nexport function setup(params) {\n  params.s = { n: 0, word: -1, rowZ: new Float32Array(W), rowS: new Int8Array(W), rowA: new Float32Array(W), px: new Float32Array(8), pz: new Float32Array(8), qx: new Float32Array(8), qz: new Float32Array(8) };\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const n = cl(round(k[2]), 3, 7), word = cl(round(k[3]), 0, 4);\n  if (n !== S.n || word !== S.word) reset(S, n, word);\n  S.t += (dt * cl(k[1], 0.05, 3)) / 2 / GEN;\n  while (S.k * S.dt \u003c= S.t) push(S);\n  advance(S, S.t);\n  state(S, S.t, S.nowX, S.nowZ);\n  S.home = max(0, S.home - dt * 1.2);\n}\n\nfunction setDisc(display, cx, cy, rad, rgb, lv) {\n  for (let y = max(0, floor(cy - rad - 1)); y \u003c= min(BAND - 1, floor(cy + rad + 1)); y++)\n    for (let x = max(0, floor(cx - rad - 1)); x \u003c= min(W - 1, floor(cx + rad + 1)); x++) {\n      const d = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2);\n      const a = cl(rad - d + 0.5, 0, 1);\n      if (a \u003c= 0) continue;\n      // A little white in the middle, like a bead lit from above.\n      const w = 0.45 * max(0, 1 - d / (rad * 0.7));\n      const v = a * lv;\n      display.setPixel(x, y, (rgb[0] * (1 - w) + w) * v * 255, (rgb[1] * (1 - w) + w) * v * 255, (rgb[2] * (1 - w) + w) * v * 255);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.n) return;\n  const { n, sp, r, dt, rowZ, rowS, rowA } = S;\n  const cols = [];\n  for (let s = 0; s \u003c n; s++) cols.push(hsv(0.55 + S.hue + (0.8 * s) / (n - 1), 0.78, 1));\n\n  // ---- The space-time picture. Row y shows the braid u = y + 0.5 - BAND\n  // rows ago. The newest sample sits frac of a row below the strip.\n  const last = S.k - 1, frac = (S.t - last * dt) / dt;\n  const hw = 0.15 * sp, gw = 0.07 * sp + 0.8, eps = 0.2 * r;\n  const { px, pz, qx, qz } = S;\n  for (let y = BAND; y \u003c H; y++) {\n    const u = y + 0.5 - BAND, mm = u - frac;\n    let w;\n    if (mm \u003c 0) {\n      // Between now and the newest sample.\n      const o = (last % KEEP) * n;\n      for (let s = 0; s \u003c n; s++) (px[s] = S.nowX[s]), (pz[s] = S.nowZ[s]), (qx[s] = S.hx[o + s]), (qz[s] = S.hz[o + s]);\n      w = (mm + frac) / max(frac, 1e-6);\n    } else {\n      const j = floor(mm);\n      if (last - j - 1 \u003c 0) break;\n      const o0 = ((last - j) % KEEP) * n, o1 = ((last - j - 1) % KEEP) * n;\n      for (let s = 0; s \u003c n; s++) (px[s] = S.hx[o0 + s]), (pz[s] = S.hz[o0 + s]), (qx[s] = S.hx[o1 + s]), (qz[s] = S.hz[o1 + s]);\n      w = mm - j;\n    }\n    rowS.fill(-1);\n    for (let s = 0; s \u003c n; s++) {\n      const xc = px[s] + (qx[s] - px[s]) * w, z = pz[s] + (qz[s] - pz[s]) * w;\n      // Across a sloped strand a row cuts a wider piece.\n      const sec = sqrt(1 + (qx[s] - px[s]) ** 2);\n      const reach = (hw + gw) * sec + 1;\n      for (let x = max(0, floor(xc - reach)); x \u003c= min(W - 1, floor(xc + reach)); x++) {\n        const d = abs(x + 0.5 - xc) / sec;\n        if (d >= hw + gw) continue;\n        const a = cl(hw - d + 0.5, 0, 1) * (1 - 0.4 * (d / hw) ** 2);\n        const held = rowS[x];\n        if (held \u003c 0 || (held !== s && z > rowZ[x] + eps)) {\n          // In front: its core, or the dark gap round it, covers what is behind.\n          rowS[x] = s;\n          rowZ[x] = z;\n          rowA[x] = max(0, a);\n        } else if (held === s) rowA[x] = max(rowA[x], a);\n        else if (z >= rowZ[x] - eps && a > rowA[x]) {\n          // Level with it: the brighter wins, and no gap is cut.\n          rowS[x] = s;\n          rowZ[x] = z;\n          rowA[x] = a;\n        }\n      }\n    }\n    // Older rows dim a little, and a strand behind is a little darker.\n    const fade = 1 - (0.4 * u) / ROWS;\n    for (let x = 0; x \u003c W; x++) {\n      const s = rowS[x];\n      if (s \u003c 0 || rowA[x] \u003c= 0) continue;\n      const v = rowA[x] * fade * (0.86 + (0.14 * rowZ[x]) / r);\n      const c = cols[s];\n      display.setPixel(x, y, c[0] * v * 255, c[1] * v * 255, c[2] * v * 255);\n    }\n  }\n\n  // ---- The strip. A faint floor, the home of each colour as a tick on the\n  // near edge (bright when its own strand stands on it), and a flash of the\n  // edges when every strand is home.\n  const home = S.home;\n  for (let x = 0; x \u003c W; x++) {\n    const e = 34 + 150 * home;\n    display.setPixel(x, 0, e, e, e * 1.1);\n    display.setPixel(x, BAND - 1, e, e, e * 1.1);\n    for (let y = 1; y \u003c BAND - 1; y++) display.setPixel(x, y, 5, 6, 12);\n  }\n  for (let k = 0; k \u003c n; k++) {\n    const c = cols[k], x0 = placeX(S, k), lv = S.perm[k] === k ? 0.9 : 0.3;\n    for (let x = floor(x0 - 2); x \u003c x0 + 2; x++) display.setPixel(x, BAND - 2, c[0] * lv * 255, c[1] * lv * 255, c[2] * lv * 255);\n  }\n  // The circle the turning pair runs on, while it turns.\n  const [gi, gs] = S.gen, p = (S.t - S.g0) / TURN;\n  if (p \u003c 1) {\n    const m = (placeX(S, gi) + placeX(S, gi + 1)) / 2, lv = 70 * sin(PI * cl(p, 0, 1)) ** 0.5;\n    for (let y = 1; y \u003c BAND - 1; y++)\n      for (let x = max(0, floor(m - r - 1)); x \u003c= min(W - 1, floor(m + r + 1)); x++) {\n        const d = abs(sqrt((x + 0.5 - m) ** 2 + (y + 0.5 - CY) ** 2) - r);\n        if (d \u003c 0.7) display.setPixel(x, y, lv, lv, lv * 1.15);\n      }\n  }\n  // The points.\n  const pr = cl(0.3 * sp, 2.3, 3.6);\n  for (let s = 0; s \u003c n; s++) setDisc(display, S.nowX[s], CY + S.nowZ[s], pr, cols[s], 1);\n  // The generator playing, as its index with a minus for an inverse.\n  const dg = DIGITS[gi + 1] || DIGITS[0];\n  for (let b = 0; b \u003c 15; b++) if (dg[b] === \"1\") display.setPixel(5 + (b % 3), 2 + floor(b / 3), 150, 150, 165);\n  if (gs \u003c 0) for (let x = 1; x \u003c 4; x++) display.setPixel(x, 4, 150, 150, 165);\n}\n","blinking-vortex":"// ===== Patternflow pattern =====\n// Title:   Blinking Vortex\n// Family:  sim\n// Idea:    Two point vortices one above the other take turns, each spinning the fluid round itself for half a period while the other rests, and soft bands of two dyes, traced back exactly through every turn, are stretched and folded into filaments until they are finer than an LED and blend to one even colour, when a fresh dye is laid.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the blinking vortex flow (Hassan Aref, Stirring by chaotic advection, J. Fluid Mech. 143, 1984), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strength=2..16, Dye=0..3\n//\n// Knob 1: Hue. Turns both dyes round the wheel: at 0 one is turquoise and the other violet, both brightest in blue, so where they are mixed finer than an LED the brightness holds and only the colour blends to periwinkle.\n// Knob 2: Speed. Half periods a second: 2.2 at 2, 0.22 at 0.2, 3.3 at 3.\n// Knob 3: Strength. The stirring strength mu = Gamma T / (2 pi a^2), with 2a the distance between the vortices: fluid at the midpoint turns mu/2 radians each half period. At 2 each vortex winds the bands into its own spiral and the bands beyond them stay whole while an S of mixed dye grows between; past about 5 the S fills the middle within two half periods. A dye lasts 12/mu half periods, 6 at 2 and 3 from 4 up. The whole history is traced again at the new strength, so the picture answers at once.\n// Knob 4: Dye. How the dye is laid: 0 bands across the panel, 20 rows each; 1 two halves either side of the line through the vortices, shaded in bands of 32 rows; 2 stripes down the panel, 16 columns each; 3 rings round the midpoint, 16 LEDs each. Every band is brightest along its middle and dark where the colour changes.\n// Buttons: any knob's button lays a fresh dye now.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Aref's flow had a circular wall; this one is the unbounded plane, so each\n// vortex alone is the exact point-vortex field: fluid at distance r turns\n// about it at Gamma / (2 pi r^2) radians a second and r never changes. A half\n// period is then an exact rotation by an angle that depends on r alone,\n//   theta(r) = Gamma T / (4 pi r^2) = mu a^2 / (2 r^2),\n// with 2a the distance between the vortices. The vortices themselves never\n// move: only one is on at a time, and a vortex is not moved by its own field.\nconst AV = 30, CX = 32, YA = 64 - AV, YB = 64 + AV, A2 = AV * AV;\n\n// A dye lasts 12 / mu half periods (3 to 6), then a fresh one fades in at\n// the start of the next. By then an S of dye mixed finer than an LED joins\n// the two vortices.\nconst life = (mu) => cl(round(12 / mu), 3, 6);\n// A fresh start begins this far into a dye, so the stirring shows at once.\nconst AHEAD = 2;\n\n// The angles reach thousands of radians next to a vortex, so sine and cosine\n// come from a table of 4096 steps with linear interpolation: an error near\n// 3e-7, far below an LED, at half the cost of Math.sin and Math.cos.\nconst TB = 4096, MASK = TB - 1, KT = TB / (2 * PI);\nconst SN = new Float64Array(TB + 1), CS = new Float64Array(TB + 1);\nfor (let i = 0; i \u003c= TB; i++) (SN[i] = sin(i / KT)), (CS[i] = cos(i / KT));\n\n// One sample an LED, at its centre, and the LED's own square traced back\n// with it: each half period's rotation has an exact Jacobian, so the square's\n// two edges are carried back step by step, and the dye is averaged over the\n// patch of the first dye they cover. Where the stirring has pulled one LED's\n// worth of fluid out over many bands, the LED shows their mean instead of\n// one band picked at random.\n//\n// The dye has two parts laid along one coordinate u: bands (u = y), stripes\n// (u = x) or rings round the midpoint (u = distance), or two halves either\n// side of the vortices (u = x - 32, with the shade along y). Its colour,\n// dye A or dye B, changes sharply every P / 2 along u. Its shade rises and\n// falls as a cosine of period P / 2, darkest where the colour changes and\n// brightest in the middle of each band. The two colours share\n// their brightest channel, so a colour edge never shows as a step in\n// brightness; only the shade does, and the shade is soft.\nconst LAYOUTS = [\n  { u: 1, P: 40 },\n  { u: 3, P: 64 },\n  { u: 0, P: 32 },\n  { u: 2, P: 32 },\n];\n// Shade: L0 - L1 cos(4 pi u / P), from 0.17 to 0.97.\nconst L0 = 0.57, L1 = 0.4;\n// The shade is averaged as if the LED were BLUR times its traced size, so a\n// band of shade fades into its mean before it is squeezed steep enough to\n// step more than 40 levels from one LED to the next; the colour is averaged\n// over the LED's own traced size.\nconst BLUR = 3;\n\n// The length of [0, P/2) mod P that lies below u.\nfunction below(u, P) {\n  const k = floor(u / P), r = u - k * P;\n  return k * (P / 2) + (r > P / 2 ? P / 2 : r);\n}\n\n// The share of dye A in a box of width w round u.\nfunction shareA(halves, u, w, P) {\n  if (halves) return w \u003c 1e-6 ? (u \u003c 0 ? 1 : 0) : cl(0.5 - u / w, 0, 1);\n  if (w \u003c 1e-3) return u - floor(u / P) * P \u003c P / 2 ? 1 : 0;\n  if (w > 1e7) return 0.5;\n  return (below(u + w / 2, P) - below(u - w / 2, P)) / w;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: AHEAD, f: 0, born: 0, gen: 0, old: -1, fade: 1,\n    hue: 0, mu: 2, layout: 0,\n    cv: [0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.mu = cl(k[2], 2, 16);\n  S.layout = cl(round(k[3]), 0, 3);\n  const rate = d * cl(k[1], 0.2, 3) * 1.1;\n  S.f += rate;\n  // A new dye fades in over 0.4 of a half period while the old one, still\n  // being stirred under it, fades out.\n  if (S.old >= 0 && (S.fade += rate * 2.5) >= 1) S.old = -1;\n  const lay = () => ((S.old = S.born), (S.born = S.n), (S.gen ^= 1), (S.fade = 0));\n  while (S.f >= 1) {\n    S.f -= 1;\n    S.n++;\n    if (S.old \u003c 0 && S.n - S.born >= life(S.mu)) lay();\n  }\n  // A press lays a fresh dye now.\n  if (input.btnPressed && input.btnPressed.some(Boolean) && S.old \u003c 0) lay();\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const n = S.n, f = S.f, c = (S.mu * A2) / 2, L = LAYOUTS[S.layout], gen = S.gen, cv = S.cv;\n  // The new dye was laid at the start of half period born: it has been turned\n  // by the whole half periods born..n-1 and part of n. An old dye still\n  // fading out has been turned longer.\n  const sNew = n - S.born + 1, sOld = S.old >= 0 ? n - S.old + 1 : -1;\n  const steps = max(sNew, sOld);\n  const fi = S.fade, wNew = sOld >= 0 ? fi * fi * (3 - 2 * fi) : 1;\n  // Both dyes keep blue as their brightest channel at the opening hue.\n  const dyeA = hsv(0.51 + S.hue, 0.75, 1), dyeB = hsv(0.79 + S.hue, 0.6, 1);\n  const col = (a, lv, g, ch) => lv * (g ? dyeB[ch] * a + dyeA[ch] * (1 - a) : dyeA[ch] * a + dyeB[ch] * (1 - a));\n  for (let j = 0; j \u003c H; j++)\n    for (let i = 0; i \u003c W; i++) {\n      let x = i + 0.5, y = j + 0.5;\n      // The LED's two edges, carried back with it.\n      let ux = 1, uy = 0, vx = 0, vy = 1;\n      // Undo the part of the current half period already turned, then the\n      // whole half periods before it, newest first. Half period m is\n      // stirred by vortex A when m is even and by B when it is odd.\n      let frac = f, m = n, aN = 0, lN = 0;\n      for (let s = 0; s \u003c steps; s++) {\n        const cy = m & 1 ? YB : YA, dx = x - CX, dy = y - cy, r2 = dx * dx + dy * dy + 1e-9;\n        const th = (frac * c) / r2;\n        let a = th * KT;\n        if (a > 1e9) a %= TB;\n        const a0 = a | 0, t = a - a0, q = a0 & MASK;\n        const co = CS[q] + t * (CS[q + 1] - CS[q]), sn = SN[q] + t * (SN[q + 1] - SN[q]);\n        // Back in time: rotate by minus the angle. The angle falls off as\n        // 1/r^2, so an edge e first shears by (2 theta / r^2)(d . e) along\n        // the circle and then turns with the point.\n        const sh = (2 * th) / r2, pu = sh * (dx * ux + dy * uy), pv = sh * (dx * vx + dy * vy);\n        const ux1 = ux - dy * pu, uy1 = uy + dx * pu, vx1 = vx - dy * pv, vy1 = vy + dx * pv;\n        ux = co * ux1 + sn * uy1, uy = co * uy1 - sn * ux1;\n        vx = co * vx1 + sn * vy1, vy = co * vy1 - sn * vx1;\n        x = CX + dx * co + dy * sn;\n        y = cy - dx * sn + dy * co;\n        frac = 1;\n        m--;\n        if (s + 1 === sNew) dyeAt(L, x, y, ux, uy, vx, vy, cv), (aN = cv[0]), (lN = cv[1]);\n      }\n      let r = col(aN, lN, gen, 0), g = col(aN, lN, gen, 1), b = col(aN, lN, gen, 2);\n      if (wNew \u003c 1) {\n        dyeAt(L, x, y, ux, uy, vx, vy, cv);\n        const k = 1 - wNew;\n        r = r * wNew + k * col(cv[0], cv[1], gen ^ 1, 0);\n        g = g * wNew + k * col(cv[0], cv[1], gen ^ 1, 1);\n        b = b * wNew + k * col(cv[0], cv[1], gen ^ 1, 2);\n      }\n      display.setPixel(i, j, (255 * min(1, r)) | 0, (255 * min(1, g)) | 0, (255 * min(1, b)) | 0);\n    }\n  // The vortices: the one stirring burns white, the resting one is a dim ring.\n  const on = n & 1 ? 1 : 0;\n  for (let v = 0; v \u003c 2; v++) {\n    const cy = v ? YB : YA, act = v === on;\n    for (let dy = -2; dy \u003c= 1; dy++)\n      for (let dx = -2; dx \u003c= 1; dx++) {\n        const r = sqrt((dx + 0.5) * (dx + 0.5) + (dy + 0.5) * (dy + 0.5));\n        const x = CX + dx, y = cy + dy;\n        if (act) {\n          const b = r \u003c 1 ? 255 : r \u003c 2 ? 150 : 0;\n          if (b) display.setPixel(x, y, b, b, b);\n        } else if (r > 1 && r \u003c 2.2) display.setPixel(x, y, 120, 120, 130);\n        else if (r \u003c 1) display.setPixel(x, y, 0, 0, 0);\n      }\n  }\n}\n\n// The dye at the traced-back point (x, y), averaged over what the LED's\n// traced-back edges cover: out[0] the share of dye A, out[1] the shade.\nfunction dyeAt(L, x, y, ux, uy, vx, vy, out) {\n  let u, w;\n  if (L.u === 1) (u = y), (w = abs(uy) + abs(vy));\n  else if (L.u === 0 || L.u === 3) (u = L.u === 3 ? x - CX : x), (w = abs(ux) + abs(vx));\n  else {\n    const dx = x - CX, dy = y - 64, r = sqrt(dx * dx + dy * dy) + 1e-9, gx = dx / r, gy = dy / r;\n    (u = r), (w = abs(gx * ux + gy * uy) + abs(gx * vx + gy * vy));\n  }\n  // A square pulled out longer than a period does not stay straight: the\n  // flow folds it, so it crosses the bands even when its two traced edges\n  // happen to lie along them. Past a period, its length counts as width.\n  const s = sqrt(ux * ux + uy * uy + vx * vx + vy * vy), fold = (s * s) / (s + L.P);\n  out[0] = shareA(L.u === 3, u, max(w, fold), L.P);\n  // The halves take their shade from bands along y.\n  let us = u, ws = w;\n  if (L.u === 3) (us = y), (ws = abs(uy) + abs(vy));\n  // A cosine averaged over a Gaussian as wide as the box keeps\n  // exp(-(k w)^2 / 24) of its swing, k its wavenumber.\n  const kw = ((4 * PI) / L.P) * BLUR * max(ws, fold);\n  out[1] = L0 - L1 * exp(-(kw * kw) / 24) * cos(((4 * PI) / L.P) * us);\n}\n","braille-relief":"// ===== Patternflow pattern =====\n// Title:   Braille Relief\n// Family:  type\n// Idea:    A page of embossed six-dot braille lies in the dark under a low lamp that circles it, so each raised dot shows only as a lit side and a long shadow, while a fingertip glow reads along the lines cell by cell and the print letter it has just felt surfaces small under the cell and fades.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: six-dot braille (Louis Braille, Procédé pour écrire les paroles, la musique et le plain-chant au moyen de points, 1829), uncontracted English letters; text from Helen Keller, The Story of My Life (1903); pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Relief=0.4..2.4, Light=0..1\n//\n// Knob 1: Hue. Turns the lamp, the shade and the print round the wheel together: at 0 a cream lamp on cool grey paper, blue-violet in the shadows, the print letters pale sky blue.\n// Knob 2: Speed. How fast the fingertip reads: 2.5 cells a second at 2, so the 40 cells of the first page take 16 s, 0.25 at 0.2 and 3.75 at 3. The lamp circles the page once in 16 s at 2, once in 36 s at 0.2, so the light moves however slowly the page is read.\n// Knob 3: Relief. The height of each dot, from 0.4 LED, barely raised, where the lamp finds a lit rim and a short shadow, to 2.4 LEDs, where every dot throws a shadow down the page across the dots behind it.\n// Knob 4: Light. How high the lamp stands: 3 degrees above the paper at 0 (4 at the opening 0.06), where the dots blaze on one side and their shadows run 19 times their height (14 at the opening); 20 degrees at 1, where the shadows shrink to under 3 times and the dots fade to a faint crescent.\n// Buttons: any knob's button turns to the next page.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Braille. Dots are numbered 1-2-3 down the left column and 4-5-6 down\n// the right. The first ten letters use only dots 1, 2, 4 and 5; k to t are\n// a to j with dot 3 added; u, v, x, y and z are a to e with dots 3 and 6\n// added; w stands outside the series as 2-4-5-6. A word broken at the end of\n// a line takes the hyphen, dots 3-6. Checked against Unicode's braille block:\n// a to z come out as U+2801 2803 2809 2819 2811 280B 281B 2813 280A 281A 2805\n// 2807 280D 281D 2815 280F 281F 2817 280E 281E 2825 2827 283A 282D 283D 2835.\nconst AJ = [[1], [1, 2], [1, 4], [1, 4, 5], [1, 5], [1, 2, 4], [1, 2, 4, 5], [1, 2, 5], [2, 4], [2, 4, 5]];\nconst DOTS = { \" \": [], \"-\": [3, 6], w: [2, 4, 5, 6] };\nfor (let i = 0; i \u003c 10; i++) {\n  DOTS[\"abcdefghij\"[i]] = AJ[i];\n  DOTS[\"klmnopqrst\"[i]] = [...AJ[i], 3];\n  if (i \u003c 5) DOTS[\"uvxyz\"[i]] = [...AJ[i], 3, 6];\n}\n\n// Helen Keller at the well-house, from chapter IV of The Story of My Life.\n// Grade 1 braille, letters and spaces only: the capital sign (dot 6) before\n// Everything and I is left out, and so are the comma and the full stops. No\n// number sign is needed, as the text has no numbers. 119 letters in 29 words\n// fill four pages with 4 hyphens and 354 raised dots.\nconst TEXT =\n  \"every|thing had a name and each name gave birth to a new thought as we re|turned to the house every ob|ject which i touched seemed to quiv|er with life\";\n\n// ---- The page. Dots 4 LEDs apart inside a cell, cells 10 apart, six to a\n// line; lines 18 apart, seven to a page, which leaves a gap of 7 rows under\n// each line for the print letter. Embossed braille keeps about 2.5 mm, 6 mm\n// and 10 mm; this page keeps the first two near that ratio and sets its lines\n// a little wider for the letters.\nconst DP = 4, CP = 10, NC = 6, LP = 18, NL = 7, X0 = 5, Y0 = 3, R = 1.75;\nconst PER = NC * NL;\n\n// Words go whole onto a line when they fit. A word that does not fit the\n// room left is broken at a syllable marked | in the text if its first part\n// and a hyphen fit, and otherwise starts a new line. A word longer than the\n// whole line (thought, touched) has no other way and is broken after five\n// letters.\nfunction paginate(text) {\n  const cells = [];\n  let col = 0;\n  const put = (ch) => {\n    cells.push(ch);\n    col = (col + 1) % NC;\n  };\n  const newline = () => {\n    while (col > 0) put(\" \");\n  };\n  for (const word of text.split(\" \")) {\n    const parts = word.split(\"|\");\n    let w = parts.join(\"\");\n    if (w.length > NC - col) {\n      let cut = 0;\n      for (let i = 1, k = 0; i \u003c parts.length; i++) {\n        k += parts[i - 1].length;\n        if (k + 1 \u003c= NC - col) cut = k;\n      }\n      if (cut) {\n        for (const ch of w.slice(0, cut)) put(ch);\n        put(\"-\");\n        w = w.slice(cut);\n      } else newline();\n    }\n    while (w.length > NC) {\n      for (const ch of w.slice(0, NC - 1)) put(ch);\n      put(\"-\");\n      w = w.slice(NC - 1);\n    }\n    for (const ch of w) put(ch);\n    if (col > 0) put(\" \");\n  }\n  while (cells.length % PER) cells.push(\" \");\n  const pages = [];\n  for (let i = 0; i \u003c cells.length; i += PER) pages.push(cells.slice(i, i + PER));\n  return pages;\n}\nconst PAGES = paginate(TEXT);\n// The fingertip stops at the last letter of a page, not at the blank cells\n// that pad the last page out.\nconst ENDS = PAGES.map((pg) => {\n  let e = PER;\n  while (e > 1 && pg[e - 1] === \" \") e--;\n  return e;\n});\n\n// Dot slot s = (line * NC + cell) * 6 + (dot - 1); its centre falls on a\n// corner between LEDs, so a dot is a round 4 by 4 patch.\nconst NS = PER * 6, SX = new Float32Array(NS), SY = new Float32Array(NS);\nfor (let s = 0; s \u003c NS; s++) {\n  const c = floor(s / 6), k = s % 6;\n  SX[s] = X0 + (c % NC) * CP + floor(k / 3) * DP;\n  SY[s] = Y0 + floor(c / NC) * LP + (k % 3) * DP;\n}\nconst raised = (page, s) => DOTS[page[floor(s / 6)]].includes((s % 6) + 1);\n\n// ---- Print letters, 3 by 5, as small capitals: lowercase would need\n// descenders the gap under a line has no room for.\nconst FONT = {\n  a: \"010101111101101\", b: \"110101110101110\", c: \"011100100100011\", d: \"110101101101110\",\n  e: \"111100110100111\", f: \"111100110100100\", g: \"011100101101011\", h: \"101101111101101\",\n  i: \"111010010010111\", j: \"001001001101010\", k: \"101101110101101\", l: \"100100100100111\",\n  m: \"101111111101101\", n: \"110101101101101\", o: \"010101101101010\", p: \"110101110100100\",\n  q: \"010101101110011\", r: \"110101110101101\", s: \"011100010001110\", t: \"111010010010010\",\n  u: \"101101101101111\", v: \"101101101101010\", w: \"101101111111101\", x: \"101101010101101\",\n  y: \"101101010010010\", z: \"111001010100111\", \"-\": \"000000111000000\",\n};\n\n// ---- Paper grain: a fixed field of tiny slopes from a hash, smoothed, so the\n// paper glints a little where its fibres face the lamp.\nconst GX = new Float32Array(W * H), GY = new Float32Array(W * H);\n{\n  const hz = new Float32Array(W * H);\n  for (let i = 0; i \u003c W * H; i++) {\n    let h = (i * 2654435761) >>> 0;\n    h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0;\n    h = Math.imul(h ^ (h >>> 13), 3266489917) >>> 0;\n    hz[i] = ((h ^ (h >>> 16)) >>> 0) / 4294967296 - 0.5;\n  }\n  const sm = new Float32Array(W * H);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let a = 0;\n      for (let dy = -1; dy \u003c= 1; dy++)\n        for (let dx = -1; dx \u003c= 1; dx++) a += hz[cl(y + dy, 0, H - 1) * W + cl(x + dx, 0, W - 1)];\n      sm[y * W + x] = a / 9;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      GX[y * W + x] = 0.04 * (sm[y * W + min(W - 1, x + 1)] - sm[y * W + max(0, x - 1)]);\n      GY[y * W + x] = 0.04 * (sm[min(H - 1, y + 1) * W + x] - sm[max(0, y - 1) * W + x]);\n    }\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, relief: 0.4, light: 0.06, az: -2.4,\n    page: 0, read: 0, cell: 0, hold: 0, turn: 0,\n    seen: new Float32Array(PER).fill(-99),\n    lift: new Float32Array(NS),\n    cov: new Float32Array(W * H), lit: new Float32Array(W * H), hgt: new Float32Array(W * H),\n    own: new Int16Array(W * H), sh: new Float32Array(W * H), rgb: new Float32Array(W * H * 3),\n  };\n  const S = params.s;\n  for (let s = 0; s \u003c NS; s++) S.lift[s] = raised(PAGES[0], s) ? 1 : 0;\n  S.seen[0] = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.relief = cl(k[2], 0.4, 2.4);\n  S.light = cl(k[3], 0, 1);\n  // The lamp keeps circling however slowly the page is read.\n  S.az += d * (0.15 + 0.12 * S.speed);\n  let page = PAGES[S.page];\n  if (S.turn === 0) {\n    // Reading: the fingertip steps cell by cell, gliding over the first\n    // quarter of each step.\n    S.read += d * 1.25 * S.speed;\n    const c = floor(S.read);\n    if (c >= ENDS[S.page]) (S.turn = 1), (S.hold = 0), (S.read = ENDS[S.page] - 1e-6);\n    else if (c !== S.cell) (S.cell = c), (S.seen[c] = S.t);\n  } else {\n    // The page turns: hold 1.2 s, the dots sink in 0.8 s, and the next\n    // page is embossed line by line from the top.\n    S.hold += d;\n    if (S.turn === 1) {\n      const u = cl((S.hold - 1.2) / 0.8, 0, 1);\n      for (let s = 0; s \u003c NS; s++) S.lift[s] = raised(page, s) ? 1 - u * u * (3 - 2 * u) : 0;\n      if (u >= 1) (S.turn = 2), (S.hold = 0), (S.page = (S.page + 1) % PAGES.length), (page = PAGES[S.page]), S.seen.fill(-99);\n    } else {\n      for (let s = 0; s \u003c NS; s++) {\n        const u = cl((S.hold - 0.18 * floor(s / 6 / NC)) / 0.5, 0, 1);\n        S.lift[s] = raised(page, s) ? u * u * (3 - 2 * u) : 0;\n      }\n      if (S.hold > 0.18 * NL + 0.5) {\n        S.turn = 0, S.read = 0, S.cell = 0;\n        S.seen.fill(-99);\n        S.seen[0] = S.t;\n      }\n    }\n  }\n  // Any button turns to the next page now.\n  if (S.turn === 0 && input.btnPressed && input.btnPressed.some(Boolean)) (S.turn = 1), (S.hold = 1.2);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cov, lit, hgt, own, sh, lift, rgb } = S;\n  // The lamp: elevation e, toward-the-lamp direction (ux, uy) on the page.\n  const e = ((3 + 17 * S.light) * PI) / 180, se = sin(e), ce = cos(e), te = se / ce;\n  const ux = cos(S.az), uy = sin(S.az), Lx = ce * ux, Ly = ce * uy;\n  cov.fill(0), lit.fill(0), hgt.fill(0), own.fill(-1), sh.fill(0);\n\n  // Domes: h = Hd (1 - r^2 / R^2), shaded at 3 by 3 points in each LED by\n  // the lamp's angle to the surface.\n  for (let s = 0; s \u003c NS; s++) {\n    const Hd = S.relief * lift[s];\n    if (Hd \u003c 0.01) continue;\n    const cx = SX[s], cy = SY[s], g = (2 * Hd) / (R * R);\n    for (let py = cy - 2; py \u003c cy + 2; py++)\n      for (let px = cx - 2; px \u003c cx + 2; px++) {\n        const p = py * W + px;\n        let n = 0, v = 0;\n        for (let sy = 0; sy \u003c 3; sy++)\n          for (let sx = 0; sx \u003c 3; sx++) {\n            const dx = px + (sx + 0.5) / 3 - cx, dy = py + (sy + 0.5) / 3 - cy, r2 = dx * dx + dy * dy;\n            if (r2 >= R * R) continue;\n            // Normal (g dx, g dy, 1), unnormalised.\n            const hx = g * dx, hy = g * dy;\n            v += max(0, (hx * Lx + hy * Ly + se) / sqrt(hx * hx + hy * hy + 1));\n            n++;\n          }\n        if (!n) continue;\n        cov[p] = n / 9, lit[p] = v / 9;\n        const dx = px + 0.5 - cx, dy = py + 0.5 - cy, r2 = dx * dx + dy * dy;\n        if (r2 \u003c R * R) (hgt[p] = Hd * (1 - r2 / (R * R))), (own[p] = s);\n      }\n  }\n\n  // Cast shadows. A point at height z0 is in the shadow of a dome when the\n  // ray from it toward the lamp, climbing te per LED, passes under the dome.\n  // For the paraboloid this has a closed form: with d the offset from the\n  // dome's centre split along (dp) and across (dq) the lamp's direction, the\n  // ray's lowest clearance is\n  //   f = Hd + te^2 R^2 / (4 Hd) - Hd dq^2 / R^2 + te dp - z0,\n  // reached at distance s = -dp - te R^2 / (2 Hd) along the ray, so the\n  // shadow on flat paper is a parabola Hd / te long. f > 0 is shadow, softened\n  // over a penumbra that widens with s.\n  for (let s = 0; s \u003c NS; s++) {\n    const Hd = S.relief * lift[s];\n    if (Hd \u003c 0.01) continue;\n    const cx = SX[s], cy = SY[s], len = Hd / te + R + 1;\n    const x0 = max(0, floor(min(cx, cx - len * ux) - R - 1)), x1 = min(W - 1, ceil(max(cx, cx - len * ux) + R + 1));\n    const y0 = max(0, floor(min(cy, cy - len * uy) - R - 1)), y1 = min(H - 1, ceil(max(cy, cy - len * uy) + R + 1));\n    const sStar0 = (te * R * R) / (2 * Hd), k0 = Hd + (te * te * R * R) / (4 * Hd), kq = Hd / (R * R);\n    for (let py = y0; py \u003c= y1; py++)\n      for (let px = x0; px \u003c= x1; px++) {\n        const p = py * W + px;\n        if (own[p] === s) continue;\n        const dx = px + 0.5 - cx, dy = py + 0.5 - cy, dp = dx * ux + dy * uy, dq = -dx * uy + dy * ux;\n        const ss = -dp - sStar0;\n        if (ss \u003c= 0) continue;\n        const f = k0 - kq * dq * dq + te * dp - hgt[p];\n        if (f \u003c= -0.3) continue;\n        const a = cl(f / (0.1 + 0.05 * ss) + 0.5, 0, 1);\n        if (a > sh[p]) sh[p] = a;\n      }\n  }\n\n  // The fingertip rests on the cell being read and glides on to the next\n  // one over the first quarter of each step.\n  const cell = min(PER - 1, floor(S.read)), fr = S.read - cell, gl = min(1, fr * 4);\n  let fx = X0 + (cell % NC) * CP + 2, fy = Y0 + floor(cell / NC) * LP + 4;\n  if (S.turn === 0 && cell > 0 && gl \u003c 1) {\n    const pc = cell - 1, sm = gl * gl * (3 - 2 * gl);\n    const qx = X0 + (pc % NC) * CP + 2, qy = Y0 + floor(pc / NC) * LP + 4;\n    (fx = qx + (fx - qx) * sm), (fy = qy + (fy - qy) * sm);\n  }\n  // The hand lifts while the page turns.\n  const touch = S.turn === 0 ? 1 : S.turn === 1 ? max(0, 1 - S.hold / 1.2) : 0;\n\n  // Compose. Brightness goes by the ratio of light on a surface to the\n  // light on bare paper, so the paper stays dim at every elevation; a\n  // distant lamp falls off a little across the page.\n  const lamp = hsv(0.11 + S.hue, 0.45, 1), shade = hsv(0.68 + S.hue, 0.7, 1), paperC = hsv(0.62 + S.hue, 0.12, 0.95);\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px;\n      const gx = GX[p], gy = GY[p];\n      const paper = max(0, (-gx * Lx - gy * Ly + se) / sqrt(1 + gx * gx + gy * gy));\n      let v = (lit[p] + (1 - cov[p]) * paper) * (1 - 0.92 * sh[p]);\n      let rho = v / se;\n      rho *= 1 + (0.3 * ((px - 32) * ux + (py - 64) * uy)) / 64;\n      const dx = px + 0.5 - fx, dy = py + 0.5 - fy, gf = touch * exp(-(dx * dx) / 12 - (dy * dy) / 30);\n      rho = rho * (1 + 1.2 * gf) + 0.5 * gf;\n      const b = 1 - exp(-0.16 * rho * rho), amb = 0.04 + 0.03 * cov[p];\n      // Dim light reads brown on LEDs, so the lamp's colour comes in with\n      // its brightness: the paper is a cool grey, the lit sides cream.\n      const w = b \u003c 0.15 ? 0 : b > 0.6 ? 1 : (b - 0.15) / 0.45;\n      rgb[p * 3] = (paperC[0] + (lamp[0] - paperC[0]) * w) * b + shade[0] * amb;\n      rgb[p * 3 + 1] = (paperC[1] + (lamp[1] - paperC[1]) * w) * b + shade[1] * amb;\n      rgb[p * 3 + 2] = (paperC[2] + (lamp[2] - paperC[2]) * w) * b + shade[2] * amb;\n    }\n\n  // The print letters, under the cells read so far, each surfacing as the\n  // fingertip reaches it and fading over 3 s.\n  const page = PAGES[S.page], ink = hsv(0.56 + S.hue, 0.45, 1);\n  for (let c = 0; c \u003c PER; c++) {\n    const age = S.t - S.seen[c], glyph = FONT[page[c]];\n    if (!glyph || age \u003c 0 || age > 3.2) continue;\n    let a = age \u003c 0.15 ? age / 0.15 : age \u003c 0.8 ? 1 : max(0, 1 - (age - 0.8) / 2.4);\n    if (S.turn) a *= touch;\n    if (a \u003c= 0.01) continue;\n    const lx = X0 + (c % NC) * CP + 1, ly = Y0 + floor(c / NC) * LP + 11;\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++) {\n        if (glyph[r * 3 + q] !== \"1\") continue;\n        const o = ((ly + r) * W + lx + q) * 3;\n        rgb[o] += ink[0] * a, rgb[o + 1] += ink[1] * a, rgb[o + 2] += ink[2] * a;\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++)\n    display.setPixel(p % W, floor(p / W), (255 * min(1, rgb[p * 3])) | 0, (255 * min(1, rgb[p * 3 + 1])) | 0, (255 * min(1, rgb[p * 3 + 2])) | 0);\n}\n","distance-field":"// ===== Patternflow pattern =====\n// Title:   Distance Field\n// Family:  type\n// Idea:    One glyph fills the panel, kept only as a coarse grid of signed distances whose texel centres show as dim dots, and every LED is drawn by magnifying that grid bilinearly and cutting it at a threshold, so W, S, K, 3, 빛 and ? keep crisp edges at any grid size while their corners round off and thin strokes vanish as the grid coarsens; an outline band and an outer glow come from the same field, and each glyph melts into the next by blending the two fields.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: signed distance fields for alpha-tested magnification (Chris Green, Valve, \"Improved Alpha-Tested Magnification for Vector Textures and Special Effects\", SIGGRAPH 2007), glyphs drawn for this pattern, pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Magnify=-1.5..1.8, Weight=-4..5\n//\n// Knob 1: Hue. Turns all three colours round the wheel together: at 0 a cyan glyph with a pale rim and a magenta glow.\n// Knob 2: Speed. How fast the glyphs come: at 2 each holds 2 seconds and melts into the next over 0.5, at 0.2 ten times slower; the glow's ripples move with it.\n// Knob 3: Magnify. How far the stored field is blown up, in octaves around 6 LEDs a texel where it opens (12 by 23 texels): at -1.5 a texel is 2 LEDs and the glyph is sharp, at 1 it is 12 LEDs and the corners are round, at 1.8 it is 21 LEDs, 4 by 8 texels, and the thin parts are gone.\n// Knob 4: Weight. Where the field is cut, in LEDs off the true outline: -4 thins every stroke by 8 LEDs, 0 is the drawn weight, 5 makes it 10 LEDs bolder and closes the small counters.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, abs, sqrt, exp, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Glyphs, as exact geometry in panel LEDs (x 0..64, y 0..128 down).\n// Each glyph is a union of simple polygons that may overlap: rectangles,\n// slanted bars cut level at both ends, and bands along an ellipse whose\n// arcs are flattened into chords of at most 5 degrees. The box is about\n// 56 by 116, x 4..60 and y 6..122. The round strokes are 12 LEDs wide, the\n// straight ones 8 to 15 and the Hangul ones 8 to 12, so at 12 LEDs a\n// texel the thin ones go first.\nconst rect = (x0, y0, x1, y1) => [[x0, y0], [x1, y0], [x1, y1], [x0, y1]];\n// A bar from a top edge centred on xt, wt wide, to a bottom edge on xb.\nconst bar = (xt, yt, wt, xb, yb, wb) => [[xt - wt / 2, yt], [xt + wt / 2, yt], [xb + wb / 2, yb], [xb - wb / 2, yb]];\n// A band hw either side of an ellipse from angle a0 to a1 in degrees,\n// clockwise on the panel (0 is right, 90 down), its ends cut along the\n// radius.\nfunction arc(cx, cy, rx, ry, hw, a0, a1) {\n  const n = ceil(abs(a1 - a0) / 5), out = [], inn = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, c = cos(a), s = sin(a);\n    out.push([cx + (rx + hw) * c, cy + (ry + hw) * s]);\n    inn.push([cx + (rx - hw) * c, cy + (ry - hw) * s]);\n  }\n  return out.concat(inn.reverse());\n}\nfunction disc(cx, cy, r) {\n  const p = [];\n  for (let i = 0; i \u003c 48; i++) p.push([cx + r * cos((i * PI) / 24), cy + r * sin((i * PI) / 24)]);\n  return p;\n}\n\n// The order alternates straight and round, so every melt turns a corner\n// into a curve or back.\nconst GLYPHS = [\n  // W: four bars, the inner two thinner and sharing the top apex.\n  [bar(9.5, 6, 11, 20, 122, 11), bar(31, 6, 8, 20, 122, 9), bar(33, 6, 8, 44, 122, 9), bar(54.5, 6, 11, 44, 122, 11)],\n  // S: two elliptic bowls meeting in the middle stroke at y 64.\n  [arc(32, 38, 22, 26, 6, -25, -280), arc(32, 90, 22, 26, 6, -100, 155)],\n  // K: the arm ends inside the stem, the leg starts inside the arm.\n  [rect(5, 6, 18, 122), bar(51, 6, 14, 12, 84, 12), bar(26, 56, 10, 51, 122, 15)],\n  // 3: a small bowl over a big one, a short tongue to the left where they\n  // meet, and a notch on the right between them.\n  [arc(30, 37, 22, 25, 6, -155, 100), arc(30, 89, 24, 27, 6, -100, 150), rect(17, 56, 32, 68)],\n  // 빛: ㅂ and ㅣ over the final ㅊ, whose top tick is the smallest stroke.\n  [\n    rect(5, 6, 15, 62), rect(28, 6, 38, 62), rect(5, 29, 38, 38), rect(5, 53, 38, 62), rect(47, 6, 57, 68),\n    rect(27, 69, 37, 77), rect(8, 81, 56, 90), bar(31, 88, 11, 10, 122, 12), bar(28, 92, 9, 54, 122, 12),\n  ],\n  // ?: a hook that turns into the stem, and a round dot.\n  [arc(32, 37, 22, 25, 6, -160, 92), rect(26, 58, 38, 92), disc(32, 112, 8.5)],\n];\n\n// Even-odd test against one simple polygon, kept flat as x0 y0 x1 y1 ...\n// after its bounding box.\nfunction flat(P) {\n  const f = new Float64Array(4 + 2 * P.length);\n  f[0] = f[1] = Infinity;\n  f[2] = f[3] = -Infinity;\n  P.forEach(([x, y], i) => {\n    f[4 + 2 * i] = x;\n    f[5 + 2 * i] = y;\n    if (x \u003c f[0]) f[0] = x;\n    if (y \u003c f[1]) f[1] = y;\n    if (x > f[2]) f[2] = x;\n    if (y > f[3]) f[3] = y;\n  });\n  return f;\n}\nfunction inPoly(f, x, y) {\n  if (x \u003c f[0] || y \u003c f[1] || x > f[2] || y > f[3]) return false;\n  let c = false;\n  for (let i = 4, j = f.length - 2; i \u003c f.length; j = i, i += 2) {\n    const xi = f[i], yi = f[i + 1], xj = f[j], yj = f[j + 1];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) c = !c;\n  }\n  return c;\n}\n\n// The outline of a union. Every polygon edge is split where any other\n// polygon's edge crosses it (or runs along it), and a piece is kept when a\n// point a hair to one side is in the union and a point to the other side is\n// not. Edges buried inside another polygon go, and so do edges where two\n// polygons only touch. The distance to the kept pieces is then the exact\n// distance to the glyph's outline, inside as well as outside: the plain\n// minimum of each polygon's own distance would be wrong inside, wherever\n// two strokes join.\nfunction outline(polys) {\n  const flats = polys.map(flat);\n  const inside = (x, y) => {\n    for (const f of flats) if (inPoly(f, x, y)) return true;\n    return false;\n  };\n  const segs = [];\n  polys.forEach((P, i) => {\n    for (let k = 0; k \u003c P.length; k++) {\n      const [ax, ay] = P[k], [bx, by] = P[(k + 1) % P.length];\n      const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;\n      if (L2 \u003c 1e-12) continue;\n      const ts = [0, 1];\n      polys.forEach((Q, j) => {\n        if (j === i) return;\n        for (let m = 0; m \u003c Q.length; m++) {\n          const [cx, cy] = Q[m], [ex, ey] = Q[(m + 1) % Q.length];\n          const fx = ex - cx, fy = ey - cy, den = dx * fy - dy * fx;\n          if (abs(den) \u003c 1e-12) {\n            if (abs((cx - ax) * dy - (cy - ay) * dx) \u003c 1e-9) ts.push(((cx - ax) * dx + (cy - ay) * dy) / L2, ((ex - ax) * dx + (ey - ay) * dy) / L2);\n            continue;\n          }\n          const u = ((cx - ax) * dy - (cy - ay) * dx) / den;\n          if (u >= 0 && u \u003c= 1) ts.push(((cx - ax) * fy - (cy - ay) * fx) / den);\n        }\n      });\n      const tt = ts.filter((t) => t >= 0 && t \u003c= 1).sort((a, b) => a - b);\n      const L = sqrt(L2), nx = (-dy / L) * 1e-4, ny = (dx / L) * 1e-4;\n      for (let q = 1; q \u003c tt.length; q++) {\n        if (tt[q] - tt[q - 1] \u003c 1e-9) continue;\n        const tm = (tt[q] + tt[q - 1]) / 2, mx = ax + dx * tm, my = ay + dy * tm;\n        if (inside(mx + nx, my + ny) !== inside(mx - nx, my - ny))\n          segs.push(ax + dx * tt[q - 1], ay + dy * tt[q - 1], ax + dx * tt[q], ay + dy * tt[q]);\n      }\n    }\n  });\n  return { segs: Float64Array.from(segs), inside };\n}\n\n// Signed distance in LEDs, negative inside.\nfunction sdf(G, x, y) {\n  const s = G.segs;\n  let d2 = Infinity;\n  for (let i = 0; i \u003c s.length; i += 4) {\n    const ax = s[i], ay = s[i + 1], dx = s[i + 2] - ax, dy = s[i + 3] - ay;\n    let t = ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy);\n    t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n    const ex = x - ax - t * dx, ey = y - ay - t * dy, e = ex * ex + ey * ey;\n    if (e \u003c d2) d2 = e;\n  }\n  return G.inside(x, y) ? -sqrt(d2) : sqrt(d2);\n}\n\n// The texel grid for a texel size of s LEDs: centres on LED centres, s\n// apart, the first at or left of the panel's first LED and the last at or\n// right of its last, so the reconstruction never runs off the field.\nfunction grid(s) {\n  const nx = ceil((W - 1) / s) + 1, ny = ceil((H - 1) / s) + 1;\n  const ox = -floor(((nx - 1) * s - (W - 1)) / 2), oy = -floor(((ny - 1) * s - (H - 1)) / 2);\n  // For each LED column and row: the texel to its left (above) and how far\n  // along to the next one, for the bilinear weights.\n  const xi = new Int16Array(W), xf = new Float32Array(W), yi = new Int16Array(H), yf = new Float32Array(H);\n  for (let x = 0; x \u003c W; x++) {\n    const g = (x - ox) / s, i = min(nx - 2, floor(g));\n    xi[x] = i;\n    xf[x] = g - i;\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const g = (y - oy) / s, j = min(ny - 2, floor(g));\n    yi[y] = j;\n    yf[y] = g - j;\n  }\n  return { s, nx, ny, ox, oy, xi, xf, yi, yf, fields: [] };\n}\n\n// Sample a glyph's exact distance at every texel centre (LED centres sit at\n// x + 0.5). This is the whole texture: nothing else of the glyph survives.\nfunction field(G, glyph) {\n  if (G.fields[glyph]) return G.fields[glyph];\n  const F = new Float32Array(G.nx * G.ny), O = OUTLINES[glyph];\n  for (let j = 0; j \u003c G.ny; j++)\n    for (let i = 0; i \u003c G.nx; i++) F[j * G.nx + i] = sdf(O, G.ox + i * G.s + 0.5, G.oy + j * G.s + 0.5);\n  return (G.fields[glyph] = F);\n}\n\nconst OUTLINES = GLYPHS.map(outline);\nconst NG = GLYPHS.length;\n// Seconds at Speed 2: a glyph holds HOLD, then melts into the next over MELT.\nconst HOLD = 2, MELT = 0.5, BEAT = HOLD + MELT;\n// The rim: a band this many LEDs wide just inside the cut.\nconst RIM = 1.3;\n\nexport function setup(params) {\n  params.s = { T: 0, ripple: 0, G: grid(6), F: null, hue: 0, weight: 0 };\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3) / 2;\n  S.T += dt * sp;\n  S.ripple += dt * sp * 0.55;\n  S.hue = k[0];\n  S.weight = cl(k[3], -6, 8);\n  const s = cl(round(6 * 2 ** cl(k[2], -2, 2)), 2, 21);\n  if (s !== S.G.s) S.G = grid(s);\n  // The texture of the moment: one glyph's field, or two blended while it\n  // melts. A blend of two distance fields is not itself a distance field,\n  // but its zero set slides from one outline to the other.\n  const n = floor(S.T / BEAT), u = smooth((S.T - n * BEAT - HOLD) / MELT);\n  const A = field(S.G, n % NG);\n  if (u \u003c= 0) S.F = A;\n  else {\n    const B = field(S.G, (n + 1) % NG);\n    if (!S.F || S.F === A || S.F === B || S.F.length !== A.length) S.F = new Float32Array(A.length);\n    for (let i = 0; i \u003c A.length; i++) S.F[i] = A[i] + (B[i] - A[i]) * u;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.F) return;\n  const { G, F, weight } = S;\n  const { nx, xi, xf, yi, yf } = G;\n  const buf = S.buf || (S.buf = new Float32Array(W * H * 3));\n  const [fr, fg, fb] = hsv(0.5 + S.hue, 0.78, 1);\n  const [rr, rg, rb] = hsv(0.47 + S.hue, 0.22, 1);\n  const [gr, gg, gb] = hsv(0.87 + S.hue, 0.72, 1);\n  const ph = S.ripple;\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    const r0 = yi[y] * nx, r1 = r0 + nx, v = yf[y];\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      // Bilinear magnification, what the texture unit does for free.\n      const i = xi[x], h = xf[x];\n      const top = F[r0 + i] + (F[r0 + i + 1] - F[r0 + i]) * h;\n      const bot = F[r1 + i] + (F[r1 + i + 1] - F[r1 + i]) * h;\n      const e = top + (bot - top) * v - weight;\n      // Alpha test, softened over one LED so the cut edge is crisp but not\n      // stair-stepped.\n      const a = cl(0.5 - e, 0, 1);\n      let R = 0, Gc = 0, B = 0;\n      if (a > 0) {\n        // Deeper inside is brighter, so the spine of each stroke shows.\n        const lv = 0.5 + 0.5 * smooth(-e / 6), rim = cl(e + RIM + 0.5, 0, 1);\n        R = a * (fr * lv + (rr - fr * lv) * rim);\n        Gc = a * (fg * lv + (rg - fg * lv) * rim);\n        B = a * (fb * lv + (rb - fb * lv) * rim);\n      }\n      if (a \u003c 1) {\n        // Outer glow from the same field: falls off with distance, with\n        // slow rings at fixed distances running outward.\n        const d = e > 0 ? e : 0;\n        const g = (1 - a) * 0.8 * exp(-d / 4.2) * (0.6 + 0.4 * cos(2 * PI * (d / 7 - ph)));\n        R += gr * g;\n        Gc += gg * g;\n        B += gb * g;\n      }\n      buf[p] = R;\n      buf[p + 1] = Gc;\n      buf[p + 2] = B;\n    }\n  }\n  // The texel centres, dim dots: dark holes where they fall in the glyph,\n  // faint light where they fall outside. Too dense to read below 4 LEDs.\n  const fade = cl((G.s - 2) / 3, 0, 1);\n  if (fade > 0) {\n    const [dr, dg, db] = hsv(0.6 + S.hue, 0.25, 0.28 * fade);\n    for (let j = 0; j \u003c G.ny; j++) {\n      const y = G.oy + j * G.s;\n      if (y \u003c 0 || y >= H) continue;\n      for (let i = 0; i \u003c nx; i++) {\n        const x = G.ox + i * G.s;\n        if (x \u003c 0 || x >= W) continue;\n        const e = F[j * nx + i] - weight, p = (y * W + x) * 3;\n        if (e \u003c 0) {\n          const k = 1 - 0.55 * fade;\n          buf[p] *= k;\n          buf[p + 1] *= k;\n          buf[p + 2] *= k;\n        } else {\n          buf[p] += dr;\n          buf[p + 1] += dg;\n          buf[p + 2] += db;\n        }\n      }\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, buf[p] * 255), min(255, buf[p + 1] * 255), min(255, buf[p + 2] * 255));\n}\n","dupin-cyclide":"// ===== Patternflow pattern =====\n// Title:   Dupin Cyclide\n// Family:  geometry\n// Idea:    A torus turns at the top of the panel and below it its image under an inversion in a sphere turns with it, a Dupin cyclide drawn as the two families of circles that are its lines of curvature, every torus circle landing on a circle, while a band of light runs round both families on both surfaces at once.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dupin cyclides (Charles Dupin, 1822), the surfaces whose lines of curvature are all circles, each the image of a torus, a circular cylinder or a circular cone under an inversion in a sphere; pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..2, Distance=0..1\n//\n// Knob 1: Hue. Turns both families round the wheel together: at 0 the circles round the tube are cyan and the circles round the hole rose.\n// Knob 2: Speed. How fast the pair turns and the band of light runs: one turn in 11 seconds at 2, in 112 at 0.2.\n// Knob 3: Shape. The torus tube against its centre circle, and so the cyclide's type: a ring torus and ring cyclide at 0 (tube half the radius), the horn pair at 1 where the hole closes to a point, and spindle pairs up to 2 where the tube is 1.6 times the radius and the surface passes through itself.\n// Knob 4: Distance. The gap between the torus and the centre of inversion below it, in outer radii of the torus: 1.2 at 0 and 1.45 at the opening 0.06, where the cyclide's tube is 3.1 times as thick at the bottom as at the top, out to 29 at 1, where the image is the torus again to within 9 per cent.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, cos, sin, exp, PI, hypot } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The torus: centre circle radius 1 in the plane z = 0, centred at (0, d, 0),\n// so it stands on edge facing the viewer, and the centre of inversion is the\n// origin, d below it. Meridians (u fixed, round the tube) and parallels (v\n// fixed, round the hole) are its two families of lines of curvature.\nconst NU = 18, NV = 10, K = 60;\n// Panel boxes: the torus above, the cyclide below.\nconst TOP = [1, 57], BOT = [63, 126], BW = 61;\n\nconst sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];\nconst add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];\n\n// The circle through three points: centre, radius and an orthonormal pair\n// spanning its plane.\nfunction circleThrough(A, B, C) {\n  const a = sub(A, C), b = sub(B, C), n = cross(a, b), nn = dot(n, n);\n  const c = add(C, scale(cross(sub(scale(b, dot(a, a)), scale(a, dot(b, b))), n), 1 / (2 * nn)));\n  const e1 = sub(A, c), rad = sqrt(dot(e1, e1));\n  const u = scale(e1, 1 / rad), w = cross(scale(n, 1 / sqrt(nn)), u);\n  return { c, rad, u, w };\n}\n\n// One circle of the torus, as centre, radius and plane.\nfunction torusCircle(fam, i, r, d, us) {\n  if (fam === 0) {\n    const u = us[i];\n    return { c: [cos(u), d + sin(u), 0], rad: r, u: [cos(u), sin(u), 0], w: [0, 0, 1] };\n  }\n  const v = (i / NV) * TAU;\n  return { c: [0, d, r * sin(v)], rad: 1 + r * cos(v), u: [1, 0, 0], w: [0, 1, 0] };\n}\nconst onCircle = (C, t) => add(C.c, add(scale(C.u, C.rad * cos(t)), scale(C.w, C.rad * sin(t))));\n// The inversion in the sphere of radius d about the origin, followed by the\n// point reflection through it (an anti-inversion), so the image hangs below\n// the centre the way the torus stands above it. Spheres go to spheres and\n// circles to circles either way.\nconst invert = (p, k2) => scale(p, -k2 / dot(p, p));\n\nfunction build(S) {\n  const r = S.r, d = (1 + r) * (1 + S.del), k2 = d * d;\n  // Where the meridians sit. The inversion stretches the side of the torus\n  // nearest the centre k2 / |p|^2 times, so meridians evenly spaced on the\n  // torus crowd on the image's thin side. Spacing them evenly in the square\n  // root of that stretch splits the crowding between the two surfaces, and\n  // the torus shows where the inversion pulls hardest.\n  const F = [0];\n  for (let j = 1; j \u003c= 720; j++) {\n    const u = -PI / 2 + ((j - 0.5) / 720) * TAU, q = cos(u) ** 2 + (d + sin(u)) ** 2;\n    F[j] = F[j - 1] + sqrt(k2 / q);\n  }\n  const us = [];\n  for (let i = 0, j = 0; i \u003c NU; i++) {\n    const want = (i / NU) * F[720];\n    while (F[j + 1] \u003c want) j++;\n    us.push(-PI / 2 + ((j + (want - F[j]) / (F[j + 1] - F[j] || 1)) / 720) * TAU);\n  }\n  const objs = [[], []];\n  for (let fam = 0; fam \u003c 2; fam++)\n    for (let i = 0; i \u003c (fam ? NV : NU); i++) {\n      const T = torusCircle(fam, i, r, d, us);\n      // A horn torus has a parallel of radius 0 where the hole closes, a\n      // point: there is no circle to draw.\n      if (abs(T.rad) \u003c 1e-3) continue;\n      objs[0].push({ fam, i, C: T });\n      // The image of a circle is a circle, so three image points fix it.\n      const P = [0, 1, 2].map((j) => invert(onCircle(T, (j * TAU) / 3 + 0.3), k2));\n      objs[1].push({ fam, i, C: circleThrough(P[0], P[1], P[2]) });\n    }\n  // Sample every circle and fit each surface to its box. The turn is about\n  // the vertical axis, and a half turn about it maps each surface onto\n  // itself, so the drawing is never wider than twice the largest distance\n  // from that axis.\n  S.objs = objs.map((list, o) => {\n    let ylo = 1e9, yhi = -1e9, rad = 0;\n    const pts = list.map(({ C }) => {\n      const a = new Float32Array(K * 3);\n      for (let j = 0; j \u003c K; j++) {\n        const p = onCircle(C, (j / K) * TAU);\n        a.set(p, j * 3);\n        ylo = min(ylo, p[1]);\n        yhi = max(yhi, p[1]);\n        rad = max(rad, hypot(p[0], p[2]));\n      }\n      return a;\n    });\n    const box = o ? BOT : TOP;\n    const s = min(BW / (2 * rad), (box[1] - box[0]) / (yhi - ylo));\n    return { list, pts, s, rad, ym: (ylo + yhi) / 2, cy: (box[0] + box[1]) / 2 };\n  });\n}\n\nexport function setup(params) {\n  params.s = { phi: 0.5, band: 0, key: \"\", R: new Float32Array(W * H), G: new Float32Array(W * H), B: new Float32Array(W * H) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1], 0.2, 3);\n  S.phi += dt * speed * 0.28;\n  S.band += dt * speed * 1.1;\n  // Shape: tube over centre radius 0.5 (ring) to 1 (horn) to 1.6 (spindle).\n  const sh = cl(k[2], 0, 2);\n  S.r = sh \u003c= 1 ? 0.5 + 0.5 * sh : 1 + 0.6 * (sh - 1);\n  // Distance: the gap between the torus and the centre, in outer radii.\n  S.del = 1.2 * exp(3.2 * cl(k[3], 0, 1));\n  const key = S.r.toFixed(4) + \",\" + S.del.toFixed(4);\n  if (key !== S.key) {\n    S.key = key;\n    build(S);\n  }\n}\n\n// An antialiased line one LED wide, kept as the brightest colour per LED.\nfunction line(S, x0, y0, x1, y1, r, g, b) {\n  const dx = x1 - x0, dy = y1 - y0, L = dx * dx + dy * dy;\n  const xa = max(0, floor(min(x0, x1) - 1)), xb = min(W - 1, floor(max(x0, x1) + 1));\n  const ya = max(0, floor(min(y0, y1) - 1)), yb = min(H - 1, floor(max(y0, y1) + 1));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x - x0, py = y - y0;\n      const t = L ? cl((px * dx + py * dy) / L, 0, 1) : 0;\n      const ex = px - t * dx, ey = py - t * dy;\n      const a = cl(1.05 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (a \u003c= 0) continue;\n      const p = y * W + x;\n      if (r * a > S.R[p]) S.R[p] = r * a;\n      if (g * a > S.G[p]) S.G[p] = g * a;\n      if (b * a > S.B[p]) S.B[p] = b * a;\n    }\n}\n\nexport function draw(display, params) {\n  if (!params.s || !params.s.objs) return;\n  const S = params.s;\n  S.R.fill(0);\n  S.G.fill(0);\n  S.B.fill(0);\n  const cphi = cos(S.phi), sphi = sin(S.phi);\n  const cols = [hsv(S.hue + 0.5, 0.8, 1), hsv(S.hue + 0.88, 0.62, 1)];\n  const sx = [], sy = [], sz = [];\n  S.objs.forEach((O, o) => {\n    const dim = o ? 1 : 0.8;\n    O.list.forEach(({ fam, i }, n) => {\n      const a = O.pts[n];\n      // The band of light: a soft bump running round each family's index,\n      // the same circles lit on the torus and on its image.\n      const N = fam ? NV : NU;\n      let g = (i - S.band * (fam ? 0.5 : 1)) % N;\n      if (g \u003c 0) g += N;\n      g = min(g, N - g);\n      const hl = exp(-g * g * 0.8);\n      const col = cols[fam];\n      for (let j = 0; j \u003c K; j++) {\n        const x = a[j * 3], y = a[j * 3 + 1], z = a[j * 3 + 2];\n        const xr = x * cphi + z * sphi, zr = -x * sphi + z * cphi;\n        sx[j] = W / 2 + xr * O.s;\n        sy[j] = O.cy - (y - O.ym) * O.s;\n        sz[j] = zr / O.rad;\n      }\n      for (let j = 0; j \u003c K; j++) {\n        const q = (j + 1) % K;\n        // Depth: the near side bright, the far side down to a fifth.\n        const depth = cl(0.5 + 0.25 * (sz[j] + sz[q]), 0, 1);\n        const v = dim * (0.1 + 0.9 * depth * depth) * (0.75 + 0.25 * hl);\n        const wv = 0.55 * hl * depth;\n        line(S, sx[j], sy[j], sx[q], sy[q], 255 * v * (col[0] * (1 - wv) + wv), 255 * v * (col[1] * (1 - wv) + wv), 255 * v * (col[2] * (1 - wv) + wv));\n      }\n    });\n  });\n  for (let p = 0; p \u003c W * H; p++) {\n    if (S.R[p] + S.G[p] + S.B[p] \u003c 1) continue;\n    display.setPixel(p % W, floor(p / W), min(255, S.R[p]) | 0, min(255, S.G[p]) | 0, min(255, S.B[p]) | 0);\n  }\n}\n","hanging-line":"// ===== Patternflow pattern =====\n// Title:   Hanging Line\n// Family:  type\n// Idea:    Kim Sowol's poem Azaleas types itself jamo by jamo, initial, vowel, final, in a geometric out-of-the-square Hangul after Ahn Sang-soo's face, every jamo one fixed shape so the syllables hang from a common top line with ragged bottoms, until the Frame knob squeezes each syllable into the same square box the way a conventional face does.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: 안상수체, the out-of-the-square (탈네모꼴) three-set Hangul face of Ahn Sang-soo (1985), whose 19 initials, 21 vowels and 27 finals each keep one shape; the jamo here are drawn after it for this pattern, not copied; the text is Kim Sowol's 진달래꽃 (Azaleas, 1922); pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=1..2, Frame=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel: at 0 the text is a pale azalea pink and each new jamo lands in full azalea magenta, under dim teal hanging lines.\n// Knob 2: Speed. Steps a second, a step being one jamo, a space or a line break: 4.4 at the opening 2, so the poem's 264 steps take a minute, 0.44 at 0.2 and 6.6 at 3.\n// Knob 3: Size. The jamo cell: 7 LEDs at 1, where up to five syllables fit a line and five and a half lines the panel, 13 LEDs at 2, where two or three do and the lines wrap again.\n// Knob 4: Frame. Out of the square at 0: each jamo one shape and size, every syllable hanging from its line's top. At 1 each syllable is stretched into the same 13 by 13 square, as a conventional (네모꼴) face resizes its jamo per syllable, and a syllable still being typed jumps in size as each jamo arrives. The opening 0.06 sits near the hanging line.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// 진달래꽃 in today's spelling: 94 syllables, 222 jamo.\nconst POEM = [\n  \"나 보기가 역겨워\", \"가실 때에는\", \"말없이 고이 보내 드리우리다\", \"\",\n  \"영변에 약산\", \"진달래꽃\", \"아름 따다 가실 길에 뿌리우리다\", \"\",\n  \"가시는 걸음걸음\", \"놓인 그 꽃을\", \"사뿐히 즈려밟고 가시옵소서\", \"\",\n  \"나 보기가 역겨워\", \"가실 때에는\", \"죽어도 아니 눈물 흘리우리다\", \"\",\n];\n\n// ---- The face. Drawn after 안상수체, not copied from it: straight strokes\n// and circles on a grid one LED apart at Size 1. A consonant fills a 7 by 7\n// cell (0..6), the same cell as an initial and as a final. Strokes are\n// polylines [x0, y0, x1, y1, ...]; a circle is [cx, cy, r, 0, 0] tagged by\n// length 5. Only the 16 consonant shapes and 11 vowels the poem uses are here.\nconst C = {\n  g: [[0, 0, 6, 0, 6, 6]],\n  n: [[0, 0, 0, 6, 6, 6]],\n  d: [[6, 0, 0, 0, 0, 6, 6, 6]],\n  r: [[0, 0, 6, 0, 6, 3, 0, 3, 0, 6, 6, 6]],\n  m: [[0, 0, 6, 0, 6, 6, 0, 6, 0, 0]],\n  b: [[0, 0, 0, 6, 6, 6, 6, 0], [0, 3, 6, 3]],\n  s: [[3, 0, 0, 6], [3, 0, 6, 6]],\n  o: [[3, 3, 3, 0, 0]],\n  j: [[0, 0, 6, 0], [3, 0, 0, 6], [3, 0, 6, 6]],\n  c: [[2, 0, 4, 0], [0, 2, 6, 2], [3, 2, 0, 6], [3, 2, 6, 6]],\n  // ㅎ's circle is too small for a round ring one LED wide to stay open at\n  // this size, so it is the eight-sided ring those LEDs make.\n  h: [[2, 0, 4, 0], [0, 1, 6, 1], [2, 3, 4, 3, 5, 4, 5, 5, 4, 6, 2, 6, 1, 5, 1, 4, 2, 3]],\n};\n// A double or a cluster sets two consonants side by side, each squeezed to\n// three LEDs.\nfunction pair(a, b) {\n  const sq = (st, dx) => (st.length === 5 ? [dx + st[0] / 3, st[1], st[2], 0, 0] : st.map((v, i) => (i % 2 ? v : dx + v / 3)));\n  return [...C[a].map((s) => sq(s, 0)), ...C[b].map((s) => sq(s, 4))];\n}\nconst INI = { 0: C.g, 1: pair(\"g\", \"g\"), 2: C.n, 3: C.d, 4: pair(\"d\", \"d\"), 5: C.r, 6: C.m, 7: C.b, 8: pair(\"b\", \"b\"), 9: C.s, 11: C.o, 12: C.j, 18: C.h };\nconst FIN = { 1: C.g, 4: C.n, 8: C.r, 11: pair(\"r\", \"b\"), 16: C.m, 17: C.b, 18: pair(\"b\", \"s\"), 21: C.o, 23: C.c, 27: C.h };\n// Vertical vowels stand right of the initial from x = 8; their stem runs\n// from the top down to y = 11, the middle of a final set under the initial\n// at y = 8..14, whether the syllable has a final or not: one shape.\nconst V = (list, x0, len) => list.map((s) => s.map((v, i) => (i % 2 ? (v === 99 ? len : v) : v + x0)));\nconst STEM = (x) => [x, 0, x, 99];\nconst VERT = {\n  0: [STEM(0), [0, 3, 2, 3]], // ㅏ\n  1: [STEM(0), [0, 3, 2, 3], STEM(4)], // ㅐ\n  2: [STEM(0), [0, 2, 2, 2], [0, 4, 2, 4]], // ㅑ\n  4: [[0, 3, 2, 3], STEM(2)], // ㅓ\n  5: [[0, 3, 2, 3], STEM(2), STEM(4)], // ㅔ\n  6: [[0, 2, 2, 2], [0, 4, 2, 4], STEM(2)], // ㅕ\n  20: [STEM(0)], // ㅣ\n};\n// Horizontal vowels hang under the initial from y = 8; the final goes two\n// rows under the vowel's lowest row.\nconst HORI = {\n  8: [[[3, 8, 3, 9], [0, 10, 6, 10]], 10], // ㅗ\n  13: [[[0, 8, 6, 8], [3, 8, 3, 10]], 10], // ㅜ\n  18: [[[0, 8, 6, 8]], 8], // ㅡ\n};\n// Compounds: the horizontal part under the initial, the vertical part\n// beside it with its stem down to the middle of where the final would sit.\nconst COMP = { 14: [13, 4] }; // ㅝ = ㅜ + ㅓ\n\n// A syllable as three stroke lists (initial, vowel, final) in grid units.\nfunction syllable(ch) {\n  const k = ch.charCodeAt(0) - 0xac00, ci = floor(k / 588), vi = floor((k % 588) / 28), fi = k % 28;\n  let vow, fy;\n  if (VERT[vi]) {\n    vow = V(VERT[vi], 8, 11);\n    fy = 8;\n  } else if (HORI[vi]) {\n    vow = HORI[vi][0];\n    fy = HORI[vi][1] + 2;\n  } else {\n    const [h, v] = COMP[vi];\n    fy = HORI[h][1] + 2;\n    vow = [...HORI[h][0], ...V(VERT[v], 8, fy + 3)];\n  }\n  const fin = fi ? FIN[fi].map((s) => (s.length === 5 ? [s[0], s[1] + fy, s[2], 0, 0] : s.map((v, i) => (i % 2 ? v + fy : v)))) : [];\n  return [INI[ci], vow, fin];\n}\n// The box a list of strokes fills: right and bottom edges, in LEDs.\nfunction extent(lists) {\n  let w = 1, h = 1;\n  for (const L of lists)\n    for (const s of L) {\n      if (s.length === 5) {\n        w = max(w, s[0] + s[2] + 1);\n        h = max(h, s[1] + s[2] + 1);\n      } else\n        for (let i = 0; i \u003c s.length; i += 2) {\n          w = max(w, s[i] + 1);\n          h = max(h, s[i + 1] + 1);\n        }\n    }\n  return [w, h];\n}\n\n// ---- The page. Each copy of the poem starts on a fresh line, so the\n// layout repeats copy after copy and the cursor can wrap round unseen.\nconst COPIES = 3, SQ = 13, TRACK = 2, SPACE = 4, LEAD = 4, MARGIN = 2;\n\nfunction tokens() {\n  const out = [];\n  let step = 0;\n  for (let c = 0; c \u003c COPIES; c++)\n    for (const line of POEM) {\n      if (line === \"\") {\n        out.push({ t: \"stanza\", step });\n        step += 2;\n        continue;\n      }\n      line.split(\" \").forEach((word, wi) => {\n        if (wi) out.push({ t: \"space\", step: step++ });\n        const syl = [...word].map((ch) => {\n          const parts = syllable(ch);\n          const n = parts[2].length ? 3 : 2;\n          const tok = { t: \"syl\", step, n, parts, ext: [extent([parts[0]]), extent([parts[0], parts[1]]), extent(parts)] };\n          step += n;\n          return tok;\n        });\n        out.push({ t: \"word\", syl });\n      });\n      out.push({ t: \"line\", step: step++ });\n    }\n  return { list: out, steps: step };\n}\n\nexport function setup(params) {\n  const { list, steps } = tokens();\n  const S = (params.s = { list, steps, copySteps: steps / COPIES, cur: 0, scroll: 0, key: \"\", blink: 0 });\n  S.maxH = 0;\n  for (const tk of list) if (tk.t === \"word\") for (const s of tk.syl) S.maxH = max(S.maxH, s.ext[2][1]);\n  // Open in the second copy, on 「아름 따다 가실 길에」, with the first\n  // copy's lines filling the page above.\n  let n = 0;\n  for (const tk of list)\n    if (tk.t === \"word\")\n      for (const s of tk.syl)\n        if (++n === 94 + 38) S.cur = s.step;\n  S.R = new Float32Array(W * H);\n  S.G = new Float32Array(W * H);\n  S.B = new Float32Array(W * H);\n}\n\n// Where every syllable goes for this Size and Frame: slot x, line top y,\n// slot width, in LEDs.\nfunction layout(S) {\n  const sc = S.size, f = S.frame;\n  const pitch = ((1 - f) * S.maxH + f * SQ + LEAD) * sc;\n  const adv = (w) => ((1 - f) * w + f * SQ + TRACK) * sc;\n  let x = MARGIN, y = 0, lineIx = 0;\n  S.laid = true;\n  const newLine = (gap) => {\n    x = MARGIN;\n    y += pitch * gap;\n    lineIx++;\n  };\n  for (const tk of S.list) {\n    if (tk.t === \"stanza\") newLine(0.45);\n    else if (tk.t === \"line\") newLine(1);\n    else if (tk.t === \"space\") {\n      if (x > MARGIN) x += SPACE * sc;\n    } else if (tk.t === \"word\") {\n      const wW = tk.syl.reduce((a, s) => a + adv(s.ext[2][0]), 0) - TRACK * sc;\n      if (x > MARGIN && x + wW > W - MARGIN) newLine(1);\n      for (const s of tk.syl) {\n        const aw = adv(s.ext[2][0]);\n        if (x > MARGIN && x + aw - TRACK * sc > W - MARGIN) newLine(1);\n        s.x = x;\n        s.y = y;\n        s.line = lineIx;\n        s.w = aw - TRACK * sc;\n        x += aw;\n      }\n    }\n  }\n  S.pitch = pitch;\n  // The height of one copy: where the first syllable of each copy sits.\n  const firsts = [];\n  let k = 0;\n  for (const tk of S.list) if (tk.t === \"word\") for (const s of tk.syl) if (k++ % 94 === 0) firsts.push(s.y);\n  S.period = firsts[1] - firsts[0];\n}\n\n// The syllable the cursor is on, or the last one before it.\nfunction caretSyl(S) {\n  let last = null;\n  for (const tk of S.list) {\n    if (tk.t !== \"word\") {\n      if (tk.step !== undefined && tk.step > S.cur) break;\n      continue;\n    }\n    for (const s of tk.syl) {\n      if (s.step > S.cur) return last;\n      last = s;\n    }\n  }\n  return last;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1], 0.2, 3);\n  S.size = cl(k[2], 1, 2);\n  S.frame = cl(k[3], 0, 1);\n  S.blink += dt;\n  S.cur += dt * speed * 2.2;\n  // Past the second copy, step back a copy: the page looks the same.\n  let jumped = false;\n  if (S.cur >= 2 * S.copySteps) {\n    S.cur -= S.copySteps;\n    jumped = true;\n  }\n  const key = S.size.toFixed(3) + \",\" + S.frame.toFixed(3);\n  const relaid = key !== S.key;\n  if (relaid) {\n    S.key = key;\n    layout(S);\n  }\n  if (jumped && !relaid) S.scroll -= S.period;\n  // Keep the cursor's line on the panel: its tallest possible syllable\n  // ends two rows above the bottom edge.\n  const cs = caretSyl(S);\n  S.caret = cs;\n  const lineH = ((1 - S.frame) * S.maxH + S.frame * SQ) * S.size;\n  const target = cs ? cs.y + lineH - (H - 3) : 0;\n  if (relaid || S.first === undefined) S.scroll = target;\n  else S.scroll += (target - S.scroll) * (1 - exp(-dt * 5));\n  S.first = 1;\n}\n\n// ---- Drawing: strokes as distances, one LED wide at Size 1.\nfunction plot(S, p, a, col) {\n  if (a \u003c= 0) return;\n  if (col[0] * a > S.R[p]) S.R[p] = col[0] * a;\n  if (col[1] * a > S.G[p]) S.G[p] = col[1] * a;\n  if (col[2] * a > S.B[p]) S.B[p] = col[2] * a;\n}\nfunction seg(S, x0, y0, x1, y1, hw, col) {\n  const dx = x1 - x0, dy = y1 - y0, L = dx * dx + dy * dy;\n  const xa = max(0, floor(min(x0, x1) - hw - 1)), xb = min(W - 1, floor(max(x0, x1) + hw + 1));\n  const ya = max(0, floor(min(y0, y1) - hw - 1)), yb = min(H - 1, floor(max(y0, y1) + hw + 1));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x - x0, py = y - y0, t = L ? cl((px * dx + py * dy) / L, 0, 1) : 0;\n      const ex = px - t * dx, ey = py - t * dy;\n      plot(S, y * W + x, cl(hw + 0.5 - sqrt(ex * ex + ey * ey), 0, 1), col);\n    }\n}\n// An ellipse ring; the distance to it is taken to first order.\nfunction ring(S, cx, cy, rx, ry, hw, col) {\n  for (let y = max(0, floor(cy - ry - hw - 1)); y \u003c= min(H - 1, cy + ry + hw + 1); y++)\n    for (let x = max(0, floor(cx - rx - hw - 1)); x \u003c= min(W - 1, cx + rx + hw + 1); x++) {\n      const u = (x - cx) / rx, v = (y - cy) / ry, k = sqrt(u * u + v * v);\n      const g = sqrt((u / rx) ** 2 + (v / ry) ** 2);\n      const d = g > 1e-6 ? (k * k - k) / g : min(rx, ry);\n      plot(S, y * W + x, cl(hw + 0.5 - abs(d), 0, 1), col);\n    }\n}\n\nexport function draw(display, params) {\n  if (!params.s || !params.s.laid) return;\n  const S = params.s, sc = S.size, f = S.frame, hw = 0.5 + 0.35 * (sc - 1);\n  S.R.fill(0);\n  S.G.fill(0);\n  S.B.fill(0);\n  const ink = hsv(S.hue + 0.93, 0.42, 0.9).map((v) => v * 255);\n  const hot = hsv(S.hue + 0.88, 0.85, 1).map((v) => v * 255);\n  const guide = hsv(S.hue + 0.5, 0.7, 0.2).map((v) => v * 255);\n  const lineH = ((1 - f) * S.maxH + f * SQ) * sc;\n  const top = S.scroll;\n  // The hanging lines: where each line's typed text ends.\n  const ends = new Map();\n  for (const tk of S.list) {\n    if (tk.t !== \"word\") continue;\n    for (const s of tk.syl) {\n      if (s.step > S.cur) break;\n      const y = s.y - top;\n      if (y + lineH \u003c 0 || y > H) continue;\n      ends.set(s.line, [y, max(ends.get(s.line)?.[1] ?? 0, s.x + s.w)]);\n      const typed = min(s.n, floor(S.cur - s.step) + 1);\n      // The box this much of the syllable fills, and the stretch that puts\n      // it in the square: none at Frame 0, all of it at 1.\n      const [bw, bh] = s.ext[typed - 1];\n      const fx = (1 - f + (f * SQ) / bw) * sc, fy = (1 - f + (f * SQ) / bh) * sc;\n      const ox = round(s.x), oy = round(y);\n      for (let j = 0; j \u003c typed; j++) {\n        const age = S.cur - s.step - j;\n        const glow = exp(-age / 4);\n        const col = ink.map((v, i) => v + (hot[i] - v) * glow);\n        for (const st of s.parts[j]) {\n          if (st.length === 5) ring(S, ox + round(st[0] * fx * 2) / 2, oy + round(st[1] * fy * 2) / 2, st[2] * fx, st[2] * fy, hw, col);\n          else\n            for (let i = 0; i + 3 \u003c st.length; i += 2)\n              seg(S, ox + round(st[i] * fx), oy + round(st[i + 1] * fy), ox + round(st[i + 2] * fx), oy + round(st[i + 3] * fy), hw, col);\n        }\n      }\n    }\n  }\n  // The guide: the top line every syllable hangs from, fading out toward\n  // the square, where a bottom line fades in.\n  for (const [, [y, xe]] of ends) {\n    const yt = round(y) - 2, yb = round(y + SQ * sc) + 1;\n    for (let x = MARGIN; x \u003c min(W, xe); x++) {\n      if (yt >= 0 && yt \u003c H) plot(S, yt * W + x, 1 - 0.6 * f, guide);\n      if (f > 0 && yb >= 0 && yb \u003c H) plot(S, yb * W + x, f, guide);\n    }\n  }\n  // The caret: the slot being typed, lit on its hanging line.\n  const c = S.caret;\n  if (c) {\n    const on = 0.55 + 0.45 * Math.cos(S.blink * 7);\n    const y = round(c.y - top) - 2;\n    if (y >= 0 && y \u003c H) for (let x = round(c.x); x \u003c min(W, c.x + c.w); x++) plot(S, y * W + x, on, hot);\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    if (S.R[p] + S.G[p] + S.B[p] \u003c 1) continue;\n    display.setPixel(p % W, floor(p / W), min(255, S.R[p]) | 0, min(255, S.G[p]) | 0, min(255, S.B[p]) | 0);\n  }\n}\n","radon-transform":"// ===== Patternflow pattern =====\n// Title:   Radon Transform\n// Family:  algo\n// Idea:    A beam takes half a turn round a few ellipses of different densities and counts the photons that get through, filling the bottom square row by row with a grainy sinogram, then each projection is filtered and smeared back across the top square along its own angle, so the ellipses build up out of crossing streaks, hold, and the panel clears for the next, slightly moved phantom.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Radon transform and its inversion (Johann Radon, 1917), filtered back-projection with the ramp filter (G. N. Ramachandran and A. V. Lakshminarayanan, 1971), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Angles=0..64, Filter=0..1\n//\n// Knob 1: Hue. Turns both squares round the wheel: at 0 the reconstruction runs from dark cyan to ice white and the sinogram from blue violet to purple.\n// Knob 2: Speed. At 2 the beam's half turn takes 1 s, reading the projections back takes 6 s, and the picture holds 1.5 s, dimming to 15% over its last 0.3 s before the next scan starts on an empty sinogram; at 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Angles. How many projections a half turn takes. 0 takes turns, doubling each cycle from 16: 16, 32, 64, then 4, 8 and round again. 1 to 64 hold that count; with few the shapes are crossed by the star of streaks, one per angle. The half turn has a fixed dose of photons shared by its projections: at 4 angles each bin gets 2,000 and the rows are clean, at 64 it gets 125 and they are grainy.\n// Knob 4: Filter. The filter each projection passes before it is smeared back: (1 - f) c + f |w|, with c the ramp's height at 1/400 of a cycle a sample. At 0 it is plain back-projection, every shape in a blurred 1/r halo; at 0.06 the edges already come through; at 1 it is the ramp alone, sharp, with dark lobes beside every streak. Plain back-projection smooths the photon noise away; the ramp turns it into fine grain.\n\nconst W = 64, Q = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, exp, log, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The detector: NB bins one LED wide, wide enough to cover the square's\n// diagonal, so the corners get their share of every projection. The\n// sinogram shows the middle 64.\nconst NB = 92, MID = (NB - 1) / 2, OFF = (NB - Q) / 2, C = (Q - 1) / 2;\n// Ramachandran and Lakshminarayanan's ramp filter in space, one bin apart:\n// 1/4 at 0, -1/(pi n)^2 at odd n, 0 at even n. Its response rises as |w|\n// from 0 to 1/2 at the Nyquist frequency.\nconst KER = new Float32Array(2 * NB - 1);\nfor (let n = -(NB - 1); n \u003c NB; n++) KER[n + NB - 1] = n === 0 ? 0.25 : n & 1 ? -1 / (PI * PI * n * n) : 0;\n// The flat part of the Filter knob's blend, in the ramp's units.\nconst FLAT = 1 / 400;\n\n// A phantom is a list of ellipses [x0, y0, a, b, phi, density]. The line\n// integral of one along s at angle th is closed form: with\n// r2 = a^2 cos^2(th - phi) + b^2 sin^2(th - phi) and t = s - (x0 cos th +\n// y0 sin th) the line's distance from the centre, it is\n// 2 rho a b sqrt(r2 - t^2) / r2 where t^2 \u003c r2, and 0 elsewhere.\n// One projection, each bin the mean of the lines a quarter bin either side\n// of its middle.\nfunction project(E, th, out) {\n  out.fill(0);\n  const c = cos(th), sn = sin(th);\n  for (const [x0, y0, a, b, phi, rho] of E) {\n    const ca = cos(th - phi), sa = sin(th - phi);\n    const r2 = a * a * ca * ca + b * b * sa * sa, r = sqrt(r2), k = (rho * a * b) / r2, s0 = x0 * c + y0 * sn + MID;\n    for (let i = max(0, floor(s0 - r - 1)), e = min(NB - 1, floor(s0 + r + 1)); i \u003c= e; i++)\n      for (const d of [-0.25, 0.25]) {\n        const t = i + d - s0;\n        if (t * t \u003c r2) out[i] += k * sqrt(r2 - t * t);\n      }\n  }\n  return out;\n}\n\n// Photon counts. A line of attenuation p lets through exp(-MU p) of the\n// beam, so a bin that should count m photons counts a Poisson draw from m,\n// and the projection is read back as -ln(count / I0) / MU, as a scanner\n// reads it. One half turn has a fixed DOSE, shared by its projections: each\n// of N gets DOSE / N photons a bin, so few angles give clean rows and many\n// give grainy ones. The thickest line through the first phantom lets 5.4%\n// of the beam through.\nconst MU = 0.08, DOSE = 8000;\nconst gauss = () => sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\nfunction poisson(m) {\n  if (m > 40) return max(0, round(m + sqrt(m) * gauss()));\n  const L = exp(-m);\n  let k = 0;\n  for (let q = Math.random(); q > L; q *= Math.random()) k++;\n  return k;\n}\nfunction expose(p, I0) {\n  for (let i = 0; i \u003c p.length; i++) p[i] = -log(max(0.5, poisson(I0 * exp(-MU * p[i]))) / I0) / MU;\n  return p;\n}\n\nfunction ramp(p, q) {\n  for (let i = 0; i \u003c NB; i++) {\n    let s = 0;\n    for (let j = 0; j \u003c NB; j++) s += p[j] * KER[i - j + NB - 1];\n    q[i] = s;\n  }\n  return q;\n}\n\n// Every LED of the top square, (x, y) with y up, takes the value of the\n// projection at s = x cos th + y sin th, read between bins.\nfunction smear(acc, p, th) {\n  const c = cos(th), sn = sin(th);\n  for (let y = 0; y \u003c Q; y++) {\n    const u0 = -C * c + (C - y) * sn + MID;\n    for (let x = 0, k = y * Q; x \u003c Q; x++, k++) {\n      const u = u0 + x * c, i = floor(u);\n      if (i \u003c 0 || i >= NB - 1) continue;\n      const f = u - i;\n      acc[k] += p[i] + (p[i + 1] - p[i]) * f;\n    }\n  }\n}\n\n// The first phantom: a body and five inner shapes, one of them a hole.\nfunction firstPhantom() {\n  return [\n    [0, 0, 27, 22, 0.3, 0.5],\n    [-9, 6, 9, 5, 0.9, 0.35],\n    [8, 7, 7, 7, 0, -0.3],\n    [5, -9, 10, 4, -0.4, 0.3],\n    [-8, -8, 3, 3, 0, 0.7],\n    [12, -4, 2, 3.5, 0.5, 0.8],\n  ];\n}\n\n// The next phantom: the whole turns 26 to 43 degrees, the inner shapes\n// drift, and one of them is drawn anew. Everything stays inside a circle of\n// 28 LEDs, so every shadow falls inside the 64 bins the sinogram shows.\nfunction nextPhantom(E) {\n  const turn = 0.45 + Math.random() * 0.3, ct = cos(turn), st = sin(turn);\n  const out = E.map(([x, y, a, b, phi, rho], i) => {\n    let nx = x * ct - y * st, ny = x * st + y * ct;\n    if (i > 0) {\n      nx += (Math.random() - 0.5) * 6, ny += (Math.random() - 0.5) * 6;\n      const r = sqrt(nx * nx + ny * ny), lim = 15 - max(a, b) * 0.4;\n      if (r > lim) (nx *= lim / r), (ny *= lim / r);\n    }\n    return [nx, ny, a, b, phi + turn, rho];\n  });\n  const k = 1 + floor(Math.random() * (out.length - 1)), small = Math.random() \u003c 0.4;\n  const a = small ? 2 + Math.random() * 2 : 4 + Math.random() * 6, b = small ? 2 + Math.random() * 2 : 3 + Math.random() * 4;\n  const ang = Math.random() * 2 * PI, r = Math.random() * 10;\n  const rho = small ? 0.6 + Math.random() * 0.3 : Math.random() \u003c 0.4 ? -0.3 : 0.25 + Math.random() * 0.2;\n  out[k] = [r * cos(ang), r * sin(ang), a, b, Math.random() * PI, rho];\n  // The body breathes between rounder and longer.\n  out[0][2] = 25 + Math.random() * 3, out[0][3] = 19 + Math.random() * 5;\n  return out;\n}\n\n// The sinogram a scan at all 64 angles would count at the same dose a\n// projection, the middle 64 bins across, and its peak before the noise.\nfunction sinogram(E, out, I0) {\n  const p = new Float32Array(NB);\n  let peak = 1e-6;\n  for (let r = 0; r \u003c Q; r++) {\n    project(E, (r * PI) / Q, p);\n    for (let x = OFF; x \u003c OFF + Q; x++) peak = max(peak, p[x]);\n    expose(p, I0);\n    out.set(p.subarray(OFF, OFF + Q), r * Q);\n  }\n  return peak;\n}\n\nconst TURNS = [4, 8, 16, 32, 64];\n// At Speed 2 the beam's half turn takes SCAN seconds, reading the sinogram\n// back into the picture takes SWEEP, the result holds HOLD and the last\n// FADE of the hold clears both squares.\nconst SCAN = 1, SWEEP = 6, HOLD = 1.5, FADE = 0.25, DIM = 0.15, P0 = 0.75;\n\n// A new scan starts on a cleared panel.\nfunction startCycle(S, E) {\n  S.E = E;\n  S.cycle++;\n  S.scan = 0, S.prog = 0, S.hold = 0;\n  rebuild(S);\n}\n\nfunction anglesFor(S) {\n  return S.knobN > 0 ? S.knobN : TURNS[(S.cycle + 2) % TURNS.length];\n}\n\n// Start over for the current angle count: measure every projection the\n// beam has passed and smear back every one the reading has reached.\nfunction rebuild(S) {\n  S.N = anglesFor(S);\n  S.peak = sinogram(S.E, S.sino, DOSE / S.N);\n  S.P.fill(0), S.R.fill(0);\n  S.done = 0, S.measured = 0, S.taken.fill(-1);\n  measure(S);\n  take(S);\n}\n\n// The beam passes angle k pi / N and the detector counts its projection.\nfunction measure(S) {\n  while (S.measured \u003c S.N && S.measured / S.N \u003c= S.scan + 1e-9) {\n    const k = S.measured++;\n    expose(project(S.E, (k * PI) / S.N, S.proj[k]), DOSE / S.N);\n    // Its row of the sinogram, drawn up to 3 rows deep when the rows\n    // between projections leave room.\n    const r0 = round((k / S.N) * Q), deep = cl(floor(Q / S.N / 3), 1, 3);\n    for (let j = 0; j \u003c deep; j++) {\n      const r = (r0 + j) % Q;\n      S.taken[r] = k, S.depth[r] = j;\n      S.rows[r].set(S.proj[k].subarray(OFF, OFF + Q));\n    }\n  }\n}\n\n// The reading reaches projection k: it is filtered and smeared back.\nfunction take(S) {\n  while (S.done \u003c S.measured && S.done / S.N \u003c= S.prog + 1e-9) {\n    const th = (S.done * PI) / S.N, p = S.proj[S.done];\n    ramp(p, S.q);\n    smear(S.P, p, th);\n    smear(S.R, S.q, th);\n    S.lastP.set(p), S.lastQ.set(S.q), S.lastTh = th, S.lastT = S.t;\n    S.done++;\n  }\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, filt: 0.06, knobN: -1, N: 4, cycle: -1, scan: 0, prog: 0, hold: 0, done: 0, measured: 0, first: true,\n    proj: Array.from({ length: 64 }, () => new Float32Array(NB)),\n    E: firstPhantom(), P: new Float32Array(Q * Q), R: new Float32Array(Q * Q), shown: new Float32Array(Q * Q),\n    sino: new Float32Array(Q * Q), peak: 1, clear: 1,\n    q: new Float32Array(NB), lastP: new Float32Array(NB), lastQ: new Float32Array(NB), lastTh: 0, lastT: -9,\n    taken: new Int16Array(Q).fill(-1), depth: new Uint8Array(Q), rows: Array.from({ length: Q }, () => new Float32Array(Q)), gain: 0, hist: new Int32Array(256), c: [0, 0, 0],\n  });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.t += dt;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.filt = cl(k[3], 0, 1);\n  const kn = cl(round(k[2]), 0, 64);\n  if (S.first) {\n    // The panel opens with the scan done and the reading P0 of the way\n    // through, so the picture is built by 1.5 s and the first clearing\n    // falls at 3 s.\n    S.knobN = kn;\n    startCycle(S, S.E);\n    S.scan = 1, S.prog = P0;\n    measure(S);\n    take(S);\n    S.first = false;\n  } else if (kn !== S.knobN) {\n    S.knobN = kn;\n    if (anglesFor(S) !== S.N) rebuild(S);\n  }\n  const rate = S.speed / 2;\n  if (S.scan \u003c 1) {\n    S.scan = min(1, S.scan + (dt * rate) / SCAN);\n    measure(S);\n  }\n  if (S.prog \u003c 1) {\n    S.prog = min(1, S.prog + (dt * rate) / SWEEP);\n    take(S);\n  } else {\n    S.hold += dt * rate;\n    if (S.hold >= HOLD) startCycle(S, nextPhantom(S.E));\n  }\n  // Near the end of the hold both squares dim over FADE seconds to DIM of\n  // their light and stay there for the last 0.07 s.\n  S.clear = S.prog \u003c 1 ? 1 : DIM + (1 - DIM) * cl((HOLD - S.hold - 0.07) / FADE, 0, 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.first) return;\n  const c = S.c, f = S.filt, n = max(1, S.done), A = (1 - f) * FLAT, B = f;\n  const shown = S.shown;\n  // The reconstruction is the sum of the smeared projections so far over\n  // the full count, so it builds up from black. The gain follows the peak\n  // of their mean, eased so a new streak does not flash the scale.\n  let top = 1e-6;\n  for (let i = 0; i \u003c Q * Q; i++) {\n    const v = (A * S.P[i] + B * S.R[i]) / n;\n    shown[i] = v;\n    if (v > top) top = v;\n  }\n  // The scale is set by the brightest 0.5% of LEDs, so a few noise spikes\n  // do not darken the whole picture.\n  const hist = S.hist.fill(0);\n  for (let i = 0; i \u003c Q * Q; i++) if (shown[i] > 0) hist[min(255, floor((shown[i] / top) * 256))]++;\n  let b = 255;\n  for (let cnt = 0; b > 0 && (cnt += hist[b]) \u003c Q * Q * 0.005; ) b--;\n  const peak = (top * (b + 1)) / 256;\n  S.gain = S.gain > 0 ? S.gain + (1 / peak - S.gain) * 0.25 : 1 / peak;\n  const g = S.gain, env = S.clear;\n  // The newest projection flashes along its rays for a moment.\n  const fl = exp(-(S.t - S.lastT) / 0.25) * 0.5 * S.clear, cth = cos(S.lastTh), sth = sin(S.lastTh);\n  const hr = 0.55 + S.hue, hn = 0.78 + S.hue;\n  for (let y = 0; y \u003c Q; y++) {\n    const u0 = -C * cth + (C - y) * sth + MID;\n    for (let x = 0; x \u003c Q; x++) {\n      const i = y * Q + x;\n      let u = shown[i] * g * env;\n      if (fl > 0.01) {\n        const s = u0 + x * cth, j = floor(s);\n        if (j >= 0 && j \u003c NB - 1) {\n          const w = s - j, pv = S.lastP[j] + (S.lastP[j + 1] - S.lastP[j]) * w, qv = S.lastQ[j] + (S.lastQ[j + 1] - S.lastQ[j]) * w;\n          u += fl * (A * pv + B * qv) * g;\n        }\n      }\n      shown[i] = u;\n      if (u >= 0) {\n        // A soft shoulder above 0.7 instead of a hard clip at white.\n        const v = u \u003c 0.7 ? u : 1 - 0.3 * exp(-(u - 0.7) / 0.3);\n        hsv(hr - 0.05 + 0.1 * v, 0.85 - 0.75 * v * v, 0.06 + 0.94 * v ** 0.65, c);\n      } else hsv(hn, 0.65, min(0.5, -u * 0.9), c);\n      display.setPixel(x, y, 255 * c[0], 255 * c[1], 255 * c[2]);\n    }\n  }\n  // The sinogram, angle 0 at the top to 180 degrees at the bottom. Rows the\n  // beam has passed show the full sinogram dimly and the rows of the\n  // projections measured brightly, brightest once they are smeared back;\n  // rows ahead are dark. A row flashes white as it is smeared back.\n  const swept = S.scan >= 1 ? Q : floor(S.scan * Q + 1e-6) + 1, hs = 0.72 + S.hue, pk = S.peak;\n  for (let r = 0; r \u003c swept; r++) {\n    const tk = S.taken[r] >= 0;\n    const lv = (tk ? (S.taken[r] \u003c S.done ? 1 : 0.7) * (S.depth[r] ? 0.8 : 1) : 0.55) * S.clear;\n    const src = tk ? S.rows[r] : S.sino.subarray(r * Q, r * Q + Q);\n    const hot = tk && S.taken[r] === S.done - 1 ? exp(-(S.t - S.lastT) / 0.3) : 0;\n    for (let x = 0; x \u003c Q; x++) {\n      // An empty bin reads 0 give or take its noise, on a faint floor.\n      const v = cl(0.12 + 0.88 * (src[x] / pk), 0, 1), e = v ** 0.65;\n      hsv(hs - 0.04 + 0.12 * v, max(0, 0.8 - 0.55 * v * v - 0.6 * hot), lv * e * (1 - hot) + hot * (0.3 + 0.7 * v), c);\n      display.setPixel(x, Q + r, 255 * c[0], 255 * c[1], 255 * c[2]);\n    }\n  }\n  // While the beam turns: its place, a tick at each side of the sinogram,\n  // and its direction across the top square as a faint line.\n  if (S.scan \u003c 1) {\n    const r = min(Q - 1, floor(S.scan * Q));\n    for (const x of [0, 1, Q - 2, Q - 1]) display.setPixel(x, Q + r, 255, 255, 255);\n    const th = S.scan * PI, dx = -sin(th), dy = -cos(th);\n    for (let s = -44; s \u003c= 44; s += 0.5) {\n      const x = round(C + s * dx), y = round(C + s * dy);\n      if (x \u003c 0 || x >= Q || y \u003c 0 || y >= Q) continue;\n      const u = shown[y * Q + x];\n      hsv(hr, 0.3, min(1, 0.35 + max(0, u)), c);\n      display.setPixel(x, y, 255 * c[0], 255 * c[1], 255 * c[2]);\n    }\n  }\n}\n","shannon-approximations":"// ===== Patternflow pattern =====\n// Title:   Shannon's Approximations\n// Family:  type\n// Idea:    A page of 21 lines of 16 small capitals is typed over and over by a cursor that writes Claude Shannon's approximations to English, from 27 equiprobable symbols up through letter, digram and trigram statistics to word frequencies and word pairs, all counted from the opening of Pride and Prejudice, and every run of letters that is a real word of that text lights up, so the page turns from dim noise into lit words as the order rises.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the series of approximations to English in A Mathematical Theory of Communication, section 3 (Claude Shannon, 1948), counted from the opening of Pride and Prejudice (Jane Austen, 1813), 3x5 capitals drawn for this pattern, pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=0..5, Blackout=0..1\n//\n// Knob 1: Hue. Turns the page round the wheel: at 0 the words are sea green, word pairs from the book warm gold and the noise between them slate.\n// Knob 2: Speed. Letters a second, eight times the knob: 16 at 2, so the cursor goes round the 336 cells of the page in 21 s; 1.6 at 0.2, 24 at 3. Fresh letters burn white and cool over a second.\n// Knob 3: Order. Shannon's six steps, in whole steps: 0 the 27 symbols equiprobable, 1 letter frequencies, 2 digrams, 3 trigrams, 4 words by their frequency, 5 each word drawn after the word before it. A change rewrites the whole page from the top in 0.6 s. The bottom row is a gauge of the share of the page's letters that stand in real words.\n// Knob 4: Blackout. How the runs that are not words show: dim letters at 0, and turned up they sink under dark ink bars until at 1 only the real words stand on a blacked-out page.\n\nconst W = 64, H = 128;\nconst { floor, min, max, exp, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The opening of Pride and Prejudice, chapter 1 up to Lizzy, cut down to\n// Shannon's 27 symbols: capitals and the space. 2,812 symbols, 577 words,\n// 236 different words.\nconst TEXT =\n  \"IT IS A TRUTH UNIVERSALLY ACKNOWLEDGED THAT A SINGLE MAN IN POSSESSION OF A \" +\n  \"GOOD FORTUNE MUST BE IN WANT OF A WIFE HOWEVER LITTLE KNOWN THE FEELINGS OR \" +\n  \"VIEWS OF SUCH A MAN MAY BE ON HIS FIRST ENTERING A NEIGHBOURHOOD THIS TRUTH \" +\n  \"IS SO WELL FIXED IN THE MINDS OF THE SURROUNDING FAMILIES THAT HE IS \" +\n  \"CONSIDERED THE RIGHTFUL PROPERTY OF SOME ONE OR OTHER OF THEIR DAUGHTERS MY \" +\n  \"DEAR MR BENNET SAID HIS LADY TO HIM ONE DAY HAVE YOU HEARD THAT NETHERFIELD \" +\n  \"PARK IS LET AT LAST MR BENNET REPLIED THAT HE HAD NOT BUT IT IS RETURNED SHE \" +\n  \"FOR MRS LONG HAS JUST BEEN HERE AND SHE TOLD ME ALL ABOUT IT MR BENNET MADE \" +\n  \"NO ANSWER DO YOU NOT WANT TO KNOW WHO HAS TAKEN IT CRIED HIS WIFE \" +\n  \"IMPATIENTLY YOU WANT TO TELL ME AND I HAVE NO OBJECTION TO HEARING IT THIS \" +\n  \"WAS INVITATION ENOUGH WHY MY DEAR YOU MUST KNOW MRS LONG SAYS THAT \" +\n  \"NETHERFIELD IS TAKEN BY A YOUNG MAN OF LARGE FORTUNE FROM THE NORTH OF \" +\n  \"ENGLAND THAT HE CAME DOWN ON MONDAY IN A CHAISE AND FOUR TO SEE THE PLACE \" +\n  \"AND WAS SO MUCH DELIGHTED WITH IT THAT HE AGREED WITH MR MORRIS IMMEDIATELY \" +\n  \"THAT HE IS TO TAKE POSSESSION BEFORE MICHAELMAS AND SOME OF HIS SERVANTS ARE \" +\n  \"TO BE IN THE HOUSE BY THE END OF NEXT WEEK WHAT IS HIS NAME BINGLEY IS HE \" +\n  \"MARRIED OR SINGLE OH SINGLE MY DEAR TO BE SURE A SINGLE MAN OF LARGE FORTUNE \" +\n  \"FOUR OR FIVE THOUSAND A YEAR WHAT A FINE THING FOR OUR GIRLS HOW SO HOW CAN \" +\n  \"IT AFFECT THEM MY DEAR MR BENNET REPLIED HIS WIFE HOW CAN YOU BE SO TIRESOME \" +\n  \"YOU MUST KNOW THAT I AM THINKING OF HIS MARRYING ONE OF THEM IS THAT HIS \" +\n  \"DESIGN IN SETTLING HERE DESIGN NONSENSE HOW CAN YOU TALK SO BUT IT IS VERY \" +\n  \"LIKELY THAT HE MAY FALL IN LOVE WITH ONE OF THEM AND THEREFORE YOU MUST \" +\n  \"VISIT HIM AS SOON AS HE COMES I SEE NO OCCASION FOR THAT YOU AND THE GIRLS \" +\n  \"MAY GO OR YOU MAY SEND THEM BY THEMSELVES WHICH PERHAPS WILL BE STILL BETTER \" +\n  \"FOR AS YOU ARE AS HANDSOME AS ANY OF THEM MR BINGLEY MAY LIKE YOU THE BEST \" +\n  \"OF THE PARTY MY DEAR YOU FLATTER ME I CERTAINLY HAVE HAD MY SHARE OF BEAUTY \" +\n  \"BUT I DO NOT PRETEND TO BE ANYTHING EXTRAORDINARY NOW WHEN A WOMAN HAS FIVE \" +\n  \"GROWN UP DAUGHTERS SHE OUGHT TO GIVE OVER THINKING OF HER OWN BEAUTY IN SUCH \" +\n  \"CASES A WOMAN HAS NOT OFTEN MUCH BEAUTY TO THINK OF BUT MY DEAR YOU MUST \" +\n  \"INDEED GO AND SEE MR BINGLEY WHEN HE COMES INTO THE NEIGHBOURHOOD IT IS MORE \" +\n  \"THAN I ENGAGE FOR I ASSURE YOU BUT CONSIDER YOUR DAUGHTERS ONLY THINK WHAT \" +\n  \"AN ESTABLISHMENT IT WOULD BE FOR ONE OF THEM SIR WILLIAM AND LADY LUCAS ARE \" +\n  \"DETERMINED TO GO MERELY ON THAT ACCOUNT FOR IN GENERAL YOU KNOW THEY VISIT \" +\n  \"NO NEWCOMERS INDEED YOU MUST GO FOR IT WILL BE IMPOSSIBLE FOR US TO VISIT \" +\n  \"HIM IF YOU DO NOT YOU ARE OVER SCRUPULOUS SURELY I DARE SAY MR BINGLEY WILL \" +\n  \"BE VERY GLAD TO SEE YOU AND I WILL SEND A FEW LINES BY YOU TO ASSURE HIM OF \" +\n  \"MY HEARTY CONSENT TO HIS MARRYING WHICHEVER HE CHOOSES OF THE GIRLS THOUGH I \" +\n  \"MUST THROW IN A GOOD WORD FOR MY LITTLE LIZZY \";\n\n// Symbol 0 is the space, 1 to 26 the letters. The text is read as a ring\n// (its last space leads back to IT), so every context it holds has a\n// letter after it.\nconst ABC = \" ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\nconst SRC = Uint8Array.from(TEXT, (c) => ABC.indexOf(c));\nconst N = SRC.length;\n// Shannon's way of drawing the higher orders: open the book at a random\n// place where the last letters occur and copy the letter that follows. The\n// lists below are those places, by the last letter and by the last two.\nconst AFTER1 = Array.from({ length: 27 }, () => []);\nconst AFTER2 = Array.from({ length: 27 * 27 }, () => []);\nfor (let i = 0; i \u003c N; i++) {\n  AFTER1[SRC[i]].push(i);\n  AFTER2[SRC[(i + N - 1) % N] * 27 + SRC[i]].push(i);\n}\n// Words: the vocabulary, the running text as word ids, where each word\n// occurs, and every pair of words that stands side by side in the book.\nconst TOKS = TEXT.trim().split(\" \");\nconst VOCAB = new Map(), WORDS = [];\nfor (const w of TOKS) if (!VOCAB.has(w)) VOCAB.set(w, WORDS.length), WORDS.push(w);\nconst NV = WORDS.length, TID = TOKS.map((w) => VOCAB.get(w));\nconst SUCC = Array.from({ length: NV }, () => []);\nconst PAIRS = new Set();\nfor (let k = 0; k + 1 \u003c TID.length; k++) SUCC[TID[k]].push(k), PAIRS.add(TID[k] * NV + TID[k + 1]);\n\n// 3x5 capitals, rows top to bottom, a 1 is a lit LED.\nconst GLYPHS = [\n  \"010101111101101\", \"110101110101110\", \"011100100100011\", \"110101101101110\", \"111100110100111\",\n  \"111100110100100\", \"011100101101011\", \"101101111101101\", \"111010010010111\", \"001001001101010\",\n  \"101101110101101\", \"100100100100111\", \"101111111101101\", \"111101101101101\", \"010101101101010\",\n  \"110101110100100\", \"010101101110011\", \"110101110101101\", \"011100010001110\", \"111010010010010\",\n  \"101101101101111\", \"101101101101010\", \"101101111111101\", \"101101010101101\", \"101101010010010\",\n  \"111001010100111\",\n];\nconst FONT = GLYPHS.map((g) => Uint8Array.from(g, (c) => +c));\n\n// The page: 16 cells across, 4 LEDs each, and 21 lines 6 LEDs apart.\nconst COLS = 16, ROWS = 21, CELLS = COLS * ROWS, CW = 4, CH = 6, TOP = 1;\n// The fresh-ink glow fades with this time constant, and a wipe writes one\n// line every WIPE seconds.\nconst GLOW = 1, WIPE = 0.03;\n\nconst rnd = (n) => floor(Math.random() * n);\n\n// The next symbol at the current order.\nfunction nextSymbol(S) {\n  const o = S.order;\n  let c;\n  if (o >= 4) {\n    if (S.qi >= S.q.length) {\n      let id = -1;\n      if (o === 5 && S.pw >= 0 && SUCC[S.pw].length) id = TID[SUCC[S.pw][rnd(SUCC[S.pw].length)] + 1];\n      if (id \u003c 0) id = TID[rnd(TID.length)];\n      S.q = (S.h1 === 0 ? \"\" : \" \") + WORDS[id] + \" \";\n      S.qi = 0;\n      S.pw = id;\n    }\n    c = ABC.indexOf(S.q[S.qi++]);\n  } else {\n    S.q = \"\", S.qi = 0, S.pw = -1;\n    if (o === 0) c = rnd(27);\n    else {\n      let list = o === 3 ? AFTER2[S.h0 * 27 + S.h1] : o === 2 ? AFTER1[S.h1] : null;\n      // A context the book never has (a Q, or two letters a lower order\n      // put side by side) falls back to a lower order.\n      if (o === 3 && !list.length) list = AFTER1[S.h1];\n      c = list && list.length ? SRC[(list[rnd(list.length)] + 1) % N] : SRC[rnd(N)];\n    }\n  }\n  S.h0 = S.h1, S.h1 = c;\n  return c;\n}\n\n// Which cells are words. The page is read as one ring of text in typing\n// order, so a word may run over a line end, and from the bottom line back\n// to the top. Each run of letters is looked up in the vocabulary; two words\n// one space apart that stand side by side in the book are a pair.\nfunction classify(S) {\n  const P = S.P, C = S.cls, L = S.len;\n  C.fill(0), L.fill(0);\n  let s0 = -1;\n  for (let i = 0; i \u003c CELLS; i++) if (P[i] === 0) { s0 = i; break; }\n  if (s0 \u003c 0) return C.fill(1);\n  const runs = [];\n  let i = 1;\n  while (i \u003c= CELLS) {\n    if (P[(s0 + i) % CELLS] === 0) { i++; continue; }\n    const st = i;\n    let word = \"\";\n    while (i \u003c= CELLS && P[(s0 + i) % CELLS] !== 0) word += ABC[P[(s0 + i++) % CELLS]];\n    const id = VOCAB.get(word);\n    runs.push([st, i - st, id === undefined ? -1 : id, 0]);\n  }\n  for (let r = 0; r + 1 \u003c runs.length; r++) {\n    const a = runs[r], b = runs[r + 1];\n    if (a[2] >= 0 && b[2] >= 0 && b[0] === a[0] + a[1] + 1 && PAIRS.has(a[2] * NV + b[2])) a[3] = b[3] = 1;\n  }\n  let words = 0, letters = 0;\n  for (const [st, n, id, pair] of runs) {\n    const k = id \u003c 0 ? 1 : pair ? 3 : 2;\n    letters += n;\n    if (id >= 0) words += n;\n    for (let j = 0; j \u003c n; j++) {\n      const p = (s0 + st + j) % CELLS;\n      C[p] = k, L[p] = n;\n    }\n  }\n  S.share = words / max(1, letters);\n}\n\n// A fresh page at the current order, as if just typed at the current speed.\nfunction fillPage(S) {\n  for (let i = 0; i \u003c CELLS; i++) {\n    S.P[i] = nextSymbol(S);\n    S.T[i] = S.t - (CELLS - 1 - i) / S.cps;\n  }\n  S.cur = 0, S.acc = 0, S.dirty = true;\n}\n\nexport function setup(params) {\n  params.s = {\n    P: new Uint8Array(CELLS), T: new Float32Array(CELLS), NEXT: new Uint8Array(CELLS),\n    cls: new Uint8Array(CELLS), len: new Uint8Array(CELLS),\n    t: 0, cps: 16, order: -1, cur: 0, acc: 0, dirty: true, share: 0,\n    h0: 0, h1: 0, q: \"\", qi: 0, pw: -1, wipe: -1, wiped: 0, hue: 0, black: 0.06,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.t += dt;\n  S.hue = k[0];\n  S.cps = 8 * cl(k[1], 0.2, 3);\n  S.black = cl(k[3], 0, 1);\n  const order = cl(round(k[2]), 0, 5);\n  if (S.order \u003c 0) {\n    S.order = order;\n    fillPage(S);\n  } else if (order !== S.order) {\n    // A new order writes a whole new page, revealed a line at a time from\n    // the top; the cursor then goes on from the top-left cell.\n    S.order = order;\n    for (let i = 0; i \u003c CELLS; i++) S.NEXT[i] = nextSymbol(S);\n    S.wipe = S.t, S.wiped = 0;\n  }\n  if (S.wipe >= 0) {\n    const upto = min(ROWS, floor((S.t - S.wipe) / WIPE) + 1);\n    for (; S.wiped \u003c upto; S.wiped++)\n      for (let c = 0; c \u003c COLS; c++) {\n        const i = S.wiped * COLS + c;\n        S.P[i] = S.NEXT[i], S.T[i] = S.t;\n      }\n    S.dirty = true;\n    if (S.wiped >= ROWS) S.wipe = -1, S.cur = 0, S.acc = 0;\n    else return;\n  }\n  S.acc += dt * S.cps;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    S.P[S.cur] = nextSymbol(S);\n    S.T[S.cur] = S.t;\n    S.cur = (S.cur + 1) % CELLS;\n    S.dirty = true;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.order \u003c 0) return;\n  if (S.dirty) classify(S), (S.dirty = false);\n  const h = S.hue, B = S.black;\n  // Colours by class: 1 noise, 2 a word, 3 a word of a pair from the book.\n  const noise = hsv(h + 0.62, 0.5, 0.42), word = hsv(h + 0.45, 0.8, 1), pair = hsv(h + 0.12, 0.5, 1);\n  const ink = hsv(h + 0.64, 0.55, 0.2 * B);\n  const nl = (1 - B) * (1 - B);\n  const blink = S.wipe \u003c 0 && (S.t * 2.5) % 1 \u003c 0.6;\n  for (let i = 0; i \u003c CELLS; i++) {\n    const x0 = (i % COLS) * CW, y0 = TOP + floor(i / COLS) * CH;\n    const sym = S.P[i], k = S.cls[i];\n    if (i === S.cur && blink) {\n      for (let y = 0; y \u003c 5; y++) for (let x = 0; x \u003c 3; x++) display.setPixel(x0 + x, y0 + y, 200, 200, 190);\n      continue;\n    }\n    if (sym === 0) continue;\n    let col, lv;\n    if (k === 1) (col = noise), (lv = nl);\n    else {\n      col = k === 3 ? pair : word;\n      const n = S.len[i];\n      lv = n >= 3 ? 1 : n === 2 ? 0.8 : 0.6;\n    }\n    // Fresh ink burns toward white and cools into its class colour.\n    const g = exp(-(S.t - S.T[i]) / GLOW), wv = 235 * g;\n    const r = 255 * col[0] * lv * (1 - g) + wv, gg = 255 * col[1] * lv * (1 - g) + wv, b = 255 * col[2] * lv * (1 - g) + wv;\n    const bar = k === 1 && B > 0.01;\n    const f = FONT[sym - 1];\n    for (let y = 0, j = 0; y \u003c 5; y++)\n      for (let x = 0; x \u003c 3; x++, j++) {\n        if (f[j]) {\n          // Under the ink a noise letter fades into its bar.\n          if (bar) display.setPixel(x0 + x, y0 + y, min(255, r + 255 * ink[0]), min(255, gg + 255 * ink[1]), min(255, b + 255 * ink[2]));\n          else display.setPixel(x0 + x, y0 + y, min(255, r), min(255, gg), min(255, b));\n        } else if (bar) display.setPixel(x0 + x, y0 + y, 255 * ink[0], 255 * ink[1], 255 * ink[2]);\n        else if (g > 0.05) display.setPixel(x0 + x, y0 + y, 0.2 * wv, 0.2 * wv, 0.2 * wv);\n      }\n  }\n  // The bottom row is a gauge: the share of the page's letters that stand\n  // in real words, about 0, 2, 6 and 27% at orders 0 to 3 and 98% from 4 on.\n  const lit = round(W * S.share);\n  for (let x = 0; x \u003c W; x++) {\n    const c = x \u003c lit ? word : noise, v = x \u003c lit ? 200 : 110;\n    display.setPixel(x, H - 1, v * c[0], v * c[1], v * c[2]);\n  }\n}\n","silencio":"// ===== Patternflow pattern =====\n// Title:   Silencio\n// Family:  type\n// Idea:    Eugen Gomringer's constellation of fourteen words round one empty place is set on the panel, the Latin words turned a quarter like book spines and the Hangul ones upright, and the empty place drifts from slot to slot, the word it enters trailing off letter by letter while the word it leaves is spoken back in from its first letter, as a slow reading light passes along every line and goes dark over the gap.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: silencio (Eugen Gomringer, 1953), the best-known constellation of concrete poetry, with schweigen and silence, its German and English versions; the Latin letters and the Hangul 침묵 and 고요 drawn for this pattern, pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Hush=0..1\n//\n// Knob 1: Hue. Turns the words round the wheel from a pale azure at 0; the words nearest the silence lean a little towards violet.\n// Knob 2: Speed. How fast the reading light runs and the silence moves: at 2 the light takes a second over each word and pauses 0.6 between words, and the silence moves on every 3.6 seconds (5.4 when it is home); at 0.2 all of it ten times slower. The glow behind the light dies in 1.1 seconds at any speed, so a fast reading leaves whole words lit.\n// Knob 3: Word. 0 silencio, 1 schweigen, 2 silence, 3 침묵, 4 고요. The Latin words stand turned in five columns of three, the Hangul in Gomringer's own three columns of five; a new word empties the field and speaks back in.\n// Knob 4: Hush. Up to 0.1 one place is silent, as in the poem. Above that the silence spreads from it to its neighbours, trailing their words off, until at 1 nine of the fifteen places are silent and only the outer words still speak.\n// Buttons: any button moves the silence on at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- Latin. A lowercase face 9 rows tall: rows 0 and 1 hold ascenders,\n// 2 to 6 the x-height, 7 and 8 the one descender (g). Only the ten letters\n// the three words use. Most are 3 wide; i is 1, l 2, w 5.\nconst LATIN = {\n  s: [\"...\", \"...\", \".##\", \"#..\", \".#.\", \"..#\", \"##.\", \"...\", \"...\"],\n  i: [\"#\", \".\", \"#\", \"#\", \"#\", \"#\", \"#\", \".\", \".\"],\n  l: [\"#.\", \"#.\", \"#.\", \"#.\", \"#.\", \"#.\", \".#\", \"..\", \"..\"],\n  e: [\"...\", \"...\", \".#.\", \"#.#\", \"###\", \"#..\", \".##\", \"...\", \"...\"],\n  n: [\"...\", \"...\", \"##.\", \"#.#\", \"#.#\", \"#.#\", \"#.#\", \"...\", \"...\"],\n  c: [\"...\", \"...\", \".##\", \"#..\", \"#..\", \"#..\", \".##\", \"...\", \"...\"],\n  o: [\"...\", \"...\", \".#.\", \"#.#\", \"#.#\", \"#.#\", \".#.\", \"...\", \"...\"],\n  h: [\"#..\", \"#..\", \"##.\", \"#.#\", \"#.#\", \"#.#\", \"#.#\", \"...\", \"...\"],\n  w: [\".....\", \".....\", \"#...#\", \"#...#\", \"#.#.#\", \"#.#.#\", \".#.#.\", \".....\", \".....\"],\n  g: [\"...\", \"...\", \".##\", \"#.#\", \"#.#\", \"#.#\", \".##\", \"..#\", \"##.\"],\n};\n\n// A Latin word turned a quarter clockwise, the way a spine reads in English:\n// the tops of the letters face right and the word runs down. Turned so, a\n// page of lines becomes columns read top to bottom and right to left, the\n// order of Korean set in vertical columns. A word is a list of letters, each\n// a flat list of LED offsets x, y from the word's top left.\nfunction latinWord(text) {\n  const rows = text.split(\"\").some((ch) => LATIN[ch].slice(7).some((r) => r.includes(\"#\"))) ? 9 : 7;\n  const letters = [];\n  let y = 0;\n  for (const ch of text) {\n    const g = LATIN[ch], px = [];\n    for (let gy = 0; gy \u003c rows; gy++)\n      for (let gx = 0; gx \u003c g[gy].length; gx++) if (g[gy][gx] === \"#\") px.push(rows - 1 - gy, y + gx);\n    letters.push(px);\n    y += g[0].length + 1;\n  }\n  return { w: rows, h: y - 1, letters };\n}\n\n// ---- Hangul. Each syllable is 7 by 11 and each digit marks the jamo a dot\n// belongs to, in writing order, so a Hangul word goes quiet and comes back\n// jamo by jamo: 침묵 has six letters (ㅊ ㅣ ㅁ, ㅁ ㅜ ㄱ), 고요 four (ㄱ ㅗ, ㅇ ㅛ).\nconst HANGUL = {\n  침: [\"..1...2\", \"11111.2\", \"..1...2\", \".1.1..2\", \"1...1.2\", \"......2\", \".......\", \".33333.\", \".3...3.\", \".3...3.\", \".33333.\"],\n  묵: [\".11111.\", \".1...1.\", \".1...1.\", \".11111.\", \".......\", \"2222222\", \"...2...\", \".......\", \".33333.\", \".....3.\", \".....3.\"],\n  고: [\".......\", \".11111.\", \".....1.\", \".....1.\", \".....1.\", \".....1.\", \".......\", \"...2...\", \"...2...\", \"2222222\", \".......\"],\n  요: [\".......\", \"..111..\", \".1...1.\", \".1...1.\", \".1...1.\", \"..111..\", \".......\", \"..2.2..\", \"..2.2..\", \"2222222\", \".......\"],\n};\n\nfunction hangulWord(text) {\n  const letters = [];\n  [...text].forEach((syl, k) => {\n    const g = HANGUL[syl], parts = [];\n    for (let y = 0; y \u003c g.length; y++)\n      for (let x = 0; x \u003c 7; x++) {\n        const d = +g[y][x];\n        if (!d) continue;\n        (parts[d - 1] = parts[d - 1] || []).push(k * 8 + x, y);\n      }\n    letters.push(...parts);\n  });\n  return { w: 15, h: 11, letters };\n}\n\nconst WORDS = [\"silencio\", \"schweigen\", \"silence\", \"침묵\", \"고요\"];\n\n// Fifteen places. Gomringer set three words to a line in five lines with\n// the middle of the third line empty. The Latin words, turned, fill five\n// columns of three (the first line is the right column); the Hangul ones\n// stand in his three columns of five. Either way the empty place is the\n// middle one.\nfunction layout(k) {\n  const latin = k \u003c 3;\n  const word = latin ? latinWord(WORDS[k]) : hangulWord(WORDS[k]);\n  const cols = latin ? 5 : 3, rows = latin ? 3 : 5, slots = [];\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++)\n      slots.push(\n        latin\n          ? { c, r, x: round((c + 0.5) * 12.8 - word.w / 2), y: round(((r + 0.5) * H) / 3 - word.h / 2), line: cols - 1 - c, at: r }\n          : { c, r, x: [3, 24, 46][c], y: 8 + 25 * r, line: r, at: c },\n      );\n  const n = word.letters.length;\n  // A reading light runs along each of the five lines word by word, a pause\n  // the length of 0.6 of a word between words.\n  const step = n * 1.6;\n  return { word, n, cols, rows, slots, home: (rows >> 1) * cols + (cols >> 1), step, line: step * 3 };\n}\n\nconst HOP = 3.6, TRANS = 1.5, RATE = 1 / 1.6;\n\nexport function setup(params) {\n  params.s = { T: 0, k: -1, L: null, q: null, qt: null, at: 0, prev: -1, next: 0, cx: 0, cy: 0, fx: 0, fy: 0, glide: 9, hush: 0, Lv: new Float32Array(N), Hu: new Float32Array(N), Bo: new Float32Array(N) };\n}\n\n// The places sorted into rings by distance from the silence; the hush\n// budget (1 place at Hush 0.1 or less, up to 9) fills them ring by ring and\n// shares out a ring it cannot fill, so neighbours trail off together.\nfunction targets(S) {\n  const { slots, n } = S.L, a = slots[S.at];\n  const budget = 1 + (max(0, S.hush - 0.1) / 0.9) * 8;\n  const d = slots.map((s) => round(sqrt((s.c - a.c) ** 2 + (s.r - a.r) ** 2) * 1000));\n  const rings = [...new Set(d)].sort((x, y) => x - y);\n  let left = budget;\n  S.reach = 0;\n  for (const ring of rings) {\n    const idx = [];\n    d.forEach((v, j) => v === ring && idx.push(j));\n    const f = cl(left / idx.length, 0, 1);\n    for (const j of idx) S.qt[j] = f * n;\n    if (f > 0) S.reach = ring / 1000;\n    left -= idx.length;\n  }\n}\n\nfunction useWord(S, k, first) {\n  S.k = k;\n  S.L = layout(k);\n  const m = S.L.slots.length;\n  S.q = new Float32Array(m);\n  S.qt = new Float32Array(m);\n  S.at = S.L.home;\n  S.prev = -1;\n  const h = S.L.slots[S.at];\n  S.cx = S.fx = h.c;\n  S.cy = S.fy = h.r;\n  S.glide = 9;\n  targets(S);\n  // The first word is there at once. A new word empties the field and comes\n  // back place by place in reading order, each spoken from its first letter.\n  S.L.slots.forEach((s, j) => (S.q[j] = first ? S.qt[j] : S.L.n + 1 + (s.line * 3 + s.at) * 0.2 * S.L.n));\n  S.next = S.T + (first ? HOP * 0.3 : HOP * 1.6);\n}\n\n// The silence moves to a neighbouring place, never straight back, and\n// leans home: a place's weight falls with the square of its distance from\n// the middle, so the poem's own form comes round often.\nfunction hop(S) {\n  const { slots, cols, rows, home } = S.L, a = slots[S.at];\n  const h = slots[home], opts = [], wts = [];\n  for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n    const c = a.c + dc, r = a.r + dr;\n    if (c \u003c 0 || r \u003c 0 || c >= cols || r >= rows) continue;\n    const j = r * cols + c;\n    if (j === S.prev) continue;\n    opts.push(j);\n    wts.push(1 / (1 + (c - h.c) ** 2 + (r - h.r) ** 2));\n  }\n  let u = Math.random() * wts.reduce((x, y) => x + y, 0), j = opts[0];\n  for (let i = 0; i \u003c opts.length; i++) if ((u -= wts[i]) \u003c= 0) {\n    j = opts[i];\n    break;\n  }\n  S.fx = S.cx;\n  S.fy = S.cy;\n  S.prev = S.at;\n  S.at = j;\n  S.glide = 0;\n  targets(S);\n  S.next = S.T + (j === home ? HOP * 1.5 : HOP);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const want = cl(round(k[2]), 0, 4);\n  if (S.k \u003c 0) {\n    S.hush = cl(k[3], 0, 1);\n    useWord(S, want, true);\n  } else if (want !== S.k) useWord(S, want, false);\n  if (abs(k[3] - S.hush) > 1e-4) {\n    S.hush = cl(k[3], 0, 1);\n    targets(S);\n  }\n  S.speed = cl(k[1], 0.05, 3);\n  const step = (dt * S.speed) / 2;\n  S.T += step;\n  if ((input.btnPressed || []).some(Boolean)) S.next = S.T;\n  if (S.T >= S.next) hop(S);\n  // Letters go and come at n letters in TRANS.\n  const rate = (S.L.n / TRANS) * step;\n  for (let j = 0; j \u003c S.q.length; j++) {\n    const d = S.qt[j] - S.q[j];\n    S.q[j] += abs(d) \u003c= rate ? d : Math.sign(d) * rate;\n  }\n  S.glide = min(9, S.glide + step / TRANS);\n  const e = smooth(S.glide), a = S.L.slots[S.at];\n  S.cx = S.fx + (a.c - S.fx) * e;\n  S.cy = S.fy + (a.r - S.fy) * e;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.L) return;\n  const { Lv, Hu, Bo } = S, { word, n, slots, step, line } = S.L;\n  Lv.fill(0);\n  const H0 = 0.56 + S.hue;\n  const pos = S.T * RATE * step;\n  // The sound dies away in 1.1 seconds whatever the speed, so a fast\n  // reader leaves a longer glow behind and a slow one barely any.\n  const tail = max(0.25, RATE * step * (S.speed / 2) * 1.1);\n  slots.forEach((s, j) => {\n    const quiet = S.q[j];\n    if (quiet >= n) return;\n    // Words near the silence speak more softly: full voice two places\n    // beyond the edge of the silence.\n    const dist = sqrt((s.c - S.cx) ** 2 + (s.r - S.cy) ** 2);\n    const near = 1 - smooth((dist - S.reach) / 2);\n    const voice = 1 - 0.34 * near;\n    // Where this line's reading light is, in letters; lines are staggered\n    // by the golden ratio so the five lights never march together.\n    const r = (((pos + s.line * line * 0.618) % line) + line) % line;\n    const hue = H0 + 0.07 * near;\n    word.letters.forEach((px, i) => {\n      const a = cl(n - quiet - i, 0, 1);\n      if (a \u003c= 0) return;\n      // A sound: quick to come, slow to die away behind the light.\n      let u = r - (s.at * step + i);\n      if (u \u003c -line / 2) u += line;\n      else if (u > line / 2) u -= line;\n      const boost = u >= 0 ? exp(-u / tail) : exp(-u * u * 0.8);\n      const v = a * voice * (0.48 + 0.52 * boost);\n      for (let p = 0; p \u003c px.length; p += 2) {\n        const o = (s.y + px[p + 1]) * W + s.x + px[p];\n        Lv[o] = v;\n        Hu[o] = hue;\n        Bo[o] = boost;\n      }\n    });\n  });\n  // A faint glow one LED round each letter; the silent places hold no\n  // letters, and the places sit at least 3 LEDs apart, so it never reaches\n  // into the silence.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      const v = Lv[o];\n      if (v > 0) {\n        const sat = 0.58 * (1 - 0.55 * Bo[o]);\n        const [r, g, b] = hsv(Hu[o], sat, v);\n        display.setPixel(x, y, r * 255, g * 255, b * 255);\n        continue;\n      }\n      let best = 0, hb = 0;\n      for (let dy = -1; dy \u003c= 1; dy++) {\n        const yy = y + dy;\n        if (yy \u003c 0 || yy >= H) continue;\n        for (let dx = -1; dx \u003c= 1; dx++) {\n          const xx = x + dx;\n          if (xx \u003c 0 || xx >= W) continue;\n          const w = Lv[yy * W + xx] * (dx && dy ? 0.14 : 0.24);\n          if (w > best) (best = w), (hb = Hu[yy * W + xx]);\n        }\n      }\n      if (best \u003c= 0) continue;\n      const [r, g, b] = hsv(hb, 0.75, best);\n      display.setPixel(x, y, r * 255, g * 255, b * 255);\n    }\n}\n","walsh-functions":"// ===== Patternflow pattern =====\n// Title:   Walsh Functions\n// Family:  wave\n// Idea:    The top half is the chart of all 64 two-dimensional Walsh functions on 8 by 8 LEDs, laid out in Walsh's sequency order, Paley's dyadic order or Sylvester's natural order, and the bottom half rebuilds a moving abstract picture from its Walsh-Hadamard coefficients, adding them one at a time in zigzag order over the chart, so the picture sharpens out of 8 by 8 blocks while the tile being added lights up above.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Walsh functions (Joseph L. Walsh, \"A closed set of normal orthogonal functions\", 1923), Sylvester's construction of Hadamard matrices (James Joseph Sylvester, 1867), Paley's dyadic ordering (Raymond Paley, 1932), pattern round 67\n// Round:   67\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=0..2, Drop=0..63\n//\n// Knob 1: Hue. Turns both halves round the wheel: at 0 the chart is a checkerboard of blue and pink tiles and the picture runs from navy through teal to pale cyan.\n// Knob 2: Speed. How fast coefficients come: 6 a second at 2, so all 64 are in after 10.5 seconds; they leave three times faster and the count starts again. The picture drifts with it.\n// Knob 3: Order. How the 64 functions are laid out, and so the order they are added in: 0 sequency (Walsh, 1923), where the number of sign changes grows to the right and down; 1 dyadic (Paley, 1932); 2 natural, the rows of Sylvester's Hadamard matrix. Turning it slides every tile to its new place and starts the count again.\n// Knob 4: Drop. How many coefficients at the end of the zigzag are never added: 0 keeps all 64 and the picture comes back exactly; 48 keeps 16; 63 keeps only the mean of each 8 by 8 block. Dropped tiles go dark in the chart.\n\nconst S8 = 8;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The functions. Sylvester's matrix of order 8: row h, column x is\n// +1 or -1 by the parity of the bits h and x share. That is the natural\n// order. Paley's dyadic order takes row bitreverse(k), which multiplies\n// the Rademacher square waves named by the bits of k; Walsh's sequency\n// order takes row bitreverse(gray(k)), and its row k changes sign exactly\n// k times. setup() counts the sign changes and throws if any is wrong.\nconst bits = (v) => { let n = 0; for (; v; v &= v - 1) n++; return n; };\nconst HAD = (h, x) => (bits(h & x) & 1 ? -1 : 1);\nconst rev3 = (k) => ((k & 1) \u003c\u003c 2) | (k & 2) | ((k >> 2) & 1);\nconst gray = (k) => k ^ (k >> 1);\nconst ORDERS = [\n  Array.from({ length: S8 }, (_, k) => rev3(gray(k))), // sequency\n  Array.from({ length: S8 }, (_, k) => rev3(k)), // dyadic\n  Array.from({ length: S8 }, (_, k) => k), // natural\n];\nconst changes = (h) => { let n = 0; for (let x = 1; x \u003c S8; x++) if (HAD(h, x) !== HAD(h, x - 1)) n++; return n; };\n// Sequency of each natural row: 0 7 3 4 1 6 2 5.\nconst SEQ = Array.from({ length: S8 }, (_, h) => changes(h));\n\n// JPEG's zigzag over the 8 by 8 chart: [column, row] in the order added.\nconst ZIG = [];\nfor (let s = 0; s \u003c 2 * S8 - 1; s++)\n  for (let i = 0; i \u003c= s; i++) {\n    const a = s & 1 ? i : s - i, b = s - a;\n    if (a \u003c S8 && b \u003c S8) ZIG.push([b, a]);\n  }\n\n// In-place fast Walsh-Hadamard transform of an 8 by 8 block, rows then\n// columns, natural order, whole numbers only: three rounds of sums and\n// differences each way. Applied twice it gives the block back times 64.\nfunction fwht(B) {\n  for (let r = 0; r \u003c 64; r += 8)\n    for (let len = 1; len \u003c 8; len \u003c\u003c= 1)\n      for (let i = 0; i \u003c 8; i += len \u003c\u003c 1)\n        for (let j = i; j \u003c i + len; j++) {\n          const a = B[r + j], b = B[r + j + len];\n          B[r + j] = a + b;\n          B[r + j + len] = a - b;\n        }\n  for (let c = 0; c \u003c 8; c++)\n    for (let len = 1; len \u003c 8; len \u003c\u003c= 1)\n      for (let i = 0; i \u003c 8; i += len \u003c\u003c 1)\n        for (let j = i; j \u003c i + len; j++) {\n          const a = B[c + j * 8], b = B[c + (j + len) * 8];\n          B[c + j * 8] = a + b;\n          B[c + (j + len) * 8] = a - b;\n        }\n}\n\nexport function setup(params) {\n  // The check the knob names promise: sequency rows change sign 0..7\n  // times in order; a dyadic row's count is the Gray decoding of its index;\n  // the rows are orthogonal.\n  ORDERS[0].forEach((h, k) => { if (SEQ[h] !== k) throw new Error(\"sequency order is wrong at \" + k); });\n  ORDERS[1].forEach((h, k) => { let g = k; for (let m = k >> 1; m; m >>= 1) g ^= m; if (SEQ[h] !== g) throw new Error(\"dyadic order is wrong at \" + k); });\n  for (let a = 0; a \u003c S8; a++)\n    for (let b = 0; b \u003c S8; b++) {\n      let dot = 0;\n      for (let x = 0; x \u003c S8; x++) dot += HAD(a, x) * HAD(b, x);\n      if (dot !== (a === b ? S8 : 0)) throw new Error(\"rows \" + a + \" and \" + b + \" are not orthogonal\");\n    }\n  params.s = {\n    T: 1, dir: 1, wait: 0, clock: 0, order: 0, knob: -1, slide: 1,\n    from: null, img: new Int32Array(4096), rec: new Float64Array(4096), add: new Float64Array(4096), bump: 0,\n    blk: new Int32Array(64), R: new Float64Array(64), keepW: new Float64Array(64), hue: 0, keep: 64,\n  };\n}\n\n// Where each natural pair (hu, hv) sits on the chart in an order:\n// [column, row, zigzag index].\nfunction places(o) {\n  const inv = new Int8Array(S8);\n  ORDERS[o].forEach((h, k) => (inv[h] = k));\n  const at = new Int8Array(S8 * S8);\n  ZIG.forEach(([c, r], i) => (at[r * S8 + c] = i));\n  const P = [];\n  for (let hv = 0; hv \u003c S8; hv++)\n    for (let hu = 0; hu \u003c S8; hu++) {\n      const c = inv[hu], r = inv[hv];\n      P.push([c, r, at[r * S8 + c]]);\n    }\n  return P;\n}\nconst PLACES = [0, 1, 2].map(places);\n\n// The picture, whole numbers 0..255 on 64 by 64: a turning square and a\n// disc drifting past each other over a slowly turning ramp, brighter where\n// they overlap.\nfunction picture(S) {\n  const t = S.clock, img = S.img;\n  const sx = 30 + 10 * cos(t * 0.23), sy = 29 + 9 * sin(t * 0.31), a = t * 0.2, ca = cos(a), sa = sin(a);\n  const dx = 33 + 14 * cos(t * 0.37 + 2), dy = 35 + 13 * sin(t * 0.29 + 1);\n  const th = t * 0.13, ux = cos(th), uy = sin(th);\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c 64; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const lx = (px - sx) * ca + (py - sy) * sa, ly = (py - sy) * ca - (px - sx) * sa;\n      const sq = cl(0.5 - max(abs(lx), abs(ly)) + 12.5, 0, 1);\n      const dc = cl(11.5 - sqrt((px - dx) ** 2 + (py - dy) ** 2), 0, 1);\n      const v = 0.1 + 0.14 * (((px - 32) * ux + (py - 32) * uy) / 45) + 0.5 * sq + 0.4 * dc;\n      img[y * 64 + x] = round(cl(v, 0, 1) * 255);\n    }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  const sp = cl(k[1], 0.05, 3);\n  S.hue = k[0];\n  S.keep = 64 - cl(round(k[3]), 0, 63);\n  const o = cl(round(k[2]), 0, 2);\n  if (S.knob \u003c 0) (S.knob = S.order = o), (S.from = PLACES[o]);\n  else if (o !== S.order) {\n    // Slide from wherever the tiles are now, and count again from one.\n    S.from = current(S);\n    S.order = o;\n    S.slide = 0;\n    S.T = 1;\n    S.dir = 1;\n    S.wait = 0.4;\n  }\n  S.slide = min(1, S.slide + dt / 0.9);\n  S.clock += dt * sp * 0.5;\n  // The count: up at 3 x Speed a second to keep, a pause, down three times\n  // faster, a pause, again.\n  const rate = 3 * sp;\n  if (S.wait > 0) S.wait -= dt;\n  else if (S.dir > 0) {\n    S.T = min(S.keep, S.T + dt * rate);\n    if (S.T >= S.keep) (S.dir = -1), (S.wait = 1.4);\n  } else {\n    S.T = max(1, S.T - dt * rate * 3);\n    if (S.T \u003c= 1) (S.dir = 1), (S.wait = 0.6);\n  }\n  if (S.T > S.keep) S.T = S.keep;\n\n  // Transform every 8 by 8 block of the picture, then rebuild it from the\n  // first floor(T) coefficients in zigzag order and a share of the next.\n  picture(S);\n  const { img, rec, add, blk, keepW, R } = S;\n  const n = floor(S.T), part = S.T - n, P = PLACES[S.order];\n  let fN = -1;\n  P.forEach(([, , i], f) => {\n    keepW[f] = i \u003c n ? 1 : i === n && n \u003c S.keep ? part : 0;\n    if (i === n && n \u003c S.keep) fN = f;\n  });\n  S.bump = fN \u003c 0 ? 0 : sin(PI * part);\n  for (let by = 0; by \u003c 8; by++)\n    for (let bx = 0; bx \u003c 8; bx++) {\n      const o0 = by * 512 + bx * 8;\n      for (let y = 0; y \u003c 8; y++) for (let x = 0; x \u003c 8; x++) blk[y * 8 + x] = img[o0 + y * 64 + x];\n      fwht(blk);\n      // What the coefficient now fading in adds to this block: its own\n      // basis image, as large as the coefficient.\n      const c = fN \u003c 0 ? 0 : blk[fN] / 64;\n      for (let y = 0; y \u003c 8; y++) for (let x = 0; x \u003c 8; x++) add[o0 + y * 64 + x] = c * HAD(fN & 7, x) * HAD(fN >> 3, y);\n      // Inverse: the same transform on the kept coefficients, over 64. Kept\n      // whole, they stay whole numbers; only the one fading in is a share.\n      for (let f = 0; f \u003c 64; f++) R[f] = blk[f] * keepW[f];\n      fwht(R);\n      for (let y = 0; y \u003c 8; y++) for (let x = 0; x \u003c 8; x++) rec[o0 + y * 64 + x] = R[y * 8 + x] / 64;\n    }\n}\n\n// Where the tiles are drawn now: on the way from the old layout to the new.\nfunction current(S) {\n  const to = PLACES[S.order], e = smooth(S.slide);\n  return to.map(([c, r, i], f) => [S.from[f][0] + (c - S.from[f][0]) * e, S.from[f][1] + (r - S.from[f][1]) * e, i]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.from) return;\n  const pos = current(S);\n  const T = S.T, keep = S.keep;\n  // The chart. Tile f is the natural pair (hu, hv) = (f % 8, f / 8); its\n  // colour belongs to the function, by its two sequencies, so it travels\n  // with the tile: a checkerboard of two hues in sequency order.\n  for (let f = 0; f \u003c 64; f++) {\n    const hu = f & 7, hv = f >> 3, su = SEQ[hu], sv = SEQ[hv], i = PLACES[S.order][f][2];\n    const hueF = 0.59 + S.hue + 0.31 * ((su + sv) & 1) + (0.06 * (su + sv)) / 14;\n    let L, flash = 0;\n    if (i >= keep) L = 0.1;\n    else {\n      const inn = cl(T - i, 0, 1);\n      flash = T > i ? exp(-(T - i) * 0.8) : 0;\n      L = 0.34 + 0.5 * inn;\n    }\n    const [pr, pg, pb] = hsv(hueF, 0.75 - 0.6 * flash, min(1, L + 0.5 * flash));\n    const [nr, ng, nb] = hsv(hueF, 0.6, 0.04 + 0.06 * L + 0.25 * flash);\n    const ox = round(pos[f][0] * 8), oy = round(pos[f][1] * 8);\n    for (let y = 0; y \u003c 8; y++) {\n      const sy = HAD(hv, y);\n      for (let x = 0; x \u003c 8; x++) {\n        const plus = HAD(hu, x) * sy > 0;\n        display.setPixel(ox + x, oy + y, min(255, (plus ? pr : nr) * 255), min(255, (plus ? pg : ng) * 255), min(255, (plus ? pb : nb) * 255));\n      }\n    }\n  }\n  // The rebuilt picture below.\n  const rec = S.rec;\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c 64; x++) {\n      const v = cl(rec[y * 64 + x] / 255, 0, 1);\n      const [r, g, b] = hsv(0.6 + S.hue - 0.16 * v, 0.85 - 0.6 * v * v, 0.13 + 0.87 * v);\n      // A white stamp of the term coming in, where it changes the picture.\n      const w = S.bump * min(1, abs(S.add[y * 64 + x]) / 48) * 0.45;\n      display.setPixel(x, 64 + y, min(255, (r + w) * 255), min(255, (g + w) * 255), min(255, (b + w) * 255));\n    }\n}\n","barrier-grid":"// ===== Patternflow pattern =====\n// Title:   Barrier Grid\n// Family:  type\n// Idea:    A barrier of dark bars with one slit in every two to four columns slides one column at a time over a print that interleaves a word and its negative column by column, so each step turns the word from light to shadow and back, every fourth step brings the next word, the frames mix while the barrier glides, and a tilted barrier lays moire bands across the word.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: barrier-grid animation as in the scanimation books of Rufus Butler Seder (Gallop!, 2007); moire of two superposed line gratings (Lord Rayleigh, 1874), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Frames=2..4, Tilt=0..1\n//\n// Knob 1: Hue. The light behind the slits: at 0 the word glows gold and its negative is the opposite blue, and turning it moves the pair round the wheel, always opposite each other the way a colour negative is.\n// Knob 2: Speed. How fast the barrier steps: at 2 a step every 1.6 seconds (held 0.96 s, gliding 0.64 s) and a new word every 6.4 seconds, at 0.2 a step every 16 seconds, at 3 one every 1.07.\n// Knob 3: Frames. How many frames the print interleaves, which is the period of the line screen and of the barrier: at 2 every other column is lit, at 3 every third, at 4 every fourth, with the bars wider in between.\n// Knob 4: Tilt. Turns the barrier against the print, so the slits drift sideways down the panel by up to three periods at 1 (tilt squared, so 0.06 is nearly level): moire bands cross the word, light in one band and shadow in the next, and roll down it while the barrier glides.\n\nconst W = 64, H = 128, N = W * H;\nconst Q = 3; // supersampling of the glyph masks\nconst { floor, round, min, max, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Words of light and of looking. A Hangul word is one syllable filling the\n// panel; a Latin word is four letters, two by two, 28 by 58 LEDs each.\nconst WORDS = [\"빛\", \"LOOK\", \"달\", \"NEON\", \"별\", \"HALO\", \"밤\", \"SEEN\"];\n\n// Shapes: [kind, add, ...]. kind 0 a rounded box x0 y0 x1 y1 tl tr br bl,\n// kind 1 a thick segment x0 y0 x1 y1 width.\nfunction glyph(ch, w, h, s, t) {\n  const P = [];\n  const rr = (x0, y0, x1, y1, tl = 0, tr = 0, br = 0, bl = 0, add = 1) => P.push([0, add, x0, y0, x1, y1, tl, tr, br, bl]);\n  const ln = (x0, y0, x1, y1, wd, add = 1) => P.push([1, add, x0, y0, x1, y1, wd]);\n  const R = 13, r = 5;\n  switch (ch) {\n    case \"O\":\n      rr(0, 0, w, h, R, R, R, R);\n      rr(s, t, w - s, h - t, r, r, r, r, 0);\n      break;\n    case \"L\":\n      rr(0, 0, s, h);\n      rr(0, h - t, w, h);\n      break;\n    case \"K\":\n      rr(0, 0, s, h);\n      ln(s - 1, h * 0.58, w - 5, 4, 10);\n      ln(s + 5, h * 0.42, w - 5, h - 4, 10);\n      rr(w - 9, 0, w, 6, 0, 0, 0, 0, 0);\n      break;\n    case \"N\":\n      rr(0, 0, s, h);\n      rr(w - s, 0, w, h);\n      ln(4, 4, w - 4, h - 4, 10);\n      break;\n    case \"E\":\n      rr(0, 0, s, h);\n      rr(0, 0, w, t);\n      rr(0, round(h / 2 - t / 2), w - 4, round(h / 2 + t / 2));\n      rr(0, h - t, w, h);\n      break;\n    case \"H\":\n      rr(0, 0, s, h);\n      rr(w - s, 0, w, h);\n      rr(0, round(h / 2 - t / 2), w, round(h / 2 + t / 2));\n      break;\n    case \"A\":\n      rr(0, 0, w, h, R, R, 0, 0);\n      rr(s, t, w - s, h + 1, r, r, 0, 0, 0);\n      rr(0, round(h * 0.55), w, round(h * 0.55) + t);\n      break;\n    case \"S\": {\n      // Two bowls sharing the middle bar, each open on one side.\n      const m = round(h / 2 - t / 2);\n      rr(0, 0, w, m + t, R, R, R, R);\n      rr(s, t, w - s, m, r, r, r, r, 0);\n      rr(w - s, t + 4, w + 1, m, 0, 0, 0, 0, 0);\n      rr(0, m, w, h, R, R, R, R);\n      rr(s, m + t, w - s, h - t, r, r, r, r, 0);\n      rr(-1, m + t, s, h - t - 4, 0, 0, 0, 0, 0);\n      break;\n    }\n    default:\n      hangul(ch, w, h, s, t, rr, ln);\n  }\n  return P;\n}\n\n// The four Hangul syllables, each one filling the panel: the initial top\n// left, the vowel's stem on the right, the final across the lower half. The\n// coordinates are the panel's, and the upright strokes stand on multiples of\n// 4 LEDs, so a stroke covers whole columns of the line screen.\nfunction hangul(ch, w, h, s, t, rr, ln) {\n  // ㅂ, ㄷ, ㄹ and ㅁ from bars.\n  const b = (x0, y0, x1, y1) => {\n    const m = round(y0 + (y1 - y0) * 0.45);\n    rr(x0, y0, x0 + s, y1);\n    rr(x1 - s, y0, x1, y1);\n    rr(x0, m, x1, m + t);\n    rr(x0, y1 - t, x1, y1);\n  };\n  const d = (x0, y0, x1, y1) => {\n    rr(x0, y0, x1, y0 + t);\n    rr(x0, y0, x0 + s, y1);\n    rr(x0, y1 - t, x1, y1);\n  };\n  const rieul = (x0, y0, x1, y1) => {\n    const m = round((y0 + y1) / 2 - t / 2);\n    rr(x0, y0, x1, y0 + t);\n    rr(x1 - s, y0, x1, m + t);\n    rr(x0, m, x1, m + t);\n    rr(x0, m, x0 + s, y1);\n    rr(x0, y1 - t, x1, y1);\n  };\n  const mieum = (x0, y0, x1, y1) => {\n    rr(x0, y0, x1, y1, 2, 2, 2, 2);\n    rr(x0 + s, y0 + t, x1 - s, y1 - t, 0, 0, 0, 0, 0);\n  };\n  // ㅏ: the stem with its arm to the right.\n  const a = () => {\n    rr(44, 4, 56, 68);\n    rr(56, 30, 64, 39);\n  };\n  if (ch === \"빛\") {\n    b(4, 8, 40, 64);\n    rr(48, 4, 60, 70);\n    rr(28, 74, 36, 82);\n    rr(4, 84, 60, 93);\n    ln(32, 95, 12, 124, 13);\n    ln(32, 95, 52, 124, 13);\n  } else if (ch === \"달\") {\n    d(4, 8, 36, 64);\n    a();\n    rieul(8, 76, 56, 124);\n  } else if (ch === \"별\") {\n    b(4, 8, 32, 64);\n    rr(48, 4, 60, 70);\n    rr(36, 20, 48, 29);\n    rr(36, 42, 48, 51);\n    rieul(8, 76, 56, 124);\n  } else if (ch === \"밤\") {\n    b(4, 8, 36, 64);\n    a();\n    mieum(8, 76, 56, 124);\n  }\n}\n\nfunction inside(p, x, y) {\n  if (p[0] === 0) {\n    if (x \u003c p[2] || x > p[4] || y \u003c p[3] || y > p[5]) return false;\n    const cx = (p[2] + p[4]) / 2, cy = (p[3] + p[5]) / 2;\n    const left = x \u003c cx, top = y \u003c cy;\n    const r = left ? (top ? p[6] : p[9]) : top ? p[7] : p[8];\n    if (r \u003c= 0) return true;\n    const dx = left ? p[2] + r - x : x - (p[4] - r);\n    const dy = top ? p[3] + r - y : y - (p[5] - r);\n    if (dx \u003c= 0 || dy \u003c= 0) return true;\n    return dx * dx + dy * dy \u003c= r * r;\n  }\n  const ex = p[4] - p[2], ey = p[5] - p[3];\n  const u = cl(((x - p[2]) * ex + (y - p[3]) * ey) / (ex * ex + ey * ey), 0, 1);\n  const dx = x - p[2] - u * ex, dy = y - p[3] - u * ey;\n  return dx * dx + dy * dy \u003c= (p[6] * p[6]) / 4;\n}\n\n// The shapes of a word placed on the panel, each with the rows and columns\n// of the supersampled mask it may touch.\nfunction layout(word) {\n  const chars = [...word];\n  const big = chars.length === 1;\n  const cells = big ? [[0, 0, 64, 128]] : [[2, 4, 28, 58], [34, 4, 28, 58], [2, 66, 28, 58], [34, 66, 28, 58]];\n  const out = [];\n  chars.forEach((ch, gi) => {\n    const [cx, cy, w, h] = cells[gi];\n    for (const p of glyph(ch, w, h, big ? 12 : 8, big ? 9 : 7)) {\n      let x0, y0, x1, y1;\n      if (p[0] === 0) (x0 = p[2]), (y0 = p[3]), (x1 = p[4]), (y1 = p[5]);\n      else {\n        const r = p[6] / 2;\n        (x0 = min(p[2], p[4]) - r), (x1 = max(p[2], p[4]) + r), (y0 = min(p[3], p[5]) - r), (y1 = max(p[3], p[5]) + r);\n      }\n      out.push({\n        p, cx, cy,\n        sx0: max(cx * Q, floor((cx + x0) * Q)), sx1: min((cx + w) * Q, ceil((cx + x1) * Q)),\n        sy0: max(cy * Q, floor((cy + y0) * Q)), sy1: min((cy + h) * Q, ceil((cy + y1) * Q)),\n      });\n    }\n  });\n  return out;\n}\n\n// A word's mask is built 8 rows at a time, a few frames ahead of the step\n// that needs it, so no frame pays for a whole word. Each shape inks (1) or\n// cuts (0) the samples inside it, in order, and the samples are averaged\n// back to coverage per LED.\nconst CHUNK = 8;\nfunction buildRows(B, rows) {\n  const r0 = B.row, r1 = min(H, r0 + rows);\n  const hi = B.hi, WQ = W * Q;\n  for (const sh of B.shapes) {\n    const sy0 = max(sh.sy0, r0 * Q), sy1 = min(sh.sy1, r1 * Q);\n    for (let sy = sy0; sy \u003c sy1; sy++)\n      for (let sx = sh.sx0; sx \u003c sh.sx1; sx++)\n        if (inside(sh.p, (sx + 0.5) / Q - sh.cx, (sy + 0.5) / Q - sh.cy)) hi[sy * WQ + sx] = sh.p[1];\n  }\n  for (let y = r0; y \u003c r1; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let n = 0;\n      for (let j = 0; j \u003c Q; j++) for (let i = 0; i \u003c Q; i++) n += hi[(y * Q + j) * WQ + x * Q + i];\n      B.m[y * W + x] = n / (Q * Q);\n    }\n  B.row = r1;\n}\n\nfunction job(S, wi) {\n  if (!S.jobs[wi]) S.jobs[wi] = { shapes: layout(WORDS[wi]), hi: new Uint8Array(W * Q * H * Q), m: new Float32Array(N), row: 0 };\n  return S.jobs[wi];\n}\n\n// The mask now: finished at once if the background builder has not got there.\nfunction mask(S, wi) {\n  const B = job(S, wi);\n  if (B.row \u003c H) buildRows(B, H);\n  return B.m;\n}\n\nexport function setup(params) {\n  params.s = { jobs: [], u: 0, hue: 0, n: 2, tilt: 0.06, col: new Float32Array(H * 6), bar: new Float32Array(6) };\n}\n\n// The stream of frames: each word four times, light, shadow, light, shadow.\nconst REPEAT = 4;\nconst wordOf = (f) => floor(f / REPEAT) % WORDS.length;\n\n// A step lasts STEP seconds at Speed 2, and the barrier glides for the last\n// GLIDE of it. The bars are pierced on a checkerboard: a hole catches G1 of\n// the light in the slits beside it and lets G2 of the print under the bar\n// show through. OVER brightens a half-open column, so in mid-glide both\n// frames shine at 0.8.\nconst STEP = 1.6, GLIDE = 0.4;\nconst G1 = 0.35, G2 = 0.2, OVER = 1.6;\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.hue = k[0];\n  S.n = cl(round(k[2]), 2, 4);\n  S.tilt = cl(k[3], 0, 1);\n  S.u += (dt * cl(k[1], 0.05, 3)) / 2 / STEP;\n  // Build ahead: the first unfinished word among those the print holds now\n  // and the next one it will need.\n  for (let f = floor(S.u); f \u003c= floor(S.u) + S.n + REPEAT; f++) {\n    const B = job(S, wordOf(f));\n    if (B.row \u003c H) {\n      buildRows(B, CHUNK);\n      break;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  const n = S.n;\n  const K = floor(S.u);\n  const e = S.u - K;\n  const g = e \u003c 1 - GLIDE ? 0 : (e - 1 + GLIDE) / GLIDE;\n  // The barrier's place in columns: on step K the slits stand over the\n  // columns of slot K mod n, and in the glide they ease one column right.\n  const b = K + g * g * (3 - 2 * g);\n  // Slot s of the print holds the frame f of K..K+n-1 with f = s mod n. A\n  // slot the barrier has just left is printed again with the frame n steps\n  // on, so the print always carries the frame on show and the next n-1.\n  const fw = [], fn = [];\n  for (let s = 0; s \u003c n; s++) {\n    const f = K + ((((s - K) % n) + n) % n);\n    fw.push(mask(S, wordOf(f)));\n    fn.push(f % 2);\n  }\n  // Light for the word (gold at Hue 0) and for its negative (the opposite\n  // blue), a little warmer down the panel.\n  const col = S.col;\n  for (let y = 0; y \u003c H; y++) {\n    hsv(0.11 + S.hue - 0.05 * (y / H), 0.62, 1, col, y * 6);\n    hsv(0.61 + S.hue - 0.05 * (y / H), 0.62, 1, col, y * 6 + 3);\n  }\n  // The bars' own faint indigo, and the pale light of the print under them.\n  const bar = S.bar;\n  hsv(0.7, 0.7, 0.1, bar, 0);\n  hsv(0.7, 0.3, 1, bar, 3);\n  const shift = S.tilt * S.tilt * 3 * n;\n  const o = [0, 0, 0, 0], V = [0, 0, 0, 0];\n  const g1 = (G1 * 2) / n, g2 = (G2 * 2) / n;\n  for (let y = 0; y \u003c H; y++) {\n    // How open each slot's columns are in this row: a slit one column wide,\n    // box-filtered over the LED, so the openings of the n slots add to 1.\n    const by = b + shift * (y / (H - 1) - 0.5);\n    for (let k = 0; k \u003c n; k++) {\n      let d = (k - by) % n;\n      if (d \u003c 0) d += n;\n      o[k] = max(0, 1 - min(d, n - d));\n    }\n    const c0 = y * 6;\n    for (let x = 0; x \u003c W; x++) {\n      const s = x % n, p = y * W + x;\n      // Every slot's print at this LED, and the light the slits pass, which\n      // is what a hole in a bar here would catch.\n      let vr = 0, vg = 0, vb = 0;\n      for (let k = 0; k \u003c n; k++) {\n        const v = fn[k] ? 1 - fw[k][p] : fw[k][p];\n        V[k] = v;\n        const c = c0 + fn[k] * 3, w = o[k] * v;\n        vr += col[c] * w;\n        vg += col[c + 1] * w;\n        vb += col[c + 2] * w;\n      }\n      const os = o[s], lit = V[s] * min(1, OVER * os), c = c0 + fn[s] * 3, shut = 1 - os;\n      let r = col[c] * lit + bar[0] * shut, gg = col[c + 1] * lit + bar[1] * shut, bb = col[c + 2] * lit + bar[2] * shut;\n      if ((x + y) & 1) {\n        const h1 = shut * g1, h2 = shut * g2 * V[s];\n        r += h1 * vr + h2 * bar[3];\n        gg += h1 * vg + h2 * bar[4];\n        bb += h1 * vb + h2 * bar[5];\n      }\n      display.setPixel(x, y, min(255, r * 255) | 0, min(255, gg * 255) | 0, min(255, bb * 255) | 0);\n    }\n  }\n}\n","etaoin-shrdlu":"// ===== Patternflow pattern =====\n// Title:   Etaoin Shrdlu\n// Family:  data\n// Idea:    A passage set in a 3 by 5 face comes loose one letter at a time from its last line, and each letter falls into one of sixteen columns kept sorted by how often the letter has come, so the columns trade places as one overtakes another and the labels under them end up spelling the passage's own etaoin shrdlu above the order the Linotype keyboard was built on.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: pattern round 66, after the Linotype (Ottmar Mergenthaler, 1886), whose lowercase keys ran etaoin shrdlu cmfwyp vbgkqj by letter frequency, and the line ETAOIN SHRDLU that operators left in newspapers; counting Lewis Carroll's Alice's Adventures in Wonderland (1865), Lorem ipsum from Cicero's De finibus bonorum et malorum (45 BC), ten pangrams, and the cryptogram Legrand breaks by counting in Edgar Allan Poe's The Gold-Bug (1843); the 3 by 5 face from the Typewriter pattern (round 18), with figures and Poe's symbols added\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Forget=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. Each letter keeps one colour, set by its place in the Linotype's order: at 0 E is cyan, the rest of ETAOIN blue, SHRDLU indigo to magenta and the rare letters red, orange and gold, so a passage close to that order reads as one rainbow across the columns and Lorem ipsum as a broken one.\n// Knob 2: Speed. Letters coming loose a second: 8 at 2, so Alice's 464 letters take 58 s; 0.8 at 0.2 and 12 at 3. They also fall a little harder as it turns up.\n// Knob 3: Text. Each ends on its own order: 0 Alice, ETIONS AHRDWG, six of the twelve in the Linotype's places; 1 Lorem ipsum, IETAOU NLRDSM, two; 2 ten pangrams, every letter 10 times or more and 17 of them exactly 10, none; 3 Poe's cryptogram, 8;4)‡* 56(†10, which is ETHSON AIRDFL, five.\n// Knob 4: Forget. How far back the columns count: the last 520 letters at 0.06, which is all of every passage here, 113 at 0.5 and only the last 20 at 1, where each letter is a sort 15 rows tall with its face on it and the order changes at 80 of 100 landings against 18 at 0.06.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp, sqrt, sin, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Layout, rows y down. Seven lines of type at the top (6 rows each), the\n// reading line last; sixteen columns 4 LEDs apart standing on row 113 and at\n// most 62 rows tall; the passage's labels on rows 116-120 and the\n// Linotype's order on rows 122-126.\nconst LINES = 7;\nconst READ_Y = 37;\nconst BASE = 113;\nconst MAXH = 62;\nconst LABEL_Y = 116;\nconst REF_Y = 122;\nconst SLOTS = 16;\n// Under floor(S) letters in the tallest column the scale stops growing, so\n// early in a passage each letter is a sort 62 / 9 = 6.9 rows tall with its\n// face on it. Counting only the last 20, the floor drops to 4 and a sort is\n// 15.5 rows.\nconst floorUnits = (S) => cl(S.keep / 5, 4, 9);\nconst HOLD = 6;\nconst DRAIN = 1.2;\n\n// The Linotype's lowercase keys, column by column.\nconst LINO = \"ETAOINSHRDLUCMFWYPVBGKQJXZ\";\n\n// The 3 by 5 face, rows top to bottom, one bit per column. The letters and\n// most punctuation are Typewriter's; the figures and Poe's dagger, double\n// dagger, pilcrow, asterisk and brackets are new.\nconst GLYPHS = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\", \".\": \"000000000000010\", \",\": \"000000000010100\",\n  \"-\": \"000000111000000\", \"!\": \"010010010000010\", \"?\": \"110001010000010\", \"'\": \"010010000000000\",\n  \":\": \"000010000010000\", \";\": \"000010000010100\",\n  \"0\": \"111101101101111\", \"1\": \"010110010010111\", \"2\": \"111001111100111\", \"3\": \"111001011001111\",\n  \"4\": \"101101111001001\", \"5\": \"111100111001111\", \"6\": \"111100111101111\", \"8\": \"111101111101111\",\n  \"9\": \"111101111001111\", \"†\": \"010111010010010\", \"‡\": \"010111010111010\", \"¶\": \"011111011011011\",\n  \"*\": \"101010111010101\", \"(\": \"001010010010001\", \")\": \"100010010010100\",\n};\nconst BITS = {};\nfor (const ch in GLYPHS) BITS[ch] = GLYPHS[ch].split(\"\").map(Number);\n\n// Poe's key, letter to symbol, as Legrand reads it out: 8 is e, ; is t, and\n// so on. The cryptogram is the plaintext below put through it, so the counts\n// are the plaintext's: 8 33, ; 26, 4 19, the start of Legrand's own table.\nconst KEY = { A: \"5\", B: \"2\", C: \"-\", D: \"†\", E: \"8\", F: \"1\", G: \"3\", H: \"4\", I: \"6\", L: \"0\", M: \"9\", N: \"*\", O: \"‡\", P: \".\", R: \"(\", S: \")\", T: \";\", U: \"?\", V: \"¶\", Y: \":\" };\nconst PLAIN =\n  \"A GOOD GLASS IN THE BISHOP'S HOSTEL IN THE DEVIL'S SEAT FORTY-ONE DEGREES AND THIRTEEN MINUTES NORTHEAST AND BY NORTH MAIN BRANCH SEVENTH LIMB EAST SIDE SHOOT FROM THE LEFT EYE OF THE DEATH'S-HEAD A BEE LINE FROM THE TREE THROUGH THE SHOT FIFTY FEET OUT\";\n\nconst TEXTS = [\n  // Alice's Adventures in Wonderland (1865), the first two sentences.\n  \"ALICE WAS BEGINNING TO GET VERY TIRED OF SITTING BY HER SISTER ON THE BANK, AND OF HAVING NOTHING TO DO: ONCE OR TWICE SHE HAD PEEPED INTO THE BOOK HER SISTER WAS READING, BUT IT HAD NO PICTURES OR CONVERSATIONS IN IT, 'AND WHAT IS THE USE OF A BOOK,' THOUGHT ALICE 'WITHOUT PICTURES OR CONVERSATIONS?' SO SHE WAS CONSIDERING IN HER OWN MIND (AS WELL AS SHE COULD, FOR THE HOT DAY MADE HER FEEL VERY SLEEPY AND STUPID), WHETHER THE PLEASURE OF MAKING A DAISY-CHAIN WOULD BE WORTH THE TROUBLE OF GETTING UP AND PICKING THE DAISIES, WHEN SUDDENLY A WHITE RABBIT WITH PINK EYES RAN CLOSE BY HER.\",\n  \"LOREM IPSUM DOLOR SIT AMET, CONSECTETUR ADIPISCING ELIT, SED DO EIUSMOD TEMPOR INCIDIDUNT UT LABORE ET DOLORE MAGNA ALIQUA. UT ENIM AD MINIM VENIAM, QUIS NOSTRUD EXERCITATION ULLAMCO LABORIS NISI UT ALIQUIP EX EA COMMODO CONSEQUAT. DUIS AUTE IRURE DOLOR IN REPREHENDERIT IN VOLUPTATE VELIT ESSE CILLUM DOLORE EU FUGIAT NULLA PARIATUR. EXCEPTEUR SINT OCCAECAT CUPIDATAT NON PROIDENT, SUNT IN CULPA QUI OFFICIA DESERUNT MOLLIT ANIM ID EST LABORUM.\",\n  \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS. SPHINX OF BLACK QUARTZ, JUDGE MY VOW. JACKDAWS LOVE MY BIG SPHINX OF QUARTZ. HOW VEXINGLY QUICK DAFT ZEBRAS JUMP! THE FIVE BOXING WIZARDS JUMP QUICKLY. WALTZ, BAD NYMPH, FOR QUICK JIGS VEX. GLIB JOCKS QUIZ NYMPH TO VEX DWARF. QUICK ZEPHYRS BLOW, VEXING DAFT JIM. TWO DRIVEN JOCKS HELP FAX MY BIG QUIZ.\",\n  null,\n];\n\n// A passage as lines of at most 16 characters and the list of letters to\n// count, each with its line, column, token (what it looks like) and key (the\n// letter it stands for, which sets its colour).\nfunction prepare(t) {\n  const lines = [];\n  if (t === 3) {\n    // Poe printed the cryptogram run together, so it breaks every 16.\n    let s = \"\";\n    for (const ch of PLAIN) if (KEY[ch]) s += KEY[ch];\n    for (let i = 0; i \u003c s.length; i += 16) lines.push(s.slice(i, i + 16));\n  } else {\n    let line = \"\";\n    for (const word of TEXTS[t].split(\" \")) {\n      if (line && line.length + 1 + word.length > 16) {\n        lines.push(line);\n        line = word;\n      } else line = line ? line + \" \" + word : word;\n    }\n    lines.push(line);\n  }\n  const back = {};\n  for (const k in KEY) back[KEY[k]] = k;\n  const letters = [];\n  lines.forEach((s, li) => {\n    for (let c = 0; c \u003c s.length; c++) {\n      const ch = s[c];\n      if (t === 3 ? back[ch] : ch >= \"A\" && ch \u003c= \"Z\") letters.push({ tok: ch, key: t === 3 ? back[ch] : ch, line: li, col: c });\n    }\n  });\n  return { lines, letters, cipher: t === 3 };\n}\n\nfunction hsv(h, s, v) {\n  h = (((h % 1) + 1) % 1) * 6;\n  const i = floor(h), f = h - i;\n  const p = v * (1 - s), q = v * (1 - s * f), u = v * (1 - s * (1 - f));\n  const c = [[v, u, p], [q, v, p], [p, v, u], [p, q, v], [u, p, v], [v, p, q]][i % 6];\n  return [c[0] * 255, c[1] * 255, c[2] * 255];\n}\n\n// A letter's colour: its key's place in the Linotype's order round the wheel.\nconst colourOf = (S, tok) => hsv(0.5 + S.hue + LINO.indexOf(S.keyOf[tok] || tok) * 0.031, 0.78, 1);\n\nexport function setup(params) {\n  params.s = { started: false };\n}\n\n// Start a passage: no counts, no columns, its first line onto the galley.\nfunction begin(S, t) {\n  S.textIdx = t;\n  S.text = prepare(t);\n  S.read = 0;\n  S.line = -1;\n  S.cnt = {};\n  S.keyOf = {};\n  for (const L of S.text.letters) S.keyOf[L.tok] = L.key;\n  S.cols = [];\n  S.cx = {};\n  S.flash = {};\n  S.queue = [];\n  S.head = 0;\n  S.fall = [];\n  S.acc = 0;\n  S.phase = 0;\n  S.pt = 0;\n  S.drain = 1;\n  feed(S, 0, false);\n}\n\n// Put passage lines up to li onto the galley; it scrolls up a line for each.\nfunction feed(S, li, still) {\n  while (S.line \u003c li) {\n    S.line++;\n    S.galley.push({ s: S.text.lines[S.line], slug: null, li: S.line });\n    if (!still) S.scroll += 6;\n  }\n  if (S.galley.length > 12) S.galley.splice(0, S.galley.length - 12);\n}\n\nconst slotX = (i) => i * 4;\n\nfunction bubbleLeft(S, i) {\n  const c = S.cols, n = S.cnt;\n  while (i > 0 && n[c[i]] > n[c[i - 1]]) {\n    const a = c[i];\n    c[i] = c[i - 1];\n    c[i - 1] = a;\n    i--;\n  }\n}\n\n// The letter not in a column with the highest count, if it beats the last column.\nfunction promote(S) {\n  const c = S.cols;\n  let best = null;\n  for (const k in S.cnt) if (S.cnt[k] > 0 && !c.includes(k) && (best === null || S.cnt[k] > S.cnt[best])) best = k;\n  if (best === null) return;\n  if (c.length \u003c SLOTS) {\n    c.push(best);\n    if (S.cx[best] === undefined) S.cx[best] = slotX(c.length - 1);\n    bubbleLeft(S, c.length - 1);\n  } else if (S.cnt[best] > S.cnt[c[SLOTS - 1]]) {\n    S.cx[best] = S.cx[c[SLOTS - 1]];\n    c[SLOTS - 1] = best;\n    bubbleLeft(S, SLOTS - 1);\n  }\n}\n\n// A letter has landed: count it, forget the oldest past the keep, re-sort.\nfunction land(S, tok) {\n  S.cnt[tok] = (S.cnt[tok] || 0) + 1;\n  S.queue.push(tok);\n  const i = S.cols.indexOf(tok);\n  if (i >= 0) {\n    bubbleLeft(S, i);\n    S.flash[tok] = 1;\n  } else promote(S);\n  trim(S);\n}\n\nfunction trim(S) {\n  while (S.queue.length - S.head > S.keep) {\n    const old = S.queue[S.head++];\n    S.cnt[old]--;\n    const c = S.cols;\n    let i = c.indexOf(old);\n    if (i >= 0) {\n      if (S.cnt[old] \u003c= 0) c.splice(i, 1);\n      else\n        while (i \u003c c.length - 1 && S.cnt[c[i]] \u003c S.cnt[c[i + 1]]) {\n          c[i] = c[i + 1];\n          c[i + 1] = old;\n          i++;\n        }\n    }\n    promote(S);\n  }\n  if (S.head > 2000) {\n    S.queue = S.queue.slice(S.head);\n    S.head = 0;\n  }\n}\n\nconst tallest = (S) => {\n  let m = 0;\n  for (const k of S.cols) m = max(m, S.cnt[k]);\n  return m;\n};\n\n// One step of the machine.\nfunction step(S, dt) {\n  const L = S.text.letters;\n  S.scroll = max(0, S.scroll - max(S.scroll * (1 - exp(-dt * 7)), dt * 6));\n  if (S.phase === 0) {\n    S.acc += dt * S.rate;\n    while (S.acc >= 1 && S.read \u003c L.length) {\n      S.acc -= 1;\n      const l = L[S.read++];\n      // The slot in the reading line before the scroll moves it.\n      const y0 = READ_Y + S.scroll - 6 * (S.line - l.line);\n      // While there are free columns a new letter takes one as it leaves.\n      if (S.cols.length \u003c SLOTS && !S.cols.includes(l.tok)) {\n        S.cnt[l.tok] = S.cnt[l.tok] || 0;\n        S.cols.push(l.tok);\n        if (S.cx[l.tok] === undefined) S.cx[l.tok] = slotX(S.cols.length - 1);\n      }\n      S.fall.push({ tok: l.tok, x: l.col * 4, x0: l.col * 4, y: y0, y0, t: 0, T: 0 });\n      if (S.read \u003c L.length) feed(S, L[S.read].line, false);\n    }\n    if (S.read >= L.length) S.acc = 0;\n  }\n  for (const f of S.fall) {\n    f.t += dt;\n    if (!f.T) {\n      const i = S.cols.indexOf(f.tok);\n      const top = i >= 0 ? BASE - S.cnt[f.tok] * S.scale - 4 : BASE - 4;\n      const d = max(1, top - f.y0);\n      f.T = (S.vy + sqrt(S.vy * S.vy + 2 * S.g * d)) / S.g;\n    }\n    f.y = f.y0 - S.vy * f.t + 0.5 * S.g * f.t * f.t;\n    const i = S.cols.indexOf(f.tok);\n    f.pi = i \u003c 0;\n    if (!f.pi) {\n      const u = sm(0, 1, f.t / f.T);\n      f.x = f.x0 + (S.cx[f.tok] - f.x0) * u;\n      if (f.y >= BASE - S.cnt[f.tok] * S.scale - 4) f.done = true;\n    } else {\n      f.x0 = f.x;\n      if (f.y >= BASE - 4) f.done = true;\n    }\n  }\n  if (S.fall.some((f) => f.done)) {\n    for (const f of S.fall) if (f.done) land(S, f.tok);\n    S.fall = S.fall.filter((f) => !f.done);\n  }\n  // Columns slide to their slots; the scale follows the tallest.\n  S.cols.forEach((k, i) => {\n    S.cx[k] += (slotX(i) - S.cx[k]) * (1 - exp(-dt * 9));\n  });\n  for (const k in S.flash) S.flash[k] = max(0, S.flash[k] - dt * 3);\n  const target = MAXH / max(floorUnits(S), tallest(S));\n  S.scale += (target - S.scale) * (1 - exp(-dt * 5));\n\n  if (S.phase === 0 && S.read >= L.length && S.fall.length === 0) {\n    // The passage is spent: cast its own order as a line.\n    S.phase = 1;\n    S.pt = 0;\n    const c = S.cols;\n    const s = c.slice(0, 6).join(\"\") + \" \" + c.slice(6, 12).join(\"\");\n    S.galley.push({ s, slug: s.split(\"\").map((ch) => (ch === \" \" ? null : colourOf(S, ch))), li: -1 });\n    S.scroll += 6;\n  } else if (S.phase === 1) {\n    S.pt += dt;\n    if (S.pt > HOLD) {\n      S.phase = 2;\n      S.pt = 0;\n    }\n  } else if (S.phase === 2) {\n    S.pt += dt;\n    S.drain = 1 - sm(0, DRAIN, S.pt);\n    if (S.pt > DRAIN) begin(S, S.next);\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1] === undefined ? 2 : k[1], 0.2, 3);\n  S.rate = 4 * speed;\n  S.g = 150 * (0.6 + 0.2 * speed);\n  S.vy = 18;\n  const tx = cl(round(k[2] || 0), 0, 3);\n  S.keep = round(20 * 32 ** (1 - cl(k[3] === undefined ? 0.06 : k[3], 0, 1)));\n  S.next = tx;\n  if (!S.started) {\n    S.started = true;\n    S.galley = [];\n    S.scroll = 0;\n    S.scale = MAXH / floorUnits(S);\n    begin(S, tx);\n    // Read 28% of the passage (50 to 130 letters) before the first frame,\n    // then run a second and a half so letters are in the air.\n    const L = S.text.letters;\n    const pre = cl(round(0.28 * L.length), 50, 130);\n    for (let i = 0; i \u003c pre; i++) {\n      const l = L[S.read++];\n      if (S.read \u003c L.length) feed(S, L[S.read].line, true);\n      land(S, l.tok);\n    }\n    S.scroll = 0;\n    S.cols.forEach((c, i) => (S.cx[c] = slotX(i)));\n    S.scale = MAXH / max(floorUnits(S), tallest(S));\n    for (const c in S.flash) S.flash[c] = 0;\n    for (let i = 0; i \u003c 45; i++) step(S, 1 / 30);\n  }\n  if (tx !== S.textIdx && S.phase !== 2) {\n    // A new text: the columns drain and the new passage starts from its top.\n    S.phase = 2;\n    S.pt = 0;\n    S.fall = [];\n  }\n  trim(S);\n  step(S, dt);\n}\n\nfunction glyph(display, ch, x0, y0, r, g, b, a) {\n  const bits = BITS[ch];\n  if (!bits || a \u003c= 0.02) return;\n  const R = round(min(255, r * a)), G = round(min(255, g * a)), B = round(min(255, b * a));\n  for (let j = 0; j \u003c 15; j++) {\n    if (!bits[j]) continue;\n    const x = x0 + (j % 3), y = y0 + floor(j / 3);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, R, G, B);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.started) return;\n  const colour = {};\n  const col = (tok) => colour[tok] || (colour[tok] = colourOf(S, tok));\n  const pulse = S.phase === 1 ? 0.8 + 0.2 * sin(S.pt * 5) : 1;\n\n  // Letters with no column fall behind the columns and go out at the floor.\n  for (const f of S.fall) if (f.pi) glyph(display, f.tok, round(f.x), round(f.y), 150, 150, 160, 0.75);\n\n  // The columns: a solid bar with a seam at each letter, or, when a letter\n  // has room, a stack of sorts each showing its letter in the middle.\n  const s = S.scale;\n  const sorts = sm(5, 6.5, s);\n  const face = floor(max(0, s - 6) / 2);\n  for (const tok of S.cols) {\n    const c = col(tok);\n    const x0 = round(S.cx[tok]);\n    const n = S.cnt[tok];\n    const h = n * s * S.drain;\n    const bits = BITS[tok];\n    const fl = S.flash[tok] || 0;\n    for (let r = 0; r \u003c h && r \u003c MAXH + 2; r++) {\n      const y = BASE - r;\n      const cover = min(1, h - r);\n      const unit = floor(r / s), o = r - unit * s;\n      const top = unit >= n - 1;\n      for (let dx = 0; dx \u003c 3; dx++) {\n        const seam = s >= 2.5 && o > s - 1;\n        const solid = seam ? 0.42 : 0.9;\n        const gr = 4 - floor(o - face);\n        const stamp = seam ? 0 : gr >= 0 && gr \u003c 5 ? (bits[gr * 3 + dx] ? 1 : 0.28) : 0.28;\n        const v = (solid + (stamp - solid) * sorts) * cover;\n        if (v \u003c= 0.02) continue;\n        const w = top ? fl * 0.8 : 0;\n        const R = c[0] * v * (1 - w) + 255 * w * cover, G = c[1] * v * (1 - w) + 255 * w * cover, B = c[2] * v * (1 - w) + 255 * w * cover;\n        const x = x0 + dx;\n        if (x >= 0 && x \u003c W) display.setPixel(x, y, round(min(255, R)), round(min(255, G)), round(min(255, B)));\n      }\n    }\n  }\n\n  // Labels under the columns, and under them the Linotype's order. Where a\n  // column's letter stands where the Linotype put it, both light. At the end\n  // of Poe's cryptogram the bottom row turns into the key.\n  const keyRow = S.text.cipher && S.phase > 0;\n  S.cols.forEach((tok) => {\n    const c = col(tok);\n    const x = round(S.cx[tok]);\n    glyph(display, tok, x, LABEL_Y, c[0], c[1], c[2], pulse * S.drain);\n  });\n  for (let i = 0; i \u003c SLOTS; i++) {\n    const tok = S.cols[i];\n    const settled = tok !== undefined && abs(S.cx[tok] - slotX(i)) \u003c 0.6;\n    const match = settled && S.keyOf[tok] === LINO[i];\n    if (keyRow) {\n      if (tok === undefined) continue;\n      const c = col(tok);\n      glyph(display, S.keyOf[tok], round(S.cx[tok]), REF_Y, c[0], c[1], c[2], (match ? 1 : 0.55) * S.drain);\n    } else if (match) {\n      const c = col(tok);\n      glyph(display, LINO[i], slotX(i), REF_Y, 0.5 * c[0] + 128, 0.5 * c[1] + 128, 0.5 * c[2] + 128, S.drain);\n    } else glyph(display, LINO[i], slotX(i), REF_Y, 84, 80, 92, 1);\n  }\n\n  // The galley: what has been read is dim, the rest of the reading line is\n  // lit and the next letter to come loose shows its colour. A cast order\n  // line keeps its colours.\n  const G = S.galley;\n  const L = S.text.letters;\n  const next = S.phase === 0 && S.read \u003c L.length ? L[S.read] : null;\n  for (let j = 0; j \u003c G.length && j \u003c LINES + 1; j++) {\n    const ln = G[G.length - 1 - j];\n    const y = READ_Y - 6 * j + round(S.scroll);\n    if (y \u003c -5 || y > READ_Y + 6) continue;\n    const live = ln.li >= 0 && ln.li === S.line && j === 0 && S.phase === 0;\n    for (let c = 0; c \u003c ln.s.length; c++) {\n      const ch = ln.s[c];\n      if (ch === \" \") continue;\n      if (ln.slug) {\n        const cc = ln.slug[c];\n        const a = j === 0 ? pulse : 0.45;\n        glyph(display, ch, c * 4, y, cc[0], cc[1], cc[2], a);\n      } else if (live && next && c === next.col) {\n        const cc = col(ch);\n        glyph(display, ch, c * 4, y, 0.4 * cc[0] + 150, 0.4 * cc[1] + 150, 0.4 * cc[2] + 150, 1);\n      } else if (live && next && c > next.col) glyph(display, ch, c * 4, y, 236, 224, 202, 1);\n      else glyph(display, ch, c * 4, y, 236, 224, 202, 0.33);\n    }\n  }\n\n  // Letters in the air, white as they leave the line and their colour as they fall.\n  for (const f of S.fall) {\n    if (f.pi) continue;\n    const c = col(f.tok);\n    const w = max(0, 1 - f.t / 0.35);\n    glyph(display, f.tok, round(f.x), round(f.y), c[0] + (255 - c[0]) * w, c[1] + (255 - c[1]) * w, c[2] + (255 - c[2]) * w, 1);\n  }\n}\n","golomb-ruler":"// ===== Patternflow pattern =====\n// Title:   Golomb Ruler\n// Family:  number\n// Idea:    A ruler runs down the panel with a mark on some of its 128 rows, every pair of marks is joined by an arc as tall as the distance it measures, and a caliper sweeps the lengths 1 to 127, lighting the arcs of each length and ticking a length scale on the right edge, so the optimal 14-mark Golomb ruler lights one arc or none at each length and Wichmann's ruler lights at least one, with the sevens piling up.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sidon sets (Simon Sidon, 1932) and Golomb rulers (W. C. Babcock's radio channels, 1953; named for Solomon W. Golomb), sparse rulers (Brian Wichmann, 1963), the greedy Sidon sequence (Abdul Majid Mian and Sarvadaman Chowla, 1944), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ruler=0..3, Shape=-1..1\n//\n// Knob 1: Hue. Turns the length colours round the wheel: at 0 the short arcs are sea green and the long ones run through blue and violet to rose; at 0.5 they run from rose through yellow to green.\n// Knob 2: Speed. How fast the caliper measures: 16 lengths a second at 2, so a sweep of 1 to 127 takes 8 s, then the whole picture holds 1.5 s and fades back to its ghost in 1 s. At 0.2 a sweep takes 80 s, at 3 it takes 5.3 s.\n// Knob 3: Ruler. Which marks: 0 the optimal Golomb ruler, 14 marks on 0..127 whose 91 arcs measure every length from 1 to 55 once and 36 longer ones never; 1 Mian and Chowla's greedy Sidon set, 12 marks on 0..122 whose 66 arcs already miss 22; 2 fourteen random marks with both ends, drawn anew each sweep, which on average measure 66 lengths and repeat 20 of them; 3 Wichmann's ruler W(1,16), 23 marks whose 253 arcs measure every length, 7 sixteen times, 14 fifteen times and so on down the multiples of 7.\n// Knob 4: Shape. The outline of every arc, a half superellipse: straight chevrons at -1, where the arcs from one mark run along one ray and the picture turns into a lattice of crossing rays; half ellipses near the opening 0.06; square brackets like the dimension lines of a drawing at 1.\n\nconst W = 64, H = 128, L = 127;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, exp, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The optimal Golomb ruler with 14 marks: its 91 differences are all\n// different and 127 is the shortest length that holds 14 such marks.\nconst GOLOMB = [0, 4, 6, 20, 35, 52, 59, 77, 78, 86, 89, 99, 122, 127];\n\n// Mian and Chowla's greedy Sidon sequence 1, 2, 4, 8, 13, ...: each term the\n// least number that keeps all pairwise sums (so all differences) distinct.\n// Shifted to start at 0, twelve terms fit, up to 122.\nfunction mianChowla() {\n  const T = [1], sums = new Set([2]);\n  for (let k = 2; k - 1 \u003c= L; k++) {\n    let ok = !sums.has(2 * k);\n    for (const a of T) if (sums.has(k + a)) ok = false;\n    if (!ok) continue;\n    for (const a of T) sums.add(k + a);\n    sums.add(2 * k);\n    T.push(k);\n  }\n  return T.map((a) => a - 1);\n}\n\n// Wichmann's ruler W(r, s): steps 1 (r times), r+1, 2r+1 (r times),\n// 4r+3 (s times), 2r+2 (r+1 times), 1 (r times). Length\n// 4r(r+s+2)+3(s+1) with 4r+s+3 marks; W(1,16) is 127 long with 23.\nfunction wichmann(r, s) {\n  const steps = [];\n  const put = (v, n) => { for (let i = 0; i \u003c n; i++) steps.push(v); };\n  put(1, r), put(r + 1, 1), put(2 * r + 1, r), put(4 * r + 3, s), put(2 * r + 2, r + 1), put(1, r);\n  const m = [0];\n  for (const v of steps) m.push(m[m.length - 1] + v);\n  return m;\n}\n\n// Fourteen random marks on 0..127, the ends always among them.\nfunction randomRuler() {\n  const set = new Set([0, L]);\n  while (set.size \u003c 14) set.add(1 + floor(Math.random() * (L - 1)));\n  return [...set].sort((a, b) => a - b);\n}\n\nconst RULERS = [() => GOLOMB, mianChowla, randomRuler, () => wichmann(1, 16)];\n\n// Geometry. The spine stands at x = X0; an arc for the marks a \u003c b leaves\n// the spine at rows a and b and bulges right to X0 + A, A in proportion to\n// b - a, so the 127-row arc reaches column X0 + AMAX. The length scale is\n// the right edge: row d is the length d.\nconst X0 = 1.5, AMAX = 52.5, SX = 63;\n\n// Superellipse exponent from the Shape knob: 1 chevron, 2 ellipse, 8 bracket.\nconst expo = (k) => (k \u003c 0 ? pow(2, 1 + k) : pow(2, 1 + 2 * k));\n\n// One arc's light as a list of pixels and weights: the half superellipse\n// sampled along its angle, each piece of the polyline cut into steps of at\n// most 0.4 LED and splatted bilinearly with its length as weight. Each arc\n// owns a slot of cap entries in the shared arrays.\nconst TMP = new Float32Array(W * H), TOUCH = new Int32Array(W * H);\nconst cap = (d) => 104 + 12 * d;\nfunction arcPixels(S, i, p) {\n  const [a, b, d] = S.pairs[i], A = (AMAX * d) / L, B = d / 2, c = (a + b) / 2, e = 2 / p;\n  const n = 24 + 2 * ceil(A + B), at = S.off[i], room = cap(d), I = S.I, Wt = S.Wt;\n  let nt = 0, px = X0, py = a;\n  const splat = (x, y, w) => {\n    const i = floor(x), j = floor(y), fx = x - i, fy = y - j;\n    for (let q = 0; q \u003c 4; q++) {\n      const ii = i + (q & 1), jj = j + (q >> 1);\n      if (ii \u003c 0 || ii >= W || jj \u003c 0 || jj >= H) continue;\n      const ww = w * (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy);\n      if (ww \u003c= 0) continue;\n      const k = jj * W + ii;\n      if (TMP[k] === 0) {\n        if (nt >= room) continue;\n        TOUCH[nt++] = k;\n      }\n      TMP[k] += ww;\n    }\n  };\n  for (let s = 1; s \u003c= n; s++) {\n    const th = -PI / 2 + (PI * s) / n, cs = max(0, cos(th)), sn = sin(th);\n    const x = X0 + A * pow(cs, e), y = c + B * (sn \u003c 0 ? -pow(-sn, e) : pow(sn, e));\n    const len = sqrt((x - px) * (x - px) + (y - py) * (y - py)), k = max(1, ceil(len / 0.4));\n    for (let u = 0; u \u003c k; u++) {\n      const f = (u + 0.5) / k;\n      splat(px + (x - px) * f, py + (y - py) * f, len / k);\n    }\n    px = x, py = y;\n  }\n  for (let q = 0; q \u003c nt; q++) {\n    const k = TOUCH[q];\n    I[at + q] = k, Wt[at + q] = min(1.4, TMP[k]);\n    TMP[k] = 0;\n  }\n  S.np[i] = nt;\n}\n\n// Marks, pairs (shortest first) and how many pairs measure each length. The\n// arcs are drawn over the next few frames, shortest first.\nfunction useRuler(S, which, p) {\n  S.which = which;\n  const m = RULERS[which]();\n  const P = [];\n  for (let i = 0; i \u003c m.length; i++) for (let j = i + 1; j \u003c m.length; j++) P.push([m[i], m[j], m[j] - m[i]]);\n  P.sort((u, v) => u[2] - v[2]);\n  const cnt = new Int32Array(L + 1);\n  for (const q of P) cnt[q[2]]++;\n  S.marks = m, S.pairs = P, S.cnt = cnt;\n  // Denser rulers draw each arc fainter so 253 arcs do not burn to white.\n  S.gain = min(1, pow(91 / P.length, 0.75));\n  S.tm = new Float64Array(P.length).fill(-1);\n  const off = new Int32Array(P.length + 1);\n  for (let i = 0; i \u003c P.length; i++) off[i + 1] = off[i] + cap(P[i][2]);\n  S.off = off, S.np = new Int32Array(P.length);\n  S.I = new Int32Array(off[P.length]), S.Wt = new Float32Array(off[P.length]);\n  S.geoP = p, S.redo = 0;\n}\n\nfunction restart(S) {\n  S.d = 0, S.phase = 0, S.pt = 0;\n  S.tm.fill(-1);\n  S.next = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, which: -1, shape: 0.06, d: 0, phase: 0, pt: 0, next: 0,\n    acc: new Float32Array(W * H * 3), mf: new Float32Array(L + 1), c: [0, 0, 0],\n  });\n  useRuler(S, 0, expo(0.06));\n  restart(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.shape = cl(k[3], -1, 1);\n  const which = cl(round(k[2]), 0, 3), p = expo(S.shape);\n  if (which !== S.which) useRuler(S, which, p), restart(S);\n  // When the shape has moved by a visible amount the arcs are drawn again,\n  // shortest first and a share each frame, so the new outline spreads out\n  // from the spine over a few frames instead of costing one long frame. A\n  // pass runs to the end before the next one starts.\n  if (S.redo >= S.pairs.length && abs(p - S.geoP) / p > 0.02) (S.geoP = p), (S.redo = 0);\n  for (let budget = 1800; S.redo \u003c S.pairs.length && budget > 0; S.redo++) {\n    arcPixels(S, S.redo, p);\n    budget -= 20 + S.pairs[S.redo][2];\n  }\n  // Sweep: the caliper opens from 0 to 127, then the picture holds and fades.\n  if (S.phase === 0) {\n    S.d += 8 * S.speed * d;\n    const P = S.pairs;\n    while (S.next \u003c P.length && P[S.next][2] \u003c= S.d) S.tm[S.next++] = S.t;\n    if (S.d >= L + 1) (S.phase = 1), (S.pt = 0);\n  } else {\n    S.pt += d * (0.5 + S.speed / 4);\n    if (S.pt > 2.5) {\n      if (S.which === 2) useRuler(S, 2, S.geoP);\n      restart(S);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.I) return;\n  const acc = S.acc, c = S.c, P = S.pairs, I = S.I, Wt = S.Wt, off = S.off, np = S.np, t = S.t;\n  acc.fill(0);\n  const h0 = 0.44 + S.hue;\n  // Measured arcs hold their colour; after the hold they fade to the ghost.\n  const fade = S.phase === 1 ? cl((S.pt - 1.5) / 1, 0, 1) : 0;\n  const ghost = 0.16, mf = S.mf;\n  mf.fill(0);\n  for (let i = 0; i \u003c P.length; i++) {\n    const dd = P[i][2], tm = S.tm[i];\n    let e = ghost, flash = 0;\n    if (tm >= 0) {\n      e = 1 - (1 - ghost) * fade;\n      flash = exp(-(t - tm) / 0.2);\n      mf[P[i][0]] = max(mf[P[i][0]], flash), mf[P[i][1]] = max(mf[P[i][1]], flash);\n    }\n    hsv(h0 + 0.46 * (dd / L), 0.8 - 0.6 * flash, 1, c);\n    const gn = S.gain * e, r = c[0] * gn + flash, g = c[1] * gn + flash, b = c[2] * gn + flash;\n    for (let q = off[i], qe = off[i] + np[i]; q \u003c qe; q++) {\n      const k = I[q] * 3, w = Wt[q];\n      acc[k] += r * w, acc[k + 1] += g * w, acc[k + 2] += b * w;\n    }\n  }\n  // The caliper's jaw: a faint vertical line where arcs of the current\n  // length touch it with their tips.\n  if (S.phase === 0) {\n    const xj = X0 + (AMAX * S.d) / L, i = floor(xj), f = xj - i;\n    for (let y = 0; y \u003c H; y++) {\n      if (i >= 0 && i \u003c W) acc[(y * W + i) * 3 + 2] += 0.12 * (1 - f), acc[(y * W + i) * 3] += 0.06 * (1 - f), acc[(y * W + i) * 3 + 1] += 0.06 * (1 - f);\n      if (i + 1 \u003c W) acc[(y * W + i + 1) * 3 + 2] += 0.12 * f, acc[(y * W + i + 1) * 3] += 0.06 * f, acc[(y * W + i + 1) * 3 + 1] += 0.06 * f;\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const k = (y * W + x) * 3;\n      display.setPixel(x, y, (255 * (1 - exp(-1.5 * acc[k]))) | 0, (255 * (1 - exp(-1.5 * acc[k + 1]))) | 0, (255 * (1 - exp(-1.5 * acc[k + 2]))) | 0);\n    }\n  // The spine and its marks.\n  for (let y = 0; y \u003c H; y++) display.setPixel(0, y, 40, 40, 48);\n  // A mark burns white while an arc from it is being measured.\n  for (const m of S.marks) {\n    const f = mf[m], v = (170 + 85 * f) | 0;\n    display.setPixel(0, m, 255, 250, 240);\n    display.setPixel(1, m, v, v - 5, v - 15);\n    if (f > 0.05) display.setPixel(2, m, (255 * f) | 0, (255 * f) | 0, (255 * f) | 0);\n  }\n  // The length scale: row d ticks once measured, 2 + n LEDs long when n\n  // pairs share the length, white for a moment as the caliper passes; a\n  // length nobody measures blinks dark red and stays a gap. Rows the\n  // caliper has not reached keep a faint dot.\n  const cur = S.phase === 0 ? floor(S.d) : L + 1, rate = 8 * S.speed;\n  for (let dd = 1; dd \u003c= L; dd++) {\n    const n = S.cnt[dd], since = S.phase === 0 ? (S.d - dd) / rate : 9;\n    if (dd > cur) {\n      display.setPixel(SX, dd, 34, 34, 40);\n      continue;\n    }\n    if (n === 0) {\n      const b = exp(-since / 0.5);\n      if (b > 0.1) display.setPixel(SX, dd, (200 * b) | 0, (30 * b) | 0, (40 * b) | 0);\n      continue;\n    }\n    const fl = exp(-since / 0.25);\n    hsv(h0 + 0.46 * (dd / L), 0.7 * (1 - fl), 1 - 0.6 * fade, c);\n    const len = 2 + n;\n    for (let x = SX; x > SX - len; x--) display.setPixel(x, dd, (c[0] * 255) | 0, (c[1] * 255) | 0, (c[2] * 255) | 0);\n  }\n  if (S.phase === 0) {\n    display.setPixel(SX, cur, 255, 255, 255);\n    display.setPixel(SX - 1, cur, 255, 255, 255);\n  }\n}\n","gridfonts":"// ===== Patternflow pattern =====\n// Title:   Gridfonts\n// Family:  type\n// Idea:    Three lines of three lowercase letters are built only from short strokes joining neighbouring points of a faint 3 by 7 dot grid, as in Douglas Hofstadter's gridfonts, and when the style changes every letter on the panel takes back and draws in its strokes by the same rule at once, cutting its corners, raising gables, opening stencil gaps or turning to outline.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: gridfonts and the Letter Spirit project (Douglas Hofstadter, 1980s; Gary McGraw's thesis, 1995; Hofstadter and the Fluid Analogies Research Group, Fluid Concepts and Creative Analogies, 1995), letters and styles drawn for this pattern, pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Style=0..6, Grid=0..1\n//\n// Knob 1: Hue. Turns the letters round the wheel from sea green at 0; each style keeps its own small step off that colour.\n// Knob 2: Speed. How fast strokes draw and the pages turn: at 2 something changes every 4 seconds, at 0.2 every 40.\n// Knob 3: Style. At 0 the six styles take turns: one change puts a new style on the same words, the next brings new words in that style. 1 to 6 hold one style while the words change: Square, Cut, Lean, Gable, Stencil, Outline.\n// Knob 4: Grid. What shows of the grid under the letters: only its points at 0, brighter up to 0.33, and from 0.1 upward, more and more, all 56 quanta of each letter's cell, the strokes every letter could have used.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The grid of one letter: 3 points across and 7 down, point p = 3 * row +\n// column with row 0 at the top. Rows 2 to 4 are the central zone, from the\n// x-height down to the baseline; rows 0 and 1 hold ascenders, 5 and 6\n// descenders.\nconst GC = 3, GR = 7, GP = GC * GR;\n// A quantum joins two points that are neighbours across, down or on a\n// diagonal. Counted here: 14 across, 18 down and 24 diagonals, 56 in all.\nconst QA = [], QB = [];\nconst QID = new Int8Array(GP * GP).fill(-1);\nfor (let p = 0; p \u003c GP; p++)\n  for (let q = p + 1; q \u003c GP; q++)\n    if (max(abs((q % GC) - (p % GC)), abs(floor(q / GC) - floor(p / GC))) === 1) {\n      QID[p * GP + q] = QID[q * GP + p] = QA.length;\n      QA.push(p);\n      QB.push(q);\n    }\nconst NQ = QA.length;\n\n// The panel: points 7 LEDs apart, three letters a line with an empty square\n// between letters, so the points of all nine letters fall on one lattice of\n// 9 by 19 points. Lines share a row of points: one line's descender row is\n// the next line's ascender row, and the pages are chosen so that no\n// descender meets an ascender there.\nconst SQ = 7, X0 = 3, PITCH = 3 * SQ, LINE = 6 * SQ, CELLS = 9;\n\n// The base face, written as pen paths. Each pair of digits is a point,\n// column then row, and the pen goes straight from one to the next, so one\n// step of a path may run over two quanta in a line.\nconst BASE = {\n  a: \"022224040323\",\n  b: \"0004242202\",\n  c: \"22020424\",\n  d: \"2024040222\",\n  e: \"032322020424\",\n  f: \"201014 0222\",\n  g: \"240402222606\",\n  h: \"0004 022224\",\n  i: \"1214 1011\",\n  j: \"121606 1011\",\n  k: \"0004 221303 1324\",\n  l: \"1014\",\n  m: \"04022224 1214\",\n  n: \"04022224\",\n  o: \"0222240402\",\n  p: \"0602222404\",\n  q: \"2622020424\",\n  r: \"040222\",\n  s: \"220203232404\",\n  t: \"1114 0222 1424\",\n  u: \"02042422\",\n  v: \"0203142322\",\n  w: \"0204132422\",\n  x: \"0224 2204\",\n  y: \"020424 222606\",\n  z: \"02220424\",\n};\n\n// A path string to directed quanta [from point, to point] in pen order.\nfunction parse(src) {\n  const out = [];\n  for (const path of src.split(\" \"))\n    for (let i = 2; i + 1 \u003c path.length; i += 2) {\n      let c = +path[i - 2], r = +path[i - 1];\n      const c1 = +path[i], r1 = +path[i + 1];\n      const sc = Math.sign(c1 - c), sr = Math.sign(r1 - r);\n      for (let n = max(abs(c1 - c), abs(r1 - r)); n > 0; n--) {\n        out.push([r * GC + c, (r + sr) * GC + c + sc]);\n        c += sc;\n        r += sr;\n      }\n    }\n  return out;\n}\n\nconst col = (p) => p % GC, row = (p) => floor(p / GC);\nconst other = (s, p) => (s[0] === p ? s[1] : s[0]);\n\n// Style rules. Each takes a letter's directed quanta and gives new ones, the\n// same rule for every letter, which is what Hofstadter meant by a gridfont\n// having one spirit.\n\n// Cut corners. Where exactly two quanta meet at a point, one across and one\n// down, both go and the diagonal across the corner takes their place. The\n// mask says which corners of a box: 1 top left, 2 top right, 4 bottom left,\n// 8 bottom right. A quantum is used by one corner at most.\nfunction cut(list, mask) {\n  const at = Array.from({ length: GP }, () => []);\n  list.forEach((s, i) => (at[s[0]].push(i), at[s[1]].push(i)));\n  const out = list.slice(), gone = new Uint8Array(list.length);\n  list.forEach((s, i) => {\n    for (const p of [s[1], s[0]]) {\n      if (gone[i] || at[p].length !== 2) continue;\n      const j = at[p][0] === i ? at[p][1] : at[p][0];\n      if (gone[j]) continue;\n      const a = other(s, p), b = other(list[j], p);\n      const horiz = (q) => row(q) === row(p), vert = (q) => col(q) === col(p);\n      let hq, vq;\n      if (horiz(a) && vert(b)) (hq = a), (vq = b);\n      else if (vert(a) && horiz(b)) (hq = b), (vq = a);\n      else continue;\n      const east = col(hq) > col(p), south = row(vq) > row(p);\n      const bit = east ? (south ? 1 : 4) : south ? 2 : 8;\n      if (!(mask & bit)) continue;\n      out[i] = s[1] === p ? [a, b] : [b, a];\n      gone[i] = gone[j] = 1;\n      out[j] = null;\n    }\n  });\n  return out.filter(Boolean);\n}\n\n// Gables. A full bar at the x-height whose both ends go on down becomes a\n// roof peaked one square higher; a full bar on the baseline whose both ends\n// come up becomes a keel one square lower. A stroke that met the middle of\n// the bar is carried on to the peak or the keel.\nfunction gable(list) {\n  const out = list.map((s) => s.slice());\n  const has = (a, b) => out.findIndex((s) => (s[0] === a && s[1] === b) || (s[0] === b && s[1] === a));\n  const goes = (p, dr) => out.some((s) => (s[0] === p || s[1] === p) && row(other(s, p)) === row(p) + dr);\n  for (const [r, dr] of [[2, 1], [4, -1]]) {\n    const L = r * GC, M = L + 1, R = L + 2, apex = M - dr * GC;\n    const i = has(L, M), j = has(M, R);\n    if (i \u003c 0 || j \u003c 0 || !goes(L, dr) || !goes(R, dr)) continue;\n    const meets = out.some((s, k) => k !== i && k !== j && (s[0] === M || s[1] === M));\n    out[i] = out[i].map((p) => (p === M ? apex : p));\n    out[j] = out[j].map((p) => (p === M ? apex : p));\n    if (meets) out.push(dr > 0 ? [apex, M] : [M, apex]);\n  }\n  return out;\n}\n\n// Six styles. cut is a corner mask for cut(), gable says gable() runs, gap\n// opens every quantum away from the points it joins so each one stands\n// alone as in a stencil, ring draws a stroke as its outline, and hue is the\n// style's step off the Hue knob.\nconst STYLES = [\n  { name: \"Square\", hue: 0, cut: 0, gable: 0, gap: 0, ring: 0 },\n  { name: \"Cut\", hue: 0.06, cut: 15, gable: 0, gap: 0, ring: 0 },\n  { name: \"Lean\", hue: -0.06, cut: 1 | 8, gable: 0, gap: 0, ring: 0 },\n  { name: \"Gable\", hue: 0.12, cut: 0, gable: 1, gap: 0, ring: 0 },\n  { name: \"Stencil\", hue: -0.12, cut: 0, gable: 0, gap: 1, ring: 0 },\n  { name: \"Outline\", hue: 0.18, cut: 0, gable: 0, gap: 0, ring: 1 },\n];\nconst NS = STYLES.length;\n\nconst idOf = (s) => QID[s[0] * GP + s[1]];\nconst keyOf = (l) => l.map(idOf).sort((a, b) => a - b).join();\nconst bits = (m) => (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1);\n\n// Every letter in every style, as directed quanta with no quantum twice.\nconst FACES = STYLES.map((st) => {\n  const make = (ch, mask) => {\n    let l = parse(BASE[ch]);\n    if (mask) l = cut(l, mask);\n    if (st.gable) l = gable(l);\n    const seen = new Uint8Array(NQ);\n    return l.filter((s) => {\n      const id = idOf(s);\n      if (id \u003c 0 || seen[id]) return false;\n      return (seen[id] = 1);\n    });\n  };\n  const face = {};\n  for (const ch in BASE) face[ch] = make(ch, st.cut);\n  // The letter comes before the style. Cut makes u the same quanta as v, so\n  // a letter the rule turns into another letter backs off, cutting as many\n  // of its corners as it can and still be itself.\n  const clash = (ch) => Object.keys(face).some((o) => o !== ch && keyOf(face[o]) === keyOf(face[ch]));\n  for (const ch in BASE) {\n    if (!st.cut || !clash(ch) || keyOf(face[ch]) === keyOf(parse(BASE[ch]))) continue;\n    const masks = [];\n    for (let m = st.cut - 1; m >= 0; m--) if ((m & st.cut) === m) masks.push(m);\n    masks.sort((a, b) => bits(b) - bits(a));\n    for (const m of masks) if (((face[ch] = make(ch, m)), !clash(ch))) break;\n  }\n  return face;\n});\n\n// Pages of three three-letter lines. Three of them are the alphabet, a to\n// z, the way a gridfont is shown.\nconst PAGES = [\"the\", \"sly\", \"fox\", \"abc\", \"def\", \"ghi\", \"web\", \"zig\", \"zag\", \"jkl\", \"mno\", \"pqr\", \"sea\", \"and\", \"sky\", \"stu\", \"vwx\", \"yz \", \"art\", \"for\", \"all\"]\n  .join(\"\")\n  .match(/.{9}/g);\n\n// Timing in seconds at Speed 2: a change every BEAT; quanta that leave take\n// back over BACK, those that come draw over DRAW one STEP apart in pen order,\n// after the leaving is done; each letter starts LAG after the one before.\nconst BEAT = 4, BACK = 0.3, DRAW = 0.2, STEP = 0.09, LAG = 0.06, CLEAR = 0.4;\n\n// Stroke profile against distance from the stroke's middle line, 64 steps\n// a LED: a 1 LED core, a shoulder to 1.25 LEDs and a glow that dies by 3.5.\nconst PROF = new Float32Array(256);\nfor (let k = 0; k \u003c 256; k++) {\n  const d = k / 64;\n  PROF[k] = d \u003c 0.55 ? 1 : d \u003c 1.25 ? 1 - ((d - 0.55) / 0.7) * 0.55 : 0.45 * exp(-(d - 1.25) * 1.35);\n}\nconst REACH = 3.5;\n// The outline style lights the edge of a stroke this far out.\nconst RING = 2.1;\n\nexport function setup(params) {\n  // The lattice points, and every quantum of every cell as a one-LED line.\n  const dot = new Uint8Array(N), mesh = new Uint8Array(N);\n  for (let gy = 0; gy \u003c= 18; gy++) for (let gx = 0; gx \u003c 9; gx++) dot[gy * SQ * W + X0 + gx * SQ] = 1;\n  for (let c = 0; c \u003c CELLS; c++) {\n    const ox = X0 + (c % 3) * PITCH, oy = floor(c / 3) * LINE;\n    for (let id = 0; id \u003c NQ; id++) {\n      const ax = ox + col(QA[id]) * SQ, ay = oy + row(QA[id]) * SQ;\n      const sx = col(QB[id]) - col(QA[id]), sy = row(QB[id]) - row(QA[id]);\n      for (let k = 1; k \u003c SQ; k++) {\n        const x = ax + sx * k, y = ay + sy * k;\n        if (y \u003c H) mesh[y * W + x] = 1;\n      }\n    }\n  }\n  const Q = CELLS * NQ;\n  params.s = {\n    dot, mesh, D: new Float32Array(N), B: new Float32Array(N), Wh: new Float32Array(N),\n    kind: new Uint8Array(Q), t0: new Float32Array(Q), dir: new Uint8Array(Q), ord: new Uint8Array(Q),\n    T: 0, next: BEAT, page: 0, style: 0, knob: -1, flip: 0, ready: false,\n    from: STYLES[0], to: STYLES[0], styleT: -9, hue: 0, grid: 0.06,\n  };\n}\n\n// Send the current page in the current style to the cells. Quanta the old\n// and the new letter share stay lit; the rest take back or draw in. kind is\n// 0 dark, 1 drawing or drawn, 2 taking back.\nfunction show(S, first) {\n  const text = PAGES[S.page], face = FACES[S.style];\n  const want = new Int16Array(NQ);\n  for (let c = 0; c \u003c CELLS; c++) {\n    want.fill(-1);\n    const list = face[text[c]] || [];\n    list.forEach((s, j) => (want[idOf(s)] = j));\n    for (let id = 0; id \u003c NQ; id++) {\n      const k = c * NQ + id;\n      if (S.kind[k] !== 1 || want[id] >= 0) continue;\n      // One that has not begun to draw just never comes.\n      if (S.t0[k] > S.T) S.kind[k] = 0;\n      else (S.kind[k] = 2), (S.t0[k] = S.T + c * LAG);\n    }\n    let n = 0;\n    const start = S.T + c * LAG + (first ? 0 : CLEAR);\n    list.forEach((s, j) => {\n      const id = idOf(s), k = c * NQ + id;\n      S.dir[k] = s[0] === QA[id] ? 0 : 1;\n      S.ord[k] = j;\n      if (S.kind[k] === 1) return;\n      S.kind[k] = 1;\n      S.t0[k] = start + n++ * STEP;\n    });\n  }\n}\n\nconst blend = (S) => {\n  const e = smooth((S.T - S.styleT) / 0.9), f = S.from, t = S.to;\n  return { hue: f.hue + (t.hue - f.hue) * e, gap: f.gap + (t.gap - f.gap) * e, ring: f.ring + (t.ring - f.ring) * e };\n};\n\nfunction restyle(S, style) {\n  // The blend starts from wherever the last one had got to.\n  S.from = blend(S);\n  S.to = STYLES[style];\n  S.style = style;\n  S.styleT = S.T;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.grid = cl(k[3], 0, 1);\n  const want = cl(round(k[2]), 0, NS);\n  if (!S.ready) {\n    S.ready = true;\n    S.knob = want;\n    S.style = want > 0 ? want - 1 : 0;\n    S.from = S.to = STYLES[S.style];\n    show(S, true);\n  } else if (want !== S.knob) {\n    S.knob = want;\n    if (want > 0 && want - 1 !== S.style) {\n      restyle(S, want - 1);\n      show(S, false);\n    }\n  }\n  S.T += (dt * cl(k[1], 0.05, 3)) / 2;\n  while (S.T >= S.next) {\n    S.next += BEAT;\n    // Held: new words each beat. Taking turns: a new style on the same\n    // words, then new words in that style.\n    if (S.knob === 0 && (S.flip ^= 1)) restyle(S, (S.style + 1) % NS);\n    else S.page = (S.page + 1) % PAGES.length;\n    show(S, false);\n  }\n}\n\n// One stroke from (x0, y0) to (x1, y1), its pen position running s0 to s1.\n// Each LED keeps the distance to the nearest stroke (so the outline of\n// strokes that meet is one outline) and how near that stroke's stretch is\n// to the light running along the pen path at P.\nfunction stroke(S, x0, y0, x1, y1, s0, s1, P, fade) {\n  const { D, B } = S;\n  const bx0 = max(0, floor(min(x0, x1) - REACH)), bx1 = min(W - 1, ceil(max(x0, x1) + REACH));\n  const by0 = max(0, floor(min(y0, y1) - REACH)), by1 = min(H - 1, ceil(max(y0, y1) + REACH));\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-6;\n  for (let y = by0; y \u003c= by1; y++)\n    for (let x = bx0; x \u003c= bx1; x++) {\n      const t = cl(((x - x0) * dx + (y - y0) * dy) / L2, 0, 1);\n      const ex = x - x0 - t * dx, ey = y - y0 - t * dy;\n      const d = sqrt(ex * ex + ey * ey) + fade, p = y * W + x;\n      if (d >= D[p]) continue;\n      D[p] = d;\n      const u = s0 + (s1 - s0) * t - P;\n      B[p] = u * u \u003c 9 ? exp(-u * u * 1.2) : 0;\n    }\n}\n\n// The pen's head while a quantum draws: a small white spark.\nfunction spark(Wh, x, y, lv) {\n  for (let yy = max(0, floor(y - 2)); yy \u003c= min(H - 1, ceil(y + 2)); yy++)\n    for (let xx = max(0, floor(x - 2)); xx \u003c= min(W - 1, ceil(x + 2)); xx++) {\n      const d2 = (xx - x) * (xx - x) + (yy - y) * (yy - y);\n      const v = lv * exp(-d2 / 1.1), p = yy * W + xx;\n      if (v > Wh[p]) Wh[p] = v;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.ready) return;\n  const { D, B, Wh, kind, t0, dir, ord, T } = S;\n  D.fill(REACH);\n  B.fill(0);\n  Wh.fill(0);\n  const { hue, gap, ring } = blend(S);\n  for (let c = 0; c \u003c CELLS; c++) {\n    const ox = X0 + (c % 3) * PITCH, oy = floor(c / 3) * LINE;\n    // A light runs along each letter's pen path, a quantum in 0.3 s, the\n    // letters a little apart in reading order.\n    const P = ((T - c * 0.23) * 3.3) % 18 - 2;\n    for (let id = 0; id \u003c NQ; id++) {\n      const k = c * NQ + id, kd = kind[k];\n      if (!kd) continue;\n      const tt = T - t0[k];\n      let u0 = 0, u1 = 1, fade = 0, head = 0;\n      if (kd === 1) {\n        const p = tt / DRAW;\n        if (p \u003c= 0) continue;\n        if (p \u003c 1) (u1 = p), (head = 1 - p * 0.5);\n      } else {\n        const q = tt / BACK;\n        if (q >= 1) continue;\n        if (q > 0) (u0 = q), (fade = 1.2 * q);\n      }\n      let a = QA[id], b = QB[id];\n      if (dir[k]) [a, b] = [b, a];\n      const ax = ox + col(a) * SQ, ay = oy + row(a) * SQ;\n      const dx = (col(b) - col(a)) * SQ, dy = (row(b) - row(a)) * SQ;\n      // Stencil: pull both ends back from the points.\n      const g = (gap * 1.8) / sqrt(dx * dx + dy * dy);\n      u0 = max(u0, g);\n      u1 = min(u1, 1 - g);\n      if (u1 \u003c= u0) continue;\n      const o = ord[k];\n      stroke(S, ax + dx * u0, ay + dy * u0, ax + dx * u1, ay + dy * u1, o + u0, o + u1, P, fade);\n      if (head > 0) spark(Wh, ax + dx * u1, ay + dy * u1, head);\n    }\n  }\n  const [lr, lg, lb] = hsv(0.42 + S.hue + hue, 0.72, 1);\n  const [gr, gg, gb] = hsv(0.36 + S.hue + hue, 0.35, 1);\n  const G = S.grid;\n  const dotL = 44 + 60 * min(1, G * 3), meshL = 78 * max(0, (G - 0.08) / 0.92);\n  const rc = RING * ring;\n  const { dot, mesh } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const d = D[p];\n    let v = 0, w = Wh[p];\n    if (d \u003c REACH) {\n      const k = (abs(d - rc) * 64) | 0;\n      v = k \u003c 256 ? PROF[k] : 0;\n      const b = B[p];\n      w += 0.3 * b * v;\n      v *= 0.7 + 0.3 * b;\n    }\n    const base = (dot[p] ? dotL : mesh[p] ? meshL : 0) * (1 - v);\n    // The middle of a lit stroke runs a little toward white.\n    const hot = v > 0.75 ? (v - 0.75) * 1.2 : 0;\n    display.setPixel(\n      p % W,\n      (p / W) | 0,\n      min(255, 255 * (lr * v + (1 - lr) * hot + w) + gr * base),\n      min(255, 255 * (lg * v + (1 - lg) * hot + w) + gg * base),\n      min(255, 255 * (lb * v + (1 - lb) * hot + w) + gb * base),\n    );\n  }\n}\n","hodograph":"// ===== Patternflow pattern =====\n// Title:   Hodograph\n// Family:  physics\n// Idea:    Bodies of different eccentricity go round one Sun in the upper half with Kepler's timing, each trailing a fan of three equal-time slices, and below them each body's velocity, drawn from one common origin, runs round a circle set off from that origin by e times its radius.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hodograph of motion under an inverse-square force (William Rowan Hamilton, 1846), Kepler's equation and the law of equal areas (Johannes Kepler, 1609), Feynman's lost lecture (Richard Feynman, 1964; David and Judith Goodstein, 1996), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Eccentricity=0.6..0.95, Bodies=3..6\n//\n// Knob 1: Hue. Turns the bodies' colours round the wheel together: at 0 the first three are cyan, magenta and green and the fourth to sixth azure, rose and yellow, while the Sun stays pale gold and the origin of the velocities white.\n// Knob 2: Speed. How fast time runs. At 1 the three opening bodies go round in 3.2, 5.3 and 7.1 seconds, the period growing as the 3/2 power of the semi-major axis; at the opening 2 they take 1.6, 2.6 and 3.5 seconds.\n// Knob 3: Eccentricity. The eccentricity of the most eccentric body, with the others spread evenly below it: 0.2, 0.4 and 0.6 at the opening 0.6. At 0.95 that body moves 39 times faster at periapsis than at apoapsis, its hodograph is the largest circle with the origin 0.05 of a radius inside its rim, and the other hodographs shrink round the origin.\n// Knob 4: Bodies. Three to six bodies, their eccentricities spread evenly up to Knob 3's (six at 0.6 run 0.1, 0.2 ... 0.6), their apoapses from 13 to 29.5 units and their apse lines turned 137.5 degrees (the golden angle) from one another; each half of the panel is fitted to the new set.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, PI, round, hypot } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst wrap = (v) => v - TAU * floor(v / TAU);\n\n// Upper half: the orbits round the Sun. Lower half: velocity space, every\n// velocity drawn from one origin O. World y runs up in both. Each half is\n// fitted to its own box, BOX LEDs square, centred on row MID[0] or MID[1].\nconst BOX = 57, MID = [30, 97];\n// Apoapses run from Q0 to Q1 in world units, and an orbit with semi-major\n// axis 20 takes T20 seconds at Speed 1. One Sun, so one mu for every body.\nconst Q0 = 13, Q1 = 29.5, T20 = 8;\nconst MU = (TAU / T20) ** 2 * 8000;\n// Each body's fan covers this share of its period, in BANDS equal-time slices.\nconst FAN = 0.3, BANDS = 3;\n// The arrow at a body is this share of the same velocity's length below.\nconst ARROW = 0.55;\n// Equal steps of true anomaly marked on every orbit and hodograph.\nconst BEADS = 12;\nconst TAB = 1024;\n// Body colours at Hue 0: cyan, magenta, green, azure, rose, yellow.\nconst HUES = [0.5, 0.83, 0.3, 0.64, 0.97, 0.14];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Kepler's equation M = E - e sin E by Newton's method from E = M. Over e\n// up to 0.95 and 20 000 values of M it settles within 7 steps.\nfunction kepler(M, e) {\n  let E = M;\n  for (let k = 0; k \u003c 20; k++) {\n    const d = (E - e * sin(E) - M) / (1 - e * cos(E));\n    E -= d;\n    if (abs(d) \u003c 1e-13) break;\n  }\n  return E;\n}\n\n// Mean anomaly at true anomaly th in [0, 2 pi], through the eccentric anomaly.\nfunction meanAt(e, th) {\n  const E = 2 * atan2(sqrt(1 - e) * sin(th / 2), sqrt(1 + e) * cos(th / 2));\n  return E - e * sin(E);\n}\n\n// The claim, checked: velocities from Kepler's equation at 720 equal steps\n// of time, a least-squares circle through them (Kasa's fit, which is not\n// told the answer), the largest distance of a velocity from that circle as\n// a share of its radius, and how far the circle's offset from the origin\n// is from e times its radius.\nfunction check() {\n  let radial = 0, offset = 0;\n  for (let e = 0; e \u003c 0.96; e += 0.05) {\n    const pts = [];\n    for (let k = 0; k \u003c 720; k++) {\n      const E = kepler((TAU * k) / 720, e), q = 1 - e * cos(E);\n      pts.push([-sin(E) / q, (sqrt(1 - e * e) * cos(E)) / q]);\n    }\n    let a = 0, b = 0, c = 0, d = 0, f = 0, n = pts.length, u = 0, v = 0, z = 0;\n    for (const [x, y] of pts) {\n      const r = x * x + y * y;\n      a += x * x; b += x * y; c += y * y; d += x; f += y; u += x * r; v += y * r; z += r;\n    }\n    const det3 = (m) =>\n      m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);\n    const A = [a, b, d, b, c, f, d, f, n], rhs = [-u, -v, -z], D = det3(A);\n    const sol = [0, 1, 2].map((col) => det3(A.map((m, i) => (i % 3 === col ? rhs[floor(i / 3)] : m))) / D);\n    const cx = -sol[0] / 2, cy = -sol[1] / 2, R = sqrt(cx * cx + cy * cy - sol[2]);\n    for (const [x, y] of pts) radial = max(radial, abs(hypot(x - cx, y - cy) - R) / R);\n    offset = max(offset, abs(hypot(cx, cy) / R - e));\n  }\n  return { radial, offset };\n}\n\nfunction body() {\n  return {\n    e: 0, a: 1, p: 1, Q: 1, nm: 1, R: 1, w0: 0, w: 0, cw: 1, sw: 0, M0: 0, M: 0,\n    x: 0, y: 0, vx: 0, vy: 0, psi: 0, span: 0, hx: 0, hy: 0, hr: 1, mt: new Float64Array(TAB + 1), col: new Float32Array(3),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, n: 0, emax: -1, hue: 0,\n    // Orbit scale and the Sun's LED; hodograph scale and the origin's LED.\n    so: 1, fx: 31.5, fy: 31, hs: 1, ox: 31.5, oy: 96,\n    b: [0, 1, 2, 3, 4, 5].map(body),\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3),\n    check: check(),\n  };\n  return params.s;\n}\n\n// Scale and centre that fit a world box into a half of the panel.\nfunction fit(x0, x1, y0, y1, row) {\n  const s = BOX / max(x1 - x0, y1 - y0);\n  return [s, 31.5 - (s * (x0 + x1)) / 2, row + (s * (y0 + y1)) / 2];\n}\n\n// The orbits' box with every apse line turned by tilt, as [x0, x1, y0, y1].\nfunction orbitBox(S, tilt) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c S.n; i++) {\n    const B = S.b[i], w = B.w0 + tilt, cw = cos(w), sw = sin(w), b = B.a * sqrt(1 - B.e * B.e);\n    const cx = -B.a * B.e * cw, cy = -B.a * B.e * sw;\n    const ex = sqrt(B.a * B.a * cw * cw + b * b * sw * sw), ey = sqrt(B.a * B.a * sw * sw + b * b * cw * cw);\n    x0 = min(x0, cx - ex); x1 = max(x1, cx + ex); y0 = min(y0, cy - ey); y1 = max(y1, cy + ey);\n  }\n  return [x0, x1, y0, y1];\n}\n\n// The bodies: eccentricities spread evenly up to the knob's, apoapses from\n// Q0 to Q1, apse lines turned by the golden angle from one another, and the\n// whole set turned to the tilt that lets it stand largest in its square.\n// Then both halves are fitted: the orbits by their box, the hodographs by\n// theirs, each circle of radius R = mu / h centred e R from O, square to\n// the apse line.\nfunction build(S, n, emax) {\n  S.n = n;\n  S.emax = emax;\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i], e = (emax * (i + 1)) / n;\n    B.e = e;\n    B.Q = Q0 + ((Q1 - Q0) * i) / (n - 1);\n    B.a = B.Q / (1 + e);\n    B.p = B.a * (1 - e * e);\n    B.nm = sqrt(MU / (B.a * B.a * B.a));\n    B.R = sqrt(MU / B.p);\n    B.w0 = i * 2.39996;\n    B.M0 = 0.6 + i * 2.6;\n    for (let k = 0; k \u003c= TAB; k++) B.mt[k] = meanAt(e, (TAU * k) / TAB);\n  }\n  let tilt = 0, best = 1e9;\n  for (let k = 0; k \u003c 60; k++) {\n    const [x0, x1, y0, y1] = orbitBox(S, (PI * k) / 60), size = max(x1 - x0, y1 - y0);\n    if (size \u003c best - 1e-9) (best = size), (tilt = (PI * k) / 60);\n  }\n  let u0 = 1e9, u1 = -1e9, v0 = 1e9, v1 = -1e9;\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i];\n    B.w = B.w0 + tilt;\n    B.cw = cos(B.w);\n    B.sw = sin(B.w);\n    const hx = -B.e * B.R * B.sw, hy = B.e * B.R * B.cw;\n    u0 = min(u0, hx - B.R); u1 = max(u1, hx + B.R); v0 = min(v0, hy - B.R); v1 = max(v1, hy + B.R);\n  }\n  const [x0, x1, y0, y1] = orbitBox(S, tilt);\n  [S.so, S.fx, S.fy] = fit(x0, x1, y0, y1, MID[0]);\n  [S.hs, S.ox, S.oy] = fit(u0, u1, v0, v1, MID[1]);\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i];\n    B.hr = B.R * S.hs;\n    B.hx = -B.e * B.hr * B.sw;\n    B.hy = B.e * B.hr * B.cw;\n  }\n}\n\nfunction meanOf(B, th) {\n  const f = (wrap(th) / TAU) * TAB, k = min(TAB - 1, floor(f));\n  return B.mt[k] + (B.mt[k + 1] - B.mt[k]) * (f - k);\n}\n\n// Position (from the Sun) and velocity of a body at time t, by Kepler's\n// equation, both in world axes.\nfunction place(B, t) {\n  const e = B.e, M = wrap(B.M0 + B.nm * t), E = kepler(M, e);\n  const cE = cos(E), sE = sin(E), s1 = sqrt(1 - e * e), k = (B.nm * B.a) / (1 - e * cE);\n  const px = B.a * (cE - e), py = B.a * s1 * sE, vx = -k * sE, vy = k * s1 * cE;\n  B.M = M;\n  B.x = px * B.cw - py * B.sw;\n  B.y = px * B.sw + py * B.cw;\n  B.vx = vx * B.cw - vy * B.sw;\n  B.vy = vx * B.sw + vy * B.cw;\n  // The directions of the velocity now and at the oldest edge of the fan.\n  // O is inside every hodograph, so the direction turns one way only, and\n  // the fan below lies between these two.\n  const Eo = kepler(wrap(M - TAU * FAN), e);\n  B.psi = atan2(vy, vx) + B.w;\n  B.span = wrap(B.psi - atan2(s1 * cos(Eo), -sin(Eo)) - B.w);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1], 0.2, 3), emax = cl(kv[2], 0.6, 0.95), n = cl(round(kv[3]), 3, 6);\n  if (n !== S.n || emax !== S.emax) build(S, n, emax);\n  S.t += d * speed;\n  for (let i = 0; i \u003c n; i++) {\n    const B = S.b[i];\n    place(B, S.t);\n    hsv(S.hue + HUES[i], 0.8, 1, B.col);\n  }\n}\n\n// Brightness of a fan at a given age, as a share of the fan's window:\n// equal-time slices alternate bright and dim, fading toward the oldest.\nfunction fan(age) {\n  return (1 - age) ** 0.7 * (floor(age * BANDS) % 2 ? 0.26 : 0.5);\n}\n\nfunction put(rgb, x, y, c, v) {\n  const o = (y * W + x) * 3;\n  if (rgb[o] \u003c c[0] * v) rgb[o] = c[0] * v;\n  if (rgb[o + 1] \u003c c[1] * v) rgb[o + 1] = c[1] * v;\n  if (rgb[o + 2] \u003c c[2] * v) rgb[o + 2] = c[2] * v;\n}\n\n// A soft point at panel coordinates (px, py), weights split over the four\n// nearest LEDs, each keeping the brighter value.\nfunction dot(rgb, px, py, c, v) {\n  const x0 = floor(px), y0 = floor(py), fx = px - x0, fy = py - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const x = x0 + i, y = y0 + j;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      put(rgb, x, y, c, v * (i ? fx : 1 - fx) * (j ? fy : 1 - fy));\n    }\n}\n\nfunction line(rgb, x0, y0, x1, y1, c, v) {\n  const n = max(1, Math.ceil(hypot(x1 - x0, y1 - y0) * 2.2));\n  for (let k = 0; k \u003c= n; k++) dot(rgb, x0 + ((x1 - x0) * k) / n, y0 + ((y1 - y0) * k) / n, c, v);\n}\n\nfunction disc(rgb, px, py, rad, c, core) {\n  for (let y = max(0, floor(py - rad - 1)); y \u003c= min(H - 1, Math.ceil(py + rad + 1)); y++)\n    for (let x = max(0, floor(px - rad - 1)); x \u003c= min(W - 1, Math.ceil(px + rad + 1)); x++) {\n      const d = hypot(x - px, y - py), v = cl(rad + 0.5 - d, 0, 1);\n      if (v \u003c= 0) continue;\n      const w = core * cl(1 - d / rad, 0, 1), o = (y * W + x) * 3;\n      rgb[o] = max(rgb[o], c[0] * v + (1 - c[0]) * w);\n      rgb[o + 1] = max(rgb[o + 1], c[1] * v + (1 - c[1]) * w);\n      rgb[o + 2] = max(rgb[o + 2], c[2] * v + (1 - c[2]) * w);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, n = S.n, bs = S.b, c = S.c, win = TAU * FAN;\n  const so = S.so, fx = S.fx, fy = S.fy, hs = S.hs, ox = S.ox, oy = S.oy;\n  rgb.fill(0);\n\n  // The fans in the orbits: an LED's direction from the Sun is a true\n  // anomaly on every orbit, the orbit's radius there says whether the LED is\n  // inside, and the time since the body passed that direction picks the slice.\n  for (let y = 0; y \u003c 64; y++) {\n    const dy = (fy - y) / so;\n    for (let x = 0; x \u003c W; x++) {\n      const dx = (x - fx) / so, d = sqrt(dx * dx + dy * dy), phi = atan2(dy, dx);\n      for (let i = 0; i \u003c n; i++) {\n        const B = bs[i];\n        if (d > B.Q + 1) continue;\n        const th = phi - B.w, age = wrap(B.M - meanOf(B, th)) / win;\n        if (age >= 1) continue;\n        const edge = (B.p / (1 + B.e * cos(th)) - d) * so + 0.5;\n        if (edge \u003c= 0) continue;\n        put(rgb, x, y, B.col, fan(age) * min(1, edge));\n      }\n    }\n  }\n  // The same fans in velocity space: the ray from O through an LED meets\n  // each hodograph at one velocity, whose angle round its circle's centre is\n  // the true anomaly plus a quarter turn.\n  for (let y = 64; y \u003c H; y++) {\n    const wy = oy - y;\n    for (let x = 0; x \u003c W; x++) {\n      const wx = x - ox, d = sqrt(wx * wx + wy * wy);\n      if (d \u003c 1e-6) continue;\n      const ux = wx / d, uy = wy / d, psi = atan2(wy, wx);\n      for (let i = 0; i \u003c n; i++) {\n        const B = bs[i];\n        if (wrap(B.psi - psi) > B.span) continue;\n        const ex = wx - B.hx, ey = wy - B.hy, edge = B.hr + 0.5 - sqrt(ex * ex + ey * ey);\n        if (edge \u003c= 0) continue;\n        const uc = ux * B.hx + uy * B.hy;\n        const s = uc + sqrt(max(0, uc * uc - B.hx * B.hx - B.hy * B.hy + B.hr * B.hr));\n        const th = atan2(s * uy - B.hy, s * ux - B.hx) - B.w - PI / 2;\n        const age = wrap(B.M - meanOf(B, th)) / win;\n        if (age >= 1) continue;\n        put(rgb, x, y, B.col, fan(age) * min(1, edge));\n      }\n    }\n  }\n\n  for (let i = 0; i \u003c n; i++) {\n    const B = bs[i], e = B.e, s1 = sqrt(1 - e * e), A = B.a * so;\n    // The orbit, brighter where the body has just been.\n    for (let k = 0; k \u003c 420; k++) {\n      const E = (TAU * k) / 420, px = A * (cos(E) - e), py = A * s1 * sin(E);\n      const age = wrap(B.M - (E - e * sin(E))) / win;\n      dot(rgb, fx + px * B.cw - py * B.sw, fy - (px * B.sw + py * B.cw), B.col, age \u003c 1 ? 0.95 - 0.5 * age : 0.4);\n    }\n    // The hodograph, the same way.\n    const nh = max(90, round(B.hr * 9));\n    for (let k = 0; k \u003c nh; k++) {\n      const th = (TAU * k) / nh, vx = -B.hr * sin(th), vy = B.hr * (e + cos(th));\n      const age = wrap(B.M - meanAt(e, th)) / win;\n      dot(rgb, ox + vx * B.cw - vy * B.sw, oy - (vx * B.sw + vy * B.cw), B.col, age \u003c 1 ? 0.95 - 0.5 * age : 0.4);\n    }\n    // The circle's centre, e times its radius from O.\n    dot(rgb, ox + B.hx, oy - B.hy, B.col, 0.6);\n    // Feynman's beads: the orbit at equal steps of angle round the Sun, and\n    // the velocities there, which fall at equal steps round the circle.\n    for (let k = 0; k \u003c 3; k++) c[k] = 0.55 + 0.45 * B.col[k];\n    for (let k = 0; k \u003c BEADS; k++) {\n      const th = (TAU * k) / BEADS, r = (B.p * so) / (1 + e * cos(th));\n      const px = r * cos(th), py = r * sin(th), vx = -B.hr * sin(th), vy = B.hr * (e + cos(th));\n      dot(rgb, fx + px * B.cw - py * B.sw, fy - (px * B.sw + py * B.cw), c, 1);\n      dot(rgb, ox + vx * B.cw - vy * B.sw, oy - (vx * B.sw + vy * B.cw), c, 1);\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const B = bs[i], col = B.col;\n    for (let k = 0; k \u003c 3; k++) c[k] = 0.5 + 0.5 * col[k];\n    const bx = fx + B.x * so, by = fy - B.y * so, tx = ox + B.vx * hs, ty = oy - B.vy * hs;\n    // A thread from the body to the tip of its velocity, the velocity arrow\n    // at the body, and the same velocity from O.\n    line(rgb, bx, by, tx, ty, col, 0.16);\n    line(rgb, bx, by, bx + (tx - ox) * ARROW, by + (ty - oy) * ARROW, c, 1);\n    line(rgb, ox, oy, tx, ty, c, 1);\n    disc(rgb, tx, ty, 1.2, col, 0.6);\n    disc(rgb, bx, by, 1.5, col, 0.8);\n  }\n  c[0] = 1; c[1] = 0.86; c[2] = 0.6;\n  disc(rgb, fx, fy, 1.8, c, 1);\n  c[0] = c[1] = c[2] = 1;\n  disc(rgb, ox, oy, 0.9, c, 1);\n\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n    }\n}\n","shapley-folkman":"// ===== Patternflow pattern =====\n// Title:   Shapley-Folkman\n// Family:  geometry\n// Idea:    Four bands down the panel hold one nonconvex shape and its Minkowski averages of 2, 4 and 8 copies, each summed exactly on a lattice, so its bays and holes close band by band toward the convex hull drawn faintly round it, the distance still to go halving at every band and every point coloured by the band where it first appears.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Shapley-Folkman lemma (Lloyd Shapley and Jon Folkman, first published by Ross Starr, 1969), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..4, Hull=0..1\n//\n// Knob 1: Hue. Turns the four layer colours round a wheel that skips orange. At 0 the shape is teal and the parts added at 2, 4 and 8 copies azure, indigo and violet; at 0.25 blue, violet, magenta and yellow; at 0.75 lime, green, cyan and azure. The uncovered part of the hull is gold at 0 and turns with them.\n// Knob 2: Speed. How fast the shape moves: at 2 the moon's bite, the pearls and the ring's gap go round in 9 s, the star turns one point in 1.8 s and the comb's teeth rise and fall every 6.9 s; at 0.2 ten times slower, at 3 two thirds of that. Every band follows at once, since all four are summed again each frame.\n// Knob 3: Shape. 0 a moon (an ellipse with a bite), 1 three pearls, 2 an open ring, 3 a comb, 4 a five-pointed star; in between, the two neighbours blend and break into pieces. At 1 copy they leave 43, 51, 45, 37 and 45% of their hull uncovered, at 8 copies 3.7, 1.3, 0.7, 0.9 and 4.4%.\n// Knob 4: Hull. The convex hull is a faint line at 0 and at the opening 0.06. From 0.1 the part of the hull a band has not covered yet is hatched in gold, the hatching at full strength by 0.4, and from there it fills in until at 1 that whole part is gold. It is the gap the lemma says shrinks like 1/n: for the moon, 43, 20, 8.6 and 3.7% of the hull in the four bands.\n\n// The Shapley-Folkman lemma: in the plane, a point of the convex hull of a\n// sum of n sets is a sum of n points, one from each set, of which at most\n// two come from a set's hull instead of the set. So the average of n copies\n// of a shape S, A(n) = (S + ... + S) / n, comes within 2D/n of every point\n// of S's hull, where D is how far the hull reaches from S itself: the\n// average fills toward the hull like 1/n. A(1), A(2), A(4) and A(8) also\n// nest, since (a + b) / 2 = (a + a + b + b) / 4.\n//\n// The panel takes S as the lattice points, one per LED, inside the shape,\n// sums the point sets exactly (8 copies make a lattice of 465 by 217),\n// and lights each LED by the share of A(n)'s points that fall inside it.\n// Brightness is never how many ways a point can be reached: that count is\n// the bell of the central limit theorem, a different statement.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, cos, sin, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\n// One band per n. The shape's lattice is SW by SH points, one per LED,\n// placed at (X0, Y0) inside each 32-row band.\nconst NS = [1, 2, 4, 8], NMAX = 8;\nconst SW = 59, SH = 28, X0 = 4, Y0 = 2, BAND = 32;\nconst CX = (SW - 1) / 2, CY = (SH - 1) / 2;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// ---- Lattice sets as bitmaps: w by h points, rows of 32-bit words. ----\nfunction bitmap(w, h) {\n  const ww = ((w + 31) >> 5) + 1;\n  return { w, h, ww, b: new Uint32Array(ww * h) };\n}\nconst has = (B, x, y) => (B.b[y * B.ww + (x >> 5)] >>> (x & 31)) & 1;\n\n// dst |= src moved by (dx, dy).\nfunction orShift(dst, src, dx, dy) {\n  const q = dx >> 5, r = dx & 31, sw = src.ww, dw = dst.ww, sb = src.b, db = dst.b;\n  const used = (src.w + 31) >> 5;\n  for (let y = 0; y \u003c src.h; y++) {\n    const so = y * sw, d0 = (y + dy) * dw + q;\n    if (r === 0) for (let i = 0; i \u003c used; i++) db[d0 + i] |= sb[so + i];\n    else\n      for (let i = 0; i \u003c used; i++) {\n        const v = sb[so + i];\n        if (!v) continue;\n        db[d0 + i] |= v \u003c\u003c r;\n        db[d0 + i + 1] |= v >>> (32 - r);\n      }\n  }\n}\n\n// The points of B with one of their eight neighbours outside B.\nfunction boundary(B, xs, ys) {\n  const { h, ww, b } = B, used = (B.w + 31) >> 5;\n  const hor = (o, i) => {\n    const m = b[o + i];\n    if (!m) return 0;\n    return m & ((m \u003c\u003c 1) | (i > 0 ? b[o + i - 1] >>> 31 : 0)) & ((m >>> 1) | (i + 1 \u003c used ? b[o + i + 1] \u003c\u003c 31 : 0));\n  };\n  let n = 0;\n  for (let y = 0; y \u003c h; y++)\n    for (let i = 0; i \u003c used; i++) {\n      const m = b[y * ww + i];\n      if (!m) continue;\n      const inner = y > 0 && y \u003c h - 1 ? hor(y * ww, i) & hor((y - 1) * ww, i) & hor((y + 1) * ww, i) : 0;\n      let e = m & ~inner;\n      while (e) {\n        const t = e & -e;\n        xs[n] = i * 32 + 31 - Math.clz32(t);\n        ys[n++] = y;\n        e ^= t;\n      }\n    }\n  return n;\n}\n\n// One point from each 8-connected piece of S.\nfunction pieces(S, lab, stack, out) {\n  out.length = 0;\n  lab.fill(0);\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      if (lab[y * SW + x] || !has(S, x, y)) continue;\n      out.push(x, y);\n      let sp = 0;\n      stack[sp++] = y * SW + x;\n      lab[y * SW + x] = 1;\n      while (sp) {\n        const p = stack[--sp], px = p % SW, py = (p - px) / SW;\n        for (let yy = max(0, py - 1); yy \u003c= min(SH - 1, py + 1); yy++)\n          for (let xx = max(0, px - 1); xx \u003c= min(SW - 1, px + 1); xx++) {\n            const k = yy * SW + xx;\n            if (!lab[k] && has(S, xx, yy)) (lab[k] = 1), (stack[sp++] = k);\n          }\n      }\n    }\n}\n\n// C = A + S, the Minkowski sum of lattice sets. Shifting the small S to\n// every point of A would do; it is enough to shift it to the boundary\n// points of A, and add one copy of A for each piece of S. For a piece P of\n// S and a sum x = p + a, the set x - P is connected and holds a; either it\n// leaves A, and then it crosses A's boundary, or it stays inside A and\n// x lies in A shifted by any one point of P. S is at most 64 points wide,\n// so each of its rows, moved by 0 to 31 bits, is kept ready as three words.\nfunction sum(C, A, St, reps, xs, ys) {\n  const cb = C.b, cw = C.ww, pre = St.pre, y0 = St.ylo, y1 = St.yhi;\n  cb.fill(0);\n  const n = boundary(A, xs, ys);\n  for (let k = 0; k \u003c n; k++) {\n    const x = xs[k], p0 = (x & 31) * SH * 3;\n    let o = (ys[k] + y0) * cw + (x >> 5);\n    for (let y = y0, p = p0 + y0 * 3; y \u003c= y1; y++, p += 3, o += cw) {\n      cb[o] |= pre[p];\n      cb[o + 1] |= pre[p + 1];\n      cb[o + 2] |= pre[p + 2];\n    }\n  }\n  for (let k = 0; k \u003c reps.length; k += 2) orShift(C, A, reps[k], reps[k + 1]);\n}\n\n// ---- The shapes, as rough signed distances in LEDs (inside \u003c 0). ----\n// The lattice is 59 wide and 28 tall; U and V scale a unit circle to it.\nconst U = 28.5, V = 13;\nconst len = (x, y) => sqrt(x * x + y * y);\nconst SHAPES = [\n  // Moon: an ellipse with a bite out of it, the bite going round.\n  (x, y, p) => {\n    const u = x / U, v = y / V, bu = u - 0.45 * cos(p), bv = v - 0.45 * sin(p);\n    return max(len(u, v) - 1, 0.75 - len(bu, bv)) * V;\n  },\n  // Pearls: three discs going round an ellipse.\n  (x, y, p) => {\n    let d = 1e9;\n    for (let j = 0; j \u003c 3; j++) {\n      const a = p + (TAU * j) / 3;\n      d = min(d, len(x - 21 * cos(a), y - 6.5 * sin(a)) - 6.5);\n    }\n    return d;\n  },\n  // Open ring: an elliptic band with a gap going round.\n  (x, y, p) => {\n    const u = x / U, v = y / V, r = len(u, v);\n    const a = atan2(v, u) - p, g = abs(atan2(sin(a), cos(a)));\n    return max(abs(r - 0.8) - 0.2, (0.55 - g) * r) * V;\n  },\n  // Comb: a back along the bottom and four teeth rising and falling.\n  (x, y, p) => {\n    let d = max(abs(x) - 28.5, abs(y - 10.5) - 3);\n    for (let j = 0; j \u003c 4; j++) {\n      const tx = -21.4 + 14.25 * j, top = -13 + 7 * (0.5 + 0.5 * sin(p * 1.3 + j * 1.9));\n      d = min(d, max(abs(x - tx) - 3.2, max(top - y, y - 10)));\n    }\n    return d;\n  },\n  // Star: five points turning, seen flattened to fit the band.\n  (x, y, p) => {\n    const u = x / U, v = y / V, r = len(u, v);\n    const a = atan2(v, u) - p, k = (a * 5) / TAU, f = abs(k - floor(k) - 0.5) * 2;\n    return (r - (0.38 + 0.62 * f * f)) * V * 1.4;\n  },\n];\n\nexport function setup(params) {\n  const sums = [null];\n  for (let k = 1; k \u003c= NMAX; k++) sums.push(bitmap(k * (SW - 1) + 1, k * (SH - 1) + 1));\n  const big = sums[NMAX - 1].w * sums[NMAX - 1].h;\n  params.s = {\n    phase: 0, hue: 0, shape: 0, hk: 0.06,\n    sums, xs: new Int32Array(big), ys: new Int32Array(big),\n    lab: new Uint8Array(SW * SH), stack: new Int32Array(SW * SH * 9), reps: [],\n    cov: new Float32Array(NS.length * SW * SH), sd: new Float32Array(SW * SH),\n    hull: [], pre: new Uint32Array(32 * SH * 3), ylo: 0, yhi: -1, ex: new Float64Array(SW * SH * 3),\n    pop: new Uint8Array(256).map((_, i) => (i.toString(2).match(/1/g) || []).length),\n    c: new Float32Array(3), lay: new Float32Array(NS.length * 9), unc: new Float32Array(SW * SH), rgb: new Float32Array(W * H * 3),\n  };\n  return params.s;\n}\n\n// Rasterise the shape at this phase and knob, then the sums 2..8.\nfunction build(S) {\n  const A = S.sums[1];\n  A.b.fill(0);\n  const k = cl(S.shape, 0, 4), i0 = min(3, floor(k)), f = k - i0;\n  const fa = SHAPES[i0], fb = SHAPES[i0 + 1];\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      const px = x - CX, py = y - CY;\n      let d = fa(px, py, S.phase);\n      if (f > 0) d = d * (1 - f) + fb(px, py, S.phase) * f;\n      if (d \u003c= 0) A.b[y * A.ww + (x >> 5)] |= 1 \u003c\u003c (x & 31);\n    }\n  pieces(A, S.lab, S.stack, S.reps);\n  S.ylo = SH;\n  S.yhi = -1;\n  for (let y = 0; y \u003c SH; y++) {\n    const w0 = A.b[y * A.ww], w1 = A.b[y * A.ww + 1];\n    if (w0 | w1) (S.ylo = min(S.ylo, y)), (S.yhi = y);\n    for (let r = 0; r \u003c 32; r++) {\n      const p = (r * SH + y) * 3;\n      S.pre[p] = w0 \u003c\u003c r;\n      S.pre[p + 1] = r ? (w0 >>> (32 - r)) | (w1 \u003c\u003c r) : w1;\n      S.pre[p + 2] = r ? w1 >>> (32 - r) : 0;\n    }\n  }\n  for (let n = 1; n \u003c NMAX; n++) sum(S.sums[n + 1], S.sums[n], S, S.reps, S.xs, S.ys);\n  hullOf(S);\n  // Coverage of each LED: the share of the n by n lattice points of the\n  // n-fold sum that fall in it, since A(n) is that sum shrunk by 1/n.\n  for (let bi = 0; bi \u003c NS.length; bi++) {\n    const n = NS[bi], B = S.sums[n], o = bi * SW * SH, h = n >> 1, mask = (1 \u003c\u003c n) - 1;\n    for (let y = 0; y \u003c SH; y++)\n      for (let x = 0; x \u003c SW; x++) {\n        let c = 0;\n        const a = n * x - h;\n        for (let r = n * y - h; r \u003c n * y - h + n; r++) {\n          if (r \u003c 0 || r >= B.h) continue;\n          const row = r * B.ww;\n          if (a \u003c 0) {\n            c += S.pop[B.b[row] & ((1 \u003c\u003c (a + n)) - 1)];\n            continue;\n          }\n          const wi = a >> 5, off = a & 31;\n          let v = B.b[row + wi] >>> off;\n          if (off + n > 32) v |= B.b[row + wi + 1] \u003c\u003c (32 - off);\n          c += S.pop[v & mask];\n        }\n        S.cov[o + y * SW + x] = c / (n * n);\n      }\n  }\n}\n\n// Convex hull of the shape's lattice points (monotone chain), then each\n// LED's signed distance to it, negative inside.\nfunction hullOf(S) {\n  const n = boundary(S.sums[1], S.xs, S.ys), P = [];\n  for (let k = 0; k \u003c n; k++) P.push([S.xs[k], S.ys[k]]);\n  P.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n  const cr = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);\n  const lo = [], up = [];\n  for (const p of P) {\n    while (lo.length >= 2 && cr(lo[lo.length - 2], lo[lo.length - 1], p) \u003c= 0) lo.pop();\n    lo.push(p);\n  }\n  for (let i = P.length - 1; i >= 0; i--) {\n    const p = P[i];\n    while (up.length >= 2 && cr(up[up.length - 2], up[up.length - 1], p) \u003c= 0) up.pop();\n    up.push(p);\n  }\n  const Hl = lo.slice(0, -1).concat(up.slice(0, -1));\n  S.hull = Hl;\n  // The chain turns left at every corner, reading y as up, so the inside\n  // is on the left of each edge; an LED's distance is the largest it lies\n  // outside any edge, which is exact inside and close enough near it.\n  const m = Hl.length, E = S.ex;\n  for (let i = 0; i \u003c m; i++) {\n    const a = Hl[i], b = Hl[(i + 1) % m], ex = b[0] - a[0], ey = b[1] - a[1], L = sqrt(ex * ex + ey * ey) || 1;\n    E[i * 3] = ey / L;\n    E[i * 3 + 1] = -ex / L;\n    E[i * 3 + 2] = (a[1] * ex - a[0] * ey) / L;\n  }\n  for (let y = 0; y \u003c SH; y++)\n    for (let x = 0; x \u003c SW; x++) {\n      let d = -1e9;\n      for (let i = 0; i \u003c m * 3; i += 3) d = max(d, x * E[i] + y * E[i + 1] + E[i + 2]);\n      S.sd[y * SW + x] = m \u003c 3 ? 9 : d;\n    }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1] ?? 2, 0.2, 3);\n  S.shape = cl(kv[2] || 0, 0, 4);\n  S.hk = cl(kv[3] ?? 0.06, 0, 1);\n  S.phase += d * speed * 0.35;\n  build(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, c = S.c, L = S.lay, unc = S.unc, cov = S.cov, A = SW * SH;\n  rgb.fill(0);\n  // The uncovered part of the hull: gold hatching that comes in from Hull\n  // 0.1 to 0.4, then fills between its lines up to 1. Gold dimmed evenly\n  // would read brown.\n  const hk = S.hk, hatch = cl((hk - 0.1) / 0.3, 0, 1) * 0.85, fill = cl((hk - 0.4) / 0.6, 0, 1) * 0.85;\n  // Colour by n: each band's points are coloured by the band where they\n  // first appear, since A(1), A(2), A(4) and A(8) each hold the one before.\n  // Older layers are deep, the layer new in this band is pale and bright.\n  // The wheel skips orange, which goes brown at the depth of the old\n  // layers: the knob runs from yellow through green, blue and violet to red.\n  const wheel = (p) => 0.16 + (p - floor(p)) * 0.84;\n  for (let j = 0; j \u003c NS.length; j++) {\n    const h = wheel(S.hue + 0.352 + 0.136 * j);\n    hsv(h, 0.88, 0.58, c);\n    L.set(c, j * 9);\n    hsv(h + 0.03, 0.45, 1, c);\n    L.set(c, j * 9 + 3);\n    hsv(h, 0.9, 0.85, c);\n    L.set(c, j * 9 + 6);\n  }\n  hsv(S.hue + 0.13, 0.8, 1, c);\n  const fr = c[0], fg = c[1], fb = c[2];\n  for (let bi = 0; bi \u003c NS.length; bi++) {\n    const n = NS[bi], o = bi * A;\n    for (let k = 0; k \u003c A; k++) unc[k] = cl(0.5 - S.sd[k], 0, 1) * (1 - cov[o + k]);\n    for (let y = 0; y \u003c SH; y++)\n      for (let x = 0; x \u003c SW; x++) {\n        const k = y * SW + x, cv = cov[o + k], sd = S.sd[k];\n        let r = 0, g = 0, b = 0, acc = 0;\n        for (let j = 0; j \u003c= bi; j++) {\n          const cj = min(cov[j * A + k], cv), lj = cj - acc;\n          if (lj \u003c= 0) continue;\n          acc = cj;\n          const q = j * 9 + (bi === 0 ? 6 : j === bi ? 3 : 0);\n          r += L[q] * lj;\n          g += L[q + 1] * lj;\n          b += L[q + 2] * lj;\n        }\n        // The filling edge: lit points next to the part of the hull still\n        // uncovered glow in the new layer's pale colour.\n        let u = 0;\n        if (cv > 0) {\n          if (x > 0) u = max(u, unc[k - 1]);\n          if (x \u003c SW - 1) u = max(u, unc[k + 1]);\n          if (y > 0) u = max(u, unc[k - SW]);\n          if (y \u003c SH - 1) u = max(u, unc[k + SW]);\n        }\n        const glow = u * cv * 0.7, gq = bi * 9 + 3;\n        const line = cl(1 - abs(sd) / 0.8, 0, 1) * (0.14 + 0.5 * hk);\n        const gap = unc[k] * ((x + y) % 3 ? fill : hatch);\n        const q = ((bi * BAND + Y0 + y) * W + X0 + x) * 3;\n        rgb[q] = r + L[gq] * glow + fr * gap + line * 0.8;\n        rgb[q + 1] = g + L[gq + 1] * glow + fg * gap + line * 0.75;\n        rgb[q + 2] = b + L[gq + 2] * glow + fb * gap + line * 0.6;\n      }\n    // n dots at the left edge: the number of copies summed.\n    for (let j = 0; j \u003c n; j++) {\n      const Y = bi * BAND + 16 - ((n - 1) * 3) / 2 + j * 3;\n      const q = ((Y | 0) * W + 1) * 3;\n      rgb[q] = L[bi * 9 + 3];\n      rgb[q + 1] = L[bi * 9 + 4];\n      rgb[q + 2] = L[bi * 9 + 5];\n    }\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const q = (Y * W + X) * 3;\n      display.setPixel(X, Y, min(255, rgb[q] * 255) | 0, min(255, rgb[q + 1] * 255) | 0, min(255, rgb[q + 2] * 255) | 0);\n    }\n}\n","subpixel":"// ===== Patternflow pattern =====\n// Title:   Subpixel\n// Family:  type\n// Idea:    Two letters stored as TrueType outlines drift by fractions of a pixel over a magnified pixel grid that is scan-converted again every frame, as red, green and blue subpixel stripes, as grey coverage or as one-bit pixels, so the raster jumps and its colour fringes shimmer while the thin outline glides on top.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: TrueType quadratic outlines and its pixel-centre rule for scan conversion (Apple, 1991), ClearType subpixel rendering (Microsoft, announced 1998), FreeType's default LCD filter and light hinting, pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Letters=0..2, Speed=0.2..3, Mode=0..3, Hint=0..2\n//\n// Knob 1: Letters. Which pair: a over g at 13.2 pixels to the em or R over & at 12.2, on pixels six LEDs square, or 한 over 글 at 19.5 on pixels three LEDs square.\n// Knob 2: Speed. How fast the outlines drift and breathe: at 2 they travel half a pixel a second and swell and shrink by 5.5 percent over 15 seconds, at 0.2 ten times slower.\n// Knob 3: Mode. How the grid is filled: 0 subpixel stripes, each pixel three LED columns red, green and blue, each lit by the coverage of its own third after FreeType's five-tap filter; 1 the same three values as the colour of the whole pixel, where the fringes show; 2 grey coverage; 3 one bit, a pixel lit when its centre is inside, TrueType's first rule.\n// Knob 4: Hint. Snapping to the grid: 0 none; 1 the baseline, heights and horizontal strokes on pixel rows, as FreeType's light hinting does; 2 the vertical stems as well, each a whole number of pixels wide, so the hinted letter keeps its shape and moves only in whole-pixel jumps while the outline glides.\n// Buttons: K2 tap holds the outlines still, tap again to let them drift.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sin, cos, sqrt, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// ---- Outlines. Units per em 1000, y up, baseline 0. A contour is a list of\n// points [x, y, on]: on 1 lies on the curve, on 0 is a quadratic control\n// point off it, and two off points in a row have an implied on point half\n// way between them, which is how TrueType stores a glyph. As in TrueType,\n// outer contours run clockwise and holes counter-clockwise, contours may\n// overlap, and the fill rule is nonzero winding. Each contour carries its\n// own stems for the hinter.\n\n// \"x,y\" on the curve, \"~x,y\" off it.\nconst pts = (s) => s.trim().split(/\\s+/).map((t) => {\n  const off = t[0] === \"~\";\n  const [x, y] = t.slice(off ? 1 : 0).split(\",\").map(Number);\n  return [x, y, off ? 0 : 1];\n});\n\nfunction rect(x0, y0, x1, y1) {\n  return { p: [[x0, y0, 1], [x0, y1, 1], [x1, y1, 1], [x1, y0, 1]], hx: [[x0, x1]], hy: [[y0, y1]] };\n}\n\n// An oval as eight off points and no on points at all: the implied on\n// points between them fall on the ellipse at every 45 degrees, the extremes\n// among them. A ring is the oval and a smaller one turned the other way.\nfunction oval(cx, cy, rx, ry, hole) {\n  const k = 1 / cos(PI / 8), p = [];\n  for (let i = 0; i \u003c 8; i++) {\n    const a = PI / 8 - (i * PI) / 4;\n    p.push([cx + rx * k * cos(a), cy + ry * k * sin(a), 0]);\n  }\n  return hole ? p.reverse() : p;\n}\nfunction ring(cx, cy, rx, ry, tx, ty) {\n  const hx = [[cx - rx, cx - rx + tx], [cx + rx - tx, cx + rx]], hy = [[cy - ry, cy - ry + ty], [cy + ry - ty, cy + ry]];\n  return [{ p: oval(cx, cy, rx, ry, false), hx, hy }, { p: oval(cx, cy, rx - tx, ry - ty, true), hx, hy }];\n}\n\n// A stroke: a centre line of on points with at most one control point\n// between them, \"x,y,w\" giving the width from that point on. The outline is\n// the line offset to the left going forward and to the right coming back,\n// each control point moved to where the offset tangents meet, so the\n// result is again quadratic. The ends are cut square.\nfunction stroke(s, hx, hy) {\n  const c = s.trim().split(/\\s+/).map((t) => {\n    const off = t[0] === \"~\";\n    const v = t.slice(off ? 1 : 0).split(\",\").map(Number);\n    return { x: v[0], y: v[1], on: !off, w: v[2] };\n  });\n  let w = 0;\n  for (const q of c) if (q.on) (w = q.w || w), (q.w = w);\n  const n = c.length;\n  const dir = (a, b) => {\n    const dx = b.x - a.x, dy = b.y - a.y, l = Math.hypot(dx, dy) || 1;\n    return [dx / l, dy / l];\n  };\n  // Tangent at each point.\n  const t = c.map((q, i) => {\n    const a = i > 0 ? dir(c[i - 1], q) : null, b = i \u003c n - 1 ? dir(q, c[i + 1]) : null;\n    if (!a) return b;\n    if (!b || !q.on) return a;\n    const x = a[0] + b[0], y = a[1] + b[1], l = Math.hypot(x, y) || 1;\n    return [x / l, y / l];\n  });\n  const side = (sg) => {\n    const out = [];\n    for (let i = 0; i \u003c n; i++) {\n      const q = c[i];\n      if (q.on) {\n        const d = (sg * q.w) / 2;\n        out.push([q.x + d * t[i][1], q.y - d * t[i][0], 1]);\n        continue;\n      }\n      // Meet the offset tangent lines of the two on points either side.\n      const A = c[i - 1], B = c[i + 1], ta = dir(A, q), tb = dir(q, B);\n      const da = (sg * A.w) / 2, db = (sg * B.w) / 2;\n      const ax = A.x + da * ta[1], ay = A.y - da * ta[0], bx = B.x + db * tb[1], by = B.y - db * tb[0];\n      const den = ta[0] * tb[1] - ta[1] * tb[0];\n      if (abs(den) \u003c 1e-6) out.push([(ax + bx) / 2, (ay + by) / 2, 0]);\n      else {\n        const u = ((bx - ax) * tb[1] - (by - ay) * tb[0]) / den;\n        out.push([ax + u * ta[0], ay + u * ta[1], 0]);\n      }\n    }\n    return out;\n  };\n  return { p: [...side(-1), ...side(1).reverse()], hx: hx || [], hy: hy || [] };\n}\n\nconst poly = (s, hx, hy) => ({ p: pts(s), hx: hx || [], hy: hy || [] });\n\nconst GLYPHS = {\n  // Double-storey a: stem, arch with a cut terminal, and the bowl hung\n  // from a shelf.\n  a: () => [\n    rect(416, 0, 512, 372),\n    stroke(\"464,360,96 ~464,490 290,490,84 ~176,490 112,424,80\", [[416, 512]], [[448, 532]]),\n    stroke(\"470,259,82 300,259 ~95,259 95,145,94 ~95,31 235,31,86 ~385,31 462,124,90\", [[48, 142], [416, 512]], [[-12, 74], [218, 300]]),\n  ],\n  // Double-storey g: a round upper bowl with an ear, a link and a lower loop.\n  g: () => [\n    ...ring(250, 352, 172, 180, 90, 80),\n    rect(360, 468, 548, 532),\n    stroke(\"178,204,76 ~112,132 180,98,72 ~226,64 330,64,74 ~500,64 500,-62,88 ~500,-194 275,-194,72 ~50,-194 50,-72,88 ~50,34 190,74,70\", [[6, 94], [456, 544]], [[27, 101], [-230, -158]]),\n  ],\n  R: () => [\n    rect(80, 0, 182, 700),\n    stroke(\"130,655,90 330,655 ~484,655 484,491,98 ~484,327 330,327,90 130,327\", [[80, 182], [435, 533]], [[610, 700], [282, 372]]),\n    poly(\"440,0 288,330 404,330 558,0\", [], [[0, 330]]),\n  ],\n  // Ampersand as one stroke: up the diagonal from the right foot, round the\n  // small upper loop, down across itself into the bowl and up the arm.\n  \"&\": () => [\n    stroke(\"588,26,100 ~468,160 332,308,94 ~202,452 205,548,88 ~208,662 305,662,84 ~402,662 402,562,86 ~402,470 292,400,90 ~85,270 85,160,96 ~85,31 252,31,86 ~420,31 490,158,92 ~528,228 546,330,88\", [[37, 133], [161, 249], [359, 445]], [[-12, 74], [620, 704]]),\n  ],\n  // Hangul in a 1000 square, gothic strokes 100 wide and 85 high.\n  \"한\": () => [\n    rect(245, 862, 405, 942), rect(80, 728, 570, 812), ...ring(325, 553, 178, 123, 92, 80),\n    rect(650, 372, 750, 950), rect(750, 622, 885, 706),\n    rect(150, 70, 250, 330), rect(150, 70, 882, 155),\n  ],\n  \"글\": () => [\n    rect(130, 845, 835, 930), rect(742, 700, 835, 930),\n    rect(45, 560, 955, 645),\n    rect(150, 385, 850, 466), rect(762, 228, 852, 466), rect(150, 228, 852, 308),\n    rect(150, 70, 240, 308), rect(150, 70, 870, 150),\n  ],\n};\n\n// Alignment zones for the Latin letters: the flat height and the\n// overshoot of round letters past it. Hinted, both land on one pixel line.\nconst ZONES = [[0, -12], [520, 532], [700, 712], [-220, -232]];\n\n// A set: the glyphs, how many LEDs one pixel takes, and the size in pixels\n// per em. Hangul packs three jamo into one square, so it gets twice the pixels.\nconst SETS = [\n  { g: [\"a\", \"g\"], zoom: 6, ppem: 13.2, gap: 1.3, zones: true },\n  { g: [\"R\", \"&\"], zoom: 6, ppem: 12.2, gap: 1.3, zones: true },\n  { g: [\"한\", \"글\"], zoom: 3, ppem: 19.5, gap: 3.2, zones: false },\n];\n\n// Flatten a contour list to line segments at unit scale, for the bounds.\nfunction bounds(contours) {\n  let x0 = 1e9, y0 = 1e9, x1 = -1e9, y1 = -1e9;\n  const seg = new Float32Array(4096);\n  const n = flatten(contours.map((c) => c.p.map((q) => [q[0], -q[1], q[2]])), seg, 0, 4);\n  for (let i = 0; i \u003c n * 4; i += 2) {\n    x0 = min(x0, seg[i]), x1 = max(x1, seg[i]);\n    y0 = min(y0, -seg[i + 1]), y1 = max(y1, -seg[i + 1]);\n  }\n  return { x0, y0, x1, y1 };\n}\n\n// Decode TrueType contours (already in pixels, y down) to quadratic pieces\n// and cut each into straight segments fine enough at `fine` LEDs a pixel.\n// Writes x0 y0 x1 y1 per segment from index n; returns the new count.\nfunction flatten(cs, seg, n, fine) {\n  const cap = seg.length >> 2;\n  const line = (ax, ay, bx, by) => {\n    if (n \u003c cap) (seg[n * 4] = ax), (seg[n * 4 + 1] = ay), (seg[n * 4 + 2] = bx), (seg[n * 4 + 3] = by), n++;\n  };\n  const quad = (ax, ay, qx, qy, bx, by) => {\n    const dev = (Math.hypot(ax - 2 * qx + bx, ay - 2 * qy + by) / 4) * fine;\n    const k = cl(ceil(sqrt(dev / 0.08)), 1, 24);\n    let px = ax, py = ay;\n    for (let i = 1; i \u003c= k; i++) {\n      const u = i / k, v = 1 - u;\n      const x = v * v * ax + 2 * u * v * qx + u * u * bx, y = v * v * ay + 2 * u * v * qy + u * u * by;\n      line(px, py, x, y);\n      (px = x), (py = y);\n    }\n  };\n  for (const p of cs) {\n    const m = p.length;\n    let s = p.findIndex((q) => q[2]);\n    let sx, sy;\n    if (s \u003c 0) (sx = (p[m - 1][0] + p[0][0]) / 2), (sy = (p[m - 1][1] + p[0][1]) / 2), (s = 0);\n    else (sx = p[s][0]), (sy = p[s][1]), (s = s + 1);\n    let cx = sx, cy = sy, ctl = null;\n    for (let k = 0; k \u003c m; k++) {\n      const q = p[(s + k) % m];\n      if (q[2]) {\n        if (ctl) quad(cx, cy, ctl[0], ctl[1], q[0], q[1]);\n        else line(cx, cy, q[0], q[1]);\n        (cx = q[0]), (cy = q[1]), (ctl = null);\n      } else if (ctl) {\n        const mx = (ctl[0] + q[0]) / 2, my = (ctl[1] + q[1]) / 2;\n        quad(cx, cy, ctl[0], ctl[1], mx, my);\n        (cx = mx), (cy = my), (ctl = q);\n      } else ctl = q;\n    }\n    if (ctl) quad(cx, cy, ctl[0], ctl[1], sx, sy);\n    else line(cx, cy, sx, sy);\n  }\n  return n;\n}\n\n// ---- Hinting. Each stem's two edges go to whole pixel lines with the\n// stem's width rounded, never under one pixel; an edge in an alignment zone\n// goes to the zone's line, which takes the overshoot with it at these sizes.\n// Every other point is moved in proportion between the edges either side of\n// it, the way TrueType's IUP instruction moves the points no instruction\n// touched, here per contour. `zones` are the zones the contour reaches.\nconst inZone = (z, u) => u >= min(z[0], z[1]) - 2 && u \u003c= max(z[0], z[1]) + 2;\nfunction edgeMap(stems, zones, f) {\n  const out = [];\n  const zoneOf = (u) => zones.find((z) => inZone(z, u)) || null;\n  for (const [a, b] of stems) {\n    const pa = f(a), pb = f(b), w = max(1, round(abs(pb - pa))), sg = pb > pa ? 1 : -1;\n    const za = zoneOf(a), zb = zoneOf(b);\n    let ha;\n    if (za) ha = round(f(za[0]));\n    else if (zb) ha = round(f(zb[0])) - sg * w;\n    else ha = round((pa + pb) / 2 - (sg * w) / 2);\n    out.push([a, ha], [b, ha + sg * w]);\n  }\n  for (const z of zones) out.push([z[0], round(f(z[0]))], [z[1], round(f(z[0]))]);\n  out.sort((p, q) => p[0] - q[0]);\n  // Keep the order: a later edge never crosses an earlier one.\n  const dec = f(1) \u003c f(0);\n  for (let i = 1; i \u003c out.length; i++) {\n    if (dec ? out[i][1] > out[i - 1][1] : out[i][1] \u003c out[i - 1][1]) out[i][1] = out[i - 1][1];\n  }\n  return out;\n}\nfunction mapEdge(E, f, u) {\n  const n = E.length;\n  if (!n) return f(u);\n  if (u \u003c= E[0][0]) return E[0][1] + f(u) - f(E[0][0]);\n  if (u >= E[n - 1][0]) return E[n - 1][1] + f(u) - f(E[n - 1][0]);\n  let i = 1;\n  while (E[i][0] \u003c u) i++;\n  const [ua, ha] = E[i - 1], [ub, hb] = E[i];\n  return ub > ua ? ha + ((u - ua) / (ub - ua)) * (hb - ha) : ha;\n}\n\n// The FreeType default LCD filter, in 256ths across five subpixels.\nconst FIR = [8, 77, 86, 77, 8].map((v) => v / 256);\n\nexport function setup(params) {\n  const sets = SETS.map((s) => {\n    const glyphs = s.g.map((ch) => {\n      const contours = GLYPHS[ch]().flat();\n      // A contour reaches a zone when one of its points or stem edges is in it.\n      const reach = (c, z) => c.p.some((q) => inZone(z, q[1])) || c.hy.some((e) => inZone(z, e[0]) || inZone(z, e[1]));\n      for (const c of contours) c.zones = s.zones ? ZONES.filter((z) => reach(c, z)) : [];\n      return { contours, box: bounds(contours) };\n    });\n    // Stack the two glyphs with a gap and centre the stack on the grid.\n    const GW = floor(W / s.zoom), GH = floor(H / s.zoom), sc = s.ppem / 1000;\n    const hs = glyphs.map((g) => (g.box.y1 - g.box.y0) * sc);\n    let y = (GH - hs[0] - hs[1] - s.gap) / 2;\n    glyphs.forEach((g, i) => {\n      g.cx = GW / 2;\n      g.cy = y + hs[i] / 2;\n      g.ux = (g.box.x0 + g.box.x1) / 2;\n      g.uy = (g.box.y0 + g.box.y1) / 2;\n      y += hs[i] + s.gap;\n    });\n    return { ...s, glyphs, GW, GH, X0: (W - GW * s.zoom) >> 1, Y0: (H - GH * s.zoom) >> 1 };\n  });\n  params.s = {\n    sets, set: 0, mode: 0, hint: 0, T: 0, hold: false,\n    seg: new Float32Array(4 * 6000), outl: new Float32Array(4 * 6000), nSeg: 0, nOut: 0,\n    cx: new Float32Array(256 * MAXC), cd: new Int8Array(256 * MAXC), cnt: new Int32Array(256),\n    bins: new Float32Array(43 * 64), bit: new Uint8Array(43 * 22), fir: new Float32Array(43 * 64),\n    mask: new Uint8Array(W * H), line: new Float32Array(W * H), offs: new Float32Array(1024), nOff: 0,\n  };\n}\n\n// Where glyph i of the set sits now: drift in pixels and a breathing scale.\nfunction pose(S, set, i) {\n  const T = S.T, ph = i * 2.1;\n  const g = set.glyphs[i];\n  const dx = 0.55 * sin(0.37 * T + ph) + 0.3 * sin(0.83 * T + 1.3 * ph);\n  const dy = 0.45 * sin(0.29 * T + 0.7 + ph) + 0.25 * sin(0.71 * T + 2 * ph);\n  const sc = (set.ppem / 1000) * (1 + 0.055 * sin(0.21 * T + 1.7 * ph));\n  return { ox: g.cx + dx, oy: g.cy + dy, sc, g };\n}\n\n// Place one glyph's contours in grid pixels, y down, hinted on the axes\n// asked. A hinted axis first puts the glyph's origin on a whole pixel, the\n// baseline on a pixel row as text lines are set, so the hinted glyph keeps\n// one shape wherever the outline drifts and moves only in whole pixels.\nfunction place(S, set, i, hint) {\n  const { ox, oy, sc, g } = pose(S, set, i);\n  const fx = (u) => ox + (u - g.ux) * sc, fy = (v) => oy - (v - g.uy) * sc;\n  return g.contours.map((c) => {\n    if (!hint) return c.p.map((q) => [fx(q[0]), fy(q[1]), q[2]]);\n    const y0 = fy(0), sy = (v) => fy(v) + round(y0) - y0;\n    const Ey = edgeMap(c.hy, c.zones, sy);\n    if (hint \u003c 2) return c.p.map((q) => [fx(q[0]), mapEdge(Ey, sy, q[1]), q[2]]);\n    const x0 = fx(0), sx = (u) => fx(u) + round(x0) - x0;\n    const Ex = edgeMap(c.hx, [], sx);\n    return c.p.map((q) => [mapEdge(Ex, sx, q[0]), mapEdge(Ey, sy, q[1]), q[2]]);\n  });\n}\n\n// ---- Scan conversion. Horizontal sample lines k = 0..L-1 sit at\n// y = (k + 0.5 - b) / a in the segments' units. On each, the crossings are\n// sorted and walked under nonzero winding, and span(k, x0, x1) gets every\n// run that is inside, exact in x.\nconst MAXC = 48;\nfunction scan(S, seg, nseg, L, a, b, span) {\n  const { cx, cd, cnt } = S;\n  cnt.fill(0, 0, L);\n  for (let s = 0; s \u003c nseg; s++) {\n    const x0 = seg[s * 4], y0 = seg[s * 4 + 1], x1 = seg[s * 4 + 2], y1 = seg[s * 4 + 3];\n    if (y0 === y1) continue;\n    const d = y1 > y0 ? 1 : -1, ya = min(y0, y1), yb = max(y0, y1);\n    const k0 = max(0, ceil(a * ya + b - 0.5)), k1 = min(L - 1, ceil(a * yb + b - 0.5) - 1);\n    for (let k = k0; k \u003c= k1; k++) {\n      if (cnt[k] >= MAXC) continue;\n      const y = (k + 0.5 - b) / a, j = k * MAXC + cnt[k]++;\n      cx[j] = x0 + ((y - y0) * (x1 - x0)) / (y1 - y0);\n      cd[j] = d;\n    }\n  }\n  for (let k = 0; k \u003c L; k++) {\n    const n = cnt[k], o = k * MAXC;\n    for (let i = 1; i \u003c n; i++) {\n      const x = cx[o + i], dd = cd[o + i];\n      let j = i - 1;\n      while (j >= 0 && cx[o + j] > x) (cx[o + j + 1] = cx[o + j]), (cd[o + j + 1] = cd[o + j]), j--;\n      (cx[o + j + 1] = x), (cd[o + j + 1] = dd);\n    }\n    let w = 0, start = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const was = w;\n      w += cd[o + i];\n      if (!was && w) start = cx[o + i];\n      else if (was && !w) span(k, start, cx[o + i]);\n    }\n  }\n}\n\n// Seven sample lines a pixel row (five on the finer Hangul grid). Coverage\n// is gathered per third of a pixel, so one pass gives the grey value of a\n// pixel and of its three subpixels. The middle line runs through the pixel\n// centres and gives the one-bit raster: TrueType's first rule, a pixel is\n// on when its centre is inside the outline.\nfunction rasterise(S, set) {\n  const { GW, GH } = set;\n  const SS = set.zoom > 3 ? 7 : 5, mid = (SS - 1) >> 1, NB = GW * 3;\n  const { bins, bit } = S;\n  bins.fill(0, 0, GH * NB);\n  bit.fill(0, 0, GH * GW);\n  scan(S, S.seg, S.nSeg, GH * SS, SS, 0, (k, xa, xb) => {\n    const row = (k / SS) | 0, u0 = cl(xa * 3, 0, NB), u1 = cl(xb * 3, 0, NB);\n    for (let q = floor(u0); q \u003c u1 && q \u003c NB; q++) bins[row * NB + q] += min(u1, q + 1) - max(u0, q);\n    if (k % SS === mid) for (let p = max(0, ceil(xa - 0.5)); p \u003c min(GW, ceil(xb - 0.5)); p++) bit[row * GW + p] = 1;\n  });\n  for (let i = 0; i \u003c GH * NB; i++) bins[i] /= SS;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.set = cl(round(k[0]), 0, SETS.length - 1);\n  S.mode = cl(round(k[2]), 0, 3);\n  S.hint = cl(round(k[3]), 0, 2);\n  if (input.btnPressed && input.btnPressed[1]) S.hold = !S.hold;\n  if (!S.hold) S.T += dt * cl(k[1], 0.05, 3);\n  const set = S.sets[S.set];\n  // The true outline and its off-curve points, for drawing, and the outline\n  // the raster is made from, which is the hinted one when hinting is on.\n  let n = 0;\n  S.nOff = 0;\n  for (let i = 0; i \u003c 2; i++) {\n    const cs = place(S, set, i, 0);\n    for (const c of cs) for (const q of c) if (!q[2] && S.nOff \u003c 512) (S.offs[S.nOff * 2] = q[0]), (S.offs[S.nOff * 2 + 1] = q[1]), S.nOff++;\n    n = flatten(cs, S.outl, n, set.zoom);\n  }\n  S.nOut = n;\n  if (S.hint) {\n    n = 0;\n    for (let i = 0; i \u003c 2; i++) n = flatten(place(S, set, i, S.hint), S.seg, n, set.zoom);\n  } else S.seg.set(S.outl.subarray(0, n * 4));\n  S.nSeg = n;\n  rasterise(S, set);\n}\n\n// An outline as a thin line on the LEDs, added into acc. Overlapping\n// contours leave edges inside the letter, so a stretch of line is drawn only\n// where one side of it is outside: the outline is first filled at one sample\n// per LED.\nfunction trace(S, set, sg, nseg, acc) {\n  const { mask } = S, z = set.zoom, X0 = set.X0, Y0 = set.Y0;\n  mask.fill(0);\n  scan(S, sg, nseg, H, z, Y0, (k, xa, xb) => {\n    for (let x = max(0, ceil(X0 + xa * z - 0.5)); x \u003c min(W, ceil(X0 + xb * z - 0.5)); x++) mask[k * W + x] = 1;\n  });\n  const inside = (x, y) => {\n    const i = round(x), j = round(y);\n    return i >= 0 && j >= 0 && i \u003c W && j \u003c H && mask[j * W + i];\n  };\n  acc.fill(0);\n  for (let s = 0; s \u003c nseg; s++) {\n    const ax = X0 + sg[s * 4] * z - 0.5, ay = Y0 + sg[s * 4 + 1] * z - 0.5;\n    const bx = X0 + sg[s * 4 + 2] * z - 0.5, by = Y0 + sg[s * 4 + 3] * z - 0.5;\n    const len = Math.hypot(bx - ax, by - ay);\n    if (len \u003c 1e-6) continue;\n    const nx = (by - ay) / len, ny = (ax - bx) / len, k = max(1, ceil(len / 0.3)), wt = len / k;\n    for (let i = 0; i \u003c k; i++) {\n      const u = (i + 0.5) / k, x = ax + u * (bx - ax), y = ay + u * (by - ay);\n      if (inside(x + nx * 1.2, y + ny * 1.2) && inside(x - nx * 1.2, y - ny * 1.2)) continue;\n      const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n      for (let q = 0; q \u003c 4; q++) {\n        const px = xi + (q & 1), py = yi + (q >> 1);\n        if (px \u003c 0 || py \u003c 0 || px >= W || py >= H) continue;\n        acc[py * W + px] += wt * (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy);\n      }\n    }\n  }\n}\n\n// The outline's pen: white over the stripes, rose over white pixels.\nconst PEN = [[255, 255, 255], [255, 64, 176], [255, 64, 176], [255, 64, 176]];\n\nexport function draw(display, params) {\n  const S = params.s;\n  const set = S.sets[S.set];\n  const { GW, GH, zoom: z, X0, Y0 } = set, NB = GW * 3;\n  const { bins, bit, fir, line, mode } = S;\n  // The subpixel values, filtered along each row across pixel borders.\n  if (mode \u003c 2)\n    for (let j = 0; j \u003c GH; j++)\n      for (let q = 0; q \u003c NB; q++) {\n        let v = 0;\n        for (let t = -2; t \u003c= 2; t++) {\n          const r = q + t;\n          if (r >= 0 && r \u003c NB) v += FIR[t + 2] * bins[j * NB + r];\n        }\n        fir[j * NB + q] = v;\n      }\n  trace(S, set, S.outl, S.nOut, line);\n  const pen = z > 3 ? 1.25 : 0.7, P = PEN[mode];\n  // The control points off the curve, one LED each.\n  for (let i = 0; i \u003c S.nOff; i++) {\n    const x = round(X0 + S.offs[i * 2] * z - 0.5), y = round(Y0 + S.offs[i * 2 + 1] * z - 0.5);\n    if (x >= 0 && y >= 0 && x \u003c W && y \u003c H) line[y * W + x] = max(line[y * W + x], 0.6 / pen);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      const gx = x - X0, gy = y - Y0;\n      if (gx >= 0 && gy >= 0 && gx \u003c GW * z && gy \u003c GH * z) {\n        const i = (gx / z) | 0, j = (gy / z) | 0, o = j * NB + i * 3;\n        if (mode === 0) {\n          // The LCD under a loupe: each third of the pixel a stripe of its own primary.\n          const sub = (((gx - i * z) * 3) / z) | 0, v = fir[o + sub] * 255;\n          if (sub === 0) r = v;\n          else if (sub === 1) g = v;\n          else b = v;\n        } else if (mode === 1) (r = fir[o] * 255), (g = fir[o + 1] * 255), (b = fir[o + 2] * 255);\n        else r = g = b = (mode === 2 ? (bins[o] + bins[o + 1] + bins[o + 2]) / 3 : bit[j * GW + i]) * 255;\n        // The grid: a faint dot at each pixel corner where nothing is lit.\n        if (gx % z === 0 && gy % z === 0 && r + g + b \u003c 40) r = g = b = 30;\n      }\n      const a = min(1, line[y * W + x] * pen);\n      if (a > 0) (r += (P[0] - r) * a), (g += (P[1] - g) * a), (b += (P[2] - b) * a);\n      display.setPixel(x, y, r, g, b);\n    }\n}\n","syllable-odometer":"// ===== Patternflow pattern =====\n// Title:   Syllable Odometer\n// Family:  type\n// Idea:    Three reels of Hangul jamo roll like the wheels of an odometer through all 11,172 modern syllables in Unicode order, the final fastest, then the vowel, then the initial, while a big syllable above them shows what they spell, solid when it is one of the 2,350 that KS C 5601-1987 encoded and hollow when it is not, two rolling counters count every syllable and the encoded ones, and a map of the current initial's 21 vowels by 28 finals lights up as the odometer passes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Hangul Syllables block, U+AC00 + (initial x 21 + vowel) x 28 + final (Unicode 2.0, 1996), against the 2,350 precomposed syllables (wansung) of KS C 5601-1987, now KS X 1001; the 9 by 11 combining Hangul face of Wongoji (pattern round 64); pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Initial=0..18, Skip=0..1\n//\n// Knob 1: Hue. Turns the palette round the wheel: at 0 the encoded syllables are amber and the missing ones blue-violet, at 0.25 green and rose, at 0.5 azure and lime; the reels and the first counter stay a pale tint of the encoded colour.\n// Knob 2: Speed. Steps a second: 0.5 at 0.2, 6 at the opening 2 (the first vowel row in 4.6 seconds, the 588 syllables of ㄱ in 94, all 11,172 in 30 minutes), 48 at 3.\n// Knob 3: Initial. Sets the slowest wheel by hand, 0 for ㄱ (가) up to 18 for ㅎ (하): the panel opens on the first syllable of that initial, and turned later the odometer spins on to it, starts a new map and counts on from there.\n// Knob 4: Skip. How long the odometer stays on a syllable KS C 5601 left out, as a share of a step: all of it at 0, 0.94 at the opening 0.06, none at 1, where it counts like a wansung machine that has only the 2,350 and spins over the other 8,822 between them (all 11,172 in 6.5 minutes at Speed 2).\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, asin, cos, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// ---- The 2,350. Bit i is syllable U+AC00 + i, six bits a character, low\n// bit first. Built offline by decoding the EUC-KR bytes B0A1..C8FE (rows\n// B0..C8, cells A1..FE: 25 rows of 94) and marking each syllable they give.\n// The decoded set has 2,350 syllables in Unicode order, misses 똠 (U+B620),\n// and per initial ㄱ..ㅎ holds 171 120 141 128 86 127 129 129 73 163 86 208\n// 135 82 112 107 106 105 142.\nconst A64 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nconst KS =\n  \"Tew/+EBsDMRAoAREAAwkFsnHRA7AXGwOSEBoAMZlrBTUwKQEBIDMRArAREgCwkHuGMRAwABAACwEBsAERAAATOwKQAAAAMZBrR\" +\n  \"XUwOyEBsDMQAAAAAAAwFBsDMBApAREAGSAAAAMVArDDEAMwAAACERAjABAAAwEBuGEQAwATEwEQEBMAEAAAATV4KCAAAAMRArA\" +\n  \"Xew+6EBsDMRAhAAAAAwGNsDORA7ATEwMREAAAMRBrwREAEAAAAAERALATEgKwkBsCEAAQABAAAQEBMAMQAjATcwaUEBAAMRBrQ\" +\n  \"X+4+4EBsDEAAAAAAAAwlNsKNRA7AREAMQEAAAMZFrKREAAQAAABERALABAAAwEBsCEAAQABAAIQEBoCERAhATWwKQAAAAMZA7B\" +\n  \"TEwO4EBsDAAAAAAAAAwENsDORA7ABAAEAAAAAMRAgABEAAQAAAAEBAAAAAAAwEBGCAAAAABAAAQEBMCAAAAATGwCQEBMAERArA\" +\n  \"TEwe8EBsDMBAoAAAAAwEBsDORArATEwOQEAoAMRArARAAIAAAABERArAREgKwEBsCEAAQABAAAwEBkCMRArATEwaGAAAAMRArA\" +\n  \"Tfwa6EBsHMQAgAAAAAwEFsGORA7ATEAuQAAAAsRBrARAAMAAAAAERAqAREgCwlHsiGRAKABAAAQEBAAERAJAREQCAAAAAMZB7K\" +\n  \"f+wKyEBsjMBACAAAAAwkFsGMZA7ATEgOSEAAAcRArARAAEQAAABMRADARAAAwkHsiFQAQABAAAwEBACERApATEwCAAAAAMRBrD\" +\n  \"TUwO4EBsDMAABAAAAAwkBkDEAAgADAwOAAAAAMRAjAAAAAAAAAAEAAAABAAIwEBkCAAAAAAAAAAAAAAEAAgAREwAAAAAAMRArA\" +\n  \"bewOyEBsDMRArAREQIwnNsDNRA7ATEwOQEBACcRBrITEAIQEBkBERALATEwKwkBsqFAAQATEQIwEBsCMQApATMwKAAAAAMZgrQ\" +\n  \"bEwM4EBMDAAAgAAAAAwEFMDERAAAAAAAAEAAAMZBjATAAEQAAABERADABAAAwEBMCEAAQABAAAQEAAAAAAgATU4AQEBEAMRArA\" +\n  \"zd4O2EBsDMRCroREgAwsH8XNRArAX0wPeEBsBMxlrCTEwOwEAkCMRArATEwKwEHsCMRAzATEwIwEBsCMRArCTE06fEBkAMxh7R\" +\n  \"TXwewEBsDMVAhAREAAwEFsGMRArAREwMQAAAAMRBrjDEgKQAAADERArATAAIwEHsCEAAQABAAAwEBsAERABATEwKAAAAAMZBrZ\" +\n  \"TlwOwEBsDEBAgAAAAAwEBsDEAAgABAAEAAAAAMRArCDEAEQAAABERADAAAAIwEBMCEAAwAAAAAQAAAAEAAAABAQKAAAAAMRAjh\" +\n  \"TFwewEBsDEVAhAAAAAwEBsDMRArARAAEQEAACMRArAREAIAAAAAERArABAQAwEBsCEAAQARAAAQEBsCERAhATEwKAAAAAM5ArA\" +\n  \"TEwKwEBsDMAAgAAAAAwkBsDMRArAREwOQAAAAMRArATEQIQAAACEQAAABAAAwEBsCERAgABAAIwEBsCERABATEwIAAAAAMRArA\" +\n  \"TMwOwEBsDEAAgAAAAAwEFsDMRArARAAEQEAAAMRArQRAAAQAAAAEBAoABAAAwEBsCEAAQABAAAwEBMCERAhATWwCQEBMAMRArA\" +\n  \"XUwOyEBsDMAAAAAAAAwEBsDMRArAREwMQABoAMRArABAAIAAAAAEBAAAREgCwkFsCEAAgAAAAAQEBkAERApAREwCAAAAAMRArA\" +\n  \"TEyKwEBsDEAAgAAAAAwEFsCMRArATEwOQEBIAMRIrITEAKwEAgCMRAqAREgCwEhkCERAhATEAIwEBsCMRApATPwKSEBMCMRArA\";\nconst ALL = 11172;\n\n// ---- The face: Wongoji's 9 by 11 combining Hangul (pattern round 64).\n// Jamo are strokes, lists of points in a box w by h; a syllable puts them in\n// boxes that depend on its vowel and on whether it has a final.\nconst INI = \"g gg n d dd r m b bb s ss o j jj c k t p h\".split(\" \");\nconst FIN = \". g gg gs n nj nh d r rg rm rb rs rt rp rh m b bs s ss o j c k t p h\".split(\" \");\n\nfunction ring(w, h, ox, oy) {\n  const rw = min(w, h + 2), rh = min(h, w + 1);\n  ox += (w - rw) >> 1;\n  oy += (h - rh) >> 1;\n  const R = rw - 1, B = rh - 1, c = R >> 1;\n  const pts = rh \u003c= 2 ? [[1, 0], [R - 1, 0], [R - 1, B], [1, B]] : [[c, 0], [1, 0], [0, 1], [0, B - 1], [1, B], [R - 1, B], [R, B - 1], [R, 1], [R - 1, 0], [c + 1, 0]];\n  return pts.map(([x, y]) => [x + ox, y + oy]);\n}\nfunction legs(w, h, y0) {\n  const c = (w - 1) >> 1, d = h - 1 - y0;\n  const xl = max(0, round(c - 1.3 * d)), xr = min(w - 1, round(c + (w % 2 ? 0 : 1) + 1.3 * d));\n  return [[[c, y0], [xl, h - 1]], [[c, y0 + max(1, round(d / 3))], [xr, h - 1]]];\n}\nfunction cons(k, w, h, tail) {\n  const c = (w - 1) >> 1, m = (h - 1) >> 1, S = [];\n  switch (k) {\n    case \"g\":\n      S.push(tail && h >= 6 ? [[0, 0], [w - 1, 0], [w - 1, h - 3], [w - 3, h - 1]] : [[0, 0], [w - 1, 0], [w - 1, h - 1]]);\n      break;\n    case \"n\":\n      S.push([[0, 0], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"d\":\n      S.push([[0, 0], [w - 1, 0]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"r\":\n      if (h >= 5) S.push([[0, 0], [w - 1, 0], [w - 1, m]], [[0, m], [w - 2, m]], [[0, m + 1], [0, h - 1], [w - 1, h - 1]]);\n      else {\n        const z = w >> 1;\n        S.push([[0, 0], [w - 1, 0], [w - 1, 1], [z, 1]], [[z, 2], [0, 2], [0, h - 1], [w - 1, h - 1]]);\n      }\n      break;\n    case \"m\":\n      S.push([[0, 0], [0, h - 1]], [[0, 0], [w - 1, 0], [w - 1, h - 1]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"b\":\n      S.push([[0, 0], [0, h - 1]], [[w - 1, 0], [w - 1, h - 1]], [[1, m], [w - 2, m]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"s\":\n      S.push(...legs(w, h, 0));\n      break;\n    case \"o\":\n      S.push(ring(w, h, 0, 0));\n      break;\n    case \"j\":\n      S.push([[0, 0], [w - 1, 0]], ...legs(w, h, 1));\n      break;\n    case \"c\":\n      S.push([[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ...legs(w, h, 2));\n      break;\n    case \"k\":\n      S.push([[0, 0], [w - 1, 0], [w - 1, h - 1]], [[0, h >> 1], [w - 2, h >> 1]]);\n      break;\n    case \"t\":\n      S.push([[0, 0], [w - 1, 0]], [[1, m], [w - 1, m]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"p\": {\n      const a = w >= 5 ? 1 : 0;\n      S.push([[0, 0], [w - 1, 0]], [[a, 1], [a, h - 2]], [[w - 1 - a, 1], [w - 1 - a, h - 2]], [[0, h - 1], [w - 1, h - 1]]);\n      break;\n    }\n    case \"h\":\n      S.push(w >= 7 ? [[c - 1, 0], [c + 1, 0]] : [[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ring(w, h - 2, 0, 2));\n      break;\n  }\n  return S;\n}\n// One consonant, or a double or cluster side by side, in a box at (x, y).\nfunction group(key, x, y, w, h, tail) {\n  const parts = [...key], out = [];\n  const put = (list, dx) => list.forEach((s) => out.push(s.map(([a, b]) => [a + x + dx, b + y])));\n  if (parts.length === 1) put(cons(parts[0], w, h, tail), 0);\n  else {\n    const w1 = (w - 1) >> 1;\n    put(cons(parts[0], w1, h, false), 0);\n    put(cons(parts[1], w - 1 - w1, h, false), w1 + 1);\n  }\n  return out;\n}\n// Vowels, as in Wongoji: vertical ones are the initial's width, then lines\n// [0, x] and ticks [1, x0, x1, slot]; horizontal ones ticks above [2, x],\n// bars [3, x0, x1] and stems below [4, x]; compounds have both.\nconst VV = {\n  0: [5, [0, 6], [1, 7, 8, 0]],\n  1: [5, [0, 6], [1, 7, 7, 0], [0, 8]],\n  2: [5, [0, 6], [1, 7, 8, 1], [1, 7, 8, 2]],\n  3: [5, [0, 6], [1, 7, 7, 1], [1, 7, 7, 2], [0, 8]],\n  4: [5, [1, 6, 7, 0], [0, 8]],\n  5: [4, [1, 5, 5, 0], [0, 6], [0, 8]],\n  6: [5, [1, 6, 7, 1], [1, 6, 7, 2], [0, 8]],\n  7: [4, [1, 5, 5, 1], [1, 5, 5, 2], [0, 6], [0, 8]],\n  20: [6, [0, 7]],\n};\nconst HV = { 8: [[2, 4], [3, 0, 8]], 12: [[2, 2], [2, 6], [3, 0, 8]], 13: [[3, 0, 8], [4, 4]], 17: [[3, 0, 8], [4, 2], [4, 6]], 18: [[3, 0, 8]] };\nconst MV = {\n  9: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 8, 0]]],\n  10: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 7, 0], [0, 8]]],\n  11: [6, [[2, 2], [3, 0, 5]], [[0, 7]]],\n  14: [5, [[3, 0, 4], [4, 2]], [[1, 5, 6, 3], [0, 8]]],\n  15: [4, [[3, 0, 3], [4, 2]], [[1, 5, 5, 3], [0, 6], [0, 8]]],\n  16: [6, [[3, 0, 5], [4, 3]], [[0, 7]]],\n  19: [6, [[3, 0, 5]], [[0, 7]]],\n};\nconst FREE = new Set([\"g\", \"gg\", \"s\", \"ss\", \"j\", \"jj\", \"c\", \"k\"]);\nconst NEED4 = new Set([\"r\", \"b\", \"bb\", \"c\", \"k\", \"t\", \"h\"]);\n\nfunction vparts(parts, y0, y1, bar, out) {\n  const mid = (y0 + y1) >> 1;\n  for (const p of parts) {\n    if (p[0] === 0) out.push([[p[1], y0], [p[1], y1]]);\n    else {\n      const y = p[3] === 0 ? mid : p[3] === 1 ? mid - 1 : p[3] === 2 ? mid + 1 : bar + 1;\n      out.push([[p[1], y], [p[2], y]]);\n    }\n  }\n}\nfunction hparts(parts, bar, stem, out) {\n  for (const p of parts) {\n    if (p[0] === 2) out.push([[p[1], bar - 1], [p[1], bar - 1]]);\n    else if (p[0] === 3) out.push([[p[1], bar], [p[2], bar]]);\n    else out.push([[p[1], bar + 1], [p[1], bar + stem]]);\n  }\n}\n\n// Syllable s (0..11171) as three stroke lists: initial, vowel, final.\nfunction jamo(s) {\n  const ci = floor(s / 588), vi = floor((s % 588) / 28), fi = s % 28;\n  const ini = INI[ci], has = fi > 0, vow = [];\n  let box;\n  const fbox = FIN[fi].length > 1 ? [0, 7, 9, 4] : [1, 7, 7, 4];\n  if (VV[vi]) {\n    const [iw, ...parts] = VV[vi];\n    box = has ? [0, 0, iw, 5] : [0, 2, iw, 7];\n    vparts(parts, has ? 0 : 1, has ? 5 : 9, 0, vow);\n  } else if (HV[vi]) {\n    const up = vi === 8 || vi === 12, down = vi === 13 || vi === 17;\n    let bar = 7;\n    if (!has) {\n      box = [1, 1, 7, 5];\n      if (up) bar = 8;\n    } else if (up) {\n      box = FREE.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = 5;\n    } else if (down) {\n      box = NEED4.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = box[3] + 1;\n    } else {\n      box = [1, 0, 7, 4];\n      bar = 5;\n    }\n    hparts(HV[vi], bar, has ? 1 : 2, vow);\n  } else {\n    const [iw, hp, vp] = MV[vi];\n    const up = hp[0][0] === 2, flat = hp.length === 1;\n    let bar;\n    if (!has) {\n      box = [0, 1, iw, flat ? 5 : 4];\n      bar = up || flat ? 7 : 6;\n    } else {\n      box = [0, 0, iw, flat ? 4 : 3];\n      bar = up || flat ? 5 : 4;\n    }\n    hparts(hp, bar, has ? 1 : 2, vow);\n    vparts(vp, has ? 0 : 1, has ? 5 : 9, bar, vow);\n  }\n  const tail = !has && VV[vi] && (ini === \"g\" || ini === \"k\");\n  return [group(ini, box[0], box[1], box[2], box[3], tail), vow, has ? group(FIN[fi], fbox[0], fbox[1], fbox[2], fbox[3], false) : []];\n}\n\n// Strokes to LEDs: a bitmap bw by bh, and the diagonal steps inside each\n// stroke, which the big glyph joins (the legs of ㅅ, ㅈ, ㅊ).\nfunction bitmap(strokes, bw, bh) {\n  const bits = new Uint8Array(bw * bh), diag = [];\n  for (const st of strokes) {\n    let lx = null, ly = null;\n    for (let i = 0; i \u003c st.length; i++) {\n      const [x0, y0] = st[i], [x1, y1] = st[min(i + 1, st.length - 1)];\n      const n = max(abs(x1 - x0), abs(y1 - y0));\n      for (let j = 0; j \u003c= n; j++) {\n        const x = round(x0 + ((x1 - x0) * j) / (n || 1)), y = round(y0 + ((y1 - y0) * j) / (n || 1));\n        if (x === lx && y === ly) continue;\n        if (x >= 0 && y >= 0 && x \u003c bw && y \u003c bh) bits[y * bw + x] = 1;\n        if (lx !== null && x !== lx && y !== ly) diag.push([lx, ly, x, y]);\n        lx = x;\n        ly = y;\n      }\n    }\n  }\n  return { bits, diag };\n}\n\n// ---- Layout.\n// The big glyph: the 9 by 11 face drawn 5 LEDs a column and 4 a row, each\n// lit LED of the face a round dot joined to its lit neighbours.\nconst GX = 9.5, GY = 2, SX = 5, SY = 4, GR = 2.0, GH = 46;\n// The counters, the reels and the map.\nconst CY = 49;\nconst RY = 70, RH = 14, RT = 15, RW = 20, RXS = [1, 22, 43], P = 21;\nconst MX = 4, MY = 86;\n\n// A row of the 3 by 5 digits, each row a 3-bit number, left bit high.\nconst DIG = [\"75557\", \"26227\", \"71747\", \"71317\", \"55711\", \"74717\", \"74757\", \"71122\", \"75757\", \"75717\"].map((s) => [...s].map(Number));\n\n// One reel's tape: each symbol drawn two LEDs a dot, centred in its own\n// stretch of P rows.\nfunction tape(symbols) {\n  const T = new Float32Array(RW * symbols.length * P);\n  symbols.forEach((strokes, k) => {\n    if (!strokes) {\n      // The empty final: a dotted slot.\n      for (let i = 0; i \u003c 7; i++)\n        for (let j = 0; j \u003c 7; j++) {\n          if ((i > 0 && i \u003c 6 && j > 0 && j \u003c 6) || (i + j) % 2) continue;\n          for (let a = 0; a \u003c 2; a++) for (let b = 0; b \u003c 2; b++) T[(k * P + 3 + 2 * j + b) * RW + 3 + 2 * i + a] = 0.55;\n        }\n      return;\n    }\n    const { bits } = bitmap(strokes, 9, 11);\n    let x0 = 9, x1 = -1, y0 = 11, y1 = -1;\n    for (let y = 0; y \u003c 11; y++)\n      for (let x = 0; x \u003c 9; x++)\n        if (bits[y * 9 + x]) {\n          x0 = min(x0, x);\n          x1 = max(x1, x);\n          y0 = min(y0, y);\n          y1 = max(y1, y);\n        }\n    const ox = (RW >> 1) - (x1 + x0 + 1), oy = k * P + (P >> 1) - (y1 + y0 + 1);\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        if (!bits[y * 9 + x]) continue;\n        for (let a = 0; a \u003c 2; a++) for (let b = 0; b \u003c 2; b++) T[(oy + 2 * y + b) * RW + ox + 2 * x + a] = 1;\n      }\n  });\n  return T;\n}\n\nexport function setup(params) {\n  const S = (params.s = { n: 0, p: 0, acc: 0, k3: -1, shown: -1, mapC: -1, fade: 0, rk: -1 });\n  // The set, and for each syllable how many of the 2,350 come at or before it.\n  S.ks = new Uint8Array(ALL);\n  S.rank = new Uint16Array(ALL);\n  let i = 0;\n  for (let c = 0; c \u003c KS.length; c++) {\n    const v = A64.indexOf(KS[c]);\n    for (let b = 0; b \u003c 6 && i \u003c ALL; b++) S.ks[i++] = (v >> b) & 1;\n  }\n  for (let s = 0, r = 0; s \u003c ALL; s++) S.rank[s] = r += S.ks[s];\n  // The three tapes: 19 initials, 21 vowels (as they stand beside or under\n  // ㅇ), 28 finals with the empty one first.\n  const box = (key) => group(key, key.length > 1 ? 0 : 1, 2, key.length > 1 ? 9 : 7, 7, false);\n  S.tapes = [\n    tape(INI.map(box)),\n    tape(Array.from({ length: 21 }, (_, v) => jamo(11 * 588 + v * 28)[1])),\n    tape(FIN.map((f, k) => (k ? box(f) : null))),\n  ];\n  S.row = new Float32Array(RW);\n  S.G = new Float32Array(W * GH);\n  S.E = new Float32Array(W * GH);\n  S.B = new Float32Array(W * GH);\n  S.Hl = new Float32Array(W * GH);\n  S.F = new Float32Array(W * H * 3);\n}\n\n// The big glyph of syllable s into S.G (coverage) and S.E (its outline).\nfunction bigGlyph(S, s) {\n  const { bits, diag } = bitmap(jamo(s).flat(), 9, 11);\n  const segs = diag.slice();\n  for (let y = 0; y \u003c 11; y++)\n    for (let x = 0; x \u003c 9; x++) {\n      if (!bits[y * 9 + x]) continue;\n      segs.push([x, y, x, y]);\n      if (x \u003c 8 && bits[y * 9 + x + 1]) segs.push([x, y, x + 1, y]);\n      if (y \u003c 10 && bits[(y + 1) * 9 + x]) segs.push([x, y, x, y + 1]);\n    }\n  const G = S.G;\n  G.fill(0);\n  for (const [a, b, c, d] of segs) {\n    const ax = GX + (a + 0.5) * SX, ay = GY + (b + 0.5) * SY, bx = GX + (c + 0.5) * SX, by = GY + (d + 0.5) * SY;\n    const dx = bx - ax, dy = by - ay, L = dx * dx + dy * dy;\n    for (let y = max(0, floor(min(ay, by) - GR - 1)); y \u003c= min(GH - 1, floor(max(ay, by) + GR + 1)); y++)\n      for (let x = max(0, floor(min(ax, bx) - GR - 1)); x \u003c= min(W - 1, floor(max(ax, bx) + GR + 1)); x++) {\n        const px = x + 0.5 - ax, py = y + 0.5 - ay;\n        const u = L ? cl((px * dx + py * dy) / L, 0, 1) : 0;\n        const ex = px - u * dx, ey = py - u * dy;\n        const v = cl(GR + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n        if (v > G[y * W + x]) G[y * W + x] = v;\n      }\n  }\n  // The outline: lit LEDs with an unlit neighbour.\n  const E = S.E;\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const g = G[y * W + x];\n      let lo = 1;\n      if (g > 0.3) for (const [ox, oy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) lo = min(lo, x + ox \u003c 0 || x + ox >= W || y + oy \u003c 0 || y + oy >= GH ? 0 : G[(y + oy) * W + x + ox]);\n      E[y * W + x] = g > 0.3 && lo \u003c 0.5 ? g : 0;\n    }\n  // A soft halo round the strokes, for the encoded syllables: a box blur\n  // five LEDs wide, across and then down.\n  const B = S.B, Hl = S.Hl;\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let i = -2; i \u003c= 2; i++) s += x + i >= 0 && x + i \u003c W ? G[y * W + x + i] : 0;\n      B[y * W + x] = s / 5;\n    }\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let i = -2; i \u003c= 2; i++) s += y + i >= 0 && y + i \u003c GH ? B[(y + i) * W + x] : 0;\n      Hl[y * W + x] = max(0, s / 5 - G[y * W + x]);\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  const speed = cl(k[1], 0.2, 3);\n  const d = speed - 2;\n  S.rate = 6 * exp(1.83 * d + 0.25 * d * d);\n  S.skip = cl(k[3], 0, 1);\n  // The Initial knob sets the slowest wheel when it is turned; the first\n  // frame starts there without spinning.\n  const c = round(cl(k[2], 0, 18));\n  if (c !== S.k3) {\n    const base = floor(S.n / ALL) * ALL;\n    let to = base + c * 588;\n    if (S.k3 >= 0 && to \u003c= S.n) to += ALL;\n    if (S.k3 \u003c 0) S.p = to;\n    S.n = to;\n    S.acc = 0;\n    S.k3 = c;\n  }\n  // Count: the odometer stays a whole step on each syllable, on a missing\n  // one 1 - Skip of a step.\n  const stay = (s) => (S.ks[s % ALL] ? 1 : 1 - S.skip);\n  S.acc += dt * S.rate;\n  for (let i = 0; i \u003c 4000 && S.acc >= stay(S.n); i++) {\n    S.acc -= stay(S.n);\n    S.n++;\n  }\n  // The wheels rest on the count and turn to the next syllable in the last\n  // 0.08 seconds of the stay (the whole stay when stays are shorter),\n  // then a quick spring smooths them, so a jump spins through what lies\n  // between.\n  const g = S.n % ALL, next = (g + 1) % ALL, cost = stay(g);\n  const w = cost > 0 ? min(1, (0.08 * S.rate) / cost) : 1, phi = cost > 0 ? cl(S.acc / cost, 0, 1) : 1;\n  const e = cl((phi - 1 + w) / w, 0, 1), turn = w >= 1 ? e : e * e * (3 - 2 * e);\n  const spring = 1 - exp(-dt * 30);\n  S.p += (S.n + turn - S.p) * spring;\n  if (abs(S.n + turn - S.p) \u003c 0.002) S.p = S.n + turn;\n  // The glyph and the map read the count.\n  if (g !== S.shown) {\n    S.shown = g;\n    bigGlyph(S, g);\n  }\n  // A new initial starts a new map; the last one fades out over it.\n  const ci = floor(g / 588);\n  if (ci !== S.mapC) {\n    S.mapOld = S.mapC;\n    S.oldAt = S.mapC === (ci + 18) % 19 ? 587 : S.at;\n    S.mapC = ci;\n    S.fade = S.mapOld \u003c 0 ? 0 : 1;\n  }\n  S.at = g % 588;\n  // The count of the 2,350 turns with the wheels when the next syllable is\n  // one of them, and starts again after 힣.\n  const rk = S.rank[g] + (S.ks[next] ? turn : 0);\n  S.rk = rk \u003c S.rk - 50 || S.rk \u003c 0 ? rk : S.rk + (rk - S.rk) * spring;\n  if (abs(rk - S.rk) \u003c 0.002) S.rk = rk;\n  S.fade = max(0, S.fade - dt / 0.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.shown \u003c 0) return;\n  const F = S.F;\n  F.fill(0);\n  const hue = 0.1 + S.hue;\n  const lit = hsv(hue, 0.85, 255), miss = hsv(hue + 0.6, 0.6, 255), pale = hsv(hue + 0.02, 0.3, 255);\n  const add = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    F[o] += c[0] * a;\n    F[o + 1] += c[1] * a;\n    F[o + 2] += c[2] * a;\n  };\n  const g = S.shown, inSet = S.ks[g] === 1;\n\n  // The big glyph: solid when encoded, a hollow outline when not.\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      if (inSet) {\n        const v = S.G[y * W + x] + 0.3 * S.Hl[y * W + x];\n        if (v > 0) add(x, y, lit, v);\n      } else {\n        const v = S.E[y * W + x];\n        if (v > 0) add(x, y, miss, 0.75 * v);\n      }\n    }\n\n  // The counters, rolling like the reels: the syllable's place among all\n  // 11,172, and among the 2,350. A digit turns while every digit to its\n  // right turns from 9 to 0.\n  const roll = (val, digits, x0, c, a) => {\n    const fl = floor(val), fr = val - fl;\n    for (let d = 0, m = 1; d \u003c digits; d++, m *= 10) {\n      const base = floor(fl / m) % 10, sh = round((fl % m === m - 1 ? fr : 0) * 7), x = x0 + (digits - 1 - d) * 4;\n      for (const [dig, oy] of [[base, -sh], [(base + 1) % 10, 7 - sh]])\n        for (let r = 0; r \u003c 5; r++) {\n          if (r + oy \u003c 0 || r + oy > 4) continue;\n          for (let b = 0; b \u003c 3; b++) if (DIG[dig][r] & (4 >> b)) add(x + b, CY + r + oy, c, a);\n        }\n    }\n  };\n  roll(min(ALL, (S.p % ALL) + 1), 5, 1, pale, 0.8);\n  roll(S.rk, 4, 48, inSet ? lit : miss, inSet ? 1 : 0.5);\n\n  // The reels: each a wheel of radius RT seen through a window 2 RH tall,\n  // its symbols squeezed and dimmed towards the window's edges.\n  const p = S.p, fr = p - floor(p), q = floor(p);\n  const pos = [\n    (floor(q / 588) % 19) + (q % 588 === 587 ? fr : 0),\n    (floor(q / 28) % 21) + (q % 28 === 27 ? fr : 0),\n    (q % 28) + fr,\n  ];\n  const len = [19, 21, 28];\n  for (let r = 0; r \u003c 3; r++) {\n    const T = S.tapes[r], span = len[r] * P, uc = pos[r] * P + (P >> 1);\n    for (let y = RY - RH; y \u003c RY + RH; y++) {\n      let shade = 0;\n      const row = S.row.fill(0);\n      for (let s = 0; s \u003c 4; s++) {\n        const dy = y + (s + 0.5) / 4 - RY, th = asin(cl(dy / RT, -1, 1));\n        let u = floor(uc + RT * th) % span;\n        if (u \u003c 0) u += span;\n        const w = cos(th);\n        shade += w / 4;\n        for (let x = 0; x \u003c RW; x++) row[x] += (T[u * RW + x] * w) / 4;\n      }\n      for (let x = 0; x \u003c RW; x++) {\n        add(RXS[r] + x, y, pale, 0.11 * shade + 0.89 * row[x]);\n      }\n    }\n  }\n\n  // The map: the current initial's 21 vowels down and 28 finals across.\n  // Ahead of the odometer the encoded cells wait faintly; behind it they\n  // burn, fresh ones brighter for a moment.\n  const ci = S.mapC, at = g % 588;\n  const cell = (x, y, c, a) => {\n    add(x, y, c, a);\n    add(x + 1, y, c, a);\n    add(x, y + 1, c, a * 0.45);\n    add(x + 1, y + 1, c, a * 0.45);\n  };\n  for (let v = 0; v \u003c 21; v++)\n    for (let f = 0; f \u003c 28; f++) {\n      const k = v * 28 + f, x = MX + 2 * f, y = MY + 2 * v, on = S.ks[ci * 588 + k];\n      let c, a;\n      if (k === at) (c = [255, 255, 255]), (a = 1);\n      else if (k > at) (c = pale), (a = on ? 0.24 : 0.06);\n      else {\n        const age = (at - k) / S.rate, glow = exp(-age / 0.7);\n        c = on ? lit : miss;\n        a = on ? 0.75 + 0.25 * glow : 0.2 + 0.3 * glow;\n      }\n      if (S.fade > 0 && k \u003c= S.oldAt) {\n        const o = S.ks[S.mapOld * 588 + k];\n        cell(x, y, o ? lit : miss, (o ? 0.9 : 0.2) * S.fade * S.fade);\n      }\n      cell(x, y, c, a);\n    }\n  // The current vowel row, marked at both sides.\n  for (const x of [1, 2, 61, 62]) add(x, MY + 2 * floor(at / 28), pale, 0.7);\n\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(min(255, F[o])), round(min(255, F[o + 1])), round(min(255, F[o + 2])));\n}\n","wilkinson-polynomial":"// ===== Patternflow pattern =====\n// Title:   Wilkinson's Polynomial\n// Family:  algo\n// Idea:    The twenty roots of (x - 1)(x - 2)...(x - 20) stand up the panel as beads, and as a change in the x^19 coefficient sweeps on a log scale up past Wilkinson's 2^-23 and back, the upper ten meet in pairs and fly apart sideways into the complex plane leaving arcs, inside a sparkling nebula of everywhere a root can be pushed by nudging every coefficient a little, whose bright core fills a fifth of the panel while the roots sit on the integers and shrinks to specks once they have split.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Wilkinson's polynomial (James H. Wilkinson, 1959; \"The perfidious polynomial\", 1984), the Ehrlich-Aberth simultaneous root iteration (Louis W. Ehrlich, 1967; Oliver Aberth, 1973), pseudozero sets (Ronald G. Mosier, 1986; Kim-Chuan Toh and Lloyd N. Trefethen, 1994), pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phase=0..1, Cloud=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the arcs and cloud dots run from purple at root 1 to rose at root 20 and the nebula is blue at its edge and cyan in its core; at 0.33 the arcs are yellow to green on a red and magenta nebula, at 0.66 cyan to blue on green and amber.\n// Knob 2: Speed. At 2 the change climbs from 2^-35 to 2^-21 in 6 seconds and comes back down in 6, lingering at both ends; at 0.2 a round takes two minutes, at 3 eight seconds.\n// Knob 3: Phase. Which way the change pushes, as a turn of the complex plane: a_19 becomes -210 - eps e^(2 pi i Phase). At 0 it is Wilkinson's: roots 16 and 17 meet first, at eps = 1.42e-10, then 14 and 15, 18 and 19, 12 and 13, and 10 and 11 at 1.91e-8, so at 2^-23 there are five pairs, the widest 16.73 +- 2.81i. At 0.5 eps pushes the other way and the neighbours change partners: 15 and 16 meet first, then 17-18, 13-14, 19-20, 11-12, and 9-10 just past 2^-23. At 0.25 and 0.75 eps is imaginary, there are no conjugate pairs, and no two roots come closer than 0.91: they peel off the axis one by one, alternately to the left and to the right.\n// Knob 4: Cloud. delta, the size of the random relative nudges given to every coefficient below the top one, from 2^-45 at 0 to 2^-39 at 1; at the start 2^-44.6, about 330 times the rounding error of a double. There, with the roots on the integers, the dots of roots 13 to 16 land up to 1.7 away while root 5 moves 1e-4 and root 1 1e-11, and the delta set the clouds stay inside covers 19% of the panel; at 2^-23 it covers 2.4%. At 1 it covers 46% at the bottom of the sweep and still 45% at 2^-23.\n// Buttons: K1 tap eases the change to exactly 2^-23 and holds it there for three seconds. K3 tap moves the change one power down, x^19, x^18 and on to the constant term 20!, then x^19 again: the roots first go home, then the sweep starts over on the new coefficient, scaled so that it pushes its most sensitive root as hard as 2^-23 pushes root 16; at x^0 the pairs run from 3-4 to 17-18.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, exp, log2, cos, sin, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = () => Math.random();\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The plane: the real axis runs up the panel, RY rows to a unit, with\n// Re = RE0 at the bottom edge, so root k sits on the middle of row\n// 123 - 6 (k - 1); the imaginary axis runs across, CX columns to a unit,\n// with Im = 0 on the middle of column 31.\nconst RY = 6, RE0 = 0.25, CX = 9, XC = 31.5;\nconst toX = (im) => XC + im * CX, toY = (re) => H - (re - RE0) * RY;\n\n// The coefficients a_j of p(x) = (x - 1)...(x - 20), lowest first: a_19 =\n// -210, a_0 = 20!. In doubles a_3 to a_7 are already rounded, which is\n// harmless here: they only scale the nudges and the level below.\nconst A = new Float64Array(21);\nA[0] = 1;\nfor (let k = 1; k \u003c= 20; k++) for (let j = k; j >= 0; j--) A[j] = (j ? A[j - 1] : 0) - k * A[j];\nconst AB = A.map(abs);\n// SENS[k]: the largest first-order shift a relative change of a_k gives any\n// root, |a_k| r^k / |p'(r)| at its worst r (root 16 for a_19, root 10 for\n// a_0). A K3 tap moves the change to another power, scaled by these.\nconst SENS = new Float64Array(20);\nfor (let k = 0; k \u003c 20; k++)\n  for (let r = 1; r \u003c= 20; r++) {\n    let d = 1;\n    for (let j = 1; j \u003c= 20; j++) if (j !== r) d *= abs(r - j);\n    SENS[k] = max(SENS[k], (AB[k] * r ** k) / d);\n  }\n\n// The sweep runs log2 of the change from LO to HI and back, easing at both\n// ends. At LO every root is within 0.07 of home (root 16 the farthest, under\n// half a row); at HI root 20 is at 21.39 and the widest pair at\n// 16.77 +- 3.49i, inside the panel's 31 columns either side.\nconst LO = -35, HI = -21, WILK = -23;\n\n// The Ehrlich-Aberth iteration for all roots of p(z) + sum C_j z^j, j \u003c 20,\n// at once, from the starting points in Z (re, im pairs), at most `iters`\n// sweeps, roots with index below `from` held where they are. p and p' come\n// from the product form, which stays accurate next to the roots where the\n// expanded coefficients would cancel to nothing. Run from rest with eps =\n// 2^-23 it gives Wilkinson's table to nine places: 1 to 4 to the last\n// digit, 4.999999928, 6.000006944, 6.999697234, 8.007267603, 8.917250249,\n// 10.095266145 +- 0.643500904i, 11.793633881 +- 1.652329728i,\n// 13.992358137 +- 2.518830070i, 16.730737466 +- 2.812624894i,\n// 19.502439400 +- 1.940330347i and 20.846908101. STEP[i] keeps each root's\n// last step squared.\nconst STEP = new Float64Array(20);\nfunction aberth(Z, Cr, Ci, iters, from) {\n  let big = 0;\n  for (let it = 0; it \u003c iters; it++) {\n    big = 0;\n    for (let i = from; i \u003c 20; i++) {\n      const zr = Z[2 * i], zi = Z[2 * i + 1];\n      let pr = 1, pi = 0, dr = 0, di = 0;\n      for (let k = 1; k \u003c= 20; k++) {\n        const ur = zr - k;\n        const t = dr * ur - di * zi + pr;\n        di = dr * zi + di * ur + pi;\n        dr = t;\n        const s = pr * ur - pi * zi;\n        pi = pr * zi + pi * ur;\n        pr = s;\n      }\n      let qr = 0, qi = 0, er = 0, ei = 0;\n      for (let j = 19; j >= 0; j--) {\n        const t = er * zr - ei * zi + qr;\n        ei = er * zi + ei * zr + qi;\n        er = t;\n        const s = qr * zr - qi * zi + Cr[j];\n        qi = qr * zi + qi * zr + Ci[j];\n        qr = s;\n      }\n      const fr = pr + qr, fi = pi + qi, gr = dr + er, gi = di + ei;\n      let m = gr * gr + gi * gi;\n      if (!(m > 0)) continue;\n      const wr = (fr * gr + fi * gi) / m, wi = (fi * gr - fr * gi) / m;\n      let ar = 0, ai = 0;\n      for (let j = 0; j \u003c 20; j++)\n        if (j !== i) {\n          const xr = zr - Z[2 * j], xi = zi - Z[2 * j + 1], mm = xr * xr + xi * xi;\n          if (mm > 0) (ar += xr / mm), (ai -= xi / mm);\n        }\n      const br = 1 - (wr * ar - wi * ai), bi = -(wr * ai + wi * ar);\n      m = br * br + bi * bi;\n      if (!(m > 0)) continue;\n      const sr = (wr * br + wi * bi) / m, si = (wi * br - wr * bi) / m;\n      Z[2 * i] -= sr;\n      Z[2 * i + 1] -= si;\n      const st = sr * sr + si * si;\n      STEP[i] = st;\n      if (st > big) big = st;\n    }\n    if (big \u003c 1e-24) break;\n  }\n  return big;\n}\n\n// A real polynomial keeps real iterates real, so a root that is on the\n// axis gets a tiny imaginary part, alternating up the axis, before each\n// solve: two roots that meet can then leave the axis in opposite ways.\nconst ORD = [];\nfunction seed(Z) {\n  ORD.length = 0;\n  for (let i = 0; i \u003c 20; i++) ORD.push(i);\n  ORD.sort((a, b) => Z[2 * a] - Z[2 * b]);\n  for (let k = 0; k \u003c 20; k++) {\n    const i = ORD[k];\n    if (abs(Z[2 * i + 1]) \u003c 1e-9) Z[2 * i + 1] = k & 1 ? 1e-9 : -1e-9;\n  }\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  const Z = new Float64Array(40);\n  for (let i = 0; i \u003c 20; i++) Z[2 * i] = i + 1;\n  params.s = {\n    ph: 0.17, e2: LO, pow: 19, pk: 19, hold: 0, warm: 0,\n    Z, Zo: new Float64Array(40), Zw: new Float64Array(40),\n    Cr: new Float64Array(20), Ci: new Float64Array(20), Br: new Float64Array(20), Bi: new Float64Array(20),\n    TI: F(N), TC: new Uint8Array(N), CR: F(N), CG: F(N), CB: F(N), DR: F(N), DG: F(N), DB: F(N),\n    R: F(N), G: F(N), B: F(N), pal: F(60), col: F(3), hue: 0, ld: -45, th: 0,\n  };\n}\n\n// Trails: each root draws the segment it moved along this frame into TI as\n// a line about three LEDs wide, each LED it touches at its own brightness\n// between 0.6 and 1 of the line's, keeping the brighter of that and what\n// is there. Trails fade over three and a half seconds.\nfunction trail(S, x0, y0, x1, y1, c) {\n  const n = max(1, Math.ceil(2 * hypot(x1 - x0, y1 - y0)));\n  if (n > 200) return;\n  for (let s = 0; s \u003c= n; s++) {\n    const x = x0 + ((x1 - x0) * s) / n, y = y0 + ((y1 - y0) * s) / n;\n    for (let yy = floor(y - 2); yy \u003c= y + 1; yy++)\n      for (let xx = floor(x - 2); xx \u003c= x + 1; xx++) {\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const w = (1 - hypot(xx + 0.5 - x, yy + 0.5 - y) / 1.7) * (0.6 + 0.4 * rnd()), p = yy * W + xx;\n        if (w > S.TI[p]) (S.TI[p] = w), (S.TC[p] = c);\n      }\n  }\n}\n\nfunction splat(R, G, B, x, y, r, g, b) {\n  const ix = floor(x - 0.5), iy = floor(y - 0.5), ax = x - 0.5 - ix, ay = y - 0.5 - iy;\n  for (let q = 0; q \u003c 4; q++) {\n    const xx = ix + (q & 1), yy = iy + (q >> 1);\n    if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n    const w = (q & 1 ? ax : 1 - ax) * (q >> 1 ? ay : 1 - ay), p = yy * W + xx;\n    R[p] += w * r, G[p] += w * g, B[p] += w * b;\n  }\n}\n\n// The change: a_k, k = S.pk, becomes a_k + sign(a_k) eps e^(2 pi i th),\n// so with k = 19 and th = 0 it is Wilkinson's -210 - eps, eps = 2^e2. For\n// another k, eps is scaled by |a_k| SENS[19] / (210 SENS[k]).\nfunction perturb(S) {\n  const k = S.pk, a = 2 * PI * S.th, e = 2 ** S.e2 * (AB[k] / 210) * (SENS[19] / SENS[k]) * Math.sign(A[k]);\n  S.Cr.fill(0), S.Ci.fill(0);\n  S.Cr[k] = e * cos(a);\n  S.Ci[k] = e * sin(a);\n}\n\nfunction step(S, d, sp, clouds) {\n  // A K3 tap first takes the change back down to LO, where every root is\n  // home, then moves it to the next power and starts the sweep again from\n  // the bottom. K1's hold stops the sweep and eases the change to 2^-23.\n  // Either way the change moves at most ten octaves a second.\n  let to;\n  if (S.pk !== S.pow) {\n    to = LO;\n    if (S.e2 \u003c LO + 0.3) (S.pk = S.pow), (S.ph = 0);\n  } else if (S.hold > 0) (S.hold -= d), (to = WILK);\n  else {\n    S.ph += (d * sp) / 24;\n    to = LO + ((HI - LO) * (1 - cos(2 * PI * S.ph))) / 2;\n  }\n  S.e2 += cl(to - S.e2, -10 * d, 10 * d);\n  perturb(S);\n  const { Z, Zo } = S;\n  Zo.set(Z);\n  seed(Z);\n  aberth(Z, S.Cr, S.Ci, 40, 0);\n  for (let i = 0; i \u003c 40; i++) if (!Number.isFinite(Z[i])) Z.set(Zo), (i = 40);\n  for (let i = 0; i \u003c 20; i++) trail(S, toX(Zo[2 * i + 1]), toY(Zo[2 * i]), toX(Z[2 * i + 1]), toY(Z[2 * i]), i);\n  if (clouds) cloud(S, clouds);\n}\n\n// Clouds: eight times a frame, every coefficient below the top one of the\n// current polynomial is also multiplied by 1 + delta u_j, u_j uniform in\n// [-1, 1], and all twenty roots are solved again from the current ones.\n// Each root whose last step was under 1e-4 lands as a dot of its root's\n// colour and its own brightness, and fades over two seconds. With 24\n// sweeps 99.9% land even with the roots on the integers, where the\n// nudged copies are hardest.\nfunction cloud(S, n) {\n  const { Z, Zw, Br, Bi, Cr, Ci, CR, CG, CB, pal } = S, dl = 2 ** S.ld;\n  for (let m = 0; m \u003c n; m++) {\n    for (let j = 0; j \u003c 20; j++) (Br[j] = Cr[j] + dl * (2 * rnd() - 1) * A[j]), (Bi[j] = Ci[j]);\n    Zw.set(Z);\n    seed(Zw);\n    aberth(Zw, Br, Bi, 24, 0);\n    for (let i = 0; i \u003c 20; i++) {\n      if (!(STEP[i] \u003c= 1e-8)) continue;\n      const w = 0.25 + 0.75 * rnd();\n      const x = floor(toX(Zw[2 * i + 1])), y = floor(toY(Zw[2 * i]));\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = y * W + x;\n      (CR[q] = w * pal[3 * i]), (CG[q] = w * pal[3 * i + 1]), (CB[q] = w * pal[3 * i + 2]);\n    }\n  }\n}\n\n// The nebula. z is a root of some polynomial whose coefficients below the\n// top one differ from the current ones by at most a share delta each\n// exactly when |p(z) + C(z)| \u003c= delta sum |a_j| |z|^j (Mosier 1986), so\n// L = log2 of the ratio is the smallest such delta, in octaves. Each frame\n// 1200 LEDs picked at random take a grain for a random point inside them:\n// in the delta set (L \u003c ld) a grain lights with a chance up to 70% and up\n// to full brightness, in the 16 delta and 256 delta sets around it the\n// chance and the brightness fall off to 20% and 65, and the colour runs\n// from cyan in the core to blue at the edge. Beyond 256 delta the grains\n// stay under 25, the LEDs' threshold, and take any colour. Grains fade over\n// three seconds.\nfunction dust(S, n) {\n  const { Cr, Ci, DR, DG, DB, col } = S;\n  for (let m = 0; m \u003c n; m++) {\n    const p = floor(rnd() * N), x = (p & 63) + rnd(), y = (p >> 6) + rnd();\n    const zr = RE0 + (H - y) / RY, zi = (x - XC) / CX;\n    let pr = 1, pi = 0;\n    for (let j = 1; j \u003c= 20; j++) {\n      const ur = zr - j, s = pr * ur - pi * zi;\n      pi = pr * zi + pi * ur;\n      pr = s;\n    }\n    // Plus the perturbation, and sum |a_j| |z|^j.\n    let qr = 0, qi = 0;\n    for (let j = 19; j >= 0; j--) {\n      const s = qr * zr - qi * zi + Cr[j];\n      qi = qr * zi + qi * zr + Ci[j];\n      qr = s;\n    }\n    (pr += qr), (pi += qi);\n    const r = hypot(zr, zi);\n    let sum = 0;\n    for (let j = 19; j >= 0; j--) sum = sum * r + AB[j];\n    const L = log2(hypot(pr, pi) / sum + 1e-300), depth = S.ld - L, q = cl((depth + 8) / 14, 0, 1);\n    hsv(S.hue + 0.68 - 0.2 * q, 0.8, 1, col, 0);\n    if (depth > -8) {\n      const v = rnd() \u003c 0.2 + 0.5 * q ? 25 + (40 + 190 * q) * rnd() : 24.9 * rnd(), w = 0.4 * rnd();\n      DR[p] = v * (col[0] + w * (1 - col[0])), DG[p] = v * (col[1] + w * (1 - col[1])), DB[p] = v * (col[2] + w * (1 - col[2]));\n    } else (DR[p] = 24.99 * rnd()), (DG[p] = 24.99 * rnd()), (DB[p] = 24.99 * rnd());\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const sp = cl(kv[1], 0.2, 3);\n  S.th = cl(kv[2], 0, 1);\n  S.ld = -45 + 6 * cl(kv[3], 0, 1);\n  for (let i = 0; i \u003c 20; i++) hsv(S.hue + 0.8 + (0.17 * i) / 19, 0.75, 1, S.pal, 3 * i);\n  const p = input.btnPressed || [];\n  if (p[0]) S.hold = 3;\n  if (p[2]) S.pow = S.pow ? S.pow - 1 : 19;\n  // The roots are walked up from home to the sweep's opening place, 2^-31.4,\n  // and the first second and a half is run before the first frame, so the\n  // first pairs have left the axis and drawn their arcs; at Speed 2, 2^-23\n  // then comes at 1 s and the top at 2.5 s.\n  if (!S.warm) {\n    S.warm = 1;\n    const u = (1 - cos(2 * PI * S.ph)) / 2, e0 = LO + (HI - LO) * u;\n    for (let e = LO; e \u003c e0; e += 0.25) (S.e2 = min(e, e0)), perturb(S), seed(S.Z), aberth(S.Z, S.Cr, S.Ci, 40, 0);\n    S.e2 = e0;\n    for (let i = 0; i \u003c 45; i++) step(S, 1 / 30, sp, i > 30 ? 4 : 0), fade(S, 1 / 30), dust(S, 900);\n  }\n  step(S, d, sp, 8);\n  fade(S, d);\n  dust(S, 1200);\n}\n\nfunction fade(S, d) {\n  const ft = exp(-d / 3.5), fc = exp(-d / 2), fd = exp(-d / 3);\n  const { TI, CR, CG, CB, DR, DG, DB } = S;\n  for (let p = 0; p \u003c N; p++) {\n    TI[p] *= ft;\n    CR[p] *= fc, CG[p] *= fc, CB[p] *= fc;\n    DR[p] *= fd, DG[p] *= fd, DB[p] *= fd;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.warm) return;\n  const { TI, TC, CR, CG, CB, DR, DG, DB, R, G, B, pal, Z } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const ti = TI[p], c = 3 * TC[p], tv = ti > 0.02 ? 190 * ti : 0;\n    R[p] = DR[p] + tv * pal[c] + 235 * CR[p];\n    G[p] = DG[p] + tv * pal[c + 1] + 235 * CG[p];\n    B[p] = DB[p] + tv * pal[c + 2] + 235 * CB[p];\n  }\n  // The integers 1 to 20 marked on both edges, longer at every fifth.\n  for (let k = 1; k \u003c= 20; k++) {\n    const y = 123 - 6 * (k - 1), l = k % 5 ? 2 : 3;\n    for (let x = 0; x \u003c l; x++) for (const xx of [x, 63 - x]) (R[y * W + xx] += 30), (G[y * W + xx] += 34), (B[y * W + xx] += 40);\n  }\n  for (let i = 0; i \u003c 20; i++) {\n    const x = toX(Z[2 * i + 1]), y = toY(Z[2 * i]), c = 3 * i;\n    splat(R, G, B, x, y, 160 + 300 * pal[c], 160 + 300 * pal[c + 1], 160 + 300 * pal[c + 2]);\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, cl(R[p], 0, 255) | 0, cl(G[p], 0, 255) | 0, cl(B[p], 0, 255) | 0);\n}\n","zermelo-navigation":"// ===== Patternflow pattern =====\n// Title:   Zermelo Navigation\n// Family:  line\n// Idea:    A harbour at the foot of the panel sends out, twice a second, the front of every place a boat rowing at one speed could have reached by then, and the fronts climb the whole panel bent by a current of eddies or a wandering jet, fold into corners where two ways round meet, string beads along the thin quickest routes to six places, and stop at hatched shadows where water pours in from beyond the panel faster than any boat can row.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Zermelo's navigation problem (Ernst Zermelo, 1931), arrival times by Dijkstra's algorithm (Edsger Dijkstra, 1959) on a 32-heading stencil, pattern round 66\n// Round:   66\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Current=0..2.5, Shape=0..1, Harbour=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together: at 0 a front leaves the harbour gold, turns green halfway and reaches the far coast blue, and the shadows are rose.\n// Knob 2: Current. The fastest water, in boat speeds. At 0 the fronts are circles and the routes straight lines; up to 1 every LED is reached, at any shape, harbour and moment; past 1 shadows open, at Shape 0 on 1.6% of the panel at 1.5, 5.5% at 2 (the opening) and 11.5% at 2.5.\n// Knob 3: Shape. Three eddies at 0, two on the left side and one on the right, and at 1 a jet leaving the coast at the bottom centre that wanders more as it climbs; between, both at part strength. With the harbour inside a jet faster than the boat the fronts become teardrops carried up the jet, and at first only a cone above the harbour is reached: at Shape 1 and Current 2 the water there runs at 1.99 boat speeds and the cone's half-angle is asin(1 / 1.99) = 30 degrees.\n// Knob 4: Harbour. Where the harbour stands on the coast, from column 8 at -1 to column 56 at 1. At Shape 0 the shadows do not move with it, the same 448 LEDs at Current 2 wherever it stands, since they belong to the current and the panel's edges.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, sin, cos, round, PI, cosh } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst INF = 1e9;\nconst HY = 121; // the harbour's row\nconst RATE = 18; // the boat's speed in LEDs per second\nconst GAP = 9; // a new front every GAP / RATE seconds\nconst SOLVE = 20; // frames over which one field of arrival times is solved\nconst NP = 240; // tracers in the water\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The stencil: every step (a, b) with |a|, |b| \u003c= 3 and gcd 1, 32 headings.\n// The widest gap between headings is 18.4 degrees, so in still water a\n// stencil path is at most 1 / cos(9.2 deg) - 1 = 1.3% longer than the\n// straight line; measured over the panel it is 0.66% on average.\nconst SA = [], SB = [], SL = [], SUX = [], SUY = [];\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\nfor (let a = -3; a \u003c= 3; a++)\n  for (let b = -3; b \u003c= 3; b++)\n    if ((a || b) && gcd(abs(a), abs(b)) === 1) {\n      const l = sqrt(a * a + b * b);\n      SA.push(a); SB.push(b); SL.push(l); SUX.push(a / l); SUY.push(b / l);\n    }\nconst ND = SA.length;\n\n// Ground speed along unit heading u in current w, the boat rowing at 1:\n// s solves |s u - w| = 1, s = u.w + sqrt(1 - |w|^2 + (u.w)^2). Returns the\n// time per unit length, or INF when no heading of the boat makes way along\n// u. While |w| \u003c 1 every u makes way; past 1 only a cone around w does.\nfunction slow(wx, wy, ux, uy) {\n  const d = ux * wx + uy * wy, disc = 1 - wx * wx - wy * wy + d * d;\n  if (disc \u003c 0) return INF;\n  const s = d + sqrt(disc);\n  return s > 1e-4 ? 1 / s : INF;\n}\n\n// The current at (x, y) in LEDs, in boat speeds. Both parts come from a\n// stream function psi, w = (dpsi/dy, -dpsi/dx), so no water is made or lost\n// inside the panel; it only comes in and goes out through the edges.\nfunction current(F, x, y, out) {\n  let wx = 0, wy = 0;\n  if (F.ge) {\n    // Gaussian eddies, psi = G exp(-r^2 / 2R^2) with R = 13 and G = S R\n    // sqrt(e), so the fastest water, at r = R, runs at S. Their centres sit\n    // 4 LEDs inside the sides, and the half of each that reaches past the\n    // edge brings water in through it.\n    const R2 = 169;\n    for (let k = 0; k \u003c 9; k += 3) {\n      const dx = x - F.E[k], dy = y - F.E[k + 1], e = (F.E[k + 2] * F.ge * exp(-(dx * dx + dy * dy) / (2 * R2))) / R2;\n      wx -= dy * e;\n      wy += dx * e;\n    }\n  }\n  if (F.gj) {\n    // A jet leaving the coast at the bottom centre, wandering more as it\n    // climbs: psi = J L tanh((x - X(y)) / L), X = 32 + A(y) sin(k y + phase).\n    const L = 13, k = (2 * PI) / 52, A = 9 * (1 - y / H), ph = k * y + F.th;\n    const X = 32 + A * sin(ph), dX = (-9 / H) * sin(ph) + A * k * cos(ph), c = 1 / cosh((x - X) / L), j = F.gj * c * c;\n    wx -= j * dX;\n    wy -= j;\n  }\n  out[0] = wx;\n  out[1] = wy;\n}\n\n// Where the quickest routes go: the top corners, two places on the far\n// coast and one on each side halfway up.\nconst TARGETS = [4, 2, 22, 1, 42, 1, 60, 2, 2, 62, 62, 62];\n\nexport function setup(params) {\n  params.s = {\n    WX: new Float32Array(N), WY: new Float32Array(N), Tn: new Float32Array(N), pred: new Int32Array(N),\n    done: new Uint8Array(N), pos: new Int32Array(N), hp: new Int32Array(N), hn: 0,\n    Ta: new Float32Array(N), Tb: new Float32Array(N), T: new Float32Array(N), DWX: new Float32Array(N), DWY: new Float32Array(N),\n    ra: 120, rb: 120, routes: [], fade: 1, solving: false, src: 0, t: 0, tau: 0, started: false,\n    px: new Float32Array(NP), py: new Float32Array(NP), pa: new Float32Array(NP),\n    rgb: new Float32Array(N * 3), lut: new Float32Array(65 * 3), sh: new Float32Array(3), hue: 0,\n    F: { ge: 0, gj: 0, th: 0, hx: 32, E: new Float32Array(9) }, w: [0, 0],\n  };\n  return params.s;\n}\n\n// An indexed binary heap keyed on Tn, so a node's key can drop in place.\nfunction up(S, i, v) {\n  const hp = S.hp, pos = S.pos, T = S.Tn, key = T[v];\n  while (i > 0) {\n    const p = (i - 1) >> 1, pv = hp[p];\n    if (T[pv] \u003c= key) break;\n    hp[i] = pv;\n    pos[pv] = i;\n    i = p;\n  }\n  hp[i] = v;\n  pos[v] = i;\n}\n\nfunction pop(S) {\n  const hp = S.hp, pos = S.pos, T = S.Tn, top = hp[0];\n  pos[top] = -1;\n  const n = --S.hn;\n  if (n > 0) {\n    const last = hp[n], key = T[last];\n    let i = 0;\n    for (;;) {\n      let c = 2 * i + 1;\n      if (c >= n) break;\n      if (c + 1 \u003c n && T[hp[c + 1]] \u003c T[hp[c]]) c++;\n      if (T[hp[c]] >= key) break;\n      hp[i] = hp[c];\n      pos[hp[i]] = i;\n      i = c;\n    }\n    hp[i] = last;\n    pos[last] = i;\n  }\n  return top;\n}\n\n// Start a solve for the knobs and the clock `at` seconds: the eddies ride\n// small circles and the jet's meander travels up it, once in 40 s.\nfunction begin(S, kv, at) {\n  const F = S.F, th = (at * 2 * PI) / 40, cur = cl(kv[1] ?? 2, 0, 2.5), m = cl(kv[2] || 0, 0, 1);\n  F.th = th;\n  F.ge = cur * 13 * 1.6487 * (1 - m);\n  F.gj = cur * m;\n  F.hx = 32 + 24 * cl(kv[3] ?? 0.06, -1, 1);\n  const E = F.E;\n  E[0] = 4 + 3 * sin(th); E[1] = 88 + 3 * cos(th); E[2] = 1;\n  E[3] = 60 - 3 * sin(th + 2); E[4] = 57 + 4 * cos(th + 2); E[5] = -1;\n  E[6] = 4 + 3 * sin(th + 4); E[7] = 26 + 4 * cos(th + 4); E[8] = 1;\n  const w = S.w;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      current(F, x + 0.5, y + 0.5, w);\n      S.WX[y * W + x] = w[0];\n      S.WY[y * W + x] = w[1];\n    }\n  S.Tn.fill(INF);\n  S.done.fill(0);\n  S.pos.fill(-1);\n  S.hn = 0;\n  const src = (S.src = HY * W + round(F.hx));\n  S.Tn[src] = 0;\n  S.pred[src] = -1;\n  up(S, S.hn++, src);\n  S.solving = true;\n}\n\n// Dijkstra over the stencil, settling at most `budget` LEDs. A step is\n// rowed in the mean of the currents at its two ends, and a step along which\n// no heading makes way in that current is not taken. The mean of the two\n// ends' slowness was tried first: it shut every step with either end too\n// fast to row along, and the opening's shadow shrank as the grid was made\n// finer, 756 LEDs on the LED grid and 472 on a grid four times finer. With\n// the mean current it is 441 and 444, and the arrival times of the two\n// grids differ by 0.69% at the median.\nfunction work(S, budget) {\n  const T = S.Tn, WX = S.WX, WY = S.WY, done = S.done, pred = S.pred, pos = S.pos;\n  while (S.hn > 0 && budget-- > 0) {\n    const u = pop(S);\n    done[u] = 1;\n    const ux = u % W, uy = (u - ux) / W, tu = T[u], wx = WX[u], wy = WY[u];\n    for (let k = 0; k \u003c ND; k++) {\n      const vx = ux + SA[k], vy = uy + SB[k];\n      if (vx \u003c 0 || vx >= W || vy \u003c 0 || vy >= H) continue;\n      const v = vy * W + vx;\n      if (done[v]) continue;\n      const a = slow(0.5 * (wx + WX[v]), 0.5 * (wy + WY[v]), SUX[k], SUY[k]);\n      if (a >= INF) continue;\n      const tv = tu + SL[k] * a;\n      if (tv \u003c T[v]) {\n        T[v] = tv;\n        pred[v] = u;\n        up(S, pos[v] >= 0 ? pos[v] : S.hn++, v);\n      }\n    }\n  }\n  return S.hn === 0;\n}\n\n// A solved field becomes the one faded in; the routes are traced back from\n// each target along the steps that reached it, and the colour scale is set\n// by the mean time to the far coast.\nfunction finish(S) {\n  // A lone LED left unreached among reached ones is the stencil's doing, not\n  // the current's (51 of 1,713 shadows over 45 settings, never wider than\n  // one LED): it takes the mean of its four neighbours.\n  const Tn = S.Tn;\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const i = y * W + x;\n      if (Tn[i] \u003c INF || Tn[i - 1] >= INF || Tn[i + 1] >= INF || Tn[i - W] >= INF || Tn[i + W] >= INF) continue;\n      Tn[i] = (Tn[i - 1] + Tn[i + 1] + Tn[i - W] + Tn[i + W]) / 4;\n      S.pred[i] = i - 1;\n    }\n  S.Ta.set(S.Tb);\n  S.Tb.set(S.Tn);\n  S.DWX.set(S.WX);\n  S.DWY.set(S.WY);\n  S.fade = 0;\n  S.solving = false;\n  S.routes = [];\n  for (let k = 0; k \u003c TARGETS.length; k += 2) {\n    let v = TARGETS[k + 1] * W + TARGETS[k];\n    if (S.Tn[v] >= INF) continue;\n    const path = [];\n    for (; v >= 0 && path.length \u003c N; v = S.pred[v]) path.push(v);\n    S.routes.push(path);\n  }\n  let sum = 0, n = 0;\n  for (let x = 0; x \u003c W; x++)\n    if (S.Tn[x] \u003c INF) {\n      sum += S.Tn[x];\n      n++;\n    }\n  S.ra = S.rb;\n  S.rb = n ? max(40, sum / n) : 120;\n}\n\nfunction spawn(S, i) {\n  S.px[i] = Math.random() * W;\n  S.py[i] = Math.random() * H;\n  S.pa[i] = 0;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 0, 0.06];\n  const d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.t += d;\n  S.tau += d * RATE;\n  if (!S.started) {\n    // The first field is solved whole, and fronts have been leaving the\n    // harbour for ever, so the panel opens full.\n    S.started = true;\n    begin(S, kv, S.t);\n    work(S, N);\n    finish(S);\n    S.Ta.set(S.Tb);\n    S.ra = S.rb;\n    S.fade = 1;\n    for (let i = 0; i \u003c NP; i++) {\n      spawn(S, i);\n      S.pa[i] = Math.random() * 3;\n    }\n  }\n  // Then one field is solved every SOLVE frames, a slice per frame, for the\n  // knobs as they are and the clock when it will be shown, and fades in.\n  if (!S.solving) begin(S, kv, S.t + SOLVE / 30);\n  if (work(S, Math.ceil(N / SOLVE))) finish(S);\n  S.fade = min(1, S.fade + 1 / SOLVE);\n  for (let i = 0; i \u003c NP; i++) {\n    const c = (S.py[i] | 0) * W + (S.px[i] | 0);\n    S.px[i] += S.DWX[c] * RATE * d;\n    S.py[i] += S.DWY[c] * RATE * d;\n    S.pa[i] += d;\n    if (S.px[i] \u003c 0 || S.px[i] >= W || S.py[i] \u003c 0 || S.py[i] >= H || S.pa[i] > 3) spawn(S, i);\n  }\n}\n\nfunction put(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  if (rgb[o] \u003c r) rgb[o] = r;\n  if (rgb[o + 1] \u003c g) rgb[o + 1] = g;\n  if (rgb[o + 2] \u003c b) rgb[o + 2] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const rgb = S.rgb, Ta = S.Ta, Tb = S.Tb, a = S.fade, tau = S.tau, T = S.T, lut = S.lut, sh = S.sh;\n  rgb.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const p = Ta[i], q = Tb[i];\n    T[i] = p >= INF || q >= INF ? (a \u003c 0.5 ? p : q) : p + (q - p) * a;\n  }\n  // Front colours by arrival time over the time to the far coast.\n  for (let k = 0; k \u003c= 64; k++) hsv(S.hue + 0.13 + (0.55 * k) / 64, 1, 1, lut, k * 3);\n  const sc = 64 / (S.ra + (S.rb - S.ra) * a);\n  hsv(S.hue + 0.92, 0.75, 1, sh, 0);\n  // The current: short pale streaks drifting with the water.\n  for (let i = 0; i \u003c NP; i++) {\n    const x = S.px[i], y = S.py[i], o = (y | 0) * W + (x | 0), wx = S.DWX[o], wy = S.DWY[o];\n    const f = min(1, S.pa[i] * 2, (3 - S.pa[i]) * 2), n = wx * wx + wy * wy \u003c 0.09 ? 1 : 3;\n    for (let k = 0; k \u003c n; k++) {\n      const v = f * (75 - 20 * k);\n      put(rgb, floor(x - wx * k * 0.9), floor(y - wy * k * 0.9), v * 0.6, v * 0.75, v);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, t = T[i], o = i * 3;\n      const l = x > 0 ? T[i - 1] : INF, r = x \u003c W - 1 ? T[i + 1] : INF, u = y > 0 ? T[i - W] : INF, dn = y \u003c H - 1 ? T[i + W] : INF;\n      if (t >= INF) {\n        // The shadow: no heading of the boat ever gets here. Hatched, with\n        // its rim lit.\n        const v = l \u003c INF || r \u003c INF || u \u003c INF || dn \u003c INF ? 0.55 : (x + y) % 4 === 0 ? 0.32 : 0;\n        if (v) {\n          rgb[o] = max(rgb[o], sh[0] * v);\n          rgb[o + 1] = max(rgb[o + 1], sh[1] * v);\n          rgb[o + 2] = max(rgb[o + 2], sh[2] * v);\n        }\n        continue;\n      }\n      // Distance to the nearest front in LEDs from the slope of T, taken\n      // as the steeper side so a fold does not smear.\n      const gx = max(l \u003c INF ? t - l : 0, r \u003c INF ? r - t : 0, l \u003c INF ? l - t : 0, r \u003c INF ? t - r : 0);\n      const gy = max(u \u003c INF ? t - u : 0, dn \u003c INF ? dn - t : 0, u \u003c INF ? u - t : 0, dn \u003c INF ? t - dn : 0);\n      const g = max(0.25, sqrt(gx * gx + gy * gy));\n      const q = (tau - t) / GAP, f = q - floor(q), dl = (min(f, 1 - f) * GAP) / g, behind = (f * GAP) / g;\n      // A line on the front and a short glow on the harbour side of it.\n      // Where the boats barely make way the fronts crowd together; from 3.5\n      // LEDs apart down to 1.5 they melt into a steady dim glow rather than\n      // shimmer.\n      const line = dl \u003c 1.1 ? 1 - dl / 1.1 : 0, tail = behind \u003c 9 ? 0.16 * exp(-behind / 2.5) : 0;\n      const sp = cl((GAP / g - 1.5) / 2, 0, 1), v = max(line, tail) * sp + 0.12 * (1 - sp);\n      if (v \u003c= 0.01) continue;\n      const c = min(64, (t * sc) | 0) * 3;\n      rgb[o] = max(rgb[o], lut[c] * v);\n      rgb[o + 1] = max(rgb[o + 1], lut[c + 1] * v);\n      rgb[o + 2] = max(rgb[o + 2], lut[c + 2] * v);\n    }\n  // The quickest routes, and a bead where each front crosses one: the\n  // place on the front that route's boat has got to.\n  for (const path of S.routes)\n    for (let k = 1; k \u003c path.length; k++) {\n      const p0 = path[k - 1], p1 = path[k];\n      const x0 = p0 % W, y0 = (p0 / W) | 0, x1 = p1 % W, y1 = (p1 / W) | 0, n = max(abs(x1 - x0), abs(y1 - y0));\n      for (let j = 0; j \u003c n; j++) put(rgb, round(x0 + ((x1 - x0) * j) / n), round(y0 + ((y1 - y0) * j) / n), 95, 95, 105);\n      const t0 = T[p0], t1 = T[p1], lv = tau - GAP * Math.ceil((tau - t0) / GAP);\n      if (t0 > t1 && lv >= t1) {\n        const s = (lv - t1) / (t0 - t1);\n        put(rgb, round(x1 + (x0 - x1) * s), round(y1 + (y0 - y1) * s), 255, 255, 255);\n      }\n    }\n  const hx = S.src % W;\n  for (let dy = -1; dy \u003c= 1; dy++)\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const v = dx || dy ? 120 : 255;\n      put(rgb, hx + dx, HY + dy, v, v, v);\n    }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, (i / W) | 0, min(255, rgb[o]) | 0, min(255, rgb[o + 1]) | 0, min(255, rgb[o + 2]) | 0);\n  }\n}\n","anamorphosis":"// ===== Patternflow pattern =====\n// Title:   Anamorphosis\n// Family:  type\n// Idea:    A word is painted across slabs, boxes and pillars floating at many depths, as if thrown on them by a projector at one point of view, and the camera swings round the cluster so the coloured fragments scatter and slide past one another, closing up into the word only in the moment it passes that point.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: anamorphic painting from one point of view (Hans Holbein the Younger, The Ambassadors, 1533; Felice Varini's wall paintings), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Flatten=0..1\n//\n// Knob 1: Hue. Turns the letter colours round the wheel together. Each letter keeps its own colour, evenly spaced, so the letters of a word are as far apart in hue as they can be: at 0 HERE is sky blue, violet, orange and green.\n// Knob 2: Speed. The camera flies a figure eight round the cluster, out to 52 degrees either side and 17 degrees up and down, and crosses the point of view at its middle. At 2 it crosses at 4 s and then every 8 s, slowing there to a quarter of its pace, so the word stands whole for about a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Word. HERE, NOW, LOOK, 여기 (here) and 지금 (now), stacked down the panel a letter or a syllable at a time.\n// Knob 4: Flatten. At 0 the thirteen pieces of the first cut (eight slabs, four boxes and a pillar) stand from 5.4 to 14.6 units from the point of view, each scaled by its distance so it fills its own rectangle of the picture there, and every fragment slides its own way once the camera leaves. Turned up they gather onto one plane 10 units away, the middle of the cluster, and at 1 the word is a flat sign that reads, foreshortened, from anywhere.\n// Buttons: K1 tap cuts the picture into a new set of pieces.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nconst F = 116; // focal length in LEDs, the same for the camera and the point of view\nconst DV = 10; // the point of view V stands at (0, 0, DV) and looks down -z at the origin\nconst YF = -8.6; // the floor\nconst MW = 128, MH = 256; // the word is drawn into V's picture at twice the panel's resolution\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Glyphs as strokes in a unit box, y down: L a line, A an elliptic arc\n// (centre, radii, start and end angle in degrees, clockwise on screen).\nconst GLYPHS = {\n  H: [[\"L\", 0, 0, 0, 1], [\"L\", 1, 0, 1, 1], [\"L\", 0, 0.5, 1, 0.5]],\n  E: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 0, 1, 0], [\"L\", 0, 0.5, 0.82, 0.5], [\"L\", 0, 1, 1, 1]],\n  R: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 0, 0.66, 0], [\"A\", 0.66, 0.27, 0.34, 0.27, -90, 90], [\"L\", 0, 0.54, 0.66, 0.54], [\"L\", 0.5, 0.54, 1, 1]],\n  N: [[\"L\", 0, 1, 0, 0], [\"L\", 0, 0, 1, 1], [\"L\", 1, 1, 1, 0]],\n  O: [[\"A\", 0.5, 0.5, 0.5, 0.5, 0, 360]],\n  W: [[\"L\", 0, 0, 0.22, 1], [\"L\", 0.22, 1, 0.5, 0.25], [\"L\", 0.5, 0.25, 0.78, 1], [\"L\", 0.78, 1, 1, 0]],\n  L: [[\"L\", 0, 0, 0, 1], [\"L\", 0, 1, 1, 1]],\n  K: [[\"L\", 0, 0, 0, 1], [\"L\", 1, 0, 0.08, 0.6], [\"L\", 0.36, 0.42, 1, 1]],\n  // Hangul syllables drawn whole, each in a square box.\n  \"여\": [[\"A\", 0.27, 0.5, 0.25, 0.3, 0, 360], [\"L\", 0.86, 0, 0.86, 1], [\"L\", 0.6, 0.33, 0.86, 0.33], [\"L\", 0.6, 0.67, 0.86, 0.67]],\n  \"기\": [[\"L\", 0.02, 0.1, 0.56, 0.1], [\"L\", 0.56, 0.1, 0.5, 0.92], [\"L\", 0.88, 0, 0.88, 1]],\n  \"지\": [[\"L\", 0.04, 0.1, 0.62, 0.1], [\"L\", 0.36, 0.1, 0.04, 0.9], [\"L\", 0.36, 0.4, 0.64, 0.9], [\"L\", 0.9, 0, 0.9, 1]],\n  \"금\": [[\"L\", 0.12, 0, 0.86, 0], [\"L\", 0.86, 0, 0.86, 0.3], [\"L\", 0, 0.48, 1, 0.48], [\"L\", 0.16, 0.68, 0.84, 0.68], [\"L\", 0.16, 0.68, 0.16, 1], [\"L\", 0.84, 0.68, 0.84, 1], [\"L\", 0.16, 1, 0.84, 1]],\n};\nconst WORDS = [[\"H\", \"E\", \"R\", \"E\"], [\"N\", \"O\", \"W\"], [\"L\", \"O\", \"O\", \"K\"], [\"여\", \"기\"], [\"지\", \"금\"]];\n\nfunction segDist(px, py, s) {\n  const dx = s[2] - s[0], dy = s[3] - s[1], l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - s[0]) * dx + (py - s[1]) * dy) / l, 0, 1) : 0;\n  const ex = s[0] + t * dx - px, ey = s[1] + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// The word in V's picture: coverage 0..1 and the letter each texel belongs to.\nconst hitS = new Uint8Array(MW * MH * 4);\nfunction buildWord(wi) {\n  const word = WORDS[wi], n = word.length, hangul = wi >= 3;\n  const S = MW / W; // texels per LED\n  const margin = 3, gap = hangul ? 5 : n === 4 ? 4 : 5;\n  const ch = (H - 2 * margin - (n - 1) * gap) / n, cw = 60;\n  const pen = hangul ? 7.4 : n === 4 ? 7.2 : 8.4;\n  const mask = new Float32Array(MW * MH), id = new Uint8Array(MW * MH);\n  for (let k = 0; k \u003c n; k++) {\n    const x0 = (W - cw) / 2, y0 = margin + k * (ch + gap), hw = pen / 2;\n    const sx = cw - pen, sy = ch - pen;\n    const segs = [];\n    for (const st of GLYPHS[word[k]]) {\n      const P = (u, v) => [(x0 + hw + u * sx) * S, (y0 + hw + v * sy) * S];\n      if (st[0] === \"L\") segs.push([...P(st[1], st[2]), ...P(st[3], st[4])]);\n      else {\n        const [, cx, cy, rx, ry, a0, a1] = st, m = max(4, Math.ceil(abs(a1 - a0) / 10));\n        for (let i = 0; i \u003c m; i++) {\n          const b0 = ((a0 + ((a1 - a0) * i) / m) * PI) / 180, b1 = ((a0 + ((a1 - a0) * (i + 1)) / m) * PI) / 180;\n          segs.push([...P(cx + rx * cos(b0), cy + ry * sin(b0)), ...P(cx + rx * cos(b1), cy + ry * sin(b1))]);\n        }\n      }\n    }\n    // Each stroke marks the samples within half a pen of it, two by two to a\n    // texel, then the texels count their marked samples.\n    const r = hw * S, SW = MW * 2;\n    const ty0 = max(0, floor((y0 - 1) * S)), ty1 = min(MH, Math.ceil((y0 + ch + 1) * S));\n    hitS.fill(0, ty0 * 2 * SW, ty1 * 2 * SW);\n    for (const sg of segs) {\n      const xa = max(0, floor((min(sg[0], sg[2]) - r) * 2)), xb = min(SW - 1, Math.ceil((max(sg[0], sg[2]) + r) * 2));\n      const ya = max(0, floor((min(sg[1], sg[3]) - r) * 2)), yb = min(MH * 2 - 1, Math.ceil((max(sg[1], sg[3]) + r) * 2));\n      for (let y = ya; y \u003c= yb; y++)\n        for (let x = xa; x \u003c= xb; x++) if (!hitS[y * SW + x] && segDist((x + 0.5) / 2, (y + 0.5) / 2, sg) \u003c= r) hitS[y * SW + x] = 1;\n    }\n    for (let y = ty0; y \u003c ty1; y++)\n      for (let x = 0; x \u003c MW; x++) {\n        const o = y * 2 * SW + x * 2, hit = hitS[o] + hitS[o + 1] + hitS[o + SW] + hitS[o + SW + 1];\n        if (hit) {\n          mask[y * MW + x] = hit / 4;\n          id[y * MW + x] = k;\n        }\n      }\n  }\n  return { mask, id, n };\n}\n\n// V's picture cut into rectangles, each the front face of one piece.\nfunction cutCells(random) {\n  const cells = [];\n  const cut = (x0, y0, x1, y1, d) => {\n    const w = x1 - x0, h = y1 - y0;\n    if (d > 0 && (w * h \u003c 700 || (w * h \u003c 1300 && random() \u003c 0.4) || d > 5)) {\n      cells.push([x0, y0, x1, y1]);\n      return;\n    }\n    const vert = h > 1.7 * w ? false : w > 1.4 * h ? true : random() \u003c 0.5;\n    const u = 0.32 + 0.36 * random();\n    if (vert) {\n      const xm = round(x0 + w * u);\n      cut(x0, y0, xm, y1, d + 1);\n      cut(xm, y0, x1, y1, d + 1);\n    } else {\n      const ym = round(y0 + h * u);\n      cut(x0, y0, x1, ym, d + 1);\n      cut(x0, ym, x1, y1, d + 1);\n    }\n  };\n  cut(0, 0, W, H, 0);\n  // Depths evenly spread, then shuffled, so near and far pieces mix.\n  const n = cells.length, rank = [];\n  for (let i = 0; i \u003c n; i++) rank.push(-1 + (2 * (i + 0.5)) / n);\n  for (let i = n - 1; i > 0; i--) {\n    const j = floor(random() * (i + 1)), t = rank[i];\n    rank[i] = rank[j];\n    rank[j] = t;\n  }\n  return cells.map((c, i) => ({ c, r: rank[i], kind: c[3] - c[1] > 2.2 * (c[2] - c[0]) ? 2 : random() \u003c 0.45 ? 0 : 1 }));\n}\n\n// World boxes from the cells for a given flatness: a piece at distance d\n// from V is scaled by d so its front face fills its cell exactly from V.\nfunction buildBoxes(S) {\n  const spread = 0.5 * (1 - S.flat);\n  S.boxes = S.cells.map(({ c, r, kind }) => {\n    const d = DV * (1 + spread * r);\n    const x0 = ((c[0] - 32) * d) / F, x1 = ((c[2] - 32) * d) / F;\n    const y0 = ((64 - c[3]) * d) / F, y1 = ((64 - c[1]) * d) / F;\n    const zf = DV - d, w = x1 - x0, h = y1 - y0;\n    // 0 a slab, 1 a box as deep as its short side, 2 a pillar as deep as it is wide.\n    const th = kind === 0 ? 0.14 : kind === 1 ? min(w, h) : w;\n    return [x0, y0, zf - th, x1, y1, zf];\n  });\n  S.vr = new Float32Array(S.boxes.length * 4);\n  S.cr = new Float32Array(S.boxes.length * 4);\n  rects(S.boxes, 0, 0, DV, [0, 0, -1], [1, 0, 0], [0, 1, 0], S.vr);\n}\n\n// Each box's bounding rectangle on the screen of a camera, so a ray only\n// tests the boxes whose rectangle holds its LED.\nfunction rects(boxes, ox, oy, oz, fw, rt, up, out) {\n  for (let i = 0; i \u003c boxes.length; i++) {\n    const b = boxes[i];\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (let c = 0; c \u003c 8; c++) {\n      const X = b[c & 1 ? 3 : 0] - ox, Y = b[c & 2 ? 4 : 1] - oy, Z = b[c & 4 ? 5 : 2] - oz;\n      const z = X * fw[0] + Y * fw[1] + Z * fw[2];\n      if (z \u003c 0.05) { x0 = y0 = -1e9; x1 = y1 = 1e9; break; }\n      const sx = 32 + (F * (X * rt[0] + Y * rt[1] + Z * rt[2])) / z, sy = 64 - (F * (X * up[0] + Y * up[1] + Z * up[2])) / z;\n      x0 = min(x0, sx); x1 = max(x1, sx); y0 = min(y0, sy); y1 = max(y1, sy);\n    }\n    out[i * 4] = x0 - 1; out[i * 4 + 1] = x1 + 1; out[i * 4 + 2] = y0 - 1; out[i * 4 + 3] = y1 + 1;\n  }\n}\n\n// A fixed generator, so the pieces stand where they were looked at; a K1 tap\n// gives it a new seed.\nfunction generator(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\nconst SEED = 7;\n\nexport function setup(params) {\n  params.s = {\n    cells: cutCells(generator(SEED)), boxes: [], vr: null, cr: null, flat: -1, word: -1, words: {}, w: null,\n    p: -0.25, hue: 0, cam: [0, 0, DV], fw: [0, 0, -1], rt: [1, 0, 0], up: [0, 1, 0],\n    hit: { t: 0, b: -1, ax: 0 }, col: [0, 0, 0], pal: new Float32Array(12),\n  };\n}\n\nconst T_LOOP = 16; // seconds for the whole figure eight at Speed 2\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  const speed = cl(kv[1], 0.2, 3);\n  const wi = cl(round(kv[2]), 0, WORDS.length - 1);\n  if (wi !== S.word) {\n    S.word = wi;\n    S.w = S.words[wi] || (S.words[wi] = buildWord(wi));\n  }\n  const flat = cl(kv[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.cells = cutCells(generator(floor(random() * 4294967296)));\n    S.flat = -1;\n  }\n  if (abs(flat - S.flat) > 1e-4) {\n    S.flat = flat;\n    buildBoxes(S);\n  }\n  S.p += (d * speed) / 2 / T_LOOP;\n  // A figure eight through V, slowed to a quarter of its pace there.\n  const tau = 2 * PI * S.p, ts = tau - 0.375 * sin(2 * tau);\n  const th = (52 * PI * sin(ts)) / 180, ph = (17 * PI * sin(2 * ts)) / 180;\n  const r = DV * (1 - 0.16 * sin(ts) * sin(ts));\n  const cam = S.cam;\n  cam[0] = r * cos(ph) * sin(th);\n  cam[1] = r * sin(ph);\n  cam[2] = r * cos(ph) * cos(th);\n  const l = sqrt(cam[0] * cam[0] + cam[1] * cam[1] + cam[2] * cam[2]);\n  const fw = S.fw, rt = S.rt, up = S.up;\n  fw[0] = -cam[0] / l; fw[1] = -cam[1] / l; fw[2] = -cam[2] / l;\n  // right = forward x world up, up = right x forward\n  const rl = sqrt(fw[2] * fw[2] + fw[0] * fw[0]);\n  rt[0] = -fw[2] / rl; rt[1] = 0; rt[2] = fw[0] / rl;\n  up[0] = rt[1] * fw[2] - rt[2] * fw[1];\n  up[1] = rt[2] * fw[0] - rt[0] * fw[2];\n  up[2] = rt[0] * fw[1] - rt[1] * fw[0];\n  rects(S.boxes, cam[0], cam[1], cam[2], fw, rt, up, S.cr);\n}\n\n// The nearest box along o + t d for 0 \u003c t \u003c tmax, testing only the boxes\n// whose screen rectangle in rc holds (sx, sy); fills h.\nfunction trace(boxes, rc, sx, sy, ox, oy, oz, dx, dy, dz, tmax, h) {\n  const ix = 1 / (abs(dx) \u003c 1e-9 ? 1e-9 : dx), iy = 1 / (abs(dy) \u003c 1e-9 ? 1e-9 : dy), iz = 1 / (abs(dz) \u003c 1e-9 ? 1e-9 : dz);\n  let best = tmax, bi = -1, bax = 0;\n  for (let i = 0; i \u003c boxes.length; i++) {\n    if (sx \u003c rc[i * 4] || sx > rc[i * 4 + 1] || sy \u003c rc[i * 4 + 2] || sy > rc[i * 4 + 3]) continue;\n    const b = boxes[i];\n    let t0 = (b[0] - ox) * ix, t1 = (b[3] - ox) * ix;\n    if (t0 > t1) { const q = t0; t0 = t1; t1 = q; }\n    let a0 = (b[1] - oy) * iy, a1 = (b[4] - oy) * iy;\n    if (a0 > a1) { const q = a0; a0 = a1; a1 = q; }\n    let c0 = (b[2] - oz) * iz, c1 = (b[5] - oz) * iz;\n    if (c0 > c1) { const q = c0; c0 = c1; c1 = q; }\n    let tn = t0, ax = 0;\n    if (a0 > tn) { tn = a0; ax = 1; }\n    if (c0 > tn) { tn = c0; ax = 2; }\n    const tf = min(t1, a1, c1);\n    if (tn > 1e-6 && tn \u003c= tf && tn \u003c best) { best = tn; bi = i; bax = ax; }\n  }\n  h.t = best; h.b = bi; h.ax = bax;\n  return bi;\n}\n\nconst LX = 0.42, LY = 0.78, LZ = 0.46; // light from above, right and in front\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.w) return;\n  const { boxes, cam, fw, rt, up, hit, col, pal } = S, wd = S.w, mask = wd.mask, ids = wd.id;\n  for (let k = 0; k \u003c wd.n; k++) {\n    hsv(S.hue + 0.55 + k / wd.n, 1, 1, col);\n    pal[k * 3] = col[0]; pal[k * 3 + 1] = col[1]; pal[k * 3 + 2] = col[2];\n  }\n  const ox = cam[0], oy = cam[1], oz = cam[2];\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const sx = px + 0.5 - 32, sy = 64 - py - 0.5;\n      const dx = fw[0] * F + rt[0] * sx + up[0] * sy;\n      const dy = fw[1] * F + rt[1] * sx + up[1] * sy;\n      const dz = fw[2] * F + rt[2] * sx + up[2] * sy;\n      let r = 0, g = 0, b = 0;\n      const tf = dy \u003c 0 ? (YF - oy) / dy : 1e9;\n      trace(boxes, S.cr, px + 0.5, py + 0.5, ox, oy, oz, dx, dy, dz, tf, hit);\n      const dl = sqrt(dx * dx + dy * dy + dz * dz), foot = (hit.t * dl) / F; // world size of one LED there\n      if (hit.b >= 0) {\n        const B = boxes[hit.b], t = hit.t, ax = hit.ax;\n        const X = ox + t * dx, Y = oy + t * dy, Z = oz + t * dz;\n        const dd = ax === 0 ? dx : ax === 1 ? dy : dz, sg = dd > 0 ? -1 : 1;\n        const lam = max(0, sg * (ax === 0 ? LX : ax === 1 ? LY : LZ));\n        // Where V sees this point: its place in V's picture, and whether\n        // anything stands between it and V.\n        let paint = 0, pk = 0;\n        const depth = DV - Z;\n        if (depth > 0.1) {\n          const u = 32 + (F * X) / depth, v = 64 - (F * Y) / depth;\n          const mx = u * 2 - 0.5, my = v * 2 - 0.5;\n          if (mx >= 0 && my >= 0 && mx \u003c MW - 1 && my \u003c MH - 1) {\n            const ix = floor(mx), iy = floor(my), fx = mx - ix, fy = my - iy, o = iy * MW + ix;\n            const m = (mask[o] * (1 - fx) + mask[o + 1] * fx) * (1 - fy) + (mask[o + MW] * (1 - fx) + mask[o + MW + 1] * fx) * fy;\n            if (m > 0.02) {\n              pk = ids[mask[o] > 0 ? o : mask[o + 1] > 0 ? o + 1 : mask[o + MW] > 0 ? o + MW : o + MW + 1];\n              const vx = X, vy = Y, vz = Z - DV;\n              if (trace(boxes, S.vr, u, v, 0, 0, DV, vx, vy, vz, 1 - 1e-3, hit) \u003c 0) paint = m;\n            }\n          }\n        }\n        // The surface: dim slate, lit from one side, its edges drawn faintly.\n        let e;\n        if (ax === 0) e = min(Y - B[1], B[4] - Y, Z - B[2], B[5] - Z);\n        else if (ax === 1) e = min(X - B[0], B[3] - X, Z - B[2], B[5] - Z);\n        else e = min(X - B[0], B[3] - X, Y - B[1], B[4] - Y);\n        const edge = cl(1 - e / (0.9 * foot), 0, 1);\n        const base = 0.13 + 0.17 * lam + 0.2 * edge * (1 - paint);\n        r = base * 0.86; g = base * 0.93; b = base * 1.12;\n        if (paint > 0) {\n          const pv = min(1, 0.8 + 0.45 * lam);\n          r += (pal[pk * 3] * pv - r) * paint;\n          g += (pal[pk * 3 + 1] * pv - g) * paint;\n          b += (pal[pk * 3 + 2] * pv - b) * paint;\n        }\n      } else if (tf \u003c 1e9) {\n        // The floor: a faint grid one unit square.\n        const X = ox + tf * dx, Z = oz + tf * dz, fo = (tf * dl) / F;\n        const gx = abs(X - round(X)), gz = abs(Z - round(Z));\n        const ln = cl(1 - min(gx, gz) / max(0.02, 0.8 * fo), 0, 1) * cl(1.6 - fo * 5, 0, 1);\n        const fade = cl(1 - (X * X + Z * Z) / 260, 0, 1);\n        r = g = b = (0.03 + 0.14 * ln) * fade;\n        b *= 1.25;\n      }\n      display.setPixel(px, py, floor(cl(r, 0, 1) * 255), floor(cl(g, 0, 1) * 255), floor(cl(b, 0, 1) * 255));\n    }\n}\n","foam-coarsening":"// ===== Patternflow pattern =====\n// Title:   Foam Coarsening\n// Family:  cells\n// Idea:    A fine two-dimensional foam coarsens by Potts-model Monte Carlo on the panel, every cell coloured by how many neighbours it has, so the cells with fewer than six sides glow one colour and shrink away with a spark while the cells with more than six glow the far colour and swell, whatever their size, as von Neumann's law says; when only a fraction of the cells are left a new fine foam is laid down from the top.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: von Neumann's law for two-dimensional foams (John von Neumann, 1952), grain-boundary motion (W. W. Mullins, 1956), Potts-model grain growth (M. P. Anderson, D. J. Srolovitz, G. S. Grest and P. S. Sahni, 1984), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=0..1, Noise=0..1\n//\n// Knob 1: Hue. Turns the side-count colours round the wheel together. At 0 a six-sided cell is cyan, the shrinking five-, four- and three-sided cells go green, lime and orange, and the growing seven-, eight- and nine-sided cells blue, violet and pink.\n// Knob 2: Speed. Monte Carlo sweeps a second, 3.5 at 2 for the finest foam. At the start knobs the 640 seeds leave 608 cells once two sweeps have rounded their walls, and the first new foam comes down after 7.0 s, then one every 8.2 s; at 3 every 5.4 s, at 0.2 every 79 s. A coarser foam gets more sweeps, as the square root of its cell size, since its cells take longer to die.\n// Knob 3: Size. How many cells a new foam is laid down with: 640 at 0, 12.8 LEDs each, down to 60 at 1, 137 LEDs each, evenly in the logarithm between. A foam is laid anew when fewer than 45% of its cells are left: every 8.2 s at 0, 19 s at 0.5 and 32 s at 1, at Speed 2.\n// Knob 4: Noise. The temperature of the Monte Carlo, from 0.12 to 1.22 of a bond. Low, the walls are smooth arcs that slide; high, they shiver and roughen, a cell can lose a corner and win it back, and the foam coarsens faster, a new one every 6.6 s at 1.\n\n// In a two-dimensional foam the walls meet three at a time at 120 degrees\n// and each wall moves toward its centre of curvature at a speed set by its\n// curvature. Add up the turning round a cell with n sides: the walls must\n// turn through 2 pi, the corners take n times pi / 3 of it, so the walls'\n// curvature sums to (pi / 3)(6 - n), and the area changes as\n// dA/dt = kappa (n - 6), independent of the cell's size (von Neumann 1952 for\n// soap froth, Mullins 1956 for grain boundaries). A five-sided cell shrinks\n// even when it is the biggest on the panel.\n//\n// The panel runs the large-Q Potts model the way Anderson, Srolovitz, Grest\n// and Sahni grew grains in 1984: every LED holds the number of its grain,\n// a bond between unlike neighbours costs one, and a Monte Carlo step offers\n// an LED the grain of one of its eight neighbours and takes it when the cost\n// does not rise, or with exp(-rise / T) when it does. The grid is a torus,\n// so no cell touches a wall of the panel's own.\n//\n// Checked by running this file's own update at the start knobs for 300 s,\n// the side counts read every half second and the frames with a front left\n// out (two cells are neighbours when one LED face parts them). Grouped by n,\n// the mean dA/dt in LEDs a second is -3.15 for four sides, -1.50 for five,\n// 0.20 for six, 2.05 for seven, 3.92 for eight, 5.62 for nine and 7.31 for\n// ten. The line through them is 1.77 (n - 5.85), r^2 0.9997, which at 3.5\n// sweeps a second is 0.51 LEDs a sweep for each side. Three-sided cells\n// shrink at only 2.52: they are a few LEDs across, too small for the lattice\n// to bend their walls. The mean side count is 5.87; a lattice cannot draw\n// every short wall, so it stays under the 6 Euler's formula gives a torus.\n\nconst W = 64, H = 128, N = W * H, MAXG = 2048, SHIFT = 11;\nconst { floor, min, exp, sqrt, abs, round, random, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Moore neighbours on the torus: right, left, down, up, then the corners.\nconst NB = new Int32Array(N * 8);\nconst DX = [1, -1, 0, 0, 1, -1, 1, -1], DY = [0, 0, 1, -1, 1, 1, -1, -1];\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++)\n    for (let k = 0; k \u003c 8; k++) NB[(y * W + x) * 8 + k] = ((y + DY[k] + H) % H) * W + ((x + DX[k] + W) % W);\n\nconst FRESH = 640, FEWEST = 60, LEFT = 0.45;\nconst SPARK = 0.35;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  out[1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  out[2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n}\n\nexport function setup(params) {\n  params.s = {\n    g: new Int32Array(N), area: new Int32Array(MAXG), sides: new Uint8Array(MAXG), shown: new Float32Array(MAXG),\n    keys: new Int32Array(N * 2), list: new Int32Array(FRESH),\n    alive: 0, C: 0, laid: 0, debt: 0, T: -1, boltz: new Float32Array(9),\n    front: -1, sx: null, sy: null, sid: null,\n    sparks: [], hue: 0, speed: 2, c: [0, 0, 0], palette: new Float32Array(13 * 3), first: true,\n  };\n}\n\n// The grain of the nearest new seed to an LED centre, on the torus. Only\n// the seeds in a band of rows round it are tried: the band is three seed\n// spacings each way, and a Poisson foam leaves a disc that wide empty about\n// once in 10^12 tries.\nfunction band(S, y) {\n  const { sy } = S, R = 3 * sqrt(N / sy.length) + 2, list = S.list;\n  let m = 0;\n  for (let i = 0; i \u003c sy.length; i++) {\n    let dy = abs(y - sy[i]);\n    if (dy > H / 2) dy = H - dy;\n    if (dy \u003c= R) list[m++] = i;\n  }\n  return m;\n}\n\nfunction nearest(S, x, y, m) {\n  const { sx, sy, sid, list } = S;\n  let best = 1e9, id = sid[0];\n  for (let j = 0; j \u003c m; j++) {\n    const i = list[j];\n    let dx = abs(x - sx[i]), dy = abs(y - sy[i]);\n    if (dx > W / 2) dx = W - dx;\n    if (dy > H / 2) dy = H - dy;\n    const d = dx * dx + dy * dy;\n    if (d \u003c best) (best = d), (id = sid[i]);\n  }\n  return id;\n}\n\n// Seeds for a new Poisson Voronoi foam, each with a grain number no LED holds.\nfunction newSeeds(S, count) {\n  const { area } = S;\n  const sx = new Float32Array(count), sy = new Float32Array(count), sid = new Int32Array(count);\n  let next = 0;\n  for (let i = 0; i \u003c count; i++) {\n    while (area[next] > 0) next++;\n    S.shown[next] = 99;\n    sid[i] = next++;\n    sx[i] = random() * W;\n    sy[i] = random() * H;\n  }\n  S.sx = sx;\n  S.sy = sy;\n  S.sid = sid;\n}\n\nfunction give(S, i, id) {\n  const { g, area } = S, old = g[i];\n  if (old === id) return;\n  if (--area[old] === 0) S.alive--;\n  if (area[id]++ === 0) S.alive++;\n  g[i] = id;\n}\n\nfunction layRow(S, y) {\n  const m = band(S, y + 0.5);\n  for (let x = 0; x \u003c W; x++) give(S, y * W + x, nearest(S, x + 0.5, y + 0.5, m));\n}\n\nfunction layAll(S) {\n  const { g, area } = S;\n  area.fill(0);\n  newSeeds(S, S.C);\n  for (let y = 0; y \u003c H; y++) {\n    const m = band(S, y + 0.5);\n    for (let x = 0; x \u003c W; x++) {\n      const id = nearest(S, x + 0.5, y + 0.5, m);\n      g[y * W + x] = id;\n      area[id]++;\n    }\n  }\n  S.alive = 0;\n  for (let i = 0; i \u003c MAXG; i++) if (area[i] > 0) S.alive++;\n  S.laid = S.C;\n  for (let i = 0; i \u003c MAXG; i++) S.shown[i] = 0;\n}\n\n// Monte Carlo attempts: an LED is offered one neighbour's grain.\nfunction steps(S, count) {\n  const { g, area, boltz, sparks } = S;\n  for (let a = 0; a \u003c count; a++) {\n    const i = (random() * N) | 0, o = i * 8;\n    const b = g[NB[o + ((random() * 8) | 0)]], c = g[i];\n    if (b === c) continue;\n    let rise = 0;\n    for (let k = 0; k \u003c 8; k++) {\n      const q = g[NB[o + k]];\n      if (q === c) rise++;\n      else if (q === b) rise--;\n    }\n    if (rise > 0 && random() >= boltz[rise]) continue;\n    g[i] = b;\n    area[b]++;\n    if (--area[c] === 0) {\n      S.alive--;\n      if (sparks.length \u003c 64) sparks.push({ x: i % W, y: (i / W) | 0, life: SPARK });\n    }\n  }\n}\n\n// The side count of every grain: grains are neighbours when one LED face\n// parts them. Pairs are packed into one integer, sorted and counted once.\nfunction countSides(S) {\n  const { g, keys, sides } = S;\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const a = g[i], r = g[NB[i * 8]], d = g[NB[i * 8 + 2]];\n    if (r !== a) keys[m++] = a \u003c r ? (a \u003c\u003c SHIFT) | r : (r \u003c\u003c SHIFT) | a;\n    if (d !== a) keys[m++] = a \u003c d ? (a \u003c\u003c SHIFT) | d : (d \u003c\u003c SHIFT) | a;\n  }\n  const pairs = keys.subarray(0, m).sort();\n  sides.fill(0);\n  let prev = -1;\n  for (let j = 0; j \u003c m; j++) {\n    const k = pairs[j];\n    if (k === prev) continue;\n    prev = k;\n    sides[k >> SHIFT]++;\n    sides[k & (MAXG - 1)]++;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.C = round(FRESH * pow(FEWEST / FRESH, cl(kv[2], 0, 1)));\n  const T = 0.12 + 1.1 * cl(kv[3], 0, 1);\n  if (T !== S.T) {\n    S.T = T;\n    for (let k = 0; k \u003c 9; k++) S.boltz[k] = exp(-k / T);\n  }\n  if (S.first) {\n    S.first = false;\n    layAll(S);\n    steps(S, 2 * N);\n    countSides(S);\n    for (let i = 0; i \u003c MAXG; i++) S.shown[i] = S.sides[i] - 6;\n  }\n\n  // A new foam comes down from the top as a front, row by row.\n  if (S.front \u003c 0 && (S.alive \u003c LEFT * S.laid || abs(S.C - S.laid) > 0.25 * S.laid)) {\n    newSeeds(S, S.C);\n    S.laid = S.C;\n    S.front = 0;\n  }\n  if (S.front >= 0) {\n    const to = min(H, S.front + (d * S.speed * H) / 2.4);\n    for (let y = floor(S.front); y \u003c floor(to); y++) layRow(S, y);\n    S.front = to >= H ? -1 : to;\n  }\n\n  // Sweeps a second, faster for a coarse foam so its cells still come and go.\n  const rate = 1.75 * S.speed * sqrt(FRESH / S.laid);\n  S.debt += rate * d * N;\n  const n = floor(S.debt);\n  S.debt -= n;\n  steps(S, n);\n  countSides(S);\n\n  const ease = min(1, d * 8);\n  for (let i = 0; i \u003c MAXG; i++) {\n    if (S.area[i] === 0) continue;\n    const want = cl(S.sides[i] - 6, -3, 3);\n    // A grain just laid takes its colour at once.\n    S.shown[i] = S.shown[i] > 50 ? want : S.shown[i] + (want - S.shown[i]) * ease;\n  }\n  for (const s of S.sparks) s.life -= d * S.speed * 0.5;\n  S.sparks = S.sparks.filter((s) => s.life > 0);\n\n  // Thirteen colours for n - 6 from -3 to 3 in half steps.\n  for (let j = 0; j \u003c 13; j++) {\n    const v = j / 2 - 3;\n    hsv(S.hue + 0.5 + 0.13 * v, v === 0 ? 0.45 : 0.9, v === 0 ? 0.85 : 1, S.c);\n    S.palette[j * 3] = S.c[0];\n    S.palette[j * 3 + 1] = S.c[1];\n    S.palette[j * 3 + 2] = S.c[2];\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.first) return;\n  const { g, shown, palette } = S;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, a = g[i];\n      // A wall is the LED whose right or lower neighbour is another grain.\n      if (g[NB[i * 8]] !== a || g[NB[i * 8 + 2]] !== a) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const j = round((shown[a] + 3) * 2) * 3;\n      display.setPixel(x, y, palette[j], palette[j + 1], palette[j + 2]);\n    }\n  // A cell that has just shrunk away flashes white where it closed.\n  for (const s of S.sparks) {\n    const v = 255 * (s.life / SPARK);\n    display.setPixel(s.x, s.y, v, v, v);\n    if (s.life > SPARK / 2) {\n      const u = v * 0.45;\n      display.setPixel((s.x + 1) % W, s.y, u, u, u);\n      display.setPixel((s.x + W - 1) % W, s.y, u, u, u);\n      display.setPixel(s.x, (s.y + 1) % H, u, u, u);\n      display.setPixel(s.x, (s.y + H - 1) % H, u, u, u);\n    }\n  }\n}\n","hunminjeongeum":"// ===== Patternflow pattern =====\n// Title:   Hunminjeongeum\n// Family:  type\n// Idea:    The letter-making chapter of the Hunminjeongeum Haerye grows down the panel as a family tree: the five basic consonants are drawn, each column copies its letter one step down and adds a stroke that lights up as it is drawn (ㄱ to ㅋ, ㄴ to ㄷ to ㅌ, ㅁ to ㅂ to ㅍ, ㅅ to ㅈ to ㅊ, ㅇ to ㆆ to ㅎ), the three letters of a different body (ㆁ, ㄹ, ㅿ) fade in apart, and below them the dot of heaven, the line of earth and the line of man fly together into the eight vowels.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the Jejahae, the chapter on how the letters were made, in the Hunminjeongeum Haerye (King Sejong; Jeong In-ji and seven scholars, 1446), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Style=0..1, Weight=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the strokes a letter takes over are warm gold, the stroke it adds and the vowels' dots are cyan, a stroke being drawn glows near white, and the three letters of a different body are lilac.\n// Knob 2: Speed. At 2 the eight basic letters are drawn stroke by stroke in the first 1.3 s, the second row of each tree grows from 1.05 s, the third from 2.1 s, and the odd three fade in from 3.3 s; from 4.5 s a glow runs down the trees every 2.5 s, and at 15 s everything but the basic letters fades and grows again. At 0.2 ten times slower; at 3 one and a half times faster.\n// Knob 3: Style. 0 is the Haerye's own letterforms of 1446: geometric strokes of one weight, ㅇ a circle, the vowels' dots round and apart from their stem, ㅅ an even pair of legs, a short upright tick on ㅊ and ㅎ, in a warm ink. Turning it moves them to today's forms: the dots stretch into short strokes off the stem, the right leg of ㅅ, ㅈ and ㅊ starts from the middle of the left, the ticks lie flat, the ink cools to white, and the four letters no longer used (ㆍ, ㆁ, ㆆ, ㅿ) fade to an eighth.\n// Knob 4: Weight. The stroke, from 1.5 LED at 0 (1.6 at the opening 0.06) to 3.3 LED at 1; the dots stay rounder than the stroke and grow less.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, exp, atan2, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// Strokes in a unit box, y down. C is a capsule from (x0, y0) to (x1, y1)\n// with r times the pen's half width, and a second set of numbers gives\n// today's form where it differs; a dot is a capsule of length 0 and a large\n// r. O is a ring (centre, radius). A stroke with \"from\" is taken over from\n// another letter, [letter, stroke]; one with add: 1 is the stroke this letter\n// adds; acc: 1 is drawn in the accent colour.\nconst C = (x0, y0, x1, y1, o = {}) => ({ ...o, k: \"C\", h: [x0, y0, x1, y1, o.r || 1], m: o.m ? [...o.m, o.mr || 1] : [x0, y0, x1, y1, o.mr || o.r || 1] });\nconst O = (cx, cy, r, o = {}) => ({ ...o, k: \"O\", h: [cx, cy, r] });\nconst DOT = 2.1;\n\n// The letters: name, place (column, row, area) and strokes. The consonant\n// tree has five columns and three rows; the odd three sit in their own row;\n// the vowels have the three basic letters on one row and the eight made from\n// them on two rows of four.\nconst L = {};\nconst def = (id, area, col, row, lev, strokes, extra = {}) => (L[id] = { id, area, col, row, lev, strokes, ...extra });\n// Consonants, the Jejahae's five shapes: the tongue root closing the throat,\n// the tongue touching the upper gum, the mouth, a tooth, the throat.\ndef(\"ㄱ\", \"c\", 0, 0, 0, [C(0.12, 0.15, 0.86, 0.15), C(0.86, 0.15, 0.86, 0.9)]);\ndef(\"ㄴ\", \"c\", 1, 0, 0, [C(0.15, 0.1, 0.15, 0.85), C(0.15, 0.85, 0.9, 0.85)]);\ndef(\"ㅁ\", \"c\", 2, 0, 0, [C(0.15, 0.15, 0.15, 0.85), C(0.15, 0.15, 0.85, 0.15), C(0.85, 0.15, 0.85, 0.85), C(0.15, 0.85, 0.85, 0.85)]);\ndef(\"ㅅ\", \"c\", 3, 0, 0, [C(0.5, 0.12, 0.1, 0.88), C(0.5, 0.12, 0.9, 0.88, { m: [0.31, 0.5, 0.88, 0.88] })]);\ndef(\"ㅇ\", \"c\", 4, 0, 0, [O(0.5, 0.5, 0.37)]);\n// Each stroke louder by one: ㄱ to ㅋ, ㄴ to ㄷ to ㅌ, ㅁ to ㅂ to ㅍ,\n// ㅅ to ㅈ to ㅊ, ㅇ to ㆆ to ㅎ.\ndef(\"ㅋ\", \"c\", 0, 1, 1, [C(0.12, 0.15, 0.86, 0.15, { from: [\"ㄱ\", 0] }), C(0.86, 0.15, 0.86, 0.9, { from: [\"ㄱ\", 1] }), C(0.12, 0.52, 0.86, 0.52, { add: 1 })]);\ndef(\"ㄷ\", \"c\", 1, 1, 1, [C(0.15, 0.15, 0.15, 0.85, { from: [\"ㄴ\", 0] }), C(0.15, 0.85, 0.88, 0.85, { from: [\"ㄴ\", 1] }), C(0.15, 0.15, 0.88, 0.15, { add: 1 })]);\ndef(\"ㅌ\", \"c\", 1, 2, 2, [C(0.15, 0.15, 0.15, 0.85, { from: [\"ㄷ\", 0] }), C(0.15, 0.85, 0.88, 0.85, { from: [\"ㄷ\", 1] }), C(0.15, 0.15, 0.88, 0.15, { from: [\"ㄷ\", 2] }), C(0.15, 0.5, 0.88, 0.5, { add: 1 })]);\ndef(\"ㅂ\", \"c\", 2, 1, 1, [\n  C(0.17, 0.45, 0.17, 0.88, { from: [\"ㅁ\", 0] }), C(0.17, 0.45, 0.83, 0.45, { from: [\"ㅁ\", 1] }), C(0.83, 0.45, 0.83, 0.88, { from: [\"ㅁ\", 2] }),\n  C(0.17, 0.88, 0.83, 0.88, { from: [\"ㅁ\", 3] }), C(0.17, 0.1, 0.17, 0.45, { add: 1 }), C(0.83, 0.1, 0.83, 0.45, { add: 1 }),\n]);\n// ㅍ has as many strokes as ㅂ in the Haerye's own letterforms, so nothing\n// is added here: ㅂ's strokes move into ㅍ, and the letter keeps no accent.\ndef(\"ㅍ\", \"c\", 2, 2, 2, [\n  C(0.33, 0.5, 0.33, 0.85, { from: [\"ㅂ\", 0] }), C(0.08, 0.15, 0.92, 0.15, { from: [\"ㅂ\", 1] }), C(0.67, 0.5, 0.67, 0.85, { from: [\"ㅂ\", 2] }),\n  C(0.08, 0.85, 0.92, 0.85, { from: [\"ㅂ\", 3] }), C(0.33, 0.15, 0.33, 0.5, { from: [\"ㅂ\", 4] }), C(0.67, 0.15, 0.67, 0.5, { from: [\"ㅂ\", 5] }),\n], { moved: 1 });\ndef(\"ㅈ\", \"c\", 3, 1, 1, [\n  C(0.5, 0.16, 0.12, 0.88, { from: [\"ㅅ\", 0] }), C(0.5, 0.16, 0.88, 0.88, { from: [\"ㅅ\", 1], m: [0.31, 0.52, 0.86, 0.88] }), C(0.1, 0.16, 0.9, 0.16, { add: 1 }),\n]);\ndef(\"ㅊ\", \"c\", 3, 2, 2, [\n  C(0.5, 0.34, 0.14, 0.9, { from: [\"ㅈ\", 0] }), C(0.5, 0.34, 0.86, 0.9, { from: [\"ㅈ\", 1], m: [0.33, 0.62, 0.86, 0.9] }), C(0.1, 0.34, 0.9, 0.34, { from: [\"ㅈ\", 2] }),\n  C(0.5, 0.04, 0.5, 0.24, { add: 1, m: [0.32, 0.14, 0.68, 0.14] }),\n]);\ndef(\"ㆆ\", \"c\", 4, 1, 1, [O(0.5, 0.63, 0.27, { from: [\"ㅇ\", 0] }), C(0.12, 0.2, 0.88, 0.2, { add: 1 })], { old: 1 });\ndef(\"ㅎ\", \"c\", 4, 2, 2, [O(0.5, 0.69, 0.23, { from: [\"ㆆ\", 0] }), C(0.12, 0.33, 0.88, 0.33, { from: [\"ㆆ\", 1] }), C(0.5, 0.04, 0.5, 0.22, { add: 1, m: [0.3, 0.14, 0.7, 0.14] })]);\n// The three that are not made by adding a stroke: ㆁ takes the throat's\n// circle, ㄹ and ㅿ copy the tongue and the tooth with a different body.\ndef(\"ㆁ\", \"x\", 0, 0, 3, [C(0.5, 0.04, 0.5, 0.3), O(0.5, 0.63, 0.29)], { old: 1 });\ndef(\"ㄹ\", \"x\", 1, 0, 3, [C(0.12, 0.12, 0.86, 0.12), C(0.86, 0.12, 0.86, 0.5), C(0.86, 0.5, 0.14, 0.5), C(0.14, 0.5, 0.14, 0.88), C(0.14, 0.88, 0.88, 0.88)]);\ndef(\"ㅿ\", \"x\", 3, 0, 3, [C(0.5, 0.12, 0.1, 0.86), C(0.5, 0.12, 0.9, 0.86), C(0.1, 0.86, 0.9, 0.86)], { old: 1 });\n// Vowels: heaven round, earth flat, man upright.\ndef(\"ㆍ\", \"b\", 0, 0, 0, [C(0.5, 0.5, 0.5, 0.5, { r: DOT * 1.25, acc: 1, mr: DOT * 1.25 })], { old: 1 });\ndef(\"ㅡ\", \"b\", 1, 0, 0, [C(0.06, 0.5, 0.94, 0.5)]);\ndef(\"ㅣ\", \"b\", 2, 0, 0, [C(0.5, 0.06, 0.5, 0.94)]);\n// First out: one dot with earth or man. Again out: a second dot, from ㅣ.\nconst dot = (x, y, from, m, add) => C(x, y, x, y, { r: DOT, acc: 1, from, m, add });\ndef(\"ㅗ\", \"v\", 0, 0, 1, [C(0.06, 0.7, 0.94, 0.7, { from: [\"ㅡ\", 0] }), dot(0.5, 0.38, [\"ㆍ\", 0], [0.5, 0.7, 0.5, 0.4])]);\ndef(\"ㅏ\", \"v\", 1, 0, 1, [C(0.36, 0.06, 0.36, 0.94, { from: [\"ㅣ\", 0] }), dot(0.7, 0.5, [\"ㆍ\", 0], [0.36, 0.5, 0.68, 0.5])]);\ndef(\"ㅜ\", \"v\", 2, 0, 1, [C(0.06, 0.3, 0.94, 0.3, { from: [\"ㅡ\", 0] }), dot(0.5, 0.62, [\"ㆍ\", 0], [0.5, 0.3, 0.5, 0.6])]);\ndef(\"ㅓ\", \"v\", 3, 0, 1, [C(0.64, 0.06, 0.64, 0.94, { from: [\"ㅣ\", 0] }), dot(0.3, 0.5, [\"ㆍ\", 0], [0.32, 0.5, 0.64, 0.5])]);\ndef(\"ㅛ\", \"v\", 0, 1, 2, [C(0.06, 0.7, 0.94, 0.7, { from: [\"ㅗ\", 0] }), dot(0.31, 0.38, [\"ㅗ\", 1], [0.35, 0.7, 0.35, 0.4]), dot(0.69, 0.38, null, [0.65, 0.7, 0.65, 0.4], 1)]);\ndef(\"ㅑ\", \"v\", 1, 1, 2, [C(0.36, 0.06, 0.36, 0.94, { from: [\"ㅏ\", 0] }), dot(0.7, 0.31, [\"ㅏ\", 1], [0.36, 0.35, 0.68, 0.35]), dot(0.7, 0.69, null, [0.36, 0.65, 0.68, 0.65], 1)]);\ndef(\"ㅠ\", \"v\", 2, 1, 2, [C(0.06, 0.3, 0.94, 0.3, { from: [\"ㅜ\", 0] }), dot(0.31, 0.62, [\"ㅜ\", 1], [0.35, 0.3, 0.35, 0.6]), dot(0.69, 0.62, null, [0.65, 0.3, 0.65, 0.6], 1)]);\ndef(\"ㅕ\", \"v\", 3, 1, 2, [C(0.64, 0.06, 0.64, 0.94, { from: [\"ㅓ\", 0] }), dot(0.3, 0.31, [\"ㅓ\", 1], [0.32, 0.35, 0.64, 0.35]), dot(0.3, 0.69, null, [0.32, 0.65, 0.64, 0.65], 1)]);\nconst ORDER = Object.keys(L);\n\n// Boxes on the panel. Consonants: five columns 12.8 LEDs apart, glyphs\n// 12 x 14, rows 19 apart. The odd three on row 57. Vowels: the basic three\n// on row 77, the eight on rows 94 and 111, glyphs 15 x 15.\nfunction place(g) {\n  if (g.area === \"c\" || g.area === \"x\") {\n    const cx = 6.4 + g.col * 12.8;\n    return [cx - 6, g.area === \"x\" ? 57 : 1 + g.row * 19, 12, 14];\n  }\n  if (g.area === \"b\") return [12 + g.col * 20 - 7.5, 77, 15, 15];\n  return [8 + g.col * 16 - 7.5, 94 + g.row * 17, 15, 15];\n}\nfor (const id of ORDER) {\n  const g = L[id];\n  g.box = place(g);\n  for (const s of g.strokes) if (s.acc === undefined) s.acc = s.add || 0;\n}\n\n// Beats at Speed 2, in seconds of build time.\nconst TRACE = 0.26, FLY = 0.5, T_LEV = [0, 1.05, 2.1, 3.3], STAG = 0.12, GLOW = 0.7, PULSE = 2.5, T_CYCLE = 15, T_FADE = 1;\n\nfunction startOf(g) {\n  return T_LEV[g.lev] + (g.area === \"v\" ? 0.3 + g.col * STAG : g.area === \"x\" ? g.col * 0.25 : g.col * STAG);\n}\n\nexport function setup(params) {\n  params.s = { T: 0, cyc: 0, hue: 0, speed: 2, style: 0, w: 0.8, buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.style = cl(kv[2], 0, 1);\n  S.w = 0.75 + 0.9 * cl(kv[3], 0, 1);\n  S.T += (d * S.speed) / 2;\n  // After the hold, everything but the basic letters fades and grows again.\n  if (S.T > T_CYCLE + T_FADE) {\n    S.T = T_LEV[1] - 0.3;\n    S.cyc++;\n  }\n}\n\n// One stroke's shape on the panel for a letter, at the current style: a\n// capsule [x0, y0, x1, y1, r] or a ring [cx, cy, R, 0, 0] in LEDs.\nfunction shape(S, g, s, out) {\n  const [bx, by, bw, bh] = g.box, st = S.style;\n  if (s.k === \"O\") {\n    out[0] = bx + s.h[0] * bw;\n    out[1] = by + s.h[1] * bh;\n    out[2] = s.h[2] * min(bw, bh);\n    out[3] = out[4] = 0;\n    return out;\n  }\n  for (let i = 0; i \u003c 4; i++) {\n    const v = s.h[i] + (s.m[i] - s.h[i]) * st;\n    out[i] = (i & 1 ? by + v * bh : bx + v * bw);\n  }\n  // A dot is rounder than the pen and grows less with Weight.\n  const rad = (k) => (k > 1.5 ? (k > 2.2 ? 0.95 + 1.2 * S.w : 0.75 + S.w) : S.w);\n  out[4] = rad(s.h[4]) + (rad(s.m[4]) - rad(s.h[4])) * st;\n  return out;\n}\n\nfunction segDist(px, py, x0, y0, x1, y1) {\n  const dx = x1 - x0, dy = y1 - y0, l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / l, 0, 1) : 0;\n  const ex = x0 + t * dx - px, ey = y0 + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// Paints one stroke: coverage over a 1-LED edge, plus a soft halo when it\n// glows. u is how much of it is drawn (a capsule from its start, a ring\n// from the top going left, the way ㅇ is written).\nfunction paint(S, k, g5, u, rgb, alpha, glow, w) {\n  const buf = S.buf, ring = k === \"O\";\n  let x0 = g5[0], y0 = g5[1], x1 = g5[2], y1 = g5[3], r = g5[4];\n  if (!ring && u \u003c 1) (x1 = x0 + (x1 - x0) * u), (y1 = y0 + (y1 - y0) * u);\n  const R = ring ? g5[2] : 0, pr = ring ? w : r, halo = glow > 0.01 ? 2.6 : 0;\n  const ext = (ring ? R + pr : pr) + halo + 1;\n  const xa = max(0, floor((ring ? x0 : min(x0, x1)) - ext)), xb = min(W - 1, Math.ceil((ring ? x0 : max(x0, x1)) + ext));\n  const ya = max(0, floor((ring ? y0 : min(y0, y1)) - ext)), yb = min(H - 1, Math.ceil((ring ? y0 : max(y0, y1)) + ext));\n  const sweep = u * 2 * PI;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let d;\n      if (ring) {\n        const dx = px - x0, dy = py - y0;\n        let a = atan2(-dx, -dy);\n        if (a \u003c 0) a += 2 * PI;\n        if (u >= 1 || a \u003c= sweep) d = abs(sqrt(dx * dx + dy * dy) - R);\n        else {\n          const ex = x0 - R * sin(sweep), ey = y0 - R * cos(sweep);\n          d = min(sqrt((px - x0) ** 2 + (py - y0 + R) ** 2), sqrt((px - ex) ** 2 + (py - ey) ** 2));\n        }\n      } else d = segDist(px, py, x0, y0, x1, y1);\n      const cov = cl(pr + 0.5 - d, 0, 1) * alpha;\n      let v = cov;\n      if (halo) v = max(v, glow * 0.55 * exp(-((d - pr) * (d - pr)) / 2.2) * alpha);\n      if (v \u003c= 0.004) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = max(buf[o], rgb[0] * v);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * v);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * v);\n    }\n}\n\nfunction line(S, x0, y0, x1, y1, rgb, a) {\n  paint(S, \"C\", [x0, y0, x1, y1, 0.35], 1, rgb, a, 0, 0);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, T = S.T, st = S.style, h = S.hue;\n  buf.fill(0);\n  // The ink cools from the warm tone of the printed page to plain white.\n  const ink = hsv(h + 0.11 - 0.03 * st, 0.55 - 0.45 * st, 0.9, [0, 0, 0]);\n  const acc = hsv(h + 0.5, 0.72, 1, [0, 0, 0]);\n  const odd = hsv(h + 0.78, 0.38, 0.8, [0, 0, 0]);\n  const hot = hsv(h + 0.5, 0.15, 1, [0, 0, 0]);\n  const dim = hsv(h + 0.5, 0.5, 0.3, [0, 0, 0]);\n  // Fade of everything grown, at the end of a cycle.\n  const fadeAll = T > T_CYCLE ? 1 - (T - T_CYCLE) / T_FADE : 1;\n  const tmp = [0, 0, 0, 0, 0], src = [0, 0, 0, 0, 0], g5 = [0, 0, 0, 0, 0], col = [0, 0, 0];\n  // Rules between consonants, the odd three and vowels.\n  if (T > T_LEV[3] - 0.2) {\n    const a = cl((T - T_LEV[3] + 0.2) / 0.6, 0, 1) * fadeAll * 0.5;\n    for (let x = 2; x \u003c 62; x += 3) line(S, x, 54.5, x + 1, 54.5, dim, a);\n  }\n  const ar = cl(T / 0.8, 0, 1) * 0.5;\n  for (let x = 2; x \u003c 62; x += 3) line(S, x, 74, x + 1, 74, dim, ar);\n  // The last pulse of the hold: a glow that runs down each tree.\n  const tEnd = T_LEV[3] + 1.2, pT = T > tEnd ? T - tEnd - floor((T - tEnd) / PULSE) * PULSE : -9;\n  for (const id of ORDER) {\n    const g = L[id], t0 = startOf(g), lt = g.lev === 0 && S.cyc > 0 ? 99 : T - t0;\n    if (lt \u003c 0) continue;\n    const grown = g.lev > 0 ? fadeAll : 1;\n    const oldDim = g.old ? 1 - 0.88 * st : 1;\n    const isOdd = g.area === \"x\";\n    // The tree's branch from the letter above.\n    if (g.area === \"c\" && g.lev > 0) {\n      const [bx, by] = g.box, cx = bx + 6, u = ease(lt / FLY);\n      line(S, cx, by - 4.2, cx, by - 4.2 + 3.4 * u, dim, grown * 0.8);\n    }\n    let nAdd = 0;\n    for (let i = 0; i \u003c g.strokes.length; i++) {\n      const s = g.strokes[i];\n      shape(S, g, s, g5);\n      let u = 1, alpha = grown * oldDim, glow = 0, rgb = ink;\n      if (isOdd) {\n        alpha *= ease(lt / 0.9);\n        rgb = odd;\n      } else if (g.lev === 0) {\n        // Basic letters: drawn stroke by stroke.\n        const a = lt - i * TRACE;\n        if (a \u003c 0) continue;\n        u = ease(a / TRACE);\n        glow = a \u003c TRACE ? 1 : exp(-(a - TRACE) / GLOW) * 0.6;\n        rgb = s.acc ? acc : ink;\n      } else if (s.from) {\n        // Taken over: flies from the letter it came from.\n        const f = L[s.from[0]];\n        shape(S, f, f.strokes[s.from[1]], src);\n        const e = ease(lt / FLY);\n        for (let j = 0; j \u003c 5; j++) tmp[j] = src[j] + (g5[j] - src[j]) * e;\n        for (let j = 0; j \u003c 5; j++) g5[j] = tmp[j];\n        rgb = s.acc ? acc : ink;\n        // ㅍ's strokes and the vowels' dots light as they land.\n        if (g.moved || s.acc) glow = lt \u003c FLY ? 0.5 * e : exp(-(lt - FLY) / GLOW);\n      } else {\n        // The added stroke: drawn after the rest has landed, glowing.\n        const a = lt - FLY - nAdd * TRACE;\n        nAdd++;\n        if (a \u003c 0) continue;\n        u = ease(a / TRACE);\n        glow = a \u003c TRACE ? 1 : exp(-(a - TRACE) / GLOW);\n        rgb = acc;\n      }\n      if (pT >= 0 && !isOdd && (s.add || (g.moved && g.lev > 0) || (s.acc && g.lev > 0))) {\n        const q = pT - (g.lev - 1) * 0.45 - (g.area === \"v\" ? 0.2 : 0);\n        if (q >= 0) glow = max(glow, exp(-q / 0.45) * 0.9);\n      }\n      if (glow > 0.02) {\n        const k = min(1, glow) * 0.8;\n        for (let j = 0; j \u003c 3; j++) col[j] = rgb[j] + (hot[j] - rgb[j]) * k;\n        paint(S, s.k, g5, u, col, alpha, glow, S.w);\n      } else paint(S, s.k, g5, u, rgb, alpha, 0, S.w);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, min(255, buf[o]) | 0, min(255, buf[o + 1]) | 0, min(255, buf[o + 2]) | 0);\n    }\n}\n","inversions":"// ===== Patternflow pattern =====\n// Title:   Inversions\n// Family:  type\n// Idea:    A two-syllable word stands on the panel, one 64 x 64 syllable above the other, and the whole panel turns slowly about its centre, so that at half a turn the same strokes read as another word, 곰국 (bone broth) as 논문 (a thesis), rests there, and turns on back to the first.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rotational lettering, Inversions (Scott Kim, 1981), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..8, Weight=-1..1\n//\n// Knob 1: Hue. The colour belongs to the panel, not to the word: a gradient runs from the top row to the bottom one, at 0 from sea green through cyan to blue, and the letters pass through it as they turn, so the syllable on top is always the top colour. The light a stroke leaves behind as it swings is a deeper shade of the same row.\n// Knob 2: Speed. At 2 a half turn takes 1.6 s and the word rests 2 s at each end, so it reads the second word from 1.95 s to 3.95 s and the first again from 5.55 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Word. Nine words, each checked LED by LED against its turned reading: 곰국 turns into 논문, 공공 into 운운, 눅눅 into 녹녹, 용융 into itself, MOM into WOW, and NOON, SWIMS, pod and suns into themselves.\n// Knob 4: Weight. The pen, from 2.1 LEDs at -1 through 5.9 at the start to 9.1 at 1, for Hangul and three letters; NOON and suns take 0.85 of it and SWIMS 0.7. The strokes are round-capped lines and rings sampled 16 times an LED, and the turned bitmap equals the other word's at every weight.\n// Buttons: K1 tap starts the next half turn at once.\n\nconst W = 64, H = 128, N = W * H, SS = 4;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The word list. Each turns half round into the word in the comment; the\n// knob line above says how the pairs were checked.\nconst WORDS = [\"곰국\", \"공공\", \"눅눅\", \"용융\", \"MOM\", \"NOON\", \"SWIMS\", \"pod\", \"suns\"];\n// 논문, 운운, 녹녹, 용융, WOW, NOON, SWIMS, pod, suns\n\n// Primitives, all in panel coordinates with integer or half-integer ends so\n// that turning about (32, 64) maps every one exactly onto another:\n// [1, x0, x1, y] a horizontal stroke, [2, y0, y1, x] a vertical one,\n// [0, x0, y0, x1, y1] a slanted one, [3, cx, cy, rx, ry, cut, flip] an\n// elliptic ring, cut 0 whole, 1 its upper half, 2 the bowl of an S; flip\n// reads the cut turned half round.\nfunction line(out, x0, y0, x1, y1) {\n  if (y0 === y1) out.push([1, min(x0, x1), max(x0, x1), y0]);\n  else if (x0 === x1) out.push([2, min(y0, y1), max(y0, y1), x0]);\n  else out.push([0, x0, y0, x1, y1]);\n}\nconst ring = (out, cx, cy, rx, ry, cut, flip) => out.push([3, cx, cy, rx, ry, cut || 0, flip || 0]);\n\n// ---- Hangul ----\n// A syllable with a horizontal vowel is three rows in its 64 x 64 cell: the\n// initial consonant in a box at the top, the vowel's bar across the middle,\n// the final in a box at the bottom. The bottom box is the top box turned half\n// round the cell's centre (32, 32), and the bars of ㅗ and ㅜ sit two rows\n// either side of row 32, so a turned syllable swaps its initial and final,\n// turns each over, and is a syllable again when the turned shapes are jamo:\n// ㄱ turns into ㄴ, ㅁ ㅇ ㄹ ㅍ into themselves, ㅗ into ㅜ, ㅛ into ㅠ, ㅡ stays.\nconst CHO = { 0: \"g\", 2: \"n\", 5: \"r\", 6: \"m\", 11: \"o\", 17: \"p\" };\nconst JONG = { 1: \"g\", 4: \"n\", 8: \"r\", 16: \"m\", 21: \"o\", 26: \"p\" };\nconst BOX_T = 6, BOX_B = 18, BOX_L = 11, BOX_R = 53;\n\nfunction consonant(out, k, l, t, r, b) {\n  const m = (t + b) / 2;\n  if (k === \"g\") line(out, l, t, r, t), line(out, r, t, r, b);\n  else if (k === \"n\") line(out, l, t, l, b), line(out, l, b, r, b);\n  else if (k === \"m\") line(out, l, t, r, t), line(out, r, t, r, b), line(out, l, b, r, b), line(out, l, t, l, b);\n  else if (k === \"o\") ring(out, (l + r) / 2, m, 13, (b - t) / 2);\n  else if (k === \"r\") line(out, l, t, r, t), line(out, r, t, r, m), line(out, l, m, r, m), line(out, l, m, l, b), line(out, l, b, r, b);\n  else if (k === \"p\") line(out, l, t, r, t), line(out, l, b, r, b), line(out, l + 10, t, l + 10, b), line(out, r - 10, t, r - 10, b);\n}\n\nfunction vowel(out, v, oy) {\n  // 8 ㅗ, 12 ㅛ, 13 ㅜ, 17 ㅠ, 18 ㅡ.\n  if (v === 18) return line(out, 6, oy + 32, 58, oy + 32);\n  const up = v === 8 || v === 12, bar = oy + (up ? 35.5 : 28.5), tip = oy + (up ? 28.5 : 35.5);\n  line(out, 6, bar, 58, bar);\n  for (const x of v === 8 || v === 13 ? [32] : [24, 40]) line(out, x, tip, x, bar);\n}\n\nfunction syllable(out, ch, oy) {\n  const c = ch.charCodeAt(0) - 0xac00, cho = floor(c / 588), jung = floor((c % 588) / 28), jong = c % 28;\n  consonant(out, CHO[cho], BOX_L, oy + BOX_T, BOX_R, oy + BOX_B);\n  vowel(out, jung, oy);\n  consonant(out, JONG[jong], BOX_L, oy + 64 - BOX_B, BOX_R, oy + 64 - BOX_T);\n}\n\n// ---- Latin ----\n// Letters stand one above another at a whole-number pitch centred on row 64,\n// so the turn sends slot i to slot n - 1 - i. M is drawn with upright sides\n// so that W is the same strokes turned, n is an arch on two stems and u the\n// arch turned, p and d share one bowl and a stem the length of the other's.\nfunction letter(out, ch, l, t, r, b, a) {\n  const c = (l + r) / 2, m = (t + b) / 2, hx = (r - l) / 2, q = (b - t) / 4, v = round(0.62 * (b - t));\n  if (ch === \"N\") line(out, l, b, l, t), line(out, l, t, r, b), line(out, r, b, r, t);\n  else if (ch === \"O\" || ch === \"o\") ring(out, c, m, hx, (b - t) / 2);\n  else if (ch === \"I\") line(out, c, t, c, b), line(out, c - 7, t, c + 7, t), line(out, c - 7, b, c + 7, b);\n  else if (ch === \"M\") line(out, l, b, l, t), line(out, l, t, c, t + v), line(out, c, t + v, r, t), line(out, r, t, r, b);\n  else if (ch === \"W\") line(out, l, t, l, b), line(out, l, b, c, b - v), line(out, c, b - v, r, b), line(out, r, b, r, t);\n  else if (ch === \"S\" || ch === \"s\") ring(out, c, t + q, hx, q, 2, 0), ring(out, c, b - q, hx, q, 2, 1);\n  else if (ch === \"n\") line(out, l, b, l, t + hx), line(out, r, b, r, t + hx), ring(out, c, t + hx, hx, hx, 1, 0);\n  else if (ch === \"u\") line(out, l, t, l, b - hx), line(out, r, t, r, b - hx), ring(out, c, b - hx, hx, hx, 1, 1);\n  else if (ch === \"p\") ring(out, c, m, hx, (b - t) / 2), line(out, l, t, l, b + a);\n  else if (ch === \"d\") ring(out, c, m, hx, (b - t) / 2), line(out, r, t - a, r, b);\n}\n\nconst LATIN = {\n  3: { pitch: 42, pen: 1, caps: [12, 52, 34], low: [17, 47, 18, 9] },\n  4: { pitch: 32, pen: 0.85, caps: [12, 52, 24], low: [15, 49, 22, 0] },\n  5: { pitch: 25, pen: 0.7, caps: [13, 51, 16], low: [16, 48, 14, 0] },\n};\n\nfunction wordPrims(word) {\n  const out = [];\n  if (word.charCodeAt(0) >= 0xac00) {\n    syllable(out, word[0], 0);\n    syllable(out, word[1], 64);\n    return out;\n  }\n  const n = word.length, L = LATIN[n];\n  for (let i = 0; i \u003c n; i++) {\n    const ch = word[i], yc = 64 + (i - (n - 1) / 2) * L.pitch;\n    const caps = ch \u003c \"a\", [l, r, h, a] = caps ? [L.caps[0], L.caps[1], L.caps[2], 0] : L.low;\n    const narrow = ch === \"S\" ? (n === 5 ? 7 : 4) : ch === \"s\" ? 4 : 0;\n    letter(out, ch, l + narrow, yc - h / 2, r - narrow, yc + h / 2, a);\n  }\n  return out;\n}\n\n// The pen for a weight, thinner for four and five letters, in eighths of an\n// LED with an odd numerator: samples sit on odd eighths, so no sample is ever\n// exactly half a pen from a straight stroke and none can tip either way.\nfunction penOf(word, weight) {\n  const scale = word.charCodeAt(0) >= 0xac00 ? 1 : LATIN[word.length].pen;\n  return (2 * round((5.6 + 3.5 * weight) * scale * 4) + 1) / 8;\n}\n\n// One sample against one primitive: within half the pen of the stroke.\nfunction inside(p, px, py, hw, hw2) {\n  const k = p[0];\n  if (k === 1) {\n    const dx = px \u003c p[1] ? p[1] - px : px > p[2] ? px - p[2] : 0, dy = py - p[3];\n    return dx * dx + dy * dy \u003c= hw2;\n  }\n  if (k === 2) {\n    const dy = py \u003c p[1] ? p[1] - py : py > p[2] ? py - p[2] : 0, dx = px - p[3];\n    return dx * dx + dy * dy \u003c= hw2;\n  }\n  if (k === 0) {\n    const ax = p[1], ay = p[2], ux = p[3] - ax, uy = p[4] - ay, l2 = ux * ux + uy * uy;\n    const t = cl(((px - ax) * ux + (py - ay) * uy) / l2, 0, 1), ex = ax + t * ux - px, ey = ay + t * uy - py;\n    return ex * ex + ey * ey \u003c= hw2;\n  }\n  let dx = px - p[1], dy = py - p[2];\n  if (p[6]) (dx = -dx), (dy = -dy);\n  const rx = p[3], ry = p[4], nx = dx / rx, ny = dy / ry;\n  if (p[5] === 1 && dy > 0) return false;\n  // The S bowl leaves out its lower right quarter and the upper right up to\n  // about 35 degrees, where the stroke ends.\n  if (p[5] === 2 && dx > 0 && (dy > 0 || -ny \u003c 0.7 * nx)) return false;\n  const q = sqrt(nx * nx + ny * ny), g = sqrt((nx / rx) * (nx / rx) + (ny / ry) * (ny / ry));\n  if (q === 0) return min(rx, ry) \u003c= hw;\n  return (abs(q - 1) * q) / g \u003c= hw;\n}\n\n// The word's bitmap: 16 samples an LED, the count of those inside a stroke.\nfunction render(prims, pen, out) {\n  const hw = pen / 2, hw2 = hw * hw, bits = new Uint16Array(N);\n  for (const p of prims) {\n    let x0, x1, y0, y1;\n    if (p[0] === 1) (x0 = p[1]), (x1 = p[2]), (y0 = y1 = p[3]);\n    else if (p[0] === 2) (y0 = p[1]), (y1 = p[2]), (x0 = x1 = p[3]);\n    else if (p[0] === 0) (x0 = min(p[1], p[3])), (x1 = max(p[1], p[3])), (y0 = min(p[2], p[4])), (y1 = max(p[2], p[4]));\n    else (x0 = p[1] - p[3]), (x1 = p[1] + p[3]), (y0 = p[2] - p[4]), (y1 = p[2] + p[4]);\n    const X0 = max(0, floor(x0 - hw - 1)), X1 = min(W - 1, floor(x1 + hw + 1));\n    const Y0 = max(0, floor(y0 - hw - 1)), Y1 = min(H - 1, floor(y1 + hw + 1));\n    for (let y = Y0; y \u003c= Y1; y++)\n      for (let x = X0; x \u003c= X1; x++) {\n        const o = y * W + x;\n        let b = bits[o];\n        if (b === 0xffff) continue;\n        for (let j = 0; j \u003c SS; j++)\n          for (let i = 0; i \u003c SS; i++) {\n            const bit = 1 \u003c\u003c (j * SS + i);\n            if (!(b & bit) && inside(p, x + (i + 0.5) / SS, y + (j + 0.5) / SS, hw, hw2)) b |= bit;\n          }\n        bits[o] = b;\n      }\n  }\n  for (let o = 0; o \u003c N; o++) {\n    let b = bits[o], c = 0;\n    while (b) (b &= b - 1), c++;\n    out[o] = c;\n  }\n  return out;\n}\n\n// Beats at Speed 2, in seconds: the rest at each end and the half turn.\nconst REST = 2, TURN = 1.6;\n\nexport function setup(params) {\n  params.s = {\n    word: -1, pen: -1, hits: new Uint8Array(N), cov: new Float32Array(N), trail: new Float32Array(N),\n    ph: REST - 0.35, ang: 0, hue: -1, row: new Float32Array(H * 3), ghost: new Float32Array(H * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const word = cl(round(kv[2]), 0, WORDS.length - 1), pen = penOf(WORDS[word], cl(kv[3], -1, 1));\n  if (word !== S.word || pen !== S.pen) {\n    S.word = word;\n    S.pen = pen;\n    render(wordPrims(WORDS[word]), pen, S.hits);\n  }\n  if (input.btnPressed && input.btnPressed[0] && S.rest) S.ph = S.half * (REST + TURN) + REST;\n  S.ph += (d * cl(kv[1], 0.2, 3)) / 2;\n  const k = floor(S.ph / (REST + TURN)), u = S.ph - k * (REST + TURN);\n  S.rest = u \u003c REST;\n  S.half = k;\n  S.ang = (k + (S.rest ? 0 : ease((u - REST) / TURN))) * PI;\n  S.dt = d;\n  if (kv[0] !== S.hue) {\n    S.hue = kv[0];\n    for (let y = 0; y \u003c H; y++) {\n      const h = S.hue + 0.42 + 0.2 * (y / (H - 1));\n      hsv(h, 0.72, 1, S.row, y * 3);\n      hsv(h + 0.07, 1, 0.5, S.ghost, y * 3);\n    }\n  }\n}\n\n// Bilinear read of the word's bitmap at word-space (x, y), LED centres on\n// whole numbers.\nfunction sample(hits, x, y) {\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  let v = 0;\n  if (y0 >= 0 && y0 \u003c H) {\n    const o = y0 * W;\n    if (x0 >= 0 && x0 \u003c W) v += hits[o + x0] * (1 - fx) * (1 - fy);\n    if (x0 + 1 >= 0 && x0 + 1 \u003c W) v += hits[o + x0 + 1] * fx * (1 - fy);\n  }\n  if (y0 + 1 >= 0 && y0 + 1 \u003c H) {\n    const o = (y0 + 1) * W;\n    if (x0 >= 0 && x0 \u003c W) v += hits[o + x0] * (1 - fx) * fy;\n    if (x0 + 1 >= 0 && x0 + 1 \u003c W) v += hits[o + x0 + 1] * fx * fy;\n  }\n  return v;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.word \u003c 0) return;\n  const { hits, cov, trail, row, ghost } = S;\n  if (S.rest) {\n    // At rest the panel shows the bitmap itself, or the bitmap read from the\n    // far corner: LED (x, y) shows LED (63 - x, 127 - y).\n    const flip = S.half % 2 === 1;\n    for (let o = 0; o \u003c N; o++) cov[o] = hits[flip ? N - 1 - o : o] / 16;\n  } else {\n    // Turning, the word shrinks so its 128 rows lie down across 64 columns\n    // at a quarter turn, losing a row or two of each end against the sides.\n    const a = S.ang, sn = sin(a), s = 1 - 0.47 * sn * sn, c = cos(a) / s, si = sn / s;\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let v = 0;\n        for (let j = 0; j \u003c 2; j++)\n          for (let i = 0; i \u003c 2; i++) {\n            const u = x + 0.25 + 0.5 * i - 32, w = y + 0.25 + 0.5 * j - 64;\n            v += sample(hits, 31.5 + c * u + si * w, 63.5 - si * u + c * w);\n          }\n        cov[y * W + x] = v / 64;\n      }\n  }\n  const fade = exp(-S.dt / 0.09);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x, c = cov[o], t = max(c, trail[o] * fade);\n      trail[o] = t;\n      const g = t - c;\n      display.setPixel(x, y, row[y * 3] * c + ghost[y * 3] * g, row[y * 3 + 1] * c + ghost[y * 3 + 1] * g, row[y * 3 + 2] * c + ghost[y * 3 + 2] * g);\n    }\n}\n","jacobi-geodesics":"// ===== Patternflow pattern =====\n// Title:   Jacobi Geodesics\n// Family:  space\n// Idea:    A three-axis ellipsoid stands the height of the panel and turns, and 36 geodesics leave one of its four umbilics in every direction at once: their front wraps the body and closes again to a single point at the opposite umbilic, then comes home; past the middle of K4 one long geodesic winds instead, filling the band between its two caustic lines of curvature.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: geodesics on the triaxial ellipsoid (Carl Gustav Jacob Jacobi, 1839), their caustics (Michel Chasles, 1846), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Launch=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel: at 0 the fan runs from cyan at its two ends through blue to violet in the middle of its directions, the body is a dim blue with rose lines of curvature, the long geodesic is violet and its caustics warm white. The body keeps to the hues from green to violet, which stay colours this dim.\n// Knob 2: Speed. At 2 the front runs 27 LEDs a second, so the fan from the umbilic closes at the opposite one after 4.7 s and is home at 9.3 s, and a new fan leaves after a 0.6 s fade. The body turns half round in the time of one pass, so the closing point faces you. At 0.2 ten times slower.\n// Knob 3: Axes. The half axes are 1 (60 LEDs, up the panel), 0.5 and c, with c from 0.2 at 0 to 0.45 at 1. The umbilics sit in the plane of the longest and shortest axes, at 0.884 of the half length at 0 and 0.970 at 1, nearer the tips as the body grows rounder, and the way from one to the opposite one is half the perimeter of that principal ellipse, 2.101 at 0 and 2.360 at 1.\n// Knob 4: Launch. Up to 0.08 the fan starts exactly on the umbilic. To 0.5 its start slides along the same principal ellipse toward the waist and the front no longer closes but folds into cusps. From 0.5 one geodesic leaves the end of the middle axis at 10 degrees from the long axis, turning to 60 at 1: at Axes 0 it circles the short axis over both tips up to 0.68, passes through the umbilics there, and then circles the long axis in a belt round the waist that narrows until, at 1, its caustics run between 0.50 and 0.57 of the half length above and below it.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, asin, atan2, PI, exp, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst SC = 60; // LEDs per unit: the long half axis a = 1 is 60 LEDs\nconst NB = 36; // rays in the fan\nconst DS = 0.02; // arc length between trail points\nconst STEP = 0.005; // largest RK4 step\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The body x^2 + y^2/b^2 + z^2/c^2 = 1, x up the panel.\nfunction setAxes(S, k) {\n  S.b = 0.5;\n  S.c = 0.5 * (0.4 + 0.5 * k);\n  S.A = 1; S.B = 1 / (S.b * S.b); S.C = 1 / (S.c * S.c);\n  const b2 = S.b * S.b, c2 = S.c * S.c;\n  // The four umbilics, in the plane of the long and short axes.\n  S.ux = sqrt((1 - b2) / (1 - c2));\n  S.uz = S.c * sqrt((b2 - c2) / (1 - c2));\n  // Half the perimeter of that principal ellipse: every geodesic from an\n  // umbilic reaches the opposite one after exactly this length.\n  let per = 0, px = 1, pz = 0;\n  for (let i = 1; i \u003c= 2000; i++) {\n    const t = (PI * i) / 2000, x = cos(t), z = S.c * sin(t);\n    per += hypot(x - px, z - pz);\n    px = x; pz = z;\n  }\n  S.hp = per;\n}\n\n// Geodesic acceleration on F = 0: x'' = -(v.Hv / |grad F|^2) grad F.\nfunction acc(S, p, v, o) {\n  const gx = p[0] * S.A, gy = p[1] * S.B, gz = p[2] * S.C;\n  const k = -(v[0] * v[0] * S.A + v[1] * v[1] * S.B + v[2] * v[2] * S.C) / (gx * gx + gy * gy + gz * gz);\n  o[0] = k * gx; o[1] = k * gy; o[2] = k * gz;\n}\n\n// Back onto the surface and the tangent plane, at unit speed.\nfunction settle(S, p, v) {\n  const s = 1 / sqrt(p[0] * p[0] * S.A + p[1] * p[1] * S.B + p[2] * p[2] * S.C);\n  p[0] *= s; p[1] *= s; p[2] *= s;\n  const gx = p[0] * S.A, gy = p[1] * S.B, gz = p[2] * S.C;\n  const d = (v[0] * gx + v[1] * gy + v[2] * gz) / (gx * gx + gy * gy + gz * gz);\n  v[0] -= d * gx; v[1] -= d * gy; v[2] -= d * gz;\n  const n = hypot(v[0], v[1], v[2]);\n  v[0] /= n; v[1] /= n; v[2] /= n;\n}\n\nconst K1 = [0, 0, 0], K2 = [0, 0, 0], K3 = [0, 0, 0], K4 = [0, 0, 0], P2 = [0, 0, 0], V2 = [0, 0, 0], VA = [0, 0, 0], VB = [0, 0, 0];\nfunction rk4(S, p, v, h) {\n  acc(S, p, v, K1);\n  for (let i = 0; i \u003c 3; i++) { P2[i] = p[i] + 0.5 * h * v[i]; V2[i] = v[i] + 0.5 * h * K1[i]; }\n  acc(S, P2, V2, K2);\n  for (let i = 0; i \u003c 3; i++) { VA[i] = V2[i]; P2[i] = p[i] + 0.5 * h * VA[i]; V2[i] = v[i] + 0.5 * h * K2[i]; }\n  acc(S, P2, V2, K3);\n  for (let i = 0; i \u003c 3; i++) { VB[i] = V2[i]; P2[i] = p[i] + h * VB[i]; V2[i] = v[i] + h * K3[i]; }\n  acc(S, P2, V2, K4);\n  for (let i = 0; i \u003c 3; i++) {\n    p[i] += (h / 6) * (v[i] + 2 * VA[i] + 2 * VB[i] + V2[i]);\n    v[i] += (h / 6) * (K1[i] + 2 * K2[i] + 2 * K3[i] + K4[i]);\n  }\n  settle(S, p, v);\n}\n\n// The two ellipsoidal coordinates c^2 \u003c mu \u003c b^2 \u003c nu \u003c 1 of a point on the\n// body: the roots besides 0 of sum x_i^2 / (a_i^2 - s) = 1.\nfunction ellc(S, x, y, z, out) {\n  const A2 = 1, B2 = S.b * S.b, C2 = S.c * S.c, x2 = x * x, y2 = y * y, z2 = z * z;\n  const bb = x2 + y2 + z2 - A2 - B2 - C2, cc = A2 * B2 + A2 * C2 + B2 * C2 - x2 * (B2 + C2) - y2 * (A2 + C2) - z2 * (A2 + B2);\n  const dq = sqrt(max(0, bb * bb - 4 * cc));\n  out[0] = (-bb - dq) / 2;\n  out[1] = (-bb + dq) / 2;\n  return out;\n}\n\n// A point on the principal ellipse of the long and short axes, at parameter t.\nconst onEllipse = (S, t) => [cos(t), 0, S.c * sin(t)];\n\nexport function setup(params) {\n  params.s = {\n    b: 0.5, c: 0.2, A: 1, B: 4, C: 25, ux: 0, uz: 0, hp: 2,\n    axes: -1, launch: -1, mode: 0, hue: 0, speed: 2,\n    s: 0, rho: 0, fade: 1, rays: [], lam: 0, caustic: [],\n    buf: new Float32Array(W * H * 3), G1: new Float32Array(W * H), G2: new Float32Array(W * H), SH: new Float32Array(W * H),\n    col: [0, 0, 0], e: [0, 0],\n  };\n}\n\n// The fan: NB rays from the start, one per direction. Launch below 0.08\n// starts on the umbilic.\nfunction launchFan(S) {\n  const L = S.launch, tu = atan2(S.uz / S.c, S.ux);\n  const off = cl((L - 0.08) / 0.42, 0, 1);\n  const t = tu + off * 0.55 * (PI / 2 - tu);\n  const p0 = onEllipse(S, t), e1 = [-sin(t), 0, S.c * cos(t)], l = hypot(e1[0], e1[2]);\n  e1[0] /= l; e1[2] /= l;\n  S.rays = [];\n  for (let k = 0; k \u003c NB; k++) {\n    const al = (2 * PI * (k + 0.5)) / NB;\n    const p = p0.slice(), v = [cos(al) * e1[0], sin(al), cos(al) * e1[2]];\n    settle(S, p, v);\n    S.rays.push({ p, v, tr: [p[0], p[1], p[2]], acc: 0, al });\n  }\n  S.s = 0;\n  S.fade = 1;\n}\n\n// One long geodesic from the end of the middle axis, (0, b, 0), aimed at\n// beta from the long axis, run 24 units ahead so its band is already half\n// filled. Its constant is lambda = mu (t.e_nu)^2 + nu (t.e_mu)^2 with e_mu\n// and e_nu the principal directions; here mu = c^2, nu = 1 and those are z\n// and x, so lambda = c^2 cos^2 beta + sin^2 beta. The geodesic keeps to\n// mu \u003c= lambda, a ring round the short axis over both tips, when lambda \u003c\n// b^2, and to nu >= lambda, a belt round the long axis, when lambda > b^2.\nfunction launchOne(S) {\n  const u = (S.launch - 0.5) / 0.5, be = ((10 + 50 * u) * PI) / 180;\n  const p = [0, S.b, 0], v = [cos(be), 0, sin(be)];\n  settle(S, p, v);\n  S.lam = S.c * S.c * cos(be) * cos(be) + sin(be) * sin(be);\n  S.caustic = causticLines(S, S.lam);\n  const r = { p, v, tr: [p[0], p[1], p[2]], acc: 0, al: be };\n  S.rays = [r];\n  advance(S, r, 24, 3000);\n  S.s = 0;\n  S.fade = 1;\n}\n\n// The lines of curvature at lambda, as point lists: two closed curves.\nfunction causticLines(S, lam) {\n  const a2 = 1, b2 = S.b * S.b, c2 = S.c * S.c, out = [];\n  for (const sg of [1, -1]) {\n    const pts = [];\n    for (let i = 0; i \u003c= 160; i++) {\n      const ph = (2 * PI * i) / 160;\n      let x, y, z;\n      if (lam > b2) {\n        const mu = c2 + (b2 - c2) * sin(ph) * sin(ph), nu = lam;\n        x = sg * sqrt(max(0, ((a2 - mu) * (a2 - nu)) / ((a2 - b2) * (a2 - c2))));\n        y = (cos(ph) \u003c 0 ? -1 : 1) * S.b * sqrt(max(0, ((b2 - mu) * (nu - b2)) / ((a2 - b2) * (b2 - c2))));\n        z = (sin(ph) \u003c 0 ? -1 : 1) * S.c * sqrt(max(0, ((mu - c2) * (nu - c2)) / ((a2 - c2) * (b2 - c2))));\n      } else {\n        const mu = lam, nu = b2 + (a2 - b2) * sin(ph) * sin(ph);\n        x = (cos(ph) \u003c 0 ? -1 : 1) * sqrt(max(0, ((a2 - mu) * (a2 - nu)) / ((a2 - b2) * (a2 - c2))));\n        y = (sin(ph) \u003c 0 ? -1 : 1) * S.b * sqrt(max(0, ((b2 - mu) * (nu - b2)) / ((a2 - b2) * (b2 - c2))));\n        z = sg * S.c * sqrt(max(0, ((mu - c2) * (nu - c2)) / ((a2 - c2) * (b2 - c2))));\n      }\n      pts.push(x, y, z);\n    }\n    out.push(pts);\n  }\n  return out;\n}\n\n// Moves a ray on by length L, dropping a trail point every DS, keeping at most cap.\nfunction advance(S, r, L, cap) {\n  let left = L;\n  while (left > 1e-9) {\n    const h = min(STEP, left, DS - r.acc + 1e-12);\n    rk4(S, r.p, r.v, h);\n    left -= h;\n    r.acc += h;\n    if (r.acc >= DS - 1e-9) {\n      r.acc = 0;\n      r.tr.push(r.p[0], r.p[1], r.p[2]);\n      if (r.tr.length > cap * 3) r.tr.splice(0, r.tr.length - cap * 3);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const ax = cl(kv[2], 0, 1), L = cl(kv[3], 0, 1);\n  let fresh = false;\n  if (abs(ax - S.axes) > 1e-4) { S.axes = ax; setAxes(S, ax); fresh = true; }\n  if (abs(L - S.launch) > 1e-4) { S.launch = L; fresh = true; }\n  S.mode = S.launch \u003c 0.5 ? 0 : 1;\n  if (fresh) (S.mode ? launchOne : launchFan)(S);\n  const ds = (0.45 * S.speed * d) / 2;\n  if (S.mode === 0) {\n    // Out to the opposite umbilic and home again, then a short fade and a new fan.\n    if (S.s \u003c 2 * S.hp) {\n      const step = min(ds, 2 * S.hp - S.s);\n      for (const r of S.rays) advance(S, r, step, 45);\n      S.s += step;\n    } else {\n      S.fade -= d * 1.6;\n      if (S.fade \u003c= 0) launchFan(S);\n    }\n  } else {\n    advance(S, S.rays[0], ds, 3000);\n    S.s += ds;\n  }\n  // Half a turn for every pass from umbilic to umbilic.\n  S.rho += (PI * ds) / S.hp;\n}\n\n// How close a LED is to a level line of G, n lines over 0..1, in LEDs, from\n// the step to its neighbours: 1 on the line, 0 a LED away.\nfunction gridLine(G, SH, p, px, py, n) {\n  const g = G[p], gx = px + 1 \u003c W && SH[p + 1] >= 0 ? abs(G[p + 1] - g) : 0, gy = py + 1 \u003c H && SH[p + W] >= 0 ? abs(G[p + W] - g) : 0;\n  const gr = max(gx, gy, 1e-4), f = abs(g * n - round(g * n)) / n;\n  return cl(1 - f / gr / 0.9, 0, 1);\n}\n\nfunction plot(buf, x, y, r, g, b) {\n  const x0 = floor(x - 0.5), y0 = floor(y - 0.5), fx = x - 0.5 - x0, fy = y - 0.5 - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = x0 + i, Y = y0 + j;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const w = (i ? fx : 1 - fx) * (j ? fy : 1 - fy) * 1.5, o = (Y * W + X) * 3;\n      buf[o] = max(buf[o], r * w); buf[o + 1] = max(buf[o + 1], g * w); buf[o + 2] = max(buf[o + 2], b * w);\n    }\n}\n\nfunction line(buf, x0, y0, x1, y1, r, g, b) {\n  const n = max(1, Math.ceil(hypot(x1 - x0, y1 - y0) / 0.6));\n  for (let i = 0; i \u003c= n; i++) plot(buf, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, r, g, b);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.axes \u003c 0) return;\n  const { buf, G1, G2, SH, col } = S;\n  const cr = cos(S.rho), sr = sin(S.rho), b = S.b, c = S.c, b2 = b * b, c2 = c * c;\n  const hb = 0.5 + S.hue, e = S.e;\n  buf.fill(0);\n  // The body: orthographic, seen along z after turning by rho about x.\n  for (let py = 0; py \u003c H; py++) {\n    const x = (64 - py - 0.5) / SC;\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, yp = (px + 0.5 - 32) / SC;\n      // y = yp cr + zp sr, z = -yp sr + zp cr; solve for the front zp.\n      const qa = (sr * sr) / b2 + (cr * cr) / c2, qb = 2 * yp * cr * sr * (1 / b2 - 1 / c2);\n      const qc = x * x + yp * yp * ((cr * cr) / b2 + (sr * sr) / c2) - 1;\n      const disc = qb * qb - 4 * qa * qc;\n      if (disc \u003c= 0) { SH[p] = -1; continue; }\n      const zp = (-qb + sqrt(disc)) / (2 * qa), y = yp * cr + zp * sr, z = -yp * sr + zp * cr;\n      const nx = x, ny = y / b2, nz = z / c2, nl = sqrt(nx * nx + ny * ny + nz * nz);\n      const vz = (ny * sr + nz * cr) / nl, vy = (ny * cr - nz * sr) / nl;\n      SH[p] = cl(0.35 + 0.65 * (0.55 * vz + 0.35 * (nx / nl) - 0.25 * vy), 0, 1) * cl(disc * 40, 0, 1);\n      ellc(S, x, y, z, e);\n      G1[p] = (2 / PI) * asin(sqrt(cl((e[0] - c2) / (b2 - c2), 0, 1)));\n      G2[p] = (2 / PI) * asin(sqrt(cl((e[1] - b2) / (1 - b2), 0, 1)));\n    }\n  }\n  hsv(hb + 0.42, 0.55, 1, col);\n  const lr = col[0], lg = col[1], lb = col[2];\n  // The body's own dim colour keeps to the hues from green to violet, since\n  // red, orange and yellow read brown this dim.\n  hsv(0.3 + 0.55 * ((((hb + 0.12) % 1) + 1) % 1), 0.75, 1, col);\n  const br = col[0], bg = col[1], bb = col[2];\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px;\n      if (SH[p] \u003c 0) continue;\n      const sh = SH[p], o = p * 3;\n      // Lines of curvature: six of mu, eight of nu, about a LED wide.\n      const ln = max(gridLine(G1, SH, p, px, py, 6), gridLine(G2, SH, p, px, py, 8));\n      // The band a long geodesic keeps to, lit faintly.\n      let band = 0;\n      if (S.mode === 1) {\n        const m = (G1[p] * PI) / 2, nn = (G2[p] * PI) / 2;\n        const mu = c2 + (b2 - c2) * sin(m) * sin(m), nu = b2 + (1 - b2) * sin(nn) * sin(nn);\n        band = S.lam > b2 ? (nu >= S.lam ? 1 : 0) : mu \u003c= S.lam ? 1 : 0;\n      }\n      const v = (0.09 + 0.16 * sh) * (1 + 0.9 * band);\n      buf[o] = v * br + ln * lr * 0.17 * (0.4 + 0.6 * sh);\n      buf[o + 1] = v * bg + ln * lg * 0.17 * (0.4 + 0.6 * sh);\n      buf[o + 2] = v * bb + ln * lb * 0.17 * (0.4 + 0.6 * sh);\n    }\n  // Body point to screen, and whether it faces us.\n  const proj = (x, y, z, out) => {\n    out[0] = 32 + SC * (y * cr - z * sr);\n    out[1] = 64 - SC * x;\n    out[2] = (y / b2) * sr + (z / c2) * cr > 0 ? 1 : 0.3;\n    return out;\n  };\n  const q0 = [0, 0, 0], q1 = [0, 0, 0];\n  // Caustics of the long geodesic.\n  if (S.mode === 1) {\n    hsv(hb + 0.62, 0.25, 1, col);\n    for (const pts of S.caustic)\n      for (let i = 3; i \u003c pts.length; i += 3) {\n        proj(pts[i - 3], pts[i - 2], pts[i - 1], q0);\n        proj(pts[i], pts[i + 1], pts[i + 2], q1);\n        const w = 0.6 * min(q0[2], q1[2]);\n        line(buf, q0[0], q0[1], q1[0], q1[1], col[0] * w, col[1] * w, col[2] * w);\n      }\n  }\n  // Trails and the front.\n  const f = S.fade, nr = S.rays.length;\n  for (let k = 0; k \u003c nr; k++) {\n    const r = S.rays[k], tr = r.tr, n = tr.length / 3;\n    hsv(S.mode ? hb + 0.3 : hb + 0.17 * (1 - cos(r.al)), 0.85, 1, col);\n    for (let i = 1; i \u003c n; i++) {\n      proj(tr[i * 3 - 3], tr[i * 3 - 2], tr[i * 3 - 1], q0);\n      proj(tr[i * 3], tr[i * 3 + 1], tr[i * 3 + 2], q1);\n      const age = (n - i) / n, w = f * min(q0[2], q1[2]) * (S.mode ? 0.5 + 0.5 * exp(-age * 4) : 0.15 + 0.6 * (1 - age));\n      line(buf, q0[0], q0[1], q1[0], q1[1], col[0] * w, col[1] * w, col[2] * w);\n    }\n  }\n  if (S.mode === 0 && S.s > 0) {\n    for (let k = 0; k \u003c nr; k++) {\n      const r = S.rays[k], r2 = S.rays[(k + 1) % nr];\n      proj(r.p[0], r.p[1], r.p[2], q0);\n      proj(r2.p[0], r2.p[1], r2.p[2], q1);\n      hsv(hb + 0.17 * (1 - cos(r.al)), 0.5, 1, col);\n      const w = f * min(q0[2], q1[2]);\n      line(buf, q0[0], q0[1], q1[0], q1[1], col[0] * w, col[1] * w, col[2] * w);\n    }\n  } else if (S.mode === 1) {\n    const r = S.rays[0];\n    proj(r.p[0], r.p[1], r.p[2], q0);\n    plot(buf, q0[0], q0[1], q0[2], q0[2], q0[2]);\n  }\n  // The four umbilics.\n  for (const [sx, sz] of [[1, 1], [1, -1], [-1, 1], [-1, -1]]) {\n    proj(sx * S.ux, 0, sz * S.uz, q0);\n    const w = q0[2] > 0.5 ? 1 : 0.35;\n    plot(buf, q0[0], q0[1], w, w, w);\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, floor(cl(buf[o], 0, 1) * 255), floor(cl(buf[o + 1], 0, 1) * 255), floor(cl(buf[o + 2], 0, 1) * 255));\n  }\n}\n","klein-sails":"// ===== Patternflow pattern =====\n// Title:   Klein's Sails\n// Family:  number\n// Idea:    The integer lattice flows along hyperbolas under the real powers of an integer matrix that fixes the line y = ax and its conjugate, with the X of the two lines standing lengthwise on the panel, and in each corner of the X the boundary of the convex hull of the lattice points, Klein's sail, slides along itself, its corners on the convergents of a towards y = ax, until after one unit of flow every point and every corner sits where another one was and the loop closes.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Klein's sails of continued fractions (Felix Klein, 1895), periodic continued fractions of quadratic irrationals (Joseph-Louis Lagrange, 1770), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Number=0..5, Zoom=10..22\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the sail below the line y = ax and its copy through the centre are azure, the other two rose, the two lines a near-white lilac and the lattice points dim teal with short tails along their hyperbolas.\n// Knob 2: Speed. The flow in hyperbolic angle, 0.32 a second at 2, so a point keeps its product of distances to the two lines and moves 37% further out along y = ax each second. One loop takes log e seconds over 0.32: 5.5 s for the square root of 2, 3.0 s for the golden ratio. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Number. Which quadratic irrational a, with its continued fraction and the matrix M that loops the flow: 0 the square root of 2 = [1; 2, 2, ...] with M = [[3, 2], [4, 3]], 1 the golden ratio [1; 1, 1, ...] with [[1, 1], [1, 2]], 2 the square root of 3 = [1; 1, 2, 1, 2, ...] with [[2, 1], [3, 2]], 3 the square root of 5 = [2; 4, 4, ...] with [[9, 4], [20, 9]], 4 the square root of 7 = [2; 1, 1, 1, 4, ...] with [[8, 3], [21, 8]], 5 (1 + square root of 13) / 2 = [2; 3, 3, ...] with [[4, 3], [9, 7]]. A sail edge runs through a_k - 1 lattice points between its corners, and its a_k is written beside it when there is room.\n// Knob 4: Zoom. LEDs between neighbouring lattice points, 10 to 22. At 10 the panel is 6.4 lattice steps wide and each sail keeps two or three corners on it for the square root of 2, four for the golden ratio; at 22 it is 2.9 steps wide with one or two corners a sail, and an edge is long enough to count the lattice points along it.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, exp, log, atan, cos, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// a is the larger root of a^2 = P a + Q, and the unit e = A + B a of Z[a]\n// is the fundamental one. Multiplying by e in the basis 1, a is the integer\n// matrix [[A, B], [B Q, A + B P]] whose determinant is the norm of e; it\n// sends (1, a) to e (1, a) and (1, a') to e' (1, a'). With norm -1 it swaps\n// two corners of the X, so the flow loops on its square.\nconst NUMS = [\n  { P: 0, Q: 2, A: 1, B: 1 },\n  { P: 1, Q: 1, A: 0, B: 1 },\n  { P: 0, Q: 3, A: 2, B: 1 },\n  { P: 0, Q: 5, A: 2, B: 1 },\n  { P: 0, Q: 7, A: 8, B: 3 },\n  { P: 1, Q: 3, A: 1, B: 1 },\n];\n\nconst gcd = (a, b) => {\n  a = abs(a);\n  b = abs(b);\n  while (b) [a, b] = [b, a % b];\n  return a;\n};\nconst mul = (m, v) => [m[0] * v[0] + m[1] * v[1], m[2] * v[0] + m[3] * v[1]];\n\nfunction prepare(num) {\n  const { P, Q, A, B } = num, root = sqrt(P * P + 4 * Q);\n  const al = (P + root) / 2, al2 = (P - root) / 2;\n  let M = [A, B, B * Q, A + B * P], e = A + B * al;\n  if (M[0] * M[3] - M[1] * M[2] \u003c 0) (M = [M[0] * M[0] + M[1] * M[2], M[0] * M[1] + M[1] * M[3], M[2] * M[0] + M[3] * M[2], M[2] * M[1] + M[3] * M[3]]), (e *= e);\n  const Mi = [M[3], -M[1], -M[2], M[0]];\n  // Eigen-coordinates: n = u (1, a) + w (1, a').\n  const den = al - al2;\n  const eig = (x, y) => [(y - al2 * x) / den, (al * x - y) / den];\n  // The corners of the X: K1 holds u > 0, w > 0 (the positive x axis, below\n  // y = a x), K2 holds u > 0, w \u003c 0 (above it); K3 and K4 are their negatives.\n  const sails = [];\n  for (const sign of [1, -1]) {\n    const pts = [];\n    const R = 40;\n    for (let x = -R; x \u003c= R; x++)\n      for (let y = -R; y \u003c= R; y++) {\n        const [u, w] = eig(x, y);\n        if (u > 0 && sign * w > 0) pts.push([u, sign * w, x, y]);\n      }\n    pts.sort((p, q) => p[0] - q[0]);\n    // The lower left hull in (u, w): a point that does not lie lower than the\n    // last corner is inside the hull plus the corner's quadrant, and a corner\n    // that the next point sees on its far side is no corner. The turn is read\n    // from the integer coordinates, so points on an edge never count as\n    // corners by a rounding error.\n    const hull = [];\n    for (const p of pts) {\n      if (hull.length && p[1] >= hull[hull.length - 1][1]) continue;\n      while (hull.length >= 2) {\n        const o = hull[hull.length - 2], a = hull[hull.length - 1];\n        const c = (a[2] - o[2]) * (p[3] - o[3]) - (a[3] - o[3]) * (p[2] - o[2]);\n        if (sign * c >= 0) hull.pop();\n        else break;\n      }\n      hull.push(p);\n    }\n    // One period: from the corner nearest the middle of the corner of the X\n    // to its image under M, which is again a corner.\n    let i0 = 0;\n    for (let i = 1; i \u003c hull.length; i++) if (abs(log(hull[i][0] / hull[i][1])) \u003c abs(log(hull[i0][0] / hull[i0][1]))) i0 = i;\n    const to = mul(M, [hull[i0][2], hull[i0][3]]);\n    let j = i0 + 1;\n    while (j \u003c hull.length && !(hull[j][2] === to[0] && hull[j][3] === to[1])) j++;\n    const period = hull.slice(i0, j).map((p) => [p[2], p[3]]);\n    // The whole sail, as far as the flow can bring it onto the panel.\n    const verts = [];\n    for (let k = -6; k \u003c= 6; k++) {\n      let m = [1, 0, 0, 1];\n      for (let s = 0; s \u003c abs(k); s++) {\n        const n = k > 0 ? M : Mi;\n        m = [n[0] * m[0] + n[1] * m[2], n[0] * m[1] + n[1] * m[3], n[2] * m[0] + n[3] * m[2], n[2] * m[1] + n[3] * m[3]];\n      }\n      for (const v of period) verts.push(mul(m, v));\n    }\n    sails.push(verts.map((v) => [...v, ...eig(v[0], v[1])]));\n  }\n  // The K2 corner's bisector stands straight up.\n  const th1 = atan(al), th2 = atan(al2), gam = PI / 2 - (th1 + th2 + PI) / 2;\n  return { al, al2, e, le: log(e), M, eig, sails, cg: cos(gam), sg: sin(gam), th1, th2 };\n}\n\nexport function setup(params) {\n  params.s = { idx: -1, num: null, t: 0, buf: new Float32Array(W * H * 3), tail: new Float32Array(W * H), hue: -1, cols: [] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const idx = cl(round(kv[2]), 0, NUMS.length - 1);\n  if (idx !== S.idx) {\n    S.idx = idx;\n    S.num = NUMS[idx].prep || (NUMS[idx].prep = prepare(NUMS[idx]));\n    S.t = 0;\n    S.tail.fill(0);\n  }\n  S.zoom = cl(kv[3], 10, 22);\n  S.t += (d * 0.16 * cl(kv[1], 0.2, 3)) / S.num.le;\n  S.t -= floor(S.t);\n  S.dt = d;\n  if (kv[0] !== S.hue) {\n    S.hue = kv[0];\n    const h = kv[0] + 0.56;\n    S.cols = [hsv(h, 0.7, 1, [0, 0, 0]), hsv(h + 0.36, 0.55, 1, [0, 0, 0]), hsv(h + 0.2, 0.18, 0.88, [0, 0, 0]), hsv(h - 0.06, 0.55, 0.62, [0, 0, 0])];\n  }\n}\n\n// Lights a soft line from (x0, y0) to (x1, y1), its value kept where higher.\nfunction seg(buf, x0, y0, x1, y1, wid, rgb, k) {\n  if ((x0 \u003c -2 && x1 \u003c -2) || (x0 > W + 1 && x1 > W + 1) || (y0 \u003c -2 && y1 \u003c -2) || (y0 > H + 1 && y1 > H + 1)) return;\n  const X0 = max(0, floor(min(x0, x1) - wid)), X1 = min(W - 1, ceil(max(x0, x1) + wid));\n  const Y0 = max(0, floor(min(y0, y1) - wid)), Y1 = min(H - 1, ceil(max(y0, y1) + wid));\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy || 1e-9;\n  for (let y = Y0; y \u003c= Y1; y++)\n    for (let x = X0; x \u003c= X1; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / l2, 0, 1);\n      const ex = px - t * dx, ey = py - t * dy, a = cl(wid / 2 + 0.5 - sqrt(ex * ex + ey * ey), 0, 1) * k;\n      if (a \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = max(buf[o], rgb[0] * a);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * a);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * a);\n    }\n}\n\nfunction dot(buf, cx, cy, r, rgb, k) {\n  const X0 = max(0, floor(cx - r - 1)), X1 = min(W - 1, floor(cx + r + 1)), Y0 = max(0, floor(cy - r - 1)), Y1 = min(H - 1, floor(cy + r + 1));\n  for (let y = Y0; y \u003c= Y1; y++)\n    for (let x = X0; x \u003c= X1; x++) {\n      const ex = x + 0.5 - cx, ey = y + 0.5 - cy, a = cl(r + 0.5 - sqrt(ex * ex + ey * ey), 0, 1) * k;\n      if (a \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = max(buf[o], rgb[0] * a);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * a);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * a);\n    }\n}\n\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\nfunction digit(buf, d, x0, y0, rgb) {\n  const b = DIG[d];\n  for (let r = 0; r \u003c 5; r++)\n    for (let q = 0; q \u003c 3; q++) {\n      const x = x0 + q, y = y0 + r;\n      if (b[r * 3 + q] !== \"1\" || x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      buf[o] = rgb[0];\n      buf[o + 1] = rgb[1];\n      buf[o + 2] = rgb[2];\n    }\n}\n\n// The picture at flow time t: every lattice point n at M^t n, the sails\n// carried along with it. M^t stretches u by e^t and shrinks w by e^t.\nfunction frame(S, t, buf, tail) {\n  const N = S.num, z = S.zoom, et = exp(t * N.le), al = N.al, al2 = N.al2, { cg, sg } = N;\n  const [cA, cB, cL, cD] = S.cols;\n  // Plane (x, y) to panel.\n  const px = (x, y) => 32 + z * (x * cg - y * sg), py = (x, y) => 64 - z * (x * sg + y * cg);\n  const at = (u, w) => {\n    const U = u * et, V = w / et, x = U + V, y = U * al + V * al2;\n    return [px(x, y), py(x, y)];\n  };\n  buf.fill(0);\n  // Lattice points: the panel, two LEDs wider each way, pulled back by M^-t\n  // into the integer plane is a parallelogram; its columns are scanned.\n  const corners = [];\n  for (const [X, Y] of [[-2, -2], [W + 2, -2], [W + 2, H + 2], [-2, H + 2]]) {\n    const a = (X - 32) / z, b = (64 - Y) / z, x = a * cg + b * sg, y = -a * sg + b * cg;\n    const [u, w] = N.eig(x, y), U = u / et, V = w * et;\n    corners.push([U + V, U * al + V * al2]);\n  }\n  const xs = corners.map((c) => c[0]);\n  for (let x = ceil(min(...xs)); x \u003c= floor(max(...xs)); x++) {\n    let lo = Infinity, hi = -Infinity;\n    for (let i = 0; i \u003c 4; i++) {\n      const a = corners[i], b = corners[(i + 1) % 4];\n      if ((a[0] - x) * (b[0] - x) > 0 || a[0] === b[0]) continue;\n      const y = a[1] + ((x - a[0]) * (b[1] - a[1])) / (b[0] - a[0]);\n      lo = min(lo, y);\n      hi = max(hi, y);\n    }\n    for (let y = ceil(lo); y \u003c= floor(hi); y++) {\n      const [u, w] = N.eig(x, y), [X, Y] = at(u, w);\n      if (X \u003c -2 || X > W + 2 || Y \u003c -2 || Y > H + 2) continue;\n      // A small square of light split over the four LEDs nearest it, read\n      // from the LED centres so a point on a border splits evenly instead of\n      // tipping one way on a rounding error.\n      const cx = X - 0.5 + 1e-9, cy = Y - 0.5 + 1e-9, xi = floor(cx), yi = floor(cy), fx = cx - xi, fy = cy - yi;\n      for (const [dx, dy, a] of [[0, 0, (1 - fx) * (1 - fy)], [1, 0, fx * (1 - fy)], [0, 1, (1 - fx) * fy], [1, 1, fx * fy]]) {\n        const xx = xi + dx, yy = yi + dy;\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tail[yy * W + xx] = max(tail[yy * W + xx], 0.3 + 0.7 * a);\n      }\n    }\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const v = tail[i] * 0.8;\n    buf[i * 3] = cD[0] * v;\n    buf[i * 3 + 1] = cD[1] * v;\n    buf[i * 3 + 2] = cD[2] * v;\n  }\n  // The two lines, through the centre.\n  for (const th of [N.th1, N.th2]) {\n    const c = cos(th) * 200, s = sin(th) * 200;\n    seg(buf, px(-c, -s), py(-c, -s), px(c, s), py(c, s), 1, cL, 1);\n  }\n  // The four sails, their corners and the lattice points on their edges.\n  for (let k = 0; k \u003c 4; k++) {\n    const sail = N.sails[k & 1], sgn = k \u003c 2 ? 1 : -1, col = k & 1 ? cB : cA;\n    let prev = null;\n    for (let i = 0; i \u003c sail.length; i++) {\n      const v = sail[i], p = at(sgn * v[2], sgn * v[3]);\n      if (prev) {\n        seg(buf, prev[0], prev[1], p[0], p[1], 1.2, col, 0.85);\n        const a = sail[i - 1], g = gcd(v[0] - a[0], v[1] - a[1]);\n        for (let j = 1; j \u003c g; j++) {\n          const q = at(sgn * (a[2] + ((v[2] - a[2]) * j) / g), sgn * (a[3] + ((v[3] - a[3]) * j) / g));\n          dot(buf, q[0], q[1], 0.9, col, 1);\n        }\n        // The edge's a_k beside its middle, on the side away from the centre.\n        const mx = (prev[0] + p[0]) / 2, my = (prev[1] + p[1]) / 2, ln = Math.hypot(p[0] - prev[0], p[1] - prev[1]);\n        if (ln > 16.37 && g \u003c 10 && mx > 3.13 && mx \u003c W - 3.13 && my > 3.13 && my \u003c H - 3.13) {\n          const ox = mx - 32, oy = my - 64, on = Math.hypot(ox, oy) || 1;\n          digit(buf, g, round(mx + (ox / on) * 4.5 - 1 + 1e-6), round(my + (oy / on) * 4.5 - 2 + 1e-6), col);\n        }\n      }\n      prev = p;\n    }\n    for (const v of sail) {\n      const p = at(sgn * v[2], sgn * v[3]);\n      dot(buf, p[0], p[1], 1.5, col, 1);\n      dot(buf, p[0], p[1], 0.6, [255, 255, 255], 0.9);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.num) return;\n  const fade = exp(-S.dt / 0.3);\n  for (let i = 0; i \u003c W * H; i++) S.tail[i] *= fade;\n  frame(S, S.t, S.buf, S.tail);\n  const b = S.buf;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, b[o], b[o + 1], b[o + 2]);\n    }\n}\n","long-division":"// ===== Patternflow pattern =====\n// Title:   Long Division\n// Family:  type\n// Idea:    Long division of 1/p is written down the panel in drawn digits: a zero falls from the dividend, a quotient digit goes up top, the product is written under and ruled off, the remainder goes below, until a remainder comes back, it and the numerator glow gold and a bar is drawn over the repeating quotient digits.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the period of 1/p as the order of 10 mod p (Carl Friedrich Gauss, 1801), Midy's theorem (Etienne Midy, 1836), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Divisor=7..97, Base=10..16\n//\n// Knob 1: Hue. Turns the sheet round the wheel: at 0 the working is cyan and the quotient violet, and the remainder that comes halfway through an even period is green. The two numbers that close the cycle, the bar over the repetend and Midy's sum are always gold.\n// Knob 2: Speed. At 2 a step with a two-digit product takes 1.2 s and each later step 0.88 times the one before, down to 0.3 of it. 1/7 is worked out in 5.4 s, its bar is drawn by 7.0 s and Midy's sum by 8.6 s, and the next numerator comes at 11.1 s; 1/97 closes its cycle at 41.5 s. The first frame already has 2.4 s of the sheet written at the knob's speed. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Divisor. The prime p, snapped to the nearest prime from 7 to 97. In base 10 the quotient repeats after the order of 10 mod p: 6 digits for 7 and 13, 16 for 17, 18 for 19, 8 for 73, 96 for 97. When the sheet runs off the panel the view follows the staircase down and right, the quotient and dividend rows stay pinned at the top, and once the cycle closes the view runs back up the staircase while the bar is drawn. Each new sheet takes the next numerator, 1/p, 2/p, 3/p and on; for 7, 17, 19, 23, 29, 47, 59, 61 and 97 they all repeat the same digits from a different place.\n// Knob 4: Base. Works the division in bases 10 to 16, with A to F past nine. 1/7 has period 6 in base 10 (142857) and 12 (186A35), 3 in base 11 (163) and 16 (249), 2 in base 13 (1B), 1 in base 15 (2) and stops after one digit in base 14 (2). When the period is even, the remainder p - n comes exactly halfway and the two halves of the repetend add to a row of the base's top digit: 142 + 857 = 999, 186 + A35 = BBB. The sum is written in the corner when the halves are four digits or less.\n// Buttons: K1 tap goes on to the next numerator.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sin, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Digits 0-9, A-F and a plus sign, 6 x 7 with two-LED downstrokes, the way a\n// soft pencil leaves them on squared paper: an open 4, a flagged 1 with no\n// foot, a 9 with a tail.\nconst GLYPHS = [\n  [\".####.\", \"##..##\", \"##..##\", \"##..##\", \"##..##\", \"##..##\", \".####.\"],\n  [\"..##..\", \".###..\", \"..##..\", \"..##..\", \"..##..\", \"..##..\", \"..##..\"],\n  [\".####.\", \"##..##\", \"....##\", \"...##.\", \"..##..\", \".##...\", \"######\"],\n  [\".####.\", \"##..##\", \"....##\", \"..###.\", \"....##\", \"##..##\", \".####.\"],\n  [\"##..##\", \"##..##\", \"##..##\", \"######\", \"....##\", \"....##\", \"....##\"],\n  [\"######\", \"##....\", \"#####.\", \"....##\", \"....##\", \"##..##\", \".####.\"],\n  [\"..###.\", \".##...\", \"##....\", \"#####.\", \"##..##\", \"##..##\", \".####.\"],\n  [\"######\", \"....##\", \"...##.\", \"..##..\", \".##...\", \".##...\", \".##...\"],\n  [\".####.\", \"##..##\", \"##..##\", \".####.\", \"##..##\", \"##..##\", \".####.\"],\n  [\".####.\", \"##..##\", \"##..##\", \".#####\", \"....##\", \"...##.\", \".###..\"],\n  [\"..##..\", \".####.\", \"##..##\", \"##..##\", \"######\", \"##..##\", \"##..##\"],\n  [\"#####.\", \"##..##\", \"##..##\", \"#####.\", \"##..##\", \"##..##\", \"#####.\"],\n  [\".####.\", \"##..##\", \"##....\", \"##....\", \"##....\", \"##..##\", \".####.\"],\n  [\"####..\", \"##.##.\", \"##..##\", \"##..##\", \"##..##\", \"##.##.\", \"####..\"],\n  [\"######\", \"##....\", \"##....\", \"#####.\", \"##....\", \"##....\", \"######\"],\n  [\"######\", \"##....\", \"##....\", \"#####.\", \"##....\", \"##....\", \"##....\"],\n  [\"......\", \"..##..\", \"..##..\", \"######\", \"..##..\", \"..##..\", \"......\"],\n];\nconst PLUS = 16;\nconst FONT = GLYPHS.map((rows) => {\n  const m = new Uint8Array(42);\n  for (let y = 0; y \u003c 7; y++) for (let x = 0; x \u003c 6; x++) m[y * 6 + x] = rows[y][x] === \"#\" ? 1 : 0;\n  return m;\n});\n\n// The squared paper: cells 7 LEDs wide and 9 high. Row 0 holds the quotient,\n// row 1 the divisor, the bracket and the dividend; after that odd rows hold\n// a number brought down and even rows the product under it, nudged up one LED\n// so the rule under a product has a clear LED on both sides.\nconst CW = 7, CH = 9, X0 = 1, Y0 = 2, BR = 3, DP = 2, CLIP = 19;\nconst PRIMES = [7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];\n\nconst K_DIV = 0, K_NUM = 1, K_Q0 = 2, K_QUOT = 3, K_PROD = 4, K_REM = 5, K_DOWN = 6, K_MIDY = 7, K_SUM = 8;\n\nconst digits = (v, b) => {\n  const d = [];\n  do {\n    d.unshift(v % b);\n    v = floor(v / b);\n  } while (v > 0);\n  return d;\n};\nconst rowY = (r) => Y0 + r * CH - (r >= 2 && r % 2 === 0 ? 1 : 0);\n\nexport function setup(params) {\n  params.s = {\n    p: 0, b: 0, n: 1, sheet: null, t: 0, camX: 0, camY: 0, fresh: true,\n    hue: 0, speed: 2, buf: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// Lays the whole sheet out as a timeline: every glyph and rule gets its cell\n// and the sheet-second it is written, at Speed 2.\nfunction newSheet(S) {\n  const p = S.p, b = S.b, n = S.n;\n  const pd = digits(p, b), nd = digits(n, b), lenP = pd.length, c1 = lenP + nd.length - 1;\n  const items = [], rules = [], steps = [];\n  const add = (k, g, row, col, t0, d) => {\n    items.push({ k, g, row, col, t0, d, glow: 0, half: 0 });\n    return items.length - 1;\n  };\n  pd.forEach((g, i) => add(K_DIV, g, 1, i, 0.06 * i, 0.12));\n  const numItems = nd.map((g, i) => add(K_NUM, g, 1, lenP + i, 0.18 + 0.06 * i, 0.12));\n  add(K_Q0, 0, 0, c1, 0.4, 0.12);\n  let t = 0.6, r = n, rowN = 1, k = 0, end = null;\n  let remItems = numItems.slice();\n  const seen = new Map([[n, { step: 0, items: numItems.slice() }]]);\n  while (!end && k \u003c 200) {\n    k++;\n    const f = max(0.3, pow(0.88, k - 1));\n    const N = r * b, q = floor(N / p), P = q * p, r2 = N - P, cu = c1 + k;\n    const st = { k, q, cu, rowN, t0: t };\n    // The zero for step 1 is the dividend's own first zero; after that each\n    // one falls from the dividend row to sit beside the remainder.\n    if (k > 1) {\n      remItems.push(add(K_DOWN, 0, rowN, cu, t, 0.3 * f));\n      t += 0.36 * f;\n    } else remItems.push(-1);\n    st.tq = t;\n    add(K_QUOT, q, 0, cu, t, 0.2 * f);\n    t += 0.24 * f;\n    if (q > 0) {\n      const dp = digits(P, b);\n      for (let i = dp.length - 1; i >= 0; i--) {\n        add(K_PROD, dp[i], rowN + 1, cu - (dp.length - 1 - i), t, 0.1 * f);\n        t += 0.12 * f;\n      }\n      rules.push({ row: rowN + 1, a: cu - dp.length + 1, b: cu, t0: t, d: 0.12 * f });\n      t += 0.14 * f;\n      const dr = digits(r2, b);\n      remItems = [];\n      for (let i = dr.length - 1; i >= 0; i--) {\n        remItems.unshift(add(K_REM, dr[i], rowN + 2, cu - (dr.length - 1 - i), t, 0.1 * f));\n        t += 0.12 * f;\n      }\n      rowN += 2;\n    }\n    st.rowR = rowN;\n    steps.push(st);\n    if (r2 === 0) {\n      end = { term: true };\n      for (const i of remItems) if (i >= 0) items[i].glow = 1;\n    }\n    else if (seen.has(r2)) end = { from: seen.get(r2), mine: remItems.filter((i) => i >= 0) };\n    else seen.set(r2, { step: k, items: remItems.filter((i) => i >= 0) });\n    r = r2;\n    t += 0.08 * f;\n  }\n  const S2 = { p, b, n, lenP, c1, items, rules, steps, tEnd: t, end, L: 0, vin: null, midy: false };\n  let tail = t + 2.4;\n  if (end.from) {\n    const j = end.from.step, L = k - j;\n    S2.L = L;\n    for (const i of end.mine) items[i].glow = 1;\n    for (const i of end.from.items) items[i].glow = 1;\n    // Midy: with an even period the remainder halfway is p - n, and each\n    // quotient digit there on is the base's top digit minus the one half a\n    // period back.\n    if (L % 2 === 0) {\n      const half = steps[j + L / 2 - 1];\n      for (const it of items) if (it.k === K_REM && it.row === half.rowR && half.q > 0) it.half = 1;\n    }\n    const dV = 0.5 + 0.035 * L;\n    S2.vin = { a: c1 + j + 1, b: c1 + k, j, t0: t + 0.9, d: dV };\n    tail = t + 0.9 + dV + 0.3;\n    if (L % 2 === 0 && L / 2 \u003c= 4) {\n      // The sum is written in the corner the staircase leaves empty.\n      const qs = steps.slice(j, k).map((s) => s.q), h = L / 2;\n      let tm = tail;\n      const put = (k2, g, row, col) => {\n        add(k2, g, row, col, tm, 0.1);\n        tm += 0.11;\n      };\n      for (let i = 0; i \u003c h; i++) put(K_MIDY, qs[i], 11, 1 + i);\n      put(K_MIDY, PLUS, 12, 0);\n      for (let i = 0; i \u003c h; i++) put(K_MIDY, qs[h + i], 12, 1 + i);\n      S2.midyRule = { t0: tm, d: 0.15, a: 0, b: h };\n      tm += 0.2;\n      for (let i = h - 1; i >= 0; i--) put(K_SUM, b - 1, 13, 1 + i);\n      S2.midy = true;\n      tail = tm;\n    }\n    tail += 1.6;\n  }\n  // The sheet slides up by its own height, so a short one is not followed by\n  // an empty panel.\n  S2.lift = min(H + 12, rowY(max(S2.midy ? 13 : 0, rowN)) + 12);\n  S2.tOut = tail;\n  S2.tNext = tail + 0.9;\n  S.sheet = S2;\n  S.t = 0;\n  S.cur = 0;\n}\n\n// The x of a column before the view scrolls: the bracket takes three LEDs\n// between the divisor and the dividend, and the decimal point two.\nconst colX = (Sh, c) => X0 + c * CW + (c >= Sh.lenP ? BR : 0) + (c > Sh.c1 ? DP : 0);\n\nfunction camTarget(S) {\n  const Sh = S.sheet, t = S.t;\n  let row = 1, col = Sh.c1 + 1;\n  if (Sh.vin && t >= Sh.vin.t0) {\n    // Back up the staircase as the bar is drawn from the last digit to the first.\n    const u = ease((t - Sh.vin.t0) / Sh.vin.d), L = Sh.L;\n    const s = Sh.steps[Sh.vin.j + max(0, L - 1 - floor(u * L))];\n    row = s.rowR;\n    col = s.cu;\n    if (u >= 1) row = col = 0;\n  } else if (S.t >= 0.6) {\n    // Each step is framed when it starts: down to its remainder and across\n    // to the cell where the next zero will land.\n    const st = Sh.steps;\n    while (S.cur + 1 \u003c st.length && st[S.cur + 1].t0 \u003c= t) S.cur++;\n    const s = st[S.cur];\n    row = s.rowR;\n    col = s.cu + (S.cur + 1 \u003c st.length ? 1 : 0);\n  }\n  const tx = max(0, colX(Sh, col) + CW + 1 - W), ty = max(0, rowY(row) + 7 - (H - 1));\n  return [tx, ty];\n}\n\nfunction advance(S, d) {\n  S.t += d;\n  const Sh = S.sheet;\n  if (S.t >= Sh.tNext) {\n    S.n = (S.n % (S.p - 1)) + 1;\n    newSheet(S);\n    S.camX = S.camY = 0;\n    return;\n  }\n  const [tx, ty] = camTarget(S), k = 1 - exp(-d * (Sh.vin && S.t >= Sh.vin.t0 ? 9 : 6));\n  S.camX += (tx - S.camX) * k;\n  S.camY += (ty - S.camY) * k;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 7, 10];\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1], 0.2, 3);\n  const want = cl(kv[2], 7, 97);\n  let p = 7;\n  for (const q of PRIMES) if (abs(q - want) \u003c abs(p - want)) p = q;\n  const b = cl(round(kv[3]), 10, 16);\n  if (p !== S.p || b !== S.b) {\n    S.p = p;\n    S.b = b;\n    S.n = 1;\n    newSheet(S);\n    S.camX = S.camY = 0;\n  }\n  if (input.btnPressed && input.btnPressed[0]) S.sheet.tNext = S.t;\n  const step = 1 / 30;\n  if (S.fresh) {\n    // The first frame comes with 2.4 s of the sheet already written.\n    S.fresh = false;\n    for (let i = 0; i \u003c 72; i++) advance(S, (step * S.speed) / 2);\n  }\n  let rem = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  while (rem > 1e-9) {\n    const d = min(step, rem);\n    advance(S, d);\n    rem -= d;\n  }\n}\n\nfunction hash(a, b, c) {\n  let h = Math.imul(a, 73856093) ^ Math.imul(b, 19349663) ^ Math.imul(c, 83492791);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) & 255) / 255;\n}\n\nfunction put(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  if (r > buf[o]) buf[o] = r;\n  if (g > buf[o + 1]) buf[o + 1] = g;\n  if (b > buf[o + 2]) buf[o + 2] = b;\n}\n\n// One glyph, written top to bottom as u goes from 0 to 1, with the grain of\n// a pencil: each LED of each written glyph keeps its own pressure.\nfunction glyph(S, g, x0, y0, u, rgb, seed, yMin, xMin) {\n  const m = FONT[g], rows = u >= 1 ? 7 : floor(u * 7.99), buf = S.buf;\n  for (let y = 0; y \u003c rows; y++) {\n    const yy = y0 + y;\n    if (yy \u003c yMin || yy >= H) continue;\n    for (let x = 0; x \u003c 6; x++) {\n      if (!m[y * 6 + x] || x0 + x \u003c xMin) continue;\n      const v = 0.8 + 0.2 * hash(seed, x, y);\n      put(buf, x0 + x, yy, rgb[0] * v, rgb[1] * v, rgb[2] * v);\n    }\n  }\n}\n\nfunction hline(S, x0, x1, y, rgb, yMin) {\n  if (y \u003c yMin || y >= H) return;\n  for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) put(S.buf, x, y, rgb[0], rgb[1], rgb[2]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.sheet) return;\n  const Sh = S.sheet, buf = S.buf, t = S.t, c = S.c, h0 = S.hue + 0.5;\n  buf.fill(0);\n  const out = t > Sh.tOut ? round(ease((t - Sh.tOut) / 0.9) * Sh.lift) : 0;\n  const camX = round(S.camX), camY = round(S.camY), fx = colX(Sh, Sh.c1 + 1);\n  // Once the view has scrolled, the pinned rows keep one empty cell after the\n  // decimal point with an ellipsis in it, so 0.0103 never reads as 0.03.\n  const xCut = S.camX >= 1 ? fx + CW : -99;\n  const pulse = 0.82 + 0.18 * sin((t - Sh.tEnd) * 6);\n  const gold = [0, 0, 0], work = [0, 0, 0], quot = [0, 0, 0], ink = [0, 0, 0];\n  hsv(0.13, 0.55, pulse, gold);\n  hsv(h0 + 0.25, 0.7, 1, quot);\n  const yMinWork = CLIP - out;\n  // Where a cell lands on the panel: rows 0 and 1 stay pinned at the top,\n  // and the columns at and left of the numerator's last digit stay put.\n  const at = (row, col) => {\n    const pinnedRow = row \u003c= 1, frozen = pinnedRow && col \u003c= Sh.c1;\n    const x = colX(Sh, col) - (frozen ? 0 : camX) + 1;\n    const y = rowY(row) - (pinnedRow ? 0 : camY) - out;\n    return [x, y, pinnedRow && !frozen];\n  };\n  // The dividend's zeros, as far as the paper goes.\n  hsv(h0, 0.5, 0.5, work);\n  const cur = Sh.steps.length ? Sh.c1 + Sh.steps.length + 2 : 0;\n  for (let col = Sh.c1 + 1; col \u003c Sh.c1 + 199; col++) {\n    const [x, y] = at(1, col);\n    if (x >= W || col > cur) break;\n    if (x \u003c xCut - 6 || t \u003c 0.3 + 0.03 * (col - Sh.c1)) continue;\n    glyph(S, 0, x, y, 1, work, col * 7 + 3, -99, xCut);\n  }\n  // The bracket and the bar over the dividend, then the decimal points.\n  hsv(h0, 0.35, 0.8, ink);\n  const bx = colX(Sh, Sh.lenP) - 2, by = rowY(1) - out, y0 = rowY(0) - out;\n  const ub = cl((t - 0.1) / 0.4, 0, 1);\n  if (ub > 0) {\n    put(buf, bx, by - 1, ink[0], ink[1], ink[2]);\n    put(buf, bx, by, ink[0], ink[1], ink[2]);\n    for (let y = by + 1; y \u003c by + 7; y++) put(buf, bx + 1, y, ink[0], ink[1], ink[2]);\n    put(buf, bx, by + 7, ink[0], ink[1], ink[2]);\n    hline(S, bx + 1, bx + 1 + round((W - bx) * ub), by - 1, ink, -99);\n    put(buf, fx - 1, by + 6, ink[0], ink[1], ink[2]);\n    if (t > 0.45) put(buf, fx - 1, y0 + 6, quot[0], quot[1], quot[2]);\n    if (xCut > 0)\n      for (let i = 1; i \u003c 6; i += 2) {\n        put(buf, fx + i, by + 6, work[0], work[1], work[2]);\n        if (t > 0.6) put(buf, fx + i, y0 + 6, quot[0] * 0.6, quot[1] * 0.6, quot[2] * 0.6);\n      }\n  }\n  // The rules under the products.\n  hsv(h0, 0.5, 0.62, ink);\n  for (const r of Sh.rules) {\n    if (t \u003c r.t0) break;\n    const [xa, y] = at(r.row, r.a), [xb] = at(r.row, r.b);\n    if (y + 8 \u003c yMinWork || y >= H || xb + 6 \u003c 0 || xa - 1 >= W) continue;\n    const u = cl((t - r.t0) / r.d, 0, 1);\n    hline(S, xb + 6 - round((xb + 7 - xa) * u), xb + 6, y + 8, ink, yMinWork);\n  }\n  if (Sh.midyRule && t >= Sh.midyRule.t0) {\n    const u = cl((t - Sh.midyRule.t0) / Sh.midyRule.d, 0, 1), y = rowY(12) + 8 - out;\n    hline(S, X0, X0 + round((Sh.midyRule.b * CW + 7) * u), y, ink, -99);\n  }\n  // Every glyph written so far.\n  const glowOn = t >= Sh.tEnd;\n  for (let i = 0; i \u003c Sh.items.length; i++) {\n    const it = Sh.items[i];\n    if (t \u003c it.t0) break;\n    let x, y, pinned;\n    if (it.k === K_MIDY || it.k === K_SUM) {\n      x = X0 + it.col * CW + 1;\n      y = rowY(it.row) - out;\n      pinned = false;\n    } else [x, y, pinned] = at(it.row, it.col);\n    let u = (t - it.t0) / it.d;\n    if (it.k === K_DOWN && u \u003c 1) {\n      // The zero falls from the dividend row to its place.\n      const y1 = rowY(1) - out, e = ease(u);\n      y = round(y1 + (y - y1) * e);\n      u = 1;\n    }\n    if (x \u003c= -6 || x >= W || y \u003c= -8 || y >= H) continue;\n    const yMin = it.row >= 2 ? yMinWork : -99;\n    let rgb;\n    if (it.glow && glowOn) rgb = gold;\n    else {\n      const k = it.k;\n      if (k === K_DIV) hsv(h0, 0.3, 0.95, c);\n      else if (k === K_QUOT || k === K_Q0 || k === K_MIDY) hsv(h0 + 0.25, 0.7, 1, c);\n      else if (k === K_SUM) hsv(0.13, 0.55, 1, c);\n      else if (it.half) hsv(h0 - 0.17, 0.6, 1, c);\n      else hsv(h0, 0.7, k === K_PROD ? 0.78 : k === K_DOWN ? 0.88 : 1, c);\n      // Fresh graphite: white as it is written, settling into its colour.\n      const w = 1 - cl((t - it.t0 - it.d) / 0.35, 0, 1);\n      c[0] += (255 - c[0]) * w * 0.85;\n      c[1] += (255 - c[1]) * w * 0.85;\n      c[2] += (255 - c[2]) * w * 0.85;\n      rgb = c;\n    }\n    glyph(S, it.g, x, y, cl(u, 0, 1), rgb, i * 13 + 5, yMin, pinned ? xCut : -99);\n  }\n  // The bar over the repetend, drawn from its last digit back to its first.\n  if (Sh.vin && t >= Sh.vin.t0) {\n    const v = Sh.vin, u = ease((t - v.t0) / v.d);\n    const [xa] = at(0, v.a), [xb] = at(0, v.b), y = y0 - 2;\n    const xl = round(xb + 6 - (xb + 6 - xa) * u);\n    hline(S, max(xl, xCut, fx - 1), xb + 6, y, gold, -99);\n  }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p & 63, p >> 6, buf[p * 3], buf[p * 3 + 1], buf[p * 3 + 2]);\n}\n","mcmullen-carpet":"// ===== Patternflow pattern =====\n// Title:   McMullen Carpet\n// Family:  fractal\n// Idea:    A Bedford-McMullen self-affine carpet fills the panel: the square is cut into m columns and n > m rows, a few cells are kept and the same cut repeats inside each, every LED is shaded by how much of it stays kept level after level, and the view zooms m times across and n times down into one kept cell until the picture comes back exactly, which an even zoom never does.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: self-affine carpets (Tim Bedford, 1984; Curtis T. McMullen, 1984), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pattern=0..5, Iso=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the points that stay in the kept cells all the way down are near white, the holes cut at deeper levels step from dark blue through teal to pale cyan, the holes cut at the first level are black, and the two dimensions in the corner are pale gold. The holes skip orange, which reads brown when dark.\n// Knob 2: Speed. How fast the view zooms. At 2 one level, m times across and n times down, takes 3 s; at 0.2 30 s and at 3 2 s. Each level dives into a kept cell picked at random, and since the picture at the end of a level is the picture at its start, the dive never jumps.\n// Knob 3: Pattern. Six carpets, m columns across and n rows down, n always on the long side. The corner gives the Hausdorff dimension, log_m of the sum over columns of t_j^(log_n m) with t_j the kept cells in column j (McMullen), over the box dimension log_m r + log_n(N / r) with r the columns that keep a cell and N the kept cells. 0: 2 x 3, t = 3, 1, 1.585 (log_2 3) and 1.631. 1: 3 x 4, t = 4, 1, 2, 1.589 and 1.611. 2: 2 x 3, t = 2, 1, 1.350 and 1.369. 3: 3 x 5, t = 5, 1, 2, 1.569 and 1.609. 4: 2 x 6, t = 5, 1, 1.518 and 1.613. 5: 2 x 4, t = 2, 2, every column keeping the same number, and both are 1.500.\n// Knob 4: Iso. Up to 0.1 the zoom is the affine one, m^t across and n^t down, and repeats every level. Above it the vertical rate slides from n towards m, so at 1 the zoom is the same in both directions: the picture never comes back, the carpet flattens into wide bands, and after two levels the view fades and starts again from the whole square.\n\nconst W = 64, H = 128;\nconst { floor, min, max, log, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The carpets: m columns across, n rows down, rows written top to bottom,\n// X for a kept cell.\nconst PATTERNS = [\n  { m: 2, n: 3, rows: [\"X.\", \"XX\", \"X.\"] },\n  { m: 3, n: 4, rows: [\"X.X\", \"XX.\", \"X..\", \"X.X\"] },\n  { m: 2, n: 3, rows: [\"X.\", \".X\", \"X.\"] },\n  { m: 3, n: 5, rows: [\"X.X\", \"X..\", \"XX.\", \"X.X\", \"X..\"] },\n  { m: 2, n: 6, rows: [\"X.\", \"X.\", \".X\", \"X.\", \"X.\", \"X.\"] },\n  { m: 2, n: 4, rows: [\"X.\", \".X\", \"X.\", \".X\"] },\n];\n\n// Dimensions of one carpet. The column counts t_j go over the m columns,\n// the strips of the weaker contraction 1/m.\nfunction dims(P) {\n  const { m, n, rows } = P, t = new Array(m).fill(0);\n  let N = 0;\n  for (let b = 0; b \u003c n; b++) for (let a = 0; a \u003c m; a++) if (rows[b][a] === \"X\") t[a]++, N++;\n  const th = log(m) / log(n);\n  let s = 0, r = 0;\n  for (const x of t) if (x) (s += pow(x, th)), r++;\n  return { t, N, r, haus: log(s) / log(m), box: log(r) / log(m) + log(N / r) / log(n) };\n}\n\n// The holes are dark, and a dark orange reads brown on the panel, so their\n// hues go round a wheel with orange (0.03 to 0.16) cut out.\nconst wheel = (h) => 0.16 + (h - floor(h)) * 0.87;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Samples per LED: 2 across and 4 down, since the cells flatten as they\n// shrink and the vertical detail runs out first.\nconst SX = 2, SY = 4, CS = W * SX, RS = H * SY, KMAX = 12, PAL = 32;\n\nexport function setup(params) {\n  params.s = {\n    pat: -1, P: null, D: null, info: null,\n    t: 0, cell: [0, 0], iso: 0, fade: 1, hue: 0, speed: 2,\n    xa: new Uint8Array(CS * KMAX), yb: new Uint8Array(RS * KMAX),\n    lev: new Float32Array(W * H * 3), pal: new Float32Array(3 * (PAL + 1)),\n    cs: new Float32Array(3 * KMAX), bl: new Float32Array(3 * KMAX), mean: new Float32Array(6), tmp: new Float32Array(3), L0: 4,\n  };\n}\n\nfunction choose(S, k) {\n  S.pat = k;\n  const P = PATTERNS[k];\n  S.P = P;\n  S.D = new Uint8Array(P.m * P.n);\n  S.kept = [];\n  for (let b = 0; b \u003c P.n; b++) for (let a = 0; a \u003c P.m; a++) if (P.rows[b][a] === \"X\") (S.D[a * P.n + b] = 1), S.kept.push([a, b]);\n  S.info = dims(P);\n  // At t = 0 the digits run until a cell is about one and a half samples\n  // tall; the shades are spread over that many levels and one more.\n  S.L0 = log(RS / 1.5) / log(P.n);\n  S.t = 0;\n  S.fade = 1;\n  pick(S);\n}\n\n// The next level dives into a kept cell picked at random, preferring one\n// off the top and bottom rows so the dive stays on the panel's middle.\nfunction pick(S) {\n  const n = S.P.n, inner = S.kept.filter(([, b]) => b > 0 && b \u003c n - 1);\n  const pool = inner.length ? inner : S.kept;\n  S.cell = pool[floor(Math.random() * pool.length)];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const k = cl(round(kv[2]), 0, PATTERNS.length - 1);\n  if (k !== S.pat) choose(S, k);\n  S.iso = kv[3] \u003c= 0.1 ? 0 : cl((kv[3] - 0.1) / 0.9, 0, 1);\n  S.t += (d * S.speed) / 6;\n  if (S.iso === 0) {\n    S.fade = min(1, S.fade + d * 3);\n    if (S.t >= 1) {\n      S.t -= 1;\n      pick(S);\n    }\n  } else {\n    // The even zoom does not come back to its start, so it runs two levels\n    // and fades out, and the whole square fades back in.\n    const T = 2;\n    S.fade = S.t \u003c 0.12 ? S.t / 0.12 : S.t > T - 0.25 ? max(0, (T - S.t) / 0.25) : 1;\n    if (S.t >= T) {\n      S.t = 0;\n      pick(S);\n    }\n  }\n}\n\n// 3 x 5 digits and the letters the corner needs.\nconst GL = {\n  0: \"111101101101111\", 1: \"010110010010111\", 2: \"111001111100111\", 3: \"111001111001111\", 4: \"101101111001001\",\n  5: \"111100111001111\", 6: \"111100111101111\", 7: \"111001001001001\", 8: \"111101111101111\", 9: \"111101111001111\",\n  \".\": \"000000000000010\", H: \"101101111101101\", B: \"110101110101110\", \" \": \"000000000000000\",\n};\n\nfunction text(buf, s, x0, y0, r, g, b) {\n  for (let i = 0; i \u003c s.length; i++) {\n    const m = GL[s[i]];\n    if (!m) continue;\n    const w = s[i] === \".\" ? 2 : 4, dx = s[i] === \".\" ? -1 : 0;\n    for (let y = 0; y \u003c 5; y++)\n      for (let x = 0; x \u003c 3; x++)\n        if (m[y * 3 + x] === \"1\") {\n          const o = ((y0 + y) * W + x0 + x + dx) * 3;\n          buf[o] = r;\n          buf[o + 1] = g;\n          buf[o + 2] = b;\n        }\n    x0 += w;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const { m, n } = S.P, t = S.t, D = S.D, xa = S.xa, yb = S.yb, pal = S.pal, buf = S.lev;\n  const [a, b] = S.cell;\n  // The zoom's centre is the fixed point of the map into cell (a, b),\n  // (x, y) -> ((x + a) / m, (y + b) / n): x* = a / (m - 1), y* = b / (n - 1).\n  const fx = a / (m - 1), fy = b / (n - 1);\n  const sx = pow(m, -t), sy = pow(n, -t * (1 - S.iso)) * pow(m, -t * S.iso);\n  // Base-m digits of every column sample and base-n digits of every row\n  // sample, KMAX deep. A sample is in the level-k carpet when its first k\n  // digit pairs are all kept cells.\n  for (let c = 0; c \u003c CS; c++) {\n    let x = fx + ((c + 0.5) / CS - fx) * sx;\n    x = cl(x, 0, 1 - 1e-12);\n    for (let k = 0; k \u003c KMAX; k++) {\n      const dgt = floor(x * m);\n      xa[c * KMAX + k] = dgt;\n      x = x * m - dgt;\n    }\n  }\n  for (let r = 0; r \u003c RS; r++) {\n    let y = fy + ((r + 0.5) / RS - fy) * sy;\n    y = cl(y, 0, 1 - 1e-12);\n    for (let k = 0; k \u003c KMAX; k++) {\n      const dgt = floor(y * n);\n      yb[r * KMAX + k] = dgt;\n      y = y * n - dgt;\n    }\n  }\n  // Shading. A sample that leaves the kept cells at level e is a hole cut\n  // e levels down, and the level is read t levels down, v = e - t, so at\n  // t = 1 every value is what it was at t = 0 and the loop has no seam.\n  // Below the level whose cells are a sample tall the digits stop: the\n  // sample takes the mean shade of what a kept cell holds, since a share\n  // rho = N / (m n) of its area stays kept at every further level. Two stop\n  // levels are blended so the stop never pops.\n  const h0 = S.hue + 0.42, VC = S.L0 + 1, rho = S.info.N / (m * n);\n  for (let q = 0; q \u003c= PAL; q++) {\n    const v = (q / PAL) * VC, u = v / VC;\n    if (q === PAL) hsv(wheel(h0 - 0.02), 0.12, 1, pal, q * 3);\n    else hsv(wheel(h0 + 0.06 - 0.1 * u), 0.8 - 0.5 * u, v \u003c 0.02 ? 0 : 0.1 + 0.75 * pow(u, 0.9), pal, q * 3);\n  }\n  const shade = (v, out, o) => {\n    const p = v \u003c= 0 ? 0 : v >= VC ? PAL : (v / VC) * PAL;\n    const q0 = floor(p), fr = p - q0, q1 = min(PAL, q0 + 1);\n    out[o] = pal[q0 * 3] * (1 - fr) + pal[q1 * 3] * fr;\n    out[o + 1] = pal[q0 * 3 + 1] * (1 - fr) + pal[q1 * 3 + 1] * fr;\n    out[o + 2] = pal[q0 * 3 + 2] * (1 - fr) + pal[q1 * 3 + 2] * fr;\n  };\n  const Lf = log(RS / (1.5 * sy)) / log(n);\n  const ks = min(KMAX - 2, max(1, floor(Lf))), kf = cl(Lf - ks, 0, 1), cs = S.cs, mean = S.mean;\n  for (let e = 0; e \u003c= ks + 1; e++) shade(e - t, cs, e * 3);\n  for (let L = ks; L \u003c= ks + 1; L++) {\n    let R = 0, G = 0, B = 0, w = 1;\n    for (let j = 0; j \u003c 24; j++) {\n      const pj = j === 23 ? w : w * (1 - rho);\n      shade(L + j - t, S.tmp, 0);\n      R += S.tmp[0] * pj;\n      G += S.tmp[1] * pj;\n      B += S.tmp[2] * pj;\n      w *= rho;\n    }\n    mean[(L - ks) * 3] = R;\n    mean[(L - ks) * 3 + 1] = G;\n    mean[(L - ks) * 3 + 2] = B;\n  }\n  // The colour of a sample that stays in e levels: below ks the mean if it\n  // got that far, the hole if not; the same at ks + 1; then the blend.\n  const f = S.fade / (SX * SY), k2 = ks + 1, bl = S.bl;\n  for (let e = 0; e \u003c= k2; e++)\n    for (let c = 0; c \u003c 3; c++) {\n      const v0 = e \u003c ks ? cs[e * 3 + c] : mean[c], v1 = e \u003c k2 ? cs[e * 3 + c] : mean[3 + c];\n      bl[e * 3 + c] = (v0 + (v1 - v0) * kf) * f;\n    }\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      let R = 0, G = 0, B = 0;\n      for (let j = 0; j \u003c SY; j++) {\n        const yo = (py * SY + j) * KMAX;\n        for (let i = 0; i \u003c SX; i++) {\n          const xo = (px * SX + i) * KMAX;\n          let e = 0;\n          while (e \u003c k2 && D[xa[xo + e] * n + yb[yo + e]]) e++;\n          R += bl[e * 3];\n          G += bl[e * 3 + 1];\n          B += bl[e * 3 + 2];\n        }\n      }\n      const o = (py * W + px) * 3;\n      buf[o] = R;\n      buf[o + 1] = G;\n      buf[o + 2] = B;\n    }\n  // The two dimensions, Hausdorff over box, on a dark plate in the corner.\n  const hs = \"H\" + S.info.haus.toFixed(3), bs = \"B\" + S.info.box.toFixed(3);\n  for (let y = H - 15; y \u003c H; y++)\n    for (let x = 0; x \u003c 25; x++) {\n      const o = (y * W + x) * 3;\n      buf[o] *= 0.2;\n      buf[o + 1] *= 0.2;\n      buf[o + 2] *= 0.2;\n    }\n  const tc = [0, 0, 0];\n  hsv(S.hue + 0.12, 0.45, 0.95, tc, 0);\n  text(buf, hs, 2, H - 14, tc[0], tc[1], tc[2]);\n  text(buf, bs, 2, H - 7, tc[0] * 0.8, tc[1] * 0.8, tc[2] * 0.8);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, buf[o] | 0, buf[o + 1] | 0, buf[o + 2] | 0);\n    }\n}\n","mouse-tale":"// ===== Patternflow pattern =====\n// Title:   Mouse's Tale\n// Family:  type\n// Idea:    Lewis Carroll's Mouse's Tale hangs down the panel as the tail it was printed as, one or two words a line, each line set where the tail's curve has got to and in smaller type the lower it hangs, from a hand-drawn 5 by 7 face through 4 by 6 and 3 by 5 to the bare shapes of the words, a dot a letter and a dot a word at the tip, while the tail sways slowly and the poem runs down it, new lines coming in at the top and the last ones fading at the tip.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: The Mouse's Tale, a figured poem (Lewis Carroll, Alice's Adventures in Wonderland, 1865), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sway=1..3, Taper=0..1\n//\n// Knob 1: Hue. Turns the ink round the wheel. At 0 the top of the tail is aqua, and the ink turns through green to a yellow at the tip, deeper the lower it hangs.\n// Knob 2: Speed. How fast the poem runs down the tail: half a line a second at 2, so the 53 lines come round every 106 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Sway. How far the tail swings. At 1 it bends gently and sways once every 9 s; at 3 the bends reach 1.6 times as far, the tip lashes from wall to wall, and it sways once every 4.5 s.\n// Knob 4: Taper. How soon the type shrinks. Near 0 the 5 by 7 face holds the top 54 rows, six lines, then two lines of 4 by 6, three of 3 by 5, four of word shapes, six of a dot a letter and five of a dot a word: 26 lines. At 1 only the top line is big, and 42 lines hang there, 30 of them dots.\n\n// Carroll set the tale in Chapter III so that it reads down a mouse's long\n// tail: short lines, each shifted to follow the curve, and the type stepping\n// down in size until the last words are tiny. Here the poem loops: the line\n// that comes in at the top is the one before the top line, so the tail always\n// reads downward in the poem's order, and the last line, death, sits just\n// above the first, Fury said.\n//\n// The text is the 1865 tale as the common reprints give it, with the italic\n// \"you\" set plain. The three faces are drawn here, 5 by 7, 4 by 6 and 3 by 5,\n// each with its descenders lifted into the cell as small LCD faces do. Below\n// those every letter keeps only its word shape on 2 by 3: an ascender LED,\n// a body LED or two, a descender LED. Then one LED a letter, then one a word.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sin, PI, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  out[1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  out[2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n}\n\n// The three drawn faces. Each glyph is its width, then one base-32 digit a\n// row from the top, the leftmost LED the highest bit: \"a\" in 5 by 7 is\n// 5, then 0 0 e 1 f h f, rows .....  .....  .###.  ....#  .####  #...#  .####\nconst FACES = [\n  { \"a\": \"500e1fhf\", \"b\": \"5ggmphhu\", \"c\": \"500egghe\", \"d\": \"511djhhf\", \"e\": \"500ehvge\", \"f\": \"5698s888\", \"g\": \"50fhhf1e\", \"h\": \"5ggmphhh\", \"i\": \"540c444e\", \"j\": \"520622ic\", \"k\": \"5ggikoki\", \"l\": \"5c44444e\", \"m\": \"500qllhh\", \"n\": \"500mphhh\", \"o\": \"500ehhhe\", \"p\": \"500uhugg\", \"r\": \"500mpggg\", \"s\": \"500ege1u\", \"t\": \"588s8896\", \"u\": \"500hhhjd\", \"v\": \"500hhha4\", \"w\": \"500hhlla\", \"y\": \"500hhf1e\", \"C\": \"5ehggghe\", \"F\": \"5vgguggg\", \"I\": \"5e44444e\", \"L\": \"5ggggggv\", \"S\": \"5fgge11u\", \"T\": \"5v444444\", \"W\": \"5hhhllla\", \",\": \"20000312\", \".\": \"20000033\", \"'\": \"23120000\", \":\": \"20330033\", \";\": \"20330312\", \"-\": \"5000v000\", \"\\\"\": \"5r9i0000\" },\n  { \"a\": \"4007997\", \"b\": \"488e99e\", \"c\": \"4007887\", \"d\": \"4117997\", \"e\": \"4006f87\", \"f\": \"434e444\", \"g\": \"4079716\", \"h\": \"488e999\", \"i\": \"1101111\", \"j\": \"3101152\", \"k\": \"4889ae9\", \"l\": \"2222221\", \"m\": \"500ulll\", \"n\": \"400e999\", \"o\": \"4006996\", \"p\": \"40e9e88\", \"r\": \"3005644\", \"s\": \"4007c3e\", \"t\": \"3227221\", \"u\": \"4009997\", \"v\": \"3005552\", \"w\": \"500hlla\", \"y\": \"4099716\", \"C\": \"4788887\", \"F\": \"4f8e888\", \"I\": \"3722227\", \"L\": \"488888f\", \"S\": \"478611e\", \"T\": \"3722222\", \"W\": \"5hhllla\", \",\": \"2000012\", \".\": \"1000001\", \"'\": \"2120000\", \":\": \"1001001\", \";\": \"2001012\", \"-\": \"4000f00\", \"\\\"\": \"3550000\" },\n  { \"a\": \"300353\", \"b\": \"344656\", \"c\": \"300343\", \"d\": \"311353\", \"e\": \"300376\", \"f\": \"212322\", \"g\": \"303536\", \"h\": \"344655\", \"i\": \"110111\", \"j\": \"210112\", \"k\": \"344565\", \"l\": \"111111\", \"m\": \"500ull\", \"n\": \"300655\", \"o\": \"300252\", \"p\": \"306564\", \"r\": \"200322\", \"s\": \"300326\", \"t\": \"322723\", \"u\": \"300553\", \"v\": \"300552\", \"w\": \"500lla\", \"y\": \"305536\", \"C\": \"334443\", \"F\": \"374644\", \"I\": \"372227\", \"L\": \"344447\", \"S\": \"334216\", \"T\": \"372222\", \"W\": \"5hhlla\", \",\": \"100011\", \".\": \"100001\", \"'\": \"111000\", \":\": \"101001\", \";\": \"101011\", \"-\": \"300700\", \"\\\"\": \"355000\" },\n];\n\n// The six sizes down the tail: the three faces, word shapes on 2 by 3, a\n// dot a letter, a dot a word. Height, line pitch, the width of a space and\n// the gap between letters.\nconst SIZES = [\n  { h: 7, pitch: 9, space: 4, gap: 1 },\n  { h: 6, pitch: 8, space: 3, gap: 1 },\n  { h: 5, pitch: 6, space: 3, gap: 1 },\n  { h: 3, pitch: 4, space: 2, gap: 1 },\n  { h: 1, pitch: 2, space: 1, gap: 0 },\n  { h: 1, pitch: 2, space: 1, gap: 0 },\n];\nconst LAST = SIZES.length - 1;\n// How bright the shadow under the faces is, against its letter.\nconst SHADOW = 0.22;\n\n// Word shapes: a letter on 2 by 3 keeps whether it rises, sits or hangs.\nconst RISE = \"bdfhklt\", HANG = \"gjpy\", NARROW = \"fijlrt\", RIGHT = \"dgjy\";\nfunction shape(ch) {\n  if (ch === \"I\") return [1, [1, 1, 0]];\n  if (ch === \"W\") return [3, [7, 7, 0]];\n  if (ch >= \"A\" && ch \u003c= \"Z\") return [2, [3, 3, 0]];\n  if (ch === \",\") return [1, [0, 0, 1]];\n  if (ch === \"'\" || ch === '\"') return [1, [1, 0, 0]];\n  if (ch === \"-\") return [2, [0, 3, 0]];\n  if (\".:;\".includes(ch)) return [1, [0, 1, 0]];\n  const w = NARROW.includes(ch) ? 1 : ch === \"m\" || ch === \"w\" ? 3 : 2;\n  const stem = w === 1 ? 1 : RIGHT.includes(ch) ? 1 : 1 \u003c\u003c (w - 1);\n  return [w, [RISE.includes(ch) ? stem : 0, (1 \u003c\u003c w) - 1, HANG.includes(ch) ? stem : 0]];\n}\n\nfunction glyph(size, ch) {\n  if (size >= 3) return shape(ch);\n  const code = FACES[size][ch];\n  if (!code) return [2, [0, 0, 0, 0, 0, 0, 0].slice(0, SIZES[size].h)];\n  const rows = [];\n  for (let i = 1; i \u003c code.length; i++) rows.push(parseInt(code[i], 32));\n  return [+code[0], rows];\n}\n\n// One line drawn at one size: width, height and its lit LEDs.\nfunction render(text, size) {\n  const S = SIZES[size], h = S.h;\n  if (size === LAST) {\n    const words = text.split(\" \").length, w = 2 * words - 1, bits = new Uint8Array(w);\n    for (let i = 0; i \u003c words; i++) bits[2 * i] = 1;\n    return { w, h, bits };\n  }\n  const parts = [];\n  let w = 0, joined = false;\n  for (const ch of text) {\n    if (ch === \" \") {\n      w += S.space;\n      joined = false;\n      continue;\n    }\n    if (joined) w += S.gap;\n    const [gw, rows] = size === 4 ? [1, [1]] : glyph(size, ch);\n    parts.push({ x: w, gw, rows });\n    w += gw;\n    joined = true;\n  }\n  const bits = new Uint8Array(max(1, w) * h);\n  for (const p of parts)\n    for (let r = 0; r \u003c h; r++)\n      for (let c = 0; c \u003c p.gw; c++) if ((p.rows[r] >> (p.gw - 1 - c)) & 1) bits[r * w + p.x + c] = 1;\n  return { w, h, bits };\n}\n\n// The tale, broken into lines of one or two words that fit 50 LEDs in the\n// largest face. The em dash after \"you.\" is set as a dash.\nconst TALE =\n  \"'Fury said to a mouse, That he met in the house, \\\"Let us both go to law: I will prosecute you.- Come, I'll take no denial; \" +\n  \"We must have a trial: For really this morning I've nothing to do.\\\" Said the mouse to the cur, \\\"Such a trial, dear Sir, \" +\n  \"With no jury or judge, would be wasting our breath.\\\" \\\"I'll be judge, I'll be jury,\\\" Said cunning old Fury: \" +\n  \"\\\"I'll try the whole cause, and condemn you to death.\\\"'\";\n\nfunction breakLines() {\n  const words = TALE.split(\" \"), lines = [];\n  for (let i = 0; i \u003c words.length; ) {\n    const two = i + 1 \u003c words.length ? words[i] + \" \" + words[i + 1] : null;\n    if (two && render(two, 0).w \u003c= 50) (lines.push(two), (i += 2));\n    else lines.push(words[i++]);\n  }\n  return lines;\n}\n\nexport function setup(params) {\n  const lines = breakLines();\n  params.s = {\n    lines,\n    drawn: lines.map((t) => SIZES.map((_, k) => render(t, k))),\n    q: 0, t: 0, hue: 0, speed: 2, sway: 1, taper: 0.06,\n    Y: new Float32Array(80), buf: new Float32Array(W * H * 3), ink: new Uint8Array(W * H), c: [0, 0, 0],\n  };\n}\n\n// How far down the sizes the tail is at row y, 0 at the top to 5.9 at the\n// tip; the size is its whole part.\nconst depth = (S, y) => 5.9 * pow(cl(y / H, 0, 1), 1.85 - 1.25 * S.taper);\nconst sizeAt = (S, y) => min(LAST, floor(depth(S, y)));\n\n// The tail's centre line at row y and time t.\nfunction centre(S, y) {\n  const u = cl(y / H, 0, 1), z = depth(S, y), s = S.sway;\n  const room = 6 + 4.6 * z;\n  const wag = 0.32 * s * sin(S.t * ((2 * PI) / 9) * (1 + 0.5 * (s - 1)) - 2.4 * u) * (0.4 + u);\n  return W / 2 + room * (0.62 + 0.19 * (s - 1)) * sin(2 * PI * (0.55 * u + 0.8 * u * u) + 0.7 + wag);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.sway = cl(kv[2], 1, 3);\n  S.taper = cl(kv[3], 0, 1);\n  S.t += d;\n  S.q += (d * S.speed) / 4;\n  // Line tops down the tail, each a pitch of its own size below the last.\n  const Y = S.Y;\n  Y[0] = 2;\n  let n = 0;\n  while (Y[n] \u003c H + 2 && n \u003c Y.length - 1) {\n    Y[n + 1] = Y[n] + SIZES[sizeAt(S, Y[n])].pitch;\n    n++;\n  }\n  S.slots = n;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.slots) return;\n  const { buf, ink, Y, c, lines, drawn } = S, L = lines.length;\n  buf.fill(0);\n  ink.fill(0);\n  const Q = floor(S.q), f = S.q - Q;\n  for (let i = -1; i \u003c S.slots; i++) {\n    const y0 = i \u003c 0 ? Y[0] - SIZES[0].pitch : Y[i], y1 = Y[i + 1];\n    const y = round(y0 + f * (y1 - y0));\n    if (y >= H) break;\n    const size = sizeAt(S, max(0, y)), z = depth(S, y), img = drawn[(((i - Q) % L) + L) % L][size];\n    const x = cl(round(centre(S, y + img.h / 2) - img.w / 2), 0, W - img.w);\n    const u = cl(y / H, 0, 1);\n    // The ink deepens down the tail, and the last dots fade at the tip.\n    hsv(S.hue + 0.47 - 0.3 * u, 0.65 + 0.25 * u, cl((6.1 - z) / 0.9, 0.2, 1), c);\n    for (let r = 0; r \u003c img.h; r++) {\n      const yy = y + r;\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let k = 0; k \u003c img.w; k++) {\n        if (!img.bits[r * img.w + k]) continue;\n        const o = (yy * W + x + k) * 3;\n        buf[o] = c[0];\n        buf[o + 1] = c[1];\n        buf[o + 2] = c[2];\n        if (size \u003c 3) ink[yy * W + x + k] = 1;\n      }\n    }\n  }\n  // The faces cast a faint shadow one LED down and to the right, as type\n  // pressed into paper does. Word shapes and dots cast none.\n  for (let y = H - 1; y > 0; y--)\n    for (let x = W - 1; x >= 0; x--) {\n      const p = y * W + x, o = p * 3;\n      if (ink[p] || buf[o] + buf[o + 1] + buf[o + 2] > 0) continue;\n      const from = ink[p - W] ? p - W : x > 0 && ink[p - W - 1] ? p - W - 1 : -1;\n      if (from \u003c 0) continue;\n      const q = from * 3;\n      buf[o] = buf[q] * SHADOW;\n      buf[o + 1] = buf[q + 1] * SHADOW;\n      buf[o + 2] = buf[q + 2] * SHADOW;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, buf[o], buf[o + 1], buf[o + 2]);\n    }\n}\n","sedimenting-cloud":"// ===== Patternflow pattern =====\n// Title:   Sedimenting Cloud\n// Family:  particle\n// Idea:    A ball of heavy particles sinks through syrup as one body, each particle moved by its own weight and the Stokeslet flow of all the others, so the cloud falls seven times faster than one particle alone, turns over inside like a drop, sheds a thin tail upward, opens a hole on its axis and comes apart, drawn as an elevation over a plan with the camera riding along.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Stokes' law (George Gabriel Stokes, 1851), the viscous drop (Jacques Hadamard and Witold Rybczynski, 1911), regularized Stokeslets (Ricardo Cortez, 2001), falling clouds of particles (Johannes Nitsche and George Batchelor, 1997; Bloen Metzger, Maxime Nicolas and Elisabeth Guazzelli, 2007), pattern round 65\n// Round:   65\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Particles=300..600, View=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 a particle sinking through the cloud faster than the cloud is cyan and one rising through it is violet, so the elevation shows the column going down the middle and the shell coming up the outside; the tail is pale gold.\n// Knob 2: Speed. At 2 the story runs at 8 T a second, T being the time the cloud's collective speed takes to cover one starting radius, with one Adams-Bashforth step a frame (a step is never longer than 0.3 T). With 300 particles the hole on the axis shows in the plan at about 20 s and the cloud comes apart at about 31 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Particles. 300 to 600, in tens. The particles keep their spacing, so the cloud is drawn 13 LEDs across its radius at 300 and 16.4 at 600. Fewer particles come apart sooner: of 8 clouds of 300, six split between 176 and 310 T and two thinned into the tail instead; four clouds of 450 split between 349 and 435 T; of four clouds of 600, two split at about 455 T. A new cloud starts 40 T after a split, when the tail holds 65% of the particles, or at 300 + 0.4 N T.\n// Knob 4: View. Turns the cloud about the vertical by up to half a turn, in both views at once. The plan, below the folding line, is the cloud seen from above with its far side up, laid out under the elevation as a first-angle drawing has it.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, exp, log, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Units: the cloud's starting radius is 1 and a lone particle settles at 1,\n// z pointing down. N a / R = 5, so a particle's Stokeslet carries\n// F / (8 pi mu) = 3a/4 = 3.75 / N, and the cloud should fall at about\n// 1 + 1.2 N a / R = 7, the speed of a drop as viscous as the fluid around it\n// (Hadamard and Rybczynski). T, the time for that collective speed of 6 to\n// cover one radius, is the clock the story is told in.\nconst NAR = 5, T = 1 / (1.2 * NAR), EPS = 0.05, E2 = EPS * EPS;\n// The drawing: a radius is 13 LEDs for 300 particles, and grows as the cube\n// root of the count, so the particles keep their spacing on the panel. The\n// elevation has the cloud's centre at row YS and squeezes heights above U0\n// radii logarithmically with scale LS; the plan has its centre at row YP.\nconst YS = 38, YP = 97, U0 = 1.5, LS = 0.8, XY = 68;\n\nexport function setup(params) {\n  params.s = { n: 0, buf: new Float32Array(W * H * 3), c: [0, 0, 0], frame: 0 };\n}\n\nfunction newCloud(S, n) {\n  S.n = n;\n  S.k = 0.75 * (NAR / n);\n  for (const key of [\"x\", \"y\", \"z\", \"vx\", \"vy\", \"vz\", \"wx\", \"wy\", \"wz\"]) S[key] = new Float64Array(n);\n  S.tail = new Uint8Array(n);\n  for (let i = 0; i \u003c n; i++) {\n    let x, y, z;\n    do {\n      x = 2 * Math.random() - 1;\n      y = 2 * Math.random() - 1;\n      z = 2 * Math.random() - 1;\n    } while (x * x + y * y + z * z > 1);\n    S.x[i] = x;\n    S.y[i] = y;\n    S.z[i] = z;\n  }\n  S.t = 0;\n  S.hp = 0;\n  S.seen = 0;\n  S.cx = S.cy = S.cz = 0;\n  S.camX = S.camY = S.camZ = 0;\n  S.split = -1;\n  S.fade = 0;\n}\n\n// Velocities: each particle's own settling plus the regularized Stokeslet of\n// every other, G = [I (r^2 + 2 e^2) + r r^T] / (r^2 + e^2)^(3/2) applied to\n// the weight z. G is even in r, so one pair gives both particles the same\n// vector.\nfunction velocity(S, X, Y, Z, VX, VY, VZ) {\n  const n = S.n;\n  VX.fill(0);\n  VY.fill(0);\n  VZ.fill(0);\n  for (let i = 0; i \u003c n; i++) {\n    const xi = X[i], yi = Y[i], zi = Z[i];\n    let ax = 0, ay = 0, az = 0;\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = X[j] - xi, dy = Y[j] - yi, dz = Z[j] - zi;\n      const s = dx * dx + dy * dy + dz * dz + E2, inv = 1 / (s * sqrt(s));\n      const vx = dx * dz * inv, vy = dy * dz * inv, vz = (s + E2 + dz * dz) * inv;\n      ax += vx;\n      ay += vy;\n      az += vz;\n      VX[j] += vx;\n      VY[j] += vy;\n      VZ[j] += vz;\n    }\n    VX[i] += ax;\n    VY[i] += ay;\n    VZ[i] += az;\n  }\n  const k = S.k;\n  for (let i = 0; i \u003c n; i++) {\n    VX[i] *= k;\n    VY[i] *= k;\n    VZ[i] = VZ[i] * k + 1;\n  }\n}\n\n// One step of the two-step Adams-Bashforth rule, one velocity sum a step,\n// with the weight of the last velocity scaled for a step that changed size.\nfunction step(S, h) {\n  const n = S.n, { x, y, z, vx, vy, vz, wx, wy, wz } = S;\n  velocity(S, x, y, z, vx, vy, vz);\n  const c = S.hp > 0 ? h / (2 * S.hp) : 0;\n  for (let i = 0; i \u003c n; i++) {\n    x[i] += h * (vx[i] + c * (vx[i] - wx[i]));\n    y[i] += h * (vy[i] + c * (vy[i] - wy[i]));\n    z[i] += h * (vz[i] + c * (vz[i] - wz[i]));\n    wx[i] = vx[i];\n    wy[i] = vy[i];\n    wz[i] = vz[i];\n  }\n  S.hp = h;\n  S.t += h / T;\n}\n\n// The cloud's centre: the mean of the particles that are not in the tail.\nfunction centre(S) {\n  const n = S.n, { x, y, z, tail } = S;\n  let sx = 0, sy = 0, sz = 0, m = 0;\n  for (let i = 0; i \u003c n; i++) {\n    if (tail[i]) continue;\n    sx += x[i];\n    sy += y[i];\n    sz += z[i];\n    m++;\n  }\n  if (m > 0) {\n    S.cx = sx / m;\n    S.cy = sy / m;\n    S.cz = sz / m;\n  }\n}\n\n// Friends of friends with a link of 0.32 radii. A particle in a group of\n// fewer than ten, more than 1.2 radii above the centre, is in the tail; the\n// groups of 15% or more are returned with their centres.\nfunction groups(S) {\n  const n = S.n, { x, y, z } = S, lab = new Int32Array(n).fill(-1), out = [], sizes = [], stack = [];\n  const L2 = 0.32 * 0.32;\n  for (let i = 0; i \u003c n; i++) {\n    if (lab[i] >= 0) continue;\n    const g = sizes.length;\n    lab[i] = g;\n    stack.push(i);\n    let size = 0, sx = 0, sy = 0;\n    while (stack.length) {\n      const p = stack.pop();\n      size++;\n      sx += x[p];\n      sy += y[p];\n      for (let j = 0; j \u003c n; j++) {\n        if (lab[j] >= 0) continue;\n        const dx = x[j] - x[p], dy = y[j] - y[p], dz = z[j] - z[p];\n        if (dx * dx + dy * dy + dz * dz \u003c L2) {\n          lab[j] = g;\n          stack.push(j);\n        }\n      }\n    }\n    sizes.push(size);\n    if (size >= 0.15 * n) out.push({ size, x: sx / size, y: sy / size });\n  }\n  for (let i = 0; i \u003c n; i++) S.tail[i] = sizes[lab[i]] \u003c 10 && z[i] - S.cz \u003c -1.2 ? 1 : 0;\n  return out.sort((a, b) => b.size - a.size);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 300, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  S.speed = cl(kv[1], 0.2, 3);\n  S.view = cl(kv[3], 0, 1);\n  const n = Math.round(cl(kv[2], 300, 600) / 10) * 10;\n  if (n !== S.n || (input.btnPressed && input.btnPressed[0])) newCloud(S, n);\n  // Speed 2 tells the story at 8 T a second, one step a frame.\n  const h = d * S.speed * 4 * T, parts = Math.ceil(h / (0.3 * T));\n  for (let p = 0; p \u003c parts; p++) step(S, h / parts);\n  S.frame++;\n  if (S.frame % 12 === 0) {\n    const big = groups(S);\n    // Split: the two biggest groups lie more than a radius apart across, three\n    // looks running (the ring's groups flicker before it really parts).\n    const apart = big.length >= 2 && Math.hypot(big[0].x - big[1].x, big[0].y - big[1].y) > 1;\n    S.seen = apart ? S.seen + 1 : 0;\n    if (S.split \u003c 0 && S.seen >= 3) S.split = S.t;\n  }\n  centre(S);\n  // After a split the daughters fall apart for 40 T; then a new cloud. So\n  // too when the tail has taken 65% of the particles, or at 300 + 0.4 N T.\n  let left = 0;\n  for (let i = 0; i \u003c n; i++) left += 1 - S.tail[i];\n  if ((S.split >= 0 && S.t > S.split + 40) || left \u003c 0.35 * n || S.t > 300 + 0.4 * n) S.fade += (d * S.speed) / 2;\n  if (S.fade > 1) newCloud(S, n);\n  const a = 1 - exp(-d * 6);\n  S.camX += (S.cx - S.camX) * a;\n  S.camY += (S.cy - S.camY) * a;\n  S.camZ += (S.cz - S.camZ) * min(1, a * 2);\n}\n\n// The side view's row for a height u above the centre, in radii.\nfunction rowOf(u, RP) {\n  if (u \u003c= U0) return YS - RP * u;\n  return YS - RP * (U0 + LS * log(1 + (u - U0) / LS));\n}\n\nfunction splat(buf, px, py, r, g, b, I) {\n  if (px \u003c -1 || px >= W || py \u003c -1 || py >= H) return;\n  // Bilinear, so a particle moving a fraction of an LED still moves.\n  const x0 = floor(px), y0 = floor(py), fx = px - x0, fy = py - y0;\n  for (let q = 0; q \u003c 4; q++) {\n    const xx = x0 + (q & 1), yy = y0 + (q >> 1);\n    if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n    const wgt = (q & 1 ? fx : 1 - fx) * (q >> 1 ? fy : 1 - fy) * I;\n    const o = (yy * W + xx) * 3;\n    buf[o] += r * wgt;\n    buf[o + 1] += g * wgt;\n    buf[o + 2] += b * wgt;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const { buf, c } = S, n = S.n;\n  for (let p = 0; p \u003c buf.length; p++) buf[p] *= 0.86;\n  const ph = S.view * PI, cp = cos(ph), sp = sin(ph), RP = 13 * Math.cbrt(n / 300);\n  const fade = (1 - cl(S.fade, 0, 1)) * cl(S.t / 3, 0, 1);\n  const tailC = [0, 0, 0];\n  hsv(S.hue + 0.14, 0.5, 1, tailC);\n  // The cloud's own sinking speed, to colour each particle by how fast it\n  // sinks or rises through the cloud.\n  let vm = 0, m = 0;\n  for (let i = 0; i \u003c n; i++)\n    if (!S.tail[i]) {\n      vm += S.wz[i];\n      m++;\n    }\n  vm /= max(1, m);\n  for (let i = 0; i \u003c n; i++) {\n    const ax = S.x[i] - S.camX, ay = S.y[i] - S.camY, dz = S.z[i] - S.camZ;\n    // Turned about the vertical by the View knob: across the panel and depth.\n    const sx = ax * cp + ay * sp, w = ay * cp - ax * sp;\n    const px = 32 + sx * RP;\n    if (S.tail[i]) {\n      splat(buf, px, rowOf(-dz, RP), tailC[0], tailC[1], tailC[2], 0.55 * fade);\n      continue;\n    }\n    // Sky blue for a particle sinking through the cloud, violet for one\n    // rising through it.\n    const rise = cl(vm - S.wz[i], -1, 1);\n    hsv(S.hue + 0.6 + 0.16 * rise, 0.5 + 0.3 * abs(rise), 1, c);\n    // Elevation, lit by nearness to the viewer.\n    let near = cl(0.5 - w / 2.4, 0, 1);\n    splat(buf, px, rowOf(-dz, RP), c[0], c[1], c[2], (0.14 + 0.34 * near) * fade);\n    // Plan, seen from above and laid out below the elevation as in a\n    // first-angle drawing: the far side at the top, lit by height.\n    near = cl(0.5 - dz / 2, 0, 1);\n    splat(buf, px, YP - w * RP, c[0], c[1], c[2], (0.14 + 0.34 * near) * fade);\n  }\n  // The folding line between the two views, dotted and dim.\n  for (let x = 1; x \u003c W; x += 3) {\n    const o = (XY * W + x) * 3;\n    buf[o] = max(buf[o], 0.1);\n    buf[o + 1] = max(buf[o + 1], 0.1);\n    buf[o + 2] = max(buf[o + 2], 0.12);\n  }\n  // Light adds up where particles crowd; the brightest channel is eased into\n  // range and the other two keep their ratio to it, so crowds stay coloured.\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3, L = max(buf[o], buf[o + 1], buf[o + 2]);\n    const k = L > 1e-4 ? (255 * (1 - exp(-1.6 * L))) / L : 0;\n    display.setPixel(p & 63, p >> 6, buf[o] * k, buf[o + 1] * k, buf[o + 2] * k);\n  }\n}\n","ammann-beenker":"// ===== Patternflow pattern =====\n// Title:   Ammann-Beenker\n// Family:  geometry\n// Idea:    An eightfold aperiodic tiling of squares and 45 degree rhombi, made from four families of parallel lines, slides in its hidden perpendicular space, and every so often a row of hexagons across the panel flips at once, the square and two rhombi in each sliding round to swap places and flaring white before they settle.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ammann-Beenker tiling (Robert Ammann, 1977; Frans Beenker, 1982), built as the dual of a tetragrid after Nicolaas de Bruijn's pentagrids (1981), with its phason flips, pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Phason=0.2..3, Size=8..16, Glow=0..1\n//\n// Knob 1: Hue. Turns the squares and the rhombi round the colour wheel together; at 0 the squares are deep blue and the rhombi gold.\n// Knob 2: Phason. How fast the grids slide in perpendicular space: at 2 a row of hexagons flips about twice a second, at 0.2 once in six seconds, at 3 three times a second.\n// Knob 3: Size. The tile edge in LEDs, 8 to 16: at 8 a star of eight rhombi is 30 LEDs across, at 16 one star fills the width of the panel.\n// Knob 4: Glow. How much of the light belongs to the flips: at 0 the tiles burn at full strength and a flip glows for a second, at 1 the tiles stand dim and each flipped row stays lit for four seconds, a trace of where the phason has passed.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5;\nconst { floor, ceil, cos, sin, exp, min, max, abs, hypot, SQRT1_2: R } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The four grid directions, 45 degrees apart, which are also the tile edges,\n// and the same four turned three times as far: shifting the grids along\n// those moves the tiling in perpendicular space only. It carries the picture\n// nowhere; it only flips tiles.\nconst E = [[1, 0], [R, R], [0, 1], [-R, R]];\nconst EP = [[1, 0], [-R, R], [0, -1], [R, R]];\n// Each pair of families crosses in tiles: 0-2 and 1-3 make the squares, the\n// other four pairs the 45 degree rhombi in their four turns.\nconst PAIRS = [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]];\nconst OTHER = [[2, 3], [1, 3], [1, 2], [0, 3], [0, 2], [0, 1]];\n// Where the grids start, a generic shift so that no three lines meet, and\n// the way the shift drifts in perpendicular space. Each family runs along a\n// diagonal of the square grid the two others make (e1 lies along e0 + e2),\n// so a line that reaches one crossing of that grid reaches every crossing on\n// the same diagonal in the same instant: the flips come in rows across the\n// panel, a hexagon of one square and two rhombi turning over at each.\nconst G0 = [0.137, 0.291, 0.443, 0.619];\nconst DIR = [cos(1.17), sin(1.17)];\n// The middle of the panel: where the tiling's corners sit on average.\nconst OX = -(G0[0] + G0[1] * R - G0[3] * R) + 0.5, OY = -(G0[1] * R + G0[2] + G0[3] * R) + 0.5 + R;\n// A flip slides its three tiles for SLIDE seconds.\nconst SLIDE = 0.45;\nconst LIGHT = [255, 238, 200];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const c = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[o] = c[0] * 255;\n  out[o + 1] = c[1] * 255;\n  out[o + 2] = c[2] * 255;\n}\n\nexport function setup(params) {\n  params.ab = { t: 0, u: 0, frame: 0, size: 8, tiles: new Map(), list: [], buf: new Float32Array(N * 3), col: new Float32Array(6 * 3) };\n}\n\n// Every crossing of two grid lines near the panel is a tile, named by its\n// two families and two line numbers, a name it keeps while the grids slide.\n// Its corner is the sum of the strip numbers it lies in, one per family\n// (Nicolaas de Bruijn's construction). When the grids have slid so that a\n// line of the third family has passed the crossing, the corner jumps by one\n// edge: the tile has flipped.\nfunction tile(A) {\n  const g = [0, 0, 0, 0], s = A.size;\n  for (let i = 0; i \u003c 4; i++) g[i] = G0[i] + A.u * (DIR[0] * EP[i][0] + DIR[1] * EP[i][1]);\n  // Corners lie near twice their crossing, so the crossings needed lie\n  // within half the panel, counted in edges, plus a margin.\n  const hx = (W / 2 / s + 2.5) / 2, hy = (H / 2 / s + 2.5) / 2;\n  const frame = ++A.frame, T = A.tiles, list = (A.list = []);\n  for (let q = 0; q \u003c 6; q++) {\n    const [j, k] = PAIRS[q], ej = E[j], ek = E[k], det = ej[0] * ek[1] - ej[1] * ek[0];\n    const rj = hx * abs(ej[0]) + hy * abs(ej[1]), rk = hx * abs(ek[0]) + hy * abs(ek[1]);\n    for (let mj = floor(-rj - g[j]); mj \u003c= ceil(rj - g[j]); mj++)\n      for (let mk = floor(-rk - g[k]); mk \u003c= ceil(rk - g[k]); mk++) {\n        const bj = mj + g[j], bk = mk + g[k];\n        const px = (bj * ek[1] - bk * ej[1]) / det, py = (ej[0] * bk - ek[0] * bj) / det;\n        if (abs(px) > hx || abs(py) > hy) continue;\n        let vx = mj * ej[0] + mk * ek[0] - OX, vy = mj * ej[1] + mk * ek[1] - OY;\n        for (const i of OTHER[q]) {\n          const K = ceil(px * E[i][0] + py * E[i][1] - g[i]);\n          vx += K * E[i][0];\n          vy += K * E[i][1];\n        }\n        const id = (q * 4096 + (mj & 4095)) * 4096 + (mk & 4095);\n        let t = T.get(id);\n        if (!t) T.set(id, (t = { q, vx, vy, fx: vx, fy: vy, ft: -99, seen: 0 }));\n        else if (t.seen === frame - 1 && (abs(t.vx - vx) > 1e-6 || abs(t.vy - vy) > 1e-6)) {\n          // Slide from wherever it was drawn last.\n          const [dx, dy] = drawn(t, A.t);\n          t.fx = dx;\n          t.fy = dy;\n          t.ft = A.t;\n        }\n        t.vx = vx;\n        t.vy = vy;\n        t.seen = frame;\n        list.push(t);\n      }\n  }\n  if (frame % 60 === 0) for (const [id, t] of T) if (t.seen \u003c frame - 30) T.delete(id);\n}\n\nfunction drawn(t, now) {\n  const a = cl((now - t.ft) / SLIDE, 0, 1), e = 1 - a * a * (3 - 2 * a);\n  return [t.vx + (t.fx - t.vx) * e, t.vy + (t.fy - t.vy) * e];\n}\n\nexport function update(dt, input, params) {\n  if (!params.ab) setup(params);\n  const A = params.ab, k = input.knobValues || [0, 2, 8, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  A.hue = k[0];\n  A.size = cl(k[2], 8, 16);\n  A.glow = cl(k[3], 0, 1);\n  A.t += dt;\n  A.u += dt * cl(k[1], 0.2, 3) * 0.016;\n  tile(A);\n}\n\n// One tile onto the LEDs: a parallelogram at (ax, ay) on edges u and w in\n// colour (r, g, b). LEDs within half an LED of its edges stay dark, so the\n// tiles sit apart by a dark joint one LED wide.\nfunction para(buf, ax, ay, ux, uy, wx, wy, r, g, b) {\n  const det = ux * wy - uy * wx, hu = abs(det) / hypot(wx, wy), hw = abs(det) / hypot(ux, uy);\n  const x0 = max(0, floor(min(ax, ax + ux, ax + wx, ax + ux + wx))), x1 = min(W - 1, ceil(max(ax, ax + ux, ax + wx, ax + ux + wx)));\n  const y0 = max(0, floor(min(ay, ay + uy, ay + wy, ay + uy + wy))), y1 = min(H - 1, ceil(max(ay, ay + uy, ay + wy, ay + uy + wy)));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x - ax, dy = y - ay;\n      const a = (dx * wy - dy * wx) / det, c = (ux * dy - uy * dx) / det;\n      if (a \u003c 0 || a > 1 || c \u003c 0 || c > 1) continue;\n      const m = cl((min(min(a, 1 - a) * hu, min(c, 1 - c) * hw) - 0.35) * 2, 0, 1), p = (y * W + x) * 3;\n      buf[p] = r * m;\n      buf[p + 1] = g * m;\n      buf[p + 2] = b * m;\n    }\n}\n\nexport function draw(display, params) {\n  const A = params.ab;\n  if (!A || !A.list.length) return;\n  const buf = A.buf, col = A.col, s = A.size, now = A.t;\n  buf.fill(0);\n  // Squares deep blue and rhombi gold at Hue 0, each turn of a tile a little\n  // lighter or darker. Glow dims the tiles at rest and lengthens the light\n  // a flip leaves.\n  const rest = 1 - 0.62 * A.glow, fade = 0.7 + 3.3 * A.glow;\n  for (let q = 0; q \u003c 6; q++) {\n    const c = q === 1 ? [0.6, 0.85, 0.62] : q === 4 ? [0.6, 0.8, 0.9] : [0.11, 0.9, [1, 0, 0.86, 0.93, 0, 0.8][q]];\n    hsv(A.hue + c[0], c[1], c[2], col, q * 3);\n  }\n  // Tiles at rest first, then the sliding ones over the dark hexagon they\n  // leave, so they never hide behind a neighbour.\n  const moving = [];\n  for (const t of A.list) {\n    if (now - t.ft \u003c SLIDE) moving.push(t);\n    else put(buf, col, t, t.vx, t.vy, s, rest, 0.75 * exp(-(now - t.ft - SLIDE) / fade));\n  }\n  for (const t of moving) {\n    const [vx, vy] = drawn(t, now);\n    put(buf, col, t, vx, vy, s, 1, 0.75);\n  }\n  for (let p = 0, y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, buf[p], buf[p + 1], buf[p + 2]);\n}\n\n// A tile in its colour at brightness v, whitened by lift: the light of a flip.\nfunction put(buf, col, t, vx, vy, s, v, lift) {\n  const [j, k] = PAIRS[t.q], c = t.q * 3;\n  const r = col[c] * v, g = col[c + 1] * v, b = col[c + 2] * v;\n  para(buf, CX + vx * s, CY + vy * s, E[j][0] * s, E[j][1] * s, E[k][0] * s, E[k][1] * s, r + (LIGHT[0] - r) * lift, g + (LIGHT[1] - g) * lift, b + (LIGHT[2] - b) * lift);\n}\n","broad-nib":"// ===== Patternflow pattern =====\n// Title:   Broad Nib\n// Family:  type\n// Idea:    A broad-edged pen writes Latin mottoes in capitals down a ruled panel, a word a line, stroke by stroke, and every stroke comes out thick or thin by how its direction meets the angle of the nib, so turning the nib re-inks every letter on the page while the pen is still writing.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: broad-edge pen lettering (Edward Johnston, Writing & Illuminating & Lettering, 1906) and the pen model of METAFONT (Donald Knuth, 1979), pattern round 64, writing mottoes from Pliny the Elder, Suetonius and Seneca\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Angle=30..180, Speed=0.2..3, Weight=-1..1, Slant=0..20\n//\n// Knob 1: Angle. The angle of the nib edge to the line, in degrees: at 30 the pen of Johnston's capitals, thick downstrokes and lighter cross strokes; at 90 the contrast turns over, the stems go to hairlines and the cross strokes are heavy; at 180 the pen lies flat and the cross strokes thin to hairlines.\n// Knob 2: Speed. How fast the pen moves: at 2 a downstroke takes a sixth of a second, a page of four words 9 to 15 seconds and the finished page holds for two and a half; at 0.2 the pen is ten times slower.\n// Knob 3: Weight. The nib's width against the height of the capitals: 5.2 nib widths at 0, 8.5 at -1 for a light hand, 3.9 at 1 for a heavy one that closes the counters.\n// Knob 4: Slant. Leans the letters to the right like an italic hand, up to 20 degrees, the whole page at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, cos, sin, tan, sqrt, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Skeleton capitals in a box ten units high, y down from the cap line to the\n// base line: the advance width, then the strokes in the order and direction a\n// pen writes them. M moves, L draws a line, E cx cy rx ry a0 a1 an arc of an\n// ellipse from angle a0 to a1 in degrees (0 right, 90 down).\nconst GLYPHS = {\n  A: \"7|M3.5 0L0 10|M3.5 0L7 10|M1.3 6.6L5.7 6.6\",\n  B: \"5.7|M0 0L0 10|M0 0L2.8 0E2.8 2.4 2.4 2.4 270 450L0 4.8|M0 4.8L3.1 4.8E3.1 7.4 2.6 2.6 270 450L0 10\",\n  C: \"6.1|E3.7 5 3.7 5 305 55\",\n  D: \"7|M0 0L0 10|M0 0L2.2 0E2.2 5 4.8 5 270 450L0 10\",\n  E: \"5.2|M0 0L0 10|M0 0L5 0|M0 4.9L4.2 4.9|M0 10L5.2 10\",\n  F: \"5|M0 0L0 10|M0 0L5 0|M0 4.9L4.2 4.9\",\n  G: \"7.1|E3.7 5 3.7 5 305 25|M4.3 5.7L7.1 5.7L7.1 9.6\",\n  I: \"0|M0 0L0 10\",\n  L: \"5|M0 0L0 10L5 10\",\n  M: \"8.4|M0.5 0L0 10|M0.5 0L4.2 10|M7.9 0L4.2 10|M7.9 0L8.4 10\",\n  N: \"6.6|M0 0L0 10|M0 0L6.6 10|M6.6 0L6.6 10\",\n  O: \"7.4|E3.7 5 3.7 5 270 90|E3.7 5 3.7 5 270 450\",\n  P: \"5.6|M0 0L0 10|M0 0L2.8 0E2.8 2.7 2.8 2.7 270 450L0 5.4\",\n  R: \"6|M0 0L0 10|M0 0L2.6 0E2.6 2.6 2.6 2.6 270 450L0 5.2|M2.4 5.2L6 10\",\n  S: \"5.3|E2.5 2.5 2.4 2.5 335 90E2.6 7.5 2.7 2.5 270 515\",\n  T: \"6.6|M0 0L6.6 0|M3.3 0L3.3 10\",\n  U: \"6.6|M0 0L0 6.6E3.3 6.6 3.3 3.4 180 0|M6.6 0L6.6 10\",\n  V: \"7|M0 0L3.5 10|M7 0L3.5 10\",\n};\n// Four mottoes about writing and time, a word a line: no day without a line\n// (Pliny the Elder on Apelles, Natural History, 77), spoken words fly and\n// written ones stay (a medieval proverb), make haste slowly (Augustus, after\n// Suetonius, 121) and art is long, life is short (Hippocrates, in Seneca's\n// Latin, 49).\nconst PAGES = [\n  [\"NULLA\", \"DIES\", \"SINE\", \"LINEA\"],\n  [\"VERBA\", \"VOLANT\", \"SCRIPTA\", \"MANENT\"],\n  [\"FESTINA\", \"LENTE\"],\n  [\"ARS\", \"LONGA\", \"VITA\", \"BREVIS\"],\n];\n// Ink and the red of the first letter, the rubric, for each page in turn.\nconst INKS = [\n  [[255, 228, 178], [255, 70, 38]],\n  [[120, 168, 255], [255, 196, 70]],\n  [[255, 204, 96], [255, 70, 38]],\n  [[90, 226, 176], [255, 120, 60]],\n];\n// The tallest capitals, and their height in nib widths at Weight 0.\nconst HMAX = 26, NIBS = 5.2;\n\n// Each glyph's strokes as polylines in its unit box.\nfunction parse(src) {\n  const [w, ...strokes] = src.split(\"|\");\n  return {\n    w: +w,\n    strokes: strokes.map((s) => {\n      const tk = s.match(/[MLE]|-?[\\d.]+/g), pts = [];\n      for (let i = 0; i \u003c tk.length; ) {\n        const c = tk[i++];\n        if (c === \"M\" || c === \"L\") pts.push([+tk[i++], +tk[i++]]);\n        else {\n          const [cx, cy, rx, ry, a0, a1] = tk.slice(i, i + 6).map(Number);\n          i += 6;\n          const n = ceil(abs(a1 - a0) / 6);\n          for (let j = 0; j \u003c= n; j++) {\n            const a = ((a0 + ((a1 - a0) * j) / n) * PI) / 180;\n            pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n          }\n        }\n      }\n      return pts;\n    }),\n  };\n}\nconst FONT = {};\nfor (const c in GLYPHS) FONT[c] = parse(GLYPHS[c]);\n\n// Lays out one page: each word on its own line as large as the width lets\n// it be, condensed by up to a third before it shrinks, the lines spread\n// evenly down the panel. Strokes come out in LEDs, cut into pieces no\n// longer than an LED and a half so the pen can stop anywhere along them.\nfunction layout(words) {\n  const lines = words.map((word) => {\n    const gl = [...word].map((c) => FONT[c]), sw = gl.reduce((s, g) => s + g.w, 0);\n    let ky = HMAX / 10, kx = ky;\n    for (; ky > 0.6; ky -= 0.05) {\n      const nib = (ky * 10) / NIBS, gap = nib + 1.2 * ky;\n      kx = (W - 3 - (gl.length - 1) * gap - nib * 0.9) / sw;\n      if (kx >= 0.7 * ky) break;\n    }\n    return { gl, ky, kx: min(kx, ky), gap: (ky * 10) / NIBS + 1.2 * ky };\n  });\n  let total = lines.reduce((s, l) => s + l.ky * 10, 0), room = H - total;\n  if (room \u003c 6 * (lines.length + 1)) {\n    const f = (H - 6 * (lines.length + 1)) / total;\n    for (const l of lines) (l.ky *= f), (l.kx *= f), (l.gap *= f);\n    total *= f;\n    room = H - total;\n  }\n  const strokes = [];\n  strokes.rules = [];\n  let y = room / (lines.length + 1);\n  lines.forEach((l, li) => {\n    const hgt = l.ky * 10, wid = l.gl.reduce((s, g) => s + g.w * l.kx, 0) + (l.gl.length - 1) * l.gap;\n    let x = (W - 1 - wid) / 2;\n    l.gl.forEach((g, gi) => {\n      for (const pts of g.strokes) {\n        const out = [];\n        for (let i = 0; i \u003c pts.length; i++) {\n          const px = x + pts[i][0] * l.kx, py = y + pts[i][1] * l.ky;\n          if (i) {\n            const [qx, qy] = out[out.length - 1], n = ceil(sqrt((px - qx) ** 2 + (py - qy) ** 2) / 1.5);\n            for (let j = 1; j \u003c= n; j++) out.push([qx + ((px - qx) * j) / n, qy + ((py - qy) * j) / n]);\n          } else out.push([px, py]);\n        }\n        const xy = new Float32Array(out.flat()), cum = new Float32Array(out.length);\n        for (let i = 1; i \u003c out.length; i++) cum[i] = cum[i - 1] + sqrt((xy[2 * i] - xy[2 * i - 2]) ** 2 + (xy[2 * i + 1] - xy[2 * i - 1]) ** 2);\n        strokes.push({ xy, cum, len: cum[out.length - 1], hgt, mid: y + hgt / 2, rubric: li === 0 && gi === 0, laid: new Float32Array(out.length).fill(-1) });\n      }\n      x += g.w * l.kx + l.gap;\n    });\n    strokes.rules.push(Math.round(y), Math.round(y + hgt));\n    y += hgt + room / (lines.length + 1);\n  });\n  return strokes;\n}\n\nexport function setup(params) {\n  params.bn = {\n    t: 0, page: -1, strokes: [], si: 0, d: 0, mode: \"lift\", lift: 1, from: [32, -10], to: [32, -10], timer: 0, fadeOut: 1, pen: [32, -10], started: false,\n    angle: PI / 6, speed: 2, weight: 0, slant: 0,\n    cov: new Float32Array(N), covR: new Float32Array(N), wet: new Float32Array(N),\n  };\n}\n\nfunction nextPage(B) {\n  B.page = (B.page + 1) % PAGES.length;\n  B.strokes = layout(PAGES[B.page]);\n  // The page is ruled in faint pencil at the cap line and base line of each\n  // line of writing, as a scribe rules it before the pen comes.\n  B.rule = new Uint8Array(H);\n  for (const r of B.strokes.rules) if (r >= 0 && r \u003c H) B.rule[r] = 1;\n  B.si = 0;\n  B.d = 0;\n  B.fadeOut = 1;\n  startLift(B, B.pen, B.strokes[0]);\n}\n\nfunction startLift(B, from, s) {\n  B.mode = \"lift\";\n  B.from = [from[0], from[1]];\n  B.to = [s.xy[0], s.xy[1]];\n  const dist = sqrt((B.to[0] - from[0]) ** 2 + (B.to[1] - from[1]) ** 2);\n  B.lift = 0;\n  B.liftT = max(0.06, dist / (5 * rate(B, s)));\n}\n\n// The pen's speed on a stroke in LEDs a second, in proportion to the height\n// of its letters, so big and small words take the same time a stroke.\nconst rate = (B, s) => B.speed * 3 * s.hgt;\n\n// The pen, as a little machine: write a stroke, lift and move to the next,\n// and when the page is done hold it, let it fade and turn to the next.\nfunction step(B, dt) {\n  B.t += dt;\n  if (B.mode === \"write\") {\n    const s = B.strokes[B.si];\n    B.d += rate(B, s) * dt;\n    for (let i = 0; i \u003c s.cum.length && s.cum[i] \u003c= B.d; i++) if (s.laid[i] \u003c 0) s.laid[i] = B.t;\n    B.pen = at(s, B.d);\n    if (B.d >= s.len) {\n      B.si++;\n      if (B.si \u003c B.strokes.length) startLift(B, B.pen, B.strokes[B.si]);\n      else (B.mode = \"hold\"), (B.timer = 1.2 + 2.6 / B.speed);\n    }\n  } else if (B.mode === \"lift\") {\n    B.lift = min(1, B.lift + dt / B.liftT);\n    const e = B.lift * B.lift * (3 - 2 * B.lift);\n    B.pen = [B.from[0] + (B.to[0] - B.from[0]) * e, B.from[1] + (B.to[1] - B.from[1]) * e];\n    if (B.lift >= 1) {\n      B.mode = \"write\";\n      B.d = 0;\n      B.strokes[B.si].laid[0] = B.t;\n    }\n  } else if (B.mode === \"hold\") {\n    B.timer -= dt;\n    if (B.timer \u003c= 0) (B.mode = \"fade\"), (B.timer = 0.8);\n  } else {\n    B.timer -= dt;\n    B.fadeOut = max(0, B.timer / 0.8);\n    if (B.timer \u003c= 0) nextPage(B);\n  }\n}\n\n// The point at distance d along a stroke.\nfunction at(s, d) {\n  const n = s.cum.length;\n  if (d >= s.len) return [s.xy[2 * n - 2], s.xy[2 * n - 1]];\n  let i = 0;\n  while (i \u003c n - 2 && s.cum[i + 1] \u003c d) i++;\n  const f = (d - s.cum[i]) / max(1e-6, s.cum[i + 1] - s.cum[i]);\n  return [s.xy[2 * i] + (s.xy[2 * i + 2] - s.xy[2 * i]) * f, s.xy[2 * i + 1] + (s.xy[2 * i + 3] - s.xy[2 * i + 1]) * f];\n}\n\nexport function update(dt, input, params) {\n  if (!params.bn) setup(params);\n  const B = params.bn, k = input.knobValues || [30, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  B.angle = (cl(k[0], 30, 180) * PI) / 180;\n  B.speed = cl(k[1], 0.2, 3);\n  B.weight = cl(k[2], -1, 1);\n  B.slant = (cl(k[3], 0, 20) * PI) / 180;\n  if (!B.started) {\n    // The panel opens on a page already a third written.\n    B.started = true;\n    nextPage(B);\n    for (let i = 0; i \u003c 100; i++) step(B, 1 / 30);\n  }\n  step(B, dt);\n}\n\n// Ink one piece of a stroke: the nib, a segment of half length h along\n// (nx, ny), swept from (ax, ay) to (bx, by), covers a parallelogram, as the\n// pen of METAFONT does. Each LED takes its distance to the nearest edge,\n// softened over one LED, so where the pen runs along its own edge it still\n// leaves a hairline one LED wide. wet is how fresh the ink is.\nfunction sweep(B, buf, ax, ay, bx, by, nx, ny, h, wet) {\n  const sx = bx - ax, sy = by - ay, L = sqrt(sx * sx + sy * sy), mx = (ax + bx) / 2, my = (ay + by) / 2;\n  const ux = L > 1e-4 ? sx / L : 0, uy = L > 1e-4 ? sy / L : 0;\n  const sn = abs(ux * nx + uy * ny), cr = abs(ux * ny - uy * nx);\n  const eA = h * cr, eB = (L * cr) / 2, eC = h + (L * sn) / 2, eD = L / 2 + h * sn;\n  const r = h + 1.5;\n  const x0 = max(0, floor(min(ax, bx) - r)), x1 = min(W - 1, ceil(max(ax, bx) + r));\n  const y0 = max(0, floor(min(ay, by) - r)), y1 = min(H - 1, ceil(max(ay, by) + r));\n  const W2 = B.wet;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const qx = x - mx, qy = y - my;\n      let d = max(abs(qx * ny - qy * nx) - eB, abs(qx * nx + qy * ny) - eC);\n      if (L > 1e-4) d = max(d, abs(qx * uy - qy * ux) - eA, abs(qx * ux + qy * uy) - eD);\n      const c = 0.85 - d;\n      if (c \u003c= 0) continue;\n      const p = y * W + x, v = c > 1 ? 1 : c;\n      if (v > buf[p]) buf[p] = v;\n      const w = v * wet;\n      if (w > W2[p]) W2[p] = w;\n    }\n}\n\nexport function draw(display, params) {\n  const B = params.bn;\n  if (!B || !B.started) return;\n  const { cov, covR, wet } = B;\n  cov.fill(0);\n  covR.fill(0);\n  wet.fill(0);\n  const nx = cos(B.angle), ny = -sin(B.angle), sh = tan(B.slant), wf = NIBS - (B.weight \u003c 0 ? 3.3 : 1.3) * B.weight;\n  const done = B.mode === \"write\" ? B.si + 1 : B.si;\n  for (let k = 0; k \u003c done && k \u003c B.strokes.length; k++) {\n    const s = B.strokes[k], lim = k === B.si && B.mode === \"write\" ? B.d : 1e9, h = s.hgt / wf / 2, buf = s.rubric ? covR : cov;\n    const X = (i) => s.xy[2 * i] + (s.mid - s.xy[2 * i + 1]) * sh;\n    for (let i = 0; i + 1 \u003c s.cum.length && s.cum[i] \u003c lim; i++) {\n      let bx = X(i + 1), by = s.xy[2 * i + 3];\n      if (s.cum[i + 1] > lim) {\n        const f = (lim - s.cum[i]) / (s.cum[i + 1] - s.cum[i]);\n        by = s.xy[2 * i + 1] + (by - s.xy[2 * i + 1]) * f;\n        bx = X(i) + (bx - X(i)) * f;\n      }\n      const age = s.laid[i] \u003c 0 ? 9 : B.t - s.laid[i];\n      sweep(B, buf, X(i), s.xy[2 * i + 1], bx, by, nx, ny, h, exp(-age / 0.5));\n    }\n  }\n  const [ink, rub] = INKS[B.page], f = B.fadeOut;\n  const rule = B.rule;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const a = cov[p], b = covR[p], c = max(a, b);\n      if (c \u003c= 0) {\n        const r = rule[y] * f;\n        display.setPixel(x, y, 30 * r, 34 * r, 54 * r);\n        continue;\n      }\n      const wa = a / (a + b), w = wet[p] * 0.6;\n      let r = (ink[0] * wa + rub[0] * (1 - wa)) * c, g = (ink[1] * wa + rub[1] * (1 - wa)) * c, bl = (ink[2] * wa + rub[2] * (1 - wa)) * c;\n      r += (255 * c - r) * w;\n      g += (255 * c - g) * w;\n      bl += (255 * c - bl) * w;\n      display.setPixel(x, y, r * f, g * f, bl * f);\n    }\n  // The nib itself, a short bar of light at the pen's point, dark round its\n  // edge so it reads on the ink; dimmer while the pen is lifted.\n  if (B.mode === \"write\" || B.mode === \"lift\") {\n    const s = B.strokes[min(B.si, B.strokes.length - 1)], h = s.hgt / wf / 2;\n    const px = B.pen[0] + (s.mid - B.pen[1]) * sh, py = B.pen[1], v = B.mode === \"write\" ? 1 : 0.55;\n    for (let y = max(0, floor(py - h - 2)); y \u003c= min(H - 1, ceil(py + h + 2)); y++)\n      for (let x = max(0, floor(px - h - 2)); x \u003c= min(W - 1, ceil(px + h + 2)); x++) {\n        const qx = x - px, qy = y - py, d = max(abs(qx * ny - qy * nx), abs(qx * nx + qy * ny) - h);\n        if (d \u003c 0.6) display.setPixel(x, y, 255 * v, 255 * v, 255 * v);\n        else if (d \u003c 1.5) display.setPixel(x, y, 0, 0, 0);\n      }\n  }\n}\n","counterforms":"// ===== Patternflow pattern =====\n// Title:   Counterforms\n// Family:  type\n// Idea:    Four tall bold letters stand dark on the dark panel and only their counters, the holes inside A, B, D, O, P, R and the digits, light up like windows lit from inside, so the word is read through its holes and the glow they spill on the strokes, and between words the windows drain and the next word's fill one by one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after the counter as the white shape that makes a letter (Gerrit Noordzij, De streek, 1985) and windows lit in a facade at night\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Words=0..2, Body=0..1\n//\n// Knob 1: Hue. The lamplight in the windows: warm gold at 0, then green, sky blue, violet and rose round the wheel, each window a little off the next.\n// Knob 2: Speed. How fast the windows fill and drain and the words change: at 2 a word every 8 seconds, at 0.2 one in 80.\n// Knob 3: Words. Which words: 0 four-letter words made only of letters with counters (DOOR, ROAD, DROP, BOAR, BARD, ROAR), 1 four-digit numbers made only of 0, 4, 6, 8 and 9 (4096, 8086, 6809, 9600, 8008), 2 two Hangul syllables built from the closed jamo ㅁ, ㅂ and ㅇ (봄밤, 엄마, 아빠, 마음).\n// Knob 4: Body. How much of the letter body shows besides the light the windows throw on it: none at 0, a faint stone just above what the panel shows at the opening 0.06, moonlit at 0.5, the whole letter standing out at 1.\n\nconst W = 64, H = 128, N = W * H;\nconst Q = 3; // supersampling of the glyph mask\nconst HW = W * Q, HH = H * Q;\nconst { floor, round, min, max, sin, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Every word in a set has only glyphs with counters, so every glyph shows.\nconst SETS = [\n  [\"DOOR\", \"ROAD\", \"DROP\", \"BOAR\", \"BARD\", \"ROAR\"],\n  [\"4096\", \"8086\", \"6809\", \"9600\", \"8008\"],\n  [\"봄밤\", \"엄마\", \"아빠\", \"마음\"],\n];\n\n// The face. A glyph is a list of shapes drawn in order into its cell, each\n// one adding ink (1) or cutting it away (0): rounded rectangles with a radius\n// per corner [x0, y0, x1, y1, tl, tr, br, bl] and thick lines. The cell is\n// w by h LEDs and the stroke s LEDs thick.\nfunction glyph(ch, w, h, s) {\n  const P = [];\n  const rr = (x0, y0, x1, y1, tl, tr, br, bl, add = 1) => P.push([0, add, x0, y0, x1, y1, tl, tr, br, bl]);\n  const box = (x0, y0, x1, y1, add = 1) => rr(x0, y0, x1, y1, 0, 0, 0, 0, add);\n  const ln = (x0, y0, x1, y1, wd, add = 1) => P.push([1, add, x0, y0, x1, y1, wd]);\n  const inr = (r) => (r > 0 ? max(1.5, r - s) : 0);\n  const ring = (x0, y0, x1, y1, tl, tr, br, bl) => {\n    rr(x0, y0, x1, y1, tl, tr, br, bl);\n    rr(x0 + s, y0 + s, x1 - s, y1 - s, inr(tl), inr(tr), inr(br), inr(bl), 0);\n  };\n  const R = 10, D = 13;\n  let flip = false;\n  switch (ch) {\n    case \"O\": ring(0, 0, w, h, D, D, D, D); break;\n    case \"0\": ring(0, 0, w, h, D, D, D, D); box(w / 2 - 1.5, h * 0.3, w / 2 + 1.5, h * 0.7); break;\n    case \"D\": ring(0, 0, w, h, 0, D, D, 0); break;\n    case \"A\": {\n      const y = round(h * 0.5);\n      rr(0, 0, w, h, R + 3, R + 3, 0, 0);\n      rr(s, s, w - s, h + 2, inr(R + 3), inr(R + 3), 0, 0, 0);\n      box(0, y, w, y + s);\n      break;\n    }\n    case \"B\": {\n      const m = round(s + (h - 3 * s) * 0.47);\n      ring(0, 0, w - 2, m + s, 0, R, R, 0);\n      ring(0, m, w, h, 0, R, R, 0);\n      break;\n    }\n    case \"P\":\n    case \"R\": {\n      const m = round(h * 0.56);\n      ring(0, 0, w, m, 0, R, R, 0);\n      box(0, 0, s, h);\n      if (ch === \"R\") ln(w * 0.4, m - s / 2, w - s / 2, h + 2, s * 1.1);\n      break;\n    }\n    case \"8\": {\n      const m = round(s + (h - 3 * s) * 0.46);\n      ring(1, 0, w - 1, m + s, D - 1, D - 1, D - 1, D - 1);\n      ring(0, m, w, h, D, D, D, D);\n      break;\n    }\n    case \"9\": flip = true; // a 6 turned half round\n    // falls through\n    case \"6\": {\n      const m = round(h * 0.42);\n      rr(0, 0, w, h, D, D, D, D);\n      rr(s, m + s, w - s, h - s, inr(D), inr(D), inr(D), inr(D), 0);\n      box(s, s, w + 2, m, 0);\n      box(w * 0.62, -1, w + 2, s + 1, 0);\n      break;\n    }\n    case \"4\": {\n      const x = w - s - 2, y = round(h * 0.64);\n      box(x, 0, x + s, h);\n      box(0, y, w, y + s);\n      ln(x + s * 0.5, s * 0.5, s * 0.55, y + s * 0.5, s * 1.15);\n      break;\n    }\n    // Hangul syllables, built from bars: initial, vowel and final in their\n    // usual places in a square cell.\n    default:\n      hangul(ch, w, h, s, box, rr);\n  }\n  return { P, flip };\n}\n\nfunction hangul(ch, w, h, s, box, rr) {\n  // ㅂ in a box; ㅃ as two of them; ㅁ a closed square; ㅇ a closed oval.\n  const b = (x0, y0, x1, y1) => {\n    const m = round(y0 + (y1 - y0) * 0.22);\n    box(x0, y0, x0 + s, y1);\n    box(x1 - s, y0, x1, y1);\n    box(x0, m, x1, m + s);\n    box(x0, y1 - s, x1, y1);\n  };\n  const m = (x0, y0, x1, y1) => {\n    rr(x0, y0, x1, y1, 2, 2, 2, 2);\n    box(x0 + s, y0 + s, x1 - s, y1 - s, 0);\n  };\n  const o = (x0, y0, x1, y1) => {\n    // A circle when the box is wide, an upright oval when it is tall.\n    if (x1 - x0 > y1 - y0) {\n      const c = (x0 + x1) / 2, d = y1 - y0;\n      (x0 = c - d / 2), (x1 = c + d / 2);\n    }\n    const r = min(x1 - x0, y1 - y0) / 2;\n    rr(x0, y0, x1, y1, r, r, r, r);\n    const q = max(1.5, r - s);\n    rr(x0 + s, y0 + s, x1 - s, y1 - s, q, q, q, q, 0);\n  };\n  const i0 = { 봄: b, 밤: b, 엄: o, 마: m, 아: o, 빠: b, 음: o }[ch];\n  const vertical = \"밤엄마아빠\".includes(ch);\n  const final = \"봄밤엄음\".includes(ch);\n  if (vertical) {\n    // Initial on the left, the vowel's long stem on the right, final below.\n    const yb = final ? round(h * 0.47) : h - 6;\n    const yt = final ? 0 : 6;\n    const sx = w - (ch === \"빠\" ? 13 : 16);\n    if (ch === \"빠\") {\n      const half = round((sx - 4) / 2);\n      b(0, yt, half, yb);\n      b(half + 2, yt, sx - 3, yb);\n    } else if (ch === \"엄\") i0(4, yt, sx - 13, yb);\n    else i0(0, yt, sx - 6, yb);\n    box(sx, 0, sx + s, final ? yb + 1 : h);\n    const my = round((final ? yb : h) * 0.5 - s / 2);\n    if (ch === \"엄\") box(sx - 11, my, sx, my + s);\n    else box(sx + s, my, w, my + s);\n    if (final) m(4, yb + 6, w - 4, h);\n  } else {\n    // Initial on top, the vowel's long bar across the middle, final below.\n    const yb = round(h * 0.38);\n    i0(round(w * 0.17), 0, round(w * 0.83), yb);\n    const by = yb + 8;\n    if (ch === \"봄\") box(round(w / 2 - s / 2), yb + 2, round(w / 2 + s / 2), by);\n    box(0, by, w, by + s);\n    m(6, by + s + 5, w - 6, h);\n  }\n}\n\nfunction inside(p, x, y) {\n  if (p[0] === 0) {\n    if (x \u003c p[2] || x > p[4] || y \u003c p[3] || y > p[5]) return false;\n    const cx = (p[2] + p[4]) / 2, cy = (p[3] + p[5]) / 2;\n    const left = x \u003c cx, top = y \u003c cy;\n    const r = left ? (top ? p[6] : p[9]) : top ? p[7] : p[8];\n    if (r \u003c= 0) return true;\n    const dx = left ? p[2] + r - x : x - (p[4] - r);\n    const dy = top ? p[3] + r - y : y - (p[5] - r);\n    if (dx \u003c= 0 || dy \u003c= 0) return true;\n    return dx * dx + dy * dy \u003c= r * r;\n  }\n  const ex = p[4] - p[2], ey = p[5] - p[3];\n  const t = cl(((x - p[2]) * ex + (y - p[3]) * ey) / (ex * ex + ey * ey), 0, 1);\n  const dx = x - p[2] - t * ex, dy = y - p[3] - t * ey;\n  return dx * dx + dy * dy \u003c= (p[6] * p[6]) / 4;\n}\n\n// Cells for a word: four glyphs two by two, or two Hangul syllables one\n// above the other.\nfunction cells(n) {\n  if (n === 4) return [[2, 4, 28, 58], [34, 4, 28, 58], [2, 66, 28, 58], [34, 66, 28, 58]];\n  return [[2, 2, 60, 61], [2, 65, 60, 61]];\n}\n\n// Ink the word into a mask at Q times the panel's resolution, flood the\n// paper from the panel's edge, and whatever paper the flood cannot reach is a\n// counter. Each counter is labelled, and the mask is brought back to LEDs as\n// coverage.\nfunction build(S, word) {\n  const ink = S.hi;\n  ink.fill(0);\n  const chars = [...word];\n  const cs = cells(chars.length);\n  chars.forEach((ch, gi) => {\n    const [cx, cy, w, h] = cs[gi];\n    const s = chars.length === 4 ? 6 : 5;\n    const { P, flip } = glyph(ch, w, h, s);\n    // Each shape inks or cuts only the samples inside its own box, in order.\n    for (const p of P) {\n      let x0, y0, x1, y1;\n      if (p[0] === 0) (x0 = p[2]), (y0 = p[3]), (x1 = p[4]), (y1 = p[5]);\n      else {\n        const r = p[6] / 2;\n        (x0 = min(p[2], p[4]) - r), (x1 = max(p[2], p[4]) + r), (y0 = min(p[3], p[5]) - r), (y1 = max(p[3], p[5]) + r);\n      }\n      if (flip) [x0, x1, y0, y1] = [w - x1, w - x0, h - y1, h - y0];\n      const sx0 = max(cx * Q, floor((cx + x0) * Q)), sx1 = min((cx + w) * Q, Math.ceil((cx + x1) * Q));\n      const sy0 = max(cy * Q, floor((cy + y0) * Q)), sy1 = min((cy + h) * Q, Math.ceil((cy + y1) * Q));\n      for (let sy = sy0; sy \u003c sy1; sy++)\n        for (let sx = sx0; sx \u003c sx1; sx++) {\n          let x = (sx + 0.5) / Q - cx, y = (sy + 0.5) / Q - cy;\n          if (flip) (x = w - x), (y = h - y);\n          if (inside(p, x, y)) ink[sy * HW + sx] = p[1];\n        }\n    }\n  });\n  // Flood the outside (label 2) from every paper sample on the edge.\n  const lab = S.lab;\n  for (let i = 0; i \u003c HW * HH; i++) lab[i] = ink[i] ? 1 : 0;\n  const st = S.stack;\n  const flood = (seed, l) => {\n    let n = 0, sp = 0, x0 = 1e9, x1 = -1, y0 = 1e9, y1 = -1, gx = 0;\n    st[sp++] = seed;\n    lab[seed] = l;\n    while (sp) {\n      const i = st[--sp];\n      const x = i % HW, y = (i / HW) | 0;\n      n++;\n      gx += x;\n      if (x \u003c x0) x0 = x;\n      if (x > x1) x1 = x;\n      if (y \u003c y0) y0 = y;\n      if (y > y1) y1 = y;\n      if (x > 0 && !lab[i - 1]) (lab[i - 1] = l), (st[sp++] = i - 1);\n      if (x \u003c HW - 1 && !lab[i + 1]) (lab[i + 1] = l), (st[sp++] = i + 1);\n      if (y > 0 && !lab[i - HW]) (lab[i - HW] = l), (st[sp++] = i - HW);\n      if (y \u003c HH - 1 && !lab[i + HW]) (lab[i + HW] = l), (st[sp++] = i + HW);\n    }\n    return { n, x0: x0 / Q, x1: (x1 + 1) / Q, y0: y0 / Q, y1: (y1 + 1) / Q, gx: gx / n / Q };\n  };\n  for (let x = 0; x \u003c HW; x++) for (const y of [0, HH - 1]) if (!lab[y * HW + x]) flood(y * HW + x, 2);\n  for (let y = 0; y \u003c HH; y++) for (const x of [0, HW - 1]) if (!lab[y * HW + x]) flood(y * HW + x, 2);\n  // Every sample still unlabelled is inside a counter.\n  const counters = [];\n  let next = 3;\n  for (let i = 0; i \u003c HW * HH; i++)\n    if (!lab[i]) {\n      const c = flood(i, next++);\n      if (c.n \u003c Q * Q * 3) continue; // a speck, not a window\n      // Reading order: by glyph cell, then top to bottom.\n      const cyc = (c.y0 + c.y1) / 2;\n      c.cell = cs.findIndex(([x, y, w, h]) => c.gx >= x && c.gx \u003c x + w && cyc >= y && cyc \u003c y + h);\n      c.label = next - 1;\n      counters.push(c);\n    }\n  counters.sort((a, b) => a.cell - b.cell || a.y0 - b.y0 || a.x0 - b.x0);\n  const byLabel = new Int16Array(next).fill(-1);\n  counters.forEach((c, k) => (byLabel[c.label] = k));\n  // Back to LEDs.\n  S.body.fill(0);\n  S.cov.fill(0);\n  S.cid.fill(-1);\n  const tally = new Int32Array(counters.length);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let b = 0, best = -1, bn = 0;\n      tally.fill(0);\n      for (let j = 0; j \u003c Q; j++)\n        for (let i = 0; i \u003c Q; i++) {\n          const l = lab[(y * Q + j) * HW + x * Q + i];\n          if (l === 1) b++;\n          else if (l >= 3) {\n            const k = byLabel[l];\n            if (k \u003c 0) continue;\n            if (++tally[k] > bn) (bn = tally[k]), (best = k);\n          }\n        }\n      const p = y * W + x;\n      S.body[p] = b / (Q * Q);\n      if (best >= 0) {\n        S.cid[p] = best;\n        S.cov[p] = bn / (Q * Q);\n        const c = counters[best];\n        S.hf[p] = cl((y + 0.5 - c.y0) / (c.y1 - c.y0), 0, 1);\n      }\n    }\n  S.counters = counters.map((c, k) => ({ y0: c.y0, y1: c.y1, area: c.n / (Q * Q), tint: TINTS[k % TINTS.length], beat: k * 1.7 }));\n}\n\n// Each window a little off the next, the way lamps in a row of rooms differ.\nconst TINTS = [0, 0.02, -0.025, 0.035, -0.012, 0.012, -0.035, 0.006];\n\nexport function setup(params) {\n  params.s = {\n    hi: new Uint8Array(HW * HH), lab: new Int32Array(HW * HH), stack: new Int32Array(HW * HH),\n    body: new Float32Array(N), cov: new Float32Array(N), cid: new Int16Array(N),\n    L: new Float32Array(N * 3), T: new Float32Array(N * 3), B: new Float32Array(N * 3), hf: new Float32Array(N), lut: new Float32Array(64 * 16 * 3),\n    counters: [], set: -1, word: 0, t: 0, time: 0, hue: 0, bodyK: 0.06,\n  };\n}\n\n// The word's life in seconds at Speed 2: the windows fill one after another,\n// hold, drain from the last window back, and the dark letters wait a moment\n// for the next word.\nconst STAGGER = 0.42, FILL = 1.0, HOLD = 3.4, DRAIN = 1.1, DARK = 0.55;\nfunction life(S) {\n  return S.counters.length * STAGGER + FILL + HOLD + DRAIN + DARK;\n}\n\n// How full window k is, 0..1, at word time t.\nfunction level(S, k, t) {\n  const n = S.counters.length;\n  const a = k * STAGGER;\n  const full = n * STAGGER + FILL;\n  if (t \u003c full + HOLD) {\n    const u = cl((t - a) / FILL, 0, 1);\n    return u * u * (3 - 2 * u);\n  }\n  const d = t - full - HOLD - (n - 1 - k) * 0.08;\n  const u = 1 - cl(d / DRAIN, 0, 1);\n  return u * u * (3 - 2 * u);\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.hue = k[0];\n  const sp = cl(k[1], 0.05, 3) / 2;\n  const set = cl(round(k[2]), 0, SETS.length - 1);\n  S.bodyK = cl(k[3], 0, 1);\n  if (set !== S.set) {\n    // A new set opens with its first word already lit.\n    S.set = set;\n    S.word = 0;\n    build(S, SETS[set][0]);\n    S.t = S.counters.length * STAGGER + FILL + 0.4;\n  }\n  S.time += dt;\n  S.t += dt * sp;\n  if (S.t >= life(S)) {\n    S.t -= life(S);\n    S.word = (S.word + 1) % SETS[S.set].length;\n    build(S, SETS[S.set][S.word]);\n  }\n}\n\n// How the stone answers the light thrown on it, by the light's level.\nconst SPILL = 0.8;\nconst TONE = new Float32Array(1024);\n\n// Box blur of radius r along rows or columns, A into B, the three colour\n// channels together.\nfunction blur(A, B, r, horizontal) {\n  const len = horizontal ? W : H, lines = horizontal ? H : W;\n  const step = horizontal ? 3 : W * 3;\n  const norm = 1 / (2 * r + 1);\n  for (let l = 0; l \u003c lines; l++) {\n    const base = horizontal ? l * W * 3 : l * 3;\n    let ar = A[base] * r, ag = A[base + 1] * r, ab = A[base + 2] * r;\n    for (let i = 0; i \u003c= r; i++) {\n      const q = base + i * step;\n      ar += A[q];\n      ag += A[q + 1];\n      ab += A[q + 2];\n    }\n    const last = base + (len - 1) * step;\n    for (let i = 0, q = base; i \u003c len; i++, q += step) {\n      B[q] = ar * norm;\n      B[q + 1] = ag * norm;\n      B[q + 2] = ab * norm;\n      const ai = i + r + 1 \u003c len ? q + (r + 1) * step : last;\n      const ao = i - r > 0 ? q - r * step : base;\n      ar += A[ai] - A[ao];\n      ag += A[ai + 1] - A[ao + 1];\n      ab += A[ai + 2] - A[ao + 2];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (S.set \u003c 0) return;\n  const { L, T, B, body, cov, cid, hf, counters, lut } = S;\n  // Each window's lamp: its tint, a slow breath, how full it is, and its\n  // colour from the paler top of the pane to the deeper bottom.\n  const lamp = counters.map((c, k) => {\n    const lv = level(S, k, S.t);\n    const h = 0.115 + S.hue + c.tint;\n    for (let j = 0; j \u003c 16; j++) {\n      const u = j / 15;\n      const [r, g, b] = hsv(h - 0.02 * u, 0.4 + 0.42 * u, 1);\n      lut[(k * 16 + j) * 3] = r;\n      lut[(k * 16 + j) * 3 + 1] = g;\n      lut[(k * 16 + j) * 3 + 2] = b;\n    }\n    return { lv, top: c.y1 - lv * (c.y1 - c.y0), glow: 0.86 + 0.14 * sin(S.time * 1.15 + c.beat) };\n  });\n  L.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    const k = cid[p];\n    if (k \u003c 0) continue;\n    const m = lamp[k];\n    if (m.lv \u003c= 0) continue;\n    const y = (p / W) | 0;\n    // The light stands in the window like a liquid: lit below its surface,\n    // with a brighter rim while it is still moving.\n    const f = cl(y + 1 - m.top, 0, 1);\n    if (f \u003c= 0) continue;\n    const u = hf[p];\n    const rim = m.lv \u003c 0.999 ? 0.5 * exp(-((y + 0.5 - m.top) ** 2) / 2) : 0;\n    const v = 236 * cov[p] * f * min(1.3, m.glow * (0.8 + 0.2 * (1 - u)) + rim);\n    const q = (k * 16 + round(u * 15)) * 3;\n    L[p * 3] = lut[q] * v;\n    L[p * 3 + 1] = lut[q + 1] * v;\n    L[p * 3 + 2] = lut[q + 2] * v;\n  }\n  // The light thrown out of the windows onto the strokes round them, strong\n  // on the inner edge and fading across the stroke; the night air outside\n  // the letters takes almost none of it.\n  blur(L, T, 4, true);\n  blur(T, B, 4, false);\n  blur(B, T, 3, true);\n  blur(T, B, 3, false);\n  // A square root, so the knob's opening 0.06 already lifts the stone to\n  // about 37/255, the faintest the panel shows.\n  const moon = Math.sqrt(S.bodyK);\n  if (!TONE[1]) for (let i = 1; i \u003c 1024; i++) TONE[i] = (SPILL * 255 * (i / 1020) ** 0.42) / (i / 4);\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const bd = body[p];\n      const o = p * 3;\n      const s = max(B[o], B[o + 1], B[o + 2]);\n      // The stone answers the light with a softer curve than linear, so the\n      // far side of a stroke still shows.\n      const lift = s > 0.5 ? bd * TONE[min(1023, (s * 4) | 0)] + 0.1 * (1 - bd) : 0;\n      display.setPixel(\n        x, y,\n        cl(L[o] + B[o] * lift + bd * moon * 120, 0, 255),\n        cl(L[o + 1] + B[o + 1] * lift + bd * moon * 128, 0, 255),\n        cl(L[o + 2] + B[o + 2] * lift + bd * moon * 150, 0, 255),\n      );\n    }\n}\n","hill-regions":"// ===== Patternflow pattern =====\n// Title:   Hill's Regions\n// Family:  particle\n// Idea:    Seven test particles in the rotating frame of two masses, stood upright so the masses sit one above the other, are fenced in by the zero-velocity curve of their Jacobi constant, and lowering the constant opens the necks at the Lagrange points L1, L2 and L3 one by one, so the particles leak from one mass to the other and out past the small one.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: collinear and triangular Lagrange points (Leonhard Euler, 1767; Joseph-Louis Lagrange, 1772), Jacobi integral of the circular restricted three-body problem (Carl Jacobi, 1836), zero-velocity curves and Hill's regions (George William Hill, 1878), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Jacobi=0..4, Mass=0.1..0.5, Trail=2..10\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the forbidden region is dark violet with the curves of lower C drawn in it as a contour map, its edge pale cyan, the trails run from amber through lime to teal, the large mass is pale gold and the small one sky blue. The dark wall skips orange and yellow, which read brown on the panel.\n// Knob 2: Jacobi. The Jacobi constant C = 2 Omega - v^2 as a ladder whose whole numbers count the open necks: at 0 C is above C1 and each mass keeps its own particles, the neck at L1 between the masses opens at 0.5, the one at L2 beyond the small mass at 1.5, the one at L3 beyond the large mass at 2.5, and at 4 C = 3 - mu + mu^2 and the last walls round L4 and L5 shrink to points. At mu = 0.1 that is C = 3.715 at 0, C1 = 3.597 at 0.5, C2 = 3.467 at 1.5, 3.283 at the opening 2, C3 = 3.100 at 2.5 and 2.910 at 4. The four-dot mark on a Lagrange point brightens when its neck is open, and a particle a moving wall lands on starts again.\n// Knob 3: Mass. The small mass's share mu, from 0.1 to 0.5. At 0.1 the small mass sits on row 23, L1 13 rows below it and L2 16 rows above; at 0.5 the masses are equal, the picture is symmetric about the middle row, and L2 and L3 open together.\n// Knob 4: Trail. Seconds of path each particle leaves behind, 2 to 10. Time runs at 0.9 units a second, so the frame turns once every 7 seconds and a particle close to the large mass circles it in about one.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, round, exp, hypot, PI, cos, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The rotating frame: the primary, mass 1 - mu, at (-mu, 0) and the\n// secondary, mass mu, at (1 - mu, 0), turning once in 2 pi. The x axis runs\n// up the panel, S LEDs to a unit, with x = XC on the middle row.\nconst S = 46, XC = 0.02;\nconst toRow = (x) => 63.5 - (x - XC) * S;\nconst toCol = (y) => 31.5 + y * S;\n\n// Twice the effective potential, 2 Omega = x^2 + y^2 + 2(1 - mu)/r1 + 2 mu/r2.\n// The Jacobi constant is C = 2 Omega - v^2, so v^2 = 2 Omega - C and the\n// particle can never be where 2 Omega \u003c C.\nfunction omega2(mu, x, y) {\n  const r1 = hypot(x + mu, y), r2 = hypot(x - 1 + mu, y);\n  return x * x + y * y + (2 * (1 - mu)) / r1 + (2 * mu) / r2;\n}\n// d Omega / dx on the axis, whose three roots are L3 \u003c L1 \u003c L2.\nfunction omx(mu, x) {\n  const a = x + mu, b = x - 1 + mu;\n  return x - ((1 - mu) * a) / abs(a * a * a) - (mu * b) / abs(b * b * b);\n}\nfunction root(mu, lo, hi) {\n  let flo = omx(mu, lo);\n  for (let i = 0; i \u003c 80; i++) {\n    const m = (lo + hi) / 2, fm = omx(mu, m);\n    if (fm * flo > 0) (lo = m), (flo = fm);\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\nfunction lagrange(st) {\n  const mu = st.mu, e = 1e-9;\n  const L1 = root(mu, -mu + e, 1 - mu - e);\n  const L2 = root(mu, 1 - mu + e, 3);\n  const L3 = root(mu, -3, -mu - e);\n  st.L = [\n    [L1, 0],\n    [L2, 0],\n    [L3, 0],\n    [0.5 - mu, sqrt(3) / 2],\n    [0.5 - mu, -sqrt(3) / 2],\n  ];\n  st.CL = [omega2(mu, L1, 0), omega2(mu, L2, 0), omega2(mu, L3, 0), 3 - mu + mu * mu];\n}\n\n// The Jacobi knob as a ladder: at 0.5 the L1 neck is about to open, at 1.5\n// L2, at 2.5 L3, and at 4 the last forbidden islands round L4 and L5 shrink\n// to points. So the knob's whole number is how many necks are open.\nfunction jacobiOf(st, k) {\n  const [c1, c2, c3, c4] = st.CL;\n  const nodes = [\n    [0, c1 + 0.6 * (c1 - c2) + 0.04],\n    [0.5, c1],\n    [1.5, c2],\n    [2.5, c3],\n    [4, c4],\n  ];\n  for (let i = 1; i \u003c nodes.length; i++)\n    if (k \u003c= nodes[i][0]) {\n      const [k0, a] = nodes[i - 1], [k1, b] = nodes[i];\n      return a + ((b - a) * (k - k0)) / (k1 - k0);\n    }\n  return c4;\n}\n\n// The field of 2 Omega and its gradient over the panel, built when mu changes.\nfunction buildField(st) {\n  const mu = st.mu;\n  for (let r = 0; r \u003c H; r++) {\n    const x = XC + (63.5 - r) / S;\n    for (let c = 0; c \u003c W; c++) {\n      const y = (c - 31.5) / S, o = r * W + c;\n      const ax = x + mu, bx = x - 1 + mu;\n      const r1 = hypot(ax, y), r2 = hypot(bx, y);\n      const k1 = (1 - mu) / (r1 * r1 * r1), k2 = mu / (r2 * r2 * r2);\n      st.F[o] = x * x + y * y + (2 * (1 - mu)) / r1 + (2 * mu) / r2;\n      const gx = 2 * (x - k1 * ax - k2 * bx), gy = 2 * (y - k1 * y - k2 * y);\n      st.G[o] = max(1e-6, hypot(gx, gy));\n    }\n  }\n}\n\n// Equations of motion in the rotating frame:\n//   x'' = 2 y' + dOmega/dx,  y'' = -2 x' + dOmega/dy.\nfunction deriv(mu, s, out) {\n  const [x, y, vx, vy] = s;\n  const ax = x + mu, bx = x - 1 + mu;\n  const r1 = hypot(ax, y), r2 = hypot(bx, y);\n  const k1 = (1 - mu) / (r1 * r1 * r1), k2 = mu / (r2 * r2 * r2);\n  out[0] = vx;\n  out[1] = vy;\n  out[2] = 2 * vy + x - k1 * ax - k2 * bx;\n  out[3] = -2 * vx + y - k1 * y - k2 * y;\n}\n\nconst K = [new Float64Array(4), new Float64Array(4), new Float64Array(4), new Float64Array(4)], T = new Float64Array(4);\nfunction rk4(mu, s, h) {\n  deriv(mu, s, K[0]);\n  for (let i = 0; i \u003c 4; i++) T[i] = s[i] + 0.5 * h * K[0][i];\n  deriv(mu, T, K[1]);\n  for (let i = 0; i \u003c 4; i++) T[i] = s[i] + 0.5 * h * K[1][i];\n  deriv(mu, T, K[2]);\n  for (let i = 0; i \u003c 4; i++) T[i] = s[i] + h * K[2][i];\n  deriv(mu, T, K[3]);\n  for (let i = 0; i \u003c 4; i++) s[i] += (h / 6) * (K[0][i] + 2 * K[1][i] + 2 * K[2][i] + K[3][i]);\n}\n\n// Body radii in frame units, the drawn disc and the collision.\nconst bodyR = (m) => 0.035 + 0.06 * Math.cbrt(m);\n\n// The LEDs a particle can reach from the masses without crossing a wall,\n// found by a flood fill over the allowed region whenever C or mu moves.\nfunction reach(st) {\n  const key = st.mu + \"/\" + st.C;\n  if (st.maskKey === key) return;\n  st.maskKey = key;\n  const M = st.mask, Q = st.queue, F = st.F, C = st.C;\n  M.fill(0);\n  let n = 0, qh = 0;\n  for (const x of [-st.mu, 1 - st.mu]) {\n    const o = round(toRow(x)) * W + 32;\n    if (o >= 0 && o \u003c N && !M[o]) (M[o] = 1), (Q[n++] = o);\n  }\n  while (qh \u003c n) {\n    const o = Q[qh++], c = o % W;\n    for (const q of [o - W, o + W, c > 0 ? o - 1 : -1, c \u003c W - 1 ? o + 1 : -1])\n      if (q >= 0 && q \u003c N && !M[q] && F[q] > C + 0.02) (M[q] = 1), (Q[n++] = q);\n  }\n  st.reachable = n;\n}\n\n// A particle starts anywhere the masses can reach, with the speed its\n// Jacobi constant gives it there, in a random direction. Half of them start\n// in the lobe of the smaller mass, so there is always something to leak.\nfunction spawn(st, p) {\n  const mu = st.mu, C = st.C;\n  reach(st);\n  const L1 = st.L[0][0];\n  for (let tries = 0; tries \u003c 80; tries++) {\n    let x, y;\n    if (Math.random() \u003c 0.45) {\n      const r = bodyR(mu) + 0.01 + Math.random() * 0.8 * (1 - mu - L1), a = Math.random() * 2 * PI;\n      x = 1 - mu + r * cos(a);\n      y = r * sin(a);\n    } else {\n      const o = st.queue[floor(Math.random() * st.reachable)];\n      x = XC + (63.5 - floor(o / W) - Math.random() + 0.5) / S;\n      y = ((o % W) - 31.5 + Math.random() - 0.5) / S;\n    }\n    if (hypot(x + mu, y) \u003c bodyR(1 - mu) + 0.03 || hypot(x - 1 + mu, y) \u003c bodyR(mu) + 0.01) continue;\n    const v2 = omega2(mu, x, y) - C;\n    if (v2 \u003c= 0.01) continue;\n    const v = sqrt(v2), b = Math.random() * 2 * PI;\n    p.s[0] = x;\n    p.s[1] = y;\n    p.s[2] = v * cos(b);\n    p.s[3] = v * sin(b);\n    break;\n  }\n  p.n = 0;\n  p.age = 0;\n  p.out = 0;\n}\n\n// Put the speed back on the shell of the Jacobi constant, so the particle\n// keeps to the region the panel draws for it even as the knob moves.\nfunction shell(st, p) {\n  const s = p.s, v2 = omega2(st.mu, s[0], s[1]) - st.C, v = hypot(s[2], s[3]);\n  if (v2 \u003c= 0) {\n    s[2] = s[3] = 0;\n    return v2 \u003c -0.05;\n  }\n  if (v > 1e-9) {\n    const f = sqrt(v2) / v;\n    s[2] *= f;\n    s[3] *= f;\n  }\n  return false;\n}\n\nconst NP = 7, HIST = 320;\n\nexport function setup(params) {\n  params.st = {\n    mu: -1, C: 0, k: [0, 2, 0.1, 2],\n    F: new Float32Array(N), G: new Float32Array(N), mask: new Uint8Array(N), queue: new Int32Array(N), maskKey: '', reachable: 0,\n    R: new Float32Array(N), Gc: new Float32Array(N), B: new Float32Array(N),\n    parts: [], t: 0, frame: 0, c: new Float32Array(3),\n  };\n}\n\nfunction step(st, p, T) {\n  const mu = st.mu, s = p.s;\n  let left = T;\n  while (left > 0) {\n    const r1 = hypot(s[0] + mu, s[1]), r2 = hypot(s[0] - 1 + mu, s[1]);\n    // Small steps near a mass: a Kepler orbit there gets 300 steps a turn.\n    const h = min(left, 0.004, 0.02 * min(r1 ** 1.5, (r2 ** 1.5) / sqrt(mu / 0.1)));\n    rk4(mu, s, h);\n    left -= h;\n    if (r1 \u003c bodyR(1 - mu) * 0.8 || r2 \u003c bodyR(mu) * 0.8) return true;\n  }\n  return shell(st, p);\n}\n\nexport function update(dt, input, params) {\n  if (!params.st) setup(params);\n  const st = params.st, kv = input.knobValues || [0, 2, 0.1, 2], d = cl(dt || 0, 0, 0.1);\n  st.k = [kv[0], cl(kv[1], 0, 4), cl(kv[2], 0.1, 0.5), cl(kv[3], 2, 10)];\n  const mu = st.k[2];\n  if (abs(mu - st.mu) > 1e-6) {\n    st.mu = mu;\n    lagrange(st);\n    buildField(st);\n  }\n  st.C = jacobiOf(st, st.k[1]);\n  if (!st.parts.length) {\n    for (let i = 0; i \u003c NP; i++) {\n      const p = { s: new Float64Array(4), hx: new Float32Array(HIST), hy: new Float32Array(HIST), n: 0, head: 0, age: 0, out: 0, hue: i / NP };\n      spawn(st, p);\n      st.parts.push(p);\n    }\n    // Run the opening for ten seconds so the longest trails are there at once.\n    for (let f = 0; f \u003c 300; f++) advance(st, 1 / 30);\n  }\n  advance(st, d);\n}\n\nconst SPEED = 0.9;\n\nfunction advance(st, d) {\n  st.t += d;\n  for (const p of st.parts) {\n    p.age += d;\n    // A particle sitting in a wall the knob just moved over starts again.\n    let dead = shell(st, p);\n    if (!dead) dead = step(st, p, d * SPEED);\n    const row = toRow(p.s[0]), col = toCol(p.s[1]);\n    if (row \u003c -12 || row > H + 12 || col \u003c -12 || col > W + 12) p.out += d;\n    else p.out = 0;\n    if (dead || p.out > 0.6) {\n      spawn(st, p);\n      continue;\n    }\n    p.head = (p.head + 1) % HIST;\n    p.hx[p.head] = col;\n    p.hy[p.head] = row;\n    p.n = min(HIST, p.n + 1);\n  }\n}\n\nfunction splat(st, x, y, v, c) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(st, ix, iy, (1 - fx) * (1 - fy) * v, c);\n  add(st, ix + 1, iy, fx * (1 - fy) * v, c);\n  add(st, ix, iy + 1, (1 - fx) * fy * v, c);\n  add(st, ix + 1, iy + 1, fx * fy * v, c);\n}\nfunction add(st, x, y, v, c) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = y * W + x;\n  st.R[o] += v * c[0];\n  st.Gc[o] += v * c[1];\n  st.B[o] += v * c[2];\n}\n\nexport function draw(display, params) {\n  const st = params.st;\n  if (!st || st.mu \u003c 0) return;\n  const { F, G, R, Gc, B, c } = st, C = st.C, hue = st.k[0];\n  const wall = [0, 0, 0], edge = [0, 0, 0], topo = [0, 0, 0], glow = [0, 0, 0];\n  // The wall's dark hue skips orange and yellow, which read brown and olive.\n  const wh = 0.2 + 0.8 * frac(hue + 0.7);\n  hsv(wh, 0.75, 0.2, wall, 0);\n  hsv(wh, 0.55, 0.36, topo, 0);\n  hsv(hue + 0.52, 0.45, 1, edge, 0);\n  hsv(wh - 0.1, 0.6, 0.07, glow, 0);\n  const DL = 0.06;\n  for (let o = 0; o \u003c N; o++) {\n    const f = F[o], g = G[o] / S;\n    // Distance in LEDs to the zero-velocity curve 2 Omega = C.\n    const dist = (f - C) / g;\n    let r = 0, gg = 0, b = 0;\n    if (dist \u003c 0) {\n      // The forbidden region, with the curves of lower C it would retreat\n      // to drawn in it as a contour map.\n      const q = f / DL, dl = abs(q - round(q)) * DL / g;\n      const line = cl(1 - dl / 0.7, 0, 1);\n      r = wall[0] + (topo[0] - wall[0]) * line;\n      gg = wall[1] + (topo[1] - wall[1]) * line;\n      b = wall[2] + (topo[2] - wall[2]) * line;\n    } else {\n      // The allowed region, faintly lit by the speed a particle has there.\n      const v = cl((f - C) * 0.8, 0, 1);\n      r = glow[0] * v;\n      gg = glow[1] * v;\n      b = glow[2] * v;\n    }\n    const e = cl(1.15 - abs(dist) / 0.9, 0, 1);\n    R[o] = r + (edge[0] - r) * e;\n    Gc[o] = gg + (edge[1] - gg) * e;\n    B[o] = b + (edge[2] - b) * e;\n  }\n  // Lagrange points: bright when their neck is open, dim when shut.\n  for (let i = 0; i \u003c 5; i++) {\n    const [x, y] = st.L[i];\n    const open = i \u003c 3 ? C \u003c st.CL[i] : C \u003c st.CL[3] + 1e-9;\n    const v = open ? 0.9 : 0.35;\n    c[0] = c[1] = c[2] = v;\n    const rr = toRow(x), cc = toCol(y);\n    for (const [dx, dy] of [[-2, 0], [2, 0], [0, -2], [0, 2]]) splat(st, cc + dx, rr + dy, 0.8, c);\n  }\n  // The trails, oldest faintest.\n  const tr = st.k[3] * 30;\n  for (const p of st.parts) {\n    hsv(hue + 0.08 + p.hue * 0.5, 0.6, 1, c, 0);\n    const m = min(p.n, floor(tr), HIST);\n    const fadeIn = cl(p.age / 0.4, 0, 1);\n    for (let j = 1; j \u003c m; j++) {\n      const a = (p.head - j + 1 + HIST) % HIST, b = (p.head - j + HIST) % HIST;\n      const x0 = p.hx[a], y0 = p.hy[a], x1 = p.hx[b], y1 = p.hy[b];\n      const w = 1.5 * (1 - j / m) ** 1.2 * fadeIn;\n      const L = hypot(x1 - x0, y1 - y0), n = max(1, Math.ceil(L * 2));\n      if (L > 30) continue;\n      for (let i = 0; i \u003c n; i++) splat(st, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, (w * 0.9 * L) / n, c);\n    }\n    c[0] = c[0] * 0.3 + 0.7;\n    c[1] = c[1] * 0.3 + 0.7;\n    c[2] = c[2] * 0.3 + 0.7;\n    if (p.n) splat(st, p.hx[p.head], p.hy[p.head], 2 * fadeIn, c);\n  }\n  // The two masses.\n  const mu = st.mu;\n  for (const [mx, m, h] of [\n    [-mu, 1 - mu, 0.13],\n    [1 - mu, mu, 0.55],\n  ]) {\n    const rr = toRow(mx), cc = toCol(0), rad = bodyR(m) * S;\n    hsv(hue + h, 0.35, 1, c, 0);\n    for (let y = floor(rr - rad - 1); y \u003c= rr + rad + 1; y++)\n      for (let x = floor(cc - rad - 1); x \u003c= cc + rad + 1; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const dd = hypot(x - cc, y - rr), a = cl(rad + 0.5 - dd, 0, 1);\n        const o = y * W + x;\n        R[o] += (c[0] - R[o]) * a;\n        Gc[o] += (c[1] - Gc[o]) * a;\n        B[o] += (c[2] - B[o]) * a;\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++)\n      display.setPixel(x, y, round(min(1, R[o]) * 255), round(min(1, Gc[o]) * 255), round(min(1, B[o]) * 255));\n}\n","indian-rope-trick":"// ===== Patternflow pattern =====\n// Title:   Indian Rope Trick\n// Family:  physics\n// Idea:    A chain of three rigid links stands upside down the full height of the panel on a pivot that buzzes up and down too fast and too little to see, and every few seconds a tap sets it swaying until the vibration brings it back to vertical; turn the shaking down past the threshold and the chain topples, swings down past the pivot and is lifted upright to topple again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: inverted pendulum stabilised by a vibrating pivot (Andrew Stephenson, 1908; Pyotr Kapitza, 1951), the Indian rope trick of an n-link inverted pendulum (David Acheson, 1993; David Acheson and Tom Mullin, Nature, 1993), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Shake=0..3, Links=3..6, Nudge=0..1\n//\n// Knob 1: Hue. Turns the links' colour round the wheel: brass at 0, green at 0.25, sky blue at 0.5, violet at 0.75 and brass again at 1, every other link a deeper shade (copper at 0); the joints stay white.\n// Knob 2: Shake. The pivot's peak speed A w in units of sqrt(g L), L the whole chain's height. Below about 1.25 nothing holds the chain up: it topples over the side, swings down past the pivot, lies there 1.3 s and is stood up again. From 1.3 every chain stands, at the opening 2 it rides out the taps, and shaken harder still six links shiver and fall again from about 2.15 and five from about 2.7, while three and four still stand at 3. At 2 the three links' pivot moves 0.74 LED each way, 66 times a second.\n// Knob 3: Links. Three links, the triple pendulum Acheson and Mullin stood on its head, then four, five and six, always 116 LEDs tall together. More links need a faster shake, so the drive runs at 60 n sqrt(g / l) for n links of length l: 66 Hz for three, 187 Hz for six.\n// Knob 4: Nudge. How hard the tap is, every 2.5 to 3.5 s at the top joint or another: at the opening 0.06 the top sways 7 to 17 LEDs, each swing about 0.6 of the one before, so the next tap usually finds it still moving; from about 0.5 most taps knock the chain over.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sin, cos, sqrt, exp, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The chain stands 116 LEDs tall on a pivot at row 121, centred.\nconst L_PX = 116, PX = 31.5, PY = 121;\n// sqrt(L / g) for the whole chain's height L, in panel seconds; the time a\n// chain that tall takes to start falling. The panel runs slower than a bench.\nconst TAU = 0.75;\n// Joint friction, per natural time of one link, and a drag on every bit of\n// the chain in proportion to its speed, per panel second.\nconst DAMP = 0.06, DRAG = 0.7;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = null;\n}\n\nfunction makeChain(n) {\n  const S = {\n    n,\n    l: L_PX / n,\n    th: new Float64Array(n), om: new Float64Array(n),\n    k: [0, 1, 2, 3].map(() => [new Float64Array(n), new Float64Array(n)]),\n    t1: new Float64Array(n), o1: new Float64Array(n),\n    M: new Float64Array(n * n), f: new Float64Array(n), sn: new Float64Array(n), cs: new Float64Array(n),\n    t: 0, // physics time, panel seconds\n  };\n  // A link of length l falls on the time scale sqrt(l / g).\n  const tau = TAU / sqrt(n);\n  S.G = 1 / (tau * tau); // g / l\n  S.w = (60 * n) / tau; // drive, rad per panel second\n  S.b = DAMP / tau;\n  return S;\n}\n\n// The equations of motion of n identical uniform rods hinged end to end, the\n// first on a pivot driven up and down as A cos(w t). Angles from the upward\n// vertical; in the pivot's frame gravity becomes g - A w^2 cos(w t). With\n// mass and length scaled out, for links i, j counted from the bottom,\n//   sum_j a_ij th_j'' = - sum_j c_ij sin(th_i - th_j) th_j'^2\n//                       + (g_eff / l)(n - i - 1/2) sin th_i + friction,\n// where a_ii = n - i - 2/3 (zero-based i), a_ij = c_ij cos(th_i - th_j) and\n// c_ij = n - max(i, j) - 1/2: the rods above i and half of the higher of the\n// two. The n by n system is solved for th'' at every evaluation.\nfunction accel(S, th, om, t, out) {\n  const { n, M, f, sn, cs } = S;\n  const geff = S.G - S.Al * S.w * S.w * cos(S.w * t);\n  for (let i = 0; i \u003c n; i++) {\n    sn[i] = sin(th[i]);\n    cs[i] = cos(th[i]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    let r = geff * (n - i - 0.5) * sn[i];\n    for (let j = 0; j \u003c n; j++) {\n      if (j === i) {\n        M[i * n + j] = n - i - 2 / 3;\n        continue;\n      }\n      const c = n - max(i, j) - 0.5;\n      M[i * n + j] = c * (cs[i] * cs[j] + sn[i] * sn[j]);\n      r -= c * (sn[i] * cs[j] - cs[i] * sn[j]) * om[j] * om[j];\n    }\n    r -= S.b * (om[i] - (i > 0 ? om[i - 1] : 0));\n    if (i + 1 \u003c n) r += S.b * (om[i + 1] - om[i]);\n    f[i] = r;\n  }\n  solve(n, M, f, out);\n  // A drag proportional to the mass matrix adds -DRAG th' to every link.\n  for (let i = 0; i \u003c n; i++) out[i] -= DRAG * om[i];\n}\n\n// Gaussian elimination; the matrix is symmetric positive definite, so no pivoting.\nfunction solve(n, M, f, out) {\n  for (let k = 0; k \u003c n; k++) {\n    const d = M[k * n + k];\n    for (let r = k + 1; r \u003c n; r++) {\n      const q = M[r * n + k] / d;\n      if (!q) continue;\n      for (let c = k; c \u003c n; c++) M[r * n + c] -= q * M[k * n + c];\n      f[r] -= q * f[k];\n    }\n  }\n  for (let k = n - 1; k >= 0; k--) {\n    let s = f[k];\n    for (let c = k + 1; c \u003c n; c++) s -= M[k * n + c] * out[c];\n    out[k] = s / M[k * n + k];\n  }\n}\n\n// One classical Runge-Kutta step.\nfunction rk4(S, dt) {\n  const { n, th, om, k, t1, o1 } = S;\n  const hs = [0, 0.5, 0.5, 1];\n  for (let s = 0; s \u003c 4; s++) {\n    const h = hs[s] * dt, src = k[s ? s - 1 : 0];\n    for (let i = 0; i \u003c n; i++) {\n      t1[i] = th[i] + (s ? h * src[0][i] : 0);\n      o1[i] = om[i] + (s ? h * src[1][i] : 0);\n    }\n    k[s][0].set(o1);\n    accel(S, t1, o1, S.t + h, k[s][1]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    th[i] += (dt / 6) * (k[0][0][i] + 2 * k[1][0][i] + 2 * k[2][0][i] + k[3][0][i]);\n    om[i] += (dt / 6) * (k[0][1][i] + 2 * k[1][1][i] + 2 * k[2][1][i] + k[3][1][i]);\n  }\n  S.t += dt;\n}\n\n// A tap: a sideways impulse J at the top of link s, passed as P = J / (m l).\n// Its generalised impulse is J l cos th_i on every link up to s, and the kick\n// in angular velocity is the scaled mass matrix's inverse applied to P cos th_i.\nfunction tap(S, s, P) {\n  const { n, M, f, th, om } = S;\n  for (let i = 0; i \u003c n; i++) {\n    for (let j = 0; j \u003c n; j++) M[i * n + j] = i === j ? n - i - 2 / 3 : (n - max(i, j) - 0.5) * cos(th[i] - th[j]);\n    f[i] = i \u003c= s ? P * cos(th[i]) : 0;\n  }\n  const d = new Float64Array(n);\n  solve(n, M, f, d);\n  for (let i = 0; i \u003c n; i++) om[i] += d[i];\n}\n\n// Joint positions in LEDs for the chain's angles and the pivot's height.\nfunction joints(S, th, lift, out) {\n  let x = PX, y = PY - lift;\n  out[0] = x;\n  out[1] = y;\n  for (let i = 0; i \u003c S.n; i++) {\n    x += S.l * sin(th[i]);\n    y -= S.l * cos(th[i]);\n    out[2 * i + 2] = x;\n    out[2 * i + 3] = y;\n  }\n}\n\nconst wrap = (a) => a - 2 * PI * round(a / (2 * PI));\n\nexport function update(dt, input, params) {\n  const P = params;\n  const kv = input.knobValues || [0, 2, 3, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  P.hue = kv[0] || 0;\n  const shake = cl(kv[1], 0, 3);\n  const n = round(cl(kv[2], 3, 6));\n  P.nudge = cl(kv[3], 0, 1);\n  if (!P.s || P.s.n !== n) {\n    const old = P.s;\n    P.s = makeChain(n);\n    P.R = new Float32Array(N);\n    P.Gc = new Float32Array(N);\n    P.B = new Float32Array(N);\n    P.ghost = new Float32Array(N * 3);\n    P.pos = new Float64Array(2 * n + 2);\n    P.blur = [];\n    P.mode = \"stand\";\n    P.timer = 0;\n    P.nextTap = old ? 1.2 : 0.9;\n    P.s.th[n - 1] = 0.01;\n    P.time = old ? P.time : 0;\n  }\n  const S = P.s;\n  P.time += dt;\n  // The pivot's amplitude as a share of a link: A w = shake sqrt(g L) and\n  // sqrt(g L) = sqrt(n) l / tau for links of length l.\n  S.Al = (shake * sqrt(S.n) * sqrt(S.G)) / S.w;\n  P.ampPx = S.Al * S.l;\n  // Taps every 2.5 to 3.5 s, at the top joint twice as often as any other.\n  if (P.mode === \"stand\") {\n    P.nextTap -= dt;\n    if (P.nextTap \u003c= 0) {\n      P.nextTap = 2.5 + Math.random();\n      const s = Math.random() \u003c 0.5 ? S.n - 1 : floor(Math.random() * S.n);\n      const side = Math.random() \u003c 0.5 ? -1 : 1;\n      // The impulse in units of m sqrt(g l), m and l one link's mass and length.\n      const imp = side * (0.16 + 0.5 * P.nudge + 2.6 * P.nudge * P.nudge) * sqrt(S.n);\n      tap(S, s, imp * sqrt(S.G));\n      joints(S, S.th, 0, P.pos);\n      P.flash = { x: P.pos[2 * s + 2], y: P.pos[2 * s + 3], side, life: 1 };\n    }\n  }\n  if (P.flash) P.flash.life -= dt * 3;\n  // Steps of about 0.25 radian of the drive; four snapshots a frame for blur.\n  const steps = max(4, Math.ceil((dt * S.w) / 0.25));\n  const h = dt / steps;\n  P.blur.length = 0;\n  for (let i = 1; i \u003c= steps; i++) {\n    if (P.mode !== \"lift\") rk4(S, h);\n    else S.t += h;\n    if (i % Math.ceil(steps / 4) === 0 || i === steps) {\n      const out = new Float64Array(2 * S.n + 2);\n      joints(S, S.th, P.ampPx * cos(S.w * S.t), out);\n      P.blur.push(out);\n    }\n  }\n  // Fallen: the top has dropped below 60 percent of the chain's height, or a\n  // link lies past horizontal. After 1.3 s fallen it is lifted back upright\n  // over 0.9 s, every link easing to a small lean.\n  joints(S, S.th, 0, P.pos);\n  const topH = PY - P.pos[2 * S.n + 1];\n  let worst = 0;\n  for (let i = 0; i \u003c S.n; i++) worst = max(worst, abs(wrap(S.th[i])));\n  if (P.mode === \"stand\" && (topH \u003c 0.6 * L_PX || worst > 1.7)) {\n    P.mode = \"fallen\";\n    P.timer = 0;\n  } else if (P.mode === \"fallen\") {\n    P.timer += dt;\n    if (P.timer > 1.3) {\n      P.mode = \"lift\";\n      P.timer = 0;\n      P.from = Array.from(S.th, wrap);\n      P.to = P.from.map((a, i) => (i === S.n - 1 ? 0.02 * Math.sign(a || 1) : 0));\n    }\n  } else if (P.mode === \"lift\") {\n    P.timer += dt / 0.9;\n    const u = min(1, P.timer), e = u * u * (3 - 2 * u);\n    for (let i = 0; i \u003c S.n; i++) {\n      S.th[i] = P.from[i] + (P.to[i] - P.from[i]) * e;\n      S.om[i] = 0;\n    }\n    if (u >= 1) {\n      P.mode = \"stand\";\n      P.nextTap = 2.5;\n    }\n  }\n}\n\n// Additive light: a soft disc or a segment's capsule.\nfunction stamp(P, x, y, r, v, c) {\n  const x0 = max(0, floor(x - r - 1)), x1 = min(W - 1, Math.ceil(x + r + 1));\n  const y0 = max(0, floor(y - r - 1)), y1 = min(H - 1, Math.ceil(y + r + 1));\n  for (let Y = y0; Y \u003c= y1; Y++)\n    for (let X = x0; X \u003c= x1; X++) {\n      const d = Math.hypot(X - x, Y - y);\n      const a = cl(r + 0.5 - d, 0, 1) * v;\n      if (a \u003c= 0) continue;\n      const p = Y * W + X;\n      P.R[p] += a * c[0];\n      P.Gc[p] += a * c[1];\n      P.B[p] += a * c[2];\n    }\n}\n\n// A rod's cross-section by squared distance from its axis, in eighths of an\n// LED squared: a core about 3 LEDs thick and a soft glow either side.\nconst PROF = new Float32Array(201);\nfor (let k = 0; k \u003c= 200; k++) {\n  const d2 = k / 8;\n  PROF[k] = cl(1.85 - sqrt(d2), 0, 1) + 0.35 * exp(-d2 / 4) + 0.15 * exp(-d2 / 16);\n}\n\nfunction rod(P, ax, ay, bx, by, v, c) {\n  const dx = bx - ax, dy = by - ay, len2 = dx * dx + dy * dy || 1;\n  const pad = 5;\n  const x0 = max(0, floor(min(ax, bx) - pad)), x1 = min(W - 1, Math.ceil(max(ax, bx) + pad));\n  const y0 = max(0, floor(min(ay, by) - pad)), y1 = min(H - 1, Math.ceil(max(ay, by) + pad));\n  for (let Y = y0; Y \u003c= y1; Y++)\n    for (let X = x0; X \u003c= x1; X++) {\n      const u = cl(((X - ax) * dx + (Y - ay) * dy) / len2, 0, 1);\n      const ex = X - ax - u * dx, ey = Y - ay - u * dy;\n      const k = ((ex * ex + ey * ey) * 8 + 0.5) | 0;\n      if (k > 200) continue;\n      const a = PROF[k] * v, p = Y * W + X;\n      P.R[p] += a * c[0];\n      P.Gc[p] += a * c[1];\n      P.B[p] += a * c[2];\n    }\n}\n\nexport function draw(display, params) {\n  const P = params;\n  const S = P.s;\n  if (!S) return;\n  const { R, Gc, B, ghost } = P;\n  R.fill(0);\n  Gc.fill(0);\n  B.fill(0);\n  const col = [0, 0, 0];\n  // Brass at Hue 0.\n  hsv(P.hue + 0.11, 0.62, 1, col);\n  const deep = [0, 0, 0];\n  hsv(P.hue + 0.06, 0.8, 0.88, deep);\n  const n = S.n;\n  // The plumb line the chain should stand on, dotted.\n  for (let y = PY - L_PX; y \u003c PY; y += 3) stamp(P, PX, y, 0.3, 0.16, [0.6, 0.7, 0.9]);\n  // The chain at four moments of the frame, so the shake and the sway blur.\n  const wgt = 1 / P.blur.length;\n  for (const J of P.blur) {\n    for (let i = 0; i \u003c n; i++) {\n      // Links alternate bright and deeper brass, so each reads as its own rod.\n      const c = i & 1 ? deep : col;\n      rod(P, J[2 * i], J[2 * i + 1], J[2 * i + 2], J[2 * i + 3], wgt * (i & 1 ? 0.8 : 1), c);\n    }\n    for (let i = 0; i \u003c= n; i++) stamp(P, J[2 * i], J[2 * i + 1], i === 0 ? 2.1 : 1.8, wgt * 1.1, [1, 0.96, 0.9]);\n  }\n  // The tap: a white spark at the struck joint, thrown out on the side it came from.\n  if (P.flash && P.flash.life > 0) {\n    const f = P.flash;\n    for (let k = 0; k \u003c 4; k++) stamp(P, f.x - f.side * (2 + 2.2 * k * (1 - f.life)), f.y, 1.2 - 0.2 * k, f.life * 0.8, [1, 1, 1]);\n  }\n  // The shaker under the pivot: a block whose top plate rides with the pivot,\n  // drawn where it is this frame.\n  const lift = P.ampPx * cos(S.w * S.t);\n  const top = PY + 2 - lift;\n  for (let y = floor(top); y \u003c H; y++)\n    for (let x = 18; x \u003c 46; x++) {\n      const cover = cl(y + 1 - top, 0, 1);\n      const p = y * W + x;\n      const plate = y - top \u003c 2;\n      const edge = x === 18 || x === 45;\n      const v = cover * (plate ? 0.62 : edge ? 0.3 : 0.17);\n      R[p] += v * 0.75;\n      Gc[p] += v * 0.82;\n      B[p] += v * 0.95;\n    }\n  // The coil's hum: a glow in the block, brighter for a harder shake.\n  const hum = min(1, P.ampPx * 0.9) * (0.75 + 0.25 * sin(P.time * 40));\n  for (let x = 24; x \u003c 40; x++) stamp(P, x, 125.5, 0.6, 0.18 * hum, [1, 0.25, 0.5]);\n  // A short afterglow, so a fast swing leaves a fan behind it.\n  const keep = exp(-1 / 30 / 0.3);\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    ghost[q] = max(ghost[q] * keep, R[p] * 0.55);\n    ghost[q + 1] = max(ghost[q + 1] * keep, Gc[p] * 0.55);\n    ghost[q + 2] = max(ghost[q + 2] * keep, B[p] * 0.55);\n    const r = max(R[p], ghost[q]), g = max(Gc[p], ghost[q + 1]), b = max(B[p], ghost[q + 2]);\n    display.setPixel(p % W, (p / W) | 0, round(min(1, r) * 255), round(min(1, g) * 255), round(min(1, b) * 255));\n  }\n}\n","kibble-zurek-ions":"// ===== Patternflow pattern =====\n// Title:   Kibble-Zurek Ions\n// Family:  particle\n// Idea:    A chain of 30 to 40 ions standing the height of the panel buckles into a zigzag each time its transverse trap is lowered past the critical value, the quench freezes in kinks where the two orientations of the zigzag meet, and the chain prints its history outward on both sides, one rib per ion every quarter second, magenta and green for the two orientations with yellow seams where the kinks run.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kibble-Zurek mechanism (Tom Kibble, 1976; Wojciech Zurek, 1985), the linear-zigzag transition of ion chains (Shmuel Fishman, Gabriele De Chiara, Tommaso Calarco and Giovanna Morigi, 2008), kinks quenched into ion crystals (Karsten Pyka and others, 2013; Stefan Ulm and others, 2013), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Quench=0.2..3, Ions=30..40, Heat=0..1\n//\n// Knob 1: Hue. Turns the four colours round the wheel together. At 0 the two orientations of the zigzag are magenta and green, the straight chain blue and the kinks yellow; at 0.25 the orientations are orange and azure on a rose chain; at 0.5 magenta and green trade places and the straight chain turns yellow.\n// Knob 2: Quench. How fast the transverse trap frequency falls from 1.3 to 0.42 times its critical value: in 10 s at 0.2, 3.2 s at 1, 0.78 s at 2 and 0.19 s at 3. Over 60 quenches of 30 ions, counted 1.2 s into the hold, that freezes in 0.15 kinks at 0.2, 0.73 at 1, 1.9 at 2 and 2.1 at 3; during the 4 s hold about half of them slide out at the ends.\n// Knob 3: Ions. 30 to 40 ions, the axial trap set so a straight chain of any count reaches from row 5 to row 122. Thirty ions sit 3.3 rows apart in the middle and 6.5 at the ends and buckle when the transverse frequency drops below 12.0 times the axial one; forty sit 2.4 rows apart, buckle below 15.5 times and have room for more kinks, 3.1 a quench at Quench 3.\n// Knob 4: Heat. The temperature of the random kicks that stand for the cooling laser's photon recoil. At 0.06 they only decide which way each stretch of the chain buckles; at 0.5 the zigzag shivers and the kinks drift; toward 1 kinks and antikinks pop up in pairs and the history breaks into short domains.\n\nconst W = 64, H = 128, CX = 31.5, CY = 63.5;\nconst { floor, min, max, abs, sqrt, exp, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: lengths in LEDs, time in 1 / omega_z, the axial trap frequency, so\n// the axial force is -y. The Coulomb constant K is set per ion count so the\n// linear chain reaches HALF rows each way from the middle.\nconst HALF = 58;\n// The transverse trap frequency as a fraction of its critical value: RHI\n// holds the chain straight, RLO is the bottom of the quench. At RLO all but\n// the two end ions on each side buckle, 2.9 LEDs off the axis for 30 ions.\nconst RHI = 1.3, RLO = 0.42;\nconst DT = 0.004, GAMMA = 2, RATE = 1;\n// The transverse axis is drawn XS times wider than the axial one, so the\n// zigzag of 30 ions spans 12 columns.\nconst XS = 2;\n// History: KW columns each side of the chain, one every KT seconds.\nconst KW = 19, KT = 0.25;\n// Phases of the cycle in seconds: straight hold, quench (from the knob),\n// zigzag hold, release.\nconst T_LIN = 1, T_HOLD = 4, T_UP = 1;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The straight chain of n ions for Coulomb constant 1, by Newton's method,\n// then scaled to HALF; and the critical transverse stiffness, the largest\n// eigenvalue of the transverse Coulomb matrix (its zigzag mode).\nfunction chainFor(n) {\n  const z = new Float64Array(n);\n  for (let i = 0; i \u003c n; i++) z[i] = (i - (n - 1) / 2) * 0.9;\n  const J = new Float64Array(n * n), f = new Float64Array(n);\n  for (let it = 0; it \u003c 60; it++) {\n    J.fill(0);\n    let err = 0;\n    for (let i = 0; i \u003c n; i++) {\n      let fi = -z[i], dii = -1;\n      for (let j = 0; j \u003c n; j++) {\n        if (j === i) continue;\n        const d = z[i] - z[j], ad = abs(d);\n        fi += (d > 0 ? 1 : -1) / (d * d);\n        const c = 2 / (ad * ad * ad);\n        dii -= c;\n        J[i * n + j] = c;\n      }\n      J[i * n + i] = dii;\n      f[i] = -fi;\n      err = max(err, abs(fi));\n    }\n    if (err \u003c 1e-10) break;\n    // Gaussian elimination on J dz = -f.\n    for (let c = 0; c \u003c n; c++) {\n      const p = J[c * n + c];\n      for (let r = c + 1; r \u003c n; r++) {\n        const m = J[r * n + c] / p;\n        if (!m) continue;\n        for (let k = c; k \u003c n; k++) J[r * n + k] -= m * J[c * n + k];\n        f[r] -= m * f[c];\n      }\n    }\n    let lim = 1;\n    for (let r = n - 1; r >= 0; r--) {\n      let s = f[r];\n      for (let k = r + 1; k \u003c n; k++) s -= J[r * n + k] * f[k];\n      f[r] = s / J[r * n + r];\n    }\n    for (let i = 1; i \u003c n; i++) {\n      const gap = z[i] - z[i - 1], close = f[i - 1] - f[i];\n      if (close > 0.5 * gap) lim = min(lim, (0.5 * gap) / close);\n    }\n    for (let i = 0; i \u003c n; i++) z[i] += lim * f[i];\n  }\n  const s = HALF / z[n - 1], K = s * s * s;\n  for (let i = 0; i \u003c n; i++) z[i] *= s;\n  const M = new Float64Array(n * n);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) {\n      if (i === j) continue;\n      const d = abs(z[i] - z[j]), c = K / (d * d * d);\n      M[i * n + i] += c;\n      M[i * n + j] -= c;\n    }\n  let v = new Float64Array(n), u = new Float64Array(n), lam = 0;\n  for (let i = 0; i \u003c n; i++) v[i] = i % 2 ? 1 : -1;\n  for (let it = 0; it \u003c 400; it++) {\n    let nn = 0;\n    for (let i = 0; i \u003c n; i++) {\n      let a = 0;\n      for (let j = 0; j \u003c n; j++) a += M[i * n + j] * v[j];\n      u[i] = a;\n      nn += a * a;\n    }\n    lam = sqrt(nn);\n    for (let i = 0; i \u003c n; i++) v[i] = u[i] / lam;\n  }\n  return { n, K, z, kxc: lam };\n}\n\nexport function setup(params) {\n  params.s = {\n    chains: {}, c: null, n: 0,\n    x: new Float64Array(40), y: new Float64Array(40), vx: new Float64Array(40), vy: new Float64Array(40),\n    fx: new Float64Array(40), fy: new Float64Array(40), rank: new Int32Array(40), phi: new Float64Array(40),\n    hy: new Float32Array(KW * 40), hp: new Float32Array(KW * 40), hn: new Uint8Array(KW), head: 0, kt: 0,\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3), ck: new Float32Array(3),\n    phase: 0, pt: 0, r: RHI, tq: 1, temp: 0.002, hue: 0, kinks: [], started: false,\n  };\n  return params.s;\n}\n\nfunction load(S, n) {\n  if (!S.chains[n]) S.chains[n] = chainFor(n);\n  const c = (S.c = S.chains[n]);\n  S.n = n;\n  for (let i = 0; i \u003c n; i++) {\n    S.x[i] = 0;\n    S.y[i] = c.z[i];\n    S.vx[i] = S.vy[i] = 0;\n    S.rank[i] = i;\n  }\n  S.phase = 0;\n  S.pt = 0;\n  S.r = RHI;\n}\n\nfunction gauss() {\n  return (Math.random() + Math.random() + Math.random() - 1.5) * 2;\n}\n\nfunction step(S, h) {\n  const n = S.n, x = S.x, y = S.y, vx = S.vx, vy = S.vy, fx = S.fx, fy = S.fy, K = S.c.K;\n  const kx = S.c.kxc * S.r * S.r;\n  for (let i = 0; i \u003c n; i++) {\n    fx[i] = -kx * x[i];\n    fy[i] = -y[i];\n  }\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = x[i] - x[j], dy = y[i] - y[j], r2 = dx * dx + dy * dy, inv = K / (r2 * sqrt(r2));\n      fx[i] += dx * inv;\n      fy[i] += dy * inv;\n      fx[j] -= dx * inv;\n      fy[j] -= dy * inv;\n    }\n  const kick = sqrt(2 * GAMMA * S.temp * h), g = 1 - GAMMA * h;\n  for (let i = 0; i \u003c n; i++) {\n    vx[i] = (vx[i] + fx[i] * h) * g + kick * gauss();\n    vy[i] = (vy[i] + fy[i] * h) * g + kick * gauss();\n    x[i] += vx[i] * h;\n    y[i] += vy[i] * h;\n  }\n}\n\n// Order the ions along the axis and read the zigzag order parameter of\n// each, its sideways offset with the sign flipped on every other ion.\nfunction order(S) {\n  const n = S.n, rank = S.rank, y = S.y;\n  for (let a = 1; a \u003c n; a++) {\n    const v = rank[a];\n    let b = a - 1;\n    while (b >= 0 && y[rank[b]] > y[v]) {\n      rank[b + 1] = rank[b];\n      b--;\n    }\n    rank[b + 1] = v;\n  }\n  for (let a = 0; a \u003c n; a++) S.phi[a] = (a % 2 ? 1 : -1) * S.x[rank[a]];\n}\n\n// A kink sits between two neighbours that have both buckled, more than\n// BUCKLED LEDs off the axis, with opposite signs of the order parameter.\nconst BUCKLED = 0.35;\nfunction kinks(S) {\n  const rank = S.rank, phi = S.phi;\n  S.kinks.length = 0;\n  for (let a = 0; a + 1 \u003c S.n; a++) {\n    const pa = phi[a], pb = phi[a + 1];\n    if (pa * pb \u003c 0 && abs(pa) > BUCKLED && abs(pb) > BUCKLED) {\n      const ya = S.y[rank[a]], yb = S.y[rank[a + 1]];\n      S.kinks.push(CY + ya + ((yb - ya) * abs(pa)) / (abs(pa) + abs(pb)));\n    }\n  }\n}\n\nfunction advance(S, d) {\n  // The cycle: straight, quench, zigzag, release.\n  S.pt += d;\n  if (S.phase === 0 && S.pt >= T_LIN) (S.phase = 1), (S.pt = 0);\n  if (S.phase === 1 && S.pt >= S.tq) (S.phase = 2), (S.pt = 0);\n  if (S.phase === 2 && S.pt >= T_HOLD) (S.phase = 3), (S.pt = 0);\n  if (S.phase === 3 && S.pt >= T_UP) (S.phase = 0), (S.pt = 0);\n  S.r = S.phase === 0 ? RHI : S.phase === 1 ? RHI + ((RLO - RHI) * S.pt) / S.tq : S.phase === 2 ? RLO : RLO + ((RHI - RLO) * S.pt) / T_UP;\n  const steps = max(1, round((d * RATE) / DT)), h = (d * RATE) / steps;\n  for (let k = 0; k \u003c steps; k++) step(S, h);\n  order(S);\n  kinks(S);\n  S.kt += d;\n  if (S.kt >= KT) {\n    S.kt -= KT;\n    S.head = (S.head + 1) % KW;\n    const b = S.head * 40;\n    S.hn[S.head] = S.n;\n    for (let a = 0; a \u003c S.n; a++) {\n      S.hy[b + a] = S.y[S.rank[a]] + CY;\n      S.hp[b + a] = S.phi[a];\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 30, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const q = cl(kv[1], 0.2, 3);\n  S.tq = 10 * 30 ** (-(q - 0.2) / 2.4);\n  const n = cl(round(kv[2]), 30, 40);\n  const heat = cl(kv[3], 0, 1);\n  S.temp = 0.002 + 3 * heat * heat * heat;\n  if (n !== S.n) load(S, n);\n  if (!S.started) {\n    // Run quenches until one has frozen in a kink (four at most), and open\n    // 1.2 s into its hold, with the history beside it already full.\n    S.started = true;\n    for (let tries = 0, f = 0; f \u003c 3000; f++) {\n      advance(S, 1 / 30);\n      if (S.phase === 2 && S.pt >= 1.2 && S.pt \u003c 1.2 + 1 / 30) {\n        if (S.kinks.length || ++tries >= 4) break;\n      }\n    }\n  }\n  advance(S, d);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.c) return;\n  const rgb = S.rgb, c = S.c, ck = S.ck;\n  rgb.fill(0);\n  hsv(0.1667 + S.hue, 1, 1, ck);\n  // History: the newest column touches the chain's zone and older ones move\n  // out. Each ion leaves a rib in its colour, one row high while it is on\n  // the axis and two once it has buckled, from blue through violet to\n  // magenta or through cyan to green; yellow fills the gap at a kink.\n  const inner = 12;\n  for (let k = 0; k \u003c KW; k++) {\n    const col = ((S.head - k) % KW + KW) % KW, b = col * 40, n = S.hn[col];\n    const xl = floor(CX) - inner - k, xr = Math.ceil(CX) + inner + k;\n    let prevY = -9, prevP = 0;\n    for (let a = 0; a \u003c n; a++) {\n      const p = S.hp[b + a], Y = floor(S.hy[b + a]);\n      const s = cl((abs(p) - 0.25) / 0.3, 0, 1);\n      hsv(S.hue + 0.6667 + (p > 0 ? 0.1667 : -0.3333) * s, 1, 1, c);\n      const r = c[0], g = c[1], bl = c[2];\n      for (let y = Y; y \u003c= Y + (s > 0.5 ? 1 : 0); y++) {\n        if (y \u003c 0 || y >= H) continue;\n        for (const X of [xl, xr]) {\n          if (X \u003c 0 || X >= W) continue;\n          const i = (y * W + X) * 3;\n          rgb[i] = r;\n          rgb[i + 1] = g;\n          rgb[i + 2] = bl;\n        }\n      }\n      if (p * prevP \u003c 0 && abs(p) > BUCKLED && abs(prevP) > BUCKLED)\n        for (let y = prevY + 2; y \u003c Y; y++) {\n          if (y \u003c 0 || y >= H) continue;\n          for (const X of [xl, xr]) {\n            if (X \u003c 0 || X >= W) continue;\n            const i = (y * W + X) * 3;\n            rgb[i] = ck[0];\n            rgb[i + 1] = ck[1];\n            rgb[i + 2] = ck[2];\n          }\n        }\n      prevY = Y;\n      prevP = p;\n    }\n  }\n  // Kink ticks beside the chain.\n  for (const yk of S.kinks) {\n    const Y = round(yk);\n    if (Y \u003c 0 || Y >= H) continue;\n    for (let X = floor(CX) - inner + 2; X \u003c= Math.ceil(CX) + inner - 2; X++) {\n      if (abs(X - CX) \u003c 8) continue;\n      const i = (Y * W + X) * 3;\n      rgb[i] = ck[0];\n      rgb[i + 1] = ck[1];\n      rgb[i + 2] = ck[2];\n    }\n  }\n  // Ions: a disc in their colour, with a pale core.\n  for (let a = 0; a \u003c S.n; a++) {\n    const i = S.rank[a], p = S.phi[a];\n    const px = CX + XS * S.x[i], py = CY + S.y[i];\n    const s = cl((abs(p) - 0.25) / 0.3, 0, 1);\n    hsv(S.hue + 0.6667 + (p > 0 ? 0.1667 : -0.3333) * s, 1, 1, c);\n    const hr = c[0], hg = c[1], hb = c[2];\n    for (let Y = max(0, floor(py - 3)); Y \u003c= min(H - 1, Math.ceil(py + 3)); Y++)\n      for (let X = max(0, floor(px - 3)); X \u003c= min(W - 1, Math.ceil(px + 3)); X++) {\n        const e2 = (X - px) * (X - px) + (Y - py) * (Y - py);\n        const halo = cl((exp(-((e2 / 5) ** 3)) - 0.25) / 0.5, 0, 1), core = exp(-e2 / 0.6);\n        if (halo \u003c= 0) continue;\n        const o = (Y * W + X) * 3;\n        rgb[o] = max(rgb[o], hr * halo + (255 - hr) * core * 0.8);\n        rgb[o + 1] = max(rgb[o + 1], hg * halo + (255 - hg) * core * 0.8);\n        rgb[o + 2] = max(rgb[o + 2], hb * halo + (255 - hb) * core * 0.8);\n      }\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = (Y * W + X) * 3;\n      display.setPixel(X, Y, min(255, rgb[o]) | 0, min(255, rgb[o + 1]) | 0, min(255, rgb[o + 2]) | 0);\n    }\n}\n","letter-sand":"// ===== Patternflow pattern =====\n// Title:   Letter Sand\n// Family:  type\n// Idea:    A word of four wide bold letters stacked down the panel is made of grains of sand: it stands, crumbles from the bottom letter up with each letter running out from its foot, and the grains fall and slide into a pile whose layers keep the letters' colours in order, until a stream of sand rises from a pit in the pile and builds the next word of the sediment cycle, ROCK, SAND, DUNE, DUST, SILT, LOAM, from each letter's foot up.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after falling-sand games and bottles of layered craft sand\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Grain=1..3, Wind=-1..1\n//\n// Knob 1: Hue. Turns the four sand colours round the wheel together. At 0 the letters from the top are gold, rose, turquoise and violet, like a bottle of craft sand; at 0.25 green, lime, indigo and red; at 0.5 blue, aqua, rose and lime.\n// Knob 2: Speed. Everything at once. At 2 a grain in the air falls up to 75 LEDs a second and a word takes about 10.6 s, 2.4 s standing, 4.7 s crumbling and 2.9 to 3.8 s rising again, so the six words come round in 64 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Grain. The size of a grain: one LED at 1, where SAND is 1,262 grains, a 2 by 2 block at 2 (394 grains) and a 3 by 3 block at 3 (204). The letters stay about 36 LEDs wide and 20 tall; a new size rebuilds the sand around the word that stands.\n// Knob 4: Wind. Blows across the falling grains and leans the rising stream. At 0.06 a breath: the stream barely leans and now and then a grain on the pile rolls one cell to the right. At 1 or -1 every other step of a falling grain is a step sideways, so the sand pours at 27 degrees, the pile creeps against one wall and the stream bows over.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, sqrt } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The sediment cycle, one word a turn: rock weathers to sand, wind heaps it\n// into a dune and lifts the finest as dust, water carries silt, and silt\n// settles into loam.\nconst WORDS = [\"ROCK\", \"SAND\", \"DUNE\", \"DUST\", \"SILT\", \"LOAM\"];\n\n// A wide bold face drawn as stroke centre lines on a 4 by 4 grid, y down.\n// Straight strokes have square ends; the short diagonals cut the corners.\nconst C = 0.9, D = 4 - C;\nconst GLYPH = {\n  A: [[0, 4, 0, C, C, 0, D, 0, 4, C, 4, 4], [0, 2.2, 4, 2.2]],\n  C: [[4, 0, C, 0, 0, C, 0, D, C, 4, 4, 4]],\n  D: [[0, 0, D, 0, 4, C, 4, D, D, 4, 0, 4, 0, 0]],\n  E: [[4, 0, 0, 0, 0, 4, 4, 4], [0, 2, 3.2, 2]],\n  I: [[1, 0, 3, 0], [2, 0, 2, 4], [1, 4, 3, 4]],\n  K: [[0, 0, 0, 4], [0, 2, 1.6, 2, 4, 0], [1.6, 2, 4, 4]],\n  L: [[0, 0, 0, 4, 4, 4]],\n  M: [[0, 4, 0, 0, 2, 2.2, 4, 0, 4, 4]],\n  N: [[0, 4, 0, 0, 4, 4, 4, 0]],\n  O: [[C, 0, D, 0, 4, C, 4, D, D, 4, C, 4, 0, D, 0, C, C, 0]],\n  R: [[0, 4, 0, 0, D, 0, 4, C, 4, 2 - C, D, 2, 0, 2], [2, 2, 4, 4]],\n  S: [[4, 0, C, 0, 0, C, 0, 2 - C, C, 2, D, 2, 4, 2 + C, 4, D, D, 4, 0, 4]],\n  T: [[0, 0, 4, 0], [2, 0, 2, 4]],\n  U: [[0, 0, 0, D, C, 4, D, 4, 4, D, 4, 0]],\n};\n// For each grain size, in cells: letter width and height, stroke width of\n// the uprights and of the bars, the gap between letters and the top margin.\nconst LAYOUT = [\n  null,\n  { lw: 36, lh: 19, sx: 5, sy: 3, gap: 3, top: 3 },\n  { lw: 18, lh: 10, sx: 3, sy: 2, gap: 2, top: 2 },\n  { lw: 12, lh: 7, sx: 3, sy: 1, gap: 1, top: 1 },\n];\n// Slot colours, top letter first: gold, rose, turquoise, violet, as in a\n// bottle of layered craft sand.\nconst HUES = [0.12, 0.96, 0.48, 0.74];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The cells of one letter, relative to its box.\nfunction raster(ch, L) {\n  const { lw, lh, sx, sy } = L, hx = sx / 2, hy = sy / 2;\n  const mx = (x) => (sx - 1) / 2 + (x / 4) * (lw - sx), my = (y) => (sy - 1) / 2 + (y / 4) * (lh - sy);\n  const segs = [];\n  for (const pl of GLYPH[ch]) for (let i = 0; i + 3 \u003c pl.length; i += 2) segs.push([mx(pl[i]), my(pl[i + 1]), mx(pl[i + 2]), my(pl[i + 3])]);\n  const out = [];\n  for (let Y = 0; Y \u003c lh; Y++)\n    for (let X = 0; X \u003c lw; X++)\n      for (const [ax, ay, bx, by] of segs) {\n        let d;\n        if (abs(ay - by) \u003c 1e-6) d = max(max(0, min(ax, bx) - X, X - max(ax, bx)) / hx, abs(Y - ay) / hy);\n        else if (abs(ax - bx) \u003c 1e-6) d = max(max(0, min(ay, by) - Y, Y - max(ay, by)) / hy, abs(X - ax) / hx);\n        else {\n          const ux = (X - ax) / hx, uy = (Y - ay) / hy, vx = (bx - ax) / hx, vy = (by - ay) / hy;\n          const t = cl((ux * vx + uy * vy) / (vx * vx + vy * vy), 0, 1);\n          d = sqrt((ux - t * vx) ** 2 + (uy - t * vy) ** 2);\n        }\n        if (d \u003c 1) {\n          out.push(X, Y);\n          break;\n        }\n      }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = { g: 0, trail: new Float32Array(W * H * 3), pal: new Float32Array(12), tmp: new Float32Array(3) };\n  return params.s;\n}\n\n// Build the grid for grain size g, with word w standing and the rest of the\n// sand lying on the floor in old layers.\nfunction build(S, g, w) {\n  const L = LAYOUT[g];\n  const cw = floor(W / g), ch = floor(H / g);\n  S.g = g;\n  S.L = L;\n  S.cw = cw;\n  S.ch = ch;\n  S.ox = floor((W - cw * g) / 2);\n  S.oy = H - ch * g;\n  // Target cells of every word, top letter first.\n  S.targets = WORDS.map((word) => {\n    const cells = [];\n    const x0 = floor((cw - L.lw) / 2);\n    for (let k = 0; k \u003c 4; k++) {\n      const r = raster(word[k], L), y0 = L.top + k * (L.lh + L.gap);\n      for (let i = 0; i \u003c r.length; i += 2) cells.push(x0 + r[i], y0 + r[i + 1], k);\n    }\n    return cells;\n  });\n  let most = 0;\n  for (const t of S.targets) most = max(most, t.length / 3);\n  const T = (S.T = most + (5 - g) * cw);\n  S.grid = new Int32Array(cw * ch);\n  S.x = new Float32Array(T);\n  S.y = new Float32Array(T);\n  S.st = new Uint8Array(T); // 0 loose sand, 1 held in a letter, 2 in flight\n  S.col = new Uint8Array(T); // slot colour 0..3\n  S.from = new Uint8Array(T);\n  S.shade = new Float32Array(T);\n  S.rel = new Float32Array(T);\n  S.fx0 = new Float32Array(T);\n  S.fy0 = new Float32Array(T);\n  S.fcx = new Float32Array(T);\n  S.fcy = new Float32Array(T);\n  S.fdx = new Float32Array(T);\n  S.fdy = new Float32Array(T);\n  S.ft = new Float32Array(T);\n  S.fdur = new Float32Array(T);\n  S.slot = new Int32Array(T);\n  S.stamp = new Int32Array(T);\n  S.step = 0;\n  for (let i = 0; i \u003c T; i++) S.shade[i] = 0.72 + 0.28 * Math.random();\n  // The word.\n  const tg = S.targets[w];\n  let i = 0;\n  for (let j = 0; j \u003c tg.length; j += 3, i++) put(S, i, tg[j], tg[j + 1], 1, tg[j + 2]);\n  // The rest on the floor, in bands of the four colours, bottom up.\n  for (let y = ch - 1; i \u003c T; y--)\n    for (let x = 0; x \u003c cw && i \u003c T; x++, i++) put(S, i, x, y, 0, (floor((ch - 1 - y) / 2) + 3) % 4);\n  S.word = w;\n  S.phase = 0;\n  S.pt = 0;\n  S.flying = 0;\n}\n\nfunction put(S, i, x, y, st, col) {\n  S.x[i] = x;\n  S.y[i] = y;\n  S.st[i] = st;\n  S.col[i] = col;\n  S.grid[y * S.cw + x] = i + 1;\n}\n\n// One step of falling sand: each loose grain drops a cell if it can, else\n// slides one cell diagonally down; returns how many fell or slid. Wind tips a falling grain sideways, and\n// now and then rolls a grain on the surface one cell downwind, so a pile in\n// the wind creeps and grows a steep lee side.\nfunction fall(S, wind) {\n  const cw = S.cw, ch = S.ch, grid = S.grid, stamp = S.stamp, step = ++S.step;\n  const dir = wind > 0 ? 1 : -1, creep = abs(wind) * 0.06;\n  let moved = 0;\n  const flip = (S.flip = !S.flip);\n  for (let y = ch - 1; y >= 0; y--)\n    for (let k = 0; k \u003c cw; k++) {\n      const x = flip ? k : cw - 1 - k, o = y * cw + x, id = grid[o];\n      if (!id || S.st[id - 1] !== 0 || stamp[id - 1] === step) continue;\n      const i = id - 1, b = o + cw, floor_ = y === ch - 1;\n      let to = -1;\n      if (!floor_ && !grid[b]) {\n        // Grains in the air fall at slightly different speeds, so a\n        // crumbling letter smears into a curtain on the way down.\n        if (Math.random() > S.shade[i]) continue;\n        to = b;\n        const xx = x + dir;\n        if (Math.random() \u003c abs(wind) * 0.5 && xx >= 0 && xx \u003c cw && !grid[b + dir]) to = b + dir;\n      } else if (!floor_) {\n        const first = Math.random() \u003c 0.5 + wind * 0.4 ? 1 : -1;\n        for (const dx of [first, -first]) {\n          const xx = x + dx;\n          if (xx >= 0 && xx \u003c cw && !grid[b + dx]) {\n            to = b + dx;\n            break;\n          }\n        }\n      }\n      if (to >= 0) moved++;\n      else if ((y === 0 || !grid[o - cw]) && Math.random() \u003c creep) {\n        const xx = x + dir;\n        if (xx >= 0 && xx \u003c cw && !grid[o + dir]) to = o + dir;\n      }\n      if (to \u003c 0) continue;\n      grid[o] = 0;\n      grid[to] = id;\n      stamp[i] = step;\n      S.x[i] = to % cw;\n      S.y[i] = floor(to / cw);\n    }\n  return moved;\n}\n\n// The top grain of the pile in column x: the highest of the loose grains\n// stacked without a gap from the floor. The two rows on the floor are\n// bedrock and stay.\nfunction topOf(S, x) {\n  let y = S.ch - 1, top = -1;\n  if (S.grid[y * S.cw + x] && S.grid[(y - 1) * S.cw + x]) y -= 2;\n  else return -1;\n  for (; y >= 0; y--) {\n    const id = S.grid[y * S.cw + x];\n    if (!id || S.st[id - 1] !== 0) break;\n    top = id - 1;\n  }\n  return top;\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const rate = cl(kv[1], 0.2, 3) / 2;\n  const g = cl(round(kv[2]), 1, 3);\n  S.wind = cl(kv[3], -1, 1);\n  if (g !== S.g) {\n    // A new grain size rebuilds the sand around the word standing now. The\n    // first build opens 0.8 s into the hold.\n    const first = !S.g;\n    build(S, g, first ? 0 : S.word);\n    S.pt = first ? 0.8 : 0;\n  }\n  const t = d * rate;\n  S.pt += t;\n  // Falling sand runs 75 LEDs a second at Speed 2.\n  S.acc = (S.acc || 0) + (t * 75) / g;\n  let moved = 0;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    moved += fall(S, S.wind);\n  }\n  if (S.phase === 0) {\n    // While the word holds, now and then a grain with nothing under it\n    // runs out of a letter's foot.\n    const L = S.L;\n    for (let k = 0; k \u003c S.T / 60; k++) {\n      const i = floor(Math.random() * S.T);\n      if (S.st[i] === 1 && S.y[i] === L.top + S.col[i] * (L.lh + L.gap) + L.lh - 1 && !S.grid[(S.y[i] + 1) * S.cw + S.x[i]] && Math.random() \u003c t * 3) S.st[i] = 0;\n    }\n  }\n  if (S.phase === 0 && S.pt > 2.4) {\n    // Crumble: the bottom letter goes first, each letter from its foot up.\n    S.phase = 1;\n    S.pt = 0;\n    const L = S.L;\n    for (let i = 0; i \u003c S.T; i++)\n      if (S.st[i] === 1) {\n        const k = S.col[i], y0 = L.top + k * (L.lh + L.gap), up = (y0 + L.lh - 1 - S.y[i]) / L.lh;\n        S.rel[i] = (3 - k) * 0.6 + up * 0.95 + Math.random() * 0.12;\n      }\n  } else if (S.phase === 1) {\n    let held = 0;\n    for (let i = 0; i \u003c S.T; i++)\n      if (S.st[i] === 1) {\n        if (S.rel[i] \u003c= S.pt) S.st[i] = 0;\n        else held++;\n      }\n    if (!held && ((!moved && S.pt > 2.5) || S.pt > 8)) {\n      // Assemble the next word: queue its cells top letter first, each\n      // letter from its foot up.\n      S.phase = 2;\n      S.pt = 0;\n      S.word = (S.word + 1) % WORDS.length;\n      const tg = S.targets[S.word], n = tg.length / 3, ord = [];\n      for (let j = 0; j \u003c n; j++) {\n        const x = tg[3 * j], y = tg[3 * j + 1];\n        ord.push([tg[3 * j + 2] * 100000 - y * 1000 + (y % 2 ? x : -x), j]);\n      }\n      ord.sort((a, b) => a[0] - b[0]);\n      S.queue = ord.map((o) => o[1]);\n      S.next = 0;\n      S.launch = 0;\n    }\n  } else if (S.phase === 2) {\n    const tg = S.targets[S.word], cw = S.cw;\n    S.launch += (t * 440) / (g * g);\n    while (S.launch >= 1 && S.next \u003c S.queue.length) {\n      S.launch -= 1;\n      // Take the highest grain near the mouth, which wanders slowly over\n      // the pile; the sand around slides into the pit it digs. Sand still\n      // heaped up into the letter about to be built goes first.\n      const j0 = S.queue[S.next], L = S.L;\n      const foot = L.top + tg[3 * j0 + 2] * (L.lh + L.gap) + L.lh + 1;\n      const mouth = round(cw / 2 + (cw / 5) * Math.sin(S.pt * 0.9));\n      let best = -1, high = -1;\n      for (let x = 0; x \u003c cw; x++) {\n        const id = topOf(S, x);\n        if (id \u003c 0) continue;\n        if (high \u003c 0 || S.y[id] \u003c S.y[high]) high = id;\n        if (abs(x - mouth) \u003c= 3 && (best \u003c 0 || S.y[id] \u003c S.y[best])) best = id;\n      }\n      if (high >= 0 && (best \u003c 0 || S.y[high] \u003c= foot)) best = high;\n      if (best \u003c 0) break;\n      const j = S.queue[S.next++], i = best;\n      S.grid[S.y[i] * cw + S.x[i]] = 0;\n      S.st[i] = 2;\n      S.from[i] = S.col[i];\n      S.col[i] = tg[3 * j + 2];\n      S.slot[i] = j;\n      // Every grain for one letter rides the same two control points, so\n      // the grains in flight draw one rising stream from the top of the\n      // pile to a point under the letter, where it fans out into the\n      // letter's cells. The stream sways, and the wind leans it.\n      const x0 = S.x[i], y0 = S.y[i], k = S.col[i];\n      const yb = L.top + k * (L.lh + L.gap) + L.lh + 2, lx = cw / 2;\n      const lean = (S.wind * 14 + 5 * Math.sin(S.pt * 1.3)) / g, jit = () => (Math.random() - 0.5) * 2;\n      S.fx0[i] = x0;\n      S.fy0[i] = y0;\n      S.fcx[i] = x0 + lean + jit();\n      S.fcy[i] = y0 - 0.55 * (y0 - yb) + jit();\n      S.fdx[i] = lx + 0.6 * lean + 1.5 * jit();\n      S.fdy[i] = yb + 0.1 * (y0 - yb) + jit();\n      S.ft[i] = 0;\n      S.fdur[i] = 0.9 + Math.random() * 0.1;\n      S.flying++;\n    }\n    for (let i = 0; i \u003c S.T; i++) {\n      if (S.st[i] !== 2) continue;\n      S.ft[i] += t;\n      const j = S.slot[i], x1 = tg[3 * j], y1 = tg[3 * j + 1];\n      let u = S.ft[i] / S.fdur[i];\n      if (u >= 1) {\n        S.flying--;\n        const o = y1 * cw + x1, there = S.grid[o];\n        if (there) {\n          // A loose grain already sits in the cell: it joins the letter and\n          // the newcomer drops in as loose sand beside it.\n          const k = there - 1;\n          S.st[k] = 1;\n          S.col[k] = S.col[i];\n          let yy = y1 - 1;\n          while (yy > 0 && S.grid[yy * cw + x1]) yy--;\n          put(S, i, x1, yy, 0, S.col[i]);\n        } else put(S, i, x1, y1, 1, S.col[i]);\n        continue;\n      }\n      u = u * u * (3 - 2 * u);\n      const v = 1 - u, a = v * v * v, b = 3 * v * v * u, c = 3 * v * u * u, e = u * u * u;\n      S.x[i] = a * S.fx0[i] + b * S.fcx[i] + c * S.fdx[i] + e * x1;\n      S.y[i] = a * S.fy0[i] + b * S.fcy[i] + c * S.fdy[i] + e * y1;\n    }\n    if (S.next >= S.queue.length && !S.flying) {\n      S.phase = 0;\n      S.pt = 0;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.g) return;\n  const g = S.g, pal = S.pal, tr = S.trail, c = S.tmp;\n  for (let k = 0; k \u003c 4; k++) hsv(HUES[k] + S.hue, 0.78, 1, pal, k * 3);\n  for (let o = 0; o \u003c tr.length; o++) tr[o] *= 0.75;\n  const rgb = (S.rgb = S.rgb || new Float32Array(W * H * 3));\n  rgb.set(tr);\n  for (let i = 0; i \u003c S.T; i++) {\n    const sh = S.shade[i];\n    let r = pal[S.col[i] * 3] * sh, gg = pal[S.col[i] * 3 + 1] * sh, b = pal[S.col[i] * 3 + 2] * sh;\n    let X = S.ox + round(S.x[i] * g), Y = S.oy + round(S.y[i] * g);\n    if (S.st[i] === 2) {\n      // In flight: brighter, turning from the old colour to the new.\n      const u = cl(S.ft[i] / S.fdur[i], 0, 1), f = S.from[i] * 3, k = S.col[i] * 3;\n      r = min(255, (pal[f] + (pal[k] - pal[f]) * u) * 1.2);\n      gg = min(255, (pal[f + 1] + (pal[k + 1] - pal[f + 1]) * u) * 1.2);\n      b = min(255, (pal[f + 2] + (pal[k + 2] - pal[f + 2]) * u) * 1.2);\n    }\n    for (let yy = 0; yy \u003c g; yy++)\n      for (let xx = 0; xx \u003c g; xx++) {\n        const px = X + xx, py = Y + yy;\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const o = (py * W + px) * 3;\n        rgb[o] = r;\n        rgb[o + 1] = gg;\n        rgb[o + 2] = b;\n        if (S.st[i] === 2) {\n          tr[o] = max(tr[o], r * 0.45);\n          tr[o + 1] = max(tr[o + 1], gg * 0.45);\n          tr[o + 2] = max(tr[o + 2], b * 0.45);\n        }\n      }\n  }\n  for (let Y = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++) {\n      const o = (Y * W + X) * 3;\n      display.setPixel(X, Y, rgb[o] | 0, rgb[o + 1] | 0, rgb[o + 2] | 0);\n    }\n}\n","polynomial-amoeba":"// ===== Patternflow pattern =====\n// Title:   Polynomial Amoeba\n// Family:  topology\n// Idea:    The amoeba of a curve f(z, w) = 0 whose Newton polygon is a hexagon with three interior points, solved row by row as the image of its zeros under (log|z|, log|w|), breathes slowly between a fat starfish and the thin tropical ladder it shrinks onto, and its three stacked holes open and close by turns as the middle coefficients rise and fall.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: amoebas of polynomials (Israel Gelfand, Mikhail Kapranov and Andrei Zelevinsky, 1994), holes and interior lattice points (Mikael Forsberg, Mikael Passare and August Tsikh, 2000), amoebas of maximal area (Grigory Mikhalkin and Hans Rullgard, 2001), tropical limit (Grigory Mikhalkin, 2005), pattern round 64\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lift=-1..1, Phase=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together; at 0 the body is sea green, bluer along its diagonal tentacles, the holes are violet and the tropical curve a pale gold thread.\n// Knob 2: Speed. How fast the tide of t runs: at 2 the amoeba goes from starfish to ladder and back in 22 seconds, at 0.2 in 3 minutes 40, at 3 in 15 seconds; the coefficients drift at the same pace.\n// Knob 3: Lift. The size of the three middle coefficients, those of z w, z w^2 and z w^3: at -1 they are too small for any hole and the amoeba is a cross of tentacles, at 0 they rise and fall so the holes open and close by turns, at 1 all three stand wide open.\n// Knob 4: Phase. The arguments of the coefficients: at 0 they are real with Harnack's signs (-1)^(ij), and the amoeba covers the most it can (Mikhalkin and Rullgard: a simple Harnack curve's amoeba has the largest area); turned up they spread round the circle, the body thins and the holes change size and slide.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, log, exp, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst SC = 7; // LEDs to one unit of log|z| or log|w|\nconst XC = 32, YC = 64;\nconst K = 64; // samples of arg w round each row's circle\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The Newton polygon: the hexagon (1,0) (2,1) (2,3) (1,4) (0,3) (0,1), with\n// interior points (1,1), (1,2), (1,3). f is quadratic in z, so each row\n// (fixed |w|) is solved with the quadratic formula.\nconst MON = [[0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [2, 1], [2, 2], [2, 3]];\nconst NM = MON.length;\nconst MI = MON.map((m) => m[0]), MJ = MON.map((m) => m[1]);\nconst INNER = [4, 5, 6];\nconst ALPHA = 1.4, BETA = 1.4;\n\nexport function setup(params) {\n  const cs = new Float64Array((K + 1) * 5 * 2);\n  for (let k = 0; k \u003c= K; k++)\n    for (let j = 0; j \u003c 5; j++) {\n      cs[(k * 5 + j) * 2] = cos((2 * PI * k * j) / K);\n      cs[(k * 5 + j) * 2 + 1] = sin((2 * PI * k * j) / K);\n    }\n  const seed = MON.map((m, k) => (k * 0.618034 + 0.31) % 1);\n  params.s = {\n    cs, seed, t: 0, hue: 0, lift: 0, phase: 0, started: false,\n    v: new Float64Array(NM), ph: new Float64Array(NM),\n    cov: new Float32Array(N), F: new Float32Array(N * 3), h: 1,\n  };\n}\n\n// The coefficients at tide time t: |c| = exp(h v) and arg c. The valuations v\n// are a concave lift of the hexagon's points, so every point stands on the\n// upper hull and the tropical curve is a ladder of three cells; the inner\n// points' lifts wander, the outer ones drift a little.\nfunction coefficients(S) {\n  const t = S.t;\n  // The tide of t: with c = t^v the amoeba drawn at scale 1 / log t shrinks\n  // onto the tropical curve as t grows (Mikhalkin). h = log t swings between\n  // 0.64 and 3.9; the panel opens near the fattest and thins for ten seconds.\n  S.h = exp(0.45 + 0.9 * sin((2 * PI * (t - 5)) / 22));\n  for (let m = 0; m \u003c NM; m++) {\n    const [i, j] = MON[m];\n    const r = S.seed[m];\n    let v = -(ALPHA * (i - 1) * (i - 1) + BETA * (j - 2) * (j - 2));\n    // The middle point has the most neighbours pressing on its hole, so it\n    // stands a little higher.\n    if (INNER.includes(m)) v += (S.lift \u003c 0 ? 1.9 : 1.2) * S.lift + 0.45 * sin(t * (0.21 + 0.05 * (m - 5)) + 1.3 + 2.1 * (m - 4)) - 0.1 + (m === 5 ? 0.35 : 0);\n    else v += 0.35 * sin(t * (0.11 + 0.07 * r) + 6.28 * r);\n    S.v[m] = v;\n    // Harnack's signs, (-1)^(ij), and the Phase knob spreading the\n    // arguments away from them.\n    S.ph[m] = ((i * j) & 1 ? PI : 0) + S.phase * (PI * (2 * r - 1) * 1.6 + 0.25 * sin(t * 0.13 + 9 * r));\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt, 0, 0.1);\n  S.hue = k[0];\n  S.lift = cl(k[2], -1, 1);\n  S.phase = cl(k[3], 0, 1);\n  S.t += (dt * cl(k[1], 0.05, 3)) / 2;\n}\n\n// One row: |w| = exp(h Y). For each sample of arg w, the two roots z of\n// A(w) + B(w) z + C(w) z^2 = 0, sorted by |z|. Each of the lower and upper\n// root is continuous round the circle, so each sweeps one interval of\n// x = log|z| / h, and the two intervals together are the row of the amoeba.\n// Where the roots swap round the circle the two intervals overlap, and their\n// union is still exact.\nfunction row(S, y, cov) {\n  const h = S.h, Y = (YC - y - 0.5) / SC;\n  let top = -1e9;\n  for (let m = 0; m \u003c NM; m++) top = max(top, S.v[m] + MJ[m] * Y);\n  const pr = S.pr, pi = S.pi;\n  for (let m = 0; m \u003c NM; m++) {\n    const a = exp(h * (S.v[m] + MJ[m] * Y - top));\n    pr[m] = a * cos(S.ph[m]);\n    pi[m] = a * sin(S.ph[m]);\n  }\n  const cs = S.cs;\n  // Squared moduli of the lower and upper root, their least and greatest.\n  let loA = Infinity, loB = 0, hiA = Infinity, hiB = 0;\n  const o = y * W;\n  for (let x = 0; x \u003c W; x++) cov[o + x] = 0;\n  // A(w), B(w), C(w): the coefficients of z^0, z^1, z^2, by powers of w.\n  const A1r = pr[0], A1i = pi[0], A2r = pr[1], A2i = pi[1], A3r = pr[2], A3i = pi[2];\n  const B0r = pr[3], B0i = pi[3], B1r = pr[4], B1i = pi[4], B2r = pr[5], B2i = pi[5], B3r = pr[6], B3i = pi[6], B4r = pr[7], B4i = pi[7];\n  const C1r = pr[8], C1i = pi[8], C2r = pr[9], C2i = pi[9], C3r = pr[10], C3i = pi[10];\n  for (let k = 0; k \u003c= K; k++) {\n    const c0 = k * 10;\n    const e1r = cs[c0 + 2], e1i = cs[c0 + 3], e2r = cs[c0 + 4], e2i = cs[c0 + 5];\n    const e3r = cs[c0 + 6], e3i = cs[c0 + 7], e4r = cs[c0 + 8], e4i = cs[c0 + 9];\n    const ar = A1r * e1r - A1i * e1i + A2r * e2r - A2i * e2i + A3r * e3r - A3i * e3i;\n    const ai = A1r * e1i + A1i * e1r + A2r * e2i + A2i * e2r + A3r * e3i + A3i * e3r;\n    const br = B0r + B1r * e1r - B1i * e1i + B2r * e2r - B2i * e2i + B3r * e3r - B3i * e3i + B4r * e4r - B4i * e4i;\n    const bi = B0i + B1r * e1i + B1i * e1r + B2r * e2i + B2i * e2r + B3r * e3i + B3i * e3r + B4r * e4i + B4i * e4r;\n    const cr = C1r * e1r - C1i * e1i + C2r * e2r - C2i * e2i + C3r * e3r - C3i * e3i;\n    const ci = C1r * e1i + C1i * e1r + C2r * e2i + C2i * e2r + C3r * e3i + C3i * e3r;\n    // Discriminant D = B^2 - 4AC and the root of larger modulus,\n    // q = -(B + sqrt D) / 2 with the sign that keeps B and sqrt D from\n    // cancelling: |q|^2 = (|B|^2 + |D| + 2 |Re(conj(B) sqrt D)|) / 4, and\n    // |Re(conj(B) sqrt D)|^2 = (|B|^2 |D| + Re(conj(B)^2 D)) / 2. The roots\n    // are z1 = q / C and z2 = A / q.\n    const dr = br * br - bi * bi - 4 * (ar * cr - ai * ci);\n    const di = 2 * br * bi - 4 * (ar * ci + ai * cr);\n    const dm = sqrt(dr * dr + di * di);\n    const b2 = br * br + bi * bi;\n    const q2 = (b2 + dm + 2 * sqrt(max(0, (b2 * dm + (br * br - bi * bi) * dr + 2 * br * bi * di) / 2))) / 4;\n    const r1 = q2 / (cr * cr + ci * ci), r2 = (ar * ar + ai * ai) / q2;\n    const lo = r1 \u003c r2 ? r1 : r2, hi = r1 \u003c r2 ? r2 : r1;\n    if (lo \u003c loA) loA = lo;\n    if (lo > loB) loB = lo;\n    if (hi \u003c hiA) hiA = hi;\n    if (hi > hiB) hiB = hi;\n  }\n  // To LEDs: x = log|z| / h.\n  const px = (r) => cl(XC + (log(r) / (2 * h)) * SC, -4, W + 4);\n  let a1 = px(loA), b1 = px(loB), a2 = px(hiA), b2 = px(hiB);\n  // The union of the two intervals, as coverage of each LED.\n  if (a2 \u003c= b1) (b1 = max(b1, b2)), (a2 = 1e9);\n  span(cov, o, a1, b1);\n  if (a2 \u003c 1e8) span(cov, o, a2, b2);\n}\n\n// Coverage of [a, b] on a row.\nfunction span(cov, o, a, b) {\n  a = max(a, 0);\n  b = min(b, W);\n  for (let x = floor(a); x \u003c b; x++) cov[o + x] = min(1, cov[o + x] + min(b, x + 1) - max(a, x));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S.pr) {\n    S.pr = new Float64Array(NM);\n    S.pi = new Float64Array(NM);\n  }\n  coefficients(S);\n  const { cov, F, v } = S;\n  for (let y = 0; y \u003c H; y++) row(S, y, cov);\n  // The body's colour follows the edge of the Newton polygon its piece is\n  // dual to: ladder sides, rungs and side tentacles, and the two diagonals.\n  const tone = [0, 1, 2, 3].map((d) => hsv(0.42 + S.hue + 0.06 * d, 0.6 - 0.06 * d, 1));\n  const hole = hsv(0.8 + S.hue, 0.6, 72);\n  const line = [255, 228, 176];\n  const blend = S.started ? 0.5 : 1;\n  S.started = true;\n  const gb = new Float64Array(3), gs = new Float64Array(3), gm = new Int32Array(3), gn = new Int32Array(3);\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    const Y = (YC - y - 0.5) / SC;\n    // Along a row only i X changes, so each power of z keeps its best and\n    // second-best monomial for the whole row.\n    gb.fill(-1e9);\n    gs.fill(-1e9);\n    for (let m = 0; m \u003c NM; m++) {\n      const i = MI[m], val = v[m] + MJ[m] * Y;\n      if (val > gb[i]) (gs[i] = gb[i]), (gn[i] = gm[i]), (gb[i] = val), (gm[i] = m);\n      else if (val > gs[i]) (gs[i] = val), (gn[i] = m);\n    }\n    for (let x = 0; x \u003c W; x++, p++) {\n      const X = (x + 0.5 - XC) / SC;\n      // The tropical polynomial max(v + iX + jY): the winning monomial, the\n      // runner-up, and the winner's lead as distance to the tropical curve.\n      let w = 0;\n      for (let i = 1; i \u003c 3; i++) if (gb[i] + i * X > gb[w] + w * X) w = i;\n      const b1 = gb[w] + w * X, m1 = gm[w];\n      let b2 = gs[w] + w * X, m2 = gn[w];\n      for (let i = 0; i \u003c 3; i++)\n        if (i !== w && gb[i] + i * X > b2) (b2 = gb[i] + i * X), (m2 = gm[i]);\n      const di = MI[m1] - MI[m2], dj = MJ[m1] - MJ[m2];\n      const dist = ((b1 - b2) * SC) / sqrt(di * di + dj * dj);\n      const c = cov[p];\n      // Outside the amoeba: night, and the holes, where an inner monomial\n      // wins, a deep violet.\n      let r = 6, g = 9, b = 16;\n      if (m1 >= 4 && m1 \u003c= 6) (r = hole[0]), (g = hole[1]), (b = hole[2]);\n      if (c > 0) {\n        const t = tone[di === 0 ? 1 : dj === 0 ? 0 : di * dj > 0 ? 2 : 3];\n        const lv = 205 + 50 * max(0, 1 - dist * dist * 0.04);\n        r += (t[0] * lv - r) * c;\n        g += (t[1] * lv - g) * c;\n        b += (t[2] * lv - b) * c;\n      }\n      if (dist \u003c 0.8) {\n        const a = 0.5 * (1 - dist / 0.8);\n        r += (line[0] - r) * a;\n        g += (line[1] - g) * a;\n        b += (line[2] - b) * a;\n      }\n      const q = p * 3;\n      F[q] += (r - F[q]) * blend;\n      F[q + 1] += (g - F[q + 1]) * blend;\n      F[q + 2] += (b - F[q + 2]) * blend;\n      display.setPixel(x, y, F[q], F[q + 1], F[q + 2]);\n    }\n  }\n}\n","rivers-of-white":"// ===== Patternflow pattern =====\n// Title:   Rivers of White\n// Family:  type\n// Idea:    The opening paragraph of A Tale of Two Cities is set justified in a 3 by 5 pixel face down the whole panel, and wherever the stretched word spaces of successive lines line up into rivers of white the paragraph lights them, so the typesetter's flaw glows and meanders while the column narrows and widens and the rivers break and re-form.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after the rivers of white that justified type has always made, with total-fit line breaking (Donald Knuth and Michael Plass, 1981), setting Charles Dickens's A Tale of Two Cities (1859)\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fit=0..1, Space=0..1\n//\n// Knob 1: Hue. The colour of the light in the rivers: ice blue at 0, violet at 0.25, peach at 0.5, green at 0.75 and ice blue again at 1; the type stays warm.\n// Knob 2: Speed. How fast the column breathes between 64 and 54 LEDs wide and the light runs down the rivers: at 2 one breath takes 10 s, at 0.2 it takes 100 s.\n// Knob 3: Fit. How the lines are broken: at 0 greedily, as many words as fit on each line in turn, the way a word processor does; from 0.02 to 0.15 by Knuth and Plass's total fit, the breaks that make the whole paragraph's spacing least bad; and turned further each column a word space shares with the space on the line above costs more, until at 1 the breaks steer the spaces apart and the rivers mostly dry up.\n// Knob 4: Space. The natural word space: 3 LEDs at the opening, 4, 5 and 6 as it turns. Wider spaces line up more easily, and at 6 the rivers braid through the whole page.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The 3 by 5 face, rows top to bottom; punctuation is one LED wide.\nconst GLYPHS = {\n  A: \"010101111101101\", B: \"110101110101110\", C: \"011100100100011\", D: \"110101101101110\",\n  E: \"111100110100111\", F: \"111100110100100\", G: \"011100101101011\", H: \"101101111101101\",\n  I: \"111010010010111\", J: \"001001001101010\", K: \"101101110101101\", L: \"100100100100111\",\n  M: \"101111111101101\", N: \"110101101101101\", O: \"010101101101010\", P: \"110101110100100\",\n  Q: \"010101101111011\", R: \"110101110101101\", S: \"011100010001110\", T: \"111010010010010\",\n  U: \"101101101101011\", V: \"101101101010010\", W: \"101101111111101\", X: \"101101010101101\",\n  Y: \"101101010010010\", Z: \"111001010100111\", \"-\": \"000000111000000\",\n  \".\": \"00001\", \",\": \"00011\", \";\": \"01011\", \":\": \"01010\", \"'\": \"11000\", \"!\": \"11101\",\n};\n\n// Charles Dickens, A Tale of Two Cities (1859), the first paragraph. The dash\n// before IN SHORT is set close, as the book sets it.\nconst TEXT =\n  \"IT WAS THE BEST OF TIMES, IT WAS THE WORST OF TIMES, IT WAS THE AGE OF WISDOM, IT WAS THE AGE OF FOOLISHNESS, \" +\n  \"IT WAS THE EPOCH OF BELIEF, IT WAS THE EPOCH OF INCREDULITY, IT WAS THE SEASON OF LIGHT, IT WAS THE SEASON OF DARKNESS, \" +\n  \"IT WAS THE SPRING OF HOPE, IT WAS THE WINTER OF DESPAIR, WE HAD EVERYTHING BEFORE US, WE HAD NOTHING BEFORE US, \" +\n  \"WE WERE ALL GOING DIRECT TO HEAVEN, WE WERE ALL GOING DIRECT THE OTHER WAY-IN SHORT, THE PERIOD WAS SO FAR LIKE \" +\n  \"THE PRESENT PERIOD, THAT SOME OF ITS NOISIEST AUTHORITIES INSISTED ON ITS BEING RECEIVED, FOR GOOD OR FOR EVIL, \" +\n  \"IN THE SUPERLATIVE DEGREE OF COMPARISON ONLY.\";\n\n// A line is 5 rows of type and 1 of leading; 21 lines fill rows 1 to 126.\nconst LH = 6, TOP = 1, LINES = 21;\n// The narrowest column still holds FOOLISHNESS, and INCREDULITY, at 45 LEDs.\nconst MIN_M = 46;\n\n// Each word as a list of column masks, one bit per row, with a blank column\n// between letters.\nfunction shapeWords() {\n  return TEXT.split(\" \").map((w) => {\n    const cols = [];\n    for (const ch of w) {\n      const g = GLYPHS[ch];\n      const gw = g.length / 5;\n      if (cols.length) cols.push(0);\n      for (let i = 0; i \u003c gw; i++) {\n        let m = 0;\n        for (let j = 0; j \u003c 5; j++) if (g[j * gw + i] === \"1\") m |= 1 \u003c\u003c j;\n        cols.push(m);\n      }\n    }\n    return cols;\n  });\n}\n\nexport function setup(params) {\n  const P = params;\n  P.words = shapeWords();\n  P.wl = P.words.map((c) => c.length);\n  P.n = P.words.length;\n  P.cache = new Map();\n  P.phase = 0;\n  P.flow = 0;\n  P.key = \"\";\n  P.ink = new Uint8Array(N); // type\n  P.target = new Float32Array(N); // river light wanted now\n  P.light = new Float32Array(N); // river light shown, easing toward it\n  P.halo = new Float32Array(N);\n  P.tmp = new Float32Array(N);\n  P.started = false;\n}\n\n// ---- Line breaking -------------------------------------------------------\n\n// A line of words a..b-1 at measure M with natural space S: its words' width,\n// gap count and slack against natural spacing; null if it cannot fit even at\n// the tightest space S - 1 (a single word always fits, overhanging if it must).\nfunction lineOf(P, a, b, M, S) {\n  let w = 0;\n  for (let i = a; i \u003c b; i++) w += P.wl[i];\n  const g = b - a - 1;\n  if (g > 0 && w + (S - 1) * g > M) return null;\n  return { w, g, slack: M - w - S * g };\n}\n\n// How bad a line is: the square of how far each space is stretched or shrunk\n// from natural, in LEDs; shrinking counts eight times; a lone word on a\n// justified line pays a great deal; the last line is set ragged and is free.\nfunction badness(L, last) {\n  if (last) return L.slack >= 0 ? 0 : 1e6;\n  if (L.g === 0) return 60 + L.slack * L.slack;\n  const r = L.slack / L.g;\n  return r >= 0 ? r * r : 8 * r * r;\n}\n\n// The word spaces of a justified line as inclusive column ranges, the stretch\n// spread from left to right as evenly as whole LEDs allow.\nfunction gapsOf(P, a, b, M, S, x0, last) {\n  const L = lineOf(P, a, b, M, S) || { w: 0, g: b - a - 1, slack: 0 };\n  const out = [];\n  const extra = last || L.g === 0 ? 0 : L.slack;\n  let x = x0;\n  for (let i = a, k = 0; i \u003c b - 1; i++, k++) {\n    x += P.wl[i];\n    const s = S + floor((extra * (k + 1)) / L.g) - floor((extra * k) / L.g);\n    out.push(x, x + s - 1);\n    x += s;\n  }\n  return out;\n}\n\n// Columns shared between the spaces of two lines.\nfunction overlap(A, B) {\n  let s = 0;\n  for (let i = 0; i \u003c A.length; i += 2)\n    for (let j = 0; j \u003c B.length; j += 2) {\n      const o = min(A[i + 1], B[j + 1]) - max(A[i], B[j]) + 1;\n      if (o > 0) s += o;\n    }\n  return s;\n}\n\n// Greedy: as many words as fit at natural spacing, line after line.\nfunction greedy(P, M, S) {\n  const br = [0];\n  for (let a = 0; a \u003c P.n; ) {\n    let b = a + 1;\n    while (b \u003c P.n) {\n      const L = lineOf(P, a, b + 1, M, S);\n      if (!L || L.slack \u003c 0) break;\n      b++;\n    }\n    br.push(b);\n    a = b;\n  }\n  return br;\n}\n\n// Total fit with a river toll: the breaks of least total badness, plus mu for\n// every column a line's spaces share with the spaces of the line above. The\n// toll needs the line above, so a state is the pair (start of the line above,\n// start of this line); with mu = 0 it is Knuth and Plass's total fit.\nfunction totalFit(P, M, S, mu, x0) {\n  const n = P.n;\n  const ends = [];\n  for (let a = 0; a \u003c n; a++) {\n    const l = [];\n    for (let b = a + 1; b \u003c= n; b++) {\n      if (!lineOf(P, a, b, M, S)) break;\n      l.push(b);\n    }\n    ends.push(l);\n  }\n  const gaps = new Map();\n  const gp = (a, b) => {\n    const k = a * 512 + b;\n    let v = gaps.get(k);\n    if (!v) gaps.set(k, (v = gapsOf(P, a, b, M, S, x0, b === n)));\n    return v;\n  };\n  // cost[a] maps the start of the line above to the best cost of setting\n  // words 0..a-1 with that line last.\n  const cost = [], back = [];\n  for (let a = 0; a \u003c= n; a++) {\n    cost.push(new Map());\n    back.push(new Map());\n  }\n  cost[0].set(-1, 0);\n  for (let a = 0; a \u003c n; a++) {\n    for (const [p, c0] of cost[a]) {\n      const above = p >= 0 ? gp(p, a) : null;\n      for (const b of ends[a]) {\n        const L = lineOf(P, a, b, M, S);\n        let c = c0 + badness(L, b === n);\n        if (above && mu > 0) c += mu * overlap(above, gp(a, b));\n        const was = cost[b].get(a);\n        if (was === undefined || c \u003c was) {\n          cost[b].set(a, c);\n          back[b].set(a, p);\n        }\n      }\n    }\n  }\n  let best = Infinity, last = -1;\n  for (const [p, c] of cost[n]) if (c \u003c best) (best = c), (last = p);\n  const br = [n];\n  for (let b = n, a = last; a >= 0; ) {\n    br.push(a);\n    const p = back[b].get(a);\n    b = a;\n    a = p;\n  }\n  return br.reverse();\n}\n\n// The page for a measure: every visible line's words as [x, word] pairs and\n// its spaces, cached because the column passes the same widths again.\nfunction layout(P, M) {\n  const key = M + \"/\" + P.S + \"/\" + P.mu.toFixed(3);\n  let L = P.cache.get(key);\n  if (L) return L;\n  const x0 = floor((W - M) / 2);\n  const br = P.mu \u003c 0 ? greedy(P, M, P.S) : totalFit(P, M, P.S, P.mu, x0);\n  const lines = [];\n  for (let i = 0; i + 1 \u003c br.length && i \u003c LINES; i++) {\n    const a = br[i], b = br[i + 1], last = b === P.n;\n    const gaps = gapsOf(P, a, b, M, P.S, x0, last);\n    const xs = [x0];\n    for (let k = 0; k \u003c gaps.length; k += 2) xs.push(gaps[k + 1] + 1);\n    lines.push({ a, b, xs, gaps });\n  }\n  // Rivers: a space joins a space on the next line when they share a column;\n  // each space carries the most lines any chain through it spans.\n  const down = lines.map((l) => new Array(l.gaps.length / 2).fill(1));\n  const up = lines.map((l) => new Array(l.gaps.length / 2).fill(1));\n  const touch = (A, i, B, j) => max(A[i], B[j]) \u003c= min(A[i + 1], B[j + 1]);\n  for (let i = lines.length - 2; i >= 0; i--)\n    for (let k = 0; k \u003c down[i].length; k++)\n      for (let m = 0; m \u003c down[i + 1].length; m++)\n        if (touch(lines[i].gaps, 2 * k, lines[i + 1].gaps, 2 * m)) down[i][k] = max(down[i][k], 1 + down[i + 1][m]);\n  for (let i = 1; i \u003c lines.length; i++)\n    for (let k = 0; k \u003c up[i].length; k++)\n      for (let m = 0; m \u003c up[i - 1].length; m++)\n        if (touch(lines[i].gaps, 2 * k, lines[i - 1].gaps, 2 * m)) up[i][k] = max(up[i][k], 1 + up[i - 1][m]);\n  for (let i = 0; i \u003c lines.length; i++) lines[i].run = down[i].map((d, k) => d + up[i][k] - 1);\n  L = { lines, x0, M };\n  if (P.cache.size > 400) P.cache.clear();\n  P.cache.set(key, L);\n  return L;\n}\n\n// How brightly a space glows for the lines its river spans: two lines are a\n// coincidence, three a river, six a flood.\nconst glowOf = (run) => (run \u003c 2 ? 0 : run === 2 ? 0.16 : min(1, 0.4 + 0.15 * (run - 3)));\n\nfunction paint(P, L) {\n  const { ink, target } = P;\n  ink.fill(0);\n  target.fill(0);\n  L.lines.forEach((ln, i) => {\n    const y0 = TOP + i * LH;\n    // Type.\n    for (let k = ln.a; k \u003c ln.b; k++) {\n      const cols = P.words[k], x = ln.xs[k - ln.a];\n      for (let c = 0; c \u003c cols.length; c++) {\n        const X = x + c;\n        if (X \u003c 0 || X >= W || !cols[c]) continue;\n        for (let j = 0; j \u003c 5; j++) if (cols[c] & (1 \u003c\u003c j)) ink[(y0 + j) * W + X] = 1;\n      }\n    }\n    // The spaces of rivers: a space is lit dimly across its width and fully in\n    // the columns it shares with the spaces above and below, the channel the\n    // river runs down; the leading is lit where it steps to the next line.\n    const prev = L.lines[i - 1], next = L.lines[i + 1];\n    for (let k = 0; k \u003c ln.run.length; k++) {\n      const v = glowOf(ln.run[k]);\n      if (!v) continue;\n      const g0 = ln.gaps[2 * k], g1 = ln.gaps[2 * k + 1];\n      for (let y = y0; y \u003c y0 + 5; y++) for (let x = g0; x \u003c= g1; x++) target[y * W + x] = max(target[y * W + x], 0.28 * v);\n      for (const [nb, dy] of [[prev, -1], [next, 5]]) {\n        if (!nb) continue;\n        for (let m = 0; m \u003c nb.run.length; m++) {\n          const a = max(g0, nb.gaps[2 * m]), b = min(g1, nb.gaps[2 * m + 1]);\n          if (a > b) continue;\n          const w = min(v, glowOf(nb.run[m]));\n          for (let x = a; x \u003c= b; x++) {\n            for (let y = y0; y \u003c y0 + 5; y++) target[y * W + x] = max(target[y * W + x], w);\n            if (dy > 0) target[(y0 + dy) * W + x] = max(target[(y0 + dy) * W + x], w);\n          }\n        }\n      }\n    }\n  });\n}\n\nexport function update(dt, input, params) {\n  const P = params;\n  if (!P.words) setup(P);\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  P.hue = k[0] || 0;\n  P.speed = cl(k[1], 0.2, 3);\n  const fit = cl(k[2], 0, 1);\n  // Greedy at the very bottom, plain total fit up to 0.15, then the river toll\n  // rises to 100 per shared column at 1.\n  P.mu = fit \u003c 0.02 ? -1 : fit \u003c= 0.15 ? 0 : 100 * ((fit - 0.15) / 0.85) ** 2;\n  P.S = cl(round(3 + 3 * cl(k[3], 0, 1)), 3, 6);\n  // The column breathes from full width down to 54 LEDs and back; the\n  // opening frame is 1.4 radians into a breath (2.2 s at Speed 2), already\n  // drawing in.\n  P.phase += (dt * 2 * PI * P.speed) / 20;\n  const breath = (1 - cos(P.phase + 1.4)) / 2;\n  const M = max(MIN_M, round(64 - 10 * breath));\n  P.flow += dt * P.speed * 0.3;\n  const L = layout(P, M);\n  const key = L.M + \"/\" + P.S + \"/\" + P.mu;\n  if (key !== P.key) {\n    P.key = key;\n    P.page = L;\n    paint(P, L);\n  }\n  // River light eases in and out over a fifth of a second as rivers form and break.\n  const e = P.started ? 1 - exp(-dt / 0.2) : 1;\n  P.started = true;\n  const { light, target, halo, tmp } = P;\n  for (let p = 0; p \u003c N; p++) light[p] += (target[p] - light[p]) * e;\n  // The halo: the light spread two LEDs each way, across then down.\n  for (let y = 0; y \u003c H; y++) {\n    let s = 0;\n    const r = y * W;\n    for (let x = -2; x \u003c W; x++) {\n      if (x + 2 \u003c W) s += light[r + x + 2];\n      if (x - 3 >= 0) s -= light[r + x - 3];\n      if (x >= 0) tmp[r + x] = s / 5;\n    }\n  }\n  for (let x = 0; x \u003c W; x++) {\n    let s = 0;\n    for (let y = -2; y \u003c H; y++) {\n      if (y + 2 \u003c H) s += tmp[(y + 2) * W + x];\n      if (y - 3 >= 0) s -= tmp[(y - 3) * W + x];\n      if (y >= 0) halo[y * W + x] = s / 5;\n    }\n  }\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function draw(display, params) {\n  const P = params;\n  if (!P.page) return;\n  const c = [0, 0, 0];\n  // Ice blue at Hue 0, pale enough to read as white light.\n  hsv(P.hue + 0.56, 0.56, 1, c);\n  const [rr, rg, rb] = c;\n  const { ink, light, halo } = P;\n  const ft = P.flow;\n  for (let y = 0, p = 0; y \u003c H; y++) {\n    // Light runs down the rivers in slow swells.\n    const wave = 0.74 + 0.26 * sin(2 * PI * (y / 30 - ft));\n    for (let x = 0; x \u003c W; x++, p++) {\n      const h = halo[p];\n      if (ink[p]) {\n        // The type, warm parchment, catching a little of the river light.\n        const g = 0.7 * h;\n        display.setPixel(x, y, round(min(255, 178 + 80 * g * rr)), round(min(255, 136 + 80 * g * rg)), round(min(255, 84 + 80 * g * rb)));\n      } else {\n        const v = light[p] * wave * 0.92 + h * 0.24;\n        display.setPixel(x, y, round(min(255, 255 * v * rr)), round(min(255, 255 * v * rg)), round(min(255, 255 * v * rb)));\n      }\n    }\n  }\n}\n","wongoji":"// ===== Patternflow pattern =====\n// Title:   Wongoji\n// Family:  type\n// Idea:    A pen writes Yun Dong-ju's Prelude (1941) in vertical lines on Korean manuscript paper, stroke by stroke in a 9 by 11 Hangul face the pattern composes from jamo, each square cell top to bottom and the columns right to left, and turns the page when the sheet is full.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 64, after wongoji manuscript paper and the johab Hangul bitmap fonts that drew each jamo in several sets (beol) by the vowel beside it and the final under it; the poem is Yun Dong-ju's Seosi (Prelude), written 20 November 1941\n// Round:   64\n// ===============================\n// @matrix 64x128\n// @knobs Paper=0..1, Speed=0.2..3, Brush=0..1, Hand=0..1\n//\n// Knob 1: Paper. Five sheets, each holding over most of its fifth of the knob and giving way to the next in a short cross-fade: at 0 night paper with vermilion lines and cream ink that shines gold while wet, at 0.25 hanji with red lines and brown-black ink, at 0.5 white school paper with green lines and blue-black ink, at 0.75 a blackboard ruled in chalk, at 1 blueprint.\n// Knob 2: Speed. The pen draws 34 LEDs of stroke a second per unit, and its lifts and rests shorten with it: at 2 a syllable takes about a second, a sheet about 29 seconds and the whole poem, 95 syllables on four sheets, 109 seconds with its page turns; at 3 a sheet takes 20 seconds, at 0.2 over four minutes.\n// Knob 3: Brush. At 0 a pen, every stroke one LED wide and even. Turned up, the brush presses a dot beside each stroke's start, lifts at its end and runs dry here and there, and the ink bleeds into the paper round it over a second after the pen passes, up to 42 percent of full ink at 1.\n// Knob 4: Hand. The chance that a jamo is written one LED aside, 0.6 times Hand, and one LED up or down, half that: at the opening 0.06 one jamo in 28 strays aside and one in 56 up or down, at 1 three in five aside, and the page reads as a quick hand.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs, exp, hypot, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];\n\n// The sheet: 5 columns of 10 square cells, 12 LEDs apart, so each cell has\n// 11 by 11 LEDs inside its lines; a glyph is 9 wide and 11 tall. A 9 by 9\n// face in 10-LED cells gave 72 cells a sheet, but a final ㄹ under ㅡ then\n// had 3 rows and closed into a block, in 12 of the poem's 95 syllables.\nconst X0 = 1, Y0 = 3, P = 12, NC = 5, NR = 10;\n\n// Yun Dong-ju, Seosi (Prelude), November 1941. # is the title, @ the author.\nconst POEM = [\n  \"#서시\",\n  \"@윤동주\",\n  \"죽는 날까지 하늘을 우러러\",\n  \"한 점 부끄럼이 없기를,\",\n  \"잎새에 이는 바람에도\",\n  \"나는 괴로워했다.\",\n  \"별을 노래하는 마음으로\",\n  \"모든 죽어 가는 것을 사랑해야지\",\n  \"그리고 나한테 주어진 길을\",\n  \"걸어가야겠다.\",\n  \"\",\n  \"오늘 밤에도 별이 바람에 스치운다.\",\n];\n\n// ---- The face. Jamo are strokes in writing order, each a list of points\n// in a box w by h; a syllable puts them in boxes that depend on its vowel\n// and on whether it has a final, the way the johab fonts kept several\n// forms of each jamo. Over all 11,172 syllables that gives each initial 16\n// or 17 forms, each vowel 2 or 3 and each final 1: 391 jamo pictures.\nconst INI = \"g gg n d dd r m b bb s ss o j jj c k t p h\".split(\" \");\nconst FIN = \". g gg gs n nj nh d r rg rm rb rs rt rp rh m b bs s ss o j c k t p h\".split(\" \");\n\nfunction ring(w, h, ox, oy) {\n  const rw = min(w, h + 2), rh = min(h, w + 1);\n  ox += (w - rw) >> 1;\n  oy += (h - rh) >> 1;\n  const R = rw - 1, B = rh - 1, c = R >> 1;\n  const pts = rh \u003c= 2 ? [[1, 0], [R - 1, 0], [R - 1, B], [1, B]] : [[c, 0], [1, 0], [0, 1], [0, B - 1], [1, B], [R - 1, B], [R, B - 1], [R, 1], [R - 1, 0], [c + 1, 0]];\n  return pts.map(([x, y]) => [x + ox, y + oy]);\n}\n\n// Two legs from an apex: the s shape, also under the bar of j and c.\nfunction legs(w, h, y0) {\n  const c = (w - 1) >> 1, d = h - 1 - y0;\n  const xl = max(0, round(c - 1.3 * d)), xr = min(w - 1, round(c + (w % 2 ? 0 : 1) + 1.3 * d));\n  return [[[c, y0], [xl, h - 1]], [[c, y0 + max(1, round(d / 3))], [xr, h - 1]]];\n}\n\nfunction cons(k, w, h, tail) {\n  const c = (w - 1) >> 1, m = (h - 1) >> 1, S = [];\n  switch (k) {\n    case \"g\":\n      S.push(tail && h >= 6 ? [[0, 0], [w - 1, 0], [w - 1, h - 3], [w - 3, h - 1]] : [[0, 0], [w - 1, 0], [w - 1, h - 1]]);\n      break;\n    case \"n\":\n      S.push([[0, 0], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"d\":\n      S.push([[0, 0], [w - 1, 0]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"r\":\n      if (h >= 5) S.push([[0, 0], [w - 1, 0], [w - 1, m]], [[0, m], [w - 2, m]], [[0, m + 1], [0, h - 1], [w - 1, h - 1]]);\n      else {\n        // Four rows: the middle bar breaks into a step, the way ㄹ is written fast.\n        const z = w >> 1;\n        S.push([[0, 0], [w - 1, 0], [w - 1, 1], [z, 1]], [[z, 2], [0, 2], [0, h - 1], [w - 1, h - 1]]);\n      }\n      break;\n    case \"m\":\n      S.push([[0, 0], [0, h - 1]], [[0, 0], [w - 1, 0], [w - 1, h - 1]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"b\":\n      S.push([[0, 0], [0, h - 1]], [[w - 1, 0], [w - 1, h - 1]], [[1, m], [w - 2, m]], [[1, h - 1], [w - 2, h - 1]]);\n      break;\n    case \"s\":\n      S.push(...legs(w, h, 0));\n      break;\n    case \"o\":\n      S.push(ring(w, h, 0, 0));\n      break;\n    case \"j\":\n      S.push([[0, 0], [w - 1, 0]], ...legs(w, h, 1));\n      break;\n    case \"c\":\n      S.push([[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ...legs(w, h, 2));\n      break;\n    case \"k\": {\n      const mk = (h >> 1);\n      S.push([[0, 0], [w - 1, 0], [w - 1, h - 1]], [[0, mk], [w - 2, mk]]);\n      break;\n    }\n    case \"t\":\n      S.push([[0, 0], [w - 1, 0]], [[1, m], [w - 1, m]], [[0, 1], [0, h - 1], [w - 1, h - 1]]);\n      break;\n    case \"p\": {\n      const a = w >= 5 ? 1 : 0;\n      S.push([[0, 0], [w - 1, 0]], [[a, 1], [a, h - 2]], [[w - 1 - a, 1], [w - 1 - a, h - 2]], [[0, h - 1], [w - 1, h - 1]]);\n      break;\n    }\n    case \"h\":\n      S.push(w >= 7 ? [[c - 1, 0], [c + 1, 0]] : [[c, 0], [c, 0]], [[0, 1], [w - 1, 1]], ring(w, h - 2, 0, 2));\n      break;\n  }\n  return S;\n}\n\n// One consonant, or a double or cluster side by side, in a box at (x, y).\nfunction group(key, x, y, w, h, tail) {\n  const parts = [...key];\n  const out = [];\n  if (parts.length === 1) {\n    for (const s of cons(parts[0], w, h, tail)) out.push(s.map(([a, b]) => [a + x, b + y]));\n    return out;\n  }\n  const w1 = (w - 1) >> 1, w2 = w - 1 - w1;\n  for (const s of cons(parts[0], w1, h, false)) out.push(s.map(([a, b]) => [a + x, b + y]));\n  for (const s of cons(parts[1], w2, h, false)) out.push(s.map(([a, b]) => [a + x + w1 + 1, b + y]));\n  return out;\n}\n\n// Vowels. Vertical ones: the initial's width, then lines [0, x] and ticks\n// [1, x0, x1, slot] (slot 0 the middle, 1 above it, 2 below it, 3 the row\n// under a horizontal bar). Horizontal ones: ticks above [2, x], bars\n// [3, x0, x1], stems below [4, x].\nconst VV = {\n  0: [5, [0, 6], [1, 7, 8, 0]],\n  1: [5, [0, 6], [1, 7, 7, 0], [0, 8]],\n  2: [5, [0, 6], [1, 7, 8, 1], [1, 7, 8, 2]],\n  3: [5, [0, 6], [1, 7, 7, 1], [1, 7, 7, 2], [0, 8]],\n  4: [5, [1, 6, 7, 0], [0, 8]],\n  5: [4, [1, 5, 5, 0], [0, 6], [0, 8]],\n  6: [5, [1, 6, 7, 1], [1, 6, 7, 2], [0, 8]],\n  7: [4, [1, 5, 5, 1], [1, 5, 5, 2], [0, 6], [0, 8]],\n  20: [6, [0, 7]],\n};\nconst HV = { 8: [[2, 4], [3, 0, 8]], 12: [[2, 2], [2, 6], [3, 0, 8]], 13: [[3, 0, 8], [4, 4]], 17: [[3, 0, 8], [4, 2], [4, 6]], 18: [[3, 0, 8]] };\nconst MV = {\n  9: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 8, 0]]],\n  10: [5, [[2, 2], [3, 0, 4]], [[0, 6], [1, 7, 7, 0], [0, 8]]],\n  11: [6, [[2, 2], [3, 0, 5]], [[0, 7]]],\n  14: [5, [[3, 0, 4], [4, 2]], [[1, 5, 6, 3], [0, 8]]],\n  15: [4, [[3, 0, 3], [4, 2]], [[1, 5, 5, 3], [0, 6], [0, 8]]],\n  16: [6, [[3, 0, 5], [4, 3]], [[0, 7]]],\n  19: [6, [[3, 0, 5]], [[0, 7]]],\n};\n// Initials whose bottom row is clear in the middle, so the tick of ㅗ may sit\n// right under them; and initials that need four rows to read.\nconst FREE = new Set([\"g\", \"gg\", \"s\", \"ss\", \"j\", \"jj\", \"c\", \"k\"]);\nconst NEED4 = new Set([\"r\", \"b\", \"bb\", \"c\", \"k\", \"t\", \"h\"]);\n\nfunction vparts(parts, y0, y1, bar, out) {\n  const mid = (y0 + y1) >> 1;\n  for (const p of parts) {\n    if (p[0] === 0) out.push([[p[1], y0], [p[1], y1]]);\n    else {\n      const y = p[3] === 0 ? mid : p[3] === 1 ? mid - 1 : p[3] === 2 ? mid + 1 : bar + 1;\n      out.push([[p[1], y], [p[2], y]]);\n    }\n  }\n}\nfunction hparts(parts, bar, stem, out) {\n  for (const p of parts) {\n    if (p[0] === 2) out.push([[p[1], bar - 1], [p[1], bar - 1]]);\n    else if (p[0] === 3) out.push([[p[1], bar], [p[2], bar]]);\n    else out.push([[p[1], bar + 1], [p[1], bar + stem]]);\n  }\n}\n\n// The strokes of one syllable in a 9 by 11 box, each jamo moved by its own\n// offset for the Hand knob.\nfunction syllable(code, off) {\n  const s = code - 0xac00;\n  const ci = floor(s / 588), vi = floor((s % 588) / 28), fi = s % 28;\n  const ini = INI[ci], has = fi > 0, out = [], vow = [];\n  let box, fbox = FIN[fi].length > 1 ? [0, 7, 9, 4] : [1, 7, 7, 4];\n  if (VV[vi]) {\n    const [iw, ...parts] = VV[vi];\n    box = has ? [0, 0, iw, 5] : [0, 2, iw, 7];\n    vparts(parts, has ? 0 : 1, has ? 5 : 9, 0, vow);\n  } else if (HV[vi]) {\n    const up = vi === 8 || vi === 12, down = vi === 13 || vi === 17;\n    let bar = 7;\n    if (!has) {\n      box = [1, 1, 7, 5];\n      if (up) bar = 8;\n    } else if (up) {\n      box = FREE.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = 5;\n    } else if (down) {\n      box = NEED4.has(ini) ? [1, 0, 7, 4] : [1, 0, 7, 3];\n      bar = box[3] + 1;\n    } else {\n      box = [1, 0, 7, 4];\n      bar = 5;\n    }\n    hparts(HV[vi], bar, has ? 1 : 2, vow);\n  } else {\n    const [iw, hp, vp] = MV[vi];\n    const up = hp[0][0] === 2, flat = hp.length === 1;\n    let bar;\n    if (!has) {\n      box = [0, 1, iw, flat ? 5 : 4];\n      bar = up || flat ? 7 : 6;\n    } else {\n      box = [0, 0, iw, flat ? 4 : 3];\n      bar = up || flat ? 5 : 4;\n    }\n    hparts(hp, bar, has ? 1 : 2, vow);\n    vparts(vp, has ? 0 : 1, has ? 5 : 9, bar, vow);\n  }\n  const tail = !has && VV[vi] && (ini === \"g\" || ini === \"k\");\n  const mv = (list, o) => list.map((st) => st.map(([x, y]) => [x + o[0], y + o[1]]));\n  out.push(...mv(group(ini, box[0], box[1], box[2], box[3], tail), off[0]));\n  out.push(...mv(vow, off[1]));\n  if (has) out.push(...mv(group(FIN[fi], fbox[0], fbox[1], fbox[2], fbox[3], false), off[2]));\n  return out;\n}\n\n// Marks: in vertical writing the comma and the full stop sit high on the right.\nconst MARKS = { \",\": [[[5, 1], [7, 3]]], \".\": [[[6, 0], [5, 1], [6, 2], [7, 1], [6, 0]]] };\n\nfunction strokesOf(ch, off) {\n  const code = ch.codePointAt(0);\n  if (code >= 0xac00 && code \u003c= 0xd7a3) return syllable(code, off);\n  return MARKS[ch] ? MARKS[ch].map((s) => s.map(([x, y]) => [x + off[0][0], y + off[0][1]])) : [];\n}\n\n// Points to pixels, in drawing order.\nfunction raster(stroke) {\n  const px = [];\n  for (let i = 0; i \u003c stroke.length; i++) {\n    const [x0, y0] = stroke[i], [x1, y1] = stroke[min(i + 1, stroke.length - 1)];\n    const n = max(abs(x1 - x0), abs(y1 - y0));\n    for (let j = 0; j \u003c= n; j++) {\n      const x = round(x0 + ((x1 - x0) * j) / (n || 1)), y = round(y0 + ((y1 - y0) * j) / (n || 1));\n      const l = px[px.length - 1];\n      if (!l || l[0] !== x || l[1] !== y) px.push([x, y]);\n    }\n  }\n  return px;\n}\n\n// ---- The manuscript: columns of 10 cells, a new column for every line, a\n// wrapped line going on one cell down, the title in the middle of its\n// column and the author's name ending one cell from the foot of the next.\nfunction layout() {\n  const cols = [];\n  const blank = () => new Array(NR).fill(null);\n  for (const line of POEM) {\n    const col = blank();\n    if (line[0] === \"#\" || line[0] === \"@\") {\n      const t = [...line.slice(1)];\n      const s = line[0] === \"#\" ? (NR - t.length) >> 1 : NR - 1 - t.length;\n      t.forEach((ch, i) => (col[s + i] = ch));\n      cols.push(col);\n      continue;\n    }\n    let cur = col, r = 0;\n    for (const word of line.split(\" \").filter(Boolean)) {\n      const chs = [...word];\n      if (r > 0 && r + 1 + chs.length > NR) {\n        cols.push(cur);\n        cur = blank();\n        r = 1;\n      } else if (r > 0) r++;\n      for (const ch of chs) cur[r++] = ch;\n    }\n    cols.push(cur);\n  }\n  const cells = [];\n  cols.forEach((col, ci) => col.forEach((ch, r) => ch && cells.push({ page: floor(ci / NC), col: ci % NC, row: r, ch, rnd: [0, 1, 2, 3, 4, 5].map(() => Math.random()) })));\n  return { cells, pages: Math.ceil(cols.length / NC) };\n}\n\nconst cellX = (c) => X0 + P * (NC - 1 - c) + 2;\nconst cellY = (r) => Y0 + P * r + 1;\n\n// Paper, grid, ink, fresh ink and the pen, for the Paper knob: night paper\n// with vermilion lines, hanji with red, school paper with green, a\n// blackboard with chalk, and blueprint.\nconst SETS = [\n  [[3, 4, 10], [196, 58, 40], [236, 230, 212], [255, 214, 140], [255, 196, 96]],\n  [[232, 218, 186], [206, 64, 46], [26, 20, 16], [96, 36, 26], [150, 30, 20]],\n  [[224, 232, 220], [46, 148, 92], [24, 36, 124], [70, 110, 230], [40, 70, 220]],\n  [[14, 44, 30], [150, 190, 120], [236, 240, 226], [255, 250, 190], [255, 255, 255]],\n  [[8, 20, 56], [72, 146, 210], [226, 236, 255], [150, 220, 255], [255, 255, 255]],\n];\n\nexport function setup(params) {\n  const S = (params.s = { ...layout(), started: false, t: 0 });\n  S.ink = new Float32Array(N);\n  S.when = new Float32Array(N);\n  S.halo = new Float32Array(N);\n  S.glow = new Float32Array(N);\n  S.leaf = new Float32Array(N);\n  S.grid = new Float32Array(N);\n  for (let y = Y0; y \u003c= Y0 + P * NR; y++)\n    for (let x = X0; x \u003c= X0 + P * NC; x++) {\n      const vx = (x - X0) % P === 0, hy = (y - Y0) % P === 0;\n      if (!vx && !hy) continue;\n      const edge = x === X0 || x === X0 + P * NC || y === Y0 || y === Y0 + P * NR;\n      S.grid[y * W + x] = edge ? 1 : 0.5;\n    }\n  S.F = new Float32Array(N * 3);\n}\n\n// Ink one LED, light the paper round it for a moment, and with the Brush up\n// let the ink bleed into its four neighbours.\nfunction inkAt(S, x, y, a, t) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  if (a > S.ink[p]) S.ink[p] = a;\n  S.when[p] = t;\n  for (let dy = -1; dy \u003c= 1; dy++)\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const xx = x + dx, yy = y + dy;\n      if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) S.glow[yy * W + xx] = t;\n    }\n  const b = S.brush;\n  if (b > 0)\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n      const q = p + dy * W + dx, xx = x + dx;\n      if (xx \u003c 0 || xx >= W || q \u003c 0 || q >= N) continue;\n      const v = 0.42 * b * a;\n      if (v > S.halo[q]) S.halo[q] = v;\n    }\n}\n\nfunction prepare(S, cell) {\n  // The hand: each jamo steps one LED aside with a chance of 0.6 Hand, and\n  // one LED up or down with half that.\n  const o = (i, k) => {\n    const r = cell.rnd[i] * 2 - 1;\n    return abs(r) > 1 - 0.6 * k * S.hand ? Math.sign(r) : 0;\n  };\n  const off = [[o(0, 1), o(1, 0.5)], [o(2, 1), o(3, 0.5)], [o(4, 1), o(5, 0.5)]];\n  const x = cellX(cell.col), y = cellY(cell.row);\n  cell.px = strokesOf(cell.ch, off).map((st) => raster(st).map(([a, b]) => [a + x, b + y]));\n}\n\n// A stroke's LEDs from `from` up to `upto`. With the Brush up it presses a\n// dot beside the stroke's start, lifts at its end and runs dry here and there.\nfunction inkStroke(S, st, upto, from, t) {\n  const b = S.brush, n = st.length;\n  for (let i = from; i \u003c upto; i++) {\n    const [x, y] = st[i];\n    let a = 1;\n    if (b > 0) {\n      if (i === n - 1 && n > 2) a = 1 - 0.35 * b;\n      else if (i > 0) a = 1 - 0.3 * b * Math.random();\n    }\n    inkAt(S, x, y, a, t);\n    if (i === 0 && b > 0.05) inkAt(S, x - 1, y, 0.55 * b, t);\n  }\n}\n\nfunction startPage(S, page) {\n  S.page = page;\n  S.ink.fill(0);\n  S.halo.fill(0);\n  S.when.fill(-99);\n  S.glow.fill(-99);\n}\n\n// The pen: writes, lifts between strokes, rests between cells, and at the\n// foot of a page waits, then the page turns.\nfunction step(S, dt) {\n  S.t += dt;\n  const v = 34 * S.speed, q = 2 / S.speed;\n  let left = dt;\n  while (left > 0) {\n    if (S.mode === \"wait\") {\n      const u = min(left, S.timer);\n      S.timer -= u;\n      left -= u;\n      if (S.timer > 0) return;\n      S.mode = S.next;\n      if (S.mode === \"turn\") {\n        S.leaf.set(S.ink);\n        S.leafHalo = Float32Array.from(S.halo);\n        S.turn = 0;\n        const done = S.ci >= S.cells.length;\n        if (done) S.ci = 0;\n        startPage(S, S.cells[S.ci].page);\n        S.mode = \"turning\";\n      }\n      continue;\n    }\n    if (S.mode === \"turning\") {\n      S.turn += left / 1.6;\n      left = 0;\n      if (S.turn >= 1) {\n        S.turn = 0;\n        S.mode = \"cell\";\n      }\n      return;\n    }\n    if (S.mode === \"cell\") {\n      if (S.ci >= S.cells.length) {\n        S.mode = \"wait\";\n        S.timer = 4;\n        S.next = \"turn\";\n        continue;\n      }\n      const cell = S.cells[S.ci];\n      if (cell.page !== S.page) {\n        S.mode = \"wait\";\n        S.timer = 1.2;\n        S.next = \"turn\";\n        continue;\n      }\n      prepare(S, cell);\n      S.si = 0;\n      S.pos = 0;\n      S.mode = \"lift\";\n      S.from = S.pen;\n      const to = cell.px[0] ? cell.px[0][0] : S.pen;\n      S.lift = 0;\n      S.liftT = 0.12 * q + hypot(to[0] - S.pen[0], to[1] - S.pen[1]) / (4 * v);\n      continue;\n    }\n    if (S.mode === \"lift\") {\n      const cell = S.cells[S.ci];\n      const u = min(left, S.liftT - S.lift);\n      S.lift += u;\n      left -= u;\n      const to = cell.px[S.si] ? cell.px[S.si][0] : S.pen;\n      const f = S.lift / S.liftT;\n      S.nib = [S.from[0] + (to[0] - S.from[0]) * f, S.from[1] + (to[1] - S.from[1]) * f];\n      if (S.lift \u003c S.liftT) return;\n      if (!cell.px[S.si]) {\n        S.ci++;\n        S.mode = \"cell\";\n        continue;\n      }\n      S.mode = \"draw\";\n      S.pos = 0;\n      S.done = 0;\n      continue;\n    }\n    if (S.mode === \"draw\") {\n      const cell = S.cells[S.ci], st = cell.px[S.si];\n      const u = min(left, (st.length - S.pos) / v);\n      S.pos += u * v;\n      left -= u;\n      const upto = min(st.length, floor(S.pos) + 1);\n      inkStroke(S, st, upto, S.done, S.t - left);\n      S.done = upto;\n      S.pen = st[upto - 1];\n      S.nib = S.pen;\n      if (S.done \u003c st.length) return;\n      S.si++;\n      S.from = S.pen;\n      S.mode = \"lift\";\n      S.lift = 0;\n      const to = cell.px[S.si] ? cell.px[S.si][0] : S.pen;\n      S.liftT = (cell.px[S.si] ? 0.05 : 0.1) * q + hypot(to[0] - S.pen[0], to[1] - S.pen[1]) / (4 * v);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  dt = cl(dt || 0, 0, 0.1);\n  S.paper = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.brush = cl(k[2], 0, 1);\n  S.hand = cl(k[3], 0, 1);\n  if (!S.started) {\n    S.started = true;\n    // The panel opens on the first sheet with the title, the author and the\n    // first column of the poem already written, and the pen has been at the\n    // next column for four seconds at the knob's speed.\n    startPage(S, 0);\n    S.ci = 0;\n    while (S.cells[S.ci].page === 0 && S.cells[S.ci].col \u003c 3) {\n      const cell = S.cells[S.ci++];\n      prepare(S, cell);\n      for (const st of cell.px) inkStroke(S, st, st.length, 0, -50);\n    }\n    S.pen = [cellX(2) + 4, cellY(9) + 6];\n    S.nib = S.pen;\n    S.mode = \"cell\";\n    for (let i = 0; i \u003c 120; i++) step(S, 1 / 30);\n  }\n  step(S, dt);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  // Each set holds over most of its stretch of the knob and gives way to the\n  // next in a short cross-fade, so no muddy half-way sheet lasts long.\n  const u = S.paper * 4, i0 = min(3, floor(u)), f = u - i0, sm = cl((f - 0.3) / 0.4, 0, 1);\n  const [paper, grid, ink, wet, pen] = [0, 1, 2, 3, 4].map((j) => mix(SETS[i0][j], SETS[i0 + 1][j], sm * sm * (3 - 2 * sm)));\n  const inner = mix(paper, grid, 0.5), glowC = mix(ink, wet, 0.35);\n  const F = S.F, t = S.t;\n  // One LED of a sheet: paper or line, then ink, then the bleed round the\n  // ink, which spreads for a second after the pen passes; on the sheet being\n  // written, fresh ink and the paper round it glow for a moment.\n  const shade = (p, I, Hh, fresh, out, o) => {\n    const g = S.grid[p], c = g ? (g === 1 ? grid : inner) : paper;\n    let a = I[p];\n    if (Hh[p] > a) {\n      const age = t - S.glow[p], h = Hh[p] * (fresh && age \u003c 4 ? 1 - exp(-age / 0.6) : 1);\n      if (h > a) a = h;\n    }\n    let r = c[0] + (ink[0] - c[0]) * a, gg = c[1] + (ink[1] - c[1]) * a, b = c[2] + (ink[2] - c[2]) * a;\n    if (fresh) {\n      const age = t - (I[p] > 0 ? S.when[p] : S.glow[p]);\n      if (age \u003c 4) {\n        const w = I[p] > 0 ? 0.75 * exp(-age / 0.8) : 0.32 * exp(-age / 0.5), c2 = I[p] > 0 ? wet : glowC;\n        r += (c2[0] - r) * w;\n        gg += (c2[1] - gg) * w;\n        b += (c2[2] - b) * w;\n      }\n    }\n    out[o] = r;\n    out[o + 1] = gg;\n    out[o + 2] = b;\n  };\n  for (let p = 0; p \u003c N; p++) shade(p, S.ink, S.halo, true, F, p * 3);\n  // The pen's nib, bright while it writes and dimmer while it is lifted.\n  if (S.mode !== \"turning\" && S.nib) {\n    const [nx, ny] = S.nib, down = S.mode === \"draw\";\n    const x = round(nx), y = round(ny);\n    const k = down ? 1 : 0.6;\n    for (const [dx, dy, a] of [[0, 0, 1], [1, 0, 0.5], [-1, 0, 0.5], [0, 1, 0.5], [0, -1, 0.5], [1, 1, 0.22], [-1, 1, 0.22], [1, -1, 0.22], [-1, -1, 0.22]]) {\n      const X = x + dx, Y = y + dy;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const o = (Y * W + X) * 3;\n      for (let j = 0; j \u003c 3; j++) F[o + j] += (pen[j] - F[o + j]) * a * k;\n    }\n  }\n  // A turning page: the written leaf folds over towards the binding at the\n  // right edge, shading as it goes, over the fresh sheet.\n  if (S.mode === \"turning\") {\n    const e = S.turn * S.turn * (3 - 2 * S.turn), th = (e * PI) / 2, lw = W * cos(th);\n    const edge = W - lw, tmp = [0, 0, 0];\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const o = (y * W + x) * 3;\n        if (x >= edge && lw > 0.5) {\n          const sx = floor(W - ((W - x - 0.5) * W) / lw);\n          shade(y * W + cl(sx, 0, W - 1), S.leaf, S.leafHalo, false, tmp, 0);\n          const l = 0.45 + 0.55 * cos(th) + 0.25 * exp(-(x - edge) / 2) * (1 - cos(th));\n          F[o] = tmp[0] * l;\n          F[o + 1] = tmp[1] * l;\n          F[o + 2] = tmp[2] * l;\n        } else {\n          const d = 1 - 0.6 * exp(-(edge - x) / 5) * (1 - e);\n          F[o] *= d;\n          F[o + 1] *= d;\n          F[o + 2] *= d;\n        }\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(min(255, F[o])), round(min(255, F[o + 1])), round(min(255, F[o + 2])));\n}\n","excursion-sets":"// ===== Patternflow pattern =====\n// Title:   Excursion Sets\n// Family:  noise\n// Idea:    A smooth Gaussian random field on a 64 by 96 torus is cut at a level that sweeps up and down, each island of the set above the level filled in a cool tint and each lake inside land in pink, while the strip below plots islands minus lakes, the Euler characteristic, against the level, the dots gathering round the curve u e^(-u^2/2) that Adler's formula predicts.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler characteristic of Gaussian excursion sets (Robert Adler and Abraham Hasofer, 1976; Robert Adler, 1981), its use on brain images (Keith Worsley, 1992), bit-quad counting (Stephen Gray, 1971), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=3..8, Level=-1.5..1.5\n//\n// Knob 1: Hue. Turns the islands and lakes round the wheel together. At 0 the islands are cyan, going azure the higher their peak stands above the level, and the lakes pink, going violet the deeper they are; at 0.5 the islands go red to orange and the lakes green. The land that winds round the torus stays a dim teal and the sea black, whatever the knob.\n// Knob 2: Speed. At 2 the level climbs from -2.40 to 2.52 in 12 s and comes back in 12 s, and every wave of the field turns at its own rate of up to 0.35 rad/s, so the field forgets itself in about 9 s (pi / 0.35). At 0.2 ten times slower; at 3 one and a half times faster.\n// Knob 3: Scale. The width sigma in LEDs of the Gaussian that blurs white noise into the field. At 3 the expected count at u = 1 is 13.1 islands more than lakes, and 240 independent fields gave 13.3 (and -13.0 at u = -1); at 5 it is 4.7 and they gave 4.6; at 8 it is 1.8. The plot is scaled so the curve always peaks 11 rows from its axis.\n// Knob 4: Level. The middle of the sweep, its span shrinking as it moves off centre. At the opening 0.06 the level swings from -2.40 to 2.52 and the dots draw the whole curve; at 1.5 it swings from 0 to 3 and the panel stays among islands, at -1.5 from -3 to 0 among lakes.\n//\n// On a torus the Euler characteristic and the boundary length of the domain\n// are 0, so of Adler's three terms only the area's is left:\n// E chi{f >= u} = A sqrt(lx ly) (2 pi)^(-3/2) u e^(-u^2/2), with A = 64 x 96\n// and lx = ly = 1 / (2 sigma^2) the variance of the field's slope.\n\nconst W = 64, FH = 96, A = W * FH, H = 128;\nconst { floor, round, min, max, abs, exp, sqrt, cos, sin, PI, random, log } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nfunction gauss() {\n  let u = 0;\n  while (u === 0) u = random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * random());\n}\n\n// 3 x 5 digits for the two counts.\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\n\n// The strip: its axis row, and the rows above and below the axis the curve\n// may use at its peak.\nconst AXIS = 112, PEAK_ROWS = 11, U_MAX = 3;\nconst OMEGA = 0.35, SWEEP = 12;\n\nexport function setup(params) {\n  params.s = {\n    sigma: 0, modes: 0, mm: null, nn: null, c0r: null, c0i: null, om: null, th: null,\n    M: 0, cx: null, sx: null, cy: null, sy: null, gr: null, gi: null,\n    f: new Float32Array(A), lab: new Int32Array(A), ux: new Int16Array(A), uy: new Int16Array(A),\n    stack: new Int32Array(A), cWrap: new Uint8Array(A), cExt: new Float32Array(A), cSet: new Uint8Array(A), cArea: new Int32Array(A),\n    hits: new Float32Array(W * 32), hitSign: new Int8Array(W * 32),\n    phase: -0.21, u: 0, chi: 0, blobs: 0, holes: 0, peak: 1, hue: 0, c: [0, 0, 0],\n  };\n}\n\n// The field is the real part of a sum of plane waves e^(ik.x) over the\n// torus's own wave vectors, each with a complex Gaussian amplitude of\n// variance exp(-sigma^2 k^2): white noise blurred by a Gaussian of width\n// sigma, whose covariance is exp(-r^2 / 4 sigma^2). Waves past |k| = 3.4 /\n// sigma carry less than 1e-5 of the variance and are left out.\nfunction build(S, sigma) {\n  S.sigma = sigma;\n  const kc = 3.4 / sigma, M = Math.ceil((kc * W) / (2 * PI)), N = Math.ceil((kc * FH) / (2 * PI));\n  const mm = [], nn = [], amp = [];\n  let sum = 0, lx = 0, ly = 0;\n  for (let m = -M; m \u003c= M; m++)\n    for (let n = -N; n \u003c= N; n++) {\n      const kx = (2 * PI * m) / W, ky = (2 * PI * n) / FH, k2 = kx * kx + ky * ky;\n      if (k2 > kc * kc) continue;\n      const sp = exp(-sigma * sigma * k2);\n      mm.push(m);\n      nn.push(n);\n      amp.push(sqrt(sp / 2));\n      sum += sp;\n      lx += sp * kx * kx;\n      ly += sp * ky * ky;\n    }\n  const K = mm.length, norm = 1 / sqrt(sum / 2);\n  S.modes = K;\n  S.M = M;\n  S.mm = Int8Array.from(mm);\n  S.nn = Int8Array.from(nn);\n  S.c0r = new Float32Array(K);\n  S.c0i = new Float32Array(K);\n  S.om = new Float32Array(K);\n  S.th = new Float32Array(K);\n  for (let i = 0; i \u003c K; i++) {\n    S.c0r[i] = amp[i] * gauss() * norm;\n    S.c0i[i] = amp[i] * gauss() * norm;\n    S.om[i] = OMEGA * (2 * random() - 1);\n    S.th[i] = 2 * PI * random();\n  }\n  // Second spectral moments of the unit-variance field, and from them the\n  // expected Euler characteristic at its peak u = 1: A sqrt(lx ly) (2 pi)^-3/2 e^-1/2.\n  S.lam = sqrt(lx * ly) / sum;\n  S.peak = A * S.lam * Math.pow(2 * PI, -1.5) * exp(-0.5);\n  const MW = 2 * M + 1, NW = 2 * N + 1;\n  S.cx = new Float32Array(MW * W);\n  S.sx = new Float32Array(MW * W);\n  for (let m = -M; m \u003c= M; m++)\n    for (let x = 0; x \u003c W; x++) {\n      const a = (2 * PI * m * x) / W;\n      S.cx[(m + M) * W + x] = cos(a);\n      S.sx[(m + M) * W + x] = sin(a);\n    }\n  S.N = N;\n  S.cy = new Float32Array(NW * FH);\n  S.sy = new Float32Array(NW * FH);\n  for (let n = -N; n \u003c= N; n++)\n    for (let y = 0; y \u003c FH; y++) {\n      const a = (2 * PI * n * y) / FH;\n      S.cy[(n + N) * FH + y] = cos(a);\n      S.sy[(n + N) * FH + y] = sin(a);\n    }\n  S.gr = new Float32Array(MW * FH);\n  S.gi = new Float32Array(MW * FH);\n  S.hits.fill(0);\n}\n\n// The expected Euler characteristic of {f >= u} on the torus: its Euler\n// characteristic and boundary length are 0, so of the three terms of the\n// kinematic formula only the area's is left.\n// The fill of an island or a lake fades as it grows, from v at 60 LEDs to\n// half of v at 1000, so the big ones near the median do not swamp the panel.\nconst fillOf = (area, v) => v * (1 - 0.5 * cl(Math.log(area / 60) / Math.log(1000 / 60), 0, 1));\n\nconst expected = (S, u) => S.peak * exp(0.5) * u * exp(-u * u / 2);\n\nfunction synth(S) {\n  const { M, N, gr, gi, cy, sy, cx, sx, f, mm, nn, c0r, c0i, th } = S;\n  gr.fill(0);\n  gi.fill(0);\n  for (let i = 0; i \u003c S.modes; i++) {\n    const c = cos(th[i]), s = sin(th[i]);\n    const ar = c0r[i] * c - c0i[i] * s, ai = c0r[i] * s + c0i[i] * c;\n    const go = (mm[i] + M) * FH, yo = (nn[i] + N) * FH;\n    for (let y = 0; y \u003c FH; y++) {\n      const ey = cy[yo + y], fy = sy[yo + y];\n      gr[go + y] += ar * ey - ai * fy;\n      gi[go + y] += ar * fy + ai * ey;\n    }\n  }\n  const MW = 2 * M + 1;\n  for (let y = 0; y \u003c FH; y++) {\n    const row = y * W;\n    for (let x = 0; x \u003c W; x++) f[row + x] = 0;\n    for (let j = 0; j \u003c MW; j++) {\n      const a = gr[j * FH + y], b = gi[j * FH + y], o = j * W;\n      for (let x = 0; x \u003c W; x++) f[row + x] += a * cx[o + x] - b * sx[o + x];\n    }\n  }\n}\n\nconst N8X = [1, -1, 0, 0, 1, 1, -1, -1], N8Y = [0, 0, 1, -1, 1, -1, 1, -1];\n\n// Components of the lit set, eight-connected, and of the dark set,\n// four-connected, so the two count each other's holes. Each pixel keeps its\n// unwrapped position from the fill; reaching a pixel of the same component at\n// another position means the component winds round the torus. Islands minus\n// lakes, counting only the components that do not wind, is the Euler\n// characteristic Gray's bit quads give; the two agreed on all 640 fields\n// tried, each cut at 11 levels.\nfunction label(S, u) {\n  const { f, lab, ux, uy, stack, cWrap, cExt, cSet, cArea } = S;\n  lab.fill(-1);\n  let id = 0, blobs = 0, holes = 0;\n  for (let p = 0; p \u003c A; p++) {\n    if (lab[p] >= 0) continue;\n    const lit = f[p] >= u, nb = lit ? 8 : 4;\n    let sp = 0, wraps = 0, ext = f[p], area = 1;\n    lab[p] = id;\n    ux[p] = p & 63;\n    uy[p] = p >> 6;\n    stack[sp++] = p;\n    while (sp) {\n      const q = stack[--sp], qx = ux[q], qy = uy[q];\n      for (let k = 0; k \u003c nb; k++) {\n        const x = qx + N8X[k], y = qy + N8Y[k];\n        const r = (((y % FH) + FH) % FH) * W + (x & 63);\n        if ((f[r] >= u) !== lit) continue;\n        if (lab[r] === id) {\n          if (ux[r] !== x || uy[r] !== y) wraps = 1;\n          continue;\n        }\n        lab[r] = id;\n        ux[r] = x;\n        uy[r] = y;\n        stack[sp++] = r;\n        area++;\n        const v = f[r];\n        if (lit ? v > ext : v \u003c ext) ext = v;\n      }\n    }\n    cWrap[id] = wraps;\n    cExt[id] = ext;\n    cSet[id] = lit ? 1 : 0;\n    cArea[id] = area;\n    if (!wraps) {\n      if (lit) blobs++;\n      else holes++;\n    }\n    id++;\n  }\n  S.blobs = blobs;\n  S.holes = holes;\n  S.chi = blobs - holes;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), sigma = cl(k[2], 3, 8), c = cl(k[3], -1.5, 1.5);\n  if (abs(sigma - S.sigma) > 0.04) build(S, sigma);\n  const r = (d * speed) / 2;\n  for (let i = 0; i \u003c S.modes; i++) S.th[i] += S.om[i] * r;\n  // A triangle wave with rounded turns, so the level spends equal time at\n  // every height between them.\n  S.phase += r / (2 * SWEEP);\n  const tri = (2 / PI) * Math.asin(0.985 * sin(2 * PI * S.phase)) / ((2 / PI) * Math.asin(0.985));\n  const span = 2.5 - (2 / 3) * abs(c);\n  S.u = c + span * tri;\n  synth(S);\n  label(S, S.u);\n  // The count lands in the strip at the level's column and fades over 20 s.\n  const fade = exp(-r / 10);\n  for (let i = 0; i \u003c S.hits.length; i++) S.hits[i] *= fade;\n  const col = round(((S.u + U_MAX) / (2 * U_MAX)) * (W - 1));\n  const row = round(AXIS - S.chi * (PEAK_ROWS / S.peak)) - 96;\n  if (col >= 0 && col \u003c W && row >= 1 && row \u003c 32) {\n    S.hits[row * W + col] = 1;\n    S.hitSign[row * W + col] = S.chi > 0 ? 1 : S.chi \u003c 0 ? -1 : 0;\n  }\n}\n\nfunction digits(display, n, x0, y0, rgb, alignRight) {\n  const s = String(n);\n  let x = alignRight ? x0 - 4 * s.length + 1 : x0;\n  for (let i = 0; i \u003c s.length; i++, x += 4) {\n    const g = DIG[s.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++)\n      for (let q = 0; q \u003c 3; q++) if (g[r * 3 + q] === \"1\") display.setPixel(x + q, y0 + r, rgb[0], rgb[1], rgb[2]);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cx) return;\n  const { f, lab, cWrap, cExt, cSet, cArea, c } = S, u = S.u, h = S.hue;\n  const hb = h + 0.5, hh = h + 0.87;\n  for (let p = 0; p \u003c A; p++) {\n    const id = lab[p], x = p & 63, y = p >> 6;\n    const lit = cSet[id] === 1;\n    // An edge pixel has a four-neighbour on the other side of the level.\n    const L = (x + 63) & 63, R = (x + 1) & 63, U = ((y + FH - 1) % FH) * W, D = ((y + 1) % FH) * W, row = y * W;\n    const edge = (f[row + L] >= u) !== lit || (f[row + R] >= u) !== lit || (f[U + x] >= u) !== lit || (f[D + x] >= u) !== lit;\n    if (lit) {\n      if (cWrap[id]) hsv(0.54, 0.55, edge ? 0.5 : 0.2, c);\n      else {\n        // An island's tint follows how far its peak stands above the level.\n        const t = cl((cExt[id] - u) / 1.6, 0, 1);\n        hsv(hb + 0.11 * t, 0.85 - 0.25 * (1 - t), edge ? 1 : fillOf(cArea[id], 0.5), c);\n      }\n    } else if (cWrap[id]) {\n      c[0] = c[1] = c[2] = 0;\n    } else {\n      const t = cl((u - cExt[id]) / 1.6, 0, 1);\n      hsv(hh - 0.07 * t, 0.6, edge ? 1 : fillOf(cArea[id], 0.45), c);\n    }\n    display.setPixel(x, y, c[0], c[1], c[2]);\n  }\n\n  // The strip: the axis, the expected curve, the counts so far, the level.\n  for (let y = 96; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n  const sc = PEAK_ROWS / S.peak, b = [0, 0, 0], o = [0, 0, 0];\n  hsv(hb + 0.05, 0.85, 1, b);\n  hsv(hh, 0.7, 1, o);\n  for (let x = 0; x \u003c W; x++) {\n    display.setPixel(x, AXIS, 34, 34, 40);\n    display.setPixel(x, 96, 30, 30, 36);\n  }\n  for (let i = 0; i \u003c 32 * W; i++) {\n    const v = S.hits[i];\n    if (v \u003c 0.04) continue;\n    const s = S.hitSign[i], col = s > 0 ? b : s \u003c 0 ? o : [200, 200, 200];\n    const a = 0.25 + 0.75 * v;\n    display.setPixel(i & 63, 96 + (i >> 6), col[0] * a, col[1] * a, col[2] * a);\n  }\n  let prev = null;\n  for (let x = 0; x \u003c W; x++) {\n    const uu = -U_MAX + (2 * U_MAX * x) / (W - 1), yy = AXIS - expected(S, uu) * sc;\n    const lo = prev === null ? yy : min(yy, prev), hi = prev === null ? yy : max(yy, prev);\n    for (let y = floor(lo); y \u003c= Math.ceil(hi); y++) {\n      if (y \u003c 97 || y > 127) continue;\n      const w = y \u003c lo ? 1 - (lo - y) : y > hi ? 1 - (y - hi) : 1;\n      if (w \u003c= 0) continue;\n      const g = 150 * w + 40;\n      display.setPixel(x, y, g, g, g + 10);\n    }\n    prev = yy;\n  }\n  const col = round(((u + U_MAX) / (2 * U_MAX)) * (W - 1));\n  for (let y = 97; y \u003c H; y++) display.setPixel(col, y, 60, 60, 70);\n  const ry = round(AXIS - S.chi * sc);\n  const now = S.chi > 0 ? b : S.chi \u003c 0 ? o : [255, 255, 255];\n  for (let dy = -1; dy \u003c= 1; dy++)\n    for (let dx = -1; dx \u003c= 1; dx++) {\n      const yy = ry + dy, xx = col + dx;\n      if (yy >= 97 && yy \u003c H && xx >= 0 && xx \u003c W && (dx === 0 || dy === 0)) display.setPixel(xx, yy, now[0], now[1], now[2]);\n    }\n  // Islands at the top left, lakes at the bottom right, where the curve\n  // never goes.\n  digits(display, S.blobs, 1, 98, b, false);\n  digits(display, S.holes, 62, 122, o, true);\n}\n","izhikevich-network":"// ===== Patternflow pattern =====\n// Title:   Izhikevich Network\n// Family:  rhythm\n// Idea:    A thousand of Izhikevich's model neurons, 800 excitatory and 200 inhibitory with random synapses and noisy thalamic input, write their spike raster down the panel two milliseconds a row, so the population rhythms stand as horizontal bands of synchrony.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: simple model of spiking neurons (Eugene Izhikevich, 2003), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drive=-1.5..3, Inhibition=0.8..1.6\n//\n// Knob 1: Hue. Turns both kinds of cell round the wheel together, skipping red-orange to orange, which reads brown when dim. At 0 the 800 excitatory cells are azure and the 200 inhibitory cells magenta; a column that fires two or more spikes in one row goes paler, toward white.\n// Knob 2: Speed. At 2 the raster moves 14 rows a second, 28 ms of the network, so it runs 36 times slower than a brain and the panel holds the last 256 ms; at 0.2 it moves 1.4 rows a second, at 3, 21.\n// Knob 3: Drive. The thalamic noise: each excitatory cell gets 5 + Drive mV times a fresh Gaussian every millisecond and each inhibitory cell 0.4 of that, so 0 is the paper's 5 and 2. At -1.5 the cells fire 1.6 times a second and the panel is nearly dark; at -1, 4.2 times in bursts 180 to 900 ms apart; at 0, 8.5 times in bursts every 124 ms; at 3, 15 times, and the bands break into a 50 Hz ripple.\n// Knob 4: Inhibition. Scales every inhibitory synapse against the paper's. At 0.8 the network locks into a burst every 124 ms, 8.1 Hz, with an autocorrelation of 0.63; at 1, the paper's network, the bursts loosen to 0.16 and a weak ripple near 30 Hz shows between them; at 1.6 the bursts are gone and a 38 Hz rhythm runs through the raster as thin stripes 13 rows apart.\n// Buttons: K1 tap gives every cell 12 mV more input for 2 ms: the whole network fires one volley about 18 ms long, falls silent for about 120 ms and comes back in a burst.\n\nconst W = 64, H = 128, NE = 800, NI = 200, N = NE + NI, EC = 50, MS = 2, KICK = 12;\nconst { floor, sqrt, log, cos, sin, PI, min } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// A fixed generator, so the network is the same one every time the pattern\n// opens and each knob setting means the same rhythm.\nfunction mulberry(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nexport function setup(params) {\n  const rnd = mulberry(2003);\n  const a = new Float32Array(N), b = new Float32Array(N), c = new Float32Array(N), d = new Float32Array(N);\n  const col = new Uint8Array(N);\n  // Izhikevich's listing draws re and ri uniform on [0, 1]; here they are\n  // drawn sorted, so the columns run from regular spiking on the left to\n  // chattering cells, and the inhibitory ones from slow to fast.\n  const re = Array.from({ length: NE }, rnd).sort((x, y) => x - y);\n  const ri = Array.from({ length: NI }, rnd).sort((x, y) => x - y);\n  for (let i = 0; i \u003c NE; i++) {\n    const r2 = re[i] * re[i];\n    a[i] = 0.02; b[i] = 0.2; c[i] = -65 + 15 * r2; d[i] = 8 - 6 * r2;\n    col[i] = floor((i * EC) / NE);\n  }\n  for (let k = 0; k \u003c NI; k++) {\n    const i = NE + k;\n    a[i] = 0.02 + 0.08 * ri[k]; b[i] = 0.25 - 0.05 * ri[k]; c[i] = -65; d[i] = 2;\n    col[i] = EC + floor((k * (W - EC)) / NI);\n  }\n  // The weights S(i, j) are stored by the firing cell j, so a spike adds\n  // one run of 1000 numbers and a quiet cell costs nothing.\n  const S = new Float32Array(N * N);\n  for (let j = 0; j \u003c N; j++) {\n    const o = j * N;\n    if (j \u003c NE) for (let i = 0; i \u003c N; i++) S[o + i] = 0.5 * rnd();\n    else for (let i = 0; i \u003c N; i++) S[o + i] = -rnd();\n  }\n  const v = new Float64Array(N).fill(-65), u = new Float64Array(N);\n  for (let i = 0; i \u003c N; i++) u[i] = b[i] * v[i];\n  params.s = {\n    a, b, c, d, col, S, v, u, I: new Float32Array(N), fired: new Int32Array(N),\n    rnd: mulberry(1963), spare: 0, hasSpare: false,\n    rows: new Uint8Array(W * H), cur: new Uint8Array(W), head: 0, acc: 0,\n    fresh: true, hue: 0, drive: 5, inh: 1, kick: 0, rgb: [0, 0, 0],\n  };\n}\n\nfunction randn(S) {\n  if (S.hasSpare) { S.hasSpare = false; return S.spare; }\n  let x = S.rnd();\n  while (x === 0) x = S.rnd();\n  const r = sqrt(-2 * log(x)), th = 2 * PI * S.rnd();\n  S.spare = r * sin(th);\n  S.hasSpare = true;\n  return r * cos(th);\n}\n\n// One millisecond of the network, as in the paper's listing: thalamic noise,\n// reset of the cells at 30 mV, their synapses, and two half steps of v.\nfunction step(S) {\n  const { a, b, c, d, v, u, I, fired, col, cur } = S;\n  const gE = S.drive, gI = 0.4 * S.drive, wI = S.inh;\n  const kick = S.kick > 0 ? (S.kick--, KICK) : 0;\n  for (let i = 0; i \u003c NE; i++) I[i] = gE * randn(S) + kick;\n  for (let i = NE; i \u003c N; i++) I[i] = gI * randn(S) + kick;\n  let nf = 0;\n  for (let i = 0; i \u003c N; i++)\n    if (v[i] >= 30) {\n      fired[nf++] = i;\n      v[i] = c[i];\n      u[i] += d[i];\n      if (cur[col[i]] \u003c 255) cur[col[i]]++;\n    }\n  const Sw = S.S;\n  for (let k = 0; k \u003c nf; k++) {\n    const j = fired[k], o = j * N, w = j \u003c NE ? 1 : wI;\n    for (let i = 0; i \u003c N; i++) I[i] += w * Sw[o + i];\n  }\n  for (let i = 0; i \u003c N; i++) {\n    let x = v[i];\n    const ui = u[i], Ii = I[i];\n    x += 0.5 * (0.04 * x * x + 5 * x + 140 - ui + Ii);\n    x += 0.5 * (0.04 * x * x + 5 * x + 140 - ui + Ii);\n    v[i] = x;\n    u[i] = ui + a[i] * (b[i] * x - ui);\n  }\n}\n\n// Ends the row being written: it becomes the top row and the rest move down.\nfunction pushRow(S) {\n  S.head = (S.head + H - 1) % H;\n  S.rows.set(S.cur, S.head * W);\n  S.cur.fill(0);\n}\n\nfunction runRows(S, n) {\n  for (let r = 0; r \u003c n; r++) {\n    for (let m = 0; m \u003c MS; m++) step(S);\n    pushRow(S);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.drive = 5 + cl(k[2], -1.5, 3);\n  S.inh = cl(k[3], 0.8, 1.6);\n  if (input.btnPressed && input.btnPressed[0]) S.kick = 2;\n  if (S.fresh) {\n    // The paper's run starts every cell at -65 mV, and the first 50 ms are\n    // one big volley with 100 quiet ones after it. The panel opens 300 ms\n    // in, already full.\n    S.fresh = false;\n    for (let m = 0; m \u003c 300; m++) step(S);\n    S.cur.fill(0);\n    runRows(S, H);\n  }\n  const rate = 7 * cl(k[1], 0.2, 3);\n  S.acc += cl(dt || 0, 0, 0.1) * rate;\n  let n = floor(S.acc);\n  S.acc -= n;\n  n = min(n, 8);\n  runRows(S, n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, h = S.hue;\n  // The wheel skips red-orange to orange (0 to 0.11), which reads brown\n  // when dim. At Hue 0 the excitatory cells are azure, the inhibitory\n  // ones magenta.\n  const wheel = (f) => 0.11 + 0.89 * (f - floor(f));\n  const hE = wheel(h + 0.528), hI = wheel(h + 0.843);\n  const sat = [0, 0.8, 0.5, 0.25], val = [0, 0.82, 1, 1];\n  for (let y = 0; y \u003c H; y++) {\n    const o = ((S.head + y) % H) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const n = S.rows[o + x];\n      if (!n) { display.setPixel(x, y, 0, 0, 0); continue; }\n      const m = min(3, n);\n      hsv(x \u003c EC ? hE : hI, sat[m], val[m], rgb);\n      display.setPixel(x, y, rgb[0] | 0, rgb[1] | 0, rgb[2] | 0);\n    }\n  }\n}\n","jamo-assembly":"// ===== Patternflow pattern =====\n// Title:   Jamo Assembly\n// Family:  type\n// Idea:    A Korean word is built down the tall panel one syllable block at a time: the slots its vowel calls for open as faint outlines, the initial consonant, the vowel and the final fly in from the panel's edges as separate letters in three colours, shrink or stretch into their slots and lock with a flash, and beside each block its code point counts up from U+AC00 as the pieces land, until the word holds in one paler colour and flies apart to be built again.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hangul syllable blocks, 모아쓰기 of the Hunminjeongeum (King Sejong, created 1443, promulgated 1446), the Unicode Hangul Syllables block at U+AC00 (Unicode 2.0, 1996), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Phrase=0..7, Flight=0..1\n//\n// Knob 1: Hue. Turns the three roles round the wheel together. At 0 initials are cyan, vowels violet-pink and finals yellow, a finished block pales 80% of the way to azure, and the code point is azure grey; at 0.5 the roles are red, green and blue and the finished word salmon.\n// Knob 2: Speed. At 2 a syllable starts every 1.15 s with its pieces 0.3 s apart, a flight takes 0.95 s, the word holds 2.6 s after its last piece locks and flies apart in about 1 s: one round is 8.6 s for 모아쓰기, 6.4 s for a two-syllable word and 5.1 s for 빛. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Phrase. 0 모아쓰기, 1 훨훨, 2 패턴, 3 흐름, 4 한글, 5 괜찮아, 6 훈민정음, 7 빛. A one- or two-syllable word gets 56-LED blocks, 괜찮아 39, the four-syllable words 28. Between them the initial sits beside a vertical vowel (아 기 패 턴 한 찮 민 정 빛), above a horizontal one (모 쓰 흐 름 글 훈 음) and in the corner of a compound (훨 괜), with a final under them in 13 of the 20 blocks and doubled letters in 쓰 (ㅆ) and 찮 (ㄶ).\n// Knob 4: Flight. How the pieces fly in. At 0 they come in on an arc bent by 0.3 of their path, turn 0.3 rad and land in 0.9 s with a small overshoot; at 1 the arc bends by 0.9, they spin through up to 3.2 rad, overshoot further, take 1.8 s and leave trails that fade in 0.16 s instead of 0.06 s. A piece keeps the flight time it set off with, so a turn shows on the next pieces.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, exp, cos, sin, PI, random, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst PHRASES = [\"모아쓰기\", \"훨훨\", \"패턴\", \"흐름\", \"한글\", \"괜찮아\", \"훈민정음\", \"빛\"];\n\n// The basic letters as strokes on a 20 x 20 grid, y down. A stroke is a\n// polyline of x, y pairs; one that starts with O is an ellipse cx, cy, rx, ry.\nconst O = -1;\nconst BASE = {\n  \"ㄱ\": [[3, 3, 17, 3, 17, 18]],\n  \"ㄴ\": [[3, 2, 3, 17, 18, 17]],\n  \"ㄷ\": [[17, 3, 3, 3, 3, 17, 18, 17]],\n  \"ㄹ\": [[3, 2, 17, 2, 17, 10, 3, 10, 3, 18, 18, 18]],\n  \"ㅁ\": [[3, 3, 17, 3, 17, 17, 3, 17, 3, 3]],\n  \"ㅂ\": [[3, 2, 3, 18, 17, 18, 17, 2], [3, 10, 17, 10]],\n  \"ㅅ\": [[10, 2, 2, 18], [10, 2, 18, 18]],\n  \"ㅇ\": [[O, 10, 10, 7.5, 7.5]],\n  \"ㅈ\": [[3, 3, 17, 3], [10, 3, 3, 18], [10, 3, 17, 18]],\n  \"ㅊ\": [[10, 0, 10, 4], [3, 5, 17, 5], [10, 5, 3, 19], [10, 5, 17, 19]],\n  \"ㅋ\": [[3, 3, 17, 3, 17, 18], [3, 10, 17, 10]],\n  \"ㅌ\": [[17, 2, 3, 2, 3, 18, 18, 18], [3, 10, 17, 10]],\n  \"ㅍ\": [[2, 3, 18, 3], [2, 17, 18, 17], [7, 3, 7, 17], [13, 3, 13, 17]],\n  \"ㅎ\": [[10, 0, 10, 3], [3, 5, 17, 5], [O, 10, 13, 5.5, 5]],\n  \"ㅣ\": [[10, 1, 10, 19]],\n  \"ㅏ\": [[7, 1, 7, 19], [7, 10, 17, 10]],\n  \"ㅑ\": [[7, 1, 7, 19], [7, 7, 17, 7], [7, 13, 17, 13]],\n  \"ㅓ\": [[13, 1, 13, 19], [3, 10, 13, 10]],\n  \"ㅕ\": [[13, 1, 13, 19], [3, 7, 13, 7], [3, 13, 13, 13]],\n  \"ㅐ\": [[5, 1, 5, 19], [5, 10, 13, 10], [15, 0, 15, 20]],\n  \"ㅒ\": [[5, 1, 5, 19], [5, 7, 13, 7], [5, 13, 13, 13], [15, 0, 15, 20]],\n  \"ㅔ\": [[2, 10, 9, 10], [9, 1, 9, 19], [16, 0, 16, 20]],\n  \"ㅖ\": [[2, 7, 9, 7], [2, 13, 9, 13], [9, 1, 9, 19], [16, 0, 16, 20]],\n  \"ㅡ\": [[1, 10, 19, 10]],\n  \"ㅗ\": [[10, 4, 10, 13], [1, 13, 19, 13]],\n  \"ㅛ\": [[7, 4, 7, 13], [13, 4, 13, 13], [1, 13, 19, 13]],\n  \"ㅜ\": [[1, 7, 19, 7], [10, 7, 10, 16]],\n  \"ㅠ\": [[1, 7, 19, 7], [7, 7, 7, 16], [13, 7, 13, 16]],\n};\n// The 19 initials, 21 vowels and 27 finals in Unicode's order, each spelled\n// with the basic letters it is built from.\nconst INIT = [\"ㄱ\", \"ㄱㄱ\", \"ㄴ\", \"ㄷ\", \"ㄷㄷ\", \"ㄹ\", \"ㅁ\", \"ㅂ\", \"ㅂㅂ\", \"ㅅ\", \"ㅅㅅ\", \"ㅇ\", \"ㅈ\", \"ㅈㅈ\", \"ㅊ\", \"ㅋ\", \"ㅌ\", \"ㅍ\", \"ㅎ\"];\nconst MED = [\"ㅏ\", \"ㅐ\", \"ㅑ\", \"ㅒ\", \"ㅓ\", \"ㅔ\", \"ㅕ\", \"ㅖ\", \"ㅗ\", \"ㅗㅏ\", \"ㅗㅐ\", \"ㅗㅣ\", \"ㅛ\", \"ㅜ\", \"ㅜㅓ\", \"ㅜㅔ\", \"ㅜㅣ\", \"ㅠ\", \"ㅡ\", \"ㅡㅣ\", \"ㅣ\"];\nconst FIN = [\"\", \"ㄱ\", \"ㄱㄱ\", \"ㄱㅅ\", \"ㄴ\", \"ㄴㅈ\", \"ㄴㅎ\", \"ㄷ\", \"ㄹ\", \"ㄹㄱ\", \"ㄹㅁ\", \"ㄹㅂ\", \"ㄹㅅ\", \"ㄹㅌ\", \"ㄹㅍ\", \"ㄹㅎ\", \"ㅁ\", \"ㅂ\", \"ㅂㅅ\", \"ㅅ\", \"ㅅㅅ\", \"ㅇ\", \"ㅈ\", \"ㅊ\", \"ㅋ\", \"ㅌ\", \"ㅍ\", \"ㅎ\"];\nconst HORIZONTAL = \"ㅗㅛㅜㅠㅡ\";\n\n// The slots on a 20 x 20 block, [x, y, w, h]: the initial, the vowel (two\n// rects for a compound: its horizontal part and its vertical part) and the\n// final, by the vowel's shape and whether there is a final.\nconst SLOTS = {\n  V: [[1, 3, 11, 14], [[12, 0, 7, 20]]],\n  VF: [[1, 1, 11, 10], [[12, 0, 7, 12]], [3, 13, 14, 7]],\n  H: [[3, 1, 14, 10], [[0, 10, 20, 9]]],\n  HF: [[3, 0, 14, 7], [[0, 6, 20, 6]], [3, 13, 14, 7]],\n  C: [[1, 1, 11, 9], [[0, 9, 14, 8], [13, 0, 7, 20]]],\n  CF: [[1, 0, 11, 6], [[0, 5, 14, 6], [13, 0, 7, 13]], [3, 13, 14, 7]],\n};\n\n// 3 x 5 hex digits for the code point, top row first, 4 is the left column.\nconst HEX = [[7, 5, 5, 5, 7], [2, 6, 2, 2, 7], [7, 1, 7, 4, 7], [7, 1, 3, 1, 7], [5, 5, 7, 1, 1], [7, 4, 7, 1, 7], [7, 4, 7, 5, 7], [7, 1, 1, 2, 2],\n  [7, 5, 7, 5, 7], [7, 5, 7, 1, 7], [2, 5, 7, 5, 5], [6, 5, 6, 5, 6], [3, 4, 4, 4, 3], [6, 5, 5, 5, 6], [7, 4, 6, 4, 7], [7, 4, 6, 4, 4]];\n\n// The timeline, in seconds at Speed 2.\n// A flight takes 0.9 s with Flight at 0 and 1.8 s at 1; a piece keeps the\n// time it set off with.\nconst STEP = 1.15, LAG = 0.3, HOLD = 2.6, OUT = 0.9, REST = 0.1;\nconst flyTime = (F) => 0.9 + 0.9 * F;\n\nexport function setup(params) {\n  params.s = { phrase: -1, t: 0, syl: [], pieces: [], end: 0, hue: 0, flight: 0, buf: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0] };\n}\n\n// Lay a letter group (one to two basic letters side by side) into a rect.\nfunction split(letters, r) {\n  if (letters.length === 1) return [{ ch: letters, r }];\n  const w = r[2] * 0.47;\n  return [{ ch: letters[0], r: [r[0], r[1], w, r[3]] }, { ch: letters[1], r: [r[0] + r[2] - w, r[1], w, r[3]] }];\n}\n\n// Where a piece enters: out from its slot along (dx, dy) until its centre is\n// past the panel's edge by half.\nfunction edgeStart(tx, ty, dx, dy, half) {\n  let t = 1e9;\n  if (dx > 1e-6) t = min(t, (W + half - tx) / dx);\n  if (dx \u003c -1e-6) t = min(t, (-half - tx) / dx);\n  if (dy > 1e-6) t = min(t, (H + half - ty) / dy);\n  if (dy \u003c -1e-6) t = min(t, (-half - ty) / dy);\n  return [tx + dx * t, ty + dy * t];\n}\n\nfunction build(S, idx) {\n  S.phrase = idx;\n  const word = PHRASES[idx], n = word.length;\n  const B = n \u003c= 2 ? 56 : floor((124 - (n - 1) * 3) / n), gap = n \u003c= 2 ? 4 : 3;\n  const x0 = (W - B) / 2, y0 = (H - (n * B + (n - 1) * gap)) / 2;\n  S.B = B;\n  S.syl = [];\n  S.pieces = [];\n  for (let s = 0; s \u003c n; s++) {\n    const code = word.charCodeAt(s) - 0xac00;\n    const L = floor(code / 588), V = floor((code % 588) / 28), T = code % 28;\n    const shape = MED[V].length === 2 ? \"C\" : HORIZONTAL.includes(MED[V]) ? \"H\" : \"V\";\n    const slots = SLOTS[shape + (T ? \"F\" : \"\")];\n    const bx = x0, by = y0 + s * (B + gap);\n    const syl = { L, V, T, bx, by, B, pieces: [], t0: 0.15 + s * STEP };\n    const groups = [split(INIT[L], slots[0])];\n    groups.push(MED[V].length === 2 ? [{ ch: MED[V][0], r: slots[1][0] }, { ch: MED[V][1], r: slots[1][1] }] : [{ ch: MED[V], r: slots[1][0] }]);\n    if (T) groups.push(split(FIN[T], slots[2]));\n    groups.forEach((subs, role) => {\n      // The piece's box is the union of its sub-rects, in block units.\n      let ux0 = 20, uy0 = 20, ux1 = 0, uy1 = 0;\n      for (const u of subs) {\n        ux0 = min(ux0, u.r[0]); uy0 = min(uy0, u.r[1]);\n        ux1 = max(ux1, u.r[0] + u.r[2]); uy1 = max(uy1, u.r[1] + u.r[3]);\n      }\n      const k = B / 20;\n      const p = {\n        role, syl: s,\n        subs: subs.map((u) => ({ g: BASE[u.ch], rel: [(u.r[0] - ux0) / (ux1 - ux0), (u.r[1] - uy0) / (uy1 - uy0), u.r[2] / (ux1 - ux0), u.r[3] / (uy1 - uy0)] })),\n        slot: subs.map((u) => [bx + u.r[0] * k, by + u.r[1] * k, u.r[2] * k, u.r[3] * k]),\n        tx: bx + ((ux0 + ux1) / 2) * k, ty: by + ((uy0 + uy1) / 2) * k, tw: (ux1 - ux0) * k, th: (uy1 - uy0) * k,\n        launch: syl.t0 + role * LAG,\n      };\n      // Enter from the side the slot faces, give or take 75 degrees.\n      let ax = p.tx - (bx + B / 2), ay = p.ty - (by + B / 2);\n      const a = Math.atan2(ay, ax) + (random() - 0.5) * 2.6;\n      ax = cos(a); ay = sin(a);\n      const SZ = B * 0.8;\n      [p.sx, p.sy] = edgeStart(p.tx, p.ty, ax, ay, SZ * 0.35);\n      // Leave outward from the block's centre, give or take 30 degrees.\n      const b = Math.atan2(p.ty - (by + B / 2), p.tx - (bx + B / 2)) + (random() - 0.5) * 1.05;\n      p.ex = cos(b); p.ey = sin(b);\n      p.bend = random() \u003c 0.5 ? -1 : 1;\n      p.spin = random() \u003c 0.5 ? -1 : 1;\n      p.SZ = SZ;\n      syl.pieces.push(p);\n      S.pieces.push(p);\n    });\n    S.syl.push(syl);\n  }\n}\n\n// Lock, hold and leave times from the flights as they stand: a piece in the\n// air keeps its own flight time, one still waiting takes the knob's.\nfunction schedule(S) {\n  const fly = flyTime(S.flight);\n  let last = 0;\n  for (const p of S.pieces) {\n    if (p.fly === undefined && S.t >= p.launch) p.fly = fly;\n    p.lock = p.launch + (p.fly === undefined ? fly : p.fly);\n    last = max(last, p.lock);\n  }\n  const hold = last + HOLD;\n  S.syl.forEach((syl, s) => {\n    syl.done = 0;\n    for (const p of syl.pieces) {\n      syl.done = max(syl.done, p.lock);\n      p.out = hold + s * 0.12 + (2 - p.role) * 0.05;\n    }\n  });\n  S.end = hold + (S.syl.length - 1) * 0.12 + 0.1 + 0.7 * OUT + REST;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.flight = cl(k[3], 0, 1);\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  S.tau = tau;\n  const idx = round(cl(k[2], 0, PHRASES.length - 1));\n  if (idx !== S.phrase) {\n    build(S, idx);\n    // The very first build opens with the first pieces already in the air.\n    S.t = S.started ? 0 : 0.55;\n    S.started = true;\n  }\n  S.t += tau;\n  schedule(S);\n  if (S.t > S.end) {\n    build(S, idx);\n    S.t = 0;\n    schedule(S);\n  }\n}\n\n// Ease in and out, overshooting the slot by more as s grows.\nfunction easeBack(u, s) {\n  const c = s * 1.525;\n  return u \u003c 0.5 ? ((2 * u) ** 2 * ((c + 1) * 2 * u - c)) / 2 : ((2 * u - 2) ** 2 * ((c + 1) * (2 * u - 2) + c) + 2) / 2;\n}\nconst smooth = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// Where a piece is at time t: box centre, size, rotation, and visibility.\nfunction pose(S, p, t) {\n  const F = S.flight;\n  if (t \u003c p.launch) return null;\n  if (t \u003c p.lock) {\n    const u = (t - p.launch) / (p.lock - p.launch), q = easeBack(u, 0.4 + 1.6 * F), m = smooth(u * 1.15);\n    // A quadratic curve bent sideways by 0.3 to 0.9 of its length.\n    const mx = (p.sx + p.tx) / 2, my = (p.sy + p.ty) / 2, dx = p.tx - p.sx, dy = p.ty - p.sy;\n    const bend = (0.3 + 0.6 * F) * p.bend;\n    const cx = mx - dy * bend, cy = my + dx * bend;\n    const a = (1 - q) * (1 - q), b = 2 * (1 - q) * q, c = q * q;\n    return { x: a * p.sx + b * cx + c * p.tx, y: a * p.sy + b * cy + c * p.ty, w: p.SZ + (p.tw - p.SZ) * m, h: p.SZ + (p.th - p.SZ) * m, r: p.spin * (0.3 + 2.9 * F) * (1 - m) ** 2, a: 1 };\n  }\n  if (t \u003c p.out) return { x: p.tx, y: p.ty, w: p.tw, h: p.th, r: 0, a: 1 };\n  const u = (t - p.out) / OUT;\n  if (u >= 1) return null;\n  const e = u * u, dist = 90 * e;\n  return { x: p.tx + p.ex * dist, y: p.ty + p.ey * dist, w: p.tw + (p.SZ - p.tw) * e, h: p.th + (p.SZ - p.th) * e, r: p.spin * (0.3 + 2.9 * F) * e, a: 1 - u * u };\n}\n\n// Max-blend a stroke segment of width w into the buffer.\nfunction seg(buf, x0, y0, x1, y1, w, c) {\n  const r = w / 2 + 0.5;\n  const lx = max(0, floor(min(x0, x1) - r)), hx = min(W - 1, ceil(max(x0, x1) + r));\n  const ly = max(0, floor(min(y0, y1) - r)), hy = min(H - 1, ceil(max(y0, y1) + r));\n  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1e-9;\n  for (let y = ly; y \u003c= hy; y++)\n    for (let x = lx; x \u003c= hx; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0;\n      const u = cl((px * dx + py * dy) / L2, 0, 1), ex = px - u * dx, ey = py - u * dy;\n      const f = cl(r - sqrt(ex * ex + ey * ey), 0, 1);\n      if (f \u003c= 0) continue;\n      const i = (y * W + x) * 3;\n      if (buf[i] \u003c c[0] * f) buf[i] = c[0] * f;\n      if (buf[i + 1] \u003c c[1] * f) buf[i + 1] = c[1] * f;\n      if (buf[i + 2] \u003c c[2] * f) buf[i + 2] = c[2] * f;\n    }\n}\n\nfunction drawPiece(buf, p, ps, w, c) {\n  const co = cos(ps.r), si = sin(ps.r);\n  const map = (rel, gx, gy) => {\n    const lx = (rel[0] + (rel[2] * gx) / 20 - 0.5) * ps.w, ly = (rel[1] + (rel[3] * gy) / 20 - 0.5) * ps.h;\n    return [ps.x + lx * co - ly * si, ps.y + lx * si + ly * co];\n  };\n  for (const sub of p.subs)\n    for (const st of sub.g) {\n      const pts = [];\n      if (st[0] === O) {\n        for (let i = 0; i \u003c= 24; i++) {\n          const a = (i / 24) * 2 * PI;\n          pts.push(map(sub.rel, st[1] + st[3] * cos(a), st[2] + st[4] * sin(a)));\n        }\n      } else for (let i = 0; i \u003c st.length; i += 2) pts.push(map(sub.rel, st[i], st[i + 1]));\n      for (let i = 1; i \u003c pts.length; i++) seg(buf, pts[i - 1][0], pts[i - 1][1], pts[i][0], pts[i][1], w, c);\n    }\n}\n\nfunction rectOutline(buf, r, c) {\n  const x0 = round(r[0]), y0 = round(r[1]), x1 = round(r[0] + r[2]) - 1, y1 = round(r[1] + r[3]) - 1;\n  const put = (x, y) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    for (let j = 0; j \u003c 3; j++) buf[i + j] = max(buf[i + j], c[j]);\n  };\n  for (let x = x0; x \u003c= x1; x++) { put(x, y0); put(x, y1); }\n  for (let y = y0 + 1; y \u003c y1; y++) { put(x0, y); put(x1, y); }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.phrase \u003c 0) return;\n  const buf = S.buf, c = S.c, c2 = S.c2, t = S.t, h0 = S.hue + 0.5;\n  // Trails: what was drawn fades in 0.06 s at Speed 2 with Flight at 0, in\n  // 0.16 s at 1.\n  const fade = exp(-(S.tau || 0) / (0.06 + 0.1 * S.flight));\n  for (let i = 0; i \u003c buf.length; i++) buf[i] *= fade;\n  const w = cl(S.B * 0.08, 1.5, 4.2);\n  // Slot outlines while a piece is on its way, fading once it locks.\n  for (const p of S.pieces) {\n    const g = t \u003c p.launch - 0.15 ? 0 : t \u003c p.lock ? 1 : max(0, 1 - (t - p.lock) / 0.4);\n    if (g \u003c= 0) continue;\n    hsv(h0 + p.role / 3, 0.7, 0.22 * g, c);\n    for (const r of p.slot) rectOutline(buf, r, c);\n  }\n  for (const syl of S.syl) {\n    // The block's square from its first launch until it is whole.\n    const g = t \u003c syl.t0 - 0.1 ? 0 : t \u003c syl.done ? 1 : max(0, 1 - (t - syl.done) / 0.6);\n    if (g > 0) {\n      c[0] = c[1] = c[2] = 0.1 * g;\n      rectOutline(buf, [syl.bx - 1, syl.by - 1, syl.B + 2, syl.B + 2], c);\n    }\n  }\n  for (const p of S.pieces) {\n    const ps = pose(S, p, t);\n    if (!ps) continue;\n    const syl = S.syl[p.syl];\n    hsv(h0 + p.role / 3, 0.75, 1, c);\n    // A whole block pales toward one colour; a piece flashes white as it locks.\n    const one = smooth((t - syl.done - 0.25) / 0.6) * (t \u003c p.out ? 1 : 1 - smooth((t - p.out) / 0.3));\n    hsv(h0 + 0.08, 0.5, 1, c2);\n    const fl = t >= p.lock && t \u003c p.out ? exp(-(t - p.lock) / 0.18) : 0;\n    for (let j = 0; j \u003c 3; j++) c[j] = ((c[j] + (c2[j] - c[j]) * one * 0.8) * (1 - fl) + fl) * ps.a;\n    drawPiece(buf, p, ps, w * (t \u003c p.lock ? 1 + 0.3 * (1 - (t - p.launch) / (p.lock - p.launch)) : 1), c);\n  }\n  // Beside each block, its code point as the pieces land: U+AC00, then\n  // + initial x 588, + vowel x 28, + final.\n  const out = S.out || (S.out = new Float32Array(buf.length));\n  out.set(buf);\n  for (const syl of S.syl) {\n    if (t \u003c syl.t0) continue;\n    const [pi, pv, pf] = syl.pieces;\n    let v = 0xac00, lastLock = syl.t0;\n    if (t >= pi.lock) { v += syl.L * 588; lastLock = pi.lock; }\n    if (t >= pv.lock) { v += syl.V * 28; lastLock = pv.lock; }\n    if (pf && t >= pf.lock) { v += syl.T; lastLock = pf.lock; }\n    const gone = t \u003c pi.out ? 1 : max(0, 1 - (t - pi.out) / 0.4), fl = exp(-(t - lastLock) / 0.25);\n    hsv(h0 + 0.08, 0.4, (0.5 + 0.5 * fl) * gone, c);\n    const xd = round(syl.bx + syl.B + (syl.bx - 3) / 2), yd = round(syl.by + syl.B / 2 - 11.5);\n    for (let d = 0; d \u003c 4; d++) {\n      const g = HEX[(v >> (12 - 4 * d)) & 15];\n      for (let ry = 0; ry \u003c 5; ry++)\n        for (let rx = 0; rx \u003c 3; rx++)\n          if (g[ry] & (4 >> rx)) {\n            const x = xd + rx, y = yd + d * 6 + ry;\n            if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n            const i = (y * W + x) * 3;\n            for (let j = 0; j \u003c 3; j++) out[i + j] = max(out[i + j], c[j]);\n          }\n    }\n  }\n  for (let p = 0, i = 0; p \u003c W * H; p++, i += 3)\n    display.setPixel(p & 63, p >> 6, round(cl(out[i], 0, 1) * 255), round(cl(out[i + 1], 0, 1) * 255), round(cl(out[i + 2], 0, 1) * 255));\n}\n","kaprekar-routine":"// ===== Patternflow pattern =====\n// Title:   Kaprekar's Routine\n// Family:  type\n// Idea:    A worksheet of Kaprekar's routine runs down the panel in large drawn digits: the digits of a number fly one by one, largest first, into descending order on the line below, that row turns half round like a carousel into ascending order under it, the two are subtracted column by column from the right with the borrows marked, and the difference becomes the next line, until 6174 comes back and the two 6174s light up gold.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kaprekar's routine and the constant 6174 (D. R. Kaprekar, 1949), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Digits=4..7, Start=0..1\n//\n// Knob 1: Hue. Turns the digits round the wheel. Each digit value keeps its own colour, so a digit can be followed as it moves: at 0 a 0 is cyan, a 9 violet and the rest between; the number the routine comes back to is always gold.\n// Knob 2: Speed. At 2 the start is written in 1.5 s and the first step takes 4.7 s (the sort 1.2 s, the turn 0.9 s, the rule 0.3 s, four columns of 0.45 s and a pause), each later step 0.86 times the one before, down to half. A seven-step start has 6174 on the sheet at 23.8 s and finds it again at 26.1 s; the pair glows 3.5 s, the sheet slides away and a new start comes at 30.5 s. At 0.2 ten times slower; at 3 one and a half times faster.\n// Knob 3: Digits. 4: all 9990 starts from 0000 to 9999 whose digits are not all the same reach 6174 within 7 steps. 5: no number stays; every start falls within 6 steps into the 2-cycle 53955, 59994 (3190 starts) or one of the 4-cycles 61974, 82962, 75933, 63954 (48,480) and 62964, 71973, 83952, 74943 (48,320). 6: 549945 (1950 starts) and 631764 (62,520) stay put, and the rest fall into the 7-cycle 840852, 860832, 862632, 642654, 420876, 851742, 750843, within 13 steps. 7: all 9,999,990 starts fall into one 8-cycle through 7509843, within 13 steps. A sheet stops when a number comes back, and with a cycle every line of the loop lights up.\n// Knob 4: Start. Which starts the sheet takes, by the steps they need: at 0 the farthest (7 steps for 4 digits, 6 for 5, 13 for 6 and 7), at 1 the nearest, one step. Each start is a random arrangement of a random digit multiset that needs that many. At 0 with 4 digits the 2184 seven-step starts leave only 8 different numbers after their first subtraction, and those run into three tails, so the sheet keeps ending in the same lines: 8172, 7443, 3996, 6264, 4176 or 7992, 7173, 6354, 3087, 8352 or 5994, 5355, 1998, 8082, 8532.\n// Buttons: K1 tap starts a new sheet.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI, random, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The digits, drawn as strokes on a 10 x 16 grid with the pen's centre kept\n// inside 1..9 and 1..15: L for a line, A for an arc (centre, radius, start\n// and end angle in degrees, y pointing down, so the angle grows clockwise).\nconst STROKES = [\n  [[\"A\", 5, 5, 4, 180, 360], [\"L\", 9, 5, 9, 11], [\"A\", 5, 11, 4, 0, 180], [\"L\", 1, 11, 1, 5]],\n  [[\"L\", 5.6, 1, 5.6, 15], [\"L\", 5.6, 1, 2.2, 4.4]],\n  [[\"A\", 5, 5, 4, 180, 390], [\"L\", 8.46, 7, 1, 15], [\"L\", 1, 15, 9, 15]],\n  [[\"A\", 5, 4.5, 3.5, 195, 450], [\"A\", 5, 11.5, 3.6, 270, 525], [\"L\", 3.2, 8, 5, 8]],\n  [[\"L\", 7, 15, 7, 1], [\"L\", 7, 1, 1, 11], [\"L\", 1, 11, 9.4, 11]],\n  [[\"L\", 8.8, 1, 2.3, 1], [\"L\", 2.3, 1, 2.03, 7.53], [\"A\", 5, 10.5, 4.2, 225, 500]],\n  [[\"A\", 5, 10.8, 4, 0, 360], [\"A\", 9.5, 10.8, 8.5, 180, 258]],\n  [[\"L\", 1, 1, 9, 1], [\"L\", 9, 1, 3.6, 15]],\n  [[\"A\", 5, 4.6, 3.4, 0, 360], [\"A\", 5, 11.2, 3.8, 0, 360]],\n  [[\"A\", 5, 5.2, 4, 0, 360], [\"A\", 0.5, 5.2, 8.5, 0, 78]],\n];\n\n// Layout for 4 to 7 digits: the left margin that holds the minus sign and the\n// step count, the glyph's width and height, the pen, and the gap between lines.\nconst LAYOUT = {\n  4: { margin: 8, gw: 12, gh: 19, pen: 2.4, gap: 5 },\n  5: { margin: 9, gw: 9, gh: 14, pen: 1.9, gap: 5 },\n  6: { margin: 7, gw: 8, gh: 12, pen: 1.6, gap: 4 },\n  7: { margin: 7, gw: 7, gh: 10, pen: 1.35, gap: 4 },\n};\nconst MAX_STEPS = { 4: 7, 5: 6, 6: 13, 7: 13 };\n\n// Beats of each phase at Speed 2, in seconds.\nconst T_INTRO = 0.25, T_SLIDE = 0.3, T_FLIP = 0.9, T_RULE = 0.3, T_COL = 0.45, T_SETTLE = 0.45, T_FINAL = 3.5, T_OUT = 0.9;\n\nfunction segments(strokes) {\n  const out = [];\n  for (const s of strokes) {\n    if (s[0] === \"L\") out.push([s[1], s[2], s[3], s[4]]);\n    else {\n      const [, cx, cy, r, a0, a1] = s, n = max(2, Math.ceil(abs(a1 - a0) / 8));\n      for (let i = 0; i \u003c n; i++) {\n        const b0 = ((a0 + ((a1 - a0) * i) / n) * PI) / 180, b1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * PI) / 180;\n        out.push([cx + r * cos(b0), cy + r * sin(b0), cx + r * cos(b1), cy + r * sin(b1)]);\n      }\n    }\n  }\n  return out;\n}\n\nfunction segDist(px, py, x0, y0, x1, y1) {\n  const dx = x1 - x0, dy = y1 - y0, l = dx * dx + dy * dy;\n  const t = l > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / l, 0, 1) : 0;\n  const ex = x0 + t * dx - px, ey = y0 + t * dy - py;\n  return sqrt(ex * ex + ey * ey);\n}\n\n// Renders the ten digits at one size: 4 x 4 samples a pixel, a sample lit\n// when it lies within half the pen of a stroke.\nfunction renderGlyphs(L) {\n  const { gw, gh, pen } = L, sx = (gw - pen) / 8, sy = (gh - pen) / 14, hw = pen / 2;\n  const glyphs = [];\n  for (let d = 0; d \u003c 10; d++) {\n    const segs = segments(STROKES[d]).map(([a, b, c, e]) => [hw + (a - 1) * sx, hw + (b - 1) * sy, hw + (c - 1) * sx, hw + (e - 1) * sy]);\n    const g = new Float32Array(gw * gh);\n    for (let y = 0; y \u003c gh; y++)\n      for (let x = 0; x \u003c gw; x++) {\n        let hit = 0;\n        for (let j = 0; j \u003c 4; j++)\n          for (let i = 0; i \u003c 4; i++) {\n            const px = x + (i + 0.5) / 4, py = y + (j + 0.5) / 4;\n            for (const s of segs)\n              if (segDist(px, py, s[0], s[1], s[2], s[3]) \u003c= hw) {\n                hit++;\n                break;\n              }\n          }\n        g[y * gw + x] = hit / 16;\n      }\n    glyphs.push(g);\n  }\n  return glyphs;\n}\n\nconst toDigits = (v, n) => {\n  const d = new Int8Array(n);\n  for (let i = n - 1; i >= 0; i--, v = floor(v / 10)) d[i] = v % 10;\n  return d;\n};\nconst toValue = (d) => {\n  let v = 0;\n  for (let i = 0; i \u003c d.length; i++) v = v * 10 + d[i];\n  return v;\n};\nfunction kStep(v, n) {\n  const d = Array.from(toDigits(v, n)).sort((a, b) => a - b);\n  let asc = 0, desc = 0;\n  for (let i = 0; i \u003c n; i++) {\n    asc = asc * 10 + d[i];\n    desc = desc * 10 + d[n - 1 - i];\n  }\n  return desc - asc;\n}\n\n// Every multiset of n digits, not all the same, grouped by how many steps a\n// number made of it takes to reach the fixed point or the cycle.\nfunction classify(n) {\n  const cache = new Map();\n  const enter = (y) => {\n    const path = [], seen = new Set();\n    let z = y;\n    while (!seen.has(z) && !cache.has(z)) {\n      seen.add(z);\n      path.push(z);\n      z = kStep(z, n);\n    }\n    if (!cache.has(z)) {\n      let c = z;\n      do {\n        cache.set(c, 0);\n        c = kStep(c, n);\n      } while (c !== z);\n    }\n    for (let i = path.length - 1; i >= 0; i--) if (!cache.has(path[i])) cache.set(path[i], cache.get(kStep(path[i], n)) + 1);\n    return cache.get(y);\n  };\n  const by = [];\n  const digits = [];\n  const rec = (pos, lo) => {\n    if (pos === n) {\n      if (digits[0] === digits[n - 1]) return;\n      let asc = 0, desc = 0;\n      for (let i = 0; i \u003c n; i++) {\n        asc = asc * 10 + digits[i];\n        desc = desc * 10 + digits[n - 1 - i];\n      }\n      const e = enter(desc - asc) + 1;\n      (by[e] || (by[e] = [])).push(digits.slice());\n      return;\n    }\n    for (let d = lo; d \u003c= 9; d++) {\n      digits.push(d);\n      rec(pos + 1, d);\n      digits.pop();\n    }\n  };\n  rec(0, 0);\n  return by;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, L: null, glyphs: null, fonts: {}, cell: 0, classes: {}, target: -1,\n    lines: [], phase: \"intro\", t: 0, k: 0, cam: 0, glow: [],\n    buf: new Float32Array(W * H * 3), hue: 0, speed: 2, c: [0, 0, 0], gold: [0, 0, 0],\n  };\n}\n\nfunction slotX(S, j) {\n  return round(S.L.margin + j * S.cell + (S.cell - S.L.gw) / 2);\n}\n\nfunction pickStart(S) {\n  const n = S.n, by = S.classes[n] || (S.classes[n] = classify(n));\n  let t = S.target;\n  while (t > 1 && !by[t]) t--;\n  const pool = by[t], ms = pool[floor(random() * pool.length)].slice();\n  // A random arrangement of the multiset, not starting with 0 if it can help it.\n  for (let tries = 0; tries \u003c 8; tries++) {\n    for (let i = n - 1; i > 0; i--) {\n      const j = floor(random() * (i + 1)), x = ms[i];\n      ms[i] = ms[j];\n      ms[j] = x;\n    }\n    if (ms[0] !== 0) break;\n  }\n  return Int8Array.from(ms);\n}\n\nfunction newSheet(S) {\n  const L = LAYOUT[S.n];\n  S.L = L;\n  S.cell = (W - L.margin) / S.n;\n  S.glyphs = S.fonts[S.n] || (S.fonts[S.n] = renderGlyphs(L));\n  S.pitch = L.gh + L.gap;\n  const dig = pickStart(S);\n  S.lines = [{ kind: \"N\", dig, y: 4, value: toValue(dig), step: 0 }];\n  S.phase = \"intro\";\n  S.t = 0;\n  S.k = 0;\n  S.cam = 0;\n  S.glow = [];\n}\n\nconst last = (S) => S.lines[S.lines.length - 1];\n\n// The next step's three lines: the digits sorted down, the same flipped, and\n// the difference with the borrows it needs.\nfunction beginStep(S) {\n  const n = S.n, top = last(S), src = top.dig;\n  const order = Array.from(src, (d, i) => [d, i]).sort((a, b) => b[0] - a[0] || a[1] - b[1]);\n  const D = Int8Array.from(order, (o) => o[0]);\n  const A = Int8Array.from(D).reverse();\n  const R = new Int8Array(n), dots = new Uint8Array(n), ticks = new Uint8Array(n);\n  let borrow = 0;\n  for (let j = n - 1; j >= 0; j--) {\n    let v = D[j] - borrow - A[j];\n    if (v \u003c 0) {\n      v += 10;\n      ticks[j] = 1;\n      if (j > 0) dots[j - 1] = 1;\n      borrow = 1;\n    } else borrow = 0;\n    R[j] = v;\n  }\n  const p = S.pitch, y = top.y;\n  S.k++;\n  S.lines.push({ kind: \"D\", dig: D, y: y + p, from: order.map((o) => o[1]), dots, ticks });\n  S.lines.push({ kind: \"A\", dig: A, y: y + 2 * p });\n  S.lines.push({ kind: \"R\", dig: R, y: y + 3 * p + 3, value: toValue(R), step: S.k });\n  S.phase = \"slide\";\n  S.t = 0;\n}\n\nconst pace = (S) => max(0.5, Math.pow(0.86, S.k - 1));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = cl(round(kv[2]), 4, 7), maxT = MAX_STEPS[n];\n  const target = maxT - round(cl(kv[3], 0, 1) * (maxT - 1));\n  if (n !== S.n || target !== S.target) {\n    S.n = n;\n    S.target = target;\n    newSheet(S);\n  }\n  if (input.btnPressed && input.btnPressed[0]) newSheet(S);\n  let r = (d * S.speed) / 2;\n  // Phases run on beats; one frame can cross several short ones.\n  for (let guard = 0; guard \u003c 6 && r > 0; guard++) {\n    const f = S.phase === \"intro\" || S.phase === \"final\" || S.phase === \"out\" ? 1 : pace(S);\n    const dur =\n      S.phase === \"intro\" ? T_INTRO * S.n + 0.5 :\n      S.phase === \"slide\" ? T_SLIDE * S.n * f :\n      S.phase === \"flip\" ? T_FLIP * f :\n      S.phase === \"rule\" ? T_RULE * f :\n      S.phase === \"sub\" ? T_COL * S.n * f :\n      S.phase === \"settle\" ? T_SETTLE * f :\n      S.phase === \"final\" ? T_FINAL : T_OUT;\n    const used = min(r, dur - S.t);\n    S.t += used;\n    r -= used;\n    if (S.t \u003c dur - 1e-9) break;\n    S.t = 0;\n    if (S.phase === \"intro\") beginStep(S);\n    else if (S.phase === \"slide\") S.phase = \"flip\";\n    else if (S.phase === \"flip\") S.phase = \"rule\";\n    else if (S.phase === \"rule\") S.phase = \"sub\";\n    else if (S.phase === \"sub\") S.phase = \"settle\";\n    else if (S.phase === \"settle\") {\n      const R = last(S);\n      let hit = -1;\n      for (let i = 0; i \u003c S.lines.length - 1; i++) if ((S.lines[i].kind === \"N\" || S.lines[i].kind === \"R\") && S.lines[i].value === R.value) hit = i;\n      if (hit >= 0) {\n        S.glow = [];\n        for (let i = hit; i \u003c S.lines.length; i++) if (S.lines[i].kind === \"N\" || S.lines[i].kind === \"R\") S.glow.push(i);\n        S.phase = \"final\";\n      } else beginStep(S);\n    } else if (S.phase === \"final\") S.phase = \"out\";\n    else newSheet(S);\n  }\n  // The view follows the lowest line being written.\n  const L = S.L, bottom = last(S).y + L.gh + 3;\n  const want = max(0, bottom - (H - 6));\n  S.cam += (want - S.cam) * (1 - exp(-d * 5));\n}\n\nfunction blit(S, d, x0, y0, rgb) {\n  const { gw, gh } = S.L, g = S.glyphs[d], buf = S.buf;\n  const xi = round(x0), yi = round(y0);\n  for (let y = 0; y \u003c gh; y++) {\n    const yy = yi + y;\n    if (yy \u003c 0 || yy >= H) continue;\n    for (let x = 0; x \u003c gw; x++) {\n      const v = g[y * gw + x], xx = xi + x;\n      if (v \u003c= 0 || xx \u003c 0 || xx >= W) continue;\n      const o = (yy * W + xx) * 3;\n      buf[o] = max(buf[o], rgb[0] * v);\n      buf[o + 1] = max(buf[o + 1], rgb[1] * v);\n      buf[o + 2] = max(buf[o + 2], rgb[2] * v);\n    }\n  }\n}\n\nfunction rect(S, x0, y0, w, h, r, g, b) {\n  for (let y = round(y0); y \u003c round(y0) + h; y++)\n    for (let x = round(x0); x \u003c round(x0) + w; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      S.buf[o] = max(S.buf[o], r);\n      S.buf[o + 1] = max(S.buf[o + 1], g);\n      S.buf[o + 2] = max(S.buf[o + 2], b);\n    }\n}\n\nconst SMALL = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\nfunction small(S, v, x0, y0, g) {\n  const s = String(v);\n  for (let i = 0; i \u003c s.length; i++) {\n    const b = SMALL[s.charCodeAt(i) - 48];\n    for (let r = 0; r \u003c 5; r++) for (let q = 0; q \u003c 3; q++) if (b[r * 3 + q] === \"1\") rect(S, x0 + 4 * i + q, y0 + r, 1, 1, g, g, g + 12);\n  }\n}\n\n// Alpha over: a glyph in flight covers what it passes.\nfunction blitOver(S, d, x0, y0, rgb) {\n  const { gw, gh } = S.L, g = S.glyphs[d], buf = S.buf;\n  const xi = round(x0), yi = round(y0);\n  for (let y = 0; y \u003c gh; y++) {\n    const yy = yi + y;\n    if (yy \u003c 0 || yy >= H) continue;\n    for (let x = 0; x \u003c gw; x++) {\n      const a = g[y * gw + x], xx = xi + x;\n      if (a \u003c= 0 || xx \u003c 0 || xx >= W) continue;\n      const o = (yy * W + xx) * 3;\n      buf[o] += (rgb[0] - buf[o]) * a;\n      buf[o + 1] += (rgb[1] - buf[o + 1]) * a;\n      buf[o + 2] += (rgb[2] - buf[o + 2]) * a;\n    }\n  }\n}\n\nconst STAGE = { intro: 0, slide: 1, flip: 2, rule: 3, sub: 4, settle: 5, final: 6, out: 7 };\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.L) return;\n  const { L, buf, c, gold } = S, n = S.n;\n  buf.fill(0);\n  const ph = S.phase, st = STAGE[ph], f = pace(S), h0 = S.hue + 0.5;\n  const dy = S.cam + (ph === \"out\" ? ease(S.t / T_OUT) * (H + 20) : 0);\n  const pulse = 0.78 + 0.22 * sin(S.t * 6);\n  hsv(0.13, 0.5, 1, gold);\n  const g = [gold[0] * pulse, gold[1] * pulse, gold[2] * pulse];\n  const nl = S.lines.length, top = st === 0 ? 0 : nl - 4;\n  const u = ph === \"slide\" ? S.t / (T_SLIDE * n * f) : ph === \"flip\" ? S.t / (T_FLIP * f) : ph === \"rule\" ? S.t / (T_RULE * f) : 0;\n  const colT = ph === \"sub\" ? S.t / (T_COL * f) : st > 4 ? n + 1 : -1;\n  const colour = (dv, v, sat) => hsv(h0 + 0.034 * dv, sat, v, c);\n  const lnD = st > 0 ? S.lines[nl - 3] : null;\n  for (let li = 0; li \u003c nl; li++) {\n    const ln = S.lines[li], y = ln.y - dy;\n    if (y > H || y + L.gh + 3 \u003c -3) continue;\n    const cur = li >= top + 1 && st > 0, glow = st >= 6 && S.glow.indexOf(li) >= 0;\n    const base = li \u003c top ? 0.4 : li === top && st > 0 ? 0.6 : 1;\n    for (let j = 0; j \u003c n; j++) {\n      let v = base, sat = 0.72;\n      if (ln.kind === \"N\" && st === 0 && j >= floor(S.t / T_INTRO)) continue;\n      if (li === top && ph === \"slide\") {\n        // A digit dims once it has been picked for the sorted row.\n        let picked = false;\n        for (let k = 0; k \u003c n; k++) if (lnD.from[k] === j && u * n - k > 0) picked = true;\n        v = picked ? 0.6 : 1;\n      }\n      if (cur && ln.kind === \"D\" && st === 1 && u * n - j \u003c 1) continue;\n      if (cur && ln.kind === \"A\" && st \u003c= 2) continue;\n      if (cur && ln.kind === \"R\") {\n        if (st \u003c 4) continue;\n        const k = n - 1 - j;\n        if (colT \u003c k + 0.5) continue;\n        // The digit is written white and settles into its colour.\n        sat = 0.72 * cl((colT - k - 0.5) * 2, 0, 1);\n      }\n      if (cur && ph === \"sub\" && (ln.kind === \"D\" || ln.kind === \"A\") && j === n - 1 - floor(colT)) {\n        v = 1;\n        sat = 0.12;\n      }\n      if (glow) blit(S, ln.dig[j], slotX(S, j), y, g);\n      else {\n        colour(ln.dig[j], v, sat);\n        blit(S, ln.dig[j], slotX(S, j), y, c);\n      }\n    }\n    // Borrows: a tick before the digit that takes ten, a dot over the one\n    // that gives it.\n    if (ln.kind === \"D\" && ln.ticks && (!cur || st >= 4)) {\n      const w = n === 4 ? 2 : 1, b = (li \u003c top ? 0.45 : 1) * 255;\n      for (let j = 0; j \u003c n; j++) {\n        if (ln.ticks[j] && colT + (cur ? 0 : 99) >= n - 1 - j + 0.25) rect(S, slotX(S, j) - 2, y + 1, 1, round(L.gh * 0.42), b, b * 0.85, b * 0.35);\n        if (ln.dots[j] && colT + (cur ? 0 : 99) >= n - 2 - j + 0.25) rect(S, slotX(S, j) + round((L.gw - w) / 2), y - 1 - w, w, w, b, b * 0.85, b * 0.35);\n      }\n    }\n    if (ln.kind === \"A\" && (!cur || st >= 3)) {\n      const b = (li \u003c top ? 0.45 : 1) * 190, my = y + round(L.gh / 2) - 1;\n      rect(S, 1, my, L.margin - 3, n === 4 ? 2 : 1, b, b, b);\n      const rw = cur && ph === \"rule\" ? round((W - 2) * ease(u)) : W - 2;\n      rect(S, 1, y + L.gh + 1, rw, 1, b * 0.75, b * 0.75, b * 0.8);\n    }\n    if (ln.kind === \"R\" && (!cur || st >= 5)) small(S, ln.step, 1, y + L.gh - 5, li \u003c top ? 50 : 90);\n  }\n  if (ph === \"slide\") {\n    // The sorted row is picked one digit at a time, the largest first, each\n    // flying from its place in the line above.\n    const lnN = S.lines[nl - 4];\n    for (let k = 0; k \u003c n; k++) {\n      const uk = u * n - k;\n      if (uk \u003c= 0 || uk >= 1) continue;\n      const i = lnD.from[k], e = ease(uk);\n      const x = slotX(S, i) + (slotX(S, k) - slotX(S, i)) * ease(uk * 1.2);\n      const yy = lnN.y + (lnD.y - lnN.y) * e - 2 * sin(PI * e) - dy;\n      colour(lnD.dig[k], 1, 0.3);\n      blitOver(S, lnD.dig[k], x, yy, c);\n    }\n  }\n  if (ph === \"flip\") {\n    // The copy drops a line, then turns half round like a carousel seen from\n    // a little below, the digits behind swinging low and dim, so it lands\n    // reversed.\n    const lnA = S.lines[nl - 2], e = ease(u / 0.3), th = PI * ease((u - 0.3) / 0.7), cx = L.margin + (n * S.cell) / 2;\n    const dx = (j) => slotX(S, j) + L.gw / 2 - cx, zmax = abs(dx(0)) || 1;\n    const idx = [];\n    for (let j = 0; j \u003c n; j++) idx.push(j);\n    idx.sort((a, b) => dx(b) - dx(a));\n    for (const j of idx) {\n      const z = -dx(j) * sin(th);\n      const x = cx + dx(j) * cos(th) - L.gw / 2;\n      const yy = lnD.y + (lnA.y - lnD.y) * e + (z \u003c 0 ? -z * 0.55 : -z * 0.08) - dy;\n      colour(lnD.dig[j], 0.55 + 0.45 * (0.5 + (0.5 * z) / zmax), 0.3);\n      blitOver(S, lnD.dig[j], x, yy, c);\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p & 63, p >> 6, buf[p * 3], buf[p * 3 + 1], buf[p * 3 + 2]);\n}\n","maxwell-fish-eye":"// ===== Patternflow pattern =====\n// Title:   Maxwell's Fish-Eye\n// Family:  line\n// Idea:    Inside Maxwell's fish-eye lens, where the index falls off as n0 / (1 + r^2/R^2), 24 rays leave a point source and bend along circles, pulses of light run out along all of them at once, and the ring their heads draw swells, turns over and closes on the image point -R^2 P / |P|^2, every pulse arriving together, while the source drifts and its image swings round the far side of the dotted circle r = R.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Maxwell's fish-eye lens (James Clerk Maxwell, 1854), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Source=-1..1, Profile=0..1\n//\n// Knob 1: Hue. Turns the fan's colours round the wheel together. At 0 the ray aimed straight at the image is cyan and the one aimed straight away violet, with the pulses paled towards white; at 0.25 the fan runs violet to red, at 0.5 red to yellow-green.\n// Knob 2: Speed. At 2 a pulse takes 2.95 s from the source to the image and a new one leaves every 1.18 s, so the arrivals fall between the departures; the source swings 24 degrees either side of the vertical through the centre in 13.7 s and its distance breathes in and out by a fifth over 22.9 s. At 0.2 everything is ten times slower, at 3 a pulse crosses in 1.96 s.\n// Knob 3: Source. How far the source sits from the centre, as R e^(K/2) with R = 30 LEDs: at the opening 0 it wanders between 24.6 and 36.6 LEDs out and its image the same, on the far side; at 1 the source rides 40 to 60 LEDs up near the top and the image closes in to 15 to 22 below the centre; at -1 the two swap.\n// Knob 4: Profile. Bends the index away from Maxwell's to n0 / (1 + r^2/R^2)^q. Up to 0.1 q = 1 and all 24 rays land within 0.01 LED of the image; then q rises to 1.5 at 1, the rays cross in a cusped caustic instead of a point, and the pulses never come closer together than 3.8 LEDs at 0.25, 9.4 at 0.5 and 8.5 at 1.\n\n// The rays are integrated, not drawn as circles. With n0 = 2 the optical\n// length from the source P to the image -R^2 P / |P|^2 is pi R on every ray,\n// the length of half a great circle on a sphere of radius R: the fish-eye is\n// that sphere seen through stereographic projection, and its rays are the\n// great circles. Checked by RK4 in this file and in a separate script: each\n// ray is a circle to 1e-8 R, lands on the image to 0.01 LED, and crosses the\n// dotted circle r = R at the two ends of one diameter (the sphere's\n// equator, which a great circle cuts at opposite points; the angle at which\n// a ray crosses it is not fixed, anything from 37 to 90 degrees for a source\n// at R/2).\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, sin, cos, abs, PI, hypot } = Math;\nconst TAU = 2 * PI;\nconst OX = 31.5, OY = 63.5, R = 30, R2 = R * R;\nconst NR = 24, MAXS = 700;\nconst HALF = PI * R; // optical length from source to image, n0 = 2\nconst GAP = HALF * 0.4; // optical length between pulses\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, ph: 0,\n    acc: new Float32Array(W * H * 3),\n    xs: new Float32Array(NR * MAXS), ys: new Float32Array(NR * MAXS), ls: new Float32Array(NR * MAXS),\n    cnt: new Int32Array(NR),\n    c: [0, 0, 0],\n    k1: [0, 0, 0, 0], k2: [0, 0, 0, 0], k3: [0, 0, 0, 0], k4: [0, 0, 0, 0],\n    px: OX, py: 20, qx: OX, qy: 100,\n  };\n}\n\n// n = 2 / (1 + r^2/R^2)^q, Maxwell's own at q = 1. A ray is stepped in\n// its length s along the panel: it turns towards higher n at the rate\n// d(theta)/ds = grad(ln n) . (-sin theta, cos theta), with\n// grad(ln n) = -2 q x / (R^2 + r^2), and gathers optical length dL = n ds.\n// RK4, with steps from 0.8 LEDs near the centre to 1.5% of r far out.\nfunction deriv(x, y, th, q, o) {\n  const r2 = x * x + y * y, g = (-2 * q) / (R2 + r2), c = cos(th), s = sin(th);\n  o[0] = c; o[1] = s; o[2] = g * (y * c - x * s); o[3] = q === 1 ? 2 / (1 + r2 / R2) : 2 / (1 + r2 / R2) ** q;\n}\n\nfunction trace(S, k, x, y, th, q, Lmax) {\n  const base = k * MAXS, a = S.k1, b = S.k2, c3 = S.k3, d = S.k4;\n  let L = 0, c = 1;\n  S.xs[base] = x; S.ys[base] = y; S.ls[base] = 0;\n  while (L \u003c Lmax && c \u003c MAXS) {\n    const h = 0.8 + 0.015 * sqrt(x * x + y * y);\n    deriv(x, y, th, q, a);\n    deriv(x + (h / 2) * a[0], y + (h / 2) * a[1], th + (h / 2) * a[2], q, b);\n    deriv(x + (h / 2) * b[0], y + (h / 2) * b[1], th + (h / 2) * b[2], q, c3);\n    deriv(x + h * c3[0], y + h * c3[1], th + h * c3[2], q, d);\n    x += (h / 6) * (a[0] + 2 * b[0] + 2 * c3[0] + d[0]);\n    y += (h / 6) * (a[1] + 2 * b[1] + 2 * c3[1] + d[1]);\n    th += (h / 6) * (a[2] + 2 * b[2] + 2 * c3[2] + d[2]);\n    L += (h / 6) * (a[3] + 2 * b[3] + 2 * c3[3] + d[3]);\n    S.xs[base + c] = x; S.ys[base + c] = y; S.ls[base + c] = L; c++;\n  }\n  S.cnt[k] = c;\n}\n\nfunction splat(acc, x, y, r, g, b) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++) {\n    const yy = iy + j;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = j ? fy : 1 - fy;\n    for (let i = 0; i \u003c 2; i++) {\n      const xx = ix + i;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = wy * (i ? fx : 1 - fx), o = (yy * W + xx) * 3;\n      acc[o] += r * w; acc[o + 1] += g * w; acc[o + 2] += b * w;\n    }\n  }\n}\n\nfunction seg(acc, x0, y0, x1, y1, r, g, b) {\n  if ((x0 \u003c -2 && x1 \u003c -2) || (x0 > W + 1 && x1 > W + 1) || (y0 \u003c -2 && y1 \u003c -2) || (y0 > H + 1 && y1 > H + 1)) return;\n  const len = hypot(x1 - x0, y1 - y0), n = Math.ceil(len / 0.6) || 1;\n  const w = len / n;\n  for (let i = 0; i \u003c n; i++) {\n    const t = (i + 0.5) / n;\n    splat(acc, x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, r * w, g * w, b * w);\n  }\n}\n\nfunction glow(acc, x, y, rad, r, g, b) {\n  const x0 = max(0, floor(x - rad * 2)), x1 = min(W - 1, floor(x + rad * 2) + 1);\n  const y0 = max(0, floor(y - rad * 2)), y1 = min(H - 1, floor(y + rad * 2) + 1);\n  for (let yy = y0; yy \u003c= y1; yy++)\n    for (let xx = x0; xx \u003c= x1; xx++) {\n      const d2 = ((xx - x) ** 2 + (yy - y) ** 2) / (rad * rad);\n      const w = exp(-d2);\n      const o = (yy * W + xx) * 3;\n      acc[o] += r * w; acc[o + 1] += g * w; acc[o + 2] += b * w;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0]; S.speed = k[1]; S.src = k[2]; S.q = 1 + 0.5 * max(0, (k[3] - 0.1) / 0.9) ** 1.5;\n  S.t += dt * S.speed;\n  S.ph += dt * S.speed * 16;\n  const sw = 0.42 * sin(S.t * 0.23);\n  const d = R * exp(0.5 * S.src + 0.2 * sin(S.t * 0.137 + 1));\n  S.px = d * sin(sw); S.py = -d * cos(sw);\n  const m = R2 / (d * d);\n  S.qx = -m * S.px; S.qy = -m * S.py;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const acc = S.acc;\n  acc.fill(0);\n  const c = S.c;\n  // the circle r = R, dotted\n  for (let i = 0; i \u003c 96; i++) {\n    const a = (TAU * i) / 96;\n    splat(acc, OX + R * cos(a), OY + R * sin(a), 0.16, 0.14, 0.2);\n  }\n  const Lmax = HALF * 1.6;\n  const axis = Math.atan2(S.qy - S.py, S.qx - S.px);\n  const Lp = S.ph % GAP;\n  for (let k = 0; k \u003c NR; k++) {\n    const off = (TAU * (k + 0.5)) / NR;\n    trace(S, k, S.px, S.py, axis + off, S.q, Lmax);\n    const wide = abs(((off + PI) % TAU) - PI) / PI; // 0 for the ray aimed at the image, 1 for the one aimed away\n    hsv(S.hue + 0.5 + 0.28 * wide, 0.85, 1, c);\n    const base = k * MAXS, cnt = S.cnt[k];\n    for (let i = 1; i \u003c cnt; i++) {\n      const L = S.ls[base + i];\n      const dim = L \u003c HALF ? 0.22 : 0.13 * max(0, 1 - (L - HALF) / (0.6 * HALF));\n      seg(acc, OX + S.xs[base + i - 1], OY + S.ys[base + i - 1], OX + S.xs[base + i], OY + S.ys[base + i], c[0] * dim, c[1] * dim, c[2] * dim);\n    }\n    // pulses, GAP apart in optical length, so the arrivals fall between the departures\n    for (let pz = 0; pz \u003c 4; pz++) {\n      const Lh = Lp + pz * GAP;\n      const fade = Lh \u003c HALF ? 1 : max(0, 1 - (Lh - HALF) / (0.5 * HALF));\n      for (let i = 1; i \u003c cnt; i++) {\n        const L0 = S.ls[base + i - 1], L1 = S.ls[base + i];\n        if (L1 \u003c Lh - 8 || L0 > Lh) continue;\n        const a = min(1, max(0, 1 - (Lh - L1) / 8));\n        const v = 1.2 * a * a * fade;\n        seg(acc, OX + S.xs[base + i - 1], OY + S.ys[base + i - 1], OX + S.xs[base + i], OY + S.ys[base + i], (c[0] * 0.6 + 0.4) * v, (c[1] * 0.6 + 0.4) * v, (c[2] * 0.6 + 0.4) * v);\n      }\n    }\n  }\n  glow(acc, OX + S.px, OY + S.py, 1.3, 1.4, 1.0, 0.6);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, 255 * (1 - exp(-acc[o] * 1.6)), 255 * (1 - exp(-acc[o + 1] * 1.6)), 255 * (1 - exp(-acc[o + 2] * 1.6)));\n    }\n}\n","moffatt-eddies":"// ===== Patternflow pattern =====\n// Title:   Moffatt Eddies\n// Family:  sim\n// Idea:    A wedge of syrup stands on its point, stirred far above, and Moffatt's similarity solution fills it with a stack of counter-rotating eddies that shrink by a fixed ratio toward the corner, each one drawn with its own stream lines on its own log scale between white dividing stream lines, with tracers circling in every eddy while the view sinks into the corner one eddy at a time.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Moffatt eddies in a corner (H. Keith Moffatt, 1964), their photograph (Sadatoshi Taneda, 1979), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Angle=28..100, Truth=0..1\n//\n// Knob 1: Hue. Turns the two eddy colours together along the hues from green to pink, leaving out red, orange and yellow, which read brown this dim: at 0 the eddies turning one way are teal and the ones turning the other way violet, at 0.4 violet and green, at 0.6 magenta and sky blue. The dividing stream lines stay white and the walls grey.\n// Knob 2: Speed. At 2 the view sinks into the corner by one eddy every 3.0 s at 28 degrees (6.6 s at 100), and a tracer goes round its stream line in 1.6 to 2.3 s whatever the size of its eddy. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Angle. The wedge's opening 2 alpha, from 28 degrees, where its walls meet the panel's top corners, to 100. The exponent lambda solves sin(2 (lambda - 1) alpha) = -(lambda - 1) sin(2 alpha): at 28 degrees lambda = 9.636 + 4.516i and each eddy is 2.005 times smaller than the one above it and its fluid moves 406 times slower; at 60 degrees 5.000 and 688, at 90 16.57 and 2189, at 100 29.27 and 4322, when one eddy fills the panel. Past 146.3 degrees lambda turns real and the eddies are gone.\n// Knob 4: Truth. At 0 every eddy is drawn and turned on its own scale, so the deep ones still glow and turn. Turned up, brightness and turning follow the real flow: at 1 brightness is the log of the speed over three decades below an eddy whose outer edge is at the top of the panel. At 28 degrees an eddy brightens from 0.13 to full as its outer edge climbs from row 66 to the top, the eddy under it stays dark, and its tracers turn 203 times slower than the ones above. That is about what Taneda's camera saw.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, exp, log, sqrt, sin, cos, sinh, cosh, atan2, atan, PI, random, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst frac = (v) => v - floor(v);\nconst CX = 32, CY = 128; // the corner, at the middle of the bottom edge\nconst TN = 513; // samples of the angular profile across the wedge\nconst NP = 64; // tracers\nconst TL = 9; // trail points per tracer\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// cos and sin of a complex number x + iy, as [re, im].\nconst ccos = (x, y) => [cos(x) * cosh(y), -sin(x) * sinh(y)];\nconst csin = (x, y) => [sin(x) * cosh(y), cos(x) * sinh(y)];\n\n// Stokes flow in the wedge |theta| \u003c alpha with psi even in theta, so the\n// fluid crosses the bisector: psi = Re[r^lambda f(theta)] with\n// f = A cos(lambda theta) + C cos((lambda - 2) theta). No slip on both walls\n// (f = f' = 0 at theta = alpha) leaves a 2x2 system whose determinant,\n// (l - 2) cos(l a) sin((l - 2) a) - l sin(l a) cos((l - 2) a), reduces to\n// sin(2 (l - 1) a) + (l - 1) sin(2 a) = 0. Newton on p = l - 1, followed\n// from a 2 degree wedge, where 2 p a is near the root 4.2124 + 2.2507i of\n// sin z = -z, up to the wedge asked for.\nfunction solve(S, deg) {\n  let from = S.deg, pr = S.pr, pi = S.pi;\n  if (!(from > 0) || abs(deg - from) > 60) {\n    from = 2;\n    const a0 = (PI / 180) * 1;\n    pr = 4.212392 / (2 * a0); pi = 2.250729 / (2 * a0);\n  }\n  const steps = max(1, Math.ceil(abs(deg - from) / 1));\n  for (let s = 1; s \u003c= steps; s++) {\n    const d = from + ((deg - from) * s) / steps, a = (PI / 180) * d * 0.5, s2 = sin(2 * a);\n    for (let it = 0; it \u003c 30; it++) {\n      const [sr, si] = csin(2 * a * pr, 2 * a * pi), [cr, ci] = ccos(2 * a * pr, 2 * a * pi);\n      const fr = sr + pr * s2, fi = si + pi * s2, dr = 2 * a * cr + s2, di = 2 * a * ci;\n      const dd = dr * dr + di * di;\n      const qr = (fr * dr + fi * di) / dd, qi = (fi * dr - fr * di) / dd;\n      pr -= qr; pi -= qi;\n      if (abs(qr) + abs(qi) \u003c 1e-12) break;\n    }\n  }\n  S.deg = deg; S.pr = pr; S.pi = pi;\n  const al = (PI / 180) * deg * 0.5, lr = pr + 1, li = pi;\n  S.al = al; S.a = lr; S.mu = li; S.c = lr / li;\n  // Each eddy is rho times the next one in, and its speeds exp(pi (a - 1) / mu) times.\n  S.rho = exp(PI / li);\n  // The angular profile: f = cos((l-2) a) cos(l t) - cos(l a) cos((l-2) t).\n  const [Ar, Ai] = ccos((lr - 2) * al, li * al), [Cr, Ci] = ccos(lr * al, li * al);\n  let prev = 0;\n  for (let j = 0; j \u003c TN; j++) {\n    const t = -al + (2 * al * j) / (TN - 1);\n    const [xr, xi] = ccos(lr * t, li * t), [yr, yi] = ccos((lr - 2) * t, li * t);\n    const fr = Ar * xr - Ai * xi - (Cr * yr - Ci * yi), fi = Ar * xi + Ai * xr - (Cr * yi + Ci * yr);\n    let g = atan2(fi, fr);\n    if (j > 0) { while (g - prev > PI) g -= 2 * PI; while (g - prev \u003c -PI) g += 2 * PI; }\n    prev = g;\n    S.arg[j] = g;\n    S.lf[j] = 0.5 * log(fr * fr + fi * fi + 1e-300);\n  }\n  const off = S.arg[(TN - 1) >> 1];\n  for (let j = 0; j \u003c TN; j++) {\n    S.arg[j] -= off;\n    S.G[j] = S.lf[j] - S.c * S.arg[j];\n  }\n  for (let j = 1; j \u003c TN - 1; j++) S.da[j] = (S.arg[j + 1] - S.arg[j - 1]) / ((4 * al) / (TN - 1));\n  S.da[0] = S.da[1]; S.da[TN - 1] = S.da[TN - 2];\n  // ln u = G(t) + c x + ln sin x - ln m, x in [0, pi) across one eddy; the\n  // largest e^(c x) sin x is at x = pi - atan(1/c).\n  const xs = PI - atan(1 / S.c);\n  let gm = -1e9;\n  for (let j = 0; j \u003c TN; j++) gm = max(gm, S.G[j]);\n  S.lnm = gm + S.c * xs + log(sin(xs));\n}\n\n// The field at a screen point, into q: inside, the eddy index k, xh (0..pi\n// across the eddy), lu (ln of |psi| over the eddy's own scale, so the same\n// numbers in every eddy) and gc, the length of grad chi in 1/LED.\nfunction field(S, x, y, q) {\n  const dx = x - CX, dy = CY - y, r = hypot(dx, dy), t = atan2(dx, dy);\n  q.r = r; q.t = t;\n  if (r \u003c 1e-6 || abs(t) >= S.al) { q.inside = 0; return q; }\n  const fj = ((t + S.al) / (2 * S.al)) * (TN - 1), j = min(TN - 2, floor(fj)), w = fj - j;\n  const arg = S.arg[j] + (S.arg[j + 1] - S.arg[j]) * w;\n  const G = S.G[j] + (S.G[j + 1] - S.G[j]) * w;\n  const da = S.da[j] + (S.da[j + 1] - S.da[j]) * w;\n  const chi = S.mu * log(r) + arg + S.phi;\n  const k = floor((chi - PI / 2) / PI), xh = chi - PI / 2 - k * PI;\n  q.inside = 1; q.k = k; q.xh = xh;\n  q.lu = G + S.c * xh + log(max(1e-30, sin(xh))) - S.lnm;\n  q.gc = sqrt(S.mu * S.mu + da * da) / r;\n  return q;\n}\n\nexport function setup(params) {\n  params.s = {\n    arg: new Float64Array(TN), lf: new Float64Array(TN), G: new Float64Array(TN), da: new Float64Array(TN),\n    deg: 0, pr: 0, pi: 0, al: 0, a: 0, mu: 1, c: 1, rho: 1, lnm: 0,\n    phi: 0, hue: 0, truth: 0, speed: 2, kap: 0, spin: 1,\n    px: new Float32Array(NP), py: new Float32Array(NP), pu: new Float32Array(NP), pk: new Int32Array(NP),\n    tx: new Float32Array(NP * TL), ty: new Float32Array(NP * TL), tick: 0,\n    q: {}, q2: {}, rgb: new Float32Array(W * H * 3), col: [0, 0, 0],\n    K: new Float64Array(W * H), LU: new Float32Array(W * H), TH: new Float32Array(W * H), DM: new Float32Array(W * H),\n  };\n}\n\n// A tracer on a random stream line. Fresh tracers spread over every eddy\n// from the newest one at least 5 LEDs across up to the top of the panel; a\n// tracer whose eddy has left the panel comes back in one of them, picked by\n// size, so the big eddies near the top keep enough tracers.\nfunction spawn(S, i, deep) {\n  const q = S.q, size = min(S.rho - 1, 2 * sin(S.al));\n  const k0 = Math.ceil((S.mu * log(5 / size) - PI / 2 + S.phi) / PI);\n  const k1 = floor((S.mu * log(124) - PI / 2 + S.phi) / PI);\n  for (let tries = 0; tries \u003c 40; tries++) {\n    let k = k0 + floor(random() * (max(k0, k1) - k0 + 1));\n    if (deep) for (let kk = k1, tot = 0; kk >= k0; kk--) {\n      const z = exp((0.8 * (kk - k1) * PI) / S.mu);\n      tot += z;\n      if (random() * tot \u003c z) k = kk;\n    }\n    const t = (random() * 2 - 1) * S.al * 0.8, xh = random() * PI;\n    const fj = ((t + S.al) / (2 * S.al)) * (TN - 1), j = floor(fj);\n    const r = exp((k * PI + PI / 2 + xh - S.arg[j] - S.phi) / S.mu);\n    const x = CX + r * sin(t), y = CY - r * cos(t);\n    field(S, x, y, q);\n    if (!q.inside || q.k !== k || y \u003c 0) continue;\n    const u = exp(q.lu);\n    if (u \u003c 0.015 || u > 0.85) continue;\n    S.px[i] = x; S.py[i] = y; S.pu[i] = u; S.pk[i] = k;\n    for (let n = 0; n \u003c TL; n++) { S.tx[i * TL + n] = x; S.ty[i * TL + n] = y; }\n    return;\n  }\n  S.pu[i] = -1;\n}\n\n// The tracer velocity: the dive's outward stretch plus the flow along the\n// stream lines of eddy k. The flow is scaled by a constant on each stream line,\n// so the paths are the real ones, and every stream line of every eddy goes\n// round in about the same time (Truth 0) or at its eddy's real rate.\nfunction vel(S, x, y, k, iu, out) {\n  const q = S.q2, h = 0.2;\n  field(S, x + h, y, q); const ux1 = q.inside && q.k === k ? exp(q.lu) : 0;\n  field(S, x - h, y, q); const ux0 = q.inside && q.k === k ? exp(q.lu) : 0;\n  field(S, x, y + h, q); const uy1 = q.inside && q.k === k ? exp(q.lu) : 0;\n  field(S, x, y - h, q); const uy0 = q.inside && q.k === k ? exp(q.lu) : 0;\n  const gx = (ux1 - ux0) / (2 * h), gy = (uy1 - uy0) / (2 * h);\n  const R = exp((k * PI + PI - S.phi) / S.mu);\n  const slow = exp(-S.truth * (S.a - 2) * max(0, log(120 / R)));\n  const sg = k & 1 ? 1 : -1, f = sg * R * R * S.spin * slow * iu;\n  out[0] = -gy * f + S.kap * (x - CX);\n  out[1] = gx * f + S.kap * (y - CY);\n  out[2] = gx; out[3] = gy;\n  return out;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.truth = cl(kv[3], 0, 1);\n  const deg = cl(kv[2], 28, 100);\n  let fresh = false;\n  if (abs(deg - S.deg) > 0.05) { solve(S, deg); fresh = true; }\n  // The dive: one eddy grows into the next one's place every T seconds.\n  const T = (3 * sqrt(log(S.rho) / log(2))) / (S.speed / 2);\n  const om = PI / T;\n  S.kap = om / S.mu;\n  // A loop takes about 3.2 / (spin mu^2) s, measured from 28 to 100 degrees.\n  S.spin = (0.65 * S.speed) / (S.mu * S.mu);\n  S.phi -= om * d;\n  if (S.phi \u003c -2 * PI) { S.phi += 2 * PI; for (let i = 0; i \u003c NP; i++) S.pk[i] += 2; }\n  if (fresh) for (let i = 0; i \u003c NP; i++) spawn(S, i, false);\n  const v = [0, 0, 0, 0], v2 = [0, 0, 0, 0], q = S.q;\n  for (let i = 0; i \u003c NP; i++) {\n    if (S.pu[i] \u003c 0) { spawn(S, i, true); continue; }\n    let x = S.px[i], y = S.py[i];\n    const k = S.pk[i], iu = 1 / S.pu[i]; // eddies keep their index as the field slides\n    vel(S, x, y, k, iu, v);\n    const sp = hypot(v[0], v[1]) * d, r = hypot(x - CX, y - CY);\n    const n = max(1, min(8, Math.ceil(sp / max(0.3, 0.08 * r))));\n    const h = d / n;\n    for (let s = 0; s \u003c n; s++) {\n      vel(S, x, y, k, iu, v);\n      vel(S, x + 0.5 * h * v[0], y + 0.5 * h * v[1], k, iu, v2);\n      x += h * v2[0]; y += h * v2[1];\n    }\n    // Back onto the stream line it started on.\n    field(S, x, y, q);\n    if (q.inside && q.k === k) {\n      vel(S, x, y, k, iu, v);\n      const g2 = v[2] * v[2] + v[3] * v[3], e = exp(q.lu) - S.pu[i];\n      if (g2 > 1e-9) { x -= (e * v[2]) / g2; y -= (e * v[3]) / g2; }\n    }\n    field(S, x, y, q);\n    const gone = exp((k * PI + PI / 2 - S.phi) / S.mu) > 135;\n    if (!q.inside || q.k !== k || gone) { spawn(S, i, true); continue; }\n    S.px[i] = x; S.py[i] = y;\n  }\n  // Trails ride the dive with their tracers.\n  const g = exp(S.kap * d);\n  for (let n = 0; n \u003c NP * TL; n++) { S.tx[n] = CX + (S.tx[n] - CX) * g; S.ty[n] = CY + (S.ty[n] - CY) * g; }\n  S.tick += d;\n  if (S.tick > 1 / 30) {\n    S.tick = 0;\n    for (let i = 0; i \u003c NP; i++) {\n      for (let n = TL - 1; n > 0; n--) { S.tx[i * TL + n] = S.tx[i * TL + n - 1]; S.ty[i * TL + n] = S.ty[i * TL + n - 1]; }\n      S.tx[i * TL] = S.px[i]; S.ty[i * TL] = S.py[i];\n    }\n  }\n}\n\nfunction splat(rgb, x, y, r, g, b) {\n  const x0 = floor(x - 0.5), y0 = floor(y - 0.5), fx = x - 0.5 - x0, fy = y - 0.5 - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = x0 + i, Y = y0 + j;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const w = (i ? fx : 1 - fx) * (j ? fy : 1 - fy), p = (Y * W + X) * 3;\n      rgb[p] = max(rgb[p], r * w * 1.6); rgb[p + 1] = max(rgb[p + 1], g * w * 1.6); rgb[p + 2] = max(rgb[p + 2], b * w * 1.6);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.deg) return;\n  const rgb = S.rgb, q = S.q, c = S.col;\n  // Two hues apart on a wheel from green to pink, without the red, orange and\n  // yellow that read brown when dim: teal and violet at 0.\n  const hA = 0.3 + 0.64 * frac(0.266 + S.hue), hB = 0.3 + 0.64 * frac(0.781 + S.hue);\n  const K = S.K, LU = S.LU, TH = S.TH, DM = S.DM;\n  const top = log(124), span = S.c * PI, deep = 3 * log(10);\n  const lev = (lu) => (lu > -0.3 ? 0 : lu > -1 ? 1 : lu > -2.1 ? 2 : lu > -3.6 ? 3 : lu > -5.6 ? 4 : 5);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      field(S, x + 0.5, y + 0.5, q);\n      if (!q.inside) { K[p] = -1e9; continue; }\n      K[p] = q.k; LU[p] = q.lu; TH[p] = PI / q.gc;\n      // Truth: how far the real speed in this eddy sits below the speed in an\n      // eddy whose outer edge is at the top of the panel, over three decades.\n      const o = (S.a - 1) * min(0, (q.k * PI + 1.5 * PI - S.phi) / S.mu - top);\n      DM[p] = cl(1 + (S.truth * o) / deep, 0, 1);\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3;\n      if (K[p] === -1e9) {\n        const dx = x + 0.5 - CX, dy = CY - y - 0.5, r = hypot(dx, dy);\n        const e = abs(atan2(dx, dy)) - S.al, dw = r * sin(e), sw = r * cos(e);\n        // The solid: the wall line and a band of hatching behind it.\n        const hm = dw \u003c 6 && ((sw + dw) % 4 + 4) % 4 \u003c 1 ? 0.2 * (1 - dw / 6) : 0;\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = max(cl(1 - dw, 0, 1) * 0.5, hm);\n        continue;\n      }\n      const k = K[p], lu = LU[p], th = TH[p], dm = DM[p];\n      const b = cl(1 + lu / span, 0, 1);\n      const hue = k & 1 ? hB : hA;\n      let sep = 0, ring = 0;\n      const n = lev(lu);\n      for (let e = 0; e \u003c 4; e++) {\n        const X = x + (e === 0 ? 1 : e === 1 ? -1 : 0), Y = y + (e === 2 ? 1 : e === 3 ? -1 : 0);\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const pp = Y * W + X;\n        if (K[pp] === -1e9) continue;\n        if (K[pp] !== k) sep = 1;\n        else if (n \u003c 5 && lev(LU[pp]) > n) ring = 1;\n      }\n      sep *= cl((th - 2) / 4, 0, 1);\n      ring *= cl((th - 8) / 10, 0, 1);\n      hsv(hue, 0.9 - 0.35 * ring, dm * (0.12 + 0.25 * b + 0.5 * ring), c);\n      const dx = x + 0.5 - CX, dy = CY - y - 0.5, r = hypot(dx, dy);\n      const dw = r * sin(S.al - abs(atan2(dx, dy))), wl = cl(1 - dw, 0, 1) * 0.5;\n      const sv = sep * (0.35 + 0.55 * dm);\n      rgb[o] = max(c[0] + sv, wl); rgb[o + 1] = max(c[1] + sv, wl); rgb[o + 2] = max(c[2] + sv, wl);\n    }\n  for (let i = 0; i \u003c NP; i++) {\n    if (S.pu[i] \u003c 0) continue;\n    const dm = cl(1 + (S.truth * (S.a - 1) * min(0, (S.pk[i] * PI + 1.5 * PI - S.phi) / S.mu - top)) / deep, 0, 1);\n    for (let n = TL - 1; n > 0; n--) {\n      const b = dm * 0.7 * (1 - n / TL);\n      splat(rgb, S.tx[i * TL + n], S.ty[i * TL + n], b, b, b);\n    }\n    const X = floor(S.px[i]), Y = floor(S.py[i]);\n    if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) { const o = (Y * W + X) * 3; rgb[o] = rgb[o + 1] = rgb[o + 2] = max(rgb[o], dm); }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, floor(cl(rgb[o], 0, 1) * 255), floor(cl(rgb[o + 1], 0, 1) * 255), floor(cl(rgb[o + 2], 0, 1) * 255));\n  }\n}\n","simpson-paradox":"// ===== Patternflow pattern =====\n// Title:   Simpson's Paradox\n// Family:  data\n// Idea:    Three to five coloured clouds of points each rise to the right along their own least-squares line while the groups slide up and down like a seesaw, so the white least-squares line through all the points together swings through level and falls, and a slope gauge at the foot keeps every group's bar on the plus side while the pooled bar crosses to minus.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Simpson's paradox (Edward H. Simpson, 1951; named by Colin R. Blyth, 1972), after associations that vanish on pooling (Karl Pearson, 1899; G. Udny Yule, 1903), ordinary least squares (Adrien-Marie Legendre, 1805), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Groups=3..5, Spread=0..1\n//\n// Knob 1: Hue. Turns the groups' colours round the wheel together. At 0 three groups are amber, sea green and violet, four amber, green, blue and pink, five amber, green, cyan, violet and pink; the pooled line, its bar and the zero mark stay white whatever the knob.\n// Knob 2: Speed. At 2 one seesaw takes 12 s: the groups hold in the reversed order for 2 s, slide for 4 s, hold in agreement for 2 s and slide back for 4 s, and the pooled slope crosses zero near 3.6 s and 9.5 s of the first round. The points wander inside their groups on the same clock. At 0.2 one seesaw takes 120 s, at 3 it takes 8 s.\n// Knob 3: Groups. 3, 4 or 5 groups of 48, 38 or 30 points. Every group's own slope is 1.5 by construction, while the line through the group means tilts from -1.5 to +1.2; the fitted pooled slope ran from -1.33 to +1.30 with three groups and from -1.44 to +1.24 with five, and crosses zero where that tilt is -1.5 W / B, W the variance of x inside a group and B the variance of the group means: -0.14 for three groups, -0.09 for four, -0.06 for five.\n// Knob 4: Spread. The scatter of each point about its group's line, 5 LEDs at 0 and 11.5 at 1 with three groups, less with more groups as they get narrower. The groups' fitted slopes shiver more on the gauge: at the opening 0.06 they stayed between 0.97 and 2.08 over ten minutes, at 1 between 0.12 and 3.00 over an hour, never below zero. The pooled slope hardly moves, as scatter inside the groups adds nothing to the tilt between them.\n\nconst W = 64, H = 128;\n// The plot fills rows 0..107; the slope gauge sits in rows 110..127.\nconst PH = 108, GY = 110;\nconst { floor, round, min, max, abs, sqrt, exp, cos, log, PI, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => u * u * (3 - 2 * u);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nfunction gauss() {\n  let u = random();\n  while (u \u003c 1e-12) u = random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * random());\n}\n\n// Inside a group a point sits at x = cx + HX u and y = cy + SLOPE HX u + sigma e,\n// so the group's own trend is SLOPE (rows per column, y counted upward).\nconst SLOPE = 1.5;\n// The group centres stand at fixed columns, SX either side of the middle,\n// and their heights follow a tilt MB that the seesaw sweeps.\nconst SX = 21, YC = PH / 2;\nconst MB_LO = -1.5, MB_HI = 1.2;\n// The seesaw, in seconds at Speed 2.\nconst HOLD_LO = 2, GLIDE = 4, HOLD_HI = 2, CYCLE = HOLD_LO + GLIDE + HOLD_HI + GLIDE;\nconst NPTS = [0, 0, 0, 48, 38, 30];\n\nexport function setup(params) {\n  params.s = {\n    G: 0, n: 0, gi: [], home: [], w: [], e: [], x: [], y: [],\n    t: 0.4, mb: MB_LO, hue: 0, spread: 0,\n    fit: [], pooled: { b: 0, a: 0 }, sign: -1, flash: 0,\n    buf: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\nfunction populate(S, G) {\n  S.G = G;\n  const per = NPTS[G];\n  S.n = G * per;\n  S.gi = []; S.home = []; S.w = []; S.e = []; S.x = new Float64Array(S.n); S.y = new Float64Array(S.n);\n  for (let g = 0; g \u003c G; g++)\n    for (let i = 0; i \u003c per; i++) {\n      S.gi.push(g);\n      // Stratified along the group so every cloud covers its width.\n      S.home.push(-1 + (2 * (i + random())) / per);\n      S.w.push(0.12 * gauss());\n      S.e.push(gauss());\n    }\n  S.fit = [];\n  for (let g = 0; g \u003c G; g++) S.fit.push({ b: SLOPE, a: 0, x0: 0, x1: 0, mx: 0, my: 0 });\n}\n\nfunction tilt(t) {\n  t = t % CYCLE;\n  if (t \u003c HOLD_LO) return MB_LO;\n  t -= HOLD_LO;\n  if (t \u003c GLIDE) return MB_LO + (MB_HI - MB_LO) * ease(t / GLIDE);\n  t -= GLIDE;\n  if (t \u003c HOLD_HI) return MB_HI;\n  t -= HOLD_HI;\n  return MB_HI + (MB_LO - MB_HI) * ease(t / GLIDE);\n}\n\n// Ordinary least squares of y on x over the points whose group passes keep.\nfunction ols(S, keep, out) {\n  let n = 0, sx = 0, sy = 0;\n  for (let i = 0; i \u003c S.n; i++) if (keep(S.gi[i])) { n++; sx += S.x[i]; sy += S.y[i]; }\n  const mx = sx / n, my = sy / n;\n  let sxx = 0, sxy = 0, lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c S.n; i++)\n    if (keep(S.gi[i])) {\n      const dx = S.x[i] - mx;\n      sxx += dx * dx;\n      sxy += dx * (S.y[i] - my);\n      lo = min(lo, S.x[i]);\n      hi = max(hi, S.x[i]);\n    }\n  out.b = sxy / sxx;\n  out.a = my - out.b * mx;\n  out.mx = mx; out.my = my; out.x0 = lo; out.x1 = hi;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  const G = round(cl(k[2], 3, 5));\n  S.spread = cl(k[3], 0, 1);\n  if (G !== S.G) populate(S, G);\n  S.t += tau;\n  S.mb = tilt(S.t);\n  // The points wander inside their groups on Ornstein-Uhlenbeck walks: the\n  // scatter e keeps variance 1, and the offset w from a point's home along\n  // the group keeps a deviation of 0.12 of the half-width.\n  const th = 0.5, de = sqrt(2 * th * tau);\n  for (let i = 0; i \u003c S.n; i++) {\n    S.w[i] += -th * S.w[i] * tau + 0.12 * de * gauss();\n    S.e[i] += -th * S.e[i] * tau + de * gauss();\n  }\n  const half = (G - 1) / 2, HX = min(9, (0.47 * 2 * SX) / (G - 1));\n  // The scatter shrinks faster than the groups' width, so that over an hour\n  // at the widest spread no group's fitted slope fell below 0.12.\n  const sigma = (5 + 6.5 * S.spread) * (HX / 9) ** 1.5;\n  for (let i = 0; i \u003c S.n; i++) {\n    const kg = (S.gi[i] - half) / half, cx = W / 2 + SX * kg, cy = YC + S.mb * SX * kg;\n    const u = cl(S.home[i] + S.w[i], -1, 1);\n    S.x[i] = cx + HX * u;\n    S.y[i] = cy + SLOPE * HX * u + sigma * S.e[i];\n  }\n  for (let g = 0; g \u003c G; g++) ols(S, (j) => j === g, S.fit[g]);\n  ols(S, () => true, S.pooled);\n  const sign = S.pooled.b >= 0 ? 1 : -1;\n  if (sign !== S.sign) S.flash = 1;\n  S.sign = sign;\n  S.flash = max(0, S.flash - d / 0.6);\n}\n\nfunction groupHue(S, g) {\n  return S.hue + 0.12 + (S.G === 3 ? g * 0.3 : (g * 0.8) / (S.G - 1));\n}\n\n// Add a line y = a + b x (y upward in plot rows) between columns x0 and x1,\n// anti-aliased, width w, colour c times v, into the buffer with max blending.\nfunction line(buf, a, b, x0, x1, w, c, v) {\n  const nrm = sqrt(1 + b * b), r = w / 2 + 0.5;\n  for (let py = 0; py \u003c PH; py++) {\n    const yu = PH - 1 - py;\n    // Columns where the line passes within r of this row.\n    const xa = b === 0 ? -1 : (yu - a) / b, span = (r * nrm) / max(abs(b), 1e-6);\n    let lo = b === 0 ? 0 : floor(xa - span), hi = b === 0 ? W - 1 : Math.ceil(xa + span);\n    lo = max(lo, 0, floor(x0));\n    hi = min(hi, W - 1, Math.ceil(x1));\n    for (let x = lo; x \u003c= hi; x++) {\n      const dd = abs(b * x - yu + a) / nrm;\n      let f = cl(r - dd, 0, 1);\n      // Soft ends.\n      f *= cl(x - x0 + 1, 0, 1) * cl(x1 - x + 1, 0, 1);\n      if (f \u003c= 0) continue;\n      const p = (py * W + x) * 3;\n      for (let j = 0; j \u003c 3; j++) buf[p + j] = max(buf[p + j], c[j] * v * f);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.G) return;\n  const buf = S.buf, c = S.c, white = [1, 1, 1];\n  buf.fill(0);\n  // A faint wash round each point in its group's colour.\n  for (let i = 0; i \u003c S.n; i++) {\n    hsv(groupHue(S, S.gi[i]), 0.85, 1, c);\n    const X = S.x[i], Y = PH - 1 - S.y[i];\n    for (let dy = -2; dy \u003c= 2; dy++)\n      for (let dx = -2; dx \u003c= 2; dx++) {\n        const x = round(X) + dx, y = round(Y) + dy;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= PH) continue;\n        const r2 = (x - X) * (x - X) + (y - Y) * (y - Y), f = 0.12 * exp(-r2 / 3);\n        const p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) buf[p + j] = min(0.3, buf[p + j] + c[j] * f);\n      }\n  }\n  // Each group's own line, pale, across its points and faintly beyond.\n  for (let g = 0; g \u003c S.G; g++) {\n    const f = S.fit[g];\n    hsv(groupHue(S, g), 0.45, 1, c);\n    line(buf, f.a, f.b, 0, W - 1, 0.9, c, 0.13);\n    line(buf, f.a, f.b, f.x0 - 1, f.x1 + 1, 1.0, c, 0.75);\n  }\n  // The pooled line, white, thicker for a moment when its sign turns.\n  line(buf, S.pooled.a, S.pooled.b, 0, W - 1, 1.5 + 1.5 * S.flash, white, 1);\n  // Each group's mean as a small pale cross on its line.\n  for (let g = 0; g \u003c S.G; g++) {\n    const f = S.fit[g], X = round(f.mx), Y = round(PH - 1 - f.my);\n    hsv(groupHue(S, g), 0.3, 1, c);\n    for (let a = -2; a \u003c= 2; a++)\n      for (const [x, y] of [[X + a, Y], [X, Y + a]]) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= PH) continue;\n        const p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) buf[p + j] = c[j];\n      }\n  }\n  // The points on top, one LED each in full colour.\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = round(S.x[i]), y = round(PH - 1 - S.y[i]);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= PH) continue;\n    hsv(groupHue(S, S.gi[i]), 0.9, 1, c);\n    const p = (y * W + x) * 3;\n    buf[p] = c[0]; buf[p + 1] = c[1]; buf[p + 2] = c[2];\n  }\n  // The gauge: one bar per group and the pooled bar in white, from the zero\n  // mark in column 31, 16 LEDs per unit of slope, plus to the right.\n  const bars = S.G + 1, th = bars \u003c= 4 ? 3 : 2, gap = 1;\n  const top = GY + floor((H - GY - (bars * th + (bars - 1) * gap)) / 2);\n  for (let r = 0; r \u003c bars; r++) {\n    const pooled = r === S.G, b = pooled ? S.pooled.b : S.fit[r].b;\n    if (pooled) c[0] = c[1] = c[2] = 1;\n    else hsv(groupHue(S, r), 0.8, 1, c);\n    const len = cl(b * 16, -31, 31), y0 = top + r * (th + gap);\n    const xa = 32 + min(0, len), xb = 32 + max(0, len);\n    for (let y = y0; y \u003c y0 + th; y++)\n      for (let x = floor(xa); x \u003c Math.ceil(xb); x++) {\n        if (x \u003c 0 || x >= W) continue;\n        const f = cl(min(x + 1 - xa, xb - x), 0, 1) * (pooled ? 1 : 0.85);\n        const p = (y * W + x) * 3;\n        for (let j = 0; j \u003c 3; j++) buf[p + j] = c[j] * f;\n      }\n  }\n  for (let y = GY - 1; y \u003c H; y++) {\n    const p = (y * W + 31) * 3;\n    for (let j = 0; j \u003c 3; j++) buf[p + j] = max(buf[p + j], 0.35);\n  }\n  for (let p = 0, i = 0; p \u003c W * H; p++, i += 3)\n    display.setPixel(p & 63, p >> 6, round(cl(buf[i], 0, 1) * 255), round(cl(buf[i + 1], 0, 1) * 255), round(cl(buf[i + 2], 0, 1) * 255));\n}\n","trip-let":"// ===== Patternflow pattern =====\n// Title:   Trip-let\n// Family:  type\n// Idea:    A block carved as the intersection of three extruded letters turns in a slanting beam of light, a third of a turn at a time about its own diagonal, and each time one of its axes comes round to the beam the long shadow it throws across the floor stops being a lump and becomes a whole letter, G, then E, then B.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the trip-let of Gödel, Escher, Bach (Douglas Hofstadter, 1979), letters drawn for this pattern, pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Letters=0..5, Haze=0..1\n//\n// Knob 1: Hue. Turns the three lights round the wheel together. At 0 the beam is a pale azure white, so the pool on the floor is pale blue and the letter in it deep violet, and the block's faces take a violet light from the front left and a pink one from the right; at 0.5 the beam is pale peach and the block yellow-green.\n// Knob 2: Speed. At 2 the block holds each lined-up pose 1.6 s and takes 2.4 s over the next third of a turn, so the three letters come round every 12 s. At 0.2 a letter holds 16 s, at 3 a whole round takes 8 s.\n// Knob 3: Letters. Which block hangs in the beam: 0 GEB, 1 EGB (the cover's second block), 2 LED, 3 SUN, 4 ONE, 5 SEE, carved from 235, 240, 150, 182, 200 and 216 of the 512 voxels. Each was checked with all three letters whole in its shadow; with these glyphs YES, EYE, LUX, FUN and HUE are not, and LED only became whole once the right side of the D was carried down into its second row from the bottom.\n// Knob 4: Haze. Dust in the air, so the beam shows: the sky above the block reads 31/255 at the opening 0.06, 91 at 0.5 and 159 at 1, with the dark column of the shadow running from the block down to its letter.\n\n// The block is built from the letters and the shadows are cast from the\n// block: each frame a shadow map is marched through the voxels along the\n// beam, and the floor and the haze are lit or not from that map alone.\n// Read back at the 18 lined-up poses, each map matches its letter, scaled\n// to four texels a cell, on all 3600 texels, and the floor shows it as a\n// 32 x 32 LED letter, four LEDs a cell, without one LED wrong.\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, PI } = Math;\nconst N = 8, U = 4, HALFB = (N * U) / 2;\n// Camera: orthographic, looking down at EL. The light comes from behind the\n// block, ALPHA from straight up, at the same elevation as the camera, which\n// is what lets the long shadow read on the panel at its true shape.\nconst EL = (35 * PI) / 180, SE = sin(EL), CE = cos(EL);\nconst ALPHA = PI / 2 - EL, SA = sin(ALPHA), CA = cos(ALPHA);\n// The block's centre hangs HB above the floor, 39.07 units, chosen so that\n// at the lined-up poses every texel of the shadow lands on one LED.\nconst HB = 32 / SA;\nconst YC = 64; // screen row of the point of the floor under the block\nconst RP = 30; // radius of the beam\nconst MS = 2 * RP; // shadow map texels a side, one world unit each\nconst WFAR = 80; // where the map's lines of light start, below the block\n\n// 8x8 letters, rows from the top, bit 7 the left column.\nconst GLYPHS = {\n  G: [0x7e, 0xff, 0xc0, 0xcf, 0xcf, 0xc3, 0xff, 0x7e],\n  E: [0xff, 0xff, 0xc0, 0xfc, 0xfc, 0xc0, 0xff, 0xff],\n  B: [0xfe, 0xff, 0xc3, 0xfe, 0xfe, 0xc3, 0xff, 0xfe],\n  L: [0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xff, 0xff],\n  D: [0xfe, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xfe],\n  S: [0x7f, 0xff, 0xc0, 0xfe, 0x7f, 0x03, 0xff, 0xfe],\n  U: [0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0x7e],\n  N: [0xc3, 0xe3, 0xf3, 0xdb, 0xdb, 0xcf, 0xc7, 0xc3],\n  O: [0x7e, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0x7e],\n};\nconst WORDS = [\"GEB\", \"EGB\", \"LED\", \"SUN\", \"ONE\", \"SEE\"];\n\nconst lit = (ch, h, v) => (GLYPHS[ch][N - 1 - v] >> (N - 1 - h)) & 1;\n\n// The block: voxel (x, y, z) is solid when all three letters are lit where\n// it falls. Letter 0 is seen along x (h = y, v = z), letter 1 along y\n// (h = z, v = x), letter 2 along z (h = x, v = y).\nfunction carve(S, word) {\n  const vox = S.vox;\n  for (let x = 0; x \u003c N; x++)\n    for (let y = 0; y \u003c N; y++)\n      for (let z = 0; z \u003c N; z++)\n        vox[(x * N + y) * N + z] = lit(word[0], y, z) & lit(word[1], z, x) & lit(word[2], x, y);\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\nexport function setup(params) {\n  params.s = {\n    vox: new Uint8Array(N * N * N),\n    word: -1,\n    phase: 0,\n    R: new Float64Array(9),\n    top: new Float32Array(MS * MS),\n    hit: [0, 0],\n    key: [0, 0, 0],\n    fill: [0, 0, 0],\n    side: [0, 0, 0],\n  };\n}\n\nconst ease = (f) => f * f * f * (f * (f * 6 - 15) + 10);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s;\n  const k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = k[1];\n  S.haze = k[3];\n  const w = max(0, min(WORDS.length - 1, Math.round(k[2])));\n  if (w !== S.word) {\n    S.word = w;\n    carve(S, WORDS[w]);\n  }\n  S.phase += (dt * S.speed) / 8;\n  // A third of a turn about the block's diagonal at each step, so its axes\n  // come round x -> light, y -> light, z -> light: letter 0, 1, 2 in turn.\n  const step = floor(S.phase), f = S.phase - step;\n  const HOLD = 0.4;\n  const g = f \u003c HOLD ? 0 : ease((f - HOLD) / (1 - HOLD));\n  const th = (-2 * PI / 3) * (1 + step + g);\n  const c = cos(th), s = sin(th), t = 1 - c, a = 1 / sqrt(3);\n  // Rodrigues about (a, a, a): D maps x -> y -> z -> x at th = 2 pi / 3.\n  const d0 = c + a * a * t, d1 = a * a * t - a * s, d2 = a * a * t + a * s;\n  // Then T, whose columns are x, (0, CA, -SA) and (0, SA, CA), tilts z\n  // towards the light.\n  // R = T D, rows of D: [d0 d1 d2], [d2 d0 d1], [d1 d2 d0].\n  const R = S.R;\n  R[0] = d0; R[1] = d1; R[2] = d2;\n  R[3] = CA * d2 + SA * d1; R[4] = CA * d0 + SA * d2; R[5] = CA * d1 + SA * d0;\n  R[6] = -SA * d2 + CA * d1; R[7] = -SA * d0 + CA * d2; R[8] = -SA * d1 + CA * d0;\n}\n\n// Amanatides-Woo through the voxel grid from grid point (ox, oy, oz) along\n// (dx, dy, dz). Returns the entry t of the first solid voxel, its face in\n// S.hit as axis and sign, or -1. With last it returns the exit t of the last\n// solid voxel instead.\nfunction march(S, ox, oy, oz, dx, dy, dz, last) {\n  let t0 = -1e9, t1 = 1e9, ax = -1;\n  const E = 1e-12;\n  if (abs(dx) \u003c E) { if (ox \u003c 0 || ox > N) return -1; }\n  else { let a = -ox / dx, b = (N - ox) / dx; if (a > b) { const q = a; a = b; b = q; } if (a > t0) { t0 = a; ax = 0; } if (b \u003c t1) t1 = b; }\n  if (abs(dy) \u003c E) { if (oy \u003c 0 || oy > N) return -1; }\n  else { let a = -oy / dy, b = (N - oy) / dy; if (a > b) { const q = a; a = b; b = q; } if (a > t0) { t0 = a; ax = 1; } if (b \u003c t1) t1 = b; }\n  if (abs(dz) \u003c E) { if (oz \u003c 0 || oz > N) return -1; }\n  else { let a = -oz / dz, b = (N - oz) / dz; if (a > b) { const q = a; a = b; b = q; } if (a > t0) { t0 = a; ax = 2; } if (b \u003c t1) t1 = b; }\n  if (t0 > t1 || t1 \u003c 0) return -1;\n  let t = max(t0, 0);\n  const te = t + 1e-6;\n  let ix = floor(ox + dx * te), iy = floor(oy + dy * te), iz = floor(oz + dz * te);\n  ix = ix \u003c 0 ? 0 : ix >= N ? N - 1 : ix;\n  iy = iy \u003c 0 ? 0 : iy >= N ? N - 1 : iy;\n  iz = iz \u003c 0 ? 0 : iz >= N ? N - 1 : iz;\n  const sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, sz = dz > 0 ? 1 : -1;\n  const ddx = abs(dx) \u003c E ? 1e9 : abs(1 / dx), ddy = abs(dy) \u003c E ? 1e9 : abs(1 / dy), ddz = abs(dz) \u003c E ? 1e9 : abs(1 / dz);\n  let mx = abs(dx) \u003c E ? 1e9 : ((dx > 0 ? ix + 1 : ix) - ox) / dx;\n  let my = abs(dy) \u003c E ? 1e9 : ((dy > 0 ? iy + 1 : iy) - oy) / dy;\n  let mz = abs(dz) \u003c E ? 1e9 : ((dz > 0 ? iz + 1 : iz) - oz) / dz;\n  const vox = S.vox;\n  let found = -1;\n  for (;;) {\n    if (vox[(ix * N + iy) * N + iz]) {\n      if (!last) { S.hit[0] = ax; S.hit[1] = ax === 0 ? -sx : ax === 1 ? -sy : -sz; return t; }\n      found = min(mx, my, mz);\n    }\n    if (mx \u003c= my && mx \u003c= mz) { ix += sx; t = mx; mx += ddx; ax = 0; if (ix \u003c 0 || ix >= N) break; }\n    else if (my \u003c= mz) { iy += sy; t = my; my += ddy; ax = 1; if (iy \u003c 0 || iy >= N) break; }\n    else { iz += sz; t = mz; mz += ddz; ax = 2; if (iz \u003c 0 || iz >= N) break; }\n  }\n  return found;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const R = S.R, top = S.top;\n  const key = S.key, fill = S.fill, side = S.side;\n  hsv(S.hue + 0.55, 0.16, 1.25, key);\n  hsv(S.hue + 0.71, 0.62, 1, fill);\n  hsv(S.hue + 0.9, 0.5, 1, side);\n  // world (relative to the block's centre) -> grid\n  const gx = (x, y, z) => (R[0] * x + R[3] * y + R[6] * z) / U + N / 2;\n  const gy = (x, y, z) => (R[1] * x + R[4] * y + R[7] * z) / U + N / 2;\n  const gz = (x, y, z) => (R[2] * x + R[5] * y + R[8] * z) / U + N / 2;\n  // beam frame: eu = x, ev = (0, CA, -SA), eL = (0, SA, CA) towards the light\n  const Ly = SA, Lz = CA;\n  const lgx = (R[3] * Ly + R[6] * Lz) / U, lgy = (R[4] * Ly + R[7] * Lz) / U, lgz = (R[5] * Ly + R[8] * Lz) / U;\n  // Shadow map over the beam's cross-section: how far along eL the block\n  // reaches on each line of light (-1e9 where the line misses it).\n  for (let j = 0; j \u003c MS; j++)\n    for (let i = 0; i \u003c MS; i++) {\n      const u = i - RP + 0.5, v = j - RP + 0.5;\n      const x = u, y = v * CA - WFAR * SA, z = -v * SA - WFAR * CA;\n      const t = march(S, gx(x, y, z), gy(x, y, z), gz(x, y, z), lgx, lgy, lgz, true);\n      top[j * MS + i] = t \u003c 0 ? -1e9 : t - WFAR;\n    }\n  const lit3 = (x, y, z) => {\n    // x, y, z relative to the block's centre\n    const v = y * CA - z * SA, w = y * SA + z * CA;\n    const i = floor(x + RP), j = floor(v + RP);\n    if (i \u003c 0 || j \u003c 0 || i >= MS || j >= MS) return 1;\n    return top[j * MS + i] > w ? 0 : 1;\n  };\n  // camera: forward f = (0, CE, -SE), up = (0, SE, CE), right = x\n  const fy = CE, fz = -SE;\n  const cgx = (R[3] * fy + R[6] * fz) / U, cgy = (R[4] * fy + R[7] * fz) / U, cgz = (R[5] * fy + R[8] * fz) / U;\n  // two fills without shadows: the sky from the front left, a weaker one from the right\n  const AX = -0.62, AY = -0.62, AZ = 0.48, BX = 0.85, BY = -0.35, BZ = 0.4;\n  const al = 1 / Math.hypot(AX, AY, AZ), bl = 1 / Math.hypot(BX, BY, BZ);\n  const hazeK = 0.0012 + 0.007 * S.haze;\n  for (let py = 0; py \u003c H; py++) {\n    const Y = YC - (py + 0.5);\n    for (let px = 0; px \u003c W; px++) {\n      const X = px + 0.5 - W / 2;\n      // the ray through this LED, relative to the block's centre\n      const cx = X, cy = Y * SE, cz = Y * CE - HB;\n      let r = 0, g = 0, b = 0;\n      const tc = -(cy * fy + cz * fz);\n      const ex = cx, ey = cy + fy * tc, ez = cz + fz * tc;\n      let tBlock = 1e9;\n      if (ex * ex + ey * ey + ez * ez \u003c HALFB * HALFB * 3) {\n        const t0 = tc - 2 * HALFB;\n        const ox = cx, oy = cy + fy * t0, oz = cz + fz * t0;\n        const tt = march(S, gx(ox, oy, oz), gy(ox, oy, oz), gz(ox, oy, oz), cgx, cgy, cgz, false);\n        if (tt >= 0) {\n          tBlock = t0 + tt;\n          const ax = S.hit[0], sg = S.hit[1];\n          const nx = R[ax] * sg, ny = R[3 + ax] * sg, nz = R[6 + ax] * sg;\n          const hx = cx, hy = cy + fy * tBlock, hz = cz + fz * tBlock;\n          let kl = max(0, ny * Ly + nz * Lz);\n          if (kl > 0) {\n            const q = 0.05;\n            const qx = hx + nx * q, qy = hy + ny * q, qz = hz + nz * q;\n            if (march(S, gx(qx, qy, qz), gy(qx, qy, qz), gz(qx, qy, qz), lgx, lgy, lgz, false) >= 0) kl = 0;\n          }\n          const fa = max(0, (nx * AX + ny * AY + nz * AZ) * al), fb = max(0, (nx * BX + ny * BY + nz * BZ) * bl);\n          r = key[0] * kl + fill[0] * (0.05 + 0.7 * fa) + side[0] * 0.35 * fb;\n          g = key[1] * kl + fill[1] * (0.05 + 0.7 * fa) + side[1] * 0.35 * fb;\n          b = key[2] * kl + fill[2] * (0.05 + 0.7 * fa) + side[2] * 0.35 * fb;\n        }\n      }\n      // floor: world z = 0, which is z = -HB here\n      const tf = (cz + HB) / SE;\n      if (tBlock > 1e8) {\n        const wx = cx, wy = cy + fy * tf;\n        if (abs(wx) \u003c= W / 2 && wy \u003c 40 && wy > -110) {\n          const v = wy * CA + HB * SA;\n          const rr = sqrt(wx * wx + v * v);\n          const pool = rr \u003c RP - 0.5 ? 1 : rr > RP + 0.5 ? 0 : RP + 0.5 - rr;\n          const kk = pool > 0 ? pool * lit3(wx, wy, -HB) * CA : 0;\n          const ff = 0.12;\n          r = key[0] * kk + fill[0] * ff;\n          g = key[1] * kk + fill[1] * ff;\n          b = key[2] * kk + fill[2] * ff;\n        }\n      }\n      // haze in the beam, in front of whatever the ray meets\n      if (abs(cx) \u003c RP) {\n        const hw = sqrt(RP * RP - cx * cx);\n        const v0 = cy * CA - cz * SA, dv = fy * CA - fz * SA;\n        let ta = (-hw - v0) / dv, tb = (hw - v0) / dv;\n        if (ta > tb) { const q = ta; ta = tb; tb = q; }\n        tb = min(tb, tf, tBlock);\n        ta = max(ta, -200);\n        if (tb > ta) {\n          const n = 16, dtt = (tb - ta) / n;\n          let acc = 0;\n          for (let i = 0; i \u003c n; i++) {\n            const t = ta + (i + 0.5) * dtt;\n            acc += lit3(cx, cy + fy * t, cz + fz * t);\n          }\n          const hz = acc * dtt * hazeK;\n          r += key[0] * hz; g += key[1] * hz; b += key[2] * hz;\n        }\n      }\n      display.setPixel(px, py, min(255, r * 255), min(255, g * 255), min(255, b * 255));\n    }\n  }\n}\n","type-mosaic":"// ===== Patternflow pattern =====\n// Title:   Type Mosaic\n// Family:  type\n// Idea:    A word is spelled one big raised letter at a time on the faces of a turning four-sided prism, lit by a lamp that circles it, and the whole picture is set in small 3 by 5 letters, digits and signs, each cell taking the glyph whose ink matches the brightness there.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Studies in Perception I (Kenneth Knowlton and Leon Harmon, 1966), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Word=0..4, Cell=0..2\n//\n// Knob 1: Hue. Turns the type round the wheel, skipping red-orange to orange, which reads brown when dim. At 0 the letters alternate cyan and pink face by face, their brightest glyphs nearly white, on a face of dim violet dots.\n// Knob 2: Speed. At 2 a letter holds 2.2 s and the prism turns a quarter in 0.8 s, so TYPE takes 12 s; the lamp goes round once in 10 s, and each small glyph gives way to another of the same ink every 2.2 to 6.7 s. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Word. The word the prism spells: TYPE at 0, then INK, 1966, LOOK and BELL at 4.\n// Knob 4: Cell. The size of the small type. At 0 each glyph has a cell of 4 by 6 LEDs, 336 of them on a 16 by 21 grid; at 1 a cell of 5 by 8, 192 glyphs; at 2 the glyphs are drawn double, 6 by 10 in cells of 7 by 11, and the big letter is set in 99 of them, where the small type reads first and the big letter second.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The small type: a 3 by 5 face drawn for this pattern, rows top to bottom,\n// capitals and a few lower case letters with their bowls in the bottom three\n// rows. Each glyph's ink is its number of lit dots, 1 to 13 of 15.\nconst SMALL = {\n  \".\": \"000000000000010\", \",\": \"000000000010100\", \":\": \"000010000010000\", \"'\": \"010010000000000\",\n  \"-\": \"000000111000000\", \"^\": \"010101000000000\", \"_\": \"000000000000111\", \";\": \"000010000010100\",\n  '\"': \"101101000000000\", \"!\": \"010010010000010\", \"~\": \"000011110000000\",\n  \"+\": \"000010111010000\", x: \"000101010101000\", \"/\": \"001001010100100\", \"\u003c\": \"001010100010001\",\n  \">\": \"100010001010100\", v: \"000000101101010\", \"\\\\\": \"100100010001001\",\n  \"=\": \"000111000111000\", \"?\": \"111001010000010\", \"%\": \"101001010100101\", J: \"001001001101010\",\n  \"7\": \"111001010010010\", T: \"111010010010010\", L: \"100100100100111\", C: \"011100100100011\",\n  Y: \"101101010010010\", S: \"011100010001110\",\n  \"1\": \"010110010010111\", F: \"111100110100100\",\n  V: \"101101101101010\", X: \"101101010101101\", I: \"111010010010111\", Z: \"111001010100111\",\n  \"4\": \"101101111001001\", G: \"011100101101011\", N: \"110101101101101\",\n  K: \"101101110101101\", A: \"010101111101101\", P: \"111101111100100\", D: \"110101101101110\", R: \"110101110101101\",\n  \"2\": \"111001111100111\", \"3\": \"111001111001111\", \"5\": \"111100111001111\", U: \"101101101101111\",\n  H: \"101101111101101\", \"#\": \"101111101111101\", E: \"111100111100111\", B: \"110101111101110\",\n  \"0\": \"111101101101111\", \"6\": \"111100111101111\", \"9\": \"111101111001111\", M: \"101111111101101\", W: \"101101111111101\",\n  \"8\": \"111101111101111\", Q: \"111101101111111\", \"@\": \"111101111100111\",\n  o: \"000000111101111\", n: \"000000110101101\", u: \"000000101101111\", r: \"000000011100100\",\n  c: \"000000011100011\", h: \"100100111101101\", b: \"100100111101111\", d: \"001001111101111\",\n};\nconst GL = Object.values(SMALL).map((s) => Array.from(s, (c) => c === \"1\"));\nconst INK = GL.map((g) => g.filter(Boolean).length);\nconst MAXINK = max(...INK);\n// CLASS[k] lists the glyphs with ink k; an empty class borrows its neighbour.\nconst CLASS = [];\nfor (let k = 0; k \u003c= MAXINK; k++) CLASS.push(GL.map((_, i) => i).filter((i) => INK[i] === k));\nfor (let k = 1; k \u003c= MAXINK; k++) if (!CLASS[k].length) CLASS[k] = CLASS[k - 1].length ? CLASS[k - 1] : CLASS[k + 1];\n\n// The big letters as strokes on the prism face: x across from -18 to 18\n// LEDs (stretched 4% below), y down from 12 to 116, each stroke a list of\n// points, drawn as round strokes R LEDs in radius.\nfunction arc(cx, cy, rx, ry, a0, a1, n = 10) {\n  const pts = [];\n  for (let i = 0; i \u003c= n; i++) {\n    const a = a0 + ((a1 - a0) * i) / n;\n    pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n  }\n  return pts;\n}\nconst HP = PI / 2;\nconst BIG = {\n  T: [[[-18, 12], [18, 12]], [[0, 12], [0, 116]]],\n  Y: [[[-18, 12], [0, 62]], [[18, 12], [0, 62]], [[0, 62], [0, 116]]],\n  P: [[[-18, 116], [-18, 12]], [[-18, 12], [2, 12], ...arc(2, 38, 16, 26, -HP, HP), [-18, 64]]],\n  E: [[[-18, 12], [-18, 116]], [[-18, 12], [18, 12]], [[-18, 62], [12, 62]], [[-18, 116], [18, 116]]],\n  I: [[[0, 12], [0, 116]], [[-14, 12], [14, 12]], [[-14, 116], [14, 116]]],\n  N: [[[-18, 116], [-18, 12], [18, 116], [18, 12]]],\n  K: [[[-18, 12], [-18, 116]], [[18, 12], [-16, 70]], [[-6, 56], [18, 116]]],\n  1: [[[-12, 30], [2, 12], [2, 116]], [[-14, 116], [18, 116]]],\n  9: [arc(0, 42, 18, 30, 0, 2 * PI, 16), [[18, 42], [18, 86], ...arc(0, 86, 18, 30, 0, HP + 0.6, 6)]],\n  6: [arc(0, 86, 18, 30, 0, 2 * PI, 16), [[-18, 86], [-18, 42], ...arc(0, 42, 18, 30, PI, PI + HP + 0.6, 6)]],\n  L: [[[-18, 12], [-18, 116], [18, 116]]],\n  O: [arc(0, 64, 18, 52, 0, 2 * PI, 24)],\n  B: [[[-18, 12], [-18, 116]], [[-18, 12], [2, 12], ...arc(2, 37, 14, 25, -HP, HP, 8), [-18, 62]], [[-18, 62], [4, 62], ...arc(4, 89, 14, 27, -HP, HP, 8), [-18, 116]]],\n};\n// Each stroke as segments: x0, y0, x1, y1.\nconst SEG = {}, XS = 1.04;\nfor (const ch in BIG) {\n  const s = [];\n  for (const pl of BIG[ch]) for (let i = 0; i + 1 \u003c pl.length; i++) s.push(XS * pl[i][0], pl[i][1], XS * pl[i + 1][0], pl[i + 1][1]);\n  SEG[ch] = new Float32Array(s);\n}\nconst WORDS = [\"TYPE\", \"INK\", \"1966\", \"LOOK\", \"BELL\"];\n// The prism's half width, the stroke's radius, and the cell sizes.\nconst PW = 30, R = 12;\nconst CELLS = [\n  { cw: 4, ch: 6, sc: 1 },\n  { cw: 5, ch: 8, sc: 1 },\n  { cw: 7, ch: 11, sc: 2 },\n];\n\n// Distance from (x, y) to the nearest stroke, and the unit vector from the\n// stroke out to the point, written to out.\nfunction dist(seg, x, y, out) {\n  let best = 1e9, bx0 = 0, by0 = 0;\n  for (let i = 0; i \u003c seg.length; i += 4) {\n    const ax = seg[i], ay = seg[i + 1], bx = seg[i + 2] - ax, by = seg[i + 3] - ay;\n    const px = x - ax, py = y - ay, L = bx * bx + by * by;\n    const t = L > 0 ? cl((px * bx + py * by) / L, 0, 1) : 0;\n    const dx = px - t * bx, dy = py - t * by, d = dx * dx + dy * dy;\n    if (d \u003c best) { best = d; bx0 = dx; by0 = dy; }\n  }\n  const d = sqrt(best);\n  out[0] = d;\n  out[1] = d > 1e-6 ? bx0 / d : 0;\n  out[2] = d > 1e-6 ? by0 / d : 0;\n  return d;\n}\n\nexport function setup(params) {\n  params.s = { t: 0, hue: 0, word: 0, cell: 0, seed: new Float32Array(1024), rate: new Float32Array(1024), rgb: [0, 0, 0], dd: [0, 0, 0] };\n  for (let i = 0; i \u003c 1024; i++) {\n    params.s.seed[i] = Math.random() * 64;\n    params.s.rate[i] = 0.15 + 0.3 * Math.random();\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.t += cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3) / 2;\n  S.word = cl(round(k[2]), 0, WORDS.length - 1);\n  S.cell = cl(round(k[3]), 0, CELLS.length - 1);\n}\n\n// The prism turns a quarter at a time: each letter holds HOLD units, then\n// turns away to the left while the next comes in from the right.\nconst HOLD = 2.2, TURN = 0.8, PER = HOLD + TURN;\n// The lamp stands 40 degrees off the face's normal and goes round it once\n// in LAMP units of the clock, from the upper left at the start.\nconst LS = 0.64, LZ = 0.77, LAMP = 10, SH = 8;\nconst ease = (u) => u * u * (3 - 2 * u);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const word = WORDS[S.word], n = floor(S.t / PER), s = S.t - n * PER;\n  const phi = s \u003c HOLD ? 0 : ease((s - HOLD) / TURN) * HP;\n  const faces = [\n    { a: -phi, ch: word[n % word.length], k: n },\n    { a: HP - phi, ch: word[(n + 1) % word.length], k: n + 1 },\n  ];\n  const az = -0.75 * PI + (2 * PI * S.t) / LAMP, LX = LS * cos(az), LY = LS * sin(az);\n  const shx = -SH * LX, shy = -SH * LY;\n  for (const f of faces) {\n    f.c = cos(f.a);\n    f.x0 = PW * sin(f.a);\n    // The light in the face's own frame: x along the face, z out of it.\n    f.lx = LX * cos(f.a) - LZ * sin(f.a);\n    f.lz = LX * sin(f.a) + LZ * cos(f.a);\n    f.seg = SEG[f.ch];\n  }\n  const { cw, ch, sc } = CELLS[S.cell];\n  const cols = floor(W / cw), rows = floor(H / ch);\n  const ox = floor((W - cols * cw) / 2), oy = floor((H - rows * ch) / 2);\n  const rgb = S.rgb, h = S.hue, dd = S.dd;\n  const wheel = (f) => 0.11 + 0.89 * (f - floor(f));\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) display.setPixel(x, y, 0, 0, 0);\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++) {\n      const cx = ox + c * cw + (cw - 1) / 2 - 31.5, cy = oy + r * ch + (ch - 1) / 2;\n      // Which face of the prism this cell sees, and where on it.\n      let face = null, u = 0;\n      for (const f of faces) {\n        if (f.c \u003c= 0.001) continue;\n        const uu = (cx - f.x0) / (PW * f.c);\n        if (uu >= -1 && uu \u003c= 1) { face = f; u = uu; break; }\n      }\n      if (!face) continue;\n      const fx = u * PW, d = dist(face.seg, fx, cy, dd);\n      let tone, letter = false;\n      if (d \u003c R) {\n        // A round stroke: its normal leans out from the stroke's spine.\n        const q = d / R, nz = sqrt(1 - q * q);\n        const diff = max(0, q * (dd[1] * face.lx + dd[2] * LY) + nz * face.lz);\n        tone = 0.18 + 0.82 * diff;\n        letter = true;\n      } else {\n        // The flat face, lighter at the top, and the stroke's shadow on it.\n        tone = (0.05 + 0.2 * (1 - cy / H)) * (0.3 + max(0, face.lz));\n        if (dist(face.seg, fx - shx, cy - shy, dd) \u003c R) tone *= 0.15;\n      }\n      let ink = round(tone * MAXINK);\n      if (ink \u003c 1) continue;\n      ink = min(MAXINK, ink);\n      const cls = CLASS[ink], id = r * 32 + c;\n      const g = GL[cls[floor(S.seed[id] + S.t * S.rate[id]) % cls.length]];\n      if (letter) hsv(wheel(h + 0.44 + 0.38 * (face.k % 2)), 0.9 - 0.6 * tone, 1, rgb);\n      else hsv(wheel(h + 0.68), 0.8, 0.5, rgb);\n      const gx = ox + c * cw, gy = oy + r * ch;\n      for (let j = 0; j \u003c 5; j++)\n        for (let i = 0; i \u003c 3; i++)\n          if (g[j * 3 + i])\n            for (let yy = 0; yy \u003c sc; yy++)\n              for (let xx = 0; xx \u003c sc; xx++) display.setPixel(gx + i * sc + xx, gy + j * sc + yy, rgb[0] | 0, rgb[1] | 0, rgb[2] | 0);\n    }\n}\n","word-ladder":"// ===== Patternflow pattern =====\n// Title:   Word Ladder\n// Family:  type\n// Idea:    Lewis Carroll's word ladders build themselves down the tall panel: the first word writes itself stroke by stroke with the goal word waiting dimly at the bottom, each new rung is lowered from the one above while the ink of its one changed letter runs into the new letter on a lit cell, so the changed column zig-zags down the ladder until the goal lights, holds and clears for the next ladder.\n// Author:  patternflow-lab\n// Date:    2026-10-29\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Doublets (Lewis Carroll, 1879), pattern round 63\n// Round:   63\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ladder=0..11, Weight=0..1\n//\n// Knob 1: Hue. Turns the ladder's colours along the hues from green to pink, leaving out red, orange and yellow, which read brown on a dim cell. At 0 the words run from azure at the top through blue to violet at the goal, each changed letter white on a cell of its rung's colour; at 0.5 pink at the top, then green down to teal.\n// Knob 2: Speed. At 2 the first word takes 1.4 s to write, each rung 1.15 s, the solved ladder holds 2.6 s and clears in 1.1 s, so HEAD to TAIL is solved at 7.2 s and the next ladder starts at 10.9 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Ladder. Which of twelve ladders the panel starts on; after it the next follows. 0 is HEAD heal teal tell tall TAIL, the example Carroll gave when Doublets began in Vanity Fair on 29 March 1879. Then FOUR to FIVE, PIG to STY, WHEAT to BREAD, EYE to LID, COLD to WARM, FLOUR to BREAD, ONE to TWO in eight steps, APE to MAN, WET to DRY, LESS to MORE and TEA to HOT. The rungs share the 128 rows, 21 rows each for HEAD to TAIL, 14 for ONE to TWO, and the letters grow to fit: 16 LEDs tall for HEAD, 12 for WHEAT, 19 for EYE.\n// Knob 4: Weight. The pen: at 0 a hairline one LED wide, at the opening 0.06 still a hairline, at 1 a bold stroke 4 to 5 LEDs wide on HEAD, where the counters of A and D shrink to a slot.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Carroll's rule: every rung a word, and each differs from the one above in\n// exactly one letter. A ladder that breaks it is dropped here.\nconst LADDERS = [\n  \"HEAD HEAL TEAL TELL TALL TAIL\",\n  \"FOUR FOUL FOOL FOOT FORT FORE FIRE FIVE\",\n  \"PIG WIG WAG WAY SAY STY\",\n  \"WHEAT CHEAT CHEAP CHEEP CREEP CREED BREED BREAD\",\n  \"EYE DYE DIE DID LID\",\n  \"COLD CORD CARD WARD WARM\",\n  \"FLOUR FLOOR FLOOD BLOOD BROOD BROAD BREAD\",\n  \"ONE OWE EWE EYE DYE DOE TOE TOO TWO\",\n  \"APE APT OPT OAT MAT MAN\",\n  \"WET BET BAT BAY DAY DRY\",\n  \"LESS LOSS LOSE LORE MORE\",\n  \"TEA PEA PET POT HOT\",\n]\n  .map((s) => s.split(\" \"))\n  .filter((w) => w.every((a, r) => r === 0 || (a.length === w[0].length && [...a].filter((ch, i) => ch !== w[r - 1][i]).length === 1)));\n\n// The capitals, drawn for this pattern as pen strokes on a grid 4 wide and\n// 6 tall, y down, each stroke a polyline in the order a hand would draw it.\nconst STROKES = {\n  A: [[0, 6, 1.6, 0, 2.4, 0, 4, 6], [0.65, 4, 3.35, 4]],\n  B: [[0, 6, 0, 0, 2.8, 0, 3.7, 0.8, 3.7, 2.2, 2.8, 3, 0, 3], [2.8, 3, 4, 3.9, 4, 5.1, 3, 6, 0, 6]],\n  C: [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5]],\n  D: [[0, 0, 0, 6, 2.4, 6, 4, 4.4, 4, 1.6, 2.4, 0, 0, 0]],\n  E: [[4, 0, 0, 0, 0, 6, 4, 6], [0, 3, 3, 3]],\n  F: [[4, 0, 0, 0, 0, 6], [0, 3, 3, 3]],\n  G: [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 3.4, 2.2, 3.4]],\n  H: [[0, 0, 0, 6], [4, 0, 4, 6], [0, 3, 4, 3]],\n  I: [[1, 0, 3, 0], [2, 0, 2, 6], [1, 6, 3, 6]],\n  L: [[0, 0, 0, 6, 4, 6]],\n  M: [[0, 6, 0, 0, 2, 3.6, 4, 0, 4, 6]],\n  N: [[0, 6, 0, 0, 4, 6, 4, 0]],\n  O: [[1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5, 0, 1, 1, 0]],\n  P: [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2.2, 3, 3.2, 0, 3.2]],\n  R: [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2.2, 3, 3.2, 0, 3.2], [2, 3.2, 4, 6]],\n  S: [[4, 1, 3, 0, 1, 0, 0, 1, 0, 2, 1, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],\n  T: [[0, 0, 4, 0], [2, 0, 2, 6]],\n  U: [[0, 0, 0, 5, 1, 6, 3, 6, 4, 5, 4, 0]],\n  V: [[0, 0, 2, 6, 4, 0]],\n  W: [[0, 0, 1, 6, 2, 2.4, 3, 6, 4, 0]],\n  Y: [[0, 0, 2, 3, 4, 0], [2, 3, 2, 6]],\n};\n\n// Every letter resampled to NP points spaced evenly along its strokes, in\n// stroke order, so any letter can flow into any other point by point.\nconst NP = 120;\nconst GLYPH = {};\nfor (const ch in STROKES) {\n  const st = STROKES[ch];\n  let total = 0;\n  for (const s of st) for (let i = 2; i \u003c s.length; i += 2) total += Math.hypot(s[i] - s[i - 2], s[i + 1] - s[i - 1]);\n  const pts = new Float32Array(NP * 2);\n  let n = 0;\n  for (const s of st) {\n    for (let i = 2; i \u003c s.length; i += 2) {\n      const len = Math.hypot(s[i] - s[i - 2], s[i + 1] - s[i - 1]);\n      const share = (len / total) * NP;\n      const from = n, to = min(NP, round(from + share + (i === s.length - 2 && s === st[st.length - 1] ? NP : 0)));\n      for (let k = from; k \u003c to; k++) {\n        const t = to - from > 1 ? (k - from) / (to - from - 1) : 0;\n        pts[2 * k] = s[i - 2] + (s[i] - s[i - 2]) * t;\n        pts[2 * k + 1] = s[i - 1] + (s[i + 1] - s[i - 1]) * t;\n      }\n      n = to;\n    }\n  }\n  GLYPH[ch] = pts;\n}\n\nexport function setup(params) {\n  params.s = {\n    lad: -1, k3: -1, t: 0, hue: 0, speed: 2, weight: 0.06,\n    ink: new Float32Array(W * H * 3), col: [0, 0, 0],\n    PALE: [0, 1, 2, 3, 4, 5, 6, 7, 8].map(() => [0, 0, 0]), ACC: [0, 1, 2, 3, 4, 5, 6, 7, 8].map(() => [0, 0, 0]),\n    CELL: [0, 1, 2, 3, 4, 5, 6, 7, 8].map(() => [0, 0, 0]),\n  };\n}\n\nconst T_WRITE = 1.4, T_STEP = 1.15, T_HOLD = 2.6, T_CLEAR = 1.1;\nconst length = (n) => T_WRITE + (n - 1) * T_STEP + T_HOLD + T_CLEAR;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.weight = cl(kv[3], 0, 1);\n  const k3 = cl(round(kv[2]), 0, LADDERS.length - 1);\n  if (k3 !== S.k3) { S.k3 = k3; S.lad = k3; S.t = 0; }\n  S.t += (d * S.speed) / 2;\n  if (S.t > length(LADDERS[S.lad].length)) { S.t = 0; S.lad = (S.lad + 1) % LADDERS.length; }\n}\n\n// Lays a letter's points into the ink, each a disc of radius rad.\nfunction stamp(S, ch, x0, y0, sx, sy, rad, c, bright, upto) {\n  const pts = GLYPH[ch], ink = S.ink, n = upto === undefined ? NP : upto;\n  for (let k = 0; k \u003c n; k++) dot(ink, x0 + pts[2 * k] * sx, y0 + pts[2 * k + 1] * sy, rad, c, bright);\n}\n\nfunction dot(ink, x, y, rad, c, b) {\n  const r = rad + 0.5, xa = max(0, floor(x - r)), xb = min(W - 1, floor(x + r)), ya = max(0, floor(y - r)), yb = min(H - 1, floor(y + r));\n  for (let Y = ya; Y \u003c= yb; Y++)\n    for (let X = xa; X \u003c= xb; X++) {\n      const dx = X + 0.5 - x, dy = Y + 0.5 - y, w = cl(r - sqrt(dx * dx + dy * dy), 0, 1) * b;\n      if (w \u003c= 0) continue;\n      const o = (Y * W + X) * 3;\n      if (c[0] * w > ink[o]) ink[o] = c[0] * w;\n      if (c[1] * w > ink[o + 1]) ink[o + 1] = c[1] * w;\n      if (c[2] * w > ink[o + 2]) ink[o + 2] = c[2] * w;\n    }\n}\n\nfunction box(S, x0, y0, w, h, c, b) {\n  const ink = S.ink;\n  for (let y = max(0, round(y0)); y \u003c min(H, round(y0 + h)); y++)\n    for (let x = max(0, round(x0)); x \u003c min(W, round(x0 + w)); x++) {\n      const o = (y * W + x) * 3;\n      ink[o] = max(ink[o], c[0] * b); ink[o + 1] = max(ink[o + 1], c[1] * b); ink[o + 2] = max(ink[o + 2], c[2] * b);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.lad \u003c 0) return;\n  const words = LADDERS[S.lad], n = words.length, L = words[0].length, ink = S.ink;\n  ink.fill(0);\n  const rh = H / n, cw = (W - 4) / L;\n  const gh = min(rh * 0.74, (cw - 3) * 1.5), gw = min(cw - 3, gh * (L \u003c 4 ? 0.8 : 0.68));\n  const sx = gw / 4, sy = gh / 6;\n  const rad = 0.42 + S.weight * 0.1 * gh;\n  // The colour walks from the first word to the goal, azure to violet at 0,\n  // on the hues from green to pink: red, orange and yellow read brown on a\n  // dim cell.\n  const col = S.col, PALE = S.PALE, ACC = S.ACC, CELL = S.CELL;\n  for (let r = 0; r \u003c n; r++) {\n    const u = 0.39 + S.hue + (0.44 * r) / (n - 1), h = 0.3 + 0.64 * (u - floor(u));\n    hsv(h, 0.7, 1, PALE[r]);\n    hsv(h, 0.12, 1, ACC[r]);\n    hsv(h, 0.9, 1, CELL[r]);\n  }\n  const gx = (i) => 2 + i * cw + (cw - gw) / 2, gy = (r) => r * rh + (rh - gh) / 2;\n  const diff = (r) => { const a = words[r - 1], b = words[r]; for (let i = 0; i \u003c L; i++) if (a[i] !== b[i]) return i; return -1; };\n\n  const t = S.t, steps = n - 1;\n  const tEnd = T_WRITE + steps * T_STEP;\n  // How many rungs stand finished, and the one being lowered.\n  const done = t \u003c T_WRITE ? 1 : min(n, 1 + floor((t - T_WRITE) / T_STEP));\n  const live = t >= T_WRITE && t \u003c tEnd ? done : -1;\n  const tau = live > 0 ? t - T_WRITE - (live - 1) * T_STEP : 0;\n  const hold = t >= tEnd ? t - tEnd : -1;\n  const clear = hold > T_HOLD ? hold - T_HOLD : -1;\n  const fade = (r) => (clear \u003c 0 ? 1 : 1 - ease((clear - r * 0.07) / 0.35));\n\n  for (let r = 0; r \u003c n; r++) {\n    const f = fade(r);\n    if (f \u003c= 0) continue;\n    const y0 = gy(r), pale = PALE[r], acc = ACC[r], cell = CELL[r];\n    if (r \u003c done && r !== live) {\n      // A finished rung: the changed letter on its tinted cell.\n      const c = r > 0 ? diff(r) : -1;\n      let pulse = 0;\n      if (hold >= 0 && r > 0) pulse = max(0, 1 - abs(hold - 0.25 - r * 0.16) / 0.25);\n      if (c >= 0) box(S, 2 + c * cw + 1, r * rh + 1, cw - 2, rh - 2, cell, (0.3 + 0.3 * pulse) * f);\n      for (let i = 0; i \u003c L; i++) {\n        const ch = words[r][i];\n        if (r === 0 && t \u003c T_WRITE) {\n          // The first word writes itself, letter after letter in stroke order.\n          const p = cl((t / (T_WRITE * 0.85)) * L - i, 0, 1);\n          stamp(S, ch, gx(i), y0, sx, sy, rad, pale, f, floor(p * NP));\n        } else {\n          const goal = r === n - 1 && hold >= 0 ? max(0, 1 - hold / 0.6) : 0;\n          stamp(S, ch, gx(i), y0, sx, sy, rad, i === c ? acc : pale, f * (1 + 0.6 * pulse + goal));\n        }\n      }\n    } else if (r === live) {\n      // Lowering a copy of the rung above while one letter re-forms.\n      const c = diff(r), a = words[r - 1], drop = ease(tau / 0.5);\n      const yd = gy(r - 1) + drop * rh;\n      box(S, 2 + c * cw + 1, r * rh + 1, cw - 2, rh - 2, cell, 0.3 * ease((tau - 0.3) / 0.5));\n      if (r === n - 1) for (let i = 0; i \u003c L; i++) stamp(S, words[r][i], gx(i), y0, sx, sy, rad, pale, 0.38 * (1 - drop));\n      for (let i = 0; i \u003c L; i++) if (i !== c) stamp(S, a[i], gx(i), yd, sx, sy, rad, pale, 0.25 + 0.75 * drop);\n      // The changed letter rides down as the old glyph, then its ink runs\n      // point by point, in stroke order, into the new glyph.\n      const p0 = GLYPH[a[c]], p1 = GLYPH[words[r][c]], x0 = gx(c);\n      for (let k = 0; k \u003c NP; k++) {\n        const e = ease((tau - 0.3 - 0.35 * (k / NP)) / 0.4);\n        const xa = x0 + p0[2 * k] * sx, ya = yd + p0[2 * k + 1] * sy;\n        const xb = x0 + p1[2 * k] * sx, yb = y0 + p1[2 * k + 1] * sy;\n        const sw = sin(PI * e) * gh * 0.18, an = (2 * PI * k) / NP;\n        for (let j = 0; j \u003c 3; j++) col[j] = pale[j] + (acc[j] - pale[j]) * min(1, e * 3);\n        dot(ink, xa + (xb - xa) * e + sw * cos(an), ya + (yb - ya) * e + sw * sin(an), rad, col, (0.25 + 0.75 * drop) * (1 + 0.5 * sin(PI * e)));\n      }\n    } else {\n      // A rung still to find: blanks, and the goal word waiting dimly.\n      const a = t \u003c T_WRITE ? cl(t / T_WRITE, 0, 1) : 1;\n      if (r === n - 1) for (let i = 0; i \u003c L; i++) stamp(S, words[r][i], gx(i), y0, sx, sy, rad, pale, 0.38 * a * f);\n      else for (let i = 0; i \u003c L; i++) box(S, gx(i), y0 + gh - 1, gw, 1, pale, 0.3 * a * f);\n    }\n  }\n  // The rails, down to the lowest rung so far: the panel's two edge columns.\n  const reach = t \u003c T_WRITE ? (rh * t) / T_WRITE : live > 0 ? (live - 1 + ease(tau / 0.5)) * rh + rh : done * rh;\n  for (let y = 0; y \u003c min(H, round(reach)); y++) {\n    const r = min(n - 1, floor(y / rh)), f = fade(r) * 0.6;\n    if (f \u003c= 0) continue;\n    box(S, 0, y, 1, 1, PALE[r], f);\n    box(S, W - 1, y, 1, 1, PALE[r], f);\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const o = p * 3;\n    display.setPixel(p & 63, p >> 6, round(cl(ink[o], 0, 1) * 255), round(cl(ink[o + 1], 0, 1) * 255), round(cl(ink[o + 2], 0, 1) * 255));\n  }\n}\n","abrikosov-lattice":"// ===== Patternflow pattern =====\n// Title:   Abrikosov Lattice\n// Family:  physics\n// Idea:    A rotating Bose-Einstein condensate fills the tall panel in the lowest Landau level, its phase drawn as hue and its density as brightness, so each quantised vortex is a black core round which every hue turns once, the cores stand in Abrikosov's triangular lattice and turn with the fluid, and turning up the rotation packs them closer, Feynman's 2 m Omega / h to each unit of area, while new ones come in from the dark rim.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Abrikosov vortex lattice (Alexei Abrikosov, 1957), triangular vortex lattice (W. H. Kleiner, L. M. Roth and S. H. Autler, 1964), areal density of quantised vortices (Richard Feynman, 1955), vortex lattices in rotating Bose-Einstein condensates (K. W. Madison, F. Chevy, W. Wohlleben and J. Dalibard, 2000; J. R. Abo-Shaeer, C. Raman, J. M. Vogels and W. Ketterle, 2001), rapidly rotating condensate in the lowest Landau level (Tin-Lun Ho, 2001), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rotation=0.3..0.95, Round=0..1\n//\n// Knob 1: Hue. Turns the wheel the phase is drawn on. At 0 phase zero is azure, and the hues run azure, violet, magenta, red, gold, green and cyan anticlockwise round every core; at 0.5 phase zero is orange. Blue is paled toward periwinkle so that it does not read as a hole beside the cores, which are the only black.\n// Knob 2: Speed. How fast the lattice turns, anticlockwise with the flow round the cores, at 0.25 Speed Omega / omega radians a second: at 2 and the opening Rotation 0.3 it turns 0.15 rad/s, a sixth of a turn, the lattice's own symmetry, in 7 s; at 0.2 in 70 s, at 3 in 4.7 s.\n// Knob 3: Rotation. Omega / omega, from 0.3 to 0.95. Feynman's rule puts 2 m Omega / h vortices on each unit of area, so the spacing goes as 1 / sqrt(Omega): 25 LEDs at 0.3, where 9 to 13 cores sit in the bright cloud and 15 to 17 on the panel; 17.7 LEDs at 0.6, with 21 to 23 in the cloud; 14 LEDs at 0.95, with 31 to 37 in the cloud and 47 to 51 on the panel. The lattice closes in on the central core, so new vortices come in from the dark rim, and it turns faster in step with Omega.\n// Knob 4: Round. The trap's aspect. The cloud's half axes are 33 LEDs across and 33 (2 - Round) down: 64 at the opening 0.06, so the cloud fills the tall panel; 49.5 at 0.5; 33 at 1, a round cloud with 7 cores in it at the opening Rotation and the top and bottom of the panel dark.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, exp, cos, sin, atan2, round, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Abrikosov's lattice function in the lowest Landau level, Landau gauge,\n// lengths in the magnetic length l: Phi(x, y) = sum_n C_n e^(i q n y)\n// e^(-(x - q n)^2 / 2), with C_n = 1 for even n and i for odd n and\n// q^2 = pi sqrt 3, the triangular lattice of Kleiner, Roth and Autler. Its\n// zeros sit at (q/2, Ly/4) + the lattice, Ly = 2 pi / q, one to each area\n// 2 pi l^2, spacing D = sqrt(4 pi / sqrt 3) = 2.694 l.\nconst Q = sqrt(PI * sqrt(3)), LY = TAU / Q, D = sqrt((4 * PI) / sqrt(3)), X0 = Q / 2, Y0 = LY / 4;\nconst OUT = [0, 0];\nfunction phi(x, y) {\n  let re = 0, im = 0;\n  const n0 = round(x / Q), c = cos(Q * y), s = sin(Q * y);\n  // e^(i q n y) for n = n0 - 3 by one cos and sin, then by rotation.\n  let er = cos(Q * (n0 - 3) * y), ei = sin(Q * (n0 - 3) * y);\n  for (let n = n0 - 3; n \u003c= n0 + 3; n++) {\n    const u = x - Q * n, g = exp(-u * u / 2);\n    if (n & 1) (re -= ei * g), (im += er * g);\n    else (re += er * g), (im += ei * g);\n    const t = er * c - ei * s;\n    ei = er * s + ei * c;\n    er = t;\n  }\n  OUT[0] = re;\n  OUT[1] = im;\n  return OUT;\n}\n\n// Phi over one magnetic cell, x in [0, 2q) and y in [0, Ly), tabled once:\n// Phi(x + 2q j, y + Ly m) = e^(2 i q j y) Phi(x, y), so the table and one\n// phase give Phi anywhere.\nconst TX = 168, TY = 96, TRe = new Float32Array((TX + 1) * (TY + 1)), TIm = new Float32Array((TX + 1) * (TY + 1));\nfor (let j = 0; j \u003c= TY; j++)\n  for (let i = 0; i \u003c= TX; i++) {\n    const f = phi((i / TX) * 2 * Q, (j / TY) * LY);\n    TRe[j * (TX + 1) + i] = f[0];\n    TIm[j * (TX + 1) + i] = f[1];\n  }\n// The largest |Phi| in the table, the brightest point of every cell.\nlet MX = 0;\nfor (let o = 0; o \u003c TRe.length; o++) MX = max(MX, sqrt(TRe[o] * TRe[o] + TIm[o] * TIm[o]));\n// Phi at (x, y) from the table: modulus and argument.\nconst LOOK = [0, 0];\nfunction look(x, y) {\n  const jx = floor(x / (2 * Q)), my = floor(y / LY), u = ((x - jx * 2 * Q) / (2 * Q)) * TX, v = ((y - my * LY) / LY) * TY;\n  let i = floor(u), j = floor(v);\n  if (i >= TX) i = TX - 1;\n  if (j >= TY) j = TY - 1;\n  const fu = u - i, fv = v - j, o = j * (TX + 1) + i;\n  const re = (TRe[o] * (1 - fu) + TRe[o + 1] * fu) * (1 - fv) + (TRe[o + TX + 1] * (1 - fu) + TRe[o + TX + 2] * fu) * fv;\n  const im = (TIm[o] * (1 - fu) + TIm[o + 1] * fu) * (1 - fv) + (TIm[o + TX + 1] * (1 - fu) + TIm[o + TX + 2] * fu) * fv;\n  LOOK[0] = sqrt(re * re + im * im);\n  LOOK[1] = atan2(im, re) + 2 * Q * jx * y;\n  return LOOK;\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, rot: 0.3, round: 0.06, angle: 0, ek: -1, E: new Float32Array(N), A: new Float32Array(N), P: new Float32Array(N) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.rot = cl(k[2], 0.3, 0.95);\n  S.round = cl(k[3], 0, 1);\n  S.angle += d * 0.25 * S.speed * S.rot;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // Feynman's rule: vortices per area 2 m Omega / h, so the spacing goes as\n  // 1 / sqrt(Omega): 25 LEDs at Omega = 0.3 omega.\n  const dl = 25 * sqrt(0.3 / S.rot), sc = D / dl; // l per LED\n  const { A, P, E } = S, ca = cos(S.angle), sa = sin(S.angle), tmp = [0, 0, 0];\n  if (S.ek !== S.round) {\n    // The cloud: half axes 33 LEDs across and 33 (2 - Round) down, its\n    // envelope exp(-r^6), flat inside and falling over about 8 LEDs.\n    S.ek = S.round;\n    const a = 33, b = 33 * (2 - S.round);\n    for (let Y = 0, p = 0; Y \u003c H; Y++)\n      for (let X = 0; X \u003c W; X++, p++) {\n        const r2 = ((X - 31.5) / a) ** 2 + ((Y - 63.5) / b) ** 2;\n        E[p] = exp(-(r2 * r2 * r2));\n      }\n  }\n  // In the lab frame the condensate is this function in the symmetric gauge,\n  // f(z) e^(-|z|^2 / 4) with f holomorphic: Phi times e^(-i x y / 2), moved\n  // by a magnetic translation so a zero sits on the cloud's centre, and\n  // turned with the lattice, which keeps that form. So every zero winds\n  // the phase once anticlockwise. The cloud's envelope multiplies it, the\n  // slowly varying density times the lattice that many vortices make.\n  for (let Y = 0, p = 0; Y \u003c H; Y++)\n    for (let X = 0; X \u003c W; X++, p++) {\n      const px = (X - 31.5) * sc, py = (63.5 - Y) * sc;\n      // Into the lattice's turning frame, then onto Abrikosov's function\n      // with a zero on the cloud's centre.\n      const x = ca * px + sa * py, y = -sa * px + ca * py;\n      const f = look(x + X0, y + Y0), m = f[0];\n      // Symmetric gauge about the centre: arg Phi - x y / 2 - x0 y.\n      P[p] = f[1] - (x * y) / 2 - X0 * y;\n      A[p] = m * E[p];\n    }\n  // Brightness |psi|^1.25: a core is dark, below half brightness, over a\n  // disc 0.4 of the spacing across, 10 LEDs at the opening, where the\n  // steepest step between neighbours is 28 / 255.\n  for (let p = 0; p \u003c N; p++) {\n    const u = min(1, A[p] / MX), v = u * sqrt(sqrt(u)), h = S.hue + 0.6 + P[p] / TAU, e = max(0, 1 - abs(h - floor(h) - 0.667) * 7);\n    hsv(h, 1 - 0.35 * e * e, v, tmp);\n    display.setPixel(p & 63, p >> 6, round(tmp[0] * 255), round(tmp[1] * 255), round(tmp[2] * 255));\n  }\n}\n","balanced-rhythms":"// ===== Patternflow pattern =====\n// Title:   Balanced Rhythms\n// Family:  rhythm\n// Idea:    A playhead goes round a ring of steps and every onset it strikes adds its own unit vector to a walk drawn below, tip to tail, and when the onsets are perfectly balanced, their roots of unity summing to zero, the walk closes on its starting point at the end of every bar, even for the six onsets of 30 steps that no union of regular polygons can make.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: vanishing sums of roots of unity (N. G. de Bruijn, 1953; I. J. Schoenberg, 1964), the sizes a vanishing sum can have (T. Y. Lam and K. H. Leung, 2000), perfectly balanced rhythms and scales (Andrew Milne, David Bulger, Steffen Herff and William Sethares, 2015), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rhythm=0..1, Rotate=0..1\n//\n// Knob 1: Hue. Turns the components' colours round the wheel together. At 0 pentagons and the clave's three side are azure, triangles and its two side violet, digons green and a second triangle or digon pink; at 0.5 they are red, lime, magenta and cyan. The walk's edges and the wedges it sweeps take the colour of the component their onset came from. Orange is skipped, as it reads brown when dim.\n// Knob 2: Speed. One bar, once round the ring, takes 6 / Speed seconds: 3 s at 2, ten steps a second on 30 steps, 30 s at 0.2, 2 s at 3. Each onset flashes, draws its vector from the ring's centre and adds the same vector to the walk below, drawn out over 0.22 s.\n// Knob 3: Rhythm. Below 0.2, 6 onsets of 30 steps, 5, 6, 12, 18, 24 and 25: the pentagon from step 0 and the triangle from step 5, less the digon 0 and 15 joining them, dashed, so the walk's tent of two edges at 60 degrees either side of the top stands in for the pentagon's missing edge. It is balanced and no union of polygons; of the 2^30 sets of steps, 146,854 are balanced, 26,640 of them are no union of polygons, and the 30 smallest of those, 6 onsets each, are all turns of this one. To 0.4 a pentagon, a triangle and a digon, one for each prime of 30, 10 onsets; to 0.6 the pentagon with two vertices split by two triangles, 7 onsets; to 0.8 a triangle and two digons on 12 steps, 7 onsets, where with two primes every one of the 100 balanced sets is a union of polygons; then the son clave of 16 steps, 0, 3, 6, 10 and 12, which is not balanced: each bar's walk ends 0.082 of a step from its start, dashed, and the walk runs on four bars before it starts again.\n// Knob 4: Rotate. Turns one component round the ring, and a balanced rhythm stays balanced. In the first rhythm the triangle goes two steps a stop, 5 to 13, which moves the split to another vertex of the pentagon and turns the whole rhythm by 12 steps; in the second and fourth a digon goes one step a stop, and where it lands on an onset already there that step counts twice, a bigger dot and a walk edge twice as long; in the third the second triangle splits vertex 6, 18, 12 or 24 in turn. In the clave it turns the two side a step at a time and the miss grows from 0.082 to 0.710, 1.385, 2.009 and 2.556 steps. It opens at 0.06, the rhythms as listed.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, cos, sin, exp, round, ceil, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without its orange, 0.03 to 0.15, which reads brown when dim.\nconst wheel = (h) => 0.15 + (h - floor(h)) * 0.88;\n\n// The ring: centre (31.5, 31.5), radius 27, step k at 2 pi k / N clockwise\n// from the top. The walk below: centred on (31.5, 96.5) in a 58 x 54 box.\nconst CX = 31.5, CY = 31.5, RING = 27, WX = 31.5, WY = 96.5, WW = 58, WH = 54;\n// A component is a regular m-gon from step `off`, or a set of steps; `turn`\n// lists where Rotate puts it. `links` are digons taken away: the antipodal\n// pair with one end in each of the two components named.\nconst RHYTHMS = [\n  // A pentagon and a triangle, less the digon joining them: 6 onsets of 30,\n  // balanced and no union of polygons.\n  { N: 30, comps: [{ m: 5, off: 0, c: 0 }, { m: 3, off: 5, c: 1, turn: [5, 7, 9, 11, 13] }], links: [[0, 1]] },\n  // A pentagon, a triangle and a digon, one for each prime of 30: 10 onsets.\n  { N: 30, comps: [{ m: 5, off: 1, c: 0 }, { m: 3, off: 0, c: 1 }, { m: 2, off: 2, c: 2, turn: [2, 3, 4, 5, 6] }], links: [] },\n  // The pentagon with two of its vertices split by two triangles: 7 onsets.\n  { N: 30, comps: [{ m: 5, off: 0, c: 0 }, { m: 3, off: 5, c: 1 }, { m: 3, off: 11, c: 3, turn: [11, 13, 17, 19] }], links: [[0, 1], [0, 2]] },\n  // 12 steps, two primes: a triangle and two digons, 7 onsets.\n  { N: 12, comps: [{ m: 3, off: 0, c: 1 }, { m: 2, off: 1, c: 2, turn: [1, 2, 3, 4, 5] }, { m: 2, off: 5, c: 3 }], links: [] },\n  // The son clave of 16 steps, which is not balanced, its two side turned.\n  { N: 16, comps: [{ set: [0, 3, 6], c: 0 }, { set: [10, 12], c: 1, turn: [0, 1, 2, 3, 4] }], links: [] },\n];\n\n// An unbalanced walk keeps four bars, then starts again.\nconst KEEP = 4;\n\nfunction build(S, which, j) {\n  const R = RHYTHMS[which], N = R.N;\n  const pts = R.comps.map((c) => {\n    const t = c.turn ? c.turn[min(c.turn.length - 1, round(j * (c.turn.length - 1)))] : c.off ?? 0;\n    if (c.set) return c.set.map((k) => (k + t) % N);\n    const out = [];\n    for (let i = 0; i \u003c c.m; i++) out.push((t + (i * N) / c.m) % N);\n    return out;\n  });\n  const coef = new Int32Array(N), owner = new Int32Array(N).fill(-1);\n  pts.forEach((p, ci) =>\n    p.forEach((k) => {\n      coef[k]++;\n      if (owner[k] \u003c 0) owner[k] = R.comps[ci].c;\n    }),\n  );\n  const links = [];\n  for (const [a, b] of R.links) {\n    const k = pts[a].find((p) => pts[b].includes((p + N / 2) % N));\n    links.push(k);\n    coef[k]--;\n    coef[(k + N / 2) % N]--;\n  }\n  // The onsets in time order, each with its vector (sin, -cos) on the\n  // screen, as long as its weight.\n  const on = [];\n  for (let k = 0; k \u003c N; k++) if (coef[k] > 0) on.push(k);\n  const vx = new Float64Array(N), vy = new Float64Array(N);\n  for (let k = 0; k \u003c N; k++) {\n    const a = (2 * PI * k) / N;\n    vx[k] = coef[k] * sin(a);\n    vy[k] = -coef[k] * cos(a);\n  }\n  let x = 0, y = 0;\n  const P = [[0, 0]];\n  for (const k of on) P.push([(x += vx[k]), (y += vy[k])]);\n  const fx = x, fy = y, balanced = sqrt(fx * fx + fy * fy) \u003c 1e-9;\n  // Fit the walk, one bar when it closes, four when it does not.\n  const fit = balanced ? 1 : KEEP;\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let b = 0; b \u003c fit; b++)\n    for (const [px, py] of P) {\n      x0 = min(x0, px + b * fx);\n      x1 = max(x1, px + b * fx);\n      y0 = min(y0, py + b * fy);\n      y1 = max(y1, py + b * fy);\n    }\n  const e = min(WW / max(1e-6, x1 - x0), WH / max(1e-6, y1 - y0), 24);\n  Object.assign(S, {\n    which, j, N, pts, coef, owner, links, on, vx, vy, P, fx, fy, balanced, e,\n    ox: WX - ((x0 + x1) / 2) * e, oy: WY - ((y0 + y1) / 2) * e,\n    phase: -1e-6, pos: [0, 0], start: [0, 0], verts: [[0, 0]], hist: [], kept: 0,\n    fire: new Float64Array(N).fill(-99), edgeAt: -99, closeAt: -99,\n  });\n}\n\nexport function setup(params) {\n  params.s = null;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  let S = params.s;\n  if (!S) S = params.s = { clock: 0, maxClose: 0, barCount: 0, col: new Float32Array(15), R: new Float32Array(NP), G: new Float32Array(NP), B: new Float32Array(NP) };\n  const which = min(RHYTHMS.length - 1, floor(cl(k[2], 0, 1) * RHYTHMS.length)), j = cl(k[3], 0, 1);\n  const R = RHYTHMS[which], turns = R.comps.find((c) => c.turn)?.turn.length ?? 1;\n  const jj = round(j * (turns - 1)) / max(1, turns - 1);\n  if (S.which !== which || S.j !== jj) build(S, which, jj);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.clock += d;\n  // One bar takes 6 / Speed seconds.\n  const old = S.phase * S.N;\n  S.phase += d / (6 / S.speed);\n  const now = S.phase * S.N;\n  for (let a = floor(old) + 1; a \u003c= floor(now); a++) {\n    const step = ((a % S.N) + S.N) % S.N;\n    if (step === 0) {\n      // A new bar. The walk should be back where the bar began.\n      const ex = S.pos[0] - S.start[0], ey = S.pos[1] - S.start[1];\n      if (S.balanced && a > 0) S.maxClose = max(S.maxClose, sqrt(ex * ex + ey * ey));\n      if (a > 0) S.barCount++;\n      if (!S.balanced) {\n        S.hist.push(S.verts);\n        if (++S.kept >= KEEP) (S.kept = 0), (S.hist = []), (S.pos = [0, 0]);\n      }\n      S.start = [S.pos[0], S.pos[1]];\n      S.verts = [[S.pos[0], S.pos[1]]];\n    }\n    if (S.coef[step] > 0) {\n      S.pos = [S.pos[0] + S.vx[step], S.pos[1] + S.vy[step]];\n      S.verts.push(S.pos);\n      S.fire[step] = S.clock;\n      S.edgeAt = S.clock;\n      const cx = S.pos[0] - S.start[0], cy = S.pos[1] - S.start[1];\n      if (S.balanced && S.verts.length > 2 && sqrt(cx * cx + cy * cy) \u003c 1e-9) S.closeAt = S.clock;\n    }\n  }\n}\n\n// Light into the float frame: a bilinear dot, and lines of them.\nfunction dot(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  put(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  put(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  put(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  put(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction put(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction line(S, x0, y0, x1, y1, v, c, o, dash) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, ceil(len * 2.5)), w = (v * len) / n;\n  for (let i = 0; i \u003c= n; i++) {\n    if (dash && floor((i / n) * len / 2) % 2) continue;\n    dot(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n  }\n}\n// A line two LEDs wide: two lines half an LED either side.\nfunction thick(S, x0, y0, x1, y1, v, c, o) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) || 1, nx = (-(y1 - y0) / len) * 0.45, ny = ((x1 - x0) / len) * 0.45;\n  line(S, x0 + nx, y0 + ny, x1 + nx, y1 + ny, v * 0.75, c, o);\n  line(S, x0 - nx, y0 - ny, x1 - nx, y1 - ny, v * 0.75, c, o);\n}\n// A round dot of radius r, its rim soft.\nfunction disc(S, x, y, r, v, c, o) {\n  for (let iy = floor(y - r - 1); iy \u003c= ceil(y + r + 1); iy++)\n    for (let ix = floor(x - r - 1); ix \u003c= ceil(x + r + 1); ix++) {\n      const d = sqrt((ix + 0.5 - x) ** 2 + (iy + 0.5 - y) ** 2), f = cl(r + 0.5 - d, 0, 1);\n      if (f > 0) put(S, ix, iy, f * v, c, o);\n    }\n}\nconst WHITE = [1, 1, 1, 0.35, 0.35, 0.35, 1, 0.25, 0.3];\n\n// Fill a convex polygon with v of colour c, row by row: a pixel is in when\n// its centre is. Two wedges that share an edge share no pixel.\nfunction fill(S, poly, v, c, o) {\n  const n = poly.length;\n  if (n \u003c 3) return;\n  let y0 = 1e9, y1 = -1e9;\n  for (const q of poly) (y0 = min(y0, q[1])), (y1 = max(y1, q[1]));\n  for (let y = max(0, ceil(y0 - 0.5)); y \u003c= min(H - 1, floor(y1 - 0.5)); y++) {\n    const py = y + 0.5 + 6.1e-5;\n    let xa = 1e9, xb = -1e9;\n    for (let i = 0; i \u003c n; i++) {\n      const a = poly[i], b = poly[(i + 1) % n];\n      if ((a[1] \u003c= py && b[1] > py) || (b[1] \u003c= py && a[1] > py)) {\n        const x = a[0] + ((py - a[1]) / (b[1] - a[1])) * (b[0] - a[0]);\n        xa = min(xa, x);\n        xb = max(xb, x);\n      }\n    }\n    // Centres x + 0.5 in [xa, xb).\n    for (let x = max(0, ceil(xa - 0.5 - 3.7e-5)); x \u003c= min(W - 1, ceil(xb - 0.5 - 3.7e-5) - 1); x++) {\n      const p = y * W + x;\n      S.R[p] += v * c[o];\n      S.G[p] += v * c[o + 1];\n      S.B[p] += v * c[o + 2];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, G, B, col, N, coef, owner } = S;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  // Component colours: azure, violet, green, pink at Hue 0.\n  for (let c = 0; c \u003c 4; c++) hsv(wheel(0.49 + S.hue + [0, 0.19, 0.77, 0.4][c]), 0.75, 1, col, c * 3);\n  const t = S.clock;\n  const ang = (k) => (2 * PI * k) / N;\n  const rx = (k, r) => CX + r * sin(ang(k)), ry = (k, r) => CY - r * cos(ang(k));\n\n  // The ring, faint, and the playhead with its arc trailing behind and a\n  // faint hand from the centre.\n  const u = S.phase - floor(S.phase);\n  for (let i = 0; i \u003c 160; i++) dot(S, CX + RING * sin((2 * PI * i) / 160), CY - RING * cos((2 * PI * i) / 160), 0.16, WHITE, 3);\n  for (let i = 0; i \u003c 48; i++) {\n    const a = 2 * PI * u - (i / 48) * 1.1;\n    dot(S, CX + (RING + 3.5) * sin(a), CY - (RING + 3.5) * cos(a), 0.6 * (1 - i / 48), WHITE, 0);\n  }\n  disc(S, CX + (RING + 3.5) * sin(2 * PI * u), CY - (RING + 3.5) * cos(2 * PI * u), 1.2, 1, WHITE, 0);\n  line(S, CX, CY, CX + (RING - 3) * sin(2 * PI * u), CY - (RING - 3) * cos(2 * PI * u), 0.22, WHITE, 0);\n  // The polygons inside, each lit up a moment when one of its onsets is struck.\n  const comps = RHYTHMS[S.which].comps;\n  S.pts.forEach((p, ci) => {\n    const c = comps[ci].c, sorted = [...p].sort((a, b) => a - b);\n    let f = 0;\n    for (const k of p) f = max(f, exp(-(t - S.fire[k]) / 0.3));\n    for (let i = 0; i \u003c sorted.length; i++) {\n      const a = sorted[i], b = sorted[(i + 1) % sorted.length];\n      if (sorted.length === 2 && i === 1) break;\n      line(S, rx(a, RING - 2), ry(a, RING - 2), rx(b, RING - 2), ry(b, RING - 2), 0.4 + 0.5 * f, col, c * 3);\n    }\n  });\n  // The digons taken away, dashed.\n  for (const k of S.links) {\n    line(S, rx(k, RING - 2), ry(k, RING - 2), rx(k + N / 2, RING - 2), ry(k + N / 2, RING - 2), 0.55, WHITE, 3, true);\n    // Its ends, emptied: a hollow ring where each polygon lost a vertex.\n    for (const q of [k, k + N / 2])\n      for (let i = 0; i \u003c 16; i++) dot(S, rx(q, RING) + 2.2 * cos((PI * i) / 8), ry(q, RING) + 2.2 * sin((PI * i) / 8), 0.16, WHITE, 0);\n  }\n  // The steps: onsets in their colours, flashing white as they are struck,\n  // with their vectors from the centre; rests a dim grey.\n  for (let k = 0; k \u003c N; k++) {\n    const x = rx(k, RING), y = ry(k, RING);\n    if (coef[k] > 0) {\n      const f = exp(-(t - S.fire[k]) / 0.35), c = owner[k] * 3;\n      const tmp = [col[c] + (1 - col[c]) * f, col[c + 1] + (1 - col[c + 1]) * f, col[c + 2] + (1 - col[c + 2]) * f];\n      disc(S, x, y, (coef[k] > 1 ? 2.3 : 1.6) + 0.6 * f, 0.75 + 0.25 * f, tmp, 0);\n      const fv = exp(-(t - S.fire[k]) / 0.4);\n      if (fv > 0.02) thick(S, CX, CY, rx(k, RING - 2.5), ry(k, RING - 2.5), fv, col, c);\n    } else dot(S, x, y, 0.7, WHITE, 3);\n  }\n\n  // The walk.\n  const e = S.e, X = (p) => S.ox + p[0] * e, Y = (p) => S.oy + p[1] * e;\n  const verts = S.verts, last = verts.length - 1;\n  // The edge struck last is drawn out over 0.22 s.\n  const ease = min(1, (t - S.edgeAt) / 0.22), ee = 1 - (1 - ease) ** 3;\n  let tipx = verts[last][0], tipy = verts[last][1];\n  if (last > 0 && ease \u003c 1) {\n    tipx = verts[last - 1][0] + (verts[last][0] - verts[last - 1][0]) * ee;\n    tipy = verts[last - 1][1] + (verts[last][1] - verts[last - 1][1]) * ee;\n  }\n  const tip = [X([tipx, tipy]), Y([tipx, tipy])];\n  const own = (i) => owner[S.on[i % S.on.length]] * 3;\n  const sx = X(S.start), sy = Y(S.start);\n  if (S.balanced) {\n    // The whole bar's polygon, faint, from where this bar began.\n    const poly = S.P.slice(0, -1).map((p) => [X([p[0] + S.start[0], p[1] + S.start[1]]), Y([p[0] + S.start[0], p[1] + S.start[1]])]);\n    fill(S, poly, 0.12, col, 0);\n    for (let i = 0; i \u003c S.on.length; i++) {\n      const a = poly[i], b = poly[(i + 1) % poly.length];\n      line(S, a[0], a[1], b[0], b[1], 0.35, col, own(i));\n    }\n    // The part swept so far this bar, a wedge from the start to each edge in\n    // the edge's colour.\n    for (let i = 1; i \u003c= last; i++) {\n      const a = [X(verts[i - 1]), Y(verts[i - 1])], b = i === last ? tip : [X(verts[i]), Y(verts[i])];\n      fill(S, [[sx, sy], a, b], 0.22, col, own(i - 1));\n    }\n  } else {\n    // Earlier bars of the walk, dimmer, each with its miss dashed in red.\n    for (const h of S.hist) {\n      for (let i = 1; i \u003c h.length; i++) line(S, X(h[i - 1]), Y(h[i - 1]), X(h[i]), Y(h[i]), 0.45, col, own(i - 1));\n      line(S, X(h[h.length - 1]), Y(h[h.length - 1]), X(h[0]), Y(h[0]), 0.8, WHITE, 6, true);\n      disc(S, X(h[h.length - 1]), Y(h[h.length - 1]), 1, 0.8, WHITE, 6);\n    }\n  }\n  for (let i = 1; i \u003c last; i++) thick(S, X(verts[i - 1]), Y(verts[i - 1]), X(verts[i]), Y(verts[i]), 0.9, col, own(i - 1));\n  if (last > 0) thick(S, X(verts[last - 1]), Y(verts[last - 1]), tip[0], tip[1], 1.1, col, own(last - 1));\n  if (!S.balanced && last > 0) line(S, tip[0], tip[1], sx, sy, 0.6, WHITE, 6, true);\n  // The start, ringing when the walk comes back to it, and the tip.\n  const fc = exp(-(t - S.closeAt) / 0.45);\n  disc(S, sx, sy, 1.3 + fc, 0.7 + 0.3 * fc, WHITE, 0);\n  if (fc > 0.02) for (let i = 0; i \u003c 32; i++) dot(S, sx + (2.5 + 6 * (1 - fc)) * cos((2 * PI * i) / 32), sy + (2.5 + 6 * (1 - fc)) * sin((2 * PI * i) / 32), 0.6 * fc, WHITE, 0);\n  disc(S, tip[0], tip[1], 1.2, 1, WHITE, 0);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","berggren-tree":"// ===== Patternflow pattern =====\n// Title:   Berggren Tree\n// Family:  number\n// Idea:    Berggren's ternary tree of primitive Pythagorean triples grows from (3, 4, 5) one generation at a time over the plane of the legs, odd leg up and even leg across, its A and C branches running along the parabolas c - b = k^2 and c - a = 2n^2 on whose crossings every primitive triple sits, its B branches jumping between them, while the window widens to keep the newest generation at the edge and the crossings that are multiples never light.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euclid's formula for Pythagorean triples (Euclid, c. 300 BC), tree of primitive Pythagorean triples (B. Berggren, 1934), rediscovered (F. J. M. Barning, 1963; A. Hall, 1970), the count N / 2 pi of primitive triples with c below N (D. N. Lehmer, 1900), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Reach=-1..1, Root=0..1\n//\n// Knob 1: Hue. Turns the three matrices' colours round the wheel, skipping orange and yellow. At 0 the A branches and the triples A made are azure, C's rose and B's pale violet, with (3, 4, 5) white; at 0.25 violet, green and pink, at 0.5 red, cyan and pale green, at 0.75 green, blue and pale azure. The faint parabolas take the colour of their branches.\n// Knob 2: Speed. At 2 the first tree opens three generations grown, the window reaching odd legs of 173 and even legs of 86, and takes the rest of a 12 s run to grow to the full Reach: at Reach 0 one generation every 1.1 s, full at 8.7 s. It holds 4 s while a pulse runs out from the root a generation at a time, then fades and starts again from (3, 4, 5) alone, every 16 s. At 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Reach. How far the window has widened when the run ends: odd legs up to 128 u and even legs up to 64 u, u = 4 x 2^Reach. At 0 the legs reach 512 and 256 and the window holds 61 triples down to the 10th generation, on 71 crossings of the two families, 10 of them multiples like 9 (3, 4, 5) that stay dark; at -1, 30 triples to the 6th generation, at 1, 124 to the 14th. The window starts at 0.18 of its last size at Reach 0 (0.28 at -1, 0.12 at 1) and widens as (G + 8)^2 with the generation G.\n// Knob 4: Root. Bends the plane from the legs, z^2 for z = m + i n, at 0.06 and below, to z itself at 1, the plane of Euclid's (m, n): the parabolas straighten, the C branches stand upright with n fixed, the A branches run at 45 degrees with m - n fixed, and the triples sit on the lattice of coprime m > n of opposite parity.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, round, min, max, abs, sqrt, atan2, cos, sin, pow, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n// The wheel without its orange and yellow, 0.03 to 0.17.\nconst wheel = (h) => 0.17 + (h - floor(h)) * 0.86;\n\n// Every primitive triple is (m^2 - n^2, 2mn, m^2 + n^2) for one pair m > n\n// > 0, coprime and of opposite parity, and Berggren's matrices A, B and C on\n// (a, b, c) are, on (m, n):\n//   A: (m, n) -> (2m - n, m)   keeps m - n, so c - b = (m - n)^2\n//   B: (m, n) -> (2m + n, m)\n//   C: (m, n) -> (m + 2n, n)   keeps n, so c - a = 2 n^2\n// from (2, 1), which is (3, 4, 5). A child's c is always larger than its\n// parent's, so cutting the tree at c \u003c= CB keeps every triple up to CB.\nconst UMAX = 8, CB = 170 * UMAX;\nconst NM = [2], NN = [1], ND = [0], NX = [-1], NPAR = [-1];\nfor (let i = 0; i \u003c NM.length; i++) {\n  const m = NM[i], n = NN[i], kids = [[2 * m - n, m], [2 * m + n, m], [m + 2 * n, n]];\n  for (let k = 0; k \u003c 3; k++) {\n    const M = kids[k][0], N = kids[k][1];\n    if (M * M + N * N > CB) continue;\n    NM.push(M);\n    NN.push(N);\n    ND.push(ND[i] + 1);\n    NX.push(k);\n    NPAR.push(i);\n  }\n}\nconst NNODE = NM.length;\nconst RUN = 12, HOLD = 4, G0 = 8;\n\nexport function setup(params) {\n  params.s = {\n    rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3), c: new Float32Array(3), cols: [0, 1, 2].map(() => new Float32Array(3)),\n    o: [0, 0], key: \"\", deep: 1, tau: 0, hold: 0, fade: 0, G: 0, started: false,\n    hue: 0, speed: 2, uf: 4, u: 1, p: 2, sc: 1,\n  };\n}\n\n// Where (m, n) lands: z = m + i n raised to the power p and scaled so that\n// |z|^2 = 128 u reaches the top row. At p = 2 that is the odd leg a up and\n// the even leg b across, u legs to an LED; at p = 1 the lattice of (m, n).\nfunction proj(S, m, n, out) {\n  if (S.p === 2) {\n    out[0] = 2 * m * n * S.sc;\n    out[1] = H - 1 - (m * m - n * n) * S.sc;\n    return;\n  }\n  const r2 = m * m + n * n, th = atan2(n, m) * S.p, rp = pow(r2, S.p / 2) * S.sc;\n  out[0] = rp * sin(th);\n  out[1] = H - 1 - rp * cos(th);\n}\nconst inside = (x, y) => x >= -0.5 && x \u003c W - 0.5 && y >= -0.5 && y \u003c H - 0.5;\nfunction scale(S, u) {\n  S.u = u;\n  S.sc = 128 / pow(128 * u, S.p / 2);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.uf = 4 * pow(2, cl(k[2], -1, 1));\n  S.p = 2 - cl((k[3] - 0.06) / 0.94, 0, 1);\n  // The deepest generation with a triple inside the window at full reach.\n  const key = S.uf.toFixed(4) + \",\" + S.p.toFixed(4);\n  if (key !== S.key) {\n    S.key = key;\n    scale(S, S.uf);\n    S.deep = 1;\n    for (let i = 0; i \u003c NNODE; i++) {\n      proj(S, NM[i], NN[i], S.o);\n      if (inside(S.o[0], S.o[1])) S.deep = max(S.deep, ND[i]);\n    }\n  }\n  // The first tree opens three generations grown; the later ones start\n  // from (3, 4, 5) alone.\n  if (!S.started) {\n    S.started = true;\n    S.tau = (3 * RUN) / (S.deep + 1);\n  }\n  const g = d * (S.speed / 2);\n  S.fade = max(0, S.fade - d / 0.6);\n  if (S.tau \u003c RUN) S.tau = min(RUN, S.tau + g);\n  else {\n    S.hold += g;\n    if (S.hold > HOLD) {\n      S.old.set(S.rgb);\n      S.tau = S.hold = 0;\n      S.fade = 1;\n    }\n  }\n  // One generation after another, each in the same share of the run, and\n  // the window widening as (G + G0)^2, the way the reach of a generation\n  // along A or C grows, so the newest one always spans the panel.\n  const D = S.deep + 1;\n  S.G = (D * S.tau) / RUN;\n  scale(S, S.uf * ((S.G + G0) / (D + G0)) ** 2);\n}\n\n// While the grown tree holds, a pulse runs out from the root through the\n// generations, one generation every RUN / (deep + 1) at Speed 2.\nfunction wave(S, d) {\n  if (S.tau \u003c RUN) return 0;\n  const at = (S.hold / HOLD) * (S.deep + 2) - 0.5, e = (d - at) / 0.6;\n  return exp(-e * e);\n}\n\nfunction put(rgb, x, y, r, g, b) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  if (r > rgb[o]) rgb[o] = r;\n  if (g > rgb[o + 1]) rgb[o + 1] = g;\n  if (b > rgb[o + 2]) rgb[o + 2] = b;\n}\n\n// A straight run in (m, n) from its start to t1 of the way, through the\n// projection: for A and C the run lies on m - n = k or n = const, so the\n// branch is drawn along its parabola.\nfunction branch(S, rgb, m0, n0, m1, n1, t1, col, w) {\n  const o = S.o;\n  proj(S, m0, n0, o);\n  const x0 = o[0], y0 = o[1];\n  proj(S, m0 + (m1 - m0) * t1, n0 + (n1 - n0) * t1, o);\n  const steps = max(2, min(300, floor((abs(o[0] - x0) + abs(o[1] - y0)) * 1.5)));\n  const r = col[0] * w, g = col[1] * w, b = col[2] * w;\n  for (let i = 0; i \u003c= steps; i++) {\n    const t = (t1 * i) / steps;\n    proj(S, m0 + (m1 - m0) * t, n0 + (n1 - n0) * t, o);\n    if (o[1] \u003c -1 || o[0] > W) return;\n    put(rgb, o[0], o[1], r, g, b);\n  }\n  // A branch still growing carries a white spark at its tip.\n  if (t1 \u003c 1) put(rgb, o[0], o[1], 255, 255, 255);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, cols, o } = S;\n  rgb.fill(0);\n  const h = S.hue, G = S.G;\n  hsv(wheel(0.452 + h), 0.75, 1, cols[0]); // A\n  hsv(wheel(0.72 + h), 0.3, 1, cols[1]); // B\n  hsv(wheel(0.88 + h), 0.6, 1, cols[2]); // C\n  // The two families the branches run along, faint: m - n = k for odd k,\n  // c - b = k^2, starting up the left edge at a = k^2, and n = 1, 2, ...,\n  // c - a = 2 n^2, starting along the foot at b = 2 n^2. Every primitive\n  // triple sits on a crossing, but not every crossing is primitive: (6, 3)\n  // is 9 (3, 4, 5), and the tree never lights it.\n  const top = sqrt(200 * S.u) + 2;\n  hsv(wheel(0.452 + h), 0.5, 0.19, S.c);\n  for (let k = 1; k \u003c top; k += 2) branch(S, rgb, k, 0, k + top, top, 1, S.c, 1);\n  hsv(wheel(0.88 + h), 0.45, 0.19, S.c);\n  for (let n = 1; n \u003c top; n++) branch(S, rgb, n, n, n + 2 * top, n, 1, S.c, 1);\n  // The branches: growing for a generation, then A and C stay as the\n  // parabolas they lie on and B, which jumps between them, fades.\n  for (let i = 1; i \u003c NNODE; i++) {\n    const f = G - (ND[i] - 1);\n    if (f \u003c= 0) continue;\n    const j = NPAR[i], k = NX[i];\n    proj(S, NM[j], NN[j], o);\n    if (!inside(o[0], o[1])) continue;\n    const w = (k === 1 ? (f \u003c 1 ? 0.5 : 0) : f \u003c 1 ? 1 : max(0.55, 1 - (f - 1) * 0.45)) + wave(S, ND[i]) * 0.5;\n    if (w > 0) branch(S, rgb, NM[j], NN[j], NM[i], NN[i], min(1, f), cols[k], w);\n  }\n  // The triples, five-LED crosses in the colour of the matrix that made\n  // them, white as they arrive and the root (3, 4, 5) white for good.\n  for (let i = 0; i \u003c NNODE; i++) {\n    const age = G - ND[i];\n    if (age \u003c 0) continue;\n    proj(S, NM[i], NN[i], o);\n    const x = round(o[0]), y = round(o[1]);\n    if (x \u003c -1 || y \u003c -1 || x > W || y > H) continue;\n    const k = NX[i], fl = k \u003c 0 ? 1 : max(0, 1 - age, wave(S, ND[i])), col = cols[max(0, k)];\n    const R = col[0] + (255 - col[0]) * fl, Gg = col[1] + (255 - col[1]) * fl, B = col[2] + (255 - col[2]) * fl;\n    put(rgb, x, y, 160 + R * 0.4, 160 + Gg * 0.4, 160 + B * 0.4);\n    put(rgb, x + 1, y, R * 0.8, Gg * 0.8, B * 0.8);\n    put(rgb, x - 1, y, R * 0.8, Gg * 0.8, B * 0.8);\n    put(rgb, x, y + 1, R * 0.8, Gg * 0.8, B * 0.8);\n    put(rgb, x, y - 1, R * 0.8, Gg * 0.8, B * 0.8);\n  }\n  const fd = S.fade, old = S.old;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      let r = min(255, rgb[p]), gg = min(255, rgb[p + 1]), b = min(255, rgb[p + 2]);\n      if (fd > 0) (r = max(r, old[p] * fd)), (gg = max(gg, old[p + 1] * fd)), (b = max(b, old[p + 2] * fd));\n      (rgb[p] = r), (rgb[p + 1] = gg), (rgb[p + 2] = b);\n      display.setPixel(x, y, r, gg, b);\n    }\n}\n","busy-beaver":"// ===== Patternflow pattern =====\n// Title:   Busy Beaver\n// Family:  algo\n// Idea:    The busy beaver Turing machines write their tapes as space-time diagrams, tape across and time down, the five-state champion's 47,176,870 steps folding into a stack of triangles that zooms out as it grows, one triangle for each pass of its Collatz-like loop.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: busy beaver game (Tibor Rado, 1962), S(3) = 21 (Shen Lin and Tibor Rado, 1965), S(4) = 107 (Allen Brady, 1983), five-state champion (Heiner Marxen and Juergen Buntrock, 1989), its Collatz-like loop (Pascal Michel, 1993), S(5) = 47,176,870 proved (bbchallenge, 2024), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Machine=0..3, Clock=0..1\n//\n// Knob 1: Hue. Turns the tape colour round the wheel, skipping orange and yellow. At 0 the tape is azure, pale where it holds solid 1s and deep blue where it holds the champion's stripes 100 100 100, averaged to a third; the head's left turns are gold and its right turns rose, the sides of every triangle.\n// Knob 2: Speed. At 2 the champion opens 100 turns and 3592 steps in, and its turns grow 9.4 percent a second, a new triangle about every 6 s (0.6, 6.9, 13.0, 18.9, 24.8, 30.6, 36.3, 42.0 and 48.7 s). From 45.7 s, 9.9 million steps in, the panel spends no more than 2.4 million steps a second and the zoom waits for the machine; it halts at 62.2 s, holds 6 s and starts again. At 0.2 ten times slower, halting at 636 s; at 3 it halts at 41.5 s. The small machines take 3 s for their whole run at 2 and hold 3 s.\n// Knob 3: Machine. 0 is the five-state champion of Heiner Marxen and Juergen Buntrock, 47,176,870 steps, 12,258 turns and 4098 ones over 12,289 cells; 1 is Allen Brady's four-state champion, 107 steps and 13 ones over 14 cells, 4 LEDs a cell and 1 row a step; 2 is the three-state machine of 21 steps and 5 ones, 12 LEDs a cell and 5 rows a step; 3 is the two-state one, 6 steps and 4 ones, 16 LEDs a cell and 15 rows a step. The counts sit at the top left for the champion and under the small diagrams, steps above and the 1s on the tape now below, and turn white at the halt.\n// Knob 4: Clock. What a row of the champion counts. At 0 every sweep, turn to turn, gets the same height and the triangles have straight sides; at 1 every step does, and they swell into arches as the sweeps lengthen, until at the halt the last pass, 30.2 of the 47.2 million steps, takes the bottom 82 rows. At the opening 0.06 a row is nearly a sweep. The small machines always give each step its own band of rows.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, log } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// The machines in the notation of bbchallenge: for each state A, B, ... the\n// moves on reading 0 and on reading 1, each the symbol to write, the way to\n// go and the next state, Z for halt.\nconst MACHINES = [\n  \"1RB1LC_1RC1RB_1RD0LE_1LA1LD_1RZ0LA\", // Marxen and Buntrock, 5 states\n  \"1RB1LB_1LA0LC_1RZ1LD_1RD0RA\", // Brady, 4 states\n  \"1RB1RZ_1LB0RC_1LC1LA\", // Lin and Rado, 3 states\n  \"1RB1LB_1LA1RZ\", // 2 states\n];\nfunction parse(text) {\n  const st = text.split(\"_\"), n = st.length;\n  const wr = new Int8Array(2 * n), dr = new Int8Array(2 * n), nx = new Int8Array(2 * n);\n  for (let s = 0; s \u003c n; s++)\n    for (let r = 0; r \u003c 2; r++) {\n      const m = st[s].slice(3 * r, 3 * r + 3), o = 2 * s + r;\n      wr[o] = m.charCodeAt(0) - 48;\n      dr[o] = m[1] === \"R\" ? 1 : -1;\n      nx[o] = m[2] === \"Z\" ? -1 : m.charCodeAt(2) - 65;\n    }\n  return { wr, dr, nx, n };\n}\nconst TABLES = MACHINES.map(parse);\n\n// The tape: the start cell sits at ORG, with room for the champion's 12,243\n// cells to the left and 45 to the right.\nconst TL = 16384, ORG = 13600;\n// Snapshots of the tape, as running counts of 1s over blocks of 2^bs cells,\n// never more than NB blocks, taken at every step for the first 256 and\n// after that at a turn of the head once the steps or the turns have grown\n// by a 200th since the last one: 1894 over the champion's run.\nconst SMAX = 4096, NB = 256, BLK = NB + 2;\nconst RATE = 0.09, TAU0 = 100, CAP = 40000, RUN = 3, HOLD = 3, HOLD5 = 6;\nconst SMALL_H = 110, SH = [0.55, 0.2, 0.75, 0.37, 0.9];\nconst DIG = [\"111101101101111\", \"010110010010111\", \"111001111100111\", \"111001111001111\", \"101101111001001\", \"111100111001111\", \"111100111101111\", \"111001001001001\", \"111101111101111\", \"111101111001111\"];\n\nexport function setup(params) {\n  params.s = {\n    tape: new Uint8Array(TL), blk: new Int32Array(TL), pool: new Uint16Array(SMAX * BLK),\n    sStep: new Float64Array(SMAX), sTurn: new Int32Array(SMAX), sHead: new Int32Array(SMAX), sState: new Int8Array(SMAX),\n    sP0: new Int32Array(SMAX), sBs: new Int8Array(SMAX), sNb: new Int16Array(SMAX), sLo: new Int32Array(SMAX), sHi: new Int32Array(SMAX),\n    tStep: new Float64Array(16384), tPos: new Int32Array(16384), tState: new Int8Array(16384),\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3), cs: new Float32Array(SMAX),\n    tw: new Float32Array(W * H), trgb: new Float32Array(W * H * 3), tx: new Int16Array(16384), ty: new Int16Array(16384),\n    pal: new Float32Array(9), sc: [0, 1, 2, 3, 4].map(() => new Float32Array(3)), white: [255, 255, 255],\n    m: -1, hue: 0, speed: 2, q: 0.06, fins: [],\n  };\n}\n\nfunction fresh(S, m) {\n  S.m = m;\n  S.T = TABLES[m];\n  S.tape.fill(0);\n  S.blk.fill(0);\n  S.h = ORG;\n  S.st = 0;\n  S.steps = 0;\n  S.lo = S.hi = ORG;\n  S.bs = 0;\n  S.lastD = 0;\n  S.nt = 0;\n  S.ns = 0;\n  S.lastSnapStep = 0;\n  S.lastSnapTurn = 0;\n  S.halted = false;\n  S.r = 0;\n  S.hold = 0;\n  S.tmp = false;\n  snap(S, false);\n  if (m === 0) advance(S, TAU0, 1e9);\n  else S.fin = S.fins[m] || (S.fins[m] = measure(S.T));\n}\n\n// A small machine's whole run on a scratch tape: its steps and the cells it\n// visits, so its diagram can be laid out before it starts.\nfunction measure(T) {\n  const tape = new Uint8Array(64);\n  let h = 32, st = 0, steps = 0, lo = 32, hi = 32;\n  while (st >= 0 && steps \u003c 1000) {\n    const o = 2 * st + tape[h];\n    tape[h] = T.wr[o];\n    h += T.dr[o];\n    st = T.nx[o];\n    steps++;\n    lo = min(lo, h);\n    hi = max(hi, h);\n  }\n  return { steps, lo: lo - 32 + ORG, hi: hi - 32 + ORG };\n}\n\nfunction snap(S, tmp) {\n  if (S.ns >= SMAX) return;\n  S.tmp = tmp;\n  const j = S.ns++, bs = S.bs, p0 = S.lo >> bs, nb = (S.hi >> bs) - p0 + 1, o = j * BLK;\n  const { pool, blk } = S;\n  pool[o] = 0;\n  for (let b = 0; b \u003c nb; b++) pool[o + b + 1] = pool[o + b] + blk[p0 + b];\n  S.sStep[j] = S.steps;\n  S.sTurn[j] = S.nt;\n  S.sHead[j] = S.h;\n  S.sState[j] = S.st;\n  S.sP0[j] = p0;\n  S.sBs[j] = bs;\n  S.sNb[j] = nb;\n  S.sLo[j] = S.lo;\n  S.sHi[j] = S.hi;\n  if (!tmp) {\n    S.lastSnapStep = S.steps;\n    S.lastSnapTurn = S.nt;\n  }\n}\n\n// Doubles the block size of the running counts when the tape outgrows NB.\nfunction coarsen(S) {\n  const { blk } = S, n = TL >> S.bs;\n  for (let i = 0; i \u003c n / 2; i++) blk[i] = blk[2 * i] + blk[2 * i + 1];\n  for (let i = n / 2; i \u003c n; i++) blk[i] = 0;\n  S.bs++;\n}\n\n// Runs the machine until it has made `turns` turns or `steps` steps more.\nfunction advance(S, turns, budget) {\n  if (S.halted) return 0;\n  // A snapshot left at the end of the last frame only stood for the bottom\n  // row; the run goes on from the one before it.\n  if (S.tmp) {\n    S.ns--;\n    S.tmp = false;\n  }\n  const { tape, blk, tStep, tPos, tState } = S, { wr, dr, nx } = S.T;\n  let h = S.h, st = S.st, steps = S.steps, lo = S.lo, hi = S.hi, lastD = S.lastD, bs = S.bs, nt = S.nt;\n  const end = steps + budget;\n  while (steps \u003c end && nt \u003c turns) {\n    const sym = tape[h], o = 2 * st + sym, w = wr[o], d = dr[o];\n    let turned = false;\n    if (w !== sym) {\n      tape[h] = w;\n      blk[h >> bs] += w - sym;\n    }\n    if (d !== lastD) {\n      if (lastD !== 0) {\n        tStep[nt] = steps;\n        tPos[nt] = h;\n        tState[nt] = st;\n        nt++;\n        turned = true;\n      }\n      lastD = d;\n    }\n    h += d;\n    st = nx[o];\n    steps++;\n    if (h \u003c lo || h > hi) {\n      if (h \u003c lo) lo = h;\n      else hi = h;\n      if ((hi >> bs) - (lo >> bs) >= NB) {\n        S.bs = bs;\n        coarsen(S);\n        bs = S.bs;\n      }\n    }\n    if (st \u003c 0) {\n      S.halted = true;\n      break;\n    }\n    if (steps \u003c 256 || (turned && ((steps - S.lastSnapStep) * 200 >= steps || (nt - S.lastSnapTurn) * 200 >= nt))) {\n      S.h = h; S.st = st; S.steps = steps; S.lo = lo; S.hi = hi; S.nt = nt;\n      snap(S, false);\n    }\n  }\n  const did = budget - (end - steps);\n  S.h = h; S.st = st; S.steps = steps; S.lo = lo; S.hi = hi; S.lastD = lastD; S.nt = nt;\n  if (S.halted) {\n    S.st = -1;\n    snap(S, false);\n  } else if (S.lastSnapStep !== steps) snap(S, true);\n  return did;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.q = cl(k[3], 0, 1);\n  const m = cl(floor(k[2] + 0.5), 0, 3);\n  if (m !== S.m) fresh(S, m);\n  const g = d * (S.speed / 2);\n  if (S.halted) {\n    S.hold += g;\n    if (S.hold > (m === 0 ? HOLD5 : HOLD)) fresh(S, m);\n    return;\n  }\n  if (m === 0) {\n    // The turns grow by RATE a second at Speed 2, unless that would take\n    // more than CAP steps a frame; then the zoom waits for the machine.\n    const r = S.r + g, target = floor(TAU0 * exp(RATE * r)), budget = floor(CAP * S.speed * 30 * d);\n    const did = target > S.nt ? advance(S, target, max(1, budget)) : 0;\n    S.r = did >= budget ? log(max(S.nt, TAU0) / TAU0) / RATE : r;\n  } else {\n    S.r += g;\n    const want = floor((S.fin.steps * S.r) / RUN);\n    if (want > S.steps) advance(S, 1e9, want - S.steps);\n  }\n}\n\n// Where a snapshot sits down the panel, 0 to 1: the share of sweeps (each\n// sweep, turn to turn, one unit, its steps spread evenly through it) mixed\n// with the share of steps by the Clock knob.\nfunction clocks(S) {\n  const { tStep, sStep, sTurn, cs } = S, nt = S.nt, now = S.steps, q = S.q;\n  const tk = nt > 0 ? tStep[nt - 1] : 0, prev = nt > 1 ? tStep[nt - 1] - tStep[nt - 2] : 1;\n  const curLen = max(1, now - tk, prev), sigNow = max(1e-9, nt + (now - tk) / curLen);\n  for (let j = 0; j \u003c S.ns; j++) {\n    const s = sStep[j], kk = sTurn[j];\n    const a = kk > 0 ? tStep[kk - 1] : 0, b = kk \u003c nt ? tStep[kk] : a + curLen;\n    cs[j] = (1 - q) * ((kk + (s - a) / max(1, b - a)) / sigNow) + q * (s / max(1, now));\n  }\n  return sigNow;\n}\n\n// The running count of 1s left of cell p in snapshot j, blocks interpolated.\nfunction cum(S, j, p) {\n  const bs = S.sBs[j], u = p / (1 \u003c\u003c bs) - S.sP0[j], nb = S.sNb[j], o = j * BLK, pool = S.pool;\n  if (u \u003c= 0) return 0;\n  if (u >= nb) return pool[o + nb];\n  const i = floor(u);\n  return pool[o + i] + (pool[o + i + 1] - pool[o + i]) * (u - i);\n}\n\nfunction shade(S, dn, out) {\n  const P = S.pal;\n  if (dn \u003c= 1 / 3) {\n    const u = dn * 3;\n    for (let i = 0; i \u003c 3; i++) out[i] = P[3 + i] + (P[i] - P[3 + i]) * u;\n  } else {\n    const u = (dn - 1 / 3) * 1.5;\n    for (let i = 0; i \u003c 3; i++) out[i] = P[i] + (P[6 + i] - P[i]) * u;\n  }\n}\n\n// The champion: every row the tape at one moment, the window the whole tape\n// so far, each LED the share of 1s in its 1/64 of it.\nfunction drawChampion(S) {\n  const { rgb, c, tw, trgb } = S, col = [0, 0, 0];\n  const sigNow = clocks(S), cs = S.cs, lo = S.lo, ext = S.hi - S.lo + 1, C = ext / W;\n  let j = 0;\n  for (let y = 0; y \u003c H; y++) {\n    const want = (y + 1) / H - 1e-9;\n    while (j + 1 \u003c S.ns && cs[j + 1] \u003c= want) j++;\n    const sl = S.sLo[j], sh = S.sHi[j] + 1;\n    // Each LED averages a whole number of the stripes' 3 cells and of the\n    // snapshot's blocks, so 100 100 100 comes out a third everywhere\n    // instead of beating against the LEDs.\n    const u = 3 \u003c\u003c S.sBs[j], wf = u * Math.ceil(C / u - 1e-9);\n    for (let x = 0; x \u003c W; x++) {\n      const a = lo + x * C, b = a + C;\n      if (b \u003c= sl || a >= sh) continue;\n      const m = (a + b) / 2;\n      const dn = (cum(S, j, m + wf / 2) - cum(S, j, m - wf / 2)) / wf;\n      shade(S, cl(dn, 0, 1), col);\n      const o = (y * W + x) * 3;\n      rgb[o] = col[0];\n      rgb[o + 1] = col[1];\n      rgb[o + 2] = col[2];\n    }\n  }\n  // Every turn of the head in the colour of the state it turned in. The\n  // champion turns left in A and right in D, so the head draws the sides\n  // of its own triangles.\n  tw.fill(0);\n  trgb.fill(0);\n  const { tStep, tPos, tState, nt } = S, q = S.q;\n  const TX = S.tx, TY = S.ty;\n  for (let i = 0; i \u003c nt; i++) {\n    const cc = (1 - q) * ((i + 1) / sigNow) + q * (tStep[i] / max(1, S.steps));\n    const y = min(H - 1, floor(cc * H)), x = min(W - 1, floor((tPos[i] - lo) / C)), P = S.sc[tState[i]];\n    TX[i] = x;\n    TY[i] = y;\n    // Joined to the turn two before it, on the same side, so the sides\n    // stay whole lines while a sweep is taller than a row.\n    let x1 = x, y1 = y;\n    if (i >= 2 && tState[i - 2] === tState[i] && abs(TX[i - 2] - x) \u003c= 3 && y - TY[i - 2] \u003c= 8) (x1 = TX[i - 2]), (y1 = TY[i - 2]);\n    const n = max(1, abs(x - x1), y - y1);\n    for (let k = n === 1 && x1 === x && y1 === y ? 0 : 1; k \u003c= n; k++) {\n      const px = round(x1 + ((x - x1) * k) / n), py = round(y1 + ((y - y1) * k) / n), p = py * W + px;\n      tw[p]++;\n      trgb[p * 3] += P[0];\n      trgb[p * 3 + 1] += P[1];\n      trgb[p * 3 + 2] += P[2];\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    if (!tw[p]) continue;\n    const w = min(1, 0.6 + tw[p] * 0.2), o = p * 3, n = tw[p];\n    for (let i = 0; i \u003c 3; i++) rgb[o + i] = rgb[o + i] * (1 - w) + (trgb[o + i] / n) * w;\n  }\n  // The head now, at the foot of the diagram.\n  if (!S.halted) {\n    const x = min(W - 1, floor((S.h - lo) / C)), P = S.sc[S.st];\n    for (let y = H - 4; y \u003c H; y++) {\n      const o = (y * W + x) * 3;\n      rgb[o] = y === H - 1 ? 255 : P[0];\n      rgb[o + 1] = y === H - 1 ? 255 : P[1];\n      rgb[o + 2] = y === H - 1 ? 255 : P[2];\n    }\n  }\n}\n\n// A small machine: one row band for every step, the cells as blocks over\n// the tape its whole run will use, a dark line between bands and cells\n// once they are 4 LEDs or more.\nfunction drawSmall(S) {\n  const { rgb } = S, col = [0, 0, 0], F = S.fin, ext = F.hi - F.lo + 1;\n  const cw = floor(W / ext), x0 = floor((W - cw * ext) / 2), rh = floor(SMALL_H / (F.steps + 1));\n  for (let j = 0; j \u003c S.ns; j++) {\n    const sl = S.sLo[j], sh = S.sHi[j], hd = S.sHead[j], st = S.sState[j];\n    for (let p = sl; p \u003c= sh; p++) {\n      const one = cum(S, j, p + 1) - cum(S, j, p) > 0.5;\n      shade(S, one ? 1 : 0, col);\n      if (p === hd) {\n        const P = st >= 0 ? S.sc[st] : S.white;\n        for (let i = 0; i \u003c 3; i++) col[i] = one ? P[i] * 0.75 + col[i] * 0.25 : P[i] * 0.8;\n      }\n      const xa = x0 + (p - F.lo) * cw, xb = xa + cw - (cw >= 4 && rh >= 4 ? 1 : 0);\n      const ya = j * rh, yb = ya + rh - (rh >= 4 ? 1 : 0);\n      for (let y = ya; y \u003c yb; y++)\n        for (let x = xa; x \u003c xb; x++) {\n          const o = (y * W + x) * 3;\n          rgb[o] = col[0];\n          rgb[o + 1] = col[1];\n          rgb[o + 2] = col[2];\n        }\n    }\n  }\n}\n\nfunction number(rgb, n, x, y, P) {\n  const s = String(n);\n  for (let i = 0; i \u003c s.length; i++) {\n    const g = DIG[s.charCodeAt(i) - 48];\n    for (let k = 0; k \u003c 15; k++)\n      if (g[k] === \"1\") {\n        const o = ((y + floor(k / 3)) * W + x + 4 * i + (k % 3)) * 3;\n        rgb[o] = P[0];\n        rgb[o + 1] = P[1];\n        rgb[o + 2] = P[2];\n      }\n  }\n}\n\n// Orange and yellow read brown on an LED when dim, so the tape takes its\n// hue from a wheel without 0.03 to 0.17.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c } = S;\n  rgb.fill(0);\n  const h0 = wheel(0.477 + S.hue), P = S.pal;\n  hsv(h0, 0.9, 0.5, c);\n  P[0] = c[0]; P[1] = c[1]; P[2] = c[2];\n  P[3] = 7; P[4] = 9; P[5] = 16;\n  hsv(h0 - 0.03, 0.28, 1, c);\n  P[6] = c[0]; P[7] = c[1]; P[8] = c[2];\n  for (let i = 0; i \u003c 5; i++) {\n    hsv(h0 + SH[i], 0.75, 1, c);\n    S.sc[i][0] = c[0]; S.sc[i][1] = c[1]; S.sc[i][2] = c[2];\n  }\n  if (S.m === 0) drawChampion(S);\n  else drawSmall(S);\n  // The counts: steps, then the 1s on the tape now.\n  let ones = 0;\n  for (let b = S.lo >> S.bs; b \u003c= S.hi >> S.bs; b++) ones += S.blk[b];\n  hsv(h0 + 0.5, 0.12, S.halted ? 0.95 : 0.55, c);\n  const y = S.m === 0 ? 1 : 114;\n  number(rgb, S.steps, 1, y, c);\n  hsv(h0 - 0.03, 0.35, S.halted ? 1 : 0.7, c);\n  number(rgb, ones, 1, y + 7, c);\n  for (let p = 0, yy = 0; yy \u003c H; yy++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, yy, min(255, rgb[p]), min(255, rgb[p + 1]), min(255, rgb[p + 2]));\n}\n","feynman-checkerboard":"// ===== Patternflow pattern =====\n// Title:   Feynman Checkerboard\n// Family:  wave\n// Idea:    Time runs down the panel and space across it on Feynman's light-cone lattice, where a particle steps one site left or right each row and every corner multiplies its amplitude by i epsilon: four such zigzag paths fall from the source with each corner marked in the colour of i^R, the exact sum over all 2^128 of them glows underneath as phase and brightness, and its gold mean position trembles from side to side, Schroedinger's Zitterbewegung.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dirac equation (Paul Dirac, 1928), Zitterbewegung (Erwin Schroedinger, 1930), Feynman's checkerboard (Richard Feynman; Richard Feynman and Albert Hibbs, Quantum Mechanics and Path Integrals, 1965, problem 2-6), continuum limit of the checkerboard (Ted Jacobson and Lawrence Schulman, 1984), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mass=0.08..0.4, Focus=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the source's own phase is azure, so the field opens azure at the top and turns through violet, red, gold and green as its phase runs on down the panel; a corner dot is azure, violet, red or green as the path has made 0, 1, 2 or 3 corners mod 4, and the mean is pale gold. At 0.5 the field opens amber and the mean turns lavender.\n// Knob 2: Speed. How fast the present, the row the paths have reached, runs down: 16 rows a second per unit, so at 2 a sweep takes 4 s and the paths fade for 0.6 s at the bottom before four new ones leave the source; at 0.2 a sweep takes 40 s, at 3 it takes 2.7 s. Rows the present has passed are lit fully, rows ahead of it at 0.6, and the opening sweep starts on row 40.\n// Knob 3: Mass. epsilon = m dt, from 0.08 to 0.4. A path turns with probability eps / (1 + eps) a step, every 13.5 rows at 0.08 and every 3.5 at 0.4; the packet's phase turns once in 2 pi / atan(eps) rows, 79 at 0.08 and 16.5 at 0.4; and the mean trembles with a period of pi / atan(eps) rows, 39 at 0.08, where it swings 3 to 6 LEDs peak to peak, and 8.3 at 0.4, where it swings 0.5 to 1.2.\n// Knob 4: Focus. The source packet's width, sigma = 1.5 (1 - Focus)^1.5 / eps sites, two sites to an LED: 17 sites at the opening 0.06, 1.4 Compton wavelengths 1 / eps, where the mean trembles clearly; 6.6 sites at 0.5; at 1 a single site, the point source of Feynman's propagator, whose cone edges are the one path with no corner (right) and the one that turns at once (left), whose phase bands are the hyperbolas of constant proper time, and whose mean runs right at 0.92 c and leaves the panel on row 69.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, exp, atan2, round, ceil, hypot, PI, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The lattice: two sites to an LED across, one time step to a row down.\n// The panel shows sites M .. M + 127 of a line of NX = 384 sites, and the\n// line runs 192 sites either side of the source, past the 128 that light\n// covers in the panel's 128 steps. Amplitude that leaves the panel's sides\n// is still carried, comes back when its paths do, and never meets an end:\n// the panel shows the free propagator, exactly.\nconst C = 2, M = 128, NX = 128 + 2 * M, X0 = M + 64;\nconst ux = (s) => (s - M + 0.5) / C - 0.5; // site -> splat x\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, eps: 0.08, focus: 0.06, key: '',\n    Rr: new Float64Array(NX), Ri: new Float64Array(NX), Lr: new Float64Array(NX), Li: new Float64Array(NX),\n    nRr: new Float64Array(NX), nRi: new Float64Array(NX), nLr: new Float64Array(NX), nLi: new Float64Array(NX),\n    rho: new Float32Array(N), ph: new Float32Array(N), V: new Float32Array(N), mean: new Float64Array(H), tot: new Float64Array(H),\n    D: new Float32Array(N),\n    paths: [], R: new Float32Array(N), G: new Float32Array(N), B: new Float32Array(N), c: new Float32Array(15),\n  };\n}\n\n// One step of the checkerboard, unitary form: going straight costs\n// a = 1 / sqrt(1 + eps^2), a corner b = i eps / sqrt(1 + eps^2), so a path\n// with R corners carries (i eps)^R / (1 + eps^2)^(T/2).\n//   R(x, t+1) = a R(x-1, t) + b L(x-1, t)\n//   L(x, t+1) = a L(x+1, t) + b R(x+1, t)\nfunction field(S) {\n  const eps = S.eps, a = 1 / sqrt(1 + eps * eps), b = eps / sqrt(1 + eps * eps);\n  let { Rr, Ri, Lr, Li, nRr, nRi, nLr, nLi } = S;\n  Rr.fill(0); Ri.fill(0); Lr.fill(0); Li.fill(0);\n  // The source: a Gaussian packet at rest in the right-moving component,\n  // width sigma sites, on the sites of one parity.\n  const sigma = S.sigma;\n  let n = 0;\n  for (let s = 0; s \u003c NX; s++) {\n    const d = s - X0;\n    if (d & 1) continue;\n    const g = sigma \u003c 0.5 ? +(d === 0) : exp((-d * d) / (4 * sigma * sigma));\n    Rr[s] = g;\n    n += g * g;\n  }\n  n = 1 / sqrt(n);\n  for (let s = 0; s \u003c NX; s++) Rr[s] *= n;\n  const { rho, ph, mean, tot } = S;\n  for (let t = 0; t \u003c H; t++) {\n    let m = 0, p = 0;\n    for (let s = 0; s \u003c NX; s++) {\n      const q = Rr[s] * Rr[s] + Ri[s] * Ri[s] + Lr[s] * Lr[s] + Li[s] * Li[s];\n      p += q;\n      m += q * s;\n    }\n    mean[t] = m / p;\n    tot[t] = p;\n    // The brightness scale of the row: the densest site within t/2 + 2 sigma\n    // of the centre, so the two straight paths along a point source's cone\n    // do not black out the rest; brightness is (density / scale)^0.4.\n    let mx = 0;\n    const half = max(2, floor(t / 2 + 2 * S.sigma));\n    for (let s = max(1, X0 - half); s \u003c= min(NX - 2, X0 + half); s++) {\n      const q = Rr[s] * Rr[s] + Ri[s] * Ri[s] + Lr[s] * Lr[s] + Li[s] * Li[s];\n      if (q > mx) mx = q;\n    }\n    const ref = mx > 0 ? mx : 1;\n    // The live site under LED X on row t is M + 2X + (t & 1).\n    for (let X = 0; X \u003c W; X++) {\n      const s = M + 2 * X + ((t + X0) & 1), o = t * W + X;\n      rho[o] = Rr[s] * Rr[s] + Ri[s] * Ri[s] + Lr[s] * Lr[s] + Li[s] * Li[s];\n      ph[o] = atan2(Ri[s] + Li[s], Rr[s] + Lr[s]) / (2 * PI);\n      S.V[o] = min(1, (rho[o] / ref) ** 0.4);\n    }\n    for (let s = 1; s \u003c NX - 1; s++) {\n      nRr[s] = a * Rr[s - 1] - b * Li[s - 1];\n      nRi[s] = a * Ri[s - 1] + b * Lr[s - 1];\n      nLr[s] = a * Lr[s + 1] - b * Ri[s + 1];\n      nLi[s] = a * Li[s + 1] + b * Rr[s + 1];\n    }\n    nRr[0] = nRi[0] = nLr[0] = nLi[0] = 0;\n    nRr[NX - 1] = nRi[NX - 1] = nLr[NX - 1] = nLi[NX - 1] = 0;\n    [Rr, nRr] = [nRr, Rr];\n    [Ri, nRi] = [nRi, Ri];\n    [Lr, nLr] = [nLr, Lr];\n    [Li, nLi] = [nLi, Li];\n  }\n  Object.assign(S, { Rr, Ri, Lr, Li, nRr, nRi, nLr, nLi });\n}\n\n// A path sampled with weight |amplitude| = eps^R: a corner at each step with\n// probability eps / (1 + eps), starting right-moving from a site drawn from\n// the packet.\nfunction sample(S) {\n  const eps = S.eps, pc = eps / (1 + eps), xs = new Int16Array(H), k = new Uint8Array(H);\n  let s = X0;\n  if (S.sigma >= 0.5) {\n    let g;\n    do g = sqrt(-2 * Math.log(1 - Math.random())) * Math.cos(2 * PI * Math.random()) * S.sigma;\n    while (abs(g) > 3 * S.sigma);\n    s = X0 + 2 * round(g / 2);\n  }\n  let dir = 1, R = 0;\n  for (let t = 0; t \u003c H; t++) {\n    xs[t] = s;\n    k[t] = R;\n    if (Math.random() \u003c pc) (dir = -dir), R++;\n    s += dir;\n  }\n  return { xs, k };\n}\n\n// The present: a row that runs down the panel at 16 rows a second per unit\n// of Speed, then waits HOLD rows' worth of time at the bottom while the\n// paths fade, and starts again from the source with new paths.\nconst HOLD = 20, NP = 4;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.08, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.eps = cl(kv[2], 0.08, 0.4);\n  S.focus = cl(kv[3], 0, 1);\n  S.sigma = (1.5 * (1 - S.focus) ** 1.5) / S.eps;\n  const key = S.eps.toFixed(4) + '/' + S.sigma.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    field(S);\n    S.paths = [];\n  }\n  if (!S.paths.length) {\n    for (let i = 0; i \u003c NP; i++) S.paths.push(sample(S));\n    if (S.front === undefined) S.front = 40;\n  }\n  S.front += d * 16 * S.speed;\n  if (S.front > H + HOLD) {\n    S.front = 0;\n    for (let i = 0; i \u003c NP; i++) S.paths[i] = sample(S);\n  }\n}\n\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction line(S, x0, y0, x1, y1, v, c, o) {\n  const L = hypot(x1 - x0, y1 - y0), n = max(1, ceil(L * 3)), w = (v * L) / n;\n  for (let i = 1; i \u003c= n; i++) splat(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, G, B, c, V, ph, mean, D } = S;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  D.fill(1);\n  const tmp = [0, 0, 0], now = S.front, head = min(H - 1, now), fade = now > H ? max(0, 1 - (now - H) / HOLD) : 1;\n  // Shade under the lines first, so they read over the field.\n  const shade = (x, y, k) => {\n    const ix = round(x), iy = round(y);\n    if (iy \u003c 0 || iy >= H) return;\n    for (let X = ix - 1; X \u003c= ix + 1; X++) if (X >= 0 && X \u003c W) D[iy * W + X] = min(D[iy * W + X], k);\n  };\n  for (let t = 0; t \u003c= min(H - 1, now); t++) shade(ux(mean[t]), t, 0.35);\n  if (fade > 0) for (const P of S.paths) for (let t = 0; t \u003c= head; t++) shade(ux(P.xs[t]), t, 1 - 0.65 * fade);\n  // The field: phase as hue, the amplitude as brightness, full in the rows\n  // the present has passed and brightest just behind it, faint ahead of it.\n  for (let t = 0; t \u003c H; t++) {\n    const u = cl((now - t) / 8 + 0.5, 0, 1), lit = 0.34 + 0.2 * u * u * (3 - 2 * u) + (t \u003c= now ? 0.14 * exp(-(now - t) / 10) : 0);\n    for (let X = 0; X \u003c W; X++) {\n      const o = t * W + X;\n      hsv(S.hue + 0.55 + ph[o], 0.85, V[o] * lit * D[o], tmp, 0);\n      R[o] = tmp[0];\n      G[o] = tmp[1];\n      B[o] = tmp[2];\n    }\n  }\n  c[0] = c[1] = c[2] = 0.3; // cone\n  c[3] = c[4] = c[5] = 1; // white\n  hsv(S.hue + 0.14, 0.55, 1, c, 9); // the mean\n  // The light cone of the packet's centre.\n  for (let t = 0; t \u003c H; t += 2) {\n    splat(S, ux(X0 + t), t, 1, c, 0);\n    splat(S, ux(X0 - t), t, 1, c, 0);\n  }\n  // The paths, down to the present.\n  if (fade > 0)\n    for (const P of S.paths) {\n      for (let t = 0; t + 1 \u003c= head; t++) {\n        const v = 0.3 + 0.65 * exp(-(head - t) / 24);\n        line(S, ux(P.xs[t]), t, ux(P.xs[t + 1]), t + 1, v * fade, c, 3);\n      }\n      for (let t = 1; t + 1 \u003c= head; t++)\n        if (P.k[t + 1] !== P.k[t]) {\n          hsv(S.hue + 0.55 + P.k[t + 1] / 4, 1, 1, c, 6);\n          splat(S, ux(P.xs[t]), t, 2 * fade, c, 6);\n        }\n      const t0 = floor(head), f = head - t0;\n      if (t0 \u003c H - 1) splat(S, ux(P.xs[t0] + (P.xs[t0 + 1] - P.xs[t0]) * f), head, 1.5 * fade, c, 3);\n    }\n  // The mean position, row by row: drawn through the past, dotted ahead.\n  for (let t = 0; t \u003c H; t++) if (t \u003c= now || t % 3 === 0) splat(S, ux(mean[t]), t, t \u003c= now ? 1.2 : 0.6, c, 9);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","heesch-tiles":"// ===== Patternflow pattern =====\n// Title:   Heesch Tiles\n// Family:  cells\n// Idea:    One tile whose edges keep bending covers the whole panel with no gap and no overlap, each bent edge carried onto its partner the way Heesch paired them (translated T, half-turned C about its own midpoint, glide-reflected G, or turned about a shared corner, C3 and C4), and every 8 s the tiling passes on to the next of six Heesch types, each copy coloured by which way it is turned or flipped and brightest at its first corner.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the 28 types of plane tiling by one asymmetric tile (Heinrich Heesch, 1935), Flächenschluss (Heinrich Heesch and Otto Kienzle, 1963), the 93 isohedral tiling types (Branko Grünbaum and G. C. Shephard, 1977), isohedral tilings parameterised for drawing (Craig S. Kaplan and David H. Salesin, 2000), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Type=0..5, Size=-1..1\n//\n// Knob 1: Hue. Turns the class colours round a wheel that skips orange, which reads brown once shaded. At 0 the copies turned like the first tile are azure, the next class pink, then green and violet: two colours where the group has two classes (the half-turned copies of CCCC and TCTC, the mirrored ones of TG1G1TG2G2), three for C3C3C3C3C3C3, four for C4C4C4C4, and TTTT, where every copy is a translate, all azure. At 0.5 the four are red, cyan, violet and green.\n// Knob 2: Speed. At 2 the edge bends run through their quickest wave in 12 s and their slowest in 22 s, the corners wander over 27 s, the tiling drifts 0.9 LEDs a second right and 1.6 up, and each type holds 8 s before the next sweeps down the panel in 1.2 s, tile by tile, so the six come round every 55 s. At 0.2 everything is ten times slower, at 3 one and a half times faster.\n// Knob 3: Type. The type on the panel now; the cycle goes on from it. 0 C3C3C3C3C3C3 (group p3: a hexagon whose corners V0, V2, V4 are 3-fold centres and whose corner V1 wanders, three classes), 1 TG1G1TG2G2 (pg: one translated pair and two glide-reflected pairs, so mirrored columns alternate), 2 CCCC (p2: any quadrilateral, each edge half-turned about its own midpoint), 3 TCTC (p2: a parallelogram with one translated pair and two C edges), 4 TTTT (p1), 5 C4C4C4C4 (p4: a square turned a quarter about two opposite corners, four classes).\n// Knob 4: Size. The area of one tile, 290 x 2^(1.6 K) LEDs: 96 at -1, about 85 tiles on the panel; 310 at the opening 0.06, about 26; 880 at 1, about 9.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, sin, cos, sqrt, min, max, abs, atan2, PI, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst TAU = 2 * PI;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Orange reads brown on an LED once it is shaded, so the class colours come\n// from a wheel without 0.03 to 0.17.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\n// Isometries as [a, b, c, d, e, f]: (x, y) -> (a x + b y + e, c x + d y + f).\nconst mul = (M, K) => [\n  M[0] * K[0] + M[1] * K[2], M[0] * K[1] + M[1] * K[3],\n  M[2] * K[0] + M[3] * K[2], M[2] * K[1] + M[3] * K[3],\n  M[0] * K[4] + M[1] * K[5] + M[4], M[2] * K[4] + M[3] * K[5] + M[5],\n];\nconst inv = (M) => {\n  const det = M[0] * M[3] - M[1] * M[2], a = M[3] / det, b = -M[1] / det, c = -M[2] / det, d = M[0] / det;\n  return [a, b, c, d, -(a * M[4] + b * M[5]), -(c * M[4] + d * M[5])];\n};\nconst Tr = (x, y) => [1, 0, 0, 1, x, y];\nconst Rot = (p, th) => {\n  const c = cos(th), s = sin(th);\n  return [c, -s, s, c, p[0] - c * p[0] + s * p[1], p[1] - s * p[0] - c * p[1]];\n};\nconst Half = (p, q) => Rot([(p[0] + q[0]) / 2, (p[1] + q[1]) / 2], PI);\n// Reflect in the vertical line x = xa, then move dy along it.\nconst Glide = (xa, dy) => [-1, 0, 0, 1, 2 * xa, dy];\nconst ap = (M, p) => [M[0] * p[0] + M[1] * p[1] + M[4], M[2] * p[0] + M[3] * p[1] + M[5]];\n\n// An edge from P to Q, NS steps, bent off the chord by h(s) times its length.\n// Every bend is a sum of sin(k pi s) sin(pi s), so it leaves both corners\n// along the chord and the corner angles of the polygon stay.\nconst NS = 10;\nfunction edge(P, Q, h) {\n  const dx = Q[0] - P[0], dy = Q[1] - P[1], pts = [];\n  for (let i = 0; i \u003c= NS; i++) {\n    const s = i / NS, o = h(s);\n    pts.push([P[0] + dx * s - dy * o, P[1] + dy * s + dx * o]);\n  }\n  return pts;\n}\nconst mapPts = (M, pts) => pts.map((p) => ap(M, p));\nconst rev = (pts) => pts.slice().reverse();\n\n// Bends. A free edge (the first of a T, G, C3 or C4 pair) may take any\n// shape; a C edge must turn into itself under a half-turn about its\n// midpoint, so its bend is odd about s = 1/2. Seen from either end of its\n// chord, an edge never strays further off it than the angle the chord\n// makes there with the line to the tile's centre, times 0.9: the edge then\n// stays inside a rhombus on its chord whose two halves lie in the fan\n// triangles (centre, corner, corner) of the two tiles it parts. Those\n// triangles never overlap, so no two bent edges meet but at a corner and\n// the copies still cover the plane once.\nfunction limit(u, A, tm) {\n  let r = 0;\n  for (let i = 1; i \u003c 40; i++) {\n    const s = i / 40;\n    r = max(r, abs(u(s)) / min(s, 1 - s));\n  }\n  const a = r > 0 ? min(A, tm / r) : A;\n  return (s) => a * u(s);\n}\nfunction freeBend(c, A, tm) {\n  return limit((s) => sin(PI * s) * (c[0] * sin(PI * s) + 0.8 * c[1] * sin(2 * PI * s) + 0.3 * c[2] * sin(3 * PI * s)), A, tm);\n}\nfunction oddBend(c, A, tm) {\n  return limit((s) => sin(PI * s) * (1.3 * c[0] * sin(2 * PI * s) + 0.5 * c[1] * sin(4 * PI * s)), A, tm);\n}\n// The tangent of the stray allowed: 0.9 of the smallest angle between a\n// chord and the line from its end to the centre of the corners.\nfunction stray(V) {\n  const n = V.length;\n  let cx = 0, cy = 0, m = PI;\n  for (const p of V) {\n    cx += p[0] / n;\n    cy += p[1] / n;\n  }\n  const ang = (o, a, b) => {\n    const ax = a[0] - o[0], ay = a[1] - o[1], bx = b[0] - o[0], by = b[1] - o[1];\n    return abs(atan2(ax * by - ay * bx, ax * bx + ay * by));\n  };\n  for (let i = 0; i \u003c n; i++) {\n    const p = V[i], q = V[(i + 1) % n], C = [cx, cy];\n    m = min(m, ang(p, q, C), ang(q, p, C));\n  }\n  return Math.tan(0.9 * m);\n}\n\n// The six types. Each returns the corners V in order round the tile\n// (counter-clockwise), the edges as point lists from V[i] to V[i+1], the\n// isometry n[i] that carries the tile onto its neighbour across edge i,\n// and how many orientation classes the group has. c(j) is edge j's slowly\n// turning bend coefficients and g(j) a slow wave for the corners.\nconst TYPES = [\n  {\n    name: \"C3C3C3C3C3C3\", m: 3,\n    build(c, g, A) {\n      // V0, V2, V4 are a fixed equilateral triangle of 3-fold centres; V1\n      // wanders, and V3, V5 follow it by turns of -120 degrees.\n      const V = [];\n      for (let i = 0; i \u003c 6; i++) V.push([cos((i * PI) / 3), sin((i * PI) / 3)]);\n      V[1] = [V[1][0] + 0.18 * g(0), V[1][1] + 0.18 * g(1)];\n      const r0 = Rot(V[0], -TAU / 3), r2 = Rot(V[2], -TAU / 3), r4 = Rot(V[4], -TAU / 3);\n      V[3] = ap(r2, V[1]);\n      V[5] = ap(r4, V[3]);\n      const tm = stray(V);\n      const e1 = edge(V[1], V[2], freeBend(c(0), A, tm)), e3 = edge(V[3], V[4], freeBend(c(1), A, tm)), e5 = edge(V[5], V[0], freeBend(c(2), A, tm));\n      const E = [rev(mapPts(r0, e5)), e1, rev(mapPts(r2, e1)), e3, rev(mapPts(r4, e3)), e5];\n      return { V, E, n: [r0, inv(r2), r2, inv(r4), r4, inv(r0)] };\n    },\n  },\n  {\n    name: \"TG1G1TG2G2\", m: 2,\n    build(c, g, A) {\n      // T moves the tile up by h; the glides g1, g2 reflect it in vertical\n      // lines and move it half of h, so mirrored columns alternate.\n      const w = 1, h = 1.25, s = 0.22 * g(0), p = 0.32 + 0.12 * g(1), q = -0.32 + 0.12 * g(2);\n      const V = [[0, 0], [w, s], [w + p, s + h / 2], [w, s + h], [0, h], [q, h / 2]], tm = stray(V);\n      const g1 = Glide(w + p / 2, h / 2), g2 = Glide(q / 2, -h / 2), t = Tr(0, h);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e1 = edge(V[1], V[2], freeBend(c(1), A, tm)), e4 = edge(V[4], V[5], freeBend(c(2), A, tm));\n      const E = [e0, e1, mapPts(g1, e1), rev(mapPts(t, e0)), e4, mapPts(g2, e4)];\n      return { V, E, n: [inv(t), inv(g1), g1, t, inv(g2), g2] };\n    },\n  },\n  {\n    name: \"CCCC\", m: 2,\n    build(c, g, A) {\n      // Any quadrilateral tiles by half-turns about its edge midpoints.\n      const V = [[0.12 * g(0), 0.1 * g(1)], [1.1 + 0.12 * g(2), 0.08 * g(3)], [1.18 + 0.1 * g(4), 1.02 + 0.1 * g(5)], [-0.12 + 0.1 * g(6), 0.9 + 0.1 * g(7)]];\n      const E = [], n = [], tm = stray(V);\n      for (let i = 0; i \u003c 4; i++) {\n        const P = V[i], Q = V[(i + 1) % 4];\n        E.push(edge(P, Q, oddBend(c(i), A * 1.15, tm)));\n        n.push(Half(P, Q));\n      }\n      return { V, E, n };\n    },\n  },\n  {\n    name: \"TCTC\", m: 2,\n    build(c, g, A) {\n      const u = [1.15, 0.22 * g(0)], v = [0.28 * g(1), 1];\n      const V = [[0, 0], u, [u[0] + v[0], u[1] + v[1]], v], tm = stray(V);\n      const t = Tr(v[0], v[1]);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e1 = edge(V[1], V[2], oddBend(c(1), A * 1.15, tm)), e3 = edge(V[3], V[0], oddBend(c(2), A * 1.15, tm));\n      const E = [e0, e1, rev(mapPts(t, e0)), e3];\n      return { V, E, n: [inv(t), Half(V[1], V[2]), t, Half(V[3], V[0])] };\n    },\n  },\n  {\n    name: \"TTTT\", m: 1,\n    build(c, g, A) {\n      const u = [1.1, 0.25 * g(0)], v = [0.3 * g(1), 1];\n      const V = [[0, 0], u, [u[0] + v[0], u[1] + v[1]], v], tm = stray(V);\n      const tu = Tr(u[0], u[1]), tv = Tr(v[0], v[1]);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e1 = edge(V[1], V[2], freeBend(c(1), A, tm));\n      const E = [e0, e1, rev(mapPts(tv, e0)), rev(mapPts(inv(tu), e1))];\n      return { V, E, n: [inv(tv), tu, tv, inv(tu)] };\n    },\n  },\n  {\n    name: \"C4C4C4C4\", m: 4,\n    build(c, g, A) {\n      // A square with 4-fold centres at V0 and V2: edge V0V1 turns a quarter\n      // about V0 into V0V3, edge V2V3 a quarter about V2 into V2V1.\n      const V = [[0, 0], [1, 0], [1, 1], [0, 1]], tm = stray(V);\n      const r0 = Rot(V[0], PI / 2), r2 = Rot(V[2], PI / 2);\n      const e0 = edge(V[0], V[1], freeBend(c(0), A, tm)), e2 = edge(V[2], V[3], freeBend(c(1), A, tm));\n      const E = [e0, rev(mapPts(r2, e2)), e2, rev(mapPts(r0, e0))];\n      return { V, E, n: [inv(r0), r2, inv(r2), r0] };\n    },\n  },\n];\n\n// At Size 0 each tile covers this many LEDs; every edge asks for a bend of\n// BEND times its length, and gets it unless its stray limit says less.\nconst AREA = 290, BEND = 0.45;\nconst PERIOD = 8, WIPE = 1.2;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, size: 0, type: -1, base: -1, next: -1, since: 0, wipe: 1,\n    ox: 0, oy: 0,\n    own: [new Int32Array(N), new Int32Array(N)], cnt: [new Uint8Array(N), new Uint8Array(N)],\n    tiles: [[], []], frames: 0, bad: 0, c: [0, 0, 0],\n  };\n}\n\nfunction polygonArea(V) {\n  let a = 0;\n  for (let i = 0; i \u003c V.length; i++) {\n    const p = V[i], q = V[(i + 1) % V.length];\n    a += p[0] * q[1] - q[0] * p[1];\n  }\n  return abs(a) / 2;\n}\n\n// The tiling of type k at time t, rasterised into own (tile index per LED)\n// and cnt (how many tiles cover each LED centre).\nfunction tile(S, k, slot) {\n  const ty = TYPES[k], t = S.t;\n  const c = (j) => [sin(0.53 * t + 1.7 * j + 0.3 * k), sin(0.37 * t + 2.9 * j + 1.1 * k), sin(0.29 * t + 4.1 * j + 2.3 * k)];\n  const g = (j) => sin(0.23 * t + 1.9 * j + k);\n  const T = ty.build(c, g, BEND);\n  const sc = sqrt((AREA * Math.pow(2, 1.6 * S.size)) / polygonArea(T.V));\n  // The boundary, closed, in tile units.\n  const poly = [];\n  for (const e of T.E) for (let i = 0; i \u003c e.length - 1; i++) poly.push(e[i]);\n  let cx = 0, cy = 0;\n  for (const p of T.V) {\n    cx += p[0] / T.V.length;\n    cy += p[1] / T.V.length;\n  }\n  let rad = 0;\n  for (const p of poly) rad = max(rad, sqrt((p[0] - cx) ** 2 + (p[1] - cy) ** 2));\n  // Tile units to LEDs: scale, and put the first tile's centre at the\n  // panel's centre plus the drift.\n  const view = [sc, 0, 0, sc, 32 + S.ox - sc * cx, 64 + S.oy - sc * cy];\n  const own = S.own[slot], cnt = S.cnt[slot], tiles = [], np = poly.length, Q = new Float64Array(2 * np);\n  own.fill(-1);\n  cnt.fill(0);\n  // Every copy is found from the first by crossing edges, and a copy is\n  // known by where its centre lands.\n  const seen = new Set([round(cx * 64) * 65536 + round(cy * 64)]), queue = [[1, 0, 0, 1, 0, 0]], reach = sc * rad + 2;\n  for (let qi = 0; qi \u003c queue.length; qi++) {\n    const M = queue[qi], F = mul(view, M), ux = F[0] * cx + F[1] * cy + F[4], uy = F[2] * cx + F[3] * cy + F[5];\n    if (ux \u003c -reach || ux > W + reach || uy \u003c -reach || uy > H + reach) continue;\n    const id = tiles.length, det = M[0] * M[3] - M[1] * M[2];\n    // The orientation class: the turn of the tile, and for a mirrored copy\n    // the turn of its mirror image, in steps of a full turn over the\n    // rotations the group has.\n    const steps = det > 0 ? ty.m : ty.m / 2;\n    const ang = atan2(M[2], M[0]);\n    const cls = det > 0 || ty.m \u003c 2 ? round((ang / TAU) * steps + steps) % steps : steps + (round((atan2(-M[2], -M[0]) / TAU) * steps + steps) % steps);\n    tiles.push({ Fi: inv(F), cy: uy, cls });\n    for (let i = 0; i \u003c np; i++) {\n      const x = poly[i][0], y = poly[i][1];\n      Q[2 * i] = F[0] * x + F[1] * y + F[4];\n      Q[2 * i + 1] = F[2] * x + F[3] * y + F[5];\n    }\n    fill(Q, np, id, own, cnt);\n    for (const nb of T.n) {\n      const K = mul(M, nb), key = round((K[0] * cx + K[1] * cy + K[4]) * 64) * 65536 + round((K[2] * cx + K[3] * cy + K[5]) * 64);\n      if (seen.has(key)) continue;\n      seen.add(key);\n      queue.push(K);\n    }\n  }\n  S.tiles[slot] = tiles;\n  S.v0 = T.V[0];\n  S.rad = rad;\n  return tiles;\n}\n\n// Even-odd scanline fill of LED centres (x + 0.5, y + 0.5), half-open on\n// both axes, so two tiles that share an edge split the LEDs along it. Each\n// segment drops its crossings into the rows it spans.\nconst rowX = [];\nfor (let r = 0; r \u003c H; r++) rowX.push([]);\nfunction fill(Q, n, id, own, cnt) {\n  let r0 = H, r1 = -1;\n  for (let i = 0; i \u003c n; i++) {\n    const j = (i + 1) % n;\n    let ax = Q[2 * i], ay = Q[2 * i + 1], bx = Q[2 * j], by = Q[2 * j + 1];\n    if (ay === by) continue;\n    if (ay > by) {\n      const tx = ax, ty = ay;\n      ax = bx;\n      ay = by;\n      bx = tx;\n      by = ty;\n    }\n    // Rows whose centre yc has ay \u003c= yc \u003c by.\n    const ra = max(0, Math.ceil(ay - 0.5)), rb = min(H - 1, Math.ceil(by - 0.5) - 1);\n    if (ra > rb) continue;\n    const k = (bx - ax) / (by - ay);\n    for (let r = ra; r \u003c= rb; r++) rowX[r].push(ax + (r + 0.5 - ay) * k);\n    if (ra \u003c r0) r0 = ra;\n    if (rb > r1) r1 = rb;\n  }\n  for (let r = r0; r \u003c= r1; r++) {\n    const xs = rowX[r];\n    if (xs.length > 2) xs.sort((p, q) => p - q);\n    else if (xs.length === 2 && xs[0] > xs[1]) xs.reverse();\n    for (let j = 0; j + 1 \u003c xs.length; j += 2) {\n      const c0 = max(0, Math.ceil(xs[j] - 0.5)), c1 = min(W - 1, Math.ceil(xs[j + 1] - 0.5) - 1);\n      for (let x = c0, p = r * W + c0; x \u003c= c1; x++, p++) {\n        own[p] = id;\n        cnt[p]++;\n      }\n    }\n    xs.length = 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  S.hue = k[0];\n  S.size = cl(k[3], -1, 1);\n  const base = round(cl(k[2], 0, 5));\n  if (base !== S.base) {\n    // A turned knob shows its type now, and the cycle goes on from there.\n    if (S.base \u003c 0) S.type = base;\n    else {\n      S.next = base;\n      S.wipe = 0;\n    }\n    S.base = base;\n    S.since = 0;\n  }\n  S.t += tau;\n  S.since += tau;\n  S.ox += tau * 0.9;\n  S.oy -= tau * 1.6;\n  if (S.wipe >= 1 && S.since >= PERIOD) {\n    S.next = (S.type + 1) % TYPES.length;\n    S.wipe = 0;\n    S.since = 0;\n  }\n  if (S.wipe \u003c 1) {\n    S.wipe += tau / WIPE;\n    if (S.wipe >= 1) {\n      S.type = S.next;\n      S.next = -1;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.c;\n  const slots = [[S.type, 0]];\n  if (S.next >= 0 && S.wipe \u003c 1) slots.push([S.next, 1]);\n  const info = [];\n  for (const [k, slot] of slots) {\n    const tiles = tile(S, k, slot);\n    info.push({ k, slot, tiles, v0: S.v0, fall: -2.2 / (S.rad * S.rad) });\n    S.frames++;\n    for (let p = 0; p \u003c N; p++) if (S.cnt[slot][p] !== 1) S.bad++;\n  }\n  // The wipe runs down the panel tile by tile: a tile of the new type shows\n  // once its centre is above the line.\n  const line = -20 + (H + 40) * ease(cl(S.wipe, 0, 1));\n  // Each class's colour at full brightness.\n  const pal = [];\n  for (let i = 0; i \u003c 4; i++) {\n    hsv(wheel(S.hue + CLASS[i]), 0.78, 255, c);\n    pal.push([c[0], c[1], c[2]]);\n  }\n  // Which tiling each LED shows, and the tile there, as one number, so the\n  // grout also runs along the seam of a wipe.\n  const kk = S.kk || (S.kk = new Int32Array(N)), lay = S.lay || (S.lay = new Uint8Array(N));\n  const own0 = S.own[0], own1 = S.own[1], two = info.length > 1;\n  for (let p = 0; p \u003c N; p++) {\n    const id = own1[p];\n    lay[p] = two && id >= 0 && info[1].tiles[id].cy \u003c line ? 1 : 0;\n    kk[p] = lay[p] ? -2 - id : own0[p];\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p & 63, y = p >> 6, L = info[lay[p]];\n    const id = lay[p] ? own1[p] : own0[p];\n    if (id \u003c 0 || S.cnt[L.slot][p] !== 1) {\n      // Never seen: a gap or an overlap would show white.\n      display.setPixel(x, y, 255, 255, 255);\n      continue;\n    }\n    const T = L.tiles[id], F = T.Fi, xc = x + 0.5, yc = y + 0.5, me = kk[p];\n    // Grout where the LED to the right or below belongs to another tile.\n    const grout = (x \u003c W - 1 && kk[p + 1] !== me) || (y \u003c H - 1 && kk[p + W] !== me);\n    // Shade: brightest at the tile's first corner, so its turn shows.\n    const qx = F[0] * xc + F[1] * yc + F[4] - L.v0[0], qy = F[2] * xc + F[3] * yc + F[5] - L.v0[1];\n    const v = (0.45 + 0.55 * exp((qx * qx + qy * qy) * L.fall)) * (grout ? 0.14 : 1);\n    const col = pal[T.cls & 3];\n    display.setPixel(x, y, round(col[0] * v), round(col[1] * v), round(col[2] * v));\n  }\n}\n\n// Class colours on the wheel: azure, pink, green, violet at Hue 0.\nconst CLASS = [0.477, 0.849, 0.186, 0.686];\nconst ease = (u) => u * u * (3 - 2 * u);\n","riemann-function":"// ===== Patternflow pattern =====\n// Title:   Riemann's Function\n// Family:  fractal\n// Idea:    A pen draws Duistermaat's curve phi(t), the complex form of Riemann's non-differentiable function, as a heart of spirals across the top of the panel, and the loupe below dives into one rational point of it, where the curve turns a right angle or, at p/q with p and q both odd, runs straight through with Gerver's derivative -1/2.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Riemann's non-differentiable function (Bernhard Riemann, c. 1861, reported by Karl Weierstrass, 1872), non-differentiability at the irrationals (G. H. Hardy, 1916), differentiability at p/q with p and q odd (Joseph Gerver, 1970), the complex curve phi (J. J. Duistermaat, 1991), the corner of a polygonal vortex filament under the binormal flow (Francisco de la Hoz and Luis Vega, 2014), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Point=0..1, Depth=0..1\n//\n// Knob 1: Hue. Turns the curve's colours round the wheel; they run by the distance from t = 1, so the heart is coloured the same on both halves, as phi(2 - t) = -conj phi(t) makes it. At 0 the top centre, t = 1, is azure, the sides violet and the tip, t = 0, pink; at 0.25 violet to green, at 0.5 yellow to cyan, at 0.75 green to violet. Orange is skipped, as it reads brown when dim. In the loupe the hue also swings by 0.07 once every factor 16 in s = t - t0, bands that flow outward as the loupe dives.\n// Knob 2: Speed. One lap of the pen round t in [0, 2] takes 16 / Speed seconds: 8 s at 2, 80 s at 0.2, 5.3 s at 3. The last 0.3 s of its trail burns white, the curve it has passed stays bright for about a fifth of a lap and settles to 40 percent. The loupe dives in and comes out once a lap, deepest just as the pen passes its point, which it lights up; at Speed 2 that is 2.5 s in.\n// Knob 3: Point. The rational t0 the loupe dives into, boxed on the heart: 1 below 0.2, 1/2 to 0.4, 1/3 to 0.6, 0 (the tip) to 0.8, then 2/3. At 1 and 1/3, p and q both odd, the curve passes straight through, horizontal, phi'(t0) = -1/2, a bowtie of small rosettes, one every 8 s^2 in s, closing on the point; the pattern's own sums give (phi(1 + s) - phi(1)) / s = -0.300 - 0.181i, -0.410, -0.456 and -0.490 at s = 1/32, 1/128, 1/512 and 1/2048. Elsewhere it turns a right angle along c e^(i pi / 4) sqrt s and -c e^(-i pi / 4) sqrt |s|, c the mean of e^(i pi p r^2 / q) over r mod 2q: arms up and left at 1/2, where |phi(t0 + s) - phi(t0)| / sqrt s reaches 0.70711 = 1 / sqrt 2 by s = 1e-7; the V of the tip, 0.99997 at s = 7.5e-9; arms up-left and down-left at 2/3, 0.57738 against 1 / sqrt 3 = 0.57735. The dim grey lines in the loupe are these predicted tangents.\n// Knob 4: Depth. How far the loupe dives, 2^(4 + 4 Depth) times the loupe's opening scale, 200 LEDs a unit: 16 times at 0, 19 at the opening 0.06, where the loupe is 1/48 of the heart's width, 64 at 0.5 and 256 at 1, 1/644 of it. At t0 = 1 the bowtie stands 14 LEDs tall at the loupe's ends at 0.5 and 8 at 1, and 2 in the middle at both.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, cos, sin, exp, round, ceil, abs, log2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without its orange, 0.03 to 0.15, which reads brown when dim.\nconst wheel = (h) => 0.15 + (h - floor(h)) * 0.88;\n\n// phi(t) = sum over n >= 1 of e^(i pi n^2 t) / (i pi n^2). The table of the\n// whole period sums the first NT terms: past n = 128 a term moves the top\n// view by less than 1/600 of an LED.\nconst NT = 128;\n// The whole period t in [0, 2), G samples.\nconst G = 12288, HG = 2 / G;\n// The rational points the loupe can dive into, p / q.\nconst POINTS = [[1, 1], [1, 2], [1, 3], [0, 1], [2, 3]];\n\n// The top view: 77 LEDs a unit, phi(1) = i pi / 12 near the top.\nconst TS = 77, TX = 31.5, TY = 31.2;\n// The loupe: rows 74 to 127, centre (31.5, 100.5), half width RHO0 / M.\nconst LY0 = 74, LCX = 31.5, LCY = 100.5, RHO0 = 0.16;\n\n// Fresnel auxiliary functions f(w), g(w): the integral of e^(i pi u^2 / 2)\n// from w to infinity is (g + i f) e^(i pi w^2 / 2). A power series below\n// w = 3, the asymptotic series above.\nconst FG = [0, 0];\nfunction fresnelFG(w) {\n  if (w >= 3) {\n    const x = PI * w * w, x2 = 1 / (x * x);\n    FG[0] = (1 - 3 * x2 + 105 * x2 * x2 - 10395 * x2 * x2 * x2) / (PI * w);\n    FG[1] = (1 - 15 * x2 + 945 * x2 * x2) / (PI * PI * w * w * w);\n    return;\n  }\n  const a = PI / 2, w2 = w * w, w4 = w2 * w2;\n  let C = 0, S = 0, tc = w, ts = a * w * w2;\n  for (let n = 0; n \u003c 32; n++) {\n    C += tc / (4 * n + 1);\n    S += ts / (4 * n + 3);\n    tc *= (-a * a * w4) / ((2 * n + 1) * (2 * n + 2));\n    ts *= (-a * a * w4) / ((2 * n + 2) * (2 * n + 3));\n  }\n  const th = a * w2, A = 0.5 - C, B = 0.5 - S, co = cos(th), si = sin(th);\n  FG[0] = B * co - A * si;\n  FG[1] = A * co + B * si;\n}\n// I(s), the terms past a cut at n = N summed as an integral from L = N + 1/2:\n// the sum over n > N of (e^(i pi n^2 s) - 1) / (i pi n^2). Near a rational\n// p/q every term there carries the same mean factor c, so c I(s) puts back\n// the square-root corner the cut series would round off.\nconst IC = [0, 0];\nfunction tail(s, L) {\n  const as = abs(s), ph = PI * L * L * s;\n  let re = sin(ph) / (PI * L), im = (1 - cos(ph)) / (PI * L);\n  fresnelFG(L * sqrt(2 * as));\n  const r = sqrt(2 * as), pa = PI * L * L * as, cp = cos(pa), sp = sin(pa);\n  const pr = r * (FG[1] * cp - FG[0] * sp), pi = r * (FG[1] * sp + FG[0] * cp);\n  if (s >= 0) (re += pr), (im += pi);\n  else (re -= pr), (im += pi);\n  IC[0] = re;\n  IC[1] = im;\n}\n\nlet GX = null, GY = null;\n// The whole curve once, by turning each term's phasor a step at a time.\nfunction curve() {\n  if (GX) return;\n  GX = new Float64Array(G + 1);\n  GY = new Float64Array(G + 1);\n  for (let n = 1; n \u003c= NT; n++) {\n    const k = PI * n * n, a = 1 / k, rc = cos(k * HG), rs = sin(k * HG);\n    // 1 / (i pi n^2) = -i / (pi n^2)\n    let x = 0, y = -a;\n    for (let i = 0; i \u003c= G; i++) {\n      GX[i] += x;\n      GY[i] += y;\n      const nx = x * rc - y * rs;\n      y = x * rs + y * rc;\n      x = nx;\n    }\n  }\n}\n\n// The loupe's polyline for one point: shells about s = 0, each 4 times\n// thinner than the last, from s = 1/8 down to 1/8 / 4^12 = 7.5e-9, each\n// summed by turning its terms' phasors in even steps, then the rest of the\n// period from the table. Near p/q with p and q odd the curve runs along its\n// tangent as a train of small rosettes, one every 8 s^2 in s and 3.1 s^1.5\n// across (3.29 at s = 1/32, 3.11 at 1/256, summed to 3000 terms), so there\n// the shells take enough steps for each rosette as the loupe will show it:\n// 800 steps from s = 1/8 to 1/32, 16 to a rosette from 1/512 to 1/2048, where\n// at 256 times a rosette is up to 5 LEDs across. Inside s = 1/2048 they are\n// 1.7 LEDs at most and the 1024 terms a shell sums there no longer hold them,\n// so those shells take 240 steps and draw the line. A shell sums 256 terms out\n// to s = 1/32 and 1024 inside it.\nconst S0 = 1 / 8, SHELLS = 12, QODD = [800, 800, 1300, 2600, 3100], QCORNER = [600], QMIN = 240, GROUP = 120;\nconst CUT = (j) => (j \u003c 2 ? 256 : 1024);\nconst NS = 1024;\nfunction loupe(S, which) {\n  const [p, q] = POINTS[which], t0 = p / q;\n  // c, the mean of e^(i pi p r^2 / q) over r mod 2q: zero exactly when p and\n  // q are both odd.\n  let cr = 0, ci = 0;\n  for (let r = 0; r \u003c 2 * q; r++) {\n    const a = (PI * p * r * r) / q;\n    cr += cos(a);\n    ci += sin(a);\n  }\n  cr /= 2 * q;\n  ci /= 2 * q;\n  if (abs(cr) \u003c 1e-9) cr = 0;\n  if (abs(ci) \u003c 1e-9) ci = 0;\n  const odd = cr === 0 && ci === 0;\n  // The terms e^(i pi n^2 t0) / (i pi n^2) = (sin - i cos) / (pi n^2).\n  // For each cut N: phi at t0 cut there, and the coefficients' own part past\n  // it. With B_n the partial sums of e^(i pi m^2 t0) - c, the terms past N\n  // add (\u003cB> - B_N) times one more term, \u003cB> the mean of B over a period;\n  // this keeps the slope at the point, \u003cB> - c / 2, which comes to -1/2 at\n  // every p/q with p and q odd.\n  const AR = new Float64Array(NS + 1), AI = new Float64Array(NS + 1);\n  let px = 0, py = 0, br = 0, bi = 0, mr = 0, mi = 0;\n  const at = {};\n  for (let n = 1; n \u003c= NS; n++) {\n    const k = PI * n * n, ph = (PI * ((n * n * p) % (2 * q))) / q;\n    AR[n] = sin(ph) / k;\n    AI[n] = -cos(ph) / k;\n    px += AR[n];\n    py += AI[n];\n    br += cos(ph) - cr;\n    bi += sin(ph) - ci;\n    if (n \u003c= 2 * q) (mr += br / (2 * q)), (mi += bi / (2 * q));\n    if (n === NT || n === 256 || n === NS) at[n] = [px, py, br, bi];\n  }\n  const cut = {};\n  for (const N of [NT, 256, NS]) {\n    const [x, y, b1, b2] = at[N];\n    cut[N] = [N + 0.5, mr - b1, mi - b2, x, y];\n  }\n  const xs = [], ys = [], ss = [];\n  const put = (s, x, y, N) => {\n    const [L, kr, ki, ox, oy] = cut[N];\n    tail(s, L);\n    // K (e^(i pi L^2 s) - 1) / (i pi L^2)\n    const ph = PI * L * L * s, fr = sin(ph) / (PI * L * L), fi = (1 - cos(ph)) / (PI * L * L);\n    xs.push(x - ox + cr * IC[0] - ci * IC[1] + kr * fr - ki * fi);\n    ys.push(y - oy + cr * IC[1] + ci * IC[0] + kr * fi + ki * fr);\n    ss.push(s);\n  };\n  // Each term's phasor and its turn for one step, side by side.\n  const WT = new Float64Array(4 * (NS + 1));\n  const shell = (sa, sb, Q, N) => {\n    // sa to sb in Q steps, the end sb left out.\n    const h = (sb - sa) / Q;\n    for (let n = 1, o = 4; n \u003c= N; n++, o += 4) {\n      const k = PI * n * n, c0 = cos(k * sa), s0 = sin(k * sa);\n      WT[o] = AR[n] * c0 - AI[n] * s0;\n      WT[o + 1] = AR[n] * s0 + AI[n] * c0;\n      WT[o + 2] = cos(k * h);\n      WT[o + 3] = sin(k * h);\n    }\n    const end = 4 * N + 4;\n    for (let i = 0; i \u003c Q; i++) {\n      let x = 0, y = 0;\n      for (let o = 4; o \u003c end; o += 4) {\n        const wr = WT[o], wi = WT[o + 1], rc = WT[o + 2], rs = WT[o + 3];\n        x += wr;\n        y += wi;\n        WT[o] = wr * rc - wi * rs;\n        WT[o + 1] = wr * rs + wi * rc;\n      }\n      put(sa + i * h, x, y, N);\n    }\n  };\n  const QS = (j) => (odd ? QODD[j] : QCORNER[j]) || QMIN;\n  // At t0 = 0 and 1 the curve is its own mirror about the point,\n  // z(-s) = -conj z(s), from phi(2 - t) = -conj phi(t); one side is enough.\n  if (q === 1) {\n    for (let j = SHELLS - 1; j >= 0; j--) shell(S0 / 4 ** (j + 1), S0 / 4 ** j, QS(j), CUT(j));\n    const m = xs.length;\n    for (let i = m - 1; i >= 0; i--) xs.push(-xs[i]), ys.push(ys[i]), ss.push(-ss[i]);\n    // The mirrored half runs from -S0 in to -S0 / 4^12: move it to the front\n    // so the line runs -S0 .. 0 .. S0.\n    const nx = xs.splice(m), ny = ys.splice(m), ns = ss.splice(m);\n    xs.unshift(...nx, 0);\n    ys.unshift(...ny, 0);\n    ss.unshift(...ns, 0);\n  } else {\n    for (let j = 0; j \u003c SHELLS; j++) shell(-S0 / 4 ** j, -S0 / 4 ** (j + 1), QS(j), CUT(j));\n    xs.push(0), ys.push(0), ss.push(0);\n    for (let j = SHELLS - 1; j >= 0; j--) shell(S0 / 4 ** (j + 1), S0 / 4 ** j, QS(j), CUT(j));\n  }\n  // The rest of the period from the table, from t0 + S0 round to t0 - S0.\n  const i0 = ceil((t0 + S0) / HG - 1e-9), i1 = floor((t0 + 2 - S0) / HG + 1e-9);\n  for (let i = i0; i \u003c= i1; i++) {\n    const g = ((i % G) + G) % G;\n    let s = i * HG - t0;\n    s -= 2 * floor((s + 1) / 2);\n    put(s, GX[g], GY[g], NT);\n  }\n  // Keep a sample only once the curve has moved a quarter of an LED from the\n  // last one kept, as the loupe shows it when that sample is at its edge:\n  // 1/180 of the distance to phi(t0), and no less than 1/200 of an LED at\n  // 256 times.\n  const n0 = xs.length, kx = [], ky = [], ks = [], gs = [];\n  let lx = 1e9, ly = 1e9;\n  for (let i = 0; i \u003c n0; i++) {\n    const x = xs[i], y = ys[i], r = sqrt(x * x + y * y), d = sqrt((x - lx) ** 2 + (y - ly) ** 2);\n    if (ss[i] !== 0 && d \u003c max(r / 180, 1e-7) && i \u003c n0 - 1) continue;\n    if (kx.length % GROUP === 0) gs.push(kx.length);\n    kx.push(x), ky.push(y), ks.push(ss[i]);\n    (lx = x), (ly = y);\n  }\n  const n = kx.length, ng = gs.length;\n  gs.push(n);\n  const box = new Float64Array(ng * 5);\n  for (let g = 0; g \u003c ng; g++) {\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9, len = 0;\n    for (let i = gs[g]; i \u003c= gs[g + 1]; i++) {\n      const k = i % n, x = kx[k], y = ky[k];\n      x0 = min(x0, x);\n      x1 = max(x1, x);\n      y0 = min(y0, y);\n      y1 = max(y1, y);\n      if (i > gs[g]) len += sqrt((x - kx[(i - 1) % n]) ** 2 + (y - ky[(i - 1) % n]) ** 2);\n    }\n    box.set([x0, x1, y0, y1, len], g * 5);\n  }\n  S.lx = Float64Array.from(kx);\n  S.ly = Float64Array.from(ky);\n  S.ls = Float64Array.from(ks);\n  S.lg = Int32Array.from(gs);\n  S.lbox = box;\n  S.t0 = t0;\n  S.c = [cr, ci];\n  S.which = which;\n  S.lcol = null;\n}\n\n// Top view splats: for each LED a line of the curve crosses, how much line\n// from which stretch of t, NB stretches to the period. Built once.\nconst NB = 1024, PB = G / NB;\nlet TE = null;\nfunction topSplats() {\n  if (TE) return;\n  const P = [], Wt = [], I = [], acc = new Float32Array(NP), seen = [];\n  const touch = (a, b, v) => {\n    if (a \u003c 0 || a >= W || b \u003c 0 || b >= LY0 - 2 || v \u003c= 0) return;\n    const p = b * W + a;\n    if (acc[p] === 0) seen.push(p);\n    acc[p] += v;\n  };\n  for (let bk = 0; bk \u003c NB; bk++) {\n    for (let i = bk * PB; i \u003c (bk + 1) * PB; i++) {\n      const x0 = TX + GX[i] * TS, y0 = TY - GY[i] * TS, x1 = TX + GX[i + 1] * TS, y1 = TY - GY[i + 1] * TS;\n      const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, ceil(len * 2)), w = len / n;\n      for (let k = 0; k \u003c n; k++) {\n        const u = (k + 0.5) / n, x = x0 + (x1 - x0) * u, y = y0 + (y1 - y0) * u;\n        const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n        touch(ix, iy, (1 - fx) * (1 - fy) * w);\n        touch(ix + 1, iy, fx * (1 - fy) * w);\n        touch(ix, iy + 1, (1 - fx) * fy * w);\n        touch(ix + 1, iy + 1, fx * fy * w);\n      }\n    }\n    for (const p of seen) P.push(p), Wt.push(acc[p]), I.push(bk), (acc[p] = 0);\n    seen.length = 0;\n  }\n  TE = { p: Int32Array.from(P), w: Float32Array.from(Wt), i: Int32Array.from(I) };\n}\n\nexport function setup(params) {\n  params.s = null;\n}\n\nfunction init(params) {\n  curve();\n  topSplats();\n  const S = {\n    clock: 0, hue: -1, which: -1,\n    bcol: new Float32Array(NB * 3), bb: new Float32Array(NB), bw: new Float32Array(NB),\n    R: new Float32Array(NP), Gc: new Float32Array(NP), B: new Float32Array(NP), D: new Float32Array(NP),\n  };\n  params.s = S;\n  return S;\n}\n\n// Azure at t = 1, the top, to pink at t = 0 and 2, the tip: mirror-symmetric\n// like the curve, phi(2 - t) = -conj phi(t).\nconst hueAt = (S, t, band = 0) => wheel(0.5 + S.hue + 0.42 * abs(1 - t) + band);\n\nexport function update(dt, input, params) {\n  const S = params.s || init(params);\n  const k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(k[1], 0.2, 3);\n  const which = min(POINTS.length - 1, floor(cl(k[2], 0, 1) * POINTS.length));\n  if (which !== S.which) loupe(S, which);\n  S.depth = 4 + 4 * cl(k[3], 0, 1);\n  if (k[0] !== S.hue) {\n    S.hue = k[0];\n    for (let b = 0; b \u003c NB; b++) hsv(hueAt(S, (b + 0.5) * PB * HG), 0.72, 1, S.bcol, b * 3);\n    S.lcol = null;\n  }\n  S.clock += d;\n}\n\nfunction add(S, x, y, v, r, g, b) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  put(S, ix, iy, (1 - fx) * (1 - fy) * v, r, g, b);\n  put(S, ix + 1, iy, fx * (1 - fy) * v, r, g, b);\n  put(S, ix, iy + 1, (1 - fx) * fy * v, r, g, b);\n  put(S, ix + 1, iy + 1, fx * fy * v, r, g, b);\n}\nfunction put(S, x, y, v, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c LY0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * r;\n  S.Gc[p] += v * g;\n  S.B[p] += v * b;\n  S.D[p] += v;\n}\n// Light straight into the frame, after the tone curve: a bilinear dot, and\n// a thin line of them kept to rows `top` and below.\nfunction dot(S, x, y, v, top = 0) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  lit(S, ix, iy, (1 - fx) * (1 - fy) * v, top);\n  lit(S, ix + 1, iy, fx * (1 - fy) * v, top);\n  lit(S, ix, iy + 1, (1 - fx) * fy * v, top);\n  lit(S, ix + 1, iy + 1, fx * fy * v, top);\n}\nfunction lit(S, a, b, v, top) {\n  if (a \u003c 0 || a >= W || b \u003c top || b >= H) return;\n  const p = b * W + a;\n  S.R[p] += v;\n  S.Gc[p] += v;\n  S.B[p] += v;\n}\nfunction glow(S, x0, y0, x1, y1, v, top) {\n  const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), n = max(1, ceil(len * 1.5)), w = (v * len) / (n + 1);\n  for (let k = 0; k \u003c= n; k++) dot(S, x0 + ((x1 - x0) * k) / n, y0 + ((y1 - y0) * k) / n, w, top);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, Gc, B, D, bcol, bb, bw } = S;\n  R.fill(0);\n  Gc.fill(0);\n  B.fill(0);\n  D.fill(0);\n  // One lap of the pen takes 16 / Speed seconds; at Speed 2 it reaches the\n  // loupe's point 2.5 s in, as deep as the loupe goes.\n  const T = 16 / S.speed, lap = S.clock / T + S.t0 / 2 - 2.5 / 8;\n  const tp = 2 * (lap - floor(lap));\n  const base = 0.4, tau = T / 5;\n  const age = (t) => {\n    let a = tp - t;\n    a -= 2 * floor(a / 2);\n    return (a * T) / 2;\n  };\n  for (let b = 0; b \u003c NB; b++) bb[b] = base + (1 - base) * exp(-age((b + 0.5) * PB * HG) / tau);\n  // The top view.\n  const { p: EP, w: EW, i: EI } = TE;\n  // The last third of a second behind the pen burns white.\n  for (let b = 0; b \u003c NB; b++) bw[b] = exp(-age((b + 0.5) * PB * HG) / 0.3);\n  for (let e = 0; e \u003c EP.length; e++) {\n    const p = EP[e], b = EI[e], w = EW[e], v = w * bb[b], h = bw[b];\n    R[p] += v * (bcol[b * 3] + (1 - bcol[b * 3]) * h);\n    Gc[p] += v * (bcol[b * 3 + 1] + (1 - bcol[b * 3 + 1]) * h);\n    B[p] += v * (bcol[b * 3 + 2] + (1 - bcol[b * 3 + 2]) * h);\n    D[p] += w;\n  }\n\n  // The dive: magnification 2^(depth w), deepest when the pen is at t0.\n  let ph = lap - S.t0 / 2;\n  ph -= floor(ph);\n  const wv = (1 + cos(2 * PI * ph)) / 2, M = 2 ** (S.depth * wv);\n  const kz = (32 * M) / RHO0;\n  const { lx, ly, ls, lg, lbox } = S, n = lx.length, ng = lg.length - 1;\n  if (!S.lcol) {\n    S.lcol = new Float32Array(n * 3);\n    for (let i = 0; i \u003c n; i++) {\n      let t = S.t0 + ls[i];\n      t -= 2 * floor(t / 2);\n      // Bands of scale: the hue swings once every factor 16 in |s|.\n      const band = ls[i] === 0 ? 0 : 0.07 * cos((PI * log2(abs(ls[i]))) / 2);\n      hsv(hueAt(S, t, band), 0.72, 1, S.lcol, i * 3);\n    }\n  }\n  const lc = S.lcol;\n  // The loupe lights up as the pen passes its point.\n  const lb = 0.65 + 0.35 * exp(-age(S.t0) / tau);\n  const xmin = -1, xmax = W + 1, ymin = LY0 - 1, ymax = H + 1;\n  for (let g = 0; g \u003c ng; g++) {\n    const o = g * 5;\n    if (LCX + lbox[o + 1] * kz \u003c xmin || LCX + lbox[o] * kz > xmax || LCY - lbox[o + 2] * kz \u003c ymin || LCY - lbox[o + 3] * kz > ymax) continue;\n    const a = lg[g], e = lg[g + 1], gap = (lbox[o + 4] * kz) / (e - a);\n    const step = gap >= 0.5 ? 1 : min(64, floor(0.5 / gap));\n    for (let i = a; i \u003c e; i += step) {\n      const j = min(i + step, e) % n;\n      let x0 = LCX + lx[i] * kz, y0 = LCY - ly[i] * kz, x1 = LCX + lx[j] * kz, y1 = LCY - ly[j] * kz;\n      if ((x0 \u003c xmin && x1 \u003c xmin) || (x0 > xmax && x1 > xmax) || (y0 \u003c ymin && y1 \u003c ymin) || (y0 > ymax && y1 > ymax)) continue;\n      let dx = x1 - x0, dy = y1 - y0, len = sqrt(dx * dx + dy * dy);\n      if (len > 40) {\n        // Clip a long segment to the loupe (Liang-Barsky).\n        let u0 = 0, u1 = 1, ok = true;\n        const P4 = [-dx, dx, -dy, dy], Q4 = [x0 - xmin, xmax - x0, y0 - ymin, ymax - y0];\n        for (let c = 0; c \u003c 4 && ok; c++) {\n          const pp = P4[c], qq = Q4[c];\n          if (pp === 0) ok = qq >= 0;\n          else {\n            const r = qq / pp;\n            if (pp \u003c 0) r > u1 ? (ok = false) : r > u0 && (u0 = r);\n            else r \u003c u0 ? (ok = false) : r \u003c u1 && (u1 = r);\n          }\n        }\n        if (!ok) continue;\n        const ax = x0 + dx * u0, ay = y0 + dy * u0;\n        x1 = x0 + dx * u1;\n        y1 = y0 + dy * u1;\n        x0 = ax;\n        y0 = ay;\n        dx = x1 - x0;\n        dy = y1 - y0;\n        len = sqrt(dx * dx + dy * dy);\n      }\n      const m = max(1, ceil(len)), w = len / m;\n      const r = lc[i * 3] * lb, gg = lc[i * 3 + 1] * lb, b = lc[i * 3 + 2] * lb;\n      for (let k = 0; k \u003c m; k++) {\n        const u = (k + 0.5) / m;\n        add(S, x0 + dx * u, y0 + dy * u, w, r, gg, b);\n      }\n    }\n  }\n\n  // Tone: the average colour times min(1, D)^0.6.\n  for (let p = 0; p \u003c NP; p++) {\n    const dd = D[p];\n    if (dd > 0) {\n      const f = min(1, dd) ** 0.6 / dd;\n      R[p] *= f;\n      Gc[p] *= f;\n      B[p] *= f;\n    }\n  }\n\n  // Guides in the loupe: Gerver's tangent, or the corner's two arms along\n  // c e^(i pi/4) and -c e^(-i pi/4).\n  const [cr, ci] = S.c, gv = 0.18;\n  if (cr === 0 && ci === 0) glow(S, 0, LCY, W - 1, LCY, gv, LY0);\n  else {\n    const m = sqrt(cr * cr + ci * ci), e = 80;\n    for (const [ar, ai] of [[(cr - ci) / sqrt(2), (cr + ci) / sqrt(2)], [-(cr + ci) / sqrt(2), (cr - ci) / sqrt(2)]])\n      glow(S, LCX, LCY, LCX + (ar / m) * e, LCY - (ai / m) * e, gv, LY0);\n  }\n  // The loupe's window on the top view, and its point.\n  const g0 = round(S.t0 / HG) % G, cx = TX + GX[g0] * TS, cy = TY - GY[g0] * TS;\n  const wx = (RHO0 / M) * TS, wy = wx * (27 / 32);\n  if (wx >= 1.5) {\n    const v = 0.45;\n    glow(S, cx - wx, cy - wy, cx + wx, cy - wy, v, 0);\n    glow(S, cx - wx, cy + wy, cx + wx, cy + wy, v, 0);\n    glow(S, cx - wx, cy - wy, cx - wx, cy + wy, v, 0);\n    glow(S, cx + wx, cy - wy, cx + wx, cy + wy, v, 0);\n  }\n  dot(S, cx, cy, 0.8);\n  // The pen.\n  {\n    const f = tp / HG, i = min(G - 1, floor(f)), u = f - i;\n    const x = TX + (GX[i] + (GX[i + 1] - GX[i]) * u) * TS, y = TY - (GY[i] + (GY[i + 1] - GY[i]) * u) * TS;\n    dot(S, x, y, 2.5);\n    for (const [ox, oy] of [[-1.2, 0], [1.2, 0], [0, -1.2], [0, 1.2]]) dot(S, x + ox, y + oy, 0.45);\n  }\n  // The loupe's top edge.\n  for (let x = 0; x \u003c W; x += 2) dot(S, x, LY0 - 2, 0.22);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, Gc[p]) * 255), round(min(1, B[p]) * 255));\n}\n","veech-octagon":"// ===== Patternflow pattern =====\n// Title:   Veech Octagon\n// Family:  topology\n// Idea:    Four straight lines on each surface run in one shared direction across the regular octagon with opposite sides glued, above, and the double regular pentagon, below, leaving by a side and coming back by the side glued to it; in most directions they fill their surface evenly, and in the directions Veech's dichotomy picks out they close up and the surface falls apart into two cylinders of closed lines, each its own colour.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: straight-line flow on flat surfaces (Ralph Fox and Richard Kershner, 1936), unique ergodicity in almost every direction (Steven Kerckhoff, Howard Masur and John Smillie, 1986), translation surfaces from regular polygons and the Veech dichotomy (William Veech, 1989), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Direction=45..135, Trail=0..1\n//\n// Knob 1: Hue. Turns the two cylinders round the wheel together. At 0 the shorter cylinder is azure and the longer violet, the lines pale lavender with a white comet at each head, and a surface whose direction fills it dark slate; at 0.25 violet and red, at 0.5 red and green, at 0.75 green and teal. Orange and dark yellow are skipped, as they read brown.\n// Knob 2: Speed. The lines run 0.8 x Speed sides a second, 1.6 at 2 (36 LEDs a second), so a line in the octagon's middle cylinder, 2.41 sides round, closes every 1.5 s. Each line keeps the stretch it ran in the last Trail seconds, so Speed sets its length too: at 0.2 a line is 0.9 sides long and no longer reaches round its cylinder, at 3 it is 13 sides.\n// Knob 3: Direction. The direction of every line, in degrees from the horizontal. Within 1 degree of a periodic direction it snaps to it. The octagon's are 45, 90 and 135, along its sides, where it splits into its middle band, 1 + sqrt 2 = 2.414 sides round, and the two trapezoids either side of it glued into one cylinder 2 + sqrt 2 = 3.414 round, with inverse moduli 2.414 and 4.828, one exactly twice the other; and 67.5 and 112.5, along its diagonals, where the cylinders are 1.848 and 4.461 round and both have inverse modulus 2 cot(pi/8) = 4.828, the thin one showing as two corner triangles. The double pentagon's are 72 and 108, along its sides, cylinders phi = 1.618 and phi^2 = 2.618 round with inverse moduli both 2 cot(pi/5) = 2.753, and 54, 90 and 126, through its corners, 4.980 and 8.057 round with inverse moduli both 26.07, tan^2 72 = 9.47 times thinner. At 90 both surfaces close. Between the snaps the knob passes periodic directions too, densely, but they close only on long lines, 11.90 and 16.84 sides at 56.70 for the octagon, and a direction off them by any amount fills. It opens at 45: the octagon closed, the pentagon filling.\n// Knob 4: Trail. How many seconds of line each head keeps, T = 4 + 56 K4^1.3: 5.5 s at the opening, 8.7 sides at Speed 2, so each closed line in the octagon has been round 2.5 to 3.6 times and glows, while in the pentagon the same length lies as fresh parallel strokes. Every part is as bright as it is recent, falling to nothing at T. At 1 the trail is 60 s, 96 sides, and a surface that fills is an even silver.\n// Buttons: K1 tap starts all eight lines again from new random points. The first ones start from fixed points, two in each cylinder of the octagon at 45 degrees.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, cos, sin, abs, round, ceil, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without orange and dark yellow, 0.03 to 0.17, which read brown.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\n// A translation surface: convex polygons with side 1, y up, each side glued\n// to a parallel side by a translation. For a polygon symmetric about its\n// centre, or a polygon and its copy turned through a half turn, the side\n// from a to b goes to the side from -b to -a, and the translation is\n// -(a + b).\nfunction build(polys, partner) {\n  return polys.map((V, p) =>\n    V.map((a, i) => {\n      const b = V[(i + 1) % V.length], ex = b[0] - a[0], ey = b[1] - a[1], [to, j] = partner(p, i);\n      return { ax: a[0], ay: a[1], ex, ey, nx: -ey, ny: ex, len2: ex * ex + ey * ey, to, j, tx: -(a[0] + b[0]), ty: -(a[1] + b[1]) };\n    }),\n  );\n}\n// The regular octagon, sides horizontal at the top and bottom, side i glued\n// to side i + 4. Area 2 (1 + sqrt 2) = 4.83.\nconst RO = (1 + sqrt(2)) / 2;\nconst OCT_V = [[-0.5, -RO], [0.5, -RO], [RO, -0.5], [RO, 0.5], [0.5, RO], [-0.5, RO], [-RO, 0.5], [-RO, -0.5]];\n// The double pentagon: a regular pentagon standing on a horizontal side and\n// its copy turned through a half turn, glued along that side, every other\n// side of one glued to the parallel side of the other. Area 3.44.\nconst C72 = cos((2 * PI) / 5), S72 = sin((2 * PI) / 5), HP = S72 + sin(PI / 5);\nconst PEN_A = [[-0.5, 0], [0.5, 0], [0.5 + C72, S72], [0, HP], [-0.5 - C72, S72]];\nconst PEN_B = PEN_A.map(([x, y]) => [-x, -y]);\n\n// On the panel: 22.8 LEDs a side. The octagon, 55 LEDs across, at the top;\n// the double pentagon, 37 across and 70 tall, below it.\nconst SC = 22.8;\nconst SURF = [\n  { polys: [OCT_V], E: build([OCT_V], (p, i) => [0, (i + 4) % 8]), cx: 32, cy: 28.1, dirs: [45, 67.5, 90, 112.5, 135] },\n  { polys: [PEN_A, PEN_B], E: build([PEN_A, PEN_B], (p, i) => [1 - p, i]), cx: 32, cy: 92.6, dirs: [54, 72, 90, 108, 126] },\n];\nconst SNAP = 1; // degrees either side of a periodic direction that snap to it\nconst RAYS = 4; // lines on each surface\nconst VEL = 0.8; // sides a second at Speed 1\nconst COMET = 0.5; // sides of white behind each head\n\n// From (x, y) in polygon p along (ux, uy): the distance to the side the line\n// leaves by, that side, and where along it, 0 to 1.\nconst EX = [0, 0, 0];\nfunction exit(E, p, x, y, ux, uy, skip) {\n  const es = E[p];\n  let bt = Infinity, bi = -1;\n  for (let i = 0; i \u003c es.length; i++) {\n    if (i === skip) continue;\n    const e = es[i], un = ux * e.nx + uy * e.ny;\n    if (un >= -1e-15) continue;\n    const t = ((e.ax - x) * e.nx + (e.ay - y) * e.ny) / un;\n    if (t \u003c bt) (bt = t), (bi = i);\n  }\n  if (bi \u003c 0) return null;\n  const e = es[bi];\n  EX[0] = bt \u003c 0 ? 0 : bt;\n  EX[1] = bi;\n  EX[2] = ((x + bt * ux - e.ax) * e.ex + (y + bt * uy - e.ay) * e.ey) / e.len2;\n  return EX;\n}\n// The length of the closed line through (x0, y0) in polygon p0, or -1 when\n// it runs into the corner, the one cone point of angle 6 pi, first.\nfunction period(E, p0, x0, y0, ux, uy) {\n  let p = p0, x = x0, y = y0, skip = -1, L = 0;\n  for (let k = 0; k \u003c 120; k++) {\n    const r = exit(E, p, x, y, ux, uy, skip);\n    if (!r) return -1;\n    const t = r[0], i = r[1], s = r[2];\n    if (k > 0 && p === p0) {\n      const dx = x0 - x, dy = y0 - y, along = dx * ux + dy * uy;\n      if (abs(dx * uy - dy * ux) \u003c 1e-9 && along > -1e-12 && along \u003c= t + 1e-12) return L + along;\n    }\n    if (s \u003c 1e-9 || s > 1 - 1e-9) return -1;\n    const e = E[p][i];\n    x += t * ux + e.tx;\n    y += t * uy + e.ty;\n    L += t;\n    p = e.to;\n    skip = e.j;\n  }\n  return -1;\n}\nfunction inside(E, p, x, y) {\n  for (const e of E[p]) if ((x - e.ax) * e.nx + (y - e.ay) * e.ny \u003c 0) return false;\n  return true;\n}\n\nexport function setup(params) {\n  // Every LED whose centre falls inside a polygon, with its point there.\n  const who = new Int8Array(NP).fill(-1), poly = new Int8Array(NP), px = new Float64Array(NP), py = new Float64Array(NP);\n  for (let s = 0; s \u003c 2; s++) {\n    const S = SURF[s];\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const mx = (x + 0.5 - S.cx) / SC, my = (S.cy - y - 0.5) / SC;\n        for (let p = 0; p \u003c S.E.length; p++)\n          if (inside(S.E, p, mx, my)) {\n            const o = y * W + x;\n            (who[o] = s), (poly[o] = p), (px[o] = mx), (py[o] = my);\n          }\n      }\n  }\n  params.s = {\n    who, poly, px, py, maps: {}, heads: [null, null], dir: 45, started: false, prev: false,\n    k: [0, 2, 45, 0.06], rgb: new Float32Array(NP * 3), tb: new Float32Array(NP), c: new Float32Array(24), clock: 0,\n  };\n}\n\n// The cylinders of surface s in direction d: every LED inside it gets the\n// rank of its closed line's length, shortest first, so each cylinder is one\n// number.\nfunction cylinders(S, s, d) {\n  const key = s + \":\" + d;\n  if (S.maps[key]) return S.maps[key];\n  const E = SURF[s].E, ux = cos((d * PI) / 180), uy = sin((d * PI) / 180);\n  const len = new Float64Array(NP).fill(-1), lens = [];\n  for (let o = 0; o \u003c NP; o++) {\n    if (S.who[o] !== s) continue;\n    const c = period(E, S.poly[o], S.px[o], S.py[o], ux, uy);\n    len[o] = c;\n    if (c > 0 && !lens.some((v) => abs(v - c) \u003c 1e-6)) lens.push(c);\n  }\n  lens.sort((a, b) => a - b);\n  const rank = new Int8Array(NP).fill(-1);\n  for (let o = 0; o \u003c NP; o++) if (len[o] > 0) rank[o] = lens.findIndex((v) => abs(v - len[o]) \u003c 1e-6);\n  return (S.maps[key] = { rank, lens });\n}\n\n// The first lines start at fixed points, two in each cylinder of the\n// octagon at 45 degrees; a tap of K1 draws new ones at random.\nconst FIRST = [\n  [[0, 0.15, 0.1], [0, -0.75, 0.55], [0, 0.55, -0.85], [0, 0.95, 0.35]],\n  [[0, 0.05, 0.6], [0, -0.3, 1.0], [1, 0.2, -0.5], [1, -0.35, -1.0]],\n];\nfunction launch(s) {\n  const E = SURF[s].E;\n  for (;;) {\n    const p = floor(random() * E.length), x = (random() - 0.5) * 3.2, y = (random() - 0.5) * 3.2;\n    if (inside(E, p, x, y)) return { p, x, y, skip: -1 };\n  }\n}\n// Move a point a distance L along (ux, uy), through the glued sides.\nfunction flow(E, h, L, ux, uy) {\n  for (let k = 0; k \u003c 400 && L > 0; k++) {\n    const r = exit(E, h.p, h.x, h.y, ux, uy, h.skip);\n    if (!r) return;\n    const t = r[0], i = r[1];\n    if (t > L) {\n      h.x += L * ux;\n      h.y += L * uy;\n      h.skip = -1;\n      return;\n    }\n    const e = E[h.p][i];\n    h.x += t * ux + e.tx;\n    h.y += t * uy + e.ty;\n    h.p = e.to;\n    h.skip = e.j;\n    L -= t;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 45, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.k[0] = k[0];\n  S.k[1] = cl(k[1], 0.2, 3);\n  S.k[2] = cl(k[2], 45, 135);\n  S.k[3] = cl(k[3], 0, 1);\n  const press = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started || (press && !S.prev)) {\n    S.heads = S.started\n      ? [0, 1].map((s) => Array.from({ length: RAYS }, () => launch(s)))\n      : FIRST.map((f) => f.map(([p, x, y]) => ({ p, x, y, skip: -1 })));\n    S.started = true;\n  }\n  S.prev = press;\n  // Snap to the nearest direction in which either surface is periodic.\n  let dir = S.k[2];\n  for (const sf of SURF) for (const p of sf.dirs) if (abs(dir - p) \u003c= SNAP) dir = p;\n  S.dir = dir;\n  const ux = cos((dir * PI) / 180), uy = sin((dir * PI) / 180);\n  for (let s = 0; s \u003c 2; s++) for (const hd of S.heads[s]) flow(SURF[s].E, hd, VEL * S.k[1] * d, ux, uy);\n  S.clock += d;\n}\n\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction splatT(S, x, y, v) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy, T = S.tb;\n  if (ix \u003c 0 || iy \u003c 0 || ix >= W - 1 || iy >= H - 1) return;\n  const p = iy * W + ix;\n  T[p] += (1 - fx) * (1 - fy) * v;\n  T[p + 1] += fx * (1 - fy) * v;\n  T[p + W] += (1 - fx) * fy * v;\n  T[p + W + 1] += fx * fy * v;\n}\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  S.rgb[p] += v * c[o];\n  S.rgb[p + 1] += v * c[o + 1];\n  S.rgb[p + 2] += v * c[o + 2];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c, who } = S, h = S.k[0], dir = S.dir;\n  rgb.fill(0);\n  S.tb.fill(0);\n  // Colours: 0 and 3 the two cylinders, 6 a surface in a direction that\n  // fills it, 9 the sides, 12 the line, 15 its head.\n  hsv(wheel(0.48 + h), 0.85, 0.42, c, 0);\n  hsv(wheel(0.7 + h), 0.7, 0.42, c, 3);\n  hsv(wheel(0.6 + h), 0.35, 0.11, c, 6);\n  hsv(wheel(0.6 + h), 0.25, 0.42, c, 9);\n  hsv(wheel(0.62 + h), 0.15, 1, c, 12);\n  c[15] = c[16] = c[17] = 1;\n\n  for (let s = 0; s \u003c 2; s++) {\n    const sf = SURF[s], periodic = sf.dirs.includes(dir), m = periodic ? cylinders(S, s, dir) : null;\n    for (let o = 0; o \u003c NP; o++) {\n      if (who[o] !== s) continue;\n      const r = m ? m.rank[o] : -1, q = r === 0 ? 0 : r === 1 ? 3 : 6, p = o * 3;\n      rgb[p] = c[q];\n      rgb[p + 1] = c[q + 1];\n      rgb[p + 2] = c[q + 2];\n    }\n    // The sides, the double pentagon's inner side dotted.\n    for (let pi = 0; pi \u003c sf.E.length; pi++)\n      for (let i = 0; i \u003c sf.E[pi].length; i++) {\n        const e = sf.E[pi][i], inner = s === 1 && i === 0;\n        if (inner && pi === 1) continue;\n        const x0 = sf.cx + SC * e.ax, y0 = sf.cy - SC * e.ay, n = ceil(SC * 3);\n        for (let j = 0; j \u003c= n; j++) {\n          if (inner && j % 6 > 2) continue;\n          splat(S, x0 + (SC * e.ex * j) / n, y0 - (SC * e.ey * j) / n, inner ? 0.18 : 0.36, c, 9);\n        }\n      }\n    // The lines: back from each head as far as it came in the last Trail\n    // seconds, each part as bright as it is recent, so where a line closes\n    // on itself it adds up.\n    const Ltr = VEL * S.k[1] * (4 + 56 * S.k[3] ** 1.3), E = sf.E, wpass = 0.7 * min(1, sqrt(10 / Ltr));\n    const ux = cos((dir * PI) / 180), uy = sin((dir * PI) / 180);\n    for (const hd of S.heads[s]) {\n      const b = { p: hd.p, x: hd.x, y: hd.y, skip: -1 };\n      let done = 0;\n      for (let kk = 0; kk \u003c 600 && done \u003c Ltr; kk++) {\n        const r = exit(E, b.p, b.x, b.y, -ux, -uy, b.skip);\n        if (!r) break;\n        const t = min(r[0], Ltr - done), i = r[1];\n        const n = max(1, ceil(t * SC * 3));\n        for (let j = 0; j \u003c= n; j++) {\n          const u = (t * j) / n, w = 1 - (done + u) / Ltr;\n          const ww = (t * SC) / n;\n          splatT(S, sf.cx + SC * (b.x - u * ux), sf.cy - SC * (b.y - u * uy), wpass * w * ww);\n          if (done + u \u003c COMET) splat(S, sf.cx + SC * (b.x - u * ux), sf.cy - SC * (b.y - u * uy), 0.7 * (1 - (done + u) / COMET) * ww, c, 15);\n        }\n        done += t;\n        if (t \u003c r[0]) break;\n        if (r[2] \u003c 1e-9 || r[2] > 1 - 1e-9) break;\n        const e = E[b.p][i];\n        b.x -= t * ux - e.tx;\n        b.y -= t * uy - e.ty;\n        b.p = e.to;\n        b.skip = e.j;\n      }\n      splat(S, sf.cx + SC * hd.x, sf.cy - SC * hd.y, 1.2, c, 15);\n    }\n  }\n  // The lines over the surfaces, through 1 - e^(-x), so a line that closes\n  // and runs over itself many times stays below the white of the heads.\n  for (let o = 0, p = 0; o \u003c NP; o++, p += 3) {\n    const v = S.tb[o];\n    if (v \u003c= 0) continue;\n    const g = 0.86 * (1 - Math.exp(-1.6 * v));\n    rgb[p] += g * c[12];\n    rgb[p + 1] += g * c[13];\n    rgb[p + 2] += g * c[14];\n  }\n\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, round(min(1, rgb[p]) * 255), round(min(1, rgb[p + 1]) * 255), round(min(1, rgb[p + 2]) * 255));\n}\n","void-and-cluster":"// ===== Patternflow pattern =====\n// Title:   Void and Cluster\n// Family:  noise\n// Idea:    Clumpy white noise rearranges itself into blue noise as Ulichney's void-and-cluster method moves the dot at the tightest cluster into the largest void, again and again, until the move would put it back; then the settled dots are ranked one by one into a dither array and a threshold falls and rises through the ranks, so the dots leave and return in rank order, coloured by rank.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: blue noise (Robert Ulichney, 1988), the void-and-cluster method for dither arrays (Robert Ulichney, 1993), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Density=-1..1, Sigma=1.5..4\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the settling dots are azure, the crowded ones pink and pale, a dot a swap has just put down flashes white, and the ranked dots run from a pale azure at rank 0 through violet to pink at the top of the cycle; at 0.5 the dots are orange-red and the ranks run through yellow to green. The voids glow lavender to violet whatever the knob, as a dim warm glow reads brown.\n// Knob 2: Speed. At 2 the white noise stands still for 0.5 s, the swaps start at 36 a second and reach 243 a second, 0.16 of the 1516 dots, 0.8 s later, and the pattern settles after 431 to 464 swaps at 2.6 s; the threshold then falls to 0.45 of the settled count, rises to 1.45 and comes back in 6.3 s, and fresh white noise falls at 8.9 s. At 0.2 everything is ten times slower, settling at 26 s; at 3 it settles at 1.8 s.\n// Knob 3: Density. The share of LEDs lit in the settled pattern, 0.185 x 1.7^K: 891 dots at -1, 1516 at the opening 0, 2576 at 1, where the top of the cycle stops at 0.45 of the panel. A new value scatters fresh white noise.\n// Knob 4: Sigma. The width in LEDs of the Gaussian that measures clusters and voids. It opens at Ulichney's 1.5, where every threshold of the dither array keeps 7 to 9 percent of white noise's power below half the principal frequency sqrt(g); at 2.5 the settled dots keep 37 percent and at 4 83 percent, as the filter grows too wide to see the dots' own spacing: the swaps stop after 187 instead of 448 and the small clumps stay. A new value scatters fresh white noise.\n// Buttons: K1 tap scatters fresh white noise.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, exp, ceil, min, max, round, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The rank cycle after the dots settle, in seconds at Speed 2: hold, fall to\n// LO of the settled count, rise to HI, fall back, hold.\nconst HOLD0 = 0.4, FALL = 1.4, RISE = 2.8, BACK = 1.2, HOLD1 = 0.5;\nconst LO = 0.45, HI = 1.45;\n// Swaps a second at Speed 2, as a share of the dots.\nconst RATE = 0.16;\nconst STILL = 0.5, RAMP = 0.8, FLASH = 0.45, GHOST = 0.35;\n\nexport function setup(params) {\n  params.s = {\n    B: new Uint8Array(N), E: new Float64Array(N), ones: new Int32Array(N), at: new Int32Array(N), n: 0,\n    B2: new Uint8Array(N), E2: new Float64Array(N),\n    rank: new Int32Array(N), top: 0, np: 0,\n    flash: new Float32Array(N), ghost: new Float32Array(N),\n    K: null, R: 0, KW: 0, Ks: 0, sigma: 0, rho: 0,\n    mode: 0, t: 0, budget: 0, swaps: 0, thr: 0, dir: 0,\n    hue: 0, c: [0, 0, 0], fresh: true,\n  };\n}\n\nfunction kernel(S, sigma) {\n  S.sigma = sigma;\n  S.R = min(15, ceil(3 * sigma));\n  S.KW = 2 * S.R + 1;\n  S.K = new Float64Array(S.KW * S.KW);\n  S.Ks = 0;\n  for (let dy = -S.R; dy \u003c= S.R; dy++)\n    for (let dx = -S.R; dx \u003c= S.R; dx++) {\n      const v = exp(-(dx * dx + dy * dy) / (2 * sigma * sigma));\n      S.K[(dy + S.R) * S.KW + dx + S.R] = v;\n      S.Ks += v;\n    }\n}\n\n// Add (s = 1) or take away (s = -1) one dot's Gaussian from the energy E,\n// on the torus 64 x 128 the panel wraps into.\nfunction splat(S, E, p, s) {\n  const x = p & 63, y = p >> 6, R = S.R, KW = S.KW, K = S.K;\n  for (let dy = -R; dy \u003c= R; dy++) {\n    const row = (((y + dy) % H) + H) % H * W, k = (dy + R) * KW + R;\n    for (let dx = -R; dx \u003c= R; dx++) E[row + ((x + dx) & 63)] += s * K[k + dx];\n  }\n}\n\nfunction addOne(S, p) {\n  S.B[p] = 1;\n  S.at[p] = S.n;\n  S.ones[S.n++] = p;\n  splat(S, S.E, p, 1);\n}\nfunction removeOne(S, p) {\n  S.B[p] = 0;\n  const i = S.at[p], last = S.ones[--S.n];\n  S.ones[i] = last;\n  S.at[last] = i;\n  splat(S, S.E, p, -1);\n}\n\n// White noise: exactly rho N dots, every LED as likely as every other.\nfunction scatter(S) {\n  S.B.fill(0);\n  S.E.fill(0);\n  S.n = 0;\n  const want = round(S.rho * N);\n  const idx = new Int32Array(N);\n  for (let i = 0; i \u003c N; i++) idx[i] = i;\n  for (let i = 0; i \u003c want; i++) {\n    const j = i + floor(random() * (N - i)), t = idx[i];\n    idx[i] = idx[j];\n    idx[j] = t;\n    addOne(S, idx[i]);\n  }\n  S.rank.fill(-1);\n  S.flash.fill(0);\n  S.ghost.fill(0);\n  S.mode = 0;\n  S.t = 0;\n  S.budget = 0;\n  S.swaps = 0;\n}\n\nconst tightest = (S) => {\n  let c = -1, m = -1;\n  for (let i = 0; i \u003c S.n; i++) {\n    const p = S.ones[i];\n    if (S.E[p] > m) {\n      m = S.E[p];\n      c = p;\n    }\n  }\n  return c;\n};\nconst largestVoid = (B, E) => {\n  let v = -1, m = 1e30;\n  for (let p = 0; p \u003c N; p++)\n    if (!B[p] && E[p] \u003c m) {\n      m = E[p];\n      v = p;\n    }\n  return v;\n};\n\n// One swap of the initial pattern. Returns false once the dot taken from\n// the tightest cluster would go straight back into the largest void.\nfunction swap(S) {\n  const c = tightest(S);\n  removeOne(S, c);\n  const v = largestVoid(S.B, S.E);\n  if (v === c) {\n    addOne(S, c);\n    return false;\n  }\n  addOne(S, v);\n  S.flash[v] = 1;\n  S.ghost[c] = 1;\n  S.swaps++;\n  return true;\n}\n\n// The settled pattern is the prototype. Phase 1 takes its dots away, tightest\n// cluster first, ranking them from np - 1 down to 0; phase 2 starts again\n// from the prototype and fills the largest void, ranking from np up.\nfunction rankPrototype(S) {\n  S.np = S.n;\n  S.B2.set(S.B);\n  S.E2.set(S.E);\n  for (let r = S.n - 1; r >= 0; r--) {\n    const c = tightest(S);\n    S.rank[c] = r;\n    removeOne(S, c);\n  }\n  S.top = S.np;\n}\nfunction rankUpTo(S, n) {\n  while (S.top \u003c n) {\n    const v = largestVoid(S.B2, S.E2);\n    S.rank[v] = S.top++;\n    S.B2[v] = 1;\n    splat(S, S.E2, v, 1);\n  }\n}\n\nconst ease = (u) => u * u * (3 - 2 * u);\nfunction threshold(S, t) {\n  const np = S.np;\n  if (t \u003c HOLD0) return np;\n  t -= HOLD0;\n  if (t \u003c FALL) return np + (LO - 1) * np * ease(t / FALL);\n  t -= FALL;\n  if (t \u003c RISE) return LO * np + (HI - LO) * np * ease(t / RISE);\n  t -= RISE;\n  if (t \u003c BACK) return HI * np + (1 - HI) * np * ease(t / BACK);\n  return np;\n}\nconst CYCLE = HOLD0 + FALL + RISE + BACK + HOLD1;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  const speed = cl(k[1], 0.2, 3), tau = (d * speed) / 2;\n  const rho = 0.185 * Math.pow(1.7, cl(k[2], -1, 1)), sigma = cl(k[3], 1.5, 4);\n  const press = input.btnPressed && input.btnPressed[0];\n  if (S.fresh || press || Math.abs(rho - S.rho) > 0.004 || Math.abs(sigma - S.sigma) > 0.05) {\n    S.fresh = false;\n    S.rho = rho;\n    kernel(S, sigma);\n    scatter(S);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    if (S.flash[p] > 0) S.flash[p] = max(0, S.flash[p] - tau / FLASH);\n    if (S.ghost[p] > 0) S.ghost[p] = max(0, S.ghost[p] - tau / GHOST);\n  }\n  S.t += tau;\n  if (S.mode === 0) {\n    // The white noise stands still for STILL, then the swaps start slowly,\n    // one at a time to the eye, and reach RATE in RAMP more.\n    if (S.t > STILL) S.budget += tau * RATE * S.n * min(1, 0.15 + (S.t - STILL) / RAMP);\n    while (S.budget >= 1) {\n      S.budget -= 1;\n      if (!swap(S)) {\n        rankPrototype(S);\n        S.mode = 1;\n        S.t = 0;\n        break;\n      }\n    }\n  } else {\n    if (S.t >= CYCLE) {\n      scatter(S);\n      return;\n    }\n    const thr = min(0.45 * N, threshold(S, S.t));\n    S.dir = thr > S.thr + 1e-9 ? 1 : thr \u003c S.thr - 1e-9 ? -1 : 0;\n    S.thr = thr;\n    rankUpTo(S, ceil(S.thr) + 1);\n  }\n}\n\n// A dot of the pattern being settled: the azure of the opening hue, going\n// pink and pale the more crowded it is against white noise of the same\n// density, and white for an instant where a swap has just put it.\nfunction dotColour(S, E, p, h0, out) {\n  const z = (E[p] - 1) / (S.rho * (S.Ks - 1)), w = cl((z - 1.05) / 0.8, 0, 1), f = S.flash[p];\n  hsv(h0 + 0.43 * w, (0.8 - 0.4 * w) * (1 - f), 1, out);\n}\n// A ranked dot: from the opening azure at rank 0 down the wheel through\n// green to yellow at the top of the cycle.\nfunction rankColour(S, r, h0, sat, out) {\n  const u = r / (HI * S.np);\n  hsv(h0 + 0.38 * u, (0.25 + 0.6 * u) * sat, 1, out);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.c, c2 = [0, 0, 0], h0 = S.hue + 0.55;\n  const put = (p, r, g, b) => display.setPixel(p & 63, p >> 6, round(r * 255), round(g * 255), round(b * 255));\n  if (S.mode === 0) {\n    const mean = S.rho * S.Ks, vh = 0.74 + 0.12 * (S.hue - floor(S.hue));\n    for (let p = 0; p \u003c N; p++) {\n      if (S.B[p]) dotColour(S, S.E, p, h0, c);\n      else if (S.ghost[p] > 0) hsv(h0 + 0.43, 0.5, 0.6 * S.ghost[p], c);\n      else {\n        // The voids glow where the energy falls below half its mean, in a\n        // cool hue whatever the knob, since a dim warm one reads brown.\n        const g = cl(1 - S.E[p] / (0.5 * mean), 0, 1);\n        hsv(vh, 0.4, 0.5 * g, c);\n      }\n      put(p, c[0], c[1], c[2]);\n    }\n    return;\n  }\n  const thr = S.thr, mix = cl(S.t / HOLD0, 0, 1);\n  for (let p = 0; p \u003c N; p++) {\n    const r = S.rank[p];\n    if (r \u003c 0 || r >= thr + 1) {\n      display.setPixel(p & 63, p >> 6, 0, 0, 0);\n      continue;\n    }\n    // The dots within 2% of the ranks below the threshold are arriving, white\n    // as they come, or leaving, fading as they go.\n    const a = cl((thr - r) / (0.02 * S.np), 0, 1);\n    rankColour(S, r, h0, S.dir > 0 ? a : 1, c);\n    if (mix \u003c 1 && r \u003c S.np) {\n      dotColour(S, S.E2, p, h0, c2);\n      for (let i = 0; i \u003c 3; i++) c[i] = c2[i] + (c[i] - c2[i]) * mix;\n    }\n    const v = S.dir \u003c 0 ? 0.25 + 0.75 * a : 1;\n    put(p, c[0] * v, c[1] * v, c[2] * v);\n  }\n}\n","yard-sale":"// ===== Patternflow pattern =====\n// Title:   Yard-Sale Model\n// Family:  data\n// Idea:    Sixty-four agents start with equal wealth and trade in random pairs, a fair coin deciding who takes a fraction of the poorer one's wealth, and the Lorenz curve on top sags from its diagonal, the sorted fortunes below fall away to one tall bar, and the Gini coefficient climbs toward 1 along the bottom, unless a tax pulls everyone back toward the mean.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lorenz curve (Max Lorenz, 1905), Gini coefficient (Corrado Gini, 1912), yard-sale model of asset exchange (Anirban Chakraborti, 2002; named by Brian Hayes, 2002), wealth condensation and redistribution (Bruce Boghosian and coauthors, 2014 and 2017), pattern round 62\n// Round:   62\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fraction=0.2..0.6, Tax=0..1\n//\n// Knob 1: Hue. Turns the picture round the wheel. At 0 the gap between the diagonal and the Lorenz curve is azure, the bars rise from violet through blue to azure at the starting level and pale toward the top, and the curve, the trace and the one followed agent are cream; at 0.25 the gap is violet, at 0.5 red, at 0.75 green. Orange and dark yellow are skipped, as they read brown.\n// Knob 2: Speed. The clock a run is played on. A run is 1600 rounds of 32 trades, one trade per agent a round on average, on a log clock: the rounds done plus 40 grow e-fold every 5.4 s at Speed 2, so rounds 0 to 40, 40 to 120, 120 to 280 and so on each take 3.7 s, and the run reaches 1600 at 20 s. The trace across the bottom is drawn against the same log clock. At 0.2 ten times slower, at 3 one and a half times faster. The first run opens 14 rounds in, already off the diagonal; every later one starts equal.\n// Knob 3: Fraction. The share f of the poorer agent's wealth a trade moves. Over 16 economies at a time with no tax, the Gini coefficient averaged 0.54 at 50 rounds, 0.66 at 100, 0.77 at 200, 0.86 at 400, 0.92 at 800 and 0.95 at 1600 for f = 0.2; for f = 0.4 it was 0.77 at 50 rounds and 0.92 at 200, for f = 0.6 0.88 at 50. A run stops when the economy on the panel reaches 0.95 or 1600 rounds, holds 2.5 s and starts again equal: every 22 s at f = 0.2 (23 of 54 runs went the whole 1600 rounds), every 15 s at 0.4, every 11 s at 0.6.\n// Knob 4: Tax. Up to 0.1 there is none; above it every agent pays chi = 0.08 ((K4 - 0.1) / 0.9)^2 of its wealth a round into a pot shared equally, Boghosian's redistribution, and the Gini settles: at f = 0.2 on 0.69 at K4 = 0.25 (chi = 0.0022), 0.41 at 0.5 (0.0158), 0.28 at 0.75 (0.042) and 0.21 at 1 (0.08). In the Fokker-Planck limit it depends on chi / f^2 only; at chi / f^2 = 0.395 the steady Gini was 0.407, 0.403 and 0.396 for f = 0.2, 0.3 and 0.4.\n// Buttons: K1 tap restarts the economy with everyone equal.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, log, round, random, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without orange and dark yellow, 0.03 to 0.17, which read brown.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\n\n// N agents, W0 units each, so the total is N W0 = 64000 whole units and no\n// trade or tax can make or lose one.\nconst N = 64, W0 = 1000, TOTAL = N * W0;\n// The economy on the panel and 15 more run side by side from the same\n// start; the band their Gini coefficients span is drawn behind its own.\nconst E = 16;\n// A round is N / 2 trades, one for each agent on average. A run is 1600\n// rounds on a clock that runs in log time, r = R0 (e^(t / TAU) - 1), so\n// rounds 0 to 40, 40 to 120, 120 to 280 and so on each take the same time:\n// TAU = 5.4 s at Speed 2 and the whole run 20 s.\nconst R0 = 40, RUN = 1600, LRUN = log(1 + RUN / R0), TAU = 5.4;\nconst LZ = 63, BAR0 = 101, BARH = 34, TR0 = 127, TRH = 23;\nconst GSTOP = 0.95, HOLD = 2.5, BLOG = 20;\n\nexport function setup(params) {\n  params.s = {\n    w: new Int32Array(N * E), sorted: new Int32Array(N), ids: new Int32Array(N), L: new Float32Array(N + 1),\n    trace: new Float32Array(W).fill(-1), lo: new Float32Array(W).fill(-1), hi: new Float32Array(W).fill(-1),\n    rgb: new Float32Array(NP * 3), c: new Float32Array(12),\n    old: new Float32Array(NP * 3), rounds: 0, clock: 0, gini: 0, hold: 0, fade: 0, started: false,\n    k: [0, 2, 0.2, 0.06], prev: false,\n  };\n}\n\nfunction restart(S) {\n  S.w.fill(W0);\n  S.trace.fill(-1);\n  S.lo.fill(-1);\n  S.hi.fill(-1);\n  S.trace[0] = S.lo[0] = S.hi[0] = 0;\n  S.rounds = S.clock = S.gini = S.hold = 0;\n  S.old.set(S.rgb);\n  S.fade = 1;\n}\n\n// One round of economy e: N / 2 trades, then the tax. In a trade two agents\n// are drawn, a fair coin picks the winner, and the winner takes f times the\n// poorer agent's wealth, rounded at random to a whole unit so the mean is\n// exact. The tax takes chi of every agent's wealth, rounded the same way,\n// and shares the pot out equally; the units it cannot share go one each to\n// agents drawn at random.\nfunction round1(w, o, f, chi) {\n  for (let t = 0; t \u003c N / 2; t++) {\n    const i = o + floor(random() * N);\n    let j = o + floor(random() * (N - 1));\n    if (j >= i) j++;\n    const d = floor(f * min(w[i], w[j]) + random());\n    if (random() \u003c 0.5) (w[i] += d), (w[j] -= d);\n    else (w[i] -= d), (w[j] += d);\n  }\n  if (chi > 0) {\n    let pot = 0;\n    for (let i = o; i \u003c o + N; i++) {\n      const p = floor(chi * w[i] + random());\n      w[i] -= p;\n      pot += p;\n    }\n    const each = floor(pot / N);\n    for (let i = o; i \u003c o + N; i++) w[i] += each;\n    for (let r = pot - each * N; r > 0; r--) w[o + floor(random() * N)]++;\n  }\n}\n\n// Sort economy e by wealth and read its Gini coefficient off the Lorenz\n// curve: G = 1 - 2 * (area under it), the area by trapezoids, exact in\n// whole units.\nfunction sortAndGini(S, e) {\n  const { w, ids, sorted } = S, o = e * N;\n  for (let i = 0; i \u003c N; i++) ids[i] = i;\n  ids.sort((a, b) => w[o + a] - w[o + b] || a - b);\n  let cum = 0, area = 0;\n  for (let k = 0; k \u003c N; k++) {\n    const v = w[o + ids[k]];\n    sorted[k] = v;\n    area += 2 * cum + v;\n    cum += v;\n  }\n  return 1 - area / (N * TOTAL);\n}\n// The column of the trace a round falls in.\nconst colOf = (r) => min(W - 1, round(((W - 1) * log(1 + r / R0)) / LRUN));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.k[0] = k[0];\n  S.k[1] = cl(k[1], 0.2, 3);\n  S.k[2] = cl(k[2], 0.2, 0.6);\n  S.k[3] = cl(k[3], 0, 1);\n  const f = S.k[2], t4 = max(0, (S.k[3] - 0.1) / 0.9), chi = 0.08 * t4 * t4;\n  const press = !!(input.btnPressed && input.btnPressed[0]);\n  if (!S.started || (press && !S.prev)) {\n    restart(S);\n    // The first run opens 0.3 TAU into its clock, 14 rounds in, so the\n    // curve has already left the diagonal; every later run starts equal.\n    if (!S.started) (S.clock = 0.3 * TAU), (S.fade = 0);\n    S.started = true;\n  }\n  S.prev = press;\n  S.fade = max(0, S.fade - d / 0.6);\n  if (S.hold > 0) {\n    S.hold += d;\n    if (S.hold > HOLD) restart(S);\n  } else {\n    S.clock += (d * S.k[1]) / 2;\n    const target = min(RUN, floor(R0 * (Math.exp(S.clock / TAU) - 1)));\n    while (S.rounds \u003c target) {\n      for (let e = 0; e \u003c E; e++) round1(S.w, e * N, f, chi);\n      S.rounds++;\n      const col = colOf(S.rounds);\n      if (col !== colOf(S.rounds + 1) || S.rounds === target) {\n        const g = sortAndGini(S, 0);\n        let lo = g, hi = g;\n        for (let e = 1; e \u003c E; e++) {\n          const ge = sortAndGini(S, e);\n          lo = min(lo, ge);\n          hi = max(hi, ge);\n        }\n        S.trace[col] = g;\n        S.lo[col] = lo;\n        S.hi[col] = hi;\n      }\n    }\n    if (S.rounds >= RUN) S.hold = 1e-6;\n  }\n  S.gini = sortAndGini(S, 0);\n  if (S.hold === 0 && S.gini >= GSTOP) S.hold = 1e-6;\n}\n\nfunction add(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  rgb[o] += r;\n  rgb[o + 1] += g;\n  rgb[o + 2] += b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c, sorted, L } = S, h = S.k[0];\n  sortAndGini(S, 0);\n  rgb.fill(0);\n  // Colours: 0 the gap between the diagonal and the curve, 3 the share\n  // under the curve, 6 the curve and the trace.\n  hsv(wheel(0.48 + h), 0.75, 0.52, c, 0);\n  hsv(wheel(0.68 + h), 0.6, 0.1, c, 3);\n  hsv(0.12 + h, 0.15, 1, c, 6);\n\n  // The Lorenz square, rows 0 to 63: share of agents across, share of\n  // wealth up. L(k) is the wealth of the poorest k agents over the total.\n  L[0] = 0;\n  for (let kk = 0; kk \u003c N; kk++) L[kk + 1] = L[kk] + sorted[kk] / TOTAL;\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5) / W, p = u * N, i = min(N - 1, floor(p)), lv = L[i] + (L[i + 1] - L[i]) * (p - i);\n    const yd = LZ - u * LZ, yl = LZ - lv * LZ;\n    for (let y = 0; y \u003c= LZ; y++) {\n      if (y \u003c yd - 0.5) continue;\n      if (y \u003c yl - 0.5) add(rgb, x, y, c[0] * 255, c[1] * 255, c[2] * 255);\n      else add(rgb, x, y, c[3] * 255, c[4] * 255, c[5] * 255);\n    }\n  }\n  for (let x = 0; x \u003c W; x++) add(rgb, x, round(LZ - ((x + 0.5) / W) * LZ), 40, 40, 40);\n  // A dot every tenth of the agents and every tenth of the wealth.\n  for (let i = 1; i \u003c 10; i++)\n    for (let j = 1; j \u003c 10; j++) add(rgb, round((i * W) / 10 - 0.5), round(LZ - (j * LZ) / 10), 34, 34, 38);\n  // The curve as an unbroken line: in each column, every row between its\n  // heights at the column's two edges.\n  for (let x = 0; x \u003c W; x++) {\n    const ya = LZ - L[x] * LZ, yb = LZ - L[x + 1] * LZ;\n    for (let y = round(yb); y \u003c= round(ya); y++) add(rgb, x, y, c[6] * 230, c[7] * 230, c[8] * 230);\n  }\n\n  // The sorted fortunes, rows 67 to 101, poorest at the left, on a log\n  // scale, log(1 + w / 20) over log(1 + all / 20), each LED coloured by its\n  // height: violet low, the hue of the gap at the starting level, paler\n  // above it. Agent 0 is drawn cream, so one fortune can be followed as it\n  // changes rank.\n  const top = log(1 + TOTAL / BLOG), y0 = (BARH * log(1 + W0 / BLOG)) / top;\n  for (let kk = 0; kk \u003c N; kk++) {\n    const hgt = (BARH * log(1 + sorted[kk] / BLOG)) / top;\n    for (let y = 0; y \u003c hgt; y++) {\n      const a = min(1, hgt - y);\n      if (y \u003c y0) hsv(wheel(0.72 + h - (0.24 * y) / y0), 0.8, 0.45 + (0.35 * y) / y0, c, 0);\n      else hsv(wheel(0.48 + h), 0.8 * (1 - (y - y0) / (BARH - y0)) + 0.1, 0.8 + (0.2 * (y - y0)) / (BARH - y0), c, 0);\n      if (S.ids[kk] === 0) add(rgb, kk, BAR0 - y, c[6] * 230 * a, c[7] * 230 * a, c[8] * 230 * a);\n      else add(rgb, kk, BAR0 - y, c[0] * 255 * a, c[1] * 255 * a, c[2] * 255 * a);\n    }\n  }\n  for (let x = 0; x \u003c W; x += 2) add(rgb, x, round(BAR0 - y0), 50, 50, 50);\n\n  // The Gini trace, rows 104 to 127, against rounds on a log scale: G = 0 at\n  // the bottom and 1 at the top, the highest a 64-agent economy can reach,\n  // 1 - 1/64, dotted. Behind the panel's own economy, bright, the band from\n  // the lowest to the highest of the sixteen.\n  for (let x = 0; x \u003c W; x += 2) add(rgb, x, round(TR0 - (1 - 1 / N) * TRH), 50, 50, 50);\n  hsv(wheel(0.48 + h), 0.75, 0.42, c, 0);\n  hsv(wheel(0.48 + h), 0.75, 0.16, c, 3);\n  for (let x = 0; x \u003c W; x++) {\n    const g = S.trace[x];\n    if (g \u003c 0) continue;\n    const yt = round(TR0 - g * TRH), ylo = round(TR0 - S.lo[x] * TRH), yhi = round(TR0 - S.hi[x] * TRH);\n    for (let y = yhi; y \u003c= TR0; y++) {\n      const o = y \u003c= ylo ? 0 : 3;\n      add(rgb, x, y, c[o] * 255, c[o + 1] * 255, c[o + 2] * 255);\n    }\n    add(rgb, x, yt, c[6] * 255, c[7] * 255, c[8] * 255);\n  }\n\n  const fd = S.fade, old = S.old;\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      let r = min(255, rgb[p]), g = min(255, rgb[p + 1]), b = min(255, rgb[p + 2]);\n      if (fd > 0) (r = r * (1 - fd) + old[p] * fd), (g = g * (1 - fd) + old[p + 1] * fd), (b = b * (1 - fd) + old[p + 2] * fd);\n      (rgb[p] = r), (rgb[p + 1] = g), (rgb[p + 2] = b);\n      display.setPixel(x, y, r, g, b);\n    }\n}\n","art-gallery":"// ===== Patternflow pattern =====\n// Title:   Art Gallery\n// Family:  geometry\n// Idea:    A tall random gallery is drawn corner by corner, cut into triangles by clipping its ears one at a time, its corners given three colours so that every triangle has one of each, and then guards step out on the corners of the rarest colour and their light spreads over every LED they can see until the whole gallery is lit, which is Steve Fisk's proof that n/3 guards always suffice.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: art gallery problem (Victor Klee, 1973), art gallery theorem and the comb that needs every guard (Václav Chvátal, 1975), two ears theorem (Gary Meisters, 1975), three-colouring proof (Steve Fisk, 1978), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Corners=12..30, Depth=0.6..0.95\n//\n// Knob 1: Hue. Turns the three corner colours round together, on a wheel that skips orange and yellow. At 0 they are green, azure and pink; at 0.17 cyan, violet and red; at 0.5 violet, red and cyan. The guards' light is a pale version of whichever colour is rarest.\n// Knob 2: Speed. At 2 the outline takes 1 s, the ears 2.2 s, the colours 2 s and the guards 0.8 s; the light takes 2.4 s and 0.6 s more for every guard after the first; then the gallery stays lit for 2.4 s and fades in 0.8 s. That is 13.4 s for a gallery with 4 guards and 17 s for one with 10. At 0.2 it is ten times as long, at 3 two thirds as long.\n// Knob 3: Corners. n, 12 to 30. At 12 the gallery has 10 triangles, 9 diagonals and at most 4 guards; at 21 it has 19, 18 and 7; at 30 it has 28, 27 and 10. A new value starts a new gallery once the knob has rested for 0.35 s.\n// Knob 4: Depth. How far the inner corners cut in from the edge toward the spine down the middle, 0.7 to 1 times this. At 0.6 they reach 42 to 60% of the way and one guard sees 90% of a 12-corner gallery on average, 68% of a 30-corner one; at 0.95 they reach 67 to 95%, and one guard sees 74% and 41%. Every third gallery is Chvátal's comb, n/3 teeth whose tips no point sees two of, so it needs all n/3 guards and the colouring gives it that many; Depth narrows its teeth from 68% to 54% of their spacing.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, PI, exp, acos } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, x) => {\n  const t = cl((x - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The acts of one gallery, in seconds at Speed 2, and when each one ends.\n// The light act lasts as long as its guards need: they switch on 0.6 s\n// apart and each front runs out at 60 LEDs a second.\nconst T_OUT = 1, T_EAR = 2.2, T_COL = 2, T_GRD = 0.8, T_HOLD = 2.4, T_FADE = 0.8, GAP = 0.6, FRONT = 60;\nconst A1 = T_OUT, A2 = A1 + T_EAR, A3 = A2 + T_COL, A4 = A3 + T_GRD;\n// Rows of visibility worked out per frame. A gallery of 30 corners with\n// 10 guards costs up to 2 ms a frame this way for the first 32 frames,\n// and the light needs it 6 seconds in.\nconst VIS_ROWS = 4;\n\n// Hues on a wheel that skips orange through yellow, which read brown and\n// olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\nconst cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// A star around a vertical spine from row 32 to row 96. Each corner sits on\n// the ray from the spine to an even step round the edge of the panel, and\n// the rays never cross, so the polygon is simple whatever the radii. An\n// outer corner lies near the edge, an inner one depth x (0.7..1) of the way\n// in toward the spine.\nfunction star(n, depth) {\n  const X0 = 1.2, X1 = 62.8, Y0 = 1.2, Y1 = 126.8, CX = 32, S0 = 32, S1 = 96;\n  const a = X1 - X0, b = Y1 - Y0, per = 2 * (a + b);\n  const off = Math.random() * per, P = [];\n  let run = 1;\n  for (let i = 0; i \u003c n; i++) {\n    let s = (off + ((i + 0.5 + (Math.random() - 0.5) * 0.5) * per) / n) % per, qx, qy;\n    if (s \u003c a) (qx = X0 + s), (qy = Y0);\n    else if ((s -= a) \u003c b) (qx = X1), (qy = Y0 + s);\n    else if ((s -= b) \u003c a) (qx = X1 - s), (qy = Y1);\n    else (qx = X0), (qy = Y1 - (s - a));\n    // An inner corner never follows an inner one and always follows two\n    // outer ones; after one outer corner it comes with chance 0.6.\n    const inner = run > 0 && i \u003c n - 1 && (run > 1 || Math.random() \u003c 0.6);\n    run = inner ? 0 : run + 1;\n    const oy = cl(qy, S0, S1), r = inner ? 1 - depth * (0.7 + 0.3 * Math.random()) : 0.92 + 0.08 * Math.random();\n    P.push([CX + (qx - CX) * r, oy + (qy - oy) * r]);\n  }\n  return P;\n}\n\n// Chvátal's comb: a bar down one side and k = n / 3 teeth across the panel,\n// each tooth a triangle whose tip only a point inside that tooth's own cone\n// can see. A tooth w wide at its base and 48 long, in front of a bar 12\n// deep, has a cone 1.25 w wide at the back wall, so teeth narrower than 0.8\n// of their spacing keep the cones apart. Corners: two at the back, k tips\n// and two at every valley, 3k in all, and any left over go on the back wall.\nfunction comb(n, depth) {\n  const k = floor(n / 3), extra = n - 3 * k, yT = 1.5, yB = 126.5, xb = 2.2, xs = 14, xt = 62.3;\n  const s = (yB - yT) / k, w = s * (0.92 - 0.4 * depth), P = [[xb, yT]];\n  for (let e = 1; e \u003c= extra; e++) P.push([xb - 1.2, yT + ((yB - yT) * e) / (extra + 1)]);\n  P.push([xb, yB]);\n  for (let j = 0; j \u003c k; j++) {\n    const yc = yB - (j + 0.5) * s;\n    P.push([xt, yc]);\n    if (j \u003c k - 1) P.push([xs, yc - w / 2], [xs, yc - s + w / 2]);\n  }\n  const fx = Math.random() \u003c 0.5, fy = Math.random() \u003c 0.5;\n  return P.map(([x, y]) => [fx ? W - x : x, fy ? H - y : y]);\n}\n\nfunction segDist(p, a, b) {\n  const dx = b[0] - a[0], dy = b[1] - a[1], t = cl(((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / (dx * dx + dy * dy), 0, 1);\n  return Math.hypot(p[0] - a[0] - t * dx, p[1] - a[1] - t * dy);\n}\n\n// Every corner at least 2 LEDs from every edge that does not end at it, so\n// no part of the gallery is thinner than the panel can show.\nfunction roomy(P) {\n  const n = P.length;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) {\n      if (j === i || (j + 1) % n === i) continue;\n      if (segDist(P[i], P[j], P[(j + 1) % n]) \u003c 2) return false;\n    }\n  return true;\n}\n\nfunction angleAt(a, b, c) {\n  const ux = a[0] - b[0], uy = a[1] - b[1], vx = c[0] - b[0], vy = c[1] - b[1];\n  return acos(cl((ux * vx + uy * vy) / (Math.hypot(ux, uy) * Math.hypot(vx, vy) + 1e-9), -1, 1));\n}\n\n// Ear clipping. Meisters: a polygon with more than three corners has two\n// ears, corners whose triangle with their neighbours lies inside it, so\n// clipping one always leaves a smaller polygon to clip. Of the ears on\n// offer this takes the one with the widest smallest angle, which keeps the\n// triangles fat enough to read on 64 columns.\nfunction triangulate(P, sgn) {\n  const idx = P.map((_, i) => i), tris = [];\n  while (idx.length > 3) {\n    let best = 0, bq = -1;\n    const m = idx.length;\n    for (let t = 0; t \u003c m; t++) {\n      const a = idx[(t + m - 1) % m], b = idx[t], c = idx[(t + 1) % m];\n      if (cross(P[a], P[b], P[c]) * sgn \u003c= 1e-9) continue;\n      let ok = true;\n      for (const v of idx) {\n        if (v === a || v === b || v === c) continue;\n        const p = P[v];\n        if (cross(P[a], P[b], p) * sgn >= -1e-9 && cross(P[b], P[c], p) * sgn >= -1e-9 && cross(P[c], P[a], p) * sgn >= -1e-9) {\n          ok = false;\n          break;\n        }\n      }\n      if (!ok) continue;\n      const q = min(angleAt(P[c], P[a], P[b]), angleAt(P[a], P[b], P[c]), angleAt(P[b], P[c], P[a]));\n      if (q > bq) (bq = q), (best = t);\n    }\n    tris.push([idx[(best + m - 1) % m], idx[best], idx[(best + 1) % m]]);\n    idx.splice(best, 1);\n  }\n  tris.push([idx[0], idx[1], idx[2]]);\n  return tris;\n}\n\nfunction newGallery(S) {\n  const n = S.nWant, depth = S.dWant, isComb = S.count % 3 === 2;\n  let P = null;\n  for (let tries = 0; tries \u003c 40 && !P; tries++) {\n    const Q = isComb ? comb(n, depth) : star(n, depth * (1 - tries * 0.012));\n    if (isComb || roomy(Q)) P = Q;\n  }\n  let area = 0;\n  for (let i = 0; i \u003c n; i++) area += cross([0, 0], P[i], P[(i + 1) % n]);\n  const sgn = area > 0 ? 1 : -1, tris = triangulate(P, sgn), T = tris.length;\n  // Fisk: walk the dual tree from the triangle nearest the middle. Its three\n  // corners take the three colours; every triangle after it shares a\n  // diagonal, so two corners already have colours and the third takes the\n  // colour left over.\n  let start = 0, bd = 1e9;\n  tris.forEach((t, i) => {\n    const d = Math.hypot((P[t[0]][0] + P[t[1]][0] + P[t[2]][0]) / 3 - 32, (P[t[0]][1] + P[t[1]][1] + P[t[2]][1]) / 3 - 64);\n    if (d \u003c bd) (bd = d), (start = i);\n  });\n  const col = new Int8Array(n).fill(-1), step = new Int16Array(n), done = new Int16Array(T), seen = new Uint8Array(T), queue = [start];\n  let k = 0;\n  seen[start] = 1;\n  while (queue.length) {\n    const ti = queue.shift(), t = tris[ti];\n    if (ti === start) for (let c = 0; c \u003c 3; c++) (col[t[c]] = c), (step[t[c]] = k++);\n    else\n      for (const v of t)\n        if (col[v] \u003c 0) {\n          let used = 0;\n          for (const u of t) if (col[u] >= 0) used += col[u];\n          col[v] = 3 - used;\n          step[v] = k++;\n        }\n    done[ti] = max(step[t[0]], step[t[1]], step[t[2]]);\n    for (let j = 0; j \u003c T; j++) {\n      if (seen[j]) continue;\n      let shared = 0;\n      for (const v of tris[j]) if (v === t[0] || v === t[1] || v === t[2]) shared++;\n      if (shared === 2) (seen[j] = 1), queue.push(j);\n    }\n  }\n  const cnt = [0, 0, 0];\n  for (let i = 0; i \u003c n; i++) cnt[col[i]]++;\n  let rare = 0;\n  for (let c = 1; c \u003c 3; c++) if (cnt[c] \u003c cnt[rare]) rare = c;\n  const guards = [];\n  for (let i = 0; i \u003c n; i++) if (col[i] === rare) guards.push(i);\n  // Which triangle holds each LED centre, and where in it.\n  const tri = S.tri.fill(-1), bary = S.bary, vis = S.vis.fill(0);\n  tris.forEach((t, ti) => {\n    const a = P[t[0]], b = P[t[1]], c = P[t[2]], d = cross(a, b, c);\n    const x0 = max(0, floor(min(a[0], b[0], c[0]))), x1 = min(W - 1, ceil(max(a[0], b[0], c[0])));\n    const y0 = max(0, floor(min(a[1], b[1], c[1]))), y1 = min(H - 1, ceil(max(a[1], b[1], c[1])));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const p = [x + 0.5, y + 0.5], l0 = cross(b, c, p) / d, l1 = cross(c, a, p) / d, l2 = 1 - l0 - l1, o = y * W + x;\n        if (l0 \u003c -1e-6 || l1 \u003c -1e-6 || l2 \u003c -1e-6 || tri[o] >= 0) continue;\n        tri[o] = ti;\n        // How much of each corner's colour this LED takes: e^(9 l) for\n        // barycentric l, so each corner's colour holds the third of the\n        // triangle nearest it and they blend where the thirds meet.\n        const e0 = exp(9 * l0), e1 = exp(9 * l1), e2 = exp(9 * l2), es = e0 + e1 + e2;\n        bary[o * 3] = e0 / es;\n        bary[o * 3 + 1] = e1 / es;\n        bary[o * 3 + 2] = e2 / es;\n      }\n  });\n  let nIn = 0;\n  for (let o = 0; o \u003c W * H; o++) if (tri[o] >= 0) S.ins[nIn++] = o;\n  S.nIn = nIn;\n  const A5 = A4 + (guards.length - 1) * GAP + 2.4;\n  Object.assign(S, { P, n, tris, col, step, done, guards, sgn, t: 0, visRow: 0, isComb, dirty: -1, nNow: n, dNow: depth, A5, A6: A5 + T_HOLD, A7: A5 + T_HOLD + T_FADE });\n  S.count++;\n}\n\n// A guard at corner G sees the LED centre p when p is in the gallery and\n// the segment from G to p crosses no edge. On its own this test left 3 of\n// 2.5 million LEDs dark over 630 galleries, centres lying on a line\n// through a corner, which the triangle below takes care of. Edges ending at G cannot cross\n// it; if the segment leaves through G's own corner it has to come back in\n// across some other edge, so those are the only ones to test.\nfunction visRows(S, rows) {\n  const { P, n, guards, tri, vis } = S;\n  for (let r = 0; r \u003c rows && S.visRow \u003c H; r++, S.visRow++) {\n    const y = S.visRow + 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const o = S.visRow * W + x;\n      if (tri[o] \u003c 0) continue;\n      const px = x + 0.5, own = S.tris[tri[o]];\n      for (let g = 0; g \u003c guards.length; g++) {\n        // Fisk: every triangle has one corner of each colour, so one guard\n        // stands on a corner of the triangle this LED is in, and a triangle\n        // is convex, so that guard sees it without a test.\n        if (own.indexOf(guards[g]) >= 0) vis[o] |= 1 \u003c\u003c g;\n        if (vis[o] & (1 \u003c\u003c g)) continue;\n        const gi = guards[g], G = P[gi];\n        let clear = true;\n        for (let j = 0; j \u003c n && clear; j++) {\n          const j1 = (j + 1) % n;\n          if (j === gi || j1 === gi) continue;\n          const A = P[j], B = P[j1];\n          const d1 = (B[0] - A[0]) * (G[1] - A[1]) - (B[1] - A[1]) * (G[0] - A[0]);\n          const d2 = (B[0] - A[0]) * (y - A[1]) - (B[1] - A[1]) * (px - A[0]);\n          if (d1 * d2 >= 0) continue;\n          const d3 = (px - G[0]) * (A[1] - G[1]) - (y - G[1]) * (A[0] - G[0]);\n          const d4 = (px - G[0]) * (B[1] - G[1]) - (y - G[1]) * (B[0] - G[0]);\n          if (d3 * d4 \u003c 0) clear = false;\n        }\n        if (clear) vis[o] |= 1 \u003c\u003c g;\n      }\n    }\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    count: 0, nWant: 12, dWant: 0.6, tri: new Int16Array(W * H), bary: new Float32Array(W * H * 3), vis: new Uint16Array(W * H), ins: new Int32Array(W * H), nIn: 0, gx: new Float32Array(16), gy: new Float32Array(16), gr: new Float32Array(16), dc: [0, 0, 0], ec: [0, 0, 0],\n    buf: new Float32Array(W * H * 3), lifts: new Float32Array(32), tc: new Float32Array(32 * 9), hue: 0, C: [[0, 0, 0], [0, 0, 0], [0, 0, 0]], L: [0, 0, 0], c: [0, 0, 0], P: null,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 12, 0.6], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.nWant = round(cl(kv[2], 12, 30));\n  S.dWant = cl(kv[3], 0.6, 0.95);\n  if (!S.P) newGallery(S);\n  // A turned knob starts a new gallery once it has rested for 0.35 s.\n  if (S.nWant !== S.nNow || abs(S.dWant - S.dNow) > 0.02) {\n    if (S.dirty \u003c 0) S.dirty = 0;\n    if ((S.dirty += d) > 0.35) S.count--, newGallery(S);\n  } else S.dirty = -1;\n  S.t += (d * cl(kv[1], 0.2, 3)) / 2;\n  if (S.visRow \u003c H) visRows(S, VIS_ROWS);\n  if (S.t >= S.A7) newGallery(S);\n}\n\nfunction round(v) {\n  return floor(v + 0.5);\n}\n\n// Xiaolin Wu's line, mixed over what is there, so a grey diagonal is a\n// bright seam on the dark gallery and a dark one on the lit gallery.\nfunction line(B, x0, y0, x1, y1, c, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  let t;\n  if (steep) (t = x0), (x0 = y0), (y0 = t), (t = x1), (x1 = y1), (y1 = t);\n  if (x0 > x1) (t = x0), (x0 = x1), (x1 = t), (t = y0), (y0 = y1), (y1 = t);\n  const k = (y1 - y0) / (x1 - x0 || 1e-9);\n  for (let u = ceil(x0 - 0.5); u \u003c= floor(x1 - 0.5); u++) {\n    const v = y0 + k * (u + 0.5 - x0) - 0.5, vi = floor(v), f = v - vi;\n    plot(B, steep ? vi : u, steep ? u : vi, c, a * (1 - f));\n    plot(B, steep ? vi + 1 : u, steep ? u : vi + 1, c, a * f);\n  }\n}\n\nfunction plot(B, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  a = min(1, a);\n  B[o] += (c[0] - B[o]) * a;\n  B[o + 1] += (c[1] - B[o + 1]) * a;\n  B[o + 2] += (c[2] - B[o + 2]) * a;\n}\n\nfunction dot(B, x, y, r, c, a) {\n  for (let yy = floor(y - r); yy \u003c= y + r; yy++)\n    for (let xx = floor(x - r); xx \u003c= x + r; xx++) {\n      const q = Math.hypot(xx + 0.5 - x, yy + 0.5 - y) / r;\n      if (q \u003c 1) plot(B, xx, yy, c, a * min(1, 1.6 * (1 - q)));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const { P, n, tris, col, step, done, guards, tri, bary, vis, buf: B, C, L } = S, t = S.t, nt = tris.length;\n  const earAt = (k) => A1 + (T_EAR * (k + 0.5)) / nt, colAt = (s) => A2 + (T_COL * (s + 0.5)) / n;\n  for (let c = 0; c \u003c 3; c++) hsv(wheel(0.1 + S.hue + c / 3), 1, 1, C[c]);\n  const rare = col[guards[0]], G = C[rare];\n  for (let c = 0; c \u003c 3; c++) L[c] = 0.35 * G[c] + 0.65;\n  const fade = 1 - ss(S.A6, S.A7, t), base = hsv(wheel(0.46 + S.hue), 0.45, 0.12 * ss(0.3, A1, t), S.c);\n  // The light: guard k's front is FRONT x (t - A4 - k GAP) LEDs out.\n  const gx = S.gx, gy = S.gy, gr = S.gr;\n  for (let k = 0; k \u003c guards.length; k++) (gx[k] = P[guards[k]][0]), (gy[k] = P[guards[k]][1]), (gr[k] = FRONT * (t - A4 - k * GAP));\n  // Per triangle: the ear flashes as it is clipped and stays a shade\n  // lighter after; once its three corners have colours it takes a soft\n  // tint from them, each corner's colour strongest near that corner.\n  const lifts = S.lifts, tc = S.tc;\n  for (let i = 0; i \u003c nt; i++) {\n    const ea = t - earAt(i), ta = 0.3 * ss(colAt(done[i]), colAt(done[i]) + 0.4, t);\n    lifts[i] = ea > 0 ? 1.7 + 2.5 * exp(-ea / 0.3) : 1;\n    for (let k = 0; k \u003c 9; k++) tc[i * 9 + k] = C[col[tris[i][(k / 3) | 0]]][k % 3] * ta;\n  }\n  // What no guard sees yet sinks into shadow.\n  const sh = 1 - 0.4 * ss(A4, A4 + 1, t), ng = guards.length, lightOn = t > A4;\n  B.fill(0);\n  for (let j = 0; j \u003c S.nIn; j++) {\n      const o = S.ins[j], x = o % W, y = (o / W) | 0, ti = tri[o];\n      const lift = lifts[ti], w0 = bary[o * 3], w1 = bary[o * 3 + 1], w2 = bary[o * 3 + 2], q = ti * 9;\n      let r = base[0] * lift + w0 * tc[q] + w1 * tc[q + 3] + w2 * tc[q + 6];\n      let g = base[1] * lift + w0 * tc[q + 1] + w1 * tc[q + 4] + w2 * tc[q + 7];\n      let b = base[2] * lift + w0 * tc[q + 2] + w1 * tc[q + 5] + w2 * tc[q + 8];\n      if (lightOn) {\n        let lit = 0, rim = 0;\n        const m = vis[o];\n        for (let k = 0; k \u003c ng; k++) {\n          if (!(m & (1 \u003c\u003c k)) || gr[k] \u003c= 0) continue;\n          const ddx = x + 0.5 - gx[k], ddy = y + 0.5 - gy[k], d2 = ddx * ddx + ddy * ddy, R = gr[k];\n          if (R > 8 && d2 \u003c (R - 8) * (R - 8)) {\n            lit++;\n            continue;\n          }\n          const e = R - sqrt(d2);\n          if (e > -3) (lit += cl(e / 4, 0, 1)), (rim += exp(-e * e / 8));\n        }\n        if (lit > 0 || rim > 0) {\n          // A lit LED shows its colours at 1.2 times their strength where\n          // one guard sees it, 1.5 where two do and up to 1.8 where many\n          // do, with a little of the guards' light.\n          const l = 1 - Math.pow(0.5, lit), gain = 0.6 + 1.2 * l, v = 0.32 * l + 0.3 * min(1, rim);\n          (r = r * gain + L[0] * v), (g = g * gain + L[1] * v), (b = b * gain + L[2] * v);\n        } else (r *= sh), (g *= sh), (b *= sh);\n      }\n      B[o * 3] = r;\n      B[o * 3 + 1] = g;\n      B[o * 3 + 2] = b;\n    }\n  // Diagonals, each drawn from one end to the other as its ear goes.\n  const dc = hsv(wheel(0.37 + S.hue), 0.15, 0.62, S.dc);\n  for (let k = 0; k \u003c nt - 1; k++) {\n    const u = cl((t - earAt(k) + 0.06) / 0.2, 0, 1);\n    if (u \u003c= 0) continue;\n    const a = P[tris[k][0]], c = P[tris[k][2]];\n    line(B, a[0], a[1], a[0] + (c[0] - a[0]) * u, a[1] + (c[1] - a[1]) * u, dc, 1);\n  }\n  // The outline, drawn round from corner 0 during the first act.\n  const ec = hsv(wheel(0.37 + S.hue), 0.3, 1, S.ec), drawn = (t / T_OUT) * n;\n  for (let i = 0; i \u003c n; i++) {\n    const u = cl(drawn - i, 0, 1);\n    if (u \u003c= 0) break;\n    const a = P[i], b = P[(i + 1) % n];\n    line(B, a[0], a[1], a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, ec, 1);\n  }\n  // Corners: white until coloured, then their colour; the guards' corners\n  // grow a ring once the colouring is done and the others step back.\n  const white = [1, 1, 1];\n  const gOn = ss(A3, A3 + 0.5, t), pulse = 0.75 + 0.25 * Math.sin(t * 6);\n  for (let i = 0; i \u003c n; i++) {\n    if (drawn \u003c i) break;\n    const cs = ss(colAt(step[i]) - 0.05, colAt(step[i]) + 0.15, t), isG = col[i] === rare;\n    const cc = cs > 0 ? C[col[i]] : white, back = isG ? 1 : 1 - 0.5 * gOn;\n    dot(B, P[i][0], P[i][1], 1.3 + 0.6 * cs, cc, back);\n    if (isG && gOn > 0) {\n      const rr = 2.4 + 1.6 * gOn;\n      for (let k = 0; k \u003c 28; k++) {\n        const an = (k / 28) * 2 * PI;\n        plot(B, floor(P[i][0] + rr * Math.cos(an)), floor(P[i][1] + rr * Math.sin(an)), G, gOn * pulse);\n      }\n      dot(B, P[i][0], P[i][1], 1.2, white, gOn);\n    }\n  }\n  const f255 = fade * 255;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, B[o] * f255) | 0, min(255, B[o + 1] * f255) | 0, min(255, B[o + 2] * f255) | 0);\n}\n","binary-lens":"// ===== Patternflow pattern =====\n// Title:   Binary Lens\n// Family:  space\n// Idea:    Two point masses on a tilted circular orbit lens the sky behind them, and the panel is their magnification map in the source plane by inverse ray shooting, dim blue with contours of equal magnification and bright caustic folds that meet in cusps and change, as the pair swings from upright to lying across, from two astroids to one six-cusp loop to a small central caustic with two triangles, while a star drifts over the map and its light curve scrolls along the bottom with a spike at every fold it crosses.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: gravitational lensing by two point masses (Peter Schneider and Alfred Weiss, 1986), inverse ray shooting (Joachim Wambsganss, Peter Schneider and Bohdan Paczynski, 1986), the three caustic topologies of the binary lens (Hans Erdl and Peter Schneider, 1993), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mass ratio=0.2..1, Orbit=15..60\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the map is deep blue where nothing is magnified, violet inside the caustics and nearly white on the folds, with teal contours and a green star and light curve; at 0.25 the map is magenta with green folds, at 0.5 green, at 0.75 teal with blue folds. The wheel runs from green to magenta and skips red, orange and lime, which read maroon, brown and olive when dim.\n// Knob 2: Speed. 2 is real time: the star crosses the map at 1.2 Einstein radii, 34 LEDs, a second, the light curve holds the last 6.4 s, and at the bottom of Orbit the pair goes round in 24 s; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Mass ratio. q = m2 / m1 from 0.2 to 1, the masses adding to 1. At 0.2 the masses are 0.83 and 0.17 and the caustics are lopsided: the loop is a bent triangle, the lighter mass has the smaller astroid in the wide pair, and the topology changes at separations 0.74 and 1.82. At 1 the pair is equal, the caustics are symmetric and the changes come at 0.71 and 2, as Erdl and Schneider found.\n// Knob 4: Orbit. How fast the pair goes round its circle, 15 to 60 degrees a second: once in 24 s at 15, once in 6 s at 60. The circle has radius 2.3 and is tilted 76 degrees, so the separation on the sky runs from 2.3 with the pair upright, two astroids one above the other, to 0.54 lying across, a small central caustic with two triangles above and below; with equal masses the pair spends 34% of its turn wide, 53% in the six-cusp loop and 13% close, swinging fast through the close part. At 15 the opening shows the loop, the close pair at about 2 s and the wide pair from 6 s.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The map: rows 0 to 99, 28 LEDs to the Einstein radius of the total mass,\n// centred on the centre of mass. The light curve fills rows 102 to 127.\nconst MH = 100, PX = 28, MX = 32, MY = 50, CY0 = 102, CH = 26;\n// Rays: an image-plane grid 2 to the LED each way, so a patch with no\n// lensing gets 4 rays per LED. Each ray is split over the four LEDs round\n// where it lands. With a whole number of rays to the LED that split sums\n// to the same on every LED, so the grid leaves no moire where the lensing\n// is weak: a first try that dropped each ray into one cell of a grid twice\n// as fine, at 2.3 rays to the LED, drew dark arcs 5 LEDs apart all over\n// the dim parts. The grid spreads past the map by a margin that holds the\n// images of its edge: a source 1.1 Einstein radii out has its bright image\n// 0.6 further out, and a mass 1.9 out holds images 0.4 beyond itself.\nconst SUB = 2, HX = 1.8, HY = 2.35, STEP = 1 / (PX * SUB);\nconst NX = Math.ceil((2 * HX) / STEP), NY = Math.ceil((2 * HY) / STEP);\n// The counts carry a border one LED wide, so the edge LEDs get their whole\n// share.\nconst PW = W + 2, PH = MH + 2;\n// The orbit: a circle of radius A Einstein radii seen tilted, cos i = CI,\n// with its long axis along the panel's long axis. The projected\n// separation runs from A = 2.3 when the pair stands upright (two astroids\n// one above the other) to A CI = 0.54 when it lies across (the two small\n// triangles then sit above and below the central caustic). Both fit the\n// tall map, 1.8 from the centre to its top: the wide pair's astroids reach\n// 1.7 at q = 0.2 and the close pair's triangles 1.5 at q = 1.\nconst A = 2.3, CI = 0.235;\n// The light curve: one column every 0.1 s, log magnification from 1 to 16.\nconst COL_DT = 0.1, MU_TOP = 16;\n// Contours of the map, a factor 1.12 apart.\nconst CSTEP = log(1.12);\n// The star crosses the map at 1.2 Einstein radii a second. Its\n// magnification is the rays landing on a soft disk 2 LEDs in radius.\nconst VSRC = 1.2, RSRC = 2 / PX;\n// The star's trail on the map: its last 10 places, 1 s.\nconst TRAIL = 10;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel from green through blue and violet to\n// magenta, which skips red, orange and lime: dim, they read maroon, brown\n// and olive.\nconst wheel = (h) => 0.3 + 0.56 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    t: 0, ready: false, drawn: false, phi: 0, q: 0.2, om: 15, hue: 0, half: 0,\n    // Two half-grids of ray counts, one shot each frame, and the star's\n    // count from each.\n    cnt: [new Float32Array(PW * PH), new Float32Array(PW * PH)], star: [1, 1],\n    mu: new Float32Array(W * MH), lm: new Float32Array(W * MH), tmp: new Float32Array(W * MH), c3: [0, 0, 0],\n    lut: new Float32Array(256 * 3),\n    curve: new Float32Array(W), colSum: 0, colN: 0, colT: 0, tx: new Float32Array(TRAIL), ty: new Float32Array(TRAIL),\n    sx: 0, sy: 0, vx: 0, vy: 0,\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// A new crossing: in at a random point of the map's edge, aimed at a\n// point within 0.7 Einstein radii of the centre.\nfunction newTrack(S) {\n  const ex = MX / PX, ey = MY / PX, side = floor(Math.random() * 4);\n  let x, y;\n  if (side \u003c 2) {\n    x = (Math.random() * 2 - 1) * ex;\n    y = side ? ey : -ey;\n  } else {\n    y = (Math.random() * 2 - 1) * ey;\n    x = side === 2 ? ex : -ex;\n  }\n  const ax = (Math.random() * 2 - 1) * 0.7, ay = (Math.random() * 2 - 1) * 0.7;\n  const dx = ax - x, dy = ay - y, l = sqrt(dx * dx + dy * dy);\n  S.sx = x;\n  S.sy = y;\n  S.vx = (dx / l) * VSRC;\n  S.vy = (dy / l) * VSRC;\n}\n\n// The masses: the centre of mass at the origin, m1 + m2 = 1.\nfunction lenses(S) {\n  const m1 = 1 / (1 + S.q), m2 = S.q / (1 + S.q), dx = A * CI * sin(S.phi), dy = A * cos(S.phi);\n  return { m1, m2, x1: -dx * m2, y1: -dy * m2, x2: dx * m1, y2: dy * m1 };\n}\n\n// Shoot every stride-th row of the ray grid starting at row off, through\n// the lens equation zeta = z - sum m_i / conj(z - z_i), which in real\n// numbers is zeta = z - sum m_i (z - z_i) / |z - z_i|^2. Each ray is split\n// over four LEDs of cnt (if given) and adds a weight (1 - r^2 / R^2)^2 to\n// the star if it lands within R of it; the return value is the star's\n// magnification.\nfunction shoot(S, L, cnt, off, stride) {\n  const { m1, m2, x1, y1, x2, y2 } = L, sx = S.sx, sy = S.sy, r2 = RSRC * RSRC, ir2 = 1 / r2;\n  const ox = MX + 0.5, oy = MY + 0.5;\n  let star = 0;\n  for (let j = off; j \u003c NY; j += stride) {\n    const y = -HY + (j + 0.5) * STEP, dy1 = y - y1, dy2 = y - y2, e1 = dy1 * dy1, e2 = dy2 * dy2;\n    let x = -HX + 0.5 * STEP;\n    for (let i = 0; i \u003c NX; i++, x += STEP) {\n      const dx1 = x - x1, dx2 = x - x2;\n      const k1 = m1 / (dx1 * dx1 + e1), k2 = m2 / (dx2 * dx2 + e2);\n      const zx = x - k1 * dx1 - k2 * dx2, zy = y - k1 * dy1 - k2 * dy2;\n      const ux = zx - sx, uy = zy - sy, u2 = ux * ux + uy * uy;\n      if (u2 \u003c r2) {\n        const w = 1 - u2 * ir2;\n        star += w * w;\n      }\n      if (!cnt) continue;\n      const px = zx * PX + ox, py = zy * PX + oy;\n      // Written this way round so a ray that hits a mass dead on (NaN) is\n      // dropped too.\n      if (!(px >= 0 && py >= 0 && px \u003c PW - 1 && py \u003c PH - 1)) continue;\n      const ix = px | 0, iy = py | 0, fx = px - ix, fy = py - iy, o = iy * PW + ix, gx = 1 - fx;\n      cnt[o] += gx * (1 - fy);\n      cnt[o + 1] += fx * (1 - fy);\n      cnt[o + PW] += gx * fy;\n      cnt[o + PW + 1] += fx * fy;\n    }\n  }\n  // Rays per unit area of the image plane, for the rows shot, against the\n  // soft disk's area pi R^2 / 3.\n  return star / ((PI * r2) / 3 / (STEP * STEP * stride));\n}\n\n// A box 5 LEDs wide, across and then down, in place.\nfunction blur(a, t) {\n  for (let y = 0; y \u003c MH; y++) {\n    const r = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0, n = 0;\n      for (let k = max(0, x - 2); k \u003c= min(W - 1, x + 2); k++, n++) s += a[r + k];\n      t[r + x] = s / n;\n    }\n  }\n  for (let x = 0; x \u003c W; x++)\n    for (let y = 0; y \u003c MH; y++) {\n      let s = 0, n = 0;\n      for (let k = max(0, y - 2); k \u003c= min(MH - 1, y + 2); k++, n++) s += t[k * W + x];\n      a[y * W + x] = s / n;\n    }\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  // A circular orbit keeps an even pace in its own plane; seen tilted, the\n  // pair swings fast across the panel when close and slowly when upright.\n  S.phi += ((S.om * PI) / 180) * dt;\n  S.sx += S.vx * dt;\n  S.sy += S.vy * dt;\n  if (abs(S.sx) > MX / PX + 0.1 || abs(S.sy) > MY / PX + 0.1) newTrack(S);\n}\n\nfunction pushColumn(S, mu) {\n  S.curve.copyWithin(0, 1);\n  S.curve[W - 1] = mu;\n  S.tx.copyWithin(0, 1);\n  S.ty.copyWithin(0, 1);\n  S.tx[TRAIL - 1] = S.sx;\n  S.ty[TRAIL - 1] = S.sy;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.2, 15], dd = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.q = cl(kv[2], 0.2, 1);\n  S.om = cl(kv[3], 15, 60);\n  if (!S.ready) {\n    // The first frame runs the 6.4 s the light curve holds, with every\n    // fourth row of the grid and only the star's count.\n    S.ready = true;\n    S.t = -W * COL_DT;\n    // At t = 0 the orbit is 60 degrees on from upright, so the opening\n    // seconds go from the six-cusp loop to the close pair lying across, at\n    // 2 s with the Orbit knob at the bottom, and back out.\n    S.phi = ((60 - S.om * W * COL_DT) * PI) / 180;\n    newTrack(S);\n    for (let k = 0; k \u003c W; k++) {\n      step(S, COL_DT);\n      pushColumn(S, shoot(S, lenses(S), null, k % 4, 4));\n    }\n  }\n  const h = (dd * speed) / 2;\n  step(S, h);\n  S.colT += h;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const L = lenses(S), rgb = S.rgb, hue = S.hue;\n  // This frame's half of the grid; the other half is the last frame's.\n  for (let k = 0; k \u003c (S.drawn ? 1 : 2); k++) {\n    const f = S.cnt[S.half];\n    f.fill(0);\n    S.star[S.half] = shoot(S, L, f, S.half, 2);\n    S.half ^= 1;\n  }\n  S.drawn = true;\n  const muStar = (S.star[0] + S.star[1]) / 2;\n  S.colSum += muStar;\n  S.colN++;\n  while (S.colT >= COL_DT) {\n    pushColumn(S, S.colSum / S.colN);\n    S.colT -= COL_DT;\n    S.colSum = muStar;\n    S.colN = 1;\n  }\n  // Magnification: rays per LED over the rays per LED with no lens.\n  const c0 = S.cnt[0], c1 = S.cnt[1], mu = S.mu, norm = 1 / (SUB * SUB);\n  for (let y = 0; y \u003c MH; y++)\n    for (let x = 0, o = (y + 1) * PW + 1; x \u003c W; x++, o++) mu[y * W + x] = (c0[o] + c1[o]) * norm;\n  // Colours by log magnification: deep blue at 1, violet inside the\n  // caustics where there are five images and the magnification is 3 or\n  // more, nearly white on the folds.\n  const lut = S.lut;\n  for (let i = 0; i \u003c 256; i++) {\n    const l = i / 255;\n    hsv(wheel(0.56 + hue + 0.3 * l), 0.9 - 0.7 * l * l, 0.13 + 0.87 * l ** 0.8, lut, i * 3);\n  }\n  const kl = 255 / log(MU_TOP), lm = S.lm;\n  for (let p = 0; p \u003c W * MH; p++) {\n    const m = mu[p], i = m > 1 ? min(255, (log(m) * kl) | 0) : 0, o = p * 3, q = i * 3;\n    lm[p] = log(max(m, 0.05)) / CSTEP;\n    rgb[o] = lut[q];\n    rgb[o + 1] = lut[q + 1];\n    rgb[o + 2] = lut[q + 2];\n  }\n  // Contours of equal magnification outside the caustics, every 12%, so the\n  // dim part of the map shows its slope: wide loops round the pair far out,\n  // closing in and bending where the caustics pull them.\n  // The contours are read from the map smoothed twice by a box 5 LEDs\n  // wide: raw, the few rays to an LED make them speckle.\n  blur(lm, S.tmp);\n  blur(lm, S.tmp);\n  const cc = hsv(wheel(0.4 + hue), 0.6, 1, S.c3, 0), top = log(2.6) / CSTEP;\n  for (let y = 1; y \u003c MH - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, f = lm[p];\n      if (f > top || f \u003c 0.7) continue;\n      const gx = (lm[p + 1] - lm[p - 1]) / 2, gy = (lm[p + W] - lm[p - W]) / 2, g = sqrt(gx * gx + gy * gy);\n      if (g \u003c 1e-3) continue;\n      const e = abs(f - Math.round(f)) / g, v = 1 - e / 0.7;\n      if (v \u003c= 0) continue;\n      const k = v * 0.2 * min(1, (top - f) / 1.5), o = p * 3;\n      rgb[o] += cc[0] * k;\n      rgb[o + 1] += cc[1] * k;\n      rgb[o + 2] += cc[2] * k;\n    }\n  rgb.fill(0, W * MH * 3);\n  const add = (x, y, c, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || v \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += c[0] * v;\n    rgb[o + 1] += c[1] * v;\n    rgb[o + 2] += c[2] * v;\n  };\n  const dot = (cx, cy, rad, c, pk) => {\n    for (let y = floor(cy - rad); y \u003c= cy + rad; y++)\n      for (let x = floor(cx - rad); x \u003c= cx + rad; x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, q = (dx * dx + dy * dy) / (rad * rad);\n        if (q \u003c 1 && y \u003c MH) add(x, y, c, pk * (1 - q) * (1 - q));\n      }\n  };\n  // The two masses, small and grey, the heavier one larger.\n  const g = [0.7, 0.7, 0.7];\n  dot(L.x1 * PX + MX, L.y1 * PX + MY, 1.2 + 0.8 * L.m1, g, 0.45);\n  dot(L.x2 * PX + MX, L.y2 * PX + MY, 1.2 + 0.8 * L.m2, g, 0.45);\n  // The star and its trail.\n  const sc = hsv(wheel(0.18 + hue), 0.55, 1, S.c, 0);\n  for (let k = 1; k \u003c TRAIL; k++) {\n    const ax = S.tx[k - 1], ay = S.ty[k - 1], bx = k \u003c TRAIL - 1 ? S.tx[k] : S.sx, by = k \u003c TRAIL - 1 ? S.ty[k] : S.sy;\n    if ((bx - ax) ** 2 + (by - ay) ** 2 > 0.09) continue;\n    for (let s = 0; s \u003c 4; s++) {\n      const f = s / 4, x = (ax + (bx - ax) * f) * PX + MX, y = (ay + (by - ay) * f) * PX + MY;\n      dot(x, y, 1.2, sc, 0.22 * (k / TRAIL) ** 2);\n    }\n  }\n  dot(S.sx * PX + MX, S.sy * PX + MY, 2.4, sc, 1.6);\n  // The light curve: log magnification, a filled column per 0.1 s, the\n  // newest on the right.\n  const lt = log(MU_TOP);\n  for (let x = 0; x \u003c W; x++) {\n    const v = cl(log(max(1, S.curve[x])) / lt, 0, 1) * (CH - 1) + 1;\n    for (let r = 0; r \u003c CH; r++) {\n      const cover = cl(v - r, 0, 1);\n      if (cover \u003c= 0) break;\n      const top = v - r \u003c 1.5;\n      add(x, CY0 + CH - 1 - r, sc, cover * (top ? 0.95 : 0.16 + 0.22 * (r / CH)));\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const pk = max(1, rgb[o], rgb[o + 1], rgb[o + 2]), k = 255 / pk;\n    display.setPixel(p % W, (p / W) | 0, (rgb[o] * k) | 0, (rgb[o + 1] * k) | 0, (rgb[o + 2] * k) | 0);\n  }\n}\n","canard-explosion":"// ===== Patternflow pattern =====\n// Title:   Canard Explosion\n// Family:  rhythm\n// Idea:    The van der Pol oscillator walks through its family of limit cycles from a tiny Hopf cycle round the fold of the cubic, through ducks that ride the repelling middle branch further and further before jumping back, to ducks with a head and the full relaxation loop, each cycle left in the phase plane as a fading band so the family stands as nested loops, while x(t) runs down the lower panel and turns from small ripples into wide square spikes.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: relaxation oscillations (Balthasar van der Pol, 1926), the Lienard plane (Alfred-Marie Lienard, 1928), canard cycles and the canard explosion (Eric Benoit, Jean-Louis Callot, Francine Diener and Marc Diener, 1981), the explosion by geometric singular perturbation (Martin Krupa and Peter Szmolyan, 2001), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Epsilon=0.04..0.2, Pace=0.6..3\n//\n// Knob 1: Hue. Turns the family's colours round the wheel. At 0 the smallest cycles are teal, the ducks azure to violet and the relaxation loop magenta, over attracting branches drawn green and a dashed repelling branch drawn rose; at 0.5 the family runs from violet through red to lime and cyan. The wheel skips orange, which reads brown when dim.\n// Knob 2: Speed. At 2 the oscillator runs 2.5 units of its slow time a second: a Hopf cycle goes round in 0.5 s, the relaxation loop in 1.6 s and the longest duck in 2 s, and the trace below moves 15 rows a second. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Epsilon. The ratio of the fast time to the slow, 0.04 to 0.2, in eps x' = y - (x^3 / 3 - x), y' = a - x. At 0.04 the ducks are sharp: every cycle from the duck that turns back at x = 0 to the one whose head reaches x = -1.47 lies in an interval of a 1.8e-11 wide at a = 0.9948377923, the jumps are flat and the corners square. At 0.1 the same stretch of the family is 1.3e-4 wide and the loops round off; at 0.2 it is 0.023 wide, the ducks are fat and the relaxation loop reaches only x = -1.52. The family is found again by bisection a quarter second after the knob stops, 5 to 20 ms of work.\n// Knob 4: Pace. How fast the walk goes through the family of 18 cycles (17 at eps = 0.2), 0.6 to 3 cycles a second at Speed 2, out and back with a pause at each end. The parameter a changes only as the point crosses x = a going right, so each cycle is run whole. A ghost fades by e in 4 seconds. At 0.6 a duck runs one or two loops before the next takes over and five or six earlier cycles still show; at 3 the walk moves on several cycles each loop and goes from the Hopf cycle to the relaxation loop in 6 seconds.\n\nconst W = 64, H = 128, PH = 76, T0 = 79, TH = H - T0;\n// The phase plane: x from -XR to XR across, y from YT at the top to -YT.\n// Both are fitted to the family of each eps: the loops overshoot the folds\n// before they jump, up to y = 1.02 at eps = 0.04 and 1.57 at 0.2, so the\n// plane runs to 1.08 and 1.66. use(S) sets them from the state before any\n// drawing.\nlet XR = 2.2, YT = 1.1;\nconst use = (S) => {\n  XR = S.xr;\n  YT = S.yt;\n};\nconst PX = (x) => ((x + XR) * W) / (2 * XR), PY = (y) => ((YT - y) * PH) / (2 * YT);\nconst { floor, ceil, min, max, abs, exp, sqrt, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Slow time a second at Speed 2 is 2 x RATE; trace rows per unit of slow time.\nconst RATE = 1.25, TR = 6;\n// Every bisection starts here on the right attracting branch. From x = 1.95\n// the branch pulls the point onto the slow manifold by e^(-2.75 / eps)\n// before the fold, below rounding error at eps = 0.04, so the canard that\n// follows depends on a alone.\nconst X0 = 1.95;\nconst HOLD = 1.5, GHOST = 4;\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// One RK4 step of eps x' = y - (x^3/3 - x), y' = a - x. The live point and\n// the bisection use this same step at the same h, so the cycle the\n// bisection found is the cycle the point settles on.\nlet RX = 0, RY = 0;\nfunction rk4(x, y, a, ie, h) {\n  const k1x = (y - x * (x * x / 3 - 1)) * ie, k1y = a - x;\n  let xx = x + 0.5 * h * k1x, yy = y + 0.5 * h * k1y;\n  const k2x = (yy - xx * (xx * xx / 3 - 1)) * ie, k2y = a - xx;\n  xx = x + 0.5 * h * k2x;\n  yy = y + 0.5 * h * k2y;\n  const k3x = (yy - xx * (xx * xx / 3 - 1)) * ie, k3y = a - xx;\n  xx = x + h * k3x;\n  yy = y + h * k3y;\n  const k4x = (yy - xx * (xx * xx / 3 - 1)) * ie, k4y = a - xx;\n  RX = x + (h / 6) * (k1x + 2 * k2x + 2 * k3x + k4x);\n  RY = y + (h / 6) * (k1y + 2 * k2y + 2 * k3y + k4y);\n}\n\n// How far left the cycle reaches, from one pass: down the right branch,\n// round the fold, along the middle branch and off. x_min runs from near 1\n// for the smallest cycles through -1 at the maximal canard to about -1.9\n// for the relaxation loop, so it orders the whole family.\nfunction firstPass(a, ie, h) {\n  let x = X0, y = X0 * (X0 * X0 / 3 - 1), xmin = 9, below = false;\n  const M = ceil(14 / h);\n  for (let i = 0; i \u003c M; i++) {\n    rk4(x, y, a, ie, h);\n    const px = x;\n    x = RX;\n    y = RY;\n    if (x \u003c xmin) xmin = x;\n    if (x \u003c a) below = true;\n    else if (below && px \u003c a) return xmin;\n  }\n  return xmin;\n}\n\n// Run until the loops agree, then keep one loop, crossing to crossing of\n// x = a going right.\nfunction settle(a, ie, h, most) {\n  let x = X0, y = X0 * (X0 * X0 / 3 - 1), xmin = 9, prev = 9, below = false, loops = 0, rec = null, n = 0;\n  const M = ceil(400 / h);\n  for (let i = 0; i \u003c M; i++) {\n    rk4(x, y, a, ie, h);\n    const px = x;\n    x = RX;\n    y = RY;\n    if (rec) {\n      if (n \u003c rec.length / 2) {\n        rec[2 * n] = x;\n        rec[2 * n + 1] = y;\n        n++;\n      }\n    }\n    if (x \u003c xmin) xmin = x;\n    if (x \u003c a) below = true;\n    else if (below && px \u003c a) {\n      if (rec) return { a, pts: rec, n, xmin, period: n * h };\n      loops++;\n      if ((loops >= 2 && abs(xmin - prev) \u003c 3e-4) || loops >= most) rec = new Float32Array(2 * ceil(12 / h));\n      prev = xmin;\n      xmin = 9;\n      below = false;\n    }\n  }\n  return { a, pts: rec || new Float32Array(2), n, xmin: prev, period: n * h };\n}\n\n// Max-blend an antialiased segment into a PH-row raster.\nfunction seg(buf, x0, y0, x1, y1, v, rows) {\n  const n = max(1, ceil(max(abs(x1 - x0), abs(y1 - y0)) * 2));\n  for (let s = 0; s \u003c= n; s++) {\n    const f = s / n, x = x0 + (x1 - x0) * f - 0.5, y = y0 + (y1 - y0) * f - 0.5;\n    const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n    for (let k = 0; k \u003c 4; k++) {\n      const xx = xi + (k & 1), yy = yi + (k >> 1);\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= rows) continue;\n      const w = v * ((k & 1) ? fx : 1 - fx) * ((k >> 1) ? fy : 1 - fy) * 1.6;\n      const o = yy * W + xx;\n      if (w > buf[o]) buf[o] = min(1, w);\n    }\n  }\n}\n\nfunction rasterize(m) {\n  const stroke = new Float32Array(W * PH), inside = new Uint8Array(W * PH), xs = [];\n  for (let r = 0; r \u003c PH; r++) xs.push([]);\n  const P = m.pts, n = m.n;\n  for (let i = 0; i \u003c n; i++) {\n    const j = (i + 1) % n, x0 = PX(P[2 * i]), y0 = PY(P[2 * i + 1]), x1 = PX(P[2 * j]), y1 = PY(P[2 * j + 1]);\n    seg(stroke, x0, y0, x1, y1, 1, PH);\n    // Scanline crossings at row centres, for the even-odd fill.\n    const lo = min(y0, y1), hi = max(y0, y1);\n    for (let r = ceil(lo - 0.5); r + 0.5 \u003c hi; r++) {\n      if (r \u003c 0 || r >= PH) continue;\n      const yc = r + 0.5;\n      if (yc \u003c lo || yc >= hi) continue;\n      xs[r].push(x0 + ((x1 - x0) * (yc - y0)) / (y1 - y0));\n    }\n  }\n  for (let r = 0; r \u003c PH; r++) {\n    const c = xs[r].sort((p, q) => p - q);\n    for (let k = 0; k + 1 \u003c c.length; k += 2)\n      for (let x = max(0, ceil(c[k] - 0.5)); x \u003c W && x + 0.5 \u003c c[k + 1]; x++) inside[r * W + x] = 1;\n  }\n  m.stroke = stroke;\n  m.inside = inside;\n}\n\n// The family for one eps: three Hopf cycles at a = 1 - f dc, where dc =\n// eps / 8 + 3 eps^2 / 32 is the canard point to second order; fourteen\n// ducks found by bisection on x_min, nine headless and five with a head;\n// and the relaxation loop at a = 1 - 3 dc.\nfunction family(S, eps) {\n  const h = eps / 8, ie = 1 / eps, dc = eps / 8 + (3 * eps * eps) / 32;\n  const samples = [];\n  const meas = (a) => {\n    const v = firstPass(a, ie, h);\n    samples.push(a, v);\n    return v;\n  };\n  const aLo = 1 - 3 * dc, aHi = 1 - 0.5 * dc;\n  const xR = meas(aLo), xH = meas(aHi);\n  const as = [1 - 0.15 * dc, 1 - 0.4 * dc, 1 - 0.65 * dc];\n  const targets = [0.55, 0.38, 0.2, 0, -0.2, -0.4, -0.6, -0.78, -0.92];\n  for (let j = 1; j \u003c= 5; j++) targets.push(-1 + ((xR + 1) * j) / 5.6);\n  for (const T of targets) {\n    if (!(T \u003c xH && T > xR)) continue;\n    // The tightest bracket any earlier bisection left.\n    let lo = aLo, hi = aHi;\n    for (let i = 0; i \u003c samples.length; i += 2) {\n      const a = samples[i], v = samples[i + 1];\n      if (v \u003c T && a > lo) lo = a;\n      if (v >= T && a \u003c hi) hi = a;\n    }\n    for (let it = 0; it \u003c 64; it++) {\n      const mid = 0.5 * (lo + hi);\n      if (mid \u003c= lo || mid >= hi) break;\n      const v = meas(mid);\n      if (v \u003c T) lo = mid;\n      else hi = mid;\n      if (abs(v - T) \u003c 0.004) {\n        hi = mid;\n        break;\n      }\n    }\n    as.push(hi);\n  }\n  as.push(aLo);\n  const fam = [];\n  let ex = 0, ey = 0;\n  for (let i = 0; i \u003c as.length; i++) {\n    const m = settle(as[i], ie, h, i \u003c 3 ? 80 : 4);\n    if (m.n \u003c 8) continue;\n    m.hopf = i \u003c 3;\n    for (let j = 0; j \u003c 2 * m.n; j += 2) {\n      ex = max(ex, abs(m.pts[j]));\n      ey = max(ey, abs(m.pts[j + 1]));\n    }\n    fam.push(m);\n  }\n  S.xr = max(2.2, 1.03 * ex);\n  S.yt = 1.06 * ey;\n  use(S);\n  for (const m of fam) rasterize(m);\n  cubicRasters(S);\n  fam.sort((p, q) => q.xmin - p.xmin);\n  // Each pixel takes the smallest cycle round it, so nested cycles leave\n  // nested bands.\n  const band = new Int8Array(W * PH).fill(-1);\n  for (let k = fam.length - 1; k >= 0; k--) for (let p = 0; p \u003c W * PH; p++) if (fam[k].inside[p]) band[p] = k;\n  S.eps = eps;\n  S.h = h;\n  S.fam = fam;\n  S.band = band;\n  S.ghost = new Float32Array(fam.length);\n  S.kc = cl(S.kc, 0, fam.length - 1);\n  S.x = fam[S.kc].pts[0];\n  S.y = fam[S.kc].pts[1];\n}\n\nfunction cubicRasters(S) {\n  // The critical manifold y = x^3/3 - x: outer branches attract, the\n  // middle one repels.\n  const att = new Float32Array(W * PH), rep = new Float32Array(W * PH), side = new Uint8Array(W * PH);\n  const f = (x) => x * (x * x / 3 - 1);\n  for (let i = 0; i \u003c 400; i++) {\n    const x0 = -XR + (2 * XR * i) / 400, x1 = -XR + (2 * XR * (i + 1)) / 400;\n    const mid = abs(0.5 * (x0 + x1)) \u003c 1;\n    // The repelling branch is dashed.\n    if (mid && floor(i / 6) % 2) continue;\n    seg(mid ? rep : att, PX(x0), PY(f(x0)), PX(x1), PY(f(x1)), 1, PH);\n  }\n  for (let r = 0; r \u003c PH; r++)\n    for (let c = 0; c \u003c W; c++) {\n      const x = ((c + 0.5) * 2 * XR) / W - XR, y = YT - ((r + 0.5) * 2 * YT) / PH;\n      side[r * W + c] = y > f(x) ? 1 : 0;\n    }\n  S.att = att;\n  S.rep = rep;\n  S.side = side;\n}\n\nexport function setup(params) {\n  params.s = {\n    eps: 0, h: 0, fam: [], band: null, ghost: null, kc: 0, walk: 0, dir: 1,\n    x: X0, y: X0 * (X0 * X0 / 3 - 1), acc: 0, rowT: 0, cmin: 9, cmax: -9,\n    tmin: new Float32Array(TH).fill(NaN), tmax: new Float32Array(TH), tk: new Int8Array(TH), ta: new Float32Array(TH), head: 0,\n    tail: new Float32Array(512), ti: 0, tn: 0,\n    xr: 2.2, yt: 1.1, wantEps: 0, still: 0, hue: 0, tl: new Float32Array(W * PH), rgb: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],\n  };\n}\n\nfunction pushRow(S) {\n  S.head = (S.head + TH - 1) % TH;\n  S.tmin[S.head] = S.cmin;\n  S.tmax[S.head] = S.cmax;\n  S.tk[S.head] = S.kc;\n  S.ta[S.head] = S.fam[S.kc].a;\n  S.cmin = S.cmax = S.x;\n}\n\nfunction sim(S, d, speed, pace) {\n  const N = S.fam.length;\n  S.walk += S.dir * pace * d * speed * 0.5;\n  if (S.walk > N - 1 + HOLD) {\n    S.walk = N - 1 + HOLD;\n    S.dir = -1;\n  } else if (S.walk \u003c -HOLD) {\n    S.walk = -HOLD;\n    S.dir = 1;\n  }\n  const fade = exp(-(d * speed * 0.5) / GHOST);\n  for (let k = 0; k \u003c N; k++) S.ghost[k] *= fade;\n  const h = S.h, ie = 1 / S.eps;\n  S.acc += d * speed * RATE;\n  let a = S.fam[S.kc].a;\n  while (S.acc >= h) {\n    S.acc -= h;\n    const px = S.x;\n    rk4(S.x, S.y, a, ie, h);\n    S.x = RX;\n    S.y = RY;\n    if (px \u003c a && S.x >= a && S.y > a * (a * a / 3 - 1)) {\n      // A loop is done: the next cycle of the walk takes over here.\n      const was = S.fam[S.kc];\n      S.kc = cl(round(S.walk), 0, N - 1);\n      const m = S.fam[S.kc];\n      a = m.a;\n      // Out of a Hopf cycle the point sits by the weakly unstable focus and\n      // would take a dozen loops to spiral out to a duck, so it is set on\n      // the new cycle where that cycle crosses x = a.\n      if (was.hopf && !m.hopf) {\n        S.x = m.pts[0];\n        S.y = m.pts[1];\n      }\n    }\n    S.ghost[S.kc] = 1;\n    S.tail[S.ti] = S.x;\n    S.tail[S.ti + 1] = S.y;\n    S.ti = (S.ti + 2) % S.tail.length;\n    S.tn = min(S.tn + 1, S.tail.length / 2);\n    if (S.x \u003c S.cmin) S.cmin = S.x;\n    if (S.x > S.cmax) S.cmax = S.x;\n    S.rowT += h * TR;\n    if (S.rowT >= 1) {\n      S.rowT -= 1;\n      pushRow(S);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.04, 0.6], d = cl(dt || 0, 0, 0.1);\n  use(S);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), eps = cl(kv[2], 0.04, 0.2), pace = cl(kv[3], 0.6, 3);\n  if (!S.fam.length) {\n    family(S, eps);\n    // Open going up the walk at the duck that turns back near x = -0.5,\n    // with up to eight seconds already run to get there, so the ghosts and\n    // the trace are there from the first frame. At the opening Pace the\n    // first duck with a head comes 6 seconds in.\n    const N = S.fam.length, at = 0.5 * (N - 1), pre = min(8, (at + HOLD) / pace);\n    S.walk = at - pace * pre;\n    S.kc = cl(round(S.walk), 0, N - 1);\n    const m = S.fam[S.kc];\n    S.x = m.pts[0];\n    S.y = m.pts[1];\n    S.cmin = S.cmax = S.x;\n    for (let i = 0; i \u003c round(pre * 30); i++) sim(S, 1 / 30, 2, pace);\n    S.wantEps = eps;\n    return;\n  }\n  // A new eps is taken once the knob has rested for a quarter second.\n  if (abs(eps - S.wantEps) > 1e-6) {\n    S.wantEps = eps;\n    S.still = 0;\n  } else S.still += d;\n  if (abs(S.wantEps - S.eps) > 1e-6 && S.still > 0.25) family(S, S.wantEps);\n  sim(S, d, speed, pace);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.fam.length) return;\n  use(S);\n  const rgb = S.rgb, fam = S.fam, N = fam.length, c = S.c, c2 = S.c2, hue = S.hue;\n  rgb.fill(0);\n  const add = (o, col, v) => {\n    rgb[o] += col[0] * v;\n    rgb[o + 1] += col[1] * v;\n    rgb[o + 2] += col[2] * v;\n  };\n  const colOf = (k, s, v, out) => hsv(wheel(0.22 + (0.58 * k) / max(1, N - 1) + hue), s, v, out);\n  // The two sides of the cubic: above it the fast flow runs right, below it left.\n  const up = hsv(wheel(0.25 + hue), 0.45, 0.1, [0, 0, 0]), dn = hsv(wheel(0.62 + hue), 0.45, 0.1, [0, 0, 0]);\n  const cols = [];\n  for (let k = 0; k \u003c N; k++) cols.push(colOf(k, 0.75, 1, [0, 0, 0]));\n  for (let p = 0; p \u003c W * PH; p++) {\n    const o = p * 3;\n    add(o, S.side[p] ? up : dn, 1);\n    const b = S.band[p];\n    if (b >= 0) add(o, cols[b], 0.42 * S.ghost[b]);\n  }\n  // Ghost outlines.\n  for (let k = 0; k \u003c N; k++) {\n    const g = S.ghost[k];\n    if (g \u003c 0.02 || k === S.kc) continue;\n    const st = fam[k].stroke, col = cols[k];\n    for (let p = 0; p \u003c W * PH; p++) if (st[p] > 0) add(p * 3, col, st[p] * g * 0.6);\n  }\n  const att = hsv(wheel(0.07 + hue), 0.6, 0.42, [0, 0, 0]), rep = hsv(wheel(0.97 + hue), 0.6, 0.5, [0, 0, 0]);\n  for (let p = 0; p \u003c W * PH; p++) {\n    if (S.att[p] > 0) add(p * 3, att, S.att[p]);\n    if (S.rep[p] > 0) add(p * 3, rep, S.rep[p]);\n  }\n  // The cycle being run.\n  colOf(S.kc, 0.35, 1, c);\n  const st = fam[S.kc].stroke;\n  for (let p = 0; p \u003c W * PH; p++) if (st[p] > 0) add(p * 3, c, st[p] * 0.75);\n  // The equilibrium at (a, f(a)), the centre the Hopf cycle grew from.\n  const a = fam[S.kc].a, ex = PX(a), ey = PY(a * (a * a / 3 - 1));\n  for (const [dx, dy, v] of [[0, 0, 0.7], [1, 0, 0.3], [-1, 0, 0.3], [0, 1, 0.3], [0, -1, 0.3]]) {\n    const xx = floor(ex) + dx, yy = floor(ey) + dy;\n    if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c PH) add((yy * W + xx) * 3, rep, v * 2);\n  }\n  // The point and its last 0.3 units of slow time.\n  const tl = S.tl.fill(0), L = min(S.tn - 1, ceil(0.3 / S.h)), TL = S.tail.length;\n  for (let i = 0; i \u003c L; i++) {\n    const j0 = (S.ti - 2 * (i + 1) + 2 * TL) % TL, j1 = (S.ti - 2 * (i + 2) + 2 * TL) % TL;\n    seg(tl, PX(S.tail[j0]), PY(S.tail[j0 + 1]), PX(S.tail[j1]), PY(S.tail[j1 + 1]), 1 - i / L, PH);\n  }\n  for (let p = 0; p \u003c W * PH; p++) if (tl[p] > 0) add(p * 3, c, tl[p] * 0.9);\n  const qx = PX(S.x), qy = PY(S.y);\n  for (let yy = floor(qy - 3); yy \u003c= qy + 3; yy++)\n    for (let xx = floor(qx - 3); xx \u003c= qx + 3; xx++) {\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= PH) continue;\n      const dx = xx + 0.5 - qx, dy = yy + 0.5 - qy, r2 = dx * dx + dy * dy;\n      add((yy * W + xx) * 3, [1, 1, 1], 1.6 * exp(-r2 / 2.2));\n    }\n  // The axis between: ticks at x = -2, -1, 0, 1, 2 and a mark at x = a.\n  const ax = hsv(wheel(0.5 + hue), 0.2, 1, c2);\n  for (let x = 0; x \u003c W; x++) add(((PH + 1) * W + x) * 3, ax, 0.12);\n  for (let t = -2; t \u003c= 2; t++) {\n    const xx = floor(PX(t));\n    for (let yy = PH; yy \u003c= PH + 2; yy++) if (xx >= 0 && xx \u003c W) add((yy * W + xx) * 3, ax, 0.35);\n  }\n  for (let yy = PH; yy \u003c= PH + 2; yy++) add((yy * W + cl(floor(ex), 0, W - 1)) * 3, rep, 0.8);\n  // x(t) running down, newest row on top, filled from the equilibrium\n  // x = a out to the trace.\n  for (let r = 0; r \u003c TH; r++) {\n    const i = (S.head + r) % TH, lo = S.tmin[i], hi = S.tmax[i];\n    if (lo !== lo) continue;\n    const k = S.tk[i], col = cols[min(k, N - 1)], e = PX(S.ta[i]), x0 = PX(lo), x1 = PX(hi), y = T0 + r;\n    const age = 1 - (0.55 * r) / TH;\n    // A faint rule across the trace where the next cycle of the family took over.\n    const j = (i + 1) % TH;\n    if (r \u003c TH - 1 && S.tmin[j] === S.tmin[j] && S.tk[j] !== k) for (let x = 0; x \u003c W; x++) add((y * W + x) * 3, col, 0.13 * age);\n    const fl = min(e, x0), fr = max(e, x1);\n    for (let x = max(0, floor(fl)); x \u003c W && x \u003c fr; x++) {\n      const cx = x + 0.5;\n      // Coverage of the pixel by the bright stroke [x0 - 0.5, x1 + 0.5].\n      const sc = cl(min(cx + 0.5, x1 + 1) - max(cx - 0.5, x0 - 1), 0, 1);\n      const fc = cl(min(cx + 0.5, fr) - max(cx - 0.5, fl), 0, 1);\n      // The fill brightens from the equilibrium out to the trace.\n      const q = abs(cx - e) / max(1, abs((cx \u003c e ? x0 : x1) - e));\n      add((y * W + x) * 3, col, age * ((0.2 + 0.36 * min(1, q)) * fc + 0.9 * sc));\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","crackling-noise":"// ===== Patternflow pattern =====\n// Title:   Crackling Noise\n// Family:  noise\n// Idea:    A random-field Ising magnet at zero temperature is swept from all down to all up, one avalanche at a time, and each avalanche of flipped spins crawls out across the dark panel in its own colour, the colour drifting along the sweep, until the panel is a patchwork of clusters of every size; then the field is swept back down, the avalanches go dim in another patchwork, and a new disorder is dealt.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Barkhausen noise (Heinrich Barkhausen, 1919), hysteresis and avalanches in the zero-temperature random-field Ising model (James Sethna, Karin Dahmen, Sivan Kartha, James Krumhansl, Bruce Roberts and Joel Shore, 1993), crackling noise (James Sethna, Karin Dahmen and Christopher Myers, 2001), the critical disorder of the two-dimensional model (Djordje Spasojevic, Sanja Janicevic and Milan Knezevic, 2011), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Disorder=1.05..2.6, Grain=0..1.6\n//\n// Knob 1: Hue. Turns the whole sweep round the wheel. At 0 the first avalanches are teal and the colour drifts through blue and violet to pink by the last; at 0.5 it starts magenta, reaches red a quarter of the way through and goes on from green to cyan. The dim colours of the way back skip orange, which reads brown.\n// Knob 2: Speed. At 2 the panel flips 474 spins a second, so an avalanche of 1000 spins takes 2.1 seconds to crawl out and a whole sweep up takes 17 seconds (the first opens 30% done and ends at 12); 0.2 is ten times slower, 3 half as fast again. The way down runs twice as fast, and the holds of 1.5 s at the top and 1 s at the bottom scale with the knob.\n// Knob 3: Disorder. R, the width of the Gaussian random field against a coupling of 1 to each of 4 neighbours. At 0.85 and below one avalanche snaps nine tenths of the 64 x 128 panel (the critical width on an endless lattice is 0.54), so the range starts above it. At 1.05 a sweep is about 130 avalanches, the biggest 1000 to 2000 spins and 16 of 100 or more; at 1.6 about 830 with the biggest near 170; at 2.6 about 2400, four in ten of them a lone spin and none over 50.\n// Knob 4: Grain. The correlation length of the field: white noise blurred by a Gaussian of 0 to 1.6 LEDs and scaled back to width R. Below 0.25 the field is uncorrelated, the classic model, and the clusters have ragged edges; at 0.8 they are rounded blobs and there are 2.5 times as many; at 1.6 the field is smooth enough that a flat edge of flipped spins holds still, so the avalanches grow as rectangles nested inside each other.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, abs, sqrt, log, exp, cos, ceil, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Spins flipped per second at Speed 2, and the share of the first sweep\n// already done when the pattern opens.\nconst RATE = 474, OPEN = 0.3;\n// Seconds held at the top and at the bottom of the loop, at Speed 2.\nconst HOLD_UP = 1.5, HOLD_DOWN = 1;\n// The hue of a flip is set by how far through the sweep its avalanche started.\nconst SPAN = 0.62;\n// Skips orange through lime, which read brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nfunction gauss() {\n  let u = 0;\n  while (u === 0) u = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * Math.random());\n}\n\nfunction makeSweep() {\n  return {\n    seq: new Int16Array(N), // sites in the order they flip\n    pos: new Int16Array(N), // where each site is in seq\n    av: new Int32Array(N), // the avalanche each site flipped in\n    start: new Int32Array(N + 1), // where each avalanche starts in seq\n    n: 0, // avalanches\n    jit: new Float32Array(N), // per avalanche: hue jitter and saturation\n    sat: new Float32Array(N),\n    col: new Float32Array(N * 3),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    R: -1, grain: -1, hue: -1, phase: 0, cur: 0, wait: 0, started: false,\n    white: new Float64Array(N), h: new Float64Array(N), tmp: new Float64Array(N),\n    key: new Float64Array(N), fl: new Uint8Array(N),\n    hk: new Float64Array(6 * N), hs: new Int32Array(6 * N),\n    up: makeSweep(), dn: makeSweep(),\n    bg: new Float32Array(N * 3),\n  };\n}\n\nfunction deal(S) {\n  for (let i = 0; i \u003c N; i++) S.white[i] = gauss();\n  for (const sw of [S.up, S.dn])\n    for (let a = 0; a \u003c N; a++) {\n      sw.jit[a] = (Math.random() - 0.5) * 0.08;\n      sw.sat[a] = 0.5 + 0.45 * Math.random();\n    }\n}\n\n// The frozen field: the white noise, blurred on the torus by a Gaussian of\n// radius grain, then shifted to mean 0 and scaled to standard deviation R.\nfunction makeField(S) {\n  const { white, h, tmp } = S, sg = S.grain;\n  if (sg \u003c 0.25) h.set(white);\n  else {\n    const r = ceil(2.5 * sg), k = new Float64Array(2 * r + 1);\n    for (let d = -r; d \u003c= r; d++) k[d + r] = exp((-d * d) / (2 * sg * sg));\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let d = -r; d \u003c= r; d++) a += k[d + r] * white[y * W + ((x + d + 4 * W) % W)];\n        tmp[y * W + x] = a;\n      }\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        let a = 0;\n        for (let d = -r; d \u003c= r; d++) a += k[d + r] * tmp[((y + d + 4 * H) % H) * W + x];\n        h[y * W + x] = a;\n      }\n  }\n  let m = 0, v = 0;\n  for (let i = 0; i \u003c N; i++) m += h[i];\n  m /= N;\n  for (let i = 0; i \u003c N; i++) v += (h[i] -= m) * h[i];\n  const f = S.R / sqrt(v / N);\n  for (let i = 0; i \u003c N; i++) h[i] *= f;\n}\n\n// One branch of the hysteresis loop. Spin i, still down, flips up once\n// h_i + H + J (up neighbours - down neighbours) > 0 with J = 1, so its\n// key h_i + 2 (up neighbours) - 4 says the field H at which it goes. The\n// sweep raises H just to the largest key left, flips that spin, and lets\n// the avalanche run at that H, breadth first, each flip adding 2 to the key\n// of its neighbours. The way back down is the same sweep for the field -h,\n// since flipping every spin and both fields maps one branch onto the other.\n// Keys only grow, so a heap with stale entries skipped does the search.\nfunction sweep(S, sw, sign) {\n  const { key, fl, hk, hs, h } = S, seq = sw.seq;\n  let hn = 0;\n  const push = (k, s) => {\n    let i = hn++;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (hk[p] >= k) break;\n      hk[i] = hk[p];\n      hs[i] = hs[p];\n      i = p;\n    }\n    hk[i] = k;\n    hs[i] = s;\n  };\n  const pop = () => {\n    const k = hk[--hn], s = hs[hn];\n    let i = 0;\n    for (;;) {\n      let c = 2 * i + 1;\n      if (c >= hn) break;\n      if (c + 1 \u003c hn && hk[c + 1] > hk[c]) c++;\n      if (hk[c] \u003c= k) break;\n      hk[i] = hk[c];\n      hs[i] = hs[c];\n      i = c;\n    }\n    hk[i] = k;\n    hs[i] = s;\n  };\n  fl.fill(0);\n  for (let i = 0; i \u003c N; i++) push((key[i] = sign * h[i] - 4), i);\n  let pos = 0, n = 0;\n  while (pos \u003c N) {\n    let i, k;\n    do {\n      i = hs[0];\n      k = hk[0];\n      pop();\n    } while (fl[i] || k !== key[i]);\n    const field = -k;\n    sw.start[n] = pos;\n    fl[i] = 1;\n    seq[pos++] = i;\n    for (let q = pos - 1; q \u003c pos; q++) {\n      const s = seq[q], x = s % W, y = (s - x) / W;\n      for (let d = 0; d \u003c 4; d++) {\n        const j = d === 0 ? y * W + ((x + 1) % W) : d === 1 ? y * W + ((x + W - 1) % W) : d === 2 ? ((y + 1) % H) * W + x : ((y + H - 1) % H) * W + x;\n        if (fl[j]) continue;\n        key[j] += 2;\n        if (key[j] + field > 0) {\n          fl[j] = 1;\n          seq[pos++] = j;\n        } else push(key[j], j);\n      }\n    }\n    n++;\n  }\n  sw.start[n] = N;\n  sw.n = n;\n  for (let a = 0; a \u003c n; a++) for (let p = sw.start[a]; p \u003c sw.start[a + 1]; p++) {\n    sw.av[seq[p]] = a;\n    sw.pos[seq[p]] = p;\n  }\n}\n\n// Colours per avalanche. Up: by where it started in the sweep, a little\n// jitter so neighbours from the same moment part, and brightness by size,\n// 232 for a lone spin up to 255 from 400 spins. Down: the same drift, dim.\nfunction paint(S) {\n  for (const [sw, up] of [[S.up, true], [S.dn, false]]) {\n    for (let a = 0; a \u003c sw.n; a++) {\n      const m = sw.start[a] / N, size = sw.start[a + 1] - sw.start[a];\n      if (up) hsv(wheel(0.27 + S.hue + SPAN * m + sw.jit[a]), sw.sat[a], 0.91 + 0.09 * min(1, log(size) / log(400)), sw.col, a * 3);\n      else hsv(wheel(0.6 + S.hue + 0.4 * m + 2 * sw.jit[a]), sw.sat[a] + 0.05, 0.12 + 0.24 * (sw.sat[a] - 0.5), sw.col, a * 3);\n    }\n  }\n}\n\nfunction rebuild(S) {\n  makeField(S);\n  sweep(S, S.up, 1);\n  sweep(S, S.dn, -1);\n  paint(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1.05, 0];\n  const d = cl(dt || 0, 0, 0.1), speed = cl(kv[1], 0.2, 3) / 2;\n  const R = cl(kv[2], 1.05, 2.6), grain = cl(kv[3], 0, 1.6), hue = cl(kv[0], 0, 1);\n  if (!S.started) {\n    deal(S);\n    S.started = true;\n    // The first sweep opens part done, so the patchwork is already there.\n    S.cur = OPEN * N;\n  }\n  if (abs(R - S.R) > 1e-4 || abs(grain - S.grain) > 1e-3) {\n    // A new disorder width or grain reshapes the same noise and the\n    // sweep stays as far through as it was.\n    S.R = R;\n    S.grain = grain;\n    S.hue = hue;\n    rebuild(S);\n  } else if (abs(hue - S.hue) > 1e-4) {\n    S.hue = hue;\n    paint(S);\n  }\n  // 0 up, 1 held up, 2 down, 3 held down.\n  if (S.phase === 0 || S.phase === 2) {\n    S.cur += RATE * (S.phase === 2 ? 2 : 1) * speed * d;\n    if (S.cur >= N) {\n      S.cur = N;\n      S.phase++;\n      S.wait = S.phase === 1 ? HOLD_UP : HOLD_DOWN;\n    }\n  } else {\n    S.wait -= speed * d;\n    if (S.wait \u003c= 0) {\n      if (S.phase === 3) {\n        // The dim patchwork of the way down stays under the next sweep.\n        for (let i = 0; i \u003c N; i++) {\n          const o = S.dn.av[i] * 3;\n          S.bg[i * 3] = S.dn.col[o];\n          S.bg[i * 3 + 1] = S.dn.col[o + 1];\n          S.bg[i * 3 + 2] = S.dn.col[o + 2];\n        }\n        deal(S);\n        rebuild(S);\n      }\n      S.phase = (S.phase + 1) % 4;\n      S.cur = 0;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.R \u003c 0) return;\n  const c = floor(S.cur), ph = S.phase, up = S.up, dn = S.dn;\n  for (let i = 0; i \u003c N; i++) {\n    let col = up.col, o = up.av[i] * 3;\n    if (ph === 0) {\n      if (up.pos[i] >= c) {\n        col = S.bg;\n        o = i * 3;\n      }\n    } else if (ph === 3 || (ph === 2 && dn.pos[i] \u003c c)) {\n      col = dn.col;\n      o = dn.av[i] * 3;\n    }\n    display.setPixel(i % W, (i / W) | 0, col[o] | 0, col[o + 1] | 0, col[o + 2] | 0);\n  }\n}\n","greenhill-column":"// ===== Patternflow pattern =====\n// Title:   Greenhill Column\n// Family:  physics\n// Idea:    Eight elastic columns of different stiffness stand clamped along the bottom row and grow upward at a steady rate, each straight until it passes its own critical height, marked by a white tick, where it buckles under its own weight into the heavy elastica, solved every frame by shooting on the tip angle, and swings over until its tip points below the horizontal, when it shrinks back, straightens and grows again, so the stiffest one in the middle stands tallest.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: buckling of a heavy column under its own weight (Leonhard Euler, 1778; Alfred George Greenhill, 1881), Euler's flagpole with a weight on top (Leonhard Euler, 1744), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=3..64, Top weight=0..40\n//\n// Knob 1: Hue. At 0 the columns run from azure for the softest through blue and violet to rose for the stiffest, dim while straight and bright where they bend hardest; the knob turns them all round the wheel together, skipping orange, yellow and lime, which read brown and olive when dim.\n// Knob 2: Speed. At 2 the columns grow 8 LEDs a second and shrink back at 16. The stiffest takes 1 to 3 s to grow from where it last shrank back to its tick, 2 s more to fall over and about 2 s to shrink and straighten. At 0.2 they grow 0.8 LEDs a second, at 3 12.\n// Knob 3: Spread. The stiffest column's EI over the softest's, 3 to 64, in equal ratios between. Greenhill's height goes as the cube root of EI, so at 3 the eight columns buckle at 83 to 120 LEDs, at 16 at 48 to 120 and at 64 at 30 to 120.\n// Knob 4: Top weight. A weight P on every tip, 0 to 40 LEDs' worth of column. Near 0 it is Greenhill's column, buckling at 83 to 120 LEDs at Spread 3; at 20 they buckle at 67 to 103, at 40 at 56 to 90. Euler's flagpole, the top weight alone, buckles where P = pi^2 EI / (4 L^2), 67 to 117 LEDs at 40, and the softer a column the closer it comes: at Spread 64 and 40 the softest buckles at 14 LEDs against the flagpole's 15.\n\nconst W = 64, H = 128, NC = 8, NS = 24;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Lengths in LEDs, weight per LED of column Q = 1. Greenhill's column\n// buckles once q L^3 / EI passes 7.837, where (2/3) sqrt(q L^3 / EI) reaches\n// 1.866, the first zero of the Bessel function J_-1/3 in his solution;\n// Euler had tried the same problem in 1778. The stiffest column has EI =\n// 120^3 / 7.837, so with no top weight it buckles at 120 LEDs, and the\n// others step down in EI by equal ratios to 1 / Spread of it.\nconst Q = 1, LTOP = 120, GREENHILL = 7.837;\n// The tip angle at which a column gives up and shrinks back: 100 degrees,\n// reached at 1.14 times the critical height with no top weight.\nconst DROOP = (100 * PI) / 180;\n// Where each column stands, left to right: its rank in stiffness, 0 the\n// softest, so the stiffest stand in the middle.\nconst RANK = [0, 2, 4, 6, 7, 5, 3, 1];\nconst BASEY = H - 0.5;\n// The pen: a core 2.6 LEDs wide at full strength and a glow out to 4.5,\n// tabulated by squared distance.\nconst R2 = 4.5 * 4.5, PEN_STEP = 12, PEN = new Float32Array(Math.ceil(R2 * PEN_STEP) + 1);\nfor (let i = 0; i \u003c PEN.length; i++) {\n  const dd = sqrt(i / PEN_STEP);\n  PEN[i] = dd \u003c= 1.3 ? 1 : 0.7 * exp(-((dd - 1.3) * (dd - 1.3)) / 4.5);\n}\n\n// The heavy elastica: EI theta''(s) = -(q (L - s) + P) sin theta, with s\n// measured up the column. Scaled to s in [0, 1] it is theta'' = -(lam (1 -\n// s) + mu) sin theta, lam = q L^3 / EI and mu = P L^2 / EI. This integrates\n// it by RK4 in NS steps from the free top, where theta = alpha and theta' = 0\n// (no moment), down to the clamp, and returns theta there, which must be 0.\n// If th is given it gets theta and theta' at the points s = i / NS.\nfunction shoot(alpha, lam, mu, th, dth) {\n  let t = alpha, w = 0, s = 1;\n  const h = -1 / NS;\n  if (th) {\n    th[NS] = t;\n    dth[NS] = 0;\n  }\n  for (let i = NS - 1; i >= 0; i--) {\n    const a1 = -(lam * (1 - s) + mu), a2 = -(lam * (1 - s - h / 2) + mu), a3 = -(lam * (1 - s - h) + mu);\n    const k1t = w, k1w = a1 * sin(t);\n    const k2t = w + (h / 2) * k1w, k2w = a2 * sin(t + (h / 2) * k1t);\n    const k3t = w + (h / 2) * k2w, k3w = a2 * sin(t + (h / 2) * k2t);\n    const k4t = w + h * k3w, k4w = a3 * sin(t + h * k3t);\n    t += (h / 6) * (k1t + 2 * k2t + 2 * k3t + k4t);\n    w += (h / 6) * (k1w + 2 * k2w + 2 * k3w + k4w);\n    s += h;\n    if (th) {\n      th[i] = t;\n      dth[i] = w;\n    }\n  }\n  return t;\n}\n\n// The linear problem u'' = -(lam (1 - s) + mu) u with u(1) = 1, u'(1) = 0:\n// the column is critical where u(0) first reaches 0.\nfunction linear(lam, mu) {\n  let u = 1, w = 0, s = 1;\n  const h = -1 / NS;\n  for (let i = 0; i \u003c NS; i++) {\n    const a1 = -(lam * (1 - s) + mu), a2 = -(lam * (1 - s - h / 2) + mu), a3 = -(lam * (1 - s - h) + mu);\n    const k1u = w, k1w = a1 * u;\n    const k2u = w + (h / 2) * k1w, k2w = a2 * (u + (h / 2) * k1u);\n    const k3u = w + (h / 2) * k2w, k3w = a2 * (u + (h / 2) * k2u);\n    const k4u = w + h * k3w, k4w = a3 * (u + h * k3u);\n    u += (h / 6) * (k1u + 2 * k2u + 2 * k3u + k4u);\n    w += (h / 6) * (k1w + 2 * k2w + 2 * k3w + k4w);\n    s += h;\n  }\n  return u;\n}\n\n// The critical height of a column of stiffness EI under top weight P, by\n// bisection on L between 0 and its Greenhill height.\nfunction critical(EI, P) {\n  let lo = 0, hi = Math.cbrt((GREENHILL * EI) / Q) * 1.0001;\n  for (let it = 0; it \u003c 28; it++) {\n    const L = (lo + hi) / 2;\n    if (linear((Q * L * L * L) / EI, (P * L * L) / EI) > 0) lo = L;\n    else hi = L;\n  }\n  return (lo + hi) / 2;\n}\n\n// The tip angle of the buckled column, by bisection, starting from a\n// bracket round the last answer and falling back to a scan down from pi.\n// The bifurcation is supercritical, so the answer grows from 0 at the\n// critical height: 41 degrees at 1.02 times it, 88 at 1.10.\nfunction tipAngle(lam, mu, prev, ratio) {\n  let lo = -1, hi = -1;\n  if (prev > 0.02) {\n    const a = max(1e-4, prev - 0.12), b = min(PI - 1e-4, prev + 0.12);\n    if (shoot(a, lam, mu) \u003c 0 && shoot(b, lam, mu) > 0) {\n      lo = a;\n      hi = b;\n    }\n  }\n  if (lo \u003c 0) {\n    if (shoot(1e-4, lam, mu) > 0 && ratio \u003c 1.5) return 0;\n    for (let k = 47; k >= 1; k--) {\n      const a = (k * PI) / 48;\n      if (shoot(a, lam, mu) \u003c 0) {\n        lo = a;\n        hi = ((k + 1) * PI) / 48 - 1e-4;\n        break;\n      }\n    }\n    if (lo \u003c 0) return 0;\n  }\n  for (let it = 0; it \u003c 20; it++) {\n    const m = (lo + hi) / 2;\n    if (shoot(m, lam, mu) \u003c 0) lo = m;\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\n// Hue h in turns, with orange, yellow and lime (0.03 to 0.25) skipped,\n// since they read brown and olive when dim.\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 0.78;\n  if (h >= 0.03) h += 0.22;\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  const cols = [];\n  for (let k = 0; k \u003c NC; k++)\n    cols.push({ x: 3.5 + 8 * k, rank: RANK[k], EI: 1, Lc: 60, L: 0, grow: 1, side: 1, back: 0.8, alpha: 0, th: new Float64Array(NS + 1), dth: new Float64Array(NS + 1) });\n  params.s = { cols, spread: -1, P: -1, hue: 0, started: false, rgb: new Float32Array(W * H * 3), cb: new Float32Array(W * H), touched: new Int32Array(W * H), c: [0, 0, 0] };\n  return params.s;\n}\n\nfunction pickSide(c) {\n  c.side = Math.random() \u003c 0.5 ? -1 : 1;\n  c.back = 0.8 + 0.12 * Math.random();\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 3, 0], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1], 0.2, 3), spread = cl(kv[2], 3, 64), P = cl(kv[3], 0, 40);\n  if (spread !== S.spread || P !== S.P) {\n    S.spread = spread;\n    S.P = P;\n    for (const c of S.cols) {\n      c.EI = ((Q * LTOP ** 3) / GREENHILL) * spread ** (-(NC - 1 - c.rank) / (NC - 1));\n      c.Lc = critical(c.EI, P);\n    }\n  }\n  if (!S.started) {\n    // Pre-roll: every column starts somewhere in its cycle, from its\n    // shrink-back height to 1.11 times its critical height, 80% of them\n    // growing.\n    S.started = true;\n    for (const c of S.cols) {\n      pickSide(c);\n      c.L = c.Lc * (c.back + (1.11 - c.back) * Math.random());\n      c.grow = Math.random() \u003c 0.8 ? 1 : -1;\n    }\n  }\n  const rate = 4 * speed * d;\n  for (const c of S.cols) {\n    // Shrinking runs at twice the growth rate, and faster when a knob has\n    // left a column more than 1.2 times its new critical height.\n    c.L = max(4, c.grow > 0 ? c.L + rate : c.L - max(2 * rate, 3 * d * (c.L - 1.2 * c.Lc)));\n    const lam = (Q * c.L * c.L * c.L) / c.EI, mu = (S.P * c.L * c.L) / c.EI;\n    c.alpha = c.L > c.Lc ? tipAngle(lam, mu, c.alpha, c.L / c.Lc) : 0;\n    if (c.grow > 0 && c.alpha > DROOP) c.grow = -1;\n    else if (c.grow \u003c 0 && c.L \u003c c.back * c.Lc) {\n      c.grow = 1;\n      pickSide(c);\n    }\n    if (c.alpha > 0) shoot(c.alpha, lam, mu, c.th, c.dth);\n    else {\n      c.th.fill(0);\n      c.dth.fill(0);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, cb = S.cb, touched = S.touched, col = S.c;\n  rgb.fill(0);\n  for (const c of S.cols) {\n    let nt = 0;\n    const seg = c.L / NS;\n    let x = c.x, y = BASEY;\n    for (let i = 0; i \u003c NS; i++) {\n      const t0 = c.th[i], t1 = c.th[i + 1], tm = (t0 + t1) / 2;\n      const nx = x + c.side * sin(tm) * seg, ny = y - cos(tm) * seg;\n      const steps = max(1, Math.ceil(seg));\n      for (let k = 0; k \u003c steps; k++) {\n        const f = (k + 0.5) / steps, px = x + (nx - x) * f, py = y + (ny - y) * f;\n        // Bending stress: the curvature times the length, 0 on a straight\n        // column and about 4 at the clamp when the tip is horizontal.\n        const kap = abs(c.dth[i] + (c.dth[i + 1] - c.dth[i]) * f);\n        const b = 0.42 + 0.58 * min(1, kap / 4);\n        const x0 = max(0, floor(px - 4.5)), x1 = min(W - 1, Math.ceil(px + 4.5));\n        const y0 = max(0, floor(py - 4.5)), y1 = min(H - 1, Math.ceil(py + 4.5));\n        for (let Y = y0; Y \u003c= y1; Y++) {\n          const dy = Y + 0.5 - py;\n          for (let X = x0; X \u003c= x1; X++) {\n            const dx = X + 0.5 - px, d2 = dx * dx + dy * dy;\n            if (d2 >= R2) continue;\n            const v = b * PEN[(d2 * PEN_STEP) | 0], p = Y * W + X;\n            if (cb[p] === 0) touched[nt++] = p;\n            if (v > cb[p]) cb[p] = v;\n          }\n        }\n      }\n      x = nx;\n      y = ny;\n    }\n    hsv(0.48 + S.hue + 0.065 * c.rank, 0.78, 1, col);\n    for (let k = 0; k \u003c nt; k++) {\n      const p = touched[k], v = cb[p], o = p * 3;\n      // Hot spots of stress go toward white.\n      const wv = max(0, v - 0.75) * 1.6;\n      const r = v * col[0] + wv, g = v * col[1] + wv, bl = v * col[2] + wv;\n      if (r > rgb[o]) rgb[o] = r;\n      if (g > rgb[o + 1]) rgb[o + 1] = g;\n      if (bl > rgb[o + 2]) rgb[o + 2] = bl;\n      cb[p] = 0;\n    }\n  }\n  // The ticks: a white bar 7 LEDs wide at each column's critical height,\n  // dimmer over the three LEDs where a straight column passes through it.\n  for (const c of S.cols) {\n    const ty = floor(BASEY - c.Lc);\n    if (ty \u003c 0 || ty >= H) continue;\n    const cx = floor(c.x);\n    for (let X = cx - 3; X \u003c= cx + 3; X++) {\n      if (X \u003c 0 || X >= W) continue;\n      const o = (ty * W + X) * 3, v = abs(X - cx) \u003c= 1 ? 0.55 : 0.85;\n      rgb[o] = max(rgb[o], v);\n      rgb[o + 1] = max(rgb[o + 1], v);\n      rgb[o + 2] = max(rgb[o + 2], v);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","holditch-ring":"// ===== Patternflow pattern =====\n// Title:   Holditch Ring\n// Family:  line\n// Idea:    A chord of fixed length slides round a tall convex oval with both ends on it, the point that splits it into a and b leaves a gold trace, the ring between the oval and the trace fills behind the a-part, and an ellipse with semi-axes a and b in the middle fills with the same area of light as it goes, so both close together when the lap ends, and the next lap runs on a new oval with a different ring and the same ellipse.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Holditch's theorem (Hamnet Holditch, 1858), support functions and Minkowski sums of convex bodies (Hermann Minkowski, 1903), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Split=0.25..0.5, Chord=36..44\n//\n// Knob 1: Hue. Turns the colours round together. At 0 the oval is pale cyan, the trace gold and the ring and the ellipse violet; at 0.33 the oval is pink, the trace teal and the fills green; at 0.67 pale lime, violet and azure.\n// Knob 2: Speed. At 2 a lap takes 6 seconds, then the full ring and ellipse pulse together for 1.2 s and the oval morphs into the next of six in 1.8 s, 9 seconds in all; at 0.2 the cycle takes 90 seconds, at 3 six.\n// Knob 3: Split. a / (a + b), 0.25 to 0.5. With the opening 36 LED chord, at 0.25 a is 9 and b 27, the ring holds pi x 9 x 27 = 763 square LEDs and the ellipse is 18 wide and 54 tall; at 0.5 a and b are both 18, the ring holds 1018 and the ellipse is a circle 36 across.\n// Knob 4: Chord. a + b, 36 to 44 LEDs. At a split of 0.25 the ring and the ellipse hold 763 square LEDs at 36 and 1140 at 44, and at 0.5 up to 1521. At 46 the first point ahead would jump 14 LEDs across the pointed end of the egg, and the chord would no longer slide.\n\nconst W = 64, H = 128, CX = 32, CY = 64;\nconst { floor, ceil, min, max, abs, sqrt, PI, cos, sin, atan2, hypot } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (a, b, x) => {\n  const t = cl((x - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n// Points on the oval, taken at K even steps of the outward normal, and\n// chord positions per lap.\nconst K = 240, N = 240;\n// One cycle at Speed 2, in seconds.\nconst LAP = 6, HOLD = 1.2, MORPH = 1.8;\n\n// The ovals, each a Minkowski sum: its support function is the sum of its\n// parts', so a blend of two ovals taken normal by normal is convex all the\n// way through. Parts: [0, A, B] an ellipse, [1, w, h] a rectangle,\n// [2, r] a disc, [3, points] a polygon. In turn: an ellipse, a rounded\n// rectangle, an egg, a stadium, a shield and a lozenge, each 58 x 122 LEDs,\n// with ey where the ellipse sits best inside its trace. A tall rounded\n// triangle was tried and left out: at its point a 40 LED chord already\n// jumps 39 LEDs from one side to the other.\nconst OVALS = [\n  { p: [[0, 29, 61]], ey: 64 },\n  { p: [[1, 17, 49], [2, 12]], ey: 64 },\n  { p: [[0, 25, 52], [3, [[0, -9], [4, 9], [-4, 9]]]], ey: 70 },\n  { p: [[1, 0, 32], [2, 29]], ey: 64 },\n  { p: [[3, [[-12, -44], [12, -44], [12, 28], [0, 44], [-12, 28]]], [2, 17]], ey: 60 },\n  { p: [[3, [[0, -40], [9, -20], [9, 20], [0, 40], [-9, 20], [-9, -20]]], [0, 20, 21]], ey: 64 },\n];\n\n// The point of an oval whose outward normal is (c, s).\nfunction support(oval, c, s, out) {\n  let x = 0, y = 0;\n  for (const q of oval.p) {\n    if (q[0] === 0) {\n      const h = hypot(q[1] * c, q[2] * s);\n      (x += (q[1] * q[1] * c) / h), (y += (q[2] * q[2] * s) / h);\n    } else if (q[0] === 1) (x += c \u003c 0 ? -q[1] : q[1]), (y += s \u003c 0 ? -q[2] : q[2]);\n    else if (q[0] === 2) (x += q[1] * c), (y += q[1] * s);\n    else {\n      let best = -1e9, bx = 0, by = 0;\n      for (const v of q[1]) {\n        const d = v[0] * c + v[1] * s;\n        if (d > best) (best = d), (bx = v[0]), (by = v[1]);\n      }\n      (x += bx), (y += by);\n    }\n  }\n  out[0] = x;\n  out[1] = y;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// Soft fills take hues from a wheel that skips orange through yellow,\n// which read brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    f: 0, t: 0, ox: new Float32Array(K), oy: new Float32Array(K), arc: new Float64Array(K + 1),\n    sx: new Float32Array((N + 1) * 4), ang: new Float64Array(N + 1), area: new Float64Array(N + 1),\n    key: \"\", ring: new Uint8Array(W * H), tn: new Uint8Array(H), tx: new Float32Array(H * 8), xl: new Float32Array(H), xr: new Float32Array(H), buf: new Float32Array(W * H * 3),\n    c: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], tmp: [0, 0], tmq: [0, 0],\n  };\n}\n\n// The oval at morph m between oval f and the next one.\nfunction buildOval(S, m) {\n  const A = OVALS[S.f % OVALS.length], B = OVALS[(S.f + 1) % OVALS.length], p = S.tmp, q = S.tmq;\n  for (let i = 0; i \u003c K; i++) {\n    const psi = ((i + 0.5) / K) * TAU, c = cos(psi), s = sin(psi);\n    support(A, c, s, p);\n    support(B, c, s, q);\n    S.ox[i] = CX + p[0] + (q[0] - p[0]) * m;\n    S.oy[i] = CY + p[1] + (q[1] - p[1]) * m;\n  }\n  S.arc[0] = 0;\n  for (let i = 1; i \u003c= K; i++) S.arc[i] = S.arc[i - 1] + hypot(S.ox[i % K] - S.ox[i - 1], S.oy[i % K] - S.oy[i - 1]);\n  // Start each lap at the top of the oval, normal straight up.\n  S.u0 = S.arc[(3 * K) / 4];\n  S.ey = A.ey + (B.ey - A.ey) * m;\n}\n\n// The point of the oval at arc length u, and the edge it lies on.\nfunction at(S, u, out) {\n  const per = S.arc[K];\n  u = ((u % per) + per) % per;\n  let lo = 0, hi = K;\n  while (hi - lo > 1) {\n    const md = (lo + hi) >> 1;\n    if (S.arc[md] \u003c= u) lo = md;\n    else hi = md;\n  }\n  const f = (u - S.arc[lo]) / (S.arc[lo + 1] - S.arc[lo] || 1), j = (lo + 1) % K;\n  out[0] = S.ox[lo] + (S.ox[j] - S.ox[lo]) * f;\n  out[1] = S.oy[lo] + (S.oy[j] - S.oy[lo]) * f;\n  out[2] = lo;\n}\n\n// The other end of the chord: walking on from P, the first point of the\n// oval at distance L, solved exactly on the edge where it lies.\nfunction far(S, px, py, edge, L, out) {\n  for (let k = 0; k \u003c K; k++) {\n    const i = (edge + k) % K, j = (i + 1) % K;\n    const ax = k ? S.ox[i] : px, ay = k ? S.oy[i] : py, bx = S.ox[j], by = S.oy[j];\n    if (hypot(bx - px, by - py) \u003c L) continue;\n    const dx = bx - ax, dy = by - ay, fx = ax - px, fy = ay - py;\n    const a = dx * dx + dy * dy, b = 2 * (fx * dx + fy * dy), c = fx * fx + fy * fy - L * L;\n    const t = (-b + sqrt(max(0, b * b - 4 * a * c))) / (2 * a);\n    out[0] = ax + dx * t;\n    out[1] = ay + dy * t;\n    return;\n  }\n}\n\n// N + 1 chord positions round the lap: P, the split point D, the chord's\n// angle unwrapped, and the area the a-part has swept so far, quad by quad.\nfunction sampleLap(S, sp, L) {\n  const p = [0, 0, 0], q = [0, 0], per = S.arc[K], X = S.sx;\n  let prev = 0;\n  for (let k = 0; k \u003c= N; k++) {\n    at(S, S.u0 + (k / N) * per, p);\n    far(S, p[0], p[1], p[2], L, q);\n    X[k * 4] = p[0];\n    X[k * 4 + 1] = p[1];\n    X[k * 4 + 2] = p[0] + (q[0] - p[0]) * sp;\n    X[k * 4 + 3] = p[1] + (q[1] - p[1]) * sp;\n    let an = atan2(q[1] - p[1], q[0] - p[0]);\n    if (k) {\n      while (an - prev > PI) an -= TAU;\n      while (an - prev \u003c -PI) an += TAU;\n    }\n    S.ang[k] = prev = an;\n    S.area[k] = k ? S.area[k - 1] + quadArea(X, k - 1) : 0;\n  }\n  S.dir = S.ang[N] > S.ang[0] ? 1 : -1;\n  // The last quad meets the first again, so the a-part has swept the ring\n  // once: the total is pi a b to a few parts in ten thousand.\n  S.total = abs(S.area[N]);\n}\n\nfunction quadArea(X, k) {\n  const a = k * 4, b = a + 4;\n  const px = [X[a], X[a + 2], X[b + 2], X[b]], py = [X[a + 1], X[a + 3], X[b + 3], X[b + 1]];\n  let s = 0;\n  for (let i = 0; i \u003c 4; i++) s += px[i] * py[(i + 1) % 4] - px[(i + 1) % 4] * py[i];\n  return s / 2;\n}\n\n// Marks the LED centres inside triangle a b c with v.\nfunction tri(M, ax, ay, bx, by, cx, cy, v) {\n  const d = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(d) \u003c 1e-9) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, ceil(max(ay, by, cy)));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const l0 = ((cx - bx) * (py - by) - (cy - by) * (px - bx)) / d, l1 = ((ax - cx) * (py - cy) - (ay - cy) * (px - cx)) / d;\n      if (l0 >= -1e-6 && l1 >= -1e-6 && 1 - l0 - l1 >= -1e-6) {\n        const o = y * W + x;\n        if (M[o] \u003c v) M[o] = v;\n      }\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.25, 36], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.sp = cl(kv[2], 0.25, 0.5);\n  S.L = cl(kv[3], 36, 44);\n  S.t += (d * cl(kv[1], 0.2, 3)) / 2;\n  if (S.t >= LAP + HOLD + MORPH) (S.t -= LAP + HOLD + MORPH), S.f++;\n  const m = ss(LAP + HOLD, LAP + HOLD + MORPH, S.t);\n  // The lap is worked out again only when the oval or a knob has moved.\n  const key = S.f + \",\" + m.toFixed(4) + \",\" + S.sp.toFixed(4) + \",\" + S.L.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    buildOval(S, m);\n    sampleLap(S, S.sp, S.L);\n  }\n}\n\n// Xiaolin Wu's line, mixed over what is there.\nfunction line(B, x0, y0, x1, y1, c, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  let t;\n  if (steep) (t = x0), (x0 = y0), (y0 = t), (t = x1), (x1 = y1), (y1 = t);\n  if (x0 > x1) (t = x0), (x0 = x1), (x1 = t), (t = y0), (y0 = y1), (y1 = t);\n  const k = (y1 - y0) / (x1 - x0 || 1e-9);\n  for (let u = ceil(x0 - 0.5); u \u003c= floor(x1 - 0.5); u++) {\n    const v = y0 + k * (u + 0.5 - x0) - 0.5, vi = floor(v), f = v - vi;\n    plot(B, steep ? vi : u, steep ? u : vi, c, a * (1 - f));\n    plot(B, steep ? vi + 1 : u, steep ? u : vi + 1, c, a * f);\n  }\n}\n\nfunction plot(B, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const o = (y * W + x) * 3;\n  a = min(1, a);\n  B[o] += (c[0] - B[o]) * a;\n  B[o + 1] += (c[1] - B[o + 1]) * a;\n  B[o + 2] += (c[2] - B[o + 2]) * a;\n}\n\nfunction dot(B, x, y, r, c, a) {\n  for (let yy = floor(y - r); yy \u003c= y + r; yy++)\n    for (let xx = floor(x - r); xx \u003c= x + r; xx++) {\n      const q = hypot(xx + 0.5 - x, yy + 0.5 - y) / r;\n      if (q \u003c 1) plot(B, xx, yy, c, a * min(1, 1.6 * (1 - q)));\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.key) return;\n  const B = S.buf, X = S.sx, M = S.ring, t = S.t, [cBase, cOval, cFill, cTrace, cA, cB] = S.c, h = S.hue;\n  hsv(wheel(0.43 + h), 0.25, 0.11, cBase);\n  hsv(0.53 + h, 0.45, 1, cOval);\n  hsv(wheel(0.73 + h), 0.7, 0.6, cFill);\n  hsv(0.13 + h, 0.65, 1, cTrace);\n  hsv(wheel(0.73 + h), 0.35, 1, cA);\n  hsv(0.53 + h, 0.1, 0.9, cB);\n  // How far round the lap the chord is, and how bright the fills are: they\n  // pulse together in the hold and sink back to a ghost at the end of the\n  // morph, ready for the next lap to fill them again.\n  const lap = cl(t / LAP, 0, 1), kf = lap * N, k = min(N - 1, floor(kf)), fr = kf - k;\n  const full = t >= LAP, pulse = full ? 1 + 0.25 * sin((PI * (t - LAP)) / HOLD) * (t \u003c LAP + HOLD ? 1 : 0) : 1;\n  const sink = ss(LAP + HOLD + MORPH - 0.5, LAP + HOLD + MORPH, t), lit = (full ? 1 - sink * 0.65 : 1) * pulse, ghost = 0.35;\n  // The chord now, exactly, between sample k and k + 1.\n  const p = [0, 0, 0], q = [0, 0];\n  at(S, S.u0 + lap * S.arc[K], p);\n  far(S, p[0], p[1], p[2], S.L, q);\n  const sp = S.sp, dx = p[0] + (q[0] - p[0]) * sp, dy = p[1] + (q[1] - p[1]) * sp;\n  // The ring is what lies inside the oval and outside the trace. M marks\n  // the LEDs the a-part has swept so far, quad by quad. With a \u003c b the\n  // a-part can dip a little inside the trace and come back out; that part\n  // counts once forward and once back, so it is no part of the ring.\n  M.fill(0);\n  for (let i = 0; i \u003c (full ? N : k); i++) {\n    const a = i * 4, b = a + 4;\n    tri(M, X[a], X[a + 1], X[a + 2], X[a + 3], X[b + 2], X[b + 3], 2);\n    tri(M, X[a], X[a + 1], X[b + 2], X[b + 3], X[b], X[b + 1], 2);\n  }\n  if (!full) {\n    const a = k * 4;\n    tri(M, X[a], X[a + 1], X[a + 2], X[a + 3], dx, dy, 2);\n    tri(M, X[a], X[a + 1], dx, dy, p[0], p[1], 2);\n  }\n  // The ellipse fills as a sector with the area the ring has so far:\n  // parametric angle 2 A / (a b), which comes to 2 pi as the lap closes.\n  const ea = sp * S.L, eb = S.L - ea, ecx = CX, ecy = S.ey;\n  const swept = full ? S.total : abs(S.area[k] + (S.area[k + 1] - S.area[k]) * fr);\n  const phi = full ? TAU : min(TAU, (2 * swept) / (ea * eb)), a0 = S.ang[0], dir = S.dir;\n  // Row by row, where the oval starts and ends.\n  const xl = S.xl.fill(1e9), xr = S.xr.fill(-1e9);\n  for (let i = 0; i \u003c K; i++) {\n    const j = (i + 1) % K, y0 = S.oy[i], y1 = S.oy[j];\n    for (let y = ceil(min(y0, y1) - 0.5); y \u003c= floor(max(y0, y1) - 0.5); y++) {\n      if (y \u003c 0 || y >= H || y0 === y1) continue;\n      const x = S.ox[i] + ((S.ox[j] - S.ox[i]) * (y + 0.5 - y0)) / (y1 - y0);\n      if (x \u003c xl[y]) xl[y] = x;\n      if (x > xr[y]) xr[y] = x;\n    }\n  }\n  // Where the whole trace crosses each row, for an inside test by parity.\n  const tn = S.tn.fill(0), tx = S.tx;\n  for (let i = 0; i \u003c N; i++) {\n    const x0 = X[i * 4 + 2], y0 = X[i * 4 + 3], x1 = X[i * 4 + 6], y1 = X[i * 4 + 7];\n    for (let y = max(0, ceil(min(y0, y1) - 0.5)); y \u003c= min(H - 1, floor(max(y0, y1) - 0.5)); y++) {\n      const yc = y + 0.5;\n      if (yc >= y0 === yc >= y1 || tn[y] >= 8) continue;\n      tx[y * 8 + tn[y]++] = x0 + ((x1 - x0) * (yc - y0)) / (y1 - y0);\n    }\n  }\n  B.fill(0);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const cov = cl(x + 1 - xl[y], 0, 1) * cl(xr[y] - x, 0, 1);\n      if (cov \u003c= 0) continue;\n      let r = cBase[0], g = cBase[1], b = cBase[2], f = 0, inT = 0;\n      for (let c = 0; c \u003c tn[y]; c++) if (tx[y * 8 + c] \u003c x + 0.5) inT ^= 1;\n      if (!inT) f = M[o] ? lit : ghost;\n      const u = (x + 0.5 - ecx) / ea, v = (y + 0.5 - ecy) / eb;\n      if (u * u + v * v \u003c= 1) {\n        const beta = atan2(v, u);\n        f = (((dir * (beta - a0)) % TAU) + TAU) % TAU \u003c= phi ? lit : ghost;\n      }\n      (r += cFill[0] * f), (g += cFill[1] * f), (b += cFill[2] * f);\n      B[o * 3] = r * cov;\n      B[o * 3 + 1] = g * cov;\n      B[o * 3 + 2] = b * cov;\n    }\n  // The ellipse's rim, faint, and its hand at the parametric angle reached.\n  for (let i = 0; i \u003c 96; i++) {\n    const a1 = (i / 96) * TAU, a2 = ((i + 1) / 96) * TAU;\n    line(B, ecx + ea * cos(a1), ecy + eb * sin(a1), ecx + ea * cos(a2), ecy + eb * sin(a2), cA, 0.45);\n  }\n  const ha = a0 + dir * phi, hx = ecx + ea * cos(ha), hy = ecy + eb * sin(ha);\n  line(B, ecx, ecy, hx, hy, cA, 0.9);\n  // Every eighth chord of the lap so far, faint, and a tail of the last 36\n  // behind the chord, fading.\n  for (let i = 0; i \u003c (full ? N : k); i++) {\n    let al = i % 8 ? 0 : 0.16;\n    if (!full && k - i \u003c 36 && i % 3 === 0) al = max(al, 0.45 * (1 - (k - i) / 36));\n    if (al \u003c= 0) continue;\n    const a = i * 4, px = X[a], py = X[a + 1];\n    line(B, px, py, px + (X[a + 2] - px) / sp, py + (X[a + 3] - py) / sp, cB, al);\n  }\n  // The oval.\n  for (let i = 0; i \u003c K; i++) {\n    const j = (i + 1) % K;\n    line(B, S.ox[i], S.oy[i], S.ox[j], S.oy[j], cOval, 0.95);\n  }\n  // The trace of the split point, as far as the chord has gone.\n  const kk = full ? N : k;\n  for (let i = 0; i \u003c kk; i++) line(B, X[i * 4 + 2], X[i * 4 + 3], X[i * 4 + 6], X[i * 4 + 7], cTrace, 1);\n  if (!full) line(B, X[k * 4 + 2], X[k * 4 + 3], dx, dy, cTrace, 1);\n  // The chord: the a-part in the fill's colour, the b-part white.\n  line(B, p[0], p[1], dx, dy, cA, 1);\n  line(B, dx, dy, q[0], q[1], cB, 1);\n  dot(B, p[0], p[1], 1.6, cB, 1);\n  dot(B, q[0], q[1], 1.6, cB, 1);\n  dot(B, dx, dy, 2, cTrace, 1);\n  dot(B, hx, hy, 1.8, cTrace, 1);\n  for (let i = 0, o = 0; i \u003c W * H; i++, o += 3)\n    display.setPixel(i % W, (i / W) | 0, min(255, B[o] * 255) | 0, min(255, B[o + 1] * 255) | 0, min(255, B[o + 2] * 255) | 0);\n}\n","monge-transport":"// ===== Patternflow pattern =====\n// Title:   Monge Transport\n// Family:  algo\n// Idea:    Particles filling one abstract shape are paired at random with places in another shape in the other half of the panel, the pairing is untangled by swapping the targets of any two particles whose swap shortens the total of |x - y|^p, so the dim target dots sort into the colours of the particles bound for them and the sample rays stop crossing, and then every particle slides along its ray at once and the pile lands as the new shape with its colour wheel rearranged by the map.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the problem of deblais et remblais and its rays that never cross (Gaspard Monge, 1781), the relaxed problem (Leonid Kantorovich, 1942), the quadratic cost and its monotone map (Yann Brenier, 1987), displacement interpolation (Robert McCann, 1997), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Particles=150..400, Exponent=1..2\n//\n// Knob 1: Hue. Turns the colour wheel each pile carries. A particle's hue is its angle round the middle of the shape it starts in and its saturation its distance out, pale at the middle. At 0 the opening lobes run from green and yellow on the left to pink and violet on the right; at 0.5 the wheel is turned half round, blue and violet on the left, yellow and green on the right.\n// Knob 2: Speed. At 2 a round takes 7.5 seconds: 3.5 s of untangling, 2.6 s of travel and 1.4 s at rest while the colours settle into the new shape's own wheel. The opening round untangles in 1.8 s, so the first pile leaves at 1.8 s and lands at 4.4 s. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Particles. 150 to 400 in steps of 25, on a jittered grid that fills 1500 LEDs of each shape, the grid 3.2 LEDs apart at 150 and 1.9 at 400. A random pairing takes about 5 swaps a particle to untangle, 720 at 150 and 1800 at 400.\n// Knob 4: Exponent. p in the cost |x - y|^p. At 1, Monge's own cost, every crossing pair of rays is a swap that shortens the total, so when the untangling ends no two rays cross; many plans cost the same there, and the pile keeps left and right but lands with top and bottom shuffled. Any p above 1, even 1.02, also sorts top to top, and the pile slides over keeping its wheel while about one pair of rays in 60 crosses at a shallow angle. At 2, Brenier's quadratic cost, one pair in 35 crosses, but no two particles are ever in the same place at the same moment.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, atan2, cos, sin, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// LEDs each shape fills, and seconds of each stage at Speed 2.\n// The opening round untangles in T_OPEN, so its pile is moving by 2 seconds.\nconst AREA = 1500, T_U = 3.5, T_M = 2.6, T_R = 1.4, T_OPEN = 1.8;\n// Rays drawn through the untangling and the travel, from particles spread\n// out over the source.\nconst WITNESS = 8;\nconst MAXN = 400;\n// Pair checks of planning a frame.\nconst BUDGET = 50000;\n\n// Filled shapes in a box from -1 to 1 across the half panel.\nconst SHAPES = [\n  (u, v) => u * u + v * v \u003c 0.85, // disk\n  (u, v) => {\n    const r = u * u + v * v;\n    return r > 0.2 && r \u003c 0.85;\n  }, // annulus\n  (u, v) => (u + 0.45) * (u + 0.45) + v * v \u003c 0.27 || (u - 0.45) * (u - 0.45) + v * v \u003c 0.27, // two lobes\n  (u, v) => abs(v) \u003c 0.92 && abs(u) > 0.2 && abs(u) \u003c 0.7, // bar pair\n  (u, v) => v \u003c 0.75 && abs(u) \u003c (0.95 * (v + 0.92)) / 1.67, // triangle\n  (u, v) => (abs(u) \u003c 0.3 && abs(v) \u003c 0.95) || (abs(v) \u003c 0.3 && abs(u) \u003c 0.95), // cross\n  (u, v) => u * u + v * v \u003c 0.92 && (u - 0.5) * (u - 0.5) + v * v > 0.4, // crescent\n  (u, v) => abs(u) + abs(v) \u003c 0.95, // diamond\n  (u, v) => {\n    const m = max(abs(u), abs(v));\n    return m > 0.42 && m \u003c 0.92;\n  }, // square ring\n  (u, v) => sqrt(u * u + v * v) \u003c 0.66 + 0.3 * cos(3 * atan2(v, u)), // trefoil\n];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0, p: -1, g: 3, half: 0, src: 2, dst: 4, rot: 0, dRot: 0, phase: 0, t: 0, tu: T_U, tm: T_M, base: 0, job: 0, turn: false,\n    X: new Float64Array(2 * MAXN), Y: new Float64Array(2 * MAXN), P: new Float64Array(2 * MAXN), F: new Float64Array(2 * MAXN),\n    hue: new Float64Array(MAXN), sat: new Float64Array(MAXN), hue0: new Float64Array(MAXN), sat0: new Float64Array(MAXN),\n    hueTo: new Float64Array(MAXN), satTo: new Float64Array(MAXN),\n    sig: new Int32Array(MAXN), inv: new Int32Array(MAXN), work: new Int32Array(MAXN), ord: new Int32Array(MAXN),\n    C: new Float64Array(MAXN * MAXN),\n    sw: new Int16Array(2 * 60 * MAXN), cross: new Uint8Array(60 * MAXN), gain: new Float32Array(60 * MAXN), K: 0, k: 0,\n    wit: new Int32Array(WITNESS), flash: [], rgb: new Float32Array(W * H * 3), pc: new Float32Array(W * H * 3), pa: new Float32Array(W * H), c: [0, 0, 0],\n  };\n}\n\n// N points of shape kind in the given half: a jittered grid of spacing\n// sqrt(AREA / N), and the shape scaled about the middle of the half until\n// N grid points fall inside it. Extra points from the last step of the\n// scale are dropped at random.\nfunction sample(S, kind, half, rot, out) {\n  const N = S.n, inside = SHAPES[kind], cr = cos(rot), sr = sin(rot);\n  let g = sqrt(AREA / N);\n  for (let tries = 0; tries \u003c 12; tries++, g *= 0.96) {\n    const m = Math.ceil(64 / g) + 2, pts = [];\n    for (let i = 0; i \u003c m; i++)\n      for (let j = 0; j \u003c m; j++) pts.push((i - (m - 1) / 2 + (Math.random() - 0.5) * 0.12) * g, (j - (m - 1) / 2 + (Math.random() - 0.5) * 0.12) * g);\n    // A point must also stay in its half, whatever the turn of the shape.\n    const inAt = (k, s) => {\n      if (abs(pts[k]) > 30.6 || abs(pts[k + 1]) > 30.6) return false;\n      const x = pts[k] / (31 * s), y = pts[k + 1] / (31 * s);\n      return inside(x * cr + y * sr, y * cr - x * sr);\n    };\n    const count = (s) => {\n      let c = 0;\n      for (let k = 0; k \u003c pts.length; k += 2) if (inAt(k, s)) c++;\n      return c;\n    };\n    if (count(1.25) \u003c N) continue;\n    let lo = 0.2, hi = 1.25;\n    for (let it = 0; it \u003c 16; it++) {\n      const s = (lo + hi) / 2;\n      if (count(s) >= N) hi = s;\n      else lo = s;\n    }\n    const keep = [];\n    for (let k = 0; k \u003c pts.length; k += 2) if (inAt(k, hi)) keep.push(k);\n    while (keep.length > N) keep.splice(floor(Math.random() * keep.length), 1);\n    for (let i = 0; i \u003c N; i++) {\n      out[2 * i] = 32 + pts[keep[i]];\n      out[2 * i + 1] = 32 + 64 * half + pts[keep[i] + 1];\n    }\n    S.g = g;\n    return;\n  }\n}\n\n// Each particle's colour from where it sits: hue by angle round the\n// centre of the pile, saturation by distance out.\nfunction wheelOf(S, pos, hue, sat) {\n  const N = S.n;\n  let cx = 0, cy = 0, rm = 0;\n  for (let i = 0; i \u003c N; i++) {\n    cx += pos[2 * i] / N;\n    cy += pos[2 * i + 1] / N;\n  }\n  for (let i = 0; i \u003c N; i++) rm = max(rm, Math.hypot(pos[2 * i] - cx, pos[2 * i + 1] - cy));\n  for (let i = 0; i \u003c N; i++) {\n    const dx = pos[2 * i] - cx, dy = pos[2 * i + 1] - cy;\n    hue[i] = atan2(-dx, -dy) / (2 * PI) + 0.5;\n    sat[i] = 0.25 + 0.75 * pow(Math.hypot(dx, dy) / max(1, rm), 0.8);\n  }\n}\n\n// Untangling. From the pairing now in sig, try pairs of particles and\n// swap the targets of i and j whenever |x_i - y_b|^p + |x_j - y_a|^p is\n// shorter than |x_i - y_a|^p + |x_j - y_b|^p. At p = 1 two crossing rays\n// always qualify, by the triangle inequality at the point where they\n// cross, so the plan that comes out has none. The work runs ahead of what\n// is shown, a budget of pair checks a frame, and the swaps it finds are\n// played back over the stage.\nfunction startPlan(S) {\n  S.work.set(S.sig.subarray(0, S.n));\n  S.K = 0;\n  S.k = 0;\n  S.job = 1;\n  S.jr = 0;\n  S.jpass = 0;\n  S.rng = (Math.random() * 2147483647) | 1;\n}\n\nfunction record(S, i, j, a, b, d) {\n  if (S.K \u003c S.cross.length) {\n    S.sw[2 * S.K] = i;\n    S.sw[2 * S.K + 1] = j;\n    S.gain[S.K] = d;\n    S.cross[S.K] = crosses(S.X, S.Y, i, a, j, b) ? 1 : 0;\n    S.K++;\n  }\n  S.work[i] = b;\n  S.work[j] = a;\n}\n\nfunction newPass(S) {\n  const ord = S.ord;\n  for (let i = 0; i \u003c S.n; i++) ord[i] = i;\n  for (let i = S.n - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = ord[i];\n    ord[i] = ord[j];\n    ord[j] = t;\n  }\n  S.jx = 0;\n  S.jany = false;\n}\n\nfunction work(S, budget) {\n  const N = S.n, C = S.C, X = S.X, Y = S.Y, w = S.work, ord = S.ord, h = S.p / 2;\n  while (budget > 0 && S.job) {\n    if (S.job === 1) {\n      // The costs, a row a step.\n      const i = S.jr;\n      for (let j = 0; j \u003c N; j++) {\n        const dx = X[2 * i] - Y[2 * j], dy = X[2 * i + 1] - Y[2 * j + 1];\n        C[i * N + j] = pow(dx * dx + dy * dy, h);\n      }\n      budget -= N;\n      if (++S.jr === N) {\n        S.job = 2;\n        S.jr = N * N;\n      }\n    } else if (S.job === 2) {\n      // N^2 pairs at random from a xorshift stream, so the swaps play back\n      // spread over the whole pile.\n      let t = min(S.jr, budget), r = S.rng;\n      S.jr -= t;\n      budget -= t;\n      for (; t > 0; t--) {\n        r ^= r \u003c\u003c 13;\n        r ^= r >>> 17;\n        r ^= r \u003c\u003c 5;\n        const i = ((r >>> 16) * N) >>> 16, j = ((r & 0xffff) * N) >>> 16;\n        if (i === j) continue;\n        const a = w[i], b = w[j], d = C[i * N + a] + C[j * N + b] - C[i * N + b] - C[j * N + a];\n        if (d > 1e-9) record(S, i, j, a, b, d);\n      }\n      S.rng = r;\n      if (!S.jr) {\n        S.job = 3;\n        newPass(S);\n      }\n    } else {\n      // Then whole passes over every pair, in a fresh order each time,\n      // until one finds nothing.\n      const x = S.jx, i = ord[x];\n      for (let y = x + 1; y \u003c N; y++) {\n        const j = ord[y], a = w[i], b = w[j], d = C[i * N + a] + C[j * N + b] - C[i * N + b] - C[j * N + a];\n        if (d > 1e-9) {\n          record(S, i, j, a, b, d);\n          S.jany = true;\n        }\n      }\n      budget -= N - x;\n      if (++S.jx >= N - 1) {\n        if (!S.jany || ++S.jpass >= 40) S.job = 0;\n        else newPass(S);\n      }\n    }\n  }\n}\n\nfunction crosses(X, Y, i, a, j, b) {\n  const ax = X[2 * i], ay = X[2 * i + 1], bx = Y[2 * a], by = Y[2 * a + 1];\n  const cx = X[2 * j], cy = X[2 * j + 1], dx = Y[2 * b], dy = Y[2 * b + 1];\n  const o = (px, py, qx, qy, rx, ry) => (qx - px) * (ry - py) - (qy - py) * (rx - px);\n  return o(ax, ay, bx, by, cx, cy) * o(ax, ay, bx, by, dx, dy) \u003c 0 && o(cx, cy, dx, dy, ax, ay) * o(cx, cy, dx, dy, bx, by) \u003c 0;\n}\n\nfunction shuffle(S) {\n  const N = S.n, sig = S.sig;\n  for (let i = 0; i \u003c N; i++) sig[i] = i;\n  for (let i = N - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = sig[i];\n    sig[i] = sig[j];\n    sig[j] = t;\n  }\n  for (let i = 0; i \u003c N; i++) S.inv[sig[i]] = i;\n}\n\n// Rays to draw all the time: particles spread over the source, each the\n// one farthest from those already picked.\nfunction pickWitnesses(S) {\n  const N = S.n, X = S.X, d = new Float64Array(N).fill(1e9);\n  let pick = floor(Math.random() * N);\n  for (let w = 0; w \u003c WITNESS; w++) {\n    S.wit[w] = pick;\n    let best = 0;\n    for (let i = 0; i \u003c N; i++) {\n      d[i] = min(d[i], Math.hypot(X[2 * i] - X[2 * pick], X[2 * i + 1] - X[2 * pick + 1]));\n      if (d[i] > d[best]) best = i;\n    }\n    pick = best;\n  }\n}\n\n// A new round: the pile sits in S.X, the next shape is dealt in the other half.\nfunction deal(S, fresh) {\n  const N = S.n;\n  if (fresh) {\n    sample(S, S.src, S.half, S.rot, S.X);\n    wheelOf(S, S.X, S.hue, S.sat);\n  }\n  sample(S, S.dst, 1 - S.half, S.dRot, S.Y);\n  S.P.set(S.X.subarray(0, 2 * N));\n  shuffle(S);\n  pickWitnesses(S);\n  startPlan(S);\n  S.phase = 0;\n  S.t = 0;\n  S.tu = T_U;\n  S.base = 0;\n  S.flash = [];\n}\n\nconst ease = (u) => 1 - pow(1 - cl(u, 0, 1), 2.2);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 150, 1];\n  const d = cl(dt || 0, 0, 0.1) * (cl(kv[1], 0.2, 3) / 2);\n  S.hueK = cl(kv[0], 0, 1);\n  const n = cl(round(cl(kv[2], 150, 400) / 25) * 25, 150, 400), p = cl(kv[3], 1, 2);\n  if (n !== S.n) {\n    // A new count deals the same two shapes again, with the short\n    // untangling of the opening.\n    S.n = n;\n    S.p = p;\n    deal(S, true);\n    S.tu = T_OPEN;\n  } else if (abs(p - S.p) > 1e-4) {\n    S.p = p;\n    if (S.phase === 0) {\n      // Plan again from the pairing played so far and play the new plan\n      // over what is left of the stage.\n      startPlan(S);\n      S.base = ease(S.t / S.tu);\n    } else if (S.phase === 1) {\n      // Mid flight: plan from where the particles are now, and turn them\n      // towards their new targets once the plan is done.\n      S.X.set(S.P.subarray(0, 2 * S.n));\n      startPlan(S);\n      S.turn = true;\n    }\n  }\n  S.t += d;\n  for (const f of S.flash) f.life -= d;\n  S.flash = S.flash.filter((f) => f.life > 0);\n  const N = S.n;\n  if (S.job) work(S, S.phase === 0 && S.t >= S.tu ? 1e9 : BUDGET);\n  if (S.phase === 0) {\n    // Until the work is done its length is a guess, and nothing it has\n    // not found yet is played.\n    const e = ease(S.t / S.tu), base = S.base || 0, total = S.job ? S.K * 1.15 : S.K;\n    const want = min(S.K, S.t >= S.tu ? S.K : floor((total * (e - base)) / max(1e-6, 1 - base)));\n    const k0 = S.k;\n    applyTo(S, want);\n    // Flash the swap of this frame that took the most off the total,\n    // a crossing one if there is one.\n    let best = -1;\n    for (let k = k0; k \u003c S.k; k++) if (best \u003c 0 || S.cross[k] > S.cross[best] || (S.cross[k] === S.cross[best] && S.gain[k] > S.gain[best])) best = k;\n    if (best >= 0 && S.flash.length \u003c 3) S.flash.push({ i: S.sw[2 * best], j: S.sw[2 * best + 1], life: 0.2 });\n    if (S.t >= S.tu) {\n      S.phase = 1;\n      S.t = 0;\n      S.tm = T_M;\n      S.turn = false;\n      S.F.set(S.X.subarray(0, 2 * N));\n    }\n  } else if (S.phase === 1 && S.turn && !S.job) {\n    applyTo(S, S.K);\n    S.F.set(S.P.subarray(0, 2 * N));\n    S.tm = max(0.8, S.tm - S.t);\n    S.t = 0;\n    S.turn = false;\n  }\n  if (S.phase === 1) {\n    const u = cl(S.t / S.tm, 0, 1), e = u * u * (3 - 2 * u);\n    for (let i = 0; i \u003c N; i++) {\n      const a = S.sig[i];\n      S.P[2 * i] = S.F[2 * i] + (S.Y[2 * a] - S.F[2 * i]) * e;\n      S.P[2 * i + 1] = S.F[2 * i + 1] + (S.Y[2 * a + 1] - S.F[2 * i + 1]) * e;\n    }\n    if (S.t >= S.tm) {\n      S.phase = 2;\n      S.t = 0;\n      // The pile now sits in the new shape; its colours drift to that\n      // shape's own wheel while it rests.\n      for (let i = 0; i \u003c N; i++) {\n        S.X[2 * i] = S.P[2 * i];\n        S.X[2 * i + 1] = S.P[2 * i + 1];\n      }\n      wheelOf(S, S.X, S.hueTo, S.satTo);\n      S.hue0.set(S.hue.subarray(0, N));\n      S.sat0.set(S.sat.subarray(0, N));\n    }\n  } else if (S.phase === 2) {\n    const u = cl(S.t / (T_R * 0.8), 0, 1), e = u * u * (3 - 2 * u);\n    for (let i = 0; i \u003c N; i++) {\n      const dh = S.hueTo[i] - S.hue0[i] - round(S.hueTo[i] - S.hue0[i]);\n      S.hue[i] = S.hue0[i] + dh * e;\n      S.sat[i] = S.sat0[i] + (S.satTo[i] - S.sat0[i]) * e;\n    }\n    if (S.t >= T_R) {\n      // The pile becomes the source; a new shape in the half it left.\n      S.half = 1 - S.half;\n      S.src = S.dst;\n      S.rot = S.dRot;\n      let k = floor(Math.random() * (SHAPES.length - 1));\n      if (k >= S.src) k++;\n      S.dst = k;\n      S.dRot = floor(Math.random() * 8) * (PI / 4);\n      S.base = 0;\n      deal(S, false);\n    }\n  }\n}\n\nfunction applyTo(S, want) {\n  for (; S.k \u003c want; S.k++) {\n    const i = S.sw[2 * S.k], j = S.sw[2 * S.k + 1], a = S.sig[i], b = S.sig[j];\n    S.sig[i] = b;\n    S.sig[j] = a;\n    S.inv[b] = i;\n    S.inv[a] = j;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  const rgb = S.rgb, N = S.n, c = S.c, hk = 0.55 + S.hueK;\n  rgb.fill(0);\n  const add = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += r;\n    rgb[o + 1] += g;\n    rgb[o + 2] += b;\n  };\n  const line = (x0, y0, x1, y1, r, g, b) => {\n    const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n    if (n \u003c 1) return;\n    const steep = abs(y1 - y0) > abs(x1 - x0);\n    for (let s = 0; s \u003c= n; s++) {\n      const f = s / n, x = x0 + (x1 - x0) * f - 0.5, y = y0 + (y1 - y0) * f - 0.5;\n      if (steep) {\n        const xi = floor(x), fx = x - xi, yi = round(y);\n        add(xi, yi, r * (1 - fx), g * (1 - fx), b * (1 - fx));\n        add(xi + 1, yi, r * fx, g * fx, b * fx);\n      } else {\n        const yi = floor(y), fy = y - yi, xi = round(x);\n        add(xi, yi, r * (1 - fy), g * (1 - fy), b * (1 - fy));\n        add(xi, yi + 1, r * fy, g * fy, b * fy);\n      }\n    }\n  };\n  // The targets not yet reached: one dim dot each, in the colour of the\n  // particle meant for it.\n  if (S.phase \u003c 2)\n    for (let j = 0; j \u003c N; j++) {\n      const i = S.inv[j];\n      hsv(S.hue[i] + hk, S.sat[i], 0.55, c);\n      add(floor(S.Y[2 * j]), floor(S.Y[2 * j + 1]), c[0], c[1], c[2]);\n    }\n  // The sample rays, from where each particle is to where it is going.\n  if (S.phase \u003c 2)\n    for (let w = 0; w \u003c WITNESS; w++) {\n      const i = S.wit[w], a = S.sig[i];\n      hsv(S.hue[i] + hk, S.sat[i] * 0.7, 0.26, c);\n      line(S.P[2 * i], S.P[2 * i + 1], S.Y[2 * a], S.Y[2 * a + 1], c[0], c[1], c[2]);\n    }\n  for (const f of S.flash) {\n    const v = 0.75 * (f.life / 0.2);\n    for (const i of [f.i, f.j]) {\n      const a = S.sig[i];\n      line(S.P[2 * i], S.P[2 * i + 1], S.Y[2 * a], S.Y[2 * a + 1], v, v, v);\n      add(floor(S.Y[2 * a]), floor(S.Y[2 * a + 1]), v, v, v);\n    }\n  }\n  // The particles: squares a little wider than the grid. Their colour and\n  // cover add up apart from the rest, so two half-covered LEDs on a seam\n  // make a whole one, and then lie over the dots and rays.\n  const q = (S.g * 1.14) / 2, pc = S.pc, pa = S.pa;\n  pc.fill(0);\n  pa.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    hsv(S.hue[i] + hk, S.sat[i], 1, c);\n    const px = S.P[2 * i], py = S.P[2 * i + 1];\n    for (let y = floor(py - q); y \u003c py + q; y++) {\n      if (y \u003c 0 || y >= H) continue;\n      const cy = min(y + 1, py + q) - max(y, py - q);\n      if (cy \u003c= 0) continue;\n      for (let x = floor(px - q); x \u003c px + q; x++) {\n        if (x \u003c 0 || x >= W) continue;\n        const a = cy * (min(x + 1, px + q) - max(x, px - q));\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        pa[y * W + x] += a;\n        pc[o] += c[0] * a;\n        pc[o + 1] += c[1] * a;\n        pc[o + 2] += c[2] * a;\n      }\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const a = pa[p];\n    if (a \u003c= 0) continue;\n    const k = 1 / max(1, a), b = 1 - min(1, a);\n    rgb[o] = rgb[o] * b + pc[o] * k;\n    rgb[o + 1] = rgb[o + 1] * b + pc[o + 1] * k;\n    rgb[o + 2] = rgb[o + 2] * b + pc[o + 2] * k;\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","paul-trap":"// ===== Patternflow pattern =====\n// Title:   Paul Trap\n// Family:  particle\n// Idea:    Ions in a linear Paul trap whose axis runs the length of the panel repel each other into a Coulomb crystal, a zigzag when the RF is weak, a string of round dots when it is strong and a twisted three-dimensional crystal when more ions crowd in, each ion off the RF null smeared across the axis by its micromotion as a camera sees it, until past q = 0.908 the Mathieu equation has no stable solution and the ions boil out sideways while new ones load at the ends.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Mathieu equation (Émile Mathieu, 1868), the Paul trap (Wolfgang Paul, 1953), structural transitions of ion Coulomb crystals (Daniel Dubin, 1993; John Schiffer, 1993), the critical ratio of the zigzag (Daniel Enzer and others, 2000), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ions=16..40, RF q=0.3..0.95\n//\n// Knob 1: Hue. Turns the fluorescence round the wheel. At 0 the ions are azure with pale cores, the near side of a 3D crystal cyan and the far side blue; at 0.25 violet, at 0.5 rose, at 0.75 green, then cyan back to azure. Orange and yellow are skipped, since they read brown and olive when dim.\n// Knob 2: Speed. At 2 the simulation runs 38 RF periods a second: the oven fills an empty trap with 16 ions in half a second, they settle into a crystal by 1 s, and a knock from the background gas every 4 s or so melts part of it for a moment. At 0.2 ten times slower, so the first seconds show the load; at 3 half as fast again.\n// Knob 3: Ions. 16 to 40 ions, two of them dark impurities that leave gaps. The end caps are set so that a string of that many ions would be 122 rows long. At q = 0.3, 16 ions make a flat zigzag and 20 a zigzag that twists toward the camera; from 28 up the crystal is a spindle of shells, 32 LEDs across and 79 rows tall at 40 ions, with the outer ions drawn as dashes by their micromotion. Enzer's ratio puts the string at q = 0.54 for 16 ions, 0.72 for 20 and 0.86 for 24, but above about 0.7 a crystal with ions off the axis heats itself in the RF and melts in patches, so from 24 up it never lines up cleanly.\n// Knob 4: RF q. The Mathieu q of the drive, 0.3 to 0.95. At 0.3 sixteen ions make a zigzag 10 LEDs across; it narrows as q rises and lines up into a string of round dots between 0.50 and 0.54, which holds to 0.9 with a shiver near the end. At a = 0 nothing is stable past 0.908; the small static field that lays the zigzag flat splits that edge, so past 0.903 the ions fly out toward the camera and past 0.915 sideways, at 0.95 swinging 1.8 times wider every RF period, and the new ions the oven loads at the ends race inward and burst into smears. Turned back, the trap refills and cools into a crystal again, and a quick turn from string to zigzag can freeze in a kink where the zigzag changes sides.\n\nconst W = 64, H = 128, CX = 31.5, CY = 63.5, NMAX = 40;\nconst { floor, min, max, abs, sqrt, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: lengths in LEDs, time tau = Omega t / 2, mass 1. In tau the radial\n// equation is the Mathieu equation x'' + (a - 2 q cos 2 tau) x = F, and one\n// RF period is pi. The step is a fortieth of it; velocity Verlet at that\n// step puts the edge of stability at q = 0.9074 instead of 0.9081. With a\n// twentieth the edge was 0.905 and a string of 16 ions melted at q = 0.9.\n// RATE is tau per second at Speed 1.\nconst DT = PI / 40, RATE = 60;\n// Half the length of a string of N ions in a harmonic well, for a Coulomb\n// constant and an axial frequency of 1, from a relaxation run at N = 12, 16\n// ... 48. The axial frequency for N ions is then chosen so that the string\n// would reach SPAN LEDs either side of the centre.\nconst HALF = [3.2187, 3.8175, 4.3281, 4.7778, 5.1825, 5.5522, 5.8939, 6.2125, 6.5141, 6.7941];\nconst SPAN = 61;\n// The Coulomb constant, in LED^3 / tau^2. With it the axial frequency for\n// 16 ions is 0.050, and Enzer's critical ratio of radial to axial frequency,\n// 0.73 N^0.86 = 7.9, asks for a radial frequency of 0.40, which the RF gives\n// at q = 0.54. The simulated crystal straightens between 0.50 and 0.54.\nconst KC = 10.2;\n// A small static quadrupole, a = -0.007 across the panel and +0.007 toward\n// the camera, makes the picture plane the weaker radial direction, so the\n// zigzag lies flat across the panel. At 0.005 it twisted out of the plane.\nconst AS = 0.007;\n// Doppler cooling damps every bright ion's velocity at GAMMA per tau, and\n// the recoil of the scattered photons heats it toward TEMP. The dark ions\n// scatter nothing and are cooled only through their neighbours.\nconst GAMMA = 0.05, TEMP = 0.0012;\n// Background gas: one ion takes a hard knock every COLL tau on average, 4.2 s\n// at Speed 2, and the crystal melts round it and freezes again. An ion\n// RLOST from the axis has reached an electrode. While the trap holds fewer\n// ions than it should, the oven loads one every LOAD tau, at alternate ends.\nconst COLL = 500, KICK = 5, RLOST = 38, LOAD = 4;\n\n// A gamma of 0.75 on the way out lifts the faint smears of hot ions.\nconst GAMMA_LUT = new Uint8Array(1024);\nfor (let i = 0; i \u003c 1024; i++) GAMMA_LUT[i] = Math.round(255 * (i / 1023) ** 0.75);\n\nfunction halfOf(n) {\n  const f = cl((n - 12) / 4, 0, HALF.length - 1.001), i = floor(f);\n  return HALF[i] + (HALF[i + 1] - HALF[i]) * (f - i);\n}\n\n// The fluorescence colour, hue h in turns, with orange and yellow (0.03\n// to 0.2) skipped since they read brown and olive when dim.\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 0.83;\n  if (h >= 0.03) h += 0.17;\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nconst gauss = () => {\n  let u = 1 - Math.random();\n  return sqrt(-2 * Math.log(u)) * cos(2 * PI * Math.random());\n};\n\nexport function setup(params) {\n  const S = (params.s = {\n    n: 0, target: 16, q: 0.3, tau: 0, wz: 0.047, ws: 0.047, nextColl: COLL, loadAt: 0, end: 1,\n    x: new Float64Array(NMAX), y: new Float64Array(NMAX), z: new Float64Array(NMAX),\n    vx: new Float64Array(NMAX), vy: new Float64Array(NMAX), vz: new Float64Array(NMAX),\n    ax: new Float64Array(NMAX), ay: new Float64Array(NMAX), az: new Float64Array(NMAX),\n    dark: new Uint8Array(NMAX),\n    // Per frame sums of each ion's position, the camera's exposure.\n    sx: new Float64Array(NMAX), sxx: new Float64Array(NMAX), sy: new Float64Array(NMAX), syy: new Float64Array(NMAX),\n    sz: new Float64Array(NMAX), sn: new Float64Array(NMAX),\n    rgb: new Float32Array(W * H * 3), gx: new Float32Array(W), hx: new Float32Array(W), gy: new Float32Array(H), hy: new Float32Array(H),\n    hue: 0, c: [0, 0, 0], w: [0, 0, 0], started: false, loaded: 0, darkSet: false,\n  });\n  return S;\n}\n\nfunction axialFor(n) {\n  return sqrt(KC) * (halfOf(n) / SPAN) ** 1.5;\n}\n\nfunction addIon(S, y, hot, dark) {\n  const i = S.n++;\n  S.x[i] = gauss() * hot;\n  S.z[i] = gauss() * hot;\n  S.y[i] = y;\n  const v = hot * 0.06;\n  S.vx[i] = gauss() * v;\n  S.vz[i] = gauss() * v;\n  S.vy[i] = gauss() * v;\n  S.dark[i] = dark ? 1 : 0;\n  S.sx[i] = S.sxx[i] = S.sy[i] = S.syy[i] = S.sz[i] = S.sn[i] = 0;\n  return i;\n}\n\nfunction removeIon(S, i) {\n  const j = --S.n;\n  if (i === j) return;\n  for (const a of [S.x, S.y, S.z, S.vx, S.vy, S.vz, S.ax, S.ay, S.az, S.dark, S.sx, S.sxx, S.sy, S.syy, S.sz, S.sn]) a[i] = a[j];\n}\n\nfunction darkCount(S) {\n  let d = 0;\n  for (let i = 0; i \u003c S.n; i++) d += S.dark[i];\n  return d;\n}\n\n// The acceleration of every ion at phase tau.\nfunction forces(S, tau) {\n  const n = S.n, x = S.x, y = S.y, z = S.z, ax = S.ax, ay = S.ay, az = S.az;\n  const rf = 2 * S.q * cos(2 * tau), w2 = S.wz * S.wz;\n  const kx = -w2 / 2 - AS - rf, kz = -w2 / 2 + AS + rf;\n  for (let i = 0; i \u003c n; i++) {\n    ax[i] = -kx * x[i];\n    az[i] = -kz * z[i];\n    ay[i] = -w2 * y[i];\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const xi = x[i], yi = y[i], zi = z[i];\n    let fx = 0, fy = 0, fz = 0;\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = xi - x[j], dy = yi - y[j], dz = zi - z[j];\n      const r2 = dx * dx + dy * dy + dz * dz + 0.05, f = KC / (r2 * sqrt(r2));\n      fx += f * dx;\n      fy += f * dy;\n      fz += f * dz;\n      ax[j] -= f * dx;\n      ay[j] -= f * dy;\n      az[j] -= f * dz;\n    }\n    ax[i] += fx;\n    ay[i] += fy;\n    az[i] += fz;\n  }\n}\n\nfunction step(S) {\n  const n = S.n, h = DT;\n  for (let i = 0; i \u003c n; i++) {\n    S.vx[i] += 0.5 * h * S.ax[i];\n    S.vy[i] += 0.5 * h * S.ay[i];\n    S.vz[i] += 0.5 * h * S.az[i];\n    S.x[i] += h * S.vx[i];\n    S.y[i] += h * S.vy[i];\n    S.z[i] += h * S.vz[i];\n  }\n  S.tau += h;\n  forces(S, S.tau);\n  const kick = sqrt(2 * GAMMA * TEMP * h);\n  for (let i = 0; i \u003c n; i++) {\n    S.vx[i] += 0.5 * h * S.ax[i];\n    S.vy[i] += 0.5 * h * S.ay[i];\n    S.vz[i] += 0.5 * h * S.az[i];\n    if (S.dark[i]) continue;\n    // Doppler cooling and the recoil of the scattered photons.\n    const g = 1 - GAMMA * h;\n    S.vx[i] = S.vx[i] * g + kick * (Math.random() - 0.5) * 3.46;\n    S.vy[i] = S.vy[i] * g + kick * (Math.random() - 0.5) * 3.46;\n    S.vz[i] = S.vz[i] * g + kick * (Math.random() - 0.5) * 3.46;\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    S.sx[i] += S.x[i];\n    S.sxx[i] += S.x[i] * S.x[i];\n    S.sy[i] += S.y[i];\n    S.syy[i] += S.y[i] * S.y[i];\n    S.sz[i] += S.z[i];\n    S.sn[i]++;\n  }\n}\n\nexport function update(dt, input, params) {\n  const S = params.s || setup(params);\n  const kv = input.knobValues || [0, 2, 16, 0.3], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0] || 0;\n  const speed = cl(kv[1], 0.2, 3);\n  S.target = cl(Math.round(kv[2]), 16, NMAX);\n  S.q = cl(kv[3], 0.3, 0.95);\n  if (!S.started) {\n    // The trap opens empty and the oven fills it from the ends.\n    S.started = true;\n    S.wz = S.ws = axialFor(S.target);\n  }\n  // The end caps follow the ion count with a time constant of 40 tau.\n  S.ws = axialFor(S.target);\n  for (let i = 0; i \u003c S.n; i++) S.sx[i] = S.sxx[i] = S.sy[i] = S.syy[i] = S.sz[i] = S.sn[i] = 0;\n  const steps = min(120, Math.round((d * speed * RATE) / DT));\n  for (let k = 0; k \u003c steps; k++) {\n    S.wz += (S.ws - S.wz) * 0.002;\n    step(S);\n    // Losses: an ion that has reached an electrode or left past an end cap.\n    for (let i = S.n - 1; i >= 0; i--)\n      if (S.x[i] * S.x[i] + S.z[i] * S.z[i] > RLOST * RLOST || abs(S.y[i]) > 90 || !(abs(S.x[i]) \u003c 1e6)) {\n        removeIon(S, i);\n        if (S.loadAt \u003c S.tau) S.loadAt = S.tau + LOAD;\n      }\n    if (S.n > S.target && S.tau > S.loadAt) {\n      // Fewer ions wanted: the end cap opens for the outermost one.\n      let o = 0;\n      for (let i = 1; i \u003c S.n; i++) if (abs(S.y[i]) > abs(S.y[o])) o = i;\n      removeIon(S, o);\n      S.loadAt = S.tau + LOAD * 0.5;\n    } else if (S.n \u003c S.target && S.tau > S.loadAt) {\n      // An atom is ionised on the axis at one end and comes in at 0.6 LEDs\n      // per tau. After a loss a new ion is dark one time in ten while the\n      // crystal holds fewer than two.\n      S.end = -S.end;\n      const dk = S.loaded >= S.target && darkCount(S) \u003c 2 && Math.random() \u003c 0.1;\n      S.loaded++;\n      const i = addIon(S, S.end * (SPAN * 0.95), 0.1, dk);\n      S.vy[i] = -S.end * 0.6;\n      S.loadAt = S.tau + LOAD;\n    }\n    // When the first load is in, the two ions nearest two fifths of the way\n    // up and two fifths of the way down go dark, as after a reaction with the\n    // background gas, so the gaps open inside the crystal.\n    if (!S.darkSet && S.n === S.target) {\n      S.darkSet = true;\n      for (const yd of [-0.4 * SPAN, 0.4 * SPAN]) {\n        let b = 0;\n        for (let i = 1; i \u003c S.n; i++) if (abs(S.y[i] - yd) \u003c abs(S.y[b] - yd)) b = i;\n        S.dark[b] = 1;\n      }\n    }\n    if (S.tau > S.nextColl) {\n      S.nextColl = S.tau - COLL * Math.log(1 - Math.random());\n      if (S.n) {\n        const i = floor(Math.random() * S.n);\n        const ux = gauss(), uy = gauss(), uz = gauss(), u = sqrt(ux * ux + uy * uy + uz * uz) || 1;\n        S.vx[i] += (KICK * ux) / u;\n        S.vy[i] += (KICK * uy) / u;\n        S.vz[i] += (KICK * uz) / u;\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, gx = S.gx, hx = S.hx, gy = S.gy, hy = S.hy, c = S.c, w = S.w, q = S.q;\n  // Each frame keeps 40% of the last one, an exposure a little longer than a frame.\n  for (let o = 0; o \u003c rgb.length; o++) rgb[o] *= 0.4;\n  for (let i = 0; i \u003c S.n; i++) {\n    if (S.dark[i] || !S.sn[i]) continue;\n    const n = S.sn[i], mx = S.sx[i] / n, my = S.sy[i] / n, mz = S.sz[i] / n;\n    // The spread over the exposure: secular motion as measured, and at\n    // least the micromotion an ion at mx has, amplitude q mx / 2.\n    const mm = (q * mx) / 2;\n    const vxx = max(S.sxx[i] / n - mx * mx, (mm * mm) / 2), vyy = max(0, S.syy[i] / n - my * my);\n    // Depth: toward the camera is brighter, bigger and paler.\n    const dz = cl(mz / 10, -1, 1);\n    const s0 = 0.8 + 0.18 * dz, sh = 3.3 + 0.5 * dz;\n    const sx = sqrt(s0 * s0 + vxx), sy = sqrt(s0 * s0 + vyy), tx = sqrt(sh * sh + vxx), ty = sqrt(sh * sh + vyy);\n    const spread = (s0 * s0) / (sx * sy);\n    const lum = (0.72 + 0.28 * dz) * spread ** 0.25;\n    hsv(0.46 + S.hue - 0.05 * dz, 0.85, 1, c);\n    hsv(0.46 + S.hue - 0.05 * dz, 0.3 - 0.15 * dz, 1, w);\n    const px = mx + CX, py = my + CY;\n    const x0 = max(0, floor(px - 3 * tx)), x1 = min(W - 1, Math.ceil(px + 3 * tx));\n    const y0 = max(0, floor(py - 3 * ty)), y1 = min(H - 1, Math.ceil(py + 3 * ty));\n    if (x0 > x1 || y0 > y1) continue;\n    for (let X = x0; X \u003c= x1; X++) {\n      const e = X - px;\n      gx[X] = exp((-e * e) / (2 * sx * sx));\n      hx[X] = exp((-e * e) / (2 * tx * tx));\n    }\n    for (let Y = y0; Y \u003c= y1; Y++) {\n      const e = Y - py;\n      gy[Y] = exp((-e * e) / (2 * sy * sy));\n      hy[Y] = exp((-e * e) / (2 * ty * ty));\n    }\n    const A = 0.75 * lum, B = 0.21 * lum;\n    for (let Y = y0; Y \u003c= y1; Y++)\n      for (let X = x0; X \u003c= x1; X++) {\n        const core = A * gx[X] * gy[Y], halo = B * hx[X] * hy[Y], o = (Y * W + X) * 3;\n        rgb[o] += core * w[0] + halo * c[0];\n        rgb[o + 1] += core * w[1] + halo * c[1];\n        rgb[o + 2] += core * w[2] + halo * c[2];\n      }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, GAMMA_LUT[min(1023, (rgb[o] * 1023) | 0)], GAMMA_LUT[min(1023, (rgb[o + 1] * 1023) | 0)], GAMMA_LUT[min(1023, (rgb[o + 2] * 1023) | 0)]);\n}\n","taylor-unmixing":"// ===== Patternflow pattern =====\n// Title:   Taylor Unmixing\n// Family:  sim\n// Idea:    Round drops of dye in a very viscous fluid between two walls are sheared by plane Couette flow into thin streaks that wrap round the panel many times and lay down a fine slanted lattice of colours, then the walls run back the same distance and the drops come back where they started, sharp when there is no diffusion and as fainter vertical smears when there is.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: plane Couette flow (Maurice Couette, 1890), shear dispersion (G. I. Taylor, 1953), kinematic reversibility of Stokes flow shown with dye in glycerine (G. I. Taylor, film \"Low Reynolds Number Flows\", 1966), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Turns=2..8, Diffusion=0..1\n//\n// Knob 1: Hue. Moves the seven dyes round the wheel together. At 0 they are lime, green, cyan, azure, blue, violet and pink; the seven sit evenly round the wheel, so every 1/7 of the knob the same set comes back with the colours handed on, and in between one dye passes through red. The wheel skips orange and yellow, which read brown and olive where a streak thins out.\n// Knob 2: Speed. At 2 one cycle takes 10.4 seconds: 0.8 s at rest, 3.4 s of shearing, 0.6 s held, 3.4 s back, 1.4 s with the drops returned and 0.8 s while they fade and fresh drops take their place. At 0.2 it takes 104 s, at 3 it takes 6.9 s. Diffusion runs on the same clock, so Speed does not change how blurred the drops come back.\n// Knob 3: Turns. How far each wall travels before it turns back, in panel heights: 2 to 8, so 256 to 1024 rows, the two walls going opposite ways. At 2 the shear across the 60 columns of fluid reaches 8.5, a drop 29 columns wide becomes a streak 247 rows long that wraps the panel almost twice, and its lines lie 15 columns apart; at 5 the shear reaches 21 and the lines 6 apart; at 8 it reaches 34, a drop wraps the panel 7.7 times and its lines lie 3.8 columns apart. The travel follows the knob over about half a second.\n// Knob 4: Diffusion. The dye's diffusivity D = 0.6 k^3 LEDs squared per second. At 0 the drops return exactly, and at the opening 0.06 (D = 0.00013) they look the same. At 0.5 (D = 0.075) a drop comes back 1.4 times as tall at 2 turns and 4.6 times as tall at 8; at 1 (D = 0.6) 2.8 and 10 times as tall, with a third and a tenth of its brightness, and at 8 turns the dye has mixed into soft columns. The streaks blur first: at 8 turns a streak is 0.2 LED thick and diffusion crosses that almost at once, which is why a little D spoils the return.\n\nconst W = 64, H = 128, FL = 2, FR = 62, WF = FR - FL;\nconst { floor, ceil, min, max, abs, sqrt, exp, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\n// The phases of one cycle, in seconds at Speed 2.\nconst T_REST = 0.8, T_FWD = 3.4, T_HOLD = 0.6, T_BACK = 3.4, T_BACKREST = 1.4, T_SWAP = 0.8;\nconst T_CYCLE = T_REST + T_FWD + T_HOLD + T_BACK + T_BACKREST + T_SWAP;\n// The film opens in the middle of the forward stroke, so the first second is\n// already streaks and the drops come back at 4.9 s.\nconst T_OPEN = T_REST + 0.75 * T_FWD;\nconst NB = 7;\n// Each pixel is read as a small Gaussian of this variance, so a streak\n// thinner than an LED dims in proportion instead of flickering.\nconst PIX = 0.1;\n// Dye hues skip orange to lime: wheel(h) runs lime, green, cyan, blue, violet, pink, red.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Wall travel S at cycle time tau, as a fraction of the full travel.\nfunction travel(tau) {\n  if (tau \u003c T_REST) return 0;\n  tau -= T_REST;\n  if (tau \u003c T_FWD) return (1 - cos((PI * tau) / T_FWD)) / 2;\n  tau -= T_FWD;\n  if (tau \u003c T_HOLD) return 1;\n  tau -= T_HOLD;\n  if (tau \u003c T_BACK) return (1 + cos((PI * tau) / T_BACK)) / 2;\n  return 0;\n}\n\n// A fresh set of drops: seven rows down the panel, each in one of three\n// lanes across it, no two neighbours in the same lane.\nfunction drops() {\n  const set = [], hues = [0, 1, 2, 3, 4, 5, 6];\n  for (let i = NB - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = hues[i];\n    hues[i] = hues[j];\n    hues[j] = t;\n  }\n  const lanes = [13, 30, 47];\n  let lane = floor(Math.random() * 3);\n  const y0 = Math.random() * H;\n  for (let i = 0; i \u003c NB; i++) {\n    lane = (lane + 1 + floor(Math.random() * 2)) % 3;\n    const s = 5 + Math.random() * 1.6;\n    set.push({\n      x: lanes[lane] + (Math.random() - 0.5) * 5,\n      y: y0 + (i * H) / NB + (Math.random() - 0.5) * 4,\n      s0: s * s, sxx: s * s, sxy: 0, syy: s * s, hue: hues[i] / NB,\n    });\n  }\n  return set;\n}\n\n// One step of the covariance under a shear g = dGamma over a time h with\n// diffusivity D. For a shear rate constant over the step this is exact:\n// Sigma' = F Sigma F^T + 2 D integral of F(s) F(s)^T, F = [[1, 0], [g, 1]].\nfunction shearStep(b, g, h, D) {\n  const sxx = b.sxx, sxy = b.sxy, syy = b.syy;\n  b.syy = syy + 2 * g * sxy + g * g * sxx + 2 * D * (h + (g * g * h) / 3);\n  b.sxy = sxy + g * sxx + D * g * h;\n  b.sxx = sxx + 2 * D * h;\n}\n\nexport function setup(params) {\n  params.s = {\n    tau: -1, smax: 0, S: 0, Sprev: 0, set: drops(), old: null,\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0], hue: 0,\n  };\n}\n\nfunction advance(S, dtau, D) {\n  // Small steps, so the drops keep up with the walls at full speed.\n  const n = max(1, ceil(dtau / 0.02));\n  for (let k = 0; k \u003c n; k++) {\n    const t0 = S.tau, t1 = S.tau + dtau / n;\n    const cyc = floor(t1 / T_CYCLE) > floor(t0 / T_CYCLE);\n    const s1 = (cyc ? 0 : travel(t1 - floor(t1 / T_CYCLE) * T_CYCLE)) * S.smax;\n    // The strain is taken from the travel actually made, so the total comes\n    // back to exactly 0 with the walls even if Turns moved on the way.\n    const g = (2 * (s1 - S.S)) / WF, h = t1 - t0;\n    for (const b of S.set) shearStep(b, g, h, D);\n    if (S.old) for (const b of S.old) shearStep(b, 0, h, D);\n    S.tau = t1;\n    S.S = s1;\n    // The swap: the returned drops fade out while new ones are laid down.\n    const ph = S.tau - floor(S.tau / T_CYCLE) * T_CYCLE;\n    if (!S.old && ph >= T_CYCLE - T_SWAP) {\n      S.old = S.set;\n      S.set = drops();\n    }\n    if (cyc) S.old = null;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), turns = cl(kv[2], 2, 8), k4 = cl(kv[3], 0, 1);\n  const D = 0.6 * k4 * k4 * k4;\n  S.Sprev = S.S;\n  if (S.tau \u003c 0) {\n    // First frame: run the cycle from its start to the opening point, so\n    // the streaks carry the diffusion they would have gathered.\n    S.smax = turns * H;\n    S.tau = 0;\n    advance(S, T_OPEN, D);\n    S.Sprev = S.S;\n    return;\n  }\n  // The travel follows the knob over about half a second, so the walls\n  // never jump. The drops still come home, because S returns to 0.\n  S.smax += (turns * H - S.smax) * min(1, d * 2.5);\n  advance(S, (d * speed) / 2, D);\n}\n\nfunction drawSet(S, set, fade) {\n  const rgb = S.rgb, c = S.c;\n  for (const b of set) {\n    const cx = b.x, cy = b.y + (2 * b.x / WF - 1) * S.S;\n    const sxx = b.sxx + PIX, sxy = b.sxy, syy = b.syy + PIX;\n    const det = sxx * syy - sxy * sxy, det0 = (b.s0 + PIX) * (b.s0 + PIX);\n    // Dye is conserved: the peak falls as the patch spreads.\n    const amp = sqrt(det0 / det) * fade;\n    const v = det / sxx, sv = sqrt(v), slope = sxy / sxx;\n    const R = min(H * 2, ceil(4.2 * sv));\n    hsv(wheel(b.hue + S.hue), 0.85, 1, c);\n    for (let col = FL; col \u003c FR; col++) {\n      const dx = col - FL + 0.5 - cx, wx = amp * exp((-0.5 * dx * dx) / sxx);\n      if (wx \u003c 0.004) continue;\n      let mu = cy + slope * dx - 0.5;\n      mu -= floor(mu / H) * H;\n      const r0 = floor(mu) - R;\n      // Gaussian down the column by recurrence: g(j+1) = g(j) e1, e1 *= e2.\n      let dy = r0 - mu, g = wx * exp((-0.5 * dy * dy) / v), e1 = exp(-(2 * dy + 1) / (2 * v));\n      const e2 = exp(-1 / v);\n      for (let r = r0; r \u003c= r0 + 2 * R + 1; r++) {\n        if (g > 0.003) {\n          const o = ((((r % H) + H) % H) * W + col) * 3;\n          rgb[o] += c[0] * g;\n          rgb[o + 1] += c[1] * g;\n          rgb[o + 2] += c[2] * g;\n        }\n        g *= e1;\n        e1 *= e2;\n      }\n    }\n  }\n}\n\nfunction rings(S, set, w) {\n  if (w \u003c 0.01) return;\n  const rgb = S.rgb, c = S.c;\n  for (const b of set) {\n    const r = 2.3 * sqrt(b.s0);\n    hsv(wheel(b.hue + S.hue), 0.6, 1, c);\n    for (let yy = floor(b.y - r - 2); yy \u003c= b.y + r + 2; yy++)\n      for (let xx = max(FL, floor(FL + b.x - r - 2)); xx \u003c= min(FR - 1, FL + b.x + r + 2); xx++) {\n        const dx = xx - FL + 0.5 - b.x, dy = yy + 0.5 - b.y, e = abs(sqrt(dx * dx + dy * dy) - r);\n        if (e >= 0.9) continue;\n        const v = 0.16 * w * (1 - e / 0.9), o = ((((yy % H) + H) % H) * W + xx) * 3;\n        rgb[o] += c[0] * v;\n        rgb[o + 1] += c[1] * v;\n        rgb[o + 2] += c[2] * v;\n      }\n  }\n}\n\n// Wall ticks: one every 8 rows, a longer brighter one every 32, carried by\n// the wall and smeared over the frame's travel.\nfunction tick(y) {\n  const m = y - floor(y / 32) * 32, u = m - floor(m / 8) * 8;\n  const big = m \u003c 8;\n  return cl(1 - abs(u - (big ? 1.5 : 1)) / (big ? 1.8 : 1.1), 0, 1) * (big ? 1 : 0.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  // The dark fluid.\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    rgb[o] = 0.008;\n    rgb[o + 1] = 0.015;\n    rgb[o + 2] = 0.034;\n  }\n  const ph = S.tau - floor(S.tau / T_CYCLE) * T_CYCLE;\n  // The swap: the returned drops fade out, then the fresh ones fade in.\n  const u = S.old ? cl((ph - (T_CYCLE - T_SWAP)) / T_SWAP, 0, 1) : 1;\n  const fo = 1 - sm(u / 0.5), fn = sm((u - 0.4) / 0.6);\n  if (S.old) drawSet(S, S.old, fo);\n  drawSet(S, S.set, fn);\n  // Where each drop started, as a faint ring at 2.3 sigma, the edge the\n  // drop shows at. It comes up over the last 40% of the way back and goes\n  // in the first 30% of the next stroke.\n  let ring = 0;\n  if (ph \u003c T_REST) ring = 1;\n  else if (ph \u003c T_REST + 0.3 * T_FWD) ring = 1 - (ph - T_REST) / (0.3 * T_FWD);\n  else if (ph > T_REST + T_FWD + T_HOLD + 0.6 * T_BACK) ring = min(1, (ph - (T_REST + T_FWD + T_HOLD + 0.6 * T_BACK)) / (0.4 * T_BACK));\n  if (S.old) rings(S, S.old, ring * fo);\n  rings(S, S.set, ring * fn);\n  // The walls: left moves by -S, right by +S.\n  const wc = hsv(0.6 + S.hue * 0.2, 0.2, 1, [0, 0, 0]);\n  const ds = S.S - S.Sprev, n = min(40, max(1, ceil(abs(ds) * 1.5)));\n  for (let r = 0; r \u003c H; r++) {\n    let tl = 0, tr = 0;\n    for (let k = 0; k \u003c n; k++) {\n      const s = S.Sprev + (ds * (k + 0.5)) / n;\n      tl += tick(r + 0.5 + s);\n      tr += tick(r + 0.5 - s);\n    }\n    tl /= n;\n    tr /= n;\n    for (const [x, t] of [[0, tl], [1, tl], [62, tr], [63, tr]]) {\n      const o = (r * W + x) * 3, v = 0.16 + 0.95 * t;\n      rgb[o] = wc[0] * v;\n      rgb[o + 1] = wc[1] * v;\n      rgb[o + 2] = wc[2] * v;\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const x = p % W, y = (p / W) | 0;\n    if (x \u003c FL || x >= FR) display.setPixel(x, y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n    else display.setPixel(x, y, (255 * (1 - exp(-2.2 * rgb[o]))) | 0, (255 * (1 - exp(-2.2 * rgb[o + 1]))) | 0, (255 * (1 - exp(-2.2 * rgb[o + 2]))) | 0);\n  }\n}\n","thomson-kink":"// ===== Patternflow pattern =====\n// Title:   Thomson Kink\n// Family:  wave\n// Idea:    A charge runs up and down the middle of the panel and keeps reversing or stopping dead, every change sends out a sphere of news at the speed of light, and each field line is a chain of straight spokes, each aimed at where the charge would now be had it kept the velocity it had between two changes, joined by bright sideways kinks across the expanding shells.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: field of a uniformly moving charge (Oliver Heaviside, 1888), radiation as a kink in the field lines (J. J. Thomson, 1904), Purcell's drawing of the kink (Edward Purcell, 1965), pattern round 61\n// Round:   61\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=12..32, Velocity=0.3..0.9\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the regions where the news says the charge is moving down are blue, moving up green and standing still near black, the shells and kinks rose and the spokes white; at 0.25 the regions are violet and teal with aqua kinks, at 0.5 green and blue with cyan-blue kinks. The wheel runs from green to magenta and skips red, orange and lime, which read maroon, brown and olive when dim.\n// Knob 2: Speed. 2 is real time with light at 36 LEDs a second, so a shell born in the middle reaches the top and bottom rows in 1.8 s while the charge changes its mind every 0.32 to 0.6 s, and four or five shells are out at once; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Lines. 12 to 32 field lines, an even number, spaced evenly in the angle they would have round a charge at rest: every 30 degrees at 12, every 15 at 24, every 11 at 32. Each keeps that label in every region, so it stays one line through all the kinks.\n// Knob 4: Velocity. The charge's speed as a fraction of light, 0.3 to 0.9. At 0.3 the charge moves 11 LEDs a second, and a reversal puts the two pieces of the 75 degree line 18 LEDs apart along a shell 30 LEDs out; at 0.6 the kink of the 75 degree line runs 72 degrees round its shell and the shells read as rings; at 0.9 the charge moves 32 LEDs a second, gamma is 2.3, the spokes crowd towards the horizontal, each shell is a bright ring of lines running along it and the shells pile up in front of the charge. A new speed starts at the charge's next change and spreads out with the news.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Light in LEDs per second of the simulation, the axis the charge runs\n// on, and how far it may stray from the middle row.\nconst C = 36, XC = 32, YC = 64, ROAM = 36;\n// The kink shell's thickness in LEDs: the change takes 2.2 / 36 = 0.06 s.\nconst SHELL = 2.2;\n// A shell is forgotten once it is wider than this; no LED is that far from\n// any place the charge has been.\nconst RFORGET = 125;\n// Seconds between changes, and the share of changes that stop the charge.\nconst GAP0 = 0.32, GAP1 = 0.6, STOP = 0.3;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel from green through blue and violet to\n// magenta, which skips red, orange and lime: dim, they read maroon, brown\n// and olive.\nconst wheel = (h) => 0.3 + 0.56 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    T: 0, ready: false, beta: 0.3, hue: 0, n: 12,\n    // The changes, oldest first: time, the row where it happened, and the\n    // velocity after it, in LEDs a second (positive is down the panel).\n    ch: [], u0: 0, next: 0,\n    acc: new Float32Array(W * H * 3),\n    col: [[0, 0, 0], [0, 0, 0], [0, 0, 0]], kc: [0, 0, 0], lc: [0, 0, 0], sc: [0, 0, 0], c: [0, 0, 0],\n    sh: [],\n  };\n}\n\n// Where the charge is at time t, from the last change before it.\nfunction posAt(S, t) {\n  const ch = S.ch;\n  for (let i = ch.length - 1; i >= 0; i--) if (ch[i].t \u003c= t) return ch[i].p + ch[i].u * (t - ch[i].t);\n  return YC + S.u0 * (t - (ch.length ? ch[0].t : t));\n}\nconst velAt = (S) => (S.ch.length ? S.ch[S.ch.length - 1].u : S.u0);\n\n// The charge changes its mind at time t: it reverses, or stops dead, or\n// sets off again, now with the knob's speed. A change that would carry it\n// past the end of its run turns it round instead.\nfunction change(S, t) {\n  const y = posAt(S, t), u = velAt(S), v = S.beta * C;\n  const gap = GAP0 + (GAP1 - GAP0) * Math.random();\n  let nu;\n  if (u !== 0) nu = Math.random() \u003c STOP ? 0 : -Math.sign(u) * v;\n  else nu = (Math.random() \u003c 0.7 ? (y \u003c YC ? 1 : -1) : y \u003c YC ? -1 : 1) * v;\n  if (abs(y + nu * gap - YC) > ROAM) nu = y + nu * gap > YC ? -v : v;\n  if (u === 0 && nu === 0) nu = v;\n  S.ch.push({ t, p: y, u: nu });\n  S.next = t + gap;\n}\n\nfunction advance(S, T) {\n  while (S.next \u003c= T) change(S, S.next);\n  // Forget the shells that have left the panel, and with them the\n  // velocity the charge had before them.\n  while (S.ch.length > 1 && C * (T - S.ch[0].t) > RFORGET) S.u0 = S.ch.shift().u;\n  S.T = T;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 12, 0.3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.n = 2 * Math.round(cl(kv[2], 12, 32) / 2);\n  S.beta = cl(kv[3], 0.3, 0.9);\n  if (!S.ready) {\n    // The first frame starts the charge 4 s in the past, so the panel\n    // opens full of shells.\n    S.ready = true;\n    S.u0 = S.beta * C;\n    S.ch = [];\n    S.next = -4;\n    advance(S, 0);\n  }\n  advance(S, S.T + (d * speed) / 2);\n}\n\n// The far end of a ray from s (inside the sphere) along unit d where it\n// leaves the sphere of centre (XC, cy) and radius r, as a distance.\nfunction exitRay(sx, sy, dx, dy, cy, r) {\n  const ox = sx - XC, oy = sy - cy, b = ox * dx + oy * dy, c = ox * ox + oy * oy - r * r;\n  return -b + sqrt(max(0, b * b - c));\n}\n\n// Antialiased line, added into the buffer. Each column (or row, for a\n// steep line) gets one unit of ink split between the two LEDs the line\n// passes between, scaled by the length of line it holds, so a polyline is\n// even along its whole length and its joints do not flare.\nfunction line(acc, x0, y0, x1, y1, c, a) {\n  // Clip to the panel with a one-LED margin.\n  let t0 = 0, t1 = 1;\n  const dx = x1 - x0, dy = y1 - y0;\n  const clip = (p, q) => {\n    if (p === 0) return q >= 0;\n    const r = q / p;\n    if (p \u003c 0) {\n      if (r > t1) return false;\n      if (r > t0) t0 = r;\n    } else {\n      if (r \u003c t0) return false;\n      if (r \u003c t1) t1 = r;\n    }\n    return true;\n  };\n  if (!clip(-dx, x0 + 1) || !clip(dx, W + 1 - x0) || !clip(-dy, y0 + 1) || !clip(dy, H + 1 - y0)) return;\n  const ax = x0 + dx * t0, ay = y0 + dy * t0, bx = x0 + dx * t1, by = y0 + dy * t1;\n  const steep = abs(by - ay) > abs(bx - ax);\n  let u0 = steep ? ay : ax, v0 = steep ? ax : ay, u1 = steep ? by : bx, v1 = steep ? bx : by;\n  if (u1 \u003c u0) {\n    let t = u0;\n    u0 = u1;\n    u1 = t;\n    t = v0;\n    v0 = v1;\n    v1 = t;\n  }\n  const du = u1 - u0;\n  if (du \u003c 1e-6) return;\n  const g = (v1 - v0) / du, k = a * sqrt(1 + g * g);\n  for (let ui = floor(u0); ui \u003c= floor(u1); ui++) {\n    const cover = min(u1, ui + 1) - max(u0, ui);\n    if (cover \u003c= 0) continue;\n    const um = (max(u0, ui) + min(u1, ui + 1)) / 2;\n    const vv = v0 + g * (um - u0) - 0.5, vi = floor(vv), f = vv - vi;\n    for (let s = 0; s \u003c 2; s++) {\n      const p = vi + s, w = (s ? f : 1 - f) * cover * k;\n      const x = steep ? p : ui, y = steep ? ui : p;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3;\n      acc[o] += c[0] * w;\n      acc[o + 1] += c[1] * w;\n      acc[o + 2] += c[2] * w;\n    }\n  }\n}\n\n// The kink across a shell centred on row cy, from the inner face to the\n// outer one. In a thin shell the line runs along the shell, so it is drawn\n// as a spiral piece round the shell's centre: angle and radius both go\n// linearly from one end to the other. A straight chord would cut through\n// the inside once the kink spans a wide angle, as it does above 0.5 c. It\n// is drawn twice, 0.9 LED apart, so it reads two LEDs wide.\nfunction arc(acc, cy, x0, y0, x1, y1, c, a) {\n  const r0 = sqrt((x0 - XC) ** 2 + (y0 - cy) ** 2), r1 = sqrt((x1 - XC) ** 2 + (y1 - cy) ** 2);\n  const f0 = Math.atan2(x0 - XC, y0 - cy), f1 = Math.atan2(x1 - XC, y1 - cy);\n  const steps = 1 + floor(max(abs(f1 - f0) * max(r0, r1), abs(r1 - r0)) / 1.5);\n  for (let side = -1; side \u003c= 1; side += 2) {\n    let px = 0, py = 0;\n    for (let s = 0; s \u003c= steps; s++) {\n      const f = f0 + ((f1 - f0) * s) / steps, r = r0 + ((r1 - r0) * s) / steps + side * 0.45;\n      const qx = XC + r * sin(f), qy = cy + r * cos(f);\n      if (s) line(acc, px, py, qx, qy, c, a * 0.7);\n      px = qx;\n      py = qy;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const acc = S.acc, T = S.T, ch = S.ch, m = ch.length, hue = S.hue;\n  acc.fill(0);\n  // The shells, newest last: centre row, radius, thickness, and for the\n  // region just inside each one the velocity and where the charge would\n  // now be had it kept that velocity.\n  const sh = S.sh;\n  sh.length = 0;\n  for (let i = 0; i \u003c m; i++) {\n    const r = C * (T - ch[i].t), b = abs(ch[i].u) / C, ub = i ? ch[i - 1].u : S.u0;\n    sh.push({\n      cy: ch[i].p, r, w: min(SHELL, 1.2 * r * (1 - b)), u: ch[i].u, s: ch[i].p + ch[i].u * (T - ch[i].t),\n      jump: abs(ch[i].u - ub) / (2 * C),\n    });\n  }\n  // Region i lies inside shell i and outside shell i + 1; region -1 lies\n  // outside every shell and holds the velocity before the oldest change.\n  const sOut = m ? ch[0].p + S.u0 * (T - ch[0].t) : posAt(S, T);\n  // Tints: news of moving down, moving up, standing.\n  const tint = S.col;\n  hsv(wheel(0.59 + hue), 0.9, 0.25, tint[0]);\n  hsv(wheel(0.14 + hue), 0.85, 0.2, tint[1]);\n  hsv(wheel(0.36 + hue), 0.4, 0.09, tint[2]);\n  const glow = hsv(wheel(0.99 + hue), 0.65, 1, S.sc);\n  for (let y = 0; y \u003c H; y++) {\n    const py = y + 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5 - XC, o = (y * W + x) * 3;\n      let reg = -1, g = 0;\n      for (let i = 0; i \u003c m; i++) {\n        const e = sh[i], dy = py - e.cy, dd = sqrt(px * px + dy * dy);\n        if (dd \u003c e.r) reg = i;\n        // A faint ring on every shell, brightest at right angles to the\n        // motion: the radiated energy goes as sin^2.\n        const q = (dd - e.r) / 1.6;\n        if (q > -3 && q \u003c 3 && dd > 0.1) {\n          const sn = px / dd;\n          g += e.jump * (0.12 + 0.88 * sn * sn) * exp(-q * q) * (40 / (40 + e.r));\n        }\n      }\n      const u = reg \u003c 0 ? S.u0 : sh[reg].u, tc = u > 0 ? tint[0] : u \u003c 0 ? tint[1] : tint[2];\n      acc[o] = tc[0] + glow[0] * g * 0.5;\n      acc[o + 1] = tc[1] + glow[1] * g * 0.5;\n      acc[o + 2] = tc[2] + glow[2] * g * 0.5;\n    }\n  }\n  // The field lines. Line j has the angle theta it would have round a\n  // charge at rest. In a region whose charge moves at beta it leaves that\n  // charge's extrapolated place at theta' with tan theta' = gamma tan theta\n  // (Heaviside's field, squeezed towards the plane across the motion).\n  const lc = hsv(wheel(0.45 + hue), 0.12, 1, S.lc), kc = hsv(wheel(0.99 + hue), 0.45, 1, S.kc);\n  const n = S.n;\n  const dirs = new Float32Array(2 * (m + 1));\n  for (let j = 0; j \u003c n; j++) {\n    const th = ((j + 0.5) * 2 * PI) / n, st = sin(th), ct = cos(th);\n    // Directions per region; slot m holds region -1.\n    for (let i = -1; i \u003c m; i++) {\n      const u = i \u003c 0 ? S.u0 : sh[i].u, b = abs(u) / C, gm = 1 / sqrt(1 - b * b);\n      const ex = gm * st, ey = ct, l = sqrt(ex * ex + ey * ey), k = i \u003c 0 ? 2 * m : 2 * i;\n      dirs[k] = ex / l;\n      dirs[k + 1] = ey / l;\n    }\n    // From the charge out: the newest region first.\n    let ax = XC, ay = m ? sh[m - 1].s : sOut;\n    const kink = 0.25 + 0.95 * abs(st);\n    for (let i = m - 1; i >= -1; i--) {\n      const k = i \u003c 0 ? 2 * m : 2 * i, dx = dirs[k], dy = dirs[k + 1];\n      const sx = XC, sy = i \u003c 0 ? sOut : sh[i].s;\n      // Where this region's spoke starts: at the charge, or where its ray\n      // leaves the outer face of the shell inside it.\n      let t0 = 0;\n      if (i \u003c m - 1) t0 = exitRay(sx, sy, dx, dy, sh[i + 1].cy, sh[i + 1].r + sh[i + 1].w / 2);\n      const bx0 = sx + dx * t0, by0 = sy + dy * t0;\n      if (i \u003c m - 1) arc(acc, sh[i + 1].cy, ax, ay, bx0, by0, kc, kink);\n      // Where it ends: the inner face of its own shell, or far off.\n      let t1 = i \u003c 0 ? 400 : exitRay(sx, sy, dx, dy, sh[i].cy, sh[i].r - sh[i].w / 2);\n      if (t1 \u003c t0) t1 = t0;\n      const ex = sx + dx * t1, ey = sy + dy * t1;\n      line(acc, bx0, by0, ex, ey, lc, 0.46);\n      ax = ex;\n      ay = ey;\n      if (ex \u003c -2 || ex > W + 2 || ey \u003c -2 || ey > H + 2) {\n        // Off the panel; the rest of the chain could still swing back in\n        // through a kink, so keep going only while it is near.\n        if (ex \u003c -40 || ex > W + 40 || ey \u003c -40 || ey > H + 40) break;\n      }\n    }\n  }\n  // The charge itself.\n  const qy = m ? sh[m - 1].s : sOut, cc = hsv(wheel(0.45 + hue), 0.15, 1, S.c);\n  for (let y = floor(qy - 4); y \u003c= qy + 4; y++)\n    for (let x = XC - 5; x \u003c XC + 5; x++) {\n      if (y \u003c 0 || y >= H) continue;\n      const dx = x + 0.5 - XC, dy = y + 0.5 - qy, d2 = dx * dx + dy * dy, v = 1.3 * exp(-d2 / 1.6) + 0.25 * exp(-d2 / 7);\n      const o = (y * W + x) * 3;\n      acc[o] += cc[0] * v;\n      acc[o + 1] += cc[1] * v;\n      acc[o + 2] += cc[2] * v;\n    }\n  // Where lines pile up, scale the LED down as a whole instead of clipping\n  // each channel, so a crowded kink stays rose and does not wash to white.\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const pk = max(1, acc[o], acc[o + 1], acc[o + 2]), k = 255 / pk;\n    display.setPixel(p % W, (p / W) | 0, (acc[o] * k) | 0, (acc[o + 1] * k) | 0, (acc[o + 2] * k) | 0);\n  }\n}\n","cornu-spiral":"// ===== Patternflow pattern =====\n// Title:   Cornu Spiral\n// Family:  line\n// Idea:    The Euler spiral curls its two arms into their eyes at (1/2, 1/2) and (-1/2, -1/2) across the top of the panel, a bright phasor chord slides along it from one eye or across a fixed arc of it, and the square of that chord's length, the light Fresnel diffraction puts at one point behind a straight edge or a slit, is traced below as a fringe profile and shown under it as the fringes themselves.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler spiral (Leonhard Euler, 1744), Fresnel integrals (Augustin-Jean Fresnel, 1818), Cornu spiral as a diffraction calculator (Marie Alfred Cornu, 1874), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Slit=0..1, Spread=0..1\n//\n// Knob 1: Hue. Turns the spiral and the light round the wheel together. At 0 the spiral is sky blue and the light, the chord, the profile and the fringes, gold; at 0.25 violet and green, at 0.5 red and blue, at 0.75 green and pink. The spiral skips the orange part of the wheel, which reads brown when dim.\n// Knob 2: Speed. At 2 the point on the screen crosses it in 5 s and comes back in 5 s, slowing at both ends, so the chord's free end runs up the spiral and back; at 0.2 a crossing takes 50 s, at 3 it takes 3.3 s.\n// Knob 3: Slit. At 0 a straight edge: the chord runs from the lower eye, the screen spans w = -2 to 5 in Fresnel units, the light rises from 0 in the shadow through 0.25 at the edge to 1.37 at w = 1.22 and rings down to 1, the dotted line. Above 0 a slit of width a = 0.6 + 7.4 (1 - K3)^1.5, the screen w = -6 to 6, and the chord joins the two ends of an arc a long: at 0.25 (a = 5.4) Fresnel fringes stand inside the slit's image, at 0.5 (a = 3.2) two humps of 1.42 with a dip to 1.05 between them, at 0.75 (a = 1.5) one peak of 1.08 with dark zeros at w = +-1.31, and at 1 (a = 0.6) a broad hump of only 0.18 whose zeros sit at w = +-3.33 = 2 / a, the Fraunhofer sinc squared. The profile is scaled so its highest point stands 42 rows tall.\n// Knob 4: Spread. The light's band of wavelengths. At 0 one wavelength in the colour of K1; at 1 white light, 650, 530 and 450 nm in red, green and blue, each with its own chord to its own point of the spiral, since w scales as one over the square root of the wavelength. Behind the straight edge the first fringe is then white with a blue rim toward the shadow and an orange one away from it, the next ones pass through pink, sky blue, yellow, violet and green, and past w = 4.4 they wash out to white. It opens at 0.06, close to one wavelength.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, cos, sin, exp, round, ceil, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel without its orange and yellow, 0.03 to 0.17.\nconst wheel = (h) => 0.17 + (h - floor(h)) * 0.86;\n\n// C(t) and S(t), the Fresnel integrals of cos and sin of pi s^2 / 2 from 0\n// to t, tabled every 1/200 for |t| \u003c= 12 by Simpson's rule on eight\n// substeps a step: C(1) = 0.7798934004 and S(1) = 0.4382591474, and the\n// whole table is within 5e-11 of one built on 64 substeps. Between entries\n// the spiral is read as a straight chord, at most 0.005 LED off the curve\n// at t = 12, where at 39.5 LEDs a unit a coil is one LED across; everything\n// past that is the eye.\nconst TM = 12, TS = 200, NT = 2 * TM * TS + 1, I0 = TM * TS;\nconst FC = new Float64Array(NT), FS = new Float64Array(NT);\nlet tabled = false;\nfunction fresnel() {\n  if (tabled) return;\n  const h = 1 / TS, m = 8, q = h / m;\n  let c = 0, s = 0;\n  for (let i = 1; i \u003c= I0; i++) {\n    const a = (i - 1) * h;\n    let sc = 0, ss = 0;\n    for (let j = 0; j \u003c= m; j++) {\n      const u = a + j * q, ph = (PI * u * u) / 2, wt = j === 0 || j === m ? 1 : j & 1 ? 4 : 2;\n      sc += wt * cos(ph);\n      ss += wt * sin(ph);\n    }\n    c += (sc * q) / 3;\n    s += (ss * q) / 3;\n    FC[I0 + i] = c;\n    FS[I0 + i] = s;\n    FC[I0 - i] = -c;\n    FS[I0 - i] = -s;\n  }\n  tabled = true;\n}\nconst ZP = [0, 0];\nfunction Z(t) {\n  let f = (cl(t, -TM, TM) + TM) * TS, i = floor(f);\n  if (i > NT - 2) i = NT - 2;\n  f -= i;\n  ZP[0] = FC[i] + (FC[i + 1] - FC[i]) * f;\n  ZP[1] = FS[i] + (FS[i + 1] - FS[i]) * f;\n  return ZP;\n}\n\n// The spiral's plane on the panel: 39.5 LEDs a unit about (31.5, 30), S up.\n// C runs to +-0.780 (columns 0.7 to 62.3), S to +-0.714 (rows 1.8 to 58.2);\n// the eyes sit at (11.75, 49.75) and (51.25, 10.25).\nconst SC = 39.5, CX = 31.5, CY = 30;\nconst lx = (c) => CX + c * SC, ly = (s) => CY - s * SC;\n// The profile: I = 0 on row 112, the highest value 42 rows up; the screen\n// on rows 116 to 127, its LEDs as bright as the light that falls there.\nconst PB = 112, PH = 42, BAND = 116;\n// Wavelengths over the middle one at full Spread: 650 / 530 and 450 / 530.\nconst DL = [0.226, 0, -0.151], PRIM = [1, 0, 0, 0, 1, 0, 0, 0, 1];\n\nexport function setup(params) {\n  fresnel();\n  // The whole spiral once, as the length of curve under each LED.\n  const D = new Float32Array(W * 64);\n  const step = SC / TS;\n  for (let i = 0; i \u003c NT; i++) {\n    const x = lx(FC[i]), y = ly(FS[i]), ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n    const put = (a, b, v) => {\n      if (a >= 0 && a \u003c W && b >= 0 && b \u003c 64) D[b * W + a] += v;\n    };\n    put(ix, iy, (1 - fx) * (1 - fy) * step);\n    put(ix + 1, iy, fx * (1 - fy) * step);\n    put(ix, iy + 1, (1 - fx) * fy * step);\n    put(ix + 1, iy + 1, fx * fy * step);\n  }\n  for (let p = 0; p \u003c D.length; p++) D[p] = min(1, D[p]) ** 0.75;\n  params.s = {\n    hue: 0, speed: 2, slit: 0, spread: 0.06, clock: 0, phase: 0, warm: false, D,\n    last: new Float32Array(W), xh: 0, I: new Float32Array(W * 3),\n    A: new Float32Array(W * 65), R: new Float32Array(N), G: new Float32Array(N), B: new Float32Array(N), c: new Float32Array(24),\n  };\n}\n\n// Where the screen point is, 0..1 across, from the sweep's phase: there and\n// back, slowing at both ends.\nconst ease = (ph) => {\n  const u = ph - 2 * floor(ph / 2), f = u \u003c 1 ? u : 2 - u;\n  return (1 - cos(PI * f)) / 2;\n};\n\nfunction mark(S, x0, x1, t) {\n  // Columns the head passed between x0 and x1 were lit at time t.\n  const a = max(0, ceil(min(x0, x1) - 1e-9)), b = min(W - 1, floor(max(x0, x1)));\n  for (let c = a; c \u003c= b; c++) S.last[c] = t;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.slit = cl(k[2], 0, 1);\n  S.spread = cl(k[3], 0, 1);\n  const rate = S.speed / 10; // crossings a second\n  if (!S.warm) {\n    // Open as if the head had just come back across the screen from the\n    // right, so the whole profile is already there, brightest at the left.\n    S.last.fill(-99);\n    let px = W - 0.5;\n    for (let i = 1; i \u003c= 200; i++) {\n      const ph = i / 200 - 1, x = ease(ph) * W - 0.5;\n      mark(S, px, x, ph / rate);\n      px = x;\n    }\n    S.xh = -0.5;\n    S.warm = true;\n  }\n  S.clock += d;\n  S.phase += d * rate;\n  const x = ease(S.phase) * W - 0.5;\n  mark(S, S.xh, x, S.clock);\n  S.xh = x;\n}\n\n// Accumulate light into the float frame: a bilinear splat, and lines as\n// splats every third of an LED so a line carries the same light per LED of\n// length at any slope.\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction line(S, x0, y0, x1, y1, v, c, o, ends) {\n  const L = hypot(x1 - x0, y1 - y0), n = max(1, ceil(L * 3)), w = (v * L) / n;\n  for (let i = ends ? 0 : 1; i \u003c= n; i++) splat(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { R, G, B, c, D, I, last } = S, sp = S.spread, slit = S.slit > 0;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  // Colours: 0 the dim spiral, 3 the lit arc, 6 the light, 9.. the three\n  // wavelengths, 18 white, 21 grey.\n  hsv(wheel(0.48 + S.hue), 0.8, 0.32, c, 0);\n  hsv(wheel(0.48 + S.hue), 0.4, 0.8, c, 3);\n  hsv(0.13 + S.hue, 0.85, 1, c, 6);\n  for (let q = 0; q \u003c 3; q++)\n    for (let ch = 0; ch \u003c 3; ch++) c[9 + q * 3 + ch] = ((1 - sp) * c[6 + ch]) / 3 + sp * PRIM[q * 3 + ch];\n  c[18] = c[19] = c[20] = 1;\n  c[21] = c[22] = c[23] = 0.2;\n\n  // The screen in Fresnel units and the slit, a = 0.6 + 7.4 (1 - K3)^1.5.\n  const a = 0.6 + 7.4 * (1 - S.slit) ** 1.5;\n  const w0 = slit ? -6 : -2, w1 = slit ? 6 : 5, ws = (w1 - w0) / W;\n  const rs = [0, 1, 2].map((q) => 1 / sqrt(1 + sp * DL[q]));\n  let Imax = 0;\n  for (let col = 0; col \u003c W; col++) {\n    const w = w0 + (col + 0.5) * ws;\n    for (let q = 0; q \u003c 3; q++) {\n      let dx, dy;\n      if (slit) {\n        const p = Z((w - a / 2) * rs[q]), px = p[0], py = p[1], e = Z((w + a / 2) * rs[q]);\n        dx = e[0] - px;\n        dy = e[1] - py;\n      } else {\n        const e = Z(w * rs[q]);\n        dx = e[0] + 0.5;\n        dy = e[1] + 0.5;\n      }\n      const v = (I[col * 3 + q] = (dx * dx + dy * dy) / 2);\n      if (v > Imax) Imax = v;\n    }\n  }\n  const ks = PH / Imax;\n\n  // The spiral, dim, and the part of it that lets light through bright: from\n  // the lower eye up to the chord's end behind a straight edge, the arc a\n  // long inside a slit.\n  for (let y = 0, p = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const v = D[p];\n      if (v > 0) (R[p] = v * c[0]), (G[p] = v * c[1]), (B[p] = v * c[2]);\n    }\n  const wh = w0 + (S.xh + 0.5) * ws;\n  const t1 = slit ? wh - a / 2 : -TM, t2 = slit ? wh + a / 2 : wh;\n  const i1 = max(0, ceil((t1 + TM) * TS)), i2 = min(NT - 1, floor((t2 + TM) * TS)), st = SC / TS;\n  // The lit arc goes through the same tone curve as the spiral, so the\n  // coils round an eye stay rings instead of piling up into a white disc.\n  const A = S.A;\n  A.fill(0);\n  for (let i = i1; i \u003c= i2; i++) {\n    const x = lx(FC[i]), y = ly(FS[i]), ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy, p = iy * W + ix;\n    A[p] += (1 - fx) * (1 - fy) * st;\n    A[p + 1] += fx * (1 - fy) * st;\n    A[p + W] += (1 - fx) * fy * st;\n    A[p + W + 1] += fx * fy * st;\n  }\n  for (let p = 0; p \u003c A.length; p++)\n    if (A[p] > 0) {\n      const v = min(1, A[p]) ** 0.75;\n      R[p] += v * c[3];\n      G[p] += v * c[4];\n      B[p] += v * c[5];\n    }\n  // The unobstructed wave's chord, eye to eye, length sqrt 2: I = 1.\n  for (let u = 0.04; u \u003c 1; u += 0.06) splat(S, lx(u - 0.5), ly(u - 0.5), 0.9, c, 21);\n  // The chords, one a wavelength, each from its own two points.\n  for (let q = 0; q \u003c 3; q++) {\n    let x0, y0;\n    if (slit) {\n      const p = Z((wh - a / 2) * rs[q]);\n      (x0 = lx(p[0])), (y0 = ly(p[1]));\n    } else (x0 = lx(-0.5)), (y0 = ly(-0.5));\n    const e = Z((slit ? wh + a / 2 : wh) * rs[q]), x1 = lx(e[0]), y1 = ly(e[1]);\n    line(S, x0, y0, x1, y1, 1.15, c, 9 + q * 3, true);\n    splat(S, x1, y1, 0.9, c, 9 + q * 3);\n    if (slit) splat(S, x0, y0, 0.9, c, 9 + q * 3);\n  }\n  splat(S, lx(0.5), ly(0.5), 0.5, c, 18);\n  splat(S, lx(-0.5), ly(-0.5), 0.5, c, 18);\n\n  // The profile: I = 1 dotted, the geometric shadow's edges dotted, the\n  // curve brightest where the head has just been, and the head itself.\n  if (PB - ks > PB - PH - 6) for (let x = 0; x \u003c W; x += 2) add(S, x, round(PB - ks), 0.9, c, 21);\n  const edges = slit ? [-a / 2, a / 2] : [0];\n  for (const e of edges) {\n    const ex = round((e - w0) / ws - 0.5);\n    for (let y = PB - PH; y \u003c= PB; y += 2) add(S, ex, y, 0.8, c, 21);\n  }\n  const now = S.clock, glow = (col) => 0.45 + 0.55 * exp(-(now - last[col]) / 2.2);\n  for (let q = 0; q \u003c 3; q++)\n    for (let col = 0; col \u003c W - 1; col++) {\n      const g = (glow(col) + glow(col + 1)) / 2;\n      line(S, col, PB - I[col * 3 + q] * ks, col + 1, PB - I[(col + 1) * 3 + q] * ks, g, c, 9 + q * 3, col === 0);\n    }\n  const xh = S.xh, ia = floor(cl(xh, 0, W - 2)), fa = cl(xh - ia, 0, 1);\n  const Ih = I[ia * 3 + 1] * (1 - fa) + I[(ia + 1) * 3 + 1] * fa, yh = PB - Ih * ks;\n  for (let y = yh + 2; y \u003c= PB; y += 2) splat(S, xh, y, 0.5, c, 21);\n  splat(S, xh, yh, 1.6, c, 18);\n  // The screen.\n  for (let col = 0; col \u003c W; col++) {\n    const r = [0, 0, 0];\n    for (let q = 0; q \u003c 3; q++) {\n      const v = I[col * 3 + q] / Imax;\n      for (let ch = 0; ch \u003c 3; ch++) r[ch] += v * c[9 + q * 3 + ch];\n    }\n    for (let y = BAND; y \u003c H; y++) {\n      const p = y * W + col;\n      (R[p] = r[0]), (G[p] = r[1]), (B[p] = r[2]);\n    }\n  }\n  splat(S, xh, BAND - 2, 1, c, 18);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","eulers-officers":"// ===== Patternflow pattern =====\n// Title:   Euler's Officers\n// Family:  cells\n// Idea:    Two officer squares stand one above the other, each cell a ring in the colour of its rank and a core in the colour of its regiment: on top Euler's 36 officers in a best attempt where four cells at the corners of a rectangle repeat two pairs and pulse white, below an order-10 Graeco-Latin square where all 100 colour pairs appear once, while one regiment after another lights up to show it is a transversal of the ranks, one cell in every row, column and rank.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler's 36 officers problem (Leonhard Euler, 1782), no pair of order 6 (Gaston Tarry, 1900), orthogonal Latin squares of order 10, \"Euler's spoilers\" (R. C. Bose, S. S. Shrikhande and E. T. Parker, 1959), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Core=-1..1, Shuffle=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the ten ranks and regiments of the bottom square are red, orange, yellow, lime, green, teal, azure, blue, violet and magenta, and the six of the top square red, amber, green, teal, azure and purple, spread round the same wheel. Each 0.1 moves the bottom square's colours one place on; at 0.5 every colour stands opposite where it was, red turned teal.\n// Knob 2: Speed. At 2 the next regiment lights up every 1.5 s, so the ten transversals of the order-10 square come round in 15 s and the six regiments of the order-6 attempt in 9 s, and the clash cells fade to white and back every 2.4 s. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Core. How much of a cell the regiment's core takes. At -1 there is no core and each square shows only its ranks, a Latin square on its own; at -0.5 the core is the centre LED of the 5 x 5 cells below and 3 x 3 of the 9 x 9 cells on top; at 0 3 x 3 and 5 x 5; at 0.5 the bottom square shows only regiments and the top one a 7 x 7 core in a ring one LED wide; at 1 both show only the regiments, the second Latin square.\n// Knob 4: Shuffle. Swaps two rows or two columns of one square, both of its Latin squares together, which keeps every pair it had: 2.4 x K4 swaps a second at Speed 2, so one every 7 s at the opening 0.06 and none at 0. A swap fades the colours of the two lines into each other over 0.4 s, round the wheel so no LED dims, and puts white ticks at their ends.\n\nconst W = 64, H = 128;\nconst { floor, min, max, round, cos, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The squares: R gives each cell's rank row by row, G its regiment.\n// Order 6 (top) is the best a search found for Euler's officers. It took 40\n// random rank squares and split each one every way into six regiments, and\n// 15 of them reached 34 of the 36 pairs, 15 reached 32, three 31 and seven\n// 30: a square with no transversal cannot do better than 6 x 5. 34 is the\n// most there can be. Tarry's 1900 search of every case rules out 36, and 35\n// cannot happen either, since five regiments that are transversals leave a\n// sixth that is one too. Here the four cells in rows 1 and 5, columns 3 and\n// 6 (from the top left) hold only two pairs between them, amber with green\n// and red with purple at Hue 0, each twice; red with green and amber with\n// purple never appear. The code below counts the pairs and marks the cells\n// of every pair it meets twice.\nconst R6 = \"231450523104015243104532450321342015\";\nconst G6 = \"012345253401301254140523435012524130\";\n// Order 10 (bottom): the fifth random rank square the search drew had 872\n// transversals, and an exact-cover search picked 10 disjoint ones out of\n// them; transversal k is regiment k. (The first four, with 804 to 892\n// transversals, gave no cover inside two million steps.) All 100 pairs\n// appear once, which the same count finds here.\nconst R10 = \"8054267913170842536951360427983285679041041953867268921504379647803125792138450645739162802360791854\";\nconst G10 = \"3621054789217486039595034286171365792840573864902180429715636290135478795628310404873169524819507236\";\n\n// Ten hues placed by eye on the LED wheel, which crowds the greens: rank or\n// regiment k of an order-n square sits at slot k / n + Hue, and a slot maps\n// to a hue through these stops.\nconst STOPS = [0, 0.075, 0.15, 0.25, 0.37, 0.47, 0.56, 0.65, 0.76, 0.87, 1];\nfunction slotHue(t) {\n  t -= floor(t);\n  const i = floor(t * 10), f = t * 10 - i;\n  return STOPS[i] + (STOPS[i + 1] - STOPS[i]) * f;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Both squares are 59 LEDs square at columns 2..60. The top one has cells of\n// 9 x 9 LEDs at a pitch of 10, rows 2..60; the bottom one 5 x 5 at a pitch\n// of 6, rows 67..125. A dark LED line runs between the cells.\nfunction makeSquare(n, ranks, regs, oy) {\n  const pitch = n === 6 ? 10 : 6, lit = pitch - 1, nn = n * n;\n  const A = new Int8Array(nn), B = new Int8Array(nn), clash = new Uint8Array(nn);\n  for (let i = 0; i \u003c nn; i++) (A[i] = +ranks[i]), (B[i] = +regs[i]);\n  // Orthogonality, counted: a pair met twice marks both of its cells.\n  const seen = new Int16Array(nn);\n  for (let i = 0; i \u003c nn; i++) seen[A[i] * n + B[i]]++;\n  let clashes = 0;\n  for (let i = 0; i \u003c nn; i++) if (seen[A[i] * n + B[i]] > 1) (clash[i] = 1), clashes++;\n  const perm = () => Array.from({ length: n }, (_, i) => i);\n  return {\n    n, pitch, lit, ox: 2, oy, A, B, clash, clashes, rowP: perm(), colP: perm(),\n    // Display cell colours as slots, with the fade of a swap.\n    fromA: new Float32Array(nn), fromB: new Float32Array(nn), t0: new Float32Array(nn).fill(-9),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, core: 0, shuffle: 0.06, clock: 0, swapAcc: 0.5,\n    sq: [makeSquare(6, R6, G6, 2), makeSquare(10, R10, G10, 67)],\n    ticks: [], rgb: new Float32Array(W * H * 3), c: new Float32Array(6),\n  };\n}\n\nconst FADE = 0.4;\n\n// The slot a display cell shows now, part way through a swap's fade.\nfunction slotNow(S, q, i, from, to) {\n  const a = cl((S.clock - q.t0[i]) / FADE, 0, 1);\n  if (a >= 1) return to;\n  let d = to - from;\n  d -= round(d);\n  return from + d * (0.5 - 0.5 * cos(PI * a));\n}\n\nfunction swap(S) {\n  const q = S.sq[random() \u003c 0.5 ? 0 : 1], n = q.n, rows = random() \u003c 0.5;\n  const i = floor(random() * n);\n  let j = floor(random() * (n - 1));\n  if (j >= i) j++;\n  const P = rows ? q.rowP : q.colP;\n  // Note where each touched cell's colours are, then swap the two lines.\n  for (let k = 0; k \u003c n; k++)\n    for (const l of [i, j]) {\n      const d = rows ? l * n + k : k * n + l;\n      const r = rows ? P[l] : q.rowP[k], c = rows ? q.colP[k] : P[l];\n      q.fromA[d] = slotNow(S, q, d, q.fromA[d], q.A[r * n + c] / n);\n      q.fromB[d] = slotNow(S, q, d, q.fromB[d], q.B[r * n + c] / n);\n      q.t0[d] = S.clock;\n    }\n  const t = P[i];\n  P[i] = P[j];\n  P[j] = t;\n  S.ticks.push({ q, rows, i, j, t0: S.clock });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.core = cl(k[2], -1, 1);\n  S.shuffle = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.clock += ds;\n  S.swapAcc += ds * 2.4 * S.shuffle;\n  while (S.swapAcc >= 1) {\n    S.swapAcc -= 1;\n    swap(S);\n  }\n  S.ticks = S.ticks.filter((t) => S.clock - t.t0 \u003c FADE + 0.2);\n}\n\n// How lit a regiment is: each one in turn for 1.5 s, rising and falling\n// over the first and last 0.4 s.\nconst STEP = 1.5, FRAME = 0.25, BASE = 0.88, SAT = 0.88;\nfunction glow(S, n, reg) {\n  const u = S.clock / STEP, now = floor(u) % n;\n  if (reg !== now) return 0;\n  const f = u - floor(u), e = min(f, 1 - f) / (0.4 / STEP);\n  return e >= 1 ? 1 : 0.5 - 0.5 * cos(PI * e);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, c = S.c;\n  rgb.fill(0);\n  // A cell's LED lies in the core when its square ring (Chebyshev distance\n  // from the cell's centre) is under rho times half the pitch.\n  const rho = (1 + S.core) / 2;\n  // The clash cells fade to white and back every 2.4 s; white keeps the\n  // LED at the level it had, so the pulse moves nothing on the map.\n  const pulse = 0.5 - 0.5 * cos((2 * PI * S.clock) / 2.4);\n  for (const q of S.sq) {\n    const n = q.n, half = (q.lit - 1) / 2, rc = rho * (half + 1);\n    for (let r = 0; r \u003c n; r++)\n      for (let col = 0; col \u003c n; col++) {\n        const d = r * n + col, cell = q.rowP[r] * n + q.colP[col];\n        const sa = slotNow(S, q, d, q.fromA[d], q.A[cell] / n);\n        const sb = slotNow(S, q, d, q.fromB[d], q.B[cell] / n);\n        const g = glow(S, n, q.B[cell]);\n        // Cells stand at 0.88 of full and the lit regiment at full, with a\n        // faint white frame in the dark line round each of its cells.\n        const v = BASE + (1 - BASE) * g;\n        const whiten = q.clash[cell] ? pulse : 0;\n        hsv(slotHue(sa + S.hue), SAT * (1 - whiten), v, c, 0);\n        hsv(slotHue(sb + S.hue), SAT, v, c, 3);\n        const x0 = q.ox + col * q.pitch, y0 = q.oy + r * q.pitch, L = q.lit;\n        for (let yy = 0; yy \u003c L; yy++)\n          for (let xx = 0; xx \u003c L; xx++) {\n            const cheb = max(Math.abs(xx - half), Math.abs(yy - half));\n            const p = ((y0 + yy) * W + x0 + xx) * 3, o = cheb \u003c rc ? 3 : 0;\n            // The lit regiment's centre LED turns white: one white point in\n            // every row and every column.\n            const wh = cheb === 0 ? g : 0;\n            rgb[p] = wh * v + c[o] * (1 - wh);\n            rgb[p + 1] = wh * v + c[o + 1] * (1 - wh);\n            rgb[p + 2] = wh * v + c[o + 2] * (1 - wh);\n          }\n        if (g > 0)\n          for (let k = -1; k \u003c= L; k++)\n            for (const [x, y] of [[x0 + k, y0 - 1], [x0 + k, y0 + L], [x0 - 1, y0 + k], [x0 + L, y0 + k]]) {\n              const p = (y * W + x) * 3;\n              rgb[p] = rgb[p + 1] = rgb[p + 2] = max(rgb[p], FRAME * g);\n            }\n      }\n  }\n  // White ticks at the two ends of each swapped row or column.\n  for (const t of S.ticks) {\n    const q = t.q, a = cl(1 - (S.clock - t.t0 - FADE) / 0.2, 0, 1) * 0.8;\n    const span = q.n * q.pitch - 1;\n    for (const l of [t.i, t.j])\n      for (let s = 0; s \u003c q.lit; s++) {\n        const along = l * q.pitch + s;\n        const ends = t.rows\n          ? [[0, q.oy + along], [1, q.oy + along], [q.ox + span + 1, q.oy + along], [q.ox + span + 2, q.oy + along]]\n          : [[q.ox + along, q.oy - 1], [q.ox + along, q.oy + span + 1]];\n        for (const [x, y] of ends) {\n          if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n          const p = (y * W + x) * 3;\n          rgb[p] = rgb[p + 1] = rgb[p + 2] = max(rgb[p], a);\n        }\n      }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, round(rgb[p] * 255), round(rgb[p + 1] * 255), round(rgb[p + 2] * 255));\n}\n","giant-component":"// ===== Patternflow pattern =====\n// Title:   Giant Component\n// Family:  data\n// Idea:    Random edges join the dots of a 21 by 32 grid one at a time, every component wearing a colour of its own and the largest one cream, and just after the edges pass half the number of dots the cream giant component floods the panel, while a plot underneath draws its share against the edges added over the curve Erdős and Rényi's theory gives.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random graph phase transition (Paul Erdős and Alfréd Rényi, 1959 and 1960), explosive percolation (Dimitris Achlioptas, Raissa D'Souza and Joel Spencer, 2009), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Choice=0..1\n//\n// Knob 1: Hue. Turns the components' colours round the wheel; a vertex alone stays a dim slate dot and the largest component stays cream. At 0 the components take hues from azure through blue and violet to pink, at 0.25 from violet through red to lime, at 0.5 from rose through lime and green to cyan, at 0.75 from green through cyan and blue to violet; orange and dark yellow are skipped, as they read brown. The plot's dim lines turn with them, blue at 0.\n// Knob 2: Speed. Edges added a second, 0.064 x Speed x n: at 2 the first graph opens with 0.2 n edges already in, passes the threshold n / 2 at 2.3 s and reaches 1.28 n, where the plot ends, at 8.4 s; it holds 2 s and a fresh graph starts from no edges, every 12 s. At 0.2 ten times slower, at 3 one and a half times faster. Each new edge is drawn as a line for 0.25 s at Speed 2, faint when it only brings in a vertex that was alone, brighter the larger the smaller of the two components it joins.\n// Knob 3: Size. The grid, rounded: at -1 16 x 24 = 384 vertices as 3 x 3 LED dots 4 LEDs apart, at the opening 0 21 x 32 = 672 as 2 x 2 dots 3 apart, at 1 32 x 48 = 1536 single LEDs 2 apart. The larger the graph, the sharper the turn: over 200 graphs each, the largest component held 11.9, 10.4 and 8.0 percent of the vertices at n / 2 edges, falling as n^(-1/3), and at 0.75 n edges 57.5, 57.8 and 58.2 percent against the 58.3 of theory. A new value starts a fresh graph.\n// Knob 4: Choice. The chance that an edge is chosen by the product rule of Achlioptas, D'Souza and Spencer: two candidates are drawn and the one whose two components have the smaller product of sizes is kept. It opens at 0.06, almost the plain random graph. At 1 the components stay small and many past n / 2, the giant waits until 0.83 n edges and then grows from a tenth of the vertices to seven tenths in 0.07 n more, 0.5 s at Speed 2, where the plain graph takes 0.35 n and 2.75 s, and the plot rises as a cliff. Over 200 graphs of 672 vertices the edges it took the largest component to grow from the square root of n to n / 2 were 0.30 n with no choice and 0.16 n with it, and for 200000 vertices, off the panel, 0.23 n and 0.022 n: the jump grows sharper without end, explosive percolation.\n// Buttons: K1 tap starts a fresh graph from no edges.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, exp, log2, round, random, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The vertex grids: spacing, columns, rows, dot size, left margin. Each\n// stands 95 rows tall over the top of the panel, one dark LED between dots.\nconst GRIDS = [[4, 16, 24, 3, 0], [3, 21, 32, 2, 1], [2, 32, 48, 1, 0]];\nconst NMAX = 32 * 48;\n// The plot below them: edges added across, 0 to TMAX n over its 64\n// columns, the largest component's share up, 0 on row PY0 and 1 PH rows\n// higher.\nconst PY0 = 126, PH = 25, PC = 64, TMAX = 1.28;\nconst RATE = 0.064, T0 = 0.2, HOLD = 2, FADE = 0.6, LIFE = 0.25, NL = 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Orange and yellow read brown and olive on an LED unless they are bright,\n// so the components take their hues from a wheel without 0.03 to 0.17, and\n// the dim lines of the plot from one that runs only from green to rose.\nconst wheel = (h) => 0.17 + 0.86 * (h - floor(h));\nconst dimWheel = (h) => 0.3 + 0.7 * (h - floor(h));\n\n// The share of vertices in the giant component of G(n, m) as n grows,\n// m = t n: the root theta of theta = 1 - exp(-2 t theta), zero up to t = 1/2.\nconst THEORY = new Float32Array(PC);\nfor (let c = 0; c \u003c PC; c++) {\n  const k = (2 * (c + 0.5) * TMAX) / PC;\n  let th = 1;\n  for (let i = 0; i \u003c 400; i++) th = 1 - exp(-k * th);\n  THEORY[c] = k \u003c= 1 ? 0 : th;\n}\n\nexport function setup(params) {\n  params.s = {\n    par: new Int32Array(NMAX), sz: new Int32Array(NMAX), hu: new Float32Array(NMAX),\n    share: new Float32Array(PC), lines: new Int32Array(NL * 3), age: new Float32Array(NL).fill(9), nl: 0,\n    rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3), c: new Float32Array(3),\n    n: 0, grid: 1, t: 0, m: 0, big: 1, bigRoot: 0, hold: 0, fade: 0, started: false,\n    hue: 0, speed: 2, size: 1, choice: 0.06,\n  };\n}\n\n// Union-find, with path halving and union by size.\nfunction find(par, a) {\n  while (par[a] !== a) a = par[a] = par[par[a]];\n  return a;\n}\n\nfunction fresh(S) {\n  const g = GRIDS[S.size];\n  S.grid = S.size;\n  S.n = g[1] * g[2];\n  for (let v = 0; v \u003c S.n; v++) (S.par[v] = v), (S.sz[v] = 1), (S.hu[v] = random());\n  S.share.fill(-1);\n  S.t = S.m = S.hold = S.nl = 0;\n  S.big = 1;\n  S.bigRoot = 0;\n  S.age.fill(9);\n}\n\n// One edge. With probability Choice two candidate edges are drawn and the\n// one whose two components have the smaller product of sizes is kept, the\n// product rule of Achlioptas, D'Souza and Spencer; otherwise one edge,\n// uniformly at random, as in G(n, m). The line it leaves remembers the\n// smaller of the two components it joined, 0 for an edge inside one.\nfunction addEdge(S) {\n  const { par, sz } = S, n = S.n;\n  let a = floor(random() * n), b = floor(random() * (n - 1));\n  if (b >= a) b++;\n  if (random() \u003c S.choice) {\n    let c = floor(random() * n), d = floor(random() * (n - 1));\n    if (d >= c) d++;\n    if (sz[find(par, c)] * sz[find(par, d)] \u003c sz[find(par, a)] * sz[find(par, b)]) (a = c), (b = d);\n  }\n  let ra = find(par, a), rb = find(par, b), small = 0;\n  if (ra !== rb) {\n    if (sz[ra] \u003c sz[rb]) {\n      const t = ra;\n      ra = rb;\n      rb = t;\n    }\n    small = sz[rb];\n    par[rb] = ra;\n    sz[ra] += small;\n    if (sz[ra] >= S.big) (S.big = sz[ra]), (S.bigRoot = ra);\n  }\n  const k = S.nl++ % NL;\n  S.lines[k * 3] = a;\n  S.lines[k * 3 + 1] = b;\n  S.lines[k * 3 + 2] = small;\n  S.age[k] = 0;\n  S.m++;\n}\n\n// Edges up to t n, the largest share noted in the column t falls in.\nfunction grow(S, t) {\n  S.t = min(TMAX, t);\n  const target = floor(S.t * S.n);\n  while (S.m \u003c target) {\n    addEdge(S);\n    S.share[min(PC - 1, floor((S.m / S.n / TMAX) * PC))] = S.big / S.n;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.size = cl(round(k[2]), -1, 1) + 1;\n  S.choice = cl(k[3], 0, 1);\n  // The first graph opens with T0 n edges already in, so the threshold\n  // comes 2.3 s in at Speed 2; the later ones start from no edges.\n  if (!S.started) {\n    fresh(S);\n    grow(S, T0);\n    S.started = true;\n  }\n  if (S.hold > HOLD || S.size !== S.grid || (input.btnPressed && input.btnPressed[0])) {\n    S.old.set(S.rgb);\n    S.fade = 1;\n    fresh(S);\n  }\n  const h = d * (S.speed / 2);\n  S.fade = max(0, S.fade - d / FADE);\n  for (let i = 0; i \u003c NL; i++) S.age[i] += h;\n  if (S.t \u003c TMAX) grow(S, S.t + 2 * h * RATE);\n  else S.hold += h;\n}\n\nfunction add(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) return;\n  const o = (y * W + x) * 3;\n  rgb[o] += r;\n  rgb[o + 1] += g;\n  rgb[o + 2] += b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, old, par, sz, hu, c } = S, g = GRIDS[S.grid], sp = g[0], nc = g[1], dot = g[3], ox = g[4], fd = S.fade, h = S.hue;\n  rgb.fill(0);\n  const cx = (v) => (v % nc) * sp + ox, cy = (v) => floor(v / nc) * sp;\n  // The vertices: the largest component cream, a vertex alone a dim slate\n  // dot, every other component a colour of its own that it keeps through\n  // each merge it wins, brighter as it grows.\n  const lift = dot === 1 ? 1.15 : 1;\n  for (let v = 0; v \u003c S.n; v++) {\n    const r = find(par, v), s = sz[r];\n    if (r === S.bigRoot && s > 1) hsv(h + 0.12, 0.12, 1, c, 0);\n    else if (s === 1) hsv(0.62, 0.4, 0.2 * lift, c, 0);\n    else hsv(wheel(h + 0.4 + 0.5 * hu[r]), 0.8, min(1, (0.6 + 0.3 * min(1, log2(s) / 5)) * lift), c, 0);\n    const x0 = cx(v), y0 = cy(v), R = c[0] * 255, G = c[1] * 255, B = c[2] * 255;\n    for (let yy = 0; yy \u003c dot; yy++) for (let xx = 0; xx \u003c dot; xx++) add(rgb, x0 + xx, y0 + yy, R, G, B);\n  }\n  // The newest edges, as lines between the centres of their dots: faint\n  // when they only bring in a vertex that was alone or close a cycle,\n  // bright when they join two components of some size.\n  const half = (dot - 1) / 2;\n  for (let i = 0; i \u003c NL; i++) {\n    if (S.age[i] >= LIFE) continue;\n    const a = S.lines[i * 3], b = S.lines[i * 3 + 1], small = S.lines[i * 3 + 2];\n    const w = (small ? 80 + 130 * min(1, log2(small) / 4) : 50) * (1 - S.age[i] / LIFE);\n    const ax = cx(a) + half, ay = cy(a) + half, bx = cx(b) + half, by = cy(b) + half;\n    const steps = max(1, round(max(abs(bx - ax), abs(by - ay))));\n    for (let j = 0; j \u003c= steps; j++) {\n      const u = j / steps;\n      add(rgb, round(ax + (bx - ax) * u), round(ay + (by - ay) * u), w, w, w);\n    }\n  }\n  // The plot: the threshold n / 2 dashed, the share the theory gives as n\n  // grows dim behind, and the share measured so far, with the ground under\n  // it tinted and its newest point brightest.\n  hsv(dimWheel(h + 0.5), 0.6, 0.45, c, 0);\n  const tc = floor((0.5 / TMAX) * PC), TR = c[0] * 255, TG = c[1] * 255, TB = c[2] * 255;\n  for (let y = PY0 - PH; y \u003c= PY0; y += 2) add(rgb, tc, y, TR, TG, TB);\n  let last = -1;\n  for (let x = 0; x \u003c PC; x++) {\n    add(rgb, x, PY0 + 1, 28, 28, 30);\n    add(rgb, x, round(PY0 - THEORY[x] * PH), TR * 0.85, TG * 0.85, TB * 0.85);\n    if (S.share[x] >= 0) last = x;\n  }\n  hsv(h + 0.12, 0.12, 1, c, 0);\n  for (let x = 0; x \u003c= last; x++) {\n    const s = S.share[x] >= 0 ? S.share[x] : 0, y1 = round(PY0 - s * PH), w = x === last ? 255 : 190;\n    for (let y = y1 + 1; y \u003c= PY0; y++) add(rgb, x, y, c[0] * 44, c[1] * 44, c[2] * 44);\n    add(rgb, x, y1, c[0] * w, c[1] * w, c[2] * w);\n  }\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      let r = min(255, rgb[p]), gg = min(255, rgb[p + 1]), b = min(255, rgb[p + 2]);\n      if (fd > 0) (r = r * (1 - fd) + old[p] * fd), (gg = gg * (1 - fd) + old[p + 1] * fd), (b = b * (1 - fd) + old[p + 2] * fd);\n      (rgb[p] = r), (rgb[p + 1] = gg), (rgb[p + 2] = b);\n      display.setPixel(x, y, r, gg, b);\n    }\n}\n","hough-transform":"// ===== Patternflow pattern =====\n// Title:   Hough Transform\n// Family:  algo\n// Idea:    Points land one by one on the top square, most of them on a few slowly turning line segments and the rest anywhere, and as each lands its sinusoid rho = x cos theta + y sin theta is swept column by column into the accumulator below while the line through the point at that theta turns round it above; the sinusoids of collinear points all cross at one bright peak, the strongest peaks are picked, and each one's line is drawn back across the square and its sinusoids tinted in one colour, while old points and their votes fade.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hough transform (Paul Hough, 1962), its rho-theta form (Richard Duda and Peter Hart, 1972), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=2..6, Noise=0.3..0.9\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the accumulator glows deep blue through azure to white and the found lines are lime, magenta, gold, sky, violet and green; the accumulator keeps to a strip of the wheel without orange and yellow, which go brown when dim, so at 0.25 it is violet, at 0.5 rose and magenta, at 0.75 teal and green, while the lines go the whole way round. The points stay white.\n// Knob 2: Speed. At 2 eight points land a second, the newest point's sinusoid sweeps the 64 columns in 0.11 s, a point and its votes fade by e every 6 s and are gone after 18 s, and each line turns 0.4 to 1 degree a second while its distance from the centre drifts 3 to 7 LEDs either way over 1.5 to 3.5 minutes; at 0.2 all of it ten times slower, a point every 1.25 s whose sweep takes 1.06 s, at 3 half as fast again.\n// Knob 3: Lines. How many line segments the points come from and how many peaks are picked, 2 to 6, rounded. At 2, with the opening's noise, each line holds about 16 of the 46 points' worth of weight, and in three 2-minute runs the picked peaks found the lines 99% of the time, within 0.15 rad of theta and 4 LEDs of rho; with 4 lines 81%, with 6 lines 64%, and a third of the 6 peaks then stand on crossings of noise.\n// Knob 4: Noise. The share of landing points that fall anywhere on the square instead of on a line: 0.3 at the opening, so the noise sinusoids lace the accumulator thinly in blue; at 0.6 the 2 lines are still found 87% of the time; at 0.9 one point in ten is on a line, the noise weaves a mesh whose crossings stand as high as the lines' peaks, and the 2 lines are found 20% of the time.\n\nconst W = 64, H = 128, SQ = 64, NT = 64, NR = 64;\nconst { floor, min, max, round, abs, sin, cos, exp, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The accumulator's colours come off a strip of the wheel that skips red,\n// orange and yellow, which turn brown and olive when dim: u from 0 to 1\n// runs green, cyan, blue, violet, magenta to rose.\nconst wheel = (u) => 0.34 + 0.63 * (u - floor(u));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Image space is the top 64 x 64, with its origin at the centre of the\n// square, between LEDs 31 and 32, and y down. A line is the set of points\n// with x cos theta + y sin theta = rho, theta in [0, pi) across the 64\n// columns of the bottom square and rho in [-32, 32) down its 64 rows, one\n// LED of rho a row. Only a point in a corner, more than 32 LEDs from the\n// centre, has a sinusoid that leaves through the top or the bottom for a\n// stretch of theta, and every line that passes within 32 LEDs of the\n// centre has its bin. Crossing theta = pi turns (theta, rho) into (theta - pi, -rho):\n// column 64 is column 0 with its rows upside down.\nconst R = 32, DT = PI / NT, C0 = 31.5;\nconst CE = new Float64Array(NT + 1), SE = new Float64Array(NT + 1);\nfor (let j = 0; j \u003c= NT; j++) (CE[j] = cos(j * DT)), (SE[j] = sin(j * DT));\nconst rowOf = (rho) => ((rho + R) / (2 * R)) * NR;\n\n// Points land at RATE a second and fade by e every TAU seconds, both in\n// panel time, Speed 2 being 1; a point older than 3 TAU is gone. The\n// accumulator is cast afresh every frame from the points there are, each\n// with its weight e^(-age / TAU), so it is always the exact transform of\n// the points on the square, and it fades as they do. FLASH is how long the\n// newest point's sweep across the columns takes.\nconst RATE = 8, TAU = 6, FLASH = 0.85 / RATE, MAXP = 200, LMAX = 6;\n// The colours the found lines and their peaks take, as hue offsets.\nconst LINE_HUES = [0.3, 0.86, 0.14, 0.55, 0.74, 0.4];\n// Where the six lines start in theta, as fractions of pi.\nconst BASE = [0.3, 0.66, 0.48, 0.12, 0.84, 0.2];\n\nexport function setup(params) {\n  const lines = [];\n  for (let i = 0; i \u003c LMAX; i++) {\n    // Spread the lines out in theta, the first two a third of the way in\n    // from either end of the accumulator, and give each a turn of its own,\n    // so two peaks start apart and drift past each other only now and then.\n    // A line's points come from the stretch a to b of its chord across the\n    // square, which slides 0.12 of the chord either way.\n    lines.push({\n      th: PI * (BASE[i] + 0.06 * random()), w: (random() \u003c 0.5 ? -1 : 1) * (0.007 + 0.01 * random()),\n      r0: (random() * 2 - 1) * 14, ra: 3 + 4 * random(), rw: 0.03 + 0.04 * random(), rp: 6.3 * random(),\n      a: 0.04 + 0.3 * random(), b: 0.65 + 0.3 * random(), sp: 0.2 + 0.2 * random(),\n    });\n  }\n  params.s = {\n    hue: 0, speed: 2, L: 2, q: 0.3, T: 0, acc: 0, warm: false, vref: 8,\n    lines, n: 0, newest: -1,\n    px: new Int8Array(MAXP), py: new Int8Array(MAXP), age: new Float32Array(MAXP), ln: new Int8Array(MAXP), own: new Int8Array(MAXP),\n    A: new Float32Array(NT * NR),\n    peaks: [],\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(3),\n  };\n}\n\n// Where line i is now: its normal angle and its distance from the centre.\nfunction lineNow(S, i) {\n  const L = S.lines[i];\n  return [L.th + L.w * S.T, L.r0 + L.ra * sin(L.rw * S.T + L.rp)];\n}\n\n// Take point i out, moving the last point into its place.\nfunction drop(S, i) {\n  const e = --S.n;\n  S.px[i] = S.px[e], S.py[i] = S.py[e], S.age[i] = S.age[e], S.ln[i] = S.ln[e];\n  if (S.newest === e) S.newest = i;\n}\n\nfunction spawn(S) {\n  // Drop the oldest point when the store is full.\n  if (S.n >= MAXP) {\n    let o = 0;\n    for (let i = 1; i \u003c S.n; i++) if (S.age[i] > S.age[o]) o = i;\n    drop(S, o);\n  }\n  let x, y, li = -1;\n  if (random() \u003c S.q) {\n    x = floor(random() * SQ);\n    y = floor(random() * SQ);\n  } else {\n    li = floor(random() * S.L);\n    const [th, rho] = lineNow(S, li), L = S.lines[li];\n    const c = cos(th), s = sin(th), fx = rho * c, fy = rho * s;\n    // The chord of the line across the square, t along the direction\n    // (-sin, cos) from the foot of the normal, and the segment the points\n    // come from: a stretch of the chord that slides slowly along it.\n    let t0 = -99, t1 = 99;\n    for (const [p, d] of [[fx, -s], [fy, c]]) {\n      if (abs(d) \u003c 1e-6) continue;\n      const ta = (-C0 - p) / d, tb = (C0 - p) / d;\n      t0 = max(t0, min(ta, tb));\n      t1 = min(t1, max(ta, tb));\n    }\n    if (t1 - t0 \u003c 8) return;\n    const slide = 0.12 * sin(L.sp * S.T + L.rp);\n    const a = cl(L.a + slide, 0, 0.6), b = cl(L.b + slide, a + 0.3, 1);\n    const t = t0 + (t1 - t0) * (a + (b - a) * random());\n    x = round(fx - s * t + C0);\n    y = round(fy + c * t + C0);\n    if (x \u003c 0 || x >= SQ || y \u003c 0 || y >= SQ) return;\n  }\n  const k = S.n++;\n  S.px[k] = x, S.py[k] = y, S.age[k] = 0, S.ln[k] = li;\n  S.newest = k;\n}\n\n// One point's votes: in column j the sinusoid runs from rho(theta_j) to\n// rho(theta_j+1), and the point's weight is spread evenly over the rows it\n// passes, at least one row's width, so every column gets the same weight\n// and a steep stretch of the curve is drawn as a dim run, not a dotted one.\nfunction cast(A, x, y, w, nj) {\n  const X = x - C0 + 0.5, Y = y - C0 + 0.5;\n  let ra = rowOf(X * CE[0] + Y * SE[0]);\n  for (let j = 0; j \u003c nj; j++) {\n    const rb = rowOf(X * CE[j + 1] + Y * SE[j + 1]);\n    let lo = min(ra, rb), hi = max(ra, rb);\n    ra = rb;\n    if (hi - lo \u003c 1) {\n      const m = (lo + hi) / 2;\n      lo = m - 0.5;\n      hi = m + 0.5;\n    }\n    const k = w / (hi - lo);\n    for (let r = max(0, floor(lo)), e = min(NR - 1, floor(hi)); r \u003c= e; r++) {\n      const o = min(hi, r + 1) - max(lo, r);\n      if (o > 0) A[r * NT + j] += k * o;\n    }\n  }\n}\n\n// The accumulator at column j, row r, reading past the ends through the\n// theta = pi seam.\nfunction at(A, j, r) {\n  if (j \u003c 0) (j += NT), (r = NR - 1 - r);\n  else if (j >= NT) (j -= NT), (r = NR - 1 - r);\n  return r \u003c 0 || r >= NR ? 0 : A[r * NT + j];\n}\n\n// The L strongest peaks: bins at least as high as every bin within 3, over\n// a quarter of the highest and over 2.5 points' worth of votes, refined to\n// a fraction of a bin by a parabola through each axis's three bins.\nfunction findPeaks(S) {\n  const A = S.A, cand = [];\n  let top = 0;\n  for (let i = 0; i \u003c NT * NR; i++) top = max(top, A[i]);\n  const floorV = max(2.5, 0.25 * top);\n  for (let r = 0; r \u003c NR; r++)\n    for (let j = 0; j \u003c NT; j++) {\n      const v = A[r * NT + j];\n      if (v \u003c floorV) continue;\n      let ok = true;\n      for (let dr = -3; dr \u003c= 3 && ok; dr++)\n        for (let dj = -3; dj \u003c= 3; dj++) {\n          if (!dr && !dj) continue;\n          const u = at(A, j + dj, r + dr);\n          if (u > v || (u === v && (dr \u003c 0 || (dr === 0 && dj \u003c 0)))) {\n            ok = false;\n            break;\n          }\n        }\n      if (ok) cand.push([v, j, r]);\n    }\n  cand.sort((a, b) => b[0] - a[0]);\n  const out = [];\n  for (const [v, j, r] of cand) {\n    if (out.length >= S.L) break;\n    const l = at(A, j - 1, r), rr = at(A, j + 1, r), u = at(A, j, r - 1), d = at(A, j, r + 1);\n    const fj = j + cl((0.5 * (l - rr)) / (l - 2 * v + rr || -1), -0.5, 0.5);\n    const fr = r + cl((0.5 * (u - d)) / (u - 2 * v + d || -1), -0.5, 0.5);\n    out.push({ v, j, r, th: (fj + 0.5) * DT, rho: ((fr + 0.5) / NR) * 2 * R - R, slot: -1 });\n  }\n  // Each peak keeps the colour of the peak nearest it last frame, within 6\n  // bins; a new one takes a free colour.\n  const used = new Uint8Array(LMAX);\n  for (const p of out) {\n    let best = -1, bd = 36;\n    S.peaks.forEach((q, i) => {\n      if (q.slot \u003c 0 || used[q.slot]) return;\n      let dj = abs(q.j - p.j), dr = abs(q.r - p.r);\n      if (dj > NT / 2) (dj = NT - dj), (dr = abs(NR - 1 - q.r - p.r));\n      const dd = dj * dj + dr * dr;\n      if (dd \u003c bd) (bd = dd), (best = i);\n    });\n    if (best >= 0) p.slot = S.peaks[best].slot;\n    else for (let k = 0; k \u003c LMAX; k++) if (!used[k] && !out.some((o) => o.slot === k)) { p.slot = k; break; }\n    if (p.slot >= 0) used[p.slot] = 1;\n  }\n  S.peaks = out;\n}\n\n// How many columns of a point's sinusoid are cast: all 64 once its sweep\n// of FLASH seconds is over. Only the newest point sweeps, so when the next\n// one lands a sweep still running is finished at once.\nconst sweepAge = (S, i) => (i === S.newest ? S.age[i] : 1e9);\nconst sweepOf = (age) => min(NT, floor((NT * age) / FLASH) + 1);\n\nfunction step(S, d) {\n  S.T += d;\n  for (let i = 0; i \u003c S.n; i++) S.age[i] += d;\n  for (let i = 0; i \u003c S.n; )\n    if (S.age[i] > 3 * TAU) drop(S, i);\n    else i++;\n  S.acc += d * RATE;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    spawn(S);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.3], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.L = round(cl(k[2], 2, 6));\n  S.q = cl(k[3], 0.3, 0.9);\n  if (!S.warm) {\n    // Open on a square that has been filling for 12 s.\n    for (let i = 0; i \u003c 360; i++) step(S, 1 / 30);\n    S.warm = true;\n  }\n  step(S, (d * S.speed) / 2);\n  S.A.fill(0);\n  // The newest point casts its votes column by column as its sweep passes.\n  for (let i = 0; i \u003c S.n; i++) cast(S.A, S.px[i], S.py[i], exp(-S.age[i] / TAU), sweepOf(sweepAge(S, i)));\n  findPeaks(S);\n  // Each point within 1 LED of a found line belongs to it, the nearest if\n  // two are that close: those are the votes that made the peak.\n  for (let i = 0; i \u003c S.n; i++) {\n    const X = S.px[i] - C0 + 0.5, Y = S.py[i] - C0 + 0.5;\n    let best = -1, bd = 1;\n    for (const p of S.peaks) {\n      const dd = abs(X * cos(p.th) + Y * sin(p.th) - p.rho);\n      if (p.slot >= 0 && dd \u003c bd) (bd = dd), (best = p.slot);\n    }\n    S.own[i] = best;\n  }\n  let top = 0;\n  for (let i = 0; i \u003c NT * NR; i++) top = max(top, S.A[i]);\n  // The brightness scale follows the highest bin slowly, so a peak that\n  // grows brightens instead of the whole accumulator dimming round it.\n  S.vref += (max(4, top) - S.vref) * min(1, d * 1.5);\n}\n\nfunction add(S, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] += r, o[p + 1] += g, o[p + 2] += b;\n}\nfunction lift(S, x, y, c) {\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = max(o[p], c[0] * 255), o[p + 1] = max(o[p + 1], c[1] * 255), o[p + 2] = max(o[p + 2], c[2] * 255);\n}\nfunction put(S, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = r, o[p + 1] = g, o[p + 2] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.rgb, c = S.c, A = S.A, hu = S.hue;\n  o.fill(0);\n  // The accumulator: deep blue at a trace of a vote, azure, then white only\n  // near the top, on brightness (v / vref)^0.85, so one fresh noise\n  // sinusoid alone shows at about 45 of 255 and the peaks stand out of the\n  // band of flat sinusoids that the points near the centre lay along rho = 0.\n  for (let r = 0; r \u003c NR; r++)\n    for (let j = 0; j \u003c NT; j++) {\n      const v = A[r * NT + j] / S.vref;\n      if (v \u003c= 0.004) continue;\n      const b = min(1, v) ** 0.85;\n      hsv(wheel(hu + 0.476 - 0.15 * b), 1 - (0.8 * max(0, b - 0.7)) / 0.3, 0.06 + 0.94 * b, c, 0);\n      put(S, j, SQ + r, c[0] * 255, c[1] * 255, c[2] * 255);\n    }\n  // The sinusoids of the points a found line owns, in that line's colour\n  // at their weight, each LED kept at the brighter of it and the heat, so\n  // the bundle runs into its peak and the peak stays white.\n  for (let i = 0; i \u003c S.n; i++) {\n    if (S.own[i] \u003c 0 || sweepAge(S, i) \u003c FLASH) continue;\n    hsv(hu + LINE_HUES[S.own[i]], 0.85, 0.55 * exp(-S.age[i] / TAU) ** 1.5, c, 0);\n    const X = S.px[i] - C0 + 0.5, Y = S.py[i] - C0 + 0.5;\n    let ra = rowOf(X * CE[0] + Y * SE[0]);\n    for (let j = 0; j \u003c NT; j++) {\n      const rb = rowOf(X * CE[j + 1] + Y * SE[j + 1]);\n      for (let r = floor(min(ra, rb)), e = floor(max(ra, rb)); r \u003c= e; r++) if (r >= 0 && r \u003c NR) lift(S, j, SQ + r, c);\n      ra = rb;\n    }\n  }\n  // The newest points' sinusoids in white over the columns cast so far, the\n  // cursor column brightest; a finished one fades over the next 1.5 sweeps.\n  // While a point sweeps, the line through it whose normal is at the\n  // cursor's theta turns round it on the square: each bin of the sinusoid\n  // is one of those lines.\n  const HOLD = 1.5 / RATE;\n  for (let i = 0; i \u003c S.n; i++) {\n    const age = S.age[i];\n    if (age >= FLASH + HOLD) continue;\n    const sa = sweepAge(S, i), nj = sweepOf(sa), a = sa \u003c FLASH ? 1 : min(1, 1 - (age - FLASH) / HOLD);\n    const X = S.px[i] - C0 + 0.5, Y = S.py[i] - C0 + 0.5;\n    let ra = rowOf(X * CE[0] + Y * SE[0]);\n    for (let j = 0; j \u003c nj; j++) {\n      const rb = rowOf(X * CE[j + 1] + Y * SE[j + 1]), g = (j === nj - 1 && sa \u003c FLASH ? 255 : 200) * a;\n      for (let r = floor(min(ra, rb)), e = floor(max(ra, rb)); r \u003c= e; r++) if (r >= 0 && r \u003c NR) add(S, j, SQ + r, g, g, g);\n      ra = rb;\n    }\n    if (sa \u003c FLASH) {\n      const th = (nj - 0.5) * DT, cs = cos(th), sn = sin(th), rho = X * cs + Y * sn;\n      for (let y = 0; y \u003c SQ; y++)\n        for (let x = 0; x \u003c SQ; x++) {\n          const dd = abs((x - C0 + 0.5) * cs + (y - C0 + 0.5) * sn - rho);\n          if (dd \u003c 1) add(S, x, y, 90 * (1 - dd), 90 * (1 - dd), 90 * (1 - dd));\n        }\n    }\n  }\n  // The found lines across the image square, each in its peak's colour,\n  // 2.4 LEDs wide and fading out from the middle.\n  for (const p of S.peaks) {\n    if (p.slot \u003c 0) continue;\n    hsv(hu + LINE_HUES[p.slot], 0.85, 1, c, 0);\n    const cs = cos(p.th), sn = sin(p.th), str = 0.35 + 0.4 * min(1, p.v / S.vref);\n    for (let y = 0; y \u003c SQ; y++)\n      for (let x = 0; x \u003c SQ; x++) {\n        const dd = abs((x - C0) * cs + (y - C0) * sn - p.rho);\n        if (dd \u003c 1.2) {\n          const a = (1 - dd / 1.2) * str * 255;\n          add(S, x, y, c[0] * a, c[1] * a, c[2] * a);\n        }\n      }\n    // Its peak: four LEDs in the same colour at the corners of the 5 x 5\n    // round the bin, leaving the glow of the crossing inside them alone.\n    for (let dr = -2; dr \u003c= 2; dr += 4)\n      for (let dj = -2; dj \u003c= 2; dj += 4) {\n        let j = p.j + dj, r = p.r + dr;\n        if (j \u003c 0) (j += NT), (r = NR - 1 - r);\n        else if (j >= NT) (j -= NT), (r = NR - 1 - r);\n        if (r >= 0 && r \u003c NR) put(S, j, SQ + r, c[0] * 255, c[1] * 255, c[2] * 255);\n      }\n  }\n  // The points, white, as bright as their weight, 255 new and 50 when they\n  // go; the point sweeping has a ring.\n  for (let i = 0; i \u003c S.n; i++) {\n    const w = exp(-S.age[i] / TAU), x = S.px[i], y = S.py[i], g = 40 + 215 * w;\n    put(S, x, y, g, g, g);\n    if (sweepAge(S, i) \u003c FLASH) {\n      const e = 200;\n      for (const [dx, dy] of [[-2, 0], [2, 0], [0, -2], [0, 2], [-1, -1], [1, -1], [-1, 1], [1, 1]])\n        if (y + dy >= 0 && y + dy \u003c SQ) add(S, x + dx, y + dy, e, e, e);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, round(o[p])), min(255, round(o[p + 1])), min(255, round(o[p + 2])));\n}\n","jordan-curve":"// ===== Patternflow pattern =====\n// Title:   Jordan Curve\n// Family:  topology\n// Idea:    One long winding simple closed curve fills the panel and slowly reshapes without ever touching itself; a probe wanders over it casting a ray to the far end of the panel, the ray's crossings with the curve are marked in gold and counted in pips along the top, and from the probe a flood of the colour the count's parity names, odd inside and even outside, spreads through the region it stands in until inside and outside come up as two interlocking territories.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Jordan curve theorem (Camille Jordan, 1887), its first proof accepted as complete (Oswald Veblen, 1905), the crossing-number test for a point in a polygon (M. Shimrat, 1962), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tension=-1..1, Probes=1..4\n//\n// Knob 1: Hue. Moves both territories along a strip of the wheel that leaves out red, orange and yellow, which go brown when dim: at 0 the inside is teal and the outside violet, at 0.25 blue and crimson, at 0.5 violet and teal, at 0.75 crimson and blue. The curve stays white, the crossings and the count gold, the probe white.\n// Knob 2: Speed. At 2 the probe walks 7 LEDs a second, a flood takes 250 LEDs a frame and rests 0.8 s once its region is full, fresh colour fades by e every 5 s down to a third, and the curve is offered 60 changes a second, of which about 7 cells take one, each sliding across in 0.7 s; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Tension. How much the curve's length costs: a cell changes side with Metropolis probability min(1, e^-dE), E = -beta L + 0.03 (A - A*)^2, L the lattice edges the curve crosses, and beta = 0.4 - 0.5 x Tension below 0 and 0.4 - 1.1 x Tension above. At -1 (beta 0.9) inside and outside are two trees of corridors one cell wide and the curve is about 1390 LEDs long; at the opening 0 (beta 0.4) it is about 1220 LEDs round a branching coral of 127 of the 242 free cells, and a ray crosses it 8 times on average, up to 18; at 0.5 about 940 LEDs; at 1 (beta -0.7) one lobed blob of about 310.\n// Knob 4: Probes. 1 to 4, rounded, each with its own ray, its own row of pips and its own two floods, so with 4 both territories are refreshed most of the time.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs, sqrt, sin, cos, exp, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Region colours come off a strip of the wheel that skips red, orange and\n// yellow, which turn brown and olive when dim.\nconst wheel = (u) => 0.34 + 0.63 * (u - floor(u));\n\n// The curve is the zero set of a function that is linear on each triangle\n// of a jittered triangular lattice of cells SP LEDs apart. A cell holds a\n// value u in [-1, 1] and is inside where u is positive. Within a triangle\n// whose corners are not all one sign the zero set is one straight segment,\n// so the zero set is a union of disjoint simple closed curves and never\n// touches itself. A cell changes side only when that keeps the cells\n// inside one connected piece and the cells outside another, so there is\n// exactly one curve. The cells within MARGIN of the panel's edge are held\n// outside, so the outside reaches the edge all round and a ray that ends\n// there ends outside.\nconst BETA0 = 0.4, LAMBDA = 0.03, FILL = 0.47;\n// Tries a second, the seconds a changing cell takes to slide across, the\n// floor and fade time of fresh colour, LEDs a flood takes a frame at Speed\n// 1, the probe's speed, the ray's swing rate and a flood's rest.\nconst TRY = 60, SLIDE = 0.7, PFLOOR = 0.35, PTAU = 5, FLOOD = 125, VEL = 7, RAYW = 0.35, REST = 0.8;\nconst SP = 5.5, RH = (SP * Math.sqrt(3)) / 2, MARGIN = 4.5;\nconst NCOL = Math.ceil(W / SP) + 3, NROW = Math.ceil(H / RH) + 3, NC = NCOL * NROW;\n// Six neighbours of each cell in turning order: right, up-right, up-left,\n// left, down-left, down-right.\nconst NB = new Int32Array(NC * 6).fill(-1);\nfor (let j = 0; j \u003c NROW; j++)\n  for (let i = 0; i \u003c NCOL; i++) {\n    const c = j * NCOL + i, odd = j & 1;\n    const nb = [[i + 1, j], [i + odd, j - 1], [i - 1 + odd, j - 1], [i - 1, j], [i - 1 + odd, j + 1], [i + odd, j + 1]];\n    nb.forEach(([a, b], k) => {\n      if (a >= 0 && a \u003c NCOL && b >= 0 && b \u003c NROW) NB[c * 6 + k] = b * NCOL + a;\n    });\n  }\n// Triangles: each cell with its right and down-right neighbours, and with\n// its down-right and down-left ones.\nconst TRI = [];\nfor (let c = 0; c \u003c NC; c++) {\n  const r = NB[c * 6], dr = NB[c * 6 + 5], dl = NB[c * 6 + 4];\n  if (r >= 0 && dr >= 0) TRI.push(c, dr, r);\n  if (dr >= 0 && dl >= 0) TRI.push(c, dl, dr);\n}\nconst NT = TRI.length / 3;\n\nexport function setup(params) {\n  const CX = new Float32Array(NC), CY = new Float32Array(NC), FIXED = new Uint8Array(NC), LT = new Int32Array(N);\n  // The lattice is jittered once, by up to 0.22 of the spacing, small\n  // enough that no triangle turns over.\n  for (let j = 0; j \u003c NROW; j++)\n    for (let i = 0; i \u003c NCOL; i++) {\n      const c = j * NCOL + i, a = random() * 2 * PI, r = 0.22 * SP * sqrt(random());\n      CX[c] = (i - 1.5 + (j & 1 ? 0.5 : 0)) * SP + (W - (NCOL - 3) * SP) / 2 + r * cos(a);\n      CY[c] = (j - 1.5) * RH + (H - (NROW - 3) * RH) / 2 + r * sin(a);\n      let full = true;\n      for (let k = 0; k \u003c 6; k++) if (NB[c * 6 + k] \u003c 0) full = false;\n      FIXED[c] = !full || CX[c] \u003c MARGIN || CX[c] > W - 1 - MARGIN || CY[c] \u003c MARGIN || CY[c] > H - 1 - MARGIN ? 1 : 0;\n    }\n  // Each LED's triangle and its three barycentric weights; and each\n  // triangle's gradient of the three weights, for the distance to the curve.\n  const LV = new Int32Array(N * 3).fill(-1), LW = new Float32Array(N * 3), GR = new Float32Array(NT * 6);\n  for (let t = 0; t \u003c NT; t++) {\n    const a = TRI[3 * t], b = TRI[3 * t + 1], c = TRI[3 * t + 2];\n    const x0 = CX[a], y0 = CY[a], x1 = CX[b], y1 = CY[b], x2 = CX[c], y2 = CY[c];\n    const det = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n    // d lambda_k / dx and / dy.\n    GR[6 * t] = (y1 - y2) / det, GR[6 * t + 1] = (x2 - x1) / det;\n    GR[6 * t + 2] = (y2 - y0) / det, GR[6 * t + 3] = (x0 - x2) / det;\n    GR[6 * t + 4] = (y0 - y1) / det, GR[6 * t + 5] = (x1 - x0) / det;\n    const xa = max(0, floor(min(x0, x1, x2))), xb = min(W - 1, Math.ceil(max(x0, x1, x2)));\n    const ya = max(0, floor(min(y0, y1, y2))), yb = min(H - 1, Math.ceil(max(y0, y1, y2)));\n    for (let y = ya; y \u003c= yb; y++)\n      for (let x = xa; x \u003c= xb; x++) {\n        const p = y * W + x;\n        if (LV[3 * p] >= 0) continue;\n        const l1 = ((x - x0) * (y2 - y0) - (x2 - x0) * (y - y0)) / det;\n        const l2 = ((x1 - x0) * (y - y0) - (x - x0) * (y1 - y0)) / det;\n        const l0 = 1 - l1 - l2;\n        if (l0 \u003c -1e-6 || l1 \u003c -1e-6 || l2 \u003c -1e-6) continue;\n        LV[3 * p] = a, LV[3 * p + 1] = b, LV[3 * p + 2] = c;\n        LW[3 * p] = l0, LW[3 * p + 1] = l1, LW[3 * p + 2] = l2;\n        LT[p] = t;\n      }\n  }\n  const u = new Float32Array(NC).fill(-1), tgt = new Int8Array(NC).fill(-1);\n  // Start from one cell in the middle.\n  let c0 = 0, bd = 1e9;\n  for (let c = 0; c \u003c NC; c++) {\n    const d = (CX[c] - W / 2) ** 2 + (CY[c] - H / 2) ** 2;\n    if (!FIXED[c] && d \u003c bd) (bd = d), (c0 = c);\n  }\n  u[c0] = 1, tgt[c0] = 1;\n  let free = 0;\n  for (let c = 0; c \u003c NC; c++) if (!FIXED[c]) free++;\n  params.s = {\n    hue: 0, speed: 2, tension: 0, nprobe: 1, warm: false,\n    LV, LW, GR, LT, FIXED, CX, CY, u, tgt, area: 1, free, busy: [],\n    f: new Float32Array(N), gt: new Float32Array(NT),\n    paint: new Float32Array(N), cls: new Int8Array(N), heal: new Int32Array(2 * N), glow: new Float32Array(N), side: new Int8Array(N),\n    probes: [], tryAcc: 0, rgb: new Float32Array(N * 3), c: new Float32Array(3), c2: new Float32Array(3),\n  };\n}\n\n// Can cell c change sides without changing the topology? Its neighbours,\n// read round in turn, must be one run of in and one run of out: then adding\n// it to either side glues a disc to that side along an arc.\nfunction simple(S, c) {\n  let runs = 0;\n  const u = S.u;\n  for (let k = 0; k \u003c 6; k++) {\n    const a = u[NB[c * 6 + k]] > 0, b = u[NB[c * 6 + ((k + 1) % 6)]] > 0;\n    if (a !== b) runs++;\n  }\n  return runs === 2;\n}\n\nfunction inCount(S, c) {\n  let n = 0;\n  for (let k = 0; k \u003c 6; k++) if (S.u[NB[c * 6 + k]] > 0) n++;\n  return n;\n}\n\n// One Metropolis try: a cell, if simple and with no neighbour already\n// moving, changes sides with probability min(1, e^-dE), where\n// E = -beta L + LAMBDA (A - A*)^2, L the number of lattice edges the curve\n// crosses, A the cells inside and A* = FILL of the free cells. No two\n// neighbours move at once, so a cell that was simple when it set off is\n// still simple when its value crosses zero. instant flips it at once (for\n// the warm-up); otherwise its value starts to slide towards the other sign.\nfunction attempt(S, beta, instant) {\n  const c = floor(random() * NC);\n  if (S.FIXED[c] || S.u[c] !== S.tgt[c]) return;\n  for (let k = 0; k \u003c 6; k++) {\n    const n = NB[c * 6 + k];\n    if (S.u[n] !== S.tgt[n]) return;\n  }\n  if (!simple(S, c)) return;\n  const k = inCount(S, c), isIn = S.u[c] > 0;\n  const dL = isIn ? 2 * k - 6 : 6 - 2 * k, dA = isIn ? -1 : 1;\n  const A0 = S.free * FILL, a = S.area - A0;\n  const dE = -beta * dL + LAMBDA * ((a + dA) ** 2 - a ** 2);\n  if (dE > 0 && random() >= exp(-dE)) return;\n  S.area += dA;\n  S.tgt[c] = isIn ? -1 : 1;\n  if (instant) S.u[c] = S.tgt[c];\n  else S.busy.push(c);\n}\n\n// A probe keeps a flood for each side, so a flood it left behind on\n// crossing the curve runs on to the end of its region.\nconst flood = (sign, cls) => ({ sign, cls, q: new Int32Array(N), seen: new Int32Array(N), gen: 0, head: 0, tail: 0, rest: 0 });\nfunction newProbe(S, i) {\n  return { x: 12 + random() * 40, y: 16 + random() * 96, h: random() * 2 * PI, ray: PI / 2, down: 1, ph: random() * 2 * PI, F: [flood(1, 1), flood(-1, 2)], hits: [], i };\n}\n\n// The function at any point of the panel, read bilinearly off the LEDs.\nfunction fAt(S, x, y) {\n  const f = S.f;\n  x = cl(x, 0, W - 1.001);\n  y = cl(y, 0, H - 1.001);\n  const i = floor(x), j = floor(y), a = x - i, b = y - j, p = j * W + i;\n  return (f[p] * (1 - a) + f[p + 1] * a) * (1 - b) + (f[p + W] * (1 - a) + f[p + W + 1] * a) * b;\n}\n\n// March the probe's ray to the panel's edge in quarter-LED steps; every\n// change of sign is a crossing, placed where the line through the two\n// samples meets zero. A tangency the steps miss loses two crossings at\n// once and leaves the parity alone.\nfunction castRay(S, P) {\n  const dx = cos(P.ray), dy = sin(P.ray);\n  // From the centre of the LED the probe stands on, so the parity and the\n  // sign the flood follows are read at the same point.\n  P.sx = round(P.x);\n  P.sy = round(P.y);\n  let tmax = 1e9;\n  if (dx > 1e-6) tmax = min(tmax, (W - 0.5 - P.sx) / dx);\n  if (dx \u003c -1e-6) tmax = min(tmax, (-0.5 - P.sx) / dx);\n  if (dy > 1e-6) tmax = min(tmax, (H - 0.5 - P.sy) / dy);\n  if (dy \u003c -1e-6) tmax = min(tmax, (-0.5 - P.sy) / dy);\n  P.tmax = tmax;\n  P.hits.length = 0;\n  let prev = fAt(S, P.sx, P.sy);\n  for (let t = 0.25; t \u003c= tmax; t += 0.25) {\n    const v = fAt(S, P.sx + dx * t, P.sy + dy * t);\n    if ((v > 0) !== (prev > 0)) P.hits.push(t - 0.25 + (0.25 * prev) / (prev - v));\n    prev = v;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tension = cl(k[2], -1, 1);\n  S.nprobe = round(cl(k[3], 1, 4));\n  const beta = BETA0 - (S.tension \u003c 0 ? 0.5 : 1.1) * S.tension, ds = (d * S.speed) / 2;\n  if (!S.warm) {\n    // Grow the opening curve from one cell, 90000 tries at the knob's beta.\n    for (let i = 0; i \u003c 90000; i++) attempt(S, beta, true);\n    S.warm = true;\n  }\n  // Shape: tries at TRY a second, each accepted one sliding its cell's\n  // value across zero in SLIDE seconds.\n  S.tryAcc += ds * TRY;\n  while (S.tryAcc >= 1) {\n    S.tryAcc -= 1;\n    attempt(S, beta, false);\n  }\n  const step = (2 * ds) / SLIDE;\n  for (let i = 0; i \u003c S.busy.length; ) {\n    const c = S.busy[i], g = S.tgt[c];\n    S.u[c] = g > 0 ? min(1, S.u[c] + step) : max(-1, S.u[c] - step);\n    if (S.u[c] === g) {\n      S.busy[i] = S.busy[S.busy.length - 1];\n      S.busy.pop();\n    } else i++;\n  }\n  // The function on every LED, and each triangle's gradient length. An LED\n  // the curve has swept over to the other side loses its colour. Fresh\n  // paint fades by e every PTAU seconds down to PFLOOR, the glow of a flood\n  // front by e every 0.15 s.\n  const { LV, LW, GR, u, f } = S;\n  const cls = S.cls, side = S.side, paint = S.paint, glow = S.glow, heal = S.heal;\n  const fade = min(1, ds / PTAU), gf = exp(-ds / 0.15);\n  for (let p = 0; p \u003c N; p++) {\n    const q = 3 * p;\n    const v = (f[p] = LV[q] \u003c 0 ? -1 : LW[q] * u[LV[q]] + LW[q + 1] * u[LV[q + 1]] + LW[q + 2] * u[LV[q + 2]]);\n    const sd = v > 0 ? 1 : -1;\n    if (sd !== side[p]) (cls[p] = 0), (side[p] = sd);\n    if (paint[p] > PFLOOR) paint[p] -= (paint[p] - PFLOOR) * fade;\n    glow[p] *= gf;\n  }\n  for (let t = 0; t \u003c NT; t++) {\n    const a = u[TRI[3 * t]], b = u[TRI[3 * t + 1]], c = u[TRI[3 * t + 2]];\n    const gx = a * GR[6 * t] + b * GR[6 * t + 2] + c * GR[6 * t + 4], gy = a * GR[6 * t + 1] + b * GR[6 * t + 3] + c * GR[6 * t + 5];\n    S.gt[t] = sqrt(gx * gx + gy * gy) + 1e-6;\n  }\n  // A dark LED takes the colour of a coloured neighbour on its own side, one\n  // LED a frame, so colour creeps on within a region it has already reached\n  // and never crosses the curve. A region no flood has reached stays dark.\n  let nh = 0;\n  for (let p = 0; p \u003c N; p++) {\n    if (cls[p]) continue;\n    const x = p & 63, sd = side[p];\n    const q = x > 0 && side[p - 1] === sd && cls[p - 1] > 0 ? p - 1\n      : x \u003c W - 1 && side[p + 1] === sd && cls[p + 1] > 0 ? p + 1\n      : p >= W && side[p - W] === sd && cls[p - W] > 0 ? p - W\n      : p \u003c N - W && side[p + W] === sd && cls[p + W] > 0 ? p + W : -1;\n    if (q >= 0) (heal[nh++] = p), (heal[nh++] = q);\n  }\n  for (let i = 0; i \u003c nh; i += 2) (cls[heal[i]] = cls[heal[i + 1]]), (paint[heal[i]] = paint[heal[i + 1]]);\n  while (S.probes.length \u003c S.nprobe) S.probes.push(newProbe(S, S.probes.length));\n  S.probes.length = S.nprobe;\n  const budget = round(FLOOD * S.speed);\n  for (const P of S.probes) {\n    // Wander: a heading that turns at random, turned back off the margin.\n    P.h += (random() - 0.5) * 6 * ds;\n    let vx = cos(P.h) * VEL * ds, vy = sin(P.h) * VEL * ds;\n    if (P.x + vx \u003c 8 || P.x + vx > W - 9) (P.h = PI - P.h), (vx = -vx);\n    if (P.y + vy \u003c 8 || P.y + vy > H - 9) (P.h = -P.h), (vy = -vy);\n    P.x += vx;\n    P.y += vy;\n    // The ray aims at the farther end of the panel, down from the top half\n    // and up from the bottom half with 32 rows of slack between, leans\n    // towards the middle column by up to 29 degrees and swings 29 degrees\n    // either way about that; it turns at most 1.5 radians a second, so a\n    // change of end sweeps it round through the horizontal.\n    if (P.down > 0 && P.y > 80) P.down = -1;\n    else if (P.down \u003c 0 && P.y \u003c 48) P.down = 1;\n    P.ph += RAYW * ds;\n    let dr = P.down * (PI / 2 + (0.5 * (P.x - 31.5)) / 31.5) + 0.5 * sin(P.ph) - P.ray;\n    dr -= 2 * PI * round(dr / (2 * PI));\n    P.ray += cl(dr, -1.5 * ds, 1.5 * ds);\n    castRay(S, P);\n    // Odd: the probe is inside, and the inside's flood is the one it may\n    // start, once that flood has run out and rested REST seconds.\n    const Fh = P.F[P.hits.length & 1 ? 0 : 1], pl = P.sy * W + P.sx;\n    if (Fh.head >= Fh.tail && (Fh.rest -= ds) \u003c= 0) {\n      Fh.rest = REST;\n      Fh.gen++;\n      Fh.head = Fh.tail = 0;\n      Fh.q[Fh.tail++] = pl;\n      Fh.seen[pl] = Fh.gen;\n    }\n    // The flood takes a random LED off its front each time, Eden's growth\n    // rather than a breadth-first wave, so in the open it spreads as a\n    // ragged disc instead of a diamond.\n    for (const F of P.F)\n      for (let n = 0; n \u003c budget && F.head \u003c F.tail; n++) {\n        const r = F.head + floor(random() * (F.tail - F.head)), p = F.q[r];\n        F.q[r] = F.q[F.head++];\n        if ((f[p] > 0 ? 1 : -1) !== F.sign) continue;\n        S.cls[p] = F.cls;\n        S.paint[p] = 1;\n        S.glow[p] = 1;\n        const x = p & 63, y = p >> 6;\n        if (x > 0) push(S, F, p - 1);\n        if (x \u003c W - 1) push(S, F, p + 1);\n        if (y > 0) push(S, F, p - W);\n        if (y \u003c H - 1) push(S, F, p + W);\n      }\n  }\n}\nfunction push(S, P, p) {\n  if (P.seen[p] === P.gen) return;\n  if ((S.f[p] > 0 ? 1 : -1) !== P.sign) return;\n  P.seen[p] = P.gen;\n  P.q[P.tail++] = p;\n}\n\nfunction put(S, x, y, r, g, b) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = r, o[p + 1] = g, o[p + 2] = b;\n}\nfunction lift(S, x, y, v) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3, o = S.rgb;\n  o[p] = max(o[p], v), o[p + 1] = max(o[p + 1], v), o[p + 2] = max(o[p + 2], v);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const o = S.rgb, c = S.c, c2 = S.c2, hu = S.hue;\n  // Inside and outside colours, at 150 fresh and 52 faded; an LED no flood\n  // has coloured is all but dark, and a flood front glows 70 brighter.\n  hsv(wheel(hu + 0.2), 0.85, 1, c, 0);\n  hsv(wheel(hu + 0.68), 0.75, 1, c2, 0);\n  for (let p = 0; p \u003c N; p++) {\n    const q = 3 * p, kc = S.cls[p], a = S.paint[p] * 150, g = S.glow[p] * 70;\n    const col = kc === 1 ? c : c2;\n    let r = 0, gg = 0, b = 0;\n    if (kc) (r = col[0] * a + g), (gg = col[1] * a + g), (b = col[2] * a + g);\n    else r = gg = b = 8;\n    // The curve, white and about 1.7 LEDs wide: an LED's distance to the\n    // zero set is |f| over the gradient's length on its triangle.\n    const t = S.LT[p], dd = abs(S.f[p]) / S.gt[t], k = cl2(1 - dd / 0.85);\n    o[q] = r + (235 - r) * k, o[q + 1] = gg + (235 - gg) * k, o[q + 2] = b + (235 - b) * k;\n  }\n  // Each probe's ray, a pale line no brighter than the curve; its\n  // crossings as gold beads on the curve; its count as gold pips along the\n  // top, one row a probe; the probe a white cross.\n  for (const P of S.probes) {\n    const dx = cos(P.ray), dy = sin(P.ray);\n    for (let t = 1.5; t \u003c P.tmax; t += 0.5) lift(S, P.sx + dx * t, P.sy + dy * t, 150);\n    for (const t of P.hits) {\n      const x = P.sx + dx * t, y = P.sy + dy * t;\n      for (const [ex, ey] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) put(S, x + ex, y + ey, 190, 120, 10);\n      put(S, x, y, 255, 200, 40);\n    }\n    for (let i = 0; i \u003c P.hits.length; i++) put(S, 2 + 2 * (i % 30), 1 + 2 * P.i + 8 * floor(i / 30), 255, 200, 40);\n    for (const [ex, ey] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) put(S, P.sx + ex, P.sy + ey, 255, 255, 255);\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, min(255, round(o[p])), min(255, round(o[p + 1])), min(255, round(o[p + 2])));\n}\nconst cl2 = (v) => (v \u003c 0 ? 0 : v > 1 ? 1 : v);\n","penrose-diagram":"// ===== Patternflow pattern =====\n// Title:   Penrose Diagram\n// Family:  space\n// Idea:    All of flat spacetime folded into one triangle the panel's exact shape, the worldline r = 0 up the left edge and light at 45 degrees, its curves of constant time and radius crowding into the corners at infinity, while a now surface climbs from past to future infinity, gold pulses leave r = 0 once a unit of time, and an observer accelerating away carries a mirror that sends back every pulse sent before t = 0, later and later, while every pulse sent after runs past its horizon to future null infinity.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: conformal compactification of Minkowski spacetime (Roger Penrose, 1963), Penrose-Carter diagrams (Brandon Carter, 1966), hyperbolic motion (Max Born, 1909), the horizon of the uniformly accelerated frame (Wolfgang Rindler, 1966), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Grid=0..2, Accel=-2..3\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the curves of constant time are blue, the curves of constant radius green, the pulses gold and the observer magenta; at 0.5 the time curves turn amber, the radius curves rose, the pulses blue and the observer green. The edges and the now surface stay white, the haze of curves along the null infinities slate, the region past the horizon a faint violet and the region behind the mirror a faint plum.\n// Knob 2: Speed. How fast the now surface climbs. Its foot runs up the left edge at a constant pace on the panel, so t = tan(theta) in time: at 2 from i- to i+ in 6.3 s, then 0.7 s in which the pulses fade before the next climb; at 0.2 a climb takes 63 s, at 3 it takes 4.2 s. The first climb opens two ninths of the way up, at t = -1.2.\n// Knob 3: Grid. The spacing of the grid curves and of the pulses, 2^-Grid: one unit of time and radius at 0, half a unit at 1, a quarter at 2. A pulse leaves r = 0 where a curve of constant time meets the left edge, leaving out any that would start within 4 LEDs of the last, so 11 pulses cross the panel at 0, 17 at 1 and 21 at 2.\n// Knob 4: Accel. The observer's proper acceleration a = 2^(Accel - 1), from 1/8 to 4, opening at 0.52. Its worldline r^2 - t^2 = 1/a^2 crosses t = 0 at r = 1/a, 58 LEDs from the left edge at a = 1/8, 44 at the opening, 31.5 at a = 1, where it is the straight column R = pi/2, and 10 at a = 4. A pulse sent at t_k \u003c 0 comes back to r = 0 at t = 1/(a^2 |t_k|): at the opening the one sent at t = -1 returns at 3.68 and the one at -9 at 0.41.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, atan, tan, sqrt, max, min, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The diagram. With u = t - r and v = t + r, U = atan u and V = atan v, the\n// coordinates T = U + V and R = V - U fill the triangle R >= 0,\n// |T| + R \u003c= pi. One LED is pi/63 in both, so i+ sits on LED (0, 0), i0 on\n// (63, 63) and i- on (0, 126): the triangle is the panel's 64 x 127 LEDs,\n// and a light ray, T - R or T + R constant, is an exact LED diagonal.\n// Future null infinity is the diagonal x = y, past null infinity\n// x + y = 126, and the worldline r = 0 is column 0. Row 127 lies outside.\nconst K = PI / 63;\nconst IN = new Uint8Array(N), TT = new Float64Array(N), RR = new Float64Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x, T = (63 - y) * K, R = x * K;\n    if (x + Math.abs(63 - y) >= 63) continue;\n    const u = tan((T - R) / 2), v = tan((T + R) / 2);\n    IN[p] = 1;\n    TT[p] = (u + v) / 2;\n    RR[p] = (v - u) / 2;\n  }\n// An LED's four neighbours that are inside too, so a contour test reads\n// only finite fields.\nconst NB = [];\nfor (let p = 0; p \u003c N; p++) {\n  const x = p & 63, y = p >> 6, l = [];\n  if (IN[p]) for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n    const q = p + dy * W + dx;\n    if (x + dx >= 0 && x + dx \u003c W && y + dy >= 0 && y + dy \u003c H && IN[q]) l.push(q);\n  }\n  NB.push(l);\n}\n\n// A level curve f = c drawn as LEDs one wide: an LED on the high side with\n// a neighbour on the low side. Where two or more curves pass between an\n// LED and its neighbour, toward the corners and along the null\n// infinities, the curves crowd closer than the LEDs and the LED is marked\n// haze (val + 2) instead: drawn dim, as the infinitely many curves there.\nfunction contour(F, step, off, out, val) {\n  for (let p = 0; p \u003c N; p++) {\n    if (!IN[p]) continue;\n    const f = floor((F[p] - off) / step);\n    let lo = 0, g = 0;\n    for (const q of NB[p]) {\n      lo = max(lo, f - floor((F[q] - off) / step));\n      g = max(g, Math.abs(F[p] - F[q]) / step);\n    }\n    if (g > HAZE) {\n      if (out[p] === 0 || out[p] > 2) out[p] = val + 2;\n    } else if (lo === 1) out[p] = val;\n  }\n}\nconst HAZE = 0.5;\n\n// Map an event (t, r) to its LED.\nfunction led(t, r) {\n  const U = atan(t - r), V = atan(t + r);\n  return [round((V - U) / K), round(63 - (U + V) / K)];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, grid: -1, acc: 99, phase: 0.2, tn: -1e9,\n    G: new Uint8Array(N), O: new Uint8Array(N), now: new Uint8Array(N), sim: new Uint8Array(N), F: new Float64Array(N), gO: new Float64Array(N), ox: 0, oy: 0,\n    pulses: [], R: new Uint8Array(N), Gc: new Uint8Array(N), B: new Uint8Array(N), c: [0, 0, 0],\n  };\n}\n\n// The grid: 1 marks a curve of constant t, 2 of constant r, 3 and 4 their\n// haze, all at the spacing d, and a pulse at each t = k d.\nfunction buildGrid(S, d) {\n  S.G.fill(0);\n  contour(RR, d, 0, S.G, 2);\n  contour(TT, d, 0, S.G, 1);\n  S.pulses = [];\n  // Toward i+ and i- the rays crowd closer than an LED. Counting out from\n  // t = 0 both ways, a pulse whose ray would start within 4 LEDs of the\n  // last one kept is left out, so each ray drawn stands on its own.\n  for (const dir of [1, -1]) {\n    let last = 63;\n    for (let k = dir > 0 ? 0 : -1; Math.abs(k) \u003c= 400; k += dir) {\n      const tk = k * d, c = round(63 - (2 * atan(tk)) / K);\n      if (k !== 0 && Math.abs(c - last) \u003c 4) continue;\n      if (c \u003c 2 || c > 124) break;\n      S.pulses.push({ tk, c });\n      last = c;\n    }\n  }\n}\n\n// The observer: r^2 - t^2 = 1/a^2, that is u v = -1/a^2, with u \u003c 0. Read\n// the triangle as the half x >= 0 of 1+1 Minkowski spacetime, x for r, and\n// the observer, its mirror, its horizon u = 0 and its line of simultaneity\n// are exact; read as the radial diagram of 3+1 spacetime, each LED is a\n// sphere of radius r and each pulse a spherical shell. A pulse sent at\n// t_k \u003c 0 runs out along u = t_k, meets the observer at v = -1/(a^2 t_k)\n// and comes back along that v; a pulse sent at t_k >= 0 never meets it.\n// gO > 1 is the side of the worldline away from r = 0.\nfunction buildObserver(S, a) {\n  S.O.fill(0);\n  const g = S.gO;\n  for (let p = 0; p \u003c N; p++) if (IN[p]) g[p] = a * a * (RR[p] * RR[p] - TT[p] * TT[p]);\n  for (let p = 0; p \u003c N; p++) {\n    if (!IN[p] || g[p] \u003c 1) continue;\n    for (const q of NB[p])\n      if (g[q] \u003c 1) {\n        S.O[p] = 1;\n        break;\n      }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const grid = cl(k[2], 0, 2), acc = cl(k[3], -2, 3);\n  if (grid !== S.grid) {\n    S.grid = grid;\n    buildGrid(S, 2 ** -grid);\n  }\n  if (acc !== S.acc) {\n    S.acc = acc;\n    S.a = 2 ** (acc - 1);\n    buildObserver(S, S.a);\n  }\n  // One cycle is 14/speed seconds: 90% climbing, 10% fading.\n  S.phase += (d * S.speed) / 14;\n  if (S.phase >= 1) S.phase -= 1;\n  const climb = min(1, S.phase / 0.9);\n  const th = cl(-PI / 2 + PI * climb, -PI / 2 + 1e-4, PI / 2 - 1e-4);\n  S.tn = tan(th);\n  S.fade = S.phase \u003c 0.9 ? 1 : 1 - (S.phase - 0.9) / 0.1;\n  S.now.fill(0);\n  contour(TT, 1e9, S.tn, S.now, 1);\n  // The observer's own now: its line of simultaneity at this event is\n  // t = r tanh(eta), eta its rapidity, a line through the origin event\n  // (0, 63) that runs to i0 and tips toward the horizon as eta grows.\n  const ro = sqrt(1 / (S.a * S.a) + S.tn * S.tn), beta = S.tn / ro, F = S.F;\n  for (let p = 0; p \u003c N; p++) F[p] = IN[p] ? TT[p] - beta * RR[p] : 0;\n  S.sim.fill(0);\n  contour(F, 1e9, 0, S.sim, 1);\n  [S.ox, S.oy] = led(S.tn, ro);\n}\n\nfunction put(S, p, h, s, v) {\n  const c = S.c;\n  hsv(h, s, v / 255, c);\n  S.R[p] = round(c[0] * 255);\n  S.Gc[p] = round(c[1] * 255);\n  S.B[p] = round(c[2] * 255);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const hu = S.hue, G = S.G, O = S.O, tn = S.tn, f = S.fade, ox = S.ox, oy = S.oy;\n  S.R.fill(0);\n  S.Gc.fill(0);\n  S.B.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    if (!IN[p]) continue;\n    const x = p & 63, y = p >> 6;\n    // Above the horizon u = 0 lie the events the observer never sees, and\n    // behind the mirror, r^2 - t^2 > 1/a^2, those no pulse reaches.\n    if (x + y \u003c 63) put(S, p, 0.78, 0.5, 34);\n    else if (S.gO[p] > 1) put(S, p, 0.9, 0.55, 30);\n    const g = G[p];\n    if (g === 2) put(S, p, hu + 0.4, 0.8, 150);\n    else if (g === 1) put(S, p, hu + 0.6, 0.7, 170);\n    else if (g) put(S, p, 0.62, 0.35, 50);\n    if (O[p]) put(S, p, hu + 0.86, 0.75, 230);\n    else if (x + y === 63 && y >= 32 && (y & 1)) put(S, p, hu + 0.86, 0.6, 170);\n  }\n  // Pulses: each ray runs from (0, c) up the diagonal x + y = c, drawn as\n  // far as the now surface has come. The observer carries a mirror: a\n  // pulse sent before t = 0 meets it and comes back in along the diagonal\n  // x - y = constant to r = 0, arriving at t = v = -1/(a^2 t_k), later the\n  // closer t_k is to 0. A pulse sent after t = 0 never meets it and runs on\n  // to future null infinity at x = c / 2.\n  if (f > 0)\n    for (const P of S.pulses) {\n      if (P.tk > tn) continue;\n      let head = -1, x = 0, y = P.c;\n      for (; x \u003c= 63; x++, y--) {\n        const p = y * W + x;\n        if (y \u003c 0 || !IN[p] || TT[p] > tn || S.gO[p] >= 1) break;\n        put(S, p, hu + 0.13, 0.85, 215 * f);\n        head = p;\n      }\n      if (P.tk \u003c 0 && x \u003c= 63 && S.gO[y * W + x] >= 1 && TT[y * W + x] \u003c= tn) {\n        // The echo turns at the last LED before the mirror and runs back up\n        // to r = 0.\n        for (x -= 2; x >= 0; x--, y--) {\n          const p = y * W + x;\n          if (TT[p] > tn) break;\n          put(S, p, hu + 0.11, 0.7, 215 * f);\n          head = p;\n        }\n      }\n      if (head >= 0 && f === 1) put(S, head, 0, 0, 255);\n    }\n  for (let p = 0; p \u003c N; p++) if (S.now[p]) put(S, p, hu + 0.55, 0.12, 255);\n  // The edges: the worldline r = 0 and the two null infinities.\n  for (let y = 1; y \u003c 126; y++) put(S, y * W, 0, 0, 190);\n  for (let x = 1; x \u003c 63; x++) {\n    put(S, x * W + x, hu + 0.75, 0.55, 200);\n    put(S, (126 - x) * W + x, hu + 0.75, 0.55, 200);\n  }\n  for (const p of [0, 63 * W + 63, 126 * W]) put(S, p, 0, 0, 255);\n  if (f \u003c 1) return out(display, S);\n  // The observer's own now: its line of simultaneity.\n  for (let p = 0; p \u003c N; p++) if (S.sim[p] && !S.now[p]) put(S, p, hu + 0.86, 0.5, 230);\n  for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) {\n    const x = ox + dx, y = oy + dy;\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(S, y * W + x, 0, 0, 255);\n  }\n  out(display, S);\n}\n\nfunction out(display, S) {\n  for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, S.R[p], S.Gc[p], S.B[p]);\n}\n","phase-spiral":"// ===== Patternflow pattern =====\n// Title:   Phase Spiral\n// Family:  sim\n// Idea:    Three thousand parallel sheets of mass fall through each other along a line, each pulled by a force that only changes when two of them cross, and their phase portrait, position across the panel and velocity up it, winds a cold strip into a two-armed spiral whose turns multiply and thin round a settling white core, every sheet coloured by where it began on the strip.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: one-dimensional self-gravitating sheet model (Michel Hénon, 1964; Frank Hohl and Marc Feix, 1967), violent relaxation (Donald Lynden-Bell, 1967), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=0.1..1.2, Lumps=0..1\n//\n// Knob 1: Hue. Turns the ramp along the strip round the wheel. At 0 the sheet that starts at the left end is azure and the one at the right end rose, through blue, violet and magenta between; at 0.25 magenta through red to yellow, at 0.5 orange through yellow to sea green, at 0.75 green through cyan to blue. Where many sheets share an LED the colour goes toward white, so the core is pale at every setting.\n// Knob 2: Speed. Sheet time per second, 1.6 x Speed: 3.2 at 2, where the cold strip falls to the middle in 0.49 s and, once it has settled, the sheet from the end of the strip goes round in 2.3 s and one from a tenth or a quarter of the way along in 1 s, and that difference is what winds the spiral; 0.32 at 0.2 and 4.8 at 3. A fresh strip starts every 72 units of sheet time, 22.5 s at 2 (the first one after 17.5 s, as it opens 16 units in).\n// Knob 3: Spread. Half the height of the starting strip, its velocities spread evenly over plus and minus this, in units where the strip is 2 wide and a sheet with all the others on one side feels an acceleration of 1. Twice the kinetic energy over the potential starts at Spread squared: 0.01 at the opening 0.1, a cold collapse that winds the thinnest spiral; 1 at Spread 1, a waterbag in virial balance that only rocks and sheds two arms from its corners; 1.44 at 1.2, a hot one that swells first. A new value starts a fresh strip.\n// Knob 4: Lumps. Bunches the strip's sheets into four lumps, moving each by 0.95 x Lumps x sin(4 pi u) / (4 pi) from its even place u: at 1 the strip is 39 times as dense in the middle of a lump as halfway between two. Each lump falls in on itself first and spins up a little spiral, and the four then fall together and merge, which keeps the cloud ringing: the virial ratio still swings between 0.3 and 3 after 36 units, where a smooth strip has settled within 25 percent of 1 by 16. It opens at 0.06, almost smooth. A new value starts a fresh strip.\n// Buttons: K1 tap starts a fresh strip at once, falling from rest; the old spiral fades out over 0.9 s at Speed 2.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, exp, round, random, sin, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: the starting strip runs from x = -1 to 1, and a sheet with every\n// other sheet on one side is pulled toward them at 1. Inside a uniform\n// strip the pull is -x, so a cold strip would swing as a pendulum of period\n// 2 pi and fall to a point at pi / 2; any spread of velocities or of\n// density breaks that up. Phase space (x, v) is drawn with x across the\n// panel, SX LEDs to a unit, and v up it, SV LEDs to a unit.\nconst N = 3072;\nconst XC = 32, VC = 64, SX = 22, SV = 44;\nconst DT = 0.04, RATE = 1.6, PRE = 16, CYCLE = 72, FADE = 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    x: new Float64Array(N), xs: new Float64Array(N), v: new Float64Array(N), a: new Float64Array(N), f: new Float32Array(N),\n    ord: new Int32Array(N), bin: new Int32Array(N), cnt: new Int32Array(N + 1),\n    px: new Float32Array(N), py: new Float32Array(N), fresh: true, used: [0.1, 0.06],\n    D: new Float32Array(NP), F: new Float32Array(NP), rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3),\n    lut: new Float32Array(256 * 3), t: 0, fade: 0, started: false, hue: 0, speed: 2, spread: 0.1, lumps: 0.06,\n  };\n}\n\n// The pull on every sheet, from its rank. A counting sort into N bins\n// across the sheets' present extent puts them nearly in order, and an\n// insertion sort mends the few that share a bin, so the order is exact and\n// the cost does not grow with the number of crossings, about N^2 every\n// period. A sheet with k sheets on its left and N - 1 - k on its right is\n// pulled toward the heavier side by (N - 1 - 2k) / N, constant until the\n// next crossing: between crossings every sheet flies a parabola.\nfunction ranks(S, lo, hi) {\n  const { x, xs, a, ord, bin, cnt } = S, sc = (N - 1) / (hi - lo + 1e-12);\n  cnt.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const b = ((x[i] - lo) * sc) | 0;\n    bin[i] = b;\n    cnt[b + 1]++;\n  }\n  for (let b = 1; b \u003c= N; b++) cnt[b] += cnt[b - 1];\n  for (let i = 0; i \u003c N; i++) {\n    const k = cnt[bin[i]]++;\n    ord[k] = i;\n    xs[k] = x[i];\n  }\n  for (let k = 1; k \u003c N; k++) {\n    const xk = xs[k];\n    if (xs[k - 1] \u003c= xk) continue;\n    const j = ord[k];\n    let m = k - 1;\n    while (m >= 0 && xs[m] > xk) (xs[m + 1] = xs[m]), (ord[m + 1] = ord[m]), m--;\n    (xs[m + 1] = xk), (ord[m + 1] = j);\n  }\n  for (let k = 0; k \u003c N; k++) a[ord[k]] = (N - 1 - 2 * k) / N;\n}\n\n// A leapfrog step: kick with the pull of the last order, drift, sort again.\n// Across one cycle from rest at DT the total energy moved by 1 part in\n// 10^4; the coarser opening run, 0.05 through the first collapse and 0.1\n// after, lands within 0.4 percent of it.\nfunction step(S, dt) {\n  const { x, v, a } = S;\n  let lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c N; i++) {\n    v[i] += dt * a[i];\n    const xi = (x[i] += dt * v[i]);\n    if (xi \u003c lo) lo = xi;\n    if (xi > hi) hi = xi;\n  }\n  ranks(S, lo, hi);\n  S.t += dt;\n}\n\n// A fresh strip, a waterbag: the sheets evenly along x, bunched into four\n// lumps by Lumps, and their velocities spread evenly over +-Spread by the\n// golden-ratio sequence, which fills the rectangle without the clumps and\n// holes of random draws. f is a sheet's place along the strip, 0 at the\n// left end and 1 at the right, and picks its colour for good.\nfunction fresh(S) {\n  const { x, v, f } = S, A = 0.95 * S.lumps, V0 = S.spread, r0 = random();\n  for (let i = 0; i \u003c N; i++) {\n    const q = (i + 0.5) / N, u = 2 * q - 1;\n    f[i] = q;\n    x[i] = u + (A / (4 * PI)) * sin(4 * PI * u);\n    v[i] = V0 * (2 * ((i * 0.6180339887 + r0) % 1) - 1);\n  }\n  S.t = 0;\n  S.used = [V0, S.lumps];\n  ranks(S, -1, 1);\n  S.fresh = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.spread = cl(k[2], 0.1, 1.2);\n  S.lumps = cl(k[3], 0, 1);\n  // The first strip opens 16 units in, past the violent part of its\n  // relaxation, so the spiral has two turns by 2 s; the later ones start\n  // from rest and show the collapse.\n  if (!S.started) {\n    fresh(S);\n    while (S.t \u003c PRE) step(S, S.t \u003c 3 ? 0.05 : 0.1);\n    S.started = true;\n  }\n  const moved = abs(S.spread - S.used[0]) > 0.01 || abs(S.lumps - S.used[1]) > 0.01;\n  if (S.t > CYCLE || moved || (input.btnPressed && input.btnPressed[0])) {\n    S.old.set(S.rgb);\n    S.fade = 1;\n    fresh(S);\n  }\n  const h = d * S.speed * RATE;\n  S.fade = max(0, S.fade - h / FADE);\n  const n = Math.ceil(h / DT - 1e-9);\n  for (let i = 0; i \u003c n; i++) step(S, h / n);\n}\n\n// Brightness and the share of white for a density d, the number of\n// sheets on an LED, in steps of 1/32.\nconst NB = 512, BR = new Float32Array(NB), WH = new Float32Array(NB);\nfor (let e = 0; e \u003c NB; e++) (BR[e] = (1 - exp(-(e + 0.5) / 32 / 0.35)) * 255), (WH[e] = cl(((e + 0.5) / 32 - 2) / 6, 0, 0.7));\n\nfunction splat(D, F, px, py, w, f) {\n  const ix = floor(px), iy = floor(py);\n  if (ix \u003c 0 || iy \u003c 0 || ix >= W - 1 || iy >= H - 1) return;\n  const tx = px - ix, ty = py - iy, p = iy * W + ix;\n  const w00 = w * (1 - tx) * (1 - ty), w10 = w * tx * (1 - ty), w01 = w * (1 - tx) * ty, w11 = w * tx * ty;\n  D[p] += w00;\n  D[p + 1] += w10;\n  D[p + W] += w01;\n  D[p + W + 1] += w11;\n  F[p] += w00 * f;\n  F[p + 1] += w10 * f;\n  F[p + W] += w01 * f;\n  F[p + W + 1] += w11 * f;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { x, v, f, D, F, rgb, old, lut, px, py } = S, fd = S.fade;\n  for (let i = 0; i \u003c 256; i++) hsv(S.hue + 0.55 + 0.4 * (i / 255), 0.8, 1, lut, i * 3);\n  D.fill(0);\n  F.fill(0);\n  // Each sheet is laid down bilinearly where it is now and, if it moved\n  // more than 0.8 LED since the last frame, halfway back as well, so an\n  // arm sliding along itself reads as a line and not a row of dots. An LED\n  // shows the mean place along the strip of the sheets on it.\n  for (let i = 0; i \u003c N; i++) {\n    const qx = XC + x[i] * SX - 0.5, qy = VC - v[i] * SV - 0.5;\n    if (S.fresh) (px[i] = qx), (py[i] = qy);\n    const mx = 0.5 * (qx + px[i]), my = 0.5 * (qy + py[i]);\n    if ((qx - mx) ** 2 + (qy - my) ** 2 \u003c 0.16) splat(D, F, qx, qy, 1, f[i]);\n    else splat(D, F, qx, qy, 0.5, f[i]), splat(D, F, mx, my, 0.5, f[i]);\n    (px[i] = qx), (py[i] = qy);\n  }\n  S.fresh = false;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x2 = 0; x2 \u003c W; x2++, p++) {\n      const d = D[p], o = p * 3;\n      let r = 0, g = 0, b = 0;\n      if (d > 0.004) {\n        const q = min(255, round((F[p] / d) * 255)) * 3, e = min(NB - 1, (d * 32) | 0), br = BR[e], wh = WH[e];\n        r = (lut[q] * (1 - wh) + wh) * br;\n        g = (lut[q + 1] * (1 - wh) + wh) * br;\n        b = (lut[q + 2] * (1 - wh) + wh) * br;\n      }\n      if (fd > 0) (r = r * (1 - fd) + old[o] * fd), (g = g * (1 - fd) + old[o + 1] * fd), (b = b * (1 - fd) + old[o + 2] * fd);\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n      display.setPixel(x2, y, r, g, b);\n    }\n}\n","randu-planes":"// ===== Patternflow pattern =====\n// Title:   RANDU Planes\n// Family:  number\n// Idea:    Consecutive triples of IBM's RANDU generator tumble as a cloud of points in a unit cube, and each time the view passes along the planes 9x - 6y + z = n the cloud snaps into the 15 parallel lines it always lay on, one colour per plane.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: multiplicative congruential generator (D. H. Lehmer, 1949), RANDU (IBM, 1960s), the spectral test (R. R. Coveyou and R. D. MacPherson, 1967), random numbers fall mainly in the planes (George Marsaglia, 1968), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Generator=0..3, Points=1.8..8\n//\n// Knob 1: Hue. Turns the plane colours round the wheel. At 0 the 15 planes run from azure through violet, red and orange to green, top to bottom at one alignment and bottom to top at the next, as the cube turns over; the cube's edges stay a faint grey.\n// Knob 2: Speed. How fast the cube tumbles. At 2 the view lines up with the planes every 3.2 s, first at 2.5 s, and lingers there: it turns at a tenth of its mean pace while the planes stand edge on, so the lines hold for about 0.4 s, and at 1.9 times it while they face the viewer. At 0.2 the alignments come 32 s apart, at 3 every 2.1 s.\n// Knob 3: Generator. Picks the multiplier a of x -> a x mod m, and the view always passes along that generator's own widest planes. At 0 RANDU's 65539 = 2^16 + 3 puts the triples on 15 planes 5.2 LEDs apart; at 1 65541 = 2^16 + 5 on 35 planes 2.1 LEDs apart, the same trick one step on; at 2 George Marsaglia's 69069 mod 2^32 (1972) on 394 planes 0.16 LEDs apart, and at 3 the minimal standard 16807 mod 2^31 - 1 of Stephen Park and Keith Miller (1988) on 764 planes 0.09 LEDs apart, so for these two the cloud never lines up.\n// Knob 4: Points. How many triples, in thousands: 1800 at the opening, 8000 at the top, where every line at an alignment is solid.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, sqrt, sin, cos, abs, min, max, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The generators: multiplier, modulus, and the shortest integer u with\n// u1 + a u2 + a^2 u3 = 0 mod m/g, found by lattice reduction, where g is\n// the gcd of the differences between outputs: 2 for RANDU, 4 for the\n// multipliers 5 mod 8 that keep x mod 4, 1 for the prime modulus. Every\n// triple p = (x, a x mod m, a^2 x mod m) / m then has u . p in Z + c for\n// one fixed c, so it lies on one of the planes u . p = n + c, 1/|u|\n// apart. All products stay below 2^53, so the doubles are exact.\nconst GENS = [\n  { a: 65539, m: 2 ** 31, u: [9, -6, 1] },\n  { a: 65541, m: 2 ** 31, u: [25, -10, 1] },\n  { a: 69069, m: 2 ** 32, u: [22, 13, -359] },\n  { a: 16807, m: 2 ** 31 - 1, u: [90, -44, 631] },\n];\nconst MAXP = 8000;\nconst LING = 0.9;\nconst mulmod = (a, x, m) => {\n  const y = a * x;\n  return y - floor(y / m) * m;\n};\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, gen: -9, count: 1800, psi: 0.687,\n    qh: new Float64Array(MAXP), qn: new Float64Array(MAXP), qw: new Float64Array(MAXP), col: new Uint8Array(MAXP),\n    ncol: 15, sc: 56, h: [1, 0, 0], n: [0, 1, 0], w: [0, 0, 1],\n    R: new Uint8Array(N), G: new Uint8Array(N), B: new Uint8Array(N), Z: new Float32Array(N), c: [0, 0, 0],\n  };\n}\n\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst unit = (a) => {\n  const l = sqrt(dot(a, a));\n  return [a[0] / l, a[1] / l, a[2] / l];\n};\nconst l1 = (a) => abs(a[0]) + abs(a[1]) + abs(a[2]);\n\n// The view: the cube tumbles about a screen-horizontal axis h that lies in\n// the planes, so twice a turn the view looks along them and they stand\n// edge on as horizontal lines stacked down the panel. Of all such axes, h\n// is the one along which the cube is narrowest, so it fits the 64 LEDs.\nfunction aim(S, g) {\n  const n = unit(g.u);\n  const e1 = unit(cross(n, abs(n[0]) \u003c 0.9 ? [1, 0, 0] : [0, 1, 0])), e2 = cross(n, e1);\n  let best = null;\n  for (let i = 0; i \u003c 360; i++) {\n    const t = (i * PI) / 360, h = [0, 1, 2].map((j) => e1[j] * cos(t) + e2[j] * sin(t));\n    if (!best || l1(h) \u003c l1(best)) best = h;\n  }\n  S.n = n;\n  S.h = best;\n  S.w = cross(n, best);\n  S.sc = min(56, 62 / l1(best));\n}\n\nfunction build(S) {\n  const g = GENS[S.gen], m = g.m, u = g.u;\n  aim(S, g);\n  // Overlapping triples of consecutive outputs from the odd seed 12345.\n  let x = 12345, y = mulmod(g.a, x, m), z = mulmod(g.a, y, m);\n  const pl = new Int32Array(MAXP);\n  let lo = 1e9, hi = -1e9;\n  for (let k = 0; k \u003c MAXP; k++) {\n    const p = [x / m - 0.5, y / m - 0.5, z / m - 0.5];\n    S.qh[k] = dot(p, S.h);\n    S.qn[k] = dot(p, S.n);\n    S.qw[k] = dot(p, S.w);\n    pl[k] = floor((u[0] * x + u[1] * y + u[2] * z) / m + 0.125);\n    lo = min(lo, pl[k]);\n    hi = max(hi, pl[k]);\n    x = y;\n    y = z;\n    z = mulmod(g.a, z, m);\n  }\n  // One colour per plane where there are at most 15; past that the plane\n  // index mod 15, so neighbouring planes never share a colour.\n  const count = hi - lo + 1;\n  S.ncol = min(15, count);\n  for (let k = 0; k \u003c MAXP; k++) S.col[k] = (pl[k] - lo) % 15;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const gen = round(cl(k[2], 0, 3));\n  if (gen !== S.gen) {\n    S.gen = gen;\n    build(S);\n  }\n  S.count = round(1000 * cl(k[3], 1.8, 8));\n  // psi runs at a constant rate, pi every 3.2 s at Speed 2; the tumble\n  // angle phi = psi - LING sin(2 psi) / 2 is psi itself at each alignment\n  // (psi a multiple of pi) but moves there at a tenth of the pace, so the\n  // lines hold for about 0.4 s.\n  S.psi += (d * S.speed * PI) / 6.4;\n}\n\nfunction put(S, x, y, z, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  if (z \u003c S.Z[p]) return;\n  S.Z[p] = z;\n  S.R[p] = r;\n  S.G[p] = g;\n  S.B[p] = b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const phi = S.psi - (LING * sin(2 * S.psi)) / 2, cp = cos(phi), sp = sin(phi), sc = S.sc, c = S.c;\n  S.R.fill(0);\n  S.G.fill(0);\n  S.B.fill(0);\n  S.Z.fill(-9);\n  // The cube's edges, faint, behind everything.\n  const corner = (i) => {\n    const q = [(i & 1) - 0.5, ((i >> 1) & 1) - 0.5, ((i >> 2) & 1) - 0.5];\n    const a = dot(q, S.n), b = dot(q, S.w);\n    return [31.5 + sc * dot(q, S.h), 63.5 - sc * (a * cp + b * sp)];\n  };\n  for (let i = 0; i \u003c 8; i++)\n    for (const bit of [1, 2, 4]) {\n      if (i & bit) continue;\n      const [x0, y0] = corner(i), [x1, y1] = corner(i | bit);\n      const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n      for (let t = 0; t \u003c= n; t++) put(S, round(x0 + ((x1 - x0) * t) / n), round(y0 + ((y1 - y0) * t) / n), -5, 34, 36, 44);\n    }\n  const pal = [];\n  for (let j = 0; j \u003c 15; j++) {\n    hsv(S.hue + 0.55 + (0.8 * j) / max(1, S.ncol - 1), 0.85, 1, c);\n    pal.push([c[0], c[1], c[2]]);\n  }\n  for (let k = 0; k \u003c S.count; k++) {\n    const a = S.qn[k], b = S.qw[k];\n    // Screen right is h and up is n cos phi + w sin phi, so the depth\n    // toward the viewer, h x up, is n sin phi - w cos phi.\n    const y = 63.5 - sc * (a * cp + b * sp), z = a * sp - b * cp;\n    // Nearer points brighter: 0.5 at the back of the cube, 1 at the front.\n    const v = 255 * (0.75 + 0.29 * z), col = pal[S.col[k]];\n    put(S, round(31.5 + sc * S.qh[k]), round(y), z, round(col[0] * v), round(col[1] * v), round(col[2] * v));\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p & 63, p >> 6, S.R[p], S.G[p], S.B[p]);\n}\n","richardson-dividers":"// ===== Patternflow pattern =====\n// Title:   Richardson Dividers\n// Family:  fractal\n// Idea:    A random self-similar curve of dimension D runs corner to corner across the top of the panel while a pair of dividers walks along it at a fixed opening, swinging from point to point and laying down a polygon of equal chords that cuts off the curve's bays, and each finished walk drops the point (log s, log L) onto a log-log plot below, so as the opening shrinks from 23 LEDs to under one in ten steps of 0.7 the points climb a straight line of slope 1 - D.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Richardson's divider method (Lewis Fry Richardson, 1961), fractal dimension of a coastline (Benoit Mandelbrot, 1967), dimension of random recursive constructions (R. Daniel Mauldin and S. C. Williams, 1986), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Roughness=-1..1, Cutoff=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the curve is lilac, the dividers' polygon, its bays and the measured points sea green and the dividers white; at 0.25 the curve pink and the polygon blue, at 0.5 lime and pink, at 0.75 teal and yellow. The curve skips the orange part of the wheel, which reads brown when dim.\n// Knob 2: Speed. At 2 each opening takes 1.45 s, a walk of 1.1 s and a pause of 0.35 s with the polygon complete, so the ten openings of one curve take 14.5 s before a fresh curve fades in; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Roughness. Sets the dimension D = 1.27 + 0.25 x K3: 1.02 at -1, about the coast of South Africa in Richardson's table, 1.27 at 0, a little above the west coast of Britain, and 1.52 at 1. The curve grows from 109 LEDs long, a gentle wobble, through 501 to 2,185, a crumpled line that is shrunk to fit, and the slope of the line on the plot goes from -0.02 to -0.52; over 60 curves each the fitted slope of the ten points averaged -0.019, -0.137, -0.261, -0.371 and -0.496 at the five stops, a little shallower than 1 - D. The curve keeps its random choices, so turning the knob bends the same curve.\n// Knob 4: Cutoff. The curve stops dividing once a piece is no longer than 0.3 x 100^K4 LEDs: 0.40 at the opening 0.06, where the pieces average 0.19 LEDs, far under the smallest opening of 0.93, so the points keep to the line; 3 at 0.5, pieces of 1.3, and 30 at 1, where the curve is a polygon of 10 to 16 pieces averaging 12.5 LEDs. The plot's dotted mark stands at the mean piece, and to the left of it the points go flat: dividers shorter than a piece measure the polygon's own length.\n// Buttons: K1 tap draws a fresh curve and starts again from the widest opening.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, acos, atan2, pow, hypot, log10, round, ceil, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nconst wheel = (h) => 0.17 + (h - floor(h)) * 0.86;\n\n// A 32-bit hash for the curve's random choices: each piece's choices come\n// from its own id, and its four children's ids from it, so a change of D\n// or of the cutoff redraws the same tree of choices.\nfunction hash(a) {\n  a = Math.imul(a ^ (a >>> 16), 0x7feb352d);\n  a = Math.imul(a ^ (a >>> 15), 0x846ca68b);\n  return (a ^ (a >>> 16)) >>> 0;\n}\n\n// The curve runs from one corner of rows 0 to 85 to the other, (4, 4) to\n// (60, 82) or (60, 4) to (4, 82), 96 LEDs. Every piece P -> Q is replaced\n// by four: P -> P1 and P3 -> Q along the piece, each r long, and two up to\n// an apex off to one side, a coin flip deciding which. r is the Koch-type\n// ratio for D, 1 / (2 + 2 cos theta) with 2 + 2 cos theta = 4^(1/D), times\n// a random factor in 0.85..1.15; the apex sits at 0.5 + delta along the\n// piece, delta random in -0.07..0.07, and at the height h that makes\n// 2 r^D + r2^D + r3^D = 1, to 1e-15 after four Newton steps. Every\n// generator then has similarity dimension D, so by Mauldin and Williams\n// the curve has dimension D, and the random ratios smear the log-periodic\n// staircase one fixed ratio puts into L(s).\nconst TOP = 86;\nfunction makeCurve(seed, D, cut) {\n  const c = pow(4, 1 / D) / 2 - 1, rK = 1 / (2 + 2 * c), hK = rK * sin(acos(c));\n  const right = seed & 1, sx = right ? 4 : 60, ex = right ? 60 : 4;\n  const X = [sx], Y = [4];\n  const emit = (ax, ay, bx, by, id, depth) => {\n    const dx = bx - ax, dy = by - ay, len = hypot(dx, dy);\n    if (len \u003c= cut || depth > 9) {\n      X.push(bx);\n      Y.push(by);\n      return;\n    }\n    const z = hash(id), f = z & 2 ? 1 : -1;\n    const de = 0.07 * ((((z >>> 2) & 1023) / 1023) * 2 - 1);\n    const r = min(rK * (1 + 0.15 * ((((z >>> 12) & 1023) / 1023) * 2 - 1)), 0.48 - abs(de));\n    const a1 = 0.5 + de - r, a2 = 0.5 - de - r, rd = 2 * pow(r, D);\n    let h = hK;\n    for (let it = 0; it \u003c 4; it++) {\n      const q2 = a1 * a1 + h * h, q3 = a2 * a2 + h * h;\n      const g = rd + pow(q2, D / 2) + pow(q3, D / 2) - 1, gp = D * h * (pow(q2, D / 2 - 1) + pow(q3, D / 2 - 1));\n      h = max(1e-4, h - g / max(gp, 1e-6));\n    }\n    const nx = -dy * f, ny = dx * f;\n    const p1x = ax + r * dx, p1y = ay + r * dy, p3x = bx - r * dx, p3y = by - r * dy;\n    const p2x = ax + (0.5 + de) * dx + h * nx, p2y = ay + (0.5 + de) * dy + h * ny;\n    const k = Math.imul(id, 4) + 0x9e37;\n    emit(ax, ay, p1x, p1y, hash(k), depth + 1);\n    emit(p1x, p1y, p2x, p2y, hash(k + 1), depth + 1);\n    emit(p2x, p2y, p3x, p3y, hash(k + 2), depth + 1);\n    emit(p3x, p3y, bx, by, hash(k + 3), depth + 1);\n  };\n  emit(sx, 4, ex, 82, hash(seed), 0);\n  // Shrink it about its middle into columns 1 to 62 and rows 1 to 84 if it\n  // came out bigger; the plot divides L by the end-to-end length.\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c X.length; i++) (x0 = min(x0, X[i])), (x1 = max(x1, X[i])), (y0 = min(y0, Y[i])), (y1 = max(y1, Y[i]));\n  const sc = min(1, 61 / (x1 - x0), 83 / (y1 - y0)), mx = (x0 + x1) / 2, my = (y0 + y1) / 2;\n  const n = X.length - 1, PX = new Float32Array(n + 1), PY = new Float32Array(n + 1);\n  for (let i = 0; i \u003c= n; i++) (PX[i] = 31.5 + (X[i] - mx) * sc), (PY[i] = 42.5 + (Y[i] - my) * sc);\n  let len = 0;\n  for (let i = 0; i \u003c n; i++) len += hypot(PX[i + 1] - PX[i], PY[i + 1] - PY[i]);\n  const C = { seed, D, cut, n, X: PX, Y: PY, l0: hypot(PX[n] - PX[0], PY[n] - PY[0]), piece: len / n, walks: [], rows: null, ras: null };\n  for (let k = 0; k \u003c NO; k++) C.walks.push(walk(C, OPEN[k]));\n  return C;\n}\n\n// The openings, 23 LEDs down to 0.93 in ten steps of 0.7.\nconst NO = 10, OPEN = [];\nfor (let k = 0; k \u003c NO; k++) OPEN.push(23 * pow(0.7, k));\n\n// Richardson's walk: from the tip on the curve, the next tip is the first\n// point further along the curve at distance s, found on the piece that\n// first leaves the circle of radius s; the walk ends when the rest of the\n// curve stays inside the circle, and the length is n s plus that last gap.\nfunction walk(C, s) {\n  const { X, Y, n } = C, tx = [X[0]], ty = [Y[0]], tj = [0];\n  let cx = X[0], cy = Y[0], ax = cx, ay = cy, i = 0;\n  const s2 = s * s;\n  for (;;) {\n    let hit = false;\n    for (; i \u003c n; i++) {\n      const bx = X[i + 1], by = Y[i + 1];\n      if ((bx - cx) * (bx - cx) + (by - cy) * (by - cy) >= s2) {\n        const dx = bx - ax, dy = by - ay, fx = ax - cx, fy = ay - cy, A = dx * dx + dy * dy, B = 2 * (fx * dx + fy * dy);\n        const Cq = fx * fx + fy * fy - s2, t = (-B + sqrt(max(0, B * B - 4 * A * Cq))) / (2 * A);\n        cx = ax = ax + t * dx;\n        cy = ay = ay + t * dy;\n        tx.push(cx);\n        ty.push(cy);\n        tj.push(i);\n        hit = true;\n        break;\n      }\n      ax = bx;\n      ay = by;\n    }\n    if (!hit) break;\n  }\n  const steps = tx.length - 1, gap = hypot(X[n] - cx, Y[n] - cy);\n  return { s, tx, ty, tj, steps, gap, L: steps * s + gap };\n}\n\n// What a frame needs of a curve beyond its points: the light it leaves on\n// each LED, and where it crosses the middle of each row, for the bays.\nfunction prepare(C) {\n  const { X, Y, n } = C, ras = new Float32Array(W * TOP), rx = [], ri = [];\n  for (let y = 0; y \u003c TOP; y++) rx.push([]), ri.push([]);\n  for (let i = 0; i \u003c n; i++) {\n    const x0 = X[i], y0 = Y[i], x1 = X[i + 1], y1 = Y[i + 1], len = hypot(x1 - x0, y1 - y0), m = max(1, ceil(len * 3));\n    for (let j = 0; j \u003c m; j++) {\n      const t = (j + 0.5) / m, x = x0 + (x1 - x0) * t, y = y0 + (y1 - y0) * t, ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy, w = len / m;\n      if (ix >= 0 && ix \u003c W - 1 && iy >= 0 && iy \u003c TOP - 1) {\n        const p = iy * W + ix;\n        ras[p] += (1 - fx) * (1 - fy) * w;\n        ras[p + 1] += fx * (1 - fy) * w;\n        ras[p + W] += (1 - fx) * fy * w;\n        ras[p + W + 1] += fx * fy * w;\n      }\n    }\n    const ya = min(y0, y1), yb = max(y0, y1);\n    for (let y = max(0, ceil(ya - 0.5)); y \u003c TOP && y + 0.5 \u003c yb; y++) {\n      rx[y].push(x0 + ((x1 - x0) * (y + 0.5 - y0)) / (y1 - y0));\n      ri[y].push(i);\n    }\n  }\n  for (let p = 0; p \u003c ras.length; p++) ras[p] = min(1, ras[p]) ** 0.6;\n  C.ras = ras;\n  C.rows = rx.map((a) => Float32Array.from(a));\n  C.rowi = ri.map((a) => Int32Array.from(a));\n}\n\nconst T_WALK = 1.1, T_HOLD = 0.35, T_OPEN = T_WALK + T_HOLD, T_FADE = 0.5;\nconst points = (C) => C.walks.map((w) => [log10(w.s), log10(w.L / C.l0)]);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, D: 1.27, cut: 0.39, warm: false, k: 0, t: 0, fade: 1, ay: null,\n    cur: null, old: null, ghosts: [],\n    R: new Float32Array(N), G: new Float32Array(N), B: new Float32Array(N), c: new Float32Array(18), xs: new Float32Array(4096),\n  };\n}\n\nconst newSeed = () => (Math.random() * 4294967296) >>> 0;\n\nfunction fresh(S) {\n  if (S.cur) {\n    // The finished curve's points stay on the plot, dimmer, for two curves.\n    S.ghosts.unshift({ D: S.cur.D, cut: S.cur.cut, pts: points(S.cur) });\n    S.ghosts.length = min(S.ghosts.length, 2);\n    S.old = S.cur;\n  }\n  S.cur = makeCurve(newSeed(), S.D, S.cut);\n  prepare(S.cur);\n  S.k = 0;\n  S.t = 0;\n  S.fade = S.old ? 0 : 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const D = 1.27 + 0.25 * cl(k[2], -1, 1), cut = 0.3 * pow(100, cl(k[3], 0, 1));\n  if (!S.warm) {\n    // Open with two curves already measured, so the plot shows the line.\n    S.D = D;\n    S.cut = cut;\n    for (let g = 0; g \u003c 2; g++) S.ghosts.push({ D, cut, pts: points(makeCurve(newSeed(), D, cut)) });\n    fresh(S);\n    S.warm = true;\n  }\n  if (abs(D - S.D) > 0.002 || abs(cut - S.cut) / S.cut > 0.01) {\n    // The same choices bent to the new D or cut at the new length; points\n    // measured on another curve leave the plot.\n    S.D = D;\n    S.cut = cut;\n    S.cur = makeCurve(S.cur.seed, D, cut);\n    prepare(S.cur);\n    S.ghosts = S.ghosts.filter((g) => abs(g.D - D) \u003c 0.002 && abs(g.cut - cut) / cut \u003c 0.01);\n  }\n  if (input.btnPressed && input.btnPressed[0]) fresh(S);\n  const ds = (d * S.speed) / 2;\n  // Where the plot's middle sits: the mean of the ghost points and of all\n  // ten points of the curve being walked, known before it is walked.\n  let sum = 0, cnt = 0;\n  for (const g of S.ghosts) for (const p of g.pts) (sum += p[1]), cnt++;\n  for (const p of points(S.cur)) (sum += p[1]), cnt++;\n  const want = sum / cnt;\n  S.ay = S.ay === null ? want : S.ay + (want - S.ay) * min(1, ds * 6);\n  S.fade = min(1, S.fade + ds / T_FADE);\n  S.t += ds;\n  while (S.t >= T_OPEN) {\n    S.t -= T_OPEN;\n    if (++S.k >= NO) fresh(S);\n  }\n}\n\nfunction add(S, x, y, v, c, o) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x;\n  S.R[p] += v * c[o];\n  S.G[p] += v * c[o + 1];\n  S.B[p] += v * c[o + 2];\n}\nfunction splat(S, x, y, v, c, o) {\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  add(S, ix, iy, (1 - fx) * (1 - fy) * v, c, o);\n  add(S, ix + 1, iy, fx * (1 - fy) * v, c, o);\n  add(S, ix, iy + 1, (1 - fx) * fy * v, c, o);\n  add(S, ix + 1, iy + 1, fx * fy * v, c, o);\n}\nfunction line(S, x0, y0, x1, y1, v, c, o) {\n  const L = hypot(x1 - x0, y1 - y0), n = max(1, ceil(L * 3)), w = (v * L) / n;\n  for (let i = 1; i \u003c= n; i++) splat(S, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, w, c, o);\n}\n\n// The plot: log10 s across, 37.4 LEDs a decade, from -0.1 at column 3 to\n// 1.45 at column 61, and log10 (L / L0) up at 44 rows a decade on rows 87\n// to 124. Only the slope means anything on a log-log plot, so the plot\n// holds the middle of all its points, which falls at the openings' mean\n// log10 s = 0.665, on row 105.5, and the points spread up and down from it.\nconst KX = 58 / 1.55, KY = 44, PB = 124, PT = 87, PC = 105.5, MLS = log10(23) + 4.5 * log10(0.7);\nconst plx = (ls) => 3 + (ls + 0.1) * KX;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cur) return;\n  const { R, G, B, c, cur } = S;\n  R.fill(0);\n  G.fill(0);\n  B.fill(0);\n  // 0 the curve, 3 the polygon and points, 6 the bays, 9 white, 12 grey,\n  // 15 the dim points of earlier curves.\n  hsv(wheel(0.65 + S.hue), 0.62, 0.7, c, 0);\n  hsv(0.42 + S.hue, 0.8, 1, c, 3);\n  hsv(0.42 + S.hue, 0.8, 0.38, c, 6);\n  c[9] = c[10] = c[11] = 1;\n  c[12] = c[13] = c[14] = 0.3;\n  hsv(0.42 + S.hue, 0.45, 0.6, c, 15);\n\n  const w = cur.walks[S.k], done = S.t >= T_WALK, prog = done ? w.steps : (S.t / T_WALK) * w.steps;\n  const m = min(w.steps, floor(prog)), fr = done ? 0 : prog - m;\n  // Bays: the curve up to the tip and the polygon back to the start bound\n  // them, filled by the even-odd rule along the middle of each row.\n  const jt = done ? cur.n : w.tj[m], tipx = w.tx[m], tipy = w.ty[m], xs = S.xs;\n  for (let y = 0; y \u003c TOP; y++) {\n    const rx = cur.rows[y], ri = cur.rowi[y], yc = y + 0.5;\n    let n = 0;\n    for (let q = 0; q \u003c rx.length && n \u003c 4000; q++) if (ri[q] \u003c jt) xs[n++] = rx[q];\n    const cross = (x0, y0, x1, y1) => {\n      if (y0 \u003c= yc !== y1 \u003c= yc && n \u003c 4096) xs[n++] = x0 + ((x1 - x0) * (yc - y0)) / (y1 - y0);\n    };\n    if (!done) cross(cur.X[jt], cur.Y[jt], tipx, tipy);\n    for (let q = 0; q \u003c m; q++) cross(w.tx[q], w.ty[q], w.tx[q + 1], w.ty[q + 1]);\n    if (done) cross(tipx, tipy, cur.X[cur.n], cur.Y[cur.n]);\n    if (n \u003c 2) continue;\n    const a = xs.subarray(0, n).sort();\n    for (let q = 0; q + 1 \u003c n; q += 2)\n      for (let x = max(0, ceil(a[q] - 0.5)); x \u003c= min(W - 1, floor(a[q + 1] - 0.5)); x++) add(S, x, y, 1, c, 6);\n  }\n  // The curve, the one it replaces fading out.\n  const f = S.fade, ease = f * f * (3 - 2 * f);\n  for (let p = 0; p \u003c W * TOP; p++) {\n    let v = cur.ras[p] * ease;\n    if (S.old && f \u003c 1) v += S.old.ras[p] * (1 - ease);\n    if (v > 0) (R[p] += v * c[0]), (G[p] += v * c[1]), (B[p] += v * c[2]);\n  }\n  // The polygons of the openings already walked on this curve stay, dim,\n  // each finer one closer to the curve, down to 7.9 LEDs; finer ones lie on\n  // the curve. The one under way is bright, less so the finer it is, so a\n  // fine polygon does not bury the curve under it.\n  for (let o = 0; o \u003c min(S.k, 4); o++) {\n    const v = cur.walks[o];\n    for (let q = 0; q \u003c v.steps; q++) line(S, v.tx[q], v.ty[q], v.tx[q + 1], v.ty[q + 1], 0.6, c, 15);\n    line(S, v.tx[v.steps], v.ty[v.steps], cur.X[cur.n], cur.Y[cur.n], 0.6, c, 15);\n  }\n  // The polygon so far, and the gap to the curve's end once it is done.\n  const pv = 0.2 + 0.75 * min(1, w.s / 8);\n  for (let q = 0; q \u003c m; q++) line(S, w.tx[q], w.ty[q], w.tx[q + 1], w.ty[q + 1], pv, c, 3);\n  if (done) line(S, tipx, tipy, cur.X[cur.n], cur.Y[cur.n], pv, c, 3);\n  // The dividers: standing on the last two tips, or pivoting on the last\n  // tip while the other leg swings over to the next one, the hinge 0.45 s\n  // off the chord.\n  const px = tipx, py = tipy;\n  let qx, qy;\n  if (!done && m \u003c w.steps) {\n    const a0 = m > 0 ? atan2(w.ty[m - 1] - py, w.tx[m - 1] - px) : atan2(w.ty[1] - py, w.tx[1] - px) - PI;\n    let a1 = atan2(w.ty[m + 1] - py, w.tx[m + 1] - px);\n    while (a1 \u003c a0) a1 += 2 * PI;\n    const a = a0 + (a1 - a0) * fr;\n    qx = px + w.s * cos(a);\n    qy = py + w.s * sin(a);\n  } else if (m > 0) (qx = w.tx[m - 1]), (qy = w.ty[m - 1]);\n  else (qx = px + w.s * 0.6), (qy = py + w.s * 0.8);\n  const ex = qx - px, ey = qy - py, el = hypot(ex, ey) || 1;\n  const hx = (px + qx) / 2 + (ey / el) * 0.45 * w.s, hy = (py + qy) / 2 - (ex / el) * 0.45 * w.s;\n  line(S, px, py, hx, hy, 0.9, c, 9);\n  line(S, qx, qy, hx, hy, 0.9, c, 9);\n  splat(S, px, py, 1.4, c, 9);\n  splat(S, qx, qy, 1.4, c, 9);\n\n  // The plot. The line has slope 1 - D through the middle of the points.\n  const ay = S.ay, ply = (ll) => PC - (ll - ay) * KY;\n  const mine = points(cur).slice(0, S.k + (done ? 1 : 0));\n  for (let x = 1; x \u003c W - 1; x += 0.5) {\n    const yy = ply(ay + (1 - S.D) * ((x - 3) / KX - 0.1 - MLS));\n    if (yy >= PT - 1 && yy \u003c= PB + 1) splat(S, x, yy, 0.5, c, 12);\n  }\n  // The openings: a faint column each, evenly spaced in log s, and a tick\n  // under each along the bottom, the one being walked white.\n  for (let q = 0; q \u003c NO; q++) {\n    const x = round(plx(log10(OPEN[q])) - 0.5);\n    for (let y = PT + (q & 1); y \u003c= PB; y += 2) add(S, x, y, 0.55, c, 12);\n    add(S, x, 126, q === S.k ? 1 : 0.8, c, q === S.k ? 9 : 12);\n    add(S, x, 127, q === S.k ? 1 : 0.8, c, q === S.k ? 9 : 12);\n  }\n  // The curve's mean piece, where the line has to stop.\n  const lf = plx(log10(cur.piece));\n  if (lf > 1 && lf \u003c W - 1) for (let y = PT; y \u003c= PB; y += 3) splat(S, lf, y, 1, c, 12);\n  for (let g = S.ghosts.length - 1; g >= 0; g--)\n    for (const p of S.ghosts[g].pts) {\n      const x = plx(p[0]), y = ply(p[1]);\n      if (y > PT - 3 && y \u003c PB + 2) for (let q = 0; q \u003c 4; q++) add(S, round(x - 0.5) + (q & 1), round(y - 0.5) + (q >> 1), g ? 0.5 : 0.75, c, 15);\n    }\n  for (const p of mine) {\n    const x = round(plx(p[0]) - 0.5), y = round(ply(p[1]) - 0.5);\n    if (y > PT - 3 && y \u003c PB + 2) for (let q = 0; q \u003c 4; q++) add(S, x + (q & 1), y + (q >> 1), 1, c, 3);\n  }\n  // The walk under way: its length so far rising as a bar at its opening.\n  const xo = plx(log10(w.s)), sofar = log10(max(1e-6, (m + fr) * w.s + (done ? w.gap : 0)) / cur.l0);\n  for (let y = PB; y >= max(PT - 3, ply(sofar)); y -= 1) splat(S, xo, y, 0.4, c, 9);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++)\n      display.setPixel(x, y, round(min(1, R[p]) * 255), round(min(1, G[p]) * 255), round(min(1, B[p]) * 255));\n}\n","rutherford-shadow":"// ===== Patternflow pattern =====\n// Title:   Rutherford Shadow\n// Family:  physics\n// Idea:    A parallel beam of equal-energy particles streams up the panel past a repelling nucleus a third of the way up, each particle on its own Coulomb hyperbola with the nucleus at the outer focus, and since every hyperbola only touches the parabola with its focus at the nucleus and its vertex d below it, the beam leaves a sharp parabolic shadow above the nucleus, its edge lit by the orbits that bunch along it while the few head-on particles turn back down in gold.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rutherford scattering, tan(theta/2) = d / 2b (Ernest Rutherford, 1911), after the gold-foil scattering of alpha particles (Hans Geiger and Ernest Marsden, 1909), pattern round 60\n// Round:   60\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Charge=1..6, Attract=0..1\n//\n// Knob 1: Hue. Turns the beam's colours round the wheel together. At 0 particles that came in on the left of the nucleus are cyan, those on the right violet, and those turned back by more than 90 degrees gold; at 0.25 violet, red and green; at 0.5 red, lime and azure; at 0.75 lime, cyan and magenta. The nucleus stays warm white.\n// Knob 2: Speed. At 2 a particle far from the nucleus moves 45 LEDs a second and crosses the panel in about 3 s, its trail about 10 LEDs long. At 0.2 all of it is ten times slower, at 3 half as fast again; the trails keep their length.\n// Knob 3: Charge. The head-on turning distance d, in LEDs, which grows with the nucleus's charge over the beam's energy. The shadow is the parabola Y = X^2 / 4d - d, Y up the panel from the nucleus: at 1 it is 4 LEDs wide level with the nucleus and 37 wide on the top row, at 2 8 and 53, at 3 12 wide and filling the top 4 rows, at 6 24 wide and filling every row above row 49. A particle with impact parameter under d / 2 turns back by more than 90 degrees, 1 in 72 of the beam at 1 and 1 in 12 at 6.\n// Knob 4: Attract. Turns the charge through zero: the turning distance is d cos(pi K4), 0.98 d at the opening 0.06, 0.71 d at 0.25, nothing at 0.5, where the beam runs straight through, and -d at 1, where the nucleus attracts as hard as it repelled. There the orbits bend in, cross behind the nucleus and fill the shadow, cyan into the violet half and violet into the cyan, and a particle that would pass within 0.35 LED of the centre is taken in, those with impact parameter under 0.69 LED at d = 1.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, sin, cos, atan, round, random, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Units: one LED, and one second at Speed 2. The nucleus sits at the corner\n// of four LEDs, 42 rows above the bottom edge. Orbits are worked in its own\n// frame: X to the right, Y up the panel (downstream), so an LED at panel\n// (x, y) is X = x - XN, Y = YN - y.\nconst XN = 32, YN = 86;\nconst V0 = 45; // beam speed far from the nucleus, LEDs a second\nconst BMAX = 36; // impact parameters fill -36..36, 4 LEDs past each edge\nconst FLUX = 1.2; // particles a second per LED of beam width\nconst TAU = 0.1; // trail fade, seconds\nconst TRAIL = 0.9; // what a trail lays on one LED\nconst TAU_L = 3, GLOW = 0.016, GLOW_REF = 0.1; // the long exposure's fade and gain\nconst RNUC = 0.35; // an attracted particle this close is taken in\nconst CAP = 1400;\n\n// The shadow. Put X = r cos(phi), Y = r sin(phi) into the orbit equation\n// below and it becomes b^2 - X b + (s / 2)(r + Y) = 0, a quadratic in the\n// impact parameter b of the orbits through (X, Y). Two orbits, both from\n// the same side, pass a point where X^2 > 2 s (r + Y); none where it is\n// less; and on X^2 = 2 s (r + Y), which is the parabola Y = X^2 / 4s - s,\n// the two meet in one, b = X / 2, which touches the parabola there. A\n// separate leapfrog run of 2000 orbits from 4000 LEDs below, energy kept to\n// 1e-9, found the nearest any came to the axis at heights -0.9 d to 80\n// LEDs equal to 2 sqrt(d (Y + d)) to four decimals, at b = X / 2 each time.\n// In this pattern, 20 s at each of five repelling settings put one of\n// 572,000 particle positions inside the parabola, by 0.00003 LED; every\n// position lay within 0.026 LED of its exact hyperbola and every energy\n// within 0.06% of V0^2 / 2. Attracting (s \u003c 0) the discriminant\n// X^2 + 2|s|(r + Y) never vanishes: through every point pass two orbits,\n// one from each side, and there is no envelope and no shadow. Above about\n// Y = d/2 the two even share the beam's own flux between them, so in the\n// plane they cross behind the nucleus without bunching.\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, d: 1, q: 1, acc: 0, warm: false, n: 0,\n    X: new Float64Array(CAP), Y: new Float64Array(CAP), VX: new Float64Array(CAP), VY: new Float64Array(CAP),\n    B: new Float32Array(CAP), px: new Float32Array(CAP), py: new Float32Array(CAP),\n    R: new Float32Array(N), G: new Float32Array(N), Bl: new Float32Array(N), c: [0, 0, 0],\n    L: new Float32Array(N * 3), Lt: new Float32Array(N * 3), Lb: new Float32Array(N * 3), head: new Int16Array(N),\n  };\n}\n\n// Place a new particle exactly on its incoming orbit where it crosses Y.\n// For impact parameter b > 0 and signed turning distance s (s > 0 repels),\n// the orbit equation u'' + u = -s / 2b^2 with the particle coming in from\n// phi = -pi/2 gives u = 1/r = cos(phi) / b - (s / 2b^2) (1 + sin(phi)).\n// Energy and angular momentum b V0 then give the velocity.\nfunction spawn(S, b, Y) {\n  if (S.n >= CAP) return;\n  const s = S.d * S.q, ab = b \u003c 0 ? -b : b, sg = b \u003c 0 ? -1 : 1;\n  const c = s / (2 * ab * ab);\n  const u = (ph) => cos(ph) / ab - c * (1 + sin(ph));\n  let X, YY, vx, vy;\n  if (s === 0) {\n    X = ab;\n    YY = Y;\n    vx = 0;\n    vy = V0;\n  } else {\n    // y(phi) = sin(phi) / u(phi) rises from -infinity on the incoming leg\n    // up to the closest approach (repelled) or to the side of the nucleus.\n    let lo = -PI / 2 + 1e-12, hi = s > 0 ? -atan(s / (2 * ab)) : 0;\n    for (let i = 0; i \u003c 44; i++) {\n      const m = 0.5 * (lo + hi);\n      if (sin(m) / u(m) \u003c Y) lo = m;\n      else hi = m;\n    }\n    const ph = 0.5 * (lo + hi), uu = u(ph), r = 1 / uu;\n    X = r * cos(ph);\n    YY = r * sin(ph);\n    const v2 = V0 * V0 * (1 - s * uu), vt = ab * V0 * uu, vr = -sqrt(max(0, v2 - vt * vt));\n    vx = vr * cos(ph) - vt * sin(ph);\n    vy = vr * sin(ph) + vt * cos(ph);\n  }\n  const i = S.n++;\n  S.X[i] = sg * X;\n  S.Y[i] = YY;\n  S.VX[i] = sg * vx;\n  S.VY[i] = vy;\n  S.B[i] = b;\n  S.px[i] = XN + S.X[i];\n  S.py[i] = YN - S.Y[i];\n}\n\nfunction kill(S, i) {\n  const j = --S.n;\n  S.X[i] = S.X[j];\n  S.Y[i] = S.Y[j];\n  S.VX[i] = S.VX[j];\n  S.VY[i] = S.VY[j];\n  S.B[i] = S.B[j];\n  S.px[i] = S.px[j];\n  S.py[i] = S.py[j];\n}\n\n// Kick-drift-kick leapfrog in the nucleus's frame, the step cut so that no\n// step moves a particle more than a twentieth of its distance from the\n// nucleus or lets the force turn it by more than about that.\nfunction advance(S, ds) {\n  const k = (S.d * S.q * V0 * V0) / 2, ak = k \u003c 0 ? -k : k;\n  for (let i = 0; i \u003c S.n; i++) {\n    let x = S.X[i], y = S.Y[i], vx = S.VX[i], vy = S.VY[i], t = ds, dead = false;\n    for (let it = 0; it \u003c 4000 && t > 0; it++) {\n      const r2 = x * x + y * y, r = sqrt(r2), sp = sqrt(vx * vx + vy * vy) + 1e-9;\n      if (r \u003c RNUC) {\n        dead = true;\n        break;\n      }\n      let h = 0.05 * (r / sp);\n      if (ak > 0) h = min(h, 0.05 * sqrt((r2 * r) / ak));\n      h = min(h, t);\n      t -= h;\n      let f = k / (r2 * r);\n      vx += 0.5 * h * f * x;\n      vy += 0.5 * h * f * y;\n      x += h * vx;\n      y += h * vy;\n      const q2 = x * x + y * y;\n      f = k / (q2 * sqrt(q2));\n      vx += 0.5 * h * f * x;\n      vy += 0.5 * h * f * y;\n    }\n    S.X[i] = x;\n    S.Y[i] = y;\n    S.VX[i] = vx;\n    S.VY[i] = vy;\n    const px = XN + x, py = YN - y;\n    if (dead || py \u003c -3 || py > H + 4 || px \u003c -4 || px > W + 4) {\n      kill(S, i);\n      i--;\n    }\n  }\n}\n\nfunction feed(S, ds) {\n  // Poisson arrivals across the beam; each one starts a random part of this\n  // step's travel below the panel's bottom edge.\n  S.acc += ds * FLUX * 2 * BMAX;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    let b = (2 * random() - 1) * BMAX;\n    if (b > -0.01 && b \u003c 0.01) b = 0.01;\n    spawn(S, b, YN - H - 1 - random() * V0 * ds);\n  }\n}\n\n// One trail colour per particle: the side of the beam it came from, cyan on\n// the left and violet on the right, and gold once it has been turned back\n// by more than 90 degrees, tan(theta / 2) = |s| / 2|b| > 1.\nfunction colour(S, b, out) {\n  const ab = b \u003c 0 ? -b : b, s = S.d * S.q;\n  if ((s \u003c 0 ? -s : s) > 2 * ab) hsv(S.hue + 0.12, 0.85, 1, out);\n  else hsv(S.hue + (b \u003c 0 ? 0.52 : 0.78), 0.9, 1, out);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.d = cl(kv[2], 1, 6);\n  S.q = cos(PI * cl(kv[3], 0, 1));\n  if (Math.abs(S.q) \u003c 1e-6) S.q = 0;\n  if (!S.warm) {\n    // Open on the beam already flowing: 3.27 s of it, enough for a\n    // particle to cross all 128 rows. The first 2.93 s go in steps of\n    // 1/15 s and only lay the long exposure, weighted by how much of it\n    // would have faded by then; the trails need just the last 0.33 s.\n    S.warm = true;\n    for (let i = 0; i \u003c 44; i++) step(S, 1 / 15, exp(-(43 - i) / 15 / TAU_L));\n    for (let i = 0; i \u003c 10; i++) step(S, 1 / 30, 0);\n    return;\n  }\n  step(S, (d * S.speed) / 2);\n}\n\nfunction step(S, ds, early) {\n  for (let j = 0; j \u003c S.n; j++) (S.px[j] = XN + S.X[j]), (S.py[j] = YN - S.Y[j]);\n  feed(S, ds);\n  advance(S, ds);\n  lay(S, ds, early);\n}\n\n// Trails add, so where the orbits bunch the LEDs burn brighter.\nfunction dep(S, x, y, r, g, b) {\n  const ix = floor(x), iy = floor(y);\n  if (ix \u003c 0 || ix >= W || iy \u003c 0 || iy >= H) return;\n  const p = iy * W + ix;\n  S.R[p] += r;\n  S.G[p] += g;\n  S.Bl[p] += b;\n}\n\n// Fade the trails by one step and lay each particle's path over it, the\n// path it took this step, dimmer towards where it was. An early step of the\n// opening lays only the long exposure, at weight early.\nfunction lay(S, ds, early) {\n  const R = S.R, G = S.G, B = S.Bl, c = S.c, L = S.L, fade = exp(-ds / TAU), fadeL = exp(-ds / TAU_L);\n  if (!early) {\n    for (let p = 0; p \u003c N; p++) {\n      R[p] *= fade;\n      G[p] *= fade;\n      B[p] *= fade;\n    }\n    for (let p = 0; p \u003c N * 3; p++) L[p] *= fadeL;\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const x1 = XN + S.X[i], y1 = YN - S.Y[i], x0 = S.px[i], y0 = S.py[i];\n    colour(S, S.B[i], c);\n    const len = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2), m = min(40, 1 + floor(len * 2));\n    // Each sample stands for len / m of path, so a trail lays TRAIL on each\n    // LED of path it crosses, at any speed.\n    const share = (TRAIL * len) / m;\n    for (let j = 0; j \u003c m; j++) {\n      const a = j / m, w = share * exp((-(1 - a) * ds) / TAU);\n      const x = x0 + (x1 - x0) * a, y = y0 + (y1 - y0) * a;\n      if (!early) dep(S, x, y, c[0] * w, c[1] * w, c[2] * w);\n      // The long exposure: path length, in the particle's colour.\n      const ix = floor(x), iy = floor(y);\n      if (ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c H) {\n        const p = (iy * W + ix) * 3, e = (len / m) * (early || 1);\n        L[p] += c[0] * e;\n        L[p + 1] += c[1] * e;\n        L[p + 2] += c[2] * e;\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const R = S.R, G = S.G, B = S.Bl, L = S.L, Lb = S.Lb;\n  // The long exposure, blurred over 3 x 3 LEDs (across, then down), glows\n  // faintly under the trails: the beam's own density, dark in the shadow\n  // and brightest just outside its edge.\n  const T = S.Lt;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 3, a = x > 0 ? q - 3 : q, b = x \u003c W - 1 ? q + 3 : q;\n      for (let ch = 0; ch \u003c 3; ch++) T[q + ch] = L[a + ch] + L[q + ch] + L[b + ch];\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 3, a = y > 0 ? q - 3 * W : q, b = y \u003c H - 1 ? q + 3 * W : q;\n      const r = T[a] + T[q] + T[b], g = T[a + 1] + T[q + 1] + T[b + 1], bl = T[a + 2] + T[q + 2] + T[b + 2];\n      // Squared, so the glow is faint over the open beam and twice the\n      // density along the edge shows four times as bright.\n      const k = (max(r, g, bl) * GLOW * GLOW) / (81 * GLOW_REF);\n      Lb[q] = r * k;\n      Lb[q + 1] = g * k;\n      Lb[q + 2] = bl * k;\n    }\n  // Each head is a near-white LED drawn over its trail, left out of the\n  // trail itself so a slow beam does not smear it.\n  const head = S.head, c = S.c;\n  head.fill(-1);\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = floor(XN + S.X[i]), y = floor(YN - S.Y[i]);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) head[y * W + x] = i;\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      // The nucleus: four warm white LEDs.\n      if ((x === XN - 1 || x === XN) && (y === YN - 1 || y === YN)) display.setPixel(x, y, 255, 236, 200);\n      else if (head[p] >= 0) {\n        colour(S, S.B[head[p]], c);\n        display.setPixel(x, y, round(140 + 115 * c[0]), round(140 + 115 * c[1]), round(140 + 115 * c[2]));\n      } else {\n        const q = p * 3;\n        display.setPixel(x, y, round(min(1, R[p] + Lb[q]) * 255), round(min(1, G[p] + Lb[q + 1]) * 255), round(min(1, B[p] + Lb[q + 2]) * 255));\n      }\n    }\n}\n","clebsch-surface":"// ===== Patternflow pattern =====\n// Title:   Clebsch Surface\n// Family:  space\n// Idea:    Clebsch's diagonal cubic surface turns slowly about its three-fold axis inside a flat glass spheroid that stands the height of the panel, shaded by its normal in one colour for each of its two sides, with all 27 of its real lines drawn on it, the twelve of Schläfli's double six in two colours and the other fifteen in a third, dimmer where a sheet hides them, while a white focus steps from line to line and lights the ten lines that meet it and the points where they cross it.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Clebsch diagonal surface (Alfred Clebsch, 1871), the 27 lines on a cubic surface (Arthur Cayley and George Salmon, 1849), the double six (Ludwig Schläfli, 1858), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Glass=0..1, Tilt=12..60\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 one side of the surface is steel blue and the other mauve, one six of the double six is cyan and the other pink, and the fifteen other lines are green; at 0.5 the sides are rose and teal, the sixes magenta and azure and the fifteen violet. The wheel skips orange through lime, which read brown and olive when dim.\n// Knob 2: Speed. At 2 the surface turns a third of the way round its axis, which brings it back to the same shape, in 12 seconds, and every 2.5 seconds the focus steps to one of the ten lines that meet it; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Glass. At 0 the surface is opaque and a line behind a sheet keeps a fifth of its light; at 1 each sheet lets 65% of what is behind it through, so the back sheets show and a line behind one sheet keeps 72% of its light.\n// Knob 4: Tilt. How far the axis turns towards the eye, 12 to 60 degrees. At 12 the axis lies nearly across the panel and the spheroid's outline stands 118 LEDs tall; towards 60 the eye looks down the axis onto the three-fold star round the Eckardt point (1/3, 1/3, 1/3), and the outline shrinks to keep within the width.\n\nconst W = 64, H = 128;\nconst { sqrt, sin, cos, abs, min, max, floor, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst S5 = sqrt(5);\n\n// The surface, in the affine form with the three coordinates on an equal\n// footing: F = 81 (x^3 + y^3 + z^3) - 189 (x^2 y + x^2 z + y^2 x + y^2 z +\n// z^2 x + z^2 y) + 54 xyz + 126 (xy + yz + zx) - 9 (x^2 + y^2 + z^2) -\n// 9 (x + y + z) + 1. Swapping coordinates keeps it, so the line x = y = z is\n// an axis of three-fold symmetry; it meets the surface once, at\n// (1/3, 1/3, 1/3), where three of the lines cross (an Eckardt point).\nfunction F(x, y, z) {\n  return (\n    81 * (x * x * x + y * y * y + z * z * z) -\n    189 * (x * x * (y + z) + y * y * (x + z) + z * z * (x + y)) +\n    54 * x * y * z +\n    126 * (x * y + y * z + z * x) -\n    9 * (x * x + y * y + z * z) -\n    9 * (x + y + z) +\n    1\n  );\n}\n// Its gradient, into g.\nfunction grad(x, y, z, g) {\n  g[0] = 243 * x * x - 189 * (2 * x * (y + z) + y * y + z * z) + 54 * y * z + 126 * (y + z) - 18 * x - 9;\n  g[1] = 243 * y * y - 189 * (2 * y * (x + z) + x * x + z * z) + 54 * x * z + 126 * (x + z) - 18 * y - 9;\n  g[2] = 243 * z * z - 189 * (2 * z * (x + y) + x * x + y * y) + 54 * x * y + 126 * (x + y) - 18 * z - 9;\n}\n\n// The 27 lines, each from a base line and its images under the six ways of\n// permuting x, y, z. Fifteen have rational points: three through the\n// Eckardt point, three each through (1/6, 1/6, 0) and (0, 0, -1/3) along\n// (1, -1, 0), and six through (-1/30, 0, 1/10) along (3, 0, 1). The other\n// twelve need sqrt 5: the line through (0, (5 + s sqrt5) / 30, (5 + 3 s\n// sqrt5) / 30) and ((1 - s sqrt5) / 12, 0, (3 + s sqrt5) / 12), with s = 1\n// or -1, and its images. Those twelve are a double six.\nfunction buildLines() {\n  const base = [\n    [[1 / 3, 1 / 3, 1 / 3], [1, -1, 0], 0],\n    [[1 / 6, 1 / 6, 0], [1, -1, 0], 0],\n    [[0, 0, -1 / 3], [1, -1, 0], 0],\n    [[-1 / 30, 0, 1 / 10], [3, 0, 1], 0],\n  ];\n  for (const s of [1, -1]) {\n    const P = [0, (5 + s * S5) / 30, (5 + 3 * s * S5) / 30], Q = [(1 - s * S5) / 12, 0, (3 + s * S5) / 12];\n    base.push([P, [Q[0] - P[0], Q[1] - P[1], Q[2] - P[2]], 1]);\n  }\n  const perms = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]];\n  const L = [];\n  for (const [P, D, irr] of base)\n    for (const p of perms) {\n      const q = [P[p[0]], P[p[1]], P[p[2]]], e = [D[p[0]], D[p[1]], D[p[2]]];\n      const n = sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2]);\n      const d = [e[0] / n, e[1] / n, e[2] / n];\n      // The point nearest the origin stands for the line.\n      const k = q[0] * d[0] + q[1] * d[1] + q[2] * d[2];\n      const m = [q[0] - k * d[0], q[1] - k * d[1], q[2] - k * d[2]];\n      if (L.some((l) => abs(l.p[0] - m[0]) + abs(l.p[1] - m[1]) + abs(l.p[2] - m[2]) \u003c 1e-9 && abs(abs(l.d[0] * d[0] + l.d[1] * d[1] + l.d[2] * d[2]) - 1) \u003c 1e-9)) continue;\n      L.push({ p: m, d, irr, cls: 2, nb: [] });\n    }\n  // Two lines meet when they lie in one plane: (q - p) . (d x e) = 0, which\n  // also holds for parallel lines, and those meet at infinity.\n  const meets = (a, b) => {\n    const cx = a.d[1] * b.d[2] - a.d[2] * b.d[1], cy = a.d[2] * b.d[0] - a.d[0] * b.d[2], cz = a.d[0] * b.d[1] - a.d[1] * b.d[0];\n    return abs((b.p[0] - a.p[0]) * cx + (b.p[1] - a.p[1]) * cy + (b.p[2] - a.p[2]) * cz) \u003c 1e-9;\n  };\n  for (let i = 0; i \u003c L.length; i++) for (let j = 0; j \u003c L.length; j++) if (i !== j && meets(L[i], L[j])) L[i].nb.push(j);\n  // Where they meet: p + s d = q + t e gives s = ((q - p) x e) . n / |n|^2\n  // with n = d x e; parallel lines have no finite point.\n  for (const a of L)\n    a.at = a.nb.map((j) => {\n      const b = L[j], d = a.d, e = b.d;\n      const nx = d[1] * e[2] - d[2] * e[1], ny = d[2] * e[0] - d[0] * e[2], nz = d[0] * e[1] - d[1] * e[0];\n      const nn = nx * nx + ny * ny + nz * nz;\n      if (nn \u003c 1e-12) return null;\n      const wx = b.p[0] - a.p[0], wy = b.p[1] - a.p[1], wz = b.p[2] - a.p[2];\n      const s = ((wy * e[2] - wz * e[1]) * nx + (wz * e[0] - wx * e[2]) * ny + (wx * e[1] - wy * e[0]) * nz) / nn;\n      return [a.p[0] + s * d[0], a.p[1] + s * d[1], a.p[2] + s * d[2]];\n    });\n  // The double six splits in two by meeting: each of its lines meets five\n  // of the other six and none of its own six.\n  const irr = L.map((l, i) => i).filter((i) => L[i].irr);\n  L[irr[0]].cls = 0;\n  for (let sweep = 0; sweep \u003c 12; sweep++)\n    for (const i of irr)\n      if (L[i].cls \u003c 2) for (const j of L[i].nb) if (L[j].irr && L[j].cls === 2) L[j].cls = 1 - L[i].cls;\n  return L;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob turns hues on a wheel that skips orange through lime, which\n// read brown and olive when dim. Hues are given as they look at knob 0,\n// from 0.28 round to 1.02.\nconst tone = (h, k) => 0.28 + 0.74 * ((((h - 0.28) / 0.74 + k) % 1 + 1) % 1);\n\n// The centre of the view sits on the axis at (C0, C0, C0): there the\n// farthest of the 27 lines passes 0.456 from it, the least for any point\n// on the axis.\nconst C0 = 0.1;\nconst UX = 1 / sqrt(3);\nconst E1 = [1 / sqrt(2), -1 / sqrt(2), 0], E2 = [1 / sqrt(6), 1 / sqrt(6), -2 / sqrt(6)];\n\nexport function setup(params) {\n  params.s = {\n    L: buildLines(),\n    th: 0.4,\n    focus: 0,\n    prev: -1,\n    since: 0,\n    hue: 0,\n    glass: 0,\n    tilt: 12,\n    T: new Float32Array(W * H * 3),\n    nT: new Int8Array(W * H),\n    rgb: new Float32Array(W * H * 3),\n    ln: new Float32Array(W * H * 4),\n    g: new Float64Array(3),\n    r: new Float64Array(3),\n    c4: new Float64Array(12),\n    side: [new Float32Array(3), new Float32Array(3)],\n    cls: [new Float32Array(3), new Float32Array(3), new Float32Array(3)],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 12], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.glass = cl(kv[2], 0, 1);\n  S.tilt = cl(kv[3], 12, 60);\n  // A third of a turn in 12 s at Speed 2.\n  S.th += (d * speed * 2 * PI) / 72;\n  S.since += (d * speed) / 2;\n  // Every 2.5 s at Speed 2 the focus steps to one of the ten lines that meet\n  // it, not back to the one it came from.\n  if (S.since >= 2.5) {\n    S.since -= 2.5;\n    const nb = S.L[S.focus].nb.filter((j) => j !== S.prev);\n    S.prev = S.focus;\n    S.focus = nb[floor(Math.random() * nb.length) % nb.length];\n  }\n}\n\n// Real roots of a3 t^3 + a2 t^2 + a1 t + a0 in [t0, t1], ascending, into r,\n// at most the first `most` of them; returns how many. hint is a guess at\n// the first. The cubic's turning points cut the interval into pieces on\n// which it is monotone, and each piece whose ends differ in sign holds one\n// root.\nfunction cubicRoots(a3, a2, a1, a0, t0, t1, r, most, hint) {\n  let c1 = t1, c2 = t1;\n  const A = 3 * a3, B = 2 * a2, C = a1;\n  if (abs(A) > 1e-12) {\n    const disc = B * B - 4 * A * C;\n    if (disc > 0) {\n      const q = -0.5 * (B + (B >= 0 ? sqrt(disc) : -sqrt(disc)));\n      const u = q / A, v = q !== 0 ? C / q : u;\n      c1 = min(u, v);\n      c2 = max(u, v);\n    }\n  } else if (abs(B) > 1e-12) c1 = -C / B;\n  let n = 0, lo = t0, flo = ((a3 * t0 + a2) * t0 + a1) * t0 + a0;\n  for (let k = 0; k \u003c 3 && lo \u003c t1; k++) {\n    let hi = k === 0 ? c1 : k === 1 ? c2 : t1;\n    if (hi \u003c= lo) continue;\n    if (hi > t1) hi = t1;\n    const fhi = ((a3 * hi + a2) * hi + a1) * hi + a0;\n    if (flo \u003c 0 !== fhi \u003c 0 || fhi === 0) {\n      // Newton from the hint when it falls in the bracket (the next LED's\n      // root is close), else from the secant point, kept inside the bracket\n      // by halving.\n      let a = lo, b = hi, m = n === 0 && hint > lo && hint \u003c hi ? hint : (lo * fhi - hi * flo) / (fhi - flo);\n      for (let it = 0; it \u003c 12; it++) {\n        const fm = ((a3 * m + a2) * m + a1) * m + a0;\n        if (fm === 0) break;\n        if (fm \u003c 0 === flo \u003c 0) a = m;\n        else b = m;\n        let nm = m - fm / ((A * m + B) * m + C);\n        if (!(nm > a && nm \u003c b)) nm = 0.5 * (a + b);\n        const step = nm - m;\n        m = nm;\n        if (step \u003c 2e-3 && step > -2e-3) break;\n      }\n      r[n++] = m;\n      if (n === most) break;\n    }\n    lo = hi;\n    flo = fhi;\n  }\n  return n;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { L, T, nT, rgb, ln, g, r } = S;\n  // B is the spheroid's radius along the axis and A across it, twice B. The\n  // surface meets its axis only at the Eckardt point and spreads out across\n  // it, so a flat spheroid holds more of it than a ball would.\n  const B = 0.75, A = 2 * B, glass = S.glass, hue = S.hue;\n  // The view: the axis u lies across the panel, turned towards the eye by\n  // the tilt, and the surface turns about it, so the panel's height runs\n  // along the directions the surface spreads in.\n  const yaw = (S.tilt * PI) / 180;\n  const ct = cos(S.th), st = sin(S.th), cp = cos(yaw), sp = sin(yaw);\n  const U = [ct * E1[0] + st * E2[0], ct * E1[1] + st * E2[1], ct * E1[2] + st * E2[2]];\n  const p2 = [-st * E1[0] + ct * E2[0], -st * E1[1] + ct * E2[1], -st * E1[2] + ct * E2[2]];\n  const E = [cp * p2[0] + sp * UX, cp * p2[1] + sp * UX, cp * p2[2] + sp * UX];\n  const R = [cp * UX - sp * p2[0], cp * UX - sp * p2[1], cp * UX - sp * p2[2]];\n  const vx = -E[0], vy = -E[1], vz = -E[2];\n  // LEDs per unit: the outline is sqrt(B^2 cos^2 + A^2 sin^2) wide either\n  // side of the middle and A tall, and whichever is tighter sets the scale.\n  const k = min(31.5 / sqrt(B * B * cp * cp + A * A * sp * sp), 63 / A);\n  // Along the view direction the cubic's top coefficient is the same for\n  // every ray, and so is the gradient of its cubic part at v.\n  const a3 = 81 * (vx * vx * vx + vy * vy * vy + vz * vz * vz) - 189 * (vx * vx * (vy + vz) + vy * vy * (vx + vz) + vz * vz * (vx + vy)) + 54 * vx * vy * vz;\n  const g3x = 243 * vx * vx - 189 * (2 * vx * (vy + vz) + vy * vy + vz * vz) + 54 * vy * vz;\n  const g3y = 243 * vy * vy - 189 * (2 * vy * (vx + vz) + vx * vx + vz * vz) + 54 * vx * vz;\n  const g3z = 243 * vz * vz - 189 * (2 * vz * (vx + vy) + vx * vx + vy * vy) + 54 * vx * vy;\n  const qv = 126 * (vx * vy + vy * vz + vz * vx) - 9 * (vx * vx + vy * vy + vz * vz);\n  // Ray against spheroid: the ray's parts along u and across it.\n  const vu = (vx + vy + vz) * UX, vpx = vx - vu * UX, vpy = vy - vu * UX, vpz = vz - vu * UX;\n  const iA2 = 1 / (A * A), iB2 = 1 / (B * B);\n  const qa = (vpx * vpx + vpy * vpy + vpz * vpz) * iA2 + vu * vu * iB2;\n  const ru = (R[0] + R[1] + R[2]) * UX, rpx = R[0] - ru * UX, rpy = R[1] - ru * UX, rpz = R[2] - ru * UX;\n\n  // The light comes from up and to the left of the eye.\n  const lx0 = -0.45, ly0 = 0.6, lz0 = 0.66;\n  const Lx = lx0 * R[0] + ly0 * U[0] + lz0 * E[0], Ly = lx0 * R[1] + ly0 * U[1] + lz0 * E[1], Lz = lx0 * R[2] + ly0 * U[2] + lz0 * E[2];\n  const hn = 1 / sqrt((Lx + E[0]) ** 2 + (Ly + E[1]) ** 2 + (Lz + E[2]) ** 2);\n  const Hx = (Lx + E[0]) * hn, Hy = (Ly + E[1]) * hn, Hz = (Lz + E[2]) * hn;\n  // The two sides: where F > 0 and where F \u003c 0.\n  const side = S.side;\n  hsv(tone(0.6, hue), 0.5, 1, side[0], 0);\n  hsv(tone(0.8, hue), 0.38, 1, side[1], 0);\n  // Each sheet lets through this much of what is behind it. An opaque\n  // surface needs only the first sheet along each ray: a line behind it is\n  // dimmed the same however many more there are.\n  const pass = glass * 0.65, most = pass > 0 ? 3 : 1;\n\n  // Every surface point the ray through each LED meets inside the spheroid,\n  // t measured from the plane through the centre: the cubic F(o + t v) =\n  // a3 t^3 + a2 t^2 + a1 t + a0, a1 the gradient at o along v and a2 from\n  // the polarised cubic part. Along a row a0 is a cubic in the column, a1 a\n  // quadratic and a2 linear, so after four columns each is carried by its\n  // differences.\n  const c4 = S.c4;\n  for (let py = 0, p = 0; py \u003c H; py++) {\n    const sy = (H / 2 - py - 0.5) / k;\n    for (let j = 0; j \u003c 4; j++) {\n      const sx = (j + 0.5 - W / 2) / k;\n      const ox = C0 + sx * R[0] + sy * U[0], oy = C0 + sx * R[1] + sy * U[1], oz = C0 + sx * R[2] + sy * U[2];\n      grad(ox, oy, oz, g);\n      c4[j] = F(ox, oy, oz);\n      c4[4 + j] = g[0] * vx + g[1] * vy + g[2] * vz;\n      c4[8 + j] = g3x * ox + g3y * oy + g3z * oz + qv;\n    }\n    // The ray against the spheroid, qa t^2 + qb t + qc = 0, with qb linear\n    // and qc quadratic in sx along the row.\n    const hx = sy * U[0], hy = sy * U[1], hz = sy * U[2], hu = (hx + hy + hz) * UX;\n    const hpx = hx - hu * UX, hpy = hy - hu * UX, hpz = hz - hu * UX;\n    const qb0 = 2 * ((hpx * vpx + hpy * vpy + hpz * vpz) * iA2 + hu * vu * iB2), qbx = 2 * ((rpx * vpx + rpy * vpy + rpz * vpz) * iA2 + ru * vu * iB2);\n    const qc0 = (hpx * hpx + hpy * hpy + hpz * hpz) * iA2 + hu * hu * iB2 - 1;\n    const qcx = 2 * ((hpx * rpx + hpy * rpy + hpz * rpz) * iA2 + hu * ru * iB2), qcxx = (rpx * rpx + rpy * rpy + rpz * rpz) * iA2 + ru * ru * iB2;\n    let a0 = c4[0], d01 = c4[1] - c4[0], d02 = c4[2] - 2 * c4[1] + c4[0];\n    const d03 = c4[3] - 3 * c4[2] + 3 * c4[1] - c4[0];\n    let a1 = c4[4], d11 = c4[5] - c4[4];\n    const d12 = c4[6] - 2 * c4[5] + c4[4];\n    let a2 = c4[8];\n    const d21 = c4[9] - c4[8];\n    let hint = NaN;\n    for (let px = 0; px \u003c W; px++, p++) {\n      if (px > 0) {\n        a0 += d01;\n        d01 += d02;\n        d02 += d03;\n        a1 += d11;\n        d11 += d12;\n        a2 += d21;\n      }\n      const o = p * 3;\n      rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n      nT[p] = -1;\n      const sx = (px + 0.5 - W / 2) / k, qb = qb0 + qbx * sx, qc = qc0 + (qcx + qcxx * sx) * sx;\n      const disc = qb * qb - 4 * qa * qc;\n      if (disc \u003c= 0) {\n        hint = NaN;\n        continue;\n      }\n      const sq = sqrt(disc), t0 = (-qb - sq) / (2 * qa), t1 = (-qb + sq) / (2 * qa);\n      // A faint glass shell where the ray grazes the spheroid.\n      const sk = (t1 - t0) * k, rim = sk \u003c 8 ? 0.2 * (1 - sk / 8) * (1 - sk / 8) : 0;\n      rgb[o] = rim * 0.6;\n      rgb[o + 1] = rim * 0.75;\n      rgb[o + 2] = rim;\n      const ox = C0 + sx * R[0] + hx, oy = C0 + sx * R[1] + hy, oz = C0 + sx * R[2] + hz;\n      const n = cubicRoots(a3, a2, a1, a0, t0, t1, r, most, hint);\n      hint = n > 0 ? r[0] : NaN;\n      nT[p] = n;\n      let through = 1, cr = 0, cg = 0, cb = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const t = (T[o + i] = r[i]);\n        if (through \u003c 0.02) continue;\n        grad(ox + t * vx, oy + t * vy, oz + t * vz, g);\n        const nl = sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]) || 1;\n        let nx = g[0] / nl, ny = g[1] / nl, nz = g[2] / nl;\n        // Which side faces the eye: the gradient points to F > 0.\n        const facing = nx * E[0] + ny * E[1] + nz * E[2], col = side[facing > 0 ? 0 : 1];\n        if (facing \u003c 0) (nx = -nx), (ny = -ny), (nz = -nz);\n        const dif = max(0, nx * Lx + ny * Ly + nz * Lz);\n        let sp2 = max(0, nx * Hx + ny * Hy + nz * Hz);\n        sp2 *= sp2;\n        sp2 *= sp2;\n        sp2 *= sp2;\n        const spec = 0.45 * sp2 * sp2 * sp2;\n        // Depth cue: the far side of the spheroid is dimmer.\n        const fog = 1 - 0.5 * cl((t + A) / (2 * A), 0, 1);\n        const lum = (0.13 + 0.42 * dif + 0.25 * abs(facing)) * fog, a = through * (1 - pass);\n        cr += a * (col[0] * lum + spec);\n        cg += a * (col[1] * lum + spec);\n        cb += a * (col[2] * lum + spec);\n        through *= pass;\n      }\n      rgb[o] = rgb[o] * through + cr;\n      rgb[o + 1] = rgb[o + 1] * through + cg;\n      rgb[o + 2] = rgb[o + 2] * through + cb;\n    }\n  }\n\n  // The lines, sampled every LED. A sample is a point of the surface, and\n  // the sheets the ray through its LED meets before it hide it. The LED's\n  // centre is up to half an LED off the line, so the sample's depth is\n  // carried there along the surface's tangent plane before comparing.\n  ln.fill(0);\n  const plot = (X, Y, Z, cr, cg, cb, base, hid, wide, reach, top) => {\n    const sx = X * R[0] + Y * R[1] + Z * R[2], sy = X * U[0] + Y * U[1] + Z * U[2], tz = X * vx + Y * vy + Z * vz;\n    const fx = W / 2 + sx * k - 0.5, fy = H / 2 - sy * k - 0.5;\n    const cx = round(fx), cy = round(fy);\n    if (cx \u003c 0 || cx >= W || cy \u003c 0 || cy >= H) return;\n    const pc = cy * W + cx, n = nT[pc];\n    let m = 0;\n    if (n > 0) {\n      grad(X + C0, Y + C0, Z + C0, g);\n      const gv = g[0] * vx + g[1] * vy + g[2] * vz;\n      let tc = tz;\n      if (abs(gv) > 1e-6 * (abs(g[0]) + abs(g[1]) + abs(g[2]))) {\n        const dsx = (cx - fx) / k, dsy = (fy - cy) / k;\n        tc -= ((g[0] * R[0] + g[1] * R[1] + g[2] * R[2]) * dsx + (g[0] * U[0] + g[1] * U[1] + g[2] * U[2]) * dsy) / gv;\n      }\n      for (let i = 0; i \u003c n; i++) if (T[pc * 3 + i] \u003c tc - 0.03) m++;\n    }\n    const fog = 1 - 0.5 * cl((tz + A) / (2 * A), 0, 1);\n    const a = base * fog * (m === 0 ? 1 : hid + (1 - hid) * pass ** m * glass);\n    // Laid over the LEDs it is near, a soft disc of radius about\n    // sqrt(1.2 / wide) LEDs.\n    for (let yy = cy - reach; yy \u003c= cy + reach; yy++) {\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let xx = cx - reach; xx \u003c= cx + reach; xx++) {\n        if (xx \u003c 0 || xx >= W) continue;\n        const ex = xx - fx, ey = yy - fy, w = cl(1.2 - (ex * ex + ey * ey) * wide, 0, 1) * a, q = (yy * W + xx) * 4;\n        if (top) {\n          // Laid on top of what is there.\n          const o = ln[q + 3], b = o > 0 ? 1 - w : 0;\n          ln[q] = ln[q] * b + cr * (1 - b);\n          ln[q + 1] = ln[q + 1] * b + cg * (1 - b);\n          ln[q + 2] = ln[q + 2] * b + cb * (1 - b);\n          ln[q + 3] = max(o, w);\n        } else if (w > ln[q + 3]) {\n          ln[q + 3] = w;\n          ln[q] = cr;\n          ln[q + 1] = cg;\n          ln[q + 2] = cb;\n        }\n      }\n    }\n  };\n  // Line colours: the two sixes of the double six, then the fifteen.\n  const cls = S.cls;\n  hsv(tone(0.5, hue), 0.85, 1, cls[0], 0);\n  hsv(tone(0.95, hue), 0.75, 1, cls[1], 0);\n  hsv(tone(0.3, hue), 0.7, 1, cls[2], 0);\n  // The focus and the ten lines that meet it are lit; the other sixteen,\n  // skew to it, are dimmed. The focus turns white over 0.3 s, and where it\n  // runs behind a sheet it keeps half its light, the others a fifth.\n  const F0 = S.focus, nbs = L[F0].nb, fin = min(1, S.since / 0.3);\n  // Where a line enters and leaves the spheroid, as s along it, into S.s0\n  // and S.s1.\n  const span = (P, D) => {\n    const wx = P[0] - C0, wy = P[1] - C0, wz = P[2] - C0, wu = (wx + wy + wz) * UX, du = (D[0] + D[1] + D[2]) * UX;\n    const wpx = wx - wu * UX, wpy = wy - wu * UX, wpz = wz - wu * UX, dpx = D[0] - du * UX, dpy = D[1] - du * UX, dpz = D[2] - du * UX;\n    const qa2 = (dpx * dpx + dpy * dpy + dpz * dpz) * iA2 + du * du * iB2;\n    const qb2 = 2 * ((wpx * dpx + wpy * dpy + wpz * dpz) * iA2 + wu * du * iB2);\n    const qc2 = (wpx * wpx + wpy * wpy + wpz * wpz) * iA2 + wu * wu * iB2 - 1;\n    const disc = qb2 * qb2 - 4 * qa2 * qc2;\n    if (disc \u003c= 0) return false;\n    S.s0 = (-qb2 - sqrt(disc)) / (2 * qa2);\n    S.s1 = (-qb2 + sqrt(disc)) / (2 * qa2);\n    return true;\n  };\n  for (let li = 0; li \u003c L.length; li++) {\n    const l = L[li], P = l.p, D = l.d;\n    if (!span(P, D)) continue;\n    const s0 = S.s0, s1 = S.s1, isF = li === F0;\n    const base = isF || nbs.includes(li) ? 1 : 0.3, wh = isF ? 0.7 * fin : 0;\n    const col = cls[l.irr ? l.cls : 2];\n    const cr = col[0] + (1 - col[0]) * wh, cg = col[1] + (1 - col[1]) * wh, cb = col[2] + (1 - col[2]) * wh;\n    const steps = max(2, round((s1 - s0) * k));\n    for (let e = 0; e \u003c= steps; e++) {\n      const s = s0 + ((s1 - s0) * e) / steps;\n      plot(P[0] - C0 + s * D[0], P[1] - C0 + s * D[1], P[2] - C0 + s * D[2], cr, cg, cb, base, isF ? 0.5 : 0.2, isF ? 0.5 : 1.3, 1, false);\n    }\n  }\n  // The points where the ten meet the focus, white, those inside the\n  // spheroid; a line parallel to the focus meets it at infinity.\n  for (const X of L[F0].at) {\n    if (!X) continue;\n    const x = X[0] - C0, y = X[1] - C0, z = X[2] - C0, u = (x + y + z) * UX;\n    const px = x - u * UX, py = y - u * UX, pz = z - u * UX;\n    if ((px * px + py * py + pz * pz) * iA2 + u * u * iB2 >= 1) continue;\n    plot(x, y, z, 1, 1, 1, fin, 0.5, 0.3, 2, true);\n  }\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3, q = p * 4, w = ln[q + 3];\n      display.setPixel(\n        x,\n        y,\n        (255 * cl(rgb[o] * (1 - w) + ln[q] * w, 0, 1)) | 0,\n        (255 * cl(rgb[o + 1] * (1 - w) + ln[q + 1] * w, 0, 1)) | 0,\n        (255 * cl(rgb[o + 2] * (1 - w) + ln[q + 2] * w, 0, 1)) | 0,\n      );\n    }\n}\n","granular-demon":"// ===== Patternflow pattern =====\n// Title:   Granular Demon\n// Family:  particle\n// Idea:    Grains on a shaken floor fly between tall boxes through a window in each wall, and since a crowded box loses its energy in collisions and stops sending grains up to the window while a sparse one keeps throwing them over, one box fills with a cold heap lying low and the others keep a few hot grains flying to the lid, until the walls slide up, the grains spread out and the next run picks its box.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Maxwell's demon in a vibrated granular gas (Holger Schlichting and Volker Nordmark, 1996), the flux model F(n) = n^2 exp(-B n^2) (Jens Eggers, 1999), the sudden collapse of a granular cluster in several compartments (Devaraj van der Meer, Ko van der Weele and Detlef Lohse, 2002), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shaking=130..260, Boxes=2..5\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 a cold box and its slow grains are azure, a hot box pink and the fast grains paler pink, violet between; at 0.5 cold is rose and hot is blue. The scale runs the other way round when it would cross the orange to lime gap, which reads brown when dim.\n// Knob 2: Speed. 2 runs the simulation in real time, gravity 300 LEDs a second squared, so a grain leaving the floor at 275 LEDs a second just reaches the lid; 0.2 is ten times slower and 3 half as fast again. A run ends once one box has held 85% of the 240 grains, or the windows have stayed quiet, for 8 seconds, or at 45 seconds; then the walls slide up for 3 seconds while the floor shakes at 300, slide back down, and the shaking eases to the knob's over 1.5 seconds.\n// Knob 3: Shaking. The floor's speed U, 130 to 260 LEDs a second: a grain falling onto it at v leaves at U + 0.7 (U + v). At 130 two boxes split about 10 seconds into a run and the fuller one keeps 97.7% of the grains (Eggers's flux model, fitted to this floor, says 97.9%); at 150, 92.7% (93.0%); from about 170 the even split holds. More boxes cluster under harder shaking, with a sudden collapse into one box after a long even spell: three boxes up to 160, four up to 200, five up to 230, and five at 130 freeze with the grains in two boxes until the reset.\n// Knob 4: Boxes. 2 to 5 boxes across the 64 columns, the walls one LED thick at k x 64 / n, each with a window 40 rows tall from 50 to 90 LEDs above the floor. A new count deals the grains out evenly again.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, exp, log, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The demon is the grains themselves. A box of grains at temperature T\n// holds them in a barometric layer of height T / g, and collisions, each\n// losing 1 - 0.85^2 = 28% of the energy along the line of centres, cool it\n// faster the more grains it has. So the flux F(n) out through a window\n// first rises with n and then falls: Eggers wrote F(n) = A n^2 exp(-B n^2),\n// and an even split of N grains between two boxes is unstable once\n// B N^2 > 4. Measured here with the window turned into a counting mirror,\n// F(n) peaks near n = 80 when the floor moves at 130 (a fit gives B N^2 =\n// 8.1 for N = 240) and near n = 160 when it moves at 260 (2.8).\n\n// Lengths are in LEDs, time in seconds of the simulation. z counts up from\n// the floor, the bottom edge of row 125, to the lid, the top edge of row 0.\nconst ZTOP = 126;\nconst N = 240, RAD = 0.5, DIA = 1;\nconst GRAV = 300;\n// Restitution: grain on grain, grain on the floor, grain on a wall or lid.\nconst E_GG = 0.85, E_FL = 0.7, E_WL = 0.9;\n// Substep and a speed cap, so no grain moves more than 0.86 LED a substep.\nconst SUB = 1 / 650, VMAX = 560;\n// The window in every inner wall, from its sill to its lintel.\nconst ZW0 = 50, ZW1 = 90;\n// A bounce off the rough floor turns up to 30% of its speed sideways.\nconst ROUGH = 0.3;\n// The Shaking knob's range and the shaking of a reset, all floor speeds.\nconst U_LO = 130, U_HI = 260, U_RESET = 300;\n// The reset, in seconds: the walls slide up, stay up, slide down, and the\n// shaking eases back to the knob.\nconst LIFT = 0.6, OPEN = 2.4, EASE = 1.5;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel that skips orange through lime, which\n// reads brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    nb: 0, phase: 1, pt: 0, run: 0, held: 0, hue: 0, shake: 0, zb: 0,\n    x: new Float32Array(N), z: new Float32Array(N), vx: new Float32Array(N), vz: new Float32Array(N),\n    ox: new Float32Array(N), oz: new Float32Array(N),\n    head: new Int32Array(W * (ZTOP + 2)), next: new Int32Array(N),\n    count: new Int32Array(5), nsm: new Float32Array(5), temp: new Float32Array(5),\n    cross: new Float32Array(4), flux: new Float32Array(4),\n    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// A fresh start: the grains dealt out evenly, nb of them to a round, at\n// random spots in the lower half of their boxes.\nfunction start(S, nb) {\n  S.nb = nb;\n  S.walls = [];\n  for (let k = 1; k \u003c nb; k++) S.walls.push((W * k) / nb);\n  for (let i = 0; i \u003c N; i++) {\n    const b = i % nb, x0 = (W * b) / nb + (b ? 1 : RAD), x1 = (W * (b + 1)) / nb - (b \u003c nb - 1 ? 1 : RAD);\n    S.x[i] = x0 + Math.random() * (x1 - x0);\n    S.z[i] = RAD + Math.random() * 60;\n    S.vx[i] = (Math.random() - 0.5) * 60;\n    S.vz[i] = (Math.random() - 0.5) * 60;\n  }\n  S.temp.fill(8000);\n  S.nsm.fill(N / nb);\n  S.flux.fill(0);\n  S.phase = 1;\n  S.run = 0;\n  S.held = 0;\n  S.zb = 0;\n}\n\nconst boxOf = (S, x) => min(S.nb - 1, floor((x * S.nb) / W));\n\n// One substep. The floor is a sawtooth driver in the limit of a small\n// stroke: it stays at z = 0 and always meets a grain moving up at U, so a\n// grain falling at v leaves at U + E_FL (U + v). Grains collide as hard\n// disks one LED across with restitution E_GG, found through a grid of\n// one-LED cells; overlaps are pushed apart along the line of centres.\nfunction step(S, h, U) {\n  const { x, z, vx, vz, head, next, walls } = S, zb = S.zb;\n  for (let i = 0; i \u003c N; i++) {\n    const px = x[i], pz = z[i];\n    vz[i] -= GRAV * h;\n    let sp = vx[i] * vx[i] + vz[i] * vz[i];\n    if (sp > VMAX * VMAX) {\n      sp = VMAX / sqrt(sp);\n      vx[i] *= sp;\n      vz[i] *= sp;\n    }\n    x[i] += vx[i] * h;\n    z[i] += vz[i] * h;\n    if (z[i] \u003c RAD) {\n      z[i] = RAD;\n      const s = U - vz[i];\n      if (s > 0) {\n        vz[i] = U + E_FL * s;\n        vx[i] += (Math.random() - 0.5) * 2 * ROUGH * s;\n      }\n    } else if (z[i] > ZTOP - RAD) {\n      z[i] = ZTOP - RAD;\n      if (vz[i] > 0) vz[i] = -E_WL * vz[i];\n    }\n    if (x[i] \u003c RAD) (x[i] = RAD), (vx[i] = abs(vx[i]) * E_WL);\n    else if (x[i] > W - RAD) (x[i] = W - RAD), (vx[i] = -abs(vx[i]) * E_WL);\n    // The inner walls, slabs one LED thick standing above zb (0 unless a\n    // reset has lifted them). A grain may overlap a slab only below its\n    // bottom edge or inside its window, its whole body between sill and\n    // lintel.\n    for (let k = 0; k \u003c walls.length; k++) {\n      const xk = walls[k];\n      if (abs(x[i] - xk) >= RAD + 0.5) continue;\n      const open = (zi) => zi + RAD \u003c= zb || (zi - RAD >= ZW0 && zi + RAD \u003c= ZW1);\n      if (open(z[i])) {\n        if (zb === 0 && (px - xk) * (x[i] - xk) \u003c 0) S.cross[k] += 1;\n        break;\n      }\n      if (zb === 0 && abs(px - xk) \u003c RAD + 0.5 && open(pz)) {\n        // Inside the window's tunnel: it hit the sill or the lintel.\n        if (z[i] \u003c ZW0 + RAD) (z[i] = ZW0 + RAD), (vz[i] = abs(vz[i]) * E_WL);\n        else (z[i] = ZW1 - RAD), (vz[i] = -abs(vz[i]) * E_WL);\n      } else {\n        const side = px !== xk ? (px \u003c xk ? -1 : 1) : x[i] \u003c xk ? -1 : 1;\n        x[i] = xk + side * (RAD + 0.5);\n        if (vx[i] * side \u003c 0) vx[i] = -vx[i] * E_WL;\n      }\n      break;\n    }\n  }\n  head.fill(-1);\n  for (let i = 0; i \u003c N; i++) {\n    const c = cl(floor(z[i]), 0, ZTOP + 1) * W + cl(floor(x[i]), 0, W - 1);\n    next[i] = head[c];\n    head[c] = i;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const cx = floor(x[i]), cz = floor(z[i]);\n    for (let gz = max(0, cz - 1); gz \u003c= min(ZTOP + 1, cz + 1); gz++)\n      for (let gx = max(0, cx - 1); gx \u003c= min(W - 1, cx + 1); gx++)\n        for (let j = head[gz * W + gx]; j >= 0; j = next[j]) {\n          if (j \u003c= i) continue;\n          const dx = x[j] - x[i], dz = z[j] - z[i], d2 = dx * dx + dz * dz;\n          if (d2 >= DIA * DIA || d2 \u003c 1e-9) continue;\n          const d = sqrt(d2), nx = dx / d, nz = dz / d;\n          const vn = (vx[j] - vx[i]) * nx + (vz[j] - vz[i]) * nz;\n          if (vn \u003c 0) {\n            const J = (-(1 + E_GG) * vn) / 2;\n            vx[i] -= J * nx;\n            vz[i] -= J * nz;\n            vx[j] += J * nx;\n            vz[j] += J * nz;\n          }\n          const o = (DIA - d) / 2;\n          x[i] -= o * nx;\n          z[i] -= o * nz;\n          x[j] += o * nx;\n          z[j] += o * nz;\n        }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, U_LO, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), knobU = cl(kv[2], U_LO, U_HI), nb = round(cl(kv[3], 2, 5));\n  if (nb !== S.nb) start(S, nb);\n  const g = (d * speed) / 2;\n  // Phase 1 runs at the knob's shaking. Phase 0 is the reset: the walls\n  // slide up and the floor shakes at U_RESET, which spreads a heap that\n  // stronger shaking alone cannot lift over a window 50 LEDs up; then the\n  // walls slide back down and the shaking eases to the knob.\n  let level = 0;\n  if (S.phase === 0) {\n    S.pt += g;\n    const t = S.pt, up = LIFT + OPEN;\n    S.zb = t \u003c LIFT ? (ZTOP + 1) * (t / LIFT) : t \u003c up ? ZTOP + 1 : t \u003c up + LIFT ? (ZTOP + 1) * (1 - (t - up) / LIFT) : 0;\n    level = t \u003c up + LIFT ? 1 : max(0, 1 - (t - up - LIFT) / EASE);\n    if (t >= up + LIFT + EASE) (S.phase = 1), (S.run = 0), (S.held = 0), (S.zb = 0);\n  } else S.run += g;\n  S.shake = knobU + (U_RESET - knobU) * level;\n  S.ox.set(S.x);\n  S.oz.set(S.z);\n  const n = max(1, ceil(g / SUB - 1e-6));\n  for (let k = 0; k \u003c n; k++) step(S, g / n, S.shake);\n  const cnt = S.count;\n  cnt.fill(0);\n  const tsum = [0, 0, 0, 0, 0];\n  for (let i = 0; i \u003c N; i++) {\n    const b = boxOf(S, S.x[i]);\n    cnt[b]++;\n    tsum[b] += (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]) / 2;\n  }\n  // Each box's granular temperature, the mean kinetic energy a grain,\n  // smoothed over 0.6 s; an empty box keeps the last value it had.\n  const a = 1 - exp(-g / 0.6);\n  for (let b = 0; b \u003c S.nb; b++) {\n    if (cnt[b]) S.temp[b] += a * (tsum[b] / cnt[b] - S.temp[b]);\n    S.nsm[b] += a * (cnt[b] - S.nsm[b]);\n  }\n  // Crossings through each window a second, smoothed over 0.4 s.\n  const af = 1 - exp(-g / 0.4);\n  let moved = 0;\n  for (let k = 0; k \u003c S.nb - 1; k++) {\n    S.flux[k] += af * (S.cross[k] / max(1e-6, g) - S.flux[k]);\n    S.cross[k] = 0;\n    moved += S.flux[k];\n  }\n  // A run ends once one box has held 85% of the grains, or the windows\n  // have stayed quiet, for 8 s, or after 45 s.\n  if (S.phase === 1) {\n    let top = 0;\n    for (let b = 0; b \u003c S.nb; b++) top = max(top, cnt[b]);\n    S.held = top >= 0.85 * N || moved \u003c 0.3 ? S.held + g : 0;\n    if (S.held > 8 || S.run > 45) (S.phase = 0), (S.pt = 0);\n  }\n}\n\n// Colours: a cold box or grain is azure at knob 0 and a hot one pink, on\n// log T from 3,000 to 40,000 (LEDs per second, squared). The scale runs\n// SPAN round the knob's wheel from the cold hue, back the other way when\n// it would run past the wheel's end, so it never jumps across the gap.\nconst P_COLD = 0.43, SPAN = 0.43;\nconst heatOf = (T) => cl(log(max(1, T) / 3000) / log(40000 / 3000), 0, 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.nb) return;\n  const rgb = S.rgb, c = S.c, hue = S.hue;\n  const pc = P_COLD + hue - floor(P_COLD + hue), span = pc + SPAN \u003c 1 ? SPAN : -SPAN;\n  const tint = (heat) => wheel(pc + span * heat);\n  rgb.fill(0);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += col[0] * a;\n    rgb[o + 1] += col[1] * a;\n    rgb[o + 2] += col[2] * a;\n  };\n  // Each box glows in the colour of its temperature T, fading upward as\n  // the square root of the barometric profile exp(-g z / T): two scale\n  // heights T / g to fall by 1/e, short over a cold heap, the whole box\n  // over a hot gas. A box with no grains has no gas, and its glow fades\n  // below two grains.\n  for (let b = 0; b \u003c S.nb; b++) {\n    const T = max(50, S.temp[b]);\n    hsv(tint(heatOf(T)), 0.85, 1, c);\n    const amp = 0.42 * min(1, S.nsm[b] / 2);\n    const x0 = b ? floor((W * b) / S.nb) + 1 : 0, x1 = b \u003c S.nb - 1 ? floor((W * (b + 1)) / S.nb) : W;\n    for (let y = 0; y \u003c ZTOP; y++) {\n      const v = amp * exp((-GRAV * (ZTOP - y - 0.5)) / (2 * T));\n      for (let x = x0; x \u003c x1; x++) add(x, y, c, v);\n    }\n  }\n  // The walls above their bottom edge, and the sill and lintel of each\n  // window, which flare with the grains passing through it.\n  const wall = [0.55, 0.6, 0.75], lip = [1, 1, 1];\n  const rs = floor(ZTOP - ZW0), rl = floor(ZTOP - ZW1) - 1, yb = ZTOP - S.zb;\n  S.walls.forEach((xk, k) => {\n    const col = floor(xk);\n    for (let y = 0; y \u003c yb; y++) if (y \u003c= rl || y >= rs) add(col, y, wall, 0.4);\n    if (rs \u003c yb) {\n      const f = 0.25 + 0.6 * min(1, S.flux[k] / 30);\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        add(col + dx, rs, lip, dx ? f * 0.6 : f);\n        add(col + dx, rl, lip, dx ? f * 0.6 : f);\n      }\n    }\n  });\n  // The floor, brighter the harder it shakes.\n  const fl = [0.85, 0.85, 0.95];\n  for (let y = ZTOP; y \u003c H; y++) for (let x = 0; x \u003c W; x++) add(x, y, fl, 0.2 + 0.4 * min(1, S.shake / U_HI));\n  // Grains, coloured by their own kinetic energy on the boxes' scale and\n  // paler the faster, each a streak from where it was a frame ago with a\n  // faint halo round its head, so a crowd of grains reads as a heap.\n  for (let i = 0; i \u003c N; i++) {\n    const ke = (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]) / 2, heat = heatOf(ke);\n    hsv(tint(heat), 0.7 - 0.45 * heat, 0.75 + 0.25 * heat, c);\n    const x1 = S.x[i], z1 = S.z[i], x0 = S.ox[i], z0 = S.oz[i];\n    const m = min(12, ceil(max(abs(x1 - x0), abs(z1 - z0))));\n    for (let e = m - 1; e >= 0; e--) {\n      const f = e / m;\n      add(floor(x0 + (x1 - x0) * f), floor(ZTOP - (z0 + (z1 - z0) * f)), c, 0.1 + 0.3 * f);\n    }\n    const hx = floor(x1), hy = floor(ZTOP - z1);\n    add(hx, hy, c, 0.95);\n    add(hx - 1, hy, c, 0.13);\n    add(hx + 1, hy, c, 0.13);\n    add(hx, hy - 1, c, 0.13);\n    add(hx, hy + 1, c, 0.13);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","hawkes-process":"// ===== Patternflow pattern =====\n// Title:   Hawkes Process\n// Family:  rhythm\n// Idea:    Four streams of a mutually exciting Hawkes process run down the panel as a scrolling time line, each stream's intensity a filled band that jumps wide at every event and relaxes back, each event a pulse joined by a line to the event that begot it, so a burst shows as a tree growing up from one immigrant through its children and grandchildren, now and then into the next stream.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: self-exciting point process (Alan Hawkes, 1971), its cluster representation (Alan Hawkes and David Oakes, 1974), thinning simulation (Yosihiko Ogata, 1981), each event's parent drawn from the parts of the intensity (Jiancang Zhuang, Yosihiko Ogata and David Vere-Jones, 2002), time rescaling of the compensator (Yosihiko Ogata, 1988), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Branching=0.7..0.95, Decay=2..8\n//\n// Knob 1: Hue. Turns the bands and the events round the wheel together. At 0 the bands are teal, the immigrants pale gold and their descendants gold, yellow, lime and green by generation; at 0.25 violet bands with green trees, at 0.5 pink with blue, at 0.75 green with magenta. The bands skip orange, which reads brown when dim.\n// Knob 2: Speed. At 2 the time line moves 16 rows a second, so the panel holds the last 8 seconds of the process, now at the top; at 0.2 it moves 1.6 rows a second and holds 80 seconds, at 3 it moves 24 and holds 5.3.\n// Knob 3: Branching. n, the mean number of children of each event, 0.7 to 0.95. Each stream's mean rate is mu / (1 - n): at 0.7 it is 0.83 events a second, 27 on the panel, a cluster has 3.3 events on average and half the clusters are a lone immigrant; at 0.85 it is 1.7 a second and 6.7 to a cluster; at 0.95 it is 5 a second, 20 to a cluster, one cluster in 14 has 50 or more and every ten minutes or so one of several hundred fills the panel.\n// Knob 4: Decay. beta, how fast an event's push fades, 2 to 8 a second. At 2 the push lasts 0.5 s on average, 8 rows, so a child comes about 8 rows above its parent and the trees stand tall; at 8 it lasts 2 rows, the bands are thin with sharp spikes and a burst lies almost flat across the streams. The push in a middle stream is n x beta x 0.7 a second, 0.98 at the opening, against 0.25 from the immigrants.\n\nconst W = 64, H = 128, LANES = 4, LW = W / LANES, MAXE = 4096;\n// Immigrants per second in each stream, and rows the time line moves per second.\nconst MU = 0.25, V = 16;\n// Where a child lands: its own stream 70% of the time, a neighbour the\n// rest. The matrix is symmetric with rows summing to 1, so every event has\n// Poisson(n) children whatever its stream and each stream's mean rate is\n// mu / (1 - n).\nconst M = [\n  [0.85, 0.15, 0, 0],\n  [0.15, 0.7, 0.15, 0],\n  [0, 0.15, 0.7, 0.15],\n  [0, 0, 0.15, 0.85],\n];\nconst { floor, min, max, abs, exp, log } = Math;\n// The bands skip orange through lime, which reads brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    n: 0.7, beta: 2, T: 0, s: 0, E: new Float64Array(LANES), id: 0,\n    t: new Float64Array(MAXE), x: new Float32Array(MAXE), lane: new Int8Array(MAXE), par: new Int32Array(MAXE), gen: new Int16Array(MAXE),\n    rgb: new Float32Array(W * H * 3), lam: new Float32Array(H * LANES), hue: 0, c: [0, 0, 0],\n  };\n}\n\n// The excitation of each stream at time s from every event kept, used\n// when the knobs change n or beta.\nfunction recompute(S) {\n  S.E.fill(0);\n  const a = S.n * S.beta;\n  for (let id = max(0, S.id - MAXE); id \u003c S.id; id++) {\n    const i = id % MAXE, e = a * exp(-S.beta * (S.s - S.t[i]));\n    for (let k = 0; k \u003c LANES; k++) S.E[k] += e * M[S.lane[i]][k];\n  }\n}\n\nfunction decayTo(S, s) {\n  const f = exp(-S.beta * (s - S.s));\n  for (let k = 0; k \u003c LANES; k++) S.E[k] *= f;\n  S.s = s;\n}\n\n// An event in stream k at time S.s. Its parent is drawn the way the\n// intensity is made up: an immigrant with chance mu / lambda_k, else the\n// child of event i with chance a M[lane_i][k] e^(-beta (s - t_i)) /\n// lambda_k. That is the cluster process of Hawkes and Oakes read\n// backwards, and it gives the trees their true law.\nfunction addEvent(S, k) {\n  const lam = MU + S.E[k], a = S.n * S.beta;\n  let u = Math.random() * lam, par = -1;\n  if (u >= MU) {\n    u -= MU;\n    for (let id = S.id - 1; id >= max(0, S.id - MAXE); id--) {\n      const i = id % MAXE, c = a * M[S.lane[i]][k] * exp(-S.beta * (S.s - S.t[i]));\n      par = id;\n      u -= c;\n      if (u \u003c 0) break;\n    }\n  }\n  const i = S.id % MAXE;\n  S.t[i] = S.s;\n  S.lane[i] = k;\n  S.par[i] = par;\n  S.gen[i] = par >= 0 && par > S.id - MAXE ? S.gen[par % MAXE] + 1 : 0;\n  // Across its stream: near the parent if the parent shares the stream,\n  // anywhere in it otherwise.\n  const c = k * LW + LW / 2;\n  let x = c + (Math.random() - 0.5) * (LW - 5);\n  if (S.gen[i] > 0 && S.lane[par % MAXE] === k) x = cl(S.x[par % MAXE] + (Math.random() - 0.5) * 5, c - LW / 2 + 2.5, c + LW / 2 - 2.5);\n  S.x[i] = x;\n  S.id++;\n  for (let j = 0; j \u003c LANES; j++) S.E[j] += a * M[k][j];\n}\n\n// Ogata's thinning: between events every intensity only decays, so the\n// total intensity now bounds it until the next event. Draw a gap from that\n// bound, then keep the point with chance lambda(s) / bound.\nfunction simulate(S, T, most) {\n  for (let guard = 0; guard \u003c most; guard++) {\n    let bound = 0;\n    for (let k = 0; k \u003c LANES; k++) bound += MU + S.E[k];\n    const w = -log(1 - Math.random()) / bound;\n    if (S.s + w > T) {\n      decayTo(S, T);\n      return;\n    }\n    decayTo(S, S.s + w);\n    let lam = 0;\n    for (let k = 0; k \u003c LANES; k++) lam += MU + S.E[k];\n    if (Math.random() * bound > lam) continue;\n    let u = Math.random() * lam, k = 0;\n    for (; k \u003c LANES - 1; k++) if ((u -= MU + S.E[k]) \u003c 0) break;\n    addEvent(S, k);\n  }\n  decayTo(S, T);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.7, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), n = cl(kv[2], 0.7, 0.95), beta = cl(kv[3], 2, 8);\n  if (abs(n - S.n) > 1e-6 || abs(beta - S.beta) > 1e-6) {\n    S.n = n;\n    S.beta = beta;\n    recompute(S);\n  }\n  // The first frame runs 30 seconds of the process at once, so the time\n  // line opens full.\n  S.T += S.T ? (d * speed) / 2 : 30;\n  simulate(S, S.T, S.id ? 2000 : 40000);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, lam = S.lam, T = S.T, a = S.n * S.beta, b = S.beta;\n  rgb.fill(0);\n  // Row r is time T - r / V. The intensity of each stream at every row,\n  // from the bottom row up, decaying and adding the events as it passes them.\n  const t0 = T - (H - 0.5) / V, E = [0, 0, 0, 0];\n  let id = max(0, S.id - MAXE);\n  for (; id \u003c S.id && S.t[id % MAXE] \u003c= t0; id++) {\n    const i = id % MAXE, e = a * exp(-b * (t0 - S.t[i]));\n    for (let k = 0; k \u003c LANES; k++) E[k] += e * M[S.lane[i]][k];\n  }\n  const first = id;\n  let tp = t0;\n  for (let r = H - 1; r >= 0; r--) {\n    const tr = T - (r + 0.5) / V, f = exp(-b * (tr - tp));\n    for (let k = 0; k \u003c LANES; k++) E[k] *= f;\n    for (; id \u003c S.id && S.t[id % MAXE] \u003c= tr; id++) {\n      const i = id % MAXE, e = a * exp(-b * (tr - S.t[i]));\n      for (let k = 0; k \u003c LANES; k++) E[k] += e * M[S.lane[i]][k];\n    }\n    for (let k = 0; k \u003c LANES; k++) lam[r * LANES + k] = MU + E[k];\n    tp = tr;\n  }\n  // The bands: half-width 7.4 (1 - e^(-lambda / 0.8 beta)) LEDs, which\n  // saturates at the edge of the stream. At the opening knobs the\n  // immigrants alone keep it 2 LEDs wide and one event in a middle stream\n  // widens it to 8.\n  const band = hsv(wheel(0.36 + S.hue), 0.7, 1, S.c);\n  const add = (x, y, c, v) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || v \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += c[0] * v;\n    rgb[o + 1] += c[1] * v;\n    rgb[o + 2] += c[2] * v;\n  };\n  for (let r = 0; r \u003c H; r++)\n    for (let k = 0; k \u003c LANES; k++) {\n      // lam now holds the half-width, for the strokes below.\n      const w = (lam[r * LANES + k] = (LW / 2 - 0.6) * (1 - exp(-lam[r * LANES + k] / (0.8 * b)))), c = k * LW + LW / 2;\n      for (let x = k * LW; x \u003c (k + 1) * LW; x++) {\n        const dd = abs(x + 0.5 - c), cov = cl(w - dd + 0.5, 0, 1);\n        if (cov \u003c= 0) continue;\n        const q = dd / max(0.5, w), g = w / (LW / 2);\n        add(x, r, band, cov * (0.07 + 0.22 * g + 0.3 * q * q * q * q));\n      }\n    }\n  // Each event is a jump in its stream's intensity: a bright stroke across\n  // the band on the row where it happened.\n  for (let j = first; j \u003c S.id; j++) {\n    const i = j % MAXE, y = floor((T - S.t[i]) * V), k = S.lane[i], c = k * LW + LW / 2;\n    if (y \u003c 0 || y >= H) continue;\n    const w = lam[min(H - 1, y + 1) * LANES + k] * 0.5 + lam[y * LANES + k] * 0.5;\n    for (let x = k * LW; x \u003c (k + 1) * LW; x++) add(x, y, band, 0.35 * cl(w - abs(x + 0.5 - c) + 0.5, 0, 1));\n  }\n  // Parent to child, a line from row to row.\n  const col = [0, 0, 0];\n  for (let j = first; j \u003c S.id; j++) {\n    const i = j % MAXE, p = S.par[i];\n    if (p \u003c 0 || p \u003c= S.id - MAXE) continue;\n    const q = p % MAXE, y1 = (T - S.t[i]) * V, y0 = (T - S.t[q]) * V, x1 = S.x[i], x0 = S.x[q];\n    const steps = max(1, Math.ceil(max(abs(y1 - y0), abs(x1 - x0))));\n    hsv(0.08 + S.hue + 0.07 * S.gen[i], 0.6, 1, col);\n    for (let s = 0; s \u003c= steps; s++) {\n      const f = s / steps, x = x0 + (x1 - x0) * f - 0.5, y = floor(y0 + (y1 - y0) * f), xi = floor(x), fx = x - xi;\n      add(xi, y, col, 0.45 * (1 - fx));\n      add(xi + 1, y, col, 0.45 * fx);\n    }\n  }\n  // The events: pulses that flash as they happen.\n  for (let j = first; j \u003c S.id; j++) {\n    const i = j % MAXE, y = (T - S.t[i]) * V, x = S.x[i], age = T - S.t[i];\n    hsv(0.08 + S.hue + 0.07 * S.gen[i], S.gen[i] ? 0.55 : 0.2, 1, col);\n    const rad = (S.gen[i] ? 1.3 : 1.9) + 1.5 * exp(-age * 4), pk = 0.9 + exp(-age * 4);\n    for (let yy = floor(y - rad); yy \u003c= y + rad; yy++)\n      for (let xx = floor(x - rad); xx \u003c= x + rad; xx++) {\n        const dx = xx + 0.5 - x, dy = yy + 0.5 - y, d2 = (dx * dx + dy * dy) / (rad * rad);\n        if (d2 \u003c 1) add(xx, yy, col, pk * (1 - d2));\n      }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);\n}\n","kohonen-map":"// ===== Patternflow pattern =====\n// Title:   Kohonen Map\n// Family:  data\n// Idea:    A lattice of 288 nodes thrown as a random tangle over a shape of faint dots, an annulus, two crescents or a tall S, learns the shape by Kohonen's rule, each dot pulling its nearest node and that node's lattice neighbours toward it, so the tangle draws together, unfolds into a woven cloth coloured by lattice place and spreads over the shape as the neighbourhood shrinks, or as a chain folds into a Peano-like curve; it holds, fades, and the next shape starts.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the self-organizing map (Teuvo Kohonen, 1982), its topographic error (Kimmo Kiviluoto, 1996), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lattice=0..1, Radius=0.5..3\n//\n// Knob 1: Hue. Turns the cloth's colours round the wheel together. A node's hue is set by its place along the lattice's long side and its whiteness by its place across the short side: at 0 the long side runs azure, blue, violet, magenta; at 0.25 violet to teal; at 0.5 rose to blue. The scale runs the other way round when it would cross the orange to lime gap, which reads brown when dim.\n// Knob 2: Speed. 2 anneals in 14 seconds on 9,000 samples a second, about 440 a node: the neighbourhood radius falls from a quarter of the lattice's long side (6 nodes for the sheet, 72 for the chain) to the Radius knob and the learning rate from 0.5 to 0.02, both exponentially, and the first 2.5 seconds learn up to 3,000 times slower so the tangle is seen drawing together. The map then holds 5 seconds, still learning at the last rate, and fades in 0.6. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Lattice. The 288 nodes as a 12 x 24 sheet at 0, then 8 x 36, 6 x 48, 4 x 72, 3 x 96 and 2 x 144, and a chain of 288 at 1; a new lattice starts the shape again from a tangle. A sheet is drawn as a cloth, its cells fainter where stretched and darker where turned over; a ribbon follows the S and the crescents and leaves the annulus open as a C; the chain is a curve through its nodes in order, and at the opening Radius it folds back and forth until it is 828 LEDs long on the annulus, 0.76 of sqrt(288 x area), the length of a path through 288 even cells.\n// Knob 4: Radius. The neighbourhood radius the anneal ends at, 0.5 to 3 lattice steps. At 0.5 the sheet reaches the shape's edges: on the annulus after the hold a dot lies 1.52 LEDs from its nearest node on average (the quantization error; 288 even square cells would give 1.44), and 16% of dots have their two nearest nodes not side by side on the lattice (Kiviluoto's topographic error), nearly all of them diagonal neighbours. At 3 the sheet stays smooth and shrinks inside the shape: quantization error 3.62, topographic error 9.8%.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, exp, cos, sin, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Kohonen's map: a lattice of nodes, each with a weight, here a point of\n// the panel. For every sample x the best-matching node c (the nearest\n// weight) and its lattice neighbours k move toward x:\n//   w_k += alpha h(|k - c|) (x - w_k),  h(d) = exp(-d^2 / (2 sigma^2)),\n// with d measured on the lattice, not on the panel. While sigma spans the\n// lattice every node moves almost alike and the map orders itself; as\n// sigma shrinks the nodes spread out over the data, and nodes that are\n// neighbours on the lattice mostly stay neighbours on the panel.\n\n// Lattices of 288 nodes, from the sheet to the chain.\nconst DIMS = [[12, 24], [8, 36], [6, 48], [4, 72], [3, 96], [2, 144], [1, 288]];\nconst NODES = 288;\n// The anneal, in seconds at Speed 2: the neighbourhood radius falls from a\n// quarter of the lattice's long side to the Radius knob, the learning rate\n// from A0 to A1, both exponentially; then the map holds, fades and a new\n// shape starts.\nconst ANNEAL = 14, HOLD = 5, FADE = 0.6, A0 = 0.5, A1 = 0.02, RAMP = 2.5;\n// Samples a second of simulated time.\nconst RATE = 9000;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\n// The data: three shapes in panel coordinates, each a sampler that draws\n// points about evenly over its area.\nconst SHAPES = [\n  // An elliptical annulus, outer semi-axes 30 x 60, inner 15 x 34.\n  (out) => {\n    for (;;) {\n      const x = 2 + Math.random() * 60, y = 4 + Math.random() * 120;\n      const u = (x - 32) / 30, v = (y - 64) / 60, a = (x - 32) / 15, b = (y - 64) / 34;\n      if (u * u + v * v \u003c= 1 && a * a + b * b >= 1) return (out[0] = x), (out[1] = y), out;\n    }\n  },\n  // Two crescents, the two moons turned upright: half rings of radius 1\n  // and width 0.5, the second turned half a turn and shifted by (0.5, 1),\n  // drawn 30 LEDs to the unit across and 33 down.\n  (out) => {\n    const th = Math.random() * PI, r = sqrt(0.5625 + Math.random() * (1.5625 - 0.5625));\n    let X, Y;\n    if (Math.random() \u003c 0.5) (X = r * sin(th)), (Y = r * cos(th));\n    else (X = 0.5 - r * sin(th)), (Y = 1 - r * cos(th));\n    out[0] = 32 + 30 * (X - 0.25);\n    out[1] = 64 + 33 * (Y - 0.5);\n    return out;\n  },\n  // A tall S: two elliptical arcs of 250 degrees, 12 LEDs thick, the lower\n  // the upper turned half a turn. The offset across the arc is drawn with\n  // weight r + t, as an even spread over a ring of mean radius 26 would be.\n  (out) => {\n    const s = Math.random() \u003c 0.5 ? 1 : -1, ph = (20 + Math.random() * 250) * (PI / 180);\n    const t = sqrt(400 + Math.random() * (1024 - 400)) - 26;\n    out[0] = 32 + s * (24 + t) * cos(ph);\n    out[1] = 62 - s * (28 + (28 + t) * sin(ph));\n    return out;\n  },\n];\n\nexport function setup(params) {\n  params.s = {\n    dim: -1, shape: 0, phase: 0, pt: 0, hue: 0, sigma: 1,\n    wx: new Float32Array(NODES), wy: new Float32Array(NODES),\n    hx: new Float32Array(NODES + 1), samp: new Float32Array(240), ns: 0,\n    rgb: new Float32Array(W * H * 3), col: new Float32Array(NODES * 3), c: [0, 0, 0], p: [0, 0],\n  };\n}\n\nfunction start(S, dim, next) {\n  if (next) S.shape = (S.shape + 1) % SHAPES.length;\n  S.dim = dim;\n  [S.cols, S.rows] = DIMS[dim];\n  // The random tangle: every node at a random spot of the panel.\n  for (let k = 0; k \u003c NODES; k++) {\n    S.wx[k] = 2 + Math.random() * 60;\n    S.wy[k] = 4 + Math.random() * 120;\n  }\n  S.phase = 0;\n  S.pt = 0;\n}\n\n// One step of Kohonen's rule: the node nearest the sample wins, and it and\n// its lattice neighbours move toward the sample by alpha times a Gaussian\n// of their lattice distance from the winner.\nfunction learn(S, x, y, alpha, sigma, R) {\n  const { wx, wy, cols, rows, hx } = S;\n  let best = 0, bd = Infinity;\n  for (let k = 0; k \u003c NODES; k++) {\n    const dx = wx[k] - x, dy = wy[k] - y, d = dx * dx + dy * dy;\n    if (d \u003c bd) (bd = d), (best = k);\n  }\n  const bi = best % cols, bj = (best / cols) | 0;\n  for (let j = max(0, bj - R); j \u003c= min(rows - 1, bj + R); j++) {\n    const hj = hx[abs(j - bj)];\n    for (let i = max(0, bi - R); i \u003c= min(cols - 1, bi + R); i++) {\n      const k = j * cols + i, a = alpha * hj * hx[abs(i - bi)];\n      wx[k] += a * (x - wx[k]);\n      wy[k] += a * (y - wy[k]);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.5], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), dim = round(cl(kv[2], 0, 1) * (DIMS.length - 1)), rad = cl(kv[3], 0.5, 3);\n  if (dim !== S.dim) start(S, dim, false);\n  const g = (d * speed) / 2;\n  S.pt += g;\n  if (S.phase === 0 && S.pt >= ANNEAL) (S.phase = 1), (S.pt = 0);\n  else if (S.phase === 1 && S.pt >= HOLD) (S.phase = 2), (S.pt = 0);\n  else if (S.phase === 2 && S.pt >= FADE) return start(S, dim, true);\n  const f = S.phase === 0 ? S.pt / ANNEAL : 1;\n  // The first RAMP seconds learn slowly, the rate rising 3,000-fold, so\n  // the tangle is seen drawing itself together before the map orders.\n  const ramp = S.phase === 0 && S.pt \u003c RAMP ? 10 ** (-3.5 * (1 - S.pt / RAMP)) : 1;\n  const s0 = max(S.cols, S.rows) / 4, sigma = s0 * (rad / s0) ** f, alpha = A0 * (A1 / A0) ** f * ramp;\n  const R = min(max(S.cols, S.rows), ceil(3 * sigma));\n  for (let k = 0; k \u003c= R; k++) S.hx[k] = exp((-k * k) / (2 * sigma * sigma));\n  S.sigma = sigma;\n  const n = round(g * RATE), p = S.p, keep = S.samp.length / 2;\n  S.ns = 0;\n  for (let k = 0; k \u003c n; k++) {\n    SHAPES[S.shape](p);\n    learn(S, p[0], p[1], alpha, sigma, R);\n    if (S.ns \u003c keep) (S.samp[2 * S.ns] = p[0]), (S.samp[2 * S.ns + 1] = p[1]), S.ns++;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.dim \u003c 0) return;\n  const rgb = S.rgb, col = S.col, { cols, rows, wx, wy } = S;\n  rgb.fill(0);\n  const fade = S.phase === 2 ? 1 - S.pt / FADE : S.phase === 0 ? min(1, S.pt / 0.3) : 1;\n  // Node colours from lattice coordinates: hue along the long side,\n  // whiteness across the short one.\n  const pc = 0.4 + S.hue - floor(0.4 + S.hue), span = pc + 0.4 \u003c= 1 ? 0.4 : -0.4, c = S.c;\n  for (let j = 0, k = 0; j \u003c rows; j++)\n    for (let i = 0; i \u003c cols; i++, k++) {\n      const u = cols > 1 ? i / (cols - 1) : 0.5, v = rows > 1 ? j / (rows - 1) : 0;\n      hsv(wheel(pc + span * v), 0.95 - 0.55 * u, 1, c);\n      col[3 * k] = c[0];\n      col[3 * k + 1] = c[1];\n      col[3 * k + 2] = c[2];\n    }\n  const add = (x, y, r, g, b, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += r * a;\n    rgb[o + 1] += g * a;\n    rgb[o + 2] += b * a;\n  };\n  const top = (x, y, r, g, b, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], r * a);\n    rgb[o + 1] = max(rgb[o + 1], g * a);\n    rgb[o + 2] = max(rgb[o + 2], b * a);\n  };\n  if (cols > 1) {\n    // The cloth: each lattice cell a quad of two triangles, colours mixed\n    // across it, fainter the more it is stretched past the area a cell\n    // would have if the nodes shared the shape evenly. A cell turned over,\n    // its corners in the other order round from most cells', shows its\n    // back, darker.\n    const A0c = 3600 / ((cols - 1) * (rows - 1));\n    let turn = 0;\n    for (let j = 0; j \u003c rows - 1; j++)\n      for (let i = 0; i \u003c cols - 1; i++) {\n        const a = j * cols + i;\n        turn += (wx[a + 1] - wx[a]) * (wy[a + cols] - wy[a]) - (wy[a + 1] - wy[a]) * (wx[a + cols] - wx[a]) > 0 ? 1 : -1;\n      }\n    for (let j = 0; j \u003c rows - 1; j++)\n      for (let i = 0; i \u003c cols - 1; i++) {\n        const a = j * cols + i, b = a + 1, cc = a + cols + 1, dd = a + cols;\n        const cr = (wx[b] - wx[a]) * (wy[dd] - wy[a]) - (wy[b] - wy[a]) * (wx[dd] - wx[a]);\n        const alpha = (cr * turn >= 0 ? 0.5 : 0.22) * cl(A0c / max(1e-3, abs(cr)), 0.1, 1);\n        tri(rgb, wx, wy, col, a, b, cc, alpha);\n        tri(rgb, wx, wy, col, a, cc, dd, alpha);\n      }\n  }\n  // The lattice's threads: a line from each node to its right and lower\n  // neighbours, so a sheet reads as woven and a chain as a curve.\n  const seg = (k0, k1, a) => {\n    const x0 = wx[k0], y0 = wy[k0], x1 = wx[k1], y1 = wy[k1], o0 = 3 * k0, o1 = 3 * k1;\n    const m = max(1, ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5));\n    for (let e = 0; e \u003c m; e++) {\n      const t = e / m;\n      top(floor(x0 + (x1 - x0) * t), floor(y0 + (y1 - y0) * t), col[o0] + (col[o1] - col[o0]) * t, col[o0 + 1] + (col[o1 + 1] - col[o0 + 1]) * t, col[o0 + 2] + (col[o1 + 2] - col[o0 + 2]) * t, a);\n    }\n  };\n  const thread = cols > 1 ? 0.85 : 0.95;\n  for (let j = 0; j \u003c rows; j++)\n    for (let i = 0; i \u003c cols; i++) {\n      const k = j * cols + i;\n      if (i + 1 \u003c cols) seg(k, k + 1, thread);\n      if (j + 1 \u003c rows) seg(k, k + cols, thread);\n    }\n  // The data, the samples of this frame, faint.\n  for (let k = 0; k \u003c S.ns; k++) add(floor(S.samp[2 * k]), floor(S.samp[2 * k + 1]), 1, 1, 1, 0.22);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 1] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 2] * fade, 0, 1)) | 0);\n}\n\n// A triangle of three nodes, its colour mixed by barycentric weights at\n// each LED centre inside it. Overlapping cells keep the brighter, so a\n// crumpled map does not burn white.\nfunction tri(rgb, wx, wy, col, a, b, c, alpha) {\n  const ax = wx[a], ay = wy[a], bx = wx[b], by = wy[b], cx = wx[c], cy = wy[c];\n  const det = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(det) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, ceil(max(ay, by, cy)));\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const l1 = ((px - ax) * (cy - ay) - (py - ay) * (cx - ax)) / det;\n      const l2 = ((bx - ax) * (py - ay) - (by - ay) * (px - ax)) / det;\n      const l0 = 1 - l1 - l2;\n      if (l0 \u003c 0 || l1 \u003c 0 || l2 \u003c 0) continue;\n      const o = (y * W + x) * 3;\n      rgb[o] = max(rgb[o], (l0 * col[3 * a] + l1 * col[3 * b] + l2 * col[3 * c]) * alpha);\n      rgb[o + 1] = max(rgb[o + 1], (l0 * col[3 * a + 1] + l1 * col[3 * b + 1] + l2 * col[3 * c + 1]) * alpha);\n      rgb[o + 2] = max(rgb[o + 2], (l0 * col[3 * a + 2] + l1 * col[3 * b + 2] + l2 * col[3 * c + 2]) * alpha);\n    }\n  }\n}\n","laser-speckle":"// ===== Patternflow pattern =====\n// Title:   Laser Speckle\n// Family:  noise\n// Idea:    Laser light through a diffuser: the panel is the Fourier transform of a small pupil full of random phases, so every LED is the sum of 191 random phasors, lit by the squared length of the sum and coloured by its phase; the grains boil as the diffuser's phases turn, a window at the top shows the pupil changing from disc to ring, pinhole pair, square, slit and triangle while the grains take the shape of its diffraction pattern, and the histogram along the bottom follows the exponential law e^-I.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: laser speckle as a random walk of phasors (Lord Rayleigh, 1880), the statistics of speckle (J. W. Goodman, 1975), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pupil=5..14, Looks=1..8\n//\n// Knob 1: Hue. Adds one phase to the whole field, which turns every grain's hue round the wheel together; the window's tint and the bars turn with it. At 0 the bars are blue and the curve over them cream.\n// Knob 2: Speed. How fast the diffuser turns and the pupil changes shape. Every sample's phase turns at its own rate, normal with a spread of 0.9 radians a second at 2, so the intensity at an LED is correlated exp(-0.81 t^2) with itself t seconds before: half after 0.93 s, 0.15 after 1.5 s; each of the eight pupils holds 9 s, the last 2.5 of them blending into the next. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Pupil. The pupil's radius in samples of the frequency plane, 5 to 14 across and twice that down, since the panel has twice as many rows as columns; the disc holds 191 samples at 5 and 1,321 at 14. A bigger pupil makes finer grains: the intensity's autocorrelation falls to half 3.4 LEDs out at 5, 2.1 at 8 and 1.2 at 14, so a grain is about 66 LEDs over the pupil's diameter in samples, against (2 J1(z) / z)^2 = 1/2 at z = 1.62. The window draws the pupil at one size; its shape, not its size, is what it shows.\n// Knob 4: Looks. How many speckle patterns from independent diffusers are added, 1 to 8. One look has contrast sigma / \u003cI> of 1.00 and the exponential histogram; 2 have 0.70, 4 have 0.49 and 8 have 0.35, as 1 / sqrt(n), and the histogram rises into the gamma law the curve draws. The dark gaps between the grains fill in. Brightness is the mean intensity over 1 + 2 / sqrt(n) times its mean, the same for every LED, so the brightest grains stay full.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, log, cos, sin, atan2, PI, round } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n// The pupil: u runs across the 64 columns' frequencies and v down the 128\n// rows', so a pupil RU samples wide in u and 2 RU tall in v makes round\n// grains. Its largest box, RU_MAX either side.\nconst RU_MAX = 14, SU = 2 * RU_MAX + 1, SV = 4 * RU_MAX + 1, NS = SU * SV;\nconst LOOKS = 8;\n// Brightness is intensity over TONE times the mean, so a third of the mean\n// is the faintest LED that reads, and one LED in twenty is full. With n\n// looks the scale is 1 + (TONE - 1) / sqrt(n), the mean plus about two\n// standard deviations, which keeps the brightest LEDs full; it is the same\n// for every LED, so the contrast is what it is.\nconst TONE = 3, SAT = 0.82;\n// Each pupil shape holds SHAPE_T units and the last MORPH_T of them blend\n// into the next. A unit is a second at Speed 2.\nconst SHAPE_T = 9, MORPH_T = 2.5;\n// The spread of the diffuser's phase rates, radians a unit.\nconst BOIL = 0.9;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The colour of each of 256 phases at full value.\nconst LUT = new Float32Array(256 * 3);\nfor (let i = 0, c = [0, 0, 0]; i \u003c 256; i++) {\n  hsv(i / 256, SAT, 1, c);\n  LUT.set(c, i * 3);\n}\n\n// A radix-2 FFT, in place along n entries of re/im spaced by stride.\nfunction tables(n) {\n  const rev = new Uint16Array(n), cs = new Float64Array(n / 2), sn = new Float64Array(n / 2);\n  const bits = round(log(n) / log(2));\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c bits; b++) r |= ((i >> b) & 1) \u003c\u003c (bits - 1 - b);\n    rev[i] = r;\n  }\n  for (let k = 0; k \u003c n / 2; k++) (cs[k] = cos((TAU * k) / n)), (sn[k] = sin((TAU * k) / n));\n  return { n, rev, cs, sn };\n}\nconst TX = tables(W), TY = tables(H);\nfunction fft(re, im, off, stride, T) {\n  const n = T.n, rev = T.rev;\n  for (let i = 0; i \u003c n; i++) {\n    const j = rev[i];\n    if (j > i) {\n      const a = off + i * stride, b = off + j * stride;\n      let t = re[a];\n      re[a] = re[b];\n      re[b] = t;\n      t = im[a];\n      im[a] = im[b];\n      im[b] = t;\n    }\n  }\n  for (let size = 2; size \u003c= n; size \u003c\u003c= 1) {\n    const half = size >> 1, step = n / size;\n    for (let i = 0; i \u003c n; i += size)\n      for (let k = 0; k \u003c half; k++) {\n        const c = T.cs[k * step], s = T.sn[k * step];\n        const a = off + (i + k) * stride, b = a + half * stride;\n        const tr = re[b] * c - im[b] * s, ti = re[b] * s + im[b] * c;\n        re[b] = re[a] - tr;\n        im[b] = im[a] - ti;\n        re[a] += tr;\n        im[a] += ti;\n      }\n  }\n}\n\n// The pupil shapes as signed distances in pupil units (a across, b down,\n// the rim of the disc at 1): negative inside.\nconst len = (a, b) => sqrt(a * a + b * b);\nconst SHAPES = [\n  (a, b) => len(a, b) - 1, // disc\n  (a, b) => max(len(a, b) - 1, 0.6 - len(a, b)), // annulus\n  (a, b) => min(len(a - 0.62, b), len(a + 0.62, b)) - 0.36, // two pinholes side by side\n  (a, b) => max(abs(a), abs(b)) - 0.86, // square\n  (a, b) => max(len(a, b) - 1, 0.84 - len(a, b)), // thin ring\n  (a, b) => max(abs(a) - 0.24, abs(b) - 1), // slit, narrow across\n  (a, b) => len(abs(a) - 0.5, abs(b) - 0.5) - 0.3, // four pinholes\n  (a, b) => max(b - 0.5, max(-0.866 * a - 0.5 * b, 0.866 * a - 0.5 * b) - 0.5), // triangle\n];\nconst NAMES = SHAPES.length;\n\n// One look: a diffuser of its own, each pupil sample with a starting phase\n// and a rate, and the field it makes.\nfunction newLook() {\n  const L = { p0: new Float32Array(NS), w: new Float32Array(NS), I: new Float32Array(N), zr: new Float32Array(N), zi: new Float32Array(N), at: -1 };\n  for (let i = 0; i \u003c NS; i++) {\n    L.p0[i] = Math.random() * TAU;\n    // A normal rate, by Box and Muller.\n    L.w[i] = BOIL * sqrt(-2 * log(1 - Math.random())) * cos(TAU * Math.random());\n  }\n  return L;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    looks: [], re: new Float64Array(N), im: new Float64Array(N), P: new Float32Array(NS), sumP: 1,\n    clock: 0, boil: 0, ru: 5, n: 1, hue: 0, next: 0,\n    Iavg: new Float32Array(N), zr: new Float32Array(N), zi: new Float32Array(N), hist: new Float32Array(16), histOk: false,\n  });\n  for (let k = 0; k \u003c LOOKS; k++) S.looks.push(newLook());\n}\n\n// The pupil's amplitude at every sample of the box, for radius ru and the\n// shape schedule: soft-edged over one sample, so it changes smoothly with\n// the knob and as one shape blends into the next.\nfunction pupil(S) {\n  const ru = S.ru, rv = 2 * ru, i0 = floor(S.clock / SHAPE_T), f = S.clock / SHAPE_T - i0;\n  const A = SHAPES[i0 % NAMES], B = SHAPES[(i0 + 1) % NAMES];\n  const m = smooth((f * SHAPE_T - (SHAPE_T - MORPH_T)) / MORPH_T);\n  let sum = 0;\n  for (let j = 0; j \u003c SV; j++)\n    for (let i = 0; i \u003c SU; i++) {\n      const a = (i - RU_MAX) / ru, b = (j - 2 * RU_MAX) / rv;\n      const pa = cl(0.5 - A(a, b) * ru, 0, 1), pb = m > 0 ? cl(0.5 - B(a, b) * ru, 0, 1) : 0;\n      const p = pa + (pb - pa) * m;\n      S.P[j * SU + i] = p;\n      sum += p * p;\n    }\n  S.sumP = max(sum, 1e-6);\n}\n\n// The field of one look: put P e^{i phi} on the frequency plane, transform\n// the rows that hold any of it, then every column. I is |E|^2 over the sum\n// of P^2, the mean intensity, so I has mean 1 whatever the pupil.\nfunction field(S, L) {\n  const re = S.re, im = S.im, P = S.P, t = S.boil;\n  re.fill(0);\n  im.fill(0);\n  const rv = min(2 * RU_MAX, Math.ceil(2 * S.ru) + 1);\n  for (let j = 0; j \u003c SV; j++) {\n    const v = j - 2 * RU_MAX;\n    if (abs(v) > rv) continue;\n    const row = ((v + H) % H) * W;\n    for (let i = 0; i \u003c SU; i++) {\n      const s = j * SU + i, p = P[s];\n      if (p \u003c= 0) continue;\n      const ph = L.p0[s] + L.w[s] * t, o = row + ((i - RU_MAX + W) % W);\n      re[o] = p * cos(ph);\n      im[o] = p * sin(ph);\n    }\n  }\n  for (let v = -rv; v \u003c= rv; v++) fft(re, im, ((v + H) % H) * W, 1, TX);\n  for (let x = 0; x \u003c W; x++) fft(re, im, x, W, TY);\n  // zr + i zi is |E| E, the field weighted by its own amplitude: summed over\n  // the looks it gives each LED the phase of whichever look is brightest there.\n  const k = 1 / S.sumP, I = L.I;\n  for (let p = 0; p \u003c N; p++) {\n    const q = (re[p] * re[p] + im[p] * im[p]) * k, a = sqrt(q * k);\n    I[p] = q;\n    L.zr[p] = re[p] * a;\n    L.zi[p] = im[p] * a;\n  }\n  L.at = t;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 5, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.ru = cl(kv[2], 5, 14);\n  const n = round(cl(kv[3], 1, LOOKS));\n  const g = (d * speed) / 2;\n  S.clock += g;\n  S.boil += g;\n  pupil(S);\n  // Up to three looks are brought up to date each frame, in turn; a look\n  // newly added is done at once.\n  for (let k = 0; k \u003c n; k++) if (S.looks[k].at \u003c 0 || k >= S.n) field(S, S.looks[k]);\n  S.n = n;\n  for (let c = 0; c \u003c min(n, 3); c++) {\n    S.next = (S.next + 1) % n;\n    field(S, S.looks[S.next]);\n  }\n  // The mean of the looks, its phase, and its histogram, eased over a few frames.\n  const Ia = S.Iavg, Zr = S.zr, Zi = S.zi, hist = S.hist, cnt = new Float32Array(16);\n  Ia.fill(0);\n  Zr.fill(0);\n  Zi.fill(0);\n  for (let k = 0; k \u003c n; k++) {\n    const L = S.looks[k], I = L.I;\n    for (let p = 0; p \u003c N; p++) (Ia[p] += I[p] / n), (Zr[p] += L.zr[p]), (Zi[p] += L.zi[p]);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const b = floor(Ia[p] / BIN);\n    if (b \u003c 16) cnt[b]++;\n  }\n  const ease = S.histOk ? min(1, d * 6) : 1;\n  for (let b = 0; b \u003c 16; b++) hist[b] += (cnt[b] / (N * BIN) - hist[b]) * ease;\n  S.histOk = true;\n}\n\n// The density of the mean of n exponentials with mean 1: a gamma law.\nfunction gammaPdf(x, n) {\n  let lf = 0;\n  for (let k = 2; k \u003c n; k++) lf += log(k);\n  return x \u003c= 0 ? (n === 1 ? 1 : 0) : exp(n * log(n) + (n - 1) * log(x) - n * x - lf);\n}\n\n// The window at the top: the pupil drawn at a fixed size, its rim at\n// PR LEDs, over a dark disc of radius WR. The histogram along the bottom:\n// 16 bins of the mean intensity, BIN times the mean wide, HB rows tall\n// for a density of HD.\nconst WX = 31.5, WY = 11.5, WR = 11, PR = 8.5, HB = 22, HD = 1.25, BIN = 0.2;\nconst c3 = [0, 0, 0];\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.looks[0].at \u003c 0) return;\n  const n = S.n, Ia = S.Iavg, hue = S.hue, L0 = S.looks[0], tone = 1 + (TONE - 1) / sqrt(n);\n  const i0 = floor(S.clock / SHAPE_T), f = S.clock / SHAPE_T - i0;\n  const A = SHAPES[i0 % NAMES], B = SHAPES[(i0 + 1) % NAMES];\n  const m = smooth((f * SHAPE_T - (SHAPE_T - MORPH_T)) / MORPH_T);\n  const curve = new Float32Array(W);\n  for (let x = 0; x \u003c W; x++) curve[x] = H - 1 - (gammaPdf(((x + 0.5) * BIN) / 4, n) / HD) * HB;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      const v = min(1, Ia[p] / tone), c = ((floor((atan2(S.zi[p], S.zr[p]) / TAU + hue) * 256) % 256) + 256) % 256;\n      let r = v * LUT[c * 3], g = v * LUT[c * 3 + 1], b = v * LUT[c * 3 + 2];\n      const dw = len(x - WX, y - WY);\n      if (dw \u003c WR + 1) {\n        // The window: the field dims to a fifth, a thin rim, the pupil inside.\n        const k = cl(WR + 0.5 - dw, 0, 1) * 0.8;\n        (r *= 1 - k), (g *= 1 - k), (b *= 1 - k);\n        const a = (x - WX) / PR, bb = (y - WY) / PR;\n        const pa = cl(0.5 - A(a, bb) * PR, 0, 1), pb = cl(0.5 - B(a, bb) * PR, 0, 1), pu = pa + (pb - pa) * m;\n        if (pu > 0) {\n          // Tinted by the diffuser's phase at that sample of the first look.\n          const si = cl(round(a * S.ru) + RU_MAX, 0, SU - 1), sj = cl(round(bb * 2 * S.ru) + 2 * RU_MAX, 0, SV - 1), s = sj * SU + si;\n          hsv((L0.p0[s] + L0.w[s] * S.boil) / TAU + hue, 0.4, 0.95 * pu, c3);\n          (r += c3[0]), (g += c3[1]), (b += c3[2]);\n        }\n        const ring = cl(1 - abs(dw - WR) * 1.5, 0, 1) * 0.35;\n        (r += ring), (g += ring), (b += ring);\n      }\n      if (y >= H - HB - 2) {\n        // The histogram: the field dims, the bars rise, the law is a line of dots.\n        const k = cl((y - (H - HB - 2)) / 2, 0, 1) * 0.75;\n        (r *= 1 - k), (g *= 1 - k), (b *= 1 - k);\n        const bin = x >> 2, top = H - 1 - (S.hist[bin] / HD) * HB;\n        if ((x & 3) !== 3 && y > top) {\n          hsv(0.62 + hue - bin * 0.012, 0.45, 0.5, c3);\n          (r += c3[0]), (g += c3[1]), (b += c3[2]);\n        }\n        const dc = abs(y - curve[x]), dn = x \u003c W - 1 ? abs(curve[x + 1] - curve[x]) : 0;\n        if (dc \u003c max(0.8, dn + 0.3) && y \u003c H) (r = 1), (g = 0.95), (b = 0.75);\n      }\n      display.setPixel(x, y, (255 * cl(r, 0, 1)) | 0, (255 * cl(g, 0, 1)) | 0, (255 * cl(b, 0, 1)) | 0);\n    }\n}\n","quadratic-reciprocity":"// ===== Patternflow pattern =====\n// Title:   Quadratic Reciprocity\n// Family:  number\n// Idea:    Two 64 x 64 tables of Legendre symbols (p/q), one LED per pair of 64 odd primes, light where p is a square mod q and dark where it is not, the top table in the primes' own order and the bottom one with the primes 1 mod 4 first, while a cross walks the diagonal comparing each pair with its mirror image, white where the two agree and green where they differ, which happens exactly when both primes are 3 mod 4, so the green builds a plaid on top and fills one corner block below.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: law of quadratic reciprocity (Adrien-Marie Legendre, 1785), conjectured by Leonhard Euler and first proved by Carl Friedrich Gauss (1796, published 1801), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..5, Start=0..400, Law=0.25..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a residue is pale aqua and a non-residue deep indigo, the pairs the law flips lean to rose and plum, the diagonal is grey and the marks are white and green; at 0.5 the residues are pink, the non-residues dark green, the flipped pairs lean to blue and the marks are white and violet. The wheel skips orange through lime, which read brown and olive when dim.\n// Knob 2: Speed. At 2 the cross moves 2 primes a second, down the 64 primes and back up in 63 seconds; a green mark fades to a third while the cross goes 12 primes on, 6 seconds, and a white one while it goes 2. 0.2 is ten times slower and 5 two and a half times faster.\n// Knob 3: Start. Which 64 odd primes the tables use: at 0 the first 64, 3 to 313, of which 30 are 1 mod 4 and 34 are 3 mod 4; at 400 the 64 from the 401st on, 2753 to 3307, 33 and 31. The law holds in every window, and the bottom corner block is always the primes 3 mod 4 against each other.\n// Knob 4: Law. How far the pairs of two primes 3 mod 4, the pairs the law says are flipped across the diagonal, lean towards rose: a quarter of the way at 0.25, a faint plaid on top and a pale 34 x 34 block in the bottom table's corner, and all the way at 1. The green marks fall on this tint and nowhere else.\n\nconst W = 64, H = 128, N = 64;\nconst { floor, max, abs, round, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Odd primes up to 4000 by a sieve; the last one Start reaches is the\n// 464th, 3307.\nconst PRIMES = (() => {\n  const top = 4000, comp = new Uint8Array(top + 1), out = [];\n  for (let i = 3; i \u003c= top; i += 2) {\n    if (comp[i]) continue;\n    out.push(i);\n    for (let j = i * i; j \u003c= top; j += 2 * i) comp[j] = 1;\n  }\n  return out;\n})();\n\n// The Legendre symbol (a/p) for an odd prime p by Euler's criterion:\n// a^((p - 1) / 2) is 1 mod p when a is a nonzero square mod p, p - 1 when it\n// is not, 0 when p divides a. Numbers stay below 4000^2, exact in doubles.\nfunction legendre(a, p) {\n  a %= p;\n  if (a === 0) return 0;\n  let e = (p - 1) / 2, b = a, r = 1;\n  while (e > 0) {\n    if (e & 1) r = (r * b) % p;\n    b = (b * b) % p;\n    e >>= 1;\n  }\n  return r === 1 ? 1 : -1;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob turns hues on a wheel that skips orange through lime, which\n// read brown and olive when dim. Hues are given as they look at knob 0,\n// from 0.28 round to 1.02.\nconst tone = (h, k) => 0.28 + 0.74 * ((((h - 0.28) / 0.74 + k) % 1 + 1) % 1);\n\n// The tables for the 64 primes from index start. leg[i * N + j] = (p_i /\n// p_j) with p_i the row's prime, and 0 on the diagonal. ord[r] is the prime\n// shown at row and column r of the bottom table: the primes 1 mod 4 in\n// order, then those 3 mod 4.\nfunction build(S, start) {\n  S.start = start;\n  const P = PRIMES.slice(start, start + N);\n  S.P = P;\n  S.three = P.map((p) => p % 4 === 3);\n  for (let i = 0; i \u003c N; i++) for (let j = 0; j \u003c N; j++) S.leg[i * N + j] = i === j ? 0 : legendre(P[i], P[j]);\n  const ord = [];\n  for (let i = 0; i \u003c N; i++) if (!S.three[i]) ord.push(i);\n  S.n1 = ord.length;\n  for (let i = 0; i \u003c N; i++) if (S.three[i]) ord.push(i);\n  S.ord = ord;\n  S.mark.fill(0);\n}\n\nexport function setup(params) {\n  params.s = {\n    start: -1,\n    P: [],\n    three: [],\n    leg: new Int8Array(N * N),\n    ord: [],\n    n1: 0,\n    // The walk: k is a position along the 64 primes, going down then up.\n    k: 0,\n    dir: 1,\n    // The marks the cross leaves, one per pair, fading.\n    mark: new Float32Array(N * N),\n    hue: 0,\n    law: 0.25,\n    cross: new Float32Array(N),\n    pal: new Float32Array(30),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.25], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 5);\n  const start = round(cl(kv[2], 0, 400));\n  S.law = cl(kv[3], 0.25, 1);\n  if (start !== S.start) build(S, start);\n  // 2 primes a second at Speed 2, bouncing at the ends.\n  S.k += S.dir * d * speed;\n  if (S.k > N - 1) (S.k = 2 * (N - 1) - S.k), (S.dir = -1);\n  if (S.k \u003c 0) (S.k = -S.k), (S.dir = 1);\n  // The cross is on each prime by how near the walk is to it, so it slides\n  // from one row to the next without a jump.\n  for (let i = 0; i \u003c N; i++) S.cross[i] = max(0, 1 - abs(i - S.k));\n  // The cross leaves a mark on every pair it passes, (p/q) in row p and\n  // (q/p) in column p. Where the pair and its mirror differ the mark is\n  // green and fades to 1/e while the walk goes 12 primes on, 6 s at Speed\n  // 2; where they agree it is white and fades in 2 primes.\n  const fadeD = exp((-d * speed) / 12), fadeA = exp((-d * speed) / 2);\n  const { leg, mark, cross } = S;\n  for (let i = 0; i \u003c N; i++)\n    for (let j = 0; j \u003c N; j++) {\n      const q = i * N + j;\n      let m = mark[q] * (leg[q] !== leg[j * N + i] ? fadeD : fadeA);\n      const c = max(cross[i], cross[j]);\n      if (c > m) m = c;\n      mark[q] = m;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.start \u003c 0) return;\n  const { leg, mark, three, ord, pal, hue, law } = S;\n  // Colours: residue, non-residue; the same two tinted for the flipped\n  // pairs; the agreeing and differing marks of the cross; the diagonal.\n  hsv(tone(0.5, hue), 0.4, 0.9, pal, 0);\n  hsv(tone(0.68, hue), 0.85, 0.2, pal, 3);\n  hsv(tone(0.96, hue), 0.5, 0.95, pal, 6);\n  hsv(tone(0.88, hue), 0.9, 0.32, pal, 9);\n  hsv(tone(0.5, hue), 0.08, 1, pal, 12);\n  hsv(tone(0.5, hue), 0.25, 0.6, pal, 15);\n  hsv(tone(0.34, hue), 0.8, 1, pal, 18);\n  hsv(tone(0.34, hue), 0.95, 0.66, pal, 21);\n  hsv(tone(0.5, hue), 0.12, 0.5, pal, 24);\n  const c = [0, 0, 0];\n  for (let half = 0; half \u003c 2; half++)\n    for (let y = 0; y \u003c N; y++) {\n      const i = half ? ord[y] : y;\n      for (let x = 0; x \u003c N; x++) {\n        const j = half ? ord[x] : x, q = i * N + j, v = leg[q];\n        if (v === 0) {\n          // (p/p) = 0: the diagonal, the mirror's axis.\n          c[0] = pal[24];\n          c[1] = pal[25];\n          c[2] = pal[26];\n        } else {\n          // The base colour, tinted by Law where both primes are 3 mod 4.\n          const b = v > 0 ? 0 : 3, flip = three[i] && three[j] ? law : 0;\n          for (let e = 0; e \u003c 3; e++) c[e] = pal[b + e] + (pal[b + 6 + e] - pal[b + e]) * flip;\n          // The marks: white where the pair agrees with its mirror, green\n          // where it does not.\n          const m = mark[q];\n          if (m > 0.004) {\n            const w = leg[j * N + i] === v ? (v > 0 ? 12 : 15) : v > 0 ? 18 : 21;\n            for (let e = 0; e \u003c 3; e++) c[e] += (pal[w + e] - c[e]) * m;\n          }\n        }\n        display.setPixel(x, y + half * N, (255 * cl(c[0], 0, 1)) | 0, (255 * cl(c[1], 0, 1)) | 0, (255 * cl(c[2], 0, 1)) | 0);\n      }\n    }\n}\n","seam-carving":"// ===== Patternflow pattern =====\n// Title:   Seam Carving\n// Family:  algo\n// Idea:    An image of discs, rings, bands and a stripe fills the panel, its cumulative energy map sweeps down it row by row, and the cheapest eight-connected seam climbs back up from the bottom in white; then seam after seam lights the full height of the panel and is taken out, the columns closing in until the image is nearly a third narrower and the discs are still round, and after a map of the narrow image its cheapest seams are doubled one by one in mint until it is full width again and a new image is drawn.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: seam carving (Shai Avidan and Ariel Shamir, 2007), forward energy (Michael Rubinstein, Ariel Shamir and Shai Avidan, 2008), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Carve=20..40, Forward=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the ground runs from dark azure at the top to violet at the bottom with teal bands, the shapes are gold, rose, cyan, magenta and sky blue, and the energy map runs from indigo through magenta to gold; at 0.5 the ground is crimson with magenta bands and the shapes are blue, red, green, sea green and orange. The ground's wheel skips orange to lime, which reads brown when dim.\n// Knob 2: Speed. 2 is one unit of the timeline a second: the image fades in for 0.5 s, the map sweeps down in 0.7 s, the first seam climbs in 0.3 s and the map fades in 0.3 s, the carving takes 5.5 s whatever the count, the narrow image's map 1.6 s, the growing 4.5 s, and the full image rests 1.2 s: 14.6 s an image. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Carve. How many seams come out before the image grows back, 20 to 40 of its 64 columns; no row of a fresh image is more than 26 columns of shape. At 20 the image ends 44 columns wide and the carving takes 24 shape pixels an image, mostly half-lit rim pixels, out of the 2,560 it removes; at 30 it takes 93 and at 40, when some rows have no ground left, 376, and the discs come out oval. The growing doubles at most an eighth of the columns at a time, re-planned on the wider image after each batch: 5, 6, 6 and 3 seams at 20.\n// Knob 4: Forward. Mixes the seam cost from Avidan and Shamir's gradient energy at 0 to Rubinstein's forward energy at 1, the cost of the edges a removal creates. The rim light on the image is the energy the knob uses: at 0 every outline glows, at 1 only the edges a removal would join, so the tops and bottoms of the discs and the bands go dark. A seam straight down the flat middle of a disc creates no edge, so at 1 the carving takes 78 shape pixels an image instead of 24, and a disc can grow back as a capsule.\n\nconst W = 64, H = 128, F = 8, N = W * H;\nconst { floor, min, max, abs, sqrt, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n// The timeline, in units of a second at Speed 2.\nconst T_IN = 0.5, T_MAP = 0.7, T_TRACE = 0.3, T_UNMAP = 0.3, T_CARVE = 5.5, T_GROW = 4.5, T_REST = 1.2;\n// The narrow image's map: a pause, the sweep, a hold and the fade.\nconst H_PAUSE = 0.3, H_MAP = 0.7, H_HOLD = 0.3, H_FADE = 0.3, T_HOLD = H_PAUSE + H_MAP + H_HOLD + H_FADE;\n// Within one seam's slot of the carving: it climbs, holds, then closes.\nconst Q_TRACE = 0.3, Q_CLOSE = 0.5;\n// Within one seam's slot of the growing: its pixels light, then the copies open.\nconst G_OPEN = 0.3, G_FADE = 0.9;\n// Every pixel carries a random number; JIT of it is added to the cost so\n// that ties across flat ground break at random instead of to the left.\nconst JIT = 0.004;\n// Rim light: the energy shown on the image, at GLOW for an energy of E_REF.\nconst GLOW = 0.42, E_REF = 0.5;\n// Hues at knob 0. The ground goes through a wheel that skips orange to\n// lime: 0.62 azure at the top to 0.71 violet at the bottom, bands 0.55 teal.\nconst BG0 = 0.46, SH0 = 0.12, PALETTE = [0, 0.83, 0.38, 0.79, 0.45];\n// Shapes: 0 a shaded disc, 1 a thin ring, 2 a thick ring, 3 a ring round a disc.\nconst KINDS = [0, 0, 1, 2, 3];\n// The ground's hue for knob k and the pixel's offset: the offset is\n// folded back at the wheel's ends rather than wrapped, so the gradient\n// never jumps from rose to lime halfway down the panel.\nfunction groundHue(k, off) {\n  let t = BG0 + k - floor(BG0 + k) + off;\n  t = t \u003c 0 ? -t : t > 1 ? 2 - t : t;\n  return 0.28 + 0.74 * t;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// A pixel is F floats: 0..2 its colour at knob 0, which the energy reads;\n// 3 its hue offset, 4 saturation, 5 value; 6 its tie-breaking random\n// number; 7 is 1 for the ground, whose hue goes through the skipping wheel.\n// Rows are W pixels apart in memory and the first S.w of them are the image.\nconst tmp = [0, 0, 0];\nfunction setRef(img, o) {\n  hsv(img[o + 7] ? groundHue(0, img[o + 3]) : SH0 + img[o + 3], img[o + 4], img[o + 5], tmp);\n  img[o] = tmp[0];\n  img[o + 1] = tmp[1];\n  img[o + 2] = tmp[2];\n}\n// Lay colour (h, s, v) over a pixel with coverage a. Hue is not blended:\n// the edge pixel takes the hue of whichever covers more of it.\nfunction lay(img, o, a, h, s, v, ground) {\n  if (a \u003c= 0) return;\n  a = min(1, a);\n  if (a >= 0.5) (img[o + 3] = h), (img[o + 7] = ground);\n  img[o + 4] += (s - img[o + 4]) * a;\n  img[o + 5] += (v - img[o + 5]) * a;\n}\n\n// A fresh image: a vertical gradient for ground, one or two teal bands,\n// often a thin diagonal stripe from edge to edge, then discs and rings\n// placed so no row is more than 26 columns shape, which leaves the seams\n// at least 38 columns of ground in every row.\nfunction paint(S) {\n  const img = S.img, R = Math.random;\n  S.w = W;\n  const h0 = R() * 0.04, h1 = h0 + 0.08 + R() * 0.04;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0, t = y / (H - 1); x \u003c W; x++) {\n      const o = (y * W + x) * F;\n      img[o + 3] = h0 + (h1 - h0) * t;\n      img[o + 4] = 0.78;\n      img[o + 5] = 0.36 - 0.1 * t;\n      img[o + 6] = R();\n      img[o + 7] = 1;\n    }\n  const nb = 1 + (R() \u003c 0.6 ? 1 : 0);\n  for (let b = 0; b \u003c nb; b++) {\n    const y0 = 6 + floor(R() * (H - 16)), hb = 3 + floor(R() * 4);\n    for (let y = y0; y \u003c y0 + hb; y++) for (let x = 0; x \u003c W; x++) lay(img, (y * W + x) * F, 1, -0.1, 0.72, 0.5, 1);\n  }\n  if (R() \u003c 0.7) {\n    // The stripe: centre line from (0, ya) to (63, yb), 2.4 LEDs across.\n    const ya = 10 + R() * (H - 20), dy = (R() \u003c 0.5 ? -1 : 1) * (26 + R() * 30), yb = cl(ya + dy, 4, H - 5);\n    const k = (yb - ya) / (W - 1), nrm = 1 / sqrt(1 + k * k), hs = PALETTE[floor(R() * PALETTE.length)];\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const d = abs(y - (ya + k * x)) * nrm;\n        lay(img, (y * W + x) * F, 1.7 - d, hs, 0.55, 0.78, 0);\n      }\n  }\n  const cov = new Float32Array(H), shapes = [];\n  for (let tries = 0; tries \u003c 500 && shapes.length \u003c 9; tries++) {\n    const r = 5 + R() * 9, cx = 2.5 + r + R() * (W - 5 - 2 * r), cy = 2.5 + r + R() * (H - 5 - 2 * r);\n    let ok = true;\n    for (const s of shapes) if ((s.cx - cx) ** 2 + (s.cy - cy) ** 2 \u003c (s.r + r + 3) ** 2) ok = false;\n    for (let y = floor(cy - r); ok && y \u003c= cy + r; y++) if (cov[y] + 2 * sqrt(max(0, r * r - (y - cy) ** 2)) > 26) ok = false;\n    if (!ok) continue;\n    for (let y = floor(cy - r); y \u003c= cy + r; y++) cov[y] += 2 * sqrt(max(0, r * r - (y - cy) ** 2));\n    shapes.push({ cx, cy, r, kind: KINDS[floor(R() * KINDS.length)], h: PALETTE[floor(R() * PALETTE.length)], pale: R() \u003c 0.15 });\n  }\n  for (const s of shapes) {\n    const sat = s.pale ? 0.18 : 0.8;\n    for (let y = max(0, floor(s.cy - s.r - 1)); y \u003c= min(H - 1, s.cy + s.r + 1); y++)\n      for (let x = max(0, floor(s.cx - s.r - 1)); x \u003c= min(W - 1, s.cx + s.r + 1); x++) {\n        const d = sqrt((x + 0.5 - s.cx) ** 2 + (y + 0.5 - s.cy) ** 2), o = (y * W + x) * F;\n        // Discs are shaded like a ball, half as bright at the rim, which also\n        // gives their insides an energy the seams would rather go round.\n        if (s.kind === 0) lay(img, o, s.r + 0.5 - d, s.h, sat, 1 - 0.5 * (d / s.r) ** 2, 0);\n        else if (s.kind === 1) lay(img, o, 1.8 - abs(d - s.r + 1.3), s.h, sat, 0.95, 0);\n        else if (s.kind === 2) lay(img, o, min(s.r + 0.5 - d, d - 0.5 * s.r + 0.5), s.h, sat, 0.92, 0);\n        else {\n          lay(img, o, 1.6 - abs(d - s.r + 1.1), s.h, sat, 0.95, 0);\n          lay(img, o, 0.42 * s.r + 0.5 - d, s.h + 0.5, sat, 1 - 0.45 * (d / (0.42 * s.r)) ** 2, 0);\n        }\n      }\n  }\n  for (let o = 0; o \u003c N * F; o += F) setRef(img, o);\n}\n\nconst d3 = (a, o1, o2) => abs(a[o1] - a[o2]) + abs(a[o1 + 1] - a[o2 + 1]) + abs(a[o1 + 2] - a[o2 + 2]);\n\n// The dynamic programme over rows, on the first w columns of img.\n// Backward energy is Avidan and Shamir's e1, |dI/dx| + |dI/dy| summed over\n// the colours, central differences with the border pixel repeated. Forward\n// energy is the cost of the new neighbours a removal makes: taking (x, y)\n// joins x - 1 and x + 1 in row y, CU = |I(x+1,y) - I(x-1,y)|; if the seam\n// came from (x - 1, y - 1) the pixel (x, y - 1) also comes to sit over\n// (x - 1, y), CL = CU + |I(x,y-1) - I(x-1,y)|, and from (x + 1, y - 1)\n// CR = CU + |I(x,y-1) - I(x+1,y)|. With f the knob,\n// M(x,y) = (1 - f) e1(x,y) + min over the three of M(x', y-1) + f C.\n// back holds the move that won (-1, 0, +1); seam gets the cheapest path,\n// one pixel a row, from the least M in the bottom row back up.\nfunction carveDP(img, w, f, M, back, seam) {\n  for (let y = 0; y \u003c H; y++) {\n    const yu = y > 0 ? y - 1 : 0, yd = y \u003c H - 1 ? y + 1 : y;\n    for (let x = 0; x \u003c w; x++) {\n      const o = (y * W + x) * F, ol = (y * W + (x > 0 ? x - 1 : 0)) * F, or = (y * W + (x \u003c w - 1 ? x + 1 : x)) * F;\n      const cu = d3(img, ol, or);\n      const e1 = 0.5 * (cu + d3(img, (yu * W + x) * F, (yd * W + x) * F));\n      const base = (1 - f) * e1 + JIT * img[o + 6], i = y * W + x;\n      if (y === 0) {\n        M[i] = base + f * cu;\n        back[i] = 0;\n        continue;\n      }\n      const ou = (yu * W + x) * F, j = i - W;\n      let best = M[j] + f * cu, mv = 0;\n      if (x > 0) {\n        const v = M[j - 1] + f * (cu + d3(img, ou, ol));\n        if (v \u003c best) (best = v), (mv = -1);\n      }\n      if (x \u003c w - 1) {\n        const v = M[j + 1] + f * (cu + d3(img, ou, or));\n        if (v \u003c best) (best = v), (mv = 1);\n      }\n      M[i] = base + best;\n      back[i] = mv;\n    }\n  }\n  let x = 0;\n  for (let c = 1, o = (H - 1) * W; c \u003c w; c++) if (M[o + c] \u003c M[o + x]) x = c;\n  for (let y = H - 1; y >= 0; y--) {\n    seam[y] = x;\n    x += back[y * W + x];\n  }\n  return M[(H - 1) * W + seam[H - 1]];\n}\n\n// Take one pixel out of every row; the rest of the row moves left.\nfunction removeSeam(img, ids, w, seam) {\n  for (let y = 0; y \u003c H; y++) {\n    const r = y * W, s = seam[y];\n    img.copyWithin((r + s) * F, (r + s + 1) * F, (r + w) * F);\n    ids.copyWithin(r + s, r + s + 1, r + w);\n  }\n}\n\n// Each row's M from its least to its greatest, kept for drawing the map. A\n// row's span is held to at least a third of the widest, so a row of plain\n// ground shows dark instead of its tie-breaking noise stretched to full.\nfunction rowRange(S, w, M) {\n  let top = 1e-6;\n  for (let y = 0; y \u003c H; y++) {\n    let a = Infinity, b = -Infinity;\n    for (let x = 0, o = y * W; x \u003c w; x++) (a = min(a, M[o + x])), (b = max(b, M[o + x]));\n    S.mlo[y] = a;\n    S.mhi[y] = b - a;\n    top = max(top, b - a);\n  }\n  for (let y = 0; y \u003c H; y++) S.mhi[y] = max(S.mhi[y], top / 3);\n}\n\n// The rim light: the energy the knob uses, per pixel. Forward energy has no\n// cost of its own at a pixel, only at a move; the cheapest move, straight\n// down, costs CU, and half of it is shown to match e1's half differences.\n// Each pixel's colour with its rim light is kept until the image, the hue\n// or the knob changes.\nfunction prepare(S) {\n  const img = S.img, w = S.w, f = S.f, hue = S.hue, C = S.C;\n  for (let y = 0; y \u003c H; y++) {\n    const yu = y > 0 ? y - 1 : 0, yd = y \u003c H - 1 ? y + 1 : y;\n    for (let x = 0; x \u003c w; x++) {\n      const i = y * W + x, o = i * F, ol = (y * W + (x > 0 ? x - 1 : 0)) * F, or = (y * W + (x \u003c w - 1 ? x + 1 : x)) * F;\n      const dx = d3(img, ol, or), dy = d3(img, (yu * W + x) * F, (yd * W + x) * F);\n      const e = min(1, (0.5 * (dx + (1 - f) * dy)) / E_REF);\n      S.G[i] = e;\n      hsv(img[o + 7] ? groundHue(hue, img[o + 3]) : SH0 + hue + img[o + 3], img[o + 4], img[o + 5], tmp);\n      C[i * 3] = tmp[0];\n      C[i * 3 + 1] = tmp[1];\n      C[i * 3 + 2] = tmp[2];\n    }\n  }\n  S.gw = w;\n  S.gf = f;\n  S.gh = hue;\n  S.dirty = false;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    img: new Float32Array(N * F), ids: new Int16Array(N), w: W,\n    M: new Float32Array(N), M2: new Float32Array(N), back: new Int8Array(N), seam: new Int16Array(H), mlo: new Float32Array(H), mhi: new Float32Array(H),\n    G: new Float32Array(N), C: new Float32Array(N * 3), gw: -1, gf: -1, gh: -1, dirty: true,\n    // The growing's plan: a copy carved down on the side, and the seams it gave.\n    T: new Float32Array(N * F), Tids: new Int16Array(N), tw: 0, plan: [], need: 0,\n    act: new Int16Array(H),\n    ph: 0, pt: 0, q: 0, k: 20, f: 0, hue: 0, removed: 0, grown: 0, inserted: false,\n    out: new Float32Array(N * 3), last: new Float32Array(N * 3),\n  });\n  paint(S);\n  S.ph = 0;\n}\n\n// Plan b seams to double: carve them out of a copy of the image one after\n// another, recording each by the ids of its pixels, which are the columns\n// of the image as it stands now. Avidan and Shamir enlarge this way, since\n// doubling the one cheapest seam over and over would stretch one column.\nfunction planStart(S, b) {\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c S.w; x++) S.ids[y * W + x] = x;\n  S.T.set(S.img);\n  S.Tids.set(S.ids);\n  S.tw = S.w;\n  S.plan = [];\n  S.need = b;\n}\nfunction planStep(S) {\n  if (S.plan.length >= S.need) return;\n  // The first plan's map is the one drawn; the rest go to a spare.\n  carveDP(S.T, S.tw, S.f, S.plan.length ? S.M2 : S.M, S.back, S.seam);\n  const ids = new Int16Array(H);\n  for (let y = 0; y \u003c H; y++) ids[y] = S.Tids[y * W + S.seam[y]];\n  if (S.plan.length === 0) rowRange(S, S.tw, S.M);\n  S.plan.push(ids);\n  removeSeam(S.T, S.Tids, S.tw, S.seam);\n  S.tw--;\n}\n\n// Double planned seam j: after its pixel in every row goes a new one, the\n// mean of it and its right neighbour. act holds where the new pixels are.\nfunction insertSeam(S, ids) {\n  const img = S.img, w = S.w;\n  for (let y = 0; y \u003c H; y++) {\n    const r = y * W;\n    let c = 0;\n    while (c \u003c w - 1 && S.ids[r + c] !== ids[y]) c++;\n    img.copyWithin((r + c + 2) * F, (r + c + 1) * F, (r + w) * F);\n    S.ids.copyWithin(r + c + 2, r + c + 1, r + w);\n    const o = (r + c) * F, n = (r + c + 1) * F, o2 = c + 1 \u003c w ? (r + c + 2) * F : o;\n    for (let k = 0; k \u003c 7; k++) img[n + k] = 0.5 * (img[o + k] + img[o2 + k]);\n    // Hues average the short way round the wheel; the ground keeps its wheel.\n    let dh = img[o2 + 3] - img[o + 3];\n    dh -= round(dh);\n    img[n + 3] = img[o + 3] + 0.5 * dh;\n    img[n + 7] = img[o + 7];\n    img[n + 6] = Math.random();\n    S.ids[r + c + 1] = -1;\n    S.act[y] = c + 1;\n  }\n  S.w++;\n}\n// The pixels of a planned seam in the image as it stands.\nfunction locate(S, ids) {\n  for (let y = 0; y \u003c H; y++) {\n    let c = 0;\n    while (c \u003c S.w - 1 && S.ids[y * W + c] !== ids[y]) c++;\n    S.act[y] = c;\n  }\n}\n\nfunction enter(S, ph) {\n  S.ph = ph;\n  S.pt = 0;\n  if (ph === 1) {\n    // The map, and the first seam with it.\n    carveDP(S.img, S.w, S.f, S.M, S.back, S.seam);\n    rowRange(S, S.w, S.M);\n    S.act.set(S.seam);\n  } else if (ph === 4) {\n    S.removed = 0;\n    S.q = Q_TRACE;\n  } else if (ph === 5) {\n    S.grow = S.removed;\n    S.grown = 0;\n    planStart(S, min(S.grow, floor(S.w / 8)));\n    planStep(S);\n  } else if (ph === 6) {\n    S.q = 0;\n    S.inserted = false;\n    S.done = 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 20, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3);\n  S.k = round(cl(kv[2], 20, 40));\n  S.f = cl(kv[3], 0, 1);\n  const g = (d * speed) / 2;\n  S.pt += g;\n  if (S.ph === 0) {\n    if (S.pt >= T_IN) enter(S, 1);\n  } else if (S.ph === 1) {\n    if (S.pt >= T_MAP) enter(S, 2);\n  } else if (S.ph === 2) {\n    if (S.pt >= T_TRACE) enter(S, 3);\n  } else if (S.ph === 3) {\n    if (S.pt >= T_UNMAP) enter(S, 4);\n  } else if (S.ph === 4) {\n    // The carving: k seams in T_CARVE, each in its slot of q from 0 to 1.\n    S.q += (g * S.k) / T_CARVE;\n    while (S.q >= 1) {\n      removeSeam(S.img, S.ids, S.w, S.act);\n      S.w--;\n      S.removed++;\n      S.dirty = true;\n      S.q -= 1;\n      if (S.removed >= S.k || S.w \u003c= 8) {\n        enter(S, 5);\n        break;\n      }\n      carveDP(S.img, S.w, S.f, S.M, S.back, S.seam);\n      S.act.set(S.seam);\n    }\n  } else if (S.ph === 5) {\n    // The narrow image's map, while the plan is carved on the side.\n    for (let n = 0; n \u003c 3; n++) planStep(S);\n    if (S.pt >= T_HOLD) {\n      while (S.plan.length \u003c S.need) planStep(S);\n      enter(S, 6);\n      locate(S, S.plan[0]);\n    }\n  } else if (S.ph === 6) {\n    // The growing: the planned seams doubled, one slot each.\n    S.q += (g * S.grow) / T_GROW;\n    for (;;) {\n      if (!S.inserted && S.q >= G_OPEN) {\n        insertSeam(S, S.plan[S.done]);\n        S.inserted = true;\n        S.dirty = true;\n      }\n      if (S.q \u003c 1) break;\n      S.q -= 1;\n      S.inserted = false;\n      S.done++;\n      S.grown++;\n      if (S.grown >= S.grow) {\n        enter(S, 7);\n        break;\n      }\n      if (S.done >= S.plan.length) {\n        // A batch is used up: plan the next one on the wider image.\n        planStart(S, min(S.grow - S.grown, floor(S.w / 8)));\n        while (S.plan.length \u003c S.need) planStep(S);\n        S.done = 0;\n      }\n      locate(S, S.plan[S.done]);\n    }\n  } else if (S.ph === 7) {\n    if (S.pt >= T_REST) {\n      S.last.set(S.out);\n      paint(S);\n      S.dirty = true;\n      enter(S, 0);\n    }\n  }\n}\n\nconst row = new Float32Array(W * 3), c = [0, 0, 0], h2 = [0, 0, 0];\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.dirty || S.gf !== S.f || S.gw !== S.w || S.gh !== S.hue) prepare(S);\n  const w = S.w, out = S.out, hue = S.hue;\n  // What is lit and how: the map's share a, the sweep's front row, the\n  // active seam's light and the width of its pixel.\n  let mapA = 0, front = -1, light = 0, lightFrom = H, aw = 1, x0 = floor((W - w) / 2), grow = false;\n  const off = (n) => floor((W - n) / 2);\n  const ph = S.ph;\n  if (ph === 1) (mapA = 1), (front = (S.pt / T_MAP) * H);\n  else if (ph === 2) (mapA = 1), (light = 1), (lightFrom = H * (1 - S.pt / T_TRACE));\n  else if (ph === 3) (mapA = 1 - smooth(S.pt / T_UNMAP)), (light = 1), (lightFrom = 0);\n  else if (ph === 4) {\n    const q = S.q;\n    light = 1;\n    lightFrom = q \u003c Q_TRACE ? H * (1 - q / Q_TRACE) : 0;\n    const p = smooth((q - Q_CLOSE) / (1 - Q_CLOSE));\n    aw = 1 - p;\n    x0 = off(w) + p * (off(w - 1) - off(w));\n  } else if (ph === 5) {\n    const t = S.pt - H_PAUSE;\n    if (t > 0 && t \u003c H_MAP) (mapA = 1), (front = (t / H_MAP) * H);\n    else if (t >= H_MAP) mapA = 1 - smooth((t - H_MAP - H_HOLD) / H_FADE);\n  } else if (ph === 6) {\n    const q = S.q;\n    grow = true;\n    light = q \u003c G_FADE ? 1 : 1 - (q - G_FADE) / (1 - G_FADE);\n    lightFrom = q \u003c G_OPEN ? H * (1 - q / G_OPEN) : 0;\n    if (S.inserted) {\n      const p = smooth((q - G_OPEN) / (G_FADE - G_OPEN));\n      aw = p;\n      x0 = off(w - 1) + p * (off(w) - off(w - 1));\n    }\n  }\n  // Seam lights: warm white for a carved seam, pale mint for a doubled one.\n  const sl = grow ? [0.72, 1, 0.86] : [1, 0.94, 0.8];\n  for (let y = 0; y \u003c H; y++) {\n    row.fill(0);\n    const act = light > 0 || aw !== 1 ? S.act[y] : -1;\n    let pos = x0;\n    for (let i = 0; i \u003c w; i++) {\n      const wd = i === act ? aw : 1;\n      if (wd \u003c= 0) continue;\n      const gl = GLOW * S.G[y * W + i] * (1 - mapA), oc = (y * W + i) * 3;\n      for (let k = 0; k \u003c 3; k++) c[k] = S.C[oc + k] + (1 - S.C[oc + k]) * gl;\n      if (mapA > 0 && (front \u003c 0 || y \u003c front)) {\n        // The cumulative energy map, each row from its least M to its greatest.\n        const m = sqrt((S.M[y * W + i] - S.mlo[y]) / S.mhi[y]);\n        hsv(0.72 + hue + 0.4 * m, 0.9 - 0.45 * m * m, 0.16 + 0.84 * m, h2);\n        for (let k = 0; k \u003c 3; k++) c[k] += (h2[k] - c[k]) * mapA;\n      }\n      if (front >= 0 && y === floor(front)) for (let k = 0; k \u003c 3; k++) c[k] += (1 - c[k]) * 0.6;\n      if (i === act && light > 0 && y >= lightFrom) {\n        const a = light * (grow ? 0.85 : 0.9);\n        for (let k = 0; k \u003c 3; k++) c[k] += (sl[k] - c[k]) * a;\n      }\n      // Lay the pixel over the LEDs it covers, by area.\n      const a = pos, b = pos + wd;\n      pos = b;\n      for (let x = max(0, floor(a)), x1 = min(W - 1, Math.ceil(b) - 1); x \u003c= x1; x++) {\n        const cov = min(b, x + 1) - max(a, x);\n        if (cov \u003c= 0) continue;\n        row[x * 3] += c[0] * cov;\n        row[x * 3 + 1] += c[1] * cov;\n        row[x * 3 + 2] += c[2] * cov;\n      }\n    }\n    // The first image fades in from black, every later one from the last.\n    const fade = ph === 0 ? smooth(S.pt / T_IN) : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      for (let k = 0; k \u003c 3; k++) out[o + k] = S.last[o + k] + (row[x * 3 + k] - S.last[o + k]) * fade;\n      display.setPixel(x, y, (255 * cl(out[o], 0, 1)) | 0, (255 * cl(out[o + 1], 0, 1)) | 0, (255 * cl(out[o + 2], 0, 1)) | 0);\n    }\n  }\n}\n","seifert-surface":"// ===== Patternflow pattern =====\n// Title:   Seifert Surface\n// Family:  topology\n// Idea:    A knot drawn as a closed braid down the panel goes through Seifert's algorithm step by step: its crossings are smoothed so it falls apart into nested Seifert circles, each circle fills with a disc at its own depth, a half-twisted band joins two discs at every crossing, and the finished surface rocks in 3-D with its two faces in two colours, each band turning from gold to blue across its half twist, before the next knot.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Seifert's algorithm (Herbert Seifert, 1934), every knot a closed braid (James Alexander, 1923), homogeneous braids give a minimal-genus surface (John Stallings, 1978), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knot=0..7, Tilt=40..80\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the face every disc shows the viewer is blue on the outer disc, indigo and violet further in, the other face is gold, the knot pale gold, and each Seifert circle a light tint of its disc.\n// Knob 2: Speed. At 2 one knot takes 17.2 seconds: 1.4 to draw it along its orientation, the crossings smoothed from 2.2 to 3.6, the discs in from 3.8 to 5.4, the bands one after another from 5.8 to 8.8, then the finished surface rocks twice while a bright run goes round its edge at 40 LEDs a second, and fades from 16.4. 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Knot. The knot to start from, then on round the list: 0 the trefoil 3_1 (sigma1^3), 1 the figure eight 4_1 ((sigma1 sigma2^-1)^2), 2 5_1 (sigma1^5), 3 5_2 (sigma1^3 sigma2 sigma1^-1 sigma2), 4 6_2 (sigma1^-1 sigma2 sigma1^-1 sigma2^3), 5 6_3 (sigma1^-1 sigma2^2 sigma1^-2 sigma2), 6 7_1 (sigma1^7), 7 8_19 ((sigma1 sigma2)^4). The surfaces have genus 1, 1, 2, 2, 2, 2, 3, 3; all but 5_2's are the least the knot allows, and 5_2, genus 1, gets 2 from this braid.\n// Knob 4: Tilt. How far the view turns about the panel's upright middle, 40 to 80 degrees. The discs lie 22 LEDs apart in depth, so at the full turn they slide 14 LEDs apart at 40 and 22 at 80, where they stand as thin plates with the bands bridging them. The knot itself is drawn turned a fifth as far, and the finished surface rocks between a fifth of the Tilt and all of it.\n\nconst W = 64, H = 128, NPX = W * H;\nconst { floor, ceil, min, max, cos, sin, abs, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\n\n// Knots as closed braids: the number of strands, and the word (i for\n// sigma_i, -i for its inverse). Each closes up to one component.\nconst KNOTS = [\n  { name: \"3_1\", n: 2, w: [1, 1, 1] },\n  { name: \"4_1\", n: 3, w: [1, -2, 1, -2] },\n  { name: \"5_1\", n: 2, w: [1, 1, 1, 1, 1] },\n  { name: \"5_2\", n: 3, w: [1, 1, 1, 2, -1, 2] },\n  { name: \"6_2\", n: 3, w: [-1, 2, -1, 2, 2, 2] },\n  { name: \"6_3\", n: 3, w: [-1, 2, 2, -1, -1, 2] },\n  { name: \"7_1\", n: 2, w: [1, 1, 1, 1, 1, 1, 1] },\n  { name: \"8_19\", n: 3, w: [1, 2, 1, 2, 1, 2, 1, 2] },\n];\n// The steps of one knot, in seconds at Speed 2.\nconst T_HOLD = 1.4, T_SMOOTH = 2.2, T_DISCS = 3.8, T_BANDS = 5.8, T_DONE = 8.8, T_FADE = 16.4, T_NEXT = 17.2;\n// Depth between stacked discs, in LEDs.\nconst DZ = 22;\nconst STEP = 0.6;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The diagram, in LEDs about the panel's middle column. The braid runs\n// down the left and strand i comes back up the right, so once the\n// crossings are smoothed strand i is the rounded rectangle \"loop i\", the\n// loops nested one inside the next: wide apart on the left where the\n// bands go, close on the right. Disc i lies at depth z = (i - (n-1)/2) DZ,\n// the inner discs nearer the viewer. Every loop runs down its left side,\n// so the Seifert circles are oriented alike and every disc turns the same\n// face to the viewer.\nfunction layout(K) {\n  const n = K.n, c = K.w.length, dl = n === 2 ? 22 : 15, dr = n === 2 ? 8 : 6;\n  const loops = [];\n  for (let i = 0; i \u003c n; i++)\n    loops.push({ l: -30 + i * dl, r: 26 - dr * i, t: 4 + 7 * i, b: 124 - 7 * i, rc: 12 - 2 * i, z: (i - (n - 1) / 2) * DZ });\n  let top = -1e9, bot = 1e9;\n  for (const L of loops) (top = max(top, L.t + L.rc)), (bot = min(bot, L.b - L.rc));\n  const gap = (bot - top) / c, h = min(8, 0.36 * gap);\n  const cross = K.w.map((g, k) => ({ i: abs(g) - 1, sg: g > 0 ? 1 : -1, y: top + (k + 0.5) * gap }));\n  return { n, c, loops, cross, h, top, bot };\n}\n\n// A point of crossing k's band: u runs from the left loop (u = 0) to the\n// right one (u = 1), v across from -1 to 1. The band's width turns half\n// round about its core on the way, the sense of the turn set by the\n// crossing's sign, so its two edges pass over each other once: those edges\n// are the knot's two strands at the crossing.\nfunction bandPoint(G, k, u, v, out) {\n  const X = G.cross[k], A = G.loops[X.i], B = G.loops[X.i + 1];\n  const h = G.h, e = -X.sg;\n  out[0] = A.l + u * (B.l - A.l);\n  out[1] = X.y + v * h * cos(PI * u);\n  out[2] = A.z + u * (B.z - A.z) + v * h * e * sin(PI * u);\n}\n\n// The knot, walked along its orientation as one closed polyline. Every\n// point keeps where it sits in the knot, where it sits once the crossings\n// are smoothed, its crossing (or -1), the Seifert circle it lands on, and\n// how far along the knot it is.\nfunction walk(G) {\n  const P = [];\n  const add = (x, y, z, sx, sy, sz, k, circ) => P.push([x, y, z, sx, sy, sz, k, circ]);\n  const line = (i, x0, y0, x1, y1) => {\n    const z = G.loops[i].z, m = max(1, ceil(hypot(x1 - x0, y1 - y0) / STEP));\n    for (let j = 0; j \u003c m; j++) {\n      const x = x0 + ((x1 - x0) * j) / m, y = y0 + ((y1 - y0) * j) / m;\n      add(x, y, z, x, y, z, -1, i);\n    }\n  };\n  const arc = (i, cx, cy, a0, a1) => {\n    const L = G.loops[i], m = max(2, ceil((L.rc * abs(a1 - a0)) / STEP));\n    for (let j = 0; j \u003c m; j++) {\n      const t = a0 + ((a1 - a0) * j) / m, x = cx + L.rc * cos(t), y = cy + L.rc * sin(t);\n      add(x, y, L.z, x, y, L.z, -1, i);\n    }\n  };\n  // Loop i from the foot of the braid round the bottom, up the right and\n  // over the top, back to the head of the braid.\n  const around = (i) => {\n    const { l, r, t, b, rc } = G.loops[i];\n    line(i, l, G.bot, l, b - rc);\n    arc(i, l + rc, b - rc, PI, PI / 2);\n    line(i, l + rc, b, r - rc, b);\n    arc(i, r - rc, b - rc, PI / 2, 0);\n    line(i, r, b - rc, r, t + rc);\n    arc(i, r - rc, t + rc, 0, -PI / 2);\n    line(i, r - rc, t, l + rc, t);\n    arc(i, l + rc, t + rc, -PI / 2, -PI);\n    line(i, l, t + rc, l, G.top);\n  };\n  const q = [0, 0, 0];\n  let p = 0, guard = 0;\n  do {\n    let y = G.top;\n    G.cross.forEach((X, k) => {\n      if (X.i !== p && X.i + 1 !== p) return;\n      line(p, G.loops[p].l, y, G.loops[p].l, X.y - G.h);\n      const down = X.i === p, i0 = X.i, i1 = X.i + 1;\n      const m = max(8, ceil(hypot(G.loops[i1].l - G.loops[i0].l, 2 * G.h, G.loops[i1].z - G.loops[i0].z) / STEP));\n      for (let j = 0; j \u003c m; j++) {\n        // Down a strand from loop i to loop i + 1 (or back): its first half\n        // smooths onto the loop it came from, its second onto the other.\n        const w = j / m, u = down ? w : 1 - w, first = w \u003c 0.5;\n        bandPoint(G, k, u, down ? -1 : 1, q);\n        const circ = down === first ? i0 : i1, L = G.loops[circ];\n        add(q[0], q[1], q[2], L.l, X.y - G.h + 2 * w * G.h, L.z, k, circ);\n      }\n      p = down ? i1 : i0;\n      y = X.y + G.h;\n    });\n    line(p, G.loops[p].l, y, G.loops[p].l, G.bot);\n    around(p);\n  } while (p !== 0 && ++guard \u003c 4);\n  const n = P.length, D = new Float32Array(n * 9);\n  let s = 0;\n  P.forEach((e, j) => {\n    for (let t = 0; t \u003c 8; t++) D[j * 9 + t] = e[t];\n    D[j * 9 + 8] = s;\n    const f = P[(j + 1) % n];\n    s += hypot(f[0] - e[0], f[1] - e[1], f[2] - e[2]);\n  });\n  return { D, n, length: s, passes: guard + 1 };\n}\n\nexport function buildKnot(index) {\n  const K = KNOTS[((index % KNOTS.length) + KNOTS.length) % KNOTS.length];\n  const G = layout(K);\n  G.name = K.name;\n  G.word = K.w;\n  G.knot = walk(G);\n  return G;\n}\n\nexport function setup(params) {\n  params.s = {\n    G: null, idx: -1, knob: -1, t: 0, hue: 0, tilt: 0.7,\n    zb: new Float32Array(NPX), rgb: new Float32Array(NPX * 3), hz: new Float32Array(NPX), cz: new Float32Array(NPX),\n    lr: new Float32Array(NPX * 3), gl: new Float32Array(NPX * 3), gv: new Float32Array(NPX * 3), c: [0, 0, 0], q: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 40];\n  const g = (cl(dt || 0, 0, 0.1) * cl(kv[1], 0.2, 3)) / 2;\n  S.hue = cl(kv[0], 0, 1);\n  S.tilt = (cl(kv[3], 40, 80) * PI) / 180;\n  const knob = floor(cl(kv[2], 0, 7) + 1e-6);\n  if (knob !== S.knob) (S.knob = knob), (S.idx = knob), (S.G = buildKnot(knob)), (S.t = 0);\n  S.t += g;\n  if (S.t >= T_NEXT) (S.t -= T_NEXT), (S.idx += 1), (S.G = buildKnot(S.idx));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.G) return;\n  const G = S.G, t = S.t, { zb, rgb, hz, cz, lr, c: col, q } = S;\n  const n = G.n, nc = G.c;\n  // The view turns about the panel's upright middle: a fifth of the Tilt\n  // while the knot and its circles are drawn, out to the whole Tilt as the\n  // discs come in, then rocking between the two while the surface is whole.\n  const tl = S.tilt;\n  let phi = tl * (0.18 + 0.06 * sin(t * 1.3));\n  if (t > T_DISCS) phi += (tl - phi) * ease((t - T_DISCS) / 2);\n  if (t > T_DONE) phi = tl * (0.6 + 0.4 * cos((PI * (t - T_DONE)) / 1.9));\n  const cp = cos(phi), sp = sin(phi);\n  const fade = t > T_FADE ? 1 - ease((t - T_FADE) / (T_NEXT - T_FADE - 0.05)) : 1;\n  const smooth = ease((t - T_SMOOTH) / 1.4);\n  const bandOf = (k) => ease((t - T_BANDS - (k * 2.4) / max(1, nc - 1)) / 0.6);\n  const discOf = (i) => ease((t - T_DISCS - 0.4 * i) / 0.8);\n  zb.fill(-1e9);\n  rgb.fill(0);\n  hz.fill(-1e9);\n  cz.fill(-1e9);\n  lr.fill(0);\n  const H0 = S.hue;\n  // Two faces: the face every disc turns to the viewer is blue to violet,\n  // a shade per disc; the other face is gold.\n  const face = (i, v, out) => hsv(H0 + 0.58 + 0.09 * i, 0.75, v, out);\n  const other = (v, out) => hsv(H0 + 0.12, 0.85, v, out);\n  // Discs: each LED is taken back through the turn onto each disc's plane,\n  // and the nearest disc that holds it wins.\n  for (let i = 0; i \u003c n; i++) {\n    const A = discOf(i);\n    if (A \u003c= 0) continue;\n    const L = G.loops[i];\n    if (cp > 0) face(i, 0.62 * A * fade, col);\n    else other(0.62 * A * fade, col);\n    const mx = (L.l + L.r) / 2, hw = (L.r - L.l) / 2 - L.rc, my = (L.t + L.b) / 2, hh = (L.b - L.t) / 2 - L.rc;\n    // Only the columns the turned disc can reach.\n    const xa = max(0, floor(32 + min(L.l * cp, L.r * cp) + L.z * sp - 1)), xb = min(W - 1, ceil(32 + max(L.l * cp, L.r * cp) + L.z * sp + 1));\n    const ic = 1 / cp, off = 32 + L.z * sp, r2 = L.rc * L.rc, kx = 0.6 / (L.r - L.l), ky = 0.6 / (L.b - L.t);\n    for (let y = max(0, floor(L.t)); y \u003c= min(H - 1, ceil(L.b)); y++) {\n      const dy = abs(y + 0.5 - my) - hh;\n      if (dy > L.rc) continue;\n      const sy = 1 - (y - L.t) * ky;\n      for (let x = xa; x \u003c= xb; x++) {\n        const xm = (x + 0.5 - off) * ic;\n        const dx = abs(xm - mx) - hw;\n        if (dx > L.rc || (dx > 0 && dy > 0 && dx * dx + dy * dy > r2)) continue;\n        const d = -xm * sp + L.z * cp, p = y * W + x;\n        if (d \u003c= zb[p]) continue;\n        zb[p] = d;\n        // A soft light from the upper left.\n        const shade = 0.78 + 0.22 * cl(sy - (xm - L.l) * kx, 0, 1);\n        rgb[p * 3] = col[0] * shade;\n        rgb[p * 3 + 1] = col[1] * shade;\n        rgb[p * 3 + 2] = col[2] * shade;\n      }\n    }\n  }\n  // Bands, sampled finely and splatted with the depth test. Where a band\n  // turns to the viewer the face the discs show, it takes their colour;\n  // where its half twist shows the other face, gold.\n  for (let k = 0; k \u003c nc; k++) {\n    const B = bandOf(k);\n    if (B \u003c= 0) continue;\n    const X0 = G.cross[k], A = G.loops[X0.i], Bl = G.loops[X0.i + 1], hb = G.h, e = -X0.sg;\n    const ddx = Bl.l - A.l, ddz = Bl.z - A.z;\n    const NU = ceil(hypot(ddx, ddz) * 1.6), NV = ceil(hb * 3.2);\n    for (let iu = 0; iu \u003c= NU; iu++) {\n      const u = iu / NU, cu = cos(PI * u), su = sin(PI * u);\n      const x = A.l + u * ddx, zc = A.z + u * ddz;\n      for (let iv = 0; iv \u003c= NV; iv++) {\n        const v = -1 + (2 * iv) / NV;\n        const y = X0.y + v * hb * cu, z = zc + v * hb * e * su;\n        const X = 32 + x * cp + z * sp, d = -x * sp + z * cp;\n        const px = floor(X), py = floor(y);\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const p = py * W + px;\n        if (d \u003c= zb[p]) continue;\n        // The face's normal, d/du x d/dv; the band is oriented to agree\n        // with the disc it runs into at u = 1.\n        const uy = -v * hb * PI * su, uz = ddz + v * hb * e * PI * cu, vy = hb * cu, vz = hb * e * su;\n        const nx = uy * vz - uz * vy, nz = ddx * vy;\n        const lit = 0.7 + (0.3 * abs(-nx * sp + nz * cp)) / (hypot(nx, nz) + 1e-9);\n        if (nx * sp - nz * cp > 0) face(X0.i + u, 0.85 * lit * fade, col);\n        else other(0.95 * lit * fade, col);\n        // A band coming in shows through to what lies behind it.\n        if (B > 0.5) zb[p] = d;\n        rgb[p * 3] += (col[0] - rgb[p * 3]) * B;\n        rgb[p * 3 + 1] += (col[1] - rgb[p * 3 + 1]) * B;\n        rgb[p * 3 + 2] += (col[2] - rgb[p * 3 + 2]) * B;\n      }\n    }\n  }\n  // The curve. The points of the crossing strands first mark the LEDs round\n  // them as passed at their depth; then a point draws its core only where\n  // nothing a good way nearer passes close by, which leaves the gap of an\n  // under-crossing.\n  const KD = G.knot.D, KN = G.knot.n, len = G.knot.length;\n  const drawn = t \u003c T_HOLD ? len * ease(t / T_HOLD) : len + 1;\n  const pos = (j, out) => {\n    const o = j * 9, k = KD[o + 6];\n    const m = k >= 0 ? smooth * (1 - bandOf(k)) : 0;\n    out[0] = KD[o] + (KD[o + 3] - KD[o]) * m;\n    out[1] = KD[o + 1] + (KD[o + 4] - KD[o + 1]) * m;\n    out[2] = KD[o + 2] + (KD[o + 5] - KD[o + 2]) * m;\n  };\n  for (let j = 0; j \u003c KN; j++) {\n    if (KD[j * 9 + 8] > drawn) break;\n    if (KD[j * 9 + 6] \u003c 0) continue;\n    pos(j, q);\n    const X = 32 + q[0] * cp + q[2] * sp, d = -q[0] * sp + q[2] * cp, Y = q[1];\n    for (let yy = max(0, floor(Y - 2.6)); yy \u003c= min(H - 1, floor(Y + 2.6)); yy++)\n      for (let xx = max(0, floor(X - 2.6)); xx \u003c= min(W - 1, floor(X + 2.6)); xx++) {\n        const ex = xx + 0.5 - X, ey = yy + 0.5 - Y;\n        if (ex * ex + ey * ey > 6.76) continue;\n        const p = yy * W + xx;\n        if (d > hz[p]) hz[p] = d;\n      }\n  }\n  // One knot in white, then its Seifert circles each in its disc's colour,\n  // then white again as the bands make it the surface's edge. A bright run\n  // goes round it the way it is oriented.\n  const circ = ease((t - T_SMOOTH) / 0.8) * (1 - ease((t - T_BANDS) / 2.6));\n  const runAt = ((t * 40) % (len + 60)) - 30;\n  // The knot is a pale tint of the gold face; it draws thinner once it is\n  // the edge of the surface.\n  const pale = [0, 0, 0];\n  hsv(H0 + 0.12, 0.22, 0.95, pale);\n  const rad = 1.2 - 0.4 * ease((t - T_BANDS) / 2);\n  for (let j = 0; j \u003c KN; j++) {\n    const o = j * 9, s = KD[o + 8];\n    if (s > drawn) break;\n    pos(j, q);\n    const X = 32 + q[0] * cp + q[2] * sp, d = -q[0] * sp + q[2] * cp, Y = q[1];\n    hsv(H0 + 0.58 + 0.09 * KD[o + 7], 0.5, 1, col);\n    const run = t \u003c T_SMOOTH || t > T_DONE ? cl(1 - abs(s - runAt) / 16, 0, 1) : 0;\n    const wv = (1 - circ) * (1 - 0.45 * run);\n    const tip = t \u003c T_HOLD ? cl(1 - (drawn - s) / 12, 0, 1) : 0;\n    const r = col[0] * circ + wv * pale[0] + run * 1.0 * (1 - circ) + tip;\n    const gg = col[1] * circ + wv * pale[1] + run * 0.75 * (1 - circ) + tip;\n    const bb = col[2] * circ + wv * pale[2] + run * 0.2 * (1 - circ) + tip;\n    for (let yy = max(0, floor(Y - rad)); yy \u003c= min(H - 1, floor(Y + rad)); yy++)\n      for (let xx = max(0, floor(X - rad)); xx \u003c= min(W - 1, floor(X + rad)); xx++) {\n        const ex = xx + 0.5 - X, ey = yy + 0.5 - Y;\n        if (ex * ex + ey * ey > rad * rad) continue;\n        const p = yy * W + xx;\n        if (d \u003c hz[p] - 3 || d \u003c zb[p] - 3 || d \u003c cz[p]) continue;\n        cz[p] = d;\n        lr[p * 3] = r * fade;\n        lr[p * 3 + 1] = gg * fade;\n        lr[p * 3 + 2] = bb * fade;\n      }\n  }\n  // A faint glow round the curve where nothing else is lit: the curve\n  // blurred over five LEDs each way, a row pass and then a column pass.\n  const { gl, gv } = S, glow = t \u003c T_DISCS + 2;\n  if (glow) {\n    for (let y = 0; y \u003c H; y++)\n      for (let ch = 0; ch \u003c 3; ch++) {\n        let acc = 0;\n        for (let x = -2; x \u003c W; x++) {\n          if (x + 2 \u003c W) acc += lr[(y * W + x + 2) * 3 + ch];\n          if (x - 3 >= 0) acc -= lr[(y * W + x - 3) * 3 + ch];\n          if (x >= 0) gl[(y * W + x) * 3 + ch] = acc;\n        }\n      }\n    for (let x = 0; x \u003c W; x++)\n      for (let ch = 0; ch \u003c 3; ch++) {\n        let acc = 0;\n        for (let y = -2; y \u003c H; y++) {\n          if (y + 2 \u003c H) acc += gl[((y + 2) * W + x) * 3 + ch];\n          if (y - 3 >= 0) acc -= gl[((y - 3) * W + x) * 3 + ch];\n          if (y >= 0) gv[(y * W + x) * 3 + ch] = acc * 0.035;\n        }\n      }\n  }\n  for (let p = 0; p \u003c NPX; p++) {\n    const src = cz[p] > -1e8 ? lr : zb[p] > -1e8 || !glow ? rgb : gv;\n    const o = p * 3;\n    display.setPixel(p % W, (p / W) | 0, (255 * cl(src[o], 0, 1)) | 0, (255 * cl(src[o + 1], 0, 1)) | 0, (255 * cl(src[o + 2], 0, 1)) | 0);\n  }\n}\n","voderberg-tiling":"// ===== Patternflow pattern =====\n// Title:   Voderberg Tiling\n// Family:  cells\n// Idea:    Copies of Voderberg's nine-sided tile, a 12-degree sliver with a barb at its point, lie in his two-armed spiral: each cycle opens close on the middle, where two tiles shut a third in and then two shut in a pair, then backs out while the tiling grows tile by tile along its arms, turns slowly with the colour running out along each arm, and unwinds from the middle.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Voderberg's tile and spiral tiling (Heinz Voderberg, 1936), spiral tilings in Tilings and Patterns (Branko Grünbaum and G. C. Shephard, 1987), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=16..44, Arms=2..6\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 one arm runs from teal at the middle to blue at the rim and the other from violet to rose; a tile that points in is a fifth darker than one that points out, each tile brightens toward its wide end, and the grout is dark. The colours also creep a quarter of the way round the wheel in a cycle and move on a step between cycles.\n// Knob 2: Speed. At 2 a cycle takes 34 seconds: 2.2 on the four tiles at the middle, 8 for the tiling to grow out to the rim while the view backs out, 20 of the whole spiral turning at 3 degrees a second with a slow wave of light running out along the arms, and 4 to unwind from the middle. Tiles not yet laid show at a seventh of their brightness. 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Size. How long one tile is once the view has backed out: 16 LEDs at the opening, about 300 tiles on the panel and two turns of each arm from the middle to the top edge, up to 44 LEDs and about 40 tiles. At the start of a cycle a tile is 64 LEDs plus 1.4 times this long, 86 at the opening.\n// Knob 4: Arms. 2 is Voderberg's own spiral: below the middle the tiles lie in rings round one point and above it in the same rings turned half round, slipped one ring along, so each ring runs on into the next and two arms wind out. 4 and 6 slip the rings two and three rings along, four and six arms of the same tile; the knob rounds to 2, 4 or 6. Only the 2-arm spiral holds the four tiles of the opening, so 4 and 6 go straight to the growth.\n\nconst W = 64, H = 128, NPX = W * H;\nconst { floor, ceil, min, max, cos, sin, sqrt, atan2, round, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\nconst EPS = (12 * PI) / 180;\n// Rings of tiles built round each centre; ten reach past the corners of the\n// panel at the smallest size.\nconst NRING = 10;\n// The cycle, in seconds at Speed 2.\nconst INTRO = 2.2, GROW = 8, HOLD_END = 30, UNWIND = 4, CYCLE = HOLD_END + UNWIND;\n// At the opening a tile is 64 LEDs long plus 1.4 times the knob's size.\nconst L_INTRO = 64, L_INTRO_K = 1.4;\n// Tiles not yet laid, or already taken up, show faintly at this level.\nconst GHOST = 0.14;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nconst rot = (p, a) => [p[0] * cos(a) - p[1] * sin(a), p[0] * sin(a) + p[1] * cos(a)];\n\n// Voderberg's nonagon. Z is the apex, ZT = 1 and U is T turned 12 degrees\n// about Z, so ZTU is the thin isosceles triangle; S is the middle of ZT and\n// R is S turned back 12 degrees. The tile's two long sides are the chain\n// Z a1 a2 a3 T and the same chain turned 12 degrees about Z, Z b1 b2 b3 U,\n// so 30 tiles turned about Z close up into a regular 30-gon, and its other\n// side U T is the triangle's base. b1 = T + Z - U makes Z b1 T U a\n// parallelogram, and the chain Z b1 b2 b3 U T is the same chain read\n// backwards after a half turn about S (so S lies on b2 b3), which lets a\n// tile and its half turn about S fit against each other along all five of\n// those edges. The one point left free, a2, is fixed by one more ruler and\n// compass step: on the line through a1 square to RS (so the corner at a1\n// is square) at distance ZT from U. a3 is a2 turned half round R.\n// Angles: 12 at Z, 90 at a1 and U, 158.67 at a2 and b2, 201.33 at a3 and\n// b3, 78 at T, 270 at b1; the area is that of the triangle, sin(12)/2.\nexport function voderbergTile() {\n  const T = [1, 0], U = rot(T, EPS), R = rot([0.5, 0], -EPS);\n  const b1 = [T[0] - U[0], T[1] - U[1]], a1 = rot(b1, -EPS);\n  const d = [cos(-EPS / 2), sin(-EPS / 2)];\n  const f = [a1[0] - U[0], a1[1] - U[1]];\n  const B = f[0] * d[0] + f[1] * d[1], C = f[0] * f[0] + f[1] * f[1] - 1;\n  const t = -B - sqrt(B * B - C);\n  const a2 = [a1[0] + t * d[0], a1[1] + t * d[1]];\n  const a3 = [2 * R[0] - a2[0], 2 * R[1] - a2[1]];\n  return [[0, 0], a1, a2, a3, T, U, rot(a3, EPS), rot(a2, EPS), b1];\n}\n\n// The tiling. Round a centre the tiles lie in rings one tile long: ring 0 is\n// the 30 tiles turned about Z; in ring r, the tile of ring 0 turned j times\n// is moved out r times its own ZT and then 0..r times its barb edge Z a1,\n// and between two such neighbours sits the half turn of the first about\n// the middle of its a2 a3 edge, pointing in (ring r holds 30 (2r + 1)\n// tiles, which is its area over the tile's). Voderberg's spiral takes\n// the lower half of these rings round Z and the upper half of the same\n// rings turned half round a point slipped one ring along ZT: ring r below\n// runs on into ring r + 1 above, so the rings become two arms. A slip of k\n// rings gives 2k arms. Each tile keeps s = ring + k * (angle / 180), its\n// place along its arm, which grows by 2k a turn.\nexport function buildTiling(k) {\n  const X = voderbergTile();\n  const list = [];\n  const push = (poly, ring, kind) => {\n    let mx = 0, my = 0;\n    for (const p of poly) (mx += p[0]), (my += p[1]);\n    if (my >= 0) return -1;\n    list.push({ poly, ring, kind, mx: mx / 9, my: my / 9 });\n    return list.length - 1;\n  };\n  const special = [push(X, 0, 0), -1];\n  for (let j = 1; j \u003c 30; j++) {\n    const at = push(X.map((p) => rot(p, j * EPS)), 0, 0);\n    if (j === 29) special[1] = at;\n  }\n  for (let r = 1; r \u003c= NRING; r++)\n    for (let j = 0; j \u003c 30; j++) {\n      const F = X.map((p) => rot(p, j * EPS));\n      const uj = rot([1, 0], j * EPS), um = rot([1, 0], (j - 1) * EPS);\n      for (let i = 0; i \u003c= r; i++) {\n        const sx = r * uj[0] + i * (um[0] - uj[0]), sy = r * uj[1] + i * (um[1] - uj[1]);\n        const O = F.map((p) => [p[0] + sx, p[1] + sy]);\n        push(O, r, 1);\n        if (i \u003c r) {\n          const rx = O[2][0] + O[3][0], ry = O[2][1] + O[3][1];\n          push(O.map((p) => [rx - p[0], ry - p[1]]), r, 2);\n        }\n      }\n    }\n  const half = list.length, n = 2 * half, c = k / 2;\n  // Coordinates are centred on the spiral's middle, half way between Z and\n  // the slipped centre. Per tile: centre x, y, reach, s, arm parity, kind.\n  const V = new Float32Array(n * 18), info = new Float32Array(n * 6);\n  list.forEach((t, a) => {\n    const th = -atan2(t.my, t.mx);\n    for (let h = 0; h \u003c 2; h++) {\n      const id = a + h * half, mx = h ? c - t.mx : t.mx - c, my = h ? -t.my : t.my;\n      let rad = 0;\n      for (let q = 0; q \u003c 9; q++) {\n        const x = h ? c - t.poly[q][0] : t.poly[q][0] - c, y = h ? -t.poly[q][1] : t.poly[q][1];\n        V[id * 18 + q * 2] = x;\n        V[id * 18 + q * 2 + 1] = y;\n        rad = max(rad, hypot(x - mx, y - my));\n      }\n      info[id * 6] = mx;\n      info[id * 6 + 1] = my;\n      info[id * 6 + 2] = rad;\n      info[id * 6 + 3] = t.ring + (k * th) / PI;\n      info[id * 6 + 4] = (t.ring + (h ? k : 0)) & 1;\n      info[id * 6 + 5] = t.kind;\n    }\n  });\n  // X, A = X turned -12 degrees about Z, B = X turned half round S, A' = A\n  // turned half round S: A and B shut X in, A and A' shut in X and B.\n  return { n, V, info, X: special[0], A: special[1], B: special[0] + half, A2: special[1] + half };\n}\n\nexport function setup(params) {\n  params.s = {\n    k: 0, T: null, sizeFor: 0, sVis: 6, id: new Int32Array(NPX), shade: new Float32Array(NPX),\n    c: 0, turn: 0, dir: 1, hue0: 0, P: new Float32Array(18), xs: new Float32Array(12), rgb: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 16, 2];\n  const g = (cl(dt || 0, 0, 0.1) * cl(kv[1], 0.2, 3)) / 2;\n  S.hue = cl(kv[0], 0, 1);\n  S.size = cl(kv[2], 16, 44);\n  const k = cl(round(cl(kv[3], 2, 6) / 2), 1, 3);\n  if (k !== S.k) (S.k = k), (S.T = buildTiling(k)), (S.sizeFor = 0);\n  if (S.size !== S.sizeFor) {\n    // The furthest place along the arms that the panel shows at this size,\n    // whichever way the tiling is turned: the growth ends there.\n    const reach = hypot(32, 64) / S.size, info = S.T.info;\n    S.sVis = 0;\n    for (let t = 0; t \u003c S.T.n; t++)\n      if (hypot(info[t * 6], info[t * 6 + 1]) - info[t * 6 + 2] \u003c reach) S.sVis = max(S.sVis, info[t * 6 + 3]);\n    S.sizeFor = S.size;\n  }\n  S.c += g;\n  S.turn += g * 0.05 * S.dir;\n  if (S.c >= CYCLE) {\n    // A new cycle: the colours move on a step and the turn reverses.\n    S.c -= CYCLE;\n    S.dir = -S.dir;\n    S.hue0 += 0.08 + 0.1 * Math.random();\n    S.turn = (Math.random() \u003c 0.5 ? 0 : PI) + 0.4 * (Math.random() - 0.5);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  const { id, shade, P, xs, rgb } = S;\n  const { n, V, info } = S.T, k = S.k, c = S.c;\n  const intro = k === 1 ? INTRO : 0.8;\n  // The view: close on the middle with X standing up, backing out to the\n  // tile size of the knob while the tiling grows.\n  const z = ease((c - intro + 0.4) / (GROW * 0.75));\n  const L = S.size + (L_INTRO + (L_INTRO_K - 1) * S.size) * (1 - z) * (1 - z);\n  const th = PI / 2 + S.turn, ct = cos(th), st = sin(th);\n  // The growth front and the unwinding front run along the arms in s.\n  const front = c \u003c intro ? -1 : 0.2 + ((c - intro) * (S.sVis + 0.4)) / GROW;\n  const back = c \u003c HOLD_END ? -1 : ((c - HOLD_END) * (S.sVis + 0.7)) / (UNWIND - 0.4);\n  const T = S.T;\n  // The opening on the 2-arm spiral: X, then A and B round it, then A' and\n  // B pale too, before the rest grows.\n  const lightX = k === 1 ? ease(c / 0.5) : 0;\n  const lightAB = k === 1 ? ease((c - 0.5) / 0.5) : 0;\n  const lightA2 = k === 1 ? ease((c - 1.25) / 0.5) : 0;\n  const paleX = k === 1 ? 1 - ease((c - 1.95) / 0.45) : 0;\n  const paleB = k === 1 ? ease((c - 1.25) / 0.35) * paleX : 0;\n  const alphaOf = (t) => {\n    const s = info[t * 6 + 3];\n    let a = cl((front - s) / 0.25, 0, 1);\n    if (k === 1) {\n      if (t === T.X) a = max(a, lightX);\n      else if (t === T.A || t === T.B) a = max(a, lightAB);\n      else if (t === T.A2) a = max(a, lightA2);\n    }\n    if (back >= 0) a *= cl((s - back) / 0.6, 0, 1);\n    return a;\n  };\n  id.fill(-1);\n  const cx = 32, cy = 64;\n  for (let t = 0; t \u003c n; t++) {\n    const o = t * 6;\n    const mx = info[o], my = info[o + 1];\n    const px = cx + L * (ct * mx - st * my), py = cy - L * (st * mx + ct * my), pr = L * info[o + 2] + 1;\n    if (px + pr \u003c 0 || px - pr > W || py + pr \u003c 0 || py - pr > H) continue;\n    // Scanline fill of the nonagon: an LED belongs to the tile its centre\n    // falls in. The shade runs from the point (0) to the far end (1).\n    const vo = t * 18;\n    let ymin = 1e9, ymax = -1e9;\n    for (let q = 0; q \u003c 9; q++) {\n      const x = V[vo + q * 2], y = V[vo + q * 2 + 1];\n      P[q * 2] = cx + L * (ct * x - st * y);\n      P[q * 2 + 1] = cy - L * (st * x + ct * y);\n      if (P[q * 2 + 1] \u003c ymin) ymin = P[q * 2 + 1];\n      if (P[q * 2 + 1] > ymax) ymax = P[q * 2 + 1];\n    }\n    const zx = P[0], zy = P[1], ex = P[8] - zx, ey = P[9] - zy, e2 = ex * ex + ey * ey;\n    const y0 = max(0, ceil(ymin - 0.5)), y1 = min(H - 1, floor(ymax - 0.5));\n    for (let y = y0; y \u003c= y1; y++) {\n      const yc = y + 0.5;\n      let m = 0;\n      for (let q = 0; q \u003c 9; q++) {\n        const q2 = q === 8 ? 0 : q + 1;\n        const ax = P[q * 2], ay = P[q * 2 + 1], bx = P[q2 * 2], by = P[q2 * 2 + 1];\n        if ((ay \u003c= yc && yc \u003c by) || (by \u003c= yc && yc \u003c ay)) xs[m++] = ax + ((yc - ay) * (bx - ax)) / (by - ay);\n      }\n      for (let i = 1; i \u003c m; i++) {\n        const v = xs[i];\n        let j = i - 1;\n        while (j >= 0 && xs[j] > v) (xs[j + 1] = xs[j]), j--;\n        xs[j + 1] = v;\n      }\n      for (let i = 0; i + 1 \u003c m; i += 2) {\n        const xa = max(0, ceil(xs[i] - 0.5)), xb = min(W - 1, floor(xs[i + 1] - 0.5));\n        for (let x = xa; x \u003c= xb; x++) {\n          id[y * W + x] = t;\n          shade[y * W + x] = cl(((x + 0.5 - zx) * ex + (yc - zy) * ey) / e2, 0, 1);\n        }\n      }\n    }\n  }\n  // Grout is darker on big tiles, lighter on small ones, so a small tiling\n  // does not go grey.\n  const grout = 0.18 + 0.22 * cl((30 - L) / 14, 0, 1);\n  const wave = c > intro ? 1 : 0;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const t = id[p];\n      if (t \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const o = t * 6, s = info[o + 3], arm = info[o + 4], kind = info[o + 5];\n      const a = alphaOf(t);\n      // Colour runs along each arm with s, and creeps outward with time.\n      const run = (0.045 * s) / k - 0.008 * c;\n      let hue = S.hue + S.hue0 + 0.47 + run + (arm ? 0.36 : 0);\n      let sat = 0.78, val = (kind === 2 ? 0.8 : 1) * (0.72 + 0.28 * shade[p]);\n      val *= 1 - 0.18 * wave * (0.5 + 0.5 * cos(2 * PI * (s / (2 * k) - 0.11 * c)));\n      // The tiles of the opening: pale X (and B), A and B bright.\n      if (k === 1 && paleX > 0) {\n        if (t === T.X || (t === T.B && paleB > 0)) sat *= 1 - 0.85 * (t === T.X ? paleX : paleB);\n      }\n      // A new tile flashes pale as it lands.\n      const fresh = front > 0 && a > 0 ? cl(1 - (front - s) / 0.5, 0, 1) : 0;\n      sat *= 1 - 0.6 * fresh;\n      hsv(hue, sat, val, rgb);\n      const seam = (x \u003c W - 1 && id[p + 1] !== t) || (y \u003c H - 1 && id[p + W] !== t) || (x > 0 && id[p - 1] \u003c 0) || (y > 0 && id[p - W] \u003c 0);\n      const kk = (GHOST + (1 - GHOST) * a) * (seam ? grout : 1) * 255;\n      display.setPixel(x, y, (rgb[0] * kk) | 0, (rgb[1] * kk) | 0, (rgb[2] * kk) | 0);\n    }\n}\n","wigner-cat":"// ===== Patternflow pattern =====\n// Title:   Wigner Cat\n// Family:  wave\n// Idea:    The Wigner function of light in a Kerr medium glows on a slowly turning phase plane, warm where it is positive and cool where it is negative, as one coherent lump splits at the fractional revivals into Schrodinger cats of 2, 3 and 4 lumps round a circle with bands of interference fringes between every pair, shears through a rosette into one lump on the far side at half the revival time and comes back down the sequence.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Wigner quasi-probability function (Eugene Wigner, 1932), the two-lump cat of a Kerr medium (Bernard Yurke and David Stoler, 1986), its cats of n lumps at the fractional revivals (K. Tara, G. S. Agarwal and S. Chaturvedi, 1993), Husimi's Q function as a smoothed Wigner function (Kodi Husimi, 1940), pattern round 59\n// Round:   59\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Decoherence=0..1, Amplitude=2..3.2\n//\n// Knob 1: Hue. Turns both signs round the wheel together. At 0 the positive lumps and fringes are rose with pale peaks and the negative fringes azure; at 0.25 lime and violet, at 0.5 aqua and orange, at 0.75 violet and green.\n// Knob 2: Speed. At 2 the phase plane turns once in 24 seconds, and the Kerr clock holds each cat 3.2 seconds, each single lump 1.6, and takes 1.3 to move on, so the cycle 1, 2, 3, 4, far lump, 4, 3, 2 takes 33 seconds and starts each time at a new angle; at 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Decoherence. Random Gaussian kicks to the field, of variance s2 = 0.5 x knob^2 in x and in p, which smooths W with a Gaussian of that variance. At 0 the state is pure and the 2-lump cat's fringes swing to 1.9 times the lump height either side of zero; at 0.25 they keep 61% of that and the lumps 94% of theirs, at 0.5 the fringes keep 14% and the lumps 80%. At 1 the variance is the vacuum's own, W has become Husimi's Q function and is nowhere negative: lumps alone, twice as wide.\n// Knob 4: Amplitude. |alpha| of the starting coherent state, 2 to 3.2, a mean of 4 to 10 photons. The plane is scaled to keep the circle on the panel: at 2 a lump is 14 LEDs wide and 28 tall to 1/e, the 2-lump cat's fringes 8 columns or 16 rows apart, and the cats run to 4 lumps; at 3.2 a lump is 10 wide, the fringes 3.5 columns apart, and the cats run to 7 lumps before the far lump.\n\nconst W = 64, H = 128, NF = 36;\n// Rows per column for one unit of p against one of x: the phase plane is\n// drawn twice as tall as wide, an oscillator whose orbits are 1:2 ellipses.\nconst STRETCH = 2;\n// At Speed 2: one turn of the plane, the hold at a stop and the move between stops, in seconds.\nconst TURN = 24, HOLD = 3.2, MOVE = 1.3;\nconst LMAX = 168, GAMMA = 1.35, TOP = 0.72, HUE_POS = 0.985, HUE_NEG = 0.57;\nconst { floor, ceil, min, max, abs, sqrt, exp, cos, sin, asin, PI, SQRT2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Units: x = (a + a^dagger)/sqrt2, p = (a - a^dagger)/(i sqrt2), hbar = 1,\n// so the coherent state |alpha> sits at x = sqrt2 Re alpha, p = sqrt2 Im\n// alpha and its Wigner function is exp(-(x - x0)^2 - (p - p0)^2) / pi.\n//\n// The grid, rebuilt when the amplitude changes: column i is x_i = (i -\n// 31.5) h, row r is p_r = (63.5 - r) h / STRETCH. The Wigner transform\n//   W(x, p) = (1/pi) Int psi*(x + y) psi(x - y) e^(2ipy) dy\n// is summed over y_j = j h, which puts x +- y on the same grid of columns,\n// extended J columns each side. A sum with step h repeats W every pi / h\n// in p, 16 or more, where W has long died away, so it is exact.\nfunction build(S, a) {\n  S.a = a;\n  const X0 = SQRT2 * a, kx = 31 / (X0 + 1.55), h = 1 / kx;\n  // psi ~ exp(-(x - x0)^2 / 2) has fallen to 3e-4 four units out.\n  const J = ceil((X0 + 4) * kx), G = W + 2 * J;\n  S.kx = kx;\n  S.h = h;\n  S.J = J;\n  S.G = G;\n  // Hermite functions phi_k(x) by their three-term recurrence.\n  const phi = (S.phi = new Float64Array(NF * G));\n  for (let m = 0; m \u003c G; m++) {\n    const x = (m - J - 31.5) * h;\n    let p0 = PI ** -0.25 * exp((-x * x) / 2), p1 = SQRT2 * x * p0;\n    phi[m] = p0;\n    phi[G + m] = p1;\n    for (let k = 1; k + 1 \u003c NF; k++) {\n      const p2 = sqrt(2 / (k + 1)) * x * p1 - sqrt(k / (k + 1)) * p0;\n      phi[(k + 1) * G + m] = p2;\n      p0 = p1;\n      p1 = p2;\n    }\n  }\n  // |\u003ck|alpha>| = e^(-|alpha|^2/2) alpha^k / sqrt(k!).\n  const amp = (S.amp = new Float64Array(NF));\n  amp[0] = exp((-a * a) / 2);\n  for (let k = 1; k \u003c NF; k++) amp[k] = (amp[k - 1] * a) / sqrt(k);\n  // cos and sin of 2 p_r y_j.\n  const J1 = J + 1;\n  S.C = new Float32Array(H * J1);\n  S.Sn = new Float32Array(H * J1);\n  for (let r = 0; r \u003c H; r++) {\n    const p = ((63.5 - r) * h) / STRETCH;\n    for (let j = 0; j \u003c J1; j++) {\n      const t = 2 * p * j * h;\n      S.C[r * J1 + j] = cos(t);\n      S.Sn[r * J1 + j] = sin(t);\n    }\n  }\n  S.pr = new Float64Array(G);\n  S.pi = new Float64Array(G);\n  S.gr = new Float64Array(J1);\n  S.gi = new Float64Array(J1);\n  S.damp = new Float64Array(J1);\n  S.s2 = -1;\n  // How many cats before the far lump: lumps 2 alpha sin(pi/n) apart, at\n  // least five of their own standard deviations (1/2 in units of alpha).\n  // Closer than that the fringes of neighbours run over the lumps and the\n  // cat reads as a rosette; those cats still pass on the way to u = 1/2.\n  S.N = cl(floor(PI / asin(min(1, 1.25 / a))), 3, 8);\n  S.k = min(S.k, 2 * S.N - 1);\n}\n\n// The Kerr clock. Under H = K n^2 the coherent state picks up the phase\n// e^(-i K t k^2) on |k>. At K t = 2 pi m / q that phase is periodic in k\n// with period q, so it is a finite Fourier sum and the state is a sum of\n// coherent states round the circle: Yurke and Stoler's cats. At u = K t /\n// 2 pi = (n - 1) / (2n) exactly n of the coefficients are non-zero, so the\n// stops u = 0, 1/4, 1/3, 3/8, 2/5 ... hold cats of 1, 2, 3, 4, 5 lumps;\n// they crowd towards u = 1/2, where e^(-i pi k^2) = (-1)^k is the single\n// lump at -alpha, and the mirror stops 1 - u bring them back to the full\n// revival at u = 1.\n//\n// For such a sum psi = sum_j b_j |alpha_j> the Wigner function has a closed\n// form, from W(beta) = (2/pi) \u003cpsi| D(beta) (-1)^n D(beta)^dagger |psi>:\n//   W(beta) = (2/pi) sum_jk b_j* b_k \u003calpha_j|alpha_k> e^(-2 (beta - alpha_j)* (beta - alpha_k)),\n// beta = (x + ip)/sqrt2, a Gaussian lump for j = k and a Gaussian times\n// fringes for j != k. The transform below works at every u, between the\n// cats too, and at the cats it agrees with this sum to 2e-7.\nfunction stopU(N, k) {\n  if (k \u003c= 0 || k >= 2 * N) return k \u003c= 0 ? 0 : 1;\n  if (k \u003c N) return k / (2 * (k + 1));\n  if (k === N) return 0.5;\n  const n = 2 * N - k + 1;\n  return 1 - (n - 1) / (2 * n);\n}\n\nexport function setup(params) {\n  params.s = {\n    a: -1, k: 1, ph: HOLD - 1.2, th: 0.6, u: 0.25, wref: 0,\n    Wg: new Float32Array(W * H), tmp: new Float32Array(W), cr: new Float64Array(NF), ci: new Float64Array(NF),\n    pos: [0, 0, 0], neg: [0, 0, 0], hue: -1,\n  };\n}\n\n// The Fock coefficients at Kerr time u, turned by th: the free oscillator\n// adds e^(-i th k), which turns the whole plane clockwise.\nfunction kerr(S, u, th) {\n  const { amp, cr, ci } = S;\n  for (let k = 0; k \u003c NF; k++) {\n    const q = u * k * k, ph = -2 * PI * (q - floor(q)) - th * k;\n    cr[k] = amp[k] * cos(ph);\n    ci[k] = amp[k] * sin(ph);\n  }\n}\n\n// W on the grid for the state with Fock coefficients S.cr, S.ci; s2 is the\n// variance of the Gaussian that smooths it. Smoothing in p is the factor\n// exp(-2 s2 y^2) under the y integral; smoothing in x is a blur along each\n// row.\nfunction wigner(S, s2) {\n  const { G, J, h, phi, cr, ci, pr, pi, gr, gi, C, Sn, damp, Wg } = S, J1 = J + 1;\n  pr.fill(0);\n  pi.fill(0);\n  for (let k = 0; k \u003c NF; k++) {\n    const o = k * G, a = cr[k], b = ci[k];\n    if (abs(a) + abs(b) \u003c 1e-12) continue;\n    for (let m = 0; m \u003c G; m++) {\n      const f = phi[o + m];\n      pr[m] += a * f;\n      pi[m] += b * f;\n    }\n  }\n  if (s2 !== S.s2) {\n    S.s2 = s2;\n    for (let j = 0; j \u003c J1; j++) damp[j] = (j ? 2 : 1) * exp(-2 * s2 * (j * h) ** 2) * (h / PI);\n    const sg = sqrt(s2) * S.kx, R = ceil(3 * sg);\n    S.ker = new Float64Array(R + 1);\n    for (let d = 0; d \u003c= R; d++) S.ker[d] = exp((-d * d) / (2 * sg * sg));\n  }\n  for (let i = 0; i \u003c W; i++) {\n    const c = i + J;\n    let jm = 0;\n    for (let j = 0; j \u003c J1; j++) {\n      // psi*(x + y) psi(x - y), weighted for the one-sided sum.\n      const ar = pr[c + j], ai = pi[c + j], br = pr[c - j], bi = pi[c - j], d = damp[j];\n      gr[j] = (ar * br + ai * bi) * d;\n      gi[j] = (ar * bi - ai * br) * d;\n      if (abs(gr[j]) + abs(gi[j]) > 1e-7) jm = j + 1;\n    }\n    for (let r = 0, o = 0; r \u003c H; r++, o += J1) {\n      let w = 0;\n      for (let j = 0; j \u003c jm; j++) w += gr[j] * C[o + j] - gi[j] * Sn[o + j];\n      Wg[r * W + i] = w;\n    }\n  }\n  if (s2 > 0) {\n    const ker = S.ker, R = ker.length - 1, tmp = S.tmp;\n    for (let r = 0; r \u003c H; r++) {\n      const o = r * W;\n      for (let x = 0; x \u003c W; x++) {\n        let s = 0, n = 0;\n        for (let d = -R; d \u003c= R; d++) {\n          const xx = x + d;\n          if (xx \u003c 0 || xx >= W) continue;\n          const k = ker[d \u003c 0 ? -d : d];\n          s += k * Wg[o + xx];\n          n += k;\n        }\n        tmp[x] = s / n;\n      }\n      Wg.set(tmp, o);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), dec = cl(kv[2], 0, 1), a = cl(kv[3], 2, 3.2);\n  if (abs(a - S.a) > 1e-4) build(S, a);\n  const g = (d * speed) / 2;\n  S.th += (g * 2 * PI) / TURN;\n  S.ph += g;\n  // A single lump, at the start or at u = 1/2, is held half as long as a cat.\n  let hold = S.k % S.N ? HOLD : HOLD / 2;\n  if (S.ph >= hold + MOVE) {\n    S.ph -= hold + MOVE;\n    S.k = (S.k + 1) % (2 * S.N);\n    hold = S.k % S.N ? HOLD : HOLD / 2;\n  }\n  const u0 = stopU(S.N, S.k), u1 = stopU(S.N, S.k + 1);\n  let e = cl((S.ph - hold) / MOVE, 0, 1);\n  e = e * e * e * (e * (e * 6 - 15) + 10);\n  S.u = u0 + (u1 - u0) * e;\n  kerr(S, S.u, S.th);\n  wigner(S, 0.5 * dec * dec);\n  // The brightest |W| of the frame sets the scale, followed in about a\n  // third of a second: a cat of n lumps has lumps 1/n as high as the\n  // coherent state's, and this keeps the cat of 4 as bright as the cat of 2.\n  let m = 0;\n  for (let p = 0; p \u003c W * H; p++) m = max(m, abs(S.Wg[p]));\n  S.wref = S.wref > 0 ? S.wref + (m - S.wref) * min(1, 3 * d) : m;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.Wg || !S.wref) return;\n  const pos = hsv(HUE_POS + S.hue, 0.72, 1, S.pos), neg = hsv(HUE_NEG + S.hue, 0.85, 1, S.neg);\n  const Wg = S.Wg, k = 1 / (TOP * S.wref);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const w = Wg[p] * k, v = min(1, w \u003c 0 ? -w : w), c = w \u003c 0 ? neg : pos;\n      // The peaks go pale, so a lump reads as a glow rather than a disc.\n      const L = LMAX * v ** GAMMA, wh = 0.4 * v * v * v;\n      display.setPixel(x, y, (L * (c[0] + (1 - c[0]) * wh)) | 0, (L * (c[1] + (1 - c[1]) * wh)) | 0, (L * (c[2] + (1 - c[2]) * wh)) | 0);\n    }\n}\n","beckett-gray":"// ===== Patternflow pattern =====\n// Title:   Beckett-Gray\n// Family:  rhythm\n// Idea:    Six performers are six lanes of a score that scrolls down two rows a beat, so the whole 64-beat cycle of a Beckett-Gray code stands on the panel at once, each lane lit while its performer is on stage, dim when it has just come on and a step brighter each time one before it leaves, until it turns white at the head of the queue and is the next to go, with one lane flashing at the now line on every beat, while the reflected Gray code on a knob sends a performer off out of turn at 26 of its 32 exits, each one marked red.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Beckett-Gray codes (Donald Knuth, 2005), after Samuel Beckett's Quad (1981), with the reflected binary Gray code (Frank Gray, 1953), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Code=0..3, Rows=2..8\n//\n// Knob 1: Hue. Turns the six lane colours round the wheel together. At 0 the lanes run cyan, azure, blue, violet, magenta and pink from left to right; at 0.5 magenta, lime, green, aqua, cyan and azure. The lanes' wheel skips orange and yellow, which read brown in the dim cells at the back of the queue, and red, which marks an exit out of turn. The head of the queue is always near white.\n// Knob 2: Speed. Beats a second: 2 at the opening, so the score moves 4 rows a second and the 64-beat cycle goes round in 32 s; 0.2 is a beat every 5 s, 3 a cycle in 21 s.\n// Knob 3: Code. 0 is a 6-bit Beckett-Gray code: 64 states, one bit a beat, and every one of its 32 exits is the performer on stage longest. 1 is a 5-bit one, 32 beats, so the panel shows two cycles. 2 is four performers, as in Beckett's own Quad: no Beckett-Gray code exists for 4 bits (nor for 3), and this 16-beat cycle is one of the 96 of the 2688 directed cycles through the empty stage that break the rule only once, at the 14th switch, so the panel shows that one red exit four times. 3 is the reflected Gray code on 6 bits, in which 26 of the 32 exits are out of turn: the first lane leaves out of turn at 15 of its 16 exits, the second at 7 of 8, the third at 3 of 4 and the fourth at 1 of 2.\n// Knob 4: Rows. Rows a beat on the panel: 2 at the opening, the whole 64-beat cycle in 128 rows; 4 shows 32 beats, 8 shows 16, each as an 8-row block.\n\nconst W = 64, H = 128;\nconst { floor, exp, max, min, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The now line: rows above it are the beats to come, rows below the beats\n// just gone, and both scroll down through it.\nconst NOW = 96;\n\n// The codes as the bit each beat switches, the last switch closing the\n// cycle back to the empty stage. The two Beckett-Gray codes were found by a\n// depth-first search that lets a performer leave only from the front of the\n// queue; the same search over every 3- and 4-bit cycle finds none. The 4-bit\n// cycle was the first of the fewest-violation ones in a search over all\n// 2688 directed Hamiltonian cycles of the 4-cube through 0.\nconst CODES = [\n  { n: 6, t: \"0102101320102430232415323141502354310402535240415350241314505145\" },\n  { n: 5, t: \"01020132010432104342132340412304\" },\n  { n: 4, t: \"0102131202313203\" },\n  // Frank Gray's reflected code: switch k switches the lowest bit set in\n  // k + 1, and the last one the top bit, back to the empty stage.\n  { n: 6, t: null },\n];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown, and red is kept for the exits out of\n// turn, so the lanes' wheel runs from lime to pink and skips the rest.\nconst wheel = (h) => 0.25 + 0.69 * (h - floor(h));\n\n// Play a code from the empty stage. For every beat: the state, the lane that\n// switched as the beat began and how (1 enters, 2 leaves from the front of\n// the queue, 3 leaves out of turn), and each lane's place in the queue, 0 for\n// the one on stage longest, -1 for off stage. The checks a code must pass are\n// counted on the way and kept with it: each state once, one bit a switch,\n// back to the empty stage after the last switch, and the exits out of turn,\n// none for the two Beckett-Gray codes.\nfunction play(code) {\n  const n = code.n, L = 1 \u003c\u003c n;\n  const t = new Int8Array(L);\n  for (let k = 0; k \u003c L; k++) t[k] = code.t ? code.t.charCodeAt(k) - 48 : k \u003c L - 1 ? 31 - Math.clz32((k + 1) & -(k + 1)) : n - 1;\n  const state = new Int32Array(L), ev = new Int8Array(L), kind = new Int8Array(L), rank = new Int8Array(L * n).fill(-1);\n  const seen = new Uint8Array(L);\n  let s = 0, repeats = 0, multi = 0, out = 0;\n  const queue = [];\n  for (let k = 0; k \u003c= L; k++) {\n    if (k > 0) {\n      const b = t[k - 1];\n      s ^= 1 \u003c\u003c b;\n      const kk = k % L;\n      ev[kk] = b;\n      if (s >> b & 1) (queue.push(b), (kind[kk] = 1));\n      else {\n        const at = queue.indexOf(b);\n        kind[kk] = at === 0 ? 2 : 3;\n        if (at !== 0) out++;\n        queue.splice(at, 1);\n      }\n    }\n    if (k === L) break;\n    state[k] = s;\n    if (seen[s]++) repeats++;\n    for (let r = 0; r \u003c queue.length; r++) rank[k * n + queue[r]] = r;\n  }\n  for (let k = 0; k \u003c L; k++) {\n    const x = state[k] ^ state[(k + 1) % L];\n    if (!x || x & (x - 1)) multi++;\n  }\n  return { n, L, state, ev, kind, rank, out, ok: repeats === 0 && multi === 0 && s === 0 };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, code: -1, rows: 2, beat: 0, speed: 2,\n    codes: CODES.map(play),\n    col: new Float32Array(64 * 6 * 3), red: new Uint8Array(64 * 6), img: new Float32Array(W * H * 3),\n  };\n}\n\n// Lane colours, one a performer, and the colour of a cell by its place in\n// the queue: the newest on stage dimmest and most saturated, a step brighter\n// each place it moves up, near white at the head.\nfunction laneColour(S, C, k, i, out, o) {\n  const r = C.rank[k * C.n + i];\n  if (r \u003c 0) return (out[o] = out[o + 1] = out[o + 2] = 0);\n  const h = wheel(0.38 + 0.12 * i * (6 / C.n) + S.hue);\n  if (r === 0) {\n    hsv(h, 0.22, 1, out, o);\n    return;\n  }\n  hsv(h, min(1, 0.62 + 0.07 * r), max(0.4, 0.92 - 0.12 * (r - 1)), out, o);\n}\n\nfunction colours(S) {\n  const C = S.codes[S.code];\n  for (let k = 0; k \u003c C.L; k++)\n    for (let i = 0; i \u003c C.n; i++) {\n      laneColour(S, C, k, i, S.col, (k * C.n + i) * 3);\n      // The last beat on stage of a performer who leaves out of turn is red.\n      const nx = (k + 1) % C.L;\n      S.red[k * C.n + i] = C.ev[nx] === i && C.kind[nx] === 3 ? 1 : 0;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  const hue = cl(kv[0], 0, 1), code = cl(floor(cl(kv[2], 0, 3) + 0.5), 0, 3);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.rows = cl(kv[3], 2, 8);\n  if (hue !== S.hue || code !== S.code) {\n    S.hue = hue;\n    S.code = code;\n    colours(S);\n  }\n  S.beat += d * S.speed;\n  if (S.beat > 1e6) S.beat -= 64 * 4096;\n}\n\n// Lane i spans [x0, x0 + w).\nfunction lanes(n) {\n  const p = floor(60 / n), w = p - 2, m = (W - n * p) / 2 + 1;\n  return { p, w, m };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.code \u003c 0) return;\n  const C = S.codes[S.code], n = C.n, L = C.L, R = S.rows, b = S.beat, img = S.img;\n  const { p, w, m } = lanes(n);\n  img.fill(0);\n  const mod = (k) => ((k % L) + L) % L;\n  for (let y = 0; y \u003c H; y++) {\n    // Row y covers the beats from lo to hi; a row across a switch mixes the\n    // two beats by how much of the row each takes, so the score slides\n    // smoothly instead of jumping a row at a time.\n    const hi = b + (NOW - y) / R, lo = hi - 1 / R;\n    const k1 = floor(hi), k0 = floor(lo), f = k1 > k0 ? (hi - k1) * R : 1;\n    const a0 = mod(k0), a1 = mod(k1);\n    // The beats gone are dimmer, and the two rows at the now line show the\n    // stage as it stands: performers on it brighter, empty places grey.\n    const past = y >= NOW ? 0.55 : 1, line = y === NOW - 1 || y === NOW;\n    let redRow = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const o0 = (a0 * n + i) * 3, o1 = (a1 * n + i) * 3;\n      let cr = S.col[o1] * f + S.col[o0] * (1 - f), cg = S.col[o1 + 1] * f + S.col[o0 + 1] * (1 - f), cb = S.col[o1 + 2] * f + S.col[o0 + 2] * (1 - f);\n      const red = S.red[a1 * n + i] * f + S.red[a0 * n + i] * (1 - f);\n      if (red > 0) (cr += (1 - cr) * red), (cg -= (cg - 0.12) * red), (cb -= (cb - 0.08) * red);\n      redRow = max(redRow, red);\n      if (line) {\n        if (cr + cg + cb > 0.05) (cr = cr * 0.75 + 0.25), (cg = cg * 0.75 + 0.25), (cb = cb * 0.75 + 0.25);\n        else cr = cg = cb = 0.16;\n      }\n      const x0 = m + i * p;\n      for (let x = x0; x \u003c x0 + w; x++) {\n        const q = (y * W + x) * 3;\n        img[q] = cr * past;\n        img[q + 1] = cg * past;\n        img[q + 2] = cb * past;\n      }\n    }\n    // Exits out of turn are marked in both margins as well.\n    if (redRow > 0) for (const x of [0, 1, W - 2, W - 1]) (img[(y * W + x) * 3] = redRow * past), (img[(y * W + x) * 3 + 1] = 0.1 * redRow * past);\n  }\n  // The pulse: the lane that switched as this beat began flashes at the now\n  // line, white for an entry, its own colour for an exit from the front of\n  // the queue, red for an exit out of turn, and the flash runs out along the\n  // now line to both edges.\n  const kn = mod(floor(b + 1e-9)), ph = b + 1e-9 - floor(b + 1e-9), A = exp(-ph * 2.6);\n  const i = C.ev[kn], kd = C.kind[kn], x0 = m + i * p, xc = x0 + (w - 1) / 2;\n  const pc = [1, 1, 1];\n  if (kd === 2) hsv(wheel(0.38 + 0.12 * i * (6 / n) + S.hue), 0.55, 1, pc, 0);\n  else if (kd === 3) (pc[1] = 0.15), (pc[2] = 0.08);\n  for (let y = NOW - 14; y \u003c NOW + 12; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = max(0, abs(x - xc) - w / 2), dy = y \u003c NOW ? NOW - 1 - y : y - NOW;\n      const g = A * (dx > 0 ? exp(-dx * dx / 8 - dy * dy / 3) + (dy === 0 ? 0.7 * exp(-dx / 12) : 0) : exp(-dy * dy / 40));\n      if (g \u003c 0.01) continue;\n      const q = (y * W + x) * 3;\n      for (let e = 0; e \u003c 3; e++) img[q + e] += (pc[e] - img[q + e]) * min(1, g);\n    }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, (255 * cl(img[q], 0, 1)) | 0, (255 * cl(img[q + 1], 0, 1)) | 0, (255 * cl(img[q + 2], 0, 1)) | 0);\n}\n","hanging-chain":"// ===== Patternflow pattern =====\n// Title:   Hanging Chain\n// Family:  physics\n// Idea:    A chain of 32 beads hangs from the middle of the top row and swings in one of its first five normal modes, the J0 Bessel shapes Daniel Bernoulli found for it, while a fading long exposure behind it fills in the swept envelope with its pinched nodes at the heights the zeros of J0 predict, marked by small ticks.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: small oscillations of a hanging chain (Daniel Bernoulli, 1732), the first appearance of the Bessel function J0, taken up by Leonhard Euler (1781), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mode=1..5, Mix=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the chain is cyan with near-white beads, the exposure behind it blue violet and the node ticks pale yellow; at 0.25 the chain is violet over a pink exposure, at 0.5 red over lime, at 0.75 yellow green over teal. The dim exposure skips the orange and yellow part of the wheel, which reads brown and olive.\n// Knob 2: Speed. At 2 the first mode swings once every 2.4 seconds, as a chain 2.1 m long would in real time, and the fifth once every 0.39 s; 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Mode. Which normal mode the chain is let go in, rounded to a whole number 1 to 5. Mode n has n - 1 nodes, at 19% of the way up from the free end for mode 2, at 8% and 41% for mode 3, and for mode 5 at 3%, 14%, 34% and 62%, and swings j(0,n) / j(0,1) times as often as the first: 2.296, 3.601, 4.910 and 6.222 times on these 32 beads, against 2.295, 3.599, 4.903 and 6.209 for the continuous chain.\n// Knob 4: Mix. How much of the other four modes is let go with the chosen one. At 0 the chain holds one mode and the exposure settles into its clean envelope; at the opening 0.06 each other mode comes in at a tenth of the chosen one's swing at the free end and the chain shivers as it swings; at 1 all five come in equally and, since their frequencies are not in whole ratios, the chain's shape never repeats.\n// Buttons: K1 tap lets the chain go again from its starting shape.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, round, abs, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The first five zeros of J0.\nconst J0Z = [2.404826, 5.520078, 8.653728, 11.791534, 14.930918];\n// Beads, and where the chain hangs on the panel. The suspension is row 0\n// and bead k hangs k links below it. With all the mass in the beads, the\n// link above bead k carries the weight of the N - k + 1 beads below it,\n// which is what a continuous chain carries at the middle of that link if\n// its free end sits half a link below the last bead. So the continuous\n// chain this one stands for is N + 1/2 links long, its free end at row 125.\nconst N = 32, YFREE = 125, LPX = YFREE / (N + 0.5);\nconst CX = 31.5, HALF = 29;\n// Chain time is measured in units of sqrt(l / g), one link's own time.\n// The first mode swings once every 29.8 units; RATE units a second at\n// Speed 1 make that 2.4 s at Speed 2.\nconst RATE = 6.2;\n// The leapfrog step, in chain units. The stiffest mode of 32 beads has\n// omega near 11.3, so the step must stay below 2 / 11.3 = 0.18; at 0.03\n// the energy stays within 3e-4 of where it started.\nconst HSTEP = 0.03;\n// The exposure fades by e every TAU chain units, about one swing of the\n// first mode.\nconst TAU = 30;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Tension in the link above bead k, in bead weights; zero below the last.\nconst T = (k) => (k \u003c= N ? N - k + 1 : 0);\n// Dim orange and yellow read brown and olive, so the exposure's wheel\n// skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\n// The linearised bead chain is x'' = -K x with K tridiagonal:\n//   (K x)_k = T_k (x_k - x_{k-1}) + T_{k+1} (x_k - x_{k+1}),  x_0 = 0.\n// A mode with K v = lambda v is found by running that row from the free\n// end upward with v_N = 1: the row for bead k gives v_{k-1}, and lambda is\n// an eigenvalue when the value it gives at the suspension, v_0, is zero.\n// This is Bernoulli's own way down the chain, link by link.\nfunction upward(lam, v) {\n  v[N] = 1;\n  v[N - 1] = ((T(N) - lam) * v[N]) / T(N);\n  for (let k = N - 1; k >= 1; k--) v[k - 1] = ((T(k) + T(k + 1) - lam) * v[k] - T(k + 1) * v[k + 1]) / T(k);\n  return v[0];\n}\nfunction modes() {\n  const out = [], v = new Float64Array(N + 1);\n  let lam = 1e-4, f = upward(lam, v);\n  while (out.length \u003c 5) {\n    const next = lam + 0.002, g = upward(next, v);\n    if (f * g \u003c 0) {\n      let lo = lam, hi = next;\n      for (let i = 0; i \u003c 50; i++) {\n        const m = (lo + hi) / 2;\n        if (upward(m, v) * upward(lo, v) \u003c= 0) hi = m;\n        else lo = m;\n      }\n      upward((lo + hi) / 2, v);\n      v[0] = 0;\n      out.push({ lam: (lo + hi) / 2, v: Float64Array.from(v) });\n    }\n    (lam = next), (f = g);\n  }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    modes: modes(),\n    x: new Float64Array(N + 2), p: new Float64Array(N + 2), a: new Float64Array(N + 2),\n    row: new Float32Array(H), prev: new Float32Array(H),\n    E: new Float32Array(W * H), scale: HALF,\n    hue: 0, speed: 2, mode: 1, mix: 0.06, key: \"\", warm: false, t: 0,\n    col: new Float32Array(15),\n  };\n}\n\nfunction accel(S) {\n  const { x, a } = S;\n  for (let k = 1; k \u003c= N; k++) a[k] = -T(k) * (x[k] - x[k - 1]) + T(k + 1) * (x[k + 1] - x[k]);\n}\n\n// Let go from rest in the chosen mode plus Mix of each other one. Every\n// mode is 1 at the free end and no more than 1 anywhere, so at the moment\n// of release the free end is out by the sum of the weights, which is put\n// at HALF LEDs from the plumb line.\nfunction release(S) {\n  const { x, p } = S, w = S.modes.map((_, i) => (i === S.mode - 1 ? 1 : 0.25 * sqrt(S.mix) + 0.75 * S.mix));\n  const sum = w.reduce((u, v) => u + v, 0);\n  S.scale = HALF / sum;\n  x.fill(0);\n  p.fill(0);\n  S.modes.forEach((m, i) => {\n    for (let k = 1; k \u003c= N; k++) x[k] += w[i] * m.v[k];\n  });\n  accel(S);\n  S.t = 0;\n  rows(S, S.prev);\n}\n\n// Where the chain crosses each row, in LEDs from the plumb line: straight\n// links between the beads, so the chain is a function of height.\nfunction rows(S, out) {\n  const { x } = S;\n  for (let y = 0; y \u003c H; y++) {\n    const u = min(y / LPX, N), k = min(floor(u), N - 1), f = u - k;\n    out[y] = S.scale * (x[k] * (1 - f) + x[k + 1] * f);\n  }\n}\n\n// Velocity Verlet, the leapfrog: symplectic, so the energy wobbles at the\n// size of the step squared and does not drift. After each step the chain's\n// crossing of each row moved from prev to row, and the exposure gets the\n// time the chain spent over each LED it passed: the step over the LEDs\n// crossed, so the turning points, where the chain lingers, burn brightest.\nfunction step(S, span) {\n  const n = max(1, ceil(span / HSTEP)), h = span / n, { x, p, a, row, prev, E } = S;\n  const fade = exp(-span / TAU);\n  for (let i = 0; i \u003c E.length; i++) E[i] *= fade;\n  for (let s = 0; s \u003c n; s++) {\n    for (let k = 1; k \u003c= N; k++) p[k] += 0.5 * h * a[k];\n    for (let k = 1; k \u003c= N; k++) x[k] += h * p[k];\n    accel(S);\n    for (let k = 1; k \u003c= N; k++) p[k] += 0.5 * h * a[k];\n    rows(S, row);\n    const top = min(H - 1, floor(N * LPX));\n    for (let y = 0; y \u003c= top; y++) {\n      const a0 = CX + min(prev[y], row[y]), a1 = CX + max(prev[y], row[y]);\n      const i0 = cl(floor(a0), 0, W - 1), i1 = cl(floor(a1), 0, W - 1), wgt = h / (i1 - i0 + 1);\n      for (let i = i0; i \u003c= i1; i++) E[y * W + i] += wgt;\n      prev[y] = row[y];\n    }\n  }\n  S.t += span;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.mode = cl(round(k[2]), 1, 5);\n  S.mix = cl(k[3], 0, 1);\n  // A new mode or mix lets the chain go again; the old exposure fades out.\n  const key = S.mode + \":\" + S.mix.toFixed(3);\n  if (key !== S.key || (input.btnPressed && input.btnPressed[0])) {\n    S.key = key;\n    release(S);\n  }\n  if (!S.warm) {\n    // Open on a chain that has been swinging for a second and a half.\n    for (let i = 0; i \u003c 45; i++) step(S, (2 * RATE) / 30);\n    S.warm = true;\n  }\n  step(S, d * S.speed * RATE);\n}\n\nfunction put(display, x, y, c, o, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  display.setPixel(x, y, round(c[o] * v), round(c[o + 1] * v), round(c[o + 2] * v));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.col, h = S.hue;\n  hsv(wheel(h + 0.78), 0.75, 1, c, 0); // exposure\n  hsv(h + 0.52, 0.85, 1, c, 3); // links\n  hsv(h + 0.52, 0.25, 1, c, 6); // beads\n  hsv(h + 0.15, 0.45, 1, c, 9); // node ticks\n  hsv(h + 0.6, 0.3, 1, c, 12); // plumb line and suspension\n  const { E, row, x } = S, bead = N * LPX;\n  // The rest position, a dotted plumb line, and the ticks where mode n's\n  // nodes fall on the continuous chain: J0(j_n sqrt(s / L)) = 0 at\n  // s / L = (j_m / j_n)^2 for each zero j_m below j_n.\n  const tick = new Uint8Array(H), n = S.mode;\n  for (let m = 0; m \u003c n - 1; m++) tick[round(YFREE * (1 - (J0Z[m] / J0Z[n - 1]) ** 2))] = 1;\n  for (let y = 0; y \u003c H; y++)\n    for (let xx = 0; xx \u003c W; xx++) {\n      // The exposure, toned so a wide swing still reads and a narrow one\n      // does not burn out.\n      const e = E[y * W + xx], b = e > 0 ? 1 - exp(-e / 1.1) : 0;\n      let v = 150 * b, o = 0;\n      if (xx === 31 && (y & 1) === 0 && y \u003c= bead + 1 && v \u003c 46) (v = 46), (o = 12);\n      if (tick[y] && abs(xx - CX) > 2 && abs(xx - CX) \u003c 6) (v = max(v, 150)), (o = 9);\n      if (tick[y] && (xx \u003c 3 || xx > W - 4)) (v = 150), (o = 9);\n      if (y === 0 && abs(xx - CX) \u003c 5) (v = 200), (o = 12);\n      put(display, xx, y, c, o, v);\n    }\n  // The links, a line one LED wide down the chain's crossing of each row,\n  // stretched across the row where the chain leans.\n  const top = min(H - 1, floor(bead));\n  for (let y = 0; y \u003c= top; y++) {\n    const up = y > 0 ? (row[y - 1] + row[y]) / 2 : row[0], dn = y \u003c top ? (row[y] + row[y + 1]) / 2 : row[y];\n    const lo = CX + min(up, dn) - 0.5, hi = CX + max(up, dn) + 0.5;\n    for (let i = floor(lo); i \u003c= floor(hi); i++) {\n      const cover = min(hi, i + 1) - max(lo, i);\n      if (cover > 0.05) put(display, i, y, c, 3, 80 + 140 * min(1, cover));\n    }\n  }\n  // The beads, small round dots brighter than the links.\n  for (let k = 1; k \u003c= N; k++) {\n    const bx = CX + S.scale * x[k], by = k * LPX;\n    for (let yy = floor(by) - 1; yy \u003c= floor(by) + 2; yy++)\n      for (let xx = floor(bx) - 1; xx \u003c= floor(bx) + 2; xx++) {\n        const dx = xx + 0.5 - bx, dy = yy + 0.5 - by, w = cl(1.9 - sqrt(dx * dx + dy * dy), 0, 1);\n        if (w > 0.1) put(display, xx, yy, c, 6, 120 + 135 * w);\n      }\n  }\n}\n","hard-squares":"// ===== Patternflow pattern =====\n// Title:   Hard Squares\n// Family:  particle\n// Idea:    Particles that may not touch hop on and off the LEDs as a hard-square lattice gas whose activity grows down the panel like pressure under gravity, so a sparse twinkling gas at the top thickens into a fluid and, below the row where the activity passes its critical 3.796, freezes into the checkerboard crystal, cyan on one sublattice and gold on the other, whose domain walls slowly coarsen.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hard-square lattice gas (D. S. Gaunt and M. E. Fisher, 1965), its critical activity 3.796 (R. J. Baxter, I. G. Enting and S. K. Tsang, 1980), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Gravity=6..16, Activity=-1..1\n//\n// Knob 1: Hue. Turns both crystal colours round the wheel. At 0 a particle on the even sublattice is cyan and one on the odd sublattice gold; at 0.25 violet and green, at 0.5 red and blue, at 0.75 lime and magenta. The faint checker of empty sites stays slate above the critical row and plum below it.\n// Knob 2: Speed. Sweeps a second, every site offered a particle or a vacancy once a sweep on average: 4 at 2, 0.4 at 0.2 and 6 at 3. At 4 a gas particle at the top lives about a quarter of a second, while the crystal's domains grow over minutes: in one run the bottom 20 rows went from half cyan and half gold to 95% one colour in nine minutes.\n// Knob 3: Gravity. How fast the activity grows down the panel: at 6 it rises e^6, about 400 times, from 0.028 on the top row to 11 on the bottom row, with the critical 3.796 on row 104, so a gas, a fluid and a crystal stack up over the height. At 16 it rises e^16, the top 56 rows are all but empty and gas turns to crystal over the 40 rows between rows 64 and 104.\n// Knob 4: Activity. Multiplies the activity on every row by e^(2.5 x): 1.16 at the opening 0.06. At -1 it is divided by 12, the bottom row only reaches 0.8 and the whole panel stays a gas; at 1 it is multiplied by 12, the critical row rises to row 55 and the crystal takes the lower 73 rows.\n// Buttons: K1 tap empties the lattice. The gas comes back within a second and the crystal nucleates anew from the bottom up, in small domains of both colours.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, exp, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The critical activity of hard squares: below it the particles take both\n// sublattices alike, above it most of them choose one.\nconst LC = 3.796;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const rgb = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[0] = rgb[0];\n  out[1] = rgb[1];\n  out[2] = rgb[2];\n}\n\n// Levels. Every particle has four empty neighbours, since no two touch. An\n// empty site shows a faint checker: level 40 where x + y is even, dark\n// where it is odd. A particle on an even site sits among dark LEDs and one\n// on an odd site among LEDs at 40, so the odd one is drawn 40 brighter and\n// both stand 110 above their neighbours: the measured detail does not care\n// which sublattice a domain chose. Each pair of LEDs that touches a\n// particle is a hard step and every other pair a soft step of 40, so the\n// measured edges are about twice the density, 0.40 at the opening's 0.20.\nconst PE = 150, PO = 190;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, grav: 6, act: 0.06, acc: 0, warm: false, yc: H,\n    occ: new Uint8Array(N), pOn: new Float32Array(H),\n  };\n}\n\n// The activity lambda is exp(G y / 127) up to a constant, the barometric\n// law, with lambda_c on row 107 before Activity shifts it. S.yc is the first\n// row at or past lambda_c.\nfunction profile(S) {\n  const YF = 107;\n  S.yc = -1;\n  for (let y = 0; y \u003c H; y++) {\n    const lam = LC * exp((S.grav * (y - YF)) / (H - 1) + 2.5 * S.act);\n    S.pOn[y] = lam / (1 + lam);\n    if (lam >= LC && S.yc \u003c 0) S.yc = y;\n  }\n  if (S.yc \u003c 0) S.yc = H;\n}\n\n// Heat-bath (Glauber) moves: a random site whose four neighbours are empty\n// is occupied with probability lambda / (1 + lambda), and any other site\n// is emptied. The rows wrap round in x; above row 0 and below row 127 there\n// is nothing.\nfunction sweep(S, n) {\n  const occ = S.occ, pOn = S.pOn;\n  for (let i = 0; i \u003c n; i++) {\n    const p = floor(random() * N), x = p & 63, y = p >> 6;\n    const free =\n      !occ[y * W + ((x + 1) & 63)] && !occ[y * W + ((x + 63) & 63)] &&\n      (y === 0 || !occ[p - W]) && (y === H - 1 || !occ[p + W]);\n    occ[p] = free && random() \u003c pOn[y] ? 1 : 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.grav = cl(k[2], 6, 16);\n  S.act = cl(k[3], -1, 1);\n  profile(S);\n  if (input.btnPressed && input.btnPressed[0]) S.occ.fill(0);\n  if (!S.warm) {\n    // Open on a panel 150 sweeps after an empty start.\n    sweep(S, 150 * N);\n    S.warm = true;\n  }\n  S.acc += d * S.speed * 2 * N;\n  const n = floor(S.acc);\n  S.acc -= n;\n  sweep(S, n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const occ = S.occ;\n  const ce = [0, 0, 0], co = [0, 0, 0], cb = [0, 0, 0], cc = [0, 0, 0];\n  hsv(S.hue + 0.5, 1, PE / 255, ce);\n  hsv(S.hue + 0.12, 1, PO / 255, co);\n  // The faint checker turns from slate to plum on the row where lambda\n  // passes lambda_c.\n  hsv(0.6, 0.55, 40 / 255, cb);\n  hsv(0.8, 0.45, 40 / 255, cc);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const even = ((x + y) & 1) === 0;\n      const col = occ[p] ? (even ? ce : co) : even ? (y \u003c S.yc ? cb : cc) : null;\n      if (col) display.setPixel(x, y, round(col[0] * 255), round(col[1] * 255), round(col[2] * 255));\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n}\n","hexagrammum-mysticum":"// ===== Patternflow pattern =====\n// Title:   Hexagrammum Mysticum\n// Family:  line\n// Idea:    Six points slide round an ellipse and the 60 hexagons through them are drawn one a second, each with its sides run out until opposite sides meet, the three meeting points ringed and Pascal's line through all three flashing white, while the Pascal lines of the last eleven hexagons stay behind faintly in the colour of their Steiner triple, so that every third hexagon closes a triple and a gold Steiner point flares where its three lines meet.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pascal's hexagrammum mysticum theorem (Blaise Pascal, 1639), Steiner points (Jakob Steiner, 1828), Kirkman points (Thomas Kirkman, 1849), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lines=12..60, Spread=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the Pascal lines left behind are cyan, azure, blue and violet, a colour for each of the last four triples in turn, the current hexagon's three pairs of opposite sides pink, green and amber, the Steiner points pale gold and the ellipse slate blue; at 0.5 the old lines turn pink, red, lime and green, the sides aqua, violet and blue, the Steiner points pale blue. Pascal's line is always white. The faint colours skip orange and yellow, which read brown and olive when dim.\n// Knob 2: Speed. Hexagons a second, half the knob: one a second at 2, so all 60 go by in a minute and a Steiner point closes every 3 s; 0.2 is one hexagon every 10 s, 3 one every 0.67 s. The six points turn round the ellipse together once in 79 s at 2, each swaying 0.08 rad about its place with a period between 6 and 11 s.\n// Knob 3: Lines. How many of the latest Pascal lines stay drawn, the current one with them, each fading with age. 12 at the opening: the last three or four triples, so three or four Steiner points. At 30 half of the 60; at 60 all of them, with all 20 Steiner points and the 60 Kirkman points as small gold dots, where three lines meet that are not a Steiner triple and no two of which share a crossing of chords.\n// Knob 4: Spread. Draws the six points from the searched gaps towards six equal ones, 85% of the way at 1. Over a minute at 0, 68% of the crossings of opposite sides and 78% of the Steiner points fall on the panel; at 0.25 59% and 60%; at 0.5 55% and 51%; at 1 50% and 50%, as more pairs of sides turn nearly parallel and meet far off.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sin, cos, exp, hypot, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The ellipse the panel shows, centre and half axes in LEDs.\nconst CX = 31.5, CY = 63.5, AX = 16, BY = 34;\n\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n\n// The 60 hexagons on six points, each listed once: from point 0, the way\n// round that visits the lower of its two neighbours first.\nconst HEX = [];\n(function perm(arr, rest) {\n  if (!rest.length) return void (arr[1] \u003c arr[5] && HEX.push(arr));\n  for (let i = 0; i \u003c rest.length; i++) perm([...arr, rest[i]], rest.filter((_, j) => j !== i));\n})([0], [1, 2, 3, 4, 5]);\nconst hexIndex = (h) => {\n  // Turn and reverse an ordering to its listed form.\n  const z = h.indexOf(0), r = [0, 1, 2, 3, 4, 5].map((k) => h[(z + k) % 6]);\n  const f = r[1] \u003c r[5] ? r : [0, r[5], r[4], r[3], r[2], r[1]];\n  return HEX.findIndex((g) => g.every((v, k) => v === f[k]));\n};\n\n// Steiner's triples. Split the six points into two triangles; a hexagon that\n// steps from one to the other every side uses six of the nine chords between\n// them and leaves out three, one from each point: a matching of the two\n// triangles. The three hexagons whose left-out matchings are the even\n// permutations meet in one point, and the three odd ones in another, so the\n// ten splits give the 20 Steiner points, and every hexagon is in one.\nconst STEINER = [];\nfor (let p = 1; p \u003c 6; p++)\n  for (let q = p + 1; q \u003c 6; q++) {\n    const A = [0, p, q], B = [0, 1, 2, 3, 4, 5].filter((v) => !A.includes(v));\n    const tri = [[], []];\n    for (const [x, y, z] of [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]) {\n      // The hexagon A0 Bx A1 By A2 Bz leaves out A0-By, A1-Bz, A2-Bx.\n      const m = [y, z, x], sign = (m[0] - m[1]) * (m[0] - m[2]) * (m[1] - m[2]) > 0 ? 0 : 1;\n      const k = hexIndex([A[0], B[x], A[1], B[y], A[2], B[z]]);\n      if (!tri[sign].includes(k)) tri[sign].push(k);\n    }\n    STEINER.push(tri[0], tri[1]);\n  }\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  // The hexagons go round triple by triple, so every third one closes a\n  // Steiner point.\n  const order = [], tripleOf = new Int8Array(60);\n  STEINER.forEach((t, j) => t.forEach((k) => (order.push(k), (tripleOf[k] = j))));\n  params.s = {\n    t: 0, clock: 0, speed: 2, hue: 0, keep: 12, spread: 0,\n    order, tripleOf, kirkman: [],\n    img: new Float32Array(W * H * 3), pts: [], lines: [],\n  };\n  findKirkman(params.s);\n}\n\n// Kirkman's triples are found by number, once, on six fixed points of an\n// ellipse: the triples of Pascal lines that meet in one point, no two of\n// them meeting at one of the 45 crossings of chords, that are not\n// Steiner's. It finds 60, three through every line.\nfunction findKirkman(S) {\n  const P = [0.3, 1.2, 2.0, 3.4, 4.1, 5.3].map((a) => [cos(a), 1.6 * sin(a), 1]);\n  const L = HEX.map((h) => pascal(P, h).line);\n  const chords = (h) => h.map((v, i) => (1 \u003c\u003c v) | (1 \u003c\u003c h[(i + 1) % 6]));\n  const shares = (a, b) => {\n    // Two hexagons share a crossing when a pair of their opposite sides is\n    // the same pair of chords.\n    const ca = chords(HEX[a]), cb = chords(HEX[b]);\n    for (let i = 0; i \u003c 3; i++) for (let j = 0; j \u003c 3; j++) {\n      const x = [ca[i], ca[i + 3]].sort().join(), y = [cb[j], cb[j + 3]].sort().join();\n      if (x === y) return true;\n    }\n    return false;\n  };\n  const st = new Set(STEINER.map((t) => [...t].sort((a, b) => a - b).join()));\n  for (let i = 0; i \u003c 60; i++)\n    for (let j = i + 1; j \u003c 60; j++) {\n      if (shares(i, j)) continue;\n      const X = cross(L[i], L[j]);\n      for (let k = j + 1; k \u003c 60; k++) {\n        const d = abs(X[0] * L[k][0] + X[1] * L[k][1] + X[2] * L[k][2]) / hypot(X[0], X[1], X[2]);\n        if (d \u003c 1e-9 && !shares(i, k) && !shares(j, k) && !st.has([i, j, k].join())) S.kirkman.push([i, j, k]);\n      }\n    }\n}\n\n// Pascal's line of hexagon h on points P: the crossings of its three pairs\n// of opposite sides, and the line through the first and last, normalised so\n// that a x + b y + c is the distance in LEDs.\nfunction pascal(P, h) {\n  const side = (i) => cross(P[h[i]], P[h[(i + 1) % 6]]);\n  const X = [0, 1, 2].map((i) => cross(side(i), side(i + 3)));\n  const l = cross(X[0], X[2]), n = hypot(l[0], l[1]) || 1;\n  return { X, line: [l[0] / n, l[1] / n, l[2] / n] };\n}\n\n// Where the six points sit round the ellipse, as the angles between\n// neighbours. An even spread sends crossings far off: at six equal gaps 12\n// of the 45 crossings of chords are at infinity, because chords half a turn\n// apart are parallel. These gaps came out of a search over spreads with no\n// gap below 0.6, scored by the share of those 45 crossings and of the 20\n// Steiner points on the panel as the six turn round the ellipse together,\n// less a penalty for crowding to one side: 70% and 84% stay on the panel,\n// against 48% and 50% at equal gaps.\nconst GAPS = [1.766, 1.384, 0.602, 0.601, 0.604, 1.327];\nconst BASE = GAPS.map((g, i) => GAPS.slice(0, i).reduce((a, b) => a + b, 0));\nconst SWAY = [0.31, 0.43, 0.37, 0.53, 0.29, 0.47];\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 12, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.keep = round(cl(kv[2], 12, 60));\n  S.spread = 0.85 * cl(kv[3], 0, 1);\n  S.t += d * S.speed;\n  // Hexagons a second: half the speed, one a second at 2.\n  S.clock += d * S.speed * 0.5;\n  const tau = S.t;\n  // The six points turn round the ellipse together and each sways about its\n  // place; Spread draws them towards six equal gaps.\n  const th = BASE.map((c, i) => c + S.spread * ((PI * i) / 3 + 0.6 - c) - 0.9 + 0.04 * tau + 0.08 * sin(SWAY[i] * tau + i * 2.1));\n  const P = th.map((t) => [CX + AX * cos(t), CY + BY * sin(t), 1]);\n  S.pts = P;\n  S.lines = HEX.map((h) => pascal(P, h));\n}\n\n// Additive, anti-aliased drawing into a float image.\nfunction add(img, x, y, r, g, b, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const q = (y * W + x) * 3;\n  img[q] += r * a;\n  img[q + 1] += g * a;\n  img[q + 2] += b * a;\n}\n\n// A line a x + b y + c = 0 with a, b normalised, between the parameters\n// s0 and s1 along it (measured from the foot of the origin), at width w.\nfunction line(img, L, col, a, s0 = -1e9, s1 = 1e9, w = 0.9) {\n  const [la, lb, lc] = L, fx = -la * lc, fy = -lb * lc, tx = -lb, ty = la;\n  const span = (x, y) => (x - fx) * tx + (y - fy) * ty;\n  if (abs(lb) > abs(la)) {\n    for (let x = 0; x \u003c W; x++) {\n      const yc = -(la * x + lc) / lb;\n      if (yc \u003c -3 || yc > H + 2) continue;\n      for (let y = floor(yc - 1.5); y \u003c= floor(yc + 1.5) + 1; y++) {\n        const dd = abs(la * x + lb * y + lc), sp = span(x, y);\n        if (dd \u003c w + 0.6 && sp >= s0 && sp \u003c= s1) add(img, x, y, col[0], col[1], col[2], a * cl(1 - (dd - 0.15) / w, 0, 1));\n      }\n    }\n  } else {\n    for (let y = 0; y \u003c H; y++) {\n      const xc = -(lb * y + lc) / la;\n      if (xc \u003c -3 || xc > W + 2) continue;\n      for (let x = floor(xc - 1.5); x \u003c= floor(xc + 1.5) + 1; x++) {\n        const dd = abs(la * x + lb * y + lc), sp = span(x, y);\n        if (dd \u003c w + 0.6 && sp >= s0 && sp \u003c= s1) add(img, x, y, col[0], col[1], col[2], a * cl(1 - (dd - 0.15) / w, 0, 1));\n      }\n    }\n  }\n}\n\nfunction dot(img, X, rad, col, a) {\n  if (abs(X[2]) \u003c 1e-12) return;\n  const x = X[0] / X[2], y = X[1] / X[2];\n  if (x \u003c -rad - 2 || x > W + rad + 2 || y \u003c -rad - 2 || y > H + rad + 2) return;\n  for (let py = floor(y - rad - 1); py \u003c= y + rad + 1; py++)\n    for (let px = floor(x - rad - 1); px \u003c= x + rad + 1; px++) {\n      const r = hypot(px - x, py - y);\n      add(img, px, py, col[0], col[1], col[2], a * cl(rad + 0.5 - r, 0, 1));\n    }\n}\n\nfunction ring(img, X, rad, col, a) {\n  if (abs(X[2]) \u003c 1e-12) return;\n  const x = X[0] / X[2], y = X[1] / X[2];\n  if (x \u003c -rad - 2 || x > W + rad + 2 || y \u003c -rad - 2 || y > H + rad + 2) return;\n  for (let py = floor(y - rad - 1); py \u003c= y + rad + 1; py++)\n    for (let px = floor(x - rad - 1); px \u003c= x + rad + 1; px++) add(img, px, py, col[0], col[1], col[2], a * cl(1 - abs(hypot(px - x, py - y) - rad) / 0.8, 0, 1));\n}\n\nfunction glow(img, X, rad, col, a) {\n  if (abs(X[2]) \u003c 1e-12) return;\n  const x = X[0] / X[2], y = X[1] / X[2], R = rad * 2.5;\n  if (x \u003c -R || x > W + R || y \u003c -R || y > H + R) return;\n  for (let py = floor(y - R); py \u003c= y + R; py++)\n    for (let px = floor(x - R); px \u003c= x + R; px++) {\n      const r2 = (px - x) * (px - x) + (py - y) * (py - y);\n      add(img, px, py, col[0], col[1], col[2], a * exp(-r2 / (rad * rad)));\n    }\n}\n\n// Colours, as hues before Hue turns them: the four triples on the panel at\n// the opening take four cool hues in turn, the current hexagon's three pairs\n// of opposite sides three warm ones, and the Steiner points are pale gold.\n// The faint colours go through a wheel that skips orange and yellow, which\n// read brown and olive when dim.\nconst TRIPLE = [0.376, 0.471, 0.576, 0.682];\nconst PAIR = [0.92, 0.3, 0.12];\nconst GOLD = 0.14;\nconst wheel = (h) => 0.18 + 0.85 * (h - floor(h));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.pts.length) return;\n  const img = S.img, P = S.pts, hu = S.hue;\n  img.fill(0);\n  const c = [0, 0, 0];\n  // The ellipse.\n  hsv(wheel(0.494 + hu), 0.45, 0.4, c, 0);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const u = (x - CX) / AX, v = (y - CY) / BY, dd = abs((u * u + v * v - 1) / (2 * hypot(u / AX, v / BY)));\n      if (dd \u003c 1.4) add(img, x, y, c[0], c[1], c[2], cl(1.2 - dd, 0, 1));\n    }\n  const cur = floor(S.clock), ph = S.clock - cur, n = S.order.length;\n  // Past Pascal lines, fading with age, in the colour of their triple. The\n  // order is a cycle, so at the start the lines of its last lap are there.\n  const present = new Float32Array(60);\n  for (let age = S.keep - 1; age >= 1; age--) {\n    const k = S.order[(((cur - age) % n) + n) % n], fade = 1 - (age - 1) / S.keep;\n    present[k] = fade;\n    hsv(wheel(TRIPLE[S.tripleOf[k] % 4] + hu), 0.75, 1, c, 0);\n    line(img, S.lines[k].line, c, 0.1 + 0.2 * fade);\n  }\n  // The current hexagon: its sides grow out into long lines, then the three\n  // crossings of opposite sides light, then Pascal's line through them.\n  const k = S.order[cur % n], h = HEX[k], pl = S.lines[k];\n  const grow = 1 - (1 - cl(ph / 0.3, 0, 1)) ** 2, pop = cl((ph - 0.28) / 0.1, 0, 1), flash = cl((ph - 0.4) / 0.08, 0, 1), dim = cl((ph - 0.55) / 0.45, 0, 1);\n  for (let i = 0; i \u003c 6; i++) {\n    const A = P[h[i]], B = P[h[(i + 1) % 6]], l = cross(A, B), nn = hypot(l[0], l[1]), L = [l[0] / nn, l[1] / nn, l[2] / nn];\n    const fx = -L[0] * L[2], fy = -L[1] * L[2], tx = -L[1], ty = L[0];\n    const sa = (A[0] - fx) * tx + (A[1] - fy) * ty, sb = (B[0] - fx) * tx + (B[1] - fy) * ty;\n    const lo = min(sa, sb), hi = max(sa, sb), X = pl.X[i % 3];\n    hsv(PAIR[i % 3] + hu, 0.7, 1, c, 0);\n    // The whole side faintly, the chord bright, and the stretch from the\n    // chord out to where it meets its opposite side growing in.\n    line(img, L, c, 0.14 * grow);\n    line(img, L, c, 0.95, lo, hi, 1.1);\n    const far = abs(X[2]) \u003c 1e-9 * hypot(X[0], X[1]);\n    const sx = far ? (X[0] * tx + X[1] * ty > 0 ? 1e4 : -1e4) : (X[0] / X[2] - fx) * tx + (X[1] / X[2] - fy) * ty;\n    const e = 0.62 - 0.25 * dim;\n    if (sx > hi) line(img, L, c, e, hi, hi + (min(sx, hi + 300) - hi) * grow);\n    else if (sx \u003c lo) line(img, L, c, e, lo - (lo - max(sx, lo - 300)) * grow, lo);\n  }\n  if (flash > 0) {\n    present[k] = 1;\n    line(img, pl.line, [1, 1, 1], 0.35 + 0.65 * flash * (1 - 0.45 * dim), -1e9, 1e9, 1.15);\n  }\n  for (let i = 0; i \u003c 3; i++) {\n    hsv(PAIR[i] + hu, 0.55, 1, c, 0);\n    ring(img, pl.X[i], 2.6, c, 1.4 * pop * (1 - 0.4 * dim));\n    dot(img, pl.X[i], 0.9, [1, 1, 1], pop);\n  }\n  // Steiner points where all three lines of a triple are drawn; the point\n  // the current hexagon closes flares.\n  hsv(GOLD + hu, 0.45, 1, c, 0);\n  STEINER.forEach((t) => {\n    const a = min(present[t[0]], present[t[1]], present[t[2]]);\n    if (a \u003c= 0) return;\n    const X = cross(S.lines[t[0]].line, S.lines[t[1]].line);\n    const fresh = t.includes(k) ? flash * (1 - dim * 0.7) : 0;\n    glow(img, X, 1.4 + 2.2 * fresh, c, 0.45 + 0.35 * a + 0.8 * fresh);\n    dot(img, X, 0.7 + 0.6 * fresh, [1, 1, 1], 0.6 + 0.4 * a);\n  });\n  // Kirkman points, small, once all three of their lines are drawn.\n  for (const [i, j, q] of S.kirkman) {\n    const a = min(present[i], present[j], present[q]);\n    if (a > 0) dot(img, cross(S.lines[i].line, S.lines[j].line), 0.5, c, 0.35 + 0.45 * a);\n  }\n  // The six points.\n  for (const X of P) dot(img, X, 1.25, [1, 1, 1], 1);\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, (255 * min(1, img[q])) | 0, (255 * min(1, img[q + 1])) | 0, (255 * min(1, img[q + 2])) | 0);\n}\n","kp-web":"// ===== Patternflow pattern =====\n// Title:   KP Web\n// Family:  wave\n// Idea:    Exact line-soliton solutions of the Kadomtsev-Petviashvili equation glow as ridges on a dark field, coloured by their height, while time runs through each one: a Y junction whose stem grows up the panel, two kinds of X crossing, and webs from the totally nonnegative Grassmannian whose holes shrink to a single crossing and open again in another shape.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kadomtsev-Petviashvili equation (Boris Kadomtsev and Vladimir Petviashvili, 1970), resonant Y junction (John Miles, 1977), KP web solutions (Yuji Kodama, 2004), their classification by the totally nonnegative Grassmannian (Yuji Kodama and Lauren Williams, 2011), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Type=0..6, Angle=0..1\n//\n// Knob 1: Hue. Turns both ends of the height ramp round the wheel. At 0 the tallest ridges are aqua, the lowest violet and those between lavender blue, and where u rises above the tallest line, as where the two O solitons cross, the light goes white; at 0.5 the tall ones are pink and the low ones green. The wheel skips dim orange, which reads brown.\n// Knob 2: Speed. At 2 one sweep of time through a solution lasts 9 seconds, half a second of it fading out and in; at 0.2 it lasts 90, at 3 six. A web is smallest at the middle of its sweep, and its farthest junction is 100 LEDs out at either end; a lone Y or X runs 112 LEDs, bottom to top or top to bottom.\n// Knob 3: Type. Below 1 the panel tours the six types, one per sweep: the T web, Gr(2,5), Gr(3,6), Y, O, P. From 1 up it holds one, each sweep on a fresh random point of its cell: 1 the Y junction of Gr(1,3), 2 the O type and 3 the P type of Gr(2,4), each an X, 4 the T web of Gr(2,4), whose box has a tall stem on one side, 5 the Gr(2,5) web and 6 the Gr(3,6) web, with 10 and 20 exponentials in tau and several holes.\n// Knob 4: Angle. Scales every k_j by 0.55 at 0 up to 1.25 at 1, the window rescaled so a ridge keeps its width in LEDs, and the slope of the line [i, j] is k_i + k_j: the T web's far lines lean 24 degrees off upright at 0, 25 at the opening 0.06 and 45 at 1. The same solution is rebuilt as it turns.\n\nconst W = 64, H = 128;\nconst { floor, min, max, exp, log, sqrt, abs, round, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// KP-II, (-4u_t + 6uu_x + u_xxx)_x + 3u_yy = 0, has the exact solutions\n// u = 2 (ln tau)_xx with tau = sum over k-subsets I of Delta_I(A) E_I, where\n// E_I = prod_{i\u003cj in I}(k_j - k_i) * exp(sum_{j in I} theta_j) and\n// theta_j = k_j x + k_j^2 y + k_j^3 t. A is a k x N matrix whose maximal\n// minors Delta_I are all >= 0; which of them vanish picks the cell of the\n// totally nonnegative Grassmannian, and the cell picks the web.\n// With softmax weights w_I = Delta_I E_I / tau, (ln tau)_x is the mean of\n// kappa_I = sum k_j and (ln tau)_xx its variance, so u = 2 Var_w(kappa)\n// and no exponential is ever taken of more than 0: no overflow in tau.\n\nfunction subsets(n, k) {\n  const out = [];\n  const rec = (s, cur) => {\n    if (cur.length === k) return void out.push(cur.slice());\n    for (let i = s; i \u003c n; i++) cur.push(i), rec(i + 1, cur), cur.pop();\n  };\n  rec(0, []);\n  return out;\n}\n\nfunction det(M) {\n  const n = M.length, a = M.map((r) => r.slice());\n  let d = 1;\n  for (let c = 0; c \u003c n; c++) {\n    let p = c;\n    for (let r = c + 1; r \u003c n; r++) if (abs(a[r][c]) > abs(a[p][c])) p = r;\n    if (abs(a[p][c]) \u003c 1e-300) return 0;\n    if (p !== c) [a[p], a[c]] = [a[c], a[p]], (d = -d);\n    d *= a[c][c];\n    for (let r = c + 1; r \u003c n; r++) {\n      const f = a[r][c] / a[c][c];\n      for (let j = c; j \u003c n; j++) a[r][j] -= f * a[c][j];\n    }\n  }\n  return d;\n}\n\n// A strictly totally positive k x N matrix: the kernel exp(alpha_i beta_j)\n// with both sequences increasing, its columns scaled by random weights.\n// Every maximal minor is positive, so this is the top cell.\nfunction topCell(r, N) {\n  const beta = [];\n  let b = 0;\n  for (let j = 0; j \u003c N; j++) beta.push((b += 0.6 + 0.5 * random()));\n  const d = beta.map(() => exp(2 * (random() - 0.5)));\n  return Array.from({ length: r }, (_, i) => beta.map((bj, j) => d[j] * exp(i * 0.9 * bj)));\n}\nconst rnd = () => exp(2.4 * (random() - 0.5));\n\n// The six types. k is the base set of k_j; follow 'x' keeps the window at\n// one height so the junction travels up or down, 'xy' follows the web.\nconst TYPES = [\n  // Gr(1,3): one soliton [1,3] below, two above, meeting in Miles' resonant\n  // Y. k_1 + k_3 = 0 stands the stem upright; the sum of the k climbs the\n  // junction up the panel, so the stem grows.\n  { k: [-1, 0.3, 1], cell: () => [[1, rnd(), rnd()]], follow: \"x\", s0: 1.0 },\n  // Gr(2,4) O type, Delta_12 = Delta_34 = 0: the solitons [1,2] and [3,4]\n  // cross in an X, and where they cross u rises above the sum of their\n  // heights (0.26 against 0.24 at the opening Angle).\n  { k: [-1.3, -0.45, 0.25, 1.05], cell: () => [[1, rnd(), 0, 0], [0, 0, 1, rnd()]], follow: \"x\", s0: 1.0 },\n  // P type, Delta_14 = Delta_23 = 0: [1,4] and [2,3] cross, and the tall\n  // one's crest dips where they do (from 1.10 to 0.92).\n  { k: [-1.3, 0.1, 0.9, 1.2], cell: () => [[1, 0, 0, -rnd()], [0, 1, rnd(), 0]], follow: \"x\", s0: 1.0 },\n  // T type, every minor positive: [1,3] and [2,4] far away, four resonant\n  // Y junctions round a box in the middle.\n  { k: [-1.2, -0.4, 0.4, 1.2], cell: () => topCell(2, 4), follow: \"xy\", s0: 0.85 },\n  { k: [-1.2, -0.6, 0, 0.6, 1.2], cell: () => topCell(2, 5), follow: \"xy\", s0: 0.76 },\n  { k: [-1.25, -0.75, -0.25, 0.25, 0.75, 1.25], cell: () => topCell(3, 6), follow: \"xy\", s0: 0.68 },\n];\nconst TOUR = [3, 4, 5, 0, 1, 2];\n\n// At the ends of a sweep the farthest junction sits this many LEDs from the\n// window's middle: a lone junction or crossing runs the panel's height, a\n// web grows past the panel's edges so its holes fill it.\nconst REACH = { x: 56, xy: 100 };\n\nfunction build(type, a, A) {\n  const T = TYPES[type], k = T.k.map((v) => v * a), N = k.length, r = A.length;\n  const terms = [];\n  for (const I of subsets(N, r)) {\n    const D = det(A.map((row) => I.map((j) => row[j])));\n    if (D \u003c= 1e-9) continue;\n    let V = 1, p = 0, q = 0, c3 = 0;\n    for (let x = 0; x \u003c I.length; x++) for (let y = x + 1; y \u003c I.length; y++) V *= k[I[y]] - k[I[x]];\n    for (const j of I) (p += k[j]), (q += k[j] * k[j]), (c3 += k[j] ** 3);\n    terms.push({ I, c: log(D * V), p, q, c3 });\n  }\n  // The tallest line soliton that can appear: two terms whose index sets\n  // differ in one place balance along the line [i, j], height (k_i - k_j)^2 / 2.\n  let umax = 0;\n  for (const A of terms) for (const B of terms) if (A.I.filter((j) => !B.I.includes(j)).length === 1) umax = max(umax, (A.p - B.p) ** 2 / 2);\n  // s0 is LEDs per unit of x and y for the base set; scaled with the spread\n  // so a ridge of a given k_i - k_j keeps its width in LEDs.\n  return { terms, umax, follow: T.follow, S: T.s0 * a, A };\n}\n\n// Triple points: where three exponentials tie and none is bigger. These\n// are the junctions of the web.\nfunction vertices(terms, t) {\n  const out = [], n = terms.length;\n  for (let a = 0; a \u003c n; a++)\n    for (let b = a + 1; b \u003c n; b++)\n      for (let c = b + 1; c \u003c n; c++) {\n        const A = terms[a], B = terms[b], C = terms[c];\n        const a11 = A.p - B.p, a12 = A.q - B.q, r1 = B.c - A.c + (B.c3 - A.c3) * t;\n        const a21 = B.p - C.p, a22 = B.q - C.q, r2 = C.c - B.c + (C.c3 - B.c3) * t;\n        const d = a11 * a22 - a12 * a21;\n        if (abs(d) \u003c 1e-9) continue;\n        const x = (r1 * a22 - a12 * r2) / d, y = (a11 * r2 - a21 * r1) / d;\n        const f = A.c + A.p * x + A.q * y + A.c3 * t;\n        let top = true;\n        for (const M of terms) if (M.c + M.p * x + M.q * y + M.c3 * t > f + 1e-7) { top = false; break; }\n        if (top) out.push([x, y]);\n      }\n  return out;\n}\nconst centroid = (v) => {\n  let x = 0, y = 0;\n  for (const p of v) (x += p[0]), (y += p[1]);\n  return [x / max(1, v.length), y / max(1, v.length)];\n};\n\n// One sweep: a fresh point of the cell (or the same one, when only Angle\n// turned), the moment its web is smallest, and a window moving at constant\n// speed with the junctions' middle.\nfunction newSweep(S, keep) {\n  const type = keep ? S.type : S.typeKnob \u003c 1 ? TOUR[S.tour++ % 6] : min(5, floor(S.typeKnob) - 1);\n  const B = build(type, S.a, keep ? S.B.A : TYPES[type].cell());\n  let tm = 0, best = 1e9;\n  if (B.follow === \"xy\")\n    for (let t = -24; t \u003c= 24; t += 1) {\n      const v = vertices(B.terms, t);\n      let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n      for (const p of v) (x0 = min(x0, p[0])), (x1 = max(x1, p[0])), (y0 = min(y0, p[1])), (y1 = max(y1, p[1]));\n      if (x1 - x0 + y1 - y0 \u003c best) (best = x1 - x0 + y1 - y0), (tm = t);\n    }\n  const c0 = centroid(vertices(B.terms, tm)), c1 = centroid(vertices(B.terms, tm + 1));\n  const vx = c1[0] - c0[0], vy = B.follow === \"xy\" ? c1[1] - c0[1] : 0;\n  // How far each junction strays from the window per unit of t, in LEDs.\n  const v2 = vertices(B.terms, tm + 10);\n  let spread = 1e-6;\n  for (const p of v2) {\n    const dx = (p[0] - c0[0] - 10 * vx) * B.S, dy = (p[1] - c0[1] - 10 * vy) * B.S;\n    spread = max(spread, sqrt(dx * dx + dy * dy) / 10);\n  }\n  Object.assign(S, { B, type, tm, T: REACH[B.follow] / spread, cx: c0[0], cy: c0[1], vx, vy });\n}\n\n// Dim orange reads brown on the panel, so the wheel skips 0.03 to 0.16.\nfunction hsv(h) {\n  h = 0.16 + 0.87 * (h - 0.16 - floor(h - 0.16));\n  const q = (h - floor(h)) * 6, i = floor(q), f = q - i;\n  return [[1, f, 0], [1 - f, 1, 0], [0, 1, f], [0, 1 - f, 1], [f, 0, 1], [1, 0, 1 - f]][i % 6];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, typeKnob: 0, a: 0.6, tour: 0, B: null, phase: 0,\n    ph: new Float64Array(0), dp: new Float64Array(0), rgb: [0, 0, 0],\n    edge: new Float64Array(W + 1), evar: new Float64Array(W + 1), epair: new Float64Array(W + 1),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const a = 0.55 + 0.7 * cl(k[3], 0, 1), tk = cl(k[2], 0, 6);\n  const typeNow = (x) => (x \u003c 1 ? -1 : min(5, floor(x) - 1));\n  if (!S.B || typeNow(tk) !== typeNow(S.typeKnob)) {\n    S.typeKnob = tk;\n    S.a = a;\n    newSweep(S, false);\n    // A new type opens just after its sweep has faded in.\n    S.phase = 0.06;\n  } else if (abs(a - S.a) > 0.01) {\n    // Angle rebuilds the same solution with the new k and keeps its time.\n    S.a = a;\n    newSweep(S, true);\n  }\n  S.phase += (d * S.speed) / 18;\n  if (S.phase >= 1) newSweep(S, false), (S.phase -= 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.B) return;\n  const { terms, umax, S: sc } = S.B, n = terms.length;\n  const t = S.tm + (2 * S.phase - 1) * S.T;\n  const cx = S.cx + S.vx * (t - S.tm), cy = S.cy + S.vy * (t - S.tm);\n  // Fade in and out at the ends of the sweep.\n  const fade = min(1, S.phase / 0.06, (1 - S.phase) / 0.06);\n  const ph = S.ph.length === n ? S.ph : (S.ph = new Float64Array(n)), dp = S.dp.length === n ? S.dp : (S.dp = new Float64Array(n));\n  for (let i = 0; i \u003c n; i++) dp[i] = terms[i].p / sc;\n  const cHi = hsv(S.hue + 0.49), cLo = hsv(S.hue + 0.86);\n  const M = S.edge, V = S.evar, P = S.epair;\n  for (let Y = 0; Y \u003c H; Y++) {\n    // The softmax is taken at the 65 edges between the LEDs of a row. The\n    // mean of kappa there is (ln tau)_x, so u averaged over an LED's width\n    // is exactly 2 (mean_right - mean_left) / width: a box filter in x for\n    // the price of one more point a row.\n    const y = cy + (Y - 63.5) / sc, x0 = cx - 32 / sc;\n    for (let i = 0; i \u003c n; i++) {\n      const T = terms[i];\n      ph[i] = T.c + T.p * x0 + T.q * y + T.c3 * t;\n    }\n    for (let X = 0; X \u003c= W; X++) {\n      let m = -1e300;\n      for (let i = 0; i \u003c n; i++) if (ph[i] > m) m = ph[i];\n      let s = 0, s1 = 0, s2 = 0, sw = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const e = ph[i] - m;\n        if (e > -24) {\n          const w = exp(e), p = terms[i].p;\n          s += w;\n          s1 += w * p;\n          s2 += w * p * p;\n          sw += w * w;\n        }\n        ph[i] += dp[i];\n      }\n      const mu = s1 / s;\n      M[X] = mu;\n      V[X] = s2 / s - mu * mu;\n      // u = sum over pairs of w_I w_J (kappa_I - kappa_J)^2, and on a line\n      // where two terms balance 1 - sum w^2 = 2 w (1 - w), so Var / that is\n      // the local soliton's height, smooth through the junctions.\n      P[X] = 1 - sw / (s * s);\n    }\n    for (let X = 0; X \u003c W; X++) {\n      const u = 2 * (M[X + 1] - M[X]) * sc, pr = P[X] + P[X + 1];\n      const amp = pr > 1e-6 ? (V[X] + V[X + 1]) / pr : 0;\n      const ar = cl(amp / umax, 0.02, 1), r = u / umax;\n      // Brightness: the ridge's profile u / height, a little sharpened, times\n      // the 0.3 power of its height, so a low ridge still shows. Colour: the\n      // local soliton's height, cLo for the lowest, cHi for the tallest.\n      // Where u rises above the tallest line, as where two O solitons cross,\n      // the light goes white.\n      const prof = cl(u / (umax * ar), 0, 1.5), g = sqrt(ar), wh = cl((r - 1) / 1.5, 0, 0.7);\n      const v = min(1, prof ** 0.7 * ar ** 0.3) * fade;\n      const rgb = S.rgb;\n      for (let c = 0; c \u003c 3; c++) rgb[c] = v * ((cHi[c] * g + cLo[c] * (1 - g)) * (1 - wh) + wh);\n      display.setPixel(X, Y, round(rgb[0] * 255), round(rgb[1] * 255), round(rgb[2] * 255));\n    }\n  }\n}\n","loop-soup":"// ===== Patternflow pattern =====\n// Title:   Loop Soup\n// Family:  noise\n// Idea:    Closed random walks on a lattice of every other LED, rooted anywhere and sized by the scale-invariant loop measure so that each octave of length holds half as many loops as the one below, are born as a Poisson cloud, draw themselves with a white head until they close, and fade after seven seconds, while every cluster of loops that share a site takes the colour of its longest loop, so at the opening c = 1 the soup shows dozens of separate clusters of every size, and as c rises they merge into one that holds nine tenths of the ink.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Brownian loop soup (Gregory Lawler and Wendelin Werner, 2004), random walk loop soup (Gregory Lawler and José Trujillo Ferreras, 2007), CLE from loop-soup clusters (Scott Sheffield and Wendelin Werner, 2012), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Log2 c=-2..2, Smallest=-1..4\n//\n// Knob 1: Hue. Turns every cluster's colour round the wheel together. Each loop takes the next hue of a golden-ratio sequence, 0.618 of the wheel on from the last, and a cluster shows the hue of its longest loop, so when a long loop is drawn across smaller clusters they all take its colour, and when it fades they get their own back. The wheel skips the orange stretch that reads brown on a fading loop.\n// Knob 2: Speed. At 2 a loop lives 7 s: its head draws it in 0.57 s for 4 steps, 0.22 s longer for each doubling up to 2.55 s for 2048, it shines at full as it closes, eases to 70% and fades over its last 2.5 s. At c = 1 about 20 loops are born a second. 0.2 is ten times slower, 3 one and a half times faster.\n// Knob 3: Log2 c. The intensity c is 2 to this power, 0.25 to 4, and 1 at the opening 0. The loops alive at any moment are a Poisson soup of c/2 times the random walk loop measure, the normalisation in which c is the central charge, and c = 0.25, 0.5 and 1 go with CLE(kappa) for kappa = 2.81, 3 and 4. Measured over six runs of a minute: up to c = 1.4 the largest of 23 to 59 clusters holds about a third of the inked LEDs and crosses the panel from top to bottom in at most 1% of frames; at 2 it crosses in 6%, at 2.8 in 30% holding 59% of the ink, and at 4 in 86% holding 90%. The ink covers 6% of the panel at 0.25, 21% at 1 and 52% at 4.\n// Knob 4: Smallest. The shortest loop, 2 round(2 x 2^K4) steps: at -1 two steps, a dash over one edge and the commonest loop of the measure, 128 of them on the panel at c = 1; at the opening 4 steps, at 2 16 and at 4 64. The small loops are the glue: at c = 4 the largest cluster holds 92% of the ink with the two-step loops in, 90% from 4 steps, 79% from 16 and 71% from 64, and it crosses the panel in 93%, 86%, 58% and 24% of frames.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, exp, log, round, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The lattice: one site every other LED, 32 x 64 on the panel, and the\n// LED between two neighbouring sites is the edge joining them. The soup\n// lives on a bigger lattice, M sites past every side, so loops come in\n// from off the panel and clusters join off it too.\nconst SW = 32, SH = 64, M = 40, GW = SW + 2 * M, GH = SH + 2 * M;\n// Loops have 2j steps, j up to JMAX; the longest, 1024 to 2048 steps, are\n// about 70 LEDs across.\nconst JMAX = 1024;\n// A loop lives LIFE seconds of soup time and fades for the last FADE.\nconst LIFE = 7, FADE = 2.5;\nconst GOLD = 0.618034;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\n// The random walk loop measure: the loops of 2j steps rooted at one site\n// weigh p(2j) / 2j, p(2j) the chance a simple random walk is back at its\n// start after 2j steps, (C(2j, j) / 4^j)^2, about 1 / (pi j). So per site\n// the loops of 2j to 4j steps weigh about 1 / (4 pi j): half as much each\n// octave up, the scale invariance of Lawler and Werner's Brownian loop\n// measure dt dA / (2 pi t^2).\nconst WJ = new Float64Array(JMAX + 1);\n{\n  let r = 1;\n  for (let j = 1; j \u003c= JMAX; j++) {\n    r *= (2 * j - 1) / (2 * j);\n    WJ[j] = (r * r) / (2 * j);\n  }\n}\n// Loops of 2j steps are rooted up to this many sites off the panel.\nconst reach = (j) => min(M, ceil(1.5 * sqrt(j)));\nconst area = (j) => (SW + 2 * reach(j)) * (SH + 2 * reach(j));\n\n// Loops alive at once, per unit of lambda, for the shortest loop 2 jmin.\nfunction table(jmin) {\n  const cum = new Float64Array(JMAX + 1);\n  let t = 0;\n  for (let j = 1; j \u003c= JMAX; j++) {\n    if (j >= jmin) t += WJ[j] * area(j);\n    cum[j] = t;\n  }\n  return cum;\n}\n\nfunction poisson(mu) {\n  // Knuth for small means, a rounded normal for big ones.\n  if (mu > 30) return max(0, round(mu + sqrt(mu) * gauss()));\n  let k = 0, p = 1;\n  const L = exp(-mu);\n  for (;;) {\n    p *= Math.random();\n    if (p \u003c L) return k;\n    k++;\n  }\n}\nfunction gauss() {\n  const u = Math.random() || 1e-9, v = Math.random();\n  return sqrt(-2 * log(u)) * Math.cos(6.283185 * v);\n}\n\n// A uniform random walk bridge of 2j steps from site (a, b). Turned 45\n// degrees, a simple random walk is two independent coin-flip walks, so a\n// walk that comes back is two shuffles of j heads and j tails.\nfunction makeLoop(S, j, a, b, age) {\n  const n = 2 * j, u = new Int8Array(n), v = new Int8Array(n);\n  for (let i = 0; i \u003c n; i++) u[i] = v[i] = i \u003c j ? 1 : -1;\n  for (let i = n - 1; i > 0; i--) {\n    let k = floor(Math.random() * (i + 1)), t = u[i];\n    u[i] = u[k];\n    u[k] = t;\n    k = floor(Math.random() * (i + 1));\n    t = v[i];\n    v[i] = v[k];\n    v[k] = t;\n  }\n  // site[t] is the lattice cell after t steps (or -1 off the lattice);\n  // led[2t] the edge LED of step t and led[2t + 1] the site LED it reaches.\n  const site = new Int32Array(n + 1), led = new Int32Array(2 * n);\n  let x = a, y = b;\n  const cell = (x, y) => (x >= -M && x \u003c SW + M && y >= -M && y \u003c SH + M ? (y + M) * GW + x + M : -1);\n  const px = (X, Y) => (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H ? Y * W + X : -1);\n  site[0] = cell(x, y);\n  for (let t = 0; t \u003c n; t++) {\n    const dx = (u[t] + v[t]) >> 1, dy = (u[t] - v[t]) >> 1;\n    led[2 * t] = px(2 * x + dx, 2 * y + dy);\n    x += dx;\n    y += dy;\n    site[t + 1] = cell(x, y);\n    led[2 * t + 1] = px(2 * x, 2 * y);\n  }\n  // A loop draws itself in 0.35 s for two steps and 0.22 s more for each\n  // doubling, 2.55 s for 2048.\n  const trace = 0.35 + 0.22 * log(j) / log(2);\n  S.loops.push({ j, n, a, b, x1: x, y1: y, site, led, age, trace, hue: (S.seq++ * GOLD) % 1, p: 0 });\n}\n\nfunction birth(S, j, age) {\n  const r = reach(j);\n  const a = floor(-r + Math.random() * (SW + 2 * r)), b = floor(-r + Math.random() * (SH + 2 * r));\n  makeLoop(S, j, a, b, age);\n}\n\nfunction pickJ(S) {\n  const cum = S.cum, t = Math.random() * cum[JMAX];\n  let lo = S.jmin, hi = JMAX;\n  while (lo \u003c hi) {\n    const m = (lo + hi) >> 1;\n    if (cum[m] \u003c t) lo = m + 1;\n    else hi = m;\n  }\n  return lo;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, c: 1, jmin: 2, cum: table(2), loops: [], seq: 0, warm: false,\n    owner: new Int32Array(GW * GH), lev: new Float32Array(W * H), hueAt: new Float32Array(W * H),\n    white: new Uint8Array(W * H), col: new Float32Array(3),\n  };\n}\n\nconst drawnSteps = (L) => (L.age >= L.trace ? L.n : floor((L.n * L.age) / L.trace));\n// A loop's brightness: full as it closes, easing to 70% and fading out.\nconst bright = (L) => {\n  if (L.age \u003c L.trace) return 1;\n  const a = L.age - L.trace;\n  if (L.age > LIFE - FADE) return 0.7 * max(0, (LIFE - L.age) / FADE);\n  return 0.7 + 0.3 * exp(-a / 0.6);\n};\n\nfunction find(par, i) {\n  while (par[i] !== i) i = par[i] = par[par[i]];\n  return i;\n}\n\nfunction step(S, ds) {\n  const lam = S.c / 2;\n  // Age and drop.\n  const loops = S.loops;\n  let w = 0;\n  for (const L of loops) {\n    L.age += ds;\n    if (L.age \u003c LIFE) loops[w++] = L;\n  }\n  loops.length = w;\n  // Poisson births: lam = c/2 times the measure, spread over a lifetime, so\n  // the loops alive at any moment are a loop soup of central charge c.\n  const k = poisson((lam * S.cum[JMAX] * ds) / LIFE);\n  for (let i = 0; i \u003c k; i++) birth(S, pickJ(S), Math.random() * ds);\n}\n\n// Clusters: loops that share a site, drawn so far, on or off the panel.\nfunction cluster(S) {\n  const { loops, owner } = S, n = loops.length, par = new Int32Array(n);\n  owner.fill(-1);\n  for (let i = 0; i \u003c n; i++) par[i] = i;\n  for (let i = 0; i \u003c n; i++) {\n    const L = loops[i], s = L.site, k = drawnSteps(L);\n    for (let t = 0; t \u003c= k; t++) {\n      const g = s[t];\n      if (g \u003c 0) continue;\n      const o = owner[g];\n      if (o \u003c 0) owner[g] = i;\n      else {\n        const ra = find(par, o), rb = find(par, i);\n        if (ra !== rb) par[ra] = rb;\n      }\n    }\n  }\n  // Each cluster takes the colour of its longest loop, the oldest of those.\n  const lead = new Int32Array(n).fill(-1);\n  for (let i = 0; i \u003c n; i++) {\n    const r = find(par, i), l = lead[r];\n    if (l \u003c 0 || loops[i].n > loops[l].n || (loops[i].n === loops[l].n && loops[i].age > loops[l].age)) lead[r] = i;\n  }\n  for (let i = 0; i \u003c n; i++) loops[i].p = loops[lead[find(par, i)]].hue;\n  S.par = par;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.c = 2 ** cl(k[2], -2, 2);\n  const jmin = max(1, round(2 * 2 ** cl(k[3], -1, 4)));\n  if (jmin !== S.jmin) {\n    S.jmin = jmin;\n    S.cum = table(jmin);\n    S.loops = S.loops.filter((L) => L.j >= jmin);\n  }\n  if (!S.warm) {\n    // Open on a soup already at its steady state: every length its Poisson\n    // count, each loop somewhere in its life.\n    const lam = S.c / 2;\n    for (let j = jmin; j \u003c= JMAX; j++) {\n      const q = poisson(lam * WJ[j] * area(j));\n      for (let i = 0; i \u003c q; i++) birth(S, j, Math.random() * LIFE);\n    }\n    S.warm = true;\n  }\n  step(S, (d * S.speed) / 2);\n  cluster(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { lev, hueAt, white, col } = S;\n  lev.fill(0);\n  white.fill(0);\n  for (const L of S.loops) {\n    const b = bright(L), k = drawnSteps(L), led = L.led;\n    if (b \u003c= 0) continue;\n    // The root LED, then every step drawn so far.\n    const r = led[2 * L.n - 1];\n    if (r >= 0 && b > lev[r]) (lev[r] = b), (hueAt[r] = L.p);\n    for (let i = 0; i \u003c 2 * k; i++) {\n      const p = led[i];\n      if (p >= 0 && b > lev[p]) (lev[p] = b), (hueAt[p] = L.p);\n    }\n    // The walker's head, white, while the loop is being drawn.\n    if (k \u003c L.n && k > 0) {\n      const p = led[2 * k - 1];\n      if (p >= 0) white[p] = 1;\n    }\n  }\n  const h0 = S.hue + 0.5;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (white[p]) {\n        display.setPixel(x, y, 255, 255, 255);\n        continue;\n      }\n      const v = lev[p];\n      if (v \u003c= 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      hsv(wheel(h0 + hueAt[p]), 0.8, v, col, 0);\n      display.setPixel(x, y, round(col[0] * 255), round(col[1] * 255), round(col[2] * 255));\n    }\n}\n","mirror-curves":"// ===== Patternflow pattern =====\n// Title:   Mirror Curves\n// Family:  topology\n// Idea:    A light ray runs at 45 degrees round a 4 x 8 grid of dots on a board that wraps like a torus, bouncing off the two-sided mirrors on half of the 64 sites between the dots, and each closed path it makes is one strand of an alternating link, woven over and under at every free crossing and coloured on its own, while about once a second a mirror turns or moves, joining or splitting strands, and the new colour runs out along the strand from that mirror.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: mirror curves (Slavik Jablan, 2001), Lunda designs from the Chokwe sona (Paulus Gerdes, 1990s), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mirrors=0.5..1, Join=0..1\n//\n// Knob 1: Hue. Turns the eight strand colours round the wheel together. At 0 they are sky, amber, green, magenta, turquoise, violet, lime and pink; at 0.5 each takes the colour opposite, sky turning orange and green magenta. The dots and mirrors stay white and the faint field behind stays blue and violet.\n// Knob 2: Speed. At 2 the whole board drifts one LED right and one down every 0.67 s, a mirror turns or moves every 0.83 s, and its new colour runs along the strand at 130 LEDs a second. At 0.2 all of it is ten times slower; at 3 half as fast again.\n// Knob 3: Mirrors. The share of the 64 sites that hold a mirror: 32 at 0.5, so a strand bends at about every other site, 48 at 0.75, and all 64 at 1, where no strand crosses another and every strand is a closed loop fenced in by mirrors. The lit LEDs go from 800 to 864.\n// Knob 4: Join. How many strands the walk keeps: 8 at 0, 6 at 0.25, 5 at 0.5, 3 at 0.75, and at 1 a single closed curve through all 128 segments, the board drawn in one stroke as the sona drawers aimed to draw it.\n// Buttons: K3 tap frames the board for 4 seconds: every inner mirror is lifted, the 12 sites on the panel's left and top edges take mirrors along the edge, the drift stops, and the 4 x 8 rectangle is drawn by gcd(4, 8) = 4 strands. A second tap, or the end of the 4 seconds, puts the mirrors back.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, max, round, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const rgb = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[0] = rgb[0];\n  out[1] = rgb[1];\n  out[2] = rgb[2];\n}\n\n// The grid in half-cell units: a cell is 16 LEDs, so u runs 0..7 across and\n// v 0..15 down, both wrapping. Dots sit at (odd, odd), cell corners at\n// (even, even), and the crossing sites, the midpoints of the cell edges, at\n// u + v odd: 64 of them. The strands run between sites in 45-degree steps,\n// so every lit LED has x + y even and the four LEDs round it dark; where\n// x + y is odd the panel is always dark, and where it is even and nothing\n// is drawn it shows the field at level 40. A kept crossing drops four LEDs\n// from the strand under it and a mirror two, so with M mirrors the panel\n// holds 736 + 2M LEDs at 255 in every frame: 800 at the opening, which\n// puts the measured edges at 0.195 and the detail at 0.318.\nconst HC = 8, NU = W / HC, NV = H / HC;\nconst mod = (a, m) => ((a % m) + m) % m;\nconst SU = [], SV = [], SITE = new Int16Array(NU * NV).fill(-1);\nfor (let v = 0; v \u003c NV; v++)\n  for (let u = 0; u \u003c NU; u++)\n    if ((u + v) & 1) {\n      SITE[v * NU + u] = SU.length;\n      SU.push(u);\n      SV.push(v);\n    }\nconst NS = SU.length;\nconst siteAt = (u, v) => SITE[mod(v, NV) * NU + mod(u, NU)];\n// Segment 2s runs from site s down-right, 2s + 1 up-right, 8 LED steps each.\n// A site's four ports: 0 up-left, 1 up-right, 2 down-left, 3 down-right.\nconst PORT = new Int16Array(NS * 4);\nfor (let s = 0; s \u003c NS; s++) {\n  const u = SU[s], v = SV[s];\n  PORT[s * 4] = 2 * siteAt(u - 1, v - 1);\n  PORT[s * 4 + 1] = 2 * s + 1;\n  PORT[s * 4 + 2] = 2 * siteAt(u - 1, v + 1) + 1;\n  PORT[s * 4 + 3] = 2 * s;\n}\n// Which port pairs with which: a crossing goes straight on, a mirror lying\n// across the panel (kind 1) sends the ray back up or down, a mirror\n// standing up (kind 2) back left or right.\nconst PAIR = [[3, 2, 1, 0], [1, 0, 3, 2], [2, 3, 0, 1]];\n// The far end of segment k: its site and the port it arrives at.\nconst segEnd = (k) => {\n  const s = k >> 1, up = k & 1;\n  return [siteAt(SU[s] + 1, SV[s] + (up ? -1 : 1)), up ? 2 : 0];\n};\n\n// Strand hues. After a change each strand keeps the hue it shares most\n// segments with, and a new strand takes one that no other strand holds.\nconst PAL = [0.56, 0.12, 0.34, 0.84, 0.47, 0.7, 0.2, 0.92];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, share: 0.5, join: 0.06, target: 8, clock: 0,\n    kind: new Int8Array(NS), comp: new Int16Array(NS * 2), slot: new Int8Array(NS * 2),\n    hA: new Float32Array(NS * 2), hB: new Float32Array(NS * 2), t0: new Float32Array(NS * 2),\n    ox: 0, oy: 0, panT: 0, evT: 0, fresh: true, comps: 0, frame: 0, saved: null,\n    R: new Uint8Array(N), G: new Uint8Array(N), B: new Uint8Array(N), c: [0, 0, 0],\n  };\n}\n\nfunction mirrorCount(S) {\n  let m = 0;\n  for (let s = 0; s \u003c NS; s++) if (S.kind[s]) m++;\n  return m;\n}\n\n// Union the two segments each site joins; the classes are the closed\n// components of the curve.\nfunction components(S) {\n  const P = new Int16Array(NS * 2);\n  for (let i = 0; i \u003c P.length; i++) P[i] = i;\n  const find = (a) => {\n    while (P[a] !== a) a = P[a] = P[P[a]];\n    return a;\n  };\n  for (let s = 0; s \u003c NS; s++) {\n    const pr = PAIR[S.kind[s]];\n    for (let a = 0; a \u003c 4; a++)\n      if (pr[a] > a) {\n        const x = find(PORT[s * 4 + a]), y = find(PORT[s * 4 + pr[a]]);\n        if (x !== y) P[x] = y;\n      }\n  }\n  const id = new Int16Array(NS * 2).fill(-1);\n  let n = 0;\n  for (let k = 0; k \u003c NS * 2; k++) {\n    const r = find(k);\n    if (id[r] \u003c 0) id[r] = n++;\n    S.comp[k] = id[r];\n  }\n  S.comps = n;\n  return n;\n}\n\n// After a change, each new component keeps the colour slot it shares most\n// segments with, biggest overlap first; the rest take free slots. Segments\n// whose slot changed take the new hue as a wave running out from the\n// changed sites along the strand.\nfunction recolour(S, from) {\n  const n = components(S), K = PAL.length;\n  const cnt = new Int32Array(n * K);\n  for (let k = 0; k \u003c NS * 2; k++) cnt[S.comp[k] * K + S.slot[k]]++;\n  const order = [];\n  for (let i = 0; i \u003c n * K; i++) if (cnt[i]) order.push(i);\n  order.sort((a, b) => cnt[b] - cnt[a]);\n  const got = new Int8Array(n).fill(-1), used = new Int16Array(K);\n  for (const i of order) {\n    const c = floor(i / K), sl = i % K;\n    if (got[c] \u003c 0 && !used[sl]) (got[c] = sl), used[sl]++;\n  }\n  for (let c = 0; c \u003c n; c++)\n    if (got[c] \u003c 0) {\n      let best = 0;\n      for (let sl = 1; sl \u003c K; sl++) if (used[sl] \u003c used[best]) best = sl;\n      got[c] = best;\n      used[best]++;\n    }\n  // Distance along the curve from the changed sites, in segments.\n  const dist = new Int16Array(NS * 2).fill(-1), q = [];\n  for (const s of from)\n    for (let a = 0; a \u003c 4; a++) {\n      const k = PORT[s * 4 + a];\n      if (dist[k] \u003c 0) (dist[k] = 0), q.push(k);\n    }\n  for (let i = 0; i \u003c q.length; i++) {\n    const k = q[i];\n    const ends = [[k >> 1, k & 1 ? 1 : 3], segEnd(k)];\n    for (const [s, a] of ends) {\n      const j = PORT[s * 4 + PAIR[S.kind[s]][a]];\n      if (dist[j] \u003c 0) (dist[j] = dist[k] + 1), q.push(j);\n    }\n  }\n  for (let k = 0; k \u003c NS * 2; k++) {\n    const sl = got[S.comp[k]];\n    if (S.fresh) {\n      S.hA[k] = S.hB[k] = PAL[sl];\n    } else if (sl !== S.slot[k]) {\n      S.hA[k] = hueNow(S, k);\n      S.hB[k] = PAL[sl];\n      S.t0[k] = S.clock + 0.06 * max(0, dist[k]);\n    }\n    S.slot[k] = sl;\n  }\n}\n\nfunction hueNow(S, k) {\n  const a = cl((S.clock - S.t0[k]) / 0.12, 0, 1);\n  let dh = S.hB[k] - S.hA[k];\n  dh -= round(dh);\n  return S.hA[k] + dh * a;\n}\n\nfunction pick(S, want) {\n  // Random site of the wanted kind (mirror or crossing).\n  let s;\n  do s = floor(random() * NS);\n  while (want ? !S.kind[s] : S.kind[s]);\n  return s;\n}\n\nfunction setMirrors(S, M) {\n  let m = mirrorCount(S);\n  const ch = [];\n  while (m \u003c M) {\n    const s = pick(S, false);\n    S.kind[s] = 1 + floor(random() * 2);\n    ch.push(s);\n    m++;\n  }\n  while (m > M) {\n    const s = pick(S, true);\n    S.kind[s] = 0;\n    ch.push(s);\n    m--;\n  }\n  return ch;\n}\n\nfunction propose(S) {\n  // Half the time a mirror turns a quarter turn; otherwise it moves to a\n  // free crossing. Either way the count of mirrors stays.\n  if (random() \u003c 0.5 || mirrorCount(S) === NS) {\n    const s = pick(S, true);\n    return [[s, 3 - S.kind[s]]];\n  }\n  const a = pick(S, true), b = pick(S, false);\n  return [[b, 1 + floor(random() * 2)], [a, 0]];\n}\n\n// How far the link is from what the walk wants: the wanted number of\n// strands first, then no strand much longer than the others.\nfunction score(S) {\n  const n = components(S), len = new Int16Array(n);\n  let big = 0;\n  for (let k = 0; k \u003c NS * 2; k++) big = max(big, ++len[S.comp[k]]);\n  return 200 * Math.abs(n - S.target) + big;\n}\n\nfunction event(S) {\n  // A change that leaves the link further from that is made only when 24\n  // tries find nothing better.\n  const now = score(S);\n  let best = null, bestD = 1e9;\n  for (let tries = 0; tries \u003c 24; tries++) {\n    const ch = propose(S), old = ch.map(([s]) => S.kind[s]);\n    for (const [s, kd] of ch) S.kind[s] = kd;\n    const dd = score(S) - now;\n    ch.forEach(([s], i) => (S.kind[s] = old[i]));\n    if (dd \u003c= 4) {\n      best = ch;\n      break;\n    }\n    if (dd \u003c bestD) (bestD = dd), (best = ch);\n  }\n  for (const [s, kd] of best) S.kind[s] = kd;\n  recolour(S, best.map(([s]) => s));\n}\n\n// The seam of the torus, where column 0 meets column 63 and row 0 meets\n// row 127. Mirrors along all twelve of its sites make the board a framed\n// 4 x 8 rectangle, and a framed board with no other mirror is drawn by\n// gcd(4, 8) = 4 strands.\nconst SEAM = [];\nfor (let s = 0; s \u003c NS; s++) if (SU[s] === 0 || SV[s] === 0) SEAM.push(s);\n\nfunction frame(S, on) {\n  if (on) {\n    S.saved = S.kind.slice();\n    S.kind.fill(0);\n    for (const s of SEAM) S.kind[s] = SU[s] === 0 ? 2 : 1;\n    S.ox = S.oy = 0;\n    S.frame = 4;\n    recolour(S, SEAM);\n  } else if (S.saved) {\n    S.kind.set(S.saved);\n    S.saved = null;\n    S.frame = 0;\n    recolour(S, SEAM);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.share = cl(k[2], 0.5, 1);\n  S.join = cl(k[3], 0, 1);\n  S.target = round(8 - 7 * S.join);\n  const ds = (d * S.speed) / 2;\n  S.clock += ds;\n  if (input.btnPressed && input.btnPressed[2]) frame(S, S.frame \u003c= 0);\n  if (S.frame > 0) {\n    S.frame -= d;\n    if (S.frame \u003c= 0) frame(S, false);\n    return;\n  }\n  const M = round(S.share * NS);\n  if (mirrorCount(S) !== M) {\n    const ch = setMirrors(S, M);\n    recolour(S, ch);\n  }\n  if (S.fresh) {\n    // Open on a board the walk has already brought to its strand count.\n    for (let i = 0; i \u003c 80; i++) event(S);\n    S.fresh = false;\n  }\n  // The board is a torus exactly the panel's size, so a step of one LED\n  // right and one down keeps every lit LED on the even class.\n  S.panT += ds * 1.5;\n  while (S.panT >= 1) {\n    S.panT -= 1;\n    S.ox = (S.ox + 1) % W;\n    S.oy = (S.oy + 1) % H;\n  }\n  S.evT += ds * 1.2;\n  while (S.evT >= 1) {\n    S.evT -= 1;\n    event(S);\n  }\n}\n\nfunction put(S, x, y, h, sat) {\n  const c = S.c, p = mod(y, H) * W + mod(x, W);\n  hsv(h, sat, 1, c);\n  S.R[p] = round(c[0] * 255);\n  S.G[p] = round(c[1] * 255);\n  S.B[p] = round(c[2] * 255);\n}\nfunction dim(S, x, y) {\n  const p = mod(y, H) * W + mod(x, W);\n  S.R[p] = S.G[p] = S.B[p] = 40;\n}\n// The field shades the faces of the diagram in two colours, blue round\n// the dots and violet round the cell corners. A mirror only ever joins two\n// faces of the same colour, so the checkerboard holds whatever the mirrors do.\nfunction bg(S, x, y) {\n  x = mod(x, W);\n  y = mod(y, H);\n  const p = y * W + x, c = S.c;\n  if ((x + y) & 1) {\n    S.R[p] = S.G[p] = S.B[p] = 0;\n    return;\n  }\n  const dx = (x & 15) - 8, dy = (y & 15) - 8;\n  const inDot = (dx \u003c 0 ? -dx : dx) + (dy \u003c 0 ? -dy : dy) \u003c 8;\n  hsv(inDot ? 0.62 : 0.76, inDot ? 0.7 : 0.5, 1, c);\n  S.R[p] = round(c[0] * 40);\n  S.G[p] = round(c[1] * 40);\n  S.B[p] = round(c[2] * 40);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) bg(S, x, y);\n  const hu = S.hue;\n  // Strands.\n  for (let k = 0; k \u003c NS * 2; k++) {\n    const s = k >> 1, dv = k & 1 ? -1 : 1, h = hu + hueNow(S, k);\n    for (let t = 1; t \u003c 8; t++) put(S, SU[s] * HC + t, SV[s] * HC + dv * t, h, 1);\n  }\n  for (let s = 0; s \u003c NS; s++) {\n    const x = SU[s] * HC, y = SV[s] * HC, kd = S.kind[s];\n    if (kd === 0) {\n      // Alternating: at a site on a vertical cell edge (u even) the\n      // down-right strand goes over, on a horizontal edge the up-right one.\n      const d1 = (SU[s] & 1) === 0;\n      const ov = PORT[s * 4 + (d1 ? 3 : 1)];\n      put(S, x, y, hu + hueNow(S, ov), 1);\n      for (let t = 1; t \u003c= 2; t++) {\n        if (d1) bg(S, x + t, y - t), bg(S, x - t, y + t);\n        else bg(S, x + t, y + t), bg(S, x - t, y - t);\n      }\n    } else {\n      // Each pair of arms turns back two LEDs short of the mirror over a flat\n      // end of three LEDs, and the mirror is a white LED at the site with a\n      // grey one, at the field's level, each side of it.\n      const ax = kd === 1 ? 2 : 0, ay = 2 - ax;\n      bg(S, x - 1, y - 1), bg(S, x + 1, y - 1), bg(S, x - 1, y + 1), bg(S, x + 1, y + 1);\n      put(S, x - ay, y - ax, hu + hueNow(S, PORT[s * 4]), 1);\n      put(S, x + ay, y + ax, hu + hueNow(S, PORT[s * 4 + 3]), 1);\n      put(S, x, y, 0, 0);\n      dim(S, x - ax, y - ay);\n      dim(S, x + ax, y + ay);\n    }\n  }\n  // Dots at the cell centres.\n  for (let v = 1; v \u003c NV; v += 2) for (let u = 1; u \u003c NU; u += 2) put(S, u * HC, v * HC, 0, 0);\n  for (let y = 0; y \u003c H; y++) {\n    const sy = mod(y - S.oy, H) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const p = sy + mod(x - S.ox, W);\n      display.setPixel(x, y, S.R[p], S.G[p], S.B[p]);\n    }\n  }\n}\n","print-gallery":"// ===== Patternflow pattern =====\n// Title:   Print Gallery\n// Family:  fractal\n// Idea:    A checker of square rings in four to eight colours, which holds itself scaled down by s, is seen through de Smit and Lenstra's map, log z divided by 2 pi i / (2 pi i + log s), so its nested copies join into spiral arms and its white frame into one spiral line, and an endless zoom turns the panel round and in until after one period it shows the same picture to the last LED.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the conformal map behind M. C. Escher's Print Gallery (Bart de Smit and Hendrik Lenstra, 2003), the Droste effect, pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=16..256, Unwind=0..1\n//\n// Knob 1: Hue. Turns the ring colours round the wheel together, each ring a light cell beside a dark one. At 0 and Scale 16 the four rings run aqua, azure, violet and magenta; at 0.5 pink, red, green and sea green. The wheel skips dim orange, which reads brown.\n// Knob 2: Speed. The zoom passes one ring of the base, a factor 2, every 1.4 seconds at 2, so one period at Scale 16 takes 5.6 seconds and at 256 takes 11.2; 0.2 is ten times slower, 3 one and a half times faster.\n// Knob 3: Scale. The Droste factor s, snapped to 16, 32, 64, 128 or 256: the base holds 4 to 8 rings before it repeats, and they become as many spiral arms. One period of the twisted picture is a zoom of 10.2 with a turn of 59 degrees at 16, 18.0 and 110 degrees at 64, and 22.6 and 158 degrees at 256, the factor Escher drew.\n// Knob 4: Unwind. Undoes the twist. Up to 0.1 the map is Escher's, from 0.9 the panel shows the plain Droste picture of nested squares, and in between the picture tears along the ray left of the centre, where the rings fail to meet by s to the power of the twist: at Scale 16 and 0.5 the two sides are two rings apart.\n\nconst W = 64, H = 128;\nconst { floor, max, exp, log, sqrt, cos, sin, atan2, abs, round, PI, LN2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The base picture is a Droste picture: square rings, each twice the size of\n// the one inside it, the ring between half-sides 2^j and 2^(j+1) a checker of\n// cells 2^(j-1) wide with dark grout between them. Ring j takes colour j mod\n// m, and ring 0 has a white frame round its inside, so the picture holds\n// itself scaled by 1/s, s = 2^m, and by no smaller factor. f(z) = f(z / s):\n// in w = log z it is periodic under the lattice Z log s + Z 2 pi i.\n// The twisted picture shows f(exp(w / beta)), beta = 2 pi i / (2 pi i + log s),\n// so 1 / beta = 1 - i log s / (2 pi). Then 2 pi i / beta = log s + 2 pi i is\n// a lattice vector and the picture is single-valued: once round the centre\n// takes a ring to the same-coloured ring s times bigger, and the m rings of\n// a period join into m spiral arms. Between 1 and 1 / beta the seam along the\n// cut, the ray to the left of the centre, does not close.\n\n// Each subsample's log-polar place, fixed: ln r in LEDs and the angle. Out\n// past 20 LEDs from the centre a cell is 7 LEDs or more and 2 x 2 samples\n// clean its edges; inside, where the rings shrink, 3 x 3.\nconst START = new Int32Array(W * H + 1), FP = new Float32Array(W * H);\nconst LRa = [], THa = [];\nfor (let y = 0, p = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++, p++) {\n    const dx = x + 0.5 - 32, dy = y + 0.5 - 64, r = sqrt(dx * dx + dy * dy);\n    const ss = r \u003c 20 ? 3 : 2;\n    START[p] = LRa.length;\n    for (let j = 0; j \u003c ss; j++)\n      for (let i = 0; i \u003c ss; i++) {\n        const ex = x + (i + 0.5) / ss - 32, ey = y + (j + 0.5) / ss - 64;\n        LRa.push(0.5 * log(ex * ex + ey * ey + 1e-9));\n        THa.push(atan2(ey, ex));\n      }\n    // 1 / r: how far one LED reaches in log z.\n    FP[p] = 1 / max(r, 1e-3);\n  }\nSTART[W * H] = LRa.length;\nconst LR = Float32Array.from(LRa), TH = Float32Array.from(THa);\n\n// Dim orange reads brown on the panel, so the wheel skips 0.03 to 0.16.\nfunction hsv(h, s, v, out, o) {\n  h = 0.16 + 0.87 * (h - 0.16 - floor(h - 0.16));\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, m: 4, tw: 1, zoom: 0, pal: new Float32Array(9 * 3 * 3), palKey: \"\", mean: [0, 0, 0] };\n}\n\n// The twist for Unwind u: 1 (Escher's map) up to 0.1, 0 (the plain Droste\n// picture) from 0.9, straight between.\nconst twistOf = (u) => 1 - cl((u - 0.1) / 0.8, 0, 1);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // s snaps to a power of two: m rings to a period.\n  S.m = cl(round(Math.log2(cl(k[2], 16, 256))), 4, 8);\n  S.tw = twistOf(cl(k[3], 0, 1));\n  // One ring of the base, a factor 2, every 1.4 s at Speed 2. zoom runs\n  // down, so the base point under each LED moves inward: the panel zooms in.\n  S.zoom -= (d * S.speed * LN2) / 2.8;\n  const L = S.m * LN2;\n  if (S.zoom \u003c -L) S.zoom += L;\n}\n\n// Palette: per ring colour, light cell, dark cell, frame.\nfunction palette(S) {\n  const key = S.hue.toFixed(4) + \",\" + S.m;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const m = S.m, P = S.pal;\n  let r = 0, g = 0, b = 0;\n  for (let j = 0; j \u003c m; j++) {\n    const h = S.hue + 0.5 + (0.62 * j) / m;\n    hsv(h, 0.72, 1, P, j * 9);\n    hsv(h + 0.03, 0.9, 0.3, P, j * 9 + 3);\n    hsv(h, 0.12, 1, P, j * 9 + 6);\n    r += (P[j * 9] + P[j * 9 + 3]) / (2 * m);\n    g += (P[j * 9 + 1] + P[j * 9 + 4]) / (2 * m);\n    b += (P[j * 9 + 2] + P[j * 9 + 5]) / (2 * m);\n  }\n  // Grout covers a sixth of the base.\n  S.mean = [0.83 * r, 0.83 * g, 0.83 * b];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  // 1 / beta = 1 - i c1, c1 = log s / (2 pi) at full twist.\n  const m = S.m, L = m * LN2, c1 = (S.tw * L) / (2 * PI), P = S.pal, zoom = S.zoom;\n  // |1 / beta|: how much the map stretches log z.\n  const na = sqrt(1 + c1 * c1), mean = S.mean;\n  for (let p = 0; p \u003c W * H; p++) {\n    // Near the centre one LED covers more of the base than its samples can\n    // hold, so it fades to the picture's mean colour.\n    const fp = FP[p] * na, keep = cl((0.3 - fp) / 0.15, 0, 1);\n    let r = 0, g = 0, b = 0;\n    if (keep > 0) {\n      const q0 = START[p], q1 = START[p + 1];\n      for (let q = q0; q \u003c q1; q++) {\n        // w / beta = (1 - i c1)(ln r + i theta), and the zoom.\n        const lr = LR[q], th = TH[q];\n        let re = lr + c1 * th + zoom;\n        const im = th - c1 * lr;\n        // Reduce to the ring: re mod ln 2, then the square norm into [1, 2).\n        let j = floor(re / LN2);\n        re -= j * LN2;\n        const e = exp(re), X = e * cos(im), Y = e * sin(im);\n        let ax = abs(X), ay = abs(Y), n = ax > ay ? ax : ay;\n        if (n \u003c 1) (ax *= 2), (ay *= 2), (n *= 2), j--;\n        else if (n >= 2) (ax *= 0.5), (ay *= 0.5), (n *= 0.5), j++;\n        const c = ((j % m) + m) % m;\n        const gx = ax * 2, gy = ay * 2, fx = gx - floor(gx), fy = gy - floor(gy);\n        let o = -1;\n        if (c === 0 && n \u003c 1.07) o = c * 9 + 6;\n        else if (fx > 0.045 && fx \u003c 0.955 && fy > 0.045 && fy \u003c 0.955)\n          o = c * 9 + (((floor(gx) + floor(gy) + (X \u003c 0) + (Y \u003c 0)) & 1) ? 3 : 0);\n        if (o >= 0) (r += P[o]), (g += P[o + 1]), (b += P[o + 2]);\n      }\n      const inv = 1 / (q1 - q0);\n      r *= inv;\n      g *= inv;\n      b *= inv;\n    }\n    const f = 1 - keep;\n    r = r * keep + mean[0] * f;\n    g = g * keep + mean[1] * f;\n    b = b * keep + mean[2] * f;\n    display.setPixel(p % W, (p / W) | 0, round(r * 255), round(g * 255), round(b * 255));\n  }\n}\n","rayleigh-taylor":"// ===== Patternflow pattern =====\n// Title:   Rayleigh-Taylor\n// Family:  sim\n// Idea:    A heavy fluid rests on a light one across the middle of the panel, and the faint ripple on the line between them grows until heavy fingers fall to the bottom with mushroom caps that curl at their rims while light bubbles rise to the top, the two fluids churning into each other until a fresh layer settles in.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Rayleigh-Taylor instability (Lord Rayleigh, 1883; G. I. Taylor, 1950), Boussinesq vorticity-streamfunction flow, pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Modes=3..9, Viscosity=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the heavy fluid is orchid violet, the light fluid dark teal, fluid mixed half and half azure, and the sharp line between them pale lilac; at 0.25 orange over indigo through purple, at 0.5 green over dark magenta through red, at 0.75 sky blue over dark green through green. The light fluid and the mixture skip the orange and yellow part of the wheel, which reads brown and olive when dim.\n// Knob 2: Speed. At 2 the opening ripple grows by e every 0.54 s, the mushroom caps curl over about 3 s into a layer, the heavy fingers reach the floor and the light bubbles the lid between 5 and 6.5 s, and at 8.6 s the churned column fades over 1 s into a fresh layer. At 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Modes. How many half waves of the first ripple fit across the box, 3 to 9, rounded; each layer also carries the next wave up and the next down at under a third of the size, so the fingers come out unequal. At 3 two heavy fingers fall and two light bubbles rise, 43 LEDs apart, one of each against a wall; at 9 five thin ones of each, 14 LEDs apart. The shorter waves grow faster, by e in 0.54 s at 3, 0.41 s at 6 and 0.37 s at 9, where the square root of A g k alone would give 0.49, 0.35 and 0.28 s: the line between the fluids is 2 LEDs thick, which slows a short wave more than a long one. A new value starts a fresh layer.\n// Knob 4: Viscosity. nu = 0.1 x 400^K4 LEDs squared a second, and the density diffuses at a quarter of that plus 0.05: nu is 0.14 at the opening 0.06, 2 at 0.5 and 40 at 1. At the opening the caps roll up into tight curls and the stems shed small ones; at 0.5 the fingers fall as smooth tongues with one curl each; at 1 a ripple of three half waves grows by e only every 1.3 s, one of six dies away, and soft blurred fingers sag into each other.\n// Buttons: K1 tap starts a fresh layer.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sin, cos, sqrt, round, abs, tanh, random, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Units: one LED and one second at Speed 2. G is the reduced gravity A g,\n// in LEDs per second squared; the heavy fluid is rho = +1, the light -1.\nconst G = 28;\nconst Y0 = 63.5, DELTA = 1, A0 = 0.25;\nconst CYCLE = 8.6, FADE = 1;\nconst NU0 = 0.1, NUR = 400;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The box has free-slip walls on all four sides: the side walls at column\n// 0 and at column 64, one past the panel's edge, the floor and the lid one\n// row outside the panel, at rows -1 and 128. The streamfunction and the\n// vorticity are zero on every wall, so across the panel both are sums of\n// sin(pi k x / 64), k = 1..63, and a sine transform of each row turns the\n// Poisson equation into one tridiagonal solve down the panel per k. The\n// transform is a complex FFT of length 128 over the row and its mirror\n// image turned upside down, two rows at a time.\nconst NF = 128, LOGF = 7, K = 63;\nconst REV = new Uint8Array(NF), CS = new Float64Array(NF / 2), SN = new Float64Array(NF / 2);\nfor (let i = 0; i \u003c NF; i++) {\n  let r = 0;\n  for (let b = 0; b \u003c LOGF; b++) r |= ((i >> b) & 1) \u003c\u003c (LOGF - 1 - b);\n  REV[i] = r;\n}\nfor (let i = 0; i \u003c NF / 2; i++) (CS[i] = cos((TAU * i) / NF)), (SN[i] = -sin((TAU * i) / NF));\nfunction fft(re, im) {\n  for (let i = 0; i \u003c NF; i++) {\n    const j = REV[i];\n    if (j > i) {\n      let t = re[i];\n      (re[i] = re[j]), (re[j] = t);\n      t = im[i];\n      (im[i] = im[j]), (im[j] = t);\n    }\n  }\n  for (let size = 2; size \u003c= NF; size \u003c\u003c= 1) {\n    const half = size >> 1, step = NF / size;\n    for (let s = 0; s \u003c NF; s += size)\n      for (let k = 0; k \u003c half; k++) {\n        const wr = CS[k * step], wi = SN[k * step], a = s + k, b = a + half;\n        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;\n        (re[b] = re[a] - xr), (im[b] = im[a] - xi);\n        (re[a] += xr), (im[a] += xi);\n      }\n  }\n}\n\n// The sine transform S_k = sum_x f_x sin(pi k x / 64), k = 1..63, of each\n// row of f into column k of R (R[k H + y]). An odd sequence's FFT is -2i\n// times its sine transform, so of two rows packed into one FFT, row y\n// comes out in the imaginary part and row y + 1 in the real part.\nfunction toModes(S, f, R) {\n  const { zr, zi } = S;\n  for (let y = 0; y \u003c H; y += 2) {\n    zr[0] = zi[0] = zr[64] = zi[64] = 0;\n    for (let x = 1, o = y * W + 1; x \u003c= K; x++, o++) {\n      const a = f[o], b = f[o + W];\n      (zr[x] = a), (zi[x] = b), (zr[NF - x] = -a), (zi[NF - x] = -b);\n    }\n    fft(zr, zi);\n    for (let k = 1; k \u003c= K; k++) (R[k * H + y] = -0.5 * zi[k]), (R[k * H + y + 1] = 0.5 * zr[k]);\n  }\n}\n// The transform is its own inverse but for a factor 2 / 64. Column 0 is\n// the side wall.\nfunction fromModes(S, R, f) {\n  const { zr, zi } = S;\n  for (let y = 0; y \u003c H; y += 2) {\n    zr[0] = zi[0] = zr[64] = zi[64] = 0;\n    for (let k = 1; k \u003c= K; k++) {\n      const a = R[k * H + y], b = R[k * H + y + 1];\n      (zr[k] = a), (zi[k] = b), (zr[NF - k] = -a), (zi[NF - k] = -b);\n    }\n    fft(zr, zi);\n    f[y * W] = f[(y + 1) * W] = 0;\n    for (let x = 1, o = y * W + 1; x \u003c= K; x++, o++) (f[o] = -zi[x] / 64), (f[o + W] = zr[x] / 64);\n  }\n}\n\n// Solves (b - D2) out = rhs * scale down column o of the modes, D2 the\n// second difference in y, with out = 0 on the walls at rows -1 and 128.\nfunction tri(S, R, o, b, scale) {\n  const { cp, dp } = S, diag = b + 2;\n  for (let y = 0; y \u003c H; y++) {\n    const den = diag + (y ? cp[y - 1] : 0);\n    cp[y] = -1 / den;\n    dp[y] = (R[o + y] * scale + (y ? dp[y - 1] : 0)) / den;\n  }\n  R[o + H - 1] = dp[H - 1];\n  for (let y = H - 2; y >= 0; y--) R[o + y] = dp[y] - cp[y] * R[o + y + 1];\n}\n\nexport function setup(params) {\n  const f = () => new Float64Array(NP);\n  params.s = {\n    w: f(), r: f(), psi: f(), u: f(), v: f(), wa: f(), ra: f(), wb: f(), rb: f(), tmp: f(),\n    DX: new Float32Array(NP), DY: new Float32Array(NP), WR: f(), PR: f(),\n    zr: new Float64Array(NF), zi: new Float64Array(NF), cp: new Float64Array(H), dp: new Float64Array(H),\n    t: 0, total: 0, fade: 0, old: new Float32Array(NP * 3), rgb: new Float32Array(NP * 3), started: false,\n    hue: 0, speed: 2, modes: 3, layer: 3, nu: 0.2, kappa: 0.1, col: new Float32Array(12),\n  };\n}\n\n// A fresh layer: heavy over light across row Y0, the line between them a\n// smooth step DELTA LEDs thick, rippled by cos(pi m x / 64), the wave that\n// meets both side walls square, for the chosen m, and fainter by m - 1\n// and m + 1 so the fingers come out unequal.\nfunction fresh(S) {\n  const { w, r, psi, u, v } = S, m0 = (S.layer = S.modes);\n  const waves = [[m0, A0 * (random() \u003c 0.5 ? -1 : 1)]];\n  for (const m of [m0 - 1, m0 + 1]) waves.push([m, A0 * 0.3 * (2 * random() - 1)]);\n  for (let x = 0; x \u003c W; x++) {\n    let yi = Y0;\n    for (const [m, a] of waves) yi += a * cos((PI * m * x) / 64);\n    for (let y = 0; y \u003c H; y++) r[y * W + x] = tanh((yi - y) / DELTA);\n  }\n  w.fill(0);\n  psi.fill(0);\n  u.fill(0);\n  v.fill(0);\n  S.total = r.reduce((a, b) => a + b, 0);\n  S.t = 0;\n}\n\n// Two fields sampled bilinearly at one point, both ways held inside the\n// panel, into PAIR.\nconst PAIR = new Float64Array(2);\nfunction pair(f, g, x, y) {\n  x = x \u003c 0 ? 0 : x > W - 1 ? W - 1 : x;\n  y = y \u003c 0 ? 0 : y > H - 1 ? H - 1 : y;\n  const xf = min(floor(x), W - 2), yf = min(floor(y), H - 2), fx = x - xf, fy = y - yf, o = yf * W + xf;\n  const w00 = (1 - fx) * (1 - fy), w10 = fx * (1 - fy), w01 = (1 - fx) * fy, w11 = fx * fy;\n  PAIR[0] = w00 * f[o] + w10 * f[o + 1] + w01 * f[o + W] + w11 * f[o + W + 1];\n  PAIR[1] = w00 * g[o] + w10 * g[o + 1] + w01 * g[o + W] + w11 * g[o + W + 1];\n}\n\n// MacCormack advection of vorticity and density: a semi-Lagrangian step\n// back along the flow (midpoint rule), one forward again to see what it\n// lost, half that put back, and the result held inside the four values\n// it came from.\nfunction advect(S, dt) {\n  const { w, r, u, v, wa, ra, wb, rb, DX, DY } = S, hd = 0.5 * dt;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      pair(u, v, x - hd * u[p], y - hd * v[p]);\n      const dx = cl(x - dt * PAIR[0], 0, W - 1), dy = cl(y - dt * PAIR[1], 0, H - 1);\n      (DX[p] = dx), (DY[p] = dy);\n      pair(w, r, dx, dy);\n      (wa[p] = PAIR[0]), (ra[p] = PAIR[1]);\n    }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      pair(u, v, x + hd * u[p], y + hd * v[p]);\n      pair(wa, ra, x + dt * PAIR[0], y + dt * PAIR[1]);\n      (wb[p] = PAIR[0]), (rb[p] = PAIR[1]);\n    }\n  for (let p = 0; p \u003c NP; p++) {\n    const o = min(floor(DY[p]), H - 2) * W + min(floor(DX[p]), W - 2);\n    let lo = min(w[o], w[o + 1], w[o + W], w[o + W + 1]), hi = max(w[o], w[o + 1], w[o + W], w[o + W + 1]);\n    wb[p] = cl(wa[p] + 0.5 * (w[p] - wb[p]), lo, hi);\n    lo = min(r[o], r[o + 1], r[o + W], r[o + W + 1]);\n    hi = max(r[o], r[o + 1], r[o + W], r[o + W + 1]);\n    rb[p] = cl(ra[p] + 0.5 * (r[p] - rb[p]), lo, hi);\n  }\n  w.set(wb);\n  r.set(rb);\n}\n\n// One step of the flow:\n//   w_t + u . grad w = A g d(rho)/dx + nu lap w,   lap psi = -w,\n//   rho_t + u . grad rho = kappa lap rho,\n// with y pointing down the panel, the way gravity pulls, u = d psi / dy\n// and v = -d psi / dx. Advection first, then the kick the moved density\n// gives the vorticity, which makes the step a symplectic Euler step of the\n// growing wave, then the density's diffusion, then viscosity and the\n// Poisson solve, both in the sine modes across the panel.\nfunction step(S, dt) {\n  const { w, r, psi, u, v, tmp, WR, PR } = S;\n  advect(S, dt);\n  // Buoyancy.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) w[p] += dt * G * 0.5 * (r[x \u003c W - 1 ? p + 1 : p] - r[x > 0 ? p - 1 : p + 1]);\n  // The density's diffusion, with no flux through the walls, in as many\n  // explicit steps as keep it stable.\n  const kd = S.kappa * dt, n = Math.ceil(kd / 0.2), kap = kd / n;\n  for (let i = 0; i \u003c n; i++) {\n    for (let y = 0, p = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++, p++) {\n        const sum = r[x > 0 ? p - 1 : p + 1] + r[x \u003c W - 1 ? p + 1 : p] + r[y > 0 ? p - W : p] + r[y \u003c H - 1 ? p + W : p];\n        tmp[p] = r[p] + kap * (sum - 4 * r[p]);\n      }\n    r.set(tmp);\n  }\n  // The MacCormack step does not keep the total of the density: over a\n  // cycle the heavy fluid would drift by 1 to 2%. What it gained or lost\n  // is handed back where the fluids meet, in proportion to 1 - rho^2, as\n  // Priestley's fixer does for semi-Lagrangian weather models.\n  let sum = 0, wt = 0;\n  for (let p = 0; p \u003c NP; p++) (sum += r[p]), (wt += 1 - r[p] * r[p]);\n  const fix = wt > 0 ? (S.total - sum) / wt : 0;\n  for (let p = 0; p \u003c NP; p++) r[p] += fix * (1 - r[p] * r[p]);\n  toModes(S, w, WR);\n  const nd = S.nu * dt;\n  for (let k = 1; k \u003c= K; k++) {\n    const k2 = 4 * sin((PI * k) / NF) ** 2, o = k * H;\n    // (1 - nu dt lap) w' = w, as (1 / (nu dt) + k2 - D2) w' = w / (nu dt).\n    tri(S, WR, o, k2 + 1 / nd, 1 / nd);\n    // -lap psi = w', as (k2 - D2) psi = w'.\n    for (let y = 0; y \u003c H; y++) PR[o + y] = WR[o + y];\n    tri(S, PR, o, k2, 1);\n  }\n  fromModes(S, WR, w);\n  fromModes(S, PR, psi);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const up = y > 0 ? psi[p - W] : 0, dn = y \u003c H - 1 ? psi[p + W] : 0;\n      const lf = x > 0 ? psi[p - 1] : -psi[p + 1], rt = x \u003c W - 1 ? psi[p + 1] : 0;\n      u[p] = 0.5 * (dn - up);\n      v[p] = -0.5 * (rt - lf);\n    }\n  S.t += dt;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.modes = cl(round(k[2]), 3, 9);\n  S.nu = NU0 * NUR ** cl(k[3], 0, 1);\n  S.kappa = 0.05 + S.nu / 4;\n  if (!S.started) {\n    fresh(S);\n    S.started = true;\n  }\n  const h = (d * S.speed) / 2;\n  if (S.t > CYCLE || S.modes !== S.layer || (input.btnPressed && input.btnPressed[0])) {\n    S.old.set(S.rgb);\n    S.fade = 1;\n    fresh(S);\n  }\n  S.fade = max(0, S.fade - h / FADE);\n  if (h > 0) step(S, h);\n}\n\n// Dim orange and yellow read brown and olive, so the light fluid's wheel\n// skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.col, h = S.hue, { r, w, rgb, old } = S, f = S.fade;\n  hsv(h + 0.8, 0.65, 0.82, c, 0); // heavy\n  hsv(wheel(h + 0.53), 0.8, 0.24, c, 3); // light\n  hsv(wheel(h + 0.66), 0.7, 0.5, c, 6); // half and half\n  hsv(h + 0.7, 0.12, 1, c, 9); // the sharp line between them\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      // The two fluids and their mixture on a ramp through a third hue,\n      // and where the density changes sharply, a pale line as a\n      // shadowgraph shows it; spinning fluid a little brighter.\n      const q = 0.5 * (1 + r[p]), a = q \u003c 0.5 ? 3 : 6, b = q \u003c 0.5 ? 6 : 0, t = q \u003c 0.5 ? 2 * q : 2 * q - 1;\n      const gx = r[x \u003c W - 1 ? p + 1 : p] - r[x > 0 ? p - 1 : p], gy = r[y \u003c H - 1 ? p + W : p] - r[y > 0 ? p - W : p];\n      const e = min(1, 0.6 * sqrt(gx * gx + gy * gy)), hl = e * e, vb = 1 + 0.03 * min(10, abs(w[p]));\n      for (let ch = 0; ch \u003c 3; ch++) {\n        const base = c[a + ch] + t * (c[b + ch] - c[a + ch]);\n        const val = min(1, (base * (1 - 0.6 * hl) + 0.75 * c[9 + ch] * hl) * vb) * 255;\n        rgb[p * 3 + ch] = f > 0 ? val * (1 - f) + old[p * 3 + ch] * f : val;\n      }\n      display.setPixel(x, y, round(rgb[p * 3]), round(rgb[p * 3 + 1]), round(rgb[p * 3 + 2]));\n    }\n}\n","tukey-depth":"// ===== Patternflow pattern =====\n// Title:   Tukey Depth\n// Family:  data\n// Idea:    Thirty drifting points colour every LED by its Tukey depth, the fewest of them in any closed half-plane holding it, so the cloud stands as nested convex polygons each one point deeper than the last, and every eight seconds two of the points fly 160 LEDs off the panel, pulling the outer polygons after them as wedges and the orange mean out of the core, while the white ring of the Tukey median, the centroid of the deepest polygon, barely moves.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: halfspace depth and the Tukey median (John W. Tukey, 1975), centerpoint theorem (Richard Rado, 1946), breakdown point of the Tukey median (David L. Donoho and Miriam Gasko, 1992), pattern round 58\n// Round:   58\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Points=30..90, Outliers=0..0.4\n//\n// Knob 1: Hue. Turns the regions' colours round the wheel together. At 0 they run from violet at the hull through blue to aqua at the deepest, and the mean is orange; at 0.25 from red through magenta and violet to a blue core, the mean green; at 0.5 from green through yellow and red to violet, the mean blue; at 0.75 from blue through teal and green to yellow, the mean pink. The points and the median's ring stay white.\n// Knob 2: Speed. At 2 each coordinate of a point is a sum of three sines with periods between 15 and 63 s, and an outing takes 8 s: the outliers fly out in 1.5 s, stay out 4.5 s while their group swings round the middle a quarter of a radian a second, and come back in 1.5 s; each new set leaves 137 degrees further round than the last. 0.2 is ten times slower, 3 one and a half times faster.\n// Knob 3: Points. 30 to 90 points. Each level is one point deeper, so the deepest region sits at depth 11 to 14 with 30 points, 25 to 28 with 60 and 38 to 42 with 90, never under the third of the points the centerpoint theorem promises (10, 20, 30), and the bands grow finer as the count rises.\n// Knob 4: Outliers. The share of the points that fly out each outing, rounded: 2 of 30 at the opening 0.06. They go 160 LEDs from the middle, well off the panel; with 2 of 30 the mean moves 11 LEDs on average and the median 2.6, and measured in the clean data the median keeps 89% of the deepest depth while the mean keeps 40%. At 0.2 (6 of 30) the mean moves 32 LEDs and the median 7. Past a third, the breakdown point, the median gives way too: at 0.34 (10 of 30) it moves 49 LEDs and at 0.4 it leaves the panel with the outliers. A mean dragged off the panel waits on its rim.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, round, ceil, PI } = Math;\nconst random = () => Math.random();\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst NMAX = 90;\n// One outing of the outliers, in T (seconds at Speed 2).\nconst OUT = 8;\n// How far out the outliers go: two and a half half-heights of the panel.\nconst FAR = 160;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const pts = [];\n  for (let i = 0; i \u003c NMAX; i++) {\n    // Each point's place in the cloud is three sines a coordinate at slow\n    // frequencies of its own, scaled to unit variance.\n    const f = [], ph = [];\n    for (let m = 0; m \u003c 6; m++) {\n      f.push(0.1 + 0.32 * random());\n      ph.push(2 * PI * random());\n    }\n    pts.push({ f, ph, w: 0, jx: 2 * PI * random(), jy: 2 * PI * random(), jf: 0.5 + 0.5 * random() });\n  }\n  params.s = {\n    hue: 0, speed: 2, n: 30, out: 0.06, T: 0, pts,\n    px: new Float64Array(NMAX), py: new Float64Array(NMAX),\n    depth: new Uint8Array(W * H), polys: [], kmax: 0,\n    mx: 32, my: 64, tx: 32, ty: 64, trail: new Float32Array(180).fill(-99), ti: 0, pal: new Float32Array(3 * 64), c: new Float32Array(3),\n  };\n}\n\n// Keep nx x + ny y \u003c= c of a convex polygon [x0, y0, x1, y1, ...].\nfunction clip(P, nx, ny, c) {\n  const out = [], m = P.length, eps = 1e-9 * (abs(nx) + abs(ny) + abs(c));\n  for (let i = 0; i \u003c m; i += 2) {\n    const j = (i + 2) % m, ax = P[i], ay = P[i + 1], bx = P[j], by = P[j + 1];\n    const da = nx * ax + ny * ay - c, db = nx * bx + ny * by - c;\n    if (da \u003c= eps) out.push(ax, ay);\n    if ((da \u003c -eps && db > eps) || (da > eps && db \u003c -eps)) {\n      const t = da / (da - db);\n      out.push(ax + t * (bx - ax), ay + t * (by - ay));\n    }\n  }\n  return out;\n}\n\n// A cheap hash of a point and an outing, 0..1, to choose who flies out.\nconst rank = (i, c) => {\n  const v = sin(i * 12.9898 + c * 78.233) * 43758.5453;\n  return v - floor(v);\n};\n\nfunction place(S) {\n  const { pts, px, py, n, T } = S;\n  // The cloud: an upright ellipse that sways a little.\n  const th = 0.3 * sin(0.13 * T), ct = cos(th), st = sin(th);\n  const cx = 32 + 2 * sin(0.21 * T + 1), cy = 64 + 4 * sin(0.17 * T);\n  // The outliers go out together every OUT seconds of T, a new set each\n  // time, FAR LEDs from the middle, well off the panel, drift round there\n  // and come back for the last quarter of the outing.\n  const c = floor(T / OUT), psi = 2.4 * c + 0.25 * (T - c * OUT);\n  const gx = 32 + FAR * cos(psi), gy = 64 + FAR * sin(psi);\n  const k = sqrt(2 / 3);\n  for (let i = 0; i \u003c n; i++) {\n    const p = pts[i];\n    let zx = 0, zy = 0;\n    for (let q = 0; q \u003c 3; q++) {\n      zx += sin(p.f[q] * T + p.ph[q]);\n      zy += sin(p.f[q + 3] * T + p.ph[q + 3]);\n    }\n    zx *= k * 10;\n    zy *= k * 19;\n    let x = cx + ct * zx - st * zy, y = cy + st * zx + ct * zy;\n    const w = p.w;\n    if (w > 0) {\n      const ox = gx + 4 * sin(p.jf * T + p.jx), oy = gy + 4 * sin(p.jf * T + p.jy);\n      const e = w * w * (3 - 2 * w);\n      x += e * (ox - x);\n      y += e * (oy - y);\n    }\n    px[i] = x;\n    py[i] = y;\n  }\n}\n\n// The regions {depth >= k}. A line through two data points with a points\n// strictly on one side and b on the other puts every LED strictly on the\n// a side at depth a or less, so {depth >= a + 1} lies in the closed other\n// side; {depth >= k} is exactly the intersection of all those half-planes,\n// one convex polygon for each k, each inside the one before.\nfunction regions(S) {\n  const { px, py, n } = S, half = n >> 1;\n  const lev = Array.from({ length: half + 2 }, () => []);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      const nx = py[i] - py[j], ny = px[j] - px[i], c0 = nx * px[i] + ny * py[i];\n      let a = 0, b = 0;\n      for (let k = 0; k \u003c n; k++) {\n        if (k === i || k === j) continue;\n        const s = nx * px[k] + ny * py[k] - c0;\n        if (s > 0) a++;\n        else if (s \u003c 0) b++;\n      }\n      if (a \u003c= b) lev[a + 1].push(nx, ny, c0);\n      if (b \u003c= a) lev[b + 1].push(-nx, -ny, -c0);\n    }\n  let P = [-500, -500, 600, -500, 600, 700, -500, 700];\n  const polys = [];\n  for (let k = 1; k \u003c= half + 1; k++) {\n    const L = lev[k];\n    for (let q = 0; q \u003c L.length && P.length; q += 3) P = clip(P, L[q], L[q + 1], L[q + 2]);\n    if (!P.length) break;\n    polys.push(P);\n  }\n  S.polys = polys;\n  S.kmax = polys.length;\n  // The Tukey median: the centroid of the deepest region.\n  const D = polys[polys.length - 1] || [32, 64];\n  let A = 0, gx = 0, gy = 0, vx = 0, vy = 0;\n  for (let i = 0; i \u003c D.length; i += 2) {\n    const j = (i + 2) % D.length, cr = D[i] * D[j + 1] - D[j] * D[i + 1];\n    A += cr;\n    gx += (D[i] + D[j]) * cr;\n    gy += (D[i + 1] + D[j + 1]) * cr;\n    vx += D[i];\n    vy += D[i + 1];\n  }\n  if (abs(A) > 1e-6) {\n    S.tx = gx / (3 * A);\n    S.ty = gy / (3 * A);\n  } else {\n    S.tx = vx / (D.length / 2);\n    S.ty = vy / (D.length / 2);\n  }\n  // Every LED's depth, row by row from the polygons.\n  const depth = S.depth;\n  depth.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5, row = y * W;\n    for (let k = 0; k \u003c polys.length; k++) {\n      const P = polys[k];\n      let lo = 1e9, hi = -1e9;\n      for (let i = 0; i \u003c P.length; i += 2) {\n        const j = (i + 2) % P.length, y1 = P[i + 1], y2 = P[j + 1];\n        if ((y1 \u003c= yc && yc \u003c y2) || (y2 \u003c= yc && yc \u003c y1)) {\n          const x = P[i] + ((yc - y1) * (P[j] - P[i])) / (y2 - y1);\n          if (x \u003c lo) lo = x;\n          if (x > hi) hi = x;\n        }\n      }\n      if (hi \u003c lo) break;\n      const x0 = max(0, ceil(lo - 0.5)), x1 = min(W - 1, floor(hi - 0.5));\n      for (let x = x0; x \u003c= x1; x++) depth[row + x] = k + 1;\n    }\n  }\n  let sx = 0, sy = 0;\n  for (let i = 0; i \u003c n; i++) {\n    sx += px[i];\n    sy += py[i];\n  }\n  S.mx = sx / n;\n  S.my = sy / n;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.n = round(cl(k[2], 30, 90));\n  S.out = cl(k[3], 0, 0.4);\n  S.T += d * S.speed * 0.5;\n  const m = round(S.out * S.n), c = floor(S.T / OUT), out = S.T / OUT - c \u003c 0.75;\n  // This outing's outliers: the m points of lowest rank.\n  const order = [];\n  for (let i = 0; i \u003c S.n; i++) order.push(i);\n  order.sort((a, b) => rank(a, c) - rank(b, c));\n  const want = new Uint8Array(NMAX);\n  if (out) for (let q = 0; q \u003c m; q++) want[order[q]] = 1;\n  // A point flies out or comes back over 1.5 s.\n  for (let i = 0; i \u003c NMAX; i++) {\n    const p = S.pts[i];\n    p.w = want[i] ? min(1, p.w + d * S.speed / 3) : max(0, p.w - d * S.speed / 3);\n  }\n  place(S);\n  regions(S);\n  S.ti = (S.ti + 1) % 90;\n  S.trail[2 * S.ti] = S.mx;\n  S.trail[2 * S.ti + 1] = S.my;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { depth, pal, n } = S, half = n / 2, h = S.hue;\n  // Level k: hue from violet at the hull to aqua at the deepest, brighter\n  // inwards. Each region's rim is at full, its fill at 59% on odd levels\n  // and 37% on even ones, so neighbouring levels always differ.\n  const K = S.kmax;\n  for (let k = 1; k \u003c= K; k++) {\n    const u = min(1, k / half);\n    hsv(wheel(0.95 + h - 0.5 * u), 0.85 - 0.35 * u, 0.5 + 0.5 * u, pal, 3 * k);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, k = depth[p];\n      if (!k) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      // An LED of {depth >= k} next to a shallower one is the polygon's rim.\n      const rim = (x > 0 && depth[p - 1] \u003c k) || (x \u003c W - 1 && depth[p + 1] \u003c k) || (y > 0 && depth[p - W] \u003c k) || (y \u003c H - 1 && depth[p + W] \u003c k);\n      const g = rim ? 255 : k & 1 ? 150 : 95;\n      display.setPixel(x, y, round(pal[3 * k] * g), round(pal[3 * k + 1] * g), round(pal[3 * k + 2] * g));\n    }\n  const c = S.c;\n  hsv(0.1 + h, 0.8, 1, c, 0);\n  const put = (x, y, r, g, b) => {\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, r, g, b);\n  };\n  // Where the mean has been over the last three seconds, fading.\n  const tr = S.trail, L = tr.length / 2;\n  for (let q = 0; q \u003c L; q++) {\n    const a = ((S.ti - q + L) % L) * 2, f = 1 - 0.75 * q / L;\n    if (tr[a] \u003c -50) continue;\n    put(floor(tr[a]), floor(tr[a + 1]), round(c[0] * 255 * f), round(c[1] * 255 * f), round(c[2] * 255 * f));\n  }\n  // The data: white dots.\n  for (let i = 0; i \u003c n; i++) put(floor(S.px[i]), floor(S.py[i]), 255, 255, 255);\n  // The mean: an orange plus with a black rim, held on the panel when the\n  // outliers drag it off.\n  const mx = cl(floor(S.mx), 2, W - 3), my = cl(floor(S.my), 2, H - 3);\n  for (const [dx, dy] of [[-3, 0], [3, 0], [0, -3], [0, 3], [-2, -1], [-2, 1], [2, -1], [2, 1], [-1, -2], [1, -2], [-1, 2], [1, 2], [-1, -1], [1, -1], [-1, 1], [1, 1]])\n    put(mx + dx, my + dy, 0, 0, 0);\n  for (const [dx, dy] of [[0, 0], [-1, 0], [1, 0], [0, -1], [0, 1], [-2, 0], [2, 0], [0, -2], [0, 2]])\n    put(mx + dx, my + dy, round(c[0] * 255), round(c[1] * 255), round(c[2] * 255));\n  // The Tukey median: a white ring with a black inside.\n  const tx = floor(S.tx), ty = floor(S.ty);\n  for (let dy = -3; dy \u003c= 3; dy++)\n    for (let dx = -3; dx \u003c= 3; dx++) {\n      const r = sqrt(dx * dx + dy * dy);\n      if (r > 1.9 && r \u003c 3.1) put(tx + dx, ty + dy, 255, 255, 255);\n      else if (r \u003c= 1.9) put(tx + dx, ty + dy, 0, 0, 0);\n    }\n}\n","bicycle-tracks":"// ===== Patternflow pattern =====\n// Title:   Bicycle Tracks\n// Family:  line\n// Idea:    A front point weaves up the tall panel with a rear point a fixed wheelbase behind it that always rolls straight at it, so the rear track cuts inside every turn of the front track, and a comb of segments from the rear track forward to the front one, each one wheelbase long and tangent to the rear track, fills the lunes between them and shows which way the bicycle went; every 34 seconds or so the rider rides two laps of a circle, the rear spirals onto the smaller circle the bicycle's monodromy holds, and it leaves straight up along a tractrix.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the tractrix (Claude Perrault's question, 1670; Christiaan Huygens, 1692) as the track of a bicycle's rear wheel, the tangent rule of \"Which Way Did the Bicycle Go?\" (Joseph Konhauser, Dan Velleman and Stan Wagon, 1996), and bicycle monodromy as a Möbius map (Robert Foote, 1998; Mark Levi and Serge Tabachnikov, 2009), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wheelbase=16..24, Bar=50..70\n//\n// Knob 1: Hue. Turns both tracks round the wheel together. At 0 the front track is rose and the rear track cyan, with each tangent segment fading from cyan at its rear end to rose at its front end; at 0.25 the front is green and the rear blue, at 0.5 azure and magenta, at 0.75 violet and green. The wheel skips orange and yellow, which read brown and olive on the dim segments.\n// Knob 2: Speed. The front point rides 13 LEDs a second times the knob: 26 at 2, where a weave of 37 to 50 rows passes in 2.2 to 3.7 seconds; 2.6 at 0.2 and 39 at 3. After 560 LEDs of weaving, 21.5 seconds at 2, the rider straightens up near one side and rides its loop, 10 to 15 seconds at 2.\n// Knob 3: Wheelbase. The fixed distance L between the two points, 16 to 24 LEDs, and the length of every tangent segment. The loop's radius is 1.3 L + 1 up to 28: at 16 the front circles on 21.8 and the rear settles on 14.8, at 24 the front on 28 and the rear on 14.4. A lune is widest where the bar is held, at L tan(bar / 2): 7.5 LEDs at 16 and 11.2 at 24, with the bar at 50 degrees.\n// Knob 4: Bar. The angle from the frame the rider holds the bar at through each turn, 50 to 70 degrees. While it is held the front runs on a circle of radius L / sin(bar) and the rear inside it on L / tan(bar), 1.31 L and 0.84 L at 50 degrees, 1.06 L and 0.36 L at 70. A weave (two turns) takes 45 rows at 50 degrees and 23 at 70, with L at 16 (medians over 400 seconds). The rear never rolls slower than cos 70 = 0.34 of the front's speed, so it never stops or backs up.\n\n// The bicycle: F is the front point, R the rear, L = |F - R|. The rear\n// wheel cannot slide sideways, so R always moves along the frame, towards F,\n// at the speed of F's motion along the frame:\n//   dR/ds = ((F - R) . T) (F - R) / L^2,\n// with T the front's unit velocity and s its arc. That keeps |F - R| = L\n// (the derivative of |D|^2 is 2 (D . T)(1 - |D|^2 / L^2)), so the segment\n// from R to F is the tangent to the rear track and meets the front track\n// exactly L ahead. Perrault asked in 1670 what curve a watch traces when\n// its chain is pulled along a straight line; that curve, the tractrix, is\n// this rear track when the front rides a straight line, and Huygens named it\n// in 1692. Konhauser, Velleman and Wagon turned the tangent rule round: of\n// two tracks, the one whose forward tangents always meet the other at the\n// same distance is the rear one, so the tracks say which way the bicycle\n// went. When the front rides a closed loop, where the rear ends up after a\n// lap is a Möbius map of where it started (Foote, 1998). For a circle of\n// radius r > L it has two fixed points; riding forward one attracts, the\n// rear circling on radius sqrt(r^2 - L^2) with the frame tangent to it, and\n// the rear comes in by a factor exp(-2 pi sqrt(r^2 - L^2) / L) each lap.\n// Levi and Tabachnikov (2009) proved Menzin's conjecture of 1906, that the\n// same happens on any convex loop holding more area than pi L^2.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan, atan2, ceil, hypot, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst wrap = (a) => a - TAU * round(a / TAU);\n// Integration step and record spacing, in LEDs of the front's arc, and a\n// tangent segment every COMB records.\nconst STEP = 0.2, SPACE = 0.5, COMB = 8, RING = 3000;\n// While riding the rear sits L + TOP rows from the top, so the front is\n// never above row TOP.\nconst TOP = 8;\n// Arc before the opening, before the first loop, and between loops.\nconst PRE = 320, FIRST = 330, RIDE = 560;\n// Loops: two laps and a bit of a circle of radius 1.3 L + 1, at least\n// L + 4 and at most RMAX, kept MARGIN inside the panel's sides.\nconst LAPS = 2, RMAX = 28, MARGIN = 3;\n// The rider weaves along a guide line that wanders across the panel, 140\n// rows a wave and 15 LEDs either side: the bar is held at the knob's angle\n// to one side until the frame has swung SWING radians past the line to the\n// guide, then thrown to the other side over RELAX LEDs. SWING itself\n// swells and fades by 35% once every 390 LEDs.\nconst G_AMP = 15, G_K = TAU / 140, SWING = 0.72, MOD_K = TAU / 390, RELAX = 3;\n// Hues at knob 0 before the wheel below bends them: rose and cyan.\nconst HUE_F = 0.865, HUE_R = 0.297, GLOW = 1;\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const R = Math.random;\n  params.s = {\n    ready: false, hue: 0, v: 26, L: 16, Lk: 16, bar: 0.87, side: 1, run: 0,\n    // Guide phases, and the phase of the swing's swell.\n    g0: R() * TAU, g1: R() * TAU, mph: R() * TAU,\n    // y: front x, front Y (up), the bar's angle from the frame, rear x, rear Y.\n    y: new Float64Array(5), t: new Float64Array(5), k: [0, 1, 2, 3].map(() => new Float64Array(5)),\n    arc: 0, next: 0, sig: 0,\n    mode: 0, turn: 1, r: 0, cx: 0, cy: 0, b0: 0, len: 0, due: 1e9, wait: 0, fade: 0, edge: 32, blend: 0,\n    hx: new Float64Array(RING), hy: new Float64Array(RING), gx: new Float64Array(RING), gy: new Float64Array(RING), n: 0,\n    buf: new Float32Array(W * H * 3), glow: new Float32Array(W * H * 3), tmp2: new Float32Array(W * H * 3),\n    cf: new Float32Array(3), cr: new Float32Array(3),\n  };\n}\n\nconst guide = (s, Y) => 32 + G_AMP * (0.7 * sin(G_K * Y + s.g0) + 0.3 * sin(1.73 * G_K * Y + s.g1));\n\n// Derivatives along the front's arc. On a loop the front is a given circle\n// and only the rear moves by the equation; riding, the front goes where the\n// bar points, the bar follows the rider, and the rear by the same equation.\nfunction deriv(s, y, ds, out) {\n  const L = s.L;\n  let tx, ty;\n  if (s.mode === 1) {\n    const b = s.b0 - (s.turn * (s.sig + ds)) / s.r;\n    y[0] = s.cx + s.r * cos(b);\n    y[1] = s.cy + s.r * sin(b);\n    tx = s.turn * sin(b);\n    ty = -s.turn * cos(b);\n    out[0] = out[1] = out[2] = 0;\n  } else if (s.mode === 2) {\n    // Off a loop the front rides straight up while the rear swings in\n    // behind it on a tractrix.\n    tx = out[2] = out[0] = 0;\n    ty = out[1] = 1;\n  } else {\n    const phi = atan2(y[0] - y[3], y[1] - y[4]), th = phi + y[2];\n    tx = sin(th);\n    ty = cos(th);\n    // While a loop is due the rider stops weaving and steers by pure\n    // pursuit for a line near the panel's edge, where the loop starts.\n    const f = s.fade, ay = y[4] + 1.5 * L + 10, ax = (1 - f) * guide(s, ay) + f * s.edge;\n    const a = wrap(atan2(ax - y[3], ay - y[4]) - phi);\n    const nav = cl(atan((2 * L * sin(a)) / hypot(ax - y[3], ay - y[4])), -0.6, 0.6);\n    const want = (1 - f) * s.side * s.bar + f * nav;\n    out[0] = tx;\n    out[1] = ty;\n    out[2] = (want - y[2]) / RELAX;\n  }\n  const dx = y[0] - y[3], dy = y[1] - y[4], p = (dx * tx + dy * ty) / (L * L);\n  out[3] = p * dx;\n  out[4] = p * dy;\n}\n\n// One classical Runge-Kutta step of length h along the front's arc.\nfunction rk4(s, h) {\n  const y = s.y, t = s.t, [a, b, c, d] = s.k;\n  deriv(s, y, 0, a);\n  for (let i = 0; i \u003c 5; i++) t[i] = y[i] + 0.5 * h * a[i];\n  deriv(s, t, h / 2, b);\n  for (let i = 0; i \u003c 5; i++) t[i] = y[i] + 0.5 * h * b[i];\n  deriv(s, t, h / 2, c);\n  for (let i = 0; i \u003c 5; i++) t[i] = y[i] + h * c[i];\n  deriv(s, t, h, d);\n  for (let i = 0; i \u003c 5; i++) y[i] += (h / 6) * (a[i] + 2 * b[i] + 2 * c[i] + d[i]);\n  // On a loop the front is placed on its circle exactly.\n  if (s.mode === 1) (s.sig += h), deriv(s, y, 0, a);\n  s.mph = wrap(s.mph + MOD_K * h);\n  s.arc += h;\n}\n\nconst loopR = (L) => min(RMAX, max(L + 4, 1.3 * L + 1));\n\n// A loop starts on a circle through the front, tangent to it, that fits\n// across the panel; it waits for one of radius loopR, easing by a LED for\n// every 40 it waits, but never under L + 3.\nfunction tryLoop(s) {\n  const y = s.y, th = atan2(y[0] - y[3], y[1] - y[4]) + y[2], c = cos(th), x = y[0], lo = MARGIN, hi = W - MARGIN;\n  // Turning right the centre is r to the right of the heading, at x + r c.\n  const right = min((x - lo) / (1 - c + 1e-9), 1 + c > 1e-9 ? (hi - x) / (1 + c) : 1e9);\n  const left = min(1 + c > 1e-9 ? (x - lo) / (1 + c) : 1e9, (hi - x) / (1 - c + 1e-9));\n  const want = loopR(s.L), turn = right >= left ? 1 : -1, r = min(want, max(right, left));\n  if (r \u003c max(s.L + 3, want - s.wait / 40)) return;\n  s.cx = x + turn * r * c;\n  s.cy = y[1] - turn * r * sin(th);\n  s.b0 = atan2(y[1] - s.cy, x - s.cx);\n  s.turn = turn;\n  s.r = r;\n  s.sig = 0;\n  // Whole laps and then on to where the front heads straight up, at the\n  // circle's side.\n  const extra = turn > 0 ? -th : th;\n  s.len = r * (LAPS * TAU + extra - TAU * floor(extra / TAU));\n  s.mode = 1;\n}\n\n// Ride arc more LEDs of the front's track, recording both points every\n// SPACE LEDs.\nfunction advance(s, arc) {\n  const end = s.arc + arc, y = s.y;\n  while (s.arc \u003c end - 1e-9) {\n    let h = min(STEP, end - s.arc, s.next - s.arc);\n    if (s.mode === 1) h = min(h, s.len - s.sig);\n    if (h > 1e-12) rk4(s, h);\n    if (s.mode === 1) {\n      if (s.sig >= s.len - 1e-9) (s.mode = 2), (s.run = 0);\n    } else if (s.mode === 2) {\n      // Straight on until the frame points within 0.2 radians of up; then\n      // the bar takes over from there, so the track has no corner.\n      const phi = atan2(y[0] - y[3], y[1] - y[4]);\n      s.run += h;\n      if (abs(phi) \u003c 0.2 || s.run > 4 * s.L) (y[2] = -phi), (s.mode = 0), (s.due = RIDE), (s.wait = 0), (s.side = phi \u003c 0 ? 1 : -1);\n    } else {\n      // The weave: throw the bar over once the frame has swung far enough\n      // past the line to the guide, or the front comes within 6 LEDs of a\n      // side of the panel.\n      const phi = atan2(y[0] - y[3], y[1] - y[4]), ay = y[4] + 1.5 * s.L + 10;\n      const a = wrap(atan2(guide(s, ay) - y[3], ay - y[4]) - phi), sw = SWING * (1 + 0.35 * sin(s.mph));\n      if (s.side > 0 && (a \u003c -sw || y[0] > W - 6)) s.side = -1;\n      else if (s.side \u003c 0 && (a > sw || y[0] \u003c 6)) s.side = 1;\n      if (s.due \u003c= 0) {\n        if (s.wait === 0) s.edge = y[0] \u003c 32 ? 32 - loopR(s.L) + 1 : 32 + loopR(s.L) - 1;\n        s.wait += h;\n        s.fade = min(1, s.fade + h / 40);\n        tryLoop(s);\n      } else (s.due -= h), (s.fade = max(0, s.fade - h / 40));\n    }\n    if (s.arc >= s.next - 1e-9) {\n      const i = s.n % RING;\n      s.hx[i] = y[0];\n      s.hy[i] = y[1];\n      s.gx[i] = y[3];\n      s.gy[i] = y[4];\n      s.n++;\n      s.next += SPACE;\n    }\n  }\n}\n\nfunction start(s) {\n  const y = s.y;\n  y[0] = y[3] = guide(s, 0);\n  y[1] = s.L;\n  y[2] = 0;\n  y[4] = 0;\n  s.arc = s.next = 0;\n  s.due = 1e9;\n  advance(s, PRE);\n  s.due = FIRST;\n  s.ready = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 16, 50], d = cl(dt || 0, 0, 0.1), y = s.y;\n  s.hue = cl(kv[0], 0, 1);\n  s.v = 13 * cl(kv[1], 0.2, 3);\n  s.bar = (cl(kv[3], 50, 70) * PI) / 180;\n  // On a loop the wheelbase stays under the loop's radius until it ends.\n  s.Lk = cl(kv[2], 16, 24);\n  const L = s.mode === 1 ? min(s.Lk, s.r - 1) : s.Lk;\n  if (L !== s.L) {\n    // A new wheelbase: the rear slides along the frame to the new distance.\n    const dx = y[3] - y[0], dy = y[4] - y[1], m = hypot(dx, dy) || 1;\n    y[3] = y[0] + (dx * L) / m;\n    y[4] = y[1] + (dy * L) / m;\n    s.L = L;\n  }\n  if (!s.ready) start(s);\n  advance(s, s.v * d);\n  // The view eases onto a loop and back off it over 0.8 seconds.\n  s.blend = cl(s.blend + (s.mode === 1 ? d : -d) / 0.8, 0, 1);\n  // Keep the numbers small on a long run.\n  if (y[4] > 1e5) {\n    const k = 1e5, m = min(s.n, RING);\n    y[1] -= k;\n    y[4] -= k;\n    s.cy -= k;\n    s.g0 = wrap(s.g0 + G_K * k);\n    s.g1 = wrap(s.g1 + 1.73 * G_K * k);\n    for (let i = 0; i \u003c m; i++) (s.hy[i] -= k), (s.gy[i] -= k);\n  }\n}\n\n// A box blur of radius 2 along rows (step 1, n of them, len long, stride\n// W) or columns (step W, n = W, len = H, stride 1), three channels.\nfunction box(src, dst, step, len, n, stride) {\n  for (let r = 0; r \u003c n; r++)\n    for (let e = 0; e \u003c 3; e++) {\n      const base = r * stride * 3 + e, st = step * 3;\n      let acc = 0;\n      for (let j = 0; j \u003c 2 && j \u003c len; j++) acc += src[base + j * st];\n      for (let j = 0; j \u003c len; j++) {\n        if (j + 2 \u003c len) acc += src[base + (j + 2) * st];\n        if (j - 3 >= 0) acc -= src[base + (j - 3) * st];\n        dst[base + j * st] = acc / 5;\n      }\n    }\n}\n\n// A round dot 2.8 LEDs across with a soft edge, kept by the brighter of\n// what is there and what lands.\nfunction dot(B, x, y, c, k) {\n  const x0 = floor(x - 1.4), y0 = floor(y - 1.4);\n  for (let yy = y0; yy \u003c= y0 + 3; yy++) {\n    if (yy \u003c 0 || yy >= H) continue;\n    for (let xx = x0; xx \u003c= x0 + 3; xx++) {\n      if (xx \u003c 0 || xx >= W) continue;\n      const u = xx + 0.5 - x, v = yy + 0.5 - y, w = k * cl(1.4 - sqrt(u * u + v * v), 0, 1);\n      if (w \u003c= 0) continue;\n      const o = (yy * W + xx) * 3;\n      for (let e = 0; e \u003c 3; e++) if (c[e] * w > B[o + e]) B[o + e] = c[e] * w;\n    }\n  }\n}\n\n// A thin line from a to b, its colour fading from ca to cb, each sample\n// laid over its four nearest LEDs.\nfunction line(B, ax, ay, bx, by, ca, cb, k) {\n  const m = ceil(hypot(bx - ax, by - ay) * 2) || 1;\n  for (let j = 0; j \u003c= m; j++) {\n    const u = j / m, x = ax + (bx - ax) * u - 0.5, y = ay + (by - ay) * u - 0.5;\n    const ix = floor(x), iy = floor(y), tx = x - ix, ty = y - iy;\n    for (let dy = 0; dy \u003c 2; dy++) {\n      const yy = iy + dy;\n      if (yy \u003c 0 || yy >= H) continue;\n      const wy = dy ? ty : 1 - ty;\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const xx = ix + dx;\n        if (xx \u003c 0 || xx >= W) continue;\n        const w = min(1, (dx ? tx : 1 - tx) * wy * 2.6) * k, o = (yy * W + xx) * 3;\n        for (let e = 0; e \u003c 3; e++) {\n          const v = (ca[e] + (cb[e] - ca[e]) * u) * w;\n          if (v > B[o + e]) B[o + e] = v;\n        }\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.ready) return;\n  const B = s.buf, G = s.glow, T = s.tmp2, cf = s.cf, cr = s.cr, y = s.y;\n  B.fill(0);\n  hsv(wheel(HUE_F + s.hue), 0.9, 1, cf, 0);\n  hsv(wheel(HUE_R + s.hue), 0.94, 1, cr, 0);\n  const e = s.blend * s.blend * (3 - 2 * s.blend);\n  const cam = (1 - e) * (y[4] + s.L + TOP) + e * (s.cy + s.r + 6);\n  const m = min(s.n, RING), first = s.n - m;\n  // The two tracks, then a glow round them: the tracks blurred by two\n  // passes of a 5-LED box each way and added at GLOW.\n  for (let j = first; j \u003c s.n; j++) {\n    const i = j % RING, rb = cam - s.gy[i], rf = cam - s.hy[i];\n    if (rb > -3 && rb \u003c H + 3) dot(B, s.gx[i], rb, cr, 1);\n    if (rf > -3 && rf \u003c H + 3) dot(B, s.hx[i], rf, cf, 1);\n  }\n  box(B, T, 1, W, H, W);\n  box(T, G, 1, W, H, W);\n  box(G, T, W, H, W, 1);\n  box(T, G, W, H, W, 1);\n  for (let o = 0; o \u003c W * H * 3; o++) B[o] += GLOW * G[o];\n  // The comb over it: the frame every 4 LEDs of the ride, from the rear\n  // point to the front point, one wheelbase long and tangent to the rear\n  // track, fading from 0.7 near the top to 0.45 at the bottom.\n  for (let j = first; j \u003c s.n; j++) {\n    if (j % COMB) continue;\n    const i = j % RING, ra = cam - s.gy[i], fa = cam - s.hy[i];\n    if ((ra \u003c -2 && fa \u003c -2) || (ra > H + 2 && fa > H + 2)) continue;\n    line(B, s.gx[i], ra, s.hx[i], fa, cr, cf, 0.7 - 0.25 * cl((ra + fa) / (2 * H), 0, 1));\n  }\n  // On a loop, a dotted ring where the rear settles.\n  if (e > 0.01 && s.r > s.L) {\n    const rho = sqrt(s.r * s.r - s.L * s.L), n = floor((TAU * rho) / 3), wh = [0.8, 0.8, 0.85];\n    for (let j = 0; j \u003c n; j++) {\n      const a = (j / n) * TAU;\n      dot(B, s.cx + rho * cos(a), cam - (s.cy + rho * sin(a)), wh, 0.3 * e);\n    }\n  }\n  // The frame now, white-cored, and the two points.\n  const wf = [cf[0] * 0.5 + 0.5, cf[1] * 0.5 + 0.5, cf[2] * 0.5 + 0.5], wr = [cr[0] * 0.5 + 0.5, cr[1] * 0.5 + 0.5, cr[2] * 0.5 + 0.5];\n  line(B, y[3], cam - y[4], y[0], cam - y[1], wr, wf, 0.9);\n  dot(B, y[3], cam - y[4], wr, 1.2);\n  dot(B, y[0], cam - y[1], wf, 1.2);\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, (B[o] * 255) | 0), min(255, (B[o + 1] * 255) | 0), min(255, (B[o + 2] * 255) | 0));\n}\n","galperin-billiard":"// ===== Patternflow pattern =====\n// Title:   Galperin Billiard\n// Family:  physics\n// Idea:    A heavy block slides down a rail onto a light one above a wall at the bottom, and every collision, block on block or light block on wall, lights one dot of a tally that groups itself in tens, hundreds and thousands, so with masses 100, 10,000 or 1,000,000 times apart it reads 31, 314 or 3141; above it the two velocities, scaled by the square roots of the masses, are a point on the energy circle that zigzags from the circle's left end to its right, one chord per collision, sweeping the disc until it lands in the wedge of angle arctan(sqrt(m/M)) where no collision is left.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Gregory Galperin, Playing pool with π (2003), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Digits=1..3, Warp=0..8\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the heavy block is violet and the light one cyan, the swept disc runs violet through blue to green from left to right, and the tally is cyan, its thousands at k = 3 cyan, violet, green and rose; at 0.5 the heavy block is green, the light one pink and the disc runs green through rose to violet. The wheel skips orange to lime, and the unswept disc stays slate blue.\n// Knob 2: Speed. 2 is real time away from the burst, the heavy block coming down at 60 rows a second; 0.2 is ten times slower and 3 half as fast again. At 2, with Warp at its opening 0.06, the blocks meet 1.4 to 1.7 seconds into a run, the heavy block is off the top about 4 seconds in, and the tally holds 1.8 seconds before the next run.\n// Knob 3: Digits. k from 1 to 3: M = 100^k m, so 100, 10,000 or 1,000,000 times the light block, and the collisions number 31, 314 and 3141, the count of steps of theta = arctan(sqrt(m/M)), 5.71, 0.573 or 0.0573 degrees, that fit below pi (equal blocks, k = 0, would give 3). The heavy block is 4 + 6k rows tall. The tally's dots are 4, 1 and 1 LEDs wide at a pitch of 5, 2 and 1. At k = 3 the middle 90% of the collisions fall within 3.4 ms and the closest two are 0.27 microseconds apart.\n// Knob 4: Warp. Seconds of slow motion added to the burst at Speed 2, from 0 to 8, shared evenly so each collision gets Warp / n of them: at the opening 0.06 the burst runs at nearly real time and the middle 90% of k = 3's collisions pass within two frames; at 8 they come 393 a second, and k = 1's 31 come four a second.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, exp, atan, atan2, cos, sin, round, PI, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The rail: the wall's top edge is row 125's top; z counts rows up from it.\n// The light block starts Z1 rows up: at 16 the last collision of k = 2,\n// the latest of the four, still happens on the panel, the heavy block 98\n// rows up.\nconst FLOOR = 125, V0 = 60, HL = 4, Z1 = 16;\nconst HOLD = 1.8, FADE = 0.6;\n// The energy circle and the tally beside the rail.\nconst CX = 37.5, CY = 25.5, R = 24, TX = 13, TB = 124;\n// The tally's thousands at k = 3, as hues at knob 0 (they go through the\n// wheel below): cyan, violet, green, rose.\nconst BAND = [0.5, 0.75, 0.36, 0.92];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The knob turns hues on a wheel that skips orange through yellow to lime,\n// which read brown and olive when dim. Hues here are given as they look at\n// knob 0, from 0.28 round to 1.02.\nconst tone = (h, k) => 0.28 + 0.74 * (((h - 0.28) / 0.74 + k) % 1);\n\n// The collisions, event by event and in closed form: the blocks move at\n// constant speed between events, so each next event time is a gap divided\n// by a closing speed. Velocities are positive up, away from the wall. The\n// light block (mass m) sits at z1, HL rows tall; the heavy one (mass M =\n// 100^k m) has its lower face at z2. Block on block, momentum and energy\n// give v' = ((m - M) v + 2 M V) / (m + M) and V' = ((M - m) V + 2 m v) /\n// (m + M), here with r = m / M; at the wall v' = -v. It stops when the\n// light block moves up no faster than the heavy one: 0 \u003c= v \u003c= V.\nfunction collide(k, hh) {\n  const r = 1 / 100 ** k;\n  let v = 0, V = -V0, z1 = Z1, z2 = FLOOR - hh, t = 0;\n  const T = [0], A = [z1], B = [z2], VL = [v], VH = [V], kind = [0];\n  for (let guard = 0; guard \u003c 400000; guard++) {\n    const tb = V \u003c v ? max(0, z2 - z1 - HL) / (v - V) : Infinity;\n    const tw = v \u003c 0 ? max(0, z1) / -v : Infinity;\n    if (tb === Infinity && tw === Infinity) break;\n    if (tb \u003c= tw) {\n      t += tb;\n      z1 += v * tb;\n      z2 = z1 + HL;\n      const nv = ((r - 1) * v + 2 * V) / (1 + r), nV = ((1 - r) * V + 2 * r * v) / (1 + r);\n      v = nv;\n      V = nV;\n      kind.push(1);\n    } else {\n      t += tw;\n      z1 = 0;\n      z2 += V * tw;\n      v = -v;\n      kind.push(2);\n    }\n    T.push(t), A.push(z1), B.push(z2), VL.push(v), VH.push(V);\n  }\n  return { T, A, B, VL, VH, kind, n: T.length - 1, r };\n}\n\n// The slow motion. Display time s = tau + b N(tau), where N climbs by one\n// across each collision, linearly between the midpoints of the gaps around\n// it, and b = Warp / n. Far from the burst s runs with tau; inside it each\n// collision gets b seconds however close the next one is. Both directions\n// are exact on the piecewise linear knots.\nfunction warp(E, b) {\n  const T = E.T, n = E.n, m = new Float64Array(n + 1), sk = new Float64Array(n + 1);\n  m[0] = T[1] - (T[2] - T[1]) / 2;\n  for (let j = 1; j \u003c n; j++) m[j] = (T[j] + T[j + 1]) / 2;\n  m[n] = T[n] + (T[n] - T[n - 1]) / 2;\n  for (let j = 0; j \u003c= n; j++) sk[j] = m[j] + b * j;\n  E.m = m;\n  E.sk = sk;\n  E.b = b;\n}\nfunction tauOf(E, s) {\n  const { m, sk, n } = E;\n  if (s \u003c= sk[0]) return s;\n  if (s >= sk[n]) return s - E.b * n;\n  let lo = 0, hi = n;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (sk[mid] \u003c= s) lo = mid;\n    else hi = mid;\n  }\n  const span = sk[lo + 1] - sk[lo];\n  return span > 0 ? m[lo] + ((s - sk[lo]) * (m[lo + 1] - m[lo])) / span : m[lo];\n}\nfunction sOf(E, tau) {\n  const { m, n } = E;\n  if (tau \u003c= m[0]) return tau;\n  if (tau >= m[n]) return tau + E.b * n;\n  let lo = 0, hi = n;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (m[mid] \u003c= tau) lo = mid;\n    else hi = mid;\n  }\n  const span = m[lo + 1] - m[lo];\n  return tau + E.b * (lo + (span > 0 ? (tau - m[lo]) / span : 0));\n}\n// Collisions done by time tau.\nfunction doneBy(E, tau) {\n  let lo = 0, hi = E.n + 1;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (E.T[mid] \u003c= tau) lo = mid;\n    else hi = mid;\n  }\n  return lo;\n}\n\n// Where collision i's dot sits in the tally: hundreds are squares of ten\n// rows of ten, filled from the bottom; squares run five to a row at pitch 1\n// and two at pitch 2 (k = 0 and 1 never fill one), and at pitch 1 each two\n// rows of squares, a thousand, stand apart from the next by a row.\nfunction tallyAt(k, i) {\n  const p = [16, 5, 2, 1][k], side = 10 * p + (p > 1 ? p : 0), per = max(1, floor((W - TX + (p > 1 ? p : 0)) / side));\n  const q = floor(i / 100), rr = i % 100, sr = floor(q / per), sc = q % per;\n  const x = TX + sc * side + (rr % 10) * p;\n  const y = TB - sr * 10 * p - (p === 1 ? floor(sr / 2) : sr * p) - floor(rr / 10) * p;\n  return [x, y, p > 1 ? p - 1 : 1];\n}\n\nexport function setup(params) {\n  params.s = { k: -1, warpS: -1, s: 0, phase: 0, pt: 0, hue: 0, rgb: new Float32Array(W * H * 3), E: null, c: [0, 0, 0], c2: [0, 0, 0] };\n}\n\n// The run ends once the heavy block is off the top and the last collision\n// half a second gone.\nconst endOf = (E) => max(sOf(E, E.T[E.n] + (H + 4 - E.B[E.n]) / max(1, E.VH[E.n])), E.sAt[E.n] + 0.5);\n\nfunction start(S, k, wsec) {\n  S.k = k;\n  S.hh = HL + 6 * k;\n  S.E = collide(k, S.hh);\n  S.warpS = wsec;\n  warp(S.E, wsec / S.E.n);\n  const E = S.E;\n  // Points on the energy circle: (sqrt(M) V, sqrt(m) v) / (sqrt(M) V0).\n  const q = sqrt(E.r);\n  E.px = E.VH.map((V) => V / V0);\n  E.py = E.VL.map((v) => (q * v) / V0);\n  E.theta = atan(q);\n  E.sAt = E.T.map((t) => sOf(E, t));\n  E.sEnd = endOf(E);\n  S.s = 0;\n  S.phase = 0;\n  S.pt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), k = round(cl(kv[2], 1, 3)), wsec = cl(kv[3], 0, 8);\n  if (k !== S.k) start(S, k, wsec);\n  else if (abs(wsec - S.warpS) > 1e-3) {\n    // A new warp keeps the moment on screen where it is.\n    const E = S.E, tau = tauOf(E, S.s);\n    S.warpS = wsec;\n    warp(E, wsec / E.n);\n    E.sAt = E.T.map((t) => sOf(E, t));\n    E.sEnd = endOf(E);\n    S.s = sOf(E, tau);\n  }\n  const g = (d * speed) / 2;\n  if (S.phase === 0) {\n    S.s += g;\n    if (S.s >= S.E.sEnd + HOLD) (S.phase = 1), (S.pt = 0);\n  } else {\n    S.pt += g;\n    if (S.pt >= FADE) start(S, k, wsec);\n  }\n}\n\n// A point laid over its four nearest LEDs by how close it falls.\nfunction splat(rgb, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = (dx ? tx : 1 - tx) * wy * a, o = (yy * W + xx) * 3;\n      rgb[o] = max(rgb[o], c[0] * w);\n      rgb[o + 1] = max(rgb[o + 1], c[1] * w);\n      rgb[o + 2] = max(rgb[o + 2], c[2] * w);\n    }\n  }\n}\nfunction line(rgb, x0, y0, x1, y1, c, a) {\n  const len = hypot(x1 - x0, y1 - y0), m = max(1, ceil(len * 2));\n  for (let e = 0; e \u003c= m; e++) splat(rgb, x0 + ((x1 - x0) * e) / m, y0 + ((y1 - y0) * e) / m, c, a * 1.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.E) return;\n  const E = S.E, rgb = S.rgb, th = E.theta, hue = S.hue, c = S.c, c2 = S.c2;\n  const s = min(S.s, E.sEnd + HOLD), tau = tauOf(E, s), done = doneBy(E, tau);\n  const fade = S.phase === 1 ? 1 - S.pt / FADE : min(1, s / 0.3);\n  rgb.fill(0);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += col[0] * a;\n    rgb[o + 1] += col[1] * a;\n    rgb[o + 2] += col[2] * a;\n  };\n  const since = (j) => s - E.sAt[j];\n\n  // The energy circle. Inside it, the part the chords have swept: the\n  // polygon of every point so far, which is the disc on the start's side\n  // of the latest chord, less the thin caps outside each chord joining two\n  // points on the same side.\n  const cx = E.px, cy = E.py, T2 = floor(done / 2), B2 = ceil(done / 2);\n  const ti = 2 * T2, bi = done > 0 ? 2 * B2 - 1 : 0;\n  const ex = cx[bi] - cx[ti], ey = cy[bi] - cy[ti];\n  const ref = ex * (cy[0] - cy[ti]) - ey * (cx[0] - cx[ti]);\n  const cth = cos(th);\n  // The unswept disc and the rim stay slate blue whatever the hue: dim\n  // and turned to red they read brown.\n  const disc = [0.45, 0.6, 1];\n  const swept = c2;\n  for (let y = floor(CY - R - 1); y \u003c= ceil(CY + R + 1); y++)\n    for (let x = floor(CX - R - 1); x \u003c= ceil(CX + R + 1); x++) {\n      const ux = (x + 0.5 - CX) / R, uy = (CY - y - 0.5) / R, rr = hypot(ux, uy);\n      if (rr > 1 + 1.5 / R) continue;\n      // The rim, a pixel and a half wide.\n      const rim = cl(1 - abs(rr - 1) * R / 0.9, 0, 1);\n      if (rim > 0) add(x, y, disc, 0.4 * rim);\n      if (rr >= 1) continue;\n      let a = 0.09;\n      if (done >= 2 && (ex * (uy - cy[ti]) - ey * (ux - cx[ti])) * ref > 0) {\n        const phi = atan2(uy, ux);\n        let ok = true;\n        if (phi >= 0) {\n          const j = floor((PI - phi) / (2 * th));\n          if (j \u003c T2) ok = ux * cos(PI - th * (2 * j + 1)) + uy * sin(PI - th * (2 * j + 1)) \u003c= cth;\n        } else {\n          const j = floor((phi + PI) / (2 * th));\n          if (j \u003c B2) ok = ux * cos(-PI + th * (2 * j + 1)) + uy * sin(-PI + th * (2 * j + 1)) \u003c= cth;\n        }\n        if (ok) a = 0.55;\n      }\n      if (a > 0.1) hsv(tone(0.76 - 0.2 * (ux + 1), hue), 0.7, 1, swept);\n      add(x, y, a > 0.1 ? swept : disc, a);\n    }\n  // The wedge 0 \u003c= angle \u003c= theta, where v \u003c= V and no collision is left.\n  const goal = [1, 0.95, 0.8];\n  line(rgb, CX, CY, CX + R, CY, goal, 0.35);\n  line(rgb, CX, CY, CX + R * cos(th), CY - R * sin(th), goal, 0.35);\n  // The chords: every one so far, faint (the last 400 at k = 3, the older\n  // ones lie under the swept disc), and the newest bright.\n  const chord = [0.85, 0.95, 1], keep = [0.6, 0.45, 0.16, 0.12][S.k];\n  for (let j = max(1, done - 400); j \u003c= done; j++) {\n    const age = since(j), a = keep + 0.7 * exp(-age / 0.25);\n    line(rgb, CX + R * cx[j - 1], CY - R * cy[j - 1], CX + R * cx[j], CY - R * cy[j], chord, min(1, a));\n  }\n  // The state point.\n  const sx = CX + R * cx[done], sy = CY - R * cy[done];\n  for (const [dx, dy] of [[0, 0], [-0.7, 0], [0.7, 0], [0, -0.7], [0, 0.7]]) splat(rgb, sx + dx, sy + dy, [1, 1, 1], 1);\n\n  // The tally, one dot per collision; the newest flash white.\n  for (let i = 0; i \u003c done; i++) {\n    const [x, y, w] = tallyAt(S.k, i), q = floor(i / 100);\n    const band = S.k === 3 ? BAND[floor(i / 1000)] : BAND[0];\n    hsv(tone(band, hue), 0.75, q % 2 ? 0.62 : 0.9, c);\n    const f = 0.9 * exp(-since(i + 1) / 0.3);\n    for (let e = 0; e \u003c 3; e++) c2[e] = c[e] + (1 - c[e]) * f;\n    for (let yy = 0; yy \u003c w; yy++) for (let xx = 0; xx \u003c w; xx++) add(x + xx, y - yy, c2, 1);\n  }\n\n  // The rail, the wall and the blocks.\n  const rail = hsv(tone(0.62, hue), 0.35, 1, [0, 0, 0]);\n  for (let y = 0; y \u003c FLOOR; y++) add(5, y, rail, 0.16);\n  // The last wall hit and the last block hit, for a flash.\n  let lastW = -1, lastB = -1;\n  for (let j = done; j >= 1 && (lastW \u003c 0 || lastB \u003c 0) && j > done - 3; j--) {\n    if (E.kind[j] === 2 && lastW \u003c 0) lastW = j;\n    if (E.kind[j] === 1 && lastB \u003c 0) lastB = j;\n  }\n  const wf = lastW > 0 ? exp(-since(lastW) / 0.15) : 0;\n  const wall = hsv(tone(0.3, hue), 0.25, 1, [0, 0, 0]);\n  for (let y = FLOOR; y \u003c H; y++) for (let x = 0; x \u003c 11; x++) add(x, y, wall, 0.55 + 0.45 * wf);\n  const at = (j0, z0, v0) => z0 + v0 * (tau - E.T[j0]);\n  const z1 = at(done, E.A[done], E.VL[done]), z2 = at(done, E.B[done], E.VH[done]);\n  const light = hsv(tone(0.5, hue), 0.7, 1, [0, 0, 0]);\n  const heavy = hsv(tone(0.78, hue), 0.7, 1, [0, 0, 0]);\n  const block = (za, zb, x0, x1, col, a) => {\n    const ya = FLOOR - zb, yb = FLOOR - za;\n    for (let y = max(0, floor(ya)); y \u003c= min(H - 1, floor(yb)); y++) {\n      const cov = min(y + 1, yb) - max(y, ya);\n      if (cov > 0) for (let x = x0; x \u003c= x1; x++) add(x, y, col, a * cov);\n    }\n  };\n  const bf = lastB > 0 ? exp(-since(lastB) / 0.15) : 0;\n  block(z1, z1 + HL, 2, 8, light, 0.9);\n  block(z2, z2 + S.hh, S.k ? 0 : 2, S.k ? 10 : 8, heavy, 0.85);\n  // The face where they meet glows on each hit.\n  if (bf > 0.02) block(z2 - 0.5, z2 + 0.5, S.k ? 0 : 2, S.k ? 10 : 8, [1, 1, 1], 0.8 * bf);\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 1] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 2] * fade, 0, 1)) | 0);\n}\n","medial-axis":"// ===== Patternflow pattern =====\n// Title:   Medial Axis\n// Family:  algo\n// Idea:    A fire lit along a closed curve that fills the panel burns inward and outward at one speed, its fronts drawn as staggered dashes of the distance to the curve, and every LED takes the colour of the point of the curve nearest it, so the medial axis shows as a pale seam where that point jumps across and the fronts fold into corners: a tall tree that grows a long new branch from every bump a fraction of an LED high.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: medial axis and the grassfire transform (Harry Blum, 1967), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bumps=0..1, Width=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 an LED is teal where its nearest point is on the right of the curve, blue where it is at the top or bottom and magenta where it is on the left, in 32 steps round the curve; outside the curve the same hues go pale. At 0.5 the right is magenta, the top and bottom yellow and the left teal.\n// Knob 2: Speed. The fronts move 1.5 times the knob in LEDs a second: 3 at 2, so a front lit on the curve reaches the deepest point, about 29 LEDs in, after 9.5 seconds; 0.3 at 0.2 and 4.5 at 3. At 2 the blob's five harmonics drift 0.07 to 0.13 radians a second and the bumps travel round the curve 1 to 3.6 LEDs a second; both scale with the knob.\n// Knob 3: Bumps. Adds ripples of 11, 14, 17, 21, 25 and 29 waves round the curve, 1.6 down to 0.7 LEDs high, one more each sixth of the knob. At 0 the axis is a trunk with a fork, 3.5 ends inside the curve on average. Ripples a fifth of an LED high (0.02) give it 8 ends, half an LED (0.05) 15 and the whole first ripple (0.17) 26, each new branch running from its ripple deep into the curve to the trunk; past that the count stays at 21 to 24 while the branches crowd and the pale seams grow from 5% of the inside to 16%.\n// Knob 4: Width. The distance between fronts, 6.2 + 8 x knob LEDs: 6.7 at the opening 0.06, 14.2 at 1. The dashes stay about 12 LEDs long along the curve, so wide fronts break into squarer blocks.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, cos, sin, PI, round } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Vertices of the curve.\nconst N = 384;\n// The blob: harmonic k of the radius, its amplitude and its drift in\n// radians a second at Speed 2.\nconst LOW = [[2, 0.09, 0.13], [3, 0.08, -0.09], [4, 0.07, 0.07], [5, 0.05, -0.11], [6, 0.035, 0.1]];\n// The bumps, in LEDs along the outward ray, k waves round the curve. Bumps\n// brings them in one after another.\nconst BUMPS = [[11, 1.6, 0.21], [14, 1.3, -0.17], [17, 1.1, 0.13], [21, 0.9, -0.23], [25, 0.8, 0.19], [29, 0.7, -0.15]];\n// The margin left between the blob and the panel's edges.\nconst M = 2;\n// Length of a dash along the curve, in LEDs.\nconst DASH = 12;\n// The sawtooth's height: each front is 255 on its bright side.\nconst A = 255;\n\n// Vertex angles spaced evenly by arc length round a 29 x 61 ellipse.\nconst TH = new Float32Array(N), CO = new Float32Array(N), SI = new Float32Array(N);\n{\n  const K = 4096, acc = new Float64Array(K + 1);\n  for (let k = 0; k \u003c K; k++) {\n    const a = (k + 0.5) / K * TAU;\n    acc[k + 1] = acc[k] + Math.hypot(29 * sin(a), 61 * cos(a));\n  }\n  for (let i = 0, k = 0; i \u003c N; i++) {\n    const target = (i / N) * acc[K];\n    while (acc[k + 1] \u003c target) k++;\n    TH[i] = ((k + (target - acc[k]) / (acc[k + 1] - acc[k])) / K) * TAU;\n    CO[i] = cos(TH[i]);\n    SI[i] = sin(TH[i]);\n  }\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    clock: 0, ph: 0, hue: 0, speed: 2, bumps: 0, width: 5,\n    px: new Float32Array(N), py: new Float32Array(N),\n    // Per segment: start, direction, 1 / length squared, length, arc start.\n    ax: new Float32Array(N), ay: new Float32Array(N), dx: new Float32Array(N), dy: new Float32Array(N),\n    il: new Float32Array(N), len: new Float32Array(N), arc: new Float32Array(N), per: 1,\n    F: new Int16Array(NP), D2: new Float32Array(NP), T: new Float32Array(NP), U: new Float32Array(NP),\n    G: new Float32Array(NP), IN: new Uint8Array(NP),\n    DIS: new Float32Array(NP), SH: new Float32Array(NP), HT: new Float32Array(NP),\n    CR: new Float32Array(NP), CG: new Float32Array(NP), CB: new Float32Array(NP), frame: 0, ready: false,\n    xs: new Float32Array(H * 32), xc: new Int32Array(H),\n    pal: new Float32Array(256 * 6), palHue: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.bumps = cl(kv[2], 0, 1);\n  s.width = 6.2 + 8 * cl(kv[3], 0, 1);\n  s.clock += d * s.speed / 2;\n  // The fronts move 1.5 x Speed LEDs a second.\n  s.ph += (d * 1.5 * s.speed) / s.width;\n  s.ph -= floor(s.ph);\n}\n\n// The curve at this moment: the blob scaled to the panel less the margin,\n// then the bumps pushed out along the ray from its centre.\nfunction curve(s) {\n  const { px, py } = s, t = s.clock;\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c N; i++) {\n    let r = 1;\n    for (const [k, a, w] of LOW) r += a * cos(k * TH[i] + w * t + k);\n    px[i] = r * CO[i];\n    py[i] = r * SI[i];\n    x0 = min(x0, px[i]); x1 = max(x1, px[i]); y0 = min(y0, py[i]); y1 = max(y1, py[i]);\n  }\n  const sx = (W - 1 - 2 * M) / (x1 - x0), sy = (H - 1 - 2 * M) / (y1 - y0), cx = M - x0 * sx, cy = M - y0 * sy;\n  const nb = s.bumps * BUMPS.length;\n  for (let i = 0; i \u003c N; i++) {\n    const X = px[i] * sx, Y = py[i] * sy, rho = sqrt(X * X + Y * Y);\n    let b = 0;\n    for (let j = 0; j \u003c BUMPS.length && j \u003c nb; j++) {\n      const [k, a, w] = BUMPS[j];\n      b += min(1, nb - j) * a * cos((k * TAU * i) / N + w * t * 4 + j * 2.1);\n    }\n    const f = 1 + b / rho;\n    px[i] = cx + X * f;\n    py[i] = cy + Y * f;\n  }\n  let arc = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const j = i + 1 === N ? 0 : i + 1, dx = px[j] - px[i], dy = py[j] - py[i], l2 = dx * dx + dy * dy;\n    s.ax[i] = px[i]; s.ay[i] = py[i]; s.dx[i] = dx; s.dy[i] = dy;\n    s.il[i] = l2 > 0 ? 1 / l2 : 0;\n    s.len[i] = sqrt(l2);\n    s.arc[i] = arc;\n    arc += s.len[i];\n  }\n  s.per = arc;\n}\n\n// Inside or out, row by row: where the curve's edges cross each row's\n// centre line, sorted, filled between pairs.\nfunction fill(s) {\n  const { xs, xc, IN, px, py } = s;\n  xc.fill(0);\n  IN.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const j = i + 1 === N ? 0 : i + 1, ya = py[i], yb = py[j];\n    if (ya === yb) continue;\n    const lo = min(ya, yb), hi = max(ya, yb);\n    for (let y = max(0, Math.ceil(lo)); y \u003c hi && y \u003c H; y++) {\n      if (xc[y] \u003c 32) xs[y * 32 + xc[y]++] = px[i] + ((y - ya) * (px[j] - px[i])) / (yb - ya);\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const n = xc[y], o = y * 32;\n    for (let a = 1; a \u003c n; a++) {\n      const v = xs[o + a];\n      let b = a - 1;\n      while (b >= 0 && xs[o + b] > v) (xs[o + b + 1] = xs[o + b]), b--;\n      xs[o + b + 1] = v;\n    }\n    for (let a = 0; a + 1 \u003c n; a += 2) {\n      for (let x = max(0, Math.ceil(xs[o + a])); x \u003c W && x \u003c xs[o + a + 1]; x++) IN[y * W + x] = 1;\n    }\n  }\n}\n\n// The feature transform: for every LED the nearest segment of the curve,\n// the squared distance to it and where on it the nearest point lies. The\n// arrays sit in module variables so the two small functions below inline.\nlet AX, AY, DX, DY, IL, FF, DD, TT, tt = 0;\nfunction sd(i, x, y) {\n  const ex = x - AX[i], ey = y - AY[i];\n  let t = (ex * DX[i] + ey * DY[i]) * IL[i];\n  t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n  tt = t;\n  const fx = ex - t * DX[i], fy = ey - t * DY[i];\n  return fx * fx + fy * fy;\n}\n// Try segment c for LED p, then walk along the curve while it gets nearer.\n// A segment within two of the one held is skipped: the one held is already\n// the nearest of its neighbours.\nfunction relax(p, x, y, c) {\n  if (c \u003c 0) return;\n  const e = FF[p];\n  if (e >= 0) {\n    const k = c > e ? c - e : e - c;\n    if (k \u003c= 2 || k >= N - 2) return;\n  }\n  let bd = sd(c, x, y);\n  if (bd >= DD[p]) return;\n  let bt = tt;\n  for (;;) {\n    const j = c + 1 === N ? 0 : c + 1, d = sd(j, x, y);\n    if (d \u003c bd) (bd = d), (bt = tt), (c = j);\n    else break;\n  }\n  for (;;) {\n    const j = c === 0 ? N - 1 : c - 1, d = sd(j, x, y);\n    if (d \u003c bd) (bd = d), (bt = tt), (c = j);\n    else break;\n  }\n  FF[p] = c;\n  DD[p] = bd;\n  TT[p] = bt;\n}\nfunction transform(s) {\n  (AX = s.ax), (AY = s.ay), (DX = s.dx), (DY = s.dy), (IL = s.il), (FF = s.F), (DD = s.D2), (TT = s.T);\n  const F = FF, D2 = DD;\n  F.fill(-1);\n  D2.fill(1e9);\n  // Seeds: the LED nearest each vertex takes that vertex's segment, walked\n  // to the nearest segment around it.\n  for (let i = 0; i \u003c N; i++) {\n    const x = round(AX[i]), y = round(AY[i]);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    relax(y * W + x, x, y, i);\n  }\n  // Two raster passes carry the nearest segment from neighbour to neighbour.\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0, p = y * W; x \u003c W; x++, p++) {\n      if (x > 0) relax(p, x, y, F[p - 1]);\n      if (y > 0) {\n        relax(p, x, y, F[p - W]);\n        if (x > 0) relax(p, x, y, F[p - W - 1]);\n        if (x \u003c W - 1) relax(p, x, y, F[p - W + 1]);\n      }\n    }\n    for (let x = W - 2, p = y * W + x; x >= 0; x--, p--) relax(p, x, y, F[p + 1]);\n  }\n  for (let y = H - 1; y >= 0; y--) {\n    for (let x = W - 1, p = y * W + x; x >= 0; x--, p--) {\n      if (x \u003c W - 1) relax(p, x, y, F[p + 1]);\n      if (y \u003c H - 1) {\n        relax(p, x, y, F[p + W]);\n        if (x \u003c W - 1) relax(p, x, y, F[p + W + 1]);\n        if (x > 0) relax(p, x, y, F[p + W - 1]);\n      }\n    }\n    for (let x = 1, p = y * W + 1; x \u003c W; x++, p++) relax(p, x, y, F[p - 1]);\n  }\n}\n\n// Everything that depends on the curve and not on the phase of the fire:\n// the distance of each LED, its dash, its screen offset and its colour.\n//\n// The dashes and the screen are there for the study map. Bands of the\n// distance rise along the normal and stay flat along the front, so where\n// the curve runs up the panel only the steps along a row change. With every\n// rise kept under 40 levels, the mean step between neighbours stayed at\n// 0.151 of full scale with bands alone, and no height or width of band took\n// it past 0.16. The half-band jumps between dashes and the screen's steps\n// along the fronts give the columns their share too: 0.203.\nfunction field(s) {\n  curve(s);\n  fill(s);\n  transform(s);\n  const { F, D2, T, U, G, IN, arc, len, pal, ax, ay, dx, dy, DIS, SH, HT, CR, CG, CB } = s, per = s.per, half = per / 2;\n  for (let p = 0; p \u003c NP; p++) U[p] = arc[F[p]] + T[p] * len[F[p]];\n  // How far apart along the curve the nearest points of two neighbours\n  // lie: a few LEDs off the medial axis, up to half the curve across it.\n  G.fill(0);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      if (x \u003c W - 1) {\n        let g = abs(U[p] - U[p + 1]);\n        if (g > half) g = per - g;\n        if (g > G[p]) G[p] = g;\n        if (g > G[p + 1]) G[p + 1] = g;\n      }\n      if (y \u003c H - 1) {\n        let g = abs(U[p] - U[p + W]);\n        if (g > half) g = per - g;\n        if (g > G[p]) G[p] = g;\n        if (g > G[p + W]) G[p + W] = g;\n      }\n    }\n  if (s.palHue !== s.hue) {\n    // Round the curve the hue runs from teal on the right through blue at\n    // the top and bottom to magenta on the left; outside it the same hues\n    // go pale.\n    for (let i = 0; i \u003c 256; i++) {\n      const tri = 1 - abs(1 - 2 * (i / 256));\n      hsv(0.42 + s.hue + 0.5 * tri, 0.85, 1, pal, i * 6);\n      hsv(0.42 + s.hue + 0.5 * tri, 0.38, 1, pal, i * 6 + 3);\n    }\n    s.palHue = s.hue;\n  }\n  const rise = A / s.width, nd = 2 * max(2, round(per / (2 * DASH))), dl = per / nd;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const i = F[p], d = sqrt(D2[p]), u = U[p];\n      DIS[p] = d;\n      SH[p] = 0.5 * (floor(u / dl) & 1);\n      // The screen: rows, or columns where the normal is nearer vertical,\n      // alternate up and down by as much as the step to the neighbour across\n      // leaves under 38 levels. It needs the direction to the nearest point,\n      // or across the segment for an LED on the curve.\n      let gx, gy, gn;\n      if (d > 0.3) (gx = abs(x - ax[i] - T[p] * dx[i])), (gy = abs(y - ay[i] - T[p] * dy[i])), (gn = d);\n      else (gx = abs(dy[i])), (gy = abs(dx[i])), (gn = len[i] || 1);\n      const row = gx >= gy, del = (38 - (rise * (row ? gy : gx)) / gn) / 2;\n      HT[p] = del > 0 ? ((row ? y : x) & 1 ? del : -del) : 0;\n      // The hue steps 32 times round the curve.\n      const o = ((floor((u / per) * 32) & 31) \u003c\u003c 3) * 6 + (IN[p] ? 0 : 3);\n      const wh = cl((G[p] - 3) / 9, 0, 1) * 0.8;\n      CR[p] = pal[o] + (1 - pal[o]) * wh;\n      CG[p] = pal[o + 1] + (1 - pal[o + 1]) * wh;\n      CB[p] = pal[o + 2] + (1 - pal[o + 2]) * wh;\n    }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  // The curve moves a small fraction of an LED a frame, so its field is\n  // worked out every other frame; the fire moves every frame.\n  if (!s.ready || (s.frame++ & 1) === 0) field(s), (s.ready = true);\n  const { DIS, SH, HT, CR, CG, CB } = s, w = s.width, ph = s.ph;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      // A sawtooth of the distance: each front bright on its trailing side,\n      // dark ahead of it, the brightness fading back towards the curve.\n      // Every other dash runs half a band behind.\n      const f = DIS[p] / w - ph + SH[p];\n      let lv = A * (f - floor(f)) + HT[p];\n      lv = lv \u003c 0 ? 0 : lv > 255 ? 255 : lv;\n      display.setPixel(x, y, round(CR[p] * lv), round(CG[p] * lv), round(CB[p] * lv));\n    }\n}\n","ostwald-ripening":"// ===== Patternflow pattern =====\n// Title:   Ostwald Ripening\n// Family:  sim\n// Idea:    A few hundred droplets sit still in a slightly supersaturated solution and trade matter through it: every drop smaller than the mean radius is magenta and shrinks ever faster until it blinks out, every larger one is green and swells, the solution glows faint magenta round the small drops and green round the large ones while specks of solute drift from the one to the other, and when fewer than a fifth are left a new population condenses in the gaps.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ostwald ripening (Wilhelm Ostwald, 1896) and the Lifshitz-Slyozov-Wagner theory of coarsening (Ilya Lifshitz and Vitaly Slyozov, 1961; Carl Wagner, 1961), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drops=200..500, Spread=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 growing drops and the poorer solution round them are green, shrinking drops and the richer solution magenta, and drops within 30% of the mean radius pale towards white; at 0.25 growing is azure and shrinking green, at 0.5 violet and cyan, at 0.75 rose and blue. The wheel skips orange and yellow, which read brown in the faint field.\n// Knob 2: Speed. At 2 the kinetics run one time unit a second, K = 0.42 r0^3 for a population that starts at radius r0, and a population ripens down to 18% of its drops in 13 to 19 seconds and is renewed over 1.6 seconds; at 0.2 a population lasts about 3 minutes, at 3 about 12 seconds.\n// Knob 3: Drops. How many droplets a new population starts with, 200 to 500, covering 17% of the panel: at 200 they start at radius 1.49 LEDs and the 37 left at the renewal average 2.4 (the largest 3.8); at 500 they start at 0.94 and the 91 left average 1.5 (the largest 2.4).\n// Knob 4: Spread. How unequal the starting radii are: r0 (1 + s g), with g a sum of three uniform numbers scaled to deviation 1, s from 0.12 at 0 to 0.45 at 1 (0.14 at the opening), and the radius kept between 0.35 r0 and 2.2 r0. At 0.14 a population of 200 keeps 136 drops after 3 seconds; at 0.45 only 93, as the smallest go at once.\n\n// Each drop exchanges matter with a mean field. By the Gibbs-Thomson effect\n// the solution at a drop's surface is richer the smaller the drop,\n// c(r) = c_inf (1 + a / r), and in the quasi-static diffusion field round it\n// the excess over the mean c falls off as r / d. A drop gains volume at the\n// rate 4 pi D r (c - c(r)), which in reduced units is\n//   d(r^3)/dt = 3 K (r / r_c - 1),   dr/dt = (K / r)(1 / r_c - 1 / r),\n// where r_c is the radius in balance with the field. The total volume is\n// fixed, so the sum of the rates is zero and r_c is exactly the mean radius.\n// Lifshitz and Slyozov, and Wagner, showed that then r_c^3 grows as\n// (4/9) K t and the distribution of r / \u003cr> tends to one shape, with its\n// peak near 1.13 and nothing past 3/2. Run with a million drops from this\n// pattern's own start, ripen() below gave \u003cr>^3 growing at 0.446 K over the\n// time the count fell from 50,000 to 10,000 (R^2 0.9999), with the scaled\n// sizes peaking near 1.13 and none past 1.35.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (u) => u * u * (3 - 2 * u);\n// Capacity, the share of the panel a new population covers, the rate (K =\n// RATE r0^3, with time in seconds at Speed 2), when to renew (the share of\n// drops left) and how long the renewal takes, in seconds at Speed 2.\nconst CAP = 620, AREA = 0.17, RATE = 0.42, END = 0.18, RENEW = 1.6;\n// Solute specks: how many at most, how many a second leave the shrinking\n// drops, and how far the field reaches round a drop.\nconst MOTES = 200, EMIT = 110, REACH = 8;\n// Hues at knob 0 before the wheel bends them: green and magenta.\nconst HUE_G = 0.135, HUE_S = 0.81;\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    ready: false, hue: 0, speed: 2, n0: 200, spread: 0.14,\n    // Drops: centre, volume r^3, radius, how far a new drop has condensed\n    // (0..1), and whether it belongs to the population a renewal dissolves.\n    n: 0, x: new Float32Array(CAP), y: new Float32Array(CAP), v: new Float64Array(CAP), r: new Float32Array(CAP),\n    grow: new Float32Array(CAP), old: new Uint8Array(CAP),\n    K: 1, rc: 1, renew: -1, merges: 0,\n    // Specks of solute.\n    m: 0, mx: new Float32Array(MOTES), my: new Float32Array(MOTES), ml: new Float32Array(MOTES), emit: 0,\n    // Pops where drops vanish: x, y, age.\n    pops: [],\n    field: new Float32Array(N), owner: new Int16Array(N), buf: new Float32Array(N * 3),\n    cg: new Float32Array(3), cs: new Float32Array(3), tmp: new Float32Array(3),\n  };\n}\n\n// The kinetics, one step of the mean-field equation on the volumes v[0..n):\n// r_c is the mean radius, and a drop whose volume reaches zero is gone\n// (its slot is set to -1). Returns r_c.\nfunction ripen(v, n, dt, K) {\n  let sr = 0, live = 0;\n  for (let i = 0; i \u003c n; i++) if (v[i] > 0) (sr += Math.cbrt(v[i])), live++;\n  if (!live) return 0;\n  const rc = sr / live;\n  for (let i = 0; i \u003c n; i++) {\n    if (v[i] \u003c= 0) continue;\n    v[i] += 3 * K * (Math.cbrt(v[i]) / rc - 1) * dt;\n    if (v[i] \u003c= 0) v[i] = -1;\n  }\n  return rc;\n}\n\n// A new population: radii r0 (1 + spread g) with g roughly normal, placed\n// at random with a gap of a LED from every drop already there.\nfunction populate(s) {\n  const n0 = s.n0, r0 = sqrt((AREA * N) / (PI * n0));\n  s.K = RATE * r0 * r0 * r0;\n  const first = s.n;\n  for (let k = 0; k \u003c n0 && s.n \u003c CAP; k++) {\n    const g = (Math.random() + Math.random() + Math.random() - 1.5) * 2;\n    const r = r0 * cl(1 + s.spread * g, 0.35, 2.2);\n    for (let tries = 0; tries \u003c 40; tries++) {\n      const x = r + Math.random() * (W - 2 * r), y = r + Math.random() * (H - 2 * r);\n      let ok = true;\n      for (let j = 0; j \u003c s.n && ok; j++) {\n        const dx = s.x[j] - x, dy = s.y[j] - y, need = s.r[j] + r + 1;\n        if (dx * dx + dy * dy \u003c need * need) ok = false;\n      }\n      if (!ok) continue;\n      const i = s.n++;\n      s.x[i] = x;\n      s.y[i] = y;\n      s.v[i] = r * r * r;\n      s.r[i] = r;\n      s.grow[i] = first ? 0 : 1;\n      s.old[i] = 0;\n      break;\n    }\n  }\n}\n\nfunction remove(s, i) {\n  const j = --s.n;\n  s.x[i] = s.x[j];\n  s.y[i] = s.y[j];\n  s.v[i] = s.v[j];\n  s.r[i] = s.r[j];\n  s.grow[i] = s.grow[j];\n  s.old[i] = s.old[j];\n}\n\n// Two drops that touch run together, keeping their volume.\nfunction merge(s) {\n  for (let i = 0; i \u003c s.n; i++)\n    for (let j = i + 1; j \u003c s.n; j++) {\n      const dx = s.x[j] - s.x[i], dy = s.y[j] - s.y[i], need = s.r[i] + s.r[j] + 0.3;\n      if (dx * dx > need * need || dx * dx + dy * dy >= need * need || s.old[i] || s.old[j]) continue;\n      const vi = s.v[i], vj = s.v[j], v = vi + vj;\n      s.x[i] = (s.x[i] * vi + s.x[j] * vj) / v;\n      s.y[i] = (s.y[i] * vi + s.y[j] * vj) / v;\n      s.v[i] = v;\n      s.r[i] = Math.cbrt(v);\n      remove(s, j);\n      s.merges++;\n      j = i;\n    }\n}\n\n// The field round the drops: each adds (1 - r / r_c) / d outside itself,\n// the excess of a drop's surface over the mean carried out as 1 / d, faded\n// to nothing REACH LEDs past its edge. Positive near small drops, negative\n// near large ones. owner marks the LEDs inside each drop.\nfunction field(s) {\n  const F = s.field, O = s.owner, rc = s.rc;\n  F.fill(0);\n  O.fill(-1);\n  for (let i = 0; i \u003c s.n; i++) {\n    const r = s.r[i] * (s.old[i] ? 1 : sm(s.grow[i])), cx = s.x[i], cy = s.y[i];\n    if (r \u003c= 0.05) continue;\n    const e = s.old[i] ? 0 : 1 - s.r[i] / rc, R = r + REACH;\n    const x0 = max(0, floor(cx - R)), x1 = min(W - 1, floor(cx + R)), y0 = max(0, floor(cy - R)), y1 = min(H - 1, floor(cy + R));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, d = sqrt(dx * dx + dy * dy), p = y * W + x;\n        if (d \u003c r) {\n          O[p] = i;\n          continue;\n        }\n        if (d >= R) continue;\n        const t = 1 - (d - r) / REACH;\n        F[p] += (e / d) * t * t;\n      }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 200, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.n0 = round(cl(kv[2], 200, 500));\n  s.spread = 0.12 + 0.33 * cl(kv[3], 0, 1);\n  if (!s.ready) {\n    populate(s);\n    s.ready = true;\n  }\n  const g = d * s.speed;\n  if (s.renew >= 0) {\n    // A renewal: the old drops dissolve while the new ones condense.\n    s.renew += g / 2 / RENEW;\n    let sr = 0, k = 0;\n    for (let i = 0; i \u003c s.n; i++) if (!s.old[i]) (s.grow[i] = min(1, s.renew)), (sr += s.r[i]), k++;\n    // The new drops are measured against their own mean from the start.\n    s.rc = sr / max(1, k);\n    if (s.renew >= 1) {\n      for (let i = s.n - 1; i >= 0; i--) if (s.old[i]) remove(s, i);\n      s.renew = -1;\n    }\n  } else {\n    // Ripening, in steps of at most 1/60 of a second.\n    const steps = Math.ceil(g / 2 / (1 / 60)) || 1, h = g / 2 / steps;\n    for (let k = 0; k \u003c steps; k++) s.rc = ripen(s.v, s.n, h, s.K) || s.rc;\n    for (let i = s.n - 1; i >= 0; i--) {\n      if (s.v[i] \u003c 0) {\n        s.pops.push([s.x[i], s.y[i], 0]);\n        remove(s, i);\n      } else s.r[i] = Math.cbrt(s.v[i]);\n    }\n    merge(s);\n    if (s.n \u003c= max(8, s.n0 * END)) {\n      for (let i = 0; i \u003c s.n; i++) s.old[i] = 1;\n      populate(s);\n      s.renew = 0;\n    }\n  }\n  if (s.renew >= 0) {\n    // The dissolving drops shrink as the renewal runs.\n    const f = 1 - sm(min(1, s.renew));\n    for (let i = 0; i \u003c s.n; i++) if (s.old[i]) s.r[i] = Math.cbrt(s.v[i]) * f;\n  }\n  field(s);\n  motes(s, d * s.speed / 2);\n  for (const p of s.pops) p[2] += d * s.speed / 2;\n  s.pops = s.pops.filter((p) => p[2] \u003c 0.4);\n}\n\n// Specks of solute leave the shrinking drops and wander down the field to\n// the growing ones, which take them in.\nfunction motes(s, g) {\n  const F = s.field, O = s.owner;\n  s.emit += EMIT * g;\n  while (s.emit >= 1 && s.renew \u003c 0) {\n    s.emit -= 1;\n    if (s.m >= MOTES) continue;\n    // Pick a shrinking drop, the more often the faster it loses volume.\n    for (let tries = 0; tries \u003c 12; tries++) {\n      const i = floor(Math.random() * s.n), out = 1 - s.r[i] / s.rc;\n      if (out \u003c= 0 || Math.random() > out * 2) continue;\n      const a = Math.random() * TAU, k = s.m++;\n      s.mx[k] = s.x[i] + (s.r[i] + 0.7) * cos(a);\n      s.my[k] = s.y[i] + (s.r[i] + 0.7) * sin(a);\n      s.ml[k] = 0;\n      break;\n    }\n  }\n  if (s.renew >= 0) s.emit = 0;\n  for (let k = s.m - 1; k >= 0; k--) {\n    let x = s.mx[k], y = s.my[k];\n    const xi = cl(floor(x), 1, W - 2), yi = cl(floor(y), 1, H - 2), p = yi * W + xi;\n    const gx = (F[p + 1] - F[p - 1]) / 2, gy = (F[p + W] - F[p - W]) / 2;\n    // Down the gradient, at most a LED a frame, and a random walk.\n    const sp = sqrt(gx * gx + gy * gy) + 1e-9, v = min(30, 600 * sp) * g;\n    x += (-gx / sp) * v + (Math.random() - 0.5) * 3 * sqrt(g);\n    y += (-gy / sp) * v + (Math.random() - 0.5) * 3 * sqrt(g);\n    s.ml[k] += g;\n    const q = floor(y) * W + floor(x), o = x >= 0 && x \u003c W && y >= 0 && y \u003c H ? O[q] : -2;\n    if (o === -2 || s.ml[k] > 2.5 || (o >= 0 && s.r[o] > s.rc)) {\n      const j = --s.m;\n      s.mx[k] = s.mx[j];\n      s.my[k] = s.my[j];\n      s.ml[k] = s.ml[j];\n      continue;\n    }\n    s.mx[k] = x;\n    s.my[k] = y;\n  }\n}\n\nfunction add(B, x, y, c, k) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  B[o] = min(1, B[o] + c[0] * k);\n  B[o + 1] = min(1, B[o + 1] + c[1] * k);\n  B[o + 2] = min(1, B[o + 2] + c[2] * k);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.ready) return;\n  const B = s.buf, F = s.field, cg = s.cg, cs = s.cs, c = s.tmp;\n  hsv(wheel(HUE_G + s.hue), 0.85, 1, cg, 0);\n  hsv(wheel(HUE_S + s.hue), 0.8, 1, cs, 0);\n  // The field: magenta where the solution is richer than the mean, green\n  // where it is poorer, faint.\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const f = F[p], a = min(0.45, abs(f) * 3), col = f > 0 ? cs : cg;\n    B[o] = col[0] * a;\n    B[o + 1] = col[1] * a;\n    B[o + 2] = col[2] * a;\n  }\n  // The specks, pale in the colour of the field they cross.\n  const wh = [0.85, 0.85, 0.9];\n  for (let k = 0; k \u003c s.m; k++) {\n    const life = s.ml[k], a = 0.55 * min(1, life * 8) * min(1, (2.5 - life) * 2);\n    const x = floor(s.mx[k]), y = floor(s.my[k]), col = F[cl(y, 0, H - 1) * W + cl(x, 0, W - 1)] > 0 ? cs : cg;\n    for (let e = 0; e \u003c 3; e++) c[e] = 0.5 * (wh[e] + col[e]);\n    add(B, x, y, c, a);\n  }\n  // The drops: pale when near the mean radius, green the more they exceed\n  // it, magenta the more they fall short.\n  for (let i = 0; i \u003c s.n; i++) {\n    const r = s.r[i] * (s.old[i] ? 1 : sm(s.grow[i])), cx = s.x[i], cy = s.y[i];\n    if (r \u003c= 0.05) continue;\n    // A drop of the old population dissolving in a renewal is pale.\n    const q = s.old[i] ? 0 : s.r[i] / s.rc - 1, t = min(1, abs(q) / 0.3), col = q > 0 ? cg : cs;\n    for (let e = 0; e \u003c 3; e++) c[e] = 0.9 * (wh[e] * (1 - t) + col[e] * t);\n    const x0 = max(0, floor(cx - r - 1)), x1 = min(W - 1, floor(cx + r + 1)), y0 = max(0, floor(cy - r - 1)), y1 = min(H - 1, floor(cy + r + 1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, a = cl(r + 0.5 - sqrt(dx * dx + dy * dy), 0, 1);\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        for (let e = 0; e \u003c 3; e++) B[o + e] = B[o + e] * (1 - a) + c[e] * a;\n      }\n  }\n  // A drop that vanishes leaves a ring that opens and fades.\n  for (const [px, py, age] of s.pops) {\n    const u = age / 0.4, rr = 0.6 + 2.6 * u, k = 0.8 * (1 - u), m = Math.ceil(TAU * rr * 1.5);\n    for (let j = 0; j \u003c m; j++) {\n      const a = (j / m) * TAU;\n      add(B, floor(px + rr * cos(a)), floor(py + rr * sin(a)), cs, k / 2);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, (B[o] * 255) | 0, (B[o + 1] * 255) | 0, (B[o + 2] * 255) | 0);\n}\n","pentagon-tilings":"// ===== Patternflow pattern =====\n// Title:   Pentagon Tilings\n// Family:  cells\n// Idea:    The plane tiled by copies of one convex pentagon with thin dark grout, each tile coloured by which way it is turned and whether it is flipped, drifting slowly up the panel and to the left; the knob steps through five of the fifteen kinds, from Reinhardt's type 1, whose pentagon keeps changing shape while it tiles, through the Cairo tiling and Reinhardt's six-fold type 5 to Marjorie Rice's type 13 and the type 15 found in 2015, each new tiling replacing the old one tile by tile.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tilings by one convex pentagon: types 1, 4 and 5 (Karl Reinhardt, 1918), type 13 (Marjorie Rice, 1976-77), type 15 (Casey Mann, Jennifer McLoud-Mann and David Von Derau, 2015), the list of fifteen shown complete (Michaël Rao, 2017), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Type=0..4, Size=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. A tile's colour says how it is turned: at 0 an unturned tile is cyan and the hue moves half way round the wheel as the turn goes from 0 to 360 degrees, so the Cairo tiling's four turns are cyan, azure, violet and magenta; a flipped tile takes a paler tint a little further on. At 0.5 the unturned tiles are red.\n// Knob 2: Speed. The tiles drift up and to the left at 1.5 x Speed LEDs a second, 3 at the opening, and type 1 runs round its loop of shapes in 32 / Speed seconds, 16 s at the opening; 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Type. 0 is type 1 (B + C = 180, two tiles a period), its pentagon morphing with B from 70 to 110 degrees; 1 the Cairo tiling, type 4 (b = c, d = e, B = D = 90, four tiles round each right-angled corner); 2 type 5 (a = b, d = e, A = 60, D = 120, six round A); 3 Rice's type 13 (d = 2a = 2e, B = E = 90, 2A + D = 360, eight tiles a period); 4 type 15 (a = c = e, b = 2a, angles 150, 60, 135, 105 and 90, twelve tiles a period). A change sweeps down the panel in 1.1 s, the new tiles taking over one at a time.\n// Knob 4: Size. Every tiling is scaled so a tile covers the area of a square 12 LEDs on a side at 0 (13 at the opening) up to 28 at 1: about 50 tiles on the panel at the opening and 10 at the end.\n\nconst W = 64, H = 128;\nconst { floor, min, max, cos, sin, atan2, hypot, sqrt, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst D2R = PI / 180;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// An isometry [c, s, m, tx, ty] sends p to R(th) diag(1, m) p + t.\nconst ap = (g, p) => {\n  const y = g[2] * p[1];\n  return [g[0] * p[0] - g[1] * y + g[3], g[1] * p[0] + g[0] * y + g[4]];\n};\nconst rot = (th, q) => {\n  const c = cos(th), s = sin(th);\n  return [c, s, 1, q[0] - c * q[0] + s * q[1], q[1] - s * q[0] - c * q[1]];\n};\n\n// The pentagon from its angles A..E (degrees) and sides, side a = EA,\n// b = AB, c = BC, d = CD, e = DE: walk from A along AB and turn by\n// 180 - angle at each corner. sides(x, y) gives the five sides with two of\n// them unknown; the walk must close, which fixes x and y.\nfunction pentagon(ang, sides) {\n  const walk = (sd) => {\n    const v = [[0, 0]];\n    let dir = 0, x = 0, y = 0;\n    for (let k = 1; k \u003c= 5; k++) {\n      x += sd[k % 5] * cos(dir);\n      y += sd[k % 5] * sin(dir);\n      if (k \u003c 5) v.push([x, y]), (dir += (180 - ang[k]) * D2R);\n    }\n    return { v, end: [x, y] };\n  };\n  const g0 = walk(sides(0, 0)).end, gx = walk(sides(1, 0)).end, gy = walk(sides(0, 1)).end;\n  const a = [gx[0] - g0[0], gx[1] - g0[1]], b = [gy[0] - g0[0], gy[1] - g0[1]], det = a[0] * b[1] - b[0] * a[1];\n  return walk(sides((-g0[0] * b[1] + g0[1] * b[0]) / det, (-a[0] * g0[1] + a[1] * g0[0]) / det)).v;\n}\n\n// A copy glued to tile g: the copy's corner b on g's corner a, the copy's\n// edge b -> bi along g's edge a -> ai, the copy mirrored when m = -1.\nfunction glue(v, g, a, ai, b, bi, m) {\n  const V = ap(g, v[a]), U = ap(g, v[ai]);\n  const th = atan2(U[1] - V[1], U[0] - V[0]) - atan2(m * (v[bi][1] - v[b][1]), v[bi][0] - v[b][0]);\n  const c = cos(th), s = sin(th), lx = v[b][0], ly = m * v[b][1];\n  return [c, s, m, V[0] - (c * lx - s * ly), V[1] - (s * lx + c * ly)];\n}\n// A tiling from gluings: G builds the tiles of one period from tile 0, and\n// each row of L glues a copy that is a translate of tile k, giving one of\n// the two periods.\nfunction glued(v, G, L) {\n  const isos = [[1, 0, 1, 0, 0]];\n  for (const [f, a, ai, b, bi, m] of G) isos.push(glue(v, isos[f], a, ai, b, bi, m));\n  const T = L.map(([f, a, ai, b, bi, m, k]) => {\n    const g = glue(v, isos[f], a, ai, b, bi, m);\n    return [g[3] - isos[k][3], g[4] - isos[k][4]];\n  });\n  return { v, isos, T };\n}\n\n// Type 1, B + C = 180: AB and DC parallel. B = (0, 0), C = (1, 0), the\n// sides AB and DC leave at angle be with lengths b and d, and E sits over\n// AD at base angles chosen to keep every corner under 165 degrees. The\n// shape runs round a loop as w goes from 0 to 2 pi; every member tiles by\n// the copy turned half round about the midpoint of BC, the two making a\n// hexagon D E A D' E' A' with opposite sides parallel, which tiles by\n// translation.\nfunction type1(w) {\n  const be = (90 + 20 * sin(w)) * D2R, b = 1 + 0.3 * sin(2 * w + 1), d = 1 + 0.3 * sin(w + 2);\n  const u = [cos(be), sin(be)];\n  const A = [b * u[0], b * u[1]], B = [0, 0], C = [1, 0], D = [1 + d * u[0], d * u[1]];\n  const corner = (o, p, q) => {\n    const x = [p[0] - o[0], p[1] - o[1]], y = [q[0] - o[0], q[1] - o[1]];\n    return Math.acos((x[0] * y[0] + x[1] * y[1]) / hypot(x[0], x[1]) / hypot(y[0], y[1]));\n  };\n  const gA = (165 * D2R - corner(A, B, D)) * (0.5 + 0.12 * sin(3 * w));\n  const gD = (165 * D2R - corner(D, A, C)) * (0.5 - 0.12 * sin(3 * w + 0.7));\n  const dir = atan2(D[1] - A[1], D[0] - A[0]);\n  const r1 = [cos(dir + gA), sin(dir + gA)], r2 = [cos(dir + PI - gD), sin(dir + PI - gD)];\n  const t = ((D[0] - A[0]) * r2[1] - (D[1] - A[1]) * r2[0]) / (r1[0] * r2[1] - r1[1] * r2[0]);\n  const E = [A[0] + t * r1[0], A[1] + t * r1[1]];\n  const v = [A, B, C, D, E];\n  const r = rot(PI, [0.5, 0]), E2 = ap(r, E), A2 = ap(r, A);\n  return { v, isos: [[1, 0, 1, 0, 0], r], T: [[D[0] - E2[0], D[1] - E2[1]], [E[0] - A2[0], E[1] - A2[1]]] };\n}\n\n// Type 4, b = c, d = e, B = D = 90: the Cairo pentagon (angles 120, 90,\n// 120, 90, 120, four sides 1 and a = sqrt 3 - 1). Quarter turns about B and\n// about D generate it: four tiles round B, and R_D R_B^-1 a translation.\nfunction type4() {\n  const v = pentagon([120, 90, 120, 90, 120], (x, y) => [y, 1, 1, x, x]), B = v[1], D = v[3];\n  const dx = D[0] - B[0], dy = D[1] - B[1];\n  return { v, isos: [0, 1, 2, 3].map((k) => rot((k * PI) / 2, B)), T: [[dx + dy, dy - dx], [dx - dy, dx + dy]] };\n}\n\n// Type 5, a = b, d = e, A = 60, D = 120 (here B = 140, C = 100, E = 120):\n// sixth turns about A, third turns about D.\nfunction type5() {\n  const v = pentagon([60, 140, 100, 120, 120], (x, y) => [1, 1, y, x, x]), D = v[3];\n  const c = cos((2 * PI) / 3), s = sin((2 * PI) / 3);\n  const T1 = [D[0] - (c * D[0] - s * D[1]), D[1] - (s * D[0] + c * D[1])];\n  const c6 = cos(PI / 3), s6 = sin(PI / 3);\n  return { v, isos: [0, 1, 2, 3, 4, 5].map((k) => rot((k * PI) / 3, [0, 0])), T: [T1, [c6 * T1[0] - s6 * T1[1], s6 * T1[0] + c6 * T1[1]]] };\n}\n\n// Type 13, d = 2a = 2e, B = E = 90, 2A + D = 360 (here A = C = 112, D =\n// 136): eight tiles a period, in two orbits of the symmetry group.\nfunction type13() {\n  const v = pentagon([112, 90, 112, 136, 90], (x, y) => [1, x, y, 2, 1]);\n  return glued(v, [[0, 2, 3, 3, 2, 1], [0, 3, 4, 2, 3, -1], [0, 0, 4, 3, 4, 1], [0, 1, 2, 1, 2, -1], [1, 0, 4, 3, 4, 1], [2, 3, 4, 0, 4, -1], [3, 1, 2, 1, 2, -1]], [[0, 0, 1, 0, 1, -1, 2], [4, 3, 4, 0, 4, -1, 7]]);\n}\n\n// Type 15, a = c = e = 1, b = 2, d = sqrt 2 / (sqrt 3 - 1), A = 150, B = 60,\n// C = 135, D = 105, E = 90: twelve tiles a period, in three orbits of the\n// symmetry group.\nfunction type15() {\n  // The walk is solved for d and e; e comes out 1.\n  const v = pentagon([150, 60, 135, 105, 90], (x, y) => [1, 2, 1, x, y]);\n  return glued(v, [[0, 0, 4, 1, 2, 1], [0, 3, 4, 1, 2, -1], [0, 1, 2, 2, 1, 1], [1, 0, 1, 3, 4, -1], [1, 0, 4, 3, 4, 1], [3, 3, 4, 1, 2, -1], [3, 0, 4, 1, 2, 1], [4, 1, 2, 0, 4, -1], [6, 3, 4, 0, 4, -1], [7, 0, 4, 3, 4, 1], [8, 2, 3, 3, 2, -1]], [[0, 0, 1, 0, 1, -1, 2], [9, 1, 2, 0, 4, -1, 11]]);\n}\n\nconst GRID = 20;\n\n// Lookup for one tiling: every tile of a period and its translates by up\n// to two periods, as five edge lines each, filed in a GRID x GRID grid over\n// the period cell in lattice coordinates. A point is found by reducing it\n// into the cell and testing the few tiles filed in its grid square.\nfunction prepare(t) {\n  const { v, isos, T } = t;\n  const det = T[0][0] * T[1][1] - T[0][1] * T[1][0];\n  let area = 0;\n  for (let k = 0; k \u003c 5; k++) area += v[k][0] * v[(k + 1) % 5][1] - v[(k + 1) % 5][0] * v[k][1];\n  // Aspect: the tile's turn, as a fraction of a whole turn, and its hand.\n  const asp = isos.map((g) => [((atan2(g[1], g[0]) / (2 * PI) + 1.0001) % 1), g[2]]);\n  const lines = [], cells = [];\n  for (let g = 0; g \u003c GRID * GRID; g++) cells.push([]);\n  isos.forEach((g, k) => {\n    let p = v.map((q) => ap(g, q));\n    if (g[2] \u003c 0) p = p.reverse();\n    for (let i = -2; i \u003c= 2; i++)\n      for (let j = -2; j \u003c= 2; j++) {\n        const ox = i * T[0][0] + j * T[1][0], oy = i * T[0][1] + j * T[1][1];\n        const q = p.map((r) => [r[0] + ox, r[1] + oy]);\n        let a0 = 9, a1 = -9, b0 = 9, b1 = -9, cx = 0, cy = 0;\n        for (const [x, y] of q) {\n          const a = (x * T[1][1] - y * T[1][0]) / det, b = (T[0][0] * y - T[0][1] * x) / det;\n          (a0 = min(a0, a)), (a1 = max(a1, a)), (b0 = min(b0, b)), (b1 = max(b1, b)), (cx += x / 5), (cy += y / 5);\n        }\n        if (a1 \u003c 0 || a0 > 1 || b1 \u003c 0 || b0 > 1) continue;\n        const id = lines.length;\n        const L = [k, cx, cy];\n        for (let e = 0; e \u003c 5; e++) {\n          const P = q[e], Q = q[(e + 1) % 5], len = hypot(Q[0] - P[0], Q[1] - P[1]);\n          // inside when nx x + ny y >= c, the value the distance to the edge\n          const nx = -(Q[1] - P[1]) / len, ny = (Q[0] - P[0]) / len;\n          L.push(nx, ny, nx * P[0] + ny * P[1]);\n        }\n        lines.push(L);\n        for (let ga = max(0, floor(a0 * GRID)); ga \u003c= min(GRID - 1, floor(a1 * GRID)); ga++)\n          for (let gb = max(0, floor(b0 * GRID)); gb \u003c= min(GRID - 1, floor(b1 * GRID)); gb++) cells[ga * GRID + gb].push(id);\n      }\n  });\n  return { T, det, area: area / 2, asp, lines, cells, n: isos.length };\n}\n\nconst BUILD = [null, type4, type5, type13, type15];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, size: 12, type: 0, prev: -1, wipe: 1, w: 0,\n    // Where the middle of the panel sits in each tiling, in its own lattice\n    // coordinates, so the changing shapes of type 1 stay put round it.\n    pan: BUILD.map(() => [0.3, 0.6]),\n    tilings: BUILD.map((f) => (f ? prepare(f()) : null)),\n    rgb: new Float32Array(3), hit: new Float64Array(4),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.size = 12 + 16 * cl(kv[3], 0, 1);\n  const ty = round(cl(kv[2], 0, 4));\n  if (ty !== s.type) (s.prev = s.type), (s.type = ty), (s.wipe = 0);\n  s.wipe = min(1, s.wipe + d * 0.9);\n  // Type 1 runs round its loop of shapes once in 32 / Speed seconds.\n  s.w += d * s.speed * ((2 * PI) / 32);\n  s.tilings[0] = prepare(type1(s.w));\n  // The tiles drift up and to the left at 1.5 LEDs a second per unit of\n  // Speed.\n  s.tilings.forEach((t, i) => {\n    const sc = s.size / sqrt(t.area), vx = (d * s.speed * 1.2) / sc, vy = (-d * s.speed * 0.9) / sc, P = s.pan[i], T = t.T;\n    P[0] = (P[0] + (vx * T[1][1] - vy * T[1][0]) / t.det + 1) % 1;\n    P[1] = (P[1] + (T[0][0] * vy - T[0][1] * vx) / t.det + 1) % 1;\n  });\n}\n\n// The tile under tiling point (x, y): its period index and aspect, the\n// distance to its nearest edge, and its centre.\nfunction locate(t, x, y, out) {\n  const { T, det, cells, lines } = t;\n  const a = (x * T[1][1] - y * T[1][0]) / det, b = (T[0][0] * y - T[0][1] * x) / det;\n  const ia = floor(a), ib = floor(b);\n  const rx = x - ia * T[0][0] - ib * T[1][0], ry = y - ia * T[0][1] - ib * T[1][1];\n  const list = cells[min(GRID - 1, floor((a - ia) * GRID)) * GRID + min(GRID - 1, floor((b - ib) * GRID))];\n  let best = -1, bd = -1e9;\n  for (let n = 0; n \u003c list.length; n++) {\n    const L = lines[list[n]];\n    let dm = 1e9;\n    for (let e = 3; e \u003c 18; e += 3) dm = min(dm, L[e] * rx + L[e + 1] * ry - L[e + 2]);\n    if (dm > bd) (bd = dm), (best = list[n]);\n  }\n  const L = lines[best];\n  out[0] = L[0];\n  out[1] = bd;\n  out[2] = L[1] + ia * T[0][0] + ib * T[1][0];\n  out[3] = L[2] + ia * T[0][1] + ib * T[1][1];\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { rgb, hit } = s;\n  const cur = s.tilings[s.type], old = s.prev >= 0 && s.wipe \u003c 1 ? s.tilings[s.prev] : null;\n  // The front of a change of type runs down the panel on a slant; a tile of\n  // the new tiling shows once its centre is above the front.\n  const front = -20 + s.wipe * 190;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let t = cur, ti = s.type;\n      for (let pass = 0; pass \u003c 2; pass++) {\n        // Each tiling is scaled so a tile covers size^2 LEDs.\n        const sc = s.size / sqrt(t.area), P = s.pan[ti], T = t.T;\n        const ox = P[0] * T[0][0] + P[1] * T[1][0], oy = P[0] * T[0][1] + P[1] * T[1][1];\n        locate(t, (x - 31.5) / sc + ox, (63.5 - y) / sc + oy, hit);\n        if (old && t === cur) {\n          const cx = 31.5 + (hit[2] - ox) * sc, cy = 63.5 - (hit[3] - oy) * sc;\n          if (cy + 0.35 * cx > front) {\n            (t = old), (ti = s.prev);\n            continue;\n          }\n        }\n        const [turn, hand] = t.asp[hit[0]];\n        hsv(0.47 + s.hue + 0.5 * turn + (hand > 0 ? 0 : 0.05), hand > 0 ? 0.62 : 0.36, hand > 0 ? 0.95 : 0.85, rgb);\n        // Grout: the LED darkens within about half an LED of an edge.\n        const g = cl((hit[1] * sc - 0.3) / 0.7, 0, 1);\n        const k = g * (0.8 + 0.2 * cl(hit[1] * sc / 4, 0, 1));\n        display.setPixel(x, y, (255 * rgb[0] * k) | 0, (255 * rgb[1] * k) | 0, (255 * rgb[2] * k) | 0);\n        break;\n      }\n    }\n}\n","sinai-walk":"// ===== Patternflow pattern =====\n// Title:   Sinai's Walk\n// Family:  noise\n// Idea:    A random potential runs down the panel as a jagged ridge, one site to a row and each site with its own coin for a step up or down; 3,000 walkers start on one row of this one landscape and run on a clock of log t, so a pool fills every valley to depth log t and rises steadily while the walkers glow in the pool that holds them, stay there until it spills over a ridge into a deeper valley, then pour over together, until they gather in the deepest valley on the panel and a fresh landscape is drawn.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random walk in a random environment (Fred Solomon, 1975), Sinai's walk and its (log t)^2 law (Yakov Sinai, 1982), the walkers' localization in one valley (Andrei Golosov, 1984), the transient walk X_t ~ t^kappa (Harry Kesten, M. V. Kozlov and Frank Spitzer, 1975), the valleys of depth h as h-extrema (Jacques Neveu and Jim Pitman, 1989), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bias=0..1, Disorder=1.2..2.4\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 each valley's ground has its own shade between azure and violet, the valley holding the walkers a fifth brighter, the pools are cyan with a bright surface line and the walkers pale gold; at 0.5 the ground runs rose to magenta, the pools are pink and the walkers pale blue. The wheel skips orange to lime, which reads brown on the dim ground.\n// Knob 2: Speed. How fast log t runs: 1 a second at 2, so a walker has taken 19 steps after 3 seconds, 2,980 after 8 and 162,750 after 12; 0.1 a second at 0.2 and 1.5 at 3. A run ends 4.5 units of log t after the walkers' valley first reaches the deepest point of the panel, at log t 9.7 for the median landscape at the opening Disorder, then holds 1.8 seconds.\n// Knob 3: Bias. 0 is Sinai's recurrent walk: log rho = log((1 - omega)/omega) has mean 0, the walkers start on row 64 and the potential wanders with no slope. Above 0 the mean of log rho is -Bias x Disorder^2 / 2, which makes E[rho^kappa] = 1 at kappa = Bias exactly; the ridge leans, the start moves up to row 4 by Bias 0.25, and the walkers go down the panel a trap at a time as Kesten, Kozlov and Spitzer's X_t ~ t^kappa. At Bias 0.5 and Disorder 1.2 the median walker on an open line is 100 sites out after 10,000 steps and 4,420 after 10 million.\n// Knob 4: Disorder. sigma, the spread of log rho at each site, 1.2 to 2.4. The ridge draws V at 2.6 columns a unit, narrower when it would pass column 52. At 1.2 the median landscape spans 19 units and the walkers' valley reaches its deepest point at log t 5.2; at 2.4 it spans 38 and reaches it at 10.3, and one landscape in seven has its walkers' valley still short of the deepest point when the run stops at the cap, log t 19 (180 million steps).\n\nconst W = 64, H = 128, L = 128, NW = 3000;\nconst { floor, ceil, min, max, abs, sqrt, exp, log, cos, sin, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// log t a second at Speed 2, the longest run, and the hold and fade after it.\nconst RATE = 1, H_CAP = 19, HOLD = 1.8, FADE = 0.7;\n// The ridge puts the lowest V at column X0 and draws V at K_PX columns a\n// unit, so a pool rises K_PX columns for each unit of log t; a landscape\n// that would run past column X0 + SPAN is drawn narrower to fit.\nconst X0 = 2, SPAN = 50, K_PX = 2.6;\n// Base hues on the knob's wheel: ground, pools, walkers.\nconst HUE_GROUND = 0.46, HUE_POOL = 0.3, HUE_WALK = 0.13;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n// The wheel skips orange through yellow to lime, which reads brown and olive when dim.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nfunction normals(n) {\n  const z = new Float64Array(n);\n  for (let i = 0; i \u003c n; i += 2) {\n    const r = sqrt(-2 * log(1 - Math.random())), a = 2 * PI * Math.random();\n    z[i] = r * cos(a);\n    if (i + 1 \u003c n) z[i + 1] = r * sin(a);\n  }\n  return z;\n}\n\n// The environment. Site x sends a walker down the panel, to x + 1, with\n// chance omega_x and up with 1 - omega_x. log rho_x = log((1 - omega_x) /\n// omega_x) = sigma Z_x - mu with Z_x standard normal, so E[rho^k] =\n// exp(-mu k + sigma^2 k^2 / 2), which is 1 at k = 2 mu / sigma^2: mu =\n// kappa sigma^2 / 2 puts the Kesten-Kozlov-Spitzer exponent on the knob.\n// V(x) = sum of log rho up to x is the potential; the walk's resting\n// measure is about exp(-V), so walkers gather where V is low.\nfunction environment(Z, sigma, kappa) {\n  const mu = (kappa * sigma * sigma) / 2, n = Z.length;\n  const omega = new Float64Array(n), V = new Float64Array(n);\n  for (let x = 0; x \u003c n; x++) {\n    const lr = sigma * Z[x] - mu;\n    omega[x] = 1 / (1 + exp(lr));\n    if (x > 0) V[x] = V[x - 1] + lr;\n  }\n  return { omega, V };\n}\n\n// One step of the walk as an L x L matrix; the end rows hold the walker\n// where a step would leave the panel.\nfunction transition(omega) {\n  const P = new Float64Array(L * L);\n  for (let x = 0; x \u003c L; x++) {\n    P[x * L + min(L - 1, x + 1)] += omega[x];\n    P[x * L + max(0, x - 1)] += 1 - omega[x];\n  }\n  return P;\n}\n// P squared, inside the band where P can be non-zero. Products under 1e-13\n// are dropped: a row loses less than 1e-10 of its weight.\nfunction square(P, bw) {\n  const R = new Float64Array(L * L);\n  for (let i = 0; i \u003c L; i++) {\n    const oi = i * L;\n    for (let m = max(0, i - bw), m1 = min(L - 1, i + bw); m \u003c= m1; m++) {\n      const p = P[oi + m];\n      if (p \u003c 1e-13) continue;\n      const om = m * L;\n      for (let j = max(0, m - bw), j1 = min(L - 1, m + bw); j \u003c= j1; j++) R[oi + j] += p * P[om + j];\n    }\n  }\n  return R;\n}\nfunction cdf(P) {\n  const C = new Float32Array(L * L);\n  for (let i = 0, o = 0; i \u003c L; i++) {\n    let s = 0;\n    for (let j = 0; j \u003c L; j++, o++) C[o] = s += P[o];\n  }\n  return C;\n}\n\n// The bottoms of the valleys of depth h: b is one when, walking away from\n// it either way, V climbs h above V(b), or meets a wall, before it dips\n// below V(b). These are Neveu and Pitman's h-minima; between two of them V\n// rises at least h above both.\nfunction bottoms(V, h, out) {\n  let n = 0;\n  for (let b = 0; b \u003c L; b++) {\n    const vb = V[b];\n    if ((b > 0 && V[b - 1] \u003c vb) || (b \u003c L - 1 && V[b + 1] \u003c vb)) continue;\n    let ok = true;\n    for (let x = b - 1; x >= 0; x--) {\n      if (V[x] \u003c vb) { ok = false; break; }\n      if (V[x] >= vb + h) break;\n    }\n    if (ok)\n      for (let x = b + 1; x \u003c L; x++) {\n        if (V[x] \u003c vb) { ok = false; break; }\n        if (V[x] >= vb + h) break;\n      }\n    if (ok) out[n++] = b;\n  }\n  return n;\n}\n// The bottom of the valley of depth h that holds site s: Sinai's b(log t),\n// where his theorem puts the walker at time t. The valley's walls are the\n// highest points between its bottom and the next bottoms either side.\nfunction valleyOf(V, h, s, buf) {\n  const n = bottoms(V, h, buf);\n  for (let i = 0; i \u003c n; i++) {\n    let wall = L;\n    if (i \u003c n - 1) {\n      wall = buf[i];\n      for (let x = buf[i]; x \u003c= buf[i + 1]; x++) if (V[x] > V[wall]) wall = x;\n    }\n    if (s \u003c= wall) return buf[i];\n  }\n  return buf[n - 1];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, kappa: -1, sigma: -1, Z: null, buf: new Int16Array(L), buf2: new Int16Array(L),\n    pos: new Int16Array(NW), u: new Float32Array(NW),\n    rgb: new Float32Array(W * H * 3), pool: new Float32Array(L), mine: new Uint8Array(L), owner: new Int16Array(L), c: [0, 0, 0],\n    age: 0,\n  };\n  for (let j = 0; j \u003c NW; j++) params.s.u[j] = Math.random();\n}\n\nfunction build(S, kappa, sigma, fresh) {\n  if (fresh || !S.Z) S.Z = normals(L);\n  S.kappa = kappa;\n  S.sigma = sigma;\n  const { omega, V } = environment(S.Z, sigma, kappa);\n  S.V = V;\n  let lo = 0, hi = 0;\n  for (let x = 1; x \u003c L; x++) {\n    if (V[x] \u003c V[lo]) lo = x;\n    if (V[x] > V[hi]) hi = x;\n  }\n  S.vmin = V[lo];\n  S.scale = min(K_PX, SPAN / max(1e-6, V[hi] - V[lo]));\n  S.P = transition(omega);\n  S.bw = 1;\n  S.C = [cdf(S.P)];\n  // Unbiased, the walkers start on the middle row; with a bias, near the top.\n  S.s0 = round(64 - 60 * min(1, 4 * kappa));\n  S.pos.fill(S.s0);\n  // The depth at which the start's valley first reaches the deepest point\n  // of the panel. The walkers cross later than that: an escape over a\n  // barrier of height H takes e^H times a factor from the widths of the\n  // valley and the barrier, and half of them are across 3.2 units of log t\n  // after it in the median landscape at sigma 1.2, 1.9 at 2.4. The run\n  // goes on 4.5 units, a factor of 90 in time.\n  let a = 0, b = V[hi] - V[lo] + 1;\n  for (let k = 0; k \u003c 24; k++) {\n    const m = (a + b) / 2;\n    if (valleyOf(V, m, S.s0, S.buf) === lo) b = m;\n    else a = m;\n  }\n  S.hEnd = min(H_CAP, max(5, b + 4.5));\n  S.h = 0;\n  S.t = 0;\n  S.phase = 0;\n  S.pt = 0;\n  S.age = 0;\n}\n\n// Every walker takes 2^k steps at once, drawn from row pos of P^(2^k).\nfunction jump(S, k) {\n  const C = S.C[k], pos = S.pos;\n  for (let j = 0; j \u003c NW; j++) {\n    const o = pos[j] * L, u = Math.random() * C[o + L - 1];\n    let lo = 0, hi = L - 1;\n    while (lo \u003c hi) {\n      const mid = (lo + hi) >> 1;\n      if (C[o + mid] > u) hi = mid;\n      else lo = mid + 1;\n    }\n    pos[j] = lo;\n  }\n}\n\n// Bring the walkers to time floor(e^h) - 1 in jumps of powers of two,\n// squaring the matrix once more when a longer jump is due.\nfunction advance(S) {\n  let rem = floor(exp(S.h) - 1) - S.t, squared = 0;\n  for (let n = 0; n \u003c 6 && rem >= 1; n++) {\n    let k = floor(Math.log2(rem));\n    while (k > S.C.length - 1 && S.C.length \u003c 31 && squared \u003c (S.bw \u003c 32 ? 4 : 1)) {\n      S.P = square(S.P, S.bw);\n      S.bw = min(L, 2 * S.bw);\n      S.C.push(cdf(S.P));\n      squared++;\n    }\n    k = min(k, S.C.length - 1);\n    jump(S, k);\n    S.t += 2 ** k;\n    rem -= 2 ** k;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 1.2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  const speed = cl(kv[1], 0.2, 3), kappa = cl(kv[2], 0, 1), sigma = cl(kv[3], 1.2, 2.4);\n  if (abs(kappa - S.kappa) > 1e-4 || abs(sigma - S.sigma) > 1e-4) build(S, kappa, sigma, false);\n  const g = (d * speed) / 2;\n  S.age += g;\n  if (S.phase === 0) {\n    S.h = min(S.hEnd, S.h + g * RATE);\n    advance(S);\n    if (S.h >= S.hEnd) (S.phase = 1), (S.pt = 0);\n  } else {\n    // Settled: the pools stop rising, and each frame every walker takes\n    // the longest jump made so far, so they keep moving inside their valley.\n    S.pt += g;\n    jump(S, S.C.length - 1);\n    if (S.phase === 1 && S.pt >= HOLD) (S.phase = 2), (S.pt = 0);\n    else if (S.phase === 2 && S.pt >= FADE) build(S, kappa, sigma, true);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.V) return;\n  const V = S.V, rgb = S.rgb, pool = S.pool, mine = S.mine, buf = S.buf;\n  const px = (v) => X0 + (v - S.vmin) * S.scale;\n  const fade = S.phase === 2 ? 1 - S.pt / FADE : min(1, S.age / 0.5);\n  rgb.fill(0);\n  // The pools: each valley of depth h filled from its bottom to V(bottom)\n  // + h, spreading along the rows while V stays under that level.\n  mine.fill(0);\n  const n = bottoms(V, S.h, buf), b0 = valleyOf(V, S.h, S.s0, S.buf2);\n  // Each valley's ground takes a tint of its own from its bottom, from the\n  // bottom to the top of its walls, so as log t grows the valleys merge\n  // and the deeper one's tint spreads over the shallower.\n  const owner = S.owner;\n  for (let i = 0, from = 0; i \u003c n; i++) {\n    const b = buf[i], lv = V[b] + S.h;\n    let lo = b, hi = b, wall = L - 1;\n    while (lo > 0 && V[lo - 1] \u003c= lv) lo--;\n    while (hi \u003c L - 1 && V[hi + 1] \u003c= lv) hi++;\n    for (let y = lo; y \u003c= hi; y++) (pool[y] = lv), (mine[y] = b === b0 ? 2 : 1);\n    if (i \u003c n - 1) {\n      wall = b;\n      for (let x = b; x \u003c= buf[i + 1]; x++) if (V[x] > V[wall]) wall = x;\n    }\n    for (let y = from; y \u003c= wall; y++) owner[y] = b;\n    from = wall + 1;\n  }\n  const ground = S.c;\n  const ridge = hsv(wheel(HUE_GROUND + S.hue - 0.04), 0.3, 1, [0, 0, 0]);\n  const water = hsv(wheel(HUE_POOL + S.hue), 0.85, 1, [0, 0, 0]);\n  const walk = hsv(HUE_WALK + S.hue, 0.5, 1, [0, 0, 0]);\n  const add = (x, y, col, a) => {\n    if (x \u003c 0 || x >= W || a \u003c= 0) return;\n    const o = (y * W + x) * 3;\n    rgb[o] += col[0] * a;\n    rgb[o + 1] += col[1] * a;\n    rgb[o + 2] += col[2] * a;\n  };\n  for (let y = 0; y \u003c H; y++) {\n    const r = px(V[y]), ri = floor(r), fr = r - ri;\n    // Ground: lit most near the ridge, fading in to a floor that still\n    // reads. The valley's tint folds back at the ends of the wheel rather\n    // than wrapping round, so no valley jumps from rose to lime beside its\n    // neighbour.\n    const b = owner[y], base = HUE_GROUND + S.hue;\n    let tp = base - floor(base) + 0.24 * (((b * 0.618034) % 1) - 0.5);\n    tp = tp \u003c 0 ? -tp : tp > 0.999 ? 1.998 - tp : tp;\n    hsv(wheel(tp), 0.75, b === b0 ? 1.2 : 1, ground);\n    for (let x = 0; x \u003c= ri && x \u003c W; x++) {\n      const a = (0.15 + 0.3 * exp(-(r - x - 0.5) / 6)) * (x === ri ? fr : 1);\n      add(x, y, ground, a);\n    }\n    // The ridge, joined to the row above so the profile stays one line.\n    const ra = y > 0 ? px(V[y - 1]) : r;\n    for (let x = floor(min(r, ra)); x \u003c= floor(max(r, ra)); x++) add(x, y, ridge, x === ri ? 0.85 : 0.55);\n    if (mine[y]) {\n      const p = min(W - 0.5, px(pool[y])), m = mine[y] === 2;\n      for (let x = ri + 1; x \u003c p; x++) add(x, y, water, m ? 0.3 : 0.17);\n      add(floor(p), y, water, m ? 0.75 : 0.4);\n    }\n  }\n  // The walkers: each one a dot in its row, at its own fixed share of the\n  // way across the pool and dimmer the further out, so a crowded row glows\n  // across its whole width. A walker outside every pool, still on its way\n  // out of a valley Sinai's clock has already drained, gets five columns.\n  for (let j = 0; j \u003c NW; j++) {\n    const y = S.pos[j], r = px(V[y]);\n    const w = mine[y] ? max(2, min(W - 1, px(pool[y])) - r) : 5;\n    add(floor(r + 1 + S.u[j] * w), y, walk, 0.14 - 0.07 * S.u[j]);\n  }\n  // Sinai's b(log t), white at the right edge; the start row, dim.\n  for (let x = 60; x \u003c W; x++) add(x, S.s0, ridge, 0.3);\n  for (let x = 58; x \u003c W; x++) add(x, b0, [1, 1, 1], 0.9);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, (255 * cl(rgb[o] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 1] * fade, 0, 1)) | 0, (255 * cl(rgb[o + 2] * fade, 0, 1)) | 0);\n}\n","solenoid":"// ===== Patternflow pattern =====\n// Title:   Solenoid\n// Family:  fractal\n// Idea:    A solid torus stands on the panel as a dim glass ring and turns about its upright axis every 12 seconds, and inside it runs one closed strand that the Smale-Williams map has wound 16 times round, two bundles of eight that each split in two and again down to pairs, so any slice across the tube cuts it in a Cantor set; each strand wears a dark collar that cuts the strands passing behind it.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Smale-Williams solenoid (Stephen Smale, 1967; Robert F. Williams, 1967), the dyadic solenoid (Leopold Vietoris, 1927; David van Dantzig, 1930), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Level=-3..3, Lambda=0..1\n//\n// Knob 1: Hue. Turns the strand colours round the wheel together. At 0 they run from green through cyan to violet-blue: the colour follows the turning of the first term e^(is/2)/2, so where the two bundles of f(T) are green and violet, half a circuit on they are both cyan, and a whole circuit on they have swapped, because the two bundles are one tube going round twice. At 0.5 the same runs from magenta through red to yellow. The body of T stays slate.\n// Knob 2: Speed. The ring turns once in 24 / Speed seconds: 12 s at 2, so it goes from face-on (two tall arcs of cable at the sides, black in the hole) to edge-on (one column of cable down the middle) in 3 s. 120 s at 0.2, 8 s at 3.\n// Knob 3: Level. The level k is 4 plus the knob, 1 to 7: f^k(T) is one tube wound 2^k times round, so 2 strands at -3 (a double helix), 16 at 0 and 128 at 3. Between whole numbers the newest term of z grows in, so turning the knob up splits every strand in two inside its own tube; the picture follows the knob within a second.\n// Knob 4: Lambda. The contraction of f(th, z) = (2 th, lambda z + e^(i th)/2), 0.49 at 0 down to 0.22 at 1 (0.474 at the opening). The Cantor set in a slice has dimension log 2 / log(1/lambda), 0.97 down to 0.46, and the two halves of a finest bundle sit lambda^(k-1) R apart: at level 4, 1.6 LEDs at the opening and 0.16 at 0.22, where each pair fuses into one line.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, cos, sin, sqrt, PI, round, abs } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The solid torus T = S1 x D2. Its centre line is a stadium in the plane\n// of the panel: straight sides of half length HS joined by half circles of\n// radius A, run at constant speed. The disc has radius R.\nconst A = 24, HS = 30, R = 15;\nconst PER = 4 * HS + TAU * A;\n// The disc coordinate z is read in a frame that turns TWIST times round\n// the tube per circuit: another way of putting S1 x D2 into space, with\n// the same map in (th, z). In space it winds the strands round the tube\n// like a cable, so they cross the panel slanted instead of running in\n// parallel lines up its sides.\n//\n// The map is f(th, z) = (2 th, lambda z + e^(i th)/2). It sends the unit\n// disc bundle into itself (|f| \u003c= lambda + 1/2 \u003c 1), and the slice of f(T)\n// over 2 th is two discs of radius lambda round +-e^(i th)/2, apart while\n// lambda \u003c 1/2, so f is one to one. f^k(T) is a tube of radius lambda^k\n// round the curve z(s) = 1/2 sum_{m=1..k} lambda^(m-1) e^(i s / 2^m) over\n// th = s mod 2 pi, which closes after s = 2 pi 2^k: 2^k turns.\nconst TWIST = 10;\n// Steps of the circle per turn of a strand (under 0.9 LED a step), and the\n// dark collar: a strand blacks out what lies more than COLLAR LEDs behind\n// it, one LED round, so a strand passing in front reads as in front.\nconst NT = 1000, COLLAR = 3;\n// Brightness of the body of T, the glass the strands lie in. Over black\n// the collars would vanish; over the body every strand shows its edge.\nconst BODY = 0.55;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Centre point and outward normal at torus angle th.\nfunction centre(th, o, out) {\n  let u = (th / TAU) * PER;\n  if (u \u003c 2 * HS) return (out[o] = A), (out[o + 1] = -HS + u), (out[o + 2] = 1), (out[o + 3] = 0);\n  u -= 2 * HS;\n  if (u \u003c PI * A) {\n    const al = u / A;\n    return (out[o] = A * cos(al)), (out[o + 1] = HS + A * sin(al)), (out[o + 2] = cos(al)), (out[o + 3] = sin(al));\n  }\n  u -= PI * A;\n  if (u \u003c 2 * HS) return (out[o] = -A), (out[o + 1] = HS - u), (out[o + 2] = -1), (out[o + 3] = 0);\n  u -= 2 * HS;\n  const al = PI + u / A;\n  return (out[o] = A * cos(al)), (out[o + 1] = -HS + A * sin(al)), (out[o + 2] = cos(al)), (out[o + 3] = sin(al));\n}\n\nexport function setup(params) {\n  // Centre line, normal and the turning frame, per step of th.\n  const C = new Float64Array(NT * 6);\n  for (let j = 0; j \u003c NT; j++) {\n    centre((TAU * j) / NT, j * 6, C);\n    C[j * 6 + 4] = cos((TWIST * TAU * j) / NT);\n    C[j * 6 + 5] = sin((TWIST * TAU * j) / NT);\n  }\n  params.s = {\n    C, hue: 0, speed: 2, level: 4, shown: 4, lam: 0.47, phi: -PI / 3,\n    zb: new Float32Array(N), hb: new Float32Array(N), vb: new Float32Array(N), rgb: new Float32Array(3),\n    er: new Float64Array(10), ei: new Float64Array(10), sr: new Float64Array(10), si: new Float64Array(10),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.level = 4 + cl(kv[2], -3, 3);\n  s.lam = 0.49 - 0.27 * cl(kv[3], 0, 1);\n  // The level eases to the knob, so strands split in two or merge. The\n  // view opens 60 degrees short of face-on and turns about the upright.\n  s.shown += (s.level - s.shown) * min(1, d * 3);\n  s.phi += d * s.speed * (TAU / 24);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { C, zb, hb, vb, rgb, er, ei, sr, si } = s;\n  zb.fill(-1e9);\n  // Per LED: the depth that holds it, and what it shows: a strand's hue,\n  // or -1 a collar, -2 the body, -3 nothing.\n  hb.fill(-3);\n  const L = s.shown, k = floor(L + 1e-6), w = L - k, K = w > 1e-3 ? k + 1 : k, M = 1 \u003c\u003c K, lam = s.lam;\n  const cp = cos(s.phi), sp = sin(s.phi), F = 220, Dm = A + R, hue0 = 0.5 + s.hue;\n\n  // The body of T: every LED within R of the projected centre line, since\n  // the shadow of a tube is the union of the shadows of its spheres.\n  for (let j = 0; j \u003c NT; j += 15) {\n    const o = j * 6, x = C[o], y = C[o + 1];\n    const Z = -x * sp, f = F / (F - Z), qx = 31.5 + x * cp * f, qy = 63.5 - y * f, rr = R * f;\n    const y0 = max(0, ceil(qy - rr)), y1 = min(H - 1, floor(qy + rr));\n    for (let yy = y0; yy \u003c= y1; yy++) {\n      const hw = sqrt(max(0, rr * rr - (yy - qy) * (yy - qy)));\n      const x0 = max(0, ceil(qx - hw)), x1 = min(W - 1, floor(qx + hw));\n      for (let xx = x0, p = yy * W + x0; xx \u003c= x1; xx++, p++) (zb[p] = -1e8), (hb[p] = -2);\n    }\n  }\n\n  // z(s) = 1/2 sum_{m=1..K} lam^(m-1) e^(i s / 2^m); the last term grows in\n  // while the level rises from K - 1 to K.\n  const amp = [];\n  for (let m = 1, a = 0.5; m \u003c= K; m++, a *= lam) amp.push(m === K && w > 1e-3 ? a * w : a);\n  // From 64 strands on, every second or fourth step: the strands of a\n  // bundle lie closer than an LED there and fill each other's gaps.\n  const step = K > 5 ? 1 \u003c\u003c (K - 5) : 1, ds = (TAU * step) / NT;\n  for (let m = 0; m \u003c K; m++) (sr[m] = cos(ds / (2 \u003c\u003c m))), (si[m] = sin(ds / (2 \u003c\u003c m)));\n\n  const write = (p, Z, h, v) => {\n    const zh = Z - COLLAR, px = p % W;\n    if (px > 0 && zh > zb[p - 1]) (zb[p - 1] = zh), (hb[p - 1] = -1);\n    if (px \u003c W - 1 && zh > zb[p + 1]) (zb[p + 1] = zh), (hb[p + 1] = -1);\n    if (p >= W && zh > zb[p - W]) (zb[p - W] = zh), (hb[p - W] = -1);\n    if (p \u003c N - W && zh > zb[p + W]) (zb[p + W] = zh), (hb[p + W] = -1);\n    if (Z \u003c= zb[p]) return;\n    zb[p] = Z;\n    hb[p] = h;\n    vb[p] = v;\n  };\n\n  // The strand of level K is one closed curve, s from 0 to 2 pi 2^K, over\n  // the angle th = s mod 2 pi. It is plotted as a thin 8-connected line: a\n  // pixel that only turns the corner between two diagonal neighbours is\n  // dropped.\n  let ap = -1, aZ = 0, ah = 0, av = 0, bp = -1, bZ = 0, bh = 0, bv = 0;\n  const total = NT * M;\n  for (let i = 0; i \u003c total; i += step) {\n    const j = i % NT;\n    if (j === 0) {\n      // Exact phases at the start of every turn, so rounding never builds up.\n      const sv = (TAU * i) / NT;\n      for (let m = 0; m \u003c K; m++) (er[m] = cos(sv / (2 \u003c\u003c m))), (ei[m] = sin(sv / (2 \u003c\u003c m)));\n    }\n    let zr = 0, zi = 0;\n    for (let m = 0; m \u003c K; m++) {\n      zr += amp[m] * er[m];\n      zi += amp[m] * ei[m];\n      const r2 = er[m] * sr[m] - ei[m] * si[m];\n      ei[m] = er[m] * si[m] + ei[m] * sr[m];\n      er[m] = r2;\n    }\n    const o = j * 6, cq = C[o + 4], sq = C[o + 5];\n    const ur = zr * cq - zi * sq, ui = zr * sq + zi * cq;\n    const x = C[o] + R * ur * C[o + 2], y = C[o + 1] + R * ur * C[o + 3], z = R * ui;\n    const X = x * cp + z * sp, Z = -x * sp + z * cp;\n    const f = F / (F - Z);\n    const px = round(31.5 + X * f), py = round(63.5 - y * f);\n    if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) {\n      if (ap >= 0) write(ap, aZ, ah, av);\n      if (bp >= 0) write(bp, bZ, bh, bv);\n      ap = bp = -1;\n      continue;\n    }\n    const p = py * W + px;\n    if (p === bp) {\n      if (Z > bZ) bZ = Z;\n      continue;\n    }\n    const sv = (TAU * i) / NT;\n    const h = hue0 + 0.16 * cos(sv / 2) + 0.07 * cos(sv / 4);\n    const v = cl((Z + Dm) / (2 * Dm), 0, 1);\n    if (ap >= 0 && bp >= 0) {\n      const ax = ap % W, ay = (ap / W) | 0, bx = bp % W, by = (bp / W) | 0;\n      if (abs(ax - px) === 1 && abs(ay - py) === 1 && abs(bx - ax) + abs(by - ay) === 1 && abs(bx - px) + abs(by - py) === 1) {\n        (bp = p), (bZ = Z), (bh = h), (bv = v);\n        continue;\n      }\n    }\n    if (ap >= 0) write(ap, aZ, ah, av);\n    (ap = bp), (aZ = bZ), (ah = bh), (av = bv);\n    (bp = p), (bZ = Z), (bh = h), (bv = v);\n  }\n  if (ap >= 0) write(ap, aZ, ah, av);\n  if (bp >= 0) write(bp, bZ, bh, bv);\n\n  const body = [0, 0, 0];\n  hsv(0.68, 0.4, BODY, body, 0);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const h = hb[p];\n      if (h >= 0) {\n        // Near strands pale, far ones deep, all at full level.\n        hsv(h, 0.95 - 0.5 * vb[p], 1, rgb, 0);\n        display.setPixel(x, y, (255 * rgb[0]) | 0, (255 * rgb[1]) | 0, (255 * rgb[2]) | 0);\n      } else if (h === -2) display.setPixel(x, y, (255 * body[0]) | 0, (255 * body[1]) | 0, (255 * body[2]) | 0);\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n}\n","stokes-drift":"// ===== Patternflow pattern =====\n// Title:   Stokes Drift\n// Family:  wave\n// Idea:    A deep-water wave runs to the right across a cross-section of water 109 LEDs deep, and the particles stepped through its velocity field each trace a little orbit that falls short of closing, so the dye lines dropped straight down lean forward at the top along the curve e^(2kz) while the dots far below hardly stir.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Stokes drift (George Gabriel Stokes, 1847), against the trochoidal wave (Franz Gerstner, 1802), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Steepness=0.15..0.4, Gerstner=0..1\n//\n// Knob 1: Hue. Turns the four dye lines round the wheel together, magenta, gold, mint and azure at 0 from the left, and the dots' pale tint with them, pale green at 0; the surface stays white.\n// Knob 2: Speed. The wave's period, 2.6 s divided by the knob: 1.3 s at 2, 13 s at 0.2 and 0.87 s at 3. The wavelength stays 256 LEDs, four panel widths, so the panel shows a quarter of a wave.\n// Knob 3: Steepness. ak, the wave's amplitude times its wavenumber. At 0.15 the surface rises and falls 6.1 LEDs either side of its mean and the water at the top creeps 5.8 LEDs a period; at 0.25 10.2 LEDs and 16 a period; at 0.4 16.3 LEDs and 41 a period. The drift halves every 14.1 LEDs of depth, the orbits every 28.2. New dye drops when the top of the old has run 48 LEDs or after 12 periods.\n// Knob 4: Gerstner. Where each particle reads the wave's velocity. At 0 it reads it where it is, Airy's linear wave in Euler's view, and the orbits leave the drift omega k a^2 e^(2kz) behind; at 1 it reads it at the centre of its own orbit, which is Gerstner's exact trochoidal wave, whose orbits close and the dye lines only sway. In between the drift is close to 1 minus the knob times the full one: 0.94 at the opening 0.06, 0.52 at 0.5.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, exp, sin, cos, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Wavelength and domain: the water is periodic over one wavelength, 256\n// LEDs, and the panel shows the first 64 of it.\nconst L = 256, K = (2 * PI) / L;\n// The mean surface sits on row 18; depth runs down to row 127, 109 LEDs.\nconst SURF = 18, DEEP = H - 1 - SURF;\n// Material: a dot every 8 LEDs across and down, four dye lines of 220\n// points packed towards the top, and a chain of 256 surface particles.\nconst DX = 8, DZ = 8, NLINE = 4, NPT = 220, NSURF = 256;\nconst LINE_X = [8, 24, 40, 56];\nconst HUES = [0.88, 0.13, 0.42, 0.6];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A set of particles: position (x, z), z up from the mean surface, x not\n// wrapped so a particle's whole run can be read; and (rx, rz), the centre of\n// its orbit as the linear wave would have it. Dots and the surface are\n// placed by their centres and seated on their orbits.\nfunction pack(n) {\n  return { n, x: new Float64Array(n), z: new Float64Array(n), rx: new Float64Array(n), rz: new Float64Array(n) };\n}\nfunction place(P, i, x, z) {\n  P.x[i] = P.rx[i] = x;\n  P.z[i] = P.rz[i] = z;\n}\n\nexport function setup(params) {\n  const nd = (L / DX) * floor(DEEP / DZ + 1);\n  const s = {\n    ph: 0, hue: 0, speed: 2, ak: 0.15, akSeat: -1, g: 0.06, age: 0, fade: 0,\n    dots: pack(nd), lines: pack(NLINE * NPT), old: pack(NLINE * NPT), surf: pack(NSURF),\n    trail: new Float32Array(W * H), rgb: new Float32Array(W * H * 3), c: new Float32Array(3),\n  };\n  let i = 0;\n  for (let z = -4; z >= -DEEP; z -= DZ) for (let x = 4; x \u003c L; x += DX) place(s.dots, i++, x, z);\n  s.dots.n = i;\n  for (let j = 0; j \u003c NSURF; j++) place(s.surf, j, j * (L / NSURF), 0);\n  seat(s);\n  dye(s);\n  params.s = s;\n}\n\n// Fresh dye lines, dropped straight down from the surface chain to the bottom,\n// their points packed towards the top where the water moves most. Each\n// point's orbit centre is found from where it is.\nfunction dye(s) {\n  const a = s.ak / K;\n  for (let l = 0; l \u003c NLINE; l++) {\n    const x0 = LINE_X[l], top = level(s.surf, x0);\n    for (let k = 0; k \u003c NPT; k++) {\n      const i = l * NPT + k, z0 = top + (-DEEP - top) * (k / (NPT - 1)) ** 1.6;\n      s.lines.x[i] = s.lines.rx[i] = x0;\n      s.lines.z[i] = s.lines.rz[i] = z0;\n      centre(s.lines, i, a, s.ph, 12);\n    }\n  }\n  s.age = 0;\n}\n\n// The height of the surface chain above x: the pair of neighbours that\n// straddles x, wrapped onto one wavelength.\nfunction level(S, x) {\n  for (let j = 0; j \u003c S.n; j++) {\n    const k = j + 1 \u003c S.n ? j + 1 : 0;\n    const x1 = S.x[j] - floor(S.x[j] / L) * L;\n    let x2 = S.x[k] - floor(S.x[k] / L) * L;\n    if (x2 \u003c x1 - L / 2) x2 += L;\n    for (const xx of [x, x + L])\n      if (xx >= x1 && xx \u003c x2) return S.z[j] + ((S.z[k] - S.z[j]) * (xx - x1)) / (x2 - x1);\n  }\n  return 0;\n}\n\n// The surface is a material line, and at steep waves its particles bunch\n// at some crests and leave gaps elsewhere. When a gap opens past 1.2 LEDs\n// the chain is laid out again at even steps along the same curve, each new\n// point with its own orbit centre.\nfunction even(s) {\n  const S = s.surf, n = S.n, a = s.ak / K, cum = new Float64Array(n + 1);\n  let gap = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const k = j + 1 \u003c n ? j + 1 : 0, dx = S.x[k] + (k ? 0 : L) - S.x[j], d = Math.hypot(dx, S.z[k] - S.z[j]);\n    cum[j + 1] = cum[j] + d;\n    gap = max(gap, d);\n  }\n  if (gap \u003c 1.2) return;\n  const ox = Float64Array.from(S.x), oz = Float64Array.from(S.z), orx = Float64Array.from(S.rx), orz = Float64Array.from(S.rz);\n  for (let m = 0, j = 0; m \u003c n; m++) {\n    const want = (cum[n] * m) / n;\n    while (cum[j + 1] \u003c want) j++;\n    const k = j + 1 \u003c n ? j + 1 : 0, u = (want - cum[j]) / max(1e-9, cum[j + 1] - cum[j]), w = k ? 0 : L;\n    S.x[m] = ox[j] + (ox[k] + w - ox[j]) * u;\n    S.z[m] = oz[j] + (oz[k] - oz[j]) * u;\n    S.rx[m] = orx[j] + (orx[k] + w - orx[j]) * u;\n    S.rz[m] = orz[j] + (orz[k] - orz[j]) * u;\n    centre(S, m, a, s.ph, 6);\n  }\n}\n\n// The orbit centre r of a particle at p: p = r + xi(r), where the linear\n// wave moves a particle by xi = a e^(k rz) (-sin, cos)(k rx - phase); found\n// by turns of the fixed point from the last centre.\nfunction centre(P, i, a, ph, turns) {\n  const x = P.x[i], z = P.z[i];\n  let rx = P.rx[i], rz = P.rz[i];\n  for (let it = 0; it \u003c turns; it++) {\n    const e = a * exp(K * rz), th = K * rx - ph;\n    rx = x + e * sin(th);\n    rz = z - e * cos(th);\n  }\n  P.rx[i] = rx;\n  P.rz[i] = rz;\n}\n\n// Every particle put back on its orbit for steepness ak, keeping the orbit's\n// centre, and the surface chain's centres on the mean surface. After a turn\n// of Steepness the old orbits would leave dots above the new troughs, and a\n// particle above the water rides the linear wave's crest away.\nfunction seat(s) {\n  const a = s.ak / K;\n  for (const P of [s.dots, s.lines, s.old, s.surf])\n    for (let i = 0; i \u003c P.n; i++) {\n      if (P === s.surf) P.rz[i] = 0;\n      const rz = min(0, P.rz[i]), e = a * exp(K * rz), th = K * P.rx[i] - s.ph;\n      P.rz[i] = rz;\n      P.x[i] = P.rx[i] - e * sin(th);\n      P.z[i] = rz + e * cos(th);\n    }\n  s.akSeat = s.ak;\n}\n\n// One step of every particle in a set from phase ph by dph (radians of the\n// wave, so dt = dph / omega). The velocity of the linear deep-water wave\n// eta = a cos(kx - wt) is a w e^(kz) (cos, sin)(kx - wt); per radian of\n// phase, which is how it is stepped here, the w drops out. Airy's particles\n// read it where they are; Gerstner's read it at their orbit's centre. The\n// knob g reads it at centre + (1 - g)(where they are - centre). Only the\n// Airy reading feels the wave's gradient across the orbit, and that is all\n// the drift there is: nothing pushes a particle forward by hand.\nfunction step(P, ph, dph, ak, g) {\n  const a = ak / K, h = dph, f = 1 - g;\n  for (let i = 0; i \u003c P.n; i++) {\n    centre(P, i, a, ph, 2);\n    const x = P.x[i], z = P.z[i], rx = P.rx[i], rz = P.rz[i];\n    // Classical fourth-order Runge-Kutta with the centre held for the step.\n    let k1x, k1z, k2x, k2z, k3x, k3z, k4x, k4z, px, pz, e, th;\n    px = rx + f * (x - rx);\n    pz = rz + f * (z - rz);\n    e = a * exp(K * pz);\n    th = K * px - ph;\n    k1x = e * cos(th);\n    k1z = e * sin(th);\n    px = rx + f * (x + 0.5 * h * k1x - rx);\n    pz = rz + f * (z + 0.5 * h * k1z - rz);\n    e = a * exp(K * pz);\n    th = K * px - ph - 0.5 * h;\n    k2x = e * cos(th);\n    k2z = e * sin(th);\n    px = rx + f * (x + 0.5 * h * k2x - rx);\n    pz = rz + f * (z + 0.5 * h * k2z - rz);\n    e = a * exp(K * pz);\n    k3x = e * cos(K * px - ph - 0.5 * h);\n    k3z = e * sin(K * px - ph - 0.5 * h);\n    px = rx + f * (x + h * k3x - rx);\n    pz = rz + f * (z + h * k3z - rz);\n    e = a * exp(K * pz);\n    th = K * px - ph - h;\n    k4x = e * cos(th);\n    k4z = e * sin(th);\n    P.x[i] = x + (h / 6) * (k1x + 2 * k2x + 2 * k3x + k4x);\n    P.z[i] = z + (h / 6) * (k1z + 2 * k2z + 2 * k3z + k4z);\n    // A particle thrown over the crests is put back on its orbit.\n    if (!(P.z[i] \u003c 1.6 * a)) {\n      const c = min(0, rz), e2 = a * exp(K * c);\n      P.x[i] = rx - e2 * sin(K * rx - ph - h);\n      P.z[i] = c + e2 * cos(K * rx - ph - h);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0.15, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.ak = cl(kv[2], 0.15, 0.4);\n  s.g = cl(kv[3], 0, 1);\n  if (s.ak !== s.akSeat) seat(s);\n  // Phase advance this frame, in steps of at most 0.1 rad.\n  const dph = ((2 * PI) / 2.6) * s.speed * d, n = Math.ceil(dph / 0.1);\n  for (let k = 0; k \u003c n; k++) {\n    for (const P of [s.dots, s.lines, s.surf]) step(P, s.ph, dph / n, s.ak, s.g);\n    if (s.fade > 0) step(s.old, s.ph, dph / n, s.ak, s.g);\n    s.ph += dph / n;\n  }\n  // The surface chain's orbit centres are eased back onto the mean surface,\n  // a twentieth a frame. Left alone, at Steepness past 0.33 particles that\n  // started at a crest and at a trough settle at slightly different mean\n  // heights, drift at different speeds and fold the line within a minute.\n  const S = s.surf, a = s.ak / K;\n  for (let j = 0; j \u003c S.n; j++) {\n    centre(S, j, a, s.ph, 2);\n    const dz = 0.05 * S.rz[j];\n    S.rz[j] -= dz;\n    S.z[j] -= dz;\n  }\n  even(s);\n  s.age += dph;\n  s.fade = max(0, s.fade - d * 1.2);\n  // New dye when the top of the lines has run 48 LEDs ahead, or after 12\n  // periods; the old lines fade out over a second.\n  const run = s.lines.x[0] - LINE_X[0];\n  if (run > 48 || s.age > 12 * 2 * PI) {\n    const t = s.old;\n    s.old = s.lines;\n    s.lines = t;\n    s.fade = 1;\n    dye(s);\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const T = s.trail, B = s.rgb, c = s.c;\n  // The dots leave a short trail, so each traces its orbit.\n  for (let i = 0; i \u003c W * H; i++) T[i] *= 0.9;\n  B.fill(0);\n  const wrap = (x) => x - floor(x / L) * L;\n  const splat = (buf, x, y, v) => {\n    const x0 = floor(x - 0.5), y0 = floor(y - 0.5), fx = x - 0.5 - x0, fy = y - 0.5 - y0;\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const X = x0 + dx, Y = y0 + dy;\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const wgt = (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy);\n        buf[Y * W + X] += v * wgt;\n      }\n  };\n  const D = s.dots;\n  for (let i = 0; i \u003c D.n; i++) {\n    let x = wrap(D.x[i]);\n    if (x > L - 1) x -= L;\n    if (x \u003c W + 1) splat(T, x, SURF - D.z[i], 0.3);\n  }\n  // A line through a chain of points, drawn as samples every half LED, each\n  // lighting its four nearest LEDs by how near it falls.\n  const chain = (P, from, to, r, g, b, closed) => {\n    for (let i = from; i \u003c to - (closed ? 0 : 1); i++) {\n      const j = i + 1 \u003c to ? i + 1 : from;\n      const x1 = wrap(P.x[i]);\n      let x2 = wrap(P.x[j]);\n      if (x2 - x1 > L / 2) x2 -= L;\n      else if (x1 - x2 > L / 2) x2 += L;\n      const y1 = SURF - P.z[i], y2 = SURF - P.z[j];\n      const m = max(1, Math.ceil(2 * max(abs(x2 - x1), abs(y2 - y1))));\n      for (let k = 0; k \u003c m; k++) {\n        const u = k / m, y = y1 + (y2 - y1) * u;\n        let xx = x1 + (x2 - x1) * u;\n        if (xx > W + 1) xx -= L;\n        if (xx \u003c -1 || xx > W + 1) continue;\n        const x0 = floor(xx - 0.5), y0 = floor(y - 0.5), fx = xx - 0.5 - x0, fy = y - 0.5 - y0;\n        for (let dy = 0; dy \u003c 2; dy++)\n          for (let dx = 0; dx \u003c 2; dx++) {\n            const X = x0 + dx, Y = y0 + dy;\n            if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n            const wgt = min(1, 2 * (dx ? fx : 1 - fx) * (dy ? fy : 1 - fy)), o = (Y * W + X) * 3;\n            B[o] = max(B[o], r * wgt);\n            B[o + 1] = max(B[o + 1], g * wgt);\n            B[o + 2] = max(B[o + 2], b * wgt);\n          }\n      }\n    }\n  };\n  for (let l = 0; l \u003c NLINE; l++) {\n    hsv(HUES[l] + s.hue, 0.75, 1, c, 0);\n    chain(s.lines, l * NPT, (l + 1) * NPT, c[0], c[1], c[2], false);\n    if (s.fade > 0) chain(s.old, l * NPT, (l + 1) * NPT, c[0] * s.fade * 0.6, c[1] * s.fade * 0.6, c[2] * s.fade * 0.6, false);\n  }\n  chain(s.surf, 0, NSURF, 0.85, 0.88, 0.95, true);\n  // The dots in a pale tint half the wheel from the first dye line.\n  hsv(HUES[0] + 0.5 + s.hue, 0.55, 0.62, c, 0);\n  const dr = c[0], dg = c[1], db = c[2];\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3, t = min(0.5, T[p]);\n      display.setPixel(x, y, round(min(1, B[o] + t * dr) * 255), round(min(1, B[o + 1] + t * dg) * 255), round(min(1, B[o + 2] + t * db) * 255));\n    }\n}\n","terrell-rotation":"// ===== Patternflow pattern =====\n// Title:   Terrell Rotation\n// Family:  space\n// Idea:    A sheet of cubes and spheres slides up past a pinhole camera at a share of light's speed, and each LED shows the light that left the sheet earlier and reaches the camera now, so the cubes look turned to show their undersides instead of squashed, the spheres keep round outlines while their nets swing round, and the colours shift towards blue below, where the light left parts coming on.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Terrell-Penrose rotation (James Terrell, 1959; Roger Penrose, 1959), after Anton Lampa (1924), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beta=0.5..0.95, Distance=2..8\n//\n// Knob 1: Hue. The sheet's colour at rest, azure at 0, turned round the wheel. The Doppler shift moves each LED along the wheel from there by 0.12 times the log of the Doppler factor: towards violet where the light left a part coming towards the camera, towards green where it left a part going away.\n// Knob 2: Speed. How fast the sheet slides on the panel, not its speed against light's: 0.45 times the knob in cells of the sheet's own length a second, 0.9 at 2, so a new row comes in about every 1.1 s whatever Beta is.\n// Knob 3: Beta. The sheet's speed as a share of light's, from 0.5, where a cube seen straight out from the camera looks turned 30 degrees, through 36.9 at 0.6 to 64.2 at 0.9 and 71.8 at 0.95, the arcsine of Beta, showing its trailing underside; the spheres stay round. The rows bunch up towards the top, and straight out the light arrives with the Doppler factor 1/gamma, 0.44 at 0.9.\n// Knob 4: Distance. The camera's distance from the sheet, 2 to 8 cells, with the lens zoomed to keep three columns across the panel: it sees 54 degrees above and below the middle at 2, where the near rows bend, and 19 degrees at 8, where every cube is turned by nearly the same angle.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, acos, atan2, PI, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The sheet in its own rest frame, in cells: a cube or a sphere on every\n// cell of a square grid in the plane z = D, chequered, cubes 0.5 on a side\n// and spheres 0.68 across, so neither touches a neighbour.\nconst HC = 0.25, RS = 0.34, HM = 0.34;\n// The net on each sphere: its pole looks back at the camera along -z,\n// parallels every 30 degrees and six meridians.\nconst DPAR = PI / 6, DMER = PI / 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    phi: 0, hue: 0, speed: 2, beta: 0, dist: 2, key: \"\",\n    // Per LED: the ray in the sheet's frame (ex, ey, ez) and the Doppler\n    // factor of light arriving along it.\n    ray: new Float32Array(W * H * 4), rgb: new Float32Array(3),\n  };\n}\n\n// One pixel is one direction at the camera. Light reaching the camera from\n// camera-frame direction d (unit, y up the panel) left the sheet along the\n// sheet-frame direction (dx, gamma (dy + beta), dz) / (gamma (1 + beta dy)):\n// aberration, the whole of the effect. Emission point and arrival meet on a\n// straight line in the sheet's frame, so a ray traced there from the\n// camera's present place finds what the LED shows. 1 / (gamma (1 + beta dy))\n// is the Doppler factor. Rays only change with Beta and the lens.\nfunction aim(s) {\n  const b = s.beta, g = 1 / sqrt(1 - b * b), F = 23 * s.dist, R = s.ray;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 4) {\n      const X = (x + 0.5 - 32) / F, A = (64 - y - 0.5) / F, n = 1 / sqrt(X * X + A * A + 1);\n      const dy = A * n, k = 1 / (g * (1 + b * dy));\n      R[o] = X * n * k;\n      R[o + 1] = g * (dy + b) * k;\n      R[o + 2] = n * k;\n      R[o + 3] = k;\n    }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.speed = cl(kv[1], 0.2, 3);\n  s.beta = cl(kv[2], 0.5, 0.95);\n  s.dist = cl(kv[3], 2, 8);\n  // phi is how far the camera has gone through the sheet, in the sheet's\n  // own cells.\n  s.phi += d * 0.45 * s.speed;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const key = s.beta.toFixed(4) + \"/\" + s.dist.toFixed(3);\n  if (key !== s.key) aim(s), (s.key = key);\n  const R = s.ray, D = s.dist, F = 23 * D, phi = s.phi % 2, out = s.rgb, h0 = 0.56 + s.hue;\n  const z0 = D - HM, z1 = D + HM;\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 4) {\n      const ex = R[o], ey = R[o + 1], ez = R[o + 2], dop = R[o + 3];\n      // The slab the sheet fills, and the cells the ray crosses inside it.\n      const t0 = z0 / ez, t1 = z1 / ez;\n      const ya = -phi + t0 * ey, yb = -phi + t1 * ey, xa = t0 * ex, xb = t1 * ex;\n      const jlo = Math.ceil(min(ya, yb) - HM), jhi = floor(max(ya, yb) + HM);\n      const clo = max(-2, Math.ceil(min(xa, xb) - HM)), chi = min(2, floor(max(xa, xb) + HM));\n      let best = 1e9, kind = 0, bj = 0, bc = 0, axis = 0;\n      for (let j = jlo; j \u003c= jhi; j++)\n        for (let c = clo; c \u003c= chi; c++) {\n          // Local ray origin: the camera relative to this cell's centre.\n          const ox = -c, oy = -phi - j, oz = -D;\n          if (((j + c) & 1) === 0) {\n            // A cube, by slabs.\n            let tn = -1e9, tf = 1e9, ax = 0;\n            const ix = 1 / ex, iy = 1 / ey;\n            let a = (-HC - ox) * ix, b2 = (HC - ox) * ix;\n            if (a > b2) [a, b2] = [b2, a];\n            if (a > tn) (tn = a), (ax = 0);\n            if (b2 \u003c tf) tf = b2;\n            a = (-HC - oy) * iy;\n            b2 = (HC - oy) * iy;\n            if (a > b2) [a, b2] = [b2, a];\n            if (a > tn) (tn = a), (ax = 1);\n            if (b2 \u003c tf) tf = b2;\n            a = (-HC - oz) / ez;\n            b2 = (HC - oz) / ez;\n            if (a > tn) (tn = a), (ax = 2);\n            if (b2 \u003c tf) tf = b2;\n            if (tn \u003c= tf && tn > 0 && tn \u003c best) (best = tn), (kind = 1), (bj = j), (bc = c), (axis = ax);\n          } else {\n            const b2 = ox * ex + oy * ey + oz * ez, cc = ox * ox + oy * oy + oz * oz - RS * RS, disc = b2 * b2 - cc;\n            if (disc \u003c= 0) continue;\n            const t = -b2 - sqrt(disc);\n            if (t > 0 && t \u003c best) (best = t), (kind = 2), (bj = j), (bc = c);\n          }\n        }\n      if (!kind) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const px = best * ex - bc, py = best * ey - phi - bj, pz = best * ez - D;\n      // The size of one LED on the surface, in cells: Z / F across, and a\n      // Doppler factor shorter along the motion, then stretched where the\n      // surface is seen edge on.\n      const foot = (best * ez) / (F * sqrt(dop));\n      let fill, line;\n      if (kind === 1) {\n        const ea = axis === 0 ? abs(ex) : axis === 1 ? abs(ey) : ez;\n        const u = axis === 0 ? max(abs(py), abs(pz)) : axis === 1 ? max(abs(px), abs(pz)) : max(abs(px), abs(py));\n        const L = (foot * ez) / max(0.22, ea);\n        line = cl(1.15 - (HC - u) / L, 0, 1);\n        // The face towards the camera's side is brightest, the rows' tops and\n        // bottoms next, the sides dimmest.\n        fill = axis === 2 ? 0.17 : axis === 1 ? 0.12 : 0.085;\n      } else {\n        const mx = px / RS, my = py / RS, mz = pz / RS;\n        const facing = -(mx * ex + my * ey + mz * ez);\n        const th = acos(cl(-mz, -1, 1)), ps = atan2(my, mx);\n        const dp = RS * abs(th - round(th / DPAR) * DPAR), dm = RS * Math.sin(th) * abs(ps - round(ps / DMER) * DMER);\n        const L = foot / max(0.25, facing);\n        line = max(cl(1.1 - dp / L, 0, 1), cl(1.1 - dm / L, 0, 1) * cl(th * 3, 0, 1));\n        // The pole itself, and the rim where the ray grazes the outline.\n        if (th \u003c 0.2) line = 1;\n        const rim = (1 - facing) * (1 - facing);\n        line = max(line, rim * rim * 1.4);\n        fill = 0.06 + 0.1 * facing;\n      }\n      // Doppler: hue along the wheel by 0.12 times the log of the factor, blue\n      // for light from parts coming on, held short of yellow, which reads olive\n      // when dim; and brightness by a softened searchlight, the\n      // factor to the power 0.6 where the true intensity goes as its cube.\n      const ld = Math.log(dop);\n      const bright = cl(Math.exp(0.6 * ld), 0.5, 1.35);\n      const v = min(1, (fill + (0.95 - fill) * line) * bright);\n      hsv(h0 + cl(0.12 * ld, -0.24, 0.16), 0.85 - 0.4 * line, v, out, 0);\n      display.setPixel(x, y, round(out[0] * 255), round(out[1] * 255), round(out[2] * 255));\n    }\n}\n","zagier-windmill":"// ===== Patternflow pattern =====\n// Title:   Zagier's Windmills\n// Family:  number\n// Idea:    A prime p one more than a multiple of four is drawn as a windmill of p cells, a central square with four rectangular sails, and Zagier's involution and the swap of the sails take turns redrawing it: Zagier's map keeps the windmill's outline and cuts a new central square from it, the swap turns every sail on its side, and the walk from Zagier's one fixed point ends at a windmill with square sails that slide together into the two squares whose areas add up to p, while below the plane of sail sizes y and z plots every windmill of p on its hyperbola and the zigzag path the walk took.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fermat's theorem on sums of two squares (Pierre de Fermat, 1640; Leonhard Euler, 1749), Zagier's one-sentence proof (Don Zagier, 1990, after Roger Heath-Brown, 1984), pattern round 57\n// Round:   57\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Prime=1..13, Zoom=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the central square is pale gold and the sails on its top, right, bottom and left are green, cyan, blue and violet; in the plot the hyperbolas and Zagier's steps are gold and the swaps pale blue. At 0.5 the square is pale blue and the sails pink, red, orange and lime.\n// Knob 2: Speed. At 2 each step of the walk takes 1 second and holds half a second; the first windmill grows in 0.8 s and the end, a pause, the slide into two squares, the show and the fade, takes 4.4 s. So 13 takes 8.2 s, 97 with its walk of 26 steps 44 s, and the 14 primes 5.1 minutes. 0.2 is ten times slower, 3 half as fast again.\n// Knob 3: Prime. Which prime the cycle opens with: 1 is 13, 2 is 17, and so on to 13, which is 113. After 113 the cycle comes round to 5, whose windmill (1, 1, 1) is a plus that both maps leave alone, then 13 again. The walks are 2, 4, 4, 6, 10, 6, 10, 20, 20, 26, 10, 16 and 22 steps long, and for each of these primes the walk passes through every windmill of p, 3 for 13 and 23 for 113.\n// Knob 4: Zoom. 1 to 2.5 times the size that fits the windmill into the top 64 rows, which is 8 LEDs a cell for small windmills and 1 LED for the plus of 113, 57 cells across; at most 14 LEDs a cell. Turned up, the central square and the roots of the sails fill the top, where Zagier's map makes its cut, and the long sails run off the edges.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, cos, sin, atan2, round, log, PI, SQRT2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n// The primes one more than a multiple of four whose first windmill, a plus\n// sign (p + 1) / 2 cells across, fits the 64 columns.\nconst PR = [5, 13, 17, 29, 37, 41, 53, 61, 73, 89, 97, 101, 109, 113];\n// Seconds at Speed 2: the first windmill grows, each step of the walk\n// moves and holds, then the pause, the slide into two squares, the show\n// and the fade.\nconst GROW = 0.8, STEP = 1.0, HOLD = 0.5, PAUSE = 0.4, SLIDE = 1.4, SHOW = 2.0, FADE = 0.6;\n// The plot of sail sizes: y across from column 3, z up from row 126.\nconst PX = 3, PY = 126, PS = 58;\n\n// Zagier's involution on x^2 + 4yz = p, and which of its three cases ran.\nfunction zag(x, y, z) {\n  if (x \u003c y - z) return [x + 2 * z, z, y - x - z, 1];\n  if (x \u003c 2 * y) return [2 * y - x, y, x - y + z, 2];\n  return [x - 2 * y, x - y + z, y, 3];\n}\n\n// The walk for p: from Zagier's fixed point (1, 1, (p - 1) / 4), swap and\n// Zagier's map in turn until the swap would fix the windmill (y = z). Each\n// windmill keeps a turning sense: Zagier's middle case keeps the outline of\n// the mirror image, so it flips the sense, and the outline then stays put.\nfunction plan(p) {\n  const k = (p - 1) / 4, path = [[1, 1, k, 1]];\n  for (let t = path[0]; t[1] !== t[2]; ) {\n    t = [t[0], t[2], t[1], t[3]];\n    path.push(t);\n    if (t[1] === t[2]) break;\n    const z = zag(t[0], t[1], t[2]);\n    t = [z[0], z[1], z[2], z[3] === 2 ? -t[3] : t[3]];\n    path.push(t);\n  }\n  const S = [];\n  for (let x = 1; x * x \u003c p; x += 2) {\n    const m = (p - x * x) / 4;\n    for (let y = 1; y \u003c= m; y++) if (m % y === 0) S.push([x, y, m / y]);\n  }\n  const n = path.length - 1, end = GROW + n * (STEP + HOLD);\n  const lm = [];\n  for (let x = 1; x * x \u003c p; x += 2) lm.push(log((p - x * x) / 4));\n  return { p, k, path, S, n, lm, end, total: end + PAUSE + SLIDE + SHOW + FADE };\n}\n\n// The five pieces of a windmill, each as a rectangle (centre u, centre v,\n// half width, half height, turn) in cells about the centre of its square:\n// the square, then the sails on its top, right, bottom and left. Each sail\n// is y cells along its side, starting from a corner, and z cells out. A\n// turning sense of -1 mirrors the windmill.\nfunction mill(x, y, z, h, out) {\n  const c = x / 2;\n  const R = [[-c, c, -c, c], [-c, -c + y, c, c + z], [c, c + z, c - y, c], [c - y, c, -c - z, -c], [-c - z, -c, -c, -c + y]];\n  for (let i = 0; i \u003c 5; i++) {\n    const r = R[i], o = i * 5;\n    out[o] = (h * (r[0] + r[1])) / 2;\n    out[o + 1] = (r[2] + r[3]) / 2;\n    out[o + 2] = (r[1] - r[0]) / 2;\n    out[o + 3] = (r[3] - r[2]) / 2;\n    out[o + 4] = 0;\n  }\n  return out;\n}\n// The windmill with square sails as the squares x^2 and (2y)^2, side by\n// side and one cell apart, its four sails the quarters of the second.\nfunction squares(x, y, out) {\n  const c = x / 2, L = -c - y, B = -c - floor((max(x, 2 * y) - x) / 2), R = L + x + 1;\n  const Q = [[L + c, B + c, c], [R + y / 2, B + 1.5 * y, y / 2], [R + 1.5 * y, B + 1.5 * y, y / 2], [R + 1.5 * y, B + y / 2, y / 2], [R + y / 2, B + y / 2, y / 2]];\n  for (let i = 0; i \u003c 5; i++) {\n    const o = i * 5;\n    (out[o] = Q[i][0]), (out[o + 1] = Q[i][1]), (out[o + 2] = out[o + 3] = Q[i][2]), (out[o + 4] = 0);\n  }\n  return out;\n}\nconst span = (t) => max(t[0] + 2 * t[2], 2 * t[1] - t[0]);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, clock: 0, idx: -1, first: -1, hue: -1, rate: 1, zoom: 1, P: null,\n    ra: new Float32Array(25), rb: new Float32Array(25), pal: new Float32Array(24),\n    buf: new Float32Array(W * H * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const first = round(cl(kv[2], 1, 13));\n  s.rate = cl(kv[1], 0.2, 3) / 2;\n  s.zoom = 1 + 1.5 * cl(kv[3], 0, 1);\n  const hue = cl(kv[0], 0, 1);\n  if (hue !== s.hue) {\n    // The square pale gold, the sails green, cyan, blue and violet.\n    s.hue = hue;\n    hsv(0.13 + hue, 0.3, 1, s.pal, 0);\n    [0.36, 0.5, 0.63, 0.79].forEach((h, i) => hsv(h + hue, 0.78, 1, s.pal, 3 + i * 3));\n    hsv(0.6 + hue, 0.25, 1, s.pal, 15);\n    hsv(0.12 + hue, 0.55, 1, s.pal, 18);\n  }\n  if (first !== s.first) (s.first = first), (s.idx = first), (s.P = plan(PR[first])), (s.t = 0);\n  s.t += d * s.rate;\n  s.clock += d * s.rate;\n  if (s.t >= s.P.total) (s.t -= s.P.total), (s.idx = (s.idx + 1) % PR.length), (s.P = plan(PR[s.idx]));\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.P) return;\n  const P = s.P, B = s.buf, pal = s.pal, t = s.t;\n  B.fill(0);\n  const add = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    B[o] = max(B[o], r);\n    B[o + 1] = max(B[o + 1], g);\n    B[o + 2] = max(B[o + 2], b);\n  };\n  // Where the walk is: step i moving with progress e, or the end.\n  let i = 0, e = 0, grow = 1, slide = 0, fade = 1;\n  if (t \u003c GROW) grow = ease(t / GROW);\n  else if (t \u003c P.end) {\n    const u = (t - GROW) / (STEP + HOLD);\n    i = floor(u) + 1;\n    e = ease(((u - floor(u)) * (STEP + HOLD)) / STEP);\n  } else {\n    i = P.n;\n    slide = ease((t - P.end - PAUSE) / SLIDE);\n    fade = 1 - ease((t - P.end - PAUSE - SLIDE - SHOW) / FADE);\n  }\n  const a = P.path[max(0, i - 1)], b = P.path[i];\n  const ra = s.ra, rb = s.rb;\n  // The pieces this frame: ra, and for a step of Zagier's map the new\n  // pieces rb, cut in as a square that spreads out from the centre.\n  let cut = -1, fit;\n  if (t \u003c GROW) mill(1, 1, P.k * grow, 1, ra), (fit = span(b));\n  else if (t \u003c P.end && i % 2 === 1) {\n    // The swap: every sail turns a quarter about its middle, the way the\n    // windmill turns, while its middle slides to where the turned sail\n    // belongs: y cells along and z out become z along and y out.\n    mill(a[0], a[1], a[2], a[3], ra);\n    mill(b[0], b[1], b[2], b[3], rb);\n    for (let j = 5; j \u003c 25; j += 5) {\n      ra[j] += (rb[j] - ra[j]) * e;\n      ra[j + 1] += (rb[j + 1] - ra[j + 1]) * e;\n      ra[j + 4] = (e * PI * a[3]) / 2;\n    }\n    fit = span(a) + (span(b) - span(a)) * e;\n  } else if (t \u003c P.end) {\n    mill(a[0], a[1], a[2], a[3], ra);\n    mill(b[0], b[1], b[2], b[3], rb);\n    cut = e * (span(a) / 2 + 1);\n    fit = span(a) + (span(b) - span(a)) * e;\n  } else {\n    mill(b[0], b[1], b[2], b[3], ra);\n    squares(b[0], b[1], rb);\n    for (let j = 0; j \u003c 25; j++) ra[j] += (rb[j] - ra[j]) * slide;\n    fit = span(b) + (b[0] + 1 + 2 * b[1] - span(b)) * slide;\n  }\n  const cs = min(14, min(8, 58 / fit) * s.zoom), light = s.clock * 1.6 * b[3];\n  // Which piece an LED falls in, leaving its place in that piece in lu, lv\n  // (cells from the piece's corner) for the ruling of the cells.\n  let lu = 0, lv = 0;\n  const piece = (R, U, V) => {\n    for (let j = 0; j \u003c 5; j++) {\n      const o = j * 5, an = R[o + 4];\n      let du = U - R[o], dv = V - R[o + 1];\n      if (an !== 0) {\n        const c = cos(an), sn = sin(an), t0 = c * du + sn * dv;\n        (dv = c * dv - sn * du), (du = t0);\n      }\n      if (abs(du) \u003c R[o + 2] && abs(dv) \u003c R[o + 3]) return (lu = du + R[o + 2]), (lv = dv + R[o + 3]), j;\n    }\n    return -1;\n  };\n  // The top: the windmill on squared paper, one ruled line a cell, or\n  // every 2 or 4 cells when cells are small.\n  const step = cs >= 3 ? 1 : cs >= 1.5 ? 2 : 4;\n  for (let y = 0; y \u003c 64; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const U = (x + 0.5 - 31.5) / cs, V = (31.5 - (y + 0.5)) / cs;\n      const j = cut >= 0 && max(abs(U), abs(V)) \u003c cut ? piece(rb, U, V) : piece(ra, U, V);\n      if (j \u003c 0) {\n        const gu = U - 0.5, gv = V - 0.5, nu = round(gu / step) * step, nv = round(gv / step) * step;\n        if (abs(gu - nu) * cs \u003c 0.5 || abs(gv - nv) * cs \u003c 0.5) add(x, y, (0.05 + 0.13 * pal[12]) * fade, (0.05 + 0.13 * pal[13]) * fade, (0.05 + 0.13 * pal[14]) * fade);\n        continue;\n      }\n      // A light turns round the windmill the way its sails turn.\n      let k = (0.8 + 0.2 * cos(atan2(V, U) - light)) * fade;\n      if (cs >= 3.5 && ((lu - floor(lu)) * cs \u003c 1 || (lv - floor(lv)) * cs \u003c 1)) k *= 0.62;\n      // The front of the new central square as it spreads.\n      if (cut >= 0 && abs(max(abs(U), abs(V)) - cut) * cs \u003c 0.8) k = 1;\n      add(x, y, pal[j * 3] * k, pal[j * 3 + 1] * k, pal[j * 3 + 2] * k);\n    }\n\n  // The bottom: the plane of sail sizes, log y across and log z up. Every\n  // windmill of p lies on the hyperbola yz = (p - x^2) / 4 of its square's\n  // side x, which these axes draw as a straight line; the swap keeps x, so\n  // it slides a windmill along its own line, mirrored in the diagonal\n  // y = z, and Zagier's map jumps from line to line.\n  const lo = log(0.7), sc = PS / (log(P.k / 0.7) - lo), f2 = fade * min(1, t / GROW + 0.2);\n  const cur = t \u003c P.end && e \u003c 0.5 ? a : b, R2 = SQRT2;\n  for (let y = PY - PS; y \u003c PY; y++)\n    for (let x = PX; x \u003c PX + PS; x++) {\n      const lY = lo + (x + 0.5 - PX) / sc, lZ = lo + (PY - (y + 0.5)) / sc, q = lY + lZ;\n      let band = 0, hc = 0;\n      for (let j = 0; j \u003c P.lm.length; j++) {\n        if (q \u003c= P.lm[j]) band = j + 1;\n        if ((abs(q - P.lm[j]) * sc) / R2 \u003c 0.6) hc = 2 * j + 1;\n      }\n      // Below the outer line the bands between the lines, tinted with the\n      // sail colours, rippling along the lines in towards the diagonal.\n      if (band) {\n        const c = band & 1 ? 9 : 12, k = (0.15 + 0.06 * cos(abs(lY - lZ) * sc * 0.55 + s.clock * 3)) * f2;\n        add(x, y, pal[c] * k, pal[c + 1] * k, pal[c + 2] * k);\n      }\n      if ((abs(lY - lZ) * sc) / R2 \u003c 0.6) add(x, y, 0.3 * f2, 0.3 * f2, 0.34 * f2);\n      if (hc) {\n        const k = (hc === cur[0] ? 0.8 : 0.34) * f2;\n        add(x, y, pal[18] * k, pal[19] * k, pal[20] * k);\n      }\n    }\n  // The walk so far, segment by segment, the swaps in pale blue and\n  // Zagier's steps in gold, then the windmills of p as dots: grey until the\n  // walk reaches them, gold after, the one shown above white.\n  const at = (tr) => [PX + (log(tr[1]) - lo) * sc, PY - (log(tr[2]) - lo) * sc];\n  const segs = t \u003c GROW ? 0 : t \u003c P.end ? i : P.n;\n  for (let j = 1; j \u003c= segs; j++) {\n    const [x0, y0] = at(P.path[j - 1]), [x1, y1] = at(P.path[j]);\n    const reach = j === i && t \u003c P.end ? e : 1, n = max(1, round(max(abs(x1 - x0), abs(y1 - y0)) * reach));\n    const c = j % 2 ? 15 : 18, k = 0.9 * fade;\n    for (let q = 0; q \u003c= n; q++) {\n      const u = (q / n) * reach;\n      add(floor(x0 + (x1 - x0) * u), floor(y0 + (y1 - y0) * u), pal[c] * k, pal[c + 1] * k, pal[c + 2] * k);\n    }\n  }\n  const rad = cl(sc * 0.12, 0.8, 3), pulse = 0.75 + 0.25 * cos(s.clock * 7);\n  for (const tr of P.S) {\n    const [cx, cy] = at(tr);\n    let seen = false;\n    for (let q = 0; q \u003c= segs; q++) if (P.path[q][0] === tr[0] && P.path[q][1] === tr[1] && P.path[q][2] === tr[2]) seen = true;\n    const now = tr[0] === cur[0] && tr[1] === cur[1] && tr[2] === cur[2];\n    const k = (now ? pulse : seen ? 0.9 : 0.45) * f2, r = now ? 1 : seen ? pal[18] : 0.8, g = now ? 1 : seen ? pal[19] : 0.8, bl = now ? 1 : seen ? pal[20] : 0.85;\n    for (let yy = floor(cy - rad); yy \u003c= cy + rad; yy++)\n      for (let xx = floor(cx - rad); xx \u003c= cx + rad; xx++)\n        if ((xx + 0.5 - cx) ** 2 + (yy + 0.5 - cy) ** 2 \u003c= rad * rad + 0.3) add(xx, yy, r * k, g * k, bl * k);\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, round(B[o] * 255)), min(255, round(B[o + 1] * 255)), min(255, round(B[o + 2] * 255)));\n}\n","andrews-curves":"// ===== Patternflow pattern =====\n// Title:   Andrews Curves\n// Family:  data\n// Idea:    Forty synthetic points in five dimensions, three Gaussian clusters of 13 and one outlier, each become Andrews' curve f(t) = x1/sqrt 2 + x2 sin t + x3 cos t + x4 sin 2t + x5 cos 2t with t running down the panel, so the clusters hang as three braided bundles and the outlier strays, and as a grand tour turns the data the bundles twist past each other while the shaded gap between the outlier's white curve and its neighbour's keeps one root mean square, the fixed bar along the bottom.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Andrews plots (David F. Andrews, 1972), turned by the grand tour (Daniel Asimov, 1985), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=0.12..0.6, Dims=5..9\n//\n// Knob 1: Hue. Turns the three clusters round the wheel together. At 0 they are cyan, violet and green; at 0.25 indigo, rose and cyan; at 0.5 rose, green and blue. The marked pair stays white with a grey gap, and the wheel skips orange and yellow, which read brown and olive on the faint edges of the curves.\n// Knob 2: Speed. How fast the grand tour turns. At 2 each of the ten coordinate planes of five dimensions turns at its own rate between 0.10 and 0.20 radians a second, the rates linearly independent so the tour never repeats; 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Spread. Each cluster's standard deviation in every coordinate, as a share of R, the distance from the middle to a cluster centre; the centres stand R sqrt 3 = 1.73 R apart and the outlier 1.72 R from each. At 0.12 a point lies on average 0.26 R from its centre in five dimensions and the bundles are tight ropes; at 0.6 it lies 1.3 R off, the clusters overlap and the curves spread into one tangle.\n// Knob 4: Dims. The data's dimension, 5 to 9; each two coordinates past the first add a harmonic, so the curves run to cos 2t at 5, cos 3t at 7 and cos 4t at 9 and the braids wind tighter. The clusters differ only in the first five coordinates, the rest is spread, and the gap's bar is 14.6 LEDs at 5, 12.6 at 7 and 11.3 at 9, held to three decimals through a minute of touring at each (the axis narrows as the dimension grows).\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The data: three synthetic Gaussian clusters of PER points each in up to\n// DMAX dimensions, and one outlier. Cluster centres sit R from the middle,\n// 120 degrees apart, so any two are R sqrt 3 apart.\nconst DMAX = 9, PER = 13, NC = 3, N = NC * PER + 1, R = 1;\n// Tour radians a second at Speed 1.\nconst RATE = 0.11;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nfunction gauss() {\n  const u = Math.random() || 1e-9, v = Math.random();\n  return sqrt(-2 * Math.log(u)) * cos(2 * PI * v);\n}\n\nexport function setup(params) {\n  // Two orthonormal directions in the first five coordinates carry the\n  // triangle of centres; a third, square to both, carries the outlier.\n  const basis = [];\n  for (let k = 0; k \u003c 3; k++) {\n    const v = new Float64Array(DMAX);\n    for (let i = 0; i \u003c 5; i++) v[i] = gauss();\n    for (const b of basis) {\n      let d = 0;\n      for (let i = 0; i \u003c DMAX; i++) d += v[i] * b[i];\n      for (let i = 0; i \u003c DMAX; i++) v[i] -= d * b[i];\n    }\n    let n = 0;\n    for (let i = 0; i \u003c DMAX; i++) n += v[i] * v[i];\n    for (let i = 0; i \u003c DMAX; i++) v[i] /= sqrt(n);\n    basis.push(v);\n  }\n  const centre = [], z = [];\n  for (let c = 0; c \u003c NC; c++) {\n    const a = (2 * PI * c) / NC, v = new Float64Array(DMAX);\n    for (let i = 0; i \u003c DMAX; i++) v[i] = R * (cos(a) * basis[0][i] + sin(a) * basis[1][i]);\n    centre.push(v);\n  }\n  // Each point keeps its own standard normal draw; Spread scales it.\n  for (let p = 0; p \u003c N; p++) {\n    const v = new Float64Array(DMAX);\n    for (let i = 0; i \u003c DMAX; i++) v[i] = gauss();\n    z.push(v);\n  }\n  // Asimov's torus method: every coordinate plane turns at its own rate,\n  // the rates linearly independent over the rationals (fractional parts of\n  // square roots of primes), so the product of turns wanders densely\n  // through all rotations.\n  const primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151];\n  const rate = [];\n  for (let i = 0, k = 0; i \u003c DMAX; i++) for (let j = i + 1; j \u003c DMAX; j++, k++) rate.push([i, j, 0.3 + 0.7 * (sqrt(primes[k]) % 1)]);\n  // Sines and cosines of each row's t, for the harmonics.\n  const trig = new Float64Array(H * DMAX);\n  for (let r = 0; r \u003c H; r++) {\n    const t = -PI + (2 * PI * (r + 0.5)) / H;\n    trig[r * DMAX] = 1 / Math.SQRT2;\n    for (let i = 1; i \u003c DMAX; i++) {\n      const k = (i + 1) >> 1;\n      trig[r * DMAX + i] = i & 1 ? sin(k * t) : cos(k * t);\n    }\n  }\n  // The outlier stands 1.4 R from the middle, square to the centres' plane,\n  // and is marked together with the member of the first cluster nearest to\n  // it at the opening Spread.\n  const outlier = basis[2].map((x) => 1.4 * R * x);\n  let near = 0, best = 1e9;\n  for (let p = 0; p \u003c PER; p++) {\n    let d2 = 0;\n    for (let i = 0; i \u003c 5; i++) d2 += (centre[0][i] + 0.12 * z[p][i] - outlier[i]) ** 2;\n    if (d2 \u003c best) (best = d2), (near = p);\n  }\n  params.s = {\n    centre, z, outlier, rate, trig, tau: 0,\n    hue: 0, speed: 2, spread: 0.12, d: 5,\n    Q: new Float64Array(DMAX * DMAX), x: new Float64Array(N * DMAX), y: new Float64Array(N * DMAX),\n    f: new Float32Array(N * H), acc: new Float32Array(NP * 3), col: new Float32Array(NC * 3 + 3), pair: [near, N - 1],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.12, 5], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.spread = cl(kv[2], 0.12, 0.6);\n  S.d = cl(round(kv[3]), 5, DMAX);\n  S.tau += d * S.speed * RATE;\n}\n\n// The tour's rotation of the first D coordinates at time tau: the turns of\n// every plane among them, taken in a fixed order.\nfunction tour(S, D) {\n  const Q = S.Q;\n  Q.fill(0);\n  for (let i = 0; i \u003c D; i++) Q[i * DMAX + i] = 1;\n  for (const [i, j, w] of S.rate) {\n    if (j >= D) continue;\n    const a = w * S.tau, c = cos(a), s = sin(a);\n    for (let k = 0; k \u003c D; k++) {\n      const qi = Q[i * DMAX + k], qj = Q[j * DMAX + k];\n      Q[i * DMAX + k] = c * qi - s * qj;\n      Q[j * DMAX + k] = s * qi + c * qj;\n    }\n  }\n}\n\n// Splat a point onto its four nearest LEDs, adding colour c scaled by a.\nfunction splat(acc, x, y, c, o, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = (dx ? tx : 1 - tx) * wy * a, p = (yy * W + xx) * 3;\n      acc[p] += c[o] * w;\n      acc[p + 1] += c[o + 1] * w;\n      acc[p + 2] += c[o + 2] * w;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const D = S.d, { x, y, f, acc, trig, Q, col } = S;\n  // The observations in their own coordinates.\n  for (let p = 0; p \u003c N; p++)\n    for (let i = 0; i \u003c DMAX; i++) {\n      const base = p \u003c NC * PER ? S.centre[floor(p / PER)][i] + S.spread * S.z[p][i] : S.outlier[i];\n      x[p * DMAX + i] = i \u003c D ? base : 0;\n    }\n  tour(S, D);\n  for (let p = 0; p \u003c N; p++)\n    for (let i = 0; i \u003c D; i++) {\n      let v = 0;\n      for (let k = 0; k \u003c D; k++) v += Q[i * DMAX + k] * x[p * DMAX + k];\n      y[p * DMAX + i] = v;\n    }\n  // Andrews' curves: f(t) = y1 / sqrt 2 + y2 sin t + y3 cos t + y4 sin 2t + ...\n  // By Cauchy-Schwarz |f| is at most |y| sqrt(D / 2), and a turn keeps |y|,\n  // so the axis is fixed for each D: R sqrt(D / 2), the most a centre's\n  // curve can reach, is 22 LEDs either side of the middle.\n  const sc = 22 / (R * sqrt(D / 2));\n  for (let p = 0; p \u003c N; p++)\n    for (let r = 0; r \u003c H; r++) {\n      let v = 0;\n      for (let i = 0; i \u003c D; i++) v += y[p * DMAX + i] * trig[r * DMAX + i];\n      f[p * H + r] = W / 2 + v * sc;\n    }\n  // Cyan, violet and green at Hue 0.\n  for (let c = 0; c \u003c NC; c++) hsv(wheel(0.58 + S.hue + [0, 0.27, 0.73][c]), 0.8, 1, col, c * 3);\n  col[9] = col[10] = col[11] = 1;\n  acc.fill(0);\n  const [pa, pb] = S.pair;\n  // The gap between the two marked curves, shaded faintly.\n  for (let r = 0; r \u003c H; r++) {\n    const a = f[pa * H + r], b = f[pb * H + r], lo = max(0, Math.ceil(min(a, b))), hi = min(W - 1, floor(max(a, b)));\n    for (let c = lo; c \u003c= hi; c++) {\n      const o = (r * W + c) * 3;\n      acc[o] += 0.1;\n      acc[o + 1] += 0.1;\n      acc[o + 2] += 0.12;\n    }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const ci = p \u003c NC * PER ? floor(p / PER) * 3 : 9, mark = p === pa || p === pb;\n    const a = mark ? 0.7 : 0.2;\n    for (let r = 0; r + 1 \u003c H; r++) {\n      const xa = f[p * H + r], xb = f[p * H + r + 1], len = Math.hypot(xb - xa, 1), m = Math.ceil(len * 3);\n      for (let e = 0; e \u003c m; e++) splat(acc, xa + ((xb - xa) * e) / m, r + 0.5 + e / m, col, mark ? 9 : ci, ((a * len) / m) * 3);\n    }\n  }\n  // Parseval: the mean of (f_x - f_y)^2 over t is |x - y|^2 / 2, and a\n  // turn keeps |x - y|, so the gap's root mean square over the 128 rows\n  // (exact for these few harmonics) never moves while the curves do. It is\n  // measured from the drawn curves each frame and laid as a bar, that many\n  // LEDs long, across the bottom two rows with a dark row above.\n  let ss = 0;\n  for (let r = 0; r \u003c H; r++) ss += (f[pa * H + r] - f[pb * H + r]) ** 2;\n  const half = sqrt(ss / H) / 2;\n  for (let c = 0; c \u003c W; c++) {\n    const e = half - abs(c + 0.5 - W / 2);\n    if (e \u003c -2) continue;\n    for (let r = H - 3; r \u003c H; r++) {\n      const o = (r * W + c) * 3;\n      acc[o] = acc[o + 1] = acc[o + 2] = r === H - 3 ? 0 : cl(e + 0.5, 0, 1);\n    }\n  }\n  // Where curves pile up the light saturates on the brightest channel and\n  // the others follow in proportion, so a dense bundle glows in its own\n  // colour instead of washing to white.\n  for (let p = 0, o = 0; p \u003c NP; p++, o += 3) {\n    const m = max(acc[o], acc[o + 1], acc[o + 2]), k = m > 0 ? (255 * (1 - exp(-2.2 * m))) / m : 0;\n    display.setPixel(p % W, (p / W) | 0, (acc[o] * k) | 0, (acc[o + 1] * k) | 0, (acc[o + 2] * k) | 0);\n  }\n}\n","bloch-oscillations":"// ===== Patternflow pattern =====\n// Title:   Bloch Oscillations\n// Family:  wave\n// Idea:    A quantum particle on a chain of sites laid across the panel feels a steady force along the chain, and with time running down the scrolling panel it never slides away: started on one site it breathes out into a lens of Bessel fringes 50 sites wide and back to a point once every Bloch period, a broad packet swings from side to side instead, and the hue gives the quasi-momentum, which the force winds steadily through the band.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Bloch oscillations (Felix Bloch, 1929; Clarence Zener, 1934) and the Wannier-Stark ladder (Gregory Wannier, 1960), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Force=0.16..0.64, Width=0..1\n//\n// Knob 1: Hue. Turns the wheel the quasi-momentum k is read on, k being the phase step from each site to the next. At 0 the bottom of the band (k = 0) is azure, a packet moving right at full speed (k = pi/2) violet, one moving left (k = -pi/2) green, and the top of the band (k = pi), where a broad packet is Bragg-reflected and turns back, red; orange takes a narrower slice of k than the other colours. The lens from one site opens violet on its right edge and lime on its left, and as the force winds k down, the right edge turns through blue to azure and the left edge through red to pink.\n// Knob 2: Speed. How fast the carpet climbs: one row is 0.75 in units of hbar / J. At 2 sixteen rows a second, so one Bloch period at the opening Force passes in 3.3 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Force. F in units of J per site, 0.16 to 0.64. The Bloch period 2 pi / F is 52 rows at 0.16, 26 at 0.32 and 13 at 0.64, and the lens from one site opens to 4J/F either side, 25, 12.5 and 6.3 sites, which is 57, 31 and 17 lit LEDs at its widest. A broad packet swings 24.9, 12.4 and 6.2 sites from side to side, against 4J/F. Turning it mid-run changes the field from the next row on; if more than half the particle has swung off the panel it starts again in the middle.\n// Knob 4: Width. The starting packet. Up to 0.1 a single site, and the rows are J_n(4J/F sin(Ft/2))^2 to within 3e-8 of the closed form; above, a Gaussian of width 6 u^2 sites (u from 0 at 0.1 to 1 at 1) moving right at k = pi/2. At 0.3 (0.3 sites) the lens keeps its fringes; at 0.4 (0.7 sites) they are gone and a bright violet edge, the part moving right, runs down the lens from upper left to lower right; at 0.5 (1.2 sites) the lens has become one band swinging in an S, 25 sites peak to peak at the opening Force, and at 1 (6 sites) the band is 38 LEDs wide. Each turn starts the packet again.\n\nconst W = 64, H = 128;\n// Sites on the chain, and the one under the panel's middle. The panel\n// shows sites C - 32 to C + 31; the chain runs 64 further each way, past\n// any swing the knobs allow, so its ends are never reached.\nconst NS = 192, C = 96;\n// Time per row in units of hbar / J, cut into SUB exact steps; the row\n// shows the probability averaged over them.\nconst TROW = 0.75, SUB = 4, DT = TROW / SUB;\n// Rows per second at Speed 1.\nconst RATE = 8;\n// Bessel orders kept in one step: J_m(2 dt) for m > MB is below 1e-12.\nconst MB = 10;\n// Brightness from the probability on a log scale: 10^LMIN is dark, 10^(LMIN + LSPAN) full.\nconst LMIN = -3.2, LSPAN = 2.4;\nconst { floor, min, max, abs, sin, cos, sqrt, exp, round, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, F: 0.16, wid: 0, begun: false,\n    re: new Float64Array(NS), im: new Float64Array(NS), nr: new Float64Array(NS), ni: new Float64Array(NS),\n    // The step's kernel: Re and Im of i^m J_m(a) e^{-i m F dt / 2}, m = -MB..MB.\n    kr: new Float64Array(2 * MB + 1), ki: new Float64Array(2 * MB + 1), kF: -1,\n    // The last 128 rows: probability and phase per site, newest at head - 1.\n    rho: new Float32Array(W * H), ph: new Float32Array(W * H), head: 0, prog: 0, launched: 0,\n    acc: new Float64Array(W), rgb: new Float32Array(W * H * 3),\n  };\n}\n\n// J_0..J_MB at a small argument, by the power series.\nfunction besselSmall(a, out) {\n  for (let m = 0; m \u003c= MB; m++) {\n    let term = (a / 2) ** m, s = 0;\n    for (let k = 1; k \u003c= m; k++) term /= k;\n    for (let k = 0; k \u003c 20; k++) {\n      s += term;\n      term *= -((a / 2) ** 2) / ((k + 1) * (k + 1 + m));\n    }\n    out[m] = s;\n  }\n}\n\n// The exact propagator of the tilted chain over one step dt, found by\n// taking out the phase e^{-i F n t} and summing the hopping in momentum\n// space with the Jacobi-Anger expansion. With\n// H = -J sum (|n>\u003cn+1| + h.c.) + F sum n |n>\u003cn| and J = 1,\n//   psi_n(t + dt) = e^{-i F n dt} sum_m i^m J_m(a) e^{-i m F dt / 2} psi_{n+m}(t),\n//   a = (4J / F) sin(F dt / 2).\n// The site index n is counted from C.\nfunction kernel(S) {\n  const F = S.F, a = (4 / F) * sin((F * DT) / 2), b = new Float64Array(MB + 1);\n  besselSmall(a, b);\n  for (let m = -MB; m \u003c= MB; m++) {\n    const Jm = m >= 0 ? b[m] : m & 1 ? -b[-m] : b[-m], p = m * (PI / 2 - (F * DT) / 2);\n    S.kr[m + MB] = Jm * cos(p);\n    S.ki[m + MB] = Jm * sin(p);\n  }\n  S.kF = F;\n}\n\nfunction step(S) {\n  if (S.kF !== S.F) kernel(S);\n  const { re, im, nr, ni, kr, ki } = S, F = S.F;\n  for (let n = 0; n \u003c NS; n++) {\n    let sr = 0, si = 0;\n    const lo = max(-MB, -n), hi = min(MB, NS - 1 - n);\n    for (let m = lo; m \u003c= hi; m++) {\n      const a = kr[m + MB], b = ki[m + MB], x = re[n + m], y = im[n + m];\n      sr += a * x - b * y;\n      si += a * y + b * x;\n    }\n    const p = -F * (n - C) * DT, c = cos(p), s = sin(p);\n    nr[n] = sr * c - si * s;\n    ni[n] = sr * s + si * c;\n  }\n  re.set(nr);\n  im.set(ni);\n}\n\n// A packet on the middle site: a Gaussian of width sigma (one site at 0)\n// with momentum pi / 2, so a broad one starts at full speed to the right\n// and swings evenly about the middle.\nfunction launch(S) {\n  const sg = S.wid, { re, im } = S;\n  let nrm = 0;\n  for (let n = 0; n \u003c NS; n++) {\n    const x = n - C, g = sg > 0 ? exp(-(x * x) / (4 * sg * sg)) : x === 0 ? 1 : 0;\n    re[n] = g * cos((PI / 2) * x);\n    im[n] = g * sin((PI / 2) * x);\n    nrm += g * g;\n  }\n  nrm = 1 / sqrt(nrm);\n  for (let n = 0; n \u003c NS; n++) (re[n] *= nrm), (im[n] *= nrm);\n  S.launched = S.wid;\n}\n\n// One row: SUB steps, probability averaged over them, phase at the last.\nfunction row(S) {\n  const { acc, re, im } = S;\n  acc.fill(0);\n  for (let k = 0; k \u003c SUB; k++) {\n    step(S);\n    for (let x = 0; x \u003c W; x++) {\n      const n = C - 32 + x;\n      acc[x] += (re[n] * re[n] + im[n] * im[n]) / SUB;\n    }\n  }\n  // Half the probability left the panel after a turn of Force mid-swing:\n  // start again from the middle.\n  let on = 0;\n  for (let x = 0; x \u003c W; x++) on += acc[x];\n  if (on \u003c 0.5) launch(S);\n  const o = S.head * W;\n  for (let x = 0; x \u003c W; x++) {\n    const n = C - 32 + x;\n    S.rho[o + x] = acc[x];\n    // The local quasi-momentum, the phase step from this site to the next.\n    S.ph[o + x] = atan2(re[n] * im[n + 1] - im[n] * re[n + 1], re[n] * re[n + 1] + im[n] * im[n + 1]);\n  }\n  S.head = (S.head + 1) % H;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.16, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.F = cl(k[2], 0.16, 0.64);\n  // Width: one site up to 0.1, then sigma = 6 u^2 sites, so the turn from\n  // breathing to swinging (sigma 0.5 to 2) gets the first half of the knob.\n  const u = max(0, (cl(k[3], 0, 1) - 0.1) / 0.9);\n  S.wid = 6 * u * u;\n  if (!S.begun) {\n    launch(S);\n    for (let r = 0; r \u003c H; r++) row(S);\n    S.begun = true;\n  }\n  if (abs(S.wid - S.launched) > 1e-6) launch(S);\n  S.prog += d * S.speed * RATE;\n  while (S.prog >= 1) {\n    S.prog -= 1;\n    row(S);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rho, ph, rgb } = S, hb = 0.55 + S.hue;\n  for (let y = 0; y \u003c H; y++) {\n    const r = (S.head + y) % H;\n    for (let x = 0; x \u003c W; x++) {\n      const p = r * W + x, o = (y * W + x) * 3;\n      const L = cl((Math.log10(rho[p] + 1e-12) - LMIN) / LSPAN, 0, 1);\n      if (L \u003c= 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n      // k round the wheel, with orange given a narrower slice of it. Dim\n      // orange and yellow read brown and olive, so there they are lifted\n      // and paled toward peach and butter.\n      const u = hb + ph[p] / (2 * PI), h = u + 0.07 * sin(2 * PI * (u - 0.11));\n      const wm = cl(1 - abs(h - floor(h) - 0.12) / 0.1, 0, 1);\n      hsv(h, (0.85 - 0.45 * L * L) * (1 - 0.3 * wm), min(1, (0.06 + 0.94 * L) * (1 + 0.35 * wm)), rgb, o);\n    }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(255 * rgb[o]), round(255 * rgb[o + 1]), round(255 * rgb[o + 2]));\n}\n","dead-leaves":"// ===== Patternflow pattern =====\n// Title:   Dead Leaves\n// Family:  noise\n// Idea:    Flat discs with radii from half an LED to 20 LEDs come down one after another, each slipping in under the ones already there so it shows only in the gaps, until the last hole closes, a white ring runs out from it and the panel holds an exact sample of the scale-invariant dead leaves picture, where hue gives each leaf's size and every octave of size covers the same share.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: dead leaves model (Georges Matheron, 1968), scale invariant with radii by r^-3 (Ann Lee, David Mumford and Jinggang Huang, 2001), sampled exactly from below (Wilfrid Kendall and Elke Thönnes, 1999), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Grain=0.5..4, Law=-1..1\n//\n// Knob 1: Hue. Turns the size colours round the wheel together. At 0 leaves of radius half an LED are pink-magenta and each doubling of the radius steps 0.072 back round the wheel, through violet and blue to cyan at 16 to 20 LEDs; at 0.25 the small leaves are orange-red and the big ones violet, at 0.5 green down to red, at 0.75 blue down to lime. A leaf whose hue falls between orange and yellow takes only the two bright levels, so it never reads brown or olive.\n// Knob 2: Speed. At 2 the leaves come down 3.2 deep a second, about 4,900 leaves a second at the opening Grain: the panel is 95% covered after 0.9 s and the last hole closes after 2.8 s (median of 40 samples, 2.3 to 3.2 s for the middle 80%), and the white ring runs out at 60 LEDs a second while the finished sample holds 2.2 s before the next one starts under it, the old leaves showing through its holes one level darker and greyed. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Grain. The smallest radius, 0.5 to 4 LEDs. At 0.5 a sample takes about 13,500 leaves and the five octaves of radius from half an LED to 16 each cover 19 to 20% of the panel; at 4 only the octaves from 4 up are left, 500 leaves make a sample, and the picture is big overlapping discs in blue and cyan.\n// Knob 4: Law. The exponent a of the radius density r^-a, 3 + K4 outside a dead zone of 0.1 either side of 0, so the opening 0.06 is exactly 3, the law under which the picture looks the same at every scale. At -1 (a = 2) the big leaves take over: radii 8 to 16 cover 42% of the panel and those under 1 LED 2.5%. At 1 (a = 4) the smallest octave covers 51% and the panel turns to magenta grain.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, PI, ceil } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The largest leaf's radius in LEDs.\nconst RMAX = 20;\n// Leaf depth per second at Speed 1: how many leaves, on average, have come\n// down over any one LED. The uncovered share is e^-depth.\nconst RATE = 1.6;\n// Seconds the finished sample holds at Speed 1, and how fast the ring runs\n// out, in LEDs a second at Speed 1.\nconst HOLD = 4.4, RING = 30;\n// Every leaf is one of four flat levels, 45 apart. The holes show the\n// sample before, each leaf one level down and greyed, so two leaves side by\n// side, old or new, either match in level or differ by 45 or more.\nconst TIERS = [255, 210, 165, 120, 75], OLD_SAT = 0.35;\n// Hue tells a leaf's size: the smallest, half an LED across in radius, are\n// magenta at the opening, and each doubling of the radius steps OCT back\n// round the wheel, through violet, blue and cyan to green at 20 LEDs. Each\n// leaf strays a little either side, by up to JIT.\nconst H0 = 0.88, OCT = 0.072, JIT = 0.03;\n// Dim orange and yellow read brown and olive: a leaf whose hue falls there\n// takes one of the two bright tiers instead.\nconst warm = (h) => ((h = h - floor(h)), h > 0.03 && h \u003c 0.22);\n\n// hsv with an integer value v: the brightest channel is v exactly.\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = (v * (1 - s) + 0.5) | 0, q = (v * (1 - f * s) + 0.5) | 0, t = (v * (1 - (1 - f) * s) + 0.5) | 0;\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nfunction sample() {\n  return {\n    id: new Int32Array(N).fill(-1), left: N, n: 0, depth: 0,\n    cx: [], cy: [], r: [], hu: [], sa: [], lv: [],\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    cur: sample(), old: null, hue: 0, speed: 2, rmin: 0.5, alpha: 3,\n    phase: 0, pt: 0, last: [32, 64], rgb: new Uint8Array(N * 3),\n  };\n}\n\n// One radius from the density r^-alpha on [rmin, RMAX], by inverting its\n// distribution function.\nfunction radius(a, alpha) {\n  const u = Math.random();\n  if (abs(alpha - 1) \u003c 1e-6) return a * (RMAX / a) ** u;\n  const e = 1 - alpha, lo = a ** e, hi = RMAX ** e;\n  return (lo + u * (hi - lo)) ** (1 / e);\n}\n\n// The leaves are a Poisson process of discs. Only those that reach the\n// panel matter: a leaf of radius r reaches it when its centre lies in the\n// panel grown by r on every side, so radii are drawn from r^-alpha times\n// that box's area (by rejection) and the centre is uniform in the box. A\n// leaf then adds pi r^2 / box to the mean depth over every LED.\nfunction leaf(S, D) {\n  const big = (W + 2 * RMAX) * (H + 2 * RMAX);\n  let r, box;\n  do {\n    r = radius(S.rmin, S.alpha);\n    box = (W + 2 * r) * (H + 2 * r);\n  } while (Math.random() * big > box);\n  const cx = -r + Math.random() * (W + 2 * r), cy = -r + Math.random() * (H + 2 * r);\n  D.depth += (PI * r * r) / box;\n  // Seen from below: the leaf shows only on LEDs no earlier leaf covers.\n  const k = D.n++;\n  D.cx.push(cx);\n  D.cy.push(cy);\n  D.r.push(r);\n  D.hu.push(-OCT * Math.log2(r / 0.5) + (Math.random() - 0.5) * 2 * JIT);\n  D.sa.push(0.55 + 0.35 * Math.random());\n  D.lv.push(floor(Math.random() * TIERS.length));\n  const x0 = max(0, ceil(cx - r - 0.5)), x1 = min(W - 1, floor(cx + r - 0.5));\n  const y0 = max(0, ceil(cy - r - 0.5)), y1 = min(H - 1, floor(cy + r - 0.5));\n  const r2 = r * r, id = D.id;\n  for (let y = y0; y \u003c= y1; y++) {\n    const dy = y + 0.5 - cy;\n    for (let x = x0; x \u003c= x1; x++) {\n      const p = y * W + x;\n      if (id[p] >= 0) continue;\n      const dx = x + 0.5 - cx;\n      if (dx * dx + dy * dy > r2) continue;\n      id[p] = k;\n      if (--D.left === 0) S.last = [x, y];\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.rmin = cl(kv[2], 0.5, 4);\n  // Law: a dead zone of 0.1 round the middle keeps the exponent at 3.\n  const k4 = cl(kv[3], -1, 1), e = abs(k4) > 0.1 ? (Math.sign(k4) * (abs(k4) - 0.1)) / 0.9 : 0;\n  S.alpha = 3 + e;\n  const g = d * S.speed;\n  if (S.phase === 1) {\n    S.pt += g;\n    if (S.pt > HOLD) {\n      // The held sample steps one level down and greys. It shows through\n      // the holes of the next one until they close.\n      S.old = S.cur;\n      S.cur = sample();\n      S.phase = 0;\n    }\n  }\n  if (S.phase === 0) {\n    const D = S.cur, goal = D.depth + g * RATE;\n    while (D.left > 0 && D.depth \u003c goal) leaf(S, D);\n    if (D.left === 0) (S.phase = 1), (S.pt = 0);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, D = S.cur, O = S.old, hb = H0 + S.hue;\n  const ring = S.phase === 1 ? S.pt * RING : -1, [lx, ly] = S.last;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3;\n      let k = D.id[p], L = D;\n      if (k \u003c 0 && O) (L = O), (k = O.id[p]);\n      if (k \u003c 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n      const h = hb + L.hu[k], t = L.lv[k], fresh = L === D, v = TIERS[(warm(h) ? t & 1 : t) + (fresh ? 0 : 1)];\n      // Each leaf pales toward its centre, so a disc reads as a disc even\n      // where only a sliver of it shows. Only the weaker channels change.\n      const dx = x + 0.5 - L.cx[k], dy = y + 0.5 - L.cy[k], f = min(1, sqrt(dx * dx + dy * dy) / L.r[k]);\n      hsv(h, L.sa[k] * (0.6 + 0.4 * f) * (fresh ? 1 : OLD_SAT), v, rgb, o);\n    }\n  // The moment the last hole closes the sample is exact: a white ring runs\n  // out from where that hole was.\n  if (ring >= 0) {\n    for (let y = 0, p = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++, p++) {\n        const dd = sqrt((x - lx) ** 2 + (y - ly) ** 2);\n        if (dd \u003c= ring && dd > ring - 1.5) rgb[p * 3] = rgb[p * 3 + 1] = rgb[p * 3 + 2] = 255;\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o], rgb[o + 1], rgb[o + 2]);\n}\n","elliptic-law":"// ===== Patternflow pattern =====\n// Title:   Elliptic Law\n// Family:  particle\n// Idea:    The eigenvalues of a random real matrix whose entries wander drift as glowing particles inside an ellipse that stands up the panel, mirrored in pairs across the real axis down its middle, and whenever a mirrored pair meets on the axis it splits into two real eigenvalues that run apart along it, or two real ones meet and leave it as a pair.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: circular law (Jean Ginibre, 1965; Vyacheslav Girko, 1984), elliptic law (Hans-Jürgen Sommers, Andrea Crisanti, Haim Sompolinsky and Yaakov Stein, 1988), real eigenvalues of a real Gaussian matrix (Alan Edelman, Eric Kostlan and Michael Shub, 1994), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tau=0.333..1, Size=40..80\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the complex eigenvalues are cyan over a deep blue glow and the real ones pale violet, at 0.25 violet and red, at 0.5 rose and green, at 0.75 green and azure. The wheel skips the orange and yellow stretch, which reads brown when dim.\n// Knob 2: Speed. How fast the matrix entries wander. At 2 an entry's correlation with where it was first falls to zero after 4.9 s, an eigenvalue in the middle of the ellipse moves about 12 LEDs a second, and somewhere on the axis a pair meets or parts about 6.5 times a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Tau. The correlation between the entries J_ij and J_ji, from 1/3 to 1. The ellipse has half-axes 1 + Tau along the real axis and 1 - Tau across it, drawn so the real half-axis is always 61 LEDs: at 1/3 it is 61 LEDs wide and fills the panel, at 0.6 30 wide, at 0.8 14, and at 1 the matrix is symmetric and every eigenvalue lies on the axis. A 40 x 40 matrix has 7.6 real eigenvalues on average at 1/3, 10.4 at 0.6 and 15.1 at 0.8 (4,000 matrices each).\n// Knob 4: Size. The matrix is 40 x 40 to 80 x 80. The ellipse stays the same size and fills more evenly, and the share of real eigenvalues falls: at Tau 1/3 a 40 x 40 matrix has 7.6 of them on average and an 80 x 80 one 10.5, close to Peter Forrester and Taro Nagao's sqrt(2N/pi (1 + Tau)/(1 - Tau)) (2008), which gives 7.1 and 10.1.\n\nconst W = 64, H = 128, NPX = W * H, NM = 80;\nconst { floor, min, max, sqrt, exp, sin, cos, log, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The real half-axis in LEDs, and the centre of the panel.\nconst RPX = 61, CX = 32, CY = 64;\n// Entry clock: units of the entries' own time per second at Speed 1. In one\n// unit a resting entry turns one radian of its oscillation (below).\nconst RATE = 0.22;\n// Damping of each entry's velocity, per unit of entry time.\nconst GAMMA = 0.8;\n// Short trails fade by e in TRAIL seconds, the long exposure in EXPO.\nconst TRAIL = 0.3, EXPO = 3.5;\n// A spark where a pair met on the axis lasts this long.\nconst SPARK = 0.4;\n\nfunction gauss() {\n  let u = 0;\n  while (u \u003c 1e-12) u = Math.random();\n  return sqrt(-2 * log(u)) * cos(TAU * Math.random());\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel skips 0.03..0.18, orange through yellow, which reads brown and\n// olive when dim, and runs the rest a little faster.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const g = new Float64Array(NM * NM), v = new Float64Array(NM * NM);\n  for (let i = 0; i \u003c NM * NM; i++) (g[i] = gauss()), (v[i] = gauss());\n  params.s = {\n    g, v, hue: 0, speed: 2, tau: 1 / 3, n: 40,\n    a: new Float64Array(NM * NM), wr: new Float64Array(NM), wi: new Float64Array(NM),\n    // Eigenvalues as LED positions, this frame and last.\n    px: new Float32Array(NM), py: new Float32Array(NM), re: new Uint8Array(NM),\n    qx: new Float32Array(NM), qy: new Float32Array(NM), qre: new Uint8Array(NM), qn: 0,\n    trail: new Float32Array(NPX * 3), expo: new Float32Array(NPX * 2), rgb: new Float32Array(NPX * 3), flash: [],\n    pal: new Float32Array(15), palHue: -1, solved: false, fails: 0,\n  };\n}\n\n// Each entry of the matrix is built from N(0, 1) numbers g that move as the\n// position of a damped oscillator kicked by noise, a two-dimensional\n// Ornstein-Uhlenbeck process whose resting law is N(0, 1) for g and its\n// velocity v alike. A step of h units turns (g, v) by h radians, which keeps\n// that law, then takes v through an exact Ornstein-Uhlenbeck step, which keeps it\n// too; so at every moment the matrix is a fresh draw of the ensemble, and\n// g moves smoothly enough for the eigenvalues to glide instead of jitter.\nfunction wander(S, h) {\n  const { g, v, n } = S, c = cos(h), s = sin(h), e = exp(-GAMMA * h), k = sqrt(1 - e * e);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0, o = i * NM; j \u003c n; j++, o++) {\n      const a = g[o], b = v[o];\n      g[o] = a * c + b * s;\n      v[o] = (b * c - a * s) * e + k * gauss();\n    }\n}\n\n// The elliptic ensemble from those numbers: above the diagonal g holds the\n// symmetric parts, below it the antisymmetric ones, so\n//   J_ij = (c1 g_ij + c2 g_ji) / sqrt N,  J_ji = (c1 g_ij - c2 g_ji) / sqrt N,\n// with c1^2 = (1 + tau)/2 and c2^2 = (1 - tau)/2: every entry has variance\n// 1/N and E J_ij J_ji = tau/N.\nfunction build(S) {\n  const { g, a, n, tau } = S, r = 1 / sqrt(n), c1 = sqrt((1 + tau) / 2) * r, c2 = sqrt((1 - tau) / 2) * r;\n  for (let i = 0; i \u003c n; i++) {\n    a[i * n + i] = sqrt(1 + tau) * g[i * NM + i] * r;\n    for (let j = i + 1; j \u003c n; j++) {\n      const p = g[i * NM + j], q = g[j * NM + i];\n      a[i * n + j] = c1 * p + c2 * q;\n      a[j * n + i] = c1 * p - c2 * q;\n    }\n  }\n}\n\n// Reduction to upper Hessenberg form by stabilised elementary similarity\n// transforms (row and column swaps, then elimination below the subdiagonal).\nfunction hessenberg(a, n) {\n  for (let m = 1; m \u003c n - 1; m++) {\n    let x = 0, i = m;\n    for (let j = m; j \u003c n; j++) if (abs(a[j * n + m - 1]) > abs(x)) (x = a[j * n + m - 1]), (i = j);\n    if (i !== m) {\n      for (let j = m - 1; j \u003c n; j++) {\n        const t = a[i * n + j];\n        a[i * n + j] = a[m * n + j];\n        a[m * n + j] = t;\n      }\n      for (let j = 0; j \u003c n; j++) {\n        const t = a[j * n + i];\n        a[j * n + i] = a[j * n + m];\n        a[j * n + m] = t;\n      }\n    }\n    if (x === 0) continue;\n    for (i = m + 1; i \u003c n; i++) {\n      let y = a[i * n + m - 1];\n      if (y === 0) continue;\n      y /= x;\n      a[i * n + m - 1] = y;\n      for (let j = m; j \u003c n; j++) a[i * n + j] -= y * a[m * n + j];\n      for (let j = 0; j \u003c n; j++) a[j * n + m] += y * a[j * n + i];\n    }\n  }\n}\n\n// Francis's implicit double-shift QR on the Hessenberg matrix, eigenvalues\n// only. Each sweep chases a 3 x 3 Householder bulge down the subdiagonal\n// with the two shifts the trailing 2 x 2 block gives, a pair of complex\n// conjugates kept in real arithmetic; a small subdiagonal entry splits off\n// one real eigenvalue or a 2 x 2 block whose roots are a real pair or a\n// conjugate pair. Real roots come back with wi exactly 0.\nfunction francis(a, n, wr, wi) {\n  let nn = n - 1, t = 0, anorm = 0, p = 0, q = 0, r = 0, x, y, z, w, s, u, v, l, m;\n  for (let i = 0; i \u003c n; i++) for (let j = max(i - 1, 0); j \u003c n; j++) anorm += abs(a[i * n + j]);\n  while (nn >= 0) {\n    let its = 0;\n    do {\n      for (l = nn; l > 0; l--) {\n        s = abs(a[(l - 1) * n + l - 1]) + abs(a[l * n + l]);\n        if (s === 0) s = anorm;\n        if (abs(a[l * n + l - 1]) + s === s) {\n          a[l * n + l - 1] = 0;\n          break;\n        }\n      }\n      x = a[nn * n + nn];\n      if (l === nn) {\n        wr[nn] = x + t;\n        wi[nn--] = 0;\n      } else {\n        y = a[(nn - 1) * n + nn - 1];\n        w = a[nn * n + nn - 1] * a[(nn - 1) * n + nn];\n        if (l === nn - 1) {\n          p = 0.5 * (y - x);\n          q = p * p + w;\n          z = sqrt(abs(q));\n          x += t;\n          if (q >= 0) {\n            z = p + (p >= 0 ? z : -z);\n            wr[nn - 1] = wr[nn] = x + z;\n            if (z) wr[nn] = x - w / z;\n            wi[nn - 1] = wi[nn] = 0;\n          } else {\n            wr[nn - 1] = wr[nn] = x + p;\n            wi[nn - 1] = -(wi[nn] = z);\n          }\n          nn -= 2;\n        } else {\n          if (its === 60) return false;\n          // Exceptional shifts after 10 and 20 sweeps without a split.\n          if (its === 10 || its === 20) {\n            t += x;\n            for (let i = 0; i \u003c= nn; i++) a[i * n + i] -= x;\n            s = abs(a[nn * n + nn - 1]) + abs(a[(nn - 1) * n + nn - 2]);\n            y = x = 0.75 * s;\n            w = -0.4375 * s * s;\n          }\n          ++its;\n          // Where the bulge can start: two small subdiagonals in a row.\n          for (m = nn - 2; m >= l; m--) {\n            z = a[m * n + m];\n            r = x - z;\n            s = y - z;\n            p = (r * s - w) / a[(m + 1) * n + m] + a[m * n + m + 1];\n            q = a[(m + 1) * n + m + 1] - z - r - s;\n            r = a[(m + 2) * n + m + 1];\n            s = abs(p) + abs(q) + abs(r);\n            p /= s;\n            q /= s;\n            r /= s;\n            if (m === l) break;\n            u = abs(a[m * n + m - 1]) * (abs(q) + abs(r));\n            v = abs(p) * (abs(a[(m - 1) * n + m - 1]) + abs(z) + abs(a[(m + 1) * n + m + 1]));\n            if (u + v === v) break;\n          }\n          for (let i = m; i \u003c nn - 1; i++) {\n            a[(i + 2) * n + i] = 0;\n            if (i !== m) a[(i + 2) * n + i - 1] = 0;\n          }\n          // Chase the bulge.\n          for (let k = m; k \u003c nn; k++) {\n            if (k !== m) {\n              p = a[k * n + k - 1];\n              q = a[(k + 1) * n + k - 1];\n              r = k + 1 !== nn ? a[(k + 2) * n + k - 1] : 0;\n              if ((x = abs(p) + abs(q) + abs(r)) !== 0) (p /= x), (q /= x), (r /= x);\n            }\n            const sg = sqrt(p * p + q * q + r * r);\n            if ((s = p >= 0 ? sg : -sg) === 0) continue;\n            if (k === m) {\n              if (l !== m) a[k * n + k - 1] = -a[k * n + k - 1];\n            } else a[k * n + k - 1] = -s * x;\n            p += s;\n            x = p / s;\n            y = q / s;\n            z = r / s;\n            q /= p;\n            r /= p;\n            for (let j = k; j \u003c= nn; j++) {\n              p = a[k * n + j] + q * a[(k + 1) * n + j];\n              if (k + 1 !== nn) {\n                p += r * a[(k + 2) * n + j];\n                a[(k + 2) * n + j] -= p * z;\n              }\n              a[(k + 1) * n + j] -= p * y;\n              a[k * n + j] -= p * x;\n            }\n            const top = nn \u003c k + 3 ? nn : k + 3;\n            for (let i = l; i \u003c= top; i++) {\n              p = x * a[i * n + k] + y * a[i * n + k + 1];\n              if (k + 1 !== nn) {\n                p += z * a[i * n + k + 2];\n                a[i * n + k + 2] -= p * r;\n              }\n              a[i * n + k + 1] -= p * q;\n              a[i * n + k] -= p;\n            }\n          }\n        }\n      }\n    } while (l \u003c nn - 1);\n  }\n  return true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1 / 3, 40], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.tau = cl(kv[2], 1 / 3, 1);\n  S.n = cl(floor(kv[3] + 0.5), 40, NM);\n  wander(S, d * S.speed * RATE);\n  build(S);\n  hessenberg(S.a, S.n);\n  // A failed solve keeps last frame's eigenvalues; none failed in 18,000\n  // frames at the knobs' ends.\n  if (!francis(S.a, S.n, S.wr, S.wi)) {\n    S.fails++;\n    return;\n  }\n  // Last frame's positions, for the trails and to spot a meeting on the axis.\n  S.qx.set(S.px);\n  S.qy.set(S.py);\n  S.qre.set(S.re);\n  S.qn = S.solved ? S.qn : 0;\n  const sc = RPX / (1 + S.tau);\n  for (let k = 0; k \u003c S.n; k++) {\n    S.px[k] = CX + S.wi[k] * sc;\n    S.py[k] = CY - S.wr[k] * sc;\n    S.re[k] = S.wi[k] === 0 ? 1 : 0;\n  }\n  const qn = S.qn;\n  S.qn = S.n;\n  S.solved = true;\n  // An eigenvalue whose nearest one last frame was of the other kind has\n  // just crossed over: a real one born from a conjugate pair meeting on the\n  // axis, or a complex one from two real ones meeting. A spark marks where.\n  if (qn === S.n)\n    for (let k = 0; k \u003c S.n; k++) {\n      let best = 1e9, bj = -1;\n      for (let j = 0; j \u003c qn; j++) {\n        const dx = S.qx[j] - S.px[k], dy = S.qy[j] - S.py[k], e = dx * dx + dy * dy;\n        if (e \u003c best) (best = e), (bj = j);\n      }\n      if (bj \u003c 0 || S.qre[bj] === S.re[k] || best > 36) continue;\n      const fy = S.re[k] ? S.py[k] : S.qy[bj];\n      if (S.flash.some((f) => abs(f.y - fy) \u003c 3 && f.age \u003c 0.2)) continue;\n      if (S.flash.length \u003c 12) S.flash.push({ y: fy, age: 0, real: S.re[k] });\n    }\n  for (const f of S.flash) f.age += d;\n  S.flash = S.flash.filter((f) => f.age \u003c SPARK);\n  S.dt = d;\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  hsv(wheel(0.58 + h), 0.75, 1, P, 0); // complex heads and trails\n  hsv(wheel(0.9 + h), 0.6, 1, P, 3); // real heads and trails\n  hsv(wheel(0.63 + h), 0.85, 1, P, 6); // long exposure, complex\n  hsv(wheel(0.92 + h), 0.7, 1, P, 9); // long exposure, real\n  hsv(wheel(0.6 + h), 0.5, 1, P, 12); // the law's ellipse\n  S.palHue = S.hue;\n}\n\n// A point spread over its four nearest LEDs by how close it falls.\nfunction splat(buf, x, y, c0, c1, c2, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const k = (dx ? tx : 1 - tx) * wy * a, p = (yy * W + xx) * 3;\n      buf[p] = max(buf[p], c0 * k);\n      buf[p + 1] = max(buf[p + 1], c1 * k);\n      buf[p + 2] = max(buf[p + 2], c2 * k);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.solved) return;\n  if (S.palHue !== S.hue) palette(S);\n  const P = S.pal, n = S.n, tr = S.trail, ex = S.expo, rgb = S.rgb, d = S.dt || 1 / 30;\n  // Trails and exposure fade with panel time, so they keep their length in\n  // LEDs at any Speed.\n  const ft = exp(-d / TRAIL), fe = exp(-d / EXPO);\n  for (let i = 0; i \u003c NPX * 3; i++) tr[i] *= ft;\n  for (let i = 0; i \u003c NPX * 2; i++) ex[i] *= fe;\n  // Each eigenvalue draws a line back to the nearest of last frame's, and\n  // drops a little light into the long exposure, which builds up the\n  // ellipse's even density and the line of real eigenvalues.\n  for (let k = 0; k \u003c n; k++) {\n    const x = S.px[k], y = S.py[k], o = S.re[k] ? 3 : 0;\n    let best = 1e9, bx = x, by = y;\n    for (let j = 0; j \u003c S.qn; j++) {\n      const dx = S.qx[j] - x, dy = S.qy[j] - y, e = dx * dx + dy * dy;\n      if (e \u003c best) (best = e), (bx = S.qx[j]), (by = S.qy[j]);\n    }\n    if (best > 100) (bx = x), (by = y);\n    const m = Math.ceil(sqrt((bx - x) ** 2 + (by - y) ** 2) * 2) || 1;\n    for (let e = 0; e \u003c= m; e++) splat(tr, bx + ((x - bx) * e) / m, by + ((y - by) * e) / m, P[o] * 0.8, P[o + 1] * 0.8, P[o + 2] * 0.8, 1.6);\n    const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, ch = S.re[k] ? 1 : 0;\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const xx = ix + dx, yy = iy + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        ex[(yy * W + xx) * 2 + ch] += (dx ? tx : 1 - tx) * (dy ? ty : 1 - ty) * d * (ch ? 3 : 24);\n      }\n  }\n  // The law: the ellipse with half-axes 1 + tau and 1 - tau, a thin line.\n  const sc = RPX / (1 + S.tau), ah = (1 - S.tau) * sc, bh = (1 + S.tau) * sc;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3;\n      let R = tr[o], G = tr[o + 1], B = tr[o + 2];\n      // Exposure, through a soft knee so a busy spot does not burn out.\n      const e0 = ex[p * 2], e1 = ex[p * 2 + 1];\n      const k0 = 0.4 * (1 - exp(-e0 * 1.4)), k1 = 0.5 * (1 - exp(-e1 * 1.2));\n      R += P[6] * k0 + P[9] * k1;\n      G += P[7] * k0 + P[10] * k1;\n      B += P[8] * k0 + P[11] * k1;\n      // Distance to the ellipse, roughly in LEDs.\n      const u = (x + 0.5 - CX) / max(ah, 0.3), v = (y + 0.5 - CY) / bh, rr = sqrt(u * u + v * v);\n      const gx = u / max(ah, 0.3), gy = v / bh, gl = sqrt(gx * gx + gy * gy) || 1;\n      const dist = (abs(rr - 1) * rr) / gl;\n      if (dist \u003c 1.2 && ah > 1) {\n        const a = 0.3 * (1 - dist / 1.2);\n        R += P[12] * a;\n        G += P[13] * a;\n        B += P[14] * a;\n      }\n      (rgb[o] = R), (rgb[o + 1] = G), (rgb[o + 2] = B);\n    }\n  // Sparks where a pair met on the axis: a short bar across the axis that\n  // shrinks as it fades, in the colour of what was born there.\n  for (const f of S.flash) {\n    const u = f.age / SPARK, a = (1 - u) * (1 - u), o = f.real ? 3 : 0, half = 4.5 * (1 - u) + 1;\n    const iy = floor(f.y);\n    for (let dy = -1; dy \u003c= 1; dy++) {\n      const yy = iy + dy;\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let xx = floor(CX - half); xx \u003c CX + half; xx++) {\n        if (xx \u003c 0 || xx >= W) continue;\n        const w = a * (dy ? 0.45 : 1) * min(1, half - abs(xx + 0.5 - CX) + 0.5), q = (yy * W + xx) * 3;\n        for (let e = 0; e \u003c 3; e++) rgb[q + e] += (0.6 + P[o + e]) * w;\n      }\n    }\n  }\n  for (let k = 0; k \u003c n; k++) {\n    const x = S.px[k], y = S.py[k], o = S.re[k] ? 3 : 0;\n    const ix = floor(x - 0.5), iy = floor(y - 0.5);\n    for (let dy = 0; dy \u003c 2; dy++)\n      for (let dx = 0; dx \u003c 2; dx++) {\n        const xx = ix + dx, yy = iy + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const q = (yy * W + xx) * 3;\n        for (let e = 0; e \u003c 3; e++) rgb[q + e] = max(rgb[q + e], 0.45 + P[o + e] * 0.6);\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * min(1, rgb[o])) | 0, (255 * min(1, rgb[o + 1])) | 0, (255 * min(1, rgb[o + 2])) | 0);\n}\n","erdos-discrepancy":"// ===== Patternflow pattern =====\n// Title:   Erdős Discrepancy\n// Family:  rhythm\n// Idea:    A rhythm of hits (+1) and rests (-1) is heard by 64 listeners side by side, listener d taking only every d-th beat, and each writes the running sum of what it hears down its own column, one row a step with the newest at the bottom over a row of the beat itself, so the completely multiplicative rhythm weaves a quiet tartan, one set of nested bands coloured column by column by the rhythm's own signs, while coin-flip beats tear it into loud streaks, and whenever a sum beats the record so far the cells that did it light white.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Erdős discrepancy problem (Paul Erdős, 1932), solved by Terence Tao (2015), with the character-like functions of Peter Borwein, Stephen Choi and Michael Coons (2010), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Prime=3..13\n//\n// Knob 1: Hue. Turns both colours round the wheel together. At 0 sums above zero are aqua and sums below zero magenta, with records and the beat row white; at 0.25 blue and red, at 0.5 pink and green, at 0.75 lime and azure. The wheel skips orange and yellow, which read brown and olive in the dim cells of small sums.\n// Knob 2: Speed. Steps a second, 4 x Speed: 8 at 2, so the 127 rows of carpet turn over in 16 s, 0.8 at 0.2 and 12 at 3. A run goes on to step 6,561 = 3^8, 13.7 minutes at 2, and starts again from the first 128 steps with fresh coin flips.\n// Knob 3: Noise. Each beat is a coin flip instead of the multiplicative rhythm with chance Noise squared: 6% at 0.25, 25% at 0.5, 56% at 0.75, every beat at 1. At 0 every column is plus or minus the same walk, so the carpet is one column of bands times the rhythm's first 64 signs. At step 1,000 the 64 sums average 4 at 0 (all equal in size), 10 at 0.25, 18 at 0.5 and 25 at 0.75 and 1, and the record by then is 6 at 0 against 92 at 1 (mean of eight runs).\n// Knob 4: Prime. The prime p of the character-like rhythm, the one of 3, 5, 7, 11 and 13 nearest the knob: x_n is the residue symbol mod p of n with every factor p taken out. Its running sum is a sum over the base-p digits of the step, so it grows like the digit count: at p = 3 each digit 1 adds one, and the largest sum up to step m is floor(log3(2m + 1)), never above log3 m + 1 (checked to m = 600,000), with the records at m = 1, 4, 13, 40, 121, 364, 1093 and 3280 lighting whole rows. Records by step 6,561 reach 8 at p = 3, 6 at 5, 10 at 7, 11 at 11 and 7 at 13; at 5 and 13 the sums change sign, so the bands swap colours row by row.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Steps a second at Speed 1, and the step at which the walk starts over.\nconst RATE = 4, LAST = 6561;\nconst PRIMES = [3, 5, 7, 11, 13];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Quadratic residues mod p, as +1 / -1 by residue.\nfunction legendre(p) {\n  const t = new Int8Array(p).fill(-1);\n  t[0] = 0;\n  for (let a = 1; a \u003c p; a++) t[(a * a) % p] = 1;\n  return t;\n}\n\n// A 32-bit integer hash, for the coin flips: each beat n has its own draw,\n// fixed for the run, so every listener hears the same beat the same way.\nfunction hash(n) {\n  n = Math.imul(n ^ (n >>> 16), 0x7feb352d);\n  n = Math.imul(n ^ (n >>> 15), 0x846ca68b);\n  return (n ^ (n >>> 16)) >>> 0;\n}\n\nexport function setup(params) {\n  params.s = {\n    M: 0, acc: 0, seed: 0, p: 3, noise: 0, hue: 0, speed: 2, chi: null,\n    cur: new Int32Array(W + 1), ring: new Int16Array(H * W), mark: new Uint8Array(H * W),\n    rec: 0, pal: new Float32Array(2), palHue: -1, key: '',\n  };\n}\n\n// Beat n of the rhythm. Borwein, Choi and Coons' character-like function\n// takes out every factor p and reads the rest as a residue mod p; with\n// Noise the beat is a coin flip instead, with that chance.\nfunction term(S, n) {\n  const h = hash(n + S.seed);\n  if ((h >>> 8) / 16777216 \u003c S.noise) return h & 1 ? 1 : -1;\n  const p = S.p;\n  while (n % p === 0) n /= p;\n  return S.chi[n % p];\n}\n\n// One step m for all 64 listeners: listener d hears beat m d.\nfunction step(S) {\n  const m = ++S.M, row = (m % H) * W, cur = S.cur;\n  let top = 0;\n  for (let d = 1; d \u003c= W; d++) {\n    cur[d] += term(S, m * d);\n    S.ring[row + d - 1] = cur[d];\n    S.mark[row + d - 1] = 0;\n    top = max(top, abs(cur[d]));\n  }\n  // A new record discrepancy: the cells that set it.\n  if (top > S.rec) {\n    S.rec = top;\n    for (let d = 1; d \u003c= W; d++) if (abs(cur[d]) === top) S.mark[row + d - 1] = 1;\n  }\n}\n\n// Start over from step 0 and run up to step `to`, as after a knob turn.\nfunction rebuild(S, to) {\n  S.M = 0;\n  S.rec = 0;\n  S.cur.fill(0);\n  S.ring.fill(0);\n  S.mark.fill(0);\n  while (S.M \u003c to) step(S);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  // The share of coin flips is the knob squared, so the first half of its\n  // turn opens the carpet up gradually.\n  const noise = cl(kv[2], 0, 1) ** 2;\n  // The prime nearest the knob.\n  let p = 3;\n  for (const q of PRIMES) if (abs(q - kv[3]) \u003c abs(p - kv[3])) p = q;\n  if (!S.chi) S.seed = floor(Math.random() * 1e9);\n  // A turned knob rewrites the whole walk so far with the new rhythm.\n  const key = p + ':' + noise.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    S.p = p;\n    S.chi = legendre(p);\n    S.noise = noise;\n    rebuild(S, max(H, S.M));\n  }\n  S.acc += d * S.speed * RATE;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    if (S.M >= LAST) {\n      S.seed = floor(Math.random() * 1e9);\n      rebuild(S, H);\n    } else step(S);\n  }\n}\n\n// The hue wheel skips orange through yellow, which read brown and olive on\n// the dim cells of small sums.\nconst wheel = (h) => 0.25 + 0.78 * (h - floor(h));\nfunction palette(S) {\n  const P = S.pal;\n  P[0] = wheel(0.282 + S.hue); // sums above zero: aqua at Hue 0\n  P[1] = wheel(0.732 + S.hue); // sums below zero: magenta\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.chi) return;\n  if (S.palHue !== S.hue) palette(S);\n  const P = S.pal, c = [0, 0, 0], M = S.M, beat = 1 - S.acc;\n  for (let y = 0; y \u003c H; y++) {\n    // The bottom row plays the newest step; the carpet rises above it, the\n    // newest sums on row 126.\n    const m = y === H - 1 ? M : M - (H - 2 - y), row = (((m % H) + H) % H) * W;\n    // Older rows dim a little toward the top, so the carpet reads as\n    // written from the bottom.\n    const age = 0.7 + 0.3 * (y / (H - 2));\n    for (let x = 0; x \u003c W; x++) {\n      let r = 0, g = 0, b = 0;\n      if (m >= 1 && y === H - 1) {\n        // The beat itself: a hit lights, a rest stays dark, fading over the step.\n        const prev = m > 1 ? S.ring[(((m - 1) % H) * W) + x] : 0;\n        if (S.ring[row + x] > prev) r = g = b = 0.3 + 0.7 * beat;\n      } else if (m >= 1) {\n        const s = S.ring[row + x], a = abs(s);\n        if (S.mark[row + x]) (r = 1), (g = 1), (b = 1);\n        else if (a) {\n          // Brightness climbs from 0.28 at 1 to full at 5, then the colour\n          // whitens a step for each doubling, nearly white past 80.\n          hsv(s > 0 ? P[0] : P[1], 0.9 - 0.7 * cl(Math.log2(a / 5) / 4, 0, 1), min(1, 0.1 + 0.18 * a), c, 0);\n          (r = c[0] * age), (g = c[1] * age), (b = c[2] * age);\n        }\n      }\n      display.setPixel(x, y, (255 * r) | 0, (255 * g) | 0, (255 * b) | 0);\n    }\n  }\n}\n","golomb-trominoes":"// ===== Patternflow pattern =====\n// Title:   Golomb Trominoes\n// Family:  cells\n// Idea:    Two 64 x 64 boards, each short one cell, are tiled with 3-LED L trominoes exactly as Golomb's proof lays them, and as each board's blinking hole walks one LED at a time the trominoes between its old and new place re-lay in a white flash, one tromino inside a 2 x 2 block but up to 63 when it crosses the board's middle, while the field's hue marks the nested L-shaped shells of the proof closing in on the hole.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: tromino tiling of the deficient 2^n board (Solomon W. Golomb, 1954), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lift=0..4, Cell=1..4\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the 2 x 2 trominoes are azure and navy in the outermost shell and turn cyan, aqua, green, lime and yellow shell by shell towards the hole; the 4 x 4 trominoes are plum, 8 x 8 gold, 16 x 16 lime and 32 x 32 rose, and the trominoes the proof lays round the hole, one a level, are white. At 0.5 the shells run orange, red, pink and violet and the levels aqua, blue and violet. The dim colours skip the orange and yellow part of the wheel, which reads brown and olive.\n// Knob 2: Speed. The hole walks 9 LEDs a second for each unit, 18 at the opening 2, on a straight line that reflects off the board's edges. A step that stays inside a 2 x 2 block re-lays that one tromino; a step over the line between two blocks of side 2^k re-lays at most 2^k - 1 trominoes (3, 7, 15, 31, 63) and about two thirds of that on average. At 2 the two holes cross their board's middle at 0.8 s and 0.7 s and then on average every 3.5 s. 0.2 is ten times slower.\n// Knob 3: Lift. Leaves the lowest levels of the proof unlaid. At 0 every tromino is laid; 1 to 4 leave whole blocks of 4, 8, 16 and 32 cells a side (on a 16-cell board no more than 8), each one square in its tone short the one cell that the trominoes above it, or the hole, took. Each such square is the proof's induction hypothesis: a smaller board short one cell, which the same proof tiles.\n// Knob 4: Cell. LEDs to a cell: 1 below 1.5, 2 below 3.5, then 4, so each half of the panel is a board of 64, 32 or 16 cells a side, laid with 1365, 341 or 85 trominoes. The hole still walks 18 LEDs a second at Speed 2, so on the bigger cells it takes fewer, larger steps.\n\n// Each half of the panel is one square board, W LEDs a side.\nconst W = 64, H = 128;\nconst { floor, min, max, exp, round, cos, sin } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Three colours are enough for Golomb's tiling, and they come from the\n// proof itself. The 2 x 2 trominoes fill three quarters of the board in\n// two tones: bright where the block is missing its top left or bottom\n// right cell, dark where it is missing the other two. Two trominoes of the\n// same tone never share an edge, and no two trominoes laid at a bigger\n// level ever touch each other, so those all take the third colour, with\n// its hue by the level that laid them. Checked for every hole of boards\n// 16, 32 and 64 cells wide: the rule breaks on at most four edges, all\n// within two cells of the hole.\n// The field's hue says how far the cell sits from the hole in the proof:\n// its shell is the smallest block holding both, and shell k is the three\n// quarters of the hole's 2^k block that the hole is not in: an L tromino\n// scaled up 2^(k-1) times. Outermost shell azure, then cyan, aqua, green,\n// lime and yellow inwards.\nconst SHUE = [0.6, 0.5, 0.42, 0.34, 0.27, 0.2];\n// Bigger levels: plum for 4 x 4, gold for 8 x 8, lime, rose. The board's\n// middle tromino always lies round the hole and shows white.\nconst LHUE = [0, 0, 0.98, 0.13, 0.3, 0.98, 0.75];\n// Palette slots: 2 (n - shell) + tone for the field (0 bright, 1 dark),\n// 12 + level for levels 2..6, 19 for the trominoes the proof lays round\n// the hole and 20 for the hole.\n// The block sides Lift leaves unlaid: 1 lays every tromino; a 2 x 2 block\n// short one cell is a tromino already, so the next is 4.\nconst LIFT = [0, 2, 3, 4, 5];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips them.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nfunction makeBoard(y0, u, v, ang) {\n  const M = W * W;\n  return {\n    y0, u, v, dx: cos(ang), dy: sin(ang), hx: -1, hy: -1,\n    lev: new Int8Array(M), ori: new Int8Array(M), lev2: new Int8Array(M), ori2: new Int8Array(M),\n    bori: Array.from({ length: 7 }, () => new Int8Array(M)),\n    rgb: new Float32Array(M * 3), flash: new Float32Array(M), fresh: true,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, lift: 0, c: 0, n: 6, S: 64, acc: 0, t: 0,\n    // Two boards, one on each half of the panel, their holes set off on\n    // straight lines that cross the boards' middles early.\n    boards: [makeBoard(0, 0.37, 0.29, 0.56), makeBoard(H - W, 0.71, 0.4, 2.2)],\n    pal: new Float32Array(63), palHue: -1,\n  };\n}\n\n// Golomb's proof as a program: in a block with one cell taken, lay one\n// tromino over the inner corners of the three quarters that do not hold\n// it, and each of those quarters now has a cell taken too. Every cell\n// records the level of the tromino that covers it (the block's side is\n// 2^level) and which corner of the 2 x 2 at the block's centre that\n// tromino leaves out.\nfunction lay(B, n, hx, hy) {\n  const S = 1 \u003c\u003c n, lev = B.lev2, ori = B.ori2;\n  lev[hy * S + hx] = 0;\n  ori[hy * S + hx] = -1;\n  const rec = (x0, y0, L, hx, hy) => {\n    if (!L) return;\n    const h = 1 \u003c\u003c (L - 1), cx = x0 + h, cy = y0 + h, q = (hx >= cx ? 1 : 0) + (hy >= cy ? 2 : 0);\n    B.bori[L][(y0 >> L) * (S >> L) + (x0 >> L)] = q;\n    for (let k = 0; k \u003c 4; k++) {\n      const ix = cx - 1 + (k & 1), iy = cy - 1 + (k >> 1), qx = x0 + (k & 1 ? h : 0), qy = y0 + (k & 2 ? h : 0);\n      if (k === q) rec(qx, qy, L - 1, hx, hy);\n      else {\n        lev[iy * S + ix] = L;\n        ori[iy * S + ix] = q;\n        rec(qx, qy, L - 1, ix, iy);\n      }\n    }\n  };\n  rec(0, 0, n, hx, hy);\n}\n\n// Shell of a cell: the side, as a level, of the smallest block holding both\n// it and the hole.\nconst shellOf = (x, y, hx, hy) => 32 - Math.clz32((x ^ hx) | (y ^ hy));\n\n// Move the hole one cell along its line: whichever of the two grid lines\n// ahead it reaches first. At the board's edge the line reflects.\nfunction step(B, S) {\n  for (let guard = 0; guard \u003c 4; guard++) {\n    const px = B.u * S, py = B.v * S, cx = floor(px), cy = floor(py);\n    const tx = B.dx > 0 ? (cx + 1 - px) / B.dx : B.dx \u003c 0 ? (px - cx) / -B.dx : 1e9;\n    const ty = B.dy > 0 ? (cy + 1 - py) / B.dy : B.dy \u003c 0 ? (py - cy) / -B.dy : 1e9;\n    if (tx \u003c= ty) {\n      const nx = cx + (B.dx > 0 ? 1 : -1);\n      if (nx \u003c 0 || nx >= S) {\n        B.dx = -B.dx;\n        continue;\n      }\n      B.u = (nx + (B.dx > 0 ? 1e-6 : 1 - 1e-6)) / S;\n      B.v = (py + B.dy * tx) / S;\n    } else {\n      const ny = cy + (B.dy > 0 ? 1 : -1);\n      if (ny \u003c 0 || ny >= S) {\n        B.dy = -B.dy;\n        continue;\n      }\n      B.v = (ny + (B.dy > 0 ? 1e-6 : 1 - 1e-6)) / S;\n      B.u = (px + B.dx * ty) / S;\n    }\n    return;\n  }\n}\n\n// Re-lay the board for the hole's cell; every cell whose tromino changed\n// flashes.\nfunction relay(S, B, n) {\n  const N = 1 \u003c\u003c n, hx = cl(floor(B.u * N), 0, N - 1), hy = cl(floor(B.v * N), 0, N - 1);\n  if (hx === B.hx && hy === B.hy && !B.fresh) return;\n  lay(B, n, hx, hy);\n  const M = N * N;\n  for (let p = 0; p \u003c M; p++) {\n    if (!B.fresh && (B.lev[p] !== B.lev2[p] || B.ori[p] !== B.ori2[p])) B.flash[p] = 1;\n    B.lev[p] = B.lev2[p];\n    B.ori[p] = B.ori2[p];\n  }\n  if (B.fresh) B.flash.fill(0), (B.snap = true);\n  B.fresh = false;\n  B.hx = hx;\n  B.hy = hy;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const c = [1, 1, 2, 2, 4][cl(round(kv[3]), 1, 4)];\n  if (c !== S.c) {\n    S.c = c;\n    S.n = 6 - (c === 1 ? 0 : c === 2 ? 1 : 2);\n    S.S = 64 / c;\n    for (const B of S.boards) B.fresh = true;\n  }\n  const n = S.n, N = S.S;\n  S.lift = min(LIFT[cl(round(kv[2]), 0, 4)], n - 1);\n  // The hole walks nine LEDs a second for each unit of Speed, whatever the\n  // cell size.\n  S.t += d;\n  S.acc += (d * S.speed * 9) / c;\n  let steps = floor(S.acc);\n  S.acc -= steps;\n  for (const B of S.boards) {\n    relay(S, B, n);\n    for (let k = 0; k \u003c steps; k++) {\n      step(B, N);\n      relay(S, B, n);\n    }\n    // Each cell eases to its slot's colour in about an eighth of a second,\n    // so a shell that changes hue dissolves into the next; flashes fade.\n    if (S.palHue !== S.hue) palette(S);\n    const P = S.pal, u = S.lift, fv = B.snap ? 1 : min(1, d * 8), ff = exp(-d / 0.25), rgb = B.rgb;\n    B.snap = false;\n    for (let y = 0, p = 0; y \u003c N; y++)\n      for (let x = 0; x \u003c N; x++, p++) {\n        const o = B.ori[p], L = B.lev[p];\n        const sh = shellOf(x, y, B.hx, B.hy);\n        let k;\n        if (o \u003c 0) (k = 20), (B.flash[p] = 0);\n        else if (L === sh && L > u) k = 19;\n        else if (L > max(u, 1)) k = 12 + L;\n        else {\n          // Below the lift a cell takes the tone of its whole unlaid block.\n          const q = u ? B.bori[u][(y >> u) * (N >> u) + (x >> u)] : o;\n          k = 2 * (n - sh) + (q === 0 || q === 3 ? 0 : 1);\n        }\n        for (let e = 0; e \u003c 3; e++) rgb[p * 3 + e] += (P[k * 3 + e] - rgb[p * 3 + e]) * fv;\n        B.flash[p] *= ff;\n      }\n  }\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  for (let k = 0; k \u003c 6; k++) {\n    hsv(SHUE[k] + h, 0.72, 1, P, 6 * k);\n    hsv(wheel(SHUE[k] + 0.05 + h), 0.9, 0.27, P, 6 * k + 3);\n  }\n  // The 4 x 4 trominoes are half bright, so their hue skips orange too.\n  for (let L = 2; L \u003c= 6; L++) hsv(L === 2 ? wheel(LHUE[2] + h) : LHUE[L] + h, 0.75, L === 2 ? 0.62 : 0.95, P, (12 + L) * 3);\n  hsv(0.6 + h, 0.04, 1, P, 57);\n  P[60] = P[61] = P[62] = 0;\n  S.palHue = h;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.c) return;\n  const c = S.c, N = S.S, blink = S.t * 3 - floor(S.t * 3) \u003c 0.5;\n  for (const B of S.boards) {\n    for (let y = 0; y \u003c W; y++) {\n      const cy = floor(y / c);\n      for (let x = 0; x \u003c W; x++) {\n        const p = cy * N + floor(x / c), o = p * 3, r = B.rgb;\n        // The hole blinks white three times a second.\n        const f = B.ori[p] \u003c 0 ? (blink ? 1 : 0) : B.flash[p] * 0.8;\n        display.setPixel(x, B.y0 + y, (255 * (r[o] + (1 - r[o]) * f)) | 0, (255 * (r[o + 1] + (1 - r[o + 1]) * f)) | 0, (255 * (r[o + 2] + (1 - r[o + 2]) * f)) | 0);\n      }\n    }\n  }\n}\n","multiplicative-cascade":"// ===== Patternflow pattern =====\n// Title:   Multiplicative Cascade\n// Family:  fractal\n// Idea:    The panel's mass is halved thirteen times, across and down in turn, down to single LEDs, each half taking a random log-normal weight of mean 1, and every LED shows the log of its own share as light and the share of its 8 x 8 block as hue, so a patchwork of mint and violet rectangles of every size glitters at the LED level while the weights turn over level by level from the two halves down to the single LEDs and mass flows from half to half at each scale; Spread pushes the weights across the Kahane-Peyrière threshold, past which the total mass drains away and what is left gathers into a few sparks.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: multiplicative cascade (Benoit Mandelbrot, 1974), with the degeneracy threshold of Jean-Pierre Kahane and Jacques Peyrière (1976), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=0.4..1.6, Couple=-1..1\n//\n// Knob 1: Hue. Turns the colours round the wheel. At 0 heavy 8 x 8 blocks are mint, middling ones blue and light ones violet, with the heaviest LEDs near white; at 0.25 heavy blocks turn blue and light ones red; at 0.5 heavy ones pink and light ones green; at 0.75 heavy ones yellow and light ones azure. Dim orange and yellow are lifted by up to half so they do not read brown.\n// Knob 2: Speed. The weights turn over one level at a time, from the panel's two halves down to the single LEDs. At 2 a level takes 1.2 s to turn from its old draws to new ones, the next level starts 0.4 s later, and the sweep comes round every 6.4 s. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Spread. tau = E[W log2 W] for each weight W = exp(sigma G - sigma^2 / 2), from 0.4 to 1.6 (sigma 0.74 to 1.49). Kahane and Peyrière's threshold is tau = 1: below it the mass survives every halving, at and above it the total dies away. Medians of 2,000 cascades: at 0.4 the total mass is 0.64 after 7 halvings and 0.61 after 13, 98% of the LEDs show above the black floor and the heaviest 1% hold half the mass; at 1 the total falls from 0.24 to 0.15, half the LEDs show and the top 1% hold 86%; at 1.6 it falls from 0.057 to 0.019, 16% show and the top 1% hold 95%. The floor stays at 1/8100 of an even share, so lost mass shows as dark.\n// Knob 4: Couple. The correlation of the two halves' log weights at every split, -1 to 1. At -1 one half gains in log exactly what the other loses, so mass trades across every split line and each split shows a hard step; at the opening 0.06 the halves are close to independent, Mandelbrot's canonical cascade; at 1 both halves of a split take the same weight, no split line has a step of its own and the patches grow larger and softer. Each weight keeps its own law, so the threshold stays at tau = 1 (John Biggins, 1977), though after 13 halvings at Spread 1 the median total mass is 0.25 at -1, 0.15 at 0 and 0.08 at 1.\n\nconst W = 64, H = 128, N = W * H;\n// Thirteen halvings, across and down in turn, take the panel to single\n// LEDs. Node 1 is the panel, nodes 2n and 2n + 1 the halves of node n, and\n// nodes 8192..16383 the LEDs.\nconst L = 13, NODES = 1 \u003c\u003c (L + 1);\nconst { floor, min, max, sqrt, cos, sin, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The window of log mass shown, in units of the natural log of mass times\n// 8192: 0 is an LED's even share of the panel's mass, LO is shown black and\n// HI white. It does not move with the knobs, so lost mass shows as dark.\nconst LO = -9, HI = 2;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nfunction gauss() {\n  let u = 0;\n  while (u === 0) u = Math.random();\n  return sqrt(-2 * log(u)) * cos(2 * PI * Math.random());\n}\n\n// Which LED each leaf is: bit k of the path from the panel down picks the\n// upper or lower half for odd k and the left or right half for even k.\nconst LED = new Int16Array(N);\nfor (let n = 0; n \u003c N; n++) {\n  let x = 0, y = 0;\n  for (let k = 1; k \u003c= L; k++) {\n    const b = (n >> (L - k)) & 1;\n    if (k & 1) y = y * 2 + b;\n    else x = x * 2 + b;\n  }\n  LED[n] = y * W + x;\n}\n\n// The weights change one level at a time, coarse to fine: level k starts\n// k - 1 steps after the panel's own halves, takes SPAN steps to turn from\n// its old draws to new ones, and the sweep comes round every CYCLE steps.\nconst SPAN = 3, CYCLE = 16, STEPS = 2.5;\n// Steps of block weight in the colour table.\nconst HB = 16;\n\nexport function setup(params) {\n  const S = {\n    hue: -1, speed: 2, tau: 0.4, rho: 0, phi: 0, cyc: new Int32Array(L + 1).fill(-1),\n    a: new Float32Array(NODES), b: new Float32Array(NODES),\n    acc: new Float32Array(NODES), g: new Float32Array(NODES), pal: new Float32Array(HB * 256 * 3),\n  };\n  // Each weight's normal G turns from one draw a to the next b along a\n  // quarter circle, cos(t) a + sin(t) b, which is again standard normal at\n  // every moment, so the cascade's law holds while it moves.\n  for (let n = 2; n \u003c NODES; n++) {\n    S.a[n] = gauss();\n    S.b[n] = gauss();\n  }\n  params.s = S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.tau = cl(kv[2], 0.4, 1.6);\n  S.rho = cl(kv[3], -1, 1);\n  if (kv[0] !== S.hue) palette(S, cl(kv[0], 0, 1));\n  const { a, b, g: G, acc } = S;\n  S.phi += (d * S.speed * STEPS) / 2;\n  for (let k = 1; k \u003c= L; k++) {\n    const sk = S.phi - (k - 1), c = floor(sk / CYCLE), u = sk - c * CYCLE;\n    if (c !== S.cyc[k]) {\n      // A new turn for this level: the old target is the new start.\n      S.cyc[k] = c;\n      for (let n = 1 \u003c\u003c k; n \u003c 2 \u003c\u003c k; n++) {\n        a[n] = b[n];\n        b[n] = gauss();\n      }\n    }\n    const p = cl(u / SPAN, 0, 1), t = (PI / 2) * p * p * (3 - 2 * p), ct = cos(t), st = sin(t);\n    for (let n = 1 \u003c\u003c k; n \u003c 2 \u003c\u003c k; n++) G[n] = ct * a[n] + st * b[n];\n  }\n  // Spread is tau = E[W log2 W]; for W = exp(sigma G - sigma^2 / 2) that is\n  // sigma^2 / (2 ln 2).\n  const sig = sqrt(2 * Math.LN2 * S.tau), half = (sig * sig) / 2;\n  const r = S.rho, r2 = sqrt(1 - r * r);\n  // The first half takes its own normal; the second takes rho times its\n  // sibling's plus its own, so both are standard normal and their\n  // correlation is rho. Each half's log weight adds to its parent's log mass.\n  acc[1] = 0;\n  for (let n = 2; n \u003c NODES; n += 2) {\n    const g1 = G[n], g2 = r * g1 + r2 * G[n + 1], up = acc[n >> 1] - half;\n    acc[n] = up + sig * g1;\n    acc[n + 1] = up + sig * g2;\n  }\n}\n\n// Colour by two depths of the same cascade: the hue says how heavy the\n// LED's 8 x 8 block (seven halvings down) is against a typical block at\n// this Spread, the light says how heavy the LED itself is against an even\n// share. Rows of the table are HB steps of block weight, columns 256 steps\n// of LED weight.\nfunction palette(S, hue) {\n  S.hue = hue;\n  for (let j = 0; j \u003c HB; j++) {\n    const z = (2 * j) / (HB - 1) - 1;\n    for (let i = 0; i \u003c 256; i++) {\n      const v = i / 255;\n      const h = 0.62 + hue - 0.2 * z - 0.05 * v, hh = h - floor(h);\n      // Orange and yellow are lifted so that dim ones do not read brown, and\n      // deep blue is paled a little, since it reads darkest on the LEDs.\n      const warm = max(0, cos(2 * PI * (hh - 0.11))) ** 2, blue = max(0, cos(2 * PI * (hh - 0.67)));\n      const sat = 0.95 - 0.12 * blue - 0.7 * v ** 5;\n      hsv(h, sat, i ? min(1, (0.08 + 0.92 * v) * (1 + 0.5 * warm)) : 0, S.pal, (j * 256 + i) * 3);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { acc, pal } = S, k = 255 / (HI - LO);\n  // A block seven halvings down carries seven weights; its log weight\n  // against an even share has mean -7 sigma^2 / 2 and spread sigma sqrt 7.\n  const sig = sqrt(2 * Math.LN2 * S.tau), m7 = (-7 * sig * sig) / 2, s7 = 1 / (sig * sqrt(7));\n  for (let n = 0; n \u003c N; n++) {\n    const p = LED[n], x = p & 63, y = p >> 6;\n    const v = acc[N + n] - LO;\n    if (v \u003c= 0) {\n      display.setPixel(x, y, 0, 0, 0);\n      continue;\n    }\n    const z = Math.tanh((acc[(N + n) >> 6] - m7) * s7 * 0.8);\n    const c = ((((z + 1) * (HB - 1)) / 2 + 0.5) | 0) * 768 + min(255, (v * k) | 0) * 3;\n    display.setPixel(x, y, (255 * pal[c]) | 0, (255 * pal[c + 1]) | 0, (255 * pal[c + 2]) | 0);\n  }\n}\n","random-organization":"// ===== Patternflow pattern =====\n// Title:   Random Organization\n// Family:  sim\n// Idea:    Disks in a periodic box are sheared, one side sliding up and the other down and back once a cycle, every disk that touched another during the cycle is kicked a short random step, and the share kicked, traced along the bottom, falls cycle by cycle until below a critical strain the box finds places where nobody touches and freezes for good, while above it the flashing never stops.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random organization under periodic shear (Laurent Corté, Paul Chaikin, Jerry Gollub and David Pine, 2008), an absorbing-state phase transition, pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strain=1..4, Density=0.2..0.35\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 calm disks are teal, disks that have touched another this cycle gold, disks touching right now pale gold, a kick flashes white, and the material grid is slate; at 0.25 calm disks are violet and touched ones green, at 0.5 pink and blue, at 0.75 green and magenta. The calm colour skips orange and yellow, which read brown and olive at its level.\n// Knob 2: Speed. Shear cycles a second, 0.75 x Speed: 1.5 at 2, 0.15 at 0.2, 2.25 at 3. At the opening Strain and Density the box froze after a median of 89 cycles over 30 runs, a minute at Speed 2; it then shears on calm for 10 cycles and a fresh box is dropped.\n// Knob 3: Strain. The strain amplitude gamma0, 1 to 4: the panel's side columns travel 32 x gamma0 rows each way and back every cycle, and the grid's squares lean into parallelograms that steep. At the opening Density (83 disks) the median run froze after 89 cycles at 1, 219 at 2 and 504 at 2.5; at 3 half of 8 runs were still going after 6,000 cycles, and at 3.5 and 4 none stopped, with 52% and 63% of the disks kicked every cycle.\n// Knob 4: Density. The disks' area fraction, 0.2 to 0.35: 83 to 146 disks of radius 2.5 LEDs in the 64 x 128 box, added at random or taken away at the end of a cycle. At the opening Strain the median run froze after 89 cycles at 0.2, 216 at 0.24 and 839 at 0.27; at 0.3 none of 8 runs stopped in 6,000 cycles, 44% of the disks kicked every cycle, and 65% at 0.35.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, cos, sin, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Disk radius in LEDs, the kick (a random step up to KICK diameters), the\n// most disks the arrays hold, and the calm cycles held before a fresh box.\nconst R = 2.5, D = 2 * R, KICK = 0.75, NMAX = 260, HOLD = 10;\n// Shear cycles a second at Speed 1.\nconst RATE = 0.75;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob's wheel skips orange through yellow, which reads brown and olive\n// on dim disks.\nconst wheel = (h) => 0.18 + 0.85 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    n: 0, X: new Float64Array(NMAX), Y: new Float64Array(NMAX),\n    first: new Float32Array(NMAX), age: new Float32Array(NMAX), flash: new Float32Array(NMAX),\n    pa: new Int16Array(2048), pb: new Int16Array(2048), lo: new Float32Array(2048), hi: new Float32Array(2048), np: 0,\n    phase: 0, g0: 1, gNext: 1, phi: 0.2, cps: 2, hue: 0, born: false,\n    hist: new Float32Array(W).fill(-1), quiet: 0, cycles: 0, f: 1,\n    rgb: new Float32Array(NP * 3), pal: new Float32Array(18), palHue: -1,\n  };\n}\n\nconst count = (phi) => cl(round((phi * W * H) / (PI * R * R)), 4, NMAX);\n\nfunction scatter(S, i) {\n  S.X[i] = Math.random() * W;\n  S.Y[i] = Math.random() * H;\n  S.age[i] = 0;\n  S.flash[i] = 1;\n}\n\n// A fresh box: disks dropped anywhere, overlaps and all.\nfunction stir(S) {\n  S.n = count(S.phi);\n  for (let i = 0; i \u003c S.n; i++) scatter(S, i);\n  S.hist.fill(-1);\n  S.quiet = 0;\n  S.cycles = 0;\n}\n\n// The whole cycle's contacts, worked out before it starts. Under the shear\n// y -> y + g (x - 32) a pair with reference separation (dx, dy) sits at\n// (dx, dy + g dx), so it touches at strain g when |dy + g dx| \u003c sqrt(D^2 - dx^2).\n// That is an interval of g; where it meets [0, g0] the pair collides this\n// cycle, and its lower end is the strain of first contact. The box is\n// periodic in x and y, and its x images ride the shear with it\n// (Lees-Edwards), so dx is the nearest image and dy is tried a box up and down.\nfunction contacts(S) {\n  const { n, X, Y, first } = S, g0 = S.g0;\n  first.fill(1e9, 0, n);\n  S.np = 0;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++) {\n      let dx = X[j] - X[i];\n      dx -= W * round(dx / W);\n      if (dx >= D || dx \u003c= -D) continue;\n      const h = sqrt(D * D - dx * dx);\n      for (let m = -1; m \u003c= 1; m++) {\n        const dy = Y[j] - Y[i] + m * H;\n        let a, b;\n        if (abs(dx) \u003c 1e-9) {\n          if (abs(dy) >= h) continue;\n          (a = 0), (b = g0);\n        } else {\n          const u = (-h - dy) / dx, v = (h - dy) / dx;\n          (a = max(0, min(u, v))), (b = min(g0, max(u, v)));\n          if (a >= b) continue;\n        }\n        if (a \u003c first[i]) first[i] = a;\n        if (a \u003c first[j]) first[j] = a;\n        if (S.np \u003c 2048) {\n          S.pa[S.np] = i;\n          S.pb[S.np] = j;\n          S.lo[S.np] = a;\n          S.hi[S.np] = b;\n          S.np++;\n        }\n      }\n    }\n}\n\n// End of a cycle, back at zero strain: every disk that touched anyone is\n// moved a random step up to KICK diameters, the rest stay exactly put.\nfunction endCycle(S) {\n  let k = 0;\n  for (let i = 0; i \u003c S.n; i++) {\n    if (S.first[i] > 1e8) {\n      S.age[i] += 1;\n      continue;\n    }\n    k++;\n    const a = Math.random() * TAU, m = Math.random() * KICK * D;\n    S.X[i] = (S.X[i] + m * cos(a) + W) % W;\n    S.Y[i] = (S.Y[i] + m * sin(a) + H) % H;\n    S.age[i] = 0;\n    S.flash[i] = 1;\n  }\n  S.f = S.n ? k / S.n : 0;\n  S.hist.copyWithin(0, 1);\n  S.hist[W - 1] = S.f;\n  S.cycles++;\n  S.quiet = k ? 0 : S.quiet + 1;\n}\n\n// Density turned: disks are added at random or the last ones taken away.\nfunction resize(S) {\n  const want = count(S.phi);\n  while (S.n \u003c want) scatter(S, S.n++);\n  if (S.n > want) S.n = want;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.2], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.cps = cl(kv[1], 0.2, 3);\n  S.gNext = cl(kv[2], 1, 4);\n  S.phi = cl(kv[3], 0.2, 0.35);\n  if (!S.born) {\n    stir(S);\n    S.g0 = S.gNext;\n    contacts(S);\n    S.born = true;\n  }\n  for (let i = 0; i \u003c S.n; i++) S.flash[i] = max(0, S.flash[i] - d * 4);\n  S.phase += d * S.cps * RATE;\n  while (S.phase >= 1) {\n    S.phase -= 1;\n    endCycle(S);\n    if (S.quiet >= HOLD) stir(S);\n    resize(S);\n    S.g0 = S.gNext;\n    contacts(S);\n  }\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  hsv(wheel(h + 0.376), 0.65, 1, P, 0); // calm disks, teal at Hue 0\n  hsv(h + 0.13, 0.85, 0.9, P, 3); // disks that touched this cycle, gold\n  hsv(wheel(h + 0.5), 0.45, 0.3, P, 6); // the sheared material grid\n  hsv(h + 0.13, 0.4, 1, P, 9); // touching right now, pale gold\n  hsv(h + 0.13, 0.55, 0.85, P, 12); // activity trace\n  S.palHue = S.hue;\n}\n\n// One disk at lab centre (cx, cy), soft at the rim, kept brightest per LED.\nfunction disk(S, cx, cy, r, g, b) {\n  const rgb = S.rgb, x0 = floor(cx - R - 1), y0 = floor(cy - R - 1);\n  for (let yy = y0; yy \u003c= y0 + 2 * R + 2; yy++) {\n    const py = ((yy % H) + H) % H, ey = yy + 0.5 - cy;\n    for (let xx = x0; xx \u003c= x0 + 2 * R + 2; xx++) {\n      if (xx \u003c 0 || xx >= W) continue;\n      const ex = xx + 0.5 - cx, k = cl(R + 0.5 - sqrt(ex * ex + ey * ey), 0, 1);\n      if (k \u003c= 0) continue;\n      const p = (py * W + xx) * 3;\n      if (rgb[p] \u003c r * k) rgb[p] = r * k;\n      if (rgb[p + 1] \u003c g * k) rgb[p + 1] = g * k;\n      if (rgb[p + 2] \u003c b * k) rgb[p + 2] = b * k;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  if (S.palHue !== S.hue) palette(S);\n  const P = S.pal, rgb = S.rgb, g = (S.g0 * (1 - cos(TAU * S.phase))) / 2;\n  // How far the strain has reached this cycle: contacts up to here have happened.\n  const reach = S.phase \u003c 0.5 ? g : S.g0;\n  rgb.fill(0);\n  // The material grid: squares 16 LEDs on a side in the unsheared box. The\n  // shear tilts their rows into parallelograms and slides the columns\n  // along themselves.\n  for (let x = 0; x \u003c W; x++) {\n    const off = g * (x + 0.5 - 32);\n    for (let y = 0; y \u003c H; y++) {\n      const v = (((y + 0.5 - off) % 16) + 16) % 16, k = max(cl(1.2 - abs(v - 8), 0, 1), x % 16 === 8 ? 0.6 : 0);\n      if (k \u003c= 0) continue;\n      const p = (y * W + x) * 3;\n      rgb[p] = P[6] * k;\n      rgb[p + 1] = P[7] * k;\n      rgb[p + 2] = P[8] * k;\n    }\n  }\n  // Which disks touch right now.\n  const now = new Uint8Array(S.n);\n  for (let q = 0; q \u003c S.np; q++) if (g > S.lo[q] && g \u003c S.hi[q]) now[S.pa[q]] = now[S.pb[q]] = 1;\n  for (let i = 0; i \u003c S.n; i++) {\n    let o = S.first[i] \u003c= reach ? 3 : 0;\n    if (now[i]) o = 9;\n    // A calm disk kicked lately is brighter, settling over a few cycles to\n    // the steady level of disks that have stopped moving.\n    const f = S.flash[i], v = o ? 1 : 0.5 + 0.35 * Math.exp(-S.age[i] / 4);\n    let r = P[o] * v, gg = P[o + 1] * v, b = P[o + 2] * v;\n    (r += f * (1 - r)), (gg += f * (1 - gg)), (b += f * (1 - b));\n    const cx = S.X[i], cy = S.Y[i] + g * (S.X[i] - 32);\n    disk(S, cx, cy, r, gg, b);\n    // Images across the side edges ride the shear 64 * g further.\n    if (cx \u003c R + 1) disk(S, cx + W, cy + g * W, r, gg, b);\n    if (cx > W - R - 1) disk(S, cx - W, cy - g * W, r, gg, b);\n  }\n  // Activity: the share of disks kicked in each of the last 64 cycles, one\n  // column a cycle, newest on the right, full height 16 rows.\n  for (let x = 0; x \u003c W; x++) {\n    const f = S.hist[x];\n    if (f \u003c 0) continue;\n    const top = round(f * 16);\n    for (let k = 0; k \u003c= top; k++) {\n      const p = ((H - 1 - k) * W + x) * 3, a = k === top ? 1 : 0.35;\n      rgb[p] = max(rgb[p], P[12] * a);\n      rgb[p + 1] = max(rgb[p + 1], P[13] * a);\n      rgb[p + 2] = max(rgb[p + 2], P[14] * a);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, (255 * min(1, rgb[p])) | 0, (255 * min(1, rgb[p + 1])) | 0, (255 * min(1, rgb[p + 2])) | 0);\n}\n","tree-peano-curve":"// ===== Patternflow pattern =====\n// Title:   Tree Peano Curve\n// Family:  line\n// Idea:    A uniform spanning tree of the panel's 32 x 64 blocks of 2 x 2 LEDs grows by Wilson's loop-erased random walks, and its Peano curve, which winds round the tree through every one of the 8192 LEDs once on its way from the bottom left corner to the top left, is coloured green to magenta in the order it passes them, so its space-filling sweep up the panel shows as fractal fronts while pale fronts and short runners flow along it, and every 8 seconds a new tree is grown and its curve traced in.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: uniform spanning tree by loop-erased random walks (David Wilson, 1996), its Peano curve converges to SLE(8) (Gregory Lawler, Oded Schramm and Wendelin Werner, 2004), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bands=1..8, Stretch=-1..1\n//\n// Knob 1: Hue. Turns the curve's colours round the wheel. At 0 the curve runs from green at the bottom left corner through teal and blue to magenta at the top left; at 0.25 from azure through violet and red to orange; at 0.5 from violet through red and yellow to teal; at 0.75 from red through yellow and green to azure. Orange and yellow are lifted most of the way to full light between fronts, so they never sink to brown.\n// Knob 2: Speed. At 2 each tree lasts 8 s: colour flows over its curve for 3.6 s, Wilson's walks grow the next tree in 2 s (about 5,600 steps of 840 walks, the first slowly), and the next curve is traced in from the corner in 2.4 s. Fronts run 1,024 LEDs a second along the curve and the 51 runners 40. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Bands. How many pale fronts run along the curve at once, 1 to 8. A front lights the stretch of curve it has just passed, so its edge is the outline of the region the curve has filled so far, the discrete SLE(8) hull. At 1 one front sweeps up the panel and each LED is passed every 8 s at Speed 2; at 8 eight fronts run 1,024 LEDs apart and each LED is passed every second.\n// Knob 4: Stretch. An upright edge of the grid weighs e^(2.5 x Stretch) times a level one, 12 times at 1, and the walks step up and down that much more often, which makes the tree the weighted uniform one. At -1 a fifth of the tree's 2,047 edges stand upright and the curve lies in long level folds, at the opening 0.06 just over half do, and at 1 four fifths do and the curve hangs in tall columns.\n\nconst W = 64, H = 128, N = W * H;\n// The tree lives on the 32 x 64 grid of 2 x 2 LED blocks.\nconst X = 32, Y = 64, M = X * Y;\nconst { floor, min, max, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Direction bits of a tree edge out of a block.\nconst E = 1, WE = 2, S_ = 4, NO = 8;\n// Seconds at Speed 2: colour flows over the finished curve, then Wilson's\n// walks grow the next tree, then the next curve is traced in from a to b.\nconst FLOW = 3.6, GROW = 2.0, TRACE = 2.4;\n// A front runs the whole cycle in this many seconds at Speed 2, whatever\n// the number of bands, so more bands pass each LED more often.\nconst LAP = 8;\n// The hue at a at knob 0, and how far round the wheel it turns by b.\nconst HUE0 = 0.3, SPAN = 0.6;\n// Runners: a bright head every GAP LEDs along the curve with a tail TAIL\n// LEDs long, running from a to b at RUN LEDs a second at Speed 2, so the\n// way the curve winds shows LED by LED.\nconst GAP = 160, TAIL = 32, RUN = 40;\nconst TL = new Float32Array(GAP);\nfor (let i = 0; i \u003c TAIL; i++) TL[i] = 0.8 * Math.pow(1 - i / TAIL, 1.6);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The wired arc: the blocks along the bottom, up the right side and back\n// along the top, joined in one path that every tree contains. The left side\n// is free. The curve then runs from the bottom left corner (a) to the top\n// left corner (b), which is Lawler, Schramm and Werner's set-up.\nconst ARC = [];\nfor (let i = 0; i \u003c X; i++) ARC.push((Y - 1) * X + i);\nfor (let j = Y - 2; j >= 0; j--) ARC.push(j * X + X - 1);\nfor (let i = X - 2; i >= 0; i--) ARC.push(i);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, bands: 1, stretch: 0,\n    adj: new Uint8Array(M), nadj: new Uint8Array(M),\n    sOld: new Int16Array(N).fill(-1), sNew: new Int16Array(N),\n    log: new Int16Array(1 \u003c\u003c 16), nlog: 0,\n    inT: new Uint8Array(M), par: new Int16Array(M), born: new Float32Array(M), blen: new Int16Array(M),\n    path: new Int16Array(M), pos: new Int16Array(M), plen: 0, k: 0,\n    phase: -1, pt: 0, phi: 0, psi: 0,\n    rgb: new Float32Array(N * 3), pal: new Float32Array(1024 * 3), warm: new Float32Array(1024), palKey: -1,\n  };\n}\n\nfunction link(adj, p, out) {\n  const x = p & 63, y = p >> 6, b = (y >> 1) * X + (x >> 1), sx = x & 1, sy = y & 1;\n  out[0] = adj[b] & (sx ? E : WE) ? p + (sx ? 1 : -1) : p ^ 64;\n  out[1] = adj[b] & (sy ? S_ : NO) ? p + (sy ? W : -W) : p ^ 1;\n}\n\nconst dirOf = (a, b) => (b === a + 1 ? E : b === a - 1 ? WE : b === a + X ? S_ : NO);\n\n// Wilson's algorithm with the arc as root: from each block not yet in the\n// tree a random walk runs until it meets the tree, and its loop erasure is\n// added. Edge weights wh (across) and wv (up and down) bias the walk, which\n// makes the tree the weighted uniform one. Every step is logged so the\n// walks can be shown afterwards at the pace of the panel.\nfunction wilson(S, wh, wv) {\n  const inT = new Uint8Array(M), nxt = new Int16Array(M).fill(-1), adj = S.nadj;\n  adj.fill(0);\n  for (const v of ARC) inT[v] = 1;\n  for (let k = 0; k + 1 \u003c ARC.length; k++) {\n    const a = ARC[k], b = ARC[k + 1];\n    adj[a] |= dirOf(a, b);\n    adj[b] |= dirOf(b, a);\n  }\n  const order = new Int16Array(M);\n  for (let i = 0; i \u003c M; i++) order[i] = i;\n  for (let i = M - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = order[i];\n    order[i] = order[j];\n    order[j] = t;\n  }\n  let n = 0, log = S.log;\n  const put = (v) => {\n    if (n >= log.length) {\n      const big = new Int16Array(log.length * 2);\n      big.set(log);\n      log = S.log = big;\n    }\n    log[n++] = v;\n  };\n  for (let o = 0; o \u003c M; o++) {\n    const s = order[o];\n    if (inT[s]) continue;\n    put(s);\n    let u = s;\n    while (!inT[u]) {\n      const i = u % X, j = (u / X) | 0;\n      const a = i > 0 ? wh : 0, b = i \u003c X - 1 ? wh : 0, c = j > 0 ? wv : 0, d = j \u003c Y - 1 ? wv : 0;\n      let r = Math.random() * (a + b + c + d);\n      const v = (r -= a) \u003c 0 ? u - 1 : (r -= b) \u003c 0 ? u + 1 : (r -= c) \u003c 0 ? u - X : u + X;\n      nxt[u] = v;\n      put(v);\n      u = v;\n    }\n    for (u = s; !inT[u]; u = nxt[u]) {\n      inT[u] = 1;\n      adj[u] |= dirOf(u, nxt[u]);\n      adj[nxt[u]] |= dirOf(nxt[u], u);\n    }\n  }\n  S.nlog = n;\n}\n\n// The curve. Each block starts as a ring round its own four LEDs; every tree\n// edge cuts the two facing sides of two rings and joins them across, so the\n// tree's 2047 edges join the 2048 rings into one cycle through all 8192\n// LEDs, the outline of the thickened tree. It is cut where it leaves the\n// bottom left corner: the Peano path from a to b first, then 254 LEDs back\n// round the outside of the arc.\nfunction trace(adj, s) {\n  s.fill(-1);\n  const nb = [0, 0];\n  let prev = 127 * W, p = 126 * W, k = 0;\n  while (k \u003c N && s[p] \u003c 0) {\n    s[p] = k++;\n    link(adj, p, nb);\n    const q = nb[0] !== prev ? nb[0] : nb[1];\n    prev = p;\n    p = q;\n  }\n  return k;\n}\n\nfunction startGrow(S) {\n  const a = S.stretch * 1.25;\n  wilson(S, exp(-a), exp(a));\n  S.inT.fill(0);\n  for (const v of ARC) S.inT[v] = 1;\n  S.born.fill(-9);\n  S.pos.fill(-1);\n  S.plen = 0;\n  S.k = 0;\n}\n\n// One logged step of the walks: start, step, erase a loop, or join the tree.\n// Erasing each loop as it closes gives back the same tree Wilson's run built.\nfunction replay(S) {\n  const v = S.log[S.k++], { path, pos, inT } = S;\n  if (S.plen === 0) {\n    path[0] = v;\n    pos[v] = 0;\n    S.plen = 1;\n  } else if (inT[v]) {\n    for (let i = 0; i \u003c S.plen; i++) {\n      const u = path[i];\n      inT[u] = 1;\n      pos[u] = -1;\n      S.par[u] = i + 1 \u003c S.plen ? path[i + 1] : v;\n      S.born[u] = S.pt;\n      S.blen[u] = S.plen;\n    }\n    S.plen = 0;\n  } else if (pos[v] >= 0) {\n    for (let i = pos[v] + 1; i \u003c S.plen; i++) pos[path[i]] = -1;\n    S.plen = pos[v] + 1;\n  } else {\n    pos[v] = S.plen;\n    path[S.plen++] = v;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.bands = cl(kv[2], 1, 8);\n  S.stretch = cl(kv[3], -1, 1);\n  const g = (d * S.speed) / 2;\n  S.phi += (g * S.bands) / LAP;\n  S.psi += g * RUN;\n  if (S.phase \u003c 0) {\n    // The first tree is grown at once and traced in from black.\n    startGrow(S);\n    S.adj.set(S.nadj);\n    trace(S.adj, S.sNew);\n    S.phase = 2;\n    S.pt = 0;\n    return;\n  }\n  S.pt += g;\n  if (S.phase === 0 && S.pt >= FLOW) {\n    S.phase = 1;\n    S.pt = 0;\n    S.sOld.set(S.sNew);\n    startGrow(S);\n  } else if (S.phase === 1) {\n    const want = floor(pow(cl(S.pt / GROW, 0, 1), 2.5) * S.nlog);\n    while (S.k \u003c want) replay(S);\n    if (S.pt >= GROW) {\n      S.adj.set(S.nadj);\n      trace(S.adj, S.sNew);\n      S.phase = 2;\n      S.pt = 0;\n    }\n  } else if (S.phase === 2 && S.pt >= TRACE) {\n    S.phase = 0;\n    S.pt = 0;\n  }\n}\n\n// A monotone turn of the hue circle that hurries through orange and\n// yellow, which read brown and olive when dim.\nconst warp = (h) => h + (0.5 / (2 * Math.PI)) * Math.sin(2 * Math.PI * (h - 0.11));\n\n// Hue by place along the whole curve, from a to b; brightness and a\n// whitening by how long ago the last front passed.\nfunction palette(S) {\n  const key = S.hue;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const P = S.pal, h0 = HUE0 + S.hue;\n  for (let i = 0; i \u003c 1024; i++) {\n    // Deep blue is paled a little, since it reads darkest on the LEDs.\n    const h = warp(h0 + SPAN * (i / 1023));\n    hsv(h, 0.88 - 0.3 * max(0, Math.cos(2 * Math.PI * (h - 0.66))), 1, P, i * 3);\n    // Orange and yellow keep most of their light even long after a front,\n    // so they never sink to brown and olive.\n    S.warm[i] = 0.65 * pow(max(0, Math.cos(2 * Math.PI * (h - 0.11))), 2);\n  }\n}\n// Palette index by place on the cycle: up the hues along the Peano path,\n// then back down them along the 254 LEDs that close the cycle round the\n// outside of the arc, so the closing run meets a in a's own colour.\nconst PATH = N - 254, HP = new Int16Array(N);\nfor (let s = 0; s \u003c N; s++) HP[s] = s \u003c PATH ? ((s * 1023) / PATH) | 0 : (((N - s) * 1023) / (N - PATH)) | 0;\nconst VL = new Float32Array(1024), WL = new Float32Array(1024);\nfor (let i = 0; i \u003c 1024; i++) {\n  const u = i / 1023;\n  VL[i] = 0.45 + 0.55 * u;\n  WL[i] = 0.55 * Math.pow(u, 8);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.phase \u003c 0) return;\n  palette(S);\n  const rgb = S.rgb, P = S.pal, K = S.bands, phi = S.phi, sN = S.sNew, sO = S.sOld;\n  const ph = S.phase, pt = S.pt;\n  const head = ph === 2 ? (pt / TRACE) * N : N + 1e9;\n  const dim = ph === 1 ? 1 - 0.6 * cl(pt / 0.4, 0, 1) : 0.4;\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    // Behind the head of a trace the new curve, ahead of it the old one.\n    let s = sN[p], f = 1, tip = 0;\n    if (ph === 1 || s > head) {\n      s = sO[p];\n      f = dim;\n      if (s \u003c 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n    } else if (ph === 2 && head - s \u003c 160) tip = (1 - (head - s) / 160) ** 2;\n    let u = (K * s) / N - phi;\n    u -= floor(u);\n    const i = HP[s], c = i * 3, ui = (u * 1023) | 0;\n    // A runner's tail, if one is passing.\n    let a = (S.psi - s) % GAP;\n    if (a \u003c 0) a += GAP;\n    const t = ph === 1 ? 0 : TL[a | 0];\n    const lo = VL[ui] + (1 - VL[ui]) * S.warm[i];\n    f *= lo + (1 - lo) * t;\n    const w = WL[ui] + (1 - WL[ui]) * t * 0.6;\n    for (let e = 0; e \u003c 3; e++) {\n      const v = (P[c + e] + (1 - P[c + e]) * w) * f;\n      // The tip of the curve being traced in glows white.\n      rgb[o + e] = v + (1 - v) * tip;\n    }\n  }\n  if (ph === 1) {\n    // Wilson's walks: the loop-erased path still walking, and the branches\n    // that have just joined the tree, drawn through the top left LED of\n    // each block.\n    const at = (v, c) => {\n      const x = (v % X) * 2, y = ((v / X) | 0) * 2, o = (y * W + x) * 3;\n      for (let e = 0; e \u003c 3; e++) rgb[o + e] += (1 - rgb[o + e]) * c;\n    };\n    const mid = (a, b, c) => {\n      const x = (a % X) + (b % X), y = ((a / X) | 0) + ((b / X) | 0), o = (y * W + x) * 3;\n      for (let e = 0; e \u003c 3; e++) rgb[o + e] += (1 - rgb[o + e]) * c;\n    };\n    for (let v = 0; v \u003c M; v++) {\n      const age = pt - S.born[v];\n      if (age \u003c 0 || age > 0.6) continue;\n      // Long branches flash longer than the many short ones at the end.\n      const c = 0.85 * min(1, S.blen[v] / 8) * exp(-age / 0.18);\n      at(v, c);\n      mid(v, S.par[v], c);\n    }\n    for (let i = 0; i \u003c S.plen; i++) {\n      at(S.path[i], 0.95);\n      if (i) mid(S.path[i - 1], S.path[i], 0.95);\n    }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","twist-writhe":"// ===== Patternflow pattern =====\n// Title:   Twist and Writhe\n// Family:  topology\n// Idea:    A closed ribbon, twisted Lk times round a flat circle, folds through a figure-eight into a tall supercoil while its two coloured edges stay linked the same number of times, so the twist of its two-toned faces unwinds as the writhe of its centre line grows, and a bar along the bottom shows Tw and Wr adding up to the same whole number all the way.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Călugăreanu-White-Fuller theorem Lk = Tw + Wr (Gheorghe Călugăreanu, 1959; James H. White, 1969; F. Brock Fuller, 1971), supercoiled DNA (Jerome Vinograd, 1965), pattern round 56\n// Round:   56\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lk=3..6, Coil=3..6\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the ribbon's front face is azure and its back violet, its edges pink and lime; at 0.25 purple and rose with green and aqua edges, at 0.5 red and green with cyan and blue, at 0.75 green and sky blue with violet and magenta. The wheel skips orange and yellow, which read brown on the shaded far side.\n// Knob 2: Speed. At 2 a cycle takes 12 s: the loop lies flat for 1.2 s, coils for 4.5 s, holds for 1.8 s and uncoils for 4.5 s, while the view turns half a turn, slowly while the loop is flat. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Lk. The linking number of the two edges, a whole number from 3 to 6. On the flat circle it is all twist: the ribbon turns over 2 Lk times round the loop, a half-turn every 47 LEDs of ribbon at 3 and every 24 at 6. Turning it cuts the ribbon, turns one end and joins it again, as a type I topoisomerase does to a ring of DNA one turn at a time.\n// Knob 4: Coil. The writhe the centre line reaches at the deepest point of the cycle, 3 to 6, so the twist left there is Lk - Coil. At 3 the supercoil winds 4.3 half-turns and stands 106 LEDs tall and 14 across; at 6 it winds 8.1 and is 8 across, its strands 6 LEDs apart. Past Lk the ribbon comes out twisted the other way, and the Tw bar runs back to the mark, striped.\n\nconst W = 64, H = 128, NPX = W * H;\nconst { floor, min, max, sqrt, sin, cos, abs, atan2, asin, round, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Points on the centre line, and its length in LEDs: a circle of radius 45.\nconst M = 144, LEN = TAU * 45;\n// Half the ribbon's width, in LEDs.\nconst HW = 3;\n// Where the middle of the ribbon sits on the panel; the bar is below.\nconst CX = 32, CY = 57;\n// The cycle at Speed 2, in seconds: flat, coiling, held, uncoiling.\nconst FLAT = 1.2, UP = 4.5, HOLD = 1.8, DOWN = 4.5, CYCLE = FLAT + UP + HOLD + DOWN;\n// Writhe of the coiling family below at q = 0, 0.5, 1, ... 9 half-turns,\n// from the same Gauss integral the pattern runs, used only to pick the q\n// whose writhe is the knob's target. The writhe shown is computed afresh.\nconst WR_OF_Q = [0, 0.124, 0.454, 0.823, 1.189, 1.584, 1.979, 2.375, 2.771, 3.166, 3.56, 3.954, 4.347, 4.74, 5.132, 5.525, 5.917, 6.309, 6.701];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the wheel skips 0.03..0.18.\nconst wheel = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const K = M * 4;\n  params.s = {\n    t: 0, hue: 0, speed: 2, lk: 3, coil: 3, q: 0,\n    P: new Float64Array(M * 3), T: new Float64Array(M * 3), U: new Float64Array(M * 3), P1: new Float64Array(M * 3),\n    Q: new Float64Array(K * 3), cum: new Float64Array(K + 1),\n    wr: 0, tw: 0, phi: 0, yaw: 0,\n    sx: new Float32Array(M * 2), sy: new Float32Array(M * 2), sz: new Float32Array(M * 2), face: new Float32Array(M),\n    zb: new Float32Array(NPX), rgb: new Float32Array(NPX * 3), pal: new Float32Array(18), palHue: -1,\n  };\n}\n\n// The coiling family, q half-turns deep. An oval in the xz-plane, a circle\n// at q = 0 and a rounded long loop (superellipse exponent 0.6) from q = 2,\n// is twisted about its long axis z by q pi from bottom to top, so its two\n// long sides wind round each other q half-turns as the two strands of a\n// supercoil; the oval stretches so the strands keep a pitch of about 42\n// degrees. It never passes through itself: at each height its two strands\n// sit on opposite sides of the axis. The curve is then laid out at equal\n// steps of arc length and scaled to LEN, so the ribbon keeps its length.\nfunction shape(S, q) {\n  const { P, Q, cum } = S, K = M * 4;\n  const b = sqrt(1 + ((q * PI) / 1.8) ** 2), p = 1 - 0.4 * min(1, q / 2), kap = -(q * PI) / (2 * b);\n  for (let i = 0; i \u003c K; i++) {\n    const th = (TAU * i) / K, c = cos(th), s = sin(th);\n    const x = (c \u003c 0 ? -1 : 1) * abs(c) ** p, z = b * (s \u003c 0 ? -1 : 1) * abs(s) ** p, ps = kap * z;\n    Q[i * 3] = x * cos(ps);\n    Q[i * 3 + 1] = x * sin(ps);\n    Q[i * 3 + 2] = z;\n  }\n  cum[0] = 0;\n  for (let i = 0; i \u003c K; i++) {\n    const j = ((i + 1) % K) * 3, o = i * 3;\n    cum[i + 1] = cum[i] + hypot(Q[j] - Q[o], Q[j + 1] - Q[o + 1], Q[j + 2] - Q[o + 2]);\n  }\n  const k0 = LEN / cum[K];\n  for (let i = 0, k = 0; i \u003c M; i++) {\n    const s = (cum[K] * i) / M;\n    while (cum[k + 1] \u003c s) k++;\n    const f = (s - cum[k]) / (cum[k + 1] - cum[k] || 1), o = k * 3, j = ((k + 1) % K) * 3;\n    for (let e = 0; e \u003c 3; e++) P[i * 3 + e] = (Q[o + e] + f * (Q[j + e] - Q[o + e])) * k0;\n  }\n}\n\n// The writhe by the Gauss double integral over the closed polygon, each\n// pair of segments in closed form: the solid angle the one sees the other\n// under, signed, over 4 pi (Konstantin Klenin and Jörg Langowski, 2000).\nfunction writhe(P) {\n  let w = 0;\n  const r = S12, n = N12;\n  for (let i = 0; i \u003c M; i++) {\n    const a = i * 3, b = ((i + 1) % M) * 3, fx = P[b] - P[a], fy = P[b + 1] - P[a + 1], fz = P[b + 2] - P[a + 2];\n    for (let j = i + 2; j \u003c M; j++) {\n      if (i === 0 && j === M - 1) continue;\n      const c = j * 3, d = ((j + 1) % M) * 3;\n      // r13, r14, r24, r23: from the ends of segment i to those of j.\n      (r[0] = P[c] - P[a]), (r[1] = P[c + 1] - P[a + 1]), (r[2] = P[c + 2] - P[a + 2]);\n      (r[3] = P[d] - P[a]), (r[4] = P[d + 1] - P[a + 1]), (r[5] = P[d + 2] - P[a + 2]);\n      (r[6] = P[d] - P[b]), (r[7] = P[d + 1] - P[b + 1]), (r[8] = P[d + 2] - P[b + 2]);\n      (r[9] = P[c] - P[b]), (r[10] = P[c + 1] - P[b + 1]), (r[11] = P[c + 2] - P[b + 2]);\n      for (let k = 0; k \u003c 12; k += 3) {\n        const v = (k + 3) % 12;\n        const x = r[k + 1] * r[v + 2] - r[k + 2] * r[v + 1], y = r[k + 2] * r[v] - r[k] * r[v + 2], z = r[k] * r[v + 1] - r[k + 1] * r[v];\n        const l = sqrt(x * x + y * y + z * z) || 1;\n        (n[k] = x / l), (n[k + 1] = y / l), (n[k + 2] = z / l);\n      }\n      let om = 0;\n      for (let k = 0; k \u003c 12; k += 3) {\n        const v = (k + 3) % 12;\n        om += asin(cl(n[k] * n[v] + n[k + 1] * n[v + 1] + n[k + 2] * n[v + 2], -1, 1));\n      }\n      // The sign: (r34 x r12) . r13.\n      const ex = P[d] - P[c], ey = P[d + 1] - P[c + 1], ez = P[d + 2] - P[c + 2];\n      const sg = (ey * fz - ez * fy) * r[0] + (ez * fx - ex * fz) * r[1] + (ex * fy - ey * fx) * r[2];\n      w += sg > 0 ? om : sg \u003c 0 ? -om : 0;\n    }\n  }\n  return (2 * w) / (4 * PI);\n}\nconst S12 = new Float64Array(12), N12 = new Float64Array(12);\n\n// Rotate v (at o in V) about the unit axis that turns t0 into t1, by the\n// angle between them: parallel transport along the polygon, which adds no\n// twist. Writes into out at p.\nfunction transport(V, o, t0, t1, out, p) {\n  const ax = t0[1] * t1[2] - t0[2] * t1[1], ay = t0[2] * t1[0] - t0[0] * t1[2], az = t0[0] * t1[1] - t0[1] * t1[0];\n  const s = hypot(ax, ay, az), c = t0[0] * t1[0] + t0[1] * t1[1] + t0[2] * t1[2];\n  const vx = V[o], vy = V[o + 1], vz = V[o + 2];\n  if (s \u003c 1e-12) {\n    (out[p] = vx), (out[p + 1] = vy), (out[p + 2] = vz);\n    return;\n  }\n  const kx = ax / s, ky = ay / s, kz = az / s, kd = (kx * vx + ky * vy + kz * vz) * (1 - c);\n  out[p] = vx * c + (ky * vz - kz * vy) * s + kx * kd;\n  out[p + 1] = vy * c + (kz * vx - kx * vz) * s + ky * kd;\n  out[p + 2] = vz * c + (kx * vy - ky * vx) * s + kz * kd;\n}\n\n// The ribbon. Tangents at the points, a parallel-transported normal P1\n// round the loop, and its holonomy phi: how far P1 has turned about the\n// tangent when it comes back to the start. A closed ribbon turns about the\n// curve a whole number of times relative to P1 less phi / 2 pi, so its\n// twist is m - phi / 2 pi. The twist is spread evenly, as in an elastic rod\n// at rest, and m is the whole number that makes the two edges link Lk\n// times: by the theorem the one that brings Tw + Wr nearest Lk. Tw is then\n// measured off the built ribbon, angle by angle. Over whole cycles at every\n// Lk with Coil 3, 4.5 and 6, the Gauss linking integral of the two edges\n// came out Lk exactly each time, and Tw + Wr stayed within 0.005 of it.\nfunction ribbon(S) {\n  const { P, T, U, P1 } = S, t0 = [0, 0, 0], t1 = [0, 0, 0], tmp = [0, 0, 0];\n  for (let i = 0; i \u003c M; i++) {\n    const a = ((i + M - 1) % M) * 3, b = ((i + 1) % M) * 3, o = i * 3;\n    const x = P[b] - P[a], y = P[b + 1] - P[a + 1], z = P[b + 2] - P[a + 2], l = hypot(x, y, z) || 1;\n    T[o] = x / l;\n    T[o + 1] = y / l;\n    T[o + 2] = z / l;\n  }\n  // Start P1 pointing into the loop, square to the tangent.\n  {\n    const d = -(P[0] * T[0] + P[1] * T[1] + P[2] * T[2]);\n    let x = -P[0] + d * T[0], y = -P[1] + d * T[1], z = -P[2] + d * T[2];\n    const l = hypot(x, y, z) || 1;\n    (P1[0] = x / l), (P1[1] = y / l), (P1[2] = z / l);\n  }\n  const tv = (o, out) => ((out[0] = T[o]), (out[1] = T[o + 1]), (out[2] = T[o + 2]));\n  for (let i = 1; i \u003c= M; i++) {\n    tv((i - 1) * 3, t0);\n    tv((i % M) * 3, t1);\n    if (i \u003c M) transport(P1, (i - 1) * 3, t0, t1, P1, i * 3);\n    else transport(P1, (M - 1) * 3, t0, t1, tmp, 0);\n  }\n  // tmp is P1 carried once round; phi is its angle from P1 at the start.\n  const p2x = T[1] * P1[2] - T[2] * P1[1], p2y = T[2] * P1[0] - T[0] * P1[2], p2z = T[0] * P1[1] - T[1] * P1[0];\n  S.phi = atan2(tmp[0] * p2x + tmp[1] * p2y + tmp[2] * p2z, tmp[0] * P1[0] + tmp[1] * P1[1] + tmp[2] * P1[2]);\n  const m = round(S.lk - S.wr + S.phi / TAU), tw = m - S.phi / TAU;\n  for (let i = 0; i \u003c M; i++) {\n    const o = i * 3, th = (TAU * tw * i) / M, c = cos(th), s = sin(th);\n    const qx = T[o + 1] * P1[o + 2] - T[o + 2] * P1[o + 1], qy = T[o + 2] * P1[o] - T[o] * P1[o + 2], qz = T[o] * P1[o + 1] - T[o + 1] * P1[o];\n    U[o] = c * P1[o] + s * qx;\n    U[o + 1] = c * P1[o + 1] + s * qy;\n    U[o + 2] = c * P1[o + 2] + s * qz;\n  }\n  // The twist of the ribbon as built: each U carried to the next point,\n  // and the angle it is then short of that point's U, about the tangent.\n  let sum = 0;\n  for (let i = 0; i \u003c M; i++) {\n    const j = ((i + 1) % M) * 3;\n    tv(i * 3, t0);\n    tv(j, t1);\n    transport(U, i * 3, t0, t1, tmp, 0);\n    const wx = t1[1] * tmp[2] - t1[2] * tmp[1], wy = t1[2] * tmp[0] - t1[0] * tmp[2], wz = t1[0] * tmp[1] - t1[1] * tmp[0];\n    sum += atan2(U[j] * wx + U[j + 1] * wy + U[j + 2] * wz, U[j] * tmp[0] + U[j + 1] * tmp[1] + U[j + 2] * tmp[2]);\n  }\n  S.tw = sum / TAU;\n}\n\n// The q whose writhe is w, from the table.\nfunction qFor(w) {\n  if (w \u003c= 0) return 0;\n  for (let k = 1; k \u003c WR_OF_Q.length; k++)\n    if (WR_OF_Q[k] >= w) return 0.5 * (k - 1 + (w - WR_OF_Q[k - 1]) / (WR_OF_Q[k] - WR_OF_Q[k - 1]));\n  return 9;\n}\n\nconst ease = (x) => x * x * (3 - 2 * x);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 3, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.lk = cl(round(kv[2]), 3, 6);\n  S.coil = cl(kv[3], 3, 6);\n  S.t = (S.t + (d * S.speed) / 2) % CYCLE;\n  const t = S.t;\n  const g = t \u003c FLAT ? 0 : t \u003c FLAT + UP ? ease((t - FLAT) / UP) : t \u003c FLAT + UP + HOLD ? 1 : ease(1 - (t - FLAT - UP - HOLD) / DOWN);\n  S.q = qFor(S.coil * g);\n  shape(S, S.q);\n  S.wr = writhe(S.P);\n  ribbon(S);\n  // The view turns half a turn a cycle, slowly while the loop is flat so it\n  // is seen at a slant (it would not fit the panel face on), faster while\n  // it is coiled.\n  const ph = t / CYCLE;\n  S.yaw = (2.1 + PI * ph - 0.44 * sin(TAU * ph)) % TAU;\n}\n\nfunction palette(S) {\n  const P = S.pal, h = S.hue;\n  hsv(wheel(0.65 + h), 0.75, 1, P, 0); // front face\n  hsv(wheel(0.86 + h), 0.8, 0.7, P, 3); // back face\n  hsv(wheel(1.05 + h), 0.6, 1, P, 6); // edge one\n  hsv(wheel(0.26 + h), 0.7, 1, P, 9); // edge two\n  hsv(wheel(0.65 + h), 0.6, 1, P, 12); // Tw bar, the front face's colour\n  hsv(wheel(0.1 + h), 0.12, 0.95, P, 15); // Wr bar\n  S.palHue = S.hue;\n}\n\n// Fill a triangle with depth test, at LED centres.\nfunction tri(S, x0, y0, z0, x1, y1, z1, x2, y2, z2, r, g, b) {\n  const area = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(area) \u003c 1e-6) return;\n  const { zb, rgb } = S;\n  const xa = max(0, floor(min(x0, x1, x2))), xb = min(W - 1, floor(max(x0, x1, x2)));\n  const ya = max(0, floor(min(y0, y1, y2))), yb = min(H - 1, floor(max(y0, y1, y2)));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const w0 = ((x1 - px) * (y2 - py) - (x2 - px) * (y1 - py)) / area;\n      const w1 = ((x2 - px) * (y0 - py) - (x0 - px) * (y2 - py)) / area;\n      const w2 = 1 - w0 - w1;\n      if (w0 \u003c -1e-4 || w1 \u003c -1e-4 || w2 \u003c -1e-4) continue;\n      const z = w0 * z0 + w1 * z1 + w2 * z2, p = y * W + x;\n      if (z \u003c= zb[p]) continue;\n      zb[p] = z;\n      (rgb[p * 3] = r), (rgb[p * 3 + 1] = g), (rgb[p * 3 + 2] = b);\n    }\n}\n\n// Nearer is brighter.\nconst shadeOf = (z) => 0.5 + 0.5 * cl((z + 46) / 92, 0, 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.T) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { P, U, T, sx, sy, sz, face, zb, rgb } = S, C = S.pal;\n  zb.fill(-1e9);\n  rgb.fill(0);\n  const cy = cos(S.yaw), sy0 = sin(S.yaw), el = 0.3, ce = cos(el), se = sin(el);\n  // Project: turn about the vertical, tip the top away by el, look along +y.\n  // k = 0 the edge at +HW U, k = 1 the one at -HW U.\n  const proj = (x, y, z, o) => {\n    const x1 = x * cy - y * sy0, y1 = x * sy0 + y * cy;\n    const y2 = y1 * ce + z * se, z2 = z * ce - y1 * se;\n    sx[o] = CX + x1;\n    sy[o] = CY - z2;\n    sz[o] = -y2;\n  };\n  for (let i = 0; i \u003c M; i++) {\n    const o = i * 3;\n    for (let k = 0; k \u003c 2; k++) {\n      const s = k ? -HW : HW;\n      proj(P[o] + s * U[o], P[o + 1] + s * U[o + 1], P[o + 2] + s * U[o + 2], i * 2 + k);\n    }\n    // Which face looks at us: the normal T x U against the view.\n    const nx = T[o + 1] * U[o + 2] - T[o + 2] * U[o + 1], ny = T[o + 2] * U[o] - T[o] * U[o + 2], nz = T[o] * U[o + 1] - T[o + 1] * U[o];\n    const y1 = nx * sy0 + ny * cy;\n    face[i] = -(y1 * ce + nz * se);\n  }\n  // Faces, as two triangles a segment.\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M, a = i * 2, b = j * 2, f = (face[i] + face[j]) / 2;\n    const o = f >= 0 ? 0 : 3, lit = (0.35 + 0.65 * min(1, abs(f) * 1.4)) * shadeOf((sz[a] + sz[b] + sz[a + 1] + sz[b + 1]) / 4);\n    const r = C[o] * lit, g = C[o + 1] * lit, bl = C[o + 2] * lit;\n    tri(S, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], sx[b + 1], sy[b + 1], sz[b + 1], r, g, bl);\n    tri(S, sx[a], sy[a], sz[a], sx[b + 1], sy[b + 1], sz[b + 1], sx[a + 1], sy[a + 1], sz[a + 1], r, g, bl);\n  }\n  // The two edges, a line each, a little in front of the faces they bound.\n  for (let k = 0; k \u003c 2; k++) {\n    const o = 6 + k * 3;\n    for (let i = 0; i \u003c M; i++) {\n      const a = i * 2 + k, b = ((i + 1) % M) * 2 + k, n = Math.ceil(hypot(sx[b] - sx[a], sy[b] - sy[a]) * 2.5) || 1;\n      for (let e = 0; e \u003c n; e++) {\n        const u = e / n, x = sx[a] + (sx[b] - sx[a]) * u, y = sy[a] + (sy[b] - sy[a]) * u, z = sz[a] + (sz[b] - sz[a]) * u + 1.5;\n        const ix = floor(x), iy = floor(y);\n        if (ix \u003c 0 || ix >= W || iy \u003c 0 || iy >= H) continue;\n        const p = iy * W + ix;\n        if (z \u003c zb[p]) continue;\n        zb[p] = z;\n        const l = 0.25 + 0.75 * shadeOf(z);\n        (rgb[p * 3] = C[o] * l), (rgb[p * 3 + 1] = C[o + 1] * l), (rgb[p * 3 + 2] = C[o + 2] * l);\n      }\n    }\n  }\n  // The bar: Wr from 0, then Tw from where Wr ends, which always stops at\n  // the mark at Lk. A negative Tw runs back from Wr to Lk, striped.\n  const X0 = 6, UNIT = 8, row = (y, a, b, o, stripe) => {\n    const lo = min(a, b), hi = max(a, b);\n    for (let x = floor(X0 + lo * UNIT); x \u003c X0 + hi * UNIT; x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const cover = min(1, x + 1 - (X0 + lo * UNIT), X0 + hi * UNIT - x);\n      if (cover \u003c= 0) continue;\n      const l = cover * (stripe && (x & 1) ? 0.45 : 1);\n      for (let e = 0; e \u003c 3; e++) rgb[(y * W + x) * 3 + e] = C[o + e] * l;\n    }\n  };\n  for (const y of [119, 120]) row(y, 0, S.wr, 15, false);\n  for (const y of [122, 123]) row(y, S.wr, S.wr + S.tw, 12, S.tw \u003c 0);\n  for (let v = 0; v \u003c= 7; v++) {\n    const x = X0 + v * UNIT;\n    if (x >= W) break;\n    rgb[(125 * W + x) * 3] = rgb[(125 * W + x) * 3 + 1] = rgb[(125 * W + x) * 3 + 2] = 0.3;\n  }\n  // The mark at Lk in the two edges' colours: it counts how often they link.\n  const lx = X0 + S.lk * UNIT;\n  for (let y = 118; y \u003c= 126; y++) {\n    const o = y \u003c 122 ? 6 : 9;\n    for (let e = 0; e \u003c 3; e++) rgb[(y * W + lx) * 3 + e] = C[o + e];\n  }\n  for (let p = 0; p \u003c NPX; p++) display.setPixel(p % W, (p / W) | 0, (255 * min(1, rgb[p * 3])) | 0, (255 * min(1, rgb[p * 3 + 1])) | 0, (255 * min(1, rgb[p * 3 + 2])) | 0);\n}\n","buffon-noodle":"// ===== Patternflow pattern =====\n// Title:   Buffon's Noodle\n// Family:  data\n// Idea:    Needles drop one after another onto a floor of lines 16 LEDs apart, warm where they cross a line and cool where they miss, with a white tick on the line at every crossing, while the count of crossings against the length dropped estimates pi below, and bending every needle into an arc of the same length leaves the average alone until, as a closed circle 16 LEDs across, each one crosses exactly twice and the estimate stops wobbling on pi.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Buffon's needle (Georges-Louis Leclerc, Comte de Buffon, 1777) and Barbier's noodle (Joseph-Emile Barbier, 1860), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Length=0.2..1, Bend=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the needles that cross a line are gold and those that miss are azure; at 0.25 green and magenta, at 0.5 blue and orange. The floor lines stay slate.\n// Knob 2: Speed. Needles a second, five times the knob: 10 at 2, 1 at 0.2, 15 at 3. A needle lies about 4 seconds at 2 and longer when the drops are slower, so at Length 0.2 the floor holds about 40 needles at 2 and 13 at 0.2. The first 12 fall in the first half second whatever the knob says.\n// Knob 3: Length. The needle's length as a share of pi times the line spacing: 0.2 opens on needles 10 LEDs long that cross 0.4 lines on average, 0.5 on 25 LEDs crossing 1, and 1 on 50 LEDs crossing 2. Longer needles leave sooner, about 2 seconds at 1, so the floor carries about the same ink. The estimate is 2 x (length dropped) / (16 x crossings), so any length gives pi on average.\n// Knob 4: Bend. Bends each new needle into a circular arc of the same length, turning through Bend x 360 degrees: 0.06 is a needle bowed by 22 degrees, 0.5 a half circle, 1 a closed ring. The average count never changes. At Length 1 and Bend 1 the ring is 16 LEDs across, crosses exactly two lines every time, and the error bars of the trace fall flat onto the pi line.\n// Buttons: K1 tap starts the count again. It also starts again by itself half a second after Length or Bend comes to rest at a new value.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Line spacing, the floor's last row, and line k's height: the centre of\n// row 16k, so rows 0, 16, ... 96 carry the lines.\nconst D = 16, FLOOR = 96, Y0 = 0.5;\n// The trace: one column per drop, the newest on the right, beside a pi\n// sign; the windowed estimate is over the last WIN drops.\nconst TX = 7, HIST = W - TX, WIN = 24, TMID = 116, TAMP = 10;\n// Hue of the crossing needles at knob 0 (gold), and the missing ones\n// opposite it on the wheel.\nconst HUE0 = 0.13;\n\n// 3 x 5 digits, row by row from the top, three bits a row.\nconst FONT = {\n  0: 0b111101101101111, 1: 0b010110010010111, 2: 0b111001111100111, 3: 0b111001111001111,\n  4: 0b101101111001001, 5: 0b111100111001111, 6: 0b111100111101111, 7: 0b111001001001001,\n  8: 0b111101111101111, 9: 0b111101111001111, \"-\": 0b000000111000000,\n};\n// A pi sign, five bits a row.\nconst PI_SIGN = [0b11111, 0b01010, 0b01010, 0b01010, 0b10011];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, acc: 0, acc0: 0, burst: 12, needles: [], epoch: 0,\n    hue: 0, speed: 2, share: 0.2, bend: 0.06, ref: null, settle: 0,\n    // Since the last start: drops, length dropped and crossings.\n    n: 0, sumL: 0, sumC: 0,\n    winL: new Float64Array(WIN), winC: new Float64Array(WIN), wi: 0, wn: 0,\n    // The trace, oldest first: the running estimate, the windowed one, and\n    // a mark where the count started again.\n    cum: new Float64Array(HIST).fill(NaN), win: new Float64Array(HIST).fill(NaN), mark: new Uint8Array(HIST),\n    rgb: new Float32Array(W * H * 3), warm: [0, 0, 0], cool: [0, 0, 0],\n  };\n}\n\n// The noodle's shape. It is a circular arc of length L turning through th,\n// placed by its centroid G and the direction a from the arc's centre to\n// its midpoint; the arc's centre sits c behind G. For th near 0 it is the\n// straight needle through G, square to a. A point s along the arc (from\n// -L/2 to L/2) lies at G + (R cos(s/R) - c) u + R sin(s/R) v, with u the\n// direction a and v a quarter turn on.\nfunction shape(L, th) {\n  if (th \u003c 1e-3) return { R: 0, c: 0 };\n  const R = L / th;\n  return { R, c: (R * sin(th / 2)) / (th / 2) };\n}\nfunction rel(nd, s, o) {\n  const ca = cos(nd.a), sa = sin(nd.a);\n  let pu, pv;\n  if (nd.R === 0) (pu = 0), (pv = s);\n  else (pu = nd.R * cos(s / nd.R) - nd.c), (pv = nd.R * sin(s / nd.R));\n  o[0] = pu * ca - pv * sa;\n  o[1] = pu * sa + pv * ca;\n}\n\n// Every crossing of the noodle with the lines y = 16k + 0.5, all of them,\n// not just the ones on the panel, as positions s along it. Exact: a\n// straight needle meets a line at one s, a circle at the two angles whose\n// sine puts it on the line, kept when they fall inside the arc.\nfunction crossings(nd) {\n  const out = [], L = nd.L, k0 = Math.ceil((nd.gy - L - Y0) / D), k1 = floor((nd.gy + L - Y0) / D);\n  const ca = cos(nd.a), sa = sin(nd.a);\n  for (let k = k0; k \u003c= k1; k++) {\n    const y = D * k + Y0;\n    if (nd.R === 0) {\n      // y(s) = gy + s cos a\n      if (abs(ca) \u003c 1e-12) continue;\n      const s = (y - nd.gy) / ca;\n      if (abs(s) \u003c L / 2) out.push(s);\n    } else {\n      const oy = nd.gy - nd.c * sa, v = (y - oy) / nd.R;\n      if (abs(v) >= 1) continue;\n      const b = asin(v);\n      for (const beta of [b, PI - b]) {\n        const d = (((beta - (nd.a - nd.th / 2)) % TAU) + TAU) % TAU;\n        if (d \u003c nd.th) out.push((d - nd.th / 2) * nd.R);\n      }\n    }\n  }\n  return out;\n}\n\nfunction drop(S, fall) {\n  const R = Math.random;\n  // Four draws a drop whatever the knobs, so drop i lands in the same place\n  // at every Length and Bend and only its shape differs.\n  const gx = 2 + 60 * R(), gy = Y0 + FLOOR * R(), a = TAU * R(), spin = (R() \u003c 0.5 ? -1 : 1) * (1.5 + 2 * R());\n  const L = S.share * PI * D, th = S.bend * TAU, sh = shape(L, th);\n  const nd = { gx, gy, a, spin, L, th, R: sh.R, c: sh.c, age: 0, fall, landed: false, epoch: S.epoch };\n  nd.cross = crossings(nd);\n  S.needles.push(nd);\n}\n\nfunction land(S, nd) {\n  nd.landed = true;\n  // Long needles go sooner, so the floor holds about as much ink at any\n  // Length: about 4 seconds at Speed 2 and Length 0.2, 2 at Length 1.\n  nd.life = 4 * sqrt(2 / S.speed) * (0.2 / (nd.L / (PI * D))) ** 0.4;\n  if (nd.epoch !== S.epoch) return;\n  const C = nd.cross.length;\n  S.n++;\n  S.sumL += nd.L;\n  S.sumC += C;\n  S.winL[S.wi] = nd.L;\n  S.winC[S.wi] = C;\n  S.wi = (S.wi + 1) % WIN;\n  S.wn = min(WIN, S.wn + 1);\n  let wl = 0, wc = 0;\n  for (let i = 0; i \u003c S.wn; i++) (wl += S.winL[i]), (wc += S.winC[i]);\n  S.cum.copyWithin(0, 1);\n  S.win.copyWithin(0, 1);\n  S.mark.copyWithin(0, 1);\n  S.cum[HIST - 1] = S.sumC ? (2 * S.sumL) / (D * S.sumC) : Infinity;\n  S.win[HIST - 1] = wc ? (2 * wl) / (D * wc) : Infinity;\n  S.mark[HIST - 1] = S.n === 1 ? 1 : 0;\n}\n\nfunction restart(S) {\n  S.epoch++;\n  S.n = S.sumL = S.sumC = 0;\n  S.wi = S.wn = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.share = cl(kv[2], 0.2, 1);\n  S.bend = cl(kv[3], 0, 1);\n  // A new Length or Bend starts the count again once the knob rests, so the\n  // readout is about the noodle on the floor.\n  if (!S.ref) S.ref = [S.share, S.bend];\n  if (abs(S.share - S.ref[0]) > 0.004 || abs(S.bend - S.ref[1]) > 0.004) (S.ref = [S.share, S.bend]), (S.settle = 0.5);\n  if (S.settle > 0 && (S.settle -= d) \u003c= 0) restart(S);\n  if (input.btnPressed && input.btnPressed[0]) restart(S);\n  S.t += d;\n  const fall = 0.32 * cl(2 / S.speed, 0.7, 2);\n  // The first dozen fall in half a second, so the floor is never bare.\n  if (S.burst > 0) {\n    S.acc0 += d * 24;\n    while (S.acc0 >= 1 && S.burst > 0) S.acc0--, S.burst--, drop(S, 0.3);\n  } else {\n    S.acc += d * 5 * S.speed;\n    while (S.acc >= 1) S.acc--, drop(S, fall);\n  }\n  for (const nd of S.needles) {\n    nd.age += d;\n    if (!nd.landed && nd.age >= nd.fall) land(S, nd);\n  }\n  S.needles = S.needles.filter((nd) => !nd.landed || nd.age \u003c nd.fall + nd.life);\n}\n\n// Lines are laid as points every third of an LED, each lighting its four\n// nearest LEDs by how close it falls, and an LED keeps the brightest\n// colour laid on it, so a heap of needles never washes out to white.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy > FLOOR) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.8) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\nfunction put(S, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = (y * W + x) * 3;\n  S.rgb[p] = max(S.rgb[p], c[0] * a);\n  S.rgb[p + 1] = max(S.rgb[p + 1], c[1] * a);\n  S.rgb[p + 2] = max(S.rgb[p + 2], c[2] * a);\n}\nfunction text(S, str, x, y, colOf) {\n  for (let i = 0; i \u003c str.length; i++) {\n    const ch = str[i];\n    if (ch === \".\") {\n      put(S, x, y + 4, colOf(i), 1);\n      x += 2;\n      continue;\n    }\n    const g = FONT[ch];\n    if (g === undefined) {\n      x += 4;\n      continue;\n    }\n    for (let r = 0; r \u003c 5; r++) for (let b = 0; b \u003c 3; b++) if ((g >> (14 - r * 3 - b)) & 1) put(S, x + b, y + r, colOf(i), 1);\n    x += 4;\n  }\n}\n// Error to trace rows: about 1.7 rows for 0.05, 5 for 0.25, never past 10.\nconst errRows = (e) => (e === Infinity ? TAMP : (TAMP * e) / (abs(e) + 0.25));\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb } = S;\n  rgb.fill(0);\n  const warm = hsv(HUE0 + S.hue, 0.8, 1, S.warm), cool = hsv(HUE0 + 0.45 + S.hue, 0.75, 1, S.cool);\n  // The floor lines are slate whatever the hue: a tinted grey would turn\n  // brown wherever the wheel puts orange.\n  const slate = [0.24, 0.28, 0.34];\n  for (let y = 0; y \u003c= FLOOR; y += D) for (let x = 0; x \u003c W; x++) put(S, x, y, slate, 1);\n  const o = [0, 0], white = [1, 1, 1];\n  // Falling needles first, so landed ones lie over them.\n  const order = S.needles.slice().sort((p, q) => (p.landed === q.landed ? 0 : p.landed ? 1 : -1));\n  for (const nd of order) {\n    let k = 1, rot = 0, keep = 1, dash = 0;\n    const c = nd.cross.length ? warm : cool;\n    let tint = c;\n    if (!nd.landed) {\n      // Falling: drawn dashed, larger and turning, as if seen from above,\n      // settling on its spot as it lands. The colour stays at full\n      // strength, since a dimmed gold reads brown on the panel.\n      const u = nd.age / nd.fall, e = (1 - u) * (1 - u);\n      k = 1 + 0.9 * e;\n      rot = nd.spin * e;\n      dash = 1.5;\n    } else {\n      const age = nd.age - nd.fall, left = nd.life - age;\n      // A white flash on landing, and at the end the needle draws in from\n      // both ends to its middle instead of going dark.\n      const fl = max(0, 1 - age / 0.25);\n      tint = [c[0] + (1 - c[0]) * fl, c[1] + (1 - c[1]) * fl, c[2] + (1 - c[2]) * fl];\n      keep = cl(left / 0.6, 0, 1);\n    }\n    const cr = cos(rot), sr = sin(rot), half = (nd.L / 2) * keep, n = Math.ceil(nd.L * keep * k * 3) + 1;\n    for (let i = 0; i \u003c= n; i++) {\n      const s = -half + (2 * half * i) / n;\n      if (dash && floor((k * (s + half)) / dash) % 2) continue;\n      rel(nd, s, o);\n      plot(S, nd.gx + k * (o[0] * cr - o[1] * sr), nd.gy + k * (o[0] * sr + o[1] * cr), tint, 1);\n    }\n  }\n  // The crossings: a white dash on the line where each one meets it, wide\n  // on landing and narrowing to three LEDs.\n  for (const nd of S.needles) {\n    if (!nd.landed) continue;\n    const age = nd.age - nd.fall, keep = cl((nd.life - age) / 0.6, 0, 1);\n    for (const s of nd.cross) {\n      if (abs(s) > (nd.L / 2) * keep) continue;\n      rel(nd, s, o);\n      const x = floor(nd.gx + o[0]), y = floor(nd.gy + o[1]);\n      if (y > FLOOR) continue;\n      const arm = 1 + max(0, 3 * (1 - age / 0.4));\n      for (let dx = -3; dx \u003c= 3; dx++) put(S, x + dx, y, white, cl(arm + 0.5 - abs(dx), 0, 1));\n      if (age \u003c 0.3) put(S, x, y - 1, white, 1 - age / 0.3), put(S, x, y + 1, white, 1 - age / 0.3);\n    }\n  }\n\n  // The readout. The running estimate to four places: the digits that agree\n  // with pi in white, the rest cool when it is too high (too few crossings)\n  // and warm when too low. The drop count on the right.\n  const est = S.sumC ? (2 * S.sumL) / (D * S.sumC) : Infinity;\n  const str = est \u003c 10 ? est.toFixed(4) : \"-.----\", ref = PI.toFixed(4);\n  let agree = 0;\n  while (agree \u003c str.length && str[agree] === ref[agree]) agree++;\n  const over = est > PI;\n  text(S, str, 1, 99, (i) => (i \u003c agree ? white : over ? cool : warm));\n  const ns = String(min(S.n, 99999));\n  text(S, ns, W - 4 * ns.length, 99, () => slate.map((v) => v * 2));\n  // The pi line, dotted, with its sign.\n  for (let x = TX; x \u003c W; x += 2) put(S, x, TMID, white, 0.35);\n  for (let r = 0; r \u003c 5; r++) for (let b = 0; b \u003c 5; b++) if ((PI_SIGN[r] >> (4 - b)) & 1) put(S, 1 + b, TMID - 2 + r, white, 0.8);\n  // Each drop's column: a bar from the pi line to the estimate over the last\n  // 24 drops, and a white line through the running estimate.\n  let prev = NaN;\n  for (let i = 0; i \u003c HIST; i++) {\n    const x = TX + i, wv = S.win[i], cv = S.cum[i];\n    if (S.mark[i]) for (let y = TMID - TAMP; y \u003c= TMID + TAMP; y++) put(S, x, y, slate, 1.6);\n    if (!Number.isNaN(wv)) {\n      // Its body is a checkerboard at full strength rather than a dim fill,\n      // which would turn the gold brown.\n      const r = errRows(wv - PI), c = r \u003c 0 ? warm : cool, top = Math.round(r);\n      for (let j = 1; j \u003c= abs(top); j++) if (j === abs(top) || (j + x) % 2 === 0) put(S, x, TMID - Math.sign(top) * j, c, 1);\n    }\n    if (!Number.isNaN(cv)) {\n      const y = TMID - errRows(cv - PI);\n      if (!Number.isNaN(prev)) {\n        const lo = min(prev, y), hi = max(prev, y);\n        for (let yy = Math.round(lo); yy \u003c= Math.round(hi); yy++) put(S, x, yy, white, 0.95);\n      } else put(S, x, Math.round(y), white, 0.95);\n      prev = y;\n    } else prev = NaN;\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","burrows-wheeler":"// ===== Patternflow pattern =====\n// Title:   Burrows-Wheeler\n// Family:  algo\n// Idea:    The 128 rotations of a text stand as 128 rows of coloured letters and glide into sorted order, so the last column at the right edge gathers into runs; then the rows fade to their first and last letters and come back one at a time as the LF walk rebuilds them from the last column alone.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Burrows-Wheeler transform (Michael Burrows and David Wheeler, 1994), with its perfect clustering on Sturmian words (Sabrina Mantaci, Antonio Restivo and Marinella Sciortino, 2003) and on interval exchange words (Sebastien Ferenczi and Luca Zamboni, 2013), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Order=0..3, Letters=2..6\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the first letter is bright gold and the last a dim violet at a sixth of its brightness, with green, cyan and blue between them when there are more letters. The run marks, the walk and the mark beside the text's own row are white.\n// Knob 2: Speed. At 2 one text takes 6.6 seconds: 0.4 in rotation order, 1 gliding into sorted order, 1.2 sorted, 1.2 with the shared prefixes lit, 0.3 fading to the first and last columns, 2 for the LF walk at 64 rows a second, and 0.5 for a last look. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Order. How much structure the text has. At 0 every letter is drawn at random; with 2 letters the last column breaks into 64 runs on average and a row needs 8 letters to tell it from its neighbours. At 1 each letter follows a fixed rule on the two before it four times in five, and at 2 the text strings together copies of three short words; for 2 letters both bring the last column down to 25 to 28 runs, and the rows need 17 or 18 letters. At 3 the text is perfectly clustering and the last column is one run per letter in falling order: for 2 letters a Sturmian word, the first one of slope 49/128 next to the Fibonacci word's 0.382, and for more letters the coding of an interval exchange that turns the order of its intervals round. 95% of the rows of the Sturmian word share all 53 letters on the panel with a neighbour.\n// Knob 4: Letters. The size of the alphabet, 2 to 6. Each letter is a step dimmer than the one before, from full brightness down to a sixth of it, so two different letters side by side always differ in brightness as well as colour.\n\nconst W = 64, H = 128, N = 128;\nconst { floor, round, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The first letter of each rotation stands 3 LEDs wide at the left edge\n// and the last 5 wide at the right, the two columns the transform keeps.\n// Between them the next 52 letters, and a gutter for the run marks.\nconst FW = 3, BX = 4, MC = 52, GX = 56, LX = 59;\n// Hue of the first letter at knob 0, and how far round the wheel the\n// alphabet spreads.\nconst HUE0 = 0.13, SPREAD = 0.7;\n// The phases of one text, in seconds at Speed 2: rotation order, the glide,\n// the sorted hold, the shared prefixes, the fade to the first and last\n// columns, the LF walk, and a last look at the whole sorted matrix.\nconst PH = [0.4, 1.0, 1.2, 1.2, 0.3, 2.0, 0.5];\nconst END = PH.reduce((a, b) => a + b, 0);\nconst at = (k) => PH.slice(0, k).reduce((a, b) => a + b, 0);\n// A letter whose row is not known yet is drawn on every other LED of a\n// checkerboard, at this brightness.\nconst GHOST = 0.75;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst rnd = (k) => floor(Math.random() * k);\n\n// The coding of a discrete interval exchange with the order of its\n// intervals turned round: point x in interval k moves to x - s_k + t_k, with\n// t_k the length of the intervals after k. When the map is one cycle of all\n// 128 points, its coding is perfectly clustering: the last column of the\n// sorted rotations is the letters in falling order, one run each.\nfunction exchange(lens) {\n  const m = lens.length, s = [], t = [];\n  let acc = 0;\n  for (let k = 0; k \u003c m; k++) s.push(acc), (acc += lens[k]);\n  for (let k = 0; k \u003c m; k++) t.push(N - s[k] - lens[k]);\n  const lab = (x) => {\n    let k = m - 1;\n    while (x \u003c s[k]) k--;\n    return k;\n  };\n  const w = new Uint8Array(N);\n  let x = rnd(N), c = 0;\n  const x0 = x;\n  do {\n    const k = lab(x);\n    w[c++] = k;\n    x = x - s[k] + t[k];\n  } while (x !== x0 && c \u003c N);\n  return c === N ? w : null;\n}\n\n// Two letters open on the Sturmian word of slope 49/128, the nearest to the\n// Fibonacci word's 1/phi^2 that 128 allows; later texts cut 128 at random.\nfunction clustering(m, first) {\n  if (m === 2 && first) return exchange([79, 49]);\n  for (;;) {\n    // Cut 128 into m pieces of at least 8.\n    const cuts = [];\n    while (cuts.length \u003c m - 1) {\n      const c = 8 + rnd(N - 15);\n      if (cuts.every((d) => abs(d - c) >= 8)) cuts.push(c);\n    }\n    cuts.sort((a, b) => a - b);\n    const lens = [];\n    let prev = 0;\n    for (const c of cuts) lens.push(c - prev), (prev = c);\n    lens.push(N - prev);\n    if (lens[0] \u003c 8) continue;\n    const w = exchange(lens);\n    if (w) return w;\n  }\n}\n\nfunction makeText(order, m, first) {\n  const T = new Uint8Array(N);\n  if (order === 0) for (let i = 0; i \u003c N; i++) T[i] = rnd(m);\n  else if (order === 1) {\n    // Each letter follows a fixed rule on the two before it, four times in\n    // five.\n    const rule = Array.from({ length: m * m }, () => rnd(m));\n    T[0] = rnd(m);\n    T[1] = rnd(m);\n    for (let i = 2; i \u003c N; i++) T[i] = Math.random() \u003c 0.8 ? rule[T[i - 2] * m + T[i - 1]] : rnd(m);\n  } else if (order === 2) {\n    const words = Array.from({ length: 3 }, () => Array.from({ length: 5 + rnd(7) }, () => rnd(m)));\n    let i = 0;\n    while (i \u003c N) for (const c of words[rnd(3)]) if (i \u003c N) T[i++] = c;\n  } else return clustering(m, first);\n  return T;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, sp: 2, ord: -1, m: -1, tau: 0,\n    T: null, rank: new Int32Array(N), L: new Uint8Array(N), walk: new Int32Array(N),\n    keep: new Int32Array(N), seen: new Int32Array(N), rowRot: new Int32Array(H),\n    pos: new Float64Array(N), ord128: Array.from({ length: N }, (_, i) => i),\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(6 * 3), palKey: \"\",\n  };\n}\n\n// Sort the rotations, read off the last column, and take the LF walk from\n// the row that holds the text itself.\nfunction build(s, first) {\n  const T = makeText(s.ord, s.m, first);\n  s.T = T;\n  const idx = Array.from({ length: N }, (_, i) => i);\n  idx.sort((a, b) => {\n    for (let k = 0; k \u003c N; k++) {\n      const d = T[(a + k) % N] - T[(b + k) % N];\n      if (d) return d;\n    }\n    return a - b;\n  });\n  for (let r = 0; r \u003c N; r++) (s.rank[idx[r]] = r), (s.L[r] = T[(idx[r] + N - 1) % N]);\n  // LF(r): the row of the rotation one letter earlier, found from the last\n  // column alone as the count of smaller letters plus the count of the\n  // same letter above row r.\n  const C = new Int32Array(8), occ = new Int32Array(8), lf = new Int32Array(N);\n  for (let r = 0; r \u003c N; r++) C[s.L[r] + 1]++;\n  for (let c = 1; c \u003c 8; c++) C[c] += C[c - 1];\n  for (let r = 0; r \u003c N; r++) lf[r] = C[s.L[r]] + occ[s.L[r]]++;\n  let r = s.rank[0];\n  for (let k = 0; k \u003c N; k++) (s.walk[k] = r), (r = lf[r]);\n  // The prefix each sorted row shares with a neighbour, plus the letter\n  // that tells them apart.\n  const lcp = (a, b) => {\n    let k = 0;\n    while (k \u003c N && T[(a + k) % N] === T[(b + k) % N]) k++;\n    return k;\n  };\n  for (let q = 0; q \u003c N; q++) {\n    const up = q > 0 ? lcp(idx[q - 1], idx[q]) : 0, dn = q \u003c N - 1 ? lcp(idx[q], idx[q + 1]) : 0;\n    s.keep[q] = max(up, dn) + 1;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.sp = cl(kv[1], 0.2, 3);\n  const ord = round(cl(kv[2], 0, 3)), m = round(cl(kv[3], 2, 6));\n  // A turn of Order or Letters starts over at once with a new text, so the\n  // knob shows in the first sort.\n  if (ord !== s.ord || m !== s.m) {\n    s.ord = ord;\n    s.m = m;\n    s.tau = 0;\n    build(s, true);\n  }\n  s.tau += d * (s.sp / 2);\n  if (s.tau >= END) {\n    s.tau -= END;\n    build(s, false);\n  }\n}\n\nfunction palette(s) {\n  const P = s.pal, m = s.m;\n  for (let k = 0; k \u003c m; k++) {\n    const u = k / (m - 1);\n    hsv(HUE0 + s.hue + SPREAD * u, 0.7 + 0.2 * u, 1 - 0.84 * u, P, k * 3);\n  }\n  s.palKey = s.hue + \":\" + m;\n}\n\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.T) return;\n  if (s.palKey !== s.hue + \":\" + s.m) palette(s);\n  const { buf: B, pal: P, T, rank, keep, tau } = s;\n  B.fill(0);\n  const put = (x, y, o, k) => {\n    const i = (y * W + x) * 3;\n    B[i] += P[o] * k;\n    B[i + 1] += P[o + 1] * k;\n    B[i + 2] += P[o + 2] * k;\n  };\n  const white = (x, y, k) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    B[i] += k;\n    B[i + 1] += k;\n    B[i + 2] += k;\n  };\n\n  // Which rotation sits on each row: rotation i glides from row i to its\n  // sorted row, all of them at once, and the rows are dealt out in the\n  // order of where they have got to, so two rows crossing swap places\n  // and no row is ever empty.\n  const g = ease((tau - at(1)) / PH[1]), pos = s.pos, ord = s.ord128;\n  for (let i = 0; i \u003c N; i++) (pos[i] = i + (rank[i] - i) * g), (ord[i] = i);\n  ord.sort((a, b) => pos[a] - pos[b] || a - b);\n  for (let y = 0; y \u003c H; y++) s.rowRot[y] = ord[y];\n\n  // How far each sorted row stays solid. In the prefix phase the ghost\n  // sweeps in from the right and stops at the shared prefix; then it goes\n  // on to column 1, leaving the first column, which is the last column\n  // sorted. The walk makes each row it reaches solid again.\n  const pref = ease((tau - at(3)) / 0.5), drop = ease((tau - at(4)) / PH[4]);\n  const inWalk = tau >= at(5) && tau \u003c at(6);\n  const step = inWalk ? min(N - 1, floor(((tau - at(5)) / PH[5]) * N)) : -1;\n  s.seen.fill(0);\n  if (inWalk) for (let k = 0; k \u003c= step; k++) s.seen[s.walk[k]] = 1;\n  const ghostAll = tau >= at(4) && tau \u003c at(6);\n\n  for (let y = 0; y \u003c H; y++) {\n    const i = s.rowRot[y], q = rank[i];\n    // Letters 0..solid-1 are solid; letter 0 is the first column.\n    let solid = MC + 1;\n    if (tau >= at(3) && tau \u003c at(4)) solid = round(MC + 1 + (keep[q] - MC - 1) * pref);\n    if (ghostAll) solid = round(keep[q] + (1 - keep[q]) * drop);\n    if (inWalk && s.seen[q]) solid = MC + 1;\n    const fo = T[i] * 3;\n    for (let x = 0; x \u003c FW; x++) put(x, y, fo, 1);\n    for (let c = 1; c \u003c= MC; c++) {\n      const o = T[(i + c) % N] * 3, x = BX + c - 1;\n      if (c \u003c solid) put(x, y, o, 1);\n      else if (((x + y) & 1) === 0) put(x, y, o, GHOST);\n    }\n    // The letter that tells the row from its neighbours, lit white while\n    // the prefixes show, so the sorted contexts draw their own outline.\n    if (tau >= at(3) && tau \u003c at(4) && keep[q] \u003c= MC + 1) {\n      const c = keep[q] - 1;\n      if (c === 0) for (let x = 0; x \u003c FW; x++) white(x, y, 0.6 * pref);\n      else white(BX + c - 1, y, 0.6 * pref);\n    }\n    // The last letter of the rotation.\n    const lo = T[(i + N - 1) % N] * 3;\n    for (let x = LX; x \u003c W; x++) put(x, y, lo, 1);\n  }\n\n  // Run marks in the gutter, once the rows are sorted: one at the top of\n  // each run of the last column.\n  const sorted = ease((tau - at(2)) / 0.4);\n  if (sorted > 0)\n    for (let q = 1; q \u003c N; q++)\n      if (s.L[q] !== s.L[q - 1]) for (let x = GX; x \u003c LX; x++) white(x, q, 0.55 * sorted);\n\n  // The walk: the row it stands on flashes, and a line runs from its last\n  // letter to the same letter's place in the first column, the next row.\n  if (inWalk) {\n    for (let back = 0; back \u003c 3; back++) {\n      const k = step - back;\n      if (k \u003c 0 || k >= N - 1) continue;\n      const r0 = s.walk[k], r1 = s.walk[k + 1], a = (0.7 * (3 - back)) / 3;\n      if (back === 0) for (let x = BX; x \u003c GX; x++) white(x, r0, 0.35);\n      for (let x = FW; x \u003c LX; x++) white(x, round(r0 + ((r1 - r0) * (LX - 1 - x)) / (LX - 1 - FW)), a * 0.6);\n      if (back === 0) for (let x = 0; x \u003c FW; x++) white(x, r1, 0.6);\n    }\n  }\n  // The text itself: a white mark beside the row it is on.\n  const home = s.rowRot.indexOf(0);\n  if (home >= 0) for (let x = GX; x \u003c LX; x++) white(x, home, x === GX ? 1 : 0.6);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, min(255, round(B[p] * 255)), min(255, round(B[p + 1] * 255)), min(255, round(B[p + 2] * 255)));\n}\n","hex-theorem":"// ===== Patternflow pattern =====\n// Title:   Hex Theorem\n// Family:  cells\n// Idea:    A Hex board stands on its long diagonal and fills one random cell at a time until one colour's chain joins that colour's two edges and lights up with a pulse running along it; on the full board the loser's cells flood in from both of its edges and stop against the chain, and Gale's walk threads the seam between the colours from the bottom corner out to the corner that names the winner.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hex theorem (David Gale, 1979), on the game of Hex (Piet Hein, 1942; John Nash, 1948), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=7..15, Bias=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 player A, who owns the lower right and upper left edges, is azure and player B, who owns the other two, is magenta, on dark slate empty cells; a winning chain brightens, its shortest path runs near white, and the loser's two floods take two pale tints of its colour. At 0.25 A is violet and B lime, at 0.5 A rose and B teal, at 0.75 A green and B blue. The wheel skips the stretch from orange to yellow, which reads brown and olive on the dim cells.\n// Knob 2: Speed. At 2 a 7 x 7 board fills at 18 cells a second and is full in 2.7 s; a 15 x 15 board fills at 57 a second and is full in 4 s. The win holds the filling for 0.45 s, then the proof takes 1.9 s, the hold 1.3 s and the clearing wave 0.9 s, so a 7 x 7 board turns over every 7.3 s. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Size. The board's side, 7 to 15 cells. Cells are about 8 LEDs across at 7 and 4 at 15, stood 18 to 21% taller than regular so the long diagonal runs 116 rows. At even odds the first chain shows when 86% of a 7 x 7 board is filled (median of 2,000 boards) and 91% of a 15 x 15 board, and Gale's walk is 32 and 110 edges long.\n// Knob 4: Bias. Each cell goes to A with chance 0.5 + 0.25 x Bias, from 0.25 to 0.75, and 0.515 at the opening 0.06. A then wins 56% of 7 x 7 boards and 59% of 15 x 15; at Bias 0.5 (0.625) 87% and 97%. With a bias the chain shows when the winner holds about half the board, the threshold of site percolation on the triangular lattice: after 80% of the cells at 0.625 and 67% at 0.75.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, round } = Math;\nconst R3 = sqrt(3);\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The six neighbours in turn round a cell, in axial coordinates (q, r).\nconst DQ = [1, 1, 0, -1, -1, 0], DR = [0, -1, -1, 0, 1, 1];\n// Board seconds at Speed 2: a 7 x 7 board fills in FILL, longer boards as\n// the square root of their side; then the pause on the win, the proof\n// (flood and walk), the hold and the clearing wave.\nconst FILL = 2.7, PAUSE = 0.45, PROOF = 1.9, HOLD = 1.3, CLEAR = 0.9;\n// The two players' hues at knob 0, before the wheel below bends them.\nconst HUE_A = 0.324, HUE_B = 0.797;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The knob's wheel skips the stretch from orange through yellow to lime,\n// which reads brown and olive on the dim cells.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    n: 0, hue: 0, speed: 2, p: 0.5, clock: 0,\n    rgb: new Float32Array(N * 3), cc: null, tmp: new Float32Array(3),\n  };\n}\n\n// Pixel to cell, once per board size. Cell (q, r) sits at\n// x = (q - r) s / 2, y = -(q + r) h, so (0, 0) is the bottom corner,\n// (n-1, n-1) the top, and the rows r = 0 and r = n - 1 are the lower right\n// and upper left sides.\nfunction layout(S, n) {\n  const s = 58 / n;\n  const ky = min(1.25, 116 / (s * (R3 * (n - 1) + 2 / R3)));\n  const h = (s * R3 / 2) * ky, ox = 32, oy = 64 + (n - 1) * h;\n  const cell = new Int16Array(N).fill(-1), shade = new Float32Array(N), side = new Uint8Array(N);\n  const hexm = (dq, dr) => max(abs(dq + dr / 2), abs(dr + dq / 2), abs((dq - dr) / 2));\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const u = (x + 0.5 - ox) / (s / 2), v = (oy - y - 0.5) / h;\n      const fq = (u + v) / 2, fr = (v - u) / 2, fs = -fq - fr;\n      let q = round(fq), r = round(fr);\n      const t = round(fs), eq = abs(q - fq), er = abs(r - fr), es = abs(t - fs);\n      if (eq > er && eq > es) q = -r - t;\n      else if (er > es) r = -q - t;\n      if (q >= 0 && q \u003c n && r >= 0 && r \u003c n) {\n        cell[p] = r * n + q;\n        // A soft seam a pixel wide where two cells meet.\n        shade[p] = cl(((0.5 - hexm(fq - q, fr - r)) * s - 0.3) / 0.9, 0, 1);\n        continue;\n      }\n      // Outside: how far to the nearest cell of the board, for the home edges.\n      const cq = cl(q, 0, n - 1), cr = cl(r, 0, n - 1);\n      let m = 9;\n      for (let k = -1; k \u003c 6; k++) {\n        const aq = cq + (k \u003c 0 ? 0 : DQ[k]), ar = cr + (k \u003c 0 ? 0 : DR[k]);\n        if (aq \u003c 0 || aq >= n || ar \u003c 0 || ar >= n) continue;\n        m = min(m, hexm(fq - aq, fr - ar));\n      }\n      const out = (m - 0.5) * s;\n      const a = cl(out - 0.4, 0, 1) * cl(2.8 - out, 0, 1);\n      if (a \u003c= 0) continue;\n      shade[p] = a;\n      side[p] = max(-fr, fr - (n - 1)) > max(-fq, fq - (n - 1)) ? 1 : 2;\n    }\n  Object.assign(S, { s, h, ox, oy, cell, shade, side });\n}\n\nfunction newBoard(S, n) {\n  if (n !== S.n) layout(S, n), (S.cc = new Float32Array(n * n * 3));\n  S.n = n;\n  const M = n * n;\n  S.cells = new Uint8Array(M);\n  S.at = new Float32Array(M).fill(-99);\n  // Each cell's draw is made as the board is laid and held against Bias\n  // when the cell's turn comes, so a turn of the knob recolours only the\n  // cells still to come.\n  S.u = new Float32Array(M);\n  S.order = new Int16Array(M);\n  for (let i = 0; i \u003c M; i++) (S.order[i] = i), (S.u[i] = Math.random());\n  for (let i = M - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = S.order[i];\n    S.order[i] = S.order[j];\n    S.order[j] = t;\n  }\n  // Union-find over the cells and four side nodes: A's rows r = 0 and\n  // r = n - 1, then B's columns q = 0 and q = n - 1.\n  S.par = new Int16Array(M + 4);\n  for (let i = 0; i \u003c M + 4; i++) S.par[i] = i;\n  S.k = 0;\n  S.acc = 0;\n  S.wait = 0;\n  S.winner = 0;\n  S.winAt = 0;\n  S.path = [];\n  S.onPath = new Int16Array(M).fill(-1);\n  S.club = new Uint8Array(M);\n  S.flood = new Int16Array(M);\n  S.fmax = 1;\n  S.walk = null;\n  S.phase = 0;\n  S.pt = 0;\n}\n\nfunction find(P, i) {\n  while (P[i] !== i) (P[i] = P[P[i]]), (i = P[i]);\n  return i;\n}\nfunction join(P, a, b) {\n  a = find(P, a);\n  b = find(P, b);\n  if (a !== b) P[a] = b;\n}\n\nfunction place(S) {\n  const n = S.n, M = n * n, P = S.par, i = S.order[S.k++], c = S.u[i] \u003c S.p ? 1 : 2;\n  S.cells[i] = c;\n  S.at[i] = S.clock;\n  const q = i % n, r = (i / n) | 0;\n  for (let k = 0; k \u003c 6; k++) {\n    const aq = q + DQ[k], ar = r + DR[k];\n    if (aq >= 0 && aq \u003c n && ar >= 0 && ar \u003c n && S.cells[ar * n + aq] === c) join(P, i, ar * n + aq);\n  }\n  if (c === 1) {\n    if (r === 0) join(P, i, M);\n    if (r === n - 1) join(P, i, M + 1);\n  } else {\n    if (q === 0) join(P, i, M + 2);\n    if (q === n - 1) join(P, i, M + 3);\n  }\n  if (!S.winner) {\n    if (find(P, M) === find(P, M + 1)) win(S, 1);\n    else if (find(P, M + 2) === find(P, M + 3)) win(S, 2);\n  }\n  if (S.winner) {\n    // The winning chain's whole cluster, which grows as the board fills.\n    const root = find(P, S.winner === 1 ? M : M + 2);\n    for (let j = 0; j \u003c M; j++) S.club[j] = S.cells[j] === S.winner && find(P, j) === root ? 1 : 0;\n  }\n}\n\nconst onSide = (n, c, i, which) => (c === 1 ? ((i / n) | 0) === (which ? n - 1 : 0) : i % n === (which ? n - 1 : 0));\n\n// Breadth-first distances through colour c from one of its sides.\nfunction bfs(S, c, which, dist) {\n  const n = S.n, M = n * n, queue = new Int16Array(M);\n  dist.fill(-1);\n  let head = 0, tail = 0;\n  for (let i = 0; i \u003c M; i++) if (S.cells[i] === c && onSide(n, c, i, which)) (dist[i] = 0), (queue[tail++] = i);\n  while (head \u003c tail) {\n    const i = queue[head++], q = i % n, r = (i / n) | 0;\n    for (let k = 0; k \u003c 6; k++) {\n      const aq = q + DQ[k], ar = r + DR[k], j = ar * n + aq;\n      if (aq \u003c 0 || aq >= n || ar \u003c 0 || ar >= n || S.cells[j] !== c || dist[j] >= 0) continue;\n      dist[j] = dist[i] + 1;\n      queue[tail++] = j;\n    }\n  }\n}\n\n// The first chain: the shortest path through the winner's cells from one\n// home edge to the other, found the moment the two edges join.\nfunction win(S, c) {\n  const n = S.n, M = n * n, d0 = new Int16Array(M);\n  S.winner = c;\n  S.winAt = S.clock;\n  S.wait = PAUSE;\n  bfs(S, c, 0, d0);\n  let end = -1;\n  for (let i = 0; i \u003c M; i++) if (d0[i] >= 0 && onSide(n, c, i, 1) && (end \u003c 0 || d0[i] \u003c d0[end])) end = i;\n  const path = [end];\n  while (d0[path[path.length - 1]] > 0) {\n    const i = path[path.length - 1], q = i % n, r = (i / n) | 0;\n    for (let k = 0; k \u003c 6; k++) {\n      const aq = q + DQ[k], ar = r + DR[k], j = ar * n + aq;\n      if (aq >= 0 && aq \u003c n && ar >= 0 && ar \u003c n && d0[j] === d0[i] - 1) {\n        path.push(j);\n        break;\n      }\n    }\n  }\n  path.reverse();\n  S.path = path;\n  path.forEach((i, k) => (S.onPath[i] = k));\n}\n\n// On the full board: the loser's cells reached from each of its edges, by\n// distance, and Gale's walk. The walk starts at the bottom corner on the\n// seam between the two border rows, and at every corner of a cell it meets\n// it turns so that A stays on one hand and B on the other. It cannot close\n// or stop, so it leaves at another corner, and which one says who won.\nfunction proof(S) {\n  const n = S.n, M = n * n, lose = 3 - S.winner, d = new Int16Array(M);\n  S.flood.fill(-1);\n  for (const which of [0, 1]) {\n    bfs(S, lose, which, d);\n    for (let i = 0; i \u003c M; i++) if (d[i] >= 0) S.flood[i] = which * 1000 + d[i];\n  }\n  S.fmax = 1;\n  for (let i = 0; i \u003c M; i++) if (S.flood[i] >= 0) S.fmax = max(S.fmax, S.flood[i] % 1000);\n  const col = (q, r) => {\n    const qi = q >= 0 && q \u003c n, ri = r >= 0 && r \u003c n;\n    if (qi && ri) return S.cells[r * n + q];\n    if (!qi && !ri) return 0;\n    return ri ? 2 : 1;\n  };\n  const px = (q, r) => S.ox + ((q - r) * S.s) / 2, py = (q, r) => S.oy - (q + r) * S.h;\n  const vert = (a, b, c) => [(px(a[0], a[1]) + px(b[0], b[1]) + px(c[0], c[1])) / 3, (py(a[0], a[1]) + py(b[0], b[1]) + py(c[0], c[1])) / 3];\n  // The cell beside both a and b that is not x.\n  const other = (a, b, x) => {\n    const dq = b[0] - a[0], dr = b[1] - a[1];\n    let k = 0;\n    while (DQ[k] !== dq || DR[k] !== dr) k++;\n    const u = [a[0] + DQ[(k + 5) % 6], a[1] + DR[(k + 5) % 6]];\n    return u[0] === x[0] && u[1] === x[1] ? [a[0] + DQ[(k + 1) % 6], a[1] + DR[(k + 1) % 6]] : u;\n  };\n  let a = [0, -1], b = [-1, 0], back = [-1, -1], ahead = [0, 0];\n  const pts = [vert(a, b, back)];\n  for (let guard = 0; guard \u003c 4 * M + 20; guard++) {\n    pts.push(vert(a, b, ahead));\n    const c = col(ahead[0], ahead[1]);\n    if (c === 0) break;\n    let dropped;\n    if (c === 1) (dropped = a), (a = ahead);\n    else (dropped = b), (b = ahead);\n    ahead = other(a, b, dropped);\n  }\n  S.walk = pts;\n  S.walkEnd = ahead[0] === n ? 2 : 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = cl(floor(kv[2] + 0.5), 7, 15);\n  S.p = 0.5 + 0.25 * cl(kv[3], -1, 1);\n  if (n !== S.n) newBoard(S, n);\n  const g = (d * S.speed) / 2;\n  S.clock += g;\n  const M = n * n;\n  if (S.phase === 0) {\n    if (S.wait > 0) S.wait -= g;\n    else {\n      S.acc += (g * M) / (FILL * sqrt(n / 7));\n      while (S.acc >= 1 && S.k \u003c M) {\n        S.acc -= 1;\n        const had = S.winner;\n        place(S);\n        if (!had && S.winner) break;\n      }\n      if (S.k >= M) (S.phase = 1), (S.pt = 0), proof(S);\n    }\n  } else {\n    S.pt += g;\n    if (S.phase === 1 && S.pt >= PROOF + HOLD) (S.phase = 2), (S.pt = 0);\n    else if (S.phase === 2 && S.pt >= CLEAR) newBoard(S, n);\n  }\n}\n\n// Lines for the walk: points every third of a pixel, each laid over its\n// four nearest LEDs by how close it falls, so the thread stays white\n// across the small cells of a big board.\nfunction plot(rgb, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 2.5) * a, p = (yy * W + xx) * 3;\n      for (let k = 0; k \u003c 3; k++) rgb[p + k] += (c[k] - rgb[p + k]) * w;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cells) return;\n  const n = S.n, M = n * n, cc = S.cc, rgb = S.rgb, T = S.tmp;\n  const hA = wheel(HUE_A + S.hue), hB = wheel(HUE_B + S.hue);\n  const end = S.phase >= 1, pt = S.pt;\n  const pulse = (S.clock - S.winAt) / 1.3;\n  for (let i = 0, o = 0; i \u003c M; i++, o += 3) {\n    const c = S.cells[i];\n    if (!c) {\n      (cc[o] = 0.1), (cc[o + 1] = 0.1), (cc[o + 2] = 0.15);\n      continue;\n    }\n    const hc = c === 1 ? hA : hB;\n    // Once a chain has won, the other cells step back.\n    let s = 0.85, v = S.winner ? 0.5 : 0.62;\n    if (S.club[i]) (s = 0.72), (v = 1);\n    if (end && !S.club[i]) {\n      // The full board: the loser's cells light up from each of its edges,\n      // a little apart on the wheel, and stop against the chain.\n      const f = S.flood[i];\n      const at = f >= 0 ? (f % 1000) / S.fmax : 2;\n      const lit = S.phase === 2 ? (f >= 0 ? 1 : 0) : cl((pt / (PROOF * 0.6) - at) * 3, 0, 1);\n      hsv(hc + lit * (f >= 1000 ? 0.035 : -0.035), 0.62 - 0.17 * lit, 0.3 + 0.5 * lit, cc, o);\n    } else hsv(hc, s, v, cc, o);\n    const k = S.onPath[i];\n    if (k >= 0) {\n      // The chain lights from end to end at 30 cells a second, then a pulse runs along it.\n      const shown = (S.clock - S.winAt) * 30 - k;\n      if (shown > 0) {\n        const ph = pulse - floor(pulse) - k / S.path.length;\n        const w = 0.4 + 0.55 * exp(-((ph - round(ph)) ** 2) * 60) + 0.4 * exp(-shown / 6);\n        for (let e = 0; e \u003c 3; e++) cc[o + e] += (1 - cc[o + e]) * min(1, w);\n      }\n    }\n    // A fresh cell flashes white.\n    const age = S.clock - S.at[i];\n    if (age \u003c 0.4) {\n      const f = 0.85 * exp(-age / 0.1);\n      for (let e = 0; e \u003c 3; e++) cc[o + e] += (1 - cc[o + e]) * f;\n    }\n  }\n  // The clearing wave runs down the board.\n  let cut = -1;\n  if (S.phase === 2) cut = (pt / CLEAR) * (H + 30) - 15;\n  hsv(hA, 0.9, 1, T, 0);\n  const eA = [T[0], T[1], T[2]];\n  hsv(hB, 0.9, 1, T, 0);\n  const eB = [T[0], T[1], T[2]];\n  const { cell, shade, side } = S;\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const i = cell[p];\n    if (i >= 0) {\n      let a = shade[p];\n      if (cut > -2) a *= cl((floor(p / W) - cut) / 12, 0, 1);\n      (rgb[o] = cc[i * 3] * a), (rgb[o + 1] = cc[i * 3 + 1] * a), (rgb[o + 2] = cc[i * 3 + 2] * a);\n    } else if (side[p]) {\n      const e = side[p] === 1 ? eA : eB, a = shade[p];\n      (rgb[o] = e[0] * a), (rgb[o + 1] = e[1] * a), (rgb[o + 2] = e[2] * a);\n    } else rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n  }\n  // Gale's walk, drawn in along the seams after the flood has started,\n  // with a spark at its head; once it is out, the spark runs it again\n  // from the bottom corner every 1.2 seconds.\n  if (S.phase >= 1 && S.walk) {\n    const pts = S.walk, L = pts.length - 1, drawn = S.phase === 1 && pt \u003c PROOF;\n    const f = drawn ? cl((pt - PROOF * 0.25) / (PROOF * 0.75), 0, 1) * L : L;\n    const head = drawn ? f : (((S.phase === 1 ? pt - PROOF : pt + HOLD) / 1.2) % 1) * L;\n    const col = [0.95, 0.95, 0.86], hot = [1, 1, 1];\n    for (let k = 0; k \u003c L && k \u003c f; k++) {\n      const [xa, ya] = pts[k], [xb, yb] = pts[k + 1], u = min(1, f - k);\n      const len = Math.hypot(xb - xa, yb - ya), m = Math.ceil(len * 3 * u) || 1;\n      for (let e = 0; e \u003c= m; e++) {\n        const y = ya + ((yb - ya) * u * e) / m, a = cut > -2 ? cl((y - cut) / 12, 0, 1) : 1;\n        if (a \u003c= 0) continue;\n        const x = xa + ((xb - xa) * u * e) / m, near = cl(1 - abs(k + (u * e) / m - head) / 3, 0, 1);\n        plot(rgb, x, y, near > 0 ? hot : col, (0.8 + 0.2 * near) * a);\n        if (near > 0.5) for (const [dx, dy] of [[-0.6, 0], [0.6, 0], [0, -0.6], [0, 0.6]]) plot(rgb, x + dx, y + dy, hot, near * a);\n      }\n    }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","imaginary-geometry":"// ===== Patternflow pattern =====\n// Title:   Imaginary Geometry\n// Family:  noise\n// Idea:    Thirteen flow lines of a drifting Gaussian free field leave one point on the bottom edge as a fan of angles and climb to one point on the top edge, each turning wherever the field turns it, so a line of larger angle always stays to the left, and where two come within an LED they run on together as one and part again without ever crossing.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: imaginary geometry, the flow lines of the Gaussian free field (Jason Miller and Scott Sheffield, 2016); Gaussian Free Field (round 52) draws the same field's level lines, this one its flow lines, pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Kappa=0.5..3, Spread=4..6.2\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the lines run from magenta on the left (the largest angle) through violet and blue to cyan on the right, with white marks where a line joins another for four LEDs or more. Behind them the direction a line of angle 0 would take at each LED shows as a faint hue, 22 of 255 in its brightest channel; that faint wheel skips orange and yellow, which read brown and olive so dark.\n// Knob 2: Speed. How fast the field drifts. Each of its 2,048 sine modes is a smooth random process whose law stays the free field's: at 2 the largest mode forgets itself in 1.5 s and the finest, 4 LEDs from crest to crest, in 0.24 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Kappa. The SLE parameter. It sets chi = 2/sqrt(kappa) - sqrt(kappa)/2, from 2.47 at 0.5 to 0.29 at 3, and the lines turn by the field divided by chi. At 0.5 they wobble round a lens 37 LEDs wide at mid-height and ride on another line for 7% of their length, at 1 for 19%. At 2 they braid into one winding bundle 26 LEDs wide, riding together 42% of the way, and at 3 into a ribbon 11 LEDs wide, 55%. The field is smoothed over 1.2 LEDs up to kappa 1.55, then over a width that grows to 4.1 LEDs at 3, so that a line's turning stays near 0.6 radians per LED, root mean square, and the line stays a line.\n// Knob 4: Spread. The fan of angles, in radians: thirteen lines evenly from -2 to +2 at 4, up to -3.1 to +3.1 at 6.2. At kappa 0.5 the lens is 37 LEDs wide at mid-height at 4 and 57 at 6.2, where the outermost lines hug the side edges: a line whose angle reached pi would run along the bottom edge.\n// Buttons: K1 tap draws a new field, and the fan grows from the bottom point again over about a second.\n\nconst W = 64, H = 128, NX = W + 1, NY = H + 1, NN = NX * NY;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, atan2, hypot, PI } = Math;\nconst TAU = 2 * PI, HALF = PI / 2;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Lines, sine modes across and up, and points a line may hold.\nconst NL = 13, MM = 32, NM = 64, MAXP = 3000;\n// The root on the bottom edge and the target on the top, both at x = 32.\n// Positions are in LEDs with v measured up from the bottom edge, and the\n// field lives on the 65 x 129 nodes at the LED corners.\nconst RX = 32;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The field is h0 + lambda U + chi V. h0 is the free field, zero on the\n// edges. lambda U carries the boundary values -lambda left of the root and\n// +lambda right of it that make the angle-0 line from root to target an\n// SLE(kappa), with lambda = pi / sqrt(kappa). chi V is the coordinate change\n// h o phi - chi arg phi' from the half-plane: V is the boundary's own\n// turning, 0 along the bottom, pi/2 up the sides and pi along the top,\n// minus on the left. U and V jump at the root and the target, so each is\n// split into those jumps, written out (argR, argT), and a smooth rest\n// solved once on the nodes.\nconst argR = (u, v) => atan2(v, u - RX);\nconst argT = (u, v) => (v >= H ? (u >= RX ? 0 : -PI) : atan2(v - H, u - RX));\n\n// Laplace's equation inside, the edge nodes held: over-relaxed sweeps.\nfunction harmonic(F) {\n  const om = 2 / (1 + sin(PI / NY));\n  for (let it = 0; it \u003c 4000; it++) {\n    let worst = 0;\n    for (let j = 1; j \u003c H; j++)\n      for (let i = 1; i \u003c W; i++) {\n        const p = j * NX + i, d = om * (0.25 * (F[p - 1] + F[p + 1] + F[p - NX] + F[p + NX]) - F[p]);\n        F[p] += d;\n        if (abs(d) > worst) worst = abs(d);\n      }\n    if (worst \u003c 1e-7) break;\n  }\n}\n\n// Sine modes of the 64 x 128 rectangle. With the free field's covariance\n// -log|x - y|, mode (m, n) has standard deviation sqrt(2 pi / mu) on the\n// orthonormal basis, mu being its eigenvalue. TC is its time constant in\n// seconds at Speed 1: 3 s for the largest, down as mu^-1/4.\nconst SXT = new Float64Array(MM * NX), SYT = new Float64Array(NM * NY);\nfor (let m = 0; m \u003c MM; m++) for (let i = 0; i \u003c NX; i++) SXT[m * NX + i] = sin((PI * (m + 1) * i) / W);\nfor (let n = 0; n \u003c NM; n++) for (let j = 0; j \u003c NY; j++) SYT[n * NY + j] = sin((PI * (n + 1) * j) / H);\nconst MU = new Float64Array(MM * NM), AMP = new Float64Array(MM * NM), TC = new Float64Array(MM * NM);\nfor (let m = 0; m \u003c MM; m++)\n  for (let n = 0; n \u003c NM; n++) {\n    const q = m * NM + n, mu = PI * PI * (((m + 1) / W) ** 2 + ((n + 1) / H) ** 2);\n    MU[q] = mu;\n    AMP[q] = sqrt((2 * PI) / mu) * (2 / sqrt(W * H));\n    TC[q] = 3 * (MU[0] / mu) ** 0.25;\n  }\n\nfunction gauss() {\n  const a = Math.random() || 1e-12, b = Math.random();\n  return sqrt(-2 * log(a)) * cos(TAU * b);\n}\n\nexport function setup(params) {\n  const SU = new Float64Array(NN), SV = new Float64Array(NN);\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c NX; i++) {\n      if (i > 0 && i \u003c W && j > 0 && j \u003c H) continue;\n      const p = j * NX + i;\n      let ud, vd;\n      if (j === 0) (ud = i \u003c RX ? -1 : i > RX ? 1 : 0), (vd = i === 0 ? -PI / 4 : i === W ? PI / 4 : 0);\n      else if (j === H) (ud = i \u003c RX ? -1 : i > RX ? 1 : 0), (vd = i === 0 ? (-3 * PI) / 4 : i === W ? (3 * PI) / 4 : i \u003c RX ? -PI : i > RX ? PI : 0);\n      else if (i === 0) (ud = -1), (vd = -HALF);\n      else (ud = 1), (vd = HALF);\n      const at = argT(i, j), aR = j === 0 ? ud : 1 - (2 / PI) * argR(i, j);\n      // The two ends themselves take the rest's limit there, which is 0.\n      const end = i === RX && (j === 0 || j === H);\n      SU[p] = end ? 0 : ud - aR - (1 + (2 / PI) * at);\n      SV[p] = end ? 0 : vd - (PI + 2 * at);\n    }\n  harmonic(SU);\n  harmonic(SV);\n  // The jumps at the nodes too, for the look-up away from the two ends.\n  const AR = new Float64Array(NN), AV = new Float64Array(NN);\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c NX; i++) {\n      const p = j * NX + i, at = argT(i, j);\n      AR[p] = 2 + (2 / PI) * (at - argR(i, j));\n      AV[p] = PI + 2 * at;\n    }\n  const K = MM * NM, X = new Float64Array(K), Y = new Float64Array(K);\n  for (let q = 0; q \u003c K; q++) (X[q] = gauss()), (Y[q] = gauss() / TC[q]);\n  params.s = {\n    SU, SV, AR, AV, X, Y, C: new Float64Array(K), B: new Float64Array(MM * NY), h: new Float64Array(NN), P: new Float64Array(NN), F: new Float64Array(NN),\n    own: new Int16Array(W * H), pts: Array.from({ length: NL }, () => new Float32Array(MAXP * 2)), vis: Array.from({ length: NL }, () => new Uint8Array(MAXP)), np: new Int32Array(NL),\n    jx: new Float32Array(40), jy: new Float32Array(40), nj: 0,\n    rgb: new Float32Array(W * H * 3), col: new Float64Array(3), pal: new Float32Array(192), palHue: -1,\n    t: 0, hue: 0, speed: 2, kappa: 0.5, spread: 4, chi: 1, lc: 1, eps: 1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.5, 4], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.kappa = cl(kv[2], 0.5, 3);\n  S.spread = cl(kv[3], 4, 6.2);\n  if (input.btnPressed && input.btnPressed[0]) {\n    for (let q = 0; q \u003c S.X.length; q++) (S.X[q] = gauss()), (S.Y[q] = gauss() / TC[q]);\n    S.t = 0;\n  }\n  S.t += d;\n  const rk = sqrt(S.kappa);\n  S.chi = 2 / rk - rk / 2;\n  // lambda / chi = 2 pi / (4 - kappa): how far the boundary values turn a line.\n  S.lc = PI / rk / S.chi;\n  // A line turns by the gradient of h / chi, whose spread is 1 / (sqrt 2 eps\n  // chi) for a field smoothed over eps: eps keeps that near 0.6 rad per LED,\n  // and never under 1.2 LEDs, where the finest modes run out.\n  S.eps = max(1.2, 1 / (sqrt(2) * S.chi * 0.6));\n  // Each mode is a critically damped oscillator driven by noise: its path is\n  // smooth, so the lines glide, and its law stays the unit normal.\n  const de = d * S.speed, X = S.X, Y = S.Y;\n  for (let q = 0; q \u003c X.length; q++) {\n    const tc = TC[q];\n    Y[q] += (-2 * Y[q] / tc - X[q] / (tc * tc)) * de + (2 / (tc * sqrt(tc))) * sqrt(de) * gauss();\n    X[q] += Y[q] * de;\n  }\n  const C = S.C, e2 = (S.eps * S.eps) / 2, kmax2 = 4.6 / e2;\n  let mTop = 0;\n  for (let m = 0; m \u003c MM; m++)\n    for (let n = 0; n \u003c NM; n++) {\n      const q = m * NM + n;\n      if (MU[q] > kmax2) {\n        C[q] = 0;\n        continue;\n      }\n      C[q] = AMP[q] * exp(-MU[q] * e2) * X[q];\n      if (m + 1 > mTop) mTop = m + 1;\n    }\n  // Mode k is even or odd about the middle as k is odd or even, so each sum\n  // serves a node and its mirror.\n  const B = S.B, h = S.h;\n  for (let m = 0; m \u003c mTop; m++)\n    for (let j = 0; j \u003c= H / 2; j++) {\n      let e = 0, o = 0;\n      for (let n = 0; n \u003c NM; n += 2) {\n        e += C[m * NM + n] * SYT[n * NY + j];\n        o += C[m * NM + n + 1] * SYT[(n + 1) * NY + j];\n      }\n      B[m * NY + j] = e + o;\n      B[m * NY + H - j] = e - o;\n    }\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = 0; i \u003c= W / 2; i++) {\n      let e = 0, o = 0;\n      for (let m = 0; m \u003c mTop; m += 2) {\n        e += SXT[m * NX + i] * B[m * NY + j];\n        if (m + 1 \u003c mTop) o += SXT[(m + 1) * NX + i] * B[(m + 1) * NY + j];\n      }\n      h[j * NX + i] = e + o;\n      h[j * NX + W - i] = e - o;\n    }\n  // P is the angle field without the jumps at the ends, F with them.\n  const P = S.P, F = S.F, ic = 1 / S.chi, lc = S.lc;\n  for (let p = 0; p \u003c NN; p++) {\n    P[p] = h[p] * ic + lc * S.SU[p] + S.SV[p];\n    F[p] = P[p] + lc * S.AR[p] + S.AV[p];\n  }\n  trace(S);\n}\n\n// h / chi at a point: the angle a line of angle 0 turns from north. Within\n// 6 LEDs of either end the jumps are written out instead of interpolated.\nfunction phiAt(S, u, v) {\n  const fu = cl(u, 0, W - 1e-6), fv = cl(v, 0, H - 1e-6), i = floor(fu), j = floor(fv), a = fu - i, b = fv - j, p = j * NX + i;\n  if ((u - RX) ** 2 + v * v > 36 && (u - RX) ** 2 + (v - H) ** 2 > 36) {\n    const F = S.F;\n    return (F[p] * (1 - a) + F[p + 1] * a) * (1 - b) + (F[p + NX] * (1 - a) + F[p + NX + 1] * a) * b;\n  }\n  const P = S.P, rest = (P[p] * (1 - a) + P[p + 1] * a) * (1 - b) + (P[p + NX] * (1 - a) + P[p + NX + 1] * a) * b;\n  const at = argT(u, min(v, H));\n  return rest + S.lc * (2 + (2 / PI) * (at - argR(u, max(v, 0)))) + PI + 2 * at;\n}\n\n// Each line follows exp(i (h / chi + theta)) from the root, by midpoint steps\n// of half an LED that shorten near the ends. The middle line goes first and\n// the rest pair off outward. A line that steps into an LED an earlier line\n// holds rides with it, undrawn, until it steps into a free LED again. In the\n// smoothed field two lines of different angle cannot even touch, since they\n// would cross with the larger angle going right; in the free field itself\n// lines whose angles differ by less than pi kappa / (4 - kappa) do touch\n// and bounce off. Drawn at one LED, both look like this.\nfunction trace(S) {\n  const own = S.own, grow = S.t \u003c 2.5 ? 180 * S.t : 1e9, lc = S.lc, sp = S.spread, mid = (NL - 1) / 2;\n  own.fill(0);\n  S.nj = 0;\n  for (let k = 0; k \u003c= mid; k++)\n    for (const L of k ? [mid + k, mid - k] : [mid]) {\n      const th = -sp / 2 + (sp * L) / (NL - 1), pts = S.pts[L], vis = S.vis[L], id = L + 1;\n      // Near the root the field is the half-plane's alone, and the line of\n      // angle theta leaves along the one ray it maps to itself.\n      const a0 = (HALF + th + lc) / (1 + (2 * lc) / PI);\n      let u = RX + cos(a0), v = sin(a0), n = 0, len = 0, ride = false, ju = 0, jv = 0, rc = 0;\n      (vis[n] = 1), (pts[2 * n] = RX), (pts[2 * n++ + 1] = 0);\n      (vis[n] = 1), (pts[2 * n] = u), (pts[2 * n++ + 1] = v);\n      let ci = floor(u), cj = floor(H - v);\n      while (n \u003c MAXP) {\n        const rr = hypot(u - RX, v), rt = hypot(u - RX, v - H), s = cl(0.15 * min(rr, rt), 0.05, 0.5);\n        let f = HALF + th + phiAt(S, u, v);\n        f = HALF + th + phiAt(S, u + 0.5 * s * cos(f), v + 0.5 * s * sin(f));\n        u += s * cos(f);\n        v += s * sin(f);\n        len += s;\n        if (rt \u003c 0.8 || u \u003c 0.05 || u > W - 0.05 || v \u003c 0.05 || v > H - 0.05 || len > grow) break;\n        const ni = floor(u), nj = floor(H - v);\n        if (ni !== ci || nj !== cj) {\n          let o = own[nj * W + ni];\n          if (ni !== ci && nj !== cj) {\n            // A diagonal step: the side LED nearer the path counts too, so\n            // two lines cannot slip past each other through a corner.\n            const sx = abs(u - max(ni, ci)) \u003c abs(H - v - max(nj, cj)) ? ci : ni, sy = sx === ci ? nj : cj, os = own[sy * W + sx];\n            if (os && os !== id) o = o || os;\n            else if (!o && rr > 3.5) own[sy * W + sx] = id;\n          }\n          // The lines all leave the root together, so the first 3.5 LEDs are shared.\n          const held = rr > 3.5 && o && o !== id;\n          if (held && !ride) (ju = u), (jv = v), (rc = 0);\n          if (held && ++rc === 4 && S.nj \u003c 40) (S.jx[S.nj] = ju), (S.jy[S.nj++] = jv);\n          ride = held;\n          if (!held) own[nj * W + ni] = id;\n          (ci = ni), (cj = nj);\n        }\n        vis[n] = ride ? 0 : 1;\n        (pts[2 * n] = u), (pts[2 * n++ + 1] = v);\n      }\n      S.np[L] = n;\n    }\n}\n\n// Lines are laid as points every third of an LED, each lighting its four\n// nearest LEDs by how close it falls; an LED keeps the brightest.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, col = S.col, pal = S.pal, F = S.F;\n  // The faint wheel runs from lime round through blue and magenta to red,\n  // leaving out orange and yellow.\n  if (S.palHue !== S.hue) {\n    for (let k = 0; k \u003c 64; k++) {\n      const fh = k / 64 + S.hue;\n      hsv(0.22 + 0.8 * (fh - floor(fh)), 0.6, 0.088, col);\n      (pal[3 * k] = col[0]), (pal[3 * k + 1] = col[1]), (pal[3 * k + 2] = col[2]);\n    }\n    S.palHue = S.hue;\n  }\n  for (let r = 0, o = 0; r \u003c H; r++)\n    for (let c = 0; c \u003c W; c++, o += 3) {\n      const p = (H - 1 - r) * NX + c, f = (F[p] + F[p + 1] + F[p + NX] + F[p + NX + 1]) / (4 * TAU), q = 3 * ((64 * (f - floor(f))) | 0);\n      (rgb[o] = pal[q]), (rgb[o + 1] = pal[q + 1]), (rgb[o + 2] = pal[q + 2]);\n    }\n  // Line colours go round half the wheel by angle, cyan to magenta at 0.\n  const c = [0, 0, 0];\n  for (let L = 0; L \u003c NL; L++) {\n    const pts = S.pts[L], vis = S.vis[L], n = S.np[L];\n    hsv(0.45 + S.hue + (0.45 * L) / (NL - 1), 0.8, 1, c);\n    for (let k = 0; k + 1 \u003c n; k++) {\n      if (!vis[k + 1]) continue;\n      const xa = pts[2 * k], ya = H - pts[2 * k + 1], xb = pts[2 * k + 2], yb = H - pts[2 * k + 3];\n      const m = Math.ceil(hypot(xb - xa, yb - ya) * 3) || 1;\n      for (let e = 0; e \u003c m; e++) plot(S, xa + ((xb - xa) * e) / m, ya + ((yb - ya) * e) / m, c, 1);\n    }\n  }\n  const white = [1, 1, 1];\n  for (let k = 0; k \u003c S.nj; k++) plot(S, S.jx[k], H - S.jy[k], white, 0.85);\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","question-mark":"// ===== Patternflow pattern =====\n// Title:   Question Mark Function\n// Family:  number\n// Idea:    Minkowski's question mark function rises as a filled staircase that zooms for ever into a quadratic irrational, the Farey fractions marked where the dyadic levels meet the stair, while the point's continued fraction digits and the binary digits of its image scroll past underneath as the same runs.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Minkowski's question mark function (Hermann Minkowski, 1904), with Denjoy's continued fraction sum (Arnaud Denjoy, 1938), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Point=0..5, Depth=3..7\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the staircase is azure with a pale rim, the Farey marks and their dyadic lines rose, and the point pale gold, with the lines of its own Stern-Brocot path in a pale grey gold. Underneath, runs of noughts are rose and runs of ones azure.\n// Knob 2: Speed. At 2 the bits scroll past at 0.6 a second, so the golden point's loop, where the picture shrinks 6.9 times across and 4 times up, takes 3.3 seconds and the silver point's, 34 times across and 16 up, takes 6.7. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Point. The quadratic irrational the zoom falls into: 0 the golden point 1/phi = [0; 1, 1, 1, ...], where ? is 2/3; 1 the silver point sqrt(2) - 1 = [0; 2, 2, ...], ? = 2/5; 2 sqrt(3) - 1 = [0; 1, 2, 1, 2, ...], ? = 6/7; 3 (sqrt(3) - 1)/2 = [0; 2, 1, ...], ? = 2/7; 4 [0; 3, 3, ...], ? = 2/9; 5 [0; 1, 3, ...], ? = 14/15.\n// Knob 4: Depth. How many levels of the Farey tree are marked, counted from the window's own scale: 3 marks the 7 fractions down to the quarters and fifths on the whole graph, 7 marks 127, and each loop of the zoom fades in the next levels as they grow into view. As on a ruler, the deeper the level the fainter its lines.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, pow, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Hue of the staircase at knob 0, azure so the panel never opens on red,\n// and the turn to the marks' colour.\nconst HUE0 = 0.56, MARK = 0.4;\n// The graph's box and the two bars under it, in LED rows.\nconst GT = 1, GB = 105, BAR1 = 110, BAR2 = 120, CELL = 3;\n// The periods of the continued fractions the knob chooses from.\nconst POINTS = [[1], [2], [1, 2], [2, 1], [3], [1, 3]];\n// Bits a second at Speed 2.\nconst RATE = 0.6;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Denjoy's sum: x = [0; a1, a2, ...] goes to 2 (2^-A1 - 2^-A2 + ...), with\n// A_k the sum of the first k partial quotients.\nfunction qm(x) {\n  if (x \u003c= 0) return 0;\n  if (x >= 1) return 1;\n  let y = 0, sg = 1, pw = 2;\n  for (let k = 0; k \u003c 80 && x > 1e-13; k++) {\n    const inv = 1 / x, a = floor(inv);\n    x = inv - a;\n    pw *= pow(2, -a);\n    y += sg * pw;\n    sg = -sg;\n    if (pw \u003c 1e-16) break;\n  }\n  return y;\n}\n\n// The point's map phi(t) = [0; a1, ..., ap + t] as a Moebius matrix, its\n// two fixed points, and the multiplier at the attracting one. An odd period\n// turns the picture over, so it is taken twice.\nfunction point(k) {\n  let a = POINTS[k];\n  if (a.length % 2) a = a.concat(a);\n  let m00 = 1, m01 = 0, m10 = 0, m11 = 1;\n  for (const q of a) {\n    // Multiply by [[0, 1], [1, q]]: t -> 1 / (q + t).\n    const n00 = m01, n01 = m00 + q * m01, n10 = m11, n11 = m10 + q * m11;\n    m00 = n00; m01 = n01; m10 = n10; m11 = n11;\n  }\n  // m10 x^2 + (m11 - m00) x - m01 = 0.\n  const b = m11 - m00, disc = sqrt(b * b + 4 * m10 * m01);\n  const r1 = (-b + disc) / (2 * m10), r2 = (-b - disc) / (2 * m10);\n  const x0 = r1 > 0 && r1 \u003c 1 ? r1 : r2, x1 = x0 === r1 ? r2 : r1;\n  const kap = 1 / (m10 * x0 + m11) ** 2;\n  let A = 0;\n  // The binary digits of ?(x0), the units digit first: a1 noughts, a2\n  // ones, a3 noughts and so on.\n  const bits = [];\n  for (let i = 0; i \u003c a.length; i++) {\n    for (let j = 0; j \u003c a[i]; j++) bits.push(i % 2);\n    A += a[i];\n  }\n  return { a, A, x0, x1, kap, y0: qm(x0), bits, sig: pow(2, -A) };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, sp: 2, pk: -1, P: null, z: 0, depth: 3, ys: new Float64Array(W + 1),\n    mk: [], buf: new Float32Array(W * H * 3), pal: new Float32Array(24), palHue: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.sp = cl(kv[1], 0.2, 3);\n  const pk = round(cl(kv[2], 0, POINTS.length - 1));\n  s.depth = cl(kv[3], 3, 7);\n  if (pk !== s.pk) {\n    s.pk = pk;\n    s.P = point(pk);\n    s.z = 0;\n  }\n  // One loop of the zoom is one period of the digits, A bits.\n  s.z += (d * RATE * (s.sp / 2)) / s.P.A;\n  s.z -= floor(s.z);\n}\n\nfunction palette(s) {\n  const P = s.pal, h = HUE0 + s.hue;\n  hsv(h, 0.8, 1, P, 0); // stair fill, scaled down the column\n  hsv(h - 0.03, 0.3, 1, P, 3); // stair edge\n  hsv(h + MARK, 0.6, 1, P, 6); // mark\n  hsv(h + MARK, 0.55, 0.36, P, 9); // dyadic arm\n  hsv(h + 0.62, 0.45, 1, P, 12); // probe ring and path\n  hsv(h + MARK, 0.8, 0.95, P, 15); // a run of noughts\n  hsv(h, 0.75, 0.95, P, 18); // a run of ones\n  hsv(h + 0.62, 0.22, 0.42, P, 21); // dyadic arm on the point's path\n  s.palHue = s.hue;\n}\n\n// Screen to x and back. u = (x - x0)/(x - x1) turns phi into u -> kap u,\n// so the window kap^z u(s) for s in [0, 1] is the whole graph at z = 0 and\n// its copy one period down at z = 1, and the loop has no seam.\nfunction uOf(P, x) { return (x - P.x0) / (x - P.x1); }\nfunction xOf(P, u) { return (P.x0 - u * P.x1) / (1 - u); }\n\n// The Stern-Brocot tree inside the window: each mediant of two Farey\n// neighbours goes to the midpoint of their images, which is what ? is.\nfunction walk(s, P, xlo, xhi, a, b, c, dd, ylo, yhi, lev, maxLev, path) {\n  if (lev > maxLev) return;\n  if (c / dd \u003c xlo || a / b > xhi) return;\n  const p = a + c, q = b + dd, m = p / q, ym = (ylo + yhi) / 2;\n  const onPath = path && P.x0 > a / b && P.x0 \u003c c / dd;\n  s.mk.push(m, ym, lev, onPath ? 1 : 0);\n  walk(s, P, xlo, xhi, a, b, p, q, ylo, ym, lev + 1, maxLev, onPath);\n  walk(s, P, xlo, xhi, p, q, c, dd, ym, yhi, lev + 1, maxLev, onPath);\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.P) return;\n  if (s.palHue !== s.hue) palette(s);\n  const { buf: B, pal: C, P, z } = s;\n  B.fill(0);\n  const add = (x, y, o, k) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = (y * W + x) * 3;\n    B[i] += C[o] * k;\n    B[i + 1] += C[o + 1] * k;\n    B[i + 2] += C[o + 2] * k;\n  };\n  const kx = pow(P.kap, z), ky = pow(P.sig, z);\n  const sx = (x) => xOf(P, uOf(P, x) / kx); // x -> screen 0..1\n  const xs = (t) => xOf(P, kx * uOf(P, t)); // screen 0..1 -> x\n  const ry = (y) => P.y0 + (y - P.y0) / ky; // y -> screen 0..1, up\n  const GHt = GB - GT;\n  const row = (r) => GB - r * GHt; // screen up 0..1 -> LED row (float)\n\n  // The stair: ? at the 65 column edges. It only rises, so between two\n  // edges the graph fills exactly the span of the two values.\n  for (let c = 0; c \u003c= W; c++) s.ys[c] = row(ry(qm(xs(c / W))));\n  for (let c = 0; c \u003c W; c++) {\n    const top = s.ys[c + 1], bot = s.ys[c];\n    // Fill from the floor of the box up to the low end of the span,\n    // brightest just under the rim.\n    const yTop = max(GT, floor(top)), yBot = min(GB, floor(bot));\n    for (let y = GB; y > yBot; y--) add(c, y, 0, 0.18 + 0.5 * exp((-5 * (y - bot)) / GHt));\n    // The span itself, a riser where ? climbs and a tread where it is flat.\n    for (let y = yBot; y >= yTop; y--) if (y >= GT && y \u003c= GB) add(c, y, 3, 0.9);\n  }\n\n  // Farey marks down to Depth levels below the window's own scale. A level\n  // grows one period deeper each loop, so rel = level - A z is the same at\n  // z = 0 and z = 1.\n  const D = s.depth, maxLev = floor(D + P.A * z) + 1;\n  s.mk.length = 0;\n  const xlo = xs(0), xhi = xs(1);\n  walk(s, P, xlo, xhi, 0, 1, 1, 1, 0, 1, 1, maxLev, true);\n  const mk = s.mk;\n  for (let i = 0; i \u003c mk.length; i += 4) {\n    const rel = mk[i + 2] - P.A * z, w = cl(D + 1 - rel, 0, 1);\n    if (w \u003c= 0) continue;\n    const px = floor(sx(mk[i]) * W), py = round(row(ry(mk[i + 1])));\n    if (px \u003c 0 || px >= W) continue;\n    const path = mk[i + 3] === 1;\n    // A dyadic line from the left edge to its fraction, above the stair,\n    // and a cut down through the fill under it. Like the ticks of a ruler,\n    // the deeper the level the fainter both are.\n    const tick = w * (1 - 0.65 * cl((rel - 1) / max(1, D - 1), 0, 1));\n    if (py >= GT && py \u003c= GB) {\n      for (let x = 0; x \u003c px; x++) add(x, py, path ? 21 : 9, tick);\n      for (let y = py + 2; y \u003c= GB; y++) {\n        const i3 = (y * W + px) * 3;\n        B[i3] *= 1 - 0.7 * tick;\n        B[i3 + 1] *= 1 - 0.7 * tick;\n        B[i3 + 2] *= 1 - 0.7 * tick;\n      }\n      const o = path ? 12 : 6;\n      add(px, py, o, w);\n      if (rel \u003c D - 1.5) add(px, py - 1, o, 0.6 * w), add(px + 1, py, o, 0.6 * w), add(px - 1, py, o, 0.6 * w), add(px, py + 1, o, 0.4 * w);\n    }\n  }\n\n  // The point itself, fixed at the centre of the zoom.\n  const qx = floor(P.x0 * W), qy = round(row(P.y0));\n  for (let dy = -2; dy \u003c= 2; dy++)\n    for (let dx = -2; dx \u003c= 2; dx++) {\n      const x = qx + dx, y = qy + dy;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const i3 = (y * W + x) * 3, ring = max(abs(dx), abs(dy)) === 2 && abs(dx) + abs(dy) \u003c 4;\n      B[i3] *= 0.15;\n      B[i3 + 1] *= 0.15;\n      B[i3 + 2] *= 0.15;\n      if (ring) add(x, y, 12, 1);\n    }\n  add(qx, qy, 3, 1.5);\n\n  // Underneath: the continued fraction as blocks a_k cells wide, and the\n  // binary digits of ?(x0) as cells, noughts dim and ones bright. Each block\n  // sits over the run of bits it becomes, so a gap in the top bar falls\n  // wherever the bits below change. Both scroll A cells a loop and the\n  // digits repeat every A cells, so the loop has no seam.\n  const bits = P.bits, L = bits.length, off = round(P.A * z * CELL);\n  for (let x = 0; x \u003c W; x++) {\n    const q = x + off, k = floor(q / CELL) % L, e = q % CELL, bit = bits[k];\n    const last = e === CELL - 1, runEnd = last && bits[(k + 1) % L] !== bit, o = bit ? 18 : 15;\n    if (!runEnd) for (let y = BAR1; y \u003c BAR1 + 7; y++) add(x, y, o, y === BAR1 || y === BAR1 + 6 ? 0.95 : 0.4);\n    if (!last) for (let y = BAR2; y \u003c BAR2 + 6; y++) add(x, y, o, bit ? 1 : 0.25);\n  }\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, min(255, round(B[p] * 255)), min(255, round(B[p + 1] * 255)), min(255, round(B[p + 2] * 255)));\n}\n","tissot-indicatrix":"// ===== Patternflow pattern =====\n// Title:   Tissot's Indicatrix\n// Family:  space\n// Idea:    A lattice of equal small circles on a turning sphere, each drawn as the ellipse a map projection makes of it: on Mercator they stay circles but swell towards the top and bottom edges, the row at 80 degrees nearly six times as wide as the equator's, and as the projection blends into an equal-area one the same circles flatten into ellipses that all cover the same area and turn one colour.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Tissot's indicatrix (Nicolas Auguste Tissot, 1859) on the Mercator projection (Gerardus Mercator, 1569) and Lambert's cylindrical equal-area projection (Johann Heinrich Lambert, 1772), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tilt=25..90, Blend=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a circle is cyan at its smallest (the Mercator equator), azure where it covers three times that, violet at 14 times (latitude 75 on Mercator) and pink-magenta from 42 times (latitude 81); its outline is a paler tint of the same colour and the graticule is a dim mauve. The wheel leaves out orange and yellow, which read brown and olive in the dim fills.\n// Knob 2: Speed. How fast the sphere turns about its own axis: at 2 ten degrees a second, a whole turn in 36 s and a circle across the 180 degrees of the panel in 18 s. At 0.2 one degree a second, at 3 fifteen.\n// Knob 3: Tilt. How far the projection's axis leans from the sphere's, in degrees. It opens at 25: the sphere's pole sits just inside the top edge with the meridians fanning out from it, the circles travel on curved paths, and each one swells as its path carries it towards the top or bottom edge and shrinks back. The normal aspect, where the circles only glide sideways in nine rows, would be 0; the knob stops at 25 so the panel opens on circles that change size as they move. At 90 the transverse aspect: the pole sits at the centre and the circles wheel round it. On Mercator a circle's size depends only on its height on the map, so at every tilt the rows near the top and bottom edge are the ones at 14 LEDs in radius against 2.5 in the middle.\n// Knob 4: Blend. The projection's height, blended from Mercator at 0 to the equal-area cylindrical projection that fits the same box at 1, whose standard parallels are at 55.7 degrees. At 1 a circle on the equator is three times as tall as wide and one at 80 degrees ten times as wide as tall, and every one covers 61 square LEDs; on Mercator they run from 19 to 650. It opens at 0.06, nearly all Mercator.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, atan2, log, tan, PI } = Math;\nconst TAU = 2 * PI, DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// 180 degrees of longitude across, so 64 / pi LEDs to the radian, and\n// Mercator's y = ln tan(pi/4 + phi/2) from -pi to pi down the 128 rows:\n// y reaches pi at 85.0511 degrees, the cut Web Mercator makes for its\n// square world, and the box is exactly 1:2.\nconst SC = W / PI, PHIMAX = 2 * Math.atan(Math.exp(PI)) - PI / 2, SMAX = sin(PHIMAX);\n// The circles' geodesic radius, and h * k of the equal-area map, in LEDs\n// squared per steradian.\nconst RAD = 7 * DEG, HKEA = (SC * W) / SMAX;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel from lime round through blue and magenta to red, without the\n// orange and yellow that turn brown and olive when dim.\nconst wheel = (f) => 0.22 + 0.8 * (f - floor(f));\n\n// Circle centres: rows every 20 degrees of latitude, each with as many\n// circles as fit 20 degrees apart round it, odd rows shifted half a step.\n// No two centres are closer than 19.7 degrees, so the 7-degree circles\n// never touch. The poles are left out: they are 10 degrees from the 80 row.\nconst CL = [];\nfor (let r = -4; r \u003c= 4; r++) {\n  const lat = r * 20 * DEG, n = Math.round(18 * cos(lat));\n  for (let k = 0; k \u003c n; k++) CL.push([lat, ((k + (r & 1 ? 0.5 : 0)) / n) * TAU]);\n}\nconst NC = CL.length;\n\nexport function setup(params) {\n  params.s = { spin: 0, hue: 0, speed: 2, tilt: 25 * DEG, blend: 0.06, rgb: new Float32Array(W * H * 3), col: new Float64Array(3), o: [0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 25, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.tilt = cl(kv[2], 25, 90) * DEG;\n  S.blend = cl(kv[3], 0, 1);\n  S.spin = (S.spin + d * S.speed * 5 * DEG) % TAU;\n}\n\n// A point of the sphere, turned about the sphere's axis, then seen in the\n// projection's frame, whose axis leans from the sphere's by the tilt\n// towards the middle of the panel: o gets latitude and longitude there.\nfunction rot(S, lat, lon, o) {\n  const cp = cos(lat), x0 = cp * cos(lon + S.spin), y0 = cp * sin(lon + S.spin), z0 = sin(lat);\n  const ct = cos(S.tilt), st = sin(S.tilt);\n  o[0] = asin(cl(-x0 * st + z0 * ct, -1, 1));\n  o[1] = atan2(y0, x0 * ct + z0 * st);\n}\n// Height above the middle row, in LEDs: Mercator blended into the\n// equal-area map scaled to the same box.\nconst yOf = (b, phi) => (1 - b) * SC * log(tan(PI / 4 + phi / 2)) + (b * W * sin(phi)) / SMAX;\n\n// Lines are laid as points, each lighting its four nearest LEDs by how\n// close it falls; an LED keeps the brightest.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\n\n// A graticule line, sampled along the sphere and joined on the panel. A\n// join is skipped where the line leaves the visible half or the cut.\nfunction gratLine(S, c, lat0, lon0, lat1, lon1, steps) {\n  const o = S.o, b = S.blend;\n  let px = 0, py = 0, ok = false;\n  for (let k = 0; k \u003c= steps; k++) {\n    const u = k / steps;\n    rot(S, lat0 + (lat1 - lat0) * u, lon0 + (lon1 - lon0) * u, o);\n    const inside = abs(o[0]) \u003c PHIMAX + 0.02 && abs(o[1]) \u003c PI / 2 + 0.05;\n    const x = W / 2 + SC * o[1], y = H / 2 - yOf(b, cl(o[0], -1.55, 1.55));\n    if (inside && ok && abs(x - px) + abs(y - py) \u003c 20) {\n      const m = Math.ceil(Math.hypot(x - px, y - py) * 2.5) || 1;\n      for (let e = 1; e \u003c= m; e++) plot(S, px + ((x - px) * e) / m, py + ((y - py) * e) / m, c, 1);\n    }\n    (px = x), (py = y), (ok = inside);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, col = S.col, b = S.blend, o = S.o;\n  rgb.fill(0);\n  // The sphere's graticule every 30 degrees, and its poles.\n  const gc = [0, 0, 0];\n  hsv(wheel(0.85 + S.hue), 0.3, 0.32, gc);\n  for (let k = 0; k \u003c 12; k++) gratLine(S, gc, -PI / 2, k * 30 * DEG, PI / 2, k * 30 * DEG, 360);\n  for (let k = -2; k \u003c= 2; k++) gratLine(S, gc, k * 30 * DEG, 0, k * 30 * DEG, TAU, 720);\n  for (const lat of [PI / 2, -PI / 2]) {\n    rot(S, lat, 0, o);\n    if (abs(o[0]) \u003c PHIMAX && abs(o[1]) \u003c PI / 2) plot(S, W / 2 + SC * o[1], H / 2 - yOf(b, o[0]), [0.85, 0.85, 0.85], 1);\n  }\n  // Each circle as its indicatrix: a cylindrical map keeps meridians and\n  // parallels square, so the ellipse lies along the panel's axes with\n  // semi-axes r k across and r h up, k = SC / cos phi along the parallel\n  // and h = dy/dphi along the meridian. On Mercator h = k.\n  for (let i = 0; i \u003c NC; i++) {\n    rot(S, CL[i][0], CL[i][1], o);\n    const ph = o[0], la = o[1];\n    if (abs(ph) > PHIMAX || abs(la) > PI / 2 + 0.3) continue;\n    const cp = cos(ph), k = SC / cp, h = ((1 - b) * SC) / cp + (b * W * cp) / SMAX;\n    const A = RAD * k, B = RAD * h, cx = W / 2 + SC * la, cy = H / 2 - yOf(b, ph);\n    // The colour is h k against the equal-area map's, on a log scale from\n    // the Mercator equator's 0.32 up to 13.5.\n    const tn = cl((log((h * k) / HKEA) + 1.15) / 3.75, 0, 1);\n    hsv(wheel(0.35 + 0.44 * tn + S.hue), 0.7, 1, col);\n    // A circle fades over the last 4 degrees before the cut, where it is\n    // about 20 LEDs across on Mercator, so it does not drop out whole.\n    const fade = cl((PHIMAX - abs(ph)) / (4 * DEG), 0, 1);\n    const lr = 0.55 + 0.45 * col[0], lg = 0.55 + 0.45 * col[1], lb = 0.55 + 0.45 * col[2];\n    const x0 = max(0, floor(cx - A - 1)), x1 = min(W - 1, floor(cx + A + 1)), y0 = max(0, floor(cy - B - 1)), y1 = min(H - 1, floor(cy + B + 1));\n    for (let yy = y0; yy \u003c= y1; yy++)\n      for (let xx = x0; xx \u003c= x1; xx++) {\n        // Distance to the outline in LEDs, to first order: (rho - 1) / |grad rho|.\n        const qx = (xx + 0.5 - cx) / A, qy = (yy + 0.5 - cy) / B, r2 = qx * qx + qy * qy, r = sqrt(r2) || 1e-9;\n        const dist = (r - 1) / (sqrt((qx / A) ** 2 + (qy / B) ** 2) / r || 1);\n        const line = cl(1 - abs(dist) / 0.8, 0, 1), fill = dist \u003c 0 ? cl(-dist, 0, 1) * (0.16 + 0.14 * (1 - r2)) : 0;\n        const v = max(line, fill) * fade;\n        if (v \u003c= 0) continue;\n        const p = (yy * W + xx) * 3, pale = line > fill;\n        const cr = (pale ? lr : col[0]) * v, cg = (pale ? lg : col[1]) * v, cb = (pale ? lb : col[2]) * v;\n        if (rgb[p] \u003c cr) rgb[p] = cr;\n        if (rgb[p + 1] \u003c cg) rgb[p + 1] = cg;\n        if (rgb[p + 2] \u003c cb) rgb[p + 2] = cb;\n      }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","toussaint-wilczek":"// ===== Patternflow pattern =====\n// Title:   Toussaint-Wilczek\n// Family:  particle\n// Idea:    Two species of random walkers sprinkled evenly over the panel annihilate wherever they meet, and the chance surplus of one or the other in each patch survives as green and magenta domains that grow like the square root of time behind dark fizzing seams.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: diffusion-limited annihilation A + B -> 0 (A. A. Ovchinnikov and Ya. B. Zeldovich, 1978; Doug Toussaint and Frank Wilczek, 1983), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Density=80..320, Excess=0..1\n//\n// Knob 1: Hue. Turns both species round the wheel together, B always 0.47 of a turn from A. At 0 A is spring green and B magenta; at 0.25 blue and orange; at 0.6 red and aquamarine. The dim glow of each domain behind its walkers skips the orange and yellow part of the wheel, which reads brown and olive when dark.\n// Knob 2: Speed. Hops a second for every walker, 4 for each unit: 8 at 2, 0.8 at 0.2, 12 at 3. The panel is sprinkled again after 100 hops, every 12.5 seconds at 2, so the 2 to 8 second window sees hops 16 to 64, where a row crosses a domain in 16 LEDs on average at the start and 29 at the end, the square root of four times the hops.\n// Knob 3: Density. How many A and how many B each LED gets at the sprinkle, as Poisson means, from 80 to 320. Most cancel on the spot and about 10 a LED are left at 80 (20 at 320). The domains grow at the same pace at any Density, and only their fill changes: after 40 hops 0.71 walkers a LED are left at 80 and 1.40 at 320, the square root of four times as many, and 45% or 64% of the LEDs hold one.\n// Knob 4: Excess. A surplus of A over B at the sprinkle, 1.6 x knob^2 a LED: 0.006 at the opening 0.06, 47 walkers on the whole panel, 0.4 at 0.5 and 1.6 at 1. The surplus never cancels, so the magenta minority dies out while the green fills in: at 1 the 2,011 B left after 8 hops are 4 after 96, and at 0.5 the 4,881 are 556.\n// Buttons: K1 tap sprinkles the panel afresh.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Hops per walker per second at Speed 1. At 8 hops a second the 2 to 8\n// second window spans hops 16 to 64, where the LEDs holding a walker fall\n// from 59% to 39%: dense enough to read every domain, sparse enough that\n// the seams between them are already dark.\nconst RATE = 4;\n// Hops per walker before the panel is sprinkled again. By 100 a row\n// crosses a domain in 37 LEDs on average, on a panel 64 wide, and the\n// walls start to set the domains' size instead of the walk.\nconst LIFE = 100;\n// Hue of species A at knob 0; B sits opposite.\nconst HUE_A = 0.38;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the glow's hue wheel skips\n// 0.03..0.18 and runs the rest a little faster.\nconst glowHue = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  let seed = (Math.random() * 4294967296) >>> 0 || 1;\n  params.s = {\n    // Signed count per LED: A is positive, B negative. An A and a B on one\n    // LED cancel at once, so a sign says which species is there.\n    m: new Int32Array(N), pos: new Int32Array(N), neg: new Int32Array(N),\n    spark: new Float32Array(N), glow: new Float32Array(N), tmp: new Float32Array(N),\n    hops: 0, hue: 0, speed: 2, n0: 80, ex: 0.06, born: false, extinct: 0,\n    rnd: () => {\n      seed ^= seed \u003c\u003c 13;\n      seed ^= seed >>> 17;\n      seed ^= seed \u003c\u003c 5;\n      return seed >>> 0;\n    },\n    pal: new Float32Array(24), palHue: -1, rgb: new Float32Array(N * 3),\n  };\n}\n\n// A Poisson count, by its normal: the means here are 80 and up.\nfunction poisson(S, l) {\n  const u = (S.rnd() + 1) / 4294967297, v = S.rnd() / 4294967296;\n  return max(0, floor(l + sqrt(l) * sqrt(-2 * log(u)) * cos(2 * PI * v) + 0.5));\n}\n\n// Every LED gets a Poisson number of A and of B; what is left after they\n// cancel on the spot is the starting field. Its sign is white noise, and\n// the walk smooths it: a patch L LEDs wide keeps a surplus of about L times\n// the square root of the Density, so the density left falls as one over\n// the square root of the hops (Toussaint and Wilczek's t^(-d/4) in two\n// dimensions), not as one over the hops the well-stirred rate law gives.\n// Over 5 to 80 hops it fell with exponent -0.49 at Density 80.\nfunction sprinkle(S) {\n  const d = 1.6 * S.ex * S.ex;\n  let sum = 0;\n  for (let i = 0; i \u003c N; i++) sum += S.m[i] = poisson(S, S.n0) - poisson(S, S.n0);\n  // The two species start exactly level, or level but for the Excess: a\n  // chance surplus over the whole panel would hand it to one colour within\n  // seconds. Each correction adds or cancels one particle on a random LED.\n  for (let k = Math.round(d * N) - sum, s = k > 0 ? 1 : -1; k !== 0; k -= s) S.m[S.rnd() % N] += s;\n  S.hops = 0;\n  S.extinct = 0;\n  S.spark.fill(0);\n}\n\n// One sub-step: each walker hops to a random neighbour with chance p, the\n// walls reflect, and opposite signs arriving on one LED annihilate in pairs.\n// The signed sum is the whole reaction; the spark marks where it happened.\nfunction step(S, p) {\n  const { m, pos, neg, spark } = S;\n  pos.fill(0);\n  neg.fill(0);\n  const P = floor(p * 1073741824);\n  let nA = 0, nB = 0;\n  for (let y = 0, i = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, i++) {\n      let k = m[i];\n      if (!k) continue;\n      const to = k > 0 ? pos : neg;\n      k = abs(k);\n      if (m[i] > 0) nA += k;\n      else nB += k;\n      for (let j = 0; j \u003c k; j++) {\n        const r = S.rnd();\n        if (r >>> 2 >= P) {\n          to[i]++;\n          continue;\n        }\n        const d = r & 3;\n        let xx = x, yy = y;\n        if (d === 0) xx = x + 1 \u003c W ? x + 1 : x - 1;\n        else if (d === 1) xx = x > 0 ? x - 1 : x + 1;\n        else if (d === 2) yy = y + 1 \u003c H ? y + 1 : y - 1;\n        else yy = y > 0 ? y - 1 : y + 1;\n        to[yy * W + xx]++;\n      }\n    }\n  for (let i = 0; i \u003c N; i++) {\n    const a = pos[i], b = neg[i];\n    m[i] = a - b;\n    if (a && b) spark[i] = 1;\n  }\n  S.nA = nA;\n  S.nB = nB;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 80, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.n0 = cl(kv[2], 80, 320);\n  S.ex = cl(kv[3], 0, 1);\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (!S.born || tap || S.hops > LIFE || S.extinct > 40) {\n    sprinkle(S);\n    S.born = true;\n  }\n  // Hops this frame, split into sub-steps of at most one hop each, so a walker\n  // moves on some frames and not others instead of jumping two LEDs.\n  const want = d * S.speed * RATE, n = Math.ceil(want - 1e-9);\n  for (let k = 0; k \u003c n; k++) step(S, want / n);\n  S.hops += want;\n  if (!S.nA || !S.nB) S.extinct += want;\n  for (let i = 0; i \u003c N; i++) S.spark[i] *= exp(-d * 3.5);\n  // The glow: the signed field blurred by two box passes of radius 2, scaled\n  // by its own spread so it holds its brightness while the walkers thin out.\n  const { m, glow, tmp } = S;\n  for (let i = 0; i \u003c N; i++) glow[i] = m[i];\n  for (let pass = 0; pass \u003c 2; pass++) {\n    for (let y = 0; y \u003c H; y++) {\n      let acc = 0;\n      const o = y * W;\n      for (let x = -2; x \u003c= 2; x++) acc += glow[o + cl(x, 0, W - 1)];\n      for (let x = 0; x \u003c W; x++) {\n        tmp[o + x] = acc / 5;\n        acc += glow[o + min(W - 1, x + 3)] - glow[o + max(0, x - 2)];\n      }\n    }\n    for (let x = 0; x \u003c W; x++) {\n      let acc = 0;\n      for (let y = -2; y \u003c= 2; y++) acc += tmp[cl(y, 0, H - 1) * W + x];\n      for (let y = 0; y \u003c H; y++) {\n        glow[y * W + x] = acc / 5;\n        acc += tmp[min(H - 1, y + 3) * W + x] - tmp[max(0, y - 2) * W + x];\n      }\n    }\n  }\n  let ss = 0;\n  for (let i = 0; i \u003c N; i++) ss += glow[i] * glow[i];\n  S.rms = sqrt(ss / N) || 1;\n}\n\nfunction palette(S) {\n  const P = S.pal, h = HUE_A + S.hue;\n  hsv(h, 0.8, 1, P, 0); // A particle\n  hsv(h + 0.47, 0.75, 1, P, 3); // B particle\n  hsv(glowHue(h), 0.85, 1, P, 6); // A glow\n  hsv(glowHue(h + 0.47), 0.85, 1, P, 9); // B glow\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { m, glow, spark, pal: P, rgb } = S;\n  const inv = 1 / (1.6 * S.rms);\n  for (let i = 0, o = 0; i \u003c N; i++, o += 3) {\n    const k = m[i];\n    if (k) {\n      const c = k > 0 ? 0 : 3, a = abs(k), L = a === 1 ? 0.93 : a === 2 ? 0.97 : 1;\n      rgb[o] = P[c] * L;\n      rgb[o + 1] = P[c + 1] * L;\n      rgb[o + 2] = P[c + 2] * L;\n      continue;\n    }\n    // Gaps stay dark against the walkers, which keeps the speckle sharp; a\n    // gap next to walkers lifts a little, so steps between gaps are soft.\n    const x = i % W, nb = (x + 1 \u003c W && m[i + 1] ? 1 : 0) + (x > 0 && m[i - 1] ? 1 : 0) + (i + W \u003c N && m[i + W] ? 1 : 0) + (i >= W && m[i - W] ? 1 : 0);\n    const g = glow[i] * inv, c = g > 0 ? 6 : 9, a = min(1, abs(g)) * 0.2 + 0.01 + 0.01 * nb, sp = spark[i] * 0.45;\n    rgb[o] = P[c] * a + sp;\n    rgb[o + 1] = P[c + 1] * a + sp;\n    rgb[o + 2] = P[c + 2] * a + sp;\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * min(1, rgb[o])) | 0, (255 * min(1, rgb[o + 1])) | 0, (255 * min(1, rgb[o + 2])) | 0);\n}\n","universal-cover":"// ===== Patternflow pattern =====\n// Title:   Universal Cover\n// Family:  topology\n// Idea:    A dot loops round a figure-eight at the foot of the panel, one loop a step, while its lift walks the four-way tree above that covers it, the fractal cross of the free group on a and b; the view re-roots on the lift every step so the tree slides and regrows round it, and the reduced word, drawn back to the root and spelled in a strip of blocks, grows by half a letter a step unless Return pulls the lift home.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: universal cover of the figure-eight, the Cayley graph of the free group F2 (Henri Poincaré, 1895; Max Dehn, 1910), with the escape of random walk on the free group (Harry Kesten, 1959), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Return=0.25..0.85, Depth=-1..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the letter a, the left loop and every horizontal edge, is aqua and b, the right loop and every vertical edge, is magenta; the word's path runs in pale tints of the two, the dot and its lift are white and the root wears a gold ring. At 0.25 a is blue and b red, at 0.5 a pink and b aqua, at 0.75 a green and b blue. The wheel skips orange, yellow and lime, which read brown and olive on the dim outer branches.\n// Knob 2: Speed. At 2 a step, one loop of the figure-eight below and one edge of the tree above, takes 0.75 s. The lift leaves first and the view follows a quarter of a step behind, so the lift runs up to a quarter of its edge ahead of the centre, 4 LEDs on an a edge and 5.6 on a b edge, before the tree slides under it. Every vertex of the tree lies over the wedge point, and all of them blink as the dot passes it. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Return. The chance a step cancels the word's last letter and sends the lift back towards the root; the other three letters share the rest, and from the root all four lead away. At 0.25 that is the simple random walk, every letter equally likely: the word grows by half a letter a step, Kesten's escape speed, and was 50.2 letters long after 100 steps (mean of 300 runs). At 0.5 the length is a fair coin's walk, 8.3 letters after 100 steps; at 0.6 it averages 2.5, and at 0.85 the lift sits on the root 41% of the time and the word averages 0.71 letters.\n// Knob 4: Depth. How many levels of the tree are drawn round the lift, 4 + 2.5 x Depth, from 1.5 to 6.5, the last one fading in. The lift's own edges lengthen as levels drop so the drawing stays 60 LEDs wide: an a edge is 23 LEDs at -1, 15.9 at the opening 0.06 and 15.2 at 1, and a b edge 1.4 times that. Each level halves the edge and dims it by a fifth.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, exp, cos, sin, PI, LN2 } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (t) => t * t * (3 - 2 * t);\n// Letters: 0 a, 1 a^-1, 2 b, 3 b^-1; the inverse of l is l ^ 1. a runs right\n// in the tree, b runs up.\nconst DX = [1, -1, 0, 0], DY = [0, 0, -1, 1];\n// The tree's centre, how much longer a b edge is drawn than an a edge, the\n// strip that spells the word, and the figure-eight's wedge point and radius.\nconst TX = 32, TY = 43, KB = 1.4, WY = 88, BX = 32, BY = 110, BR = 14.5;\n// Seconds a step takes at Speed 2.\nconst STEP = 0.75;\nconst WHITE = [1, 1, 1];\nconst HUE_A = 0.276, HUE_B = 0.73;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// The wheel skips orange, yellow and lime, which read brown and olive on\n// the dim outer branches.\nconst wheel = (h) => 0.28 + 0.74 * (h - floor(h));\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, ret: 0.25, depth: 0, L0: 15, levels: 4,\n    word: [], x: 0, back: false, t: 0, steps: 0, at: 1,\n    rgb: new Float32Array(N * 3), col: new Float32Array(12), c: 0, w: 0,\n  };\n  next(params.s);\n}\n\n// The next step: back along the word's last letter with chance Return, or\n// on along one of the other three. From the root all four lead away.\nfunction next(S) {\n  const word = S.word, last = word.length ? word[word.length - 1] : -1;\n  if (last >= 0 && Math.random() \u003c S.ret) S.x = last ^ 1;\n  else {\n    const k = floor(Math.random() * (last >= 0 ? 3 : 4));\n    let l = 0;\n    for (let seen = -1; ; l++) if (l !== (last ^ 1) || last \u003c 0) if (++seen === k) break;\n    S.x = l;\n  }\n  S.back = last >= 0 && S.x === (last ^ 1);\n  S.t = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.25, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.ret = cl(kv[2], 0.25, 0.85);\n  S.depth = cl(kv[3], -1, 1);\n  // Levels of the tree drawn round the lift, the last one fading in.\n  S.levels = 4 + 2.5 * S.depth;\n  // The lift's own edges are as long as keeps the drawn tree 60 LEDs wide:\n  // the levels add up to 2 - 2^(1 - levels) edges each way.\n  S.L0 = 30 / (2 - Math.pow(2, 1 - S.levels));\n  S.t += (d * S.speed) / 2 / STEP;\n  if (S.t >= 1) {\n    if (S.back) S.word.pop();\n    else S.word.push(S.x);\n    S.steps++;\n    next(S);\n  }\n  // The dot and its lift ease out of the wedge point and into the next\n  // node; the view follows a little behind.\n  S.w = ss(cl(S.t, 0, 1));\n  S.c = ss(cl((S.t - 0.25) / 0.75, 0, 1));\n  // Near either end of a step the dot is at the wedge point and the lift\n  // at a vertex.\n  S.at = exp(-min(S.t, 1 - S.t) / 0.07);\n}\n\n// The tree stops above the strip, so a zoomed-in tree never runs over\n// the figure-eight.\nlet YMAX = H;\nfunction plot(rgb, x, y, c, o, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= YMAX) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.8) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[o] * w) rgb[p] = c[o] * w;\n      if (rgb[p + 1] \u003c c[o + 1] * w) rgb[p + 1] = c[o + 1] * w;\n      if (rgb[p + 2] \u003c c[o + 2] * w) rgb[p + 2] = c[o + 2] * w;\n    }\n  }\n}\nfunction seg(rgb, xa, ya, xb, yb, c, o, a) {\n  if (max(xa, xb) \u003c -1 || min(xa, xb) > W + 1 || max(ya, yb) \u003c -1 || min(ya, yb) > H + 1) return;\n  const n = Math.ceil(Math.hypot(xb - xa, yb - ya) * 3) || 1;\n  for (let e = 0; e \u003c= n; e++) plot(rgb, xa + ((xb - xa) * e) / n, ya + ((yb - ya) * e) / n, c, o, a);\n}\n\n// The tree drawn from u, the node the lift leaves. An edge is drawn\n// L0 / 2^e long, e being its nearer end's distance from the root of the\n// view: from u at the start of a step and from v at the end, so e slides\n// from d to d - 1 on v's side and to d + 1 elsewhere while the view\n// follows. The edge from u to v keeps e = 0.\nfunction grow(S, rgb, x, y, d, inV, last) {\n  const c = S.c, L0 = S.L0, col = S.col;\n  for (let l = 0; l \u003c 4; l++) {\n    if (last >= 0 && l === (last ^ 1)) continue;\n    const e = d === 0 ? (l === S.x ? 0 : c) : inV ? d - c : d + c;\n    const len = L0 * exp(-e * LN2) * (l >= 2 ? KB : 1);\n    if (e >= S.levels || len \u003c 0.5) continue;\n    const nx = x + DX[l] * len, ny = y + DY[l] * len;\n    const a = Math.pow(0.8, e) * cl(len / 2, 0.3, 1) * cl(S.levels - e, 0, 1);\n    // Edges near the lift are drawn up to two LEDs wide.\n    const half = e \u003c 1 ? 0.45 * (1 - e) : 0;\n    if (half > 0.05) {\n      const ox = l >= 2 ? half : 0, oy = l >= 2 ? 0 : half;\n      seg(rgb, x - ox, y - oy, nx - ox, ny - oy, col, l >= 2 ? 3 : 0, a);\n      seg(rgb, x + ox, y + oy, nx + ox, ny + oy, col, l >= 2 ? 3 : 0, a);\n    } else seg(rgb, x, y, nx, ny, col, l >= 2 ? 3 : 0, a);\n    // Every vertex lies over the wedge point, and they all blink as the\n    // dot passes it.\n    if (S.at > 0.03 && len > 1.2) plot(rgb, nx, ny, WHITE, 0, S.at * a * 1.2);\n    grow(S, rgb, nx, ny, d + 1, d === 0 ? l === S.x : inV, l);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, col = S.col, L0 = S.L0, x = S.x;\n  rgb.fill(0);\n  const hA = wheel(HUE_A + S.hue), hB = wheel(HUE_B + S.hue);\n  hsv(hA, 0.8, 1, col, 0); // a edges\n  hsv(hB, 0.75, 1, col, 3); // b edges\n  hsv(hA, 0.35, 1, col, 6); // a on the word's path\n  hsv(hB, 0.3, 1, col, 9); // b on the word's path\n  // u sits back from the centre by the share of its edge to v that the\n  // view has covered.\n  const luv = L0 * (x >= 2 ? KB : 1);\n  const ux = TX - DX[x] * luv * S.c, uy = TY - DY[x] * luv * S.c;\n  YMAX = WY - 2;\n  grow(S, rgb, ux, uy, 0, false, -1);\n\n  // The reduced word, drawn back from u to the root. On a step that\n  // cancels the last letter the edge to v is that letter, and it goes out\n  // behind the lift as the lift runs down it.\n  const word = S.word, m = word.length;\n  let px = ux, py = uy, rootSeen = 0;\n  for (let j = m - 1, dd = 0; j >= 0; j--, dd++) {\n    const l = word[j] ^ 1, inV = dd === 0 ? l === x : (word[m - 1] ^ 1) === x;\n    const e = dd === 0 ? (l === x ? 0 : S.c) : inV ? dd - S.c : dd + S.c;\n    const len = L0 * exp(-e * LN2) * (l >= 2 ? KB : 1);\n    let sx = px, sy = py;\n    if (dd === 0 && S.back) (sx = px + DX[l] * len * S.w), (sy = py + DY[l] * len * S.w);\n    const nx = px + DX[l] * len, ny = py + DY[l] * len;\n    for (const r of [-0.5, 0.5]) {\n      const ox = l >= 2 ? r : 0, oy = l >= 2 ? 0 : r;\n      seg(rgb, sx + ox, sy + oy, nx + ox, ny + oy, col, l >= 2 ? 9 : 6, 1);\n    }\n    (px = nx), (py = ny);\n    if (len \u003c 0.3) break;\n    if (j === 0) rootSeen = cl(len / 2, 0, 1);\n  }\n  if (m === 0) rootSeen = 1;\n  // The step itself: on a step away from the root the word gains x, drawn\n  // out behind the lift.\n  const lx = ux + DX[x] * luv * S.w, ly = uy + DY[x] * luv * S.w;\n  if (!S.back)\n    for (const r of [-0.5, 0.5]) {\n      const ox = x >= 2 ? r : 0, oy = x >= 2 ? 0 : r;\n      seg(rgb, ux + ox, uy + oy, lx + ox, ly + oy, col, x >= 2 ? 9 : 6, 1);\n    }\n  const gold = [1, 0.93, 0.7];\n  // The root, the identity, while it is near enough to see.\n  if (rootSeen > 0) {\n    const rx = m === 0 ? ux : px, ry = m === 0 ? uy : py;\n    for (let k = 0; k \u003c 24; k++) plot(rgb, rx + 2.6 * cos((TAU * k) / 24), ry + 2.6 * sin((TAU * k) / 24), gold, 0, rootSeen);\n  }\n  // The lift.\n  for (let yy = -3; yy \u003c= 3; yy++)\n    for (let xx = -3; xx \u003c= 3; xx++) if (Math.hypot(xx, yy) \u003c= 2.6) plot(rgb, lx + xx * 0.6, ly + yy * 0.6, WHITE, 0, 1);\n  YMAX = H;\n\n  // The word as a strip, oldest letter at the left: a in its colour, b in\n  // its own, the inverses at half strength. Past 16 letters the start slides off.\n  const shown = S.back ? m - S.w : m + (S.t > 0 ? S.w : 0);\n  const total = Math.ceil(shown), first = max(0, total - 16);\n  for (let j = first; j \u003c total; j++) {\n    const l = j \u003c m ? word[j] : x, a = j \u003c shown - 1 ? 1 : shown - j;\n    const bright = (l & 1 ? 0.45 : 1) * a, o = l >= 2 ? 9 : 6;\n    const x0 = 1 + (j - first) * 4;\n    for (let yy = WY; yy \u003c WY + 3; yy++)\n      for (let xx = x0; xx \u003c x0 + 3; xx++) {\n        const p = (yy * W + xx) * 3;\n        for (let k = 0; k \u003c 3; k++) rgb[p + k] = max(rgb[p + k], col[o + k] * bright);\n      }\n  }\n\n  // The figure-eight: loop a on the left, loop b on the right, both run\n  // anticlockwise from the wedge point, and the dot goes round the loop of\n  // this step's letter, backwards for an inverse.\n  for (let k = 0; k \u003c 200; k++) {\n    const th = (TAU * k) / 200;\n    plot(rgb, BX - BR + BR * cos(th), BY - BR * sin(th), col, 0, 0.7);\n    plot(rgb, BX + BR - BR * cos(th), BY + BR * sin(th), col, 3, 0.7);\n  }\n  // Arrowheads at the tops of the loops show which way the letter runs.\n  for (const side of [-1, 1]) {\n    const cx = BX + side * BR, ty = BY - BR, o = side \u003c 0 ? 0 : 3;\n    for (let k = 1; k \u003c= 3; k++) {\n      plot(rgb, cx - 1.2 + k, ty - k * 0.9, col, o, 0.9);\n      plot(rgb, cx - 1.2 + k, ty + k * 0.9, col, o, 0.9);\n    }\n  }\n  const loopA = x \u003c 2, sgn = x & 1 ? -1 : 1, o = loopA ? 6 : 9;\n  const at = (u) => {\n    const th = sgn * TAU * u;\n    return loopA ? [BX - BR + BR * cos(th), BY - BR * sin(th)] : [BX + BR - BR * cos(th), BY + BR * sin(th)];\n  };\n  const steps = floor(S.w * 120);\n  for (let k = 0; k \u003c= steps; k++) {\n    const u = (k / 120), [qx, qy] = at(u);\n    plot(rgb, qx, qy, col, o, 0.35 + 0.65 * (u / max(S.w, 1e-3)));\n  }\n  if (S.at > 0.03) for (let k = 0; k \u003c 28; k++) plot(rgb, BX + 3.4 * cos((TAU * k) / 28), BY + 3.4 * sin((TAU * k) / 28), WHITE, 0, S.at);\n  const [dx, dy] = at(S.w);\n  for (let yy = -3; yy \u003c= 3; yy++)\n    for (let xx = -3; xx \u003c= 3; xx++) if (Math.hypot(xx, yy) \u003c= 2.6) plot(rgb, dx + xx * 0.6, dy + yy * 0.6, WHITE, 0, 1);\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let xx = 0; xx \u003c W; xx++, p += 3) display.setPixel(xx, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","vortex-sheet":"// ===== Patternflow pattern =====\n// Title:   Vortex Sheet\n// Family:  sim\n// Idea:    A vortex sheet runs up the panel between a stream flowing down on its left and one flowing up on its right, and a small ripple on it grows and rolls up into a double-branched spiral that winds the two fluids into each other in thinner and thinner layers.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kelvin-Helmholtz instability of a vortex sheet (Hermann von Helmholtz, 1868; Lord Kelvin, 1871), computed past Moore's curvature singularity (Derek Moore, 1979) with Robert Krasny's vortex-blob method (1986), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Blob=0.15..0.5, Waves=1..4\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the left stream is dark teal with azure tracers, the right one dark violet with magenta tracers, and the sheet pale lavender; at 0.25 indigo and maroon with a pink sheet; at 0.5 maroon and green with a pale yellow one. The dark streams skip the orange and yellow part of the wheel, which reads brown and olive when dim.\n// Knob 2: Speed. At 2 each stream runs 22 LEDs a second at one wave on the panel, the ripple grows by e every 1.1 seconds at the opening Blob, and a fresh sheet starts every 8.6 seconds. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Blob. Krasny's delta, how far each point vortex of the sheet is smoothed, from 0.15 to 0.5. A smaller blob grows the ripple faster and winds the spiral tighter: the ripple grows at 2.64 a unit of time at 0.15, 2.34 at 0.25 and 1.72 at 0.5, against pi for the bare sheet, and 8 seconds into a sheet the row through the core crosses it 25 times at 0.15, 19 at 0.25, 13 at 0.35 and 9 at 0.5. Below 0.15 the 340 points could no longer hold the core and the sheet frayed.\n// Knob 4: Waves. How many wavelengths of the sheet stand on the panel, 1 to 4: one period is 128, 64, 43 or 32 LEDs tall, and each rolls up into its own spiral, so 1 opens on one spiral 62 LEDs wide by 8 seconds and 4 makes a chain of four small ones. The sheet is computed over one period and repeated, so four cost what one does.\n// Buttons: K1 tap starts a fresh sheet with a new ripple.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Sheet time units per second at Speed 1. In one unit the far streams\n// slide one wavelength past each other, half a wavelength each way.\nconst RATE = 0.175;\n// Points on a fresh sheet, the most it may grow to, and the widest gap\n// (in wavelengths) before a point is put in between. 340 points keep a\n// frame near 2 ms; at the opening Blob a sheet has them all after about 3.5\n// seconds, and the core goes on winding with the points it has.\nconst N0 = 96, NMAX = 340, GAP = 0.015;\n// A sheet is started again at this age, when the core has wound into a\n// disc the LEDs no longer part.\nconst AGE = 3.0;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Dim orange and yellow read brown and olive, so the streams' hue wheel\n// skips 0.03..0.18 and runs the rest a little faster.\nconst dimHue = (h) => 0.18 + 0.85 * (h - 0.18 - floor(h - 0.18));\n\nexport function setup(params) {\n  const M = NMAX + 8;\n  params.s = {\n    n: 0, x: new Float64Array(M), y: new Float64Array(M), g: new Float64Array(M), w: new Float64Array(M),\n    // RK4 stages, and the trig of each point packed for the kernel.\n    k: Array.from({ length: 8 }, () => new Float64Array(M)), x0: new Float64Array(M), y0: new Float64Array(M),\n    pk: new Float64Array(M * 5),\n    tx: new Float64Array(600), ty: new Float64Array(600), nt: 0, tWaves: 0,\n    tu: new Float64Array(600), tv: new Float64Array(600),\n    t: 0, born: false, hue: 0, speed: 2, delta: 0.15, waves: 1,\n    side: new Uint8Array(NP), flip: new Int16Array((W + 2) * H), rgb: new Float32Array(NP * 3), old: new Float32Array(NP * 3), fade: 0,\n    pal: new Float32Array(24), palHue: -1,\n  };\n}\n\n// A fresh sheet: Krasny's ripple x = G + a sin 2 pi G, y = -a sin 2 pi G,\n// with a random phase and size, so each roll-up stands at its own height\n// and comes a little sooner or later. A second harmonic was tried for\n// variety; below Blob 0.25 it rolled up into a second small spiral that\n// tangled with the first.\nfunction start(S) {\n  const R = Math.random, a = 0.035 + 0.02 * R(), ph = R();\n  S.n = N0;\n  for (let i = 0; i \u003c N0; i++) {\n    const G = i / N0, e = a * sin(TAU * (G + ph));\n    S.g[i] = G;\n    S.x[i] = G + e;\n    S.y[i] = -e;\n  }\n  S.t = 0;\n  S.nt = 0;\n}\n\n// Circulation carried by each point: half the gap in G to each neighbour.\nfunction weights(S) {\n  const { n, g, w } = S;\n  for (let i = 0; i \u003c n; i++) {\n    const a = i ? g[i - 1] : g[n - 1] - 1, b = i + 1 \u003c n ? g[i + 1] : g[0] + 1;\n    w[i] = (b - a) / 2;\n  }\n}\n\n// The blob kernel for one period of the sheet, with total circulation 1:\n//   u_i = -1/2 sum w_j sinh 2pi(y_i - y_j) / D,  v_i = 1/2 sum w_j sin 2pi(x_i - x_j) / D,\n//   D = cosh 2pi(y_i - y_j) - cos 2pi(x_i - x_j) + delta^2.\n// The differences come from products of each point's own trig, packed five\n// numbers a point with its weight, and each pair is visited once since the\n// kernel is odd.\nfunction pack(S, X, Y) {\n  const { n, w, pk } = S;\n  for (let i = 0, o = 0; i \u003c n; i++, o += 5) {\n    const a = TAU * X[i], e = exp(TAU * Y[i]), ie = 1 / e;\n    pk[o] = cos(a);\n    pk[o + 1] = sin(a);\n    pk[o + 2] = (e + ie) / 2;\n    pk[o + 3] = (e - ie) / 2;\n    pk[o + 4] = w[i];\n  }\n}\nfunction velocity(S, X, Y, U, V) {\n  const { n, pk } = S, d2 = S.delta * S.delta;\n  pack(S, X, Y);\n  U.fill(0, 0, n);\n  V.fill(0, 0, n);\n  for (let i = 0, oi = 0; i \u003c n; i++, oi += 5) {\n    const ci = pk[oi], si = pk[oi + 1], hi = pk[oi + 2], gi = pk[oi + 3], wi = pk[oi + 4];\n    let ui = 0, vi = 0;\n    for (let j = i + 1, o = oi + 5; j \u003c n; j++, o += 5) {\n      const cj = pk[o], sj = pk[o + 1], hj = pk[o + 2], gj = pk[o + 3], wj = pk[o + 4];\n      const q = 0.5 / (hi * hj - gi * gj - ci * cj - si * sj + d2), fu = (gi * hj - hi * gj) * q, fv = (si * cj - ci * sj) * q;\n      ui -= wj * fu;\n      vi += wj * fv;\n      U[j] += wi * fu;\n      V[j] -= wi * fv;\n    }\n    U[i] += ui;\n    V[i] += vi;\n  }\n}\n\nfunction rk4(S, h) {\n  const { n, x, y, x0, y0, k } = S;\n  for (let i = 0; i \u003c n; i++) (x0[i] = x[i]), (y0[i] = y[i]);\n  const cs = [0, 0.5, 0.5, 1];\n  for (let st = 0; st \u003c 4; st++) {\n    if (st) for (let i = 0; i \u003c n; i++) (x[i] = x0[i] + cs[st] * h * k[2 * st - 2][i]), (y[i] = y0[i] + cs[st] * h * k[2 * st - 1][i]);\n    velocity(S, x, y, k[2 * st], k[2 * st + 1]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    x[i] = x0[i] + (h / 6) * (k[0][i] + 2 * k[2][i] + 2 * k[4][i] + k[6][i]);\n    y[i] = y0[i] + (h / 6) * (k[1][i] + 2 * k[3][i] + 2 * k[5][i] + k[7][i]);\n  }\n}\n\n// Where a gap has opened wider than GAP, a point goes in at the middle G,\n// placed on the cubic through the four points around it. The points run\n// once round the period in order of G; the one after the last is the\n// first moved on by a whole period, so a point that goes in there is\n// simply added at the end.\nfunction refine(S) {\n  const { x, y, g } = S;\n  const at = (q, o) => {\n    const n = S.n, f = floor(q / n), m = q - f * n;\n    o[0] = x[m] + f;\n    o[1] = y[m];\n    o[2] = g[m] + f;\n  };\n  const a = [0, 0, 0], b = [0, 0, 0], c = [0, 0, 0], e = [0, 0, 0];\n  for (let i = 0; i \u003c S.n && S.n \u003c NMAX; i++) {\n    at(i, b);\n    at(i + 1, c);\n    const dx = c[0] - b[0], dy = c[1] - b[1];\n    if (dx * dx + dy * dy \u003c GAP * GAP) continue;\n    at(i - 1, a);\n    at(i + 2, e);\n    const n = S.n;\n    for (let m = n; m > i + 1; m--) (x[m] = x[m - 1]), (y[m] = y[m - 1]), (g[m] = g[m - 1]);\n    x[i + 1] = (-a[0] + 9 * b[0] + 9 * c[0] - e[0]) / 16;\n    y[i + 1] = (-a[1] + 9 * b[1] + 9 * c[1] - e[1]) / 16;\n    g[i + 1] = (b[2] + c[2]) / 2;\n    S.n++;\n    i++;\n  }\n}\n\n// Tracers: dots laid on a grid of the period, moved by the sheet's own\n// velocity, so the two streams and the winding read away from the sheet.\nfunction seedTracers(S) {\n  const sc = H / S.waves, rows = max(2, round(sc / 6)), cols = 11;\n  S.nt = 0;\n  for (let r = 0; r \u003c rows; r++)\n    for (let c = 0; c \u003c cols; c++) {\n      if (S.nt >= 600) break;\n      S.tx[S.nt] = (r + 0.5) / rows;\n      S.ty[S.nt] = ((c + 0.5) / cols - 0.5) * (W / sc);\n      S.nt++;\n    }\n  S.tWaves = S.waves;\n}\n\n// Tracers feel every other point of the sheet, each carrying the\n// circulation of two: they only have to read the streams, and it halves\n// their cost.\nfunction tracerVel(S, TX, TY, n, U, V) {\n  const { pk } = S, d2 = S.delta * S.delta, np = S.n;\n  for (let i = 0; i \u003c n; i++) {\n    const a = TAU * TX[i], e = exp(TAU * TY[i]), ie = 1 / e;\n    const ci = cos(a), si = sin(a), hi = (e + ie) / 2, gi = (e - ie) / 2;\n    let u = 0, v = 0;\n    for (let j = 0, o = 0; j + 1 \u003c np; j += 2, o += 10) {\n      const cj = pk[o], sj = pk[o + 1], hj = pk[o + 2], gj = pk[o + 3];\n      const q = (0.5 * (pk[o + 4] + pk[o + 9])) / (hi * hj - gi * gj - ci * cj - si * sj + d2);\n      u -= (gi * hj - hi * gj) * q;\n      v += (si * cj - ci * sj) * q;\n    }\n    U[i] = u;\n    V[i] = v;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0.15, 1], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.delta = cl(kv[2], 0.15, 0.5);\n  S.waves = cl(round(kv[3]), 1, 4);\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (!S.born || tap || S.t > AGE) {\n    if (S.born) S.fade = 1;\n    start(S);\n    S.born = true;\n  }\n  if (S.tWaves !== S.waves || !S.nt) seedTracers(S);\n  S.fade = max(0, S.fade - d * 2);\n  // A point at the core's centre turns at up to pi / delta^2 radians a unit\n  // of time if all the circulation sat in its blob, and about half does.\n  // Steps are cut so RK4 turns it under 2.5 radians, inside its stable 2.8;\n  // at Speed 3 that is one step a frame, and a run with four times the\n  // steps put every point within 0.05 LED of it after 2.6 units.\n  const h = d * S.speed * RATE, sub = Math.ceil(h / (2.5 / (PI / (2 * S.delta * S.delta))));\n  for (let k = 0; k \u003c sub; k++) {\n    weights(S);\n    rk4(S, h / sub);\n    S.t += h / sub;\n    refine(S);\n  }\n  // Tracers take one step with the sheet where it now is.\n  weights(S);\n  pack(S, S.x, S.y);\n  const nt = S.nt, TX = S.tx, TY = S.ty, TU = S.tu, TV = S.tv;\n  tracerVel(S, TX, TY, nt, TU, TV);\n  for (let i = 0; i \u003c nt; i++) {\n    TX[i] += h * TU[i];\n    TY[i] += h * TV[i];\n    TX[i] -= floor(TX[i]);\n  }\n}\n\nfunction palette(S) {\n  const P = S.pal, h = 0.55 + S.hue;\n  hsv(dimHue(h), 0.8, 0.26, P, 0); // left fluid\n  hsv(dimHue(h + 0.3), 0.8, 0.26, P, 3); // right fluid\n  hsv(h, 0.6, 0.75, P, 6); // left tracers\n  hsv(h + 0.3, 0.6, 0.75, P, 9); // right tracers\n  hsv(h + 0.15, 0.3, 0.95, P, 12); // sheet\n  S.palHue = S.hue;\n}\n\n// Points laid along a line every third of an LED, each lighting its four\n// nearest LEDs by how close it falls; an LED keeps the brightest.\nfunction plot(S, x, y, P, o, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const k = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c P[o] * k) rgb[p] = P[o] * k;\n      if (rgb[p + 1] \u003c P[o + 1] * k) rgb[p + 1] = P[o + 1] * k;\n      if (rgb[p + 2] \u003c P[o + 2] * k) rgb[p + 2] = P[o + 2] * k;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { x, y, n, rgb, flip } = S, P = S.pal;\n  const sc = H / S.waves, ox = W / 2;\n  const PX = (Y) => ox + Y * sc, PY = (X, k) => (X + k) * sc;\n  // Which fluid each LED holds: the crossings of the sheet to its left,\n  // counted row by row. The sheet spans every row, so the far left is\n  // always the left stream.\n  flip.fill(0);\n  for (let k = -1; k \u003c= S.waves; k++)\n    for (let i = 0; i \u003c n; i++) {\n      const j = i + 1 \u003c n ? i + 1 : 0, wrap = j === 0 ? 1 : 0;\n      const ya = PY(x[i], k), yb = PY(x[j] + wrap, k), xa = PX(y[i]), xb = PX(y[j]);\n      const lo = Math.ceil(min(ya, yb) - 0.5), hi = Math.ceil(max(ya, yb) - 0.5);\n      for (let r = max(0, lo); r \u003c min(H, hi); r++) {\n        const f = (r + 0.5 - ya) / (yb - ya), xc = xa + f * (xb - xa);\n        flip[r * (W + 2) + cl(Math.ceil(xc - 0.5), 0, W)] ^= 1;\n      }\n    }\n  for (let r = 0; r \u003c H; r++) {\n    let par = 0;\n    for (let c = 0; c \u003c W; c++) {\n      par ^= flip[r * (W + 2) + c];\n      const p = (r * W + c) * 3, o = par ? 3 : 0;\n      rgb[p] = P[o];\n      rgb[p + 1] = P[o + 1];\n      rgb[p + 2] = P[o + 2];\n      S.side[r * W + c] = par;\n    }\n  }\n  // Tracers, in the colour of the fluid they are in now, each with a streak\n  // of where it was a tenth of a second ago.\n  const back = 0.1 * S.speed * RATE;\n  for (let k = -1; k \u003c= S.waves; k++)\n    for (let i = 0; i \u003c S.nt; i++) {\n      const px = PX(S.ty[i]), py = PY(S.tx[i], k);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const o = S.side[floor(py) * W + floor(px)] ? 9 : 6, ex = S.tv[i] * back * sc, ey = S.tu[i] * back * sc;\n      for (let e = 3; e >= 0; e--) plot(S, px - (ex * e) / 3, py - (ey * e) / 3, P, o, 1 - e * 0.22);\n    }\n  // The sheet on top.\n  for (let k = -1; k \u003c= S.waves; k++)\n    for (let i = 0; i \u003c n; i++) {\n      const j = i + 1 \u003c n ? i + 1 : 0, wrap = j === 0 ? 1 : 0;\n      const xa = PX(y[i]), ya = PY(x[i], k), xb = PX(y[j]), yb = PY(x[j] + wrap, k);\n      if ((ya \u003c -2 && yb \u003c -2) || (ya > H + 2 && yb > H + 2)) continue;\n      const m = Math.ceil(Math.hypot(xb - xa, yb - ya) * 3) || 1;\n      for (let e = 0; e \u003c= m; e++) plot(S, xa + ((xb - xa) * e) / m, ya + ((yb - ya) * e) / m, P, 12, 1);\n    }\n  const f = S.fade, old = S.old;\n  for (let r = 0, p = 0; r \u003c H; r++)\n    for (let c = 0; c \u003c W; c++, p += 3) {\n      let R = rgb[p], G = rgb[p + 1], B = rgb[p + 2];\n      if (f > 0) (R = R * (1 - f) + old[p] * f), (G = G * (1 - f) + old[p + 1] * f), (B = B * (1 - f) + old[p + 2] * f);\n      else (old[p] = R), (old[p + 1] = G), (old[p + 2] = B);\n      display.setPixel(c, r, (255 * min(1, R)) | 0, (255 * min(1, G)) | 0, (255 * min(1, B)) | 0);\n    }\n}\n","vuza-canon":"// ===== Patternflow pattern =====\n// Title:   Vuza Canon\n// Family:  rhythm\n// Idea:    Twelve voices play the same six-note rhythm from twelve different entries in a cycle of 72 beats, scrolling up the panel one beat a row, and every row holds exactly one note, so the voices tile time with no beat doubled or missed while neither the rhythm nor the entries repeat inside the cycle.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rhythmic tiling canons (Dan Tudor Vuza, 1991), the non-periodic factorisations of cyclic groups (Gyorgy Hajos, 1950; N. G. de Bruijn, 1953), pattern round 55\n// Round:   55\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Canon=0..3, Focus=0..12\n//\n// Knob 1: Hue. Turns the six note colours round the wheel together. At 0 the six notes of the rhythm run gold, green, cyan, azure, violet and magenta in the order each voice plays them; at 0.5 they run blue, violet, red, orange, lime and cyan.\n// Knob 2: Speed. Beats a second, 4.5 times the knob: 9 at 2, so a cycle of 72 passes the now line in 8 seconds; 0.9 at 0.2 (80 seconds) and 13.5 at 3 (5.3 seconds).\n// Knob 3: Canon. 0 is Vuza's canon of Z72: the rhythm A = {0, 8, 16, 18, 26, 34}, gaps 8, 8, 2, 8, 8, 38, in 12 voices entering at B = {0, 1, 5, 6, 12, 25, 29, 36, 42, 48, 49, 53}. 1 swaps the roles: 6 voices entering at A play B, the same 72 notes in the same colours regrouped so each column is one colour. 2 is a tiling with the rhythm {0, 1, 8, 9, 16, 17} whose entries {0, 2, 4, 6} + {0, 24, 48} repeat every 24 beats, so the picture comes round three times a cycle. 3 is the plainest tiling, 6 consecutive beats in 12 voices 6 apart: one staircase.\n// Knob 4: Focus. 0 lights every voice alike. 1 to 12 pick one voice: it is drawn white-cored with a stem joining its notes, and each of its notes rules a faint line across the panel, so its rhythm lies over the roll as a ruler (for Vuza's A, lines 8, 8, 2, 8 and 8 rows apart, then 38 rows of nothing), while the other voices narrow to two LEDs. With 6 voices, 1 and 2 pick the first, 3 and 4 the second, and so on.\n\nconst W = 64, H = 128, N = 72;\nconst { floor, min, max, exp, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The now line, with 104 beats of the past above it and 23 to come below.\nconst NOW = 104;\n// The six note colours at knob 0, a sixth of the wheel apart from gold to\n// magenta, skipping red and orange.\nconst HUES = [0.14, 0.3, 0.46, 0.6, 0.74, 0.88];\n\n// Each canon as a rhythm played by voices at a set of entries, and which of\n// the two the colours follow. A tiling has |A| x |B| = 72 and every sum\n// a + b distinct mod 72; build() checks it and keeps the voice and colour\n// of each beat.\nconst CANONS = [\n  { rhythm: [0, 8, 16, 18, 26, 34], entries: [0, 1, 5, 6, 12, 25, 29, 36, 42, 48, 49, 53], colourBy: \"rhythm\" },\n  { rhythm: [0, 1, 5, 6, 12, 25, 29, 36, 42, 48, 49, 53], entries: [0, 8, 16, 18, 26, 34], colourBy: \"entries\" },\n  { rhythm: [0, 1, 8, 9, 16, 17], entries: [0, 2, 4, 6, 24, 26, 28, 30, 48, 50, 52, 54], colourBy: \"rhythm\" },\n  { rhythm: [0, 1, 2, 3, 4, 5], entries: [0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66], colourBy: \"rhythm\" },\n];\n\nfunction build(c) {\n  const voice = new Int8Array(N).fill(-1), colour = new Int8Array(N), note = new Int8Array(N);\n  c.rhythm.forEach((a, i) =>\n    c.entries.forEach((b, j) => {\n      const t = (a + b) % N;\n      if (voice[t] >= 0) throw new Error(\"not a tiling\");\n      voice[t] = j;\n      note[t] = i;\n      colour[t] = c.colourBy === \"rhythm\" ? i : j;\n    }),\n  );\n  return { voices: c.entries.length, voice, colour, note, entries: c.entries };\n}\nconst TABLES = CANONS.map(build);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    // p is the beat on the now line, counted from the start.\n    p: 0, bps: 9, hue: 0, canon: 0, focus: 0, since: 0, last: 0,\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(18), palHue: -1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.bps = 4.5 * cl(kv[1], 0.2, 3);\n  s.canon = round(cl(kv[2], 0, 3));\n  s.focus = round(cl(kv[3], 0, 12));\n  s.p += d * s.bps;\n  const b = floor(s.p);\n  if (b !== s.last) (s.last = b), (s.since = 0);\n  else s.since += d;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const B = s.buf, P = s.pal;\n  if (s.palHue !== s.hue) {\n    for (let i = 0; i \u003c 6; i++) hsv(HUES[i] + s.hue, 0.8, 1, P, i * 3);\n    s.palHue = s.hue;\n  }\n  B.fill(0);\n  const set = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    B[o] = max(B[o], r);\n    B[o + 1] = max(B[o + 1], g);\n    B[o + 2] = max(B[o + 2], b);\n  };\n  const T = TABLES[s.canon], nv = T.voices, pitch = floor(60 / nv), lit = nv > 6 ? pitch - 1 : pitch - 2;\n  const x0 = (W - pitch * nv + (pitch - lit)) >> 1;\n  // With 6 voices, focus 1 and 2 pick the first, 3 and 4 the second.\n  const fv = s.focus ? floor(((s.focus - 1) * nv) / 12) : -1;\n  const now = floor(s.p), flash = exp(-s.since * 9);\n  const mod = (b) => ((b % N) + N) % N;\n\n  // The scale on the left: a tick every 8 beats, and a dotted line across\n  // where a cycle of 72 begins.\n  for (let y = 0; y \u003c H; y++) {\n    const b = now - (NOW - y), t = mod(b);\n    if (t % 8 === 0) set(0, y, 0.3, 0.32, 0.38);\n    if (t === 0) for (let x = 0; x \u003c W; x += 2) set(x, y, 0.32, 0.34, 0.42);\n  }\n  // A dim lane down the middle of each voice's column, so the voices read as\n  // columns between their notes. It also keeps a fifth of the panel lit:\n  // with the notes alone the picture lit 7% and stretched the study map's\n  // fill axis past its end.\n  for (let v = 0; v \u003c nv; v++) {\n    const cx = x0 + v * pitch + (lit >> 1);\n    for (let y = 0; y \u003c H; y++) set(cx, y, 0.11, 0.115, 0.13);\n  }\n  // The focused voice rules a faint line across the panel at each of its\n  // notes, so its rhythm reads as a ruler laid over the others, and a stem\n  // joins its notes down its own column.\n  if (fv >= 0) {\n    const cx = x0 + fv * pitch + (lit >> 1);\n    let prev = -1;\n    for (let y = 0; y \u003c H; y++) {\n      const t = mod(now - (NOW - y));\n      if (T.voice[t] !== fv) continue;\n      for (let x = 2; x \u003c W; x++) set(x, y, 0.2, 0.2, 0.24);\n      if (prev >= 0) for (let yy = prev + 1; yy \u003c y; yy++) set(cx, yy, 0.45, 0.45, 0.5);\n      prev = y;\n    }\n  }\n  // The notes: one a row, since the voices tile time.\n  for (let y = 0; y \u003c H; y++) {\n    const b = now - (NOW - y), t = mod(b), v = T.voice[t], c = T.colour[t] * 3;\n    const r = P[c], g = P[c + 1], bl = P[c + 2], xl = x0 + v * pitch;\n    const future = y > NOW, hit = y === NOW;\n    let a = xl, z = xl + lit;\n    // Others narrow to their middle two LEDs while one voice is in focus,\n    // and the beats still to come are drawn the same way.\n    if ((fv >= 0 && v !== fv) || future) (a = xl + (lit >> 1) - 1), (z = a + 2);\n    for (let x = a; x \u003c z; x++) {\n      if (fv === v && !future) {\n        // White-cored: the middle LEDs whitened, the ends in the note colour.\n        const core = x > xl && x \u003c xl + lit - 1 ? 0.55 : 0;\n        set(x, y, r + (1 - r) * core, g + (1 - g) * core, bl + (1 - bl) * core);\n      } else set(x, y, r, g, bl);\n    }\n    if (hit) {\n      // The note that sounds flashes white and throws a glow along the now\n      // line in its colour.\n      for (let x = xl - 2; x \u003c xl + lit + 2; x++) {\n        const k = x \u003c xl || x >= xl + lit ? 0.6 * flash : flash;\n        set(x, y, r + (1 - r) * k, g + (1 - g) * k, bl + (1 - bl) * k);\n        set(x, y - 1, r * k, g * k, bl * k);\n        set(x, y + 1, r * k, g * k, bl * k);\n      }\n      // The line itself is grey, coloured only near the note: a dim gold\n      // line across the panel would read brown.\n      for (let x = 0; x \u003c W; x++) {\n        const dd = x \u003c xl ? xl - x : x >= xl + lit ? x - xl - lit + 1 : 0, k = 0.7 * flash * exp(-dd / 8);\n        set(x, y, 0.26 + r * k, 0.27 + g * k, 0.3 + bl * k);\n      }\n    }\n  }\n\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, round(B[o] * 255)), min(255, round(B[o + 1] * 255)), min(255, round(B[o + 2] * 255)));\n}\n","arcsine-law":"// ===== Patternflow pattern =====\n// Title:   Arcsine Law\n// Family:  data\n// Idea:    48 fair random walks come down the panel a row a step, each LED one toss of the coin, bright for a step up and dark for a step down, coloured warm while its walk is above zero and cool below, so the tosses look like noise while most columns run in long stretches of one colour; after 126 steps the warm cells rise to the top of each column and the columns sort themselves by how many there are, so the boundary between the colours draws the arcsine quantile curve, while a histogram beside them gathers every walk so far into Lévy's U-shaped law, its exact values marked by white dots.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: arcsine laws (Paul Lévy, 1939)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Statistic=0..2, Drift=-1..1\n//\n// Knob 1: Hue. Turns every colour around the wheel together. At 0 a walk above zero is amber and below zero azure, pale near zero and deeper the further out it is, a step down drawn at a third of the brightness of a step up, with lavender histogram bars; at 0.25 green above and magenta below, at 0.5 the two sides trade colours.\n// Knob 2: Speed. 20 rows a second per unit: 40 at the opening 2, so a batch of 126 steps comes down in 3.2 s, settles and sorts in 1.4 s and holds for 1.4 s; at 0.2 a batch takes 32 s to come down, at 3 it takes 2.1 s. Walks that are not drawn feed the histogram at 120 a second per unit.\n// Knob 3: Statistic. Which of Lévy's three the columns sort by and the histogram counts. At 0 the time above zero: the warm cells rise to the top of their column. At 1 the last zero: the cells before each walk's last return to zero are dimmed, leaving a bright tail of one colour below it. At 2 the first time of the maximum: the cells after each walk's highest point so far are dimmed. All three histograms settle on the same U.\n// Knob 4: Drift. A step goes up with chance (1 + mu) / 2. mu is 0 within 0.08 of the middle, so the opening 0.06 is the fair walk, then grows as the square to 0.014 at 0.3, 0.052 at 0.5 and 0.25 at either end, where nearly every column floods one colour. Any drift breaks the law: at 0.5 the histogram of time above zero lies 0.19 from it in Kolmogorov distance, while the last zero, which only asks whether the walk comes back, lies 0.051 from it.\n\nconst W = 64, H = 128;\n// 48 walks of 126 steps, one a column, step t drawn in row t - 1; then a\n// dark column and the histogram, 15 columns wide, its bins two rows tall on\n// the same time axis as the walks.\nconst NW = 48, N = 126, HX = 49, HL = 15, NB = 64;\nconst { floor, round, min, max, abs, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The exact laws for N = 126 steps, bin k of the histogram. The time spent\n// above zero (counting a step as above when either end of it is) and the\n// last zero both take the value 2k with probability u(2k) u(N - 2k), where\n// u(2m) = C(2m, m) / 4^m is the chance of being at zero at time 2m: the\n// discrete arcsine law of Feller's textbook (1950). The first time of the\n// maximum is k with probability a(k) b(N - k): a(k) the chance a walk stays\n// above zero for k steps, b(m) the chance it stays at or below zero for m,\n// both by following the walk step by step. Lévy's arcsine law is the limit\n// of all three.\nconst U = new Float64Array(N + 1);\nU[0] = 1;\nfor (let m = 1; 2 * m \u003c= N; m++) U[2 * m] = (U[2 * m - 2] * (2 * m - 1)) / (2 * m);\nfunction stay(strict) {\n  // out[k]: chance that S_1..S_k all stay above zero (strict) or at or\n  // below zero, by the distribution of the walk killed when it leaves.\n  const out = new Float64Array(N + 1), off = N + 1;\n  let p = new Float64Array(2 * N + 3), q = new Float64Array(2 * N + 3);\n  p[off] = 1;\n  out[0] = 1;\n  for (let k = 1; k \u003c= N; k++) {\n    q.fill(0);\n    let tot = 0;\n    for (let x = 1; x \u003c 2 * N + 2; x++) {\n      const v = 0.5 * (p[x - 1] + p[x + 1]);\n      const y = x - off;\n      if (strict ? y > 0 : y \u003c= 0) (q[x] = v), (tot += v);\n    }\n    [p, q] = [q, p];\n    out[k] = tot;\n  }\n  return out;\n}\nconst PB = [new Float64Array(NB), new Float64Array(NB), new Float64Array(NB)];\n{\n  const a = stay(true), b = stay(false);\n  for (let k = 0; k \u003c NB; k++) PB[0][k] = PB[1][k] = U[2 * k] * U[N - 2 * k];\n  for (let t = 0; t \u003c= N; t++) PB[2][t >> 1] += a[t] * b[N - t];\n}\n// The histogram's scale puts the third bin from either end at full length,\n// so the bins at the very ends run off the band.\nconst PFULL = PB[0][2];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, stat: 0, mu: 0, init: false,\n    // The batch on show: positions S[i * (N + 1) + t].\n    S: new Int16Array(NW * (N + 1)), row: 0, phase: 0, clock: 0,\n    pos: new Int16Array(NW), lz: new Int16Array(NW), tm: new Int16Array(NW), top: new Int16Array(NW),\n    // Sorting: each walk's target column and each cell's target row.\n    X: new Int16Array(NW), R: new Int16Array(NW * N), sortStat: -1,\n    // The last sorted picture, shown on every other LED below the new\n    // batch's front.\n    prev: new Float32Array(NW * N * 3),\n    hist: [new Float64Array(NB), new Float64Array(NB), new Float64Array(NB)], walks: 0, histMu: 0,\n    fb: new Float32Array(W * H * 3), c: [0, 0, 0],\n  };\n}\n\n// One walk's three statistics from its positions w[0..N].\nfunction stats(w, o, out) {\n  let pos = 0, lz = 0, tm = 0, top = 0;\n  for (let t = 1; t \u003c= N; t++) {\n    const a = w[o + t - 1], b = w[o + t];\n    if (a + b > 0) pos++;\n    if (b === 0) lz = t;\n    if (b > top) (top = b), (tm = t);\n  }\n  out[0] = pos;\n  out[1] = lz;\n  out[2] = tm;\n}\n\nconst tmpW = new Int16Array(N + 1), tmpS = [0, 0, 0];\nfunction hiddenWalk(S) {\n  const p = (1 + S.mu) / 2;\n  tmpW[0] = 0;\n  for (let t = 1; t \u003c= N; t++) tmpW[t] = tmpW[t - 1] + (Math.random() \u003c p ? 1 : -1);\n  stats(tmpW, 0, tmpS);\n  addStats(S, tmpS);\n}\nfunction addStats(S, st) {\n  S.hist[0][st[0] >> 1]++;\n  S.hist[1][st[1] >> 1]++;\n  S.hist[2][st[2] >> 1]++;\n  S.walks++;\n}\n\nfunction stepRow(S) {\n  const t = S.row + 1, p = (1 + S.mu) / 2, A = S.S;\n  for (let i = 0; i \u003c NW; i++) {\n    const o = i * (N + 1), b = (A[o + t] = A[o + t - 1] + (Math.random() \u003c p ? 1 : -1)), a = A[o + t - 1];\n    if (a + b > 0) S.pos[i]++;\n    if (b === 0) S.lz[i] = t;\n    if (b > S.top[i]) (S.top[i] = b), (S.tm[i] = t);\n  }\n  S.row = t;\n}\n\nfunction newBatch(S) {\n  S.S.fill(0);\n  S.pos.fill(0);\n  S.lz.fill(0);\n  S.tm.fill(0);\n  S.top.fill(0);\n  S.row = 0;\n  S.phase = 0;\n  S.clock = 0;\n}\n\n// The statistic each walk is sorted by, and where each cell goes: for the\n// time above zero the cells above zero rise to the top of their column in\n// their order and the rest sink below them; for the other two the cells\n// stay in their rows.\nfunction plan(S) {\n  const st = S.stat === 0 ? S.pos : S.stat === 1 ? S.lz : S.tm, A = S.S;\n  const idx = [...Array(NW).keys()].sort((a, b) => st[a] - st[b] || A[a * (N + 1) + N] - A[b * (N + 1) + N] || a - b);\n  idx.forEach((w, r) => (S.X[w] = r));\n  for (let i = 0; i \u003c NW; i++) {\n    const o = i * (N + 1);\n    let up = 0, down = S.pos[i];\n    for (let t = 1; t \u003c= N; t++) {\n      const above = A[o + t - 1] + A[o + t] > 0;\n      S.R[i * N + t - 1] = S.stat === 0 ? (above ? up++ : down++) : t - 1;\n    }\n  }\n  S.sortStat = S.stat;\n}\n\n// A cell is one toss of the coin: bright when the step went up, dark when\n// it went down, so the tosses read as noise. Its hue is the sign of the\n// running total, warm above zero and cool below, paler near zero and\n// deeper the further the walk is out in units of sqrt(t), and that hue\n// runs in long stretches. Cells are dimmed before the last zero or after\n// the maximum when those are the statistic.\nfunction shade(S, i, t, out) {\n  const o = i * (N + 1), a = S.S[o + t - 1], b = S.S[o + t], m = min(1, abs(a + b) / (2.2 * sqrt(t))), up = b > a;\n  if (a + b > 0) hsv(0.11 + S.hue, 0.3 + 0.7 * m, up ? 1 : 0.3, out);\n  else hsv(0.6 + S.hue, 0.3 + 0.65 * m, up ? 0.85 : 0.25, out);\n  let dim = false;\n  if (S.stat === 1) dim = t \u003c= S.lz[i];\n  else if (S.stat === 2) dim = t > S.tm[i];\n  if (dim) {\n    const g = (out[0] + out[1] + out[2]) / 3;\n    for (let c = 0; c \u003c 3; c++) out[c] = 0.2 * (0.4 * out[c] + 0.6 * g);\n  }\n  return out;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.stat = cl(round(kv[2]), 0, 2);\n  // Drift: none within 0.08 of the middle, then growing as the square to\n  // 0.25 at either end; the chance of a step up is (1 + mu) / 2.\n  const k4 = cl(kv[3], -1, 1), e = max(0, (abs(k4) - 0.08) / 0.92);\n  S.mu = (k4 \u003c 0 ? -1 : 1) * 0.25 * e * e;\n  if (S.mu !== S.histMu) {\n    for (const h of S.hist) h.fill(0);\n    S.walks = 0;\n    S.histMu = S.mu;\n  }\n  if (!S.init) {\n    // The first batch comes down a dark panel; each later one comes down\n    // over the sorted picture of the one before.\n    S.init = true;\n    newBatch(S);\n  }\n  // Walks nobody sees feed the histogram, 8 a frame at Speed 2.\n  S.hidden = (S.hidden || 0) + (d * 30 * 8 * S.speed) / 2;\n  while (S.hidden >= 1) hiddenWalk(S), S.hidden--;\n  const rate = 20 * S.speed, slow = sqrt(2 / S.speed);\n  S.clock += d;\n  if (S.phase === 0) {\n    const want = min(N, floor(S.clock * rate));\n    while (S.row \u003c want) stepRow(S);\n    if (S.row >= N) {\n      for (let i = 0; i \u003c NW; i++) addStats(S, [S.pos[i], S.lz[i], S.tm[i]]);\n      plan(S);\n      S.phase = 1;\n      S.clock = 0;\n    }\n  } else {\n    if (S.stat !== S.sortStat) plan(S), (S.clock = 0), (S.phase = 1);\n    if (S.phase === 1 && S.clock > 1.4 * slow) (S.phase = 2), (S.clock = 0);\n    if (S.phase === 2 && S.clock > 1.4 * slow) keep(S), newBatch(S);\n  }\n}\n\n// Store the sorted picture of the batch as the backdrop.\nfunction keep(S) {\n  const P = S.prev, c = S.c;\n  P.fill(0);\n  for (let i = 0; i \u003c NW; i++)\n    for (let t = 1; t \u003c= N; t++) {\n      shade(S, i, t, c);\n      const q = (S.R[i * N + t - 1] * NW + S.X[i]) * 3;\n      P[q] = c[0];\n      P[q + 1] = c[1];\n      P[q + 2] = c[2];\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.init) return;\n  const fb = S.fb, c = S.c, P = S.prev;\n  fb.fill(0);\n  if (S.phase === 0) {\n    // The old picture below the front on every other LED, the new walks\n    // above it.\n    for (let r = S.row; r \u003c N; r++)\n      for (let x = (r + 1) & 1; x \u003c NW; x += 2) {\n        const q = (r * W + x) * 3, s = (r * NW + x) * 3;\n        fb[q] = P[s];\n        fb[q + 1] = P[s + 1];\n        fb[q + 2] = P[s + 2];\n      }\n    for (let i = 0; i \u003c NW; i++)\n      for (let t = 1; t \u003c= S.row; t++) {\n        shade(S, i, t, c);\n        const q = ((t - 1) * W + i) * 3;\n        fb[q] = c[0];\n        fb[q + 1] = c[1];\n        fb[q + 2] = c[2];\n      }\n  } else {\n    // Settle first, then slide the columns into their order.\n    const u = S.phase === 2 ? 1 : S.clock / (1.4 * sqrt(2 / S.speed));\n    const ey = ease(u * 2), ex = ease(u * 2 - 1);\n    for (let i = 0; i \u003c NW; i++) {\n      const x = round(i + (S.X[i] - i) * ex);\n      for (let t = 1; t \u003c= N; t++) {\n        const y = round(t - 1 + (S.R[i * N + t - 1] - (t - 1)) * ey);\n        shade(S, i, t, c);\n        const q = (y * W + x) * 3;\n        fb[q] = c[0];\n        fb[q + 1] = c[1];\n        fb[q + 2] = c[2];\n      }\n    }\n  }\n  // Once the columns stand in order, a dot in each marks where Lévy's law\n  // puts that rank: column r of 48 at N sin^2(pi (r + 1/2) / 96), the\n  // arcsine quantile. The boundary of the batch should hug it.\n  if (S.phase === 2) {\n    const v = 0.85 * min(1, S.clock / 0.4);\n    for (let r = 0; r \u003c NW; r++) {\n      const sn = sin((PI * (r + 0.5)) / (2 * NW)), y = min(N - 1, floor(N * sn * sn)), q = (y * W + r) * 3;\n      for (let j = 0; j \u003c 3; j++) fb[q + j] += (255 - fb[q + j]) * v;\n    }\n  }\n  // The histogram of the chosen statistic over every walk so far, and the\n  // exact law as a dot at the length each bar should reach.\n  const h = S.hist[S.stat], pb = PB[S.stat], n = max(1, S.walks), sc = HL / PFULL;\n  for (let k = 0; k \u003c NB; k++) {\n    const len = (h[k] / n) * sc, ex = pb[k] * sc;\n    for (let j = 0; j \u003c HL; j++) {\n      const f = cl(len - j, 0, 1), y0 = 2 * k;\n      let r = 0, g = 0, b = 0;\n      // The bar, the shortfall from the law dimmer, and the law's dot.\n      const sf = j >= len && j \u003c ex - 0.5 ? 0.3 : 0;\n      if (f > 0 || sf) hsv(0.8 + S.hue, 0.35, f > 0 ? 0.3 + 0.6 * f : sf, c), (r = c[0]), (g = c[1]), (b = c[2]);\n      if (abs(j + 0.5 - ex) \u003c 0.5) (r = 255), (g = 255), (b = 255);\n      for (let y = y0; y \u003c y0 + 2; y++) {\n        const q = (y * W + HX + j) * 3;\n        fb[q] = r;\n        fb[q + 1] = g;\n        fb[q + 2] = b;\n      }\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) display.setPixel(p % W, (p / W) | 0, fb[p * 3] | 0, fb[p * 3 + 1] | 0, fb[p * 3 + 2] | 0);\n}\n","nodal-domains":"// ===== Patternflow pattern =====\n// Title:   Nodal Domains\n// Family:  noise\n// Idea:    Berry's random wave, 40 plane waves of one wavelength in random directions each drifting at its own frequency, cut at a level into its nodal domains, each domain one flat colour that stays with it from frame to frame and runs from rose to gold above the level and from violet to cyan below as the domain grows, the largest one pale, while a white spark marks each saddle where two domains just merged or one just split.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: random wave model (Michael Berry, 1977), with the percolation picture of nodal domains (Eugene Bogomolny and Charles Schmit, 2002)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=0..1, Level=-1..1\n//\n// Knob 1: Hue. Turns every colour around the wheel together. At 0 the domains above the level run from rose through orange to gold and those below from blue violet to cyan, with the largest domain cream or sky blue; at 0.25 above is lime to green and below pink to violet, at 0.5 the two sides trade warm and cool.\n// Knob 2: Speed. Each wave turns its phase at its own rate, drawn from a normal law with a spread of 0.3 radians a second per unit: 0.6 at the opening 2, where a domain changes shape within a second or two and the panel sees about 55 merges and as many splits a second; 0.06 at 0.2, and 0.9 at 3.\n// Knob 3: Wavenumber. The wavelength of all 40 waves, 8 LEDs at 0 and 5.5 at 1, zooming about the middle of the panel. Bogomolny and Schmit's count for an area the size of the panel goes from 25 domains to 53; the panel shows about 54 and 95, because its edges cut domains into pieces.\n// Knob 4: Level. Where psi is cut, in units of its standard deviation; it opens at 0.06, next to the critical level 0, where domains of both signs can reach across the panel. At 1 only 16% of the panel lies above the level, the warm side breaks into about 100 islands and one cool domain holds 85% of the panel; at -1 the same with the sides swapped.\n\nconst W = 64, H = 128, N = W * H, J = 40, MAXID = 4096;\nconst { floor, abs, sqrt, sin, cos, log, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Bogomolny and Schmit: nodal domains per unit of k^2 / (4 pi) of area,\n// which is the number of eigenvalues below k^2 per unit area (Weyl).\nconst BS = (3 * sqrt(3) - 5) / PI;\n\n// Colour follows a domain's size. Above the level a domain runs from rose\n// when it is a single lobe of a few LEDs through orange to gold when it is\n// as big as 1,500 LEDs; below the level from blue violet through blue to\n// cyan. Each domain keeps a small hue offset of its own, and the largest\n// domain on the panel is drawn in a light tint, cream above the level and\n// sky blue below.\nconst RAMP = [[0.97, 0.8, 1, 0.13, 0.95, 1], [0.7, 0.75, 0.95, 0.5, 0.9, 0.95]];\nconst PALE = [[0.57, 0.5, 1], [0.14, 0.38, 1]];\nconst A0 = log(8), A1 = log(1500);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nconst gauss = () => sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, wn: 0, lev: 0.06, k: -1, nc: 0, count: 0, bulk: 0,\n    th: new Float64Array(J), ph: new Float64Array(J), om: new Float64Array(J),\n    AR: new Float64Array(W * J), AI: new Float64Array(W * J), CR: new Float64Array(J), CI: new Float64Array(J), SR: new Float64Array(J), SI: new Float64Array(J),\n    V: new Float64Array(N), sg: new Uint8Array(N), par: new Int32Array(N), comp: new Int32Array(N),\n    area: new Int32Array(N), csign: new Uint8Array(N), cid: new Int32Array(N),\n    id: new Int32Array(N).fill(-1), fl: new Float32Array(N), dec: new Uint8Array(N), dec0: new Uint8Array(N),\n    idSign: new Uint8Array(MAXID), idHue: new Float64Array(MAXID), idLA: new Float64Array(MAXID), bigId: -1, used: new Uint8Array(MAXID), taken: new Uint8Array(MAXID),\n    free: [], pairs: new Map(), c: [0, 0, 0],\n  });\n  for (let i = MAXID - 1; i >= 0; i--) S.free.push(i);\n  // Wave directions spread over half a turn, one in each of J equal slots at\n  // a random place in it; phases uniform; each wave its own frequency.\n  for (let j = 0; j \u003c J; j++) {\n    S.th[j] = (PI * (j + Math.random())) / J;\n    S.ph[j] = 2 * PI * Math.random();\n    S.om[j] = gauss();\n  }\n}\n\nfunction find(par, p) {\n  while (par[p] !== p) p = par[p] = par[par[p]];\n  return p;\n}\nfunction union(par, a, b) {\n  a = find(par, a);\n  b = find(par, b);\n  if (a \u003c b) par[b] = a;\n  else if (b \u003c a) par[a] = b;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.wn = cl(kv[2], 0, 1);\n  S.lev = cl(kv[3], -1, 1);\n  // Wavelength in LEDs: 8 at 0, 5.5 at 1.\n  const lam = 8 / (1 + 0.4545 * S.wn), k = (2 * PI) / lam;\n  const AR = S.AR, AI = S.AI, CR = S.CR, CI = S.CI, SR = S.SR, SI = S.SI, th = S.th, ph = S.ph, om = S.om;\n  if (k !== S.k) {\n    S.k = k;\n    for (let j = 0; j \u003c J; j++) {\n      SR[j] = cos(k * sin(th[j]));\n      SI[j] = sin(k * sin(th[j]));\n      for (let x = 0; x \u003c W; x++) {\n        const a = k * cos(th[j]) * (x - (W - 1) / 2);\n        AR[x * J + j] = cos(a);\n        AI[x * J + j] = sin(a);\n      }\n    }\n  }\n  // psi = sum_j a cos(k (x cos th + y sin th) + ph), the real part of a\n  // column factor times a row factor; a = sqrt(2 / J) gives variance 1. The\n  // row factor starts at the top row and turns by k sin th from row to row.\n  const amp = sqrt(2 / J), V = S.V;\n  for (let j = 0; j \u003c J; j++) {\n    ph[j] += d * S.speed * 0.3 * om[j];\n    const b = (-k * sin(th[j]) * (H - 1)) / 2 + ph[j];\n    CR[j] = amp * cos(b);\n    CI[j] = amp * sin(b);\n  }\n  for (let y = 0; y \u003c H; y++) {\n    if (y)\n      for (let j = 0; j \u003c J; j++) {\n        const r = CR[j] * SR[j] - CI[j] * SI[j];\n        CI[j] = CR[j] * SI[j] + CI[j] * SR[j];\n        CR[j] = r;\n      }\n    // The column factor's real part is even about the middle column and its\n    // imaginary part odd, so one pair of sums serves a column and its mirror.\n    const r = y * W;\n    for (let x = 0; x \u003c W / 2; x++) {\n      const o = x * J;\n      let e = 0, q = 0;\n      for (let j = 0; j \u003c J; j++) {\n        e += AR[o + j] * CR[j];\n        q += AI[o + j] * CI[j];\n      }\n      V[r + x] = e - q;\n      V[r + W - 1 - x] = e + q;\n    }\n  }\n  label(S);\n  match(S, d);\n  // What Bogomolny and Schmit expect for an area of the panel's size, far\n  // from any edge.\n  S.bulk = (BS * N * k * k) / (4 * PI);\n}\n\n// Components of {psi > c} and of {psi \u003c c}: 4-neighbours of one sign join,\n// and in a 2 by 2 cell whose corners alternate in sign the value of the\n// bilinear surface at its saddle decides which diagonal pair is joined (the\n// asymptotic decider), so these are the domains of the bilinear surface\n// through the LEDs.\nfunction label(S) {\n  const V = S.V, sg = S.sg, par = S.par, c = S.lev, dec = S.dec0;\n  // dec keeps which diagonal each cell joined, 1 or 2, for the last two\n  // frames, so match can tell where a saddle crossed the level.\n  S.dec0 = S.dec;\n  S.dec = dec;\n  dec.fill(0);\n  for (let p = 0; p \u003c N; p++) {\n    sg[p] = V[p] > c ? 1 : 0;\n    par[p] = p;\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, s = sg[p];\n      if (x \u003c W - 1 && sg[p + 1] === s) union(par, p, p + 1);\n      if (y \u003c H - 1) {\n        if (sg[p + W] === s) union(par, p, p + W);\n        const q = p + W + 1;\n        if (x \u003c W - 1 && sg[q] === s && sg[p + 1] !== s && sg[p + W] !== s) {\n          const a = V[p] - c, b = V[p + 1] - c, e = V[p + W] - c, f = V[q] - c;\n          const sad = (a * f - b * e) / (a + f - b - e);\n          if (sad > 0 === (s === 1)) union(par, p, q), (dec[p] = 1);\n          else union(par, p + 1, p + W), (dec[p] = 2);\n        }\n      }\n    }\n  const comp = S.comp, area = S.area, csign = S.csign;\n  let nc = 0;\n  // Each root is the lowest LED of its domain, so it comes first.\n  for (let p = 0; p \u003c N; p++) {\n    const r = find(par, p);\n    if (r === p) {\n      comp[p] = nc;\n      area[nc] = 0;\n      csign[nc++] = sg[p];\n    } else comp[p] = comp[r];\n    area[comp[p]]++;\n  }\n  S.nc = S.count = nc;\n  let big = 0;\n  for (let i = 1; i \u003c nc; i++) if (area[i] > area[big]) big = i;\n  S.big = big;\n}\n\n// Each domain takes over the colour of the old domain of its sign that it\n// overlaps most, largest overlaps first. So a domain that splits keeps its\n// colour on the larger piece, and of two that merge the one with the larger\n// overlap keeps its colour.\nfunction match(S, d) {\n  const comp = S.comp, id = S.id, sg = S.sg, idSign = S.idSign, pairs = S.pairs, nc = S.nc, cid = S.cid, taken = S.taken, used = S.used;\n  const fl = S.fl, decay = exp(-4 * d);\n  for (let p = 0; p \u003c N; p++) fl[p] *= decay;\n  if (S.k === S.k0) saddles(S);\n  S.k0 = S.k;\n  pairs.clear();\n  let run = 0, key = -1;\n  for (let p = 0; p \u003c= N; p++) {\n    const o = p \u003c N ? id[p] : -1;\n    const kk = o >= 0 && idSign[o] === sg[p] ? comp[p] * MAXID + o : -1;\n    if (kk !== key || p === N) {\n      if (key >= 0) pairs.set(key, (pairs.get(key) || 0) + run);\n      key = kk;\n      run = 0;\n    }\n    run++;\n  }\n  const list = [...pairs].sort((a, b) => b[1] - a[1]);\n  cid.fill(-1, 0, nc);\n  taken.fill(0);\n  for (const [kk] of list) {\n    const ci = floor(kk / MAXID), o = kk % MAXID;\n    if (cid[ci] \u003c 0 && !taken[o]) (cid[ci] = o), (taken[o] = 1);\n  }\n  for (let o = 0; o \u003c MAXID; o++) if (used[o] && !taken[o]) (used[o] = 0), S.free.push(o);\n  for (let i = 0; i \u003c nc; i++)\n    if (cid[i] \u003c 0 && S.free.length) {\n      const o = S.free.pop();\n      used[o] = 1;\n      cid[i] = o;\n      idSign[o] = S.csign[i];\n      S.idHue[o] = 0.05 * (Math.random() - 0.5);\n      S.idLA[o] = log(S.area[i]);\n    }\n  for (let p = 0; p \u003c N; p++) id[p] = cid[comp[p]];\n  // The size a colour shows eases toward the true size in about a quarter\n  // of a second, so a big domain that touches a neighbour at one saddle and\n  // lets go again does not flicker. The pale mark stays on the domain that\n  // has it until another one is a quarter bigger.\n  const e = 1 - exp(-d / 0.25), area = S.area;\n  let bi = -1, top = 0;\n  for (let i = 0; i \u003c nc; i++) {\n    const o = cid[i];\n    S.idLA[o] += (log(area[i]) - S.idLA[o]) * e;\n    if (o === S.bigId) bi = i;\n    if (area[i] > top) top = area[i];\n  }\n  if (bi \u003c 0 || area[bi] * 1.25 \u003c top) S.bigId = cid[S.big];\n}\n\n// A merge or a split happens where a saddle of psi crosses the level: an LED\n// changes sign, or a cell's saddle value does. Around each such place, two\n// LEDs of one sign that were in different domains last frame and are in one\n// now mark a merge, and two that were in one and are now apart mark a split.\n// The 3 by 3 LEDs around it flash white.\nfunction saddles(S) {\n  const id = S.id, sg = S.sg, comp = S.comp, idSign = S.idSign, dec = S.dec, dec0 = S.dec0, fl = S.fl;\n  let n = 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = id[p];\n      if (!((o >= 0 && idSign[o] !== sg[p]) || (dec[p] && dec0[p] && dec[p] !== dec0[p]))) continue;\n      const x0 = x > 0 ? x - 1 : 0, x1 = x \u003c W - 1 ? x + 1 : x, y0 = y > 0 ? y - 1 : 0, y1 = y \u003c H - 1 ? y + 1 : y;\n      let hit = false;\n      for (let q = 0; q \u003c 9 && !hit; q++) {\n        const a = x - 1 + (q % 3), b = y - 1 + floor(q / 3);\n        if (a \u003c x0 || a > x1 || b \u003c y0 || b > y1) continue;\n        const u = b * W + a, ou = id[u];\n        if (ou \u003c 0 || idSign[ou] !== sg[u]) continue;\n        for (let r = q + 1; r \u003c 9; r++) {\n          const a2 = x - 1 + (r % 3), b2 = y - 1 + floor(r / 3);\n          if (a2 \u003c x0 || a2 > x1 || b2 \u003c y0 || b2 > y1) continue;\n          const v = b2 * W + a2, ov = id[v];\n          if (ov \u003c 0 || sg[v] !== sg[u] || idSign[ov] !== sg[v]) continue;\n          if ((ou !== ov) === (comp[u] === comp[v])) {\n            hit = true;\n            break;\n          }\n        }\n      }\n      if (hit) {\n        if (fl[p] \u003c 1) n++;\n        for (let b = y0; b \u003c= y1; b++) for (let a = x0; a \u003c= x1; a++) fl[b * W + a] = 1;\n      }\n    }\n  S.events = n;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const V = S.V, id = S.id, comp = S.comp, fl = S.fl, c = S.c, lev = S.lev, nc = S.nc;\n  const R = S.R || (S.R = new Float32Array(N * 3));\n  for (let i = 0; i \u003c nc; i++) {\n    const o = S.cid[i], s = S.idSign[o];\n    if (S.cid[i] === S.bigId) hsv(PALE[s][0] + S.hue, PALE[s][1], PALE[s][2], c);\n    else {\n      const u = cl((S.idLA[o] - A0) / (A1 - A0), 0, 1), P = RAMP[s ? 0 : 1];\n      hsv(P[0] + (P[3] - P[0] + (s ? 1 : 0)) * u + S.idHue[o] + S.hue, P[1] + (P[4] - P[1]) * u, P[2] + (P[5] - P[2]) * u, c);\n    }\n    R[i * 3] = c[0];\n    R[i * 3 + 1] = c[1];\n    R[i * 3 + 2] = c[2];\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, v = V[p] - lev;\n      // Distance to the level line in LEDs, the value over the gradient; the\n      // line is drawn dark, about one LED wide.\n      const gx = ((x \u003c W - 1 ? V[p + 1] : V[p]) - (x > 0 ? V[p - 1] : V[p])) / (x > 0 && x \u003c W - 1 ? 2 : 1);\n      const gy = ((y \u003c H - 1 ? V[p + W] : V[p]) - (y > 0 ? V[p - W] : V[p])) / (y > 0 && y \u003c H - 1 ? 2 : 1);\n      const f = cl((abs(v) / (sqrt(gx * gx + gy * gy) + 1e-6) - 0.2) / 0.6, 0, 1);\n      // A spark lights the saddle white, the line through it included.\n      const q = comp[p] * 3, w = 0.85 * fl[p], g = f * (1 - w), h = 255 * w;\n      display.setPixel(x, y, (R[q] * g + h) | 0, (R[q + 1] * g + h) | 0, (R[q + 2] * g + h) | 0);\n    }\n}\n","pearcey-cusp":"// ===== Patternflow pattern =====\n// Title:   Pearcey Cusp\n// Family:  wave\n// Idea:    The Pearcey integral, the wave field at the tip of a cusp caustic, computed at every LED: from a bright focus near the top its intensity opens downward into a lattice of bright spots whose wavefronts flow down the panel, and each exact zero of the field, a phase vortex, carries a mark coloured by the way its phase turns.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pearcey integral (Trevor Pearcey, 1946), the cusp diffraction catastrophe (Michael Berry and Colin Upstill, 1980)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wavenumber=-1..1, Tilt=-1..1\n//\n// Knob 1: Hue. The colour of the light. At 0 it is green inside the ray caustic, where three rays cross, and teal outside it, where one ray passes; a zero is marked pink when the phase climbs clockwise round it and amber when it climbs anticlockwise. At 0.25 the light is violet and at 0.5 rose; 0.75 turns it gold.\n// Knob 2: Speed. How fast the phase turns: 0.4 turns a second for each unit, 0.8 at the opening 2. The crests run down the panel and wheel anticlockwise round a pink zero, clockwise round an amber one.\n// Knob 3: Wavenumber. The wavenumber k in octaves around the opening view, with the ray caustic held still: at 0 the panel spans x from -12 to 12 and y from 2 to -10 and holds 76 zeros; at -1 it is 0.59 of that across and 0.71 down, 18 zeros; at 1 it is 1.68 across and 1.41 down, about 285 zeros, packed as close as the LEDs can mark them.\n// Knob 4: Tilt. Adds a t^3 term to the phase, up to 1.5 t^3 at either end. A shift of t removes it again, so the field is the same Pearcey field on sheared axes: the cusp's axis leans 21 LEDs left at 1 or right at -1 by the bottom row, and its tip rises 9 rows.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The opening view in Pearcey units: x across, y down the panel.\nconst XH = 12, YT = 2, YB = -10;\n\n// Quadrature nodes. P(x, y) is the integral over real t of\n// exp(i (t^4 + y t^2 + x t)). Cauchy lets the path leave the real axis, and\n// on t(s) = s + i K s^3 / (s^2 + C^2) the integrand is real-axis-like near\n// the stationary points and dies as exp(-s^4) far out. The integrand is\n// analytic along the path, so the trapezoid rule converges geometrically:\n// 169 nodes agree with an 80-digit sum on the path t = s e^(i pi/8) to\n// 3e-10 of the field's size at 40 LEDs, tilted views among them.\nconst HS = 0.06, CC = 5, KK = 0.5, SM = 5, J = 2 * Math.ceil(SM / HS) + 1;\nconst SR = new Float64Array(J), SI = new Float64Array(J), WR = new Float64Array(J), WI = new Float64Array(J);\nfor (let j = 0; j \u003c J; j++) {\n  const s = (j - (J - 1) / 2) * HS, d = s * s + CC * CC;\n  SR[j] = s;\n  SI[j] = (KK * s * s * s) / d;\n  // dt = t'(s) ds\n  WR[j] = HS;\n  WI[j] = (HS * KK * s * s * (s * s + 3 * CC * CC)) / (d * d);\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, kn: NaN, tl: NaN, ph: 0,\n    re: new Float64Array(N), im: new Float64Array(N), amp: new Float32Array(N), ur: new Float32Array(N), ui: new Float32Array(N),\n    zs: new Int8Array(N), nz: 0, rays: new Float32Array(N), xs: new Float64Array(W), ys: new Float64Array(H),\n    Er: new Float64Array(W * J), Ei: new Float64Array(W * J), Br: new Float64Array(J), Bi: new Float64Array(J), c: [0, 0, 0],\n  };\n}\n\n// The whole field for wavenumber knob kn and tilt knob tl. Scaling the\n// wavenumber k by 2^kn scales x by k^(3/4) and y by k^(1/2), which keeps the\n// ray caustic 8 y^3 + 27 x^2 = 0 at the same LEDs. The cubic coefficient\n// scales by k^(1/4), which keeps the lean the same.\nfunction field(S, kn, tl) {\n  const s = 2 ** (kn / 2), sx = s ** 1.5, a = 1.5 * tl * sqrt(s), q = a / 4;\n  const { re, im, xs, ys, Er, Ei, Br, Bi } = S;\n  for (let m = 0; m \u003c W; m++) xs[m] = sx * XH * ((2 * m + 1) / W - 1);\n  for (let r = 0; r \u003c H; r++) ys[r] = s * (YT + ((YB - YT) * (r + 0.5)) / H);\n  // The path shifted left by a/4 is the one that suits the t^3 term, since\n  // t = u - a/4 turns t^4 + a t^3 into u^4 plus lower powers.\n  for (let m = 0; m \u003c W; m++)\n    for (let j = 0; j \u003c J; j++) {\n      const x = xs[m], e = exp(-x * SI[j]), ang = x * (SR[j] - q);\n      Er[m * J + j] = e * cos(ang);\n      Ei[m * J + j] = e * sin(ang);\n    }\n  for (let r = 0; r \u003c H; r++) {\n    const y = ys[r];\n    for (let j = 0; j \u003c J; j++) {\n      const tr = SR[j] - q, ti = SI[j];\n      const t2r = tr * tr - ti * ti, t2i = 2 * tr * ti, t3r = t2r * tr - t2i * ti, t3i = t2r * ti + t2i * tr;\n      const pr = t2r * t2r - t2i * t2i + a * t3r + y * t2r, pi = 2 * t2r * t2i + a * t3i + y * t2i, g = exp(-pi);\n      const fr = g * cos(pr), fi = g * sin(pr);\n      Br[j] = fr * WR[j] - fi * WI[j];\n      Bi[j] = fr * WI[j] + fi * WR[j];\n    }\n    for (let m = 0; m \u003c W; m++) {\n      let ar = 0, ai = 0;\n      for (let j = 0, o = m * J; j \u003c J; j++, o++) {\n        const er = Er[o], ei = Ei[o], br = Br[j], bi = Bi[j];\n        ar += br * er - bi * ei;\n        ai += br * ei + bi * er;\n      }\n      re[r * W + m] = ar;\n      im[r * W + m] = ai;\n    }\n  }\n  // Brightness: the amplitude |P| over 2.2, nearly linear, which is the\n  // square root of the intensity: the dim fan outside the cusp still reads\n  // while the focus, |P|^2 = 6.9 at most, does not swamp the lattice.\n  const { amp, ur, ui, zs, rays } = S;\n  for (let p = 0; p \u003c N; p++) {\n    const A = sqrt(re[p] * re[p] + im[p] * im[p]);\n    amp[p] = min(1, (A / 2.2) ** 0.95);\n    ur[p] = A > 0 ? re[p] / A : 0;\n    ui[p] = A > 0 ? im[p] / A : 0;\n  }\n  // The ray picture, for the tint: on the sheared axes u = x - a y / 2 +\n  // a^3 / 8, v = y - 3 a^2 / 8 the caustic is 8 v^3 + 27 u^2 = 0. Inside it\n  // three rays cross each point, outside one. rays runs from 0 outside to 1\n  // inside across about two LEDs, by the caustic's value over its gradient.\n  const ex = (2 * sx * XH) / W, ey = (s * (YT - YB)) / H;\n  for (let r = 0; r \u003c H; r++)\n    for (let m = 0; m \u003c W; m++) {\n      const y = ys[r], u = xs[m] - (a * y) / 2 + (a * a * a) / 8, v = y - (3 * a * a) / 8;\n      const f = 8 * v * v * v + 27 * u * u, gx = 54 * u * ex, gy = 24 * v * v * ey;\n      rays[r * W + m] = cl(0.5 - f / sqrt(gx * gx + gy * gy + 1e-9) / 2, 0, 1);\n    }\n  // Zeros: the phase winds by a whole turn round a square of four LEDs.\n  // The sign of the turn is the vortex's charge; the LED of the four with\n  // the least amplitude carries the mark.\n  zs.fill(0);\n  let nz = 0;\n  const wrap = (d) => d - 2 * PI * round(d / (2 * PI));\n  for (let r = 0; r \u003c H - 1; r++)\n    for (let m = 0; m \u003c W - 1; m++) {\n      const p = r * W + m, c4 = [p, p + 1, p + W + 1, p + W];\n      let w = 0;\n      for (let k = 0; k \u003c 4; k++) {\n        const u = c4[k], v = c4[(k + 1) & 3];\n        w += wrap(atan2(im[v], re[v]) - atan2(im[u], re[u]));\n      }\n      const n = round(w / (2 * PI));\n      if (n) {\n        let b = c4[0];\n        for (let k = 1; k \u003c 4; k++) if (amp[c4[k]] \u003c amp[b]) b = c4[k];\n        zs[b] = n > 0 ? 1 : -1;\n        nz++;\n      }\n    }\n  S.nz = nz;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const kn = cl(k[2], -1, 1), tl = cl(k[3], -1, 1);\n  if (abs(kn - S.kn) > 1e-4 || abs(tl - S.tl) > 1e-4 || S.kn !== S.kn) {\n    S.kn = kn;\n    S.tl = tl;\n    field(S, kn, tl);\n  }\n  // A monochromatic wave keeps its intensity and turns its phase. P obeys\n  // dP/dy = -i d2P/dx2, the paraxial wave equation with y as minus the\n  // distance travelled, so the light runs down the panel; drawing the real\n  // part of P exp(i w t) moves each crest toward lower phase, down with it.\n  S.ph += d * S.speed * 0.4 * 2 * PI;\n  if (S.ph > 2 * PI) S.ph -= 2 * PI;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { amp, ur, ui, zs, rays, c } = S, cr = cos(S.ph), ci = sin(S.ph), h0 = 0.47 + S.hue;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, a = amp[p];\n      if (zs[p]) {\n        // A vortex: pink when the phase climbs going clockwise round the\n        // square on the panel (right, down, left, up), amber the other way.\n        hsv(zs[p] > 0 ? h0 + 0.48 : h0 + 0.67, 0.75, 0.95, c);\n      } else {\n        // The real part of the turning field over its amplitude: 1 on a\n        // crest. Crests brighten and whiten, troughs dim.\n        const w = 0.5 + 0.5 * (ur[p] * cr - ui[p] * ci), w2 = w * w;\n        hsv(h0 + 0.12 * (1 - rays[p]) - 0.1 * w, 0.85 - 0.5 * a * w2, a * (0.4 + 0.6 * w2), c);\n      }\n      display.setPixel(x, y, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n}\n","smale-horseshoe":"// ===== Patternflow pattern =====\n// Title:   Smale Horseshoe\n// Family:  fractal\n// Idea:    Smale's horseshoe map squeezes the square in the middle of the panel sideways and stretches it up past the top, then bends it back down over itself, fold after fold; the panel holds the folded ribbon of the fifth image, 32 strands about an LED wide that cross the square gold where the ribbon runs up and azure where it runs down, turning in nested arches above and nested U's below; where they cross the eight horizontal strips of points that stay in the square for three more folds they turn white, the invariant Cantor set on which the map is the shift on two symbols.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Smale's horseshoe (Stephen Smale, 1965)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strands=-1..1, Squeeze=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the rising strands are gold and the falling ones azure, with violet stable strands and white crossings; at 0.5 the rising strands turn blue and the falling ones orange.\n// Knob 2: Speed. One fold a cycle. At 2 a cycle takes 3 s and holds still for the first half; the squeeze and stretch take 0.45 s of the rest and the bend 1.05 s. At 0.2 a cycle takes 30 s, at 3 two seconds.\n// Knob 3: Strands. Which Cantor family shows. At 0 both: the images of the panel as vertical strands and the points that stay in the square for three more folds as faint violet bands, white where they cross. At -1 only the images. Towards +1 the images fade and the violet bands brighten to full, the stable set alone.\n// Knob 4: Squeeze. The factor lambda by which a fold narrows the square, 0.445 at 0 down to 0.285 at 1 (0.435 at the opening), with the stretch mu = 2 + (pi/2)(1 - lambda), 2.89 at the opening. The level drawn keeps the finest strands near an LED wide: the fifth image's 32 strands up to 0.15 and the fourth's 16 up to 0.66; from there on the third's 8, with gaps that widen as lambda falls.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (t) => t * t * (3 - 2 * t);\n\n// The domain D is the panel: x from 0 to 64, Y from 0 at the bottom row to\n// 128. The square Q runs from Y = C to QT; the cap A lies below it and the\n// cap B above.\nconst C = 32, QT = 96, HQ = 64;\n// A cycle: held still for HOLD of it, then the homotopy, its first T1 the\n// straight squeeze and stretch and the rest the bend.\nconst HOLD = 0.5, T1 = 0.3;\n\n// f lays D along a U-shaped centre line, squeezed by lambda across it and\n// stretched along it by mu through Q. The left leg runs up the left edge of\n// Q and the right leg down the right edge; between them the bend of radius R\n// turns over in B. A goes to the left foot below Q, shifted sideways only,\n// and B to the right foot, turned over. So f(D) lies in D and meets Q in two\n// vertical strips, each lambda wide; the horizontal strip of Q between the\n// two that feed the legs goes round the bend.\nfunction geom(S, lam) {\n  S.lam = lam;\n  S.w = 32 * lam;\n  S.R = 32 - S.w;\n  // The bend runs as fast as the legs: pi R = mu (HQ - 2 HQ / mu).\n  S.mu = 2 + (PI * S.R) / HQ;\n  S.len = 2 * C + HQ * S.mu;\n  // The level drawn: the finest vertical strands near an LED wide, the\n  // finest horizontal ones near an LED tall.\n  S.nf = cl(floor(log(0.85 / 64) / log(lam)), 2, 6);\n  S.nb = cl(floor(log(0.9 / HQ) / log(1 / S.mu)), 2, 6);\n}\n\n// From arc length along the centre line back to the height Y in D.\nconst isig = (S, s) => (s \u003c C ? s : s \u003c= C + HQ * S.mu ? C + (s - C) / S.mu : QT + s - C - HQ * S.mu);\n\n// The preimage under f of a point of f(D), into P. P[2] is 1 when that\n// point's piece of the strand runs the other way up from its preimage: the\n// right leg and foot, and the half of the bend past the top. False when the\n// point is not in f(D).\nfunction finv(S, X, Y, P) {\n  const lam = S.lam, w2 = 2 * S.w;\n  if (Y \u003c= QT) {\n    if (X \u003c= w2) {\n      P[0] = X / lam;\n      P[1] = Y \u003c C ? Y : C + (Y - C) / S.mu;\n      P[2] = 0;\n      return true;\n    }\n    if (X >= 64 - w2) {\n      P[0] = (64 - X) / lam;\n      P[1] = Y \u003c C ? QT + C - Y : QT - (Y - C) / S.mu;\n      P[2] = 1;\n      return true;\n    }\n    return false;\n  }\n  const dx = X - 32, dy = Y - QT, r = sqrt(dx * dx + dy * dy);\n  if (abs(r - S.R) > S.w) return false;\n  const th = atan2(dy, dx);\n  P[0] = 32 + (S.R - r) / lam;\n  P[1] = C + (HQ + S.R * (PI - th)) / S.mu;\n  P[2] = th \u003c PI / 2 ? 1 : 0;\n  return true;\n}\n\n// How many times a point can be pulled back by f and stay in D, up to nf:\n// a point of f^d(D) outside f^(d+1)(D). In Q this is the depth of the gap\n// of the Cantor set it sits in. The parity of the turns over in the first\n// nf - 1 pulls goes to S.o1 and in all nf to S.o2: whether the strand of\n// f^nf(D) through the point runs up (0) or down (1). Strands next to each\n// other always run opposite ways.\nfunction fdepth(S, X, Y, P) {\n  let k = 0, o = 0;\n  P[0] = X;\n  P[1] = Y;\n  S.o1 = 0;\n  while (k \u003c S.nf && finv(S, P[0], P[1], P)) {\n    o ^= P[2];\n    k++;\n    if (k === S.nf - 1) S.o1 = o;\n  }\n  S.o2 = o;\n  return k;\n}\n\n// How many times f can push a point forward and keep it in Q, up to nb + 1.\n// It depends on the height alone: the horizontal strips.\nfunction bdepth(S, Y) {\n  let k = 0;\n  const mu = S.mu, h = HQ / mu;\n  while (k \u003c= S.nb && Y >= C && Y \u003c= QT) {\n    k++;\n    const q = Y - C;\n    if (q \u003c h) Y = C + mu * q;\n    else if (q > HQ - h) Y = C + mu * (HQ - q);\n    else return k;\n  }\n  return k;\n}\n\n// The homotopy from the identity at tau = 0 to f at tau = 1: the panel\n// squeezed toward its left edge and stretched straight up along the centre\n// line, then the part above Q bent over, the bend's angle growing to pi.\n// phase() fixes the shape for one tau; minv() takes a point back through it\n// into P, with P[2] set where the bend has turned the strand downward, and\n// is false outside the image.\nfunction phase(S, tau) {\n  S.tau = tau;\n  if (tau \u003c T1) {\n    const a = ss(tau / T1);\n    S.sx = 1 - a + a * S.lam;\n    S.sq = 1 - a + a * S.mu;\n    S.gt = QT * (1 - a) + a * (C + HQ * S.mu);\n  } else {\n    S.phi = PI * ss((tau - T1) / (1 - T1));\n    S.ct = cos(PI - S.phi);\n    S.st = sin(PI - S.phi);\n  }\n}\n\nfunction minv(S, X, Y, P) {\n  P[2] = 0;\n  if (S.tau \u003c T1) {\n    const x = X / S.sx, y = Y \u003c C ? Y : Y \u003c= S.gt ? C + (Y - C) / S.sq : QT + Y - S.gt;\n    if (x > 64 || y > 128) return false;\n    P[0] = x;\n    P[1] = y;\n    return true;\n  }\n  const phi = S.phi, lam = S.lam, w = S.w, R = S.R;\n  let s = -1, u = 0;\n  if (Y \u003c= QT) {\n    if (X \u003c= 2 * w) (s = Y), (u = (X - w) / lam);\n  } else {\n    const dx = X - 32, dy = Y - QT, r = sqrt(dx * dx + dy * dy);\n    if (abs(r - R) \u003c= w) {\n      const th = atan2(dy, dx);\n      if (th >= PI - phi) {\n        s = QT + R * (PI - th);\n        u = (R - r) / lam;\n        P[2] = th \u003c PI / 2 ? 1 : 0;\n      }\n    }\n  }\n  if (s \u003c 0) {\n    // Past the bend the strip runs straight on, along its tangent.\n    const ct = S.ct, st = S.st, px = X - 32 - R * ct, py = Y - QT - R * st;\n    const sl = px * st - py * ct, off = -px * ct - py * st;\n    if (sl >= 0 && abs(off) \u003c= w) {\n      s = QT + R * phi + sl;\n      u = off / lam;\n      P[2] = phi > PI / 2 ? 1 : 0;\n    }\n  }\n  if (s \u003c 0 || s > S.len) return false;\n  P[0] = 32 + u;\n  P[1] = isig(S, s);\n  return true;\n}\n\nexport function setup(params) {\n  // The first second shows the folded ribbon still; the first stretch\n  // starts at 1.5 s.\n  params.s = { ph: 0.98, hue: 0, strands: 0, lam: 0, nf: 5, nb: 4, tau: 0, sx: 1, sq: 1, gt: QT, phi: 0, ct: -1, st: 0, o1: 0, o2: 0, c: [0, 0, 0], P: [0, 0, 0], pal: new Float64Array(15) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.strands = cl(k[2], -1, 1);\n  const lam = 0.445 - 0.16 * cl(k[3], 0, 1);\n  if (lam !== S.lam) geom(S, lam);\n  S.ph += (d * cl(k[1], 0.2, 3)) / 6;\n  S.ph -= floor(S.ph);\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const tau = S.ph \u003c HOLD ? 0 : (S.ph - HOLD) / (1 - HOLD);\n  phase(S, tau);\n  const P = S.P, c = S.c, pal = S.pal, h = S.hue, nf = S.nf, nb = S.nb;\n  const wf = min(1, 1 - S.strands), wb = min(1, 1 + S.strands), vb = 0.3 + 0.7 * max(0, S.strands);\n  // Rising strands gold and falling strands azure; where a stable strand\n  // crosses them, near white. The stable strands alone are violet.\n  const cols = [0.12, 0.85, 1, 0.58, 0.75, 0.8, 0.12, 0.12, 1, 0.58, 0.3, 0.9, 0.78, 0.65, vb];\n  for (let n = 0; n \u003c 15; n += 3) {\n    hsv(h + cols[n], cols[n + 1], cols[n + 2], c);\n    pal[n] = c[0];\n    pal[n + 1] = c[1];\n    pal[n + 2] = c[2];\n  }\n  for (let j = 0; j \u003c H; j++) {\n    const Y = 127.5 - j;\n    for (let i = 0; i \u003c W; i++) {\n      // The drawn depths move with the ribbon and climb by tau through the\n      // fold, so the picture at the end of a cycle is the one it began with:\n      // f maps the strands of each level onto those of the next.\n      let v = tau - 1, e = 0, dn = 0;\n      if (minv(S, i + 0.5, Y, P)) {\n        const fl = P[2];\n        e = max(0, bdepth(S, P[1]) - tau);\n        v = fdepth(S, P[0], P[1], P) + tau;\n        // Which way the strand runs, by the turns of the last nf pulls,\n        // handing over to the last nf - 1 as the fold adds one more.\n        dn = (1 - tau) * (S.o2 ^ fl) + tau * (S.o1 ^ fl);\n      } else if (tau > 0.6 && i + 0.5 > 2 * S.w && i + 0.5 \u003c 64 - 2 * S.w) {\n        // In the gap the ribbon leaves between its legs, the stable strips\n        // of Q come back while the bend closes.\n        e = nb - 1 + ((tau - 0.6) / 0.4) * (bdepth(S, Y) - nb + 1);\n      }\n      const F = wf * cl(v - (nf - 1), 0, 1), B = wb * cl(e - (nb - 1), 0, 1);\n      const up = 1 - dn, a = F * (1 - B), b = F * B, g = (1 - F) * B;\n      for (let q = 0; q \u003c 3; q++) c[q] = a * (up * pal[q] + dn * pal[3 + q]) + b * (up * pal[6 + q] + dn * pal[9 + q]) + g * pal[12 + q];\n      display.setPixel(i, j, min(255, c[0]) | 0, min(255, c[1]) | 0, min(255, c[2]) | 0);\n    }\n  }\n}\n","stable-marriage":"// ===== Patternflow pattern =====\n// Title:   Stable Marriage\n// Family:  algo\n// Idea:    Gale and Shapley's deferred acceptance between 16 people along the top edge and 16 along the bottom, every proposal a line that runs the panel's full height; a proposal held stays lit and one turned away flashes and fades, and when a receiver trades up the line it held snaps in two. Once the top has its stable matching the bottom proposes on the same lists, and then the pairs where the two stable matchings differ swap back and forth.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: deferred acceptance (David Gale and Lloyd Shapley, 1962)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Agreement=0..1, Choosy=0..1\n//\n// Knob 1: Hue. Each end of a line, and the tile of each person, is coloured by the rank that person gives the partner: at 0 a first choice is green and the last pink, with blue at about the fifth. Turning it moves the whole scale round the colour wheel.\n// Knob 2: Speed. Rounds a second: 2 at the opening 2. In a round every free proposer sends one proposal; a round of eight or more takes a whole round's time, a round of one, as in the chains of rejections that end a run, 0.35 of it. A proposal takes 0.6 of its round to cross.\n// Knob 3: Agreement. How much everyone shares one ranking of the other side, left best. At 0 each list is an independent shuffle and the lines cross every which way: a run takes 47 proposals on average, close to n ln n = 44, and in 9 runs of 10 the two sides' matchings differ. At 1 everyone agrees: all 16 first proposals land on the bottom left, the run takes 136 proposals in 16 rounds, and it ends in 16 parallel lines, the one stable matching.\n// Knob 4: Choosy. The share of the other side each person refuses outright, from none at 0 to three quarters at 1, where 7.5 of the 16 on each side stay single on average. A single person's tile is dim grey, and the same people are single in both stable matchings.\n\nconst W = 64, H = 128, n = 16, SP = W / n, Y0 = 4, Y1 = 123;\nconst { floor, min, max, abs, sqrt, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst XP = (i) => SP * i + (SP >> 1);\n// Rank given to someone a person will not take.\nconst NO = 999;\n// The phases of a cycle. The top proposes and its matching holds; the\n// bottom proposes on the same lists and its matching holds; then the two are\n// compared, and the panel fades to new lists.\nconst RUN_A = 0, HOLD_A = 1, RUN_B = 2, HOLD_B = 3, COMPARE = 4, FADE = 5;\n// Lengths in rounds; FLY is when the proposals of a round arrive.\nconst T_HOLD_A = 3, T_HOLD_B = 2, T_CMP = 8, T_FADE = 1.5, FLY = 0.6, T_GONE = 0.8;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, agree: -1, choosy: -1, phase: RUN_A, pt: 0, rt: 0, decided: true,\n    // Lists: lt[i * n + k] is the k-th choice of top person i, lb the same\n    // for the bottom; rkt and rkb hold the rank each gives, NO if refused.\n    lt: new Int8Array(n * n), lb: new Int8Array(n * n), nt: new Int8Array(n), nb: new Int8Array(n),\n    rkt: new Int16Array(n * n), rkb: new Int16Array(n * n),\n    nx: new Int8Array(n), hold: new Int8Array(n), hb: new Float64Array(n), rl: 1,\n    ma: new Int8Array(n), mb: new Int8Array(n), props: 0, propsA: 0, propsB: 0, rounds: 0,\n    fx: [],\n    buf: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],\n  };\n}\n\n// Preferences: top person i values bottom person j at\n// A (1 - j / (n - 1)) + (1 - A) u with u uniform, and the bottom the same way,\n// so at A = 1 everyone ranks the other side left to right. Each pair is\n// refused by each side with chance c.\nfunction newPrefs(S) {\n  const A = S.agree, c = 0.75 * S.choosy, u = new Float64Array(n), idx = [];\n  for (let side = 0; side \u003c 2; side++) {\n    const L = side ? S.lb : S.lt, R = side ? S.rkb : S.rkt, len = side ? S.nb : S.nt;\n    for (let i = 0; i \u003c n; i++) {\n      idx.length = 0;\n      for (let j = 0; j \u003c n; j++) {\n        u[j] = A * (1 - j / (n - 1)) + (1 - A) * Math.random();\n        R[i * n + j] = NO;\n        if (Math.random() >= c) idx.push(j);\n      }\n      idx.sort((a, b) => u[b] - u[a]);\n      len[i] = idx.length;\n      for (let k = 0; k \u003c idx.length; k++) {\n        L[i * n + k] = idx[k];\n        R[i * n + idx[k]] = k + 1;\n      }\n    }\n  }\n}\n\n// Ranks seen from each end of the pair (top a, bottom b).\nconst rankTop = (S, a, b) => S.rkt[a * n + b];\nconst rankBot = (S, a, b) => S.rkb[b * n + a];\n\nfunction startRun(S, side) {\n  S.side = side;\n  S.nx.fill(0);\n  S.hold.fill(-1);\n  S.props = 0;\n  S.rounds = 0;\n  S.rt = S.t - 1;\n  S.rl = 1;\n  S.decided = true;\n  S.fx = S.fx.filter((e) => e.k >= 2);\n}\n\n// The proposals of one round leave together: every free proposer with\n// someone left on the list sends one. Returns how many left.\nfunction sendRound(S) {\n  const side = S.side, L = side ? S.lb : S.lt, len = side ? S.nb : S.nt, held = new Uint8Array(n);\n  for (let r = 0; r \u003c n; r++) if (S.hold[r] >= 0) held[S.hold[r]] = 1;\n  let sent = 0;\n  for (let p = 0; p \u003c n; p++) {\n    if (held[p] || S.nx[p] >= len[p]) continue;\n    const r = L[p * n + S.nx[p]++];\n    S.fx.push({ k: side, a: side ? r : p, b: side ? p : r, t0: S.t });\n    sent++;\n  }\n  S.props += sent;\n  if (sent) S.rounds++;\n  return sent;\n}\n\n// The receivers answer: each keeps the best of what it holds and what just\n// arrived, among those it will take, and turns the rest away.\nfunction decide(S) {\n  const side = S.side, fly = [], keep = [];\n  for (const e of S.fx) (e.k === side ? fly : keep).push(e);\n  const best = new Int8Array(n).fill(-1), bestRank = new Int16Array(n).fill(NO);\n  for (let r = 0; r \u003c n; r++) {\n    const h = S.hold[r];\n    if (h >= 0) {\n      best[r] = h;\n      bestRank[r] = side ? rankTop(S, r, h) : rankBot(S, h, r);\n    }\n  }\n  for (const e of fly) {\n    const p = side ? e.b : e.a, r = side ? e.a : e.b, rk = side ? rankTop(S, r, p) : rankBot(S, p, r);\n    if (rk \u003c bestRank[r]) (best[r] = p), (bestRank[r] = rk);\n  }\n  for (const e of fly) {\n    const p = side ? e.b : e.a, r = side ? e.a : e.b;\n    if (best[r] === p && S.hold[r] !== p) continue;\n    keep.push({ k: 2, a: e.a, b: e.b, t0: S.t });\n  }\n  for (let r = 0; r \u003c n; r++)\n    if (best[r] !== S.hold[r]) {\n      const o = S.hold[r];\n      if (o >= 0) keep.push({ k: 3, a: side ? r : o, b: side ? o : r, t0: S.t });\n      S.hold[r] = best[r];\n      S.hb[r] = S.t;\n    }\n  S.fx = keep;\n}\n\n// The run's matching as top person to bottom person, -1 for single.\nfunction matching(S, m) {\n  m.fill(-1);\n  for (let r = 0; r \u003c n; r++) {\n    const p = S.hold[r];\n    if (p >= 0) S.side ? (m[r] = p) : (m[p] = r);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const ag = cl(k[2], 0, 1), ch = cl(k[3], 0, 1);\n  if (abs(ag - S.agree) > 0.02 || abs(ch - S.choosy) > 0.02) {\n    // New lists from the start whenever Agreement or Choosy moves.\n    S.agree = ag;\n    S.choosy = ch;\n    newPrefs(S);\n    S.fx = [];\n    S.phase = RUN_A;\n    S.pt = S.t;\n    startRun(S, 0);\n  }\n  S.t += d * S.speed;\n  const T = S.t, el = T - S.pt;\n  if (S.phase === RUN_A || S.phase === RUN_B) {\n    if (!S.decided && T - S.rt >= FLY * S.rl) {\n      decide(S);\n      S.decided = true;\n    }\n    if (S.decided && T - S.rt >= S.rl - 1e-9) {\n      S.rt = T;\n      const sent = sendRound(S);\n      // A round of one proposal, the chains of rejections that end a run,\n      // takes 0.35 of the time of a round of eight or more.\n      S.rl = 0.35 + 0.65 * min(1, (sent - 1) / 7);\n      for (const e of S.fx) if (e.k \u003c 2 && e.t0 === T) e.fl = FLY * S.rl;\n      if (sent) S.decided = false;\n      else {\n        // Nobody free has anyone left to ask: the matching is stable.\n        if (S.phase === RUN_A) matching(S, S.ma), (S.propsA = S.props), (S.phase = HOLD_A);\n        else matching(S, S.mb), (S.propsB = S.props), (S.phase = HOLD_B);\n        S.pt = T;\n      }\n    }\n  } else if (S.phase === HOLD_A && el >= T_HOLD_A) {\n    S.phase = RUN_B;\n    S.pt = T;\n    startRun(S, 1);\n  } else if (S.phase === HOLD_B && el >= T_HOLD_B) {\n    S.phase = COMPARE;\n    S.pt = T;\n  } else if (S.phase === COMPARE && el >= T_CMP) {\n    S.phase = FADE;\n    S.pt = T;\n  } else if (S.phase === FADE && el >= T_FADE) {\n    newPrefs(S);\n    S.fx = [];\n    S.phase = RUN_A;\n    S.pt = T;\n    startRun(S, 0);\n  }\n  S.fx = S.fx.filter((e) => e.k \u003c 2 || T - e.t0 \u003c T_GONE);\n}\n\n// Rank to colour: green for a first choice through blue to pink for a last.\nfunction rankCol(S, rank, o) {\n  const q = rank >= NO ? 1 : (rank - 1) / (n - 1);\n  return hsv(0.3 + S.hue + 0.6 * sqrt(q), 0.85, 1, o);\n}\n\n// Where lines cross, each channel keeps the brighter of the two.\nfunction add(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W) return;\n  const o = (y * W + x) * 3;\n  buf[o] = max(buf[o], r);\n  buf[o + 1] = max(buf[o + 1], g);\n  buf[o + 2] = max(buf[o + 2], b);\n}\n\n// The line from top person a to bottom person b over rows ya..yb, its\n// colour running from ca at the top end to cb at the bottom, times v. Each\n// row lights the LEDs within LW / 2 of the line, the edge ones in part.\nconst LW = 1.5;\nfunction line(buf, a, b, ya, yb, ca, cb, v, white) {\n  const xa = XP(a), xb = XP(b), y0 = max(Y0, Math.ceil(ya)), y1 = min(Y1, floor(yb));\n  for (let y = y0; y \u003c= y1; y++) {\n    const f = (y - Y0) / (Y1 - Y0), x = xa + (xb - xa) * f;\n    const r = ((ca[0] + (cb[0] - ca[0]) * f) * (1 - white) + 255 * white) * v, g = ((ca[1] + (cb[1] - ca[1]) * f) * (1 - white) + 255 * white) * v, bl = ((ca[2] + (cb[2] - ca[2]) * f) * (1 - white) + 255 * white) * v;\n    for (let xi = floor(x - LW / 2); xi \u003c= x + LW / 2; xi++) {\n      const k = cl(LW / 2 + 0.5 - abs(xi - x), 0, 1);\n      if (k > 0) add(buf, xi, y, r * k, g * k, bl * k);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, c = S.c, c2 = S.c2, T = S.t, el = T - S.pt, ph = S.phase;\n  buf.fill(0);\n  const fade = ph === FADE ? max(0, 1 - el / T_FADE) : 1;\n  const pair = (a, b, v, white) => {\n    rankCol(S, rankTop(S, a, b), c);\n    rankCol(S, rankBot(S, a, b), c2);\n    line(buf, a, b, Y0, Y1, c, c2, v, white);\n  };\n  // The first stable matching stays as dim ghosts while the bottom proposes.\n  if (ph === RUN_B || ph === HOLD_B) for (let a = 0; a \u003c n; a++) if (S.ma[a] >= 0) pair(a, S.ma[a], 0.25, 0.3);\n  if (ph \u003c= HOLD_B) {\n    // Held proposals; one just taken glows white for half a round.\n    for (let r = 0; r \u003c n; r++) {\n      const p = S.hold[r];\n      if (p \u003c 0) continue;\n      const a = S.side ? r : p, b = S.side ? p : r, g = max(0, 1 - (T - S.hb[r]) * 2);\n      pair(a, b, 0.85 + 0.15 * g, 0.5 * g);\n    }\n  } else {\n    // Compare: pairs in both matchings stay; the others swap between the\n    // top's best matching and the bottom's best, a full swing in 4 rounds.\n    const w = 0.5 + 0.5 * cos((PI * el) / 2);\n    for (let a = 0; a \u003c n; a++) {\n      const x = S.ma[a], y = S.mb[a];\n      if (x >= 0 && x === y) pair(a, x, 0.45 * fade, 0);\n      else {\n        if (x >= 0) pair(a, x, w * fade, 0.25 * w);\n        if (y >= 0) pair(a, y, (1 - w) * fade, 0.25 * (1 - w));\n      }\n    }\n  }\n  for (const e of S.fx) {\n    const age = T - e.t0;\n    if (e.k \u003c 2) {\n      // In flight: the proposer's end coloured by the rank it gives, a white\n      // head running across the panel.\n      const fr = min(1, age / e.fl), down = e.k === 0;\n      rankCol(S, down ? rankTop(S, e.a, e.b) : rankBot(S, e.a, e.b), c);\n      const yh = down ? Y0 + (Y1 - Y0) * fr : Y1 - (Y1 - Y0) * fr;\n      line(buf, e.a, e.b, down ? Y0 : yh, down ? yh : Y1, c, c, 0.55, 0.15);\n      line(buf, e.a, e.b, yh - 3, yh + 3, c, c, 0.9, 0.8);\n    } else if (e.k === 2) {\n      // Turned away: a flash that fades.\n      const q = 1 - age / T_GONE;\n      rankCol(S, rankTop(S, e.a, e.b), c);\n      rankCol(S, rankBot(S, e.a, e.b), c2);\n      line(buf, e.a, e.b, Y0, Y1, c, c2, 0.8 * q * q, 0.6 * q);\n    } else {\n      // Snapped: the line breaks at its middle and each half pulls back to\n      // its own person.\n      const q = age / T_GONE, mid = (Y0 + Y1) / 2, l = (mid - Y0) * (1 - q);\n      rankCol(S, rankTop(S, e.a, e.b), c);\n      rankCol(S, rankBot(S, e.a, e.b), c2);\n      line(buf, e.a, e.b, Y0, Y0 + l - 1, c, c2, 0.9 * (1 - q), 0.3);\n      line(buf, e.a, e.b, Y1 - l + 1, Y1, c, c2, 0.9 * (1 - q), 0.3);\n    }\n  }\n  // People: a tile of three by three LEDs at each end, in the colour of the\n  // rank of what they hold now, dim grey while single.\n  const mt = new Int8Array(n).fill(-1), mbm = new Int8Array(n).fill(-1);\n  if (ph \u003c= HOLD_B) {\n    for (let r = 0; r \u003c n; r++) {\n      const p = S.hold[r];\n      if (p \u003c 0) continue;\n      S.side ? ((mt[r] = p), (mbm[p] = r)) : ((mt[p] = r), (mbm[r] = p));\n    }\n  } else {\n    const m = ph === COMPARE && cos((PI * el) / 2) \u003c 0 ? S.mb : S.ma;\n    for (let a = 0; a \u003c n; a++) if (m[a] >= 0) (mt[a] = m[a]), (mbm[m[a]] = a);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    for (const top of [1, 0]) {\n      const o = top ? mt[i] : mbm[i];\n      if (o >= 0) rankCol(S, top ? rankTop(S, i, o) : rankBot(S, o, i), c);\n      else c[0] = c[1] = c[2] = 60;\n      const y0 = top ? 0 : H - 3;\n      for (let y = y0; y \u003c y0 + 3; y++) for (let x = XP(i) - 1; x \u003c= XP(i) + 1; x++) add(buf, x, y, c[0] * fade, c[1] * fade, c[2] * fade);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) | 0, min(255, buf[o + 1]) | 0, min(255, buf[o + 2]) | 0);\n}\n","stit-tessellation":"// ===== Patternflow pattern =====\n// Title:   STIT Tessellation\n// Family:  cells\n// Idea:    The panel starts as one cell, and as in Nagel and Weiss's STIT process every cell waits an exponential time at a rate of its perimeter over pi before a random line among those that hit it cuts it in two, so each new segment flashes white and ends on older ones in T junctions, never crossing them; once the cells reach their density the view dives toward a slowly wandering point while the cutting runs on for just the time that restores the same law, since the tessellation at time t scaled by t is the one at time 1, and cells that leave the panel are dropped.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: STIT tessellations (Werner Nagel and Viola Weiss, 2005)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Axes=0..1, Cells=0..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. A cut gives its two halves the parent's colour stepped 0.05 to 0.1 round the wheel in opposite directions, one lighter and one darker, kept within 0.34 of the centre, so the oldest lines part families of colour. At 0 the centre is blue and the cells run from lime through cyan and violet to rose; at 0.5 the centre is orange.\n// Knob 2: Speed. At 2 the first cells reach their density in 1.5 s; then the view closes in by e^0.24 a second, twice as close every 2.9 s, and about 18 cuts land a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Axes. The share of the cutting lines that run along the two axes instead of in a uniform direction. At 0 the isotropic STIT; at 1 every line is horizontal or vertical and the cells are rectangles, the Mondrian process (Daniel Roy and Yee Whye Teh, 2008). Between the two a mix, still a STIT.\n// Knob 4: Cells. The scale of the dive, which keeps the panel looking at the process at time 1/kappa in LED units, 1 + 384/(pi kappa) + 8192/(pi kappa^2) cells on average: 42 at 0, 46 at the opening, 89 at 0.5, 194 at 1.\n// Buttons: K1 tap starts over from one cell: the dive pauses while the STIT grows again from time zero.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Edge times: the panel's border is never drawn.\nconst BORDER = -1e9;\n\n// A cell is a convex polygon in LED units: corners x, y and for each edge,\n// from corner i to i + 1, the time it was cut. clk is the exponential mass\n// left on its clock; hv and lv its colour.\nfunction props(c) {\n  const x = c.x, y = c.y, n = x.length;\n  let a = 0, p = 0, x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c n; i++) {\n    const j = i + 1 === n ? 0 : i + 1;\n    a += x[i] * y[j] - x[j] * y[i];\n    p += sqrt((x[j] - x[i]) ** 2 + (y[j] - y[i]) ** 2);\n    if (x[i] \u003c x0) x0 = x[i];\n    if (x[i] > x1) x1 = x[i];\n    if (y[i] \u003c y0) y0 = y[i];\n    if (y[i] > y1) y1 = y[i];\n  }\n  c.area = abs(a) / 2;\n  c.per = p;\n  c.x0 = x0;\n  c.x1 = x1;\n  c.y0 = y0;\n  c.y1 = y1;\n  return c;\n}\n\nconst windowCell = () => props({ x: [0, W, W, 0], y: [0, 0, H, H], t: [BORDER, BORDER, BORDER, BORDER], clk: 0, hv: 0, lv: 0 });\n\n// The part of cell c where nx x + ny y \u003c= p, or null. The cut edge carries\n// time tc; edges cut short keep their own.\nfunction half(c, nx, ny, p, tc) {\n  const x = c.x, y = c.y, t = c.t, n = x.length, ox = [], oy = [], ot = [];\n  for (let i = 0; i \u003c n; i++) {\n    const j = i + 1 === n ? 0 : i + 1;\n    const si = nx * x[i] + ny * y[i] - p, sj = nx * x[j] + ny * y[j] - p;\n    if (si \u003c= 0) {\n      ox.push(x[i]);\n      oy.push(y[i]);\n      ot.push(t[i]);\n    }\n    if ((si \u003c 0 && sj > 0) || (si > 0 && sj \u003c 0)) {\n      const f = si / (si - sj);\n      ox.push(x[i] + f * (x[j] - x[i]));\n      oy.push(y[i] + f * (y[j] - y[i]));\n      ot.push(si \u003c 0 ? tc : t[i]);\n    }\n  }\n  if (ox.length \u003c 3) return null;\n  const o = props({ x: ox, y: oy, t: ot, clk: c.clk, hv: c.hv, lv: c.lv });\n  return o.area > 1e-6 ? o : null;\n}\n\n// The rate at which a cell is cut, the measure of the lines that hit it:\n// lines in a uniform direction with weight 1 - m give perimeter / pi by\n// Cauchy's formula, lines along the two axes with weight m give half the\n// width plus half the height.\nconst rate = (c, m) => ((1 - m) * c.per) / PI + (m * (c.x1 - c.x0 + c.y1 - c.y0)) / 2;\n\n// A line from that measure among the lines that hit c, as nx x + ny y = p.\nfunction cutLine(c, m, L) {\n  const bw = c.x1 - c.x0, bh = c.y1 - c.y0;\n  if (Math.random() * rate(c, m) \u003c (m * (bw + bh)) / 2) {\n    if (Math.random() * (bw + bh) \u003c bw) (L[0] = 1), (L[1] = 0), (L[2] = c.x0 + Math.random() * bw);\n    else (L[0] = 0), (L[1] = 1), (L[2] = c.y0 + Math.random() * bh);\n    return;\n  }\n  // Uniform direction, uniform offset across the cell's bounding circle,\n  // kept when the line meets the cell.\n  const cx = (c.x0 + c.x1) / 2, cy = (c.y0 + c.y1) / 2, r = sqrt(bw * bw + bh * bh) / 2;\n  for (;;) {\n    const th = Math.random() * PI, nx = cos(th), ny = sin(th), p = nx * cx + ny * cy + (2 * Math.random() - 1) * r;\n    let lo = 1e9, hi = -1e9;\n    for (let i = 0; i \u003c c.x.length; i++) {\n      const s = nx * c.x[i] + ny * c.y[i];\n      if (s \u003c lo) lo = s;\n      if (s > hi) hi = s;\n    }\n    if (p > lo && p \u003c hi) {\n      L[0] = nx;\n      L[1] = ny;\n      L[2] = p;\n      return;\n    }\n  }\n}\n\nconst clock = () => -log(1 - Math.random());\n// Folds v back into -r..r.\nconst refl = (v, r) => (v > r ? 2 * r - v : v \u003c -r ? -2 * r - v : v);\n\nfunction split(S, k, tc) {\n  const c = S.cells[k], L = S.L;\n  cutLine(c, S.m, L);\n  const a = half(c, L[0], L[1], L[2], tc), b = half(c, -L[0], -L[1], -L[2], tc);\n  if (!a || !b) return;\n  a.clk = clock();\n  b.clk = clock();\n  // The two halves take their parent's colour, one a step one way round\n  // the wheel and lighter or darker, the other the opposite step.\n  const dh = (Math.random() \u003c 0.5 ? 1 : -1) * (0.05 + 0.05 * Math.random()), dl = Math.random() \u003c 0.5 ? 0.1 : -0.1;\n  a.hv = refl(c.hv + dh, 0.34);\n  b.hv = refl(c.hv - dh, 0.34);\n  a.lv = refl(c.lv + dl, 0.2);\n  b.lv = refl(c.lv - dl, 0.2);\n  S.cells[k] = a;\n  S.cells.push(b);\n  S.splits++;\n}\n\nexport function setup(params) {\n  params.s = { time: 0, hue: 0, m: 0, kap: 9, T: 0, cells: [windowCell()], splits: 0, L: [0, 0, 0], c: [0, 0, 0], zx: W / 2, zy: H / 2, ph: 0, seen: new Uint8Array(W * H) };\n  params.s.cells[0].clk = clock();\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.m = cl(k[2], 0, 1);\n  S.kap = 9.6 * 0.4167 ** cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.cells = [windowCell()];\n    S.cells[0].clk = clock();\n    S.T = 0;\n  }\n  const tau = d * cl(k[1], 0.2, 3);\n  S.time += d;\n  S.ph += tau;\n  // In LED units the panel shows the process at time 1/kappa. From one\n  // cell it first runs up to that time, in 1.5 s at Speed 2. Then the dive:\n  // the view closes in by z on a point that wanders slowly, and the process\n  // runs on for the time that brings it back to the same law, because Y(t)\n  // scaled by t has the law of Y(1). STIT's restriction to a window is a\n  // STIT in that window, so the cells can be clipped to the panel and the\n  // ones that leave it dropped.\n  let z = 1, dlt;\n  if (S.T \u003c 1 / S.kap) {\n    dlt = min(1 / S.kap - S.T, tau / (3 * S.kap));\n    S.T += dlt;\n  } else {\n    z = exp(0.12 * tau);\n    dlt = (1 - 1 / z) / S.kap;\n  }\n  S.zx = W / 2 + 14 * sin(0.21 * S.ph);\n  S.zy = H / 2 + 34 * sin(0.13 * S.ph + 1);\n  const cells = S.cells, out = [];\n  for (let i = 0; i \u003c cells.length; i++) {\n    let c = cells[i];\n    if (z !== 1) {\n      for (let v = 0; v \u003c c.x.length; v++) {\n        c.x[v] = S.zx + z * (c.x[v] - S.zx);\n        c.y[v] = S.zy + z * (c.y[v] - S.zy);\n      }\n      props(c);\n      if (c.x1 \u003c= 0 || c.x0 >= W || c.y1 \u003c= 0 || c.y0 >= H) continue;\n      if (c.x0 \u003c 0) c = half(c, -1, 0, 0, BORDER);\n      if (c && c.x1 > W) c = half(c, 1, 0, W, BORDER);\n      if (c && c.y0 \u003c 0) c = half(c, 0, -1, 0, BORDER);\n      if (c && c.y1 > H) c = half(c, 0, 1, H, BORDER);\n    }\n    if (c) out.push(c);\n  }\n  S.cells = out;\n  // Each cell's clock runs at its rate; when it runs out the cell is cut.\n  const n = out.length;\n  for (let i = 0; i \u003c n; i++) {\n    const c = out[i];\n    c.clk -= rate(c, S.m) * dlt;\n    if (c.clk \u003c= 0) split(S, i, S.time);\n  }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const seen = S.seen, c = S.c, now = S.time, ex = [], ey = [], ed = [], et = [];\n  seen.fill(0);\n  for (const cell of S.cells) {\n    hsv(S.hue + 0.62 + cell.hv, 0.7, 0.78 + cell.lv, c);\n    const r = c[0], g = c[1], b = c[2];\n    // The drawn edges: unit normal, offset and the time of the cut.\n    const x = cell.x, y = cell.y, t = cell.t, n = x.length;\n    ex.length = ey.length = ed.length = et.length = 0;\n    for (let i = 0; i \u003c n; i++) {\n      if (t[i] === BORDER) continue;\n      const j = i + 1 === n ? 0 : i + 1, dx = x[j] - x[i], dy = y[j] - y[i], l = sqrt(dx * dx + dy * dy) || 1;\n      ex.push(-dy / l);\n      ey.push(dx / l);\n      ed.push((-dy * x[i] + dx * y[i]) / l);\n      et.push(t[i]);\n    }\n    // Fill the LEDs whose centres the cell holds, row by row, with a dark\n    // line where a centre lies within 0.62 LED of an edge, flashing white\n    // for half a second after the cut.\n    const j0 = max(0, Math.ceil(cell.y0 - 0.5)), j1 = min(H - 1, floor(cell.y1 - 0.5));\n    for (let row = j0; row \u003c= j1; row++) {\n      const yc = row + 0.5;\n      let xl = 1e9, xr = -1e9;\n      for (let i = 0; i \u003c n; i++) {\n        const j = i + 1 === n ? 0 : i + 1;\n        if ((y[i] - yc) * (y[j] - yc) > 0 || y[i] === y[j]) continue;\n        const xx = x[i] + ((yc - y[i]) / (y[j] - y[i])) * (x[j] - x[i]);\n        if (xx \u003c xl) xl = xx;\n        if (xx > xr) xr = xx;\n      }\n      const i0 = max(0, Math.ceil(xl - 0.5)), i1 = min(W - 1, Math.ceil(xr - 0.5) - 1);\n      for (let col = i0; col \u003c= i1; col++) {\n        const p = row * W + col;\n        if (seen[p]) continue;\n        seen[p] = 1;\n        const xc = col + 0.5;\n        let dm = 9, tm = BORDER;\n        for (let e = 0; e \u003c ex.length; e++) {\n          const dd = abs(ex[e] * xc + ey[e] * yc - ed[e]);\n          if (dd \u003c dm) (dm = dd), (tm = et[e]);\n        }\n        const w = cl((0.62 - dm) / 0.3, 0, 1), f = exp(-(now - tm) / 0.5) * 255;\n        display.setPixel(col, row, (r + w * (f - r)) | 0, (g + w * (f - g)) | 0, (b + w * (f - b)) | 0);\n      }\n    }\n  }\n  for (let p = 0; p \u003c W * H; p++) if (!seen[p]) display.setPixel(p % W, (p / W) | 0, 0, 0, 0);\n}\n","stormer-trap":"// ===== Patternflow pattern =====\n// Title:   Størmer Trap\n// Family:  particle\n// Idea:    Charged particles in the field of a magnetic dipole lying across the panel are integrated in three dimensions: each one spirals along a faint field-line loop that stands up to the top or the bottom of the panel and turns back at a mirror point near the centre, while the whole belt drifts slowly round the dipole's axis, positive charges one way and negative ones the other; the few inside the loss cone reach the small sphere at the centre and flash where they land.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Størmer's problem, charged particles in a dipole field (Carl Størmer, 1907)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Energy=0..1, Pitch=0..90\n//\n// Knob 1: Hue. Turns both charges round the colour wheel together. At 0 the positive charges are gold and the negative ones sky blue, at 0.5 blue and orange; the field lines stay a faint violet.\n// Knob 2: Speed. At 2 a particle covers 100 LEDs a second and one on an outer shell goes from one mirror point to the other and back in two to three seconds, while the belt takes about 100 s to drift once round. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Energy. The particles' momentum against the field, given as the outermost shell's distance from the centre in Størmer lengths, from 0.19 at 0 to 1 at 1. At 0 a gyration at the top of an outer loop is 4.5 LEDs across and the magnetic moment holds to a fifth of a percent. Størmer showed that a particle on the equator nearer than sqrt(2) - 1 = 0.414 of his length can never leave, whatever its direction, and the outermost shell passes that at 0.47. Around 0.5 the gyrations swell to 24 LEDs and the moment breaks; past it the orbits begin to leave the panel, two a second at 0.75 and at 1 nearly all of them within a second or two.\n// Knob 4: Pitch. The smallest angle, in degrees, between a particle's velocity and the field where it crosses the equator; each particle starts between it and 60% of the way to 90. At 0 most dive deep toward the sphere, and the few inside the loss cone (1.9 degrees on the outermost shell, 4.9 on the innermost) land on it within one bounce. At 90 they all stay on the equator, a tall thin ellipse in the tilted view, and only gyrate and drift.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// NP particles on shells LMIN to LMAX LEDs from the centre at the equator,\n// round a sphere of radius RS. RATE is the simulated time per second at\n// Speed 1; a particle moves one LED per unit of it.\nconst NP = 48, RS = 8, LMIN = 34, LMAX = 62, RATE = 50;\n// The view is turned TILT radians about the vertical, so a ring round the\n// dipole's axis shows as a narrow ellipse instead of a line.\nconst TILT = 0.21, CT = cos(TILT), ST = sin(TILT);\n// Largest gyration angle and largest distance one Boris step may take.\nconst DPHI = 0.3, DMAX = 0.5;\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The dipole points along +x, across the panel; y is up and z comes out of\n// the panel toward the viewer. B = k (3 x r / r^5 - x_hat / r^3), with k the\n// dipole moment times the charge-to-mass ratio, so that a charge s = +1 or -1\n// feels dv/dt = s v x B.\nfunction field(x, y, z, k, o) {\n  const r2 = x * x + y * y + z * z, i3 = k / (r2 * sqrt(r2)), f = (3 * x) / r2;\n  o[0] = i3 * (f * x - 1);\n  o[1] = i3 * f * y;\n  o[2] = i3 * f * z;\n}\n\n// The latitude where a particle of equatorial pitch angle a mirrors: there\n// the field is 1 / sin^2(a) times its equatorial value, and along a dipole\n// field line B / B_eq = sqrt(1 + 3 sin^2 l) / cos^6 l.\nfunction mirrorLat(s2) {\n  let lo = 0, hi = PI / 2 - 1e-6;\n  for (let i = 0; i \u003c 40; i++) {\n    const m = (lo + hi) / 2, c = cos(m), sn = sin(m), g = (c * c * c * c * c * c) / sqrt(1 + 3 * sn * sn);\n    if (g > s2) lo = m;\n    else hi = m;\n  }\n  return lo;\n}\n\n// Equatorial distance from the centre in Størmer lengths for the outermost\n// shell, from the Energy knob. The Størmer length is sqrt(k / v) with v = 1.\nconst sOf = (u) => 0.19 * (1 / 0.19) ** u;\n\nexport function setup(params) {\n  const F = (n) => new Float64Array(n);\n  const S = (params.s = {\n    hue: 0, speed: 2, en: 0, pitch: 0, k: 1, cst: 1,\n    x: F(NP), y: F(NP), z: F(NP), vx: F(NP), vy: F(NP), vz: F(NP), sg: new Int8Array(NP), tc: F(NP), rh: F(NP), L: F(NP), a: F(NP), want: new Uint8Array(NP),\n    tp: new Float32Array(N), tn: new Float32Array(N), fx: new Float32Array(N), fl: new Float32Array(N), b: F(3), c: [0, 0, 0], d: [0, 0, 0],\n    lost: 0, esc: 0, started: false,\n  });\n  // The faint field lines in the plane of the panel: x = L cos^2 l sin l and\n  // y = +-L cos^3 l, from the sphere on one side round to the sphere on the\n  // other, for six shells.\n  for (const L of [16, 26, 36, 46, 56, 66]) {\n    const lh = Math.acos(sqrt(RS / L));\n    for (let t = -lh; t \u003c= lh; t += 0.002) {\n      const c = cos(t), x = CT * L * c * c * sin(t), y = L * c * c * c;\n      splat(S.fl, CX + x, CY - y, 1);\n      splat(S.fl, CX + x, CY + y, 1);\n    }\n  }\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) m = max(m, S.fl[i]);\n  for (let i = 0; i \u003c N; i++) S.fl[i] = min(1, S.fl[i] / (0.55 * m));\n}\n\nfunction splat(A, px, py, w) {\n  const x0 = floor(px), y0 = floor(py), fx = px - x0, fy = py - y0;\n  if (x0 >= 0 && x0 \u003c W && y0 >= 0 && y0 \u003c H) A[y0 * W + x0] += w * (1 - fx) * (1 - fy);\n  if (x0 + 1 >= 0 && x0 + 1 \u003c W && y0 >= 0 && y0 \u003c H) A[y0 * W + x0 + 1] += w * fx * (1 - fy);\n  if (x0 >= 0 && x0 \u003c W && y0 + 1 >= 0 && y0 + 1 \u003c H) A[(y0 + 1) * W + x0] += w * (1 - fx) * fy;\n  if (x0 + 1 >= 0 && x0 + 1 \u003c W && y0 + 1 >= 0 && y0 + 1 \u003c H) A[(y0 + 1) * W + x0 + 1] += w * fx * fy;\n}\n\n// Puts particle i on a shell L at a random point of its bounce: its guiding\n// centre goes on the field line at a latitude inside its mirror latitude,\n// with the pitch angle there that keeps the magnetic moment\n// sin^2(a) / B the same as at the equator, then the particle is set off by\n// its gyration radius in a random gyration phase.\nfunction inject(S, i) {\n  const R = Math.random;\n  const sg = i & 1 ? -1 : 1, L = LMIN + (LMAX - LMIN) * R();\n  const a = ((S.pitch + 0.6 * (90 - S.pitch) * R()) * PI) / 180, s2 = sin(a) ** 2;\n  // A guiding centre whose mirror point lies inside the sphere starts above\n  // the sphere: it is in the loss cone and will land on its way down.\n  const lm = min(mirrorLat(s2), 0.97 * Math.acos(sqrt(RS / L))), l0 = lm * sin(2 * PI * R());\n  const c = cos(l0), r = L * c * c, ph = 2 * PI * R(), rho = r * c;\n  const gx = r * sin(l0), gy = rho * cos(ph), gz = rho * sin(ph);\n  const b = S.b;\n  field(gx, gy, gz, S.k, b);\n  const bm = sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]), hx = b[0] / bm, hy = b[1] / bm, hz = b[2] / bm;\n  const sl = min(1, (s2 * bm * L * L * L) / S.k), vp = sqrt(sl), va = sqrt(1 - sl) * (R() \u003c 0.5 ? -1 : 1);\n  // Two unit vectors across the field line.\n  let ex = -hy, ey = hx, ez = 0, n = sqrt(ex * ex + ey * ey);\n  if (n \u003c 1e-6) (ex = 0), (ey = -hz), (ez = hy), (n = sqrt(ey * ey + ez * ez));\n  ex /= n;\n  ey /= n;\n  ez /= n;\n  const fx = hy * ez - hz * ey, fy = hz * ex - hx * ez, fz = hx * ey - hy * ex, ps = 2 * PI * R(), cp = cos(ps), sp = sin(ps);\n  const ux = vp * (cp * ex + sp * fx), uy = vp * (cp * ey + sp * fy), uz = vp * (cp * ez + sp * fz);\n  S.vx[i] = va * hx + ux;\n  S.vy[i] = va * hy + uy;\n  S.vz[i] = va * hz + uz;\n  // The gyration radius vector is s (b_hat x v_perp) / B.\n  S.x[i] = gx + (sg * (hy * uz - hz * uy)) / bm;\n  S.y[i] = gy + (sg * (hz * ux - hx * uz)) / bm;\n  S.z[i] = gz + (sg * (hx * uy - hy * ux)) / bm;\n  S.sg[i] = sg;\n  S.L[i] = L;\n  S.a[i] = a;\n  S.want[i] = 0;\n  S.tc[i] = 0;\n  field(S.x[i], S.y[i], S.z[i], S.k, b);\n  S.rh[i] = max(sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]) / DPHI, 1 / DMAX);\n}\n\n// Advances particle i by T of simulated time with the Boris pusher, which\n// turns the velocity about the local field by exactly the angle the field\n// gives and so keeps the speed fixed to rounding. Steps are short enough for\n// about 0.3 rad of gyration and half an LED of travel. A step length read\n// straight off the field would break the pusher's symmetry in time, and the\n// magnetic moment then drifted by a quarter in 20 s; so the step density\n// follows Hairer and Söderlind's reversible rule, the mean of the densities\n// either side of a position equal to the one the field there asks for. The\n// time a particle runs past its frame is taken off its next one. Every step\n// leaves its light on the panel, weighted by the time it took and by depth.\nfunction push(S, i, T) {\n  const b = S.b, k = S.k, sg = S.sg[i], A = sg > 0 ? S.tp : S.tn, esc = max(1.6 * LMAX, S.cst);\n  let x = S.x[i], y = S.y[i], z = S.z[i], vx = S.vx[i], vy = S.vy[i], vz = S.vz[i], rh = S.rh[i], n = 0;\n  T += S.tc[i];\n  while (T > 0 && n++ \u003c 6000) {\n    field(x, y, z, k, b);\n    const bm = sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]), g = max(bm / DPHI, 1 / DMAX);\n    let rn = 2 * g - rh;\n    if (rn \u003c 0.5 * g) rn = g;\n    const h = 1 / rn, hm = 0.5 * (h + 1 / rh);\n    rh = rn;\n    const tx = 0.5 * sg * hm * b[0], ty = 0.5 * sg * hm * b[1], tz = 0.5 * sg * hm * b[2], q = 2 / (1 + tx * tx + ty * ty + tz * tz);\n    const wx = vx + vy * tz - vz * ty, wy = vy + vz * tx - vx * tz, wz = vz + vx * ty - vy * tx;\n    vx += q * (wy * tz - wz * ty);\n    vy += q * (wz * tx - wx * tz);\n    vz += q * (wx * ty - wy * tx);\n    x += vx * h;\n    y += vy * h;\n    z += vz * h;\n    T -= h;\n    const r2 = x * x + y * y + z * z;\n    const u = CT * x - ST * z, dz = ST * x + CT * z;\n    if (r2 \u003c RS * RS) {\n      // Into the sphere: a flash where it lands (dimmer on the far side),\n      // then a new particle.\n      const fw = dz > -2 ? 1 : 0.4;\n      splat(S.fx, CX + u, CY - y, 4 * fw);\n      for (let j = 0; j \u003c 4; j++) splat(S.fx, CX + u + (j \u003c 2 ? 2 * j - 1 : 0), CY - y + (j \u003c 2 ? 0 : 2 * j - 5), 1.5 * fw);\n      S.lost++;\n      inject(S, i);\n      return;\n    }\n    // Past the Størmer length, or past 1.6 times the outermost shell if that\n    // is further, the particle has left the trap; a new one takes its place.\n    if (r2 > esc * esc) {\n      S.esc++;\n      inject(S, i);\n      return;\n    }\n    if (dz \u003c 0 && u * u + y * y \u003c RS * RS) continue;\n    splat(A, CX + u, CY - y, h * (0.45 + 0.55 * cl(0.5 + dz / (1.6 * LMAX), 0, 1)));\n  }\n  S.tc[i] = min(T, 0);\n  S.rh[i] = rh;\n  S.x[i] = x;\n  S.y[i] = y;\n  S.z[i] = z;\n  S.vx[i] = vx;\n  S.vy[i] = vy;\n  S.vz[i] = vz;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const en = cl(kv[2], 0, 1), pitch = cl(kv[3], 0, 90);\n  // Energy: the field strength k sets the Størmer length sqrt(k) against\n  // which the outermost shell sits at sOf(Energy). Changing it changes every\n  // gyration at once, as a change of energy would.\n  S.en = en;\n  S.cst = LMAX / sOf(en);\n  S.k = S.cst * S.cst;\n  if (!S.started || abs(pitch - S.pitch) > 0.5) {\n    S.pitch = pitch;\n    if (!S.started) for (let i = 0; i \u003c NP; i++) inject(S, i);\n    else S.want.fill(1);\n    S.started = true;\n  }\n  // A new pitch reaches the particles four a frame, each put back on its\n  // shell with the new pitch angle.\n  for (let i = 0, m = 0; i \u003c NP && m \u003c 4; i++) if (S.want[i]) inject(S, i), m++;\n  const T = d * S.speed * RATE, f = exp(-d / 0.32), g = exp(-d / 0.25);\n  const tp = S.tp, tn = S.tn, fx = S.fx;\n  for (let i = 0; i \u003c N; i++) (tp[i] *= f), (tn[i] *= f), (fx[i] *= g);\n  for (let i = 0; i \u003c NP; i++) push(S, i, T);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const c = S.c, e = S.d, cp = hsv(0.13 + S.hue, 0.75, 1, [0, 0, 0]), cn = hsv(0.56 + S.hue, 0.8, 1, [0, 0, 0]);\n  hsv(0.69 + S.hue * 0.3, 0.55, 1, e);\n  const tp = S.tp, tn = S.tn, fx = S.fx, fl = S.fl;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, dx = x - CX, dy = y - CY, r2 = dx * dx + dy * dy;\n      const a = 1 - exp(-0.9 * tp[p]), b = 1 - exp(-0.9 * tn[p]), w = max(0, a + b - 1.1) * 0.6 + 0.9 * (1 - exp(-fx[p]));\n      let r = a * cp[0] + b * cn[0], gg = a * cp[1] + b * cn[1], bb = a * cp[2] + b * cn[2];\n      // Field lines underneath, and the sphere as a dark disc with a dim rim.\n      const fv = r2 \u003c RS * RS ? 0 : 0.16 * fl[p] * (1 - min(1, a + b));\n      const rim = abs(sqrt(r2) - RS + 0.3) \u003c 0.7 ? 0.14 : 0;\n      r += fv * e[0] + rim + w;\n      gg += fv * e[1] + rim + w;\n      bb += fv * e[2] + rim + w;\n      display.setPixel(x, y, min(255, r * 255) | 0, min(255, gg * 255) | 0, min(255, bb * 255) | 0);\n    }\n}\n","strange-eigenmode":"// ===== Patternflow pattern =====\n// Title:   Strange Eigenmode\n// Family:  sim\n// Idea:    A dye on a torus stirred by Pierrehumbert's alternating sine flow, the rows sliding sideways for half a period and the columns sliding up and down for the other half, with a little diffusion, and rescaled every frame so it never fades: the striated picture is the flow's slowest decaying Floquet mode, the strange eigenmode, so it comes back in exactly the same shape every period while its true contrast falls to 39% each time.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: strange eigenmodes (Raymond Pierrehumbert, 1994), in his alternating sine flow\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Stir=-1..1, Diffusion=0..1\n//\n// Knob 1: Hue. The colour of the dye. At 0 the positive half runs from violet where it is faint to pale aqua where it is strongest, and the negative half shows as dim indigo level lines; 0.25 turns it crimson to lilac, 0.5 olive through amber to rose, 0.75 teal through green to pale gold, and 1 is back at violet and aqua.\n// Knob 2: Speed. One period of the flow takes 6 / Speed seconds: 3 s at the opening 2, each half 1.5 s with the slide easing in and out and resting a fifth of a second at either end. At 0.2 a period takes 30 s and at 3 it takes 2 s; Speed only changes how fast the same flow plays.\n// Knob 3: Stir. The amplitude A of both sines in units of the torus, which the panel draws 64 LEDs wide and 128 tall, so a row slides up to 64 A LEDs and a column up to 128 A. At 0, A = 1.2 (77 and 154 LEDs): global chaos, the leading Floquet multiplier 0.39 well ahead of the next, 0.28, so one shape returns every period at 39% of its contrast, a decay rate of 0.95 a period. At -1, A = 0.45: islands of regular flow keep their dye, which leaves only by diffusion, and the pattern fades only 10% a period. At -0.5 (A = 0.82) and +0.5 (A = 1.4) the leading multipliers are a complex pair, 137 and 136 degrees round, and the pattern swings between shapes without repeating. At +1 (A = 1.6) the leading multiplier is negative, -0.41: the pattern returns as its own negative every period, bright where it was dark.\n// Knob 4: Diffusion. The diffusivity, 4 A times 30 to the power of the knob, in LED^2 a period: 5.9 at the opening 0.06, where the stripes are 2.9 LEDs across (rms over rms gradient). At 0.5 it is 26 (6 LEDs). At 1 it is 144 (12 LEDs): a few broad bands are left, and the decay rate rises to 1.6 a period. Any thinner than at 0 and the stripes would be finer than the LEDs.\n// Buttons: K1 tap pours fresh dye, a few random waves, which the flow stirs on screen until, after about a dozen periods, the same mode is back.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// Radix-2 FFT of n points. The forward transform takes its input in\n// bit-reversed order and the inverse leaves its output so, which the loads\n// and stores in shear do for free. Twiddles of the stage with half width h\n// sit at h - 1 .. 2h - 2.\nfunction plan(n) {\n  const bits = Math.round(log(n) / log(2)), rev = new Uint16Array(n), wr = new Float64Array(n), wi = new Float64Array(n);\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c bits; b++) r |= ((i >> b) & 1) \u003c\u003c (bits - 1 - b);\n    rev[i] = r;\n  }\n  for (let h = 1; h \u003c n; h \u003c\u003c= 1) for (let j = 0; j \u003c h; j++) (wr[h - 1 + j] = cos((PI * j) / h)), (wi[h - 1 + j] = -sin((PI * j) / h));\n  return { n, rev, wr, wi, re: new Float64Array(n), im: new Float64Array(n), d: new Float64Array(n) };\n}\nfunction fwd(P) {\n  const n = P.n, re = P.re, im = P.im, wr = P.wr, wi = P.wi;\n  for (let h = 1; h \u003c n; h \u003c\u003c= 1)\n    for (let j = 0, m = h \u003c\u003c 1; j \u003c h; j++) {\n      const cr = wr[h - 1 + j], ci = wi[h - 1 + j];\n      for (let a = j; a \u003c n; a += m) {\n        const b = a + h, tr = re[b] * cr - im[b] * ci, ti = re[b] * ci + im[b] * cr;\n        re[b] = re[a] - tr, im[b] = im[a] - ti;\n        re[a] += tr, im[a] += ti;\n      }\n    }\n}\nfunction inv(P) {\n  const n = P.n, re = P.re, im = P.im, wr = P.wr, wi = P.wi;\n  for (let h = n >> 1; h >= 1; h >>= 1)\n    for (let j = 0, m = h \u003c\u003c 1; j \u003c h; j++) {\n      const cr = wr[h - 1 + j], ci = -wi[h - 1 + j];\n      for (let a = j; a \u003c n; a += m) {\n        const b = a + h, xr = re[a] - re[b], xi = im[a] - im[b];\n        re[a] += re[b], im[a] += im[b];\n        re[b] = xr * cr - xi * ci, im[b] = xr * ci + xi * cr;\n      }\n    }\n}\nconst PX = plan(W), PY = plan(H);\n\n// Every line (a row when rows, else a column) moves along itself by sh[line]\n// LEDs, exactly, as a phase turn of each Fourier mode, and each mode is\n// damped by P.d, the diffusion along that axis over the step (with the 1/n\n// of the inverse folded in). Two real lines ride one complex FFT and are\n// parted again in Fourier space. The Nyquist mode is dropped.\nfunction shear(F, rows, sh) {\n  const P = rows ? PX : PY, n = P.n, lines = rows ? H : W, ls = rows ? W : 1, es = rows ? 1 : W;\n  const re = P.re, im = P.im, d = P.d, rev = P.rev, hn = n >> 1;\n  for (let l = 0; l \u003c lines; l += 2) {\n    const o1 = l * ls, o2 = o1 + ls;\n    for (let i = 0, q = 0; i \u003c n; i++, q += es) {\n      const r = rev[i];\n      re[r] = F[o1 + q], im[r] = F[o2 + q];\n    }\n    fwd(P);\n    const t1 = (-2 * PI * sh[l]) / n, t2 = (-2 * PI * sh[l + 1]) / n;\n    const c1 = cos(t1), s1 = sin(t1), c2 = cos(t2), s2 = sin(t2);\n    let e1r = 1, e1i = 0, e2r = 1, e2i = 0;\n    for (let k = 1; k \u003c hn; k++) {\n      let q = e1r * c1 - e1i * s1;\n      e1i = e1r * s1 + e1i * c1, e1r = q;\n      q = e2r * c2 - e2i * s2;\n      e2i = e2r * s2 + e2i * c2, e2r = q;\n      const m = n - k, zr = re[k], zi = im[k], wr = re[m], wi = im[m], dk = 0.5 * d[k];\n      const ar = zr + wr, ai = zi - wi, br = zi + wi, bi = wr - zr;\n      const a2r = (ar * e1r - ai * e1i) * dk, a2i = (ar * e1i + ai * e1r) * dk;\n      const b2r = (br * e2r - bi * e2i) * dk, b2i = (br * e2i + bi * e2r) * dk;\n      re[k] = a2r - b2i, im[k] = a2i + b2r;\n      re[m] = a2r + b2i, im[m] = b2r - a2i;\n    }\n    re[0] *= d[0], im[0] *= d[0];\n    re[hn] = im[hn] = 0;\n    inv(P);\n    for (let i = 0, q = 0; i \u003c n; i++, q += es) {\n      const r = rev[i];\n      F[o1 + q] = re[r], F[o2 + q] = im[r];\n    }\n  }\n}\n\n// Diffusion along one axis for tau periods at kappa LED^2 a period, as the\n// damping of each Fourier mode.\nfunction damp(P, kappa, tau) {\n  const n = P.n;\n  for (let k = 0; k \u003c n; k++) {\n    const w = (2 * PI * min(k, n - k)) / n;\n    P.d[k] = exp(-kappa * w * w * tau) / n;\n  }\n}\n\n// Diffusion across the lines while the variance v is small: three taps.\nconst TMP = new Float64Array(N);\nfunction blur(F, rows, v) {\n  const a = v / 2, b = 1 - v;\n  TMP.set(F);\n  if (rows)\n    for (let y = 0; y \u003c H; y++) {\n      const o = y * W, u = ((y + H - 1) % H) * W, w = ((y + 1) % H) * W;\n      for (let x = 0; x \u003c W; x++) F[o + x] = b * TMP[o + x] + a * (TMP[u + x] + TMP[w + x]);\n    }\n  else\n    for (let y = 0; y \u003c H; y++) {\n      const o = y * W;\n      for (let x = 0; x \u003c W; x++) F[o + x] = b * TMP[o + x] + a * (TMP[o + ((x + 63) & 63)] + TMP[o + ((x + 1) & 63)]);\n    }\n}\n\n// Remove the mean and scale to unit rms; returns the log of the rms before.\nfunction norm(F) {\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) m += F[i];\n  m /= N;\n  let q = 0;\n  for (let i = 0; i \u003c N; i++) q += (F[i] -= m) * F[i];\n  const r = sqrt(q / N) || 1e-30, g = 1 / r;\n  for (let i = 0; i \u003c N; i++) F[i] *= g;\n  return log(r);\n}\n\n// The torus is one unit wide and one tall, drawn 64 LEDs wide and 128\n// tall, so a shift of A moves a row by 64 A LEDs and a column by 128 A. The\n// phases of the two sines are fixed: the flow is periodic in time.\nconst P1 = 0.3, P2 = 1.9, SX = new Float64Array(H), SY = new Float64Array(W), ZERO = new Float64Array(H);\nfor (let y = 0; y \u003c H; y++) SX[y] = W * sin((2 * PI * y) / H + P1);\nfor (let x = 0; x \u003c W; x++) SY[x] = H * sin((2 * PI * x) / W + P2);\n\nfunction fresh(S) {\n  const F = S.F;\n  // A few random large waves to start from; the eigenmode forgets them.\n  F.fill(0);\n  for (let j = 0; j \u003c 6; j++) {\n    const kx = 1 + floor(Math.random() * 3), ky = 1 + floor(Math.random() * 5), a = Math.random() * 2 * PI, b = Math.random() * 2 * PI;\n    for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) F[y * W + x] += sin((2 * PI * kx * x) / W + a) * sin((2 * PI * ky * y) / H + b);\n  }\n  norm(F);\n  S.ph = 0, S.logsum = 0;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, A: 1.2, kap: 6, ph: 0, logsum: 0, gamma: 0, warm: 10,\n    F: new Float64Array(N), sh: new Float64Array(H), c: [0, 0, 0],\n  });\n  fresh(S);\n}\n\n// One step of the flow: a share f of the half period's shear along one\n// axis, with tau periods of diffusion along both. The step is cut so that\n// no piece tilts a line by more than one LED for each LED across, and the\n// diffusion across the lines runs after each piece, as three taps or, when\n// that much would be too wide for three, as damping in Fourier space. The\n// log of what norm took away adds up over a period to minus its decay rate.\nfunction step(S, rows, f, tau) {\n  const tilt = abs(f) * S.A * (rows ? (2 * PI * W) / H : (2 * PI * H) / W), n = max(1, Math.ceil(tilt));\n  const prof = rows ? SX : SY, sh = S.sh, len = rows ? H : W, v = (2 * S.kap * tau) / n;\n  for (let i = 0; i \u003c len; i++) sh[i] = (f / n) * S.A * prof[i];\n  damp(rows ? PX : PY, S.kap, tau / n);\n  if (v > 0.8) damp(rows ? PY : PX, S.kap, tau / n);\n  for (let i = 0; i \u003c n; i++) {\n    shear(S.F, rows, sh);\n    if (v > 0.8) shear(S.F, !rows, ZERO);\n    else blur(S.F, rows, v);\n  }\n  S.logsum += norm(S.F);\n}\n\n// Within each half period the shear starts and stops smoothly and rests a\n// little at either end.\nconst ease = (u) => {\n  const t = cl((u - 0.15) / 0.7, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Advance the flow by dp of a period from phase ph.\nfunction advance(S, dp) {\n  while (dp > 1e-9) {\n    const inX = S.ph \u003c 0.5, end = inX ? 0.5 : 1, st = min(dp, end - S.ph);\n    const u0 = 2 * S.ph - (inX ? 0 : 1), f = ease(u0 + 2 * st) - ease(u0);\n    step(S, inX, f, st);\n    S.ph += st;\n    dp -= st;\n    if (S.ph >= 1 - 1e-9) {\n      S.ph = 0;\n      S.gamma = -S.logsum;\n      S.logsum = 0;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const st = cl(k[2], -1, 1);\n  S.A = 1.2 + st * (st \u003c 0 ? 0.75 : 0.4);\n  S.kap = 4 * S.A * 30 ** cl(k[3], 0, 1);\n  // K1 tap: fresh dye, stirred from here on screen.\n  if (input.btnPressed && input.btnPressed[0]) fresh(S), (S.warm = 0);\n  if (S.warm > 0) {\n    // At the start the flow runs ahead unseen, steady shears whole periods\n    // at a time, two periods before the first frame and one more in each\n    // of the next eight, so the panel opens on the mode itself.\n    const n = S.warm === 10 ? 2 : 1;\n    for (let i = 0; i \u003c 2 * n; i++) step(S, i % 2 === 0, 1, 0.5);\n    S.warm -= n;\n    S.logsum = 0;\n    if (!S.warm) {\n      // The equation is linear, so the mode and its negative are the same\n      // mode. Draw it with its long tail on the bright side.\n      let m3 = 0;\n      for (let i = 0; i \u003c N; i++) m3 += S.F[i] * S.F[i] * S.F[i];\n      if (m3 \u003c 0) for (let i = 0; i \u003c N; i++) S.F[i] = -S.F[i];\n    }\n  }\n  advance(S, (d * S.speed) / 6);\n}\n\n// A triangle wave of period 1, 0 at whole numbers and 1 halfway.\nconst tri = (u) => 1 - abs(2 * (u - floor(u)) - 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const F = S.F, c = S.c, h0 = 0.45 + S.hue, V0 = -0.05;\n  for (let y = 0; y \u003c H; y++) {\n    const o = y * W, u = ((y + H - 1) % H) * W, w = ((y + 1) % H) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const p = o + x, v = F[p];\n      // Relief: the field as a height lit from the upper left.\n      const gx = F[o + ((x + 1) & 63)] - F[o + ((x + 63) & 63)], gy = F[w + x] - F[u + x];\n      const g = -(gx + gy) * 0.6, sh = g / (1 + abs(g));\n      // Above a cut just under zero, about half the panel, the dye lights\n      // from violet to pale aqua; level lines every 0.35 shade it a little.\n      if (v > V0) {\n        const t = 1 - exp(-(v - V0) / 0.9), b = tri(v / 0.35);\n        hsv(h0 + 0.3 - 0.3 * t + 0.06 * sh - 0.03 * b, 0.9 - 0.5 * t - 0.15 * sh, 0.11 + (0.06 + 0.83 * t) * (0.78 + 0.3 * sh) * (0.9 + 0.1 * b), c);\n      } else {\n        // Below the cut, the level lines of the mode every 0.15, dim.\n        const t = exp((v - V0) / 1.2), b = tri(v / 0.15);\n        hsv(h0 + 0.32 - 0.12 * t + 0.05 * sh, 0.55 + 0.3 * b, min(0.09, (0.02 + 0.045 * t + 0.03 * b) * (1 + 0.3 * sh)), c);\n      }\n      display.setPixel(x, y, cl(c[0], 0, 255) | 0, cl(c[1], 0, 255) | 0, cl(c[2], 0, 255) | 0);\n    }\n  }\n}\n","ulam-sequence":"// ===== Patternflow pattern =====\n// Title:   Ulam Sequence\n// Family:  number\n// Idea:    The Ulam sequence counted live, each new term the least number that is a sum of two earlier terms in exactly one way, wound round a circle by the hidden frequency alpha that the code finds for itself: every term sits across the panel at the angle alpha times the term and lower down the larger it is, so the terms fill only the half of the circle where cos(alpha a) \u003c 0, in two humps, and leave the other half empty but for 2, 3, 47 and 69, while each new one drops into the pile below.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ulam sequence (Stanisław Ulam, 1964), with the hidden frequency Stefan Steinerberger found (2017)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Seed=0..5, Detune=-1..1\n//\n// Knob 1: Hue. The colour of the terms, with the ones off the pile in a hue a fifth of the wheel back: gold with pink at 0, green with yellow at 0.25, blue with sea green at 0.5, magenta with blue at 0.75.\n// Knob 2: Speed. New terms a second, 40 for each unit: 80 at the opening 2. At 0.2 there are 8 a second, at 3 there are 120. Each new term falls from the foot of the coil into its column of the pile in 0.4 s. After 16,000 terms (the last of U(1,2) is 213,514) the count rests 4 s and starts again from the first 600.\n// Knob 3: Seed. Which sequence: U(1,2) at 0, U(1,3) at 1, U(1,4) at 2, U(2,3) at 3, U(3,4) at 4 and U(2,5) at 5. The code finds each frequency itself as the alpha in (0, pi] where |sum of exp(i alpha a)| over the terms is largest, and finds it again each time the count doubles: 2.5714 for U(1,2) (Steinerberger gives 2.5714474995), 2.8335 for U(1,3), 0.5060 for U(1,4), 1.1650 for U(2,3), 2.2090 for U(3,4). U(2,5) has just two even terms, 2 and 12 (James Schmerl and Eugene Spiegel, 1994), so its frequency is pi and its pile is one spike. The terms off the pile are 2, 3, 47 and 69 for U(1,2), 4 and 98 for U(1,3), 1 and 10 for U(1,4), 5 for U(2,3), 3 and 11 for U(3,4).\n// Knob 4: Detune. Moves alpha off the found value: not at all within 0.1 of the middle (it opens at 0.06), then as the square of the rest, to 0.002 either way at the ends. The error in the angle grows with the term, so at 0.5 (0.0004 off) the band leans more and more towards the foot of the coil and winds into stripes that cross the empty half in pink; at 1 the pile is flat.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, log, PI, round } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The seeds K3 steps through.\nconst SEEDS = [[1, 2], [1, 3], [1, 4], [2, 3], [3, 4], [2, 5]];\n// Terms kept at most, and the counting array: C[m] is how many ways m is a\n// sum of two distinct terms so far, stopped at 2.\nconst NMAX = 16000, LIM = 1 \u003c\u003c 19, HEAD = 600;\n// Rows of the coil (the number line wound on the circle) and of the pile.\nconst CH = 86, PB = 34;\n\nfunction start(S, seed) {\n  const [p, q] = SEEDS[seed];\n  S.seed = seed;\n  S.C.fill(0);\n  S.T[0] = p, S.T[1] = q, S.n = 2;\n  S.C[p + q] = 1;\n  S.alpha = 0, S.fitN = 0, S.acc = 0, S.full = 0;\n  S.born.fill(-9);\n  while (S.n \u003c HEAD) next(S);\n  fit(S);\n}\n\n// The next Ulam term: the least m above the last term that is a sum of two\n// distinct earlier terms in exactly one way. Then its sums with every\n// earlier term are counted.\nfunction next(S) {\n  const T = S.T, C = S.C, n = S.n;\n  let m = T[n - 1] + 1;\n  while (m \u003c LIM >> 1 && C[m] !== 1) m++;\n  if (m >= LIM >> 1 || n >= NMAX) return false;\n  T[n] = m;\n  for (let j = 0; j \u003c n; j++) {\n    const s = m + T[j];\n    if (s \u003c LIM && C[s] \u003c 2) C[s]++;\n  }\n  S.n = n + 1;\n  return true;\n}\n\n// |sum of exp(i alpha a)|^2 over the first n terms.\nfunction power(T, n, a) {\n  let re = 0, im = 0;\n  for (let j = 0; j \u003c n; j++) (re += cos(a * T[j])), (im += sin(a * T[j]));\n  return re * re + im * im;\n}\n\n// The same at K points a0, a0 + step, ..., each term's phase turned on by a\n// fixed step from the last; returns the best point.\nconst CR = new Float64Array(NMAX), CI = new Float64Array(NMAX), WR = new Float64Array(NMAX), WI = new Float64Array(NMAX);\nfunction scan(T, n, a0, step, K) {\n  for (let j = 0; j \u003c n; j++) (CR[j] = cos(a0 * T[j])), (CI[j] = sin(a0 * T[j])), (WR[j] = cos(step * T[j])), (WI[j] = sin(step * T[j]));\n  let best = -1, at = a0;\n  for (let k = 0; k \u003c= K; k++) {\n    let re = 0, im = 0;\n    for (let j = 0; j \u003c n; j++) {\n      re += CR[j], im += CI[j];\n      const r = CR[j] * WR[j] - CI[j] * WI[j];\n      CI[j] = CR[j] * WI[j] + CI[j] * WR[j], CR[j] = r;\n    }\n    const p = re * re + im * im;\n    if (p > best) (best = p), (at = a0 + k * step);\n  }\n  return at;\n}\n\n// The hidden frequency: the alpha in (0, pi] where the terms' Fourier sum\n// is largest. The first time, a scan of the first 200 terms from 0.01 to pi\n// in steps of a fifth of the peak's width; each time the count doubles, a\n// scan of three old peak widths round the last value with all the terms.\n// Then the top of a parabola through the best point and its neighbours,\n// twice, the second time five times closer.\nfunction fit(S) {\n  const T = S.T, n = S.n;\n  let at, h;\n  if (!S.alpha) {\n    h = (0.2 * TAU) / T[199];\n    at = scan(T, 200, 0.01, h, Math.ceil((PI - 0.01) / h));\n  } else {\n    h = (0.2 * TAU) / T[n - 1];\n    const w = (1.5 * TAU) / T[S.fitN - 1];\n    at = scan(T, n, S.alpha - w, h, Math.ceil((2 * w) / h));\n  }\n  for (let i = 0; i \u003c 2; i++, h /= 5) {\n    const f0 = power(T, n, at - h), f1 = power(T, n, at), f2 = power(T, n, at + h), q = f0 - 2 * f1 + f2;\n    if (q \u003c 0) at += (cl((0.5 * (f0 - f2)) / q, -1, 1)) * h;\n  }\n  S.alpha = at;\n  S.fitN = n;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, seed: 0, det: 0, alpha: 0, fitN: 0, acc: 0, n: 0, full: 0, t: 0,\n    T: new Float64Array(NMAX), C: new Uint8Array(LIM), born: new Float64Array(NMAX),\n    G: new Float64Array(W * CH), R: new Float64Array(CH), P: new Float64Array(W), c: [0, 0, 0],\n  });\n  start(S, 0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const seed = cl(round(k[2]), 0, SEEDS.length - 1);\n  if (seed !== S.seed) start(S, seed);\n  // Detune: nothing within 0.1 of the middle, then up to 0.002 either way.\n  const u = cl(abs(k[3]) - 0.1, 0, 0.9) / 0.9;\n  S.det = (k[3] \u003c 0 ? -1 : 1) * 0.002 * u * u;\n  S.t += d;\n  // New terms, 40 a second for each unit of Speed.\n  S.acc += 40 * S.speed * d;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    if (!next(S)) {\n      S.full += d;\n      break;\n    }\n    S.born[S.n - 1] = S.t;\n  }\n  if (S.n >= 2 * S.fitN) fit(S);\n  if (S.full > 4) start(S, S.seed);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const T = S.T, n = S.n, G = S.G, R = S.R, P = S.P, c = S.c, al = S.alpha + S.det;\n  G.fill(0), R.fill(0), P.fill(0);\n  // Rows of the coil go as log(a + 16), from a = 1 at the top to the\n  // largest term at the bottom; columns are alpha a modulo 2 pi.\n  const l0 = log(17), sc = (CH - 1) / (log(T[n - 1] + 16) - l0);\n  let pm = 1;\n  for (let j = 0; j \u003c n; j++) {\n    const a = T[j], x = floor(((al * a) % TAU) * (W / TAU)) & 63, y = (log(a + 16) - l0) * sc, y0 = floor(y), f = y - y0;\n    G[y0 * W + x] += 1 - f, R[y0] += 1 - f;\n    if (y0 + 1 \u003c CH) (G[(y0 + 1) * W + x] += f), (R[y0 + 1] += f);\n    if (++P[x] > pm) pm = P[x];\n  }\n  const h0 = 0.12 + S.hue;\n  // A cell's light goes with its count against the row's share of terms\n  // for each of the 24 columns the band spans, so sparse rows near the top\n  // show single terms and dense rows the band's shape.\n  for (let y = 0; y \u003c CH; y++) {\n    const q = 1.2 / max(0.4, R[y] / 24);\n    for (let x = 0; x \u003c W; x++) {\n      const b = 1 - exp(-G[y * W + x] * q);\n      hsv(h0 + 0.05 * b, 0.75 - 0.3 * b, b, c);\n      display.setPixel(x, y, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n  }\n  // The terms with cos(alpha a) >= 0, on the empty half of the circle, in\n  // pink with a dim cross round each.\n  for (let j = 0; j \u003c n; j++) {\n    const a = T[j];\n    if (cos(al * a) \u003c 0) continue;\n    const x = floor(((al * a) % TAU) * (W / TAU)) & 63, y = min(CH - 1, round((log(a + 16) - l0) * sc));\n    hsv(h0 + 0.8, 0.7, 0.45, c);\n    for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) {\n      const yy = y + dy;\n      if (yy >= 0 && yy \u003c CH) display.setPixel((x + dx) & 63, yy, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n    hsv(h0 + 0.8, 0.5, 1, c);\n    display.setPixel(x, y, c[0] | 0, c[1] | 0, c[2] | 0);\n  }\n  // The pile: how many terms in each 64th of the circle, on a bottom row\n  // that marks the half where cos(alpha a) \u003c 0 apart from the other half.\n  for (let x = 0; x \u003c W; x++) {\n    const hgt = (P[x] / pm) * PB;\n    for (let z = 0; z \u003c PB; z++) {\n      const b = cl(hgt - z, 0, 1);\n      if (b \u003c= 0) break;\n      hsv(h0 + 0.03 * (z / PB), 0.85 - 0.4 * (z / PB), b * (0.62 + 0.38 * (z / PB)), c);\n      display.setPixel(x, H - 2 - z, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n    if (x >= 16 && x \u003c 48) hsv(h0 + 0.5, 0.6, 0.3, c);\n    else hsv(h0 + 0.8, 0.6, 0.3, c);\n    display.setPixel(x, H - 1, c[0] | 0, c[1] | 0, c[2] | 0);\n  }\n  // Each new term falls from the bottom of the coil into its column of\n  // the pile in 0.4 s.\n  for (let j = n - 1; j >= 2 && S.t - S.born[j] \u003c 0.4; j--) {\n    const a = T[j], x = floor(((al * a) % TAU) * (W / TAU)) & 63, u = (S.t - S.born[j]) / 0.4;\n    const top = H - 2 - (P[x] / pm) * PB, y = CH - 1 + (top - CH + 1) * u * u;\n    for (let i = 0; i \u003c 3; i++) {\n      const yy = round(y) - i;\n      if (yy \u003c CH || yy >= H) continue;\n      hsv(h0 + 0.02, 0.35 + 0.2 * i, 1 - 0.3 * i, c);\n      display.setPixel(x, yy, c[0] | 0, c[1] | 0, c[2] | 0);\n    }\n  }\n}\n","weaire-phelan":"// ===== Patternflow pattern =====\n// Title:   Weaire-Phelan\n// Family:  space\n// Idea:    A tall column of 48 foam cells turns slowly in depth, each the Voronoi cell of a site of the A15 lattice, so that together they are the flat-faced Weaire-Phelan foam of green-teal pentagonal dodecahedra and fourteen-faced cells with two gold hexagons each, and a knob lowers a line above which Kelvin's truncated octahedra of the same volume, with violet squares, take their place.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Weaire-Phelan structure (Denis Weaire and Robert Phelan, 1993), against Kelvin's truncated octahedra (William Thomson, Lord Kelvin, 1887)\n// Round:   54\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Kelvin=0..1, Gap=0..1\n//\n// Knob 1: Hue. Turns every face colour round the wheel together. At 0 the pentagons of the fourteen-faced cells are blue-teal, those of the dodecahedra a greener teal, the hexagons gold and Kelvin's squares violet; at 0.5 the pentagons turn red and the hexagons blue.\n// Knob 2: Speed. How fast the column turns about its upright axis: at 2 once in 16 s, at 0.2 once in two and a half minutes, at 3 once in 10.5 s.\n// Knob 3: Kelvin. Lowers a line through the column. Below it the cells are Weaire and Phelan's, above it Kelvin's truncated octahedra with six squares and eight hexagons, each of 2,744 cubic LEDs, the mean of WP's two sizes (2,680 and 2,765). At 0 the column is all WP, at 0.5 its top half is Kelvin's, at 1 all of it. With flat faces the walls come to 5.2950 per cell of unit volume for WP and 5.3147 for Kelvin, 0.37% more.\n// Knob 4: Gap. Shrinks every cell about its own site, to half its size at 1, so the foam opens up. At 0 the walls meet and at 0.06 they part by a hairline; at 0.5 the inner stack of fourteen-faced cells shows through the gaps, and at 1 each cell stands apart and its faces can be counted.\n\nconst W = 64, H = 128, N = W * H, CX = 31.5, CY = 63.5;\nconst { floor, min, max, abs, sin, cos, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return o;\n}\n\n// The sites of one unit cube. A15 (the beta-tungsten structure): its Voronoi\n// cells are the flat-faced Weaire-Phelan foam. BCC: its Voronoi cells are\n// Kelvin's truncated octahedra.\nconst A15 = [[0, 0, 0], [0.5, 0.5, 0.5], [0.25, 0.5, 0], [0.75, 0.5, 0], [0, 0.25, 0.5], [0, 0.75, 0.5], [0.5, 0, 0.25], [0.5, 0, 0.75]];\nconst BCC = [[0, 0, 0], [0.5, 0.5, 0.5]];\n// The WP cube edge in LEDs. Kelvin's cube holds two cells to WP's eight, so\n// for the same volume per cell its edge is the WP edge over the cube root of 4.\nconst AW = 28, AK = AW / Math.cbrt(4);\n\nconst sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];\nconst dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\nconst crs = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\n\n// The Voronoi cell of site i, relative to the site: a cube two cube edges\n// wide, cut by the bisecting plane of every site of the periodic lattice\n// within 1.5 cube edges, nearest first. Each cut keeps the part of every face\n// on the site's side and closes the hole with a new face, its corners sorted\n// by angle round their mean.\nfunction voronoi(sites, i) {\n  const c = sites[i], E = 1e-10;\n  let F = [];\n  for (let ax = 0; ax \u003c 3; ax++)\n    for (const sg of [-1, 1]) {\n      const u = (ax + 1) % 3, v = (ax + 2) % 3, q = [];\n      for (const [a, b] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) {\n        const p = [0, 0, 0];\n        p[ax] = sg;\n        p[u] = a * sg;\n        p[v] = b;\n        q.push(p);\n      }\n      F.push(q);\n    }\n  const nb = [];\n  for (const s of sites)\n    for (let x = -2; x \u003c= 2; x++)\n      for (let y = -2; y \u003c= 2; y++)\n        for (let z = -2; z \u003c= 2; z++) {\n          const d = [s[0] + x - c[0], s[1] + y - c[1], s[2] + z - c[2]], r2 = dot(d, d);\n          if (r2 > E && r2 \u003c 2.25) nb.push([d, r2]);\n        }\n  nb.sort((a, b) => a[1] - b[1]);\n  // A plane further than the farthest corner cannot cut, nor can any after it.\n  let far = 3;\n  for (const [d, r2] of nb) {\n    if (r2 > 4 * far) break;\n    const side = (p) => dot(p, d) - r2 / 2, out = [], cut = [];\n    for (const f of F) {\n      const q = [];\n      for (let m = 0; m \u003c f.length; m++) {\n        const A = f[m], B = f[(m + 1) % f.length], sa = side(A), sb = side(B);\n        if (sa \u003c= E) q.push(A);\n        if (abs(sa) \u003c= E) cut.push(A);\n        else if ((sa \u003c 0) !== (sb \u003c 0) && abs(sb) > E) {\n          const t = sa / (sa - sb), X = [A[0] + t * (B[0] - A[0]), A[1] + t * (B[1] - A[1]), A[2] + t * (B[2] - A[2])];\n          q.push(X);\n          cut.push(X);\n        }\n      }\n      if (q.length >= 3) out.push(q);\n    }\n    if (cut.length >= 3) {\n      const m = [0, 1, 2].map((k) => cut.reduce((s, p) => s + p[k], 0) / cut.length), e1 = sub(cut[0], m), e2 = crs(d, e1), pts = [];\n      for (const p of cut) if (!pts.some((o) => hypot(...sub(o[0], p)) \u003c 1e-7)) pts.push([p, Math.atan2(dot(sub(p, m), e2), dot(sub(p, m), e1))]);\n      pts.sort((a, b) => a[1] - b[1]);\n      if (pts.length >= 3) out.push(pts.map((o) => o[0]));\n    }\n    F = out;\n    far = 0;\n    for (const f of F) for (const p of f) far = max(far, dot(p, p));\n  }\n  // Corners shared between faces, and each face as a list of corner indices\n  // with its outward unit normal. The cell's volume is summed as pyramids on\n  // its faces with their apex at the site.\n  const V = [], faces = [];\n  const idx = (p) => {\n    for (let k = 0; k \u003c V.length; k++) if (hypot(...sub(V[k], p)) \u003c 1e-7) return k;\n    V.push(p);\n    return V.length - 1;\n  };\n  let vol = 0, area = 0;\n  for (const f of F) {\n    const ix = [];\n    for (const p of f) {\n      const k = idx(p);\n      if (ix[ix.length - 1] !== k && ix[0] !== k) ix.push(k);\n    }\n    let n = [0, 0, 0];\n    for (let m = 1; m + 1 \u003c ix.length; m++) n = n.map((v, t) => v + crs(sub(V[ix[m]], V[ix[0]]), sub(V[ix[m + 1]], V[ix[0]]))[t] / 2);\n    const ar = hypot(...n);\n    if (ix.length \u003c 3 || ar \u003c 1e-9) continue;\n    n = n.map((v) => v / ar);\n    if (dot(n, V[ix[0]]) \u003c 0) ix.reverse(), (n = n.map((v) => -v));\n    faces.push({ ix, n, nv: ix.length });\n    area += ar;\n    vol += (ar * dot(n, V[ix[0]])) / 3;\n  }\n  // Each edge once, with the two faces that meet there.\n  const edges = [], seen = new Map();\n  faces.forEach((f, j) => {\n    for (let m = 0; m \u003c f.nv; m++) {\n      const a = f.ix[m], b = f.ix[(m + 1) % f.nv], key = min(a, b) * 1000 + max(a, b);\n      if (seen.has(key)) edges[seen.get(key) + 3] = j;\n      else seen.set(key, edges.length), edges.push(a, b, j, j);\n    }\n  });\n  return { V, faces, edges, vol, area };\n}\n\nexport function setup(params) {\n  const S = (params.s = { hue: 0, speed: 2, kel: 0, gap: 0.06, th: 0.6, inst: [], cells: [], check: null });\n  // The base cells, eight of WP and two of Kelvin. S.check keeps what the\n  // theorem is about: each cell's volume and face sizes, and the mean surface\n  // of a cell scaled to unit volume, the number Kelvin's problem is quoted in\n  // (each wall then counts once for each of the two cells it parts).\n  const base = [A15, BCC].map((sites) => sites.map((_, i) => voronoi(sites, i)));\n  const ck = (S.check = {});\n  base.forEach((cells, k) => {\n    const v = cells.reduce((s, c) => s + c.vol, 0), a = cells.reduce((s, c) => s + c.area, 0), n = cells.length;\n    ck[k ? \"kelvin\" : \"wp\"] = { volumes: cells.map((c) => c.vol), faces: cells.map((c) => c.faces.map((f) => f.nv)), total: v, areaPerUnitVolume: a / n / (v / n) ** (2 / 3) };\n  });\n  // The column: every site within a radius of a vertical axis and a height\n  // of the middle, for each lattice. WP's axis runs up a stack of\n  // fourteen-faced cells joined by their hexagons; Kelvin's up a line of sites.\n  const pick = (sites, cells, a, ax, az, R, kind) => {\n    for (let i = 0; i \u003c sites.length; i++)\n      for (let x = -3; x \u003c= 3; x++)\n        for (let y = -6; y \u003c= 6; y++)\n          for (let z = -3; z \u003c= 3; z++) {\n            const s = [sites[i][0] + x - ax, sites[i][1] + y - 0.5, sites[i][2] + z - az];\n            if (hypot(s[0], s[2]) > R || abs(s[1]) * a > 48) continue;\n            const n = cells[i].V.length;\n            S.inst.push({ c: cells[i], kind, x: s[0] * a, y: s[1] * a, z: s[2] * a, a, on: false, fr: new Uint8Array(cells[i].faces.length), sx: new Float64Array(n), sy: new Float64Array(n), sz: new Float64Array(n) });\n          }\n  };\n  pick(A15, base[0], AW, 0, 0.5, 0.57, 0);\n  pick(BCC, base[1], AK, 0.25, 0.25, 0.8, 1);\n  S.PX = new Float64Array(16);\n  S.PY = new Float64Array(16);\n  S.PZ = new Float64Array(16);\n  S.zb = new Float32Array(N);\n  S.rgb = new Float32Array(N * 3);\n  S.col = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.kel = cl(k[2], 0, 1);\n  S.gap = cl(k[3], 0, 1);\n  S.th += d * S.speed * 0.2;\n}\n\n// The view: turned th about the vertical, then tipped EL toward the viewer\n// so the tops of the cells show, with a little perspective from DCAM LEDs.\n// A key light from the upper left and a weaker fill from the right.\nconst EL = 0.28, CE = cos(EL), SE = sin(EL), DCAM = 220;\n// Light kept in the shade and overall gain for each face colour (see draw);\n// hexagons keep more so their gold never sinks to brown.\nconst AMB = [0.14, 0.42, 0.22, 0.14], GAIN = [0.95, 1.05, 1, 0.95];\n\n// Fills a convex polygon of n screen corners row by row, the depth taken\n// from the plane through three of them; nearer pixels win.\nfunction poly(S, X, Y, Z, n, r, g, b) {\n  let y0 = 1e9, y1 = -1e9;\n  for (let m = 0; m \u003c n; m++) (y0 = min(y0, Y[m])), (y1 = max(y1, Y[m]));\n  const ux = X[1] - X[0], uy = Y[1] - Y[0], uz = Z[1] - Z[0], vx = X[2] - X[0], vy = Y[2] - Y[0], vz = Z[2] - Z[0], dn = ux * vy - uy * vx;\n  if (abs(dn) \u003c 1e-6) return;\n  const zx = (uz * vy - uy * vz) / dn, zy = (ux * vz - uz * vx) / dn, zb = S.zb, rgb = S.rgb;\n  for (let y = max(0, Math.ceil(y0)), ye = min(H - 1, floor(y1)); y \u003c= ye; y++) {\n    let xl = 1e9, xr = -1e9;\n    for (let m = 0; m \u003c n; m++) {\n      const k = m + 1 \u003c n ? m + 1 : 0, ya = Y[m], yb = Y[k];\n      if ((ya \u003c= y && yb >= y) || (yb \u003c= y && ya >= y)) {\n        const x = ya === yb ? X[m] : X[m] + ((y - ya) * (X[k] - X[m])) / (yb - ya);\n        xl = min(xl, x);\n        xr = max(xr, x);\n        if (ya === yb) xr = max(xr, X[k]), (xl = min(xl, X[k]));\n      }\n    }\n    for (let x = max(0, Math.ceil(xl)), xe = min(W - 1, floor(xr)); x \u003c= xe; x++) {\n      const p = y * W + x, z = Z[0] + zx * (x - X[0]) + zy * (y - Y[0]);\n      if (z \u003c= zb[p]) continue;\n      // Darker with depth, pixel by pixel, so a face turning away fades\n      // along its length.\n      const f = cl(0.72 + z / 55, 0.3, 1);\n      zb[p] = z;\n      rgb[p * 3] = r * f;\n      rgb[p * 3 + 1] = g * f;\n      rgb[p * 3 + 2] = b * f;\n    }\n  }\n}\n\nfunction line(S, ax, ay, az, bx, by, bz, lv) {\n  const n = Math.ceil(max(abs(bx - ax), abs(by - ay))) + 1, zb = S.zb, rgb = S.rgb;\n  for (let i = 0; i \u003c= n; i++) {\n    const t = i / n, x = Math.round(ax + t * (bx - ax)), y = Math.round(ay + t * (by - ay));\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const p = y * W + x;\n    if (az + t * (bz - az) \u003c zb[p] - 1.5) continue;\n    rgb[p * 3] = max(rgb[p * 3], lv);\n    rgb[p * 3 + 1] = max(rgb[p * 3 + 1], lv);\n    rgb[p * 3 + 2] = max(rgb[p * 3 + 2], lv);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const zb = S.zb, rgb = S.rgb, PX = S.PX, PY = S.PY, PZ = S.PZ;\n  zb.fill(-1e9);\n  rgb.fill(0);\n  const ct = cos(S.th), st = sin(S.th), sc = 1 - 0.5 * S.gap;\n  // Face colours: pentagons of the fourteen-faced cells, hexagons, squares\n  // and the pentagons of the dodecahedra, a little greener.\n  const col = S.col;\n  hsv(0.53 + S.hue, 0.75, 1, col[0]);\n  hsv(0.14 + S.hue, 0.6, 1, col[1]);\n  hsv(0.8 + S.hue, 0.6, 1, col[2]);\n  hsv(0.45 + S.hue, 0.65, 1, col[3]);\n  // The cut between the two structures, from above the top (all WP) at\n  // Kelvin 0 to below the bottom (all Kelvin) at 1.\n  const yc = 64 - 128 * S.kel, half = 8;\n  for (const it of S.inst) {\n    it.on = it.kind === 0 ? it.y \u003c yc - half : it.y > yc + half;\n    if (!it.on) continue;\n    const c = it.c, V = c.V, a = it.a * sc, sx = it.sx, sy = it.sy, sz = it.sz, fr = it.fr;\n    for (let k = 0; k \u003c V.length; k++) {\n      const x = it.x + a * V[k][0], y = it.y + a * V[k][1], z = it.z + a * V[k][2];\n      const xr = ct * x + st * z, zr = -st * x + ct * z, yr = CE * y - SE * zr, zz = SE * y + CE * zr, f = DCAM / (DCAM - zz);\n      sx[k] = CX + xr * f;\n      sy[k] = CY - yr * f;\n      sz[k] = zz;\n    }\n    c.faces.forEach((fc, j) => {\n      const n = fc.n, nx = ct * n[0] + st * n[2], nzr = -st * n[0] + ct * n[2], ny = CE * n[1] - SE * nzr, nz = SE * n[1] + CE * nzr;\n      // Back faces away (seen from the camera, DCAM in front); the rest lit\n      // from the upper left and darker with depth.\n      const i0 = fc.ix[0], px = (sx[i0] - CX) * (DCAM - sz[i0]) / DCAM, py = (CY - sy[i0]) * (DCAM - sz[i0]) / DCAM;\n      fr[j] = nx * -px + ny * -py + nz * (DCAM - sz[i0]) > 0 ? 1 : 0;\n      if (!fr[j]) return;\n      const t = fc.nv === 5 ? (c.faces.length === 12 ? 3 : 0) : fc.nv === 6 ? 1 : 2;\n      const lam = max(0, -0.45 * nx + 0.6 * ny + 0.66 * nz), fill = max(0, 0.6 * nx - 0.1 * ny + 0.79 * nz);\n      const sh = min(1, AMB[t] + (1 - AMB[t]) * (0.8 * lam * lam + 0.3 * fill)) * GAIN[t], cc = col[t];\n      for (let m = 0; m \u003c fc.nv; m++) (PX[m] = sx[fc.ix[m]]), (PY[m] = sy[fc.ix[m]]), (PZ[m] = sz[fc.ix[m]]);\n      poly(S, PX, PY, PZ, fc.nv, cc[0] * sh, cc[1] * sh, cc[2] * sh);\n    });\n  }\n  // Edges of the faces turned to the viewer, white, dimmer further back.\n  for (const it of S.inst) {\n    if (!it.on) continue;\n    const e = it.c.edges, sx = it.sx, sy = it.sy, sz = it.sz, fr = it.fr;\n    for (let m = 0; m \u003c e.length; m += 4) {\n      if (!fr[e[m + 2]] && !fr[e[m + 3]]) continue;\n      const a = e[m], b = e[m + 1];\n      line(S, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], cl(0.62 + (sz[a] + sz[b]) / 100, 0.35, 0.95));\n    }\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, min(255, rgb[p * 3] * 255) | 0, min(255, rgb[p * 3 + 1] * 255) | 0, min(255, rgb[p * 3 + 2] * 255) | 0);\n}\n","barycentric-subdivision":"// ===== Patternflow pattern =====\n// Title:   Barycentric Subdivision\n// Family:  fractal\n// Idea:    A triangle cut along its medians into six, and each of those again, fills the panel as a mosaic coloured by each piece's largest angle, and the camera dives child after child down one random line of descent, outlined in white three steps ahead and turning and scaling but never stretching, until the pieces are hot slivers and the walk starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: iterated barycentric subdivision, whose triangles flatten (Imre Bárány, Alan F. Beardon and T. Keith Carne, 1996; Persi Diaconis and Laurent Miclo, 2011), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=2..3, Steer=0..1\n//\n// Knob 1: Hue. Turns the whole angle scale round the wheel. At 0 a piece whose largest angle is 60 degrees is cyan, 90 azure, 120 blue, 150 violet, 170 magenta, 177 rose and 179 red-orange, and one within a third of a degree of flat is a pale amber.\n// Knob 2: Speed. At 2 the camera takes 2.2 seconds to dive from one triangle into the next, slowing as it arrives; at 0.2 ten times slower, at 3 half as fast again. When the current triangle's largest angle passes 179 degrees the picture fades and starts again from an equilateral triangle; with random steps that happens after 25 dives in the median, under a minute at 2.\n// Knob 3: Depth. How many levels below the current triangle the mosaic is cut. At 2 the current triangle shows as 36 pieces and the third level, 216, fades in as the camera closes on the next triangle, which then shows 36 of its own; at 3 it is 216 going to 1,296. A piece whose smallest height on the panel is under 3 LEDs is never cut, so the slivers stay whole and the finest level shows only inside the rounder pieces.\n// Knob 4: Steer. The chance at each step that the camera takes the roundest of the six children instead of a random one, from 0 at 0.1 to 1 at the top. Up to 0.1 every step is random as in the theorem, and after 40 steps two descents in three have a largest angle over 179 degrees. At 0.3, two steps in nine steered, it is one in twelve. From 0.4, one step in three, the shapes hold: the median largest angle stays near 115 degrees and the colours stay cool. At 1 every step takes the roundest child and the largest angle stays between 68 and 90 degrees.\n// Buttons: K1 tap starts again from an equilateral triangle.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, atan2, acos, abs, exp, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// A child is named by the order of the barycentric coordinates inside it:\n// child c holds the points whose largest coordinate is CI[c] and second CJ[c].\n// Its corners are the vertex CI, the midpoint of the side CI-CJ and the\n// centroid, in that order. With corners 0, 1 and z, child c has the shape\n// 2(1+z)/3, 2(1+z)/3z, (4-2z)/3, 2(z-2)/3(z-1), 2(2z-1)/3z, 2(1-2z)/3(1-z):\n// a fixed Moebius map of z, or of its mirror image for c = 1, 2 and 5.\nconst CI = [0, 0, 1, 1, 2, 2], CJ = [1, 2, 0, 2, 0, 1];\n// Triangles kept above the current one, for the mosaic round it.\nconst KEEP = 12;\n// Seconds per level at Speed 1.\nconst LEVEL = 4.4;\n// A line of descent ends when the current triangle's largest angle passes this.\nconst FLAT = 179;\n// A triangle whose smallest height on the panel is under LOD LEDs is not cut\n// further; up to twice that its children fade in.\nconst LOD = 3;\n// Margin in LEDs when a triangle is framed.\nconst MG = 1;\n// Angle scale: LUT entries from 60 to 180 degrees.\nconst NL = 512;\n\nfunction child(src, so, c, dst, d) {\n  const i = 2 * CI[c], j = 2 * CJ[c];\n  const xi = src[so + i], yi = src[so + i + 1];\n  const gx = (src[so] + src[so + 2] + src[so + 4]) / 3, gy = (src[so + 1] + src[so + 3] + src[so + 5]) / 3;\n  dst[d] = xi;\n  dst[d + 1] = yi;\n  dst[d + 2] = 0.5 * (xi + src[so + j]);\n  dst[d + 3] = 0.5 * (yi + src[so + j + 1]);\n  dst[d + 4] = gx;\n  dst[d + 5] = gy;\n}\n\n// Where a triangle sits on the colour scale, 0 to 1: half is its largest\n// angle from 60 to 180 degrees, half how far it is short of flat on a log\n// scale from 30 degrees down to 0.3, so 170, 177 and 179.5 look different.\nfunction heat(t, o) {\n  const a = bigAngle(t, o), d = 180 - a;\n  return cl(0.5 * ((a - 60) / 120) + 0.5 * cl((Math.log10(30) - Math.log10(d > 1e-9 ? d : 1e-9)) / 2, 0, 1), 0, 1);\n}\n\n// Largest angle of a triangle, in degrees.\nfunction bigAngle(t, o) {\n  const ax = t[o + 2] - t[o + 4], ay = t[o + 3] - t[o + 5];\n  const bx = t[o + 4] - t[o], by = t[o + 5] - t[o + 1];\n  const cx = t[o] - t[o + 2], cy = t[o + 1] - t[o + 3];\n  let m = ax * ax + ay * ay, p = bx * bx + by * by, q = cx * cx + cy * cy, w;\n  if (p > m) (w = m), (m = p), (p = w);\n  if (q > m) (w = m), (m = q), (q = w);\n  return (acos(cl((p + q - m) / (2 * sqrt(p * q) + 1e-300), -1, 1)) * 180) / PI;\n}\n\n// The similarity z -> a z + b that sets triangle t as large as it fits in the\n// panel, preferring small turns from the present view. Writes [ar, ai, br, bi].\nfunction frame(t, o, out) {\n  let best = -1, bs = 1, bt = 0, lx = 0, ly0 = 0, ll = 0;\n  for (let v = 0; v \u003c 6; v += 2) {\n    const w = (v + 2) % 6, dx = t[o + w] - t[o + v], dy = t[o + w + 1] - t[o + v + 1];\n    if (dx * dx + dy * dy > ll) (ll = dx * dx + dy * dy), (lx = dx), (ly0 = dy);\n  }\n  const tryAt = (th) => {\n    if (th > PI) th -= 2 * PI;\n    if (th \u003c= -PI) th += 2 * PI;\n    const c = cos(th), sn = sin(th);\n    let x0 = 1e300, x1 = -1e300, y0 = 1e300, y1 = -1e300;\n    for (let v = 0; v \u003c 6; v += 2) {\n      const x = t[o + v], y = t[o + v + 1], rx = c * x - sn * y, ry = sn * x + c * y;\n      if (rx \u003c x0) x0 = rx;\n      if (rx > x1) x1 = rx;\n      if (ry \u003c y0) y0 = ry;\n      if (ry > y1) y1 = ry;\n    }\n    const sc = min((W - 2 * MG) / (x1 - x0 + 1e-300), (H - 2 * MG) / (y1 - y0 + 1e-300));\n    // A long side stood upright scores a quarter more, so a sliver stands\n    // along the columns instead of the panel's diagonal.\n    const ly = sn * lx + c * ly0;\n    const score = sc * (1 - (0.3 * abs(th)) / PI) * (1 + 0.25 * (ly * ly / ll) ** 8);\n    if (score > best) (best = score), (bs = sc), (bt = th);\n  };\n  for (let n = -48; n \u003c 48; n++) tryAt((n * PI) / 48);\n  const t0 = bt;\n  for (let n = -16; n \u003c= 16; n++) tryAt(t0 + (n * PI) / 768);\n  const ar = bs * cos(bt), ai = bs * sin(bt);\n  let x0 = 1e300, x1 = -1e300, y0 = 1e300, y1 = -1e300;\n  for (let v = 0; v \u003c 6; v += 2) {\n    const x = t[o + v], y = t[o + v + 1], rx = ar * x - ai * y, ry = ai * x + ar * y;\n    if (rx \u003c x0) x0 = rx;\n    if (rx > x1) x1 = rx;\n    if (ry \u003c y0) y0 = ry;\n    if (ry > y1) y1 = ry;\n  }\n  out[0] = ar;\n  out[1] = ai;\n  out[2] = W / 2 - 0.5 * (x0 + x1);\n  out[3] = H / 2 - 0.5 * (y0 + y1);\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The colour scale: cyan for round pieces through blue, violet, magenta and\n// rose to a pale amber for flat ones.\nfunction palette(s) {\n  for (let n = 0; n \u003c NL; n++) {\n    const t = n / (NL - 1);\n    hsv(s.hue + 0.48 + 0.64 * t, 0.9 - 0.35 * t ** 6, 0.62 + 0.38 * t, s.lut, n * 3);\n  }\n  s.lutHue = s.hue;\n}\n\nexport function setup(params) {\n  const s = {\n    hue: 0, depth: 2, steer: 0,\n    // Stored triangles in world coordinates: 0 is the current one, j its j-th\n    // ancestor; path[j] is the child taken from j + 1 to j.\n    tri: new Float64Array((KEEP + 1) * 6), path: new Int8Array(KEEP + 1), nA: 1,\n    // The planned line of descent: plan[0] leads from the current triangle to\n    // the next, plan[1] and plan[2] on from there.\n    next: 0, plan: new Int8Array(3), dz: new Float64Array(4), u: 0, level: 0, ang: 60,\n    ow: new Float32Array(W * H), ot: new Float64Array(24),\n    gain: 1, fading: 0, lut: new Float64Array(NL * 3), lutHue: -1, tmp: new Float64Array(36),\n    // Drawing: one triangle per depth of the walk, the path as seen from the\n    // oldest kept triangle, and the frame.\n    P: new Float64Array(40 * 6), pc: new Int8Array(KEEP + 2), A: 0, tgt: 0, w: 0, spIn: 1, spOut: 1,\n    fb: new Float32Array(W * H * 3), mark: new Uint8Array(W * H),\n  };\n  params.s = s;\n  // The first update reads the knobs and then plans the first steps.\n  s.fresh = true;\n}\n\nfunction restart(s) {\n  // An equilateral triangle, turned at random, then framed.\n  const th = Math.random() * 2 * PI, t = s.tri;\n  for (let v = 0; v \u003c 3; v++) {\n    t[2 * v] = cos(th + (v * 2 * PI) / 3);\n    t[2 * v + 1] = sin(th + (v * 2 * PI) / 3);\n  }\n  frame(t, 0, s.dz);\n  apply(t, 0, s.dz);\n  s.nA = 1;\n  s.u = 0;\n  s.level = 0;\n  s.ang = 60;\n  const k = s.tmp;\n  for (let v = 0; v \u003c 6; v++) k[v] = t[v];\n  for (let m = 0; m \u003c 3; m++) {\n    s.plan[m] = pick(s, k, m * 6);\n    child(k, m * 6, s.plan[m], k, m * 6 + 6);\n  }\n  aim(s);\n}\n\nfunction apply(t, o, z) {\n  for (let v = o; v \u003c o + 6; v += 2) {\n    const x = t[v], y = t[v + 1];\n    t[v] = z[0] * x - z[1] * y + z[2];\n    t[v + 1] = z[1] * x + z[0] * y + z[3];\n  }\n}\n\n// Picks a child of triangle t: at random, or with chance Steer the roundest\n// one; between children of the same shape, the one the camera reaches with\n// the smallest turn.\nfunction pick(s, t, o) {\n  let c = floor(Math.random() * 6) % 6;\n  if (Math.random() \u003c s.steer) {\n    const k = s.ot, z = [0, 0, 0, 0];\n    let bv = 1e9, bt = 1e9;\n    for (let n = 0; n \u003c 6; n++) {\n      child(t, o, n, k, 0);\n      const a = bigAngle(k, 0);\n      frame(k, 0, z);\n      const turn = abs(atan2(z[1], z[0]));\n      if (a \u003c bv - 1e-6 || (a \u003c bv + 1e-6 && turn \u003c bt)) (bv = min(bv, a)), (bt = turn), (c = n);\n    }\n  }\n  return c;\n}\n\n// The similarity that frames the next triangle.\nfunction aim(s) {\n  s.next = s.plan[0];\n  child(s.tri, 0, s.next, s.tmp, 0);\n  frame(s.tmp, 0, s.dz);\n}\n\nfunction advance(s) {\n  const t = s.tri, z = s.dz;\n  for (let j = 0; j \u003c s.nA; j++) apply(t, j * 6, z);\n  const keep = min(s.nA, KEEP);\n  for (let j = keep; j > 0; j--) {\n    for (let v = 0; v \u003c 6; v++) t[j * 6 + v] = t[(j - 1) * 6 + v];\n    s.path[j] = s.path[j - 1];\n  }\n  child(t, 6, s.next, t, 0);\n  s.path[0] = s.next;\n  s.nA = keep + 1;\n  s.level++;\n  s.ang = bigAngle(t, 0);\n  if (s.ang > FLAT && !s.fading) s.fading = 1;\n  const k = s.tmp, pl = s.plan;\n  pl[0] = pl[1];\n  pl[1] = pl[2];\n  child(t, 0, pl[0], k, 0);\n  child(k, 0, pl[1], k, 6);\n  pl[2] = pick(s, k, 6);\n  aim(s);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.depth = cl(k[2], 2, 3);\n  s.steer = cl((k[3] - 0.1) / 0.9, 0, 1);\n  if (s.fresh) {\n    s.fresh = false;\n    restart(s);\n  }\n  if (input.btnPressed && input.btnPressed[0] && !s.fading) s.fading = 2;\n  if (s.fading) {\n    // Fade out, start again, fade in.\n    s.gain -= d * (s.fading === 2 ? 4 : 1.5);\n    if (s.gain \u003c= 0) {\n      s.gain = 0;\n      s.fading = 0;\n      restart(s);\n    }\n  } else s.gain = min(1, s.gain + d * 1.5);\n  s.u += (d * sp) / LEVEL;\n  while (s.u >= 1) {\n    s.u -= 1;\n    advance(s);\n  }\n}\n\n// Fills one triangle's LEDs: the colour, darkened near the parent's sides\n// (heights hc2 and hj) at weight wl and near the child's own inner sides\n// (heights hc0, hc1) at weight wk.\nfunction raster(s, X0, Y0, X1, Y1, X2, Y2, r, g, b, hc0, hc1, hc2, hj, wl, wk) {\n  const ex = X1 - X0, ey = Y1 - Y0, fx = X2 - X0, fy = Y2 - Y0, dd = ex * fy - fx * ey;\n  if (!(abs(dd) > 1e-12)) return;\n  const a1 = fy / dd, b1 = -fx / dd, c1 = (fx * Y0 - fy * X0) / dd;\n  const a2 = -ey / dd, b2 = ex / dd, c2 = (ey * X0 - ex * Y0) / dd;\n  const a0 = -a1 - a2, b0 = -b1 - b2, c0 = 1 - c1 - c2;\n  const ya = max(0, Math.ceil(min(Y0, Y1, Y2) - 0.5)), yb = min(H - 1, floor(max(Y0, Y1, Y2) - 0.5));\n  const xa = max(0, Math.ceil(min(X0, X1, X2) - 0.5)), xb = min(W - 1, floor(max(X0, X1, X2) - 0.5));\n  const { fb, mark } = s;\n  for (let y = ya; y \u003c= yb; y++) {\n    const py = y + 0.5;\n    let lo = xa, hi = xb;\n    for (let e = 0; e \u003c 3; e++) {\n      const a = e === 0 ? a0 : e === 1 ? a1 : a2, bt = e === 0 ? b0 * py + c0 : e === 1 ? b1 * py + c1 : b2 * py + c2;\n      if (a > 1e-12) {\n        const x = Math.ceil(-bt / a - 0.5);\n        if (x > lo) lo = x;\n      } else if (a \u003c -1e-12) {\n        const x = floor(-bt / a - 0.5);\n        if (x \u003c hi) hi = x;\n      } else if (bt \u003c 0) hi = -1;\n    }\n    for (let x = lo; x \u003c= hi; x++) {\n      const px = x + 0.5, q1 = a1 * px + b1 * py + c1, q2 = a2 * px + b2 * py + c2, q0 = 1 - q1 - q2;\n      let dl = q2 * hc2, dk = q0 * hc0;\n      const dj = (0.5 * q1 + q2 / 3) * hj, d1 = q1 * hc1;\n      if (dj \u003c dl) dl = dj;\n      if (d1 \u003c dk) dk = d1;\n      const el = wl * (1 - cl((dl - 0.15) / 0.6, 0, 1)), ek = wk * (1 - cl((dk - 0.15) / 0.6, 0, 1));\n      const f = 1 - 0.8 * (el > ek ? el : ek), i = y * W + x;\n      fb[i * 3] = r * f;\n      fb[i * 3 + 1] = g * f;\n      fb[i * 3 + 2] = b * f;\n      mark[i] = 1;\n    }\n  }\n}\n\n// Draws the six children of the triangle at depth d, each in a mix of its\n// parent's colour and its own at weight w, with its inner sides at weight w.\nfunction emit(s, d, w, on, inT, A2, l0, l1, l2) {\n  const P = s.P, o = d * 6, q = o + 6, lut = s.lut;\n  let id = floor(heat(P, o) * (NL - 1)) * 3;\n  const nr = lut[id], ng = lut[id + 1], nb = lut[id + 2];\n  const s0 = sqrt(l0), s1 = sqrt(l1), s2 = sqrt(l2);\n  const wl = cl((A2 / (s0 + s1 + s2) - 0.3) / 0.9, 0, 1), ca = A2 / 6;\n  for (let c = 0; c \u003c 6; c++) {\n    child(P, o, c, P, q);\n    let r = nr, g = ng, b = nb;\n    if (w > 0) {\n      id = floor(heat(P, q) * (NL - 1)) * 3;\n      r += (lut[id] - nr) * w;\n      g += (lut[id + 1] - ng) * w;\n      b += (lut[id + 2] - nb) * w;\n    }\n    const X0 = P[q], Y0 = P[q + 1], X1 = P[q + 2], Y1 = P[q + 3], X2 = P[q + 4], Y2 = P[q + 5];\n    const k0 = Math.hypot(X1 - X2, Y1 - Y2), k1 = Math.hypot(X2 - X0, Y2 - Y0), k2 = Math.hypot(X0 - X1, Y0 - Y1);\n    const wk = w * cl((ca / (k0 + k1 + k2) - 0.3) / 0.9, 0, 1);\n    const sp = inT || (on && d === s.A && c === s.next) ? s.spIn : s.spOut;\n    const j = CJ[c], hj = A2 / (j === 0 ? s0 : j === 1 ? s1 : s2);\n    raster(s, X0, Y0, X1, Y1, X2, Y2, r * sp, g * sp, b * sp, ca / k0, ca / k1, ca / k2, hj, wl, wk);\n  }\n}\n\n// Walks the subdivision from the oldest kept triangle down to the mosaic's\n// level, skipping triangles off the panel.\nfunction walk(s, d, on, inT) {\n  const P = s.P, o = d * 6;\n  const x0 = P[o], y0 = P[o + 1], x1 = P[o + 2], y1 = P[o + 3], x2 = P[o + 4], y2 = P[o + 5];\n  if (max(x0, x1, x2) \u003c 0 || min(x0, x1, x2) > W || max(y0, y1, y2) \u003c 0 || min(y0, y1, y2) > H) return;\n  const A2 = abs((x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0));\n  const l0 = (x1 - x2) ** 2 + (y1 - y2) ** 2, l1 = (x2 - x0) ** 2 + (y2 - y0) ** 2, l2 = (x0 - x1) ** 2 + (y0 - y1) ** 2;\n  const open = (d \u003c s.tgt ? 1 : s.w) * cl((A2 / sqrt(max(l0, l1, l2)) - LOD) / LOD, 0, 1);\n  if (open >= 1 && d \u003c s.tgt) {\n    for (let c = 0; c \u003c 6; c++) {\n      child(P, o, c, P, o + 6);\n      const oc = on && d \u003c= s.A && c === s.pc[d];\n      walk(s, d + 1, oc, inT || (oc && d === s.A));\n    }\n  } else emit(s, d, open, on, inT, A2, l0, l1, l2);\n}\n\nfunction outline(ow, t, o, al) {\n  for (let e = 0; e \u003c 6; e += 2) {\n    const ax = t[o + e], ay = t[o + e + 1], bx = t[o + ((e + 2) % 6)], by = t[o + ((e + 3) % 6)];\n    const n = Math.ceil(Math.hypot(bx - ax, by - ay) * 2.5) + 1;\n    for (let i = 0; i \u003c= n; i++) {\n      const x = floor(ax + ((bx - ax) * i) / n), y = floor(ay + ((by - ay) * i) / n);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H && ow[y * W + x] \u003c al) ow[y * W + x] = al;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || s.fresh) return;\n  if (s.lutHue !== s.hue) palette(s);\n  const { tri, dz, P, fb, mark } = s;\n  // The camera: the spiral similarity from this triangle's frame to the next\n  // one, raised to the eased progress v, about its fixed point.\n  const u = s.u, v = u - (0.7 * sin(2 * PI * u)) / (2 * PI);\n  const ar = dz[0], ai = dz[1], den = (1 - ar) * (1 - ar) + ai * ai;\n  const qr = (dz[2] * (1 - ar) - dz[3] * ai) / den, qi = (dz[3] * (1 - ar) + dz[2] * ai) / den;\n  const ls = log(Math.hypot(ar, ai)) * v, th = atan2(ai, ar) * v;\n  const mr = exp(ls) * cos(th), mi = exp(ls) * sin(th);\n  const A = s.nA - 1;\n  for (let c = 0; c \u003c 6; c += 2) {\n    const x = tri[A * 6 + c] - qr, y = tri[A * 6 + c + 1] - qi;\n    P[c] = qr + mr * x - mi * y;\n    P[c + 1] = qi + mi * x + mr * y;\n  }\n  for (let d = 0; d \u003c A; d++) s.pc[d] = s.path[A - 1 - d];\n  s.pc[A] = s.next;\n  s.A = A;\n  // The mosaic's depth below the current triangle runs on with the dive, so\n  // the next level fades in as the camera closes in.\n  const e = s.depth + v, L = floor(e);\n  s.tgt = A + L;\n  s.w = e - L;\n  const { ow, ot, plan } = s;\n  for (let c = 0; c \u003c 6; c += 2) {\n    const x = tri[c] - qr, y = tri[c + 1] - qi;\n    ot[c] = qr + mr * x - mi * y;\n    ot[c + 1] = qi + mi * x + mr * y;\n  }\n  // Mid-dive the next triangle is lit and the rest dimmed, while the current\n  // triangle is wide enough on the panel to be cut.\n  const l0 = (ot[2] - ot[4]) ** 2 + (ot[3] - ot[5]) ** 2, l1 = (ot[4] - ot[0]) ** 2 + (ot[5] - ot[1]) ** 2, l2 = (ot[0] - ot[2]) ** 2 + (ot[1] - ot[3]) ** 2;\n  const tall = abs((ot[2] - ot[0]) * (ot[5] - ot[1]) - (ot[4] - ot[0]) * (ot[3] - ot[1])) / sqrt(max(l0, l1, l2));\n  const g = tall > 2 * LOD ? sin(PI * v) ** 2 : 0;\n  s.spIn = 1 + 0.15 * g;\n  s.spOut = 1 - 0.3 * g;\n  fb.fill(0);\n  mark.fill(0);\n  walk(s, 0, true, false);\n  // The planned line of descent in white: the next triangle and the two inside\n  // it, each outline coming up as the one before it is reached.\n  ow.fill(0);\n  for (let m = 0; m \u003c 3; m++) {\n    child(ot, m * 6, plan[m], ot, m * 6 + 6);\n    const x = m + 1 - v, al = x \u003c 1 ? 0.5 * x : x \u003c 2 ? 0.5 - 0.2 * (x - 1) : 0.3 * (3 - x);\n    if (al > 0.01) outline(ow, ot, m * 6 + 6, al);\n  }\n  // An LED whose centre fell exactly on a shared side takes its neighbour's colour.\n  const ex = P[2] - P[0], ey = P[3] - P[1], fx = P[4] - P[0], fy = P[5] - P[1], dd = ex * fy - fx * ey;\n  const gain = s.gain * 255;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let i = y * W + x;\n      if (!mark[i]) {\n        const px = x + 0.5 - P[0], py = y + 0.5 - P[1];\n        const b1 = (px * fy - py * fx) / dd, b2 = (ex * py - ey * px) / dd;\n        if (b1 \u003c 0 || b2 \u003c 0 || b1 + b2 > 1) {\n          display.setPixel(x, y, 0, 0, 0);\n          continue;\n        }\n        if (x > 0 && mark[i - 1]) i--;\n        else if (y > 0 && mark[i - W]) i -= W;\n        else if (x \u003c W - 1 && mark[i + 1]) i++;\n      }\n      const w = ow[y * W + x], f = 1 - w;\n      display.setPixel(x, y, (fb[i * 3] * f + w) * gain, (fb[i * 3 + 1] * f + w) * gain, (fb[i * 3 + 2] * f + w) * gain);\n    }\n}\n","belt-trick":"// ===== Patternflow pattern =====\n// Title:   Belt Trick\n// Family:  topology\n// Idea:    A cube in the middle of the panel, tied by ribbons to bars along the top and bottom edges, turns about one axis without stopping: after one full turn the ribbons are wound round it and no moving of the ribbons alone can free them, after the second they have swung round the cube and hang straight again, and a ring behind it fills once a turn, violet in the first and green in the second, so the two turns can be told apart.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dirac's string problem (Paul Dirac; M. H. A. Newman, 1942), the double cover of SO(3) by the unit quaternions, pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ribbons=2..8, Tilt=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the ribbons are amber on the front and cyan on the back, the cube's faces blue, violet and pink, and the ring violet in the first turn and green in the second.\n// Knob 2: Speed. At 2 the cube turns once in 4 seconds, so the ribbons come free every 8; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Ribbons. How many ribbons tie the cube, from 2, one belt up and one down, to 8, four each way. Fewer ribbons are wider. Neighbours also sit 4 apart in depth: over a whole loop no two ribbons come closer than 0.6 LEDs with 8 of them, 0.8 with 4 and 4.8 with 2.\n// Knob 4: Tilt. The spin axis. At 0 it stands upright and the cube turns like a plate on a waiter's hand, and after one turn the ribbons lie wound round it in the plane of the panel; at 1 it points at us, the cube turns like a wheel, and after one turn the ribbons are twisted round each other like a rope.\n// Buttons: K1 tap reverses the spin.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, ceil, sqrt, sin, cos, abs, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The cube's half side, the ball it turns in, the shell the ribbons move in,\n// and the wall the ribbons are tied to, just past the panel's top and bottom.\nconst HC = 8, RIN = HC * sqrt(3) + 1.2, ROUT = 30.5, YW = 67;\n// Rows of a ribbon inside the shell.\nconst NS = 110;\n// Camera: turned a little to the right and looking a little down.\nconst DIST = 170, YAW = 0.42, PITCH = 0.16, CX = 31.5, CY = 63.5;\nconst CYW = cos(YAW), SYW = sin(YAW), CP = cos(PITCH), SP = sin(PITCH);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [\n    i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p,\n    i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p,\n    i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p,\n  ];\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  params.s = {\n    t: 0, dir: 1, hue: 0, sp: 2, n: 2, tilt: 0.06,\n    zb: F(N), id: new Int16Array(N), col: F(N * 3),\n    // Mapped ribbon vertices (world) and their screen places.\n    wx: F(2 * NS + 8), wy: F(2 * NS + 8), wz: F(2 * NS + 8), sx: F(2 * NS + 8), sy: F(2 * NS + 8), sz: F(2 * NS + 8),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  s.sp = cl(k[1], 0.2, 3);\n  s.n = cl(Math.round(k[2]), 2, 8);\n  s.tilt = cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) s.dir = -s.dir;\n  // t runs 0..1 over the two turns, 720 degrees.\n  s.t += (s.dir * d * s.sp) / 16;\n  s.t -= floor(s.t);\n}\n\n// The homotopy. q(t) = cos(2 pi t) + sin(2 pi t) a is the cube's turn by\n// 720 degrees about the unit axis a, a loop in the unit quaternions. With\n// b = s pi / 2 and v a unit vector at right angles to a,\n//   H(s, t) = (cos^2 b + sin^2 b cos 2 pi t) + (sin b sin 2 pi t) a + (cos b sin b (1 - cos 2 pi t)) v.\n// For each s, t runs H round a circle in the 3-sphere that passes through 1\n// and touches the loop there; the circles shrink from the loop itself at\n// s = 1 to the point 1 at s = 0. H has length 1, H(0, t) = 1, H(1, t) = q(t)\n// and H(s, 0) = H(s, 1) = 1. At t = 1/2 it is a turn by 360 s degrees about\n// v: the ribbons wound once round the cube. s is read off the distance from\n// the cube's centre, 0 at the shell's outer sphere and 1 at its inner one,\n// so every sphere round the cube turns as one piece and nothing in space\n// ever passes through anything else.\nfunction shellTurn(x, y, z, ax, ay, az, vx, vy, vz, C, S, out, o) {\n  const r = sqrt(x * x + y * y + z * z);\n  let u = cl((ROUT - r) / (ROUT - RIN), 0, 1);\n  u = u * u * (3 - 2 * u);\n  const b = (u * PI) / 2, cb = cos(b), sb = sin(b);\n  const w = cb * cb + sb * sb * C, p = sb * S, q = cb * sb * (1 - C);\n  rot(w, p * ax + q * vx, p * ay + q * vy, p * az + q * vz, x, y, z, out, o);\n}\n\n// Turn (x, y, z) by the unit quaternion w + (i, j, k).\nfunction rot(w, i, j, k, x, y, z, out, o) {\n  const tx = 2 * (j * z - k * y), ty = 2 * (k * x - i * z), tz = 2 * (i * y - j * x);\n  out[o] = x + w * tx + (j * tz - k * ty);\n  out[o + 1] = y + w * ty + (k * tx - i * tz);\n  out[o + 2] = z + w * tz + (i * ty - j * tx);\n}\n\n// World to screen: the camera turns the world, then a soft perspective.\nfunction cam(x, y, z, out, o) {\n  const x1 = x * CYW - z * SYW, z1 = x * SYW + z * CYW;\n  const y2 = y * CP - z1 * SP, z2 = y * SP + z1 * CP;\n  const f = DIST / (DIST - z2);\n  out[o] = CX + x1 * f;\n  out[o + 1] = CY - y2 * f;\n  out[o + 2] = DIST - z2;\n}\n\nconst tmp = new Float32Array(3), hc = new Float32Array(3 * (NS + 3));\n// How much a normal faces the eye.\nconst toEye = (x, y, z) => y * SP + (x * SYW + z * CYW) * CP;\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const { zb, id, col, wx, wy, wz, sx, sy, sz } = s;\n  zb.fill(1e9);\n  id.fill(0);\n  const al = ((1 - s.tilt) * PI) / 2;\n  const ax = 0, ay = sin(al), az = cos(al), vx = 0, vy = cos(al), vz = -sin(al);\n  const C = cos(TAU * s.t), S = sin(TAU * s.t);\n  const L = [0.42, 0.55, 0.72];\n  const h0 = s.hue;\n  const fr = hsv(h0 + 0.1, 0.85, 1), bk = hsv(h0 + 0.5, 0.75, 1);\n  const n = s.n, nt = ceil(n / 2);\n  let rib = 0;\n  for (let side = 0; side \u003c 2; side++) {\n    const k = side ? n - nt : nt, sg = side ? -1 : 1;\n    const spc = (1.75 * HC) / k, wdt = min(8.5, 0.5 * spc), spw = 46 / k;\n    for (let r = 0; r \u003c k; r++, rib++) {\n      // Neighbours sit 4 apart in depth as well, which keeps them about\n      // twice as far apart when they are wound round the cube.\n      const zs = k > 1 ? ((r + side) & 1 ? 2 : -2) : 0;\n      const off = r - (k - 1) / 2;\n      const Ax = off * spw, Ay = sg * YW, Bx = off * spc, By = sg * HC;\n      const dx = Bx - Ax, dy = By - Ay, len = sqrt(dx * dx + dy * dy);\n      // Across the ribbon, in the panel's plane.\n      const bx = (dy / len) * sg, by = (-dx / len) * sg;\n      // Where the centre line crosses the shell's spheres.\n      const uo = cross(Ax, Ay, dx, dy, sqrt((ROUT + 1) ** 2 - zs * zs)), ui = cross(Ax, Ay, dx, dy, sqrt((RIN - 0.5) ** 2 - zs * zs));\n      const rows = NS + 3;\n      for (let j = 0; j \u003c rows; j++) {\n        const u = j === 0 ? 0 : j === rows - 1 ? 1 : uo + ((ui - uo) * (j - 1)) / NS;\n        const cxp = Ax + dx * u, cyp = Ay + dy * u;\n        for (let e = 0; e \u003c 2; e++) {\n          const h = (e ? 0.5 : -0.5) * wdt, vi = j * 2 + e;\n          shellTurn(cxp + bx * h, cyp + by * h, zs, ax, ay, az, vx, vy, vz, C, S, tmp, 0);\n          wx[vi] = tmp[0];\n          wy[vi] = tmp[1];\n          wz[vi] = tmp[2];\n          cam(tmp[0], tmp[1], tmp[2], tmp, 0);\n          sx[vi] = tmp[0];\n          sy[vi] = tmp[1];\n          sz[vi] = tmp[2];\n        }\n      }\n      for (let j = 0; j \u003c rows - 1; j++) {\n        const a = j * 2, b = a + 1, c = a + 2, dd = a + 3;\n        // The face's normal in the world, for the light.\n        const ux = wx[c] - wx[a], uy = wy[c] - wy[a], uz = wz[c] - wz[a];\n        const qx = wx[b] - wx[a], qy = wy[b] - wy[a], qz = wz[b] - wz[a];\n        let nx = uy * qz - uz * qy, ny = uz * qx - ux * qz, nz = ux * qy - uy * qx;\n        const nl = 1 / (sqrt(nx * nx + ny * ny + nz * nz) + 1e-9);\n        nx *= nl;\n        ny *= nl;\n        nz *= nl;\n        // Which face is towards us: the sign of the quad's area on the screen.\n        const area = (sx[a] - sx[dd]) * (sy[b] - sy[c]) - (sx[b] - sx[c]) * (sy[a] - sy[dd]);\n        const front = area * sg \u003c 0;\n        tri(s, a, c, b, rib + 1, nx, ny, nz, front ? fr : bk, L);\n        tri(s, b, c, dd, rib + 1, nx, ny, nz, front ? fr : bk, L);\n        hc[j * 3] = s.lr * 0.8;\n        hc[j * 3 + 1] = s.lg * 0.8;\n        hc[j * 3 + 2] = s.lb * 0.8;\n      }\n      // The hems, drawn as lines, so a ribbon seen edge on stays a line.\n      for (let j = 0; j \u003c rows - 1; j++)\n        for (let e = 0; e \u003c 2; e++) {\n          const a = j * 2 + e, b = a + 2;\n          line(s, sx[a], sy[a], sz[a], sx[b], sy[b], sz[b], rib + 1, hc[j * 3], hc[j * 3 + 1], hc[j * 3 + 2]);\n        }\n    }\n  }\n  cube(s, ax, ay, az, C, S, L);\n  shade(s, display);\n}\n\n// The u where the line (Ax, Ay) + u (dx, dy) is at distance R from the centre.\nfunction cross(Ax, Ay, dx, dy, R) {\n  const a = dx * dx + dy * dy, b = 2 * (Ax * dx + Ay * dy), c = Ax * Ax + Ay * Ay - R * R;\n  const disc = b * b - 4 * a * c;\n  if (disc \u003c 0) return 1;\n  return cl((-b - sqrt(disc)) / (2 * a), 0, 1);\n}\n\nfunction tri(s, i0, i1, i2, idv, nx, ny, nz, c, L) {\n  const { sx, sy, sz } = s;\n  const x0 = sx[i0], y0 = sy[i0], x1 = sx[i1], y1 = sy[i1], x2 = sx[i2], y2 = sy[i2];\n  // Two-sided light: the normal is turned to face the eye.\n  const sgn = toEye(nx, ny, nz) >= 0 ? 1 : -1;\n  const ld = max(0, sgn * (nx * L[0] + ny * L[1] + nz * L[2]));\n  const lit = 0.6 + 0.4 * ld;\n  const r = c[0] * lit, g = c[1] * lit, b = c[2] * lit;\n  (s.lr = r), (s.lg = g), (s.lb = b);\n  fill(s, x0, y0, x1, y1, x2, y2, sz[i0], sz[i1], sz[i2], idv, r, g, b);\n}\n\nfunction line(s, x0, y0, z0, x1, y1, z1, idv, r, g, b) {\n  const { zb, id, col } = s;\n  const n = ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5) + 1;\n  for (let i = 0; i \u003c= n; i++) {\n    const u = i / n, x = floor(x0 + (x1 - x0) * u), y = floor(y0 + (y1 - y0) * u);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const q = y * W + x, d = z0 + (z1 - z0) * u - 0.9;\n    if (d \u003c zb[q]) {\n      zb[q] = d + 0.9;\n      id[q] = idv;\n      col[q * 3] = r;\n      col[q * 3 + 1] = g;\n      col[q * 3 + 2] = b;\n    }\n  }\n}\n\nfunction fill(s, x0, y0, x1, y1, x2, y2, z0, z1, z2, idv, r, g, b) {\n  const { zb, id, col } = s;\n  const den = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(den) \u003c 1e-9) return;\n  const inv = 1 / den;\n  const X0 = max(0, ceil(min(x0, x1, x2) - 0.5)), X1 = min(W - 1, floor(max(x0, x1, x2) - 0.5));\n  const Y0 = max(0, ceil(min(y0, y1, y2) - 0.5)), Y1 = min(H - 1, floor(max(y0, y1, y2) - 0.5));\n  for (let y = Y0; y \u003c= Y1; y++) {\n    const cy = y + 0.5 - y0;\n    for (let x = X0; x \u003c= X1; x++) {\n      const cx = x + 0.5 - x0;\n      const a = (cx * (y2 - y0) - cy * (x2 - x0)) * inv, bb = ((x1 - x0) * cy - (y1 - y0) * cx) * inv;\n      if (a \u003c -1e-6 || bb \u003c -1e-6 || a + bb > 1 + 1e-6) continue;\n      const d = z0 + (z1 - z0) * a + (z2 - z0) * bb, q = y * W + x;\n      if (d \u003c zb[q]) {\n        zb[q] = d;\n        id[q] = idv;\n        col[q * 3] = r;\n        col[q * 3 + 1] = g;\n        col[q * 3 + 2] = b;\n      }\n    }\n  }\n}\n\n// The cube: six faces, each its own colour, turned by q(t).\nconst FACES = [\n  [1, 0, 0, 0, 1, 0, 0, 0, 1], [-1, 0, 0, 0, 1, 0, 0, 0, -1],\n  [0, 1, 0, 0, 0, 1, 1, 0, 0], [0, -1, 0, 0, 0, -1, 1, 0, 0],\n  [0, 0, 1, 1, 0, 0, 0, 1, 0], [0, 0, -1, -1, 0, 0, 0, 1, 0],\n];\nconst cv = new Float32Array(12), cn = new Float32Array(3);\nfunction cube(s, ax, ay, az, C, S, L) {\n  const w = C, i = S * ax, j = S * ay, k = S * az;\n  for (let f = 0; f \u003c 6; f++) {\n    const F = FACES[f];\n    rot(w, i, j, k, F[0], F[1], F[2], cn, 0);\n    const vdot = toEye(cn[0], cn[1], cn[2]);\n    const ld = max(0, cn[0] * L[0] + cn[1] * L[1] + cn[2] * L[2]);\n    const c = hsv(s.hue + 0.62 + 0.13 * (f >> 1), f & 1 ? 0.4 : 0.8, 1);\n    const lit = 0.5 + 0.5 * ld;\n    for (let q = 0; q \u003c 4; q++) {\n      const e = q === 0 || q === 3 ? -1 : 1, g = q \u003c 2 ? -1 : 1;\n      const x = (F[0] + e * F[3] + g * F[6]) * HC, y = (F[1] + e * F[4] + g * F[7]) * HC, z = (F[2] + e * F[5] + g * F[8]) * HC;\n      rot(w, i, j, k, x, y, z, tmp, 0);\n      cam(tmp[0], tmp[1], tmp[2], cv, q * 3);\n    }\n    if (vdot \u003c -0.05) continue;\n    const r = c[0] * lit, gg = c[1] * lit, b = c[2] * lit;\n    fill(s, cv[0], cv[1], cv[3], cv[4], cv[6], cv[7], cv[2], cv[5], cv[8], 20 + f, r, gg, b);\n    fill(s, cv[0], cv[1], cv[6], cv[7], cv[9], cv[10], cv[2], cv[8], cv[11], 20 + f, r, gg, b);\n  }\n}\n\nfunction shade(s, display) {\n  const { id, col } = s;\n  const lap = s.t \u003c 0.5 ? 0 : 1, prog = (s.t * 2) % 1;\n  const ca = hsv(s.hue + 0.78, 0.65, 0.7), cb = hsv(s.hue + 0.36, 0.75, 0.7);\n  const cur = lap ? cb : ca, old = lap ? ca : cb;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3, p = id[q];\n      // The bars the ribbons are tied to, along the top and bottom edges,\n      // with a clamp where a ribbon goes under.\n      if (y \u003c 2 || y > H - 3) {\n        const edge = y === 1 || y === H - 2, tied = edge && id[y === 1 ? q + W : q - W] > 0 && id[y === 1 ? q + W : q - W] \u003c 20;\n        const v = tied ? 170 : edge ? 70 : 40;\n        display.setPixel(x, y, v * 0.85, v * 0.78, v);\n        continue;\n      }\n      if (p) {\n        // A seam where two ribbons or two faces meet.\n        const rp = x \u003c W - 1 ? id[q + 1] : p, dp = y \u003c H - 1 ? id[q + W] : p;\n        const k = (rp && rp !== p) || (dp && dp !== p) ? 150 : 255;\n        display.setPixel(x, y, min(255, col[o] * k), min(255, col[o + 1] * k), min(255, col[o + 2] * k));\n        continue;\n      }\n      // The dial behind the cube: one colour fills it in the first turn,\n      // the other in the second.\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      const ring = cl(1.6 - abs(r - ROUT - 0.6), 0, 1);\n      if (ring > 0) {\n        let a = atan2(dx, -dy) / TAU;\n        if (a \u003c 0) a += 1;\n        const c = a \u003c prog ? cur : old, m = a \u003c prog ? 1 : 0.4;\n        const tip = abs(a - prog) \u003c 0.012 || abs(a - prog) > 0.988 ? 1.6 : 1;\n        display.setPixel(x, y, c[0] * 255 * ring * m * tip, c[1] * 255 * ring * m * tip, c[2] * 255 * ring * m * tip);\n      } else display.setPixel(x, y, 4, 3, 10);\n    }\n}\n","catenoid-helicoid":"// ===== Patternflow pattern =====\n// Title:   Catenoid-Helicoid\n// Family:  space\n// Idea:    A helicoid stands up the panel and turns about its axis while it unwinds into a catenoid and winds up again the other way, a checkerboard painted on it in (u, v) keeping every square the same size and shape the whole time, because the bending stretches nothing.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the catenoid (Leonhard Euler, 1744) bent into the helicoid (Jean Baptiste Meusnier, 1776) without stretching (Edmond Bour, 1862), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Squares=12..36, Tilt=0..1\n//\n// Knob 1: Hue. Turns both faces round the wheel together: at 0 the face that becomes the catenoid's inside is cyan and the other violet, and the dark squares of each sink toward indigo. The line v = 0 stays warm white.\n// Knob 2: Speed. At 2 the surface takes 4 seconds to bend from the helicoid to the catenoid, lingering a little at each end, and turns once about its axis in 20 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Squares. How many checker squares go once round in u: 12 where it opens, where a square is about 9 LEDs on the line v = 0 and 16 at the free edge, and 36 at the top. The count is always even, so the checker closes up across the catenoid's seam.\n// Knob 4: Tilt. How far we look down on the surface: 12 degrees at 0, 15 where it opens, 60 at 1, and the view nods 24 degrees further down as the catenoid forms so we see into its mouth. The scale is set once per tilt from the tallest moment of the bending. It never zooms while the surface bends, so the squares keep their size on the panel too.\n// Buttons: K1 tap holds the bending where it is while the surface keeps turning; tap again to let it go on.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, round, sqrt, sin, cos, abs, pow, sinh, cosh, tanh, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The surface, for the bending angle th:\n//   x =  cos th sinh v sin u + sin th cosh v cos u\n//   y = -cos th sinh v cos u + sin th cosh v sin u\n//   z =  u cos th + v sin th\n// th = 0 is the helicoid, th = pi/2 the catenoid. Its first fundamental\n// form is cosh^2 v (du^2 + dv^2) for every th, so a square in (u, v)\n// stays a square, and its normal (cos u / cosh v, sin u / cosh v, -tanh v)\n// does not depend on th either.\nconst U = PI, V = 1.15;\nconst NU = 96, NV = 30, VU = NU + 1, VV = NV + 1, NPT = VU * VV;\nconst CAM = 12, CX = 31.5, CY = 63.5;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  const s = {\n    t: 0, b: 0, phi: 0.35, hold: false, hue: 0, squares: 12, tilt: 0.06, scaleTilt: -1, S: 18,\n    gu: F(NPT), gv: F(NPT), su: F(NPT), cu: F(NPT), sh: F(NPT), ch: F(NPT),\n    sx: F(NPT), sy: F(NPT), sd: F(NPT),\n    zb: F(N), pu: F(N), pv: F(N), side: new Int8Array(N), col: F(N * 3),\n    pal: F(12), palHue: -1,\n  };\n  for (let j = 0; j \u003c VV; j++)\n    for (let i = 0; i \u003c VU; i++) {\n      const k = j * VU + i, u = -U + (2 * U * i) / NU, v = -V + (2 * V * j) / NV;\n      s.gu[k] = u;\n      s.gv[k] = v;\n      s.su[k] = sin(u);\n      s.cu[k] = cos(u);\n      s.sh[k] = sinh(v);\n      s.ch[k] = cosh(v);\n    }\n  params.s = s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 12, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.squares = 2 * round(cl(k[2], 12, 36) / 2);\n  s.tilt = cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) s.hold = !s.hold;\n  s.t += d * sp;\n  s.phi += d * sp * 0.157;\n  if (!s.hold) s.b += d * sp * 0.125;\n}\n\n// The bending angle: a quarter turn of th per unit of b, slowed near the\n// helicoid and the catenoid so each end holds for a moment.\nfunction bend(b) {\n  const n = floor(b), f = b - n;\n  return (PI / 2) * (n + f - (0.7 * sin(TAU * f)) / TAU);\n}\n\n// The camera nods down as the catenoid forms, so we look into its mouth.\nconst look = (e0, st) => min(1.25, e0 + 0.42 * st * st);\n\n// One scale per tilt: the largest the surface ever gets on the panel over\n// the whole bending and every turn, so the picture never zooms.\nfunction fit(s, e0) {\n  let mu = 0, mx = 0;\n  for (let a = 0; a \u003c= 24; a++) {\n    const th = (PI / 2) * (a / 24), ct = cos(th), st = sin(th), e = look(e0, st), ce = cos(e), se = sin(e);\n    for (let r = 0; r \u003c 16; r++) {\n      const ph = (TAU * r) / 16, cp = cos(ph), spn = sin(ph);\n      for (let q = 0; q \u003c 48; q++) {\n        let u, v;\n        if (q \u003c 16) (u = q \u003c 8 ? -U : U), (v = -V + (2 * V * (q % 8)) / 7);\n        else (u = -U + (2 * U * (q - 16)) / 31), (v = q & 1 ? V : -V);\n        const x = ct * sinh(v) * sin(u) + st * cosh(v) * cos(u), y = -ct * sinh(v) * cos(u) + st * cosh(v) * sin(u), z = u * ct + v * st;\n        const xr = x * cp - y * spn, yr = x * spn + y * cp;\n        const dep = yr * ce - z * se, up = yr * se + z * ce, f = CAM / (CAM + dep);\n        mu = max(mu, abs(up * f));\n        mx = max(mx, abs(xr * f));\n      }\n    }\n  }\n  s.S = min(65 / mu, 33.5 / mx);\n  s.scaleTilt = s.tilt;\n}\n\nfunction palette(s) {\n  // Light and dark squares of the outer face, then of the inner face.\n  // A dark square is its light square at 0.4 over an indigo floor, so a\n  // warm face darkens toward plum rather than brown or olive.\n  hsv(s.hue + 0.52, 0.5, 1, s.pal, 0);\n  hsv(s.hue + 0.8, 0.45, 1, s.pal, 6);\n  for (const o of [0, 6]) {\n    s.pal[o + 3] = 0.4 * s.pal[o] + 0.1;\n    s.pal[o + 4] = 0.4 * s.pal[o + 1] + 0.03;\n    s.pal[o + 5] = 0.4 * s.pal[o + 2] + 0.28;\n  }\n  s.palHue = s.hue;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  if (s.palHue !== s.hue) palette(s);\n  const e0 = ((12 + 48 * s.tilt) * PI) / 180;\n  if (s.scaleTilt !== s.tilt) fit(s, e0);\n  const th = bend(s.b), ct = cos(th), st = sin(th), cp = cos(s.phi), spn = sin(s.phi), S = s.S;\n  const e = look(e0, st), ce = cos(e), se = sin(e);\n  const { gu, gv, su, cu, sh, ch, sx, sy, sd, zb, pu, pv, side, col, pal } = s;\n  for (let k = 0; k \u003c NPT; k++) {\n    const x = ct * sh[k] * su[k] + st * ch[k] * cu[k], y = -ct * sh[k] * cu[k] + st * ch[k] * su[k], z = gu[k] * ct + gv[k] * st;\n    const xr = x * cp - y * spn, yr = x * spn + y * cp;\n    const dep = yr * ce - z * se, up = yr * se + z * ce, f = (S * CAM) / (CAM + dep);\n    sx[k] = CX + f * xr;\n    sy[k] = CY - f * up;\n    sd[k] = dep;\n  }\n  zb.fill(1e9);\n  side.fill(0);\n  for (let j = 0; j \u003c NV; j++)\n    for (let i = 0; i \u003c NU; i++) {\n      const a = j * VU + i;\n      tri(s, a, a + 1, a + VU + 1);\n      tri(s, a, a + VU + 1, a + VU);\n    }\n  const n = s.squares, dl = TAU / n;\n  // Light from the upper left, in front: (screen x, depth, screen up).\n  const LX = -0.45, LD = -0.62, LU = 0.64, HD = LD - 1, HL = 1 / sqrt(LX * LX + LU * LU + HD * HD);\n  const lw = 0.62 / S;\n  for (let q = 0; q \u003c N; q++) {\n    const o = q * 3, sd0 = side[q];\n    if (!sd0) {\n      col[o] = col[o + 1] = col[o + 2] = 0;\n      continue;\n    }\n    const u = pu[q], v = pv[q], cv = cosh(v);\n    // The normal, the same for every th, turned with the surface.\n    const nx = cos(u) / cv, ny = sin(u) / cv, nz = -tanh(v);\n    let mx = nx * cp - ny * spn;\n    const nyr = nx * spn + ny * cp;\n    let md = nyr * ce - nz * se, mu = nyr * se + nz * ce;\n    if (md > 0) (mx = -mx), (md = -md), (mu = -mu);\n    const ld = max(0, mx * LX + md * LD + mu * LU), hh = max(0, (mx * LX + md * HD + mu * LU) * HL);\n    // Light falls off toward an indigo shade rather than toward black.\n    const spc = pow(hh, 24) * 0.45, lit = 0.2 + 0.8 * ld, sh0 = (1 - ld) * 0.16;\n    const par = (floor((u + U) / dl) + floor(v / dl)) & 1, c = (sd0 > 0 ? 0 : 6) + par * 3;\n    let r = pal[c] * lit + 0.3 * sh0 + spc, g = pal[c + 1] * lit + 0.1 * sh0 + spc, b = pal[c + 2] * lit + sh0 + spc;\n    // The line v = 0: the helicoid's axis and the catenoid's waist, the\n    // same length 2 pi all the way through the bending.\n    if (abs(v) \u003c lw) (r = 1 * (0.45 + 0.55 * lit)), (g = 0.86 * (0.45 + 0.55 * lit)), (b = 0.62 * (0.45 + 0.55 * lit));\n    col[o] = r;\n    col[o + 1] = g;\n    col[o + 2] = b;\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3;\n      if (side[q]) {\n        // Where one sheet passes in front of another, or the ribbon turns\n        // over at a fold, a darker LED keeps the two apart.\n        let k = 255;\n        const rq = x \u003c W - 1 ? q + 1 : q, dq = y \u003c H - 1 ? q + W : q;\n        if ((side[rq] && (side[rq] !== side[q] || abs(zb[rq] - zb[q]) > 0.4)) || (side[dq] && (side[dq] !== side[q] || abs(zb[dq] - zb[q]) > 0.4))) k = 120;\n        display.setPixel(x, y, min(255, col[o] * k), min(255, col[o + 1] * k), min(255, col[o + 2] * k));\n        continue;\n      }\n      // An empty LED on the outline takes a little of its lit neighbours.\n      let r = 0, g = 0, b = 0;\n      if (x > 0 && side[q - 1]) (r += col[o - 3]), (g += col[o - 2]), (b += col[o - 1]);\n      if (x \u003c W - 1 && side[q + 1]) (r += col[o + 3]), (g += col[o + 4]), (b += col[o + 5]);\n      if (y > 0 && side[q - W]) (r += col[o - W * 3]), (g += col[o - W * 3 + 1]), (b += col[o - W * 3 + 2]);\n      if (y \u003c H - 1 && side[q + W]) (r += col[o + W * 3]), (g += col[o + W * 3 + 1]), (b += col[o + W * 3 + 2]);\n      display.setPixel(x, y, r * 22, g * 22, b * 22);\n    }\n}\n\n// One triangle of the (u, v) grid into the depth buffer. Its winding on\n// the screen says which face of the surface we see there.\nfunction tri(s, i0, i1, i2) {\n  const { sx, sy, sd, gu, gv, zb, pu, pv, side } = s;\n  const x0 = sx[i0], y0 = sy[i0], x1 = sx[i1], y1 = sy[i1], x2 = sx[i2], y2 = sy[i2];\n  const den = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(den) \u003c 1e-9) return;\n  const inv = 1 / den, sg = den > 0 ? 1 : -1;\n  const X0 = max(0, Math.ceil(min(x0, x1, x2) - 0.5)), X1 = min(W - 1, floor(max(x0, x1, x2) - 0.5));\n  const Y0 = max(0, Math.ceil(min(y0, y1, y2) - 0.5)), Y1 = min(H - 1, floor(max(y0, y1, y2) - 0.5));\n  if (X0 > X1 || Y0 > Y1) return;\n  const z0 = sd[i0], dz1 = sd[i1] - z0, dz2 = sd[i2] - z0;\n  const u0 = gu[i0], du1 = gu[i1] - u0, du2 = gu[i2] - u0, v0 = gv[i0], dv1 = gv[i1] - v0, dv2 = gv[i2] - v0;\n  for (let y = Y0; y \u003c= Y1; y++) {\n    const cy = y + 0.5 - y0;\n    for (let x = X0; x \u003c= X1; x++) {\n      const cx = x + 0.5 - x0;\n      const a = (cx * (y2 - y0) - cy * (x2 - x0)) * inv, b = ((x1 - x0) * cy - (y1 - y0) * cx) * inv;\n      if (a \u003c -1e-6 || b \u003c -1e-6 || a + b > 1 + 1e-6) continue;\n      const dd = z0 + dz1 * a + dz2 * b, q = y * W + x;\n      if (dd \u003c zb[q]) (zb[q] = dd), (pu[q] = u0 + du1 * a + du2 * b), (pv[q] = v0 + dv1 * a + dv2 * b), (side[q] = sg);\n    }\n  }\n}\n","costas-array":"// ===== Patternflow pattern =====\n// Title:   Costas Array\n// Family:  rhythm\n// Idea:    A Costas array plays as a frequency-hopping rhythm in the top half while a ghost copy of it spirals out through the shifts in time and pitch, flashing where it lands on a dot, and the bottom half fills in one cell per shift with how many dots met: noughts and ones all the way out, and one spike of N at the centre.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Costas arrays (John P. Costas, 1965, published 1984), with the Welch and Lempel-Golomb constructions (Solomon W. Golomb, 1984), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Field=0..8, Rival=0..3\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the array's dots are sea green, the ghost copy rose, a single meeting in the map green and a crowd of them rose fading to white.\n// Knob 2: Speed. At 2 the playhead strikes 5.5 columns a second at order 10 and 10.5 at order 30. The ghost takes 1.2 (2N - 1) steps a second and stays one step on an empty shift, four on a meeting and up to seven on a crowd, so the order 10 map is full in 15 seconds and the order 30 map in 43. 0.2 is ten times slower and 3 half as fast again.\n// Knob 3: Field. The finite field the arrays are built over, one of 11, 13, 16, 17, 19, 23, 29, 31 and 32 elements. A prime p gives Welch arrays of order p - 1 and Lempel-Golomb arrays of order p - 2; 16 and 32 give Lempel-Golomb arrays of order 14 and 30. The field of 11 opens on the Welch array of 2^i mod 11.\n// Knob 4: Rival. Swaps the array for a permutation that is not a Costas array and keeps the scan where it is. 0 is the Costas array and 1 a shuffle of the same order, whose map picks up a few twos and threes. 2 is the folded chirp i -> a*i mod N, a lattice of tall counts, and 3 the plain diagonal, one ridge that climbs to N - 1 beside the spike.\n// Buttons: K1 tap moves on to the next array of the field: the next construction, primitive root and one of the eight symmetries of the square. The pattern also moves on by itself a few seconds after a map is full.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst FIELDS = [11, 13, 16, 17, 19, 23, 29, 31, 32];\n// Hue of the array's dots at knob 0, and the ghost's hue past it.\nconst HUE0 = 0.42, GHOST = 0.5;\n// Seconds the full map stays before the next array, and the extra time the\n// ghost sits on the original at the start of a scan, both at Speed 2.\nconst HOLD = 5, REST = 0.9;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\n\n// GF(q) for a prime q or q = 16, 32. The elements are 0..q-1; exp and log\n// are taken to a generator g0, and the primitive elements are g0^e with e\n// prime to q - 1, sorted by value so the field of 11 starts with 2.\nfunction field(q) {\n  const two = (q & (q - 1)) === 0, poly = q === 16 ? 0x13 : 0x25;\n  const ex = new Int32Array(q - 1), lg = new Int32Array(q);\n  let g0 = 2;\n  for (;;) {\n    let v = 1, ok = true;\n    for (let i = 0; i \u003c q - 1; i++) {\n      ex[i] = v;\n      if (i > 0 && v === 1) { ok = false; break; }\n      if (two) { v \u003c\u003c= 1; if (v & q) v ^= poly; } else v = (v * g0) % q;\n    }\n    if (ok && v === 1) break;\n    g0++;\n  }\n  for (let i = 0; i \u003c q - 1; i++) lg[ex[i]] = i;\n  const prim = [];\n  for (let e = 1; e \u003c q - 1; e++) if (gcd(e, q - 1) === 1) prim.push(ex[e]);\n  prim.sort((a, b) => a - b);\n  // 1 - a: a subtraction mod q, or in characteristic 2 an XOR.\n  const oneMinus = (a) => (two ? 1 ^ a : (1 - a + q) % q);\n  return { q, two, ex, lg, prim, oneMinus };\n}\n\n// Welch: column i, row g^(i + c) mod p minus 1, order p - 1.\nfunction welch(F, g, c) {\n  const n = F.q - 1, e = F.lg[g], f = new Int32Array(n);\n  for (let i = 0; i \u003c n; i++) f[i] = F.ex[(e * (i + c)) % n] - 1;\n  return f;\n}\n\n// Lempel-Golomb: a dot at (i, j), 1 \u003c= i, j \u003c= q - 2, where a^i + b^j = 1.\n// a = b is Lempel's symmetric array.\nfunction lempelGolomb(F, a, b) {\n  const n = F.q - 2, m = F.q - 1, ea = F.lg[a], eb = F.lg[b], f = new Int32Array(n);\n  let inv = 1;\n  while ((eb * inv) % m !== 1) inv++;\n  for (let i = 1; i \u003c= n; i++) {\n    const v = F.oneMinus(F.ex[(ea * i) % m]);\n    f[i - 1] = ((F.lg[v] * inv) % m) - 1;\n  }\n  return f;\n}\n\n// The eight symmetries of the square: bit 0 transposes (the inverse\n// permutation), bit 1 mirrors the columns, bit 2 the rows.\nfunction symmetry(f, k) {\n  const n = f.length;\n  let g = Int32Array.from(f);\n  if (k & 1) for (let i = 0; i \u003c n; i++) g[f[i]] = i;\n  if (k & 2) g = g.map((_, i, a) => a[n - 1 - i]);\n  if (k & 4) g = g.map((v) => n - 1 - v);\n  return g;\n}\n\n// Array number k of a field: Welch and Lempel-Golomb in turn for a prime,\n// Lempel-Golomb alone for 16 and 32, the roots and symmetry moving on.\nfunction costas(F, k) {\n  const P = F.prim, R = P.length, h = floor(k / 2), sym = (3 * k) % 8;\n  let f;\n  if (F.two) f = lempelGolomb(F, P[k % R], P[(2 * k) % R]);\n  else if (k % 2 === 0) f = welch(F, P[h % R], (3 * h) % (F.q - 1));\n  else f = lempelGolomb(F, P[h % R], P[(2 * h) % R]);\n  return symmetry(f, sym);\n}\n\n// The coincidence count of every shift: C[dx, dy] is how many dots of the\n// copy shifted by (dx, dy) land on a dot. Index (N-1-dy)*M + dx+N-1.\nfunction counts(f) {\n  const n = f.length, M = 2 * n - 1, C = new Int16Array(M * M);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) C[(n - 1 - (f[j] - f[i])) * M + j - i + n - 1]++;\n  return C;\n}\n\n// A small seeded generator, so a shuffled rival is the same each time.\nfunction shuffle(n, seed) {\n  let a = seed >>> 0;\n  const rnd = () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = Math.imul(a ^ (a >>> 15), a | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n  for (;;) {\n    const f = Int32Array.from({ length: n }, (_, i) => i);\n    for (let i = n - 1; i > 0; i--) {\n      const j = floor(rnd() * (i + 1)), t = f[i];\n      f[i] = f[j];\n      f[j] = t;\n    }\n    // A shuffle that came out a Costas array by chance is drawn again.\n    const C = counts(f), M = 2 * n - 1, mid = (n - 1) * M + n - 1;\n    let worst = 0;\n    for (let d = 0; d \u003c C.length; d++) if (d !== mid) worst = max(worst, C[d]);\n    if (worst > 1) return f;\n  }\n}\n\nfunction rival(f, kind, seed) {\n  const n = f.length;\n  if (kind === 1) return shuffle(n, seed);\n  if (kind === 2) {\n    let a = max(2, round(n * 0.3));\n    while (gcd(a, n) !== 1) a++;\n    return Int32Array.from({ length: n }, (_, i) => (a * i) % n);\n  }\n  if (kind === 3) return Int32Array.from({ length: n }, (_, i) => i);\n  return f;\n}\n\n// The scan. A shift and its opposite meet the same dots, the copy's dot\n// and the array's dot trading places, so the ghost visits half of each\n// square ring round (0, 0), the right side and the top, and the opposite\n// cell of the map fills in with it. Odd rings go up the right side and left\n// along the top, even rings back the other way, so each step is to a\n// neighbouring shift.\nfunction spiral(n) {\n  const M = 2 * n - 1, L = (M * M + 1) / 2, sx = new Int8Array(L), sy = new Int8Array(L);\n  let m = 1;\n  const put = (x, y) => ((sx[m] = x), (sy[m++] = y));\n  for (let k = 1; k \u003c n; k++) {\n    if (k & 1) {\n      for (let y = -k + 1; y \u003c= k; y++) put(k, y);\n      for (let x = k - 1; x >= -k; x--) put(x, k);\n    } else {\n      for (let x = -k; x \u003c k; x++) put(x, k);\n      for (let y = k; y > -k; y--) put(k, y);\n    }\n  }\n  const ord = new Int32Array(M * M);\n  for (let i = 0; i \u003c L; i++) {\n    ord[(n - 1 - sy[i]) * M + sx[i] + n - 1] = i;\n    ord[(n - 1 + sy[i]) * M - sx[i] + n - 1] = i;\n  }\n  return { sx, sy, ord, L };\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, sp: 2, fi: -1, kind: -1, k: 0, F: null,\n    base: null, f: null, n: 0, C: null, scan: null,\n    m: 0, w: 0, dur: 1, step: 1, clk: 0, rev: null, ph: 0, col: -1,\n    hit: null, str: null,\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(30), palHue: -1,\n  };\n}\n\nfunction build(s, fresh) {\n  const n = s.base.length;\n  s.f = rival(s.base, s.kind, s.F.q * 977 + s.k * 131 + 7);\n  s.C = counts(s.f);\n  if (!fresh && s.n === n) return;\n  s.n = n;\n  s.scan = spiral(n);\n  s.step = 1 / (1.2 * (2 * n - 1));\n  s.rev = new Float32Array((2 * n - 1) ** 2);\n  s.m = 0;\n  s.w = 0;\n  s.ph = 0;\n  s.col = -1;\n  s.hit = new Float32Array(n).fill(9);\n  s.str = new Float32Array(n).fill(9);\n  arrive(s, 0);\n}\n\nfunction next(s, k) {\n  s.k = k;\n  s.base = costas(s.F, k);\n  build(s, true);\n}\n\n// The ghost has landed on shift number m: every dot it covers flashes,\n// and it stays one step for nothing and four for a meeting, up to seven for\n// three or more, so the meetings are the scan's own rhythm.\nfunction arrive(s, m) {\n  const { f, n } = s, dx = s.scan.sx[m], dy = s.scan.sy[m];\n  let met = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const j = i + dx;\n    if (j >= 0 && j \u003c n && f[j] === f[i] + dy) (s.hit[j] = 0), met++;\n  }\n  s.rev[(n - 1 - dy) * (2 * n - 1) + dx + n - 1] = s.rev[(n - 1 + dy) * (2 * n - 1) - dx + n - 1] = s.clk;\n  s.dur = m ? s.step * (1 + 3 * min(met, 1) + max(0, min(met, 3) - 1) * 1.5) : REST + 4 * s.step;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(kv[0], 0, 1);\n  s.sp = cl(kv[1], 0.2, 3);\n  const fi = round(cl(kv[2], 0, 8)), kind = round(cl(kv[3], 0, 3));\n  if (fi !== s.fi) {\n    s.fi = fi;\n    s.F = field(FIELDS[fi]);\n    s.kind = kind;\n    next(s, 0);\n  } else if (kind !== s.kind) {\n    s.kind = kind;\n    build(s, false);\n  }\n  if (input.btnPressed && input.btnPressed[0]) next(s, s.k + 1);\n  const r = d * (s.sp / 2), n = s.n, total = s.scan.L;\n  for (let i = 0; i \u003c n; i++) (s.hit[i] += r), (s.str[i] += r);\n  s.clk += r;\n  s.w += r;\n  while (s.m \u003c total - 1 && s.w >= s.dur) (s.w -= s.dur), arrive(s, ++s.m);\n  if (s.m === total - 1 && s.w >= HOLD) return next(s, s.k + 1);\n  // The playhead: 5.5 columns a second at order 10, faster for the big\n  // orders so a bar stays under three seconds.\n  s.ph += r * (3 + n / 4);\n  const c = floor(s.ph) % n;\n  if (c !== s.col) (s.col = c), (s.str[c] = 0);\n}\n\nfunction palette(s) {\n  const P = s.pal, h = HUE0 + s.hue;\n  hsv(h, 0.85, 0.85, P, 0); // dot\n  hsv(h, 0.35, 1, P, 3); // struck dot\n  hsv(h, 0.7, 0.55, P, 6); // ring\n  hsv(h + GHOST, 0.75, 0.6, P, 9); // ghost\n  hsv(h, 0.8, 0.15, P, 12); // playhead band\n  hsv(h + 0.12, 0.9, 0.22, P, 15); // a nought in the map\n  hsv(h - 0.05, 0.7, 0.8, P, 18); // a one\n  hsv(h + GHOST, 0.8, 0.85, P, 21); // two or more\n  hsv(h + 0.1, 0.8, 0.1, P, 24); // lattice\n  hsv(h + GHOST, 0.4, 0.75, P, 27); // flash halo\n  s.palHue = s.hue;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.f) return;\n  if (s.palHue !== s.hue) palette(s);\n  const { buf: B, pal: P, f, n, C } = s;\n  B.fill(0);\n  const add = (x, y, o, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    B[p] += P[o] * a;\n    B[p + 1] += P[o + 1] * a;\n    B[p + 2] += P[o + 2] * a;\n  };\n  const white = (x, y, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    B[p] += a;\n    B[p + 1] += a;\n    B[p + 2] += a;\n  };\n\n  // Top: the array, column i is time step i, row f(i) the frequency, low\n  // frequencies at the bottom.\n  const c = floor(64 / n), d = c >= 5 ? c - 2 : c >= 3 ? c - 1 : c, e = (c - d) >> 1;\n  const ox = (W - c * n) >> 1, oy = (64 - c * n) >> 1, side = c * n;\n  const X = (i) => ox + i * c + e, Y = (r) => oy + (n - 1 - r) * c + e;\n  const block = (x0, y0, sz, fn) => {\n    for (let y = y0; y \u003c y0 + sz; y++) for (let x = x0; x \u003c x0 + sz; x++) fn(x, y);\n  };\n  if (c >= 4) for (let i = 0; i \u003c n; i++) for (let r = 0; r \u003c n; r++) add(X(i) + (d >> 1), Y(r) + (d >> 1), 24, 1);\n  // The playhead's column and the row of the note it is playing.\n  if (s.col >= 0) {\n    const yr = Y(f[s.col]) - e;\n    for (let y = oy; y \u003c oy + side; y++) for (let x = ox + s.col * c; x \u003c ox + s.col * c + c; x++) add(x, y, 12, 1);\n    for (let y = yr; y \u003c yr + c; y++) for (let x = ox; x \u003c ox + side; x++) add(x, y, 12, 1);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const a = s.str[i], x0 = X(i), y0 = Y(f[i]);\n    const k = a \u003c 0.6 ? exp(-a * 5) : 0;\n    block(x0, y0, d, (x, y) => (add(x, y, 0, 1 - k), add(x, y, 3, k)));\n    // A struck note rings out as a widening square.\n    if (a \u003c 0.45) {\n      const rr = (d >> 1) + 1 + floor(a * 14), cx = x0 + (d >> 1), cy = y0 + (d >> 1), al = (1 - a / 0.45) ** 2;\n      for (let t = -rr; t \u003c= rr; t++) {\n        for (const [x, y] of [[cx + t, cy - rr], [cx + t, cy + rr], [cx - rr, cy + t], [cx + rr, cy + t]])\n          if (x >= ox && x \u003c ox + side && y >= oy && y \u003c oy + side) add(x, y, 6, al);\n      }\n    }\n  }\n  // The ghost copy glides from shift m to shift m + 1.\n  const { sx, sy, ord, L: total } = s.scan, m = s.m;\n  // It rests, then glides in the last 0.8 of a plain step.\n  const g = m \u003c total - 1 ? cl((s.w - s.dur) / (0.8 * s.step) + 1, 0, 1) : 0, gg = g * g * (3 - 2 * g);\n  const mn = min(m + 1, total - 1), gdx = sx[m] + (sx[mn] - sx[m]) * gg, gdy = sy[m] + (sy[mn] - sy[m]) * gg;\n  const hollow = d >= 3;\n  // The sheet the ghost is printed on: faint where it overlaps the array,\n  // brighter along its edge.\n  const gx0 = ox + round(gdx * c), gy0 = oy - round(gdy * c);\n  for (let y = max(oy, gy0); y \u003c min(oy + side, gy0 + side); y++)\n    for (let x = max(ox, gx0); x \u003c min(ox + side, gx0 + side); x++) {\n      const edge = x === gx0 || x === gx0 + side - 1 || y === gy0 || y === gy0 + side - 1;\n      add(x, y, 9, edge ? 0.45 : 0.1);\n    }\n  for (let i = 0; i \u003c n; i++) {\n    const x0 = round(X(i) + gdx * c), y0 = round(Y(f[i]) - gdy * c);\n    block(x0, y0, d, (x, y) => {\n      if (x \u003c ox || x >= ox + side || y \u003c oy || y >= oy + side) return;\n      if (hollow && x > x0 && x \u003c x0 + d - 1 && y > y0 && y \u003c y0 + d - 1) return;\n      add(x, y, 9, hollow ? 1 : 0.7);\n    });\n  }\n  // Where the ghost met a dot.\n  for (let j = 0; j \u003c n; j++) {\n    const a = s.hit[j];\n    if (a > 0.5) continue;\n    const k = 1 - a / 0.5, x0 = X(j), y0 = Y(f[j]);\n    block(x0 - 1, y0 - 1, d + 2, (x, y) => {\n      const edge = x \u003c x0 || y \u003c y0 || x >= x0 + d || y >= y0 + d;\n      if (edge) add(x, y, 27, k);\n      else white(x, y, k * 0.8), add(x, y, 27, k * 0.6);\n    });\n  }\n\n  // Bottom: one cell per shift, dx across and dy up, filled as the scan\n  // reaches it.\n  const M = 2 * n - 1, sc = floor(64 / M), sd = sc >= 3 ? sc - 1 : 1;\n  const mx = (W - sc * M) >> 1, my = 64 + ((64 - sc * M) >> 1), mid = (n - 1) * M + n - 1;\n  const cur = (n - 1 - sy[m]) * M + sx[m] + n - 1;\n  for (let gy = 0; gy \u003c M; gy++)\n    for (let gx = 0; gx \u003c M; gx++) {\n      const q = gy * M + gx, o = ord[q], x0 = mx + gx * sc, y0 = my + gy * sc;\n      if (o > m) {\n        if (sc >= 2) add(x0, y0, 24, sc >= 3 ? 1.6 : 0.9);\n        continue;\n      }\n      const v = C[q], age = s.clk - s.rev[q];\n      const flash = age \u003c 0.35 ? (1 - age / 0.35) * 0.7 : 0;\n      block(x0, y0, sd, (x, y) => {\n        if (q === mid) return white(x, y, 1);\n        if (v === 0) add(x, y, 15, 1);\n        else if (v === 1) add(x, y, 18, 1);\n        else {\n          // Two or more: the ghost hue, whitening toward N - 1.\n          const t = (v - 2) / max(1, n - 3);\n          add(x, y, 21, 1 - 0.6 * t);\n          white(x, y, 0.6 * t);\n        }\n        if (flash) white(x, y, flash);\n      });\n    }\n  // The spike of N fills the gaps round its cell, and the scan has a cursor.\n  if (sc >= 3) {\n    const x0 = mx + (n - 1) * sc, y0 = my + (n - 1) * sc;\n    for (let t = -1; t \u003c= sd; t++) white(x0 + t, y0 - 1, 0.8), white(x0 + t, y0 + sd, 0.8), white(x0 - 1, y0 + t, 0.8), white(x0 + sd, y0 + t, 0.8);\n  }\n  // The opposite shift gets a fainter cursor of its own.\n  if (m \u003c total - 1)\n    for (const [q, a] of [[cur, 1], [M * M - 1 - cur, 0.45]]) {\n      const x0 = mx + (q % M) * sc, y0 = my + floor(q / M) * sc;\n      if (sd >= 2) for (let t = -1; t \u003c= sd; t++) white(x0 + t, y0 - 1, 0.55 * a), white(x0 + t, y0 + sd, 0.55 * a), white(x0 - 1, y0 + t, 0.55 * a), white(x0 + sd, y0 + t, 0.55 * a);\n      else white(x0, y0, 0.8 * a), white(x0 - 1, y0, 0.35 * a), white(x0 + 1, y0, 0.35 * a), white(x0, y0 - 1, 0.35 * a), white(x0, y0 + 1, 0.35 * a);\n    }\n\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3)\n      display.setPixel(x, y, min(255, round(B[p] * 255)), min(255, round(B[p + 1] * 255)), min(255, round(B[p + 2] * 255)));\n}\n","elastica":"// ===== Patternflow pattern =====\n// Title:   Euler's Elastica\n// Family:  physics\n// Idea:    A thin elastic rod 120 LEDs long, pinned at both ends on its line of thrust, is slowly pushed and let go and sweeps Euler's family of bent shapes from the first slight bow through the arch and the drop where its ends meet to the loops where they pass each other, while a bead runs along it, a pendulum above swings with its arm always parallel to the rod at the bead, and the pendulum's orbit goes round its phase portrait below.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Euler's elastica (Leonhard Euler, 1744), after Jacob Bernoulli's elastic curve (1694), with Kirchhoff's kinetic analogy to the pendulum (Gustav Kirchhoff, 1859), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mode=1..4, Preload=0..1\n//\n// Knob 1: Hue. The rod is coloured by the direction it points, and the same colours mark the pendulum's swing and the orbit below. At 0 a straight rod is cyan, leaning one way it turns green and the other way violet; the knob turns all of it round the wheel, hurrying past orange and yellow.\n// Knob 2: Speed. At 2 one push and release takes 16 seconds and the bead runs the rod in 2.4; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Mode. How many half waves the rod buckles into, 1 to 4. At the same end slope mode n carries n squared times the load of mode 1, and its rod is n copies of the mode 1 shape at 1/n the size, each the mirror of the one before.\n// Knob 4: Preload. How far each release goes back. At 0 the rod comes back straight and buckles again to a side picked by chance; at 0.5 it never unbends past an end slope of 38 degrees, and at 1 it stays among the loops, 150 to 176 degrees.\n// Buttons: K1 tap holds the load where it is, so one shape stands still while the bead and the pendulum keep going; a second tap lets the load move again.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, ceil, round, abs, sqrt, sin, cos, asin, exp, PI } = Math;\nconst DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The rod is 120 LEDs long and drawn from 241 points half an LED apart.\nconst L = 120, M = 240;\n// The largest end slope, one push and release at Speed 2 in seconds, and the\n// bead's speed at Speed 2 in LEDs a second.\nconst AMAX = 176 * DEG, CYCLE = 16, BEAD = 50;\n// The rod's radius in each mode: thinner for the smaller loops of modes 3 and 4.\nconst RAD = [0, 2.7, 2.6, 2.2, 1.9];\n// The pendulum's pivot and arm, and the phase portrait's middle row, half\n// height and half width.\nconst PX = 31.5, PY = 20.5, PL = 16.5;\nconst PIN = [0.82, 0.82, 0.86];\nconst QY = 108.5, QH = 16, QW = 29.5;\n// Light from the upper left and in front, and the half vector for the shine.\nconst LX = -0.42, LY = -0.5, LZ = 0.757;\nconst HX = -0.229, HY = -0.272, HZ = 0.935;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The arithmetic-geometric mean of 1 and k' gives K(k), E(k) and the a_n, c_n\n// the Jacobi functions are built from (Abramowitz and Stegun 17.6).\nfunction agm(k, g) {\n  const a = g.a, c = g.c;\n  let b = sqrt(1 - k * k), n = 0, sum = 0.5 * k * k;\n  a[0] = 1;\n  c[0] = k;\n  while (n \u003c 15 && c[n] > 1e-15) {\n    const an = a[n];\n    a[n + 1] = (an + b) / 2;\n    c[n + 1] = (an - b) / 2;\n    b = sqrt(an * b);\n    n++;\n    sum += 2 ** (n - 1) * c[n] * c[n];\n  }\n  g.n = n;\n  g.K = PI / (2 * a[n]);\n  g.E = g.K * (1 - sum);\n}\n\n// sn u, cn u and Jacobi's epsilon E(u) = Z(u) + u E/K, by the descending\n// Landen sequence of amplitudes; Z(u) is the sum of c_n sin(phi_n).\nfunction jac(u, g, o) {\n  const { a, c, n, ph } = g;\n  ph[n] = 2 ** n * a[n] * u;\n  let z = 0;\n  for (let i = n; i >= 1; i--) {\n    z += c[i] * sin(ph[i]);\n    ph[i - 1] = (asin((c[i] / a[i]) * sin(ph[i])) + ph[i]) / 2;\n  }\n  o.sn = sin(ph[0]);\n  o.cn = cos(ph[0]);\n  o.e = z + (g.E / g.K) * u;\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  params.s = {\n    hue: 0, mode: 1, alo: 0, al: 0, ph: 0.07, side: 1, hold: false,\n    sb: 0, dir: 1,\n    g: { a: new Float64Array(17), c: new Float64Array(17), ph: new Float64Array(17), n: 0, K: PI / 2, E: PI / 2 },\n    j: { sn: 0, cn: 1, e: 0 },\n    cx: F(M + 1), cy: F(M + 1), sg: F(M + 1),\n    buf: F(N * 3), zs: F(N), zd: F(N), zo: F(N), col: F(3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  const btn = input.btnPressed || [];\n  S.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  S.mode = cl(round(k[2]), 1, 4);\n  const pre = cl(k[3], 0, 1);\n  S.alo = 150 * DEG * pre * pre;\n  if (btn[0]) S.hold = !S.hold;\n  if (!S.hold) {\n    const was = floor(S.ph);\n    S.ph += (d * sp) / (2 * CYCLE);\n    // Back at the bottom of a release with the rod straight, it buckles again\n    // to whichever side chance picks.\n    if (floor(S.ph) !== was && S.alo \u003c 1.2 * DEG) S.side = Math.random() \u003c 0.5 ? -1 : 1;\n  }\n  S.al = S.alo + (AMAX - S.alo) * (0.5 - 0.5 * cos(2 * PI * S.ph));\n  S.sb += d * sp * (BEAD / 2) * S.dir;\n  if (S.sb > L) (S.sb = 2 * L - S.sb), (S.dir = -1);\n  if (S.sb \u003c 0) (S.sb = -S.sb), (S.dir = 1);\n}\n\n// The colour of a rod pointing at screen angle a from straight up. The wheel\n// hurries from rose to lime, so dim orange and yellow, brown and olive on\n// this panel, hardly come up.\nfunction tint(S, a, out, o) {\n  let h = S.hue + 0.53 + (0.24 * a) / PI;\n  h -= floor(h);\n  const x = (h + 0.05 - floor(h + 0.05)) / 0.3;\n  if (x \u003c 1) h = 0.95 + 0.3 * (x - sin(2 * PI * x) / (2 * PI));\n  hsv(h, 0.8, 1, out, o);\n}\n\n// A point drawn between four LEDs, each channel kept at the brightest.\nfunction dot(buf, x, y, r, g, b) {\n  x -= 0.5;\n  y -= 0.5;\n  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = x0 + i, Y = y0 + j;\n      if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n      const w = (i ? fx : 1 - fx) * (j ? fy : 1 - fy), p = (Y * W + X) * 3;\n      buf[p] = max(buf[p], r * w);\n      buf[p + 1] = max(buf[p + 1], g * w);\n      buf[p + 2] = max(buf[p + 2], b * w);\n    }\n}\n\nfunction line(buf, ax, ay, bx, by, r, g, b) {\n  const m = max(1, ceil(Math.hypot(bx - ax, by - ay) * 2));\n  for (let i = 0; i \u003c= m; i++) dot(buf, ax + ((bx - ax) * i) / m, ay + ((by - ay) * i) / m, r, g, b);\n}\n\n// A shaded ball, written over what is there.\nfunction ball(buf, x, y, R, col) {\n  for (let Y = max(0, floor(y - R - 1)); Y \u003c= min(H - 1, ceil(y + R + 1)); Y++)\n    for (let X = max(0, floor(x - R - 1)); X \u003c= min(W - 1, ceil(x + R + 1)); X++) {\n      const dx = X + 0.5 - x, dy = Y + 0.5 - y, d2 = dx * dx + dy * dy, p = (Y * W + X) * 3;\n      if (d2 >= (R + 0.9) * (R + 0.9)) continue;\n      if (d2 >= R * R) {\n        buf[p] = buf[p + 1] = buf[p + 2] = 0;\n        continue;\n      }\n      const nz = sqrt(R * R - d2) / R, nx = dx / R, ny = dy / R;\n      const lam = max(0, nx * LX + ny * LY + nz * LZ), sh = max(0, nx * HX + ny * HY + nz * HZ) ** 24;\n      const v = 0.3 + 0.75 * lam;\n      buf[p] = col[0] * v + sh * 0.6;\n      buf[p + 1] = col[1] * v + sh * 0.6;\n      buf[p + 2] = col[2] * v + sh * 0.6;\n    }\n}\n\n// The rod's shape for end slope al in mode n, in closed form. With\n// k = sin(al/2) and sqrt(lambda) = 2nK/L, the tangent's angle theta from the\n// line of thrust has sin(theta/2) = k sn(u), u = sqrt(lambda) s + K, so\n// theta'' = -lambda sin(theta), the pendulum. Integrating cos and sin of theta:\n// x = (2/sqrt(lambda)) (E(u) - E(K)) - s along the line, y = -(2k/sqrt(lambda)) cn(u) off it.\nfunction shape(S) {\n  const { g, j, cx, cy, sg } = S, k = sin(S.al / 2), n = S.mode;\n  agm(k, g);\n  const r = (2 * n * g.K) / L;\n  jac(g.K, g, j);\n  const e0 = j.e;\n  let lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c= M; i++) {\n    const s = (L * i) / M;\n    jac(r * s + g.K, g, j);\n    cy[i] = (2 / r) * (j.e - e0) - s;\n    cx[i] = S.side * (-2 * k / r) * j.cn;\n    sg[i] = S.side * 2 * asin(cl(k * j.sn, -1, 1));\n    lo = min(lo, cx[i]);\n    hi = max(hi, cx[i]);\n  }\n  // The pins sit on the vertical centre line while the rod fits the panel.\n  // Mode 1 bows to one side only, up to 48.4 LEDs at an end slope of 114\n  // degrees, so there the line of thrust slides over with the pins on it\n  // until the bow clears the far edge. Nothing is scaled.\n  const m = RAD[n] + 1.6, D = cy[M], ox = cl(31.5, m - lo, W - m - hi);\n  for (let i = 0; i \u003c= M; i++) {\n    cx[i] += ox;\n    cy[i] = 63.5 + D / 2 - cy[i];\n  }\n  S.r = r;\n  S.k = k;\n  S.ox = ox;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  shape(S);\n  const { buf, zs, zd, zo, cx, cy, sg, g, j, col } = S, k = S.k;\n  buf.fill(0);\n  zs.fill(-1);\n\n  // The bead's angle and the pendulum's phase: going up the rod is forward\n  // time, coming back down is the same swing run on.\n  jac(S.r * S.sb + g.K, g, j);\n  const sb = S.side * 2 * asin(cl(k * j.sn, -1, 1));\n  const vb = S.side * k * j.cn * S.dir;\n  const ub = S.dir > 0 ? S.r * S.sb + g.K : 2 * g.K - (S.r * S.sb + g.K);\n\n  // The line of thrust between the pins, dotted.\n  const ya = cy[0], yb = cy[M];\n  for (let y = min(ya, yb) + 1; y \u003c max(ya, yb) - 1; y += 2) dot(buf, S.ox, y, 0.28, 0.28, 0.34);\n\n  // The pendulum, all of it behind the rod. Its arm hangs straight down when\n  // the rod at the bead points straight up. First a long exposure of the\n  // swing: the arm lingers where it turns, so the fan is brightest at its\n  // edges, by how slowly the pendulum passes each angle.\n  const pend = (a) => [PX - PL * sin(a), PY + PL * cos(a)];\n  for (let y = max(0, floor(PY - PL - 1)); y \u003c= ceil(PY + PL + 1); y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY, rr = Math.hypot(dx, dy);\n      if (rr > PL + 0.5 || rr \u003c 1.5) continue;\n      const a = Math.atan2(-dx, dy), sa = sin(abs(a) / 2);\n      if (sa >= k) continue;\n      const v = sqrt(1 - (sa * sa) / (k * k)), f = (round((0.07 + 0.2 * (1 - v) ** 2) * 16) / 16) * min(1, PL + 0.5 - rr);\n      tint(S, a, col, 0);\n      const o = (y * W + x) * 3;\n      buf[o] = col[0] * f;\n      buf[o + 1] = col[1] * f;\n      buf[o + 2] = col[2] * f;\n    }\n  // The bob's path from -al to al in the rod's colours, and the arm where it\n  // was over the bead's last 12 LEDs, fading.\n  for (let a = -S.al; a \u003c= S.al; a += 0.5 / PL) {\n    tint(S, a, col, 0);\n    const [x, y] = pend(a);\n    dot(buf, x, y, col[0] * 0.4, col[1] * 0.4, col[2] * 0.4);\n  }\n  for (let q = 12; q >= 1; q--) {\n    let s = S.sb - S.dir * q;\n    s = s \u003c 0 ? -s : s > L ? 2 * L - s : s;\n    jac(S.r * s + g.K, g, j);\n    const a = S.side * 2 * asin(cl(k * j.sn, -1, 1)), f = 0.34 * (1 - q / 13);\n    tint(S, a, col, 0);\n    const [x, y] = pend(a);\n    line(buf, PX, PY, x, y, col[0] * f, col[1] * f, col[2] * f);\n  }\n  const [bx, by] = pend(sb);\n  line(buf, PX, PY, bx, by, 0.62, 0.62, 0.68);\n  tint(S, sb, col, 0);\n  ball(buf, bx, by, 3.3, col);\n  ball(buf, PX, PY, 1.3, PIN);\n\n  // The phase portrait: the separatrix and the orbits of end slopes 30 to 150\n  // degrees, faint, and the orbit at this slope, brightest just behind the\n  // moving point. An orbit of slope b has sin(theta/2) = sin(b/2) sin(t) and\n  // theta' over twice sqrt(lambda) = sin(b/2) cos(t).\n  const qx = (a) => 31.5 - (QW * a) / PI, qy = (v) => QY - QH * v;\n  for (let a = -PI; a \u003c= PI; a += 0.02) {\n    const v = cos(a / 2);\n    tint(S, a, col, 0);\n    dot(buf, qx(a), qy(v), col[0] * 0.26, col[1] * 0.26, col[2] * 0.26);\n    dot(buf, qx(a), qy(-v), col[0] * 0.26, col[1] * 0.26, col[2] * 0.26);\n  }\n  for (let o = 1; o \u003c= 5; o++) {\n    const kb = sin((o * PI) / 12);\n    for (let t = 0; t \u003c 2 * PI; t += 0.03) {\n      const a = 2 * asin(kb * sin(t));\n      tint(S, a, col, 0);\n      dot(buf, qx(a), qy(kb * cos(t)), col[0] * 0.16, col[1] * 0.16, col[2] * 0.16);\n    }\n  }\n  const K4 = 4 * g.K, steps = 520;\n  for (let i = 0; i \u003c steps; i++) {\n    const u = (K4 * i) / steps;\n    jac(u, g, j);\n    const a = S.side * 2 * asin(cl(k * j.sn, -1, 1)), v = S.side * k * j.cn;\n    let b = (ub - u) / K4;\n    b -= floor(b);\n    const f = 0.42 + 0.58 * exp(-b * 7);\n    tint(S, a, col, 0);\n    dot(buf, qx(a), qy(v), col[0] * f, col[1] * f, col[2] * f);\n  }\n  tint(S, sb, col, 0);\n  ball(buf, qx(sb), qy(vb), 1.9, col);\n\n  // The rod. Each LED near it takes the nearest point of the strand on top:\n  // a strand more than one and a half rod widths further along lies over the\n  // earlier one, and its dark rim cuts the one below where the loops cross.\n  const R = RAD[S.mode], R1 = R + 1.1, same = 6 * R;\n  for (let i = 0; i \u003c M; i++) {\n    const ax = cx[i], ay = cy[i], dx = cx[i + 1] - ax, dy = cy[i + 1] - ay, l2 = dx * dx + dy * dy || 1e-9, ln = sqrt(l2);\n    const x0 = max(0, floor(min(ax, ax + dx) - R1)), x1 = min(W - 1, ceil(max(ax, ax + dx) + R1));\n    const y0 = max(0, floor(min(ay, ay + dy) - R1)), y1 = min(H - 1, ceil(max(ay, ay + dy) + R1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x + 0.5 - ax, py = y + 0.5 - ay, t = cl((px * dx + py * dy) / l2, 0, 1);\n        const qx2 = px - t * dx, qy2 = py - t * dy, d2 = qx2 * qx2 + qy2 * qy2;\n        if (d2 >= R1 * R1) continue;\n        const p = y * W + x, s = i + t, z = zs[p], dd = sqrt(d2);\n        if (z >= 0 && s \u003c= z + same && dd >= zd[p]) continue;\n        zs[p] = s;\n        zd[p] = dd;\n        zo[p] = (dx * qy2 - dy * qx2) / ln;\n      }\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const s = zs[p];\n    if (s \u003c 0) continue;\n    const o = p * 3;\n    if (zd[p] >= R) {\n      buf[o] = buf[o + 1] = buf[o + 2] = 0;\n      continue;\n    }\n    const i = min(M - 1, floor(s)), f = s - i, a = sg[i] + (sg[i + 1] - sg[i]) * f;\n    // The tube's normal: across the rod in the panel, and out of it.\n    const u = zo[p] / R, w = sqrt(max(0, 1 - u * u)), nx = cos(a) * u, ny = sin(a) * u;\n    const lam = max(0, nx * LX + ny * LY + w * LZ), sh = max(0, nx * HX + ny * HY + w * HZ) ** 20;\n    tint(S, a, col, 0);\n    const sl = (s * L) / M, gb = exp(-(((sl - S.sb) / 1.7) ** 2)), tr = S.dir * (S.sb - sl);\n    const v = (0.3 + 0.75 * lam) * (1 + (tr > 0 ? 0.35 * exp(-tr / 9) : 0));\n    buf[o] = col[0] * v + sh * 0.55 + gb * 0.8;\n    buf[o + 1] = col[1] * v + sh * 0.55 + gb * 0.8;\n    buf[o + 2] = col[2] * v + sh * 0.55 + gb * 0.8;\n  }\n\n  // The pins, on top.\n  ball(buf, cx[0], cy[0], 2.2, PIN);\n  ball(buf, cx[M], cy[M], 2.2, PIN);\n\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    if (buf[o] + buf[o + 1] + buf[o + 2] \u003c 0.02) continue;\n    // Each channel in steps of 4 of 255.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] * 63.75) * 4), min(255, round(buf[o + 1] * 63.75) * 4), min(255, round(buf[o + 2] * 63.75) * 4));\n  }\n}\n","four-vertex":"// ===== Patternflow pattern =====\n// Title:   Four-Vertex Theorem\n// Family:  line\n// Idea:    A smooth closed curve slowly changes shape while its evolute, the path of its centres of curvature, turns inside it as a gold star with one cusp for each white vertex where the curvature is greatest or least, and the cusps are born and die in pairs but never number fewer than four.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: four-vertex theorem (Syamadas Mukhopadhyaya, 1909; Adolf Kneser, 1912), with the curve's evolute (Christiaan Huygens, 1673), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Terms=2..6, Bend=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the curve runs from azure where it is flattest through violet to magenta where it is sharpest. Its evolute is peach on the arcs that come from flat parts and pale gold on those from sharp parts, over a dark violet glow on the LEDs that four normals of the curve pass through. At 0.25 the curve runs violet through red to orange and the evolute is lime; at 0.5 orange to green with a pale azure evolute; at 0.75 green to blue with a pink one. The dark glow keeps off orange and yellow, which read brown and olive when dim.\n// Knob 2: Speed. At 2 each wave of the curve swells and fades every 5 to 10 seconds while it turns, and the vertex count changes about 30 times a minute. The osculating circle rolls once round the curve in 7 seconds; on each lap its radius swells to about 105 LEDs on the flattest stretch (62 to 455) and shrinks to about 17 at the sharpest end. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Terms. How many waves bend the curve's radius: at 2 one with 3 lobes and one with 4, and each step adds the next, up to 8 lobes at 6. All of them share one swing of curvature, so the higher ones hardly move the outline while they fold the evolute into small swallowtails. At 2 the curve has 4 vertices 13% of the time, 6 for 52% and 8 for 35%; at 6 it has 4 to 16, mostly 10 or 12, and the count changes 60 times a minute. Every count is even.\n// Knob 4: Bend. How far the waves may swing the curvature. Up to 0.06 the curve stays convex and the evolute a closed star. At Terms 2 the curve starts to dent from about 0.1, and at 1 it is dented 84% of the time (53% at Terms 6). The curvature passes through zero at the two ends of each dent and the evolute runs off the panel towards them; a small arc of it opens outside the curve, carrying the cusp of the dent's own vertex. Kneser's theorem covers these curves too, and the count still never falls below 4.\n// Buttons: K1 tap swells the next wave up for about two seconds, peaking half a second after the tap, so a burst of swallowtails opens on the evolute and closes again; at the opening the count rises from 6.4 on average to a peak of 9.6.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Samples round the curve, the lowest and highest waves (in lobes), and\n// how much taller than wide the curve stands before its waves bend it.\nconst M = 720, K0 = 3, KMAX = 8, ASP = 1.4;\n// The box the curve is scaled to fit, in LEDs.\nconst BOX_W = 60, BOX_H = 120;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const R = Math.random, K = KMAX + 1;\n  const nu = new Float64Array(K), a0 = new Float64Array(K), mu = new Float64Array(K), p0 = new Float64Array(K);\n  for (let k = K0; k \u003c= KMAX; k++) {\n    nu[k] = 0.5 + 0.4 * R();\n    a0[k] = TAU * R();\n    mu[k] = (k % 2 ? -1 : 1) * (0.05 + 0.08 * R()) * (3 / k);\n    p0[k] = TAU * R();\n  }\n  params.s = {\n    nu, a0, mu, p0, wgt: new Float64Array(K), amp: new Float64Array(K), ph: new Float64Array(K),\n    t: 0, u: 0, tap: 99, hue: 0, speed: 2, terms: 2, bend: 0.06, first: true,\n    // Per sample: the point, its curvature, its centre of curvature, the sign\n    // of the curvature's slope, and the arc length so far.\n    x: new Float64Array(M), y: new Float64Array(M), k: new Float64Array(M),\n    ex: new Float64Array(M), ey: new Float64Array(M), v: new Float64Array(M), arc: new Float64Array(M + 1),\n    sc: 1, ox: 32, oy: 64, kmin: 0, kmax: 1,\n    vert: [], prev: [], flash: [], osc: null, pt: new Float64Array(10),\n    dx: new Float64Array(M), dy: new Float64Array(M), ga: new Float64Array(M), gx: new Float64Array(M), gb: new Float64Array(M), run: new Int32Array(W + 1), cnt: new Uint8Array(N), q: new Float64Array(M),\n    // A running record: frames, how many had each vertex count, the least\n    // count seen, and frames where the curve was dented.\n    stat: { frames: 0, hist: {}, minCount: 99, concave: 0 },\n    rgb: new Float32Array(N * 3), col: new Float64Array(3),\n  };\n}\n\n// The curve in its own frame: r(phi) = 1 + sum c_k cos(k phi - p_k), drawn\n// as (r cos phi, ASP r sin phi), with r and its first three derivatives\n// summed exactly. Fills o with the point (0, 1), its centre of curvature\n// (2, 3), the curvature (4), a number with the sign of the curvature's\n// slope (5) and the velocity (6, 7), all in the curve's own units. With\n// cross = x'y'' - y'x'' and D = x'^2 + y'^2 the curvature is cross / D^1.5,\n// its slope has the sign of cross' D - 1.5 cross D', and the centre is the\n// point plus D / cross times the velocity turned a quarter.\nfunction at(S, phi, o) {\n  let r = 1, r1 = 0, r2 = 0, r3 = 0;\n  for (let k = K0; k \u003c= KMAX; k++) {\n    const a = S.amp[k];\n    if (a === 0) continue;\n    const q = k * phi - S.ph[k], c = a * cos(q), s = a * sin(q);\n    r += c;\n    r1 -= k * s;\n    r2 -= k * k * c;\n    r3 += k * k * k * s;\n  }\n  const cp = cos(phi), sp = sin(phi);\n  const x = r * cp, y = ASP * r * sp;\n  const x1 = r1 * cp - r * sp, y1 = ASP * (r1 * sp + r * cp);\n  const x2 = r2 * cp - 2 * r1 * sp - r * cp, y2 = ASP * (r2 * sp + 2 * r1 * cp - r * sp);\n  const cross = x1 * y2 - y1 * x2, D = x1 * x1 + y1 * y1;\n  const dcross = ASP * (2 * r * r1 + 3 * r1 * r2 - r * r3), dD = 2 * (x1 * x2 + y1 * y2);\n  o[0] = x;\n  o[1] = y;\n  const f = D / cross;\n  o[2] = x - f * y1;\n  o[3] = y + f * x1;\n  o[4] = cross / (D * sqrt(D));\n  o[5] = dcross * D - 1.5 * cross * dD;\n  o[6] = x1;\n  o[7] = y1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.terms = cl(floor(kv[2] + 0.5), 2, 6);\n  S.bend = cl(kv[3], 0, 1);\n  S.t += d * S.speed * 0.65;\n  const t = S.t;\n  // Each wave fades in or out over about a second when Terms moves.\n  let wsum = 0;\n  for (let k = K0; k \u003c= KMAX; k++) {\n    const target = k \u003c K0 + S.terms ? 1 : 0;\n    S.wgt[k] = S.first ? target : S.wgt[k] + (target - S.wgt[k]) * min(1, d * 2.5);\n    wsum += S.wgt[k];\n  }\n  // How far the waves together may swing the curvature, as a share of the\n  // circle's. The waves split it evenly, each scaled by 1 / (k^2 - 1) since\n  // a wave of k lobes swings the curvature k^2 - 1 times its own height.\n  // At 0.7 the curve stays convex; from about 0.86 (Bend 0.1) it dents.\n  const budget = 0.7 + 1.6 * S.bend;\n  if (input.btnPressed && input.btnPressed[0]) S.tap = 0;\n  S.tap += d;\n  // A tap swells the next wave up (or the top one when all are in). The\n  // swell peaks 0.5 seconds after the tap and is gone in about 3.\n  const kick = (S.tap / 0.5) * Math.exp(1 - S.tap / 0.5);\n  const kicked = min(KMAX, K0 + S.terms);\n  for (let k = K0; k \u003c= KMAX; k++) {\n    const e = 0.6 + 0.4 * sin(S.nu[k] * t + S.a0[k]);\n    S.amp[k] = (budget * (S.wgt[k] * e / wsum + (k === kicked ? 0.6 * kick : 0))) / (k * k - 1);\n    S.ph[k] = S.p0[k] + S.mu[k] * t;\n  }\n  // Sample, fit to the box, and find where the curvature's slope changes sign.\n  const o = S.pt, X = S.x, Y = S.y, K = S.k, EX = S.ex, EY = S.ey, V = S.v;\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9, kmin = 1e9, kmax = -1e9, concave = false;\n  // kmin is the least positive curvature.\n  for (let i = 0; i \u003c M; i++) {\n    at(S, (TAU * i) / M, o);\n    (X[i] = o[0]), (Y[i] = o[1]), (EX[i] = o[2]), (EY[i] = o[3]), (K[i] = o[4]), (V[i] = o[5]), (S.dx[i] = o[6]), (S.dy[i] = o[7]);\n    x0 = min(x0, o[0]), x1 = max(x1, o[0]), y0 = min(y0, o[1]), y1 = max(y1, o[1]);\n    kmax = max(kmax, o[4]);\n    if (o[4] \u003c= 0) concave = true;\n    else kmin = min(kmin, o[4]);\n  }\n  // The scale fits the curve to the box.\n  const fit = min(BOX_W / (x1 - x0), BOX_H / (y1 - y0));\n  S.sc = S.first ? fit : S.sc + (fit - S.sc) * min(1, d * 2);\n  const sc = S.sc;\n  // Centred on the curve's box.\n  S.ox = W / 2 - (sc * (x0 + x1)) / 2;\n  S.oy = H / 2 + (sc * (y0 + y1)) / 2;\n  S.kmin = kmin;\n  S.kmax = kmax;\n  // Arc length, for the osculating circle's even roll.\n  S.arc[0] = 0;\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M;\n    S.arc[i + 1] = S.arc[i] + Math.hypot(X[j] - X[i], Y[j] - Y[i]);\n  }\n  // Vertices: each sign change of the slope, placed by one secant step.\n  S.prev = S.vert;\n  const vert = [];\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M, a = V[i], b = V[j];\n    if ((a \u003c 0) !== (b \u003c 0)) {\n      const f = a / (a - b), phi = (TAU * (i + f)) / M;\n      at(S, phi, o);\n      vert.push({ phi, x: o[0], y: o[1], cx: o[2], cy: o[3], kap: o[4], max: a > 0 });\n    }\n  }\n  S.vert = vert;\n  // Vertices born or gone this frame start a flash, drawn as a ring.\n  if (!S.first) {\n    const near = (a, b) => a.max === b.max && angDist(a.phi, b.phi) \u003c 0.15;\n    if (vert.length !== S.prev.length) {\n      for (const v of vert) if (!S.prev.some((p) => near(p, v))) S.flash.push({ v, age: 0, born: true });\n      for (const p of S.prev) if (!vert.some((v) => near(p, v))) S.flash.push({ v: p, age: 0, born: false });\n    }\n  }\n  for (const f of S.flash) f.age += d;\n  S.flash = S.flash.filter((f) => f.age \u003c 0.8);\n  // The osculating circle rolls once round in 7 seconds at Speed 2.\n  S.u = (S.u + (d * S.speed) / 14) % 1;\n  const L = S.arc[M], goal = S.u * L;\n  let lo = 0, hi = M;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (S.arc[mid] \u003c= goal) lo = mid;\n    else hi = mid;\n  }\n  const f = (goal - S.arc[lo]) / (S.arc[lo + 1] - S.arc[lo] || 1);\n  at(S, (TAU * (lo + f)) / M, o);\n  S.osc = { x: o[0], y: o[1], cx: o[2], cy: o[3], kap: o[4] };\n  const st = S.stat;\n  st.frames++;\n  st.hist[vert.length] = (st.hist[vert.length] || 0) + 1;\n  st.minCount = min(st.minCount, vert.length);\n  if (concave) st.concave++;\n  S.first = false;\n}\n\nfunction angDist(a, b) {\n  const d = abs(a - b) % TAU;\n  return d > PI ? TAU - d : d;\n}\n\n// Drawing: lines are laid as points every third of an LED, each lighting\n// its four nearest LEDs by how close it falls, and an LED keeps the\n// brightest colour laid on it.\nfunction plot(S, x, y, c, a) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy, rgb = S.rgb;\n  for (let dy = 0; dy \u003c 2; dy++) {\n    const yy = iy + dy;\n    if (yy \u003c 0 || yy >= H) continue;\n    const wy = dy ? ty : 1 - ty;\n    for (let dx = 0; dx \u003c 2; dx++) {\n      const xx = ix + dx;\n      if (xx \u003c 0 || xx >= W) continue;\n      const w = min(1, (dx ? tx : 1 - tx) * wy * 1.7) * a, p = (yy * W + xx) * 3;\n      if (rgb[p] \u003c c[0] * w) rgb[p] = c[0] * w;\n      if (rgb[p + 1] \u003c c[1] * w) rgb[p + 1] = c[1] * w;\n      if (rgb[p + 2] \u003c c[2] * w) rgb[p + 2] = c[2] * w;\n    }\n  }\n}\n// A segment, cut to the panel first: a radius of curvature can run\n// thousands of LEDs off it.\nfunction line(S, xa, ya, xb, yb, c, a, gap) {\n  const dx = xb - xa, dy = yb - ya;\n  let t0 = 0, t1 = 1;\n  for (const [p, q] of [[-dx, xa + 1], [dx, W + 1 - xa], [-dy, ya + 1], [dy, H + 1 - ya]]) {\n    if (p === 0) {\n      if (q \u003c 0) return;\n    } else if (p \u003c 0) t0 = max(t0, q / p);\n    else t1 = min(t1, q / p);\n  }\n  if (t0 > t1) return;\n  const len = Math.hypot(dx, dy), n = Math.ceil(len * (t1 - t0) * 3) || 1;\n  for (let e = 0; e \u003c= n; e++) {\n    const u = t0 + ((t1 - t0) * e) / n;\n    if (gap && floor((u * len) / gap) % 2) continue;\n    plot(S, xa + dx * u, ya + dy * u, c, a);\n  }\n}\nfunction dot(S, x, y, c, a, rad) {\n  for (let yy = floor(y - rad); yy \u003c= floor(y + rad); yy++)\n    for (let xx = floor(x - rad); xx \u003c= floor(x + rad); xx++) {\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n      const dd = Math.hypot(xx + 0.5 - x, yy + 0.5 - y), w = cl(rad + 0.5 - dd, 0, 1) * a, p = (yy * W + xx) * 3;\n      if (w \u003c= 0) continue;\n      S.rgb[p] = max(S.rgb[p], c[0] * w);\n      S.rgb[p + 1] = max(S.rgb[p + 1], c[1] * w);\n      S.rgb[p + 2] = max(S.rgb[p + 2], c[2] * w);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, col, sc, ox, oy, x: X, y: Y, ex: EX, ey: EY, k: K } = S;\n  const px = (u) => ox + sc * u, py = (v) => oy - sc * v;\n  const h0 = S.hue + 0.55;\n  rgb.fill(0);\n  // How many normals of the curve pass through each LED: the sign changes\n  // round the curve of g(phi) = (curve - LED) . tangent. Along a row, the\n  // sign at one sample flips at a single column, so each pair of\n  // neighbouring samples disagrees on one run of columns (or outside it),\n  // added into the row's tally as a difference.\n  const DX = S.dx, DY = S.dy, A = S.ga, B = S.gb, T = S.gx, run = S.run, cnt = S.cnt;\n  for (let i = 0; i \u003c M; i++) A[i] = X[i] * DX[i] + Y[i] * DY[i];\n  for (let yy = 0; yy \u003c H; yy++) {\n    const my = (oy - yy - 0.5) / sc;\n    run.fill(0);\n    for (let i = 0; i \u003c M; i++) {\n      B[i] = A[i] - my * DY[i];\n      // The column (in LED units) where this sample's sign flips.\n      const tx = DX[i] || 1e-12;\n      T[i] = (B[i] / tx) * sc + ox - 0.5;\n    }\n    for (let i = 0; i \u003c M; i++) {\n      const j = i + 1 \u003c M ? i + 1 : 0;\n      let c1 = T[i], c2 = T[j];\n      if (c1 > c2) (c1 = T[j]), (c2 = T[i]);\n      const lo = cl(Math.ceil(c1), 0, W), hi = cl(floor(c2) + 1, 0, W);\n      if ((DX[i] || 1e-12) * (DX[j] || 1e-12) > 0) {\n        if (hi > lo) run[lo]++, run[hi]--;\n      } else {\n        run[0]++, run[W]--;\n        if (hi > lo) run[lo]--, run[hi]++;\n      }\n    }\n    for (let xx = 0, c = 0, p = yy * W; xx \u003c W; xx++, p++) {\n      c += run[xx];\n      cnt[p] = c;\n    }\n  }\n  // The dim fill keeps off the orange and yellow part of the wheel, which\n  // reads brown and olive when dark: its hue runs from green round to red.\n  const fills = [];\n  for (let c = 0; c \u003c 4; c++) {\n    const fh = h0 + 0.16 + 0.07 * c;\n    hsv(0.22 + 0.8 * (fh - floor(fh)), 0.75, 0.24 + 0.12 * c, col);\n    fills.push([col[0], col[1], col[2]]);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const c = cnt[p];\n    if (c \u003c= 2) continue;\n    const f = fills[min(3, (c - 4) >> 1)];\n    (rgb[o] = f[0]), (rgb[o + 1] = f[1]), (rgb[o + 2] = f[2]);\n  }\n  // Each sample's place between the flattest and the sharpest of the\n  // curve, on a log scale.\n  const lk0 = log(S.kmin), lk1 = log(S.kmax), Q = S.q;\n  for (let i = 0; i \u003c M; i++) Q[i] = K[i] > 0 ? cl((log(K[i]) - lk0) / (lk1 - lk0 || 1), 0, 1) : 0;\n  // The evolute, pale and opposite the curve on the wheel, a little nearer\n  // the curve's own hue where its arc comes from a sharp part, and broken\n  // where it runs off towards an inflection.\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M;\n    if (K[i] > 0 !== K[j] > 0) continue;\n    const xa = px(EX[i]), ya = py(EY[i]), xb = px(EX[j]), yb = py(EY[j]);\n    if (abs(xb - xa) + abs(yb - ya) > 24) continue;\n    hsv(h0 + 0.5 + 0.12 * Q[i], 0.5, 1, col);\n    line(S, xa, ya, xb, yb, col, 0.9);\n  }\n  // Each vertex joined to its cusp by a dotted radius.\n  const join = [0.5, 0.5, 0.55];\n  for (const v of S.vert) line(S, px(v.x), py(v.y), px(v.cx), py(v.cy), join, 0.45, 1);\n  // The osculating circle, in the colour of the curve where it touches.\n  const oc = S.osc;\n  if (oc && abs(oc.kap) > 1e-6) {\n    const R = sc / abs(oc.kap), cx = px(oc.cx), cy = py(oc.cy);\n    hsv(h0 + 0.35 * (oc.kap > 0 ? cl((log(oc.kap) - lk0) / (lk1 - lk0 || 1), 0, 1) : 0), 0.35, 0.8, col);\n    const n = Math.ceil(min(TAU, 300 / R) * R * 2.5);\n    const a0 = Math.atan2(py(oc.y) - cy, px(oc.x) - cx), span = min(PI, 150 / R);\n    for (let e = 0; e \u003c= n; e++) {\n      const a = a0 - span + (2 * span * e) / n;\n      plot(S, cx + R * cos(a), cy + R * sin(a), col, 0.7);\n    }\n  }\n  // The curve, coloured by curvature: flat parts at the base hue, the\n  // sharpest a third of the wheel on.\n  for (let i = 0; i \u003c M; i++) {\n    const j = (i + 1) % M;\n    hsv(h0 + 0.35 * Q[i], 0.85, 1, col);\n    line(S, px(X[i]), py(Y[i]), px(X[j]), py(Y[j]), col, 1);\n  }\n  // Vertices on the curve, their cusps on the evolute.\n  const cusp = [1, 0.92, 0.8];\n  for (const v of S.vert) {\n    dot(S, px(v.x), py(v.y), [1, 1, 1], 1, 1.1);\n    dot(S, px(v.cx), py(v.cy), cusp, 1, 0.9);\n  }\n  if (oc) {\n    dot(S, px(oc.x), py(oc.y), [1, 1, 1], 1, 0.9);\n    dot(S, px(oc.cx), py(oc.cy), cusp, 1, 1);\n  }\n  const evo = [0.7, 0.7, 0.75];\n  // A ring opens where a vertex was born or died: at its cusp, or at the\n  // vertex itself when the cusp is off the panel.\n  for (const f of S.flash) {\n    let fx = px(f.v.cx), fy = py(f.v.cy);\n    if (fx \u003c 0 || fx >= W || fy \u003c 0 || fy >= H) (fx = px(f.v.x)), (fy = py(f.v.y));\n    const r = 1.5 + 6 * f.age, a = 1 - f.age / 0.8, n = 40;\n    for (let e = 0; e \u003c n; e++) plot(S, fx + r * cos((TAU * e) / n), fy + r * sin((TAU * e) / n), f.born ? [1, 1, 1] : evo, a);\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, (255 * cl(rgb[p], 0, 1)) | 0, (255 * cl(rgb[p + 1], 0, 1)) | 0, (255 * cl(rgb[p + 2], 0, 1)) | 0);\n}\n","gaussian-periods":"// ===== Patternflow pattern =====\n// Title:   Gaussian Periods\n// Family:  number\n// Idea:    Every residue k mod n lights one LED at its Gaussian period eta(k), a sum of d roots of unity, so eleven rotated deltoids stand as a sunburst of dots coloured by k mod 11; then every point slides to eta(u k), the burst comes apart, and the same set of points builds it again with the copies' colours traded.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Gaussian periods (Carl Friedrich Gauss, 1801), plotted as William Duke, Stephan Ramon Garcia and Bob Lutz plotted them (2015), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Figure=0..7, Unit=0..2\n//\n// Knob 1: Hue. Turns the colour classes round the wheel together. At 0 the class of k = 0 is cyan and the other classes step evenly round the wheel, ordered so that neighbouring spikes get neighbouring hues.\n// Knob 2: Speed. At 2 the figure rests 1 second and a rebuild takes 1.75 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Figure. Eight pairs (n, omega): eleven rotated deltoids (n = 11 * 991), seven (7 * 1201), four (4 * 1201), a deltoid and its negative (2 * 2719), deltoids scaled by 2 cos(2 pi j / 13) (13 * 1021), the five-cusp star of the prime 12011, a nine-point star (9 * 1093) and the deltoid lace of 7^4.\n// Knob 4: Unit. Which multiplier u the rebuilds use. At 0 a unit that carries points into other colour classes, at 1 one that keeps every class in place so each copy rebuilds itself, at 2 one that turns whole copies about the centre. A figure without copies uses u = -1 there, which folds it onto its mirror image.\n// Buttons: K1 tap goes to the next figure.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, cos, sin, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// [n, omega, colour kind, m, g, q, x zoom, hue step, three units u].\n// Colour kind 0 is k mod m, kind 1 is k mod m up to sign, kind 2 is the class\n// of k mod q among the units mod q, read off the m-th powers of the\n// primitive root g, with k = 0 mod q a class of its own. Each class is a\n// union of whole orbits k, k omega, k omega^2, ..., so every dot has one\n// colour. The hue step orders the classes so that neighbouring spikes get\n// neighbouring hues. The first unit carries points into other classes (on\n// the hexagram none can, so it is a second unit of the next kind), the\n// second keeps every class in place, the third turns whole copies about the\n// centre (u = 1 mod n / m) or, on a figure without copies, is u = -1.\nconst FIG = [\n  [10901, 9032, 0, 11, 0, 0, 1.2, 3, 882, 870, 992], // 11 * 991, omega = 1 mod 11: eleven rotated deltoids\n  [8407, 3032, 0, 7, 0, 0, 1.1, 6, 1363, 2689, 1202], // 7 * 1201: seven rotated deltoids\n  [4804, 4173, 0, 4, 0, 0, 1, 3, 679, 1921, 2403], // 4 * 1201: four rotated deltoids\n  [5438, 1453, 0, 2, 0, 0, 1, 1, 57, 819, 5437], // 2 * 2719: a deltoid and its negative\n  [13273, 3431, 1, 13, 0, 0, 1, 1, 87, 116, 13272], // 13 * 1021, omega = -1 mod 13: deltoids scaled by 2 cos(2 pi j / 13)\n  [12011, 2557, 2, 2, 2, 12011, 1, 1, 1819, 151, 12010], // prime, d = 5: the five-cusp star, by quadratic character\n  [9837, 151, 0, 3, 0, 0, 1, 1, 2960, 31, 3280], // 9 * 1093, omega of order 3 mod 9 too: a nine-point star\n  [2401, 1047, 2, 2, 3, 7, 1, 1, 38, 1086, 2400], // 7^4, d = 3: deltoid lace, by quadratic character of k mod 7\n];\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Build one figure: the orbits of omega on Z/n, eta for every k, the colour\n// of each orbit and the scale that fills the panel.\nfunction build(idx) {\n  const [n, w, kind, m, g, q, zx, hm, u0, u1, u2] = FIG[idx];\n  const pw = [1];\n  for (let x = w % n; x !== 1; x = (x * w) % n) pw.push(x);\n  const d = pw.length;\n  const C = new Float64Array(n), S = new Float64Array(n);\n  for (let k = 0; k \u003c n; k++) (C[k] = cos((TAU * k) / n)), (S[k] = sin((TAU * k) / n));\n  const er = new Float64Array(n), ei = new Float64Array(n);\n  for (let k = 0; k \u003c n; k++) {\n    let a = 0, b = 0;\n    for (let j = 0; j \u003c d; j++) {\n      const r = (k * pw[j]) % n;\n      a += C[r];\n      b += S[r];\n    }\n    er[k] = a;\n    ei[k] = b;\n  }\n  let lg = null;\n  if (kind === 2) {\n    lg = new Int32Array(q);\n    for (let e = 0, x = 1; e \u003c q - 1; e++, x = (x * g) % q) lg[x] = e % m;\n  }\n  const seen = new Uint8Array(n), rep = [];\n  for (let k = 0; k \u003c n; k++) {\n    if (seen[k]) continue;\n    for (let j = 0; j \u003c d; j++) seen[(k * pw[j]) % n] = 1;\n    rep.push(k);\n  }\n  const np = rep.length, ncls = kind === 0 ? m : kind === 1 ? (m >> 1) + 1 : m + 1;\n  const cls = new Int16Array(np), slot = new Float32Array(ncls);\n  for (let p = 0; p \u003c np; p++) {\n    const k = rep[p], r = k % m;\n    cls[p] = kind === 0 ? r : kind === 1 ? min(r, m - r) : k % q === 0 ? m : lg[k % q];\n  }\n  for (let c = 0; c \u003c ncls; c++) slot[c] = ((hm * c) % ncls) / ncls;\n  let r0 = 1e9, r1 = -1e9, i1 = 0;\n  for (let k = 0; k \u003c n; k++) (r0 = min(r0, er[k])), (r1 = max(r1, er[k])), (i1 = max(i1, abs(ei[k])));\n  // The imaginary axis runs across and the real axis up, each scaled to the\n  // panel, so a round figure stands twice as tall as it is wide and complex\n  // conjugation, eta(-k), is the left-right mirror. The eleven and the seven\n  // deltoids are drawn 1.2 and 1.1 times wider and lose the tips of their\n  // side spikes.\n  const sx = (31.2 * zx) / i1, sy = 126.4 / (r1 - r0), cr = (r0 + r1) / 2;\n  return {\n    idx, n, d, pw, er, ei, sx, sy, cr, ncls, slot, units: [u0, u1, u2],\n    cls, cur: Int32Array.from(rep), np, a: new Int32Array(np * d), dl: new Int32Array(np * d),\n  };\n}\n\nexport function setup(params) {\n  params.s = { f: build(0), fig: 0, knobFig: 0, t: 0, s: 0, moving: false, u: 0, hue: -1, palHue: -2, pal: [], grid: new Int16Array(W * H) };\n}\n\nconst TRAVEL = 3.5, REST = 2;\n\n// A rebuild: root j of point k, e(k omega^j / n), turns along the shorter\n// arc to e(u k omega^j / n), so the point ends exactly at eta(u k).\nfunction startRebuild(s, u) {\n  const { n, d, pw, cur, a, dl, np } = s.f;\n  for (let p = 0; p \u003c np; p++) {\n    const k = cur[p], v = (u * k) % n;\n    for (let j = 0; j \u003c d; j++) {\n      const x = (k * pw[j]) % n;\n      let e = ((v * pw[j]) % n) - x;\n      if (e > n / 2) e -= n;\n      else if (e \u003c= -n / 2) e += n;\n      a[p * d + j] = x;\n      dl[p * d + j] = e;\n    }\n  }\n  s.u = u;\n  s.moving = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06], step = cl(dt || 0, 0, 0.1);\n  const kf = cl(round(k[2]), 0, FIG.length - 1);\n  if (kf !== s.knobFig) (s.knobFig = kf), (s.fig = kf);\n  if (input.btnPressed && input.btnPressed[0]) s.fig = (s.fig + 1) % FIG.length;\n  if (s.fig !== s.f.idx) (s.f = build(s.fig)), (s.t = 0), (s.moving = false);\n  const f = s.f;\n  s.hue = cl(k[0], 0, 1);\n  s.t += step * cl(k[1], 0.2, 3);\n  if (!s.moving) {\n    s.s = 0;\n    if (s.t >= REST) (s.t -= REST), startRebuild(s, f.units[cl(round(k[3]), 0, 2)]);\n  }\n  if (s.moving) {\n    if (s.t >= TRAVEL) {\n      s.t -= TRAVEL;\n      s.moving = false;\n      s.s = 0;\n      for (let p = 0; p \u003c f.np; p++) f.cur[p] = (s.u * f.cur[p]) % f.n;\n    } else {\n      const x = s.t / TRAVEL;\n      s.s = x * x * (3 - 2 * x);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  const f = s.f, { n, d, er, ei, sx, sy, cr, cls, cur, a, dl, np, ncls, slot } = f;\n  if (s.palHue !== s.hue || s.pal.length !== ncls) {\n    s.pal = [];\n    for (let c = 0; c \u003c ncls; c++) s.pal.push(hsv(s.hue + 0.5 + slot[c], 0.78, 255));\n    s.palHue = s.hue;\n  }\n  const grid = s.grid;\n  grid.fill(-1);\n  const t = s.s, moving = s.moving && t > 0;\n  for (let p = 0; p \u003c np; p++) {\n    let re = 0, im = 0;\n    if (!moving) (re = er[cur[p]]), (im = ei[cur[p]]);\n    else\n      for (let j = 0, o = p * d; j \u003c d; j++, o++) {\n        const ang = (TAU * (a[o] + t * dl[o])) / n;\n        re += cos(ang);\n        im += sin(ang);\n      }\n    const x = floor(31.5 + im * sx + 0.5), y = floor(63.5 - (re - cr) * sy + 0.5);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) grid[y * W + x] = cls[p];\n  }\n  const pal = s.pal;\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      const c = grid[q];\n      if (c \u003c 0) display.setPixel(x, y, 0, 0, 0);\n      else display.setPixel(x, y, pal[c][0], pal[c][1], pal[c][2]);\n    }\n}\n","leapfrogging-vortices":"// ===== Patternflow pattern =====\n// Title:   Leapfrogging Vortices\n// Family:  sim\n// Idea:    Two smoke rings travel up the panel one behind the other, seen in a slice through their axis as two pairs of dye spirals, and the rear ring keeps shrinking, darting through the front one and widening again while the front one swells, slows and falls behind.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: leapfrogging vortex rings (Hermann von Helmholtz, 1858), as two pairs of point vortices (Walter Gröbli, 1877; A. E. H. Love, 1894), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=3..8, Dye=0..1\n//\n// Knob 1: Hue. Turns both dyes round the wheel together: at 0 the ring that starts in front is emerald and the one behind it magenta.\n// Knob 2: Speed. At 2 a whole leapfrog, each ring passing through the other once, takes 7.9 seconds at the start ratio and the pair climbs 67 LEDs in it; at 0.2 ten times slower.\n// Knob 3: Ratio. How many times wider the big ring is than the small one at the moment the small one passes through it. At 3 the rings leapfrog every 7.9 seconds; at 5 every 41, drifting up to 53 LEDs apart between passes. Love's threshold is 1 / (3 - 2 sqrt 2) = 5.83. From about 5.6 the rings part further than the panel before they turn back, and above 5.83 the small ring darts through once and walks away for good; either way a fresh pair is launched.\n// Knob 4: Dye. How much dye fills the rings' bubbles of water: at the start the spirals in the cores and a thin wake; turned up, two full smoke rings and a long braided wake.\n// Buttons: K1 tap lays fresh dye on both rings.\n\n// Each ring is a pair of point vortices of circulation G in the plane\n// through the axis, one on each side, spinning opposite ways. A ring is the\n// same all round its axis, so only the right-hand vortex of each pair is\n// integrated and its mirror image across the axis carries -G. The slice is\n// four point vortices, and the motion is the one Gröbli and Love worked\n// out: when the small pair passes through the big one, if it is wider than\n// 3 - 2 sqrt 2 = 0.17157 of the big one the two keep leapfrogging, and if it\n// is narrower they part. The threshold is where the energy of the four\n// vortices at that moment equals the most that two pairs far apart can\n// have with the same impulse, so above it they can never get far apart.\n//\n// Checked in a separate run (G = 1, the big pair's half width 1, both\n// level at the start, RK4): at 0.17157 the pairs walked away, 2000 apart at\n// t = 1.3e6; at 0.1716 they came level again at t = 38545, at 0.172 at 2433,\n// at 0.175 at 297. Near the threshold that half period grows as\n// 1 / (ratio - 0.17157). Integrating all four vortices with no mirror\n// imposed and one nudged by 1e-9, the leapfrog broke its mirror symmetry at\n// every ratio up to 0.38 (at 0.3 by t = 62) and held from 0.385, as Acheson\n// (2000) found with 0.382. A ring that stays round cannot do that, hence the\n// mirror. With this file's integrator over 600 seconds at Speed 2 the energy\n// of the four vortices drifted by 2.6e-12 of itself and the impulse along the\n// axis by 3e-14, at every ratio from 3 to 5.5.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, sqrt, sin, cos, exp, abs, log, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = () => Math.random();\n// The big ring's half width when the small one is level with it, in LEDs;\n// circulation per vortex in LED^2 per second at Speed 2, divided by 2 pi;\n// the panel row the rings' middle is held on; dye particles per ring\n// (right half, drawn mirrored); the separation at which a pair is replaced.\nconst A = 22, GAM = 820, G = GAM / (2 * PI), ROW = 52, NPR = 2600, LIM = 104;\n// The vortex step, and the longest dye step, in seconds.\nconst HV = 0.004, HD = 0.018;\n// Dye brightness: density scale, and the share under which dye is only haze.\nconst S0 = 2.2, D0 = 0.06;\nconst JIT = new Uint8Array(N).map((_, p) => h32(p, 77) & 63);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\nfunction h32(i, j) {\n  let h = (Math.imul(i, 374761393) + Math.imul(j, 668265263)) | 0;\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return (h ^ (h >>> 16)) >>> 0;\n}\n\n// Velocity of the two right-hand vortices (x, y up) from the other three.\nconst K1 = new Float64Array(4), K2 = new Float64Array(4), K3 = new Float64Array(4), K4 = new Float64Array(4), TV = new Float64Array(4);\nfunction vvel(V, o) {\n  for (let k = 0; k \u003c 2; k++) {\n    const x = V[2 * k], y = V[2 * k + 1], j = 2 - 2 * k, xj = V[j], dy = y - V[j + 1];\n    const dx = x - xj, r1 = dx * dx + dy * dy, ex = x + xj, r2 = ex * ex + dy * dy;\n    o[2 * k] = G * (dy / r1 - dy / r2);\n    o[2 * k + 1] = G * (0.5 / x - dx / r1 + ex / r2);\n  }\n}\nfunction vstep(V, h) {\n  vvel(V, K1);\n  for (let i = 0; i \u003c 4; i++) TV[i] = V[i] + 0.5 * h * K1[i];\n  vvel(TV, K2);\n  for (let i = 0; i \u003c 4; i++) TV[i] = V[i] + 0.5 * h * K2[i];\n  vvel(TV, K3);\n  for (let i = 0; i \u003c 4; i++) TV[i] = V[i] + h * K3[i];\n  vvel(TV, K4);\n  for (let i = 0; i \u003c 4; i++) V[i] += (h / 6) * (K1[i] + 2 * K2[i] + 2 * K3[i] + K4[i]);\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  params.s = {\n    V: new Float64Array(4), V0: new Float64Array(4), Vm: new Float64Array(4),\n    yc: 0, ratio: -1, want: 3, wait: 0, go: 0, gain: 1,\n    hue: -1, dye: 0.06, d2: 4, nact: NPR,\n    px: F(2 * NPR), py: F(2 * NPR), age: F(2 * NPR), life: F(2 * NPR), pt: [0, 0], pp: [0, 0],\n    M: F(2 * N), M2: F(2 * N), DA: F(N), DB: F(N), col: F(6),\n  };\n}\n\n// Dye. Each ring has NL particles that are laid as straight lines across\n// its core, half of them every PULSE seconds, so each line lives two pulses\n// and winds into a spiral, the inside turning faster than the outside. The\n// rest fill the ring's bubble of water; what the rings shed of it trails\n// behind as the wake, and comes back into a bubble when it leaves the panel.\nconst NL = 360, CL = NL / 2, PULSE = 1.3;\nfunction line(S, k) {\n  const V = S.V, a = V[2 * k], R = 0.62 * a, th = rnd() * PI, c = cos(th), s = sin(th), par = (S.pp[k] ^= 1);\n  for (let m = 0; m \u003c CL; m++) {\n    const i = k * NPR + 2 * m + par, r = R * (((m + 0.5) / CL) * 2 - 1);\n    S.px[i] = abs(a + r * c);\n    S.py[i] = V[2 * k + 1] + r * s;\n    S.age[i] = 0;\n    S.life[i] = 2 * PULSE;\n  }\n}\nfunction bubble(S, i, spread) {\n  const k = i \u003c NPR ? 0 : 1, V = S.V, a = V[2 * k];\n  let x, y;\n  do (x = rnd()), (y = 2 * rnd() - 1);\n  while (x * x + y * y > 1);\n  S.px[i] = 1.5 * a * x;\n  S.py[i] = V[2 * k + 1] + 1.8 * a * y;\n  S.age[i] = spread ? -0.5 * rnd() : 0;\n  S.life[i] = 9 + 12 * rnd();\n}\n\n// A fresh pair: level with the small ring inside the big one, then run\n// backwards until the small one is furthest behind (or LIM / 2 behind, if\n// they would part for good), so it shrinks and darts through first.\nfunction launch(S, ratio) {\n  const V = S.V;\n  V[0] = A, V[1] = 0, V[2] = A / ratio, V[3] = 0;\n  let last = 0;\n  for (let t = 0; t \u003c 60; t += HV * 4) {\n    vstep(V, -HV * 4);\n    const sep = abs(V[1] - V[3]);\n    if (sep \u003c last || sep > LIM * 0.42) break;\n    last = sep;\n  }\n  const m = (V[1] + V[3]) / 2;\n  V[1] += S.yc - m, V[3] += S.yc - m;\n  S.ratio = ratio;\n  fresh(S);\n  // A second and a bit, so the first lines are already spirals.\n  for (let i = 0; i \u003c 70; i++) advance(S, HD);\n}\n\nfunction fresh(S) {\n  for (let k = 0; k \u003c 2; k++) {\n    S.pt[k] = PULSE * (0.5 + 0.5 * k);\n    S.age.fill(9, k * NPR, k * NPR + NL);\n    line(S, k);\n    for (let i = k * NPR + NL; i \u003c (k + 1) * NPR; i++) bubble(S, i, 1);\n  }\n}\n\n// Velocity of the water at (x, y), each core a disc of radius sqrt(d2)\n// turning as a solid body; outside it the same as a point vortex.\nlet U = 0, VY = 0;\nfunction flow(x, y, V, d2) {\n  let u = 0, v = 0;\n  for (let k = 0; k \u003c 4; k += 2) {\n    const xk = V[k], dy = y - V[k + 1], dx = x - xk, ex = x + xk;\n    let r = dx * dx + dy * dy;\n    if (r \u003c d2) r = d2;\n    let q = ex * ex + dy * dy;\n    if (q \u003c d2) q = d2;\n    u += dy / r - dy / q;\n    v += ex / q - dx / r;\n  }\n  U = G * u;\n  VY = G * v;\n}\n\nfunction advance(S, h) {\n  const { V, V0, Vm, px, py, age, life, nact, d2 } = S;\n  V0.set(V);\n  const n = Math.max(1, Math.round(h / 2 / HV)), hv = h / 2 / n;\n  for (let i = 0; i \u003c n; i++) vstep(V, hv);\n  Vm.set(V);\n  for (let i = 0; i \u003c n; i++) vstep(V, hv);\n  for (let k = 0; k \u003c 2; k++) if ((S.pt[k] -= h) \u003c= 0) (S.pt[k] += PULSE), line(S, k);\n  for (let i = 0; i \u003c 2 * NPR; i++) {\n    const j = i \u003c NPR ? i : i - NPR;\n    if (j >= nact) continue;\n    if (j >= NL && ((age[i] += h) > life[i] || py[i] \u003c S.yc + ROW - H - 3 || px[i] > 36)) {\n      bubble(S, i, 0);\n      continue;\n    }\n    if (j \u003c NL) age[i] += h;\n    const x = px[i], y = py[i];\n    flow(x, y, V0, d2);\n    const u1 = U, v1 = VY;\n    flow(x + 0.5 * h * u1, y + 0.5 * h * v1, Vm, d2);\n    const u2 = U, v2 = VY;\n    flow(x + 0.5 * h * u2, y + 0.5 * h * v2, Vm, d2);\n    const u3 = U, v3 = VY;\n    flow(x + h * u3, y + h * v3, V, d2);\n    px[i] = abs(x + (h / 6) * (u1 + 2 * u2 + 2 * u3 + U));\n    py[i] = y + (h / 6) * (v1 + 2 * v2 + 2 * v3 + VY);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3), want = cl(k[2], 3, 8);\n  S.dye = cl(k[3], 0, 1);\n  S.nact = NL + Math.round((NPR - NL) * (0.25 + 0.75 * S.dye));\n  if (S.ratio \u003c 0) launch(S, want), (S.want = want);\n  if (abs(want - S.want) > 0.01) (S.want = want), (S.wait = 0.3);\n  if (S.wait > 0 && (S.wait -= d) \u003c= 0 && !S.go) S.go = 0.5;\n  const p = input.btnPressed || [];\n  if (p[0]) fresh(S);\n  // Rings that have parted beyond the panel make way for a fresh pair.\n  if (!S.go && abs(S.V[1] - S.V[3]) > LIM) S.go = 0.5;\n  if (S.go) {\n    S.gain = S.go / 0.5;\n    if ((S.go -= d) \u003c= 0) (S.go = 0), launch(S, S.want), (S.gain = 0);\n  } else S.gain = min(1, S.gain + d / 0.5);\n  const h = (d * sp) / 2, n = Math.ceil(h / HD - 1e-9);\n  // Heights are kept within a few thousand LEDs of the start.\n  if (S.yc > 4096) {\n    (S.V[1] -= 4096), (S.V[3] -= 4096), (S.yc -= 4096);\n    for (let i = 0; i \u003c 2 * NPR; i++) S.py[i] -= 4096;\n    for (let i = 1; i \u003c 2 * N; i += 2) S.M[i] -= 4096;\n  }\n  const yc0 = S.yc;\n  if (!S.mset) {\n    S.mset = 1;\n    for (let j = 0; j \u003c H; j++) for (let i = 0; i \u003c W; i++) (S.M[2 * (j * W + i)] = i - 31.5), (S.M[2 * (j * W + i) + 1] = yc0 + ROW - j - 0.5);\n  }\n  for (let i = 0; i \u003c n; i++) advance(S, h / n);\n  S.yc = (S.V[1] + S.V[3]) / 2;\n  water(S, h, yc0);\n}\n\n// The water carries fine glitter that catches the light sheet, too faint to\n// light an LED. Each LED keeps the place its water came from (M), carried\n// back along the flow every frame, and shows the glitter of that place, so\n// still water slides down past the rings and the water they carry turns.\nfunction water(S, h, yc0) {\n  const { V, M, M2, d2 } = S;\n  for (let j = 0; j \u003c H; j++) {\n    const y = S.yc + ROW - j - 0.5;\n    for (let i = 32; i \u003c W; i++) {\n      const x = i - 31.5;\n      flow(x, y, V, d2);\n      for (let s = 0; s \u003c 2; s++) {\n        const X = s ? -x : x, u = s ? -U : U, xb = X - h * u, yb = y - h * VY;\n        const fx = xb + 31.5, fy = yc0 + ROW - yb - 0.5, o = 2 * (j * W + (s ? 63 - i : i));\n        if (fx \u003c 0 || fx > W - 1 || fy \u003c 0 || fy > H - 1) {\n          M2[o] = xb, M2[o + 1] = yb;\n          continue;\n        }\n        const ix = floor(fx), iy = floor(fy), ax = fx - ix, ay = fy - iy, q = 2 * (iy * W + ix), q2 = q + (ix \u003c W - 1 ? 2 : 0), q3 = q + (iy \u003c H - 1 ? 2 * W : 0), q4 = q3 + (ix \u003c W - 1 ? 2 : 0);\n        for (let c = 0; c \u003c 2; c++) M2[o + c] = (M[q + c] * (1 - ax) + M[q2 + c] * ax) * (1 - ay) + (M[q3 + c] * (1 - ax) + M[q4 + c] * ax) * ay;\n      }\n    }\n  }\n  S.M = M2, S.M2 = M;\n}\n\nfunction splat(D, x, y, w) {\n  const fx = x - 0.5, fy = y - 0.5, ix = floor(fx), iy = floor(fy);\n  if (ix \u003c -1 || ix >= W || iy \u003c -1 || iy >= H) return;\n  const ax = fx - ix, ay = fy - iy;\n  if (iy >= 0) {\n    if (ix >= 0) D[iy * W + ix] += w * (1 - ax) * (1 - ay);\n    if (ix \u003c W - 1) D[iy * W + ix + 1] += w * ax * (1 - ay);\n  }\n  if (iy \u003c H - 1) {\n    if (ix >= 0) D[(iy + 1) * W + ix] += w * (1 - ax) * ay;\n    if (ix \u003c W - 1) D[(iy + 1) * W + ix + 1] += w * ax * ay;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.ratio \u003c 0) return;\n  const { px, py, age, life, DA, DB, col, M, nact } = S;\n  hsv(S.hue + 0.4, 0.55, 1, col, 0);\n  hsv(S.hue + 0.86, 0.5, 1, col, 3);\n  DA.fill(0), DB.fill(0);\n  for (let i = 0; i \u003c 2 * NPR; i++) {\n    const j = i \u003c NPR ? i : i - NPR;\n    if (j >= nact) continue;\n    const a = age[i], w = (j \u003c NL ? min(1, a / 0.5, (life[i] - a) / 0.6) : 0.22 * min(1, a / 0.5, (life[i] - a) / 2)) * min(1, 0.5 + px[i]);\n    if (w \u003c= 0) continue;\n    const y = ROW + S.yc - py[i], D = i \u003c NPR ? DA : DB;\n    splat(D, 32 + px[i], y, w), splat(D, 32 - px[i], y, w);\n  }\n  const gain = S.gain, cA0 = col[0], cA1 = col[1], cA2 = col[2], cB0 = col[3], cB1 = col[4], cB2 = col[5];\n  for (let p = 0; p \u003c N; p++) {\n    // The glitter of the water this LED shows, never past 24, and a fixed\n    // flicker of a level or two per LED under it.\n    const g = h32(floor(M[2 * p] + 64), floor(M[2 * p + 1]) & 4095), q = JIT[p];\n    let r = (((g & 31) * 22) >> 5) + (q & 3), gg = ((((g >> 5) & 31) * 22) >> 5) + ((q >> 2) & 3), b = ((((g >> 10) & 31) * 22) >> 5) + ((q >> 4) & 3);\n    const a = DA[p], c = DB[p], s = a + c;\n    if (s > 0.01) {\n      const D = gain * (1 - exp(-s / S0)), u = a / s, c0 = cB0 + (cA0 - cB0) * u, c1 = cB1 + (cA1 - cB1) * u, c2 = cB2 + (cA2 - cB2) * u;\n      if (D \u003c D0) {\n        // Thin dye is a haze in the water that stays under the LEDs' threshold.\n        const t = (0.7 * D) / D0;\n        (r += (24 * c0 - r) * t), (gg += (24 * c1 - gg) * t), (b += (24 * c2 - b) * t);\n      } else {\n        const v = 28 + 227 * ((D - D0) / (1 - D0)) ** 0.45, e = 2.4;\n        (r = v * c0 + (r - 12) * e), (gg = v * c1 + (gg - 12) * e), (b = v * c2 + (b - 12) * e);\n      }\n    }\n    display.setPixel(p & 63, p >> 6, cl(r, 0, 255) | 0, cl(gg, 0, 255) | 0, cl(b, 0, 255) | 0);\n  }\n}\n","max-flow-min-cut":"// ===== Patternflow pattern =====\n// Title:   Max-Flow Min-Cut\n// Family:  algo\n// Idea:    A triangular network of pipes, the wide ones holding more, runs from a source bar along the bottom to a sink bar along the top; pulses climb it one shortest augmenting path at a time and fill the pipes cyan until the full ones turn gold, then the nodes the source can still reach fill in as a pool that stops at a jagged line, and the full pipes crossing that line flash while the sink bar splits into their capacities, which add up to exactly the flow that got through.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: max-flow min-cut theorem (Lester R. Ford Jr. and Delbert R. Fulkerson, 1956; Peter Elias, Amiel Feinstein and Claude Shannon, 1956), augmenting along shortest paths (Yefim Dinitz, 1970; Jack Edmonds and Richard Karp, 1972), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Columns=7..13, Grain=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the empty pipes are steel blue, flow is cyan, a full pipe is gold and the cut flashes between gold and pale pink. The dim colours, the empty pipes and the pool, lose their saturation between red and lime so they never go brown or olive.\n// Knob 2: Speed. At 2 a pulse climbs the panel in a second, the augmenting paths start one after another for five seconds, and a whole run from the first pulse to the next network takes eleven; at 0.2 ten times as long, at 3 two thirds as long.\n// Knob 3: Columns. The network is 7 to 13 nodes wide in a triangular lattice: 15 rows, 98 nodes and 251 pipes at 7, and 28 rows, 350 nodes and 970 pipes at 13. Turning it builds a new network.\n// Knob 4: Grain. How much of each pipe's capacity is its own random draw rather than the smooth terrain with its wavy band of thin pipes. Near 0 neighbouring pipes hold about the same and the cut follows the band; at 1 the capacities scatter pipe by pipe from 1 to 9, a quarter of them 9 and an eighth 1, and the cut wanders. Turning it drains the flow and runs the same network again on the new capacities.\n// Buttons: K1 tap draws new capacities now.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// 1 at the middle of the arc of the wheel from red through orange and\n// yellow to lime, 0 outside it.\nconst warm = (h) => ((h -= floor(h)), h \u003c 0.3 ? sin((PI * h) / 0.3) : 0);\n// Rows of nodes run from y = BOT up to y = TOP; the source bar is the two\n// bottom rows of LEDs and the sink bar the two top rows.\nconst TOP = 6, BOT = 121, SRC_Y = 126.5, SINK_Y = 0.5;\n// Pulse speed in LEDs per unit of time (Speed 2 runs two units a second).\nconst V = 70;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The lattice: rows of C and C - 1 nodes in turn, each node tied to its\n// neighbours in the row and to the two nearest in the rows above and below.\nfunction build(s, C) {\n  const sx = W / C, R = max(4, round((BOT - TOP) / (sx * 0.87)) + 1), sy = (BOT - TOP) / (R - 1);\n  const X = [], Y = [], rows = [];\n  for (let r = 0; r \u003c R; r++) {\n    const odd = r & 1, cnt = odd ? C - 1 : C, ids = [];\n    for (let i = 0; i \u003c cnt; i++) {\n      let x = 31.5 + sx * (i - (cnt - 1) / 2), y = BOT - r * sy;\n      if (r > 0 && r \u003c R - 1) y += (Math.random() - 0.5) * 0.34 * sy;\n      x += (Math.random() - 0.5) * 0.34 * sx;\n      ids.push(X.length);\n      X.push(cl(x, 0.5, 62.5));\n      Y.push(y);\n    }\n    rows.push(ids);\n  }\n  const eu = [], ev = [];\n  for (let r = 0; r \u003c R; r++) {\n    const a = rows[r];\n    for (let i = 0; i + 1 \u003c a.length; i++) eu.push(a[i]), ev.push(a[i + 1]);\n    if (r + 1 \u003c R) {\n      const b = rows[r + 1];\n      for (let i = 0; i \u003c a.length; i++)\n        for (const j of r & 1 ? [i, i + 1] : [i - 1, i]) if (j >= 0 && j \u003c b.length) eu.push(a[i]), ev.push(b[j]);\n    }\n  }\n  const n = X.length, m = eu.length;\n  const deg = new Int32Array(n + 1);\n  for (let k = 0; k \u003c m; k++) deg[eu[k] + 1]++, deg[ev[k] + 1]++;\n  for (let i = 0; i \u003c n; i++) deg[i + 1] += deg[i];\n  const adjE = new Int32Array(2 * m), fill = deg.slice(0, n);\n  for (let k = 0; k \u003c m; k++) (adjE[fill[eu[k]]++] = k), (adjE[fill[ev[k]]++] = k);\n  // Each pipe's samples, one per LED along its longer axis: the LED on that\n  // axis (sb), where the line crosses the other axis (sm), the step to the\n  // next LED across (ss), and the share of the way from eu to ev (tt).\n  const sb = [], sm = [], ss = [], tt = [], off = new Int32Array(m + 1);\n  for (let k = 0; k \u003c m; k++) {\n    const x1 = X[eu[k]], y1 = Y[eu[k]], dx = X[ev[k]] - x1, dy = Y[ev[k]] - y1, flat = abs(dx) >= abs(dy);\n    const steps = max(2, Math.ceil(max(abs(dx), abs(dy))));\n    for (let j = 1; j \u003c steps; j++) {\n      const t = j / steps, px = x1 + dx * t, py = y1 + dy * t;\n      sb.push(flat ? round(px) : round(py) * W);\n      sm.push(flat ? py : px);\n      ss.push(flat ? W : 1);\n      tt.push(t);\n    }\n    off[k + 1] = sb.length;\n  }\n  // The node nearest each LED, for the pool the source can reach.\n  const near = new Int16Array(N);\n  for (let p = 0; p \u003c N; p++) {\n    const px = p % W, py = (p / W) | 0;\n    let best = 1e9, bi = 0;\n    for (let i = 0; i \u003c n; i++) {\n      const d = (X[i] - px) ** 2 + (Y[i] - py) ** 2;\n      if (d \u003c best) (best = d), (bi = i);\n    }\n    near[p] = bi;\n  }\n  const isBot = new Uint8Array(n), isTop = new Uint8Array(n);\n  for (const i of rows[0]) isBot[i] = 1;\n  for (const i of rows[R - 1]) isTop[i] = 1;\n  Object.assign(s, {\n    C, n, m, X: Float32Array.from(X), Y: Float32Array.from(Y), eu: Int32Array.from(eu), ev: Int32Array.from(ev),\n    deg, adjE, sb: Int32Array.from(sb), sm: Float32Array.from(sm), ss: Int32Array.from(ss), tt: Float32Array.from(tt), off, near,\n    bottom: Int32Array.from(rows[0]), isBot, isTop,\n    g: new Float32Array(m), e: new Float32Array(m), cap: new Int32Array(m), flow: new Int32Array(m), dcap: new Float32Array(m), dcap0: new Float32Array(m),\n    dflow: new Float32Array(m), dflow0: new Float32Array(m), inS: new Uint8Array(n), level: new Int32Array(n), vS: new Uint8Array(n), vLevel: new Int32Array(n),\n    dist: new Int32Array(n), prevE: new Int32Array(n), queue: new Int32Array(n), cut: new Uint8Array(m),\n  });\n}\n\n// Fresh random capacities. Each pipe gets a share g from a smooth terrain\n// of a few broad waves, cut by a wavy band of thin pipes somewhere across\n// the middle and thickened near the two bars, and a draw of its own, e.\nfunction drawField(s) {\n  const w = [];\n  for (let i = 0; i \u003c 3; i++) w.push([TAU * Math.random(), (0.03 + 0.07 * Math.random()) * (Math.random() \u003c 0.5 ? -1 : 1), 0.02 + 0.05 * Math.random()]);\n  const yc = 44 + 40 * Math.random(), A = 5 + 11 * Math.random(), fx = (TAU * (0.6 + Math.random())) / W, ph = TAU * Math.random(), bw = 7 + 5 * Math.random();\n  for (let k = 0; k \u003c s.m; k++) {\n    const x = (s.X[s.eu[k]] + s.X[s.ev[k]]) / 2, y = (s.Y[s.eu[k]] + s.Y[s.ev[k]]) / 2;\n    let f = 0;\n    for (const [a, ax, ay] of w) f += sin(a + ax * x + ay * y) / 3;\n    const band = Math.exp(-(((y - yc - A * sin(fx * x + ph)) / bw) ** 2)), bar = cl(1 - min(y - TOP, BOT - y) / 18, 0, 1);\n    s.g[k] = 0.6 + 0.3 * f - 0.5 * band + 0.3 * bar;\n    s.e[k] = Math.random() - 0.5;\n  }\n}\n\nfunction capacities(s, grain) {\n  const a = 0.25 + 1.1 * grain;\n  for (let k = 0; k \u003c s.m; k++) s.cap[k] = cl(round(1 + 8 * (s.g[k] + a * s.e[k])), 1, 9);\n}\n\n// Residual capacity of pipe k leaving node u.\nconst resid = (s, k, u) => (s.eu[k] === u ? s.cap[k] - s.flow[k] : s.cap[k] + s.flow[k]);\n\n// Breadth-first search from every bottom node at once over pipes with room\n// left. Returns the first top node reached, or -1 once the sink is cut off;\n// dist then marks the nodes the source still reaches.\nfunction bfs(s) {\n  const { dist, prevE, queue, bottom, adjE, deg, eu, ev, isTop } = s;\n  dist.fill(-1);\n  let h = 0, t = 0;\n  // The bottom nodes enter the queue in a new order each search.\n  for (const b of bottom) {\n    const j = floor(Math.random() * (t + 1));\n    queue[t++] = queue[j];\n    queue[j] = b;\n  }\n  for (let i = 0; i \u003c t; i++) (dist[queue[i]] = 0), (prevE[queue[i]] = -1);\n  while (h \u003c t) {\n    const u = queue[h++];\n    if (isTop[u]) return u;\n    for (let j = deg[u]; j \u003c deg[u + 1]; j++) {\n      const k = adjE[j], v = eu[k] === u ? ev[k] : eu[k];\n      if (dist[v] \u003c 0 && resid(s, k, u) > 0) (dist[v] = dist[u] + 1), (prevE[v] = k), (queue[t++] = v);\n    }\n  }\n  return -1;\n}\n\n// Edmonds-Karp: augment along a shortest path until none is left, keeping\n// every path for the pulses; then read the cut off the last search.\nfunction solve(s) {\n  const { eu, ev, adjE, deg, flow } = s;\n  flow.fill(0);\n  // Shuffle each node's pipes so ties between shortest paths fall anywhere.\n  for (let u = 0; u \u003c s.n; u++)\n    for (let j = deg[u + 1] - 1; j > deg[u]; j--) {\n      const r = deg[u] + floor(Math.random() * (j - deg[u] + 1)), x = adjE[j];\n      (adjE[j] = adjE[r]), (adjE[r] = x);\n    }\n  s.paths = [];\n  s.F = 0;\n  for (let top; (top = bfs(s)) >= 0; ) {\n    const nodes = [top], ks = [];\n    let d = 1e9;\n    for (let v = top; s.prevE[v] >= 0; ) {\n      const k = s.prevE[v], u = eu[k] === v ? ev[k] : eu[k];\n      d = min(d, resid(s, k, u));\n      ks.push(k);\n      nodes.push(u);\n      v = u;\n    }\n    nodes.reverse();\n    ks.reverse();\n    const sg = new Int8Array(ks.length);\n    ks.forEach((k, i) => {\n      sg[i] = eu[k] === nodes[i] ? 1 : -1;\n      flow[k] += sg[i] * d;\n    });\n    // The pulse's way: up from the source bar, along the path, into the sink bar.\n    const pts = [s.X[nodes[0]], SRC_Y];\n    for (const v of nodes) pts.push(s.X[v], s.Y[v]);\n    pts.push(s.X[top], SINK_Y);\n    const cum = new Float32Array(pts.length / 2);\n    for (let i = 1; i \u003c cum.length; i++) cum[i] = cum[i - 1] + Math.hypot(pts[2 * i] - pts[2 * i - 2], pts[2 * i + 1] - pts[2 * i - 1]);\n    s.paths.push({ pts, cum, ks, sg, d, j: 0 });\n    s.F += d;\n  }\n  // The last search found no top node: what it reached is the source's side.\n  let lv = 0;\n  for (let i = 0; i \u003c s.n; i++) (s.inS[i] = s.dist[i] >= 0 ? 1 : 0), (s.level[i] = s.dist[i]), (lv = max(lv, s.dist[i]));\n  s.maxLevel = lv;\n  s.cutCap = 0;\n  s.cutList = [];\n  for (let k = 0; k \u003c s.m; k++) {\n    s.cut[k] = s.inS[eu[k]] !== s.inS[ev[k]] ? 1 : 0;\n    if (s.cut[k]) (s.cutCap += s.cap[k]), s.cutList.push(k);\n  }\n  // Left to right, for the pieces of the sink bar.\n  s.cutList.sort((a, b) => s.X[eu[a]] + s.X[ev[a]] - s.X[eu[b]] - s.X[ev[b]]);\n  const P = s.paths.length;\n  s.gap = cl(10 / max(1, P), 0.15, 0.9);\n  s.paths.forEach((p, i) => (p.t0 = i * s.gap));\n  s.flowEnd = P ? (P - 1) * s.gap + s.paths[P - 1].cum[s.paths[P - 1].cum.length - 1] / V : 0;\n  s.arrived = 0;\n}\n\n// A new run: capacities from the current field, the flow drained from what\n// the panel shows over DRAIN units while the pipes take their new widths.\nconst DRAIN = 2, REVEAL = 2.5, HOLD = 5;\nfunction restart(s, fresh) {\n  if (fresh) drawField(s);\n  capacities(s, s.k4);\n  solve(s);\n  s.dcap0.set(s.dcap);\n  s.dflow0.set(s.dflow);\n  s.glow0 = s.glow;\n  s.phase = 1;\n  s.pt = 0;\n}\n\nexport function setup(params) {\n  // The network itself is built on the first update, from the knobs.\n  params.s = { C: 0, t: 0, hue: 0, k4: 0.06, glow: 0, glow0: 0, phase: 2, pt: 0, rgb: new Float32Array(N * 3), col: new Float32Array(15) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 7, 0.06], d = cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3);\n  s.hue = cl(k[0], 0, 1);\n  const C = round(cl(k[2], 7, 13)), k4 = cl(k[3], 0, 1);\n  if (C !== s.C) {\n    build(s, C);\n    s.k4 = k4;\n    drawField(s);\n    capacities(s, s.k4);\n    solve(s);\n    s.dcap.set(s.cap);\n    s.glow = 0;\n    s.phase = 2;\n    s.pt = 0;\n  } else if (abs(k4 - s.k4) > 0.004) {\n    s.k4 = k4;\n    restart(s, false);\n  }\n  if (input.btnPressed && input.btnPressed[0]) restart(s, true);\n  s.t += d;\n  s.pt += d;\n  if (s.phase === 1) {\n    // Drain: flow and pool fade, capacities ease to the new ones.\n    const e = cl(s.pt / DRAIN, 0, 1), q = e * e * (3 - 2 * e);\n    for (let i = 0; i \u003c s.m; i++) (s.dcap[i] = s.dcap0[i] + (s.cap[i] - s.dcap0[i]) * q), (s.dflow[i] = s.dflow0[i] * (1 - q));\n    s.glow = s.glow0 * (1 - q);\n    if (e >= 1) (s.phase = 2), (s.pt = 0), s.dflow.fill(0), s.dcap.set(s.cap);\n  } else if (s.phase === 2) {\n    // Augment: as a pulse's head passes the end of a pipe, the pipe takes its flow.\n    for (const p of s.paths) {\n      const dist = (s.pt - p.t0) * V;\n      while (p.j \u003c p.ks.length && dist >= p.cum[p.j + 2]) {\n        s.dflow[p.ks[p.j]] += p.sg[p.j] * p.d;\n        p.j++;\n      }\n      if (!p.done && dist >= p.cum[p.cum.length - 1]) (p.done = 1), (s.arrived += p.d);\n    }\n    // Every path is in: show the side the source still reaches, kept apart\n    // so the next run's search does not move the pool while it fades.\n    if (s.pt > s.flowEnd + 0.4) (s.phase = 3), (s.pt = 0), s.vS.set(s.inS), s.vLevel.set(s.level);\n  } else if (s.phase === 3) {\n    s.glow = 1;\n    if (s.pt > REVEAL + HOLD) restart(s, true);\n  }\n}\n\n// Brightest-wins write, so pipes meeting at a node do not pile up.\nfunction put(rgb, p, r, g, b) {\n  const o = p * 3;\n  if (r > rgb[o]) rgb[o] = r;\n  if (g > rgb[o + 1]) rgb[o + 1] = g;\n  if (b > rgb[o + 2]) rgb[o + 2] = b;\n}\nfunction add(rgb, x, y, r, g, b, w) {\n  const xi = round(x), yi = round(y);\n  if (xi \u003c 0 || xi >= W || yi \u003c 0 || yi >= H) return;\n  const o = (yi * W + xi) * 3;\n  rgb[o] += r * w;\n  rgb[o + 1] += g * w;\n  rgb[o + 2] += b * w;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s || !s.C) return;\n  const { rgb, col, n, m, eu, ev, sb, sm, ss, tt, off, dcap, dflow, near, vS, vLevel } = s;\n  rgb.fill(0);\n  const hb = s.hue + 0.5;\n  // The dim colours lose their saturation near orange and yellow, which\n  // read brown and olive on the panel when dim.\n  hsv(hb + 0.08, 0.45 * (1 - 0.85 * warm(hb + 0.08)), 1, col, 0); // empty pipe\n  hsv(hb, 0.8, 1, col, 3); // flow\n  hsv(hb + 0.62, 0.78, 1, col, 6); // full pipe\n  hsv(hb + 0.4, 0.45, 1, col, 9); // cut flash\n  hsv(hb, 0.8 * (1 - 0.8 * warm(hb)), 1, col, 12); // pool\n  // The pool: LEDs whose nearest node the source still reaches, rising by\n  // search level, with its rim (the cut line, a path in the dual) brighter.\n  const reveal = s.phase === 3 ? (s.pt / REVEAL) * (s.maxLevel + 2) : s.phase === 1 ? 1e9 : -1;\n  if (s.glow > 0.01 && reveal >= 0) {\n    for (let p = 0; p \u003c N; p++) {\n      const i = near[p];\n      if (!vS[i]) continue;\n      const a = cl(reveal - vLevel[i], 0, 1) * s.glow;\n      if (a \u003c= 0) continue;\n      const x = p % W, y = (p / W) | 0;\n      const rim = (y > 0 && !vS[near[p - W]]) || (x > 0 && !vS[near[p - 1]]) || (x \u003c W - 1 && !vS[near[p + 1]]);\n      const v = (rim ? 110 : 34) * a;\n      put(rgb, p, col[12] * v, col[13] * v, col[14] * v);\n    }\n  }\n  const hold = s.phase === 3 ? cl((s.pt - REVEAL) / 0.4, 0, 1) : 0;\n  const flash = 0.5 + 0.5 * sin(s.t * 7), wf = warm(hb);\n  for (let k = 0; k \u003c m; k++) {\n    const cap = max(dcap[k], 0.01), r = min(1, abs(dflow[k]) / cap), cf = cap / 9;\n    // A pipe's width and brightness both grow with its capacity.\n    let wd = 0.6 + cf;\n    const v0 = 0.1 + 0.36 * cf * sqrt(cf);\n    let cr = col[0] * v0, cg = col[1] * v0, cb = col[2] * v0;\n    if (r > 0.999) {\n      cr = col[6];\n      cg = col[7];\n      cb = col[8];\n      // Once the cut is found, full pipes off it go back to the flow colour.\n      if (!s.cut[k] && hold > 0) {\n        cr += (col[3] * 0.8 - cr) * hold;\n        cg += (col[4] * 0.8 - cg) * hold;\n        cb += (col[5] * 0.8 - cb) * hold;\n      } else if (hold > 0) {\n        const f = hold * flash;\n        cr += (col[9] - cr) * f;\n        cg += (col[10] - cg) * f;\n        cb += (col[11] - cb) * f;\n        wd += hold * (0.6 + 0.6 * flash);\n      }\n    } else if (r > 0) {\n      // Part full: brighter with its share, and lifted near yellow.\n      const v = 0.45 + 0.4 * r + 0.25 * (1 - r) * wf, a = 0.4 + 0.6 * r;\n      cr += (col[3] * v - cr) * a;\n      cg += (col[4] * v - cg) * a;\n      cb += (col[5] * v - cb) * a;\n    }\n    // Flow runs along the pipe as faint ripples from the side it comes from.\n    const dir = dflow[k] > 0 ? 1 : -1, wave = r > 0 && r \u003c 0.999 ? 0.25 : 0, hw = wd / 2;\n    const len = Math.hypot(s.X[ev[k]] - s.X[eu[k]], s.Y[ev[k]] - s.Y[eu[k]]);\n    for (let j = off[k]; j \u003c off[k + 1]; j++) {\n      const w0 = (1 - wave + wave * sin(TAU * ((dir * tt[j] * len) / 5 - s.t * 0.9))) * 255;\n      const c = sm[j], top = ss[j] === W ? H : W;\n      for (let i = max(0, Math.ceil(c - hw - 0.5)); i \u003c= min(top - 1, floor(c + hw + 0.5)); i++) {\n        const cover = min(i + 0.5, c + hw) - max(i - 0.5, c - hw);\n        if (cover > 0) put(rgb, sb[j] + i * ss[j], cr * cover * w0, cg * cover * w0, cb * cover * w0);\n      }\n    }\n  }\n  // Nodes.\n  for (let i = 0; i \u003c n; i++) {\n    const p = round(s.Y[i]) * W + round(s.X[i]);\n    const v = vS[i] && s.glow > 0 && reveal > vLevel[i] ? 200 : 120;\n    put(rgb, p, v * 0.9, v * 0.95, v);\n  }\n  // Pulses: a white head and a tail in the flow colour.\n  if (s.phase === 2)\n    for (const p of s.paths) {\n      const dist = (s.pt - p.t0) * V, L = p.cum[p.cum.length - 1];\n      if (dist \u003c 0 || dist > L + 12) continue;\n      let seg = 0;\n      for (let j = 0; j \u003c 14; j++) {\n        const dd = dist - j;\n        if (dd \u003c 0) break;\n        if (dd > L) continue;\n        while (seg + 1 \u003c p.cum.length - 1 && p.cum[seg + 1] \u003c dd) seg++;\n        while (seg > 0 && p.cum[seg] > dd) seg--;\n        const f = (dd - p.cum[seg]) / max(1e-6, p.cum[seg + 1] - p.cum[seg]);\n        const x = p.pts[2 * seg] + (p.pts[2 * seg + 2] - p.pts[2 * seg]) * f, y = p.pts[2 * seg + 1] + (p.pts[2 * seg + 3] - p.pts[2 * seg + 1]) * f;\n        if (j === 0) {\n          add(rgb, x, y, 255, 255, 255, 1);\n          for (const [ox, oy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) add(rgb, x + ox, y + oy, col[3], col[4], col[5], 140);\n        } else {\n          const w = (1 - j / 14) ** 2 * 230;\n          add(rgb, x, y, col[3], col[4], col[5], w);\n        }\n      }\n    }\n  // Source bar along the bottom, sink bar along the top. The sink bar lights\n  // from the middle out as the flow arrives; once the cut is found it splits\n  // into one piece per cut pipe, as wide as its share of the flow, and the\n  // pieces fill the bar exactly.\n  for (let x = 0; x \u003c W; x++) for (const y of [126, 127]) put(rgb, y * W + x, col[3] * 200, col[4] * 200, col[5] * 200);\n  const fill = s.phase === 2 ? s.arrived / max(1, s.F) : s.phase === 3 ? 1 : s.glow;\n  if (hold > 0) {\n    let x0 = 0;\n    s.cutList.forEach((k, i) => {\n      const x1 = x0 + (W * s.cap[k]) / s.F, c = i & 1 ? 6 : 9, a = i & 1 ? 0.9 : 0.55 + 0.45 * flash;\n      for (let x = round(x0); x \u003c round(x1); x++) for (const y of [0, 1]) put(rgb, y * W + x, col[c] * 230 * a, col[c + 1] * 230 * a, col[c + 2] * 230 * a);\n      x0 = x1;\n    });\n  } else\n    for (let x = 0; x \u003c W; x++) {\n      const v = abs(x - 31.5) \u003c fill * 32 ? 200 : 60;\n      for (const y of [0, 1]) put(rgb, y * W + x, col[3] * v, col[4] * v, col[5] * v);\n    }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, min(255, rgb[p * 3]), min(255, rgb[p * 3 + 1]), min(255, rgb[p * 3 + 2]));\n}\n","squared-rectangle":"// ===== Patternflow pattern =====\n// Title:   Squared Rectangle\n// Family:  cells\n// Idea:    A network of resistors between a top and a bottom pole is drawn the way Brooks, Smith, Stone and Tutte drew it, one tile per wire with the voltage drop for its height and the current for its width, so the tiles always fill one tall rectangle exactly while the conductances wander and stretch them, and every few seconds the conductances all come back to 1 and the tiling snaps into squares, with a new network now and then giving a new squared rectangle.\n// Author:  patternflow-lab\n// Date:    2026-10-26\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: squared rectangles from electrical networks (R. L. Brooks, C. A. B. Smith, A. H. Stone and W. T. Tutte, 1940), after Zbigniew Moroń's first squared rectangle (1925), pattern round 53\n// Round:   53\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tiles=13..20, Wander=-1..1\n//\n// Knob 1: Hue. Turns the palette round the wheel. A tile's colour comes from its size against the biggest and smallest tiles shown: at 0 the biggest is teal, the middling ones blue, violet and pink, and the smallest orange.\n// Knob 2: Speed. At 2 a cycle takes 8 seconds: the squares hold for 1.2, the conductances drift for 5.6, and the tiling snaps back into squares at the end of the eighth second with a flash on every seam. Every second cycle the network is rewired; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Tiles. How many wires the network has, so how many squares the snap shows, from 13 to 20. Rewiring keeps the count within one of the knob; at 16, 17 and 19 the first rectangle shown is perfect, every square a different size.\n// Knob 4: Wander. How far each conductance drifts from 1: within a factor of 1.4 at -1, 2 at the opening 0.06, and 4.5 at 1.\n// Buttons: K1 tap snaps the tiling into squares now.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, sin, sqrt, log, atan2, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\n\n// The network lives on a triangular lattice of 3 by 4 nodes, the top pole\n// above it wired to the first row and the bottom pole below wired to the\n// last. Positions only fix the order of the wires round each node, which\n// is all the drawing needs: the plane picture says which faces lie on\n// either side of a wire.\nconst CW = 3, RW = 4, NI = CW * RW, PS = NI, PT = NI + 1, NN = NI + 2;\nconst NX = [], NY = [];\nfor (let j = 0; j \u003c RW; j++) for (let i = 0; i \u003c CW; i++) NX.push(i + (j % 2) * 0.5), NY.push(-j * 0.866);\nNX.push(1.25, 1.25);\nNY.push(1.5, -(RW - 1) * 0.866 - 1.5);\nconst EU = [], EW = [];\nconst wire = (u, w) => (EU.push(u), EW.push(w));\nfor (let j = 0; j \u003c RW; j++)\n  for (let i = 0; i \u003c CW; i++) {\n    const p = j * CW + i, k = j % 2 ? i + 1 : i - 1;\n    if (i + 1 \u003c CW) wire(p, p + 1);\n    if (j + 1 \u003c RW) {\n      wire(p, p + CW);\n      if (k >= 0 && k \u003c CW) wire(p, (j + 1) * CW + k);\n    }\n  }\nfor (let i = 0; i \u003c CW; i++) wire(PS, i), wire((RW - 1) * CW + i, PT);\n// Wire NE is the battery, leaving the top pole upward and reaching the\n// bottom pole from below, round the outside.\nconst NE = EU.length;\n\n// Networks, one walk per Tiles setting from 13 to 20. Each is a set of\n// wires written as a bitmask in base 36, and two neighbours in a walk differ\n// by one or two wires. They were picked so that at conductance 1 no wire\n// carries zero current, the rectangle stands 1.75 to 2.35 times as tall as\n// it is wide and the smallest square is at least 4.5 LEDs. Walks 16, 17\n// and 19 open on perfect squared rectangles of orders 16, 17 and 19.\nconst WALKS = [\n  \"46p4dk 47xze0 47y2js 47y3ag 46qjoo 46qiy0 46npt4 46qiw8 46p548 46p554\",\n  \"46mus8 46pniw 46qyxk 46qzbk 464le8 46o9cg 46r0wg 46pmfk 46k060 46lemw\",\n  \"46pmfs 46pmcc 46k1ng 46musc 47vsyg 46o9co 46qzbs 464leg 46pnx4 46q0d4\",\n  \"6c9fh7 69sxp7 69sxln 6l1h5n 6l1h5m 6l02oq 6l2vtm 6jwqsa 6m3el6 6m3ehn\",\n  \"8k66kn 8hoa87 8hpop3 7xqhxr 808ea7 6catzj 6casf3 6c9dy7 69rj6n 69sxr2\",\n  \"5iz8d7 6cy0ij 6d287v 6dj317 6m9q8r 6ma2or 6jtkwr 6jxsm3 6juzkr 26jdsr\",\n  \"3syppz 3t02pj 3t02lz 3szwan 3t01tr 3t03en 3syou7 47y2wv 4cxvlq 4cxvlp\",\n  \"8glqwb 8gg4mz 8gg5f7 8gg5ff 8gg5fc 8gg3y0 7mhbso 4am77c 4am9ko 4am9kc\",\n].map((s) => s.split(\" \").map((w) => parseInt(w, 36)));\nconst has = (m, e) => floor(m / 2 ** e) % 2 === 1;\nconst apart = (a, b) => {\n  let d = 0;\n  for (let e = 0; e \u003c NE; e++) d += has(a, e) !== has(b, e);\n  return d;\n};\n\n// The plane structure of a set of wires: which nodes take part, and for\n// each wire the face on its left going from EU to EW (half 2e) and going\n// back (half 2e + 1). Faces are traced by turning clockwise at each node.\nfunction build(S, mask) {\n  const on = [];\n  for (let e = 0; e \u003c NE; e++) if (has(mask, e)) on.push(e);\n  const adj = [];\n  for (let u = 0; u \u003c NN; u++) adj.push([]);\n  for (const e of on) {\n    const u = EU[e], w = EW[e];\n    adj[u].push([atan2(NY[w] - NY[u], NX[w] - NX[u]), e, w]);\n    adj[w].push([atan2(NY[u] - NY[w], NX[u] - NX[w]), e, u]);\n  }\n  adj[PS].push([PI / 2, NE, PT]);\n  adj[PT].push([-PI / 2, NE, PS]);\n  for (const l of adj) l.sort((p, q) => p[0] - q[0]);\n  const half = (e, from) => 2 * e + (e === NE ? (from === PS ? 0 : 1) : from === EU[e] ? 0 : 1);\n  const face = new Int32Array(2 * NE + 2).fill(-1);\n  let nf = 0;\n  for (let u0 = 0; u0 \u003c NN; u0++)\n    for (const h0 of adj[u0]) {\n      if (face[half(h0[1], u0)] >= 0) continue;\n      let u = u0, h = h0;\n      while (face[half(h[1], u)] \u003c 0) {\n        face[half(h[1], u)] = nf;\n        const l = adj[h[2]];\n        let k = 0;\n        while (l[k][1] !== h[1]) k++;\n        u = h[2];\n        h = l[(k + l.length - 1) % l.length];\n      }\n      nf++;\n    }\n  // Unknown node potentials: the inner nodes some wire touches.\n  const idx = new Int32Array(NN).fill(-1);\n  let n = 0;\n  for (const e of on) for (const u of [EU[e], EW[e]]) if (u \u003c NI && idx[u] \u003c 0) idx[u] = n++;\n  // An order to fix the face potentials: across wire e the left face sits\n  // higher than the right by the current along it.\n  const known = new Uint8Array(nf), order = [];\n  known[face[2 * NE]] = 1;\n  for (let more = true; more; ) {\n    more = false;\n    for (const e of [...on, NE]) {\n      const a = face[2 * e], b = face[2 * e + 1];\n      if (known[a] && !known[b]) order.push([e, a, b, -1]), (known[b] = 1), (more = true);\n      else if (known[b] && !known[a]) order.push([e, b, a, 1]), (known[a] = 1), (more = true);\n    }\n  }\n  Object.assign(S, { on, face, nf, idx, n, order, phi: new Float64Array(nf) });\n}\n\n// Kirchhoff: solve for the node potentials with the top pole at 1 and the\n// bottom at 0, then lay every wire out as a tile.\nfunction solve(S) {\n  const { on, idx, n, c, v, cur, face, order, phi, tiles } = S;\n  const A = S.A;\n  for (let i = 0; i \u003c n; i++) A[i].fill(0, 0, n + 1);\n  for (const e of on) {\n    const g = c[e], u = EU[e], w = EW[e], iu = idx[u], iw = idx[w];\n    if (iu >= 0) {\n      A[iu][iu] += g;\n      if (iw >= 0) A[iu][iw] -= g;\n      else if (w === PS) A[iu][n] += g;\n    }\n    if (iw >= 0) {\n      A[iw][iw] += g;\n      if (iu >= 0) A[iw][iu] -= g;\n      else if (u === PS) A[iw][n] += g;\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    let p = i;\n    for (let k = i + 1; k \u003c n; k++) if (abs(A[k][i]) > abs(A[p][i])) p = k;\n    const t = A[i];\n    (A[i] = A[p]), (A[p] = t);\n    for (let k = i + 1; k \u003c n; k++) {\n      const f = A[k][i] / A[i][i];\n      if (f) for (let m = i; m \u003c= n; m++) A[k][m] -= f * A[i][m];\n    }\n  }\n  v.fill(0);\n  v[PS] = 1;\n  for (let i = n - 1; i >= 0; i--) {\n    let s = A[i][n];\n    for (let m = i + 1; m \u003c n; m++) s -= A[i][m] * S.x[m];\n    S.x[i] = s / A[i][i];\n  }\n  for (let u = 0; u \u003c NI; u++) if (idx[u] >= 0) v[u] = S.x[idx[u]];\n  let I = 0;\n  for (const e of on) {\n    cur[e] = c[e] * (v[EU[e]] - v[EW[e]]);\n    if (EU[e] === PS) I += cur[e];\n  }\n  cur[NE] = -I;\n  phi[face[2 * NE]] = 0;\n  for (const [e, a, b, s] of order) phi[b] = phi[a] + s * cur[e];\n  let lo = 0;\n  for (let f = 0; f \u003c S.nf; f++) lo = min(lo, phi[f]);\n  S.I = I;\n  tiles.length = 0;\n  for (const e of on) {\n    const a = phi[face[2 * e]] - lo, b = phi[face[2 * e + 1]] - lo, p = v[EU[e]], q = v[EW[e]];\n    tiles.push([e, min(a, b), max(a, b), 1 - max(p, q), 1 - min(p, q)]);\n  }\n}\n\n// Story seconds at Speed 2: squares hold, drift rises, drift, snap.\nconst HOLD = 1.2, RISE = 2.4, SETTLE = 6.8, CYCLE = 8, REWIRE = 3.4;\n\nexport function setup(params) {\n  const fq = [], ph = [];\n  for (let e = 0; e \u003c NE; e++) fq.push(0.35 + 0.5 * Math.random(), 0.8 + 0.7 * Math.random()), ph.push(6.3 * Math.random(), 6.3 * Math.random());\n  params.s = {\n    t: 0, tc: 0, cyc: 0, amp: 0, set0: SETTLE, setLen: CYCLE - SETTLE, setFrom: 1, flash: 1,\n    K: 0, walk: 0, step: 0, dir: 1, mask: 0, next: 0, ramp: -1, rate: 0,\n    hue: 0, speed: 2, wander: 0.06, fq, ph, drift: new Float64Array(NE + 1), c: new Float64Array(NE),\n    v: new Float64Array(NN), cur: new Float64Array(NE + 1), x: new Float64Array(NI), A: Array.from({ length: NI }, () => new Float64Array(NI + 1)),\n    tiles: [], I: 1, id: new Int16Array(W * H), stripe: new Float64Array(NE),\n  };\n}\n\nfunction rewire(S, to) {\n  S.next = to;\n  S.ramp = 0;\n  S.rate = 1 / 2.6;\n  build(S, S.mask | to);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 13, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wander = 0.7 * 2 ** (1.1 * cl(k[3], -1, 1));\n  const K = round(cl(k[2], 13, 20));\n  if (!S.K) {\n    S.K = K;\n    S.mask = WALKS[K - 13][0];\n    build(S, S.mask);\n  } else if (K !== S.K && S.ramp \u003c 0) {\n    // A new walk: go to its network nearest the one shown.\n    S.K = K;\n    const w = WALKS[K - 13];\n    let best = 0;\n    for (let i = 1; i \u003c w.length; i++) if (apart(w[i], S.mask) \u003c apart(w[best], S.mask)) best = i;\n    (S.step = best), (S.dir = best === w.length - 1 ? -1 : 1);\n    if (w[best] !== S.mask) rewire(S, w[best]);\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.flash *= exp(-d / 0.35);\n  const press = input.btnPressed && input.btnPressed[0];\n  if (press && S.tc > 0.15 && S.tc \u003c S.set0) {\n    // Snap now: settle from where the drift is in 0.4 seconds.\n    (S.setFrom = S.amp), (S.set0 = S.tc), (S.setLen = 0.4);\n    if (S.ramp >= 0) S.rate = max(S.rate, (1 - S.ramp) / 0.38);\n  }\n  S.tc += ds;\n  if (S.tc >= S.set0 + S.setLen) {\n    (S.tc = 0), S.cyc++, (S.flash = 1), (S.set0 = SETTLE), (S.setLen = CYCLE - SETTLE), (S.setFrom = 1);\n  }\n  const tc = S.tc;\n  S.amp = tc \u003c HOLD ? 0 : tc \u003c S.set0 ? (tc \u003c RISE ? sm((tc - HOLD) / (RISE - HOLD)) : 1) : S.setFrom * (1 - ((tc - S.set0) / S.setLen) ** 2);\n  // Every second cycle, one step along the walk.\n  if (S.ramp \u003c 0 && S.cyc % 2 === 1 && tc >= REWIRE && tc \u003c REWIRE + 0.5 && S.set0 === SETTLE) {\n    const w = WALKS[S.K - 13];\n    if (w.length > 1) {\n      if (S.step + S.dir \u003c 0 || S.step + S.dir >= w.length) S.dir = -S.dir;\n      S.step += S.dir;\n      rewire(S, w[S.step]);\n    }\n  }\n  if (S.ramp >= 0) {\n    S.ramp += ds * S.rate;\n    if (S.ramp >= 1) {\n      S.mask = S.next;\n      S.ramp = -1;\n      build(S, S.mask);\n    }\n  }\n  // Conductances: each wire drifts as exp(a n(t)), n a slow wave in -1..1.\n  const r = S.ramp \u003c 0 ? 1 : sm(S.ramp), a = S.amp * S.wander;\n  for (const e of S.on) {\n    const n = 0.6 * sin(S.fq[2 * e] * S.t + S.ph[2 * e]) + 0.4 * sin(S.fq[2 * e + 1] * S.t + S.ph[2 * e + 1]);\n    let g = a ? exp(a * n) : 1;\n    if (S.ramp >= 0) {\n      const was = has(S.mask, e), will = has(S.next, e);\n      if (was && !will) g *= 1 - r;\n      else if (will && !was) g *= r;\n    }\n    S.c[e] = max(g, 1e-9);\n    S.stripe[e] += ds * 9 * S.c[e];\n  }\n  solve(S);\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.tiles.length) return;\n  const { tiles, id, I } = S;\n  const sc = min(W / I, H), ox = (W - I * sc) / 2, oy = (H - sc) / 2;\n  id.fill(-1);\n  const col = [], top = [], q = [];\n  let qa = 1, qb = 0;\n  tiles.forEach((t, k) => {\n    const x0 = round(ox + t[1] * sc), x1 = round(ox + t[2] * sc), y0 = round(oy + t[3] * sc), y1 = round(oy + t[4] * sc);\n    for (let y = max(0, y0); y \u003c min(H, y1); y++) for (let x = max(0, x0); x \u003c min(W, x1); x++) id[y * W + x] = k;\n    // Size: the side of a square of the same area, against the width.\n    q.push(log(max(1e-6, sqrt((t[2] - t[1]) * (t[4] - t[3])) / I)));\n    if (x1 > x0 && y1 > y0) (qa = min(qa, q[k])), (qb = max(qb, q[k]));\n    top.push(y0 + S.stripe[t[0]]);\n  });\n  // Colour by size between the smallest and the biggest tile shown now.\n  tiles.forEach((t, k) => {\n    const u = cl((q[k] - qa) / max(0.3, qb - qa), 0, 1);\n    col.push(hsv(0.52 + S.hue + 0.55 * (1 - u), 0.85 - 0.1 * u, 0.62 + 0.38 * (1 - u)));\n  });\n  const fl = S.flash;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const k = id[p];\n      if (k \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const c = col[k];\n      // Seams on the left and top of each tile; the rectangle's own edge stays.\n      if ((x > 0 && id[p - 1] >= 0 && id[p - 1] !== k) || (y > 0 && id[p - W] >= 0 && id[p - W] !== k)) {\n        const b = 255 * fl;\n        display.setPixel(x, y, round(0.08 * 255 * c[0] * (1 - fl) + b * 0.9), round(0.08 * 255 * c[1] * (1 - fl) + b * 0.95), round(0.08 * 255 * c[2] * (1 - fl) + b));\n        continue;\n      }\n      // Faint bands run down each tile at a speed set by its conductance.\n      const ph = (((y - top[k]) % 9) + 9) % 9, m = ph \u003c 1 ? 0.8 : 1;\n      display.setPixel(x, y, round(255 * c[0] * m), round(255 * c[1] * m), round(255 * c[2] * m));\n    }\n}\n","anscombes-quartet":"// ===== Patternflow pattern =====\n// Title:   Anscombe's Quartet\n// Family:  data\n// Idea:    Anscombe's four scatter plots of eleven points stand stacked under one shared regression line, then fold into a single tall plot where their points split into a cloud of 264 that anneals from shape to shape while all five of its statistics stay the same to two decimals, so the line and the crosshair never move.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Anscombe's quartet (Francis Anscombe, 1973); same-stats annealing (Justin Matejka, George Fitzmaurice, 2017)\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Heat=0..1, Residuals=0..1\n//\n// Knob 1: Hue. Turns the four sets' colours round the wheel together: at 0 set I is sea green, II blue, III pink and IV yellow, and the cloud keeps each point's colour. The faint washes above and below the line stay on the cool side, teal over violet at 0 and magenta over green at 1.\n// Knob 2: Speed. At 2 the quartet stands 1 s and folds in 0.8 s, each of the eight shapes takes 3.6 s (the cloud settles in about 1.5 s, and the round ones turn a quarter radian a second), the cloud walks home in 3 s and the quartet stands 4 s: one round is 37.4 s. The annealer tries 20,000 nudges a second through the first second of a shape and 100,000 a second from the second second on. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Heat. The annealing temperature: the chance that a nudge taking a point away from its place is kept anyway, still only when the statistics hold. 0.2% at 0, with 5% that cools over the first second of each shape; 60% at 1, where the nudges are also 2.5 times longer and the shapes fray into a haze round their outlines while the numbers stay put.\n// Knob 4: Residuals. A stick from each point straight up or down to the line, in the point's colour, brightest at the point. Too faint to see below about 0.1; at 1 the sticks fill the space between the cloud and the line, and their squares add up to about the same total in every shape, since r and the spread of y are held.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, exp, cos, sin, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Anscombe's published sets (1973). The first three share x.\nconst AX = [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5];\nconst SETS = [\n  [AX, [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]],\n  [AX, [9.14, 8.14, 8.74, 8.77, 9.26, 8.1, 6.13, 3.1, 9.13, 7.26, 4.74]],\n  [AX, [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73]],\n  [[8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8], [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.5, 5.56, 7.91, 6.89]],\n];\n// What all four share: means 9 and 7.50, deviations 3.32 and 2.03,\n// correlation 0.816, and the line y = 3 + 0.5 x.\nconst MX = 9, MY = 7.5, SDX = sqrt(11), SDY = 2.0316, RHO = 0.8164;\n\n// Two views of the data. The quartet: four plots 32 rows tall, x from 3 to\n// 20 across the panel. The tall plot: one plot over all 128 rows, scaled so\n// that the outliers at x 19 and y 12.74 still land on the panel.\nconst QKX = 3.47, QX0 = 2 + 6 * QKX, QKY = 2.64;\nconst qY0 = (k) => 32 * k + 30 - (MY - 2.5) * QKY;\nconst KX = 3.4, KY = 12, X0 = 27, Y0 = 67;\n\n// Each of the 44 points splits into C copies for the cloud.\nconst C = 6, NP = 44, N = NP * C;\n\n// The cloud's shapes, drawn in a design square and then fitted so that their\n// own means and covariance are the cloud's: a shape can only be one the\n// statistics allow. Lines stay upright (\"L\") or level (\"U\") under the fit.\nfunction seg(o, a, b, c, d) {\n  const n = max(2, round(hypot(c - a, d - b) / 0.02));\n  for (let i = 0; i \u003c= n; i++) o.push([a + ((c - a) * i) / n, b + ((d - b) * i) / n]);\n}\nfunction circ(o, r) {\n  const n = max(8, round((2 * PI * r) / 0.02));\n  for (let i = 0; i \u003c n; i++) o.push([r * cos((2 * PI * i) / n), r * sin((2 * PI * i) / n)]);\n}\nfunction dot(o, a, b, n) {\n  for (let i = 0; i \u003c n; i++) o.push([a + 0.03 * cos(i), b + 0.03 * sin(i)]);\n}\nfunction star(o) {\n  const p = [];\n  for (let i = 0; i \u003c 10; i++) {\n    const a = -PI / 2 + (i * PI) / 5, r = i % 2 ? 0.45 : 1.1;\n    p.push([r * cos(a), r * sin(a)]);\n  }\n  for (let i = 0; i \u003c 10; i++) seg(o, p[i][0], p[i][1], p[(i + 1) % 10][0], p[(i + 1) % 10][1]);\n}\nfunction lattice(o) {\n  for (let b = -1.2; b \u003c= 1.21; b += 0.4) for (let a = -1.2; a \u003c= 1.21; a += 0.4) if (a * a + b * b \u003c 1.5) dot(o, a, b, 12);\n}\n// \"R\" shapes are round and carry no correlation of their own: they keep\n// their roundness on the panel and the statistics put a clump of points out\n// at each end of the line to carry r = 0.82, as Anscombe's outliers do.\n// \"L\" shapes are fitted whole: upright lines stay upright. \"U\": level stays level.\nconst SHAPES = [\n  [\"R\", circ1],\n  [\"L\", (o) => { for (const v of [-1.2, -0.4, 0.4, 1.2]) seg(o, -1.6, v, 1.6, v); }],\n  [\"R\", star],\n  [\"L\", (o) => { for (const u of [-1.5, -0.75, 0, 0.75, 1.5]) seg(o, u, -1.3, u, 1.3); }],\n  [\"R\", (o) => (circ(o, 1), circ(o, 0.5))],\n  [\"U\", (o) => { for (const v of [-1.5, -0.75, 0, 0.75, 1.5]) seg(o, -1.3, v, 1.3, v); }],\n  [\"R\", lattice],\n  [\"R\", (o) => (seg(o, -1, -1, 1, 1), seg(o, -1, 1, 1, -1))],\n];\nfunction circ1(o) {\n  circ(o, 1);\n}\n\n// Fit points to the cloud's means and covariance (sx, sy, sxy in LEDs).\nfunction fit(pts, ref, mode, sx, sy, sxy) {\n  let ma = 0, mb = 0, aa = 0, bb = 0, ab = 0;\n  for (const p of ref) (ma += p[0]), (mb += p[1]);\n  ma /= ref.length;\n  mb /= ref.length;\n  for (const p of ref) {\n    const a = p[0] - ma, b = p[1] - mb;\n    aa += a * a;\n    bb += b * b;\n    ab += a * b;\n  }\n  aa /= ref.length;\n  bb /= ref.length;\n  ab /= ref.length;\n  let M;\n  if (mode !== \"U\") {\n    // T times the inverse of S, both lower triangular: x depends on x alone.\n    const s11 = sqrt(aa), s21 = ab / s11, s22 = sqrt(bb - s21 * s21);\n    const t11 = sx, t21 = sxy / sx, t22 = sqrt(sy * sy - t21 * t21);\n    M = [t11 / s11, 0, t21 / s11 - (t22 * s21) / (s11 * s22), t22 / s22];\n  } else {\n    // Both upper triangular: y depends on y alone, so level lines stay level.\n    const s22 = sqrt(bb), s12 = ab / s22, s11 = sqrt(aa - s12 * s12);\n    const t22 = sy, t12 = sxy / sy, t11 = sqrt(sx * sx - t12 * t12);\n    M = [t11 / s11, t12 / s22 - (t11 * s12) / (s11 * s22), 0, t22 / s22];\n  }\n  return pts.map((p) => {\n    const a = p[0] - ma, b = p[1] - mb;\n    return [X0 + M[0] * a + M[1] * b, Y0 + M[2] * a + M[3] * b];\n  });\n}\n\n// Distance from each LED centre to the nearest point of a shape, filled a\n// few rows at a time so that no frame stalls on it.\nfunction fillRows(F, rows) {\n  const { f, xs, ys } = F, n = xs.length, end = min(H, F.row + rows);\n  for (let y = F.row; y \u003c end; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let best = 1e9;\n      const px = x + 0.5, py = y + 0.5;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = xs[i] - px, dy = ys[i] - py, d = dx * dx + dy * dy;\n        if (d \u003c best) best = d;\n      }\n      f[y * W + x] = sqrt(best);\n    }\n  F.row = end;\n}\nfunction look(f, x, y) {\n  const fx = cl(x - 0.5, 0, W - 1.001), fy = cl(y - 0.5, 0, H - 1.001);\n  const ix = floor(fx), iy = floor(fy), u = fx - ix, v = fy - iy, i = iy * W + ix;\n  return (f[i] * (1 - u) + f[i + 1] * u) * (1 - v) + (f[i + W] * (1 - u) + f[i + W + 1] * u) * v;\n}\n\nexport function setup(params) {\n  // The cloud: copy c of point j of set k, spread round the means by a hair\n  // so that its deviations divided by n - 1 are Anscombe's again.\n  let sxx = 0;\n  for (const [xs] of SETS) for (const x of xs) sxx += (x - MX) ** 2;\n  const grow = sqrt(((N - 1) * 11) / (C * sxx));\n  const hx = new Float64Array(N), hy = new Float64Array(N), set = new Uint8Array(N), idx = new Uint8Array(N);\n  for (let n = 0; n \u003c N; n++) {\n    const k = floor(n / (11 * C)), j = floor(n / C) % 11;\n    set[n] = k;\n    idx[n] = j;\n    const [xs, ys] = SETS[k];\n    hx[n] = X0 + KX * (xs[j] - MX) * grow;\n    hy[n] = Y0 - KY * (ys[j] - MY) * grow;\n  }\n  params.s = {\n    t: 0, hue: 0, speed: 2, heat: 0, res: 0.06, fade: 0,\n    hx, hy, set, idx, x: Float64Array.from(hx), y: Float64Array.from(hy), d: new Float64Array(N),\n    fields: [], pts: [], cores: [], cur: -1, bx: null, by: null, core: new Uint8Array(N), tx: new Float64Array(N), ty: new Float64Array(N), lock: null, stats: [0, 0, 0, 0, 0],\n    rgb: new Float32Array(W * H * 3), trail: new Float32Array(W * H * 3),\n  };\n}\n\n// Pixel sums of the cloud, and its statistics in Anscombe's units, rounded\n// to two decimals as whole hundredths.\nfunction sums(S) {\n  let a = 0, b = 0, aa = 0, bb = 0, ab = 0;\n  for (let n = 0; n \u003c N; n++) {\n    const x = S.x[n] - X0, y = S.y[n] - Y0;\n    a += x;\n    b += y;\n    aa += x * x;\n    bb += y * y;\n    ab += x * y;\n  }\n  return [a, b, aa, bb, ab];\n}\nfunction stats(a, b, aa, bb, ab, out) {\n  const vx = (aa - (a * a) / N) / (N - 1), vy = (bb - (b * b) / N) / (N - 1), c = (ab - (a * b) / N) / (N - 1);\n  out[0] = round(100 * (MX + a / N / KX));\n  out[1] = round(100 * (MY - b / N / KY));\n  out[2] = round((100 * sqrt(vx)) / KX);\n  out[3] = round((100 * sqrt(vy)) / KY);\n  out[4] = round((-100 * c) / sqrt(vx * vy));\n  return out;\n}\n\nfunction shapeField(S, k, rows = H) {\n  if (!S.fields[k]) {\n    // The shape's points carry the cloud's spread divided by n, so a cloud\n    // lying on it has Anscombe's spread divided by n - 1. Pixel rows run\n    // down, so the covariance turns negative.\n    const f = sqrt((N - 1) / N), sx = KX * SDX * f, sy = KY * SDY * f, sxy = -RHO * sx * sy;\n    const [mode, build] = SHAPES[k];\n    let raw = [];\n    build(raw);\n    const coreLen = raw.length;\n    if (mode === \"R\") {\n      // A fraction 2w of the points sits in the two clumps at (+-cx, -+cy):\n      // 2w cx cy carries the covariance, and what the clumps leave of the\n      // x and y spread, equal, is the round core's.\n      const w2 = 0.24, A = sx * sx, D = sy * sy, B = -sxy / w2, E = (D - A) / w2;\n      const cx = sqrt((-E + sqrt(E * E + 4 * B * B)) / 2), cy = B / cx;\n      let v = 0;\n      for (const p of raw) v += p[0] * p[0] + p[1] * p[1];\n      const lam = sqrt((A - w2 * cx * cx) / (1 - w2) / (v / raw.length / 2));\n      raw = raw.map((p) => [lam * p[0], lam * p[1]]);\n      const m = round(((raw.length * w2) / (1 - w2)) / 2);\n      for (const sg of [1, -1])\n        for (let i = 0; i \u003c m; i++) {\n          const a = i * 2.4, r = 2.2 * sqrt((i + 0.5) / m);\n          raw.push([sg * cx + r * cos(a), -sg * cy + r * sin(a)]);\n        }\n    }\n    // One place on the shape for each point, picked evenly along it. The fit\n    // is taken from these places, so a cloud sitting on them has the\n    // statistics exactly.\n    const spots = [], core = new Uint8Array(N);\n    for (let n = 0; n \u003c N; n++) {\n      const i = floor(((n + 0.5) * raw.length) / N);\n      spots.push(raw[i]);\n      core[n] = mode === \"R\" && i \u003c coreLen ? 1 : 0;\n    }\n    const pts = fit(raw, spots, mode, sx, sy, sxy);\n    S.pts[k] = fit(spots, spots, mode, sx, sy, sxy);\n    S.cores[k] = core;\n    const half = pts.filter((_, i) => i % 2 === 0);\n    S.fields[k] = { f: new Float32Array(W * H), xs: Float32Array.from(half, (p) => p[0]), ys: Float32Array.from(half, (p) => p[1]), row: 0 };\n  }\n  const F = S.fields[k];\n  if (F.row \u003c H) fillRows(F, rows);\n  return F.f;\n}\n\n// Hand the places out: start in any order, then swap pairs while a swap\n// shortens the paths.\nfunction assign(S, pts, core) {\n  const tx = S.tx, ty = S.ty, X = S.x, Y = S.y;\n  for (let n = 0; n \u003c N; n++) (tx[n] = pts[n][0]), (ty[n] = pts[n][1]);\n  const own = new Uint16Array(N).map((_, i) => i);\n  for (let t = 0; t \u003c 40000; t++) {\n    const a = floor(Math.random() * N), b = floor(Math.random() * N), oa = own[a], ob = own[b];\n    const xa = X[a], ya = Y[a], xb = X[b], yb = Y[b];\n    const keep = (xa - tx[oa]) ** 2 + (ya - ty[oa]) ** 2 + (xb - tx[ob]) ** 2 + (yb - ty[ob]) ** 2;\n    const swap = (xa - tx[ob]) ** 2 + (ya - ty[ob]) ** 2 + (xb - tx[oa]) ** 2 + (yb - ty[oa]) ** 2;\n    if (swap \u003c keep) (own[a] = ob), (own[b] = oa);\n  }\n  S.bx = Float64Array.from(own, (m) => tx[m]);\n  S.by = Float64Array.from(own, (m) => ty[m]);\n  S.core = Uint8Array.from(own, (m) => core[m]);\n  S.tx.set(S.bx);\n  S.ty.set(S.by);\n}\n\n// Matejka and Fitzmaurice: nudge one point, keep the nudge only if all five\n// statistics still round to the same two decimals, and prefer nudges that\n// bring the point nearer the target. A hot step takes a worse nudge too.\n// The target here is the shape's outline plus twice the distance to the\n// point's own place on it: the outline alone left a fifth of the points\n// stranded in a clump or on the wrong line, since only a hot step could\n// carry them across a gap.\nfunction anneal(S, tries, temp, f, rc, rs) {\n  let [a, b, aa, bb, ab] = sums(S);\n  const st = [0, 0, 0, 0, 0], L = S.lock, home = !f, step = 1.2 * (1 + 1.5 * S.heat);\n  const tx = home ? S.hx : S.tx, ty = home ? S.hy : S.ty, be = home ? 1 : BETA;\n  // A turning shape is looked up turned back, near its middle.\n  const at = (x, y) => {\n    const dx = x - X0, dy = y - Y0;\n    return rs && dx * dx + dy * dy \u003c 900 ? look(f, X0 + rc * dx + rs * dy, Y0 - rs * dx + rc * dy) : look(f, x, y);\n  };\n  const dist = (n, x, y) => (home ? 0 : at(x, y)) + be * sqrt((x - tx[n]) ** 2 + (y - ty[n]) ** 2);\n  for (let n = 0; n \u003c N; n++) S.d[n] = dist(n, S.x[n], S.y[n]);\n  for (let t = 0; t \u003c tries; t++) {\n    const n = floor(Math.random() * N);\n    const ox = S.x[n], oy = S.y[n];\n    const nx = ox + (Math.random() + Math.random() - 1) * step, ny = oy + (Math.random() + Math.random() - 1) * step;\n    if (nx \u003c 0 || nx >= W || ny \u003c 0 || ny >= H) continue;\n    const nd = dist(n, nx, ny);\n    if (nd >= S.d[n] && Math.random() >= temp) continue;\n    const x0 = ox - X0, y0 = oy - Y0, x1 = nx - X0, y1 = ny - Y0;\n    const a2 = a - x0 + x1, b2 = b - y0 + y1, aa2 = aa - x0 * x0 + x1 * x1, bb2 = bb - y0 * y0 + y1 * y1, ab2 = ab - x0 * y0 + x1 * y1;\n    stats(a2, b2, aa2, bb2, ab2, st);\n    if (st[0] !== L[0] || st[1] !== L[1] || st[2] !== L[2] || st[3] !== L[3] || st[4] !== L[4]) continue;\n    S.x[n] = nx;\n    S.y[n] = ny;\n    S.d[n] = nd;\n    a = a2;\n    b = b2;\n    aa = aa2;\n    bb = bb2;\n    ab = ab2;\n  }\n}\n\n// The story, in seconds at Speed 2: the quartet 1 s, folding into one plot\n// 0.8 s, eight shapes of 3.6 s, back home 3 s, unfolding 0.8 s, the quartet\n// 4 s. Nudges tried a second, the weight on a point's own place, the round\n// shapes' turn in radians a second, and the heat that cools at each shape.\nconst TR = 20000, BETA = 2, SPIN = 0.25, TEMP0 = 0.05, TAU = 1;\nconst QFIRST = 1, FOLD = 0.8, SHAPE = 3.6, NSH = 8, BACK = 3, QHOLD = 4;\nconst CYCLE = FOLD + NSH * SHAPE + BACK + FOLD + QHOLD;\nfunction phase(t) {\n  if (t \u003c QFIRST) return { q: 1, next: 0 };\n  let u = (t - QFIRST) % CYCLE;\n  const cyc = floor((t - QFIRST) / CYCLE);\n  if (u \u003c FOLD) return { fold: sm(u / FOLD), next: (cyc * NSH) % SHAPES.length };\n  u -= FOLD;\n  if (u \u003c NSH * SHAPE) return { shape: (cyc * NSH + floor(u / SHAPE)) % SHAPES.length, into: u % SHAPE };\n  u -= NSH * SHAPE;\n  const next = ((cyc + 1) * NSH) % SHAPES.length;\n  if (u \u003c BACK) return { back: u, next };\n  u -= BACK;\n  if (u \u003c FOLD) return { fold: 1 - sm(u / FOLD), next };\n  return { q: 1, next };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.heat = cl(k[2], 0, 1);\n  S.res = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  S.fade = exp(-g * 9);\n  const P = (S.P = phase(S.t));\n  if (!S.lock) S.lock = stats(...sums(S), [0, 0, 0, 0, 0]);\n  const into = P.shape !== undefined ? P.into : P.back !== undefined ? P.back : 0;\n  const rate = TR * (1 + 4 * sm(into - 1));\n  const tries = min(13000, round(g * rate));\n  // Work on the next shape's distances a few rows a frame.\n  shapeField(S, P.shape !== undefined ? (P.shape + 1) % SHAPES.length : P.next, 8);\n  if (P.shape !== undefined && P.shape !== S.cur) {\n    shapeField(S, P.shape);\n    assign(S, S.pts[P.shape], S.cores[P.shape]);\n    S.cur = P.shape;\n  }\n  if (P.shape === undefined) S.cur = -1;\n  if (P.shape !== undefined) {\n    // A round shape turns slowly about the means while it holds; turned\n    // whole, its spread and its zero correlation do not change.\n    const th = SPIN * P.into, rc = cos(th), rs = sin(th);\n    for (let n = 0; n \u003c N; n++)\n      if (S.core[n]) {\n        const dx = S.bx[n] - X0, dy = S.by[n] - Y0;\n        S.tx[n] = X0 + rc * dx - rs * dy;\n        S.ty[n] = Y0 + rs * dx + rc * dy;\n      }\n    anneal(S, tries, 0.002 + 0.6 * S.heat + TEMP0 * exp(-P.into / TAU), shapeField(S, P.shape), rc, rs);\n  }\n  else if (P.back !== undefined) anneal(S, tries, 0.002, null);\n  else for (let n = 0; n \u003c N; n++) (S.x[n] = S.hx[n]), (S.y[n] = S.hy[n]);\n  stats(...sums(S), S.stats);\n}\n\n// Where set k's data lands at fold s (0 the quartet, 1 the tall plot), and\n// the rows its plot may use.\nfunction view(k, s) {\n  return {\n    x0: QX0 + (X0 - QX0) * s, kx: QKX + (KX - QKX) * s,\n    y0: qY0(k) + (Y0 - qY0(k)) * s, ky: QKY + (KY - QKY) * s,\n    top: 32 * k * (1 - s), bot: 32 * (k + 1) + (H - 32 * (k + 1)) * s,\n  };\n}\n\n// Digits three LEDs wide and five tall, a row of bits each, top first.\nconst DIG = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7249, 0x7bef, 0x7bcf];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const P = S.P || { q: 1 }, rgb = S.rgb, tr = S.trail;\n  rgb.fill(0);\n  const add = (x, y, c, a) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = max(rgb[o], c[0] * a);\n    rgb[o + 1] = max(rgb[o + 1], c[1] * a);\n    rgb[o + 2] = max(rgb[o + 2], c[2] * a);\n  };\n  const s = P.q ? 0 : P.fold !== undefined ? P.fold : 1;\n  const cols = [0, 1, 2, 3].map((k) => hsv(0.42 + S.hue + 0.25 * k, 0.6, 1));\n  // The washes keep to the cool side of the wheel: dark yellow and orange\n  // read as olive and brown.\n  const upC = hsv(0.5 + 0.45 * S.hue, 0.8, 0.09), dnC = hsv(0.78 - 0.45 * S.hue, 0.7, 0.09);\n  const lineC = [1, 0.82, 0.55], meanC = [0.45, 0.5, 0.65], sdC = [0.22, 0.26, 0.4];\n  // The fixed things: one set of them per plot while there are four.\n  const views = s >= 1 ? [view(0, 1)] : [0, 1, 2, 3].map((k) => view(k, s));\n  views.forEach((v, k) => {\n    const inb = (y) => y >= v.top && y \u003c v.bot;\n    // The line splits each plot in two: a faint wash above it, where the\n    // residuals are positive, and another below, a little stronger inside\n    // one deviation of the means.\n    const bx = v.kx * SDX, by = v.ky * SDY;\n    for (let x = 0; x \u003c W; x++) {\n      const ly = v.y0 - v.ky * 0.5 * ((x + 0.5 - v.x0) / v.kx), inx = abs(x + 0.5 - v.x0) \u003c bx;\n      for (let y = Math.ceil(v.top); y \u003c v.bot; y++) add(x, y, y + 0.5 \u003c ly ? upC : dnC, inx && abs(y + 0.5 - v.y0) \u003c by ? 1.35 : 1);\n    }\n    if (s \u003c 1 && k > 0) for (let x = 0; x \u003c W; x++) add(x, v.top, sdC, 1 - s);\n    const sdx = v.kx * SDX, sdy = v.ky * SDY;\n    for (let y = Math.ceil(v.top); y \u003c v.bot; y++) {\n      if (y % 4 \u003c 2) add(v.x0, y, meanC, 1);\n      if (y % 3 === 0) (add(v.x0 - sdx, y, sdC, 1), add(v.x0 + sdx, y, sdC, 1));\n    }\n    for (let x = 0; x \u003c W; x++) {\n      if (inb(v.y0) && x % 4 \u003c 2) add(x, v.y0, meanC, 1);\n      if (x % 3 === 0) for (const yy of [v.y0 - sdy, v.y0 + sdy]) if (inb(yy)) add(x, yy, sdC, 1);\n    }\n  });\n  // The residuals: from each point straight down or up to the line.\n  const pos = new Float32Array(2 * N);\n  for (let n = 0; n \u003c N; n++) {\n    const k = S.set[n];\n    let px = S.x[n], py = S.y[n];\n    if (s \u003c 1) {\n      const v = view(k, s), [xs, ys] = SETS[k], j = S.idx[n];\n      const hx = (S.hx[n] - X0) / KX + MX, hy = MY - (S.hy[n] - Y0) / KY;\n      const dx = xs[j] + (hx - xs[j]) * s, dy = ys[j] + (hy - ys[j]) * s;\n      px = v.x0 + v.kx * (dx - MX);\n      py = v.y0 - v.ky * (dy - MY);\n    }\n    pos[2 * n] = px;\n    pos[2 * n + 1] = py;\n    if (S.res > 0.02) {\n      const v = s >= 1 ? views[0] : views[k];\n      const ly = v.y0 - v.ky * 0.5 * ((px - v.x0) / v.kx);\n      // Brightest at the point, under a third as bright where it meets the line.\n      const len = max(1, abs(py - ly));\n      for (let y = floor(min(ly, py)); y \u003c= floor(max(ly, py)); y++) add(px, y, cols[k], S.res * (0.3 + 0.7 * (1 - abs(y + 0.5 - py) / len)));\n    }\n  }\n  // The line y = 3 + 0.5 x, filled down each column so it stays unbroken.\n  views.forEach((v) => {\n    for (let x = 0; x \u003c W; x++) {\n      const ya = v.y0 - v.ky * 0.5 * ((x - v.x0) / v.kx), yb = v.y0 - v.ky * 0.5 * ((x + 1 - v.x0) / v.kx);\n      for (let y = floor(min(ya, yb)); y \u003c= floor(max(ya, yb)) && y \u003c H; y++) if (y + 0.5 >= v.top && y + 0.5 \u003c v.bot) add(x, y, lineC, 1);\n    }\n  });\n  // The five numbers the cloud keeps, top left of the tall plot, each in the\n  // colour of the lines it sets.\n  if (s > 0.5) {\n    const a = sm((s - 0.5) * 2), vals = S.stats, cc = [meanC, meanC, sdC, sdC, lineC];\n    for (let r = 0; r \u003c 5; r++) {\n      const v = vals[r], ds = [floor(v / 100), floor(v / 10) % 10, v % 10];\n      const c = r >= 2 && r \u003c 4 ? [0.4, 0.46, 0.7] : cc[r];\n      let x = 1;\n      for (let q = 0; q \u003c 3; q++) {\n        for (let b = 0; b \u003c 15; b++) if ((DIG[ds[q]] >> (14 - b)) & 1) add(x + (b % 3), 2 + 7 * r + floor(b / 3), c, a);\n        x += 4;\n        if (q === 0) (add(x, 6 + 7 * r, c, a), (x += 2));\n      }\n    }\n  }\n  // The points, over everything, leaving a short trail as they move.\n  const fd = S.fade;\n  for (let i = 0; i \u003c tr.length; i++) tr[i] *= fd;\n  for (let n = 0; n \u003c N; n++) {\n    const c = cols[S.set[n]], px = pos[2 * n], py = pos[2 * n + 1];\n    const big = s \u003c 0.5 ? 2 : 1;\n    for (let dy = 0; dy \u003c big; dy++)\n      for (let dx = 0; dx \u003c big; dx++) {\n        const x = floor(px - (big - 1) / 2 + dx), y = floor(py - (big - 1) / 2 + dy);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        tr[o] = c[0];\n        tr[o + 1] = c[1];\n        tr[o + 2] = c[2];\n      }\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const o = i * 3, t = max(tr[o], tr[o + 1], tr[o + 2]);\n    // A point covers what is under it; its fading trail only adds.\n    const r = t > 0.97 ? tr[o] : max(rgb[o], tr[o] * 0.6), g = t > 0.97 ? tr[o + 1] : max(rgb[o + 1], tr[o + 1] * 0.6), b = t > 0.97 ? tr[o + 2] : max(rgb[o + 2], tr[o + 2] * 0.6);\n    display.setPixel(i % W, floor(i / W), 4 * round(63.75 * cl(r, 0, 1)), 4 * round(63.75 * cl(g, 0, 1)), 4 * round(63.75 * cl(b, 0, 1)));\n  }\n}\n","banshee":"// ===== Patternflow pattern =====\n// Title:   Banshee\n// Family:  halloween\n// Idea:    A pale, see-through woman drifts in the night wind above a cottage with one lit window, her long hair and tattered robe streaming and whipping, and every 7 seconds she throws back her head and wails: rings of toxic green sound burst from her mouth and bend the night as they pass, the sky flashes green, the window panes rattle in their frame and the candle flame lies flat, the crows on the ridge scatter and the ground fog is blown back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Fury=0..1\n//\n// Knob 1: Hue. The colour of her light, of the rings and of the flash; the sky and the cottage with its window stay as they are. At 0 she is green-white and wails toxic green, at 0.25 blue-white with blue rings, at 0.5 lilac with magenta and at 0.75 peach with orange-red.\n// Knob 2: Speed. At 2 she wails every 7 s, the first time at 1.2 s: her head goes back over 0.5 s and the wail lasts 1.8 s, a ring leaving her mouth every 0.2 s; 0.7 s later she is quiet again. The rings travel 60 LEDs a second and reach the window about 1.2 s after they leave her; the crows are back on the ridge 4.5 to 5.5 s after they flew. At 0.2 everything, her drift and the flutter of her hair too, is ten times slower, at 3 half as fast again.\n// Knob 3: Wind. A wind from the left. At 0 a breeze of 4 LEDs a second, and her own drifting is what lifts her hair and hem; at 1 it blows 44 LEDs a second with gusts and her hair and robe stream out flat to the right. She hangs 8 LEDs further left against it, and the fog runs past four times as fast.\n// Knob 4: Fury. How hard she wails. At 0.06 the rings are thin and the sky glows faintly green round her; at 1 the rings are nearly twice as bright and more than twice as wide, they bend the scene further, and the flash floods the whole sky. The crows fly off faster and the flame lies flatter; the fog is blown back harder too.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  for (let i = 0; i \u003c 3; i++) {\n    const k = (5 - 2 * i + 6 * (h - floor(h))) % 6;\n    out[i] = v - v * s * max(0, min(k, 4 - k, 1));\n  }\n  return out;\n}\n// Channels in steps of 4 of 255.\nconst q4 = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\n// The roof's ridge and eaves, the ground, and where the fog starts.\nconst RIDGE = 70, EAVE = 86, GROUND = 119, FOG = 98;\n// The window: its left edge, top and pane size; the candle's wick sits in\n// the lower left pane.\nconst WX = 30, WY = 93, PS = 7, FX = 34.5, FY = 106;\n// Hair: strands, nodes and segment length in LEDs. Robe and sleeve tatters\n// the same.\nconst NH = 16, HN = 20, HL = 2.3, NR = 9, RN = 14, RL = 3.1, NT = 3, TN = 7, TL = 2.4;\n// The wail at Speed 2, in seconds: one every WP, the first at W0; the head\n// goes back over WA, she wails until WB and is quiet again by WC.\nconst WP = 7, W0 = 1.2, WA = 0.5, WB = 2.3, WC = 3.0;\n// Sound rings: speed in LEDs a second and the gap between them.\nconst RV = 60, RI = 0.2;\n// The crows' perches along the ridge.\nconst PERCH = [24, 32, 41, 49];\n\n// Every chain in one set of arrays: hair first, then robe, then tatters.\nconst CH = [];\n{\n  let o = 0;\n  for (let i = 0; i \u003c NH; i++) CH.push({ o, n: HN, L: HL * (0.85 + 0.3 * hash(i + 5)), g: 12, k: 0.07 + 0.1 * hash(i + 21), kind: 0, f: 0.7 + 0.6 * hash(i + 33) }), (o += HN);\n  for (let i = 0; i \u003c NR; i++) CH.push({ o, n: RN - (hash(i + 40) * 4) | 0, L: RL, g: 40, k: 0.04, kind: 1, f: 1 }), (o += RN);\n  for (let i = 0; i \u003c 2 * NT; i++) CH.push({ o, n: TN, L: TL * (0.8 + 0.4 * hash(i + 80)), g: 14, k: 0.1, kind: 2, f: 1 }), (o += TN);\n}\nconst NN = NH * HN + NR * RN + 2 * NT * TN;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, wind: 0, fury: 0.06, gust: 0,\n    hx: 32, hy: 30, tilt: 0, mouth: 0, arms: 0, blast: 0, flash: 0,\n    X: new Float32Array(NN), Y: new Float32Array(NN), PX: new Float32Array(NN), PY: new Float32Array(NN),\n    rx: new Float32Array(NN), ry: new Float32Array(NN), init: false,\n    rings: [], wailN: -1, ringT: 0,\n    rattle: 0, bend: 0, gutter: 0, fogX: 32, fogR: 0, fogP: 0,\n    crows: PERCH.map((x, i) => ({ hx: x, hy: RIDGE, x, y: RIDGE, vx: 0, vy: 0, st: 0, t: 0, ph: i * 1.7, face: i & 1 ? 1 : -1 })),\n    bg: new Float32Array(N * 3), sky: new Float32Array(N), buf: new Float32Array(N * 3),\n    ga: new Float32Array(N), gh: new Float32Array(N), ri: new Float32Array(N), rs: new Float64Array(400),\n    gc: [0, 0, 0], wc: [0, 0, 0],\n  };\n  scene(params.s);\n}\n\n// The still picture: sky, far hills, the cottage and the ground.\nfunction scene(S) {\n  const { bg, sky } = S;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r, g, b, s = 0;\n      // The roof: a hipped thatch from the left end to past the right edge.\n      const roofL = 14 + ((EAVE - y) / (EAVE - RIDGE)) * 8;\n      const hill = 84 + 3 * sin(x * 0.09 + 1) + 2 * sin(x * 0.23);\n      if (y >= RIDGE && y \u003c EAVE && x >= roofL) {\n        const n = hash(x * 3 + y * 131) * 0.5 + 0.5 * (0.5 + 0.5 * sin(x * 1.3 + y * 0.6));\n        r = 22 + 10 * n;\n        g = 14 + 6 * n;\n        b = 26 + 8 * n;\n        if (y === RIDGE) (r += 14), (g += 10), (b += 18);\n      } else if (y >= 60 && y \u003c RIDGE && x >= 53 && x \u003c= 58) {\n        // The chimney.\n        const n = hash(x + y * 17);\n        r = 24 + 8 * n;\n        g = 16 + 5 * n;\n        b = 26 + 6 * n;\n      } else if (y >= EAVE && y \u003c GROUND && x >= 16) {\n        // Stone wall: courses of rough stones with dark mortar.\n        const row = floor((y - EAVE) / 4), off = row & 1 ? 3 : 0, col = floor((x + off) / 6);\n        const mort = (y - EAVE) % 4 === 3 || (x + off) % 6 === 5;\n        const n = hash(row * 97 + col * 13);\n        r = mort ? 8 : 26 + 14 * n;\n        g = mort ? 6 : 20 + 10 * n;\n        b = mort ? 12 : 30 + 12 * n;\n        if (x === 16) (r *= 0.6), (g *= 0.6), (b *= 0.6);\n      } else if (y >= GROUND || (y >= hill && (x \u003c 16 || y >= EAVE))) {\n        // Moor: dark peat with tufts.\n        const n = hash(x * 7 + y * 61);\n        const d = y >= GROUND ? 1 : 0.7;\n        r = (10 + 8 * n) * d;\n        g = (12 + 9 * n) * d;\n        b = (16 + 6 * n) * d;\n      } else {\n        // Sky, near black overhead and violet towards the horizon, with stars.\n        const u = y / 84;\n        s = 1;\n        r = 4 + 54 * u * u;\n        g = 2 + 26 * u * u;\n        b = 12 + 80 * u * u;\n        if (y \u003c 56 && hash(p * 3 + 1) > 0.985) {\n          const v = 50 + 70 * hash(p);\n          (r += v), (g += v), (b += v * 1.1);\n        }\n      }\n      bg[p * 3] = r / 255;\n      bg[p * 3 + 1] = g / 255;\n      bg[p * 3 + 2] = b / 255;\n      sky[p] = s;\n    }\n  // The window's frame, dark wood round the four panes.\n  for (let y = WY - 1; y \u003c= WY + 2 * PS + 1; y++)\n    for (let x = WX - 1; x \u003c= WX + 2 * PS + 1; x++) {\n      const p = (y * W + x) * 3;\n      bg[p] = 0.07;\n      bg[p + 1] = 0.04;\n      bg[p + 2] = 0.05;\n    }\n}\n\n// Where each chain hangs from this step, from the head and the arms.\nfunction roots(S) {\n  const { hx, hy, tilt, arms, rx, ry } = S;\n  for (let c = 0; c \u003c CH.length; c++) {\n    const ch = CH[c];\n    let x, y;\n    if (ch.kind === 0) {\n      // Hair across the crown, from one temple over to the other.\n      const a = PI * (1.06 + (0.88 * c) / (NH - 1));\n      x = hx + 4.3 * cos(a);\n      y = hy - 0.6 - tilt + 5 * sin(a);\n    } else if (ch.kind === 1) {\n      // The robe across the shoulders.\n      const u = ((c - NH) / (NR - 1)) * 2 - 1;\n      x = hx + u * 5.6;\n      y = hy + 6.4 + 1.4 * u * u;\n    } else {\n      // Tatters along the forearms.\n      const j = c - NH - NR, side = j \u003c NT ? -1 : 1, f = ((j % NT) + 1) / NT;\n      const [ex, ey, wx, wy] = arm(S, side);\n      x = ex + (wx - ex) * f;\n      y = ey + (wy - ey) * f;\n    }\n    rx[c] = x;\n    ry[c] = y;\n  }\n}\n\n// An arm's elbow and wrist: hanging a little out at rest, flung up and out\n// when she wails.\nconst ARM = [0, 0, 0, 0];\nfunction arm(S, side) {\n  const a = 0.32 + 0.1 * sin(S.t * 1.3 + side) + 2.1 * S.arms, b = a + 0.45 - 0.75 * S.arms;\n  const sx = S.hx + side * 5, sy = S.hy + 7.5;\n  ARM[0] = sx + side * 8 * sin(a);\n  ARM[1] = sy + 8 * cos(a);\n  ARM[2] = ARM[0] + side * 7 * sin(b);\n  ARM[3] = ARM[1] + 7 * cos(b);\n  return ARM;\n}\n\n// One step of h for every chain: each node keeps its motion, is pulled\n// towards the wind's speed and by its own gravity, and the blast of the wail\n// pushes it away from her head; then each segment is set back to its length,\n// root first.\nfunction chains(S, h) {\n  const { X, Y, PX, PY, rx, ry, t, hx, hy } = S;\n  const wx0 = 4 + 40 * S.wind + S.gust, amp = 7 + 18 * S.wind, bl = S.blast * 45;\n  for (let c = 0; c \u003c CH.length; c++) {\n    const { o, n, L, g, k, f: fq } = CH[c];\n    X[o] = PX[o] = rx[c];\n    Y[o] = PY[o] = ry[c];\n    for (let i = 1; i \u003c n; i++) {\n      const j = o + i, f = i / n, vx = X[j] - PX[j], vy = Y[j] - PY[j];\n      let wx = wx0 + amp * f * sin(t * 2.9 * fq + i * 0.42 + c * 1.37), wy = amp * 0.8 * f * cos(t * 2.3 * fq + i * 0.5 + c * 0.9);\n      if (bl > 0) {\n        const dx = X[j] - hx, dy = Y[j] - hy, d = sqrt(dx * dx + dy * dy) + 2;\n        wx += bl * (0.5 + (0.6 * dx) / d);\n        wy += (bl * 0.3 * dy) / d;\n      }\n      PX[j] = X[j];\n      PY[j] = Y[j];\n      X[j] += vx * 0.98 + k * (wx * h - vx);\n      Y[j] += vy * 0.98 + k * (wy * h - vy) + g * h * h;\n    }\n    for (let i = 1; i \u003c n; i++) {\n      const j = o + i, dx = X[j] - X[j - 1], dy = Y[j] - Y[j - 1], d = sqrt(dx * dx + dy * dy) || 1;\n      X[j] = X[j - 1] + (dx * L) / d;\n      Y[j] = Y[j - 1] + (dy * L) / d;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.fury = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2, F = 0.55 + 0.45 * S.fury;\n  S.t += ds;\n  const t = S.t;\n  // Where she is in her wail.\n  const nw = floor((t - W0) / WP), w = t >= W0 ? t - W0 - nw * WP : -1;\n  const up = w \u003c 0 ? 0 : w \u003c WA ? sm(w / WA) : w \u003c WB ? 1 : w \u003c WC ? 1 - sm((w - WB) / (WC - WB)) : 0;\n  S.tilt = up;\n  S.arms = up;\n  S.mouth = w \u003c 0 ? 0.1 : w \u003c WA ? 0.1 + 0.9 * sm((w - 0.15) / (WA - 0.15)) : w \u003c WB ? 1 : w \u003c WC ? 1 - 0.9 * sm((w - WB) / 0.4) : 0.1;\n  S.blast = w >= WA && w \u003c WB ? F * (0.6 + 0.4 * sm((w - WA) / 0.3)) : 0;\n  // She drifts and bobs. When she wails she rises.\n  S.hx = 27 - 8 * S.wind + 10 * sin(0.23 * t + 0.4) + 4 * sin(0.57 * t);\n  S.hy = 30 + 4 * sin(0.31 * t) + 1.5 * sin(1.3 * t) - 4 * up;\n  S.gust = vn(t * 0.7, 3) * (4 + 16 * S.wind);\n  // A new wail: rings start leaving her mouth.\n  if (w >= WA && w \u003c WB) {\n    if (S.wailN !== nw) (S.wailN = nw), (S.ringT = 0), (S.fogX = S.hx), (S.fogR = 0);\n    S.ringT -= ds;\n    if (S.ringT \u003c= 0) {\n      S.ringT += RI;\n      S.rings.push({ x: S.hx, y: S.hy + 2.5 - S.tilt, t0: t, a: F });\n    }\n  }\n  S.flash = max(S.flash * exp(-6 * ds), (S.blast > 0) * (0.45 + 1.2 * S.fury) * (S.ringT > RI * 0.5 ? 1 : 0.7));\n  S.rattle *= exp(-3 * ds);\n  S.fogP = max(0, S.fogP - 0.22 * ds);\n  const mx = S.hx, my = S.hy + 2.5;\n  for (let i = S.rings.length - 1; i >= 0; i--) {\n    const R = S.rings[i], r = (t - R.t0) * RV, r0 = r - ds * RV;\n    if (r > 140) {\n      S.rings.splice(i, 1);\n      continue;\n    }\n    // What the ring front crossed this step.\n    const dw = sqrt((R.x - 38.5) ** 2 + (R.y - 101) ** 2);\n    if (r0 \u003c dw && r >= dw) S.rattle = max(S.rattle, R.a);\n    const fy = FOG + 8 - R.y;\n    if (r > fy) S.fogR = max(S.fogR, sqrt(r * r - fy * fy)), (S.fogP = max(S.fogP, R.a));\n    for (const c of S.crows) {\n      const dc = sqrt((R.x - c.x) ** 2 + (R.y - c.y) ** 2);\n      if (c.st === 0 && r0 \u003c dc && r >= dc) {\n        c.st = 1;\n        c.t = 0;\n        c.vx = (c.x \u003c R.x ? -1 : 1) * (16 + 14 * hash(c.hx + nw * 7)) * (0.6 + 0.6 * R.a);\n        c.vy = -(24 + 12 * hash(c.hx * 3 + nw));\n      }\n    }\n  }\n  // The candle flame lies over, away from her, while the wail lasts.\n  const flat = w >= WA && w \u003c WB + 0.3 && S.rattle > 0.05 ? 1 : 0;\n  const lean = (FX > mx ? 1 : -1) * 1.45 * F;\n  S.bend += ((flat ? lean : 0.12 * vn(t * 3, 9)) - S.bend) * min(1, 9 * ds);\n  S.gutter += ((flat ? 0.55 * F : 0) - S.gutter) * min(1, 5 * ds);\n  // Crows: off the ridge, away and back.\n  for (const c of S.crows) {\n    c.ph += ds * (c.st ? 40 : 1.3);\n    c.t += ds;\n    if (c.st === 1) {\n      c.vy += 8 * ds;\n      c.vx *= 1 - 0.3 * ds;\n      if (c.t > 2.2) c.st = 2;\n    } else if (c.st === 2) {\n      const dx = c.hx - c.x, dy = c.hy - c.y, dd = sqrt(dx * dx + dy * dy) || 1;\n      const sp = min(28, 3 + dd * 2);\n      c.vx += ((dx / dd) * sp - c.vx) * min(1, 2.5 * ds);\n      c.vy += ((dy / dd) * sp - c.vy) * min(1, 2.5 * ds);\n      if (dd \u003c 1.2) (c.st = 0), (c.x = c.hx), (c.y = c.hy), (c.vx = c.vy = 0), (c.face = c.hx \u003c mx ? 1 : -1);\n    }\n    if (c.st) (c.x += c.vx * ds), (c.y += c.vy * ds), (c.face = c.vx \u003c 0 ? -1 : 1);\n  }\n  // Hair and cloth, two steps a frame; the first frame lets them stream out.\n  if (!S.init) {\n    S.init = true;\n    roots(S);\n    for (let c = 0; c \u003c CH.length; c++)\n      for (let i = 0; i \u003c CH[c].n; i++) {\n        const j = CH[c].o + i;\n        S.X[j] = S.PX[j] = S.rx[c] + i * CH[c].L * 0.6;\n        S.Y[j] = S.PY[j] = S.ry[c] + i * CH[c].L * 0.8;\n      }\n    for (let i = 0; i \u003c 90; i++) chains(S, 1 / 60);\n  }\n  roots(S);\n  chains(S, ds / 2);\n  chains(S, ds / 2);\n}\n\n// Ghost light: an anti-aliased dot added into a buffer, a segment of them,\n// and filled shapes kept at the higher of what is there and a.\nfunction dot(g, x, y, a) {\n  x -= 0.5;\n  y -= 0.5;\n  const ix = floor(x), iy = floor(y), fx = x - ix, fy = y - iy;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const X = ix + i, Y = iy + j;\n      if (X >= 0 && X \u003c W && Y >= 0 && Y \u003c H) g[Y * W + X] += a * (i ? fx : 1 - fx) * (j ? fy : 1 - fy);\n    }\n}\nfunction seg(g, x0, y0, x1, y1, a0, a1) {\n  const n = max(1, Math.ceil(sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) * 1.6));\n  for (let i = 0; i \u003c n; i++) {\n    const f = i / n;\n    dot(g, x0 + (x1 - x0) * f, y0 + (y1 - y0) * f, (a0 + (a1 - a0) * f) * 0.62);\n  }\n}\nfunction tri(g, ax, ay, bx, by, cx, cy, a) {\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, floor(max(ax, bx, cx))), y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, floor(max(ay, by, cy)));\n  const ar = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(ar) \u003c 1e-6) return;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const u = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / ar, v = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / ar;\n      if (u >= 0 && v >= 0 && u + v \u003c= 1) {\n        const p = y * W + x;\n        if (g[p] \u003c a) g[p] = a;\n      }\n    }\n}\nfunction ell(g, cx, cy, rx, ry, a) {\n  for (let y = max(0, floor(cy - ry)); y \u003c= min(H - 1, floor(cy + ry)); y++)\n    for (let x = max(0, floor(cx - rx)); x \u003c= min(W - 1, floor(cx + rx)); x++) {\n      const u = (x + 0.5 - cx) / rx, v = (y + 0.5 - cy) / ry, q = u * u + v * v;\n      if (q \u003c 1) {\n        const p = y * W + x, b = a * min(1, (1 - q) * 3);\n        if (g[p] \u003c b) g[p] = b;\n      }\n    }\n}\n\n// Crow on a perch, facing left; flipped when it faces right.\nconst PERCHED = [\".##....\", \"####...\", \".#####.\", \"..#####\", \"...#.#.\"];\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { bg, sky, buf, ga, gh, X, Y, gc, wc, t } = S;\n  const hue = 0.33 + S.hue;\n  hsv(hue, 0.85, 1, wc);\n  hsv(hue, 0.2, 1, gc);\n  const mx = S.hx, my = S.hy + 2.6 - 1.1 * S.tilt;\n  // Rings now: centre, radius and strength.\n  const rs = S.rs, ri = S.ri;\n  let nr = 0;\n  for (const R of S.rings) {\n    const r = (t - R.t0) * RV;\n    rs[nr * 4] = R.x;\n    rs[nr * 4 + 1] = R.y;\n    rs[nr * 4 + 2] = r;\n    rs[nr++ * 4 + 3] = R.a * (1 - r / 140);\n  }\n  ri.fill(0);\n  // The night, bent where a ring passes, and lit by the flash.\n  const fr = 40 + 40 * S.fury, rw = 0.9 + 1.4 * S.fury;\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      let sx = x, sy = y;\n      for (let k = 0; k \u003c nr * 4; k += 4) {\n        const dx = x + 0.5 - rs[k], dy = y + 0.5 - rs[k + 1], d = sqrt(dx * dx + dy * dy) + 1e-3, e = d - rs[k + 2], a = rs[k + 3];\n        if (e > -4 && e \u003c 4) {\n          const o = 2.4 * a * (1 - abs(e) / 4) * (e \u003c 0 ? 1 : -0.5);\n          sx += (dx / d) * o;\n          sy += (dy / d) * o;\n          if (e > -rw && e \u003c rw) ri[p] += a * 0.75 * (1 - abs(e) / rw);\n        }\n      }\n      const q = (cl(round(sy), 0, H - 1) * W + cl(round(sx), 0, W - 1)) * 3;\n      const dm = sqrt((x - mx) ** 2 + (y - my) ** 2), fl = S.flash * (0.25 + 0.5 * sky[p]) * exp(-dm / fr);\n      buf[p * 3] = bg[q] + wc[0] * fl * 0.5;\n      buf[p * 3 + 1] = bg[q + 1] + wc[1] * fl * 0.5;\n      buf[p * 3 + 2] = bg[q + 2] + wc[2] * fl * 0.5;\n    }\n  win(S);\n  fog(S);\n  crows(S);\n  // The banshee.\n  ga.fill(0);\n  gh.fill(0);\n  for (let c = NH; c \u003c NH + NR - 1; c++) {\n    const A = CH[c], B = CH[c + 1], n = min(A.n, B.n);\n    for (let i = 0; i \u003c n - 1; i++) {\n      const a = 0.45 - (0.25 * i) / n, p = A.o + i, q = B.o + i;\n      tri(ga, X[p], Y[p], X[p + 1], Y[p + 1], X[q + 1], Y[q + 1], a);\n      tri(ga, X[p], Y[p], X[q + 1], Y[q + 1], X[q], Y[q], a);\n    }\n  }\n  for (let c = NH; c \u003c CH.length; c++) {\n    const { o, n, kind } = CH[c];\n    for (let i = 0; i \u003c n - 1; i++) seg(gh, X[o + i], Y[o + i], X[o + i + 1], Y[o + i + 1], kind === 1 ? 0.25 : 0.5, kind === 1 ? 0.2 : 0.2);\n  }\n  for (const side of [-1, 1]) {\n    const [ex, ey, wx, wy] = arm(S, side), sx = S.hx + side * 5, sy = S.hy + 7.5;\n    seg(gh, sx, sy, ex, ey, 0.9, 0.8);\n    seg(gh, ex, ey, wx, wy, 0.8, 0.7);\n    ell(ga, wx, wy, 1.1, 1.1, 0.9);\n  }\n  seg(gh, S.hx, S.hy + 3, S.hx, S.hy + 7, 0.9, 0.9);\n  ell(ga, S.hx, S.hy, 3.7, 4.7 * (1 - 0.12 * S.tilt), 0.95);\n  for (let c = 0; c \u003c NH; c++) {\n    const { o, n } = CH[c];\n    for (let i = 0; i \u003c n - 1; i++) seg(gh, X[o + i], Y[o + i], X[o + i + 1], Y[o + i + 1], 0.55 - (0.4 * i) / n, 0.55 - (0.4 * (i + 1)) / n);\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const a = min(1, ga[p] + gh[p]);\n    if (a \u003c= 0) continue;\n    const k = 1 - 0.72 * a;\n    buf[p * 3] = buf[p * 3] * k + gc[0] * a * 0.92;\n    buf[p * 3 + 1] = buf[p * 3 + 1] * k + gc[1] * a * 0.92;\n    buf[p * 3 + 2] = buf[p * 3 + 2] * k + gc[2] * a * 0.92;\n  }\n  face(S, mx, my);\n  // The rings themselves, added on top.\n  for (let p = 0; p \u003c N; p++) {\n    const v = ri[p];\n    if (v > 0) (buf[p * 3] += wc[0] * v), (buf[p * 3 + 1] += wc[1] * v), (buf[p * 3 + 2] += wc[2] * v);\n  }\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), q4(buf[3 * p]), q4(buf[3 * p + 1]), q4(buf[3 * p + 2]));\n}\n\n// Eyes and the mouth: dark hollows with a glint, and a mouth that opens to a\n// long dark O glowing inside while she wails.\nfunction face(S, mx, my) {\n  const { buf, wc } = S;\n  const set = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    buf[p] = r;\n    buf[p + 1] = g;\n    buf[p + 2] = b;\n  };\n  const ey = floor(S.hy - 0.6 - 1.2 * S.tilt), gl = 0.3 + 0.7 * S.blast;\n  for (const side of [-1, 1]) {\n    const ex = floor(S.hx + side * 1.6);\n    set(ex, ey, wc[0] * gl, wc[1] * gl, wc[2] * gl);\n    set(ex, ey + 1, 0.04, 0.03, 0.08);\n  }\n  const rx = 0.5 + 1.1 * S.mouth, ry = 0.5 + 2.3 * S.mouth;\n  for (let y = floor(my - ry); y \u003c= floor(my + ry); y++)\n    for (let x = floor(mx - rx); x \u003c= floor(mx + rx); x++) {\n      const u = (x + 0.5 - mx) / rx, v = (y + 0.5 - my) / ry, q = u * u + v * v;\n      if (q \u003c 1) {\n        const g = S.blast * (1 - q) * 0.9;\n        set(x, y, 0.03 + wc[0] * g, 0.02 + wc[1] * g, 0.06 + wc[2] * g);\n      }\n    }\n}\n\n// The window: four panes lit warm by a candle on the sill, shaken loose in\n// their frame by a passing ring, the flame bending over.\nfunction win(S) {\n  const { buf, t } = S;\n  const fb = 1 - S.gutter, fl = 0.92 + 0.08 * vn(t * 9, 4);\n  const len = (4.2 + 0.6 * vn(t * 7, 2)) * (1 - 0.35 * S.gutter);\n  for (let pj = 0; pj \u003c 2; pj++)\n    for (let pi = 0; pi \u003c 2; pi++) {\n      const id = pj * 2 + pi, r = S.rattle;\n      const ox = r > 0.06 ? round(r * 1.4 * sin(t * 53 + id * 2.1)) : 0, oy = r > 0.06 ? round(r * 1.1 * cos(t * 47 + id * 1.3)) : 0;\n      const x0 = WX + pi * (PS + 1), y0 = WY + pj * (PS + 1);\n      for (let y = y0; y \u003c y0 + PS; y++)\n        for (let x = x0; x \u003c x0 + PS; x++) {\n          const p = (y * W + x) * 3, lx = x - ox, ly = y - oy;\n          if (lx \u003c x0 || lx >= x0 + PS || ly \u003c y0 || ly >= y0 + PS) {\n            buf[p] = 0.05;\n            buf[p + 1] = 0.03;\n            buf[p + 2] = 0.04;\n            continue;\n          }\n          const d = sqrt((lx + 0.5 - FX) ** 2 + (ly + 0.5 - FY + 2) ** 2), gw = exp(-d / 5) * fb * fl;\n          let R = 0.42 + 0.58 * gw, G = 0.2 + 0.52 * gw, B = 0.06 + 0.22 * gw;\n          // The candle, cream wax on the sill.\n          if (lx >= 34 && lx \u003c= 35 && ly > FY && ly \u003c= FY + 4) (R = 0.85), (G = 0.75), (B = 0.55);\n          buf[p] = R * fl;\n          buf[p + 1] = G * fl;\n          buf[p + 2] = B * fl;\n        }\n    }\n  // The flame: a tongue from the wick, bent by S.bend.\n  const r = S.rattle, ox = r > 0.06 ? round(r * 1.4 * sin(t * 53 + 4.2)) : 0, oy = r > 0.06 ? round(r * 1.1 * cos(t * 47 + 1.3)) : 0;\n  for (let i = 0; i \u003c= 8; i++) {\n    const f = i / 8, a = S.bend * f, px = FX + ox + sin(a) * len * f, py = FY + oy - cos(a) * len * f, wd = 1.3 * (1 - f) + 0.3;\n    for (let y = floor(py - wd); y \u003c= floor(py + wd); y++)\n      for (let x = floor(px - wd); x \u003c= floor(px + wd); x++) {\n        if (x \u003c WX + 0 || x >= WX + PS || y \u003c WY + PS + 1 || y >= WY + 2 * PS + 1) continue;\n        if ((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2 > wd * wd) continue;\n        const p = (y * W + x) * 3;\n        buf[p] = 1 * fb + 0.4 * (1 - fb);\n        buf[p + 1] = (0.95 - 0.45 * f) * fb + 0.2 * (1 - fb);\n        buf[p + 2] = (0.7 - 0.6 * f) * fb + 0.05;\n      }\n  }\n}\n\n// Ground fog drifting with the wind, blown out in a ring under her by the\n// wail and creeping back.\nfunction fog(S) {\n  const { buf, t } = S;\n  const sp = 3 + 9 * S.wind;\n  for (let y = FOG; y \u003c H; y++) {\n    const pr = sm((y - FOG) / 16);\n    for (let x = 0; x \u003c W; x++) {\n      let d = pr * (0.62 + 0.24 * vn(x * 0.11 - t * sp * 0.1 + y * 0.37, 11) + 0.18 * vn(x * 0.23 - t * sp * 0.07 - y * 0.21, 12));\n      if (S.fogP > 0) {\n        const dd = abs(x + 0.5 - S.fogX), e = (dd - S.fogR) / 3;\n        d *= dd \u003c S.fogR ? 1 - S.fogP * 0.92 * sm((S.fogR - dd) / 5) : 1;\n        d += pr * S.fogP * 0.6 * exp(-e * e);\n      }\n      const a = cl(d * 0.62, 0, 0.85), p = (y * W + x) * 3;\n      buf[p] = buf[p] * (1 - a) + 0.5 * a;\n      buf[p + 1] = buf[p + 1] * (1 - a) + 0.45 * a;\n      buf[p + 2] = buf[p + 2] * (1 - a) + 0.62 * a;\n    }\n  }\n}\n\nfunction crows(S) {\n  const { buf } = S;\n  const set = (x, y) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = (y * W + x) * 3;\n    buf[p] = 0.02;\n    buf[p + 1] = 0.01;\n    buf[p + 2] = 0.03;\n  };\n  for (const c of S.crows) {\n    const x = round(c.x), y = round(c.y);\n    if (c.st === 0) {\n      for (let j = 0; j \u003c 5; j++)\n        for (let i = 0; i \u003c 7; i++) if (PERCHED[j][c.face \u003c 0 ? i : 6 - i] === \"#\") set(x - 3 + i, y - 5 + j);\n    } else {\n      // In flight: a body, a head and two wings beating.\n      const f = sin(c.ph), tip = -3.2 * f, mid = -1.4 * f;\n      for (let i = -1; i \u003c= 1; i++) set(x + i, y);\n      set(x + 2 * c.face, y - 1);\n      set(x + c.face, y - 1);\n      set(x - 2 * c.face, y + 1);\n      for (const s of [-1, 1]) {\n        set(x + s * 2, round(y + mid * 0.6));\n        set(x + s * 3, round(y + mid));\n        set(x + s * 4, round(y + (mid + tip) * 0.5));\n        set(x + s * 5, round(y + tip));\n      }\n    }\n  }\n}\n","creaking-door":"// ===== Patternflow pattern =====\n// Title:   Creaking Door\n// Family:  halloween\n// Idea:    A door at the end of a purple-dark hallway creaks open in lurches and candlelight from the room behind spills out as a widening wedge across the floorboards and up the left wall, dust glittering in it, while the shadow of a long-fingered hand, or of someone in a pointed hat, reaches across the light from somewhere out of sight; then the door slams with a jolt that shakes the panel and brings dust down from the lintel, and in the dark two feet cross the line of light under the door before it begins again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Reach=0..1, Haze=0..1\n//\n// Knob 1: Hue. The colour of the light in the room. At 0 a candle's, deep red where it is faint and pale gold where it is strong, orange between. At 0.33 toxic green turning towards cyan where it is strong, at 0.67 blue turning violet. The hallway's purple stays.\n// Knob 2: Speed. At 2 a round lasts 10 to 11.5 seconds: the door lurches open over 3.4 to 4.8 s to between 54 and 69 degrees, the shadow comes 2.2 to 2.8 s in and stays 4 s, the door slams 6.2 to 7 s in, shut in 0.14 s, and the dark lasts 3.6 to 4.2 s. The first round starts with the door already ajar. At 1 everything takes twice as long, at 0.2 ten times.\n// Knob 3: Reach. How far the candle's light carries before it falls to half: 0.9 m (30 LEDs across at the door) at 0, 2.3 m at 1. At 0 the boards near the eye stay deep red and the hallway outside the wedge stays purple; at 1 the wedge burns orange down to the bottom of the panel and the left wall glows gold.\n// Knob 4: Haze. Dust in the air. At 0 the light shows only where it lands, with a few motes; at the opening 0.06 a faint glow over the wedge and 140 motes glittering in it; at 1 the beam stands in the air as a glowing wedge with the shadow cut through it.\n// Buttons: K1 tap slams the door while it is opening or open; while it is shut, a tap opens it again.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\n\n// World in metres: x to the right, y up, z away from the eye. The eye stands\n// EYE above the floor and ZC in front of the far wall (z = 0). F is the focal\n// length in LEDs, and the horizon sits on row CY.\nconst EYE = 1.2, ZC = 3, F = 100, CX = 32, CY = 42;\n// The hallway is 2 HW wide under a ceiling HC high. The doorway in the far\n// wall is 2 DW wide and DH high inside a trim TRIM wide, with a gap GAP\n// under the door.\nconst HW = 0.6, HC = 2.4, DW = 0.45, DH = 2, TRIM = 0.07, GAP = 0.02;\n// The room behind is 2 RW wide, RD deep and RH high. The candle stands in it\n// at (LX, LY, LZ), round the corner to the right where the eye cannot see it.\nconst RW = 1.4, RD = 2.6, RH = 2.5, LX = 0.75, LY = 0.85, LZ = 1.4;\n// Light strength, and its strength on the room's own walls.\nconst LI = 8, RI = 2;\n// Kinds of LED.\nconst CEIL = 0, WALL = 1, TRM = 2, LEFT = 3, RIGHT = 4, FLOOR = 5, DOOR = 6;\nconst NRM = [[0, -1, 0], [0, 0, -1], [0, 0, -1], [1, 0, 0], [-1, 0, 0], [0, 1, 0]];\n\nfunction setup0(S) {\n  const g = (S.geo = {\n    kind: new Uint8Array(N), P: new Float32Array(N * 3), amb: new Float32Array(N * 3), alb: new Float32Array(N),\n    d: new Float32Array(N * 2), R: new Float32Array(N * 3), rn: new Float32Array(N * 3), ramb: new Float32Array(N * 3), tz: new Float32Array(N),\n  });\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, dx = (x + 0.5 - CX) / F, dy = -(y + 0.5 - CY) / F;\n      // The nearest of the hallway's six faces along the ray from the eye.\n      let t = ZC, k = WALL;\n      if (dy \u003c 0 && -EYE / dy \u003c t) (t = -EYE / dy), (k = FLOOR);\n      if (dy > 0 && (HC - EYE) / dy \u003c t) (t = (HC - EYE) / dy), (k = CEIL);\n      if (dx \u003c 0 && -HW / dx \u003c t) (t = -HW / dx), (k = LEFT);\n      if (dx > 0 && HW / dx \u003c t) (t = HW / dx), (k = RIGHT);\n      const X = dx * t, Y = EYE + dy * t, Z = -ZC + t;\n      if (k === WALL && abs(X) \u003c DW && Y \u003c DH) k = DOOR;\n      else if (k === WALL && abs(X) \u003c DW + TRIM && Y \u003c DH + TRIM) k = TRM;\n      g.kind[p] = k;\n      g.P[p * 3] = X;\n      g.P[p * 3 + 1] = Y;\n      g.P[p * 3 + 2] = Z;\n      g.d[p * 2] = dx;\n      g.d[p * 2 + 1] = dy;\n      g.tz[p] = Z;\n      let r = 0, gg = 0, b = 0, a = 1;\n      if (k === FLOOR) {\n        // Boards 0.12 wide running away from the eye.\n        const bi = floor((X + 3) / 0.12), u = (X + 3) / 0.12 - bi;\n        const seam = u \u003c 0.14 ? 0.55 : 1, tone = 0.85 + 0.3 * hash(bi * 13);\n        r = 26 * seam * tone;\n        gg = 11 * seam * tone;\n        b = 30 * seam * tone;\n        a = 0.85 * seam * tone;\n      } else if (k === CEIL) (r = 14), (gg = 6), (b = 22), (a = 0.8);\n      else if (k === TRM) (r = 54), (gg = 30), (b = 58), (a = 1);\n      else {\n        // Wallpaper in stripes above the dado rail, panelling below it.\n        const u = k === WALL ? X : Z, st = 0.5 + 0.5 * cos(u * 2 * PI * 7), lo = Y \u003c 0.9, rail = abs(Y - 0.9) \u003c 0.03 || Y \u003c 0.1;\n        const f = rail ? 1.12 : lo ? 0.8 : 0.85 + 0.25 * st;\n        r = 36 * f;\n        gg = 14 * f;\n        b = 50 * f;\n        a = f;\n      }\n      g.amb[p * 3] = r;\n      g.amb[p * 3 + 1] = gg;\n      g.amb[p * 3 + 2] = b;\n      g.alb[p] = a;\n      if (k === DOOR) {\n        // Where the ray lands in the room if the door is not in the way.\n        let tr = 1e9, kk = 0;\n        const c = [[0, -1, 0], [0, 1, 0], [-1, 0, 0], [1, 0, 0], [0, 0, -1]];\n        const ts = [dy > 0 ? (RH - EYE) / dy : 1e9, dy \u003c 0 ? -EYE / dy : 1e9, dx > 0 ? RW / dx : 1e9, dx \u003c 0 ? -RW / dx : 1e9, ZC + RD];\n        for (let i = 0; i \u003c 5; i++) if (ts[i] > ZC && ts[i] \u003c tr) (tr = ts[i]), (kk = i);\n        const RX = dx * tr, RY = EYE + dy * tr, RZ = -ZC + tr;\n        g.R[p * 3] = RX;\n        g.R[p * 3 + 1] = RY;\n        g.R[p * 3 + 2] = RZ;\n        g.rn[p * 3] = c[kk][0];\n        g.rn[p * 3 + 1] = c[kk][1];\n        g.rn[p * 3 + 2] = c[kk][2];\n        // A picture on the back wall; plain plaster elsewhere.\n        const pic = kk === 4 && abs(RX + 0.1) \u003c 0.35 && abs(RY - 1.45) \u003c 0.3, fr = pic && (abs(RX + 0.1) > 0.29 || abs(RY - 1.45) > 0.24);\n        const f = fr ? 0.35 : pic ? 0.6 : kk === 1 ? 0.7 : 1;\n        g.ramb[p * 3] = 40 * f;\n        g.ramb[p * 3 + 1] = 18 * f;\n        g.ramb[p * 3 + 2] = 40 * f;\n      }\n    }\n}\n\n// The door turns by th about its hinge at the left jamb, into the room.\n// Does the segment from A to the candle cross it?\nfunction doorBlocks(S, ax, ay, az) {\n  const s = S.sn, c = S.cs, na = s * (ax + DW) - c * az, nb = s * (LX + DW) - c * LZ;\n  if ((na > 0) === (nb > 0)) return false;\n  const t = na / (na - nb), X = ax + (LX - ax) * t, Y = ay + (LY - ay) * t, Z = az + (LZ - az) * t, u = (X + DW) * c + Z * s;\n  return u >= 0 && u \u003c= 2 * DW && Y >= GAP && Y \u003c= DH;\n}\n\n// Light at P from the candle, 0 when something is in the way. Points in the\n// hallway see the candle only through the doorway, and there the shadow\n// mask (the hand, or the figure) can stand in it. A door ajar by less than\n// 0.03 rad counts as shut: the slit would light a dotted line.\nfunction vis(S, x, y, z) {\n  if (z \u003c 0) {\n    if (S.th \u003c 0.03) return 0;\n    const k = -z / (LZ - z), qx = x + (LX - x) * k, qy = y + (LY - y) * k;\n    if (abs(qx) >= DW || qy \u003c= 0 || qy >= DH) return 0;\n    if (doorBlocks(S, x, y, z)) return 0;\n    return 1 - mask(S, qx, qy);\n  }\n  return doorBlocks(S, x, y, z) ? 0 : 1;\n}\n\n// The shadow, kept as the shape it throws on the boards: a grid over the\n// hallway floor. A ray from the candle through the doorway is in shadow when\n// the floor it would reach is dark, so the haze shows the same shadow as the\n// floor does.\nconst MS = 0.02, MW = 60, MH = 80;\nfunction mask(S, qx, qy) {\n  if (qy >= LY * 0.99) return 0;\n  const m = LY / (LY - qy), i = floor((LX + (qx - LX) * m + HW) / MS), j = floor((LZ * (m - 1)) / MS);\n  return j \u003c MH && i >= 0 && i \u003c MW ? S.mk[j * MW + i] : 0;\n}\n// A round-ended stroke from (ax, az) to (bx, bz) on the floor, r wide. The\n// shapes are drawn upright and sheared along the light, which crosses the\n// boards leaning SH to the left for every metre it comes towards the eye.\nconst SH = 0.3;\nfunction capsule(S, ax, az, bx, bz, r) {\n  (ax += SH * az), (bx += SH * bz);\n  const M = S.mk, x0 = max(0, floor((min(ax, bx) - r - 0.03 + HW) / MS)), x1 = min(MW - 1, floor((max(ax, bx) + r + 0.03 + HW) / MS));\n  const y0 = max(0, floor((-max(az, bz) - r - 0.03) / MS)), y1 = min(MH - 1, floor((-min(az, bz) + r + 0.03) / MS));\n  const ex = bx - ax, ey = bz - az, ee = ex * ex + ey * ey || 1;\n  for (let j = y0; j \u003c= y1; j++)\n    for (let i = x0; i \u003c= x1; i++) {\n      const px = (i + 0.5) * MS - HW, py = -(j + 0.5) * MS, t = cl(((px - ax) * ex + (py - az) * ey) / ee, 0, 1);\n      const d = sqrt((px - ax - ex * t) ** 2 + (py - az - ey * t) ** 2), v = cl((r - d) / 0.03 + 0.5, 0, 1);\n      if (v > M[j * MW + i]) M[j * MW + i] = v;\n    }\n}\n// A long-fingered hand lying in the light: the wrist at (wx, wz), the\n// fingers reaching towards the eye, turned by a, curled by c.\nfunction hand(S, wx, wz, a, c) {\n  const ca = cos(a), sa = sin(a), P = (u, v) => [wx + u * ca + v * sa, wz - v * ca + u * sa];\n  capsule(S, ...P(0, -0.6), ...P(0, 0), 0.1);\n  capsule(S, ...P(-0.03, 0.03), ...P(0, 0.16), 0.15);\n  for (let f = 0; f \u003c 4; f++) {\n    let [px, pz] = P(-0.15 + f * 0.1, 0.24), an = -PI / 2 + a + (f - 1.5) * 0.12;\n    const len = [0.19, 0.24, 0.23, 0.17][f], wig = 0.12 * sin(S.t * 5 + f * 1.7) * (1 - c);\n    for (let seg = 0; seg \u003c 3; seg++) {\n      an += (c * (0.3 + 0.15 * seg) * (1.5 - f) * 0.5 + wig * (f \u003c 2 ? 1 : -1)) * 0.7;\n      const nx = px + cos(an) * len * (1 - 0.45 * c), nz = pz + sin(an) * len * (1 - 0.45 * c);\n      capsule(S, px, pz, nx, nz, 0.045 - seg * 0.009);\n      (px = nx), (pz = nz);\n    }\n  }\n  const t0 = P(0.17, 0.05), t1 = P(0.31, 0.19);\n  capsule(S, ...t0, ...t1, 0.045);\n  capsule(S, ...t1, ...P(0.35, 0.33), 0.035);\n}\n// Someone in a pointed hat crossing the room between the candle and the\n// door: a long shadow from the threshold, the legs walking, the hat nearest\n// the eye.\nfunction figure(S, x, walk) {\n  const l = 0.07 * sin(walk);\n  capsule(S, x - 0.05 - l, 0.15, x - 0.05, -0.36, 0.05);\n  capsule(S, x + 0.05 + l, 0.15, x + 0.05, -0.36, 0.05);\n  capsule(S, x, -0.38, x, -0.6, 0.13);\n  capsule(S, x - 0.06, -0.66, x + 0.06, -0.66, 0.11);\n  capsule(S, x, -0.76, x, -0.84, 0.085);\n  capsule(S, x - 0.17, -0.92, x + 0.17, -0.92, 0.035);\n  for (let i = 0; i \u003c 6; i++) capsule(S, x - 0.006 * i * i, -0.95 - 0.06 * i, x - 0.006 * (i + 1) * (i + 1), -1.01 - 0.06 * i, 0.08 - 0.013 * i);\n}\n\n// One round of the door. Times in seconds at Speed 2.\nfunction plan(S, first) {\n  const r = Math.random;\n  // Now and then the door gets only half way before it slams.\n  const part = !first && r() \u003c 0.3;\n  S.cy = {\n    t0: first ? 0.8 : 0, open0: 0.8, dur: part ? 2.4 : 3.4 + r() * 1.4, thMax: part ? 0.5 + r() * 0.15 : 0.95 + r() * 0.25, kind: S.round % 2,\n    steps: [0, 1, 2, 3, 4].map(() => r()).sort(), sh0: 2.2 + r() * 0.6, slam: part ? 4.6 + r() * 0.6 : 6.2 + r() * 0.8,\n  };\n  S.cy.end = S.cy.slam + 3.6 + r() * 0.6;\n  S.ct = S.cy.t0;\n  S.round++;\n}\n// The angle as the door creaks open: five lurches with sticking between.\nfunction creak(c, u) {\n  let a = 0;\n  for (let i = 0; i \u003c 5; i++) a += sm((u - c.steps[i] * 0.85) / 0.12) * 0.2;\n  return 0.12 + (c.thMax - 0.12) * (0.25 * u + 0.75 * a);\n}\n\nexport function setup(params) {\n  const S = (params.s = { t: 0, ct: 0, round: 0, hue: 0, speed: 2, reach: 0, haze: 0.06, th: 0.12, sn: 0, cs: 1, slamT: -9, shake: [0, 0], flick: 1, D0: -1, feet: -1, peep: true,\n    mk: new Float32Array(MW * MH), lf: new Float32Array(N), buf: new Float32Array(N * 3), hz: new Float32Array(32 * 64), motes: [], falls: [] });\n  setup0(S);\n  plan(S, true);\n  for (let i = 0; i \u003c 140; i++) S.motes.push({ x: (Math.random() * 2 - 1) * HW, y: Math.random() * HC, z: -Math.random() * 1.6, ph: Math.random() * 6.3, f: 0.5 + Math.random() });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.reach = cl(k[2], 0, 1);\n  S.haze = cl(k[3], 0, 1);\n  const ft = cl(dt || 0, 0, 0.1), st = (ft * S.speed) / 2, c = S.cy;\n  S.t += st;\n  S.ct += st;\n  if (input.btnPressed && input.btnPressed[0]) {\n    if (S.ct \u003c c.slam && S.ct > c.open0) c.slam = S.ct;\n    else if (S.ct > c.slam + 0.3) S.ct = c.end + 1;\n  }\n  if (S.ct > c.end) {\n    plan(S, false);\n    if (input.btnPressed && input.btnPressed[0]) S.ct = S.cy.open0;\n  }\n  const ct = S.ct, cc = S.cy;\n  // The door's angle.\n  let th = 0;\n  if (ct \u003c cc.open0) th = 0;\n  else if (ct \u003c cc.slam) th = creak(cc, cl((ct - cc.open0) / cc.dur, 0, 1));\n  else {\n    const e = ct - cc.slam, a0 = creak(cc, cl((cc.slam - cc.open0) / cc.dur, 0, 1));\n    th = e \u003c 0.14 ? a0 * (1 - (e / 0.14) ** 2) : 0.025 * exp(-(e - 0.14) * 9) * abs(sin((e - 0.14) * 30));\n    if (e >= 0.14 && S.slamT \u003c cc.slam) {\n      S.slamT = cc.slam;\n      for (let i = 0; i \u003c 28; i++) S.falls.push({ x: (Math.random() * 2 - 1) * (DW + TRIM), y: DH + TRIM + Math.random() * 0.05, z: -0.01 - Math.random() * 0.1, v: -Math.random() * 2.5, m: 0.2 + Math.random() * 0.45, a: 1.3 + Math.random(), w: Math.random() * 6 });\n    }\n  }\n  S.th = th;\n  S.sn = sin(th);\n  S.cs = cos(th);\n  // Shake after the slam.\n  const e = ct - cc.slam - 0.14;\n  if (e > 0 && e \u003c 0.8) {\n    const A = 3 * exp(-e * 3.5);\n    S.shake = [round(A * sin(e * 83)), round(0.6 * A * sin(e * 61 + 1))];\n  } else S.shake = [0, 0];\n  // After the slam two feet cross the light under the door, right to left,\n  // and a while later the keyhole goes dark: an eye on the other side.\n  S.feet = e > 1 && e \u003c 2.8 ? (e - 1) / 1.8 : -1;\n  S.peep = !(e > 3 && e \u003c 3.5);\n  // Candle flicker.\n  S.flick = 1 + 0.13 * vn(S.t * 9, 3) + 0.06 * vn(S.t * 23, 5);\n  // The shadow.\n  S.mk.fill(0);\n  const sh = ct - cc.sh0;\n  if (sh > 0 && sh \u003c 4) {\n    const u = sh / 4;\n    if (cc.kind === 0) {\n      const reach = sm(u / 0.4) - 1.5 * sm((u - 0.78) / 0.22);\n      hand(S, 0.05 + 0.08 * sin(sh * 0.9), 0.6 - 1.1 * reach, 0.12 * sin(sh * 1.3), 0.75 * sm((u - 0.45) / 0.2) - 0.75 * sm((u - 0.72) / 0.1));\n    } else figure(S, 0.75 - 1.3 * u, sh * 7);\n  }\n  // Dust falling from the lintel after the slam.\n  for (const f of S.falls) {\n    f.v = min(f.m, f.v + 1.5 * st);\n    f.y -= max(0, f.v) * st;\n    f.x += 0.04 * sin(S.t * 3 + f.w) * st;\n    f.z -= 0.03 * st;\n    f.a -= st * 0.45;\n  }\n  S.falls = S.falls.filter((f) => f.y > 0 && f.a > 0);\n  for (const m of S.motes) {\n    m.x += 0.03 * vn(S.t * 0.5 + m.ph * 10, 1) * st;\n    m.y += (0.02 * vn(S.t * 0.4 + m.ph * 7, 2) - 0.01) * st;\n    if (m.y \u003c 0) m.y += HC;\n    if (abs(m.x) > HW) m.x = -m.x * 0.98;\n  }\n}\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n// Warm light by amount: deep red when faint, orange, then pale gold, so it\n// never sinks to brown.\nconst RAMP = 256, RMAX = 2;\nfunction ramp(S) {\n  if (S.rh === S.hue) return;\n  S.rh = S.hue;\n  const T = (S.rt = S.rt || new Float32Array(RAMP * 3)), o = [0, 0, 0];\n  for (let j = 0; j \u003c RAMP; j++) {\n    const w = (j / (RAMP - 1)) * RMAX;\n    hsv(S.hue + 0.11 * min(1, w), 1 - 0.55 * cl(w - 0.9, 0, 1), pow(min(1, w * 1.6), 0.7), o);\n    T[j * 3] = o[0];\n    T[j * 3 + 1] = o[1];\n    T[j * 3 + 2] = o[2];\n  }\n}\n\n// 0 where a foot stands in the gap under the door, 1 elsewhere.\nfunction feet(S, x, d) {\n  if (S.feet \u003c 0) return 1;\n  const r = 0.05 + 0.3 * d;\n  const u = S.feet, step = u * 5, a = DW + 0.15 - (2 * DW + 0.3) * (floor(step) + sm((step % 1) * 2)) / 5;\n  const b = DW + 0.15 - (2 * DW + 0.3) * (floor(step + 0.5) + sm(((step + 0.5) % 1) * 2) - 0.5) / 5 + 0.13;\n  return abs(x - a) \u003c r || abs(x - b) \u003c r ? 0.08 : 1;\n}\n\n// Candle light at a point facing (nx, ny, nz); nx = 2 for a mote or a speck\n// of haze, which faces every way.\nfunction lightAt(S, x, y, z, nx, ny, nz) {\n  const lx = LX - x, ly = LY - y, lz = LZ - z, d2 = lx * lx + ly * ly + lz * lz, d = sqrt(d2), lam = nx === 2 ? 1 : (nx * lx + ny * ly + nz * lz) / d;\n  if (lam \u003c= 0) return 0;\n  return lam / (1 + d2 / (S.D * S.D));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  ramp(S);\n  const g = S.geo, T = S.rt, buf = S.buf, lf = S.lf, I = LI * S.flick;\n  S.D = 0.9 * pow(2.6, S.reach);\n  if (S.D0 !== S.D) {\n    S.D0 = S.D;\n    for (let p = 0; p \u003c N; p++) {\n      const k = g.kind[p];\n      if (k === DOOR) continue;\n      const n = NRM[k];\n      lf[p] = lightAt(S, g.P[p * 3], g.P[p * 3 + 1], g.P[p * 3 + 2], n[0], n[1], n[2]) * g.alb[p];\n    }\n  }\n  const s = S.sn, c = S.cs, shut = S.th \u003c 0.03;\n  // Haze: light scattered towards the eye along each ray, at half size.\n  const hz = S.hz, hk = 0.02 + 0.3 * S.haze * S.haze;\n  for (let j = 0; j \u003c 64; j++)\n    for (let i = 0; i \u003c 32; i++) {\n      const p = (j * 2) * W + i * 2, dx = g.d[p * 2], dy = g.d[p * 2 + 1], tz = min(0, g.tz[p]);\n      let a = 0;\n      if (!shut) {\n        const t0 = 1.2, t1 = tz + ZC, n = 8, h = (t1 - t0) / n;\n        for (let q = 0; q \u003c n; q++) {\n          const t = t0 + (q + 0.5) * h, x = dx * t, y = EYE + dy * t, z = -ZC + t;\n          if (z > -1.8) a += vis(S, x, y, z) * lightAt(S, x, y, z, 2, 0, 0) * h;\n        }\n      }\n      hz[j * 32 + i] = a * hk;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, k = g.kind[p];\n      let w = 0, ar = g.amb[p * 3], ag = g.amb[p * 3 + 1], ab = g.amb[p * 3 + 2];\n      if (k === DOOR) {\n        const dx = g.d[p * 2], dy = g.d[p * 2 + 1], nC = s * DW + c * ZC, nd = s * dx - c, t = -nC / nd;\n        let hit = false;\n        if (t > ZC - 1e-6 && t \u003c 1e8) {\n          const X = dx * t, Y = EYE + dy * t, Z = -ZC + t, u = (X + DW) * c + Z * s;\n          if (u >= 0 && u \u003c= 2 * DW && Y >= GAP && Y \u003c= DH && Z \u003c= g.R[p * 3 + 2]) {\n            hit = true;\n            // The door's face: stiles, rails and four sunk panels.\n            const pu = u / (2 * DW), pv = Y / DH, inP = pu > 0.13 && pu \u003c 0.87 && ((pv > 0.08 && pv \u003c 0.43) || (pv > 0.52 && pv \u003c 0.93)) && abs(pu - 0.5) > 0.04;\n            const edge = inP && (pu \u003c 0.16 || pu > 0.84 || abs(pu - 0.5) \u003c 0.07 || abs(pv - 0.08) \u003c 0.02 || abs(pv - 0.43) \u003c 0.02 || abs(pv - 0.52) \u003c 0.02 || abs(pv - 0.93) \u003c 0.02);\n            const knob = (pu - 0.88) ** 2 * 4 + (pv - 0.48) ** 2 \u003c 0.0004, key = shut && S.peep && abs(pu - 0.88) \u003c 0.012 && abs(pv - 0.44) \u003c 0.012;\n            const f = knob ? 1.8 : edge ? 0.55 : inP ? 1.12 : 1;\n            ar = 42 * f;\n            ag = 20 * f;\n            ab = 38 * f;\n            w = lightAt(S, X, Y, Z, s, 0, -c) * 0.7 * f;\n            if (key) w = 0.8 * S.flick;\n          }\n        }\n        if (!hit) {\n          const R = g.R, X = R[p * 3], Y = R[p * 3 + 1], Z = R[p * 3 + 2];\n          ar = g.ramb[p * 3];\n          ag = g.ramb[p * 3 + 1];\n          ab = g.ramb[p * 3 + 2];\n          w = shut ? 0 : (doorBlocks(S, X, Y, Z) ? 0.08 : (lightAt(S, X, Y, Z, g.rn[p * 3], g.rn[p * 3 + 1], g.rn[p * 3 + 2]) * RI) / LI) * (ar / 40);\n          if (Y \u003c GAP * 2 && shut) w = 0.9 * feet(S, X, 0);\n        }\n        w *= I;\n      } else if (lf[p] > 0) w = lf[p] * I * vis(S, g.P[p * 3], g.P[p * 3 + 1], g.P[p * 3 + 2]);\n      // Light leaking under a shut door onto the boards just in front.\n      if (k === FLOOR && shut && g.P[p * 3 + 2] > -0.3 && abs(g.P[p * 3]) \u003c DW + 0.1) {\n        const z = g.P[p * 3 + 2], e = 1 + z / 0.3;\n        w += 0.55 * S.flick * e * e * cl((DW + 0.1 - abs(g.P[p * 3])) / 0.1, 0, 1) * feet(S, g.P[p * 3], -z);\n      }\n      // The haze, laid back over the full panel between its four nearest.\n      const hy = cl((y - 0.5) / 2, 0, 62.999), hx = cl((x - 0.5) / 2, 0, 30.999), iy = floor(hy), ix = floor(hx), fy = hy - iy, fx = hx - ix, q = iy * 32 + ix;\n      w += (hz[q] * (1 - fx) * (1 - fy) + hz[q + 1] * fx * (1 - fy) + hz[q + 32] * (1 - fx) * fy + hz[q + 33] * fx * fy) * I;\n      const j = 3 * min(RAMP - 1, round((w / RMAX) * (RAMP - 1))), keep = max(0, 1 - 2 * w);\n      buf[p * 3] = ar * keep + T[j];\n      buf[p * 3 + 1] = ag * keep + T[j + 1];\n      buf[p * 3 + 2] = ab * keep + T[j + 2];\n    }\n  // Dust in the beam.\n  for (const m of shut ? [] : S.motes) {\n    const v = vis(S, m.x, m.y, m.z);\n    if (!v) continue;\n    const t = m.z + ZC, x = floor(CX + (F * m.x) / t), y = floor(CY - (F * (m.y - EYE)) / t);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const a = lightAt(S, m.x, m.y, m.z, 2, 0, 0) * I * (0.5 + 0.5 * sin(S.t * 6 * m.f + m.ph * 9)) * (0.5 + 2 * S.haze), p = (y * W + x) * 3;\n    buf[p] += 255 * a;\n    buf[p + 1] += 170 * a;\n    buf[p + 2] += 90 * a;\n  }\n  for (const f of S.falls) {\n    const t = f.z + ZC, x = floor(CX + (F * f.x) / t), y = floor(CY - (F * (f.y - EYE)) / t);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const p = (y * W + x) * 3, a = min(1, f.a) * (0.6 + 0.4 * sin(S.t * 7 + f.w * 5));\n    buf[p] += 90 * a;\n    buf[p + 1] += 78 * a;\n    buf[p + 2] += 110 * a;\n  }\n  const [ox, oy] = S.shake;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const sx = x - ox, sy = y - oy;\n      if (sx \u003c 0 || sx >= W || sy \u003c 0 || sy >= H) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const p = (sy * W + sx) * 3;\n      display.setPixel(x, y, min(252, round(buf[p] / 4) * 4), min(252, round(buf[p + 1] / 4) * 4), min(252, round(buf[p + 2] / 4) * 4));\n    }\n}\n","de-bruijn-sequence":"// ===== Patternflow pattern =====\n// Title:   de Bruijn Sequence\n// Family:  rhythm\n// Idea:    A binary de Bruijn sequence plays as a rhythm, a hit for each 1 and a rest for each 0, and each beat its window of the last k bits lights the one tile of a board of all 2^k words that it spells, so the board fills exactly once a cycle while the jumps from tile to tile trace a Hamiltonian cycle and the same words light one by one as the threads of the order k-1 de Bruijn graph below the tape.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: de Bruijn sequence (Nicolaas Govert de Bruijn, 1946)\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rule=0..2, Zoom=0..3\n//\n// Knob 1: Hue. Each word takes its colour from when it comes in the cycle, a sweep of three tenths of the wheel from the first word to the last: cyan through blue to violet at 0, violet to magenta and red at 0.25, red through yellow to green at 0.5, lime to cyan at 0.75.\n// Knob 2: Speed. Three bits a second for each unit: 6 at the opening 2, so the 64 words of order 6 take 10.7 s; 0.6 a second at 0.2 and 9 at 3.\n// Knob 3: Rule. Which sequence plays. At 0 a new one every cycle, drawn uniformly from all 67,108,864 of order 6 (2,048 of order 5, 16 of order 4, 2 of order 3): a random spanning tree of the order k-1 graph by Wilson's loop-erased walks, then the Eulerian circuit that leaves each vertex by its tree edge last (the BEST theorem). At 1 Martin's prefer-one rule (1934), the same every cycle, which runs down the right column and along the bottom row early on. At 2 a maximal shift register, x^k + x + 1 (x^5 + x^2 + 1 at order 5), which never makes the all-zero word: its 2^k - 1 beats, 63 at order 6, leave the top left tile dark and the first slot of the tape empty.\n// Knob 4: Zoom. The order k, 6 minus the knob rounded: 6 at 0 is 64 words on 8 by 8 tiles 8 LEDs apart, with 1 LED a bit on the tape; 5 at 1 gives 32 tiles 8 by 16; 4 at 2 gives 16 tiles of 16 by 16; 3 at 3 gives 8 tall tiles, and there Martin's rule plays 01110100, the light and heavy syllables of ya mā tā rā ja bhā na sa, the Sanskrit prosody mnemonic yamātārājabhānasalagāḥ.\n// Buttons: K1 tap ends the cycle now: the board flashes and fades and a new sequence starts from the all-zero word.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hsv = (h, s, v, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + (h - floor(h)) * 6) % 6;\n  o[c] = 255 * v * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\n// The board fills the top 64 rows; the tape and the loom share the rest.\nconst BY = 0, BH = 64, TY = 68, TH = 6, LY0 = 82, LY1 = 125;\n\n// A uniformly random binary de Bruijn sequence of order k, by the BEST\n// theorem: a random spanning arborescence of the order k-1 graph into the\n// all-zero vertex (Wilson's loop-erased walks), then the Eulerian circuit\n// that leaves every other vertex by its tree edge last.\nfunction randomSeq(k) {\n  const M = 1 \u003c\u003c (k - 1), m = M - 1, inT = new Uint8Array(M), nb = new Uint8Array(M);\n  inT[0] = 1;\n  for (let v = 1; v \u003c M; v++) {\n    let u = v;\n    while (!inT[u]) (nb[u] = Math.random() \u003c 0.5 ? 0 : 1), (u = ((u \u003c\u003c 1) | nb[u]) & m);\n    for (u = v; !inT[u]; u = ((u \u003c\u003c 1) | nb[u]) & m) inT[u] = 1;\n  }\n  const used = new Uint8Array(M), s = new Uint8Array(2 * M);\n  for (let i = 0, v = 0; i \u003c 2 * M; i++) {\n    const b = v === 0 ? used[v] : used[v] ? nb[v] : 1 - nb[v];\n    used[v]++;\n    s[i] = b;\n    v = ((v \u003c\u003c 1) | b) & m;\n  }\n  return s;\n}\n// Martin's rule (1934): from k zeros, append a 1 whenever the new word is\n// new, else a 0.\nfunction martin(k) {\n  const L = 1 \u003c\u003c k, mask = L - 1, seen = new Uint8Array(L), s = new Uint8Array(L);\n  seen[0] = 1;\n  for (let i = 1, w = 0; i \u003c L; i++) {\n    const b = seen[((w \u003c\u003c 1) | 1) & mask] ? 0 : 1;\n    w = ((w \u003c\u003c 1) | b) & mask;\n    seen[w] = 1;\n    s[i] = b;\n  }\n  return s;\n}\n// A maximal-length shift register, x^k + x^a + 1: every word but the\n// all-zero one, so slot 0 of the tape stays empty.\nconst TAP = [0, 0, 0, 1, 1, 2, 1];\nfunction lfsr(k) {\n  const L = 1 \u003c\u003c k, s = new Uint8Array(L), r = new Uint8Array(L + k);\n  r[k - 1] = 1;\n  for (let i = k; i \u003c L + k; i++) r[i] = r[i - k] ^ r[i - k + TAP[k]];\n  // Turn it so the run of k-1 zeros comes last; the missing zero is slot 0.\n  let z = 0;\n  for (let i = 0; i \u003c L - 1; i++) {\n    let ok = r[i] === 1;\n    for (let j = 1; j \u003c k && ok; j++) ok = r[(i - j + L - 1) % (L - 1)] === 0;\n    if (ok) z = i;\n  }\n  for (let i = 1; i \u003c L; i++) s[i] = r[(z + i - 1) % (L - 1)];\n  return s;\n}\n\nexport function setup(params) {\n  params.s = {\n    pos: 0, k: 0, rule: -1, hue: 0, start: 0, seq: null, word: null, old: null, oldAge: 9,\n    buf: new Float32Array(N * 3), c: [0, 0, 0],\n  };\n}\n\nfunction newCycle(S) {\n  const k = S.k;\n  S.seq = S.rule === 0 ? randomSeq(k) : S.rule === 1 ? martin(k) : lfsr(k);\n  const L = 1 \u003c\u003c k, w = new Int16Array(L);\n  for (let i = 0; i \u003c L; i++) {\n    let v = 0;\n    for (let j = k - 1; j >= 0; j--) v = (v \u003c\u003c 1) | S.seq[(i - j + L) % L];\n    w[i] = v;\n  }\n  S.word = w;\n  S.start = S.rule === 2 ? 1 : 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kn[0], 0, 1);\n  const rule = round(cl(kn[2], 0, 2)), k = 6 - round(cl(kn[3], 0, 3));\n  if (k !== S.k || rule !== S.rule) {\n    S.k = k;\n    S.rule = rule;\n    newCycle(S);\n    S.pos = S.start;\n    S.old = null;\n  }\n  // Bits a second: three for each unit of Speed.\n  const L = 1 \u003c\u003c S.k, rate = 3 * cl(kn[1], 0.2, 3);\n  S.pos += d * rate;\n  if (input.btnPressed && input.btnPressed[0]) S.pos = L;\n  if (S.pos >= L) {\n    // The cycle is complete: keep the full board to fade, draw the next.\n    S.old = { word: S.word, start: S.start };\n    S.oldAge = 0;\n    newCycle(S);\n    S.pos = S.start + (S.pos - floor(S.pos));\n  }\n  if (S.old) S.oldAge += d * rate;\n}\n\n// Cell of word w on the board: columns and rows of a 64x64 square.\nfunction cell(k, w) {\n  const cols = 1 \u003c\u003c ((k + 1) >> 1), rows = 1 \u003c\u003c (k >> 1), cw = W / cols, ch = BH / rows;\n  return [(w % cols) * cw, BY + floor(w / cols) * ch, cw, ch];\n}\nfunction add(buf, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += r;\n  buf[o + 1] += g;\n  buf[o + 2] += b;\n}\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0), 1);\n  for (let i = 0; i \u003c= n; i++) add(buf, round(x0 + ((x1 - x0) * i) / n), round(y0 + ((y1 - y0) * i) / n), c[0] * a, c[1] * a, c[2] * a);\n}\nfunction rect(buf, x0, y0, w, h, r, g, b) {\n  for (let y = y0; y \u003c y0 + h; y++) for (let x = x0; x \u003c x0 + w; x++) add(buf, x, y, r, g, b);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.seq) return;\n  const buf = S.buf, k = S.k, L = 1 \u003c\u003c k, M = L >> 1, i = floor(S.pos), f = S.pos - i, c = S.c;\n  buf.fill(0);\n  // Colour of the n-th word of the cycle: a sweep along the wheel.\n  const col = (n, out) => hsv(S.hue + 0.5 + (0.3 * n) / L, 0.7, 1, out);\n  const hit = S.seq[i], beat = exp(-f * 5);\n  const ctr = (w) => {\n    const [x, y, cw, ch] = cell(k, w);\n    return [round(x + cw / 2 - 0.5), round(y + ch / 2 - 0.5)];\n  };\n  // The path so far, under the tiles: it shows only in the gaps.\n  for (let j = S.start + 1; j \u003c= i - 6; j++) {\n    col(j, c);\n    line(buf, ...ctr(S.word[j - 1]), ...ctr(S.word[j]), c, 0.22);\n  }\n  // The board: every word a tile, dim until its turn.\n  const step = new Int16Array(L).fill(-1), ostep = new Int16Array(L).fill(-1), O = S.old, fade = O ? max(0, 1 - S.oldAge / 4) : 0;\n  for (let j = S.start; j \u003c= i; j++) step[S.word[j]] = j;\n  if (fade > 0) for (let j = O.start; j \u003c L; j++) ostep[O.word[j]] = j;\n  for (let w = 0; w \u003c L; w++) {\n    const [x, y, cw, ch] = cell(k, w), j = step[w];\n    if (j \u003c 0) {\n      // Not yet this cycle: the last cycle's full board fading out, after a\n      // flash on the downbeat that completed it.\n      let r = 14, g = 16, b = 22;\n      if (fade > 0 && ostep[w] >= 0) {\n        col(ostep[w], c);\n        const a = 0.5 * fade, e = 160 * max(0, 1 - S.oldAge * 1.5);\n        (r = max(r, c[0] * a + e)), (g = max(g, c[1] * a + e)), (b = max(b, c[2] * a + e));\n      }\n      fill(buf, x + 1, y + 1, cw - 2, ch - 2, r, g, b);\n      continue;\n    }\n    col(j, c);\n    const now = j === i, a = now ? (hit ? 1 : 0.75) : 0.5, g = now ? (hit ? 220 : 70) * beat : 0;\n    fill(buf, x + 1, y + 1, cw - 2, ch - 2, c[0] * a + g, c[1] * a + g, c[2] * a + g);\n    // A hit rings the tile's edge.\n    if (now && hit) {\n      const r = (c[0] * 0.6 + 40) * beat, gg = (c[1] * 0.6 + 40) * beat, bb = (c[2] * 0.6 + 40) * beat;\n      rect(buf, x + 1, y, cw - 2, 1, r, gg, bb);\n      rect(buf, x + 1, y + ch - 1, cw - 2, 1, r, gg, bb);\n      rect(buf, x, y + 1, 1, ch - 2, r, gg, bb);\n      rect(buf, x + cw - 1, y + 1, 1, ch - 2, r, gg, bb);\n    }\n  }\n  // The last jumps on top, fading with age.\n  for (let j = max(S.start + 1, i - 6); j \u003c= i; j++) {\n    col(j, c);\n    line(buf, ...ctr(S.word[j - 1]), ...ctr(S.word[j]), c, 0.22 + 0.7 * exp(-(i - j + f) / 2));\n  }\n  // The tape: the whole cycle, one slot per bit, the window bracketed.\n  const sw = W / L, bw = max(1, floor(sw));\n  for (let j = S.start; j \u003c L; j++) {\n    const played = j \u003c= i, x = floor(j * sw);\n    col(j, c);\n    const a = S.seq[j] ? (played ? 0.95 : 0.3) : played ? 0.1 : 0.04;\n    rect(buf, x, TY, bw, TH, c[0] * a, c[1] * a, c[2] * a);\n  }\n  for (let q = 0; q \u003c k; q++) {\n    const j = (i - q + L) % L, x = floor(j * sw), g = 150 + 100 * beat * hit;\n    rect(buf, x, TY - 2, bw, 1, g, g, g);\n    rect(buf, x, TY + TH + 1, bw, 1, g, g, g);\n    if (q === 0 && hit) rect(buf, x, TY, bw, TH, 160 * beat, 160 * beat, 160 * beat);\n  }\n  // The loom: each word is a thread from its first k-1 bits, along the top,\n  // to its last k-1 bits along the bottom: the order k-1 de Bruijn graph.\n  const nx = (v) => (v + 0.5) * (W / M) - 0.5, th = max(1, round(12 / M));\n  if (fade > 0)\n    for (let j = O.start; j \u003c L; j++) {\n      col(j, c);\n      thread(buf, nx(O.word[j] >> 1), nx(O.word[j] & (M - 1)), c, 0.12 * fade, th);\n    }\n  for (let j = S.start; j \u003c= i; j++) {\n    const w = S.word[j], age = i - j + f;\n    col(j, c);\n    thread(buf, nx(w >> 1), nx(w & (M - 1)), c, j === i ? (hit ? 1 : 0.6) : 0.12 + 0.5 * exp(-age / 2.5), th);\n  }\n  for (let v = 0; v \u003c M; v++) {\n    rect(buf, round(nx(v)), LY0 - 2, 1, 1, 90, 90, 100);\n    rect(buf, round(nx(v)), LY1 + 2, 1, 1, 90, 90, 100);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\nfunction fill(buf, x0, y0, w, h, r, g, b) {\n  for (let y = y0; y \u003c y0 + h; y++)\n    for (let x = x0, o = (y * W + x) * 3; x \u003c x0 + w; x++, o += 3) (buf[o] = r), (buf[o + 1] = g), (buf[o + 2] = b);\n}\n// A thread of the loom: an S from top to bottom, eased at both ends, wider\n// when there are fewer of them.\nfunction thread(buf, x0, x1, c, a, th) {\n  const n = max(LY1 - LY0, abs(x1 - x0) * 2);\n  let px = -1, py = -1;\n  for (let s = 0; s \u003c= n; s++) {\n    const t = s / n, e = t * t * (3 - 2 * t), x = round(x0 + (x1 - x0) * e - (th - 1) / 2), y = round(LY0 + (LY1 - LY0) * t);\n    if (x === px && y === py) continue;\n    for (let q = 0; q \u003c th; q++) add(buf, x + q, y, c[0] * a, c[1] * a, c[2] * a);\n    (px = x), (py = y);\n  }\n}\n","force-chains":"// ===== Patternflow pattern =====\n// Title:   Force Chains\n// Family:  particle\n// Idea:    About 175 soft discs fill a tall box seen in white light between crossed circular polarisers and are squeezed in turn by a piston on top and by the side walls, and only the discs that carry the load light up in isochromatic fringes, grey, white, yellow, orange, red, violet and blue, along branching chains that swing from upright to sideways and find new paths as the push moves, while the discs between them stay dark.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: photoelastic force chains (Pierre Dantu, 1957; Trushant Majmudar and Robert Behringer, 2005), pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Analyser=0..1, Speed=0.2..3, Load=-1..1, Grain=0..1\n//\n// Knob 1: Analyser. Turns the analyser away from crossed, a quarter turn over the range. At 0 the field is dark: an unloaded disc is black and only the loaded ones light up; turning it shifts every fringe along the colour sequence, and at 1 the field is light: unloaded discs shine white and the chains show as dark and coloured bands.\n// Knob 2: Speed. At 2 a round takes 6 s: the piston presses hardest at 0 s while the walls ease off, and at 3 s the walls squeeze hardest while the piston eases to a fifth. In each squeeze one wall pushes three times as hard as the other, the left in one round and the right in the next, so the pile leans one way and then the other and the whole sequence takes 12 s. At 0.2 it is ten times slower, at 3 half as fast again; the discs always move at their own pace.\n// Knob 3: Load. The hardest push of the piston and of the walls, as a multiple of the weight of the pile spread over the floor: 1.5 at -1, 3 at 0 and 6 at 1. At -1 the chains are thin and grey-white with a little yellow; at 1 they thicken and the strongest discs low in the pile run through red and blue into the pale pinks and greens of high orders.\n// Knob 4: Grain. The size of the discs: at 0.06 they are 6.3 and 8.1 LEDs across, 175 of them; at 0.5 8.5 and 11, 95 of them; at 1 12 and 15.6, 48 discs whose fringes show the whole pattern of a disc squeezed at its contacts. A new size pours a new pile.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, PI, pow, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Gravity in LEDs a second squared, physics steps a frame, and the most\n// contacts one disc keeps.\nconst G = 50, SUB = 16, MC = 8;\n// Normal stiffness per unit of the weight pressure on the floor, tangential\n// stiffness as a share of it, the friction coefficient, the share of critical\n// damping a contact gets along its normal and the share of that along its\n// tangent, and the drag every disc feels, per second.\nconst KS = 150, KT = 0.4, MU = 0.5, ZETA = 0.35, TD = 0.2, DRAG = 2.5;\n// One round at Speed 2 in seconds. The piston and the two side walls are\n// heavy plates pushed with set pressures, as shares of the Load: the piston\n// from SY0 to SY1 and the walls from SX0 to SX1 and back. Each wall is NS\n// plates stacked up its height, like a membrane, so the squeeze does not all\n// land on the stiff bottom of the pile. A wall plate stops at WOUT LEDs\n// outside the panel's edge and WIN inside it. One wall pushes 1 + LEAN of\n// the set pressure and the other 1 - LEAN, the left in one round and the\n// right in the next, and the pile leans.\nconst T_R = 6, SY0 = 1, SY1 = 0.2, SX0 = 0.2, SX1 = 1, NS = 8, WOUT = 2, WIN = 3, PD = 30, LEAN = 0.5;\n// White-light fringe colours: retardation in nanometres per LUT step, the\n// steps, and the wavelength the fringe order is counted at.\nconst LS = 3, LN = 1024, L0 = 560;\n// Contact softening: the squared radius in LEDs over which a point load spreads.\nconst A2 = 0.25;\n// Fringes made by the weight pressure on the floor, and the LUT's gamma.\nconst FR = 0.09, GAM = 1.0;\n\n// CIE 1931 colour matching, as the piecewise Gaussian fit of Wyman, Sloan\n// and Shirley (2013).\nconst gp = (l, m, s1, s2) => {\n  const t = (l - m) / (l \u003c m ? s1 : s2);\n  return exp(-0.5 * t * t);\n};\nconst XB = (l) => 1.056 * gp(l, 599.8, 37.9, 31) + 0.362 * gp(l, 442, 16, 26.7) - 0.065 * gp(l, 501.1, 20.4, 26.2);\nconst YB = (l) => 0.821 * gp(l, 568.8, 46.9, 40.5) + 0.286 * gp(l, 530.9, 16.3, 31.1);\nconst ZB = (l) => 1.217 * gp(l, 437, 11.8, 36) + 0.681 * gp(l, 459, 26, 13.8);\n\n// The colour seen through a circular polariscope at each retardation, for an\n// analyser turned beta from crossed: each wavelength passes sin^2(pi R/l + beta).\nfunction buildLut(S, beta) {\n  const lut = S.lut, ws = [];\n  for (let l = 400; l \u003c= 700; l += 10) ws.push(l);\n  let wr = 0, wg = 0, wb = 0;\n  const rgb = (X, Y, Z) => [3.2406 * X - 1.5372 * Y - 0.4986 * Z, -0.9689 * X + 1.8758 * Y + 0.0415 * Z, 0.0557 * X - 0.204 * Y + 1.057 * Z];\n  {\n    let X = 0, Y = 0, Z = 0;\n    for (const l of ws) (X += XB(l)), (Y += YB(l)), (Z += ZB(l));\n    [wr, wg, wb] = rgb(X, Y, Z);\n  }\n  for (let i = 0; i \u003c LN; i++) {\n    const R = i * LS;\n    let X = 0, Y = 0, Z = 0;\n    for (const l of ws) {\n      const s = sin((PI * R) / l + beta), I = s * s;\n      X += I * XB(l);\n      Y += I * YB(l);\n      Z += I * ZB(l);\n    }\n    const c = rgb(X, Y, Z);\n    lut[i * 3] = pow(cl(c[0] / wr, 0, 1), GAM) * 255;\n    lut[i * 3 + 1] = pow(cl(c[1] / wg, 0, 1), GAM) * 255;\n    lut[i * 3 + 2] = pow(cl(c[2] / wb, 0, 1), GAM) * 255;\n  }\n  S.beta = beta;\n}\n\nconst NMAX = 400, WALL = 1000;\nexport function setup(params) {\n  const F = (k) => new Float64Array(NMAX * k);\n  params.s = {\n    u: 0, speed: 2, load: 3, grain: -1, beta: -1, n: 0, rm: 3, gen: 0,\n    x: F(1), y: F(1), vx: F(1), vy: F(1), w: F(1), r: F(1), m: F(1), fx: F(1), fy: F(1), tq: F(1),\n    nb: new Int32Array(NMAX * MC).fill(-1), xi: F(MC), sg: new Int32Array(NMAX * MC),\n    cn: new Uint8Array(NMAX), cux: new Float32Array(NMAX * MC), cuy: new Float32Array(NMAX * MC),\n    cfx: new Float32Array(NMAX * MC), cfy: new Float32Array(NMAX * MC),\n    head: new Int32Array(4096), next: new Int32Array(NMAX),\n    wi: new Float64Array(2 * NS), wv: new Float64Array(2 * NS), wf: new Float64Array(2 * NS), lean: 0, yp: 0, vp: 0, mp: 1, fp: 0, fw: 0,\n    k: 1, c: 0, kt: 1, mg: 1, gw: 1, gh: 1, cs: 8,\n    lut: new Float32Array(LN * 3), buf: new Uint8Array(NP * 3), cc: new Float64Array(MC * 4),\n  };\n}\n\n// Pours a new pile: half small discs and half large ones, 1.3 times wider, so\n// the packing stays disordered. The discs are dropped anywhere in the box at\n// a fifth of their size and grown while overlapping pairs are pushed apart,\n// then the pile settles under gravity and the piston.\nfunction pour(S, grain) {\n  S.grain = grain;\n  const rm = 3.6 * pow(2, grain - 0.06), rs = rm * 0.87, rl = rm * 1.13;\n  S.rm = rm;\n  const bw = W + 2 * WOUT, area = 0.82 * bw * (H + 2), n = min(NMAX, Math.round(area / (PI * (rs * rs + rl * rl) * 0.5)));\n  const top = H - (H * 0.82) / 0.78;\n  S.n = n;\n  let mg = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const r = i & 1 ? rs : rl;\n    S.r[i] = r;\n    S.m[i] = r * r;\n    S.x[i] = -WOUT + r + Math.random() * (bw - 2 * r);\n    S.y[i] = top + r + Math.random() * (H - top - 2 * r);\n    S.vx[i] = S.vy[i] = S.w[i] = 0;\n    mg += r * r * G;\n  }\n  S.nb.fill(-1);\n  S.mg = mg;\n  S.cs = 2 * rl + 0.01;\n  S.gw = floor((W + 8) / S.cs) + 1;\n  S.gh = floor((H + 200) / S.cs) + 1;\n  for (let it = 0; it \u003c 90; it++) grow(S, min(1, 0.2 + it / 50), top);\n  // Stiffness and damping scale with the weight pressure on the floor, so a\n  // contact squeezes the same share of a radius whatever the grain.\n  S.k = (KS * mg) / W;\n  S.kt = KT * S.k;\n  S.c = 2 * ZETA * sqrt(S.k * rm * rm * 0.5);\n  S.mp = (0.15 * mg) / G;\n  let ymin = H;\n  for (let i = 0; i \u003c n; i++) ymin = min(ymin, S.y[i] - S.r[i]);\n  S.yp = ymin;\n  S.vp = 0;\n  S.wi.fill(-WOUT);\n  S.wv.fill(0);\n  press(S, 0);\n  for (let i = 0; i \u003c 50 * SUB; i++) step(S, 1 / 30 / SUB, 8, false);\n}\n\n// One pass of growing: radii at share s of their size, every overlapping\n// pair pushed apart by its overlap, half each, and the walls pushing back.\nfunction grow(S, s, top) {\n  const { n, x, y, r, head, next } = S;\n  const cs = S.cs, gw = S.gw, gh = S.gh, off = 200;\n  head.fill(-1, 0, gw * gh);\n  for (let i = 0; i \u003c n; i++) {\n    const o = cl(floor((y[i] + off) / cs), 0, gh - 1) * gw + cl(floor((x[i] + 4) / cs), 0, gw - 1);\n    next[i] = head[o];\n    head[o] = i;\n  }\n  for (let gy = 0; gy \u003c gh; gy++)\n    for (let gx = 0; gx \u003c gw; gx++)\n      for (let i = head[gy * gw + gx]; i >= 0; i = next[i])\n        for (let dy = 0; dy \u003c= 1; dy++)\n          for (let dx = -1; dx \u003c= 1; dx++) {\n            if (dy === 0 && dx \u003c 0) continue;\n            const hx = gx + dx, hy = gy + dy;\n            if (hx \u003c 0 || hx >= gw || hy >= gh) continue;\n            for (let j = dy === 0 && dx === 0 ? next[i] : head[hy * gw + hx]; j >= 0; j = next[j]) {\n              const ddx = x[j] - x[i], ddy = y[j] - y[i], rr = (r[i] + r[j]) * s, d2 = ddx * ddx + ddy * ddy;\n              if (d2 >= rr * rr) continue;\n              const d = sqrt(d2) || 1e-6, p = (0.5 * (rr - d)) / d;\n              x[i] -= ddx * p;\n              y[i] -= ddy * p;\n              x[j] += ddx * p;\n              y[j] += ddy * p;\n            }\n          }\n  for (let i = 0; i \u003c n; i++) {\n    const ri = r[i] * s;\n    x[i] = cl(x[i], ri - WOUT, W + WOUT - ri);\n    y[i] = cl(y[i], top + ri, H - ri);\n  }\n}\n\n// The slot that holds the tangential spring between disc a and body id, made\n// if there is none and room for one.\nfunction slot(S, a, id) {\n  const nb = S.nb, b0 = a * MC;\n  let free = -1;\n  for (let o = b0; o \u003c b0 + MC; o++) {\n    if (nb[o] === id) return o;\n    if (nb[o] \u003c 0 && free \u003c 0) free = o;\n  }\n  if (free >= 0) (nb[free] = id), (S.xi[free] = 0);\n  return free;\n}\n\n// The tangential force on the second body of a contact that slid vt h along\n// its tangent, from the spring held in slot o: it slips past MU times fn.\nfunction fric(S, o, vt, fn, h, cd) {\n  if (o \u003c 0) return 0;\n  let xi = S.xi[o] + vt * h, ft = -S.kt * xi - TD * cd * vt;\n  const lim = MU * fn;\n  if (ft > lim) (ft = lim), (xi = -lim / S.kt);\n  else if (ft \u003c -lim) (ft = -lim), (xi = lim / S.kt);\n  S.xi[o] = xi;\n  S.sg[o] = S.gen;\n  return ft;\n}\n\n// Keeps a contact for drawing: the direction from the disc's centre to it\n// and the force on the disc there.\nfunction keepC(S, i, ux, uy, fx, fy) {\n  if (S.cn[i] >= MC) return;\n  const o = i * MC + S.cn[i]++;\n  S.cux[o] = ux;\n  S.cuy[o] = uy;\n  S.cfx[o] = fx;\n  S.cfy[o] = fy;\n}\n\n// One physics step of h seconds, after Cundall and Strack: touching discs\n// push apart with a spring and a damper along the line between them and hold\n// each other with a tangential spring that slips past Coulomb friction. The\n// walls and the floor do the same. The piston is a heavy lid pushed down\n// with force S.fp, and each wall plate is pushed in with S.fw.\nfunction step(S, h, drag, keep) {\n  const { n, x, y, vx, vy, w, r, m, fx, fy, tq, head, next, nb, sg, k, c } = S;\n  const cs = S.cs, gw = S.gw, gh = S.gh, off = 200, gen = ++S.gen, cd0 = c / (S.rm * 0.7071);\n  head.fill(-1, 0, gw * gh);\n  for (let i = 0; i \u003c n; i++) {\n    fx[i] = 0;\n    fy[i] = m[i] * G;\n    tq[i] = 0;\n    const o = cl(floor((y[i] + off) / cs), 0, gh - 1) * gw + cl(floor((x[i] + 4) / cs), 0, gw - 1);\n    next[i] = head[o];\n    head[o] = i;\n  }\n  if (keep) S.cn.fill(0);\n  for (let gy = 0; gy \u003c gh; gy++)\n    for (let gx = 0; gx \u003c gw; gx++)\n      for (let i = head[gy * gw + gx]; i >= 0; i = next[i])\n        for (let dy = 0; dy \u003c= 1; dy++)\n          for (let dx = -1; dx \u003c= 1; dx++) {\n            if (dy === 0 && dx \u003c 0) continue;\n            const hx = gx + dx, hy = gy + dy;\n            if (hx \u003c 0 || hx >= gw || hy >= gh) continue;\n            for (let j = dy === 0 && dx === 0 ? next[i] : head[hy * gw + hx]; j >= 0; j = next[j]) {\n              const a = i \u003c j ? i : j, b = i \u003c j ? j : i;\n              const ddx = x[b] - x[a], ddy = y[b] - y[a], rr = r[a] + r[b], d2 = ddx * ddx + ddy * ddy;\n              if (d2 >= rr * rr) continue;\n              const d = sqrt(d2) || 1e-6, nx = ddx / d, ny = ddy / d, ov = rr - d;\n              const rvx = vx[b] - vx[a], rvy = vy[b] - vy[a], vn = rvx * nx + rvy * ny;\n              const vt = -rvx * ny + rvy * nx - w[b] * r[b] - w[a] * r[a];\n              const cd = cd0 * sqrt((m[a] * m[b]) / (m[a] + m[b]));\n              const fs = k * ov, fn = max(0, fs - cd * vn), ft = fric(S, slot(S, a, b), vt, fn, h, cd);\n              const Fx = fn * nx - ft * ny, Fy = fn * ny + ft * nx;\n              fx[b] += Fx;\n              fy[b] += Fy;\n              fx[a] -= Fx;\n              fy[a] -= Fy;\n              tq[a] -= r[a] * ft;\n              tq[b] -= r[b] * ft;\n              if (keep) {\n                const Kx = fs * nx - ft * ny, Ky = fs * ny + ft * nx;\n                keepC(S, a, nx, ny, -Kx, -Ky);\n                keepC(S, b, -nx, -ny, Kx, Ky);\n              }\n            }\n          }\n  // Walls: m is the direction from the disc to the wall, the wall moves at\n  // (wx, wy).\n  let up = 0;\n  const yp = S.yp, wi = S.wi, wv = S.wv, wf = S.wf;\n  wf.fill(0);\n  const wall = (i, id, ov, mx, my, wx, wy) => {\n    const ri = r[i], cd = cd0 * sqrt(m[i]), rvx = vx[i] - wx, rvy = vy[i] - wy;\n    const vn = rvx * mx + rvy * my, vt = -rvx * my + rvy * mx + w[i] * ri;\n    const fs = k * ov, fn = max(0, fs + cd * vn), ft = fric(S, slot(S, i, id), vt, fn, h, cd);\n    fx[i] += -fn * mx - ft * my;\n    fy[i] += -fn * my + ft * mx;\n    tq[i] += ri * ft;\n    if (keep) keepC(S, i, mx, my, -fs * mx - ft * my, -fs * my + ft * mx);\n    return fn;\n  };\n  for (let i = 0; i \u003c n; i++) {\n    const ri = r[i];\n    const sl = cl(floor((y[i] * NS) / H), 0, NS - 1), sr = sl + NS;\n    let ov = ri - (x[i] - wi[sl]);\n    if (ov > 0) wf[sl] += wall(i, WALL, ov, -1, 0, wv[sl], 0);\n    ov = ri - (W - wi[sr] - x[i]);\n    if (ov > 0) wf[sr] += wall(i, WALL + 1, ov, 1, 0, -wv[sr], 0);\n    ov = ri - (H - y[i]);\n    if (ov > 0) wall(i, WALL + 2, ov, 0, 1, 0, 0);\n    ov = ri - (y[i] - yp);\n    if (ov > 0) up += wall(i, WALL + 3, ov, 0, -1, 0, S.vp);\n  }\n  // Springs whose contact broke this step are let go.\n  for (let o = 0, e = n * MC; o \u003c e; o++) if (nb[o] >= 0 && sg[o] !== gen) nb[o] = -1;\n  const dmp = 1 - drag * h;\n  for (let i = 0; i \u003c n; i++) {\n    vx[i] = (vx[i] + (fx[i] / m[i]) * h) * dmp;\n    vy[i] = (vy[i] + (fy[i] / m[i]) * h) * dmp;\n    w[i] = (w[i] + ((2 * tq[i]) / (m[i] * r[i] * r[i])) * h) * dmp;\n    x[i] += vx[i] * h;\n    y[i] += vy[i] * h;\n  }\n  const pd = 1 - PD * h;\n  S.vp = (S.vp + ((S.fp - up) / S.mp) * h) * pd;\n  S.yp += S.vp * h;\n  // The wall plates move inward at wv and halt at their stops. The top plate\n  // also holds the pile above the panel's top edge.\n  const mw = S.mp / NS;\n  for (let k = 0; k \u003c 2 * NS; k++) {\n    const f = S.fw * (k \u003c NS ? 1 + S.lean : 1 - S.lean) * (k % NS ? 1 : 1 - (yp * NS) / H);\n    wv[k] = (wv[k] + ((f - wf[k]) / mw) * h) * pd;\n    wi[k] += wv[k] * h;\n    if (wi[k] \u003c -WOUT) (wi[k] = -WOUT), (wv[k] = max(0, wv[k]));\n    if (wi[k] > WIN) (wi[k] = WIN), (wv[k] = min(0, wv[k]));\n  }\n}\n\n// The pushes at point q of the round, 0 with the piston pressing hardest and\n// 1 with the walls pressing hardest. A pressure of 1 is the weight of the\n// pile spread over the floor.\nfunction press(S, q) {\n  const p = (S.load * S.mg) / W;\n  S.fp = p * (SY0 + (SY1 - SY0) * q) * (W - S.wi[0] - S.wi[NS]);\n  S.fw = (p * (SX0 + (SX1 - SX0) * q) * H) / NS;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  const beta = cl(kv[0], 0, 1) * PI * 0.5;\n  if (abs(beta - S.beta) > 0.004) buildLut(S, beta);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.load = 3 * pow(2, cl(kv[2], -1, 1));\n  const grain = cl(kv[3], 0, 1);\n  if (S.grain \u003c 0 || abs(grain - S.grain) > 0.03) pour(S, grain), (S.u = 0);\n  const h = 1 / 30 / SUB, steps = max(1, Math.round(d * 30 * SUB)), du = (d * S.speed) / 2 / steps;\n  for (let i = 0; i \u003c steps; i++) {\n    S.u = (S.u + du) % (2 * T_R);\n    // The round: the piston pressing hard with the walls easing off, then the\n    // walls squeezing while the piston eases, and back. The lean turns over\n    // once every two rounds.\n    press(S, 0.5 - 0.5 * cos((2 * PI * S.u) / T_R));\n    S.lean = LEAN * sin((PI * S.u) / T_R);\n    step(S, h, DRAG, i === steps - 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { n, x, y, r, cn, cux, cuy, cfx, cfy, lut, buf, cc } = S;\n  buf.fill(0);\n  // LUT steps per unit of stress: the weight pressure on the floor makes FR\n  // of a fringe.\n  const ks = (L0 * W * FR) / (S.mg * LS);\n  for (let i = 0; i \u003c n; i++) {\n    const R = r[i], cx = x[i], cy = y[i], nc = cn[i], R2 = R * R, Ri = (R - 0.7) * (R - 0.7);\n    for (let k = 0; k \u003c nc; k++) {\n      const o = i * MC + k;\n      cc[k * 4] = R * cux[o];\n      cc[k * 4 + 1] = R * cuy[o];\n      cc[k * 4 + 2] = cfx[o];\n      cc[k * 4 + 3] = cfy[o];\n    }\n    const x0 = max(0, floor(cx - R)), x1 = min(W - 1, floor(cx + R)), y0 = max(0, floor(cy - R)), y1 = min(H - 1, floor(cy + R));\n    for (let py = y0; py \u003c= y1; py++)\n      for (let px = x0; px \u003c= x1; px++) {\n        const ex0 = px + 0.5 - cx, ey0 = py + 0.5 - cy, q = ex0 * ex0 + ey0 * ey0;\n        if (q >= R2) continue;\n        let cr = 0, cg = 0, cb = 0;\n        for (let sub = 0; sub \u003c 4; sub++) {\n          const ex = ex0 + (sub & 1 ? 0.25 : -0.25), ey = ey0 + (sub & 2 ? 0.25 : -0.25);\n          let sxx = 0, syy = 0, sxy = 0;\n          for (let k = 0; k \u003c nc * 4; k += 4) {\n            const dx = ex - cc[k], dy = ey - cc[k + 1];\n            const r2 = dx * dx + dy * dy + A2, wgt = (cc[k + 2] * dx + cc[k + 3] * dy) / (r2 * r2);\n            sxx += wgt * dx * dx;\n            syy += wgt * dy * dy;\n            sxy += wgt * dx * dy;\n          }\n          const a = sxx - syy, ds = sqrt(a * a + 4 * sxy * sxy) * (2 / PI);\n          const li = min(LN - 1, (ds * ks) | 0) * 3;\n          cr += lut[li];\n          cg += lut[li + 1];\n          cb += lut[li + 2];\n        }\n        // Four samples a LED, and the rim darkened where the disc's edge bends\n        // the light away.\n        const f = (q > Ri ? 0.45 : 1) * 0.25, o = (py * W + px) * 3;\n        buf[o] = cr * f;\n        buf[o + 1] = cg * f;\n        buf[o + 2] = cb * f;\n      }\n  }\n  for (let p = 0, yy = 0; yy \u003c H; yy++)\n    for (let xx = 0; xx \u003c W; xx++, p += 3) display.setPixel(xx, yy, buf[p], buf[p + 1], buf[p + 2]);\n}\n","gaussian-free-field":"// ===== Patternflow pattern =====\n// Title:   Gaussian Free Field\n// Family:  noise\n// Idea:    The discrete Gaussian free field on the panel's 64 by 128 lattice, an amber land above zero and a dark violet sea below, its zero level lines drawn as white coastlines that close into nested loops, while every sine mode of the field wanders on its own and the whole map redraws itself within a second or two; with the boundary knob up, one white line climbs all 128 rows, the SLE(4) curve.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: discrete Gaussian free field, whose contour lines converge to SLE(4) (Oded Schramm and Scott Sheffield, 2009), pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Boundary=0..1, Grain=0..1\n//\n// Knob 1: Hue. The colour of the land. At 0 it rises from orange through amber to gold, a step at every height of 0.63 (the height gap, see Boundary); at 0.25 green, at 0.5 sky blue, at 0.75 pink, and back to orange at 1. The sea stays violet, leaning bluer or redder, and the coastlines stay white.\n// Knob 2: Speed. Each of the 8,192 sine modes wanders as its own Ornstein-Uhlenbeck process, smoothed in time, so at every instant the field has the free field's law. At 2 the largest mode forgets itself in 0.7 s and the finest, two LEDs from crest to crest, in 0.14 s; at 0.2 ten times slower, at 3 one and a half times faster.\n// Knob 3: Boundary. What lies outside the frame. At 0 the field is zero all round, and the coastlines are closed loops, nested, which tend to CLE(4). Turned up, the frame is held at +h on its left half and -h on its right, up to h = sqrt(pi/8) = 0.63 at 1: then exactly one coastline runs from the middle of the bottom edge to the middle of the top, the chordal SLE(4), and from 0.33 on it is drawn two LEDs wide while the other coastlines dim to pale amber.\n// Knob 4: Grain. The width of the Gaussian blur under the coastlines and bands, from 1.4 LEDs at 0 to 5 at 1, where the land breaks into a few smooth blobs; it opens at 1.6. The shading always shows the lattice field itself, lit from the upper left.\n\nconst W = 64, H = 128, N = W * H, HW = W / 2, HH = H / 2;\nconst { floor, min, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The height gap: with -LAM on one boundary arc and +LAM on the other the\n// zero line between them is SLE(4), for a field whose covariance is the\n// inverse of the lattice Laplacian.\nconst LAM = sqrt(PI / 8);\n\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// Sine modes, orthonormal: SX[j * W + x] is mode j at column x and, the\n// matrix being symmetric, also mode x at column j. LA is the eigenvalue of\n// minus the lattice Laplacian for mode (j, k), stored at j * H + k.\nconst SX = new Float64Array(W * W), SY = new Float64Array(H * H), LA = new Float64Array(N);\nfor (let j = 0; j \u003c W; j++) for (let x = 0; x \u003c W; x++) SX[j * W + x] = sqrt(2 / (W + 1)) * sin((PI * (j + 1) * (x + 1)) / (W + 1));\nfor (let k = 0; k \u003c H; k++) for (let y = 0; y \u003c H; y++) SY[k * H + y] = sqrt(2 / (H + 1)) * sin((PI * (k + 1) * (y + 1)) / (H + 1));\nfor (let j = 0; j \u003c W; j++) for (let k = 0; k \u003c H; k++) LA[j * H + k] = 4 - 2 * cos((PI * (j + 1)) / (W + 1)) - 2 * cos((PI * (k + 1)) / (H + 1));\nconst LMIN = LA[0];\n// The field is drawn with a blur of a third of an LED, which leaves the lattice\n// as it is: AMP is each mode's standard deviation, 1 / sqrt(l), times the\n// square root of 1.5 that the filter in update takes away. TAU is each\n// mode's relaxation time as a share of the largest mode's.\nconst C0 = 0.05, AMP = new Float64Array(N), TAU = new Float64Array(N);\nfor (let i = 0; i \u003c N; i++) {\n  AMP[i] = (sqrt(1.5) * exp(-C0 * LA[i])) / sqrt(LA[i]);\n  TAU[i] = (LMIN / LA[i]) ** 0.2;\n}\n\n// Normal deviates from a table of 4096 quantiles of the unit normal, read\n// off its distribution function summed in steps of a thousandth and scaled\n// to unit variance: one draw of Math.random each.\nconst GT = new Float64Array(4096);\n{\n  let c = 0, i = 0, v = 0;\n  for (let z = -6; z \u003c 6 && i \u003c 4096; z += 0.001) {\n    const c2 = c + (exp(-((z + 0.0005) ** 2) / 2) * 0.001) / sqrt(2 * PI);\n    while (i \u003c 4096 && (i + 0.5) / 4096 \u003c= c2) GT[i++] = z + (0.001 * ((i + 0.5) / 4096 - c)) / (c2 - c);\n    c = c2;\n  }\n  for (i = 0; i \u003c 4096; i++) v += GT[i] * GT[i];\n  v = sqrt(v / 4096);\n  for (i = 0; i \u003c 4096; i++) GT[i] /= v;\n}\nconst gauss = () => GT[(Math.random() * 4096) | 0];\n\n// Modes B (j, k at B[j * H + k]) to the field F[y * W + x], one axis at a\n// time. Mode k is even or odd about the middle row as k + 1 is odd or even,\n// so each sum serves a row and its mirror; the same for columns.\nfunction synth(B, T, F) {\n  for (let j = 0; j \u003c W; j++) {\n    const b = j * H;\n    for (let y = 0; y \u003c HH; y++) {\n      const r = y * H;\n      let e = 0, o = 0;\n      for (let k = 0; k \u003c H; k += 2) {\n        e += B[b + k] * SY[r + k];\n        o += B[b + k + 1] * SY[r + k + 1];\n      }\n      T[y * W + j] = e + o;\n      T[(H - 1 - y) * W + j] = e - o;\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const t = y * W;\n    for (let x = 0; x \u003c HW; x++) {\n      const r = x * W;\n      let e = 0, o = 0;\n      for (let j = 0; j \u003c W; j += 2) {\n        e += SX[r + j] * T[t + j];\n        o += SX[r + j + 1] * T[t + j + 1];\n      }\n      F[t + x] = e + o;\n      F[t + W - 1 - x] = e - o;\n    }\n  }\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: 0, speed: 2, bnd: 0, grain: 0.06, qd: -1,\n    z: new Float64Array(N), a: new Float64Array(N), Q: new Float64Array(N), R: new Float64Array(N), Z: new Float64Array(N),\n    B: new Float64Array(N), T: new Float64Array(N), F: new Float64Array(N), U: new Float64Array(N), G: new Float64Array(N), V: new Float64Array(N),\n    K: new Float64Array(24), P: new Float64Array(H + 40), side: new Int8Array(N), stack: new Int32Array(N), chord: new Uint8Array(N), c: [0, 0, 0],\n  });\n  for (let i = 0; i \u003c N; i++) S.z[i] = S.a[i] = gauss();\n  // The harmonic part for the Dobrushin boundary: +1 outside the left half\n  // of the frame and -1 outside the right half. Minus its Laplacian inside\n  // is what the edge LEDs see beyond the frame, so it is that source divided\n  // by each mode's eigenvalue. The sine matrices are symmetric, so synth run\n  // on the source laid out by column gives its modes laid out by row.\n  const f = S.B, m = S.F;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      if (x === 0) s += 1;\n      if (x === W - 1) s -= 1;\n      if (y === 0 || y === H - 1) s += x \u003c HW ? 1 : -1;\n      f[x * H + y] = s;\n    }\n  synth(f, S.T, m);\n  for (let j = 0; j \u003c W; j++) for (let k = 0; k \u003c H; k++) f[j * H + k] = m[k * W + j] / LA[j * H + k];\n  synth(f, S.T, S.U);\n}\n\n// The pixels joined to the left arc through LEDs above zero (side 1), and\n// those joined to the right arc through the rest (side 2): the zero line\n// between the two is the chordal one, from the middle of the bottom edge to\n// the middle of the top.\nfunction sides(S) {\n  const V = S.V, sd = S.side, st = S.stack;\n  sd.fill(0);\n  let n = 0;\n  const seed = (p, s) => {\n    if (!sd[p] && (s === 2 || V[p] > 0)) (sd[p] = s), (st[n++] = p);\n  };\n  const fill = (s) => {\n    while (n) {\n      const p = st[--n], x = p % W;\n      if (x > 0) seed(p - 1, s);\n      if (x \u003c W - 1) seed(p + 1, s);\n      if (p >= W) seed(p - W, s);\n      if (p \u003c N - W) seed(p + W, s);\n    }\n  };\n  for (let y = 0; y \u003c H; y++) seed(y * W, 1);\n  for (let x = 0; x \u003c HW; x++) seed(x, 1), seed(N - W + x, 1);\n  fill(1);\n  for (let y = 0; y \u003c H; y++) seed(y * W + W - 1, 2);\n  for (let x = HW; x \u003c W; x++) seed(x, 2), seed(N - W + x, 2);\n  fill(2);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.bnd = cl(k[2], 0, 1);\n  S.grain = cl(k[3], 0, 1);\n  // Each mode is an Ornstein-Uhlenbeck process seen through an exponential\n  // filter of half its time constant, which smooths its path in time; the\n  // filter takes its variance to 1 / 1.5, which AMP gives back, so at every\n  // instant the modes are independent normals and the field is the free\n  // field. The largest mode forgets itself in about 0.7 s at Speed 2.\n  const z = S.z, a = S.a, B = S.B, Q = S.Q, R = S.R, Z = S.Z;\n  const qd = (d * S.speed) / (0.7 * 2);\n  if (qd !== S.qd) {\n    S.qd = qd;\n    for (let i = 0; i \u003c N; i++) {\n      const q = exp(-qd / TAU[i]);\n      Q[i] = q;\n      Z[i] = sqrt(1 - q * q);\n      R[i] = q * q;\n    }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    z[i] = z[i] * Q[i] + Z[i] * gauss();\n    a[i] = a[i] * R[i] + z[i] * (1 - R[i]);\n    B[i] = a[i] * AMP[i];\n  }\n  synth(B, S.T, S.F);\n  // The field the level lines are drawn on: the same field blurred by a\n  // Gaussian of Grain's width, zero outside the panel as the boundary is.\n  const sg = 1.4 + 3.6 * S.grain, rad = min(20, Math.ceil(2.5 * sg)), K = S.K;\n  let ks = 0;\n  for (let i = 0; i \u003c= rad; i++) ks += (K[i] = exp((-i * i) / (2 * sg * sg))) * (i ? 2 : 1);\n  for (let i = 0; i \u003c= rad; i++) K[i] /= ks;\n  const F = S.F, G = S.G, V = S.V, U = S.U, P = S.P, g = S.bnd * LAM;\n  // Rows, then columns, each copied into a strip with 20 zeros either side.\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) P[20 + x] = F[y * W + x];\n    for (let x = 0; x \u003c W; x++) {\n      const c = 20 + x;\n      let s = K[0] * P[c];\n      for (let i = 1; i \u003c= rad; i++) s += K[i] * (P[c - i] + P[c + i]);\n      G[y * W + x] = s;\n    }\n  }\n  for (let x = 0; x \u003c W; x++) {\n    for (let y = 0; y \u003c H; y++) P[20 + y] = G[y * W + x];\n    for (let y = 0; y \u003c H; y++) {\n      const c = 20 + y, p = y * W + x;\n      let s = K[0] * P[c];\n      for (let i = 1; i \u003c= rad; i++) s += K[i] * (P[c - i] + P[c + i]);\n      V[p] = (s + g * U[p]) / LAM;\n    }\n  }\n  if (S.bnd > 0) sides(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const V = S.V, F = S.F, sd = S.side, c = S.c, hp = 0.07 + S.hue, hn = 0.7 + 0.06 * sin(2 * PI * S.hue);\n  const ch = S.bnd > 0 ? min(1, 3 * S.bnd) : 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, v = V[p], L = Math.round(v), e = v - L, ae = abs(e);\n      // On a level line: a neighbour lies across the nearest level and is no\n      // nearer to it. The chord is drawn two LEDs wide, on both sides.\n      let z = 0, q, n = -1;\n      if (x > 0 && ((q = V[p - 1] - L), q * e \u003c 0) && abs(q) >= ae) n = p - 1;\n      else if (x \u003c W - 1 && ((q = V[p + 1] - L), q * e \u003c 0) && abs(q) >= ae) n = p + 1;\n      else if (y > 0 && ((q = V[p - W] - L), q * e \u003c 0) && abs(q) >= ae) n = p - W;\n      else if (y \u003c H - 1 && ((q = V[p + W] - L), q * e \u003c 0) && abs(q) >= ae) n = p + W;\n      if (n >= 0) z = L === 0 ? 2 : 1;\n      if (ch) {\n        const o = 3 - sd[p];\n        if (o \u003c 3 && ((x > 0 && sd[p - 1] === o) || (x \u003c W - 1 && sd[p + 1] === o) || (y > 0 && sd[p - W] === o) || (y \u003c H - 1 && sd[p + W] === o))) z = 3;\n      }\n      // Relief: the fine field lit from the upper left.\n      const u = ((x > 0 ? F[p - 1] : 0) - (x \u003c W - 1 ? F[p + 1] : 0) + (y > 0 ? F[p - W] : 0) - (y \u003c H - 1 ? F[p + W] : 0)) * 0.8, sh = (0.35 * u) / (1 + abs(u));\n      const t = 1 - exp(-abs(v) / 1.5);\n      if (z === 3) hsv(hp + 0.1 + 0.03 * sh, 0.04 + 0.1 * abs(sh), 1, c);\n      else if (z === 2) hsv(hp + 0.05 + 0.04 * sh, 0.05 + 0.12 * abs(sh) + 0.35 * ch, 1 - 0.35 * ch, c);\n      else if (v > 0) {\n        // Above zero the brightest channel stays at full. Each band of\n        // height LAM steps the hue from amber toward gold and pales it; the\n        // relief turns hue and saturation a little inside the band.\n        const b = min(L - (e \u003c 0 ? 1 : 0), 3);\n        hsv(hp + 0.04 * b + 0.02 * (v - b) + 0.05 * sh - (z ? 0.025 : 0), 0.8 - 0.1 * b + 0.5 * sh, z ? 0.86 + 0.3 * sh : 1, c);\n      } else hsv(hn + 0.08 * t + 0.12 * sh, 0.85 - 0.3 * t, z ? 0.3 * (1 + sh) : (0.16 - 0.04 * t) * (1 + 1.8 * sh), c);\n      display.setPixel(x, y, min(255, c[0]) | 0, min(255, c[1]) | 0, min(255, c[2]) | 0);\n    }\n}\n","lost-head":"// ===== Patternflow pattern =====\n// Title:   Lost Head\n// Family:  halloween\n// Idea:    A headless skeleton scuttles along moonlit tombstones trying on the skulls that sit on them and puts each wrong one back with a shrug, until the right one clicks on and its sockets light toxic green; it dances a jig, then the head falls off and rolls away.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52, built on Skull Swap, pattern round 50\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tries=1..5, Size=0..1\n//\n// Knob 1: Hue. The night sky and the shaded side of the bones, round the cold side of the wheel from violet at 0 to teal at 1. The moon and the halo stay.\n// Knob 2: Speed. One beat a second for each unit. At the opening 2 the big skull is on the neck at 0.9 s and the right one clicks on at 7 s, after a 2 s walk; it rolls away at 10.8 s. Ten times slower at 0.2.\n// Knob 3: Tries. Wrong skulls before the right one, 1 to 5, in turn from too small, witch's hat, biter, pumpkin, too big. The first round ends on the big one, so at 1 it opens on the big one and at 5 on the small one.\n// Knob 4: Size. How wrong the wrong sizes are: the big skull is 1.1 times the right one at 0 and twice it at 1, sliding down over the hips; the small one goes from 0.8 to 0.4.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, acos, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\n// Up from a over ra beats, down from c over rc.\nconst win = (b, a, ra, c, rc) => ease((b - a) / ra) * (1 - ease((b - c) / rc));\nconst blend = (D, o, w) => Object.keys(o).forEach((key) => (D[key] = mix(D[key], o[key], w)));\nconst hsv = (h, s, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + h * 6) % 6;\n  o[c] = 255 * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\n// --- Skull Swap's bones, as distances in their own frames, y down.\nconst seg = (x, y, ax, ay, bx, by) => {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return sqrt((x - ax - dx * t) ** 2 + (y - ay - dy * t) ** 2);\n};\nconst ell = (x, y, cx, cy, rx, ry) => (sqrt(((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2) - 1) * min(rx, ry);\nconst box = (x, y, cx, cy, hx, hy, r) => {\n  const qx = abs(x - cx) - hx + r, qy = abs(y - cy) - hy + r;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n};\nfunction long(x, y, L, w, r) {\n  const e = L / 2 - r, q = 0.6 * r, ry = r * 0.9;\n  return min(seg(x, y, 0, -e, 0, e) - w, ell(x, y, -q, -e, r, ry), ell(x, y, q, -e, r, ry), ell(x, y, -q, e, r, ry), ell(x, y, q, e, r, ry));\n}\n// 0 long bone, 1 paired bones, 2 cage, 3 lumbar, 4 pelvis, 5 skull, 6 jaw,\n// 7 hand, 8 foot, 9 hat.\nconst RIBS = [[6.4, 2.4], [7.9, 6.6], [8.8, 10.8], [8.8, 15], [7.8, 19]];\nfunction shape(k, x, y, sg) {\n  switch (k) {\n    case 0:\n      return long(x, y, sg, 0.95 + 0.015 * sg, 1.5);\n    case 1: {\n      const e = sg / 2 - 1.1;\n      return min(seg(x, y, -1, -e, -1, e) - 0.8, seg(x, y, 1.1, -e, 1.1, e) - 0.6, box(x, y, 0, -e - 0.2, 2.3, 1.1, 1), box(x, y, 0, e + 0.2, 2.1, 1.1, 1));\n    }\n    case 2: {\n      let d = min(box(x, y, 0, -3.4, 1.5, 0.75, 0.5), box(x, y, 0, -1.4, 1.6, 0.75, 0.5));\n      d = min(d, seg(x, y, -1.4, 0.8, -9.6, -0.2) - 0.8, seg(x, y, 1.4, 0.8, 9.6, -0.2) - 0.8, seg(x, y, 0, 1, 0, 14) - 1.2);\n      for (let v = 15.5; v \u003c 24; v += 2.7) d = min(d, box(x, y, 0, v, 1.6, 0.9, 0.5));\n      for (const [rx, ry] of RIBS) {\n        const c = 3.6 / (rx * rx), ax = min(abs(x), rx), f = ry + c * ax * ax;\n        d = min(d, abs(x) \u003c= rx ? abs(y - f) / sqrt(1 + (2 * c * ax) ** 2) - 0.7 : sqrt((abs(x) - rx) ** 2 + (y - f) ** 2) - 0.7);\n      }\n      return d;\n    }\n    case 3: {\n      let d = 9;\n      for (let v = -4; v \u003c= 4.1; v += 2.7) d = min(d, box(x, y, 0, v, 1.9, 0.95, 0.5), box(x, y, 0, v, 3.1, 0.4, 0.3));\n      return d;\n    }\n    case 4: {\n      let d = max(abs(x) - (2.5 - 0.28 * (y + 5.5)), abs(y + 2.6) - 3);\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const dx = x - s * 5.3, dy = y + 3.6, c = 0.8, n = 0.6 * s;\n        d = min(d, ell(dx * c + dy * n, -dx * n + dy * c, 0, 0, 4.1, 2.9), abs(ell(x, y, s * 3.4, 2.4, 2.4, 1.9)) - 0.75, ell(x, y, s * 6.5, 0, 1.5, 1.5));\n      }\n      return d;\n    }\n    case 5:\n      return min(ell(x, y, 0, -10.6, 7, 7.3), ell(x, y, 0, -6.8, 6.4, 2.3), box(x, y, 0, -3.2, 4.4, 2.6, 1.4));\n    case 6: {\n      const hw = 4.3 - 0.4 * max(0, y);\n      return min(box(x, y, 0, 1.5, 4.3, 1.6, 0.8), max(abs(x) - hw, abs(y - 1.6) - 1.8));\n    }\n    case 7: {\n      let d = ell(x, y, 0, 1.4, 1.8, 1.4);\n      for (let i = 0; i \u003c 4; i++) d = min(d, seg(x, y, -1.2 + 0.8 * i, 2.2, -1.8 + 1.2 * i, 5.4) - 0.5);\n      return d;\n    }\n    case 8:\n      return min(ell(x, y, sg * 0.8, 1.6, 3.1, 1.4), ell(x, y, 0, 0.4, 1.4, 1));\n    default: {\n      const t = cl((-17.4 - y) / 10, 0, 1);\n      return min(ell(x, y, 0.4, -17, 8.4, 1.4), seg(x, y, 0, -17.4, 2.6, -27.4) - mix(4.6, 0.7, t), seg(x, y, 2.6, -27.4, 6, -28.6) - 0.7);\n    }\n  }\n}\n// 0 none, 1 dark, 2 socket, 3 shade, 4 pupil, 5 hat band.\nfunction hole(k, x, y) {\n  if (k === 5) {\n    if (((abs(x) - 2.9) / 2.2) ** 2 + ((y + 7.9) / 2.5) ** 2 \u003c 1) return ((abs(x) - 2.9) / 1.15) ** 2 + ((y + 7.7) / 1.3) ** 2 \u003c 1 ? 4 : 2;\n    const ny = y + 5.4;\n    if (ny >= 0 && ny \u003c 1.7 && abs(x) \u003c 0.3 + 0.5 * ny) return 1;\n    if (y > -2 && y \u003c -0.5 && abs(x * 0.8) \u003c 3.4) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 || y > -0.9 ? 1 : 0;\n  } else if (k === 6 && y \u003c 1.2 && y > -0.2 && abs(x) \u003c 3.8) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 ? 1 : 0;\n  else if (k === 4 && ((abs(x) - 4.6) / 2.3) ** 2 + ((y + 4.4 + 0.3 * abs(x)) / 1.3) ** 2 \u003c 1) return 3;\n  else if (k === 9 && y > -19.4 && y \u003c -17.6 && abs(x) \u003c 5.2) return 5;\n  return 0;\n}\n\nconst FEMUR = 22, TIBIA = 21, ARM = 15, FORE = 13, HIP = 6.5, FLOOR = 120, HIPY = FLOOR - 3 - FEMUR - TIBIA;\nconst two = (p) => [p, p];\nconst PIECES = [[8, -1, -3.9, 3.9, -1, 3.2], [8, 1, -3.9, 3.9, -1, 3.2], ...two([1, TIBIA, -2.4, 2.4, -11, 11]), ...two([0, FEMUR, -2.6, 2.6, -11.4, 11.4]), [4, 0, -11, 11, -9, 5.2], [3, 0, -3.6, 3.6, -5.3, 5.3], [2, 0, -10.6, 10.6, -4.5, 22.6], ...two([0, ARM, -2.6, 2.6, -7.9, 7.9]), ...two([1, FORE, -2.4, 2.4, -7, 7]), ...two([7, 0, -2.7, 2.7, -0.3, 6.1])];\nconst SKULL = [5, 0, -7.2, 7.2, -18.1, 0.6], JAW = [6, 0, -4.4, 4.4, -0.3, 3.5], CAP = [9, 0, -8.6, 7, -29.6, -15.4];\n\nconst at = (K, i, x, y, a) => {\n  K.x[i] = K.cx + K.sc * x;\n  K.y[i] = FLOOR + K.sc * (y - FLOOR);\n  K.a[i] = a;\n};\nconst ang = (dx, dy) => atan2(-dx, dy);\nconst bone = (K, i, ax, ay, bx, by) => at(K, i, (ax + bx) / 2, (ay + by) / 2, ang(bx - ax, by - ay));\nconst rot = (a, x, y) => [x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)];\nfunction limb(K, ax, ay, tx, ty, L1, L2, i1, i2, px, py) {\n  const dx = tx - ax, dy = ty - ay, d = cl(sqrt(dx * dx + dy * dy), 2, L1 + L2 - 0.01), b = atan2(dy, dx);\n  const al = acos(cl((L1 * L1 + d * d - L2 * L2) / (2 * L1 * d), -1, 1));\n  let kx = ax + L1 * cos(b + al), ky = ay + L1 * sin(b + al);\n  const mx = ax + L1 * cos(b - al), my = ay + L1 * sin(b - al);\n  if ((mx - px) ** 2 + (my - py) ** 2 \u003c (kx - px) ** 2 + (ky - py) ** 2) (kx = mx), (ky = my);\n  const n = sqrt((tx - kx) ** 2 + (ty - ky) ** 2) || 1, u = (tx - kx) / n, v = (ty - ky) / n;\n  bone(K, i1, ax, ay, kx, ky);\n  bone(K, i2, kx, ky, kx + L2 * u, ky + L2 * v);\n  return [kx + L2 * u, ky + L2 * v, u, v];\n}\nfunction torso(D, K) {\n  const rx = D.sway, ry = HIPY + D.bob, t = D.tilt, l = D.lean;\n  at(K, 6, rx, ry, t);\n  for (const s of [-1, 1]) {\n    const [hx, hy] = rot(t, s * HIP, 0), f = s \u003c 0 ? D.fl : D.fr, ax = rx + hx, ay = ry + hy;\n    const [ex, ey] = limb(K, ax, ay, s * (HIP + f[1]), FLOOR - 3 - f[0], FEMUR, TIBIA, 4 + (s > 0), 2 + (s > 0), ax + s * 60, ay + 20);\n    at(K, s > 0 ? 1 : 0, ex, ey, 0);\n  }\n  const [b0, b1] = rot(t, 0, -5), sx = rx + b0, sy = ry + b1, [c0, c1] = rot(l, 0, -10);\n  bone(K, 7, sx + c0, sy + c1, sx, sy);\n  const [d0, d1] = rot(l, 0, -24), tx = sx + c0 + d0, ty = sy + c1 + d1 - D.shr * 0.4;\n  at(K, 8, tx, ty, l);\n  const [n0, n1] = rot(l, 0, -4.4);\n  Object.assign(K, { tx, ty, nx: K.cx + K.sc * (tx + n0), ny: FLOOR + K.sc * (ty + n1 - FLOOR), na: l + D.head });\n}\nfunction arms(D, K) {\n  const l = D.lean;\n  for (const s of [-1, 1]) {\n    const [o0, o1] = rot(l, s * 10, 0.6 - D.shr), ax = K.tx + o0, ay = K.ty + o1, a1 = s \u003c 0 ? D.al : D.ar, a2 = s \u003c 0 ? D.bl : D.br;\n    const [u0, u1] = rot(l, s * sin(a1), cos(a1)), ex = ax + ARM * u0, ey = ay + ARM * u1;\n    const [v0, v1] = rot(l, s * sin(a1 + a2), cos(a1 + a2));\n    let wx = ex + FORE * v0, wy = ey + FORE * v1;\n    const h = K.hold[s > 0 ? 1 : 0];\n    if (h[0] > 0) (wx = mix(wx, (h[1] - K.cx) / K.sc, h[0])), (wy = mix(wy, FLOOR + (h[2] - FLOOR) / K.sc, h[0]));\n    const [hx, hy, u, v] = limb(K, ax, ay, wx, wy, ARM, FORE, 9 + (s > 0), 11 + (s > 0), ex, ey);\n    at(K, 13 + (s > 0), hx, hy, ang(u, v));\n  }\n}\nconst REST = { sway: 0, bob: 0, tilt: 0, lean: 0, head: 0, jaw: 0, shr: 0, al: 0.1, bl: 0.06, ar: 0.1, br: 0.06, fl: [0, 0], fr: [0, 0] };\n\n// --- the story. The camera follows the body at BX; the stone tried stands\n// at SX, its top at ST, the next GAP further on.\nconst SC = 0.85, BX = 20, SX = 40, ST = 82, SHW = 8, GAP = 48, WALK = 4, GROUND = 117, HS = GAP / SC / 8;\nconst BIG = 0, SMALL = 1, HAT = 2, BITER = 3, PUMPKIN = 4, RIGHT = 5;\nconst ORDER = [SMALL, HAT, BITER, PUMPKIN, BIG];\nconst DARK = [34, 20, 50], TOXIC = [96, 255, 64];\nconst EYE = [DARK, DARK, [255, 132, 8], [200, 70, 255], DARK, DARK];\n// Beats a wrong one stays on the neck, and when the shrug starts.\nconst GAG = [3.6, 3.6, 3.8, 0, 3.2, 0];\nconst shrugAt = (k) => (k === RIGHT ? 10.6 : k === BITER ? 4.4 : 3.4 + GAG[k]);\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, t: 0, b: 0, ph: 0, cam: 0, c0: 0, stones: [], queue: [],\n    light: [0, 0, 0], bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    K: { cx: BX, sc: SC, x: new Float64Array(15), y: new Float64Array(15), a: new Float64Array(15), D: { ...REST }, hold: [] },\n  };\n}\nfunction stone(S, j) {\n  if (j \u003c 0) return { j };\n  if (!S.queue.length) {\n    for (let i = 0; i \u003c S.tries; i++) S.queue.push(ORDER[(S.g + i) % 5]);\n    S.g += S.tries;\n    S.queue.push(RIGHT);\n  }\n  const kind = S.queue.shift(), sc = kind === BIG ? 1.1 + 0.9 * S.size : kind === SMALL ? 0.8 - 0.4 * S.size : kind === HAT ? 0.95 : 1;\n  return { j, kind, Hd: { kind, sc, eye: EYE[kind].slice(), hd: 0, jaw: 0, glow: 0 } };\n}\n// A skull on its stone; where a hand takes it, on top (s 0) or at a side.\nconst sit = (S, st, Hd) => Object.assign(Hd, { x: SX + st.j * GAP - S.cam, y: ST - (Hd.kind === PUMPKIN ? 1 : 3.5 * Hd.sc), a: 0, z: 0 });\nconst grip = (Hd, s) => {\n  const [p, q] = Hd.kind === PUMPKIN ? [0, -18] : rot(Hd.a, s * 8.6 * Hd.sc, (s ? -6 : -23) * Hd.sc);\n  return [Hd.x + p, Hd.y + q];\n};\nconst arc = (Hd, ax, ay, a0, bx, by, a1, f, h, z = 1) => Object.assign(Hd, { x: mix(ax, bx, f), y: mix(ay, by, f) - 4 * h * f * (1 - f), a: mix(a0, a1, f), z });\n// A sideways scuttle: one foot stays put as the other swings on ahead.\nfunction gait(D, u) {\n  const p = u / (2 * HS) - floor(u / (2 * HS)), q = (p % 0.5) * 2, w = q * HS, lift = 6 * sin(PI * q), o = sin(TAU * p);\n  D.fl = [p \u003c 0.5 ? 0 : lift, p \u003c 0.5 ? w : HS - w];\n  D.fr = [p \u003c 0.5 ? lift : 0, p \u003c 0.5 ? w : HS - w];\n  Object.assign(D, { bob: 2 - 1.6 * sin(PI * q), sway: (p \u003c 0.5 ? -1.2 : 1.2) * sin(PI * q), al: 0.45 + 0.25 * o, ar: 0.45 - 0.25 * o, bl: 0.5, br: 0.5 });\n}\n\n// The body for beat b of a try: crouch, rise with the skull, the gag, crouch\n// to put it back, shrug.\nfunction pose(D, k, b) {\n  const E = 1.8 + GAG[k], q = b - 1.8, big = k === BIG, w = sin(PI * b), o = sin(TAU * b);\n  let c = b \u003c 0.8 ? ease(b / 0.8) : 1 - ease(k === BITER ? (b - 0.95) / 0.3 : b - 0.8);\n  if (k \u003c BITER || k === PUMPKIN) c = max(c, b \u003c E + 1.2 ? ease((b - E - 0.4) / 0.6) : 1 - ease((b - E - 1.2) / 0.5));\n  D.bob += (big ? 7 : 3) * c;\n  D.lean += (big ? 0.2 : 0.12) * c;\n  // A hand on the hip while the other carries.\n  if (k > SMALL && k !== BITER) blend(D, { al: 0.5, bl: -1.6 }, 1 - ease((b - (k === RIGHT ? 2 : E + 1.8)) / 0.4));\n  if (big) {\n    // Blind: groping, staggering.\n    const g = win(q, 0.3, 0.4, GAG[k] - 0.5, 0.4);\n    blend(D, { al: 1.3 + 0.3 * o, ar: 1.3 - 0.3 * o, bl: 0.4, br: 0.4, sway: 3 * w, lean: D.lean + 0.1 * w }, g);\n    D[w > 0 ? \"fr\" : \"fl\"] = [5 * abs(w) * g, 2 * abs(w) * g];\n  }\n  // The hips work against the small one's wobble.\n  if (k === SMALL && b \u003c E) D.sway = -3 * sin(TAU * 1.25 * q) * cl(q / 1.5, 0, 1);\n  if (k === BITER) {\n    // Bitten: jump back, the free arm flapping.\n    const g = win(b, 1, 0.2, 3.4, 0.4);\n    D.lean -= 0.12 * g;\n    D.bob -= 3 * g * abs(sin(TAU * 1.25 * b));\n    blend(D, { al: 1.3 + 0.5 * sin(TAU * 2 * b), bl: 0.6 }, g);\n  }\n  if (k === RIGHT) {\n    // The jig: kicks to each side, hands on the hips.\n    const g = win(q, 0.5, 0.4, 6.4, 0.3), j = sin(PI * (b - floor(b))) ** 2 * g, s = floor(b) & 1 ? 1 : -1;\n    blend(D, { sway: -2 * s * j, bob: -2 * j, head: 0.2 * s * j, al: 0.5, ar: 0.5, bl: -1.6, br: -1.6 }, g);\n    D[s \u003c 0 ? \"fl\" : \"fr\"] = [12 * j, 7 * j];\n    blend(D, { al: 2.6, ar: 2.6, bl: 0.3, br: 0.3 }, win(b, 8.4, 0.15, 9, 0.4));\n  }\n  const s0 = shrugAt(k);\n  blend(D, { shr: 3.5, al: 0.3, ar: 0.3, bl: 2.5, br: 2.5 }, win(b, s0, 0.3, s0 + 0.9, 0.3));\n}\n\n// The skull being tried and the hands on it.\nfunction skull(S, K, st, b) {\n  const Hd = st.Hd, k = st.kind, E = 1.8 + GAG[k], q = b - 1.8, R = (s, w, x, y) => (K.hold[s] = [w, x, y]);\n  // Patting the neck where it was.\n  const pat = k === RIGHT ? win(b, 9.2, 0.3, 10.4, 0.3) : 0;\n  if (pat > 0) for (const s of [0, 1]) R(s, pat, K.nx + (2 * s - 1) * 5, K.ny - 3 + 3 * sin(TAU * 2 * b + s * PI));\n  if (!Hd) return;\n  // A hand on top; both at the sides of the big one.\n  const take = (w, two = k === BIG) => (two ? [0, 1].forEach((s) => R(s, w, ...grip(Hd, 2 * s - 1))) : R(1, w, ...grip(Hd, 0)));\n  sit(S, st, Hd);\n  const sx = Hd.x, sy = Hd.y;\n  if (k === BITER) {\n    Hd.jaw = b > 0.8 && b \u003c 1.05 ? 1.3 : 0.5 * max(0, sin(TAU * 3 * b));\n    if (b \u003c 1.05) take(ease(b / 0.6));\n    else if (b \u003c 3.3) {\n      // Clamped on the hand, shaken high.\n      Object.assign(Hd, { x: K.x[14], y: K.y[14] + 2, a: 0.35 * sin(TAU * 2.5 * b), jaw: 0, z: 2, fx: K.x[14] });\n      R(1, 1, BX + 13 + 5 * sin(TAU * 2.2 * b), 34 + 4 * sin(TAU * 4.4 * b));\n    } else if (b \u003c 4.1) {\n      // Flung back, turning once.\n      arc(Hd, Hd.fx ?? sx, 36, 0, sx, sy, -TAU, ease((b - 3.3) / 0.8), 8, 2);\n      R(1, 1 - ease((b - 3.3) / 0.5), SX - 6, 60);\n    }\n    return;\n  }\n  if (b \u003c 0.8) return take(ease(b / 0.6));\n  if (b \u003c 1.8) return arc(Hd, sx, sy, 0, K.nx, K.ny, K.na, ease(b - 0.8), 7), take(1);\n  const gag = (t) => {\n    Object.assign(Hd, { x: K.nx, y: K.ny, a: K.na, z: 1 });\n    if (k === BIG) {\n      // It drops down over the ribs.\n      const [p, r] = rot(K.na, 0, (6 + 18 * Hd.sc) * ease(t / 0.4) - 3 * sin(PI * cl((t - 0.4) / 0.3, 0, 1)));\n      (Hd.x += p), (Hd.y += r);\n    } else if (k === SMALL) {\n      // Wobbling ever wider, then tipping off.\n      const tip = ease((t - GAG[k] + 0.7) / 0.5);\n      Hd.a += 0.5 * sin(TAU * 1.25 * t) * cl(t / 1.5, 0, 1) * (1 - tip) + 1.4 * tip;\n      (Hd.x += 5 * tip), (Hd.y += 3 * tip);\n    } else if (k === HAT) Hd.hd = win(t, 0.3, 0.2, 1, 0.3) + (t > 2.1 && t \u003c GAG[k] ? ease((t - 2.1) / 0.2) : 0);\n  };\n  if (k === RIGHT) {\n    gag(min(q, 6.6));\n    Hd.glow = ease(q / 0.4);\n    Hd.flash = q \u003c 0.5 ? 1 - q / 0.5 : 0;\n    for (let c = 0; c \u003c 3; c++) Hd.eye[c] = mix(DARK[c], TOXIC[c], Hd.glow);\n    Hd.jaw = K.D.jaw;\n    if (q \u003c 0.3) take(1 - ease(q / 0.3));\n    if (b > 8.4) {\n      // Off it goes.\n      const f = min(1, b - 8.4);\n      arc(Hd, K.nx, K.ny, K.na, 3, GROUND - 3.5, -TAU, f, 14, 2);\n      if (f >= 1) (S.lost = { Hd, wx: 3 + S.cam, t: 0 }), (st.Hd = null);\n    }\n    return;\n  }\n  if (b \u003c E) {\n    gag(q);\n    if (k === PUMPKIN) R(1, win(q, 0.6, 0.3, 2.4, 0.3), Hd.x + 10 + 2.5 * abs(sin(TAU * 1.5 * q)), Hd.y - 7);\n    else if (k === HAT) R(1, win(q, 0.8, 0.2, 1.6, 0.3), Hd.x + 6.5 * Hd.sc, Hd.y + (10 * Hd.hd - 17) * Hd.sc);\n    else if (k === SMALL) {\n      // Hands up ready; the right one catches it.\n      for (const s of [0, 1]) R(s, ease((q - 0.3) / 0.4), K.nx + (2 * s - 1) * 11, K.ny - 8);\n      if (b > E - 0.5) R(1, 1, ...grip(Hd, 1));\n    } else if (q \u003c 0.3) take(1 - ease(q / 0.3));\n    return;\n  }\n  gag(E - 1.801);\n  if (b \u003c E + 0.4) return take(ease((b - E) / 0.4));\n  if (b \u003c E + 1.4) return arc(Hd, Hd.x, Hd.y, Hd.a, sx, sy, 0, ease(b - E - 0.4), 6), (Hd.hd = 0), take(1);\n  sit(S, st, Hd);\n  take(1 - ease((b - E - 1.4) / 0.4));\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1), hue = cl(kn[0], 0, 1);\n  if (hue !== S.hue) {\n    hsv(0.78 - 0.3 * (S.hue = hue), 0.62, S.light);\n    background(S);\n  }\n  (S.size = cl(kn[3], 0, 1)), (S.tries = round(cl(kn[2], 1, 5)));\n  if (!S.stones.length) (S.g = 5 - S.tries), (S.stones = [-1, 0, 1].map((j) => stone(S, j)));\n  const db = d * cl(kn[1], 0.2, 3);\n  (S.b += db), (S.t += d);\n  let st = S.stones[1];\n  if (!S.ph && S.b >= shrugAt(st.kind) + 1.2) (S.b -= shrugAt(st.kind) + 1.2), (S.ph = 1), (S.c0 = S.cam);\n  if (S.ph && S.b >= WALK) {\n    S.b -= WALK;\n    S.ph = 0;\n    S.cam = S.c0 + GAP;\n    S.stones = [S.stones[1], S.stones[2], stone(S, S.stones[2].j + 1)];\n    st = S.stones[1];\n  }\n  const K = S.K, D = Object.assign(K.D, REST, { fl: [0, 0], fr: [0, 0] });\n  K.hold = [[0], [0]];\n  if (S.ph) {\n    // Walking on: the camera glides one stone further.\n    S.cam = S.c0 + GAP * ease(S.b / WALK);\n    gait(D, (S.cam - S.c0) / SC);\n  } else pose(D, st.kind, S.b);\n  torso(D, K);\n  for (const x of S.stones) if (x.Hd && (x !== st || S.ph)) sit(S, x, x.Hd);\n  if (!S.ph) skull(S, K, st, S.b);\n  arms(D, K);\n  if (S.lost) {\n    // Rolling away about the middle of the cranium.\n    const L = S.lost, x = L.wx - S.cam - 9 * (L.t += db), a = -L.t, [p, r] = rot(a, 0, 10.6);\n    Object.assign(L.Hd, { x: x + p, y: GROUND - 14.1 + r, a, z: 2 });\n    if (x \u003c -24) S.lost = null;\n  }\n}\n\n// --- the graveyard, laid out per sky colour: the stepped sky and the moon\n// over a dark hill.\nconst MX = 46, MY = 20, MR = 12;\nconst put = (buf, o, r, g, b) => ((buf[o] = r), (buf[o + 1] = g), (buf[o + 2] = b));\nfunction background(S) {\n  const L = S.light;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = sqrt((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2), v = floor((0.14 + 0.5 * (y / GROUND) ** 1.6) * 20) / 20, e = q \u003c MR + 4 ? 60 : q \u003c MR + 9 ? 26 : 0;\n      const sp = q > MR - 1.5 || (x - MX + 3) ** 2 + (y - MY + 2) ** 2 \u003c 10 ? 24 : 0;\n      if (q \u003c MR) put(S.bg, (y * W + x) * 3, 255 - sp, 240 - sp, 204 - sp);\n      else if (y > 100 + 4 * sin(x * 0.09) + 2.5 * sin(x * 0.23 + 1.3)) put(S.bg, (y * W + x) * 3, L[0] * 0.16 + 8, L[1] * 0.16 + 6, L[2] * 0.16 + 12);\n      else put(S.bg, (y * W + x) * 3, L[0] * v + e, L[1] * v + e * 0.93, L[2] * v + e * 0.83);\n    }\n}\n// A tall headstone with a cut cross, rimmed by the moon.\nconst inStone = (dx, y) => abs(dx) \u003c SHW && y \u003c GROUND && (y >= ST + SHW || dx * dx + (y - ST - SHW) ** 2 \u003c SHW * SHW);\nfunction headstone(buf, cx) {\n  for (let y = ST - 1; y \u003c GROUND; y++)\n    for (let x = max(0, floor(cx - SHW)); x \u003c min(W, ceil(cx + SHW)); x++) {\n      const dx = x + 0.5 - cx, yy = y + 0.5;\n      if (!inStone(dx, yy)) continue;\n      const cut = (abs(dx) \u003c 1.1 && y > ST + 5 && y \u003c ST + 19) || (abs(dx) \u003c 4.2 && y >= ST + 9 && y \u003c ST + 11);\n      const v = !inStone(dx, yy - 1) || !inStone(dx + 1, yy) ? 1.6 : cut ? 0.45 : dx \u003c 3 - SHW ? 0.75 : 1;\n      put(buf, (y * W + x) * 3, 92 * v, 94 * v, 112 * v);\n    }\n}\n// Bone in three tones, the darkest tinted by the sky; the hat violet.\nconst BONE = [[255, 244, 220], [212, 202, 180], [96, 88, 84]];\nconst HATC = [[196, 120, 255], [140, 64, 210], [70, 26, 112]];\nconst FIELD = new Float32Array(48 * 48);\nfunction piece(S, pc, cx, cy, a, sc, Hd) {\n  const [k, sg, x0, x1, y0, y1] = pc, c = cos(a), s = sin(a);\n  let xa = 1e9, xb = -1e9, ya = 1e9, yb = -1e9;\n  for (const [u, v] of [[x0, y0], [x1, y0], [x0, y1], [x1, y1]]) {\n    const wx = cx + (u * c - v * s) * sc, wy = cy + (u * s + v * c) * sc;\n    (xa = min(xa, wx)), (xb = max(xb, wx)), (ya = min(ya, wy)), (yb = max(yb, wy));\n  }\n  xa = max(0, floor(xa) - 1);\n  xb = min(W - 1, ceil(xb) + 1);\n  ya = max(0, floor(ya) - 1);\n  yb = min(H - 1, ceil(yb) + 1);\n  if (xb \u003c xa || yb \u003c ya || xb - xa >= 48 || yb - ya >= 48) return;\n  const buf = S.buf, L = S.light, z = 1 / sc;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy;\n      FIELD[(y - ya) * 48 + x - xa] = shape(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z, sg) * sc;\n    }\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const f = (y - ya) * 48 + x - xa, d = FIELD[f], o = (y * W + x) * 3;\n      if (d > 0.1) {\n        if (d \u003c 1.1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, hl = hole(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z);\n      if (hl && hl !== 3) {\n        const e = hl === 1 ? [2, 0, 4] : hl === 5 ? [245, 134, 2] : Hd.eye, g = hl === 2 ? 0.34 : 1;\n        put(buf, o, e[0] * g + 10, e[1] * g + 6, e[2] * g + 14);\n        continue;\n      }\n      const up = y > ya ? FIELD[f - 48] : d + 1, dn = y \u003c yb ? FIELD[f + 48] : d + 1, n = (up - dn) / (abs(up - dn) + abs((x > xa ? FIELD[f - 1] : d) - (x \u003c xb ? FIELD[f + 1] : d)) + 0.01);\n      const t = hl === 3 || n \u003c= -0.3 ? 2 : n > 0.4 || (d > -0.6 && up > 0.1) ? 0 : 1, C = k === 9 ? HATC : BONE, w = t === 2 && k !== 9 ? 0.4 : 0;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = C[t][ch] + L[ch] * w;\n    }\n}\n// A jack-o'-lantern, the face flickering in three steps.\nfunction pumpkin(S, Hd) {\n  const buf = S.buf, cx = Hd.x, cy = Hd.y - 6, v = 0.6 + 0.2 * sin(S.t * 9) + 0.2 * sin(S.t * 23.7), fl = v > 0.82 ? 1 : v > 0.66 ? 0.84 : 0.7;\n  for (let y = max(0, floor(cy - 11)); y \u003c min(H, cy + 9); y++)\n    for (let x = max(0, floor(cx - 11)); x \u003c min(W, cx + 11); x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, o = (y * W + x) * 3, e = (dx / 9) ** 2 + (dy / 7) ** 2;\n      if (e \u003c 1) {\n        const rib = abs(abs(dx) - 4.2) \u003c 0.6 && e > 0.25, eye = dy > -4.2 && dy \u003c -0.8 && abs(abs(dx) - 3.6) \u003c 1.9 + (dy + 4.2) * 0.5, grin = dy > 1.1 && dy \u003c 3.9 - abs(dx) * 0.15 && abs(dx) \u003c 6 && !(abs(dx) % 3 \u003c 0.8 && dy \u003c 2.2);\n        if (eye || grin) put(buf, o, 255, 196 * fl + 30, 50 * fl);\n        else put(buf, o, rib ? 220 : 255, rib ? 84 : 118, rib ? 0 : 10);\n      } else if (e \u003c 1.35 && dy > -8) put(buf, o, buf[o] * 0.3, buf[o + 1] * 0.3, buf[o + 2] * 0.3);\n      if (abs(dx + 0.3) \u003c 1.2 && dy > -9.6 && dy \u003c -6.2) put(buf, o, 72, 150, 40);\n    }\n}\nfunction head(S, Hd) {\n  if (Hd.kind === PUMPKIN) return pumpkin(S, Hd);\n  // The right one's toxic halo, white on the click.\n  const [p, q] = rot(Hd.a, 0, -8), cx = Hd.x + p, cy = Hd.y + q, f = Hd.flash || 0;\n  for (let y = max(0, floor(cy - 15)); y \u003c min(H, cy + 15) && Hd.glow > 0; y++)\n    for (let x = max(0, floor(cx - 15)); x \u003c min(W, cx + 15); x++) {\n      const v = floor(max(0, 1 - sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2) / 15) * 4) / 4;\n      for (let ch = 0, o = (y * W + x) * 3; ch \u003c 3; ch++) S.buf[o + ch] += (TOXIC[ch] * Hd.glow * 0.8 + 255 * f) * v;\n    }\n  piece(S, SKULL, Hd.x, Hd.y, Hd.a, Hd.sc, Hd);\n  const [j0, j1] = rot(Hd.a, 0, (2.4 * Hd.jaw - 0.7) * Hd.sc), [h0, h1] = rot(Hd.a, 0, 10 * Hd.hd * Hd.sc);\n  piece(S, JAW, Hd.x + j0, Hd.y + j1, Hd.a, Hd.sc, Hd);\n  if (Hd.kind === HAT) piece(S, CAP, Hd.x + h0, Hd.y + h1, Hd.a, Hd.sc, Hd);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0 || !S.stones.length) return;\n  const buf = S.buf, K = S.K, cam = S.cam;\n  buf.set(S.bg);\n  // The ground, a lit edge and specks sliding with the camera.\n  for (let p = GROUND * W; p \u003c N; p++) {\n    const y = (p / W) | 0, e = y === GROUND ? 30 : (floor((p % W) + cam) * 7 + y * y * 3) % 11 ? 0 : 12;\n    put(buf, p * 3, 40 + e, 26 + e * 0.8, 48 + e);\n  }\n  const heads = (z) => [...S.stones.map((st) => st.Hd), S.lost?.Hd].forEach((Hd) => Hd && Hd.z === z && head(S, Hd));\n  // The stones stand in front of the path; the hands in front of what they hold.\n  for (let i = 0; i \u003c 13; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  for (const st of S.stones) headstone(buf, SX + st.j * GAP - cam);\n  heads(0);\n  heads(1);\n  for (let i = 13; i \u003c 15; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  heads(2);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","pumpkin-drop":"// ===== Patternflow pattern =====\n// Title:   Pumpkin Drop\n// Family:  halloween\n// Idea:    A lit jack-o'-lantern is wound up a wooden hoist under a cloudy purple night, swings at the top, is let go and falls all 128 rows with its flame streaking upward, then bursts on the ground, flinging shards and seeds over a splash of pulp while the candle tumbles out and sputters into a puff of smoke; the next pumpkin spins in from the right, lights up and goes up.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Flame=0..1, Speed=0.2..3, Wind=0..1, Size=0..1\n//\n// Knob 1: Flame. The colour of the candle and of what it lights: the carved face, the halo on the sky and the hoist, the streak as it falls and the flash of the burst. Gold at 0, toxic green at 0.25, blue at 0.5, magenta at 0.75. The pumpkin's skin stays orange.\n// Knob 2: Speed. At 2 a round takes about 10 s. The pumpkin is wound up from the ground in 2.2 s and swings for 1.6 s; the fall of 81 rows takes 1.04 s and ends at 156 LEDs a second; the burst lasts 2.4 s, the candle going out 1.3 to 1.6 s after the impact; the hook comes down in 0.9 s and the next pumpkin takes 1.8 s to come in and light. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Wind. How far the pumpkin swings at the top and how fast the clouds and the smoke drift right. At 0 nearly still air: a swing of 5 degrees either way and clouds at 2 LEDs a second. At 1 it swings 50 degrees and is let go at the end of a long arc, left and right in turn, while the top band of cloud runs at 18 LEDs a second. A big pumpkin swings less, so it stays on the panel.\n// Knob 4: Size. The pumpkin, 16 LEDs wide at 0 and 32 at 1, about 17 at the opening. A bigger one throws its light farther and bursts into more pieces: 25 shards at the opening and 48 at 1.\n// Buttons: K1 tap lets the hanging pumpkin go at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, asin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  o[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  o[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  o[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return o;\n}\n\n// The ground's top row; the hoist's post, beam and pulley; the moon.\nconst GY = 119, PX = 38, PY = 13, MX = 52, MY = 34, MR = 7, CB = [20, 40, 62];\n// The rope's length from the pulley to the hook when the pumpkin hangs at\n// the top; the pumpkin's middle hangs its half height and 2 LEDs below.\nconst HOOK = 9;\n// Seconds of each part at Speed 2.\nconst T_HANG = 1.6, T_SMASH = 2.4, T_LOWER = 0.9, T_ROLL = 1.3, T_LIGHT = 0.5, T_HOIST = 2.2, SWING = 1.6;\nconst G = 150;\n// Light round a point, by squared distance in LEDs.\nconst RAD = new Float32Array(20480);\nfor (let i = 0; i \u003c RAD.length; i++) RAD[i] = exp(-sqrt(i) / 16);\n// Kinds of LED in the still picture and how much lantern light each takes.\nconst SKY = 0, WOOD = 1, EARTH = 2, MOON = 3, TAKE = [0.5, 0.75, 1, 0.1];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, gh: 0.11, speed: 2, wind: 0, size: 0.06, cx: [0, 31, 67], rx: 9, ry: 7,\n    ph: \"hoist\", e: 0, side: 1, lc: 0, th: 0, x: PX, y: 0, vy: 0, lit: 1, roll: 0,\n    hook: { l: 0, a: 0, w: 0 },\n    shards: [], seeds: [], smoke: [], splat: null, candle: null, flash: 0, fl: 1, fade: 1,\n    bg: new Float32Array(N * 3), kind: new Uint8Array(N), buf: new Float32Array(N * 3), c: [0, 0, 0], g: [0, 0, 0],\n    stars: [],\n  };\n  scene(params.s);\n}\n\n// The still picture: a violet sky paling to mauve at the horizon with the\n// moon in it, and the black hoist with a moonlit edge standing on the earth.\nfunction scene(S) {\n  const bg = S.bg, kd = S.kind, c = S.c;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3, u = y / GY;\n      hsv(0.74 + 0.08 * u, 0.72 - 0.12 * u, 0.3 + 0.2 * u * u, c);\n      const dm = sqrt((x - MX) ** 2 + (y - MY) ** 2);\n      const halo = 0.5 * exp(-max(0, dm - MR) / 7);\n      bg[o] = c[0] + 70 * halo;\n      bg[o + 1] = c[1] + 60 * halo;\n      bg[o + 2] = c[2] + 70 * halo;\n      if (dm \u003c MR + 0.5) {\n        // The moon, two grey seas on it set on a slant.\n        const sea = exp(-((x - MX + 2) ** 2 + (y - MY + 2) ** 2) / 5) + 0.8 * exp(-((x - MX - 3) ** 2 + (y - MY - 3) ** 2) / 4);\n        const a = cl(MR + 0.5 - dm, 0, 1), m = 1 - 0.18 * sea;\n        bg[o] += (238 * m - bg[o]) * a;\n        bg[o + 1] += (228 * m - bg[o + 1]) * a;\n        bg[o + 2] += (196 * m - bg[o + 2]) * a;\n        kd[p] = MOON;\n      }\n      if (y >= GY) {\n        // Earth, a little lighter in the top rows, with a speckle.\n        const k = 1 - (y - GY) * 0.05, n = 0.85 + 0.3 * ((x * 37 + y * 91) % 7) / 7;\n        bg[o] = 52 * k * n;\n        bg[o + 1] = 30 * k * n;\n        bg[o + 2] = 60 * k * n;\n        kd[p] = EARTH;\n      }\n    }\n  // Grass tufts standing on the ground line, black against the sky.\n  for (let x = 0; x \u003c W; x++) {\n    const hgt = 1 + ((x * 7 + 3) % 5 === 0 ? 2 : (x * 13) % 3 === 0 ? 1 : 0);\n    for (let j = 1; j \u003c= hgt; j++) wood(S, x, GY - j, 0.4);\n  }\n  // The post and the beam with its brace, each with a moonlit edge.\n  for (let y = 8; y \u003c GY; y++) for (let x = 4; x \u003c= 6; x++) wood(S, x, y, x === 6 ? 1 : 0);\n  for (let x = 2; x \u003c= 44; x++) for (let y = 8; y \u003c= 10; y++) wood(S, x, y, y === 8 ? 1 : 0);\n  for (let i = 0; i \u003c= 16; i++) for (let j = 0; j \u003c 2; j++) wood(S, 6 + i, 25 - i + j, j);\n  // The rope down the post to the winch.\n  for (let y = 11; y \u003c 97; y++) rope(bg, 8, y, 0.8);\n  for (let i = 0; i \u003c 26; i++) S.stars.push({ x: floor(rnd(0, W)), y: floor(rnd(0, 70)), ph: rnd(0, 7), f: rnd(1, 3), b: rnd(0.4, 1) });\n}\n\nfunction wood(S, x, y, edge) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const p = y * W + x, o = p * 3;\n  S.bg[o] = 16 + 44 * edge;\n  S.bg[o + 1] = 8 + 30 * edge;\n  S.bg[o + 2] = 24 + 54 * edge;\n  S.kind[p] = WOOD;\n}\n\nfunction rope(buf, x, y, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (176 - buf[o]) * a;\n  buf[o + 1] += (140 - buf[o + 1]) * a;\n  buf[o + 2] += (96 - buf[o + 2]) * a;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.gh = 0.11 + cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.size = cl(k[3], 0, 1);\n  // A pie pumpkin 16 LEDs wide at 0, 32 at 1.\n  S.rx = 8 + 8 * S.size;\n  S.ry = 0.78 * S.rx;\n  const ds = (d * S.speed) / 2, hk = S.hook, RY = S.ry;\n  const TOP = HOOK + 2 + RY, LOW = GY - RY - 1 - PY;\n  // The swing, kept small enough that a big pumpkin stays on the panel.\n  const A = min(0.08 + 0.8 * S.wind, asin(min(1, (W - S.rx - 2 - PX) / TOP)));\n  S.t += ds;\n  S.e += ds;\n  // Three bands of cloud drift right, the lower ones slower.\n  for (let i = 0; i \u003c 3; i++) S.cx[i] += (2 + 16 * S.wind) * (1 - 0.25 * i) * ds;\n  // The candle flickers on three beats.\n  S.fl = 0.8 + 0.1 * sin(S.t * 23) + 0.06 * sin(S.t * 41 + 1) + 0.05 * sin(S.t * 7.3);\n  if (input.btnPressed && input.btnPressed[0] && S.ph === \"hang\") S.e = T_HANG;\n  if (S.ph === \"hoist\" || S.ph === \"hang\") {\n    // A pendulum from the pulley. While it is wound up the swing builds, and\n    // it is let go at the end of its swing, where it stands still.\n    const p = S.ph === \"hoist\" ? sm(S.e / T_HOIST) : 1;\n    const tt = S.ph === \"hoist\" ? S.e - T_HOIST : S.e;\n    S.lc = S.ph === \"hoist\" ? LOW + (TOP - LOW) * p : TOP;\n    S.th = S.side * A * p * cos((2 * PI * tt) / SWING);\n    S.x = PX + S.lc * sin(S.th);\n    S.y = PY + S.lc * cos(S.th);\n    hk.l = S.lc - RY - 2;\n    hk.a = S.th;\n    if (S.ph === \"hoist\" && S.e >= T_HOIST) (S.ph = \"hang\"), (S.e = 0);\n    else if (S.ph === \"hang\" && S.e >= T_HANG) {\n      S.ph = \"fall\";\n      S.e = 0;\n      S.vy = 0;\n      hk.w = 0;\n    }\n  } else if (S.ph === \"fall\") {\n    S.vy += G * ds;\n    S.y += S.vy * ds;\n    S.th *= exp(-1.5 * ds);\n    if (S.y + RY >= GY - 0.5) smash(S);\n  } else if (S.ph === \"smash\") {\n    if (S.e >= T_SMASH) (S.ph = \"lower\"), (S.e = 0);\n  } else if (S.ph === \"lower\") {\n    // The hook is let down to the ground while the mess fades.\n    const p = sm(S.e / T_LOWER);\n    hk.l = HOOK + (LOW - TOP) * p;\n    S.fade = 1 - p;\n    if (S.e >= T_LOWER) {\n      S.ph = \"roll\";\n      S.e = 0;\n      S.shards.length = S.seeds.length = 0;\n      S.splat = null;\n      S.fade = 1;\n      S.lit = 0;\n    }\n  } else if (S.ph === \"roll\") {\n    // The next pumpkin spins in from the right and turns its face to us.\n    const p = S.e / T_ROLL, q = 1 - (1 - p) * (1 - p);\n    S.x = PX + 36 * (1 - q);\n    S.y = PY + LOW;\n    S.roll = (S.x - PX) / S.rx;\n    S.th = 0;\n    if (S.e >= T_ROLL) (S.ph = \"light\"), (S.e = 0), (S.roll = 0);\n  } else if (S.ph === \"light\") {\n    S.lit = S.e \u003c 0.12 ? 1.6 * (S.e / 0.12) : 1 + 0.6 * exp(-(S.e - 0.12) * 8);\n    if (S.e >= T_LIGHT) {\n      S.ph = \"hoist\";\n      S.e = 0;\n      S.lit = 1;\n      S.side = -S.side;\n    }\n  }\n  // The empty hook swings back under the pulley.\n  if (S.ph !== \"hoist\" && S.ph !== \"hang\") {\n    hk.w += (-30 * hk.a - 2.2 * hk.w) * ds;\n    hk.a += hk.w * ds;\n  }\n  physics(S, ds);\n}\n\n// The pumpkin hits the ground and everything in it is thrown out at once.\nfunction smash(S) {\n  const RX = S.rx, RY = S.ry, b = S.size;\n  S.ph = \"smash\";\n  S.e = 0;\n  S.y = GY - RY - 0.5;\n  S.flash = 1;\n  const n = round(3 * RX), x0 = cl(S.x, 6, W - 7);\n  S.x = x0;\n  for (let i = 0; i \u003c n; i++) {\n    const a = rnd(-PI + 0.25, -0.25), sp = rnd(40, 95) * (0.9 + 0.4 * b), r = rnd(1.3, 3) * RX / 9;\n    S.shards.push({ x: x0 + rnd(-RX, RX) * 0.8, y: S.y + rnd(-RY, RY) * 0.6, vx: cos(a) * sp * 0.8, vy: sin(a) * sp, a: rnd(0, 7), w: rnd(-12, 12), r, k: Math.random() \u003c 0.3 ? 1 : 0, rest: 0 });\n  }\n  for (let i = 0; i \u003c 14 + 26 * b; i++) {\n    const a = rnd(-PI * 0.95, -PI * 0.05), sp = rnd(30, 85) * (0.8 + 0.5 * b);\n    S.seeds.push({ x: x0 + rnd(-4, 4), y: S.y, vx: cos(a) * sp, vy: sin(a) * sp, rest: 0, p: Math.random() \u003c 0.35 });\n  }\n  S.splat = { x: x0, w: 0, s: 6 + 8 * b + 4 * Math.random() };\n  const dir = Math.random() \u003c 0.5 ? -1 : 1;\n  S.candle = { x: x0, y: S.y, vx: dir * rnd(16, 26), vy: -rnd(55, 70), a: 0, w: dir * rnd(8, 14), f: 1, out: rnd(1.3, 1.6), t: 0, puff: false };\n}\n\nfunction physics(S, ds) {\n  S.flash *= exp(-ds * 9);\n  for (const s of S.shards) {\n    if (s.rest) continue;\n    s.vy += G * ds;\n    s.x += s.vx * ds;\n    s.y += s.vy * ds;\n    s.a += s.w * ds;\n    if (s.x \u003c 0.5 || s.x > W - 1.5) (s.vx = -0.5 * s.vx), (s.x = cl(s.x, 0.5, W - 1.5));\n    if (s.y > GY - 0.5 && s.vy > 0) {\n      s.y = GY - 0.5;\n      s.vy *= -0.42;\n      s.vx *= 0.55;\n      s.w *= 0.5;\n      if (abs(s.vy) \u003c 12) (s.rest = 1), (s.y = GY - 0.5 + rnd(0, 1.2));\n    }\n  }\n  for (const s of S.seeds) {\n    if (s.rest) continue;\n    s.vy += G * ds;\n    s.x += s.vx * ds;\n    s.y += s.vy * ds;\n    if (s.y > GY && s.vy > 0) {\n      s.y = GY;\n      s.vy *= -0.45;\n      s.vx *= 0.6;\n      if (abs(s.vy) \u003c 10) (s.rest = 1), (s.y = GY + floor(rnd(0, 3)));\n    }\n  }\n  if (S.splat) S.splat.w = min(1, S.splat.w + ds * 6);\n  const cd = S.candle;\n  if (cd) {\n    cd.t += ds;\n    cd.vy += G * ds;\n    cd.x += cd.vx * ds;\n    cd.y += cd.vy * ds;\n    cd.a += cd.w * ds;\n    if (cd.x \u003c 2 || cd.x > W - 3) (cd.vx = -0.6 * cd.vx), (cd.x = cl(cd.x, 2, W - 3));\n    if (cd.y > GY - 1 && cd.vy > 0) {\n      // On the ground it lies down and rolls to a stop.\n      cd.y = GY - 1;\n      cd.vy *= -0.3;\n      cd.vx *= 0.7;\n      cd.w = 0;\n      cd.a += (PI / 2 - (cd.a % PI)) * 0.4;\n      if (abs(cd.vy) \u003c 8) cd.vy = 0;\n    }\n    if (cd.vy === 0) cd.vx *= exp(-4 * ds);\n    // It sputters: the flame gutters and goes out.\n    const left = cd.out - cd.t;\n    cd.f = left > 0 ? cl(left / cd.out + 0.3, 0, 1) * (left \u003c 0.6 ? (sin(cd.t * 61) > 0.1 ? 1 : 0.25) : 1) : 0;\n    if (left \u003c= 0 && !cd.puff) {\n      cd.puff = true;\n      const w = wick(cd);\n      for (let i = 0; i \u003c 22; i++) S.smoke.push({ x: w[0] + rnd(-0.5, 0.5), y: w[1] - rnd(0, 2), vx: rnd(-5, 5), vy: -rnd(10, 26), r: rnd(0.8, 1.4), t: 0, life: rnd(1.8, 2.8) });\n    }\n    if (S.ph === \"roll\") S.candle = null;\n  }\n  let n = 0;\n  for (const m of S.smoke) {\n    m.t += ds;\n    m.x += (m.vx + 3 * sin(m.t * 3 + m.life * 5) + 12 * S.wind * min(1, m.t)) * ds;\n    m.y += m.vy * ds;\n    m.vy *= exp(-0.6 * ds);\n    m.r = min(3.6, m.r + ds * 1.6);\n    if (m.t \u003c m.life) S.smoke[n++] = m;\n  }\n  S.smoke.length = n;\n}\n\n// Where the candle's wick is: the top of the stick, which tumbles.\nfunction wick(cd) {\n  return [cd.x + 2.5 * sin(cd.a), cd.y - 2.5 * cos(cd.a)];\n}\n\n// Add a colour at a pixel by alpha.\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\n// One LED of the pumpkin at local (u, v) from its middle, turned by its\n// spin: false outside it. Ribs are meridians, so they crowd at the edges;\n// the face is painted on the front and turns away as it spins.\nfunction pumpkinAt(S, u, v, out) {\n  const RX = S.rx, RY = S.ry, k = 9 / RX, vv = v / RY;\n  if (vv \u003c -1 || vv > 1) return false;\n  const half = RX * sqrt(1 - vv * vv) * (vv \u003c 0 ? 1 : 1 - 0.08 * vv);\n  if (abs(u) > half + 0.35) return false;\n  // A dip at the top round the stem.\n  if (vv \u003c -0.8 && abs(u) \u003c 2 && v \u003c -RY + 0.9) return false;\n  const n = cl(u / max(half, 0.5), -1, 1), lon = asin(n) - S.roll;\n  const rib = abs(((lon / 0.628 + 50.5) % 1) - 0.5) \u003c 0.13;\n  const nz = sqrt(max(0, 1 - n * n)) * sqrt(max(0, 1 - vv * vv));\n  const lightv = 0.82 + 0.18 * cl(0.3 * n - 0.5 * vv + 0.5 * nz, 0, 1);\n  const glow = S.lit * S.fl;\n  let hole = false;\n  if (cos(lon) > 0.2) hole = face(9 * sin(lon), v * k);\n  if (hole) {\n    if (glow > 0.05) {\n      hsv(S.gh + 0.03, 0.62 - 0.4 * cl(glow - 0.7, 0, 1), min(1, 0.5 + 0.5 * glow), out);\n    } else (out[0] = 46), (out[1] = 16), (out[2] = 6);\n    return true;\n  }\n  // Skin: bright saturated orange, the ribs a redder line.\n  hsv(rib ? 0.05 : 0.07, 1, lightv * (rib ? 0.86 : 0.97), out);\n  return true;\n}\n\n// The carving, in LEDs from the middle of a pumpkin 18 wide: triangle eyes\n// over a small nose, then a grin with two teeth above and one below.\nfunction face(u, v) {\n  const au = abs(u);\n  if (v >= -4 && v \u003c= -1.5) {\n    const w = (v + 4.3) * 0.75;\n    if (abs(au - 4.2) \u003c w) return true;\n  }\n  if (v >= -0.5 && v \u003c= 0.6 && au \u003c 0.6 + (v + 0.5) * 0.9) return true;\n  if (v > 1.5 && v \u003c 4.5) {\n    const top = 2.5 - 0.035 * au * au, bot = 4.2 - 0.05 * au * au;\n    if (au \u003c 6.4 && v > top && v \u003c bot) {\n      if (v \u003c top + 1.2 && (abs(u + 2.5) \u003c 0.6 || abs(u - 2.5) \u003c 0.6)) return false;\n      if (v > bot - 1.1 && au \u003c 0.6) return false;\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const bg = S.bg, buf = S.buf, kd = S.kind, gc = hsv(S.gh, 0.85, 1, S.g), c = S.c, hk = S.hook;\n  // Lantern light: from the pumpkin while it is whole and lit, then from the\n  // candle out on the ground; the burst adds a flash.\n  const whole = S.ph !== \"smash\" && S.ph !== \"lower\";\n  const L1 = whole ? (0.9 + 0.5 * S.size) * S.lit * S.fl : 0, q1 = (8.5 / S.rx) ** 2, cd = S.candle, RX = S.rx, RY = S.ry;\n  const L2 = cd ? 0.7 * cd.f * S.fl : 0, wk = cd ? wick(cd) : [0, 0];\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = p * 3;\n      let l = 0;\n      if (L1 > 0) l += L1 * RAD[min(20479, round(((x - S.x) ** 2 + (y - S.y) ** 2) * q1))];\n      if (L2 > 0) l += L2 * RAD[min(20479, round((x - wk[0]) ** 2 + (y - wk[1]) ** 2 * 1.5))];\n      if (S.flash > 0.01) l += 1.6 * S.flash * RAD[min(20479, round(((x - S.x) ** 2 + (y - GY) ** 2) * 0.4))];\n      const t = l * TAKE[kd[p]];\n      let r = bg[o], g = bg[o + 1], b = bg[o + 2];\n      if (y > 6 && y \u003c 78 && kd[p] !== WOOD) {\n        // Cloud: wisps of value noise in three wavy bands, lilac grey.\n        let a = 0;\n        for (let i = 0; i \u003c 3; i++) {\n          const dy = (y - CB[i] - 3 * vn((x - S.cx[i]) * 0.03, i * 31)) / (3.5 + 1.5 * i);\n          if (dy * dy > 4) continue;\n          const u = x - S.cx[i], n = vn(u * 0.045 + y * 0.02, i * 101) + 0.6 * vn(u * 0.12 - y * 0.05, i * 101 + 7) + 0.3 * vn(u * 0.25 + y * 0.1, i * 101 + 13);\n          a += cl((n - 0.05) * 2.2, 0, 1) * exp(-dy * dy) * 0.75;\n        }\n        if (a > 0) {\n          a = min(0.8, a);\n          r += (142 - r) * a;\n          g += (116 - g) * a;\n          b += (178 - b) * a;\n        }\n      }\n      buf[o] = r + gc[0] * t;\n      buf[o + 1] = g + gc[1] * t;\n      buf[o + 2] = b + gc[2] * t;\n    }\n  // Stars twinkle.\n  for (const s of S.stars) {\n    const b = s.b * (0.55 + 0.45 * sin(S.t * s.f + s.ph));\n    put(buf, s.x, s.y, 235, 220, 255, 0.85 * b);\n  }\n  // The winch on the post turns as the rope runs.\n  const wa = hk.l / 3;\n  for (let i = 0; i \u003c 24; i++) {\n    const a = (i / 24) * 2 * PI;\n    put(buf, 9 + 3.5 * cos(a), 100 + 3.5 * sin(a), 120, 90, 60, 1);\n  }\n  for (let i = 0; i \u003c 4; i++) {\n    const a = wa + (i * PI) / 2;\n    for (let r = 0; r \u003c= 3; r++) put(buf, 9 + r * cos(a), 100 + r * sin(a), 150, 112, 70, 1);\n  }\n  // The pulley under the beam.\n  for (let i = 0; i \u003c 16; i++) {\n    const a = (i / 16) * 2 * PI;\n    put(buf, PX + 2.2 * cos(a), PY + 2.2 * sin(a), 120, 110, 130, 1);\n  }\n  put(buf, PX, PY, 200, 190, 210, 1);\n  // The rope and the hook: on the pumpkin while it hangs, empty after.\n  const ha = hk.a, hl = hk.l;\n  for (let i = 2; i \u003c= hl; i += 0.7) rope(buf, PX + i * sin(ha), PY + i * cos(ha), 0.9);\n  const hx = PX + hl * sin(ha), hy = PY + hl * cos(ha);\n  put(buf, hx, hy + 1, 170, 170, 190, 1);\n  put(buf, hx + 1, hy + 2, 170, 170, 190, 1);\n  put(buf, hx, hy + 2.6, 140, 140, 160, 1);\n  // The pumpkin, turned by its swing.\n  if (whole) {\n    const cs = cos(S.th), sn = sin(S.th);\n    // The flame streaks up out of it as it falls.\n    if (S.ph === \"fall\") {\n      const len = min(20, S.vy / 6);\n      for (let j = 0; j \u003c len; j++) {\n        const f = 1 - j / len;\n        hsv(S.gh + 0.04 - 0.08 * (1 - f), 0.1 + 0.8 * (1 - f), 1, c);\n        put(buf, S.x, S.y - RY - 1 - j, c[0], c[1], c[2], S.fl * min(1, 1.5 * f));\n        hsv(S.gh - 0.03, 0.85, 1, c);\n        for (let i = -1; i \u003c= 1; i += 2) if (j \u003c len * 0.7) put(buf, S.x + i, S.y - RY - 1 - j, c[0], c[1], c[2], 0.75 * f * S.fl);\n      }\n    }\n    for (let dy = -ceil(RY) - 3; dy \u003c= RY + 1; dy++)\n      for (let dx = -ceil(RX) - 2; dx \u003c= RX + 2; dx++) {\n        const u = dx * cs + dy * sn, v = -dx * sn + dy * cs;\n        if (pumpkinAt(S, u, v, c)) put(buf, S.x + dx, S.y + dy, c[0], c[1], c[2], 1);\n        else if (v \u003c -RY + 1 && v > -RY - 2.5 && abs(u) \u003c 1.1) put(buf, S.x + dx, S.y + dy, 70, 120, 40, 1);\n      }\n  }\n  // The burst: pulp splashed on the ground, with the shards and seeds over it.\n  const fa = S.fade;\n  if (S.splat) {\n    const sp = S.splat;\n    for (let i = -sp.s - 3; i \u003c= sp.s + 3; i++) {\n      const w = sp.s * sp.w, r = abs(i) / max(1, w), j = (i * 7919 + 13) % 5;\n      if (r > 1) continue;\n      const hgt = 1 + (r \u003c 0.6 ? 1 : 0) + (j === 0 ? 1 : 0);\n      for (let k = 0; k \u003c hgt; k++) put(buf, sp.x + i, GY - k + (k ? 0 : 0), 255, 150 + 20 * j, 30, fa * (1 - 0.3 * k));\n    }\n  }\n  for (const s of S.shards) {\n    const ca = cos(s.a), sa = sin(s.a), r = s.r;\n    for (let dy = -3; dy \u003c= 3; dy++)\n      for (let dx = -3; dx \u003c= 3; dx++) {\n        // A rough triangle of skin, or of yellow flesh.\n        const u = dx * ca + dy * sa, v = -dx * sa + dy * ca;\n        if (v \u003c -r * 0.5 || v > r * 0.6 || abs(u) > r - (v + r * 0.5) * 0.9) continue;\n        if (s.k) put(buf, s.x + dx, s.y + dy, 255, 196, 60, fa);\n        else put(buf, s.x + dx, s.y + dy, 255, v \u003c 0 ? 112 : 96, 0, fa);\n      }\n  }\n  for (const s of S.seeds) {\n    put(buf, s.x, s.y, 250, 238, 190, fa);\n    if (s.p && !s.rest) put(buf, s.x - s.vx * 0.02, s.y - s.vy * 0.02, 255, 170, 40, fa * 0.8);\n  }\n  if (cd) {\n    // The candle, a stub of wax two LEDs thick, and its flame, which stands\n    // up whichever way the stub lies.\n    const ca = cos(cd.a), sa = sin(cd.a);\n    for (let j = -2; j \u003c= 2; j += 0.5)\n      for (let i = 0; i \u003c= 1; i++) put(buf, cd.x + j * sa + i * ca, cd.y - j * ca + i * sa, 240, 232, 212, fa);\n    if (cd.f > 0.02) {\n      const w = wick(cd), fl = cd.f * S.fl;\n      hsv(S.gh + 0.04, 0.15, 1, c);\n      put(buf, w[0], w[1] - 1, c[0], c[1], c[2], min(1, fl * 1.4));\n      put(buf, w[0] + 1, w[1] - 1, c[0], c[1], c[2], min(1, fl * 0.8));\n      hsv(S.gh, 0.8, 1, c);\n      put(buf, w[0], w[1] - 2, c[0], c[1], c[2], min(1, fl * 1.2));\n      put(buf, w[0] + 1, w[1] - 2, c[0], c[1], c[2], fl * 0.6);\n      if (fl > 0.5) put(buf, w[0] + 0.5 + 0.6 * sin(S.t * 13), w[1] - 3, c[0], c[1], c[2], fl - 0.3);\n    }\n  }\n  for (const m of S.smoke) {\n    const a = 0.5 * (1 - m.t / m.life) * min(1, m.t * 8);\n    const r = m.r;\n    for (let dy = -4; dy \u003c= 4; dy++)\n      for (let dx = -4; dx \u003c= 4; dx++) {\n        const q = dx * dx + dy * dy;\n        if (q \u003c= r * r + 0.3) put(buf, m.x + dx, m.y + dy, 180, 170, 196, a * (1 - q / (r * r + 1.5)));\n      }\n  }\n  // Out in steps of four.\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, min(255, ((buf[o] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 1] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 2] + 2) >> 2) \u003c\u003c 2));\n}\n","specimen-shelf":"// ===== Patternflow pattern =====\n// Title:   Specimen Shelf\n// Family:  halloween\n// Idea:    Three specimen jars on two shelves, toxic green and amber above and violet below, each hold a floating eyeball; one turns to stare out at you, the others glance at it and turn one after another, then all of them look away together, roll up in a blink and drift apart, while bubbles rise and a knock on a shelf sets the fluid sloshing and glowing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Knock=0..1\n//\n// Knob 1: Hue. Turns the three fluids round the wheel together, each iris with its fluid: at 0 toxic green with a magenta iris and amber with a blue iris on the top shelf, violet with a gold iris below. At 0.33 they are blue, green and amber, at 0.67 red, violet and teal. The whites, veins, nerves, lids, cork and shelves stay as they are.\n// Knob 2: Speed. At 2 one round of the story takes 12 s: the first eye turns to stare 0.6 s in, the second glances at it at 1.3 s and stares at 1.8, the third glances at 2.1 and stares at 2.6; they stare until 4.4, look away together until 5.3, blink and drift from 5.7. Each round a different eye starts. A small bubble rises through its jar in about 3 s. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Bubbles. At 0 four bubbles a second across the three jars, a third of them rings; at 0.5 about 18 a second; at 1 sixty a second, four in five of them rings up to 5 LEDs across in the small jars and 7 in the big one.\n// Knob 4: Knock. How often something knocks a shelf, and how hard. At 0 the first knock comes 6.6 s in and then one every 12 s; at 0.06, 6.3 s in and every 11.4 s; at 1, 1.5 s in and every 1.8 s, twice as hard. Each knock hits the other shelf from the last: the board jolts 2 LEDs sideways, dust falls from under it or jumps off it, the fluid tilts 3 rows at the glass (6 at 1) and sloshes for about 2 s, glowing brighter while it settles, a burst of bubbles shakes loose, and every eye that is not staring turns toward the knock.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, acos, exp, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The two shelves: the top of each board and the row its front ends.\nconst SHELF = [[56, 61], [119, 127]];\n// The three jars. Rows: lid (or cork), neck, shoulder, body, rounded bottom,\n// thick base. Half-widths inside the glass. surf is the fluid's resting\n// row, ex/ey/er the eye's rest and radius, hue the fluid's colour, iris the\n// eye's, lum how bright the fluid is away from the light.\nconst JARS = [\n  { cx: 16, lid: [5, 10], lidW: 11.5, cork: 0, neck: [11, 13], neckW: 9, sh: [14, 18], w: 12, bot: [50, 54], base: 55, shelf: 0,\n    surf: 19, ex: 16, ey: 36, er: 7, hue: 0.29, iris: 0.83, irisS: 0.8, lum: 0.08 },\n  { cx: 48, lid: [4, 9], lidW: 5.5, cork: 1, neck: [10, 17], neckW: 5, sh: [18, 28], w: 12.5, bot: [49, 54], base: 55, shelf: 0,\n    surf: 24, ex: 48, ey: 40, er: 7, hue: 0.09, iris: 0.6, irisS: 0.8, lum: 0.2 },\n  { cx: 32, lid: [63, 69], lidW: 22.5, cork: 0, neck: [70, 72], neckW: 18, sh: [73, 79], w: 23, bot: [111, 117], base: 118, shelf: 1,\n    surf: 81, ex: 32, ey: 98, er: 11, hue: 0.78, iris: 0.12, irisS: 0.72, lum: 0.07, gold: 1 },\n];\nfunction halfIn(J, y) {\n  if (y \u003c J.neck[0] || y >= J.bot[1]) return -1;\n  if (y \u003c J.sh[0]) return J.neckW;\n  if (y \u003c J.sh[1]) {\n    const u = (J.sh[1] - y) / (J.sh[1] - J.sh[0]);\n    return J.neckW + (J.w - J.neckW) * sqrt(1 - u * u);\n  }\n  if (y \u003c J.bot[0]) return J.w;\n  const u = (y - J.bot[0]) / (J.bot[1] - J.bot[0]);\n  return J.w - (J.w * 0.25) * (1 - sqrt(1 - u * u));\n}\n\n// Veins on the white, laid out in the eye's own angles (th from the gaze\n// axis, ph round it) so they turn with it; tabled once, ph against th.\nconst VEINS = [], VT = 65;\nfor (let k = 0; k \u003c 7; k++) {\n  const ph0 = (k * TAU) / 7 + 0.35 * sin(k * 2.3), a = 0.22 + 0.08 * sin(k * 1.7), f = 3 + (k % 3), p = k * 1.3;\n  const tab = new Float32Array(VT);\n  for (let j = 0; j \u003c VT; j++) {\n    const th = (j * PI) / (VT - 1);\n    tab[j] = ph0 + a * sin(f * th + p) + 0.1 * sin(9 * th + 2 * p);\n  }\n  VEINS.push({ tab, end: 0.8 + 0.1 * ((k * 5) % 3) });\n}\nconst IRIS = 0.62;\n// The fluid's glow round an eye, falling off by e every 5 LEDs, tabled.\nconst EXP5 = Float32Array.from({ length: 64 }, (_, i) => exp(-i / 20));\n\nexport function setup(params) {\n  // Per LED: which jar (0 none, else 1 + index) and what part of it.\n  // 1 fluid side of the glass, 2 glass wall, 3 thick base, 4 lid, 5 cork,\n  // 6 shelf top, 7 shelf front, 0 the wall behind.\n  const reg = new Uint8Array(N), jar = new Uint8Array(N), glow = new Float32Array(N);\n  JARS.forEach((J, j) => {\n    J.hw = new Float32Array(H);\n    for (let y = 0; y \u003c H; y++) J.hw[y] = halfIn(J, y);\n    for (let y = 0; y \u003c H; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const i = y * W + x, dx = abs(x + 0.5 - J.cx), hw = J.hw[y];\n        let r = 0;\n        if (y >= J.lid[0] && y \u003c= J.lid[1]) {\n          const lw = J.cork ? J.lidW - 0.15 * (y - J.lid[0]) : y === J.lid[0] ? J.lidW - 1.5 : y === J.lid[0] + 1 ? J.lidW - 0.5 : J.lidW;\n          if (dx \u003c lw) r = J.cork ? 5 : 4;\n        } else if (hw > 0 && dx \u003c hw) r = 1;\n        else if (hw > 0 && dx \u003c hw + 1.3) r = 2;\n        else if (y >= J.bot[1] && y \u003c= J.base && dx \u003c J.w * 0.8 + 1) r = 3;\n        if (r) (reg[i] = r), (jar[i] = j + 1);\n        // How much of this jar's glow reaches the wall here.\n        const top = J.lid[0], bot = J.base;\n        const ddx = max(0, dx - (hw > 0 ? hw + 1 : J.w)), ddy = y \u003c top ? top - y : y > bot ? y - bot : 0;\n        const gw = exp(-hypot(ddx, ddy) / 5);\n        if (!r && !reg[i] && gw > glow[i]) (glow[i] = gw), (jar[i] = j + 1);\n      }\n  });\n  SHELF.forEach(([a, b]) => {\n    for (let y = a; y \u003c= b; y++) for (let x = 0; x \u003c W; x++) reg[y * W + x] = y \u003c a + 2 ? 6 : 7;\n  });\n  params.s = {\n    t: 0, hue: 0, speed: 2, bub: 0, knockK: 0.06,\n    reg, jar, glow,\n    eyes: JARS.map((J, j) => ({\n      yaw: 0.6 - 0.6 * j, pitch: 0.2, roll: 0, tyaw: 0.6, tpitch: 0.2, next: 0.5 + 0.7 * j, rate: 2,\n      stare: 0, dil: 0, ox: 0, oy: 0, vx: 0, vy: 0, ph: j * 2.1,\n    })),\n    slosh: JARS.map(() => ({ a: 0, v: 0, ag: 0 })),\n    bubbles: [], acc: 0, pops: [], dust: [], kSide: 1, cyc: -1, look: [0, 0],\n    knockAt: 0, kAge: 9, kShelf: 0,\n    rgb: new Float32Array(N * 3), nerve: new Float32Array(N),\n  };\n}\n\n// The story, in seconds at Speed 2, one round of 12 s: one eye turns to\n// stare out at 0.6; the next glances at it at 1.3 and stares at 1.8; the\n// last glances at 2.1 and stares at 2.6; at 4.4 all three look away to the\n// same place, at 5.3 they roll up and back down together, a blink, and from\n// 5.7 each drifts on its own.\nconst ROUND = 12;\nfunction story(S, e, j, tc, order) {\n  const pos = order.indexOf(j), st = [0.6, 1.8, 2.6][pos], gl = [9, 1.3, 2.1][pos];\n  if (tc >= 5.3 && tc \u003c 5.7) return { yaw: 0, pitch: -1.75, rate: 16, stare: 0 };\n  if (tc >= 4.4 && tc \u003c 5.3) return { yaw: S.look[0], pitch: S.look[1], rate: 11, stare: 0 };\n  if (tc >= st && tc \u003c 4.4) return { yaw: 0, pitch: 0, rate: 6, stare: 1 };\n  if (tc >= gl && tc \u003c st) {\n    // Glance at whichever has already turned.\n    const L = JARS[order[0]], J = JARS[j];\n    const dx = L.ex - J.ex, dy = L.ey - J.ey;\n    return { yaw: atan2(dx, 10), pitch: cl(atan2(dy, hypot(dx, 10)), -1, 1), rate: 9, stare: 0 };\n  }\n  return null;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.bub = cl(k[2], 0, 1);\n  S.knockK = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  const cyc = floor(S.t / ROUND), tc = S.t - cyc * ROUND;\n  if (cyc !== S.cyc) {\n    S.cyc = cyc;\n    // Who starts this round, and where all three look together.\n    const o = [[2, 0, 1], [1, 2, 0], [0, 1, 2]][cyc % 3];\n    S.order = o;\n    const looks = [[-1.1, -0.5], [1.1, 0.3], [0.2, 0.9], [-0.9, 0.6]];\n    S.look = looks[cyc % 4];\n  }\n  // Knocks: the first 6.6 s in at 0, 1.5 s in at 1; then every 12 s at 0\n  // and every 1.8 s at 1. Each hits the other shelf from the last.\n  S.knockAt += g;\n  const first = mix(6.6, 1.5, S.knockK), every = mix(12, 1.8, S.knockK);\n  if (S.knockAt >= (S.knocks ? every : first)) {\n    S.knockAt = 0;\n    S.knocks = (S.knocks || 0) + 1;\n    S.kAge = 0;\n    S.kShelf = S.knocks % 2;\n    const hard = 0.6 + 0.6 * S.knockK, side = S.knocks % 3 === 1 ? -1 : 1;\n    S.kSide = side;\n    JARS.forEach((J, j) => {\n      const near = J.shelf === S.kShelf ? 1 : 0.35;\n      S.slosh[j].v += side * hard * near * 20;\n      S.slosh[j].ag = min(1.5, S.slosh[j].ag + hard * near);\n      const e = S.eyes[j];\n      e.vx += side * hard * near * 22;\n      e.vy -= hard * near * 16;\n    });\n    // Dust shaken off the board: down from under the top shelf, up off the\n    // bottom one.\n    for (let n = 0; n \u003c 14 + 10 * S.knockK; n++) {\n      const top = S.kShelf === 0;\n      S.dust.push({ x: Math.random() * W, y: top ? SHELF[0][1] + 1 : SHELF[1][0] - 1, vx: (Math.random() - 0.5) * 6, vy: top ? 2 + 6 * Math.random() : -8 - 10 * Math.random(), life: 1.2 + Math.random() });\n    }\n    // A rush of bubbles shaken loose.\n    for (let n = 0; n \u003c 10 + 14 * S.knockK; n++) spawn(S, floor(Math.random() * 3), true);\n  }\n  S.kAge += g;\n  for (const m of S.dust) {\n    m.vy += 14 * g;\n    m.x += m.vx * g;\n    m.y += m.vy * g;\n    m.life -= g;\n  }\n  S.dust = S.dust.filter((m) => m.life > 0 && m.y \u003c H);\n  JARS.forEach((J, j) => {\n    // The fluid's tilt, a damped swing of about 1.4 a second.\n    const sl = S.slosh[j];\n    sl.v += (-80 * sl.a - 2.2 * sl.v) * g;\n    sl.a += sl.v * g;\n    // Shaken, the fluid lights up, and settles back in about a second.\n    sl.ag *= exp(-g * 1.1);\n    const e = S.eyes[j];\n    let tg = story(S, e, j, tc, S.order);\n    if (!tg && S.kAge \u003c 1) {\n      // A knock: every idle eye looks round at it.\n      const up = JARS[j].shelf > S.kShelf ? -0.6 : JARS[j].shelf \u003c S.kShelf ? 0.6 : 0.15;\n      tg = { yaw: S.kSide * 1, pitch: up, rate: 10, stare: 0 };\n      e.next = min(e.next, 1.2);\n    }\n    if (!tg) {\n      // Drifting: somewhere new to look every 1.5 to 3.5 s.\n      e.next -= g;\n      if (e.next \u003c= 0) {\n        e.next = 1.5 + 2 * Math.random();\n        e.tyaw = (Math.random() * 2 - 1) * (Math.random() \u003c 0.15 ? 1.9 : 0.9);\n        e.tpitch = (Math.random() * 2 - 1) * 0.6;\n      }\n      tg = { yaw: e.tyaw, pitch: e.tpitch, rate: 2, stare: 0 };\n    } else (e.tyaw = tg.yaw), (e.tpitch = tg.pitch);\n    const r = min(1, g * tg.rate);\n    e.yaw += wrap(tg.yaw - e.yaw) * r;\n    e.pitch += (tg.pitch - e.pitch) * r;\n    e.roll = 0.3 * sin(S.t * 0.23 + j) + 0.12 * sin(S.t * 0.61 + 2 * j);\n    e.stare += (tg.stare - e.stare) * min(1, g * (tg.stare ? 4 : 2.5));\n    e.dil += ((tg.stare && e.stare > 0.6 ? 1 : 0) - e.dil) * min(1, g * 2.4);\n    // A knock throws the eye; a spring brings it back.\n    e.vx += (-30 * e.ox - 3 * e.vx) * g;\n    e.vy += (-30 * e.oy - 3 * e.vy) * g;\n    e.ox += e.vx * g;\n    e.oy += e.vy * g;\n  });\n  // Bubbles: a few a second from each jar at 0, a fizz at 1.\n  S.acc += g * mix(4, 60, S.bub * S.bub);\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    spawn(S, floor(Math.random() * 3), false);\n  }\n  for (const b of S.bubbles) {\n    const J = JARS[b.j];\n    b.v = min(b.v + g * 30, 7 + 6 * b.r);\n    b.y -= b.v * g;\n    b.x += 2.5 * sin(b.ph + b.y * 0.3) * g;\n    b.x = cl(b.x, J.cx - J.hw[cl(round(b.y), 0, H - 1)] + 1, J.cx + J.hw[cl(round(b.y), 0, H - 1)] - 1);\n    if (b.y \u003c surfAt(S, b.j, b.x) + 0.5) {\n      b.dead = 1;\n      S.pops.push({ x: b.x, j: b.j, life: 0.25 });\n    }\n  }\n  S.bubbles = S.bubbles.filter((b) => !b.dead);\n  for (const p of S.pops) p.life -= g;\n  S.pops = S.pops.filter((p) => p.life > 0);\n}\nfunction spawn(S, j, shaken) {\n  const J = JARS[j];\n  const x = J.cx + (Math.random() * 2 - 1) * J.w * 0.7;\n  const y = shaken ? J.surf + 6 + Math.random() * (J.bot[0] - J.surf - 6) : J.bot[0] + 1;\n  const r = Math.random() \u003c 0.3 + 0.5 * S.bub ? 1.1 + Math.random() * (0.5 + 1.2 * S.bub) * (J.er / 7) : 0.5;\n  S.bubbles.push({ j, x, y, z: Math.random() * 2 - 1, r, v: shaken ? 4 : 1, ph: TAU * Math.random() });\n}\n// The fluid's surface row at x, tilted by the slosh and rippled.\nfunction surfAt(S, j, x) {\n  const J = JARS[j], t = S.t, a = S.slosh[j].a;\n  return J.surf + (a * (x - J.cx)) / J.w * 2.2 + 0.5 * sin(0.4 * x + 1.9 * t + j) + 0.35 * sin(0.7 * x - 2.6 * t) * (1 + 2 * abs(a));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, reg, jar, glow, nerve } = S, t = S.t;\n  const fls = JARS.map((J) => hsv(J.hue + S.hue, 0.92, 1));\n  const irs = JARS.map((J) => hsv(J.iris + S.hue, J.irisS, 1));\n  // Each eye this frame: where it sits and which way it faces.\n  const E = JARS.map((J, j) => {\n    const e = S.eyes[j], bob = 1 - 0.6 * e.stare, s2 = J.er / 11;\n    const ex = J.ex + (3 * sin(t * 0.45 + 1 + j * 2) * bob) * s2 + e.ox;\n    const ey = J.ey + (5 * sin(t * 0.9 + j * 1.7) + 1.2 * sin(t * 2.1 + j)) * bob * s2 + e.oy;\n    const er = J.er * (1 + 0.15 * e.stare);\n    const ca = cos(e.yaw), sa = sin(e.yaw), cb = cos(e.pitch), sb = sin(e.pitch);\n    const f = [sa * cb, sb, ca * cb];\n    const r0 = [ca, 0, -sa], u0 = [-sa * sb, cb, -ca * sb];\n    const cr = cos(e.roll), sr = sin(e.roll);\n    const rx = [r0[0] * cr + u0[0] * sr, r0[1] * cr + u0[1] * sr, r0[2] * cr + u0[2] * sr];\n    const ux = [u0[0] * cr - r0[0] * sr, u0[1] * cr - r0[1] * sr, u0[2] * cr - r0[2] * sr];\n    return { ex, ey, er, f, rx, ux, pupil: mix(0.36, 0.72, e.dil), front: f[2] \u003c 0, stare: e.stare };\n  });\n  // The optic nerves: a pink cord from the back of each eye, hanging and\n  // waving in the fluid.\n  nerve.fill(0);\n  E.forEach((v, j) => {\n    let bx = -v.f[0], by = -v.f[1];\n    const bl = hypot(bx, by);\n    let dx = bl > 0.05 ? bx / bl : 0, dy = bl > 0.05 ? by / bl : 1;\n    let x = v.ex + v.er * bx, y = v.ey + v.er * by;\n    const sc = v.er / 11;\n    for (let s = 0; s \u003c 11; s++) {\n      const rad = (2.2 - 0.1 * s) * max(0.7, sc);\n      for (let yy = floor(y - rad); yy \u003c= y + rad; yy++)\n        for (let xx = floor(x - rad); xx \u003c= x + rad; xx++) {\n          if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || jar[yy * W + xx] !== j + 1) continue;\n          const dd = sqrt((xx + 0.5 - x) ** 2 + (yy + 0.5 - y) ** 2);\n          if (dd \u003c rad) nerve[yy * W + xx] = max(nerve[yy * W + xx], dd \u003c rad - 1 ? 1 : 0.6);\n        }\n      const a = atan2(dy, dx), wave = 0.32 * sin(t * 1.6 - s * 0.45 + j);\n      const na = a + 0.12 * wrap(PI / 2 - a) + wave * 0.35;\n      dx = cos(na);\n      dy = sin(na);\n      x += 2 * sc * dx;\n      y += 2 * sc * dy;\n    }\n  });\n\n  // The light rippling through the fluid: three wavy bands, lit where their\n  // sum crosses zero. Each band's inner wave is worked out once a frame.\n  const cs = S.cs || (S.cs = new Float32Array(2 * W + 2 * H));\n  for (let y = 0; y \u003c H; y++) cs[y] = 0.9 * sin(y * 0.15 + t * 0.9);\n  for (let x = 0; x \u003c W; x++) cs[H + x] = 0.9 * sin(x * 0.19 - t * 0.6);\n  for (let i = 0; i \u003c W + H; i++) cs[H + W + i] = 0.7 * sin((i - H) * 0.12 + t * 0.9);\n  const sc = S.sc || (S.sc = new Float32Array(3 * W));\n  for (let j = 0; j \u003c 3; j++) for (let x = 0; x \u003c W; x++) sc[j * W + x] = surfAt(S, j, x + 0.5);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, rg = reg[i], jj = jar[i] - 1, px = x + 0.5, py = y + 0.5;\n      let r = 0.035, gg = 0.012, b = 0.06;\n      const J = JARS[jj], fl = fls[jj];\n      if (rg === 1) {\n        const sy = sc[jj * W + x] - (abs(px - J.cx) > J.hw[y] - 1.5 ? 1 : 0);\n        if (py \u003c sy - 0.5) {\n          r = 0.03 + 0.06 * fl[0];\n          gg = 0.02 + 0.08 * fl[1];\n          b = 0.06 + 0.06 * fl[2];\n        } else {\n          const v = E[jj], cyl = 1 - ((px - J.cx) / J.hw[y]) ** 2;\n          const a1 = x * 0.27 + cs[y] + t * 0.75 + jj;\n          const a2 = y * 0.2 + cs[H + x] - t * 1.1;\n          const a3 = (x + y) * 0.15 + cs[H + W + x - y + H];\n          const cv = abs(sin(a1) + sin(a2) + sin(a3));\n          const caus = cv \u003c 0.3 ? 1 - cv / 0.3 : 0;\n          const de = sqrt((px - v.ex) ** 2 + (py - v.ey) ** 2) - v.er;\n          const flare = 1 + 0.6 * v.stare + 1.4 * S.slosh[jj].ag;\n          let L = (J.lum + 0.2 * cyl * cyl) * flare + caus * (0.3 + 0.4 * cyl) + (de > 0 && de \u003c 16 ? 0.1 * (0.6 + 1.6 * v.stare) * EXP5[floor(de * 4)] : 0);\n          if (py \u003c sy + 0.5) L = 0.95;\n          L = q(L, 14);\n          r = fl[0] * L;\n          gg = fl[1] * L;\n          b = fl[2] * L;\n        }\n      } else if (rg === 2) {\n        r = 0.14 + 0.22 * fl[0];\n        gg = 0.16 + 0.24 * fl[1];\n        b = 0.2 + 0.22 * fl[2];\n      } else if (rg === 3) {\n        r = fl[0] * 0.45;\n        gg = fl[1] * 0.45;\n        b = fl[2] * 0.45;\n      } else if (rg === 4) {\n        // Pewter lid, ridged, with a bright band.\n        const dx = abs(px - J.cx), rnd = 0.6 + 0.4 * sqrt(max(0, 1 - (dx / J.lidW) ** 2));\n        const ridge = (y - J.lid[0]) % 2 === 0 ? 1.25 : 0.8;\n        const spec = abs(px - (J.cx - J.lidW * 0.5)) \u003c 1.2 ? 2.6 : 1;\n        const vv = ridge * spec * rnd * (y === J.lid[1] ? 0.6 : 1);\n        r = 0.17 * vv;\n        gg = 0.13 * vv;\n        b = 0.25 * vv;\n        if (y === J.lid[0]) (r = 0.42), (gg = 0.36), (b = 0.52);\n      } else if (rg === 5) {\n        // The cork, grainy and lit from the left.\n        const dx = px - J.cx, grain = ((x * 7 + y * 13) % 5) / 5;\n        const vv = (0.75 - 0.05 * dx) * (0.85 + 0.25 * grain) * (y === J.lid[0] ? 1.2 : 1);\n        r = 0.62 * vv;\n        gg = 0.36 * vv;\n        b = 0.24 * vv;\n      } else if (rg === 6) {\n        // The shelf top: the jars' glow pools under them.\n        let pr = 0, pg = 0, pb = 0;\n        JARS.forEach((K, k) => {\n          if (SHELF[K.shelf][0] !== y && SHELF[K.shelf][0] + 1 !== y) return;\n          const pool = exp(-abs(px - K.cx) / (K.w * 0.7)), f2 = fls[k];\n          pr += 0.45 * pool * f2[0];\n          pg += 0.45 * pool * f2[1];\n          pb += 0.45 * pool * f2[2];\n        });\n        r = 0.2 + pr;\n        gg = 0.1 + pg;\n        b = 0.28 + pb;\n      } else if (rg === 7) {\n        const edge = y === SHELF[0][0] + 2 || y === SHELF[1][0] + 2;\n        r = edge ? 0.26 : 0.1;\n        gg = edge ? 0.15 : 0.04;\n        b = edge ? 0.36 : 0.16;\n      } else if (jj >= 0) {\n        const gw = 0.1 * glow[i] * (1 + 0.8 * E[jj].stare);\n        r += gw * fl[0];\n        gg += gw * fl[1];\n        b += gw * fl[2];\n      }\n      if (rg === 1) {\n        const v = E[jj], u = (px - v.ex) / v.er, w = (py - v.ey) / v.er, d2 = u * u + w * w, nv = nerve[i];\n        if (nv && (v.front || d2 >= 1)) {\n          r = 0.9 * nv;\n          gg = 0.32 * nv;\n          b = 0.42 * nv;\n        } else if (d2 \u003c 1) {\n          const f = v.f, rx = v.rx, ux = v.ux, iris = irs[jj];\n          const nz = sqrt(1 - d2), cosA = u * f[0] + w * f[1] + nz * f[2];\n          const th = acos(cl(cosA, -1, 1)), sh = 0.55 + 0.45 * nz;\n          if (th \u003c IRIS * v.pupil) (r = 0), (gg = 0), (b = 0);\n          else if (th \u003c IRIS) {\n            const tt = th / IRIS;\n            const ph = atan2(u * ux[0] + w * ux[1] + nz * ux[2], u * rx[0] + w * rx[1] + nz * rx[2]);\n            // Never below 0.6 of full, and the gold one near full, so that\n            // it stays gold and does not turn olive.\n            const streak = 0.8 + 0.2 * sin(ph * 13 + 3 * sin(ph * 4));\n            let vv = tt > 0.86 ? 0.05 : streak * (tt \u003c v.pupil + 0.12 ? 1 : 0.88) * (0.85 + 0.15 * sh);\n            if (J.gold && vv > 0.1) vv = 0.9 + 0.1 * streak;\n            r = iris[0] * vv;\n            gg = iris[1] * vv;\n            b = iris[2] * vv;\n          } else {\n            const rim = (1 - nz) * (1 - nz);\n            r = mix(1, fl[0], 0.7 * rim) * sh;\n            gg = mix(0.97, fl[1], 0.7 * rim) * sh;\n            b = mix(0.95, fl[2], 0.7 * rim) * sh;\n            const ph = atan2(u * ux[0] + w * ux[1] + nz * ux[2], u * rx[0] + w * rx[1] + nz * rx[2]);\n            const st = sin(th) * v.er, jt = round((th / PI) * (VT - 1)), wd = 0.4 + 0.3 * (th / PI);\n            for (const vn of VEINS)\n              if (th >= vn.end && abs(wrap(ph - vn.tab[jt])) * st \u003c wd) {\n                r = 0.8 * sh;\n                gg = 0.02 * sh;\n                b = 0.06 * sh;\n                break;\n              }\n          }\n          if ((u + 0.38) ** 2 + (w + 0.42) ** 2 \u003c 0.03) (r = 1), (gg = 1), (b = 1);\n        }\n      }\n      // The glass catches the light down its left side.\n      if ((rg === 1 || rg === 2) && abs(px - (J.cx - J.hw[y] - 0.2)) \u003c 0.8 && y > J.sh[1] && y \u003c J.bot[0]) {\n        r += 0.22;\n        gg += 0.22;\n        b += 0.22;\n      }\n      const o = i * 3;\n      rgb[o] = r;\n      rgb[o + 1] = gg;\n      rgb[o + 2] = b;\n    }\n  // Bubbles: a bright point, or a ring for the bigger ones; those behind the\n  // eye are hidden by it.\n  for (const bb of S.bubbles) {\n    const R = bb.r, v = E[bb.j], fl = fls[bb.j], x0 = floor(bb.x - R - 1), y0 = floor(bb.y - R - 1);\n    for (let y = y0; y \u003c= y0 + 2 * R + 2; y++)\n      for (let x = x0; x \u003c= x0 + 2 * R + 2; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || reg[y * W + x] !== 1 || jar[y * W + x] !== bb.j + 1) continue;\n        if (bb.z \u003c 0 && (x + 0.5 - v.ex) ** 2 + (y + 0.5 - v.ey) ** 2 \u003c v.er * v.er) continue;\n        const dd = sqrt((x + 0.5 - bb.x) ** 2 + (y + 0.5 - bb.y) ** 2);\n        if (R \u003c 1 ? dd \u003c 0.75 : abs(dd - R) \u003c 0.55) {\n          const o = (y * W + x) * 3;\n          rgb[o] = mix(fl[0], 1, 0.6);\n          rgb[o + 1] = mix(fl[1], 1, 0.6);\n          rgb[o + 2] = mix(fl[2], 1, 0.6);\n        }\n      }\n  }\n  // A popped bubble flicks two drops off the surface.\n  for (const p of S.pops) {\n    const fl = fls[p.j];\n    for (const dx of [-1, 1]) {\n      const x = floor(p.x + dx * (1.5 - p.life * 2)), y = floor(surfAt(S, p.j, p.x) - 2 - (p.life \u003c 0.12 ? 1 : 0));\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || reg[y * W + x] !== 1) continue;\n      const o = (y * W + x) * 3;\n      rgb[o] = mix(fl[0], 1, 0.5);\n      rgb[o + 1] = mix(fl[1], 1, 0.5);\n      rgb[o + 2] = mix(fl[2], 1, 0.5);\n    }\n  }\n  for (const m of S.dust) {\n    const x = floor(m.x), y = floor(m.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3, a = 0.5 * min(1, m.life);\n    rgb[o] = max(rgb[o], 0.75 * a);\n    rgb[o + 1] = max(rgb[o + 1], 0.62 * a);\n    rgb[o + 2] = max(rgb[o + 2], 0.8 * a);\n  }\n  // A knock jolts its shelf sideways for a moment.\n  const jolt = S.kAge \u003c 0.5 ? round(2.2 * sin(S.kAge * 40) * exp(-S.kAge / 0.18)) : 0;\n  const j0 = S.kShelf ? 62 : 0, j1 = S.kShelf ? H : 62;\n  for (let i = 0; i \u003c N; i++) {\n    const x = i % W, y = floor(i / W);\n    const sx = jolt && y >= j0 && y \u003c j1 ? cl(x - jolt, 0, W - 1) : x, o = (y * W + sx) * 3;\n    display.setPixel(x, y, 4 * round(63.75 * cl(rgb[o], 0, 1)), 4 * round(63.75 * cl(rgb[o + 1], 0, 1)), 4 * round(63.75 * cl(rgb[o + 2], 0, 1)));\n  }\n}\n","zonal-jets":"// ===== Patternflow pattern =====\n// Title:   Zonal Jets\n// Family:  wave\n// Idea:    Two-dimensional turbulence stirred in small eddies on a beta plane, solved on the panel's own 64x128 grid, gathers its energy into east-west jets stacked up the panel, eastward flow red to pale amber and westward violet to sky blue, while the stream lines drawn over them close into cat's eyes between the jets and slide west as Rossby waves, three times faster than the jets carry the water east; beta sets how many jets stand, through the Rhines scale.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: beta-plane zonal jets and the Rhines scale (Peter Rhines, 1975), Rossby waves (Carl-Gustaf Rossby, 1939), pattern round 52\n// Round:   52\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beta=-1..1, Stir=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together. At 0 eastward flow runs from red through orange to pale amber and westward flow from violet through blue to pale sky blue, dark where the water is still. At 0.33 the eastward flow is green and the westward crimson to pink; at 0.67 blue and lime.\n// Knob 2: Speed. Flow time per second. At 2 the jet cores carry the water east at about 7 LEDs a second, and the pattern of stream lines on them slides west at about 20. At 1 half as fast, at 0.2 a tenth. Above 2 a frame may take a third step; when the flow is too fast for the steps a frame may take, it runs slower instead.\n// Knob 3: Beta. How fast the Coriolis parameter grows northward, 9 at 0, from 2.5 at -1 to 32 at 1. At -1 two eastward jets stand on the panel, now and then three, with big eddies between them; at 0 three or four; at 1 four to six narrow ones, and the stream lines slide west at about 48 LEDs a second. Turning it by more than 0.2 starts a fresh run at the new beta.\n// Knob 4: Stir. How hard the small eddies that feed the jets are stirred, at a wavelength of 6.4 LEDs, by a factor of 12 from one end to the other. At 0 and at the opening 0.06 the jets run smooth between round eddies; at 1 the bands fill with grainy small eddies and the jets fray.\n// Buttons: K1 tap starts a fresh run.\n\nconst W = 64, H = 128;\nconst { floor, min, max, exp, sqrt, abs, cos, sin, PI, log2, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The panel is a periodic box 2 pi wide and 4 pi tall, x to the east and y to\n// the north (up the panel), solved pseudo-spectrally the way Inverse Cascade\n// solves it, with Orszag's two-thirds rule and third-order Adams-Bashforth\n// steps of changing length. The vorticity q obeys\n//   dq/dt + J(psi, q) + beta dpsi/dx = stirring - MU q - NU (k / kmax)^8 q\n// The beta term is linear like the friction, so it goes into the integrating\n// factor with them: each mode turns round by beta kx / k^2 per unit time,\n// the westward drift of a Rossby wave.\n// Flow time per panel second at Speed 2, and the Courant number each step\n// keeps to (with |u| + |v|). At 1.0 the smallest modes flare up now and\n// then; at 0.9 they do not.\nconst RATE = 0.7, CFL = 0.9;\n// Hyperviscosity at the cut-off wavenumber, per unit time. At 12 the\n// enstrophy piled up near the cut-off in bursts, patches of ripples three\n// LEDs long; at 80 it drains away.\nconst NU = 80;\n// White-in-time stirring on a ring of wavenumbers KF +- 1, a wavelength of\n// 6.4 LEDs, injecting energy EPS per unit time at Stir 0.06; the knob scales\n// it by STR per unit of knob. Linear drag MU.\nconst KF = 10, EPS = 0.003, STR = 12, MU = 0.003;\n// beta at Beta 0, and the factor one unit of the knob multiplies it by.\nconst BM = 9, BR = 3.6;\n// A run starts from noise round wavenumber K0 with energy E0 on a grid half\n// as fine (32 x 64, stirred at KF0). It runs there for PRE units of flow\n// time before the first frame and is then carried over mode for mode to the\n// panel grid, so the jets already stand when the panel lights.\nconst KF0 = 7, K0 = 5, E0 = 1, PRE = 15;\n// The colour is the zonal velocity u with only AL of its departure from the\n// row's mean, so the eddies tint the bands without breaking them; UN of its\n// largest size reaches full colour.\nconst AL = 0.4, UN = 0.7, LUT = 512;\n// Stream lines: BANDS per largest size of psi, cut DEP deep with a cos^LP\n// profile so they stay thin.\nconst BANDS = 4, DEP = 0.6, LP = 3;\n// The hue of the strongest eastward flow at Hue 0 and how far the weak flow\n// turns from it; the brightness floor and curve.\nconst HE = 0.12, HS = 0.15, V0 = 0.25, GAM = 0.5;\n// Crossfade into a fresh run, panel seconds.\nconst FADE = 0.6;\n\n// ---- radix-2 FFT, in place on (re, im) at off, off + st, off + 2 st, ...\nfunction plan(n) {\n  const lg = log2(n), rev = new Uint16Array(n), c = new Float64Array(n >> 1), s = new Float64Array(n >> 1);\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c lg; b++) r |= ((i >> b) & 1) \u003c\u003c (lg - 1 - b);\n    rev[i] = r;\n  }\n  for (let i = 0; i \u003c n >> 1; i++) (c[i] = cos((2 * PI * i) / n)), (s[i] = sin((2 * PI * i) / n));\n  return { n, rev, c, s, br: new Float64Array(n), bi: new Float64Array(n) };\n}\nfunction fft1(P, re, im, off, st, sign) {\n  const { n, rev, c, s, br, bi } = P;\n  for (let i = 0; i \u003c n; i++) {\n    const j = off + rev[i] * st;\n    br[i] = re[j];\n    bi[i] = im[j];\n  }\n  for (let size = 2; size \u003c= n; size \u003c\u003c= 1) {\n    const half = size >> 1, step = n / size;\n    for (let a0 = 0; a0 \u003c n; a0 += size)\n      for (let k = 0, t = 0; k \u003c half; k++, t += step) {\n        const wr = c[t], wi = sign * s[t], a = a0 + k, b = a + half;\n        const xr = br[b] * wr - bi[b] * wi, xi = br[b] * wi + bi[b] * wr;\n        br[b] = br[a] - xr;\n        bi[b] = bi[a] - xi;\n        br[a] += xr;\n        bi[a] += xi;\n      }\n  }\n  for (let i = 0; i \u003c n; i++) (re[off + i * st] = br[i]), (im[off + i * st] = bi[i]);\n}\n// The y transforms run only on the columns that survive the cut.\nfunction fft2(G, re, im, sign) {\n  const { w, h, cols, px, py } = G;\n  if (sign \u003c 0) for (let y = 0; y \u003c h; y++) fft1(px, re, im, y * w, 1, sign);\n  for (let t = 0; t \u003c cols.length; t++) fft1(py, re, im, cols[t], w, sign);\n  if (sign > 0) for (let y = 0; y \u003c h; y++) fft1(px, re, im, y * w, 1, sign);\n}\n\n// One grid over the box, w x h, stirred at kf.\nfunction grid(w, h, kf) {\n  const n = w * h, kxc = floor(w / 3), kyc = floor(h / 3), F = () => new Float64Array(n);\n  const G = {\n    w, h, n, dx: (2 * PI) / w, px: plan(w), py: plan(h), cols: [],\n    kx: F(), ky: F(), k2: F(), ik2: F(), lin: F(), neg: new Int32Array(n), idx: new Int32Array(n),\n    wr: F(), wi: F(), nr: F(), ni: F(), p1r: F(), p1i: F(), p2r: F(), p2i: F(), ar: F(), ai: F(), br: F(), bi: F(), ug: F(),\n    h1: 0, h2: 0, vmax: 0.4, vs: 0.4, um: 0, Ec: new Map(),\n  };\n  for (let x = 0; x \u003c w; x++) if ((x \u003c w / 2 ? x : w - x) \u003c= kxc) G.cols.push(x);\n  const keep = [], forced = [];\n  for (let y = 0; y \u003c h; y++)\n    for (let x = 0; x \u003c w; x++) {\n      const i = y * w + x, jx = x \u003c w / 2 ? x : x - w, jy = y \u003c h / 2 ? y : y - h, k2 = jx * jx + (jy * jy) / 4;\n      G.kx[i] = jx;\n      G.ky[i] = jy / 2;\n      G.k2[i] = k2;\n      G.ik2[i] = k2 > 0 ? 1 / k2 : 0;\n      G.neg[i] = ((h - y) % h) * w + ((w - x) % w);\n      // where the same mode sits on the panel grid\n      G.idx[i] = ((jy + H) % H) * W + ((jx + W) % W);\n      const q = k2 / (kxc * kxc);\n      G.lin[i] = q * q * q * q;\n      if (abs(jx) > kxc || abs(jy) > kyc) continue;\n      keep.push(i);\n      if (abs(sqrt(k2) - kf) \u003c= 1 && (jx > 0 || (jx === 0 && jy > 0))) forced.push(i);\n    }\n  G.keep = Int32Array.from(keep);\n  G.forced = Int32Array.from(forced);\n  // A kick of +-A sqrt(h) to both parts of each forced pair adds 4 A^2 h / 3\n  // to the sum of |q^|^2, an energy of EPS h at wavenumber kf.\n  G.famp = n * sqrt((3 * EPS * kf * kf) / (2 * forced.length));\n  return G;\n}\n\n// -div(u q) for the spectrum (sr, si), into (or, oi), dealiased. One inverse\n// transform brings q and psi to the grid together as q + i psi, the velocity\n// comes from fourth-order differences of psi, and one forward transform takes\n// u q + i v q back. Leaves q, psi and u on the grid in br, bi, ug.\nfunction tendency(G, sr, si, or, oi) {\n  const { w, h, n, kx, ky, ik2, keep, neg, ar, ai, br: om, bi: ps, ug } = G, nk = keep.length, mw = w - 1, mh = h - 1;\n  om.fill(0);\n  ps.fill(0);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], r = sr[i] / n, m = si[i] / n, q = ik2[i];\n    om[i] = r + q * m;\n    ps[i] = m - q * r;\n  }\n  fft2(G, om, ps, 1);\n  const c = 1 / (12 * G.dx);\n  let vmax = 0, um = 0;\n  for (let y = 0; y \u003c h; y++) {\n    const o = y * w, u1 = ((y + 1) & mh) * w, d1 = ((y - 1) & mh) * w, u2 = ((y + 2) & mh) * w, d2 = ((y - 2) & mh) * w;\n    for (let x = 0; x \u003c w; x++) {\n      const r1 = (x + 1) & mw, l1 = (x - 1) & mw, r2 = (x + 2) & mw, l2 = (x - 2) & mw;\n      const u = -c * (8 * (ps[u1 + x] - ps[d1 + x]) - (ps[u2 + x] - ps[d2 + x]));\n      const v = c * (8 * (ps[o + r1] - ps[o + l1]) - (ps[o + r2] - ps[o + l2]));\n      const q = om[o + x];\n      ug[o + x] = u;\n      ar[o + x] = u * q;\n      ai[o + x] = v * q;\n      const sp = abs(u) + abs(v);\n      if (sp > vmax) vmax = sp;\n    }\n  }\n  fft2(G, ar, ai, -1);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], j = neg[i], cr = ar[i], ci = ai[i], dr = ar[j], di = ai[j], a = kx[i], b = ky[i];\n    or[i] = 0.5 * (a * (ci - di) - b * (cr - dr));\n    oi[i] = -0.5 * (a * (cr + dr) + b * (ci + di));\n  }\n  return vmax;\n}\n\n// One AB3 step of length h with the linear terms in a complex integrating\n// factor (kept for a few step lengths at a time), then the stirring kick.\nfunction step(G, S, h) {\n  const { wr, wi, nr, ni, p1r, p1i, p2r, p2i, lin, kx, ik2, keep } = G, nk = keep.length;\n  G.vmax = tendency(G, wr, wi, nr, ni);\n  const key = h * 1e6 + S.beta;\n  let E = G.Ec.get(key);\n  if (!E) {\n    if (G.Ec.size > 8) G.Ec.clear();\n    E = new Float64Array(2 * G.n);\n    for (let t = 0; t \u003c nk; t++) {\n      const i = keep[t], d = exp(-h * (NU * lin[i] + MU)), th = h * S.beta * kx[i] * ik2[i];\n      E[2 * i] = d * cos(th);\n      E[2 * i + 1] = d * sin(th);\n    }\n    G.Ec.set(key, E);\n  }\n  const h1 = G.h1, h2 = G.h2;\n  let c0 = h, c1 = 0, c2 = 0;\n  if (h1 && h2) {\n    const a = (h * h * h) / 3, b = (h * h) / 2;\n    c0 = (a + (2 * h1 + h2) * b + h1 * (h1 + h2) * h) / (h1 * (h1 + h2));\n    c1 = -(a + (h1 + h2) * b) / (h1 * h2);\n    c2 = (a + h1 * b) / ((h1 + h2) * h2);\n  } else if (h1) (c0 = h * (1 + h / (2 * h1))), (c1 = -(h * h) / (2 * h1));\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], er = E[2 * i], ei = E[2 * i + 1];\n    const xr = wr[i] + c0 * nr[i] + c1 * p1r[i] + c2 * p2r[i], xi = wi[i] + c0 * ni[i] + c1 * p1i[i] + c2 * p2i[i];\n    wr[i] = er * xr - ei * xi;\n    wi[i] = er * xi + ei * xr;\n    let ar = p1r[i], ai = p1i[i];\n    p2r[i] = er * ar - ei * ai;\n    p2i[i] = er * ai + ei * ar;\n    ar = nr[i];\n    ai = ni[i];\n    p1r[i] = er * ar - ei * ai;\n    p1i[i] = er * ai + ei * ar;\n  }\n  const A = G.famp * sqrt(h * S.stir), F = G.forced, NG = G.neg;\n  for (let t = 0; t \u003c F.length; t++) {\n    const i = F[t], j = NG[i], a = (Math.random() * 2 - 1) * A, b = (Math.random() * 2 - 1) * A;\n    wr[i] += a;\n    wi[i] += b;\n    wr[j] += a;\n    wi[j] -= b;\n  }\n  G.h2 = h1;\n  G.h1 = h;\n}\n\n// The step: n steps from a ladder 16 to an octave, as long as the Courant\n// number allows, so the integrating factors come back.\nfunction ladder(G, adv, most) {\n  G.vs = max(G.vmax, G.vs * 0.98);\n  const hmax = (CFL * G.dx) / max(1e-6, G.vs), n = min(most, Math.ceil(adv / hmax));\n  return [n, pow(2, floor(16 * log2(min(adv / n, hmax))) / 16)];\n}\n\n// A fresh run: noise round K0 on the coarse grid, spun up, carried over.\nfunction start(S) {\n  const C = S.G0, G = S.G, { wr, wi, k2, keep, n } = C;\n  wr.fill(0);\n  wi.fill(0);\n  for (let i = 0; i \u003c n; i++) wr[i] = Math.random() * 2 - 1;\n  fft2(C, wr, wi, -1);\n  const on = new Uint8Array(n);\n  for (let t = 0; t \u003c keep.length; t++) on[keep[t]] = 1;\n  let e = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const q = k2[i] / (K0 * K0), a = on[i] && k2[i] > 0 ? q * exp(-q) : 0;\n    wr[i] *= a;\n    wi[i] *= a;\n    if (k2[i] > 0) e += (wr[i] * wr[i] + wi[i] * wi[i]) / k2[i];\n  }\n  const g = sqrt(E0 / ((0.5 * e) / (n * n)));\n  for (let i = 0; i \u003c n; i++) (wr[i] *= g), (wi[i] *= g);\n  C.h1 = C.h2 = 0;\n  for (let t = 0; t \u003c PRE; ) {\n    const [, h] = ladder(C, 1, 1);\n    step(C, S, h);\n    t += h;\n  }\n  const s = G.n / n;\n  G.wr.fill(0);\n  G.wi.fill(0);\n  for (let t = 0; t \u003c keep.length; t++) {\n    const i = keep[t], j = C.idx[i];\n    G.wr[j] = wr[i] * s;\n    G.wi[j] = wi[i] * s;\n  }\n  G.h1 = G.h2 = 0;\n  G.vs = C.vs;\n  G.vmax = C.vmax;\n  tendency(G, G.wr, G.wi, G.nr, G.ni);\n  S.b0 = S.k3;\n  S.runs++;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, k3: 0, b0: 0, beta: BM, stir: 1, runs: 0, fade: 0, usc: 0, psc: 0, palHue: -1,\n    G: grid(W, H, KF), G0: grid(W / 2, H / 2, KF0), zm: new Float64Array(H),\n    pal: new Float32Array(2 * LUT * 3), lines: new Float32Array(256), old: new Uint8Array(W * H * 3), cur: new Uint8Array(W * H * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, G = S.G, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.k3 = cl(k[2], -1, 1);\n  S.beta = BM * pow(BR, S.k3);\n  S.stir = pow(STR, cl(k[3], 0, 1) - 0.06);\n  const ft = cl(dt || 0, 0, 0.1);\n  if (!S.runs) start(S);\n  else if ((input.btnPressed && input.btnPressed[0]) || abs(S.k3 - S.b0) > 0.2) {\n    S.old.set(S.cur);\n    S.fade = 1;\n    start(S);\n  }\n  S.fade = max(0, S.fade - ft / FADE);\n  const adv = (ft * S.speed * RATE) / 2;\n  if (adv \u003c= 0) return;\n  const [n, h] = ladder(G, adv, S.speed > 2 ? 3 : 2);\n  for (let j = 0; j \u003c n; j++) step(G, S, h);\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Zonal velocity to colour: the upper half of the table is eastward flow,\n// red through orange to pale amber, the lower half westward, violet through\n// blue to pale sky blue, both dark where the flow is still.\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  const T = S.pal, c = [0, 0, 0];\n  for (let j = 0; j \u003c 2 * LUT; j++) {\n    const east = j >= LUT, a = east ? (j - LUT) / (LUT - 1) : (LUT - 1 - j) / (LUT - 1);\n    hsv(S.hue + (east ? HE : HE + 0.42) + (east ? -HS : HS) * pow(1 - a, 1.2), 1 - 0.5 * a * a * a, 1, c);\n    const v = 255 * (V0 + (1 - V0) * pow(a, GAM));\n    T[j * 3] = v * c[0];\n    T[j * 3 + 1] = v * c[1];\n    T[j * 3 + 2] = v * c[2];\n  }\n  for (let j = 0; j \u003c 256; j++) S.lines[j] = 1 - DEP * pow(0.5 + 0.5 * cos((2 * PI * j) / 256), LP);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.runs) return;\n  palette(S);\n  const G = S.G, { ug, bi: ps } = G, { pal: T, lines: L, zm, cur, old } = S;\n  let pm = 0, um = 0;\n  for (let y = 0; y \u003c H; y++) {\n    let a = 0;\n    for (let x = 0, o = y * W; x \u003c W; x++) {\n      a += ug[o + x];\n      if (abs(ps[o + x]) > pm) pm = abs(ps[o + x]);\n    }\n    zm[y] = a / W;\n  }\n  // The scales follow the flow slowly, so a strong eddy does not flash.\n  S.psc = S.psc ? S.psc + (pm - S.psc) * 0.05 : pm;\n  if (!S.usc) for (let i = 0; i \u003c G.n; i++) S.usc = max(S.usc, abs(zm[i >> 6] + AL * (ug[i] - zm[i >> 6])));\n  const iu = (LUT - 1) / max(1e-6, S.usc * UN), ip = (256 * BANDS) / max(1e-6, S.psc), f = S.fade, g = 1 - f;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, u = zm[y] + AL * (ug[i] - zm[y]), j = 3 * (LUT + cl(round(u * iu), -LUT, LUT - 1)), l = L[(ps[i] * ip + 1e6) & 255], o = 3 * ((H - 1 - y) * W + x);\n      if (abs(u) > um) um = abs(u);\n      cur[o] = T[j] * l;\n      cur[o + 1] = T[j + 1] * l;\n      cur[o + 2] = T[j + 2] * l;\n    }\n  S.usc = S.usc ? S.usc + (um - S.usc) * 0.05 : um;\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) {\n      if (f > 0) display.setPixel(x, y, cur[o] * g + old[o] * f, cur[o + 1] * g + old[o + 1] * f, cur[o + 2] * g + old[o + 2] * f);\n      else display.setPixel(x, y, cur[o], cur[o + 1], cur[o + 2]);\n    }\n}\n","bat-form":"// ===== Patternflow pattern =====\n// Title:   Bat Form\n// Family:  halloween\n// Idea:    In the tall pointed window of a dark tower room a vampire stands black against a crimson and orange dusk, raises his arms so his cape spreads into a wide sail, shrinks as the cape's hem breaks into the scallops of a bat's wings, flies a loop out into the sky and back to the sill, and grows into the vampire again and folds his cape, while far bats circle over the hills.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cape=-1..1, Flock=0..1\n//\n// Knob 1: Hue. The dusk: overhead it stays purple, and the glow over the hills walks back round the wheel from gold at 0 through red at 0.15, magenta at 0.3, violet at 0.45 and blue at 0.6 to teal at 0.8 and lime green at 1. The vampire stays black, his eyes red and his cape's lining dark crimson.\n// Knob 2: Speed. At 2 one change takes 10 seconds: his arms rise from 0.25 s and the cape is wide by 1.15 s, he shrinks into the bat from 2 to 3.7 s, the bat beats its wings four to five times a second, flies its loop from 3.4 to 7.6 s and lands, he is a man again by 8.9 s and has folded the cape by 9.7 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Cape. How far the cape opens, and with it the bat's wings: at -1 the open cape is 25 LEDs across and the wings 25; at 0, where it opens, 43 and 45; at 1 the cape is 62 across, spilling over the jambs, and the wings span the panel.\n// Knob 4: Flock. How many far bats circle high in the sky and low over the hills, hazed a little toward the sky so the vampire stays the blackest thing: none at 0, 7 at 0.06 where it opens, 60 at 0.5 and a swarm of 120 at 1.\n// Buttons: K1 tap while he stands starts the change now; tapped while he folds his cape, he opens it again.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst lerp = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The window: an equilateral pointed arch over straight jambs, its sill a\n// ledge across the room. The vampire's chest stands at PX, PY.\nconst WX0 = 7, WX1 = 57, SPRING = 50, SILL = 104, SPAN = WX1 - WX0, TOP = SPRING - SPAN * 0.866;\nconst G0 = 1.15, PX = 32, PY = SILL - 30 * G0;\nconst inWindow = (x, y) => y \u003c= SILL && x >= WX0 && x \u003c= WX1 && (y >= SPRING || (Math.hypot(x - WX1, y - SPRING) \u003c= SPAN && Math.hypot(x - WX0, y - SPRING) \u003c= SPAN));\n// The dusk from the top of the window to the hills: height, how far the\n// hue has gone from the purple overhead toward the hue over the hills,\n// saturation and value.\nconst DUSK = [[0, 0, 0.85, 0.36], [0.3, 0.24, 0.85, 0.52], [0.55, 0.52, 0.85, 0.7], [0.78, 0.76, 0.9, 0.95], [0.9, 0.91, 0.85, 1], [1, 1, 0.7, 1]];\n// The far hills: their top per column.\nconst HILL = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) HILL[x] = 99.5 + 1.6 * sin(x * 0.11 + 1) + 1.2 * sin(x * 0.31) + 0.6 * sin(x * 0.9);\n// Two dead trees on the hills as line segments [x0, y0, x1, y1].\nconst TREES = [];\nfor (const [bx, h, s] of [[13, 12, 1], [51, 9, -1]]) {\n  const by = HILL[bx];\n  TREES.push([bx, by, bx + 0.5 * s, by - h], [bx + 0.3 * s, by - 0.55 * h, bx + 3.5 * s, by - 0.85 * h], [bx + 0.4 * s, by - 0.75 * h, bx - 2.5 * s, by - h - 1], [bx + 2 * s, by - 0.7 * h, bx + 3 * s, by - 0.6 * h - 3]);\n}\n\n// Three poses of the right half of the figure, in LEDs, feet at (0, 0) and\n// up negative; the left half mirrors it. head: centre and radius. collar:\n// inner and outer foot and the tip; it rises into the bat's ear. sh, waist,\n// hip, foot: the body's side. arm: shoulder, elbow, wrist. tips: the cape's\n// hem, which becomes the trailing edge of the wing, and att where the\n// membrane meets the body; dep is how deep the scallops between them are.\nconst CLOSED = {\n  head: [0, -40.5, 3.6], collar: [2.4, -36.6, 6.2, -35.4, 7.4, -46.5],\n  sh: [5.6, -35.4], waist: [4, -22], hip: [4.2, -19.5], foot: [2.6, 0],\n  arm: [5.4, -35.4, 7.2, -26, 8.4, -16], tips: [11.2, -1.6, 8.2, -1, 5.2, -0.8, 2.6, -0.8], att: [0.4, -0.8], dep: 0.12,\n};\nconst SPREAD = {\n  head: [0, -40.5, 3.6], collar: [2.4, -36.6, 6.2, -35.4, 7.4, -46.5],\n  sh: [5.6, -35.4], waist: [4, -22], hip: [4.2, -19.5], foot: [3.4, 0],\n  arm: [5.6, -35.4, 12.5, -40.5, 18.5, -45.5], tips: [20.5, -24, 16.5, -10.5, 11, -4.5, 5.6, -2], att: [1.6, -2.4], dep: 0.22,\n};\nconst BAT = {\n  head: [0, -33.6, 2.6], collar: [0.5, -35.4, 2.6, -34.3, 2.6, -39.8],\n  sh: [2.3, -31.3], waist: [1.9, -27.5], hip: [1.5, -25.8], foot: [1, -23],\n  arm: [2.3, -31.3, 8.5, -35.6, 14.5, -37], tips: [27, -30.5, 21.5, -26.6, 15, -25.2, 8.5, -26.6], att: [2.3, -27], dep: 0.5,\n};\nconst mixPose = (A, B, t, o) => {\n  for (const k in A) o[k] = typeof A[k] === \"number\" ? lerp(A[k], B[k], t) : A[k].map((v, i) => lerp(v, B[k][i], t));\n  return o;\n};\n\n// Small bats far over the hills: orbit centre, radii, speed and phase,\n// half span and wing beat.\nconst FLOCK = [];\nfor (let i = 0; i \u003c 120; i++) {\n  const r = (k) => hash(i * 7 + k);\n  // Most fly high, where the cape never covers them; each orbit fits the\n  // arch at its height.\n  const cy = r(11) \u003c 0.7 ? 14 + 44 * r(2) : 60 + 32 * r(2), half = (cy >= SPRING ? SPAN : sqrt(SPAN * SPAN - (cy - SPRING) ** 2)) - SPAN / 2 - 3;\n  const rx = min(half * 0.6, 3 + 9 * r(3));\n  FLOCK.push({ cx: 32 + (2 * r(1) - 1) * max(0, half - rx), cy, rx, ry: 2 + 4 * r(4), w: (r(5) \u003c 0.5 ? -1 : 1) * (0.5 + 0.8 * r(6)), ph: TAU * r(7), s: 3 + 4.4 * r(8) ** 2, f: 9 + 6 * r(9), fp: TAU * r(10) });\n}\n\n// A small bat's right half, half span 1, from the top of the head round to\n// the middle of its belly: x, y and how far the beat lifts the point.\nconst MINI = [0, -0.36, 0, 0.1, -0.4, 0, 0.16, -0.66, 0, 0.24, -0.34, 0, 0.5, -0.5, 1, 1, -0.3, 1.4, 0.84, -0.04, 1.1, 0.7, 0.04, 0.9, 0.6, -0.06, 0.8, 0.44, 0.12, 0.6, 0.34, 0, 0.4, 0.2, 0.18, 0.2, 0.1, 0.32, 0, 0, 0.34, 0];\n\n// One change in story seconds at Speed 2.\nconst CYCLE = 10;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, clock: 0, hue: 0, speed: 2, cape: 0, flock: 0.06, key: \"\", btn: false, flap: 0, spread: 0, m: 0, lift: 0, fly: 0, beat: 0,\n    base: new Float32Array(N * 3), buf: new Float32Array(N * 3), win: new Uint8Array(N), covB: new Float32Array(N), covM: new Float32Array(N),\n    pose: {}, pts: new Float64Array(64), xs: [], col: new Float32Array(3),\n  };\n}\n\n// The room, the window and the dusk, kept until Hue moves.\nfunction background(S) {\n  const { base, win } = S, c = S.col, hue = S.hue;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), cx = x + 0.5, cy = y + 0.5;\n    win[p] = inWindow(cx, cy) ? 1 : 0;\n  }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), cx = x + 0.5, cy = y + 0.5, o = 3 * p;\n    if (win[p]) {\n      sky(hue, (cy - TOP) / (SILL - TOP), c);\n      let [r, g, b] = c;\n      // The jamb: a band just inside the opening where the stone is lit.\n      let edge = 9;\n      for (let dy = -2; dy \u003c= 2; dy++)\n        for (let dx = -2; dx \u003c= 2; dx++) {\n          const xx = x + dx, yy = y + dy;\n          if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || !win[yy * W + xx]) edge = min(edge, max(abs(dx), abs(dy)));\n        }\n      if (edge \u003c= 2 && cy \u003c SILL - 0.5) {\n        const k = edge === 1 ? 0.42 : 0.62;\n        (r = r * k + 0.04), (g = g * k + 0.02), (b = b * k + 0.06);\n      }\n      // The hills and their trees, dark against the glow.\n      if (cy > HILL[x]) [r, g, b] = cy - HILL[x] \u003c 1 ? [r * 0.35, g * 0.25, b * 0.4] : [0.05, 0.02, 0.07];\n      base[o] = r;\n      base[o + 1] = g;\n      base[o + 2] = b;\n    } else {\n      // The room: dark stone in courses, warmed near the window, the sill's\n      // top edge lit.\n      const near = max(0, 1 - distWin(cx, cy) / 14);\n      const course = (y % 6 === 5) || ((x + (floor(y / 6) % 2) * 5) % 10 === 0) ? 0.55 : 1;\n      sky(hue, 0.55, c);\n      let k = (0.06 + 0.16 * near * near) * course;\n      let r = 0.05 * course + c[0] * k, g = 0.02 * course + c[1] * k, b = 0.08 * course + c[2] * k;\n      if (y >= SILL && y \u003c SILL + 6 && x >= WX0 - 3 && x \u003c= WX1 + 3) {\n        sky(hue, 0.95, c);\n        const top = y === SILL ? 0.75 : y === SILL + 1 ? 0.3 : y \u003c SILL + 4 ? 0.12 : 0.07;\n        (r = c[0] * top + 0.03), (g = c[1] * top + 0.01), (b = c[2] * top + 0.05);\n      }\n      base[o] = r;\n      base[o + 1] = g;\n      base[o + 2] = b;\n    }\n  }\n  for (const [x0, y0, x1, y1] of TREES) {\n    const n = ceil(max(abs(x1 - x0), abs(y1 - y0)) * 2);\n    for (let i = 0; i \u003c= n; i++) {\n      const x = floor(lerp(x0, x1, i / n)), y = floor(lerp(y0, y1, i / n)), o = 3 * (y * W + x);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) base.set([0.05, 0.02, 0.07], o);\n    }\n  }\n}\n// Rough distance from (x, y) to the window opening.\nfunction distWin(x, y) {\n  if (y > SILL) return Math.hypot(max(0, WX0 - x, x - WX1), y - SILL);\n  if (y >= SPRING) return max(0, WX0 - x, x - WX1);\n  return max(0, Math.hypot(x - (x \u003c 32 ? WX1 : WX0), y - SPRING) - SPAN, WX0 - x, x - WX1);\n}\nfunction sky(hue, t, out) {\n  t = cl(t, 0, 1);\n  let i = 0;\n  while (i \u003c DUSK.length - 2 && t > DUSK[i + 1][0]) i++;\n  const A = DUSK[i], B = DUSK[i + 1], u = (t - A[0]) / (B[0] - A[0]);\n  // Over the hills gold at Hue 0, walking back through red, magenta,\n  // violet and blue to green at 1; overhead always purple, so the dim top\n  // never turns brown.\n  const low = 1.12 - 0.85 * hue;\n  hsv(0.79 + (low - 0.79) * lerp(A[1], B[1], u), lerp(A[2], B[2], u), lerp(A[3], B[3], u), out, 0);\n}\n\n// Coverage of a polygon added into cov: four sub-rows per LED, the span\n// ends shared out by area, nonzero winding.\nfunction fill(S, cov, P, n) {\n  let y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c n; i++) (y0 = min(y0, P[2 * i + 1])), (y1 = max(y1, P[2 * i + 1]));\n  const s0 = max(0, floor(y0 * 4)), s1 = min(4 * H - 1, ceil(y1 * 4)), xs = S.xs;\n  for (let sy = s0; sy \u003c= s1; sy++) {\n    const y = (sy + 0.5) / 4, row = floor(y) * W;\n    xs.length = 0;\n    for (let i = 0, j = n - 1; i \u003c n; j = i++) {\n      const ay = P[2 * j + 1], by = P[2 * i + 1];\n      if (ay \u003c= y !== by \u003c= y) {\n        const ax = P[2 * j], bx = P[2 * i];\n        xs.push(ax + ((y - ay) / (by - ay)) * (bx - ax), by > ay ? 1 : -1);\n      }\n    }\n    // Sort the crossings by x (a few, so insertion sort).\n    for (let i = 2; i \u003c xs.length; i += 2) {\n      const vx = xs[i], vd = xs[i + 1];\n      let j = i - 2;\n      while (j >= 0 && xs[j] > vx) (xs[j + 2] = xs[j]), (xs[j + 3] = xs[j + 1]), (j -= 2);\n      xs[j + 2] = vx;\n      xs[j + 3] = vd;\n    }\n    let wind = 0, from = 0;\n    for (let i = 0; i \u003c xs.length; i += 2) {\n      const before = wind;\n      wind += xs[i + 1];\n      if (before === 0) from = xs[i];\n      else if (wind === 0) span(cov, row, from, xs[i], 0.25);\n    }\n  }\n}\nfunction span(cov, row, xa, xb, w) {\n  xa = max(xa, 0);\n  xb = min(xb, W);\n  if (xb \u003c= xa) return;\n  const ia = floor(xa), ib = floor(xb);\n  if (ia === ib) {\n    cov[row + ia] += (xb - xa) * w;\n    return;\n  }\n  cov[row + ia] += (ia + 1 - xa) * w;\n  for (let x = ia + 1; x \u003c ib; x++) cov[row + x] += w;\n  if (ib \u003c W) cov[row + ib] += (xb - ib) * w;\n}\n\n// Where the story is at story time t: the spread s (0 cape closed, 1 arms\n// up and the cape wide), the change m (0 man, 1 bat), the flight f along its\n// loop, the lift off the sill and the wing beat's strength.\nfunction story(S) {\n  const t = S.t;\n  S.spread = t \u003c 5 ? ease((t - 0.25) / 0.9) : 1 - ease((t - 8.9) / 0.8);\n  S.m = t \u003c 5 ? ease((t - 2) / 1.7) : 1 - ease((t - 7.8) / 1.1);\n  S.lift = ease((t - 2.9) / 0.8) - ease((t - 7.6) / 0.5);\n  S.fly = ease((t - 3.4) / 4.2);\n  S.beat = ease((t - 2.3) / 0.8) * (1 - ease((t - 8) / 0.7));\n}\n\n// The figure's outline for the current story, into covB (body) and covM\n// (cape and wings), and the eyes.\nfunction figure(S) {\n  const wC = 0.92 + 0.4 * S.cape, m = S.m, mb = ease((m - 0.15) / 0.85), mw = ease(m / 0.85);\n  const A = mixPose(CLOSED, SPREAD, S.spread, S.pa || (S.pa = {}));\n  // The arm swings up through its angles, keeping its length, so the cape\n  // opens like a wing instead of being pulled flat.\n  const c0 = CLOSED.arm, c1 = SPREAD.arm, ang = (q, i) => Math.atan2(q[i + 3] - q[i + 1], q[i + 2] - q[i]), len = (q, i) => Math.hypot(q[i + 2] - q[i], q[i + 3] - q[i + 1]);\n  for (let i = 0; i \u003c 4; i += 2) {\n    const th = lerp(ang(c0, i), ang(c1, i), S.spread), l = lerp(len(c0, i), len(c1, i), S.spread);\n    A.arm[i + 2] = A.arm[i] + l * cos(th);\n    A.arm[i + 3] = A.arm[i + 1] + l * sin(th);\n  }\n  const Pz = mixPose(A, BAT, mw, S.pose);\n  // The body changes a little behind the wings.\n  for (const k of [\"head\", \"sh\", \"waist\", \"hip\", \"foot\"]) Pz[k] = A[k].map((v, i) => lerp(v, BAT[k][i], mb));\n  // Cape: the arms and hem reach wider with the knob, more so once spread.\n  const wx = lerp(1 + 0.6 * (wC - 1), wC, max(S.spread, m));\n  // Where the chest is, how big the figure is and how it leans.\n  const f = S.fly, a = TAU * f, depth = 1 - 0.6 * sin(PI * f) ** 2;\n  const g = G0 * lerp(1, 0.78, mb) * depth, cx = PX + 13 * sin(a), cy = PY - 4 * S.lift - 22 * (1 - cos(a)), bank = 0.32 * sin(a) * sin(PI * f);\n  // Out past the window the wall hides what strays beyond the opening.\n  S.clip = depth \u003c 0.97;\n  const flap = S.beat * 0.55 * sin(S.flap), cb = cos(bank), sb = sin(bank);\n  const pt = (x, y, side) => {\n    // local (feet at 0, chest at -30) to the panel.\n    const lx = side * x, ly = y + 30;\n    return [cx + g * (cb * lx - sb * ly), cy + g * (sb * lx + cb * ly)];\n  };\n  const P = S.pts;\n  S.box = [99, -99, 999, -99];\n  const poly = (cov, list) => {\n    for (let i = 0; i \u003c list.length; i++) {\n      P[2 * i] = list[i][0];\n      P[2 * i + 1] = list[i][1];\n      S.box[0] = min(S.box[0], list[i][0]);\n      S.box[1] = max(S.box[1], list[i][0]);\n      S.box[2] = min(S.box[2], list[i][1]);\n      S.box[3] = max(S.box[3], list[i][1]);\n    }\n    fill(S, cov, P, list.length);\n  };\n  for (const side of [1, -1]) {\n    // Wing: arm then hem, turned about the shoulder by the beat.\n    const [sx, sy] = Pz.sh, ca = cos(flap), sa = sin(flap);\n    const rot = (x, y, ch = 1) => {\n      const dx = x * wx - sx, dy = (y - sy) * ch;\n      return [sx + ca * dx + sa * dy, sy - sa * dx + ca * dy];\n    };\n    // The arms lift the sail higher as well as wider with the knob.\n    const up = lerp(1, 1 + 0.22 * S.cape, max(S.spread, m));\n    const ar = Pz.arm, el = rot(ar[2], ar[3], up), wr = rot(ar[4], ar[5], up);\n    const T = [];\n    // The hem stirs in the draught from the window while the cape is wide.\n    const stir = 0.9 * S.spread * (1 - mw);\n    const ch = lerp(1, 1 + 0.2 * S.cape, mw);\n    for (let i = 0; i \u003c 4; i++) T.push(rot(Pz.tips[2 * i] + stir * sin(S.clock * 2.3 + i * 1.7 + side), Pz.tips[2 * i + 1] + stir * 0.6 * sin(S.clock * 1.9 + i * 2.3), ch));\n    T.push(Pz.att);\n    const out = [[sx, sy - 1.2], el, wr, T[0]];\n    for (let i = 0; i \u003c 4; i++) {\n      // A scallop from tip i to i + 1, bowed toward the shoulder.\n      const [x0, y0] = T[i], [x1, y1] = T[i + 1], mx = (x0 + x1) / 2, my = (y0 + y1) / 2, L = Math.hypot(x1 - x0, y1 - y0);\n      const ux = sx - mx, uy = sy - my, ul = Math.hypot(ux, uy) || 1, d = Pz.dep * L;\n      const qx = mx + (ux / ul) * d, qy = my + (uy / ul) * d;\n      for (let k = 1; k \u003c= 4; k++) {\n        const u = k / 4, v = 1 - u;\n        out.push([v * v * x0 + 2 * u * v * qx + u * u * x1, v * v * y0 + 2 * u * v * qy + u * u * y1]);\n      }\n    }\n    poly(S.covM, out.map(([x, y]) => pt(x, y, side)));\n    // Arm bones over the membrane.\n    const arm = (a0, a1, r0, r1) => {\n      const dx = a1[0] - a0[0], dy = a1[1] - a0[1], l = Math.hypot(dx, dy) || 1, nx = -dy / l, ny = dx / l;\n      poly(S.covB, [[a0[0] + nx * r0, a0[1] + ny * r0], [a1[0] + nx * r1, a1[1] + ny * r1], [a1[0] - nx * r1, a1[1] - ny * r1], [a0[0] - nx * r0, a0[1] - ny * r0]].map(([x, y]) => pt(x, y, side)));\n    };\n    const thick = lerp(1.3, 0.75, mw);\n    arm([sx, sy], el, thick * 1.2, thick);\n    arm(el, wr, thick, thick * 0.8);\n    // Collar, rising into the ear.\n    const c = Pz.collar;\n    poly(S.covB, [[c[0], c[1]], [c[2], c[3]], [c[4], c[5]]].map(([x, y]) => pt(x, y, side)));\n    // Body side: neck, shoulder, waist, hip, leg to the foot, and the\n    // middle line back up.\n    const hd = Pz.head, nk = hd[1] + hd[2] * 0.7;\n    poly(S.covB, [[0, nk], [hd[2] * 0.45, nk], [Pz.sh[0], Pz.sh[1]], [Pz.waist[0], Pz.waist[1]], [Pz.hip[0], Pz.hip[1]], [Pz.foot[0] + 0.9, Pz.foot[1]], [Pz.foot[0] - 1.6 * (1 - mb) - 0.3, Pz.foot[1]], [0.4, Pz.hip[1] + 1.5 * (1 - mb)], [0, Pz.hip[1] + 1.5 * (1 - mb)]].map(([x, y]) => pt(x, y, side)));\n  }\n  // Head.\n  const hd = Pz.head, circ = [];\n  for (let i = 0; i \u003c 14; i++) circ.push(pt(hd[0] + hd[2] * cos((TAU * i) / 14), hd[1] + hd[2] * sin((TAU * i) / 14), 1));\n  poly(S.covB, circ);\n  // Eyes, while it faces the room.\n  const away = sin(PI * f) > 0.35;\n  S.eyes = away ? null : [pt(hd[2] * 0.36, hd[1] - 0.2, 1), pt(hd[2] * 0.36, hd[1] - 0.2, -1)];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.cape = cl(k[2], -1, 1);\n  S.flock = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  // A tap while he stands starts the change. While he folds the cape he\n  // opens it again from the same width: the fold is the spread run\n  // backwards, so the time that matches is a mirror image.\n  if (btn && !S.btn) {\n    if (S.t \u003c 0.25) S.t = 0.25;\n    else if (S.t >= 8.9) S.t = 0.25 + 0.9 * (1 - cl((S.t - 8.9) / 0.8, 0, 1));\n  }\n  S.btn = btn;\n  S.t = (S.t + ds) % CYCLE;\n  S.clock += ds;\n  S.flap += ds * TAU * (4.2 + 1.2 * S.beat * (1 - S.fly));\n  story(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.hue.toFixed(3);\n  if (key !== S.key) {\n    S.key = key;\n    background(S);\n  }\n  const { base, buf, win, covB, covM } = S;\n  buf.set(base);\n  // Thin clouds drifting across the dusk.\n  for (let y = floor(TOP); y \u003c 92; y++)\n    for (let x = WX0; x \u003c= WX1; x++) {\n      const p = y * W + x;\n      if (!win[p]) continue;\n      let c = 0;\n      for (let i = 0; i \u003c 3; i++) {\n        const yc = 24 + 21 * i + 2 * sin(x * 0.08 + i * 2 + S.clock * 0.1), dy = (y - yc) / (1.2 + 0.6 * i);\n        const patch = 0.5 + 0.5 * sin((x + S.clock * (1.2 + 0.4 * i)) * (0.13 + 0.03 * i) + i * 4);\n        c += exp(-dy * dy) * patch;\n      }\n      if (c > 0.02) {\n        const o = 3 * p, k = 1 - 0.45 * min(1, c);\n        buf[o] *= k;\n        buf[o + 1] *= k;\n        buf[o + 2] *= k * 0.95 + 0.05 * c;\n      }\n    }\n  // Small bats against the sky, seen only through the window: a filled\n  // outline each, the wings lifted and dropped by the beat.\n  const nb = round(120 * S.flock), sb = S.covM, P = S.pts;\n  sb.fill(0);\n  for (let i = 0; i \u003c nb; i++) {\n    // Each flutters off its orbit in small jerks, as bats do.\n    const b = FLOCK[i], a = b.ph + b.w * S.clock * 0.9, c = S.clock * b.f * 0.37 + b.fp;\n    const x = b.cx + b.rx * cos(a) + 1.2 * sin(c) * sin(2.3 * c), y = b.cy + b.ry * sin(a) + 1.4 * sin(1.7 * c + 1) * sin(0.9 * c);\n    const lift = -0.5 * sin(b.f * S.clock + b.fp);\n    let n = 0;\n    for (const sd of [1, -1])\n      for (let j = 0; j \u003c MINI.length; j += 3) {\n        const k = sd > 0 ? j : MINI.length - 3 - j, lx = MINI[k], ly = MINI[k + 1] + MINI[k + 2] * lift;\n        P[2 * n] = x + sd * lx * b.s;\n        P[2 * n + 1] = y + ly * b.s;\n        n++;\n      }\n    fill(S, sb, P, n);\n  }\n  if (nb)\n    for (let p = 0; p \u003c N; p++) {\n      const a = min(1, sb[p]);\n      if (a \u003c= 0 || !win[p]) continue;\n      // Hazed a little toward the sky, so they stay apart from the black\n      // figure in front of them.\n      const o = 3 * p;\n      buf[o] += (0.2 * base[o] + 0.01 - buf[o]) * a;\n      buf[o + 1] += (0.2 * base[o + 1] - buf[o + 1]) * a;\n      buf[o + 2] += (0.2 * base[o + 2] + 0.02 - buf[o + 2]) * a;\n    }\n  // The vampire or the bat.\n  covB.fill(0);\n  covM.fill(0);\n  figure(S);\n  const bx0 = max(0, floor(S.box[0]) - 1), bx1 = min(W - 1, ceil(S.box[1]) + 1), by0 = max(0, floor(S.box[2]) - 1), by1 = min(H - 1, ceil(S.box[3]) + 1);\n  // The cape's lining shows dark crimson while it is spread, and goes as it\n  // becomes a wing.\n  const lin = 0.16 * S.spread * (1 - ease(S.m / 0.6)), lining = [lin, lin * 0.05, lin * 0.12];\n  for (let y = by0; y \u003c= by1; y++)\n    for (let x = bx0; x \u003c= bx1; x++) {\n      const p = y * W + x, cb = min(1, covB[p]), cm = min(1, covM[p]), a = max(cb, cm);\n      if (a \u003c= 0 || (S.clip && !win[p])) continue;\n      const o = 3 * p, fr = 0.02 * (1 - cb) + 0.015, fg = 0.008, fbl = 0.03;\n      const lr = lining[0] * (1 - cb), lg = lining[1] * (1 - cb), lb = lining[2] * (1 - cb);\n      buf[o] += (fr + lr - buf[o]) * a;\n      buf[o + 1] += (fg + lg - buf[o + 1]) * a;\n      buf[o + 2] += (fbl + lb - buf[o + 2]) * a;\n    }\n  if (S.eyes) {\n    const glow = 0.6 + 0.4 * sin(S.clock * 3);\n    for (const [ex, ey] of S.eyes) {\n      const x = floor(ex), y = floor(ey);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = 3 * (y * W + x);\n      buf[o] = glow;\n      buf[o + 1] = 0.05 * glow;\n      buf[o + 2] = 0.04 * glow;\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      display.setPixel(x, y, round(cl(buf[o], 0, 1) * 255), round(cl(buf[o + 1], 0, 1) * 255), round(cl(buf[o + 2], 0, 1) * 255));\n    }\n}\n","calabi-yau":"// ===== Patternflow pattern =====\n// Title:   Calabi-Yau Quintic\n// Family:  space\n// Idea:    The complex curve z1^5 + z2^5 = 1, a slice of the quintic Calabi-Yau, built from Andrew Hanson's 25 patches and projected into space, turns slowly on black with each patch in its own colour, so the seams show where the patches join and where five of them fan in to one point.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Calabi-Yau manifolds (Eugenio Calabi, 1954; Shing-Tung Yau, 1977), the Fermat quintic slice drawn after Andrew J. Hanson (1994), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Angle=-45..45, Spread=0..1\n//\n// Knob 1: Hue. Turns every patch round the wheel together. A patch takes its hue from k1, the fifth root of unity in front of z1, and a small shift from k2: at 0 the five k1 families are cyan, violet, rose, orange and green.\n// Knob 2: Speed. At 2 the surface turns once about its upright axis in 24 seconds and nods 18 degrees up and down every 16; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Angle. The projection angle alpha, in degrees from Hanson's 45. The upright axis shows cos(alpha) Im z1 + sin(alpha) Im z2, so at -45 it is Im z1 alone and at 45 Im z2 alone, and the whole surface reshapes as the knob turns.\n// Knob 4: Spread. An exploded view: each patch moves out from the centre along the line to its own middle, stretched 1.8 times up and down and 0.8 times across so the pieces use the panel's height. Whole at 0.06, 25 separate pieces at 1.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, sqrt, sin, cos, atan2, hypot, abs, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Grid of one patch: NU steps across x in [-A, A], NV across y in [0, pi/2].\nconst NU = 24, NV = 12, VU = NU + 1, VV = NV + 1, PV = VU * VV, NP = 25 * PV, A = 1.1;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Hanson's patch (k1, k2) at z = x + iy:\n// z1 = e^(2 pi i k1/5) cosh(z)^(2/5), z2 = e^(2 pi i k2/5) (-i sinh z)^(2/5),\n// principal branches, so z1^5 + z2^5 = cosh^2 z - sinh^2 z = 1.\nfunction point(k1, k2, x, y, out, o) {\n  const cr = Math.cosh(x) * cos(y), ci = Math.sinh(x) * sin(y);\n  const sr = Math.sinh(x) * cos(y), si = Math.cosh(x) * sin(y);\n  // -i sinh z\n  const mr = si, mi = -sr;\n  const r1 = pow(hypot(cr, ci), 0.4), a1 = 0.4 * atan2(ci, cr) + (TAU * k1) / 5;\n  const r2 = pow(hypot(mr, mi), 0.4), a2 = 0.4 * atan2(mi, mr) + (TAU * k2) / 5;\n  out[o] = r1 * cos(a1);\n  out[o + 1] = r1 * sin(a1);\n  out[o + 2] = r2 * cos(a2);\n  out[o + 3] = r2 * sin(a2);\n}\n\nexport function setup(params) {\n  const F = (n) => new Float32Array(n);\n  const s = {\n    t: 0, yaw: 0.6, hue: 0, alpha: PI / 4, spread: 0.06,\n    // Re z1, Im z1, Re z2, Im z2 for every grid point of every patch.\n    z: F(NP * 4), cen: F(25 * 4),\n    px: F(NP), py: F(NP), pz: F(NP), sx: F(NP), sy: F(NP), nx: F(NP), ny: F(NP), nz: F(NP),\n    zb: F(N), id: new Int16Array(N), wa: F(N), wb: F(N), tv: new Int32Array(N), col: F(N * 3),\n    pal: F(25 * 3), palHue: -1,\n  };\n  // The grid crowds toward x = 0 and toward both ends of y, where the\n  // patches meet at the points z2 = 0 and z1 = 0 and the 2/5 power stretches them.\n  const gx = F(VU), gy = F(VV);\n  for (let i = 0; i \u003c VU; i++) {\n    const u = (2 * i) / NU - 1;\n    gx[i] = A * Math.sign(u) * pow(abs(u), 1.7);\n  }\n  for (let j = 0; j \u003c VV; j++) gy[j] = (PI / 4) * (1 - cos((PI * j) / NV));\n  for (let p = 0; p \u003c 25; p++) {\n    const k1 = (p / 5) | 0, k2 = p % 5;\n    for (let j = 0; j \u003c VV; j++)\n      for (let i = 0; i \u003c VU; i++) {\n        const v = p * PV + j * VU + i;\n        point(k1, k2, gx[i], gy[j], s.z, v * 4);\n        for (let c = 0; c \u003c 4; c++) s.cen[p * 4 + c] += s.z[v * 4 + c] / PV;\n      }\n  }\n  params.s = s;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.alpha = ((45 + cl(k[2], -45, 45)) * PI) / 180;\n  s.spread = cl(k[3], 0, 1);\n  s.t += d * sp;\n  s.yaw += d * sp * 0.13;\n}\n\nfunction palette(s) {\n  for (let p = 0; p \u003c 25; p++) {\n    const k1 = (p / 5) | 0, k2 = p % 5;\n    hsv(s.hue + 0.5 + 0.2 * k1 + 0.035 * (k2 - 2), 0.62 + 0.07 * k2, 1, s.pal, p * 3);\n  }\n  s.palHue = s.hue;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  if (s.palHue !== s.hue) palette(s);\n  const { z, cen, px, py, pz, sx, sy, nx, ny, nz, zb, id, wa, wb, tv, col, pal } = s;\n  const ca = cos(s.alpha), sa = sin(s.alpha);\n  // The turn about the upright (projected) axis and a slow nod.\n  const cy = cos(s.yaw), sy0 = sin(s.yaw), el = 0.32 * sin(s.t * 0.19), ce = cos(el), se = sin(el);\n  const sc = 19.5 / (1 + 0.25 * s.spread), CX = 31.5, CY = 64, CAM = 8;\n  const sp = s.spread;\n  for (let p = 0; p \u003c 25; p++) {\n    // The patch's own middle, turned like the rest; the exploded view moves\n    // the patch out along it, 1.8 times as far up and down and 0.8 across.\n    const X = cen[p * 4] * sp, Y = cen[p * 4 + 2] * sp, Z = (ca * cen[p * 4 + 1] + sa * cen[p * 4 + 3]) * sp;\n    const xr = X * cy - Y * sy0, yr = X * sy0 + Y * cy;\n    const ox = xr * 0.8, oz = (yr * se + Z * ce) * 1.8, oy = yr * ce - Z * se;\n    for (let v = p * PV, e = v + PV; v \u003c e; v++) {\n      const X = z[v * 4], Y = z[v * 4 + 2], Z = ca * z[v * 4 + 1] + sa * z[v * 4 + 3];\n      // Yaw about the upright axis, then the nod about the screen's x axis.\n      const xr = X * cy - Y * sy0, yr = X * sy0 + Y * cy;\n      const yy = yr * ce - Z * se + oy, zz = yr * se + Z * ce + oz, xx = xr + ox;\n      px[v] = xx;\n      py[v] = zz;\n      pz[v] = yy;\n      const f = (sc * CAM) / (CAM + yy);\n      sx[v] = CX + f * xx;\n      sy[v] = CY - f * zz;\n    }\n  }\n  // Normals from the grid's neighbours.\n  for (let p = 0; p \u003c 25; p++)\n    for (let j = 0; j \u003c VV; j++)\n      for (let i = 0; i \u003c VU; i++) {\n        const v = p * PV + j * VU + i;\n        const a = i > 0 ? v - 1 : v, b = i \u003c NU ? v + 1 : v, c = j > 0 ? v - VU : v, e = j \u003c NV ? v + VU : v;\n        const ux = px[b] - px[a], uy = py[b] - py[a], uz = pz[b] - pz[a];\n        const wx = px[e] - px[c], wy = py[e] - py[c], wz = pz[e] - pz[c];\n        const qx = uy * wz - uz * wy, qy = uz * wx - ux * wz, qz = ux * wy - uy * wx;\n        const l = 1 / (sqrt(qx * qx + qy * qy + qz * qz) + 1e-12);\n        nx[v] = qx * l;\n        ny[v] = qy * l;\n        nz[v] = qz * l;\n      }\n  zb.fill(1e9);\n  id.fill(-1);\n  for (let p = 0; p \u003c 25; p++)\n    for (let j = 0; j \u003c NV; j++)\n      for (let i = 0; i \u003c NU; i++) {\n        const v = p * PV + j * VU + i;\n        tri(s, v, v + 1, v + VU + 1, p);\n        tri(s, v, v + VU + 1, v + VU, p);\n      }\n  // Shade into col.\n  const LX = -0.5, LY = 0.6, LZ = -0.62, HZ = LZ - 1, HL = 1 / sqrt(LX * LX + LY * LY + HZ * HZ);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, p = id[q], o = q * 3;\n      if (p \u003c 0) {\n        col[o] = col[o + 1] = col[o + 2] = 0;\n        continue;\n      }\n      const t0 = tv[q], a = wa[q], b = wb[q], c = 1 - a - b;\n      const v0 = t0 & 0x3fff, v1 = v0 + ((t0 >> 14) & 0xff), v2 = v0 + ((t0 >> 22) & 0xff);\n      let mx = nx[v0] * c + nx[v1] * a + nx[v2] * b, my = ny[v0] * c + ny[v1] * a + ny[v2] * b, mz = nz[v0] * c + nz[v1] * a + nz[v2] * b;\n      const l = 1 / (sqrt(mx * mx + my * my + mz * mz) + 1e-12);\n      mx *= l;\n      my *= l;\n      mz *= l;\n      // Two-sided: the eye looks along +depth, so a normal is turned to face it.\n      if (mz > 0) (mx = -mx), (my = -my), (mz = -mz);\n      const ld = max(0, mx * LX + my * LY + mz * LZ), hh = max(0, (mx * LX + my * LY + mz * HZ) * HL);\n      const spc = pow(hh, 30) * 0.5;\n      // The far side dims a quarter; light falls off toward an indigo shade\n      // rather than toward black, so a turned-away yellow reads violet, not olive.\n      const fog = 1 - 0.25 * cl((zb[q] + 1.6) / 3.2, 0, 1), lit = (0.1 + 0.9 * ld) * fog, sh = (1 - ld) * 0.22 * fog;\n      const r = pal[p * 3] * lit + 0.35 * sh + spc, g = pal[p * 3 + 1] * lit + 0.12 * sh + spc, bb = pal[p * 3 + 2] * lit + sh + spc;\n      // Seams: an LED beside another patch, joined to it or passing in front, is dimmed.\n      const rp = x \u003c W - 1 ? id[q + 1] : p, dp = y \u003c H - 1 ? id[q + W] : p;\n      const k = (rp >= 0 && rp !== p) || (dp >= 0 && dp !== p) ? 127 : 255;\n      col[o] = min(255, r * k);\n      col[o + 1] = min(255, g * k);\n      col[o + 2] = min(255, bb * k);\n    }\n  // An empty LED on the outline takes a third of its lit neighbours'\n  // light, which softens the stairs of the edge against black.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3;\n      if (id[q] >= 0) {\n        display.setPixel(x, y, col[o], col[o + 1], col[o + 2]);\n        continue;\n      }\n      let r = 0, g = 0, b = 0;\n      for (const n of [x > 0 ? q - 1 : -1, x \u003c W - 1 ? q + 1 : -1, y > 0 ? q - W : -1, y \u003c H - 1 ? q + W : -1])\n        if (n >= 0 && id[n] >= 0) (r += col[n * 3]), (g += col[n * 3 + 1]), (b += col[n * 3 + 2]);\n      display.setPixel(x, y, r * 0.09, g * 0.09, b * 0.09);\n    }\n}\n\n// One triangle into the depth buffer, keeping the barycentric weights of\n// the nearest surface at each LED centre.\nfunction tri(s, i0, i1, i2, p) {\n  const { sx, sy, pz, zb, id, wa, wb, tv } = s;\n  const x0 = sx[i0], y0 = sy[i0], x1 = sx[i1], y1 = sy[i1], x2 = sx[i2], y2 = sy[i2];\n  const den = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);\n  if (abs(den) \u003c 1e-9) return;\n  const inv = 1 / den;\n  let xa = min(x0, x1, x2), xb = max(x0, x1, x2), ya = min(y0, y1, y2), yb = max(y0, y1, y2);\n  const X0 = max(0, Math.ceil(xa - 0.5)), X1 = min(W - 1, floor(xb - 0.5)), Y0 = max(0, Math.ceil(ya - 0.5)), Y1 = min(H - 1, floor(yb - 0.5));\n  if (X0 > X1 || Y0 > Y1) return;\n  const z0 = pz[i0], z1 = pz[i1], z2 = pz[i2];\n  const pack = i0 | ((i1 - i0) \u003c\u003c 14) | ((i2 - i0) \u003c\u003c 22);\n  for (let y = Y0; y \u003c= Y1; y++) {\n    const cy = y + 0.5 - y0;\n    for (let x = X0; x \u003c= X1; x++) {\n      const cx = x + 0.5 - x0;\n      const a = (cx * (y2 - y0) - cy * (x2 - x0)) * inv, b = ((x1 - x0) * cy - (y1 - y0) * cx) * inv;\n      if (a \u003c -1e-6 || b \u003c -1e-6 || a + b > 1 + 1e-6) continue;\n      const d = z0 + (z1 - z0) * a + (z2 - z0) * b, q = y * W + x;\n      if (d \u003c zb[q]) (zb[q] = d), (id[q] = p), (wa[q] = a), (wb[q] = b), (tv[q] = pack);\n    }\n  }\n}\n","grimoire":"// ===== Patternflow pattern =====\n// Title:   Grimoire\n// Family:  halloween\n// Idea:    A spellbook lies open on a lectern in a dark tower room beside a flickering candle, and a ghostly draft turns its pages by itself, each sheet lifting and curling over, catching the candle light before it lands; on every new spread a toxic-green sigil draws itself stroke by stroke, then its glyphs peel off the page one by one and rise up the dark as green sparks and wisps that fade near the top.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wind=0..1, Glow=0..1\n//\n// Knob 1: Hue. The colour of the magic, round the whole wheel: toxic green at 0, sky blue at 0.25, violet at 0.5, ember orange at 0.75 and green again at 1. The dark of the room moves from purple at 0 through indigo to deep teal at 1. The candle and the paper stay warm.\n// Knob 2: Speed. At 2 the first page lifts at 0.5 s, a slow page takes 1.6 seconds to cross, a sigil draws in 1.4 seconds and burns for 2.6 while its glyphs rise; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Wind. At 0 one slow page turns every 7.8 seconds and the candle stands nearly straight; at 1 the draft riffles seven pages over in 1.1 seconds every 5.9 seconds and lifts the free edge of the next page while it waits. The flame leans and gutters with the draft, and the rising glyphs drift right.\n// Knob 4: Glow. How bright the sigil burns: at 0 a thin line and a dim green light on the pages, at the opening 0.06 a little more. At 1 the sigil blazes and lights the room green, throwing four times the sparks, and every rising glyph trails a thick wisp.\n// Buttons: K1 tap sends a gust that riffles pages now.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The book in its own frame: x across the spread from the gutter (a page\n// is PW wide), y down the page from its middle (PH tall), z up off the\n// paper. The lectern tilts it toward us; the eye looks down at it.\nconst GX = 32, YC = 87, PW = 27, PH = 44, CA = cos(0.92), SA = sin(0.92);\n// The rise of the paper out of the gutter.\nconst zp = (x) => 2.4 * (1 - (1 - min(1, abs(x) / 12)) ** 2);\n// Book frame to the panel, with a little perspective: the near edge is wider.\nfunction proj(x, y, z, out) {\n  const k = 1 + 0.005 * (y * SA + z * CA);\n  // Seen a little from the right, so a standing sheet is not edge on.\n  out[0] = GX + (x + 0.3 * z) * k;\n  out[1] = YC + (y * CA - z * SA) * k;\n  out[2] = y * SA + z * CA;\n}\n// The candle: its flame on the panel and in the book frame.\nconst FX = 9, FY = 53, CANDLE = [-25, -27, 22];\n// The sigil hovers flat at ZS over the paper; its middle on the panel.\nconst ZS = 3, SGX = GX + 0.3 * ZS, SGY = YC - ZS * SA;\n\n// Light from the candle on a surface with normal n at book point p.\nfunction lambert(px, py, pz, nx, ny, nz) {\n  let lx = CANDLE[0] - px, ly = CANDLE[1] - py, lz = CANDLE[2] - pz;\n  const d = sqrt(lx * lx + ly * ly + lz * lz);\n  return max(0, (lx * nx + ly * ny + lz * nz) / d) / (1 + (d * d) / 2500);\n}\n\n// Ink on a page: lines of words with margins, laid out by the page's\n// number. u runs from the gutter out, v down the page, both 0..1.\nfunction ink(page, u, v) {\n  if (u \u003c 0.12 || u > 0.9 || v \u003c 0.08 || v > 0.93) return 0;\n  const yy = v * PH, line = floor(yy / 3.4);\n  if (yy - line * 3.4 > 1.3) return 0;\n  const sd = page * 131 + line * 17, xx = u * PW;\n  // A short last line now and then, and a blank line between paragraphs.\n  if (hash(sd) \u003c 0.12 || xx > PW * (0.9 - (hash(sd + 1) \u003c 0.25 ? 0.5 * hash(sd + 2) : 0))) return 0;\n  const word = floor(xx / 3.2 + hash(sd + 3) * 3);\n  return (xx / 3.2 + hash(sd + 3) * 3) % 1 \u003c 0.78 - 0.25 * hash(sd + word) ? 1 : 0;\n}\nconst PAPER = [1, 0.82, 0.56], INKC = [0.5, 0.31, 0.22];\n\n// Where every LED of the lying spread is on the paper, found once by\n// scattering fine samples: page x and y, how much of the LED is paper, and\n// the candle light on it.\nconst SPX = new Float32Array(N), SPY = new Float32Array(N), SPC = new Float32Array(N), SPL = new Float32Array(N);\n{\n  const o = [0, 0, 0], n = new Float32Array(N);\n  for (let x = -PW + 0.15; x \u003c PW; x += 0.3)\n    for (let y = -PH / 2 + 0.15; y \u003c PH / 2; y += 0.3) {\n      proj(x, y, zp(x), o);\n      const p = floor(o[1]) * W + floor(o[0]);\n      SPX[p] += x;\n      SPY[p] += y;\n      n[p]++;\n    }\n  for (let p = 0; p \u003c N; p++)\n    if (n[p]) {\n      (SPX[p] /= n[p]), (SPY[p] /= n[p]);\n      SPC[p] = min(1, n[p] / 9);\n      const x = SPX[p], s = (zp(x + 0.1) - zp(x - 0.1)) / 0.2, l = sqrt(1 + s * s);\n      // Darker into the gutter, where the paper turns away and down.\n      SPL[p] = lambert(x, SPY[p], zp(x), -s / l, 0, 1 / l) * (0.55 + 0.45 * min(1, abs(x) / 5));\n    }\n}\n\n// The room, the lectern, the book's cover and the candle's wax, as an\n// unlit colour and how much candle light each LED takes, built per Hue.\nconst WALL = 0, WOOD = 1, COVER = 2, WAX = 3, EDGE = 4;\nconst KIND = new Uint8Array(N), CLF = new Float32Array(N), GLF = new Float32Array(N);\n{\n  const o = [0, 0, 0], cov = new Uint8Array(N);\n  // The cover: the pages' outline grown by 1.6 and pushed 2 down.\n  for (let x = -PW - 1.6; x \u003c PW + 1.6; x += 0.3)\n    for (let y = -PH / 2 - 1.6; y \u003c PH / 2 + 1.6; y += 0.3) {\n      proj(x, y, -1.2, o);\n      cov[floor(o[1]) * W + floor(o[0])] = 1;\n    }\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), dx = x + 0.5 - FX, dy = y + 0.5 - FY;\n    let k = WALL;\n    // The lectern: the slanted board under the book, its front edge, a\n    // turned post and a foot.\n    const post = abs(x + 0.5 - GX) \u003c 4.5 - 1.6 * sin(((y - 104) / 6) * PI) ** 2 && y >= 104;\n    if ((y >= 98 && y \u003c 104 && abs(x + 0.5 - GX) \u003c 29 - (y - 98) * 0.5) || post || (y >= 121 && abs(x + 0.5 - GX) \u003c 16 - (y - 121) * 0.3)) k = WOOD;\n    if (y === 103 && k === WOOD) k = EDGE;\n    if (cov[p] || SPC[p] > 0) k = COVER;\n    // The candle stands behind the book's top left corner.\n    if (abs(x + 0.5 - FX) \u003c 1.8 && y >= FY + 4 && y \u003c 74 && !cov[p] && !SPC[p]) k = WAX;\n    KIND[p] = k;\n    const r = sqrt(dx * dx + dy * dy);\n    CLF[p] = k === WAX ? 0.9 - (y - FY - 4) * 0.035 : 1 / (1 + (r * r) / (k === WALL ? 200 : 380)) * (k === WOOD && x \u003c GX ? 1.3 : 1);\n    // The sigil's light: strong on the spread, rising up the wall above it.\n    const gx = (x + 0.5 - SGX) / 34, gy = (y + 0.5 - SGY) / (y \u003c SGY ? 46 : 18);\n    GLF[p] = exp(-(gx * gx + gy * gy) * 2);\n  }\n}\nfunction scene(S) {\n  const room = hsv(0.78 - 0.3 * S.hue, 0.7, 1), A = S.amb, L = S.lit;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), k = KIND[p];\n    let a, l;\n    if (k === WALL) {\n      // Rough stone blocks of uneven length, the dark gathering toward the top.\n      const row = floor(y / 7);\n      let bx = -floor(hash(row) * 9), i = 0;\n      while (bx + 7 + floor(hash(row * 31 + i) * 7) \u003c= x) bx += 7 + floor(hash(row * 31 + i++) * 7);\n      const mortar = y % 7 === 0 || x === bx, v = (mortar ? 0.55 : 0.8 + 0.2 * hash(row * 53 + i)) * (0.6 + 0.4 * min(1, y / 80));\n      a = room.map((c) => c * 0.19 * v);\n      l = [(0.72 + 0.1 * room[0]) * v, (0.42 + 0.1 * room[1]) * v, (0.24 + 0.1 * room[2]) * v];\n    } else if (k === WOOD || k === EDGE) {\n      const grain = 0.85 + 0.15 * sin(x * 0.7 + y * 0.2);\n      a = [0.09 * grain, 0.035, 0.08 * grain];\n      l = k === EDGE ? [0.85, 0.5, 0.25] : [0.5 * grain, 0.24 * grain, 0.14];\n    } else if (k === COVER) {\n      a = [0.09, 0.02, 0.1];\n      l = [0.42, 0.14, 0.2];\n    } else {\n      a = [0.12, 0.1, 0.08];\n      l = [1, 0.85, 0.6];\n    }\n    for (let c = 0; c \u003c 3; c++) (A[3 * p + c] = a[c]), (L[3 * p + c] = l[c] * CLF[p]);\n  }\n}\n\n// Tiny invented glyphs, 3x3, row by row from the top left.\nconst GLYPH = [0b111010010, 0b101010101, 0b110011001, 0b010101010, 0b111101001, 0b100111001, 0b011100011, 0b101111101, 0b110010011, 0b001010111, 0b010111100, 0b111001110];\n\n// A new sigil: an outer ring, a ring of glyphs, an inner ring, a polygon or\n// star in it and a small eye in the middle, as strokes in book coordinates\n// drawn in that order. Each stroke is a list of points; glyphs are points.\nfunction sigil(seed) {\n  const r = (i) => hash(seed * 97 + i), circle = (R, a0) => {\n    const pts = [];\n    for (let i = 0; i \u003c= 64; i++) pts.push([R * cos(a0 + (TAU * i) / 64), R * sin(a0 + (TAU * i) / 64)]);\n    return pts;\n  };\n  const a0 = r(1) * TAU, forms = [[3, 1], [4, 1], [7, 2], [7, 3], [8, 3], [5, 1], [6, 1], [9, 4]], [n, m] = forms[floor(r(2) * 8)];\n  const star = [];\n  for (let i = 0; i \u003c= n; i++) star.push([12.5 * cos(a0 + (TAU * i * m) / n), 12.5 * sin(a0 + (TAU * i * m) / n)]);\n  const ng = 8 + floor(r(3) * 4), glyphs = [];\n  for (let i = 0; i \u003c ng; i++) glyphs.push({ x: 16.5 * cos(a0 + (TAU * i) / ng), y: 16.5 * sin(a0 + (TAU * i) / ng), g: floor(r(10 + i) * GLYPH.length), gone: false });\n  const strokes = [circle(20.5, a0), null, circle(13.5, a0 + PI), star, circle(3, 0)];\n  // Lengths, so the pen can run along them at one speed; the glyph ring\n  // counts as one more stroke, a glyph every 4 units.\n  const len = strokes.map((s) => {\n    if (!s) return ng * 4;\n    let l = 0;\n    for (let i = 1; i \u003c s.length; i++) l += Math.hypot(s[i][0] - s[i - 1][0], s[i][1] - s[i - 1][1]);\n    return l;\n  });\n  return { strokes, glyphs, len, total: len.reduce((a, b) => a + b, 0) };\n}\n\nexport function setup(params) {\n  params.s = {\n    fresh: true, t: 0, hue: 0, speed: 2, wind: 0, glow: 0.06, key: \"\", prevBtn: false,\n    phase: \"turn\", pt: -0.5, pages: [], page: 0, leftPage: -1, sg: sigil(1), sgA: 0, draw: 1, flick: 1, lean: 0,\n    risers: [], sparks: [], amb: new Float32Array(N * 3), lit: new Float32Array(N * 3),\n    buf: new Float32Array(N * 3), zb: new Float32Array(N), mg: new Float32Array(N), ws: new Float32Array(N), o: [0, 0, 0],\n  };\n}\n\n// The pages that turn at once: one slow sheet in a calm, a riffle in a gale.\nfunction startTurn(S, gust) {\n  const w = gust ? max(S.wind, 0.6) : S.wind, n = 1 + round(6 * w * w), dur = 1.6 - 1.1 * w, gap = dur * (0.32 - 0.12 * w);\n  S.pages = [];\n  for (let i = 0; i \u003c n; i++) S.pages.push({ start: i * gap, dur, num: S.page + i });\n  S.page += n;\n  S.phase = \"turn\";\n  S.pt = 0;\n}\n\n// A glyph leaves the page and rises.\nfunction rise(S, x, y, g) {\n  S.risers.push({ x, y, vx: (Math.random() - 0.5) * 4, vy: -11 - 7 * Math.random(), g, age: 0, ph: Math.random() * TAU });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.glow = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  if (S.fresh) {\n    // The night is already going: the last sigil's glyphs are on their way\n    // up and its light is dying on the page.\n    S.fresh = false;\n    for (let i = 0, n = 7 + round(5 * S.glow); i \u003c n; i++) {\n      rise(S, SGX + (Math.random() - 0.5) * 34, SGY - 4 - Math.random() * 8, floor(Math.random() * GLYPH.length));\n      const r = S.risers[i], a = 0.4 + 2.6 * Math.random();\n      for (let s = 0; s \u003c a; s += 0.05) step(S, r, 0.05);\n    }\n    S.sgA = 1;\n    for (const g of S.sg.glyphs) g.gone = true;\n    S.pages = [{ start: 0, dur: 1.6 - 1.1 * S.wind, num: 0 }];\n    S.page = 1;\n  }\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.prevBtn && !(S.phase === \"turn\" && S.pt \u003c 0.3)) {\n    for (const g of S.sg.glyphs) if (!g.gone && S.phase !== \"turn\") (g.gone = true), rise(S, ...glyphAt(S, g));\n    startTurn(S, true);\n  }\n  S.prevBtn = btn;\n  S.pt += ds;\n  // The story: turn the pages, draw the sigil, burn it and let it fade, rest, then turn again.\n  if (S.phase === \"turn\") {\n    S.sgA = max(0, S.sgA - ds * 1.3);\n    for (const p of S.pages) if (S.pt > p.start + p.dur) S.leftPage = max(S.leftPage, p.num * 2 + 1);\n    if (S.pages.every((p) => S.pt > p.start + p.dur)) (S.phase = \"draw\"), (S.pt = 0), (S.draw = 0), (S.sg = sigil(S.page * 7 + 3)), (S.sgA = 1), (S.pages = []);\n  } else if (S.phase === \"draw\") {\n    S.draw = min(1, S.pt / 1.4);\n    if (S.pt > 1.4) (S.phase = \"burn\"), (S.pt = 0);\n  } else if (S.phase === \"burn\") {\n    // The glyphs peel off one by one round the ring.\n    const gs = S.sg.glyphs;\n    gs.forEach((g, i) => {\n      if (!g.gone && S.pt > 0.3 + (2 * i) / gs.length) (g.gone = true), rise(S, ...glyphAt(S, g));\n    });\n    if (S.pt > 2.6) (S.phase = \"fade\"), (S.pt = 0);\n  } else if (S.phase === \"fade\") {\n    S.sgA = 1 - S.pt / 0.6;\n    if (S.pt > 0.6) (S.phase = \"rest\"), (S.pt = 0), (S.sgA = 0);\n  } else if (S.pt > 1.6 - 1.4 * S.wind) startTurn(S, false);\n  // Sparks fly off a burning sigil and off the pen.\n  const burning = S.phase === \"burn\" ? 1 : S.phase === \"draw\" ? 0.5 : 0;\n  const want = burning * ds * (10 + 30 * S.glow);\n  for (let i = 0, n = floor(want) + (Math.random() \u003c want % 1 ? 1 : 0); i \u003c n; i++) {\n    const a = Math.random() * TAU, r = Math.random() \u003c 0.5 ? 20.5 : 13.5;\n    proj(r * cos(a), r * sin(a), ZS, S.o);\n    S.sparks.push({ x: S.o[0], y: S.o[1], vx: (Math.random() - 0.5) * 6, vy: -18 - 14 * Math.random(), age: 0, life: 0.6 + Math.random() });\n  }\n  for (const r of S.risers) step(S, r, ds);\n  S.risers = S.risers.filter((r) => r.y > -4);\n  for (const s of S.sparks) (s.x += (s.vx + 10 * S.wind) * ds), (s.y += s.vy * ds), (s.age += ds);\n  S.sparks = S.sparks.filter((s) => s.age \u003c s.life);\n  // The flame: flicker and the draft's lean.\n  // The draft bows the flame and makes it gutter.\n  S.flick = 0.84 - 0.24 * S.wind + (0.08 + 0.12 * S.wind) * sin(S.t * 13) + 0.06 * sin(S.t * 31 + 1) + 0.05 * (Math.random() - 0.5);\n  S.lean = S.wind * (1.6 + 0.8 * sin(S.t * 3.1)) + 0.4 * sin(S.t * 2.3);\n  // The wisps fade.\n  const f = exp(-ds / 0.55);\n  for (let p = 0; p \u003c N; p++) S.ws[p] *= f;\n}\n\n// A rising glyph: up with a sway, drifting with the wind, leaving a wisp.\nfunction step(S, r, ds) {\n  r.age += ds;\n  r.vy *= 1 - 0.15 * ds;\n  r.x += (r.vx + 5 * sin(r.age * 2.2 + r.ph) + 12 * S.wind) * ds;\n  r.y += r.vy * ds;\n  const x = floor(r.x), y = floor(r.y) + 2;\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) S.ws[y * W + x] = min(1.4, S.ws[y * W + x] + (0.25 + 0.5 * S.glow) * ds * 8);\n}\n\n// Where a glyph of the sigil sits on the panel, and which it is.\nfunction glyphAt(S, g) {\n  proj(g.x, g.y, ZS, S.o);\n  return [S.o[0], S.o[1], g.g];\n}\n\n// One turning sheet as fine samples: its section bends from the gutter\n// (angle th0) to the free edge (th1), lifting off the right-hand pile and\n// landing on the left. The face toward us shows text and takes the candle\n// light; a glint runs across it as it faces the flame.\nfunction sheet(S, pg, u) {\n  const { buf, zb, o } = S;\n  const th0 = PI * ease(u), bend = 0.8 * sin(TAU * u) + 0.25 * S.wind * sin(S.t * 9) * sin(PI * u);\n  const th1 = cl(th0 + bend, 0.03, PI - 0.03), lift = 1 - sin(PI * u);\n  let x = 0, z = 0;\n  const NS = 54, ds = PW / NS;\n  for (let i = 0; i \u003c NS; i++) {\n    const s = (i + 0.5) / NS, th = th0 + (th1 - th0) * s ** 1.6, c = cos(th), sn = sin(th);\n    x += c * ds;\n    z += sn * ds;\n    const zz = z + zp(x) * lift + 0.3, front = th \u003c PI / 2;\n    // Normal of the face we see, and its light.\n    const nx = front ? -sn : sn, nz = front ? c : -c;\n    const li = lambert(x, 0, zz, nx, 0, nz), glint = li > 0 ? max(0, nx * -0.55 + nz * 0.83) ** 24 : 0;\n    const lv = 0.38 + 1.6 * li * S.flick;\n    const side = front ? pg.num * 2 : pg.num * 2 + 1, uu = s;\n    for (let y = -PH / 2 + 0.25; y \u003c PH / 2; y += 0.5) {\n      proj(x, y, zz, o);\n      const px = floor(o[0]), py = floor(o[1]);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px;\n      if (o[2] \u003c zb[p]) continue;\n      zb[p] = o[2];\n      const k = ink(side, uu, (y + PH / 2) / PH), edge = s > 0.97 || abs(y) > PH / 2 - 0.6 ? 0.8 : 1;\n      for (let ch = 0; ch \u003c 3; ch++) buf[3 * p + ch] = (k ? INKC[ch] : PAPER[ch]) * min(1.15, lv) * edge + glint * 0.45;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.hue.toFixed(3);\n  if (key !== S.key) (S.key = key), scene(S);\n  const { buf, amb, lit, mg, ws, zb, sg, o } = S, fl = S.flick, mc = hsv(0.3 + S.hue, 0.8, 1);\n  const burn = S.sgA * (S.phase === \"burn\" ? 1 + 0.25 * sin(S.t * 17) : S.phase === \"draw\" ? 0.6 + 0.4 * S.draw : 0.8);\n  const gl = burn * (0.08 + 0.92 * S.glow);\n  // Room, lectern, cover and candle wax, lit by the flame and the sigil.\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3)\n    for (let c = 0; c \u003c 3; c++) buf[q + c] = amb[q + c] + lit[q + c] * fl + mc[c] * GLF[p] * gl * 0.8;\n  // The lying spread: the left page shows the back of the last sheet that\n  // turned, the right one the next sheet.\n  const left = S.leftPage, right = S.page * 2;\n  for (let p = 0; p \u003c N; p++) {\n    const cv = SPC[p];\n    if (!cv) continue;\n    const x = SPX[p], pg = x \u003c 0 ? left : right;\n    const k = ink(pg, abs(x) / PW, (SPY[p] + PH / 2) / PH), lv = 0.22 + 1.7 * SPL[p] * fl, q = 3 * p;\n    for (let c = 0; c \u003c 3; c++) {\n      const v = (k ? INKC[c] : PAPER[c]) * lv + mc[c] * GLF[p] * gl * 0.6;\n      buf[q + c] += (v - buf[q + c]) * cv;\n    }\n  }\n  // The next sheet flutters in the draft, under the hovering sigil.\n  zb.fill(-1e9);\n  if (S.wind > 0.05 && S.phase !== \"turn\") sheet(S, { num: S.page }, 0.05 * S.wind * (0.7 + 0.3 * sin(S.t * 7) * sin(S.t * 2.9)));\n  // The sigil: strokes up to where the pen is, each LED a bright line with a glow.\n  mg.fill(0);\n  if (S.sgA > 0) {\n    let budget = (S.phase === \"draw\" ? S.draw : 1) * sg.total, pen = null;\n    sg.strokes.forEach((st, si) => {\n      if (budget \u003c= 0) return;\n      if (!st) {\n        sg.glyphs.forEach((g, i) => {\n          if (budget > i * 4 && !g.gone) {\n            const [gx, gy, gi] = glyphAt(S, g);\n            for (let b = 0; b \u003c 9; b++) if ((GLYPH[gi] >> (8 - b)) & 1) put(mg, floor(gx) - 1 + (b % 3), floor(gy) - 1 + floor(b / 3), 1);\n          }\n        });\n        budget -= sg.len[si];\n        return;\n      }\n      let l = 0;\n      for (let i = 1; i \u003c st.length && l \u003c budget; i++) {\n        const [ax, ay] = st[i - 1], [bx, by] = st[i], sl = Math.hypot(bx - ax, by - ay);\n        for (let f = 0; f \u003c sl && l + f \u003c budget; f += 0.45) {\n          const x = ax + ((bx - ax) * f) / sl, y = ay + ((by - ay) * f) / sl;\n          proj(x, y, ZS, o);\n          put(mg, floor(o[0]), floor(o[1]), 1);\n          pen = [o[0], o[1]];\n        }\n        l += sl;\n      }\n      budget -= sg.len[si];\n    });\n    const a = S.sgA * (0.55 + 0.45 * S.glow), core = [0.3 + 0.7 * mc[0], 0.3 + 0.7 * mc[1], 0.3 + 0.7 * mc[2]];\n    for (let y = 60; y \u003c 104; y++)\n      for (let x = 1; x \u003c W - 1; x++) {\n        const p = y * W + x, m = mg[p], h = (mg[p - 1] + mg[p + 1] + mg[p - W] + mg[p + W]) * 0.25 + (mg[p - W - 1] + mg[p - W + 1] + mg[p + W - 1] + mg[p + W + 1]) * 0.12;\n        if (!m && !h) continue;\n        for (let c = 0; c \u003c 3; c++) {\n          const q = 3 * p + c;\n          buf[q] = m ? buf[q] + (core[c] * min(1, burn + 0.2) - buf[q]) * min(1, a * 1.6) : buf[q] + mc[c] * h * a * 0.6;\n        }\n      }\n    // The pen: a white-hot point where the line is being drawn.\n    if (pen && S.phase === \"draw\") glow(buf, pen[0], pen[1], [1, 1, 0.9], 1.8, 1);\n  }\n  // Turning sheets, over the spread and its sigil.\n  zb.fill(-1e9);\n  for (const pg of S.pages) {\n    const u = (S.pt - pg.start) / pg.dur;\n    if (u > 0 && u \u003c 1) sheet(S, pg, u);\n  }\n  // The candle flame, leaning with the draft, and its halo.\n  const lean = S.lean, fh = 6 + 1.2 * sin(S.t * 9) + 0.6 * (fl - 0.82) * 5;\n  for (let y = floor(FY - fh - 1); y \u003c= FY + 4; y++)\n    for (let x = FX - 5; x \u003c= FX + 5; x++) {\n      const v = (FY + 3.5 - (y + 0.5)) / (fh + 3.5);\n      if (v \u003c 0 || v > 1 || x \u003c 0) continue;\n      const cx = FX + lean * v * v, wdt = 1.9 * sin(PI * (0.15 + 0.85 * v) ** 0.8) * (1 - v * 0.6), dx = abs(x + 0.5 - cx);\n      if (dx > wdt + 0.5) continue;\n      const a = cl(wdt + 0.5 - dx, 0, 1), hot = 1 - v, q = 3 * (y * W + x), col = [1, 0.45 + 0.5 * hot, 0.1 + 0.6 * hot * hot];\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += (col[c] * fl * 1.15 - buf[q + c]) * a;\n    }\n  glow(buf, FX + lean * 0.5, FY - 2, [1, 0.5, 0.15], 9, 0.28 * fl);\n  // Wisps, rising glyphs and sparks in the colour of the magic.\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    const w = ws[p];\n    if (w > 0.01) {\n      const a = min(1, w) * (0.3 + 0.3 * S.glow) * min(1, floor(p / W) / 30);\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += mc[c] * a;\n    }\n  }\n  for (const r of S.risers) {\n    const a = min(1, r.age / 0.2) * cl((r.y - 4) / 34, 0, 1), x0 = floor(r.x) - 1, y0 = floor(r.y) - 1, gb = GLYPH[r.g];\n    for (let b = 0; b \u003c 9; b++) {\n      const x = x0 + (b % 3), y = y0 + floor(b / 3);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = 3 * (y * W + x), on = (gb >> (8 - b)) & 1 ? a : a * 0.25;\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += ((0.35 + 0.65 * mc[c]) * 1.1 - buf[q + c]) * on;\n    }\n  }\n  for (const s of S.sparks) {\n    const x = floor(s.x), y = floor(s.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const a = (1 - s.age / s.life) * (0.6 + 0.4 * sin(s.age * 40)), q = 3 * (y * W + x);\n    for (let c = 0; c \u003c 3; c++) buf[q + c] += (0.5 + 0.5 * mc[c]) * a;\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, min(255, round(buf[q] * 255)), min(255, round(buf[q + 1] * 255)), min(255, round(buf[q + 2] * 255)));\n}\n\nfunction put(mg, x, y, v) {\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) mg[y * W + x] = v;\n}\n// A round soft light added at (x, y).\nfunction glow(buf, gx, gy, col, r, a) {\n  for (let y = max(0, floor(gy - 2 * r)); y \u003c min(H, gy + 2 * r); y++)\n    for (let x = max(0, floor(gx - 2 * r)); x \u003c min(W, gx + 2 * r); x++) {\n      const dx = x + 0.5 - gx, dy = y + 0.5 - gy, f = a * exp(-(dx * dx + dy * dy) / (r * r)), q = 3 * (y * W + x);\n      for (let c = 0; c \u003c 3; c++) buf[q + c] += col[c] * f;\n    }\n}\n","hat-monotile":"// ===== Patternflow pattern =====\n// Title:   Hat Monotile\n// Family:  cells\n// Idea:    The panel fills with copies of one 13-sided tile, the hat, cluster by cluster in the order its metatile substitution nests them, coloured by the metatile each hat belongs to with the rare mirrored hats in orange, and while the window drifts across a patch of 7,921 hats that never repeats, waves of colour regroup the same hats into the bigger clusters of the next two levels.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the hat, an aperiodic monotile (David Smith, Joseph Samuel Myers, Craig S. Kaplan and Chaim Goodman-Strauss, 2023), built by its H/T/P/F metatile substitution as in Kaplan's hatviz (reimplemented), with the paper's continuous family Tile(a, b), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=9..16, Shape=-1..1\n//\n// Knob 1: Hue. Turns the five label colours round the wheel together. At 0 the H hats are blue, the mirrored H1 hats orange, T yellow, P magenta and F green.\n// Knob 2: Speed. At 2 the panel fills in 1.6 seconds and the window drifts 2.5 LEDs a second. A cycle takes 36 seconds: the colours regroup at 11 and 17 seconds and fall back at 23, and from 34.4 the panel clears to build again at 36; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Size. How many LEDs across one hat is, from 9 to 16. At 9 about 220 hats share the panel, at 16 about 70.\n// Knob 4: Shape. Re-measures every edge of the same tiling with two lengths, a for the edges along the hexagon sides and b for the others, as Tile(a, b) of the paper: at -1 the comet Tile(1, 0), at -0.5 the turtle Tile(sqrt 3, 1), at -0.25 Tile(1, 1), from 0 to 0.12 the hat Tile(1, sqrt 3) itself, at 1 the chevron Tile(0, 1).\n// Buttons: K1 tap clears the panel cluster by cluster and builds it again.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, min, max, round, sin, cos, atan2, sqrt, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => ((u = cl(u, 0, 1)), u * u * (3 - 2 * u));\n\n// The substitution. This is Craig Kaplan's hatviz construction, rewritten:\n// four metatiles H, T, P and F, each a polygon holding hats (H four, one of\n// them mirrored, T one, P and F two), are glued into a patch by a fixed list\n// of rules and the patch is cut into the four metatiles of the next level.\n// Transforms are affine maps [a, b, c, d, e, f]: x' = a x + b y + c, y' = d x + e y + f.\nconst R3 = sqrt(3) / 2;\nconst pt = (x, y) => ({ x, y });\nconst hexPt = (x, y) => pt(x + 0.5 * y, R3 * y);\nconst ID = [1, 0, 0, 0, 1, 0];\nconst mul = (A, B) => [A[0] * B[0] + A[1] * B[3], A[0] * B[1] + A[1] * B[4], A[0] * B[2] + A[1] * B[5] + A[2], A[3] * B[0] + A[4] * B[3], A[3] * B[1] + A[4] * B[4], A[3] * B[2] + A[4] * B[5] + A[5]];\nfunction inv(T) {\n  const d = T[0] * T[4] - T[1] * T[3];\n  return [T[4] / d, -T[1] / d, (T[1] * T[5] - T[2] * T[4]) / d, -T[3] / d, T[0] / d, (T[2] * T[3] - T[0] * T[5]) / d];\n}\nconst add = (p, q) => pt(p.x + q.x, p.y + q.y), sub = (p, q) => pt(p.x - q.x, p.y - q.y);\nconst move = (x, y) => [1, 0, x, 0, 1, y];\nconst turnAbout = (p, a) => mul(move(p.x, p.y), mul([cos(a), -sin(a), 0, sin(a), cos(a), 0], move(-p.x, -p.y)));\nconst apply = (M, p) => pt(M[0] * p.x + M[1] * p.y + M[2], M[3] * p.x + M[4] * p.y + M[5]);\n// The similarity taking segment p1 q1 onto segment p2 q2.\nconst seg = (p, q) => [q.x - p.x, p.y - q.y, p.x, q.y - p.y, q.x - p.x, p.y];\nconst match = (p1, q1, p2, q2) => mul(seg(p2, q2), inv(seg(p1, q1)));\nfunction cross(p1, q1, p2, q2) {\n  const d = (q2.y - p2.y) * (q1.x - p1.x) - (q2.x - p2.x) * (q1.y - p1.y);\n  const u = ((q2.x - p2.x) * (p1.y - p2.y) - (q2.y - p2.y) * (p1.x - p2.x)) / d;\n  return pt(p1.x + u * (q1.x - p1.x), p1.y + u * (q1.y - p1.y));\n}\n// The hat on the triangular lattice, eight kites of a hexagon grid. The\n// midpoint of its one long edge is kept as a vertex, so the outline has 14\n// corners and every edge is one of two kinds.\nconst HAT = [[0, 0], [-1, -1], [0, -2], [1, -2], [2, -2], [2, -1], [4, -2], [5, -1], [4, 0], [3, 0], [2, 2], [0, 3], [0, 2], [-1, 2]].map(([a, b]) => hexPt(a, b));\nconst NV = 14;\n// Edge kind: 0 for a unit edge along a hexagon side (length a), 1 for a\n// sqrt 3 edge from a hexagon's centre to the middle of a side (length b).\nconst KIND = HAT.map((p, i) => (abs1(sub(HAT[(i + 1) % NV], p)) \u003c 1.01 ? 0 : 1));\nfunction abs1(p) {\n  return sqrt(p.x * p.x + p.y * p.y);\n}\n// Hat labels: 0 H, 1 H1 (the mirrored one), 2 T, 3 P, 4 F.\nconst hat = (label) => ({ hat: true, label });\nconst meta = (shape, label) => ({ shape, label, kids: [] });\nconst kid = (m, T, g) => m.kids.push({ T, g });\nconst at = (m, n, i) => apply(m.kids[n].T, m.kids[n].g.shape[i]);\nfunction recentre(m) {\n  let cx = 0, cy = 0;\n  for (const p of m.shape) (cx += p.x), (cy += p.y);\n  (cx /= m.shape.length), (cy /= m.shape.length);\n  m.shape = m.shape.map((p) => pt(p.x - cx, p.y - cy));\n  for (const k of m.kids) k.T = mul(move(-cx, -cy), k.T);\n}\nfunction first() {\n  const Ho = [pt(0, 0), pt(4, 0), pt(4.5, R3), pt(2.5, 5 * R3), pt(1.5, 5 * R3), pt(-0.5, R3)];\n  const h = meta(Ho, 0), t = meta([pt(0, 0), pt(3, 0), pt(1.5, 3 * R3)], 2);\n  const p = meta([pt(0, 0), pt(4, 0), pt(3, 2 * R3), pt(-1, 2 * R3)], 3);\n  const f = meta([pt(0, 0), pt(3, 0), pt(3.5, R3), pt(3, 2 * R3), pt(-1, 2 * R3)], 4);\n  // The hat outline without the long edge's midpoint, as hatviz indexes it.\n  const o = HAT.filter((_, i) => i !== 3);\n  kid(h, match(o[5], o[7], Ho[5], Ho[0]), hat(0));\n  kid(h, match(o[9], o[11], Ho[1], Ho[2]), hat(0));\n  kid(h, match(o[5], o[7], Ho[3], Ho[4]), hat(0));\n  kid(h, mul(move(2.5, R3), mul([-0.5, -R3, 0, R3, -0.5, 0], [0.5, 0, 0, 0, -0.5, 0])), hat(1));\n  kid(t, [0.5, 0, 0.5, 0, 0.5, R3], hat(2));\n  for (const [m, l] of [[p, 3], [f, 4]]) {\n    kid(m, [0.5, 0, 1.5, 0, 0.5, R3], hat(l));\n    kid(m, mul(move(0, 2 * R3), mul([0.5, R3, 0, -R3, 0.5, 0], [0.5, 0, 0, 0, 0.5, 0])), hat(l));\n  }\n  return [h, t, p, f];\n}\n// The patch rules: [shape] for the first, [child, edge, shape, its edge] to\n// glue a new metatile to one edge of a child, or [child, corner, child,\n// corner, shape, its edge] to glue it between corners of two children.\nconst RULES = [[\"H\"], [0, 0, \"P\", 2], [1, 0, \"H\", 2], [2, 0, \"P\", 2], [3, 0, \"H\", 2], [4, 4, \"P\", 2], [0, 4, \"F\", 3], [2, 4, \"F\", 3], [4, 1, 3, 2, \"F\", 0], [8, 3, \"H\", 0], [9, 2, \"P\", 0], [10, 2, \"H\", 0], [11, 4, \"P\", 2], [12, 0, \"H\", 2], [13, 0, \"F\", 3], [14, 2, \"F\", 1], [15, 3, \"H\", 4], [8, 2, \"F\", 1], [17, 3, \"H\", 0], [18, 2, \"P\", 0], [19, 2, \"H\", 2], [20, 4, \"F\", 3], [20, 0, \"P\", 2], [22, 0, \"H\", 2], [23, 4, \"F\", 3], [23, 0, \"F\", 3], [16, 0, \"P\", 2], [9, 4, 0, 2, \"T\", 2], [4, 0, \"F\", 3]];\nfunction patch([h, t, p, f]) {\n  const out = meta([], -1), S = { H: h, T: t, P: p, F: f };\n  for (const r of RULES) {\n    if (r.length === 1) kid(out, ID, S[r[0]]);\n    else if (r.length === 4) {\n      const c = out.kids[r[0]], poly = c.g.shape, g = S[r[2]], n = g.shape.length;\n      kid(out, match(g.shape[r[3]], g.shape[(r[3] + 1) % n], apply(c.T, poly[(r[1] + 1) % poly.length]), apply(c.T, poly[r[1]])), g);\n    } else {\n      const g = S[r[4]], n = g.shape.length;\n      kid(out, match(g.shape[r[5]], g.shape[(r[5] + 1) % n], at(out, r[2], r[3]), at(out, r[0], r[1])), g);\n    }\n  }\n  return out;\n}\nfunction next(P) {\n  const b1 = at(P, 8, 2), b2 = at(P, 21, 2), rb = apply(turnAbout(b1, (-2 * PI) / 3), b2);\n  const p72 = at(P, 7, 2), p252 = at(P, 25, 2), llc = cross(b1, rb, at(P, 6, 2), p72);\n  let w = apply(turnAbout(pt(0, 0), -PI / 3), sub(at(P, 6, 2), llc));\n  const nH = [llc, b1, add(b1, w), at(P, 14, 2)];\n  w = apply(turnAbout(pt(0, 0), -PI / 3), w);\n  nH.push(sub(nH[3], w), at(P, 6, 2));\n  const take = (m, list) => (list.forEach((i) => kid(m, P.kids[i].T, P.kids[i].g)), m);\n  const h = take(meta(nH, 0), [0, 9, 16, 27, 26, 6, 1, 8, 10, 15]);\n  const p = take(meta([p72, add(p72, sub(b1, llc)), b1, llc], 3), [7, 2, 3, 4, 28]);\n  const f = take(meta([b2, at(P, 24, 2), at(P, 25, 0), p252, add(p252, sub(llc, b1))], 4), [21, 20, 22, 23, 24, 25]);\n  const A = nH[2], B = add(nH[1], sub(nH[4], nH[5]));\n  const t = take(meta([B, apply(turnAbout(B, -PI / 3), A), A], 2), [11]);\n  for (const m of [h, t, p, f]) recentre(m);\n  return [h, t, p, f];\n}\n\n// Four substitutions: an H metatile of 7,921 hats, 1,009 of them mirrored.\n// Each hat keeps its label and its turn (0..5, sixty degrees each), with the\n// index and label of the cluster holding it at levels 0 to 3 (level 0 is the\n// metatile of one to four hats, level 3 a cluster of up to 1,156). The order\n// of the list is the order the substitution nests them.\nconst LEVELS = 4;\nconst TILING = (() => {\n  let m = first();\n  for (let i = 0; i \u003c LEVELS; i++) m = next(patch(m));\n  const list = [];\n  let serial = 0;\n  const walk = (g, T, ids, labs) => {\n    if (g.hat) return list.push({ T, label: g.label, ids: ids.slice(), labs: labs.slice() });\n    ids.push(serial++);\n    labs.push(g.label);\n    for (const k of g.kids) walk(k.g, mul(T, k.T), ids, labs);\n    ids.pop();\n    labs.pop();\n  };\n  walk(m[0], ID, [], []);\n  const n = list.length;\n  const label = new Uint8Array(n), turn = new Uint8Array(n), cid = new Int32Array(n * 4), clab = new Uint8Array(n * 4);\n  const vx = new Float64Array(n * NV), vy = new Float64Array(n * NV);\n  list.forEach((h, k) => {\n    label[k] = h.label;\n    turn[k] = (round(atan2(h.T[3], h.T[0]) / (PI / 3)) + 6) % 6;\n    // ids run from the top (level 4) down to level 0.\n    for (let l = 0; l \u003c 4; l++) (cid[k * 4 + l] = h.ids[LEVELS - l]), (clab[k * 4 + l] = h.labs[LEVELS - l]);\n    HAT.forEach((p, i) => {\n      const q = apply(h.T, p);\n      (vx[k * NV + i] = q.x), (vy[k * NV + i] = q.y);\n    });\n  });\n  // Lift every corner into two parts, the sum of the a edges and the sum of\n  // the b edges along a path to it from one fixed corner. An a edge always\n  // meets an a edge, so the lift does not depend on the path, and a * A +\n  // b * B is the same tiling made of Tile(a, b).\n  // Corners are keyed by their lattice place relative to the first corner.\n  const key = (x, y) => (round((x - vx[0]) * 4) + 4096) * 16384 + round((y - vy[0]) / (R3 / 2)) + 4096;\n  const share = new Map();\n  for (let i = 0; i \u003c n * NV; i++) {\n    const kk = key(vx[i], vy[i]);\n    const l = share.get(kk);\n    l ? l.push(i) : share.set(kk, [i]);\n  }\n  const LA = new Float32Array(n * NV * 4), known = new Map(), seen = new Uint8Array(n), stack = [0];\n  known.set(key(vx[0], vy[0]), [0, 0, 0, 0]);\n  seen[0] = 1;\n  while (stack.length) {\n    const k = stack.pop();\n    let i0 = 0;\n    while (!known.has(key(vx[k * NV + i0], vy[k * NV + i0]))) i0++;\n    let [ax, ay, bx, by] = known.get(key(vx[k * NV + i0], vy[k * NV + i0]));\n    for (let s = 0; s \u003c NV; s++) {\n      const i = (i0 + s) % NV, j = (i + 1) % NV, o = k * NV + i, kk = key(vx[o], vy[o]);\n      if (!known.has(kk)) known.set(kk, [ax, ay, bx, by]);\n      LA.set([ax, ay, bx, by], o * 4);\n      for (const r of share.get(kk)) {\n        const h = (r / NV) | 0;\n        if (!seen[h]) (seen[h] = 1), stack.push(h);\n      }\n      const dx = vx[k * NV + j] - vx[o], dy = vy[k * NV + j] - vy[o];\n      if (KIND[i]) (bx += dx), (by += dy);\n      else (ax += dx), (ay += dy);\n    }\n  }\n  // Over the whole patch the a part grows as a fixed similarity MA of the\n  // position (a least-squares fit), the b part as I - MA. Dividing by the mix\n  // keeps any Tile(a, b) the hat's size and lined up with the hat tiling.\n  let a11 = 0, a12 = 0, a21 = 0, a22 = 0, xx = 0, xy = 0, yy = 0;\n  for (let i = 0; i \u003c n * NV; i++) {\n    const px = vx[i] - vx[0], py = vy[i] - vy[0], A = LA[i * 4], B = LA[i * 4 + 1];\n    (a11 += A * px), (a12 += A * py), (a21 += B * px), (a22 += B * py), (xx += px * px), (xy += px * py), (yy += py * py);\n  }\n  const d = xx * yy - xy * xy;\n  const MA = [(a11 * yy - a12 * xy) / d, (a12 * xx - a11 * xy) / d, (a21 * yy - a22 * xy) / d, (a22 * xx - a21 * xy) / d];\n  // The patch's middle in lift coordinates: the top metatile is centred on 0.\n  return { n, label, turn, cid, clab, LA, MA, cx: -vx[0], cy: -vy[0] };\n})();\nconst NH = TILING.n;\n\n// Size of a hat across, in lattice units: the hats sit at half scale.\nconst ACROSS = 2.75;\n// Story seconds at Speed 2 for the build and the cycle. WAVES says when the\n// colours regroup and to which level; a wave and a clearing take WAVE and\n// CLEAR seconds, and the window drifts DRIFT LEDs a second.\nconst BUILD = 1.6, CYCLE = 36, WAVES = [[11, 1], [17, 2], [23, 0]], WAVE = 1.6, CLEAR = 1.2, DRIFT = 2.5;\n// Hue of each label at Hue 0: H blue, H1 orange, T yellow, P magenta, F green.\nconst HUES = [0.6, 0.075, 0.15, 0.84, 0.36];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    fresh: true, t: 0, hue: 0, speed: 2, size: 9, shape: 0.06, shapeKey: NaN,\n    PX: new Float32Array(NH * NV), PY: new Float32Array(NH * NV), CX: new Float32Array(NH), CY: new Float32Array(NH),\n    born: new Float32Array(NH), gone: new Float32Array(NH).fill(1e9), flip: new Float32Array(NH).fill(-10), from: 0, to: 0,\n    cycle: 0, waveAt: 0, clearAt: 1e9, arc: 0, ox: 0, oy: 0, u: 1,\n    id: new Int32Array(NP), col: new Float32Array(NH * 3), lv: new Uint8Array(NH), vis: new Int32Array(NH), nvis: 0, xs: new Float64Array(32),\n  };\n}\n\n// Shape knob to the angle of (a, b): comet at 0 degrees, turtle 30, Tile(1, 1) 45, hat 60, chevron 90.\nconst angle = (k) => (k \u003c 0 ? 60 + 60 * k : k \u003c 0.12 ? 60 : 60 + (30 * (k - 0.12)) / 0.88);\n\nfunction reshape(S) {\n  const th = (angle(S.shape) * PI) / 180, wa = cos(th), wb = sin(th) / sqrt(3), { LA, MA } = TILING;\n  const L = [wa * MA[0] + wb * (1 - MA[0]), wa * MA[1] - wb * MA[1], wa * MA[2] - wb * MA[2], wa * MA[3] + wb * (1 - MA[3])];\n  const d = L[0] * L[3] - L[1] * L[2], i0 = L[3] / d, i1 = -L[1] / d, i2 = -L[2] / d, i3 = L[0] / d;\n  const { PX, PY, CX, CY } = S;\n  for (let k = 0; k \u003c NH; k++) {\n    let sx = 0, sy = 0;\n    for (let i = k * NV; i \u003c (k + 1) * NV; i++) {\n      const x = wa * LA[4 * i] + wb * LA[4 * i + 2], y = wa * LA[4 * i + 1] + wb * LA[4 * i + 3];\n      sx += PX[i] = i0 * x + i1 * y;\n      sy += PY[i] = i2 * x + i3 * y;\n    }\n    CX[k] = sx / NV;\n    CY[k] = sy / NV;\n  }\n}\n\n// The hats whose middles are on the panel now, in nesting order.\nfunction onPanel(S) {\n  const { CX, CY, u, ox, oy, vis } = S, r = 2 * u + 2;\n  let n = 0;\n  for (let k = 0; k \u003c NH; k++) {\n    const x = CX[k] * u + ox, y = CY[k] * u + oy;\n    if (x > -r && x \u003c W + r && y > -r && y \u003c H + r) vis[n++] = k;\n  }\n  return n;\n}\n\n// Each hat on the panel gets a time in nesting order across span seconds.\nfunction stagger(S, out, t0, span, rest) {\n  const n = onPanel(S);\n  out.fill(t0 + rest);\n  for (let i = 0; i \u003c n; i++) out[S.vis[i]] = t0 + (span * i) / max(1, n - 1);\n}\n\n// The window: a slow loop round the middle of the patch, kept inside it.\nfunction view(S) {\n  S.u = S.size / ACROSS;\n  const R = cl(64 - 74 / S.u, 6, 40), a = S.arc / R + 2;\n  S.ox = round(W / 2 - (TILING.cx + R * cos(a)) * S.u);\n  S.oy = round(H / 2 - (TILING.cy + 0.8 * R * sin(a)) * S.u);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.size = cl(k[2], 9, 16);\n  S.shape = cl(k[3], -1, 1);\n  if (S.shape !== S.shapeKey) (S.shapeKey = S.shape), reshape(S);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.arc += (DRIFT * ds) / (S.size / ACROSS);\n  view(S);\n  if (S.fresh) {\n    S.fresh = false;\n    stagger(S, S.born, 0, BUILD, BUILD);\n  }\n  const press = input.btnPressed && input.btnPressed[0];\n  const c = S.t - S.cycle;\n  if ((press && S.clearAt > S.t + CLEAR) || (c > CYCLE - CLEAR - 0.4 && S.clearAt > 1e8)) {\n    // Clear in nesting order, then build again where the window is then.\n    S.clearAt = S.t;\n    stagger(S, S.gone, S.t, CLEAR, CLEAR);\n  }\n  if (S.t > S.clearAt + CLEAR + 0.4) {\n    S.cycle = S.t;\n    S.clearAt = 1e9;\n    S.gone.fill(1e9);\n    S.from = S.to = 0;\n    S.waveAt = 0;\n    stagger(S, S.born, S.t, BUILD, BUILD);\n  }\n  for (const [w, v] of WAVES)\n    if (c >= w && S.waveAt \u003c w) {\n      S.waveAt = w;\n      S.from = S.to;\n      S.to = v;\n      stagger(S, S.flip, S.t, WAVE, WAVE);\n    }\n}\n\n// The label a hat shows in a view: its own, or that of the cluster of level\n// 1 or 2 holding it. The mirrored hats keep their own colour in every view.\nconst shown = (k, v) => (v === 0 || TILING.label[k] === 1 ? TILING.label[k] : TILING.clab[k * 4 + v]);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { id, col, lv, PX, PY, u, ox, oy, xs, born, gone, flip, t } = S, cid = TILING.cid;\n  id.fill(-1);\n  const n = onPanel(S), rgb = [0, 0, 0];\n  for (let i = 0; i \u003c n; i++) {\n    const k = S.vis[i];\n    // Fill the hat's 14-gon, LED centres inside it.\n    let y0 = 1e9, y1 = -1e9;\n    for (let j = k * NV; j \u003c (k + 1) * NV; j++) (y0 = min(y0, PY[j])), (y1 = max(y1, PY[j]));\n    const r0 = max(0, ceil(y0 * u + oy - 0.5)), r1 = min(H - 1, ceil(y1 * u + oy - 0.5) - 1);\n    for (let r = r0; r \u003c= r1; r++) {\n      const py = r + 0.5;\n      let m = 0;\n      for (let a = k * NV + NV - 1, b = k * NV; b \u003c (k + 1) * NV; a = b++) {\n        const ya = PY[a] * u + oy, yb = PY[b] * u + oy;\n        if (ya \u003c= py !== yb \u003c= py) {\n          const xa = PX[a] * u + ox;\n          let x = xa + ((py - ya) * (PX[b] * u + ox - xa)) / (yb - ya), q = m++;\n          while (q > 0 && xs[q - 1] > x) (xs[q] = xs[q - 1]), q--;\n          xs[q] = x;\n        }\n      }\n      for (let q = 0; q + 1 \u003c m; q += 2) {\n        const xa = max(0, ceil(xs[q] - 0.5)), xb = min(W - 1, ceil(xs[q + 1] - 0.5) - 1);\n        for (let x = xa; x \u003c= xb; x++) id[r * W + x] = k;\n      }\n    }\n    // Its colour: the label's hue, one of six close shades for its turn,\n    // a white flash as it arrives or changes colour, dark before and after.\n    const tn = TILING.turn[k], age = t - born[k], fl = t - flip[k];\n    const v = (lv[k] = fl >= 0 ? S.to : S.from);\n    hsv(HUES[shown(k, v)] + S.hue + 0.012 * (tn - 2.5), 0.92 - 0.045 * tn, 1 - 0.02 * tn, rgb, 0);\n    const glow = max(age >= 0 ? exp(-age / 0.18) : 0, fl >= 0 ? 0.7 * exp(-fl / 0.25) : 0);\n    const on = age \u003c 0 ? 0 : (1 - ease((t - gone[k]) / 0.3)) * min(1, 0.75 + age / 0.12);\n    for (let c = 0; c \u003c 3; c++) col[k * 3 + c] = on * (rgb[c] + (1 - rgb[c]) * glow);\n  }\n  // A hat that differs from the LED to its right or below loses that LED to\n  // a dark seam, one LED wide. While a view of level 1 or 2 shows, a seam\n  // inside one cluster keeps a third of the colour, so the clusters read as\n  // pieces with black between them.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const k = id[p];\n      if (k \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const kr = x \u003c W - 1 ? id[p + 1] : k, kd = y \u003c H - 1 ? id[p + W] : k, L = lv[k];\n      let f = 1;\n      if (kr !== k || kd !== k) {\n        const same = (q) => q === k || (L > 0 && q >= 0 && lv[q] === L && cid[q * 4 + L] === cid[k * 4 + L]);\n        f = same(kr) && same(kd) ? 0.3 : 0;\n      }\n      display.setPixel(x, y, round(col[k * 3] * 255 * f), round(col[k * 3 + 1] * 255 * f), round(col[k * 3 + 2] * 255 * f));\n    }\n}\n","jack-in-the-box":"// ===== Patternflow pattern =====\n// Title:   Jack-in-the-Box\n// Family:  halloween\n// Idea:    A purple tin box with orange harlequin diamonds sits on the floor while its crank turns by itself and the box shivers at every turn, until the lid bursts open and a grinning jack-o'-lantern on a long coiled spring shoots up the panel, overshoots and bobs on the stretching and bunching coil, swaying side to side, then slowly sinks back in, the lid slams and the crank turns again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spring=0..1, Wobble=0..1\n//\n// Knob 1: Hue. The tin and the candle in the head. The tin runs from purple at 0 through blue and teal to poison green at 1, its diamonds always orange; the candle from orange at 0 through lime at 0.25, sea green at 0.5 and blue at 0.75 to violet at 1, lighting the carving, the glow round the head and the inside of the box. The pumpkin's skin and the spring stay as they are.\n// Knob 2: Speed. At 2 the lid bursts at 0.85 seconds, the head bobs for 3.6 seconds, sinks back in 1.6, the lid slams and the crank turns for 1.4 seconds before the next pop, so a pop comes every 7 seconds; the crank turns 1.3 times a second. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Spring. Its stiffness. At 0 a soft spring: the head rests 40 LEDs above the box, overshoots to 66 and bounces deep and slow, 0.9 bounces a second; at 1 a stiff one: the head rides 56 LEDs up and buzzes 4.5 times a second in a tight shiver that dies away.\n// Knob 4: Wobble. How far the spring and the head sway. The pop throws the head to one side and it swings back and forth every 2.4 seconds, the head tilting with the top of the spring and rocking on its neck: at 0 about 2 LEDs either way, at the opening 0.06 about 3, at 1 a throw of 20 LEDs that settles to 12 either way.\n// Buttons: K1 tap pops it now; with the head already out it gives the head another shove up.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The box in an oblique view: the front face from column 10 to 46 and row\n// 93 to 121, and one unit of depth going 0.4 right and 0.22 up, so the top\n// and the right side show. The box is 24 deep.\nconst X0 = 10, X1 = 46, Y0 = 93, Y1 = 121, DEP = 24, DX = 0.4 * DEP, DY = 0.22 * DEP, FLOOR = 122;\n// The spring stands on the middle of the top; L is how far it reaches up\n// from there to the bottom of the head's collar. Shut in, the head sits at\n// L = -27, its stem below the box's front edge.\nconst BX = (X0 + X1) / 2 + DX / 2, BY = Y0 - DY / 2, INSIDE = -27, LMAX = 68;\n// The head: a pumpkin RX by RY, the collar under it, and the coil.\nconst RX = 12, RY = 10, NECK = 2.5, COILS = 8, CR = 5.5;\n// The story at Speed 2, in seconds after a pop: bob, sink, slam; then the\n// box stays shut and cranks for SHUT before the next pop. The first pop\n// comes at FIRST.\nconst BOB = 3.6, SINK = 1.6, SLAM = 0.35, SHUT = 1.4, FIRST = 0.85, CYCLE = BOB + SINK + SLAM + SHUT;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, stiff: 0, wob: 0.06,\n    // Spring length and speed; time since the pop (negative while shut);\n    // the lid's angle and speed; the crank's angle, the jolt it gives the\n    // box and the trembling before a pop; which side the pop throws the\n    // head; the candle's flicker.\n    L: INSIDE, v: 0, since: -FIRST, lid: 0, lidV: 0, crank: 0, jolt: 0, tremble: 0, side: 1, flick: 1,\n    buf: new Float32Array(N * 3), key: \"\", pal: null,\n  };\n}\n\n// Where the spring wants to rest and how it moves, by stiffness s: the\n// angular frequency, the rest length and the damping, light for small\n// motions and heavy for fast ones, so the pop cannot fly off the panel.\nfunction springOf(s) {\n  return { w: TAU * 0.9 * 5 ** s, le: 40 + 16 * s, z: 0.05 - 0.04 * s, c2: 0.012 + 0.02 * s };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.stiff = cl(k[2], 0, 1);\n  S.wob = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // A tap: pop now if shut or on the way down, or shove the head up.\n  if (input.btnPressed && input.btnPressed[0]) {\n    if (S.since \u003c 0 || S.since > BOB) pop(S);\n    else S.v += 160;\n  }\n  // The clock of one cycle: negative while the box waits for its first pop,\n  // 0 at a pop, and round again to the next pop at CYCLE.\n  const before = S.since;\n  S.since += ds;\n  if ((before \u003c 0 && S.since >= 0) || S.since >= CYCLE) pop(S);\n  const sp = springOf(S.stiff), a = S.since;\n  // The rest length: up while it bobs, drawn down into the box as it sinks.\n  const out = a >= 0 && a \u003c BOB + SINK;\n  const le = a \u003c 0 ? INSIDE : a \u003c BOB ? sp.le : a \u003c BOB + SINK ? sp.le + (INSIDE - 2 - sp.le) * ease((a - BOB) / SINK) : INSIDE;\n  // The spring, in eight steps a frame: L'' = -w^2 (L - le) - 2 z w L' - c2 |L'| L'.\n  if (out || S.L > INSIDE + 0.5 || abs(S.v) > 1) {\n    const n = 8, h = ds / n;\n    for (let i = 0; i \u003c n; i++) {\n      let acc = -sp.w * sp.w * (S.L - le) - 2 * sp.z * sp.w * S.v - sp.c2 * abs(S.v) * S.v;\n      // The coil cannot stretch past LMAX: it pulls back hard there.\n      if (S.L > LMAX) acc -= 900 * (S.L - LMAX) + 25 * max(0, S.v);\n      S.v += acc * h;\n      S.L += S.v * h;\n    }\n    // Shut in the box, it stops at the bottom.\n    if (!out && S.L \u003c INSIDE) (S.L = INSIDE), (S.v = 0);\n    // Going down it stops on the bottom of the box.\n    if (S.L \u003c INSIDE - 2) (S.L = INSIDE - 2), (S.v = max(0, S.v));\n  }\n  // The lid: flung open at the pop to lean back past upright, then shut as\n  // the head goes down, with a small bounce each time.\n  const goal = a >= 0 && a \u003c BOB + SINK ? 1.95 : 0;\n  const lk = goal ? 260 : 380, lz = goal ? 16 : 14;\n  S.lidV += (-lk * (S.lid - goal) - lz * S.lidV) * ds;\n  if (a >= BOB + SINK - 0.05 && S.L > INSIDE + 6) S.lidV = max(S.lidV, 0);\n  S.lid += S.lidV * ds;\n  if (S.lid \u003c 0) (S.lid = 0), (S.lidV = -0.35 * S.lidV);\n  // While shut the crank turns 1.3 times a second and jolts the box at every\n  // turn; in the last 0.4 seconds before a pop the box trembles and the lid\n  // rattles.\n  const shut = a \u003c 0 || a >= BOB + SINK + SLAM;\n  if (shut) {\n    const c0 = S.crank;\n    S.crank += TAU * 1.3 * ds;\n    if (floor(S.crank / TAU) !== floor(c0 / TAU)) S.jolt = 1;\n  }\n  S.jolt = max(0, S.jolt - ds / 0.09);\n  const toPop = a \u003c 0 ? -a : a >= BOB + SINK + SLAM ? CYCLE - a : 9;\n  S.tremble = toPop \u003c 0.4 ? 1 - toPop / 0.4 : 0;\n  S.flick += (0.8 + 0.2 * Math.random() - S.flick) * min(1, ds * 12);\n}\n\nfunction pop(S) {\n  S.since = 0;\n  S.L = max(S.L, INSIDE);\n  S.v = max(S.v, 0);\n  S.side = Math.random() \u003c 0.5 ? -1 : 1;\n  S.lidV = max(S.lidV, 14);\n}\n\n// Colours that only change with Hue.\nfunction palette(S) {\n  const key = S.hue.toFixed(3);\n  if (S.key === key) return;\n  S.key = key;\n  // The tin runs from purple through blue and teal to poison green; the\n  // diamonds stay orange. The candle in the head runs from orange through\n  // yellow and green to blue and violet.\n  const h = 0.78 - 0.45 * S.hue, hd = 0.075, hc = 0.09 + 0.66 * S.hue;\n  S.pal = {\n    front: hsv(h, 0.78, 0.58), side: hsv(h, 0.8, 0.36), top: hsv(h, 0.7, 0.72), lining: hsv(h, 0.75, 0.22), inner: hsv(h, 0.8, 0.07),\n    dia: hsv(hd, 0.92, 1), diaSide: hsv(hd - 0.01, 0.9, 0.8), diaTop: hsv(hd, 0.85, 0.9), floor: hsv(h, 0.6, 0.12),\n    halo: hsv(hc, 0.92, 1), cut: hsv(hc, 0.85, 1), core: hsv(hc + 0.03, 0.55, 1),\n  };\n}\n\n// The head's place and tilt from the spring: the coil leaves the box\n// straight up and bends toward the head, a quadratic curve from its foot at\n// (BX, BY) through (BX, BY - 0.55 L) to the collar.\nfunction headOf(S) {\n  // The pop throws the head to one side; it swings back and forth every\n  // 2.4 seconds, wide at first and settling to a steady sway.\n  const a = max(0, S.since), L = S.L, amp = 0.1 + 0.9 * S.wob, reach = cl(L / 40, 0, 1);\n  const X = cl(amp * reach * S.side * (12 + 12 * exp(-a / 2.5)) * sin(TAU * 0.42 * a + 0.36), -20, 20);\n  // The head tilts with the spring's end and rocks on its neck besides.\n  const hx = BX + X, hy = BY - L, tilt = 0.85 * atan2(X, max(8, 0.45 * L)) + amp * reach * 0.3 * sin(TAU * 0.9 * a);\n  return { hx, hy, tilt, cx: hx + (RY + NECK) * sin(tilt), cy: hy - (RY + NECK) * cos(tilt) };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const P = S.pal, buf = S.buf;\n  // The box's jolt and trembling, in whole LEDs.\n  const jy = S.jolt > 0.5 ? -1 : 0, jx = S.tremble > 0 && floor(S.t * 30) % 2 ? (S.tremble > 0.5 ? 1 : 0) : 0;\n  const ox = X0 + jx, oy = Y0 + jy;\n  const head = headOf(S), glow = cl((S.L - INSIDE) / 20, 0, 1) * S.flick;\n  const set = (p, c, a) => {\n    const o = 3 * p;\n    buf[o] = c[0] * a;\n    buf[o + 1] = c[1] * a;\n    buf[o + 2] = c[2] * a;\n  };\n  // Night: black above, a floor in the tin's colour, the candle's glow\n  // around the head.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      let r = 0, g = 0, b = 0;\n      if (y >= FLOOR) {\n        const f = 0.8 + 0.2 * ((y - FLOOR) / (H - FLOOR));\n        (r = P.floor[0] * f), (g = P.floor[1] * f), (b = P.floor[2] * f);\n      }\n      const dx = x + 0.5 - head.cx, dy = (y + 0.5 - head.cy) * 0.85, d2 = dx * dx + dy * dy;\n      if (d2 \u003c 900 && glow > 0) {\n        const q = (1 - sqrt(d2) / 30) ** 2 * 0.42 * glow;\n        r += q * P.halo[0];\n        g += q * P.halo[1];\n        b += q * P.halo[2];\n      }\n      buf[o] = r;\n      buf[o + 1] = g;\n      buf[o + 2] = b;\n    }\n  // The lid on its hinge along the back edge of the top: lid angle 0 lies\n  // shut, past 0.22 radians it shows its lining. Open wide it stands behind\n  // the spring; nearly shut it lies over everything.\n  const lidQuad = () => {\n    const ph = S.lid + 0.1 * S.tremble * abs(sin(S.t * 47)), fx = -DX * cos(ph), fy = DY * cos(ph) - DEP * sin(ph), hx0 = ox + DX, hy = oy - DY;\n    const y0 = floor(min(hy, hy + fy)), y1 = floor(max(hy, hy + fy)), outer = fy > 0;\n    for (let y = max(0, y0); y \u003c= min(H - 1, y1 + 1); y++) {\n      const t = fy === 0 ? 0 : cl((y + 0.5 - hy) / fy, 0, 1);\n      if (abs(fy) > 0.5 && ((y + 0.5 - hy) / fy \u003c -0.02 || (y + 0.5 - hy) / fy > 1.02)) continue;\n      const xa = hx0 + fx * t;\n      for (let x = max(0, floor(xa)); x \u003c min(W, xa + (X1 - X0)); x++) {\n        const u = x + 0.5 - xa, side = u \u003c 1 || u > X1 - X0 - 1, rim = side || t > 0.85 || t \u003c 0.12;\n        let c = outer ? (rim ? [0.95, 0.75, 0.3] : P.top) : side || t > 0.9 ? [0.62, 0.46, 0.18] : P.lining;\n        if (outer && !rim && diamond(u - 7, (1 - t) * DEP - 6)) c = P.diaTop;\n        // The lining darkens toward the free edge and takes the head's glow.\n        set(y * W + x, c, outer || side || t > 0.9 ? 1 : 1.25 - 0.55 * t + 0.6 * glow * (1 - t));\n      }\n    }\n  };\n  if (S.lid > 0.9) lidQuad();\n  // The top: the open mouth of the box, dark, lit orange by the head inside.\n  for (let y = floor(oy - DY); y \u003c oy; y++) {\n    const t = (oy - (y + 0.5)) / DY, xa = ox + DX * t;\n    for (let x = floor(xa); x \u003c xa + (X1 - X0); x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const c = P.inner, a = 1 + 4 * glow * (1 - t);\n      set(y * W + x, [c[0] * a + 0.25 * glow * P.halo[0], c[1] * a + 0.25 * glow * P.halo[1], c[2] * a + 0.25 * glow * P.halo[2]], 1);\n    }\n  }\n  // The spring: a helix about the curve, back half first, steel bright in front.\n  const L = S.L, hx = head.hx, hy = head.hy, bx = BX + jx, by = BY + jy;\n  if (L > -2) {\n    const steps = COILS * 40;\n    for (let pass = 0; pass \u003c 2; pass++)\n      for (let i = 0; i \u003c= steps; i++) {\n        const s = i / steps, ph = TAU * COILS * s + 0.6, z = sin(ph);\n        if ((z > 0) !== (pass === 1)) continue;\n        // Bezier point and tangent.\n        const m1x = bx, m1y = by - 0.55 * L, u = 1 - s;\n        const px = u * u * bx + 2 * u * s * m1x + s * s * hx, py = u * u * by + 2 * u * s * m1y + s * s * hy;\n        let tx = 2 * u * (m1x - bx) + 2 * s * (hx - m1x), ty = 2 * u * (m1y - by) + 2 * s * (hy - m1y);\n        const tl = sqrt(tx * tx + ty * ty) || 1;\n        (tx /= tl), (ty /= tl);\n        const r = CR * (s \u003c 0.04 ? 0.6 + 10 * s : 1), x = floor(px - ty * r * cos(ph) + 0.5), y = floor(py + tx * r * cos(ph) + 0.5);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= oy + Y1 - Y0) continue;\n        const lit = pass ? 0.55 + 0.45 * z : 0.22 + 0.1 * (1 + z), shine = pass && z > 0.85 ? 0.25 : 0;\n        set(y * W + x, [0.78 * lit + shine + 0.15 * glow * lit, 0.8 * lit + shine + 0.05 * glow * lit, 0.9 * lit + shine], 1);\n      }\n  }\n  // The head: a ribbed pumpkin with a carved grin glowing from inside, a\n  // green collar of points under it and a stem on top, all tilted with the\n  // spring's end.\n  {\n    const ct = cos(head.tilt), st = sin(head.tilt), cx = head.cx, cy = head.cy, fl = S.flick;\n    for (let y = max(0, floor(cy - 15)); y \u003c min(oy + Y1 - Y0, cy + 16); y++)\n      for (let x = max(0, floor(cx - 15)); x \u003c min(W, cx + 16); x++) {\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, u = dx * ct + dy * st, v = -dx * st + dy * ct;\n        const p = y * W + x;\n        // The collar: a ring of points below the head.\n        if (v > RY - 2 && v \u003c RY + NECK + 2.2 && abs(u) \u003c 9) {\n          const tip = RY + NECK + 2.2 - 2.2 * abs(sin((u * PI) / 3));\n          if (v \u003c tip) {\n            set(p, (floor((u + 9) / 3) & 1) ? [0.35, 1, 0.1] : [0.6, 0.15, 0.85], 0.9);\n            continue;\n          }\n        }\n        // The stem.\n        if (v \u003c -RY + 1.5 && v > -RY - 3.2 && abs(u - 0.4 - 0.35 * (v + RY)) \u003c 1.4) {\n          set(p, [0.25, 0.55, 0.12], 1);\n          continue;\n        }\n        // The pumpkin: an ellipse with lobes.\n        const ang = atan2(v, u), e = (u / RX) ** 2 + (v / RY) ** 2, lobe = 1 - 0.05 * abs(sin(ang * 3));\n        if (e > lobe * lobe) continue;\n        const face = carved(u, v);\n        // The cut wall shows as a dark line along the top of each hole.\n        if (!face && carved(u, v + 1)) {\n          set(p, [0.5, 0.17, 0.02], 1);\n          continue;\n        }\n        if (face) {\n          // The candle inside: pale at the core, its full colour at the cut.\n          set(p, face === 2 ? P.cut : P.core, face === 2 ? 0.8 * fl : fl);\n          continue;\n        }\n        // Skin: ribs along the meridians, lit from the upper left, a darker\n        // rind at the edge so the head stands off its own glow.\n        const mer = u / RX / sqrt(max(0.05, 1 - (v / RY) ** 2)), rib = abs(sin(mer * PI * 2.2)) \u003c 0.22 ? 0.84 : 1;\n        const light = (0.82 + 0.18 * cl(-(u + v) / RX, -1, 1)) * (e > 0.8 * lobe * lobe ? 0.78 : 1);\n        set(p, [light * rib, 0.44 * light * rib, 0.04], 1);\n      }\n  }\n  // The box's front and right side, over whatever is inside it.\n  for (let y = max(0, floor(oy - DY)); y \u003c= oy + (Y1 - Y0); y++)\n    for (let x = ox; x \u003c min(W, ox + (X1 - X0) + DX + 1); x++) {\n      const p = y * W + x, u = x + 0.5 - ox, v = y + 0.5 - oy;\n      if (u \u003c X1 - X0) {\n        if (v \u003c 0 || v > Y1 - Y0) continue;\n        // Gold rims top and bottom, purple tin with orange diamonds between.\n        if (v \u003c 2 || v > Y1 - Y0 - 2) {\n          set(p, [0.95, 0.72, 0.25], v \u003c 1 || v > Y1 - Y0 - 1 ? 1 : 0.75);\n          continue;\n        }\n        // Diamonds on a harlequin lattice, three across and two down, each\n        // 10 LEDs from point to point, the purple showing between.\n        const di = diamond(u - 7, v - 2);\n        const edge = u \u003c 1 ? 1.3 : u > X1 - X0 - 1 ? 0.75 : 1;\n        set(p, di ? P.dia : P.front, edge);\n      } else {\n        const t = (u - (X1 - X0)) / DX;\n        if (t > 1) continue;\n        const vv = v + DY * t;\n        if (vv \u003c 0 || vv > Y1 - Y0) continue;\n        if (vv \u003c 2 || vv > Y1 - Y0 - 2) {\n          set(p, [0.6, 0.45, 0.15], 1);\n          continue;\n        }\n        set(p, diamond(t * DEP - 6, vv - 2) ? P.diaSide : P.side, 1);\n      }\n    }\n  // The crank on the side: a brass hub, an arm turning in the side's plane\n  // and a red knob sticking out of it.\n  {\n    const hubX = ox + (X1 - X0) + DX / 2 + 1, hubY = oy + (Y1 - Y0) / 2 - DY / 2, c = S.crank;\n    const ex = hubX + 1.5 + 7 * cos(c) * 0.4, ey = hubY - 7 * cos(c) * 0.22 + 7 * sin(c);\n    const dot = (x, y, col, a = 1) => {\n      x = floor(x);\n      y = floor(y);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) set(y * W + x, col, a);\n    };\n    for (let i = 0; i \u003c= 10; i++) dot(hubX + (1.5 * i) / 10 + ((ex - hubX - 1.5) * i) / 10, hubY + ((ey - hubY) * i) / 10, [0.95, 0.75, 0.3]);\n    dot(hubX, hubY, [1, 0.9, 0.55]);\n    dot(hubX + 1, hubY, [0.9, 0.7, 0.3]);\n    for (let i = 1; i \u003c= 3; i++) dot(ex + i, ey, [0.8, 0.6, 0.25]);\n    for (const [kx, ky] of [[4, 0], [5, 0], [4, -1], [5, -1], [6, 0], [4, 1], [5, 1]]) dot(ex + kx, ey + ky, [1, 0.25, 0.12], kx === 6 ? 0.8 : 1);\n  }\n  if (S.lid \u003c= 0.9) lidQuad();\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) display.setPixel(x, y, round(min(1, buf[3 * p]) * 255), round(min(1, buf[3 * p + 1]) * 255), round(min(1, buf[3 * p + 2]) * 255));\n}\n\n// Whether (a, b), in LEDs along and across a face of the tin, falls in one\n// of its diamonds: every other cell of a lattice of 12 by 12 diamonds holds\n// one, 10 from point to point, centred on a = 0 and b = 6.\nfunction diamond(a, b) {\n  const qa = a / 12 + b / 12, qb = a / 12 - b / 12, fa = qa - floor(qa), fb = qb - floor(qb);\n  return (floor(qa) + floor(qb)) & 1 && max(abs(fa - 0.5), abs(fb - 0.5)) \u003c 0.42;\n}\n\n// The carving at (u, v) in the head's frame: 0 skin, 1 the open cut, 2 its\n// lit rim. Two eyes pointing up, a small nose and a wide grin curving up at\n// the corners, with a tooth hanging from the top and one standing below.\nfunction carved(u, v) {\n  const au = abs(u);\n  // Eyes: triangles 7 wide at v = -0.5 up to a point at v = -6, centred at |u| = 5.\n  if (v \u003c -0.5 && v > -6) {\n    const half = (3.5 * (v + 6)) / 5.5, e = abs(au - 5);\n    if (e \u003c half) return v > -1.5 || e > half - 1 ? 2 : 1;\n  }\n  // Nose: a small triangle.\n  if (v > 0.3 && v \u003c 2.6 && au \u003c (v - 0.3) * 0.8 + 0.2) return 2;\n  // Grin: between two curves meeting at |u| = 9.5, v = 3.2.\n  const q = 1 - (au / 9.5) ** 2;\n  if (q > 0) {\n    const top = 3.2 + 1.3 * q, bot = 3.2 + 4.6 * q;\n    if (v > top && v \u003c bot) {\n      if ((abs(u + 2.6) \u003c 1.2 && v \u003c top + 1.6) || (abs(u - 3) \u003c 1.2 && v > bot - 1.6)) return 0;\n      return v > bot - 1 ? 2 : 1;\n    }\n  }\n  return 0;\n}\n","persistence-barcode":"// ===== Patternflow pattern =====\n// Title:   Persistence Barcode\n// Family:  topology\n// Idea:    Disks grow round points scattered about a ring until they swallow it while the Delaunay edges and triangles they reach join in, and below them the barcode of that growth, reduced exactly over Z/2, lights up behind a sweeping line: short pale teal bars for points whose disks merge and one long orange bar for the ring's hole, whose loop and shrinking rim glow the same orange until the hole closes.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: persistent homology (Herbert Edelsbrunner, David Letscher and Afra Zomorodian, 2002) of the alpha complex of the points (alpha shapes, Herbert Edelsbrunner, David Kirkpatrick and Raimund Seidel, 1983), drawn as a barcode (Afra Zomorodian and Gunnar Carlsson, 2005), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=0..1, Rings=1..3\n//\n// Knob 1: Hue. Turns the loops' colours round the wheel while the disks swing between violet and green and the merging bars between pale teal and pale violet, so nothing dim goes brown. At 0 violet disks, teal bars and an orange loop (the second and third rings pink and yellow); at 0.25 green loops on teal disks; at 0.5 blue loops on green disks; at 0.75 magenta loops.\n// Knob 2: Speed. At 2 the disks grow from nothing to 1.12 times the radius that closes the last hole in 7 seconds, the whole barcode holds for 1.5 s and a fresh sample comes at 9 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Noise. How far the points scatter from their circles: a twentieth of the radius at 0, where one ring's bar spans about three quarters of the ruler with one or two short bars beside it; a third at 1, where the ring frays into clusters and its bar spans under half among some 28 short ones. Turning it slides the same points, and the barcode is computed again at once.\n// Knob 4: Rings. One, two or three circles sharing 40, 38 or 36 points, so that many long bars stand in the barcode, orange, pink and yellow, each loop drawn in its bar's colour.\n// Buttons: K1 tap draws a fresh sample now.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The cloud is the square of rows 0..63; the barcode starts at row BT, and\n// the bottom row is its ruler of r.\nconst CH = 64, BT = 68;\n// The rings for one, two and three circles, [cx, cy, R] in LEDs, and how\n// many points they share.\nconst LAYOUT = [\n  { n: 40, rings: [[31.5, 31.5, 24]] },\n  { n: 38, rings: [[21, 21, 15.5], [45, 45, 11]] },\n  { n: 36, rings: [[15, 15, 10.5], [33, 33, 9], [50.5, 50.5, 8.5]] },\n];\nconst MAXN = 40;\n// Story seconds at Speed 2: the disks grow, the full barcode holds, the\n// picture fades and the next sample begins.\nconst GROW = 7, HOLD = 1.5, FADE = 0.5, CYCLE = GROW + HOLD + FADE;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, noise: 0, rings: 1, key: \"\", seed: 0, first: true, btn: false,\n    rnd: null, n: 0, X: new Float64Array(MAXN), Y: new Float64Array(MAXN), K: null,\n    buf: new Float32Array(W * H * 3), pal: new Float32Array(8 * 3),\n  };\n  fresh(params.s);\n}\n\n// A new sample's randomness: each point's place along its circle and its\n// standard normal offset from it, and each ring's turn, size and shift.\nfunction fresh(S) {\n  const R = Math.random, gauss = () => cl(sqrt(-2 * log(1 - R())) * cos(TAU * R()), -2.6, 2.6);\n  S.rnd = {\n    ja: Array.from({ length: MAXN }, () => R() - 0.5),\n    z: Array.from({ length: MAXN }, gauss),\n    ring: Array.from({ length: 3 }, () => [TAU * R(), 1 + 0.08 * (R() - 0.5), 2 * (R() - 0.5), 2 * (R() - 0.5)]),\n    sym: floor(8 * R()),\n  };\n  S.seed++;\n  S.key = \"\";\n}\n\n// The points for the current knobs from the sample's randomness, so turning\n// Noise slides them instead of drawing new ones.\nfunction place(S) {\n  const L = LAYOUT[S.rings - 1], rr = S.rnd, sig = 0.05 + 0.28 * S.noise;\n  const tot = L.rings.reduce((a, g) => a + g[2], 0);\n  let i = 0;\n  L.rings.forEach((g, k) => {\n    const m = k === L.rings.length - 1 ? L.n - i : round((L.n * g[2]) / tot), [ph, sz, sx, sy] = rr.ring[k];\n    for (let j = 0; j \u003c m; j++, i++) {\n      const th = ph + (TAU * (j + 0.7 * rr.ja[i])) / m, rad = g[2] * sz * (1 + sig * rr.z[i]);\n      let u = g[0] + sx + rad * cos(th) - 31.5, v = g[1] + sy + rad * sin(th) - 31.5;\n      if (rr.sym & 1) u = -u;\n      if (rr.sym & 2) v = -v;\n      if (rr.sym & 4) [u, v] = [v, u];\n      // Points pushed against the edge are nudged apart, so two never meet.\n      S.X[i] = cl(31.5 + u, 1, 62.5) + 0.001 * i;\n      S.Y[i] = cl(31.5 + v, 1, CH - 1.5) + 0.0007 * i;\n    }\n  });\n  S.n = L.n;\n}\n\n// The alpha complex of the points and its persistence. Delaunay triangles\n// are the triples whose circumcircle holds no other point, and a triangle\n// enters when the disks reach its circumradius. An edge enters at half its\n// length, except when a triangle on one side has an obtuse angle facing it\n// (its third point lies inside the circle on the edge); then the edge enters\n// with that triangle. At radius r this complex has the shape of the union of\n// the disks, so the barcode is the barcode of the picture.\n// H0 comes from joining components in order; H1 from reducing the\n// triangles' boundary columns over Z/2, each surviving column's lowest edge\n// giving birth to the hole the triangle kills. The reduced column is that\n// hole's loop and the triangles summed into it are what fills it.\nfunction persistence(X, Y, n) {\n  const T = [];\n  for (let a = 0; a \u003c n; a++)\n    for (let b = a + 1; b \u003c n; b++)\n      for (let c = b + 1; c \u003c n; c++) {\n        const ax = X[a], ay = Y[a], bx = X[b] - ax, by = Y[b] - ay, cx = X[c] - ax, cy = Y[c] - ay;\n        const d = 2 * (bx * cy - by * cx);\n        if (abs(d) \u003c 1e-9) continue;\n        const b2 = bx * bx + by * by, c2 = cx * cx + cy * cy, ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d;\n        const R2 = ux * ux + uy * uy, ox = ax + ux, oy = ay + uy;\n        let ok = true;\n        for (let e = 0; e \u003c n && ok; e++) {\n          if (e === a || e === b || e === c) continue;\n          const dx = X[e] - ox, dy = Y[e] - oy;\n          if (dx * dx + dy * dy \u003c R2 * (1 - 1e-9)) ok = false;\n        }\n        if (ok) T.push({ v: [a, b, c], x: ox, y: oy, R: sqrt(R2), e: [] });\n      }\n  const emap = new Map(), E = [];\n  T.forEach((t) => {\n    const [a, b, c] = t.v;\n    for (const [p, q, o] of [[a, b, c], [a, c, b], [b, c, a]]) {\n      const k = p * 64 + q;\n      let e = emap.get(k);\n      if (!e) {\n        e = { a: p, b: q, v: 0.5 * Math.hypot(X[q] - X[p], Y[q] - Y[p]), att: null, o: 0 };\n        emap.set(k, e);\n        E.push(e);\n      }\n      t.e.push(e);\n      if ((X[p] - X[o]) * (X[q] - X[o]) + (Y[p] - Y[o]) * (Y[q] - Y[o]) \u003c 0) e.att = t;\n    }\n  });\n  for (const e of E) if (e.att) e.v = e.att.R;\n  E.sort((p, q) => p.v - q.v);\n  E.forEach((e, i) => (e.o = i));\n  T.sort((p, q) => p.R - q.R);\n  T.forEach((t, i) => (t.o = i));\n  // H0: every point is born at 0; joining two components kills one.\n  const up = Array.from({ length: n }, (_, i) => i), find = (i) => (up[i] === i ? i : (up[i] = find(up[i])));\n  const h0 = [];\n  for (const e of E) {\n    const ra = find(e.a), rb = find(e.b);\n    if (ra !== rb) {\n      up[ra] = rb;\n      h0.push(e.v);\n    }\n  }\n  while (h0.length \u003c n) h0.push(Infinity);\n  // H1: column reduction.\n  const nw = (E.length + 31) >> 5, tw = (T.length + 31) >> 5, owner = new Int32Array(E.length).fill(-1);\n  const cols = [], vs = [], h1 = [];\n  const top = (c) => {\n    for (let w = nw - 1; w >= 0; w--) if (c[w]) return 32 * w + 31 - Math.clz32(c[w]);\n    return -1;\n  };\n  const bits = (c, w) => {\n    const out = [];\n    for (let i = 0; i \u003c 32 * w; i++) if (c[i >> 5] & (1 \u003c\u003c (i & 31))) out.push(i);\n    return out;\n  };\n  let zero = 0;\n  T.forEach((t, j) => {\n    const col = new Uint32Array(nw), vv = new Uint32Array(tw);\n    for (const e of t.e) col[e.o >> 5] ^= 1 \u003c\u003c (e.o & 31);\n    vv[j >> 5] |= 1 \u003c\u003c (j & 31);\n    let low = top(col);\n    while (low >= 0 && owner[low] >= 0) {\n      const k = owner[low];\n      for (let w = 0; w \u003c nw; w++) col[w] ^= cols[k][w];\n      for (let w = 0; w \u003c tw; w++) vv[w] ^= vs[k][w];\n      low = top(col);\n    }\n    cols.push(col);\n    vs.push(vv);\n    if (low \u003c 0) return;\n    owner[low] = j;\n    const b = E[low].v, d = t.R;\n    if (d - b > 1e-9) h1.push({ b, d, cyc: bits(col, nw), reg: bits(vv, tw) });\n    else zero++;\n  });\n  let essential = 0;\n  E.forEach((e, i) => {\n    if (owner[i] \u003c 0) essential++;\n  });\n  // Edges that joined components are never pivots, so essential counts the\n  // n - 1 of them plus any loop that never closed (none in a triangulated\n  // disk). zero counts loops filled at the radius they closed.\n  return { T, E, h0, h1, zero, essential: essential - (n - 1) };\n}\n\n// Rebuild the complex, the per-LED maps of the cloud and the barcode's rows.\nfunction build(S) {\n  place(S);\n  const { X, Y, n } = S, K = (S.K = persistence(X, Y, n));\n  const { T, h0, h1 } = K;\n  let far = 0;\n  for (const d of h0) if (d \u003c Infinity) far = max(far, d);\n  for (const c of h1) far = max(far, c.d);\n  K.rMax = max(8, far * 1.12);\n  // Each loop's colour: the three most persistent loops, when they are\n  // long enough to be the rings' holes, get a colour each, the rest one more.\n  const ranked = [...h1].sort((p, q) => q.d - q.b - (p.d - p.b)), top = ranked.length ? ranked[0].d - ranked[0].b : 0;\n  ranked.forEach((c, i) => (c.col = i \u003c 3 && c.d - c.b > 0.3 * top ? i : 3));\n  // Nearest point and containing triangle for every LED of the cloud.\n  const P = CH * W;\n  K.dm = new Float32Array(P);\n  K.tri = new Int16Array(P).fill(-1);\n  for (let p = 0; p \u003c P; p++) {\n    const x = (p % W) + 0.5, y = floor(p / W) + 0.5;\n    let d = 1e9;\n    for (let i = 0; i \u003c n; i++) d = min(d, (X[i] - x) ** 2 + (Y[i] - y) ** 2);\n    K.dm[p] = sqrt(d);\n  }\n  for (const t of T) {\n    const [a, b, c] = t.v, x0 = max(0, floor(min(X[a], X[b], X[c]))), x1 = min(W - 1, floor(max(X[a], X[b], X[c])));\n    const y0 = max(0, floor(min(Y[a], Y[b], Y[c]))), y1 = min(CH - 1, floor(max(Y[a], Y[b], Y[c])));\n    const s = (X[b] - X[a]) * (Y[c] - Y[a]) - (Y[b] - Y[a]) * (X[c] - X[a]);\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x + 0.5, py = y + 0.5;\n        const w0 = ((X[b] - px) * (Y[c] - py) - (Y[b] - py) * (X[c] - px)) * s;\n        const w1 = ((X[c] - px) * (Y[a] - py) - (Y[c] - py) * (X[a] - px)) * s;\n        const w2 = ((X[a] - px) * (Y[b] - py) - (Y[a] - py) * (X[b] - px)) * s;\n        if (w0 >= 0 && w1 >= 0 && w2 >= 0) K.tri[y * W + x] = t.o;\n      }\n  }\n  // Which loops each triangle lies inside, the soonest to close first.\n  K.own = T.map(() => []);\n  [...h1].sort((p, q) => p.d - q.d).forEach((c) => c.reg.forEach((j) => K.own[j].push(c)));\n  // Barcode rows: H0 from the longest down, then H1 by birth. The rings'\n  // bars come first, as thick as the room allows up to 4 rows. The short\n  // bars then take one row each from what is left, longest first; those\n  // that do not fit are left out. A dark row stands between bars.\n  const room = H - 2 - (BT + n + 3), long = ranked.filter((c) => c.col \u003c 3);\n  let th = 4;\n  while (th > 1 && long.length * (th + 1) > room + 1) th--;\n  let left = room + 1 - long.length * (th + 1);\n  const shown = [...long];\n  for (const c of ranked) if (c.col === 3 && left >= 2) shown.push(c), (left -= 2);\n  shown.sort((p, q) => p.b - q.b);\n  K.rows = [];\n  [...h0].sort((p, q) => q - p).forEach((d, i) => K.rows.push({ y: BT + i, b: 0, d, col: -1, h: 1 }));\n  let y = BT + n + 3;\n  for (const c of shown) {\n    const h = c.col \u003c 3 ? th : 1;\n    K.rows.push({ y, b: c.b, d: c.d, col: c.col, h });\n    y += h + 1;\n  }\n}\n\nfunction plot(buf, x, y, c, a) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= CH) return;\n  const o = 3 * (y * W + x);\n  buf[o] = max(buf[o], c[0] * a);\n  buf[o + 1] = max(buf[o + 1], c[1] * a);\n  buf[o + 2] = max(buf[o + 2], c[2] * a);\n}\nfunction line(buf, x0, y0, x1, y1, c, a) {\n  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n  for (let i = 0; i \u003c= n; i++) plot(buf, floor(x0 + ((x1 - x0) * i) / n), floor(y0 + ((y1 - y0) * i) / n), c, a);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.noise = cl(k[2], 0, 1);\n  S.rings = round(cl(k[3], 1, 3));\n  const btn = !!(input.btnPressed && input.btnPressed[0]);\n  if (btn && !S.btn) {\n    fresh(S);\n    S.t = 0;\n    S.first = false;\n  }\n  S.btn = btn;\n  S.t += (d * S.speed) / 2;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    S.first = false;\n    fresh(S);\n  }\n  const key = `${S.seed} ${S.rings} ${S.noise.toFixed(2)}`;\n  if (key !== S.key) {\n    S.key = key;\n    build(S);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.K) return;\n  const K = S.K, buf = S.buf, pal = S.pal, X = S.X, Y = S.Y;\n  const r = K.rMax * cl(S.t / GROW, 0, 1);\n  const fade = cl((CYCLE - S.t) / FADE, 0, 1) * (S.first ? 1 : cl(S.t / 0.3, 0, 1));\n  // Palette: 0..3 the loops, 4 merging (H0), 5 disks, 6 triangles, 7\n  // points. The dim colours stay in the cool half of the wheel and the\n  // merging colour is pale, so neither goes brown; only the bright loop\n  // colours turn the whole way round.\n  const u = S.hue, sw = sin(PI * u) ** 2, cool = 0.72 - 0.38 * sw, pale = 0.52 + 0.3 * sw;\n  hsv(u + 0.07, 0.92, 1, pal, 0);\n  hsv(u + 0.9, 0.72, 1, pal, 3);\n  hsv(u + 0.15, 0.85, 1, pal, 6);\n  hsv(u + 0.98, 0.4, 0.85, pal, 9);\n  hsv(pale, 0.55, 0.95, pal, 12);\n  hsv(cool, 0.7, 1, pal, 15);\n  hsv(cool - 0.05, 0.55, 1, pal, 18);\n  hsv(pale, 0.12, 1, pal, 21);\n  const C = (i) => [pal[3 * i], pal[3 * i + 1], pal[3 * i + 2]];\n  const cLoop = [C(0), C(1), C(2), C(3)], cH0 = C(4), cDisk = C(5), cTri = C(6), cPt = C(7);\n  buf.fill(0);\n  // The union of disks with its scalloped edge, the triangles in it, each\n  // open hole lined with its loop's colour, and the hole that just closed\n  // flashing.\n  const flashR = 0.06 * K.rMax;\n  for (let p = 0, P = CH * W; p \u003c P; p++) {\n    const dm = K.dm[p], t = K.tri[p], o = 3 * p;\n    let a = 0;\n    if (dm \u003c= r + 0.5) a = 0.17 * cl(r + 0.5 - dm, 0, 1) + (r - dm \u003c 1.2 && r > 0.8 ? 0.2 : 0);\n    let rr = cDisk[0] * a, gg = cDisk[1] * a, bb = cDisk[2] * a;\n    if (t >= 0) {\n      if (K.T[t].R \u003c= r) (rr += cTri[0] * 0.12), (gg += cTri[1] * 0.12), (bb += cTri[2] * 0.12);\n      for (const cy of K.own[t]) {\n        if (cy.b \u003c= r && r \u003c cy.d) {\n          const e = dm - r;\n          if (e > 0) {\n            const L = cLoop[cy.col], q = e \u003c 1 ? 0.9 : e \u003c 2 ? 0.38 : 0;\n            (rr = L[0] * q), (gg = L[1] * q), (bb = L[2] * q);\n          }\n          break;\n        }\n        if (r >= cy.d && r - cy.d \u003c flashR) {\n          const L = cLoop[cy.col], q = 0.7 * (1 - (r - cy.d) / flashR);\n          (rr += L[0] * q), (gg += L[1] * q), (bb += L[2] * q);\n          break;\n        }\n      }\n    }\n    buf[o] = rr;\n    buf[o + 1] = gg;\n    buf[o + 2] = bb;\n  }\n  // Edges that have entered, bright as they arrive and dimmer after.\n  for (const e of K.E) {\n    if (e.v > r) break;\n    const a = 0.32 + 0.5 * Math.exp(-(r - e.v) / (0.05 * K.rMax));\n    line(buf, X[e.a], Y[e.a], X[e.b], Y[e.b], cH0, a);\n  }\n  // The loops that are alive, each in its bar's colour.\n  for (const c of K.h1)\n    if (c.b \u003c= r && r \u003c c.d) for (const i of c.cyc) line(buf, X[K.E[i].a], Y[K.E[i].a], X[K.E[i].b], Y[K.E[i].b], cLoop[c.col], 1);\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = floor(X[i]), y = floor(Y[i]);\n    plot(buf, x, y, cPt, 1);\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) plot(buf, x + dx, y + dy, cPt, 0.3);\n  }\n  // The ruler: a tick every 4 LEDs of radius, the sweep's place bright.\n  const span = W - 2, col = (v) => 1 + round((min(v, K.rMax) / K.rMax) * span), xs = col(r);\n  const set = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = 3 * (y * W + x);\n    buf[o] = max(buf[o], c[0] * a);\n    buf[o + 1] = max(buf[o + 1], c[1] * a);\n    buf[o + 2] = max(buf[o + 2], c[2] * a);\n  };\n  for (let v = 0; v \u003c= K.rMax; v += 4) set(col(v), H - 1, cPt, 0.35);\n  for (let x = 0; x \u003c W; x += 2) set(x, BT - 2, cH0, 0.2);\n  set(xs, H - 1, cPt, 1);\n  // Bars: solid up to the sweep, brightest while alive; dotted beyond it,\n  // where the sweep has yet to go. The sweep line runs down between them\n  // to the ruler on the bottom row.\n  for (let y = BT - 1; y \u003c H - 1; y++) set(xs, y, cPt, 0.2);\n  for (const row of K.rows) {\n    const c = row.col \u003c 0 ? cH0 : cLoop[row.col], x0 = col(row.b), x1 = max(x0, row.d === Infinity ? W - 1 : col(row.d) - 1);\n    const alive = row.b \u003c= r && r \u003c row.d, h = row.h;\n    for (let j = 0; j \u003c h; j++) {\n      const y = row.y + j, rim = j === 0 || j === h - 1;\n      for (let x = x0; x \u003c= x1; x++) {\n        if (x \u003c= xs) set(x, y, c, alive ? 1 : row.col \u003c 0 ? 0.62 : 0.8);\n        else if ((rim && (x - x0) % 2 === 0) || x === x1) set(x, y, c, 0.4);\n      }\n      if (alive) set(xs, y, cPt, 1);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      display.setPixel(x, y, round(cl(buf[o] * fade, 0, 1) * 255), round(cl(buf[o + 1] * fade, 0, 1) * 255), round(cl(buf[o + 2] * fade, 0, 1) * 255));\n    }\n}\n","phantom-jam":"// ===== Patternflow pattern =====\n// Title:   Phantom Jam\n// Family:  sim\n// Idea:    Cars run round a tall ring road at the panel's edge, each driver easing toward the speed its gap allows, and with no crash or roadworks a stop-and-go jam forms and creeps backward round the ring while every car keeps going forward, as the space-time diagram inside the track shows with car lines slanting one way and red jam stripes the other.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the optimal velocity model of traffic (Masako Bando, Katsuya Hasebe, Akihiro Nakayama, Akihiro Shibata and Yuki Sugiyama, 1995) and the circuit experiment of Yuki Sugiyama and seven others (2008), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cars=22..44, Sensitivity=0.5..2.5\n//\n// Knob 1: Hue. The colour of free flow, on the moving cars and their lines: cyan green at 0, blue at 0.5, violet at 1. Stopped cars and the jam stripes stay brake red, with amber for the speeds between. One car stays white so its line can be followed through the jams.\n// Knob 2: Speed. At 2 a car at full speed laps the ring in 5 seconds, or 11 at the even spacing of 22 cars, and the diagram takes 10 new rows a second, so it holds the last 11.6 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Cars. How many cars share the ring, from 22, the number in Sugiyama's circuit, to 44. Turning it lets a car join at the widest gap or leave from the tightest, which is a kink of its own. More cars mean shorter gaps and slower flow: at 44 the ring crawls in amber between red queues.\n// Knob 4: Sensitivity. How hard each driver chases the speed its gap allows, the model's a. Uniform flow is unstable when a is below twice the slope of the speed law at its gap. At 0.5 every number of cars jams hard and the queues stand still. At 1.5 only 22 to 29 cars are unstable, and a wave takes about a minute to grow. From 2 on every kink heals and the lines run parallel.\n// Buttons: K1 tap makes the driver nearest the start line, the white tick at the bottom of the track, brake to a stop.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, tanh, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The model. Ring length in model units, the headway where the speed law is\n// steepest, and the speed law V(h) = tanh(h - C) + tanh(C), which runs from\n// 0 at h = 0 to VMAX for long gaps. Uniform flow at headway h is unstable\n// when a \u003c 2 V'(h) = 2 / cosh(h - C)^2.\nconst L = 39, C = 1.87, VMAX = 2 * tanh(C);\nconst V = (h) => tanh(h - C) + tanh(C);\n// Fixed physics step, the smallest bumper-to-bumper headway (a car is 0.35\n// units long), and the model time between two rows of the diagram.\nconst DT = 0.05, HMIN = 0.47, ROW = 0.4;\n\n// The track's centre line: straights at x = 3 and x = 61 from y = 14 to\n// y = 114, joined by half ellipses 29 LEDs across and 11 deep. Arc length s\n// starts at the bottom middle and runs right along the bottom, up the right\n// straight, over the top and down the left.\nconst CX = 32, XL = 3, XR = 61, YT = 14, YB = 114, RX = 29, RY = 11;\nconst PT = [];\n{\n  const n = 400;\n  for (let i = 0; i \u003c= n; i++) {\n    const a = ((PI / 2) * i) / n;\n    PT.push([CX + RX * sin(a), YB + RY * cos(a)]);\n  }\n  for (let i = 1; i \u003c= n; i++) PT.push([XR, YB - ((YB - YT) * i) / n]);\n  for (let i = 1; i \u003c= 2 * n; i++) {\n    const a = (PI * i) / (2 * n);\n    PT.push([CX + RX * cos(a), YT - RY * sin(a)]);\n  }\n  for (let i = 1; i \u003c= n; i++) PT.push([XL, YT + ((YB - YT) * i) / n]);\n  for (let i = 1; i \u003c= n; i++) {\n    const a = ((PI / 2) * i) / n;\n    PT.push([CX - RX * cos(a), YB + RY * sin(a)]);\n  }\n  let s = 0;\n  PT[0].push(0);\n  for (let i = 1; i \u003c PT.length; i++) PT[i].push((s += Math.hypot(PT[i][0] - PT[i - 1][0], PT[i][1] - PT[i - 1][1])));\n}\nconst LT = PT[PT.length - 1][2], NB = ceil(LT);\n// Where s is on the panel, every half LED of arc.\nconst SX = new Float32Array(2 * NB + 2), SY = new Float32Array(2 * NB + 2);\nfor (let i = 0, j = 0; i \u003c SX.length; i++) {\n  const s = (i / 2) % LT;\n  if (s \u003c PT[j][2]) j = 0;\n  while (j \u003c PT.length - 2 && PT[j + 1][2] \u003c s) j++;\n  const a = PT[j], b = PT[j + 1], u = (s - a[2]) / (b[2] - a[2] || 1);\n  SX[i] = a[0] + (b[0] - a[0]) * u;\n  SY[i] = a[1] + (b[1] - a[1]) * u;\n}\n\n// Every LED's arc length and its distance from the centre line (negative\n// inside), then its part: 0 dark, 1 outer kerb, 2 lane, 3 inner kerb, 4 the\n// gap, 5 the diagram.\nconst TS = new Float32Array(N), KIND = new Uint8Array(N);\n// The diagram: 52 columns for the ring unrolled, 116 rows of time.\nconst DX0 = 6, DY0 = 6, DCOL = 52, DROWS = 116;\nconst DIAG = [];\n{\n  const sR = PT[400][2], sL = PT[1600][2];\n  const cap = PT.filter((q) => q[1] \u003c YT || q[1] > YB);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, px = x + 0.5, py = y + 0.5;\n      let d, s;\n      if (py >= YT && py \u003c= YB) {\n        const dl = px - XL, dr = XR - px;\n        if (dl \u003c dr) (d = -dl), (s = sL + (py - YT));\n        else (d = -dr), (s = sR + (YB - py));\n      } else {\n        let best = 1e9, q = cap[0];\n        for (const c of cap) {\n          const e = (c[0] - px) ** 2 + (c[1] - py) ** 2;\n          if (e \u003c best) (best = e), (q = c);\n        }\n        const ey = py \u003c YT ? YT : YB, inside = ((px - CX) / RX) ** 2 + ((py - ey) / RY) ** 2 \u003c 1;\n        d = inside ? -sqrt(best) : sqrt(best);\n        s = q[2];\n      }\n      TS[p] = s;\n      const k = d > 2 ? 0 : d > 1 ? 1 : d > -1 ? 2 : d > -2 ? 3 : d > -3 ? 4 : 5;\n      KIND[p] = k;\n      if (k === 5) DIAG.push(p, x - DX0, y - DY0);\n    }\n}\n// Lane LEDs by whole LED of arc, for drawing cars.\nconst LANE = Array.from({ length: NB }, () => []);\nfor (let p = 0; p \u003c N; p++) if (KIND[p] === 2) LANE[floor(TS[p]) % NB].push(p);\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, speed: 2, n: 0, a: 0.5, clock: 0, head: 0, cars: [],\n    lineA: new Float32Array(DROWS * DCOL), lineF: new Float32Array(DROWS * DCOL), field: new Float32Array(DROWS * DCOL),\n    lut: new Float32Array(66 * 6), buf: new Float32Array(N * 3), ready: false,\n  };\n}\n\n// The colour of a speed, f = v / VMAX: brake red when stopped, amber at an\n// eighth of top speed, the free-flow colour from a third of it.\nfunction speedColour(f, mov) {\n  if (f \u003c 0.12) {\n    const u = sm((f - 0.03) / 0.09);\n    return [1, 0.06 + 0.44 * u, 0.03 * (1 - u)];\n  }\n  const u = sm((f - 0.12) / 0.23), c = [1 + (mov[0] - 1) * u, 0.5 + (mov[1] - 0.5) * u, mov[2] * u], m = max(c[0], c[1], c[2]);\n  return [c[0] / m, c[1] / m, c[2] / m];\n}\n\n// One physics step of every driver: dv/dt = a (V(h) - v), with a little\n// jitter in each driver's foot. A braking driver aims for 0 instead.\nfunction step(S) {\n  const cars = S.cars, n = cars.length;\n  for (let i = 0; i \u003c n; i++) {\n    const c = cars[i], h = (cars[(i + 1) % n].x - c.x + L) % L || L;\n    let acc = S.a * (V(h) - c.v);\n    if (c.brake > 0) {\n      acc = -2.5 * c.v;\n      c.brake -= DT;\n    }\n    c.acc = acc + 0.06 * (Math.random() - 0.5);\n  }\n  for (const c of cars) {\n    c.v = max(0, c.v + c.acc * DT);\n    c.x = (c.x + c.v * DT) % L;\n  }\n  // No one drives into the car ahead.\n  for (let i = 0; i \u003c n; i++) {\n    const c = cars[i], f = cars[(i + 1) % n], h = (f.x - c.x + L) % L;\n    if (n > 1 && h \u003c HMIN) {\n      c.x = (f.x - HMIN + L) % L;\n      c.v = min(c.v, f.v);\n    }\n  }\n  if ((S.clock += DT) >= ROW - 1e-9) {\n    S.clock -= ROW;\n    record(S);\n  }\n}\n\n// A new top row of the diagram: each car's stretch since the last row as a\n// line one column wide, coloured by its speed, over the speed field between\n// the cars, which shows dark red where the traffic stands.\nfunction record(S) {\n  const cars = S.cars, n = cars.length;\n  S.head = (S.head + 1) % DROWS;\n  const o = S.head * DCOL, A = S.lineA, F = S.lineF, G = S.field;\n  A.fill(0, o, o + DCOL);\n  G.fill(1, o, o + DCOL);\n  for (const c of cars) {\n    const c1 = (c.x / L) * DCOL;\n    let c0 = c.pc \u003c 0 ? c1 : c.pc;\n    if (c0 > c1 + DCOL / 2) c0 -= DCOL;\n    const lo = min(c1 - 0.5, c0 + 0.5), hi = c1 + 0.5, f = c.tr ? 2 : c.v / VMAX;\n    for (let j = floor(lo); j \u003c= floor(hi); j++) {\n      const cov = min(hi, j + 1) - max(lo, j), jj = (j + DCOL) % DCOL;\n      if (cov > A[o + jj] || (c.tr && cov > 0.3)) (A[o + jj] = cov), (F[o + jj] = f);\n    }\n    c.pc = c1;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    const c = cars[i], d = cars[(i + 1) % n], x0 = (c.x / L) * DCOL;\n    let x1 = (d.x / L) * DCOL;\n    if (x1 \u003c= x0) x1 += DCOL;\n    const f0 = c.v / VMAX, f1 = d.v / VMAX;\n    for (let j = ceil(x0 - 0.5); j \u003c= floor(x1 - 0.5); j++) {\n      const u = (j + 0.5 - x0) / (x1 - x0 || 1);\n      G[o + (j % DCOL)] = f0 + (f1 - f0) * u;\n    }\n  }\n}\n\n// Cars evenly spaced at the equilibrium speed, then the diagram's whole\n// height of history run at once, one driver lifting off a little at the\n// start of it.\nfunction begin(S) {\n  const n = S.n, h0 = L / n, v0 = V(h0);\n  S.cars = [];\n  for (let i = 0; i \u003c n; i++) S.cars.push({ x: i * h0, v: v0, acc: 0, brake: 0, pc: -1 });\n  S.cars[0].v = v0 * 0.6;\n  S.cars[0].tr = true;\n  S.lineA.fill(0);\n  S.field.fill(1);\n  S.clock = 0;\n  const steps = round((DROWS * ROW) / DT);\n  for (let i = 0; i \u003c steps; i++) step(S);\n}\n\n// K3 moved: one car joins in the widest gap or leaves the tightest.\nfunction retune(S) {\n  const cars = S.cars, n = cars.length;\n  let best = -1, at = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const h = (cars[(i + 1) % n].x - cars[i].x + L) % L;\n    if (S.n > n ? h > best : best \u003c 0 || h \u003c best) (best = h), (at = i);\n  }\n  if (S.n > n) {\n    const a = cars[at], b = cars[(at + 1) % n];\n    cars.splice(at + 1, 0, { x: (a.x + best / 2) % L, v: (a.v + b.v) / 2, acc: 0, brake: 0, pc: -1 });\n  } else {\n    if (cars[at].tr) cars[(at + 1) % n].tr = true;\n    cars.splice(at, 1);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.a = cl(k[3], 0.5, 2.5);\n  S.n = round(cl(k[2], 22, 44));\n  if (!S.ready) {\n    S.ready = true;\n    begin(S);\n  } else if (S.n !== S.cars.length) retune(S);\n  if (input.btnPressed && input.btnPressed[0]) {\n    let best = 1e9, who = S.cars[0];\n    for (const c of S.cars) {\n      const e = min(c.x, L - c.x);\n      if (e \u003c best) (best = e), (who = c);\n    }\n    who.brake = 2;\n  }\n  S.acc = (S.acc || 0) + d * S.speed * 2;\n  while (S.acc >= DT) {\n    S.acc -= DT;\n    step(S);\n  }\n  // Hue: free flow from cyan green round to violet.\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    S.mov = hsv(0.42 + 0.4 * hue, 0.85, 1);\n    // Lines: stopped cars bright, free ones dimmer, so the jams stand out\n    // of the hatching; the last entry is the one white car. Under them the\n    // speed field, dark red where the traffic stands.\n    for (let i = 0; i \u003c= 65; i++) {\n      const f = i / 64, c = i > 64 ? [1, 1, 1] : speedColour(f, S.mov), b = i > 64 ? 1 : 0.95 - 0.45 * sm((f - 0.05) / 0.3), o = 6 * i, jam = 0.22 * sm(1 - f / 0.12);\n      S.lut[o] = c[0] * b;\n      S.lut[o + 1] = c[1] * b;\n      S.lut[o + 2] = c[2] * b;\n      S.lut[o + 3] = jam;\n      S.lut[o + 4] = jam * 0.08;\n      S.lut[o + 5] = jam * 0.12;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const buf = S.buf, lut = S.lut, mov = S.mov;\n  buf.fill(0);\n  // The diagram, newest row at the top.\n  const A = S.lineA, F = S.lineF, G = S.field;\n  for (let i = 0; i \u003c DIAG.length; i += 3) {\n    const p = DIAG[i], r = (S.head - DIAG[i + 2] + DROWS) % DROWS, o = r * DCOL + DIAG[i + 1];\n    const g = 6 * round(cl(G[o], 0, 1) * 64), a = A[o] * (0.9 - (0.5 * DIAG[i + 2]) / DROWS), l = 6 * (F[o] > 1.5 ? 65 : round(cl(F[o], 0, 1) * 64)), q = 3 * p;\n    buf[q] = lut[g + 3] + lut[l] * a;\n    buf[q + 1] = lut[g + 4] + lut[l + 1] * a;\n    buf[q + 2] = lut[g + 5] + lut[l + 2] * a;\n  }\n  // The road: dim kerbs tinted by the free-flow colour, dark lane, a white\n  // start line at the bottom middle.\n  const kerb = [0.12 + 0.08 * mov[0], 0.12 + 0.08 * mov[1], 0.12 + 0.08 * mov[2]];\n  for (let p = 0; p \u003c N; p++) {\n    const k = KIND[p], q = 3 * p;\n    if (k === 1 || k === 3) (buf[q] = kerb[0]), (buf[q + 1] = kerb[1]), (buf[q + 2] = kerb[2]);\n    else if (k === 2) {\n      const sl = TS[p] \u003c 1 || TS[p] > LT - 1;\n      buf[q] = sl ? 0.5 : 0.04;\n      buf[q + 1] = sl ? 0.5 : 0.04;\n      buf[q + 2] = sl ? 0.5 : 0.05;\n    }\n  }\n  // Brake lights glow on the road round each braking car's tail.\n  for (const c of S.cars) {\n    if (c.acc > -0.12 && c.v > 0.08) continue;\n    const s = (c.x / L) * LT, gx = SX[round(2 * s) % SX.length], gy = SY[round(2 * s) % SY.length];\n    const amp = c.v \u003c 0.08 ? 0.35 : 0.5;\n    for (let y = floor(gy - 4); y \u003c= ceil(gy + 4); y++)\n      for (let x = floor(gx - 4); x \u003c= ceil(gx + 4); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const r = Math.hypot(x + 0.5 - gx, y + 0.5 - gy);\n        if (r > 4) continue;\n        const w = amp * (1 - r / 4) ** 2, q = 3 * (y * W + x);\n        buf[q] += w;\n        buf[q + 1] += w * 0.06;\n        buf[q + 2] += w * 0.04;\n      }\n  }\n  // The cars: dashes three LEDs long, coloured by speed, tail lit red when braking.\n  for (const c of S.cars) {\n    const sr = (c.x / L) * LT, col = c.tr ? [1, 1, 1] : speedColour(c.v / VMAX, mov), braking = c.acc \u003c -0.12 || c.v \u003c 0.08;\n    for (let b = floor(sr) - 1; b \u003c= floor(sr) + 4; b++) {\n      for (const p of LANE[((b % NB) + NB) % NB]) {\n        let u = TS[p] - sr;\n        if (u \u003c -LT / 2) u += LT;\n        if (u > LT / 2) u -= LT;\n        const cov = min(u + 0.5, 3) - max(u - 0.5, 0);\n        if (cov \u003c= 0) continue;\n        const q = 3 * p, w = min(1, cov);\n        const tail = braking && u \u003c 1, front = u > 2;\n        const r = tail ? 1 : front ? 0.6 + 0.4 * col[0] : col[0], g = tail ? 0.05 : front ? 0.6 + 0.4 * col[1] : col[1], bl = tail ? 0.03 : front ? 0.6 + 0.4 * col[2] : col[2];\n        buf[q] += (r - buf[q]) * w;\n        buf[q + 1] += (g - buf[q + 1]) * w;\n        buf[q + 2] += (bl - buf[q + 2]) * w;\n      }\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const q = 3 * p;\n      display.setPixel(x, y, round(cl(buf[q], 0, 1) * 255), round(cl(buf[q + 1], 0, 1) * 255), round(cl(buf[q + 2], 0, 1) * 255));\n    }\n}\n","sato-tate":"// ===== Patternflow pattern =====\n// Title:   Sato-Tate\n// Family:  number\n// Idea:    Primes rain down the panel, each dropping at the column of a_p / (2 sqrt p) for an elliptic curve counted exactly mod p, and pile into a histogram that fills the faint semicircle (2/pi) sqrt(1 - x^2) layer by layer, each new layer as many primes as all the layers under it, while a curve with complex multiplication sends half its primes down the middle and heaps the rest against the walls.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Sato-Tate conjecture (Mikio Sato and John Tate, 1963), proved for elliptic curves without complex multiplication (Laurent Clozel, Michael Harris, Nicholas Shepherd-Barron and Richard Taylor, 2008-2011), pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Curve=0..1, Bins=-1..1\n//\n// Knob 1: Hue. Turns the layers round the wheel. At 0 the first layer of primes is cyan and each later one a step further round, through azure and blue to violet and rose at the top of the full pile; at 0.5 the first is red and the later ones orange, yellow, lime and green. The outline stays a pale cream.\n// Knob 2: Speed. At 2 the first drop lands at 0.9 seconds, the first 512 primes fill the dome by 2.6, the next four layers take 2.9, 4.5, 8.2 and 24 seconds, the last reaching p = 84,053, and after a 2.5 second hold the pile sinks and the count starts again from p = 3. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Curve. Three curves in steps. Below 1/3 the curve 37a, y^2 + y = x^3 - x, with no complex multiplication, whose primes fill the semicircle; from 1/3 y^2 = x^3 - x, where every p = 3 mod 4 has a_p = 0 and falls down the middle, and the rest follow 1/(pi sqrt(1 - x^2)) up the two walls; from 2/3 y^2 = x^3 + 1, the same for p = 2 mod 3. A new curve starts the count again.\n// Knob 4: Bins. How the 63 columns of the plot are grouped: at -1 seven bins 9 LEDs wide, at -0.5 nine bins of 7, from -0.2 (so at the opening 0.06) 21 bins of 3, and from 0.6 every column its own bin. The counts are kept per column, so the bars regroup at once.\n// Buttons: K1 tap lets the pile sink now and starts the count again from p = 3.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sqrt, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The plot: x = a_p / (2 sqrt p) in [-1, 1] over columns 0..62, x = c/31 - 1,\n// so x = 0 is column 31 and every bin count that divides 63 has a middle bin.\n// The end columns hold half the width of the others.\nconst COLS = 63, MID = 31;\nconst WIDTH = new Float32Array(COLS).fill(1 / 31);\nWIDTH[0] = WIDTH[COLS - 1] = 0.5 / 31;\n// Rows: the readout on rows 1..5, the rain from row 7, the pile standing on\n// row 127. A density of 2/pi, the top of the semicircle, stands 50 rows tall;\n// no bar stands above 72.\nconst TOP = 7, BASE = 127, HS = 50 / (2 / PI), HMAX = 72;\n// Drops in rows and story seconds: they leave at V0 and gain G a second.\nconst V0 = 55, G = 170;\n\n// The three curves, each as the cubic f with y^2 = f(x) (after completing the\n// square, so 37a's y^2 + y = x^3 - x is (2y + 1)^2 = 4x^3 - 4x + 1), with the\n// odd primes of bad reduction to skip, and its law: 0 the semicircle, 1 half\n// the mass at 0 and half on 1/(pi sqrt(1 - x^2)).\nconst CURVES = [\n  { f: [4, 0, -4, 1], bad: 37, cm: 0 },\n  { f: [1, 0, -1, 0], bad: 0, cm: 1 },\n  { f: [1, 0, 0, 1], bad: 3, cm: 1 },\n];\n// The density of each law at x, without the point mass.\nconst law = (cm, x) => (cm ? 1 / (2 * PI * sqrt(max(1e-6, 1 - x * x))) : (2 / PI) * sqrt(max(0, 1 - x * x)));\n\n// The odd primes below 86,000, by a sieve: 8,400 of them, enough for the\n// 8,192 a run counts on every curve.\nconst PMAX = 86000;\nconst PRIMES = (() => {\n  const comp = new Uint8Array(PMAX), out = [];\n  for (let i = 3; i \u003c PMAX; i += 2) {\n    if (comp[i]) continue;\n    out.push(i);\n    for (let j = i * i; j \u003c PMAX; j += 2 * i) comp[j] = 1;\n  }\n  return Int32Array.from(out);\n})();\n\n// a_p = p + 1 - #E(F_p) = -(sum over x of the Legendre symbol (f(x) | p)),\n// exactly: a table of the squares mod p, then f(x) walked by its finite\n// differences, so the loop over x adds and never multiplies.\nconst CHI = new Int8Array(PMAX);\nfunction ap(p, c) {\n  CHI.fill(-1, 0, p);\n  CHI[0] = 0;\n  for (let i = 1, sq = 0, n = (p - 1) >> 1; i \u003c= n; i++) {\n    sq += 2 * i - 1;\n    if (sq >= p) sq -= p;\n    CHI[sq] = 1;\n  }\n  const m = (v) => ((v % p) + p) % p;\n  let f = m(c[3]), d1 = m(c[0] + c[1] + c[2]), d2 = m(6 * c[0] + 2 * c[1]), s = 0;\n  const d3 = m(6 * c[0]);\n  for (let x = 0; x \u003c p; x++) {\n    s += CHI[f];\n    f = f + d1 - p;\n    f += (f >> 31) & p;\n    d1 = d1 + d2 - p;\n    d1 += (d1 >> 31) & p;\n    d2 = d2 + d3 - p;\n    d2 += (d2 >> 31) & p;\n  }\n  return -s;\n}\n\n// Layers: the first 512 primes, then each layer as many as all before it.\n// The pile is drawn so the layers so far fill the outline, and when a layer\n// is in, the scale halves for the next.\nconst TARGET = [512, 1024, 2048, 4096, 8192], LAYERS = TARGET.length, LAST = TARGET[LAYERS - 1];\nconst layerOf = (i) => {\n  let k = 0;\n  while (i >= TARGET[k]) k++;\n  return k;\n};\n// How many primes have left the top by story time t of a run, piecewise linear.\nconst KNOTS = [[0, 0], [1.9, 512], [4.8, 1024], [9.3, 2048], [17.5, 4096], [41.5, LAST]];\nfunction countAt(t) {\n  for (let i = 1; i \u003c KNOTS.length; i++) {\n    const [t0, n0] = KNOTS[i - 1], [t1, n1] = KNOTS[i];\n    if (t \u003c t1) return n0 + ((n1 - n0) * max(0, t - t0)) / (t1 - t0);\n  }\n  return LAST;\n}\nfunction timeOf(n) {\n  for (let i = 1; i \u003c KNOTS.length; i++) {\n    const [t0, n0] = KNOTS[i - 1], [t1, n1] = KNOTS[i];\n    if (n \u003c n1) return t0 + ((t1 - t0) * (n - n0)) / (n1 - n0);\n  }\n  return KNOTS[KNOTS.length - 1][0];\n}\n// Bins on Knob 4: 7, 9, 21 or 63 bins, 9, 7, 3 or 1 columns wide.\nconst binWidth = (k) => (k \u003c -0.6 ? 9 : k \u003c -0.2 ? 7 : k \u003c 0.6 ? 3 : 1);\n\n// Digits 3 x 5 for the readout, a bit per LED from the top left, then a\n// minus sign, a p and an a.\nconst FONT = [0x7b6f, 0x2c97, 0x73e7, 0x73cf, 0x5bc9, 0x79cf, 0x79ef, 0x7292, 0x7bef, 0x7bcf, 0x01c0, 0x7be4, 0x076b];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, bw: 3, curve: -1, t: 0, pi: 0, spawned: 0, landed: 0, sc: 1 / TARGET[0], done: -1, sink: -1,\n    lastP: 0, lastA: 0, shown: [0, 0], shownAt: -1,\n    cnt: new Float32Array(LAYERS * COLS), flash: new Float32Array(COLS), drops: [],\n    height: new Float32Array(COLS), binOf: new Int16Array(COLS), buf: new Float32Array(N * 3), pal: [],\n  };\n  begin(params.s, 0);\n}\n\n// A fresh run on curve k: an empty pile, the primes from 3.\nfunction begin(S, k) {\n  S.curve = k;\n  S.t = 0;\n  S.pi = 0;\n  S.spawned = 0;\n  S.landed = 0;\n  S.sc = 1 / TARGET[0];\n  S.done = -1;\n  S.sink = -1;\n  S.cnt.fill(0);\n  S.flash.fill(0);\n  S.drops.length = 0;\n  S.shownAt = -1;\n}\n\n// Each bar's height in rows, per column, from the counts and the scale.\nfunction heights(S) {\n  const w = S.bw, nb = COLS / w, cnt = S.cnt, h = S.height;\n  for (let b = 0; b \u003c nb; b++) {\n    let n = 0, dx = 0;\n    for (let c = b * w; c \u003c b * w + w; c++) {\n      dx += WIDTH[c];\n      for (let L = 0; L \u003c LAYERS; L++) n += cnt[L * COLS + c];\n    }\n    const v = (n * S.sc * HS) / dx;\n    for (let c = b * w; c \u003c b * w + w; c++) (h[c] = v), (S.binOf[c] = b);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.bw = binWidth(cl(k[3], -1, 1));\n  const curve = min(2, floor(cl(k[2], 0, 1) * 3));\n  if (curve !== S.curve) begin(S, curve);\n  if (input.btnPressed && input.btnPressed[0] && S.sink \u003c 0) S.sink = S.t;\n  const ds = (d * S.speed) / 2, C = CURVES[S.curve];\n  S.t += ds;\n  // New primes leave the top on the schedule, at most 60 a frame.\n  if (S.sink \u003c 0) {\n    const want = min(LAST, floor(countAt(S.t)));\n    for (let n = 0; S.spawned \u003c want && n \u003c 60; n++) {\n      let p = PRIMES[S.pi++];\n      if (p === C.bad) p = PRIMES[S.pi++];\n      const a = ap(p, C.f), x = a / (2 * sqrt(p));\n      S.drops.push({ c: round((x + 1) * MID), t0: timeOf(S.spawned), L: layerOf(S.spawned) });\n      S.spawned++;\n      S.lastP = p;\n      S.lastA = a;\n    }\n  }\n  // The readout keeps each prime for a sixth of a second.\n  if (S.t - S.shownAt > 1 / 6 && S.lastP) (S.shown = [S.lastP, S.lastA]), (S.shownAt = S.t);\n  // The scale: the layers landed so far fill the outline.\n  let e = 0;\n  while (e \u003c LAYERS - 1 && S.landed >= TARGET[e]) e++;\n  S.sc += (1 / TARGET[e] - S.sc) * (1 - exp(-ds / 0.18));\n  heights(S);\n  // Drops fall and land on their bar.\n  const keep = [];\n  for (const D of S.drops) {\n    const s = S.t - D.t0;\n    D.y = TOP + V0 * s + 0.5 * G * s * s;\n    D.v = V0 + G * s;\n    const floorY = S.sink >= 0 ? H + 12 : BASE + 1 - min(HMAX, S.height[D.c]);\n    if (D.y >= floorY) {\n      if (S.sink \u003c 0) {\n        S.cnt[D.L * COLS + D.c]++;\n        S.landed++;\n        S.flash[D.c] = 1;\n      }\n      continue;\n    }\n    keep.push(D);\n  }\n  S.drops = keep;\n  for (let c = 0; c \u003c COLS; c++) S.flash[c] *= exp(-ds / 0.12);\n  // A full run holds for 2.5 seconds, then the pile sinks in 1.5 and the\n  // count starts again.\n  if (S.landed >= LAST && S.done \u003c 0) S.done = S.t;\n  if (S.done >= 0 && S.sink \u003c 0 && S.t > S.done + 2.5) S.sink = S.t;\n  if (S.sink >= 0 && S.t > S.sink + 1.5) begin(S, S.curve);\n}\n\n// Layer colours round the wheel: at Hue 0 the first layer cyan, then azure,\n// blue, violet and rose for the later ones.\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  S.pal = [];\n  for (let L = 0; L \u003c LAYERS; L++) S.pal.push(hsv(0.5 + S.hue + 0.09 * L, 0.82, 1));\n}\n\nfunction glyph(buf, g, x0, y0, c, a) {\n  for (let j = 0; j \u003c 15; j++) {\n    if (!((g >> (14 - j)) & 1)) continue;\n    const x = x0 + (j % 3), y = y0 + floor(j / 3);\n    if (x \u003c 0 || x >= W) continue;\n    const o = 3 * (y * W + x);\n    for (let i = 0; i \u003c 3; i++) buf[o + i] = c[i] * a;\n  }\n}\n// A number in 3 x 5 digits ending at column x1 (right aligned), or starting at x0.\nfunction number(buf, v, x, y, right, c) {\n  const s = String(abs(v)), n = s.length + (v \u003c 0 ? 1 : 0);\n  let px = right ? x - 4 * n + 1 : x;\n  if (v \u003c 0) glyph(buf, FONT[10], px, y, c, 1), (px += 4);\n  for (const ch of s) glyph(buf, FONT[ch.charCodeAt(0) - 48], px, y, c, 1), (px += 4);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const buf = S.buf, pal = S.pal, cnt = S.cnt, w = S.bw, cm = CURVES[S.curve].cm;\n  buf.fill(0);\n  const sink = S.sink >= 0 ? (HMAX + 4) * ease((S.t - S.sink) / 1.5) : 0;\n  // The pile: each column's bar in its layers, oldest at the bottom; a bar\n  // too tall for the panel keeps its layers in proportion under the ceiling.\n  // Every other bin is a shade darker so the bins read apart.\n  const cum = new Float32Array(LAYERS);\n  for (let c = 0; c \u003c COLS; c++) {\n    const b = S.binOf[c], h0 = S.height[c];\n    if (h0 \u003c= 0.02) continue;\n    let tot = 0;\n    for (let L = 0; L \u003c LAYERS; L++) {\n      let n = 0;\n      for (let cc = b * w; cc \u003c b * w + w; cc++) n += cnt[L * COLS + cc];\n      tot += n;\n      cum[L] = tot;\n    }\n    const h = min(h0, HMAX), k = h / tot, shade = w > 1 && b % 2 ? 0.8 : 1;\n    const top = floor(h - 1e-4), lift = h0 > HMAX ? 0.75 : 0.25 + 0.6 * S.flash[c];\n    for (let r = 0, L = 0; r \u003c= top; r++) {\n      const y = BASE - r + round(sink);\n      if (y \u003c 0 || y >= H) continue;\n      while (L \u003c LAYERS - 1 && cum[L] * k \u003c= r + 0.5) L++;\n      const col = pal[L], a = (r \u003c top ? 1 : h - r) * shade, o = 3 * (y * W + c);\n      const wt = r === top ? lift : 0;\n      for (let i = 0; i \u003c 3; i++) buf[o + i] = (col[i] * (1 - wt) + wt) * a;\n    }\n  }\n  // The outline of the law in pale cream, brighter where it crosses a bar.\n  // A curve with complex multiplication also gets a dotted line up the middle\n  // for the half of its primes that sits at x = 0.\n  const line = [1, 0.86, 0.62];\n  let prev = -1;\n  for (let c = 0; c \u003c COLS; c++) {\n    const y = round(BASE + 1 - min(HMAX + 2, HS * law(cm, c / MID - 1))) + round(sink);\n    const y0 = prev \u003c 0 ? y : prev \u003c y ? prev + 1 : y, y1 = prev \u003c 0 ? y : prev > y ? prev - 1 : y;\n    for (let yy = min(y0, y1); yy \u003c= max(y0, y1); yy++) {\n      if (yy \u003c TOP || yy >= H) continue;\n      const o = 3 * (yy * W + c), inside = buf[o] + buf[o + 1] + buf[o + 2] > 0.3;\n      for (let i = 0; i \u003c 3; i++) buf[o + i] = inside ? buf[o + i] * 0.45 + line[i] * 0.55 : line[i] * 0.34;\n    }\n    prev = y;\n  }\n  if (cm)\n    for (let y = BASE + 1 - HMAX - 2 + round(sink); y \u003c= BASE; y += 3) {\n      if (y \u003c TOP || y >= H) continue;\n      const o = 3 * (y * W + MID);\n      if (buf[o] + buf[o + 1] + buf[o + 2] \u003c 0.3) for (let i = 0; i \u003c 3; i++) buf[o + i] = line[i] * 0.34;\n    }\n  // Drops: a bright head and a short tail, in the colour of their layer.\n  for (const D of S.drops) {\n    if (D.y === undefined) continue;\n    const col = pal[D.L], tail = min(7, 2 + D.v * 0.03), hy = floor(D.y);\n    for (let j = 0; j \u003c= tail; j++) {\n      const y = hy - j;\n      if (y \u003c TOP || y >= H) continue;\n      const a = j === 0 ? 1 : 0.85 * (1 - j / (tail + 1)) ** 1.5, wt = j === 0 ? 0.55 : j === 1 ? 0.2 : 0, o = 3 * (y * W + D.c);\n      for (let i = 0; i \u003c 3; i++) buf[o + i] = max(buf[o + i], (col[i] * (1 - wt) + wt) * a);\n    }\n  }\n  // The readout: the newest prime at the left, its a_p at the right.\n  if (S.shown[0]) {\n    const grey = [0.62, 0.62, 0.62], lab = pal[layerOf(min(LAST - 1, S.spawned))];\n    glyph(buf, FONT[11], 1, 1, lab, 1);\n    number(buf, S.shown[0], 6, 1, false, grey);\n    glyph(buf, FONT[12], 62 - 4 * (String(abs(S.shown[1])).length + (S.shown[1] \u003c 0 ? 1 : 0)) - 4, 1, lab, 1);\n    number(buf, S.shown[1], 62, 1, true, grey);\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) display.setPixel(x, y, round(min(1, buf[3 * p]) * 255), round(min(1, buf[3 * p + 1]) * 255), round(min(1, buf[3 * p + 2]) * 255));\n}\n","tower-stair":"// ===== Patternflow pattern =====\n// Title:   Tower Stair\n// Family:  halloween\n// Idea:    A hooded climber carries a candle up the spiral stair of a round stone tower cut open to show its inside, the flame lighting the curved wall and throwing his huge shadow round it as he winds up past slit windows full of purple night, until a draft at the top blows the candle out and two green eyes look in at the window in the dark; then the candle is lit again at the foot of the stair.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Turns=3..8, Reach=-1..1\n//\n// Knob 1: Hue. The moonlight on the stone and the night in the windows, through the cold colours: purple at 0, indigo at 0.3, blue at 0.6, green at 1. The flame stays orange and the eyes green.\n// Knob 2: Speed. At 2 the climb from the foot to the top takes 10 seconds with 3 turns and 16 with 8, then the draft and the dark take 2.8 seconds before a match is struck at the foot again; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Turns. How many times the stair winds round in the panel's height, from 3 to 8, and the whole tower is rebuilt at once. At 3 a turn has 15 steps and the climber stands 21 LEDs tall; at 8 the stair is a tight coil of 7 steps a turn and he is 7 LEDs tall.\n// Knob 4: Reach. How far the candle light carries before it falls to half: 14 LEDs at -1, a small warm pool round the climber; 29 at the opening 0.06; 56 at 1, so the wall across the well lights up and the shadow stands out on it.\n// Buttons: K1 tap blows the candle out where it is.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\nconst ang = (x, z) => {\n  const a = atan2(x, z);\n  return a \u003c 0 ? a + TAU : a;\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The tower in LEDs: its axis at x = 32, the wall's inside radius, the\n// treads' inner edge and the line the climber walks. The view looks down a\n// little, so a point nearer by z sits K lower: screen y = YB - Y + K z.\n// Angles a run from the front (z toward us) round to the right.\nconst RW = 30, RIN = 16, WALK = 23, K = 0.4, YB = 115;\n// Surfaces: wall, tread top, riser, tread end, inner edge, floor, the cut wall.\nconst WALL = 1, TOP = 2, RISE = 3, END = 4, EDGE = 5, FLOOR = 6, CUT = 7;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, turns: 0, hue: -1, speed: 2, reach: 29, phase: 0, u: 0.05, tp: 0, flare: 0.5, flick: 1,\n    kind: new Uint8Array(N), pos: new Float32Array(N * 3), nrm: new Float32Array(N * 3), alb: new Float32Array(N), amb: new Float32Array(N),\n    eh: new Float32Array(N), win: new Float32Array(N), buf: new Float32Array(N * 3), fz: new Float32Array(N), fl: new Float32Array(N), wins: [],\n  };\n}\n\n// The tower for this many turns. The stair is a solid helix of steps: step\n// j rises rise * j and a slab th thick sits under each tread. Every LED's\n// first surface along its view line is found once, stepping back from the\n// front, with its place, its facing, its stone and its share of moonlight.\nfunction build(S) {\n  const T = S.turns, pitch = 118 / T, st = cl(round(pitch / 2.6), 7, 16), rise = pitch / st, ds = TAU / st, th = rise + 1.5;\n  Object.assign(S, { pitch, rise, th, ds });\n  const { kind, pos, nrm, alb, amb, eh, win } = S;\n  // Two slit windows a turn at the back, half way up the corridor.\n  const wins = [];\n  for (let n = 0; n \u003c= T; n++)\n    for (const f of [0.38, 0.62]) {\n      const a = f * TAU, y = pitch * (n + f) + th + 0.45 * (pitch - th), hh = cl(0.15 * pitch, 3, 6.5), sy = YB - y + K * RW * cos(a);\n      if (sy > hh + 3 && sy \u003c H - 20) wins.push({ a, y, hh, sx: 32 + RW * sin(a), sy, n: 0 });\n    }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const wx = x + 0.5 - 32, c = YB - (y + 0.5);\n      let k = 0, Y = c, z = 0, nx = 0, ny = 0, nz = 1, e = 0, j = 0, aa = 0;\n      win[p] = 0;\n      if (abs(wx) >= RW) k = CUT;\n      else {\n        const zw = sqrt(RW * RW - wx * wx);\n        let pj = -1, well = false;\n        for (z = zw; z > -zw; z -= 0.25) {\n          Y = c + K * z;\n          if (Y \u003c 0) {\n            (z = -c / K), (Y = 0), (k = FLOOR), (nz = 0), (ny = 1);\n            break;\n          }\n          const r2 = wx * wx + z * z;\n          if (r2 \u003c RIN * RIN) {\n            (well = true), (pj = -1);\n            continue;\n          }\n          aa = ang(wx, z);\n          j = floor(aa / ds);\n          const m = floor((Y - rise * j) / pitch), base = rise * j + pitch * m;\n          if (m >= 0 && Y - base \u003c th) {\n            const r = sqrt(r2);\n            if (z === zw) (k = END), (nx = wx / r), (ny = 0), (nz = z / r);\n            else if (well) (k = EDGE), (nx = -wx / r), (ny = 0), (nz = -z / r);\n            else if (pj >= 0 && pj !== j) (k = RISE), (nx = -cos(aa)), (ny = 0), (nz = sin(aa));\n            else (k = TOP), (ny = 1), (nz = 0);\n            e = Y - base - th;\n            j += st * m;\n            break;\n          }\n          (pj = j), (well = false);\n        }\n        if (!k) {\n          (z = -zw), (Y = c + K * z), (k = WALL), (nx = -wx / RW), (ny = 0), (nz = zw / RW);\n          aa = ang(wx, z);\n          e = (((Y - rise * floor(aa / ds) - th) % pitch) + pitch) % pitch;\n          for (let i = 0; i \u003c wins.length; i++) {\n            const w = wins[i], da = RW * wrap(aa - w.a), dy = Y - w.y;\n            if (abs(dy) \u003c w.hh + 2 && abs(da) \u003c 3.6 - (0.4 * abs(dy)) / w.hh) win[p] = -1;\n            if (abs(dy) \u003c w.hh - (abs(da) > 1 ? 0.8 : 0) && abs(da) \u003c 1.6) {\n              // Where a sliver of moon would be: a crescent opening left.\n              const my = abs(dy - 0.3 * w.hh), moon = (da > 0.5 && my \u003c 1.6) || (da > -0.5 && da \u003c= 0.5 && abs(my - 2) \u003c 0.6);\n              win[p] = 0.5 + 0.5 * cl((dy + w.hh) / (2 * w.hh), 0, 1) + (moon ? 10 : 0);\n              // A slit LED is never lit, so it keeps its window's number here.\n              w.n++;\n              e = i;\n            }\n          }\n        }\n      }\n      kind[p] = k;\n      pos.set([wx, Y, z], 3 * p);\n      nrm.set([nx, ny, nz], 3 * p);\n      eh[p] = e;\n      // Stone: wall courses 4 LEDs high with blocks 7 long, mortar darker;\n      // each step its own stone; flags on the floor.\n      let al = 1;\n      if (k === WALL || k === CUT) {\n        const s = k === CUT ? (wx > 0 ? 16 : 2) : RW * aa, row = floor(Y / 4), off = s + (row & 1) * 3.5, blk = floor(off / 7);\n        al = Y - 4 * row \u003c 0.9 || off - 7 * blk \u003c 0.9 ? 0.62 : 0.85 + 0.3 * hash(row * 131 + blk);\n      } else if (k === FLOOR) al = abs(wx % 8) \u003c 0.7 || abs(z % 6) \u003c 0.6 ? 0.6 : 0.9 + 0.2 * hash(floor(wx / 8) * 7 + floor(z / 6));\n      else al = 0.85 + 0.3 * hash(j * 17 + 3) - (k === TOP && aa - ds * floor(aa / ds) > ds - 0.06 ? 0.25 : 0);\n      alb[p] = al;\n      // Moonlight: tread tops brightest and the steps in front more than\n      // those behind, risers and the wall darker, a window's splay in shadow.\n      const front = 0.75 + 0.25 * (z / RW);\n      amb[p] = win[p] \u003c 0 ? 0.5 : k === TOP ? 1.9 * front : k === END ? 1.3 : k === EDGE ? 1.15 : k === RISE ? 0.9 * front : k === FLOOR ? 0.9 : k === CUT ? 1.2 : 0.8;\n    }\n  // The windows the stair leaves in sight, highest first: the eyes come to\n  // the top one, the moon shows in the next.\n  const seen = wins.filter((w) => w.n > 5).sort((u, v) => v.y - u.y), moon = wins.indexOf(seen[1]);\n  for (let p = 0; p \u003c N; p++) if (win[p] >= 10) win[p] = eh[p] === moon ? 3 : win[p] - 10;\n  S.wins = seen;\n}\n\n// Is the way from the candle to this point clear of the stair? The stair\n// is solid, so on the candle's side of the well a point is lit only inside\n// the candle's own turn of the corridor; across the well the light must\n// also clear the treads at both ends of its path. e is the point's height\n// above the tread under it.\nfunction clear(S, C, px, pY, pz, e) {\n  const dx = px - C[0], dz = pz - C[2], L2 = dx * dx + dz * dz || 1e-6, D = sqrt(L2), room = S.pitch - S.th;\n  const b = -(C[0] * dx + C[2] * dz) / L2, t = cl(b, 0, 1), mx = C[0] + t * dx, mz = C[2] + t * dz;\n  if (mx * mx + mz * mz >= RIN * RIN) {\n    const f = pY - C[4] - (S.pitch * wrap(ang(px, pz) - C[3])) / TAU;\n    return f > -0.7 && f \u003c room + 0.3;\n  }\n  const s = (pY - C[1]) / D, cc = C[0] * C[0] + C[2] * C[2] - RIN * RIN, disc = sqrt(max(0, b * b - cc / L2));\n  const h1 = C[1] - C[4] + s * (b - disc) * D, h2 = e - s * (1 - b - disc) * D;\n  return h1 > 0 && h1 \u003c room && h2 > -0.7 && h2 \u003c room + 0.3;\n}\n\n// Shortest distance between segments PQ and AB, squared; segT keeps where\n// along AB it falls, for a tapered capsule's radius there.\nlet segT = 0;\nfunction segDist2(px, py, pz, qx, qy, qz, ax, ay, az, bx, by, bz) {\n  const d1x = qx - px, d1y = qy - py, d1z = qz - pz, d2x = bx - ax, d2y = by - ay, d2z = bz - az, rx = px - ax, ry = py - ay, rz = pz - az;\n  const a = d1x * d1x + d1y * d1y + d1z * d1z, e = d2x * d2x + d2y * d2y + d2z * d2z || 1e-6, f = d2x * rx + d2y * ry + d2z * rz;\n  const c = d1x * rx + d1y * ry + d1z * rz, bd = d1x * d2x + d1y * d2y + d1z * d2z, den = a * e - bd * bd;\n  let s = den > 1e-9 ? cl((bd * f - c * e) / den, 0, 1) : 0, t = (bd * s + f) / e;\n  if (t \u003c 0) (t = 0), (s = cl(-c / a, 0, 1));\n  else if (t > 1) (t = 1), (s = cl((bd - c) / a, 0, 1));\n  const ux = px + d1x * s - ax - d2x * t, uy = py + d1y * s - ay - d2y * t, uz = pz + d1z * s - az - d2z * t;\n  segT = t;\n  return ux * ux + uy * uy + uz * uz;\n}\n\n// The climber at progress u along the stair: tapered capsules [ax, ay, az,\n// bx, by, bz, ra, rb] in the tower's frame (x right, Y up, z toward us), and\n// the flame C = [x, Y, z, angle, height of the tread under it].\nfunction climber(S) {\n  const pitch = S.pitch, hgt = 0.6 * (pitch - S.th);\n  const a0 = 0.25, a1 = (TAU * (108 - 1.05 * hgt - S.th)) / pitch, a = a0 + (a1 - a0) * S.u;\n  const walk = (a * WALK) / (0.2 * hgt), fy = (pitch * a) / TAU - 0.5 * S.rise + S.th + 0.04 * hgt * abs(sin(walk));\n  const sa = sin(a), ca = cos(a);\n  // Local axes: forward along the stair, out toward the wall, up.\n  const at = (f, o, u) => [(WALK + o * hgt) * sa + f * hgt * ca, fy + u * hgt, (WALK + o * hgt) * ca - f * hgt * sa];\n  const caps = [];\n  const cap = (p, q, ra, rb) => caps.push([...p, ...q, ra * hgt, rb * hgt]);\n  const sw = 0.03 * sin(walk);\n  // A cloak that widens to the hem, square shoulders, a hood with a point.\n  cap(at(-0.03, 0, 0.1), at(0.01, 0, 0.58), 0.21, 0.11);\n  cap(at(0.02, 0.07, 0.68), at(0.02, -0.07, 0.68), 0.09, 0.09);\n  cap(at(0.06, 0, 0.84), at(0.07, 0, 0.85), 0.1, 0.1);\n  cap(at(0.03, 0, 0.88), at(-0.09, 0, 1.06), 0.08, 0.012);\n  // The arm reaches forward and in, holding the candle over the well side.\n  const hand = at(0.2 + sw, -0.22, 0.64);\n  cap(at(0.03, -0.08, 0.7), hand, 0.045, 0.035);\n  const C = [hand[0], hand[1] + 0.1 * hgt + 1.5, hand[2], 0, 0];\n  C[3] = ang(C[0], C[2]);\n  C[4] = fy + (pitch * wrap(C[3] - a)) / TAU;\n  let mx = 0, my = 0, mz = 0;\n  for (const c of caps) (mx += c[0] + c[3]), (my += c[1] + c[4]), (mz += c[2] + c[5]);\n  S.P = { a, hgt, caps, hand, C, mid: [mx / 10, my / 10, mz / 10], rad: 0.78 * hgt };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.reach = 28 * 2 ** cl(k[3], -1, 1);\n  const T = round(cl(k[2], 3, 8));\n  if (T !== S.turns) {\n    S.turns = T;\n    build(S);\n  }\n  const ds = (d * S.speed) / 2, D = 10 * sqrt(T / 3);\n  S.t += ds;\n  S.tp += ds;\n  S.flare = max(0, S.flare - ds);\n  if (input.btnPressed && input.btnPressed[0] && S.phase === 0) (S.phase = 1), (S.tp = 0.25);\n  // 0 climbing, 1 a draft bends the flame, 2 dark with eyes at the window.\n  if (S.phase === 0) {\n    S.u = min(1, S.u + ds / D);\n    if (S.u >= 1) (S.phase = 1), (S.tp = 0);\n  } else if (S.phase === 1 && S.tp > 0.6) (S.phase = 2), (S.tp = 0);\n  else if (S.phase === 2 && S.tp > 2.2) (S.phase = 0), (S.tp = 0), (S.u = 0), (S.flare = 0.5);\n  const fl = 0.9 + 0.06 * sin(S.t * 23) + 0.04 * sin(S.t * 37 + 1);\n  S.flick = S.phase === 0 ? fl : S.phase === 1 ? fl * (1 - sm(S.tp / 0.6)) * (0.6 + 0.4 * sin(S.t * 61)) : 0;\n  climber(S);\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    S.tint = hsv(0.76 - 0.36 * hue, 0.68, 1);\n    S.sky = hsv(0.76 - 0.36 * hue, 0.75, 1);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const { kind, pos, nrm, alb, amb, eh, win, buf, fz, fl, P, tint, sky } = S;\n  const C = P.C, lit = S.flick, R = S.reach, cut = 3 * R, caps = P.caps, LC = [1, 0.55, 0.2];\n  for (let p = 0; p \u003c N; p++) {\n    const q = 3 * p, w = win[p];\n    if (w > 0) {\n      // The night through a slit, deeper at the top, and a sliver of moon.\n      const v = w > 2 ? 1 : 0.2 + 0.5 * w;\n      buf[q] = w > 2 ? 0.95 : sky[0] * v;\n      buf[q + 1] = w > 2 ? 0.9 : sky[1] * v;\n      buf[q + 2] = w > 2 ? 0.7 : sky[2] * v;\n      continue;\n    }\n    const k = kind[p], a = alb[p] * amb[p] * 0.2;\n    let r = tint[0] * a, g = tint[1] * a, b = tint[2] * a;\n    if (lit > 0.01) {\n      const px = pos[q], py = pos[q + 1], pz = pos[q + 2], lx = C[0] - px, ly = C[1] - py, lz = C[2] - pz, dd = sqrt(lx * lx + ly * ly + lz * lz) || 1;\n      if (dd \u003c cut) {\n        const ln = (nrm[q] * lx + nrm[q + 1] * ly + nrm[q + 2] * lz) / dd;\n        let li = (sm((cut - dd) / R) * (0.2 + 0.8 * max(0, ln))) / (1 + (dd / R) ** 2);\n        if (ln \u003c -0.3) li = 0;\n        if (li > 0.004 && k !== CUT && !clear(S, C, px, py, pz, eh[p])) li = 0;\n        if (li > 0.004) {\n          // The climber's shadow: does the way to the flame pass through him?\n          const mx = P.mid[0] - px, my = P.mid[1] - py, mz = P.mid[2] - pz, tt = cl((mx * lx + my * ly + mz * lz) / (dd * dd), 0, 1);\n          const ex = mx - lx * tt, ey = my - ly * tt, ez = mz - lz * tt;\n          if (ex * ex + ey * ey + ez * ez \u003c P.rad * P.rad)\n            for (const c of caps) {\n              const d2 = segDist2(px, py, pz, C[0], C[1], C[2], c[0], c[1], c[2], c[3], c[4], c[5]), rr = c[6] + (c[7] - c[6]) * segT;\n              if (d2 \u003c rr * rr) li = 0;\n            }\n        }\n        li *= lit * 1.5 * alb[p];\n        r += LC[0] * li;\n        g += LC[1] * li;\n        b += LC[2] * li;\n      }\n    }\n    if (w \u003c 0) (r *= 0.55), (g *= 0.55), (b *= 0.55);\n    buf[q] = r;\n    buf[q + 1] = g;\n    buf[q + 2] = b;\n  }\n  // The climber: a dark cloak, the side toward the flame lit warm.\n  fz.fill(-99);\n  for (const c of caps) {\n    const sx0 = 32 + c[0], sy0 = YB - c[1] + K * c[2], sx1 = 32 + c[3], sy1 = YB - c[4] + K * c[5], ra = c[6], rb = c[7], rr = max(ra, rb);\n    const ex = sx1 - sx0, ey = sy1 - sy0, e2 = ex * ex + ey * ey || 1e-6;\n    for (let y = max(0, floor(min(sy0, sy1) - rr)); y \u003c= min(H - 1, ceil(max(sy0, sy1) + rr)); y++)\n      for (let x = max(0, floor(min(sx0, sx1) - rr)); x \u003c= min(W - 1, ceil(max(sx0, sx1) + rr)); x++) {\n        const qx = x + 0.5 - sx0, qy = y + 0.5 - sy0, u = cl((qx * ex + qy * ey) / e2, 0, 1), hx = qx - u * ex, hy = qy - u * ey, h2 = hx * hx + hy * hy, ru = ra + (rb - ra) * u;\n        if (h2 > ru * ru) continue;\n        const p = y * W + x, hz = sqrt(ru * ru - h2), zz = c[2] + (c[5] - c[2]) * u + hz;\n        if (zz \u003c pos[3 * p + 2] - 1 || zz \u003c fz[p]) continue;\n        fz[p] = zz;\n        const wxp = c[0] + (c[3] - c[0]) * u + hx, wyp = c[1] + (c[4] - c[1]) * u - hy;\n        const lx = C[0] - wxp, ly = C[1] - wyp, lz = C[2] - zz, dd = sqrt(lx * lx + ly * ly + lz * lz) || 1;\n        fl[p] = max(0, (hx * lx - hy * ly + hz * lz) / (ru * dd)) / (1 + (dd / R) ** 2);\n      }\n  }\n  for (let p = 0; p \u003c N; p++)\n    if (fz[p] > -99) {\n      const q = 3 * p, v = fl[p] * lit;\n      buf[q] = 0.035 + 1.1 * v;\n      buf[q + 1] = 0.02 + 0.55 * v;\n      buf[q + 2] = 0.05 + 0.2 * v;\n    }\n  // The hand, the candle and its flame, hidden where the climber is in\n  // front of them, and a halo round the flame either way.\n  const sx = (v) => 32 + v[0], sy = (v) => YB - v[1] + K * v[2], hx = sx(P.hand), hy = sy(P.hand), fx = sx(C), fy = sy(C), front = C[2] + 1;\n  const put = (x, y, r, g, b) => {\n    (x = floor(x)), (y = floor(y));\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const p = y * W + x, q = 3 * p;\n    if (fz[p] > front || pos[3 * p + 2] > front + 0.5) return;\n    buf[q] = r;\n    buf[q + 1] = g;\n    buf[q + 2] = b;\n  };\n  const glow = (cx, cy, rad, amp, col) => {\n    for (let y = max(0, floor(cy - rad)); y \u003c= min(H - 1, ceil(cy + rad)); y++)\n      for (let x = max(0, floor(cx - rad)); x \u003c= min(W - 1, ceil(cx + rad)); x++) {\n        const dd = Math.hypot(x + 0.5 - cx, y + 0.5 - cy);\n        if (dd > rad) continue;\n        const v = amp * (1 - dd / rad) ** 2, q = 3 * (y * W + x);\n        buf[q] += col[0] * v;\n        buf[q + 1] += col[1] * v;\n        buf[q + 2] += col[2] * v;\n      }\n  };\n  if (S.phase \u003c 2) {\n    const sk = 0.25 + 0.6 * lit;\n    put(hx, hy, sk, 0.6 * sk, 0.42 * sk);\n    put(hx + (fx > hx ? -1 : 1), hy, 0.8 * sk, 0.48 * sk, 0.33 * sk);\n    for (let y = floor(hy) - 1; y > floor(fy); y--) put(fx, y, 0.75, 0.7, 0.6);\n  }\n  if (lit > 0.01) {\n    glow(fx, fy - 0.5, 8, 0.5 * lit, LC);\n    const sway = S.phase === 1 ? 1.4 * sin(S.t * 30) : 0.4 * sin(S.t * 11);\n    put(fx, fy, 1, 0.95 * lit, 0.6 * lit);\n    put(fx + sway * 0.5, fy - 1, 1, 0.75 * lit, 0.25 * lit);\n    put(fx + sway, fy - 2, 0.9 * lit, 0.4 * lit, 0.05);\n  } else if (S.phase === 2 && S.tp \u003c 1)\n    // A thread of smoke from the wick.\n    for (let i = 0; i \u003c 6; i++) put(fx + 1.2 * sin(S.tp * 6 + i), fy - 1 - i - 4 * S.tp, 0.3 * (1 - S.tp), 0.28 * (1 - S.tp), 0.3 * (1 - S.tp));\n  // The match struck at the foot of the stair before each climb.\n  if (S.flare > 0) glow(fx, fy - 1, 3 + 8 * (0.5 - S.flare), 2 * S.flare, [1, 0.85, 0.55]);\n  // Two green eyes at the top window while it is dark.\n  if (S.phase === 2 && S.tp > 0.3 && S.tp \u003c 2 && S.wins.length) {\n    const w = S.wins[0];\n    const e = sm((S.tp - 0.3) / 0.3) * (1 - sm((S.tp - 1.7) / 0.3)) * (abs(S.tp - 1.15) \u003c 0.07 ? 0.1 : 1);\n    glow(w.sx, w.sy - 1, 6, 0.2 * e, [0.3, 1, 0.3]);\n    // A pale face fills the slit behind them.\n    for (let y = floor(w.sy - 3); y \u003c= w.sy + 2; y++)\n      for (let x = floor(w.sx - 1.5); x \u003c= w.sx + 1; x++) {\n        const q = 3 * (y * W + x);\n        if (y >= 0 && x >= 0 && x \u003c W) (buf[q] += 0.14 * e), (buf[q + 1] += 0.17 * e), (buf[q + 2] += 0.14 * e);\n      }\n    for (const dx of [-1, 1]) {\n      const x = floor(w.sx + dx), y = floor(w.sy - 1), q = 3 * (y * W + x);\n      if (x >= 0 && x \u003c W && y >= 0) (buf[q] = 0.3 * e), (buf[q + 1] = e), (buf[q + 2] = 0.2 * e);\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const q = 3 * p;\n      display.setPixel(x, y, round(cl(buf[q], 0, 1) * 255), round(cl(buf[q + 1], 0, 1) * 255), round(cl(buf[q + 2], 0, 1) * 255));\n    }\n}\n","zombie-shamble":"// ===== Patternflow pattern =====\n// Title:   Zombie Shamble\n// Family:  halloween\n// Idea:    A horde of zombies shambles toward you down a foggy country lane at night, black figures rim-lit by a sickly green glow behind the horizon with their arms reaching and heads lolling, small in the far fog and growing until the nearest fill the panel and come apart in the mist.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 51\n// Round:   51\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Horde=5..18, Fog=0..1\n//\n// Knob 1: Hue. The glow, the fog and the green of the rims and eyes together: toxic green at 0, sea green at 0.25, sky blue at 0.5, blue violet at 0.75 and magenta at 1, while the sky leans from purple to indigo and back.\n// Knob 2: Speed. At 2 each zombie closes a tenth of its distance a second, so it grows on the panel at one steady rate, at a little under two steps a second; the nearest, 1.95 m off at the start, begins to come apart in the fog two seconds later and is gone by about six. At 0.2 ten times slower with short shuffling steps, at 3 half as fast again with longer strides and harder lurches. The fog drifts on the same clock.\n// Knob 3: Horde. How many walk at once, 5 to 18. They open spread from 2 m to 26 m, nearest first, a bigger horde as a wider wall of near ones, and each count puts its nearest zombie in a different place. Three in five drag a leg, and two in five have eyes that glow.\n// Knob 4: Fog. How deep and thick the ground fog lies: at 0 a mist 0.3 m deep that hides the far lane and the feet of the far zombies, at 1 a bank 1.35 m deep and nearly six times as thick that swallows them to the chest.\n// Buttons: K1 tap snaps every head upright to look at you, face turned to the eye and eyes lit green, for about two and a half seconds.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Value noise on a 256 x 256 lattice.\nconst NT = new Float32Array(65536);\nfor (let i = 0; i \u003c 65536; i++) NT[i] = hash(i * 7 + 3);\nfunction vn(x, y) {\n  const xi = floor(x), yi = floor(y);\n  let fx = x - xi, fy = y - yi;\n  fx = fx * fx * (3 - 2 * fx);\n  fy = fy * fy * (3 - 2 * fy);\n  const x0 = xi & 255, x1 = (xi + 1) & 255, y0 = (yi & 255) \u003c\u003c 8, y1 = ((yi + 1) & 255) \u003c\u003c 8;\n  const a = NT[y0 + x0], b = NT[y0 + x1], c = NT[y1 + x0], d = NT[y1 + x1];\n  return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;\n}\n\n// The eye: horizon row, vanishing column, LEDs per metre at one metre and\n// eye height in metres. A point x metres to the side, h up and z ahead\n// lands at column VX + F x / z and row YH + F (HC - h) / z.\nconst YH = 32, VX = 32, F = 100, HC = 1.45;\n// The glow behind the horizon stands a little right of the lane.\nconst GX = 36;\n// Half the lane's width; how far off zombies appear, where they are gone\n// and where they start to come apart in the fog; the most there can be.\nconst ROAD = 1.1, ZMAX = 26, ZOUT = 1.05, ZFADE = 1.6, MAXZ = 18;\n// Each zombie keeps to its line x of the lane until about ZC metres out,\n// then bears in on the eye, so from there on it holds its column and only\n// grows.\nconst ZC = 5, column = (Z) => VX + (F * Z.x) / sqrt(Z.z * Z.z + ZC * ZC);\n\n// The glow's reach on the panel, the same every frame.\nconst GL = new Float32Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - GX, dy = y + 0.5 - YH;\n    GL[y * W + x] = exp(-(dx * dx) / 900 - (dy * dy) / 110) * 0.8 + exp(-(dx * dx) / 3000 - (dy * dy) / 700) * 0.35;\n  }\n\n// ---- Scenery: dead trees, a fence and a far treeline, drawn once as\n// coverage with the depth of what covers each LED.\nfunction capsuleInto(A, Z, x0, y0, x1, y1, r0, r1, z0, z1) {\n  const ex = x1 - x0, ey = y1 - y0, ll = ex * ex + ey * ey || 1e-9, R = max(r0, r1) + 1;\n  const X0 = max(0, floor(min(x0, x1) - R)), X1 = min(W - 1, floor(max(x0, x1) + R));\n  const Y0 = max(0, floor(min(y0, y1) - R)), Y1 = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = Y0; y \u003c= Y1; y++)\n    for (let x = X0; x \u003c= X1; x++) {\n      let c = 0, uu = 0;\n      for (let j = 0; j \u003c 3; j++)\n        for (let i = 0; i \u003c 3; i++) {\n          const px = x + (i + 0.5) / 3 - x0, py = y + (j + 0.5) / 3 - y0, u = cl((px * ex + py * ey) / ll, 0, 1);\n          const dx = px - u * ex, dy = py - u * ey;\n          if (dx * dx + dy * dy \u003c= (r0 + (r1 - r0) * u) ** 2) c++, (uu = u);\n        }\n      if (!c) continue;\n      const q = y * W + x, zz = z0 + (z1 - z0) * uu;\n      A[q] = max(A[q], c / 9);\n      if (zz \u003c Z[q]) Z[q] = zz;\n    }\n}\n// A crooked limb in the tree's own plane, in metres: from (x, h) at angle a\n// from upright, len long, radius r, walked in short kinked steps that give\n// off side limbs, mostly toward the lane (side tow).\nfunction limb(A, Z, bx, z, x, h, a, len, r, depth, seed, tow) {\n  const s = F / z, n = max(2, round(len / 0.4));\n  for (let i = 0; i \u003c n; i++) {\n    const k = seed * 13 + i * 7, l = len / n, r0 = r * (1 - (0.5 * i) / n), r1 = r * (1 - (0.5 * (i + 1)) / n);\n    a += (hash(k) - 0.5) * 0.9;\n    const x2 = x + l * sin(a), h2 = h + l * cos(a);\n    capsuleInto(A, Z, VX + s * (bx + x), YH + s * (HC - h), VX + s * (bx + x2), YH + s * (HC - h2), max(0.3, r0 * s), max(0.28, r1 * s), z, z);\n    if (depth > 0 && i > 0 && hash(k + 1) \u003c 0.55) {\n      const side = hash(k + 2) \u003c 0.65 ? tow : -tow;\n      limb(A, Z, bx, z, x2, h2, a + side * (0.6 + 0.6 * hash(k + 3)), (len - i * l) * (0.45 + 0.35 * hash(k + 4)), r1 * 0.6, depth - 1, k + 5, tow);\n    }\n    (x = x2), (h = h2);\n  }\n}\nfunction blur(A) {\n  const T = new Float32Array(N);\n  for (let q = 0; q \u003c N; q++) {\n    const x = q % W;\n    T[q] = (2 * A[q] + A[x > 0 ? q - 1 : q] + A[x \u003c W - 1 ? q + 1 : q]) / 4;\n  }\n  for (let q = 0; q \u003c N; q++) A[q] = (2 * T[q] + T[q >= W ? q - W : q] + T[q \u003c N - W ? q + W : q]) / 4;\n}\nfunction scenery() {\n  const A = new Float32Array(N), Z = new Float32Array(N).fill(1e9);\n  // Trees: side, distance, lean, height, seed.\n  const trees = [[-2.3, 8.5, 0.15, 4.2, 1], [2.5, 11, -0.12, 4.4, 2], [-2.6, 16, 0.1, 4.6, 3], [2.9, 23, -0.1, 4.2, 4], [-3.1, 33, 0.05, 4.8, 5], [3.4, 48, -0.1, 4.5, 6]];\n  for (const [bx, z, lean, ht, sd] of trees) {\n    const s = F / z, tow = bx \u003c 0 ? 1 : -1;\n    // Root flare, then the trunk and its crown.\n    capsuleInto(A, Z, VX + s * (bx - 0.25), YH + s * HC, VX + s * bx, YH + s * (HC - 0.45), 0.18 * s, 0.17 * s, z, z);\n    capsuleInto(A, Z, VX + s * (bx + 0.25), YH + s * HC, VX + s * bx, YH + s * (HC - 0.45), 0.14 * s, 0.17 * s, z, z);\n    limb(A, Z, bx, z, 0, 0.3, lean, ht, 0.13, 3, sd * 31, tow);\n  }\n  // The fence on the left: posts every 2.6 m, two rails, one post leaning\n  // and one rail fallen.\n  for (let i = 0; i \u003c 14; i++) {\n    const z = 4.4 + 2.6 * i, s = F / z, x = -2.2, lean = i === 2 ? 0.25 : (hash(i + 40) - 0.5) * 0.1;\n    capsuleInto(A, Z, VX + s * x, YH + s * HC, VX + s * (x + lean), YH + s * (HC - 1.15), 0.06 * s, 0.05 * s, z, z);\n    if (i === 13) break;\n    const z2 = z + 2.6, s2 = F / z2;\n    for (const [h, k] of [[0.5, 0], [0.95, 1]]) {\n      const drop = i === 4 && k === 1 ? 0.7 : 0;\n      capsuleInto(A, Z, VX + s * x, YH + s * (HC - h), VX + s2 * x, YH + s2 * (HC - h + drop), 0.025 * s, 0.025 * s2, z, z2);\n    }\n  }\n  // A far treeline on the horizon.\n  for (let x = 0; x \u003c W; x++) {\n    const ht = 1.5 + 2.2 * vn(x / 5, 7) + 1.6 * max(0, vn(x / 2.3, 11) - 0.55);\n    for (let y = YH - 6; y \u003c YH + 1; y++) {\n      const c = cl(ht - (YH + 0.5 - y), 0, 1), q = y * W + x;\n      if (c > A[q]) (A[q] = c), (Z[q] = 60);\n    }\n  }\n  blur(A);\n  return { A, Z };\n}\n\n// Where the opening zombies stand across the panel, nearest first, so a\n// bigger horde opens as a wider wall of them.\nconst COLS = [-0.45, 0.5, -0.92, 0.95, 0.08, -0.7, 0.75, -0.2, 0.3, -1, 1, -0.55, 0.6, -0.1, 0.15, -0.85, 0.85, -0.35];\n\nexport function setup(params) {\n  const zs = [];\n  for (let i = 0; i \u003c MAXZ; i++) zs.push({ z: 0, seed: i * 17 + 5 });\n  const sc = scenery(), A = (n) => new Float32Array(n);\n  params.s = {\n    t: 0, gait: 1, hue: 0, fog: 0.06, count: 5, look: 0, lookT: 0, started: false, zs, sA: sc.A, sZ: sc.Z,\n    col: A(N * 3), base: A(N * 3), fogC: A(N * 3), fc: A(N * 3), nb: A(33 * 65), bg: A(N), nz: A(N), dist: A(N), R: A(65), caps: A(20 * 6),\n    sky: [0, 0, 0], glow: [0, 0, 0], fogHue: [0, 0, 0], palHue: -1,\n  };\n}\n\nfunction spawn(Z, z, x) {\n  Z.seed += 101;\n  const r = (j) => hash(Z.seed * 3 + j);\n  Z.z = z || ZMAX - 4 * r(0);\n  // x: the column to stand in now, or none for a line drawn at random.\n  Z.x = x === undefined ? (r(1) - 0.5) * 2.6 : ((x - VX) * sqrt(Z.z * Z.z + ZC * ZC)) / F;\n  Z.ph = r(2);\n  Z.rate = 0.75 + 0.35 * r(3);\n  // Which leg drags (-1 left, 1 right, 0 neither), how the arms go, which\n  // way the head hangs and how far.\n  Z.drag = r(4) \u003c 0.6 ? (r(5) \u003c 0.5 ? -1 : 1) : 0;\n  Z.arms = floor(r(6) * 3);\n  Z.loll = (r(7) \u003c 0.5 ? -1 : 1) * (0.3 + 0.35 * r(8));\n  Z.size = 0.92 + 0.2 * r(9);\n  Z.eyes = r(10) \u003c 0.4;\n  Z.raiseL = (r(11) - 0.4) * 0.18;\n  Z.raiseR = (r(12) - 0.4) * 0.18;\n  // Half turned one way or the other, and stooped.\n  Z.yaw = (r(13) \u003c 0.5 ? -1 : 1) * (0.45 + 0.4 * r(14));\n  Z.stoop = 0.12 + 0.2 * r(15);\n  Z.fade = z ? 1 : 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const s = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  s.hue = cl(k[0], 0, 1);\n  const sp = cl(k[1], 0.2, 3);\n  s.count = round(cl(k[2], 5, MAXZ));\n  s.fog = cl(k[3], 0, 1);\n  if (!s.started) {\n    // The opening horde, nearest first: one already close, the rest spread\n    // evenly in the log of distance, which is how walking at a speed in\n    // proportion to distance spreads them.\n    for (let i = 0; i \u003c s.count; i++) spawn(s.zs[i], 1.95 * (ZMAX / 1.95) ** ((i + 0.6 * hash(i + 9) * (i > 0)) / s.count), VX + (i ? 26 * COLS[i] : 13 * sin(s.count * 2.4)));\n    s.started = true;\n  }\n  const dd = (d * sp) / 2;\n  s.t += dd;\n  // A faster walk takes longer strides and lurches harder.\n  s.gait = 0.5 + 0.25 * sp;\n  const b = input.btnPressed || [];\n  if (b[0]) s.lookT = 3;\n  s.lookT = max(0, s.lookT - d);\n  s.look = cl(s.look + (s.lookT > 0.6 ? d / 0.12 : -d / 0.8), 0, 1);\n  for (let i = 0; i \u003c MAXZ; i++) {\n    const Z = s.zs[i];\n    if (i \u003c s.count && !Z.z) spawn(Z, 0);\n    if (!Z.z) continue;\n    // They come on at a tenth of their distance a second at Speed 2, so\n    // each grows on the panel at the same steady rate and the near ones\n    // linger; slower again while a dragged leg comes through.\n    const u = (Z.ph + Z.rate * s.t) % 1;\n    Z.z -= dd * 0.1 * Z.z * (Z.drag ? 0.6 + 0.8 * abs(sin(TAU * u)) : 1);\n    Z.fade = i \u003c s.count ? min(1, Z.fade + d * 0.5) : Z.fade - d;\n    if (Z.z \u003c ZOUT || Z.fade \u003c 0) i \u003c s.count ? spawn(Z, 0) : (Z.z = 0);\n  }\n}\n\n// The colours, and everything on the panel that only they change: the sky\n// and the lane before fog, and the fog's own light at each LED.\nfunction palette(s) {\n  const h = s.hue, { sky, glow, fogHue, base, fogC } = s;\n  // At 0 a toxic green glow under a purple sky; the glow turns through\n  // cyan and blue to magenta and the sky leans toward indigo on the way.\n  hsv(0.3 + 0.52 * h, 0.85, 1, glow);\n  hsv(0.78 - 0.14 * sin(PI * h), 0.82, 1, sky);\n  hsv(0.32 + 0.52 * h, 0.55, 1, fogHue);\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5, dy = yc - YH;\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3, gl = GL[q], dx = x + 0.5 - GX;\n      let v, sh;\n      if (dy \u003c 0) {\n        const u = yc / YH;\n        (v = 0.19 + 0.16 * u * u), (sh = gl);\n      } else {\n        // A wet lane between dark fields, mirroring the glow, brightest far\n        // off where the eye meets it at a graze: two wheel ruts full of water\n        // and a dark strip of grass between them.\n        const z = (F * HC) / dy, ax = abs(((x + 0.5 - VX) * z) / F);\n        const road = (1 - sm(ROAD - 0.12, ROAD + 0.12, ax)) * (0.45 + 0.55 * sm(0.12, 0.3, ax)), rut = exp(-(((ax - 0.55) / 0.16) ** 2));\n        v = 0.05 + 0.05 * road;\n        sh = road * (0.7 + 0.5 * rut) * (0.12 + 0.4 * exp(-dy / 26) + 0.25 * exp(-(dx * dx) / (60 + 4 * dy)));\n      }\n      const fl = 0.42 + 0.65 * gl;\n      for (let c = 0; c \u003c 3; c++) {\n        base[o + c] = (sky[c] * v + glow[c] * sh) * 255;\n        fogC[o + c] = fogHue[c] * 255 * fl;\n      }\n    }\n  }\n  s.palHue = h;\n}\n\n// The fog's density at height h: thick at the ground and gone above a soft\n// top that the Fog knob raises from 0.3 m to the chest. R is its integral\n// up from the ground, in 64 steps to 2.4 m.\nfunction fogTable(s) {\n  const top = 0.3 + 1.05 * s.fog, rho = 0.55 + 2.6 * s.fog, R = s.R;\n  let acc = 0;\n  R[0] = 0;\n  for (let i = 1; i \u003c= 64; i++) {\n    acc += (rho * (1 - sm(top * 0.45, top * 1.15, ((i - 0.5) / 64) * 2.4)) * 2.4) / 64;\n    R[i] = acc;\n  }\n}\nconst Rat = (R, h) => {\n  const u = cl((h / 2.4) * 64, 0, 64), i = min(63, floor(u));\n  return R[i] + (R[i + 1] - R[i]) * (u - i);\n};\n// Optical depth from the eye to a point z ahead at height h: z times the\n// mean density between the two heights.\nfunction tau(R, z, h) {\n  const dh = HC - h;\n  if (abs(dh) \u003c 0.02) return (z * (Rat(R, HC + 0.02) - Rat(R, HC - 0.02))) / 0.04;\n  return (z * (Rat(R, HC) - Rat(R, h))) / dh;\n}\n\n// One zombie's pose as capsules in LEDs, [x0, y0, x1, y1, r0, r1] each.\n// The body is built in metres, feet at 0, x to its right, y up and z\n// forward toward the eye, then turned by its yaw: a zombie half turned\n// shows both its reaching arms off to one side.\nfunction pose(s, Z, out) {\n  const z = Z.z, sc = (F / z) * Z.size, X = (Z.X = column(Z)), Y = YH + (F * HC) / z;\n  const u = (Z.ph + Z.rate * s.t) % 1, w = TAU * u, cy = cos(Z.yaw), sy = sin(Z.yaw), G = s.gait;\n  // The lurch: the trunk rolls over the planted leg, more so onto the good\n  // one when the other drags; it stoops forward by Z.stoop.\n  const roll = G * (0.08 * sin(w + 0.6) + (Z.drag ? 0.08 * Z.drag * max(0, sin(w * -Z.drag)) : 0)), cr = cos(roll), sr = sin(roll);\n  const hipY = 0.92 - 0.035 * abs(cos(w)), hx = 0.04 * sin(w), cs = cos(Z.stoop), ss = sin(Z.stoop);\n  let n = 0;\n  const q = [0, 0, 0, 0];\n  // A point of the upper body: stoop about the hips, then roll.\n  const up = (x, y, f) => {\n    const y1 = y * cs, z1 = y * ss + f;\n    return [hx + x * cr + y1 * sr, hipY + y1 * cr - x * sr, z1];\n  };\n  const P = (a, b, r0, r1) => {\n    out[n++] = X + (a[0] * cy + a[2] * sy) * sc;\n    out[n++] = Y - a[1] * sc;\n    out[n++] = X + (b[0] * cy + b[2] * sy) * sc;\n    out[n++] = Y - b[1] * sc;\n    out[n++] = r0 * sc;\n    out[n++] = r1 * sc;\n  };\n  for (const side of [-1, 1]) {\n    // Each leg swings forward in its half of the cycle; a dragged leg\n    // barely lifts and trails behind.\n    const dragged = Z.drag === side, ph = side \u003c 0 ? w : w + PI, l = max(0, sin(ph)) * (dragged ? 0.15 : G);\n    const fz = (dragged ? 0.08 : 0.24 * G) * cos(ph - PI / 2) - (dragged ? 0.12 : 0), fy = 0.05 + 0.13 * l;\n    const hip = [hx + side * 0.1, hipY, 0], knee = [hx + side * 0.115, 0.5 + 0.06 * l, fz * 0.5 + 0.1 * l], foot = [side * 0.13, fy, fz];\n    P(hip, knee, 0.09, 0.066);\n    P(knee, foot, 0.066, 0.05);\n    P(foot, [foot[0], foot[1] - 0.02, foot[2] + 0.1], 0.055, 0.05);\n  }\n  const neck = up(0, 0.5, 0), chest = up(0, 0.28, 0), sl = up(-0.17, 0.44, 0), sr2 = up(0.17, 0.44, 0);\n  P(up(0, 0.04, 0), chest, 0.15, 0.18);\n  P(chest, up(0, 0.44, 0), 0.18, 0.13);\n  P(sl, sr2, 0.08, 0.08);\n  // Rags of a shirt hanging below the waist.\n  for (const [a, b, c] of [[-0.13, -0.17, 0.13], [0.02, 0.05, 0.11], [0.12, 0.15, 0.09]]) P(up(a, 0.06, 0), up(b, -c, 0), 0.05, 0.022);\n  for (const side of [-1, 1]) {\n    // Arms reach forward at shoulder height with the hands hanging limp;\n    // some carry one arm dead at the side.\n    const sh = side \u003c 0 ? sl : sr2, bob = 0.035 * G * sin(w + side * 1.3), raise = side \u003c 0 ? Z.raiseL : Z.raiseR;\n    if (Z.arms === 2 && side > 0) {\n      const el = [sh[0] + 0.05, sh[1] - 0.3, sh[2] + 0.03], wr = [sh[0] + 0.07, sh[1] - 0.56, sh[2] + 0.06];\n      P(sh, el, 0.065, 0.05);\n      P(el, wr, 0.05, 0.04);\n      P(wr, [wr[0] + 0.01, wr[1] - 0.1, wr[2]], 0.042, 0.03);\n    } else {\n      const el = [sh[0] + side * 0.09, sh[1] - 0.04 + raise + bob, sh[2] + 0.27], wr = [el[0] + side * 0.07, el[1] + 0.02 + raise * 0.5 + bob, el[2] + 0.25];\n      P(sh, el, 0.07, 0.056);\n      P(el, wr, 0.056, 0.042);\n      P(wr, [wr[0], wr[1] - 0.13, wr[2] + 0.05], 0.046, 0.028);\n    }\n  }\n  // The head hangs to one side and swings with the step, unless it has\n  // snapped up to look; its jaw hangs open below it.\n  const la = (Z.loll + 0.2 * sin(w + 1.3)) * (1 - s.look) + roll, nk = [neck[0], neck[1] - 0.06, neck[2]];\n  const hc = [neck[0] + 0.13 * sin(la), neck[1] + 0.13 * cos(la), neck[2] + 0.04];\n  P(nk, hc, 0.065, 0.055);\n  P(hc, [hc[0] - 0.06 * sin(la), hc[1] - 0.06 * cos(la), hc[2] + 0.02], 0.11, 0.085);\n  return n;\n}\n\nexport function draw(display, params) {\n  const s = params.s;\n  if (!s) return;\n  if (s.palHue !== s.hue) palette(s);\n  fogTable(s);\n  const { col, base, bg, fogC, fc, nz, nb, dist, R, sA, sZ, glow, caps } = s, t = s.t;\n  // The fog's billows, on every other LED each way: they drift across and\n  // the bank breathes slowly.\n  for (let j = 0; j \u003c= H / 2; j++)\n    for (let i = 0; i \u003c= W / 2; i++) {\n      const x = 2 * i, yc = 2 * j + 0.5;\n      nb[j * 33 + i] = 0.6 + 0.8 * vn((x + 9 * t) / 13, yc / 5 + 0.3 * t) * (0.6 + 0.4 * vn((x - 4 * t) / 9, yc / 4 + 50));\n    }\n  // The sky, the lane under its fog, and the scenery, fogged at its depth.\n  for (let y = 0; y \u003c H; y++) {\n    const yc = y + 0.5, dy = yc - YH, tg = dy > 0 ? tau(R, (F * HC) / dy, 0) : 0, j = y >> 1, fy = (y & 1) * 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, o = q * 3, i = j * 33 + (x >> 1), fx = (x & 1) * 0.5;\n      const n0 = nb[i] + (nb[i + 1] - nb[i]) * fx, n1 = nb[i + 33] + (nb[i + 34] - nb[i + 33]) * fx, n = n0 + (n1 - n0) * fy, L = 0.45 + 0.55 * n;\n      nz[q] = n;\n      // The billows catch the light unevenly too.\n      (fc[o] = fogC[o] * L), (fc[o + 1] = fogC[o + 1] * L), (fc[o + 2] = fogC[o + 2] * L);\n      let r = base[o], g = base[o + 1], b = base[o + 2];\n      if (tg > 0) {\n        const f = 1 - exp(-tg * n);\n        r += (fc[o] - r) * f;\n        g += (fc[o + 1] - g) * f;\n        b += (fc[o + 2] - b) * f;\n      }\n      const a = sA[q];\n      if (a > 0) {\n        const z = sZ[q], gl = GL[q], f = 1 - exp(-tau(R, z, HC - (dy * z) / F) * n) * (z > 50 ? 0.45 : 1);\n        const tr = 10 + glow[0] * 40 * gl, tgr = 6 + glow[1] * 40 * gl, tb = 14 + glow[2] * 40 * gl;\n        r += (tr + (fc[o] - tr) * f - r) * a;\n        g += (tgr + (fc[o + 1] - tgr) * f - g) * a;\n        b += (tb + (fc[o + 2] - tb) * f - b) * a;\n      }\n      col[o] = r;\n      col[o + 1] = g;\n      col[o + 2] = b;\n      bg[q] = max(r, g, b);\n    }\n  }\n  // Zombies, far to near, each as a soft distance field of its capsules.\n  const order = s.zs.filter((Z) => Z.z > 0).sort((a, b) => b.z - a.z);\n  for (const Z of order) {\n    const nc = pose(s, Z, caps), z = Z.z, scl = (F / z) * Z.size, fw = cl(0.6 + scl / 50, 0.8, 1.45);\n    let X0 = W, X1 = -1, Y0 = H, Y1 = -1;\n    for (let c = 0; c \u003c nc; c += 6) {\n      const r = max(caps[c + 4], caps[c + 5]) + fw + 1;\n      X0 = min(X0, caps[c] - r, caps[c + 2] - r);\n      X1 = max(X1, caps[c] + r, caps[c + 2] + r);\n      Y0 = min(Y0, caps[c + 1] - r, caps[c + 3] - r);\n      Y1 = max(Y1, caps[c + 1] + r, caps[c + 3] + r);\n    }\n    (X0 = max(0, floor(X0))), (X1 = min(W - 1, floor(X1))), (Y0 = max(0, floor(Y0))), (Y1 = min(H - 1, floor(Y1)));\n    if (X0 > X1 || Y0 > Y1) continue;\n    for (let y = Y0; y \u003c= Y1; y++) dist.fill(1e9, y * W + X0, y * W + X1 + 1);\n    for (let c = 0; c \u003c nc; c += 6) {\n      const x0 = caps[c], y0 = caps[c + 1], x1 = caps[c + 2], y1 = caps[c + 3], r0 = caps[c + 4], r1 = caps[c + 5];\n      const ex = x1 - x0, ey = y1 - y0, ll = ex * ex + ey * ey || 1e-9, R2 = max(r0, r1) + fw + 1;\n      const xa = max(X0, floor(min(x0, x1) - R2)), xb = min(X1, floor(max(x0, x1) + R2)), ya = max(Y0, floor(min(y0, y1) - R2)), yb = min(Y1, floor(max(y0, y1) + R2));\n      for (let y = ya; y \u003c= yb; y++)\n        for (let x = xa, q = y * W + xa; x \u003c= xb; x++, q++) {\n          const px = x + 0.5 - x0, py = y + 0.5 - y0, u = cl((px * ex + py * ey) / ll, 0, 1), dx = px - u * ex, dy = py - u * ey;\n          const rr = r0 + (r1 - r0) * u, d2 = dx * dx + dy * dy, far = rr + fw;\n          if (d2 > far * far) continue;\n          const dd = sqrt(d2) - rr;\n          if (dd \u003c dist[q]) dist[q] = dd;\n        }\n    }\n    // Black with a rim of the glow behind it, as bright as what it stands\n    // against, then fogged by the air between.\n    const fade = Z.fade * sm(ZOUT, ZFADE, z);\n    for (let y = Y0; y \u003c= Y1; y++) {\n      const h = HC - ((y + 0.5 - YH) * z) / F, th = tau(R, z, h);\n      for (let x = X0, q = y * W + X0; x \u003c= X1; x++, q++) {\n        const dd = dist[q];\n        if (dd > fw) continue;\n        // A fading zombie comes apart where the fog billows thickest first.\n        let a = sm(fw, -fw, dd) * (fade > 0.99 ? 1 : sm(0, 0.35, fade * 1.4 - 0.5 * (nz[q] - 0.6)));\n        if (sZ[q] \u003c z) a *= 1 - sA[q];\n        if (a \u003c= 0) continue;\n        const o = q * 3, rim = dd \u003c -6 ? 0 : exp(min(0, dd) / 1.4) * min(1, bg[q] / 150) * 0.85, f = 1 - exp(-th * nz[q]) * (0.6 + 0.4 * fade);\n        const r = 18 + glow[0] * 200 * rim, g = 9 + glow[1] * 200 * rim, b = 32 + glow[2] * 200 * rim;\n        col[o] += (r + (fc[o] - r) * f - col[o]) * a;\n        col[o + 1] += (g + (fc[o + 1] - g) * f - col[o + 1]) * a;\n        col[o + 2] += (b + (fc[o + 2] - b) * f - col[o + 2]) * a;\n      }\n    }\n    // Eyes: some always, every one while the heads are up.\n    const eo = (Z.eyes ? 0.7 : 0) + s.look * 0.6;\n    if (eo > 0 && scl > 9) {\n      // On the face, which turns to the eye as the head comes up.\n      const yw = Z.yaw * (1 - s.look), hx = (caps[nc - 6] - Z.X) / scl + 0.08 * sin(yw), ey = caps[nc - 5] + 0.01 * scl;\n      const e = min(1, eo) * exp(-tau(R, z, 1.62)) * fade;\n      for (const side of [-1, 1]) glowDot(col, Z.X + (hx + side * 0.045 * cos(yw)) * scl, ey, max(0.5, 0.022 * scl), glow, e);\n    }\n  }\n  grain(display, col, nz);\n}\n\nfunction glowDot(col, cx, cy, r, c, e) {\n  for (let y = max(0, floor(cy - 4)); y \u003c= min(H - 1, floor(cy + 4)); y++)\n    for (let x = max(0, floor(cx - 4)); x \u003c= min(W - 1, floor(cx + 4)); x++) {\n      const d2 = (x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2, k = e * (exp(-d2 / (r * r)) + 0.35 * exp(-d2 / (5 * r * r))), o = (y * W + x) * 3;\n      col[o] += (120 + c[0] * 135) * k;\n      col[o + 1] += (120 + c[1] * 135) * k;\n      col[o + 2] += (120 + c[2] * 135) * k;\n    }\n}\n\n// Grain: a fine checker half a step above and below each LED's level, the\n// mist's droplets, as strong as the picture around it allows so it never\n// makes a step of more than 40 levels, and a little stronger where the fog\n// billows thick.\nconst lv = new Float32Array(N);\nfunction grain(display, col, nz) {\n  for (let q = 0; q \u003c N; q++) lv[q] = min(255, max(col[q * 3], col[q * 3 + 1], col[q * 3 + 2]));\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = y * W + x, m = lv[q], o = q * 3;\n      let g = 0;\n      if (x > 0) g = max(g, abs(m - lv[q - 1]));\n      if (x \u003c W - 1) g = max(g, abs(m - lv[q + 1]));\n      if (y > 0) g = max(g, abs(m - lv[q - W]));\n      if (y \u003c H - 1) g = max(g, abs(m - lv[q + W]));\n      const amp = max(0, min(19.5 * (0.8 + 0.15 * nz[q]), 0.45 * m, 0.45 * (255 - m), (39 - g) / 2));\n      const f = m > 0.5 ? (m + ((x + y) & 1 ? amp : -amp)) / m : 1;\n      display.setPixel(x, y, min(255, round(col[o] * f)), min(255, round(col[o + 1] * f)), min(255, round(col[o + 2] * f)));\n    }\n}\n","bak-sneppen":"// ===== Patternflow pattern =====\n// Title:   Bak-Sneppen\n// Family:  data\n// Idea:    Sixty-four species stand on a ring as bars of fitness, and every step the least fit one and its two neighbours are redrawn at random, so the floor of the bars climbs by itself to a threshold near two thirds while fresh colours break out in avalanches around the hopping minimum.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Bak-Sneppen model of evolution (Per Bak and Kim Sneppen, 1993), with its random-neighbour version (Henrik Flyvbjerg, Kim Sneppen and Per Bak, 1993), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Random=0..1, Memory=0..1\n//\n// Knob 1: Hue. Turns the colours of age round the wheel together. At 0 a bar just redrawn is pale gold, then orange, rose and violet as it waits, and a bar left alone for long is deep blue; the gap line and the marked minimum are aqua. At 0.25 fresh bars are lime and old ones crimson; at 0.5 fresh is aqua and old is gold; at 0.75 fresh is pink and old is green.\n// Knob 2: Speed. Steps of the model a second, 25 times the knob, so 50 at 2. Each fresh start first runs a climb: 6,000 steps in 1.8 s, slow at first and faster and faster, so the gap line rises evenly from the bottom to 0.645 on average; then the model walks at the knob's pace for 40 s and the bars are thrown again. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Random. The chance that each of the two neighbours redrawn with the minimum is a species picked anywhere on the ring instead of the one beside it. At 0 the classic ring: the floor settles at 0.62 for 64 species, just under the 0.667 tick of the infinite ring, and avalanches stay local. At 0.25 the floor drops to 0.42, at 0.5 to 0.37, and at 1, the random-neighbour model, to 0.35, just over the 1/3 tick, and fresh bars flicker all over the ring.\n// Knob 4: Memory. How many steps a bar takes to turn from fresh to old, on a log scale of its age: 150 steps at 0, 184 at the opening 0.06, 820 at 0.5 and 4,500 at 1. Short memory shows only the avalanche of the last second or two as a bright patch on a blue block; long memory paints each bar by how long ago it was touched, so old avalanches stay as bands of rose and violet.\n// Buttons: K1 tap throws all 64 bars again from a uniform start and the climb runs anew.\n\nconst W = 64, H = 128, N = 64;\nconst { floor, round, min, max, abs, log, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The climb: CMAX steps in TC seconds at Speed 2, the step count growing as\n// CMAX^u, so the gap, which rises about 0.05 for every doubling of the steps,\n// rises evenly. Then RATE * Speed steps a second for CYCLE seconds at Speed 2.\nconst CMAX = 6000, TC = 1.8, RATE = 25, CYCLE = 40;\n// The threshold of the infinite ring (Paczuski, Maslov and Bak, 1996) and of\n// the random-neighbour model (Flyvbjerg, Sneppen and Bak, 1993).\nconst FC = 0.66702, FMF = 1 / 3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, rnd: 0, mem: 0.06,\n    f: new Float32Array(N), born: new Float64Array(N), step: 0, m: 0, G: 0,\n    ph: \"climb\", pt: 0, acc: 0,\n    // 64 colours of age, plus the gap line, its dim twin, the ticks and the\n    // marked minimum.\n    pal: new Float32Array(70 * 3), palKey: \"\",\n  };\n  throwBars(params.s);\n}\n\n// A uniform start: every species gets a fitness drawn at random and counts\n// as old, so the bars the climb redraws stand out from the first step.\nfunction throwBars(S) {\n  for (let i = 0; i \u003c N; i++) (S.f[i] = Math.random()), (S.born[i] = -1e9);\n  S.step = 0;\n  S.G = 0;\n  S.ph = \"climb\";\n  S.pt = 0;\n  S.acc = 0;\n  S.m = argmin(S.f);\n}\n\nfunction argmin(f) {\n  let m = 0;\n  for (let i = 1; i \u003c N; i++) if (f[i] \u003c f[m]) m = i;\n  return m;\n}\n\n// One step of the model: the least fit species and two others get new\n// fitnesses, and the gap, the largest minimum seen since the start, may rise.\nfunction step(S) {\n  const f = S.f, m = S.m;\n  if (f[m] > S.G) S.G = f[m];\n  S.step++;\n  const a = Math.random() \u003c S.rnd ? floor(Math.random() * N) : (m + N - 1) % N;\n  const b = Math.random() \u003c S.rnd ? floor(Math.random() * N) : (m + 1) % N;\n  for (const i of [m, a, b]) (f[i] = Math.random()), (S.born[i] = S.step);\n  S.m = argmin(f);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.rnd = cl(k[2], 0, 1);\n  S.mem = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1), v = S.speed / 2;\n  if (input.btnPressed && input.btnPressed[0]) throwBars(S);\n  S.pt += d * v;\n  if (S.ph === \"climb\") {\n    const u = min(1, S.pt / TC), target = round(pow(CMAX, u)) - 1;\n    while (S.step \u003c target) step(S);\n    if (u >= 1) (S.ph = \"walk\"), (S.pt = 0);\n  } else {\n    S.acc += d * RATE * S.speed;\n    while (S.acc >= 1) step(S), (S.acc -= 1);\n    if (S.pt > CYCLE) throwBars(S);\n  }\n}\n\n// Colours of age: index 0 is a bar redrawn this step, 63 a bar older than\n// the memory. Then 64 the gap line, 65 the line's dim twin over the dark,\n// 66 the threshold ticks, 67 the marked minimum, 68 the pointer above it.\nfunction palette(S) {\n  const key = S.hue + \":\" + S.mem;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const P = S.pal, h = S.hue + 0.14;\n  for (let i = 0; i \u003c 64; i++) {\n    const u = i / 63;\n    // Warm white, gold, orange, rose and violet to deep blue; the value\n    // stays above 0.55, and old ages near orange and yellow stay brighter\n    // still, so no age turns brown or olive whatever the hue.\n    const hh = h - 0.48 * pow(u, 0.8), dw = abs(hh - floor(hh) - 0.11), warm = max(0, 1 - min(dw, 1 - dw) / 0.14);\n    hsv(hh, 0.4 + 0.48 * min(1, u * 3), min(1, (1 - 0.45 * u) * (1 + 0.55 * warm * u)), P, i * 3);\n  }\n  hsv(h + 0.38, 0.3, 1, P, 64 * 3);\n  hsv(h + 0.38, 0.45, 0.6, P, 65 * 3);\n  hsv(h, 0.05, 1, P, 66 * 3);\n  hsv(h + 0.38, 0.55, 1, P, 67 * 3);\n  hsv(h + 0.38, 0.6, 0.45, P, 68 * 3);\n}\n\nconst row = (f) => cl(round(H - f * H), 0, H - 1);\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const P = S.pal, f = S.f, born = S.born, step = S.step;\n  // Ages on a log scale up to the memory, 150 to 4,500 steps.\n  const M = 150 * pow(30, S.mem), lm = log(1 + M);\n  const yG = S.G > 0 ? row(S.G) : -1, y1 = row(FC), y2 = row(FMF);\n  for (let x = 0; x \u003c W; x++) {\n    const top = row(f[x]), mark = x === S.m;\n    const c = min(63, round((63 * log(1 + step - born[x])) / lm)) * 3;\n    // Every other bar a shade darker, so 64 bars read as 64 and not a block.\n    const sh = x & 1 ? 0.86 : 1;\n    for (let y = 0; y \u003c H; y++) {\n      let o = -1, s = 1;\n      if (y >= top) {\n        o = mark ? 67 * 3 : c;\n        s = y === top ? 1.12 : sh;\n      } else if (mark) o = 68 * 3;\n      if (y === yG) o = y >= top ? 64 * 3 : 65 * 3;\n      if ((y === y1 || y === y2) && (x \u003c 3 || x > W - 4)) o = 66 * 3;\n      if (o \u003c 0) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      // Channels in steps of 4 of 255: too fine to see, and a frame packs smaller.\n      display.setPixel(x, y, min(255, round((P[o] * s) / 4) * 4), min(255, round((P[o + 1] * s) / 4) * 4), min(255, round((P[o + 2] * s) / 4) * 4));\n    }\n  }\n}\n","diffusion-front":"// ===== Patternflow pattern =====\n// Title:   Diffusion Front\n// Family:  fractal\n// Idea:    Every LED is a lattice site with a fixed random number and is occupied while that number is below the concentration of a dye diffusing up from the bottom row, erfc(h / 2 sqrt(Dt)); the occupied sites joined to the source glow pale cyan to deep blue with the concentration, a site that has just joined flashes white, islands not joined glow violet, and the cluster's outer boundary, the diffusion front, is drawn gold: a fractal hull that climbs as the square root of time and sits where the concentration is 0.5927, the percolation threshold, until the source shuts, the cluster is cut from it, the dye drains out and a fresh lattice starts.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: diffusion fronts and gradient percolation (Bernard Sapoval, Michel Rosso and Jean-François Gouyet, 1985), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hop=0..1, Islands=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the cluster runs from pale cyan at the front to deep blue at the source, the front is gold and the islands violet; at 0.25 the cluster runs from grey violet to magenta, the front is mint and the islands brick red; at 0.5 the cluster runs from brown to amber, the front is pale blue and the islands olive; at 0.75 the cluster is green, the front pink and the islands teal.\n// Knob 2: Speed. At 2 the front is 28 rows up after a quarter of a second, 55 after one second, 78 after two and 121 after 4.8, as the square root of time; it holds half a second, the source shuts and the dye drains for a second, so a run lasts 6.3 seconds. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Hop. How often each site draws a new random number. At 0 the lattice is frozen, the gradient percolation of one fixed lattice, and the front only climbs; at 0.5 each site draws again once a second on average and at 1 twice, so the occupied sites flicker like hopping particles, islands join the cluster and fall away, and the front shivers as it climbs.\n// Knob 4: Islands. How bright the occupied sites that are not joined to the source glow. At 0 they are dark and only the cluster joined to the source shows; at the opening 0.06 they glow violet at 113 of 255, at 0.25 at 196 and at 1 at 237, nearly as bright as the front.\n// Buttons: K1 tap starts a fresh lattice.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, exp, sqrt, abs, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// erfc(x) to 1.2e-7 (Numerical Recipes' Chebyshev fit).\nfunction erfc(x) {\n  const z = abs(x), t = 1 / (1 + 0.5 * z);\n  const r = t * exp(-z * z - 1.26551223 + t * (1.00002368 + t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * (-0.82215223 + t * 0.17087277)))))))));\n  return x >= 0 ? r : 2 - r;\n}\n\n// The front sits where p = 0.5927, at h = 0.3778 L with L = 2 sqrt(D t).\n// A run grows L from L0 to L1 in GROW seconds (at Speed 2) with L^2 growing\n// evenly in time, holds, shuts the source and drains for DRAIN seconds, then\n// starts again on a fresh lattice.\nconst L1 = 320, L0 = 10, GROW = 4.8, HOLD = 0.5, DRAIN = 1.0, PC = 0.5927;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, hop: 0, isl: 0.06, c: 0, L: L0, runs: 0,\n    u: new Float32Array(N), occ: new Uint8Array(N), A: new Uint8Array(N), B: new Uint8Array(N), hull: new Uint8Array(N),\n    join: new Float32Array(N), q: new Int32Array(N), p: new Float64Array(H), glow: new Float32Array(N * 3), ease: 1,\n    // Front sites and their mean height in rows, kept for checking the\n    // front against the threshold.\n    nHull: 0, hf: 0,\n  };\n  fresh(params.s);\n}\n\nfunction fresh(S) {\n  for (let i = 0; i \u003c N; i++) S.u[i] = Math.random();\n  S.join.fill(-1);\n  S.c = 0;\n  S.runs++;\n}\n\n// Occupancy from p(h), the cluster joined to the source row (4-neighbour),\n// the empty sites joined to the open top (8-neighbour), and the hull: the\n// cluster's sites that touch that open emptiness.\nfunction percolate(S) {\n  const { u, occ, A, B, hull, q, p } = S;\n  for (let y = 0; y \u003c H; y++) {\n    const py = p[y], o = y * W;\n    for (let x = 0; x \u003c W; x++) occ[o + x] = u[o + x] \u003c py ? 1 : 0;\n  }\n  A.fill(0);\n  let t = 0;\n  for (let x = 0, o = (H - 1) * W; x \u003c W; x++) if (occ[o + x]) (A[o + x] = 1), (q[t++] = o + x);\n  for (let k = 0; k \u003c t; k++) {\n    const i = q[k], x = i % W;\n    if (x > 0 && occ[i - 1] && !A[i - 1]) (A[i - 1] = 1), (q[t++] = i - 1);\n    if (x \u003c W - 1 && occ[i + 1] && !A[i + 1]) (A[i + 1] = 1), (q[t++] = i + 1);\n    if (i >= W && occ[i - W] && !A[i - W]) (A[i - W] = 1), (q[t++] = i - W);\n    if (i + W \u003c N && occ[i + W] && !A[i + W]) (A[i + W] = 1), (q[t++] = i + W);\n  }\n  B.fill(0);\n  t = 0;\n  for (let x = 0; x \u003c W; x++) if (!occ[x]) (B[x] = 1), (q[t++] = x);\n  for (let k = 0; k \u003c t; k++) {\n    const i = q[k], x = i % W, y = (i - x) / W;\n    for (let dy = -1; dy \u003c= 1; dy++) {\n      const yy = y + dy;\n      if (yy \u003c 0 || yy >= H) continue;\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        const xx = x + dx;\n        if (xx \u003c 0 || xx >= W) continue;\n        const j = yy * W + xx;\n        if (!occ[j] && !B[j]) (B[j] = 1), (q[t++] = j);\n      }\n    }\n  }\n  let nh = 0, sh = 0;\n  for (let i = 0; i \u003c N; i++) {\n    let f = 0;\n    if (A[i]) {\n      const x = i % W;\n      f = i \u003c W || (x > 0 && B[i - 1]) || (x \u003c W - 1 && B[i + 1]) || B[i - W] || (i + W \u003c N && B[i + W]) ? 1 : 0;\n      if (f) (nh++), (sh += H - 1 - (i - x) / W);\n    }\n    hull[i] = f;\n  }\n  S.nHull = nh;\n  S.hf = nh ? sh / nh : 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.hop = cl(k[2], 0, 1);\n  S.isl = cl(k[3], 0, 1);\n  const d = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.ease = 1 - exp(-d / 0.08);\n  if (input.btnPressed && input.btnPressed[0]) fresh(S);\n  S.c += d;\n  if (S.c > GROW + HOLD + DRAIN) fresh(S);\n  // L^2 = 4 D t grows evenly; once the source shuts at GROW + HOLD, the\n  // profile is the same erfc less one started at the moment of shutting\n  // (the source row held at zero from then on), so the source row empties\n  // at once and the rest drains out through it.\n  const K = (L1 * L1 - L0 * L0) / GROW, ts = GROW + HOLD;\n  S.L = sqrt(L0 * L0 + K * S.c);\n  const Ls = S.c > ts ? sqrt(K * (S.c - ts)) : 0;\n  for (let y = 0; y \u003c H; y++) {\n    const h = H - 1 - y;\n    S.p[y] = erfc(h / S.L) - (Ls > 0 ? erfc(h / Ls) : 0);\n  }\n  // Hop: each site draws a new random number at this rate a second.\n  if (S.hop > 0) {\n    const r = 1 - exp(-2 * S.hop * d);\n    for (let i = 0; i \u003c N; i++) if (Math.random() \u003c r) S.u[i] = Math.random();\n  }\n  percolate(S);\n  const { A, join } = S;\n  for (let i = 0; i \u003c N; i++) {\n    if (A[i]) {\n      if (join[i] \u003c 0) join[i] = S.c;\n    } else join[i] = -1;\n  }\n}\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { occ, A, hull, join, p, glow } = S;\n  const hu = S.hue;\n  const front = hsv(hu + 0.12, 0.35, 1), flash = hsv(hu + 0.5, 0.05, 1), isl = hsv(hu + 0.78, 0.7, 1);\n  const il = (255 * S.isl) / (S.isl + 0.075);\n  for (let y = 0; y \u003c H; y++) {\n    // The cluster is lit by the concentration where it stands: dim at the\n    // front, where p is near the threshold, bright near the source.\n    const sy = pow(cl((p[y] - PC) / (1 - PC), 0, 1), 0.8), lv = 255 * (0.45 + 0.55 * sy);\n    const c = hsv(hu + 0.5 + 0.12 * sy, 0.4 + 0.5 * sy, 1);\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let r = 0, g = 0, b = 0;\n      if (hull[i]) (r = 255 * front[0]), (g = 255 * front[1]), (b = 255 * front[2]);\n      else if (A[i]) {\n        // A site that has just joined flashes pale and settles in half a second.\n        const a = cl((S.c - join[i]) / 0.5, 0, 1), v = 255 * (1 - a), w = lv * a;\n        r = flash[0] * v + c[0] * w;\n        g = flash[1] * v + c[1] * w;\n        b = flash[2] * v + c[2] * w;\n      } else if (occ[i]) (r = il * isl[0]), (g = il * isl[1]), (b = il * isl[2]);\n      // Each LED eases towards its colour in about a tenth of a second, so a\n      // cluster cut from the source sinks to island colour instead of\n      // switching.\n      const o = i * 3, e = S.ease;\n      glow[o] += (r - glow[o]) * e;\n      glow[o + 1] += (g - glow[o + 1]) * e;\n      glow[o + 2] += (b - glow[o + 2]) * e;\n      display.setPixel(x, y, glow[o], glow[o + 1], glow[o + 2]);\n    }\n  }\n}\n","in-the-flash":"// ===== Patternflow pattern =====\n// Title:   In the Flash\n// Family:  halloween\n// Idea:    A rainy field at night stays almost dark, rain and a faint horizon, until lightning lights it violet-white for a moment and shows a tall thin figure standing in the grass, a little closer at every flash and never once seen moving, until a flash shows its head right in front of you and two glowing eyes stay behind in the dark; the next flash shows an empty field, and then it stands far off again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Approach=3..8\n//\n// Knob 1: Hue. The tint of the flash and the colour of the eyes, turned together: at 0 a violet-white flash and toxic green eyes; at 0.25 a pink-white flash and blue eyes; at 0.5 a pale yellow-green flash and magenta eyes; at 0.75 a pale cyan flash and orange eyes. The dark sky between flashes stays deep violet.\n// Knob 2: Speed. How often the lightning comes. At 2 the figure takes 6.4 s to come from far off to right in front, split evenly between its steps, each gap 0.85 to 1.15 times its share, and the eyes stay at least 2.3 s; at 0.2 the gaps are ten times as long, at 3 two thirds as long, but never shorter than half a second. A flash itself always lights the field for about two thirds of a second: a bright stroke, and a weaker one 0.2 s later. The first comes 0.5 s in at Speed 2.\n// Knob 3: Rain. At 0 about 200 drops in the air, at 1 about 900, each a streak slanting left, dim in the dark and lit with the flash's tint when it comes.\n// Knob 4: Approach. How many flashes it takes to come from far off to right in front: at 3 it stands 18 LEDs tall on the horizon, then 38, then 82 with its feet at the bottom; at 8 it comes in eight smaller steps, so the lightning comes more often. Then one flash for the face and one for the empty field.\n// Buttons: K1 tap brings the next flash at once.\n\nconst W = 64, H = 128, N = W * H, HZ = 70;\nconst { floor, round, min, max, abs, sqrt, exp, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n// Value noise on a lattice, in two dimensions.\nconst vn2 = (x, y, sd) => {\n  const i = floor(x), j = floor(y), u = sm(x - i), v = sm(y - j);\n  const a = hash(i * 7919 + j * 104729 + sd), b = hash((i + 1) * 7919 + j * 104729 + sd);\n  const c = hash(i * 7919 + (j + 1) * 104729 + sd), d = hash((i + 1) * 7919 + (j + 1) * 104729 + sd);\n  return a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// Seen from eye height 1.6 m with 60 LEDs to the metre at one metre off, the\n// horizon on row HZ. The figure is 2.4 m tall and comes from 8 m to 1.75 m.\nconst FOC = 60, EYE = 1.6, TALL = 2.4, ZFAR = 8, ZNEAR = 1.75;\n// Seconds at Speed 2 for the whole approach, and the least the eyes stay.\nconst TAPP = 6.4, TEYES = 2.3;\nconst MAXD = 900;\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, rain: 0, steps: 3,\n    next: 0.5, ft: 9, k: 0, n: 0, cyc: 0, x0: 24, fig: null, face: false, eyes: -1,\n    bolt: new Int16Array(800), nb: 0, bx: 32,\n    drops: new Float32Array(MAXD * 3), base: new Float32Array(N * 3), lit: new Float32Array(N), fm: new Uint8Array(N), buf: new Float32Array(N * 3),\n    fc: [0, 0, 0], ec: [0, 0, 0], colF: new Float32Array(W),\n  });\n  scene(S);\n  for (let i = 0; i \u003c MAXD; i++) {\n    S.drops[i * 3] = Math.random() * 80;\n    S.drops[i * 3 + 1] = Math.random() * H;\n    S.drops[i * 3 + 2] = Math.random();\n  }\n}\n\n// The still scene: its dark colours and how much of the flash each LED gives\n// back. Clouds in the sky, wet grass below, and a lone tree and a fence line\n// that stay black.\nfunction scene(S) {\n  const { base, lit } = S;\n  const tree = new Uint8Array(N);\n  // A bare tree on the horizon: a trunk and branches that fork twice.\n  const limb = (x, y, a, len, w, d) => {\n    for (let s = 0; s \u003c len; s += 0.5) {\n      const px = x + Math.sin(a) * s, py = y - Math.cos(a) * s;\n      for (let i = -floor(w / 2); i \u003c= floor((w - 1) / 2); i++) {\n        const xx = round(px) + i, yy = round(py);\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tree[yy * W + xx] = 1;\n      }\n    }\n    if (d \u003c 3) {\n      const ex = x + Math.sin(a) * len, ey = y - Math.cos(a) * len;\n      limb(ex, ey, a - 0.45 - 0.3 * hash(d * 7 + len), len * 0.68, max(1, w - 1), d + 1);\n      limb(ex, ey, a + 0.5 + 0.25 * hash(d * 13 + len), len * 0.62, max(1, w - 1), d + 1);\n    }\n  };\n  limb(10, HZ + 1, 0.05, 9, 2, 0);\n  // Fence posts along the right, 1.9 m off, every 1.9 m, with two wires.\n  const posts = [];\n  for (let i = 0; i \u003c 16; i++) {\n    const z = 3.4 + 1.9 * i, x = 32 + (FOC * 1.9) / z, yb = HZ + (FOC * EYE) / z, h = (FOC * 1.15) / z;\n    posts.push([x, yb, h]);\n    for (let y = round(yb - h); y \u003c= round(yb); y++)\n      for (let xx = floor(x - max(0.5, 5 / z)); xx \u003c= floor(x + max(0.5, 5 / z) - 0.01); xx++) if (xx >= 0 && xx \u003c W && y \u003c H) tree[y * W + xx] = 1;\n  }\n  for (let i = 0; i + 1 \u003c posts.length; i++)\n    for (const f of [0.9, 0.5]) {\n      const [x1, y1, h1] = posts[i], [x2, y2, h2] = posts[i + 1];\n      for (let s = 0; s \u003c= 1; s += 0.05) {\n        const xx = round(x1 + (x2 - x1) * s), yy = round(y1 - h1 * f + (y2 - h2 * f - y1 + h1 * f) * s);\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tree[yy * W + xx] = 1;\n      }\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3;\n      if (tree[p]) {\n        (base[o] = 3), (base[o + 1] = 2), (base[o + 2] = 6), (lit[p] = 0);\n        continue;\n      }\n      if (y \u003c HZ) {\n        // Clouds: two scales of noise, in five steps, heavier low down.\n        const c = floor(cl(0.65 * vn2(x / 14, y / 7, 3) + 0.35 * vn2(x / 5, y / 3, 9) - 0.15 + y / 260, 0, 1) * 5) / 5;\n        const g = y > HZ - 9 ? ((y - HZ + 9) / 9) ** 2 : 0;\n        base[o] = 12 + 9 * c + 30 * g;\n        base[o + 1] = 8 + 6 * c + 22 * g;\n        base[o + 2] = 22 + 14 * c + 40 * g;\n        lit[p] = 0.22 + 0.45 * c;\n      } else {\n        // The field: rows of wet grass closing up toward the horizon.\n        const d = (y - HZ + 1) / (H - HZ), gr = floor(vn2(x / (2 + 3 * d), (y - HZ) / (1 + 2 * d), 21) * 3) / 3;\n        base[o] = 5;\n        base[o + 1] = 6;\n        base[o + 2] = 10;\n        lit[p] = (0.16 + 0.14 * gr) * (y \u003c HZ + 3 ? 1.5 : 1);\n      }\n    }\n}\n\n// The figure, standing: rows of spans from the top of its head (v = 0) to\n// its feet (v = 1), into the mask fm, centred on an LED so that it stays\n// symmetric when small. A small head on a long neck, narrow shoulders, a\n// thin trunk, long legs, and long arms that hang off the shoulders and\n// spread a little to hands below the knee. A lean of the head and how far\n// the arms stand off change from flash to flash.\nfunction stand(S, cx, top, h, tilt, spread) {\n  const fm = S.fm;\n  fm.fill(0);\n  cx = floor(cx) + 0.5;\n  const span = (y, c, hw) => {\n    for (let x = max(0, floor(cx + c - hw)); x \u003c= min(W - 1, floor(cx + c + hw)); x++) if (abs(x + 0.5 - cx - c) \u003c= hw + 0.02) fm[y * W + x] = 1;\n  };\n  const tw0 = max(0.5, 0.05 * h), aw0 = max(0.5, 0.017 * h), sh = tw0 + aw0 + 1.05, lc = max(1, 0.036 * h), lw = max(0.5, 0.022 * h);\n  for (let y = max(0, floor(top)); y \u003c min(H, top + h + 1); y++) {\n    const v = (y + 0.5 - top) / h;\n    if (v \u003c 0 || v > 1.01) continue;\n    if (v \u003c 0.095) {\n      const q = (v - 0.05) / 0.05;\n      span(y, round(tilt * 0.02 * h * (1 - v * 10)), max(1, 0.042 * h * sqrt(max(0, 1 - q * q))));\n    } else if (v \u003c 0.13) span(y, 0, max(0.5, 0.013 * h));\n    // Narrow shoulders, joining the arms to the trunk.\n    else if (v \u003c 0.13 + max(0.035, 1.1 / h)) span(y, 0, sh + 0.6);\n    else {\n      if (v \u003c 0.53) span(y, 0, max(0.5, tw0 * (1 - 0.25 * (v - 0.13))));\n      // The arms spread a little as they hang; the hands are thinner, with\n      // a finger turned out.\n      if (v \u003c 0.84) {\n        const s = (v - 0.13) / 0.71, hand = v > 0.76, aw = hand ? max(0.5, aw0 * 0.6) : aw0;\n        for (const sg of [-1, 1]) {\n          const c = sh + (max(1.6, 0.05 * h) + spread * (sg > 0 ? 1 : 0.5) * 0.04 * h) * s;\n          span(y, sg * c, aw);\n          if (hand && h > 40 && v > 0.79) span(y, sg * (c + 1 + (v - 0.79) * h * 0.5), 0.5);\n        }\n      }\n      if (v >= 0.5) {\n        span(y, -lc, lw);\n        span(y, lc, lw);\n        if (v > 0.985 && h > 30) (span(y, -lc - lw, lw), span(y, lc + lw, lw));\n      }\n    }\n  }\n}\n\n// Right in front: a head from row 13 to row 66, leaning a little, on a thin\n// neck, and narrow shoulders falling away to the edges.\nconst TILT = -0.12, EYEY = 38;\nfunction close(S) {\n  const fm = S.fm;\n  fm.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const dy = (y - 39.5) / 26.5, rx = 19 * (dy > 0 ? 1 - 0.3 * dy * dy : 1), head = abs(dy) \u003c 1 ? rx * sqrt(1 - dy * dy) : 0, hx = 32 + (y - EYEY) * TILT;\n    const neck = y > 60 ? 6.5 : 0, sh = y > 82 ? 6.5 + (y - 82) * 1.6 : 0;\n    for (let x = 0; x \u003c W; x++) if (abs(x + 0.5 - hx) \u003c= head || abs(x + 0.5 - 32) \u003c= max(neck, sh)) fm[y * W + x] = 1;\n  }\n}\n\n// A flash: what it shows, the bolt, and when the next one comes.\nfunction flash(S) {\n  const n = S.steps, k = S.k;\n  S.ft = 0;\n  S.face = false;\n  S.fig = null;\n  if (k \u003c n) {\n    if (k === 0) (S.cyc++), (S.x0 = 15 + 14 * hash(S.cyc * 31));\n    const p = n > 1 ? k / (n - 1) : 1, z = ZFAR * pow(ZNEAR / ZFAR, p), h = (FOC * TALL) / z, feet = HZ + (FOC * EYE) / z;\n    const sd = S.cyc * 17 + k;\n    S.fig = 1;\n    stand(S, S.x0 + (32 - S.x0) * p, feet - h, h, hash(sd) * 2 - 1, hash(sd + 5));\n  } else if (k === n) (S.face = true), close(S), (S.eyes = 0);\n  else S.fm.fill(0);\n  // A bolt: a jagged walk down from the top with two forks, ending low in the\n  // clouds or at the horizon.\n  let x = (S.bx = 6 + 52 * Math.random()), nb = 0;\n  const yEnd = Math.random() \u003c 0.6 ? HZ - 1 : 34 + 24 * Math.random();\n  const walk = (x, y, y1, dir, lim) => {\n    while (y \u003c y1 && nb \u003c lim) {\n      const ny = y + 2 + floor(Math.random() * 4), nx = x + dir * (Math.random() * 2.5) + (Math.random() - 0.5) * 5;\n      for (let s = 0; s \u003c 1; s += 0.2) if (nb \u003c lim) (S.bolt[2 * nb] = round(x + (nx - x) * s)), (S.bolt[2 * nb + 1] = round(y + (ny - y) * s)), nb++;\n      (x = nx), (y = ny);\n      if (dir === 0 && Math.random() \u003c 0.12 && y \u003c y1 - 12) {\n        const keep = [x, y];\n        walk(x, y, y + 10 + 14 * Math.random(), Math.random() \u003c 0.5 ? -1.6 : 1.6, min(400, nb + 60));\n        [x, y] = keep;\n      }\n    }\n  };\n  walk(x, 0, yEnd, 0, 400);\n  S.nb = nb;\n  // The next flash.\n  const d = TAPP / n, j = 0.85 + 0.3 * hash(S.n++ * 13 + 7);\n  // Never more than two flashes a second, whatever the knobs.\n  S.next = S.t + max(0.26 * S.speed, (k === n ? max(d, TEYES) : d) * j);\n  S.k = k + 1 > n + 1 ? 0 : k + 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 0, 3], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kn[0], 0, 1);\n  S.speed = cl(kn[1], 0.2, 3);\n  S.rain = cl(kn[2], 0, 1);\n  S.steps = round(cl(kn[3], 3, 8));\n  if (S.k > S.steps + 1) S.k = 0;\n  S.t += (d * S.speed) / 2;\n  S.ft += d;\n  if (S.eyes >= 0) S.eyes += (d * S.speed) / 2;\n  if (S.t >= S.next || (input.btnPressed && input.btnPressed[0] && S.ft > 0.6)) flash(S);\n  // Rain falls 105 LEDs a second, slanting left.\n  const dr = S.drops, cnt = 200 + floor(700 * S.rain);\n  for (let i = 0; i \u003c cnt; i++) {\n    const o = i * 3, v = 80 + 50 * dr[o + 2];\n    dr[o + 1] += v * d;\n    dr[o] -= 0.22 * v * d;\n    if (dr[o + 1] > H + 4) (dr[o + 1] -= H + 8), (dr[o] = Math.random() * 80);\n  }\n}\n\n// How bright the flash is, s seconds after it starts: a stroke, and a second\n// weaker one 0.2 s later.\nconst env = (s) => {\n  const f = s \u003c 0 ? 0 : max(exp(-s / 0.2), 0.62 * sm((s - 0.17) / 0.05) * exp(-max(0, s - 0.22) / 0.24));\n  return f \u003c 0.02 ? 0 : f;\n};\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { buf, base, lit, fm, colF } = S, F = env(S.ft), fc = hsv(0.76 + S.hue, 0.45, 1, S.fc), ec = hsv(0.3 + S.hue, 0.8, 1, S.ec);\n  // The sky is brightest round the bolt.\n  for (let x = 0; x \u003c W; x++) colF[x] = F * (0.85 + 0.75 * exp(-abs(x - S.bx) / 12));\n  // The figure is black against the flash and gone into the dark between.\n  const hide = 1 - min(1, F * 6);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    if (fm[p]) {\n      buf[o] = base[o] * hide;\n      buf[o + 1] = base[o + 1] * hide;\n      buf[o + 2] = base[o + 2] * hide;\n      continue;\n    }\n    const l = lit[p] * colF[p & 63];\n    buf[o] = base[o] + fc[0] * l;\n    buf[o + 1] = base[o + 1] + fc[1] * l;\n    buf[o + 2] = base[o + 2] + fc[2] * l;\n  }\n  // The bolt, white with a glow of the flash's tint, while the strokes last.\n  if (F > 0.3) {\n    const a = min(1, (F - 0.3) * 2.5);\n    for (let i = 0; i \u003c S.nb; i++) {\n      const x = S.bolt[2 * i], y = S.bolt[2 * i + 1];\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= HZ || fm[y * W + x]) continue;\n      for (const dx of [-1, 1]) if (x + dx >= 0 && x + dx \u003c W && !fm[y * W + x + dx]) add(buf, (y * W + x + dx) * 3, fc, 0.5 * a);\n      const o = (y * W + x) * 3;\n      buf[o] += (255 - buf[o]) * a;\n      buf[o + 1] += (255 - buf[o + 1]) * a;\n      buf[o + 2] += (255 - buf[o + 2]) * a;\n    }\n  }\n  // Rain: dim streaks in the dark, near white in the flash. Two depths.\n  const dr = S.drops, cnt = 200 + floor(700 * S.rain);\n  for (let i = 0; i \u003c cnt; i++) {\n    const o = i * 3, near = dr[o + 2] > 0.6, len = near ? 4 : 2, br = near ? 1 : 0.6;\n    const r = (30 + 0.9 * fc[0] * F) * br, g = (34 + 0.9 * fc[1] * F) * br, b = (50 + 0.9 * fc[2] * F) * br;\n    for (let j = 0; j \u003c len; j++) {\n      const x = round(dr[o] + 0.22 * j), y = round(dr[o + 1] - j);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = (y * W + x) * 3, f = (1 - j / (len + 1)) * (fm[y * W + x] ? 0.35 + 0.65 * hide : 1);\n      buf[q] = max(buf[q], r * f);\n      buf[q + 1] = max(buf[q + 1], g * f);\n      buf[q + 2] = max(buf[q + 2], b * f);\n    }\n  }\n  // The eyes, right in front, glowing on after the flash, blinking once.\n  if (S.face && S.eyes >= 0) {\n    const e = S.eyes, open = e \u003c 0.08 ? e / 0.08 : abs(e - 1.1) \u003c 0.08 ? 0.15 : e > TEYES - 0.3 ? max(0, (TEYES - e) / 0.3) : 1;\n    if (open > 0)\n      for (const cx of [24.5, 40.5])\n        for (let dy = -3; dy \u003c= 3; dy++)\n          for (let dx = -6; dx \u003c= 6; dx++) {\n            // Round, with a slit, the outer corners lifted a little.\n            const side = cx \u003c 32 ? -1 : 1, y = EYEY + dy, x = floor(cx + dx), u = x + 0.5 - cx, lift = u * side > 1.5 ? 0.6 : 0;\n            const r = (u / 3.3) ** 2 + ((dy + lift) / (2.4 * open + 0.3)) ** 2;\n            if (r > 1.9) continue;\n            const o = (y * W + x) * 3;\n            if (r \u003c= 1) add(buf, o, abs(u) \u003c 0.6 && open > 0.5 ? [10, 10, 10] : r \u003c 0.3 ? [255, 255, 235] : ec, 1);\n            else add(buf, o, ec, 0.3 * open);\n          }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3)\n    display.setPixel(p & 63, p >> 6, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n}\n\nfunction add(buf, o, c, a) {\n  buf[o] += (c[0] - buf[o]) * a;\n  buf[o + 1] += (c[1] - buf[o + 1]) * a;\n  buf[o + 2] += (c[2] - buf[o + 2]) * a;\n}\n","inverse-cascade":"// ===== Patternflow pattern =====\n// Title:   Inverse Cascade\n// Family:  noise\n// Idea:    Two-dimensional turbulence solved on the panel's own 64x128 grid: a field of small random eddies gathers within two seconds into round vortices, red-to-amber ones turning one way and indigo-to-sky-blue ones the other, each ringed by contour bands of its vorticity, and same-sign vortices orbit, wrap each other in thin spiral filaments and merge into fewer and larger ones, carrying the energy up to the large scales while the enstrophy drains away down the filaments, until the energy fills the box and a fresh field of small eddies starts the cascade again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: inverse energy cascade of two-dimensional turbulence (Robert Kraichnan, 1967; George Batchelor, 1969), coherent vortices of decaying two-dimensional turbulence (James McWilliams, 1984), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Scale=-1..1, Viscosity=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together, always half a turn apart. At 0 vorticity of one sign runs from deep crimson through red to amber and the white of a vortex core, and of the other from indigo through blue to sky blue and white; on the panel the warm vortices turn clockwise and the cool ones anticlockwise. At 0.25 lime and magenta, at 0.5 olive and cyan, at 0.75 green and violet. The stream function tints each side a little towards one end or the other of its own range.\n// Knob 2: Speed. Flow time per second. At 2 the eddies gather into round vortices in about 2 seconds; some 60 vortices at 2 seconds are 12 at 8, and a run ends with 6 or 7 after 13 to 22 seconds. At 1 half as fast, at 0.2 a tenth. Above 2 a frame may take a third step, and at 3 a run lasts about 8 seconds. When the flow is too fast for the steps a frame may take, it runs slower instead.\n// Knob 3: Scale. The size of the eddies a run starts from: the noise is filtered round wavenumber 5 at 0, a wavelength of 13 LEDs, round 8.7 at -1 (7 LEDs) and 2.9 at 1 (22 LEDs). At -1 a run lasts about 10 seconds; the big eddies at 1 carry so much energy that the step limit slows them, and a run lasts about 28. Turning it by more than 0.15 starts a fresh run at the new size.\n// Knob 4: Viscosity. The hyperviscosity that takes the enstrophy out at the bottom of its cascade, doubling with every fifth of the knob. At the opening 0.06 a filament two LEDs wide lasts about a tenth of a second and wider ones survive, so the vortices trail long spiral arms; at 1 it is 26 times stronger, filaments up to three LEDs wide dissolve as fast, and the vortices sit in smoother, emptier water.\n// Buttons: K1 tap starts a fresh run of small eddies.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, exp, sqrt, abs, cos, sin, PI, log2, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The panel is a periodic box 2 pi wide and 4 pi tall, one grid step 2 pi / 64\n// either way, so kx runs over the integers and ky over the half-integers.\n// Modes with |kx| or |ky| above 21 are dropped after every product\n// (Orszag's two-thirds rule).\nconst KXC = 21, KYC = 42, DX = (2 * PI) / W;\n// Flow time per panel second at Speed 2, and the Courant number each step\n// keeps to (with |u| + |v|). A frame takes at most two steps up to Speed 2\n// and three above it; when the flow is faster than that allows, it runs\n// slower instead.\nconst RATE = 7.5, CFL = 0.8;\n// Hyperviscosity nu (k / 21)^8: nu at Viscosity 0, doubling with every fifth\n// of the knob.\nconst NU = 12;\n// A run ends when the energy-weighted wavenumber has fallen to this share of\n// the one it started from (but not below 1, the box), or after this much\n// flow time.\nconst KEND = 0.28, RUN = 240;\n// Crossfade into a fresh field, panel seconds.\nconst FADE = 0.7;\n// Colour: the hue of strong warm vorticity at Hue 0; contour bands per unit\n// of the display scale and how deep they cut (reaching full depth above a\n// sixth of the scale); the brightness curve; the share of the largest |w| that\n// shows at full scale; and how far round the wheel the stream function tints.\nconst WARM = 0.09, BANDS = 4, BDEP = 0.4, GAM = 0.4, NORM = 0.7, TINT = 0.08, LUT = 1024;\n\n// ---- radix-2 FFT, in place on (re, im) at off, off + st, off + 2 st, ...\nfunction plan(n) {\n  const lg = log2(n), rev = new Uint16Array(n), c = new Float64Array(n >> 1), s = new Float64Array(n >> 1);\n  for (let i = 0; i \u003c n; i++) {\n    let r = 0;\n    for (let b = 0; b \u003c lg; b++) r |= ((i >> b) & 1) \u003c\u003c (lg - 1 - b);\n    rev[i] = r;\n  }\n  for (let i = 0; i \u003c n >> 1; i++) (c[i] = cos((2 * PI * i) / n)), (s[i] = sin((2 * PI * i) / n));\n  return { n, rev, c, s, br: new Float64Array(n), bi: new Float64Array(n) };\n}\nfunction fft1(P, re, im, off, st, sign) {\n  const { n, rev, c, s, br, bi } = P;\n  for (let i = 0; i \u003c n; i++) {\n    const j = off + rev[i] * st;\n    br[i] = re[j];\n    bi[i] = im[j];\n  }\n  for (let size = 2; size \u003c= n; size \u003c\u003c= 1) {\n    const half = size >> 1, step = n / size;\n    for (let a0 = 0; a0 \u003c n; a0 += size)\n      for (let k = 0, t = 0; k \u003c half; k++, t += step) {\n        const wr = c[t], wi = sign * s[t], a = a0 + k, b = a + half;\n        const xr = br[b] * wr - bi[b] * wi, xi = br[b] * wi + bi[b] * wr;\n        br[b] = br[a] - xr;\n        bi[b] = bi[a] - xi;\n        br[a] += xr;\n        bi[a] += xi;\n      }\n  }\n  for (let i = 0; i \u003c n; i++) (re[off + i * st] = br[i]), (im[off + i * st] = bi[i]);\n}\n// Only the 43 columns with |kx| \u003c= 21 can be non-zero, so the y transforms\n// run on those alone: after the x transforms going forward (sign -1), before\n// them going back (sign +1). Neither direction divides by N.\nconst COLS = [];\nfor (let x = 0; x \u003c W; x++) if ((x \u003c W / 2 ? x : W - x) \u003c= KXC) COLS.push(x);\nfunction fft2(S, re, im, sign) {\n  if (sign \u003c 0) for (let y = 0; y \u003c H; y++) fft1(S.px, re, im, y * W, 1, sign);\n  for (let t = 0; t \u003c COLS.length; t++) fft1(S.py, re, im, COLS[t], W, sign);\n  if (sign > 0) for (let y = 0; y \u003c H; y++) fft1(S.px, re, im, y * W, 1, sign);\n}\n\n// The vorticity equation dw/dt = -div(u w) for the spectrum (sr, si), into\n// (or, oi), dealiased. One inverse transform brings w and the stream function\n// psi (psi^ = -w^ / k^2) to the grid together, as w + i psi; the velocity\n// u = -dpsi/dy, v = dpsi/dx comes from fourth-order differences of psi; one\n// forward transform takes u w + i v w back, and the two products are pulled\n// apart with the conjugate mode. Leaves w and psi on the grid in br, bi\n// (and their largest sizes in wm, pm) and returns the largest |u| + |v|.\nfunction tendency(S, sr, si, or, oi) {\n  const { kx, ky, ik2, keep, neg, ar, ai, br: om, bi: ps } = S, nk = keep.length;\n  om.fill(0);\n  ps.fill(0);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], r = sr[i] / N, m = si[i] / N, q = ik2[i];\n    om[i] = r + q * m;\n    ps[i] = m - q * r;\n  }\n  fft2(S, om, ps, 1);\n  const c = 1 / (12 * DX);\n  let vmax = 0, wm = 0, pm = 0;\n  for (let y = 0; y \u003c H; y++) {\n    const o = y * W, u1 = ((y + 1) & (H - 1)) * W, d1 = ((y - 1) & (H - 1)) * W, u2 = ((y + 2) & (H - 1)) * W, d2 = ((y - 2) & (H - 1)) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const r1 = (x + 1) & (W - 1), l1 = (x - 1) & (W - 1), r2 = (x + 2) & (W - 1), l2 = (x - 2) & (W - 1);\n      const u = -c * (8 * (ps[u1 + x] - ps[d1 + x]) - (ps[u2 + x] - ps[d2 + x]));\n      const v = c * (8 * (ps[o + r1] - ps[o + l1]) - (ps[o + r2] - ps[o + l2]));\n      const w = om[o + x], p = ps[o + x];\n      ar[o + x] = u * w;\n      ai[o + x] = v * w;\n      const sp = abs(u) + abs(v);\n      if (sp > vmax) vmax = sp;\n      if (w > wm) wm = w;\n      else if (-w > wm) wm = -w;\n      if (p > pm) pm = p;\n      else if (-p > pm) pm = -p;\n    }\n  }\n  S.wm = wm;\n  S.pm = pm;\n  fft2(S, ar, ai, -1);\n  for (let t = 0; t \u003c nk; t++) {\n    const i = keep[t], j = neg[i], cr = ar[i], ci = ai[i], dr = ar[j], di = ai[j], a = kx[i], b = ky[i];\n    or[i] = 0.5 * (a * (ci - di) - b * (cr - dr));\n    oi[i] = -0.5 * (a * (cr + dr) + b * (ci + di));\n  }\n  return vmax;\n}\n\n// One third-order Adams-Bashforth step of length h with the viscous decay\n// folded in exactly (integrating factor). The two previous tendencies, each\n// already decayed to the present, wait in (p1r, p1i) and (p2r, p2i); the\n// coefficients come from integrating the quadratic through the last three\n// tendencies, so the step may change length. A fresh run starts with an\n// Euler step and a second-order one.\nfunction step(S, h) {\n  const { wr, wi, nr, ni, p1r, p1i, p2r, p2i, lin } = S;\n  S.vmax = tendency(S, wr, wi, nr, ni);\n  // The decay factors for each step length on the ladder are kept, a few\n  // at a time, so a step that comes back costs no exponentials.\n  const key = h * S.nu;\n  let E = S.Ec.get(key);\n  if (!E) {\n    if (S.Ec.size > 8) S.Ec.clear();\n    E = new Float64Array(N);\n    for (let i = 0; i \u003c N; i++) E[i] = exp(-key * lin[i]);\n    S.Ec.set(key, E);\n  }\n  const h1 = S.h1, h2 = S.h2;\n  let c0 = h, c1 = 0, c2 = 0;\n  if (h1 && h2) {\n    const a = (h * h * h) / 3, b = (h * h) / 2;\n    c0 = (a + (2 * h1 + h2) * b + h1 * (h1 + h2) * h) / (h1 * (h1 + h2));\n    c1 = -(a + (h1 + h2) * b) / (h1 * h2);\n    c2 = (a + h1 * b) / ((h1 + h2) * h2);\n  } else if (h1) (c0 = h * (1 + h / (2 * h1))), (c1 = -(h * h) / (2 * h1));\n  for (let t = 0, keep = S.keep, nk = keep.length; t \u003c nk; t++) {\n    const i = keep[t], e = E[i];\n    wr[i] = e * (wr[i] + c0 * nr[i] + c1 * p1r[i] + c2 * p2r[i]);\n    wi[i] = e * (wi[i] + c0 * ni[i] + c1 * p1i[i] + c2 * p2i[i]);\n    p2r[i] = e * p1r[i];\n    p2i[i] = e * p1i[i];\n    p1r[i] = e * nr[i];\n    p1i[i] = e * ni[i];\n  }\n  S.h2 = h1;\n  S.h1 = h;\n}\n\n// A fresh field: white noise filtered to a band round k0, scaled to an rms\n// vorticity of 1.\nfunction seed(S) {\n  const { wr, wi, k2, mask } = S, k0 = S.k0;\n  for (let i = 0; i \u003c N; i++) (wr[i] = Math.random() * 2 - 1), (wi[i] = 0);\n  fft2(S, wr, wi, -1);\n  let z = 0;\n  for (let i = 0; i \u003c N; i++) {\n    const q = k2[i] / (k0 * k0), a = mask[i] && k2[i] > 0 ? q * exp(-q) : 0;\n    wr[i] *= a;\n    wi[i] *= a;\n    z += wr[i] * wr[i] + wi[i] * wi[i];\n  }\n  const g = N / sqrt(z);\n  for (let i = 0; i \u003c N; i++) (wr[i] *= g), (wi[i] *= g);\n  S.age = 0;\n  S.h1 = S.h2 = 0;\n  S.sk = S.scale;\n  S.runs++;\n}\n\n// The energy-weighted mean wavenumber: sum k |w^|^2 / k^2 over sum |w^|^2 / k^2.\nfunction kmean(S) {\n  const { wr, wi, ik2, kk, keep } = S;\n  let e = 0, ek = 0;\n  for (let t = 0; t \u003c keep.length; t++) {\n    const i = keep[t], a = (wr[i] * wr[i] + wi[i] * wi[i]) * ik2[i];\n    e += a;\n    ek += a * kk[i];\n  }\n  return e > 0 ? ek / e : 0;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Four tables from |w| / scale to colour, two for each sign of spin, at two\n// hues the stream function blends between. Weak vorticity is deep crimson on\n// one side and indigo on the other, so it does not sink to brown and navy;\n// strong vorticity climbs to amber and to sky blue, and the cores to white.\nfunction palette(S) {\n  if (S.palHue === S.hue) return;\n  S.palHue = S.hue;\n  const c = [0, 0, 0];\n  for (let s = 0; s \u003c 4; s++) {\n    const T = S.pals[s], neg = s & 1, h0 = S.hue + (neg ? WARM + 0.47 : WARM) + ((s & 2 ? 1 : -1) * TINT) / 2;\n    for (let j = 0; j \u003c LUT; j++) {\n      const a = j / (LUT - 1), d = BDEP * cl(a / 0.15, 0, 1);\n      const b = pow(a, GAM) * (1 - d + d * cos(2 * PI * BANDS * a));\n      hsv(h0 + (neg ? 0.15 : -0.11) * (1 - a), 1 - 0.55 * a * a, 1, c, 0);\n      T[j * 3] = 255 * b * c[0];\n      T[j * 3 + 1] = 255 * b * c[1];\n      T[j * 3 + 2] = 255 * b * c[2];\n    }\n  }\n}\n\nexport function setup(params) {\n  const F = () => new Float64Array(N);\n  const S = (params.s = {\n    hue: 0, speed: 2, scale: 0, visc: 0.06, nu: NU, k0: 5, sk: 0, t: 0, age: 0, runs: 0, h1: 0, h2: 0, fade: 0, vmax: 0.4, vs: 0.4, km: 0,\n    px: plan(W), py: plan(H),\n    kx: F(), ky: F(), k2: F(), kk: F(), ik2: F(), lin: F(), mask: new Uint8Array(N), neg: new Int32Array(N),\n    wr: F(), wi: F(), nr: F(), ni: F(), p1r: F(), p1i: F(), p2r: F(), p2i: F(), ar: F(), ai: F(), br: F(), bi: F(),\n    wm: 0, pm: 0, Ec: new Map(),\n    pals: [0, 1, 2, 3].map(() => new Float32Array(LUT * 3)), palHue: -1,\n    old: new Uint8Array(N * 3), cur: new Uint8Array(N * 3), wsc: 0, psc: 0,\n  });\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, jx = x \u003c W / 2 ? x : x - W, jy = y \u003c H / 2 ? y : y - H;\n      S.kx[i] = jx;\n      S.ky[i] = jy / 2;\n      S.k2[i] = jx * jx + (jy * jy) / 4;\n      S.kk[i] = sqrt(S.k2[i]);\n      S.ik2[i] = S.k2[i] > 0 ? 1 / S.k2[i] : 0;\n      S.mask[i] = abs(jx) \u003c= KXC && abs(jy) \u003c= KYC ? 1 : 0;\n      S.neg[i] = ((H - y) % H) * W + ((W - x) % W);\n      const q = S.k2[i] / (KXC * KXC);\n      S.lin[i] = q * q * q * q;\n    }\n  // The modes inside the two-thirds cut, the only ones that are ever\n  // non-zero: the spectral loops run over these 3,655 alone.\n  const keep = [];\n  for (let i = 0; i \u003c N; i++) if (S.mask[i]) keep.push(i);\n  S.keep = Int32Array.from(keep);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.scale = cl(k[2], -1, 1);\n  S.visc = cl(k[3], 0, 1);\n  S.nu = NU * pow(2, 5 * S.visc);\n  S.k0 = 5 * pow(2, -0.8 * S.scale);\n  const ft = cl(dt || 0, 0, 0.1);\n  if (!S.runs) seed(S);\n  else if ((input.btnPressed && input.btnPressed[0]) || abs(S.scale - S.sk) > 0.15 || S.age > RUN || (S.age > 20 && (S.km = (S.km + 1) % 8) === 0 && kmean(S) \u003c max(1, KEND * S.k0))) {\n    S.old.set(S.cur);\n    S.fade = 1;\n    seed(S);\n  }\n  S.fade = max(0, S.fade - ft / FADE);\n  let adv = (ft * S.speed * RATE) / 2;\n  if (adv \u003c= 0) return;\n  // The speed limit holds the highest speed seen and lets it go slowly, so\n  // the step length changes smoothly from frame to frame.\n  S.vs = max(S.vmax, S.vs * 0.98);\n  const hmax = (CFL * DX) / max(1e-6, S.vs);\n  const n = min(S.speed > 2 ? 3 : 2, Math.ceil(adv / hmax));\n  // Steps come from a ladder 16 to an octave, so the decay factors are\n  // worked out again only when the step moves up or down a rung.\n  const h = pow(2, floor(16 * log2(min(adv / n, hmax))) / 16);\n  adv = n * h;\n  for (let j = 0; j \u003c n; j++) step(S, h);\n  S.t += adv;\n  S.age += adv;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.runs) return;\n  palette(S);\n  const { br: om, bi: ps, pals, cur, old } = S, m = S.wm, mp = S.pm;\n  // The scales follow the field slowly, so a merger does not flash.\n  S.wsc = S.wsc ? S.wsc + (m - S.wsc) * 0.05 : m;\n  S.psc = S.psc ? S.psc + (mp - S.psc) * 0.05 : mp;\n  const sc = (LUT - 1) / max(1e-6, S.wsc * NORM), tp = 0.5 / max(1e-9, S.psc);\n  const f = S.fade, g = 1 - f;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, w = om[i], j = min(LUT - 1, round(abs(w) * sc)) * 3, s = w > 0 ? 0 : 1, A = pals[s], B = pals[s + 2], o = i * 3;\n      const t = cl(0.5 + ps[i] * tp, 0, 1), u = 1 - t;\n      cur[o] = A[j] * u + B[j] * t;\n      cur[o + 1] = A[j + 1] * u + B[j + 1] * t;\n      cur[o + 2] = A[j + 2] * u + B[j + 2] * t;\n      if (f > 0) display.setPixel(x, y, cur[o] * g + old[o] * f, cur[o + 1] * g + old[o + 1] * f, cur[o + 2] * g + old[o + 2] * f);\n      else display.setPixel(x, y, cur[o], cur[o + 1], cur[o + 2]);\n    }\n}\n","motility-clusters":"// ===== Patternflow pattern =====\n// Title:   Motility Clusters\n// Family:  particle\n// Idea:    About 1,400 self-propelled discs swim round the periodic panel, each along its own slowly wandering heading and touching the others only to be pushed apart, and above a persistence threshold they jam into pale packed clusters edged by discs that face inward, coloured round the wheel by heading, while a faint gas of free swimmers runs between them and the clusters merge.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: motility-induced phase separation of active Brownian particles (Yaouen Fily and M. Cristina Marchetti, 2012; Michael Cates and Julien Tailleur, 2015), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pe=-1..1, Packing=0.55..0.72\n//\n// Knob 1: Hue. Turns the heading wheel and the tint of the packed discs together. At 0 a disc swimming down is red, down-left yellow, up-left green, up cyan, up-right blue and down-right magenta, so a cluster's edge, where the discs face inward, runs pink-red along its top, cyan along its bottom, violet on its left and yellow-green on its right; packed discs are pale lavender. At 0.25 the tint is pale cyan, at 0.5 pale lime and at 0.75 pale pink.\n// Knob 2: Speed. At 2 the discs swim 20 LEDs, ten diameters, a second, at 0.2 a tenth of that and at 3 half as fast again; the turning and the clustering keep pace. The head start before the first frame is always 4 seconds of swimming.\n// Knob 3: Pe. The Peclet number v0 / (sigma Dr), the distance in diameters a disc swims before its heading forgets itself, 40 times 8 to the knob. At -1 (Pe 5, a heading lasts half a second at Speed 2) the discs stay a gas of brief clumps, the largest holding a tenth of them; at -0.5 (Pe 14) two fifths; at 0 (Pe 40, four seconds) two thirds after ten seconds, with a third already in one cluster 2.5 s in; at 1 (Pe 320) four fifths.\n// Knob 4: Packing. The share of the panel the discs would cover laid flat: 0.55 at the start (1,434 discs), where clusters sit in a gas, to 0.72 (1,877 discs), where the packed phase fills most of the panel and the gas lives in dark bubbles. New discs drop in at random places and taken ones leave from random places.\n// Buttons: K1 tap scatters every disc into a fresh uniform gas, and the clusters gather again over the next few seconds.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, min, max, sqrt, round, PI, pow, exp } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Disc diameter in LEDs. The neighbour grid is 32 by 64 cells one diameter\n// wide, so two discs that overlap are in the same or neighbouring cells.\nconst SIG = 2, S2 = SIG * SIG, GX = 32, GY = 64, NC = GX * GY, CW = W / GX, LIST2 = (SIG + 0.25) ** 2;\n// Swim speed in LEDs a second at Speed 2 (ten diameters a second), the step,\n// and how many passes push overlapping pairs apart in each step.\nconst V0 = 20, HS = 1 / 80, SWEEPS = 6;\n// Most discs the Packing knob can ask for, room for the pair list, and the\n// head start: seconds of swimming run before the first frame, so the panel\n// opens on clusters already gathering out of the gas.\nconst NMAX = 1900, PMAX = NMAX * 8, PRE = 4;\n// Drawing: the squared radius of a disc's splash of light in LEDs, how pale\n// the packed discs' tint is, the light of a packed disc and of a lone one,\n// and where the heading wheel starts.\nconst KR = 2.2, TS = 0.25, LC = 0.92, L0 = 0.3, HUE0 = 0.25;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, pe: 40, phi: 0.55, n: 0, t: 0, acc: 0, pre: false,\n    x: new Float64Array(NMAX), y: new Float64Array(NMAX), c: new Float64Array(NMAX), s: new Float64Array(NMAX),\n    cr: new Float32Array(NMAX), ex: new Float32Array(NMAX), ey: new Float32Array(NMAX),\n    x2: new Float64Array(NMAX), y2: new Float64Array(NMAX), c2: new Float64Array(NMAX), s2: new Float64Array(NMAX),\n    cr2: new Float32Array(NMAX), ex2: new Float32Array(NMAX), ey2: new Float32Array(NMAX),\n    kn: new Float32Array(NMAX), kx: new Float32Array(NMAX), ky: new Float32Array(NMAX),\n    pl: new Int32Array(PMAX), m: 0, cell: new Int32Array(NMAX), cnt: new Int32Array(NC + 1), fill: new Int32Array(NC),\n    bw: new Float32Array(NP), br: new Float32Array(NP), bg: new Float32Array(NP), bb: new Float32Array(NP),\n  };\n}\n\n// A uniform gas: discs dropped anywhere, headings anywhere.\nfunction place(S, n) {\n  for (let i = S.n; i \u003c n; i++) {\n    S.x[i] = Math.random() * W;\n    S.y[i] = Math.random() * H;\n    const a = Math.random() * TAU;\n    S.c[i] = Math.cos(a);\n    S.s[i] = Math.sin(a);\n    S.cr[i] = S.ex[i] = S.ey[i] = 0;\n  }\n  S.n = n;\n}\n\n// Takes discs away at random until n are left. The arrays are in grid order,\n// so cutting the tail would empty the bottom of the panel.\nfunction drop(S, n) {\n  const { x, y, c, s, cr, ex, ey } = S;\n  while (S.n > n) {\n    const i = floor(Math.random() * S.n), j = --S.n;\n    x[i] = x[j];\n    y[i] = y[j];\n    c[i] = c[j];\n    s[i] = s[j];\n    cr[i] = cr[j];\n    ex[i] = ex[j];\n    ey[i] = ey[j];\n  }\n}\n\n// Sorts the discs by grid cell, moving every per-disc array along, so the\n// pushes below walk memory in order. cnt holds where each cell starts.\nfunction sort(S) {\n  const { cell, cnt, fill, n } = S;\n  const { x, y, c, s, cr, ex, ey } = S;\n  cnt.fill(0);\n  for (let i = 0; i \u003c n; i++) {\n    const k = floor(x[i] / CW) + GX * floor(y[i] / CW);\n    cell[i] = k;\n    cnt[k + 1]++;\n  }\n  for (let k = 0; k \u003c NC; k++) cnt[k + 1] += cnt[k];\n  fill.set(cnt.subarray(0, NC));\n  const X = S.x2, Y = S.y2, C = S.c2, Sn = S.s2, R = S.cr2, EX = S.ex2, EY = S.ey2;\n  for (let i = 0; i \u003c n; i++) {\n    const o = fill[cell[i]]++;\n    X[o] = x[i];\n    Y[o] = y[i];\n    C[o] = c[i];\n    Sn[o] = s[i];\n    R[o] = cr[i];\n    EX[o] = ex[i];\n    EY[o] = ey[i];\n  }\n  S.x2 = x, S.y2 = y, S.c2 = c, S.s2 = s, S.cr2 = cr, S.ex2 = ex, S.ey2 = ey;\n  S.x = X, S.y = Y, S.c = C, S.s = Sn, S.cr = R, S.ex = EX, S.ey = EY;\n}\n\n// One step of h seconds: every disc swims V0 h along its heading, the\n// heading turns by rotational diffusion dr, then overlapping pairs are pushed\n// apart along the line between them, half the overlap each, the overdamped\n// limit of a stiff short-range spring. Nothing attracts.\nfunction step(S, h, dr) {\n  swim(S, S.n, sqrt(6 * dr * h), V0 * h);\n  sort(S);\n  const m = (S.m = pushGrid(S.x, S.y, S.cnt, S.pl));\n  for (let sw = 1; sw \u003c SWEEPS; sw++) pushList(S.x, S.y, S.pl, m);\n  wrap(S.x, S.y, S.n);\n}\n\nfunction swim(S, n, amp, d) {\n  const { x, y, c, s } = S;\n  for (let i = 0; i \u003c n; i++) {\n    const xi = x[i] + d * c[i], yi = y[i] + d * s[i];\n    x[i] = xi \u003c 0 ? xi + W : xi >= W ? xi - W : xi;\n    y[i] = yi \u003c 0 ? yi + H : yi >= H ? yi - H : yi;\n    const e = amp * (2 * Math.random() - 1), ci = c[i], si = s[i], q = 1 - 0.5 * e * e;\n    c[i] = ci * q - si * e;\n    s[i] = si * q + ci * e;\n  }\n}\n\n// The first pass searches the grid and pushes. It also lists every pair\n// closer than SIG + 0.25, and the later passes push only those. Returns the\n// list's length.\nfunction pushGrid(x, y, cnt, pl) {\n  let m = 0;\n  for (let cy = 0; cy \u003c GY; cy++) {\n    const dn = (cy + 1 === GY ? 0 : cy + 1) * GX, r0 = cy * GX;\n    for (let cx = 0; cx \u003c GX; cx++) {\n      const k0 = r0 + cx, a0 = cnt[k0], a1 = cnt[k0 + 1];\n      if (a0 === a1) continue;\n      const xr = cx + 1 === GX ? 0 : cx + 1, xl = cx === 0 ? GX - 1 : cx - 1;\n      for (let q = 0; q \u003c 5; q++) {\n        const k = q === 0 ? k0 : q === 1 ? r0 + xr : q === 2 ? dn + xl : q === 3 ? dn + cx : dn + xr;\n        const b0 = cnt[k], b1 = cnt[k + 1];\n        for (let i = a0; i \u003c a1; i++)\n          for (let j = q === 0 ? i + 1 : b0; j \u003c b1; j++) {\n            const dx = near(x[j] - x[i], W), dy = near(y[j] - y[i], H), r2 = dx * dx + dy * dy;\n            if (r2 >= LIST2) continue;\n            if (m \u003c PMAX) (pl[m++] = i), (pl[m++] = j);\n            if (r2 \u003c S2 && r2 > 0) push(x, y, i, j, dx, dy, r2);\n          }\n      }\n    }\n  }\n  return m;\n}\n\nfunction pushList(x, y, pl, m) {\n  for (let p = 0; p \u003c m; p += 2) {\n    const i = pl[p], j = pl[p + 1];\n    const dx = near(x[j] - x[i], W), dy = near(y[j] - y[i], H), r2 = dx * dx + dy * dy;\n    if (r2 \u003c S2 && r2 > 0) push(x, y, i, j, dx, dy, r2);\n  }\n}\n\n// The shortest way round the periodic panel.\nconst near = (d, L) => (d > L / 2 ? d - L : d \u003c -L / 2 ? d + L : d);\n\nfunction push(x, y, i, j, dx, dy, r2) {\n  const r = sqrt(r2), f = (0.5 * (SIG - r)) / r;\n  x[i] -= f * dx;\n  y[i] -= f * dy;\n  x[j] += f * dx;\n  y[j] += f * dy;\n}\n\nfunction wrap(x, y, n) {\n  for (let i = 0; i \u003c n; i++) {\n    x[i] = x[i] \u003c 0 ? x[i] + W : x[i] >= W ? x[i] - W : x[i];\n    y[i] = y[i] \u003c 0 ? y[i] + H : y[i] >= H ? y[i] - H : y[i];\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.55];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.pe = 40 * pow(8, cl(k[2], -1, 1));\n  S.phi = cl(k[3], 0.55, 0.72);\n  if (input.btnPressed && input.btnPressed[0]) S.n = 0;\n  const want = min(NMAX, round((S.phi * NP) / (PI * S2 * 0.25)));\n  if (want > S.n) place(S, want);\n  else if (want \u003c S.n) drop(S, want);\n  // Pe = V0 / (SIG Dr), the persistence length in diameters.\n  const dr = V0 / (SIG * S.pe);\n  let run = cl(dt || 0, 0, 0.1) * (S.speed / 2);\n  if (!S.pre) {\n    S.pre = true;\n    run += PRE;\n  }\n  S.acc += run;\n  let ran = 0;\n  while (S.acc >= HS) {\n    step(S, HS, dr);\n    S.acc -= HS;\n    S.t += HS;\n    ran += HS;\n  }\n  if (ran > 0) touch(S, 1 - exp(-ran * 8));\n}\n\n// Each disc's neighbours from the last step's pair list: how many touch it\n// and the sum of the directions to them, eased so the light does not\n// flicker with every knock. A disc packed all round has many neighbours and\n// a short sum; a disc at the edge of a cluster has them all on one side.\nfunction touch(S, k) {\n  const { x, y, pl, m, kn, kx, ky, cr, ex, ey, n } = S;\n  kn.fill(0, 0, n);\n  kx.fill(0, 0, n);\n  ky.fill(0, 0, n);\n  for (let p = 0; p \u003c m; p += 2) {\n    const i = pl[p], j = pl[p + 1];\n    const dx = near(x[j] - x[i], W), dy = near(y[j] - y[i], H), r = sqrt(dx * dx + dy * dy) + 1e-9;\n    kn[i]++;\n    kn[j]++;\n    kx[i] += dx / r;\n    ky[i] += dy / r;\n    kx[j] -= dx / r;\n    ky[j] -= dy / r;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    cr[i] += (kn[i] - cr[i]) * k;\n    ex[i] += (kx[i] - ex[i]) * k;\n    ey[i] += (ky[i] - ey[i]) * k;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { x, y, c, s, cr, ex, ey, bw, br, bg, bb, n } = S;\n  bw.fill(0);\n  br.fill(0);\n  bg.fill(0);\n  bb.fill(0);\n  // The colour wheel by heading: each channel is full for discs swimming\n  // within 60 degrees of its own direction and dark beyond 120, a third of a\n  // turn apart. Discs packed all round fade to one pale tint.\n  const h0 = (S.hue + HUE0) * TAU;\n  const ar = Math.cos(h0), as = Math.sin(h0), ag = Math.cos(h0 + TAU / 3), gs = Math.sin(h0 + TAU / 3), ab = Math.cos(h0 - TAU / 3), bs = Math.sin(h0 - TAU / 3);\n  const tr = 1 - TS + TS * cl(0.5 + ar, 0, 1), tg = 1 - TS + TS * cl(0.5 + ag, 0, 1), tb = 1 - TS + TS * cl(0.5 + ab, 0, 1);\n  for (let i = 0; i \u003c n; i++) {\n    const k = cr[i], e = sqrt(ex[i] * ex[i] + ey[i] * ey[i]) / max(k, 1), ci = c[i], si = s[i];\n    const lum = L0 + (LC - L0) * cl((k - 0.5) / 3.5, 0, 1), u = cl((k - 3) / 2, 0, 1) * cl(1 - 1.6 * e, 0, 1), v = 1 - u;\n    const r = lum * (v * cl(0.5 + ci * ar + si * as, 0, 1) + u * tr);\n    const g = lum * (v * cl(0.5 + ci * ag + si * gs, 0, 1) + u * tg);\n    const b = lum * (v * cl(0.5 + ci * ab + si * bs, 0, 1) + u * tb);\n    const px = x[i], py = y[i], ix = floor(px), iy = floor(py);\n    for (let yy = iy - 1; yy \u003c= iy + 1; yy++)\n      for (let xx = ix - 1; xx \u003c= ix + 1; xx++) {\n        const dx = xx + 0.5 - px, dy = yy + 0.5 - py, w = 1 - (dx * dx + dy * dy) / KR;\n        if (w \u003c= 0) continue;\n        const o = ((yy + H) & 127) * W + ((xx + W) & 63);\n        bw[o] += w;\n        br[o] += w * r;\n        bg[o] += w * g;\n        bb[o] += w * b;\n      }\n  }\n  for (let p = 0, yy = 0; yy \u003c H; yy++)\n    for (let xx = 0; xx \u003c W; xx++, p++) {\n      const w = bw[p], f = w > 1 ? 1 / w : 1;\n      display.setPixel(xx, yy, q4(br[p] * f), q4(bg[p] * f), q4(bb[p] * f));\n    }\n}\n\n// Channels in steps of 4 of 255, from 0..1.\nconst q4 = (v) => ((v * 63 + 0.5) | 0) \u003c\u003c 2;\n\n","murmuration":"// ===== Patternflow pattern =====\n// Title:   Murmuration\n// Family:  halloween\n// Idea:    Over a black treeline at sundown a murmuration of crows swirls and folds against a sky running from violet to hot orange, then every bird sweeps to its place in a giant skull whose eye sockets, nose and the gaps between its teeth let the sky through, the skull holds and looks about with glinting eyes and a chattering jaw, and bursts back into the flock.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Flock=0..1, Shape=0..1\n//\n// Knob 1: Hue. Turns the sunset round the wheel. At 0 violet overhead through hot pink and orange to a yellow glow round a low sun; at 0.25 brick red overhead through gold to lime; at 0.5 green to cyan; at 0.75 sky blue through violet to pink. The crows stay black, the sun cream and the glints in the eyes toxic green.\n// Knob 2: Speed. At 2 the flock swirls 1.4 s before the first call, the birds take 1.9 s to sweep into the shape, the shape holds 1.5 s, the burst takes 1.6 s, and the flock swirls 5 s before the next call, a call every 10 s. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Flock. How many crows: 500 at 0, 750 at 0.25, 1,000 at 0.5 and 1,500 at 1. A small flock is a cloud of specks that darkens to a band when it turns edge on, and fills the skull with each bird's wings spread over five LEDs; a large one folds into black sheets and holds one LED and a bit more of the skull per bird, 1.7 at 1,500.\n// Knob 4: Shape. What the flock forms. Up to 0.25 a skull 54 LEDs wide and 72 tall whose jaw drops twice and whose eyes glint and look left and right; to 0.5 a bat 62 LEDs across that beats its wings with glinting eyes; to 0.75 a crescent moon 54 LEDs tall that rocks; above 0.75 the three in turn.\n// Buttons: K1 tap calls the flock into its shape at once.\n\nconst W = 64, H = 128, N = W * H, MAXB = 1500;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Seconds at Speed 2: the first swirl, later swirls, the sweep into the\n// shape, the hold and the burst.\nconst T0 = 1.4, TS = 5, TG = 1.9, TH = 1.5, TB = 1.6;\n\n// The shapes, tested at LED centres; u is across from the middle column.\nconst SKULL = 0, BAT = 1, MOON = 2;\nconst CENTRE = [[32, 57], [32, 50], [32, 55]];\nfunction skull(u, y) {\n  const au = abs(u);\n  let inside = (u / 27) ** 2 + ((y - 47) / 26) ** 2 \u003c 1 && y \u003c 66;\n  // Cheekbones, then the upper jaw, then the chin.\n  if (y >= 54 && y \u003c 80 && au \u003c 23.5 - max(0, y - 66) * 0.4) inside = true;\n  if (y >= 80 && y \u003c 93 && au \u003c 16 - max(0, y - 87) * 1.1) inside = true;\n  if (!inside) return false;\n  // Eye sockets, flattened under the brow and sloping to the nose.\n  const du = au - 11.5;\n  if ((du / 8.5) ** 2 + ((y - 57.5) / 7.5) ** 2 \u003c 1 && y > 50 + 0.18 * (au - 3)) return false;\n  // The nose, an upturned heart.\n  if (y >= 66 && y \u003c 75 && au \u003c (y - 66) * 0.45 + 0.6 && !(y > 72 && au \u003c 0.6)) return false;\n  // The mouth line and the gaps between the teeth.\n  if (y >= 82 && y \u003c 83 && au \u003c 14) return false;\n  if (y >= 78 && y \u003c 87 && au \u003c 12 && floor(u + 12) % 4 === 0) return false;\n  return true;\n}\nfunction bat(u, y) {\n  const s = abs(u);\n  if ((u / 5) ** 2 + ((y - 54) / 9.5) ** 2 \u003c 1) return true;\n  if ((u / 5.2) ** 2 + ((y - 44) / 5) ** 2 \u003c 1) return true;\n  if (y >= 35 && y \u003c 42 && abs(s - 3) \u003c (y - 35) * 0.35) return true;\n  if (s \u003c 4 || s > 31) return false;\n  // The arm rises from the shoulder to the wing tip; the trailing edge hangs\n  // from four finger tips in scallops.\n  const top = s \u003c 26 ? 48 - 13 * sin((((s - 4) / 22) * PI) / 2) : 35 + (s - 26) * 0.7;\n  const f = (s - 4) / 9, k = min(2, floor(f)), fr = f - k;\n  const tips = [66, 59, 51, 40];\n  const bottom = tips[k] + (tips[k + 1] - tips[k]) * fr - 5.5 * sin(PI * fr);\n  return y > top && y \u003c bottom;\n}\nfunction moon(u, y) {\n  return u * u + (y - 55) ** 2 \u003c 27 * 27 && (u - 11) ** 2 + (y - 46) ** 2 > 23 * 23;\n}\nconst SHAPES = [skull, bat, moon];\n\n// Ordered-dither rank of an LED, so the first n cells of a shape taken in\n// this order are spread evenly over it.\nfunction bayer(x, y) {\n  let v = 0;\n  for (let b = 0; b \u003c 3; b++) {\n    const xb = (x >> b) & 1, yb = (y >> b) & 1;\n    v |= (((xb ^ yb) \u003c\u003c 1) | yb) \u003c\u003c (2 * (2 - b));\n  }\n  return v;\n}\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: -1, speed: 2, flock: 0, shapeK: 0.06, nb: 500,\n    t: 0, ph: \"swirl\", pt: 0, tswirl: T0, shape: SKULL, turn: 0,\n    // Per bird: place in the flock's sheet, depth, start delay, arc, burst\n    // direction and speed, flap phase.\n    a: new Float32Array(MAXB), b: new Float32Array(MAXB), w: new Float32Array(MAXB),\n    dl: new Float32Array(MAXB), arc: new Float32Array(MAXB), bd: new Float32Array(MAXB), bv: new Float32Array(MAXB),\n    // Slot: where it sits in the shape, and the LED it was cut from.\n    tx: new Float32Array(MAXB), ty: new Float32Array(MAXB), tc: new Int32Array(MAXB).fill(-1),\n    px: new Float32Array(MAXB), py: new Float32Array(MAXB), c: new Float32Array(MAXB),\n    order: new Int32Array(MAXB), key: new Float32Array(MAXB),\n    masks: SHAPES.map((fn) => {\n      const m = new Uint8Array(N);\n      for (let y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++) m[y * W + x] = fn(x + 0.5 - 32, y + 0.5) ? 1 : 0;\n      return m;\n    }),\n    ranked: [], disc: [], dark: new Float32Array(N), bg: new Float32Array(N * 3), glint: 0, look: 0,\n  });\n  for (let i = 0; i \u003c MAXB; i++) {\n    const r = sqrt(Math.random()), th = Math.random() * 2 * PI;\n    S.a[i] = r * cos(th);\n    S.b[i] = r * sin(th);\n    S.w[i] = (Math.random() - 0.5) * 6;\n    S.dl[i] = Math.random();\n    S.arc[i] = (Math.random() - 0.5) * 2;\n    S.bd[i] = (Math.random() - 0.5) * 1.6;\n    S.bv[i] = 30 + Math.random() * 45;\n  }\n  // Cells of each shape in dither order.\n  S.ranked = S.masks.map((m) => {\n    const cells = [];\n    for (let p = 0; p \u003c N; p++) if (m[p]) cells.push(p);\n    const r = cells.map((p) => bayer(p % W & 7, floor(p / W) & 7) + hash(p) * 0.99);\n    return cells.map((p, i) => [r[i], p]).sort((x, y) => x[0] - y[0]).map((e) => e[1]);\n  });\n  scenery(S);\n}\n\n// Where bird i flies in the flock at time t: a sheet of birds, bent by a\n// travelling fold, turned in depth and seen from the side, so it thins out\n// when it faces us and darkens to a band when it turns edge on.\nfunction sheet(S, i, t, out) {\n  const al = 0.21 * t, ca = cos(al), sa = sin(al);\n  let a = S.a[i] * ca - S.b[i] * sa;\n  const b = S.a[i] * sa + S.b[i] * ca;\n  a += 0.16 * sin(3.1 * b - 1.9 * t);\n  const X = a * (24 + 5 * sin(0.53 * t)), Y = b * (18 + 5 * sin(0.47 * t + 2));\n  const Z = 11 * sin(2.3 * a + 1.4 * t + b) + S.w[i];\n  const th = 1.15 * sin(0.37 * t) + 0.35 * sin(0.93 * t + 1), ph = 0.8 * sin(0.29 * t + 1);\n  const x3 = X * cos(th) + Z * sin(th), z3 = Z * cos(th) - X * sin(th);\n  out[0] = 33 + 9 * sin(0.5 * t + 0.6) + x3;\n  out[1] = 47 + 17 * sin(0.37 * t + 0.5) + Y * cos(ph) + z3 * sin(ph);\n}\n\n// Hand each bird a slot: birds and slots both taken round in angle, so the\n// flock pours into the shape from the side it is on.\nfunction call(S) {\n  const n = S.nb, sh = S.shape, cells = S.ranked[sh], [cx, cy] = CENTRE[sh], o = [0, 0];\n  const slots = [];\n  for (let k = 0; k \u003c n; k++) {\n    const p = cells[k % cells.length], x = (p % W) + 0.5, y = floor(p / W) + 0.5;\n    slots.push([atan2(y - cy, x - cx), x, y, p]);\n  }\n  slots.sort((p, q) => p[0] - q[0]);\n  let mx = 0, my = 0;\n  for (let i = 0; i \u003c n; i++) sheet(S, i, S.t, o), (S.px[i] = o[0]), (S.py[i] = o[1]), (mx += o[0]), (my += o[1]);\n  (mx /= n), (my /= n);\n  const ord = Array.from({ length: n }, (_, i) => i);\n  for (let i = 0; i \u003c n; i++) S.key[i] = atan2(S.py[i] - my, S.px[i] - mx);\n  ord.sort((p, q) => S.key[p] - S.key[q]);\n  for (let k = 0; k \u003c n; k++) {\n    const i = ord[k], s = slots[k];\n    (S.tx[i] = s[1]), (S.ty[i] = s[2]), (S.tc[i] = s[3]);\n  }\n  for (let i = n; i \u003c MAXB; i++) S.tc[i] = -1;\n  // Each bird's wings spread to cover the LEDs between slots.\n  const rho = 0.9 * sqrt(cells.length / n) + 0.5;\n  S.disc = [];\n  const R = Math.ceil(rho);\n  for (let dy = -R; dy \u003c= R; dy++) for (let dx = -R; dx \u003c= R; dx++) if (dx * dx + dy * dy \u003c= rho * rho) S.disc.push(dx, dy);\n}\n\n// How the shape moves while it holds: the skull's jaw drops twice, the bat\n// beats its wings, the moon rocks.\nfunction holdMove(S, x, y, out) {\n  const h = S.ph === \"hold\" ? S.pt : 0;\n  (out[0] = x), (out[1] = y);\n  if (S.shape === SKULL) {\n    if (y > 82) out[1] += 3.5 * abs(sin(PI * cl((h - 0.35) / 0.4, 0, 2)));\n  } else if (S.shape === BAT) {\n    const s = abs(x - 32);\n    out[1] += (s > 4 ? ((s - 4) / 27) ** 1.3 : 0) * 9 * sin(h * 2 * PI * 1.4);\n  } else {\n    const an = 0.16 * sin(h * 2 * PI * 0.8), dx = x - 32, dy = y - 55;\n    out[0] = 32 + dx * cos(an) - dy * sin(an);\n    out[1] = 55 + dx * sin(an) + dy * cos(an);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) (S.hue = hue), scenery(S);\n  S.speed = cl(k[1], 0.2, 3);\n  S.flock = cl(k[2], 0, 1);\n  S.shapeK = cl(k[3], 0, 1);\n  S.nb = round(500 + 1000 * S.flock);\n  const d = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += d;\n  S.pt += d;\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (S.ph === \"swirl\" && (S.pt > S.tswirl || tap)) {\n    const q = S.shapeK;\n    S.shape = q \u003c 0.25 ? SKULL : q \u003c 0.5 ? BAT : q \u003c 0.75 ? MOON : S.turn++ % 3;\n    call(S);\n    (S.ph = \"gather\"), (S.pt = 0);\n  } else if (S.ph === \"gather\" && S.pt > TG) (S.ph = \"hold\"), (S.pt = 0);\n  else if (S.ph === \"hold\" && S.pt > TH) (S.ph = \"burst\"), (S.pt = 0);\n  else if (S.ph === \"burst\" && S.pt > TB) (S.ph = \"swirl\"), (S.pt = 0), (S.tswirl = TS);\n  // Eye glints and where they look, for the skull and the bat.\n  const h = S.ph === \"hold\" ? S.pt : -1;\n  S.glint = h \u003c 0 ? 0 : sm(h / 0.25) * sm((TH - h) / 0.3);\n  S.look = h \u003c 0 ? 0 : 2.5 * sin(h * 2 * PI * 0.75);\n  // Bird positions and how close each is to its slot.\n  const o = [0, 0], m = [0, 0], g = S.pt, ph = S.ph;\n  for (let i = 0; i \u003c S.nb; i++) {\n    sheet(S, i, S.t, o);\n    let x = o[0], y = o[1], c = 0;\n    if (S.tc[i] >= 0 && ph !== \"swirl\") {\n      holdMove(S, S.tx[i], S.ty[i], m);\n      if (ph === \"gather\") {\n        const e = sm(cl((g - 0.6 * S.dl[i]) / (TG - 0.65), 0, 1)), dx = m[0] - x, dy = m[1] - y;\n        // A swoop off the straight line, widest halfway.\n        const sw = sin(PI * e) * S.arc[i] * 0.35;\n        x += dx * e - dy * sw;\n        y += dy * e + dx * sw;\n        c = sm((e - 0.88) / 0.12);\n      } else if (ph === \"hold\") (x = m[0]), (y = m[1]), (c = 1);\n      else {\n        // Out from the middle of the shape, slowing, then back into the sheet.\n        const [cx, cy] = CENTRE[S.shape], an = atan2(m[1] - cy, m[0] - cx) + S.bd[i];\n        const r = (S.bv[i] * (1 - exp(-g * 3.2))) / 3.2, f = sm((g - 0.35) / (TB - 0.35));\n        x = (m[0] + cos(an) * r) * (1 - f) + x * f;\n        y = (m[1] + sin(an) * r - 6 * g * g) * (1 - f) + y * f;\n        c = 1 - sm(g / 0.12);\n      }\n    }\n    (S.px[i] = x), (S.py[i] = y), (S.c[i] = c);\n  }\n}\n\n// The sky, the sun on the horizon, the treeline and the field, redrawn when\n// the hue turns.\nconst STOPS = [[0, 0.77, 0.66, 0.8], [34, 0.88, 0.62, 0.92], [62, 0.98, 0.7, 1], [86, 1.06, 0.8, 1], [102, 1.12, 0.55, 1]];\nfunction treeTop(x) {\n  return 101 + 2 * sin(x / 6.3 + 1) + 1.5 * sin(x / 2.7) - 5 * max(0, sin(x / 4.1 + 2)) ** 6 - 3 * max(0, sin(x / 2.2)) ** 8;\n}\n// A dead tree on each side: trunk and branches as segments [x0, y0, x1, y1, width].\nconst TREES = [\n  [5, 104, 7, 66, 2.2], [7, 66, 4, 56, 1.2], [6.5, 76, 14, 66, 1.2], [14, 66, 19, 64, 0.8], [5.5, 84, 0, 76, 1.2], [6, 70, 9, 58, 0.9],\n  [58, 104, 57, 80, 1.8], [57, 80, 61, 72, 1], [57, 88, 50, 80, 1], [50, 80, 47, 81, 0.7], [57.5, 84, 64, 82, 0.8],\n];\nfunction scenery(S) {\n  const bg = S.bg, c = [0, 0, 0], hu = S.hue \u003c 0 ? 0 : S.hue;\n  for (let y = 0; y \u003c H; y++) {\n    let k = 0;\n    while (k \u003c STOPS.length - 2 && y > STOPS[k + 1][0]) k++;\n    const A = STOPS[k], B = STOPS[k + 1], f = cl((y - A[0]) / (B[0] - A[0]), 0, 1);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      hsv(A[1] + (B[1] - A[1]) * f + hu, A[2] + (B[2] - A[2]) * f, A[3] + (B[3] - A[3]) * f, c, 0);\n      // The sun, low and half sunk, with two steps of glow round it.\n      const r = sqrt((x + 0.5 - 40) ** 2 + (y + 0.5 - 104) ** 2);\n      const sun = r \u003c 12 ? 1 : r \u003c 15 ? 0.55 : r \u003c 19 ? 0.25 : 0;\n      if (sun) for (let j = 0; j \u003c 3; j++) c[j] += (255 * [1, 0.95, 0.75][j] - c[j]) * sun;\n      let dark = y >= treeTop(x);\n      for (const [x0, y0, x1, y1, w] of TREES) {\n        const vx = x1 - x0, vy = y1 - y0, t = cl(((x + 0.5 - x0) * vx + (y + 0.5 - y0) * vy) / (vx * vx + vy * vy), 0, 1);\n        if ((x + 0.5 - x0 - vx * t) ** 2 + (y + 0.5 - y0 - vy * t) ** 2 \u003c (w * (1 - 0.3 * t)) ** 2) dark = true;\n      }\n      if (dark) {\n        // The field below the trees, a dark plum with furrows.\n        const fy = y - 108, fu = fy > 0 ? (x - 32) / (fy + 6) : 0;\n        const v = fy > 0 ? (abs(fu * 3 - round(fu * 3)) \u003c 0.12 ? 0.2 : 0.14) * min(1, fy / 10) : 0;\n        hsv(0.8 + hu, 0.6, v, c, 0);\n      }\n      for (let j = 0; j \u003c 3; j++) bg[p * 3 + j] = c[j];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const D = S.dark, bg = S.bg, disc = S.disc;\n  D.fill(0);\n  for (let i = 0; i \u003c S.nb; i++) {\n    const x = S.px[i], y = S.py[i], c = S.c[i];\n    const xi = floor(x), yi = floor(y);\n    if (c \u003c 1 && xi >= 0 && xi \u003c W && yi >= 0 && yi \u003c H) {\n      // A banking wave runs through the flock: where it passes, the birds\n      // show their spread wings and the cloud darkens in a moving band.\n      const bank = sin(2.4 * S.a[i] + 1.3 * S.b[i] - 2.6 * S.t), wing = bank > 0.55 ? 0.75 * (1 - c) : 0;\n      D[yi * W + xi] += (0.62 + 0.3 * bank * bank) * (1 - c);\n      if (wing && xi + 1 \u003c W) D[yi * W + xi + 1] += wing;\n    }\n    if (c > 0) {\n      // Wings spread over the slot's share of the shape, cut to the shape so\n      // the holes stay sharp.\n      const m = S.masks[S.shape], tc = S.tc[i], tx = tc % W, ty = floor(tc / W);\n      for (let j = 0; j \u003c disc.length; j += 2) {\n        const dx = disc[j], dy = disc[j + 1], X = xi + dx, Y = yi + dy, sx = tx + dx, sy = ty + dy;\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H || sx \u003c 0 || sx >= W || sy \u003c 0 || sy >= H || !m[sy * W + sx]) continue;\n        D[Y * W + X] += c;\n      }\n    }\n  }\n  // Glints: two toxic green points in the skull's sockets or the bat's eyes.\n  const gl = S.glint, eyes = gl > 0 && S.shape !== MOON ? (S.shape === SKULL ? [[20.5 + S.look, 58], [43.5 + S.look, 58]] : [[30 + S.look * 0.3, 44], [34 + S.look * 0.3, 44]]) : [];\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, k = 1 - min(1, D[p]);\n      let r = bg[p * 3] * k, g = bg[p * 3 + 1] * k, b = bg[p * 3 + 2] * k;\n      for (const [ex, ey] of eyes) {\n        const q = abs(x + 0.5 - ex) + abs(y + 0.5 - ey), a = gl * (q \u003c 1.1 ? 1 : q \u003c 2.1 ? 0.75 : q \u003c 3.1 ? 0.3 : 0);\n        if (a) (r += (150 + 105 * (q \u003c 1.1) - r) * a), (g += (255 - g) * a), (b += (60 + 170 * (q \u003c 1.1) - b) * a);\n      }\n      // Channels in steps of 4 of 255: too fine to see, and a frame packs smaller.\n      display.setPixel(x, y, min(255, round(r / 4) * 4), min(255, round(g / 4) * 4), min(255, round(b / 4) * 4));\n    }\n}\n","old-well":"// ===== Patternflow pattern =====\n// Title:   Old Well\n// Family:  halloween\n// Idea:    A cut-away stone well under the moon lowers its bucket to the black water, which glows sickly green as two pale eyes open beneath and a pale hand yanks the bucket under, the rope whipping and the windlass spinning, until it is wound back up brimming, sometimes with the hand still on its rim.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Moon=0..1, Fog=0..1\n//\n// Knob 1: Hue. The colour of the glow in the water, of the light it throws up the shaft and of what comes up in the bucket: sickly green at 0, cyan at 0.25, violet at 0.5, orange at 0.75. The sky, the stones and the moonlight stay as they are.\n// Knob 2: Speed. At 2 the bucket goes down at 18 LEDs a second and is wound up at 26, and one round takes about 12.5 s: down 3.6 s, the water and the hand 3.8 s, a 0.5 s calm, up 3.8 s and 0.9 s hanging at the top. At 0.2 everything is ten times slower, at 3 half as fast again. The first round starts with the bucket already low, so it touches the water 0.5 s in and is pulled under at 1.8 s.\n// Knob 3: Moon. Where the moon stands. At 0 high on the left: its light falls into the shaft slanting right and thins all the way down to the water. At 0.25 it falls straight; at 0.5 the moon peeks over the ridge and the light leans left; at 1 it hangs low on the right and lights only the upper left of the shaft.\n// Knob 4: Fog. A mist over the water, added as light, moonlit and tinted by the glow. At 0 none; at 0.06 a thin layer over the water; at 0.5 it fills the bottom half of the shaft; at 1 it rises 70 rows, to the mouth of the well.\n// Buttons: K1 tap lets go of the crank while the bucket is going down or hanging at the top: it falls to the water at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The shaft's inside runs from column SX0 to SX1; its stone walls, seen cut\n// through, are the eight columns either side, and earth lies beyond them.\nconst SX0 = 13, SX1 = 50;\n// The parapet's top, the ground and the water.\nconst PY = 32, GY = 40, WS = 104;\n// The little roof: its ridge and its eaves.\nconst AY = 5, EY = 15;\n// The windlass wheel, seen end on, and the column the rope hangs down.\nconst CX = 26, CY = 22, RX = 31;\n// The bucket's rim at the top and floating on the water.\nconst TOPB = 33, BOTB = 97;\n// Seconds into the event at Speed 2: the glow is up, the hand has risen, it\n// has a grip, the yank, the glow starts to fade, and it is all over.\nconst E_GLOW = 0.35, E_HAND0 = 0.5, E_HAND1 = 1.0, E_GRIP = 1.15, E_YANK = 1.3, E_FADE = 2.5, E_END = 3.8;\n// Kinds of LED in the still picture.\nconst SKY = 0, ROOF = 1, GABLE = 2, WOOD = 3, BACK = 4, SECT = 5, SOIL = 6, GRASS = 7, WATER = 8;\nconst MOONC = [175, 185, 225], TINT = [0.95, 0.9, 1.12];\n// The bucket's iron hoops, its rim and its two shades of stave.\nconst HOOP = [70, 70, 86], RIM = [214, 150, 84], STAVE = [[160, 98, 48], [186, 116, 58]];\n// The glow's light, falling off up the shaft from the water.\nconst UP = new Float32Array(128);\nfor (let i = 0; i \u003c 128; i++) UP[i] = exp(-i / 16);\n// Light round a point, by squared distance in LEDs.\nconst RAD = new Float32Array(4096);\nfor (let i = 0; i \u003c 4096; i++) RAD[i] = exp(-sqrt(i) / 7);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, moon: -1, fog: 0.06, s: 0.3,\n    ph: \"lower\", e: 0, by: 88, v: 0, cyc: 0, cling: false,\n    th: 0, ex: 0, sv: 0, wa: 0, wp: 0,\n    hand: { on: false, x: 22, y: 140, c: 0, v: 0, fall: false },\n    eo: 0, g: 0, cg: 0,\n    bits: [], bubbles: [], ripples: [], dripT: 0, bubT: 0,\n    kind: new Uint8Array(N), alb: new Float32Array(N), bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    gc: [0, 0, 0], off: new Float32Array(W),\n  };\n  geometry(params.s);\n}\n\n// The still shapes: roof, posts, walls, earth and water, and how much light\n// each stone gives back.\nfunction geometry(S) {\n  const { kind, alb } = S;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, ry = AY + ((EY - AY) * abs(x + 0.5 - 32)) / 26;\n      let k = SKY, a = 0;\n      if (x >= 6 && x \u003c= 57 && y >= ry && y \u003c ry + 3) (k = ROOF), (a = y \u003c ry + 1 ? 1 : (x + (floor(y - ry) & 1) * 2) % 4 === 0 ? 0.45 : 0.7);\n      else if (x >= 9 && x \u003c= 54 && y >= ry + 3 && y \u003c= EY) (k = GABLE), (a = x % 4 === 0 ? 0.4 : 1);\n      else if ((x >= 7 && x \u003c= 56 && (y === EY + 1 || y === EY + 2)) || ((x === 9 || x === 10 || x === 53 || x === 54) && y > EY && y \u003c PY - 1) || (x > 10 && x \u003c 53 && (y === 21 || y === 22)))\n        (k = WOOD), (a = x === 9 || x === 53 || y === EY + 1 || y === 21 ? 1.3 : 1);\n      else if ((y === PY - 1 && ((x >= 4 && x \u003c= 13) || (x >= 50 && x \u003c= 59))) || (y >= PY && ((x >= 5 && x \u003c SX0) || (x > SX1 && x \u003c= 58)))) {\n        // Cut stone: the same courses as the wall behind, one joint per course.\n        k = SECT;\n        const c = floor((y - PY + 6) / 6), r = (y - PY + 6) % 6, side = x \u003c 32 ? 0 : 1, j = (x - (side ? 51 : 5) + (c % 2) * 4) % 8;\n        a = y === PY - 1 ? 1.5 : r === 5 || j === 7 ? 0.3 : 0.78 + 0.22 * floor(hash(c * 31 + side * 7 + (j > 3 ? 1 : 0)) * 3) / 2;\n      } else if (y >= PY && x >= SX0 && x \u003c= SX1) {\n        if (y >= WS) k = WATER;\n        else {\n          // The back wall, in courses six rows high with staggered joints.\n          k = BACK;\n          const c = floor((y - PY) / 6), r = (y - PY) % 6, w = 7 + (c % 3), xx = x - SX0 + (c % 2) * 4 + floor(hash(c * 7 + 1) * 3), si = floor(xx / w);\n          a = r === 5 || xx % w === w - 1 ? 0.3 : 0.5 + 0.14 * floor(hash(c * 131 + si * 17) * 4) + (r === 0 ? 0.1 : 0) - (hash(p) \u003c 0.12 ? 0.12 : 0);\n        }\n      } else if (y > GY) (k = SOIL), (a = hash(p * 3 + 1) \u003c 0.05 ? 1.6 : 1);\n      else if (y >= GY - 2 && (y === GY || hash(x * 5 + y) \u003c 0.45 + (y - GY) * 0.2)) (k = GRASS), (a = 1);\n      kind[p] = k;\n      alb[p] = a;\n    }\n}\n\n// The beam of moonlight in the shaft at (x, y): 0 in the shadow of the lip,\n// 1 inside, with a soft edge.\nfunction beam(s, x, y) {\n  const d = y - PY, L = SX0 + max(0, s) * d, R = SX1 + 1 + min(0, s) * d;\n  return cl(min(x + 0.5 - L, R - x - 0.5) / 1.5 + 0.5, 0, 1);\n}\n\n// The still picture for one place of the moon: sky, moon, roof, the lit and\n// shaded stones, the dust in the moonbeam and the dark water.\nfunction build(S) {\n  const u = S.moon, bg = S.bg, kind = S.kind, alb = S.alb;\n  const mx = 9 + 46 * u, my = 8 + 14 * u * u - 6 * sin(PI * u), s = (S.s = 0.3 - 1.2 * u);\n  for (let y = 0; y \u003c H; y++) {\n    const f = floor(min(1, y / 40) * 6) / 6, I = exp(-max(0, y - PY) / 36), amb = 5 + 21 * exp(-max(0, y - PY) / 50);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3, k = kind[p];\n      let r = 0, g = 0, b = 0;\n      if (k === SKY) {\n        r = 30 + 14 * f;\n        g = 20 + 16 * f;\n        b = 64 + 24 * f;\n        const dx = x + 0.5 - mx, dy = y + 0.5 - my, dd = sqrt(dx * dx + dy * dy);\n        if (dd \u003c 5.3) {\n          const sea = (dx - 1.3) ** 2 + (dy + 1.2) ** 2 \u003c 3.6 || (dx + 1.9) ** 2 + (dy - 1.8) ** 2 \u003c 1.5;\n          (r = sea ? 196 : 238), (g = sea ? 194 : 234), (b = sea ? 190 : 214);\n        } else {\n          const hl = dd \u003c 7.5 ? 0.3 : dd \u003c 10.5 ? 0.16 : dd \u003c 15 ? 0.07 : 0;\n          (r += MOONC[0] * hl), (g += MOONC[1] * hl), (b += MOONC[2] * hl);\n          if (hl === 0 && y \u003c 30 && hash(p * 13 + 1) \u003c 0.012) r = g = b = 90 + 80 * hash(p);\n        }\n      } else if (k === ROOF) (r = 70 * alb[p]), (g = 50 * alb[p]), (b = 66 * alb[p]);\n      else if (k === GABLE) (r = 40 * alb[p]), (g = 26 * alb[p]), (b = 30 * alb[p]);\n      else if (k === WOOD) (r = 104 * alb[p]), (g = 66 * alb[p]), (b = 42 * alb[p]);\n      else if (k === GRASS) (r = 34), (g = 66), (b = 50);\n      else if (k === SOIL) (r = alb[p] * 30), (g = alb[p] * 19), (b = alb[p] * 26);\n      else if (k === SECT) {\n        const l = 62 - 22 * max(0, y - PY) / 96;\n        (r = alb[p] * l * TINT[0]), (g = alb[p] * l * TINT[1]), (b = alb[p] * l * TINT[2]);\n      } else if (k === BACK) {\n        // A stone gives back the dim light of the night and the moonbeam;\n        // the dust in the beam glows whatever is behind it.\n        const m = I * beam(s, x, y);\n        r = alb[p] * (TINT[0] * amb + MOONC[0] * 0.5 * m) + MOONC[0] * 0.2 * m;\n        g = alb[p] * (TINT[1] * amb + MOONC[1] * 0.5 * m) + MOONC[1] * 0.2 * m;\n        b = alb[p] * (TINT[2] * amb + MOONC[2] * 0.5 * m) + MOONC[2] * 0.2 * m;\n      } else if (k === WATER) {\n        // Black water; a faint broken copy of the moonbeam just under the top.\n        const dy = y - WS, m = dy \u003c 6 && (x + dy) % 3 !== 0 ? 0.3 * exp(-1.5) * beam(s, x, WS) * (1 - dy / 6) : 0;\n        (r = 3 + MOONC[0] * m), (g = 5 + MOONC[1] * m), (b = 10 + MOONC[2] * m);\n      }\n      bg[o] = r;\n      bg[o + 1] = g;\n      bg[o + 2] = b;\n    }\n  }\n}\n\nfunction touch(S, hard) {\n  S.ph = \"event\";\n  S.e = 0;\n  S.by = BOTB;\n  S.cyc++;\n  S.ripples.push({ x: RX, t: 0, a: hard ? 2 : 1.2 });\n  for (let i = 0; i \u003c (hard ? 14 : 6); i++) S.bits.push({ x: RX - 6 + Math.random() * 12, y: WS - 1, vx: (Math.random() - 0.5) * 18, vy: -14 - Math.random() * (hard ? 34 : 16), gl: 0 });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.fog = cl(k[3], 0, 1);\n  const m = cl(k[2], 0, 1);\n  if (abs(m - S.moon) > 0.003) (S.moon = m), build(S);\n  const ds = (d * S.speed) / 2, hd = S.hand;\n  S.t += ds;\n  S.e += ds;\n  if (input.btnPressed && input.btnPressed[0] && (S.ph === \"lower\" || S.ph === \"top\")) (S.ph = \"drop\"), (S.v = 18);\n  if (S.ph === \"lower\") {\n    S.by += 18 * ds;\n    if (S.by >= BOTB) touch(S, false);\n  } else if (S.ph === \"drop\") {\n    S.v += 160 * ds;\n    S.by += S.v * ds;\n    if (S.by >= BOTB) touch(S, true);\n  } else if (S.ph === \"event\") {\n    const e = S.e;\n    if (e \u003c E_YANK) S.by = BOTB + 1.3 * sin(e * 8) * exp(-e * 2.5);\n    else {\n      const y = (e - E_YANK) / 0.3;\n      S.by = min(190, BOTB + (y \u003c 1 ? 34 * y * y : 34 + 40 * (y - 1)));\n      if (e - ds \u003c E_YANK) {\n        // The yank: a splash, a big ring, the rope whips and the wheel runs free.\n        S.ripples.push({ x: RX, t: 0, a: 2.4 });\n        for (let i = 0; i \u003c 18; i++) S.bits.push({ x: RX - 7 + Math.random() * 14, y: WS - 1, vx: (Math.random() - 0.5) * 30, vy: -22 - Math.random() * 40, gl: 0 });\n        S.wa = 6;\n        S.sv = 16;\n      }\n    }\n    S.g = e \u003c E_FADE ? sm(e / E_GLOW) * (0.92 + 0.08 * vn(S.t * 7, 3)) : 1 - sm((e - E_FADE) / (E_END - E_FADE));\n    S.eo = e \u003c 0.25 ? 0 : e \u003c 2.8 ? sm((e - 0.25) / 0.2) * (abs(e - 1.9) \u003c 0.07 ? 0.2 : 1) : 1 - sm((e - 2.8) / 0.25);\n    // The hand rises beside the bucket, takes the rim and goes under with it.\n    hd.on = e > E_HAND0 && S.by \u003c 150;\n    hd.fall = false;\n    hd.x = 22;\n    hd.y = e \u003c E_HAND1 ? 134 - (134 - BOTB - 6) * (1 - (1 - (e - E_HAND0) / (E_HAND1 - E_HAND0)) ** 2) : S.by + 6;\n    hd.c = sm((e - E_HAND1) / (E_GRIP - E_HAND1));\n    if (e > 1.4 && e \u003c 3.3 && (S.bubT += ds * 10) >= 1) {\n      S.bubT--;\n      S.bubbles.push({ x: RX + (Math.random() - 0.5) * 12, y: 128, v: 10 + Math.random() * 9, sd: floor(Math.random() * 999) });\n    }\n    if (e > E_END) (S.ph = \"calm\"), (S.e = 0), (S.g = 0), (S.eo = 0);\n  } else if (S.ph === \"calm\") {\n    if (S.e > 0.5) {\n      S.ph = \"raise\";\n      S.by = 132;\n      // Every other round the hand comes up still holding the rim.\n      S.cling = S.cyc % 2 === 1;\n      hd.on = S.cling;\n      hd.c = 1;\n      hd.fall = false;\n    }\n  } else if (S.ph === \"raise\") {\n    S.by -= 26 * ds;\n    if (hd.on && !hd.fall) {\n      hd.y = S.by + 6;\n      if (S.by \u003c 62) (hd.fall = true), (hd.v = 0);\n    }\n    if (S.by \u003c= TOPB) (S.by = TOPB), (S.ph = \"top\"), (S.e = 0);\n  } else if (S.ph === \"top\" && S.e > 0.9) (S.ph = \"lower\"), (S.e = 0);\n  // A hand that lets go drops back down the shaft, opening as it falls.\n  if (hd.fall) {\n    hd.v += 150 * ds;\n    hd.y += hd.v * ds;\n    hd.c = max(0, hd.c - ds * 3);\n    if (hd.y > WS + 12) {\n      hd.fall = hd.on = false;\n      S.ripples.push({ x: hd.x + 2, t: 0, a: 1.6 });\n      for (let i = 0; i \u003c 8; i++) S.bits.push({ x: hd.x + Math.random() * 5, y: WS - 1, vx: (Math.random() - 0.5) * 16, vy: -12 - Math.random() * 22, gl: 0 });\n    }\n  }\n  if (S.ph === \"raise\" || S.ph === \"top\" || S.ph === \"lower\") hd.on = hd.on && S.ph === \"raise\";\n  // What the bucket brings up glows and drips, less the higher it gets.\n  S.cg = S.ph === \"raise\" || S.ph === \"top\" ? (S.by \u003c WS - 9 ? exp(-(WS - 9 - S.by) / 40) : 1) : 0;\n  if (S.cg > 0.15 && S.by \u003c WS - 9 && (S.dripT += ds * 12 * S.cg) >= 1) {\n    S.dripT--;\n    S.bits.push({ x: RX - 5 + floor(Math.random() * 10), y: S.by + 10, vx: 0, vy: 0, gl: 1 });\n  }\n  // The rope's length turns the wheel; after the yank it also runs free a while.\n  S.ex += S.sv * ds;\n  S.sv *= exp(-1.4 * ds);\n  S.th = -(S.by - 5 - CY) / 5 + S.ex;\n  S.wa *= exp(-2.4 * ds);\n  S.wp += 24 * ds;\n  // Flying water falls back; drips fall; bubbles rise and break the surface.\n  let n = 0;\n  for (const b of S.bits) {\n    b.vy += 170 * ds;\n    b.x += b.vx * ds;\n    b.y += b.vy * ds;\n    if (b.y > WS && b.vy > 0) {\n      if (b.gl) S.ripples.push({ x: b.x, t: 0, a: 0.5 });\n    } else S.bits[n++] = b;\n  }\n  S.bits.length = n;\n  n = 0;\n  for (const b of S.bubbles) {\n    b.y -= b.v * ds;\n    if (b.y \u003c= WS + 1) S.ripples.push({ x: b.x, t: 0, a: 0.6 });\n    else S.bubbles[n++] = b;\n  }\n  S.bubbles.length = n;\n  n = 0;\n  for (const r of S.ripples) if ((r.t += ds) \u003c 2.2) S.ripples[n++] = r;\n  S.ripples.length = n;\n  if (S.ripples.length > 24) S.ripples.splice(0, S.ripples.length - 24);\n}\n\n// Add a colour at a pixel, by alpha.\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\n// Something solid at (x, y): under the water it takes the glow's colour and\n// darkens.\nfunction solid(S, x, y, r, g, b) {\n  if (y > WS + S.off[cl(round(x), 0, W - 1)]) {\n    const gc = S.gc, k = 0.3 * S.g;\n    r = r * 0.55 + gc[0] * k;\n    g = g * 0.55 + gc[1] * k;\n    b = b * 0.55 + gc[2] * k;\n  }\n  put(S.buf, x, y, r, g, b, 1);\n}\n\n// The hand, wrist at (x, y): a long forearm from below, a palm, three long\n// fingers and a thumb. c is the grip: 0 spread upward, 1 hooked over to the\n// right, onto the bucket's rim.\nfunction hand(S, x, y, c) {\n  const P = [205, 222, 200];\n  for (let j = 0; j \u003c 40; j++) {\n    const yy = y + 1 + j, xx = x - 1 - j * 0.12;\n    for (let i = -1; i \u003c= 1; i++) solid(S, xx + i, yy, P[0] * 0.86, P[1] * 0.86, P[2] * 0.86);\n  }\n  for (let j = 0; j \u003c 3; j++) for (let i = -2; i \u003c= 2; i++) solid(S, x + i, y - j, P[0], P[1], P[2]);\n  for (let f = 0; f \u003c 3; f++) {\n    const bx = x - 2 + 2 * f, sp = (f - 1) * (1 - c);\n    for (let j = 0; j \u003c 4 + (f === 1 ? 1 : 0); j++) solid(S, bx + round(sp * j * 0.3), y - 3 - j, P[0], P[1], P[2]);\n    const jx = bx + round(sp * 1.4), jy = y - 7 - (f === 1 ? 1 : 0);\n    // The last joint: up when open, over and down when it grips.\n    solid(S, jx + round(c), jy - round(1 - c), P[0], P[1], P[2]);\n    solid(S, jx + round(2 * c), jy - round(2 * (1 - c)) + round(c), P[0] * 0.9, P[1] * 0.9, P[2] * 0.9);\n  }\n  solid(S, x - 3, y - 2, P[0], P[1], P[2]);\n  solid(S, x - 4, y - 3, P[0], P[1], P[2]);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.moon \u003c 0) return;\n  const { buf, alb, kind, off } = S, t = S.t, g = S.g, cg = S.cg, by = S.by, s = S.s;\n  const gc = hsv(0.3 + S.hue, 0.85, 1, S.gc);\n  buf.set(S.bg);\n  // The water's surface, rings running out from where things went in.\n  for (let x = 0; x \u003c W; x++) {\n    let v = 0;\n    for (const r of S.ripples) {\n      const dx = abs(x + 0.5 - r.x), front = 18 * r.t;\n      if (dx \u003c front) v += r.a * exp(-1.6 * r.t) * sin(0.9 * (dx - front)) * min(1, (front - dx) / 3);\n    }\n    off[x] = cl(round(v), -3, 3);\n  }\n  // The glow, and what the bucket brings up, light the stones and the air.\n  if (g > 0.01 || cg > 0.01) {\n    for (let y = PY; y \u003c WS; y++) {\n      const fw = g * UP[WS - y];\n      for (let x = SX0 - 1; x \u003c= SX1 + 1; x++) {\n        let f = fw;\n        if (cg > 0.01) {\n          const dx = x - RX, dy = y - by - 4;\n          f += 0.8 * cg * RAD[min(4095, (dx * dx + dy * dy) | 0)];\n        }\n        if (f \u003c 0.012) continue;\n        const p = y * W + x, o = p * 3, a = alb[p] * 0.72 + (kind[p] === BACK ? 0.3 : 0);\n        buf[o] += gc[0] * f * a;\n        buf[o + 1] += gc[1] * f * a;\n        buf[o + 2] += gc[2] * f * a;\n      }\n    }\n  }\n  // The water: black, or lit from below in slow swirls with a brighter\n  // heart round the eyes.\n  for (let y = WS; y \u003c H; y++)\n    for (let x = SX0; x \u003c= SX1; x++) {\n      const o = (y * W + x) * 3;\n      if (y \u003c WS + off[x]) {\n        // A trough: the stones and air above show through.\n        const q = ((y - 1) * W + x) * 3;\n        (buf[o] = buf[q]), (buf[o + 1] = buf[q + 1]), (buf[o + 2] = buf[q + 2]);\n        continue;\n      }\n      if (g \u003c 0.01) continue;\n      const n = vn(x * 0.21 + 1.6 * vn(y * 0.17 - t * 0.6, 3) + t * 0.5, 11 + (y >> 2)), ex = x - RX, ey = y - 117;\n      const f = g * (0.12 + 0.1 * floor(n * 3 + 1.5) / 2 + 0.6 * RAD[min(4095, round((ex * ex * 0.4 + ey * ey) * 1.36))] + (y - WS \u003c 2 ? 0.2 : 0));\n      buf[o] += gc[0] * f;\n      buf[o + 1] += gc[1] * f;\n      buf[o + 2] += gc[2] * f;\n    }\n  // Mist over the water, added as light.\n  if (S.fog > 0) {\n    const top = WS - 4 - 66 * S.fog, a0 = 0.16 + 0.42 * S.fog, mk = 0.7 * g;\n    const mr = 150 + (gc[0] - 150) * mk, mg = 150 + (gc[1] - 150) * mk, mb = 186 + (gc[2] - 186) * mk;\n    for (let y = max(PY, floor(top)); y \u003c WS + 3; y++) {\n      const ramp = sm((y - top) / 12);\n      for (let x = SX0; x \u003c= SX1; x++) {\n        const nn = 0.55 + 0.45 * vn(x * 0.13 - t * 0.7 + y * 0.04, 17 + (y >> 3)) + 0.3 * vn(x * 0.31 + t * 1.1, 29 + (y >> 2));\n        const a = floor(a0 * ramp * cl(nn, 0, 1) * 10) / 10;\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        buf[o] += mr * a;\n        buf[o + 1] += mg * a;\n        buf[o + 2] += mb * a;\n      }\n    }\n  }\n  // Eyes under the water, pale, with dark slits.\n  if (S.eo > 0.02)\n    for (const ex of [RX - 6, RX + 4]) {\n      const ey = 116, wide = S.eo > 0.45;\n      for (let i = 0; i \u003c 5; i++) {\n        const pup = i === 2, r = pup ? 20 : 228 + gc[0] * 0.1, gg = pup ? 30 : 240, b = pup ? 20 : 222;\n        put(buf, ex + i, ey, r, gg, b, min(1, S.eo * 2));\n        if (wide && i > 0 && i \u003c 4) {\n          put(buf, ex + i, ey - 1, r, gg, b, 1);\n          put(buf, ex + i, ey + 1, r, gg, b, 1);\n        }\n      }\n    }\n  // The rope, whipping after the yank.\n  const end = min(H - 1, by - 5), ry = PY;\n  for (let y = CY; y \u003c= end; y++) {\n    const x = RX + S.wa * sin(0.32 * y - S.wp) * ((y - CY) / 90);\n    const l = y \u003c ry ? 0.95 : 0.5 + 0.5 * exp(-(y - ry) / 48) * (0.5 + 0.5 * beam(s, round(x), y));\n    solid(S, x, y, 200 * l, 176 * l, 122 * l);\n  }\n  // The windlass wheel: rim, four spokes, the hub and the crank.\n  const th = S.th;\n  for (let a = 0; a \u003c 2 * PI; a += 0.2) put(buf, CX + 5 * cos(a), CY + 5 * sin(a), 140, 92, 54, 1);\n  for (let q = 0; q \u003c 4; q++) {\n    const a = th + (q * PI) / 2;\n    for (let r = 1; r \u003c 5; r++) put(buf, CX + r * cos(a), CY + r * sin(a), 118, 76, 44, 1);\n  }\n  const ca = th + PI / 4;\n  for (let r = 1; r \u003c= 7; r++) put(buf, CX + r * cos(ca), CY + r * sin(ca), 90, 90, 104, 1);\n  put(buf, CX + 7.6 * cos(ca), CY + 7.6 * sin(ca), 170, 120, 70, 1);\n  put(buf, CX, CY, 60, 60, 72, 1);\n  // The bucket: staves, two iron hoops, its bail, lit less the deeper it hangs.\n  if (by - 6 \u003c H) {\n    const lit = by \u003c PY ? 1 : 0.45 + 0.55 * exp(-(by - PY) / 45) * (0.55 + 0.45 * beam(s, RX, round(by))), gl = g * UP[cl(round(WS - by - 5), 0, 127)] * 0.22;\n    for (let r = 0; r \u003c 10; r++) {\n      const xl = RX - 6 + round(r / 9), xr = RX + 5 - round(r / 9);\n      for (let x = xl; x \u003c= xr; x++) {\n        const hoop = r === 2 || r === 7, edge = x === xl || x === xr, rim = r === 0;\n        const c = hoop ? HOOP : rim ? RIM : STAVE[x & 1];\n        const e = edge && !hoop ? 0.7 : 1;\n        solid(S, x, by + r, (c[0] * lit + gc[0] * gl) * e, (c[1] * lit + gc[1] * gl) * e, (c[2] * lit + gc[2] * gl) * e);\n      }\n    }\n    for (let x = RX - 6; x \u003c= RX + 5; x++) solid(S, x, by - 5 * (1 - ((x - RX + 0.5) / 6) ** 2), 120 * lit, 120 * lit, 136 * lit);\n    // Brimming with the glowing water it brought up.\n    if (cg > 0.05) for (let x = RX - 5; x \u003c= RX + 4; x++) put(buf, x, by - 1, gc[0], gc[1], gc[2], min(1, cg * 1.4));\n  }\n  // The hand, rising, gripping, clinging or falling.\n  const hd = S.hand;\n  if (hd.on) hand(S, hd.x, hd.y, hd.c);\n  // Bubbles, flying water and green drips.\n  for (const b of S.bubbles) {\n    const x = b.x + 1.2 * sin(b.y * 0.5 + b.sd);\n    put(buf, x, b.y, 220, 255, 230, 0.8);\n    if (b.sd % 3 === 0) put(buf, x + 1, b.y, 200, 240, 210, 0.5);\n  }\n  for (const b of S.bits)\n    if (b.gl) put(buf, b.x, b.y, gc[0], gc[1], gc[2], 0.9);\n    else put(buf, b.x, b.y, 170 + gc[0] * 0.3 * g, 190 + gc[1] * 0.25 * g, 200, 0.85);\n  // The surface line: moonlit where the beam reaches it, bright with the glow.\n  for (let x = SX0; x \u003c= SX1; x++) {\n    const m = beam(s, x, WS) * 0.25, y = WS + off[x], crest = off[x] \u003c 0 ? 1.4 : 1;\n    put(buf, x, y, (40 + MOONC[0] * m + gc[0] * g * 0.6) * crest, (44 + MOONC[1] * m + gc[1] * g * 0.6) * crest, (60 + MOONC[2] * m + gc[2] * g * 0.6) * crest, 1);\n  }\n  // Out in steps of four.\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3)\n      display.setPixel(x, y, min(255, ((buf[o] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 1] + 2) >> 2) \u003c\u003c 2), min(255, ((buf[o + 2] + 2) >> 2) \u003c\u003c 2));\n}\n","paper-lantern-ghost":"// ===== Patternflow pattern =====\n// Title:   Paper Lantern Ghost\n// Family:  halloween\n// Idea:    On a rainy purple night a ribbed paper lantern swings from an eave until one big eye opens on it and its seam tears into a wide grin with a long red tongue lolling out, while below a one-eyed paper umbrella hops on its single leg back and forth across the wet ground, tongue out, splashing the puddles that carry the lantern's light.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Hop=0..1\n//\n// Knob 1: Hue. The lantern's light: the paper, its halo, the rain it lights and its reflection in the puddles. Orange at 0, green at 0.25, sky blue at 0.5, magenta at 0.75; the umbrella stays toxic green and the tongues red.\n// Knob 2: Speed. Everything's clock, rain included. At the opening 2 the eye opens at 0.8 s, the grin tears open at 1.2 s, the tongue is out by 2.4 s, the eye blinks at 4.6 s and the face closes back into a plain lantern at 7.4 s before it starts again at 9 s; the umbrella hops every 0.6 s. At 0.2 ten times slower, at 3 half again as fast.\n// Knob 3: Rain. At 0 a steady rain of 90 short streaks falling nearly straight; at 1 a downpour of 420 longer ones driven slantwise by the wind. Each drop that lands rings a puddle or splashes the stones.\n// Knob 4: Hop. How high and far the umbrella hops: 10 LEDs up and 8 along at 0, a little more at the opening 0.06, 46 up and 18 along at 1, high enough to reach the lantern's tongue, each hop longer in the air.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hsv = (h, s, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + (h - floor(h)) * 6) % 6;\n  o[c] = 255 * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\nconst PX = 32, PY = 9, LC = 27, GROUND = 110, FOOT = 117;\n// Puddles on the stones: [x, y, half width, half height].\nconst PUDDLES = [[13, 116, 11, 2.6], [46, 120.5, 13, 3], [24, 125.5, 9, 1.8]];\nconst inPuddle = (x, y) => PUDDLES.some(([a, b, c, d]) => ((x - a) / c) ** 2 + ((y - b) / d) ** 2 \u003c 1);\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, t: 0, ph: 0, th: 0, wind: 0, L: [0, 0, 0], paper: [0, 0, 0],\n    bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    // The tongue: a hanging chain, each point with where it was last frame.\n    tg: Array.from({ length: 8 }, () => [PX, PY + LC + 8, PX, PY + LC + 8]),\n    // The umbrella: where it took off and where it lands, the way it faces,\n    // and how far through the hop it is.\n    U: { x0: 12, x1: 21, dir: 1, p: 0.1, x: 12, y: 0, tilt: 0, sq: 1, leg: 13 },\n    drops: [], rings: [], bits: [],\n    face: { eye: 0, mouth: 0, tongue: 0 },\n  };\n  background(params.s);\n}\n\n// A new drop, upwind far enough that the wind carries some to every column.\nfunction drop(top, wind) {\n  return { x: Math.random() * (66 + wind * 140) - wind * 140, y: top ? Math.random() * -30 : Math.random() * FOOT, v: 95 + Math.random() * 40, fy: GROUND + Math.random() * 17, len: 3 + floor(Math.random() * 3 + wind * 8) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const hue = cl(k[0], 0, 1), rain = cl(k[2], 0, 1), hop = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1) * (cl(k[1], 0.2, 3) / 2);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    hsv(0.075 + hue, 0.78, S.L);\n    // The paper glows paler than the light it gives.\n    for (let c = 0; c \u003c 3; c++) S.paper[c] = mix(S.L[c], [255, 246, 214][c], 0.5);\n  }\n  S.t += d;\n  // The face, on a 9 s loop: the eye opens, the seam tears into a grin, the\n  // tongue lolls out; a blink; then it all closes up again.\n  const tau = S.t % 9, F = S.face;\n  F.eye = ease((tau - 0.8) / 0.3) * (1 - ease((tau - 7.9) / 0.3)) * (1 - sin(PI * cl((tau - 4.6) / 0.25, 0, 1)));\n  F.mouth = ease((tau - 1.2) / 0.5) * (1 - ease((tau - 7.4) / 0.5));\n  F.tongue = 25 * ease((tau - 1.5) / 0.9) * (1 - ease((tau - 6.9) / 0.6));\n  // The swing: wider while the face is open.\n  S.ph += d * 1.8;\n  S.th = (0.15 + 0.1 * F.mouth) * sin(S.ph) + 0.04 * sin(S.ph * 1.7 + 1);\n  // The tongue hangs from the lower lip and swings behind the lantern.\n  const [ax, ay] = toWorld(S.th, 0.5, LC + 6 + 4 * F.mouth), seg = F.tongue / 7, g = 140 * d * d;\n  S.tg[0] = [ax, ay, ax, ay];\n  for (let i = 1; i \u003c 8; i++) {\n    const p = S.tg[i], vx = (p[0] - p[2]) * 0.94, vy = (p[1] - p[3]) * 0.94;\n    (p[2] = p[0]), (p[3] = p[1]);\n    (p[0] += vx), (p[1] += vy + g);\n  }\n  for (let n = 0; n \u003c 3; n++)\n    for (let i = 1; i \u003c 8; i++) {\n      const a = S.tg[i - 1], b = S.tg[i], dx = b[0] - a[0], dy = b[1] - a[1], l = sqrt(dx * dx + dy * dy) || 1;\n      (b[0] = a[0] + (dx / l) * seg), (b[1] = a[1] + (dy / l) * seg);\n    }\n  // The umbrella: crouch, a parabola from one landing to the next, a squash\n  // on landing; it turns round at either side.\n  const U = S.U, P = 0.55 + 0.45 * hop, hh = 10 + 36 * hop, step = 8 + 10 * hop, was = U.p;\n  U.p += d / P;\n  if (U.p >= 1) {\n    U.p -= 1;\n    U.x0 = U.x1;\n    if (U.x0 + U.dir * step > 54 || U.x0 + U.dir * step \u003c 10) U.dir = -U.dir;\n    U.x1 = U.x0 + U.dir * step;\n  }\n  const a = cl((U.p - 0.2) / 0.65, 0, 1), cr = U.p \u003c 0.2 ? sin((PI * U.p) / 0.2) : U.p > 0.85 ? sin((PI * (U.p - 0.85)) / 0.15) : 0;\n  U.x = mix(U.x0, U.x1, a);\n  U.y = -hh * 4 * a * (1 - a);\n  U.tilt = 0.16 * U.dir * sin(PI * a);\n  U.sq = 1 - 0.16 * cr + 0.06 * sin(PI * a);\n  U.leg = 13 - 5 * cr;\n  if (was \u003c 0.85 && U.p >= 0.85) {\n    // Landing: a ring in the puddle and a spray of drops.\n    S.rings.push([U.x, FOOT, 0, 1.6]);\n    for (let i = 0; i \u003c 12; i++) S.bits.push([U.x + (Math.random() - 0.5) * 8, FOOT - 1, (Math.random() - 0.5) * 50, -25 - Math.random() * 35, 0]);\n  }\n  // Rain, its rings in the puddles and splashes on the stones.\n  const want = round(90 + 330 * rain), wind = (S.wind = 0.08 + 0.32 * rain);\n  while (S.drops.length \u003c want) S.drops.push(drop(false, wind));\n  if (S.drops.length > want) S.drops.length = want;\n  for (const r of S.drops) {\n    r.y += r.v * d;\n    r.x += r.v * d * wind;\n    if (r.y > r.fy) {\n      if (inPuddle(r.x, r.fy)) S.rings.length \u003c 60 && S.rings.push([r.x, r.fy, 0, 1]);\n      else if (S.bits.length \u003c 120) S.bits.push([r.x, r.fy, (Math.random() - 0.5) * 20, -18, 0.25]);\n      Object.assign(r, drop(true, wind));\n    }\n  }\n  S.rings = S.rings.filter((r) => (r[2] += d) \u003c 0.45 * r[3]);\n  S.bits = S.bits.filter((b) => {\n    b[0] += b[2] * d;\n    b[1] += b[3] * d;\n    b[3] += 160 * d;\n    return (b[4] += d) \u003c 0.55 && b[1] \u003c FOOT + 2;\n  });\n}\nconst toWorld = (th, x, y) => [PX + x * cos(th) - y * sin(th), PY + x * sin(th) + y * cos(th)];\n\n// --- the night, laid out once: the eave of a roof along the top with a row\n// of round tile ends, a purple sky stepping lighter downward, a bamboo fence,\n// wet paving with three puddles.\nfunction background(S) {\n  const bg = S.bg;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, v = floor(cl((y - 8) / 84, 0, 1) * 12) / 12;\n      let r = 34 + 60 * v, g = 20 + 40 * v, b = 62 + 76 * v;\n      const te = (((x + 3) % 6) - 2.5) ** 2 + (y - 2.5) ** 2;\n      if (y \u003c 8) {\n        // Round tile ends along the roof's edge over a dark beam.\n        const rim = (y \u003c 4 && te > 3 && te \u003c 7.5) || y === 7;\n        (r = rim ? 76 : 20), (g = rim ? 52 : 12), (b = rim ? 96 : 28);\n      } else if (y >= 88 && y \u003c GROUND) {\n        // Slats of split bamboo, two bindings across.\n        const slat = x % 3 !== 2 || y \u003c 90, bind = abs(y - 93) \u003c 1 || abs(y - 104) \u003c 1;\n        if (slat || bind) (r = bind ? 46 : 16), (g = bind ? 30 : 10), (b = bind ? 52 : 24);\n        if (y === 88 && slat) (r = 70), (g = 50), (b = 90);\n      } else if (y >= GROUND) {\n        const joint = (y - GROUND) % 6 === 5 || (x + (floor((y - GROUND) / 6) & 1) * 5) % 10 === 0;\n        (r = joint ? 16 : 34), (g = joint ? 10 : 22), (b = joint ? 24 : 46);\n        if (inPuddle(x + 0.5, y + 0.5)) (r = 62), (g = 44), (b = 104);\n      }\n      bg[o] = r;\n      bg[o + 1] = g;\n      bg[o + 2] = b;\n    }\n}\n\nconst put = (buf, o, c) => {\n  buf[o] = c[0];\n  buf[o + 1] = c[1];\n  buf[o + 2] = c[2];\n};\nconst addc = (buf, o, c, a) => {\n  buf[o] += c[0] * a;\n  buf[o + 1] += c[1] * a;\n  buf[o + 2] += c[2] * a;\n};\nconst RAIN = [110, 100, 170], BLACK = [18, 8, 22], WHITE = [255, 250, 236], GULLET = [70, 0, 22], TONGUE = [244, 62, 96], GROOVE = [186, 26, 66];\nconst GREEN = [120, 236, 44], GREEN2 = [74, 178, 26], RIB = [30, 80, 20], SKIN = [244, 208, 172];\n\n// The lantern in its own frame, hung from the hook: a barrel of paper 26\n// wide between two black lacquered caps, ribbed every 3.3 LEDs.\nfunction lantern(S, buf) {\n  const F = S.face, th = S.th, c = cos(th), s = sin(th), L = S.L, Pp = S.paper;\n  // Where the eye looks: at the umbrella.\n  const [cx, cy] = toWorld(th, 0, LC), ux = S.U.x - cx, uy = FOOT - 20 + S.U.y - cy, ul = sqrt(ux * ux + uy * uy) || 1;\n  const lx0 = ((ux * c + uy * s) / ul) * 2.4, ly0 = ((-ux * s + uy * c) / ul) * 1.8;\n  for (let y = PY; y \u003c PY + 54; y++)\n    for (let x = 6; x \u003c 58; x++) {\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY, bx = dx * c + dy * s, by = -dx * s + dy * c - LC, o = (y * W + x) * 3;\n      if (by \u003c -19.5) {\n        if ((abs(bx) \u003c 0.6 && by > -LC) || (abs(bx) \u003c 2.4 && by > -22)) put(buf, o, BLACK);\n        continue;\n      }\n      if (abs(by) > 16.5) {\n        if (abs(bx) \u003c (by \u003c 0 ? 7.5 : 8.5) && abs(by) \u003c 20) put(buf, o, abs(by) \u003c 17.6 ? [90, 66, 100] : BLACK);\n        continue;\n      }\n      const hw = 13 * sqrt(1 - (by / 19.5) ** 2);\n      if (abs(bx) > hw) continue;\n      // The eye, its lids and the pupil looking at the umbrella.\n      const ey = (bx - 2) ** 2 / 36 + (by + 5) ** 2 / (25 * F.eye * F.eye + 0.01);\n      if (F.eye > 0.04 && ey \u003c 1.45) {\n        put(buf, o, ey > 1 ? BLACK : (bx - 2 - lx0) ** 2 + (by + 5 - ly0 * F.eye) ** 2 \u003c 6.8 ? ((bx - 2.7 - lx0) ** 2 + (by + 5.8 - ly0) ** 2 \u003c 0.7 ? WHITE : BLACK) : WHITE);\n        continue;\n      }\n      // The grin: the seam at row 6 tears open, corners curling up, the\n      // torn edges ragged.\n      const q = bx / 11.5, m = F.mouth, rag = 0.5 * sin(bx * 2.7) * m;\n      const top = 6 - m * (1.6 * (1 - q * q) + 3.2 * q ** 4) + rag, bot = 6 + m * (8.5 * (1 - q * q) - 3.2 * q ** 4) + rag;\n      if (abs(q) \u003c 1 && by > top - 0.45 && by \u003c bot + 0.45) {\n        put(buf, o, m \u003c 0.05 || by \u003c top + 0.35 || by > bot - 0.35 ? [150, 40, 30] : GULLET);\n        continue;\n      }\n      // Paper: palest in the middle, the light's own colour at the sides,\n      // ribs a little darker, bowed with the barrel.\n      const e = (bx / hw) ** 2, rb = (by + 16.5 + 0.9 * e) % 3.3 \u003c 0.8;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = mix(Pp[ch], L[ch], e) * (rb ? 0.78 : 1);\n    }\n}\n\n// The tongue: a capsule along the chain, thinning to a round tip, a groove\n// down the middle, outlined dark.\nfunction tongue(S, buf) {\n  const T = S.tg, F = S.face;\n  if (F.tongue \u003c 1) return;\n  let xa = 64, xb = 0, ya = 128, yb = 0;\n  for (const p of T) (xa = min(xa, p[0])), (xb = max(xb, p[0])), (ya = min(ya, p[1])), (yb = max(yb, p[1]));\n  for (let y = max(0, floor(ya - 4)); y \u003c min(H, yb + 5); y++)\n    for (let x = max(0, floor(xa - 4)); x \u003c min(W, xb + 5); x++) {\n      let dm = 9, cm = 9;\n      for (let i = 1; i \u003c 8; i++) {\n        const [ax, ay] = T[i - 1], [bx, by] = T[i], vx = bx - ax, vy = by - ay, l2 = vx * vx + vy * vy || 1;\n        const t = cl(((x + 0.5 - ax) * vx + (y + 0.5 - ay) * vy) / l2, 0, 1), dd = sqrt((x + 0.5 - ax - vx * t) ** 2 + (y + 0.5 - ay - vy * t) ** 2);\n        const r = i === 7 ? 2.6 : 2.7 - 0.08 * i;\n        if (dd - r \u003c dm) (dm = dd - r), (cm = dd);\n      }\n      const o = (y * W + x) * 3;\n      if (dm \u003c 0) put(buf, o, cm \u003c 0.55 && y > T[1][1] ? GROOVE : TONGUE);\n      else if (dm \u003c 1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n    }\n}\n\n// The umbrella in its own frame, origin where the leg meets the canopy, y\n// down: a bell of oiled paper 26 wide and 28 tall on five ribs, scalloped\n// between the ribs at the rim, one eye, a tongue, one leg on a clog.\nfunction canopy(x, y) {\n  if (y \u003c -28 || y > 1.4 * abs(sin((PI * x) / 6.5))) return 0;\n  const s = -y / 28;\n  return abs(x) \u003c (y \u003c 0 ? 13 * sqrt(1 - s) * (1 - 0.15 * s) : 13) ? 1 : 0;\n}\nfunction umbrella(S, buf) {\n  const U = S.U, c = cos(U.tilt), s = sin(U.tilt), ox = U.x, oy = FOOT - 3.3 - U.leg + U.y, f = U.dir, z = 1 / U.sq;\n  for (let y = max(0, floor(oy - 34 * U.sq)); y \u003c min(H, oy + U.leg + 5); y++)\n    for (let x = max(0, floor(ox - 17)); x \u003c min(W, ox + 18); x++) {\n      const dx = x + 0.5 - ox, dy = y + 0.5 - oy, lx = dx * c + dy * s, ly = -dx * s + dy * c, cy = ly * z, o = (y * W + x) * 3;\n      // The tongue, out of the mouth under the eye and down over the rim,\n      // flapping with the hop.\n      const tl = (cy + 8.5) / 13.5, tx = f * (0.6 + (1.5 + 2.5 * sin(PI * U.p)) * tl);\n      if (tl > 0 && tl \u003c 1 && abs(lx - tx) \u003c 1.9 - 0.4 * tl) {\n        put(buf, o, abs(lx - tx) \u003c 0.45 && tl > 0.2 ? GROOVE : TONGUE);\n        continue;\n      }\n      if (canopy(lx, cy)) {\n        const hw = cy \u003c 0 ? 13 * sqrt(1 + cy / 28) * (1 + (0.15 * cy) / 28) : 13, u = lx / hw;\n        const ey = (lx - f) ** 2 / 20 + (cy + 15) ** 2 / 16;\n        if (ey \u003c 1.4) {\n          // The eye looks the way it is going.\n          put(buf, o, ey > 1 ? BLACK : (lx - 2 * f) ** 2 + (cy + 15.5) ** 2 \u003c 3.6 ? BLACK : WHITE);\n        } else if (abs(lx - f * 0.6) \u003c 3 && abs(cy + 8.6) \u003c 1) put(buf, o, GULLET);\n        else if (cy \u003c -26.5) put(buf, o, BLACK);\n        else {\n          const rib = abs(u * 2 - round(u * 2)) * hw \u003c 0.55, side = floor((u + 1) * 2) & 1;\n          put(buf, o, rib ? RIB : side ? GREEN2 : GREEN);\n          if (cy > -1.5) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.62;\n        }\n        continue;\n      }\n      if (canopy(lx + 0.9, cy) || canopy(lx - 0.9, cy) || canopy(lx, cy + 0.9) || canopy(lx, cy - 0.9)) {\n        for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      // The tip.\n      if (lx * lx + (cy + 29.6) ** 2 \u003c 2.6) {\n        put(buf, o, BLACK);\n        continue;\n      }\n      // The leg, its knee bending forward in a crouch, and the clog.\n      const kx = f * (13 - U.leg) * 0.9, kl = U.leg / 2, legd = ly \u003c kl ? abs(lx - kx * (ly / kl)) : abs(lx - kx * (1 - (ly - kl) / kl));\n      if (ly > 0 && ly \u003c U.leg && legd \u003c 1.15) put(buf, o, SKIN);\n      else if (ly >= U.leg && ly \u003c U.leg + 1.4 && abs(lx) \u003c 3.8) put(buf, o, [150, 30, 40]);\n      else if (ly >= U.leg + 1.4 && ly \u003c U.leg + 3.3 && abs(abs(lx) - 2.3) \u003c 0.8) put(buf, o, [92, 56, 40]);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0) return;\n  const buf = S.buf, L = S.L;\n  buf.set(S.bg);\n  const [cx, cy] = toWorld(S.th, 0, LC);\n  // The halo around the lantern in three steps, and its light under the eave.\n  for (let y = 0; y \u003c GROUND; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const r = sqrt((x + 0.5 - cx) ** 2 + ((y + 0.5 - cy) * 0.8) ** 2), a = r \u003c 22 ? 0.3 : r \u003c 30 ? 0.17 : r \u003c 40 ? 0.07 : 0;\n      if (a) addc(buf, (y * W + x) * 3, L, a * (y \u003c 9 ? 1.6 : 1));\n    }\n  // The puddles hold the lantern upside down, broken up by ripples, and the\n  // wet stones catch its light where it falls.\n  for (let y = GROUND; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, wob = sin(y * 2.1 + S.t * 5) * 1.2;\n      if (inPuddle(x + 0.5, y + 0.5)) {\n        const w = abs(x + 0.5 + wob - cx);\n        if (w \u003c 11) addc(buf, o, S.paper, w \u003c 6 ? 0.8 : 0.45);\n      } else if (abs(x + 0.5 - cx) \u003c 11 - (y - GROUND) * 0.3 && (y - GROUND) % 6 === 0) addc(buf, o, L, 0.75);\n    }\n  for (const [x, y, t, big] of S.rings) {\n    const rr = 1 + (t / 0.45 / big) * 4.5 * big, a = 0.6 * (1 - t / 0.45 / big);\n    for (let i = 0; i \u003c 20; i++) {\n      const px = round(x + rr * cos((i * TAU) / 20)), py = round(y + rr * 0.32 * sin((i * TAU) / 20));\n      if (px >= 0 && px \u003c W && py \u003c H && inPuddle(px + 0.5, py + 0.5)) addc(buf, (py * W + px) * 3, [190, 180, 230], a);\n    }\n  }\n  lantern(S, buf);\n  // The tongue swings in front of the lantern's lower half and below it.\n  tongue(S, buf);\n  umbrella(S, buf);\n  // Rain: pale lilac streaks, lit the lantern's colour near it.\n  const wind = S.wind;\n  for (const r of S.drops) {\n    const dl = sqrt((r.x - cx) ** 2 + ((r.y - cy) * 0.8) ** 2), lit = dl \u003c 20 ? 0.85 : dl \u003c 32 ? 0.5 : dl \u003c 46 ? 0.22 : 0;\n    for (let i = 0; i \u003c r.len; i++) {\n      const x = round(r.x - wind * i), y = round(r.y - i);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = (y * W + x) * 3, a = 1 - i / r.len;\n      // Lit drops lose the lilac, so they read orange rather than peach.\n      addc(buf, o, RAIN, 0.55 * a * (1 - lit));\n      if (lit) addc(buf, o, L, lit * a);\n    }\n  }\n  for (const [x, y, , , t] of S.bits) {\n    const px = round(x), py = round(y);\n    if (px >= 0 && px \u003c W && py >= 0 && py \u003c H) addc(buf, (py * W + px) * 3, [170, 160, 220], 1 - t / 0.55);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","risset-rhythm":"// ===== Patternflow pattern =====\n// Title:   Risset Rhythm\n// Family:  rhythm\n// Idea:    A binary ruler, its ticks longer the coarser their level, lies across five octaves of tempo and zooms out by two every four seconds towards a point just under the panel, so each lane of ticks strikes the playhead ever faster while the lanes slide towards the fast side under a fixed bell of light, and after each doubling the picture is exactly where it began.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Risset's eternal accelerando (Jean-Claude Risset, 1970s), the rhythmic twin of Shepard tones (Roger Shepard, 1964), pattern round 50\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Spread=-1..1, Ratio=2..4\n//\n// Knob 1: Hue. Turns the colours across the panel together; the strikes stay white. At 0 the slow lanes on the left are green, the middle azure and the fast lanes on the right violet; at 0.25 blue, magenta and red; at 0.5 violet, orange and yellow-green; at 0.75 yellow, green and teal.\n// Knob 2: Speed. Every tempo doubles in 8 / Speed seconds: 4 at 2, 40 at 0.2 and 2.7 at 3. At 2 the ticks cross the playhead at 11 rows a second, and a lane strikes 0.23 times a second at the left edge, 1.3 at the middle and 7 at the right edge, each lane twice as often one doubling later, by which time it has slid one lane to the right.\n// Knob 3: Spread. The width of the bell of light in octaves of tempo, 1.4 times 2 to the knob. At 0 the edge lanes glow at a fifth of the middle; at -1 (0.7 octaves) one lane carries the light and the edges are dark; at 1 (2.8 octaves) the edges keep two thirds and the hand-over from fast to slow shows plainly.\n// Knob 4: Ratio. The tempo ratio between neighbouring layers, rounded to 2, 3 or 4: a binary, ternary or base-four ruler. Its lanes are 12.8, 20.3 and 25.6 LEDs wide, a doubling of tempo always being 12.8, and the picture repeats after one ratio's worth of tempo, every 4, 6.3 and 8 seconds at Speed 2.\n// Buttons: K1 tap turns the accelerando into a ritardando and back: the zoom runs the other way, the ticks rise through the playhead, the lanes slide towards the slow side and every tempo halves in the time it took to double.\n\nconst W = 64, H = 128, NP = W * H;\nconst { floor, ceil, min, max, exp, pow, log2, round, LN2 } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Across the panel runs log tempo: OCT LEDs to an octave, five octaves from\n// the slowest layer on the left to the fastest on the right. The loudness\n// bell is centred BELL octaves in from the left.\nconst OCT = W / 5, BELL = 2.4;\n// The ruler's zero, the point the zoom closes on, sits 8 rows below the\n// bottom edge; the playhead is row PLAY. The layer at the left edge has its\n// ticks SP0 rows apart.\nconst Y0 = H + 8, PLAY = 72, SP0 = 48;\n// Seconds for every tempo to double at Speed 2, and how long a hit glows.\nconst T2 = 4, GLOW = 0.12;\n// The light of a played tick against one to come, the rows the white of a\n// tick crossing the playhead takes to fade, the halo of a hit and its reach\n// in rows, and the faint light of every other lane.\nconst PAST = 0.6, FLASH = 3, HALO = 0.45, HR = 12, LANE = 0.12;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, dir: 1, hue: 0, speed: 2, spread: 1.4, r: 2,\n    buf: new Float32Array(NP * 3), bell: new Float32Array(W), cr: new Float32Array(W), cg: new Float32Array(W), cb: new Float32Array(W),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 2];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.spread = 1.4 * pow(2, cl(k[2], -1, 1));\n  S.r = round(cl(k[3], 2, 4));\n  if (input.btnPressed && input.btnPressed[0]) S.dir = -S.dir;\n  // t counts doublings: every tempo is 2^t times what it was at the start.\n  S.t += (S.dir * cl(dt || 0, 0, 0.1) * S.speed) / (2 * T2);\n}\n\nfunction hsv(h, s, v, o, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0][o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1][o] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2][o] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { buf, bell, cr, cg, cb } = S;\n  buf.fill(0);\n  // The bell is fixed in log tempo: each column's loudness, and its colour.\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5) / OCT - BELL;\n    bell[x] = exp((-u * u) / (2 * S.spread * S.spread));\n    hsv(S.hue + 0.3 + (0.55 * x) / W, 0.8, 1, x, [cr, cg, cb]);\n  }\n  // One period of the picture is log2(r) doublings: then every layer has\n  // become the next one.\n  const r = S.r, per = log2(r), lw = OCT * per;\n  const z = S.t / per, n = floor(z), p = z - n;\n  // Real seconds per doubling at this speed, for the glow of a hit.\n  const Td = (2 * T2) / S.speed;\n  // Bars just past the playhead burn white, fading over FLASH rows.\n  const sgn = S.dir > 0 ? 1 : -1;\n  for (let j = -2; (j + p) * lw \u003c W; j++) {\n    const x0 = max(0, floor((j + p) * lw + 0.5)), x1 = min(W, floor((j + 1 + p) * lw + 0.5));\n    if (x1 \u003c= x0) continue;\n    const sp = SP0 * pow(r, -(j + p)), th = cl(sp / 4, 0.6, 2.2);\n    // Ticks: every multiple of sp above the ruler's zero.\n    const m0 = max(0, ceil((Y0 - H - 2) / sp)), m1 = floor((Y0 + 2) / sp);\n    if (sp >= 1.2) {\n      for (let m = m0; m \u003c= m1; m++) {\n        // Played ticks, past the playhead, are dimmer than the ones to come.\n        const y = Y0 - m * sp, d = sgn * (y - PLAY);\n        bar(buf, y, th, x0, x1, d > 0 ? PAST : 1, d > -0.5 ? exp(-max(0, d) / FLASH) : 0, bell, cr, cg, cb);\n      }\n    } else {\n      for (let y = 0; y \u003c H; y++) line(buf, y, x0, x1, min(1, 0.8 / sp) * (sgn * (y - PLAY) > 0 ? PAST : 1), 0, bell, cr, cg, cb);\n    }\n    // A hit: the playhead stands phi tick spacings above zero, so the layer\n    // strikes whenever phi passes a whole number, phi ln2 times a doubling.\n    const phi = (Y0 - PLAY) / sp, fr = phi - floor(phi);\n    const age = ((S.dir > 0 ? fr : 1 - fr) * Td) / (phi * LN2);\n    const g = exp(-age / GLOW);\n    for (let dy = -HR; dy \u003c= HR; dy++) {\n      const f = 1 - Math.abs(dy) / (HR + 1);\n      line(buf, PLAY + dy, x0, x1, HALO * g * f * f, 0.3 * HALO * g * f * f * f, bell, cr, cg, cb);\n    }\n  }\n  // Each lane is faintly lit, with a dark seam at its edges, so the lanes\n  // show sliding towards the fast side.\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5) / lw - p, e = (u - floor(u)) * lw, v = LANE * min(1, e / 1.5, (lw - e) / 1.5);\n    for (let y = 0; y \u003c H; y++) line(buf, y, x, x + 1, v, 0, bell, cr, cg, cb);\n  }\n  // The playhead.\n  for (let x = 0, o = 3 * PLAY * W; x \u003c W; x++, o += 3) (buf[o] += 0.16), (buf[o + 1] += 0.16), (buf[o + 2] += 0.16);\n  for (let p = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = 3 * p;\n      display.setPixel(x, y, q4(buf[o]), q4(buf[o + 1]), q4(buf[o + 2]));\n    }\n}\n\n// A bar th rows thick centred on row y, spread over the rows it covers.\nfunction bar(buf, y, th, x0, x1, v, w, bell, cr, cg, cb) {\n  const top = y - th / 2, bot = y + th / 2;\n  for (let a = floor(top); a \u003c bot; a++) {\n    const c = min(bot, a + 1) - max(top, a);\n    if (c > 0) line(buf, a, x0, x1, v * c, w * c, bell, cr, cg, cb);\n  }\n}\n\n// Adds colour v and white w along row y from x0 to x1, each column weighted\n// by the bell.\nfunction line(buf, y, x0, x1, v, w, bell, cr, cg, cb) {\n  if (y \u003c 0 || y >= H) return;\n  for (let x = x0, o = 3 * (y * W + x0); x \u003c x1; x++, o += 3) {\n    const b = bell[x], c = v * b, e = w * b;\n    buf[o] += c * cr[x] + e;\n    buf[o + 1] += c * cg[x] + e;\n    buf[o + 2] += c * cb[x] + e;\n  }\n}\n\n// Channels in steps of 4 of 255, from 0..1.\nconst q4 = (v) => (v >= 1 ? 252 : ((v * 63 + 0.5) | 0) \u003c\u003c 2);\n","skull-swap":"// ===== Patternflow pattern =====\n// Title:   Skull Swap\n// Family:  halloween\n// Idea:    Two skeletons dance side by side in a moonlit graveyard, then each lifts off its own skull and they toss them across on crossing arcs past the moon, catch them on the wrong necks, wobble, turn their glowing sockets on each other, shrug, and toss them back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 50, built on Bone Pile, pattern round 48\n// Round:   50\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Toss=0..1, Dance=2..8\n//\n// Knob 1: Hue. The night sky and the shade side of the bones, through the cold half of the wheel only: violet at 0, blue at 0.25, cyan at 0.5, sea green at 0.75, toxic green at 1. The moon stays cream, the pumpkin orange, one skull's eyes green and the other's orange.\n// Knob 2: Speed. The tempo, 50 beats a minute for each unit. At the opening 100 the skulls leave the hands at 1.6 s, land on the wrong necks at 2.1 s, the two look at each other at 2.8 s, shrug at 3.6 s and throw back at 4.9 s. At 0.2 ten times slower; 150 at 3.\n// Knob 3: Toss. How high the skulls fly and how often they spin. At 0 the higher arc crosses the moon and each skull turns once; at 0.5 it brushes the top edge and they turn twice; at 1 it leaves the panel for a moment, they turn three times and the throwers hop.\n// Knob 4: Dance. Beats danced between swaps, 2 to 8. Each round they dance the next of three dances: a sway with both arms up, kicks to the side with hands on hips, a bounce at the knees pumping the forearms in turn.\n// Buttons: K1 tap ends the dance and starts the throw at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, acos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hsv = (h, s, o) => [5, 3, 1].forEach((n, c) => {\n  const k = (n + h * 6) % 6;\n  o[c] = 255 * (1 - s * max(0, min(k, 4 - k, 1)));\n});\n\n// --- shapes in their own frames, y down, as distances (negative inside).\nconst seg = (x, y, ax, ay, bx, by) => {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return sqrt((x - ax - dx * t) ** 2 + (y - ay - dy * t) ** 2);\n};\nconst ell = (x, y, cx, cy, rx, ry) => (sqrt(((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2) - 1) * min(rx, ry);\nconst box = (x, y, cx, cy, hx, hy, r) => {\n  const qx = abs(x - cx) - hx + r, qy = abs(y - cy) - hy + r;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n};\nfunction long(x, y, L, w, r) {\n  const e = L / 2 - r, q = 0.6 * r, ry = r * 0.9;\n  return min(seg(x, y, 0, -e, 0, e) - w, ell(x, y, -q, -e, r, ry), ell(x, y, q, -e, r, ry), ell(x, y, -q, e, r, ry), ell(x, y, q, e, r, ry));\n}\n// Kinds: 0 long bone, 1 paired bones, 2 cage and neck, 3 lumbar, 4 pelvis,\n// 5 skull, 6 jaw, 7 hand, 8 foot, 9 hat. The cage is narrower than Bone Pile's.\nconst RIBS = [[6.4, 2.4], [7.9, 6.6], [8.8, 10.8], [8.8, 15], [7.8, 19]];\nfunction shape(k, x, y, sg) {\n  switch (k) {\n    case 0:\n      return long(x, y, sg, 0.95 + 0.015 * sg, 1.5);\n    case 1: {\n      const e = sg / 2 - 1.1;\n      return min(seg(x, y, -1, -e, -1, e) - 0.8, seg(x, y, 1.1, -e, 1.1, e) - 0.6, box(x, y, 0, -e - 0.2, 2.3, 1.1, 1), box(x, y, 0, e + 0.2, 2.1, 1.1, 1));\n    }\n    case 2: {\n      let d = min(box(x, y, 0, -3.4, 1.5, 0.75, 0.5), box(x, y, 0, -1.4, 1.6, 0.75, 0.5));\n      d = min(d, seg(x, y, -1.4, 0.8, -9.6, -0.2) - 0.8, seg(x, y, 1.4, 0.8, 9.6, -0.2) - 0.8, seg(x, y, 0, 1, 0, 14) - 1.2);\n      for (let v = 15.5; v \u003c 24; v += 2.7) d = min(d, box(x, y, 0, v, 1.6, 0.9, 0.5));\n      for (const [rx, ry] of RIBS) {\n        const c = 3.6 / (rx * rx), ax = min(abs(x), rx), f = ry + c * ax * ax;\n        d = min(d, abs(x) \u003c= rx ? abs(y - f) / sqrt(1 + (2 * c * ax) ** 2) - 0.7 : sqrt((abs(x) - rx) ** 2 + (y - f) ** 2) - 0.7);\n      }\n      return d;\n    }\n    case 3: {\n      let d = 9;\n      for (let v = -4; v \u003c= 4.1; v += 2.7) d = min(d, box(x, y, 0, v, 1.9, 0.95, 0.5), box(x, y, 0, v, 3.1, 0.4, 0.3));\n      return d;\n    }\n    case 4: {\n      let d = max(abs(x) - (2.5 - 0.28 * (y + 5.5)), abs(y + 2.6) - 3);\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const dx = x - s * 5.3, dy = y + 3.6, c = 0.8, n = 0.6 * s;\n        d = min(d, ell(dx * c + dy * n, -dx * n + dy * c, 0, 0, 4.1, 2.9), abs(ell(x, y, s * 3.4, 2.4, 2.4, 1.9)) - 0.75, ell(x, y, s * 6.5, 0, 1.5, 1.5));\n      }\n      return d;\n    }\n    case 5:\n      return min(ell(x, y, 0, -10.6, 7, 7.3), ell(x, y, 0, -6.8, 6.4, 2.3), box(x, y, 0, -3.2, 4.4, 2.6, 1.4));\n    case 6: {\n      const hw = 4.3 - 0.4 * max(0, y);\n      return min(box(x, y, 0, 1.5, 4.3, 1.6, 0.8), max(abs(x) - hw, abs(y - 1.6) - 1.8));\n    }\n    case 7: {\n      let d = ell(x, y, 0, 1.4, 1.8, 1.4);\n      for (let i = 0; i \u003c 4; i++) d = min(d, seg(x, y, -1.2 + 0.8 * i, 2.2, -1.8 + 1.2 * i, 5.4) - 0.5);\n      return d;\n    }\n    case 8:\n      return min(ell(x, y, sg * 0.8, 1.6, 3.1, 1.4), ell(x, y, 0, 0.4, 1.4, 1));\n    default: {\n      // A witch's hat: brim, tapering cone, bent tip.\n      const t = cl((-17.4 - y) / 10, 0, 1);\n      return min(ell(x, y, 0.4, -17, 8.4, 1.4), seg(x, y, 0, -17.4, 2.6, -27.4) - mix(4.6, 0.7, t), seg(x, y, 2.6, -27.4, 6, -28.6) - 0.7);\n    }\n  }\n}\n// 0 none, 1 dark, 2 socket, 3 shade, 4 pupil, 5 hat band; the face slides\n// sideways as the head turns, the pupils further.\nfunction hole(k, x, y, Hd) {\n  if (k === 5) {\n    const p = Hd.pitch * 3, xs = x - Hd.yaw * 1.7;\n    if (((abs(xs) - 2.9) / 2.2) ** 2 + ((y + 7.9 - p) / 2.5) ** 2 \u003c 1) return ((abs(xs) - 2.9 - Hd.yaw * Math.sign(xs) * 0.9) / 1.15) ** 2 + ((y + 7.7 - p) / 1.3) ** 2 \u003c 1 ? 4 : 2;\n    const ny = y + 5.4 - p;\n    if (ny >= 0 && ny \u003c 1.7 && abs(xs) \u003c 0.3 + 0.5 * ny) return 1;\n    if (y > -2 + p * 0.5 && y \u003c -0.5 && abs(xs * 0.8) \u003c 3.4) return (xs + 4) / 1.45 - floor((xs + 4) / 1.45) \u003c 0.3 || y > -0.9 ? 1 : 0;\n  } else if (k === 6 && y \u003c 1.2 && y > -0.2 && abs(x) \u003c 3.8) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 ? 1 : 0;\n  else if (k === 4 && ((abs(x) - 4.6) / 2.3) ** 2 + ((y + 4.4 + 0.3 * abs(x)) / 1.3) ** 2 \u003c 1) return 3;\n  else if (k === 9 && y > -19.4 && y \u003c -17.6 && abs(x) \u003c 5.2) return 5;\n  return 0;\n}\n\n// Body pieces back to front, [kind, length, bounds]; the hands are drawn\n// after the heads, to hold one from in front.\nconst FEMUR = 22, TIBIA = 21, ARM = 15, FORE = 13, HIP = 6.5, FLOOR = 120, HIPY = FLOOR - 3 - FEMUR - TIBIA;\nconst two = (p) => [p, p];\nconst PIECES = [[8, -1, -3.9, 3.9, -1, 3.2], [8, 1, -3.9, 3.9, -1, 3.2], ...two([1, TIBIA, -2.4, 2.4, -11, 11]), ...two([0, FEMUR, -2.6, 2.6, -11.4, 11.4]), [4, 0, -11, 11, -9, 5.2], [3, 0, -3.6, 3.6, -5.3, 5.3], [2, 0, -10.6, 10.6, -4.5, 22.6], ...two([0, ARM, -2.6, 2.6, -7.9, 7.9]), ...two([1, FORE, -2.4, 2.4, -7, 7]), ...two([7, 0, -2.7, 2.7, -0.3, 6.1])];\nconst SKULL = [5, 0, -7.2, 7.2, -18.1, 0.6], JAW = [6, 0, -4.4, 4.4, -0.3, 3.5], HAT = [9, 0, -8.6, 7, -29.6, -15.4];\n\n// --- the body, posed in Bone Pile's frame (floor 120, x = 0, full size)\n// and placed on the panel at its own scale.\nconst at = (K, i, x, y, a) => {\n  K.x[i] = K.cx + K.sc * x;\n  K.y[i] = FLOOR + K.sc * (y - FLOOR);\n  K.a[i] = a;\n};\nconst ang = (dx, dy) => atan2(-dx, dy);\nconst bone = (K, i, ax, ay, bx, by) => at(K, i, (ax + bx) / 2, (ay + by) / 2, ang(bx - ax, by - ay));\nconst rot = (a, x, y) => [x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)];\n// Two-bone reach; of the two joints that work, the one nearer (px, py).\nfunction limb(K, ax, ay, tx, ty, L1, L2, i1, i2, px, py) {\n  const dx = tx - ax, dy = ty - ay, d = cl(sqrt(dx * dx + dy * dy), 2, L1 + L2 - 0.01), b = atan2(dy, dx);\n  const al = acos(cl((L1 * L1 + d * d - L2 * L2) / (2 * L1 * d), -1, 1));\n  let kx = ax + L1 * cos(b + al), ky = ay + L1 * sin(b + al);\n  const mx = ax + L1 * cos(b - al), my = ay + L1 * sin(b - al);\n  if ((mx - px) ** 2 + (my - py) ** 2 \u003c (kx - px) ** 2 + (ky - py) ** 2) (kx = mx), (ky = my);\n  const n = sqrt((tx - kx) ** 2 + (ty - ky) ** 2) || 1, u = (tx - kx) / n, v = (ty - ky) / n;\n  bone(K, i1, ax, ay, kx, ky);\n  bone(K, i2, kx, ky, kx + L2 * u, ky + L2 * v);\n  return [kx + L2 * u, ky + L2 * v, u, v];\n}\n// Legs, spine and cage; leaves the neck on the panel in K.nx, K.ny, K.na.\nfunction torso(D, K) {\n  const rx = D.sway, ry = HIPY + D.bob, t = D.tilt, l = D.lean;\n  at(K, 6, rx, ry, t);\n  for (const s of [-1, 1]) {\n    const [hx, hy] = rot(t, s * HIP, 0), f = s \u003c 0 ? D.fl : D.fr, ax = rx + hx, ay = ry + hy;\n    const [ex, ey] = limb(K, ax, ay, s * (HIP + f[1]), FLOOR - 3 - f[0], FEMUR, TIBIA, 4 + (s > 0), 2 + (s > 0), ax + s * 60, ay + 20);\n    at(K, s > 0 ? 1 : 0, ex, ey, 0);\n  }\n  const [b0, b1] = rot(t, 0, -5), sx = rx + b0, sy = ry + b1, [c0, c1] = rot(l, 0, -10);\n  bone(K, 7, sx + c0, sy + c1, sx, sy);\n  const [d0, d1] = rot(l, 0, -24), tx = sx + c0 + d0, ty = sy + c1 + d1 - D.shr * 0.4;\n  at(K, 8, tx, ty, l);\n  const [n0, n1] = rot(l, 0, -4.4);\n  Object.assign(K, { tx, ty, nx: K.cx + K.sc * (tx + n0), ny: FLOOR + K.sc * (ty + n1 - FLOOR), na: l + D.head });\n}\n// Arms from the dance angles, each hand pulled toward its K.hold target.\nfunction arms(D, K) {\n  const l = D.lean;\n  for (const s of [-1, 1]) {\n    const [o0, o1] = rot(l, s * 10, 0.6 - D.shr), ax = K.tx + o0, ay = K.ty + o1, a1 = s \u003c 0 ? D.al : D.ar, a2 = s \u003c 0 ? D.bl : D.br;\n    const [u0, u1] = rot(l, s * sin(a1), cos(a1)), ex = ax + ARM * u0, ey = ay + ARM * u1;\n    const [v0, v1] = rot(l, s * sin(a1 + a2), cos(a1 + a2));\n    let wx = ex + FORE * v0, wy = ey + FORE * v1;\n    const h = K.hold[s > 0 ? 1 : 0];\n    if (h[0] > 0) (wx = mix(wx, (h[1] - K.cx) / K.sc, h[0])), (wy = mix(wy, FLOOR + (h[2] - FLOOR) / K.sc, h[0]));\n    const [hx, hy, u, v] = limb(K, ax, ay, wx, wy, ARM, FORE, 9 + (s > 0), 11 + (s > 0), ex, ey);\n    at(K, 13 + (s > 0), hx, hy, ang(u, v));\n  }\n}\n\nconst REST = { sway: 0, bob: 0, tilt: 0, lean: 0, head: 0, pitch: 0, jaw: 0, shr: 0, al: 0.1, bl: 0.06, ar: 0.1, br: 0.06, fl: [0, 0], fr: [0, 0] };\nconst clack = (b) => max(0, sin(TAU * b)) ** 2;\nfunction dance(m, b, D) {\n  Object.assign(D, REST, { fl: [0, 0], fr: [0, 0], jaw: clack(b) });\n  const w = sin(PI * b), s2 = sin((PI * b) / 2);\n  if (m === 0) {\n    // Sway: hips side to side over four beats, both arms up waving.\n    Object.assign(D, { sway: 3 * s2, tilt: 0.1 * s2, lean: -0.08 * s2, head: -0.18 * s2, al: 2.75 + 0.18 * w, ar: 2.75 - 0.18 * w, bl: 0.25 + 0.25 * w, br: 0.25 - 0.25 * w });\n  } else if (m === 1) {\n    // Kicks: a foot out to the side each beat, hands on the hips.\n    const k = sin(PI * (b - floor(b))) ** 2, s = floor(b) & 1 ? 1 : -1;\n    D[s \u003c 0 ? \"fl\" : \"fr\"] = [8 * k, 4 * k];\n    Object.assign(D, { sway: -s * 1.2 * k, head: s * 0.16 * k, al: 0.5, ar: 0.5, bl: -1.6, br: -1.6 });\n  } else {\n    // Bounce: a dip at the knees on every beat, elbows at the sides and the\n    // forearms pumping up in turn.\n    const e = 0.5 - 0.5 * cos(PI * b);\n    Object.assign(D, { bob: 1.4 - 1.4 * cos(TAU * b), sway: 1.5 * w, head: 0.16 * w, al: 0.3, bl: 0.2 + 2.3 * e, ar: 0.3, br: 2.5 - 2.3 * e });\n  }\n}\n// The right-hand skeleton dances the mirror image.\nfunction mirror(D) {\n  [D.al, D.ar, D.bl, D.br, D.fl, D.fr] = [D.ar, D.al, D.br, D.bl, D.fr, D.fl];\n  for (const key of [\"sway\", \"tilt\", \"lean\", \"head\"]) D[key] = -D[key];\n}\n\n// The story of one round in beats from its start: dance, lift, fly, land on\n// the wrong neck, look, shrug, lift, fly back, land home and nod.\nconst LIFT = 0.6;\nfunction times(S) {\n  const t0 = S.d, t1 = t0 + LIFT, t2 = t1 + S.T, t3 = t2 + 1.2, t4 = t3 + 1.3, t5 = t4 + 1.6;\n  return [t0, t1, t2, t3, t4, t5, t5 + LIFT, t5 + LIFT + S.T, t5 + LIFT + S.T + 1.6];\n}\n\nexport function setup(params) {\n  const body = (cx, sc) => ({ cx, sc, x: new Float64Array(15), y: new Float64Array(15), a: new Float64Array(15), D: { ...REST } });\n  params.s = {\n    hue: -1, beat: 0, t: 0, start: 0, moves: 0, d: 2, T: 1,\n    light: [0, 0, 0], bg: new Float32Array(N * 3), buf: new Float32Array(N * 3),\n    // The green-eyed skull belongs to the tall skeleton on the left, the\n    // orange-eyed one in the hat to the short one on the right.\n    K: [body(16, 0.8), body(48, 0.68)],\n    hd: [{ sc: 1, eye: [96, 255, 64], hat: 0 }, { sc: 0.86, eye: [255, 132, 8], hat: 1 }],\n  };\n}\n\n// Where a skull's hands go: either side of its cranium.\nconst sides = (Hd, s) => {\n  const [p, q] = rot(Hd.a, s * 8.6 * Hd.sc, -6 * Hd.sc);\n  return [Hd.x + p, Hd.y + q];\n};\nconst onNeck = (Hd, K, lift) => {\n  const [p, q] = rot(K.na, 0, -7 * lift);\n  Object.assign(Hd, { x: K.nx + p, y: K.ny + q, a: K.na + K.wob, yaw: K.yaw, jaw: K.D.jaw, pitch: K.D.pitch, fly: 0 });\n};\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 2], d = cl(dt || 0, 0, 0.1);\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    hsv(0.78 - 0.47 * hue, 0.62, S.light);\n    background(S);\n  }\n  const toss = cl(k[2], 0, 1), every = round(cl(k[3], 2, 8));\n  S.beat += (d * 50 * cl(k[1], 0.2, 3)) / 60;\n  S.t += d;\n  let u = S.beat - S.start;\n  if (u \u003c S.d) S.d = every;\n  if (input.btnPressed && input.btnPressed[0] && u \u003c S.d) (S.start = S.beat - S.d), (u = S.d);\n  let T = times(S);\n  if (u >= T[8]) {\n    S.start += T[8];\n    u -= T[8];\n    S.moves++;\n    S.d = every;\n  }\n  T = times(S);\n  // The arc is settled while no skull is in the air.\n  if (!((u >= T[1] && u \u003c T[2]) || (u >= T[6] && u \u003c T[7]))) {\n    S.h = 13 + 24 * toss;\n    S.T = 0.26 * sqrt(S.h);\n    S.turns = 1 + floor(toss * 2.99);\n    S.hop = toss;\n    T = times(S);\n  }\n  const [t0, t1, t2, t3, t4, t5, t6, t7] = T, m = S.moves % 3;\n  // Bodies: the dance, eased in and out, then the story.\n  S.K.forEach((K, i) => {\n    const D = K.D, dir = i ? -1 : 1;\n    dance(m, S.beat, D);\n    if (i) mirror(D);\n    const w = ease(u / 0.5) * (1 - ease((u - t0) / 0.4));\n    for (const key in REST) if (typeof REST[key] === \"number\") D[key] = mix(REST[key], D[key], w);\n    for (const f of [\"fl\", \"fr\"]) D[f] = D[f].map((v) => v * w);\n    K.wob = K.lift = 0;\n    for (const [ts, back] of [[t0, 0], [t5, 1]]) {\n      const q = u - ts;\n      if (q \u003c 0 || q > LIFT + S.T + 1.6) continue;\n      if (q \u003c LIFT) {\n        // Crouch with the skull lifted off the neck.\n        K.lift = ease((q / LIFT - 0.35) / 0.65);\n        D.bob += K.lift * (4 + 4 * S.hop);\n      } else if (q \u003c LIFT + S.T) {\n        // A hop on the throw, more for a high one.\n        const f = (q - LIFT) / S.T;\n        D.bob -= (2 + 7 * S.hop) * sin(PI * cl(f * 2.5, 0, 1));\n      } else {\n        // Landed: the knees give, more under the big skull; the head wobbles.\n        const v = q - LIFT - S.T, big = (i === 1) !== !!back ? 1.5 : 1;\n        D.bob += 5 * big * exp(-4 * v) * sin(min(PI, v * 9));\n        K.wob = (back ? 0.22 : 0.5) * big * exp(-2.4 * v) * sin(TAU * 2.2 * v) * dir;\n      }\n    }\n    // Look: the sockets turn on the other one; the jaw drops.\n    const lk = ease((u - t3) / 0.25) * (1 - ease((u - t4 + 0.1) / 0.3));\n    K.yaw = dir * lk;\n    D.lean += 0.07 * lk * dir;\n    D.jaw = max(D.jaw, 0.9 * lk * ease((u - t3 - 0.45) / 0.15));\n    // Shrug: shoulders up, elbows out, hands up and open, head on one side.\n    const sh = ease((u - t4) / 0.3) * (1 - ease((u - t5 + 0.45) / 0.35));\n    if (sh > 0) Object.assign(D, { shr: 3.5 * sh, al: mix(D.al, 0.3, sh), ar: mix(D.ar, 0.3, sh), bl: mix(D.bl, 2.5, sh), br: mix(D.br, 2.5, sh), head: D.head + 0.32 * sh * dir, jaw: max(D.jaw, 0.5 * sh) });\n    // Home again: a nod.\n    const n = (u - t7 - 0.8) / 0.6;\n    D.pitch = n > 0 && n \u003c 1 ? sin(PI * n) : 0;\n    torso(D, K);\n  });\n  // Skulls: on a neck, lifted, or flying neck to neck, the left one higher.\n  const A = S.K[0];\n  S.hd.forEach((Hd, i) => {\n    const own = S.K[i], other = S.K[1 - i];\n    let from = null, to = null, f = 0;\n    if (u \u003c t1) onNeck(Hd, own, own.lift);\n    else if (u \u003c t2) (from = own), (to = other), (f = (u - t1) / S.T);\n    else if (u \u003c t6) onNeck(Hd, other, other.lift);\n    else if (u \u003c t7) (from = other), (to = own), (f = (u - t6) / S.T);\n    else onNeck(Hd, own, 0);\n    if (from) {\n      // The arc is the cranium's middle, and the skull spins about it.\n      const pv = -9.5 * Hd.sc, h = S.h + (from === A ? 12 : 0), a = mix(from.na, to.na, f) + (from === A ? 1 : -1) * S.turns * TAU * f;\n      const [p, q] = rot(from.na, 0, pv - 7), [r, s] = rot(to.na, 0, pv), [e, g] = rot(a, 0, pv);\n      Object.assign(Hd, { x: mix(from.nx + p, to.nx + r, f) - e, y: mix(from.ny + q, to.ny + s, f) - 4 * h * f * (1 - f) - g, a, yaw: 0, jaw: 0.8, pitch: 0, fly: 1 });\n    }\n  });\n  // Hands: onto the skull, after it on the throw, up to catch, then down.\n  S.K.forEach((K, i) => {\n    K.hold = [[0], [0]];\n    const dir = i ? -1 : 1;\n    for (const [ts, back] of [[t0, 0], [t5, 1]]) {\n      const q = u - ts, f = (q - LIFT) / S.T, mine = S.hd[back ? 1 - i : i], theirs = S.hd[back ? i : 1 - i];\n      if (q \u003c 0 || f > 1 + 0.8 / S.T) continue;\n      for (const s of [0, 1]) {\n        const sd = 2 * s - 1;\n        if (f \u003c 0) K.hold[s] = [ease(q / LIFT / 0.45), ...sides(mine, sd)];\n        else if (f \u003c 1) {\n          const c = ease((f - 0.3) / 0.45), [x, y] = sides({ x: K.nx, y: K.ny, a: K.na, sc: theirs.sc }, sd);\n          K.hold[s] = [1, mix(K.nx + dir * 9 + sd * 3, x, c), mix(K.ny - 18, y, c)];\n        } else K.hold[s] = [1 - ease((q - LIFT - S.T - 0.2) / 0.5), ...sides(theirs, sd)];\n      }\n    }\n    arms(K.D, K);\n  });\n}\n\n// --- the graveyard, laid out per sky colour: a stepped sky, the moon and two\n// halo rings, black stones rimmed by the moon, the ground.\nconst MX = 32, MY = 21, MR = 13, GROUND = 117;\nconst CRATERS = [[-4, -4, 3.2], [4, 1, 2.6], [-2, 6, 2.2], [6, -6, 1.6], [-7, 2, 1.4]];\nconst STONES = [[5, 101, 5.5], [24, 108, 3.6], [41, 107, 3.8], [59, 99, 5.5]];\nfunction grave(x, y) {\n  let d = abs(x - 32) \u003c 1.6 && y > 86 && y \u003c GROUND ? 0 : abs(x - 32) \u003c 6 && y > 92 && y \u003c 95.5 ? 0 : 1;\n  for (const [sx, top, hw] of STONES) if (abs(x - sx) \u003c hw && y \u003c GROUND && (y > top + hw || (x - sx) ** 2 + (y - top - hw) ** 2 \u003c hw * hw)) d = 0;\n  return d === 0;\n}\nfunction background(S) {\n  const bg = S.bg, L = S.light;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, q = sqrt((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2);\n      let r, g, b;\n      if (y \u003c GROUND) {\n        const v = floor((0.14 + 0.52 * (y / GROUND) ** 1.6) * 20) / 20;\n        (r = L[0] * v), (g = L[1] * v), (b = L[2] * v);\n        if (q \u003c MR) {\n          const sp = CRATERS.some(([a, b, c]) => (x + 0.5 - MX - a) ** 2 + (y + 0.5 - MY - b) ** 2 \u003c c * c) ? 26 : 0;\n          (r = 255 - sp), (g = 240 - sp), (b = 204 - sp);\n        } else if (q \u003c MR + 4) (r += 60), (g += 56), (b += 50);\n        else if (q \u003c MR + 9) (r += 26), (g += 24), (b += 22);\n        if (grave(x, y)) {\n          // Black stone, rimmed on top where the moon catches it.\n          const rim = !grave(x, y - 1);\n          (r = rim ? 120 : 14), (g = rim ? 110 : 8), (b = rim ? 132 : 22);\n        }\n      } else {\n        const e = y === GROUND ? 1 : 0, sp = (x * 7 + y * y * 3) % 11 ? 0 : 10;\n        (r = 40 + 30 * e + sp), (g = 26 + 22 * e + sp), (b = 48 + 30 * e + sp);\n      }\n      bg[o] = r;\n      bg[o + 1] = g;\n      bg[o + 2] = b;\n    }\n}\n\n// Ivory, grey, and shade tinted by the sky; the hat violet.\nconst PG = [255, 120, 20], BONE = [[255, 244, 220], [212, 202, 180], [96, 88, 84]];\nconst HATC = [[196, 120, 255], [140, 64, 210], [70, 26, 112]];\nconst FIELD = new Float32Array(48 * 48);\nfunction piece(S, pc, cx, cy, a, sc, Hd) {\n  const [k, sg, x0, x1, y0, y1] = pc, c = cos(a), s = sin(a);\n  let xa = 1e9, xb = -1e9, ya = 1e9, yb = -1e9;\n  for (const [u, v] of [[x0, y0], [x1, y0], [x0, y1], [x1, y1]]) {\n    const wx = cx + (u * c - v * s) * sc, wy = cy + (u * s + v * c) * sc;\n    (xa = min(xa, wx)), (xb = max(xb, wx)), (ya = min(ya, wy)), (yb = max(yb, wy));\n  }\n  xa = max(0, floor(xa) - 1);\n  xb = min(W - 1, ceil(xb) + 1);\n  ya = max(0, floor(ya) - 1);\n  yb = min(H - 1, ceil(yb) + 1);\n  if (xb \u003c xa || yb \u003c ya || xb - xa >= 48 || yb - ya >= 48) return;\n  const buf = S.buf, L = S.light, z = 1 / sc;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy;\n      FIELD[(y - ya) * 48 + x - xa] = shape(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z, sg) * sc;\n    }\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const f = (y - ya) * 48 + x - xa, d = FIELD[f], o = (y * W + x) * 3;\n      if (d > 0.1) {\n        if (d \u003c 1.1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, hl = hole(k, (dx * c + dy * s) * z, (-dx * s + dy * c) * z, Hd);\n      if (hl && hl !== 3) {\n        // Dark holes, the glowing sockets and pupils, the hat's band.\n        const e = hl === 1 ? [2, 0, 4] : hl === 5 ? [245, 134, 2] : Hd.eye, g = hl === 2 ? 0.34 : 1;\n        put(buf, o, e[0] * g + 10, e[1] * g + 6, e[2] * g + 14);\n        continue;\n      }\n      // The slope of the field: where it climbs upward the piece faces the moon.\n      const up = y > ya ? FIELD[f - 48] : d + 1, dn = y \u003c yb ? FIELD[f + 48] : d + 1, n = (up - dn) / (abs(up - dn) + abs((x > xa ? FIELD[f - 1] : d) - (x \u003c xb ? FIELD[f + 1] : d)) + 0.01);\n      const t = hl === 3 || n \u003c= -0.3 ? 2 : n > 0.4 || (d > -0.6 && up > 0.1) ? 0 : 1, C = k === 9 ? HATC : BONE, w = t === 2 && k !== 9 ? 0.4 : 0;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = C[t][ch] + L[ch] * w;\n    }\n}\nconst put = (buf, o, r, g, b) => {\n  buf[o] = r;\n  buf[o + 1] = g;\n  buf[o + 2] = b;\n};\nfunction head(S, Hd) {\n  piece(S, SKULL, Hd.x, Hd.y, Hd.a, Hd.sc, Hd);\n  const [j0, j1] = rot(Hd.a, 0, (-0.7 + 2.4 * Hd.jaw + Hd.pitch * 0.6) * Hd.sc);\n  piece(S, JAW, Hd.x + j0, Hd.y + j1 + Hd.pitch * 2.5 * Hd.sc, Hd.a, Hd.sc, Hd);\n  if (Hd.hat) piece(S, HAT, Hd.x, Hd.y + Hd.pitch * 2 * Hd.sc, Hd.a, Hd.sc, Hd);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0) return;\n  const buf = S.buf;\n  buf.set(S.bg);\n  // The jack-o'-lantern: glow rings on the ground, a face in three steps.\n  const v = 0.6 + 0.2 * sin(S.t * 9) + 0.2 * sin(S.t * 23.7), fl = v > 0.82 ? 1 : v > 0.66 ? 0.84 : 0.7;\n  for (let y = 104; y \u003c H; y++)\n    for (let x = 14; x \u003c 50; x++) {\n      const q = sqrt(((x + 0.5 - 32) / 1.6) ** 2 + (y + 0.5 - 121) ** 2), gl = (q \u003c 9 ? 0.3 : q \u003c 13 ? 0.18 : q \u003c 17 ? 0.08 : 0) * fl;\n      for (let ch = 0, o = (y * W + x) * 3; ch \u003c 3; ch++) buf[o + ch] += PG[ch] * gl;\n    }\n  // Shadows of the two skeletons cast forward onto the ground.\n  for (const K of S.K)\n    for (let y = GROUND + 1; y \u003c GROUND + 6; y++)\n      for (let x = 0; x \u003c W; x++) if (abs(x + 0.5 - K.x[6]) \u003c (12 - (y - GROUND) * 1.2) * K.sc) for (let ch = 0; ch \u003c 3; ch++) buf[(y * W + x) * 3 + ch] *= 0.5;\n  for (let y = 114; y \u003c 127; y++)\n    for (let x = 24; x \u003c 41; x++) {\n      const dx = x + 0.5 - 32, dy = y + 0.5 - 121.2, o = (y * W + x) * 3;\n      const e = (dx / 7.4) ** 2 + (dy / 5) ** 2;\n      if (e \u003c 1) {\n        const rib = abs(abs(dx) - 3.4) \u003c 0.6 && e > 0.25, eye = dy > -3 && dy \u003c -0.6 && abs(abs(dx) - 3) \u003c 1.6 + (dy + 3) * 0.5, grin = dy > 0.8 && dy \u003c 2.8 - abs(dx) * 0.15 && abs(dx) \u003c 5 && !(abs(dx) % 2.5 \u003c 0.7 && dy \u003c 1.6);\n        if (eye || grin) put(buf, o, 255, 196 * fl + 30, 50 * fl);\n        else put(buf, o, rib ? 220 : 255, rib ? 84 : 118, rib ? 0 : 10);\n      } else if (e \u003c 1.35 && dy > -6) put(buf, o, buf[o] * 0.3, buf[o + 1] * 0.3, buf[o + 2] * 0.3);\n      if (abs(dx + 0.3) \u003c 1 && dy > -7.4 && dy \u003c -4.6) put(buf, o, 72, 150, 40);\n    }\n  // Bodies, skulls on necks, hands, skulls in the air.\n  for (const K of S.K) for (let i = 0; i \u003c 13; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  for (const Hd of S.hd) if (!Hd.fly) head(S, Hd);\n  for (const K of S.K) for (let i = 13; i \u003c 15; i++) piece(S, PIECES[i], K.x[i], K.y[i], K.a[i], K.sc, null);\n  for (const Hd of S.hd) if (Hd.fly) head(S, Hd);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","curlicue":"// ===== Patternflow pattern =====\n// Title:   Curlicue\n// Family:  number\n// Idea:    The partial sums of the theta sum over -N \u003c= n \u003c= N, one unit step per n with step n turned by pi n^2 x, grow out from the middle of the panel in both directions into a lace of separate LEDs while the view zooms out for ever, and every level of the zoom brings the same curls back, because N steps of x trace the shape of N x steps of -1/x, turned 45 degrees and drawn 1/sqrt(x) times larger.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: curlicues and their renormalisation (Michael Berry and Jonathan Goldberg, 1988), approximate functional equation of the theta sum (G. H. Hardy and J. E. Littlewood, 1914), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Number=0..1, Steps=0..1\n//\n// Knob 1: Hue. Turns the colours of the path round the wheel. At 0 the oldest steps, in the middle, are deep blue, turning to cyan toward the two ends, where the newest steps are white; at 0.5 the old steps are yellow and the new ones red.\n// Knob 2: Speed. How fast the view zooms out. At 2 the picture shrinks to half its size every 4 seconds while the two ends add steps to keep the panel filled, and the first growth from one step to the full lace takes 1.2 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Number. Which x the sum is for, in five steps: at 0 the square root of 3, at 0.25 the golden ratio, at 0.5 the square root of 2, at 0.75 sqrt 26 - 5 = 1/(10 + 1/(10 + ...)), at 1 sqrt 101 - 10 = 1/(20 + 1/(20 + ...)). The first three grow a lace with hooked arms; the last two sit close to 1/10 and 1/20, so their paths run straight between curls and the curls read as Euler spirals. Each chain of renormalised numbers comes round after one or two levels, so the zoom never ends and never changes its kind.\n// Knob 4: Steps. How many steps each half of the path holds when a level begins. At 0.06 about 2,000, so the path is a lace of single LEDs; at 1 about 120, each step a dotted stroke several LEDs long, so the curls read as lines.\n\nconst W = 64, H = 128;\nconst { floor, round, sqrt, sin, cos, log, exp, atan2, hypot, min, max, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The box the path is fitted into, and the most LEDs one step may span.\nconst BW = 62, BH = 126, SMAX = 9;\n// Story seconds at Speed 2: the size halves every ZOOM seconds; the first\n// growth from 1 step to the level's start takes INTRO seconds.\nconst ZOOM = 4, INTRO = 1.2;\n// Most partial sums a level may hold.\nconst CAP = 100000;\n\n// The five numbers on the knob, each a quadratic irrational, so its chain\n// of renormalised numbers comes round again after one or two levels:\n// the square root of 3 (2 - sqrt 3 = 0.268, which renormalises to itself),\n// the golden ratio (0.382 and 0.618 in turn), the square root of 2 (0.586\n// and 0.293), sqrt 26 - 5 = 1/(10 + 1/(10 + ...)) and sqrt 101 - 10 =\n// 1/(20 + 1/(20 + ...)), each its own mirror image one level down. The last\n// two sit close to 1/10 and 1/20, so their paths run straight for a while\n// between curls.\nconst STOPS = [sqrt(3), (1 + sqrt(5)) / 2, sqrt(2), sqrt(26) - 5, sqrt(101) - 10];\nconst mod2 = (v) => v - 2 * floor(v / 2);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), u = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? u : p, i === 1 || i === 2 ? v : i === 0 ? u : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? u : i === 5 ? q : p];\n}\n// Colour bands by age, from the middle out; the last one is the white ends.\nconst BANDS = 10;\n\n// Start the chain at the knob's number: x mod 2, folded into (0, 1]. A\n// number above 1 is drawn as the mirror image of 2 - x, the same sum conjugated.\nfunction begin(S, num) {\n  let x = mod2(STOPS[round(num * 4)]);\n  S.mirror = x > 1;\n  if (S.mirror) x = 2 - x;\n  S.xh = x;\n  S.orbit = [x];\n  S.filled = 0;\n  S.num = num;\n}\n\n// The partial sums S_k = sum of e^(i pi n^2 x) over 0 \u003c= n \u003c k, added as the\n// ends reach them. The path over -N..N is S_k - 1/2 and its negative.\nfunction fill(S, n) {\n  const re = S.re, im = S.im, x = S.xh;\n  n = min(n, CAP);\n  if (!S.filled) (re[0] = 0), (im[0] = 0);\n  let a = re[S.filled], b = im[S.filled];\n  for (let k = S.filled; k \u003c n; k++) {\n    const ph = PI * ((k * k * x) % 2);\n    a += cos(ph);\n    b += sin(ph);\n    re[k + 1] = a;\n    im[k + 1] = b;\n  }\n  S.filled = max(S.filled, n);\n}\n\n// One level deeper. Hardy and Littlewood: for 0 \u003c x \u003c= 1,\n//   S_n(x) = e^(i pi/4) x^(-1/2) S_(floor(n x) + 1)(-1/x) + O(x^(-1/2)),\n// and -1/x mod 2 folds into (0, 1] as y or as the mirror of 2 - y. So the n\n// steps on the panel are swapped for floor(n x) + 1 steps of the new number,\n// and the view is carried through the same turn and scale, so nothing moves.\nfunction deeper(S) {\n  const x = S.xh, N = S.N;\n  let y = mod2(-1 / x), flip = false;\n  if (y > 1) (y = 2 - y), (flip = true);\n  // A number that has come round before is set back to its first value, so\n  // rounding does not build up level after level and the chain repeats exactly.\n  for (const o of S.orbit) if (abs(y - o) \u003c 1e-9) y = o;\n  if (!S.orbit.includes(y)) S.orbit.push(y);\n  const oldRe = S.re, oldIm = S.im, n0 = min(floor(N), S.filled);\n  S.re = S.re2;\n  S.im = S.im2;\n  S.re2 = oldRe;\n  S.im2 = oldIm;\n  S.xh = y;\n  S.filled = 0;\n  fill(S, floor(N * x) + 2);\n  // The check: how far the old half path lies from the new one carried\n  // through the similarity, after the mean offset, against the path's size.\n  const ar = cos(PI / 4) / sqrt(x), ai = sin(PI / 4) / sqrt(x), sg = flip ? -1 : 1, stride = max(1, floor(n0 / 1500));\n  let dr = 0, di = 0, c = 0, gap = 0, size = 1;\n  for (let pass = 0; pass \u003c 2; pass++)\n    for (let n = 1; n \u003c= n0; n += stride) {\n      const m = floor(n * x) + 1, qr = S.re[m] - 0.5, qi = sg * S.im[m];\n      const u = oldRe[n] - 0.5 - (ar * qr - ai * qi), v = oldIm[n] - (ai * qr + ar * qi);\n      if (pass === 0) (dr += u), (di += v), c++;\n      else (gap = max(gap, hypot(u - dr, v - di))), (size = max(size, hypot(oldRe[n] - 0.5, oldIm[n])));\n      if (pass === 0 && n + stride > n0) (dr /= c), (di /= c);\n    }\n  S.gap = max(S.gap, gap / size);\n  S.offset = max(S.offset, hypot(dr, di));\n  S.levels++;\n  // Carry the view: screen = alpha w + centre, w the half path or its mirror.\n  const Ai = S.mirror ? -ai : ai;\n  for (const v of [S.view, S.goal]) [v.ar, v.ai] = [v.ar * ar - v.ai * Ai, v.ar * Ai + v.ai * ar];\n  S.mirror = S.mirror !== flip;\n  S.N = N * x;\n  S.L = log(S.N);\n}\n\n// Where the view wants to be: the long axis upright, the whole path in the\n// box. The path is symmetric about the middle of step 0, so that point is\n// always the middle of the panel and a half turn changes nothing.\nfunction aim(S) {\n  const n = min(floor(S.N), S.filled), re = S.re, im = S.im, sg = S.mirror ? -1 : 1, G = S.goal;\n  const stride = max(1, floor(n / 3000));\n  let sxx = 0, syy = 0, sxy = 0;\n  for (let i = 1; i \u003c= n; i += stride) {\n    const u = re[i] - 0.5, v = sg * im[i];\n    sxx += u * u;\n    syy += v * v;\n    sxy += u * v;\n  }\n  let ang = atan2(G.ai, G.ar);\n  const spread = sxx + syy, aniso = spread > 0 ? hypot(sxx - syy, 2 * sxy) / spread : 0;\n  if (aniso > 0.12 || n \u003c 40) {\n    const a = PI / 2 - 0.5 * atan2(2 * sxy, sxx - syy), da = a - ang;\n    ang += da - PI * round(da / PI);\n  }\n  const ca = cos(ang), sa = sin(ang);\n  let mu = 1e-6, mv = 1e-6;\n  for (let i = 1; i \u003c= n; i++) {\n    const u = re[i] - 0.5, v = sg * im[i];\n    mu = max(mu, abs(ca * u - sa * v));\n    mv = max(mv, abs(sa * u + ca * v));\n  }\n  const s = min(BW / (2 * mu), BH / (2 * mv), SMAX);\n  G.ar = s * ca;\n  G.ai = s * sa;\n}\n\nexport function setup(params) {\n  const S = {\n    re: new Float64Array(CAP + 2), im: new Float64Array(CAP + 2), re2: new Float64Array(CAP + 2), im2: new Float64Array(CAP + 2),\n    view: { ar: SMAX - 0.5, ai: 0.5 }, goal: { ar: SMAX - 0.5, ai: 0.5 },\n    hue: 0.5, speed: 1.5, n1: 2000.5, N: 1, L: 0, levels: 0, gap: 0, offset: 0, xh: 0.5, num: 0.5, mirror: false, filled: 0, orbit: [],\n    pal: new Uint8Array((BANDS + 2) * 3), idx: new Uint8Array(W * H), palHue: -1,\n  };\n  begin(S, 0);\n  params.s = S;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // 2,400 steps a half at 0, about 2,000 at 0.06, 120 at 1.\n  S.n1 = 2400 * 0.05 ** cl(k[3], 0, 1);\n  const num = cl(k[2], 0, 1);\n  // A new number: the same number of steps of it, from its first level.\n  if (abs(num - S.num) > 1e-9) begin(S, num);\n  // Below the level's start the path grows fast, from 1 step to n1 in\n  // INTRO seconds; from there the zoom runs at its steady pace.\n  const g = (d * S.speed) / 2, ln1 = log(S.n1);\n  S.L = S.L \u003c ln1 ? min(ln1, S.L + (g * ln1) / INTRO) : S.L + (g * 2 * Math.LN2) / ZOOM;\n  S.N = exp(S.L);\n  // A chain that has not come round in 16 levels starts over.\n  if (S.orbit.length > 16) begin(S, S.num);\n  for (let guard = 0; guard \u003c 8 && S.N >= min(S.n1 / S.xh, CAP); guard++) deeper(S);\n  fill(S, floor(S.N) + 1);\n  aim(S);\n  // Ease the view toward its aim in angle and size; shrink fast, so the\n  // ends never leave the box, and grow slowly.\n  const V = S.view, G = S.goal;\n  const la = log(hypot(V.ar, V.ai)), lg = log(hypot(G.ar, G.ai)), es = 1 - exp(-d / (lg \u003c la ? 0.05 : 0.5));\n  const aa = atan2(V.ai, V.ar), ag = atan2(G.ai, G.ar), da = ag - aa, ea = 1 - exp(-d / 0.6);\n  const a = aa + (da - PI * round(da / PI)) * ea, ca = cos(a), sa = sin(a);\n  // While the angle is still turning, the size the aim chose may not fit\n  // the angle the view stands at: shrink to fit that too.\n  const n = min(floor(S.N), S.filled), sg = S.mirror ? -1 : 1;\n  let mu = 1e-6, mv = 1e-6;\n  for (let i = 1; i \u003c= n; i++) {\n    const u = S.re[i] - 0.5, v = sg * S.im[i];\n    mu = max(mu, abs(ca * u - sa * v));\n    mv = max(mv, abs(sa * u + ca * v));\n  }\n  const r = min(exp(la + (lg - la) * es), BW / (2 * mu), BH / (2 * mv));\n  V.ar = r * ca;\n  V.ai = r * sa;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const pal = S.pal, idx = S.idx;\n  if (S.palHue !== S.hue) {\n    S.palHue = S.hue;\n    // Deep blue for the oldest steps, turning to cyan for the newest. Every\n    // colour has a channel at 255, so the old blue reads dim on the panel\n    // while each LED of the lace stands at full level.\n    for (let b = 0; b \u003c BANDS; b++) {\n      const q = b / (BANDS - 1), c = hsv(0.66 - 0.18 * q + S.hue, 1 - 0.25 * q, 1);\n      for (let j = 0; j \u003c 3; j++) pal[(b + 1) * 3 + j] = round(255 * c[j]);\n    }\n    for (let j = 0; j \u003c 3; j++) pal[(BANDS + 1) * 3 + j] = 255;\n  }\n  idx.fill(0);\n  const n = min(floor(S.N), S.filled), re = S.re, im = S.im, sg = S.mirror ? -1 : 1;\n  const ar = S.view.ar, ai = S.view.ai, step = hypot(ar, ai), head = n - max(2, floor(n * 0.012));\n  const put = (X, Y, c) => {\n    // The nearest LED of one checkerboard colour, so lit LEDs never touch\n    // side to side and each step stands as its own point.\n    const a = round((X + Y - 1) / 2), b = round((X - Y) / 2), u = a + b, v = a - b;\n    if (u >= 0 && u \u003c W && v >= 0 && v \u003c H) idx[v * W + u] = c;\n    // The newer half of the path is drawn with a nib two LEDs long on the\n    // diagonal, so the young curls stand bolder than the old lace inside.\n    if (c > BANDS / 2 && u + 1 \u003c W && v + 1 \u003c H && u >= -1 && v >= -1) idx[(v + 1) * W + u + 1] = c;\n  };\n  let px = -ar * 0.5, py = -ai * 0.5;\n  for (let i = 1; i \u003c= n; i++) {\n    const u = re[i] - 0.5, v = sg * im[i], X = ar * u - ai * v, Y = ai * u + ar * v;\n    const c = i > head ? BANDS + 1 : 1 + floor((i / (n + 1)) * BANDS);\n    // Long steps, while the path is young or the Steps knob is high, are\n    // drawn as dotted strokes.\n    if (step > 1.6) {\n      const k = Math.ceil(step / 0.8);\n      for (let j = 1; j \u003c k; j++) {\n        const sx = px + ((X - px) * j) / k, sy = py + ((Y - py) * j) / k;\n        put(32 + sx, 64 + sy, c);\n        put(32 - sx, 64 - sy, c);\n      }\n    }\n    put(32 + X, 64 + Y, c);\n    put(32 - X, 64 - Y, c);\n    px = X;\n    py = Y;\n  }\n  for (let i = 0; i \u003c W * H; i++) {\n    const o = idx[i] * 3;\n    display.setPixel(i % W, floor(i / W), pal[o], pal[o + 1], pal[o + 2]);\n  }\n}\n","durer-unfolding":"// ===== Patternflow pattern =====\n// Title:   Dürer's Unfolding\n// Family:  space\n// Idea:    A convex solid, its faces hatched like an engraving, lies flat as one net up the panel, folds shut hinge by hinge along a spanning tree of its edges, turns in the dark, shrinks away and comes back as the next solid, which turns and unfolds along its own tree into a new net that never overlaps itself.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dürer's unfolding problem (Albrecht Dürer, 1525; Geoffrey Shephard, 1975), edge unfoldings of the Platonic solids never overlap (Takashi Horiyama and Wataru Shoji, 2011), uniform spanning trees by loop-erased random walk (David Wilson, 1996), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Solid=0..5, Tree=0..1\n//\n// Knob 1: Hue. Each face is coloured by how many hinges lie between it and the root face the net is folded round: at 0 the root is azure and the faces furthest out pink, through blue and violet; turning it carries that third of the wheel round together, so at 0.5 the root is red orange and the far faces green. A face that comes round to orange or yellow keeps at least 0.8 of full value, so it never dims to brown. The plain backs of the faces, seen while the net folds, are a dim grey of the face's own colour, cross-hatched.\n// Knob 2: Speed. At 2 one solid's story takes 10.6 seconds: it grows out of a point in 0.4, turns for 0.9, unfolds hinge by hinge in 3, lies flat swaying for 2.4, folds shut in 2.6, turns for 0.9 and shrinks away in 0.4. A fresh start opens with the last hinges opening and folds at 3.4 seconds. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Solid. Which solid the round starts from, and the five after it follow in turn: 0 cube (6 squares, edges 26 LEDs long), 1 octahedron (8 triangles, 36), 2 dodecahedron (12 pentagons, 15), 3 icosahedron (20 triangles, 23), 4 truncated octahedron (8 hexagons and 6 squares, 13), 5 cuboctahedron (8 triangles and 6 squares, 21). Each net is scaled to fill a 60 by 124 LED box, so the edge length depends on the solid and the tree.\n// Knob 4: Tree. Which spanning tree of hinges the solid unfolds along, out of 8 different nets kept for each solid from 160 uniform random spanning trees: at 0 the net that fills the most of the box (the cube's covers 51% of the panel), at 1 the eighth (the cube's covers 32%). Every later round of the six solids takes the next tree.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, acos, atan2, hypot, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// How near a hue is to orange and yellow, 0 to 1.\nconst warm = (h) => max(0, 1 - abs(h - floor(h) - 0.11) / 0.13);\nconst sub = (p, q) => [p[0] - q[0], p[1] - q[1], p[2] - q[2]];\nconst dot = (p, q) => p[0] * q[0] + p[1] * q[1] + p[2] * q[2];\nconst crs = (p, q) => [p[1] * q[2] - p[2] * q[1], p[2] * q[0] - p[0] * q[2], p[0] * q[1] - p[1] * q[0]];\nconst nrm = (p) => {\n  const l = hypot(p[0], p[1], p[2]) || 1;\n  return [p[0] / l, p[1] / l, p[2] / l];\n};\n\n// The solids as vertex sets: every signed permutation of a triple, or only\n// the cyclic ones.\nfunction signed(b, all) {\n  const out = [], seen = new Set();\n  const ps = all ? [[0, 1, 2], [1, 2, 0], [2, 0, 1], [0, 2, 1], [2, 1, 0], [1, 0, 2]] : [[0, 1, 2], [1, 2, 0], [2, 0, 1]];\n  for (const p of ps)\n    for (let s = 0; s \u003c 8; s++) {\n      const v = p.map((i, k) => ((s >> k) & 1 ? -b[i] : b[i]) + 0);\n      const key = v.map((x) => x.toFixed(4)).join();\n      if (!seen.has(key)) seen.add(key), out.push(v);\n    }\n  return out;\n}\nconst PHI = (1 + sqrt(5)) / 2;\nconst SOLIDS = [\n  () => signed([1, 1, 1], 1),\n  () => signed([1, 0, 0], 1),\n  () => signed([1, 1, 1], 1).concat(signed([0, 1 / PHI, PHI], 0)),\n  () => signed([0, 1, PHI], 0),\n  () => signed([0, 1, 2], 1),\n  () => signed([1, 1, 0], 1),\n];\n\n// The faces of the hull: every plane through three vertices with all the\n// others on one side, its vertices ordered counter-clockwise from outside.\nfunction hull(V) {\n  const F = [], seen = new Set(), n = V.length;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = i + 1; j \u003c n; j++)\n      for (let k = j + 1; k \u003c n; k++) {\n        let c = crs(sub(V[j], V[i]), sub(V[k], V[i]));\n        if (hypot(c[0], c[1], c[2]) \u003c 1e-9) continue;\n        c = nrm(c);\n        const d = dot(c, V[i]), on = [];\n        let pos = 0, neg = 0;\n        for (let m = 0; m \u003c n; m++) {\n          const s = dot(c, V[m]) - d;\n          if (s > 1e-6) pos++;\n          else if (s \u003c -1e-6) neg++;\n          else on.push(m);\n        }\n        if (pos && neg) continue;\n        if (pos) c = [-c[0], -c[1], -c[2]];\n        const key = on.join();\n        if (seen.has(key)) continue;\n        seen.add(key);\n        const ce = [0, 1, 2].map((a) => on.reduce((s, m) => s + V[m][a], 0) / on.length);\n        const e1 = nrm(sub(V[on[0]], ce)), e2 = crs(c, e1);\n        const ang = (m) => {\n          const p = sub(V[m], ce);\n          return atan2(dot(p, e2), dot(p, e1));\n        };\n        on.sort((a, b) => ang(a) - ang(b));\n        F.push({ v: on, n: c, c: ce });\n      }\n  return F;\n}\n\n// A uniform random spanning tree of the face graph, by loop-erased random\n// walks (Wilson's algorithm): parent of each face, -1 at the root.\nfunction wilson(adj) {\n  const n = adj.length, inT = new Uint8Array(n), nx = new Int32Array(n).fill(-1);\n  inT[0] = 1;\n  for (let i = 1; i \u003c n; i++) {\n    let u = i;\n    while (!inT[u]) u = nx[u] = adj[u][floor(Math.random() * adj[u].length)];\n    for (u = i; !inT[u]; u = nx[u]) inT[u] = 1;\n  }\n  nx[0] = -1;\n  return nx;\n}\n\n// Lay a tree out flat. From the root outward, each face is turned about its\n// hinge into its parent's plane, on the far side of the hinge. Returns each\n// face's polygon in the root's plane, the BFS order, parents and depths.\nfunction layout(V, F, adj, par, root) {\n  const n = F.length, kids = F.map(() => []);\n  for (let f = 0; f \u003c n; f++) if (par[f] >= 0) kids[par[f]].push(f), kids[f].push(par[f]);\n  const P = new Int32Array(n).fill(-2), dep = new Int32Array(n), order = [root];\n  P[root] = -1;\n  for (let q = 0; q \u003c order.length; q++)\n    for (const g of kids[order[q]]) if (P[g] === -2) (P[g] = order[q]), (dep[g] = dep[order[q]] + 1), order.push(g);\n  const pos = new Array(n), f0 = F[root], e1 = nrm(sub(V[f0.v[0]], f0.c)), e2 = crs(f0.n, e1);\n  pos[root] = f0.v.map((m) => {\n    const p = sub(V[m], f0.c);\n    return [dot(p, e1), dot(p, e2)];\n  });\n  for (const f of order.slice(1)) {\n    const p = P[f], pf = F[p], ff = F[f], [a, b] = ff.v.filter((m) => pf.v.includes(m));\n    const pa = pos[p][pf.v.indexOf(a)], pb = pos[p][pf.v.indexOf(b)], ux = pb[0] - pa[0], uy = pb[1] - pa[1], ul = hypot(ux, uy);\n    let wx = -uy / ul, wy = ux / ul, cx = 0, cy = 0;\n    for (const q of pos[p]) (cx += q[0]), (cy += q[1]);\n    if ((cx / pos[p].length - pa[0]) * wx + (cy / pos[p].length - pa[1]) * wy > 0) (wx = -wx), (wy = -wy);\n    const u = nrm(sub(V[b], V[a])), r = sub(ff.c, V[a]), t = dot(r, u), w = nrm([r[0] - t * u[0], r[1] - t * u[1], r[2] - t * u[2]]);\n    pos[f] = ff.v.map((m) => {\n      const q = sub(V[m], V[a]), s = dot(q, u), h = dot(q, w);\n      return [pa[0] + (s * ux) / ul + h * wx, pa[1] + (s * uy) / ul + h * wy];\n    });\n  }\n  return { pos, order, P, dep, e1, e2 };\n}\n\n// The turn of the net and the LEDs per unit that fit it into the box: K\n// turns tried over half a circle, then a finer look round the best.\nconst BOXW = 60, BOXH = 124;\nfunction fitNet(pos, K = 48) {\n  let best = { s: 0 };\n  const tryA = (a) => {\n    const c = cos(a), s = sin(a);\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (const poly of pos)\n      for (const [x, y] of poly) {\n        const X = c * x - s * y, Y = s * x + c * y;\n        (x0 = min(x0, X)), (x1 = max(x1, X)), (y0 = min(y0, Y)), (y1 = max(y1, Y));\n      }\n    const sc = min(BOXW / (x1 - x0), BOXH / (y1 - y0));\n    if (sc > best.s) best = { s: sc, a, cx: (x0 + x1) / 2, cy: (y0 + y1) / 2 };\n  };\n  for (let k = 0; k \u003c K; k++) tryA((k / K) * PI);\n  const a0 = best.a;\n  for (let k = -6; k \u003c= 6; k++) tryA(a0 + (k / 6) * (PI / K));\n  return best;\n}\n\n// Two convex polygons of the net overlap when no edge of either separates\n// them by less than a hair: neighbours along a hinge only touch. Run on\n// 20,000 uniform random trees of each of the six solids it found no net\n// that overlaps, as Horiyama and Shoji proved for the Platonic ones; on the\n// truncated icosahedron it finds about one in a hundred (47 and 51 of\n// 5,000 in two runs), so it does see an overlap where there is one.\n// The corners round each solid vertex in those nets leave gaps that add up\n// to 720 degrees, Descartes' total defect, within 8e-13 degrees.\nfunction overlap(A, B) {\n  for (const poly of [A, B])\n    for (let i = 0; i \u003c poly.length; i++) {\n      const p = poly[i], q = poly[(i + 1) % poly.length], ax = q[1] - p[1], ay = p[0] - q[0];\n      let a0 = 1e9, a1 = -1e9, b0 = 1e9, b1 = -1e9;\n      for (const v of A) (a0 = min(a0, v[0] * ax + v[1] * ay)), (a1 = max(a1, v[0] * ax + v[1] * ay));\n      for (const v of B) (b0 = min(b0, v[0] * ax + v[1] * ay)), (b1 = max(b1, v[0] * ax + v[1] * ay));\n      if (min(a1, b1) - max(a0, b0) \u003c 1e-6 * hypot(ax, ay)) return false;\n    }\n  return true;\n}\n\n// Trees tried per solid and kept per solid.\nconst TRIES = 160, KEEP = 8;\nfunction buildSolid(S, k) {\n  const V = SOLIDS[k](), F = hull(V), n = F.length, em = new Map();\n  F.forEach((f, fi) =>\n    f.v.forEach((a, j) => {\n      const b = f.v[(j + 1) % f.v.length], key = min(a, b) * 64 + max(a, b);\n      if (!em.has(key)) em.set(key, []);\n      em.get(key).push(fi);\n    }),\n  );\n  const adj = F.map(() => []);\n  for (const [p, q] of em.values()) adj[p].push(q), adj[q].push(p);\n  let area = 0;\n  for (const f of F)\n    for (let j = 1; j + 1 \u003c f.v.length; j++) {\n      const c = crs(sub(V[f.v[j]], V[f.v[0]]), sub(V[f.v[j + 1]], V[f.v[0]]));\n      area += hypot(c[0], c[1], c[2]) / 2;\n    }\n  // Sample trees, drop nets already seen (same face-centre distances from\n  // the middle), rank the rest by how much of the box a rough fit fills,\n  // and keep the best that do not overlap.\n  const cand = [], sigs = new Set();\n  for (let t = 0; t \u003c TRIES; t++) {\n    const par = wilson(adj), L = layout(V, F, adj, par, 0), fit = fitNet(L.pos, 12);\n    const cs = L.pos.map((p) => [p.reduce((s, q) => s + q[0], 0) / p.length, p.reduce((s, q) => s + q[1], 0) / p.length]);\n    const gx = cs.reduce((s, q) => s + q[0], 0) / n, gy = cs.reduce((s, q) => s + q[1], 0) / n;\n    const sig = cs.map((q) => hypot(q[0] - gx, q[1] - gy).toFixed(3)).sort().join();\n    if (sigs.has(sig)) continue;\n    sigs.add(sig);\n    cand.push({ par, L, cov: (area * fit.s * fit.s) / N });\n  }\n  cand.sort((a, b) => b.cov - a.cov);\n  const trees = [];\n  for (const c of cand) {\n    if (trees.length === KEEP) break;\n    let bad = false;\n    for (let i = 0; i \u003c n && !bad; i++) for (let j = i + 1; j \u003c n && !bad; j++) bad = overlap(c.L.pos[i], c.L.pos[j]);\n    S.tested++;\n    if (bad) {\n      S.overlaps++;\n      continue;\n    }\n    c.fit = fitNet(c.L.pos);\n    c.cov = (area * c.fit.s * c.fit.s) / N;\n    trees.push(makeTree(V, F, adj, c));\n  }\n  trees.sort((a, b) => b.cov - a.cov);\n  return { V, F, n, trees };\n}\n\n// A kept tree, rooted at the face nearest the middle of its net, with what\n// the fold needs: each face's hinge, the angle that lays it flat, and the\n// turn from solid to screen that stands the net up the panel.\nfunction makeTree(V, F, adj, c) {\n  const n = F.length, { fit } = c;\n  let root = 0, bd = 1e9;\n  const ca = cos(fit.a), sa = sin(fit.a);\n  c.L.pos.forEach((p, f) => {\n    let x = 0, y = 0;\n    for (const q of p) (x += q[0] / p.length), (y += q[1] / p.length);\n    const d = hypot(ca * x - sa * y - fit.cx, sa * x + ca * y - fit.cy);\n    if (d \u003c bd) (bd = d), (root = f);\n  });\n  const L = layout(V, F, adj, c.par, root), f2 = fitNet(L.pos), s = f2.s, c2 = cos(f2.a), s2 = sin(f2.a);\n  const f0 = F[root];\n  // Solid to screen: x and y along the net's turned frame, z out of the root face.\n  const Q = [0, 1, 2].map((r) => [0, 1, 2].map((k) => s * (r === 0 ? c2 * L.e1[k] - s2 * L.e2[k] : r === 1 ? s2 * L.e1[k] + c2 * L.e2[k] : f0.n[k])));\n  const o = Q.map((row, r) => -dot(row, f0.c) - (r === 0 ? f2.cx * s : r === 1 ? f2.cy * s : 0));\n  const ax = [], an = [], phi = new Float64Array(n), hv = [];\n  let maxD = 0;\n  for (let f = 0; f \u003c n; f++) {\n    maxD = max(maxD, L.dep[f]);\n    const ff = F[f];\n    let a, b;\n    if (f === root) (a = ff.v[0]), (b = ff.v[1]);\n    else [a, b] = ff.v.filter((m) => F[L.P[f]].v.includes(m));\n    const u = nrm(sub(V[b], V[a]));\n    ax[f] = [V[a], u];\n    if (f !== root) {\n      const np = F[L.P[f]].n, th = acos(cl(dot(ff.n, np), -1, 1)), r = rot(u, th), m = mul(r, ff.n);\n      phi[f] = dot(m, np) > 0.999 ? th : -th;\n    }\n    // The hatching is laid on each face from its hinge: each corner's\n    // distance from the hinge and along it, in LEDs (kept positive).\n    hv[f] = ff.v.map((m) => {\n      const q = sub(V[m], V[a]), t = dot(q, u);\n      return [s * hypot(q[0] - t * u[0], q[1] - t * u[1], q[2] - t * u[2]), s * t + 64];\n    });\n    an[f] = ff.n;\n  }\n  // Shut, the solid is brought nearer until it is 58 LEDs across.\n  const rc = max(...V.map((v) => hypot(v[0], v[1], v[2])));\n  return { root, order: L.order, P: L.P, dep: L.dep, maxD, Q, o, ax, an, phi, hv, s, cov: c.cov, pos: L.pos, zoom: min(1.8, 29 / (rc * s)) };\n}\n\n// Rotation matrices, row-major 3x3 as nested arrays.\nfunction rot(u, th) {\n  const c = cos(th), s = sin(th), t = 1 - c, [x, y, z] = u;\n  return [\n    [c + t * x * x, t * x * y - s * z, t * x * z + s * y],\n    [t * x * y + s * z, c + t * y * y, t * y * z - s * x],\n    [t * x * z - s * y, t * y * z + s * x, c + t * z * z],\n  ];\n}\nconst mul = (m, v) => [dot(m[0], v), dot(m[1], v), dot(m[2], v)];\nconst mm = (a, b) => a.map((row) => [0, 1, 2].map((k) => row[0] * b[0][k] + row[1] * b[1][k] + row[2] * b[2][k]));\n\n// The story of one solid, in seconds at Speed 2: grow out of a point, turn,\n// unfold, lie flat, fold, turn, shrink away. A fresh start opens on the net.\nconst GROW = 0.4, TURN = 0.9, UNF = 3, HOLD = 2.4, FOLD = 2.6, SHR = 0.4;\nconst CYC = GROW + TURN + UNF + HOLD + FOLD + TURN + SHR;\nconst T0 = GROW + TURN + UNF + HOLD - 3.4;\n// Each hinge swings over this share of the unfolding, the last starting at its end.\nconst SWING = 0.4;\n// The camera's distance in LEDs, the light (a unit vector toward it), and\n// the hatching: lines 1 LED wide at 45 degrees to each face's hinge, every\n// 2.1 LEDs, at HD of the face's colour, crossed at right angles where a face\n// turns from the light and on the plain backs. The map places this pattern\n// by the hatching: with no lines the window read detail 0.039; lines every\n// 2.8 LEDs along the hinge at 0.4 gave 0.071, and at 45 degrees with the net\n// held longer 0.122. Drift comes from the dark moment between two solids, so\n// it is the flat net's mean level: 0.351 at HD 0.4, 0.365 at 0.46.\nconst CAM = 170, LIGHT = nrm([-0.35, 0.45, 0.82]), HP = 3, HD = 0.46;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0.5, speed: 2, solidK: 0.5, treeK: 0.06, tau: T0,\n    solids: [], tested: 0, overlaps: 0,\n    zb: new Float32Array(N), id: new Int16Array(N), hb: new Float32Array(N), hc: new Float32Array(N),\n    cur: null, tr: null,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.solidK = cl(k[2], 0, 5);\n  S.treeK = cl(k[3], 0, 1);\n  S.tau += (d * S.speed) / 2;\n  const cyc = floor(S.tau / CYC), t = S.tau - cyc * CYC;\n  const si = (floor(S.solidK + 0.5) + cyc) % 6;\n  if (!S.solids[si]) S.solids[si] = buildSolid(S, si);\n  const sol = S.solids[si], tr = sol.trees[(min(KEEP - 1, floor(S.treeK * KEEP)) + floor(cyc / 6)) % sol.trees.length];\n  S.cur = sol;\n  S.tr = tr;\n  // How open the net is, 0 shut to 1 flat, its scale, and the turn.\n  let open = 0, g = 1;\n  const t1 = GROW + TURN, t2 = t1 + UNF, t3 = t2 + HOLD, t4 = t3 + FOLD, t5 = t4 + TURN;\n  if (t \u003c GROW) g = ease(t / GROW);\n  else if (t \u003c t1) open = 0;\n  else if (t \u003c t2) open = (t - t1) / UNF;\n  else if (t \u003c t3) open = 1;\n  else if (t \u003c t4) open = 1 - (t - t3) / FOLD;\n  else if (t >= t5) g = 1 - ease((t - t5) / SHR);\n  // The turn slows to rest as the net opens and picks up as it shuts.\n  const inEnd = t1 + 0.6 * UNF, outStart = t3 + 0.4 * FOLD;\n  let th = 0;\n  if (t \u003c inEnd) th = 5.6 * (1 - t / inEnd) ** 2;\n  else if (t > outStart) th = -5.6 * ((t - outStart) / (CYC - outStart)) ** 2;\n  S.turn = rot(nrm([0.45 * sin(cyc * 2.3), 1, 0.45 * cos(cyc * 2.3)]), th);\n  // Lying flat, the net sways a little about the panel's long axis.\n  if (t >= t2 && t \u003c t3) S.turn = rot([0, 1, 0], 0.2 * sin((PI * (t - t2)) / HOLD) * sin((2 * PI * (t - t2)) / HOLD));\n  S.g = g;\n  // Each hinge in BFS order swings in its own window of the unfolding.\n  const n = sol.n, nh = n - 1, ang = new Float64Array(n);\n  let sum = 0, tot = 0;\n  for (let q = 1; q \u003c n; q++) {\n    const f = tr.order[q], st = nh > 1 ? ((q - 1) / (nh - 1)) * (1 - SWING) : 0, o = ease((open - st) / SWING);\n    ang[f] = o * tr.phi[f];\n    sum += o * abs(tr.phi[f]);\n    tot += abs(tr.phi[f]);\n  }\n  S.ang = ang;\n  S.shut = 1 - sum / tot;\n  // Shut, it is seen from a little above, so a turn always shows its top.\n  S.turn = mm(rot([1, 0, 0], 0.42 * S.shut), S.turn);\n}\n\n// Fill one screen triangle, nearest wins: q is 1 over depth, and the two\n// hatching coordinates are carried perspective-correct as h q.\nfunction tri(S, A, B, C, f) {\n  const area = (B[0] - A[0]) * (C[1] - A[1]) - (B[1] - A[1]) * (C[0] - A[0]);\n  if (abs(area) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(A[0], B[0], C[0]))), x1 = min(W - 1, floor(max(A[0], B[0], C[0])));\n  const y0 = max(0, floor(min(A[1], B[1], C[1]))), y1 = min(H - 1, floor(max(A[1], B[1], C[1])));\n  const { zb, id, hb, hc } = S;\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const w0 = ((B[0] - px) * (C[1] - py) - (B[1] - py) * (C[0] - px)) / area, w1 = ((C[0] - px) * (A[1] - py) - (C[1] - py) * (A[0] - px)) / area, w2 = 1 - w0 - w1;\n      if (w0 \u003c 0 || w1 \u003c 0 || w2 \u003c 0) continue;\n      const q = w0 * A[2] + w1 * B[2] + w2 * C[2], i = y * W + x;\n      if (q \u003c= zb[i]) continue;\n      zb[i] = q;\n      id[i] = f;\n      hb[i] = (w0 * A[3] * A[2] + w1 * B[3] * B[2] + w2 * C[3] * C[2]) / q;\n      hc[i] = (w0 * A[4] * A[2] + w1 * B[4] * B[2] + w2 * C[4] * C[2]) / q;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.tr) return;\n  const { cur: sol, tr, zb, id, hb, hc, ang, turn: R, g } = S;\n  const { V, F, n } = sol, { Q, o, order, P, ax, an, hv } = tr;\n  zb.fill(0);\n  id.fill(-1);\n  // Each face's motion from the shut solid: its parent's, then its own\n  // swing about its hinge, in BFS order from the root.\n  const MR = new Array(n), MT = new Array(n), col = new Array(n), side = new Int8Array(n), cross = new Uint8Array(n);\n  const sh = S.shut, cxv = o[0] * sh, cyv = o[1] * sh, czv = o[2] * sh, gz = g * (1 + (tr.zoom - 1) * sh);\n  for (const f of order) {\n    if (f === tr.root) (MR[f] = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]), (MT[f] = [0, 0, 0]);\n    else {\n      const p = P[f], [a, u] = ax[f], r = rot(u, ang[f]), ra = mul(r, a), pr = MR[p];\n      MR[f] = mm(pr, r);\n      const v = mul(pr, sub(a, ra));\n      MT[f] = [v[0] + MT[p][0], v[1] + MT[p][1], v[2] + MT[p][2]];\n    }\n    // Corners to the screen: solid, fold, stand up, centre, turn, scale, project.\n    const ff = F[f], pts = [];\n    for (let j = 0; j \u003c ff.v.length; j++) {\n      const p0 = mul(MR[f], V[ff.v[j]]), p1 = [p0[0] + MT[f][0], p0[1] + MT[f][1], p0[2] + MT[f][2]];\n      const v = [dot(Q[0], p1) + o[0] - cxv, dot(Q[1], p1) + o[1] - cyv, dot(Q[2], p1) + o[2] - czv], w = mul(R, v);\n      const q = 1 / (CAM - gz * w[2]);\n      pts.push([32 + CAM * gz * w[0] * q, 64 - CAM * gz * w[1] * q, q, hv[f][j][0], hv[f][j][1]]);\n    }\n    let a2 = 0;\n    for (let j = 0; j \u003c pts.length; j++) {\n      const p = pts[j], q = pts[(j + 1) % pts.length];\n      a2 += p[0] * q[1] - q[0] * p[1];\n    }\n    side[f] = a2 \u003c 0 ? 1 : 0;\n    for (let j = 1; j + 1 \u003c pts.length; j++) tri(S, pts[0], pts[j], pts[j + 1], f);\n    // Light on the face, in five steps.\n    const nn = mul(R, mul(Q, mul(MR[f], an[f]))), nl = hypot(nn[0], nn[1], nn[2]);\n    const lit = round(cl(0.3 + 0.85 * (dot(nn, LIGHT) / nl) * (side[f] ? 1 : -1), 0.3, 1) * 5) / 5;\n    const hue = 0.55 + S.hue + (0.32 * tr.dep[f]) / max(1, tr.maxD), wm = warm(hue);\n    col[f] = side[f] ? hsv(hue, 0.72, max(lit, 0.4 + 0.4 * wm)) : hsv(hue, 0.2, 0.4);\n    cross[f] = !side[f] || lit \u003c 0.8 ? 1 : 0;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const f = id[i], x = i % W, y = (i - x) / W;\n    let r = 0, gg = 0, b = 0;\n    if (f >= 0) {\n      const c = col[f], fr = x + 1 \u003c W ? id[i + 1] : -1, fd = y + 1 \u003c H ? id[i + W] : -1;\n      // An LED whose right or lower neighbour is another face is a dark seam.\n      let m = 1;\n      if ((fr >= 0 && fr !== f) || (fd >= 0 && fd !== f)) m = 0.08;\n      else if ((hb[i] + hc[i]) % HP \u003c 1.41 || (cross[f] && (hb[i] - hc[i] + 999) % HP \u003c 1.41)) m = HD;\n      (r = c[0] * m), (gg = c[1] * m), (b = c[2] * m);\n    }\n    display.setPixel(x, y, (255 * r) | 0, (255 * gg) | 0, (255 * b) | 0);\n  }\n}\n","gargoyle":"// ===== Patternflow pattern =====\n// Title:   Gargoyle\n// Family:  halloween\n// Idea:    A stone gargoyle juts from a cathedral ledge into a night storm, rain slanting across bruised purple clouds, and pours the gutter's water from its open jaws in a long arc that falls the whole height of the panel into a splashing puddle; every few seconds lightning flashes behind the spires, throws the stone into black silhouette with a bright rim, and leaves the gargoyle's eyes glowing poison green.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Rain=0..1, Lightning=0..1\n//\n// Knob 1: Hue. The storm's tint, kept to the cool side so the dark sky never reads brown: bruised violet at 0, blue at 0.25, teal at 0.5, sea green at 0.75 and a sickly green at 1. The stone takes a little of it; the water, the stained glass and the green eyes stay as they are.\n// Knob 2: Speed. At 2 a parcel of water takes 1.2 seconds from the jaws to the puddle and a raindrop crosses the panel in 0.8; at 0.2 the water hangs ten times slower, at 3 it falls half as fast again. The clouds scud on the same clock, and the gaps between strikes stretch up to 1.6 times at 0.2 and shrink by a fifth at 3. A flash always lasts the same half second.\n// Knob 3: Rain. At 0 a steady rain of 90 drops and a stream three LEDs thick that frays into drops on the way down; at 1 a downpour of 280 drops slanting harder, and a gush four LEDs thick at the jaws, thrown 5 LEDs further, that frays to eight and splashes twice as high.\n// Knob 4: Lightning. The first strike always comes 1.5 seconds after the start. Then at 0 one every 4.5 seconds on average, a bolt with at most one branch; at the opening 0.06 one every 4.3; at 1 one every 0.9 seconds, brighter, with up to five branches and a third return stroke. Each strike leaves the eyes glowing green for about 2.5 seconds.\n// Buttons: any button calls a strike at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst q20 = (v) => floor(v * 20) / 20;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// A fixed generator for the stonework, so the cathedral never changes;\n// Math.random is left for the weather.\nfunction prng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n// Smooth value noise on a 16 x 16 lattice that wraps, for the clouds.\nconst LAT = new Float32Array(256);\n{\n  const r = prng(11);\n  for (let i = 0; i \u003c 256; i++) LAT[i] = r();\n}\nfunction noise(x, y) {\n  const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi, u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);\n  const a = LAT[(yi & 15) * 16 + (xi & 15)], b = LAT[(yi & 15) * 16 + ((xi + 1) & 15)];\n  const c = LAT[((yi + 1) & 15) * 16 + (xi & 15)], d = LAT[((yi + 1) & 15) * 16 + ((xi + 1) & 15)];\n  return mix(mix(a, b, u), mix(c, d, u), v);\n}\n\n// What each LED is: sky, the far tower, a near pinnacle, the near wall and\n// ledge, the gargoyle, its open mouth, the street, the puddle, stained glass.\nconst SKY = 0, FAR = 1, PIN = 2, WALL = 3, GARG = 4, MOUTH = 5, STREET = 6, POOL = 7, GLASS = 8;\n// The water leaves the jaws here; the street's top row; the puddle.\nconst MX = 34.5, MY = 25, GROUND = 120, PX = 51, PY = 123.5, PRX = 13, PRY = 3.6;\n// The eye, two LEDs on the head.\nconst EYE = [20 * W + 29, 20 * W + 30];\n// Water: gravity and the jet's speed out of the jaws at Speed 2, in LEDs.\nconst G = 150, VX = 14, VY = -6, WIND = 3;\n// Raindrops on the panel at Rain 0 and at 1, and their fall in LEDs a second.\nconst RAIN0 = 90, RAIN1 = 280, FALL = 165;\n// Where a new drop starts: far enough left that its slant brings it in.\nconst spawnX = (vx) => -((vx / FALL) * H) + (W + (vx / FALL) * H) * Math.random();\n\nconst inEl = (x, y, cx, cy, rx, ry) => ((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2 \u003c 1;\nfunction inCap(x, y, ax, ay, bx, by, r) {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return hypot(x - ax - t * dx, y - ay - t * dy) \u003c r;\n}\nfunction inPoly(x, y, P) {\n  let c = false;\n  for (let i = 0, j = P.length - 2; i \u003c P.length; j = i, i += 2)\n    if (P[i + 1] > y !== P[j + 1] > y && x \u003c ((P[j] - P[i]) * (y - P[i + 1])) / (P[j + 1] - P[i + 1]) + P[i]) c = !c;\n  return c;\n}\n// The gargoyle, crouched on the ledge facing right: haunch, back, chest,\n// neck, head, snout and jaw, horn and ear, legs, and a folded bat wing.\nconst WING = [17, 24.5, 14, 19, 10.5, 13.5, 10, 18, 6.8, 14.5, 6, 19.5, 2.6, 17.5, 3.4, 24, 8, 27.5];\nfunction gargoyle(x, y) {\n  if (inPoly(x, y, [27.4, 24.3, 34.8, 23.7, 34.3, 26.1, 27.6, 25.7])) return MOUTH;\n  const body =\n    inEl(x, y, 9, 31.5, 7.5, 6.5) || inCap(x, y, 9, 28, 20, 26.5, 5) || inEl(x, y, 21, 29.5, 4, 5) ||\n    inCap(x, y, 22, 26, 26.5, 22.5, 3.3) || inEl(x, y, 28, 21.5, 4.2, 3.6) || inCap(x, y, 29, 21.6, 34.2, 22.6, 1.7) ||\n    inCap(x, y, 27.5, 26.4, 32.8, 27.2, 1.2) || inPoly(x, y, [25.2, 19.5, 27.6, 18.6, 22, 11.5]) || inPoly(x, y, [29, 18.8, 31, 19.2, 31.6, 14.6]) ||\n    inCap(x, y, 21.5, 32, 22.5, 37, 2.1) || inEl(x, y, 23.6, 37.4, 2.7, 1.3) || inCap(x, y, 5.5, 33, 7.5, 37.2, 2.4) ||\n    inEl(x, y, 9.2, 37.6, 3, 1) || inPoly(x, y, WING);\n  return body ? GARG : -1;\n}\n\nexport function setup(params) {\n  const kind = new Uint8Array(N), tone = new Float32Array(N), rnd = prng(5);\n  const blk = new Float32Array(64);\n  for (let i = 0; i \u003c 64; i++) blk[i] = 0.42 + 0.16 * rnd();\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, cx = x + 0.5, cy = y + 0.5;\n      let k = SKY, t = 0;\n      // The far tower: a spire with crockets every 8 rows on a square tower,\n      // corner pinnacles where they meet.\n      const ax = abs(cx - 52);\n      if (y >= 72 && ax \u003c= 6.5) k = FAR;\n      else if (y >= 12 && y \u003c 72 && ax \u003c= 0.6 + (5.4 * (y - 12)) / 60 + ((y - 12) % 8 \u003c 2 ? 1 : 0)) k = FAR;\n      else if (y >= 62 && y \u003c 72 && (abs(cx - 45.5) \u003c= ((y - 62) * 1.2) / 10 || abs(cx - 58.5) \u003c= ((y - 62) * 1.2) / 10)) k = FAR;\n      // Two near pinnacles on the parapet, then the parapet, the ledge\n      // and the wall with its blocks.\n      for (const [px, tip, hw] of [[4.5, 1, 4.2], [20, 4, 3.2]]) {\n        if (y >= tip && y \u003c 30) {\n          const u = y - tip, w = u \u003c 3 ? (u === 1 ? 1.4 : 0.6) : 0.5 + (hw * (u - 3)) / (27 - tip) + (u % 5 === 3 ? 1 : 0);\n          if (abs(cx - px) \u003c= w) (k = PIN), (t = cx \u003c px ? 0.66 : 0.42);\n        }\n      }\n      if (y >= 30 && y \u003c 38 && x \u003c= 22) (k = WALL), (t = y >= 32 && y \u003c= 35 && x % 5 >= 2 && x % 5 \u003c= 3 ? 0.08 : 0.5);\n      if (y >= 38 && y \u003c 42 && x \u003c= 24) (k = WALL), (t = [0.85, 0.62, 0.45, 0.25][y - 38]);\n      if (y >= 42 && y \u003c GROUND && x \u003c= 14) {\n        k = WALL;\n        const row = floor((y - 42) / 6), bx = x + (row & 1 ? 4 : 0);\n        t = (y - 42) % 6 === 5 || bx % 8 === 7 ? 0.22 : blk[(row * 3 + floor(bx / 8)) & 63];\n        if (x === 14) t *= 0.6;\n        // A lancet window with a pointed head and diamond leading.\n        const wy = y - 58, hwin = wy \u003c 0 ? -1 : wy \u003c 6 ? 3 * sqrt(1 - ((6 - wy) / 6.5) ** 2) - 0.3 : 3;\n        if (y \u003c= 92 && abs(cx - 7.5) \u003c= hwin) (k = GLASS), (t = (x + y) % 4 === 0 || (x - y + 400) % 4 === 0 ? 0 : 1 + ((floor((x + y) / 4) + floor((x - y + 400) / 4)) % 3));\n        else if (y \u003c= 93 && abs(cx - 7.5) \u003c= hwin + 1.2 && wy >= -1) t = 0.75;\n      }\n      // Cobbles in rows two LEDs deep, wider toward us, each row offset by\n      // half a stone, the top of each stone wet and lighter.\n      if (y >= GROUND) {\n        const row = (y - GROUND) >> 1, sw = 3 + (row >> 1), sx = x + (row & 1 ? sw >> 1 : 0);\n        k = STREET;\n        t = sx % sw === 0 ? 0.06 : (y - GROUND) & 1 ? 0.16 : 0.27 + 0.08 * ((floor(sx / sw) * 5 + row) % 3 === 0);\n      }\n      if (y >= GROUND && inEl(cx, cy, PX, PY, PRX, PRY)) k = POOL;\n      const g = gargoyle(cx, cy);\n      if (g >= 0) k = g;\n      (kind[p] = k), (tone[p] = t);\n    }\n  // The gargoyle's stone shaded by how deep each LED lies inside it (a\n  // chamfer distance) and which way the edge faces: lit from the upper left\n  // in four steps; the wing ribs and the mouth dark, teeth pale.\n  const d = new Float32Array(N);\n  for (let p = 0; p \u003c N; p++) d[p] = kind[p] === GARG || kind[p] === MOUTH ? 99 : 0;\n  for (let y = 1; y \u003c H - 1; y++) for (let x = 1; x \u003c W - 1; x++) { const p = y * W + x; d[p] = min(d[p], d[p - 1] + 1, d[p - W] + 1, d[p - W - 1] + 1.4, d[p - W + 1] + 1.4); }\n  for (let y = H - 2; y > 0; y--) for (let x = W - 2; x > 0; x--) { const p = y * W + x; d[p] = min(d[p], d[p + 1] + 1, d[p + W] + 1, d[p + W + 1] + 1.4, d[p + W - 1] + 1.4); }\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (kind[p] !== GARG) continue;\n      const gx = min(d[p + 1], 4) - min(d[p - 1], 4), gy = min(d[p + W], 4) - min(d[p - W], 4), gl = hypot(gx, gy) || 1;\n      const face = d[p] \u003c 3.5 ? (0.55 * gx + 0.8 * gy) / gl : 0, lit = 0.6 + 0.4 * face * (1 - min(d[p], 3) / 4);\n      tone[p] = [0.32, 0.48, 0.64, 0.82][cl(floor(lit * 4 - 0.6), 0, 3)];\n    }\n  const rib = (ax, ay, bx, by) => {\n    for (let s = 0; s \u003c= 20; s++) {\n      const p = floor(mix(ay, by, s / 20)) * W + floor(mix(ax, bx, s / 20));\n      if (kind[p] === GARG) tone[p] = 0.2;\n    }\n  };\n  rib(16, 24, 10.5, 14.5), rib(15.5, 24.5, 7, 15.5), rib(15, 25, 3, 18.5);\n  for (let x = 28; x \u003c= 34; x += 2) {\n    if (kind[24 * W + x] === MOUTH) (tone[24 * W + x] = 1), (kind[24 * W + x] = GARG);\n    if (kind[25 * W + x + 1] === MOUTH) (tone[25 * W + x + 1] = 1), (kind[25 * W + x + 1] = GARG);\n  }\n  for (const p of EYE) tone[p] = 0.06;\n  tone[19 * W + 29] = tone[19 * W + 30] = 0.9;\n  // The trough along the gargoyle's back that carries the gutter's water to\n  // its jaws: the top LED of its stone in each column from the wing to the head.\n  const trough = [];\n  for (let x = 17; x \u003c= 26; x++)\n    for (let y = 14; y \u003c 40; y++)\n      if (inCap(x + 0.5, y + 0.5, 9, 28, 20, 26.5, 5) || inCap(x + 0.5, y + 0.5, 22, 26, 26.5, 22.5, 3.3)) {\n        if (kind[y * W + x] === GARG) trough.push(y * W + x);\n        break;\n      }\n  // The puddle's far edge, where it meets the cobbles, catches the light.\n  for (let p = W; p \u003c N; p++) if (kind[p] === POOL && kind[p - W] !== POOL) tone[p] = 1;\n  // Stone that touches the sky catches the flash behind it.\n  const rim = new Uint8Array(N);\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, k = kind[p];\n      if (k === SKY || k >= STREET) continue;\n      if (kind[p - W] === SKY || kind[p + 1] === SKY || kind[p - 1] === SKY) rim[p] = 1;\n    }\n  params.s = {\n    kind, tone, rim, trough,\n    hue: 0, speed: 2, rain: 0, bolt: 0.06, t: 0, clock: 0, flow: 0,\n    landX: 50, strikeAt: -9, next: 1.5, strokes: [0], boltMask: new Float32Array(N), boltX: 40, amp: 0.6, eye: 0,\n    jet: new Float32Array(1200 * 4), nj: 0, emit: 0,\n    drops: new Float32Array(RAIN1 * 3), spl: new Float32Array(300 * 4), ns: 0,\n    rip: new Float32Array(48 * 3), nr: 0, ripAt: 0,\n    rgb: new Float32Array(N * 3), pal: new Float32Array(21 * 11 * 3), palH: -1, near: new Float32Array(W),\n  };\n  const S = params.s;\n  for (let i = 0; i \u003c RAIN1; i++) (S.drops[i * 3] = spawnX(28)), (S.drops[i * 3 + 1] = -8 + 136 * Math.random()), (S.drops[i * 3 + 2] = 0.8 + 0.4 * Math.random());\n  // The stream is already falling when the picture opens.\n  for (let i = 0; i \u003c 45; i++) water(S, 1 / 30);\n}\n\n// A new bolt: a jagged channel from above the panel down behind the far\n// tower or the wall, with branches; drawn into a mask the sky reads.\nfunction strike(S) {\n  const m = S.boltMask, n = 1 + floor(4 * S.bolt);\n  m.fill(0);\n  let x = 22 + 40 * Math.random(), y = -2;\n  S.boltX = x;\n  const end = 70 + 35 * Math.random(), lean = (Math.random() - 0.5) * 1.2;\n  const put = (px, py, v) => {\n    for (let dy = -1; dy \u003c= 1; dy++)\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        const xx = floor(px) + dx, yy = floor(py) + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n        const w = dx || dy ? v * 0.3 : v;\n        if (m[yy * W + xx] \u003c w) m[yy * W + xx] = w;\n      }\n  };\n  const seg = (x0, y0, x1, y1, v) => {\n    const s = ceil1(max(abs(x1 - x0), abs(y1 - y0)));\n    for (let i = 0; i \u003c= s; i++) put(mix(x0, x1, i / s), mix(y0, y1, i / s), v);\n  };\n  const forks = [];\n  while (y \u003c end) {\n    const nx = x + lean + (Math.random() - 0.5) * 5, ny = y + 2 + 3 * Math.random();\n    seg(x, y, nx, ny, 1);\n    if (forks.length \u003c n && Math.random() \u003c 0.12) forks.push([nx, ny, Math.random() \u003c 0.5 ? -1 : 1]);\n    (x = nx), (y = ny);\n  }\n  for (const [fx, fy, sg] of forks) {\n    let bx = fx, by = fy;\n    const len = 6 + floor(10 * Math.random());\n    for (let i = 0; i \u003c len; i++) {\n      const nx = bx + sg * (1 + 2 * Math.random()), ny = by + 1.5 + 2 * Math.random();\n      seg(bx, by, nx, ny, 0.6);\n      (bx = nx), (by = ny);\n    }\n  }\n  S.strokes = S.bolt > 0.5 ? [0, 0.16, 0.31] : [0, 0.16];\n  S.amp = 0.72 + 0.28 * S.bolt;\n  S.strikeAt = S.t;\n}\nconst ceil1 = (v) => Math.max(1, Math.ceil(v));\n\n// The water for h seconds of the story: parcels leave the jaws, fall under\n// gravity with a little wind and land in the puddle, throwing up splashes\n// and rings; the rain falls and rings the puddle too.\nfunction water(S, h) {\n  const jet = S.jet, rain = S.rain;\n  S.emit += h * (190 + 170 * rain);\n  while (S.emit >= 1 && S.nj \u003c 1200) {\n    S.emit--;\n    const o = S.nj++ * 4, gs = () => Math.random() + Math.random() - 1;\n    jet[o] = MX + 2 * Math.random() - 1;\n    jet[o + 1] = MY + (Math.random() - 0.5) * (2.2 + 2.2 * rain);\n    jet[o + 2] = VX * (1 + 0.3 * rain) + gs() * (2.2 + 1.6 * rain);\n    jet[o + 3] = VY + gs() * (1.2 + rain);\n  }\n  for (let i = 0; i \u003c S.nj; i++) {\n    const o = i * 4;\n    jet[o + 3] += G * h;\n    jet[o + 2] += WIND * h;\n    jet[o] += jet[o + 2] * h;\n    jet[o + 1] += jet[o + 3] * h;\n    const x = jet[o], y = jet[o + 1];\n    if (y >= GROUND + 1 || x > W + 4) {\n      if (inEl(x, y, PX, PY, PRX, PRY)) {\n        S.landX = mix(S.landX, x, 0.05);\n        const n = Math.random() \u003c 0.5 + 0.4 * rain ? 1 + floor(Math.random() * 2) : 0;\n        for (let k = 0; k \u003c n && S.ns \u003c 300; k++) {\n          const s = S.ns++ * 4;\n          (S.spl[s] = x), (S.spl[s + 1] = GROUND + 1), (S.spl[s + 2] = (Math.random() - 0.5) * 50), (S.spl[s + 3] = -(25 + 45 * Math.random()) * (1 + rain));\n        }\n        if (S.t >= S.ripAt) (S.ripAt = S.t + 0.12), ring(S, x, y);\n      }\n      // Removed by moving the last parcel into its slot.\n      S.nj--;\n      for (let k = 0; k \u003c 4; k++) jet[o + k] = jet[S.nj * 4 + k];\n      i--;\n    }\n  }\n  for (let i = 0; i \u003c S.ns; i++) {\n    const o = i * 4, sp = S.spl;\n    sp[o + 3] += G * h;\n    sp[o] += sp[o + 2] * h;\n    sp[o + 1] += sp[o + 3] * h;\n    if (sp[o + 1] > GROUND + 2) {\n      S.ns--;\n      for (let k = 0; k \u003c 4; k++) sp[o + k] = sp[S.ns * 4 + k];\n      i--;\n    }\n  }\n  const dr = S.drops, live = RAIN0 + floor((RAIN1 - RAIN0) * rain), vx = 28 + 34 * rain;\n  for (let i = 0; i \u003c RAIN1; i++) {\n    const o = i * 3;\n    dr[o] += vx * h * dr[o + 2];\n    dr[o + 1] += FALL * h * dr[o + 2];\n    if (dr[o + 1] > GROUND + 1 + 7 * ((i * 0.37) % 1)) {\n      if (i \u003c live && inEl(dr[o], dr[o + 1], PX, PY, PRX, PRY) && Math.random() \u003c 0.5) ring(S, dr[o], dr[o + 1]);\n      (dr[o] = spawnX(vx)), (dr[o + 1] = -6 - 6 * Math.random()), (dr[o + 2] = 0.8 + 0.4 * Math.random());\n    }\n  }\n  for (let i = 0; i \u003c S.nr; i++) {\n    S.rip[i * 3 + 2] += h;\n    if (S.rip[i * 3 + 2] > 0.55) {\n      S.nr--;\n      for (let k = 0; k \u003c 3; k++) S.rip[i * 3 + k] = S.rip[S.nr * 3 + k];\n      i--;\n    }\n  }\n}\nfunction ring(S, x, y) {\n  if (S.nr >= 48) return;\n  const o = S.nr++ * 3;\n  (S.rip[o] = x), (S.rip[o + 1] = y), (S.rip[o + 2] = 0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.rain = cl(k[2], 0, 1);\n  S.bolt = cl(k[3], 0, 1);\n  const h = (d * S.speed) / 2;\n  S.t += d;\n  S.clock += h;\n  S.flow += h;\n  water(S, h);\n  // Strikes: the first at 1.5 s, then gaps round the Lightning knob's mean.\n  if (S.t >= S.next || (input.btnPressed && input.btnPressed.some(Boolean))) {\n    strike(S);\n    S.next = S.t + mix(4.5, 0.9, S.bolt) * (0.7 + 0.6 * Math.random()) * min(2.5, 2 / S.speed) ** 0.5;\n  }\n  // The eyes kindle a quarter second after each strike and stay lit until two seconds after it, then fade.\n  const e = S.t - S.strikeAt;\n  S.eye = e \u003c 0.25 ? max(0, S.eye - d) : e \u003c 0.45 ? max(S.eye, sm(0.25, 0.45, e)) : e \u003c 2 ? 1 : 1 - sm(2, 3, e);\n}\n\n// How bright the strike is t seconds after it began: a spike for each return\n// stroke and an afterglow; and how strongly the channel itself shows.\nfunction flashAt(S, t) {\n  if (t \u003c 0 || t > 2) return [0, 0];\n  let spike = 0, chan = 0;\n  for (const s of S.strokes)\n    if (t >= s) (spike = max(spike, exp(-(t - s) / 0.05))), (chan = max(chan, exp(-(t - s) / 0.1)));\n  return [min(1, 0.7 * spike + 0.3 * exp(-t / 0.4)) * S.amp, chan];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { kind, tone, rim, rgb } = S;\n  const [flash, chan] = flashAt(S, S.t - S.strikeAt), fq = q20(flash);\n  const skyH = 0.78 - 0.45 * S.hue, lite = hsv(skyH, 0.28, 0.86), stone = hsv(skyH - 0.04, 0.16, 0.62);\n  const dark = 1 - min(1, flash * 2.4), far = hsv(skyH, 0.55, 0.1);\n  const glass = [[0.04, 0.02, 0.05], [1, 0.74, 0.16], [0.86, 0.1, 0.2], [0.36, 0.3, 0.95]];\n  const flick = 0.62 + 0.08 * floor(3 * noise(S.clock * 3, 4.5));\n  // The sky's colours for this hue by brightness step and cloud step, and\n  // how much of the flash each column gets from the bolt's place.\n  const pal = S.pal, near = S.near;\n  if (S.palH !== skyH) {\n    S.palH = skyH;\n    for (let vi = 0; vi \u003c= 20; vi++) for (let ci = 0; ci \u003c= 10; ci++) pal.set(hsv(skyH + 0.003 * ci, 0.72 - 0.03 * ci, vi / 20), (vi * 11 + ci) * 3);\n  }\n  for (let x = 0; x \u003c W; x++) near[x] = 0.55 + 0.45 * exp(-((x - S.boltX) ** 2) / 500);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = p * 3, k = kind[p];\n      let r, g, b;\n      if (k === SKY || k === POOL) {\n        // Bruised clouds drifting right, in 1/20 steps, lighter toward the\n        // street; the puddle shows the sky over it, darker.\n        const yy = k === POOL ? 2 * GROUND - y - 30 : y;\n        const c1 = noise(x / 17 + S.clock * 0.3, yy / 11 + 1 + S.clock * 0.04), c2 = noise(x / 8 + S.clock * 0.55 + 5, yy / 6);\n        const ci = floor(cl((0.7 * c1 + 0.3 * c2 - 0.32) * 1.8, 0, 0.99) * 10), cq = ci / 10;\n        const vi = floor((0.15 + 0.13 * (yy / H) + 0.22 * cq * cq) * (k === POOL ? 15 : 20)), po = (vi * 11 + ci) * 3;\n        const f = q20(fq * near[x] * (0.8 + 0.3 * cq)) * (k === POOL ? 0.6 : 1);\n        (r = mix(pal[po], lite[0], f)), (g = mix(pal[po + 1], lite[1], f)), (b = mix(pal[po + 2], lite[2], f));\n        const bl = k === SKY ? S.boltMask[p] * chan : 0;\n        if (bl > 0.05) (r = mix(r, 1, bl)), (g = mix(g, 1, bl)), (b = mix(b, 1, bl));\n        // In the puddle: the lit far edge, and the falling stream mirrored\n        // under the place it lands.\n        if (k === POOL) {\n          const e = tone[p] ? 0.4 : abs(x + 0.5 - S.landX) \u003c 1.6 ? 0.3 : 0;\n          if (e) (r = mix(r, 0.7, e)), (g = mix(g, 0.86, e)), (b = mix(b, 1, e));\n        }\n      } else if (k === FAR) {\n        (r = far[0] * dark), (g = far[1] * dark), (b = far[2] * dark);\n        if (rim[p]) (r += lite[0] * fq * 0.7), (g += lite[1] * fq * 0.7), (b += lite[2] * fq * 0.7);\n      } else if (k === GLASS) {\n        const c = glass[tone[p]], v = flick;\n        (r = c[0] * v), (g = c[1] * v), (b = c[2] * v);\n      } else if (k === STREET) {\n        const v = tone[p] * (1 + fq);\n        (r = stone[0] * v), (g = stone[1] * v), (b = stone[2] * v);\n      } else {\n        // Stone: lit dimly by the storm, black against the flash, its edges\n        // catching the light behind it.\n        const v = k === MOUTH ? 0.04 : tone[p] * (k === PIN ? 0.8 : 1), dk = k === PIN ? dark : mix(dark, 1, 0.25);\n        (r = stone[0] * v * dk), (g = stone[1] * v * dk), (b = stone[2] * v * dk);\n        if (rim[p]) (r += lite[0] * fq), (g += lite[1] * fq), (b += lite[2] * fq);\n      }\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n  const add = (x, y, c, v) => {\n    x = floor(x), y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    (rgb[o] = max(rgb[o], c[0] * v)), (rgb[o + 1] = max(rgb[o + 1], c[1] * v)), (rgb[o + 2] = max(rgb[o + 2], c[2] * v));\n  };\n  // The trough on its back: water glinting as it runs to the jaws.\n  const wat = [0.66, 0.86, 1];\n  S.trough.forEach((p, i) => add(p % W, floor(p / W), wat, (i - S.flow * 14) % 5 \u003c -3.5 || (i - S.flow * 14) % 5 > 3.5 ? 0.85 : 0.42));\n  // The puddle's rings, flattened by the angle we see it at.\n  for (let i = 0; i \u003c S.nr; i++) {\n    const cx = S.rip[i * 3], cy = S.rip[i * 3 + 1], a = S.rip[i * 3 + 2], rr = 1 + a * 14, v = 0.6 - 0.15 * floor(a * 6);\n    for (let s = 0; s \u003c 24; s++) {\n      const x = cx + rr * cos((s * PI) / 12), y = cy + 0.3 * rr * sin((s * PI) / 12);\n      if (inEl(x, y, PX, PY, PRX, PRY)) add(x, y, lite, v);\n    }\n  }\n  // The stream: each parcel a streak over the way it came in the last frame,\n  // or at slow speeds over the way it comes in a frame at Speed 1.2, so the\n  // slowed stream still reads as water and not as beads.\n  const step = (1 / 30) * (max(1.2, S.speed) / 2), wc = [mix(0.72, 1, fq), mix(0.88, 1, fq), 1];\n  for (let i = 0; i \u003c S.nj; i++) {\n    const o = i * 4, x = S.jet[o], y = S.jet[o + 1], vx = S.jet[o + 2], vy = S.jet[o + 3];\n    const n = ceil1(abs(vy * step));\n    for (let s = 0; s \u003c n; s++) add(x - (vx * step * s) / n, y - (vy * step * s) / n, wc, s ? 0.7 : 0.92);\n  }\n  for (let i = 0; i \u003c S.ns; i++) add(S.spl[i * 4], S.spl[i * 4 + 1], wc, 0.8);\n  // Rain in front of it all, a bright head and a fainter tail along its slant.\n  const live = RAIN0 + floor((RAIN1 - RAIN0) * S.rain), vx = 28 + 34 * S.rain, rc = hsv(skyH, 0.22, 1), len = 4 + floor(S.speed / 1.5);\n  for (let i = 0; i \u003c live; i++) {\n    const o = i * 3, x = S.drops[o], y = S.drops[o + 1];\n    for (let s = 0; s \u003c len; s++) add(x - (vx / FALL) * s, y - s, rc, (s ? 0.34 : 0.55) + 0.3 * fq);\n  }\n  // The eyes, poison green, with a stepped glow round them.\n  if (S.eye > 0) {\n    const e = q20(S.eye), gc = [0.42, 1, 0.12];\n    for (let dy = -2; dy \u003c= 2; dy++)\n      for (let dx = -2; dx \u003c= 3; dx++) {\n        const r2 = hypot(dx - 0.5, dy), v = r2 \u003c 0.9 ? 1 : r2 \u003c 1.8 ? 0.4 : r2 \u003c 2.6 ? 0.18 : 0;\n        if (v) add(29 + dx, 20 + dy, gc, v * e);\n      }\n  }\n  for (let i = 0; i \u003c N; i++) display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","kempe-chains":"// ===== Patternflow pattern =====\n// Title:   Kempe Chains\n// Family:  cells\n// Idea:    A map of drifting countries is kept four-coloured as their borders change: when a new border puts two neighbours in one colour, the country takes a free colour if one is left, and if all four surround it a Kempe chain of two colours lights up, shows its links from capital to capital and swaps its colours to free one.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kempe chains (Alfred Kempe, 1879; the gap found by Percy Heawood, 1890), four colour theorem (Kenneth Appel and Wolfgang Haken, 1976), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Countries=15..40, Sizes=0..1\n//\n// Knob 1: Hue. Turns the four colours round the wheel together, a quarter apart: at 0 orange, green, azure and pink. At 0.25 each has moved on to the next, so every country wears another of the same four; at 0.5 orange and azure trade places, and so do green and pink.\n// Knob 2: Speed. How fast the stirring carries the countries. At 2 a capital moves at up to 14 LEDs a second, and with 15 countries a new border appears 2 to 3 times a second, a quarter to a third of them between two countries of one colour; at 0.2 everything drifts ten times slower, at 3 half as fast again. A repair shows in the same time at any Speed: 0.2 s of glow, 0.5 s of cross-fade, 0.3 s to cool.\n// Knob 3: Countries. How many countries share the panel, from 15 (each about 23 LEDs across) to 40 (about 14). With 15 there is a repair every 1.2 to 2 seconds and half of them or more need a chain; with 40 five or six a second, three in four with a chain.\n// Knob 4: Sizes. At 0 every capital has the same weight and the map is a Voronoi diagram, its largest country under twice the area of its smallest. Turning it up makes it a power diagram whose weights spread: at 1 the largest is 8 times the smallest with 15 countries and 18 times with 40, and a big country can border eight or nine others.\n\nconst W = 64, H = 128, N = W * H, M = 40;\nconst { floor, min, max, abs, sqrt, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A repair as the panel shows it, in seconds whatever the Speed: the\n// countries it touches glow, cross-fade to their new colours and cool.\nconst RISE = 0.2, CROSS = 0.5, FALL = 0.3, LIFE = RISE + CROSS + FALL;\n// Where four countries nearly meet at a point, the LED grid lets the border\n// between one pair and the border between the other flicker for a few\n// frames. A border counts for this long (in drift seconds) after it was last\n// seen, so the colouring is kept proper for both and a repair is not undone\n// by the next frame.\nconst HOLD = 0.4;\n// A capital's own wandering speed and the stirring's strength, in LEDs per\n// drift second.\nconst V0 = 2, FLOW = 10;\n\nexport function setup(params) {\n  const f = () => new Float32Array(M);\n  params.s = {\n    t: 0, clock: 0, n: 0, hue: 0, speed: 2, sizes: 0.06, started: false, plan: 0,\n    x: f(), y: f(), vx: f(), vy: f(), th: f(), om: f(), u: f(), w: f(), r: f(),\n    own: new Uint8Array(N), col: new Uint8Array(M).fill(255),\n    // seen: drift time each pair last shared a border; cur: sharing one this frame; act: counts for the colouring.\n    seen: new Float32Array(M * M).fill(-1e9), cur: new Uint8Array(M * M), act: new Uint8Array(M * M),\n    area: f(), cx: f(), cy: f(), dy2: f(),\n    // The colour each country fades from, how far into its repair it is, and how hard it glows.\n    from: new Float32Array(M * 3), age: new Float32Array(M).fill(LIFE), gl: f(),\n    pal: new Float32Array(12), fl: [0, 0], disp: new Float32Array(M * 3), ov: new Float32Array(N),\n    mark: new Uint8Array(M), queue: new Int16Array(M),\n    // Events still showing: chain links between capitals and the new border that started it.\n    ev: [],\n    stats: { frames: 0, proper: 0, repairs: 0, free: 0, swap1: 0, swap2: 0, local: 0, failed: 0, forget: 0, firstSwap: -1, chainSizes: 0 },\n  };\n}\n\nfunction addSeed(S, i) {\n  S.x[i] = 2 + Math.random() * (W - 4);\n  S.y[i] = 2 + Math.random() * (H - 4);\n  S.vx[i] = S.vy[i] = 0;\n  S.th[i] = Math.random() * TAU;\n  S.om[i] = 0.6 + 0.8 * Math.random();\n  S.u[i] = Math.random() * 2 - 1;\n  S.col[i] = 255;\n  S.age[i] = 0;\n  S.gl[i] = 0.3;\n  S.from.fill(0.08, 3 * i, 3 * i + 3);\n  for (let j = 0; j \u003c M; j++) S.seen[i * M + j] = S.seen[j * M + i] = -1e9;\n}\n\n// The stirring: a stream function of four box modes whose strengths rise\n// and fall out of step, so the map is sheared one way and then another and\n// neighbours keep changing. A box mode never flows through the frame.\nconst MODES = [[1, 2, 0.21, 0], [2, 3, 0.17, 2.1], [1, 3, 0.13, 4.2], [2, 1, 0.11, 1.3]];\nfunction flow(t, x, y, out) {\n  let u = 0, v = 0;\n  for (const [a, b, f, ph] of MODES) {\n    const A = FLOW * cos(TAU * f * t + ph), ka = (PI * a) / W, kb = (PI * b) / H, k = 1 / max(ka, kb);\n    u += A * k * kb * sin(ka * x) * cos(kb * y);\n    v -= A * k * ka * cos(ka * x) * sin(kb * y);\n  }\n  out[0] = u;\n  out[1] = v;\n}\n\n// Each capital wanders on a turning heading and is pushed off the others and\n// the frame by its size. A capital's size r is half the distance it keeps to\n// a neighbour; its power weight is r squared, so the border between two\n// touching countries falls where their two sizes meet.\nfunction move(S, ds, wander) {\n  const n = S.n, A = N / n, { x, y, vx, vy, th, om, u, w, r } = S;\n  for (let i = 0; i \u003c n; i++) {\n    const g = 1 + 0.82 * u[i] * S.sizes;\n    r[i] = 0.58 * sqrt(A * g);\n    w[i] = 0.3364 * A * (g - 1);\n  }\n  if (ds \u003c= 0) return;\n  for (let i = 0; i \u003c n; i++) {\n    let fx = 0, fy = 0;\n    if (wander) {\n      // The heading turns on two slow waves of the capital's own, so the\n      // whole drift follows from where things are: the opening can look ahead.\n      const a = th[i] + 1.6 * sin(0.53 * S.t * om[i] + 5 * th[i]) + 0.9 * sin(1.31 * S.t + 3 * om[i]);\n      fx = V0 * cos(a);\n      fy = V0 * sin(a);\n      flow(S.t, x[i], y[i], S.fl);\n      fx += S.fl[0];\n      fy += S.fl[1];\n    }\n    for (let j = 0; j \u003c n; j++) {\n      if (j === i) continue;\n      const dx = x[i] - x[j], dy = y[i] - y[j], d = sqrt(dx * dx + dy * dy) + 1e-6, rr = r[i] + r[j];\n      if (d \u003c rr) {\n        const k = (3.5 * (rr - d)) / d;\n        fx += dx * k;\n        fy += dy * k;\n      }\n    }\n    const m = 0.7 * r[i];\n    if (x[i] \u003c m) fx += 3.5 * (m - x[i]);\n    if (x[i] > W - m) fx -= 3.5 * (x[i] - W + m);\n    if (y[i] \u003c m) fy += 3.5 * (m - y[i]);\n    if (y[i] > H - m) fy -= 3.5 * (y[i] - H + m);\n    const e = min(1, ds * 2.5);\n    vx[i] += (fx - vx[i]) * e;\n    vy[i] += (fy - vy[i]) * e;\n  }\n  for (let i = 0; i \u003c n; i++) {\n    x[i] = cl(x[i] + vx[i] * ds, 0.5, W - 0.5);\n    y[i] = cl(y[i] + vy[i] * ds, 0.5, H - 0.5);\n  }\n}\n\n// The map: every LED belongs to the capital of least power distance\n// |p - c|^2 - w. Two countries share a border when two LEDs side by side\n// (not only corner to corner) belong to them.\nfunction map(S) {\n  const n = S.n, { x, y, w, own, cur, seen, act, area, cx, cy, dy2 } = S;\n  for (let y0 = 0, p = 0; y0 \u003c H; y0++) {\n    const py = y0 + 0.5;\n    for (let i = 0; i \u003c n; i++) dy2[i] = (py - y[i]) * (py - y[i]) - w[i];\n    for (let x0 = 0; x0 \u003c W; x0++, p++) {\n      const px = x0 + 0.5;\n      let best = 1e9, bi = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = px - x[i], v = dx * dx + dy2[i];\n        if (v \u003c best) (best = v), (bi = i);\n      }\n      own[p] = bi;\n    }\n  }\n  cur.fill(0);\n  area.fill(0);\n  cx.fill(0);\n  cy.fill(0);\n  for (let y0 = 0, p = 0; y0 \u003c H; y0++)\n    for (let x0 = 0; x0 \u003c W; x0++, p++) {\n      const o = own[p];\n      area[o]++;\n      cx[o] += x0 + 0.5;\n      cy[o] += y0 + 0.5;\n      if (x0 \u003c W - 1 && own[p + 1] !== o) cur[o * M + own[p + 1]] = cur[own[p + 1] * M + o] = 1;\n      if (y0 \u003c H - 1 && own[p + W] !== o) cur[o * M + own[p + W]] = cur[own[p + W] * M + o] = 1;\n    }\n  for (let i = 0; i \u003c n; i++) {\n    if (area[i]) (cx[i] /= area[i]), (cy[i] /= area[i]);\n    else (cx[i] = x[i]), (cy[i] = y[i]);\n  }\n  act.fill(0);\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c n; j++) {\n      const k = i * M + j;\n      if (cur[k]) seen[k] = S.t;\n      if (i !== j && S.t - seen[k] \u003c HOLD) act[k] = 1;\n    }\n}\n\n// Colours used round country v, as four bits (uncoloured neighbours ignored).\nfunction used(S, v) {\n  let m = 0;\n  for (let j = 0; j \u003c S.n; j++) if (S.act[v * M + j] && S.col[j] \u003c 4) m |= 1 \u003c\u003c S.col[j];\n  return m;\n}\n\n// The Kempe chain(s): every country reachable from the starts through\n// countries coloured a or b, never through v. Marks them in S.mark and\n// returns their indices.\nfunction chain(S, v, starts, a, b) {\n  const { mark, queue, col, act, n } = S;\n  mark.fill(0);\n  let h = 0, t = 0;\n  for (const s of starts) if (!mark[s]) (mark[s] = 1), (queue[t++] = s);\n  while (h \u003c t) {\n    const i = queue[h++];\n    for (let j = 0; j \u003c n; j++)\n      if (j !== v && !mark[j] && act[i * M + j] && (col[j] === a || col[j] === b)) (mark[j] = 1), (queue[t++] = j);\n  }\n  return Array.from(queue.subarray(0, t));\n}\n\nconst nbOf = (S, v, c) => {\n  const out = [];\n  for (let j = 0; j \u003c S.n; j++) if (S.act[v * M + j] && S.col[j] === c) out.push(j);\n  return out;\n};\n\n// One swap: for some pair of colours (a, b), the a/b chains through v's\n// a-coloured neighbours reach none of its b-coloured ones, so swapping a and b\n// on them leaves no a round v. Of the swaps that work, the one shown is the\n// longest chain of up to five countries, then the shortest longer one; a\n// chain of one country only when nothing else works.\nfunction single(S, xs) {\n  let best = null, score = 1e9;\n  for (const v of xs)\n    for (let a = 0; a \u003c 4; a++) {\n      const starts = nbOf(S, v, a);\n      if (!starts.length) continue;\n      for (let b = 0; b \u003c 4; b++) {\n        if (b === a) continue;\n        const comp = chain(S, v, starts, a, b);\n        let ok = true;\n        for (let j = 0; j \u003c S.n && ok; j++) if (S.mark[j] && S.col[j] === b && S.act[v * M + j]) ok = false;\n        if (!ok) continue;\n        const L = comp.length, sc = L === 1 ? 100 : L \u003c= 5 ? 10 - L : 10 + L;\n        if (sc \u003c score) (score = sc), (best = { v, a, b, comp });\n      }\n    }\n  return best;\n}\n\nfunction swap(S, comp, a, b) {\n  for (const i of comp) S.col[i] = S.col[i] === a ? b : a;\n}\n\n// The colour a country shows now, part way through its repair.\nfunction shown(S, i, out, o) {\n  const e = ease((S.age[i] - RISE) / CROSS), c = S.col[i] \u003c 4 ? S.col[i] : 0, p = S.pal;\n  for (let k = 0; k \u003c 3; k++) out[o + k] = S.from[3 * i + k] + (p[3 * c + k] - S.from[3 * i + k]) * e;\n}\n\n// Give i the colour c; on screen it glows by g and fades over from what it shows now.\nfunction paint(S, i, c, show, g) {\n  if (show) {\n    shown(S, i, S.from, 3 * i);\n    S.gl[i] = max(g, S.age[i] \u003c LIFE ? S.gl[i] * 0.5 : 0);\n    S.age[i] = 0;\n  }\n  S.col[i] = c;\n  if (!show) {\n    S.age[i] = LIFE;\n    S.gl[i] = 0;\n  }\n}\n\nfunction event(S, comp, v, a, b, show) {\n  if (!show) return;\n  // Links between capitals along the chain, and from v to the chain.\n  const links = [];\n  const inC = new Uint8Array(M);\n  for (const i of comp) inC[i] = 1;\n  for (const i of comp) for (const j of comp) if (i \u003c j && S.act[i * M + j]) links.push(i, j);\n  for (const j of comp) if (S.act[v * M + j]) links.push(v, j);\n  S.ev.push({ links, age: 0, a, b });\n}\n\n// Repair the conflict on the border u-v (u -1: v is a new, uncoloured country).\nfunction repair(S, u, v, show, last) {\n  const st = S.stats, xs = u \u003c 0 ? [v] : [v, u];\n  if (show) st.repairs++;\n  // A free colour.\n  for (const x of xs) {\n    const m = used(S, x);\n    if (m !== 15) {\n      const free = [];\n      for (let c = 0; c \u003c 4; c++) if (!(m & (1 \u003c\u003c c))) free.push(c);\n      paint(S, x, free[floor(Math.random() * free.length)], show, 0.28);\n      if (show) st.free++, S.ev.push({ links: [], age: 0, a: u, b: v });\n      return true;\n    }\n  }\n  // One Kempe swap.\n  let k = single(S, xs);\n  if (k) {\n    for (const i of k.comp) paint(S, i, S.col[i] === k.a ? k.b : k.a, show, 0.6);\n    paint(S, k.v, k.a, show, 0.6);\n    if (show) {\n      st.swap1++;\n      st.chainSizes += k.comp.length;\n      if (st.firstSwap \u003c 0) st.firstSwap = S.clock;\n      event(S, k.comp, k.v, u, v, true);\n    }\n    return true;\n  }\n  // Two swaps, as Kempe argued for a country of five neighbours: the first\n  // swap on any a/b chain through a neighbour, then one swap that works.\n  for (const x of xs)\n    for (let a = 0; a \u003c 4; a++)\n      for (let b = 0; b \u003c 4; b++) {\n        if (a === b) continue;\n        for (const w of nbOf(S, x, a)) {\n          const c1 = chain(S, x, [w], a, b);\n          swap(S, c1, a, b);\n          k = single(S, [x]);\n          if (k) {\n            swap(S, c1, a, b);\n            for (const i of c1) paint(S, i, S.col[i] === a ? b : a, show, 0.6);\n            for (const i of k.comp) paint(S, i, S.col[i] === k.a ? k.b : k.a, show, 0.6);\n            paint(S, x, k.a, show, 0.6);\n            if (show) {\n              st.swap2++;\n              if (st.firstSwap \u003c 0) st.firstSwap = S.clock;\n              event(S, c1.concat(k.comp), x, u, v, true);\n            }\n            return true;\n          }\n          swap(S, c1, a, b);\n        }\n      }\n  // Neither worked (Heawood's case or worse). While remembered borders are in\n  // the graph, the caller forgets them and asks again; on the map as it is, a\n  // short local search: each step takes a country in conflict and gives it\n  // the colour fewest of its neighbours have.\n  if (!last) {\n    if (show) st.repairs--;\n    return false;\n  }\n  if (show) st.local++;\n  const n = S.n, col = S.col.slice(0, n);\n  for (let step = 0; step \u003c 4000; step++) {\n    const bad = [];\n    for (let i = 0; i \u003c n; i++) {\n      if (S.area[i] === 0 && col[i] \u003c 4) continue;\n      if (col[i] > 3) {\n        bad.push(i);\n        continue;\n      }\n      for (let j = 0; j \u003c n; j++) if (S.act[i * M + j] && col[j] === col[i]) {\n        bad.push(i);\n        break;\n      }\n    }\n    if (!bad.length) {\n      for (let i = 0; i \u003c n; i++) if (col[i] !== S.col[i]) paint(S, i, col[i], show, 0.6);\n      return true;\n    }\n    const i = bad[floor(Math.random() * bad.length)], cnt = [0, 0, 0, 0];\n    for (let j = 0; j \u003c n; j++) if (S.act[i * M + j] && col[j] \u003c 4) cnt[col[j]]++;\n    let bc = 0;\n    if (Math.random() \u003c 0.15) bc = floor(Math.random() * 4);\n    else for (let c = 1; c \u003c 4; c++) if (cnt[c] \u003c cnt[bc] || (cnt[c] === cnt[bc] && Math.random() \u003c 0.5)) bc = c;\n    col[i] = bc;\n  }\n  if (show) st.failed++;\n  return false;\n}\n\nfunction repairAll(S, show) {\n  const n = S.n, col = S.col, act = S.act;\n  for (let guard = 0, forgot = false; guard \u003c 120; guard++) {\n    let u = -1, v = -1;\n    for (let i = 0; i \u003c n && v \u003c 0; i++) if (col[i] > 3 && S.area[i] > 0) v = i;\n    for (let i = 0; i \u003c n && v \u003c 0; i++)\n      for (let j = i + 1; j \u003c n; j++)\n        if (act[i * M + j] && col[i] === col[j]) {\n          // Recolour the smaller of the two first.\n          [u, v] = S.area[i] \u003c S.area[j] ? [j, i] : [i, j];\n          break;\n        }\n    if (v \u003c 0) return;\n    let mem = false;\n    for (let k = 0; k \u003c M * M && !mem; k++) if (act[k] && !S.cur[k]) mem = true;\n    if (repair(S, u, v, show, forgot || !mem)) continue;\n    // Kempe's moves found nothing on the graph with the remembered borders in\n    // it, which need not be planar: two countries touched a moment ago that\n    // no longer do, and the map has closed round them. Forget every border\n    // not on the map now and repair again on the map as it is.\n    if (forgot) return;\n    forgot = true;\n    if (show) S.stats.forget++;\n    for (let k = 0; k \u003c M * M; k++) if (!S.cur[k]) (S.seen[k] = -1e9), (act[k] = 0);\n  }\n}\n\n// The opening. The drift is worked out 1.9 drift seconds ahead, and the first\n// colouring is chosen so that one of the first six borders to appear after\n// 0.6 s joins two countries of one colour, each already ringed by the other\n// three colours: no free colour is left for either, so the first repair needs\n// a chain. Borders that appear before it get proper colours from the start.\n// If no such colouring turns up, the first new border at least joins one\n// colour, and if there is none the map is coloured plainly.\nfunction opening(S, ds) {\n  const n = S.n, keep = [S.x, S.y, S.vx, S.vy].map((a) => a.slice()), t0 = S.t, G0 = S.cur.slice();\n  const pre = S.cur.slice(), first = new Float32Array(M * M).fill(-1), acts = [];\n  for (let k = 1; S.t \u003c t0 + 1.9; k++) {\n    move(S, ds, true);\n    S.t += ds;\n    map(S);\n    acts.push(S.act.slice());\n    for (let i = 0; i \u003c n; i++)\n      for (let j = i + 1; j \u003c n; j++) if (S.cur[i * M + j] && !G0[i * M + j] && first[i * M + j] \u003c 0) first[i * M + j] = S.t - t0;\n  }\n  [S.x, S.y, S.vx, S.vy].forEach((a, i) => a.set(keep[i]));\n  S.t = t0;\n  S.seen.fill(-1e9);\n  map(S);\n  const cands = [];\n  for (let k = 0; k \u003c M * M; k++) if (first[k] >= 0.6) cands.push(k);\n  cands.sort((a, b) => first[a] - first[b]);\n  for (const k of cands.slice(0, 6)) {\n    const c = floor(k / M), d = k % M, step = round(first[k] / ds) - 1, Gt = acts[min(acts.length - 1, step)];\n    // Every border seen before this one must be proper from the start.\n    pre.set(G0);\n    for (let q = 0; q \u003c M * M; q++) if (first[q] >= 0 && first[q] \u003c first[k]) pre[q] = pre[(q % M) * M + floor(q / M)] = 1;\n    for (let tries = 0; tries \u003c 40; tries++) {\n      if (!colourWith(S, pre, c, d)) break;\n      let ok = true;\n      for (const x of [c, d]) {\n        let m = 0;\n        for (let j = 0; j \u003c n; j++) if (j !== c && j !== d && Gt[x * M + j]) m |= 1 \u003c\u003c S.col[j];\n        if ((m | (1 \u003c\u003c S.col[c])) !== 15) ok = false;\n      }\n      if (ok) return first[k];\n    }\n  }\n  // No such pair: at least let the first new border join one colour.\n  if (cands.length && colourWith(S, G0, floor(cands[0] / M), cands[0] % M)) return -first[cands[0]];\n  S.col.fill(255);\n  return 0;\n}\n\n// A random proper colouring of the graph g with c and d given one colour, by\n// backtracking over the countries in random order, most neighbours first.\nfunction colourWith(S, g, c, d) {\n  const n = S.n, col = S.col, order = [];\n  for (let i = 0; i \u003c n; i++) if (i !== d) order.push(i);\n  const dg = new Float32Array(M);\n  for (const i of order) {\n    for (let j = 0; j \u003c n; j++) dg[i] += g[i * M + j] + (i === c ? g[d * M + j] : 0);\n    dg[i] += Math.random();\n  }\n  order.sort((a, b) => dg[b] - dg[a]);\n  col.fill(255);\n  let budget = 5000;\n  const fits = (i, k) => {\n    for (let j = 0; j \u003c n; j++) if (col[j] === k && (g[i * M + j] || (i === c && g[d * M + j]))) return false;\n    return true;\n  };\n  const go = (q) => {\n    if (q === order.length) return true;\n    if (--budget \u003c 0) return false;\n    const i = order[q], o = floor(Math.random() * 4);\n    for (let e = 0; e \u003c 4; e++) {\n      const k = (o + e) % 4;\n      if (!fits(i, k)) continue;\n      col[i] = k;\n      if (i === c) col[d] = k;\n      if (go(q + 1)) return true;\n    }\n    col[i] = 255;\n    if (i === c) col[d] = 255;\n    return false;\n  };\n  return go(0);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 15, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.sizes = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 15, 40)), ds = (d * S.speed) / 2;\n  S.clock += d;\n  for (let c = 0; c \u003c 4; c++) hsv(S.hue + 0.075 + c / 4, 0.72, 0.92, S.pal, 3 * c);\n  if (!S.started) {\n    S.started = true;\n    S.n = n;\n    for (let i = 0; i \u003c n; i++) addSeed(S, i);\n    // Spread the capitals out before the first frame.\n    for (let i = 0; i \u003c 25; i++) move(S, 0.05, false);\n    move(S, 0, true);\n    map(S);\n    S.plan = opening(S, (S.speed / 2) / 30);\n    repairAll(S, false);\n  } else {\n    if (n > S.n) for (let i = S.n; i \u003c n; i++) addSeed(S, i);\n    S.n = n;\n    move(S, ds, true);\n    S.t += ds;\n    map(S);\n    repairAll(S, true);\n  }\n  // Count the frames whose map, as it is drawn, is properly four-coloured.\n  const st = S.stats;\n  let ok = true;\n  for (let i = 0; i \u003c S.n && ok; i++) {\n    if (S.area[i] > 0 && S.col[i] > 3) ok = false;\n    for (let j = i + 1; j \u003c S.n; j++) if (S.cur[i * M + j] && S.col[i] === S.col[j]) ok = false;\n  }\n  st.frames++;\n  if (ok) st.proper++;\n  for (let i = 0; i \u003c M; i++) S.age[i] = min(LIFE, S.age[i] + d);\n  for (const e of S.ev) e.age += d;\n  S.ev = S.ev.filter((e) => e.age \u003c LIFE);\n}\n\n// A glow envelope over a repair's life: up in RISE, held, down in FALL.\nconst env = (a) => (a \u003c RISE ? a / RISE : a > LIFE - FALL ? max(0, (LIFE - a) / FALL) : 1);\n// Channels in steps of 4 of 255, so flat countries stay flat.\nconst q = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\nfunction line(ov, x0, y0, x1, y1, a) {\n  const steps = max(1, round(max(abs(x1 - x0), abs(y1 - y0))));\n  for (let s = 0; s \u003c= steps; s++) {\n    const px = floor(x0 + ((x1 - x0) * s) / steps), py = floor(y0 + ((y1 - y0) * s) / steps);\n    if (px >= 0 && px \u003c W && py >= 0 && py \u003c H) ov[py * W + px] = max(ov[py * W + px], a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const { own, disp, ov, cx, cy, gl, age } = S;\n  for (let i = 0; i \u003c S.n; i++) shown(S, i, disp, 3 * i);\n  ov.fill(0);\n  // The new border that started each repair flashes white; the chain's links run capital to capital.\n  const flash = new Float32Array(M * M);\n  for (const e of S.ev) {\n    const a = env(e.age);\n    if (e.a >= 0 && e.b >= 0) flash[e.a * M + e.b] = flash[e.b * M + e.a] = max(flash[e.a * M + e.b], a);\n    const L = e.links;\n    for (let i = 0; i \u003c L.length; i += 2) {\n      line(ov, cx[L[i]], cy[L[i]], cx[L[i + 1]], cy[L[i + 1]], a * 0.85);\n      for (const j of [L[i], L[i + 1]])\n        for (let dy = -1; dy \u003c= 0; dy++)\n          for (let dx = -1; dx \u003c= 0; dx++) {\n            const px = floor(cx[j]) + dx, py = floor(cy[j]) + dy;\n            if (px >= 0 && px \u003c W && py >= 0 && py \u003c H) ov[py * W + px] = max(ov[py * W + px], a);\n          }\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const o = own[p], r = x \u003c W - 1 ? own[p + 1] : o, b = y \u003c H - 1 ? own[p + W] : o;\n      let R, G, B;\n      if (r !== o || b !== o) {\n        // A dark border LED, white while its border is the new one.\n        const f = max(r !== o ? flash[o * M + r] : 0, b !== o ? flash[o * M + b] : 0);\n        R = G = B = f;\n        R += 0.07 * (1 - f);\n        G += 0.05 * (1 - f);\n        B += 0.09 * (1 - f);\n      } else {\n        const g = gl[o] * env(age[o]);\n        R = disp[3 * o] + (1 - disp[3 * o]) * g;\n        G = disp[3 * o + 1] + (1 - disp[3 * o + 1]) * g;\n        B = disp[3 * o + 2] + (1 - disp[3 * o + 2]) * g;\n      }\n      const v = ov[p];\n      if (v > 0) {\n        R += (1 - R) * v;\n        G += (1 - G) * v;\n        B += (1 - B) * v;\n      }\n      display.setPixel(x, y, q(R), q(G), q(B));\n    }\n}\n","music-box":"// ===== Patternflow pattern =====\n// Title:   Music Box\n// Family:  halloween\n// Idea:    A haunted music box on a velvet shelf: its brass cylinder turns and each pin plucks a steel tooth that flashes and rings, a skeleton ballerina in a tutu pirouettes on the spindle under a cone of moonlight, then the spring runs down, the melody drags to a stop with her facing us, a cloud covers the moon and her eye sockets glow green, until an unseen hand spins the key and it plays again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Velvet=0..1, Speed=0.2..3, Tune=0..1, Wind=0..1\n//\n// Knob 1: Velvet. The colour of the velvet on the box, the lining behind the cylinder and the shelf, through the cold hues only so it never turns brown: purple at 0, blue at 0.33, teal at 0.67, poison green at 1. The brass, the steel, the bones and the moonlight stay as they are.\n// Knob 2: Speed. At 2 the waltz plays a beat every 0.42 seconds and the ballerina turns once a bar; at Wind 0.06 a wind plays 4.8 seconds at full tempo and then runs down over 1.2 to 4.2, as long as it takes her to stop facing us; the eyes glow for 2.2 and the key spins for 1.5. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Tune. Which of three A minor melodies is on the box, each on its own cylinder with its own dance: below 1/3 a waltz with an oom-pah-pah bass on brass, the ballerina in lilac with her arms rounded overhead; from 1/3 a slow lullaby on nickel silver, a pale blue tutu and the arms open wide; from 2/3 a brisk minuet on blackened steel, a black tutu edged in orange and the arms low in front. She turns once a bar of each tune's tempo.\n// Knob 4: Wind. How far the key is wound, so how long the box plays at full tempo before it runs down: 0.8 seconds at 0, 4.8 at 0.06, 9 at 0.25, 17.2 at 1.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst smooth = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The box, front on: its top from row 60 to the brass front edge at 66,\n// the velvet front to 115, the shelf below. A glass window shows the\n// cylinder (rows 71 to 87) and the comb whose 13 teeth hang from row 88.\nconst TOP = 60, RIM = 66, BOT = 115, BX0 = 2, BX1 = 57;\nconst WX0 = 6, WX1 = 53, WY0 = 69, WY1 = 106;\nconst CX0 = 9, CX1 = 50, CY = 79, CR = 8;\nconst TEETH = 13, TX = 11, TIP = 88, PLATE = 103;\nconst toothLen = (i) => round(15 - 0.55 * i);\n// The spindle and the ballerina's toe, the key on the box's right side.\nconst SPX = 30, TOE = 58, KX = 60, KY = 92;\n// The run-down's share of a wind, the glow and the winding, in seconds.\nconst SLOW = 1.8, GLOW = 2.2, WIND = 1.5;\n// The cloud's puffs: offset across, offset down, radius.\nconst PUFFS = [[-13, 4, 4.5], [-7, 2, 6.5], [0, 0, 8], [7.5, 2, 6.5], [13, 5, 4.5]], CLOUD = [0.13, 0.1, 0.2], CLOUD_RIM = [0.36, 0.33, 0.5];\n// A cylinder for each tune, five shades and its pins: brass with steel pins,\n// nickel silver with brass ones, blackened steel with silver ones.\nconst METALS = [\n  [[[0.76, 0.48, 0.08], [0.88, 0.6, 0.12], [0.96, 0.72, 0.2], [1, 0.84, 0.36], [1, 0.93, 0.62]], [1, 0.97, 0.86]],\n  [[[0.42, 0.45, 0.52], [0.58, 0.62, 0.7], [0.72, 0.76, 0.84], [0.86, 0.9, 0.96], [0.97, 0.98, 1]], [1, 0.78, 0.25]],\n  [[[0.1, 0.1, 0.14], [0.17, 0.17, 0.23], [0.25, 0.26, 0.33], [0.36, 0.37, 0.46], [0.55, 0.56, 0.66]], [0.95, 0.96, 1]],\n];\n// And a tutu for each: lilac tulle, pale ghostly blue, black edged in orange.\nconst TUTUS = [\n  [[0.55, 0.4, 0.7], [0.78, 0.62, 0.9], [0.95, 0.85, 1]],\n  [[0.5, 0.62, 0.75], [0.72, 0.84, 0.95], [0.93, 0.98, 1]],\n  [[0.1, 0.06, 0.12], [0.24, 0.16, 0.28], [1, 0.55, 0.1]],\n];\n\n// The comb, low to high: A3 B3 C4 D4 E4 F4 G#4 A4 B4 C5 D5 E5 F5, A minor\n// with the raised seventh. Each tune is 8 bars of 3 beats, one turn of the\n// cylinder, written as [beat, tooth] pins, and its beat in story seconds.\nconst TUNES = [\n  // Waltz: bass on the bar, a chord tone on beats 2 and 3, the tune on top.\n  {\n    beat: 0.42,\n    bass: [[0, 4, 4], [1, 3, 3], [1, 3, 3], [0, 4, 4], [3, 5, 5], [0, 4, 4], [1, 3, 3], [0, 4, 4]],\n    tune: [[0, 11], [2, 9], [3, 8], [4, 9], [5, 8], [6, 6], [8, 4], [9, 7], [12, 12], [14, 10], [15, 9], [16, 10], [17, 9], [18, 8], [19, 6], [20, 8], [21, 7]],\n  },\n  // Lullaby: slow, the bass and one tone a bar, the tune in long notes.\n  {\n    beat: 0.55,\n    bass: [[0, 2, -1], [1, 3, -1], [0, 4, -1], [3, 5, -1], [3, 5, -1], [0, 2, -1], [1, 3, -1], [0, 4, -1]],\n    tune: [[0, 7], [2, 9], [3, 8], [5, 6], [6, 7], [8, 4], [9, 5], [12, 10], [14, 12], [15, 11], [17, 9], [18, 8], [20, 6], [21, 7]],\n  },\n  // Minuet: brisk, a note on every beat.\n  {\n    beat: 0.32,\n    bass: [[0, -1, -1], [3, -1, -1], [0, -1, -1], [1, -1, -1], [3, -1, -1], [0, -1, -1], [1, -1, -1], [0, -1, -1]],\n    tune: [7, 9, 11, 10, 9, 8, 9, 7, 4, 6, 8, 11, 12, 11, 10, 9, 8, 7, 8, 6, 4, 7, -1, 11].map((t, b) => [b, t]).filter((q) => q[1] >= 0),\n  },\n];\n// Every pin of a tune, sorted by beat.\nconst PINS = TUNES.map((T) => {\n  const p = T.tune.slice();\n  T.bass.forEach(([b, c1, c2], bar) => {\n    p.push([bar * 3, b]);\n    if (c1 >= 0) p.push([bar * 3 + 1, c1]);\n    if (c2 >= 0) p.push([bar * 3 + 2, c2]);\n  });\n  return p.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n});\n\n// The ballerina in her own frame, y up from the toe, z toward us when she\n// faces us: standing leg en pointe, the other drawn up in retire with its\n// knee turned out, arms rounded overhead. One unit is SC LEDs.\nconst J = {\n  toe: [0, 0, 0], ank: [-0.1, 2.5, 0], kn: [-0.5, 9.5, 0], hipS: [-1.2, 16.6, 0],\n  hipW: [1.2, 16.6, 0], knW: [6.8, 12.6, 1.4], ftW: [-0.1, 10.2, 1.1],\n  waist: [0, 18.2, 0], chest: [0, 26, 0], neck: [0, 29.4, 0], head: [0, 33, 0.2],\n  shL: [-3.6, 27, 0], shR: [3.6, 27, 0], elL: [-6.4, 31.8, 0.9], elR: [6.4, 31.8, 0.9], haL: [-1.4, 38.2, 1.1], haR: [1.4, 38.2, 1.1],\n};\n// The other two dances: the lullaby's attitude, the leg lifted behind and\n// the arms open to the sides; the minuet's arms rounded low in front.\nconst POSES = [\n  {},\n  { knW: [2.4, 16.4, -7.2], ftW: [3.6, 20.6, -11.4], elL: [-8.2, 28.4, 0.6], elR: [8.2, 28.4, 0.6], haL: [-12.6, 29.8, 0], haR: [12.6, 29.8, 0] },\n  { elL: [-5.6, 23.6, 2.6], elR: [5.6, 23.6, 2.6], haL: [-1.6, 21.6, 4.6], haR: [1.6, 21.6, 4.6] },\n];\nconst SC = 1.3, ELEV = 0.28, CE = cos(ELEV), SE = sin(ELEV), HEAD_R = 3.5, TUTU_Y = 17.6, TUTU_R = 9.5;\nconst RIBS = [[20.8, 2.3], [22.4, 2.9], [24, 3.1], [25.6, 2.9]];\n\n// The cloud's shape, 40 by 12 about its middle: 1 inside a puff, 2 on a\n// lower rim not covered by another puff.\nfunction cloudMask() {\n  const m = new Uint8Array(40 * 12);\n  for (let y = 0; y \u003c 12; y++)\n    for (let j = 0; j \u003c 40; j++) {\n      let inside = false, deep = false;\n      for (const [dx, dy, r] of PUFFS) {\n        const d = Math.hypot(j + 0.5 - 20 - dx, y + 0.5 - dy);\n        if (d \u003c r) (inside = true), (deep = deep || d \u003c r - 1.2);\n      }\n      if (inside) m[y * 40 + j] = !deep && y > 3 ? 2 : 1;\n    }\n  return m;\n}\n\n// The tutu's LEDs: for each, where it meets each of the three layers of the\n// disc, as a radius and an angle in the room; turning her only adds phi.\nfunction tutuMap() {\n  const out = [], yc = floor(TOE + 0.5 - SC * TUTU_Y * CE), RM = TUTU_R + 0.7;\n  for (let y = yc - 6; y \u003c= yc + 6; y++)\n    for (let x = SPX - 14; x \u003c= SPX + 15; x++) {\n      const xr = (x + 0.5 - SPX - 0.5) / SC, layers = [];\n      for (const h of [TUTU_Y - 0.7, TUTU_Y, TUTU_Y + 0.7]) {\n        const zr = ((y + 0.5 - TOE - 0.5) / SC + h * CE) / SE, r = Math.hypot(xr, zr);\n        if (r \u003c RM) layers.push(r, atan2(zr, xr));\n      }\n      if (layers.length) out.push([x, y, layers]);\n    }\n  return out;\n}\n\nexport function setup(params) {\n  const motes = [];\n  for (let i = 0; i \u003c 18; i++) motes.push([Math.random(), Math.random() * 58, 1.5 + 2.5 * Math.random(), Math.random() * TAU]);\n  params.s = {\n    rgb: new Float32Array(N * 3), cloudMask: cloudMask(), tutu: tutuMap(), motes, started: false,\n    hue: 0.5, speed: 1.5, tuneI: 0, wind: 0.06, t: 0.5,\n    phase: \"play\", ph: 0.5, tau: 4.5, beat: 0.5, phi: 0.5, phiA: 0.5, D: 1.5,\n    key: 0.5, amp: 0.5, cloud: 0.5, ring: new Float32Array(TEETH), wave: new Float32Array(TEETH), spark: new Float32Array(TEETH), eyes: 0.5,\n  };\n}\n\n// Seconds of play a wind gives, the run-down included.\nconst runFor = (w) => 2.6 + 16.4 * sqrt(w);\n// Full tempo while playing; in the run-down it falls as (left / D)^0.8.\nconst tempo = (S) => (S.phase === \"play\" ? 1 : S.phase === \"slow\" ? (max(0, S.D - S.ph) / S.D) ** 0.8 : 0);\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tuneI = min(2, floor(cl(k[2], 0, 1) * 3));\n  S.wind = cl(k[3], 0, 1);\n  const T = TUNES[S.tuneI], pins = PINS[S.tuneI], g = (d * S.speed) / 2;\n  if (!S.started) {\n    // The first pin plucks a quarter second in, the ballerina already turning.\n    S.started = true;\n    S.tau = runFor(S.wind) - SLOW;\n    S.beat = 24 - 0.25 / T.beat;\n    S.phi = 0;\n    S.ph = 0;\n    S.t = 0;\n  }\n  S.t += g;\n  S.ph += g;\n  const f = tempo(S), om = TAU / (3 * T.beat);\n  if (S.phase === \"play\" || S.phase === \"slow\") {\n    // The cylinder: beats go by at the tempo, and every pin passed plucks.\n    const b0 = S.beat, b1 = b0 + (g * f) / T.beat;\n    for (const [b, tooth] of pins) {\n      const at = b \u003c b0 ? b + 24 : b;\n      if (at > b0 && at \u003c= b1) (S.ring[tooth] = 1), (S.spark[tooth] = 1);\n    }\n    S.beat = b1 >= 24 ? b1 - 24 : b1;\n    S.key += 0.6 * f * g;\n  }\n  if (S.phase === \"play\") {\n    S.phi += om * g;\n    S.tau -= g;\n    if (S.tau \u003c= 0) {\n      // The run-down: she turns om D / 1.8 more as the tempo falls to 0 over\n      // D seconds, so D is chosen to end that on a whole turn, facing us,\n      // and at least 1.2 seconds long.\n      const k = Math.ceil((S.phi + (1.2 * om) / 1.8) / TAU);\n      (S.phase = \"slow\"), (S.ph = 0), (S.phiA = S.phi), (S.D = (1.8 * (TAU * k - S.phi)) / om);\n    }\n  } else if (S.phase === \"slow\") {\n    const u = min(S.ph, S.D);\n    S.phi = S.phiA + ((om * S.D) / 1.8) * (1 - ((S.D - u) / S.D) ** 1.8);\n    if (S.ph >= S.D) (S.phi = 0), (S.phase = \"glow\"), (S.ph = 0);\n  } else if (S.phase === \"glow\" && S.ph >= GLOW) (S.phase = \"wind\"), (S.ph = 0);\n  else if (S.phase === \"wind\") {\n    // Two and a half turns of the key, eased in and out.\n    S.key += ((2.5 * TAU) / WIND) * 2 * (1 - abs(2 * (S.ph / WIND) - 1)) * g;\n    if (S.ph >= WIND) (S.phase = \"play\"), (S.ph = 0), (S.tau = runFor(S.wind) - SLOW);\n  }\n  // Teeth ring and fade; the ripple along a tooth runs at its pitch, and\n  // drags lower as the tempo falls, so the box goes flat as it stops.\n  for (let i = 0; i \u003c TEETH; i++) {\n    S.ring[i] *= exp(-g / 0.5);\n    S.spark[i] *= exp(-g / 0.07);\n    S.wave[i] += g * (14 + 2.2 * i) * (0.35 + 0.65 * f);\n  }\n  // The moonlight swells a little with each note.\n  let amp = 0;\n  for (let i = 0; i \u003c TEETH; i++) amp = max(amp, S.ring[i]);\n  S.amp = amp * f;\n  const eyeT = S.phase === \"glow\" ? smooth(S.ph / 0.6) : S.phase === \"wind\" ? 1 - smooth(S.ph / 0.7) : 0;\n  S.eyes = eyeT * (0.82 + 0.18 * sin(S.t * 23) * sin(S.t * 7.7));\n  // A cloud over the moon: it slides off as the box first plays, drifts back\n  // as the spring runs down, covers the moon while the eyes glow and slides\n  // off again while the key turns.\n  const run = S.phase === \"play\" || S.phase === \"slow\" ? 1 - f : S.phase === \"glow\" ? 1 : 1 - smooth(S.ph / WIND);\n  S.cloud = max(run, 1 - smooth(S.t / 1.2));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  const rgb = S.rgb;\n  const put = (x, y, c, a = 1) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    if (a >= 1) (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n    else (rgb[o] = mix(rgb[o], c[0], a)), (rgb[o + 1] = mix(rgb[o + 1], c[1], a)), (rgb[o + 2] = mix(rgb[o + 2], c[2], a));\n  };\n  const line = (x0, y0, x1, y1, c) => {\n    const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0))));\n    for (let j = 0; j \u003c= n; j++) put(x0 + ((x1 - x0) * j) / n, y0 + ((y1 - y0) * j) / n, c);\n  };\n  // The moonlight: a quarter of itself behind the cloud, swelling a little\n  // on each note while the moon is clear.\n  const cv = S.cloud, dim = 1 - 0.75 * cv + 0.15 * S.amp * (1 - cv);\n  // The velvet's shades this frame: the front's sheen, the moonlit top, the\n  // shelf and the lining.\n  const vel = (v, sat = 0.78) => hsv(0.78 - 0.45 * S.hue, sat, v);\n  const sheen = [0, 1, 2, 3].map((k) => vel(0.42 + (0.16 * k) / 3));\n  const topC = [vel(0.82 * dim, 0.55), vel(0.62 * dim), vel(0.45)], shelfC = [vel(0.3, 0.7), vel(0.5, 0.7), vel(0.22, 0.7)], lining = vel(0.16, 0.85);\n\n  // A run of one colour along a row, written straight into the frame.\n  const span = (y, x0, x1, c) => {\n    x0 = max(0, x0);\n    x1 = min(W - 1, x1);\n    for (let o = (y * W + x0) * 3, e = (y * W + x1) * 3; o \u003c= e; o += 3) (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n  };\n  // The room: near-black violet, the moon peeking in at the top and its\n  // cone in three bands.\n  const room = [0.035, 0.012, 0.06], cone = [0.17, 0.25, 0.34].map((a) => [0.55 * a * dim + 0.03, 0.55 * a * dim + 0.01, 0.85 * a * dim + 0.05]);\n  for (let y = 0; y \u003c H; y++) span(y, 0, W - 1, room);\n  for (let y = 0; y \u003c TOP; y++) {\n    const hw = 8 + 0.3 * y;\n    for (let b = 0; b \u003c 3; b++) {\n      const e = [1, 0.75, 0.45][b] * hw;\n      span(y, Math.ceil(SPX - e - 0.5), floor(SPX + e - 0.5), cone[b]);\n    }\n  }\n  for (let y = 0; y \u003c 8; y++)\n    for (let x = SPX - 10; x \u003c= SPX + 10; x++) {\n      const mx = x + 0.5 - SPX, my = y + 0.5 + 3, mr = mx * mx + my * my;\n      if (mr >= 100) continue;\n      const crater = (mx + 3) ** 2 + (my - 3) ** 2 \u003c 6 || (mx - 4) ** 2 + (my - 5) ** 2 \u003c 3, c = crater ? 0.78 : mr > 80 ? 0.86 : 0.95;\n      put(x, y, [c, c, c + 0.05]);\n    }\n  // The cloud: dark puffs with a rim lit by the moon behind them.\n  const cx = round(SPX + 52 * (1 - smooth(cv)));\n  for (let y = 0; y \u003c 12; y++)\n    for (let j = 0; j \u003c 40; j++) {\n      const m = S.cloudMask[y * 40 + j];\n      if (m) put(cx - 20 + j, y, m === 2 ? CLOUD_RIM : CLOUD);\n    }\n  // Dust in the beam, drifting down and twinkling.\n  for (const m of S.motes) {\n    const y = (m[1] + S.t * m[2]) % 58, hw = 8 + 0.3 * y, x = SPX + (m[0] * 2 - 1) * hw * 0.85;\n    const a = (0.35 + 0.35 * sin(S.t * 3 + m[3])) * dim;\n    if (a > 0.2) put(x, y + 10, [0.6 + a * 0.4, 0.6 + a * 0.4, 0.75 + a * 0.25], 0.6);\n  }\n\n  // The box top, in perspective, lit in a pool round the spindle.\n  for (let y = TOP; y \u003c RIM; y++) {\n    const inset = (RIM - 1 - y) * 0.6;\n    for (let x = floor(BX0 + inset); x \u003c= BX1 - inset; x++) {\n      const px = (x + 0.5 - SPX) / 22, py = (y + 0.5 - 62.5) / 3.2, pool = px * px + py * py;\n      put(x, y, topC[pool \u003c 0.35 ? 0 : pool \u003c 1 ? 1 : 2]);\n    }\n  }\n  const brass = METALS[0][0];\n  line(BX0, RIM, BX1, RIM, brass[3]);\n  // The front: velvet with a sheen in four steps, brass trim at the edges.\n  for (let x = BX0; x \u003c= BX1; x++) {\n    const c = sheen[min(3, floor(4 * (0.5 + 0.5 * cos((x - 14) / 9))))];\n    for (let y = RIM + 1; y \u003c= BOT; y++) put(x, y, c);\n  }\n  line(BX0, RIM + 1, BX0, BOT, brass[2]);\n  line(BX1, RIM + 1, BX1, BOT, brass[1]);\n  line(BX0, BOT, BX1, BOT, brass[1]);\n  // The shelf.\n  for (let y = BOT + 1; y \u003c H; y++) span(y, 0, W - 1, shelfC[y \u003c BOT + 4 ? 0 : y === BOT + 4 ? 1 : 2]);\n  // The window: dark lining, brass frame.\n  for (let y = WY0 + 1; y \u003c WY1; y++) span(y, WX0 + 1, WX1 - 1, lining);\n  line(WX0, WY0, WX1, WY0, brass[3]);\n  line(WX0, WY1, WX1, WY1, brass[1]);\n  line(WX0, WY0, WX0, WY1, brass[2]);\n  line(WX1, WY0, WX1, WY1, brass[1]);\n\n  // The cylinder, shaded in five steps from its highlight above the middle.\n  const [metal, pinC] = METALS[S.tuneI];\n  for (let y = CY - CR; y \u003c= CY + CR - 1; y++) {\n    const v = (y + 0.5 - CY) / CR, lv = v \u003c -0.82 ? 1 : v \u003c -0.5 ? 3 : v \u003c -0.2 ? 4 : v \u003c 0.45 ? 2 : v \u003c 0.8 ? 1 : 0;\n    span(y, CX0, CX1, metal[lv]);\n    put(CX0 - 2, y, brass[max(0, lv - 1)]);\n    put(CX0 - 1, y, brass[max(0, lv - 1)]);\n    put(CX1 + 1, y, brass[max(0, lv - 1)]);\n    // A gear on the right end, its teeth running with the cylinder.\n    const gt = floor(y + S.beat * 3) % 2 === 0;\n    put(CX1 + 2, y, brass[gt ? 3 : 1]);\n  }\n  // The pins: from the top edge, coming round from behind, down to the\n  // bottom edge, where each one plucks its tooth.\n  const pins = PINS[S.tuneI], silver = pinC, shadow = metal[0];\n  for (const [b, tooth] of pins) {\n    let a = b - S.beat;\n    if (a \u003c 0) a += 24;\n    if (a > 12) continue;\n    const y = CY + CR * cos((PI * a) / 12) - 0.5, x = TX + 3 * tooth;\n    if (a > 0.6 && a \u003c 11.4) (put(x, y + 1, shadow), put(x + 1, y + 1, shadow));\n    const c = S.spark[tooth] > 0.3 && a \u003c 0.6 ? [1, 1, 1] : silver;\n    put(x, y, c);\n    put(x + 1, y, c);\n  }\n  // The comb: a steel plate under slanted roots, a tooth for each note.\n  const steel = [0.5, 0.56, 0.7], steelHi = [0.72, 0.78, 0.9], plate = [0.3, 0.33, 0.45], bright = [0.88, 0.97, 1];\n  const glowC = [0.3, 0.55, 0.85], white = [1, 1, 1];\n  for (let i = 0; i \u003c TEETH; i++) {\n    const x = TX + 3 * i, root = TIP + toothLen(i);\n    for (let y = root; y \u003c= PLATE; y++) for (let dx = -1; dx \u003c= 2; dx++) put(x + dx, y, plate);\n    // A ringing tooth flashes, bright and half bright bands running down it.\n    const r = S.ring[i], hq = floor(r * 3) / 3;\n    const tone = (c, a) => (a > 0.05 ? [mix(c[0], bright[0], a), mix(c[1], bright[1], a), mix(c[2], bright[2], a)] : c);\n    const hiA = tone(steelHi, r), hiB = tone(steelHi, r / 2), loA = tone(steel, r), loB = tone(steel, r / 2);\n    for (let y = TIP; y \u003c root; y++) {\n      const band = sin((y - TIP) * 1.3 - S.wave[i]) > 0;\n      put(x, y, band ? hiA : hiB);\n      put(x + 1, y, band ? loA : loB);\n      // The ringing glows into the gaps either side, in three steps.\n      if (hq > 0) (put(x - 1, y, glowC, hq * 0.8), put(x + 2, y, glowC, hq * 0.8));\n    }\n    if (S.spark[i] > 0.3) put(x, TIP, white), put(x + 1, TIP, white);\n  }\n  for (const sx of [TX + 4, TX + 31]) put(sx, PLATE - 1, brass[4]);\n\n  // The key on the right side: a brass shaft and two wings turning about it,\n  // seen edge on, so they swing between full height and a sliver.\n  line(BX1 + 1, KY, KX, KY, brass[2]);\n  const kc = cos(S.key), ks = abs(sin(S.key));\n  for (const sg of [-1, 1]) {\n    const ext = 5.5 * kc * sg, n = Math.ceil(abs(ext));\n    for (let j = 1; j \u003c= n; j++) {\n      const u = j / (n + 0.5), hw = 1.6 * sin(PI * (0.25 + 0.75 * u));\n      for (let dx = -1; dx \u003c= 1; dx++) if (abs(dx) \u003c= hw) put(KX + 1 + dx, KY - Math.sign(ext) * j, brass[ks > 0.7 ? 2 : abs(kc) > 0.7 ? 4 : 3]);\n    }\n  }\n  put(KX + 1, KY, brass[4]);\n  // While it winds, a pale green glow where a hand would be.\n  if (S.phase === \"wind\") {\n    const a = 0.45 * sin((PI * S.ph) / WIND);\n    for (let y = KY - 7; y \u003c= KY + 7; y++)\n      for (let x = KX - 2; x \u003c W; x++) {\n        const e = ((x - KX - 1) / 3.5) ** 2 + ((y - KY) / 7.5) ** 2;\n        if (e \u003c 1) put(x, y, [0.35, 0.95, 0.45], a * (e \u003c 0.4 ? 0.6 : 0.3));\n      }\n  }\n\n  // The spindle and the ballerina.\n  line(SPX, TOE + 1, SPX, 62, brass[3]);\n  dancer(S, put, line);\n\n  const q = (v) => (v >= 1 ? 255 : v \u003c= 0 ? 0 : (v * 255) | 0);\n  for (let y = 0, o = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, q(rgb[o]), q(rgb[o + 1]), q(rgb[o + 2]));\n}\n\n// The skeleton ballerina, turned by phi about her standing toe and seen a\n// little from above: legs first, then the tutu, then the upper body and the\n// skull from back to front.\nfunction dancer(S, put, line) {\n  const phi = S.phi, c = cos(phi), s = sin(phi), Q = { ...J, ...POSES[S.tuneI] };\n  const P = (p) => {\n    const x = p[0] * c + p[2] * s, z = -p[0] * s + p[2] * c;\n    return [SPX + 0.5 + SC * x, TOE + 0.5 - SC * (p[1] * CE - z * SE), z];\n  };\n  // Lit by the moon: half as bright while the cloud covers it.\n  const L = 1 - 0.5 * S.cloud, lit = (c) => [c[0] * L, c[1] * L, c[2] * L];\n  const bone = lit([0.96, 0.93, 0.84]), boneLo = lit([0.7, 0.66, 0.62]), pink = lit([1, 0.62, 0.75]);\n  // A bone; a wide one is two LEDs thick, doubled across its length.\n  const seg = (a, b, col, wide) => {\n    const A = P(a), B = P(b);\n    line(A[0], A[1], B[0], B[1], col);\n    if (wide) abs(B[0] - A[0]) \u003c abs(B[1] - A[1]) ? line(A[0] + 1, A[1], B[0] + 1, B[1], col) : line(A[0], A[1] + 1, B[0], B[1] + 1, col);\n  };\n  // Legs: the back one first.\n  const legS = [[Q.toe, Q.ank, pink], [Q.ank, Q.kn, bone], [Q.kn, Q.hipS, bone]];\n  const legW = [[Q.hipW, Q.knW, bone], [Q.knW, Q.ftW, bone]];\n  const zW = P(Q.knW)[2];\n  for (const L of zW \u003c 0 ? [legW, legS] : [legS, legW]) for (const [a, b, col] of L) seg(a, b, col, true);\n  const kn = P(Q.kn), kw = P(Q.knW);\n  put(kn[0], kn[1], boneLo);\n  put(kw[0], kw[1], boneLo);\n  // The tutu: three layers of a scalloped disc, pleats turning with her.\n  const [lilacLo, lilac, edge] = TUTUS[S.tuneI].map(lit);\n  for (const [x, y, layers] of S.tutu) {\n    let hit = -1;\n    for (let j = 0; j \u003c layers.length; j += 2) {\n      const beta = layers[j + 1] + phi, R = TUTU_R + 0.7 * cos(12 * beta);\n      if (layers[j] \u003c R) hit = max(hit, layers[j] > R - 1.2 ? 2 : (floor(((beta + PI) / TAU) * 16) % 2 + 2) % 2);\n    }\n    if (hit >= 0) put(x, y, hit === 2 ? edge : hit === 1 ? lilac : lilacLo);\n  }\n  // The upper body, sorted back to front.\n  const ribs = RIBS.map(([y, w]) => {\n    const pts = [];\n    for (let j = 0; j \u003c= 6; j++) {\n      const a = -PI / 2 + (PI * j) / 6;\n      pts.push([w * sin(a), y - 0.4 * cos(a), 0.7 * w * cos(a)]);\n    }\n    return pts;\n  });\n  const parts = [\n    { z: P(Q.chest)[2] - 0.2, draw: () => (seg(Q.waist, Q.chest, boneLo, true), seg(Q.chest, Q.neck, bone)) },\n    ...ribs.map((pts) => ({ z: P(pts[3])[2], draw: () => { for (let j = 0; j \u003c 6; j++) seg(pts[j], pts[j + 1], bone); } })),\n    { z: P(Q.neck)[2], draw: () => (seg(Q.shL, Q.neck, bone), seg(Q.neck, Q.shR, bone)) },\n    { z: P(Q.elL)[2], draw: () => (seg(Q.shL, Q.elL, bone, true), seg(Q.elL, Q.haL, bone)) },\n    { z: P(Q.elR)[2], draw: () => (seg(Q.shR, Q.elR, bone, true), seg(Q.elR, Q.haR, bone)) },\n    { z: 0.1, draw: () => skull(S, P, put, c, s) },\n  ].sort((a, b) => a.z - b.z);\n  for (const p of parts) p.draw();\n}\n\n// The skull: a round cranium and a narrower jaw, top lit by the moon; the\n// sockets, nose and teeth sit on its face and slide round as she turns.\nfunction skull(S, P, put, c, s) {\n  const H0 = P(J.head), r = HEAD_R * SC, L = 1 - 0.5 * S.cloud, dark = [0.06, 0.02, 0.09];\n  const bone = [0.96 * L, 0.93 * L, 0.84 * L], boneLo = [0.74 * L, 0.7 * L, 0.66 * L];\n  for (let y = floor(H0[1] - r - 1); y \u003c= H0[1] + r + 2; y++)\n    for (let x = floor(H0[0] - r - 1); x \u003c= H0[0] + r + 1; x++) {\n      const dx = x + 0.5 - H0[0], dy = y + 0.5 - H0[1];\n      const cran = dx * dx + dy * dy \u003c r * r, jaw = dy > 0 && dy \u003c r + 1.8 && abs(dx) \u003c r * 0.62;\n      if (cran || jaw) put(x, y, dy > r * 0.35 ? boneLo : bone);\n    }\n  // Face features in the head's frame: eyes, nose, the line of teeth.\n  const face = (fx, fy) => {\n    const p = [J.head[0] + fx, J.head[1] + fy, J.head[2] + sqrt(max(0, HEAD_R * HEAD_R - fx * fx - fy * fy * 0.6))];\n    const q = P(p);\n    return [q[0], q[1], -p[0] * s + p[2] * c];\n  };\n  const g = S.eyes, glow = [0.4, 1, 0.35], halo = [0.15, 0.6, 0.18];\n  for (const ex of [-1.3, 1.3]) {\n    const e = face(ex, 0.5);\n    if (e[2] \u003c 0.8) continue;\n    const wide = e[2] > 2.2 ? 2 : 1;\n    if (g > 0.05) for (let dy = -1; dy \u003c= 2; dy++) for (let dx = -1; dx \u003c= wide; dx++) put(e[0] + dx, e[1] + dy, halo, g * 0.55);\n    for (let dy = 0; dy \u003c= 1; dy++) for (let dx = 0; dx \u003c wide; dx++) put(e[0] + dx, e[1] + dy, g > 0.05 ? [mix(dark[0], glow[0], g), mix(dark[1], glow[1], g), mix(dark[2], glow[2], g)] : dark);\n  }\n  const n = face(0, -1.1);\n  if (n[2] > 0.8) put(n[0], n[1], dark);\n  for (const tx of [-1.2, 0, 1.2]) {\n    const t = face(tx, -2.6);\n    if (t[2] > 0.6) put(t[0], t[1], boneLo);\n  }\n}\n","party-lights":"// ===== Patternflow pattern =====\n// Title:   Party Lights\n// Family:  halloween\n// Idea:    Strings of big orange, purple, poison green and bone white bulbs sag across a dark porch wall at different heights down the panel, running a chase, a sparkle, a slow breath and a flash on the beat in turn, while gusts swing the strings like pendulums and a garland of black paper bats twists on its threads between the bulbs.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Warmth=-1..1, Speed=0.2..3, Strands=3..7, Gust=0..1\n//\n// Knob 1: Warmth. At 0 the bulbs are orange, purple, poison green and bone white in turn along each string; at 1 red orange, rose, amber and candle white, and the wall paint takes their light a little warmer; at -1 magenta, blue violet, aqua green and ice white on a colder wall. A dimmed bulb sinks to deep red, plum, dark green or lavender grey, never brown.\n// Knob 2: Speed. At 2 each program runs 4 seconds, in turn: a chase (one bulb in three lit, stepping 6 times a second, each string the other way), a sparkle (every bulb at two thirds, each flaring on its own 0.7 to 1.6 times a second), a breath (a 2.4 second swell rolling down the strings) and the beat (every bulb flashing together at 120 a minute, every fourth flash held twice as long). Gusts come every 5 seconds, the first at 1.7. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Strands. How many strings hang down the panel, 3 to 7, each slung from edge to edge with one end a few rows higher than the other: 3 sag 22 rows each, 7 sag 9 rows and fill the panel, and every string carries 6 bulbs 10 LEDs apart. The paper bats always hang from the second string.\n// Knob 4: Gust. The wind swings each string out of the wall like a pendulum, so it lifts, its low point slides sideways and the lower strings swing a little slower. At 0 the strings hang still; at 0.06 a breeze swings them up to 0.5 radians, lifting the sag by an eighth and sliding the low point 5 LEDs; at 1 each gust swings them past a radian, lifting them to a third of their sag and sliding the low point 11 LEDs, while the bulbs knock about and the bats spin on their threads.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, exp, atan, tanh, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (t) => (t \u003c= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));\nconst fr = (x) => x - floor(x);\n\n// The four bulbs, each lit and dimmed, at Warmth -1, 0 and 1. Dimmed, the\n// warm ones sink to red rather than brown.\nconst PAL = [\n  // orange\n  [[[0.95, 0.2, 0.9], [0.5, 0.04, 0.55]], [[1, 0.46, 0.02], [0.78, 0.1, 0.02]], [[1, 0.22, 0.02], [0.72, 0.04, 0.02]]],\n  // purple\n  [[[0.35, 0.3, 1], [0.14, 0.1, 0.7]], [[0.7, 0.2, 1], [0.42, 0.08, 0.72]], [[1, 0.12, 0.5], [0.68, 0.03, 0.3]]],\n  // poison green\n  [[[0.15, 1, 0.6], [0.03, 0.55, 0.3]], [[0.45, 1, 0.08], [0.12, 0.58, 0.04]], [[1, 0.72, 0.05], [0.75, 0.16, 0.02]]],\n  // bone white\n  [[[0.75, 0.9, 1], [0.35, 0.42, 0.62]], [[1, 0.95, 0.8], [0.55, 0.45, 0.62]], [[1, 0.82, 0.5], [0.72, 0.36, 0.2]]],\n];\n// A glass bulb hanging from its socket: half its width and length in LEDs,\n// and how far below the socket its middle hangs.\nconst BRX = 2.1, BRY = 3, BDY = 3.6;\n// A paper bat, 9 wide and 5 tall, its middle column at 4: ears, head,\n// wings with raised tips and a scalloped hem.\nconst BAT = [\"#..#.#..#\", \"##.###.##\", \"#########\", \".#######.\", \"..#.#.#..\"];\n// The light's rings round a bulb, radius in LEDs and share of the bulb's colour.\nconst RING = [[3.2, 0.45], [5.6, 0.3], [9, 0.2], [13, 0.1]];\n// The same as squared radii and the share inside each.\nconst RR = RING.map(([r]) => r * r), RS = RING.map((_, k) => RING.slice(k).reduce((s, q) => s + q[1], 0));\n// The programs, each this many story seconds; a chase steps this many times\n// a second; the beat is this long.\nconst PROG = 4, STEP = 6, BEAT = 0.5;\n// Gusts come every GUSTS seconds, the first at G0.\nconst GUSTS = 5, G0 = 2.2;\n\nexport function setup(params) {\n  // Each bulb's sparkle rate and phase, so they twinkle out of step.\n  const spark = [];\n  for (let i = 0; i \u003c 7 * 9; i++) spark.push([0.7 + 0.9 * Math.random(), Math.random()]);\n  params.s = {\n    warmth: 0.5, speed: 2, strands: 3, gust: 0.06, pt: 0.5,\n    phi: new Float64Array(7), dphi: new Float64Array(7), wind: 0.5, spark,\n    yw: new Float32Array(7 * W), light: new Float32Array(N * 3), rgb: new Float32Array(N * 3),\n    bulbs: [],\n  };\n}\n\n// Where a strand hangs. i of n, its anchors at the panel's edges, its sag,\n// and the lowest point pushed sideways and lifted as it swings out of the\n// wall by phi, seen through a soft limit so it never swings past 75 degrees.\nfunction strandY(S, i, n, x) {\n  const D = (H - 22) / n, yl = 5 + i * D + (i % 2 ? 5 : 0), yr = yl + (i % 2 ? -6 : 5), sag = 0.62 * D;\n  const ph = 1.3 * tanh(S.phi[i] / 1.3), u = (x + 0.5) / W, u0 = 0.5 + 0.18 * sin(ph), sg = sag * cos(ph);\n  const v = u \u003c u0 ? (u - u0) / u0 : (u - u0) / (1 - u0);\n  return mix(yl, yr, u) + sg * (1 - v * v);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.warmth = cl(k[0], -1, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.strands = round(cl(k[2], 3, 7));\n  S.gust = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.pt += ds;\n  // The wind: a breeze and a gust every few seconds, each a swell of about\n  // a second and a half.\n  const t = S.pt, gt = t - G0, gk = floor(gt / GUSTS + 0.5), dg = gt - gk * GUSTS;\n  S.wind = sqrt(S.gust) * (0.35 + 1.1 * exp(-((dg / 0.75) ** 2)) * (gk % 2 ? 0.75 : 1));\n  // Each strand swings out of the wall like a pendulum, the lower and\n  // longer ones slower, pushed by the wind and slowly damped.\n  for (let i = 0; i \u003c 7; i++) {\n    const w = TAU / (1.5 + 0.12 * i), steps = 3;\n    for (let s = 0; s \u003c steps; s++) {\n      const h = ds / steps, a = -w * w * S.phi[i] - 0.5 * w * S.dphi[i] + w * w * 1.1 * S.wind * (1 + 0.15 * sin(i * 1.7));\n      S.dphi[i] += a * h;\n      S.phi[i] = cl(S.phi[i] + S.dphi[i] * h, -3, 3);\n    }\n  }\n  const n = S.strands;\n  for (let i = 0; i \u003c n; i++) for (let x = 0; x \u003c W; x++) S.yw[i * W + x] = strandY(S, i, n, x);\n  // The program and how far into it: chase, sparkle, breath, beat, with a\n  // short cross-fade from the one before.\n  const pn = floor(t / PROG), pf = t - pn * PROG, p = pn % 4, q = (pn + 3) % 4, xf = pn > 0 ? ease(pf / 0.4) : 1;\n  const level = (pr, i, j) => {\n    if (pr === 0) {\n      // Chase: one bulb in three lit, stepping along, each strand the other way.\n      const st = floor(t * STEP);\n      return ((((i % 2 ? j : -j) + st + i) % 3) + 3) % 3 === 0 ? 1 : 0.25;\n    }\n    if (pr === 1) {\n      // Sparkle: every bulb two thirds lit, each flaring at its own times.\n      const [r, o] = S.spark[(i * 9 + j) % S.spark.length], f = fr(t * r + o);\n      return 0.68 + 0.32 * max(0, 1 - f * 5) ** 2;\n    }\n    if (pr === 2) return 0.4 + 0.6 * (0.5 + 0.5 * sin(TAU * (t / 2.4 - i * 0.11 - j * 0.03)));\n    // Beat: all strings flash together and hold, every fourth beat longer.\n    const b = floor(t / BEAT), f = t - b * BEAT - (b % 4 ? 0.1 : 0.22);\n    return f \u003c 0 ? 1 : 0.35 + 0.65 * exp(-f / 0.12);\n  };\n  // The bulbs: every 10 LEDs along each strand, the kinds in turn, each\n  // hanging off the wire tilted by its slope and knocked about by the wind.\n  S.bulbs.length = 0;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c 7; j++) {\n      const x = (i % 2 ? 7 : 2) + 10 * j;\n      if (x > W - 3) continue;\n      const xi = min(W - 1, x), y = S.yw[i * W + xi], sl = S.yw[i * W + min(W - 1, xi + 1)] - S.yw[i * W + max(0, xi - 1)];\n      const tilt = 0.6 * atan(sl / 2) + S.wind * 0.35 * sin(S.pt * (5 + j * 0.7) + i * 2 + j);\n      const lv = mix(level(q, i, j), level(p, i, j), xf);\n      S.bulbs.push({ x, y, tilt, kind: (j + i) % 4, lv });\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.bulbs.length) return;\n  const { light: L, rgb, bulbs, yw } = S, n = S.strands, wm = S.warmth;\n  // The bulbs' colours at this warmth, lit and dimmed.\n  const col = PAL.map((k) => [0, 1].map((m) => [0, 1, 2].map((c) => (wm \u003c 0 ? mix(k[1][m][c], k[0][m][c], -wm) : mix(k[1][m][c], k[2][m][c], wm)))));\n  const bulbCol = (b) => [0, 1, 2].map((c) => mix(col[b.kind][1][c], col[b.kind][0][c], cl((b.lv - 0.35) / 0.65, 0, 1)));\n  // The light on the wall: stepped rings round each bulb, by its brightness.\n  L.fill(0);\n  for (const b of bulbs) {\n    const c = col[b.kind][0], cx = b.x + 0.5 + BDY * sin(b.tilt), cy = b.y + BDY * cos(b.tilt), a = b.lv;\n    const R = RING[RING.length - 1][0];\n    for (let y = max(0, floor(cy - R)); y \u003c= min(H - 1, floor(cy + R)); y++)\n      for (let x = max(0, floor(cx - R)); x \u003c= min(W - 1, floor(cx + R)); x++) {\n        const r2 = (x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2;\n        if (r2 >= RR[3]) continue;\n        const s = r2 \u003c RR[0] ? RS[0] : r2 \u003c RR[1] ? RS[1] : r2 \u003c RR[2] ? RS[2] : RS[3];\n        const o = (y * W + x) * 3;\n        (L[o] += c[0] * s * a), (L[o + 1] += c[1] * s * a), (L[o + 2] += c[2] * s * a);\n      }\n  }\n  // The porch wall: clapboards 6 rows tall, each with a shadowed lower edge,\n  // dark violet and lit by the bulbs, its paint a little warmer or colder\n  // with the bulbs.\n  const ar = 0.85 + 0.15 * wm, ab = 0.85 - 0.15 * wm;\n  for (let y = 0; y \u003c H; y++) {\n    const edge = y % 6 === 5, alb = edge ? 0.53 : 1, br = edge ? 0.5 : 1;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      rgb[o] = 0.04 * br + alb * ar * min(1, L[o]);\n      rgb[o + 1] = 0.025 * br + alb * 0.85 * min(1, L[o + 1]);\n      rgb[o + 2] = 0.075 * br + alb * ab * min(1, L[o + 2]);\n    }\n  }\n  const put = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n  };\n  // The wires, dark green, lit where the bulbs are near.\n  for (let i = 0; i \u003c n; i++) {\n    let py = round(yw[i * W]);\n    for (let x = 0; x \u003c W; x++) {\n      const y = round(yw[i * W + x]);\n      for (let yy = min(py, y); yy \u003c= max(py, y); yy++) {\n        const o = (yy * W + x) * 3;\n        if (yy >= 0 && yy \u003c H) put(x, yy, 0.06 + 0.5 * min(1, L[o]), 0.12 + 0.5 * min(1, L[o + 1]), 0.05 + 0.5 * min(1, L[o + 2]));\n      }\n      py = y;\n    }\n  }\n  // The garland of paper bats on the second strand, one between each pair\n  // of bulbs on a thread 8 LEDs long, so they hang in the glow below the\n  // bulbs, each twisting on its thread.\n  const gi = 1, off = gi % 2 ? 7 : 2;\n  for (let j = 0; j \u003c 6; j++) {\n    const x0 = off + 5 + 10 * j;\n    if (x0 > W - 3) continue;\n    const yt = round(yw[gi * W + x0]), tw = S.pt * (1.3 + 0.37 * j) + j * 1.9, amp = 0.35 + 2.2 * S.wind;\n    const sw = cos(amp * sin(tw) + 0.25 * j), wid = max(0.12, abs(sw));\n    for (let yy = yt + 1; yy \u003c= yt + 8; yy++) put(x0, yy, 0.16, 0.13, 0.18);\n    const by = yt + 9, flap = sin(S.pt * 9 + j) > 0.6 ? 1 : 0;\n    for (let r = 0; r \u003c BAT.length; r++)\n      for (let cxx = 0; cxx \u003c 9; cxx++) {\n        if (BAT[r][cxx] !== \"#\") continue;\n        const dx = (cxx - 4) * wid, x = round(x0 + dx), y = by + r - (flap && abs(cxx - 4) > 2 && r \u003c 3 ? 1 : 0);\n        // A bat turned past a quarter shows its plain back, which takes a\n        // little more of the bulbs' light.\n        if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) {\n          const o = (y * W + x) * 3, lit = sw \u003c 0 ? 0.25 : 0.1;\n          put(x, y, 0.015 + lit * min(1, L[o]), 0.01 + lit * min(1, L[o + 1]), 0.02 + lit * min(1, L[o + 2]));\n        }\n      }\n  }\n  // The bulbs: a dark socket on the wire, then the glass, lit in its own\n  // colour with a paler fleck where it is brightest.\n  for (const b of bulbs) {\n    const c = bulbCol(b), s = sin(b.tilt), co = cos(b.tilt), bx = b.x + 0.5, by = b.y + 0.5;\n    for (let dx = -1; dx \u003c= 1; dx++) put(floor(bx + dx * co), floor(by + 0.5 - dx * s), 0.1, 0.13, 0.08);\n    const mx = bx + BDY * s, my = by + BDY * co, hot = cl((b.lv - 0.6) / 0.4, 0, 1) * 0.45;\n    for (let y = floor(my - 4); y \u003c= my + 4; y++)\n      for (let x = floor(mx - 4); x \u003c= mx + 4; x++) {\n        const px = x + 0.5 - mx, py = y + 0.5 - my, u = (px * co - py * s) / BRX, v = (px * s + py * co) / BRY, e = u * u + v * v;\n        if (e > 1) continue;\n        // The glass glows paler toward its middle, and a fleck shines up and left.\n        const m = e \u003c 0.3 ? hot : 0, fl = b.lv > 0.6 && u \u003c -0.2 && u > -0.75 && v \u003c -0.15 && v > -0.6 ? 0.55 : 0;\n        put(x, y, mix(c[0], 1, max(m, fl)), mix(c[1], 1, max(m, fl)), mix(c[2], 1, max(m, fl)));\n      }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n  }\n}\n","pit-pendulum":"// ===== Patternflow pattern =====\n// Title:   Pit and Pendulum\n// Family:  halloween\n// Idea:    A torchlit stone dungeon seen from the front: from a winch in the dark vault a long rod swings a huge steel crescent across the panel, its edge glinting and its shadows sweeping the wall, sinking a few LEDs with every pass toward an empty stone slab where rats gather; a hand above the slab the torches gutter, the blade stops, and the chain hauls it back up into the dark to start again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, after Edgar Allan Poe's story The Pit and the Pendulum (1842), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Descent=3..12, Torch=0..1\n//\n// Knob 1: Hue. The torch fire and the light it throws on the stone, in rings that turn toward violet as they dim: at 0 orange flames lighting the wall gold, orange, red and rose; at 0.1 red; at 0.25 magenta; at 0.4 violet; at 0.55 blue; at 0.75 cyan; at 1 green witch fire. Yellow is left out, because its dim rings turn olive. The slab and the steel stay pale.\n// Knob 2: Speed. At 2 the pendulum swings there and back in 2.3 s at the top of its run and 3.2 s just above the slab, as a real pendulum slows when it lengthens, and a whole descent with its haul back up takes 25 s at Descent 3. At 0.2 everything, flames too, runs ten times slower; at 3 half as fast again.\n// Knob 3: Descent. LEDs the blade sinks with each pass: at 3 it comes down from the middle of the panel to a hand above the slab in 14 passes, 18 seconds at Speed 2, while the rats on the slab grow from two to seven; at 12 it takes 4 passes and under 5 seconds.\n// Knob 4: Torch. How far the torchlight reaches: at 0.06 each torch lights the wall 66 LEDs round it in five steps, gold by the flame and rose at the edge, and the floor and the corners stay dark; at 1 the light reaches 100 LEDs and fills the dungeon.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => t * t * (3 - 2 * t);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The room: the vault's arch drops from row 12 at the middle to row 23 at\n// the sides, the wall meets the floor at row 104, and the slab's top face\n// runs rows 95 to 98 and its front 99 to 113, from column 9 to 54.\nconst FLOOR = 104, SLAB_X0 = 9, SLAB_X1 = 54, SLAB_TOP = 95, SLAB_FRONT = 99, SLAB_BOT = 113;\nconst archY = (x) => 12 + 20 * (1 - sqrt(max(0, 1 - ((x + 0.5 - 32) / 36) ** 2)));\n// The pendulum: the winch in the vault, the rod's length to the blade at\n// the start of a descent, at its end (the blade's edge a hand above the\n// slab) and hauled up; the rigid rod under the chain; how far the blade\n// reaches sideways at the end of a swing; the period at length 40.\nconst PX = 32, PY = 8, L_START = 34, L_END = 74, L_TOP = 10, ROD = 24, REACH = 22, T40 = 2.4;\n// The blade, a crescent hung by its middle with its horns up: inside the\n// outer circle and outside the inner one, both centred on the rod's line,\n// in LEDs with v down the rod from its end. Its edge is 7.8 below the\n// rod's end and its horns 20.8 to either side, 9.1 above it.\nconst OC = -13.46, OR = 21.26, IC = -28.33, IR = 28.33;\n// Two torches on the walls and the shadow's spread from each onto the wall.\nconst TX = [8, 56], TY = 52, SPREAD = 2.4;\n// The story at Speed 2: the torches gutter and the swing dies, the chain\n// hauls the blade into the dark, the torches catch again, it is let down.\nconst GUTTER = 1.4, HAUL = 3, RELIGHT = 0.7, LOWER = 1.5;\n\n// The rat, facing right, feet on the bottom row: # body, e eye.\nconst RAT = [\"     ##   \", \"  #####e# \", \" #######  \", \"## #   #  \"];\n\nexport function setup(params) {\n  // What each LED of the room is: 0 the dark vault, 1 the arch's stones,\n  // 2 and 3 the wall's blocks in two tones, 4 the mortar, 5 the floor's\n  // flags, 6 their joints.\n  const cls = new Uint8Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, ay = archY(x);\n      if (y \u003c ay) cls[i] = 0;\n      else if (y \u003c ay + 4) cls[i] = abs((x + 0.5 - 32) % 7) \u003c 0.6 ? 4 : 1;\n      else if (y \u003c FLOOR) {\n        const row = floor((y - 10) / 7), off = row % 2 ? 6 : 0, bx = floor((x + off) / 12);\n        const mortar = (y - 10) % 7 === 0 || (x + off) % 12 === 0;\n        cls[i] = mortar ? 4 : ((row * 7 + bx * 13) % 5) \u003c 2 ? 3 : 2;\n      } else {\n        const fy = y - FLOOR, band = fy === 0 || fy === 4 || fy === 9 || fy === 15 || fy === 22;\n        const k = ((x + 0.5 - 32) / (y - 70)) / 0.32, joint = abs(k - Math.round(k)) * (y - 70) * 0.32 \u003c 0.55;\n        cls[i] = band || joint ? 6 : 5;\n      }\n    }\n  const R = Math.random;\n  params.s = {\n    cls, rgb: new Float32Array(N * 3), pal: new Float64Array(8 * 3),\n    hue: 0.5, speed: 1.5, descent: 3.5, torch: 0.06, rt: 0.5, flick: new Float64Array(2),\n    // The story: phase, time in it, rod length, swing phase and how much\n    // of the swing is left, the torches' strength, the winch's turn.\n    phase: \"swing\", pt: 0.5, len: L_START + 2.5, phi: 0.35, amp: 0.5, fire: 0.5, wheel: 0.5, th: 0.5,\n    ax: 32.5, ay: 40.5,\n    // Two rats on the slab already, the rest come as the blade sinks.\n    rats: [\n      { side: 0, s: 52.5, to: 52.5, wait: 1.5, face: 1, wig: R() * TAU },\n      { side: 1, s: 58.5, to: 58.5, wait: 2.5, face: -1, wig: R() * TAU },\n    ],\n    spawn: 0.5,\n  };\n}\n\n// The rats' track from either side: in along the floor, up the end of the\n// slab, and along its top toward the middle. s counts LEDs from off-panel.\nconst TRACK = [[-10, 124], [7, 124], [10, 98], [31, 98]];\nconst SEG = TRACK.slice(1).map((p, k) => hypot(p[0] - TRACK[k][0], p[1] - TRACK[k][1]));\nconst TRACK_LEN = SEG.reduce((a, b) => a + b, 0), ON_SLAB = SEG[0] + SEG[1];\nfunction ratAt(r) {\n  let s = cl(r.s, 0, TRACK_LEN), k = 0;\n  while (k \u003c 2 && s > SEG[k]) (s -= SEG[k]), k++;\n  const a = TRACK[k], b = TRACK[k + 1], u = cl(s / SEG[k], 0, 1), x = a[0] + (b[0] - a[0]) * u;\n  return [r.side ? 63 - x : x, a[1] + (b[1] - a[1]) * u];\n}\n\nfunction rats(S, d, want) {\n  const R = Math.random;\n  S.spawn -= d;\n  const staying = S.rats.filter((r) => r.to > 0);\n  if (staying.length \u003c want && S.spawn \u003c= 0) {\n    S.rats.push({ side: R() \u003c 0.5 ? 0 : 1, s: 0, to: ON_SLAB + 3 + R() * (TRACK_LEN - ON_SLAB - 4), wait: 1 + R() * 2, face: 1, wig: R() * TAU });\n    S.spawn = 0.35 + 0.3 * R();\n  } else if (staying.length > want) staying[staying.length - 1].to = -2;\n  for (const r of S.rats) {\n    const gap = r.to - r.s;\n    if (abs(gap) > 0.3) {\n      // A rat runs at 16 LEDs a second, faster when it flees.\n      const v = (r.to \u003c 0 ? 30 : 16) * d;\n      r.s += cl(gap, -v, v);\n      r.face = (gap > 0 ? 1 : -1) * (r.side ? -1 : 1);\n    } else if ((r.wait -= d) \u003c= 0 && r.to > 0) {\n      // Now and then a rat shuffles along the slab.\n      r.to = cl(r.s + (R() - 0.5) * 12, ON_SLAB + 3, TRACK_LEN - 1);\n      r.wait = 1.2 + 2.5 * R();\n    }\n    r.wig += d * 9;\n  }\n  S.rats = S.rats.filter((r) => r.to > 0 || r.s > 0.5);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.descent = cl(k[2], 3, 12);\n  S.torch = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.rt += g;\n  S.pt += g;\n  // Each torch's light breathes and now and then jumps, on the story's clock.\n  for (let t = 0; t \u003c 2; t++) {\n    const c = S.rt * 1.7 + t * 2.3;\n    S.flick[t] = 0.88 + 0.07 * sin(c * 3.1) * sin(c * 1.3 + 1) + 0.05 * sin(c * 7.7 + t);\n  }\n  // A real pendulum: the swing's rate falls as the square root of its length.\n  const w = (TAU / T40) * sqrt(40 / S.len);\n  let want = 2;\n  if (S.phase === \"swing\") {\n    S.phi += w * g;\n    // Each pass, half a swing, lowers it Descent LEDs.\n    S.len += (S.descent * w * g) / PI;\n    S.amp = 1;\n    S.fire = 1;\n    want = 2 + Math.round((5 * (S.len - L_START)) / (L_END - L_START));\n    if (S.len >= L_END) (S.len = L_END), (S.phase = \"gutter\"), (S.pt = 0);\n  } else if (S.phase === \"gutter\") {\n    // The flames sink and sputter, and the swing dies to a stop over the slab.\n    const u = cl(S.pt / GUTTER, 0, 1);\n    S.phi += w * g;\n    S.amp = 1 - ease(u);\n    S.fire = 1 - 0.72 * ease(cl(u * 1.6, 0, 1));\n    want = 7;\n    if (u >= 1) (S.phase = \"haul\"), (S.pt = 0);\n  } else if (S.phase === \"haul\") {\n    const u = cl(S.pt / HAUL, 0, 1), was = S.len;\n    S.len = L_END + (L_TOP - L_END) * ease(u);\n    S.wheel += (was - S.len) / 5;\n    S.amp = 0;\n    S.fire = 0.28;\n    want = 0;\n    if (u >= 1) (S.phase = \"relight\"), (S.pt = 0);\n  } else if (S.phase === \"relight\") {\n    const u = cl(S.pt / RELIGHT, 0, 1);\n    S.fire = 0.28 + 0.72 * ease(u) + 0.25 * sin(PI * u);\n    want = 0;\n    if (u >= 1) (S.phase = \"lower\"), (S.pt = 0), (S.phi = 0);\n  } else {\n    // Let down to the middle of the panel, swinging again as it goes.\n    const u = cl(S.pt / LOWER, 0, 1), was = S.len;\n    S.len = L_TOP + (L_START - L_TOP) * ease(u);\n    S.wheel += (was - S.len) / 5;\n    S.phi += w * g;\n    S.amp = ease(u);\n    S.fire = 1;\n    want = 1;\n    if (u >= 1) (S.phase = \"swing\"), (S.pt = 0);\n  }\n  if (S.phase === \"swing\") S.wheel -= (S.descent * w * g) / PI / 5;\n  // The swing: the blade reaches REACH LEDs to either side at full swing.\n  S.th = S.amp * asin(min(1, REACH / S.len)) * sin(S.phi);\n  S.ax = PX + S.len * sin(S.th);\n  S.ay = PY + S.len * cos(S.th);\n  rats(S, d, want);\n}\n\n// Is (x, y) on the blade? Only the blade casts a shadow: the rod's, a thin\n// line across the whole wall, read as a second rope.\nfunction onBlade(S, x, y) {\n  const ex = sin(S.th), ey = cos(S.th), bx = x - S.ax, by = y - S.ay, u = bx * ey - by * ex, v = bx * ex + by * ey;\n  if (v > 8 || v \u003c -10 || abs(u) > 21) return false;\n  return u * u + (v - OC) ** 2 \u003c OR * OR && u * u + (v - IC) ** 2 > IR * IR;\n}\n\n// The frame's colours: the stone in six steps of torchlight, from unlit\n// through rings that turn from the fire's own hue toward violet as they\n// dim (gold, orange, red, rose for orange fire), so no ring goes brown.\n// Hue turns the fire from orange the long way round to green, past red,\n// violet and blue, and never through yellow, whose dim rings go olive.\nfunction palette(S) {\n  const P = S.pal, h = 0.075 - 0.775 * S.hue;\n  // The short way round the wheel from the fire's hue to violet.\n  let to = 0.76 - h;\n  to -= Math.round(to);\n  const ring = (f, s, v, o) => hsv(h + to * f, s, v, P, o * 3);\n  (P[0] = 0.04), (P[1] = 0.03), (P[2] = 0.07);\n  ring(0.75, 0.75, 0.2, 1);\n  ring(0.5, 0.85, 0.32, 2);\n  ring(0.25, 0.9, 0.48, 3);\n  ring(0.05, 0.88, 0.7, 4);\n  hsv(h + 0.03, 0.6, 0.92, P, 15);\n  // The flame's own colours: its hue at full and a pale core.\n  hsv(h, 0.9, 1, P, 18);\n  hsv(h + 0.05, 0.35, 1, P, 21);\n}\n\nfunction room(S, R) {\n  const { rgb, cls, pal: P } = S, LY = TY - 4, R2 = R * R;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, c = cls[i], o = i * 3;\n      if (c === 0) {\n        rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        continue;\n      }\n      let f = 0;\n      for (let t = 0; t \u003c 2; t++) {\n        const dx = x + 0.5 - TX[t], dy = y + 0.5 - LY, dd = dx * dx + dy * dy;\n        if (dd >= R2) continue;\n        // In the blade's shadow: the line back to the torch, cut at the\n        // pendulum's depth, meets the blade.\n        if (onBlade(S, TX[t] + dx / SPREAD, LY + dy / SPREAD)) continue;\n        f += (1 - sqrt(dd) / R) * S.flick[t];\n      }\n      let lv = min(5, floor(min(1, f * S.fire) * 6));\n      // Mortar and floor joints a step darker, the darker blocks a little.\n      if (c === 4 || c === 6) lv = max(0, lv - 1);\n      const dim = c === 3 ? 0.82 : c === 5 ? 0.9 : 1;\n      (rgb[o] = P[lv * 3] * dim), (rgb[o + 1] = P[lv * 3 + 1] * dim), (rgb[o + 2] = P[lv * 3 + 2] * dim);\n    }\n}\n\nfunction put(rgb, x, y, r, g, b) {\n  x = floor(x);\n  y = floor(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n}\nfunction add(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (rgb[o] += r), (rgb[o + 1] += g), (rgb[o + 2] += b);\n}\n\n// The torches: an iron bracket, a flame that leans and leaps, and round it\n// three steps of glow in the air.\nfunction torches(S) {\n  const { rgb, pal: P } = S, t = S.rt, fire = S.fire;\n  for (let k = 0; k \u003c 2; k++) {\n    const x0 = TX[k], fl = 0.75 + 0.25 * sin(t * 9.1 + k * 2) * sin(t * 4.3 + k), hgt = (6 + 3 * fl) * (0.4 + 0.6 * fire), lean = 0.8 * sin(t * 2.7 + k * 1.3);\n    for (let y = TY - 16; y \u003c= TY + 10; y++)\n      for (let x = x0 - 12; x \u003c= x0 + 12; x++) {\n        const dd = hypot(x + 0.5 - x0, y + 0.5 - (TY - 4)) / ((0.6 + 0.4 * fire) * S.flick[k]), a = dd \u003c 5 ? 0.42 : dd \u003c 8 ? 0.26 : dd \u003c 11 ? 0.13 : 0;\n        if (a > 0) add(rgb, x, y, P[18] * a * fire, P[19] * a * fire, P[20] * a * fire);\n      }\n    // The bracket and the torch's handle.\n    for (let y = TY; y \u003c= TY + 7; y++) put(rgb, x0, y, 0.22, 0.14, 0.1), put(rgb, x0 - 1, y, 0.3, 0.2, 0.13);\n    for (let x = x0 - 3; x \u003c= x0 + 3; x++) put(rgb, x, TY + 7, 0.28, 0.26, 0.3);\n    for (let y = 0; y \u003c hgt; y++) {\n      const q = y / hgt, wd = (q \u003c 0.35 ? 2.4 : 2.4 * (1 - (q - 0.35) / 0.65)) + 0.2, cx = x0 + lean * q * q;\n      for (let x = floor(cx - wd); x \u003c= cx + wd; x++) {\n        const core = abs(x + 0.5 - cx) \u003c wd * 0.45 && q \u003c 0.6;\n        const c = core ? 21 : 18;\n        put(rgb, x, TY - 1 - y, P[c], P[c + 1], P[c + 2]);\n      }\n    }\n  }\n}\n\n// The slab: a pale top face, its front in two steps, the torchlight on both.\nfunction slab(S, R) {\n  const { rgb, pal: P } = S, LY = TY - 4;\n  for (let y = SLAB_TOP; y \u003c= SLAB_BOT; y++)\n    for (let x = SLAB_X0; x \u003c= SLAB_X1; x++) {\n      const top = y \u003c SLAB_FRONT, edge = x === SLAB_X0 || x === SLAB_X1 || y === SLAB_FRONT;\n      let f = 0;\n      for (let t = 0; t \u003c 2; t++) f += max(0, 1 - hypot(x + 0.5 - TX[t], y + 0.5 - LY) / (R * 1.25));\n      const lv = min(4, floor(min(1, f * S.fire) * 6)), base = top ? 0.42 : y > SLAB_BOT - 3 ? 0.17 : 0.26, a = top ? 0.5 : 0.35;\n      const o = (y * W + x) * 3, e = edge ? 0.8 : 1;\n      (rgb[o] = (base + P[lv * 3] * a) * e), (rgb[o + 1] = (base * 0.94 + P[lv * 3 + 1] * a) * e), (rgb[o + 2] = (base * 1.08 + P[lv * 3 + 2] * a) * e);\n    }\n}\n\nfunction drawRats(S) {\n  const { rgb } = S;\n  for (const r of S.rats) {\n    const [x0, y0] = ratAt(r), sit = abs(r.to - r.s) \u003c 0.3, bob = sit ? (sin(r.wig) > 0.6 ? -1 : 0) : floor(r.wig) % 2 ? -1 : 0;\n    for (let ry = 0; ry \u003c 4; ry++)\n      for (let rx = 0; rx \u003c 10; rx++) {\n        const ch = RAT[ry][rx];\n        if (ch === \" \") continue;\n        const x = x0 + (r.face > 0 ? rx - 5 : 4 - rx), y = y0 - 3 + ry + (ry \u003c 2 ? bob : 0);\n        // The eye catches the torchlight, and burns red while the torches gutter.\n        if (ch === \"e\") put(rgb, x, y, 1, S.fire \u003c 0.6 ? 0.1 : 0.35, 0.2);\n        else {\n          // Black fur, the ears and back caught by the torches.\n          const rim = (ry === 0 || (ry === 1 && RAT[0][rx] === \" \")) * S.fire;\n          put(rgb, x, y, 0.07 + 0.26 * rim, 0.05 + 0.15 * rim, 0.07 + 0.14 * rim);\n        }\n      }\n    // The tail, a curl along the stone.\n    for (let q = 1; q \u003c= 5; q++) put(rgb, x0 + (r.face > 0 ? -5 - q : 4 + q), y0 + (q > 3 ? -1 : 0), 0.13, 0.08, 0.1);\n  }\n}\n\nfunction pendulum(S) {\n  const { rgb, pal: P } = S, ex = sin(S.th), ey = cos(S.th), lit = 0.45 + 0.55 * S.fire;\n  // The winch in the vault: a drum that turns as the chain pays out, its\n  // rim and four spokes.\n  for (let y = PY - 6; y \u003c= PY + 6; y++)\n    for (let x = PX - 6; x \u003c= PX + 6; x++) {\n      const r = hypot(x + 0.5 - PX, y + 0.5 - PY);\n      if (r \u003c 5.8) put(rgb, x, y, (r > 4.6 ? 0.36 : 0.15) * lit, (r > 4.6 ? 0.32 : 0.13) * lit, (r > 4.6 ? 0.37 : 0.17) * lit);\n    }\n  for (let s = 0; s \u003c 4; s++) {\n    const t = S.wheel + (s * PI) / 2;\n    for (let q = 1; q \u003c 5; q++) put(rgb, PX + q * cos(t), PY + q * sin(t), 0.3 * lit, 0.27 * lit, 0.31 * lit);\n  }\n  // The chain from the winch, its links moving with it, then the iron rod.\n  for (let q = 0; q \u003c= S.len * 2; q++) {\n    const a = q / 2, x = PX + a * ex, y = PY + a * ey;\n    if (a \u003c S.len - ROD) {\n      // Links lying flat and edge on by turns, each 4 LEDs.\n      let link = (a + S.wheel * 5) % 4;\n      if (link \u003c 0) link += 4;\n      const b = link \u003c 2.5 ? 0.58 : 0.22, b2 = link \u003c 2.5 ? 0.24 : 0.46;\n      put(rgb, x, y, b * lit, b * 0.94 * lit, b * 0.9 * lit);\n      put(rgb, x + ey, y - ex, b2 * lit, b2 * 0.94 * lit, b2 * 0.92 * lit);\n    } else {\n      put(rgb, x, y, 0.62 * lit, 0.58 * lit, 0.58 * lit);\n      put(rgb, x + ey, y - ex, 0.3 * lit, 0.27 * lit, 0.32 * lit);\n    }\n  }\n  // The blade: dark steel inside, brighter toward the edge, the edge itself\n  // near white, and a glint that runs along it and flares as it passes the bottom.\n  const gl = sin(S.phi) * S.amp, flare = S.amp * max(0, 1 - abs(cos(S.phi)) * 4);\n  // Hauled up into the vault the blade leaves the torchlight.\n  const bl = lit * cl((S.ay - 8) / 30, 0.3, 1);\n  for (let y = floor(S.ay - 22); y \u003c= S.ay + 22; y++)\n    for (let x = floor(S.ax - 22); x \u003c= S.ax + 22; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const bx = x + 0.5 - S.ax, by = y + 0.5 - S.ay, u = bx * ey - by * ex, v = bx * ex + by * ey;\n      const dOut = OR - sqrt(u * u + (v - OC) ** 2), dIn = sqrt(u * u + (v - IC) ** 2) - IR;\n      if (dOut \u003c= 0 || dIn \u003c= 0) continue;\n      const hot = abs(u + gl * 16) \u003c 2.6 && dOut \u003c 1.5;\n      const st = dOut \u003c 1.1 ? (hot ? 1 : 0.92) : dOut \u003c 2.4 ? 0.62 : 0.4;\n      const tint = dOut \u003c 1.1 ? 0.08 : 0.2;\n      const o = (y * W + x) * 3;\n      (rgb[o] = (st * (1 - tint) + P[12] * tint) * bl), (rgb[o + 1] = (st * 0.98 * (1 - tint) + P[13] * tint) * bl), (rgb[o + 2] = (st * 1.04 * (1 - tint) + P[14] * tint) * bl);\n    }\n  if (flare > 0.05) {\n    // A four-pointed star of light on the edge, under the rod.\n    const sx = S.ax + ex * 7.5, sy = S.ay + ey * 7.5, n = 2 + floor(5 * flare);\n    for (let q = -n; q \u003c= n; q++) {\n      const a = 1 - abs(q) / (n + 1);\n      put(rgb, sx + q, sy, 1, 1, 0.9 * a + 0.1);\n      put(rgb, sx, sy + q, 1, 1, 0.9 * a + 0.1);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, R = 64 + 36 * S.torch;\n  palette(S);\n  room(S, R);\n  torches(S);\n  slab(S, R);\n  drawRats(S);\n  pendulum(S);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","square-peg":"// ===== Patternflow pattern =====\n// Title:   Square Peg\n// Family:  topology\n// Idea:    A closed curve wobbles and twists its lobes into curling arms without ever crossing itself, and every frame all the squares with their four corners on it are found afresh and drawn as bright outlines over its dim inside, born and dying in pairs as it changes while their count stays odd.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: inscribed square problem (Otto Toeplitz, 1911), solved for smooth curves (Lev Schnirelmann, 1929); inscribed rectangles of every aspect ratio (Joshua Greene and Andrew Lobb, 2020), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Ratio=1..3, Wobble=0..1\n//\n// Knob 1: Hue. Moves the whole palette along a strip of the wheel from green through cyan, blue and violet to rose, leaving out red, orange and yellow, which go brown and olive when dim: at 0 the curve's inside is deep blue and its squares green, violet and rose; at 0.28 the inside is rose and the squares green to violet; at 0.78 the inside is green and the squares cyan to rose; at 1 blue again.\n// Knob 2: Speed. At 2 each lobe swells and shrinks every 13 to 25 seconds while it turns, and the twist swings from one side to the other and back in 33 seconds; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Ratio. The aspect ratio of the rectangles sought: at 1 squares, at 2 rectangles twice as long as they are wide, at 3 three times. Each square at 1 becomes two rectangles as the ratio leaves it, so away from 1 the count is even in more than nine frames of ten.\n// Knob 4: Wobble. How far the curve folds: at 0.06 its lobes reach 0.41 of the mean radius in and out and the twist turns its outermost points up to 2.5 radians past its innermost, and one to five squares stand on it; at 1 the lobes reach 0.5 and the twist 3.6 radians, the arms curl over the valleys between them, and up to 23 squares stand at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n// Every colour comes off a strip of the wheel that skips red, orange and\n// yellow, which turn brown and olive when dim: u from 0 to 1 runs green,\n// cyan, blue, violet, magenta to rose.\nconst wheel = (u) => 0.34 + 0.63 * u;\n\n// The curve. In its own plane it is star-shaped, r0(th) = 1 + four Fourier\n// lobes; then a twist turns each point by tau * rho^2 about the centre, a\n// smooth map of the plane onto itself with a smooth inverse, so the image\n// is still a simple closed curve however far it curls; then it is\n// stretched to stand 2:1 on the panel. Its implicit function, phi(x) =\n// rho - r0(angle - tau * rho^2) after undoing the stretch, is zero exactly\n// on the curve and negative inside, and angle - tau * rho^2 of a point on\n// the curve is its parameter.\nconst MODES = [2, 3, 4, 5], WEIGHT = [0.22, 0.36, 0.26, 0.16];\nconst CX = 32, CY = 64, HALF_W = 29.5, HALF_H = 61.5;\n// Curve samples for the search and for drawing, and the r0 table.\nconst M = 128, MD = 480, TAB = 1024;\n// The search drops candidate pairs this close along the curve (the trivial\n// squares of side 0) and solutions with a side under MIN_SIDE LEDs.\nconst NEAR = 2, MIN_SIDE = 3;\n// Seconds a square born or dying flashes; frames a square may go unfound\n// before it counts as dead.\nconst FLASH = 0.6, MISS = 2;\n\nexport function setup(params) {\n  const R = Math.random;\n  params.s = {\n    // Each lobe: rate and phase of its swell, rate and start of its turn.\n    nu: MODES.map(() => 0.25 + 0.25 * R()), c0: MODES.map(() => TAU * R()),\n    mu: MODES.map((k, i) => (i % 2 ? -1 : 1) * (0.08 + 0.12 * R()) * (3 / k)), p0: MODES.map(() => TAU * R()),\n    amp: new Float64Array(4), ph: new Float64Array(4), ac: new Float64Array(4), as: new Float64Array(4),\n    t: 0.5, hue: 0.5, speed: 1.5, ratio: 1.5, wob: 0.06, tau: 0.5, sx: 20.5, sy: 40.5,\n    tab: new Float64Array(TAB + 1), phi: new Float32Array(N), ring: new Uint8Array(N),\n    px: new Float64Array(M), py: new Float64Array(M), f1: new Float32Array(M * M), f2: new Float32Array(M * M), done: new Uint8Array(M * M),\n    sq: [], ghosts: [], next: 0, first: true, gp: new Float64Array(4), gq: new Float64Array(4),\n    // What the search found: frames searched at ratio 1, frames with a\n    // square, frames with an odd count, the largest corner residual in\n    // LEDs, and how many frames had each count.\n    stat: { frames: 0, found: 0, odd: 0, res: 0, hist: {} },\n    rgb: new Float32Array(N * 3), col: new Float64Array(3), pal: new Float64Array(24),\n  };\n}\n\n// r0 exactly, for the solver and the drawn line; the table, for the field.\n// The lobes are cos(k th - ph) for k = 2..5, built from cos th and sin th\n// by the multiple-angle recurrence, with a * cos ph and a * sin ph kept per\n// frame. The slope dr0/dth is left in RD.\nlet RD = 0;\nfunction r0(S, th) {\n  const c1 = cos(th), s1 = sin(th), ac = S.ac, as = S.as;\n  let ck = c1 * c1 - s1 * s1, sk = 2 * s1 * c1, r = 1 + ac[0] * ck + as[0] * sk, dr = 2 * (as[0] * ck - ac[0] * sk);\n  for (let m = 1; m \u003c 4; m++) {\n    const c = ck * c1 - sk * s1;\n    sk = sk * c1 + ck * s1;\n    ck = c;\n    r += ac[m] * ck + as[m] * sk;\n    dr += (m + 2) * (as[m] * ck - ac[m] * sk);\n  }\n  RD = dr;\n  return r;\n}\n// The curve's point at parameter s and its velocity, in LEDs.\nfunction gamma(S, s, out) {\n  const r = r0(S, s), dr = RD, a = s + S.tau * r * r, da = 1 + 2 * S.tau * r * dr, ca = cos(a), sa = sin(a);\n  out[0] = CX + S.sx * r * ca;\n  out[1] = CY + S.sy * r * sa;\n  out[2] = S.sx * (dr * ca - r * sa * da);\n  out[3] = S.sy * (dr * sa + r * ca * da);\n}\n// The field and its slope per LED.\nfunction phiAt(S, x, y, g) {\n  const X = (x - CX) / S.sx, Y = (y - CY) / S.sy, rr = X * X + Y * Y, rho = sqrt(rr);\n  const f = rho - r0(S, atan2(Y, X) - S.tau * rr), dr = RD;\n  if (g) {\n    g[0] = (X / rho - dr * (-Y / rr - 2 * S.tau * X)) / S.sx;\n    g[1] = (Y / rho - dr * (X / rr - 2 * S.tau * Y)) / S.sy;\n  }\n  return f;\n}\n// atan2 to within 1e-5 rad, for the per-LED field only; the solver uses\n// the exact one.\nfunction fatan2(y, x) {\n  const ax = abs(x), ay = abs(y), a = min(ax, ay) / (max(ax, ay) || 1), q = a * a;\n  let r = ((-0.0464964749 * q + 0.15931422) * q - 0.327622764) * q * a + a;\n  if (ay > ax) r = 1.57079637 - r;\n  if (x \u003c 0) r = 3.14159274 - r;\n  return y \u003c 0 ? -r : r;\n}\nfunction paramOf(S, x, y) {\n  const X = (x - CX) / S.sx, Y = (y - CY) / S.sy, a = atan2(Y, X) - S.tau * (X * X + Y * Y);\n  return a - floor(a / TAU) * TAU;\n}\n\n// The rectangle on side p(s) -> q(t), its other side Ratio times as long:\n// corners in o[0..7], the field at the two far corners in o[8], o[9] (both\n// zero is a rectangle), and their slopes in s and t in o[10..13].\nconst GR = new Float64Array(2), GU = new Float64Array(2);\nfunction corners(S, s, t, o) {\n  const P = S.gp, Q = S.gq, k = S.ratio;\n  gamma(S, s, P);\n  gamma(S, t, Q);\n  const jx = -(Q[1] - P[1]) * k, jy = (Q[0] - P[0]) * k;\n  (o[0] = P[0]), (o[1] = P[1]), (o[2] = Q[0]), (o[3] = Q[1]);\n  (o[4] = Q[0] + jx), (o[5] = Q[1] + jy), (o[6] = P[0] + jx), (o[7] = P[1] + jy);\n  o[8] = phiAt(S, o[4], o[5], GR);\n  o[9] = phiAt(S, o[6], o[7], GU);\n  // r = q + kJ(q - p) and u = p + kJ(q - p), J the quarter turn.\n  o[10] = GR[0] * k * P[3] - GR[1] * k * P[2];\n  o[11] = GR[0] * (Q[2] - k * Q[3]) + GR[1] * (Q[3] + k * Q[2]);\n  o[12] = GU[0] * (P[2] + k * P[3]) + GU[1] * (P[3] - k * P[2]);\n  o[13] = -GU[0] * k * Q[3] + GU[1] * k * Q[2];\n}\n\n// Newton's method on (s, t) from a cell of the search grid.\nconst V = new Float64Array(14);\nfunction solve(S, s, t) {\n  for (let it = 0; it \u003c 14; it++) {\n    corners(S, s, t, V);\n    if (abs(V[8]) + abs(V[9]) \u003c 1e-13) return true;\n    // Near the diagonal s = t every corner falls on p, the square of side 0,\n    // and a start drawn toward it is given up.\n    if (it >= 2 && abs(V[2] - V[0]) + abs(V[3] - V[1]) \u003c MIN_SIDE / 2) return false;\n    const a = V[10], b = V[11], c = V[12], d = V[13], det = a * d - b * c;\n    if (!det) return false;\n    let ds = (d * V[8] - b * V[9]) / det, dt = (a * V[9] - c * V[8]) / det;\n    const step = max(abs(ds), abs(dt));\n    if (step > 0.06) (ds *= 0.06 / step), (dt *= 0.06 / step);\n    s -= ds;\n    t -= dt;\n  }\n  return false;\n}\n\nfunction search(S) {\n  const { px, py, f1, f2, done, phi: F } = S, k = S.ratio;\n  for (let i = 0; i \u003c M; i++) {\n    gamma(S, (TAU * i) / M, S.gp);\n    (px[i] = S.gp[0]), (py[i] = S.gp[1]);\n  }\n  // The field at each far corner, read between LED centres; off the panel\n  // is outside.\n  for (let i = 0; i \u003c M; i++) {\n    const xi = px[i], yi = py[i];\n    for (let j = 0; j \u003c M; j++) {\n      const jx = -(py[j] - yi) * k, jy = (px[j] - xi) * k, o = i * M + j;\n      for (let c = 0; c \u003c 2; c++) {\n        const x = (c ? xi : px[j]) + jx - 0.5, y = (c ? yi : py[j]) + jy - 0.5;\n        let f = 0.5;\n        if (x > -0.5 && x \u003c W - 0.5 && y > -0.5 && y \u003c H - 0.5) {\n          const gx = x \u003c 0 ? 0 : x > W - 1.001 ? W - 1.001 : x, gy = y \u003c 0 ? 0 : y > H - 1.001 ? H - 1.001 : y;\n          const ix = gx | 0, iy = gy | 0, fx = gx - ix, fy = gy - iy, n = iy * W + ix;\n          f = (F[n] + (F[n + 1] - F[n]) * fx) * (1 - fy) + (F[n + W] + (F[n + W + 1] - F[n + W]) * fx) * fy;\n        }\n        if (c) f2[o] = f;\n        else f1[o] = f;\n      }\n    }\n  }\n  done.fill(0);\n  // A cell where both far corners cross the curve may hold a solution.\n  // Newton starts where the two fields, each taken as a plane through the\n  // cell, cross, kept to within a cell of it. Each rectangle turns up once\n  // per side that can be p -> q, four for a square and two otherwise, so\n  // once one is found the cells of the others are done.\n  const found = [], sqr = abs(k - 1) \u003c 1e-9, period = sqr ? PI / 2 : PI;\n  const mark = (a, b) => (done[floor((a / TAU) * M) * M + floor((b / TAU) * M)] = 1);\n  for (let i = 0; i \u003c M; i++) {\n    const i1 = (i + 1) % M;\n    for (let j = 0; j \u003c M; j++) {\n      const gap = abs(i - j), a = i * M + j;\n      if (min(gap, M - gap) \u003c= NEAR || done[a]) continue;\n      const j1 = (j + 1) % M, b = i * M + j1, c = i1 * M + j, d = i1 * M + j1;\n      const A1 = f1[a], B1 = f1[b], C1 = f1[c], D1 = f1[d], A2 = f2[a], B2 = f2[b], C2 = f2[c], D2 = f2[d];\n      if ((A1 > 0) === (B1 > 0) && (A1 > 0) === (C1 > 0) && (A1 > 0) === (D1 > 0)) continue;\n      if ((A2 > 0) === (B2 > 0) && (A2 > 0) === (C2 > 0) && (A2 > 0) === (D2 > 0)) continue;\n      const m1 = (A1 + B1 + C1 + D1) / 4, u1 = (C1 + D1 - A1 - B1) / 2, w1 = (B1 + D1 - A1 - C1) / 2;\n      const m2 = (A2 + B2 + C2 + D2) / 4, u2 = (C2 + D2 - A2 - B2) / 2, w2 = (B2 + D2 - A2 - C2) / 2, det = u1 * w2 - w1 * u2;\n      if (!det) continue;\n      const di = cl((-m1 * w2 + w1 * m2) / det, -1, 1), dj = cl((-u1 * m2 + m1 * u2) / det, -1, 1);\n      if (!solve(S, (TAU * (i + 0.5 + di)) / M, (TAU * (j + 0.5 + dj)) / M)) continue;\n      const len = hypot(V[2] - V[0], V[3] - V[1]);\n      if (len \u003c MIN_SIDE) continue;\n      const v = Array.from(V.subarray(0, 8)), ps = [0, 1, 2, 3].map((q) => paramOf(S, v[2 * q], v[2 * q + 1]));\n      for (let q = 0; q \u003c 4; q += sqr ? 1 : 2) mark(ps[q], ps[(q + 1) % 4]);\n      const cx = (v[0] + v[2] + v[4] + v[6]) / 4, cy = (v[1] + v[3] + v[5] + v[7]) / 4;\n      let ang = atan2(v[3] - v[1], v[2] - v[0]) % period;\n      if (ang \u003c 0) ang += period;\n      let dup = false;\n      for (const f of found) {\n        let da = abs(f.ang - ang);\n        da = min(da, period - da);\n        if (abs(f.cx - cx) \u003c 0.05 && abs(f.cy - cy) \u003c 0.05 && abs(f.len - len) \u003c 0.05 && da \u003c 0.005) dup = true;\n      }\n      if (!dup) found.push({ cx, cy, len, ang, v });\n    }\n  }\n  return found;\n}\n\n// Each square found takes the id and age of the nearest one last frame;\n// the rest are born. One unfound for more than MISS frames dies.\nfunction track(S, found, dt) {\n  const old = S.sq, used = new Uint8Array(old.length), next = [];\n  for (const f of found) {\n    let best = -1, bc = 4;\n    old.forEach((o, i) => {\n      if (used[i]) return;\n      const c = hypot(o.cx - f.cx, o.cy - f.cy) + abs(o.len - f.len);\n      if (c \u003c bc) (bc = c), (best = i);\n    });\n    if (best >= 0) (used[best] = 1), (f.id = old[best].id), (f.age = old[best].age + dt);\n    else (f.id = S.next++), (f.age = S.first ? 9 : 0);\n    f.miss = 0;\n    next.push(f);\n  }\n  old.forEach((o, i) => {\n    if (used[i]) return;\n    if (++o.miss > MISS) S.ghosts.push({ v: o.v, life: FLASH });\n    else (o.age += dt), next.push(o);\n  });\n  for (const g of S.ghosts) g.life -= dt;\n  S.ghosts = S.ghosts.filter((g) => g.life > 0);\n  S.sq = next;\n  S.first = false;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.ratio = cl(kv[2], 1, 3);\n  S.wob = cl(kv[3], 0, 1);\n  S.t += (d * S.speed) / 2;\n  const t = S.t, A = 0.4 + 0.1 * S.wob;\n  for (let m = 0; m \u003c 4; m++) {\n    S.amp[m] = A * WEIGHT[m] * (0.7 + 0.3 * sin(S.nu[m] * t + S.c0[m]));\n    S.ph[m] = S.p0[m] + S.mu[m] * t;\n    (S.ac[m] = S.amp[m] * cos(S.ph[m])), (S.as[m] = S.amp[m] * sin(S.ph[m]));\n  }\n  let rmax = 0;\n  for (let i = 0; i \u003c= TAB; i++) rmax = max(rmax, (S.tab[i] = r0(S, (TAU * i) / TAB)));\n  // The twist turns a point at radius 1 + A this far past one at 1 - A,\n  // swinging from one side to the other; and the curve is scaled to just fit.\n  S.tau = ((2.4 + 1.2 * S.wob) * sin(0.19 * t + 1.1)) / (4 * A);\n  (S.sx = HALF_W / rmax), (S.sy = HALF_H / rmax);\n  const F = S.phi, tab = S.tab;\n  for (let y = 0; y \u003c H; y++) {\n    const Y = (y + 0.5 - CY) / S.sy;\n    for (let x = 0; x \u003c W; x++) {\n      const X = (x + 0.5 - CX) / S.sx, rho2 = X * X + Y * Y;\n      let u = ((fatan2(Y, X) - S.tau * rho2) / TAU) * TAB;\n      u -= floor(u / TAB) * TAB;\n      const iu = u | 0;\n      F[y * W + x] = sqrt(rho2) - (tab[iu] + (tab[iu + 1] - tab[iu]) * (u - iu));\n    }\n  }\n  const found = search(S);\n  if (S.ratio === 1) {\n    const st = S.stat;\n    st.frames++;\n    if (found.length) st.found++;\n    if (found.length % 2) st.odd++;\n    st.hist[found.length] = (st.hist[found.length] || 0) + 1;\n    for (const f of found)\n      for (let c = 0; c \u003c 4; c++) {\n        // A corner's distance from the curve in LEDs: the field over its slope.\n        const e = abs(phiAt(S, f.v[2 * c], f.v[2 * c + 1], GR));\n        st.res = max(st.res, e / hypot(GR[0], GR[1]));\n      }\n  }\n  track(S, found, d);\n}\n\n// The inside: blue at Hue 0, along the strip to rose at 0.28, back down\n// to green at 0.78 and up to blue again at 1. A square's own colour: its id\n// picks a place on the rest of the strip, at least a quarter of it away\n// from the inside's.\nconst U0 = 0.444;\nconst insideAt = (S) => {\n  const f = (U0 + 2 * S.hue) % 2;\n  return f > 1 ? 2 - f : f;\n};\nfunction squareHue(S, id) {\n  const p = insideAt(S), lo = max(0, p - 0.25), x = ((id * 0.618034) % 1) * (lo + max(0, 0.75 - p));\n  return wheel(x \u003c lo ? x : x - lo + p + 0.25);\n}\n\nfunction line(rgb, x0, y0, x1, y1, r, g, b) {\n  const n = max(1, Math.ceil(hypot(x1 - x0, y1 - y0) * 2));\n  for (let q = 0; q \u003c= n; q++) {\n    const x = floor(x0 + ((x1 - x0) * q) / n), y = floor(y0 + ((y1 - y0) * q) / n);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3;\n    (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n  }\n}\n\n// The square's inside in its own colour, except on the curve's line.\nfunction fill(S, v, r, g, b) {\n  const { rgb, ring } = S, xs = [v[0], v[2], v[4], v[6]], ys = [v[1], v[3], v[5], v[7]];\n  const x0 = max(0, floor(min(...xs))), x1 = min(W - 1, floor(max(...xs))), y0 = max(0, floor(min(...ys))), y1 = min(H - 1, floor(max(...ys)));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let pos = 0, neg = 0;\n      for (let c = 0; c \u003c 4; c++) {\n        const ax = xs[c], ay = ys[c], cr = (xs[(c + 1) % 4] - ax) * (py - ay) - (ys[(c + 1) % 4] - ay) * (px - ax);\n        if (cr > 0) pos++;\n        else neg++;\n      }\n      const i = y * W + x;\n      if ((pos && neg) || ring[i] === 3) continue;\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, ring, phi, col } = S, hb = wheel(insideAt(S));\n  // The line: the curve sampled finely, so a fold thinner than an LED still\n  // draws both its sides. Then two rings round it.\n  ring.fill(0);\n  let a = [], b = [], x0 = 0, y0 = 0;\n  for (let q = 0; q \u003c= MD; q++) {\n    gamma(S, (TAU * q) / MD, S.gp);\n    const x1 = S.gp[0], y1 = S.gp[1], n = q ? Math.ceil(2 * max(abs(x1 - x0), abs(y1 - y0))) : 0;\n    for (let e = 0; e \u003c= n; e++) {\n      const x = floor(x1 + ((x0 - x1) * e) / (n || 1)), y = floor(y1 + ((y0 - y1) * e) / (n || 1)), i = y * W + x;\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H && !ring[i]) (ring[i] = 3), a.push(i);\n    }\n    (x0 = x1), (y0 = y1);\n  }\n  for (let lv = 2; lv > 0; lv--) {\n    for (const i of a) {\n      const x = i % W;\n      if (x > 0 && !ring[i - 1]) (ring[i - 1] = lv), b.push(i - 1);\n      if (x \u003c W - 1 && !ring[i + 1]) (ring[i + 1] = lv), b.push(i + 1);\n      if (i >= W && !ring[i - W]) (ring[i - W] = lv), b.push(i - W);\n      if (i \u003c N - W && !ring[i + W]) (ring[i + W] = lv), b.push(i + W);\n    }\n    (a = b), (b = []);\n  }\n  // Inside dim and flat with a brighter band along the line; outside black\n  // with a two-step halo. Five colours, no gradient. pal holds them by\n  // ring outside (0..3) and then ring inside (4..7).\n  const pal = S.pal, lv = [[0, 0, 0], [hb, 0.85, 0.2], [hb, 0.75, 0.42], [hb + 0.03, 0.35, 1], [hb, 0.85, 0.2], [hb, 0.8, 0.3], [hb, 0.75, 0.36], [hb + 0.03, 0.35, 1]];\n  for (let c = 0; c \u003c 8; c++) hsv(lv[c][0], lv[c][1], lv[c][2], pal, c * 3);\n  for (let i = 0, o = 0; i \u003c N; i++, o += 3) {\n    const c = (ring[i] + (phi[i] \u003c 0 ? 4 : 0)) * 3;\n    (rgb[o] = pal[c]), (rgb[o + 1] = pal[c + 1]), (rgb[o + 2] = pal[c + 2]);\n  }\n  // Squares, largest first so small ones show on top: the inside in the\n  // square's colour, then the outline, then the corners.\n  const list = S.sq.slice().sort((a, b) => b.len - a.len);\n  for (const f of list) {\n    const h = squareHue(S, f.id);\n    hsv(h, 0.8, 0.42, col, 0);\n    fill(S, f.v, col[0], col[1], col[2]);\n  }\n  for (const f of list) {\n    // Newborn squares flash white and settle into their colour.\n    const v = f.v, wh = f.age \u003c FLASH ? 1 - f.age / FLASH : 0;\n    hsv(squareHue(S, f.id), 0.6 * (1 - wh), 1, col, 0);\n    for (let c = 0; c \u003c 4; c++) line(rgb, v[2 * c], v[2 * c + 1], v[(2 * c + 2) % 8], v[(2 * c + 3) % 8], col[0], col[1], col[2]);\n    for (let c = 0; c \u003c 4; c++) {\n      const x = floor(v[2 * c]), y = floor(v[2 * c + 1]);\n      for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) {\n        const X = x + dx, Y = y + dy;\n        if (X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const o = (Y * W + X) * 3, core = dx === 0 && dy === 0;\n        (rgb[o] = core ? 1 : col[0]), (rgb[o + 1] = core ? 1 : col[1]), (rgb[o + 2] = core ? 1 : col[2]);\n      }\n    }\n  }\n  // A square that died flashes white where it last stood, then goes.\n  for (const g of S.ghosts) {\n    const a = floor((g.life / FLASH) * 4) / 4 + 0.25;\n    for (let c = 0; c \u003c 4; c++) line(rgb, g.v[2 * c], g.v[2 * c + 1], g.v[(2 * c + 2) % 8], g.v[(2 * c + 3) % 8], a, a, a);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, (255 * cl(rgb[o], 0, 1)) | 0, (255 * cl(rgb[o + 1], 0, 1)) | 0, (255 * cl(rgb[o + 2], 0, 1)) | 0);\n}\n","tennis-racket":"// ===== Patternflow pattern =====\n// Title:   Tennis Racket\n// Family:  sim\n// Idea:    A T-handle spinning about its middle axis turns itself over by half a turn again and again while its angular momentum stays fixed and upright, and below it the momentum seen from the handle runs round the momentum sphere along the polhodes, past the separatrix that joins the two ends of the middle axis.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the tennis racket theorem: Euler's equations of a free rigid body (Leonhard Euler, 1765) and their polhodes (Louis Poinsot, 1834), seen in a wing nut by Vladimir Dzhanibekov on Salyut 7 (1985), pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Axis=-1..1, Nudge=0..1\n//\n// Knob 1: Hue. Turns the three colours round the wheel together: at 0 the crossbar and the polhodes round its axis are azure, the stem, its tip and the momentum's trail amber, and the polhodes round the third axis violet; at 0.5 they are orange, blue and green. Orange and yellow are kept bright so they never dim to brown.\n// Knob 2: Speed. At 2 the handle spins at 4 radians a second, so the first flip comes at 2.3 seconds and the next ones every 3.9 seconds. At 0.2 time runs ten times slower, at 3 half as fast again.\n// Knob 3: Axis. Which principal axis the throw starts near: at 0 the middle one, the stem, and the handle flips; at -1 the smallest, the crossbar, and at 1 the largest, the normal to the T, where it only wobbles round a small polhode. Between them it starts on a wider polhode and rolls over steadily instead of flipping: once every 1.5 seconds at 0.5 and every 1.0 at -0.5. A new setting throws again 0.3 seconds after the knob stops.\n// Knob 4: Nudge. How far off that axis the throw starts: 0.072 radians at the opening 0.06, 1.2 radians at 1. At 0 it spins exactly about the middle axis and never flips. The time between flips grows like log(1 / nudge): 5.1, 3.9, 2.6 and 2.0 seconds at nudges of 0.017, 0.06, 0.25 and 0.5, and each e-fold smaller nudge adds 0.93 seconds.\n// Buttons: any button throws again with the knobs as they are.\n\nconst W = 64, H = 128, N = W * H, HALF = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// How near a hue is to orange and yellow, 0 to 1.\nconst warm = (h) => max(0, 1 - abs(h - floor(h) - 0.11) / 0.13);\nconst nrm = (p) => {\n  const l = hypot(p[0], p[1], p[2]) || 1;\n  return [p[0] / l, p[1] / l, p[2] / l];\n};\n\n// The T-handle as two boxes of one density, centre and half sizes: the\n// crossbar along the body's x axis and the stem along y, both centred on\n// x = z = 0, so x, y and z through the centre of mass are its principal axes.\n// Worked out in setup, per unit mass, the moments are 0.160, 0.306 and\n// 0.448: the crossbar's axis is the smallest, the stem's the middle, the\n// normal to the T the largest, in the ratio 1 : 1.917 : 2.807.\nconst BOXES = [\n  [0, 0, 0, 1.1, 0.17, 0.17],\n  [0, 0.76, 0, 0.14, 0.59, 0.14],\n];\n// Spin about the middle axis at Speed 2, radians a second.\nconst OMEGA = 4;\n// Nudge 1 starts the throw this many radians off the axis.\nconst NUDGE = 1.2;\n// The nudge leans the start toward this body direction (made perpendicular\n// to the start axis), 16 degrees off the separatrix, so it never starts on it.\nconst LEAN = [0.35, 0, 0.94];\n// The camera over the handle: distance, LEDs per unit at the centre, the\n// angle it looks down at, and the screen row of the centre of mass.\nconst CAMD = 11, FOC = 11 * 25, ELEV = 0.36, CY0 = 31;\n// The light, a unit vector toward it in the space frame.\nconst LIGHT = nrm([-0.45, 0.75, 0.55]);\n// The momentum sphere below: centre and radius in LEDs, and the direction\n// it is seen from, in the handle's own frame.\nconst SX = 31.5, SY = 96.5, SR = 28;\nconst VIEW = nrm([0.3, 0.3, 0.9]);\n// Frames of trail kept: the momentum's on the sphere, the stem tip's above.\nconst TRAIL = 150, TIP = 40;\n\nexport function setup(params) {\n  // Moments of inertia from the boxes, about the centre of mass.\n  let M = 0, cy = 0;\n  for (const b of BOXES) (M += b[3] * b[4] * b[5]), (cy += b[3] * b[4] * b[5] * b[1]);\n  cy /= M;\n  const I = [0, 0, 0];\n  for (const b of BOXES) {\n    const m = b[3] * b[4] * b[5], x = 2 * b[3], y = 2 * b[4], z = 2 * b[5], d = b[1] - cy;\n    I[0] += (m * (y * y + z * z)) / 12 + m * d * d;\n    I[1] += (m * (x * x + z * z)) / 12;\n    I[2] += (m * (x * x + y * y)) / 12 + m * d * d;\n  }\n  for (let k = 0; k \u003c 3; k++) I[k] /= M;\n  // The boxes' faces round the centre of mass, each as four corners, its\n  // outward normal and which box it is on; face 1 of box 1 is the stem's tip.\n  const faces = [];\n  BOXES.forEach((b, bi) => {\n    for (let ax = 0; ax \u003c 3; ax++)\n      for (const sg of [1, -1]) {\n        const u = (ax + 1) % 3, v = (ax + 2) % 3, h = [b[3], b[4], b[5]], c = [b[0], b[1] - cy, b[2]];\n        const pts = [[-1, -1], [1, -1], [1, 1], [-1, 1]].map(([pu, pv]) => {\n          const p = c.slice();\n          (p[ax] += sg * h[ax]), (p[u] += pu * h[u]), (p[v] += pv * h[v]);\n          return p;\n        });\n        if (sg \u003c 0) pts.reverse();\n        const n = [0, 0, 0];\n        n[ax] = sg;\n        faces.push({ pts, n, part: bi === 1 && ax === 1 && sg > 0 ? 2 : bi });\n      }\n  });\n  // The sphere's look, fixed because the handle's frame is: for every LED of\n  // the disc, the point of the sphere in front and the one behind, which of\n  // the four regions the separatrices cut it into each lies in, and which of\n  // three polhodes per region it lies past. The polhodes are curves of\n  // constant energy e = L1^2 / I1 + L2^2 / I2 + L3^2 / I3 on |L| = 1;\n  // rho runs from 0 at a region's pole to 1 at its separatrix.\n  const B = VIEW, U = nrm([-B[1] * B[0], 1 - B[1] * B[1], -B[1] * B[2]]);\n  const R = [U[1] * B[2] - U[2] * B[1], U[2] * B[0] - U[0] * B[2], U[0] * B[1] - U[1] * B[0]];\n  const iI = I.map((v) => 1 / v), eS = iI[1];\n  const code = (p) => {\n    const e = p[0] * p[0] * iI[0] + p[1] * p[1] * iI[1] + p[2] * p[2] * iI[2];\n    const s = e > eS ? (e - eS) / (iI[0] - eS) : (eS - e) / (eS - iI[2]);\n    const reg = e > eS ? (p[0] > 0 ? 0 : 1) : p[2] > 0 ? 2 : 3;\n    return reg * 4 + floor(sqrt(cl(1 - s, 0, 0.9999)) * 4);\n  };\n  const front = new Int16Array(W * HALF).fill(-1), back = new Int16Array(W * HALF).fill(-1);\n  const eF = new Float32Array(W * HALF), eB = new Float32Array(W * HALF);\n  const en = (p) => p[0] * p[0] * iI[0] + p[1] * p[1] * iI[1] + p[2] * p[2] * iI[2];\n  for (let y = 0; y \u003c HALF; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = (x + 0.5 - SX) / SR, py = (SY - (y + HALF + 0.5)) / SR, r2 = px * px + py * py;\n      if (r2 >= 1) continue;\n      const pz = sqrt(1 - r2), i = y * W + x;\n      const at = (z) => [px * R[0] + py * U[0] + z * B[0], px * R[1] + py * U[1] + z * B[1], px * R[2] + py * U[2] + z * B[2]];\n      const pf = at(pz), pb = at(-pz);\n      (front[i] = code(pf)), (back[i] = code(pb)), (eF[i] = en(pf)), (eB[i] = en(pb));\n    }\n  // Classes: 1 and 2 the front fill round the e1 and e3 poles, 4 the\n  // separatrix behind, 5 and 6 a polhode in front round e1 and e3, 7 the\n  // separatrix in front, 8 the rim. A line is where the code changes to a\n  // neighbour; a change of region is the separatrix. The polhodes behind\n  // (class 3) are left out: drawn, they crowded the ones in front.\n  const cls = new Uint8Array(W * HALF);\n  const edge = (A, i, x, y) => {\n    let c = 0;\n    for (const j of [x + 1 \u003c W ? i + 1 : -1, y + 1 \u003c HALF ? i + W : -1, x > 0 ? i - 1 : -1, y > 0 ? i - W : -1]) {\n      if (j \u003c 0 || A[j] \u003c 0 || A[j] === A[i]) continue;\n      if (A[j] >> 2 !== A[i] >> 2) c = 2;\n      else if ((A[j] & 3) > (A[i] & 3)) c = max(c, 1);\n    }\n    return c;\n  };\n  for (let y = 0; y \u003c HALF; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (front[i] \u003c 0) continue;\n      const rim = (x > 0 && front[i - 1] \u003c 0) || (x \u003c W - 1 && front[i + 1] \u003c 0) || (y > 0 && front[i - W] \u003c 0) || (y \u003c HALF - 1 && front[i + W] \u003c 0);\n      const ef = edge(front, i, x, y), eb = edge(back, i, x, y), reg = front[i] >> 2;\n      cls[i] = rim ? 8 : ef === 2 ? 7 : ef === 1 ? (reg \u003c 2 ? 5 : 6) : eb === 2 ? 4 : reg \u003c 2 ? 1 : 2;\n    }\n  params.s = {\n    I, iI, faces, cls, R, U, B, tipY: 1.35 - cy, front, back, eF, eB, cap: new Uint8Array(W * HALF),\n    hue: 0, speed: 2, axis: 0, nudge: 0.06, a0: 0, n0: 0.06, pend: 0, t: 0, flips: 0,\n    L: new Float64Array(3), q: new Float64Array(4), m: new Float64Array(9),\n    trail: new Float32Array(TRAIL * 3), tn: 0, tip: new Float32Array(TIP * 9), pn: 0,\n    zb: new Float32Array(W * HALF), rgb: new Float32Array(N * 3),\n  };\n  launch(params.s, 0, 0.06);\n}\n\n// A throw: |L| set so the handle would spin about the middle axis at OMEGA,\n// the start direction moved from the middle axis toward e1 (Axis -1) or e3\n// (Axis 1), then tipped by the nudge; the orientation is the least turn that\n// sets that direction upright, so the angular momentum points straight up.\nfunction launch(S, axis, nudge) {\n  const t = (axis * PI) / 2, c0 = [max(0, -sin(t)), cos(t), max(0, sin(t))];\n  let d = LEAN.map((v, k) => v - (LEAN[0] * c0[0] + LEAN[1] * c0[1] + LEAN[2] * c0[2]) * c0[k]);\n  if (hypot(d[0], d[1], d[2]) \u003c 1e-6) d = [1, 0, 0];\n  d = nrm(d);\n  const a = nudge * NUDGE, l = nrm(c0.map((v, k) => v * cos(a) + d[k] * sin(a))), Lm = OMEGA * S.I[1];\n  for (let k = 0; k \u003c 3; k++) S.L[k] = l[k] * Lm;\n  // The least turn taking l to (0, 1, 0): about l x up, by the angle between.\n  const ax = [-l[2], 0, l[0]], s = hypot(ax[0], ax[2]), ang = Math.atan2(s, l[1]);\n  if (s \u003c 1e-9) (S.q[0] = 1), (S.q[1] = S.q[2] = S.q[3] = 0);\n  else (S.q[0] = cos(ang / 2)), (S.q[1] = (sin(ang / 2) * ax[0]) / s), (S.q[2] = 0), (S.q[3] = (sin(ang / 2) * ax[2]) / s);\n  (S.a0 = axis), (S.n0 = nudge), (S.tn = 0), (S.pn = 0), (S.pend = 0), (S.flips = 0);\n  // The polhode this throw rides: its energy is fixed, so it is fixed too.\n  // The cap it bounds round its pole is tinted (1), the curve drawn in front\n  // (2) and behind (3). The region code names the pole: 0 and 1 are +e1 and\n  // -e1, 2 and 3 are +e3 and -e3.\n  const iI = S.iI, e = l[0] * l[0] * iI[0] + l[1] * l[1] * iI[1] + l[2] * l[2] * iI[2], eS = iI[1];\n  const reg = e > eS ? (l[0] > 0 ? 0 : 1) : l[2] > 0 ? 2 : 3, sg = e > eS ? 1 : -1;\n  const { front, back, eF, eB, cap } = S;\n  const inF = (i) => front[i] >= 0 && front[i] >> 2 === reg && sg * (eF[i] - e) > 0;\n  const inB = (i) => back[i] >= 0 && back[i] >> 2 === reg && sg * (eB[i] - e) > 0;\n  cap.fill(0);\n  for (let y = 0; y \u003c HALF; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (front[i] \u003c 0) continue;\n      const nb = [x + 1 \u003c W ? i + 1 : -1, y + 1 \u003c HALF ? i + W : -1, x > 0 ? i - 1 : -1, y > 0 ? i - W : -1];\n      const f = inF(i), b = inB(i);\n      if (f && nb.some((j) => j >= 0 && front[j] >= 0 && !inF(j))) cap[i] = 2;\n      else if (f) cap[i] = 1;\n      else if (b && nb.some((j) => j >= 0 && back[j] >= 0 && !inB(j))) cap[i] = 3;\n    }\n}\n\n// Euler's equations dL/dt = L x w with w = L / I in the handle's frame, and\n// the orientation dq/dt = q (0, w) / 2, stepped together by RK4.\nfunction deriv(S, s, o) {\n  const iI = S.iI, wx = s[0] * iI[0], wy = s[1] * iI[1], wz = s[2] * iI[2], w = s[3], x = s[4], y = s[5], z = s[6];\n  o[0] = s[1] * wz - s[2] * wy;\n  o[1] = s[2] * wx - s[0] * wz;\n  o[2] = s[0] * wy - s[1] * wx;\n  o[3] = -0.5 * (x * wx + y * wy + z * wz);\n  o[4] = 0.5 * (w * wx + y * wz - z * wy);\n  o[5] = 0.5 * (w * wy + z * wx - x * wz);\n  o[6] = 0.5 * (w * wz + x * wy - y * wx);\n}\nconst ST = new Float64Array(7), K1 = new Float64Array(7), K2 = new Float64Array(7), K3 = new Float64Array(7), K4 = new Float64Array(7), TMP = new Float64Array(7);\nfunction step(S, h) {\n  for (let k = 0; k \u003c 3; k++) ST[k] = S.L[k];\n  for (let k = 0; k \u003c 4; k++) ST[3 + k] = S.q[k];\n  deriv(S, ST, K1);\n  for (let k = 0; k \u003c 7; k++) TMP[k] = ST[k] + 0.5 * h * K1[k];\n  deriv(S, TMP, K2);\n  for (let k = 0; k \u003c 7; k++) TMP[k] = ST[k] + 0.5 * h * K2[k];\n  deriv(S, TMP, K3);\n  for (let k = 0; k \u003c 7; k++) TMP[k] = ST[k] + h * K3[k];\n  deriv(S, TMP, K4);\n  for (let k = 0; k \u003c 7; k++) ST[k] += (h / 6) * (K1[k] + 2 * K2[k] + 2 * K3[k] + K4[k]);\n  for (let k = 0; k \u003c 3; k++) S.L[k] = ST[k];\n  // Only the quaternion is renormalised; L is left as RK4 leaves it.\n  const l = hypot(ST[3], ST[4], ST[5], ST[6]);\n  for (let k = 0; k \u003c 4; k++) S.q[k] = ST[3 + k] / l;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.axis = cl(k[2], -1, 1);\n  S.nudge = cl(k[3], 0, 1);\n  // A turned Axis or Nudge throws again once the knob has rested 0.3 s; the\n  // first frame throws at once with the knobs it is handed.\n  if (S.t === 0 && (S.axis !== S.a0 || S.nudge !== S.n0)) launch(S, S.axis, S.nudge);\n  else if (abs(S.axis - S.a0) > 1e-4 || abs(S.nudge - S.n0) > 1e-4) {\n    if (S.pend \u003c= 0) S.pend = 0.3;\n    if (abs(S.axis - (S.ax1 ?? S.axis)) > 1e-4 || abs(S.nudge - (S.nu1 ?? S.nudge)) > 1e-4) S.pend = 0.3;\n    S.pend -= d;\n    if (S.pend \u003c= 0) launch(S, S.axis, S.nudge);\n  }\n  (S.ax1 = S.axis), (S.nu1 = S.nudge);\n  if (input.btnPressed && input.btnPressed.some(Boolean)) launch(S, S.axis, S.nudge);\n  // Speed 2 is real time; steps of at most 1/240 s of the handle's time.\n  const span = (d * S.speed) / 2, n = max(1, ceil(span * 240));\n  const was = S.L[1];\n  for (let i = 0; i \u003c n; i++) step(S, span / n);\n  if (was > 0 !== S.L[1] > 0) S.flips++;\n  S.t += d;\n  const q = S.q, m = S.m, w = q[0], x = q[1], y = q[2], z = q[3];\n  m[0] = 1 - 2 * (y * y + z * z), m[1] = 2 * (x * y - w * z), m[2] = 2 * (x * z + w * y);\n  m[3] = 2 * (x * y + w * z), m[4] = 1 - 2 * (x * x + z * z), m[5] = 2 * (y * z - w * x);\n  m[6] = 2 * (x * z - w * y), m[7] = 2 * (y * z + w * x), m[8] = 1 - 2 * (x * x + y * y);\n  // The trails: the momentum's direction in the handle's frame, and where\n  // the stem's tip is in space.\n  const Lm = hypot(S.L[0], S.L[1], S.L[2]) || 1, o = (S.tn % TRAIL) * 3;\n  for (let j = 0; j \u003c 3; j++) S.trail[o + j] = S.L[j] / Lm;\n  S.tn++;\n  const ty = S.tipY, p = (S.pn % TIP) * 9;\n  for (let j = 0; j \u003c 3; j++) {\n    S.tip[p + j] = m[j * 3 + 1] * ty;\n    S.tip[p + 3 + j] = m[j * 3] * 1.1 - m[j * 3 + 1] * (1.35 - ty);\n    S.tip[p + 6 + j] = -m[j * 3] * 1.1 - m[j * 3 + 1] * (1.35 - ty);\n  }\n  S.pn++;\n}\n\n// World (centre of mass at the origin, y up, z toward the camera) to the\n// screen: [x, y, 1 / depth].\nconst CE = cos(ELEV), SE = sin(ELEV);\nfunction proj(p, out, o) {\n  const vx = p[0], vy = p[1] - CAMD * SE, vz = p[2] - CAMD * CE;\n  const zc = -(vy * SE + vz * CE), ux = vx, uy = vy * CE - vz * SE;\n  out[o] = 32 + (FOC * ux) / zc;\n  out[o + 1] = CY0 - (FOC * uy) / zc;\n  out[o + 2] = 1 / zc;\n}\n\nfunction tri(S, ax, ay, az, bx, by, bz, cx, cy, cz, r, g, b) {\n  const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(area) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(HALF - 2, ceil(max(ay, by, cy)));\n  const zb = S.zb, rgb = S.rgb;\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const w0 = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / area, w1 = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / area, w2 = 1 - w0 - w1;\n      if (w0 \u003c 0 || w1 \u003c 0 || w2 \u003c 0) continue;\n      const iz = w0 * az + w1 * bz + w2 * cz, i = y * W + x;\n      if (iz \u003c= zb[i]) continue;\n      zb[i] = iz;\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n  }\n}\n\n// A line of LEDs from a to b in colour c times v, kept off LEDs the handle\n// covers when depth is given.\nfunction line(S, ax, ay, bx, by, c, v, y0, y1) {\n  const steps = ceil(max(abs(bx - ax), abs(by - ay))) + 1, rgb = S.rgb;\n  for (let s = 0; s \u003c= steps; s++) {\n    const t = s / steps, x = floor(mix(ax, bx, t)), y = floor(mix(ay, by, t));\n    if (x \u003c 0 || x >= W || y \u003c y0 || y > y1) continue;\n    const i = y * W + x;\n    if (y \u003c HALF && S.zb[i] > 0) continue;\n    (rgb[i * 3] = max(rgb[i * 3], c[0] * v)), (rgb[i * 3 + 1] = max(rgb[i * 3 + 1], c[1] * v)), (rgb[i * 3 + 2] = max(rgb[i * 3 + 2], c[2] * v));\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { m, zb, rgb, faces, cls } = S;\n  // The three colours: A the crossbar and the e1 polhodes, B the stem, its\n  // tip and the momentum, C the e3 polhodes. Warm ones are lifted.\n  const hA = 0.58 + S.hue, hB = 0.09 + S.hue, hC = 0.79 + S.hue;\n  const cA = hsv(hA, 0.8, 1), cB = hsv(hB, 0.82, 1), cC = hsv(hC, 0.62, 1), wB = warm(hB), wA = warm(hA), wC = warm(hC);\n  const tipC = hsv(hB, 0.35, 1);\n  rgb.fill(0);\n  zb.fill(0);\n  // The handle: each face that looks toward the camera, flat shaded.\n  const wp = [0, 0, 0], sp = new Float64Array(12);\n  for (const f of faces) {\n    const n = f.n, nx = m[0] * n[0] + m[1] * n[1] + m[2] * n[2], ny = m[3] * n[0] + m[4] * n[1] + m[5] * n[2], nz = m[6] * n[0] + m[7] * n[1] + m[8] * n[2];\n    const p0 = f.pts[0], cx = m[0] * p0[0] + m[1] * p0[1] + m[2] * p0[2], cy = m[3] * p0[0] + m[4] * p0[1] + m[5] * p0[2], cz = m[6] * p0[0] + m[7] * p0[1] + m[8] * p0[2];\n    if (nx * cx + ny * (cy - CAMD * SE) + nz * (cz - CAMD * CE) >= 0) continue;\n    for (let j = 0; j \u003c 4; j++) {\n      const p = f.pts[j];\n      wp[0] = m[0] * p[0] + m[1] * p[1] + m[2] * p[2];\n      wp[1] = m[3] * p[0] + m[4] * p[1] + m[5] * p[2];\n      wp[2] = m[6] * p[0] + m[7] * p[1] + m[8] * p[2];\n      proj(wp, sp, j * 3);\n    }\n    const lit = max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]), wm = f.part === 0 ? wA : wB;\n    const sh = floor((0.3 + 0.45 * wm + (0.7 - 0.45 * wm) * lit) * 10) / 10, col = f.part === 0 ? cA : f.part === 1 ? cB : tipC;\n    tri(S, sp[0], sp[1], sp[2], sp[3], sp[4], sp[5], sp[6], sp[7], sp[8], col[0] * sh, col[1] * sh, col[2] * sh);\n    tri(S, sp[0], sp[1], sp[2], sp[6], sp[7], sp[8], sp[9], sp[10], sp[11], col[0] * sh, col[1] * sh, col[2] * sh);\n  }\n  // The angular momentum, fixed and upright: a dim line through the centre\n  // of mass with an arrowhead at the top, where the handle does not cover it.\n  const grey = [0.5, 0.5, 0.56];\n  line(S, 32, 61, 32, 1, grey, 0.42, 0, HALF - 2);\n  line(S, 32, 1, 28, 5, grey, 0.42, 0, HALF - 2), line(S, 32, 1, 36, 5, grey, 0.42, 0, HALF - 2);\n  // The stem tip's path over the last 1.3 s and the crossbar ends' over the\n  // last 0.3 s, older steps dimmer.\n  const a = new Float64Array(3), b2 = new Float64Array(3);\n  for (let j = 1; j \u003c min(S.pn, TIP); j++)\n    for (let e = 0; e \u003c 3; e++) {\n      if (e && j > 10) break;\n      const i0 = ((S.pn - j) % TIP) * 9 + e * 3, i1 = ((S.pn - j - 1) % TIP) * 9 + e * 3;\n      const v = e ? 0.15 + 0.45 * floor((1 - j / 10) * 4) / 4 : 0.2 + 0.6 * floor((1 - j / TIP) * 5) / 5;\n      proj(S.tip.subarray(i0, i0 + 3), a, 0);\n      proj(S.tip.subarray(i1, i1 + 3), b2, 0);\n      line(S, a[0], a[1], b2[0], b2[1], e ? cA : cB, v, 0, HALF - 2);\n    }\n  // The momentum sphere, its classes coloured for this hue.\n  const lift = (c, v, w) => [c[0] * v * (1 + 0.5 * w), c[1] * v * (1 + 0.5 * w), c[2] * v * (1 + 0.5 * w)];\n  const pal = [\n    [0, 0, 0], lift(cA, 0.17, wA), lift(cC, 0.17, wC), [0.27, 0.27, 0.32], [0.48, 0.48, 0.54],\n    lift(cA, 0.62, wA), lift(cC, 0.62, wC), [0.7, 0.7, 0.76], [0.34, 0.34, 0.4],\n  ];\n  const capA = lift(cA, 0.3, wA), capC = lift(cC, 0.3, wC), orb = lift(cB, 0.5, 0), orbB = lift(cB, 0.27, 0), cap = S.cap;\n  for (let i = 0; i \u003c W * HALF; i++) {\n    const k = cls[i], o = (i + W * HALF) * 3, f = cap[i];\n    let c = pal[k];\n    if (f === 2 && k !== 8) c = orb;\n    else if (f === 1 && k \u003c 3) c = k === 1 ? capA : capC;\n    else if (f === 3 && k \u003c 3) c = orbB;\n    (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n  }\n  // The two ends of the middle axis, where the separatrices cross, ringed in\n  // the stem's colour.\n  const { R, U, B } = S, scr = (p) => [SX + SR * (p[0] * R[0] + p[1] * R[1] + p[2] * R[2]), SY - SR * (p[0] * U[0] + p[1] * U[1] + p[2] * U[2]), p[0] * B[0] + p[1] * B[1] + p[2] * B[2]];\n  for (const sg of [1, -1]) {\n    const [x, y, z] = scr([0, sg, 0]), v = z > 0 ? 0.9 : 0.5;\n    for (const [dx, dy] of [[-2, 0], [2, 0], [0, -2], [0, 2], [-1, -1], [1, -1], [-1, 1], [1, 1]]) line(S, x + dx, y + dy, x + dx, y + dy, cB, v, HALF, H - 1);\n  }\n  // The momentum's trail in the handle's frame over the last 5 s: in front\n  // of the sphere bright, behind it dimmer, older steps dimmer still.\n  const cnt = min(S.tn, TRAIL), tr = S.trail;\n  for (let j = 1; j \u003c cnt; j++) {\n    const i0 = ((S.tn - j) % TRAIL) * 3, i1 = ((S.tn - j - 1) % TRAIL) * 3;\n    const p = scr([tr[i0], tr[i0 + 1], tr[i0 + 2]]), q = scr([tr[i1], tr[i1 + 1], tr[i1 + 2]]);\n    const v = (0.3 + 0.7 * floor((1 - j / TRAIL) * 5) / 5) * (p[2] + q[2] > 0 ? 1 : 0.45) * (1 + 0.3 * wB);\n    line(S, p[0], p[1], q[0], q[1], cB, v, HALF, H - 1);\n    line(S, p[0] + 1, p[1], q[0] + 1, q[1], cB, v * 0.8, HALF, H - 1);\n  }\n  // The momentum now: a bright dot, white at the centre.\n  const nowI = ((S.tn - 1 + TRAIL) % TRAIL) * 3, now = scr([tr[nowI], tr[nowI + 1], tr[nowI + 2]]);\n  for (let dy = -2; dy \u003c= 2; dy++)\n    for (let dx = -2; dx \u003c= 2; dx++) {\n      const x = floor(now[0]) + dx, y = floor(now[1]) + dy, r = abs(dx) + abs(dy);\n      if (r > 2 || x \u003c 0 || x >= W || y \u003c HALF || y >= H) continue;\n      const o = (y * W + x) * 3, c = r === 0 ? [1, 1, 1] : r === 1 ? tipC : cB;\n      (rgb[o] = c[0]), (rgb[o + 1] = c[1]), (rgb[o + 2] = c[2]);\n    }\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","werewolf":"// ===== Patternflow pattern =====\n// Title:   Werewolf\n// Family:  halloween\n// Idea:    Clouds slide off a huge full moon and the black figure of a man standing on a rock in front of it bends forward with his back arching, his arms stretching down into forelegs and his face into a muzzle, until a wolf with pricked ears stands there and howls rings into the night; then the clouds come back over the moon and the wolf shrinks into the man again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 49\n// Round:   49\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Moon=-1..1\n//\n// Knob 1: Hue. The night sky and the clouds, through the cold colours only: at 0 purple, at 0.25 indigo, at 0.5 deep sea blue, at 0.75 teal and at 1 poison green. The moon stays pale gold.\n// Knob 2: Speed. At 2 one night takes 15 seconds: the bank of clouds is past the man by 2 s, the change runs from 0.4 s to 4.4 s, the wolf raises its head at 5 s and howls from 5.5 s to 8.6 s with a ring every 0.3 s, the clouds are back over the moon by 12 s and the wolf is a man again by 13.5 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Clouds. At 0 four thin clouds veil the moon, letting about half its light through, and two wisps cross the high sky; at 1 the four are heavy, three more trail behind them across the moon until 4 s into the night, and six thick wisps fill the high sky.\n// Knob 4: Moon. Its radius: 22 LEDs at -1, 27 at the opening 0.06 and 32 at 1, where it fills the panel's width.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, atan2, acos, round, PI } = Math;\nconst hypot = (x, y) => sqrt(x * x + y * y);\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (t) => ((t = cl(t, 0, 1)), t * t * (3 - 2 * t));\nconst lerp = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// Channels in steps of 4 of 255: flat areas stay flat for the panel.\nconst q4 = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\n// Signed distances in LEDs, negative inside.\nconst circle = (px, py, cx, cy, r) => hypot(px - cx, py - cy) - r;\nfunction capsule(px, py, ax, ay, bx, by, ra, rb) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey || 1), 0, 1);\n  return hypot(qx - u * ex, qy - u * ey) - (ra + (rb - ra) * u);\n}\nconst smin = (a, b, k) => {\n  const h = cl(0.5 + (0.5 * (b - a)) / k, 0, 1);\n  return b + (a - b) * h - k * h * (1 - h);\n};\n\n// The moon, the ground line the figure stands on, and one night in story seconds.\nconst MX = 32, MY = 74, G = 104, NIGHT = 15;\nconst MOON = [1, 0.9, 0.6];\n// The rock's top edge per column, flat under the figure and falling away in\n// steps at both ends, and the far hills, hidden behind the rock in the middle.\nconst CREST = new Float32Array(W), RIDGE = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) {\n  const l = max(0, 14 - x), r = max(0, x - 50);\n  // Boulders at both ends of the top, clear of where the feet go.\n  const knob = -2.2 * max(0, 1 - abs(x - 14.5) / 3) - 1.6 * max(0, 1 - abs(x - 50) / 2.5);\n  CREST[x] = G + knob + 0.95 * l + 1.15 * r + min(1, (l + r) / 3) * (2.2 * abs(sin(x * 0.75)) + 0.8 * sin(x * 2.1));\n  RIDGE[x] = 96 + 9 * cos((PI * (x - 32)) / 64) ** 2 + 1.3 * sin(x * 0.37) + 0.6 * sin(x * 1.3);\n}\n// Seas on the moon as [dx, dy, rx, ry] in units of its radius.\nconst SEAS = [[-0.3, -0.3, 0.22, 0.18], [0.27, -0.4, 0.18, 0.15], [0.36, 0.1, 0.22, 0.22], [-0.42, 0.22, 0.18, 0.22], [0.04, 0.45, 0.22, 0.14]];\n// Stars: LED and twinkle phase, in the high sky.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 24; i++) {\n  const x = floor(hash(3 * i + 1) * W), y = floor(2 + hash(3 * i + 2) * 40);\n  STARS.push([y * W + x, hash(3 * i + 3) * TAU]);\n}\n// The bank of clouds that covers and uncovers the moon, [dx, dy, half length,\n// thickness] about the moon's centre, most important first; and the wisps of\n// the high sky, [row, start, half length, thickness]. Each is a row of puffs\n// with a flat foot. The first four always come; the other three trail to the\n// right, so on a cloudy night they are still crossing the moon while the\n// change begins.\nconst BANK = [[-4, -9, 22, 9], [9, 10, 22, 8], [-12, 27, 18, 7], [10, -28, 17, 6], [46, -16, 18, 8], [58, 6, 20, 9], [70, 24, 20, 8]];\nconst WISPS = [[14, 0.1, 16, 3.5], [31, 0.55, 19, 4], [6, 0.8, 12, 3], [41, 0.3, 14, 3.5], [23, 0.95, 17, 3], [49, 0.7, 12, 3]];\n[...BANK, ...WISPS].forEach((C, j) => {\n  const L = C[2], T = C[3], n = 1 + Math.ceil((2 * L) / (0.8 * T));\n  C.puffs = [];\n  for (let i = 0; i \u003c n; i++) {\n    const e = (2 * i) / (n - 1) - 1, r = T * (0.7 + 0.55 * hash(j * 31 + i)) * (1 - 0.45 * e * e);\n    C.puffs.push([L * e, 0.35 * T - 0.55 * r, r]);\n  }\n});\n\n// A cloud's distance field: its puffs blended, its foot cut flat.\nfunction puff(C, px, py, th) {\n  let d = 99;\n  for (const [ux, uy, ur] of C.puffs) d = smin(d, hypot(px - ux, py - uy * th) - ur * th, 0.5 * C[3]);\n  return max(d, py - C[3] * 0.45 * th);\n}\n\n// A cloud's shape at thickness th as a mask over its box, its centre on an\n// LED: 1 edge, 2 body, plus 4 along the lit top.\nfunction shape(C, th) {\n  const L = C[2], T = C[3], ox = -ceil(L + T) - 1, oy = -ceil(2 * T * th) - 1, w = 1 - 2 * ox, h = 2 - oy + ceil(T);\n  const m = new Uint8Array(w * h);\n  for (let j = 0; j \u003c h; j++)\n    for (let i = 0; i \u003c w; i++) {\n      const px = ox + i + 0.5, py = oy + j + 0.5, d = puff(C, px, py, th);\n      if (d \u003c= 0) m[j * w + i] = (d > -1.2 ? 1 : 2) | (puff(C, px, py - 1.3, th) > 0 ? 4 : 0);\n    }\n  C.mask = { th, ox, oy, w, h, m };\n}\n\n// Two poses for the one skeleton, facing right: a man standing and a wolf on\n// four legs. Points are LEDs on the panel, angles in radians (0 right, pi/2\n// down), radii in LEDs. The legs are placed by where the feet go, so the\n// change keeps them on the rock. hip: where it is; spine: the back's angle\n// and length; rad: the body's radius at hip, middle and shoulder; head: angle\n// and distance from the shoulder; arm: where the arm leaves the shoulder;\n// up, fore: arm bones; wrists and hand: where the hands go and the hand\n// itself; toes and foot: where the toes go and the foot back to the ankle.\nconst MAN = {\n  hip: [31.5, 80.5], spine: -1.5, len: 18, rad: [3.4, 3.3, 3.9], chest: 0,\n  head: [-1.38, 7.8], face: 0.05, neck: [1.6, 1.6],\n  arm: [0.3, 1.5], up: 9.5, fore: 8.5, wrists: [[2.6, 16.6], [-2.4, 16.2]], hand: [[0.7, 3.2], [-0.3, 3.2]], ar: [1.6, 1.25, 1],\n  thigh: 12, shin: 11.5, toes: [[36.5, G], [33, G]], foot: [[4.3, 1.4], [4.3, 1.4]], lr: [2.4, 1.7, 1.15],\n};\nconst WOLF = {\n  hip: [21, 82.5], spine: -0.07, len: 21, rad: [4.2, 4.4, 5.4], chest: 4.8,\n  head: [-0.8, 10.5], face: 0.15, neck: [3.9, 2.7],\n  arm: [1.5, 2.5], up: 9, fore: 10, wrists: [[46.5, 101], [40.5, 101]], hand: [[1.6, 2.8], [1.6, 2.8]], ar: [2.2, 1.35, 1.05],\n  thigh: 9.5, shin: 9, toes: [[25.5, G], [18.5, G]], foot: [[2.5, 6.6], [2.5, 6.6]], lr: [3.2, 1.6, 1.05],\n};\n\n// Two-bone reach from (ax, ay) toward (tx, ty); bend 1 puts the middle joint\n// on the clockwise side. Writes joint and end into out.\nfunction reach(ax, ay, tx, ty, l1, l2, bend, out) {\n  const dx = tx - ax, dy = ty - ay, d = cl(hypot(dx, dy), abs(l1 - l2) + 0.01, l1 + l2 - 0.01), a = atan2(dy, dx);\n  const th = acos(cl((l1 * l1 + d * d - l2 * l2) / (2 * l1 * d), -1, 1)), a1 = a + bend * th;\n  out[0] = ax + l1 * cos(a1);\n  out[1] = ay + l1 * sin(a1);\n  const b = atan2(ty - out[1], tx - out[0]);\n  out[2] = out[0] + l2 * cos(b);\n  out[3] = out[1] + l2 * sin(b);\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, clouds: 0, moon: 0.06, key: \"\", m: 0, lift: 0, bankX: 0, howling: false, night: 0,\n    rings: [], ringClock: 0, P: null,\n    base: new Float32Array(N * 3), mc: new Float32Array(N), nm: new Float32Array(N), buf: new Float32Array(N * 3), sil: new Float32Array(N), ra: new Float32Array(N), info: { u: 0, v: 0 },\n  };\n}\n\n// Where the story is at story time t of the night: the change m (0 man, 1\n// wolf), the howl's lift and the bank's offset from the moon.\nfunction story(S) {\n  const t = S.t % NIGHT;\n  S.m = t \u003c 10.5 ? ease((t - 0.4) / 4) : 1 - ease((t - 10.5) / 3);\n  S.lift = ease((t - 5) / 0.6) - ease((t - 8.6) / 0.6);\n  S.bankX = t \u003c 9 ? -130 * ease(t / 5) : 130 * (1 - ease((t - 9) / 3));\n  S.howling = t > 5.5 && t \u003c 8.6;\n  S.night = t;\n}\n\n// The skeleton at the change m, each part on its own schedule: the back bends\n// first and arches most half way, the arms and legs follow, then the face,\n// and last the ears, tail and fur.\nfunction pose(S) {\n  const m = S.m, l = S.lift, sp = ease(m / 0.6), fl = ease((m - 0.12) / 0.6), hl = ease((m - 0.2) / 0.6);\n  const hd = ease((m - 0.3) / 0.5), late = ease((m - 0.5) / 0.45), bulk = ease((m - 0.1) / 0.7);\n  // A shudder while it changes.\n  const sh = sin(PI * m) * sin(S.t * 23) * 0.05, A = MAN, B = WOLF;\n  const P = (S.P = S.P || { leg: [[0, 0, 0, 0], [0, 0, 0, 0]], arm: [[0, 0, 0, 0], [0, 0, 0, 0]], ft: [[0, 0], [0, 0]], hn: [[0, 0], [0, 0]], tail: new Float32Array(10) });\n  P.hd = hd;\n  P.late = late;\n  P.fur = ease((m - 0.35) / 0.6);\n  P.bulk = bulk;\n  const hx = lerp(A.hip[0], B.hip[0], sp), hy = lerp(A.hip[1], B.hip[1], hl) - 1.2 * l;\n  const sa = lerp(A.spine, B.spine, sp) + sh - 0.12 * l, ln = lerp(A.len, B.len, sp);\n  const arch = 4.5 * sin(PI * cl(m / 0.85, 0, 1)) + 1.2 * bulk;\n  P.hip = [hx, hy];\n  P.sh = [hx + ln * cos(sa), hy + ln * sin(sa)];\n  // The middle of the back bulges away from the belly: behind him while he\n  // stands, up once the back is level.\n  P.mid = [hx + 0.5 * ln * cos(sa) + arch * sin(sa), hy + 0.5 * ln * sin(sa) - arch * cos(sa)];\n  P.rad = A.rad.map((r, i) => lerp(r, B.rad[i], bulk));\n  P.chest = lerp(A.chest, B.chest, bulk);\n  // The head: up and back in the howl, thrown back once in the middle of the change.\n  const throwBack = 0.5 * sin(PI * cl((m - 0.25) / 0.5, 0, 1));\n  const ha = lerp(A.head[0], B.head[0], hd) - 0.5 * l - throwBack, hl2 = lerp(A.head[1], B.head[1], hd);\n  P.head = [P.sh[0] + hl2 * cos(ha), P.sh[1] + hl2 * sin(ha)];\n  P.face = lerp(A.face, B.face, hd) - 1.25 * l - 0.9 * throwBack;\n  P.neck = A.neck.map((r, i) => lerp(r, B.neck[i], bulk));\n  P.jaw = 0.35 * ease((S.night - 5.4) / 0.3) * (1 - ease((S.night - 8.5) / 0.3)) + 0.25 * throwBack;\n  // Arms to forelegs: the wrists go from beside the thighs to the rock ahead.\n  const ax = P.sh[0] + lerp(A.arm[0], B.arm[0], fl), ay = P.sh[1] + lerp(A.arm[1], B.arm[1], fl) - 1.5 * l;\n  P.ar = A.ar.map((r, i) => lerp(r, B.ar[i], fl));\n  for (let k = 0; k \u003c 2; k++) {\n    const wa = A.wrists[k], wb = B.wrists[k];\n    const tx = lerp(P.sh[0] + wa[0], wb[0], fl), ty = lerp(P.sh[1] + wa[1], wb[1], fl) + sh * 20 * (k ? -1 : 1);\n    reach(ax, ay, tx, ty, lerp(A.up, B.up, fl), lerp(A.fore, B.fore, fl), 1, P.arm[k]);\n    const hv = A.hand[k], wv = B.hand[k];\n    P.hn[k] = [P.arm[k][2] + lerp(hv[0], wv[0], fl), P.arm[k][3] + lerp(hv[1], wv[1], fl)];\n  }\n  P.root = [ax, ay];\n  // Legs: the man's foot becomes the wolf's long hind foot, the heel rising to a hock.\n  P.lr = A.lr.map((r, i) => lerp(r, B.lr[i], hl));\n  for (let k = 0; k \u003c 2; k++) {\n    const ta = A.toes[k], tb = B.toes[k], fa = A.foot[k], fb = B.foot[k];\n    const tx = lerp(ta[0], tb[0], hl), fx = lerp(fa[0], fb[0], hl), fy = lerp(fa[1], fb[1], hl);\n    P.ft[k] = [tx, G];\n    reach(hx, hy + 1, tx - fx, G - fy, lerp(A.thigh, B.thigh, hl), lerp(A.shin, B.shin, hl), -1, P.leg[k]);\n  }\n  // The box the figure lies in: every joint, the muzzle's tip and the ears.\n  const fc = cos(P.face), fs = sin(P.face), pts = [P.hip, P.mid, P.sh, P.head, P.root, ...P.hn, ...P.ft, [P.head[0] + 10 * fc, P.head[1] + 10 * fs], [P.head[0] + 7 * fs, P.head[1] - 7 * fc]];\n  for (const a of [...P.arm, ...P.leg]) pts.push([a[0], a[1]], [a[2], a[3]]);\n  let x0 = 99, x1 = -99, y0 = 999, y1 = -99;\n  for (const [x, y] of pts) (x0 = min(x0, x)), (x1 = max(x1, x)), (y0 = min(y0, y)), (y1 = max(y1, y));\n  P.box = [x0 - 6, x1 + 6, y0 - 6, y1 + 3];\n  // The tail grows from the rump and hangs, swaying.\n  const T = P.tail;\n  let x = hx - 2.5 * sp, y = hy - 1, a = 2.45;\n  T[0] = x;\n  T[1] = y;\n  for (let i = 1; i \u003c 5; i++) {\n    a -= 0.12 + 0.05 * sin(S.t * 2.1 + i);\n    x += 4.2 * late * cos(a);\n    y += 4.2 * late * sin(a);\n    T[2 * i] = x;\n    T[2 * i + 1] = y;\n    P.box[0] = min(P.box[0], x - 4);\n  }\n}\n\n// The body as a list of tapered capsules, 11 numbers each: two ends, two\n// radii, how softly it joins what came before (0 a hard union), and a box\n// beyond which it cannot change the field where it matters, within 3 LEDs of\n// the edge.\nconst PART = 11, MAXP = 24;\nfunction parts(S) {\n  const P = S.P, L = (S.parts = S.parts || new Float32Array(PART * MAXP));\n  let n = 0;\n  const add = (ax, ay, bx, by, ra, rb, k) => {\n    const o = PART * n++, r = max(ra, rb) + 3 + k;\n    L.set([ax, ay, bx, by, ra, rb, k, min(ax, bx) - r, max(ax, bx) + r, min(ay, by) - r, max(ay, by) + r], o);\n  };\n  const [rh, rm, rs] = P.rad;\n  add(P.hip[0], P.hip[1], P.mid[0], P.mid[1], rh, rm, 0);\n  add(P.mid[0], P.mid[1], P.sh[0], P.sh[1], rm, rs, 2);\n  if (P.chest > 0.1) add(P.sh[0] + 1.5, P.sh[1] + 2.6, P.sh[0] + 1.5, P.sh[1] + 2.6, P.chest, P.chest, 2);\n  add(P.sh[0], P.sh[1], P.head[0], P.head[1], P.neck[0], P.neck[1], 1.5);\n  for (let k = 0; k \u003c 2; k++) {\n    const a = P.arm[k], r = P.ar;\n    add(P.root[0] - k * 1.5, P.root[1], a[0], a[1], r[0] + P.bulk * 0.8, r[1], 1.2);\n    add(a[0], a[1], a[2], a[3], r[1], r[2], 0);\n    add(a[2], a[3], P.hn[k][0], P.hn[k][1], r[2], 0.8 + 0.2 * P.late, 0);\n  }\n  for (let k = 0; k \u003c 2; k++) {\n    const g = P.leg[k], r = P.lr;\n    add(P.hip[0] - k, P.hip[1] + 1, g[0], g[1], r[0] + P.bulk, r[1], 1.5);\n    add(g[0], g[1], g[2], g[3], r[1], r[2], 0);\n    add(g[2], g[3], P.ft[k][0], P.ft[k][1] - 0.6, r[2], 0.9, 0);\n  }\n  if (P.late > 0.02) {\n    const T = P.tail, f = (i) => 1.2 + 1.3 * P.late * sin((PI * (i + 0.6)) / 4.6);\n    for (let i = 0; i \u003c 4; i++) add(T[2 * i], T[2 * i + 1], T[2 * i + 2], T[2 * i + 3], f(i), f(i + 1), 1);\n  }\n  S.np = n;\n  P.fc = cos(P.face);\n  P.fs = sin(P.face);\n  P.jc = cos(P.jaw);\n  P.js = sin(P.jaw);\n}\n\n// The figure's distance field at (px, py).\nfunction figure(S, px, py) {\n  const P = S.P, info = S.info, L = S.parts;\n  let d = 99;\n  for (let i = 0, o = 0; i \u003c S.np; i++, o += PART) {\n    if (px \u003c L[o + 7] || px > L[o + 8] || py \u003c L[o + 9] || py > L[o + 10]) continue;\n    const c = capsule(px, py, L[o], L[o + 1], L[o + 2], L[o + 3], L[o + 4], L[o + 5]), k = L[o + 6];\n    d = k > 0 && d \u003c 50 ? smin(d, c, k) : min(d, c);\n  }\n  // The head in its own frame (u along the face, v down): the man's head and\n  // the wolf's head blended as distance fields, so the muzzle grows out of the\n  // face and the ears rise out of the skull.\n  const qx = px - P.head[0], qy = py - P.head[1], u = qx * P.fc + qy * P.fs, v = -qx * P.fs + qy * P.fc;\n  info.u = u;\n  info.v = v;\n  if (u > -9 && u \u003c 14 && v > -12 && v \u003c 8) {\n    const man = min(circle(u, v, 0, -0.3, 3.5), capsule(u, v, 2.4, 0.6, 3.9, 1.2, 1, 0.7), capsule(u, v, 0.5, 2.2, 2.6, 2.8, 1.4, 0.9));\n    let wolf = smin(circle(u, v, -0.5, -0.4, 3.4), capsule(u, v, 1.5, -0.6, 9, 0.5, 2.3, 1.15), 1.2);\n    const ju = 1.5 + (u - 1.5) * P.jc + (v - 1.6) * P.js, jv = 1.6 - (u - 1.5) * P.js + (v - 1.6) * P.jc;\n    wolf = smin(wolf, capsule(ju, jv, 1.5, 1.6, 8, 1.8, 1.5, 0.75), 0.8);\n    // Ears grow out of the skull late in the change, laid back in the howl.\n    const e = P.late, back = (0.9 + 0.4 * S.lift) * e, up = 6.4 * e;\n    wolf = min(wolf, capsule(u, v, -2, -1.6, -2 - back, -1.6 - up, 1.5, 0.15), capsule(u, v, 0.1, -1.6, 0.1 - back, -1.6 - up, 1.5, 0.15));\n    d = min(d, man + (wolf - man) * P.hd);\n  }\n  // Fur: a ragged edge that grows with the change.\n  if (P.fur > 0 && d > -2 && d \u003c 2) d -= P.fur * 0.8 * max(0, sin(px * 1.9 + py * 0.8) * sin(py * 1.7 - px * 0.6) + 0.2);\n  return d;\n}\n\n// Sky, moon, glow, ridge and rock, kept until Hue or Moon move. mc is 1 where\n// the moon shows, for the rim light and the rings; nm is how near the moon an\n// LED is (1 on it, 0 from 14 LEDs off), for lighting the clouds.\nfunction background(S, R) {\n  const { base, mc, nm } = S, sky = 0.76 - 0.42 * S.hue, halo = hsv(sky, 0.85, 1);\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = hypot(dx, dy);\n    const t = round(12 * cl(y / G, 0, 1) ** 1.3) / 12;\n    let [cr, cg, cb] = hsv(sky, 0.78, 0.05 + 0.36 * t);\n    // The halo: half moonlight, half the sky's own colour at full strength.\n    const gl = r > R ? round((0.42 * Math.exp(-(r - R) / 5) + 0.12 * Math.exp(-(r - R) / 18)) * 20) / 20 : 0;\n    cr += (MOON[0] + halo[0]) * gl * 0.4;\n    cg += (MOON[1] + halo[1]) * gl * 0.35;\n    cb += (MOON[2] + halo[2]) * gl * 0.35;\n    let moon = 0;\n    if (r \u003c R) {\n      let e = 9;\n      for (const [sx, sy, rx, ry] of SEAS) e = min(e, ((dx / R - sx) / rx) ** 2 + ((dy / R - sy) / ry) ** 2 + 0.2 * sin(dx * 0.9 + dy));\n      const k = e \u003c 1 ? 0.84 : e \u003c 1.5 ? 0.92 : 1;\n      [cr, cg, cb] = [MOON[0] * k, MOON[1] * k, MOON[2] * k];\n      moon = 1;\n    }\n    // The far ridge across the moon's foot, then the rock, its top moonlit.\n    if (y + 0.5 > RIDGE[x]) {\n      [cr, cg, cb] = hsv(sky, 0.7, y + 0.5 - RIDGE[x] \u003c 1.2 ? 0.2 : 0.12);\n      moon = 0;\n    }\n    if (y + 0.5 > CREST[x]) {\n      // Black rock, its top edge moonlit, split by three long cracks.\n      const top = y + 0.5 - CREST[x] \u003c 1.3, dy = y + 0.5 - G;\n      let crack = false;\n      for (const c of [19, 34, 47]) if (abs(x + 0.5 - c + 0.55 * dy - 2 * sin(dy * 0.3)) \u003c 0.5 && dy > 2 && dy \u003c 20) crack = true;\n      const flat = CREST[x] - G \u003c 1.5;\n      [cr, cg, cb] = top ? (flat ? [0.42, 0.37, 0.3] : [0.16, 0.13, 0.15]) : crack ? [0.09, 0.07, 0.11] : [0.025, 0.015, 0.04];\n      moon = 0;\n    }\n    mc[p] = moon;\n    nm[p] = moon ? 1 : y + 0.5 > RIDGE[x] ? 0 : round(cl(1 - (r - R) / 14, 0, 1) * 4) / 4;\n    base[3 * p] = cr;\n    base[3 * p + 1] = cg;\n    base[3 * p + 2] = cb;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.clouds = cl(k[2], 0, 1);\n  S.moon = cl(k[3], -1, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  story(S);\n  pose(S);\n  parts(S);\n  // Rings leave the nose every 0.3 s while it holds the note, and spread.\n  if (S.howling && (S.ringClock -= ds) \u003c= 0) {\n    S.ringClock = 0.3;\n    const P = S.P, ca = cos(P.face), sa = sin(P.face);\n    S.rings.push({ x: P.head[0] + 9.5 * ca - 0.5 * sa, y: P.head[1] + 9.5 * sa + 0.5 * ca, a: P.face, r: 1 });\n  }\n  for (const r of S.rings) r.r += 20 * ds;\n  S.rings = S.rings.filter((r) => r.r \u003c 56);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.P) return;\n  const R = 27 + 5 * S.moon, key = `${S.hue.toFixed(3)} ${R.toFixed(2)}`;\n  if (key !== S.key) {\n    S.key = key;\n    background(S, R);\n  }\n  const { base, mc, nm, buf, sil } = S, sky = 0.76 - 0.42 * S.hue;\n  buf.set(base);\n  // Stars twinkle in the high sky.\n  for (const [p, ph] of STARS) {\n    const v = 0.35 + 0.3 * sin(S.t * 2.3 + ph);\n    if (buf[3 * p + 2] \u003c 0.3) buf.fill(v, 3 * p, 3 * p + 3);\n  }\n  // Clouds: dark bodies that let some of the moon through, their edges lit\n  // where they cross it or pass near it.\n  const nb = 4 + round(3 * S.clouds), nw = 2 + round(4 * S.clouds), op = 0.55 + 0.37 * S.clouds;\n  const body = hsv(sky, 0.35, 0.27), lit = [0.72, 0.66, 0.54];\n  const cloud = (C, cx, cy, a, th) => {\n    if (!C.mask || C.mask.th !== th) shape(C, th);\n    const { ox, oy, w, h, m } = C.mask, x0 = round(cx) + ox, y0 = round(cy) + oy;\n    if (x0 >= W || x0 + w \u003c= 0) return;\n    for (let j = 0; j \u003c h; j++) {\n      const y = y0 + j;\n      if (y \u003c 0 || y > G) continue;\n      for (let i = 0; i \u003c w; i++) {\n        const x = x0 + i, k = m[j * w + i];\n        if (!k || x \u003c 0 || x >= W) continue;\n        const p = y * W + x, o = 3 * p, near = nm[p], rim = k & 4 ? 0.25 + 0.6 * near : 0, al = k & 1 ? a * 0.75 : a;\n        for (let c = 0; c \u003c 3; c++) buf[o + c] += (body[c] + 0.12 * near + (lit[c] - body[c]) * rim - buf[o + c]) * al;\n      }\n    }\n  };\n  const tb = round((0.8 + 0.45 * S.clouds) * 20) / 20, tw = round((0.7 + 1.1 * S.clouds) * 20) / 20;\n  for (let i = 0; i \u003c nb; i++) cloud(BANK[i], MX + BANK[i][0] + S.bankX, MY + BANK[i][1], op, tb);\n  for (let i = 0; i \u003c nw; i++) {\n    const C = WISPS[i], span = W + 2 * C[2] + 24, x = (((C[1] * span - S.t * (2.5 + i * 0.4)) % span) + span) % span - C[2] - 12;\n    cloud(C, x, C[0], op * 0.8, tw);\n  }\n  // Rings of the howl: arcs about the muzzle's line, pale on the sky and a\n  // cool shadow on the moon, fading as they spread.\n  const ra = S.ra, hit = [];\n  for (const g of S.rings) {\n    const fade = 1 - g.r / 56;\n    for (const rad of [g.r - 0.4, g.r + 0.4]) {\n      const n = ceil(3 * rad) + 2;\n      for (let i = 0; i \u003c n; i++) {\n        const th = -0.75 + (1.5 * i) / (n - 1), x = floor(g.x + rad * cos(g.a + th)), y = floor(g.y + rad * sin(g.a + th));\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const p = y * W + x, a = fade * (1 - abs(th) / 0.75) * 0.9;\n        if (!ra[p]) hit.push(p);\n        ra[p] = max(ra[p], a);\n      }\n    }\n  }\n  for (const p of hit) {\n    const o = 3 * p, a = ra[p], on = mc[p] > 0;\n    buf[o] += ((on ? 0.42 : 0.6) - buf[o]) * a;\n    buf[o + 1] += ((on ? 0.66 : 1) - buf[o + 1]) * a;\n    buf[o + 2] += ((on ? 0.5 : 0.7) - buf[o + 2]) * a;\n    ra[p] = 0;\n  }\n  // The figure, black. Its edge takes a rim of moonlight one LED wide, but\n  // only where the figure is thicker than that, so a thin leg stays black.\n  const P = S.P, bx0 = max(1, floor(P.box[0])), bx1 = min(W - 1, ceil(P.box[1])), by0 = max(1, floor(P.box[2])), by1 = min(G + 1, ceil(P.box[3]));\n  let eyeP = -1, eyeU = 9;\n  sil.fill(1);\n  for (let y = by0; y \u003c by1; y++)\n    for (let x = bx0; x \u003c bx1; x++) {\n      const p = y * W + x, dd = (sil[p] = figure(S, x + 0.5, y + 0.5));\n      // The eye: the LED nearest its place in the head's frame.\n      const eu = S.info.u - 1.3, ev = S.info.v + 1.1, e2 = eu * eu + ev * ev;\n      if (dd \u003c -0.6 && e2 \u003c eyeU) (eyeU = e2), (eyeP = p);\n    }\n  for (let y = by0; y \u003c by1; y++)\n    for (let x = bx0; x \u003c bx1; x++) {\n      const p = y * W + x, dd = sil[p];\n      if (dd >= 0) continue;\n      const deep = min(sil[p - 1], sil[p + 1], sil[p - W], sil[p + W]) \u003c -1.3;\n      const o = 3 * p, rim = dd > -1 && deep ? (mc[p] > 0 ? 0.42 : 0.3) : 0;\n      buf[o] = 0.02 + MOON[0] * rim;\n      buf[o + 1] = 0.012 + MOON[1] * rim;\n      buf[o + 2] = 0.03 + MOON[2] * rim;\n    }\n  // The eye kindles amber as the face changes.\n  if (eyeP >= 0 && P.hd > 0.15) {\n    const e = ease((P.hd - 0.15) / 0.4);\n    buf[3 * eyeP] = e;\n    buf[3 * eyeP + 1] = 0.72 * e;\n    buf[3 * eyeP + 2] = 0.1 * e;\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) display.setPixel(x, y, q4(buf[3 * p]), q4(buf[3 * p + 1]), q4(buf[3 * p + 2]));\n}\n","barn-owl":"// ===== Patternflow pattern =====\n// Title:   Barn Owl\n// Family:  halloween\n// Idea:    A gnarled dead tree stands the full height of a purple night, roots in the grass and bare branches across a big full moon, where a pale barn owl swivels its heart-shaped face far round and back and blinks, then drops off and swoops down the whole panel with big wingbeats to grab a mouse in the grass or miss it, then beats back up as dead leaves fall.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hunger=0..1, Wind=0..1\n//\n// Knob 1: Hue. The sky's colour; moon, owl, tree and leaves stay. At 0 a violet night, at 0.25 a deep red one, at 0.5 a dark olive green one and at 0.75 a dark teal one, each a little paler towards the grass.\n// Knob 2: Speed. At 2 the swoop from branch to grass takes 1.4 s, the owl stands over its catch 0.55 s and the climb back takes 2.3 s at three wingbeats a second; a leaf falls from the branches to the grass in 6 to 10 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Hunger. How long the owl sits between hunts at Speed 2: 6 s at 0, 4 s at half and 1.5 s at 1, give or take 15%, the first hunt at 2.4 s, 1.6 s and 0.7 s. It goes for the further mouse and catches two in three; a caught one hangs from its talons and is swallowed on the branch 2 s later.\n// Knob 4: Wind. At 0.06 the crown stirs by a LED, a tenth of the sky up top is cloud drifting right at 5 LEDs a second and a leaf comes off about every 2 s; at 0.5 the crown sways up to 5 LEDs, a quarter is cloud at 15 a second and a leaf comes off each second; at 1 the crown sways up to 10 LEDs, two fifths is cloud racing over the moon at 25 a second and the leaves blow sideways at 22.\n// Buttons: K1 tap sends the owl down now, if it is on its branch.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The moon, behind the upper branches on the right.\nconst MX = 43, MY = 26, MR = 17;\nconst groundY = (x) => 121 + round(1.2 * sin(x / 6 + 0.5) + 0.7 * sin(x / 2.3));\n\n// The tree: limbs as [parent limb, point on it, x, y, half width for each\n// point]. The trunk kinks up the left third; the owl sits on limb 2.\nconst LIMBS = [\n  [-1, 0, [14, 128, 5.6, 14, 121, 4.6, 16, 112, 3.9, 13, 101, 3.6, 17, 90, 3.3, 15, 79, 3.1, 19, 68, 2.8, 18, 58, 2.5, 21, 49, 2.2, 20, 39, 1.9, 24, 29, 1.6, 23, 19, 1.2, 26, 9, 0.8, 25, 3, 0.5]],\n  [0, 1, [14, 121, 3, 8, 123, 2.2, 3, 126, 1.5, 0, 128, 1.2]],\n  [0, 8, [21, 49, 1.8, 28, 47, 1.6, 35, 47, 1.3, 42, 45, 1, 48, 42, 0.7, 52, 37, 0.5]],\n  [0, 1, [15, 121, 2.8, 22, 124, 2, 28, 127, 1.3]],\n  [0, 9, [20, 40, 1.4, 27, 34, 1.2, 34, 31, 1, 41, 26, 0.8, 47, 24, 0.6, 54, 19, 0.5]],\n  [0, 11, [23, 21, 1, 28, 15, 0.8, 33, 12, 0.6, 37, 6, 0.5]],\n  [0, 7, [18, 60, 1.5, 11, 55, 1.2, 6, 50, 0.9, 3, 43, 0.6, 1, 38, 0.5]],\n  [0, 10, [24, 31, 1.2, 17, 26, 0.9, 11, 21, 0.7, 7, 14, 0.5]],\n  [0, 5, [15, 80, 1.6, 9, 75, 1.1, 5, 69, 0.7]],\n  [4, 2, [34, 31, 0.7, 37, 37, 0.5, 41, 39, 0.5]],\n  [4, 3, [41, 26, 0.6, 45, 31, 0.5, 49, 32, 0.4]],\n  [2, 3, [42, 45, 0.6, 46, 50, 0.5, 49, 51, 0.4]],\n  [5, 1, [28, 15, 0.6, 31, 7, 0.5, 30, 2, 0.4]],\n  [7, 2, [11, 21, 0.6, 14, 15, 0.5, 13, 9, 0.4]],\n  [6, 2, [6, 50, 0.6, 1, 52, 0.4]],\n  [4, 4, [47, 24, 0.5, 52, 27, 0.4, 57, 26, 0.4]],\n  [0, 12, [26, 9, 0.6, 30, 4, 0.4]],\n  [8, 1, [9, 75, 0.7, 4, 78, 0.5, 1, 77, 0.4]],\n];\n// Each point's distance up the tree from the root, for the sway.\nconst TREE = LIMBS.map(([par, at, P]) => ({ par, at, P, n: P.length / 3, s: new Float32Array(P.length / 3) }));\nfor (const L of TREE) {\n  if (L.par >= 0) L.s[0] = TREE[L.par].s[L.at];\n  for (let i = 1; i \u003c L.n; i++) L.s[i] = L.s[i - 1] + Math.hypot(L.P[i * 3] - L.P[i * 3 - 3], L.P[i * 3 + 1] - L.P[i * 3 - 2]);\n}\n// The perch: on limb 2 between its second and third points.\nconst PERCH = [2, 1, 0.55];\n\n// The moon's tone (limb, sea, bright) and its glow in rings.\nconst MOONT = new Uint8Array(N), GLOW = new Float32Array(N);\nconst SEAS = [[-6, -5, 5, 4], [5, -2, 4, 5], [-2, 6, 6, 3], [7, 8, 3, 3]];\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR) {\n    const sea = SEAS.some(([cx, cy, rx, ry]) => ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 \u003c 1);\n    MOONT[p] = r > MR - 1.2 ? 1 : sea ? 2 : 3;\n  } else GLOW[p] = r \u003c MR + 3 ? 0.26 : r \u003c MR + 7 ? 0.15 : r \u003c MR + 13 ? 0.08 : r \u003c MR + 22 ? 0.035 : 0;\n}\nconst MOONC = [0, [240, 196, 120], [255, 238, 196], [255, 222, 150]];\n// Clouds: a noise sheet that wraps round, slid along by the wind; CQ is it\n// sorted, so a cover maps straight to a threshold.\nconst CW = 128, CH = 24, CN = new Float32Array(CW * CH);\nfor (let p = 0; p \u003c CW * CH; p++)\n  for (const [c, a] of [[8, 0.6], [4, 0.3], [2, 0.15]]) {\n    const n = CW / c, u = (p % CW) / c, w = floor(p / CW) / (c / 2), iu = floor(u), iw = floor(w), su = sm(u - iu), sw = sm(w - iw);\n    const hh = (x, y) => hash((((x % n) + n) % n) * 131 + y * 977 + c * 7);\n    CN[p] += a * ((hh(iu, iw) * (1 - su) + hh(iu + 1, iw) * su) * (1 - sw) + (hh(iu, iw + 1) * (1 - su) + hh(iu + 1, iw + 1) * su) * sw);\n  }\nconst CQ = Float32Array.from(CN).sort();\nconst STARS = [];\nfor (let k = 0, x, y; STARS.length \u003c 26; k++) if (((x = floor(hash(k * 3 + 1) * W)) - MX) ** 2 + ((y = floor(hash(k * 3 + 2) * 84)) - MY) ** 2 > 625) STARS.push([x, y, hash(k * 3 + 3) * TAU]);\n\nconst CREAM = [250, 240, 220], BUFF = [238, 176, 96], GOLD = [242, 196, 128], FACE = [255, 252, 246], RIM = [222, 140, 76];\nconst DOT = [196, 160, 136], EYE = [18, 6, 12], LID = [214, 168, 140], BEAK = [236, 198, 168], LEG = [214, 180, 168], LINE = [26, 10, 34];\nconst LEAFC = [[255, 148, 36], [255, 196, 64], [250, 108, 40]], GRASS = [70, 150, 64], BLADE = [34, 86, 44], EARTH = [14, 10, 18];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, cloud: 282, begun: false, mice: [], leaves: [], leafT: 0.3,\n    mode: 0, mt: 0, ox: 0, oy: 0, tilt: 0, spread: 0, flap: 0, talons: 0, face: 0, blink: 0, carry: 0, eat: 0, look: [], lt: 0,\n    sky: new Float32Array(H * 3), skyKey: -1, buf: new Float32Array(N * 3), tm: new Uint8Array(N), ob: new Float32Array(48 * 48 * 3), om: new Uint8Array(48 * 48),\n  };\n}\n\n// Limb k at point i and a share f on, swayed: tips most, a wave up the tree.\nfunction limbAt(S, k, i, f, out) {\n  const L = TREE[k], P = L.P, j = min(i + 1, L.n - 1);\n  const x = P[i * 3] + (P[j * 3] - P[i * 3]) * f, y = P[i * 3 + 1] + (P[j * 3 + 1] - P[i * 3 + 1]) * f, s = L.s[i] + (L.s[j] - L.s[i]) * f;\n  const a = ((s * s) / 12000) * (0.3 + 5.7 * S.wind);\n  const g = sin(S.t * 1.7 - s * 0.035) + 0.45 * sin(S.t * 4.1 + s * 0.11 + k);\n  out[0] = x + a * g;\n  out[1] = y + a * g * 0.25 * (x \u003c 20 ? -1 : 1) * 0.5;\n  return out;\n}\n\nconst tmp = [0, 0], tmp2 = [0, 0];\nfunction perch(S) {\n  limbAt(S, PERCH[0], PERCH[1], PERCH[2], tmp);\n  return [tmp[0], tmp[1] - 1.2];\n}\n\nconst mouse = (x) => ({ x, tx: x, y: 0, wait: rnd(0.2, 1.2), dir: 1, hide: 0, run: 0, flee: 0 });\nconst leaf = (x, y, c) => ({ x, y, c, ph: rnd(0, TAU), w: rnd(2.5, 4.5), vy: rnd(10, 15) });\n\n// A cubic Bézier through four points.\nconst bez = (p, t, k) => {\n  const u = 1 - t;\n  return u * u * u * p[k] + 3 * u * u * t * p[2 + k] + 3 * u * t * t * p[4 + k] + t * t * t * p[6 + k];\n};\n\nfunction startHunt(S) {\n  const live = S.mice.filter((m) => m.hide \u003c= 0 && !m.flee);\n  if (!live.length) return false;\n  const [px, py] = perch(S);\n  let m = live[0];\n  for (const q of live) if (abs(q.x - px) > abs(m.x - px)) m = q;\n  Object.assign(S, { prey: m, catchIt: Math.random() \u003c 0.67, mode: 1, mt: 0, px, py });\n  return true;\n}\n\n// The path down: off the branch, out wide on the side away from the mouse,\n// and in low over the grass to it.\nfunction swoopPath(S) {\n  const m = S.prey, ex = cl(m.x + m.dir * 6, 8, 56), ey = groundY(round(ex)) - 8, side = ex > S.ox ? -1 : 1;\n  S.path = [S.ox, S.oy, S.ox + side * 26, S.oy + 34, ex - side * 30, ey - 26, ex, ey];\n}\n\nfunction climbPath(S) {\n  const [px, py] = perch(S), side = S.ox \u003c 32 ? 1 : -1;\n  S.path = [S.ox, S.oy, S.ox + side * 22, S.oy - 40, px + side * 30, py + 30, px, py - 10];\n}\n\nconst T_DROP = 0.35, T_SWOOP = 1.4, T_STRIKE = 0.55, T_CLIMB = 2.3, T_LAND = 0.5;\n\nfunction owl(S, ds) {\n  S.mt += ds;\n  const [px, py] = perch(S);\n  const bx = S.ox, by = S.oy;\n  if (S.mode === 0) {\n    // On the branch: feet on the limb, the head looking about.\n    Object.assign(S, { ox: px, oy: py - 9, spread: max(0, S.spread - ds * 3), talons: 0, flap: 0, tilt: S.tilt * 0.8 });\n    if (S.carry && (S.eat += ds) > 2.2) (S.carry = 0), (S.eat = 0);\n    // The head: a turn far round to one side, back, a glance the other way.\n    S.lt += ds;\n    if (!S.look.length || S.lt > S.look[S.look.length - 1][0]) {\n      const far = rnd(0.5, 1) \u003c 0.5 ? -1 : 1;\n      S.look = [[0, S.face], [0.5, far * rnd(1.8, 2.6)], [1.6, far * rnd(1.8, 2.6)], [2.2, 0], [2.9, 0], [3.3, -far * rnd(0.6, 1.1)], [3.9, -far * 0.8], [4.3, 0], [5.4, 0]];\n      S.lt = 0;\n    }\n    let k = 1;\n    while (k \u003c S.look.length - 1 && S.look[k][0] \u003c S.lt) k++;\n    const [t0, a0] = S.look[k - 1], [t1, a1] = S.look[k];\n    S.face = a0 + (a1 - a0) * sm((S.lt - t0) / max(1e-6, t1 - t0));\n    S.blink = (S.lt % 2.7) > 2.55 ? 1 : 0;\n    if ((S.wait -= ds) \u003c 0 && !S.carry && !startHunt(S)) S.wait = 1;\n    return;\n  }\n  S.blink = 0;\n  S.face *= exp(-ds * 10);\n  const t = S.mt;\n  if (S.mode === 1) {\n    // Off the branch: the wings open as it falls.\n    const f = t / T_DROP;\n    Object.assign(S, { spread: sm(f * 1.4), flap: 0.8 - 0.6 * f, ox: S.px + 3 * f, oy: S.py - 9 + 6 * f * f });\n    if (t >= T_DROP) (S.mode = 2), (S.mt = 0), swoopPath(S);\n  } else if (S.mode === 2) {\n    // The swoop: two beats, then a long glide; the end follows the mouse.\n    const f = min(1, t / T_SWOOP), u = f * f * (3 - 2 * f) * 0.6 + f * 0.4, m = S.prey;\n    S.path[6] += (cl(m.x, 6, 58) - S.path[6]) * min(1, ds * 3);\n    Object.assign(S, { ox: bez(S.path, u, 0), oy: bez(S.path, u, 1), spread: 1, talons: sm((f - 0.7) / 0.3) });\n    S.flap = t \u003c 0.75 ? 0.15 + 0.7 * sin(TAU * 2.6 * t) : 0.1 + 0.25 * sm((f - 0.8) / 0.2);\n    if (f >= 1) {\n      (S.mode = 3), (S.mt = 0);\n      if (S.catchIt && abs(m.x - S.ox) \u003c 6 && !m.flee) (S.carry = 1), (m.hide = rnd(3, 6)), (m.x = rnd(0, 1) \u003c 0.5 ? -4 : 68);\n      else (m.flee = 1), (m.dir = m.x \u003c S.ox ? -1 : 1);\n    }\n  } else if (S.mode === 3) {\n    // On the grass: wings held high over the catch, a beat, and off.\n    Object.assign(S, { spread: 1, talons: 1, flap: 0.95 - 0.4 * sin(PI * cl(t / T_STRIKE, 0, 1)), oy: S.oy + sin(t * 9) * ds * 3 });\n    if (t >= T_STRIKE) (S.mode = 4), (S.mt = 0), climbPath(S);\n  } else if (S.mode === 4) {\n    // The climb back up: hard wingbeats, three a second.\n    const f = min(1, t / T_CLIMB), u = f * f * (3 - 2 * f);\n    (S.path[6] = px), (S.path[7] = py - 10);\n    Object.assign(S, { ox: bez(S.path, u, 0), oy: bez(S.path, u, 1), spread: 1, flap: 0.2 + 0.75 * sin(TAU * 3 * t), talons: S.carry ? 1 : max(0, 1 - t * 3) });\n    if (f >= 1) (S.mode = 5), (S.mt = 0);\n  } else {\n    // Landing: a flare and the wings fold.\n    const f = min(1, t / T_LAND);\n    Object.assign(S, { ox: px, oy: py - 10 + f, flap: 0.9, spread: 1 - sm(f), talons: S.carry ? 1 - f : 0 });\n    if (f >= 1) (S.mode = 0), (S.mt = 0), (S.wait = waitOf(S)), (S.look = []), (S.eat = 0);\n  }\n  const vx = (S.ox - bx) / max(1e-4, ds);\n  S.tilt += (cl(vx * 0.012, -0.45, 0.45) - S.tilt) * min(1, ds * 6);\n}\n\nconst waitOf = (S) => 6 - 4.5 * S.hunger * (1 - 0.25 * (1 - S.hunger)) * rnd(0.85, 1.15);\n\nfunction mice(S, ds) {\n  for (const m of S.mice) {\n    m.y = groundY(cl(round(m.x), 0, W - 1)) - 1;\n    if (m.hide > 0) {\n      if ((m.hide -= ds) \u003c= 0) Object.assign(m, { x: rnd(0, 1) \u003c 0.5 ? -3 : 67, tx: rnd(12, 52), flee: 0, wait: 0 });\n    } else if (m.flee) {\n      (m.x += m.dir * 60 * ds), (m.run += ds * 14);\n      if (m.x \u003c -6 || m.x > 70) (m.hide = rnd(1.5, 3)), (m.flee = 0);\n    } else if (m === S.prey && S.mode === 2) {\n      // A last dash as the owl comes in.\n      (m.x += m.dir * 18 * ds), (m.run += ds * 12);\n      if (m.x \u003c 6 || m.x > 58) m.dir = -m.dir;\n    } else if ((m.wait -= ds) \u003c 0) {\n      const d = m.tx - m.x;\n      m.dir = d \u003c 0 ? -1 : 1;\n      (m.x += m.dir * min(abs(d), 26 * ds)), (m.run += ds * 12);\n      if (abs(d) \u003c 0.5) (m.wait = rnd(0.3, 1.6)), (m.tx = cl(m.x + rnd(-24, 24), 6, 58));\n    }\n  }\n}\n\nfunction leaves(S, ds) {\n  S.leafT -= ds * (0.4 + 1.6 * S.wind);\n  if (S.leafT \u003c 0 && S.leaves.length \u003c 4 + floor(6 * S.wind)) {\n    S.leafT += rnd(0.6, 1.4);\n    const k = [2, 4, 5, 6, 7, 9, 10, 11, 13, 15][floor(rnd(0, 10))], L = TREE[k];\n    limbAt(S, k, floor(rnd(1, L.n - 1)), rnd(0, 1), tmp2);\n    S.leaves.push(leaf(tmp2[0], tmp2[1], floor(rnd(0, 3))));\n  }\n  S.leaves = S.leaves.filter((l) => {\n    l.ph += ds * l.w;\n    l.x += (S.wind * 22 + 7 * sin(l.ph)) * ds;\n    l.y += l.vy * (0.65 + 0.35 * abs(cos(l.ph))) * ds;\n    return l.y \u003c groundY(cl(round(l.x), 0, W - 1)) && l.x > -4 && l.x \u003c 68;\n  });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.hunger, S.wind] = [cl(k[0], 0, 1), cl(k[1], 0.2, 3), cl(k[2], 0, 1), cl(k[3], 0, 1)];\n  const ds = (d * S.speed) / 2;\n  if (!S.begun) {\n    S.begun = true;\n    S.mice = [mouse(14), mouse(46)];\n    S.wait = 2.4 - 1.7 * S.hunger;\n    // A few leaves already on their way down.\n    for (let i = 0; i \u003c 3; i++) S.leaves.push(leaf(rnd(8, 56), rnd(20, 110), i));\n  }\n  S.t += ds;\n  S.cloud += ds * (4 + 21 * S.wind);\n  if (input.btnPressed && input.btnPressed[0] && S.mode === 0) (S.carry = 0), startHunt(S);\n  owl(S, ds);\n  mice(S, ds);\n  leaves(S, ds);\n}\n\n// The sky by row, in ten flat steps: deep overhead, paler low down.\nfunction skyRows(S) {\n  if (S.skyKey === S.hue) return;\n  S.skyKey = S.hue;\n  for (let y = 0, t; y \u003c H; y++) (t = floor((y / H) * 10) / 9), S.sky.set(hsv(0.76 + S.hue + 0.03 * t, 0.84 - 0.2 * t, 0.2 + 0.2 * t, [0, 0, 0]), 3 * y);\n}\n\nfunction put(buf, x, y, c, f = 1) {\n  (x = round(x)), (y = round(y));\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  (buf[o] = c[0] * f), (buf[o + 1] = c[1] * f), (buf[o + 2] = c[2] * f);\n}\n\n// The owl, drawn in its own frame: u across, v down its body, origin at\n// the middle of the body, turned by its tilt.\nfunction owlPixel(S, u, v) {\n  const sp = S.spread, hx = u, hy = v + 6.4;\n  // The head: square on, the face is a white heart with a tan rim; turned,\n  // it narrows and slides aside, and past a right angle the back shows.\n  if ((hx / 5.4) ** 2 + (hy / 4.9) ** 2 \u003c 1) {\n    const c = cos(S.face), fu = sin(S.face) * 3.8, sx = max(0.2, c);\n    if (c > -0.05) {\n      const uf = (u - fu) / sx, vf = v + 5.9;\n      const heart = (d) => (uf - 2) ** 2 + (vf + 1.1) ** 2 \u003c (2.6 + d) ** 2 || (uf + 2) ** 2 + (vf + 1.1) ** 2 \u003c (2.6 + d) ** 2 || (vf > -1.1 && vf \u003c 3.8 + d && abs(uf) \u003c ((3.8 + d - vf) * 4.6) / 4.9);\n      if (heart(0)) {\n        for (const e of [-1, 1]) if ((u - fu - e * 1.9 * sx) ** 2 + (v + 5.9) ** 2 \u003c 0.7) return S.blink ? LID : EYE;\n        if ((u - fu) ** 2 + (v + 4.1) ** 2 \u003c 0.55) return BEAK;\n        return FACE;\n      }\n      if (heart(0.9 / sx)) return RIM;\n    }\n    // A darker collar, and turned away a ruff, so the head reads as a head.\n    const e = (hx / 5.4) ** 2 + (hy / 4.9) ** 2;\n    if (e > 0.72 && (hy > 1.5 || c \u003c 0)) return DOT;\n    return hash(round(u * 3) * 31 + round(v * 3) * 7) \u003c 0.16 ? DOT : GOLD;\n  }\n  // Turned side on, the beak shows past the edge of the head.\n  if (abs(sin(S.face)) > 0.85 && cos(S.face) > -0.3 && abs(v + 4.6) \u003c 0.6 && abs(u - sin(S.face) * 5.6) \u003c 0.7) return BEAK;\n  // The body, an egg wider below: a cream breast between folded buff wings.\n  const ry = 6.4 - 0.8 * sp, cy = 2.2 - 0.4 * sp, rx = (5.4 - 1.4 * sp) * (1 + 0.1 * cl((v - cy) / ry, -1, 1));\n  if ((u / rx) ** 2 + ((v - cy) / ry) ** 2 \u003c 1) {\n    const breast = abs(u) \u003c 2.7 - 0.5 * sp + (0.8 * (v - cy)) / ry;\n    if (breast) return hash(round(u * 2) * 13 + round(v * 2) * 5) \u003c 0.08 ? DOT : CREAM;\n    return hash(round(u * 2) * 17 + round(v * 2) * 3) \u003c 0.22 ? DOT : BUFF;\n  }\n  if (sp \u003c 0.3 && v > 8.2 && v \u003c 10.4 && abs(u) \u003c (10.4 - v) * 0.9) return DOT;\n  // Legs and talons, reaching down when it strikes or carries.\n  if (S.talons > 0.05) for (const e of [-1, 1]) if (abs(u - e * 1.5) \u003c 0.6 && v > 5 && v \u003c 5.5 + 4.5 * S.talons) return LEG;\n  // The wings: a buff leading edge, cream behind, dark bars near the tip.\n  if (sp > 0.02)\n    for (const e of [-1, 1]) {\n      const sx = e * 2.6, sy = -1.6, L = 13 * sp, a = S.flap, tx = sx + e * L * cos(a), ty = sy - L * sin(a) * 0.9;\n      const ax = tx - sx, ay = ty - sy, l2 = ax * ax + ay * ay;\n      if (l2 \u003c 1) continue;\n      const t = ((u - sx) * ax + (v - sy) * ay) / l2;\n      if (t \u003c -0.05 || t > 1.04) continue;\n      const qx = u - (sx + ax * t), qy = v - (sy + ay * t), il = 1 / sqrt(l2);\n      // The trailing side is the one away from the head.\n      let nx = -ay * il, ny = ax * il;\n      if (ny \u003c 0) (nx = -nx), (ny = -ny);\n      const dn = qx * nx + qy * ny, tc = cl(t, 0, 1), ch = 1.1 + 4.2 * sqrt(max(0, 1 - tc * tc)) * (1 - 0.25 * tc);\n      if (dn \u003c -0.9 || dn > ch) continue;\n      if (tc > 0.7 && (tc * 12) % 1 \u003c 0.3 && dn > 0.6) return DOT;\n      return dn \u003c 0.7 ? BUFF : dn \u003c ch * 0.55 ? GOLD : CREAM;\n    }\n  return null;\n}\n\nfunction drawOwl(S, buf) {\n  const { ob, om } = S, cx = round(S.ox), cy = round(S.oy), ct = cos(S.tilt), st = sin(S.tilt);\n  om.fill(0);\n  for (let j = 0; j \u003c 48; j++)\n    for (let i = 0; i \u003c 48; i++) {\n      const dx = i - 24 + 0.5 + cx - S.ox, dy = j - 24 + 0.5 + cy - S.oy;\n      const c = owlPixel(S, dx * ct + dy * st, -dx * st + dy * ct);\n      if (!c) continue;\n      const o = j * 48 + i;\n      om[o] = 1;\n      (ob[o * 3] = c[0]), (ob[o * 3 + 1] = c[1]), (ob[o * 3 + 2] = c[2]);\n    }\n  for (let j = 0; j \u003c 48; j++)\n    for (let i = 0; i \u003c 48; i++) {\n      const x = cx - 24 + i, y = cy - 24 + j;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const o = j * 48 + i, p = (y * W + x) * 3;\n      if (om[o]) (buf[p] = ob[o * 3]), (buf[p + 1] = ob[o * 3 + 1]), (buf[p + 2] = ob[o * 3 + 2]);\n      // A dark line round it, so a pale owl stands off a pale moon.\n      else if ((i > 0 && om[o - 1]) || (i \u003c 47 && om[o + 1]) || (j > 0 && om[o - 48]) || (j \u003c 47 && om[o + 48])) (buf[p] = LINE[0]), (buf[p + 1] = LINE[1]), (buf[p + 2] = LINE[2]);\n    }\n}\n\n// A mouse, five LEDs long with an ear, an eye and a tail, legs going.\nconst MOUSE = [204, 186, 172], TAIL = [226, 160, 168];\nfunction drawMouse(buf, x, y, dir, run) {\n  for (let i = -2; i \u003c= 2; i++) put(buf, x + dir * i, y, MOUSE);\n  for (let i = -1; i \u003c= 1; i++) put(buf, x + dir * i, y - 1, MOUSE);\n  put(buf, x + dir * 3, y, MOUSE, 0.85);\n  put(buf, x + dir * 1, y - 2, TAIL);\n  put(buf, x + dir * 2, y - 1, EYE);\n  for (let i = 0; i \u003c 4; i++) put(buf, x - dir * (3 + i), y + (i > 1 ? -1 : 0), TAIL, 0.85);\n  put(buf, x + (floor(run) % 2 ? -1 : 1), y + 1, MOUSE, 0.7);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  skyRows(S);\n  const { buf, sky, tm } = S;\n  const cover = 0.08 + 0.3 * S.wind, thr = CQ[floor((1 - cover) * (CQ.length - 1))], off = S.cloud;\n  // Sky, stars, moon and clouds.\n  for (let y = 0; y \u003c H; y++) {\n    const fy = y / 3.2, j0 = floor(fy) % CH, j1 = (j0 + 1) % CH, ty = fy - floor(fy);\n    const band = y > 60 ? (y - 60) * 0.012 : 0;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p, mt = MOONT[p], gl = GLOW[p];\n      let R = sky[3 * y], G = sky[3 * y + 1], B = sky[3 * y + 2];\n      if (mt) {\n        const c = MOONC[mt];\n        (R = c[0]), (G = c[1]), (B = c[2]);\n      } else if (gl) (R += 255 * gl), (G += 210 * gl), (B += 140 * gl);\n      if (y \u003c 90) {\n        const fx = (x - off) * 0.3, i0 = floor(fx), tx = fx - i0, a0 = ((i0 % CW) + CW) % CW, a1 = (a0 + 1) % CW;\n        const n = (CN[j0 * CW + a0] * (1 - tx) + CN[j0 * CW + a1] * tx) * (1 - ty) + (CN[j1 * CW + a0] * (1 - tx) + CN[j1 * CW + a1] * tx) * ty;\n        const e = n - band - thr;\n        if (e > 0) {\n          const lit = min(1, (mt ? 1 : gl * 3.2) + 0.15);\n          if (e \u003c 0.02) (R = 70 + 150 * lit), (G = 40 + 130 * lit), (B = 92 + 80 * lit);\n          else if (e \u003c 0.06) (R = 50 + 60 * lit), (G = 26 + 50 * lit), (B = 70 + 34 * lit);\n          else (R = 36 + 20 * lit), (G = 16 + 14 * lit), (B = 52 + 12 * lit);\n        }\n      }\n      (buf[o] = R), (buf[o + 1] = G), (buf[o + 2] = B);\n    }\n  }\n  for (const [x, y, ph] of STARS) {\n    const tw = 0.5 + 0.5 * sin(S.t * 3 + ph * 5), o = (y * W + x) * 3;\n    if (buf[o + 2] \u003c 120 && tw > 0.3) (buf[o] += 120 * tw), (buf[o + 1] += 110 * tw), (buf[o + 2] += 130 * tw);\n  }\n  // Leaves behind the tree.\n  drawLeaves(S, buf, 0);\n  // The tree: each limb a run of round-ended strokes, swayed.\n  tm.fill(0);\n  for (let k = 0; k \u003c TREE.length; k++) {\n    const L = TREE[k];\n    let ax = 0, ay = 0, aw = 0;\n    for (let i = 0; i \u003c L.n; i++) {\n      limbAt(S, k, i, 0, tmp);\n      const bx = tmp[0], by = tmp[1], bw = L.P[i * 3 + 2];\n      if (i) {\n        const x0 = max(0, floor(min(ax, bx) - 5)), x1 = min(W - 1, ceil(max(ax, bx) + 5)), y0 = max(0, floor(min(ay, by) - 5)), y1 = min(H - 1, ceil(max(ay, by) + 5));\n        const dx = bx - ax, dy = by - ay, l2 = dx * dx + dy * dy || 1;\n        for (let y = y0; y \u003c= y1; y++)\n          for (let x = x0; x \u003c= x1; x++) {\n            const px = x + 0.5 - ax, py = y + 0.5 - ay, t = cl((px * dx + py * dy) / l2, 0, 1), w = aw + (bw - aw) * t;\n            if ((px - dx * t) ** 2 + (py - dy * t) ** 2 \u003c w * w + 0.15) tm[y * W + x] = 1;\n          }\n      }\n      (ax = bx), (ay = by), (aw = bw);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (!tm[p]) continue;\n      const o = p * 3;\n      // Bark is black; an edge that faces the moon catches its light.\n      const right = x \u003c W - 1 && !tm[p + 1], top = y > 0 && !tm[p - W];\n      const towards = (MX - x) * (right ? 1 : 0) + (MY - y) * (top ? -1 : 0);\n      if ((right || top) && towards > 0) {\n        const f = min(1, 0.45 + GLOW[p] * 2.5 + (MOONT[p] ? 0.6 : 0));\n        (buf[o] = 92 * f), (buf[o + 1] = 58 * f), (buf[o + 2] = 120 * f);\n      } else (buf[o] = 8), (buf[o + 1] = 3), (buf[o + 2] = 12);\n    }\n  // The ground, where the roots go in, and the grass in front of the mice.\n  for (let x = 0; x \u003c W; x++) {\n    const g = groundY(x), h = 2 + floor(hash(x * 7 + 3) * 5), lean = (S.wind * 2.2 + 0.6 * sin(S.t * 2.3 + x * 0.4) * (0.3 + S.wind)) * 0.5;\n    for (let y = g; y \u003c H; y++) if (!tm[y * W + x] || y >= g + 2) put(buf, x, y, EARTH);\n    for (let i = 1; i \u003c= h; i++) {\n      if (hash(x * 13 + i) \u003c 0.4 && i \u003c h - 1) continue;\n      put(buf, x + lean * (i / h) * 2, g - i, i === h ? GRASS : BLADE);\n    }\n  }\n  for (const m of S.mice) if (m.hide \u003c= 0) drawMouse(buf, m.x, m.y, m.dir, m.run);\n  // The owl, and the mouse it carries.\n  drawOwl(S, buf);\n  if (S.carry) {\n    if (S.mode !== 0 || S.eat \u003c 1.3) drawMouse(buf, S.ox, S.oy + 5 + 4.5 * S.talons + 1, 1, 0);\n    else if (S.eat \u003c 2.2) for (let i = 0; i \u003c 3; i++) put(buf, S.ox + 0.5, S.oy - 3 + i, TAIL);\n  }\n  drawLeaves(S, buf, 1);\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    // Channels in steps of 4 of 255, too fine to see.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n  }\n}\n\n// Leaves: three LEDs that turn over as they fall, half behind the tree.\nfunction drawLeaves(S, buf, front) {\n  S.leaves.forEach((l, i) => {\n    if ((i & 1) !== front) return;\n    const c = LEAFC[l.c], k = floor((((l.ph % TAU) + TAU) % TAU) / (PI / 2)), f = 0.8 + 0.2 * abs(sin(l.ph));\n    const [dx, dy] = [[1, 0], [1, 1], [0, 1], [-1, 1]][k];\n    put(buf, l.x, l.y, c, f);\n    put(buf, l.x + dx, l.y + dy, c, f * 0.9);\n    put(buf, l.x - dx, l.y - dy, c, f * 0.8);\n  });\n}\n","bone-pile":"// ===== Patternflow pattern =====\n// Title:   Bone Pile\n// Family:  halloween\n// Idea:    A skeleton dances in a violet spotlight in a stone crypt until, on a beat, every bone lets go and the whole frame crashes into a heap on the flagstones, lies still while the skull's eyes kindle, then the bones fly up one at a time on arcs from the feet upward and snap back into place, the skull last, landing with a nod before the dance goes on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dance=4..32, Fog=0..1\n//\n// Knob 1: Hue. The spotlight and all it tints: the wall in the beam, the pool on the flagstones, the dust, the bones' shadow side, the fog and the kindled eyes. Violet at 0, red at 0.24, lime at 0.5, cyan at 0.75; the bones stay ivory, the candles orange.\n// Knob 2: Speed. The tempo, 50 beats a minute for each unit, and the rest keeps time with it. At the opening 2, 100: every bone is down 0.5 s after the beat that drops it, the eyes kindle at 1 s, the pieces fly back one every 0.18 s from 1.5 s and the skull lands at 4.7 s and nods. At 0.2 all ten times slower; 150 at 3.\n// Knob 3: Dance. Beats danced between collapses: 4 at the start, so the first fall comes 2.4 s in and the next 2.8 s after the nod at 7.4 s; 11 at a quarter, 18 at half, 32 at the end, 19 s at 100 a minute. Each time it gets up it dances the next of three dances: a sway with both arms up, kicks to each side with hands on hips, a bounce with the arms pumping in turn.\n// Knob 4: Fog. Ground fog drifting in two layers, thickening over its top 16 rows. None at 0; at the opening 0.06 a wisp from row 115; at 0.5 from row 93, burying half the heap; at 1 from row 68, up to the standing skeleton's hips.\n// Buttons: K1 tap brings the skeleton down at once, mid-dance or half rebuilt.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// --- shapes, each in its own frame with y down, as a distance (negative\n// inside). A hole function marks dark sockets and gaps inside a bone.\nconst seg = (x, y, ax, ay, bx, by) => {\n  const dx = bx - ax, dy = by - ay, t = cl(((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy), 0, 1);\n  return sqrt((x - ax - dx * t) ** 2 + (y - ay - dy * t) ** 2);\n};\nconst ell = (x, y, cx, cy, rx, ry) => (sqrt(((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2) - 1) * min(rx, ry);\nconst box = (x, y, cx, cy, hx, hy, r) => {\n  const qx = abs(x - cx) - hx + r, qy = abs(y - cy) - hy + r;\n  return sqrt(max(qx, 0) ** 2 + max(qy, 0) ** 2) + min(max(qx, qy), 0) - r;\n};\n// Kinds: 0 long bone, 1 paired long bones (forearm, shin), 2 rib cage with\n// collarbones and neck, 3 lumbar spine, 4 pelvis, 5 skull, 6 jaw, 7 hand,\n// 8 foot. A long bone is centred on its origin along y, L long.\nfunction long(x, y, L, w, r) {\n  const e = L / 2 - r, q = 0.6 * r, ry = r * 0.9;\n  return min(seg(x, y, 0, -e, 0, e) - w, ell(x, y, -q, -e, r, ry), ell(x, y, q, -e, r, ry), ell(x, y, -q, e, r, ry), ell(x, y, q, e, r, ry));\n}\nconst RIBS = [[7.6, 2.4], [9.4, 6.6], [10.4, 10.8], [10.4, 15], [9.2, 19]];\nfunction shape(k, x, y, sg) {\n  switch (k) {\n    case 0:\n      return long(x, y, sg, 0.85 + 0.015 * sg, 1.45);\n    case 1: {\n      const e = sg / 2 - 1.1;\n      return min(seg(x, y, -1, -e, -1, e) - 0.75, seg(x, y, 1.1, -e, 1.1, e) - 0.55, box(x, y, 0, -e - 0.2, 2.3, 1.1, 1), box(x, y, 0, e + 0.2, 2.1, 1.1, 1));\n    }\n    case 2: {\n      // Origin at the top of the breastbone; the neck rises above it.\n      let d = min(box(x, y, 0, -3.4, 1.5, 0.75, 0.5), box(x, y, 0, -1.4, 1.6, 0.75, 0.5));\n      d = min(d, seg(x, y, -1.4, 0.8, -11.4, -0.2) - 0.75, seg(x, y, 1.4, 0.8, 11.4, -0.2) - 0.75, seg(x, y, 0, 1, 0, 14) - 1.15);\n      for (let v = 15.5; v \u003c 24; v += 2.7) d = min(d, box(x, y, 0, v, 1.6, 0.9, 0.5));\n      for (const [rx, ry] of RIBS) {\n        const c = 3.6 / (rx * rx), ax = min(abs(x), rx), f = ry + c * ax * ax;\n        d = min(d, abs(x) \u003c= rx ? abs(y - f) / sqrt(1 + (2 * c * ax) ** 2) - 0.62 : sqrt((abs(x) - rx) ** 2 + (y - f) ** 2) - 0.62);\n      }\n      return d;\n    }\n    case 3: {\n      let d = 9;\n      for (let v = -4; v \u003c= 4.1; v += 2.7) d = min(d, box(x, y, 0, v, 1.9, 0.95, 0.5), box(x, y, 0, v, 3.1, 0.35, 0.3));\n      return d;\n    }\n    case 4: {\n      // Origin between the hip sockets: two wings tipped outward, the sacrum\n      // narrowing down between them, and two rings round the holes of the\n      // lower pelvis.\n      let d = max(abs(x) - (2.5 - 0.28 * (y + 5.5)), abs(y + 2.6) - 3);\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const dx = x - s * 5.3, dy = y + 3.6, c = 0.8, n = 0.6 * s;\n        d = min(d, ell(dx * c + dy * n, -dx * n + dy * c, 0, 0, 4.1, 2.9), abs(ell(x, y, s * 3.4, 2.4, 2.4, 1.9)) - 0.75, ell(x, y, s * 6.5, 0, 1.5, 1.5));\n      }\n      return d;\n    }\n    case 5:\n      // Origin at the top of the neck; the skull rises above it.\n      return min(ell(x, y, 0, -10.6, 7, 7.3), ell(x, y, 0, -6.8, 6.4, 2.3), box(x, y, 0, -3.2, 4.4, 2.6, 1.4));\n    case 6: {\n      const hw = 4.3 - 0.4 * max(0, y);\n      return min(box(x, y, 0, 1.5, 4.3, 1.6, 0.8), max(abs(x) - hw, abs(y - 1.6) - 1.8));\n    }\n    case 7: {\n      let d = ell(x, y, 0, 1.4, 1.7, 1.3);\n      for (let i = 0; i \u003c 4; i++) d = min(d, seg(x, y, -1.2 + 0.8 * i, 2.2, -1.8 + 1.2 * i, 5.4) - 0.42);\n      return d;\n    }\n    default:\n      return min(ell(x, y, sg * 0.8, 1.6, 3.1, 1.4), ell(x, y, 0, 0.4, 1.4, 1));\n  }\n}\n// 0 none, 1 dark, 2 an eye socket, 3 in shade.\nfunction hole(k, x, y, P) {\n  if (k === 5) {\n    const p = P.pitch * 3;\n    if (((abs(x) - 2.9) / 2.1) ** 2 + ((y + 7.9 - p) / 2.4) ** 2 \u003c 1) return 2;\n    const ny = y + 5.6 - p;\n    if (ny >= 0 && ny \u003c 1.7 && abs(x) \u003c 0.3 + 0.5 * ny) return 1;\n    if (y > -2 + p * 0.5 && y \u003c -0.5 && abs(x) \u003c 4) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 || y > -0.9 ? 1 : 0;\n  } else if (k === 6 && y \u003c 1.2 && y > -0.2 && abs(x) \u003c 3.8) return (x + 4) / 1.45 - floor((x + 4) / 1.45) \u003c 0.3 ? 1 : 0;\n  // The hollow of each pelvic wing, in shade.\n  else if (k === 4 && ((abs(x) - 4.6) / 2.3) ** 2 + ((y + 4.4 + 0.3 * abs(x)) / 1.3) ** 2 \u003c 1) return 3;\n  return 0;\n}\n\n// The pieces, back to front. [kind, length or side, the bounds of the shape\n// in its own frame].\nconst PIECES = [\n  [8, -1, -3.9, 3.9, -1, 3.2], [8, 1, -3.9, 3.9, -1, 3.2],\n  [1, 24, -2.4, 2.4, -12.4, 12.4], [1, 24, -2.4, 2.4, -12.4, 12.4],\n  [0, 26, -2.5, 2.5, -13.3, 13.3], [0, 26, -2.5, 2.5, -13.3, 13.3],\n  [4, 0, -11, 11, -9, 5.2], [3, 0, -3.5, 3.5, -5.3, 5.3], [2, 0, -12.2, 12.2, -4.5, 22.6],\n  [0, 19, -2.2, 2.2, -9.8, 9.8], [0, 19, -2.2, 2.2, -9.8, 9.8],\n  [1, 17, -2.4, 2.4, -8.9, 8.9], [1, 17, -2.4, 2.4, -8.9, 8.9],\n  [7, 0, -2.6, 2.6, -0.2, 6], [7, 0, -2.6, 2.6, -0.2, 6],\n  [6, 0, -4.4, 4.4, -0.3, 3.5], [5, 0, -7.2, 7.2, -18.1, 0.6],\n];\nconst NB = PIECES.length, SKULL = 16, JAW = 15;\nconst FLOOR = 120, CX = 32, HIPY = 67, HIP = 7, FEMUR = 26, TIBIA = 24, ARM = 19, FORE = 17;\n\n// --- the body: a pose to where each piece sits, [x, y, angle] with the\n// angle turning the piece's own y onto the bone.\nconst at = (P, i, x, y, a) => {\n  P.x[i] = x;\n  P.y[i] = y;\n  P.a[i] = a;\n};\nconst ang = (dx, dy) => atan2(-dx, dy);\nfunction bone(P, i, ax, ay, bx, by) {\n  at(P, i, (ax + bx) / 2, (ay + by) / 2, ang(bx - ax, by - ay));\n}\n// Two-bone reach with the knee bent outward.\nfunction leg(P, s, hx, hy, fx, fy) {\n  const dx = fx - hx, dy = fy - hy, d = cl(sqrt(dx * dx + dy * dy), 3, FEMUR + TIBIA - 0.01);\n  const al = Math.acos(cl((FEMUR * FEMUR + d * d - TIBIA * TIBIA) / (2 * FEMUR * d), -1, 1)), b = atan2(dy, dx) - s * al;\n  const kx = hx + FEMUR * cos(b), ky = hy + FEMUR * sin(b), u = (fx - kx) / sqrt((fx - kx) ** 2 + (fy - ky) ** 2), v = (fy - ky) / sqrt((fx - kx) ** 2 + (fy - ky) ** 2);\n  bone(P, 4 + (s > 0), hx, hy, kx, ky);\n  const ex = kx + TIBIA * u, ey = ky + TIBIA * v;\n  bone(P, 2 + (s > 0), kx, ky, ex, ey);\n  at(P, s > 0 ? 1 : 0, ex, ey, 0);\n}\nconst rot = (a, x, y) => [x * cos(a) - y * sin(a), x * sin(a) + y * cos(a)];\n// Pose numbers: sway, bob, pelvis tilt, torso lean, head roll, nod, jaw,\n// each arm's lift from hanging and elbow bend, each foot's lift and step.\nfunction rig(D, P) {\n  const rx = CX + D.sway, ry = HIPY + D.bob, t = D.tilt, l = D.lean;\n  at(P, 6, rx, ry, t);\n  for (const s of [-1, 1]) {\n    const [hx, hy] = rot(t, s * HIP, 0), f = s \u003c 0 ? D.fl : D.fr;\n    leg(P, s, rx + hx, ry + hy, CX + s * (HIP + f[1]), FLOOR - 3 - f[0]);\n  }\n  const [b0, b1] = rot(t, 0, -5), sx = rx + b0, sy = ry + b1, [c0, c1] = rot(l, 0, -10);\n  bone(P, 7, sx + c0, sy + c1, sx, sy);\n  const [d0, d1] = rot(l, 0, -24), tx = sx + c0 + d0, ty = sy + c1 + d1;\n  at(P, 8, tx, ty, l);\n  for (const s of [-1, 1]) {\n    const [o0, o1] = rot(l, s * 12, 0.4), ax = tx + o0, ay = ty + o1, a1 = s \u003c 0 ? D.al : D.ar, a2 = s \u003c 0 ? D.bl : D.br;\n    const [u0, u1] = rot(l, s * sin(a1), cos(a1)), ex = ax + ARM * u0, ey = ay + ARM * u1;\n    const [v0, v1] = rot(l, s * sin(a1 + a2), cos(a1 + a2)), wx = ex + FORE * v0, wy = ey + FORE * v1;\n    bone(P, 9 + (s > 0), ax, ay, ex, ey);\n    bone(P, 11 + (s > 0), ex, ey, wx, wy);\n    at(P, 13 + (s > 0), wx, wy, ang(v0, v1));\n  }\n  const [n0, n1] = rot(l, 0, -4.4), hd = l + D.head, nx = tx + n0, ny = ty + n1;\n  at(P, SKULL, nx, ny, hd);\n  const [j0, j1] = rot(hd, 0, -0.7 + 2.2 * D.jaw + D.pitch * 0.6);\n  at(P, JAW, nx + j0, ny + j1, hd);\n  P.pitch = D.pitch;\n}\n\nconst REST = { sway: 0, bob: 0, tilt: 0, lean: 0, head: 0, pitch: 0, jaw: 0, al: 0.12, bl: 0.08, ar: 0.12, br: 0.08, fl: [0, 0], fr: [0, 0] };\nconst clack = (b) => max(0, sin(TAU * b)) ** 2;\n// Three dances, each a function of the beat.\nfunction dance(m, b, D) {\n  Object.assign(D, REST, { fl: [0, 0], fr: [0, 0], jaw: clack(b) });\n  if (m === 0) {\n    // Sway: hips side to side over four beats, both arms up waving.\n    const s = sin((PI * b) / 2), w = sin(PI * b);\n    Object.assign(D, { sway: 3 * s, tilt: 0.1 * s, lean: -0.08 * s, head: -0.16 * s, al: 2.5 + 0.18 * w, ar: 2.5 - 0.18 * w, bl: 0.3 + 0.25 * w, br: 0.3 + 0.25 * w });\n  } else if (m === 1) {\n    // Kicks: a foot out to the side each beat, hands on the hips.\n    const k = sin(PI * (b - floor(b))) ** 2, s = floor(b) & 1 ? 1 : -1;\n    D[s \u003c 0 ? \"fl\" : \"fr\"] = [7 * k, 5 * k];\n    Object.assign(D, { sway: -s * 1.2 * k, head: s * 0.12 * k, al: 0.75, ar: 0.75, bl: -1.45, br: -1.45 });\n  } else {\n    // Bounce: a dip at the knees on every beat, the arms pumping up in turn\n    // over two beats.\n    const e = 0.5 - 0.5 * cos(PI * b), w = sin(PI * b);\n    Object.assign(D, { bob: 0.6 - 0.6 * cos(TAU * b), sway: 1.5 * w, head: 0.14 * w, al: 0.5 + 1.2 * e, bl: 0.3 + 0.6 * e, ar: 1.7 - 1.2 * e, br: 0.9 - 0.6 * e });\n  }\n}\n\n// The heap, as [x, y, angle] for each piece with the floor at 120: shins\n// and feet flat, thighs crossed, arms on top, the cage on its side, the\n// pelvis tipped up against it and the skull on the crown, jaw beside it.\nconst HEAP = [\n  [-25, 117.5, 0.2], [24, 117.5, -0.3], [-14, 116.4, 1.62], [13, 116.4, 1.5], [-4, 115.6, 1.32], [6, 115.6, 1.86],\n  [-9, 108.5, 0.55], [12, 111.5, 1.9], [4, 104.5, -1.32], [-15, 112, 1.1], [17, 112.8, 2.1], [-20, 113.5, 1.9], [21, 114.8, 1.3],\n  [-27, 116.2, 2.4], [28, 116.4, -2.2], [15, 106.5, 0.45], [-2, 99.5, 0.3],\n];\nconst BEAM = (x, y) => {\n  // The spotlight's cone from above the panel, 18 LEDs across at the top\n  // and 56 at the floor.\n  const hw = 9 + y * 0.16, d = abs(x + 0.5 - CX) / hw;\n  return d \u003c 0.8 ? 1 : d \u003c 1 ? 0.78 : d \u003c 1.12 ? 0.4 : 0;\n};\n\nconst pose = () => ({ x: new Float64Array(NB), y: new Float64Array(NB), a: new Float64Array(NB), pitch: 0 });\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, bpm: 100, every: 4, fog: 0.06, beat: 0, t: 0,\n    phase: 0, start: 0, base: 0, moves: 0,\n    D: Object.assign({}, REST), Q: pose(), R: pose(),\n    fall: [], heap: [], eye: 0, snap: [], light: [0, 0, 0],\n    bg: new Float32Array(N * 3), buf: new Float32Array(N * 3), low: new Int16Array(W),\n    dust: Array.from({ length: 30 }, () => [CX + (Math.random() - 0.5) * 36, Math.random() * 120, Math.random() * TAU, 2 + Math.random() * 3]),\n  };\n  rig(REST, params.s.R);\n}\n\n// Everything comes down: each piece from where it is now, flung up a little,\n// falls onto its place in the heap and bounces once.\nfunction collapse(S) {\n  if (S.phase === 0 || !S.heap.length) {\n    const m = Math.random() \u003c 0.5 ? -1 : 1;\n    S.heap = HEAP.map(([x, y, a]) => [CX + m * x + (Math.random() - 0.5) * 2, y, m * a + (Math.random() - 0.5) * 0.3]);\n  }\n  S.fall = S.heap.map(([hx, hy, ha], i) => {\n    const x0 = S.Q.x[i], y0 = S.Q.y[i], a0 = S.Q.a[i], v = 4 + Math.random() * 10, g = 520;\n    const T = (v + sqrt(v * v + 2 * g * max(0, hy - y0))) / g;\n    let da = ha - a0;\n    da -= TAU * round(da / TAU);\n    return { x0, y0, a0, hx, hy, da, v, g, T };\n  });\n  S.Q.pitch = 0;\n  S.phase = 1;\n  S.start = S.beat;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.bpm = 50 * cl(k[1], 0.2, 3);\n  S.every = round(cl(k[2], 4, 32));\n  S.fog = cl(k[3], 0, 1);\n  const hue = cl(k[0], 0, 1);\n  if (hue !== S.hue) {\n    S.hue = hue;\n    hsv(0.76 + hue, 0.62, 1, S.light);\n    background(S);\n  }\n  const db = (d * S.bpm) / 60;\n  S.beat += db;\n  S.t += d;\n  const B = S.beat, Q = S.Q, D = S.D;\n  if (input.btnPressed && input.btnPressed[0] && S.phase !== 1) collapse(S);\n  S.snap = S.snap.filter((s) => (s[2] -= d) > 0);\n  if (S.phase === 0) {\n    // Dancing, eased in from standing after the skeleton gets up.\n    if (B >= S.base + S.every) {\n      collapse(S);\n    } else {\n      dance(S.moves % 3, B, D);\n      const w = cl((B - S.start) / 0.6, 0, 1), s = w * w * (3 - 2 * w);\n      for (const key in REST) if (typeof REST[key] === \"number\") D[key] = mix(REST[key], D[key], s);\n      for (const f of [\"fl\", \"fr\"]) D[f] = [D[f][0] * s, D[f][1] * s];\n      rig(D, Q);\n      S.eye = max(0, S.eye - db * 0.8);\n    }\n  }\n  if (S.phase === 1) {\n    const u = B - S.start;\n    S.fall.forEach((f, i) => {\n      const t = min(u, f.T), r = t / f.T, b = u - f.T;\n      Q.x[i] = mix(f.x0, f.hx, r);\n      Q.y[i] = min(f.hy, f.y0 - f.v * t + 0.5 * f.g * t * t);\n      Q.a[i] = f.a0 + f.da * r;\n      if (b > 0 && b \u003c 0.3) Q.y[i] -= 2 * sin((PI * b) / 0.3) * (1 - b / 0.3);\n    });\n    // The heap lies still, then the skull's eyes kindle.\n    S.eye = cl((u - 1.6) / 0.8, 0, 1);\n    if (u > 2.5) {\n      S.phase = 2;\n      S.start = B;\n    }\n  }\n  if (S.phase === 2) {\n    // One piece every 0.3 beats from the feet up, each on an arc 0.45 beats\n    // long; the jaw and the skull go together, last, in 0.8 beats.\n    const u = B - S.start, R = S.R;\n    for (let i = 0; i \u003c NB; i++) {\n      const slot = min(i, JAW), t0 = slot * 0.3, len = slot === JAW ? 0.8 : 0.45, r = (u - t0) / len, [hx, hy, ha] = S.heap[i];\n      if (r \u003c= 0) at(Q, i, hx, hy, ha);\n      else if (r >= 1) {\n        at(Q, i, R.x[i], R.y[i], R.a[i]);\n        if (r - db / len \u003c 1) S.snap.push([R.x[i], R.y[i] - (i === SKULL ? 2 : 0), 0.12]);\n      } else {\n        let da = R.a[i] - ha;\n        da -= TAU * round(da / TAU);\n        const lift = 10 + 0.15 * (hy - R.y[i]), e = 1 - (1 - r) * (1 - r);\n        at(Q, i, mix(hx, R.x[i], r), mix(hy, R.y[i], e) - lift * sin(PI * r) * (1 - r * 0.3), ha + da * e);\n      }\n    }\n    // The nod: the skull dips its face and the jaw shuts, 0.6 beats.\n    const n = (u - JAW * 0.3 - 0.8) / 0.6;\n    Q.pitch = n > 0 && n \u003c 1 ? sin(PI * n) : 0;\n    if (n > 0) {\n      Q.y[SKULL] += 2.5 * Q.pitch;\n      Q.y[JAW] += 3.2 * Q.pitch;\n    }\n    if (n >= 1) {\n      S.phase = 0;\n      S.start = B;\n      S.base = ceil(B);\n      S.moves++;\n    }\n  }\n  for (const m of S.dust) {\n    m[1] += d * m[3];\n    m[0] += d * 1.5 * sin(S.t * 0.7 + m[2]);\n    if (m[1] > FLOOR) (m[1] = 0), (m[0] = CX + (Math.random() - 0.5) * 34);\n  }\n}\n\n// The crypt, laid out once for each light colour: stone blocks with dark\n// mortar, the beam on the wall, a pool on the flagstones, two candle niches.\nconst NICHES = [8, 56], NY = 78;\nfunction background(S) {\n  const bg = S.bg, L = S.light;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let r, g, b, lit;\n      if (y \u003c FLOOR) {\n        const row = floor(y / 7), off = row & 1 ? 6 : 0, col = floor((x + off) / 12);\n        const mortar = y % 7 === 6 || (x + off) % 12 === 11, v = hash(row * 31 + col * 7) * 10;\n        (r = mortar ? 10 : 26 + v), (g = mortar ? 6 : 19 + v * 0.7), (b = mortar ? 16 : 36 + v);\n        lit = BEAM(x, y) * (mortar ? 0.12 : 0.24);\n        for (const nx of NICHES)\n          if (abs(x + 0.5 - nx) \u003c 3.5 && y > NY - 8 && y \u003c NY + 4 && (y > NY - 5 || (x + 0.5 - nx) ** 2 + (y - NY + 5) ** 2 \u003c 12)) (r = 8), (g = 4), (b = 12), (lit = 0);\n      } else {\n        // Flagstones, and the pool where the beam lands.\n        const seam = y === FLOOR + 3 || (x + (y > FLOOR + 3 ? 5 : 0)) % 14 === 0;\n        (r = seam ? 12 : 30), (g = seam ? 8 : 22), (b = seam ? 18 : 36);\n        if (y === FLOOR) (r = 60), (g = 48), (b = 70);\n        const q = ((x + 0.5 - CX) / 30) ** 2 + ((y - FLOOR - 3) / 6) ** 2;\n        lit = (q \u003c 0.45 ? 0.62 : q \u003c 1 ? 0.42 : q \u003c 1.5 ? 0.18 : 0) * (seam ? 0.5 : 1);\n      }\n      bg[o] = r + L[0] * lit;\n      bg[o + 1] = g + L[1] * lit;\n      bg[o + 2] = b + L[2] * lit;\n    }\n}\n\n// Ivory in the light, a warmer grey across, the shade tinted by the beam.\nconst BONE = [[255, 244, 220], [212, 202, 180], [96, 88, 80]];\nconst put = (buf, o, r, g, b) => {\n  buf[o] = r;\n  buf[o + 1] = g;\n  buf[o + 2] = b;\n};\n// One piece onto the buffer: its distance field over its bounds, lit from\n// above by the field's slope, outlined dark where it passes over anything.\nconst FIELD = new Float32Array(48 * 48);\nfunction piece(S, i, P) {\n  const [k, sg, x0, x1, y0, y1] = PIECES[i], cx = P.x[i], cy = P.y[i], a = P.a[i], c = cos(a), s = sin(a);\n  let xa = 1e9, xb = -1e9, ya = 1e9, yb = -1e9;\n  for (const [u, v] of [[x0, y0], [x1, y0], [x0, y1], [x1, y1]]) {\n    const wx = cx + u * c - v * s, wy = cy + u * s + v * c;\n    (xa = min(xa, wx)), (xb = max(xb, wx)), (ya = min(ya, wy)), (yb = max(yb, wy));\n  }\n  xa = max(0, floor(xa) - 1);\n  xb = min(W - 1, ceil(xb) + 1);\n  ya = max(0, floor(ya) - 1);\n  yb = min(H - 1, ceil(yb) + 1);\n  const buf = S.buf, L = S.light;\n  if (xb \u003c xa || yb \u003c ya || xb - xa >= 48 || yb - ya >= 48) return;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy;\n      FIELD[(y - ya) * 48 + x - xa] = shape(k, dx * c + dy * s, -dx * s + dy * c, sg);\n    }\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const f = (y - ya) * 48 + x - xa, d = FIELD[f], o = (y * W + x) * 3;\n      if (d > 0.1) {\n        if (d \u003c 1.1) for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] *= 0.3;\n        continue;\n      }\n      if (y > 60 && y > S.low[x]) S.low[x] = y;\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, hl = hole(k, dx * c + dy * s, -dx * s + dy * c, P);\n      if (hl === 1 || hl === 2) {\n        const e = hl === 2 ? S.eye * (0.75 + 0.25 * sin(S.t * 9 + i)) : 0;\n        put(buf, o, 12 + L[0] * e, 6 + L[1] * e, 18 + L[2] * e);\n        continue;\n      }\n      // The slope of the field: where it climbs upward the bone faces the light.\n      const up = y > ya ? FIELD[f - 48] : d + 1, dn = y \u003c yb ? FIELD[f + 48] : d + 1, n = (up - dn) / (abs(up - dn) + abs((x > xa ? FIELD[f - 1] : d) - (x \u003c xb ? FIELD[f + 1] : d)) + 0.01);\n      const t = hl === 3 || n \u003c= -0.3 ? 2 : n > 0.4 || (d > -0.6 && up > 0.1) ? 0 : 1, beam = 0.72 + 0.28 * BEAM(x, y), w = t === 2 ? 0.36 : 0;\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = (BONE[t][ch] + L[ch] * w) * beam;\n    }\n}\n\nfunction add(buf, x, y, r, g, b) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += r;\n  buf[o + 1] += g;\n  buf[o + 2] += b;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.hue \u003c 0) return;\n  const buf = S.buf, L = S.light, low = S.low;\n  buf.set(S.bg);\n  // Candles in the niches: a flame that flickers in three steps and a glow.\n  NICHES.forEach((nx, j) => {\n    const v = 0.55 + 0.3 * vn(S.t * 3, j * 9) + 0.15 * vn(S.t * 11, j * 9 + 4), f = v > 0.72 ? 1 : v > 0.55 ? 0.82 : 0.66;\n    for (let y = NY - 12; y \u003c NY + 8; y++)\n      for (let x = nx - 8; x \u003c nx + 8; x++) {\n        const q = sqrt((x + 0.5 - nx) ** 2 + (y + 0.5 - NY + 2) ** 2), gl = (q \u003c 3.5 ? 0.24 : q \u003c 5.5 ? 0.14 : q \u003c 8 ? 0.06 : 0) * f;\n        if (gl) add(buf, x, y, 255 * gl, 140 * gl, 40 * gl);\n      }\n    for (let y = NY; y \u003c NY + 4; y++) put(buf, (y * W + nx - 1) * 3, 196, 184, 160), put(buf, (y * W + nx) * 3, 196, 184, 160);\n    const sw = round(vn(S.t * 5, j) * 2 - 1);\n    for (let i = 0; i \u003c (f > 0.9 ? 4 : 3); i++) {\n      const o = ((NY - 1 - i) * W + nx - 1 + (i > 1 ? sw : 0)) * 3, g = i ? 150 + 30 * f : 236, b = i ? 30 : 140;\n      put(buf, o, 255, g, b);\n      if (i \u003c 2) put(buf, o + 3, 255, g * 0.92, b);\n    }\n  });\n  // Dust drifting down the beam.\n  for (const [x, y, p] of S.dust) {\n    const tw = 0.45 + 0.35 * sin(S.t * 2.3 + p * 5);\n    if (BEAM(x, y) > 0.5) add(buf, x, y, (L[0] * 0.5 + 60) * tw, (L[1] * 0.5 + 60) * tw, (L[2] * 0.5 + 60) * tw);\n  }\n  // Bones; a shadow on the floor under whatever stands or lies over it.\n  low.fill(0);\n  // Pieces in the air go in front of the rest.\n  const u = S.beat - S.start, air = (i) => S.phase === 2 && u > min(i, JAW) * 0.3 && u \u003c min(i, JAW) * 0.3 + 0.9;\n  for (let pass = 0; pass \u003c 2; pass++) for (let i = 0; i \u003c NB; i++) if (air(i) === !!pass) piece(S, i, S.Q);\n  for (let x = 0; x \u003c W; x++)\n    if (low[x] > 0) {\n      const sh = low[x] > FLOOR - 8 ? 0.45 : 0.65;\n      for (let y = low[x] + 1; y \u003c min(H, FLOOR + 5); y++) if (y >= FLOOR) for (let ch = 0; ch \u003c 3; ch++) buf[(y * W + x) * 3 + ch] *= sh;\n    }\n  for (const [x, y, t] of S.snap) for (const [i, j] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) add(buf, x + i, y + j, 200 * t * 8, 190 * t * 8, 170 * t * 8);\n  // Ground fog: two drifting noises, deeper toward the floor, in steps of an eighth.\n  const fog = S.fog, top = 118 - 50 * fog;\n  for (let y = max(0, floor(top)); y \u003c H && fog > 0; y++) {\n    const depth = cl((y - top) / 16, 0, 1) * (0.25 + 0.5 * fog);\n    for (let x = 0; x \u003c W; x++) {\n      const n = 0.6 * vn(x * 0.09 + S.t * 0.35 + y * 0.03, 3 + (y >> 3)) + 0.4 * vn(x * 0.21 - S.t * 0.5, 17 + (y >> 2));\n      const al = floor(depth * (0.35 + 0.9 * n) * 8) / 8;\n      if (al \u003c= 0) continue;\n      const o = (y * W + x) * 3, a = min(0.85, al);\n      for (let ch = 0; ch \u003c 3; ch++) buf[o + ch] = mix(buf[o + ch], 70 + L[ch] * 0.32, a);\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) & 252, min(255, buf[o + 1]) & 252, min(255, buf[o + 2]) & 252);\n}\n","chebyshev-bias":"// ===== Patternflow pattern =====\n// Title:   Chebyshev's Bias\n// Family:  number\n// Idea:    The panel's height is the number line from 32 at the bottom to 2^21 at the top on a log scale and its 64 columns are 64 prime races counted by the pattern's own sieve; a white front climbs and paints each LED blue where the side Chebyshev expected leads, brighter the larger its lead in Rubinstein and Sarnak's units, and orange where the other side leads, so the field fills with the bias and the rare orange specks stand out, the first for 1 mod 4 over 3 mod 4 at 26,861, each long-awaited one sending a ring across the panel as the front passes it.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Chebyshev's bias (Pafnuty Chebyshev, 1853), with Rubinstein and Sarnak's logarithmic density (1994), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Races=0..2, Margin=0..1\n//\n// Knob 1: Hue. Turns the three colours round the wheel together. At 0 the leading side is blue, the specks where the other side leads orange and the close calls violet; at 0.25 magenta, green and orange; at 0.5 orange, azure and green, the orange paled so the weak leads do not read brown; at 0.75 green, magenta and azure.\n// Knob 2: Speed. The front climbs 6.4 rows a second for each unit, 12.8 at 2, so x doubles every 0.63 s: it passes 26,861 at 6.1 s and 616,841 at 8.9 s and reaches 2^21 at 10 s, the field holds 2.5 s and dims back to the ghost of itself over 1.2 s, and the front starts again from 32. At 0.2 all ten times slower, a climb of 100 s; at 3 a climb of 6.7 s.\n// Knob 3: Races. Which 64 races, the columns ordered by the mean lead the theory expects, largest at the left. At 0 the quadratic non-residues against the residues for every modulus from 3 to 66, each side averaged over its classes: first the five where 1 has eight square roots (24, 40, 48, 56, 60), brightest and never led by the other side, then the 24 with four, of which only 7 are ever led, then the 35 with two, from 3 and 4 on, where the orange gathers and 43 has the other side ahead on 42% of the line. At 1 the class -1 against the class 1 for the same moduli: where -1 is not a square it leans like the race at 0, and the 15 moduli at the right where it is one (5, 10, 13, 17, 25 and on) are fair races, barcodes of blue and orange. At 2 non-residues against residues for the 64 odd primes from 3 to 313 in order: the orange thickens as the modulus grows, in 16% of the rows of the first sixteen columns and a third of those of the last thirty-two. A new choice is counted in under a second.\n// Knob 4: Margin. How near a tie a lead must come to show as a close call in violet, in Rubinstein and Sarnak's units where the mod 4 lead averages 1: 0 at 0, 0.12 at the opening 0.06, 0.5 at a quarter, 1 at half, where most of the races with two square roots of 1 have turned violet, and 2 at 1, where only the five with eight keep much blue.\n// Buttons: K1 tap starts the climb again from 32.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sqrt, log, exp, sin, cos, abs, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The number line: row r from the bottom covers x in [B[r], B[r + 1]), eight\n// rows to each doubling, from 32 to 32 * 2^16 = 2^21 = 2,097,152.\nconst RPD = 8, X0 = 32, X1 = 1 \u003c\u003c 21;\nconst B = new Float64Array(H + 1);\nfor (let r = 0; r \u003c= H; r++) B[r] = round(X0 * 2 ** (r / RPD));\n// Rubinstein and Sarnak's normaliser log x / sqrt x at each row's middle.\nconst NRM = new Float64Array(H);\nfor (let r = 0; r \u003c H; r++) {\n  const xm = X0 * 2 ** ((r + 0.5) / RPD);\n  NRM[r] = log(xm) / sqrt(xm);\n}\n\n// The pattern's own sieve of Eratosthenes up to 2^21, once, on the odd\n// numbers only: SV[k] marks 2k + 1 composite. 155,611 primes.\nconst SV = new Uint8Array((X1 >> 1) + 1);\nfor (let i = 3; i * i \u003c= X1; i += 2) if (!SV[i >> 1]) for (let j = (i * i) >> 1; j \u003c= X1 >> 1; j += i) SV[j] = 1;\nconst PT = new Int32Array(160000);\nlet NP = 1;\nPT[0] = 2;\nfor (let k = 1; 2 * k + 1 \u003c X1; k++) if (!SV[k]) PT[NP++] = 2 * k + 1;\nconst PR = PT.subarray(0, NP);\n\nconst gcd = (a, b) => {\n  while (b) [a, b] = [b, a % b];\n  return a;\n};\n// A race mod q: a weight for each class, plus for the side expected to lead\n// and minus for the other, so D = sum of weights over primes \u003c= x is the\n// race. K turns D into the lead L = K D log x / sqrt x, scaled so that L\n// averages s / 2 when s is the number of square roots of 1 mod q: 1 for\n// 3 mod 4 against 1 mod 4, as in Rubinstein and Sarnak.\nfunction raceNR(q) {\n  const T = new Int32Array(q), sq = new Uint8Array(q);\n  let phi = 0, nr = 0, s = 0;\n  for (let a = 1; a \u003c q; a++)\n    if (gcd(a, q) === 1) {\n      phi++;\n      sq[(a * a) % q] = 1;\n      if ((a * a) % q === 1) s++;\n    }\n  for (let a = 1; a \u003c q; a++) if (gcd(a, q) === 1 && sq[a]) nr++;\n  const nn = phi - nr;\n  // Weights |R| for a non-residue, -|N| for a residue: the race of the two\n  // sides' averages per class.\n  for (let a = 1; a \u003c q; a++) if (gcd(a, q) === 1) T[a] = sq[a] ? -nn : nr;\n  return { q, T, K: phi / (2 * nn * nr), s, mean: s / 2 };\n}\n// The class q - 1 (that is -1) against the class 1: biased like the race\n// above when -1 is not a square mod q, fair when it is.\nfunction racePair(q) {\n  const T = new Int32Array(q), r = raceNR(q);\n  let phi = 0;\n  for (let a = 1; a \u003c q; a++) if (gcd(a, q) === 1) phi++;\n  T[q - 1] = 1;\n  T[1] = -1;\n  return { q, T, K: phi / 2, s: r.s, mean: r.T[q - 1] > 0 ? r.s / 2 : 0 };\n}\n// Columns left to right by the mean lead the theory expects, largest\n// first, then by modulus.\nconst order = (a, b) => b.mean - a.mean || a.q - b.q;\nconst ODD = [];\nfor (let k = 1; ODD.length \u003c W; k++) ODD.push(PR[k]);\nconst FAMS = [\n  Array.from({ length: W }, (_, c) => raceNR(c + 3)).sort(order),\n  Array.from({ length: W }, (_, c) => racePair(c + 3)).sort(order),\n  ODD.map(raceNR),\n];\n\n// Hues at knob 0: the leading side blue, the other side's specks orange,\n// close calls violet.\nconst HUE_LEAD = 0.6, HUE_SPECK = 0.085, HUE_CLOSE = 0.8;\n// Front speed in rows a second for each unit of Speed; the hold at the top\n// and the fade back to the ghost, in seconds at Speed 2. Above the front the\n// last count shows at GHOST of its brightness.\nconst RATE = 6.4, HOLD = 2.5, FADE = 1.2, GHOST = 0.3;\n// Primes the count takes each frame: 26 frames for the whole count.\nconst STEPS = 6000;\n// A ring goes out when the other side takes the lead after the expected\n// side has held it for RING rows, x grown 16 times over.\nconst RING = 32;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// One count of a family's 64 races from 2 to 2^21. Per LED, row-major from\n// the bottom row: the share of the row's x where the other side led, the\n// share tied, the mean lead and the least lead; and every time the other\n// side took the lead, with how many rows the expected side had held it.\n// The classes' weights sit in one table, column c's from OFF[c].\nfunction newCount(f) {\n  const races = FAMS[f], OFF = new Int32Array(W);\n  let n = 0;\n  for (let c = 0; c \u003c W; c++) (OFF[c] = n), (n += races[c].q);\n  const TT = new Int32Array(n);\n  for (let c = 0; c \u003c W; c++) TT.set(races[c].T, OFF[c]);\n  const C = {\n    Q: Int32Array.from(races, (r) => r.q), KK: Float64Array.from(races, (r) => r.K), OFF, TT,\n    D: new Int32Array(W), pos: X0, pi: 0, row: 0,\n    neg: new Float64Array(W), tie: new Float64Array(W), sum: new Float64Array(W), mn: new Int32Array(W),\n    lastNeg: new Int16Array(W).fill(-1),\n    NEG: new Float32Array(W * H), TIE: new Float32Array(W * H), ML: new Float32Array(W * H), MINL: new Float32Array(W * H),\n    ev: [],\n  };\n  // The primes below 32 are in before the first row opens.\n  for (; PR[C.pi] \u003c X0; C.pi++) for (let c = 0; c \u003c W; c++) C.D[c] += TT[OFF[c] + (PR[C.pi] % C.Q[c])];\n  openRow(C);\n  return C;\n}\n\nfunction openRow(C) {\n  C.neg.fill(0);\n  C.tie.fill(0);\n  C.sum.fill(0);\n  C.mn.set(C.D);\n}\n\n// Between two primes the race stands still, so each stretch to the next\n// prime or row boundary is added to the row's tallies whole.\nfunction tally(C, len) {\n  const { D, neg, tie, sum } = C;\n  for (let c = 0; c \u003c W; c++) {\n    const d = D[c];\n    if (d \u003c 0) neg[c] += len;\n    else if (d === 0) tie[c] += len;\n    sum[c] += d * len;\n  }\n}\n\nfunction closeRow(C) {\n  const r = C.row, len = B[r + 1] - B[r];\n  for (let c = 0, o = r * W; c \u003c W; c++, o++) {\n    const k = C.KK[c] * NRM[r];\n    C.NEG[o] = C.neg[c] / len;\n    C.TIE[o] = C.tie[c] / len;\n    C.ML[o] = (k * C.sum[c]) / len;\n    C.MINL[o] = k * C.mn[c];\n    if (C.neg[c] > 0) C.lastNeg[c] = r;\n  }\n  C.row++;\n  openRow(C);\n}\n\n// Runs the count on by at most n primes: the whole count is 155,611\n// primes and 128 rows, about 10 million small steps for the 64 races.\nfunction step(C, n) {\n  const { D, Q, OFF, TT, neg, tie, sum, mn } = C;\n  while (C.row \u003c H && n-- > 0) {\n    const p = C.pi \u003c NP ? PR[C.pi] : X1 + 1, b = B[C.row + 1];\n    // A prime on a row boundary belongs to the row above.\n    if (b \u003c= p) {\n      tally(C, b - C.pos);\n      C.pos = b;\n      closeRow(C);\n      continue;\n    }\n    const len = p - C.pos;\n    for (let c = 0; c \u003c W; c++) {\n      const d = D[c];\n      if (d \u003c 0) neg[c] += len;\n      else if (d === 0) tie[c] += len;\n      sum[c] += d * len;\n      const w = TT[OFF[c] + (p % Q[c])];\n      if (!w) continue;\n      const e = d + w;\n      D[c] = e;\n      if (e \u003c mn[c]) mn[c] = e;\n      if (d >= 0 && e \u003c 0) {\n        C.ev.push({ c, x: p, run: C.row - C.lastNeg[c] });\n        C.lastNeg[c] = C.row;\n      }\n    }\n    C.pos = p;\n    C.pi++;\n  }\n}\n\n// The front's height for x, in rows from the bottom.\nconst rowOf = (x) => RPD * Math.log2(x / X0);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, fam: -1, margin: 0.12, cnt: [null, null, null], C: null,\n    F: 0, phase: 0, timer: 0, alpha: 1, t: 0, next: 0, skip: 0,\n    bursts: [], buf: new Float32Array(W * H * 3), col: new Float32Array(12), lut: new Float32Array(99),\n  };\n}\n\nfunction replay(S) {\n  S.F = 0;\n  S.skip = 0;\n  S.phase = 0;\n  S.alpha = 1;\n  S.next = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.margin = 2 * cl(kv[3], 0, 1);\n  const f = round(cl(kv[2], 0, 2));\n  if (f !== S.fam) {\n    // Each family is counted once, the first time it is asked for.\n    S.fam = f;\n    S.C = S.cnt[f] || (S.cnt[f] = newCount(f));\n    S.bursts.length = 0;\n    S.next = 0;\n    // A count already done has its lead changes below the front passed;\n    // a new one finds them as it goes, and they pass without a ring.\n    while (S.next \u003c S.C.ev.length && rowOf(S.C.ev[S.next].x) \u003c S.F) S.next++;\n    S.skip = S.F;\n  }\n  // The count runs ahead of the front, done in under a second.\n  step(S.C, STEPS);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  if (input.btnPressed && input.btnPressed[0]) replay(S);\n  if (S.phase === 0) {\n    S.F = min(H, S.F + d * RATE * S.speed);\n    // The lead changes the front has just passed.\n    const ev = S.C.ev;\n    while (S.next \u003c ev.length && rowOf(ev[S.next].x) \u003c S.F) {\n      const e = ev[S.next++];\n      // A flip back and forth inside one lead change is not a new one.\n      if (e.run \u003c 3 || (e.run \u003c RING && S.bursts.length > 12) || rowOf(e.x) \u003c S.skip) continue;\n      S.bursts.push({ c: e.c, r: floor(rowOf(e.x)), t: 0, run: e.run });\n    }\n    if (S.F >= H) (S.phase = 1), (S.timer = HOLD);\n  } else if (S.phase === 1) {\n    if ((S.timer -= ds) \u003c 0) (S.phase = 2), (S.timer = FADE);\n  } else {\n    S.timer -= ds;\n    S.alpha = max(0, S.timer / FADE);\n    if (S.timer \u003c 0) replay(S);\n  }\n  for (const b of S.bursts) b.t += ds;\n  S.bursts = S.bursts.filter((b) => b.t \u003c 1.6);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.C) return;\n  const buf = S.buf, K = S.col, Cn = S.C, m = S.margin, F = S.F;\n  buf.fill(0);\n  hsv(HUE_SPECK + S.hue, 0.78, 1, K, 0);\n  hsv(HUE_CLOSE + S.hue, 0.55, 0.78, K, 3);\n  // The lead side in 33 steps of u = 1 - exp(-L / 1.6), brighter and paler\n  // the larger the mean lead L. Turned to orange or yellow it starts paler\n  // and brighter, or the weak leads would read brown.\n  const lut = S.lut, hl = HUE_LEAD + S.hue, wf = max(0, cos(2 * PI * (hl - 0.1))) ** 3;\n  for (let i = 0; i \u003c= 32; i++) {\n    const u = i / 32;\n    hsv(hl, 0.92 - 0.3 * u * u - 0.45 * wf, 0.2 + 0.55 * wf + (0.68 - 0.4 * wf) * u, lut, i * 3);\n  }\n  for (let r = 0; r \u003c Cn.row; r++) {\n    const y = H - 1 - r;\n    // Painted below the front, the ghost above it; freshly painted rows\n    // glow white for a moment under the front.\n    const lit = r \u003c F ? GHOST + (1 - GHOST) * S.alpha : GHOST;\n    const gl = S.phase === 0 && r \u003c F ? exp(-(F - r - 1) / 1.6) * 0.55 : 0;\n    for (let c = 0; c \u003c W; c++) {\n      const o = r * W + c, q = (y * W + c) * 3;\n      let R, G, Bl;\n      if (Cn.NEG[o] > 0) {\n        // The other side led here: a speck that never dims below 0.8.\n        const v = (0.8 + 0.2 * sqrt(Cn.NEG[o])) * (0.88 + 0.12 * sin(S.t * 3 + c * 1.7 + r * 0.9));\n        (R = K[0] * v), (G = K[1] * v), (Bl = K[2] * v);\n      } else if (Cn.TIE[o] >= 1) {\n        // Tied all along the row: neither leads.\n        (R = 0.24), (G = 0.24), (Bl = 0.28);\n      } else if (Cn.MINL[o] \u003c m) {\n        (R = K[3]), (G = K[4]), (Bl = K[5]);\n      } else {\n        const i = round(32 * (1 - exp(-max(0, Cn.ML[o]) / 1.6))) * 3;\n        (R = lut[i]), (G = lut[i + 1]), (Bl = lut[i + 2]);\n      }\n      if (gl > 0.01) (R += (1 - R) * gl), (G += (1 - G) * gl), (Bl += (1 - Bl) * gl);\n      buf[q] = R * lit;\n      buf[q + 1] = G * lit;\n      buf[q + 2] = Bl * lit;\n    }\n  }\n  // The front: a white row tinted by who leads there.\n  if (S.phase === 0 && F \u003c H) {\n    const r = floor(F), y = H - 1 - r;\n    hsv(HUE_LEAD + S.hue, 0.5, 1, K, 9);\n    for (let c = 0; c \u003c W; c++) {\n      const q = (y * W + c) * 3, k = Cn.NEG[r * W + c] > 0 ? 0 : 9;\n      buf[q] = 0.5 + 0.5 * K[k];\n      buf[q + 1] = 0.5 + 0.5 * K[k + 1];\n      buf[q + 2] = 0.5 + 0.5 * K[k + 2];\n    }\n  }\n  // Each new lead change flashes white; a long-awaited one sends out a ring\n  // in the specks' colour, the wider the longer the wait.\n  for (const b of S.bursts) {\n    const cx = b.c + 0.5, cy = H - 1 - b.r + 0.5;\n    if (b.t \u003c 0.35) {\n      const q = ((H - 1 - b.r) * W + b.c) * 3;\n      buf[q] = buf[q + 1] = buf[q + 2] = 1;\n    }\n    if (b.run \u003c RING) continue;\n    const big = min(1, (b.run - RING + 8) / 40), rad = 1 + b.t * (6 + 12 * big), f = (0.4 + 0.6 * big) * (1 - b.t / 1.6);\n    const y0 = max(0, floor(cy - rad - 1)), y1 = min(H - 1, floor(cy + rad + 1));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = max(0, floor(cx - rad - 1)); x \u003c= min(W - 1, floor(cx + rad + 1)); x++) {\n        const dd = abs(sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2) - rad);\n        if (dd >= 1.2) continue;\n        const q = (y * W + x) * 3, w = f * (1 - dd / 1.2);\n        buf[q] += (K[0] - buf[q]) * w;\n        buf[q + 1] += (K[1] - buf[q + 1]) * w;\n        buf[q + 2] += (K[2] - buf[q + 2]) * w;\n      }\n  }\n  for (let p = 0, q = 0; p \u003c W * H; p++, q += 3) {\n    const r = buf[q], g = buf[q + 1], b = buf[q + 2];\n    if (r + g + b \u003c 0.02) continue;\n    // Each channel in steps of 4 of 255.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(r * 63.75) * 4), min(255, round(g * 63.75) * 4), min(255, round(b * 63.75) * 4));\n  }\n}\n","double-gyre":"// ===== Patternflow pattern =====\n// Title:   Double Gyre\n// Family:  noise\n// Idea:    Two counter-rotating cells of fluid stand one above the other while the line between them sways up and down, and each LED lights by how hard the fluid round it is torn apart over the next twenty units of flow time in amber and over the last twenty in azure, so the thin ridges that fluid never crosses wind round both cells, fold into tongues across the middle and stand the picture on its head every half turn of the forcing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lagrangian coherent structures as ridges of the finite-time Lyapunov exponent in the double gyre (Shawn Shadden, Francois Lekien and Jerrold Marsden, 2005), drawn by composing short flow maps (Steven Brunton and Clarence Rowley, 2010), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Horizon=-1..1, Epsilon=0..1\n//\n// Knob 1: Hue. Turns both colours round the wheel together, half a wheel apart. At 0 the forward ridges, which push fluid apart, are amber and the backward ones, which draw it together, azure. Where they cross they add to white. At 0.25 green and magenta, at 0.5 azure and amber, at 0.75 magenta and green.\n// Knob 2: Speed. The starting time of the fields moves half a unit of flow time a second for each unit: 1 at the opening 2, so the forcing goes round once in 10 s and the picture stands on its head every 5 s; 0.1 at 0.2, a period in 100 s, and 1.5 at 3, a period in 6.7 s.\n// Knob 3: Horizon. How long the fluid is followed, 20 units of flow time times 2 to the knob, to the nearest 2: 10 at -1, one period of the forcing, a few soft ridges round the cells and one across the middle; 14 at -0.5; 20 at the opening 0, two periods, the ridges folded into bundles of thin lines; 28 at 0.5 and 40 at 1, where the folds crowd closer than an LED and the chaotic sea round the cells turns to grain round two dark islands.\n// Knob 4: Epsilon. How far the line between the cells sways, epsilon = 0.5 ln(1 + 1000 k) / ln 1001: 0 at 0, steady cells, where at a horizon of 10 the only ridges are the dividing line and the walls, white with the forward and backward ones lying on each other, and longer horizons add rings of shear round each cell; 0.17 at 0.01; 0.30 at the opening 0.06, where the line swings 18 LEDs either way of the middle; 0.40 at a quarter, 0.45 at half and 0.50 at 1, 26 LEDs either way.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sqrt, log, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The flow, on [0,2] x [0,1]: psi = A sin(pi f) sin(pi y), with\n// f = a x^2 + b x, a = eps sin(OM t), b = 1 - 2a. The panel stands the\n// box up: row py is x = (py + 0.5) / 64, column px is y = (px + 0.5) / 64.\nconst A = 0.1, OM = (2 * PI) / 10, PER = 10, PA = PI * A;\n// sin(pi u) from a table over one turn, for u above -4.\nconst TN = 2048, TH = TN / 2, ST = new Float64Array(TN + 1);\nfor (let i = 0; i \u003c= TN; i++) ST[i] = sin((2 * PI * i) / TN);\nconst sinpi = (u) => {\n  const w = (u + 4) * TH, i = w | 0, j = i & (TN - 1);\n  return ST[j] + (ST[j + 1] - ST[j]) * (w - i);\n};\n\n// The velocity at (x, y) when a = s, into VU, VV.\nlet VU = 0, VV = 0;\nfunction vel(x, y, s) {\n  const b = 1 - 2 * s, f = s * x * x + b * x, sy = sinpi(y), cy = sinpi(y + 0.5);\n  VU = -PA * sinpi(f) * cy;\n  VV = PA * sinpi(f + 0.5) * sy * (2 * s * x + b);\n}\n\n// Short flow maps on a grid of nodes 1/64 apart, Brunton and Rowley's way:\n// a drop is carried by looking up where the node grid round it goes, and\n// a long flight is a chain of lookups. The quarter-unit maps that start at\n// each of the 40 quarter units of a period are one RK4 step each; maps of\n// a half, one and two units are each two of the level below.\nconst G = 0.25, NP = PER / G, NX = 129, NY = 65, NN = NX * NY, STEP = 8;\nfunction buildMaps(eps) {\n  let lv = [];\n  for (let k = 0; k \u003c NP / 2; k++) {\n    const m = new Float32Array(NN * 2), t = k * G;\n    const s0 = eps * sin(OM * t), s1 = eps * sin(OM * (t + G / 2)), s2 = eps * sin(OM * (t + G));\n    for (let n = 0, j = 0; j \u003c NX; j++)\n      for (let i = 0; i \u003c NY; i++, n += 2) {\n        const x = j / 64, y = i / 64;\n        vel(x, y, s0);\n        const k1u = VU, k1v = VV;\n        vel(x + 0.5 * G * k1u, y + 0.5 * G * k1v, s1);\n        const k2u = VU, k2v = VV;\n        vel(x + 0.5 * G * k2u, y + 0.5 * G * k2v, s1);\n        const k3u = VU, k3v = VV;\n        vel(x + G * k3u, y + G * k3v, s2);\n        m[n] = cl(x + (G / 6) * (k1u + 2 * k2u + 2 * k3u + VU), 0, 2);\n        m[n + 1] = cl(y + (G / 6) * (k1v + 2 * k2v + 2 * k3v + VV), 0, 1);\n      }\n    lv.push(m);\n  }\n  // Half a period on, the flow is the same turned upside down: psi(2 - x,\n  // y, t + 5) = -psi(x, y, t). So the maps of the second half are those of\n  // the first mirrored, node for node, at every length.\n  const mirror = () => {\n    for (let k = 0; k \u003c NP / 2; k++) {\n      const a = lv[k], m = new Float32Array(NN * 2);\n      for (let j = 0; j \u003c NX; j++)\n        for (let i = 0; i \u003c NY; i++) {\n          const n = (j * NY + i) * 2, q = ((NX - 1 - j) * NY + i) * 2;\n          m[n] = 2 - a[q];\n          m[n + 1] = a[q + 1];\n        }\n      lv[k + NP / 2] = m;\n    }\n  };\n  mirror();\n  // Doubling: a map of 2L is the map of L from where the first L ends.\n  for (let L = 1; L \u003c STEP; L *= 2) {\n    const up = [];\n    for (let k = 0; k \u003c NP / 2; k++) {\n      const a = lv[k], m = new Float32Array(NN * 2);\n      chain(a, lv[(k + L) % NP], m, NN);\n      up.push(m);\n    }\n    lv = up;\n    mirror();\n  }\n  return lv;\n}\n// Bilinear lookup of map b at each point of a, into out.\nfunction chain(a, b, out, n2) {\n  for (let n = 0; n \u003c n2 * 2; n += 2) {\n    let u = a[n] * 64, v = a[n + 1] * 64;\n    if (u > 127.9999) u = 127.9999;\n    if (v > 63.9999) v = 63.9999;\n    const j = u | 0, i = v | 0, fu = u - j, fv = v - i, q = (j * NY + i) * 2, e = q + 2 * NY;\n    const x0 = b[q] + (b[q + 2] - b[q]) * fv, x1 = b[e] + (b[e + 2] - b[e]) * fv;\n    const y0 = b[q + 1] + (b[q + 3] - b[q + 1]) * fv, y1 = b[e + 1] + (b[e + 3] - b[e + 1]) * fv;\n    out[n] = x0 + (x1 - x0) * fu;\n    out[n + 1] = y0 + (y1 - y0) * fu;\n  }\n}\n\n// The forward field for the node time k G: each LED's drop carried T units\n// on through a chain of two-unit maps, rows r0..r1 of it.\nfunction carry(S, J, r0, r1) {\n  const { X, Y } = J, nm = S.T / 2;\n  // Every drop of the band goes through the same maps in the same order, so\n  // the band is carried map by map.\n  for (let p = r0 * W; p \u003c r1 * W; p++) {\n    X[p] = (floor(p / W) + 0.5) / 64;\n    Y[p] = ((p % W) + 0.5) / 64;\n  }\n  for (let q = 0, k = J.k; q \u003c nm; q++, k = (k + STEP) % NP) {\n    const b = S.maps[k];\n    for (let p = r0 * W; p \u003c r1 * W; p++) {\n      let u = X[p] * 64, v = Y[p] * 64;\n      if (u > 127.9999) u = 127.9999;\n      if (v > 63.9999) v = 63.9999;\n      const j = u | 0, i = v | 0, fu = u - j, fv = v - i, n = (j * NY + i) * 2, e = n + 2 * NY;\n      const x0 = b[n] + (b[n + 2] - b[n]) * fv, x1 = b[e] + (b[e + 2] - b[e]) * fv;\n      const y0 = b[n + 1] + (b[n + 3] - b[n + 1]) * fv, y1 = b[e + 1] + (b[e + 3] - b[e + 1]) * fv;\n      X[p] = x0 + (x1 - x0) * fu;\n      Y[p] = y0 + (y1 - y0) * fu;\n    }\n  }\n}\n\n// From the flow map to the picture: the log of the largest stretch of the\n// Cauchy-Green tensor by central differences (sigma is this over T), then\n// each LED pushed away from the mean of the nine round it, so thin ridges\n// stand out of the broad glow round them.\nconst SHARP = 5;\nfunction finish(J) {\n  const { X, Y, L } = J, d = 1 / 64, out = new Float32Array(N);\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      const p = py * W + px, u = py > 0 ? p - W : p, dn = py \u003c H - 1 ? p + W : p, l = px > 0 ? p - 1 : p, r = px \u003c W - 1 ? p + 1 : p;\n      const hx = ((dn - u) / W) * d, hy = (r - l) * d;\n      const a = (X[dn] - X[u]) / hx, b = (X[r] - X[l]) / hy, c = (Y[dn] - Y[u]) / hx, e = (Y[r] - Y[l]) / hy;\n      const c11 = a * a + c * c, c12 = a * b + c * e, c22 = b * b + e * e, m = 0.5 * (c11 + c22);\n      L[p] = 0.5 * log(max(1e-9, m + sqrt(max(0, m * m - (c11 * c22 - c12 * c12)))));\n    }\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      let s = 0, n = 0;\n      for (let j = max(0, py - 1); j \u003c= min(H - 1, py + 1); j++)\n        for (let i = max(0, px - 1); i \u003c= min(W - 1, px + 1); i++) (s += L[j * W + i]), n++;\n      const p = py * W + px;\n      out[p] = L[p] + SHARP * (L[p] - s / n);\n    }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, rate: 1, T: 20, eps: -1, t0: 0, maps: null,\n    // The sharpened log stretch at each node time of the period, worked out\n    // once for each epsilon and horizon, and the one being worked on.\n    field: [], job: null, cf: [0, 0, 0], cb: [0, 0, 0],\n    X: new Float32Array(N), Y: new Float32Array(N), L: new Float32Array(N),\n  };\n}\n\nconst node = (n) => ((n % NP) + NP) % NP;\n\n// Finishes any field the picture needs this frame, then works up to rows\n// rows on the ones it will need next.\nfunction work(S, rows) {\n  const n = floor(S.t0 / G), need = [n, n + 1, -n - 1, -n, n + 2, -n - 2, n + 3, -n - 3].map(node);\n  for (let q = 0; q \u003c need.length; q++) {\n    const k = need[q];\n    if (S.field[k]) continue;\n    if (q >= 4 && rows \u003c= 0) return;\n    if (!S.job || S.job.k !== k) S.job = { k, row: 0, X: S.X, Y: S.Y, L: S.L };\n    const J = S.job, r1 = q \u003c 4 ? H : min(H, J.row + rows);\n    carry(S, J, J.row, r1);\n    rows -= r1 - J.row;\n    J.row = r1;\n    if (r1 === H) {\n      S.field[k] = finish(J);\n      S.job = null;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.rate = 0.5 * cl(k[1], 0.2, 3);\n  const T = 2 * round(10 * 2 ** cl(k[2], -1, 1));\n  const eps = round(500 * ((0.5 * log(1 + 1000 * cl(k[3], 0, 1))) / log(1001))) / 500;\n  if (eps !== S.eps) {\n    S.eps = eps;\n    S.maps = buildMaps(eps);\n    S.field = [];\n    S.job = null;\n  }\n  if (T !== S.T) {\n    S.T = T;\n    S.field = [];\n    S.job = null;\n  }\n  S.t0 = (S.t0 + d * S.rate) % PER;\n  // Two fields for each quarter unit the start time moves, a little ahead.\n  work(S, Math.ceil(((2.4 * H * d * S.rate) / G) * (S.T / 20)) + 8);\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// An LED lights from a stretch of e^2.4 = 11 times to full at e^3.6 = 37.\nconst STRETCH = 2.4, SPAN = 1.2;\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.maps) return;\n  const cf = S.cf, cb = S.cb, n = floor(S.t0 / G), w = S.t0 / G - n;\n  // Running time backward is the same flow turned half round: the fluid\n  // carried back from t0 lands where fluid carried on from -t0 lands, with\n  // the panel turned 180 degrees (psi(x, y, -t) = psi(x, y, t + 5) and\n  // psi(x, 1 - y, t) = psi(x, y, t)). So the backward field at t0 is the\n  // forward field at -t0 upside down and back to front.\n  const f0 = S.field[node(n)], f1 = S.field[node(n + 1)], b0 = S.field[node(-n)], b1 = S.field[node(-n - 1)];\n  if (!f0 || !f1 || !b0 || !b1) return;\n  hsv(0.1 + S.hue, 0.86, 1, cf);\n  hsv(0.6 + S.hue, 0.8, 1, cb);\n  for (let py = 0, p = 0; py \u003c H; py++) {\n    for (let px = 0; px \u003c W; px++, p++) {\n      const q = N - 1 - p;\n      const vf = cl((f0[p] + (f1[p] - f0[p]) * w - STRETCH) / SPAN, 0, 1);\n      const vb = cl((b0[q] + (b1[q] - b0[q]) * w - STRETCH) / SPAN, 0, 1);\n      if (vf + vb \u003c 0.02) continue;\n      // Steps of 4 of 255.\n      const r = min(255, cf[0] * vf + cb[0] * vb), g = min(255, cf[1] * vf + cb[1] * vb), b = min(255, cf[2] * vf + cb[2] * vb);\n      display.setPixel(px, py, (r >> 2) \u003c\u003c 2, (g >> 2) \u003c\u003c 2, (b >> 2) \u003c\u003c 2);\n    }\n  }\n}\n","flashing-ratchet":"// ===== Patternflow pattern =====\n// Title:   Flashing Ratchet\n// Family:  sim\n// Idea:    Three thousand Brownian particles drift in a sawtooth potential of eight teeth stacked up the panel that switches on and off, bunching into glowing lines under each steep ridge while it is on and spreading into fog while it is off, and because each well's minimum sits 3.2 LEDs below its near ridge and 12.8 above its far one, more of every blob lands a well higher when the potential comes back, so a gold-marked cloud climbs against a downward load that would drag it down with the potential held on or held off.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Flashing ratchet (Armand Ajdari and Jacques Prost, 1992), Parrondo's paradox (Juan Parrondo, 1996), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Period=0.8..3.2, Load=0.25..1.5\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a sky blue cloud, a gold marked cloud with gold marks on the edges, and violet ridges; at 0.25 violet, green and red; at 0.5 orange, blue and lime; at 0.75 green, pink and cyan.\n// Knob 2: Speed. Model time runs at Speed / 2 of real time. At 2 the opening flash lasts 0.8 s and the marked cloud climbs 2 LEDs a second; at 0.2 everything is ten times slower and at 3 half as fast again.\n// Knob 3: Period. One off-and-on cycle in seconds of model time, off for the first 40% and on for the rest. At 0.8 a blob spreads 5.7 LEDs (one standard deviation) before the wells come back and the marked cloud climbs 0.127 teeth a second at the opening load; at 1.6 it climbs 0.058, and at 3.2 the blobs spread 11.3 LEDs, most of a tooth, the climb falls to 0.0125 and from half the stall load up the load wins.\n// Knob 4: Load. The steady downward force, as a share of the load that stalls the flashing at the 0.8 s period, 5.15 LEDs a second of free fall. At the opening 0.25 the flashing climbs 0.127 teeth a second while the potential held on loses 0.0022 and held off 0.081; at 0.75 it climbs 0.043, at 1 it stands still, and at 1.5 (7.7 LEDs a second) the flashing too goes down, 0.089 teeth a second.\n// Buttons: K1 tap steps through the three games: flashing, the potential held on, the potential held off, and back to flashing. Held on, the marked cloud stays in its lines; held off, it sinks with the load.\n//\n// Checked with this file's own update() over 300 s of model time for each\n// game and load, 3000 particles, the period at 0.8 s and the load clamp\n// opened down to 0. Mean velocity in teeth a second, up positive, with one\n// standard error in the last digit in brackets:\n//   load    flashing          held on            held off\n//   0       +0.1681 (5)       +0.0001 (1)        -0.0011 (7)\n//   0.25    +0.1270 (5)       -0.0022 (1)        -0.0811 (7)\n//   0.5     +0.0851 (5)       -0.0048 (1)        -0.1613 (6)\n//   0.75    +0.0425 (5)       -0.0078 (1)        -0.2412 (7)\n//   1       +0.0002 (5)       -0.0117 (1)        -0.3219 (7)\n//   1.5     -0.0893 (5)       -0.0216 (2)        -0.4827 (7)\n// So from load 0 to 1 both games lose and switching between them wins:\n// Parrondo's paradox. Held off, the speed is the load's own F / 16 to\n// within the error; held on, particles leave a well only by crossing a\n// ridge 7.5 D high, which the load lowers on the down side. With no load\n// the held potential makes no current, as it must in equilibrium.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, exp, log, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The sawtooth: 8 teeth of L = 16 LEDs up the panel. Measured down the\n// panel from a minimum, V rises gently for (1 - A) L = 12.8 LEDs to V0,\n// then falls steeply over A L = 3.2 LEDs to the next minimum. So the\n// steep side of every well faces up, and the near maximum is 3.2 LEDs\n// above a particle sitting in it, the far one 12.8 below.\nconst L = 16, A = 0.2, NT = H / L;\n// Diffusion D in LED^2 per second of model time, the well depth V0 = 7.5 D\n// (in units where the mobility is 1, so a force is the speed it gives).\nconst D = 50, V0 = 7.5 * D;\nconst FG = V0 / ((1 - A) * L), FS = V0 / (A * L);\n// Off for this share of each period, on for the rest.\nconst OFF = 0.4;\n// The stall load at the shortest period, measured with this code (LED/s).\nconst FSTALL = 5.15;\n// Steps while the potential is on: at most HMAX of model time, so the steep\n// side's push in one step stays under a tenth of its width.\nconst HMAX = 1 / 480;\nconst NP = 3000;\n// Pulse labelling: every particle in one well is marked and lit, and the\n// marked cloud is followed until its spread passes 3 teeth, it has moved 5\n// or 36 s have gone by; then it fades over FADE s and another well is\n// marked, the bottom one if the last cloud went up and the top one if it\n// fell. The marks on the edges are the cloud's start and its mean now.\nconst SPREAD = 3 * L, TRAVEL = 5 * L, TMAX = 36, FADE = 1.5;\n\n// A table of normal deviates, each with its negative so the noise has no\n// skew, scaled to variance 1 exactly. A table of 4096 plain draws had\n// enough skew to make the held potential lift particles: 1890 teeth up\n// against 1413 down in 200 s.\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return (((h ^ (h >>> 16)) >>> 0) + 0.5) / 4294967296;\n};\nconst NG = 4096, G = new Float32Array(NG);\n{\n  let v = 0;\n  for (let i = 0; i \u003c NG; i += 2) {\n    G[i] = sqrt(-2 * log(hash(i))) * cos(2 * PI * hash(i + 77777));\n    G[i + 1] = -G[i];\n    v += 2 * G[i] * G[i];\n  }\n  v = sqrt(v / NG);\n  for (let i = 0; i \u003c NG; i++) G[i] /= v;\n}\nconst gn = () => G[(Math.random() * NG) | 0];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  const X = new Float32Array(NP), Y = new Float32Array(NP);\n  // The start: bunched in the wells as if the potential had been on, each\n  // line with its thermal tail on the gentle side below it.\n  for (let i = 0; i \u003c NP; i++) {\n    X[i] = Math.random() * W;\n    Y[i] = (floor(Math.random() * NT) * L - log(1 - Math.random()) * (D / FG) + H) % H;\n  }\n  params.s = {\n    X, Y, M: new Uint8Array(NP), LAP: new Int16Array(NP), rng: (Math.random() * 4294967295) | 1, t: 0, ph: 0, hold: 0, on: true,\n    hue: 0, speed: 2, per: 0.8, load: 0.25,\n    age: 0, y0: 0, mean: 0, sd: 0, old: 0,\n    da: new Float32Array(N), db: new Float32Array(N), tmp: new Float32Array(N),\n    col: new Float32Array(9),\n  };\n  mark(params.s, NT - 1);\n}\n\n// Marks every particle in the basin of well k, the stretch from the\n// maximum A L above its minimum to the one (1 - A) L below; the cloud\n// marked before fades.\nfunction mark(S, k) {\n  const { Y, M, LAP } = S, lo = k * L - A * L, hi = k * L + (1 - A) * L;\n  let m = 0, n = 0;\n  for (let i = 0; i \u003c NP; i++) {\n    M[i] = M[i] === 1 ? 2 : M[i];\n    LAP[i] = 0;\n    let y = Y[i];\n    if (y >= hi) y -= H;\n    if (y >= lo && y \u003c hi) {\n      M[i] = 1;\n      m += y;\n      n++;\n    }\n  }\n  S.old = M.some((v) => v === 2) ? 1 : 0;\n  S.age = 0;\n  S.y0 = n ? m / n : k * L;\n  S.mean = S.sd = 0;\n}\n\n// Moves every particle through tau of model time with the potential off:\n// free diffusion plus the load, one exact Gaussian step.\nfunction stepOff(S, tau, F) {\n  const { X, Y } = S, a = sqrt(2 * D * tau), dy = F * tau;\n  for (let i = 0; i \u003c NP; i++) {\n    Y[i] += dy + a * gn();\n    X[i] += a * gn();\n  }\n}\n\n// The same with the potential on, in steps of at most HMAX along the height.\n// Each step is an Euler-Maruyama proposal; one that stays on the same\n// straight piece of V is exact and taken, one that crosses a corner is put\n// to the Metropolis test with the Boltzmann weight of V - F y. So while the\n// potential is held, the steps keep that weight exactly and cannot make a\n// current of their own. Plain Euler steps of this size pushed particles over\n// the steep side more often than back: with the potential held on and no\n// load, 3148 teeth climbed against 2151 fallen in 400 s; with the test,\n// 2430 against 2359.\nfunction stepOn(S, tau, F) {\n  const { X, Y } = S, n = ceil(tau / HMAX - 1e-9), h = tau / n, a = sqrt(2 * D * h), ax = sqrt(2 * D * tau);\n  const up = (F - FG) * h, dn = (F + FS) * h, edge = 1 - A, i4 = 1 / (4 * D * h);\n  let r = S.rng;\n  for (let i = 0; i \u003c NP; i++) {\n    let y = Y[i], k = floor(y / L), g = y / L - k \u003c edge, f = g ? up : dn;\n    for (let j = 0; j \u003c n; j++) {\n      r ^= r \u003c\u003c 13;\n      r ^= r >>> 17;\n      r ^= r \u003c\u003c 5;\n      const yp = y + f + a * G[r & 4095], up2 = yp / L, k2 = floor(up2), s2 = up2 - k2, g2 = s2 \u003c edge;\n      if (k2 === k && g2 === g) {\n        y = yp;\n        continue;\n      }\n      // Across a corner: V at both ends, in units of V0, and the test.\n      const s1 = y / L - k, v1 = g ? s1 / edge : (1 - s1) / A, v2 = g2 ? s2 / edge : (1 - s2) / A, f2 = g2 ? up : dn;\n      const d = yp - y, la = (-(v2 - v1) * V0 + F * d) / D + ((d - f) ** 2 - (d + f2) ** 2) * i4;\n      r ^= r \u003c\u003c 13;\n      r ^= r >>> 17;\n      r ^= r \u003c\u003c 5;\n      if (la >= 0 || (r >>> 0) / 4294967296 \u003c exp(la)) {\n        y = yp;\n        k = k2;\n        g = g2;\n        f = f2;\n      }\n    }\n    Y[i] = y;\n    X[i] += ax * gn();\n  }\n  S.rng = r;\n}\n\n// Wraps the height, counting laps so the marked cloud can be followed\n// unwrapped, reflects the sides, and measures the marked cloud: its mean\n// displacement and its spread, in LEDs, down positive.\nfunction edges(S) {\n  const { X, Y, M, LAP } = S;\n  let n = 0, m = 0, m2 = 0;\n  for (let i = 0; i \u003c NP; i++) {\n    let y = Y[i];\n    if (y \u003c 0 || y >= H) {\n      const q = floor(y / H);\n      y -= q * H;\n      LAP[i] += q;\n    }\n    Y[i] = y;\n    let x = X[i];\n    if (x \u003c 0) x = -x;\n    if (x >= W) x = 2 * W - x - 1e-3;\n    X[i] = cl(x, 0, W - 1e-3);\n    if (M[i] === 1) {\n      const u = y + LAP[i] * H;\n      n++;\n      m += u;\n      m2 += u * u;\n    }\n  }\n  if (n) {\n    m /= n;\n    S.mean = m - S.y0;\n    S.sd = sqrt(max(0, m2 / n - m * m));\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.8, 0.25];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.per = cl(k[2], 0.8, 3.2);\n  S.load = cl(k[3], 0.25, 1.5);\n  // K1 tap: flashing, then held on, then held off, then flashing again.\n  if (input.btnPressed && input.btnPressed[0]) S.hold = (S.hold + 1) % 3;\n  const F = S.load * FSTALL;\n  let rem = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += rem;\n  S.age += rem;\n  if (S.old) {\n    S.old -= rem / FADE;\n    if (S.old \u003c= 0) {\n      S.old = 0;\n      for (let i = 0; i \u003c NP; i++) if (S.M[i] === 2) S.M[i] = 0;\n    }\n  }\n  while (rem > 1e-9) {\n    let on, piece;\n    if (S.hold) {\n      on = S.hold === 1;\n      piece = rem;\n    } else {\n      // The period starts with the potential off.\n      const cut = OFF * S.per;\n      on = S.ph >= cut;\n      piece = min(rem, (on ? S.per : cut) - S.ph);\n      S.ph += piece;\n      if (S.ph >= S.per - 1e-9) S.ph = 0;\n    }\n    if (on) stepOn(S, piece, F);\n    else stepOff(S, piece, F);\n    rem -= piece;\n  }\n  S.on = S.hold ? S.hold === 1 : S.ph >= OFF * S.per;\n  edges(S);\n  if (S.sd > SPREAD || abs(S.mean) > TRAVEL || S.age > TMAX) mark(S, S.mean > 0 ? 1 : NT - 1);\n}\n\n// 1 - exp(-n) in steps of 1/128 of n, the light of n particles' worth.\nconst NTONE = 1280, TONE = new Float32Array(NTONE);\nfor (let i = 0; i \u003c NTONE; i++) TONE[i] = 1 - exp(-i / 128);\n\n// Separable blur [1 4 6 4 1] / 16, wrapping in height, clamped at the sides.\nfunction blur(src, tmp) {\n  for (let y = 0; y \u003c H; y++) {\n    const r = y * W;\n    for (let x = 0; x \u003c W; x++) {\n      const a = src[r + max(0, x - 2)], b = src[r + max(0, x - 1)], c = src[r + x], d = src[r + min(W - 1, x + 1)], e = src[r + min(W - 1, x + 2)];\n      tmp[r + x] = (a + e + 4 * (b + d) + 6 * c) / 16;\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const r0 = ((y + H - 2) % H) * W, r1 = ((y + H - 1) % H) * W, r2 = y * W, r3 = ((y + 1) % H) * W, r4 = ((y + 2) % H) * W;\n    for (let x = 0; x \u003c W; x++) src[r2 + x] = (tmp[r0 + x] + tmp[r4 + x] + 4 * (tmp[r1 + x] + tmp[r3 + x]) + 6 * tmp[r2 + x]) / 16;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { X, Y, M, da, db, tmp, col } = S;\n  da.fill(0);\n  db.fill(0);\n  // Each particle shared out over the four LEDs round it: the marked cloud\n  // into its own grid, a fading one into both.\n  for (let i = 0; i \u003c NP; i++) {\n    const x = X[i] - 0.5, y = Y[i] - 0.5, x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;\n    const xa = max(0, x0), xb = min(W - 1, x0 + 1), ya = ((y0 % H) + H) % H, yb = (ya + 1) % H;\n    const w00 = (1 - fx) * (1 - fy), w10 = fx * (1 - fy), w01 = (1 - fx) * fy, w11 = fx * fy;\n    const m = M[i], wb = m === 1 ? 1 : m === 2 ? S.old : 0, wa = 1 - wb;\n    if (wa > 0) {\n      da[ya * W + xa] += w00 * wa;\n      da[ya * W + xb] += w10 * wa;\n      da[yb * W + xa] += w01 * wa;\n      da[yb * W + xb] += w11 * wa;\n    }\n    if (wb > 0) {\n      db[ya * W + xa] += w00 * wb;\n      db[ya * W + xb] += w10 * wb;\n      db[yb * W + xa] += w01 * wb;\n      db[yb * W + xb] += w11 * wb;\n    }\n  }\n  blur(da, tmp);\n  blur(db, tmp);\n  // Colours: the cloud, the marked cloud and the field.\n  hsv(0.55 + S.hue, 0.7, 0.78, col, 0);\n  hsv(0.11 + S.hue, 0.75, 1, col, 3);\n  hsv(0.76 + S.hue, 0.7, 1, col, 6);\n  const GA = 1, GB = 2, FIELD = 0.3;\n  for (let y = 0; y \u003c H; y++) {\n    // V at this row, 0 at a minimum and 1 at a maximum.\n    let f = 0;\n    if (S.on) {\n      const u = (y + 0.5) / L, s = u - floor(u);\n      const v = s \u003c 1 - A ? s / (1 - A) : (1 - s) / A;\n      f = FIELD * v * v;\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, a = TONE[min(NTONE - 1, (da[p] * GA * 128) | 0)], b = TONE[min(NTONE - 1, (db[p] * GB * 128) | 0)], o = 1 - b;\n      const r = col[6] * f * o + a * col[0] * o + b * col[3];\n      const g = col[7] * f * o + a * col[1] * o + b * col[4];\n      const bl = col[8] * f * o + a * col[2] * o + b * col[5];\n      if (r + g + bl \u003c 0.01) continue;\n      // Each channel in steps of 4 of 255.\n      display.setPixel(x, y, min(255, round(r * 63.75) * 4), min(255, round(g * 63.75) * 4), min(255, round(bl * 63.75) * 4));\n    }\n  }\n  // Marks on both edges: where the marked cloud started, dim, and the\n  // height of its mean now, which climbs while the flashing wins.\n  tick(display, S.y0, 3, 0.4, col);\n  tick(display, S.y0 + S.mean, 4, 1, col);\n}\n\n// A short bar on each edge at height y, shared between two rows.\nfunction tick(display, y, len, v, col) {\n  y = y - 0.5 - floor((y - 0.5) / H) * H;\n  const y0 = floor(y), fy = y - y0;\n  for (const [row, w] of [[y0, 1 - fy], [(y0 + 1) % H, fy]]) {\n    const c = v * min(1, w * 1.6);\n    if (c \u003c 0.08) continue;\n    for (let i = 0; i \u003c len; i++)\n      for (const x of [i, W - 1 - i]) display.setPixel(x, row, round(col[3] * c * 63.75) * 4, round(col[4] * c * 63.75) * 4, round(col[5] * c * 63.75) * 4);\n  }\n}\n","fractal-percolation":"// ===== Patternflow pattern =====\n// Title:   Fractal Percolation\n// Family:  fractal\n// Idea:    Two stacked squares split into quarters again and again down to single LEDs, each quarter kept with chance p and the rest going dark, then a front climbs from the bottom row through the kept LEDs, the cluster that reaches the top row lights mint while the rest stays dim, and the view zooms into a kept pair of squares that grows to fill the panel and splits once more.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fractal percolation (Benoit Mandelbrot, 1974), with the crossing transition of Chayes, Chayes and Durrett (1988), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Keep=0.88..0.99, Levels=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 the kept LEDs are steel blue, the front is white over a pale blue trail, the crossing cluster is mint and the holes are dark plum; at 0.25 the kept LEDs are purple, the crossing cluster blue and the holes olive; at 0.5 tan, pink and green; at 0.75 green, yellow and navy.\n// Knob 2: Speed. At 2 a level splits every 0.45 s, so a build from two squares to single LEDs takes 2.7 s and the first front sets off 3 s in; the front climbs 110 LEDs of path a second (1.2 s to the top row on average), a crossing cluster stays lit 1.4 s and a zoom takes 1.4 s, and after four zooms the holes close and a fresh build begins, about every 23 s. At 0.2 everything is ten times slower; at 3 half as fast again, a fresh build every 16 s.\n// Knob 3: Keep. The chance p that each quarter is kept at every split. At the opening 0.88 the front reaches the top row in about half the tests and 47% of the LEDs are kept; at 0.90 in seven of ten, with 53% kept; at 0.93 in nine of ten, with 65% kept; at 0.99 every time, with 94% kept. The kept set is a random Cantor set of dimension log(4p)/log 2, 1.82 at 0.88 and 1.99 at 0.99.\n// Knob 4: Levels. How brightly each hole keeps the colour of the level that cut it, magenta for the 32-LED holes and a step on towards blue-violet for each smaller size. At 0 every hole is black and only the set shows; at the opening 0.06 the 32-LED holes glow at 35/255 and the single-LED ones at 16, so the big holes read as dark plum squares; at 0.25 at 71 and 32, and at 1 at 142 and 65, a mosaic of squares inside squares.\n// Buttons: K1 tap closes the holes back into two whole squares and carves a fresh set.\n\nconst W = 64, H = 128, N = W * H, DEPTH = 6;\nconst { floor, min, max, exp, pow, round } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Seconds at Speed 2: one level's split, the fade of a cut square, the time\n// a crossing (or its absence) stays lit, and one zoom by two.\nconst STEP = 0.45, FADE = 0.35, SEAM = 0.4, HOLD = 1.4, MISS = 0.7, ZOOM = 1.4, HEAL = 0.09;\n// The front climbs this many LEDs of path a second, and four zooms follow a\n// build before a fresh one.\nconst CLIMB = 110, ZMAX = 4;\n\n// Carves levels a..b into cut on a grid w wide and h tall made of w-by-w\n// squares: at level k every square of side w >> k that no earlier level has\n// cut is cut whole with chance 1 - p. cut holds the level that removed each\n// LED's square, or 0 while it is kept.\nfunction carve(cut, w, h, a, b, p) {\n  for (let k = a; k \u003c= b; k++) {\n    const s = w >> k;\n    for (let y = 0; y \u003c h; y += s)\n      for (let x = 0; x \u003c w; x += s) {\n        const o = y * w + x;\n        if (cut[o] || Math.random() \u003c p) continue;\n        for (let j = 0; j \u003c s; j++) cut.fill(k, o + j * w, o + j * w + s);\n      }\n  }\n}\n\n// Path length from the bottom row through kept LEDs that share an edge, into\n// dist (-1 where the bottom row cannot be reached). Returns the shortest path\n// to the top row, or -1 when no kept path crosses.\nfunction reach(cut, w, h, dist, q) {\n  dist.fill(-1);\n  let t = 0, top = -1;\n  for (let x = 0, o = (h - 1) * w; x \u003c w; x++) if (!cut[o + x]) (dist[o + x] = 0), (q[t++] = o + x);\n  for (let i = 0; i \u003c t; i++) {\n    const p = q[i], d = dist[p] + 1, x = p % w;\n    if (p \u003c w && top \u003c 0) top = d - 1;\n    if (x > 0 && !cut[p - 1] && dist[p - 1] \u003c 0) (dist[p - 1] = d), (q[t++] = p - 1);\n    if (x \u003c w - 1 && !cut[p + 1] && dist[p + 1] \u003c 0) (dist[p + 1] = d), (q[t++] = p + 1);\n    if (p >= w && !cut[p - w] && dist[p - w] \u003c 0) (dist[p - w] = d), (q[t++] = p - w);\n    if (p + w \u003c w * h && !cut[p + w] && dist[p + w] \u003c 0) (dist[p + w] = d), (q[t++] = p + w);\n  }\n  return top;\n}\n\n// The crossing cluster: every LED reached from the bottom row that also\n// connects to the top row, marked 1 in mark. Returns how many there are.\nfunction spanning(w, h, dist, mark, q) {\n  mark.fill(0);\n  let t = 0;\n  for (let x = 0; x \u003c w; x++) if (dist[x] >= 0) (mark[x] = 1), (q[t++] = x);\n  for (let i = 0; i \u003c t; i++) {\n    const p = q[i], x = p % w;\n    for (const n of [x > 0 ? p - 1 : -1, x \u003c w - 1 ? p + 1 : -1, p - w, p + w \u003c w * h ? p + w : -1])\n      if (n >= 0 && dist[n] >= 0 && !mark[n]) (mark[n] = 1), (q[t++] = n);\n  }\n  return t;\n}\n\n// Zoom targets: a column of the level-1 grid (32 LEDs wide) and a pair of\n// its rows, so 32 by 64 LEDs, the panel's shape at half its size. Only pairs\n// whose two squares survived level 1 can be chosen, and the choice looks at\n// nothing else, so the view after a zoom is a fresh sample of the\n// construction one level down.\nfunction target(cut) {\n  const ok = [];\n  for (let c = 0; c \u003c 2; c++)\n    for (let r = 0; r \u003c 3; r++) if (cut[r * 32 * W + c * 32] !== 1 && cut[(r + 1) * 32 * W + c * 32] !== 1) ok.push([c * 32, r * 32]);\n  return ok.length ? ok[floor(Math.random() * ok.length)] : null;\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, p: 0.88, lev: 0.06, t: 0,\n    ph: \"build\", pt: 0, L: 0, maxd: 0, revT: new Float64Array(DEPTH + 1).fill(-9), R: 0, top: -1, crossed: false, zooms: 0, tgt: null, zs: 1,\n    cut: new Uint8Array(N), dist: new Int32Array(N), mark: new Uint8Array(N), q: new Int32Array(N),\n    lit: new Float32Array(N), glow: new Float32Array(N),\n    tmp: new Uint8Array(N), tmpF: new Float32Array(N), tmpL: new Float32Array(N),\n    pal: new Float32Array(32 * 3), palKey: \"\",\n    // Fronts sent and crossings found, kept for checking the rates above.\n    tests: 0, hits: 0,\n  };\n  fresh(params.s);\n}\n\nfunction fresh(S) {\n  S.cut.fill(0);\n  S.ph = \"build\";\n  S.pt = 0;\n  S.L = 0;\n  S.revT.fill(-9);\n  S.zooms = 0;\n  S.R = 0;\n  S.crossed = false;\n}\n\n// After a zoom: every LED of the chosen pair becomes a 2-by-2 block and each\n// level moves up one; the build then carves the single LEDs anew.\nfunction settle(S) {\n  const [ox, oy] = S.tgt, { cut, lit, glow, tmp, tmpF, tmpL } = S;\n  tmp.set(cut);\n  tmpF.set(lit);\n  tmpL.set(glow);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = (oy + (y >> 1)) * W + ox + (x >> 1), c = tmp[o];\n      cut[p] = c > 1 ? c - 1 : 0;\n      lit[p] = tmpF[o];\n      glow[p] = tmpL[o];\n    }\n  for (let k = 1; k \u003c DEPTH; k++) S.revT[k] = -9;\n  S.L = DEPTH - 1;\n  S.ph = \"build\";\n  S.pt = STEP * (DEPTH - 1) + 0.2;\n  S.zooms++;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.88, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.p = cl(k[2], 0.88, 0.99);\n  S.lev = cl(k[3], 0, 1);\n  const d = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += d;\n  S.pt += d;\n  if (input.btnPressed && input.btnPressed[0] && S.ph !== \"heal\") (S.ph = \"heal\"), (S.pt = 0), (S.crossed = false);\n  if (S.ph === \"build\") {\n    // Level L + 1 splits every STEP; the front sets off 0.3 s after the last.\n    const L = min(DEPTH, floor(S.pt / STEP));\n    // Each level is carved as it splits, so turning Keep acts on the next.\n    while (S.L \u003c L) {\n      S.L++;\n      carve(S.cut, W, H, S.L, S.L, S.p);\n      S.revT[S.L] = S.t;\n    }\n    if (S.L === DEPTH && S.pt > STEP * DEPTH + 0.3) {\n      S.top = reach(S.cut, W, H, S.dist, S.q);\n      // The longest path, for when nothing crosses.\n      let m = 0;\n      for (let p = 0; p \u003c N; p++) if (S.dist[p] > m) m = S.dist[p];\n      S.maxd = m;\n      S.ph = \"burn\";\n      S.pt = 0;\n      S.R = 0;\n      S.crossed = false;\n    }\n  } else if (S.ph === \"burn\") {\n    S.R += CLIMB * d;\n    if (S.top >= 0 && S.R >= S.top) {\n      spanning(W, H, S.dist, S.mark, S.q);\n      S.crossed = true;\n      S.ph = \"hold\";\n      S.pt = 0;\n      S.tests++;\n      S.hits++;\n    } else if (S.top \u003c 0 && S.R > S.maxd + 8) {\n      // The front has run out of path: no crossing this time.\n      S.ph = \"hold\";\n      S.pt = HOLD - MISS;\n      S.tests++;\n    }\n  } else if (S.ph === \"hold\") {\n    if (S.pt > HOLD) {\n      S.tgt = S.zooms \u003c ZMAX ? target(S.cut) : null;\n      S.ph = S.tgt ? \"zoom\" : \"heal\";\n      S.pt = 0;\n    }\n  } else if (S.ph === \"zoom\") {\n    const u = cl(S.pt / ZOOM, 0, 1);\n    // Eased in and out, scaled exponentially so it looks like a steady fall.\n    S.zs = pow(2, u * u * (3 - 2 * u));\n    if (S.pt >= ZOOM) {\n      S.zs = 1;\n      S.crossed = false;\n      settle(S);\n    }\n  } else if (S.ph === \"heal\") {\n    // The holes close from the smallest up, then a fresh set is carved.\n    S.crossed = false;\n    const L = DEPTH - floor(S.pt / HEAL);\n    if (L \u003c S.L) S.L = max(0, L);\n    if (S.pt > HEAL * (DEPTH + 1) + 0.25) fresh(S);\n  }\n  // Light: the front and its trail brighten the kept LEDs it has reached;\n  // once it crosses, the crossing cluster turns to the accent and the rest\n  // falls back.\n  const burning = S.ph === \"burn\" || S.ph === \"hold\", kf = 1 - exp(-d * 7), kg = 1 - exp(-d * 4);\n  const { dist, lit, glow, mark } = S;\n  for (let p = 0; p \u003c N; p++) {\n    let tl = 0, tg = 0;\n    if (burning && dist[p] >= 0 && dist[p] \u003c= S.R) {\n      if (S.crossed) tg = mark[p];\n      else tl = 0.55;\n    }\n    lit[p] += (tl - lit[p]) * kf;\n    if (S.ph !== \"zoom\") glow[p] += (tg - glow[p]) * (tg > glow[p] ? kf * 1.5 : kg);\n  }\n}\n\n// Colours: 0 kept, 1 lit trail, 2 crossing, 3 front, 4 cut flash, 8 + k the\n// hole of level k.\nfunction palette(S) {\n  const key = S.hue + \":\" + S.lev;\n  if (key === S.palKey) return;\n  S.palKey = key;\n  const h = S.hue + 0.6, P = S.pal;\n  hsv(h, 0.5, 0.5, P, 0);\n  hsv(h, 0.35, 0.9, P, 3);\n  hsv(h + 0.82, 0.62, 0.9, P, 6);\n  hsv(h + 0.82, 0.1, 1, P, 9);\n  hsv(h, 0.2, 1, P, 12);\n  for (let k = 1; k \u003c= DEPTH; k++) {\n    // Each level its own hue, 0.055 of the wheel on from the last; the\n    // larger the hole, the brighter its glow.\n    const v = 0.55 * pow(S.lev, 0.5) * (1.12 - 0.11 * k);\n    hsv(h + 0.33 - 0.055 * (k - 1), 0.7, v, P, (8 + k) * 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const { cut, lit, glow, dist, pal: P, revT } = S;\n  const zoom = S.ph === \"zoom\", s = S.zs, fx = zoom ? S.tgt[0] * 2 : 0, fy = zoom ? S.tgt[1] * 2 : 0;\n  const front = S.ph === \"burn\";\n  // While a level splits, the edges of its new squares show as dark seams\n  // for a moment; before the first split, the edge between the two squares.\n  const L = S.L, age = L ? S.t - revT[L] : 0, ss = 64 >> (L ? L : 0);\n  const seam = S.ph === \"build\" && L \u003c= 3 && age \u003c SEAM ? 0.35 + 0.65 * (L ? age / SEAM : 0) : 0;\n  for (let y = 0; y \u003c H; y++) {\n    const sy = zoom ? floor(fy + (y + 0.5 - fy) / s) : y;\n    for (let x = 0; x \u003c W; x++) {\n      const sx = zoom ? floor(fx + (x + 0.5 - fx) / s) : x;\n      if (sx \u003c 0 || sx >= W || sy \u003c 0 || sy >= H) continue;\n      const p = sy * W + sx, c = cut[p];\n      let r, g, b;\n      if (c && c \u003c= S.L) {\n        // A cut square: a flash, then the glow of its level.\n        const a = min(1, (S.t - revT[c]) / FADE), o = (8 + c) * 3;\n        const f = (1 - a) * (1 - a);\n        r = P[o] + (P[12] - P[o]) * f;\n        g = P[o + 1] + (P[13] - P[o + 1]) * f;\n        b = P[o + 2] + (P[14] - P[o + 2]) * f;\n      } else {\n        const l = lit[p], gg = glow[p];\n        r = P[0] + (P[3] - P[0]) * l;\n        g = P[1] + (P[4] - P[1]) * l;\n        b = P[2] + (P[5] - P[2]) * l;\n        r += (P[6] - r) * gg;\n        g += (P[7] - g) * gg;\n        b += (P[8] - b) * gg;\n        if (front && dist[p] >= 0 && dist[p] \u003c= S.R && S.R - dist[p] \u003c 5) {\n          const f = 1 - (S.R - dist[p]) / 5;\n          r += (P[9] - r) * f;\n          g += (P[10] - g) * f;\n          b += (P[11] - b) * f;\n        }\n      }\n      if (seam && !(c && c \u003c= S.L) && (sx % ss === 0 || sy % ss === 0)) (r *= seam), (g *= seam), (b *= seam);\n      // Channels in steps of 4 of 255: too fine to see, and a frame packs smaller.\n      display.setPixel(x, y, min(255, round(r / 4) * 4), min(255, round(g / 4) * 4), min(255, round(b / 4) * 4));\n    }\n  }\n}\n","grim-reaper":"// ===== Patternflow pattern =====\n// Title:   Grim Reaper\n// Family:  halloween\n// Idea:    A hooded reaper in a tattered black robe drifts across a hillside graveyard in front of a huge pale moon and a sickly green horizon, two toxic green points burning in its hood and shreds of its ragged hem streaming behind, swinging a long scythe over its head in a wide arc whose blade glints, while the grave candles gutter and go out as it passes over them and light again behind it.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Graves=6..30, Fog=0..1\n//\n// Knob 1: Hue. The glow at the horizon, the moon's tint and the eyes; the sky overhead stays deep purple and the candles gold. At 0 a sickly green horizon, a pale yellow moon and toxic green eyes; at 0.25 a teal horizon, a mint moon and sky blue eyes; at 0.5 violet, lavender and magenta; at 0.75 a red horizon, a pink moon and orange eyes.\n// Knob 2: Speed. At 2 a pass takes 10 s: in from the right in 1.8 s, 5.7 s drifting 18 LEDs across the moon while it sways 5 LEDs either way and bobs 6 up and down every 2.9 s, and out to the left in 2.5 s. The scythe swings every 3.2 s (wound back in 0.55 s, the stroke in 0.32 s, held 0.3 s, brought back in 1.2 s), and a candle lights again 0.6 to 1.8 s after the robe has passed it. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Graves. How many graves, six to a row, each with a candle at its foot. At 6 one row stands along the bottom and the robe is all against the sky; at 12 a second row stands 9 LEDs higher on a hill, at 18, 24 and 30 a third, fourth and fifth, each a sixth smaller, until the hill's crest reaches row 82 and the candles climb it.\n// Knob 4: Fog. A lilac fog rolling to the right at 8 to 11 LEDs a second. At 0 none; at 0.06 a thin haze over the bottom 22 rows, at most a fifth thick; at 0.5 it reaches row 88 and 0.38 thick; at 1 row 68, over the hem and the lower robe, 0.58 thick.\n// Buttons: K1 tap swings the scythe at once, from rest or while it is being brought back.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, pow, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 1 : v * v * (3 - 2 * v));\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// A huge moon high in the middle; the horizon glows low down.\nconst MX = 31, MY = 45, MR = 30;\n// Headstones, each [width, height] near: a round-topped slab, a cross, a\n// broken slab, an obelisk and a slab with its corners cut.\nconst KINDS = [[11, 18], [9, 21], [11, 15], [7, 24], [12, 16]];\nfunction solid(kind, i, j, w, h) {\n  const c = (w - 1) / 2, dx = abs(i - c);\n  if (kind === 0) return j >= w / 2 || (i + 0.5 - w / 2) ** 2 + (w / 2 - j - 0.5) ** 2 \u003c= (w / 2) ** 2;\n  if (kind === 1) return dx \u003c= 1 || (j >= 3 && j \u003c= 4) || (j >= h - 2 && dx \u003c= 2.5);\n  if (kind === 2) return j >= (h * 0.35 * i) / w + (abs(i - c * 0.8) \u003c 1 ? 2 : 0);\n  if (kind === 3) return j >= h - 2 || dx \u003c= (j \u003c 3 ? j * 0.5 : 0.8 + (1.2 * j) / h);\n  return j > 0 || dx \u003c c - 0.5;\n}\n\n// The reaper, in its own frame: u across (negative is forward, the way it\n// drifts), v down from its shoulders, both in LEDs.\n// The scythe: the hand holds the snath LO below and UP above the grip; the\n// blade, BL long, leaves the top at right angles and curls back down.\nconst UP = 27, LO = 12, BL = 19, CURL = 0.3;\n// Swing angles of the snath from straight up, forward positive: at rest,\n// wound back over the shoulder, and at the end of the stroke, low in front.\nconst REST = 0.18, BACK = -0.62, END = 3.0;\n// Seconds at Speed 2: wind back, the stroke, the hold, the return, and the\n// rest before the next swing.\nconst TW = 0.55, TS = 0.32, TF = 0.3, TR = 1.2, TREST = 0.8;\n// One pass across the panel, in seconds at Speed 2.\nconst PASS = 10;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, ng: 0, fog: 0.06,\n    pass: 0.1, bx: 60, by: 50,\n    sw: \"rest\", st: TREST - 1.1, from: REST, phi: REST, glint: -1, glintT: 2,\n    candles: [], smoke: [], shreds: [], shredT: 0,\n    scene: new Uint8Array(N), bg: new Float32Array(N * 3), bgKey: -1, buf: new Float32Array(N * 3), mask: new Uint8Array(N),\n    c: [0, 0, 0], e: [0, 0, 0], fn: new Float32Array(2 * W), stamps: {},\n  };\n}\n\n// The graveyard climbs a hill, six graves to a row: the first row stands at\n// the foot, each further row 9 to 10 LEDs higher and a sixth smaller, and the\n// hill rises behind the last row, so more graves cover more of the glowing\n// horizon. Each grave has a candle at its foot.\nconst PER = 6, rowBase = (r) => 124 - 9 * r - (r > 1 ? r - 1 : 0), rowScale = (r) => 1 - 0.17 * r;\n// Scene codes: 0 sky, 1 hill, 2 its moonlit crest, 10 + r a stone of row r,\n// 20 + r its moonlit top.\nfunction graveyard(S, n) {\n  const sc = S.scene, R = ceil(n / PER);\n  sc.fill(0);\n  for (let x = 0; x \u003c W; x++) {\n    const top = rowBase(R - 1) - 3 + round(1.3 * sin(x / 9 + 0.7) + 0.6 * sin(x / 4.1));\n    for (let y = top; y \u003c H; y++) sc[y * W + x] = y === top ? 2 : 1;\n  }\n  const old = S.candles;\n  S.candles = [];\n  for (let r = R - 1; r >= 0; r--) {\n    const m = min(PER, n - r * PER), sz = rowScale(r);\n    for (let j = 0; j \u003c m; j++) {\n      const i = r * PER + j, kind = floor(hash(i * 17 + 3) * KINDS.length), w = max(3, round(KINDS[kind][0] * sz)), h = max(4, round(KINDS[kind][1] * sz));\n      const cx = (round(((j + 0.5 + (r % 2) * 0.5) * 64) / PER + (hash(i * 5 + 1) - 0.5) * 5) + W) % W, x0 = cx - (w >> 1);\n      const base = rowBase(r) + round(1.3 * sin(cx / 9 + 0.7));\n      for (let jj = 0; jj \u003c h; jj++)\n        for (let k = 0; k \u003c w; k++) {\n          const x = x0 + k, y = base - h + jj + 1;\n          if (x >= 0 && x \u003c W && y \u003c H && solid(kind, (k * KINDS[kind][0]) / w, (jj * KINDS[kind][1]) / h, KINDS[kind][0], KINDS[kind][1])) sc[y * W + x] = 10 + r;\n        }\n      const x = cl(cx + (hash(i * 11 + 7) \u003c 0.5 ? -(w >> 1) - 1 : (w >> 1) + 1), 1, W - 2);\n      const prev = old.find((c) => c.x === x && c.y === base);\n      S.candles.push(prev || { x, y: base, f: 1, out: false, wait: 0, sd: i * 97 + 5, h: max(1, round((3 + floor(hash(i * 7) * 2)) * sz)), sz });\n    }\n  }\n  for (let p = N - 1; p >= W; p--) if (sc[p] >= 10 && sc[p] \u003c 20 && sc[p - W] !== sc[p]) sc[p] += 10;\n  S.ng = n;\n}\n\n// Where the reaper is along a pass: in from the right, a slow drift across\n// the moon, and out to the left.\nfunction passX(a) {\n  if (a \u003c 0.18) return 104 - 54 * (1 - (1 - a / 0.18) ** 2);\n  if (a \u003c 0.75) return 50 - 18 * ((a - 0.18) / 0.57);\n  const b = (a - 0.75) / 0.25;\n  return 32 - 62 * b * b - 16 * b;\n}\n\nfunction swing(S, ds, tap) {\n  S.st += ds;\n  if (tap && (S.sw === \"rest\" || S.sw === \"back\")) (S.sw = \"wind\"), (S.st = 0), (S.from = S.phi);\n  if (S.sw === \"rest\") {\n    S.phi = REST + 0.25 * sin(S.st * 2.6);\n    if (S.st > TREST) (S.sw = \"wind\"), (S.st = 0), (S.from = S.phi);\n  } else if (S.sw === \"wind\") {\n    S.phi = S.from + (BACK - S.from) * sm(S.st / TW);\n    if (S.st > TW) (S.sw = \"strike\"), (S.st = 0), (S.glint = 0);\n  } else if (S.sw === \"strike\") {\n    const u = cl(S.st / TS, 0, 1);\n    S.phi = BACK + (END - BACK) * (u * u * (2 - u));\n    if (S.st > TS) (S.sw = \"follow\"), (S.st = 0);\n  } else if (S.sw === \"follow\") {\n    S.phi = END + 0.06 * sin(S.st * 20) * exp(-S.st * 8);\n    if (S.st > TF) (S.sw = \"back\"), (S.st = 0);\n  } else {\n    S.phi = END + (REST - END) * sm(S.st / TR);\n    if (S.st > TR) (S.sw = \"rest\"), (S.st = 0);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.fog = cl(k[3], 0, 1);\n  const ng = round(cl(k[2], 6, 30));\n  if (ng !== S.ng) graveyard(S, ng);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.pass += ds / PASS;\n  if (S.pass >= 1) S.pass -= 1;\n  // A sway and a bob on top of the drift: it never hangs still.\n  S.bx = passX(S.pass) + 5 * sin(S.t * 1.9);\n  S.by = 46 + 6 * sin(S.t * 2.2);\n  swing(S, ds, input.btnPressed && input.btnPressed[0]);\n  // A glint runs along the blade with every stroke, and now and then the\n  // moon catches it at rest.\n  if (S.glint >= 0) {\n    S.glint += ds / 0.45;\n    if (S.glint > 1.3) S.glint = -1;\n  } else if ((S.glintT -= ds) \u003c 0) (S.glint = 0), (S.glintT = 2.5 + 2 * hash(floor(S.t * 10)));\n  // Candles: a flame gutters as the hem comes near, goes out under the\n  // robe and lights again a moment after the reaper has passed.\n  for (const c of S.candles) {\n    const rel = c.x - S.bx;\n    if (!c.out) {\n      const tf = rel \u003c -26 || rel > 20 ? 1 : rel \u003c -14 ? (-14 - rel) / 12 : 0;\n      c.f += (tf - c.f) * min(1, ds * (tf \u003c c.f ? 5 : 2));\n      if (c.f \u003c 0.12) {\n        c.out = true;\n        c.f = 0;\n        c.wait = 0.6 + 1.2 * hash(c.sd + floor(S.t));\n        for (let i = 0; i \u003c 3; i++) S.smoke.push({ x: c.x, y: c.y - c.h - i, a: -0.15 * i, sd: c.sd + i });\n      }\n    } else if (rel > 18 || rel \u003c -44) {\n      if ((c.wait -= ds) \u003c 0) (c.out = false), (c.f = 1.7);\n    }\n    if (c.f > 1) c.f = max(1, c.f - ds * 2.5);\n  }\n  // Shreds of the hem tear off and blow away behind it.\n  for (let n = S.shredT + ds * 22; n >= 1; n--) {\n    const v = 44 + Math.random() * 14;\n    S.shreds.push({ x: S.bx + 15 + (v - 44) * 0.6 + Math.random() * 4, y: S.by + v, vx: 9 + Math.random() * 9, vy: -3 + Math.random() * 4, a: 0 });\n  }\n  S.shredT = (S.shredT + ds * 22) % 1;\n  let kept = 0;\n  for (const m of S.shreds) {\n    m.a += ds;\n    m.x += m.vx * ds;\n    m.y += m.vy * ds;\n    if (m.a \u003c 1.1 && m.x \u003c W + 2) S.shreds[kept++] = m;\n  }\n  S.shreds.length = kept;\n  // Smoke from a flame that went out rises and drifts off.\n  kept = 0;\n  for (const m of S.smoke) {\n    m.a += ds;\n    m.y -= ds * 7;\n    m.x += ds * (2 + 3 * vn(S.t + m.sd, m.sd));\n    if (m.a \u003c 1.6) S.smoke[kept++] = m;\n  }\n  S.smoke.length = kept;\n}\n\n// Sky, moon and horizon for one hue, in flat steps: deep purple overhead,\n// turning the short way round the wheel to the glow at the horizon, sickly\n// green at Hue 0. The moon is pale, with a hint of the glow.\nfunction background(S) {\n  if (S.bgKey === S.hue) return;\n  S.bgKey = S.hue;\n  const bg = S.bg, gh = 0.27 + S.hue, sky = [0, 0, 0], moon = hsv(gh - 0.1, 0.16, 0.95, [0, 0, 0]), sea = hsv(gh - 0.05, 0.2, 0.8, [0, 0, 0]);\n  let dh = gh - 0.76;\n  dh -= Math.round(dh);\n  for (let y = 0; y \u003c H; y++) {\n    const f = y \u003c 40 ? 0 : floor(min(1, pow((y - 40) / 74, 0.85)) * 11) / 11;\n    hsv(0.76 + dh * f, 0.62 + 0.04 * f, 0.2 + 0.46 * f, sky);\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n      for (let c = 0; c \u003c 3; c++) bg[o + c] = sky[c];\n      if (r \u003c MR) {\n        const s = vn(x * 0.3 + 3, 11) + vn(y * 0.27 + 7, 23) + 0.6 * vn((x + y) * 0.21, 5) > 0.75;\n        const t = r > MR - 1.2 ? 0.88 : 1;\n        for (let c = 0; c \u003c 3; c++) bg[o + c] = (s ? sea[c] : moon[c]) * t;\n      } else {\n        const g = r \u003c MR + 3 ? 0.2 : r \u003c MR + 7 ? 0.11 : r \u003c MR + 13 ? 0.05 : 0;\n        for (let c = 0; c \u003c 3; c++) bg[o + c] += moon[c] * g;\n      }\n    }\n  }\n}\n\n// The robe's spans on one row, in the reaper's frame, into SP as pairs;\n// returns how many. The hood's dark opening is FACE.\nconst SP = new Float32Array(32), FACE = [0, 0];\nfunction spans(v, t) {\n  FACE[0] = FACE[1] = 0;\n  if (v \u003c -22 || v > 64) return 0;\n  if (v \u003c -4) {\n    // The hood, its peak leaning back, and the opening in front.\n    const top = v \u003c -12 ? pow((v + 22) / 10, 0.7) : 1, cu = 1 + max(0, -12 - v) * 0.5, hw = 7.4 * top + (v > -8 ? (v + 8) * 0.6 : 0);\n    const fv = 1 - ((v + 10.5) / 4.6) ** 2;\n    if (fv > 0) (FACE[0] = -3 - 3.3 * sqrt(fv)), (FACE[1] = -3 + 3.3 * sqrt(fv));\n    SP[0] = cu - hw;\n    SP[1] = cu + hw;\n    return 1;\n  }\n  if (v \u003c 12) {\n    const hw = v \u003c 2 ? 8.5 + (v + 4) * 0.5 : 11.5 + (v - 2) * 0.05;\n    SP[0] = 1.5 - hw;\n    SP[1] = 1.5 + hw;\n    return 1;\n  }\n  // The skirt widens and leans back, its back edge rippling.\n  const cu = 1.5 + (v - 12) * 0.1, hw = 12 + (v - 12) * 0.12;\n  const back = (w) => cu + hw + (1.5 + 3 * ((w - 12) / 32)) * sin(w * 0.3 - t * 6.5);\n  if (v \u003c 44) {\n    SP[0] = cu - hw + 2 * sin(v * 0.25 - t * 5.5);\n    SP[1] = back(v);\n    return 1;\n  }\n  // Below the hem, eight tattered strips stream back and flutter.\n  const L = cu - hw + 2 * sin(44 * 0.25 - t * 5.5), R = back(44), wd = (R - L) / 8;\n  let n = 0;\n  for (let i = 0; i \u003c 8; i++) {\n    const len = 8 + 13 * hash(i * 13 + 1) + 3 * sin(t * 2.4 + i * 2.3), s = (v - 44) / len;\n    if (s > 1) continue;\n    const du = (v - 44) * 0.5 + sin(t * 9 + i * 1.9 - (v - 44) * 0.4) * 3.6 * s, c = L + (i + 0.5) * wd + du, w = wd * 0.62 * (1 - s) + 0.3;\n    SP[2 * n] = c - w;\n    SP[2 * n + 1] = c + w;\n    n++;\n  }\n  return n;\n}\n\n// A tapered capsule from (ax, ay) to (bx, by) into the mask, radius ra to rb.\nfunction capsule(mask, ox, oy, ax, ay, bx, by, ra, rb) {\n  const dx = bx - ax, dy = by - ay, l = dx * dx + dy * dy;\n  const x0 = max(0, floor(ox + min(ax, bx) - ra)), x1 = min(W - 1, ceil(ox + max(ax, bx) + ra)), y0 = max(0, floor(oy + min(ay, by) - ra)), y1 = min(H - 1, ceil(oy + max(ay, by) + ra));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5 - ox - ax, py = y + 0.5 - oy - ay, s = cl((px * dx + py * dy) / l, 0, 1);\n      if ((px - dx * s) ** 2 + (py - dy * s) ** 2 \u003c (ra + (rb - ra) * s) ** 2 && !mask[y * W + x]) mask[y * W + x] = 1;\n    }\n}\n\n// Neighbour steps, a point on the blade, and where along the blade the sweep runs.\nconst NB4 = [1, 0, -1, 0, 0, 1, 0, -1], BP = [0, 0], ALONG = [0.55, 0.8, 1];\n\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ng) return;\n  background(S);\n  const { buf, mask, bg, scene } = S, t = S.t, hs = S.hue;\n  buf.set(bg);\n  // The hill, dark, with its crest lit by the moon.\n  for (let p = 0; p \u003c N; p++) {\n    const m = scene[p];\n    if (!m) continue;\n    const o = p * 3;\n    if (m === 1) (buf[o] = 10), (buf[o + 1] = 7), (buf[o + 2] = 15);\n    else if (m === 2) (buf[o] = 50), (buf[o + 1] = 58), (buf[o + 2] = 60);\n    else {\n      // Stones: grey faces in the moonlight, dimmer row by row up the hill.\n      const f = 1 - 0.13 * (m % 10), lit = m >= 20 ? 2.05 : 1;\n      buf[o] = 44 * f * lit;\n      buf[o + 1] = 40 * f * lit;\n      buf[o + 2] = 58 * f * lit;\n    }\n  }\n  // Candles: a wax stub and a flame that leans and flickers, smaller up the hill.\n  for (const c of S.candles) {\n    for (let j = 0; j \u003c c.h; j++) put(buf, c.x, c.y - j, 196, 184, 160, 1);\n    if (c.out || c.f \u003c= 0.02) continue;\n    const fl = 0.75 + 0.25 * vn(t * 9 + c.sd, c.sd), gut = c.f \u003c 1 ? 1 + 2.5 * (1 - c.f) * vn(t * 23, c.sd + 3) : 0;\n    const f = c.f * fl, top = c.y - c.h, R = 7.5 * c.sz;\n    const ht = max(1, round((1 + 2.4 * f) * c.sz)), lean = round(gut + 0.3 * vn(t * 2, c.sd + 9));\n    // A warm light on whatever stands round it.\n    let st = S.stamps[c.sz];\n    if (!st) {\n      st = S.stamps[c.sz] = [];\n      for (let j = -floor(R); j \u003c= R; j++)\n        for (let i = -floor(R); i \u003c= R; i++) {\n          const r = sqrt(i * i + j * j * 1.4) / c.sz;\n          if (r \u003c 7.5) st.push(i, j, r \u003c 3 ? 0.3 : r \u003c 5.5 ? 0.17 : 0.08);\n        }\n    }\n    for (let q = 0; q \u003c st.length; q += 3) put(buf, c.x + st[q], top - 1 + st[q + 1], 255, 214, 120, f * st[q + 2]);\n    for (let j = 0; j \u003c ht; j++) {\n      const e = j / ht, x = c.x + round(lean * e);\n      if (j === 0) put(buf, x, top - j, 255, 244, 190, min(1, f + 0.3));\n      else put(buf, x, top - j, 255, 186 - 60 * e, 50, min(1, f));\n    }\n    if (c.f > 1.05) put(buf, c.x, top - ht, 255, 255, 230, 1);\n  }\n  for (const m of S.smoke) if (m.a >= 0) put(buf, m.x, m.y, 110, 104, 120, 0.6 * (1 - m.a / 1.6));\n\n  // The reaper: its robe by rows, then the arm and the sleeve hanging under it.\n  const bx = S.bx, by = S.by, phi = S.phi, ux = -sin(phi), uy = -cos(phi);\n  // The hand goes forward and down with the stroke and up for the wind-up.\n  const sg = (phi - REST) / (END - REST), gx = -12 - 4 * max(0, sg) + 3 * min(0, sg), gy = 8 + 4 * max(0, sg) + 6 * min(0, sg);\n  const y0 = max(0, floor(by - 23)), y1 = min(H - 1, floor(by + 66));\n  mask.fill(0, y0 * W, (y1 + 1) * W);\n  for (let y = y0; y \u003c= y1; y++) {\n    const n = spans(y + 0.5 - by, t);\n    for (let i = 0; i \u003c n; i++)\n      for (let x = max(0, ceil(bx + SP[2 * i] - 0.5)); x \u003c= min(W - 1, floor(bx + SP[2 * i + 1] - 0.5)); x++) mask[y * W + x] = 1;\n    if (FACE[1] > FACE[0])\n      for (let x = max(0, ceil(bx + FACE[0] - 0.5)); x \u003c= min(W - 1, floor(bx + FACE[1] - 0.5)); x++) mask[y * W + x] = 2;\n  }\n  capsule(mask, bx, by, -2, -1, gx + 1.5, gy - 0.5, 3.3, 2.5);\n  capsule(mask, bx, by, (gx - 2) * 0.55 + 1, gy * 0.55 + 1, gx + 3, gy + 6, 2.6, 1.2);\n  const robeC = [22, 15, 32], x0 = max(0, floor(bx - 24)), x1 = min(W - 1, ceil(bx + 36));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const p = y * W + x, m = mask[p];\n      if (!m) continue;\n      const o = p * 3;\n      if (m === 2) {\n        buf[o] = buf[o + 1] = buf[o + 2] = 0;\n        continue;\n      }\n      // Cloth, with a rim of the light behind it along its outline.\n      const edge = (x > 0 && !mask[p - 1]) || (x \u003c W - 1 && !mask[p + 1]) || (y > 0 && !mask[p - W]) || (y \u003c H - 1 && !mask[p + W]);\n      const a = edge ? 0.3 : 0;\n      for (let c = 0; c \u003c 3; c++) buf[o + c] = robeC[c] + (bg[o + c] - robeC[c]) * a;\n    }\n  // Shreds of cloth blowing off the hem, two LEDs wide, then one, then gone.\n  for (const m of S.shreds) {\n    const a = m.a \u003c 0.7 ? 0.9 : 0.9 * (1 - (m.a - 0.7) / 0.4);\n    put(buf, m.x - 0.5, m.y - 0.5, 22, 15, 32, a);\n    if (m.a \u003c 0.5) put(buf, m.x + 0.5, m.y - 0.5, 22, 15, 32, a);\n    if (m.a \u003c 0.25) put(buf, m.x - 0.5, m.y + 0.5, 22, 15, 32, a);\n  }\n  // The snath, dark wood.\n  const hx = bx + gx, hy = by + gy, tx = hx + ux * UP, ty = hy + uy * UP;\n  for (let s = -LO; s \u003c= UP; s += 0.4) put(buf, hx + ux * s - 0.5, hy + uy * s - 0.5, 34, 22, 16, 1);\n  // The blade: steel along its back, a bright edge on the inside of the curve.\n  const nx = cos(phi), ny = -sin(phi);\n  // A point s along the blade, f LEDs in from its back, into BP.\n  const bladeAt = (s, f) => {\n    BP[0] = tx + nx * BL * s - ux * CURL * BL * s * s - ux * f;\n    BP[1] = ty + ny * BL * s - uy * CURL * BL * s * s - uy * f;\n  };\n  for (let s = 0; s \u003c= 1; s += 0.025) {\n    bladeAt(s, 0);\n    put(buf, BP[0] - 0.5, BP[1] - 0.5, 120, 128, 146, 1);\n    if (s \u003c 0.88) {\n      bladeAt(s, 1);\n      put(buf, BP[0] - 0.5, BP[1] - 0.5, 196, 210, 228, 1);\n    }\n  }\n  // A sweep of pale light behind the outer half of the blade during the stroke.\n  if (S.sw === \"strike\" || (S.sw === \"follow\" && S.st \u003c 0.12)) {\n    const span = S.sw === \"strike\" ? min(1.6, (S.phi - BACK) * 0.9) : 1.2 * (1 - S.st / 0.12);\n    for (let a = 0.04; a \u003c span; a += 0.025) {\n      const q = phi - a, qx = -sin(q), qy = -cos(q), mx = cos(q), my = -sin(q);\n      for (const b of ALONG) {\n        const ex = hx + qx * UP + mx * BL * b - qx * CURL * BL * b * b, ey = hy + qy * UP + my * BL * b - qy * CURL * BL * b * b;\n        put(buf, ex - 0.5, ey - 0.5, 210, 255, 220, 0.6 * (1 - a / span));\n      }\n    }\n  }\n  // The glint, running along the edge, with a small star at its brightest.\n  if (S.glint >= 0 && S.glint \u003c= 1) {\n    bladeAt(S.glint, 1);\n    const gx2 = BP[0] - 0.5, gy2 = BP[1] - 0.5, b = sin(S.glint * PI);\n    put(buf, gx2, gy2, 255, 255, 255, 1);\n    for (let k = 0; k \u003c 8; k += 2) put(buf, gx2 + NB4[k], gy2 + NB4[k + 1], 255, 255, 255, 0.7 * b);\n    if (b > 0.8) for (let k = 0; k \u003c 8; k += 2) put(buf, gx2 + 2 * NB4[k], gy2 + 2 * NB4[k + 1], 255, 255, 255, 0.5);\n  }\n  // The bony hand on the snath.\n  put(buf, hx - 0.5, hy - 0.5, 206, 196, 172, 1);\n  put(buf, hx - 1.5, hy - 0.5, 176, 166, 146, 1);\n  put(buf, hx - 0.5, hy + 0.5, 176, 166, 146, 1);\n  // Two points of toxic green in the hood, flaring with the stroke.\n  const eye = hsv(0.3 + hs, 0.7, 1, S.e), flare = S.sw === \"strike\" || S.sw === \"follow\" ? 1 : 0.75 + 0.25 * vn(t * 6, 3);\n  for (const ex of [-4.6, -1.5]) {\n    const x = bx + ex, y = by - 10.5;\n    put(buf, x - 0.5, y - 0.5, eye[0], eye[1], eye[2], flare);\n    for (let k = 0; k \u003c 8; k += 2) put(buf, x - 0.5 + NB4[k], y - 0.5 + NB4[k + 1], eye[0], eye[1], eye[2], 0.28 * flare);\n  }\n\n  // Fog over the ground, rolling slowly to the right: one noise across the\n  // panel and another for each band of eight rows.\n  if (S.fog > 0) {\n    const fc = hsv(0.76 + hs, 0.22, 0.6, S.c), topY = 108 - 40 * S.fog, a0 = 0.18 + 0.4 * S.fog, FN = S.fn;\n    for (let x = 0; x \u003c W; x++) FN[x] = vn(x * 0.08 - t * 0.9, 41);\n    for (let y = max(0, floor(topY)); y \u003c H; y++) {\n      const ramp = min(1, (y - topY) / 14), band = y >> 3;\n      if ((y & 7) === 0 || y === floor(topY)) for (let x = 0; x \u003c W; x++) FN[W + x] = 0.6 * vn(x * 0.19 - t * 1.6, 43 + band);\n      for (let x = 0; x \u003c W; x++) {\n        const a = a0 * ramp * cl(0.55 + 0.5 * (FN[x] + FN[W + x]), 0, 1);\n        if (a \u003c 0.03) continue;\n        const o = (y * W + x) * 3, q = round(a * 8) / 8;\n        for (let c = 0; c \u003c 3; c++) buf[o + c] += (fc[c] - buf[o + c]) * q;\n      }\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n}\n","headless-rider":"// ===== Patternflow pattern =====\n// Title:   Headless Rider\n// Family:  halloween\n// Idea:    A headless horseman gallops across a huge low moon in black silhouette, the horse gathering and reaching through a four-beat gallop that kicks dust and sparks off the road, cape streaming and a burning jack-o'-lantern held high, while trees, gravestones and a fence slide past, and now and then he hurls the pumpkin in a flaming arc that bursts on the road ahead.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Woods=0..1, Mist=0..1\n//\n// Knob 1: Hue. Tints the sky, the far hills and the mist; moon, pumpkin and fire keep their colours. At 0 a violet night, mauve at the horizon; at 0.25 blood red, at 0.5 a sickly olive, at 0.75 teal, at 0.9 deep blue.\n// Knob 2: Speed. At 2 the horse takes 1.3 strides a second, the road runs past at 44 LEDs a second, the trees at 13 and the hills at 4, and he throws every 9 s, the first at 3.2 s, the pumpkin 3 s in the air; at 0.2 all ten times slower, at 3 half as fast again.\n// Knob 3: Woods. How many of the 14-LED slots along the horizon hold a tree: one in five at 0, a tree about every 5 s at Speed 2 with gravestones between; more than half at 0.5; nearly all at 1, a wood the moon shows through in pieces.\n// Knob 4: Mist. At 0 none, at 0.06 thin wisps on the horizon, at 0.5 a moonlit bank on the road round the hooves drifting back faster than the road, at 1 up to the horse's belly so the legs gallop half seen.\n// Buttons: K1 tap throws the pumpkin at once, or lights a new one if his hand is empty.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\n// The stage, top to bottom: sky and moon, the horizon the trees stand on,\n// the road the hooves strike at GY, the verge with the near fence.\nconst HZ = 99, RD0 = 100, RD1 = 108, GY = 104;\nconst MX = 26, MY = 70, MR = 24;\n// The moon's tone (1 limb, 2 sea, 3 bright) and its glow in stepped rings.\nconst MOONT = new Uint8Array(N), GLOW = new Float32Array(N);\nconst SEAS = [[-7, -6, 6, 5], [5, -9, 5, 4], [-3, 6, 8, 4], [9, 5, 4, 5]];\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR) MOONT[p] = r > MR - 1.2 ? 1 : SEAS.some(([cx, cy, rx, ry]) => ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 \u003c 1) ? 2 : 3;\n  else GLOW[p] = r \u003c MR + 3 ? 0.3 : r \u003c MR + 8 ? 0.17 : r \u003c MR + 15 ? 0.08 : r \u003c MR + 26 ? 0.035 : 0;\n}\nconst MOONC = [0, [232, 216, 180], [228, 216, 188], [252, 240, 204]];\nconst STARS = [];\nfor (let i = 0; i \u003c 400 && STARS.length \u003c 26; i++) {\n  const x = floor(hash(i * 3 + 1) * W), y = floor(hash(i * 3 + 2) * 62);\n  if (GLOW[y * W + x] === 0 && !MOONT[y * W + x]) STARS.push([x, y, hash(i * 3 + 3) * TAU]);\n}\n\n// A seeded sequence for the scenery, so it is the same every time.\nlet sd = 48;\nconst rng = () => hash(sd++ * 31);\n// Fills a capsule, radius r0 at one end and r1 at the other, into a mask.\nfunction stamp(m, mw, mh, x0, y0, r0, x1, y1, r1, code) {\n  const xa = max(0, floor(min(x0 - r0, x1 - r1))), xb = min(mw - 1, ceil(max(x0 + r0, x1 + r1)));\n  const ya = max(0, floor(min(y0 - r0, y1 - r1))), yb = min(mh - 1, ceil(max(y0 + r0, y1 + r1)));\n  const dx = x1 - x0, dy = y1 - y0, l2 = dx * dx + dy * dy || 1e-9;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * dx + py * dy) / l2, 0, 1);\n      const ex = px - dx * t, ey = py - dy * t, r = r0 + (r1 - r0) * t;\n      if (ex * ex + ey * ey \u003c= r * r && m[y * mw + x] \u003c code) m[y * mw + x] = code;\n    }\n}\n// Bare trees: a crooked trunk forking four times into twigs.\nconst TW = 44, TH = 96, NT = 6, TREES = [];\nfunction limb(m, x, y, a, len, w, depth) {\n  for (let i = 0, n = max(2, ceil(len / 2)); i \u003c n; i++) {\n    a += (rng() - 0.5) * 0.4;\n    const nx = x + 2 * sin(a), ny = y - 2 * cos(a), r = max(0.45, w * (1 - (0.35 * i) / n));\n    stamp(m, TW, TH, x, y, r, nx, ny, r, 1);\n    (x = nx), (y = ny);\n  }\n  if (depth \u003c= 0) return;\n  const k = depth > 2 ? 2 : 2 + (rng() \u003c 0.5 ? 1 : 0);\n  for (let j = 0; j \u003c k; j++) limb(m, x, y, a + (j - (k - 1) / 2) * (0.55 + rng() * 0.5) + (rng() - 0.5) * 0.3, len * (0.55 + rng() * 0.25), w * 0.62, depth - 1);\n}\n// Each kept as the list of its lit LEDs, column then row.\nfor (let i = 0; i \u003c NT; i++) {\n  const m = new Uint8Array(TW * TH), l = [];\n  limb(m, TW / 2, TH - 1, (rng() - 0.5) * 0.25, (54 + rng() * 34) * 0.36, 2.2 + rng() * 0.6, 4);\n  m.forEach((v, p) => v && l.push(p % TW, floor(p / TW)));\n  TREES.push(Int16Array.from(l));\n}\nconst TREEC = [26, 10, 36], FARLEG = [30, 12, 40];\n// The road's crown, ruts and dust; the verge's tufts and soil.\nconst GROUND = [92, 78, 108, 44, 34, 58, 66, 54, 82, 46, 30, 60, 24, 12, 34, 16, 8, 24];\nconst STONES = [[\".xxx.\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\"], [\"..x..\", \"xxxxx\", \"..x..\", \"..x..\", \"..x..\", \"..x..\"], [\".xx.\", \"xxxx\", \"xxxx\", \"xxxx\", \"xxxx\"]];\n// Mist: a sheet of value noise, long bands across short ones.\nconst FW = 256, FH = 32, FN = new Float32Array(FW * FH);\nfor (let p = 0; p \u003c FW * FH; p++) FN[p] = 0.5 + 0.32 * vn((p % FW) / 14 + (p >> 10) * 0.3, p >> 10) + 0.18 * vn((p % FW) / 5, (p >> 8) + 99);\n\n// The gallop. A hoof is down for DUTY of a stride, landing REACH LEDs ahead\n// of its leg's top joint and leaving BACK behind, so the road runs back\n// (REACH + BACK) / DUTY = 34 LEDs a stride and a planted hoof never slides.\n// A transverse gallop's four beats: near hind, far hind, near fore, far\n// fore, then all four off the ground, gathered under the belly.\n// [joint x, joint y in the body, landing phase, far, fore]\nconst DUTY = 0.38, REACH = 7, BACK = 6, STRIDE = (REACH + BACK) / DUTY, L1 = 11, L2 = 14, RATE = 1.3;\nconst LEGS = [[-10, 2.5, 0, 0, 0], [-10, 2.5, 0.11, 1, 0], [10, 3, 0.38, 0, 1], [10, 3, 0.49, 1, 1]];\nconst BX = 29, BY = 76, PK = 4.6;\n// The throwing arm [shoulder, elbow], radians from straight up, forward\n// positive: held high, cocked back, the release, hanging empty.\nconst HOLD = [0.35, 0.1], COCK = [-0.85, -0.5], LET = [1.05, 0.15], REST = [2.3, -0.5];\n// Times in seconds at Speed 2.\nconst THROW_EVERY = 9, FIRST = 3.2, T_COCK = 0.35, T_SWING = 0.15, T_RELIGHT = 1.5, T_GROW = 0.55;\n// Particles, six numbers each (x, y, vx, vy, life left, life) and a kind:\n// 0 flame, 1 spark, 2 dust.\nconst MAXP = 600;\n\nexport function setup(params) {\n  params.s = {\n    hue: -1, hue0: -2, speed: 2, woods: 0, mist: 0.06, t: 0, ph: 0, g: 0, bob: 0, pitch: 0, neck: 0, eye: [0, 0],\n    state: 0, st: 0, next: FIRST, pk: 1, arm: HOLD.slice(), arm0: HOLD.slice(), fly: null, fires: [],\n    A: new Float32Array(MAXP * 6), K: new Uint8Array(MAXP), np: 0,\n    buf: new Float32Array(N * 3), mask: new Uint8Array(N), bg: new Float32Array(N * 3), far: [0, 0, 0], fog: [0, 0, 0], c: [0, 0, 0],\n  };\n}\n\nfunction spawn(S, x, y, vx, vy, life, kind) {\n  if (S.np >= MAXP) return;\n  S.A.set([x, y, vx, vy, life, life], S.np * 6);\n  S.K[S.np++] = kind;\n}\n\n// A point of the horse's body on the panel, bobbing and pitching about\n// the middle of the barrel.\nfunction bodyPt(S, x, y, out, o) {\n  const c = cos(S.pitch), s = sin(S.pitch);\n  out[o] = BX + x * c - y * s;\n  out[o + 1] = BY + S.bob + x * s + y * c;\n}\nconst P = new Float32Array(4), HAND = new Float32Array(6), F = new Float32Array(2);\n\n// Shoulder, elbow and hand of the throwing arm.\nfunction hand(S) {\n  bodyPt(S, 4, -20, HAND, 0);\n  const a = S.arm[0] + S.pitch * 0.5, b = a + S.arm[1];\n  HAND[2] = HAND[0] + 7.5 * sin(a);\n  HAND[3] = HAND[1] - 7.5 * cos(a);\n  HAND[4] = HAND[2] + 7.5 * sin(b);\n  HAND[5] = HAND[3] - 7.5 * cos(b);\n}\n\n// A hoof at phase u after it landed, from its leg's top joint (jx, jy).\nfunction foot(u, fore, jx) {\n  if (u \u003c DUTY) (F[0] = jx + REACH - (REACH + BACK) * (u / DUTY)), (F[1] = GY);\n  else {\n    const s = (u - DUTY) / (1 - DUTY);\n    F[0] = jx - BACK + (REACH + BACK) * (0.5 - 0.5 * cos(PI * s));\n    // A foreleg folds its hoof up towards the elbow, a hind leg less.\n    F[1] = GY - (fore ? 13 : 9) * sin(PI * s) ** 0.8;\n  }\n}\n\nconst ease = (a, b, t) => a + (b - a) * (t * t * (3 - 2 * t));\nconst toward = (S, to, t) => (S.arm = [ease(S.arm0[0], to[0], t), ease(S.arm0[1], to[1], t)]);\nconst go = (S, st) => ((S.state = st), (S.st = 0), (S.arm0 = S.arm.slice()));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.woods, S.mist] = [cl(k[0], 0, 1), cl(k[1], 0.2, 3), cl(k[2], 0, 1), cl(k[3], 0, 1)];\n  const ds = (d * S.speed) / 2, V = STRIDE * RATE, ph0 = S.ph;\n  S.t += ds;\n  S.ph += ds * RATE;\n  S.g = S.ph * STRIDE;\n  // The body: lowest mid-stance, highest in the gathered moment, nose up as\n  // the hind legs land and down as the fore legs take the weight.\n  const a = TAU * S.ph;\n  S.bob = 1.2 * cos(a - TAU * 0.45);\n  S.pitch = -0.055 * cos(a - TAU * 0.1);\n  S.neck = 0.13 * cos(a - TAU * 0.62);\n  // A hoof landing kicks up dust, and now and then sparks off a stone.\n  for (const [jx, jy, off] of LEGS) {\n    if (floor(ph0 - off) === floor(S.ph - off)) continue;\n    bodyPt(S, jx, jy, P, 0);\n    foot(0, 0, P[0]);\n    for (let i = 0; i \u003c 3; i++) spawn(S, F[0] + rnd(-1, 1), GY + rnd(-1, 1), -V * rnd(0.8, 1), -rnd(4, 14), rnd(0.5, 0.9), 2);\n    if (Math.random() \u003c 0.4) for (let i = 0; i \u003c 3; i++) spawn(S, F[0], GY - 1, -V + rnd(-20, 25), -rnd(20, 48), rnd(0.25, 0.5), 1);\n  }\n  // The pumpkin: held, cocked back, swung, let go; the hand hangs empty,\n  // rises, and a new one catches light in it.\n  const tap = input.btnPressed && input.btnPressed[0];\n  S.st += ds;\n  if (S.state === 0) {\n    if ((S.next -= ds) \u003c= 0 || tap) go(S, 1);\n  } else if (S.state === 1) {\n    toward(S, COCK, min(1, S.st / T_COCK));\n    if (S.st >= T_COCK) go(S, 2);\n  } else if (S.state === 2) {\n    toward(S, LET, min(1, S.st / T_SWING));\n    if (S.st >= T_SWING) {\n      hand(S);\n      // Up and a little ahead: the top of the arc near the top of the panel,\n      // down on the road just ahead of the horse 3 s later.\n      S.fly = { x: HAND[4] + 0.5, y: HAND[5] - PK, vx: 6.5, vy: -58, spin: 0 };\n      S.pk = 0;\n      go(S, 3);\n    }\n  } else if (S.state === 3) {\n    toward(S, REST, min(1, S.st / 0.45));\n    if (S.st > T_RELIGHT || tap) go(S, 4);\n  } else {\n    toward(S, HOLD, min(1, S.st / 0.4));\n    S.pk = cl((S.st - 0.3) / T_GROW, 0, 1);\n    if (S.st > 0.3 + T_GROW) (S.state = 0), (S.next = THROW_EVERY);\n  }\n  // Flames stream back off the pumpkin in the rush of air.\n  const drift = -0.45 * V - 12;\n  if (S.pk > 0 || S.state === 4) {\n    hand(S);\n    const r = PK * S.pk;\n    for (let i = 0; i \u003c 1 + S.pk * 3; i++) spawn(S, HAND[4] + rnd(-r, r) * 0.6, HAND[5] - 2 * r + rnd(-1, 1), drift * rnd(0.6, 1.1), -rnd(11, 23), rnd(0.15, 0.32), 0);\n  }\n  if (S.fly) {\n    const f = S.fly;\n    f.vy += 52 * ds;\n    f.x += f.vx * ds;\n    f.y += f.vy * ds;\n    f.spin += ds * 5;\n    for (let i = 0; i \u003c 4; i++) spawn(S, f.x + rnd(-2, 2), f.y + rnd(-2, 2), drift * rnd(0.7, 1.2) - V * 0.3, rnd(-14, 4), rnd(0.25, 0.55), 0);\n    if (f.y >= GY - 3) {\n      // It bursts on the road, which carries the fire back past the horse.\n      S.fires.push({ x: f.x, t: 0 });\n      for (let i = 0; i \u003c 18; i++) spawn(S, f.x, GY - 2, -V + rnd(-40, 40), -rnd(15, 60), rnd(0.4, 0.9), 1);\n      S.fly = null;\n    }\n  }\n  S.fires = S.fires.filter((fi) => {\n    fi.x -= V * ds;\n    fi.t += ds;\n    if (fi.t \u003c 1.6) for (let i = 0; i \u003c 3; i++) spawn(S, fi.x + rnd(-3, 3), GY - 1, -V + drift * 0.3, -rnd(15, 35), rnd(0.2, 0.45), 0);\n    return fi.x > -10;\n  });\n  // Particles: flames rise and thin, sparks fall and bounce, dust settles.\n  const A = S.A;\n  let j = 0;\n  for (let i = 0; i \u003c S.np; i++) {\n    const o = i * 6, kind = S.K[i];\n    if ((A[o + 4] -= ds) \u003c= 0) continue;\n    if (kind === 1) A[o + 3] += 140 * ds;\n    else if (kind === 2) A[o + 3] *= 1 - ds * 2;\n    A[o] += A[o + 2] * ds;\n    A[o + 1] += A[o + 3] * ds;\n    if (kind === 1 && A[o + 1] > GY + 1) (A[o + 1] = GY + 1), (A[o + 3] *= -0.3), (A[o + 2] = -V);\n    if (A[o] \u003c -4 || A[o] > W + 6 || A[o + 1] \u003c -4) continue;\n    if (j !== i) A.copyWithin(j * 6, o, o + 6), (S.K[j] = kind);\n    j++;\n  }\n  S.np = j;\n}\n\n// The sky with the moon and its glow, the far hills and the mist for a\n// hue, once each time it changes.\nfunction palette(S) {\n  const h = 0.75 + S.hue, c = S.c;\n  for (let p = 0; p \u003c (HZ + 1) * W; p++) {\n    const y = floor(p / W), t = min(1, floor((y / HZ) * 10) / 9), gl = GLOW[p];\n    if (MOONT[p]) S.bg.set(MOONC[MOONT[p]], p * 3);\n    else hsv(h - 0.04 * t, 0.8 - 0.25 * t, 0.12 + 0.3 * t, c), S.bg.set([c[0] + 240 * gl, c[1] + 220 * gl, c[2] + 190 * gl], p * 3);\n  }\n  hsv(h - 0.02, 0.55, 0.26, S.far);\n  hsv(h - 0.05, 0.3, 0.8, S.fog);\n}\n\nfunction put(buf, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  buf[o] += (r - buf[o]) * a;\n  buf[o + 1] += (g - buf[o + 1]) * a;\n  buf[o + 2] += (b - buf[o + 2]) * a;\n}\n\n// Horse and rider into the mask: 2 black, 1 the far legs, a shade lighter.\nfunction figure(S, m) {\n  m.fill(0);\n  const cap = (x0, y0, r0, x1, y1, r1, code = 2) => stamp(m, W, H, x0, y0, r0, x1, y1, r1, code);\n  const bc = (x0, y0, r0, x1, y1, r1) => {\n    bodyPt(S, x0, y0, P, 0);\n    bodyPt(S, x1, y1, P, 2);\n    cap(P[0], P[1], r0, P[2], P[3], r1);\n  };\n  // Legs, far ones first, two bones each: forearm and cannon in front, the\n  // knee bending forward; gaskin and cannon behind, the hock bending back.\n  for (const [jx, jy, off, far, fore] of LEGS) {\n    bodyPt(S, jx, jy, P, 0);\n    const x0 = P[0], y0 = P[1];\n    foot(S.ph - off - floor(S.ph - off), fore, x0);\n    let dx = F[0] - x0, dy = F[1] - y0;\n    const dd = sqrt(dx * dx + dy * dy), dm = min(L1 + L2 - 0.05, max(abs(L1 - L2) + 0.5, dd));\n    (dx /= dd), (dy /= dd);\n    const fx = x0 + dx * dm, fy = y0 + dy * dm, ca = (L1 * L1 + dm * dm - L2 * L2) / (2 * L1 * dm), sa = sqrt(max(0, 1 - ca * ca)), sg = fore ? -1 : 1;\n    const kx = x0 + L1 * (dx * ca - sg * dy * sa), ky = y0 + L1 * (dy * ca + sg * dx * sa), code = far ? 1 : 2;\n    cap(x0, y0, fore ? 2.6 : 3.2, kx, ky, 1.4, code);\n    cap(kx, ky, 1.2, fx, fy, 0.9, code);\n    cap(fx, fy - 0.5, 1.3, fx + 0.8, fy, 1.2, code);\n  }\n  // The tail streaming back.\n  let tx = -14, ty = -4;\n  for (let i = 1; i \u003c= 6; i++) {\n    const nx = -14 - 2.3 * i, ny = -4 + 0.75 * i + sin(S.t * 9 - i * 0.9) * i * 0.2;\n    bc(tx, ty, 2.4 - 0.25 * i, nx, ny, 2.2 - 0.25 * i);\n    (tx = nx), (ty = ny);\n  }\n  // Barrel, chest, quarters and withers.\n  bc(-9, -0.5, 6, 8, 0, 6);\n  bc(10, -1, 6.2, 10, -1, 6.2);\n  bc(-10, -2, 6.6, -10, -2, 6.6);\n  bc(6, -6, 2.6, 8, -6, 2.6);\n  // Neck and head nod with the stride; the mane flies back.\n  const nc = cos(S.neck), ns = sin(S.neck), nk = (x, y) => [11 + (x - 11) * nc - (y + 2) * ns, -2 + (x - 11) * ns + (y + 2) * nc];\n  const [n1x, n1y] = nk(18, -12), [h1x, h1y] = nk(25, -5), [e1x, e1y] = nk(17, -16);\n  S.eye = nk(20, -10.5);\n  bc(11, -2, 5, n1x, n1y, 3);\n  bc(n1x, n1y, 2.9, h1x, h1y, 1.7);\n  bc(n1x - 0.5, n1y - 1, 0.8, e1x, e1y, 0.5);\n  for (let i = 0; i \u003c 5; i++) {\n    const [mx, my] = nk(11.5 + i * 1.4, -6.5 - i * 1.4);\n    bc(mx, my, 0.7, mx - 3.5, my + 0.5 + sin(S.t * 11 + i) * 0.8, 0.4);\n  }\n  // The rider: seat, a torso leaning into the gallop, broad shoulders, no head.\n  bc(-1, -8, 3.3, 3, -20, 3.8);\n  bc(0, -20.5, 2.5, 5.5, -20, 2.3);\n  bc(2, -22.8, 1.1, 3.6, -22.6, 1.1);\n  bc(-1, -7, 2.2, 5, -3, 1.8);\n  bc(5, -3, 1.4, 4.2, 4, 1.2);\n  bc(4.2, 4, 1.4, 6, 4.4, 1.1);\n  // The rein arm, and the reins to the bit.\n  bc(4, -19, 1.5, 7.5, -13, 1.3);\n  bc(7.5, -13, 1.3, 11.5, -10.5, 1.1);\n  bodyPt(S, 11.5, -10.5, P, 0);\n  bodyPt(S, h1x - 1, h1y + 0.5, P, 2);\n  cap(P[0], P[1], 0.45, P[2], P[3], 0.45);\n  hand(S);\n  cap(HAND[0], HAND[1], 1.6, HAND[2], HAND[3], 1.3);\n  cap(HAND[2], HAND[3], 1.3, HAND[4], HAND[5], 1.1);\n  // The cape, from the shoulders back on the wind, rippling, ragged at the hem.\n  bodyPt(S, 2, -20, P, 0);\n  const ax = P[0], ay = P[1], len = 27;\n  for (let x = floor(ax); x >= max(0, ax - len); x--) {\n    const t = (ax - x) / len, cy = ay + 4.5 * t * t + 1.5 * t + sin(TAU * (t * 1.2 - S.t * 1.7)) * 2.1 * t;\n    let hw = 1.3 + 5 * t;\n    if (t > 0.8) hw -= hash(x * 7 + floor(S.t * 6)) * 15 * (t - 0.8);\n    for (let y = max(0, round(cy - hw)); y \u003c= min(H - 1, round(cy + hw * 0.9)); y++) m[y * W + x] = 2;\n  }\n}\n\nconst RIBS = [[255, 168, 40], [255, 128, 16], [226, 92, 8]];\nfunction pumpkin(S, buf, cx, cy, k, sp) {\n  const r = PK * k;\n  if (r \u003c 0.6) return;\n  const fl = 0.78 + 0.22 * (0.5 + 0.5 * vn(S.t * 11, 3)) * (0.7 + 0.3 * vn(S.t * 3, 9));\n  // A glow round it, in steps.\n  for (let y = floor(cy - r - 9); y \u003c= cy + r + 9; y++)\n    for (let x = floor(cx - r - 9); x \u003c= cx + r + 9; x++) {\n      const e = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2) - r;\n      if (e > 0 && e \u003c 9) put(buf, x, y, 255, 120, 20, (e \u003c 2 ? 0.34 : e \u003c 5 ? 0.18 : 0.07) * fl);\n    }\n  for (let y = floor(cy - r - 1); y \u003c= cy + r; y++)\n    for (let x = floor(cx - r * 1.15 - 1); x \u003c= cx + r * 1.15; x++) {\n      const u = (x + 0.5 - cx) / (r * 1.15), v = (y + 0.5 - cy) / r;\n      if (u * u + v * v > 1) continue;\n      // Ribs in three bright tones, and the carved face lit from inside.\n      const rib = abs(sin((u + sp) * 4.2)), fu = u / 0.9;\n      const eye = v > -0.5 && v \u003c -0.05 && abs(abs(fu) - 0.42) \u003c (0.3 * (v + 0.55)) / 0.5;\n      const mouth = v > 0.2 && v \u003c 0.62 && abs(fu) \u003c 0.62 - (v - 0.2) * 0.5 && !(v \u003c 0.4 && abs(fu) > 0.1 && abs(fu) \u003c 0.3);\n      if (k > 0.7 && (eye || mouth)) put(buf, x, y, 255 * fl, 236 * fl, 120 * fl, 1);\n      else {\n        const c = RIBS[rib > 0.75 ? 0 : rib > 0.3 ? 1 : 2];\n        put(buf, x, y, c[0], c[1], c[2], 1);\n      }\n    }\n  put(buf, cx - 0.5, cy - r - 1, 60, 170, 40, 1);\n}\n\n// Mist from row y0 to y1, drifting by sp: at most `a` of it, thickest at\n// row yc and thinning over wd rows either side.\nfunction mist(S, buf, y0, y1, yc, wd, a, sp, row) {\n  const fog = S.fog;\n  for (let y = max(0, y0); y \u003c min(H, y1); y++) {\n    const band = exp(-(((y - yc) / wd) ** 2)), fj = (y + row) % FH;\n    for (let x = 0; x \u003c W; x++) {\n      const n = FN[fj * FW + (((floor((x + sp) * 0.5) % FW) + FW) % FW)], v = band * cl((n - 0.2) * 1.8, 0, 1) * a;\n      if (v > 0.03) put(buf, x, y, fog[0], fog[1], fog[2], round(v * 12) / 12);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.hue !== S.hue0) (S.hue0 = S.hue), palette(S);\n  const buf = S.buf, far = S.far, g = S.g, A = S.A;\n  buf.set(S.bg);\n  for (const [x, y, ph] of STARS) {\n    const v = sin(S.t * 2.3 + ph) > 0.2 ? 200 : 110;\n    put(buf, x, y, v, v, v + 30, 1);\n  }\n  // Far hills, slow, with a ragged line of tiny trees.\n  for (let x = 0; x \u003c W; x++) {\n    const wx = x + g * 0.1, top = HZ - 5 - 3 * vn(wx / 17, 11) - 1.5 * vn(wx / 6, 12) - (hash(floor(wx / 3) * 5 + 1) \u003c 0.25 ? 3 : 0);\n    for (let y = round(top); y \u003c= HZ; y++) put(buf, x, y, far[0], far[1], far[2], 1);\n  }\n  // Trees and gravestones on the horizon, in slots of 14 LEDs.\n  const mo = g * 0.3, pT = 0.2 + 0.72 * S.woods;\n  for (let sl = floor((mo - TW) / 14); sl \u003c= floor((mo + W + TW) / 14); sl++) {\n    const sx = sl * 14 - mo + hash(sl * 3 + 3) * 6;\n    if (hash(sl * 3 + 1) \u003c pT) {\n      const l = TREES[floor(hash(sl * 3 + 2) * NT)], flip = hash(sl * 3 + 4) \u003c 0.5, x0 = round(sx - TW / 2);\n      for (let i = 0; i \u003c l.length; i += 2) {\n        const x = x0 + (flip ? TW - 1 - l[i] : l[i]), y = HZ + 1 - TH + l[i + 1];\n        if (x >= 0 && x \u003c W && y >= 0) buf.set(TREEC, (y * W + x) * 3);\n      }\n    } else if (hash(sl * 5 + 7) \u003c 0.55) {\n      const st = STONES[floor(hash(sl * 5 + 8) * 3)];\n      for (let j = 0; j \u003c st.length; j++)\n        for (let i = 0; i \u003c st[j].length; i++) if (st[j][i] === \"x\") put(buf, sx + i, HZ - st.length + 1 + j, j ? 52 : 104, j ? 42 : 92, j ? 68 : 124, 1);\n    }\n  }\n  // The road, its ruts running back, and the dark verge with grass tufts.\n  for (let y = RD0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const gx = floor(x + g * 1.15), o = (y * W + x) * 3;\n      const k = 3 * (y \u003c RD1 ? (y === RD0 ? 0 : (y === 102 || y === 105) && hash(floor(x + g) * 3 + y) \u003c 0.35 ? 1 : 2) : hash(gx * 13) \u003c 0.3 && y - RD1 \u003c 1 + floor(hash(gx * 7) * 4) ? 3 : y \u003c 116 ? 4 : 5);\n      (buf[o] = GROUND[k]), (buf[o + 1] = GROUND[k + 1]), (buf[o + 2] = GROUND[k + 2]);\n    }\n  // Wisps along the horizon, a little thicker with the mist.\n  mist(S, buf, 84, RD1, 99, 7, 0.25 + 0.45 * S.mist, g * 0.6, 0);\n  // Dust behind the figure.\n  for (let i = 0; i \u003c S.np; i++) if (S.K[i] === 2) put(buf, A[i * 6], A[i * 6 + 1], 140, 124, 160, (A[i * 6 + 4] / A[i * 6 + 5]) * 0.75);\n  // Horse and rider: black, rimmed with moonlight where they meet the moon.\n  const m = S.mask;\n  figure(S, m);\n  for (let p = 0; p \u003c N; p++) {\n    const c = m[p], o = p * 3;\n    if (!c) continue;\n    if (c === 1) {\n      buf.set(FARLEG, o);\n      continue;\n    }\n    // The brightest open neighbour lights the rim, if it is moonlight.\n    let q = -1, best = 300;\n    for (let s = 0; s \u003c 4; s++) {\n      const n = s === 0 ? p - 1 : s === 1 ? p + 1 : s === 2 ? p - W : p + W;\n      if (n >= 0 && n \u003c N && !m[n] && buf[n * 3] + buf[n * 3 + 1] > best) (best = buf[n * 3] + buf[n * 3 + 1]), (q = n * 3);\n    }\n    if (q \u003c 0) (buf[o] = 3), (buf[o + 1] = 1), (buf[o + 2] = 6);\n    else (buf[o] = buf[q] * 0.42), (buf[o + 1] = buf[q + 1] * 0.42), (buf[o + 2] = buf[q + 2] * 0.42);\n  }\n  // The horse's eye, a coal.\n  bodyPt(S, S.eye[0], S.eye[1], P, 0);\n  put(buf, P[0] - 0.5, P[1] - 0.5, 255, 110, 30, 1);\n  // The pumpkin in his hand, or in flight.\n  if (S.pk > 0) {\n    hand(S);\n    pumpkin(S, buf, HAND[4] + 0.5, HAND[5] - PK * S.pk + 0.5, S.pk, 0);\n  }\n  if (S.fly) pumpkin(S, buf, S.fly.x, S.fly.y, 1, S.fly.spin);\n  // Flames yellow to orange to red, sparks white-gold.\n  for (let i = 0; i \u003c S.np; i++) {\n    const o = i * 6, a = 1 - A[o + 4] / A[o + 5], kind = S.K[i];\n    if (kind === 0) {\n      if (a \u003c 0.3) put(buf, A[o], A[o + 1], 255, 236, 130, 1);\n      else if (a \u003c 0.65) put(buf, A[o], A[o + 1], 255, 146, 24, 1);\n      else put(buf, A[o], A[o + 1], 236, 64, 18, 1.4 - a);\n    } else if (kind === 1) put(buf, A[o], A[o + 1], 255, 226, 150, 1);\n  }\n  // Mist in front: up to the knees at half, the belly at 1, drifting back\n  // faster than the road.\n  if (S.mist > 0.1) mist(S, buf, 70, H, GY + 12 - 18 * S.mist, 5 + 12 * S.mist, 0.35 + 0.65 * S.mist, g * 1.3 + S.t * 8, 11);\n  // The near fence, fastest of all, moonlit on its left.\n  for (let x = 0; x \u003c W; x++) {\n    const px = (((x + g * 1.15) % 40) + 40) % 40;\n    if (px \u003c 3) for (let y = 109; y \u003c H; y++) put(buf, x, y, px \u003c 1 ? 92 : 54, px \u003c 1 ? 84 : 46, px \u003c 1 ? 110 : 68, 1);\n    else for (const y of [112, 119]) put(buf, x, y, 84, 74, 100, 1);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] / 4) * 4), min(255, round(buf[o + 1] / 4) * 4), min(255, round(buf[o + 2] / 4) * 4));\n}\n","mobius-energy":"// ===== Patternflow pattern =====\n// Title:   Möbius Energy\n// Family:  topology\n// Idea:    A knotted tube, crumpled by wringing the space around it, relaxes under the gradient flow of the Möbius energy, which blows up where strands approach, so it untangles only as far as its knot type allows: an unknot opens into a circle, a trefoil into its three-lobed shape, and a trace below logs the energy falling.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Möbius energy of knots (Jun O'Hara, 1991; Michael Freedman, Zheng-Xu He and Zhenghan Wang, 1994), pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knot=0..4, Crumple=0..1\n//\n// Knob 1: Hue. The colour that walks along the tube. At 0 it runs from cyan through blue to violet and back round the loop; at 0.25 from violet through pink to orange, at 0.5 from red through yellow to green, at 0.75 from yellow-green to sky blue.\n// Knob 2: Speed. At 2 the flow takes 50 steps a second; a crumpled trefoil opens in 7 to 11 s, the unknot in 5 to 8 s, the others in 9 to 30 s, then the knot holds 2 s and crumples over 2.5 s. At 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Knot. 0 the trefoil 3_1, 1 the figure-eight 4_1, 2 the cinquefoil 5_1, 3 the three-twist knot 5_2, 4 the unknot. Turning it starts the new knot crumpled.\n// Knob 4: Crumple. How hard space is deformed before each relaxation: a stretch along one axis, a wring about it and two twists about axes through the knot. At 0.06 the stretch is 1.8 times, the wring 3.9 rad each way and the twists 3.2 rad; at 0.5 2.6 times, 6 and 5 rad; at 1 3.4 times, 8.4 and 7 rad. It stops if two strands come within half a bead spacing.\n// Buttons: K1 tap crumples the knot again now.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// A closed polygon of NB beads x_i. With l_i the mean of the two edges at\n// bead i and D(i, j) the shorter way round from i to j,\n//   E = sum over i != j of (1 / |x_i - x_j|^2 - 1 / D(i, j)^2) l_i l_j,\n// O'Hara's integral on the beads: blind to size, 4 on a round circle, its\n// least value (Freedman, He and Wang). The flow keeps each edge's length, so\n// l_i and D stay put and a step follows the exact gradient. Added: a barrier\n// between edges nearer than the mean edge, which beads cannot see cross, and\n// bending stiffness, as E is blind to inversions of space too and lets a\n// relaxed knot drift. A step is kept only if the sum went down.\nconst NB = 120, N3 = NB * 3;\n// The (2,3) and (2,5) torus knots, the figure-eight, the Lissajous knot 5_2\n// (frequencies 3, 2, 7, phases 0.7, 0.2, 0) and a bent circle.\nconst tor = (p, q, r) => (t) => [(2 + cos(q * t)) * cos(p * t), (2 + cos(q * t)) * sin(p * t), sin(r * t)];\nconst KNOTS = [tor(2, 3, 3), tor(3, 2, 4), tor(2, 5, 5), (t) => [cos(3 * t + 0.7), cos(2 * t + 0.2), cos(7 * t)], (t) => [cos(t), sin(t), 0.25 * sin(2 * t)]];\n// LEDs a unit and the tube's radius for each knot.\nconst ZOOM = [28, 22, 24, 15, 27], TUBE = [2.6, 2.3, 2.1, 1.8, 2.7];\n// Steps a second at Speed 2, a bead's largest move in one, crumple and hold s.\nconst SPS = 50, VCAP = 0.0055, CRT = 2.5, HOLD = 2;\n// Barrier weight; bending, BEND L times the integral of curvature squared\n// (7.9 on a circle: weaker, 4_1 and 5_2 pull a clasp tight by a big loop,\n// which E alone prices the same); the stretch at Crumple 0.\nconst BAR = 2, BEND = 0.2, STR = 1.7;\n// The knot's middle row; the trace's rows.\nconst KY = 50, TY0 = 100, TY1 = 124, TN = 64;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Fourier tables along the curve; mode k is smoothed by k^-2.5.\nconst KM = 32, CS = new Float64Array(NB * (KM + 1)), SN = new Float64Array(NB * (KM + 1)), PK = new Float64Array(KM + 1);\nfor (let k = 1; k \u003c= KM; k++) {\n  for (let i = 0; i \u003c NB; i++) (CS[k * NB + i] = cos((TAU * k * i) / NB)), (SN[k * NB + i] = sin((TAU * k * i) / NB));\n  PK[k] = 2 / (k * k * sqrt(k));\n}\n\nfunction centre(X) {\n  let a = 0, b = 0, c = 0;\n  for (let i = 0; i \u003c N3; i += 3) (a += X[i]), (b += X[i + 1]), (c += X[i + 2]);\n  (a /= NB), (b /= NB), (c /= NB);\n  for (let i = 0; i \u003c N3; i += 3) (X[i] -= a), (X[i + 1] -= b), (X[i + 2] -= c);\n}\n\n// Edge lengths into LE, running sums into CUM; returns the length.\nconst LE = new Float64Array(NB), CUM = new Float64Array(NB + 1);\nfunction lengths(X) {\n  for (let i = 0; i \u003c NB; i++) {\n    const o = i * 3, q = ((i + 1) % NB) * 3;\n    LE[i] = sqrt((X[q] - X[o]) ** 2 + (X[q + 1] - X[o + 1]) ** 2 + (X[q + 2] - X[o + 2]) ** 2);\n    CUM[i + 1] = CUM[i] + LE[i];\n  }\n  return CUM[NB];\n}\n\n// Knot k's beads, evened along it, centred, the furthest one unit out.\nfunction nice(k, X, Y) {\n  for (let i = 0; i \u003c NB; i++) X.set(KNOTS[k]((TAU * i) / NB), i * 3);\n  for (let g = 0; g \u003c 6; g++) resample(X, Y), X.set(Y);\n  centre(X);\n  let r = 0;\n  for (let i = 0; i \u003c N3; i += 3) r = max(r, X[i] ** 2 + X[i + 1] ** 2 + X[i + 2] ** 2);\n  for (let i = 0; i \u003c N3; i++) X[i] /= sqrt(r);\n}\n\n// Edges i and j: their distance, and in SD where along each the closest\n// points lie and the vector between them.\nconst SD = new Float64Array(5);\nfunction segd(X, i, j) {\n  const p = i * 3, pe = ((i + 1) % NB) * 3, r = j * 3, re = ((j + 1) % NB) * 3;\n  const d1x = X[pe] - X[p], d1y = X[pe + 1] - X[p + 1], d1z = X[pe + 2] - X[p + 2];\n  const d2x = X[re] - X[r], d2y = X[re + 1] - X[r + 1], d2z = X[re + 2] - X[r + 2];\n  const rx = X[p] - X[r], ry = X[p + 1] - X[r + 1], rz = X[p + 2] - X[r + 2];\n  const a = d1x * d1x + d1y * d1y + d1z * d1z, e = d2x * d2x + d2y * d2y + d2z * d2z, f = d2x * rx + d2y * ry + d2z * rz;\n  const c = d1x * rx + d1y * ry + d1z * rz, b = d1x * d2x + d1y * d2y + d1z * d2z, den = a * e - b * b;\n  let s = den > 1e-18 ? cl((b * f - c * e) / den, 0, 1) : 0, t = (b * s + f) / e;\n  if (t \u003c 0) (t = 0), (s = cl(-c / a, 0, 1));\n  else if (t > 1) (t = 1), (s = cl((b - c) / a, 0, 1));\n  const wx = rx + d1x * s - d2x * t, wy = ry + d1y * s - d2y * t, wz = rz + d1z * s - d2z * t;\n  (SD[0] = s), (SD[1] = t), (SD[2] = wx), (SD[3] = wy), (SD[4] = wz);\n  return sqrt(wx * wx + wy * wy + wz * wz);\n}\n\n// E, plus BAR (h / d - 1)^2 for edges sharing no bead d \u003c h apart (h the\n// mean edge), plus BEND L sum 2 (1 - cos a_i) / l_i over the turns a_i; with\n// G, the gradient for fixed edge lengths. DM is left the least distance\n// between edges sharing no bead, or h if that is more: beads further apart\n// than two longest edges and h have edges more than h apart.\nlet DM = 0;\nconst dmin = (X) => (energy(X, null), DM);\nfunction energy(X, G) {\n  const L = lengths(X), h = L / NB, near = (2 * max(...LE) + h) ** 2;\n  if (G) G.fill(0);\n  let E = 0, B = 0;\n  DM = h;\n  for (let i = 0; i \u003c NB; i++) {\n    const wi = (LE[(i + NB - 1) % NB] + LE[i]) / 2, xi = X[i * 3], yi = X[i * 3 + 1], zi = X[i * 3 + 2];\n    for (let j = i + 1; j \u003c NB; j++) {\n      const dx = xi - X[j * 3], dy = yi - X[j * 3 + 1], dz = zi - X[j * 3 + 2], r2 = dx * dx + dy * dy + dz * dz, wj = (LE[j - 1] + LE[j]) / 2;\n      let a = CUM[j] - CUM[i];\n      if (a > L - a) a = L - a;\n      E += (1 / r2 - 1 / (a * a)) * wi * wj;\n      if (j === i + 1 || (i === 0 && j === NB - 1)) continue;\n      if (G) {\n        const f = (-4 * wi * wj) / (r2 * r2);\n        (G[i * 3] += f * dx), (G[i * 3 + 1] += f * dy), (G[i * 3 + 2] += f * dz);\n        (G[j * 3] -= f * dx), (G[j * 3 + 1] -= f * dy), (G[j * 3 + 2] -= f * dz);\n      }\n      if (r2 > near) continue;\n      const d = segd(X, i, j);\n      if (d \u003c DM) DM = d;\n      if (d >= h) continue;\n      B += BAR * (h / d - 1) ** 2;\n      if (!G) continue;\n      const f = (-2 * BAR * (h / d - 1) * h) / (d * d * d), s = SD[0], t = SD[1], i1 = ((i + 1) % NB) * 3, j1 = ((j + 1) % NB) * 3;\n      for (let c = 0; c \u003c 3; c++) {\n        const w = f * SD[2 + c];\n        (G[i * 3 + c] += w * (1 - s)), (G[i1 + c] += w * s), (G[j * 3 + c] -= w * (1 - t)), (G[j1 + c] -= w * t);\n      }\n    }\n  }\n  for (let i = 0; i \u003c NB; i++) {\n    const i0 = (i + NB - 1) % NB, a = i0 * 3, o = i * 3, q = ((i + 1) % NB) * 3;\n    const l0 = LE[i0], l1 = LE[i], k = (BEND * L * 2) / (l0 + l1), u = 1 / (l0 * l1);\n    let dot = 0;\n    for (let c = 0; c \u003c 3; c++) dot += (X[o + c] - X[a + c]) * (X[q + c] - X[o + c]);\n    B += k * 2 * (1 - dot * u);\n    if (G)\n      for (let c = 0; c \u003c 3; c++) {\n        const p = X[o + c] - X[a + c], n = X[q + c] - X[o + c], g = -2 * k * u;\n        (G[a + c] -= g * n), (G[o + c] += g * (n - p)), (G[q + c] += g * p);\n      }\n  }\n  return 2 * E + B;\n}\n\n// Projects a motion V onto those keeping every edge's length: V less\n// J^T (J J^T)^-1 J V, J J^T cyclic tridiagonal, solved by Sherman-Morrison.\nconst UE = new Float64Array(N3), TA = new Float64Array(NB), TB = new Float64Array(NB), TR = new Float64Array(NB);\nconst TY = new Float64Array(NB), TZ = new Float64Array(NB), TW = new Float64Array(NB), TU = new Float64Array(NB);\nfunction thomas(d, o, r, x) {\n  TW[0] = d[0];\n  x[0] = r[0];\n  for (let i = 1, m; i \u003c NB; i++) (m = o[i - 1] / TW[i - 1]), (TW[i] = d[i] - m * o[i - 1]), (x[i] = r[i] - m * x[i - 1]);\n  x[NB - 1] /= TW[NB - 1];\n  for (let i = NB - 2; i >= 0; i--) x[i] = (x[i] - o[i] * x[i + 1]) / TW[i];\n}\nfunction tangent(X, V) {\n  for (let e = 0; e \u003c NB; e++) for (let c = 0, q = ((e + 1) % NB) * 3; c \u003c 3; c++) UE[e * 3 + c] = X[q + c] - X[e * 3 + c];\n  for (let e = 0; e \u003c NB; e++) {\n    const o = e * 3, q = ((e + 1) % NB) * 3;\n    TA[e] = 2 * (UE[o] ** 2 + UE[o + 1] ** 2 + UE[o + 2] ** 2);\n    TB[e] = -(UE[o] * UE[q] + UE[o + 1] * UE[q + 1] + UE[o + 2] * UE[q + 2]);\n    TR[e] = UE[o] * (V[q] - V[o]) + UE[o + 1] * (V[q + 1] - V[o + 1]) + UE[o + 2] * (V[q + 2] - V[o + 2]);\n  }\n  const g = -TA[0], bn = TB[NB - 1];\n  (TA[0] -= g), (TA[NB - 1] -= (bn * bn) / g), TU.fill(0), (TU[0] = g), (TU[NB - 1] = bn);\n  thomas(TA, TB, TR, TY);\n  thomas(TA, TB, TU, TZ);\n  const k = (TY[0] + (bn * TY[NB - 1]) / g) / (1 + TZ[0] + (bn * TZ[NB - 1]) / g);\n  for (let e = 0; e \u003c NB; e++) TY[e] -= k * TZ[e];\n  for (let i = 0; i \u003c NB; i++) {\n    const e0 = (i + NB - 1) % NB;\n    for (let c = 0; c \u003c 3; c++) V[i * 3 + c] -= TY[e0] * UE[e0 * 3 + c] - TY[i] * UE[i * 3 + c];\n  }\n}\n\n// Smooths G into D: modes up to 32 (the rest are under 1/5000), so long\n// bends move as fast as short ones (E's order is 3). Projected before and\n// after, the step still goes downhill.\nconst FA = new Float64Array(KM + 1), FB = new Float64Array(KM + 1);\nfunction smooth(G, D) {\n  D.fill(0);\n  for (let c = 0; c \u003c 3; c++) {\n    for (let k = 1; k \u003c= KM; k++) {\n      let a = 0, b = 0;\n      for (let i = 0, o = k * NB; i \u003c NB; i++) (a += G[i * 3 + c] * CS[o + i]), (b += G[i * 3 + c] * SN[o + i]);\n      (FA[k] = a * PK[k]), (FB[k] = b * PK[k]);\n    }\n    for (let k = 1; k \u003c= KM; k++) for (let i = 0, o = k * NB; i \u003c NB; i++) D[i * 3 + c] += FA[k] * CS[o + i] + FB[k] * SN[o + i];\n  }\n}\n\n// Puts each edge e back to length ell[e], to 1e-8.\nfunction edges(X, ell) {\n  for (let s = 0, worst = 1; s \u003c 40 && worst > 1e-8; s++) {\n    worst = 0;\n    for (let n = 0; n \u003c NB; n++) {\n      const i = s & 1 ? NB - 1 - n : n, o = i * 3, q = ((i + 1) % NB) * 3, h = ell[i];\n      const dx = X[q] - X[o], dy = X[q + 1] - X[o + 1], dz = X[q + 2] - X[o + 2], l = sqrt(dx * dx + dy * dy + dz * dz), f = (0.5 * (l - h)) / l;\n      worst = max(worst, abs(l - h) / h);\n      (X[o] += f * dx), (X[o + 1] += f * dy), (X[o + 2] += f * dz);\n      (X[q] -= f * dx), (X[q + 1] -= f * dy), (X[q + 2] -= f * dz);\n    }\n  }\n}\n\n// The rule that keeps the knot: beads move in straight lines from X to Y by\n// at most dm / 4, dm the least edge distance in X. No point of an edge moves\n// more than its beads, so edges sharing no bead stay dm / 2 apart all the\n// way: no strand passes through another. Returns the share of the move\n// allowed; with cut, Y is held to it.\nfunction guard(X, Y, cut, dm) {\n  let d = 0;\n  for (let i = 0; i \u003c N3; i += 3) d = max(d, (Y[i] - X[i]) ** 2 + (Y[i + 1] - X[i + 1]) ** 2 + (Y[i + 2] - X[i + 2]) ** 2);\n  d = sqrt(d);\n  if (d \u003c= 0.25 * dm) return 1;\n  const f = (0.25 * dm) / d;\n  if (cut) for (let i = 0; i \u003c N3; i++) Y[i] = X[i] + (Y[i] - X[i]) * f;\n  return f;\n}\n\n// Slides the beads along the polygon to even spacing, into Y.\nfunction resample(X, Y) {\n  const L = lengths(X), h = L / NB;\n  let s0 = 0;\n  for (let b = 0; b \u003c NB; b++) s0 += CUM[b] - b * h;\n  s0 /= NB;\n  for (let b = 0, lo = 0; b \u003c NB; b++) {\n    const s = (((s0 + b * h) % L) + L) % L;\n    if (s \u003c CUM[lo]) lo = 0;\n    while (lo \u003c NB - 1 && CUM[lo + 1] \u003c= s) lo++;\n    const u = (s - CUM[lo]) / LE[lo], o = lo * 3, q = ((lo + 1) % NB) * 3;\n    for (let c = 0; c \u003c 3; c++) Y[b * 3 + c] = X[o + c] + (X[q + c] - X[o + c]) * u;\n  }\n}\n\n// Evens the beads, guarded, until two edges would come within half an edge.\nfunction even(S, rounds, dX = dmin(S.X)) {\n  const X = S.X, Y = S.Y;\n  for (let g = 0; g \u003c rounds; g++) {\n    resample(X, Y);\n    guard(X, Y, true, dX);\n    const dY = dmin(Y);\n    if (dY \u003c (0.5 * lengths(Y)) / NB) break;\n    X.set(Y);\n    centre(X);\n    dX = dY;\n  }\n  return dX;\n}\n\n// The crumple: a stretch along an axis (volume kept), a wring about it and\n// two twists about axes through beads. A twist turns points round its axis\n// by an angle set by their distance from it and height along it, so the\n// turn back undoes it: all are diffeomorphisms of R^3, the knot stays.\nconst dir = () => {\n  const u = rnd(-1, 1), a = rnd(0, TAU), s = sqrt(1 - u * u);\n  return [s * cos(a), s * sin(a), u];\n};\nfunction newTwists(S) {\n  const X = S.X, A = 3 + 4 * S.crumple, sg = () => (Math.random() \u003c 0.5 ? -1 : 1);\n  let rg = 0;\n  for (let i = 0; i \u003c N3; i++) rg += X[i] * X[i];\n  rg = sqrt(rg / NB);\n  const a = dir();\n  S.st = { a, k: log(STR * (1 + S.crumple)) };\n  // The wring turns each slice across the axis whole, -A to A along it.\n  S.tw = [{ c: [0, 0, 0], a, sr: 2 * rg, sz: 0.8 * rg, A: 1.2 * A * sg(), w: 1 }];\n  for (let k = 0; k \u003c 2; k++) {\n    const b = floor(rnd(0, NB)) * 3;\n    S.tw.push({ c: [X[b], X[b + 1], X[b + 2]], a: dir(), sr: rnd(0.4, 0.6) * rg, sz: rnd(0.5, 0.8) * rg, A: A * rnd(0.85, 1.15) * sg(), w: 0 });\n  }\n}\n\nfunction twist(S, X, Y, f) {\n  Y.set(X);\n  const sa = S.st.a, g = exp(S.st.k * f), q = 1 / sqrt(g);\n  for (let i = 0; i \u003c N3; i += 3) {\n    const z = Y[i] * sa[0] + Y[i + 1] * sa[1] + Y[i + 2] * sa[2];\n    for (let c = 0; c \u003c 3; c++) Y[i + c] = Y[i + c] * q + z * (g - q) * sa[c];\n  }\n  for (const T of S.tw) {\n    const [cx, cy, cz] = T.c, [ax, ay, az] = T.a, ir = 1 / (T.sr * T.sr), iz = 1 / T.sz;\n    for (let i = 0; i \u003c N3; i += 3) {\n      const rx = Y[i] - cx, ry = Y[i + 1] - cy, rz = Y[i + 2] - cz, z = rx * ax + ry * ay + rz * az;\n      const qx = rx - z * ax, qy = ry - z * ay, qz = rz - z * az, zz = z * iz;\n      const th = f * T.A * exp(-(qx * qx + qy * qy + qz * qz) * ir) * (T.w ? Math.tanh(zz) : exp(-zz * zz)), c = cos(th), s = sin(th);\n      Y[i] = cx + z * ax + qx * c + (ay * qz - az * qy) * s;\n      Y[i + 1] = cy + z * ay + qy * c + (az * qx - ax * qz) * s;\n      Y[i + 2] = cz + z * az + qz * c + (ax * qy - ay * qx) * s;\n    }\n  }\n}\n\n// Crumples on from share a to b in guarded pieces, evening after each;\n// stops if two edges would come within half an edge. Returns where it got.\nfunction crumpleTo(S, a, b) {\n  const X = S.X, Y = S.Y;\n  let sub = b - a, dX = dmin(X);\n  for (let n = 0; a \u003c b - 1e-9 && n \u003c 200; n++) {\n    const f = min(sub, b - a);\n    twist(S, X, Y, sm(a + f) - sm(a));\n    const g = guard(X, Y, false, dX);\n    if (g \u003c 1) {\n      sub = f * g * 0.8;\n      continue;\n    }\n    const dY = dmin(Y);\n    if (dY \u003c (0.5 * lengths(Y)) / NB) return 1;\n    X.set(Y);\n    dX = even(S, 1, dY);\n    a += f;\n    sub = f * 1.5;\n  }\n  return a > 1 - 1e-6 ? 1 : a;\n}\n\nfunction begin(S) {\n  nice(S.knot, S.X, S.Y);\n  S.L0 = lengths(S.X);\n  newTwists(S);\n  crumpleTo(S, 0, 1);\n  relax(S);\n  frame(S, 1);\n}\n\n// The flow starts at the first length (the zoom undoes it), edges fixed.\nfunction relax(S) {\n  const f = S.L0 / lengths(S.X);\n  for (let i = 0; i \u003c N3; i++) S.X[i] *= f;\n  centre(S.X);\n  lengths(S.X);\n  S.ell.set(LE);\n  S.phase = S.t = S.tc = 0;\n  S.E = S.Ec = energy(S.X, null);\n  S.tau = 1e-5;\n}\n\n// One step: gradient, projected, smoothed, projected; cut to the guard,\n// halved until the energy falls, kept only then.\nfunction step(S) {\n  const { X, Y, G, D } = S;\n  energy(X, G);\n  const dm = DM;\n  tangent(X, G);\n  smooth(G, D);\n  tangent(X, D);\n  let m = 0;\n  for (let i = 0; i \u003c N3; i += 3) m = max(m, D[i] * D[i] + D[i + 1] * D[i + 1] + D[i + 2] * D[i + 2]);\n  let k = min(S.tau, VCAP / (sqrt(m) + 1e-30));\n  for (let tries = 0; tries \u003c 12; tries++) {\n    for (let i = 0; i \u003c N3; i++) Y[i] = X[i] - k * D[i];\n    edges(Y, S.ell);\n    centre(Y);\n    const g = guard(X, Y, false, dm);\n    if (g \u003c 1) {\n      k *= g * 0.9;\n      continue;\n    }\n    const E = energy(Y, null);\n    if (E \u003c S.E) {\n      X.set(Y);\n      S.E = E;\n      S.tau = k * 1.3;\n      return;\n    }\n    k *= 0.5;\n  }\n  S.tau = max(k, 1e-12);\n}\n\n// A smoothed view along the thinnest axis, the longest up the panel, by\n// power steps on C and tr - C.\nfunction frame(S, d) {\n  const X = S.X, C = [0, 0, 0, 0, 0, 0, 0, 0, 0];\n  for (let i = 0; i \u003c N3; i += 3) for (let a = 0; a \u003c 3; a++) for (let b = 0; b \u003c 3; b++) C[a * 3 + b] += X[i + a] * X[i + b];\n  const tr = C[0] + C[4] + C[8], dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2], unit = (w) => w.map((x) => x / (Math.hypot(...w) || 1));\n  const it = (v, sh) => {\n    for (let k = 0; k \u003c 3; k++) v = unit([0, 1, 2].map((a) => sh * v[a] + (sh ? -1 : 1) * (C[a * 3] * v[0] + C[a * 3 + 1] * v[1] + C[a * 3 + 2] * v[2])));\n    return v;\n  };\n  const k = min(1, d * 1.2), pull = (e, v) => unit(e.map((x, a) => x + (v[a] * (dot(e, v) \u003c 0 ? -1 : 1) - x) * k));\n  const e3 = pull(S.e3, it(S.e3, tr)), e2 = pull(S.e2, it(S.e2, 0)), p = dot(e2, e3);\n  S.e3 = e3;\n  S.e2 = unit(e2.map((x, a) => x - p * e3[a]));\n  S.e1 = [S.e2[1] * e3[2] - S.e2[2] * e3[1], S.e2[2] * e3[0] - S.e2[0] * e3[2], S.e2[0] * e3[1] - S.e2[1] * e3[0]];\n}\n\nexport function setup(params) {\n  params.s = {\n    knot: -1, phase: 0, t: 0, acc: 0, rock: 0, cr: 0,\n    X: new Float64Array(N3), Y: new Float64Array(N3), G: new Float64Array(N3), D: new Float64Array(N3), ell: new Float64Array(NB),\n    hist: new Float32Array(TN).fill(NaN), ht: 0,\n    e1: [1, 0, 0], e2: [0, 1, 0], e3: [0, 0, 1],\n    zb: new Float32Array(N), buf: new Float32Array(N * 3), col: new Float32Array(NB * 3), scr: new Float32Array(NB * 4),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.crumple] = [cl(kv[0], 0, 1), cl(kv[1], 0.2, 3), cl(kv[3], 0, 1)];\n  const knot = round(cl(kv[2], 0, 4));\n  if (knot !== S.knot) {\n    S.knot = knot;\n    S.hist.fill(NaN);\n    begin(S);\n  }\n  const ds = (d * S.speed) / 2;\n  S.rock += ds;\n  if (input.btnPressed && input.btnPressed[0] && S.phase !== 2) (S.phase = 2), (S.cr = 0), newTwists(S);\n  S.t += ds;\n  if (S.phase === 0) {\n    S.acc += ds * SPS;\n    for (; S.acc >= 1; S.acc--) step(S);\n    // Relaxed once half a second takes less than 0.05% off the energy.\n    if ((S.tc += ds) >= 0.5) {\n      if (S.Ec - S.E \u003c 0.0005 * S.E && S.t > 3) (S.phase = 1), (S.t = 0);\n      S.Ec = S.E;\n      S.tc = 0;\n    }\n    if (S.t > 40) (S.phase = 1), (S.t = 0);\n  } else if (S.phase === 1) {\n    // While it holds, the beads are spaced out evenly again.\n    even(S, 2);\n    S.E = energy(S.X, null);\n    if (S.t > HOLD) (S.phase = 2), (S.cr = 0), newTwists(S);\n  } else {\n    S.cr = crumpleTo(S, S.cr, min(1, S.cr + ds / CRT));\n    S.E = energy(S.X, null);\n    if (S.cr >= 1) relax(S);\n  }\n  frame(S, ds);\n  // A trace sample every quarter second.\n  if ((S.ht += ds) >= 0.25) {\n    (S.ht -= 0.25), S.hist.copyWithin(0, 1), (S.hist[TN - 1] = log(S.E));\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || S.knot \u003c 0) return;\n  const { zb, buf, col, scr, X, e1, e2, e3 } = S;\n  zb.fill(1e9), buf.fill(0);\n  // The view rocks 0.6 rad and nods 0.3.\n  const ra = 0.6 * sin((TAU * S.rock) / 13), rb = 0.3 * sin((TAU * S.rock) / 9.1), ca = cos(ra), sa = sin(ra), cb = cos(rb), sb = sin(rb);\n  const zoom = ZOOM[S.knot] * (S.L0 / lengths(X)), tr = TUBE[S.knot], CAM = 5;\n  for (let i = 0; i \u003c NB; i++) {\n    const o = i * 3, x = X[o], y = X[o + 1], z = X[o + 2];\n    let u = e1[0] * x + e1[1] * y + e1[2] * z, v = e2[0] * x + e2[1] * y + e2[2] * z, w = e3[0] * x + e3[1] * y + e3[2] * z;\n    [u, w] = [u * ca + w * sa, -u * sa + w * ca];\n    [v, w] = [v * cb + w * sb, -v * sb + w * cb];\n    const p = CAM / (CAM + w);\n    (scr[i * 4] = 31.5 + u * zoom * p), (scr[i * 4 + 1] = KY - v * zoom * p), (scr[i * 4 + 2] = w * zoom), (scr[i * 4 + 3] = tr * p);\n    // The hue walks a third of the wheel along the curve and back.\n    hsv(0.5 + S.hue + 0.34 * (0.5 - 0.5 * cos((TAU * i) / NB)), 0.8, 1, col, o);\n  }\n  // Light from the upper left and in front, and the half vector for the shine.\n  const lx = -0.451, ly = -0.551, lz = -0.702, hx = -0.245, hy = -0.299, hz = -0.922;\n  for (let i = 0; i \u003c NB; i++) {\n    const a = i * 4, b = ((i + 1) % NB) * 4, ax = scr[a], ay = scr[a + 1], az = scr[a + 2], bx = scr[b], by = scr[b + 1], bz = scr[b + 2];\n    let tx = bx - ax, ty = by - ay, tz = bz - az;\n    const tl = sqrt(tx * tx + ty * ty + tz * tz) || 1, m = max(1, ceil(Math.hypot(bx - ax, by - ay) / 0.7)), ci = i * 3, cj = ((i + 1) % NB) * 3;\n    (tx /= tl), (ty /= tl), (tz /= tl);\n    for (let q = 0; q \u003c m; q++) {\n      const f = q / m, sx = ax + (bx - ax) * f, sy = ay + (by - ay) * f, sz = az + (bz - az) * f, rp = scr[a + 3] + (scr[b + 3] - scr[a + 3]) * f;\n      const cr = col[ci] + (col[cj] - col[ci]) * f, cg = col[ci + 1] + (col[cj + 1] - col[ci + 1]) * f, cbl = col[ci + 2] + (col[cj + 2] - col[ci + 2]) * f;\n      // Nearer is brighter: the back of the knot at about 60%.\n      const fog = 0.8 - 0.2 * cl(sz / 30, -1, 1);\n      const R = rp + 1, x0 = max(0, floor(sx - R)), x1 = min(W - 1, ceil(sx + R)), y0 = max(0, floor(sy - R)), y1 = min(H - 1, ceil(sy + R));\n      for (let y = y0; y \u003c= y1; y++)\n        for (let x = x0; x \u003c= x1; x++) {\n          const nx = x + 0.5 - sx, ny = y + 0.5 - sy, d2 = nx * nx + ny * ny, p = y * W + x;\n          if (d2 >= R * R) continue;\n          if (d2 >= rp * rp) {\n            // A dark rim a little behind: it cuts the gap in a strand below.\n            const z = sz + rp * 0.9;\n            if (z \u003c zb[p]) (zb[p] = z), (buf[p * 3] = buf[p * 3 + 1] = buf[p * 3 + 2] = 0);\n            continue;\n          }\n          const nz = sqrt(rp * rp - d2), z = sz - nz;\n          if (z >= zb[p]) continue;\n          zb[p] = z;\n          // The sphere's normal less its part along the tube.\n          let Nx = nx / rp, Ny = ny / rp, Nz = -nz / rp;\n          const dn = Nx * tx + Ny * ty + Nz * tz;\n          (Nx -= dn * tx), (Ny -= dn * ty), (Nz -= dn * tz);\n          const nl = sqrt(Nx * Nx + Ny * Ny + Nz * Nz) || 1;\n          const lam = max(0, (Nx * lx + Ny * ly + Nz * lz) / nl), sp = max(0, (Nx * hx + Ny * hy + Nz * hz) / nl) ** 18, v = fog * (0.3 + 0.75 * lam);\n          (buf[p * 3] = cr * v + sp * 0.7), (buf[p * 3 + 1] = cg * v + sp * 0.7), (buf[p * 3 + 2] = cbl * v + sp * 0.7);\n        }\n    }\n  }\n  // The trace: log E over the last 16 s, a line over a faint fill.\n  let lo = 1e9, hi = -1e9, py = -1;\n  for (let i = 0; i \u003c TN; i++) if (S.hist[i] === S.hist[i]) (lo = min(lo, S.hist[i])), (hi = max(hi, S.hist[i]));\n  if (hi - lo \u003c 0.4) hi = lo + 0.4;\n  const tc = col.subarray(90, 93);\n  for (let i = 0; i \u003c TN; i++) {\n    const v = S.hist[i];\n    if (v !== v) continue;\n    const y = round(TY1 - ((v - lo) / (hi - lo)) * (TY1 - TY0)), ya = py \u003c 0 ? y : min(y, py + 1), yb = py \u003c 0 ? y : max(y, py - 1);\n    for (let yy = min(ya, y); yy \u003c= TY1; yy++) {\n      const p = yy * W + i, f = yy \u003c= max(yb, y) ? (i === TN - 1 ? 1 : 0.6) : 0.16;\n      if (zb[p] \u003c 1e9) continue;\n      (buf[p * 3] = tc[0] * f), (buf[p * 3 + 1] = tc[1] * f), (buf[p * 3 + 2] = tc[2] * f);\n    }\n    py = y;\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    if (buf[o] + buf[o + 1] + buf[o + 2] \u003c 0.02) continue;\n    // Each channel in steps of 4 of 255.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(buf[o] * 63.75) * 4), min(255, round(buf[o + 1] * 63.75) * 4), min(255, round(buf[o + 2] * 63.75) * 4));\n  }\n}\n","trick-or-treat":"// ===== Patternflow pattern =====\n// Title:   Trick or Treat\n// Family:  halloween\n// Idea:    A narrow street on Halloween night runs up the panel to a vanishing point under a purple sky, and three small trick-or-treaters, a bedsheet ghost, a witch and a cat, walk up it away from us sweeping torch beams over the pavement and swinging pumpkin buckets, stop where a door opens a wedge of yellow light for candy, and walk on into the distance as the next group comes in, with bats over the roofs and leaves blowing through the mist.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 48\n// Round:   48\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lights=0.5..1, Wind=0..1\n//\n// Knob 1: Hue. Tints the night, sky, walls, roofs and road together, while lamps, pumpkins and costumes keep their colours: at 0 a violet sky over plum walls, at 0.25 a blood red night, at 0.5 a toxic green one, at 0.75 deep teal.\n// Knob 2: Speed. At 2 the children walk about 1.5 m a second, wait 2.2 s at each door and sweep their torches across and back in 1.2 s, and a new group comes in every 9 to 12 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Lights. The share of houses with their lights on, half at the start and all at 1. A lit house has lit windows (lamps, jack-o'-lanterns, a flickering television), a porch lamp and pumpkins on the step, and only lit houses open their doors to the children.\n// Knob 4: Wind. At the start 43 leaves skitter across the street and the mist drifts at 0.7 m a second; at 0.5 there are 135 leaves, at 1 there are 240, blowing across at about 5.6 m a second and up to 3.7 m high, and the mist runs at 4.3 m a second.\n// Buttons: K1 tap opens the door of a lit house up the street for 3 s.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u;\n};\n// Smooth noise on a 32 x 32 wrapping grid, for the mist.\nconst NT = new Float32Array(1024).map((_, i) => hash(i * 7 + 11));\nconst vn2 = (x, y) => {\n  const i = floor(x), j = floor(y), u = x - i, v = y - j, a = (j & 31) * 32, b = ((j + 1) & 31) * 32, i0 = i & 31, i1 = (i + 1) & 31;\n  const su = u * u * (3 - 2 * u), sv = v * v * (3 - 2 * v);\n  return (NT[a + i0] * (1 - su) + NT[a + i1] * su) * (1 - sv) + (NT[b + i0] * (1 - su) + NT[b + i1] * su) * sv;\n};\nconst hsv = (h, s, v) => [5, 3, 1].map((n) => {\n  const k = (n + (h - floor(h)) * 6) % 6;\n  return 255 * v * (1 - s * max(0, min(k, 4 - k, 1)));\n});\nconst put = (b, o, r, g, bl) => ((b[o] = r), (b[o + 1] = g), (b[o + 2] = bl));\nconst add = (b, o, r, g, bl) => ((b[o] += r), (b[o + 1] += g), (b[o + 2] += bl));\n\n// One-point perspective. The lane is 2 units wide between the house fronts\n// (about 3.2 m), the eye HC above it and the eaves HE, a little higher, so\n// the roof lines climb from the vanishing point (32, YH) to the top corners.\n// A point x across, h up and z deep lands at (32 + R s x, YH + R s (HC - h))\n// with s = ZN / z: the ground at depth z is row YH + G s.\nconst YH = 22, G = 127.5 - YH, R = 30, HC = G / R, ZN = 3, HE = HC + 0.9;\n// Roof pitch, run from the eave to the ridge, and the houses' depth.\nconst PITCH = 1.1, RUN = 1.3, DEPTH = 2 * RUN;\nconst sOf = (z) => ZN / z;\n\n// Houses along each side: [side, z0, z1, door z].\nconst HOUSES = [];\nfor (const side of [-1, 1])\n  for (let z = 1 + hash(side + 5) * 1.5, k = 0; z \u003c 80; k++) {\n    const len = 3 + 1.6 * hash(k * 31 + side * 7 + 1);\n    HOUSES.push([side, z, z + len, z + 0.7 + (len - 1.4) * hash(k * 17 + side * 3 + 2)]);\n    z += len + 0.5 + 1.1 * hash(k * 13 + side * 11 + 3);\n  }\nconst houseAt = (side, z) => HOUSES.findIndex((h) => h[0] === side && z >= h[1] && z \u003c h[2]);\n// Three floors of windows, by height.\nconst FLOORS = [[0.55, 1.3], [1.95, 2.75], [3.3, 4.0]];\n\n// What each LED sees, worked out once by casting its ray at the ground, the\n// two rows of house fronts, their roofs and the end walls facing us; the\n// nearest hit wins. A window's id is its house, floor and slot.\nconst SKY = 0, GROUND = 1, WALL = 2, WIN = 3, DOOR = 4, END = 5, ROOF = 6;\nconst MAT = new Uint8Array(N), REF = new Int16Array(N), ZB = new Float32Array(N), XB = new Float32Array(N), HB = new Float32Array(N);\nfor (let p = 0; p \u003c N; p++) {\n  const q = ((p % W) + 0.5 - 32) / R, e = (floor(p / W) + 0.5 - YH) / R, side = q \u003c 0 ? -1 : 1, aq = abs(q);\n  let best = 0, m = SKY, ref = -1, zz = 0, xx = 0, hh = 0, s;\n  // The ground, unless a house stands on that spot.\n  if (e > 0 && (abs(q / (s = e / HC)) \u003c= 1 || !(abs(q / s) \u003c= 1 + DEPTH && houseAt(side, ZN / s) >= 0))) [best, m, zz, xx] = [s, GROUND, ZN / s, q / s];\n  // The house front on this side, then the near slope of a roof.\n  let i = houseAt(side, ZN / aq), h = HC - e / aq;\n  if (i >= 0 && h >= 0 && h \u003c= HE && aq > best) [best, m, ref, zz, hh] = [aq, WALL, i, ZN / aq, h];\n  s = (-e - PITCH * aq) / (HE - HC - PITCH);\n  if (s > best && (i = houseAt(side, ZN / s)) >= 0 && aq / s >= 1 && aq / s \u003c= 1 + RUN) [best, m, ref, zz] = [s, ROOF, i, ZN / s];\n  // End walls facing us, with their gables.\n  HOUSES.forEach(([sd, z0], i) => {\n    const s = sOf(z0), d = aq / s - 1, h = HC - e / s;\n    if (sd === side && s > best && d >= 0 && d \u003c= DEPTH && h >= 0 && h \u003c= HE + PITCH * min(d, DEPTH - d)) [best, m, ref, zz, xx, hh] = [s, END, i, z0, d, h];\n  });\n  if (m === WALL) {\n    const [, z0, z1, zd] = HOUSES[ref], f = FLOORS.findIndex(([a, b]) => hh > a && hh \u003c b), c = f ? (zz - z0 - 0.75) / 1.25 : (zz - zd) / 1.25, k = round(c);\n    if (abs(zz - zd) \u003c 0.3 && hh \u003c 1.35) m = DOOR;\n    else if (f >= 0 && abs(c - k) \u003c 0.24 && (f || k) && zz > z0 + 0.3 && zz \u003c z1 - 0.3) [m, ref] = [WIN, ref * 32 + f * 5 + ((k + 5) % 5)];\n  }\n  [MAT[p], REF[p], ZB[p], XB[p], HB[p]] = [m, ref, zz, xx, hh];\n}\n// Fixed shading: a wall's tone, each house a little different and darker\n// far off, a window's fade, each door's porch lamp on the wall, the stars.\nconst TONE = new Float32Array(N), LAMP = new Float32Array(N), STAR = new Uint8Array(N), WIDS = new Set(), GL = [], WL = [];\nfor (let p = 0; p \u003c N; p++) {\n  const m = MAT[p], fog = min(1, 7 / ZB[p]);\n  if (m === WALL || m === END) TONE[p] = (0.85 + 0.3 * hash(REF[p] * 7 + 2)) * (0.5 + 0.5 * fog);\n  if (m === WALL) {\n    const dz = ZB[p] - HOUSES[REF[p]][3] - 0.42, dh = HB[p] - 1.6;\n    LAMP[p] = abs(dz) \u003c 0.09 && abs(dh) \u003c 0.12 ? 3 : exp(-(dz * dz + dh * dh) / 0.35) * 0.9;\n  }\n  if (m === WIN) (TONE[p] = 0.15 + 0.85 * fog * fog), WIDS.add(REF[p]);\n  STAR[p] = m === SKY && hash(p * 3 + 1) \u003c 0.015;\n  // The ground and the walls, the only LEDs the lights walk.\n  if (m === GROUND) GL.push(p);\n  else if (m !== SKY && m !== ROOF) WL.push(p);\n}\n// The walls in order of depth, and where each quarter unit of depth starts.\nWL.sort((a, b) => ZB[a] - ZB[b]);\nconst WZ = new Int32Array(330);\nfor (let i = 0, j = 0; i \u003c 330; i++) {\n  while (j \u003c WL.length && ZB[WL[j]] \u003c i / 4) j++;\n  WZ[i] = j;\n}\nconst wallFrom = (z) => WZ[min(329, floor(z * 4))];\n// Where each row starts among the ground LEDs, and those between two depths.\nconst GROW = new Int32Array(H + 1);\nfor (let y = 0, j = 0; y \u003c= H; y++) {\n  while (j \u003c GL.length && GL[j] \u003c y * W) j++;\n  GROW[y] = j;\n}\nconst rowsFor = (za, zb) => [GROW[cl(floor(YH + (G * ZN) / zb), 0, H)], GROW[cl(floor(YH + (G * ZN) / max(za, 0.1)) + 2, 0, H)]];\n\n// A house is lit while its rank is under Lights, and only lit houses open\n// their doors to the children.\nconst RANK = HOUSES.map((h, i) => hash(i * 29 + 185));\n// Jack-o'-lanterns on the step at each door, one or two: [x, z, seed, house].\nconst PUMPKINS = [];\nHOUSES.forEach(([side, , , zd], i) => {\n  PUMPKINS.push([side * 0.84, zd - 0.42, i * 2, i]);\n  if (hash(i * 5 + 9) \u003c 0.5) PUMPKINS.push([side * 0.86, zd + 0.42, i * 2 + 1, i]);\n});\n// Their glow on the ground and the porch lamps', laid down once with whose\n// light it is, for the flicker and for Lights.\nconst PG = new Float32Array(N), PS = new Int16Array(N), LG = new Float32Array(N), LS = new Int16Array(N);\nfor (const p of GL) {\n  PUMPKINS.forEach(([px, pz], i) => {\n    const r2 = (XB[p] - px) ** 2 + (ZB[p] - pz) ** 2, f = r2 \u003c 0.4 ? (1 - r2 / 0.4) * 0.6 : 0;\n    if (f > PG[p]) (PG[p] = f), (PS[p] = i);\n  });\n  HOUSES.forEach(([side, , , zd], i) => {\n    const r2 = (XB[p] - side) ** 2 * 0.6 + (ZB[p] - zd - 0.4) ** 2, f = r2 \u003c 1.1 ? (1 - r2 / 1.1) ** 2 * 0.42 : 0;\n    if (f > LG[p]) (LG[p] = f), (LS[p] = i);\n  });\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, mx: 0, hue: 0, speed: 2, lights: 0.5, wind: 0.06, begun: false, groups: [], leaves: [], tap: -1, tapT: 0,\n    open: new Float32Array(HOUSES.length), rgb: new Float32Array(N * 3), lit: new Float32Array(N * 3), wc: new Float32Array(96 * HOUSES.length), hueKey: -1,\n  };\n}\n\n// A group of three, a bedsheet ghost, a little witch and a cat, walking\n// together from one lit door to the next, zigzagging up the street.\nconst SLOTS = [[-0.34, 0.1], [0, -0.05], [0.34, 0.18]];\nconst newGroup = (z) => ({\n  x: 0, z, tx: 0, tz: z, wait: 0, door: -1, side: -1, done: false,\n  kids: SLOTS.map(([x, dz], type) => ({ type, x, z: z + dz, ph: Math.random() * TAU, sw: Math.random() * TAU, candy: 0 })),\n});\n// The next lit door at least 1.6 ahead of z on one side, and its depth.\nfunction nextDoor(S, side, z) {\n  let best = -1;\n  HOUSES.forEach(([sd, , , zd], i) => {\n    if (sd === side && RANK[i] \u003c S.lights && zd > z + 1.6 && (best \u003c 0 || zd \u003c HOUSES[best][3])) best = i;\n  });\n  return best;\n}\nconst doorZ = (i) => (i \u003c 0 ? 1e9 : HOUSES[i][3]);\n\nfunction steer(S, g) {\n  if (g.z > 15 || g.done) return Object.assign(g, { done: true, door: -1, tx: 0, tz: 200 });\n  g.door = nextDoor(S, g.side, g.z);\n  // A dark stretch on this side: cross over, or walk on.\n  if (doorZ(g.door) > g.z + 6) g.door = nextDoor(S, (g.side = -g.side), g.z);\n  if (doorZ(g.door) > g.z + 6) Object.assign(g, { door: -1, tx: 0, tz: g.z + 3 });\n  // They wait on the path just short of the door, so it shows past them.\n  else Object.assign(g, { tx: g.side * 0.3, tz: doorZ(g.door) - 0.55 });\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.5, 0.06], ds = (cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3)) / 2;\n  [S.hue, S.lights, S.wind] = [cl(k[0], 0, 1), cl(k[2], 0.5, 1), cl(k[3], 0, 1)];\n  S.t += ds;\n  const gust = 0.5 + vn(S.t * 0.4, 9);\n  S.mx += ds * (0.3 + 2.4 * S.wind) * gust;\n  if (!S.begun) {\n    S.begun = true;\n    // One group already far up the street, one halfway, one just come in.\n    const far = newGroup(16), mid = newGroup(9.2), near = newGroup(2.7);\n    far.done = true;\n    near.side = doorZ(nextDoor(S, -1, 2.7)) \u003c doorZ(nextDoor(S, 1, 2.7)) ? -1 : 1;\n    for (const g of [far, mid, near]) steer(S, g), S.groups.push(g);\n  }\n  // A new group comes in from the bottom once the last is far enough on.\n  const last = S.groups[S.groups.length - 1];\n  if (!last || last.z > 9) {\n    const g = newGroup(2.4);\n    steer(S, g);\n    S.groups.push(g);\n  }\n  if (input.btnPressed && input.btnPressed[0]) {\n    const c = HOUSES.map((h, i) => i).filter((i) => HOUSES[i][3] > 4 && HOUSES[i][3] \u003c 14 && RANK[i] \u003c S.lights);\n    S.tap = c[floor(Math.random() * c.length)];\n    S.tapT = 3;\n  }\n  const want = new Float32Array(HOUSES.length);\n  if ((S.tapT -= ds) > 0) want[S.tap] = 1;\n  for (const g of S.groups) {\n    if (g.wait > 0) {\n      want[g.door] = 1;\n      if ((g.wait -= ds) \u003c= 0) {\n        for (const kd of g.kids) kd.candy++;\n        g.side = -g.side;\n        steer(S, g);\n      }\n    } else {\n      // 0.95 lane widths a second at Speed 2; the door opens as they come.\n      const dx = g.tx - g.x, dz = g.tz - g.z, l = sqrt(dx * dx + dz * dz), st = 0.95 * ds;\n      if (l \u003c= st) {\n        [g.x, g.z] = [g.tx, g.tz];\n        if (g.door >= 0) g.wait = 2.2;\n        else steer(S, g);\n      } else (g.x += (dx / l) * st), (g.z += (dz / l) * st);\n      if (g.door >= 0 && l \u003c 0.5) want[g.door] = 1;\n    }\n    const walk = g.wait \u003c= 0, f = min(1, ds * 4);\n    g.kids.forEach((kd, i) => {\n      // Each child trails its place in the group a little.\n      kd.x += (g.x + SLOTS[i][0] * (walk ? 1 : 0.8) - kd.x) * f;\n      kd.z += (g.z + SLOTS[i][1] - kd.z) * f;\n      if (walk) kd.ph += ds * TAU * 1.9;\n      kd.sw += ds * (walk ? 2.3 : 0.9);\n      [kd.walk, kd.side] = [walk, g.side];\n    });\n  }\n  S.groups = S.groups.filter((g) => g.z \u003c 40);\n  for (let i = 0; i \u003c HOUSES.length; i++) S.open[i] += (want[i] - S.open[i]) * min(1, ds * (want[i] ? 5 : 2));\n  // Leaves blown across the street, tumbling; more, faster and higher with wind.\n  const n = round(30 + 210 * S.wind);\n  while (S.leaves.length \u003c n) S.leaves.push(leaf(Math.random() * 2 - 1));\n  S.leaves.length = n;\n  for (const lf of S.leaves) {\n    lf.x += ds * (0.3 + 3.2 * S.wind) * lf.sp * gust;\n    lf.ph += ds * (7 + 10 * S.wind) * lf.sp;\n    lf.h = abs(sin(lf.ph * 0.4)) * (0.06 + 1.6 * S.wind) * lf.sp;\n    if (lf.x > 1) Object.assign(lf, leaf(-1));\n  }\n}\nconst leaf = (x) => ({ x, z: 2.4 + Math.random() * Math.random() * 11, h: 0, ph: Math.random() * TAU, c: floor(Math.random() * 3), sp: 0.6 + 0.8 * Math.random() });\n\n// Bats over the roofs, each on its own path through the sky, beating its\n// wings 6 to 9 times a second; every third is nearer and twice the size.\nconst BATW = [[\"x...x\", \".xxx.\", \"..x..\"], [\"xxxxx\", \".xxx.\"], [\".xxx.\", \"x.x.x\"]];\nfunction drawBats(buf, t) {\n  for (let i = 0; i \u003c 9; i++) {\n    const x = round(32 + 26 * (vn(t * 0.35 + i * 3.1, i * 5 + 1) * 2 - 1)), y = round(3 + 20 * vn(t * 0.3 + i * 1.7, i * 5 + 2));\n    const w = BATW[floor((t * (6 + i * 0.7) + i * 0.37) * 3) % 3], z = i % 3 ? 1 : 2;\n    for (let j = 0; j \u003c w.length * z; j++)\n      for (let k = 0; k \u003c 5 * z; k++) {\n        const px = x - 2 * z + k;\n        if (w[(j / z) | 0][(k / z) | 0] === \"x\" && px >= 0 && px \u003c W) put(buf, ((y + j) * W + px) * 3, 10, 4, 16);\n      }\n  }\n}\n\n// Costumes seen from behind, in units of the child's height: u across, v up\n// from the feet. Each returns a colour or null.\nconst WHITE = [236, 232, 255], SHADE = [176, 170, 214], SHOE = [40, 30, 50], SOCK = [255, 150, 30];\nconst HAT = [24, 14, 36], BAND = [170, 70, 240], CAPE = [112, 44, 168], HAIR = [120, 230, 60], BROOM = [150, 104, 60], STRAW = [236, 196, 90];\nconst CAT = [30, 24, 40], RIM = [110, 92, 146], BUCKET = [255, 136, 16], CANDY = [255, 70, 190];\nfunction costume(type, u, v, ph, sw) {\n  if (v \u003c 0.09 && abs(abs(u) - 0.07) \u003c 0.05 && v >= 0.04 * max(0, u \u003c 0 ? sin(ph) : -sin(ph))) return type === 1 ? (floor(v * 50) & 1 ? SOCK : HAT) : SHOE;\n  if (type === 0) {\n    // The sheet: a round top, wider to a hem that ripples as they walk.\n    if (v \u003c 0.08 + 0.03 * sin(u * 34 + ph * 2) || v > 0.95) return null;\n    const half = v > 0.72 ? sqrt(max(0, 0.042 - (v - 0.72) ** 2)) : 0.205 + 0.1 * (0.72 - v);\n    return abs(u) > half ? null : u > half - 0.07 ? SHADE : WHITE;\n  }\n  if (type === 1) {\n    // The witch: a bent hat with band and brim, green hair, a broom.\n    const t = (v - 0.81) / 0.33, a = 0.13 * ((0.64 - v) / 0.55), bu = u + 0.3 - 0.55 * (v - 0.1);\n    if (t >= 0 && t \u003c= 1 && abs(u - 0.07 * t * t) \u003c 0.13 * (1 - t)) return t \u003c 0.12 ? BAND : HAT;\n    if (v >= 0.76 && v \u003c 0.81 && abs(u) \u003c 0.25) return HAT;\n    if ((u * u) / 0.012 + (v - 0.69) ** 2 / 0.009 \u003c 1) return HAIR;\n    if (v >= 0.09 && v \u003c 0.64 && abs(u) \u003c 0.12 + a) return abs(u) > 0.09 + a ? RIM : CAPE;\n    if (v > 0.22 && v \u003c 0.98 && abs(bu) \u003c 0.03) return BROOM;\n    return v >= 0.04 && v \u003c= 0.22 && abs(bu) \u003c 0.02 + 0.5 * (0.22 - v) ? STRAW : null;\n  }\n  // The cat: a black suit, round head, two ears and a tail that sways.\n  if (u > 0.06 && u \u003c 0.38 && v > 0.17 && v \u003c 0.69)\n    for (let i = 0; i \u003c= 12; i++) {\n      const a = i / 12;\n      if ((u - 0.12 - 0.17 * a - 0.04 * sin(a * 3 + sw)) ** 2 + (v - 0.22 - 0.42 * a * a) ** 2 \u003c 0.0011) return RIM;\n    }\n  const ear = v >= 0.84 && v \u003c 0.99 && abs(abs(u) - 0.085) \u003c 0.055 * ((0.99 - v) / 0.15);\n  return u * u + (v - 0.76) ** 2 \u003c 0.018 || ear || (v >= 0.09 && v \u003c 0.68 && abs(u) \u003c 0.135 + 0.03 * sin(v * 5)) ? CAT : null;\n}\n\nfunction drawKid(buf, kd) {\n  const s = sOf(kd.z), hp = 0.92 * R * s, xs = 32 + kd.x * R * s, ys = YH + G * s, bob = kd.walk ? 0.025 * abs(sin(kd.ph)) : 0;\n  // The pumpkin bucket swings from one hand, the cat's left and the others' right.\n  const ba = kd.walk ? 0.45 * sin(kd.ph) : 0.15 * sin(kd.sw * 3), bcx = (kd.type === 2 ? -0.25 : 0.25) + 0.12 * sin(ba), bcy = 0.42 - 0.12 * cos(ba);\n  for (let y = max(0, floor(ys - 1.18 * hp)); y \u003c= min(H - 1, floor(ys)); y++)\n    for (let x = max(0, floor(xs - 0.5 * hp)); x \u003c= min(W - 1, floor(xs + 0.5 * hp)); x++) {\n      const u = (x + 0.5 - xs) / hp, v = (ys - y - 0.5) / hp - bob, o = (y * W + x) * 3;\n      let c = (u - bcx) ** 2 + (v - bcy) ** 2 \u003c 0.0064 ? (kd.candy && v > bcy + 0.03 ? CANDY : BUCKET) : costume(kd.type, u, v, kd.ph, kd.sw);\n      if (!c) continue;\n      // Black cloth gets a moonlit outline, or it vanishes on the street.\n      if (c === CAT || c === HAT) {\n        const e = 1 / hp, out = (du, dv) => !costume(kd.type, u + du, v + dv, kd.ph, kd.sw);\n        if (out(e, 0) || out(-e, 0) || out(0, e)) c = RIM;\n      }\n      put(buf, o, c[0], c[1], c[2]);\n    }\n}\n\nfunction drawPumpkin(buf, [px, pz, sd], t) {\n  const s = sOf(pz), w = 0.17 * R * s, xs = 32 + px * R * s, ys = YH + G * s, fl = 0.72 + 0.28 * vn(t * 9, sd);\n  for (let y = max(0, floor(ys - 1.9 * w)); y \u003c= min(H - 1, floor(ys)); y++)\n    for (let x = max(0, floor(xs - w - 1)); x \u003c= min(W - 1, floor(xs + w + 1)); x++) {\n      const u = (x + 0.5 - xs) / w, v = (ys - y - 0.5) / w, o = (y * W + x) * 3;\n      if (u * u + (v - 0.78) ** 2 / 0.6 \u003c 1) {\n        // Ribbed bright orange; from 5 LEDs across, two eyes and a grin.\n        const face = w > 2.4 && ((abs(abs(u) - 0.38) \u003c 0.17 && v > 0.95 && v \u003c 1.25) || (abs(u) \u003c 0.55 && v > 0.42 && v \u003c 0.62 && abs(u * 4) % 1 \u003c 0.75));\n        if (face) put(buf, o, 255, 236 * fl, 120 * fl);\n        else put(buf, o, 255 * fl, (abs(u) % 0.5 \u003c 0.12 ? 108 : 140) * fl, 12);\n      } else if (abs(u) \u003c 0.14 && v >= 1.4 && v \u003c 1.75) put(buf, o, 90, 120, 30);\n    }\n}\n\n// A dead leaf, catching the light as it tumbles.\nconst LEAF = [[240, 124, 30], [230, 176, 50], [214, 76, 34]];\nfunction drawLeaf(buf, lf, wind) {\n  const s = sOf(lf.z), xs = floor(32 + lf.x * R * s), ys = floor(YH + G * s - lf.h * R * s), sz = max(1, round((0.11 + 0.04 * wind) * R * s));\n  const c = LEAF[lf.c], f = 0.55 + 0.4 * abs(sin(lf.ph * 2)), th = max(1, round(sz * 0.6 * abs(cos(lf.ph))));\n  for (let j = 0; j \u003c th; j++)\n    for (let i = 0; i \u003c sz; i++) if (xs + i >= 0 && xs + i \u003c W && ys - j >= 0 && ys - j \u003c H) put(buf, ((ys - j) * W + xs + i) * 3, c[0] * f, c[1] * f, c[2] * f);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const { rgb, lit, open, wc } = S, t = S.t, on = (i) => RANK[i] \u003c S.lights;\n  // A stepped sky, lighter towards the vanishing point, walls, roofs, road.\n  if (S.hueKey !== S.hue) {\n    const h = 0.76 + (S.hueKey = S.hue);\n    S.sky = Array.from({ length: YH + 1 }, (_, y) => hsv(h + 0.01, 0.75 - floor((y / YH) * 6) / 24, 0.3 + (floor((y / YH) * 6) / 6) * 0.42));\n    [S.wall, S.end, S.roof] = [hsv(h, 0.55, 0.19), hsv(h, 0.5, 0.29), hsv(h, 0.5, 0.06)];\n    S.road = [hsv(h - 0.06, 0.45, 0.14), hsv(h - 0.04, 0.4, 0.2), hsv(h - 0.04, 0.35, 0.3), hsv(h - 0.31, 0.3, 0.07)];\n  }\n  lit.fill(0);\n  // Torch beams: the ghost and the cat wave a cone of light from the hand,\n  // mostly over the street ahead, now and then up the house fronts.\n  for (const g of S.groups)\n    for (const kd of g.kids) {\n      if (kd.type === 1 || kd.z > 14) continue;\n      const ang = (kd.walk ? 0 : kd.side * 0.7) + 0.7 * sin(kd.sw * 2.2 + kd.type * 2) + 0.22 * sin(kd.sw * 5.1 + kd.type);\n      const pit = -0.19 + 0.36 * max(0, sin(kd.sw * 1.1 + kd.type * 1.3)) ** 2, dx = sin(ang) * cos(pit), dy = sin(pit), dz = cos(ang) * cos(pit);\n      const cone = (p, wx, wy, wz) => {\n        const f = wx * dx + wy * dy + wz * dz, r = sqrt(max(0, wx * wx + wy * wy + wz * wz - f * f)) / f;\n        if (f \u003c 0.3 || f > 5 || r > 0.24) return;\n        const v = (r \u003c 0.12 ? 1 : 0.55) * min(1, (0.24 - r) * 25) * min(1, (f - 0.3) * 2) * min(1, 2.6 / (f + 0.5));\n        add(lit, p * 3, 255 * v, 236 * v, 190 * v);\n      };\n      const [j0, j1] = rowsFor(kd.z + 0.3, kd.z + 5);\n      for (let j = j0; j \u003c j1; j++) cone(GL[j], XB[GL[j]] - kd.x, -0.4, ZB[GL[j]] - kd.z);\n      for (let j = wallFrom(kd.z + 0.2), j2 = wallFrom(kd.z + 5.2); j \u003c j2; j++) {\n        const p = WL[j], side = (p & 63) \u003c 32 ? -1 : 1;\n        cone(p, (MAT[p] === END ? side * (1 + XB[p]) : side) - kd.x, HB[p] - 0.4, ZB[p] - kd.z);\n      }\n    }\n  // Open doors throw a wedge of yellow light across the street.\n  HOUSES.forEach(([side, , , zd], i) => {\n    if (open[i] \u003c 0.02) return;\n    const [j0, j1] = rowsFor(zd - 1.4, zd + 1.4);\n    for (let j = j0; j \u003c j1; j++) {\n      const p = GL[j], dd = 1 - XB[p] * side, w = 0.28 + 0.4 * dd, dz = abs(ZB[p] - zd);\n      if (dd \u003c 0 || dd > 1.9 || dz > w) continue;\n      const f = open[i] * (1 - dd / 2.1) * min(1, (w - dz) * 8) * 1.2;\n      add(lit, p * 3, 255 * f, 196 * f, 70 * f);\n    }\n  });\n  // This frame's flicker of each pumpkin and colour of each window: a lamp,\n  // a guttering jack-o'-lantern, or a television cutting from shot to shot.\n  const PF = PUMPKINS.map(([, , , i], k) => (on(i) ? 0.3 + 0.7 * vn(t * 11, k) : 0));\n  for (const id of WIDS) {\n    let c = [S.wall[0] * 0.6, S.wall[1] * 0.6, S.wall[2] * 0.6], f;\n    if (on(id >> 5) && hash(id * 3 + 7) \u003c= 0.3 + 0.7 * S.lights) {\n      if (hash(id * 11 + 3) \u003c 0.25) (f = 0.35 + 0.65 * hash(floor(t * 5 + hash(id)) * 31 + id)), (c = [140 * f, 166 * f, 255 * f]);\n      else if (hash(id * 5 + 1) \u003c 0.3) (f = 0.5 + 0.5 * vn(t * 9, id)), (c = [255 * f, 132 * f, 20 * f]);\n      else (f = 0.85 + 0.15 * vn(t * 1.5, id)), (c = [255 * f, 200 * f, 96 * f]);\n    }\n    put(wc, id * 3, c[0], c[1], c[2]);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const m = MAT[p];\n    if (m === SKY) {\n      const c = S.sky[min(YH, (p / W) | 0)], st = STAR[p] ? 0.3 + 0.7 * vn(t * 3, p) : 0;\n      put(rgb, o, c[0] + 160 * st, c[1] + 150 * st, c[2] + 170 * st);\n    } else if (m === GROUND) {\n      // Road, curb, pavement and dark yards, the pumpkins' and porch lamps'\n      // light, and a low mist drifting with the wind, glowing where lit.\n      const z = ZB[p], ax = abs(XB[p]), pg = PG[p] * PF[PS[p]], lg = on(LS[p]) ? LG[p] : 0, base = S.road[ax > 1 ? 3 : ax > 0.8 ? 1 : ax > 0.74 ? 2 : 0], fg = min(1, 2.4 / z);\n      const mn = 0.65 * vn2((XB[p] - S.mx) * 1.6, z * 0.7 + t * 0.05) + 0.35 * vn2((XB[p] - S.mx * 1.4) * 3.3 + 7, z * 1.5), mi = cl((mn - 0.42) * 2.2, 0, 1) * min(1, 3.5 / z) * (ax > 1 ? 0.3 : 0.7);\n      const R0 = base[0] * fg + 255 * pg + 250 * lg, G0 = base[1] * fg + 118 * pg + 190 * lg, B0 = base[2] * fg + 20 * pg + 110 * lg, k = 0.4 * mi;\n      put(rgb, o, R0 + lit[o] * (0.8 + k) + (52 + R0 * 0.5) * mi, G0 + lit[o + 1] * (0.78 + k) + (44 + G0 * 0.5) * mi, B0 + lit[o + 2] * (0.88 + k) + (78 + B0 * 0.3) * mi);\n    } else if (m === WALL || m === END) {\n      const c = m === END ? S.end : S.wall, tone = TONE[p], r = on(REF[p]) ? LAMP[p] : 0;\n      put(rgb, o, c[0] * tone + 255 * r + lit[o] * 0.42, c[1] * tone + 196 * r + lit[o + 1] * 0.36, c[2] * tone + 110 * r + lit[o + 2] * 0.26);\n    } else if (m === ROOF) put(rgb, o, S.roof[0], S.roof[1], S.roof[2]);\n    else if (m === DOOR) put(rgb, o, 44 + 211 * open[REF[p]], 28 + 198 * open[REF[p]], 38 + 92 * open[REF[p]]);\n    else put(rgb, o, wc[REF[p] * 3] * TONE[p], wc[REF[p] * 3 + 1] * TONE[p], wc[REF[p] * 3 + 2] * TONE[p]);\n  }\n  drawBats(rgb, t);\n  // Pumpkins, children and leaves, far to near.\n  const sp = [];\n  for (const pk of PUMPKINS) if (pk[1] > 2.6 && pk[1] \u003c 22 && on(pk[3])) sp.push([pk[1], 0, pk]);\n  for (const g of S.groups) for (const kd of g.kids) sp.push([kd.z, 1, kd]);\n  for (const lf of S.leaves) sp.push([lf.z, 2, lf]);\n  sp.sort((a, b) => b[0] - a[0]);\n  for (const [, kind, obj] of sp) kind ? (kind === 1 ? drawKid(rgb, obj) : drawLeaf(rgb, obj, S.wind)) : drawPumpkin(rgb, obj, t);\n  // Each channel in steps of 4 of 255.\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, rgb[o]) & 252, min(255, rgb[o + 1]) & 252, min(255, rgb[o + 2]) & 252);\n}\n","conways-soldiers":"// ===== Patternflow pattern =====\n// Title:   Conway's Soldiers\n// Family:  algo\n// Idea:    Gold soldiers below a white line leapfrog each other across it, each jumped soldier blinking off the board, until the last one lands 1, 2, 3 and then 4 rows past the line with the fewest that can do it (2, 4, 8 and 20); each soldier carries a violet disc of light whose area is its Conway weight, the discs merge as they jump and the last soldier's disc exactly fills the ring of weight 1, and then an endless army floods the board and its gathered light still cannot fill the ring round the marked square on row 5.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Conway's soldiers (John Horton Conway, 1961), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Row=0..5, Glow=0..1\n//\n// Knob 1: Hue. Turns the soldiers round the wheel from gold at 0 through green at 0.25, pale blue at 0.5 and magenta at 0.75; the light of the weights swings through the cold hues only, violet at 0, pink at 0.25, violet at 0.5 and cyan at 0.75, so it never goes a muddy orange. The square on row 5 is pink-red at 0.\n// Knob 2: Speed. At 2 a jump takes half a second: the 20 soldiers of row 4 line up in 1.4 seconds and make their 19 jumps in 9.5, and the round of all five campaigns takes 39 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Row. At 0 the campaigns come in turn: row 4 first on squares of 7 LEDs, then the endless army that tries for row 5, then rows 1, 2 and 3 on squares of 11. At 1 to 4 that row's campaign plays over and over (2, 4, 8 or 20 soldiers); at 5 the endless army floods the board again and again.\n// Knob 4: Glow. How far the weights glow on the empty board round the target: at 0 a violet diamond about four squares across each way, with bands running in towards the target; at 1 every square on the panel shows its weight, each 0.618 of its neighbour one step nearer.\n\nconst W = 64, H = 128, CX = 32;\nconst { floor, min, max, abs, round, sin, sqrt, PI, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ss = (t) => t * t * (3 - 2 * t);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Conway's weight: a square at taxicab distance d from the target weighs\n// X^d with X = (sqrt 5 - 1) / 2 = 1/phi, so X + X^2 = 1. A jump straight\n// at the target keeps the weight (X^(d+2) + X^(d+1) = X^d), any other jump\n// loses some, so an army that ends with a soldier on the target must start\n// at weight 1 or more. For row 5 the whole half-plane below the line\n// weighs exactly 1 (the columns sum to phi^3, the rows to X^3), so every\n// finite army falls short.\nconst X = (sqrt(5) - 1) / 2;\n// The line is the gap between row 0 and row 1, pixel row 76. A square of\n// side s has its rows at y = LINE - s r .. LINE - s (r - 1).\nconst LINE = 76.5;\n// The board kept: columns -6..6, rows -10..8.\nconst C0 = 6, R0 = 10, NC = 13, NR = 19;\nconst key = (c, r) => (c + C0) + (r + R0) * NC;\n\n// The four campaigns, each the fewest soldiers that can reach its row, as\n// starting squares [column, row] (row 0 is just below the line) and jumps\n// [from column, from row, to column, to row]. Found offline by a search that\n// kept only armies of weight 1 or more and pruned any jump that would drop\n// the weight under 1; for rows 1 to 3 the armies are the column, the T and\n// the cross, and the 20 of row 4 came out with 19 jumps, all of them\n// straight at the target, so each army here weighs exactly 1 from the\n// first jump to the last. Rows 1 to 3 stand on squares of 11 LEDs, row 4\n// and the endless army on squares of 7.\nconst CAMP = [\n  null,\n  { s: 11, start: [[0, 0], [0, -1]], moves: [[0, -1, 0, 1]] },\n  { s: 11, start: [[-2, 0], [-1, 0], [0, 0], [0, -1]], moves: [[0, -1, 0, 1], [-2, 0, 0, 0], [0, 0, 0, 2]] },\n  {\n    s: 11,\n    start: [[-2, 0], [-1, 0], [0, 0], [1, 0], [2, 0], [0, -1], [0, -2], [0, -3]],\n    moves: [[0, -1, 0, 1], [-2, 0, 0, 0], [0, 0, 0, 2], [2, 0, 0, 0], [0, -3, 0, -1], [0, -1, 0, 1], [0, 1, 0, 3]],\n  },\n  {\n    s: 7,\n    start: [[-4, 0], [-3, 0], [-2, 0], [-1, 0], [0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [-3, -1], [-2, -1], [-1, -1], [0, -1], [1, -1], [-2, -2], [-1, -2], [0, -2], [1, -2], [-2, -3], [0, -3]],\n    moves: [\n      [-2, -1, -2, 1], [-1, -1, -1, 1], [-2, 1, 0, 1], [0, 0, 0, 2], [-4, 0, -2, 0], [2, 0, 0, 0], [0, -1, 0, 1], [0, 1, 0, 3],\n      [1, -2, 1, 0], [4, 0, 2, 0], [2, 0, 0, 0], [-2, -3, -2, -1], [-3, -1, -1, -1], [-1, -2, -1, 0], [0, -3, 0, -1], [0, -1, 0, 1],\n      [-2, 0, 0, 0], [0, 0, 0, 2], [0, 2, 0, 4],\n    ],\n  },\n  // Row 5: the endless army, a whole row at a time.\n  { s: 7 },\n];\n// Story seconds (one a second at Speed 2): a jump, the part of it in the\n// air, the soldiers' line-up, the wait before the first jump, the win, the\n// fade, and for the endless army one row every FLOOD.\nconst STEP = 0.5, FLY = 0.36, LINEUP = 1.4, WAIT = 0.4, WIN = 1.6, FADE = 0.6, FLOOD = 0.3, ROWS5 = 8, HOLD5 = 2;\n// Soldier radius in squares, and the order campaigns come in at Row 0.\nconst RAD = 0.42, ORDER = [4, 5, 1, 2, 3];\n// The radius, in squares, of the light disc of weight 1.\nconst HALO = 2.4;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, row: 0, glowK: 0.06,\n    camp: 4, ci: 0, phase: \"lineup\", pt: 0,\n    s: 7, sFrom: 7, sTo: 7, T: 4, Tfrom: 4, Tto: 4, zoomT: 0.6,\n    occ: new Uint8Array(NC * NR), amp: new Float32Array(NC * NR), fl: new Float32Array(NC * NR),\n    order: [], rec: 0, mi: 0, fly: null, gauge: 0, rows5: 0, t: 0, flow: 0,\n  };\n  enter(params.s, 4, true);\n}\n\nconst weight = (c, r, n) => pow(X, abs(c) + abs(r - n));\n\nfunction enter(S, camp, now) {\n  S.camp = camp;\n  const C = CAMP[camp];\n  S.occ.fill(0);\n  S.amp.fill(0);\n  S.fl.fill(0);\n  S.fly = null;\n  S.mi = 0;\n  S.rec = 0;\n  S.rows5 = 0;\n  S.sFrom = S.s;\n  S.sTo = C.s;\n  S.Tfrom = S.T;\n  S.Tto = camp;\n  S.zoomT = abs(S.sTo - S.sFrom) > 0.01 ? 1.0 : abs(S.Tto - S.Tfrom) > 0.01 ? 0.7 : 0.4;\n  S.phase = now ? (camp === 5 ? \"flood\" : \"lineup\") : \"zoom\";\n  if (now) (S.s = S.sTo), (S.T = S.Tto);\n  S.pt = 0;\n  // The line-up: nearest the line first, from the middle out.\n  if (C.start) S.order = C.start.slice().sort((a, b) => b[1] - a[1] || abs(a[0]) - abs(b[0]) || a[0] - b[0]);\n}\n\nfunction next(S) {\n  if (S.row > 0) enter(S, S.row, false);\n  else {\n    S.ci = (S.ci + 1) % ORDER.length;\n    enter(S, ORDER[S.ci], false);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.glowK = cl(k[3], 0, 1);\n  const row = cl(round(k[2]), 0, 5);\n  if (row !== S.row) {\n    S.row = row;\n    if (row > 0) enter(S, row, true);\n    else (S.ci = 0), enter(S, 4, true);\n  }\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  S.pt += g;\n  S.flow += g * 0.7;\n  const C = CAMP[S.camp], { occ, amp, fl } = S;\n  // Soldiers grow in over 0.15 s, the jumped and the faded shrink away, and\n  // white flashes die down.\n  for (let i = 0; i \u003c occ.length; i++) {\n    if (occ[i]) amp[i] = min(1, amp[i] + g / 0.15);\n    else if (amp[i] > 0) amp[i] = max(0, amp[i] - g / 0.22);\n    if (fl[i] > 0) fl[i] = max(0, fl[i] - g / 0.35);\n  }\n  if (S.phase === \"zoom\") {\n    const u = ss(cl(S.pt / S.zoomT, 0, 1));\n    S.s = S.sFrom + (S.sTo - S.sFrom) * u;\n    S.T = S.Tfrom + (S.Tto - S.Tfrom) * u;\n    if (S.pt >= S.zoomT) (S.phase = S.camp === 5 ? \"flood\" : \"lineup\"), (S.pt = 0), (S.s = S.sTo), (S.T = S.Tto);\n  } else if (S.phase === \"lineup\") {\n    const iv = min(0.25, LINEUP / S.order.length);\n    while (S.rec \u003c S.order.length && S.pt >= S.rec * iv) {\n      const [c, r] = S.order[S.rec++], i = key(c, r);\n      occ[i] = 1;\n      fl[i] = 0.8;\n    }\n    if (S.rec >= S.order.length && S.pt >= S.order.length * iv + WAIT) (S.phase = \"jump\"), (S.pt = 0), (S.mi = 0);\n  } else if (S.phase === \"jump\") {\n    const m = C.moves[S.mi], p = S.pt / FLY;\n    if (!S.fly) {\n      // Lift off: the soldier leaves its square and is in the air.\n      const ia = key(m[0], m[1]);\n      occ[ia] = 0;\n      amp[ia] = 0;\n      S.fly = { x0: m[0], y0: m[1], x1: m[2], y1: m[3], bx: (m[0] + m[2]) / 2, by: (m[1] + m[3]) / 2, over: false };\n    }\n    if (!S.fly.over && p >= 0.5) {\n      // Over the top: the jumped soldier blinks white and goes.\n      const ib = key(S.fly.bx, S.fly.by);\n      occ[ib] = 0;\n      fl[ib] = 1;\n      S.fly.over = true;\n    }\n    if (p >= 1 && !S.fly.landed) {\n      const ic = key(S.fly.x1, S.fly.y1);\n      occ[ic] = 1;\n      amp[ic] = 1;\n      fl[ic] = 0.55;\n      S.fly.landed = true;\n    }\n    if (S.pt >= STEP) {\n      S.fly = null;\n      S.mi++;\n      S.pt -= STEP;\n      if (S.mi >= C.moves.length) S.phase = \"win\";\n    }\n  } else if (S.phase === \"win\") {\n    if (S.pt >= WIN) (S.phase = \"fade\"), (S.pt = 0);\n  } else if (S.phase === \"flood\") {\n    // A whole row of the endless army at a time, from the line down to the\n    // bottom of the panel. Each row counts as the whole infinite row.\n    const want = min(ROWS5, floor(S.pt / FLOOD) + 1);\n    while (S.rows5 \u003c want) {\n      const r = -S.rows5;\n      if (r >= -R0) for (let c = -C0; c \u003c= C0; c++) (occ[key(c, r)] = 1), (fl[key(c, r)] = 0.5);\n      S.rows5++;\n    }\n    if (S.pt >= ROWS5 * FLOOD + HOLD5) (S.phase = \"fade\"), (S.pt = 0);\n  } else if (S.phase === \"fade\") {\n    const f = 1 - cl(S.pt / FADE, 0, 1);\n    for (let i = 0; i \u003c occ.length; i++) if (occ[i]) amp[i] = min(amp[i], f);\n    if (S.pt >= FADE) next(S);\n  }\n  // The gauge on the line: the army's weight against its target, 1 filling\n  // the line. The soldier in the air carries its own weight and, once it is\n  // over, the jumped one's too, so a straight jump never moves the gauge.\n  let wsum = 0;\n  if (S.camp === 5) wsum = 1 - pow(X, S.rows5);\n  else {\n    const n = S.camp;\n    for (let r = -R0; r \u003c NR - R0; r++)\n      for (let c = -C0; c \u003c= C0; c++) {\n        const i = key(c, r);\n        if (occ[i]) wsum += amp[i] * weight(c, r, n);\n      }\n    if (S.fly && !S.fly.landed) wsum += weight(S.fly.x0, S.fly.y0, n) + (S.fly.over ? weight(S.fly.bx, S.fly.by, n) : 0);\n  }\n  if (S.phase === \"fade\") wsum = min(wsum, 1 - cl(S.pt / FADE, 0, 1));\n  S.gauge += (wsum - S.gauge) * min(1, g * 10);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const s = S.s, T = S.T, n = S.camp, { occ, amp, fl } = S;\n  // The glow keeps to the cold hues; where the soldiers' hue comes near it\n  // (Hue about 0.5 to 0.6) the soldiers pale towards white to stand apart.\n  const hs = 0.12 + S.hue, hg = 0.725 + 0.225 * sin(2 * PI * S.hue);\n  const near = cl(1 - abs(((hs - hg + 1.5) % 1) - 0.5) / 0.2, 0, 1);\n  const sol = hsv(hs, 0.85 - 0.55 * near, 1);\n  const glowC = hsv(hg, 0.72, 1);\n  const mark = hsv(0.95 + S.hue, 0.8, 1);\n  // How far the weights glow: the square at distance d shows X^(gam d).\n  const gam = 0.82 - 0.62 * S.glowK, amp0 = 0.62;\n  const xg = pow(X, gam);\n  // The row-5 square blinks while the endless army stands.\n  const blink5 = n === 5 && S.phase !== \"zoom\" ? 0.55 + 0.45 * sin(S.t * 9) : 1;\n  // The target ring brightens on the win.\n  const winK = S.phase === \"win\" ? 0.5 + 0.5 * sin(S.pt * 14) : 0;\n  const half = s / 2 - 0.7;\n  const fly = S.fly && !S.fly.landed ? S.fly : null;\n  let fx = 0, fy = 0, fr2 = 0;\n  if (fly) {\n    const p = ss(cl(S.pt / FLY, 0, 1));\n    fx = fly.x0 + (fly.x1 - fly.x0) * p;\n    fy = fly.y0 + (fly.y1 - fly.y0) * p;\n    // The hop: the soldier swells as it rises towards us and shrinks as it lands.\n    const rr = RAD * (1 + 0.38 * sin(PI * p));\n    fr2 = rr * rr;\n  }\n  const gw = S.gauge * 32;\n  // Each soldier's weight as light: a disc whose area is its weight, so the\n  // light on the board is the army's weight. When a soldier jumps straight\n  // at the target its disc swallows the jumped one's and the light stays\n  // the same; the last soldier on the target holds a disc of weight 1, the\n  // size of the ring drawn round it.\n  const halos = [];\n  if (n === 5) {\n    // The endless army stands too close for its discs to show: its light is\n    // gathered on the target instead, a disc of area 1 - X^k after k whole\n    // rows, which creeps towards the ring and never fills it.\n    if (S.phase !== \"zoom\") halos.push(0, 5, HALO * HALO * S.gauge);\n  } else {\n    for (let r = -R0; r \u003c NR - R0; r++)\n      for (let c = -C0; c \u003c= C0; c++) {\n        const i = key(c, r);\n        if (!occ[i] || amp[i] \u003c= 0) continue;\n        const w = weight(c, r, n) * amp[i];\n        if (w > 0.02) halos.push(c, r, HALO * HALO * w);\n      }\n    if (fly) halos.push(fx, fy, HALO * HALO * (weight(fly.x0, fly.y0, n) + (fly.over ? weight(fly.bx, fly.by, n) : 0)));\n  }\n  const nh = halos.length;\n  const ringR = HALO, ringK = n === 5 ? blink5 : 0.4;\n  for (let y = 0; y \u003c H; y++) {\n    const v = (LINE - (y + 0.5)) / s + 0.5, r = round(v), fv = v - r;\n    for (let x = 0; x \u003c W; x++) {\n      const u = (x + 0.5 - CX) / s, c = round(u), fu = u - c;\n      let R = 0.012, G = 0.01, B = 0.03;\n      const ox = abs(fu) * s, oy = abs(fv) * s;\n      if (y === 76) {\n        // The line, dim, lit from the middle out by the army's weight.\n        const dx = abs(x + 0.5 - CX);\n        R = G = B = 0.24;\n        if (dx \u003c gw) (R = 0.55 + 0.45 * sol[0]), (G = 0.55 + 0.45 * sol[1]), (B = 0.55 + 0.45 * sol[2]);\n        else if (n === 5 && S.phase !== \"zoom\" && dx > min(30, gw)) (R = mark[0] * blink5), (G = mark[1] * blink5), (B = mark[2] * blink5);\n      } else if (ox \u003c half && oy \u003c half) {\n        // A square of the board, lit by its weight against the target row.\n        // Bands run in along the rings of equal distance towards the\n        // target, two squares apart.\n        const dist = abs(c) + abs(r - T);\n        const gl = amp0 * pow(xg, dist) * (0.62 + 0.38 * sin(2 * PI * (dist / 2 + S.flow))) + (r \u003c= 0 ? 0.088 : 0.035);\n        R = glowC[0] * gl;\n        G = glowC[1] * gl;\n        B = glowC[2] * gl;\n        if (c === 0 && r === 5) {\n          // The square no army reaches: a red ring and a cross.\n          if (ox > half - 1 || oy > half - 1 || abs(ox - oy) \u003c 0.6) (R = mark[0] * blink5), (G = mark[1] * blink5), (B = mark[2] * blink5);\n        } else if (c === 0 && r === n && n \u003c 5 && !(amp[key(0, n)] > 0) && (ox > half - 1 || oy > half - 1)) {\n          const k = 0.55 + 0.45 * winK;\n          R = max(R, k * (0.6 + 0.4 * sol[0]));\n          G = max(G, k * (0.6 + 0.4 * sol[1]));\n          B = max(B, k * (0.6 + 0.4 * sol[2]));\n        }\n        if (c >= -C0 && c \u003c= C0 && r >= -R0 && r \u003c NR - R0) {\n          const i = key(c, r), a = amp[i];\n          if (a > 0) {\n            const rad = RAD * a * (n \u003c 5 && S.phase === \"win\" && c === 0 && r === n ? 1 + 0.12 * winK : 1);\n            if (fu * fu + fv * fv \u003c rad * rad) {\n              const w = fl[i];\n              R = sol[0] + (1 - sol[0]) * w;\n              G = sol[1] + (1 - sol[1]) * w;\n              B = sol[2] + (1 - sol[2]) * w;\n            }\n          }\n        }\n      }\n      // The halos add up where they overlap.\n      let hl = 0;\n      for (let h = 0; h \u003c nh; h += 3) {\n        const du = u - halos[h], dv = v - halos[h + 1];\n        if (du * du + dv * dv \u003c halos[h + 2]) hl += 0.3;\n      }\n      // The ring of weight 1 round the target: what the army has to fill.\n      const tu = u, tv = v - n, td = sqrt(tu * tu + tv * tv) * s;\n      if (abs(td - ringR * s) \u003c 0.55 && !(R > 0.5 && G > 0.3)) {\n        const k = n === 5 ? ringK : 0.4;\n        R = max(R, (n === 5 ? mark[0] : 0.8) * k);\n        G = max(G, (n === 5 ? mark[1] : 0.8) * k);\n        B = max(B, (n === 5 ? mark[2] : 0.85) * k);\n      }\n      if (hl > 0 && !(G > 0.3 && R > 0.5 && fu * fu + fv * fv \u003c RAD * RAD)) {\n        R += glowC[0] * hl;\n        G += glowC[1] * hl;\n        B += glowC[2] * hl;\n      }\n      if (fly) {\n        const du = u - fx, dv = v - fy;\n        if (du * du + dv * dv \u003c fr2) (R = 0.6 + 0.4 * sol[0]), (G = 0.6 + 0.4 * sol[1]), (B = 0.6 + 0.4 * sol[2]);\n      }\n      display.setPixel(x, y, round(255 * cl(R, 0, 1)), round(255 * cl(G, 0, 1)), round(255 * cl(B, 0, 1)));\n    }\n  }\n}\n","koebe-packing":"// ===== Patternflow pattern =====\n// Title:   Koebe Packing\n// Family:  cells\n// Idea:    A tall rectangle of discs, each touching exactly its neighbours in a triangulation drawn as spokes through the kissing points, re-solves itself every time an edge of the triangulation flips or a vertex is born or removed, so the discs swell and shrink into the one packing the new graph allows.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: circle packing theorem (Paul Koebe, 1936; E. M. Andreev, 1970; William Thurston, 1980s), computed by the iteration of Charles Collins and Kenneth Stephenson (2003), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Circles=22..56, Graph=0..1\n//\n// Knob 1: Hue. Turns the colours of the degrees round the wheel: at 0 the small discs of degree 4 are pink, 5 amber, 6 cyan, 7 blue and the big ones of degree 8 violet; at 0.5 the same five are green, blue, red, amber and lime.\n// Knob 2: Speed. At 2 the triangulation changes every 1.2 seconds and the discs take about a second to settle into the new packing; at 0.2 a change comes every 12 seconds, at 3 every 0.8.\n// Knob 3: Circles. About how many discs the packing holds, 22 to 56 (a birth or a removal moves it by one or two for a while); the rim of the rectangle grows with them, 14 boundary discs up to 24, 20 up to 40, 26 above. Turning it grows a new triangulation from points.\n// Knob 4: Graph. At 0 the discs are solid and the triangulation shows as dark spokes from each centre to the points where it kisses its neighbours; toward 1 the discs empty to rings and the spokes turn white, so the triangulation itself is the picture.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, atan2, round, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Hue of each degree, added to Hue + 0.9 so that 0 opens on pink, not red.\n// A boundary disc counts as the degree its angle would have inside: faces\n// times 2 pi over its target angle, so a side disc with three faces is a 6.\nconst DEG_HUE = [0, 0, 0, 0, 0, 0.21, 0.6, 0.73, 0.86];\n// Interior degree limits for an ordinary flip; a disc being born or removed\n// may sit at 3 for a while.\nconst DMIN = 4, DMAX = 8;\n// One change in this many story seconds (one a second at Speed 2).\nconst EVERY = 1.2;\n// How freely a flip may push degrees away from 6.\nconst TEMP = 4;\n\n// --- the triangulation ---\n// Each vertex keeps its flower: the neighbours in counterclockwise order,\n// closed for an interior vertex, open for a boundary vertex (from the next\n// boundary vertex round to the previous one). kind is 0 inside, 1 on a side\n// of the rectangle, 2 at a corner. Target angle sums: 2 pi inside, pi along\n// a side (the centres line up), pi/2 at a corner.\n\nfunction faces(S, v) {\n  return S.kind[v] ? S.fl[v].length - 1 : S.fl[v].length;\n}\nfunction target(S, v) {\n  return S.kind[v] === 0 ? TAU : S.kind[v] === 1 ? PI : PI / 2;\n}\nfunction effDeg(S, v, df = 0) {\n  return round(((faces(S, v) + df) * TAU) / target(S, v));\n}\nfunction hasNb(S, a, b) {\n  return S.fl[a].indexOf(b) >= 0;\n}\n// Two boundary vertices may be joined across the inside only when they are\n// the two neighbours of one corner (the edge cuts that corner off); joined\n// anywhere else they would have to touch through the line of discs between.\nfunction cornerCut(S, a, b) {\n  if (!S.kind[a] || !S.kind[b]) return true;\n  const B = S.B, d = (S.bi[b] - S.bi[a] + B) % B;\n  if (d === 2) return S.kind[S.ring[(S.bi[a] + 1) % B]] === 2;\n  if (d === B - 2) return S.kind[S.ring[(S.bi[b] + 1) % B]] === 2;\n  return false;\n}\n// Can vertex v lose a face, or gain one? A side disc keeps two to four\n// faces, a corner disc one or two.\nfunction canLose(S, v, focus) {\n  const f = faces(S, v);\n  if (S.kind[v] === 0) return f - 1 >= (v === focus ? 3 : DMIN);\n  return f - 1 >= (S.kind[v] === 2 ? 1 : 2);\n}\nfunction canGain(S, v) {\n  const f = faces(S, v);\n  if (S.kind[v] === 0) return f + 1 \u003c= DMAX;\n  return f + 1 \u003c= (S.kind[v] === 2 ? 2 : 4);\n}\n\n// The edge uv with its two triangles (u, v, a) and (u, b, v), both\n// counterclockwise, or null when uv lies on the boundary.\nfunction quad(S, u, v) {\n  const fu = S.fl[u], i = fu.indexOf(v), n = fu.length;\n  if (i \u003c 0) return null;\n  if (S.kind[u]) {\n    if (i === 0 || i === n - 1) return null;\n    return [fu[i + 1], fu[i - 1]];\n  }\n  return [fu[(i + 1) % n], fu[(i - 1 + n) % n]];\n}\n\nfunction canFlip(S, u, v, focus) {\n  const q = quad(S, u, v);\n  if (!q) return null;\n  const [a, b] = q;\n  if (a === b || hasNb(S, a, b) || !cornerCut(S, a, b)) return null;\n  if (!canLose(S, u, focus) || !canLose(S, v, focus) || !canGain(S, a) || !canGain(S, b)) return null;\n  return q;\n}\n\n// Flip uv to ab: the quadrilateral u, b, v, a keeps its four sides and\n// swaps its diagonal.\nfunction flip(S, u, v, a, b) {\n  const rm = (x, y) => S.fl[x].splice(S.fl[x].indexOf(y), 1);\n  const ins = (x, after, y) => S.fl[x].splice(S.fl[x].indexOf(after) + 1, 0, y);\n  rm(u, v);\n  rm(v, u);\n  ins(a, u, b);\n  ins(b, v, a);\n  S.flash.push({ a, b, t: 0 });\n}\n\nfunction newId(S) {\n  for (let i = 0; i \u003c S.kind.length; i++) if (!S.alive[i] && S.dr[i] \u003c= 0) return i;\n  S.kind.push(0), S.fl.push([]), S.alive.push(0), S.bi.push(-1);\n  for (const k of [\"R\", \"x\", \"y\", \"dx\", \"dy\", \"dr\", \"hu\"]) S[k].push(0);\n  return S.kind.length - 1;\n}\n\n// A new vertex in triangle (u, v, w), counterclockwise: it starts with\n// degree 3, the small circle in the gap between three that touch.\nfunction insert(S, u, v, w) {\n  const x = newId(S);\n  S.kind[x] = 0;\n  S.alive[x] = 1;\n  S.fl[x] = [u, v, w];\n  const ins = (p, after, y) => S.fl[p].splice(S.fl[p].indexOf(after) + 1, 0, y);\n  ins(u, v, x);\n  ins(v, w, x);\n  ins(w, u, x);\n  S.R[x] = 0.15 * min(S.R[u], S.R[v], S.R[w]);\n  // Born at the gap between the three, with no size yet.\n  S.dx[x] = (S.dx[u] + S.dx[v] + S.dx[w]) / 3;\n  S.dy[x] = (S.dy[u] + S.dy[v] + S.dy[w]) / 3;\n  S.dr[x] = 0;\n  S.born = x;\n  for (const p of [u, v, w]) S.flash.push({ a: x, b: p, t: 0 });\n  return x;\n}\n\n// Remove an interior vertex of degree 3: its three triangles become one.\nfunction remove(S, x) {\n  for (const p of S.fl[x]) S.fl[p].splice(S.fl[p].indexOf(x), 1);\n  S.fl[x] = [];\n  S.alive[x] = 0;\n}\n\n// The starting triangulation: a grid of c by 2c vertices, each square cut\n// by a random diagonal, its outer ring the boundary with corners at the\n// grid's corners; then interior vertices put into random triangles or taken\n// out until there are n, and a few hundred random flips to forget the grid.\nfunction build(S, n, grow) {\n  const c = max(3, round(sqrt(n / 2))), r = 2 * c;\n  Object.assign(S, { kind: [], fl: [], alive: [], bi: [], R: [], x: [], y: [], dx: [], dy: [], dr: [], hu: [], flash: [], focus: -1, mode: 0, born: -1 });\n  const id = (i, j) => j * c + i, adj = [];\n  for (let k = 0; k \u003c c * r; k++) newId(S), (S.alive[k] = 1), (adj[k] = new Set());\n  const link = (p, q) => (adj[p].add(q), adj[q].add(p));\n  for (let j = 0; j \u003c r; j++)\n    for (let i = 0; i \u003c c; i++) {\n      if (i + 1 \u003c c) link(id(i, j), id(i + 1, j));\n      if (j + 1 \u003c r) link(id(i, j), id(i, j + 1));\n      if (i + 1 \u003c c && j + 1 \u003c r) Math.random() \u003c 0.5 ? link(id(i, j), id(i + 1, j + 1)) : link(id(i + 1, j), id(i, j + 1));\n    }\n  // The boundary ring, counterclockwise (with y up): along the bottom,\n  // up the right, back along the top, down the left.\n  const ring = [];\n  for (let i = 0; i \u003c c - 1; i++) ring.push(id(i, 0));\n  for (let j = 0; j \u003c r - 1; j++) ring.push(id(c - 1, j));\n  for (let i = c - 1; i > 0; i--) ring.push(id(i, r - 1));\n  for (let j = r - 1; j > 0; j--) ring.push(id(0, j));\n  S.ring = ring;\n  S.B = ring.length;\n  S.corners = [id(0, 0), id(c - 1, 0), id(c - 1, r - 1), id(0, r - 1)];\n  ring.forEach((v, k) => ((S.kind[v] = 1), (S.bi[v] = k)));\n  for (const v of S.corners) S.kind[v] = 2;\n  // Flowers by angle round each grid point; a boundary flower starts just\n  // after the widest gap, which is the outside.\n  for (let k = 0; k \u003c c * r; k++) {\n    const i = k % c, j = floor(k / c);\n    const nb = [...adj[k]].map((q) => [atan2(floor(q / c) - j, (q % c) - i), q]).sort((p, q) => p[0] - q[0]);\n    let start = 0;\n    if (S.kind[k]) {\n      let gap = -1;\n      for (let m = 0; m \u003c nb.length; m++) {\n        const g = (nb[m][0] - nb[(m - 1 + nb.length) % nb.length][0] + TAU) % TAU || TAU;\n        if (g > gap) (gap = g), (start = m);\n      }\n    }\n    S.fl[k] = nb.map((_, m) => nb[(start + m) % nb.length][1]);\n    S.alive[k] = 1;\n    S.R[k] = 1;\n  }\n  // Each new vertex is followed by flips, which spread the degrees and free\n  // room for the next one.\n  for (let tries = 0; tries \u003c 400 && count(S) !== n; tries++) {\n    const t = triangles(S).filter((p) => p.every((q) => canGain(S, q)));\n    if (count(S) > n) drop(S);\n    else if (t.length) insert(S, ...t[floor(Math.random() * t.length)]);\n    for (let k = 0; k \u003c 20; k++) randomFlip(S, TEMP);\n  }\n  S.born = -1;\n  for (let k = 0; k \u003c 300; k++) randomFlip(S, TEMP);\n  S.flash = [];\n  for (let k = 0; k \u003c 600; k++) sweep(S);\n  layout(S);\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    S.dx[v] = S.x[v];\n    S.dy[v] = S.y[v];\n    S.dr[v] = S.alive[v] && !grow ? S.tr[v] : 0;\n    S.hu[v] = hueOf(S, v);\n  }\n}\n\n// Take one interior vertex out: flip its edges away until it has three,\n// then remove it.\nfunction drop(S) {\n  const vs = [];\n  for (let v = 0; v \u003c S.kind.length; v++) if (S.alive[v] && !S.kind[v]) vs.push(v);\n  vs.sort((p, q) => S.fl[p].length - S.fl[q].length);\n  for (const x of vs.slice(0, 6)) {\n    S.focus = x;\n    for (let k = 0; k \u003c 12 && S.fl[x].length > 3; k++) {\n      const opts = S.fl[x].filter((p) => canFlip(S, x, p, x));\n      if (!opts.length) break;\n      const p = opts[floor(Math.random() * opts.length)], q = canFlip(S, x, p, x);\n      flip(S, x, p, q[0], q[1]);\n    }\n    if (S.fl[x].length === 3 && S.fl[x].every((p) => canLose(S, p, -1))) {\n      remove(S, x);\n      break;\n    }\n  }\n  S.focus = -1;\n}\n\nfunction count(S) {\n  let n = 0;\n  for (let v = 0; v \u003c S.kind.length; v++) n += S.alive[v];\n  return n;\n}\n\n// Every triangle once, counterclockwise.\nfunction triangles(S) {\n  const out = [];\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (!S.alive[v]) continue;\n    const f = S.fl[v], n = f.length, m = S.kind[v] ? n - 1 : n;\n    for (let i = 0; i \u003c m; i++) {\n      const a = f[i], b = f[(i + 1) % n];\n      if (v \u003c a && v \u003c b) out.push([v, a, b]);\n    }\n  }\n  return out;\n}\n\n// Interior degrees like to stay near 6: a flip that moves them away is\n// taken less often, so the packing keeps a mix of sizes without running to\n// one huge disc.\nfunction energy(S, vs, d) {\n  let e = 0;\n  vs.forEach((v, k) => {\n    const g = effDeg(S, v, d[k]);\n    e += (g - 6) * (g - 6);\n  });\n  return e;\n}\n\nfunction randomFlip(S, temp) {\n  for (let tries = 0; tries \u003c 40; tries++) {\n    const u = floor(Math.random() * S.kind.length);\n    if (!S.alive[u] || u === S.focus) continue;\n    const f = S.fl[u], v = f[floor(Math.random() * f.length)];\n    if (v === S.focus) continue;\n    const q = canFlip(S, u, v, -1);\n    if (!q) continue;\n    const vs = [u, v, q[0], q[1]], dE = energy(S, vs, [-1, -1, 1, 1]) - energy(S, vs, [0, 0, 0, 0]);\n    if (dE > 0 && Math.random() > exp(-dE / temp)) continue;\n    flip(S, u, v, q[0], q[1]);\n    return true;\n  }\n  return false;\n}\n\n// One change of the triangulation. A disc being born keeps growing by\n// flips of the edges across from it until it has degree 5 or 6; a disc\n// being removed loses an edge a change until it is down to three, then goes.\nfunction change(S) {\n  const x = S.focus;\n  if (x >= 0 && S.mode === 1) {\n    // Grow: flip an edge ab of x's link to the vertex c across it.\n    const f = S.fl[x], n = f.length, opts = [];\n    for (let i = 0; i \u003c n; i++) {\n      const a = f[i], b = f[(i + 1) % n], q = canFlip(S, a, b, x);\n      if (q && (q[0] === x || q[1] === x)) opts.push([a, b, q]);\n    }\n    if (opts.length && n \u003c S.goal) {\n      const [a, b, q] = opts[floor(Math.random() * opts.length)];\n      flip(S, a, b, q[0], q[1]);\n      if (S.fl[x].length >= S.goal) S.focus = -1;\n      return;\n    }\n    S.focus = -1;\n  } else if (x >= 0 && S.mode === 2) {\n    // Shrink: flip one of x's own edges away.\n    if (S.fl[x].length \u003c= 3) {\n      if (S.fl[x].every((p) => canLose(S, p, -1))) remove(S, x);\n      S.focus = -1;\n      return;\n    }\n    const opts = S.fl[x].filter((p) => canFlip(S, x, p, x));\n    if (opts.length) {\n      const p = opts[floor(Math.random() * opts.length)], q = canFlip(S, x, p, x);\n      flip(S, x, p, q[0], q[1]);\n      return;\n    }\n    S.focus = -1;\n  }\n  const n = count(S), r = Math.random();\n  if (r \u003c 0.22 && n \u003c= S.n) {\n    // Born in the biggest gap: the triangle with the largest circles.\n    let best = null, bs = -1;\n    for (const t of triangles(S)) {\n      if (!t.every((p) => canGain(S, p))) continue;\n      const s = min(S.R[t[0]], S.R[t[1]], S.R[t[2]]) * (0.8 + 0.4 * Math.random());\n      if (s > bs) (bs = s), (best = t);\n    }\n    if (best) {\n      S.focus = insert(S, ...best);\n      S.mode = 1;\n      S.goal = 5 + (Math.random() \u003c 0.5 ? 1 : 0);\n      return;\n    }\n  } else if (r \u003c 0.44 && n >= S.n) {\n    // Removed: an interior disc of low degree, not one just born.\n    const vs = [];\n    for (let v = 0; v \u003c S.kind.length; v++) if (S.alive[v] && !S.kind[v] && v !== S.born) vs.push(v);\n    vs.sort((p, q) => S.fl[p].length - S.fl[q].length);\n    if (vs.length) {\n      S.focus = vs[floor(Math.random() * min(3, vs.length))];\n      S.mode = 2;\n      change(S);\n      return;\n    }\n  }\n  randomFlip(S, TEMP);\n}\n\n// --- the packing ---\n// The angle at v in the triangle of three mutually tangent circles with\n// radii r, a, b: sides r + a, r + b, a + b, and by the half-angle form of\n// the law of cosines sin^2(theta / 2) = ab / ((r + a)(r + b)).\nconst ang = (r, a, b) => 2 * asin(sqrt((a * b) / ((r + a) * (r + b))));\n\n// One sweep of Collins and Stephenson: each vertex is given the radius its\n// angle sum would need if its k neighbours were all one size (the uniform\n// neighbour model): beta = sin(sum / 2k) gives that size, delta =\n// sin(target / 2k) the radius that meets the target with it. Every target\n// is an angle, so the packing is free in scale; the mean radius is held at 1.\nfunction sweep(S) {\n  const R = S.R;\n  let sum = 0, n = 0, err = 0;\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (!S.alive[v]) continue;\n    const f = S.fl[v], m = f.length, k = S.kind[v] ? m - 1 : m, r = R[v];\n    let th = 0;\n    for (let i = 0; i \u003c k; i++) th += ang(r, R[f[i]], R[f[(i + 1) % m]]);\n    const T = target(S, v);\n    err = max(err, abs(th - T));\n    const beta = min(0.99999, sin(th / (2 * k))), delta = sin(T / (2 * k));\n    R[v] = ((beta * r) / (1 - beta)) * ((1 - delta) / delta);\n    sum += R[v];\n    n++;\n  }\n  for (let v = 0; v \u003c S.kind.length; v++) if (S.alive[v]) R[v] *= n / sum;\n  return err;\n}\n\n// Lay the circles out from one placed triangle: each placed vertex places\n// the rest of its flower by the angles round it, counterclockwise from a\n// placed neighbour (and clockwise too on the boundary). Then turn the\n// rectangle upright from its first corner to its second and fit it to the\n// panel.\nfunction layout(S) {\n  const nV = S.kind.length, R = S.R, X = new Float64Array(nV), Y = new Float64Array(nV), done = new Uint8Array(nV);\n  let v0 = 0;\n  while (!S.alive[v0]) v0++;\n  const v1 = S.fl[v0][0];\n  done[v0] = done[v1] = 1;\n  X[v1] = R[v0] + R[v1];\n  const queue = [v0, v1];\n  while (queue.length) {\n    const v = queue.shift(), f = S.fl[v], m = f.length;\n    let i0 = -1;\n    for (let i = 0; i \u003c m; i++) if (done[f[i]]) (i0 = i), (i = m);\n    if (i0 \u003c 0) continue;\n    const step = (dir) => {\n      let prev = f[i0], i = i0;\n      for (let s = 1; s \u003c m; s++) {\n        const j = S.kind[v] ? i + dir : (i + dir + m) % m;\n        if (j \u003c 0 || j >= m) break;\n        const u = f[j];\n        if (!done[u]) {\n          const a = atan2(Y[prev] - Y[v], X[prev] - X[v]) + dir * ang(R[v], R[prev], R[u]), d = R[v] + R[u];\n          X[u] = X[v] + d * cos(a);\n          Y[u] = Y[v] + d * sin(a);\n          done[u] = 1;\n          queue.push(u);\n        }\n        prev = u;\n        i = j;\n      }\n    };\n    step(1);\n    if (S.kind[v]) step(-1);\n  }\n  const [k0, k1] = S.corners, rot = -atan2(Y[k1] - Y[k0], X[k1] - X[k0]), cr = cos(rot), sr = sin(rot);\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let v = 0; v \u003c nV; v++) {\n    if (!S.alive[v]) continue;\n    const x = X[v] * cr - Y[v] * sr, y = X[v] * sr + Y[v] * cr;\n    (X[v] = x), (Y[v] = y);\n    x0 = min(x0, x - R[v]), x1 = max(x1, x + R[v]), y0 = min(y0, y - R[v]), y1 = max(y1, y + R[v]);\n  }\n  const sc = min((W - 1) / (x1 - x0), (H - 1) / (y1 - y0)), ox = (W - sc * (x1 - x0)) / 2, oy = (H - sc * (y1 - y0)) / 2;\n  S.tr = S.tr && S.tr.length === nV ? S.tr : new Float64Array(nV);\n  for (let v = 0; v \u003c nV; v++) {\n    if (!S.alive[v]) continue;\n    S.x[v] = ox + (X[v] - x0) * sc;\n    // Panel rows run down, so y up becomes the row counted from the bottom.\n    S.y[v] = H - (oy + (Y[v] - y0) * sc);\n    S.tr[v] = R[v] * sc;\n  }\n}\n\nfunction hueOf(S, v) {\n  return 0.9 + S.hue + DEG_HUE[cl(effDeg(S, v), 4, 8)];\n}\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, graph: 0.06, n: 0, clock: 0, buf: new Float32Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 22, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  S.graph = cl(k[3], 0, 1);\n  const n = round(cl(k[2], 22, 56));\n  if (n !== S.n) {\n    // A new count grows a new packing from points; the first one opens\n    // already grown.\n    build(S, n, S.n > 0);\n    S.n = n;\n    // The first change comes soon after the start.\n    S.clock = EVERY * 0.6;\n  }\n  const g = (d * S.speed) / 2;\n  S.clock += g;\n  if (S.clock >= EVERY) {\n    S.clock -= EVERY;\n    change(S);\n  }\n  for (let i = 0; i \u003c 25; i++) sweep(S);\n  layout(S);\n  // The drawn discs ease toward the packing, about a second to settle at\n  // Speed 2; a removed disc shrinks to nothing where it was.\n  const e = 1 - exp(-g * 2.6);\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (S.alive[v]) {\n      S.dx[v] += (S.x[v] - S.dx[v]) * e;\n      S.dy[v] += (S.y[v] - S.dy[v]) * e;\n      S.dr[v] += (S.tr[v] - S.dr[v]) * e;\n      // The colour turns the short way round the wheel, so it stays bright\n      // on the way instead of passing through grey.\n      const dh = hueOf(S, v) - S.hu[v];\n      S.hu[v] += (dh - round(dh)) * e;\n    } else if (S.dr[v] > 0) {\n      S.dr[v] -= S.dr[v] * e + g * 0.5;\n      if (S.dr[v] \u003c 0.3) S.dr[v] = 0;\n    }\n  }\n  for (const f of S.flash) f.t += g;\n  S.flash = S.flash.filter((f) => f.t \u003c 1.4 && S.alive[f.a] && S.alive[f.b]);\n}\n\nfunction line(buf, x0, y0, x1, y1, fn) {\n  const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n  for (let i = 0; i \u003c= n; i++) {\n    const t = n ? i / n : 0, x = floor(mix(x0, x1, t) + 0.5), y = floor(mix(y0, y1, t) + 0.5);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) fn((y * W + x) * 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.kind) return;\n  const buf = S.buf, gk = S.graph;\n  buf.fill(0);\n  const fill = 1 - 0.82 * gk;\n  // Discs: a solid inside (dimmed toward Graph 1), a full-bright rim one LED\n  // wide, and half an LED of black at the edge so two discs part everywhere\n  // but where they kiss.\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    const r = S.dr[v];\n    if (r \u003c 0.6) continue;\n    const cx = S.dx[v], cy = S.dy[v], ro = r - 0.45, ri = r - 1.55, c3 = hsv(S.hu[v], 0.9, 1);\n    const xa = max(0, floor(cx - r)), xb = min(W - 1, floor(cx + r)), ya = max(0, floor(cy - r)), yb = min(H - 1, floor(cy + r));\n    for (let y = ya; y \u003c= yb; y++)\n      for (let x = xa; x \u003c= xb; x++) {\n        const dd = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2);\n        if (dd >= ro) continue;\n        const b = dd > ri ? 1 : fill, o = (y * W + x) * 3;\n        buf[o] = c3[0] * b;\n        buf[o + 1] = c3[1] * b;\n        buf[o + 2] = c3[2] * b;\n      }\n  }\n  // The triangulation: each edge from centre to centre through the point\n  // where the two discs touch. Dark on a solid disc, white on a ring.\n  const dark = 0.3 * (1 - gk), wt = 0.85 * gk;\n  for (let v = 0; v \u003c S.kind.length; v++) {\n    if (!S.alive[v]) continue;\n    for (const u of S.fl[v]) {\n      if (u \u003c v && S.alive[u]) continue;\n      line(buf, S.dx[v], S.dy[v], S.dx[u], S.dy[u], (o) => {\n        buf[o] = buf[o] * dark + wt;\n        buf[o + 1] = buf[o + 1] * dark + wt;\n        buf[o + 2] = buf[o + 2] * dark + wt;\n      });\n    }\n  }\n  // A new edge flashes white for a second as the two discs come to touch.\n  for (const f of S.flash) {\n    const a = cl(1.4 - f.t, 0, 1);\n    line(buf, S.dx[f.a], S.dy[f.a], S.dx[f.b], S.dy[f.b], (o) => {\n      buf[o] = mix(buf[o], 1, a);\n      buf[o + 1] = mix(buf[o + 1], 1, a);\n      buf[o + 2] = mix(buf[o + 2], 1, a);\n    });\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(255 * min(1, buf[o])), round(255 * min(1, buf[o + 1])), round(255 * min(1, buf[o + 2])));\n}\n","lonely-runner":"// ===== Patternflow pattern =====\n// Title:   Lonely Runner\n// Family:  rhythm\n// Idea:    Runners at distinct whole-number speeds climb side by side round a track that is the panel's 128 rows wrapped top to bottom, each a bold bar in its own lane carrying a zone of 128/k rows either way, and whenever no other runner is inside its zone the runner is lonely, so its zone lights up and its bar burns white; with speeds 1 to k they all go lonely together, equally spaced round the track, and with scattered speeds the flares come one by one at odd times.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the lonely runner conjecture (Jörg M. Wills, 1967; Thomas Cusick, 1973), proven for up to seven runners by Javier Barajas and Oriol Serra (2008), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Runners=3..8, Scatter=0..1\n//\n// Knob 1: Hue. Turns the runners' colours round the wheel together: at 0 three runners are cyan, magenta and yellow; at 0.25 violet, orange and green; at 0.5 red, green and blue. With more runners the colours sit closer together round the same wheel.\n// Knob 2: Speed. At 2 the fastest runner laps in 1.8 seconds; with speeds 1, 2 and 3 the slowest laps in 5.4, and then all three are back on the line together and the race goes round again. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Runners. How many run, 3 to 8, each in its own lane, and the zone shrinks to 128/k rows either way: 43 rows with three, 16 with eight. Turning it starts a new race from the line at the bottom. With eight at speeds 1 to 8 the first lonely moment is a staircase of all eight bars, 1.8 seconds in.\n// Knob 4: Scatter. Below 0.2 the speeds are 1, 2, ... k, the case where all the runners go lonely together. In four steps up to 1 they become k different whole numbers drawn from 1 to k+3, k+6, k+9 and k+12, and the lonely moments break apart into single flares, some held for a second or more. Each step starts a new race.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The fastest runner's lap, in story seconds (one a second at Speed 2). The\n// slowest runner's lap is the whole race, since every speed is a whole\n// number: at its end all of them are back on the line together.\nconst LAP_FAST = 1.8;\n// A runner's bar, in rows, and the row its middle starts on: the bars stand\n// on the bottom edge at the start.\nconst BAR = 14, START = H - BAR / 2;\n// Lonely means no other runner nearer than 1/k of a lap, either way round.\n// With speeds 1..k the nearest neighbours reach exactly 1/k for a single\n// instant, which no frame would ever land on, so the check runs at 24\n// moments inside each frame and allows half an LED row (1/256 of a lap).\nconst SUB = 24, TOL = 1 / 256;\n// How long a flare takes to fade after the runner stops being lonely.\nconst FADE = 0.35;\n// The tail behind a bar is this many story seconds of its running.\nconst TAIL = 0.25;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, k: 0, level: -1,\n    v: [], pos: new Float32Array(8), flare: new Float32Array(8), lonely: new Uint8Array(8),\n    lane: new Int8Array(W), shade: new Float32Array(W), col: [], colHue: NaN, colK: 0,\n  };\n}\n\n// A small fixed hash, so each Scatter step draws the same speeds every time.\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The speeds for k runners at Scatter step L: 1..k at step 0, otherwise k\n// distinct whole numbers from 1..k+3L, shuffled by a fixed seed and sorted\n// so the slowest runs in the left lane.\nfunction speeds(k, L) {\n  const pool = [];\n  for (let i = 1; i \u003c= k + 3 * L; i++) pool.push(i);\n  if (L > 0)\n    for (let i = pool.length - 1; i > 0; i--) {\n      const j = floor(hash(k * 101 + L * 7 + i * 13) * (i + 1));\n      const tmp = pool[i];\n      pool[i] = pool[j];\n      pool[j] = tmp;\n    }\n  return pool.slice(0, k).sort((a, b) => a - b);\n}\n\n// A new race: lanes for k runners with a dark LED between them, and every\n// runner back on the line.\nfunction restart(S, k, L) {\n  S.k = k;\n  S.level = L;\n  S.v = speeds(k, L);\n  S.t = 0;\n  S.flare.fill(0);\n  for (let x = 0; x \u003c W; x++) {\n    const j = floor((x * k) / W);\n    const edge = round(((j + 1) * W) / k) - 1;\n    S.lane[x] = x === edge && j \u003c k - 1 ? -1 : j;\n    const x0 = round((j * W) / k), u = (x - x0 + 0.5) / (edge - x0 + 1);\n    S.shade[x] = 0.62 + 0.38 * (1 - (2 * u - 0.7) ** 2 / 1.69);\n  }\n}\n\n// Nearest distance from runner i to any other, as a share of a lap, for\n// the race at story time t.\nfunction nearest(S, i, t, P) {\n  const pi = (S.v[i] * t) / P;\n  let d = 1;\n  for (let j = 0; j \u003c S.k; j++) {\n    if (j === i) continue;\n    let g = pi - (S.v[j] * t) / P;\n    g -= floor(g);\n    d = min(d, g, 1 - g);\n  }\n  return d;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  const k = cl(round(kv[2]), 3, 8), L = min(4, floor(cl(kv[3], 0, 1) * 5));\n  if (k !== S.k || L !== S.level) restart(S, k, L);\n  const g = (d * S.speed) / 2, P = LAP_FAST * S.v[k - 1], t0 = S.t;\n  S.t += g;\n  const need = 1 / k - TOL;\n  for (let i = 0; i \u003c k; i++) {\n    let lonely = 0;\n    for (let s = 1; s \u003c= SUB && !lonely; s++) if (nearest(S, i, t0 + (g * s) / SUB, P) >= need) lonely = 1;\n    S.lonely[i] = lonely;\n    S.flare[i] = lonely ? 1 : S.flare[i] * exp(-g / FADE);\n    const p = (S.v[i] * S.t) / P;\n    S.pos[i] = p - floor(p);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.k) return;\n  const k = S.k;\n  if (S.colHue !== S.hue || S.colK !== k) {\n    S.col = [];\n    for (let i = 0; i \u003c k; i++) S.col.push(hsv(0.5 + S.hue + i / k, 0.9, 1));\n    S.colHue = S.hue;\n    S.colK = k;\n  }\n  const R = H / k, half = BAR / 2;\n  // Each runner's middle row; it climbs, so the row falls as the lap goes on.\n  const c = [];\n  for (let i = 0; i \u003c k; i++) c.push(START - S.pos[i] * H);\n  for (let y = 0; y \u003c H; y++) {\n    // Signed distance in rows from each runner, the short way round.\n    const dy = [];\n    for (let i = 0; i \u003c k; i++) {\n      let e = y + 0.5 - c[i];\n      e -= H * floor(e / H + 0.5);\n      dy.push(e);\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const ln = S.lane[x];\n      let r = 0, gg = 0, b = 0;\n      for (let i = 0; i \u003c k; i++) {\n        const e = dy[i], a = abs(e), cc = S.col[i], f = S.flare[i];\n        let v = 0;\n        if (ln === i) {\n          // The runner's own lane. Its zone shows faintly; while the runner\n          // is lonely it lights up, brightest at the runner, its two edges\n          // 128/k rows away drawn as lines. With speeds 1..k those edges\n          // land exactly on the neighbours' lines: the case is tight.\n          if (a \u003c R) {\n            v = 0.1;\n            if (f > 0.02) v = max(v, f * (a > R - 1 ? 0.9 : 0.15 + 0.5 * (1 - a / R) ** 1.5));\n          }\n          // A tail below the bar, as long as a quarter second of its running.\n          const tail = TAIL * S.v[i] * (H / (LAP_FAST * S.v[k - 1]));\n          if (e > half && e \u003c half + tail) v = max(v, 0.7 * (1 - (e - half) / tail) ** 2);\n          if (a \u003c half) v = 1;\n          else if (a \u003c half + 1) v = max(v, 1 - (a - half));\n          // Lit from the left, so a lane reads as a rounded rod.\n          v *= S.shade[x];\n        } else if (a \u003c 0.5) {\n          // Every runner draws a line across the other lanes at its middle,\n          // so in each lane you can see who is inside that runner's zone.\n          v = 0.55;\n        }\n        // A lonely runner's bar burns white-hot for a beat.\n        const w = ln === i && a \u003c half + 1 ? 0.55 * f * v : 0;\n        r += cc[0] * v + w;\n        gg += cc[1] * v + w;\n        b += cc[2] * v + w;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, gg)), round(255 * min(1, b)));\n    }\n  }\n}\n","oloid":"// ===== Patternflow pattern =====\n// Title:   Oloid\n// Family:  space\n// Idea:    An oloid, the hull of two circles each through the other's centre, rolls toward you down a dark floor in its swaying wobble, touching the floor along one straight ruling at a time, and leaves behind it the print of its own surface unrolled flat: the half round each circle in its own colour, the two locked together in a serpentine track that recedes up the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the oloid (Paul Schatz, 1929), rolled on its development as Hans Dirnböck and Hellmuth Stachel unrolled it (1997), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tilt=0..1, Fade=0..1\n//\n// Knob 1: Hue. Turns both halves round the wheel together, 0.38 of a turn apart: at 0 the half round one circle is azure and the half round the other pink; at 0.15 violet and orange; at 0.45 red and green; at 0.6 yellow and cyan; at 0.8 green and violet. Orange and yellow are printed brighter so they never dim to brown.\n// Knob 2: Speed. At 2 the oloid rolls its whole surface over the floor once in 5 seconds, coming 4.8 circle radii toward you and swaying 0.28 radii either way twice on the way. At 0.2 it rolls ten times slower, at 3 half as fast again.\n// Knob 3: Tilt. The camera's angle over the floor: at 0 it looks down at 53 degrees from in front, and the top of the panel is the floor five rolls back, where the track has narrowed to a third of its width; at 1 it looks straight down, the oloid tumbles at the foot of the panel and the track is a flat band of two serpents locked together.\n// Knob 4: Fade. How long the print stays on the floor: at 0.06 it loses only a third of its brightness over five rolls and so runs up to the top of the panel, dimmed a little more by distance; at 0.5 it is down to a third two rolls back; at 1 it fades within half a roll, a short tongue of print behind the oloid.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, acos, exp, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n// How near a hue is to orange and yellow, 0 to 1.\nconst warm = (h) => max(0, 1 - abs(h - floor(h) - 0.11) / 0.13);\nconst sub = (p, q) => [p[0] - q[0], p[1] - q[1], p[2] - q[2]];\nconst dot = (p, q) => p[0] * q[0] + p[1] * q[1] + p[2] * q[2];\nconst crs = (p, q) => [p[1] * q[2] - p[2] * q[1], p[2] * q[0] - p[0] * q[2], p[0] * q[1] - p[1] * q[0]];\nconst nrm = (p) => {\n  const l = hypot(p[0], p[1], p[2]) || 1;\n  return [p[0] / l, p[1] / l, p[2] / l];\n};\n\n// The two circles, radius 1. A lies in the xy-plane round the origin and B\n// in the xz-plane round (1, 0, 0), so each passes through the other's\n// centre. Both angles count from the point farthest from the other circle.\nconst cA = (a) => [-cos(a), sin(a), 0];\nconst cB = (b) => [1 + cos(b), 0, sin(b)];\n// A(a) and B(b) span a ruling of the hull when the tangent plane at A(a)\n// also touches B at B(b). With d = B - A and the two tangents, that is\n// det(tA, tB, d) = 0, which works out to cos a + cos b + cos a cos b = 0:\n// for |b| up to 2 pi / 3 it gives one |a| up to 2 pi / 3, and the four\n// signs are the four quarters of the surface. Every ruling is sqrt 3 long.\nconst partner = (u) => acos(cl(-cos(u) / (1 + cos(u)), -1, 1));\n// The closed loop of rulings, s from 0 to 8. Each eighth steps the angle\n// that moves fastest there, so the fans round the ends of the arcs, where\n// one end of the ruling barely moves, are spaced as finely as the rest.\nfunction ruling(s) {\n  const sg = s >= 4 ? -1 : 1;\n  if (s >= 4) s -= 4;\n  let a, b;\n  if (s \u003c 1) (a = (PI / 2) * s), (b = partner(a));\n  else if (s \u003c 2) (b = (PI / 2) * (2 - s)), (a = partner(b));\n  else if (s \u003c 3) (b = (-PI / 2) * (s - 2)), (a = partner(b));\n  else (a = (PI / 2) * (4 - s)), (b = -partner(a));\n  return [sg * a, sg * b];\n}\n\n// Rulings per eighth of the loop for the roll, and every RS-th of them is\n// an edge of the mesh drawn.\nconst M = 24, R = 8 * M, RS = 2, RM = R / RS;\n// The centroid, by the symmetry that swaps the circles.\nconst CEN = [0.5, 0, 0];\n// The camera: distance from the oloid, focal length in LEDs, and the row the\n// oloid sits on, low so the track has room above it.\nconst CAMD = 7.4, FOC = 118, CY0 = 98;\n// The light, a unit vector toward it: above, to the left, from the camera's side.\nconst LIGHT = nrm([-0.5, -0.55, 0.75]);\n// The print on the floor is kept on a grid of CS radii over one roll.\nconst CS = 0.04, GX0 = -0.3, GNX = 96;\n// One roll of the whole surface, in seconds at Speed 2.\nconst ROLL = 5;\n\nexport function setup(params) {\n  // The rulings, their outward normals, and the development: unroll the\n  // strip between neighbouring rulings into the plane, two triangles at a\n  // time with every edge length kept, each new point on the side of the old\n  // edge it lies on in space (the normal points down into the floor, so the\n  // turn flips).\n  const rA = [], rB = [], rn = [], a2 = [], b2 = [];\n  for (let i = 0; i \u003c= R; i++) {\n    const [a, b] = ruling((i / M) % 8), A = cA(a), B = cB(b), d = sub(B, A);\n    // The tangents can be parallel (at a = b = pi / 2), so the normal comes\n    // from the ruling and whichever tangent is further from it.\n    const c1 = crs(d, [sin(a), cos(a), 0]), c2 = crs(d, [-sin(b), 0, cos(b)]);\n    let n = nrm(dot(c1, c1) > dot(c2, c2) ? c1 : c2);\n    if (dot(n, sub([(A[0] + B[0]) / 2, A[1] / 2, B[2] / 2], CEN)) \u003c 0) n = [-n[0], -n[1], -n[2]];\n    rA.push(A), rB.push(B), rn.push(n);\n  }\n  const place = (o, d1, p, d2, sg) => {\n    const dx = p[0] - o[0], dy = p[1] - o[1], D = hypot(dx, dy), x = (d1 * d1 - d2 * d2 + D * D) / (2 * D), h = sqrt(max(0, d1 * d1 - x * x));\n    return [o[0] + (x * dx + sg * h * dy) / D, o[1] + (x * dy - sg * h * dx) / D];\n  };\n  const turn = (o, p, q, n) => (dot(crs(sub(p, o), sub(q, o)), n) \u003c 0 ? -1 : 1);\n  const len = (p, q) => hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);\n  a2.push([0, 0]), b2.push([sqrt(3), 0]);\n  for (let i = 0; i \u003c R; i++) {\n    const n = rn[i].map((v, k) => v + rn[i + 1][k]);\n    const b = place(a2[i], len(rB[i + 1], rA[i]), b2[i], len(rB[i + 1], rB[i]), turn(rA[i], rB[i], rB[i + 1], n));\n    b2.push(b);\n    a2.push(place(a2[i], len(rA[i + 1], rA[i]), b, len(rA[i + 1], rB[i + 1]), turn(rA[i], rB[i + 1], rA[i + 1], n)));\n  }\n  // One roll moves the print on by T: 4.836 radii straight down -y, with no\n  // turn (checked: under 1e-7 degrees), so the oloid rolls in a straight line.\n  const T = [a2[R][0] - a2[0][0], a2[R][1] - a2[0][1]];\n  // The pose with ruling i on the floor: the ruling laid on its developed\n  // place, the tangent plane along it on the floor, as a rotation (a\n  // quaternion) and where the centroid lands.\n  const q = new Float64Array((R + 1) * 4), cw = new Float64Array((R + 1) * 3), cum = new Float64Array(R + 1);\n  for (let i = 0; i \u003c= R; i++) {\n    const e1 = nrm(sub(rB[i], rA[i])), e3 = rn[i], e2 = crs(e3, e1);\n    const f = nrm([b2[i][0] - a2[i][0], b2[i][1] - a2[i][1], 0]), g1 = f, g2 = [f[1], -f[0], 0], g3 = [0, 0, -1];\n    const m = [0, 1, 2].map((r) => [0, 1, 2].map((c) => g1[r] * e1[c] + g2[r] * e2[c] + g3[r] * e3[c]));\n    const o = i * 4, tr = m[0][0] + m[1][1] + m[2][2];\n    if (tr > 0) {\n      const s = 2 * sqrt(tr + 1);\n      (q[o] = s / 4), (q[o + 1] = (m[2][1] - m[1][2]) / s), (q[o + 2] = (m[0][2] - m[2][0]) / s), (q[o + 3] = (m[1][0] - m[0][1]) / s);\n    } else {\n      const k = m[0][0] > m[1][1] && m[0][0] > m[2][2] ? 0 : m[1][1] > m[2][2] ? 1 : 2, k1 = (k + 1) % 3, k2 = (k + 2) % 3;\n      const s = 2 * sqrt(1 + m[k][k] - m[k1][k1] - m[k2][k2]);\n      q[o] = (m[k2][k1] - m[k1][k2]) / s;\n      q[o + 1 + k] = s / 4;\n      q[o + 1 + k1] = (m[k1][k] + m[k][k1]) / s;\n      q[o + 1 + k2] = (m[k2][k] + m[k][k2]) / s;\n    }\n    if (i > 0 && q[o] * q[o - 4] + q[o + 1] * q[o - 3] + q[o + 2] * q[o - 2] + q[o + 3] * q[o - 1] \u003c 0) for (let j = 0; j \u003c 4; j++) q[o + j] = -q[o + j];\n    const c = sub(CEN, rA[i]);\n    for (let r = 0; r \u003c 3; r++) cw[i * 3 + r] = m[r][0] * c[0] + m[r][1] * c[1] + m[r][2] * c[2] + (r \u003c 2 ? a2[i][r] : 0);\n    // The roll is timed by the centroid's path: it moves at an even speed.\n    if (i > 0) cum[i] = cum[i - 1] + hypot(cw[i * 3] - cw[i * 3 - 3], cw[i * 3 + 1] - cw[i * 3 - 2], cw[i * 3 + 2] - cw[i * 3 - 1]);\n  }\n  let xmid = 0;\n  for (let i = 0; i \u003c R; i++) xmid += cw[i * 3] / R;\n  // The mesh: each drawn ruling as A, its midpoint and B, so each strip is\n  // a quad on the A half and a quad on the B half; the normal is the same\n  // all along a ruling, as on any developable surface.\n  const mesh = new Float64Array((RM + 1) * 9), mn = new Float64Array(RM * 3);\n  for (let j = 0; j \u003c= RM; j++) {\n    const A = rA[j * RS], B = rB[j * RS];\n    for (let k = 0; k \u003c 3; k++) (mesh[j * 9 + k] = A[k]), (mesh[j * 9 + 3 + k] = (A[k] + B[k]) / 2), (mesh[j * 9 + 6 + k] = B[k]);\n    if (j \u003c RM) {\n      const n = nrm(rn[j * RS].map((v, k) => v + rn[j * RS + RS][k]));\n      for (let k = 0; k \u003c 3; k++) mn[j * 3 + k] = n[k];\n    }\n  }\n  // The rims: the two arcs of 240 degrees that are edges of the hull.\n  const ARC = 48, arcs = new Float64Array(2 * (ARC + 1) * 3);\n  for (let c = 0; c \u003c 2; c++)\n    for (let j = 0; j \u003c= ARC; j++) {\n      const p = (c ? cB : cA)(((j / ARC) * 2 - 1) * ((2 * PI) / 3));\n      for (let k = 0; k \u003c 3; k++) arcs[(c * (ARC + 1) + j) * 3 + k] = p[k];\n    }\n  // The print of one roll on the floor grid: strip i's A half codes 2i,\n  // its B half 2i + 1. A strip that pokes past either end of the roll is\n  // filed at the other end, marked as from the roll before or after.\n  const P = -T[1], GNY = ceil(P / CS), grid = new Int16Array(GNX * GNY).fill(-1), wrap = new Int8Array(GNX * GNY);\n  const fill = (pts, code) => {\n    const xs = pts.map((p) => p[0]), ys = pts.map((p) => -p[1]);\n    const x0 = floor((min(...xs) - GX0) / CS), x1 = ceil((max(...xs) - GX0) / CS), y0 = floor(min(...ys) / CS), y1 = ceil(max(...ys) / CS);\n    for (let gy = y0; gy \u003c= y1; gy++)\n      for (let gx = max(0, x0); gx \u003c= min(GNX - 1, x1); gx++) {\n        const px = GX0 + (gx + 0.5) * CS, py = -(gy + 0.5) * CS;\n        let inside = true, sgn = 0;\n        for (let k = 0; k \u003c pts.length && inside; k++) {\n          const p = pts[k], o = pts[(k + 1) % pts.length], c = (o[0] - p[0]) * (py - p[1]) - (o[1] - p[1]) * (px - p[0]);\n          if (abs(c) \u003c 1e-12) continue;\n          if (sgn === 0) sgn = c > 0 ? 1 : -1;\n          else if ((c > 0 ? 1 : -1) !== sgn) inside = false;\n        }\n        if (!inside) continue;\n        const w = gy \u003c 0 ? 1 : gy >= GNY ? -1 : 0, row = gy + w * GNY;\n        grid[row * GNX + gx] = code;\n        wrap[row * GNX + gx] = w;\n      }\n  };\n  for (let i = 0; i \u003c R; i++) {\n    const m0 = [(a2[i][0] + b2[i][0]) / 2, (a2[i][1] + b2[i][1]) / 2], m1 = [(a2[i + 1][0] + b2[i + 1][0]) / 2, (a2[i + 1][1] + b2[i + 1][1]) / 2];\n    fill([a2[i], m0, m1, a2[i + 1]], 2 * i);\n    fill([m0, b2[i], b2[i + 1], m1], 2 * i + 1);\n  }\n  params.s = {\n    hue: 0, speed: 2, tilt: 0, fade: 0.06, dist: 0, U: 0,\n    q, cw, cum, T, P, GNY, grid, wrap, xmid, mesh, mn, arcs, ARC,\n    rot: new Float64Array(9), pos: new Float64Array(3), cam: new Float64Array(12),\n    vw: new Float64Array((RM + 1) * 9), vs: new Float64Array((RM + 1) * 9), aw: new Float64Array(arcs.length),\n    zb: new Float32Array(N), rgb: new Float32Array(N * 3),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tilt = cl(k[2], 0, 1);\n  S.fade = cl(k[3], 0, 1);\n  const Lc = S.cum[R];\n  S.dist += ((d * S.speed) / 2) * (Lc / ROLL);\n  // Where the roll is: ruling i and the fraction f on to the next, found by\n  // the centroid's path length within this roll.\n  const kc = floor(S.dist / Lc), u = S.dist - kc * Lc, cum = S.cum;\n  let lo = 0, hi = R;\n  while (hi - lo > 1) {\n    const m = (lo + hi) >> 1;\n    if (cum[m] \u003c= u) lo = m;\n    else hi = m;\n  }\n  const f = cl((u - cum[lo]) / (cum[lo + 1] - cum[lo] || 1), 0, 1);\n  S.U = kc * R + lo + f;\n  // The pose between rulings lo and lo + 1: the rotations blended and\n  // renormalised, the centroid moved along, and kc rolls added on.\n  const q = S.q, o = lo * 4;\n  let w = mix(q[o], q[o + 4], f), x = mix(q[o + 1], q[o + 5], f), y = mix(q[o + 2], q[o + 6], f), z = mix(q[o + 3], q[o + 7], f);\n  const l = hypot(w, x, y, z);\n  (w /= l), (x /= l), (y /= l), (z /= l);\n  const m = S.rot;\n  m[0] = 1 - 2 * (y * y + z * z), m[1] = 2 * (x * y - w * z), m[2] = 2 * (x * z + w * y);\n  m[3] = 2 * (x * y + w * z), m[4] = 1 - 2 * (x * x + z * z), m[5] = 2 * (y * z - w * x);\n  m[6] = 2 * (x * z - w * y), m[7] = 2 * (y * z + w * x), m[8] = 1 - 2 * (x * x + y * y);\n  const cw = S.cw;\n  for (let r = 0; r \u003c 3; r++) {\n    const c = mix(cw[lo * 3 + r], cw[lo * 3 + 3 + r], f) + (r \u003c 2 ? kc * S.T[r] : 0);\n    S.pos[r] = c - (m[r * 3] * CEN[0] + m[r * 3 + 1] * CEN[1] + m[r * 3 + 2] * CEN[2]);\n  }\n  // The camera follows the centroid down the track and keeps to the middle\n  // of its sway, so the sway shows; it sits in front, looking back up the\n  // track, from 53 degrees over the floor at Tilt 0 to straight down at 1.\n  const pitch = mix(0.92, PI / 2 - 1e-4, S.tilt), cy = mix(cw[lo * 3 + 1], cw[lo * 3 + 4], f) + kc * S.T[1];\n  const C = S.cam;\n  C[0] = S.xmid;\n  C[1] = cy - CAMD * cos(pitch);\n  C[2] = 0.6 + CAMD * sin(pitch);\n  // Forward, right and up.\n  (C[3] = 0), (C[4] = cos(pitch)), (C[5] = -sin(pitch));\n  (C[6] = 1), (C[7] = 0), (C[8] = 0);\n  (C[9] = 0), (C[10] = sin(pitch)), (C[11] = cos(pitch));\n}\n\n// Fill a screen triangle into the depth buffer, nearest wins: iz is 1 over\n// the depth, interpolated across the screen as it is linear there.\nfunction tri(S, ax, ay, az, bx, by, bz, cx, cy, cz, r, g, b) {\n  const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);\n  if (abs(area) \u003c 1e-6) return;\n  const x0 = max(0, floor(min(ax, bx, cx))), x1 = min(W - 1, ceil(max(ax, bx, cx)));\n  const y0 = max(0, floor(min(ay, by, cy))), y1 = min(H - 1, ceil(max(ay, by, cy)));\n  const zb = S.zb, rgb = S.rgb;\n  for (let y = y0; y \u003c= y1; y++) {\n    const py = y + 0.5;\n    for (let x = x0; x \u003c= x1; x++) {\n      const px = x + 0.5;\n      const w0 = ((bx - px) * (cy - py) - (by - py) * (cx - px)) / area, w1 = ((cx - px) * (ay - py) - (cy - py) * (ax - px)) / area, w2 = 1 - w0 - w1;\n      if (w0 \u003c 0 || w1 \u003c 0 || w2 \u003c 0) continue;\n      const iz = w0 * az + w1 * bz + w2 * cz, i = y * W + x;\n      if (iz \u003c= zb[i]) continue;\n      zb[i] = iz;\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rot: m, pos, cam: C, zb, rgb, grid, wrap, GNY, P } = S;\n  // The two halves' colours. Orange and yellow dimmed read brown and olive,\n  // so a half that comes round to them is printed brighter and shaded less deep.\n  const hA = 0.56 + S.hue, hB = 0.94 + S.hue, wA = warm(hA), wB = warm(hB);\n  const colA = hsv(hA, 0.78, 1), colB = hsv(hB, 0.72, 1);\n  const pvA = 0.62 + 0.3 * wA, pvB = 0.62 + 0.3 * wB, loA = 0.3 + 0.25 * wA, loB = 0.3 + 0.25 * wB;\n  // World to screen: [x, y, 1 / depth].\n  const proj = (wx, wy, wz, out, o) => {\n    const vx = wx - C[0], vy = wy - C[1], vz = wz - C[2], zc = vx * C[3] + vy * C[4] + vz * C[5];\n    out[o] = 32 + (FOC * (vx * C[6] + vy * C[7] + vz * C[8])) / zc;\n    out[o + 1] = CY0 - (FOC * (vx * C[9] + vy * C[10] + vz * C[11])) / zc;\n    out[o + 2] = 1 / zc;\n  };\n  const toWorld = (src, so, out, o) => {\n    const x = src[so], y = src[so + 1], z = src[so + 2];\n    out[o] = m[0] * x + m[1] * y + m[2] * z + pos[0];\n    out[o + 1] = m[3] * x + m[4] * y + m[5] * z + pos[1];\n    out[o + 2] = m[6] * x + m[7] * y + m[8] * z + pos[2];\n  };\n  // The floor, ray by ray: where each LED's ray meets it, and what of the\n  // print lies there. A strip of roll kc was printed when the roll passed\n  // it, so its age is how many rulings ago that was.\n  const fade = R * 0.25 * 60 ** (1 - S.fade);\n  for (let py = 0; py \u003c H; py++) {\n    const vy = (CY0 - py - 0.5) / FOC;\n    for (let px = 0; px \u003c W; px++) {\n      const i = py * W + px, vx = (px + 0.5 - 32) / FOC;\n      zb[i] = 0;\n      const dx = C[3] + vx * C[6] + vy * C[9], dy = C[4] + vx * C[7] + vy * C[10], dz = C[5] + vx * C[8] + vy * C[11];\n      let r = 0.025, g = 0.012, b = 0.06;\n      if (dz \u003c 0) {\n        const t = -C[2] / dz, fx = C[0] + t * dx, fy = C[1] + t * dy;\n        const yy = -fy, kc = floor(yy / P), gy = floor((yy - kc * P) / CS), gx = floor((fx - GX0) / CS);\n        if (gx >= 0 && gx \u003c GNX && gy >= 0 && gy \u003c GNY) {\n          const c = grid[gy * GNX + gx];\n          if (c >= 0) {\n            const age = S.U - ((kc + wrap[gy * GNX + gx]) * R + (c >> 1) + 0.5);\n            if (age > 0) {\n              const v = (c & 1 ? pvB : pvA) * exp(-age / fade) * cl(1.25 - t / 40, 0.25, 1), col = c & 1 ? colB : colA;\n              (r += col[0] * v), (g += col[1] * v), (b += col[2] * v);\n            }\n          }\n        }\n      }\n      (rgb[i * 3] = r), (rgb[i * 3 + 1] = g), (rgb[i * 3 + 2] = b);\n    }\n  }\n  // The body: every mesh point to the world and the screen, then each quad\n  // facing the camera as two triangles, shaded by its ruling's normal.\n  const { mesh, mn, vw, vs } = S;\n  for (let j = 0; j \u003c (RM + 1) * 3; j++) {\n    toWorld(mesh, j * 3, vw, j * 3);\n    proj(vw[j * 3], vw[j * 3 + 1], vw[j * 3 + 2], vs, j * 3);\n  }\n  for (let j = 0; j \u003c RM; j++) {\n    const nx = m[0] * mn[j * 3] + m[1] * mn[j * 3 + 1] + m[2] * mn[j * 3 + 2];\n    const ny = m[3] * mn[j * 3] + m[4] * mn[j * 3 + 1] + m[5] * mn[j * 3 + 2];\n    const nz = m[6] * mn[j * 3] + m[7] * mn[j * 3 + 1] + m[8] * mn[j * 3 + 2];\n    const o = j * 9 + 3;\n    if (nx * (vw[o] - C[0]) + ny * (vw[o + 1] - C[1]) + nz * (vw[o + 2] - C[2]) > 0.02) continue;\n    const lit = max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]);\n    for (let h = 0; h \u003c 2; h++) {\n      const col = h ? colB : colA, lo = h ? loB : loA, sh = lo + (1 - lo) * lit, p = j * 9 + h * 3, q = p + 9;\n      tri(S, vs[p], vs[p + 1], vs[p + 2], vs[p + 3], vs[p + 4], vs[p + 5], vs[q + 3], vs[q + 4], vs[q + 5], col[0] * sh, col[1] * sh, col[2] * sh);\n      tri(S, vs[p], vs[p + 1], vs[p + 2], vs[q + 3], vs[q + 4], vs[q + 5], vs[q], vs[q + 1], vs[q + 2], col[0] * sh, col[1] * sh, col[2] * sh);\n    }\n  }\n  // The rims, the two circles' arcs, drawn where nothing nearer hides them.\n  const { arcs, aw, ARC } = S;\n  for (let j = 0; j \u003c arcs.length / 3; j++) toWorld(arcs, j * 3, aw, j * 3);\n  const a = [0, 0, 0], bq = [0, 0, 0];\n  for (let c = 0; c \u003c 2; c++) {\n    const col = c ? colB : colA;\n    for (let j = 0; j \u003c ARC; j++) {\n      const o = (c * (ARC + 1) + j) * 3;\n      proj(aw[o], aw[o + 1], aw[o + 2], a, 0);\n      proj(aw[o + 3], aw[o + 4], aw[o + 5], bq, 0);\n      const steps = ceil(max(abs(bq[0] - a[0]), abs(bq[1] - a[1])) * 2) + 1;\n      for (let s = 0; s \u003c= steps; s++) {\n        const t = s / steps, x = floor(mix(a[0], bq[0], t)), y = floor(mix(a[1], bq[1], t));\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const i = y * W + x, iz = mix(a[2], bq[2], t);\n        if (iz \u003c zb[i] * 0.985) continue;\n        (rgb[i * 3] = 0.55 + 0.45 * col[0]), (rgb[i * 3 + 1] = 0.55 + 0.45 * col[1]), (rgb[i * 3 + 2] = 0.55 + 0.45 * col[2]);\n      }\n    }\n  }\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","pumpkin-carving":"// ===== Patternflow pattern =====\n// Title:   Pumpkin Carving\n// Family:  halloween\n// Idea:    A big orange pumpkin on a dark table at night: a glinting knife saws out two eyes, a nose and a jagged grin piece by piece, each pushed in to drop into the dark inside; a match flares, the candle catches and the face burns gold and flickers, its light spilling over the table, then it gutters out and the pumpkin turns to bring round fresh skin for a different face.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Warmth=-1..1, Speed=0.2..3, Fierce=0..1, Spill=0..1\n//\n// Knob 1: Warmth. The pumpkin and its candlelight together: at 0 a bright orange pumpkin burning gold; at -1 a red one burning orange; at 1 a golden yellow one, which the candle turns orange round a pale yellow face. The night and the stem stay as they are.\n// Knob 2: Speed. At 2 a calm face takes about 13 seconds: 6 to carve, 0.9 for the match, 3.5 burning, 0.9 to gutter out and 1.8 to turn; a fierce face's long grin adds 2 more to the carving. At 0.2 the story runs ten times slower, at 3 half as fast again; the flame flickers at its own pace.\n// Knob 3: Fierce. The faces the knife chooses, each one new: at 0 upright triangle eyes and a smile with two or three square teeth; at 1 bigger eyes slanted down to the nose and a wider, deeper grin with seven or eight pointed teeth above and fangs standing up between them, which appear past 0.3.\n// Knob 4: Spill. How far the candlelight carries: at 0.06 a pool of gold, orange and crimson rings 38 LEDs either side and 16 rows down the table, and a crimson rim three LEDs round the pumpkin; at 1 the pool covers the table and the glow reaches 18 to 20 LEDs into the night.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, hypot, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (t) => t * t * (3 - 2 * t);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The pumpkin, a spheroid with ten ribs: centre, half-width, half-height;\n// the table's back edge; the candle flame's x, seen only through the holes.\nconst CX = 32, CY = 68, PA = 29.5, PB = 26, RIBS = 10, TABLE = 88, FX = 32;\n// The moon's light on the skin, a unit vector toward it: upper left, in front.\nconst LX = -0.5, LY = -0.62, LZ = 0.6;\n// Where the pumpkin stands on the table.\nconst BASE = CY + PB;\n// The story in seconds at Speed 2: the knife moves to a piece, saws round it\n// at KNIFE LEDs a second and pushes it in; match, burn, gutter, half turn.\nconst TRAVEL = 0.22, KNIFE = 60, PUSH = 0.45, MATCH = 0.9, BURN = 3.5, OUT = 0.9, TURN = 1.8, REST = 0.3;\n// Across a rib, groove to groove in 256 steps: its bulge and the lean of its normal.\nconst RIB_B = new Float32Array(256), RIB_L = new Float32Array(256);\nfor (let i = 0; i \u003c 256; i++) (RIB_B[i] = sin((PI * (i + 0.5)) / 256)), (RIB_L[i] = -0.55 * cos((PI * (i + 0.5)) / 256));\n// The knife: blade and handle in LEDs, pointing up and right as a right hand holds it.\nconst BLADE = 15, HANDLE = 10, KDX = 0.55, KDY = -0.835;\nconst BOLSTER = [1, 0.95, 0.7, 1, 0.95, 0.7, 1, 0.95, 0.7], HANDLE_C = [0.5, 0.3, 0.62, 0.32, 0.12, 0.42, 0.18, 0.06, 0.26];\n\n// A new face in head-on panel LEDs: left eye, right eye, nose, mouth, each a\n// polygon the knife saws round in turn. Fierce scowls the eyes and deepens and\n// multiplies the teeth; the rest is chance, so no two faces are the same.\nfunction makeFace(fierce) {\n  const R = Math.random, f = fierce, pieces = [];\n  const ex = 10 + 2.5 * R(), ey = CY - 9 - 2 * R(), bw = 9 + 3 * R() + 3 * f, eh = 7 + 3 * R() + 2 * f, ap = (R() - 0.5) * 3;\n  for (const sd of [-1, 1]) {\n    // q runs from the outer corner to the nose. Calm, the triangle stands on\n    // its base; fierce, its top runs down to the inner corner.\n    const calm = [[-bw / 2, eh / 2], [bw / 2, eh / 2], [ap, -eh / 2]];\n    const mad = [[-bw / 2, eh / 2 + 0.5], [bw / 2 + 2, eh / 2 - 1.5], [-bw / 2 + 1, -eh / 2 - 1.5]];\n    pieces.push(calm.map(([q, y], i) => [CX + sd * ex - sd * mix(q, mad[i][0], f), ey + mix(y, mad[i][1], f)]));\n  }\n  const nw = 5 + 2 * R(), nh = 4.5 + 2 * R(), up = R() > 0.25 + 0.4 * f ? 1 : -1;\n  pieces.push([[CX - nw / 2, CY + 1 + (up * nh) / 2], [CX + nw / 2, CY + 1 + (up * nh) / 2], [CX, CY + 1 - (up * nh) / 2]]);\n  // The mouth: a smile between two curves, its top edge sawn into teeth,\n  // square at Fierce 0 and pointed at 1, and past 0.3 its bottom into fangs.\n  const mw = 15 + 4 * R() + 4 * f, y0 = CY + 8 + R(), ct = 3 + 2.5 * R(), th0 = 3.5, cb = ct + 5 + 2 * R() + 4 * f;\n  const nt = round(2 + 5 * f + R() * 1.4), nb = f > 0.3 ? max(1, nt - 1) : 0, sharp = 0.12 + 0.38 * f;\n  const top = (u) => y0 + ct * (1 - u * u), bot = (u) => y0 + th0 + cb * (1 - u * u);\n  const edge = (n, yf, dep, dir) => {\n    const pts = [], S = 2 * n + 1, nq = max(2, Math.ceil(10 / S));\n    for (let j = 0; j \u003c S; j++) {\n      const u0 = -1 + (2 * j) / S, u1 = -1 + (2 * (j + 1)) / S;\n      if (j % 2 === 0) for (let q = 0; q \u003c nq; q++) {\n        const u = u0 + ((u1 - u0) * q) / nq;\n        pts.push([CX + mw * u, yf(u)]);\n      }\n      else {\n        const ua = mix(u0, u1, sharp), ub = mix(u1, u0, sharp);\n        pts.push([CX + mw * u0, yf(u0)], [CX + mw * ua, yf(ua) + dir * dep(ua)]);\n        if (ub > ua + 1e-6) pts.push([CX + mw * ub, yf(ub) + dir * dep(ub)]);\n      }\n    }\n    pts.push([CX + mw, yf(1)]);\n    return pts;\n  };\n  const gap = (u) => bot(u) - top(u), deepT = 0.45 + 0.1 * f, deepB = 0.3 * f;\n  const mouth = edge(nt, top, (u) => deepT * gap(u), 1).concat(edge(nb, bot, (u) => deepB * gap(u), -1).reverse());\n  pieces.push(mouth);\n  return pieces.map((pts) => {\n    let len = 0;\n    const cum = [0];\n    for (let i = 0; i \u003c pts.length; i++) {\n      const a = pts[i], b = pts[(i + 1) % pts.length];\n      len += hypot(b[0] - a[0], b[1] - a[1]);\n      cum.push(len);\n    }\n    let cx = 0, cy = 0;\n    for (const p of pts) (cx += p[0] / pts.length), (cy += p[1] / pts.length);\n    return { pts, cum, len, cx, cy, state: 0, t: 0.5 };\n  });\n}\n\n// Which piece covers each LED of the head-on face, 1 to 4, 0 for skin.\n// The candle stands so its flame rises from just inside the top of the mouth.\nfunction maskFace(S) {\n  const m = S.mask;\n  m.fill(0);\n  S.face.forEach((pc, k) => {\n    const xs = pc.pts.map((p) => p[0]), ys = pc.pts.map((p) => p[1]);\n    for (let y = max(0, floor(min(...ys))); y \u003c= min(H - 1, floor(max(...ys))); y++)\n      for (let x = max(0, floor(min(...xs))); x \u003c= min(W - 1, floor(max(...xs))); x++) {\n        const px = x + 0.5, py = y + 0.5;\n        let inside = false;\n        for (let i = 0, j = pc.pts.length - 1; i \u003c pc.pts.length; j = i++) {\n          const [xi, yi] = pc.pts[i], [xj, yj] = pc.pts[j];\n          if (yi > py !== yj > py && px \u003c ((xj - xi) * (py - yi)) / (yj - yi) + xi) inside = !inside;\n        }\n        if (inside) m[y * W + x] = k + 1;\n      }\n  });\n  let top = H;\n  for (let i = 0; i \u003c N; i++) if (m[i] === 4) top = min(top, floor(i / W));\n  S.fy = top + 3;\n}\n\nexport function setup(params) {\n  // A few stars in the sky, each with its own twinkle.\n  const stars = [];\n  for (let i = 0; i \u003c 16; i++) stars.push([floor(Math.random() * W), floor(Math.random() * 40), Math.random() * TAU]);\n  // The pumpkin's fixed geometry per LED: longitude at no turn (-10 off the\n  // pumpkin), its cosine and sine, and the spheroid's normal.\n  const geo = new Float32Array(N).fill(-10), cth = new Float32Array(N), sth = new Float32Array(N);\n  const gnx = new Float32Array(N), gny = new Float32Array(N), gnz = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++) {\n    const v = (y + 0.5 - CY) / PB, c = sqrt(max(0, 1 - v * v)), rw = PA * c;\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x + 0.5 - CX, i = y * W + x;\n      if (abs(dx) >= rw) continue;\n      const u = dx / rw, th = asin(u);\n      (geo[i] = th), (cth[i] = cos(th)), (sth[i] = u);\n      (gnx[i] = u * c), (gny[i] = v * 0.9), (gnz[i] = sqrt(max(0, 1 - u * u)) * c);\n    }\n  }\n  params.s = {\n    geo, cth, sth, gnx, gny, gnz,\n    // Numbers that change every frame start as fractions, so the engine\n    // keeps them as floats from the start and does not recompile.\n    warmth: 0.5, speed: 1.5, fierce: 0.5, spill: 0.06, rt: 0.5, made: false,\n    face: null, mask: new Uint8Array(N), stars, fy: 80.5,\n    // The story: phase, time in it, the piece being cut and how far round.\n    phase: \"cut\", pt: 0.5, piece: 3, sub: \"trace\", cut: 0.5, from: [CX + 0.5, CY + 0.5],\n    turned: 0.5, phi: 0.5, light: 0.5, flare: 0.5, mx: 0.5, my: 0.5, glow: 0.5, sway: 0.5,\n    rgb: new Float32Array(N * 3), pal: new Float64Array(36), lit: new Float32Array(N), skin: new Uint8Array(N),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.warmth = cl(k[0], -1, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.fierce = cl(k[2], 0, 1);\n  S.spill = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.rt += d;\n  if (!S.made) {\n    // The first face opens with the knife part way round the mouth.\n    S.made = true;\n    S.face = makeFace(S.fierce);\n    maskFace(S);\n    for (let i = 0; i \u003c 3; i++) S.face[i].state = 3;\n    S.face[3].state = 1;\n    S.cut = S.face[3].len * 0.45;\n  }\n  // The flame: a breath, a shiver, now and then a short gust; it leans with them.\n  const t = S.rt, gust = max(0, sin(t * 1.9 + 2 * sin(t * 0.7))) ** 6;\n  S.glow = cl(1 - 0.14 * (0.5 + 0.5 * sin(t * 11.3) * sin(t * 4.1 + 1)) - 0.05 * sin(t * 23.7) - 0.2 * gust, 0.25, 1.05);\n  S.sway = 0.5 * (0.6 * sin(t * 2.3) + 0.4 * sin(t * 5.1 + 0.4)) + 0.8 * gust * sin(t * 0.9);\n  S.pt += g;\n  const pc = S.face[S.piece];\n  if (S.phase === \"cut\") {\n    if (S.sub === \"travel\") {\n      if (S.pt >= TRAVEL) (S.sub = \"trace\"), (S.pt = 0), (pc.state = 1), (S.cut = 0);\n    } else if (S.sub === \"trace\") {\n      S.cut += g * KNIFE;\n      if (S.cut >= pc.len) (S.sub = \"push\"), (S.pt = 0), (pc.state = 2), (pc.t = 0);\n    } else {\n      pc.t = cl(S.pt / PUSH, 0, 1);\n      if (S.pt >= PUSH) {\n        pc.state = 3;\n        S.from = pc.pts[0];\n        S.pt = 0;\n        if (S.piece \u003c 3) (S.piece++), (S.sub = \"travel\");\n        else S.phase = \"match\";\n      }\n    }\n  } else if (S.phase === \"match\" && S.pt >= MATCH) (S.phase = \"burn\"), (S.pt = 0);\n  else if (S.phase === \"burn\" && S.pt >= BURN) (S.phase = \"out\"), (S.pt = 0);\n  else if (S.phase === \"out\" && S.pt >= OUT) (S.phase = \"turn\"), (S.pt = 0);\n  else if (S.phase === \"turn\" && S.pt >= TURN) {\n    // Fresh skin faces us now; the ribs repeat every half turn.\n    (S.phase = \"rest\"), (S.pt = 0), (S.phi = 0), (S.turned += PI);\n    S.face = makeFace(S.fierce);\n    maskFace(S);\n  } else if (S.phase === \"rest\" && S.pt >= REST) (S.phase = \"cut\"), (S.pt = 0), (S.piece = 0), (S.sub = \"travel\"), (S.from = [CX + 22.5, CY - 30.5]);\n  S.phi = S.phase === \"turn\" ? PI * ease(cl(S.pt / TURN, 0, 1)) : 0;\n  // How lit the inside is: the match flares and sinks to a small flame, the\n  // candle catches with a flash and burns, then gutters out.\n  S.flare = 0;\n  if (S.phase === \"match\") {\n    const u = S.pt / MATCH;\n    S.flare = u \u003c 0.15 ? u / 0.15 : u \u003c 0.5 ? 1 - ((u - 0.15) / 0.35) * 0.7 : 0.3;\n    S.light = u \u003c 0.45 ? 0 : u \u003c 0.55 ? 0.3 : 0.3 + 0.7 * ease((u - 0.55) / 0.45) + 0.4 * max(0, 1 - abs(u - 0.75) / 0.1);\n    // Struck in the dark right of the stem, put in through the mouth.\n    const v = ease(cl((u - 0.2) / 0.3, 0, 1));\n    S.mx = mix(50, FX + 2, v);\n    S.my = mix(34, S.fy - 1, v * v);\n  } else if (S.phase === \"burn\") S.light = 1;\n  else if (S.phase === \"out\") {\n    const u = S.pt / OUT;\n    S.light = (1 - u) * (1 - u) * (0.7 + 0.3 * sin(S.pt * 40));\n  } else S.light = 0;\n}\n\n// The frame's colours in S.pal, three floats each: skin lit, shaded, in the\n// grooves and sunk while the candle burns, all saturated (a dim orange reads\n// brown); cut flesh; deep orange, gold, white-hot and crimson light; and, by\n// how bright the flame burns, the light itself and its pool's inner rings.\nconst HI = 0, LO = 3, GROOVE = 6, SUNK = 9, FLESH = 12, DEEP = 15, GOLD = 18, HOT = 21, CRIM = 24, GLOW = 27, POOL0 = 30, POOL1 = 33;\nconst RED = [0.88, 0.08, 0.02];\nfunction hsvTo(P, o, h, s, v) {\n  const c = hsv(h, s, v);\n  (P[o] = c[0]), (P[o + 1] = c[1]), (P[o + 2] = c[2]);\n}\nfunction palette(S, dim) {\n  // Warmth runs the pumpkin from red through orange to golden yellow. Lit\n  // from inside, a yellow skin would pale to the face's own colour, so it\n  // sinks toward orange instead.\n  const P = S.pal, hp = 0.075 + 0.075 * S.warmth, wy = cl((hp - 0.09) / 0.06, 0, 1);\n  hsvTo(P, HI, hp + 0.015, 0.88, 1);\n  hsvTo(P, LO, hp - 0.02, 1, 0.88);\n  hsvTo(P, GROOVE, hp - 0.04, 1, 0.74);\n  hsvTo(P, SUNK, hp - 0.035 - 0.06 * wy, 1, 0.84);\n  hsvTo(P, FLESH, min(hp + 0.06, 0.15), 0.5, 0.95);\n  hsvTo(P, DEEP, hp - 0.01, 1, 1);\n  hsvTo(P, GOLD, min(hp + 0.06, 0.15), 0.88 - 0.25 * wy, 1);\n  hsvTo(P, HOT, min(hp + 0.1, 0.16), 0.28 - 0.1 * wy, 1);\n  hsvTo(P, CRIM, hp - 0.07, 0.88, 0.95);\n  // Gold at full, deep orange at half, ember red as it gutters, so a dim\n  // flame turns red, not brown.\n  for (let c = 0; c \u003c 3; c++) {\n    P[GLOW + c] = dim \u003c 0.5 ? mix(RED[c], P[DEEP + c], dim * 2) : mix(P[DEEP + c], P[GOLD + c], dim * 2 - 1);\n    P[POOL0 + c] = mix(P[CRIM + c], P[GOLD + c], dim);\n    P[POOL1 + c] = mix(P[CRIM + c], P[DEEP + c], dim);\n  }\n}\n\n// The night: violet sky in bands, the table with the pumpkin's shadow, and\n// while the candle burns its glow in the air and its pool on the table.\nfunction night(S, L) {\n  const P = S.pal, rgb = S.rgb, sp = S.spill, lamp = min(1, L);\n  const poolX = 36 + 30 * sp, poolY = 15 + 22 * sp, halo = 0.06 + 0.62 * sp, breathe = 0.72 + 0.3 * L;\n  for (let y = 0; y \u003c H; y++) {\n    const band = floor((y / TABLE) * 9) / 8, v = (y + 0.5 - CY) / PB;\n    const sky = y \u003c TABLE, front = y >= TABLE + 14;\n    const b2 = band * band, r0 = sky ? 0.02 + 0.2 * b2 : front ? 0.15 : 0.12, g0 = sky ? 0.004 + 0.05 * b2 : front ? 0.065 : 0.05, b0 = sky ? 0.05 + 0.27 * b2 : front ? 0.22 : 0.19;\n    const haloRow = L > 0 && sky && v > -1 - halo && v \u003c 1 + halo, poolRow = L > 0 && y > BASE - 1, shadeRow = !sky && y > BASE - 5 && y \u003c BASE + 5;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let r = r0, g = g0, b = b0;\n      if (haloRow) {\n        // Three rings of crimson round the pumpkin.\n        const hx = (x + 0.5 - CX) / PA, e = (sqrt(hx * hx + v * v) - 1) / halo;\n        if (e > 0 && e \u003c 1) {\n          const a = (e \u003c 0.35 ? 0.55 : e \u003c 0.7 ? 0.36 : 0.2) * lamp, c = e \u003c 0.35 ? POOL1 : CRIM;\n          (r = mix(r, P[c], a)), (g = mix(g, P[c + 1], a)), (b = mix(b, P[c + 2], a));\n        }\n      }\n      if (shadeRow) {\n        const sx = (x + 0.5 - CX - 3) / 31, sy = (y + 0.5 - BASE) / 4.5;\n        if (sx * sx + sy * sy \u003c 1) (r *= 0.4), (g *= 0.4), (b *= 0.45);\n      }\n      if (poolRow) {\n        // Gold, then orange, then crimson, all sinking to crimson as the\n        // flame dips, and the pool breathes with it.\n        const px = (x + 0.5 - CX) / poolX, py = (y + 0.5 - BASE - 1) / poolY, dd = sqrt(px * px + py * py) / breathe;\n        if (dd \u003c 1) {\n          const c = dd \u003c 0.42 ? POOL0 : dd \u003c 0.7 ? POOL1 : CRIM, a = (dd \u003c 0.42 ? 0.88 : dd \u003c 0.7 ? 0.66 : 0.45) * (0.4 + 0.6 * lamp);\n          (r = mix(r, P[c], a)), (g = mix(g, P[c + 1], a)), (b = mix(b, P[c + 2], a));\n        }\n      }\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n  }\n}\n\n// The skin: its longitude, turned with the body, sets the ribs, whose sides\n// lean the normal so the moon lights one. Five steps of light, three of groove.\nfunction skinAt(S, i, rot, warm) {\n  const P = S.pal, rgb = S.rgb, o = i * 3;\n  const gq = (((S.geo[i] - rot) * RIBS) / TAU) % 1, ri = floor((gq \u003c 0 ? gq + 1 : gq) * 256) & 255, bulge = RIB_B[ri], lean = RIB_L[ri];\n  const nx = S.gnx[i] + lean * S.cth[i], ny = S.gny[i], nz = S.gnz[i] - lean * S.sth[i];\n  const lam = floor(cl((nx * LX + ny * LY + nz * LZ) / (sqrt(nx * nx + ny * ny + nz * nz) || 1), 0, 0.999) * 5) / 4;\n  const gw = bulge \u003c 0.25 ? 0 : bulge \u003c 0.6 ? 0.55 : 1;\n  for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(mix(P[GROOVE + c], mix(P[LO + c], P[HI + c], lam), gw), P[SUNK + c], warm);\n}\n\n// A hole, or a piece on its way in. k is the piece, (fx, y) the LED in\n// head-on coordinates. Returns false where the pushed piece still covers it.\nfunction holeAt(S, i, k, fx, y, v, L, dim) {\n  const P = S.pal, rgb = S.rgb, mask = S.mask, pc = S.face[k - 1], o = i * 3;\n  if (pc.state === 2) {\n    // Pushed in: at once a dark gap opens round the piece, then it shrinks\n    // and sinks inside its hole, darkening as it goes.\n    const p = pc.t, sc = 0.9 - 0.3 * p, qx = floor(pc.cx + (fx + 0.5 - pc.cx) / sc), qy = floor(pc.cy + (y + 0.5 - pc.cy - 0.5 - 4 * p * p) / sc);\n    if (qx >= 0 && qx \u003c W && qy >= 0 && qy \u003c H && mask[qy * W + qx] === k) {\n      const d = 0.35 + 0.65 * p;\n      (rgb[o] = mix(rgb[o], P[GROOVE], d)), (rgb[o + 1] = mix(rgb[o + 1], P[GROOVE + 1], d) * (1 - 0.5 * p)), (rgb[o + 2] *= 1 - d);\n      return false;\n    }\n  }\n  // The wall of the cut shows on the side away from the middle.\n  const wx = floor(fx + 0.5 + ((fx + 0.5 - CX) / PA) * 2.6), wy = floor(y + 0.5 + v * 2.2);\n  if (wx \u003c 0 || wx >= W || wy \u003c 0 || wy >= H || mask[wy * W + wx] !== k) {\n    const a = mix(0.9, 1, cl(S.light, 0, 1));\n    for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(P[FLESH + c], P[HOT + c], dim) * a;\n    return true;\n  }\n  // Inside: dark, or the far wall candlelit, gold to white-hot by the flame,\n  // brighter than the skin so the face reads as burning.\n  const flameX = FX + S.sway, ex = fx + 0.5 - flameX, ey = (y + 0.5 - S.fy) * 0.8;\n  const near = floor(cl(1 - sqrt(ex * ex + ey * ey) / 24, 0, 0.999) * 4) / 3;\n  const a = (0.55 + 0.45 * min(1, L)) * cl(S.light * 4, 0, 1), hn = near * 0.75 * dim;\n  (rgb[o] = 0.03 + mix(P[GLOW], P[HOT], hn) * a), (rgb[o + 1] = 0.01 + mix(P[GLOW + 1], P[HOT + 1], hn) * a), (rgb[o + 2] = 0.04 + mix(P[GLOW + 2], P[HOT + 2], hn) * a);\n  S.lit[i] = a;\n  // The flame itself, through whichever hole it lies behind.\n  const flameH = 6 + 1.5 * S.glow, fy = S.fy - (y + 0.5), fxo = ex - S.sway * 0.4 * (fy / flameH);\n  if (S.light > 0.12 && fy > -1 && fy \u003c flameH) {\n    const q = fy / flameH, w = q \u003c 0.3 ? 2.2 * sqrt(q / 0.3) : 2.2 * (1 - (q - 0.3) / 0.7) ** 0.8;\n    if (fxo > -w - 0.2 && fxo \u003c w + 0.2) {\n      const core = fxo > -w * 0.5 && fxo \u003c w * 0.5 && q \u003c 0.65;\n      (rgb[o] = 1), (rgb[o + 1] = core ? 0.97 : 0.75), (rgb[o + 2] = core ? 0.8 : 0.2);\n    }\n  }\n  return true;\n}\n\n// The pumpkin: skin, and the face carried round with the turn.\nfunction pumpkin(S, L, dim) {\n  const { skin, mask, face, geo } = S, rot = S.turned + S.phi, fl = S.phi;\n  // While the candle burns the skin sinks to a saturated red-orange round the face.\n  const warm = 0.5 * cl(L, 0, 1);\n  for (let y = CY - PB; y \u003c CY + PB; y++) {\n    const v = (y + 0.5 - CY) / PB, rw = PA * sqrt(max(0, 1 - v * v));\n    for (let x = max(0, floor(CX - rw)); x \u003c= min(W - 1, floor(CX + rw)); x++) {\n      const i = y * W + x, th = geo[i];\n      if (th \u003c -9) continue;\n      skinAt(S, i, rot, warm);\n      skin[i] = 1;\n      const thr = th - fl;\n      if (thr \u003c= -PI / 2 || thr >= PI / 2) continue;\n      const fx = fl === 0 ? x : floor(CX + rw * sin(thr)), k = fx >= 0 && fx \u003c W ? mask[y * W + fx] : 0;\n      if (k && face[k - 1].state >= 2 && holeAt(S, i, k, fx, y, v, L, dim)) skin[i] = 0;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.face) return;\n  const { rgb, lit, skin, face, pal: P } = S;\n  const L = S.light * S.glow, dim = cl((L - 0.3) / 0.5, 0, 1), rot = S.turned + S.phi;\n  palette(S, dim);\n  lit.fill(0);\n  skin.fill(0);\n  night(S, L);\n  pumpkin(S, L, dim);\n  // Light from the holes blooms gold onto the skin two LEDs round them.\n  if (L > 0.02)\n    for (let i = (CY - PB) * W; i \u003c (CY + PB) * W; i++) {\n      if (!skin[i]) continue;\n      const n1 = max(lit[i - 1], lit[i + 1], lit[i - W], lit[i + W]), n2 = max(lit[i - 2], lit[i + 2], lit[i - 2 * W], lit[i + 2 * W]);\n      const a = n1 > 0 ? 0.67 * min(1, n1 * 1.2) : 0.33 * min(1, n2 * 1.2);\n      if (a > 0) for (let c = 0; c \u003c 3; c++) rgb[i * 3 + c] = mix(rgb[i * 3 + c], P[GOLD + c], a);\n    }\n  // The stem: a thick green hook from the dimple on top, its lean turning\n  // with the pumpkin.\n  const lean = 5 * sin(0.9 + rot), sx0 = CX + 0.5, sy0 = CY - PB + 3;\n  for (let s = 0; s \u003c= 24; s++) {\n    const q = s / 24, px = sx0 + lean * q * q, py = sy0 - 12 * q, rr = 2.6 - 1.1 * q;\n    for (let y = floor(py - rr); y \u003c= py + rr; y++)\n      for (let x = floor(px - rr); x \u003c= px + rr; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || (x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2 > rr * rr) continue;\n        const o = (y * W + x) * 3, hi = x + 0.5 \u003c px - 0.4;\n        (rgb[o] = hi ? 0.45 : 0.22), (rgb[o + 1] = hi ? 0.95 : 0.72), (rgb[o + 2] = hi ? 0.25 : 0.12);\n      }\n  }\n  // The stars, twinkling.\n  for (const [x, y, ph] of S.stars) {\n    const o = (y * W + x) * 3, a = 0.35 + 0.3 * sin(S.rt * 1.7 + ph);\n    if (!skin[y * W + x]) (rgb[o] = max(rgb[o], a)), (rgb[o + 1] = max(rgb[o + 1], a * 0.9)), (rgb[o + 2] = max(rgb[o + 2], a));\n  }\n  const put = (x, y, r, g, b) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n  };\n  if (S.phase === \"cut\") {\n    const pc = face[S.piece];\n    // The cut so far, a pale line of fresh flesh, ends where the blade is in.\n    let tip = [pc.cx + 1, pc.cy];\n    if (S.sub === \"travel\") {\n      const u = ease(cl(S.pt / TRAVEL, 0, 1)), to = pc.pts[0];\n      tip = [mix(S.from[0], to[0], u), mix(S.from[1], to[1], u)];\n    } else if (pc.state === 1)\n      for (let j = 0; j \u003c pc.pts.length && pc.cum[j] \u003c S.cut; j++) {\n        const a = pc.pts[j], b = pc.pts[(j + 1) % pc.pts.length], l = pc.cum[j + 1] - pc.cum[j] || 1, e = min(1, (S.cut - pc.cum[j]) / l);\n        for (let q = 0; q \u003c= e * l * 2; q++) put(mix(a[0], b[0], q / (2 * l)), mix(a[1], b[1], q / (2 * l)), P[FLESH], P[FLESH + 1], P[FLESH + 2]);\n        tip = [mix(a[0], b[0], e), mix(a[1], b[1], e)];\n      }\n    // The knife saws up and down its own length.\n    const saw = S.sub === \"trace\" ? 1.6 * sin(S.rt * 31) : 0;\n    const bl = BLADE + saw, sparkle = (S.rt * 1.3) % 1;\n    for (let s = 0; s \u003c= (bl + HANDLE) * 2; s++) {\n      const a = s / 2, x = tip[0] + KDX * a, y = tip[1] + KDY * a;\n      if (a \u003c= bl) {\n        // Silver, the edge brightest; the glint runs up it.\n        const gl = max(0, 1 - abs(a - sparkle * bl) / 2.5);\n        put(x, y, 0.78 + 0.22 * gl, 0.82 + 0.18 * gl, 0.92 + 0.08 * gl);\n        put(x + 1, y, 0.5 + 0.4 * gl, 0.54 + 0.4 * gl, 0.66 + 0.3 * gl);\n      } else {\n        // A brass bolster, then a violet handle lit on its left.\n        const c = a \u003c bl + 1 ? BOLSTER : HANDLE_C;\n        for (let j = 0; j \u003c 3; j++) put(x + j - 1, y, c[j * 3], c[j * 3 + 1], c[j * 3 + 2]);\n      }\n    }\n  }\n  if (S.phase === \"match\" && S.flare > 0) {\n    // The match: a pale stick, a white burst with rays as it is struck,\n    // then its own small flame above the head.\n    const f = S.flare, x0 = S.mx, y0 = S.my;\n    for (let j = 1; j \u003c= 6; j++) put(x0 + 0.55 * j, y0 + 0.85 * j, 0.95, 0.86, 0.62);\n    const reach = 3 + 7 * f, core = 1.2 + 2.6 * f;\n    for (let y = floor(y0 - reach); y \u003c= y0 + reach; y++)\n      for (let x = floor(x0 - reach); x \u003c= x0 + reach; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const ddx = x + 0.5 - x0, ddy = y + 0.5 - y0, dd = sqrt(ddx * ddx + ddy * ddy);\n        const ray = (abs(ddx) \u003c 0.6 || abs(ddy) \u003c 0.6 ? 1 : abs(abs(ddx) - abs(ddy)) \u003c 0.7 ? 0.65 : 0) * max(0, 1 - dd / reach);\n        const a = min(1, max(ray * f * 1.3, dd \u003c core ? 1 : 0));\n        if (a \u003c= 0.05) continue;\n        const o = (y * W + x) * 3;\n        (rgb[o] = mix(rgb[o], 1, a)), (rgb[o + 1] = mix(rgb[o + 1], dd \u003c core * 0.6 ? 1 : 0.9, a)), (rgb[o + 2] = mix(rgb[o + 2], dd \u003c core * 0.6 ? 0.9 : 0.45, a));\n      }\n    for (let j = 1; j \u003c= 4; j++) {\n      const w = j \u003c 3 ? 1 : 0;\n      for (let dx = -w; dx \u003c= w; dx++) put(x0 + dx, y0 - j, 1, j \u003c 2 ? 1 : 0.8, j \u003c 2 ? 0.8 : 0.25);\n    }\n  }\n  for (let i = 0; i \u003c N; i++)\n    display.setPixel(i % W, floor(i / W), (255 * cl(rgb[i * 3], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 1], 0, 1)) | 0, (255 * cl(rgb[i * 3 + 2], 0, 1)) | 0);\n}\n","pumpkin-vine":"// ===== Patternflow pattern =====\n// Title:   Pumpkin Vine\n// Family:  halloween\n// Idea:    Under a violet night sky and a pale moon a pumpkin vine climbs from the hill at the bottom of the panel to near the top, its stem winding up as broad five-lobed leaves unfold at every joint and tendrils coil out beside them, small orange pumpkins swell at the joints and light one by one from the bottom as jack-o'-lanterns with glowing carved faces, each one lifting the night a little, and when the whole vine has stood lit for a few seconds its leaves wither to a dead violet, sink into the dark, and a new vine starts from the ground.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Spell=0..1, Speed=0.2..3, Vines=1..3, Curl=0..1\n//\n// Knob 1: Spell. At 0 an ordinary pumpkin patch under a violet night: leaf-green leaves, candle-yellow faces and an orange glow. Turning it bewitches the vine: by 0.5 the leaves are teal, the faces lime and the night dark slate; at 1 the leaves are violet with toxic green veins, the lanterns burn green and the night is a sickly green. The pumpkins stay orange.\n// Knob 2: Speed. At 2 one vine takes 13 seconds: it starts climbing at 0.45, reaches its full height at 6.45, the four lanterns catch at about 3.9, 5.3, 6.0 and 7.4, it stands lit until 11, withers in 1.5 and the ground rests half a second. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Vines. One vine leans away from the moon with four pumpkins. Two share the width with leaves a fifth smaller and three pumpkins each, three with leaves a third smaller and two each, the one under the moon stopping lower. Turning it lays the vines out again at the same stage of growth.\n// Knob 4: Curl. How hard the stem winds, how flat the leaves spread and how far the tendrils coil: at 0.06 the stem sways gently, the leaves stand half upright and each tendril makes one turn; at 1 the stem swings in wide S-bends, the leaves spread flat out and the tendrils are springs of two and a half turns.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, asin, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sstep = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// One vine, in story seconds (one a second at Speed 2): the stem starts at\n// T0 and reaches the top GROW later; the vine stands until HOLD_END,\n// withers in WITHER and the ground rests until CYCLE.\nconst T0 = 0.45, GROW = 6, HOLD_END = 11, WITHER = 1.5, CYCLE = 13;\n// A leaf unfolds in LEAF_T after the tip passes its joint, a pumpkin swells\n// in PUMP_T, a tendril coils out in TEND_T, a lantern catches in LIGHT_T.\nconst LEAF_T = 1.2, PUMP_T = 1.4, TEND_T = 1.3, LIGHT_T = 0.5;\n// Each LED a part of the vine covers fades in over this long.\nconst RAMP = 0.15;\n// How much brighter the night is once every lantern is lit.\nconst SKY_GLOW = 0.33;\n// The stem stops this far below the top edge; joints come every GAP LEDs of\n// stem; a leaf's radius at the bottom joint.\nconst TOP_Y = 22, GAP = 13, LEAF_R = 15.5;\n// The moon, top right.\nconst MX = 52, MY = 11, MR = 7.5;\n// A pumpkin's half-width and half-height at full size.\nconst PRX = 8, PRY = 6.5;\n// Up to this many parts of the vine are kept per LED, newest on top.\nconst EV = 4;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, spell: 0, speed: 2, vines: 0, curl: -1,\n    bg: new Float32Array(N * 3), bgSpell: NaN,\n    evN: new Uint8Array(N), evT: new Float32Array(N * EV), evA: new Float32Array(N * EV), evK: new Uint8Array(N * EV),\n    tmpT: new Float32Array(N), tmpA: new Float32Array(N), tmpK: new Uint8Array(N), tmpD: new Float32Array(N), touched: [],\n    rgb: new Float32Array(N * 3), lv: new Float32Array(N), pm: new Uint8Array(N), pal: null, palSpell: NaN,\n    pumpkins: [], stars: [], seed: 0, rng: null,\n  };\n}\n\n// The palette for a Spell setting. Parts of the vine store only a kind, so\n// turning Spell recolours a vine that has already grown.\n// Kinds: 1 stem, 2 stem highlight, 3 leaf lit half, 4 leaf shaded half,\n// 5 vein, 6 leaf rim, 7 tendril, and 8, 9 and 11 the lit half, shaded half\n// and rim of every other leaf, a yellower green.\nfunction palette(sp) {\n  const lh = 0.3 + 0.47 * sp;\n  return {\n    1: hsv(0.27 + 0.05 * sp, 0.78, 0.8),\n    2: hsv(0.24 + 0.06 * sp, 0.6, 0.95),\n    3: hsv(lh, 0.86, 0.94),\n    4: hsv(lh + 0.02, 0.9, 0.86),\n    5: hsv(0.22 + 0.08 * sp, 0.62 + 0.2 * sp, 0.97),\n    6: hsv(lh + 0.03, 0.92, 0.7),\n    7: hsv(0.2 + 0.08 * sp, 0.6, 0.92),\n    8: hsv(lh - 0.07, 0.88, 0.96),\n    9: hsv(lh - 0.06, 0.9, 0.88),\n    11: hsv(lh - 0.05, 0.92, 0.72),\n    fire: hsv(0.14 + 0.17 * sp, 0.62, 1),\n    halo: hsv(0.07 + 0.24 * sp, 0.95, 1),\n  };\n}\n\n// The night: a violet sky darker towards the ground, a few still stars, the\n// moon with two faint seas and a soft ring, and a low dark hill.\nfunction sky(S) {\n  const bg = S.bg, sp = S.spell;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3, u = y / H;\n      // Spell turns the violet night to a sickly green one.\n      let r = mix(mix(0.12, 0.035, u), mix(0.02, 0.008, u), sp), g = mix(mix(0.03, 0.008, u), mix(0.17, 0.06, u), sp), b = mix(mix(0.22, 0.075, u), mix(0.09, 0.03, u), sp);\n      const d = hypot(x + 0.5 - MX, y + 0.5 - MY);\n      if (d \u003c MR) {\n        const sea = hypot(x - MX + 2.5, y - MY + 1.5) \u003c 2.6 || hypot(x - MX - 1.5, y - MY - 3) \u003c 2 ? 0.86 : 1;\n        r = 1 * sea;\n        g = mix(0.95, 1, sp) * sea;\n        b = mix(0.76, 0.7, sp) * sea;\n      } else if (d \u003c MR + 6) {\n        const k = ((MR + 6 - d) / 6) ** 2 * 0.35;\n        r += k * 0.9;\n        g += k * 0.8;\n        b += k * 0.7;\n      }\n      // The hill the vine grows out of.\n      const hill = H - 5 + 3 * cos((x - 30) / 14);\n      if (y + 0.5 > hill) (r = 0.18), (g = 0.05), (b = 0.27);\n      if (abs(y + 0.5 - hill) \u003c 0.6) (r = 0.32), (g = 0.12), (b = 0.42);\n      bg[i] = r;\n      bg[i + 1] = g;\n      bg[i + 2] = b;\n    }\n  for (const [x, y, v] of S.stars) {\n    const i = (y * W + x) * 3;\n    bg[i] = max(bg[i], 0.8 * v);\n    bg[i + 1] = max(bg[i + 1], 0.75 * v);\n    bg[i + 2] = max(bg[i + 2], v);\n  }\n  S.bgSpell = sp;\n}\n\n// Building a vine: each part is stamped into a scratch layer first (an\n// arrival time, a coverage and a kind per LED), then the layer goes on top\n// of the parts already there.\nfunction stamp(S, x, y, te, a, kind, d) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || a \u003c= 0) return;\n  const p = y * W + x;\n  if (S.tmpA[p] === 0) (S.touched.push(p), (S.tmpT[p] = te), (S.tmpD[p] = 1e9));\n  S.tmpT[p] = min(S.tmpT[p], te);\n  S.tmpA[p] = max(S.tmpA[p], a);\n  if (d \u003c S.tmpD[p]) (S.tmpD[p] = d), (S.tmpK[p] = kind);\n}\nfunction flush(S) {\n  for (const p of S.touched) {\n    let n = S.evN[p];\n    if (n === EV) {\n      // Full: the oldest part is under three others; drop it.\n      for (let j = 1; j \u003c EV; j++) {\n        S.evT[p * EV + j - 1] = S.evT[p * EV + j];\n        S.evA[p * EV + j - 1] = S.evA[p * EV + j];\n        S.evK[p * EV + j - 1] = S.evK[p * EV + j];\n      }\n      n--;\n    }\n    // Kept in order of arrival, so the one that comes last is drawn on top.\n    let j = n;\n    while (j > 0 && S.evT[p * EV + j - 1] > S.tmpT[p]) {\n      S.evT[p * EV + j] = S.evT[p * EV + j - 1];\n      S.evA[p * EV + j] = S.evA[p * EV + j - 1];\n      S.evK[p * EV + j] = S.evK[p * EV + j - 1];\n      j--;\n    }\n    S.evT[p * EV + j] = S.tmpT[p];\n    S.evA[p * EV + j] = S.tmpA[p];\n    S.evK[p * EV + j] = S.tmpK[p];\n    S.evN[p] = n + 1;\n    S.tmpA[p] = 0;\n  }\n  S.touched.length = 0;\n}\n\n// A round brush along a polyline of [x, y, time] points, or [x, y, time,\n// radius] where it tapers.\nfunction brush(S, pts, rad, kindAt) {\n  for (const [px, py, te, rr] of pts) {\n    const r = rr === undefined ? rad : rr;\n    for (let y = floor(py - r - 1); y \u003c= py + r + 1; y++)\n      for (let x = floor(px - r - 1); x \u003c= px + r + 1; x++) {\n        const d = hypot(x + 0.5 - px, y + 0.5 - py);\n        stamp(S, x, y, te, cl(r + 0.5 - d, 0, 1), kindAt(d / r), d);\n      }\n  }\n}\n\n// The inverse of smoothstep: the share of the way through an eased\n// unfolding at which it has reached u.\nconst unease = (u) => 0.5 - sin(asin(cl(1 - 2 * u, -1, 1)) / 3);\n\n// One vine from the ground at x0, leaning towards lean as it climbs and\n// stopping at row top; it starts at t0, its leaves are scaled by lr and it\n// carries np pumpkins.\nfunction vine(S, x0, lean, top, t0, lr, np) {\n  const R = S.rng, curl = S.curl;\n  // The stem: steered by a heading that swings from side to side, pulled\n  // back towards the line it leans along.\n  const pts = [], amp = 0.365 + 0.95 * (curl - 0.06), lam = 46 + 10 * R(), ph = TAU * R();\n  let x = x0, y = H + 1, s = 0;\n  while (y > top) {\n    const xc = mix(x0, lean, cl((H - y) / H, 0, 1)), th = amp * sin((TAU * s) / lam + ph) - 0.035 * (x - xc);\n    x += 0.5 * sin(th);\n    y -= 0.5 * cos(th);\n    s += 0.5;\n    pts.push([x, y, s]);\n  }\n  const len = s, tipAt = (ss) => t0 + (GROW * ss) / len;\n  brush(S, pts.map(([px, py, ss]) => [px, py, tipAt(ss), (2.2 - (1.1 * ss) / len) * (0.6 + 0.4 * lr)]), 0, (u) => (u \u003c 0.45 ? 2 : 1));\n  flush(S);\n  // The joints, alternating sides.\n  const nodes = [];\n  let side = R() \u003c 0.5 ? -1 : 1;\n  for (let sn = 9; sn \u003c len - 8; sn += GAP) {\n    const pt = pts[min(pts.length - 1, round(sn / 0.5))];\n    nodes.push({ s: sn, x: pt[0], y: pt[1], side, t: tipAt(sn) + 0.15 });\n    side = -side;\n  }\n  // Pumpkins at evenly spread joints from the second to the one below the\n  // top.\n  const last = max(1, nodes.length - 2), pick = new Set();\n  for (let j = 0; j \u003c np; j++) pick.add(round(1 + (j * (last - 1)) / max(1, np - 1)));\n  const prx = PRX * (0.7 + 0.3 * lr);\n  nodes.forEach((nd, j) => {\n    // The leaf: a petiole out and up, then a five-lobed blade that unfolds\n    // from its stalk outwards, the middle lobe first. Curl spreads the\n    // leaves from half upright to flat out.\n    const rad = LEAF_R * lr * (1.08 - (0.32 * nd.s) / len), pl = (3.5 + 1.5 * R()) * lr;\n    let a = nd.side * (0.75 + (curl - 0.06) + 0.25 * R());\n    // A leaf that would cover the moon grows on the other side instead.\n    if (hypot(nd.x + sin(a) * (pl + 0.62 * rad) - MX, nd.y - cos(a) * (pl + 0.62 * rad) - MY) \u003c rad + MR + 2) (a = -a), (nd.side = -nd.side);\n    const dx = sin(a), dy = -cos(a);\n    const bx = nd.x + dx * pl, by = nd.y + dy * pl, cx = bx + dx * 0.62 * rad, cy = by + dy * 0.62 * rad;\n    const stalk = [], alt = j % 2 ? 5 : 0;\n    for (let l = 0; l \u003c= pl; l += 0.5) stalk.push([nd.x + dx * l, nd.y + dy * l, nd.t + 0.15 * LEAF_T * (l / pl)]);\n    brush(S, stalk, 0.9, () => 1);\n    for (let yy = floor(cy - rad - 2); yy \u003c= cy + rad + 2; yy++)\n      for (let xx = floor(cx - rad - 2); xx \u003c= cx + rad + 2; xx++) {\n        const ex = xx + 0.5 - cx, ey = yy + 0.5 - cy, rho = hypot(ex, ey);\n        const phi = atan2(ex * dy - ey * dx, ex * dx + ey * dy);\n        const edge = rad * (0.62 + 0.38 * abs(cos(2.5 * phi)) ** 0.55);\n        const cov = cl(edge - rho + 0.5, 0, 1);\n        if (cov \u003c= 0) continue;\n        // Veins run from the stalk to the three upper lobe tips.\n        const fx = xx + 0.5 - bx, fy = yy + 0.5 - by, fr = hypot(fx, fy);\n        const psi = atan2(fx * dy - fy * dx, fx * dx + fy * dy);\n        let vein = 9;\n        for (const la of [0, 0.4 * PI, -0.4 * PI]) {\n          const lx = cx + rad * (cos(la) * dx + sin(la) * dy) - bx, ly = cy + rad * (cos(la) * dy - sin(la) * dx) - by;\n          const ll = hypot(lx, ly), t2 = cl((fx * lx + fy * ly) / (ll * ll), 0, 1);\n          vein = min(vein, hypot(fx - t2 * lx, fy - t2 * ly));\n        }\n        // Every other leaf is a yellower green, so neighbours stand apart.\n        const kind = edge - rho \u003c 1.1 ? 6 + alt : vein \u003c 0.55 ? 5 : (phi * nd.side > 0 ? 3 : 4) + alt;\n        const u = cl((0.72 * fr) / (1.62 * rad) + (0.28 * abs(psi)) / PI, 0, 1);\n        stamp(S, xx, yy, nd.t + LEAF_T * (0.15 + 0.85 * unease(u)), cov, kind, 0);\n      }\n    flush(S);\n    if (pick.has(j)) {\n      // A pumpkin hangs on the side away from the leaf; the lowest sits on\n      // the hill.\n      const px = cl(nd.x - nd.side * (prx * 0.75 + 1.5), prx + 0.5, W - prx - 0.5);\n      S.pumpkins.push({ x: px, top: min(nd.y + 1, H - 6 - 2 * PRY * (0.7 + 0.3 * lr)), t: nd.t + 0.45, sc: 0.7 + 0.3 * lr });\n    } else {\n      // A tendril: an Euler spiral, its curvature growing along it, so it\n      // runs out straight and winds into a tight coil.\n      const turns = mix(1, 2.5, curl), tl = mix(10, 17, curl) * lr, a0 = -nd.side * (1.1 + 0.3 * R()), c0 = 0.04;\n      const cb = (TAU * turns - c0 * tl) / (tl * tl), spin = -nd.side;\n      const tp = [];\n      let qx = nd.x, qy = nd.y, l = 0;\n      while (l \u003c tl) {\n        const hd = a0 + spin * (c0 * l + cb * l * l);\n        qx += 0.3 * sin(hd);\n        qy -= 0.3 * cos(hd);\n        l += 0.3;\n        tp.push([qx, qy, nd.t + 0.3 + TEND_T * (l / tl)]);\n      }\n      brush(S, tp, 0.55, () => 7);\n      flush(S);\n    }\n  });\n}\n\n// Lay out the vines: one leans away from the moon; two or three share the\n// width with smaller leaves, starting 0.15 seconds apart.\nconst LAYOUT = {\n  1: [[0, 20, TOP_Y]],\n  2: [[17, 15, TOP_Y], [45, 38, TOP_Y + 10]],\n  3: [[11, 10, TOP_Y], [32, 28, TOP_Y + 4], [53, 44, TOP_Y + 16]],\n};\n// A small seeded generator: a vine keeps its seed until the next one\n// starts, so turning Curl or Vines bends the same vine instead of drawing\n// a new one at every step of the knob.\nfunction rng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = Math.imul(a ^ (a >>> 15), a | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nfunction build(S) {\n  S.rng = rng(S.seed);\n  S.evN.fill(0);\n  S.lv.fill(0);\n  S.pm.fill(0);\n  S.pumpkins = [];\n  const nv = S.vines, lr = [0, 1, 0.8, 0.68][nv], np = [0, 4, 3, 2][nv];\n  LAYOUT[nv].forEach(([x0, lean, top], v) => vine(S, x0 || 30 + 8 * S.rng(), lean, top, T0 + 0.15 * v, lr, np));\n  // The lanterns catch one by one in the order their pumpkins swelled.\n  S.pumpkins.sort((a, b) => a.t - b.t);\n  let light = 0;\n  for (const P of S.pumpkins) P.light = light = max(P.t + PUMP_T + 0.25, light + 0.55);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.spell = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  const nv = cl(round(k[2]), 1, 3), curl = cl(k[3], 0, 1);\n  if (S.stars.length === 0) {\n    for (let i = 0; i \u003c 22; i++) S.stars.push([floor(Math.random() * W), floor(Math.random() * 70), 0.25 + 0.3 * Math.random()]);\n    S.seed = floor(Math.random() * 4294967296);\n  }\n  if (nv !== S.vines || abs(curl - S.curl) > 0.004) {\n    S.vines = nv;\n    S.curl = curl;\n    build(S);\n  }\n  S.t += (d * S.speed) / 2;\n  if (S.t >= CYCLE) {\n    S.t -= CYCLE;\n    S.seed = floor(Math.random() * 4294967296);\n    build(S);\n  }\n}\n\n// A pumpkin at swell sw (0 to 1) hanging from (x, top), carved face lit by\n// f; writes into rgb over whatever is there and marks its LEDs in pm, so\n// the withering knows them.\nfunction pumpkin(S, P, sw, f, rgb) {\n  const rx = PRX * P.sc * sw, ry = PRY * P.sc * sw, cx = P.x, cy = P.top + 1 + ry, fire = S.pal.fire, stem = S.pal[1];\n  for (let y = floor(cy - ry - 3); y \u003c= cy + ry + 1; y++)\n    for (let x = floor(cx - rx - 1); x \u003c= cx + rx + 1; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const u = (x + 0.5 - cx) / rx, v = (y + 0.5 - cy) / ry, rr = sqrt(u * u + v * v);\n      const i = (y * W + x) * 3;\n      // The stalk, a green stub on top.\n      if (y + 0.5 \u003c cy - ry + 1 && y + 0.5 > cy - ry - 2.5 && abs(x + 0.5 - cx - 0.4) \u003c 1.1) {\n        rgb[i] = stem[0];\n        rgb[i + 1] = stem[1];\n        rgb[i + 2] = stem[2];\n        S.pm[y * W + x] = 1;\n        continue;\n      }\n      const a = cl((1 - rr) * rx + 0.5, 0, 1);\n      if (a \u003c= 0) continue;\n      // Every part of a pumpkin keeps red at full, so as it swells no LED\n      // under it gets dimmer: ribs are a deeper orange, the shine a yellower one.\n      const w = u / sqrt(max(0.05, 1 - v * v)), rib = abs(abs(w) - 0.5) \u003c 0.12 || abs(w) \u003c 0.06;\n      let g = rib ? 0.3 : 0.5;\n      if (u \u003c -0.15 && v \u003c -0.2 && u * u + v * v > 0.25 && u * u + v * v \u003c 0.6) g = 0.68;\n      let r = 1, b = 0;\n      if (f > 0) {\n        // The carved face: two triangle eyes, a nose and a jagged grin.\n        const eye = v \u003c= -0.06 && v >= -0.5 + abs(abs(u) - 0.4) * 1.9 && abs(u) \u003c 0.7;\n        const nose = v \u003c= 0.18 && v >= -0.02 + abs(u) * 1.8;\n        const top = 0.3 + 0.08 * u * u, bot = 0.62 - 0.18 * u * u;\n        let mouth = abs(u) \u003c 0.66 && v >= top && v \u003c= bot;\n        if (mouth && ((u > -0.32 && u \u003c -0.14 && v \u003c top + 0.15) || (u > 0.14 && u \u003c 0.32 && v > bot - 0.15))) mouth = false;\n        if (eye || nose || mouth) (g = mix(g, fire[1], f)), (b = fire[2] * f), (r = mix(1, max(fire[0], 0.85), f));\n      }\n      rgb[i] = mix(rgb[i], r, a);\n      rgb[i + 1] = mix(rgb[i + 1], g, a);\n      rgb[i + 2] = mix(rgb[i + 2], b, a);\n      S.pm[y * W + x] = 1;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.pumpkins) return;\n  if (S.bgSpell !== S.spell) sky(S);\n  if (S.palSpell !== S.spell) (S.pal = palette(S.spell)), (S.palSpell = S.spell), S.lv.fill(0);\n  const t = S.t, rgb = S.rgb, bg = S.bg, pal = S.pal;\n  const wi = t > HOLD_END ? sstep((t - HOLD_END) / WITHER) : 0;\n  // Each lantern that catches lifts the whole night a step, from deep\n  // violet towards a warmer, lighter one.\n  let glow = 0;\n  for (const P of S.pumpkins) glow += cl((t - P.light) / LIGHT_T, 0, 1);\n  glow = (glow / max(1, S.pumpkins.length)) * (1 - cl(wi * 2, 0, 1));\n  const sg = 1 + SKY_GLOW * glow, warm = 0.025 * glow;\n  for (let p = 0; p \u003c N; p++) {\n    const i = p * 3;\n    let r = bg[i] * sg + warm, g = bg[i + 1] * sg, b = bg[i + 2] * sg;\n    for (let j = 0; j \u003c S.evN[p]; j++) {\n      const q = p * EV + j, a = S.evA[q] * cl((t - S.evT[q]) / RAMP, 0, 1);\n      if (a \u003c= 0) break;\n      const c = pal[S.evK[q]];\n      r = mix(r, c[0], a);\n      g = mix(g, c[1], a);\n      b = mix(b, c[2], a);\n    }\n    rgb[i] = r;\n    rgb[i + 1] = g;\n    rgb[i + 2] = b;\n  }\n  // Pumpkins swell, then light one by one; each lit lantern throws a warm\n  // glow on the leaves and the sky round it.\n  const lit = [];\n  for (const P of S.pumpkins) {\n    const sw = sstep((t - P.t) / PUMP_T);\n    if (sw \u003c= 0) continue;\n    const f = cl((t - P.light) / LIGHT_T, 0, 1) * (1 - cl(wi * 2, 0, 1));\n    pumpkin(S, P, 0.25 + 0.75 * (1 - (1 - sw) ** 2), f, rgb);\n    if (f > 0) lit.push([P.x, P.top + 1 + PRY * P.sc, f, P.sc]);\n  }\n  const halo = pal.halo, HR = 22;\n  for (const [hx, hy, f, sc] of lit)\n    for (let y = max(0, floor(hy - HR)); y \u003c= min(H - 1, hy + HR); y++)\n      for (let x = max(0, floor(hx - HR)); x \u003c= min(W - 1, hx + HR); x++) {\n        const dd = hypot((x + 0.5 - hx) / (PRX * sc), (y + 0.5 - hy) / (PRY * sc));\n        if (dd \u003c 1.05) continue;\n        const k = 0.45 * f * (1 - min(1, hypot(x + 0.5 - hx, y + 0.5 - hy) / HR)) ** 2, i = (y * W + x) * 3;\n        rgb[i] += halo[0] * k;\n        rgb[i + 1] += halo[1] * k;\n        rgb[i + 2] += halo[2] * k;\n      }\n  for (let p = 0; p \u003c N; p++) {\n    const i = p * 3;\n    let r = min(1, rgb[i]), g = min(1, rgb[i + 1]), b = min(1, rgb[i + 2]);\n    if (wi > 0) {\n      // Withering: the vine dulls to a dead violet and sinks into the night.\n      // The sky only loses the lanterns' glow.\n      const L = max(r, g, b) * 0.6, w2 = S.evN[p] || S.pm[p] ? cl(wi * 1.6, 0, 1) : 0, w3 = sstep((wi - 0.35) / 0.65);\n      r = mix(mix(r, L * 0.62, w2), bg[i], w3);\n      g = mix(mix(g, L * 0.18, w2), bg[i + 1], w3);\n      b = mix(mix(b, L, w2), bg[i + 2], w3);\n    } else {\n      // While the vine grows no LED ever gets dimmer: a part that arrives\n      // darker than what it covers is lifted to the level that was there.\n      const L = max(r, g, b);\n      if (L \u003c S.lv[p] && L > 0) {\n        const k = S.lv[p] / L;\n        (r = min(1, r * k)), (g = min(1, g * k)), (b = min(1, b * k));\n      } else S.lv[p] = L;\n    }\n    display.setPixel(p % W, floor(p / W), round(255 * r), round(255 * g), round(255 * b));\n  }\n}\n","specimen-jar":"// ===== Patternflow pattern =====\n// Title:   Specimen Jar\n// Family:  halloween\n// Idea:    A glass specimen jar on a dark violet shelf, full of glowing toxic-green fluid with light rippling through it, holds a bloodshot eyeball with a violet iris that bobs and turns as it floats, trailing its pink nerve, its gaze wandering round the jar until it swings round to stare straight out, swims up to the glass and opens its pupil wide while the fluid glows up, and bubbles rise past it to pop at the surface.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bubbles=0..1, Stare=0..1\n//\n// Knob 1: Hue. Turns the fluid from toxic green at 0 through teal at 0.3 and deep blue at 0.6 to magenta at 1, never round through orange, which glows brown this dim. The iris always takes the opposite colour: violet at 0, red at 0.3, gold at 0.6, green at 1. The eye's white, its veins, the lid and the shelf stay as they are.\n// Knob 2: Speed. At 2 the eye bobs through 16 rows every 7 seconds, a small bubble takes about 6 seconds to rise and a big one 4, and the light ripples drift a few LEDs a second. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Bubbles. At 0 a trickle of 4 bubbles a second from three spots on the bottom, a third of them rings 2 to 4 LEDs across and the rest single sparks; at 0.5 about 15 a second; at 1 a fizz of 46 a second from all over the bottom, most of them rings up to 6 LEDs across.\n// Knob 4: Stare. How often the eye turns to stare straight out at you: every 14 seconds at 0, every 13.4 at 0.06 (the first time 4 seconds in), every 3.6 at 1, where it hardly looks away. Each stare lasts about 3 seconds: the eye swings round to face out, swims up to the glass a fifth bigger, its pupil opens from a third of the iris to most of it, and the fluid glows up round it.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, atan2, acos, exp, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst wrap = (a) => a - TAU * floor((a + PI) / TAU);\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The jar, row by row: the lid, the neck, the shoulder curving out, the body\n// 50 LEDs across inside, the rounded bottom, and the shelf it stands on.\nconst CX = 32;\nconst LID0 = 9, LID1 = 20, NECK0 = 21, SH0 = 25, SH1 = 31, BOT0 = 106, BOT1 = 112, SHELF = 114;\n// The fluid's surface, a few rows below the shoulder.\nconst SURF = 34;\nfunction halfIn(y) {\n  if (y \u003c NECK0 || y >= BOT1) return -1;\n  if (y \u003c SH0) return 19.5;\n  if (y \u003c SH1) return 19.5 + 5.5 * sqrt(1 - ((SH1 - y) / (SH1 - SH0)) ** 2);\n  if (y \u003c BOT0) return 25;\n  const u = (y - BOT0) / (BOT1 - BOT0);\n  return 25 - 5 * (1 - sqrt(1 - u * u));\n}\n\n// The eye's size, and its iris and pupil as angles from the gaze axis.\nconst ER = 14.5, IRIS = 0.62;\n// Veins on the white: eight from the back of the eye towards the iris, each\n// with one branch, laid out in the eye's own angles (th from the gaze axis,\n// ph round it) so they turn with it. Each is tabled once, ph against th.\nconst VEINS = [], VT = 129;\nfor (let k = 0; k \u003c 8; k++) {\n  const ph0 = (k * TAU) / 8 + 0.35 * sin(k * 2.3), a = 0.22 + 0.08 * sin(k * 1.7), f = 3 + (k % 3), p = k * 1.3;\n  const tab = new Float32Array(VT);\n  for (let j = 0; j \u003c VT; j++) {\n    const th = (j * PI) / (VT - 1);\n    tab[j] = ph0 + a * sin(f * th + p) + 0.1 * sin(9 * th + 2 * p);\n  }\n  VEINS.push({ tab, end: 0.74 + 0.1 * ((k * 5) % 3), br: 1.3 + 0.25 * ((k * 3) % 4), bd: k % 2 ? 1 : -1 });\n}\n\nexport function setup(params) {\n  const reg = new Uint8Array(N), hw = new Float32Array(H);\n  for (let y = 0; y \u003c H; y++) hw[y] = halfIn(y);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, dx = abs(x + 0.5 - CX);\n      // 1 inside the glass, 2 the glass wall, 3 the thick base, 4 the lid,\n      // 5 the shelf top, 6 the shelf front, 0 the wall behind.\n      if (y >= LID0 && y \u003c= LID1) {\n        const r = y === LID0 ? 20.5 : y === LID0 + 1 ? 22 : 23;\n        if (dx \u003c r) reg[i] = 4;\n      } else if (hw[y] > 0 && dx \u003c hw[y]) reg[i] = 1;\n      else if (hw[y] > 0 && dx \u003c hw[y] + 1.3) reg[i] = 2;\n      else if (y >= BOT1 && y \u003c SHELF && dx \u003c 23) reg[i] = 3;\n      if (y >= SHELF && y \u003c SHELF + 2) reg[i] = 5;\n      else if (y >= SHELF + 2 && y \u003c SHELF + 9) reg[i] = 6;\n    }\n  params.s = {\n    t: 0, hue: 0, speed: 2, bub: 0, stareK: 0.06,\n    reg, hw,\n    // Where the eye looks and where it is headed, the stare's phase, how far\n    // it has turned to stare and how wide the pupil is.\n    yaw: 0.7, pitch: 0.2, roll: 0, tyaw: 0.7, tpitch: 0.2, next: 1.2,\n    sp: 0.7, stare: 0, dil: 0,\n    bubbles: [], acc: 0, pops: [],\n    rgb: new Float32Array(N * 3), nerve: new Float32Array(N), cs: new Float32Array(2 * W + H),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.bub = cl(k[2], 0, 1);\n  S.stareK = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  // The stare comes round every 14 seconds at 0 and every 3.6 at 1; for 3.1\n  // seconds of each round the eye turns to look straight out of the jar.\n  const period = mix(14, 3.6, S.stareK);\n  S.sp += g / period;\n  const into = (S.sp - floor(S.sp)) * period;\n  const staring = into \u003c 3.1;\n  S.stare += ((staring ? 1 : 0) - S.stare) * min(1, g * (staring ? 3.5 : 2));\n  S.dil += ((staring && into > 0.5 ? 1 : 0) - S.dil) * min(1, g * 2.2);\n  // Wandering: somewhere new to look every 1.5 to 3.5 seconds, a quarter of\n  // the time far round to the side, so the back of the eye and its nerve\n  // turn into view.\n  S.next -= g;\n  if (S.next \u003c= 0) {\n    S.next = 1.5 + 2 * Math.random();\n    S.tyaw = (Math.random() * 2 - 1) * (Math.random() \u003c 0.25 ? 2.3 : 1.1);\n    S.tpitch = (Math.random() * 2 - 1) * 0.6;\n  }\n  const ty = mix(S.tyaw, 0, S.stare), tp = mix(S.tpitch, 0, S.stare);\n  const rate = min(1, g * (1.2 + 3 * S.stare));\n  S.yaw += (ty - S.yaw) * rate;\n  S.pitch += (tp - S.pitch) * rate;\n  S.roll = 0.35 * sin(S.t * 0.23) + 0.15 * sin(S.t * 0.61);\n  // Bubbles: a trickle from three vents at 0, a fizz from all over the\n  // bottom at 1, more of them big.\n  S.acc += g * mix(4, 46, S.bub * S.bub);\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    const vent = Math.random() \u003c 0.85 - 0.6 * S.bub;\n    const x = vent ? CX + [-14, 3, 15][floor(Math.random() * 3)] + Math.random() * 2 - 1 : CX + (Math.random() * 2 - 1) * 22;\n    const r = Math.random() \u003c 0.3 + 0.4 * S.bub ? 1.1 + Math.random() * (0.9 + S.bub) : 0.5;\n    S.bubbles.push({ x, y: BOT1 - 1, z: Math.random() * 2 - 1, r, v: 2, ph: TAU * Math.random() });\n  }\n  for (const b of S.bubbles) {\n    b.v = min(b.v + g * 30, 9 + 7 * b.r);\n    b.y -= b.v * g;\n    // A zigzag of about one LED either side as it climbs.\n    b.x += 3 * sin(b.ph + b.y * 0.25) * g;\n    if (b.y \u003c SURF + 0.5) {\n      b.dead = 1;\n      S.pops.push({ x: b.x, life: 0.25 });\n    }\n  }\n  S.bubbles = S.bubbles.filter((b) => !b.dead);\n  for (const p of S.pops) p.life -= g;\n  S.pops = S.pops.filter((p) => p.life > 0);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, reg, hw, nerve, cs } = S, t = S.t;\n  const fl = hsv(0.29 + 0.63 * S.hue, 0.92, 1);\n  const iris = hsv(0.79 + 0.63 * S.hue, 0.8, 1);\n  // The eye: bobbing, swaying, swimming up to the glass when it stares.\n  const bobA = 1 - 0.6 * S.stare;\n  const ex = CX + 4 * sin(t * 0.45 + 1) * bobA;\n  const ey = 70 + (8 * sin(t * 0.9) + 1.5 * sin(t * 2.1)) * bobA;\n  const er = ER * (1 + 0.2 * S.stare);\n  const ca = cos(S.yaw), sa = sin(S.yaw), cb = cos(S.pitch), sb = sin(S.pitch);\n  const f = [sa * cb, sb, ca * cb];\n  // Two axes across the gaze, turned by the roll, for the angle round it.\n  const r0 = [ca, 0, -sa], u0 = [-sa * sb, cb, -ca * sb];\n  const cr = cos(S.roll), sr = sin(S.roll);\n  const rx = [r0[0] * cr + u0[0] * sr, r0[1] * cr + u0[1] * sr, r0[2] * cr + u0[2] * sr];\n  const ux = [u0[0] * cr - r0[0] * sr, u0[1] * cr - r0[1] * sr, u0[2] * cr - r0[2] * sr];\n  const pupil = mix(0.36, 0.7, S.dil);\n\n  // The optic nerve, a pink cord trailing from the back of the eye, waving\n  // in the fluid. Behind the eye while it looks out, in front of it when it\n  // looks away.\n  nerve.fill(0);\n  const front = f[2] \u003c 0;\n  {\n    let bx = -f[0], by = -f[1];\n    const bl = hypot(bx, by);\n    let dx = bl > 0.05 ? bx / bl : 0, dy = bl > 0.05 ? by / bl : 1;\n    let x = ex + er * bx, y = ey + er * by;\n    for (let s = 0; s \u003c 13; s++) {\n      const rad = 2.3 - 0.09 * s;\n      for (let yy = floor(y - rad); yy \u003c= y + rad; yy++)\n        for (let xx = floor(x - rad); xx \u003c= x + rad; xx++) {\n          if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H) continue;\n          const dd = hypot(xx + 0.5 - x, yy + 0.5 - y);\n          if (dd \u003c rad) nerve[yy * W + xx] = max(nerve[yy * W + xx], dd \u003c rad - 1 ? 1 : 0.6);\n        }\n      // Each step bends towards hanging down and waves with the fluid.\n      const a = atan2(dy, dx), down = PI / 2, wave = 0.32 * sin(t * 1.6 - s * 0.45);\n      const na = a + 0.12 * wrap(down - a) + wave * 0.35;\n      dx = cos(na);\n      dy = sin(na);\n      x += 2 * dx;\n      y += 2 * dy;\n    }\n  }\n\n  // The caustics: three wavy bands, light where their sum crosses zero.\n  // Their inner waves are kept per row, per column and per diagonal.\n  for (let i = 0; i \u003c W + H; i++) cs[i] = 0.7 * sin((i - H) * 0.1 + t * 0.9);\n  for (let x = 0; x \u003c W; x++) cs[W + H + x] = 0.9 * sin(x * 0.15 - t * 0.6);\n  const glowE = 0.1 * (0.6 + 1.4 * S.stare), flare = 1 + 0.5 * S.stare;\n  const gx = CX - 18.5, gy = 37 + ((t * 11) % 130);\n\n  for (let y = 0; y \u003c H; y++) {\n    const rowW = 0.9 * sin(y * 0.13 + t * 0.9);\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, rg = reg[i], px = x + 0.5, py = y + 0.5;\n      let r = 0.035, gg = 0.012, b = 0.06;\n      if (rg === 1) {\n        // The fluid's surface waves, and climbs a row at the glass.\n        const sy = SURF + 0.6 * sin(0.35 * x + 1.9 * t) + 0.4 * sin(0.6 * x - 2.7 * t) - (abs(px - CX) > hw[y] - 2 ? 1 : 0);\n        if (py \u003c sy - 0.5) {\n          // Air above the fluid, faintly lit from below.\n          r = 0.03 + 0.06 * fl[0];\n          gg = 0.02 + 0.08 * fl[1];\n          b = 0.06 + 0.06 * fl[2];\n        } else {\n          const cyl = 1 - ((px - CX) / hw[y]) ** 2;\n          const a1 = x * 0.21 + rowW + t * 0.75;\n          const a2 = y * 0.17 + cs[W + H + x] - t * 1.1;\n          const a3 = (x + y) * 0.12 + cs[x - y + H];\n          const cv = abs(sin(a1) + sin(a2) + sin(a3));\n          const caus = cv \u003c 0.3 ? 1 - cv / 0.3 : 0;\n          const de = sqrt((px - ex) ** 2 + (py - ey) ** 2) - er;\n          let L = (0.07 + 0.2 * cyl * cyl) * flare + caus * (0.3 + 0.45 * cyl) + (de > 0 && de \u003c 24 ? glowE * exp(-de / 6) : 0);\n          if (py \u003c sy + 0.5) L = 0.95;\n          L = q(L, 14);\n          r = fl[0] * L;\n          gg = fl[1] * L;\n          b = fl[2] * L;\n        }\n      } else if (rg === 2) {\n        r = 0.16 + 0.22 * fl[0];\n        gg = 0.18 + 0.26 * fl[1];\n        b = 0.22 + 0.22 * fl[2];\n      } else if (rg === 3) {\n        r = fl[0] * 0.5;\n        gg = fl[1] * 0.5;\n        b = fl[2] * 0.5;\n      } else if (rg === 4) {\n        // Pewter lid: ridges, round shading, a bright band and a faint one.\n        const dx = abs(px - CX), round_ = 0.6 + 0.4 * sqrt(max(0, 1 - (dx / 23) ** 2));\n        const ridge = (y - LID0) % 2 === 0 ? 1.25 : 0.8;\n        const spec = abs(px - (CX - 12)) \u003c 1.5 ? 2.8 : abs(px - (CX + 9)) \u003c 1 ? 1.6 : 1;\n        const v = ridge * spec * round_ * (y === LID1 ? 0.6 : 1);\n        r = 0.17 * v;\n        gg = 0.13 * v;\n        b = 0.25 * v;\n        if (y === LID0) (r = 0.42), (gg = 0.36), (b = 0.52);\n      } else if (rg === 5) {\n        const pool = exp(-abs(px - CX) / 16);\n        r = 0.2 + 0.45 * pool * fl[0];\n        gg = 0.1 + 0.45 * pool * fl[1];\n        b = 0.28 + 0.45 * pool * fl[2];\n      } else if (rg === 6) {\n        const edge = y === SHELF + 2;\n        r = edge ? 0.26 : 0.1;\n        gg = edge ? 0.15 : 0.04;\n        b = edge ? 0.36 : 0.16;\n      } else if (y \u003c SHELF) {\n        // The wall behind: violet dark, with the fluid's glow round the jar.\n        const hwy = hw[cl(y, NECK0, BOT1 - 1)];\n        const dxo = max(0, abs(px - CX) - (hwy > 0 ? hwy : 22));\n        const glow = 0.1 * exp(-dxo / 5) * (y > SURF ? 1 : 0.4);\n        r += glow * fl[0];\n        gg += glow * fl[1];\n        b += glow * fl[2];\n      }\n      if (rg === 1) {\n        const u = (px - ex) / er, v = (py - ey) / er, d2 = u * u + v * v;\n        const nv = nerve[i];\n        if (nv && (front || d2 >= 1)) {\n          r = 0.9 * nv;\n          gg = 0.32 * nv;\n          b = 0.42 * nv;\n        } else if (d2 \u003c 1) {\n          const nz = sqrt(1 - d2), cosA = u * f[0] + v * f[1] + nz * f[2];\n          const th = acos(cl(cosA, -1, 1));\n          // Lit by the fluid all round, brightest where it faces out.\n          const sh = 0.55 + 0.45 * nz;\n          if (th \u003c IRIS * pupil) (r = 0), (gg = 0), (b = 0);\n          else if (th \u003c IRIS) {\n            const tt = th / IRIS;\n            const ph = atan2(u * ux[0] + v * ux[1] + nz * ux[2], u * rx[0] + v * rx[1] + nz * rx[2]);\n            // Fibres round the pupil, a pale ring at its edge, a near-black\n            // ring at the rim. The iris never goes below 0.6 of full, so a\n            // gold one stays gold and does not turn olive.\n            const streak = 0.8 + 0.2 * sin(ph * 15 + 3 * sin(ph * 4));\n            const vv = tt > 0.86 ? 0.05 : streak * (tt \u003c pupil + 0.12 ? 1 : 0.85) * (0.75 + 0.25 * sh);\n            r = iris[0] * vv;\n            gg = iris[1] * vv;\n            b = iris[2] * vv;\n          } else {\n            const rim = (1 - nz) * (1 - nz);\n            r = mix(1, fl[0], 0.7 * rim) * sh;\n            gg = mix(0.97, fl[1], 0.7 * rim) * sh;\n            b = mix(0.95, fl[2], 0.7 * rim) * sh;\n            const ph = atan2(u * ux[0] + v * ux[1] + nz * ux[2], u * rx[0] + v * rx[1] + nz * rx[2]);\n            const st = sin(th) * er, j = round((th / PI) * (VT - 1)), w = 0.45 + 0.35 * (th / PI);\n            for (const vn of VEINS) {\n              if (th \u003c vn.end) continue;\n              const vp = vn.tab[j];\n              if (abs(wrap(ph - vp)) * st \u003c w || (th \u003c vn.br && th > vn.end + 0.1 && abs(wrap(ph - vp - vn.bd * 0.9 * (vn.br - th))) * st \u003c w * 0.8)) {\n                r = 0.8 * sh;\n                gg = 0.02 * sh;\n                b = 0.06 * sh;\n                break;\n              }\n            }\n          }\n          // The wet glint.\n          if ((u + 0.38) ** 2 + (v + 0.42) ** 2 \u003c 0.018) (r = 1), (gg = 1), (b = 1);\n        }\n      }\n      // The glass catches the light: a streak down its left side with a glint\n      // sliding down it, a fainter one on the right.\n      if ((rg === 1 || rg === 2) && y > 36 && y \u003c 104) {\n        let hl = 0;\n        if (abs(px - gx) \u003c 1) hl = abs(py - gy) \u003c 3 ? 0.7 : 0.26;\n        else if (abs(px - (CX + 21.5)) \u003c 0.6 && y > 42 && y \u003c 98) hl = 0.16;\n        r += hl;\n        gg += hl;\n        b += hl;\n      }\n      const o = i * 3;\n      rgb[o] = r;\n      rgb[o + 1] = gg;\n      rgb[o + 2] = b;\n    }\n  }\n  // Bubbles: a bright point, or a ring for the bigger ones; those behind the\n  // eye are hidden by it.\n  for (const bb of S.bubbles) {\n    const R = bb.r, x0 = floor(bb.x - R - 1), y0 = floor(bb.y - R - 1);\n    for (let y = y0; y \u003c= y0 + 2 * R + 2; y++)\n      for (let x = x0; x \u003c= x0 + 2 * R + 2; x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || reg[y * W + x] !== 1) continue;\n        if (bb.z \u003c 0 && (x + 0.5 - ex) ** 2 + (y + 0.5 - ey) ** 2 \u003c er * er) continue;\n        const dd = hypot(x + 0.5 - bb.x, y + 0.5 - bb.y);\n        if (R \u003c 1 ? dd \u003c 0.75 : abs(dd - R) \u003c 0.55) {\n          const o = (y * W + x) * 3;\n          rgb[o] = mix(fl[0], 1, 0.6);\n          rgb[o + 1] = mix(fl[1], 1, 0.6);\n          rgb[o + 2] = mix(fl[2], 1, 0.6);\n        }\n      }\n  }\n  // A popped bubble flicks two drops off the surface.\n  for (const p of S.pops) {\n    const y = SURF - 2 - (p.life \u003c 0.12 ? 1 : 0);\n    for (const dx of [-1, 1]) {\n      const x = floor(p.x + dx * (1.5 - p.life * 2));\n      if (x \u003c 0 || x >= W || reg[y * W + x] !== 1) continue;\n      const o = (y * W + x) * 3;\n      rgb[o] = mix(fl[0], 1, 0.5);\n      rgb[o + 1] = mix(fl[1], 1, 0.5);\n      rgb[o + 2] = mix(fl[2], 1, 0.5);\n    }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, floor(i / W), round(255 * cl(rgb[o], 0, 1)), round(255 * cl(rgb[o + 1], 0, 1)), round(255 * cl(rgb[o + 2], 0, 1)));\n  }\n}\n","swarmalators":"// ===== Patternflow pattern =====\n// Title:   Swarmalators\n// Family:  particle\n// Idea:    Two swarms of 150 swarmalators stacked down the panel, each a hard dot coloured by its phase that is pulled towards dots of a like colour and kept off by all of them, settle into rainbow rings whose colour runs once round, and as the phase coupling swings slowly up and down the rings squeeze into ovals, splinter and churn, the lower swarm always a step further along the coupling, where its dots circulate round the ring.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Swarmalators (Kevin O'Keeffe, Hyunsuk Hong and Steven Strogatz, 2017), pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Coupling=-1..0.5, Tour=0..1\n//\n// Knob 1: Hue. Turns every dot's colour round the wheel together. Each ring always carries the whole wheel, so the knob turns which colour sits where: at 0 the top ring starts red on its right, cyan on its left, blue and magenta on top and yellow and green below; at 0.5 the two halves swap. A swarm that has synchronised is one solid disc: with Coupling at 0.5 the top one goes red at Hue 0 and cyan at 0.5.\n// Knob 2: Speed. At 2 the equations run 4 of their time units a second, so a dot circulating in the bottom ring moves about 11 LEDs a second, and the coupling swing takes 24 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Coupling. The phase coupling K of the top swarm; the bottom swarm's is always 0.75 lower. At 0 the top is the static phase wave, a still rainbow ring, and the bottom the active phase wave, its dots circulating and jostling round a looser ring. At 0.5 the top synchronises within 8 seconds, folding its ring into one solid disc of a single colour 23 LEDs across, while the bottom stiffens into a clean still ring. At -1 the top churns at the edge of disorder and the bottom is static async, a disc of confetti.\n// Knob 4: Tour. How far K swings, slowly, about where Coupling puts it: plus and minus the square root of Tour, once every 24 seconds at Speed 2. At 0 there is no swing and only a faint spread of natural frequencies keeps the still ring creeping; at 0.06 K swings by 0.25, so the top ring squeezes into an oval towards sync for 12 seconds and splinters for 12; at 1 K swings by 1: every lap the top ring folds into a one-colour disc, breaks into confetti and opens back into a ring, and the bottom runs from a still ring through its circulating one to confetti and back.\n\nconst W = 64, H = 128;\nconst { floor, sqrt, sin, cos, PI, round, ceil, max } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The swarm is round and the panel is twice as tall as it is wide, so it\n// carries two swarms, one in each 64 by 64 half, each the model untouched.\n// 150 dots a swarm, one unit of the equations is 18.5 LEDs (the widest\n// state, the static phase wave, reaches 1.53 units, 28 LEDs, from its\n// centre), and a dot is a hard disc of radius 1.76 LEDs, about 10 LEDs.\n// At 120 dots of radius 1.6 the panel lit 22% and its colourfulness was\n// 0.49; this size lights 29% and reaches 0.57.\nconst N = 150, SC = 18.5, R2 = 3.1;\n// The bottom swarm's coupling sits this far below the top's, so the two show\n// neighbouring states; the slow swing of K has this period in story seconds;\n// and the natural frequencies are spread evenly over plus and minus this.\nconst GAP = 0.75, PERIOD = 24, SIG = 0.02;\n\n// The hue scale lingers on the six pure colours and hurries through the\n// in-between ones, so a ring reads as six bands of red, yellow, green, cyan,\n// blue and magenta, each dot at 255 in its strongest channel. Applied twice:\n// once still showed orange and azure arcs that the panel draws dull.\nconst ux = (h) => h - sin(6 * TAU * h) / (6 * TAU);\n\n// A swarm: positions, phases, natural frequencies. The top one starts as the\n// static phase wave it is about to be, phase equal to angle round a ring; the\n// bottom starts as the paper does, phases at random in a disc.\nfunction swarm(cy, ring) {\n  const x = new Float32Array(N), y = new Float32Array(N), th = new Float32Array(N), om = new Float32Array(N);\n  for (let i = 0; i \u003c N; i++) {\n    const a = (TAU * (i + Math.random())) / N, r = ring ? 0.65 + 0.85 * Math.random() : 1.2 * sqrt(Math.random());\n    const b = ring ? a : TAU * Math.random();\n    x[i] = r * cos(b);\n    y[i] = r * sin(b);\n    th[i] = a;\n    om[i] = SIG * ((2 * (i + 0.5)) / N - 1);\n  }\n  for (let i = N - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = om[i];\n    om[i] = om[j];\n    om[j] = t;\n  }\n  return { cy, x, y, th, om, vx: new Float32Array(N), vy: new Float32Array(N), w: new Float32Array(N), c: new Float32Array(N), s: new Float32Array(N), K: 0 };\n}\n\n// One Euler step of the swarmalator equations with A = B = J = 1:\n//   dx_i/dt = 1/N sum_j [ (x_j - x_i)/|x_j - x_i| (1 + cos(th_j - th_i)) - (x_j - x_i)/|x_j - x_i|^2 ]\n//   dth_i/dt = om_i + K/N sum_j sin(th_j - th_i)/|x_j - x_i|\n// Each pair is visited once and its pull handed to both dots with opposite\n// signs, so the swarm's centre never moves. cos and sin of the phase\n// difference come from each dot's own cos and sin, with no trigonometry in\n// the pair loop. A frame at Speed 2 is two steps of each swarm, 11175 pairs\n// a step, and with the drawing it takes under 2 ms.\nfunction step(sw, K, dt) {\n  const { x, y, th, om, vx, vy, w, c, s } = sw;\n  for (let i = 0; i \u003c N; i++) {\n    c[i] = cos(th[i]);\n    s[i] = sin(th[i]);\n    vx[i] = vy[i] = w[i] = 0;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const xi = x[i], yi = y[i], ci = c[i], si = s[i];\n    let ax = 0, ay = 0, aw = 0;\n    for (let j = i + 1; j \u003c N; j++) {\n      const dx = x[j] - xi, dy = y[j] - yi, d2 = dx * dx + dy * dy + 1e-6, inv = 1 / sqrt(d2);\n      const cd = c[j] * ci + s[j] * si, sd = s[j] * ci - c[j] * si;\n      // Attraction of constant strength 1 + cos, stronger between like\n      // phases and gone between opposite ones; repulsion falling as 1/r.\n      const f = (1 + cd) * inv - 1 / d2;\n      const fx = f * dx, fy = f * dy;\n      ax += fx;\n      ay += fy;\n      vx[j] -= fx;\n      vy[j] -= fy;\n      const pw = sd * inv;\n      aw += pw;\n      w[j] -= pw;\n    }\n    vx[i] += ax;\n    vy[i] += ay;\n    w[i] += aw;\n  }\n  for (let i = 0; i \u003c N; i++) {\n    x[i] += (dt * vx[i]) / N;\n    y[i] += (dt * vy[i]) / N;\n    const t = th[i] + dt * (om[i] + (K * w[i]) / N);\n    th[i] = t - TAU * floor(t / TAU);\n  }\n}\n\nexport function setup(params) {\n  const top = swarm(32, true), bot = swarm(96, false);\n  // Thirty time units at K = -0.75 before the first frame: from its random\n  // disc the bottom swarm has found the active phase wave by then.\n  for (let q = 0; q \u003c 300; q++) step(bot, -GAP, 0.1);\n  params.s = { hue: 0, speed: 2, K: 0, tour: 0.06, t: 0, sw: [top, bot], buf: new Uint8Array(W * H * 3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.K = cl(k[2], -1, 0.5);\n  S.tour = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  // The tour: both couplings swing together, a sine about the knob's K.\n  const swing = sqrt(S.tour) * sin((TAU * S.t) / PERIOD);\n  S.sw[0].K = S.K + swing;\n  S.sw[1].K = S.K - GAP + swing;\n  // Four time units a story second, in steps of at most 0.07.\n  const T = g * 4;\n  const n = max(1, ceil(T / 0.07));\n  for (let q = 0; q \u003c n; q++) for (const sw of S.sw) step(sw, sw.K, T / n);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf;\n  buf.fill(0);\n  for (const sw of S.sw) {\n    // Each swarm keeps to its own half: a dot flung out (one in antiphase\n    // with the rest feels no pull, only the push) leaves the panel rather\n    // than wander into the other swarm.\n    const y0h = sw.cy - 32, y1h = sw.cy + 32;\n    let mx = 0, my = 0;\n    for (let i = 0; i \u003c N; i++) (mx += sw.x[i]), (my += sw.y[i]);\n    mx /= N;\n    my /= N;\n    for (let i = 0; i \u003c N; i++) {\n      const c = hsv(ux(ux(sw.th[i] / TAU + S.hue)), 1, 1);\n      const r = round(c[0] * 255), g = round(c[1] * 255), b = round(c[2] * 255);\n      const px = 32 + (sw.x[i] - mx) * SC, py = sw.cy + (sw.y[i] - my) * SC;\n      const x0 = floor(px), y0 = floor(py);\n      for (let dy = -2; dy \u003c= 2; dy++)\n        for (let dx = -2; dx \u003c= 2; dx++) {\n          const ex = x0 + dx + 0.5 - px, ey = y0 + dy + 0.5 - py;\n          if (ex * ex + ey * ey > R2) continue;\n          const xx = x0 + dx, yy = y0 + dy;\n          if (xx \u003c 0 || xx >= W || yy \u003c y0h || yy >= y1h) continue;\n          const o = (yy * W + xx) * 3;\n          buf[o] = r;\n          buf[o + 1] = g;\n          buf[o + 2] = b;\n        }\n    }\n  }\n  for (let i = 0; i \u003c W * H; i++) display.setPixel(i % W, floor(i / W), buf[i * 3], buf[i * 3 + 1], buf[i * 3 + 2]);\n}\n","talking-board":"// ===== Patternflow pattern =====\n// Title:   Talking Board\n// Family:  halloween\n// Idea:    A near-black spirit board lies on the table between two candles, its bone-white alphabet in two arcs, the numbers, YES and NO by a sun and a moon, GOODBYE at the foot, and the heart-shaped pointer glides over it on its own, circling, tilting as it swings, stopping with its round glass window over one letter at a time, which lights up green through the glass and joins a word spelled out above the board: HELLO, BOO, BEHIND YOU, YES, I SEE YOU, 1031, NO, RUN and at last GOODBYE.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Flicker=0..1, Aura=0..1\n//\n// Knob 1: Hue. The colour of whatever answers: the light in and round the pointer's window, the lit letter and the spelled word open a poison green at 0, turn cyan at 0.25, blue at 0.5, violet at 0.75 and pink at 1. The board's dark lacquer turns with it through the cold hues only, violet at 0, magenta at 0.25 and blue at 0.75, so it never goes brown; the bone letters and the candles stay as they are.\n// Knob 2: Speed. At 2 the pointer glides about 55 LEDs a second and rests 0.65 seconds on each letter once it lights; HELLO takes 13 seconds from the first circling to the word fading, and all nine messages 111. At 0.2 everything runs ten times slower, at 3 half as fast again. The candles flicker at their own pace.\n// Knob 3: Flicker. How the two candles burn: at 0 low and nearly still, the foot of the board in a steady pool of light; at 1 the flames stand 40 per cent taller, gutter and lean, a ragged dip can halve one, and their light reaches nearly twice as far up the board, swelling and sinking with them.\n// Knob 4: Aura. The answer's own light round the pointer: at 0.06 a soft glow about 18 LEDs round the window that brightens when a letter lights; at 1 it spreads over 42 LEDs, twice as strong, and washes most of the board in its colour.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ss = (t) => t * t * (3 - 2 * t);\nconst q = (v, n) => round(v * n) / n;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The board's letters, 3 by 5: five rows of three bits, as octal digits.\nconst F3 = {\n  A: \"25755\", B: \"65656\", C: \"34443\", D: \"65556\", E: \"74647\", F: \"74644\", G: \"34553\", H: \"55755\", I: \"72227\",\n  J: \"11152\", K: \"55655\", L: \"44447\", M: \"57755\", N: \"65555\", O: \"25552\", P: \"65644\", Q: \"25563\", R: \"65655\",\n  S: \"34216\", T: \"72222\", U: \"55557\", V: \"55552\", W: \"55775\", X: \"55255\", Y: \"55222\", Z: \"71247\",\n  0: \"75557\", 1: \"26227\", 2: \"61247\", 3: \"61216\", 4: \"55711\", 5: \"74616\", 6: \"34757\", 7: \"71222\", 8: \"75757\", 9: \"75716\",\n};\n// The spelled word's letters, 5 by 7: seven rows of five bits.\nconst F5 = {\n  A: [14, 17, 17, 31, 17, 17, 17], B: [30, 17, 17, 30, 17, 17, 30], C: [14, 17, 16, 16, 16, 17, 14], D: [28, 18, 17, 17, 17, 18, 28],\n  E: [31, 16, 16, 30, 16, 16, 31], F: [31, 16, 16, 30, 16, 16, 16], G: [14, 17, 16, 23, 17, 17, 15], H: [17, 17, 17, 31, 17, 17, 17],\n  I: [14, 4, 4, 4, 4, 4, 14], J: [7, 2, 2, 2, 2, 18, 12], K: [17, 18, 20, 24, 20, 18, 17], L: [16, 16, 16, 16, 16, 16, 31],\n  M: [17, 27, 21, 21, 17, 17, 17], N: [17, 17, 25, 21, 19, 17, 17], O: [14, 17, 17, 17, 17, 17, 14], P: [30, 17, 17, 30, 16, 16, 16],\n  Q: [14, 17, 17, 17, 21, 18, 13], R: [30, 17, 17, 30, 20, 18, 17], S: [15, 16, 16, 14, 1, 1, 30], T: [31, 4, 4, 4, 4, 4, 4],\n  U: [17, 17, 17, 17, 17, 17, 14], V: [17, 17, 17, 17, 17, 10, 4], W: [17, 17, 17, 21, 21, 21, 10], X: [17, 17, 10, 4, 10, 17, 17],\n  Y: [17, 17, 17, 10, 4, 4, 4], Z: [31, 1, 2, 4, 8, 16, 31], 0: [14, 17, 19, 21, 25, 17, 14], 1: [4, 12, 4, 4, 4, 4, 14],\n  2: [14, 17, 1, 2, 4, 8, 31], 3: [31, 2, 4, 2, 1, 17, 14], 4: [2, 6, 10, 18, 31, 2, 2], 5: [31, 16, 30, 1, 1, 17, 14],\n  6: [6, 8, 16, 30, 17, 17, 14], 7: [31, 1, 2, 4, 8, 8, 8], 8: [14, 17, 17, 14, 17, 17, 14], 9: [14, 17, 17, 15, 1, 2, 12],\n};\n\n// The board fills the panel below the spelled word, from row 20 down,\n// with a thin edge line 2 LEDs in.\nconst BTOP = 20;\n// The two alphabet arcs share a centre below them: A to M on the outer\n// arc from -50 to 50 degrees, N to Z on the inner one from -66 to 66.\nconst ARC_X = 32, ARC_Y = 80.5, R1 = 36.5, R2 = 23.5;\n// Where the pointer waits between words, and the two candles.\nconst REST = [32, 96];\nconst CANDLES = [[7, 120], [56, 120]];\n// The messages, spelled in turn. YES, NO and GOODBYE are answered with\n// the printed words.\nconst MESSAGES = [\"HELLO\", \"BOO\", \"BEHIND YOU\", \"YES\", \"I SEE YOU\", \"1031\", \"NO\", \"RUN\", \"GOODBYE\"];\n// Story seconds (one a second at Speed 2): the search loop before a word,\n// settling on a letter, the letter lighting, the rest on it once lit, the\n// hold on a finished word and its fade.\nconst SEARCH = 1.6, SETTLE = 0.15, LIGHT = 0.22, LINGER = 0.65, HOLD = 1.4, FADE = 1.4;\n\nexport function setup(params) {\n  const ink = new Uint8Array(N), glyphOf = new Int16Array(N).fill(-1), haloOf = new Int16Array(N).fill(-1);\n  const glyphs = [], targets = {};\n  // Print one 3 by 5 glyph with its centre at (cx, cy); returns its id.\n  const put = (ch, cx, cy) => {\n    const x0 = round(cx - 1.5), y0 = round(cy - 2.5), id = glyphs.length, rows = F3[ch];\n    glyphs.push({ x0, y0 });\n    for (let r = 0; r \u003c 5; r++)\n      for (let c = 0; c \u003c 3; c++)\n        if ((+rows[r] >> (2 - c)) & 1) {\n          const p = (y0 + r) * W + x0 + c;\n          ink[p] = 1;\n          glyphOf[p] = id;\n        }\n    return id;\n  };\n  const word = (text, cx, cy) => {\n    const ids = [], x0 = cx - (text.length * 4 - 1) / 2 + 1.5;\n    [...text].forEach((ch, i) => ids.push(put(ch, x0 + i * 4, cy)));\n    targets[text] = { x: cx, y: cy, ids };\n  };\n  const arc = (letters, R, a0) => {\n    [...letters].forEach((ch, i) => {\n      const a = ((-a0 + (2 * a0 * i) / (letters.length - 1)) * PI) / 180;\n      const x = ARC_X + R * sin(a), y = ARC_Y - R * cos(a);\n      targets[ch] = { x: round(x - 1.5) + 1.5, y: round(y - 2.5) + 2.5, ids: [put(ch, x, y)] };\n    });\n  };\n  arc(\"ABCDEFGHIJKLM\", R1, 50);\n  arc(\"NOPQRSTUVWXYZ\", R2, 66);\n  [...\"1234567890\"].forEach((ch, i) => {\n    const x = 32 + (i - 4.5) * 6;\n    targets[ch] = { x: round(x - 1.5) + 1.5, y: 84.5, ids: [put(ch, x, 84.5)] };\n  });\n  word(\"YES\", 16.5, 30.5);\n  word(\"NO\", 48, 30.5);\n  word(\"GOODBYE\", 32, 108.5);\n  // A glow ring round each glyph, for when it lights.\n  for (let p = 0; p \u003c N; p++) {\n    if (ink[p]) continue;\n    const x = p % W, y = floor(p / W);\n    for (let dy = -1; dy \u003c= 1 && haloOf[p] \u003c 0; dy++)\n      for (let dx = -1; dx \u003c= 1; dx++) {\n        const xx = x + dx, yy = y + dy;\n        if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H && glyphOf[yy * W + xx] >= 0) {\n          haloOf[p] = glyphOf[yy * W + xx];\n          break;\n        }\n      }\n  }\n  // The sun by YES and the moon by NO, the board's edge, and the table.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, px = x + 0.5, py = y + 0.5;\n      const ds = hypot(px - 5, py - 30.5);\n      if (ds \u003c 2.3 || (ds > 3.4 && ds \u003c 4.6 && floor(((Math.atan2(py - 30.5, px - 5) / TAU) * 16 + 16.5) % 2) === 0)) ink[p] = 2;\n      const dm = hypot(px - 58, py - 30.5), dm2 = hypot(px - 59.6, py - 29.3);\n      if (dm \u003c 3.6 && dm2 > 3) ink[p] = 2;\n      // The edge: a thin line 2 LEDs in from a rounded rectangle.\n      const ex = max(0, abs(px - 32) - 25), ey = max(0, abs(py - 74) - 47);\n      const e = hypot(ex, ey);\n      if (abs(e - 4.5) \u003c 0.5) ink[p] = 3;\n      if (e > 6.5 || py \u003c BTOP) ink[p] = 4;\n    }\n  params.s = {\n    hue: 0, speed: 2, flick: 0, aura: 0.06, rt: 0,\n    ink, glyphOf, haloOf, glyphs, targets, lit: new Float32Array(glyphs.length),\n    // The pointer: where it is, its tilt, and the step it is on.\n    px: REST[0], py: REST[1], ang: 0, vx: 0,\n    msg: 0, steps: [], si: 0, st: 0, mv: null, said: \"\", flash: 0, wordA: 1,\n    flame: [1, 1], sway: [0, 0], light: new Float32Array(N * 3),\n  };\n  plan(params.s);\n  // The first search is a short one.\n  params.s.steps[0] = { k: \"loop\", r: 6, dur: 0.5 };\n}\n\n// The steps for one message: a search loop, then for each letter a glide\n// to it (a small loop first when a letter repeats), a hold and a fade.\nfunction plan(S) {\n  const text = MESSAGES[S.msg % MESSAGES.length], steps = [{ k: \"loop\", r: 10, dur: SEARCH }];\n  if (S.targets[text] && text.length > 1) steps.push({ k: \"go\", t: S.targets[text], say: text });\n  else {\n    let prev = null;\n    for (const ch of text) {\n      if (ch === \" \") {\n        steps.push({ k: \"go\", t: { x: REST[0], y: REST[1] - 4, ids: [] }, say: \" \" });\n        prev = null;\n        continue;\n      }\n      if (prev === ch) steps.push({ k: \"loop\", r: 5, dur: 0.7 });\n      steps.push({ k: \"go\", t: S.targets[ch], say: ch });\n      prev = ch;\n    }\n  }\n  steps.push({ k: \"hold\", dur: HOLD }, { k: \"fade\", dur: FADE });\n  S.steps = steps;\n  S.si = 0;\n  S.st = 0;\n  S.mv = null;\n  S.said = \"\";\n  S.text = text;\n  S.wordA = 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.flick = cl(k[2], 0, 1);\n  S.aura = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.rt += d;\n  // The candles keep their own time: two beats each and a slow sway. With\n  // Flicker up the flames burn taller and throw more light, and a ragged\n  // gutter can drop one to half.\n  const fk = 0.12 + 0.88 * S.flick, t = S.rt;\n  for (let i = 0; i \u003c 2; i++) {\n    const o = i * 2.3;\n    const gut = 0.5 + 0.5 * sin(t * 3.1 + o) * sin(t * 1.7 + 2 * o);\n    S.flame[i] = (1 + 0.4 * S.flick) * (1 - fk * (0.1 + 0.08 * sin(t * 13.1 + o) + 0.06 * sin(t * 7.3 + 1.3 * sin(t * 2.1 + o))) - 0.4 * S.flick * gut * gut);\n    S.sway[i] = fk * (0.8 * sin(t * 1.7 + o) + 0.5 * sin(t * 4.3 + 3 * o));\n  }\n  const x0 = S.px, y0 = S.py;\n  const step = S.steps[S.si];\n  S.st += g;\n  if (step.k === \"loop\") {\n    // A loop that starts and ends where the pointer is.\n    if (!S.mv) S.mv = { x: S.px, y: S.py };\n    const u = cl(S.st / step.dur, 0, 1), a = TAU * ss(u);\n    S.px = S.mv.x + step.r * sin(a);\n    S.py = S.mv.y - step.r * (1 - cos(a)) * 0.8;\n    if (u >= 1) nextStep(S);\n  } else if (step.k === \"go\") {\n    if (!S.mv) {\n      // A curved glide: a quadratic path bowed to one side by up to a\n      // third of its length, at about 55 LEDs a second.\n      const dx = step.t.x - S.px, dy = step.t.y - S.py, L = hypot(dx, dy);\n      const bow = (Math.random() - 0.5) * 0.6 * L;\n      S.mv = { x0: S.px, y0: S.py, cx: S.px + dx / 2 - (dy / (L || 1)) * bow, cy: S.py + dy / 2 + (dx / (L || 1)) * bow, dur: 0.3 + L / 55, said: false };\n    }\n    const m = S.mv, u = cl(S.st / m.dur, 0, 1), e = ss(u);\n    const a = (1 - e) * (1 - e), b = 2 * (1 - e) * e, c = e * e;\n    S.px = a * m.x0 + b * m.cx + c * step.t.x;\n    S.py = a * m.y0 + b * m.cy + c * step.t.y;\n    const rest = S.st - m.dur;\n    if (rest > SETTLE) for (const id of step.t.ids) S.lit[id] = max(S.lit[id], cl((rest - SETTLE) / LIGHT, 0, 1));\n    if (rest > SETTLE + LIGHT && !m.said) {\n      // The letter is read: it joins the word.\n      m.said = true;\n      S.said += step.say;\n      S.flash = 1;\n    }\n    if (rest > SETTLE + LIGHT + LINGER) nextStep(S);\n  } else if (step.k === \"hold\") {\n    if (S.st >= step.dur) nextStep(S);\n  } else if (step.k === \"fade\") {\n    // The word fades as the pointer drifts back to where it waits.\n    if (!S.mv) S.mv = { x: S.px, y: S.py };\n    const u = cl(S.st / step.dur, 0, 1), e = ss(u);\n    S.px = mix(S.mv.x, REST[0], e);\n    S.py = mix(S.mv.y, REST[1], e);\n    S.wordA = 1 - e;\n    if (u >= 1) {\n      S.msg++;\n      plan(S);\n    }\n  }\n  // Letters let go of their light once the pointer leaves them.\n  const cur = S.steps[S.si];\n  const keep = cur && cur.k === \"go\" && S.mv && S.mv.said ? cur.t.ids : null;\n  for (let i = 0; i \u003c S.lit.length; i++) if (!keep || !keep.includes(i)) S.lit[i] = max(0, S.lit[i] - g / 0.5);\n  S.flash = max(0, S.flash - g / 0.6);\n  // Tilt with the swing: the pointer leans into its sideways motion.\n  if (g > 0) {\n    const vx = (S.px - x0) / g;\n    S.vx += (vx - S.vx) * min(1, g * 8);\n    S.ang += (cl(-S.vx * 0.006, -0.38, 0.38) - S.ang) * min(1, g * 6);\n  }\n}\n\nfunction nextStep(S) {\n  S.si = min(S.si + 1, S.steps.length - 1);\n  S.st = 0;\n  S.mv = null;\n}\n\n// The pointer, in its own frame with the window centre at the origin: a\n// heart with its point up, 25 LEDs wide and 24 tall. Returns 0 outside, 1\n// for the body, 2 for its rim, 3 for the window's brass ring and 4 inside\n// the glass.\nfunction pointer(lx, ly) {\n  const rw = hypot(lx, ly);\n  if (rw \u003c 4.4) return 4;\n  if (rw \u003c 5.6) return 3;\n  const X = lx / 11, Y = (ly + 1.8) / 11;\n  const h = X * X + Y * Y - 1;\n  if (h * h * h - X * X * Y * Y * Y > 0) return 0;\n  // Within about 1.3 LEDs of the outline: the rim.\n  const X2 = lx / 9.7, Y2 = (ly + 1.3) / 9.7, h2 = X2 * X2 + Y2 * Y2 - 1;\n  return h2 * h2 * h2 - X2 * X2 * Y2 * Y2 * Y2 > 0 ? 2 : 1;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { ink, glyphOf, haloOf, lit, light } = S;\n  // The answer's colour runs from green through cyan, blue and violet to\n  // pink and never through orange, which dims to brown on a dark board.\n  const spirit = hsv(0.33 + 0.64 * S.hue, 0.85, 1);\n  // The board's lacquer turns with Hue only through the cold hues, violet\n  // at 0, so a near-black board never reads brown.\n  const tint = hsv(0.77 + 0.17 * sin(2 * PI * S.hue), 0.7, 1);\n  // Candlelight: a broad pool in the lacquer's colour, and a warm halo\n  // close round each flame, bright enough to stay orange.\n  const fl0 = S.flame[0], fl1 = S.flame[1];\n  const c0x = CANDLES[0][0], c0y = CANDLES[0][1] - 6, c1x = CANDLES[1][0], c1y = CANDLES[1][1] - 6;\n  // The answer's own light round the pointer's window, wider with Aura.\n  const glowA = 0.35 + 0.65 * litMax(lit), ar2 = (18 + 24 * S.aura) ** 2, aK = (0.36 + 0.36 * S.aura) * glowA;\n  // The pool's reach grows with Flicker.\n  const reach = 900 + 1900 * S.flick;\n  const PX = S.px, PY = S.py;\n  for (let p = 0; p \u003c N; p++) {\n    const x = (p % W) + 0.5, y = floor(p / W) + 0.5;\n    const d0 = (x - c0x) ** 2 + (y - c0y) ** 2, d1 = (x - c1x) ** 2 + (y - c1y) ** 2;\n    const o = p * 3;\n    // In steps of a 20th, a 16th and a 16th, so the glows do not cost a\n    // smooth gradient.\n    light[o] = q(fl0 / (1 + d0 / reach) + fl1 / (1 + d1 / reach), 20);\n    light[o + 1] = q((fl0 * fl0) / (1 + d0 / 45) + (fl1 * fl1) / (1 + d1 / 45), 16);\n    const da = (x - PX) ** 2 + (y - PY) ** 2;\n    light[o + 2] = q(aK / (1 + (2.2 * da) / ar2), 16);\n  }\n  // The pointer's frame.\n  const ca = cos(S.ang), sa = sin(S.ang);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, kind = ink[p], L = light[p * 3], Lw = light[p * 3 + 1], La = light[p * 3 + 2];\n      let r, g, b;\n      if (kind === 4) {\n        // The table: almost black.\n        (r = 0.01 + 0.3 * Lw), (g = 0.008 + 0.15 * Lw), (b = 0.016);\n      } else {\n        // The board: near-black lacquer, lit by the pool and the flames.\n        const k = 0.05 + 0.15 * L;\n        (r = tint[0] * k + 0.8 * Lw), (g = tint[1] * k + 0.42 * Lw), (b = tint[2] * k + 0.08 * Lw);\n        if (kind === 1 || kind === 2 || kind === 3) {\n          // Bone paint, brighter in the candlelight.\n          const v = (0.34 + 0.36 * L + 0.4 * Lw) * (kind === 3 ? 0.5 : 1);\n          (r = 0.86 * v), (g = 0.8 * v), (b = 0.72 * v);\n        }\n        const gi = glyphOf[p], hi = haloOf[p];\n        if (gi >= 0 && lit[gi] > 0) {\n          const a = lit[gi];\n          (r = mix(r, 0.3 + 0.7 * spirit[0], a)), (g = mix(g, 0.3 + 0.7 * spirit[1], a)), (b = mix(b, 0.3 + 0.7 * spirit[2], a));\n        } else if (hi >= 0 && lit[hi] > 0) {\n          const a = lit[hi] * 0.6;\n          (r += spirit[0] * a), (g += spirit[1] * a), (b += spirit[2] * a);\n        }\n        (r += spirit[0] * La), (g += spirit[1] * La), (b += spirit[2] * La);\n      }\n      // The pointer: a shadow first, then its body over the board.\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY;\n      if (abs(dx) \u003c 18 && abs(dy) \u003c 19) {\n        const lx = ca * dx + sa * dy, ly = -sa * dx + ca * dy;\n        const pk = pointer(lx, ly);\n        if (pk === 0) {\n          const sx = ca * (dx - 2) + sa * (dy - 3), sy = -sa * (dx - 2) + ca * (dy - 3);\n          if (pointer(sx, sy) > 0) (r *= 0.45), (g *= 0.45), (b *= 0.45);\n        } else if (pk === 1) {\n          // Smoked glass over the board: the letters show through dimly.\n          (r = r * 0.42 + 0.05), (g = g * 0.42 + 0.04), (b = b * 0.42 + 0.06);\n        } else if (pk === 2) {\n          const v = 0.78 + 0.22 * min(1, L);\n          (r = 0.92 * v), (g = 0.88 * v), (b = 0.8 * v);\n        } else if (pk === 3) {\n          // The window's ring takes the colour of what answers.\n          (r = mix(0.95, spirit[0], 0.5 * glowA)), (g = mix(0.85, spirit[1], 0.5 * glowA)), (b = mix(0.6, spirit[2], 0.5 * glowA));\n        } else {\n          // The glass: clear, the board a little brighter through it, tinted.\n          const a = 0.18 + 0.3 * glowA;\n          (r = r * 1.15 + spirit[0] * a), (g = g * 1.15 + spirit[1] * a), (b = b * 1.15 + spirit[2] * a);\n        }\n      }\n      display.setPixel(x, y, round(255 * cl(r, 0, 1)), round(255 * cl(g, 0, 1)), round(255 * cl(b, 0, 1)));\n    }\n  drawCandles(S, display);\n  drawWord(S, display, spirit);\n}\n\nconst litMax = (lit) => {\n  let m = 0;\n  for (let i = 0; i \u003c lit.length; i++) if (lit[i] > m) m = lit[i];\n  return m;\n};\n\n// Two candles seen from above at the board's foot: an ivory top with its\n// wick, and a flame leaning away from us that sways and stretches.\nfunction drawCandles(S, display) {\n  for (let i = 0; i \u003c 2; i++) {\n    const [cx, cy] = CANDLES[i], fl = S.flame[i], sw = S.sway[i];\n    for (let y = cy - 14; y \u003c min(H, cy + 6); y++)\n      for (let x = cx - 6; x \u003c= cx + 6; x++) {\n        if (x \u003c 0 || x >= W) continue;\n        const px = x + 0.5, py = y + 0.5, dw = hypot(px - cx, (py - cy) * 1.15);\n        let c = null;\n        if (dw \u003c 5) {\n          const v = dw \u003c 1 ? 0.25 : 0.72 + 0.28 * fl - 0.08 * (dw / 5);\n          c = dw \u003c 1 ? [0.2, 0.15, 0.12] : [v, v * 0.93, v * 0.8];\n        }\n        const fh = 9 + 2.5 * fl, fy = cy - 1 - py, fx = px - cx - sw * (fy / fh);\n        if (fy > -0.5 && fy \u003c fh) {\n          const u = fy / fh, w = (u \u003c 0.25 ? 2.4 * sqrt(u / 0.25) : 2.4 * (1 - (u - 0.25) / 0.75) ** 0.8) * (0.85 + 0.15 * fl);\n          if (abs(fx) \u003c w + 0.25) {\n            if (abs(fx) \u003c w * 0.45 && u \u003c 0.6) c = [1, 0.97, 0.78];\n            else if (abs(fx) \u003c w * 0.8 && u \u003c 0.85) c = [1, 0.78, 0.2];\n            else c = [1, 0.5, 0.06];\n          }\n        }\n        if (c) display.setPixel(x, y, round(255 * c[0]), round(255 * c[1]), round(255 * c[2]));\n      }\n  }\n}\n\n// The word spelled so far, above the board: twice size for five letters\n// or fewer, the newest letter flashing white as it arrives, every letter\n// glowing two LEDs round in the answer's colour.\nconst WH = 20, wmask = new Uint8Array(W * WH);\nfunction drawWord(S, display, spirit) {\n  const text = S.text, said = S.said, sc = text.length \u003c= 5 ? 2 : 1, pitch = 6 * sc;\n  const width = text.length * pitch - sc, x0 = round(32 - width / 2), y0 = sc === 2 ? 3 : 7;\n  const a = S.wordA;\n  if (a \u003c= 0 || !said.length) return;\n  wmask.fill(0);\n  for (let i = 0; i \u003c said.length; i++) {\n    const rows = F5[said[i]];\n    if (!rows) continue;\n    for (let ry = 0; ry \u003c 7 * sc; ry++)\n      for (let rx = 0; rx \u003c 5 * sc; rx++) {\n        if (!((rows[floor(ry / sc)] >> (4 - floor(rx / sc))) & 1)) continue;\n        const x = x0 + i * pitch + rx, y = y0 + ry;\n        if (x >= 0 && x \u003c W) wmask[y * W + x] = i === said.length - 1 ? 2 : 1;\n      }\n  }\n  const fr = S.flash;\n  for (let y = 0; y \u003c WH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const m = wmask[y * W + x];\n      let r, g, b;\n      if (m) {\n        const f = m === 2 ? fr : 0;\n        (r = mix(spirit[0], 1, f)), (g = mix(spirit[1], 1, f)), (b = mix(spirit[2], 1, f));\n      } else {\n        // The glow: the nearest letter LED within two.\n        let best = 9;\n        for (let dy = -2; dy \u003c= 2; dy++)\n          for (let dx = -2; dx \u003c= 2; dx++) {\n            const xx = x + dx, yy = y + dy;\n            if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c WH && wmask[yy * W + xx]) best = min(best, dx * dx + dy * dy);\n          }\n        if (best > 5) continue;\n        const k = best \u003c= 2 ? 0.34 : 0.14;\n        (r = 0.01 + spirit[0] * k), (g = 0.008 + spirit[1] * k), (b = 0.016 + spirit[2] * k);\n      }\n      display.setPixel(x, y, round(255 * cl(r * a, 0, 1)), round(255 * cl(g * a, 0, 1)), round(255 * cl(b * a, 0, 1)));\n    }\n}\n","web-tremor":"// ===== Patternflow pattern =====\n// Title:   Web Tremor\n// Family:  halloween\n// Idea:    A pale moth blunders into a tall orb web under the moon and every time it struggles a pulse of light runs out from it along the silk, fast down the radial threads and slower round the spiral, until the spider at the hub feels it, turns, runs out, wraps the moth into a white bundle and walks back, the web sagging and quivering under them, and then another moth comes.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 47\n// Round:   47\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Struggle=0..1, Sag=0..1\n//\n// Knob 1: Hue. The colour of the pulses: at 0 toxic green, at 0.25 icy cyan, at 0.5 moonlight white, at 0.75 violet, each held for 0.06 either side of its point and blending into the next, and 1 is green again. The silk, the moon, the moth and the spider keep their colours.\n// Knob 2: Speed. At 2 one hunt takes about 13 seconds: the moth flutters in for 2, struggles for 3 to 4 while the spider feels it, turns and runs out, is wrapped for 2.8, and the spider walks back for 2 and rests for 1. A pulse crosses the web in about 2 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Struggle. How hard the moth fights: at 0 it heaves in twos about every 1.3 seconds and a pulse has lost half its light 52 LEDs out; at 1 it heaves in threes every 0.6 seconds, the pulses start a quarter brighter and keep half their light to 83 LEDs, and the web round the moth shakes three times as hard.\n// Knob 4: Sag. How slack the web hangs: at 0.06 the hub sits 1.4 LEDs low, 3 with the spider on it, and the moth pulls its crossing about 3 down; at 1 the web bellies 7 LEDs at the hub, 11 with the spider, and the moth drags its crossing about 9 down. The frame never moves.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, atan2, round, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// Pulse colours round K1: toxic green, icy cyan, moonlight white, violet.\nconst PULSE = [[0.35, 1, 0.12], [0.2, 0.9, 1], [0.88, 0.94, 1], [0.8, 0.3, 1]];\n// Silk in moonlight, the moon, the moth, the spider (a cold violet grey\n// with green eyes), the wrapping silk.\nconst SILK = [0.56, 0.6, 0.92], MOON = [0.86, 0.9, 1], WING = [0.88, 0.85, 0.98], MBODY = [1, 0.96, 0.86];\nconst SBODY = [0.42, 0.32, 0.66], SLEG = [0.58, 0.54, 0.78], SEYE = [0.4, 1, 0.3], WRAP = [0.97, 0.97, 1];\nconst SILK_V = 0.34;\n// The web: hub, sixteen radials out to a frame just inside the panel, and\n// the sticky spiral as rings 4.6 LEDs apart; a ring stops where a radial is\n// too short for it, so the long upper and lower parts have more turns.\nconst HX = 32, HY = 63, K = 16, HUBR = 3, R0 = 7.5, GAP = 4.6;\nconst BOX = [3, 6, 60, 122];\nconst MOONX = 46, MOONY = 19, MOONR = 10;\n// A pulse runs along the graph of the web at V LEDs a second, the spiral\n// costing SPIRAL times its length (vibration carries best down the\n// radials, which are stiffer), with a sharp front and a short tail.\nconst V = 44, SPIRAL = 1.8, FRONT = 3, TAIL = 9;\n// Story seconds (one a second at Speed 2): the moth's flight in, the\n// spider's turn, the wrap, the rest at the hub; and the spider's pace out\n// and back, in LEDs a second.\nconst FLY = 2, TURN = 0.5, WRAPT = 2.8, REST = 1;\nconst RUN = 30, BACK = 20;\n\nfunction buildWeb(S) {\n  const nx = [], ny = [], nu = [], edges = [], th = [], R = [];\n  const node = (x, y, u) => (nx.push(x), ny.push(y), nu.push(u), nx.length - 1);\n  const hub = node(HX, HY, 0);\n  for (let k = 0; k \u003c K; k++) {\n    const a = ((k + 0.5) * TAU) / K + rnd(-0.07, 0.07), c = cos(a), s = sin(a);\n    // Out to the box, a little short of it.\n    let L = 1e9;\n    if (c > 0) L = min(L, (BOX[2] - HX) / c);\n    if (c \u003c 0) L = min(L, (BOX[0] - HX) / c);\n    if (s > 0) L = min(L, (BOX[3] - HY) / s);\n    if (s \u003c 0) L = min(L, (BOX[1] - HY) / s);\n    th.push(a);\n    R.push(L * 0.97);\n  }\n  // Rings: the hub ring, then the sticky rings while any radial reaches.\n  const rings = [HUBR];\n  for (let r = R0; r \u003c max(...R) - 3; r += GAP) rings.push(r);\n  const id = [];\n  for (let k = 0; k \u003c K; k++) {\n    id.push([]);\n    for (let j = 0; j \u003c rings.length; j++) {\n      const r = rings[j];\n      id[k].push(r \u003c= R[k] - 2.5 ? node(HX + r * cos(th[k]), HY + r * sin(th[k]), r / R[k]) : -1);\n    }\n    id[k].frame = node(HX + R[k] * cos(th[k]), HY + R[k] * sin(th[k]), 1);\n  }\n  // Edges: 0 radial, 1 spiral, 2 frame.\n  for (let k = 0; k \u003c K; k++) {\n    let prev = hub;\n    for (let j = 0; j \u003c rings.length; j++) if (id[k][j] >= 0) edges.push([prev, id[k][j], 0]), (prev = id[k][j]);\n    edges.push([prev, id[k].frame, 0]);\n    const k2 = (k + 1) % K;\n    for (let j = 0; j \u003c rings.length; j++) if (id[k][j] >= 0 && id[k2][j] >= 0) edges.push([id[k][j], id[k2][j], 1]);\n    edges.push([id[k].frame, id[k2].frame, 2]);\n  }\n  // Moorings from the frame to the panel's edges, out of the graph.\n  const moor = [];\n  for (const [k, ex, ey] of [[1, 63, 127], [6, 0, 127], [9, 0, 0], [14, 63, 0]]) moor.push([id[k].frame, ex, ey]);\n  const n = nx.length, cost = edges.map(([a, b, t]) => sqrt((nx[a] - nx[b]) ** 2 + (ny[a] - ny[b]) ** 2) * (t === 1 ? SPIRAL : t === 2 ? 1.3 : 1));\n  const adj = Array.from({ length: n }, () => []);\n  edges.forEach(([a, b], e) => (adj[a].push([b, e]), adj[b].push([a, e])));\n  Object.assign(S, { nx, ny, nu, edges, cost, adj, id, rings, th, R, hub, moor, n, px: new Float32Array(n), py: new Float32Array(n) });\n}\n\n// Graph distance of every node from a source node, by Dijkstra.\nfunction dists(S, src) {\n  const d = new Float32Array(S.n).fill(1e9), done = new Uint8Array(S.n);\n  d[src] = 0;\n  for (let it = 0; it \u003c S.n; it++) {\n    let u = -1, best = 1e9;\n    for (let i = 0; i \u003c S.n; i++) if (!done[i] && d[i] \u003c best) (best = d[i]), (u = i);\n    if (u \u003c 0) break;\n    done[u] = 1;\n    for (const [w, e] of S.adj[u]) if (d[u] + S.cost[e] \u003c d[w]) d[w] = d[u] + S.cost[e];\n  }\n  return d;\n}\n\nexport function setup(params) {\n  const S = {\n    hue: 0, speed: 2, fight: 0, sag: 0.06, t: 0, rt: 0,\n    rgb: new Float32Array(N * 3), P: new Float32Array(N), B: new Float32Array(N), T: new Float32Array(N), bg: new Float32Array(N * 3),\n    pulses: [], kicks: [], bundles: [],\n    phase: \"fly\", pt: FLY * 0.45, moth: null, sp: { x: HX, y: HY + 1, ox: HX, oy: HY, hd: PI / 2, gait: 0, s: 0, state: \"wait\", st: 0, feel: 0, heard: 0 },\n  };\n  buildWeb(S);\n  // The sky: violet at the top to blue-black below, in steps of a 64th,\n  // and the moon's halo in steps of an eighth.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, v = 1 - y / H, d = sqrt((x + 0.5 - MOONX) ** 2 + (y + 0.5 - MOONY) ** 2);\n      const halo = q(cl(1 - (d - MOONR) / 22, 0, 1) ** 2, 8);\n      S.bg[i * 3] = q(0.035 + 0.045 * v, 64) + 0.12 * halo;\n      S.bg[i * 3 + 1] = q(0.008 + 0.006 * v, 64) + 0.1 * halo;\n      S.bg[i * 3 + 2] = q(0.075 + 0.05 * v, 64) + 0.2 * halo;\n    }\n  params.s = S;\n  newMoth(S);\n  web(S);\n}\n\n// A new moth: it picks a crossing of the spiral and a radial away from the\n// hub, not on or next to a radial with a bundle already hanging, and flies\n// in from the side it is nearer.\nfunction newMoth(S) {\n  let k, j, node, tries = 0;\n  do {\n    k = floor(Math.random() * K);\n    j = 5 + floor(Math.random() * (S.rings.length - 5));\n    node = S.id[k][j];\n    tries++;\n  } while ((node \u003c 0 || S.bundles.some((b) => b.node === node || abs(b.k - k) % (K - 1) \u003c 2)) && tries \u003c 60);\n  if (node \u003c 0) (k = 4), (j = 4), (node = S.id[4][4]);\n  const left = S.nx[node] > HX ? 0 : 1;\n  const d = dists(S, node);\n  S.moth = { k, j, node, d, dmax: max(...d), x0: left ? -8 : W + 8, y0: rnd(20, 108), x: 0, y: 0, flap: 0, wrap: 0, next: 0, heave: 0 };\n}\n\n// A struggle: a pulse from the moth along the silk, and a kick to the web.\nfunction heave(S, amp) {\n  S.pulses.push({ t0: S.t, a: amp, d: S.moth.d });\n  S.kicks.push({ t0: S.t, a: amp, x: S.moth.x, y: S.moth.y });\n  S.moth.heave = 0.3;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0] || 0;\n  S.speed = cl(k[1], 0.2, 3);\n  S.fight = cl(k[2], 0, 1);\n  S.sag = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2, M = S.moth, sp = S.sp;\n  S.t += g;\n  S.rt += d;\n  S.pt += g;\n  M.heave = max(0, M.heave - g);\n  M.flap += g * (S.phase === \"fly\" ? 60 : M.heave > 0 ? 75 : 8);\n  // The moth heaves in bouts, two or three heaves a fifth of a second\n  // apart, then a rest; Struggle shortens the rest and adds the third.\n  const every = mix(1.3, 0.6, S.fight), amp = mix(1.1, 1.375, S.fight);\n  if (S.phase === \"fly\") {\n    const u = cl(S.pt / FLY, 0, 1), e = u * u * (3 - 2 * u);\n    M.x = mix(M.x0, S.px[M.node], e) + 5 * sin(u * PI * 3) * (1 - u);\n    M.y = mix(M.y0, S.py[M.node], e) + 4 * sin(u * PI * 5) * (1 - u) + 1.5 * sin(S.t * 9) * (1 - u);\n    if (u >= 1) {\n      S.phase = \"caught\";\n      S.pt = 0;\n      heave(S, 1.5);\n      M.next = 0.2;\n      M.bout = 3;\n      sp.state = \"wait\";\n      sp.heard = 0;\n    }\n  } else {\n    M.x = S.px[M.node];\n    M.y = S.py[M.node];\n  }\n  if (S.phase === \"caught\" || S.phase === \"wrap\") {\n    M.next -= g;\n    if (M.next \u003c= 0) {\n      // While it is being wrapped it fights less and less.\n      heave(S, amp * (S.phase === \"wrap\" ? 0.7 * (1 - M.wrap) : rnd(0.8, 1)));\n      if (--M.bout > 0) M.next = 0.2;\n      else {\n        M.next = every * rnd(0.8, 1.2) * (S.phase === \"wrap\" ? 1.5 : 1);\n        M.bout = 2 + (Math.random() \u003c S.fight ? 1 : 0);\n      }\n    }\n  }\n  // The spider: at the hub until the first pulse reaches it, then it turns\n  // to the moth's radial, waits for more to be sure (six in all, or four\n  // seconds), then runs out along the radial to wrap the moth and walk back.\n  const hubT = M.d[S.hub] / V;\n  const path = [S.hub];\n  for (let j = 0; j \u003c= M.j; j++) if (S.id[M.k][j] >= 0) path.push(S.id[M.k][j]);\n  const plen = [0];\n  for (let i = 1; i \u003c path.length; i++) plen.push(plen[i - 1] + sqrt((S.px[path[i]] - S.px[path[i - 1]]) ** 2 + (S.py[path[i]] - S.py[path[i - 1]]) ** 2));\n  const total = plen[plen.length - 1];\n  const at = (s) => {\n    let i = 1;\n    while (i \u003c path.length - 1 && plen[i] \u003c s) i++;\n    const f = cl((s - plen[i - 1]) / (plen[i] - plen[i - 1] || 1), 0, 1);\n    return [mix(S.px[path[i - 1]], S.px[path[i]], f), mix(S.py[path[i - 1]], S.py[path[i]], f), atan2(S.py[path[i]] - S.py[path[i - 1]], S.px[path[i]] - S.px[path[i - 1]])];\n  };\n  sp.st += g;\n  sp.feel = max(0, sp.feel - g * 2);\n  // Count the pulses that have reached the hub.\n  let heard = 0;\n  for (const p of S.pulses) if (p.d === M.d && S.t - p.t0 >= hubT) heard++;\n  if (heard > sp.heard) (sp.feel = 1), (sp.heard = heard);\n  let moving = 0;\n  if (sp.state === \"wait\") {\n    sp.s = 0;\n    turnTo(sp, PI / 2, g);\n    if (S.phase === \"caught\" && heard >= 1) (sp.state = \"turn\"), (sp.st = 0);\n  } else if (sp.state === \"turn\") {\n    turnTo(sp, S.th[M.k], g * 1.6);\n    if (sp.st > TURN && (heard >= 6 || sp.st > 4)) (sp.state = \"run\"), (sp.st = 0);\n  } else if (sp.state === \"run\") {\n    sp.s = min(total - 3, sp.s + RUN * g);\n    moving = RUN * g;\n    if (sp.s >= total - 3) {\n      sp.state = \"wrap\";\n      sp.st = 0;\n      S.phase = \"wrap\";\n      S.pt = 0;\n      sp.orb = S.th[M.k] + PI;\n    }\n  } else if (sp.state === \"wrap\") {\n    // Round and round the moth, turning it in silk.\n    sp.orb += g * 5.5;\n    M.wrap = cl(S.pt / WRAPT, 0, 1);\n    moving = g * 18;\n    if (M.wrap >= 1) {\n      S.bundles.push({ node: M.node, k: M.k, life: 1 });\n      if (S.bundles.length > 2) S.bundles[0].fade = 1;\n      sp.state = \"back\";\n      sp.st = 0;\n      S.phase = \"rest\";\n      S.pt = 0;\n      sp.s = total - 3;\n    }\n  } else if (sp.state === \"back\") {\n    sp.s = max(0, sp.s - BACK * g);\n    moving = BACK * g;\n    if (sp.s \u003c= 0) (sp.state = \"home\"), (sp.st = 0);\n  } else if (sp.state === \"home\") {\n    turnTo(sp, PI / 2, g * 1.2);\n    if (sp.st > REST) {\n      sp.state = \"wait\";\n      newMoth(S);\n      S.phase = \"fly\";\n      S.pt = 0;\n      S.pulses.length = 0;\n    }\n  }\n  if (sp.state === \"wrap\") {\n    const mx = S.px[M.node], my = S.py[M.node];\n    sp.x = mx + 4 * cos(sp.orb);\n    sp.y = my + 4 * sin(sp.orb);\n    sp.hd = sp.orb + PI;\n  } else {\n    const [x, y, a] = at(sp.s);\n    sp.x = x;\n    sp.y = y + (sp.s === 0 ? 1 : 0);\n    if (sp.state === \"run\") turnTo(sp, a, g * 3);\n    if (sp.state === \"back\") turnTo(sp, a + PI, g * 3);\n  }\n  sp.gait += moving * 0.9;\n  for (const b of S.bundles) if (b.fade) b.life -= g / 2.5;\n  S.bundles = S.bundles.filter((b) => b.life > 0);\n  S.pulses = S.pulses.filter((p) => V * (S.t - p.t0) \u003c M.dmax + 4 * TAIL);\n  S.kicks = S.kicks.filter((c) => S.t - c.t0 \u003c 2.5);\n  web(S);\n}\n\nfunction turnTo(sp, a, rate) {\n  const dh = ((a - sp.hd + 3 * PI) % TAU) - PI;\n  sp.hd += dh * min(1, rate * 6);\n}\n\n// Where every node of the web hangs now: the web's own belly, deepest at\n// the hub and nothing at the frame; the pull of the moth, the spider and\n// the bundles where they hang; and the quiver each heave sets going.\nfunction web(S) {\n  const G = 1 + 6 * S.sag, load = 3 + 5 * S.sag, M = S.moth, sp = S.sp;\n  const loads = [];\n  if (S.phase !== \"fly\") loads.push([S.nx[M.node], S.ny[M.node], load]);\n  loads.push([sp.ox, sp.oy, load * 0.5]);\n  for (const b of S.bundles) loads.push([S.nx[b.node], S.ny[b.node], load * 0.6 * b.life]);\n  let qy = 0;\n  const kx = [], ky = [], ka = [];\n  for (const c of S.kicks) {\n    const tau = S.t - c.t0, a = c.a * mix(1, 3, S.fight) * exp(-tau / 0.45) * sin(TAU * 5 * tau);\n    qy += 0.6 * a;\n    kx.push(c.x), ky.push(c.y), ka.push(a);\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const x = S.nx[i], y = S.ny[i], u = S.nu[i], taper = 1 - u * u;\n    let dy = G, dx = 0;\n    for (const [lx, ly, w] of loads) dy += w * exp(-((x - lx) ** 2 + (y - ly) ** 2) / (2 * 14 * 14));\n    let jig = qy;\n    for (let c = 0; c \u003c kx.length; c++) {\n      const f = exp(-((x - kx[c]) ** 2 + (y - ky[c]) ** 2) / (2 * 16 * 16));\n      jig += 1.4 * ka[c] * f;\n      dx += 0.8 * ka[c] * f * sin(i * 2.3);\n    }\n    S.px[i] = x + dx * taper;\n    S.py[i] = y + (dy + jig) * taper;\n  }\n  // The spider's own weight follows it out along the radial.\n  sp.ox = sp.x;\n  sp.oy = sp.y;\n}\n\n// The pulse colour for K1, holding near each of the four stops.\nfunction pulseColour(h) {\n  h = (h - floor(h)) * 4;\n  const i = floor(h) % 4, j = (i + 1) % 4, f = h - floor(h), g = cl((f - 0.25) / 0.5, 0, 1), s = g * g * (3 - 2 * g);\n  return [0, 1, 2].map((c) => mix(PULSE[i][c], PULSE[j][c], s));\n}\n\n// The light a pulse puts on a point d along the silk from the moth: a\n// sharp front running out at V, a short tail behind it, fading with the\n// distance it has run.\nfunction glow(S, d) {\n  const fr = S.fr, am = S.am;\n  let v = 0;\n  for (let i = 0; i \u003c fr.length; i++) {\n    const x = fr[i] - d;\n    if (x \u003c -FRONT * 3 || x > TAIL * 4) continue;\n    v += am[i] * (x \u003c 0 ? exp(-((x / FRONT) ** 2)) : exp(-x / TAIL));\n  }\n  return v > 0 ? v * exp(-d / S.reach) : 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, P, bg } = S;\n  rgb.set(bg);\n  P.fill(0);\n  // The moon: pale, with darker seas in steps.\n  for (let y = MOONY - MOONR - 1; y \u003c= MOONY + MOONR + 1; y++)\n    for (let x = MOONX - MOONR - 1; x \u003c= MOONX + MOONR + 1; x++) {\n      if (x \u003c 0 || x >= W || y \u003c 0) continue;\n      const dx = x + 0.5 - MOONX, dy = y + 0.5 - MOONY, r = sqrt(dx * dx + dy * dy);\n      if (r > MOONR) continue;\n      const sea = exp(-((dx + 3) ** 2 + (dy + 2) ** 2) / 14) * 0.5 + exp(-((dx - 4) ** 2 + (dy - 4) ** 2) / 8) * 0.4 + exp(-((dx - 2) ** 2 + (dy + 5) ** 2) / 5) * 0.3;\n      const v = q(0.95 - 0.35 * sea - 0.12 * (r / MOONR) ** 4, 10), o = (y * W + x) * 3;\n      rgb[o] = MOON[0] * v;\n      rgb[o + 1] = MOON[1] * v;\n      rgb[o + 2] = MOON[2] * v;\n    }\n  // Silk: each thread from node to node, and on it the pulses, with the\n  // distance along the silk from the moth taken the short way round.\n  const pc = pulseColour(S.hue), M = S.moth, D = M.d;\n  // Where each pulse's front has got to, once a frame.\n  S.fr = S.pulses.map((p) => V * (S.t - p.t0));\n  S.am = S.pulses.map((p) => p.a);\n  S.reach = mix(75, 120, S.fight);\n  const plot = (x, y, base, pv) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const i = y * W + x, o = i * 3;\n    // Over the moon the silk is a dark line against it.\n    const onMoon = (x + 0.5 - MOONX) ** 2 + (y + 0.5 - MOONY) ** 2 \u003c MOONR * MOONR;\n    if (onMoon) (rgb[o] *= 0.55), (rgb[o + 1] *= 0.55), (rgb[o + 2] *= 0.6);\n    else (rgb[o] = max(rgb[o], SILK[0] * base)), (rgb[o + 1] = max(rgb[o + 1], SILK[1] * base)), (rgb[o + 2] = max(rgb[o + 2], SILK[2] * base));\n    if (pv > P[i]) P[i] = pv;\n  };\n  const seg = (a, b, ca, cb, cost, base) => {\n    const x0 = S.px[a], y0 = S.py[a], x1 = S.px[b], y1 = S.py[b];\n    const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n    for (let s = 0; s \u003c= n; s++) {\n      const t = n ? s / n : 0, dd = min(ca + t * cost, cb + (1 - t) * cost);\n      plot(floor(mix(x0, x1, t) + 0.5), floor(mix(y0, y1, t) + 0.5), base, glow(S, dd));\n    }\n  };\n  S.edges.forEach(([a, b, t], e) => seg(a, b, D[a], D[b], S.cost[e], t === 1 ? SILK_V * 0.85 : SILK_V));\n  for (const [a, ex, ey] of S.moor) {\n    const x0 = S.px[a], y0 = S.py[a], n = Math.ceil(max(abs(ex - x0), abs(ey - y0)));\n    for (let s = 0; s \u003c= n; s++) plot(floor(mix(x0, ex, s / n) + 0.5), floor(mix(y0, ey, s / n) + 0.5), SILK_V * 0.7, 0);\n  }\n  // The pulse on the silk, and a soft glow round it so it reads from\n  // across a room: a blur two LEDs wide, across then down.\n  const B = S.B, T = S.T;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let s = 3 * P[i];\n      if (x > 0) s += 2 * P[i - 1];\n      if (x > 1) s += P[i - 2];\n      if (x \u003c W - 1) s += 2 * P[i + 1];\n      if (x \u003c W - 2) s += P[i + 2];\n      T[i] = s / 9;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      let s = 3 * T[i];\n      if (y > 0) s += 2 * T[i - W];\n      if (y > 1) s += T[i - 2 * W];\n      if (y \u003c H - 1) s += 2 * T[i + W];\n      if (y \u003c H - 2) s += T[i + 2 * W];\n      B[i] = s / 9;\n    }\n  for (let i = 0; i \u003c N; i++) {\n    const p = P[i], b = B[i], o = i * 3;\n    if (p \u003c= 0.02 && b \u003c= 0.02) continue;\n    const v = max(min(1.2, p), q(min(0.6, 1.4 * b), 6));\n    rgb[o] = max(rgb[o], pc[0] * v);\n    rgb[o + 1] = max(rgb[o + 1], pc[1] * v);\n    rgb[o + 2] = max(rgb[o + 2], pc[2] * v);\n  }\n  // Each heave flashes round the moth, the light the pulses start from.\n  if (M.heave > 0 && S.phase !== \"fly\") {\n    const a = M.heave / 0.3, R = 9;\n    for (let y = floor(M.y - R); y \u003c= M.y + R; y++)\n      for (let x = floor(M.x - R); x \u003c= M.x + R; x++) {\n        const r = sqrt((x + 0.5 - M.x) ** 2 + (y + 0.5 - M.y) ** 2) / R;\n        if (r \u003c 1) put(S, x, y, pc, q(a * 0.7 * (1 - r) ** 1.5, 6));\n      }\n  }\n  // Bundles of silk left in the web.\n  for (const b of S.bundles) drawBundle(S, S.px[b.node], S.py[b.node], 1, b.life);\n  // The moth: wings flapping as it flies, heaving in the web, folding away\n  // into the bundle as it is wrapped.\n  drawMoth(S, M);\n  drawSpider(S, S.sp);\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, round(255 * cl(rgb[o], 0, 1)), round(255 * cl(rgb[o + 1], 0, 1)), round(255 * cl(rgb[o + 2], 0, 1)));\n}\n\nfunction put(S, x, y, c, a) {\n  x = floor(x);\n  y = floor(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  S.rgb[o] = mix(S.rgb[o], c[0], a);\n  S.rgb[o + 1] = mix(S.rgb[o + 1], c[1], a);\n  S.rgb[o + 2] = mix(S.rgb[o + 2], c[2], a);\n}\n\nfunction drawBundle(S, cx, cy, size, life) {\n  for (let y = floor(cy - 6); y \u003c= cy + 6; y++)\n    for (let x = floor(cx - 4); x \u003c= cx + 4; x++) {\n      const u = (x + 0.5 - cx) / (3 * size), v = (y + 0.5 - cy) / (4.6 * size), r = u * u + v * v;\n      if (r > 1) continue;\n      // Wound round: bands of brighter and dimmer silk across it.\n      const band = ((y + x * 0.6 + 40) % 2.4) \u003c 1.2 ? 1 : 0.78;\n      put(S, x, y, WRAP.map((c) => c * band), min(1, life * 1.5));\n    }\n}\n\nfunction drawMoth(S, M) {\n  const wrap = M.wrap, open = 1 - wrap;\n  if (wrap > 0) drawBundle(S, M.x, M.y, 0.25 + 0.75 * wrap, 1);\n  if (open \u003c= 0.05) return;\n  // Wing span: the flap swings it between full and a sliver.\n  const f = 0.35 + 0.65 * abs(cos(M.flap)), span = 7 * f * open;\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let y = -5; y \u003c= 5; y++)\n      for (let x = 1; x \u003c= 8; x++) {\n        const wx = x / max(0.6, span), wy = y / 5;\n        // Forewing above, smaller hindwing below.\n        const fore = wy \u003c 0.2 && wx \u003c 1 && wy > -1 + 0.6 * wx;\n        const hind = wy >= 0.2 && wx \u003c 0.75 && wy \u003c 0.95 - 0.5 * wx;\n        if (!fore && !hind) continue;\n        // A grey eye-spot on each forewing, a darker leading edge.\n        const spot = fore && abs(wx - 0.5) \u003c 0.17 && abs(wy + 0.35) \u003c 0.15;\n        const shade = spot ? 0.58 : hind ? 0.75 : x === 1 || wy \u003c -0.6 ? 0.85 : 1;\n        put(S, M.x + side * (x - 0.5), M.y + y, WING.map((c) => c * shade * (0.6 + 0.4 * open)), 1);\n      }\n  for (let y = -4; y \u003c= 4; y++) put(S, M.x, M.y + y, MBODY, 1);\n  put(S, M.x - 1, M.y - 5, MBODY, 0.7);\n  put(S, M.x + 1, M.y - 5, MBODY, 0.7);\n}\n\n// The spider: abdomen behind, head in front, eight legs that step as it\n// walks and twitch when a pulse reaches it.\nfunction drawSpider(S, sp) {\n  const fx = cos(sp.hd), fy = sin(sp.hd), sx = -fy, sy = fx, x = sp.x, y = sp.y;\n  const line = (x0, y0, x1, y1, c) => {\n    const n = Math.ceil(max(abs(x1 - x0), abs(y1 - y0)));\n    for (let s = 0; s \u003c= n; s++) put(S, mix(x0, x1, s / (n || 1)) + 0.5, mix(y0, y1, s / (n || 1)) + 0.5, c, 1);\n  };\n  const tw = 0.25 * sp.feel * sin(S.rt * 40);\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let k = 0; k \u003c 4; k++) {\n      const a = [0.5, 1.1, 1.9, 2.5][k] + 0.25 * sin(sp.gait + k * 1.7 + (side > 0 ? PI : 0)) + tw;\n      const ca = cos(a), sa = side * sin(a), r = 3.2;\n      const kx = x + (ca * fx + sa * sx) * r, ky = y + (ca * fy + sa * sy) * r;\n      // The lower leg bends forward for the front pair, back for the rear.\n      const ex = kx + (ca * fx + sa * sx) * 2.8 + (k \u003c 2 ? fx : -fx) * 1.2, ey = ky + (ca * fy + sa * sy) * 2.8 + (k \u003c 2 ? fy : -fy) * 1.2;\n      line(x, y, kx, ky, SLEG);\n      line(kx, ky, ex, ey, SLEG);\n    }\n  const blob = (cx, cy, ra, rb, c) => {\n    for (let yy = floor(cy - 4); yy \u003c= cy + 4; yy++)\n      for (let xx = floor(cx - 4); xx \u003c= cx + 4; xx++) {\n        const px = xx + 0.5 - cx, py = yy + 0.5 - cy, u = px * fx + py * fy, v = px * sx + py * sy;\n        if ((u / ra) ** 2 + (v / rb) ** 2 \u003c= 1) put(S, xx, yy, c, 1);\n      }\n  };\n  blob(x - 2.2 * fx, y - 2.2 * fy, 2.8, 2.2, SBODY);\n  blob(x + 0.8 * fx, y + 0.8 * fy, 1.5, 1.3, SBODY.map((c) => c * 1.2));\n  put(S, x + 1.6 * fx + 0.7 * sx, y + 1.6 * fy + 0.7 * sy, SEYE, 1);\n  put(S, x + 1.6 * fx - 0.7 * sx, y + 1.6 * fy - 0.7 * sy, SEYE, 1);\n}\n","belfry":"// ===== Patternflow pattern =====\n// Title:   Belfry\n// Family:  halloween\n// Idea:    A black stone bell tower fills the panel against a stormy purple sky and a low orange moon, its bronze bell swinging like a real pendulum while the clapper lags inside and strikes the rim near each end of the swing, each strike sending out a ring of sound and a burst of bats to wheel round the spire, as the green clock creeps to midnight and the bell tolls twelve.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bats=8..40, Storm=0..1\n//\n// Knob 1: Hue. The moon, the lit windows and the moonlit cloud edges, with the clock and the middle window a quarter of the wheel on; stone, sky and bell stay. At 0 an orange moon and a toxic green clock, at 0.25 a green moon and a sky blue clock, at 0.5 a blue moon and a magenta clock, at 0.75 a magenta moon and an orange clock.\n// Knob 2: Speed. At 2 the bell swings there and back in 1.8 s and strikes every 0.93 s, the minute hand goes round in 30 s so the hour tolls every 30 s, and a bat beats its wings 6 to 9 times a second and wheels 7 to 14 s before it flies home; at 0.2 all ten times slower, at 3 half as fast again.\n// Knob 3: Bats. How many bats each strike scares out of the belfry and the spire's louvre: 8 at the start, so midnight puts 96 more in the air, 16 at a quarter, 24 at half, 32 at three quarters, 40 at the end. Four times that many stay out between the hours, at most 300 at once.\n// Knob 4: Storm. Cloud, wind and lightning. At 0.06 a fifth of the sky is cloud drifting right at 4 LEDs a second and lightning forks down from the top about every 28 s, the first at 5 s; at 0.5 half the sky is cloud moving at 13, it rains, and lightning comes every 15 s; at 1 cloud covers nine tenths of the sky at 23 a second, the rain is heavy and lightning comes every 2 s.\n// Buttons: K1 tap sets the hands to two minutes to twelve and the bell tolls midnight at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * Math.random();\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n\nconst put = (buf, o, r, g, b) => {\n  buf[o] = r;\n  buf[o + 1] = g;\n  buf[o + 2] = b;\n};\n\n// The tower, laid out once.\n// Its axis is column TX; the moon sits low behind its right shoulder.\nconst TX = 25, AX = TX + 0.5;\nconst ARCH_Y = 47.5, ARCH_R = 10.5, SILL = 62;\nconst PX = AX, PY = 40.5;\nconst CLX = AX, CLY = 76.5, CLR = 7.5;\nconst MX = 46, MY = 84, MR = 21;\n// Mask codes. BACK is the sky seen through the belfry's back arch.\nconst SKY = 0, STONE = 1, INSIDE = 2, BACK = 3, FACE = 4, WIN = 5, BEAM = 6;\nconst MASK = new Uint8Array(N), RIM = new Uint8Array(N), WID = new Int8Array(N).fill(-1);\n// Half the tower's width by row, [last row, half]: finial, spire (-2, a\n// taper), eave, belfry, ledge, clock stage, ledge, shaft, buttresses.\nconst ROWS = [[0, -1], [2, 0], [4, 1], [29, -2], [30, 15], [32, 16], [63, 14], [66, 15], [86, 13], [88, 14], [109, 12], [113, 13], [H, 15]];\nconst half = (y) => {\n  const r = ROWS.find((q) => y \u003c= q[0])[1];\n  return r === -2 ? round(1 + ((y - 5) * 13) / 24) : r;\n};\nconst groundY = (x) => 121 + round(1.6 * sin(x / 7 + 1) + 0.8 * sin(x / 3.1));\n// Gravestones on the ground line: [left column, pixel art].\nconst GRAVES = [\n  [41, [\".xxx.\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\", \"xxxxx\"]],\n  [49, [\"..x..\", \"..x..\", \"xxxxx\", \"..x..\", \"..x..\", \"..x..\", \"..x..\", \".xxx.\"]],\n  [57, [\".xx.\", \"xxxx\", \"xxxx\", \"xxxx\", \"xxxx\"]],\n];\n// A dead tree's limbs, [x0, y0, x1, y1].\nconst TREE = [[4, 122, 4, 107], [5, 122, 5, 110], [4, 110, 1, 103], [4, 107, 7, 100], [7, 100, 9, 96], [7, 101, 5, 95], [1, 103, 0, 99], [2, 105, -1, 104], [9, 96, 11, 95], [5, 95, 6, 92]];\n// Lit windows: [middle column, top row, 0 moon or 1 clock colour, seed].\nconst WINS = [[TX - 5, 91, 0, 3], [TX + 5, 91, 0, 7], [TX, 101, 1, 11], [TX, 114, 0, 17]];\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x, dx = x + 0.5 - AX, hw = half(y);\n    let m = SKY;\n    if (hw >= 0 && abs(x - TX) \u003c= hw) m = STONE;\n    // Two pinnacles on the corners of the eave.\n    for (const c of [TX - 15, TX + 15]) if (y >= 21 && y \u003c= 29 && abs(x - c) \u003c= (y \u003c 25 ? 0 : 1)) m = STONE;\n    if (y >= groundY(x)) m = STONE;\n    for (const [sx, art] of GRAVES) {\n      const r = y - (groundY(sx + 2) - art.length + 1);\n      if (r >= 0 && r \u003c art.length && art[r][x - sx] === \"x\") m = STONE;\n    }\n    for (const [x0, y0, x1, y1] of TREE) {\n      const n = max(abs(x1 - x0), abs(y1 - y0));\n      for (let i = 0; i \u003c= n; i++) if (round(x0 + ((x1 - x0) * i) / n) === x && round(y0 + ((y1 - y0) * i) / n) === y) m = STONE;\n    }\n    // The belfry arch, its back arch and the beam the bell hangs from.\n    const ar = sqrt(dx * dx + max(0, ARCH_Y - (y + 0.5)) ** 2);\n    if (y \u003c SILL && ar \u003c ARCH_R && y >= 36) {\n      m = INSIDE;\n      if (sqrt(dx * dx + max(0, ARCH_Y + 1 - (y + 0.5)) ** 2) \u003c 6.8 && y \u003c SILL - 2) m = BACK;\n      if (y >= 39 && y \u003c= 40) m = BEAM;\n    }\n    // A louvre in the spire: three slats with dark gaps.\n    if (abs(x - TX) \u003c= 1 && y >= 16 && y \u003c= 21 && y % 2 === 1) m = INSIDE;\n    if ((x + 0.5 - CLX) ** 2 + (y + 0.5 - CLY) ** 2 \u003c CLR * CLR) m = FACE;\n    // Three lancets and the door, which is wider.\n    WINS.forEach(([wx, wy], i) => {\n      const r = y - wy, w2 = i === 3 ? 2 : 1;\n      if (r >= 0 && r \u003c 5 + w2 && abs(x - wx) \u003c= (r ? w2 : w2 - 1)) (m = WIN), (WID[p] = i);\n    });\n    MASK[p] = m;\n  }\n// Rim light where stone meets sky: brightest on the right, towards the\n// moon, then on top, then dim on the left.\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x;\n    if (MASK[p] !== STONE) continue;\n    const sky = (q) => q >= 0 && q \u003c N && MASK[q] === SKY;\n    RIM[p] = x \u003c W - 1 && sky(p + 1) ? 3 : y > 0 && sky(p - W) ? 2 : x > 0 && sky(p - 1) ? 1 : 0;\n  }\nconst RIMC = [0, [50, 20, 76], [92, 40, 132], [124, 56, 176]];\n\n// Sky by row in nine flat steps, deep violet overhead to a dusky mauve low down.\nconst SKYC = new Float32Array(H * 3);\nfor (let y = 0; y \u003c H; y++) {\n  const t = floor((y / H) * 9) / 8;\n  SKYC[3 * y] = 22 + 66 * t;\n  SKYC[3 * y + 1] = 6 + 22 * t;\n  SKYC[3 * y + 2] = 42 + 50 * t;\n}\n// The moon's tone at each LED (1 limb, 2 sea, 3 bright) and its glow in\n// stepped rings, which also lights the cloud edges there.\nconst MOONT = new Uint8Array(N), GLOW = new Float32Array(N);\nconst SEAS = [[-7, -8, 6, 4], [6, -3, 5, 6], [-4, 6, 7, 4], [9, 9, 4, 3]];\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR) {\n    const sea = SEAS.some(([cx, cy, rx, ry]) => ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 \u003c 1);\n    MOONT[p] = r > MR - 1.3 ? 1 : sea ? 2 : 3;\n    GLOW[p] = 1;\n  } else GLOW[p] = r \u003c MR + 3 ? 0.24 : r \u003c MR + 7 ? 0.14 : r \u003c MR + 13 ? 0.07 : r \u003c MR + 22 ? 0.03 : 0;\n}\n// Clouds: a wrapping noise sheet slid along by the wind. CQ is its values\n// sorted, so a cloud cover maps straight to a threshold.\nconst CW = 128, CH = 32, CN = new Float32Array(CW * CH);\nfor (let j = 0; j \u003c CH; j++)\n  for (let i = 0; i \u003c CW; i++) {\n    let v = 0, a = 0.6;\n    for (const [cell, sd] of [[16, 1], [8, 2], [4, 3]]) {\n      const nx = CW / cell, u = i / cell, w = j / (cell / 2), iu = floor(u), iw = floor(w), fu = u - iu, fw = w - iw;\n      const su = fu * fu * (3 - 2 * fu), sw = fw * fw * (3 - 2 * fw);\n      const hh = (a2, b2) => hash(((a2 % nx) + nx) % nx * 131 + b2 * 977 + sd * 7);\n      v += a * ((hh(iu, iw) * (1 - su) + hh(iu + 1, iw) * su) * (1 - sw) + (hh(iu, iw + 1) * (1 - su) + hh(iu + 1, iw + 1) * su) * sw);\n      a *= 0.5;\n    }\n    CN[j * CW + i] = v;\n  }\nconst CQ = Float32Array.from(CN).sort();\n\n// The bell: a heavy pendulum, 1.8 s there and back at Speed 2, that its\n// ringer pushes to a 0.85 rad swing. The clapper is a pendulum 0.4 as long\n// hung 0.2 below the bell's pivot and carried by the bell. Shorter, it lags,\n// and as the bell slows at the end of a swing its rim comes round onto the\n// clapper: a strike when the two are 0.4 rad apart.\nconst TB = 1.8, AMP = 0.85, CA = 0.2, CLL = 0.4, ALIM = 0.4, BOUNCE = 0.2;\nconst WB = TAU / TB, G = WB * WB;\n// The bell's outline: half its width at distances down its axis from the pivot.\nconst BV = [1.5, 2.5, 3.5, 5, 9, 11, 13, 14.5], BW = [1.5, 4, 5.3, 5.7, 6.1, 6.8, 7.8, 8.4];\nfunction bellHalf(v) {\n  if (v \u003c BV[0] || v > BV[7]) return -1;\n  let i = 0;\n  while (i \u003c 6 && v > BV[i + 1]) i++;\n  return BW[i] + ((BW[i + 1] - BW[i]) * (v - BV[i])) / (BV[i + 1] - BV[i]);\n}\nconst LIP = 14.5, LIPW = 8.4, CLAP = 11.8;\nconst BRONZE = [[64, 34, 12], [140, 82, 28], [208, 142, 56], [255, 212, 128]];\n\n// Three wing positions, 9 wide close in front, 7 further round, 5 behind.\nconst SPR = [\n  [[\"x.......x\", \"xx.....xx\", \".xx.x.xx.\", \"..xxxxx..\", \"...xxx...\", \"....x....\"], [\"x.....x\", \"xx...xx\", \".xx.xx.\", \"..xxx..\", \"...x...\"], [\"x...x\", \".x.x.\", \"..x..\"]],\n  [[\"...x.x...\", \"xxxxxxxxx\", \".xx.x.xx.\", \"....x....\"], [\".......\", \"xxx.xxx\", \".xxxxx.\", \"...x...\"], [\"xx.xx\", \".xxx.\", \"..x..\"]],\n  [[\"...x.x...\", \"..xxxxx..\", \".xx.x.xx.\", \"xx.....xx\", \"x.......x\"], [\"...x...\", \".xxxxx.\", \"xx.x.xx\", \"x.....x\"], [\"..x..\", \".xxx.\", \"x...x\"]],\n];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, nb: 8, storm: 0.06,\n    // Clock in minutes past twelve, 0..720: it opens at 11:57.\n    clk: 717, toll: 0, count: 0, pump: false, brake: 0,\n    th: 0, w: 0, ph: 0, pw: 0, spark: 9, sparkS: 1,\n    bats: [], rips: [], rain: [], cloud: 0,\n    bolt: null, boltAge: 9, boltWait: 5, begun: false,\n    buf: new Float32Array(N * 3), c: [0, 0, 0], g: [0, 0, 0],\n  };\n}\n\nfunction spawnBats(S, n) {\n  for (let i = 0; i \u003c n && S.bats.length \u003c 300; i++) {\n    // Out of the spire's louvre or from under the arch's crown, and away fast.\n    const spire = Math.random() \u003c 0.3, side = Math.random() \u003c 0.5 ? -1 : 1;\n    const hx = spire ? AX + rnd(-1, 1) : AX + side * rnd(3, 9), hy = spire ? 18.5 : rnd(37.5, 42);\n    const a = -PI / 2 + side * rnd(0.2, 1.4), sp = rnd(30, 55);\n    S.bats.push({\n      x: hx, y: hy, vx: cos(a) * sp + (hx - AX) * 2, vy: sin(a) * sp, mode: 0, t: rnd(0.45, 0.9),\n      R: rnd(11, 33), yc: Math.random() \u003c 0.6 ? rnd(4, 40) : rnd(40, 82), w: (Math.random() \u003c 0.5 ? -1 : 1) * rnd(1.1, 2.1), psi: rnd(0, TAU), amp: rnd(3, 11),\n      hx, hy, ph: rnd(0, TAU), fr: rnd(6, 9), z: 1, sd: floor(rnd(0, 1e5)),\n    });\n  }\n}\n\nconst ring = (S, n) => Object.assign(S, { toll: n, count: 0, pump: true, brake: 0 });\n\nfunction strike(S, side) {\n  S.count++;\n  S.spark = 0;\n  S.sparkS = side;\n  S.rips.push(0);\n  spawnBats(S, S.nb);\n  if (S.count >= S.toll) {\n    S.pump = false;\n    S.brake = 2.5;\n  }\n}\n\n// One small step of the bell and the clapper.\nfunction physics(S, h) {\n  const th = S.th, w = S.w, E = 0.5 * w * w + G * (1 - cos(th)), Et = G * (1 - cos(AMP));\n  let acc = -G * sin(th);\n  if (S.pump) acc += ((3 * (Et - E)) / Et) * w + (E \u003c 0.02 * Et ? 2 * (w >= 0 ? 1 : -1) : 0);\n  else if (S.brake > 0) acc -= 3 * w;\n  else acc += -0.4 * w + S.storm * 1.6 * vn(S.t * 0.8, 5);\n  // The clapper's pivot rides on the bell; its acceleration swings the clapper.\n  const ax = CA * (acc * cos(th) - w * w * sin(th)), ay = CA * (-acc * sin(th) - w * w * cos(th));\n  let pacc = (-G * sin(S.ph) - ax * cos(S.ph) + ay * sin(S.ph)) / CLL;\n  if (!S.pump) pacc -= 0.4 * (S.pw - w);\n  S.th += (S.w += acc * h) * h;\n  S.ph += (S.pw += pacc * h) * h;\n  // After the last stroke the ringer checks the bell and holds the clapper,\n  // or it would knock once more.\n  if (S.brake > 0) {\n    S.ph += (S.th - S.ph) * min(1, h * 8);\n    S.pw = S.w;\n  }\n  const rel = S.ph - S.th;\n  if (abs(rel) > ALIM) {\n    const s = rel > 0 ? 1 : -1, rv = S.pw - S.w;\n    S.ph = S.th + s * ALIM;\n    if (rv * s > 0) {\n      if (abs(rv) > 0.5 && S.pump) strike(S, s);\n      S.pw = S.w - BOUNCE * rv;\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d = cl(dt || 0, 0, 0.1);\n  [S.hue, S.speed, S.nb, S.storm] = [cl(k[0], 0, 1), cl(k[1], 0.2, 3), round(cl(k[2], 8, 40)), cl(k[3], 0, 1)];\n  if (!S.begun) {\n    S.boltWait = 5 - 3 * S.storm;\n    S.begun = true;\n    // Four strikes' worth of bats are already out, along their rings.\n    spawnBats(S, 4 * S.nb);\n    for (const b of S.bats)\n      Object.assign(b, { mode: 1, t: rnd(1, 12), x: AX + b.R * cos(b.psi), y: b.yc + b.amp * sin(b.psi) * 0.6, vx: -b.R * b.w * sin(b.psi), vy: 0, z: sin(b.psi) });\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // The clock gains 2 minutes a second at Speed 2. Two minutes before each\n  // hour the ringer starts the bell, so the first strike falls on the hour,\n  // and it strikes the hour: twelve at midnight.\n  const was = S.clk;\n  S.clk += ds * 2;\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.clk = 718;\n    ring(S, 12);\n  } else if (floor((was + 2) / 60) !== floor((S.clk + 2) / 60) && !S.pump) ring(S, floor((S.clk + 2) / 60) % 12 || 12);\n  if (S.clk >= 720) S.clk -= 720;\n  for (let i = 0; i \u003c 8; i++) physics(S, ds / 8);\n  S.brake -= ds;\n  S.spark += ds;\n  // Sound rings run out at 38 LEDs a second for 1.4 s.\n  S.rips = S.rips.map((a) => a + ds).filter((a) => a \u003c 1.4);\n  // Wind: the clouds slide 4 to 23 LEDs a second and the bats lean with it.\n  const wind = 3 + 20 * S.storm;\n  S.cloud += ds * wind;\n  const lean = 5 * S.storm;\n  // As many stay out between the hours: as bats go home, others slip out.\n  if (S.bats.length \u003c 4 * S.nb && Math.random() \u003c ds * 4) spawnBats(S, 1);\n  S.bats = S.bats.filter((b) => {\n    b.ph += ds * TAU * b.fr * (b.mode === 0 ? 1.4 : 1);\n    if (b.mode === 0) {\n      const f = exp(-2.2 * ds);\n      b.x += (b.vx *= f) * ds;\n      b.y += (b.vy *= f) * ds;\n      if ((b.t -= ds) \u003c 0) {\n        b.mode = 1;\n        b.t = rnd(7, 14);\n        b.psi = Math.acos(cl((b.x - AX) / b.R, -1, 1)) * (b.y \u003c b.yc ? -1 : 1);\n      }\n      return true;\n    }\n    let tx, ty;\n    if (b.mode === 1) {\n      // Round the spire on a tilted ring, in front of it while sin(psi) > 0.\n      b.psi += b.w * ds;\n      tx = AX + b.R * cos(b.psi) + lean;\n      ty = b.yc + b.amp * sin(b.psi) * 0.6 + 2.5 * vn(S.t * 0.9, b.sd);\n      b.z = sin(b.psi);\n      if ((b.t -= ds) \u003c 0) b.mode = 2;\n    } else {\n      tx = b.hx;\n      ty = b.hy;\n      b.z += (1 - b.z) * min(1, ds * 3);\n      if (abs(b.x - tx) \u003c 1.2 && abs(b.y - ty) \u003c 1.2) return false;\n    }\n    const kk = b.mode === 2 ? 9 : 6, cc = b.mode === 2 ? 5 : 4.2;\n    b.x += (b.vx += (kk * (tx - b.x) - cc * b.vx) * ds) * ds;\n    b.y += (b.vy += (kk * (ty - b.y) - cc * b.vy) * ds) * ds;\n    return true;\n  });\n  // Lightning: a fork from the top edge.\n  S.boltAge += ds;\n  if ((S.boltWait -= ds) \u003c 0) {\n    S.boltAge = 0;\n    S.boltWait = (30 - 28 * S.storm) * rnd(0.6, 1.4);\n    let x = Math.random() \u003c 0.5 ? rnd(2, 12) : rnd(40, 62), y = 0;\n    const pts = [x, y], end = rnd(26, 58);\n    while (y \u003c end) {\n      x += rnd(-3, 3);\n      y += rnd(2, 5);\n      pts.push(x, y);\n    }\n    S.bolt = pts;\n  }\n  // Rain from Storm 0.3 up.\n  const want = round(max(0, S.storm - 0.3) * 140);\n  while (S.rain.length \u003c want) S.rain.push([rnd(-10, W + 10), rnd(-H, H)]);\n  S.rain.length = want;\n  for (const r of S.rain) {\n    r[0] += ds * wind * 1.5;\n    if ((r[1] += ds * 150) > H) (r[1] -= H + rnd(0, 20)), (r[0] = rnd(-20, W));\n  }\n}\n\n// Flash brightness at a bolt's age: a stroke, a dim gap and a restrike.\nconst flashOf = (a) => (a \u003c 0.07 ? 1 : a \u003c 0.13 ? 0.25 : a \u003c 0.21 ? 0.8 : a \u003c 0.5 ? 0.8 * (1 - (a - 0.21) / 0.29) : 0);\n\nfunction add(buf, x, y, c, f) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  for (let i = 0, o = (y * W + x) * 3; i \u003c 3; i++) buf[o + i] += c[i] * f;\n}\n\nfunction drawBats(S, buf, front) {\n  for (const b of S.bats) {\n    if (b.z \u003c -0.15 === front) continue;\n    const s = sin(b.ph), fr = s > 0.35 ? 0 : s \u003c -0.35 ? 2 : 1, spr = SPR[fr][b.z > 0.55 ? 0 : front ? 1 : 2];\n    const ox = round(b.x) - (spr[0].length >> 1), oy = round(b.y) - 1;\n    for (let j = 0; j \u003c spr.length; j++)\n      for (let i = 0; i \u003c spr[j].length; i++) {\n        if (spr[j][i] !== \"x\") continue;\n        const x = ox + i, y = oy + j;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        // Black against the sky; over black stone, moonlit wings instead.\n        const dark = max(buf[o], buf[o + 1], buf[o + 2]) \u003c 34;\n        put(buf, o, dark ? 60 : 8, dark ? 28 : 3, dark ? 82 : 14);\n      }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, M = hsv(0.075 + S.hue, 0.8, 1, S.c), Gc = hsv(0.32 + S.hue, 0.78, 1, S.g);\n  const F = S.bolt ? flashOf(S.boltAge) : 0;\n  const cover = 0.17 + 0.73 * S.storm, thr = CQ[floor((1 - cover) * (CQ.length - 1))];\n  const off = S.cloud;\n  for (let y = 0; y \u003c H; y++) {\n    const fy = y / 2.6, j0 = floor(fy) % CH, j1 = (j0 + 1) % CH, ty = fy - floor(fy);\n    // Clouds keep off the bottom rows, over the roofs.\n    const band = y > 100 ? (y - 100) * 0.03 : 0;\n    const fl = F * max(0, 1 - y / 80);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p;\n      let R = SKYC[3 * y] + fl * 70, Gg = SKYC[3 * y + 1] + fl * 60, B = SKYC[3 * y + 2] + fl * 100;\n      const gl = GLOW[p], mt = MOONT[p];\n      if (mt) {\n        // The seas are paler, not darker: dark orange would read as brown.\n        const v = mt === 1 ? 0.86 : 1, wv = mt === 2 ? 0.3 : 0;\n        (R = (M[0] + (255 - M[0]) * wv) * v), (Gg = (M[1] + (255 - M[1]) * wv) * v), (B = (M[2] + (255 - M[2]) * wv * 0.7) * v);\n      } else if (gl > 0) {\n        R += M[0] * gl, Gg += M[1] * gl, B += M[2] * gl;\n      }\n      // A cloud here: thin edges catch the moonlight, cores are dark.\n      const fx = (x + off) * 0.32, i0 = floor(fx), tx = fx - i0, a0 = ((i0 % CW) + CW) % CW, a1 = (a0 + 1) % CW;\n      const n = (CN[j0 * CW + a0] * (1 - tx) + CN[j0 * CW + a1] * tx) * (1 - ty) + (CN[j1 * CW + a0] * (1 - tx) + CN[j1 * CW + a1] * tx) * ty;\n      const e = n - band - thr;\n      if (e > 0) {\n        const lit = min(1, gl * 2.2) + fl;\n        if (e \u003c 0.025) {\n          (R = 64 + M[0] * 0.55 * lit), (Gg = 32 + M[1] * 0.55 * lit), (B = 84 + M[2] * 0.4 * lit);\n        } else if (e \u003c 0.07) {\n          (R = 44 + M[0] * 0.18 * lit), (Gg = 22 + M[1] * 0.18 * lit), (B = 60 + M[2] * 0.12 * lit);\n        } else {\n          (R = 30 + fl * 30), (Gg = 14 + fl * 24), (B = 44 + fl * 40);\n        }\n      }\n      put(buf, o, R, Gg, B);\n    }\n  }\n  // The bolt, behind the tower.\n  if (F > 0.5 && S.bolt) {\n    const P = S.bolt;\n    for (let i = 0; i + 3 \u003c P.length; i += 2) {\n      const n = ceil(max(abs(P[i + 2] - P[i]), abs(P[i + 3] - P[i + 1])) * 2);\n      for (let j = 0; j \u003c= n; j++) {\n        const x = round(P[i] + ((P[i + 2] - P[i]) * j) / n), y = round(P[i + 1] + ((P[i + 3] - P[i + 1]) * j) / n);\n        if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) put(buf, (y * W + x) * 3, 235, 225, 255);\n      }\n    }\n  }\n  drawBats(S, buf, false);\n  // The tower.\n  const sk = S.spark \u003c 0.12, cs = cos(S.th), sn = sin(S.th), rel = S.ph - S.th;\n  const bx = CLAP * sin(rel), by = 3 + CLAP * cos(rel);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p, m = MASK[p];\n      if (m === SKY) continue;\n      if (m === STONE) {\n        let R = 7, Gg = 3, B = 12;\n        const r = RIM[p];\n        if (r) {\n          const c = RIMC[r], f = 1 + F * 0.8;\n          (R = c[0] * f), (Gg = c[1] * f), (B = c[2] * f);\n        }\n        // Green light spilling from the clock onto the stone round it.\n        const cd = sqrt((x + 0.5 - CLX) ** 2 + (y + 0.5 - CLY) ** 2);\n        if (cd \u003c 12.5) {\n          const f = cd \u003c 8.6 ? 0.1 : cd \u003c 10.5 ? 0.16 : 0.07;\n          R += Gc[0] * f, Gg += Gc[1] * f, B += Gc[2] * f;\n        }\n        put(buf, o, R, Gg, B);\n        continue;\n      }\n      if (m === WIN) {\n        const [, , kind, sd] = WINS[WID[p]], c = kind ? Gc : M;\n        // Candlelight: two noises, about 2 and 7 times a second, in three steps.\n        const v = 0.62 + 0.24 * vn(S.t * 2.2, sd) + 0.14 * vn(S.t * 7, sd + 1), lv = WID[p] === 3 ? 0.72 : 1;\n        const f = (v > 0.78 ? 1 : v > 0.56 ? 0.8 : 0.6) * lv;\n        put(buf, o, c[0] * f, c[1] * f, c[2] * f);\n        continue;\n      }\n      if (m === FACE) {\n        const dx = x + 0.5 - CLX, dy = y + 0.5 - CLY, r = sqrt(dx * dx + dy * dy), f = r \u003c 3.5 ? 1 : r \u003c 6 ? 0.86 : 0.72;\n        put(buf, o, Gc[0] * f, Gc[1] * f, Gc[2] * f);\n        continue;\n      }\n      if (m === BEAM) {\n        if (y === 39) put(buf, o, 86, 46, 22);\n        else put(buf, o, 44, 22, 10);\n        continue;\n      }\n      // Inside the belfry: dark, with the sky through the back arch.\n      if (m === BACK) for (let c = 0; c \u003c 3; c++) buf[o + c] *= 0.62;\n      else put(buf, o, 14, 7, 22);\n      if (y \u003c 41) continue;\n      // The bell, in its own frame: u across, v down its axis from the pivot.\n      const dx = x + 0.5 - PX, dy = y + 0.5 - PY, u = dx * cs - dy * sn, v = dx * sn + dy * cs;\n      const hw = bellHalf(v), lipv = abs(u) \u003c LIPW ? LIP + 1.8 * sqrt(1 - (u / LIPW) ** 2) : -1;\n      const mouth = (u / 6.8) ** 2 + ((v - LIP) / 1.3) ** 2 \u003c 1;\n      // The clapper's ball, seen inside the mouth.\n      const ball = (u - bx) ** 2 + (v - by) ** 2 \u003c 2.6;\n      if (mouth) {\n        const lt = u - bx + (v - by) \u003c -0.5;\n        if (ball) put(buf, o, lt ? 150 : 70, lt ? 140 : 62, lt ? 150 : 74);\n        else put(buf, o, 22, 10, 6);\n        continue;\n      }\n      if ((hw >= 0 && abs(u) \u003c= hw) || (v > LIP && v \u003c= lipv)) {\n        // Bronze in four tones: a bright band left of the middle, a moonlit\n        // rim on the right, dark edges and a rib round the waist.\n        const t = u / (hw > 0 ? hw : LIPW);\n        let tone = t \u003c -0.78 ? 0 : t \u003c -0.18 ? 2 : t \u003c 0.5 ? 1 : t \u003c 0.82 ? 0 : 2;\n        if (v > LIP - 0.6) tone = t \u003c -0.3 ? 3 : 2;\n        else if (abs(v - 4.2) \u003c 0.5 || abs(v - 12.6) \u003c 0.45) tone = max(0, tone - 1);\n        if (t > -0.6 && t \u003c -0.3 && v > 5 && v \u003c 11) tone = 3;\n        const c = BRONZE[tone];\n        put(buf, o, c[0], c[1], c[2]);\n      } else if (ball && v > LIP) {\n        put(buf, o, 70, 62, 74);\n      }\n    }\n  // The spark where the clapper hits the soundbow.\n  if (sk) {\n    const u = S.sparkS * 6.2, v = LIP - 0.4, x = PX + u * cs + v * sn, y = PY - u * sn + v * cs;\n    for (const [i, j] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) add(buf, x - 0.5 + i, y - 0.5 + j, [255, 240, 190], 1);\n  }\n  // The clock: twelve ticks and two hands, the hour hand short.\n  for (let i = 0; i \u003c 12; i++) {\n    const a = (i / 12) * TAU, x = round(CLX + 6.2 * sin(a) - 0.5), y = round(CLY - 6.2 * cos(a) - 0.5), o = (y * W + x) * 3;\n    for (let c = 0; c \u003c 3; c++) buf[o + c] *= 0.25;\n  }\n  const hand = (a, len) => {\n    for (let r = 0; r \u003c= len; r += 0.35) put(buf, (round(CLY - r * cos(a) - 0.5) * W + round(CLX + r * sin(a) - 0.5)) * 3, 6, 14, 6);\n  };\n  hand(((S.clk % 60) / 60) * TAU, 6.6);\n  hand((S.clk / 720) * TAU, 4.2);\n  drawBats(S, buf, true);\n  // Rings of sound from the bell, two at a time, fading in steps.\n  for (const a of S.rips) {\n    const r = 3 + 38 * a, f = a \u003c 0.45 ? 0.3 : a \u003c 0.9 ? 0.2 : 0.11;\n    for (const [rr, ff] of [[r, f], [r - 5, f * 0.55]]) {\n      if (rr \u003c 2) continue;\n      const n = ceil(TAU * rr * 1.2);\n      for (let i = 0; i \u003c n; i++) add(buf, PX - 0.5 + rr * cos((i / n) * TAU), 52 - 0.5 + rr * sin((i / n) * TAU), [210, 170, 255], ff);\n    }\n  }\n  for (const [rx, ry] of S.rain) {\n    const sl = 0.3 + 0.05 * (3 + 20 * S.storm);\n    for (let j = 0; j \u003c 3; j++) add(buf, rx + sl * j, ry + j, [110, 96, 160], 0.55);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o]) | 0, min(255, buf[o + 1]) | 0, min(255, buf[o + 2]) | 0);\n}\n","brillouin-zones":"// ===== Patternflow pattern =====\n// Title:   Brillouin Zones\n// Family:  cells\n// Idea:    The plane round one point of a slowly turning, shearing lattice is cut into its Brillouin zones, every LED coloured by how many lattice points are closer to it than the origin is, so the first zone sits in the middle as a hexagon or a square and the higher zones spread outwards as rings of scattered shards in rainbow order, a dark band runs out through the zones one index at a time and relights each in its next colour, and every so often the shards of one zone slide along their lattice vectors into the first zone, fill it with no gap and no overlap, and slide back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Brillouin zones (Léon Brillouin, 1930), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Zones=16..48, Shear=0..1\n//\n// Knob 1: Hue. Turns the whole glass round the colour wheel; zone n sits n - 1 sevenths of the wheel on from zone 1, so the order of the zones reads as a rainbow outwards. At 0 the first zone opens cyan with blue, violet, rose, orange, lime and green round it, and wears blue once the first band has passed; at 0.25 it opens violet, at 0.5 red, at 0.75 lime green.\n// Knob 2: Speed. The lattice's clock. At 2 the dark band runs out 3.2 zones a second, a new band every 8.4 s, the lattice turns 3.4 degrees a second and its angle swings between hexagonal and square over about 27 s; at 0.2 everything is ten times slower, at 3 half as fast again. A fold always takes 3.3 s.\n// Knob 3: Zones. Roughly how many zones fit between the centre and the top edge, which sets the cell: pi 64^2 / Zones LEDs. At 16 each zone is 804 LEDs and about 21 zones reach the corners; at 24 it is 536 LEDs, at 32 402 and about 41 zones, at 48 268 LEDs and about 60 zones, the outer ones broken into single LEDs.\n// Knob 4: Shear. How far the lattice leaves the symmetric ones. At 0 its two arms stay equal within 5% and the angle between them wanders from 55 to 90 degrees, hexagon to square; at 0.06 (the start) the arms differ by 4%; at 0.5 the second arm is 1.35 times the first and the angle runs 45 to 80; at 1 it is 1.7 times and 33 to 68, and the first zone is a long slanted hexagon.\n// Buttons: K1 tap folds the next zone of 4, 5, 6, 7, 8 into the first zone at once. Without a press a fold comes at 12 s and every 24 s after on the lattice's clock.\n\nconst W = 64, H = 128, N = W * H;\n// The origin sits on the corner between the four middle LEDs.\nconst OX = 32, OY = 64;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n// A lattice point farther than twice an LED's distance from the origin can\n// never be closer to that LED than the origin is.\nconst RMAX = 2 * sqrt(OX * OX + OY * OY) + 2;\nconst MAXL = 2048;\n// Zone n is n - 1 sevenths of the wheel on from zone 1: neighbouring zones\n// are always 51 degrees apart and the order outwards reads as a rainbow.\n// Zone 1 at hue 0 is cyan.\nconst STEP = 1 / 7;\nconst HUE0 = 0.52;\n// Glass saturation, the dim glass's brightness, and the lead between panes.\nconst SAT = 0.76, VD = 0.3, LEAD = 0.35;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A dark band BAND_W zones wide runs out through the zones in order 1, 2,\n// 3 ..., BAND_RATE zones a second, a new band every BAND_P zones; each zone\n// it passes relights in its next colour. Since every zone has the same\n// area, the band covers the same area of glass wherever it is.\nconst BAND_RATE = 3.2, BAND_W = 3, BAND_P = 27, PHI0 = -2;\n// Folds come by themselves at 12 s and every 24 s after, in pattern seconds.\nconst AUTO0 = 12, AUTO_EVERY = 24;\n// The fold, in real seconds: the rest of the glass dims, the pieces slide\n// home, hold, slide back, the glass comes up again.\nconst F_IN = 0.35, F_SLIDE = 0.9, F_HOLD = 0.8, F_LEN = 2 * F_IN + 2 * F_SLIDE + F_HOLD;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, nextFold: AUTO0, hue: 0, speed: 2, zones: 16, shear: 0.06,\n    zone: new Uint16Array(N), diff: new Int32Array(W + 1),\n    lx: new Float32Array(MAXL), ly: new Float32Array(MAXL), nl: 0, zTop: 1,\n    // The fold: its age (-1 when none), which zone, how many so far, the\n    // frozen lattice sorted by length (origin first), the candidate pieces\n    // and the first zone's radius.\n    fold: -1, fz: 4, folds: 0,\n    sx: new Float32Array(MAXL + 1), sy: new Float32Array(MAXL + 1), sn: new Float32Array(MAXL + 1), ns: 0,\n    cx: new Float32Array(512), cy: new Float32Array(512), nc: 0, rv: 1,\n    cover: new Int16Array(N),\n    pal: new Float32Array(3 * 256), dot: new Uint8Array(N),\n  };\n}\n\n// The lattice now: basis b1 = a(1,0), b2 = a rho (cos g, sin g), both\n// turned by th, with a set so the cell keeps the area the Zones knob asks.\nfunction lattice(S) {\n  const t = S.t, sh = S.shear;\n  // g wanders between about 55 and 90 degrees: square at 90, hexagonal at 60.\n  const g = (72.5 - 12 * sin(0.23 * t) - 5.5 * sin(0.37 * t + 2) - 22 * sh) * PI / 180;\n  const rho = 1 + 0.05 * sin(0.17 * t + 1) + 0.7 * sh;\n  const th = 0.06 * t + 0.4 * sh;\n  const A = (PI * OY * OY) / S.zones;\n  const a = sqrt(A / (rho * sin(g)));\n  const c = cos(th), s = sin(th);\n  const b1x = a * c, b1y = a * s;\n  const ux = a * rho * cos(g), uy = a * rho * sin(g);\n  const b2x = c * ux - s * uy, b2y = s * ux + c * uy;\n  const mi = ceil((RMAX * a * rho) / A) + 1, mj = ceil((RMAX * a) / A) + 1;\n  let n = 0;\n  for (let i = -mi; i \u003c= mi; i++)\n    for (let j = -mj; j \u003c= mj; j++) {\n      if (!i && !j) continue;\n      const x = i * b1x + j * b2x, y = i * b1y + j * b2y;\n      if (x * x + y * y >= RMAX * RMAX || n >= MAXL) continue;\n      S.lx[n] = x;\n      S.ly[n] = y;\n      n++;\n    }\n  S.nl = n;\n}\n\n// Zone of every LED: 1 + how many lattice points are strictly closer to it\n// than the origin. L is closer to p exactly when p.L > |L|^2 / 2, a half\n// plane bounded by the perpendicular bisector of 0 and L, so along a row\n// each lattice point starts or stops counting at one x.\nfunction zones(S) {\n  const Z = S.zone, D = S.diff, LX = S.lx, LY = S.ly, nl = S.nl;\n  let top = 1;\n  for (let y = 0; y \u003c H; y++) {\n    D.fill(0);\n    const py = y + 0.5 - OY;\n    const rr = 4 * (OX * OX + py * py) + 4;\n    for (let k = 0; k \u003c nl; k++) {\n      const lx = LX[k], ly = LY[k], l2 = lx * lx + ly * ly;\n      if (l2 > rr) continue;\n      const c = l2 / 2 - py * ly;\n      if (abs(lx) \u003c 1e-9) {\n        if (c \u003c 0) D[0]++;\n        continue;\n      }\n      const tx = c / lx + OX - 0.5;\n      if (lx > 0) {\n        const x0 = floor(tx) + 1;\n        if (x0 \u003c W) D[x0 \u003c 0 ? 0 : x0]++;\n      } else {\n        const x1 = ceil(tx);\n        if (x1 > 0) {\n          D[0]++;\n          if (x1 \u003c W) D[x1]--;\n        }\n      }\n    }\n    let run = 1;\n    for (let x = 0; x \u003c W; x++) {\n      run += D[x];\n      Z[y * W + x] = run;\n      if (run > top) top = run;\n    }\n  }\n  S.zTop = top;\n}\n\n// Freeze the lattice for a fold of zone n. Each piece of zone n is the part\n// whose nearest lattice point is one L, and it lands on the first zone when\n// moved by -L. A point u of the first zone is covered by piece L exactly\n// when -L is its n-th nearest lattice point, so L can be a piece only if\n// its length is within twice the first zone's radius of the n-th length.\nfunction foldStart(S, n) {\n  const m = S.nl, idx = new Array(m);\n  for (let k = 0; k \u003c m; k++) idx[k] = k;\n  idx.sort((a, b) => S.lx[a] ** 2 + S.ly[a] ** 2 - S.lx[b] ** 2 - S.ly[b] ** 2);\n  S.sx[0] = S.sy[0] = S.sn[0] = 0;\n  for (let k = 0; k \u003c m; k++) {\n    const x = S.lx[idx[k]], y = S.ly[idx[k]];\n    S.sx[k + 1] = x;\n    S.sy[k + 1] = y;\n    S.sn[k + 1] = sqrt(x * x + y * y);\n  }\n  S.ns = m + 1;\n  let rv = 0;\n  for (let p = 0; p \u003c N; p++)\n    if (S.zone[p] === 1) rv = max(rv, sqrt(((p % W) + 0.5 - OX) ** 2 + (floor(p / W) + 0.5 - OY) ** 2));\n  S.rv = rv + 1;\n  const below = (r) => {\n    let c = 0;\n    while (c \u003c S.ns && S.sn[c] \u003c r) c++;\n    return c;\n  };\n  let nc = 0;\n  for (let k = 1; k \u003c S.ns && nc \u003c 512; k++) {\n    const r = S.sn[k];\n    if (below(r - 2 * S.rv) \u003c= n - 1 && below(r + 2 * S.rv) - 1 >= n - 1) {\n      S.cx[nc] = S.sx[k];\n      S.cy[nc] = S.sy[k];\n      nc++;\n    }\n  }\n  S.nc = nc;\n  S.fz = n;\n  S.fold = 0;\n}\n\n// Which piece of the folding zone covers each LED when the pieces have\n// moved the fraction s of the way home (0 for none).\nfunction foldCover(S, s) {\n  const C = S.cover, n = S.fz, rv = S.rv, SX = S.sx, SY = S.sy, SN = S.sn, ns = S.ns;\n  const nshort = min(17, ns);\n  C.fill(0);\n  for (let k = 0; k \u003c S.nc; k++) {\n    const Lx = S.cx[k], Ly = S.cy[k], ox = (1 - s) * Lx, oy = (1 - s) * Ly;\n    const x0 = max(0, floor(ox + OX - rv)), x1 = min(W - 1, ceil(ox + OX + rv));\n    const y0 = max(0, floor(oy + OY - rv)), y1 = min(H - 1, ceil(oy + OY + rv));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const ux = x + 0.5 - OX - ox, uy = y + 0.5 - OY - oy;\n        // u must lie in the first zone: no short lattice vector closer.\n        let inside = true;\n        for (let j = 1; j \u003c nshort; j++)\n          if (ux * SX[j] + uy * SY[j] > (SN[j] * SN[j]) / 2) {\n            inside = false;\n            break;\n          }\n        if (!inside) continue;\n        // And -L must be its n-th nearest lattice point.\n        const ex = ux + Lx, ey = uy + Ly, d2 = ex * ex + ey * ey, lim = sqrt(ux * ux + uy * uy) + sqrt(d2);\n        let cnt = 0;\n        for (let j = 0; j \u003c ns && SN[j] \u003c= lim; j++) {\n          const dx = ux - SX[j], dy = uy - SY[j];\n          if (dx * dx + dy * dy \u003c d2 && ++cnt >= n) break;\n        }\n        if (cnt === n - 1) C[y * W + x] = k + 1;\n      }\n  }\n}\n\nconst foldS = (a) => (a \u003c F_IN ? 0 : a \u003c F_IN + F_SLIDE ? sm(F_IN, F_IN + F_SLIDE, a) : a \u003c F_IN + F_SLIDE + F_HOLD ? 1 : 1 - sm(F_LEN - F_IN - F_SLIDE, F_LEN - F_IN, a));\nconst foldDim = (a) => sm(0, F_IN, a) * (1 - sm(F_LEN - F_IN, F_LEN, a));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 16, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.zones = cl(k[2], 16, 48);\n  S.shear = cl(k[3], 0, 1);\n  if (S.fold >= 0) {\n    // The lattice holds still while its pieces move.\n    S.fold += d;\n    if (S.fold >= F_LEN) S.fold = -1;\n    else {\n      foldCover(S, foldS(S.fold));\n      return;\n    }\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  lattice(S);\n  zones(S);\n  const press = input.btnPressed && input.btnPressed[0];\n  const auto = S.t >= S.nextFold;\n  if (auto) S.nextFold += AUTO_EVERY;\n  if (press || auto) {\n    // Zones 4 to 8 in turn.\n    foldStart(S, 4 + (S.folds % 5));\n    S.folds++;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const Z = S.zone, PAL = S.pal, DOT = S.dot;\n  const folding = S.fold >= 0, fd = folding ? foldDim(S.fold) : 0;\n  const phi = BAND_RATE * S.t + PHI0;\n  // Each zone's glass: its colour moves one golden step on for every band\n  // that has passed it.\n  const nz = min(S.zTop + 2, 255);\n  for (let n = 1; n \u003c= nz; n++) {\n    const k = phi >= n ? floor((phi - n) / BAND_P) + 1 : 0;\n    hsv(HUE0 + S.hue + (n - 1 + k) * STEP, SAT, 1, PAL, 3 * n);\n  }\n  // The lattice points themselves, as single pale LEDs.\n  DOT.fill(0);\n  for (let k = -1; k \u003c S.nl; k++) {\n    const x = floor((k \u003c 0 ? 0 : S.lx[k]) + OX), y = floor((k \u003c 0 ? 0 : S.ly[k]) + OY);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) DOT[y * W + x] = 1;\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, z = Z[p];\n      const e = (x + 1 \u003c W && Z[p + 1] !== z) || (y + 1 \u003c H && Z[p + W] !== z);\n      // Where this zone is in the band's cycle: dim inside the band, and\n      // flaring towards white just as it relights.\n      const o = 3 * min(z, nz), u = phi >= z ? (phi - z) % BAND_P : BAND_P;\n      const v = u \u003c BAND_W ? VD : 1;\n      let r = PAL[o] * v, g = PAL[o + 1] * v, b = PAL[o + 2] * v;\n      const fl = folding || u \u003c BAND_W ? 0 : max(0, 1 - (u - BAND_W) / 1.2) * 0.6;\n      r += (1 - r) * fl;\n      g += (1 - g) * fl;\n      b += (1 - b) * fl;\n      // Lead between the panes.\n      let f = e ? LEAD : 1;\n      if (folding) {\n        const pc = S.cover[p];\n        if (pc) {\n          // A piece of the folding zone, each piece its own shade.\n          const q = 3 * S.fz, sh = 0.75 + 0.125 * ((pc * 7) % 3);\n          const pe = (x + 1 \u003c W && S.cover[p + 1] !== pc) || (y + 1 \u003c H && S.cover[p + W] !== pc);\n          r = PAL[q] * sh;\n          g = PAL[q + 1] * sh;\n          b = PAL[q + 2] * sh;\n          f = pe ? 0.45 : 1;\n        } else {\n          // The rest dims, the places the pieces left go dark, and the\n          // first zone's rim shows white.\n          f *= 1 - fd * (z === S.fz ? 0.94 : 0.72);\n          const rim = z === 1 && ((x > 0 && Z[p - 1] !== 1) || (x + 1 \u003c W && Z[p + 1] !== 1) || (y > 0 && Z[p - W] !== 1) || (y + 1 \u003c H && Z[p + W] !== 1));\n          if (rim) (r = g = b = 1), (f = 0.25 + 0.6 * fd);\n        }\n      }\n      if (DOT[p]) {\n        r += (1 - r) * 0.7;\n        g += (1 - g) * 0.7;\n        b += (1 - b) * 0.7;\n        f = max(f, 0.8);\n      }\n      display.setPixel(x, y, r * f * 255, g * f * 255, b * f * 255);\n    }\n}\n","ghost-ship":"// ===== Patternflow pattern =====\n// Title:   Ghost Ship\n// Family:  halloween\n// Idea:    A tattered three-masted ship drifts across a dark sea under a pale moon, pitching and heaving on the swells under her while her torn sails flap, her slack rigging swings, St. Elmo's fire flickers on her mast tops and green lanterns sway at bow and stern and throw their light on the water and into the fog, and now and then she turns half see-through so the moon shows through her, or sinks into the rolling purple fog and comes back further on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Swell=1..4, Fog=0..1\n//\n// Knob 1: Hue. The ghost light: lanterns, their halos, streaks and glow in the fog, the glow round her outline, gunports, rail and St. Elmo's fire. At 0 toxic green, at 0.25 azure, at 0.5 violet, at 0.75 red orange; the moon, the sails and the orange cabin windows stay as they are.\n// Knob 2: Speed. At 2 a swell passes under her every 3.5 seconds, the sails flap 1.2 times a second and she drifts 12 LEDs in 24 seconds before the fog takes her and gives her back at the right; at 0.2 all ten times slower, at 3 half as fast again.\n// Knob 3: Swell. At 1 a gentle sea: she pitches 0.1 rad either way, her main truck swings 16 LEDs and spray flies about once a second; at 2.5 she pitches 0.25 rad, heaves 5 LEDs and throws spray at every plunge; at 4 she pitches 0.38 rad, heaves 8 LEDs and the near swells wash over her hull.\n// Knob 4: Fog. At 0 and at the opening 0.06, wisps along the waterline, thickest round the hull; at 0.5 the fog swallows the lower hull and the far sea and reaches the lower sails; at 1 it climbs to row 20, her hull is gone and only the sails, masts and lantern glow show through.\n// Buttons: K1 tap sinks the ship into the fog: she fades out in a second, the fog closes over where she was, and 1.5 seconds later she comes back 5 LEDs further on.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan, exp, PI } = Math;\nconst TAU = 2 * PI, R = () => Math.random();\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n  return out;\n}\n// Into the float frame: set, add colour c times v, move towards a colour by a.\nconst put = (B, p, r, g, b) => ((B[p] = r), (B[p + 1] = g), (B[p + 2] = b));\nconst add = (B, p, c, v) => ((B[p] += c[0] * v), (B[p + 1] += c[1] * v), (B[p + 2] += c[2] * v));\nconst mix = (B, p, r, g, b, a) => ((B[p] += (r - B[p]) * a), (B[p + 1] += (g - B[p + 1]) * a), (B[p + 2] += (b - B[p + 2]) * a));\n// Value noise for the fog.\nconst NT = new Float32Array(65536);\nfor (let i = 0; i \u003c 65536; i++) NT[i] = hash(i * 7 + 3);\nfunction vn(x, y) {\n  const xi = floor(x), yi = floor(y);\n  let fx = x - xi, fy = y - yi;\n  fx = fx * fx * (3 - 2 * fx);\n  fy = fy * fy * (3 - 2 * fy);\n  const x0 = xi & 255, x1 = (xi + 1) & 255, y0 = (yi & 255) \u003c\u003c 8, y1 = ((yi + 1) & 255) \u003c\u003c 8;\n  const a = NT[y0 + x0], b = NT[y0 + x1], c = NT[y1 + x0], d = NT[y1 + x1];\n  return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;\n}\n\n// The night, built once: the horizon row, the moon's centre and radius.\nconst HZ = 84, MX = 46, MY = 25, MR = 10;\n// Sky in eight flat steps, near black at the top to a purple haze on the horizon.\nconst SKY = new Float32Array(N * 3);\nfor (let y = 0; y \u003c HZ + 6; y++) {\n  const t = round(8 * sm(0, HZ, y)) / 8;\n  for (let x = 0; x \u003c W; x++) {\n    put(SKY, (y * W + x) * 3, 0.03 + 0.2 * t, 0.02 + 0.1 * t, 0.09 + 0.24 * t);\n  }\n}\n// The moon with three darker seas, and its halo in stepped rings.\nconst MOON = new Float32Array(N);\nconst SEAS = [[-3, -3, 4, 3], [4, 1, 3, 4], [-2, 5, 3, 2]];\nfor (let y = 0; y \u003c HZ; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy), p = (y * W + x) * 3;\n    if (r \u003c MR) {\n      let e = 9;\n      for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2);\n      MOON[y * W + x] = e \u003c 1 ? 0.84 : 1;\n      continue;\n    }\n    add(SKY, p, [0.9, 0.85, 0.8], r \u003c MR + 3 ? 0.2 : r \u003c MR + 7 ? 0.11 : r \u003c MR + 13 ? 0.05 : 0);\n  }\n// Stars, each with a twinkle phase.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 22 && i \u003c 500; i++) {\n  const x = floor(hash(i * 3 + 1) * W), y = floor(hash(i * 3 + 2) * 70);\n  if ((x - MX) ** 2 + (y - MY) ** 2 \u003c (MR + 5) ** 2) continue;\n  STARS.push([x, y, hash(i * 3 + 3) * TAU]);\n}\n\n// How a lantern's light in the fog falls off with the squared distance.\nconst FALL = new Float32Array(900);\nfor (let i = 0; i \u003c 900; i++) FALL[i] = exp(-sqrt(i) / 10);\n\n// Thin clouds far behind her: row, length, thickness, speed, start.\nconst CLOUDS = [[13, 30, 2.2, 1.6, 62], [33, 24, 1.8, 2.3, 78], [46, 36, 2.6, 1.2, 50]];\n\n// ---- The sea: six layers of swell, far to near. Each is a wave line\n// (base row, amplitude per unit of Swell, wavenumber, frequency, phase) with a\n// flat face below it; the ship rides on layer 3.\nconst LAYERS = [\n  [87, 0.35, 0.24, 2.0, 0.0],\n  [91, 0.6, 0.18, 1.95, 1.7],\n  [96, 0.9, 0.14, 1.9, 3.1],\n  [101, 2.0, 0.105, 1.8, 0.6],\n  [110, 2.6, 0.085, 1.7, 2.4],\n  [121, 3.2, 0.07, 1.6, 4.4],\n];\nconst SHIP_LAYER = 3;\n// Face and crest colours of each layer: hazy far, black-blue near.\nconst FACE = [[0.15, 0.12, 0.3], [0.11, 0.1, 0.25], [0.08, 0.075, 0.2], [0.06, 0.06, 0.16], [0.045, 0.045, 0.13], [0.035, 0.035, 0.11]];\nconst CREST = [[0.32, 0.27, 0.5], [0.3, 0.27, 0.52], [0.3, 0.28, 0.55], [0.33, 0.32, 0.6], [0.34, 0.33, 0.62], [0.36, 0.35, 0.66]];\nfunction eta(j, x, t, swell) {\n  const L = LAYERS[j], k = L[2], w = L[3];\n  return swell * L[1] * (sin(k * x - w * t + L[4]) + 0.35 * sin(2.3 * k * x + 1.7 * w * t + 2 * L[4]));\n}\n\n// ---- The ship, in her own frame: u along the hull, bow at -u, w up from\n// the waterline.\nconst MASTS = [[-11, 68], [0, 79], [11, 58]];\n// Sails: top and bottom centre, top and bottom row, top and bottom half width.\n// Three tiers on fore and main, two on the mizzen, a jib to the bowsprit.\nconst SAILS = [\n  [-11, -11, 64, 54, 2.5, 3.5], [-11, -11, 52, 41, 3.5, 4.5], [-11, -11, 39, 27, 4, 4.8],\n  [0, 0, 75, 65, 2.5, 3.5], [0, 0, 63, 51, 3.5, 4.5], [0, 0, 49, 35, 4.2, 5],\n  [11, 11, 54, 45, 2.5, 3.5], [11, 11, 43, 31, 3.5, 4.5],\n  [-12.5, -22, 48, 15, 0.3, 4.5],\n];\n// Yards across the square sails' tops and bottoms: mast u, row, half width.\nconst YARDS = [];\nfor (const s of SAILS.slice(0, 8)) YARDS.push([s[0], s[2], s[4] + 1], [s[0], s[3] + 0.5, s[5] + 0.5]);\nconst hullTop = (u) => 9 + 2.5 * sm(-14, -19, u) + 4 * sm(10, 12, u) + 2 * sm(14, 21, u);\nconst hullBot = (u) => -5 + 15 * sm(-15, -23, u) + 7 * sm(17, 22, u);\n// Broken stretches of rail, as rows taken off the top.\nconst RAIL = new Float32Array(48);\nfor (let i = 0; i \u003c 48; i++) RAIL[i] = hash(i + 900) \u003c 0.22 ? 1 : 0;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, swell: 1, fog: 0.06, t: 0,\n    // Where she is, her pitch, heave and lagging pitch (the lanterns swing\n    // from it), and the bow's depth and how fast it plunges.\n    xs: 36, pitch: 0, heave: 0, lag: 0, bowY: 0, bowV: 0,\n    // Her opacity: a ghost dip now and then, and the vanish that the button\n    // or the end of a crossing starts (age -1 when none).\n    alpha: 1, dip: -1, dipWait: 5, van: -1, moveTo: 36,\n    spray: [], fires: [], buf: new Float32Array(N * 3), ship: new Float32Array(N * 4),\n    lines: new Float32Array(W * 6), aura: new Float32Array(N), tmp: new Float32Array(N), lamps: [[0, 0], [0, 0]], g: [0, 0, 0],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.swell = cl(k[2], 1, 4);\n  S.fog = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  const t = S.t, sw = S.swell;\n  // She rides her layer's swell: heave from the water under her middle,\n  // pitch from the slope between bow and stern, both lagging a little.\n  const e0 = eta(SHIP_LAYER, S.xs - 17, t, sw), e1 = eta(SHIP_LAYER, S.xs + 17, t, sw), em = eta(SHIP_LAYER, S.xs, t, sw);\n  const tp = atan((e0 - e1) / 34) * 0.75;\n  S.pitch += (tp - S.pitch) * min(1, ds * 5);\n  S.heave += (0.85 * em - S.heave) * min(1, ds * 5);\n  S.lag += (S.pitch - S.lag) * min(1, ds * 2.2);\n  // Drift: 12 LEDs in 24 s, then she sinks into the fog and comes back\n  // at the right.\n  if (S.van \u003c 0) S.xs -= ds * 0.5;\n  if (S.van \u003c 0 && S.xs \u003c 26) start(S, 38);\n  if (input.btnPressed && input.btnPressed[0] && S.van \u003c 0) start(S, S.xs - 5 \u003c 26 ? 38 : S.xs - 5);\n  // The vanish: out in 1 s, gone 1.5 s (she moves then), back in 1.5 s.\n  let a = 1;\n  if (S.van >= 0) {\n    S.van += ds;\n    if (S.van \u003c 1) a = 1 - sm(0, 1, S.van);\n    else if (S.van \u003c 2.5) {\n      a = 0;\n      S.xs = S.moveTo;\n    } else if (S.van \u003c 4) a = sm(2.5, 4, S.van);\n    else S.van = -1;\n  } else if (S.dip >= 0) {\n    // A ghost dip: down to 0.45 in 0.8 s, held 1.2 s, back in 0.8 s.\n    S.dip += ds;\n    a = 1 - 0.55 * (S.dip \u003c 0.8 ? sm(0, 0.8, S.dip) : S.dip \u003c 2 ? 1 : 1 - sm(2, 2.8, S.dip));\n    if (S.dip > 2.8) {\n      S.dip = -1;\n      S.dipWait = 8 + 7 * R();\n    }\n  } else {\n    S.dipWait -= ds;\n    if (S.dipWait \u003c= 0) S.dip = 0;\n  }\n  S.alpha = a;\n  // Spray: the bow's depth in the water under it (LEDs, deeper positive),\n  // and droplets thrown forward and up while it plunges.\n  const bx = S.xs - 22 * cos(S.pitch), wl = LAYERS[SHIP_LAYER][0];\n  const by = 22 * sin(S.pitch) - S.heave + eta(SHIP_LAYER, bx, t, sw);\n  S.bowV = ds > 0 && S.t > ds ? (by - S.bowY) / ds : 0;\n  S.bowY = by;\n  if (S.bowV > 2 && by > -3 && S.spray.length \u003c 60 && a > 0.2 && R() \u003c ds * 0.8 * sw * (S.bowV - 2)) {\n    const n = 1 + floor(R() * sw);\n    for (let i = 0; i \u003c n; i++)\n      S.spray.push({ x: bx - 2 * R(), y: wl - eta(SHIP_LAYER, bx, t, sw) - 1, vx: -6 - 10 * R(), vy: -(8 + 7 * sw) * (0.6 + 0.6 * R()), age: 0, life: 0.5 + 0.5 * R() });\n  }\n  for (const p of S.spray) {\n    p.age += ds;\n    p.vy += 45 * ds;\n    p.x += p.vx * ds;\n    p.y += p.vy * ds;\n  }\n  S.spray = S.spray.filter((p) => p.age \u003c p.life);\n}\n\nfunction start(S, to) {\n  S.van = 0;\n  S.dip = -1;\n  S.moveTo = to;\n}\n\n// The ship's frame to the screen.\nfunction toScreen(S, u, w, out) {\n  const c = cos(S.pitch), s = sin(S.pitch), y0 = LAYERS[SHIP_LAYER][0] - S.heave;\n  out[0] = S.xs + u * c - w * s;\n  out[1] = y0 - (u * s + w * c);\n  return out;\n}\n\n// One sail: is (u, w) on its cloth, and how lit. 0 when not.\nfunction sailAt(S, i, u, w) {\n  const sl = SAILS[i], wt = sl[2], wb = sl[3];\n  if (w > wt + 0.5 || w \u003c wb - 4) return 0;\n  const ut = sl[0], ub = sl[1], ht = sl[4], hb = sl[5], t = S.t;\n  const span = wt - wb, s = (wt - w) / span, hw = ht + (hb - ht) * cl(s, 0, 1);\n  if (abs(u - ut - (ub - ut) * s) > hw + 3.5) return 0;\n  // The flap: a wave running down the cloth about once a second, pushing the\n  // lower part to and fro, with the belly blown towards the bow.\n  const ph = 7.5 * t - 2.6 * s + i * 1.9;\n  const du = (1.2 + 0.3 * S.swell) * s * s * sin(ph) - 1.6 * s * (1 - s);\n  const ul = u - ut - (ub - ut) * s - du;\n  if (abs(ul) > hw + 0.5) return 0;\n  // The torn foot: tongues of cloth of different lengths, each swinging.\n  const tongue = floor((ul + 12) / 1.7) + i * 31;\n  const rag = (hash(tongue) - 0.35) * 0.5 + 0.06 * sin(ph * 1.3 + tongue);\n  const belly = 0.1 * (1 - (ul / hw) ** 2);\n  if (s > 1 + belly + rag || s \u003c 0) return 0;\n  // Holes, fixed to the cloth.\n  if (hash(floor((ul + 12) / 1.6) * 97 + floor((s * span) / 1.6) * 13 + i * 7) \u003c 0.1) return 0;\n  // Folds catch the moon as the wave runs down: three tones.\n  const lit = 0.5 + 0.5 * cos(ph + ul * 0.5);\n  return lit > 0.66 ? 1 : lit > 0.33 ? 0.76 : 0.52;\n}\n\nfunction plot(S, x, y, r, g, b, a) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const q = (y * W + x) * 4, sh = S.ship;\n  if (a \u003c sh[q + 3]) return;\n  put(sh, q, r, g, b);\n  sh[q + 3] = a;\n}\n// A line in the ship's frame, sagging sideways by sag at its middle.\nconst P = [0, 0];\nfunction line(S, u0, w0, u1, w1, sag, r, g, b, a) {\n  const len = sqrt((u1 - u0) ** 2 + (w1 - w0) ** 2), n = Math.ceil(len * 1.6);\n  const nu = -(w1 - w0) / (len || 1), nw = (u1 - u0) / (len || 1);\n  for (let i = 0; i \u003c= n; i++) {\n    const f = i / n, bow = 4 * f * (1 - f) * sag;\n    toScreen(S, u0 + (u1 - u0) * f + nu * bow, w0 + (w1 - w0) * f + nw * bow, P);\n    plot(S, P[0], P[1], r, g, b, a);\n  }\n}\n\n// A 7-wide running mean along each of the lines of a frame: n LEDs a line,\n// lines starting ls apart, LEDs st apart along them.\nfunction box(src, dst, n, lines, ls, st) {\n  for (let l = 0; l \u003c lines; l++) {\n    let run = 0;\n    const o = l * ls;\n    for (let i = -3; i \u003c n + 3; i++) {\n      if (i + 3 \u003c n) run += src[o + (i + 3) * st];\n      if (i - 4 >= 0) run -= src[o + (i - 4) * st];\n      if (i >= 0 && i \u003c n) dst[o + i * st] = run / 7;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const t = S.t, sw = S.swell, A = S.alpha, B = S.buf, sh = S.ship, G = S.g;\n  // The ghost light, toxic green at the opening.\n  hsv(0.3 + S.hue, 0.85, 1, G);\n  const flick = 0.82 + 0.1 * sin(t * 13.1) + 0.08 * sin(t * 29.7 + 1);\n\n  // Sky, moon and stars.\n  B.set(SKY);\n  for (let p = 0; p \u003c N; p++)\n    if (MOON[p] > 0) put(B, 3 * p, 0.9 * MOON[p], 0.88 * MOON[p], 0.78 * MOON[p]);\n  for (const [x, y, ph] of STARS) {\n    const v = 0.3 + 0.25 * sin(t * 2.3 + ph), p = (y * W + x) * 3;\n    put(B, p, max(B[p], v), max(B[p + 1], v), max(B[p + 2], v * 1.1));\n  }\n\n  // Clouds: dark slate with a rim lit by the moon along the top, brighter\n  // and see-through where they cross the moon.\n  for (let k = 0; k \u003c CLOUDS.length; k++) {\n    const [cy, len, th, sp, x0] = CLOUDS[k], cx = ((((x0 - sp * t) % 110) + 110) % 110) - 23;\n    for (let x = max(0, floor(cx - len / 2 - 2)); x \u003c min(W, cx + len / 2 + 2); x++) {\n      const u = (x + 0.5 - cx) / (len / 2);\n      if (abs(u) >= 1) continue;\n      const half = th * sqrt(1 - u * u) * (0.75 + 0.25 * sin(u * 7 + k * 2)), mid = cy + 1.2 * sin(u * 2.5 + k);\n      for (let y = max(0, floor(mid - half)); y \u003c min(HZ, mid + half + 1); y++) {\n        const p = (y * W + x) * 3, near = MOON[y * W + x] > 0;\n        const rim = y + 0.5 \u003c mid - half + 1, a = near ? 0.6 : 0.85;\n        mix(B, p, rim ? 0.42 : 0.13, rim ? 0.38 : 0.09, rim ? 0.5 : 0.22, a);\n      }\n    }\n  }\n\n  // The sea lines for every column, then the layers far to near.\n  const L = S.lines;\n  for (let j = 0; j \u003c 6; j++) for (let x = 0; x \u003c W; x++) L[j * W + x] = round(LAYERS[j][0] - eta(j, x + 0.5, t, sw));\n  // Which layer's water each LED shows, -1 for sky; she shows only in\n  // front of the sky and the layers behind hers.\n  const layerOf = (x, y) => {\n    for (let j = 5; j >= 0; j--) if (y >= L[j * W + x]) return j;\n    return -1;\n  };\n  for (let y = HZ - 6; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const j = layerOf(x, y);\n      if (j \u003c 0) continue;\n      const p = (y * W + x) * 3, top = y - L[j * W + x];\n      // Crests one LED thick on the far layers, two on the near ones.\n      const c = top \u003c 1 || (top \u003c 2 && j >= SHIP_LAYER) ? CREST[j] : FACE[j];\n      put(B, p, c[0], c[1], c[2]);\n      // Moon glitter: dashes under the moon, wider towards the viewer,\n      // flickering with the crests.\n      const spread = 0.8 + (y - HZ) * 0.08, dx = abs(x + 0.5 - MX + 0.12 * (y - HZ));\n      if (dx \u003c spread && (top \u003c 1 || hash(x * 131 + y * 7 + floor(t * 7) * 1009) \u003c 0.1)) {\n        const v = top \u003c 1 ? 0.85 : 0.5;\n        put(B, p, 0.9 * v, 0.87 * v, 0.72 * v);\n      } else if (top >= 2 && top === round(3.5 + 2.5 * sin(x * LAYERS[j][2] * 2.1 + t * 2.3 + j * 1.3))) {\n        // A ripple across each face, a second, fainter crest.\n        put(B, p, (c[0] + CREST[j][0]) / 2, (c[1] + CREST[j][1]) / 2, (c[2] + CREST[j][2]) / 2);\n      }\n    }\n\n  // ---- The ship, into its own buffer with an opacity per LED.\n  sh.fill(0);\n  if (A > 0.01) {\n    const c = cos(S.pitch), s = sin(S.pitch), y0 = LAYERS[SHIP_LAYER][0] - S.heave;\n    // Hull and sails, LED by LED, in a box round her.\n    const x0 = max(0, floor(S.xs - 40)), x1 = min(W - 1, Math.ceil(S.xs + 40));\n    const yTop = max(0, floor(y0 - 77 * c - 32 * abs(s)));\n    for (let y = yTop; y \u003c y0 + 8 && y \u003c H; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - S.xs, dy = y0 - (y + 0.5);\n        const u = dx * c + dy * s, w = -dx * s + dy * c, q = (y * W + x) * 4;\n        if (w \u003c 15.5 && u > -23 && u \u003c 22 && w > hullBot(u) && w \u003c hullTop(u)) {\n          const top = hullTop(u), rail = RAIL[cl(floor(u + 24), 0, 47)];\n          if (w > top - rail) continue;\n          let r = 0.07, g = 0.05, b = 0.11;\n          // Planks: a lighter seam every third row.\n          if (((w + 30) | 0) % 3 === 0) (r = 0.1), (g = 0.08), (b = 0.15);\n          // The rail lit by the ghost light.\n          if (w > top - rail - 1.1) (r = G[0] * 0.3), (g = G[1] * 0.3), (b = G[2] * 0.3);\n          // Gunports glowing from inside.\n          const gp = (u + 30) / 5 - floor((u + 30) / 5);\n          if (w > 4 && w \u003c 6 && gp > 0.45 && gp \u003c 0.8 && u > -15 && u \u003c 10) (r = G[0] * 0.6 * flick), (g = G[1] * 0.6 * flick), (b = G[2] * 0.6 * flick);\n          // The stern's cabin windows, candle orange.\n          if (w > 9.5 && w \u003c 11.6 && ((u > 13.5 && u \u003c 15.5) || (u > 17 && u \u003c 19))) (r = 1 * flick), (g = 0.45 * flick), (b = 0.06);\n          put(sh, q, r, g, b);\n          sh[q + 3] = A;\n          continue;\n        }\n        if (w \u003c 12 || w > 76 || u \u003c -30 || u > 19) continue;\n        for (let i = 0; i \u003c SAILS.length; i++) {\n          const v = sailAt(S, i, u, w);\n          if (v > 0) {\n            put(sh, q, 0.68 * v, 0.66 * v, 0.78 * v);\n            sh[q + 3] = 0.88 * A;\n            break;\n          }\n        }\n      }\n    // Masts, yards and bowsprit in dark grey-violet; the rigging fainter,\n    // slack and swinging.\n    const mr = 0.2, mg = 0.17, mb = 0.27;\n    for (const [mu, mh] of MASTS) line(S, mu, 8, mu, mh, 0, mr, mg, mb, A);\n    line(S, 0.6, 8, 0.6, 60, 0, mr, mg, mb, A);\n    for (const [yu, yw, yh] of YARDS) line(S, yu - yh, yw, yu + yh, yw, 0, mr, mg, mb, A);\n    line(S, -21, 10, -31, 16, 0, mr, mg, mb, A);\n    const rr = 0.13, rg = 0.12, rb = 0.2;\n    MASTS.forEach(([mu, mh], i) => {\n      const sway = 0.9 * sin(t * 2.1 + i * 2) + 6 * (S.pitch - S.lag);\n      line(S, mu, mh, i ? MASTS[i - 1][0] : -31, i ? MASTS[i - 1][1] - 14 : 16, sway, rr, rg, rb, 0.8 * A);\n      line(S, mu, mh - 3, mu + 7, hullTop(mu + 7), -0.5 * sway, rr, rg, rb, 0.8 * A);\n      line(S, mu, mh - 3, mu - 6, hullTop(mu - 6), 0.5 * sway, rr, rg, rb, 0.8 * A);\n    });\n    line(S, 11, 58, 21, hullTop(21), 0.7 * sin(t * 1.7), rr, rg, rb, 0.8 * A);\n    // A torn pennant streaming forward off the main truck.\n    for (let i = 0; i \u003c= 14; i++) {\n      const f = i / 14, pw = 79 - 1.2 * f + 1.6 * f * sin(t * 9 - 5 * f);\n      toScreen(S, -f * 9, pw, P);\n      plot(S, P[0], P[1], 0.6, 0.58, 0.7, A);\n      if (f \u003c 0.55) {\n        toScreen(S, -f * 9, pw - 1, P);\n        plot(S, P[0], P[1], 0.6, 0.58, 0.7, A);\n      }\n    }\n    // Lanterns at bow and stern, swinging on hooks against the pitch.\n    const sway = cl(-4 * (S.pitch - S.lag) + 0.15 * sin(t * 3), -0.9, 0.9);\n    [[-20, 14], [20, 18]].forEach(([lu, lw], i) => {\n      toScreen(S, lu, lw, P);\n      const hx = P[0], hy = P[1];\n      const lx = hx + 2.5 * sin(sway + S.pitch), ly = hy + 2.5 * cos(sway + S.pitch);\n      S.lamps[i] = [lx, ly];\n      for (let k = 0; k \u003c= 3; k++) plot(S, hx + (lx - hx) * (k / 3), hy + (ly - hy) * (k / 3) - 1, mr, mg, mb, A);\n    });\n    // Where St. Elmo's fire can burn: the three mast tops and the main\n    // course yard's two arms.\n    S.fires.length = 0;\n    for (const [mu, mh] of MASTS) S.fires.push(toScreen(S, mu, mh + 1, [0, 0]));\n    S.fires.push(toScreen(S, -6, 36, [0, 0]), toScreen(S, 6, 36, [0, 0]));\n  }\n\n  // The ghost light round her: her opacity blurred twice over 7 x 7 LEDs,\n  // laid on in four flat steps just outside her outline.\n  const au = S.aura, tm = S.tmp;\n  for (let i = 0; i \u003c N; i++) au[i] = sh[i * 4 + 3];\n  for (let pass = 0; pass \u003c 2; pass++) {\n    box(au, tm, W, H, W, 1);\n    box(tm, au, H, W, 1, W);\n  }\n  // The ship over the sky and far sea, under her own water.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const q = (y * W + x) * 4, a = sh[q + 3], i = y * W + x;\n      // Only outside her outline: inside a sail's holes the blur runs high.\n      if (au[i] > 0.04 && au[i] \u003c 0.5 && a \u003c 0.5 && y \u003c LAYERS[SHIP_LAYER][0] + 2) {\n        add(B, i * 3, G, (round(min(1, au[i] * 2) * 4) / 4) * 0.36 * flick);\n      }\n      if (a > 0 && layerOf(x, y) \u003c SHIP_LAYER) mix(B, i * 3, sh[q], sh[q + 1], sh[q + 2], a);\n    }\n\n  // Lantern light: halos in stepped rings and a trembling streak below.\n  const la = (0.35 + 0.65 * A) * flick;\n  if (A > 0.01)\n    for (const [lx, ly] of S.lamps) {\n      for (let y = max(0, floor(ly - 13)); y \u003c min(H, ly + 14); y++)\n        for (let x = max(0, floor(lx - 13)); x \u003c min(W, lx + 14); x++) {\n          const r = sqrt((x + 0.5 - lx) ** 2 + (y + 0.5 - ly) ** 2), p = (y * W + x) * 3;\n          const v = r \u003c 1.2 ? 1 : r \u003c 3 ? 0.42 : r \u003c 5.5 ? 0.2 : r \u003c 9 ? 0.09 : r \u003c 13 ? 0.04 : 0;\n          if (v === 1) put(B, p, 0.6 + 0.4 * G[0], 0.6 + 0.4 * G[1], 0.6 + 0.4 * G[2]);\n          else add(B, p, G, v * la);\n        }\n      const wl = LAYERS[SHIP_LAYER][0] - eta(SHIP_LAYER, lx, t, sw);\n      for (let y = round(wl) + 1; y \u003c H; y += 1) {\n        const f = (y - wl) / 30, wob = round(lx + 1.8 * sin(y * 0.8 - t * 5) * (0.5 + f));\n        if (hash(y * 17 + floor(t * 9) * 131 + round(lx)) > 0.62 - 0.2 * f) continue;\n        const v = la * 0.75 * (1 - 0.6 * cl(f, 0, 1));\n        for (let x = max(0, wob - 1); x \u003c= min(W - 1, wob + 1); x++) add(B, (y * W + x) * 3, G, x === wob ? v : v / 2);\n      }\n    }\n  // St. Elmo's fire: each point flares and dies on its own noise, a core\n  // with a flame licking upward.\n  if (A > 0.01)\n    S.fires.forEach(([fx, fy], i) => {\n      const on = vn(t * 2.6 + i * 37, i * 11) * (0.6 + 0.4 * sin(t * 17 + i * 3));\n      if (on \u003c 0.42) return;\n      const v = cl((on - 0.42) * 3, 0, 1) * (0.4 + 0.6 * A), lick = round(1 + 1.5 * vn(t * 9 + i * 5, 3));\n      const pts = [[0, 0, 1], [-1, 0, 0.45], [1, 0, 0.45], [0, 1, 0.35]];\n      for (let k = 1; k \u003c= lick; k++) pts.push([round(0.6 * sin(t * 11 + i + k)), -k, 0.7 - 0.25 * k]);\n      for (const [ox, oy, e] of pts) {\n        const x = round(fx) + ox, y = round(fy) + oy;\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        mix(B, (y * W + x) * 3, 0.5 * G[0] + 0.5, 0.5 * G[1] + 0.5, 0.5 * G[2] + 0.5, v * e);\n      }\n    });\n  // Spray off the bow.\n  for (const s of S.spray) {\n    const x = round(s.x), y = round(s.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const v = 0.85 * (1 - s.age / s.life), p = (y * W + x) * 3;\n    put(B, p, max(B[p], 0.8 * v), max(B[p + 1], 0.85 * v), max(B[p + 2], v));\n  }\n\n  // The fog bank: two octaves of rolling noise along the waterline,\n  // thickened where she has just vanished, in five flat steps.\n  const fogAmt = 0.5 + 1.4 * S.fog, gone = 1 - A, roll = 0.4 * sin(t * 0.4);\n  const [l0x, l0y] = S.lamps[0], [l1x, l1y] = S.lamps[1], lit = A > 0.01 ? 0.6 * la : 0;\n  for (let y = floor(48 - 28 * S.fog); y \u003c H; y++) {\n    const band = sm(48 - 28 * S.fog, 80 - 20 * S.fog, y) * (1 - 0.5 * sm(104, 127, y));\n    for (let x = 0; x \u003c W; x++) {\n      const n = 0.6 * vn(x * 0.045 + t * 0.4, y * 0.09 + 7) + 0.4 * vn(x * 0.13 - t * 0.8 + 3, y * 0.26 + roll);\n      let dd = band * fogAmt * (n * 2.2 - 0.75);\n      if (gone > 0) dd += gone * 0.9 * exp(-(((x - S.xs) / 18) ** 2)) * sm(30, 70, y) * (1 - sm(105, 125, y));\n      dd = round(cl(dd, 0, 0.9) * 5) / 5;\n      if (dd \u003c= 0) continue;\n      // The fog glows with the lanterns near them.\n      const r0 = round((x - l0x) ** 2 + (y - l0y) ** 2), r1 = round((x - l1x) ** 2 + (y - l1y) ** 2);\n      const gl = round(lit * ((r0 \u003c 900 ? FALL[r0] : 0) + (r1 \u003c 900 ? FALL[r1] : 0)) * 10) / 10;\n      mix(B, (y * W + x) * 3, 0.36 + G[0] * gl, 0.25 + G[1] * gl, 0.5 + G[2] * gl, dd);\n    }\n  }\n\n  for (let p = 0; p \u003c N; p++)\n    display.setPixel(p % W, floor(p / W), round(cl(B[3 * p], 0, 1) * 255), round(cl(B[3 * p + 1], 0, 1) * 255), round(cl(B[3 * p + 2], 0, 1) * 255));\n}\n","glass-patterns":"// ===== Patternflow pattern =====\n// Title:   Glass Patterns\n// Family:  noise\n// Idea:    A field of random dots is laid over three copies of itself, each moved on once more by the same small linear map T = exp(εA) about a wandering fixed point, so the eye joins every dot to its partners and reads the flow of x' = Ax, concentric circles for a rotation, spirals, rays out of a source and into a sink, hyperbolas for a saddle, while the dots shimmer, die and are dealt again and A travels a slow loop through the trace-determinant plane drawn in a strip at the top, where the axes, the parabola τ² = 4Δ and the tinted regions say which kind of picture the field below is showing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Glass patterns (Leon Glass, 1969), with the trace-determinant classification of linear systems (Henri Poincaré, 1881), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dots=320..800, Step=0..1\n//\n// Knob 1: Hue. Turns the dots round the wheel; each chain of four runs from a deep tail to a pale head, the head leading the flow. At 0 ice cyan heads over violet tails, at 0.25 violet over red, at 0.5 rose over lime, at 0.75 lime over cyan. The strip keeps its own colours: magenta for the saddles, amber for the nodes, teal for the spirals.\n// Knob 2: Speed. How fast A goes round its loop of four stops (circles, rays out, hyperbolas, rays in): at 2 a stop every 4 s and the whole loop in 16 s, each stop held for about a second, the dots riding the flow at 0.3 of its rate and living 0.9 to 1.8 s; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Dots. How many chains of four are dealt over the 64 x 104 field, one to a cell of a grid: 320 at the start (1280 dots), 440 at a quarter, 560 at half, 680 at three quarters and 800 at the end (3200 dots), where the field is so crowded that the flow starts to drown in it.\n// Knob 4: Step. The size of the map, ε in T = exp(εA): 0.012 at 0, where the four dots of a chain fall within an LED or two of each other and the flow is hidden; 0.049 at 0.06, where a chain 30 LEDs from the fixed point is about 4 LEDs long; 0.10 at 0.25, long and loose; 0.14 at 0.5, where the chains come apart; 0.21 at 1, where partners land too far apart to pair and the field is noise again.\n// Buttons: K1 tap jumps A straight on to the next stop of the loop.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, sinh, cosh, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The strip: rows 0..21 hold the (τ, Δ) plane at 10 LEDs to a unit, τ = 0 on\n// column 32 and Δ = 0 on row 15. Row 22 is a faint rule; the dots live on\n// rows 24..127.\nconst IH = 22, FY = 24, FH = H - FY;\nconst SX = 10, OX = 32, OY = 15;\nconst toX = (tau) => OX + SX * tau, toY = (det) => OY - SX * det;\n// A's loop: an ellipse round the origin of the plane, τ = 2.6 sin φ and\n// Δ = 0.425 + 0.925 cos φ. It starts at the top, a pure rotation (τ = 0,\n// Δ = 1.35); passes through the spirals; meets the parabola at φs, where A is\n// a multiple of the identity, a star node; runs through the nodes into Δ \u003c 0;\n// stops at φ = π, a pure saddle; and comes back the other side with τ \u003c 0.\nconst TA = 2.6, D0 = 0.425, DB = 0.925;\n// Where the ellipse meets τ² = 4Δ: 1.69 sin² φ = 0.425 + 0.925 cos φ, a\n// quadratic in cos φ.\nconst PHS = (() => {\n  const a = (TA * TA) / 4, c = (-DB + sqrt(DB * DB + 4 * a * (a - D0))) / (2 * a);\n  return Math.acos(c);\n})();\nconst STOPS = [0, PHS, PI, 2 * PI - PHS, 2 * PI];\nconst SEG = 4; // seconds from stop to stop at Speed 2\n// Types, as the plane's regions: 0 saddle, 1 node, 2 spiral (3 the centre,\n// the positive Δ axis, which the loop only touches).\nconst typeOf = (tau, det) => (det \u003c 0 ? 0 : tau * tau - 4 * det >= -1e-9 ? 1 : abs(tau) \u003c 1e-6 ? 3 : 2);\n// Faint tints for the regions, and the brighter one for the region A is in.\nconst TINT = [[0.16, 0.03, 0.15], [0.17, 0.09, 0.0], [0.0, 0.1, 0.15], [0.0, 0.1, 0.15]];\nconst MARK = [[1, 0.35, 0.95], [1, 0.72, 0.2], [0.3, 0.9, 1], [0.3, 0.9, 1]];\n\n// Each inset LED: its region and how much of the axes or the parabola it holds.\nconst IREG = new Uint8Array(W * IH), ILINE = new Float32Array(W * IH), IAX = new Float32Array(W * IH), IPATH = new Float32Array(W * IH);\nfor (let y = 0; y \u003c IH; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const tau = (x + 0.5 - OX) / SX, det = (OY - (y + 0.5)) / SX, i = y * W + x;\n    IREG[i] = det \u003c 0 ? 0 : tau * tau > 4 * det ? 1 : 2;\n    // Distance to the parabola, in LEDs, from the gradient of Δ - τ²/4.\n    const f = det - (tau * tau) / 4, dp = (SX * abs(f)) / sqrt(1 + (tau * tau) / 4);\n    ILINE[i] = cl(1.1 - dp, 0, 1);\n    IAX[i] = y === OY || x === OX ? 1 : 0;\n  }\n// The loop's path, dotted every 3 LEDs of its length.\nfor (let k = 0, run = 0, px = toX(0), py = toY(D0 + DB); k \u003c= 720; k++) {\n  const ph = (k / 720) * 2 * PI, x = toX(TA * sin(ph)), y = toY(D0 + DB * cos(ph));\n  run += sqrt((x - px) ** 2 + (y - py) ** 2);\n  px = x;\n  py = y;\n  const ix = floor(x), iy = floor(y);\n  if (ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c IH && run % 3 \u003c 1.2) IPATH[iy * W + ix] = 1;\n}\n\nconst MAXD = 800, CH = 4, FLOW = 0.3;\nexport function setup(params) {\n  params.s = {\n    begun: false, t: 0, u: 0, hue: 0, speed: 2, n: 0, eps: 0.05,\n    // Each chain: its cell, its first dot (anywhere a little beyond the field), its age and its life.\n    cell: new Int32Array(MAXD), gx: 1, gy: 1,\n    ax: new Float32Array(MAXD), ay: new Float32Array(MAXD), age: new Float32Array(MAXD), life: new Float32Array(MAXD),\n    // A now (row by row), its trace and determinant on the loop, its type,\n    // the fixed point and the strain's axis.\n    A: new Float64Array(4), T1: new Float64Array(4), E: new Float64Array(4), s: 0, k2: 0, M: [0, 0, 0, 0], TP: new Float64Array(4 * 8),\n    tau: 0, det: 1, type: 3, cx: 32, cy: 76, psi: 0,\n    buf: new Float32Array(W * H * 3), col: new Float32Array(24),\n  };\n}\n\n// The first dots are dealt one to a cell of a grid laid over the field and a\n// margin of 5 LEDs round it, at a random place in the cell. Pure random dots\n// clump and leave holes, and on 64 columns the clumps read as structure of\n// their own; one to a cell keeps the only structure the one the map makes.\nconst MG = 5, AW = W + 2 * MG, AH = FH + 2 * MG;\nfunction layout(S, n) {\n  const gx = max(1, round(sqrt((n * AW) / AH))), gy = Math.ceil(n / gx);\n  S.gx = gx;\n  S.gy = gy;\n  // Which cells are used when n is short of gx * gy: a shuffle.\n  const all = Array.from({ length: gx * gy }, (_, i) => i);\n  for (let i = all.length - 1; i > 0; i--) {\n    const j = floor(Math.random() * (i + 1)), t = all[i];\n    all[i] = all[j];\n    all[j] = t;\n  }\n  for (let i = 0; i \u003c n; i++) S.cell[i] = all[i];\n  for (let i = 0; i \u003c n; i++) spawn(S, i), (S.age[i] = Math.random() * S.life[i]);\n}\nfunction spawn(S, i) {\n  const c = S.cell[i], cx = c % S.gx, cy = floor(c / S.gx);\n  S.ax[i] = -MG + ((cx + Math.random()) * AW) / S.gx;\n  S.ay[i] = FY - MG + ((cy + Math.random()) * AH) / S.gy;\n  S.life[i] = 0.9 + 0.9 * Math.random();\n  S.age[i] = 0;\n}\n\n// φ from the loop clock u (one unit a stop): each stop is held while the\n// smoothstep is flat, the first and last 12% of every leg.\nfunction phiOf(u) {\n  const i = floor(u) % 4, f = u - floor(u);\n  return STOPS[i] + (STOPS[i + 1] - STOPS[i]) * sm(0.12, 0.88, f);\n}\n\n// A from its trace and determinant, as the plainest matrix with them: a\n// dilation τ/2 plus a rotation w when τ² \u003c 4Δ, plus a strain e along the\n// axis ψ when τ² > 4Δ. Scaled to unit size (τ²/4 + w² + e² = 1), which\n// keeps its type: (τ, Δ) -> (cτ, c²Δ) leaves the axes and the parabola where\n// they are. exp(tA) comes in closed form, since the traceless part M has\n// M² = (e² - w²) I: cosh and sinh of t k for a node or saddle, cos and sin\n// for a spiral or centre.\nfunction expA(S, t, out) {\n  const k2 = S.k2, M = S.M;\n  let a, b;\n  if (k2 > 1e-12) {\n    const k = sqrt(k2);\n    a = cosh(t * k);\n    b = sinh(t * k) / k;\n  } else if (k2 \u003c -1e-12) {\n    const k = sqrt(-k2);\n    a = cos(t * k);\n    b = sin(t * k) / k;\n  } else {\n    a = 1;\n    b = t;\n  }\n  const g = exp(t * S.s);\n  out[0] = g * (a + b * M[0]);\n  out[1] = g * b * M[1];\n  out[2] = g * b * M[2];\n  out[3] = g * (a + b * M[3]);\n}\nfunction build(S) {\n  const tau = S.tau, det = S.det, disc = (tau * tau) / 4 - det;\n  let w = 0, e = 0;\n  if (disc \u003c 0) w = sqrt(-disc);\n  else e = sqrt(disc);\n  const m = sqrt((tau * tau) / 4 + w * w + e * e) || 1, s = tau / 2 / m;\n  w /= m;\n  e /= m;\n  const c2 = cos(2 * S.psi), s2 = sin(2 * S.psi);\n  // M = w J + e S(ψ), J the quarter turn, S(ψ) the reflection-like strain.\n  const M = [e * c2, e * s2 - w, e * s2 + w, -e * c2];\n  const A = S.A;\n  A[0] = s + M[0];\n  A[1] = M[1];\n  A[2] = M[2];\n  A[3] = s + M[3];\n  S.s = s;\n  S.k2 = e * e - w * w;\n  S.M = M;\n  expA(S, S.eps, S.T1);\n  const T1 = S.T1, TP = S.TP;\n  // TP holds T^k for k = 0 .. CH - 1.\n  TP[0] = TP[3] = 1;\n  TP[1] = TP[2] = 0;\n  for (let k = 1; k \u003c CH; k++) {\n    const o = 4 * k, q = o - 4;\n    TP[o] = T1[0] * TP[q] + T1[1] * TP[q + 2];\n    TP[o + 1] = T1[0] * TP[q + 1] + T1[1] * TP[q + 3];\n    TP[o + 2] = T1[2] * TP[q] + T1[3] * TP[q + 2];\n    TP[o + 3] = T1[2] * TP[q + 1] + T1[3] * TP[q + 3];\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 320, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = round(cl(kv[2], 320, MAXD));\n  S.eps = 0.012 + 0.2 * Math.pow(cl(kv[3], 0, 1), 0.6);\n  // A new count lays a new grid and deals every dot again.\n  if (!S.begun || n !== S.n) {\n    layout(S, n);\n    S.n = n;\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  S.u = (S.u + ds / SEG) % 4;\n  if (input.btnPressed && input.btnPressed[0]) S.u = (floor(S.u + 0.12) + 1) % 4;\n  const ph = phiOf(S.u);\n  S.tau = TA * sin(ph);\n  S.det = D0 + DB * cos(ph);\n  S.type = typeOf(S.tau, S.det);\n  // The fixed point wanders over the middle of the field, and the strain's\n  // axis turns slowly, so the nodes and the saddle do not always line up\n  // with the LED grid.\n  S.cx = 32 + 7 * sin(0.21 * S.t + 0.4);\n  S.cy = FY + FH / 2 + 14 * sin(0.13 * S.t + 1.1);\n  S.psi = 0.5 * sin(0.07 * S.t);\n  build(S);\n  // The dynamic Glass pattern: dots die and are dealt again somewhere new,\n  // so the texture never holds still while the flow it shows stays put.\n  // The dots also ride the flow itself, at FLOW times the field's speed, so\n  // the circles turn, the rays stream and the saddle pours in along one axis\n  // and out along the other.\n  expA(S, FLOW * ds, S.E);\n  const E = S.E, cx = S.cx, cy = S.cy;\n  for (let i = 0; i \u003c S.n; i++) {\n    const rx = S.ax[i] - cx, ry = S.ay[i] - cy;\n    S.ax[i] = cx + E[0] * rx + E[1] * ry;\n    S.ay[i] = cy + E[2] * rx + E[3] * ry;\n    S.age[i] += ds;\n    if (S.age[i] >= S.life[i]) spawn(S, i);\n  }\n}\n\nfunction addDot(buf, x, y, c, o, v) {\n  const ix = floor(x), iy = floor(y);\n  if (ix \u003c 0 || ix >= W || iy \u003c FY || iy >= H) return;\n  const p = (iy * W + ix) * 3;\n  buf[p] += c[o] * v;\n  buf[p + 1] += c[o + 1] * v;\n  buf[p + 2] += c[o + 2] * v;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, C = S.col, TP = S.TP;\n  buf.fill(0);\n  // Tail to head of each chain: the head leads, so the brightness says which\n  // way the flow runs.\n  const h0 = 0.5 + S.hue;\n  for (let k = 0; k \u003c CH; k++) {\n    const u = k / (CH - 1);\n    hsv(h0 + 0.27 * (1 - u), 0.9 - 0.3 * u, 0.65 + 0.35 * u, C, 3 * k);\n  }\n  const cx = S.cx, cy = S.cy;\n  for (let i = 0; i \u003c S.n; i++) {\n    const a = S.age[i], l = S.life[i];\n    // Fade in over 0.12 s and out over 0.2 s in three steps, so a chain comes and goes softly.\n    const f = min(1, a / 0.12, (l - a) / 0.2), v = f > 0.66 ? 1 : f > 0.33 ? 0.6 : 0.3;\n    const rx = S.ax[i] - cx, ry = S.ay[i] - cy;\n    for (let k = 0, o = 0; k \u003c CH; k++, o += 4) addDot(buf, cx + TP[o] * rx + TP[o + 1] * ry, cy + TP[o + 2] * rx + TP[o + 3] * ry, C, 3 * k, v);\n  }\n  // The strip: tinted regions, the one A is in lit more, axes, the parabola,\n  // the loop dotted, and A as a bright dot with a cross in its region's colour.\n  const reg = S.type === 3 ? 2 : S.type, mk = MARK[S.type];\n  for (let y = 0; y \u003c IH; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, tn = TINT[IREG[i]], k = IREG[i] === reg ? 1.6 : 0.8;\n      let R = tn[0] * k, G = tn[1] * k, B = tn[2] * k;\n      if (IPATH[i]) (R += 0.12), (G += 0.12), (B += 0.12);\n      if (IAX[i]) (R = max(R, 0.24)), (G = max(G, 0.24)), (B = max(B, 0.3));\n      const pl = ILINE[i] * 0.55;\n      R = max(R, pl);\n      G = max(G, pl * 0.9);\n      B = max(B, pl * 0.6);\n      const p = i * 3;\n      buf[p] = R;\n      buf[p + 1] = G;\n      buf[p + 2] = B;\n    }\n  const mx = floor(toX(S.tau)), my = floor(toY(S.det));\n  for (const [dx, dy, v] of [[0, 0, 2], [1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1]]) {\n    const x = mx + dx, y = my + dy;\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= IH) continue;\n    const p = (y * W + x) * 3;\n    if (v === 2) buf[p] = buf[p + 1] = buf[p + 2] = 1;\n    else (buf[p] = mk[0]), (buf[p + 1] = mk[1]), (buf[p + 2] = mk[2]);\n  }\n  // The rule under the strip, in the colour of A's region.\n  for (let x = 0; x \u003c W; x++) {\n    const p = (IH * W + x) * 3;\n    buf[p] = mk[0] * 0.22;\n    buf[p + 1] = mk[1] * 0.22;\n    buf[p + 2] = mk[2] * 0.22;\n  }\n  for (let p = 0, q = 0; p \u003c W * H; p++, q += 3)\n    display.setPixel(p % W, floor(p / W), round(255 * min(1, buf[q])), round(255 * min(1, buf[q + 1])), round(255 * min(1, buf[q + 2])));\n}\n","howling-wolf":"// ===== Patternflow pattern =====\n// Title:   Howling Wolf\n// Family:  halloween\n// Idea:    A black wolf on a rocky crag before a huge rising moon, orange at its foot and pale gold above, lifts its muzzle and howls, throat swelling, breath puffing off on the wind and faint toxic green rings spreading from its jaws, and the small wolves on the far ridge answer one after another in a green glow, while clouds drift, a dead tree bends and the wolf breathes, flicks its ears and sways its tail.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pack=2..6, Wind=0..1\n//\n// Knob 1: Hue. The moon, its glow and the rims of light: at 0 orange rising to pale gold, at 0.25 green to mint, at 0.5 azure to ice, at 0.75 magenta to pink. Rings and glow stay toxic green.\n// Knob 2: Speed. At 2 the wolf raises its head in 0.9 s, howls 3.6 s with a ring every 0.3 s, lowers it in 1 s and howls again 3.2 to 4.8 s after the pack falls quiet; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Pack. How many far wolves answer: 2 at the start, then 3, 4, 5 and 6, four against the moon. The first comes in 1.2 s into the howl at 2 and 0.4 s at 6, the rest every 1.1 s or 0.3 s, each howling 3.3 s in a green glow with rings.\n// Knob 4: Wind. At 0 two thin clouds drift 2.5 LEDs a second and the tree barely stirs; at 0.06 they drift at 3; at 0.5 five thicker clouds at 6.8, the tree leaning; at 1 eight heavy clouds at 11, the tree bent hard.\n// Buttons: K1 tap makes the wolf howl at once (and the pack answer) unless it already is.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  for (let i = 0; i \u003c 3; i++) {\n    const k = (5 - 2 * i + 6 * (h - floor(h))) % 6;\n    out[i] = v - v * s * max(0, min(k, 4 - k, 1));\n  }\n}\n// Channels in steps of 4 of 255: no banding on the panel, flat areas stay flat.\nconst q4 = (v) => (v \u003c= 0 ? 0 : v >= 1 ? 252 : round(v * 63) * 4);\n\n// Signed distances in LEDs, negative inside, and a smooth union.\nconst circle = (px, py, cx, cy, r) => sqrt((px - cx) ** 2 + (py - cy) ** 2) - r;\nfunction capsule(px, py, ax, ay, bx, by, ra, rb) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey || 1), 0, 1);\n  return sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) - (ra + (rb - ra) * u);\n}\nconst smin = (a, b, k) => {\n  const h = cl(0.5 + (0.5 * (b - a)) / k, 0, 1);\n  return b + (a - b) * h - k * h * (1 - h);\n};\n// Blend a colour into buf at LED p by a.\nfunction mix(buf, p, r, g, b, a) {\n  const q = 3 * p;\n  buf[q] += (r - buf[q]) * a;\n  buf[q + 1] += (g - buf[q + 1]) * a;\n  buf[q + 2] += (b - buf[q + 2]) * a;\n}\n// A black silhouette covering LED p by a, with a rim of the moon's colour mc.\nconst black = (buf, mc, p, a, rim) => mix(buf, p, 0.012 + mc[3 * p] * rim, 0.008 + mc[3 * p + 1] * rim, 0.02 + mc[3 * p + 2] * rim, a);\n\n// The moon low on the horizon, its seas, its glow, and per row its blend\n// from orange at the foot (0) to gold near the top (1).\nconst MX = 33, MY = 55, MR = 26;\nconst SEAS = [[-8, -8, 6, 5], [7, -11, 5, 4], [10, 3, 6, 6], [-11, 6, 5, 6], [1, 12, 6, 4], [-3, -1, 3, 3]];\nconst MOONT = new Float32Array(N), GLOW = new Float32Array(N), MROW = new Float32Array(H);\nfor (let p = 0; p \u003c N; p++) {\n  const dx = (p % W) + 0.5 - MX, dy = floor(p / W) + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n  if (r \u003c MR + 1) {\n    let e = 9;\n    for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2 + 0.25 * sin(dx + dy));\n    MOONT[p] = (e \u003c 1 ? 0.86 : e \u003c 1.6 ? 0.93 : 1) * cl(MR + 0.5 - r, 0, 1);\n  }\n  const out = max(0, r - MR);\n  GLOW[p] = round((0.3 * exp(-out / 4) + 0.1 * exp(-out / 14)) * 16) / 16;\n}\nfor (let y = 0; y \u003c H; y++) MROW[y] = sm(MY + MR, MY - MR * 0.6, y + 0.5);\n// Stars: [LED, twinkle phase], clear of the moon.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 22; i++) {\n  const x = floor(hash(i * 3 + 1) * W), y = floor(2 + hash(i * 3 + 2) * 62);\n  if ((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2 > (MR + 5) ** 2) STARS.push([y * W + x, hash(i * 3 + 3) * 6.28]);\n}\n\n// Three far ridges as the row of their crest in each column, the far one\n// across the moon's foot; the wolf's crag ends in a cliff at x = 42.\nconst R = [new Float32Array(W), new Float32Array(W), new Float32Array(W)], CRAG = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) {\n  R[0][x] = 79.5 + 3 * sm(44, 64, x) - 2 * sm(12, 0, x) + 1.1 * sin(x * 0.45) + 0.6 * sin(x * 1.3 + 2);\n  R[1][x] = 94 - 3 * sm(46, 64, x) + 1.4 * sin(x * 0.55 + 1) + 0.6 * sin(x * 1.6);\n  R[2][x] = 110 - 2 * sm(44, 64, x) + 1.6 * sin(x * 0.4 + 2) + 0.6 * sin(x * 1.4);\n  CRAG[x] = x \u003c 42 ? 104 - 1.1 * sin(x * 0.7) - 0.7 * sin(x * 1.9 + 1) - 2.5 * sm(10, 0, x) : 104 + (x - 42) * 3.2 + 1.4 * sin(x * 2.1);\n}\nconst RC = [[0.17, 0.062, 0.25], [0.095, 0.034, 0.15], [0.05, 0.018, 0.085]], ROCK = [0.012, 0.008, 0.022];\n// The ridge in front at each LED (-1 none), and the crag (2 on its top).\nconst RIDX = new Int8Array(N).fill(-1), CRG = new Uint8Array(N);\nfor (let p = 0; p \u003c N; p++) {\n  const x = p % W, py = floor(p / W) + 0.5;\n  for (let i = 0; i \u003c 3; i++) if (py > R[i][x]) RIDX[p] = i;\n  if (py > CRAG[x]) CRG[p] = py - CRAG[x] \u003c 1.2 ? 2 : 1;\n}\n\n// The far wolves, [x of their feet, ridge], in the order they answer, a\n// shade darker than their ridge, facing left.\nconst PACK = [[26, 0], [57, 0], [49, 0], [17, 0], [56, 1], [8, 0]];\nconst FC = [[0.075, 0.026, 0.12], [0.035, 0.012, 0.06]];\n// A far wolf facing right, standing and howling.\nconst FAR = [\n  [\".........\", \".........\", \"......#..\", \".....####\", \".######..\", \"#######..\", \"##.#..##.\", \".#.#...#.\"],\n  [\".......#.\", \"......##.\", \".....##..\", \"....###..\", \".#####...\", \"#######..\", \"##.#..##.\", \".#.#...#.\"],\n];\n// The glow round a howling far wolf: offsets within 5 LEDs, with weights.\nconst KERN = [];\nfor (let dy = -5; dy \u003c= 5; dy++) for (let dx = -5; dx \u003c= 5; dx++) if (dx * dx + dy * dy \u003c= 26) KERN.push([dx, dy, exp(-sqrt(dx * dx + dy * dy) / 2.2)]);\n\n// The dead tree as branches [parent, length, angle from the parent\n// (clockwise from up), base and tip radius].\nconst TREE = [\n  [-1, 13, 0.06, 2.2, 1.6], [0, 11, -0.1, 1.6, 1.1], [1, 9, 0.3, 1.1, 0.75], [2, 7, 0.35, 0.75, 0.5],\n  [1, 7, -0.7, 0.9, 0.55], [4, 5, -0.35, 0.55, 0.4], [0, 9, 0.95, 1.0, 0.55], [6, 6, 0.45, 0.55, 0.4],\n  [2, 6, -0.6, 0.65, 0.4], [3, 5, 0.95, 0.5, 0.35], [6, 4, -0.5, 0.5, 0.35], [7, 4, 0.7, 0.4, 0.3],\n];\nconst TREEX = 4, TREEY = 104;\n// Clouds: [row, length, where on its lap it starts].\nconst CLOUDS = [[66, 30, 0.47], [40, 26, 0.3], [52, 34, 0.85], [28, 24, 0.62], [72, 28, 0.12], [46, 36, 0.05], [60, 30, 0.7], [34, 28, 0.95]];\nconst CST = new Float64Array(15), RING = [1, 0.45, 0.2];\n\n// The wolf is laid out with paws on row 101 and drawn at 0.8 size, (30, 101) on (26, 104).\nconst SC = 0.8, AX = 30, AY = 101, WX = 26, WY = 104;\nconst L1 = 0.9, L2 = 3.6, L3 = 1.0, F1 = 0.3, F2 = 2.6, F3 = 0.4;\n// How far a head is up at age a of a howl: up in u s, held h s, down in w s.\nconst env = (a, u, h, w) => (a \u003c 0 ? 0 : sm(0, u, a) - sm(u + h, u + h + w, a));\nconst farLift = (a) => env(a, F1, F2, F3);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, pack: 2, wind: 0.06, cloudX: 0,\n    // The howl's age (-1 none), the wait for the next, ring and breath clocks.\n    howl: -1, wait: 0.05, ring: 0, puff: 0, lift: 0,\n    // Each far wolf: wait, howl age (-1 none), ring clock, first ring still to go.\n    fs: new Float32Array(6).fill(-1), fh: new Float32Array(6).fill(-1), fr: new Float32Array(6), fc: new Uint8Array(6),\n    rings: [], vap: [], earAge: [9, 9], earWait: [2.2, 3.6],\n    buf: new Float32Array(N * 3), bg: new Float32Array(N * 3), mc: new Float32Array(N * 3), bgHue: -1,\n    sil: new Float32Array(N), wd: new Float32Array(N), glow: new Float32Array(N), tree: new Float32Array(N),\n    moon: [0, 0, 0], gold: [0, 0, 0], tb: [0, 0, 0, 0], tail: new Float32Array(20), seg: new Float32Array(TREE.length * 6),\n  };\n}\n\n// The head: centre and muzzle angle (0 level, negative up).\nconst headPose = (S, l = S.lift) => ({ hx: 46.5 - 1.2 * l, hy: 76 - 4.5 * l, a: 0.2 - 1.32 * l });\n\n// A ring: place, heading, half width, speed, strength, reach, depth, pack's.\nconst ring = (x, y, a, w, v, s, lim, rows, far) => ({ x, y, r: 1.5, a, w, v, s, lim, rows, far });\n\nfunction startHowl(S) {\n  S.howl = 0;\n  S.ring = 0.05;\n  S.puff = 0;\n  // A bigger pack comes in sooner and closer together.\n  for (let k = 0; k \u003c 6; k++) (S.fs[k] = 1.6 - 0.2 * S.pack + (2.4 / S.pack - 0.1) * k + 0.1 * Math.random()), (S.fh[k] = -1);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.pack = round(cl(kv[2], 2, 6));\n  S.wind = cl(kv[3], 0, 1);\n  const ds = (d * S.speed) / 2, wv = 2.5 + 8.5 * S.wind;\n  S.t += ds;\n  S.cloudX += ds * wv;\n  if (input.btnPressed && input.btnPressed[0] && S.howl \u003c 0) startHowl(S);\n  if (S.howl >= 0) {\n    S.howl += ds;\n    // Rings and breath leave the nose tip while it holds the note.\n    const hp = headPose(S), ca = cos(hp.a), sa = sin(hp.a);\n    const nx = WX + (hp.hx + 9.8 * ca - 0.5 * sa - AX) * SC, ny = WY + (hp.hy + 9.8 * sa + 0.5 * ca - AY) * SC;\n    if (S.howl > L1 && S.howl \u003c L1 + L2) {\n      if ((S.ring -= ds) \u003c= 0) (S.ring += 0.3), S.rings.push(ring(nx, ny, hp.a, 1.45, 18, 0.9, 62, 3, 0));\n      if ((S.puff -= ds) \u003c= 0) (S.puff += 0.22), S.vap.push({ x: nx, y: ny, vx: 5 * ca, vy: 5 * sa, age: 0, life: 1.5 + 0.6 * Math.random() });\n    }\n    if (S.howl > L1 + L2 + L3) (S.howl = -1), (S.wait = 1e9);\n  }\n  // The pack, counted from the start of the main howl.\n  let busy = false;\n  for (let k = 0; k \u003c 6; k++) {\n    if (k >= S.pack) S.fs[k] = S.fh[k] = -1;\n    if (S.fs[k] >= 0 && (busy = true) && (S.fs[k] -= ds) \u003c 0) (S.fh[k] = 0), (S.fr[k] = 0), (S.fc[k] = 1);\n    if (S.fh[k] \u003c 0) continue;\n    busy = true;\n    S.fh[k] += ds;\n    if (S.fh[k] > F1 && S.fh[k] \u003c F1 + F2 && (S.fr[k] -= ds) \u003c= 0) {\n      S.fr[k] += 0.45;\n      const [fx, ridge] = PACK[k], x = fx - 3.5, y = round(R[ridge][fx]) - 6.5;\n      S.rings.push(ring(x, y, -1.92, 1.5, 10, 0.85, 28, 2, 1));\n      // The first note of each answer carries: one wide, faint ring.\n      if (S.fc[k]) S.rings.push(ring(x, y, -1.77, 1.6, 24, 0.55, 64, 2, 1)), (S.fc[k] = 0);\n    }\n    if (S.fh[k] > F1 + F2 + F3) S.fh[k] = -1;\n  }\n  // The next howl 3.2 to 4.8 s after the pack has done.\n  if (S.howl \u003c 0 && !busy) {\n    if (S.wait > 100) S.wait = 3.2 + 1.6 * Math.random();\n    if ((S.wait -= ds) \u003c= 0) startHowl(S);\n  }\n  S.lift = env(S.howl, L1, L2, L3);\n  // Rings spread; breath drifts off on the wind, rising.\n  for (const r of S.rings) r.r += r.v * ds;\n  S.rings = S.rings.filter((r) => r.r \u003c r.lim);\n  for (const v of S.vap) {\n    const e = min(1, ds * 1.5);\n    v.age += ds;\n    v.x += (v.vx += (wv * 0.9 - v.vx) * e) * ds;\n    v.y += (v.vy += (-1.6 - v.vy) * e) * ds;\n  }\n  S.vap = S.vap.filter((v) => v.age \u003c v.life);\n  for (let i = 0; i \u003c 2; i++) {\n    S.earAge[i] += ds;\n    if ((S.earWait[i] -= ds) \u003c= 0) (S.earAge[i] = 0), (S.earWait[i] = 1.8 + 3.5 * Math.random());\n  }\n}\n\n// The tail's joints: it hangs, sways and lifts a little in the howl; tb boxes it.\nfunction tailPose(S) {\n  const T = S.tail, tb = S.tb, t = S.t;\n  let x = 19.4, y = 81.5, a = 2.0 - 0.25 * S.lift;\n  const sw = 0.16 * sin(t * ((2 * PI) / 3.4)), w = 0.07 * sin(t * ((2 * PI) / 1.7) + 1);\n  tb[0] = tb[1] = 1e9;\n  tb[2] = tb[3] = -1e9;\n  for (let i = 0; i \u003c= 9; i++) {\n    T[2 * i] = x;\n    T[2 * i + 1] = y;\n    (tb[0] = min(tb[0], x - 5)), (tb[1] = min(tb[1], y - 5)), (tb[2] = max(tb[2], x + 5)), (tb[3] = max(tb[3], y + 5));\n    a += 0.07 + sw * (0.4 + i / 9) * 0.5 + (w * i) / 9;\n    x += cos(a) * 1.75;\n    y += sin(a) * 1.75;\n  }\n}\nconst tailR = (u) => 1.3 + 2.1 * sin(PI * min(1, u * 1.1) ** 0.8) * (0.55 + 0.45 * u);\n\n// Legs [from, to, radii, blend (0 plain)]: front near and far (forearm, cannon,\n// paw), hind near and far (thigh, shin back to the hock, foot, paw).\nconst LEGS = [\n  [[39.6, 87, 40.4, 95, 2.6, 1.6, 1.5], [40.4, 95, 40.8, 100.2, 1.5, 1.25, 0], [40.6, 100.3, 43, 100.5, 1.1, 1, 0],\n    [35.8, 88, 35.6, 95, 2.1, 1.3, 1], [35.6, 95, 35.4, 100.2, 1.25, 1.1, 0], [35.2, 100.3, 37.4, 100.5, 1, 0.95, 0]],\n  [[23.5, 84, 26, 91.5, 4.8, 2.4, 1.5], [26, 91.5, 21.6, 96.2, 2, 1.4, 0.8], [21.6, 96.2, 22.4, 100.2, 1.3, 1.15, 0], [22.2, 100.3, 24.6, 100.5, 1.05, 1, 0],\n    [27.5, 85.5, 29.5, 91.5, 3.2, 1.8, 1], [29.5, 91.5, 25.8, 96.2, 1.6, 1.2, 0.6], [25.8, 96.2, 26.4, 100.2, 1.15, 1.05, 0], [26.2, 100.3, 28.4, 100.5, 0.95, 0.9, 0]],\n];\n// The wolf, facing right; info gets the head's frame (u along the muzzle, v down) for the eye.\nfunction wolfDist(S, px, py, hp, info) {\n  const l = S.lift, br = sin(S.t * ((2 * PI) / 2.8)) * (1 - l);\n  // Body: the chest rises and falls with the breath.\n  let d = capsule(px, py, 24, 83.5, 37, 82.8 - 0.2 * br, 5, 6.2);\n  d = smin(d, circle(px, py, 39, 85 - 0.3 * br, 6.2 + 0.3 * br), 2.5);\n  d = smin(d, circle(px, py, 22.5, 83, 5), 1.5);\n  // Legs, below row 78: the front pair right of column 33, the hind pair left.\n  if (py > 78)\n    for (const [ax, ay, bx, by, ra, rb, k] of LEGS[px > 33 ? 0 : 1]) {\n      const c = capsule(px, py, ax, ay, bx, by, ra, rb);\n      d = k ? smin(d, c, k) : min(d, c);\n    }\n  // The tail, a bushy chain from the rump.\n  const T = S.tail, tb = S.tb;\n  if (px > tb[0] && px \u003c tb[2] && py > tb[1] && py \u003c tb[3])\n    for (let i = 0; i \u003c 9; i++) d = smin(d, capsule(px, py, T[2 * i], T[2 * i + 1], T[2 * i + 2], T[2 * i + 3], tailR(i / 9), tailR((i + 1) / 9)), 1.2);\n  // Neck and throat; the throat swells while it howls.\n  const ca = cos(hp.a), sa = sin(hp.a), hx = hp.hx, hy = hp.hy, sw = l > 0.9 ? 0.8 + 0.4 * sin(S.howl * 9) : l * 0.8;\n  d = smin(d, capsule(px, py, 37, 81.5, hx - 0.5 * ca, hy - 0.5 * sa, 5.2, 4), 2);\n  d = smin(d, capsule(px, py, 41.5, 87, hx + 1.2 * ca - 3.2 * sa, hy + 1.2 * sa + 3.2 * ca, 3.2 + 0.4 * sw, 2.2 + 1.1 * sw), 2);\n  // The ruff down the front of the neck, a row of tufts.\n  if (d \u003c 2.5 && d > -2.5 && px > 36 && py \u003c 90 && px \u003c hx + 4) d -= 0.7 * max(0, 1 - 2.6 * abs((((px + py * 0.6) / 2.3) % 1) - 0.5));\n  // The head in its own frame: skull, cheek, muzzle.\n  const qx = px - hx, qy = py - hy, u = qx * ca + qy * sa, v = -qx * sa + qy * ca;\n  info.u = u;\n  info.v = v;\n  if (u > 14 || u \u003c -10 || v > 9 || v \u003c -12) return d;\n  let dh = smin(circle(u, v, 0, 0, 4.2), circle(u, v, 1.8, 1.5, 3.2), 1.5);\n  dh = smin(dh, capsule(u, v, 2.5, -0.5, 9.4, 0.8, 2.3, 1.2), 1.2);\n  // The lower jaw drops while it howls, opening the mouth.\n  const jw = 0.32 * sm(L1, L1 + 0.3, S.howl) * (S.howl \u003c L1 + L2 ? 1 : 1 - sm(L1 + L2, L1 + L2 + 0.4, S.howl));\n  const jc = cos(jw), js = sin(jw);\n  dh = smin(dh, capsule(2.5 + (u - 2.5) * jc + (v - 2.2) * js, 2.2 - (u - 2.5) * js + (v - 2.2) * jc, 2.5, 2.2, 8.4, 2.4, 1.5, 0.8), 0.8);\n  // Ears, the far one behind: laid back in the howl, each flicking now and then.\n  for (let i = 0; i \u003c 2; i++) {\n    const ag = S.earAge[i], back = 0.3 * l + (ag \u003c 0.25 ? 0.45 * sin((PI * ag) / 0.25) : 0) + (i ? 0 : 0.15);\n    const bx = i ? -0.2 : -2.5, by = i ? -3.6 : -3.3, ec = cos(back), es = sin(back);\n    dh = min(dh, capsule(bx + (u - bx) * ec + (v - by) * es, by - (u - bx) * es + (v - by) * ec, bx + 0.2, by + 0.3, bx - 0.2, by - 4.8, 1.7, 0.15));\n  }\n  return min(d, dh);\n}\n\n// The tree's branches: a lean in the wind plus gusts, more the higher the branch.\nfunction treePose(S) {\n  const seg = S.seg, t = S.t, wind = S.wind, lean = (0.03 + 0.3 * wind) * (0.4 + 0.6 * (0.5 + 0.5 * sin(t * 1.3) * sin(t * 0.47 + 1)));\n  for (let i = 0; i \u003c TREE.length; i++) {\n    const [par, len, ang] = TREE[i], o = par * 6;\n    const x0 = par \u003c 0 ? TREEX : seg[o + 2], y0 = par \u003c 0 ? TREEY : seg[o + 3], depth = par \u003c 0 ? 0 : seg[o + 5] + 1;\n    const a = (par \u003c 0 ? 0 : seg[o + 4]) + ang + lean * (0.5 + depth * 0.5) + 0.03 * (1 + 2 * wind) * sin(t * 2.3 + i * 1.7) * depth;\n    seg.set([x0, y0, x0 + sin(a) * len, y0 - cos(a) * len, a, depth], i * 6);\n  }\n}\n\n// Sky, moon, ridges and crag, kept until Hue moves; mc is the moon's colour\n// at each LED, for the rims of light.\nfunction background(S) {\n  const bg = S.bg, mc = S.mc, M = S.moon, G = S.gold;\n  for (let p = 0; p \u003c N; p++) {\n    const x = p % W, y = floor(p / W), k = MROW[y], gl = GLOW[p], mt = MOONT[p];\n    const mr = M[0] + (G[0] - M[0]) * k, mg = M[1] + (G[1] - M[1]) * k, mb = M[2] + (G[2] - M[2]) * k;\n    mc.set([mr, mg, mb], 3 * p);\n    // The sky in ten steps, near black at the top and purple at the horizon.\n    const t = round(10 * sm(0, 86, y)) / 10;\n    let r = 0.025 + 0.2 * t + mr * gl * 0.8, g = 0.01 + 0.055 * t + mg * gl * 0.8, b = 0.06 + 0.24 * t + mb * gl * 0.8;\n    r += (mr * mt - r) * mt;\n    g += (mg * mt - g) * mt;\n    b += (mb * mt - b) * mt;\n    if (RIDX[p] >= 0) [r, g, b] = RC[RIDX[p]];\n    if (CRG[p]) {\n      // Black rock: moonlit top and cliff edges, faint slanting ledges.\n      const top = CRG[p] === 2, ledge = !top && (x * 0.45 + y + 3 * hash(floor(x / 6))) % 9 \u003c 1;\n      const lit = top ? 0.22 : x >= 41 && !CRG[p - 1] ? 0.14 : ledge ? 0.05 : 0, f = top || ledge ? 1 : 0;\n      [r, g, b] = [ROCK[0] + 0.03 * f + mr * lit, ROCK[1] + 0.012 * f + mg * lit * 0.7, ROCK[2] + 0.04 * f + mb * lit * 0.4];\n    }\n    bg.set([r, g, b], 3 * p);\n  }\n}\n\n// Rings of sound: arcs about the muzzle's line, fading as they spread and\n// toward their ends, mixed towards toxic green (not added) so they show on\n// the moon too. far picks the pack's rings or the wolf's own.\nfunction rings(S, buf, far) {\n  for (const rg of S.rings) {\n    if (rg.far !== far) continue;\n    const fade = (1 - rg.r / rg.lim) * rg.s, steps = max(6, round(rg.r * rg.w * 1.6));\n    for (let j = 0; j \u003c rg.rows; j++) {\n      const rr = rg.r - j;\n      if (rr \u003c 0.5) continue;\n      for (let i = -steps; i \u003c= steps; i++) {\n        const u = i / steps, a = rg.a + u * rg.w, ix = floor(rg.x + rr * cos(a)), iy = floor(rg.y + rr * sin(a));\n        if (ix >= 0 && ix \u003c W && iy >= 0 && iy \u003c H) mix(buf, iy * W + ix, 0.3, 0.95, 0.22, fade * (1 - u * u) * 0.7 * RING[j]);\n      }\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const buf = S.buf, sil = S.sil, wd = S.wd, mc = S.mc, glow = S.glow, tree = S.tree, wind = S.wind;\n  if (S.bgHue !== S.hue) {\n    // The moon: orange at its foot, pale gold at the top.\n    hsv(0.07 + S.hue, 0.85, 1, S.moon);\n    hsv(0.12 + S.hue, 0.42, 1, S.gold);\n    background(S);\n    S.bgHue = S.hue;\n  }\n  buf.set(S.bg);\n  for (const [p, ph] of STARS) {\n    const v = 0.22 + 0.22 * sin(S.t * 2.4 + ph), q = 3 * p;\n    buf[q] = max(buf[q], v);\n    buf[q + 1] = max(buf[q + 1], v);\n    buf[q + 2] = max(buf[q + 2], v * 1.15);\n  }\n  // Clouds: two or three ragged strands each, slowly boiling, purple, their\n  // edges lit where the moon is behind.\n  const nc = 2 + round(6 * wind), thick = 1.05 + 1.1 * wind, st = CST;\n  for (let i = 0; i \u003c nc; i++) {\n    const [cy0, len0, ph] = CLOUDS[i], len = len0 * (0.85 + 0.8 * wind), span = W + len + 20;\n    const x0 = ((S.cloudX * (0.85 + 0.3 * hash(i + 40)) + ph * span) % span) - len - 15, cy = cy0 + 1.5 * sin(S.t * 0.2 + i), ns = 2 + (i % 2);\n    for (let j = 0; j \u003c ns; j++) {\n      const h1 = hash(i * 17 + j), h3 = hash(i * 17 + j + 11);\n      st.set([x0 + (h1 - 0.3) * len * 0.35, len * (0.55 + 0.45 * hash(i * 17 + j + 5)), cy + j * 2.8 - 2 + h3, thick * (1.1 + 1.5 * h3), h1 * 6.28], 5 * j);\n    }\n    for (let y = max(0, floor(cy - 14)); y \u003c min(90, cy + 14); y++)\n      for (let x = max(0, floor(x0 - 10)); x \u003c min(W, x0 + len * 1.3); x++) {\n        const p = y * W + x;\n        if (RIDX[p] >= 0) continue;\n        const px = x + 0.5, py = y + 0.5, lx = px - x0;\n        let dc = 1e9;\n        for (let o = 0; o \u003c 5 * ns; o += 5) {\n          const u = (px - st[o]) / st[o + 1], sd = st[o + 4], dy = abs(py - st[o + 2]);\n          if (u \u003c= 0 || u >= 1 || dy - st[o + 3] > 1) continue;\n          dc = min(dc, dy - st[o + 3] * sin(PI * u) ** 0.6 * (0.75 + 0.2 * sin(lx * 0.8 + sd) + 0.15 * sin(lx * 1.9 + 2 * sd + S.t * 0.9)));\n        }\n        const cov = cl(0.5 - dc, 0, 1);\n        if (cov \u003c= 0) continue;\n        const near = min(1, GLOW[p] * 1.5 + MOONT[p]), rim = dc > -1 ? near * 0.4 : 0;\n        mix(buf, p, 0.13 + 0.07 * near + mc[3 * p] * rim, 0.045 + 0.03 * near + mc[3 * p + 1] * rim * 0.8, 0.2 + 0.07 * near + mc[3 * p + 2] * rim * 0.6, cov * 0.92);\n      }\n  }\n  // The far wolves, a green glow kindling round each one that howls.\n  glow.fill(0);\n  const fw = [];\n  for (let k = 0; k \u003c S.pack; k++) {\n    const g = 0.6 * farLift(S.fh[k]), [fx, ridge] = PACK[k], top = round(R[ridge][fx]) - 7, bm = FAR[g > 0.3 ? 1 : 0];\n    for (let q = 0; q \u003c 72; q++) {\n      const x = fx + 3 - (q % 9), y = top + floor(q / 9);\n      if (bm[floor(q / 9)][q % 9] !== \"#\" || x \u003c 0 || x >= W) continue;\n      fw.push([y * W + x, ridge]);\n      if (g > 0.01) for (const [dx, dy, w] of KERN) if (x + dx >= 0 && x + dx \u003c W) glow[(y + dy) * W + x + dx] = max(glow[(y + dy) * W + x + dx], g * w);\n    }\n  }\n  for (let p = 60 * W; p \u003c 100 * W; p++) if (glow[p] > 0) mix(buf, p, 0.3, 0.95, 0.22, glow[p]);\n  for (const [p, ridge] of fw) buf.set(FC[ridge], 3 * p);\n  // Their rings go behind the tree and the wolf.\n  rings(S, buf, 1);\n  // The tree, black with moonlight on its upper edges.\n  tailPose(S);\n  treePose(S);\n  const seg = S.seg;\n  tree.fill(0);\n  for (let i = 0; i \u003c TREE.length; i++) {\n    const [x0, y0, x1, y1] = seg.subarray(i * 6, i * 6 + 4), [, , , r0, r1] = TREE[i];\n    for (let y = max(0, floor(min(y0, y1) - r0 - 1)); y \u003c= floor(max(y0, y1) + r0 + 1); y++)\n      for (let x = max(0, floor(min(x0, x1) - r0 - 1)); x \u003c= floor(max(x0, x1) + r0 + 1); x++)\n        tree[y * W + x] = max(tree[y * W + x], cl(0.5 - capsule(x + 0.5, y + 0.5, x0, y0, x1, y1, r0, r1), 0, 1));\n  }\n  for (let p = 30 * W; p \u003c 105 * W; p++) {\n    const tc = tree[p], rim = tc \u003c 0.99 || tree[p - W] \u003c 0.5 ? 0.45 * (1 - MOONT[p]) * min(1, GLOW[p] * 2 + 0.3) : 0;\n    if (tc > 0) black(buf, mc, p, tc, rim);\n  }\n  // The wolf: blocks of 4 x 4 clear of it or deep inside are settled at\n  // once; only edge blocks and the eye's are worked out LED by LED.\n  const hp = headPose(S), info = { u: 0, v: 0 }, eyeOpen = 1 - sm(0.15, 0.5, S.lift);\n  const eyeX = WX + (hp.hx + 1.3 * cos(hp.a) + 0.9 * sin(hp.a) - AX) * SC, eyeY = WY + (hp.hy + 1.3 * sin(hp.a) - 0.9 * cos(hp.a) - AY) * SC;\n  const lx = (x) => AX + (x - WX) / SC, ly = (y) => AY + (y - WY) / SC;\n  sil.fill(0);\n  wd.fill(9);\n  for (let by = 64; by \u003c 108; by += 4)\n    for (let bx = 4; bx \u003c 52; bx += 4) {\n      const dc = wolfDist(S, lx(bx + 2), ly(by + 2), hp, info) * SC, nearEye = abs(bx + 2 - eyeX) \u003c 5 && abs(by + 2 - eyeY) \u003c 5;\n      if (dc > 5 && !nearEye) continue;\n      for (let y = by; y \u003c by + 4; y++)\n        for (let x = bx; x \u003c bx + 4; x++) {\n          const p = y * W + x;\n          const dd = dc \u003c -5 && !nearEye ? -9 : wolfDist(S, lx(x + 0.5), ly(y + 0.5), hp, info) * SC;\n          wd[p] = dd;\n          sil[p] = cl(0.5 - dd, 0, 1);\n          // The eye, a toxic green glint, shut while it howls.\n          if (dd \u003c -0.5 && eyeOpen > 0.1 && ((info.u - 1.3) / 1.15) ** 2 + ((info.v + 0.9) / (0.8 * eyeOpen)) ** 2 \u003c 1) sil[p] = -1;\n        }\n    }\n  for (let y = 64; y \u003c 108; y++)\n    for (let x = 4; x \u003c 52; x++) {\n      const p = y * W + x, sv = sil[p];\n      if (sv \u003c 0) buf.set([0.45, 1, 0.25], 3 * p);\n      if (sv \u003c= 0) continue;\n      // Moonlight rims edges facing up, half the sides, none on the moon's face.\n      const up = sil[p - W], side = min(sil[p - 1], sil[p + 1]);\n      const edge = wd[p] > -1.1 ? (up \u003c 0.5 && up >= 0 ? 1 : side \u003c 0.5 && side >= 0 ? 0.55 : 0.2) : 0;\n      black(buf, mc, p, sv, edge * (1 - 0.85 * MOONT[p]) * min(1, GLOW[p] * 2.2 + 0.25) * 0.8);\n    }\n  // Breath: pale puffs that swell and fade as they drift.\n  for (const v of S.vap) {\n    const f = 1 - v.age / v.life, a = 0.34 * f * f, rr = 3.2 - 2.4 * f;\n    for (let y = max(0, floor(v.y - rr - 1)); y \u003c= min(H - 1, floor(v.y + rr + 1)); y++)\n      for (let x = max(0, floor(v.x - rr - 1)); x \u003c= min(W - 1, floor(v.x + rr + 1)); x++) {\n        const c = cl(rr + 0.5 - sqrt((x + 0.5 - v.x) ** 2 + (y + 0.5 - v.y) ** 2), 0, 1) * a;\n        if (c > 0) mix(buf, y * W + x, 0.85, 0.8, 0.95, c);\n      }\n  }\n  // The wolf's own rings, in front of everything.\n  rings(S, buf, 0);\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), q4(buf[3 * p]), q4(buf[3 * p + 1]), q4(buf[3 * p + 2]));\n}\n","lantern-procession":"// ===== Patternflow pattern =====\n// Title:   Lantern Procession\n// Family:  halloween\n// Idea:    On a black night a line of hooded walkers with lanterns hung from crooked staffs winds up a path from the foot of the panel to a hilltop near the top, smaller and dimmer the further they go, each lantern a soft warm halo swinging with its walker's steps and each dark robe rimmed with its light and standing in a pool of glowing mist, while now and then a gust runs up the line ducking the flames, a lantern gutters out and a cold green ghost-lantern walks on in its place with a faint green figure under it, and the walkers at the top fade into the fog.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Walkers=8..24, Fog=0..1\n//\n// Knob 1: Hue. The colour of the lanterns and of the light they throw, the ghost-lanterns a quarter of the way on round the wheel. At 0 amber lanterns and green ghosts; at 0.25 lime lanterns and cyan ghosts, at 0.31 the living lanterns themselves ghost green, at 0.5 aqua with violet ghosts, at 0.75 blue with pink ghosts and at 1 violet with orange ones.\n// Knob 2: Speed. At 2 a walker climbs the whole path in 28 s at about 1.8 steps a second, its lantern swinging once every two steps; a gust runs up the line every 7 to 11 s and a lantern gutters every 6 to 10 s, flickering down for 1.4 s, dark for 0.9 s and lit again as a ghost over 0.6 s. At 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Walkers. How many walk the path, 8 to 24, spread evenly along it, so 8 put seven or eight lanterns in view at once, 16 about fifteen and 24 a close line of 21 or 22 from the foot to the top; a walker is 23 LEDs tall near the foot and 6 at the hilltop. At most a quarter of them are ghosts at once, and a ghost that goes over the top comes round again at the foot with a living lantern.\n// Knob 4: Fog. At 0 the night is clear: a lantern near the hilltop keeps 74% of its light and the glow in the air round each lantern spreads 0.42 of its walker's height. At 0.06 the hilltop lanterns keep 65% and faint banks start to drift across. At 1 they keep 9% and are lost, every glow spreads 60% wider and shines twice as bright, the pools of mist on the ground more than twice, and a drifting haze stands in front of the whole procession, thickest up the hill.\n// Buttons: K1 tap turns the nearest lantern wholly in view into a ghost: it gutters for 0.4 s, is dark for 0.3 s and lights green.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, round, min, max, abs, exp, log, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The path in perspective. A walker's place on it is u, 0 at the foot of\n// the panel and 1 at the hilltop; it stands 1 + PK*u times further off than\n// at the foot, so it is that much smaller, and its feet are at pathY(u),\n// which runs from row Y0 (just under the panel) to row 18 at u = 1.\nconst Y0 = 134, YK = 68, PK = 4.5, SPAN = 1.16, UIN = -0.12;\nconst depth = (u) => 1 + PK * max(0, u);\nconst pathY = (u) => (u \u003c 0 ? Y0 - YK * PK * u : Y0 - YK * log(1 + PK * u));\nconst pathX = (u) => 32 + (23 * sin(2 * PI * 1.55 * u + 0.45) - 3) / depth(u) + 2;\nconst uOfY = (y) => (exp((Y0 - y) / YK) - 1) / PK;\n// A walker's height in LEDs at the foot of the panel.\nconst TALL = 34;\n// The ridge the path goes over, row by row across the panel.\nconst CREST = pathY(1);\nconst ridge = (x) => CREST - 0.6 + 0.0045 * (x - pathX(1)) ** 2 + 0.9 * sin(x * 0.19 + 1.3);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// A hooded robe seen from behind: half its width at heights 0 (the hem) to\n// 1 (the hood's point), in walker heights.\nconst PROF_T = [0, 0.05, 0.4, 0.62, 0.69, 0.75, 0.83, 0.9, 0.96, 1];\nconst PROF_W = [0.23, 0.235, 0.19, 0.195, 0.165, 0.12, 0.135, 0.115, 0.055, 0];\nfunction prof(t) {\n  if (t \u003c= 0 || t >= 1) return t \u003c= 0 ? PROF_W[0] : 0;\n  let i = 1;\n  while (PROF_T[i] \u003c t) i++;\n  const a = (t - PROF_T[i - 1]) / (PROF_T[i] - PROF_T[i - 1]);\n  return PROF_W[i - 1] + (PROF_W[i] - PROF_W[i - 1]) * a;\n}\n\n// Lantern states: lit, guttering, out, ghost.\nconst LIT = 0, GUTTER = 1, OUT = 2, GHOST = 3;\n\nfunction walker(u) {\n  return {\n    u, side: Math.random() \u003c 0.5 ? -1 : 1, ph: Math.random() * 2, jx: (Math.random() - 0.5) * 3,\n    sw: 0.35 + Math.random() * 0.2, state: LIT, st: 0, gut: 1.4, outT: 0.9,\n    f1: Math.random() * 7, f2: Math.random() * 7, f3: Math.random() * 7, cad: 0.9 + Math.random() * 0.2,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, t: 0, hue: 0, speed: 1, n: 0, fog: 0.06, ws: [], next: 3.2, gust: -1, gustWait: 2.2,\n    L: new Float32Array(N * 3), stars: [],\n    lc: [0, 0, 0], gc: [0, 0, 0], tmp: [0, 0, 0],\n  };\n  const S = params.s;\n  for (let i = 0; i \u003c 26; i++) {\n    const x = Math.random() * W;\n    S.stars.push({ x: floor(x), y: floor(Math.random() * (ridge(x) - 2)), a: 8 + Math.random() * 14, f: Math.random() * 7, w: 0.8 + Math.random() * 2 });\n  }\n}\n\nfunction build(S, n) {\n  S.n = n;\n  const ws = [], off = S.ws.length ? S.ws[0].u : 0.0;\n  for (let i = 0; i \u003c n; i++) {\n    let u = off + (i * SPAN) / n + (Math.random() - 0.5) * (0.25 * SPAN) / n;\n    while (u > UIN + SPAN) u -= SPAN;\n    const w = walker(u);\n    // Staffs on alternate sides down the line, now and then two together.\n    w.side = i % 2 ? 1 : -1;\n    if (Math.random() \u003c 0.2) w.side = -w.side;\n    ws.push(w);\n  }\n  S.ws = ws;\n}\n\nfunction ghosts(S) {\n  let g = 0;\n  for (const w of S.ws) if (w.state !== LIT) g++;\n  return g;\n}\n\n// A lit lantern in view begins to gutter: a random one in the nearer half\n// of the path, or with the button the nearest one wholly in view, quickly.\nfunction gutter(S, quick) {\n  const c = S.ws.filter((w) => w.state === LIT && w.u > (quick ? 0.07 : 0.04) && w.u \u003c (quick ? 0.85 : 0.55));\n  if (!c.length) return;\n  c.sort((a, b) => a.u - b.u);\n  const w = quick ? c[0] : c[floor(Math.random() * c.length)];\n  w.state = GUTTER;\n  w.st = 0;\n  w.gut = quick ? 0.4 : 1.4;\n  w.outT = quick ? 0.3 : 0.9;\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  // At Speed 2 a walker climbs the whole path in 28 s and takes 1.8 steps a second.\n  const du = (SPAN / 28) * dt;\n  for (const w of S.ws) {\n    w.u += du;\n    w.ph += 1.8 * w.cad * dt;\n    w.st += dt;\n    if (w.state === GUTTER && w.st > w.gut) (w.state = OUT), (w.st = 0);\n    else if (w.state === OUT && w.st > w.outT) (w.state = GHOST), (w.st = 0);\n    // Over the hilltop and into the fog: the walker comes round again at the\n    // foot of the path with a lit lantern.\n    if (w.u > UIN + SPAN) {\n      w.u -= SPAN;\n      w.state = LIT;\n      w.side = Math.random() \u003c 0.5 ? -1 : 1;\n    }\n  }\n  // A gust of wind runs up the line from the foot of the path, 0.9 of the\n  // path a second, every 7 to 11 s.\n  S.gustWait -= dt;\n  if (S.gustWait \u003c= 0) (S.gust = UIN), (S.gustWait = 7 + Math.random() * 4);\n  if (S.gust > -1) S.gust = S.gust > 1.3 ? -1 : S.gust + 0.9 * dt;\n  S.next -= dt;\n  if (S.next \u003c= 0) {\n    S.next = 6 + Math.random() * 4;\n    if (ghosts(S) \u003c max(1, round(S.n * 0.25))) gutter(S, false);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3) / 2;\n  S.fog = cl(k[3], 0, 1);\n  const n = cl(round(k[2]), 8, 24);\n  if (n !== S.n) build(S, n);\n  if (!S.begun) S.begun = true;\n  if (input.btnPressed && input.btnPressed[0]) gutter(S, true);\n  step(S, cl(dt || 0, 0, 0.1) * S.speed);\n}\n\n// The lantern's brightness now, 0..1. Wind does not touch a ghost's light.\nfunction flame(S, w) {\n  const t = S.t;\n  let fl = 0.74 + 0.11 * sin(t * 9.1 + w.f1) + 0.08 * sin(t * 14.3 + w.f2) + 0.07 * sin(t * 22.7 + w.f3);\n  // As the gust reaches a lantern its flame ducks to half and flares after.\n  if (S.gust > -1) {\n    const g = (w.u - S.gust) / 0.05, f = (w.u - S.gust + 0.13) / 0.07;\n    fl *= 1 - 0.5 * exp(-g * g) * (0.8 + 0.2 * sin(t * 31 + w.f1)) + 0.18 * exp(-f * f);\n  }\n  if (w.state === LIT) return fl;\n  if (w.state === GUTTER) {\n    const p = w.st / w.gut;\n    return fl * (1 - p) * (0.55 + 0.45 * abs(sin(t * 17 + w.f1 * 3) * sin(t * 6.3 + w.f2)));\n  }\n  if (w.state === OUT) return 0;\n  return sm(0, 0.6, w.st) * (0.78 + 0.16 * sin(t * 2.3 + w.f1) + 0.06 * sin(t * 7.7 + w.f2));\n}\n\nfunction add(L, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  L[o] += r;\n  L[o + 1] += g;\n  L[o + 2] += b;\n}\n\n// A soft elliptical glow, amplitude a (0..255) of colour c, sx and sy wide;\n// with wisp > 0 it is mist, drifting thicker and thinner through it.\nfunction glow(L, cx, cy, sx, sy, a, c, wisp = 0, t = 0) {\n  if (a \u003c 0.5) return;\n  const rx = sx * 3, ry = sy * 3;\n  const x0 = max(0, floor(cx - rx)), x1 = min(W - 1, ceil(cx + rx)), y0 = max(0, floor(cy - ry)), y1 = min(H - 1, ceil(cy + ry));\n  const kx = 1 / (2 * sx * sx), ky = 1 / (2 * sy * sy);\n  for (let y = y0; y \u003c= y1; y++) {\n    const dy = y + 0.5 - cy, ey = exp(-dy * dy * ky) * a;\n    if (ey \u003c 0.3) continue;\n    const o = y * W * 3;\n    for (let x = x0; x \u003c= x1; x++) {\n      const dx = x + 0.5 - cx;\n      let v = ey * exp(-dx * dx * kx);\n      if (wisp) v *= 1 - wisp * (0.5 + 0.5 * sin(x * 0.45 + y * 0.21 + t * 2.9) * sin(x * 0.17 - y * 0.52 - t * 2.1));\n      const p = o + x * 3;\n      L[p] += c[0] * v;\n      L[p + 1] += c[1] * v;\n      L[p + 2] += c[2] * v;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const L = S.L, t = S.t, fog = S.fog;\n  L.fill(0);\n  hsv(0.085 + 0.7 * S.hue, 0.82, 1, S.lc);\n  hsv(0.085 + 0.7 * S.hue + 0.27, 0.7, 1, S.gc);\n  // The sky over the ridge, deep violet, a little lighter down at the\n  // ridge; faint stars; the hillside under it nearly black, and the path a\n  // pale ribbon on it.\n  for (let x = 0; x \u003c W; x++) {\n    const yr = ridge(x);\n    for (let y = 0; y \u003c H; y++) {\n      const o = (y * W + x) * 3;\n      if (y + 0.5 \u003c yr) {\n        const v = 5 + 9 * (y / yr);\n        L[o] = v * 0.55;\n        L[o + 1] = v * 0.4;\n        L[o + 2] = v;\n      } else {\n        L[o] = 2.2;\n        L[o + 1] = 1.6;\n        L[o + 2] = 3;\n      }\n    }\n  }\n  for (const s of S.stars) {\n    const v = s.a * (0.6 + 0.4 * sin(t * s.w + s.f));\n    if (s.y + 1 \u003c ridge(s.x)) add(L, s.x, s.y, v * 0.8, v * 0.8, v);\n  }\n  for (let y = ceil(CREST); y \u003c H; y++) {\n    const u = uOfY(y + 0.5), d = depth(u), cx = pathX(u), hw = 4.5 / d + 0.6;\n    const x0 = max(0, floor(cx - hw - 1)), x1 = min(W - 1, ceil(cx + hw + 1));\n    for (let x = x0; x \u003c= x1; x++) {\n      const a = cl(hw - abs(x + 0.5 - cx) + 0.5, 0, 1);\n      if (y + 0.5 \u003c ridge(x)) continue;\n      const o = (y * W + x) * 3, v = a * (8 + 4 / d);\n      L[o] += v * 0.75;\n      L[o + 1] += v * 0.62;\n      L[o + 2] += v * 0.7;\n    }\n  }\n  // How fast the night and the fog swallow light up the path.\n  const dens = 0.25 + 1.8 * fog;\n  // Walkers, the furthest first, so the nearer stand in front.\n  const order = S.ws.slice().sort((a, b) => b.u - a.u);\n  const c = S.tmp;\n  for (const w of order) {\n    const u = w.u, d = depth(u), hs = TALL / d;\n    const fy0 = pathY(u);\n    if (fy0 - 1.3 * hs > H + 2) continue;\n    const ghost = w.state === GHOST, I = flame(S, w);\n    // Far walkers fade into the night and the fog; over the top they are gone.\n    const att = exp(-dens * max(0, u) * 1.4) * (u > 0.86 ? sm(1.02, 0.86, u) : 1);\n    if (att \u003c 0.01) continue;\n    const step = w.ph * PI, bob = ghost ? 0.03 * hs * sin(t * 1.7 + w.f1) : 0.025 * hs * abs(sin(step));\n    const fx = pathX(u) + w.jx / d, fy = fy0 - bob - (ghost ? 0.05 * hs : 0);\n    const col = ghost ? S.gc : S.lc;\n    // The lantern hangs from the tip of a staff held out to one side, at\n    // head height, and swings with the steps.\n    const th = w.sw * sin(step + 0.4);\n    const tx = fx + w.side * 0.33 * hs, ty = fy - 1.2 * hs;\n    const lx = tx + sin(th) * 0.17 * hs, ly = ty + cos(th) * 0.17 * hs;\n    const Ia = I * att;\n    const sg = max(1.1, 0.13 * hs), A = min(240, 90 * sg) * Ia, sa = (0.42 + 0.25 * fog) * hs + 1;\n    // The pool of light the lantern throws on the ground and the mist round\n    // the walker's feet; the halo, and the glow in the air round it that\n    // the hood stands dark against. All of it is behind the walker.\n    glow(L, fx + 0.3 * (lx - fx), fy - 0.08 * hs, 0.62 * hs + 1, 0.2 * hs + 0.6, 46 * Ia * (0.6 + 0.8 * fog), col, 0.45, t);\n    glow(L, lx, ly + 0.1 * hs, sa, sa * 1.1, A * 0.22 * (1 + fog), col, 0.3, t);\n    glow(L, lx, ly, sg, sg * 1.25, A, col);\n    // The robe: a dark shape that hides most of the light behind it, warmed\n    // on the lantern's side. A ghost lets most of it through.\n    const op = (ghost ? 0.75 : 1) * min(1, att * 1.6), front = ghost ? 0.5 : 0.07;\n    const soft = max(1, 0.07 * hs), y0 = max(0, floor(fy - hs)), y1 = min(H - 1, floor(fy));\n    const sig2 = 2 * (0.6 * hs) ** 2;\n    for (let y = y0; y \u003c= y1; y++) {\n      const tt = (fy - (y + 0.5)) / hs;\n      // The hem swings a little with each step; a ghost's hem trails away.\n      const sway = tt \u003c 0.3 ? (0.3 - tt) * 0.06 * hs * sin(step) : 0;\n      // The sleeve of the arm that holds the staff stands out on that side.\n      const hw = prof(tt) * hs, cxr = fx + sway, sl = 0.07 * hs * sm(0.4, 0.5, tt) * sm(0.68, 0.58, tt);\n      const hem = ghost ? sm(0, 0.35, tt) : 1;\n      const x0 = max(0, floor(cxr - hw - 2)), x1 = min(W - 1, ceil(cxr + hw + 2));\n      for (let x = x0; x \u003c= x1; x++) {\n        const dx = x + 0.5 - cxr, hx = hw + (dx * w.side > 0 ? sl : 0), a = cl((hx - abs(dx)) / soft + 0.5, 0, 1) * op * hem;\n        if (a \u003c= 0) continue;\n        const ddx = x + 0.5 - lx, ddy = y + 0.5 - ly;\n        const near = exp(-(ddx * ddx + ddy * ddy) / sig2);\n        // A rim of light down the edge on the lantern's side, a band of about\n        // an LED and a half; the rest of the robe stays dark.\n        const e = dx * w.side > 0 ? sm(soft + 0.08 * hs, 0, hx - abs(dx)) : 0;\n        const rim = 150 * Ia * near * (0.04 + 0.96 * e);\n        const o = (y * W + x) * 3, k = 1 - a * (1 - front);\n        // A ghost's robe glows faintly from inside in its lantern's colour,\n        // most at the hood; a living walker's is a dark violet-grey.\n        const gl = ghost ? 30 * Ia * (0.35 + 0.65 * tt) : 0;\n        L[o] = L[o] * k + a * (4 + gl * col[0] + rim * col[0]);\n        L[o + 1] = L[o + 1] * k + a * (2.8 + gl * col[1] + rim * col[1]);\n        L[o + 2] = L[o + 2] * k + a * (5 + gl * col[2] + rim * col[2]);\n      }\n    }\n    // The staff, straight up from the hand to the crook the lantern hangs\n    // from, dark against the glow.\n    if (hs > 7) {\n      const ax = fx + w.side * 0.2 * hs, ay = fy - 0.5 * hs, m = ceil(2 * hs * 0.75);\n      let last = -1;\n      const k = ghost ? 0.85 : 0.6;\n      for (let i = 0; i \u003c= m; i++) {\n        // Up the shaft for the first four fifths, then out along the crook.\n        const f = i / m, x = floor(f \u003c 0.8 ? ax : ax + ((tx - ax) * (f - 0.8)) / 0.2), y = floor(f \u003c 0.8 ? ay + ((ty - ay) * f) / 0.8 : ty);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        if (o === last) continue;\n        last = o;\n        L[o] *= k;\n        L[o + 1] *= k;\n        L[o + 2] *= k;\n      }\n    }\n    // The lantern itself in front: a whiter core.\n    c[0] = 1;\n    c[1] = 0.88;\n    c[2] = 0.68;\n    if (ghost) (c[0] = 0.75), (c[1] = 1), (c[2] = 0.85);\n    glow(L, lx, ly, sg * 0.55, sg * 0.7, A * 0.35, c);\n  }\n  // The fog in front of it all: banks drifting across, thicker up the hill,\n  // a dim grey-violet.\n  for (let y = 0; y \u003c H && fog > 0.004; y++) {\n    const far = 1 - sm(20, 120, y);\n    for (let x = 0; x \u003c W; x++) {\n      const n = 0.5 + 0.3 * sin(x * 0.09 + y * 0.045 + t * 0.31) + 0.2 * sin(x * 0.043 - y * 0.12 - t * 0.23);\n      const v = fog * n * (5 + 11 * far);\n      const o = (y * W + x) * 3;\n      L[o] += v * 0.8;\n      L[o + 1] += v * 0.75;\n      L[o + 2] += v;\n    }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    let r = L[o], g = L[o + 1], b = L[o + 2];\n    if (r + g + b \u003c 1.5) continue;\n    // A soft shoulder above 190, and every channel in steps of 4.\n    r = r \u003c 190 ? r : 190 + 65 * (1 - exp(-(r - 190) / 65));\n    g = g \u003c 190 ? g : 190 + 65 * (1 - exp(-(g - 190) / 65));\n    b = b \u003c 190 ? b : 190 + 65 * (1 - exp(-(b - 190) / 65));\n    display.setPixel(p % W, (p / W) | 0, round(r / 4) * 4, round(g / 4) * 4, round(b / 4) * 4);\n  }\n}\n","lorentz-gas":"// ===== Patternflow pattern =====\n// Title:   Lorentz Gas\n// Family:  particle\n// Idea:    A triangular array of round scatterers fills the panel and a burst of point particles leaves one spot between them in every direction at once, each bouncing specularly off the discs and changing colour with every bounce, so the bright bead breaks into a cloud that seeps from pocket to pocket through the narrow gaps while a thin ring at the measured root mean square distance grows like the square root of time, until the cloud fills the view and a new burst leaves another spot; with smaller discs straight corridors open between the rows and particles shoot along them in long streaks.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Lorentz gas (Hendrik Lorentz, 1905), with the periodic Sinai billiard (Yakov Sinai, 1970), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Particles=800..3000, Radius=0..1\n//\n// Knob 1: Hue. Turns every colour round the wheel together. At 0 a fresh burst is ice cyan and shades through blue and violet to magenta as its particles bounce, most of the way by 120 bounces, over discs with grey-blue rims and inside a pale gold ring; at 0.25 the cloud runs from violet to orange, at 0.5 from red through yellow to green and at 0.75 from lime to blue.\n// Knob 2: Speed. Particles fly 15 LEDs a second for each unit: 30 at 2, where each bounces about 10 times a second at the opening radius and a burst fills the view in 8 to 9 s; 3 LEDs a second at 0.2, a burst lasting about 85 s, and 45 at 3, about 5.5 s.\n// Knob 3: Particles. How many leave each burst: 800 at the start, 1350 at a quarter, 1900 at half, 2450 at three quarters and 3000 at the end, the pockets lit denser and brighter the more there are. Turned during a burst it copies particles already in flight or drops some, so the cloud keeps its shape.\n// Knob 4: Radius. The discs' radius on a lattice of spacing 1, which is 12 LEDs: 0.47 at 0, 0.455 at the opening 0.06, 0.4075 at a quarter, 0.345 at half, 0.2825 at three quarters and 0.22 at 1. Above sqrt(3)/4 = 0.433, which is the knob at 0.148, every straight line meets a disc, the cloud seeps from pocket to pocket through gaps 0.7 to 1.6 LEDs wide and its mean square displacement grows in step with time; a burst lasts 10 to 12 s at 0, 8 to 9 s at 0.06 and about 6 s at the threshold. Past it corridors open between the rows of discs, up the panel and at 60 degrees to it, 2.1 LEDs wide at half and 5.1 at 1, particles shoot along them in streaks that stick out of the cloud, and the spread grows faster than time (as t log t): a burst lasts 2.4 s at half and 1.6 s at 1.\n// Buttons: K1 tap starts a new burst from another spot between the discs while the old cloud fades out over 1.2 s. A burst also starts by itself once the ring passes 30 LEDs.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, sqrt, exp, cos, sin, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The lattice: spacing 1 in its own units, D LEDs on the panel. Its rows run\n// up the panel, so the corridors that open below the threshold run the\n// panel's long way and at 60 degrees to it. A lattice point sits at\n// (i + j/2, j*SQ); the lattice X axis is the panel's y.\nconst D = 12, SQ = sqrt(3) / 2, CX = 32, CY = 64;\n// Disc radius from knob 4: 0.47 at 0, 0.455 at the opening 0.06, 0.22 at\n// 1. Discs touch at 0.5. The horizon is finite exactly when the discs block\n// every row corridor: rows are SQ apart, so a corridor SQ - 2r wide is open\n// below r = sqrt(3)/4, the knob at 0.148. Below r = 1/4 a second family\n// opens, between rows of the lattice's 30-degree direction, half apart.\nconst rOf = (k) => 0.47 - 0.25 * k;\n// Flight per second for each unit of Speed, in lattice units.\nconst RATE = 1.25;\n// The longest straight piece looked at in one go. With r + STEP under SQ,\n// only the four corners of the lattice cell a particle is in can be hit.\nconst STEP = 0.3;\n// A burst ends when its ring passes this many lattice units (30 LEDs).\nconst RMAX = 2.5;\nconst NMAX = 3000, FADE = 1.2;\n// Hue of a fresh particle at knob 0: ice cyan, shading to violet and\n// magenta as the bounces add up.\nconst HUE0 = 0.5, SHIFT = 0.38, NB = 60;\n// A particle's light fades as it moves on, over TRAIL LEDs of its path\n// whatever the speed, so a flight down a corridor shows as a streak.\nconst TRAIL = 3, VLED = RATE * D;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nfunction makeSet() {\n  return {\n    n: 0, live: false, fade: 1, ox: 0, oy: 0, s: 0, msd: 0,\n    X: new Float64Array(NMAX), Y: new Float64Array(NMAX), VX: new Float64Array(NMAX), VY: new Float64Array(NMAX),\n    PX: new Float64Array(NMAX), PY: new Float64Array(NMAX), B: new Uint16Array(NMAX),\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: -1, speed: 2, count: 800, r: -1, rmax: RMAX, keep: 0,\n    sets: [makeSet(), makeSet()], cur: 0,\n    bg: new Float32Array(N * 3), acc: new Float32Array(N * 3), lit: new Float32Array(N * 3), lut: new Float32Array(256 * 3), ring: new Float32Array(3),\n    bgKey: \"\",\n  };\n}\n\n// The centre of the disc nearest (x, y), into NC. A point in the lattice\n// cell with corners (fa, fb)..(fa+1, fb+1) is never nearer another point.\nconst NC = [0, 0, 0];\nfunction nearest(x, y) {\n  const b = y / SQ, a = x - 0.5 * b, fa = floor(a), fb = floor(b);\n  let best = 1e9;\n  for (let j = fb; j \u003c= fb + 1; j++)\n    for (let i = fa; i \u003c= fa + 1; i++) {\n      const cx = i + 0.5 * j, cy = j * SQ, d2 = (x - cx) * (x - cx) + (y - cy) * (y - cy);\n      if (d2 \u003c best) (best = d2), (NC[0] = cx), (NC[1] = cy);\n    }\n  NC[2] = best;\n}\n\n// Flies particle i of set P a distance L, bouncing off every disc it meets\n// on the way: the exact first crossing of the ray with each of the four\n// discs it can reach, the mirror reflection there, and on with what is left.\nfunction fly(P, i, L, r) {\n  let x = P.X[i], y = P.Y[i], vx = P.VX[i], vy = P.VY[i], rem = L, hits = 0;\n  const r2 = r * r;\n  for (let guard = 0; rem > 1e-12 && guard \u003c 64; guard++) {\n    const seg = min(rem, STEP);\n    const b = y / SQ, a = x - 0.5 * b, fa = floor(a), fb = floor(b);\n    let tb = seg, hx = 0, hy = 0, hit = false;\n    for (let j = fb; j \u003c= fb + 1; j++)\n      for (let k = fa; k \u003c= fa + 1; k++) {\n        const cx = k + 0.5 * j, cy = j * SQ, dx = x - cx, dy = y - cy;\n        const bd = dx * vx + dy * vy;\n        // Moving away from this disc, or along its tangent: no hit.\n        if (bd >= 0) continue;\n        const q = bd * bd - (dx * dx + dy * dy - r2);\n        if (q \u003c= 0) continue;\n        let t = -bd - sqrt(q);\n        if (t \u003c 0) t = 0;\n        if (t \u003c tb) (tb = t), (hx = cx), (hy = cy), (hit = true);\n      }\n    x += vx * tb;\n    y += vy * tb;\n    rem -= tb;\n    if (hit) {\n      // The normal at the hit point; the particle is set back onto the rim\n      // a hair outside it, so rounding never leaves it in the disc.\n      let nx = x - hx, ny = y - hy;\n      const l = sqrt(nx * nx + ny * ny);\n      nx /= l;\n      ny /= l;\n      const dn = vx * nx + vy * ny;\n      vx -= 2 * dn * nx;\n      vy -= 2 * dn * ny;\n      x = hx + nx * (r + 1e-9);\n      y = hy + ny * (r + 1e-9);\n      hits++;\n    }\n  }\n  P.X[i] = x;\n  P.Y[i] = y;\n  P.VX[i] = vx;\n  P.VY[i] = vy;\n  P.B[i] = min(65535, P.B[i] + hits);\n}\n\n// A spot in the gaps, in the middle of the view and away from the last one.\nfunction spot(S, last) {\n  let bx = 0, by = 0, bd = -1;\n  for (let k = 0; k \u003c 40; k++) {\n    const x = (Math.random() * 2 - 1) * 3.2, y = (Math.random() * 2 - 1) * 1.6;\n    nearest(x, y);\n    if (sqrt(NC[2]) \u003c S.r + 0.04) continue;\n    const d = last ? (x - last.ox) ** 2 + (y - last.oy) ** 2 : 1;\n    if (d > bd) (bd = d), (bx = x), (by = y);\n  }\n  if (bd \u003c 0) {\n    // Every try fell in a disc (only possible with the largest discs): the\n    // middle of a pocket is always free.\n    bx = 0.5;\n    by = SQ / 3;\n  }\n  return [bx, by];\n}\n\nfunction burst(S) {\n  const old = S.sets[S.cur];\n  S.cur ^= 1;\n  const P = S.sets[S.cur];\n  const [ox, oy] = spot(S, old.live ? old : null);\n  if (old.live) old.fade = 1 - 1e-6;\n  P.live = true;\n  P.fade = 1;\n  P.ox = ox;\n  P.oy = oy;\n  P.s = 0;\n  P.msd = 0;\n  P.n = S.count;\n  // Headings evenly round the circle, so the first ring is a true circle\n  // until it meets the discs.\n  const a0 = Math.random() * TAU;\n  for (let i = 0; i \u003c P.n; i++) {\n    const a = a0 + (TAU * (i + Math.random() * 0.5)) / P.n;\n    P.X[i] = P.PX[i] = ox;\n    P.Y[i] = P.PY[i] = oy;\n    P.VX[i] = cos(a);\n    P.VY[i] = sin(a);\n    P.B[i] = 0;\n  }\n}\n\n// A new radius can swallow particles: those it does are put back on the\n// rim, turned outward if they were heading in.\nfunction pushOut(S) {\n  const r = S.r;\n  for (const P of S.sets) {\n    if (!P.live) continue;\n    for (let i = 0; i \u003c P.n; i++) {\n      nearest(P.X[i], P.Y[i]);\n      if (NC[2] >= r * r) continue;\n      let nx = P.X[i] - NC[0], ny = P.Y[i] - NC[1];\n      const l = sqrt(nx * nx + ny * ny);\n      if (l \u003c 1e-9) (nx = 1), (ny = 0);\n      else (nx /= l), (ny /= l);\n      P.X[i] = P.PX[i] = NC[0] + nx * (r + 1e-9);\n      P.Y[i] = P.PY[i] = NC[1] + ny * (r + 1e-9);\n      const dn = P.VX[i] * nx + P.VY[i] * ny;\n      if (dn \u003c 0) (P.VX[i] -= 2 * dn * nx), (P.VY[i] -= 2 * dn * ny);\n    }\n  }\n}\n\n// More particles: copies of particles already in flight, in new\n// directions, so the cloud keeps its shape. Fewer: the last ones go.\nfunction resize(S, n) {\n  const P = S.sets[S.cur];\n  if (P.live && n > P.n) {\n    for (let i = P.n; i \u003c n; i++) {\n      const j = floor(Math.random() * P.n), a = Math.random() * TAU;\n      P.X[i] = P.PX[i] = P.X[j];\n      P.Y[i] = P.PY[i] = P.Y[j];\n      P.VX[i] = cos(a);\n      P.VY[i] = sin(a);\n      P.B[i] = P.B[j];\n    }\n  }\n  if (P.live) P.n = n;\n  S.count = n;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 800, 0.06];\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const n = round(cl(kv[2], 800, NMAX)), r = rOf(cl(kv[3], 0, 1));\n  if (r !== S.r) {\n    S.r = r;\n    pushOut(S);\n  }\n  if (n !== S.count) resize(S, n);\n  if (!S.begun) {\n    S.begun = true;\n    burst(S);\n  }\n  if (input.btnPressed && input.btnPressed[0]) burst(S);\n  const d = cl(dt || 0, 0, 0.1), L = d * RATE * S.speed;\n  S.keep = exp(-(d * VLED * S.speed) / TRAIL);\n  for (const P of S.sets) {\n    if (!P.live) continue;\n    if (P.fade \u003c 1) {\n      P.fade -= d / FADE;\n      if (P.fade \u003c= 0) {\n        P.live = false;\n        continue;\n      }\n    }\n    let m = 0;\n    for (let i = 0; i \u003c P.n; i++) {\n      P.PX[i] = P.X[i];\n      P.PY[i] = P.Y[i];\n      fly(P, i, L, S.r);\n      const dx = P.X[i] - P.ox, dy = P.Y[i] - P.oy;\n      m += dx * dx + dy * dy;\n    }\n    P.s += L;\n    P.msd = m / P.n;\n  }\n  // The measured spread of the cloud, from where it started.\n  if (sqrt(S.sets[S.cur].msd) > S.rmax) burst(S);\n}\n\n// The discs: a faint fill and a soft rim, laid down once for each radius.\nfunction background(S) {\n  const key = S.r + \":\" + S.hue;\n  if (key === S.bgKey) return;\n  S.bgKey = key;\n  const bg = S.bg, c = [0, 0, 0], e = [0, 0, 0];\n  hsv(HUE0 + S.hue + 0.12, 0.6, 1, c, 0);\n  hsv(HUE0 + S.hue + 0.08, 0.35, 1, e, 0);\n  const R = S.r * D;\n  for (let py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++) {\n      // Lattice X is the panel's y, lattice Y its x.\n      nearest((py + 0.5 - CY) / D, (px + 0.5 - CX) / D);\n      const dd = sqrt(NC[2]) * D - R;\n      const fill = dd \u003c 0 ? 0.035 + 0.02 * min(1, -dd / R) : 0;\n      const rim = 0.17 * exp(-(dd * dd) / 0.45);\n      const o = (py * W + px) * 3;\n      for (let k = 0; k \u003c 3; k++) bg[o + k] = c[k] * fill + e[k] * rim;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  background(S);\n  const { bg, acc, lut } = S;\n  for (let o = 0; o \u003c N * 3; o++) acc[o] *= S.keep;\n  // Colour by bounce count: a fresh particle a pale cyan, then deeper and\n  // further round the wheel, most of the way by 2 * NB bounces.\n  for (let b = 0; b \u003c 256; b++) {\n    const u = 1 - exp(-b / NB);\n    hsv(HUE0 + S.hue + SHIFT * u, 0.6 + 0.3 * min(1, b / 12), 1, lut, b * 3);\n  }\n  for (const P of S.sets) {\n    if (!P.live) continue;\n    const w = (P.fade \u003c 1 ? P.fade * P.fade : 1) * (1 - S.keep) * 1.6;\n    for (let i = 0; i \u003c P.n; i++) {\n      const c = min(255, P.B[i]) * 3;\n      // The stretch of path flown since the last frame, in steps of half\n      // an LED.\n      const x1 = CX + P.Y[i] * D, y1 = CY + P.X[i] * D, x0 = CX + P.PY[i] * D, y0 = CY + P.PX[i] * D;\n      const m = max(1, Math.ceil(2 * max(abs(x1 - x0), abs(y1 - y0)))), wk = w / m;\n      for (let k = 1; k \u003c= m; k++) {\n        const x = floor(x0 + ((x1 - x0) * k) / m), y = floor(y0 + ((y1 - y0) * k) / m);\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const o = (y * W + x) * 3;\n        acc[o] += lut[c] * wk;\n        acc[o + 1] += lut[c + 1] * wk;\n        acc[o + 2] += lut[c + 2] * wk;\n      }\n    }\n  }\n  // The ring: the root mean square distance from the burst's start.\n  const P = S.sets[S.cur], rr = sqrt(P.msd) * D, ox = CX + P.oy * D, oy = CY + P.ox * D;\n  const ring = S.ring, lit = S.lit;\n  lit.fill(0);\n  hsv(HUE0 + S.hue + 0.62, 0.3, 0.6, ring, 0);\n  if (rr > 1.5) {\n    const y0 = max(0, floor(oy - rr - 2)), y1 = min(H - 1, floor(oy + rr + 2));\n    const x0 = max(0, floor(ox - rr - 2)), x1 = min(W - 1, floor(ox + rr + 2));\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        const dd = abs(sqrt((x + 0.5 - ox) ** 2 + (y + 0.5 - oy) ** 2) - rr);\n        if (dd >= 1) continue;\n        const o = (y * W + x) * 3, a = 1 - dd;\n        for (let k = 0; k \u003c 3; k++) lit[o + k] = ring[k] * a;\n      }\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3) {\n    const r = bg[o] + lit[o] + 1 - exp(-acc[o]), g = bg[o + 1] + lit[o + 1] + 1 - exp(-acc[o + 1]), b = bg[o + 2] + lit[o + 2] + 1 - exp(-acc[o + 2]);\n    if (r + g + b \u003c 0.008) continue;\n    // Each channel in steps of 4 of 255, too fine to see, and a frame packs\n    // smaller for it.\n    display.setPixel(p % W, (p / W) | 0, min(255, round(r * 63.75) * 4), min(255, round(g * 63.75) * 4), min(255, round(b * 63.75) * 4));\n  }\n}\n","reeb-graph":"// ===== Patternflow pattern =====\n// Title:   Reeb Graph\n// Family:  topology\n// Idea:    A closed surface of genus two to six, that many rings fused in one upright chain, turns slowly about the vertical while a level plane rises through it from the bottom, the surface below the plane lit solid and the surface above it a faint ghost, the cut drawn as bright rings on the plane, each ring shrinking to one point whose path down the inside of the chain draws the Reeb graph, a stem from the bottom that splits at the bottom of every hole and joins again at its top, so that each critical point flashes in its own colour as the plane passes it and the count of minima, saddles and maxima always comes to two minus twice the genus.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Morse theory (Marston Morse, 1934) and the Reeb graph (Georges Reeb, 1946), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Holes=2..6, Tilt=0..1\n//\n// Knob 1: Hue. The surface's colour, with the cut, the graph and the three kinds of critical point turned with it. At 0 an azure surface cut in amber, minima green, saddles white, maxima magenta; at 0.25 magenta cut in lime, at 0.5 orange cut in azure, at 0.75 green cut in purple.\n// Knob 2: Speed. At 2 the plane climbs the whole chain in 5 seconds, waits a second at the top and starts again, and the chain turns once in 16 seconds; at 0.2 both are ten times slower, at 3 half as fast again.\n// Knob 3: Holes. The genus, the knob rounded: 2 at the start, 3 at a quarter, 4 at half, 5 at three quarters, 6 at the end. Genus g has one minimum, one maximum and 2g saddles, 1 - 2g + 1 = 2 - 2g, and its Reeb graph is a chain of g loops; the chain is scaled to fill the 128 rows each time.\n// Knob 4: Tilt. Leans the chain off the vertical in the plane of its rings, 0.06 rad at the start and 1.05 rad (60 degrees) at 1, and the chain shrinks to keep fitting the panel as it turns. Up to about 0.8 the loops of the graph only slide into a staircase and the count stays 1, 2g, 1. Past that each ring overhangs the next: the joints grow short spurs, a new minimum with its saddle on the low side and a new maximum with its saddle on the high side, and from about 0.85 two holes share a level and the cut has three pieces at once; genus 2 at 1 counts 2, 6, 2 and genus 6 counts 6, 20, 4, and every count still comes to 2 - 2g.\n// Buttons: K1 tap turns the height upside down: the plane sweeps down from the top, the top point is now the minimum and the bottom the maximum, and the count does not change. K2 tap starts the sweep again.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// An orthographic camera looking down at the chain from 0.36 rad above the\n// level, so the cut shows as flat rings, a third as tall as they are wide.\nconst EL = 0.36, CA = cos(EL), SA = sin(EL);\n// The surface, in units of the ring's radius: tube radius, distance between\n// ring centres along the chain, and how wide the smooth union blends. The\n// rings overlap by 0.15, so neighbours share one bar between their holes.\nconst TR = 0.32, GAP = 2.15, KS = 0.2;\n// Tilt at knob 1, in radians.\nconst TILT = 1.05;\n// Surface hue at Hue 0: azure.\nconst HUE0 = 0.58;\n// Sphere tracing: closest approach that counts as a hit, and most steps.\nconst EPS = 0.004, STEPS = 48;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The chain being drawn. draw() and build() copy it here from the state\n// before they touch the distance function, so two panels never mix.\nlet NG = 2, ST = 0, CT = 1, HALF = 0.5, CX = new Float64Array(8), CY = new Float64Array(8);\nfunction use(S) {\n  NG = S.g;\n  ST = sin(S.tilt);\n  CT = cos(S.tilt);\n  HALF = (NG - 1) / 2;\n  CX = S.cx;\n  CY = S.cy;\n}\n\n// Signed distance to the surface in the chain's own frame: the rings lie in\n// the x-y plane, y is height. Only the two rings either side of the point\n// along the chain can be near it, so only those two are measured.\nfunction sdf(x, y, z) {\n  let k = floor((x * ST + y * CT) / GAP + HALF);\n  if (k \u003c 0) k = 0;\n  else if (k > NG - 2) k = NG - 2;\n  let ax = x - CX[k], ay = y - CY[k], q = sqrt(ax * ax + ay * ay) - 1;\n  const a = sqrt(q * q + z * z) - TR;\n  ax = x - CX[k + 1];\n  ay = y - CY[k + 1];\n  q = sqrt(ax * ax + ay * ay) - 1;\n  const b = sqrt(q * q + z * z) - TR;\n  const h = 0.5 + (0.5 * (b - a)) / KS;\n  if (h \u003c= 0) return b;\n  if (h >= 1) return a;\n  return b + (a - b) * h - KS * h * (1 - h);\n}\n\n// The same, with its gradient in GR: the polynomial smooth minimum's\n// gradient is exactly the blend of the two rings' gradients.\nconst GR = new Float64Array(3);\nfunction torusG(x, y, z, k, o) {\n  const ax = x - CX[k], ay = y - CY[k], rh = sqrt(ax * ax + ay * ay) || 1e-9, q = rh - 1, d = sqrt(q * q + z * z) || 1e-9;\n  TG[o] = ((q / d) * ax) / rh;\n  TG[o + 1] = ((q / d) * ay) / rh;\n  TG[o + 2] = z / d;\n  return d - TR;\n}\nconst TG = new Float64Array(6);\nfunction sdfG(x, y, z) {\n  let k = floor((x * ST + y * CT) / GAP + HALF);\n  if (k \u003c 0) k = 0;\n  else if (k > NG - 2) k = NG - 2;\n  const a = torusG(x, y, z, k, 0), b = torusG(x, y, z, k + 1, 3);\n  const h = cl(0.5 + (0.5 * (b - a)) / KS, 0, 1);\n  for (let i = 0; i \u003c 3; i++) GR[i] = TG[i] * h + TG[i + 3] * (1 - h);\n  return b + (a - b) * h - KS * h * (1 - h);\n}\n\n// Lay the chain out for genus g and tilt, fit it to the panel and find its\n// Reeb graph.\nfunction layout(S) {\n  const g = S.g;\n  for (let k = 0; k \u003c g; k++) {\n    const u = (k - (g - 1) / 2) * GAP;\n    S.cx[k] = u * sin(S.tilt);\n    S.cy[k] = u * cos(S.tilt);\n  }\n  // The panel must hold the chain at every turn: a point at height y and\n  // distance r from the axis reaches screen heights y*CA +- r*SA.\n  let rho = 0, bLo = 1e9, bHi = -1e9;\n  for (let k = 0; k \u003c g; k++)\n    for (let i = 0; i \u003c 48; i++) {\n      const t = (i / 48) * 2 * PI;\n      for (let j = 0; j \u003c 12; j++) {\n        const u = (j / 12) * 2 * PI, rr = 1 + TR * cos(u);\n        const x = S.cx[k] + rr * cos(t), y = S.cy[k] + rr * sin(t), z = TR * sin(u), r = sqrt(x * x + z * z);\n        rho = max(rho, r);\n        bLo = min(bLo, y * CA - r * SA);\n        bHi = max(bHi, y * CA + r * SA);\n      }\n    }\n  S.rho = rho;\n  S.yLo = S.cy[0] - 1 - TR;\n  S.yHi = S.cy[g - 1] + 1 + TR;\n  S.sc = min(62 / (2 * rho), 125 / (bHi - bLo));\n  S.bc = (bHi + bLo) / 2;\n  build(S);\n}\n\n// The Reeb graph, found the way it is defined: cut the surface at a level,\n// count the pieces of the cut, and join each piece to the pieces it touches\n// one level down. The surface is mirror symmetric in z and grows in |z| from\n// the rings' plane, so every piece of a cut crosses the plane z = 0 in one\n// run of x, and the runs along that line are the pieces. A level every half\n// LED, a sample every 0.4 LED along it.\nfunction build(S) {\n  use(S);\n  const s = S.sc, dy = 0.5 / s, dx = 0.4 / s, nl = ceil((S.yHi - S.yLo) / dy), nx = ceil((2 * S.rho) / dx) + 2;\n  const NX = [], NY = [], NA = [], NB = [], L0 = [0];\n  for (let i = 0; i \u003c nl; i++) {\n    const y = S.yLo + (i + 0.5) * dy;\n    let prev = 1, xa = 0, sw = 0, swx = 0;\n    for (let j = 0; j \u003c= nx; j++) {\n      const x = -S.rho - dx + j * dx, v = j === nx ? 1 : sdf(x, y, 0);\n      if (v \u003c 0) {\n        if (prev >= 0) {\n          xa = x - (dx * -v) / (prev - v);\n          sw = swx = 0;\n        }\n        // Weighted by how far the piece reaches out of the plane, so the\n        // point sits at the middle of the piece, not of the run.\n        const u = v + TR, w = u \u003c= 0 ? TR : sqrt(max(0, TR * TR - u * u));\n        sw += w;\n        swx += w * x;\n      } else if (prev \u003c 0) {\n        NX.push(sw > 0 ? swx / sw : xa);\n        NY.push(y);\n        NA.push(xa);\n        NB.push(x - (dx * v) / (v - prev));\n      }\n      prev = v;\n    }\n    L0.push(NX.length);\n  }\n  // Join the runs of neighbouring levels that overlap.\n  const n = NX.length, up = new Int16Array(n), dn = new Int16Array(n), EA = [], EB = [];\n  for (let i = 0; i + 1 \u003c nl; i++)\n    for (let a = L0[i]; a \u003c L0[i + 1]; a++)\n      for (let b = L0[i + 1]; b \u003c L0[i + 2]; b++)\n        if (NA[a] \u003c NB[b] && NA[b] \u003c NB[a]) {\n          EA.push(a);\n          EB.push(b);\n          up[a]++;\n          dn[b]++;\n        }\n  // Critical points: a run with nothing below is born at a minimum, one with\n  // nothing above dies at a maximum, and every extra branch up or down is a\n  // saddle, placed in the gap between the two branches.\n  const C = [];\n  for (let a = 0; a \u003c n; a++) {\n    if (!dn[a]) C.push(NX[a], NY[a] - dy / 2, 0);\n    if (!up[a]) C.push(NX[a], NY[a] + dy / 2, 2);\n  }\n  // Edges are listed by lower run and then left to right, so the branches\n  // of a split sit side by side in the list.\n  for (let i = 0; i + 1 \u003c EA.length; i++)\n    if (EA[i + 1] === EA[i]) C.push((NB[EB[i]] + NA[EB[i + 1]]) / 2, NY[EA[i]] + dy / 2, 1);\n  for (let b = 0; b \u003c n; b++) {\n    if (dn[b] \u003c 2) continue;\n    const lev = NY[b], row = [];\n    for (let i = 0; i \u003c EA.length; i++) if (EB[i] === b) row.push(EA[i]);\n    row.sort((p, q) => NA[p] - NA[q]);\n    for (let j = 0; j + 1 \u003c row.length; j++) C.push((NB[row[j]] + NA[row[j + 1]]) / 2, lev - dy / 2, 1);\n  }\n  let nmin = 0, nsad = 0, nmax = 0;\n  for (let i = 2; i \u003c C.length; i += 3) C[i] === 0 ? nmin++ : C[i] === 1 ? nsad++ : nmax++;\n  S.graph = { NX, NY, EA, EB, C, L0, dy, age: new Float32Array(C.length / 3).fill(-1), was: new Uint8Array(C.length / 3) };\n  S.nMin = nmin;\n  S.nSad = nsad;\n  S.nMax = nmax;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, g: 0, tilt: -1, ph: 0, spin: 0.6, dir: 1,\n    cx: new Float64Array(8), cy: new Float64Array(8), rho: 1, yLo: -1, yHi: 1, sc: 1, bc: 0, h: -1,\n    graph: null, nMin: 0, nSad: 0, nMax: 0,\n    buf: new Float32Array(W * H * 3), ov: new Float32Array(W * H), col: new Float32Array(24),\n  };\n}\n\n// The plane takes 10 / Speed seconds to climb and waits 2 / Speed at the top.\nconst CLIMB = 10, WAIT = 2;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 2, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const g = cl(Math.round(kv[2]), 2, 6), tilt = cl(kv[3], 0, 1) * TILT;\n  if (g !== S.g || abs(tilt - S.tilt) > 1e-4) {\n    S.g = g;\n    S.tilt = tilt;\n    layout(S);\n  }\n  const bp = input.btnPressed || [];\n  if (bp[0]) {\n    S.dir = -S.dir;\n    S.ph = 0;\n  }\n  if (bp[1]) S.ph = 0;\n  S.spin += d * 0.2 * S.speed;\n  S.ph += (d * S.speed) / CLIMB;\n  if (S.ph > 1 + WAIT / CLIMB) S.ph = 0;\n  const u = min(1, S.ph), lo = S.yLo - 0.04, hi = S.yHi + 0.04;\n  S.h = S.dir > 0 ? lo + (hi - lo) * u : hi - (hi - lo) * u;\n  // A critical point lights as the plane passes it and flashes for 0.8 s.\n  const G = S.graph, C = G.C;\n  for (let i = 0; i \u003c G.age.length; i++) {\n    const swept = S.dir > 0 ? C[3 * i + 1] \u003c= S.h : C[3 * i + 1] >= S.h;\n    if (swept && !G.was[i]) G.age[i] = 0;\n    else if (G.age[i] >= 0) G.age[i] += d;\n    G.was[i] = swept ? 1 : 0;\n  }\n}\n\n// One ray through the panel's LED, in the chain's frame: origin at t = 0 and\n// direction, filled by draw().\nlet OX = 0, OY = 0, OZ = 0, DX = 0, DY = 0, DZ = 0;\nfunction march(t, end) {\n  let v = 1;\n  for (let n = 0; n \u003c STEPS; n++) {\n    v = sdf(OX + DX * t, OY + DY * t, OZ + DZ * t);\n    if (v \u003c EPS) return t;\n    t += v;\n    if (t > end) return -1e9;\n  }\n  // A ray that grazes the surface along a hole's edge runs out of steps\n  // still close to it; that counts as a hit, or it would leave a black dot.\n  return v \u003c 0.03 ? t : -1e9;\n}\n\n// Splat one point of a line into the overlay, a tent one LED wide.\nfunction dot(ov, fx, fy, w) {\n  const x0 = floor(fx), y0 = floor(fy), ax = fx - x0, ay = fy - y0;\n  for (let j = 0; j \u003c 2; j++)\n    for (let i = 0; i \u003c 2; i++) {\n      const x = x0 + i, y = y0 + j;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const v = w * (i ? ax : 1 - ax) * (j ? ay : 1 - ay) * 1.6;\n      if (v > ov[y * W + x]) ov[y * W + x] = min(1, v);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.graph) return;\n  use(S);\n  const s = S.sc, cp = cos(S.spin), sp = sin(S.spin), h = S.h, dir = S.dir, buf = S.buf, ov = S.ov, C = S.col;\n  // Colours: surface lit and ghost, the cut's fill and its edge, the graph,\n  // and the three kinds of critical point.\n  const hb = HUE0 + S.hue, hc = hb + 0.5;\n  hsv(hb, 0.72, 1, C, 0);\n  hsv(hb, 0.45, 1, C, 3);\n  hsv(hc, 0.9, 0.42, C, 6);\n  hsv(hc, 0.75, 1, C, 9);\n  hsv(hc + 0.03, 0.5, 1, C, 12);\n  hsv(hb - 0.25, 0.8, 1, C, 15);\n  C[18] = C[19] = C[20] = 1;\n  hsv(hb + 0.3, 0.75, 1, C, 21);\n  // Light from the upper left, in front, turned into the chain's frame.\n  const lx0 = -0.5, ly = 0.72, lz0 = -0.48, ll = sqrt(lx0 * lx0 + ly * ly + lz0 * lz0);\n  const lx = (lx0 * cp - lz0 * sp) / ll, lz = (lx0 * sp + lz0 * cp) / ll, lyn = ly / ll;\n  // The ray direction in the chain's frame, the same for every LED.\n  DX = -CA * sp;\n  DY = -SA;\n  DZ = CA * cp;\n  // The chain's box: across the chain in its plane, along it, and out of it.\n  const hw = 1 + TR + 0.07, hl = HALF * GAP + 1 + TR + 0.07, hz = TR + 0.07;\n  const q1 = DX * CT - DY * ST, q2 = DX * ST + DY * CT;\n  const pr = 31 / s;\n  for (let py = 0; py \u003c H; py++) {\n    const b = S.bc + (63.5 - py) / s;\n    for (let px = 0; px \u003c W; px++) {\n      const a = (px + 0.5 - 32) / s, o = (py * W + px) * 3;\n      OX = a * cp - b * SA * sp;\n      OY = b * CA;\n      OZ = a * sp + b * SA * cp;\n      let tA = -1e9, tB = 1e9;\n      // Slab by slab, the stretch of the ray inside the box.\n      const p1 = OX * CT - OY * ST, p2 = OX * ST + OY * CT;\n      if (abs(q1) > 1e-9) {\n        const u = (-hw - p1) / q1, v = (hw - p1) / q1;\n        tA = max(tA, min(u, v));\n        tB = min(tB, max(u, v));\n      } else if (abs(p1) > hw) tB = -1e9;\n      if (abs(q2) > 1e-9) {\n        const u = (-hl - p2) / q2, v = (hl - p2) / q2;\n        tA = max(tA, min(u, v));\n        tB = min(tB, max(u, v));\n      } else if (abs(p2) > hl) tB = -1e9;\n      if (abs(DZ) > 1e-9) {\n        const u = (-hz - OZ) / DZ, v = (hz - OZ) / DZ;\n        tA = max(tA, min(u, v));\n        tB = min(tB, max(u, v));\n      } else if (abs(OZ) > hz) tB = -1e9;\n      // Where the ray meets the level plane.\n      const tp = (OY - h) / SA;\n      let R = 0, G = 0, B = 0, ghost = -1e9, solid = -1e9, cap = false, ls = 0;\n      if (tA \u003c tB) {\n        const above = dir > 0 ? -1 : 1;\n        // Before the plane the ray is above it. Sweeping up, that is ghost.\n        if (tA \u003c tp) {\n          const t = march(tA, min(tB, tp));\n          if (above \u003c 0) ghost = t;\n          else solid = t;\n        }\n        if (tp >= tA && tp \u003c= tB) {\n          const x = OX + DX * tp, z = OZ + DZ * tp, v = sdfG(x, h, z);\n          if (v \u003c 0 && dir > 0) cap = true;\n          // The cut's edge, a line one LED wide whatever its slope on the panel.\n          const gX = GR[0] * cp + GR[2] * sp, gZ = -GR[0] * sp + GR[2] * cp, gs = sqrt(gX * gX + (gZ * gZ) / (SA * SA)) / s;\n          ls = gs > 1e-6 ? cl(1.3 - abs(v) / gs, 0, 1) : 0;\n        }\n        if (!cap && solid \u003c -1e8 && ((dir > 0) || ghost \u003c -1e8)) {\n          const t = march(max(tA, tp), tB);\n          if (dir > 0) solid = t;\n          else ghost = t;\n        }\n      }\n      if (solid > -1e8) {\n        sdfG(OX + DX * solid, OY + DY * solid, OZ + DZ * solid);\n        const nl = GR[0] * lx + GR[1] * lyn + GR[2] * lz, nv = -(GR[0] * DX + GR[1] * DY + GR[2] * DZ);\n        // Five flat bands of light, and a brighter band where the surface\n        // turns away along the outline.\n        let v = 0.16 + 0.84 * max(0, nl);\n        v = (floor(v * 5) + 1) / 5;\n        if (nv \u003c 0.3) v = max(v, 0.6);\n        R = C[0] * v;\n        G = C[1] * v;\n        B = C[2] * v;\n      } else if (cap) {\n        R = C[6];\n        G = C[7];\n        B = C[8];\n      }\n      if (ghost > -1e8) {\n        sdfG(OX + DX * ghost, OY + DY * ghost, OZ + DZ * ghost);\n        const nl = GR[0] * lx + GR[1] * lyn + GR[2] * lz;\n        const v = nl > 0.35 ? 0.24 : 0.16;\n        R = R * 0.6 + C[3] * v;\n        G = G * 0.6 + C[4] * v;\n        B = B * 0.6 + C[5] * v;\n      }\n      // The plane: a faint pane, its near and far edges a little brighter.\n      const Zw = b * SA + tp * CA;\n      if (abs(Zw) \u003c pr && (dir > 0 || solid \u003c -1e8)) {\n        const e = (pr - abs(Zw)) * s * SA, f = e \u003c 1 ? 0.2 : 0.05;\n        R += f * 0.6;\n        G += f * 0.65;\n        B += f * 0.8;\n      }\n      if (ls > 0) {\n        R += (C[9] - R) * ls;\n        G += (C[10] - G) * ls;\n        B += (C[11] - B) * ls;\n      }\n      buf[o] = R;\n      buf[o + 1] = G;\n      buf[o + 2] = B;\n    }\n  }\n  // The Reeb graph: every edge between two levels the plane has passed,\n  // through the middle of the chain.\n  ov.fill(0);\n  const P = S.graph, NX = P.NX, NY = P.NY, sx = (x, z) => 32 + (x * cp + z * sp) * s - 0.5;\n  const sy = (x, y, z) => 63.5 - ((y * CA + (-x * sp + z * cp) * SA) - S.bc) * s;\n  for (let i = 0; i \u003c P.EA.length; i++) {\n    const a = P.EA[i], c = P.EB[i];\n    const ya = NY[a], yb = NY[c];\n    if (dir > 0 ? yb > h : ya \u003c h) continue;\n    const x0 = sx(NX[a], 0), y0 = sy(NX[a], ya, 0), x1 = sx(NX[c], 0), y1 = sy(NX[c], yb, 0);\n    const len = max(abs(x1 - x0), abs(y1 - y0)), n = ceil(len / 0.4) + 1;\n    for (let j = 0; j \u003c= n; j++) dot(ov, x0 + ((x1 - x0) * j) / n, y0 + ((y1 - y0) * j) / n, 1);\n  }\n  // Where each piece of the cut shrinks to now: the graph's growing tips.\n  for (let p = 0; p \u003c W * H; p++) {\n    const w = ov[p];\n    if (w \u003c= 0) continue;\n    const o = p * 3;\n    buf[o] += (C[12] - buf[o]) * w;\n    buf[o + 1] += (C[13] - buf[o + 1]) * w;\n    buf[o + 2] += (C[14] - buf[o + 2]) * w;\n  }\n  // Each piece of the cut at the plane, shrunk to its point: the tips the\n  // graph grows from.\n  const lv = floor((h - S.yLo) / P.dy - 0.5) + (dir > 0 ? 0 : 1);\n  if (lv >= 0 && lv \u003c P.L0.length - 1)\n    for (let a = P.L0[lv]; a \u003c P.L0[lv + 1]; a++) {\n      const fx = sx(NX[a], 0), fy = sy(NX[a], NY[a], 0);\n      for (let j = -1; j \u003c= 1; j++)\n        for (let i = -1; i \u003c= 1; i++) {\n          const x = Math.round(fx) + i, y = Math.round(fy) + j;\n          if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || (i && j)) continue;\n          const o = (y * W + x) * 3;\n          buf[o] = buf[o + 1] = buf[o + 2] = 1;\n        }\n    }\n  // Critical points the plane has passed: a dot in the colour of their\n  // index, a ring that opens and fades as the plane crosses them, and a tick\n  // at their height on the ruler down the left edge.\n  const K = P.C;\n  for (let i = 0; i \u003c P.age.length; i++) {\n    if (!P.was[i]) continue;\n    let idx = K[3 * i + 2];\n    if (dir \u003c 0) idx = 2 - idx;\n    const co = idx === 0 ? 15 : idx === 1 ? 18 : 21;\n    const fx = sx(K[3 * i], 0), fy = sy(K[3 * i], K[3 * i + 1], 0), cx = Math.round(fx), cy = Math.round(fy);\n    const put = (x, y, w) => {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n      const o = (y * W + x) * 3;\n      buf[o] += (C[co] - buf[o]) * w;\n      buf[o + 1] += (C[co + 1] - buf[o + 1]) * w;\n      buf[o + 2] += (C[co + 2] - buf[o + 2]) * w;\n    };\n    put(cx, cy, 1);\n    put(cx - 1, cy, 1);\n    put(cx + 1, cy, 1);\n    put(cx, cy - 1, 1);\n    put(cx, cy + 1, 1);\n    const ag = P.age[i];\n    if (ag >= 0 && ag \u003c 0.8) {\n      const r = 1.5 + 9 * ag, w = 1 - ag / 0.8;\n      for (let k = 0; k \u003c 40; k++) put(Math.round(fx + r * cos((k / 40) * 2 * PI)), Math.round(fy + r * sin((k / 40) * 2 * PI) * 0.8), w);\n    }\n    const ty = Math.round(63.5 - (K[3 * i + 1] * CA - S.bc) * s);\n    put(0, ty, 1);\n    put(1, ty, 1);\n  }\n  const hy = Math.round(63.5 - (h * CA - S.bc) * s);\n  for (let x = 0; x \u003c 3; x++) {\n    const o = (cl(hy, 0, H - 1) * W + x) * 3;\n    buf[o] = buf[o + 1] = buf[o + 2] = 1;\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) display.setPixel(p % W, (p / W) | 0, min(255, buf[o] * 255) | 0, min(255, buf[o + 1] * 255) | 0, min(255, buf[o + 2] * 255) | 0);\n}\n","stochastic-resonance":"// ===== Patternflow pattern =====\n// Title:   Stochastic Resonance\n// Family:  rhythm\n// Idea:    Sixty particles each sit in their own copy of the double well V(x) = -x^2/2 + x^4/4, drawn at the top rocking under a periodic push too weak to tip anyone over the hump while white noise kicks them about, and below it every particle's well is written down one row per moment and sinks away, so at the noise where the Kramers escape time is half the push's period the record turns into violet and amber bands in time with the beat, a rhythm made out of noise.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: stochastic resonance (Roberto Benzi, Alfonso Sutera and Angelo Vulpiani, 1981), pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Noise=-1..1, Drive=0.55..0.95\n//\n// Knob 1: Hue. Turns both wells' colours round the wheel a third apart, the one nearer blue drawn dim; the curve stays white. At 0 the left well is a dim violet and the right amber, at 0.25 bright red and dim green, at 0.5 lime and dim azure, at 0.75 dim teal and magenta.\n// Knob 2: Speed. Rows of the record a second, six times the knob: 12 at 2, so the push beats once every 2 seconds and the 97-row record holds four beats; at 0.2 a beat takes 20 seconds, at 3 it takes 1.3.\n// Knob 3: Noise. The noise strength D, 0.079 times 3 to the knob. At 0, D = 0.079, where the Kramers time 4.44 e^(0.25/D) is exactly half the push's period, each particle hops about twice a beat and the record is bands; the white bar along the top row, the response at the push's frequency over the newest four beats, stands at about 0.79 of a perfect square wave. At -1 (D = 0.026) a particle hops once in about three beats, the record is long stripes down the panel and the bar shrinks to 0.16; at -0.5 most hops land in time but beats are skipped; at 0.5 (D = 0.137) they hop four times a beat; at 1 (D = 0.237) the record is speckle and the bar is back to 0.52.\n// Knob 4: Drive. The push's amplitude as a share of the static threshold 2/(3 sqrt 3) = 0.385, below which a still particle never leaves its well: 0.55 at the start (A = 0.21), 0.95 at the end (A = 0.37), where the hump nearly flattens at each beat and even the quiet setting locks.\n// Buttons: K1 tap throws every particle into a well at random, and the record shows the beat pulling them back into step.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, sqrt, log, cos, sin, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The double well: barrier dV = 1/4 between minima at x = +-1, curvature 2\n// at the minima and 1 on the hump, so the Kramers escape time is\n// (2 pi / sqrt 2) e^(dV / D).\nconst DV = 0.25;\n// Push frequency in the particles' own time. One beat is 209 time units,\n// 419 relaxation times of a well, so the particles feel it as slow. A faster\n// push (0.1) put the resonance at D = 0.128 with A/D only 1.6, and the bands\n// came out ragged; at 0.03 the resonant D is 0.079 and the bands are clean.\nconst OMEGA = 0.03;\nconst PERIOD = TAU / OMEGA;\n// Time-scale matching: the D at which the Kramers time is half a beat.\nconst DSTAR = DV / log(1 / (Math.SQRT2 * OMEGA));\n// The static threshold: the push that removes the hump of a still particle.\nconst ACRIT = 2 / (3 * sqrt(3));\n// Rows of the record per beat, and rows per second for each unit of Speed.\nconst ROWS_PER_BEAT = 24, RATE = 6;\nconst ROWT = PERIOD / ROWS_PER_BEAT;\n// Euler-Maruyama step: the well's stiffness 3x^2 - 1 is at most 19 inside\n// the clamp at |x| = 2.6, and h = 0.06 keeps 19 h under the limit of 2.\nconst HSTEP = 0.06;\n\n// Sixty particles in columns 2..61; columns 0 and 63 carry the push.\nconst N = 60, X0 = 2;\n// The well band: rows 0..29. Record rows 31..127, newest at the top.\nconst BAND = 30, R0 = 31, NR = H - R0;\n// The meter reads the newest four beats of the record.\nconst MROWS = 4 * ROWS_PER_BEAT;\n// Column c shows x = (c + 0.5 - 32) / 32 * XS.\nconst XS = 1.6;\n// The curve's height: row = VY - VS * V.\nconst VY = 9.5, VS = 30;\n// Hue of the left well at knob 0, and how far round the right one sits.\nconst HUE0 = 0.76, HUE_GAP = 0.33;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = round(255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p));\n  out[o + 1] = round(255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p));\n  out[o + 2] = round(255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p));\n}\n\n// Normal deviates two at a time, by Box-Muller.\nlet spare = 0, hasSpare = false;\nfunction gauss() {\n  if (hasSpare) {\n    hasSpare = false;\n    return spare;\n  }\n  let u = Math.random();\n  if (u \u003c 1e-12) u = 1e-12;\n  const r = sqrt(-2 * log(u)), a = TAU * Math.random();\n  spare = r * sin(a);\n  hasSpare = true;\n  return r * cos(a);\n}\n\n// How near a hue is to blue (0.62), 0 at the far side of the wheel.\nconst coolness = (h) => {\n  const d = abs(h - floor(h) - 0.62);\n  return 0.5 - min(d, 1 - d);\n};\n\nconst V = (x, f) => -0.5 * x * x + 0.25 * x * x * x * x - f * x;\n\nfunction scatter(S) {\n  for (let i = 0; i \u003c N; i++) {\n    const w = Math.random() \u003c 0.5 ? -1 : 1;\n    S.x[i] = w + 0.2 * gauss();\n    S.s[i] = w;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, D: DSTAR, A: 0.55 * ACRIT, begun: false,\n    // Position and well (-1 left, 1 right) of each particle, the particles'\n    // clock, and the time left to the next record row.\n    x: new Float32Array(N), s: new Int8Array(N), t: 0, toRow: ROWT,\n    // The record as a ring: one byte per particle per row (1 = right well),\n    // and the push's sign for each row. head is the newest row.\n    rec: new Uint8Array(NR * N), push: new Int8Array(NR), head: 0,\n    // Each row's mean well (-1..1) and the push's phase when it was written,\n    // and the response at the push's frequency over the last four beats.\n    mean: new Float32Array(NR), phase: new Float32Array(NR), R: 0,\n    col: new Uint8Array(12), curve: new Int16Array(W), pile: new Uint8Array(W),\n  };\n  scatter(params.s);\n}\n\n// Start with a full record, as if the particles had been running at these\n// knobs for four beats already.\nfunction prefill(S) {\n  for (let r = 0; r \u003c NR; r++) {\n    run(S, ROWT);\n    writeRow(S);\n  }\n  S.begun = true;\n}\n\n// Advance every particle by time T: dx = (x - x^3 + A cos(w t)) dt + sqrt(2D) dW.\n// A particle changes well only once it is past +-0.5, so jitter on the hump\n// is not counted as a hop.\nfunction run(S, T) {\n  const n = Math.max(1, round(T / HSTEP)), h = T / n, kick = sqrt(2 * S.D * h), x = S.x, s = S.s;\n  for (let k = 0; k \u003c n; k++) {\n    const f = S.A * cos(OMEGA * S.t);\n    for (let i = 0; i \u003c N; i++) {\n      let xi = x[i];\n      xi += (xi - xi * xi * xi + f) * h + kick * gauss();\n      xi = cl(xi, -2.6, 2.6);\n      x[i] = xi;\n      if (xi > 0.5) s[i] = 1;\n      else if (xi \u003c -0.5) s[i] = -1;\n    }\n    S.t += h;\n  }\n}\n\nfunction writeRow(S) {\n  S.head = (S.head + NR - 1) % NR;\n  const o = S.head * N;\n  let m = 0;\n  for (let i = 0; i \u003c N; i++) {\n    S.rec[o + i] = S.s[i] > 0 ? 1 : 0;\n    m += S.s[i];\n  }\n  const ph = OMEGA * S.t;\n  S.push[S.head] = cos(ph) >= 0 ? 1 : -1;\n  S.mean[S.head] = m / N;\n  S.phase[S.head] = ph;\n  // The meter: the first Fourier coefficient of the mean well over four\n  // whole beats, |(2/n) sum m e^(-i w t)|, as a share of the 4/pi a square\n  // wave in perfect step would give.\n  let re = 0, im = 0;\n  for (let r = 0; r \u003c MROWS; r++) {\n    const k = (S.head + r) % NR;\n    re += S.mean[k] * cos(S.phase[k]);\n    im += S.mean[k] * sin(S.phase[k]);\n  }\n  S.R = ((2 / MROWS) * sqrt(re * re + im * im)) / (4 / PI);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 0, 0.55];\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  S.D = DSTAR * Math.pow(3, cl(kv[2], -1, 1));\n  S.A = cl(kv[3], 0.55, 0.95) * ACRIT;\n  if (!S.begun) prefill(S);\n  if (input.btnPressed && input.btnPressed[0]) scatter(S);\n  // Particle time this frame; a record row each time it passes a row mark.\n  let T = cl(dt || 0, 0, 0.1) * S.speed * RATE * ROWT;\n  while (T > 0) {\n    const step = min(T, S.toRow);\n    run(S, step);\n    T -= step;\n    S.toRow -= step;\n    if (S.toRow \u003c= 1e-9) {\n      writeRow(S);\n      S.toRow += ROWT;\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const C = S.col;\n  // Left well, right well, and the same two lighter for the particles. Of\n  // the two hues the one nearer blue is drawn dim: a dim red or yellow\n  // turns to maroon and olive on the panel, a dim blue or violet does not.\n  const ha = HUE0 + S.hue, hb = ha + HUE_GAP;\n  const dimA = coolness(ha) >= coolness(hb);\n  hsv(ha, dimA ? 0.72 : 0.86, dimA ? 0.5 : 1, C, 0);\n  hsv(hb, dimA ? 0.86 : 0.72, dimA ? 1 : 0.5, C, 3);\n  hsv(ha, 0.55, 1, C, 6);\n  hsv(hb, 0.6, 1, C, 9);\n\n  // The well band. The curve under the push now, one row per column.\n  const f = S.A * cos(OMEGA * S.t), cv = S.curve;\n  for (let c = 0; c \u003c W; c++) cv[c] = round(VY - VS * V(((c + 0.5 - 32) / 32) * XS, f));\n  // Ground under the curve: deep navy, so the well reads as a shape.\n  for (let c = 0; c \u003c W; c++) {\n    const top = max(0, cv[c] + 1);\n    for (let y = top; y \u003c BAND; y++) display.setPixel(c, y, 18, 12, 46);\n  }\n  // The curve itself, joined to its neighbours so the steep walls stay whole.\n  for (let c = 0; c \u003c W; c++) {\n    const a = cv[c], b = c ? cv[c - 1] : a, c1 = c \u003c W - 1 ? cv[c + 1] : a;\n    const lo = min(a, round((a + b) / 2), round((a + c1) / 2)), hi = max(a, round((a + b) / 2), round((a + c1) / 2));\n    for (let y = max(0, lo); y \u003c= min(BAND - 1, hi); y++) display.setPixel(c, y, 210, 210, 225);\n  }\n  // Particles resting on the curve, piled up where they crowd.\n  const pile = S.pile;\n  pile.fill(0);\n  for (let i = 0; i \u003c N; i++) {\n    const c = cl(floor((S.x[i] / XS + 1) * 32), 0, W - 1);\n    const y = cv[c] - 1 - pile[c]++;\n    if (y \u003c 0 || y >= BAND) continue;\n    const o = S.s[i] > 0 ? 9 : 6;\n    display.setPixel(c, y, C[o], C[o + 1], C[o + 2]);\n  }\n\n  // The meter along the top row, out from the middle both ways: 56 LEDs\n  // wide when the record is a square wave in perfect step with the push.\n  const mw = round(cl(S.R, 0, 1) * 28);\n  for (let c = 32 - mw; c \u003c 32 + mw; c++) display.setPixel(c, 0, 150, 150, 165);\n\n  // The record: newest row at the top, sinking a row at a time.\n  for (let r = 0; r \u003c NR; r++) {\n    const y = R0 + r, ring = (S.head + r) % NR, o = ring * N;\n    // The push's direction down both edges, in the colour of the well it favours.\n    const pc = S.push[ring] > 0 ? 3 : 0;\n    display.setPixel(0, y, C[pc], C[pc + 1], C[pc + 2]);\n    display.setPixel(W - 1, y, C[pc], C[pc + 1], C[pc + 2]);\n    for (let i = 0; i \u003c N; i++) {\n      const k = S.rec[o + i] ? 3 : 0;\n      display.setPixel(X0 + i, y, C[k], C[k + 1], C[k + 2]);\n    }\n  }\n}\n","vampire-coffin":"// ===== Patternflow pattern =====\n// Title:   Vampire Coffin\n// Family:  halloween\n// Idea:    An upright wooden coffin stands in a dim purple crypt under a moonlit lancet window, between two candles on iron stands and under cobwebbed vaulting, and every few seconds its lid creaks open a few degrees at a time on its hinge while cold green mist pours from the black crack and two red eyes peer out, then the lid swings wide towards us and a swarm of bats bursts out and wheels up through the vault and out of the top, the eyes blink and the lid slams shut, mist puffs from the seams, dust sifts down and the candle flames flatten in the draught and recover.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 46\n// Round:   46\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bats=24..72, Mist=0..1\n//\n// Knob 1: Hue. The mist and its light, with the eyes a third of the wheel behind; the candles, wood and stone keep their colours. At 0 toxic green mist and red eyes, at 0.25 sky-blue mist and lime eyes, at 0.5 magenta mist and cyan eyes, at 0.75 orange mist and violet eyes.\n// Knob 2: Speed. The crypt's clock. At 2 an opening takes about 6.5 s: four creaks 0.6 to 0.75 s apart, the swing wide 0.45 s, the slam 2.7 s after it, and the bats all gone out of the top within about 4 s; the first burst comes at 1.3 s. At 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Bats. How many bats burst out each time: 24 at the start, 36 at a quarter, 48 at half, 72 at the end. One in three swings close past us as a big 13-LED bat; the far side of each turn is small and dark.\n// Knob 4: Mist. How much mist pours while the lid is open, in puffs a second: 21 at 0, a thin stream that fades on the floor; 33 at 0.06 (the start); 46 at 0.25, a steady fall spreading both ways along the flagstones; 70 at 1, a glowing bank across the whole floor. Each burst adds a rush of 1.7 times as much for 1.2 s.\n// Buttons: K1 tap swings the lid wide and lets the bats out at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n  return out;\n}\n// Colour buffers, three floats an LED: set, blend towards, add.\nconst set = (C, p, r, g, b) => ((C[3 * p] = r), (C[3 * p + 1] = g), (C[3 * p + 2] = b));\nconst mix = (C, p, r, g, b, a) => ((C[3 * p] += (r - C[3 * p]) * a), (C[3 * p + 1] += (g - C[3 * p + 1]) * a), (C[3 * p + 2] += (b - C[3 * p + 2]) * a));\nconst add = (C, p, r, g, b, a) => ((C[3 * p] += r * a), (C[3 * p + 1] += g * a), (C[3 * p + 2] += b * a));\n\n// The crypt: the floor starts at row 108. The coffin stands on it, a\n// six-sided box from row 26 (head) through its shoulders at 46 to its foot\n// at 106, centred on x = 32; hw gives its half width on a row.\nconst FLOOR = 108, CT = 26, CS = 46, CB = 106, CX = 32;\nconst hw = (y) => (y \u003c CS ? 8 + (6 * (y - CT)) / (CS - CT) : 14 - (6 * (y - CS)) / (CB - CS));\n// The lid hinges on the vertical line through the left shoulder, is 2.5\n// LEDs thick, and comes towards a viewer 150 LEDs away at eye height 66.\nconst HX = CX - 14, THK = 2.5, VIEW = 150, VY = 66;\n// The candles: flame x, the row the flame stands on, and which way it\n// leans in the draught from the coffin.\nconst CANDLE = [[6, 53, -1], [58, 53, 1]];\n\n// ---------- the still crypt, drawn once ----------\nconst BG = new Float32Array(N * 3), LIT = new Float32Array(N), HALO = [new Float32Array(N), new Float32Array(N)];\nconst put = (x, y, r, g, b, a) => x >= 0 && x \u003c W && y >= 0 && y \u003c H && mix(BG, y * W + x, r, g, b, a);\nfunction line(x0, y0, x1, y1, r, g, b, a) {\n  const n = max(abs(x1 - x0), abs(y1 - y0)) * 2 + 1;\n  for (let i = 0; i \u003c= n; i++) put(round(x0 + ((x1 - x0) * i) / n), round(y0 + ((y1 - y0) * i) / n), r, g, b, a);\n}\n// Inside the pointed arch of the vault (springing at row 44), and inside the\n// lancet window above the coffin, grown by g.\nconst inVault = (x, y) => y >= 44 || ((x - 63.5) ** 2 + (y - 44) ** 2 \u003c= 3969 && (x - 0.5) ** 2 + (y - 44) ** 2 \u003c= 3969);\nconst inWindow = (x, y, g) => y \u003c= 24 + g && x >= 24 - g && x \u003c= 40 + g && (y >= 14 || ((x - 40 - g) ** 2 + (y - 14) ** 2 \u003c= (16 + 2 * g) ** 2 && (x - 24 + g) ** 2 + (y - 14) ** 2 \u003c= (16 + 2 * g) ** 2));\nconst ROWS = [108, 111, 115, 120, 126];\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const p = y * W + x, px = x + 0.5, py = y + 0.5;\n    let r = 14, g = 8, b = 21, lit = 0.6;\n    if (y >= FLOOR) {\n      // Flagstones in perspective towards (32, 70).\n      const k = ROWS.filter((v) => y >= v).length - 1, sc = (py - 70) / 38, u = (px - 32) / (11 * sc) + (k % 2) * 0.5;\n      const v = ROWS.includes(y) || u - floor(u) \u003c 0.09 / sc ? 0.45 : 0.8 + 0.25 * round(hash(k * 97 + floor(u) + 50) * 3) / 3;\n      (r = 30 * v), (g = 22 * v), (b = 40 * v), (lit = 1);\n    } else if (inVault(px, py)) {\n      // Stone blocks, 7 rows high and 12 wide, every other course offset,\n      // darker towards the vault; the arch's rib paler.\n      const k = floor(y / 7), u = x + (k % 2) * 6;\n      const v = (y % 7 === 0 || u % 12 === 0 ? 0.5 : 0.82 + 0.24 * round(hash(k * 131 + floor(u / 12)) * 3) / 3) * (0.62 + 0.38 * sm(0, 100, y));\n      (r = 36 * v), (g = 23 * v), (b = 50 * v), (lit = 1);\n      if (!inVault(px - 2, py - 2) || !inVault(px + 2, py - 2)) (r = 46), (g = 32), (b = 60);\n    }\n    if (y === FLOOR - 1) (r *= 0.5), (g *= 0.5), (b *= 0.5);\n    // The window: night sky, the moon, a mullion and a ring of tracery, in\n    // a frame of paler stone.\n    if (inWindow(px, py, 1.5)) (r = 58), (g = 44), (b = 74);\n    if (inWindow(px, py, 0)) {\n      const md = sqrt((px - 36) ** 2 + (py - 10.5) ** 2), sky = 0.75 + 0.25 * sm(24, 2, py);\n      (r = 44 * sky), (g = 40 * sky), (b = 92 * sky), (lit = 0);\n      if (md \u003c 4) (r = 205), (g = 196), (b = 225);\n      else if (md \u003c 6) (r += 30), (g += 28), (b += 36);\n      if ((abs(px - 32) \u003c 0.8 && py > 8.5) || abs(sqrt((px - 32) ** 2 + (py - 6) ** 2) - 2.6) \u003c 0.7) (r = 30), (g = 22), (b = 40);\n    }\n    // Moonlight falling from the window down the wall, in two steps.\n    if (y > 25 && y \u003c 64 && abs(px - 33) \u003c 9 + (py - 25) * 0.35) {\n      const m = py \u003c 44 ? 1 : 0.5;\n      (r += 9 * m), (g += 8 * m), (b += 16 * m);\n    }\n    set(BG, p, r, g, b);\n    LIT[p] = lit;\n  }\n// Cobwebs in both upper corners: radial threads with sagging cross threads.\nfor (const side of [0, 1]) {\n  const X = (x) => (side ? 63 - x : x), A = [0.08, 0.42, 0.78, 1.1, 1.45], at = (r, a) => [X(round(r * cos(a))), round(r * sin(a))];\n  for (const a of A) line(X(0), 0, ...at(24, a), 92, 86, 110, 0.55);\n  for (const rr of [6, 11, 16, 21])\n    for (let i = 0; i \u003c 4; i++) {\n      const m = at(rr * 0.86, (A[i] + A[i + 1]) / 2);\n      line(...at(rr, A[i]), ...m, 92, 86, 110, 0.4);\n      line(...m, ...at(rr, A[i + 1]), 92, 86, 110, 0.4);\n    }\n}\n// The iron stands, and on each a pillar of wax 4 wide, lit from above,\n// with drips down its side.\nfor (const [cx] of CANDLE) {\n  const x0 = cx - 1;\n  for (let y = 64; y \u003c FLOOR + 2; y++) put(x0, y, 24, 22, 28, 1), put(x0 + 1, y, 44, 40, 50, 1);\n  line(x0, FLOOR, x0 - 4, FLOOR + 5, 30, 28, 34, 1);\n  line(x0 + 1, FLOOR, x0 + 5, FLOOR + 5, 30, 28, 34, 1);\n  for (let x = cx - 4; x \u003c= cx + 3; x++) put(x, 63, 40, 36, 44, 1), put(x, 64, 28, 26, 32, x > cx - 4 && x \u003c cx + 3 ? 1 : 0);\n  for (let y = 54; y \u003c 63; y++)\n    for (let x = cx - 2; x \u003c= cx + 1; x++) {\n      const v = (x === cx - 2 ? 0.75 : x === cx + 1 ? 0.62 : 0.9) * (1.05 - (y - 54) * 0.04);\n      put(x, y, 200 * v, 178 * v, 140 * v, 1);\n    }\n  put(cx - 3, 56, 170, 150, 120, 1);\n  put(cx - 3, 57, 150, 132, 104, 1);\n  put(cx + 2, 55, 160, 140, 112, 1);\n}\n// The warm light each candle throws, in rings 3.5 LEDs apart.\nconst RING = [0.55, 0.42, 0.31, 0.22, 0.15, 0.09, 0.05];\nCANDLE.forEach(([cx, cy], i) => {\n  for (let p = 0; p \u003c N; p++) HALO[i][p] = RING[floor(sqrt(((p % W) + 0.5 - cx) ** 2 + ((floor(p / W) + 2.5 - cy) * 0.8) ** 2) / 3.5)] || 0;\n});\n\n// Bats in three sizes, three wing poses each: up, level, down.\nconst SPR = [\n  [[\"#.....#\", \".#.#.#.\", \"..###..\", \"...#...\"], [\"..#.#..\", \"#######\", \"#..#..#\", \".......\"], [\"..#.#..\", \".#####.\", \"#..#..#\", \"#.....#\"]],\n  [[\"#.......#\", \"##.#.#.##\", \".#######.\", \"...###...\", \"....#....\"], [\"...#.#...\", \".#######.\", \"#########\", \"#..###..#\", \"....#....\"], [\"...#.#...\", \"...###...\", \".#######.\", \"##.###.##\", \"#...#...#\"]],\n  [\n    [\"##.........##\", \".##..#.#..##.\", \"..##.###.##..\", \"...#######...\", \".....###.....\", \"......#......\"],\n    [\".....#.#.....\", \".....###.....\", \".###########.\", \"#############\", \"##...###...##\", \"#.....#.....#\"],\n    [\".....#.#.....\", \".....###.....\", \"....#####....\", \"..#########..\", \".##..###..##.\", \"##....#....##\"],\n  ],\n];\nconst MAXB = 72, MAXM = 360, DUST = 30;\nconst F32 = (n) => new Float32Array(n);\n\nexport function setup(params) {\n  params.s = {\n    t: 0, c: 0, hue: 0, speed: 2, bats: 24, mist: 0.06,\n    // The lid: its angle in degrees and the move it is making.\n    th: 0, seg: null, plan: null, draft: 0, shake: 0, eyes: 0, fl: [1, 1], fh: [6, 6], fx: [0, 0],\n    bt: F32(MAXB).fill(-9), bp: F32(4 * MAXB), nb: 0,\n    // Mist puffs: x, y, vx, vy, age, life; dust motes: x, y, age.\n    m: F32(6 * MAXM), nm: 0, macc: 0, dust: F32(3 * DUST).fill(9),\n    C: F32(3 * N), M: F32(N), GL: F32(N), K: new Uint8Array(N), mc: [0, 0, 0], ec: [0, 0, 0],\n  };\n}\n\n// One opening: the lid creaks a few degrees at a time, the eyes come, it\n// swings wide and the bats burst out, the eyes blink, it slams. The panel\n// opens on a lid already creaking, the first burst at 1.3 s; from the third\n// opening on, the coffin sometimes rests up to 2.5 s more.\nconst timesFrom = (P, b) => Object.assign(P, { burst: b, blink2: b + 2.2, slam: b + 2.7, end: b + 3.3 });\nfunction plan(S) {\n  const j = (a) => a + (Math.random() - 0.5) * 3, n = S.plan ? S.plan.n + 1 : 0;\n  let P;\n  if (!n) P = { creaks: [[0.2, j(16)], [0.7, j(34)]], eyes: 0.55, blink: 1, b: 1.3 };\n  else {\n    const t0 = 0.3 + Math.random() * 0.5 + (n > 1 && Math.random() \u003c 0.5 ? 2.5 * Math.random() : 0);\n    P = { creaks: [[t0, j(10)], [t0 + 0.6, j(21)], [t0 + 1.25, j(32)], [t0 + 2, j(44)]], eyes: t0 + 1.3, blink: t0 + 2.3, b: t0 + 2.7 };\n  }\n  S.plan = timesFrom(Object.assign(P, { n, k: 0, burstDone: false, slamDone: false }), P.b);\n}\n\nconst backOut = (u) => 1 + 2.70158 * (u - 1) ** 3 + 1.70158 * (u - 1) ** 2;\nfunction lidAngle(S) {\n  const g = S.seg;\n  if (!g) return S.th;\n  const u = cl((S.c - g.t0) / g.d, 0, 1);\n  // A creak: quick, then slower, with a stick-slip judder.\n  if (g.kind === 0) return g.a0 + (g.a1 - g.a0) * (1 - (1 - u) ** 3) + 0.9 * sin(u * PI * 6) * (1 - u);\n  if (g.kind === 1) return g.a0 + (g.a1 - g.a0) * backOut(u);\n  if (g.kind === 2) return g.a0 * (1 - u * u);\n  return 3.5 * sin(PI * u);\n}\nconst move = (S, d, a1, kind) => (S.seg = { t0: S.c, d, a0: S.th, a1, kind });\n\n// A puff of mist; when the pool is full, a random old one is reused.\nfunction puff(S, x, y, vx, vy) {\n  const o = 6 * (S.nm \u003c MAXM ? S.nm++ : floor(Math.random() * MAXM));\n  S.m.set([x, y, vx, vy, 0, 3.5 + Math.random() * 2.5], o);\n}\n\nfunction burst(S) {\n  const P = S.plan;\n  P.burstDone = true;\n  P.k = P.creaks.length;\n  move(S, 0.45, 106, 1);\n  S.draft = 1;\n  // The swarm: each bat starts somewhere in the dark of the coffin, at its\n  // own moment in the first 0.8 s, and wheels up round a rising centre.\n  S.nb = min(MAXB, round(S.bats));\n  for (let i = 0; i \u003c S.nb; i++) {\n    S.bt[i] = -(i / S.nb) * 0.7 - Math.random() * 0.1;\n    S.bp.set([32 + (Math.random() - 0.5) * 14, 40 + Math.random() * 50, Math.random() * 2 * PI, (Math.random() \u003c 0.8 ? 1 : -1) * (2.2 + Math.random() * 1.4)], 4 * i);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 24, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.bats = cl(k[2], 24, 72);\n  S.mist = cl(k[3], 0, 1);\n  if (!S.plan) plan(S);\n  const ds = (d * S.speed) / 2, P = S.plan;\n  S.t += ds;\n  S.c += ds;\n  if (input.btnPressed && input.btnPressed[0] && !P.burstDone) timesFrom(P, S.c), (P.eyes = min(P.eyes, S.c));\n  // Each creak stirs the air: the flames duck and the coffin breathes out\n  // a little mist.\n  while (P.k \u003c P.creaks.length && S.c >= P.creaks[P.k][0] && S.c \u003c P.burst) {\n    move(S, 0.3, P.creaks[P.k++][1], 0);\n    S.draft = max(S.draft, 0.35);\n    S.macc += 6;\n  }\n  if (!P.burstDone && S.c >= P.burst) burst(S);\n  if (P.burstDone && !P.slamDone && S.c >= P.slam) (P.slamDone = true), move(S, 0.2, 0, 2);\n  if (S.seg && S.seg.kind === 2 && S.c >= S.seg.t0 + S.seg.d) {\n    // The slam lands: the coffin shudders, the lid bounces once, the\n    // flames flatten again, mist squeezes out of the seams and dust is\n    // shaken down from the vault.\n    move(S, 0.3, 0, 3);\n    S.shake = 1;\n    S.draft = max(S.draft, 0.7);\n    for (let i = 0; i \u003c 26; i++) {\n      const y = CT + 4 + Math.random() * (CB - CT - 4), sd = i % 2 ? 1 : -1;\n      puff(S, CX + sd * hw(y), y, sd * (6 + Math.random() * 8), Math.random() * 2);\n    }\n    for (let i = 0; i \u003c DUST; i++) S.dust.set([Math.random() * W, Math.random() * 26, -Math.random() * 0.6], 3 * i);\n  }\n  S.th = lidAngle(S);\n  if (S.c >= P.end) (S.c = 0), plan(S);\n  // The eyes: fade in after the third creak, blink twice, gone at the slam.\n  const blink = (t) => S.c > t && S.c \u003c t + 0.16;\n  S.eyes = S.c \u003c P.eyes || P.slamDone ? 0 : sm(P.eyes, P.eyes + 0.45, S.c) * (blink(P.blink) || blink(P.blink2) ? 0 : 1);\n  S.draft *= exp(-ds * 1.3);\n  S.shake *= exp(-ds * 9);\n  // The flames: two noises each, flattened and pushed outwards by the draught.\n  for (let i = 0; i \u003c 2; i++) {\n    const n1 = vn(S.t * 4.3, 11 + i * 5), n2 = vn(S.t * 11, 23 + i * 7), dr = S.draft;\n    S.fh[i] = 7 + 1.3 * n1 + 0.6 * n2 - 4 * dr;\n    S.fx[i] = 0.7 * vn(S.t * 2.2, 41 + i) + CANDLE[i][2] * dr * (3.5 + 0.8 * sin(S.t * 13));\n    S.fl[i] = 0.82 + 0.16 * n1 + 0.1 * n2 - 0.45 * dr;\n  }\n  for (let i = 0; i \u003c S.nb; i++) if (S.bt[i] > -5) S.bt[i] += ds;\n  // Mist: poured from the gap while the lid is open, a wisp now and then\n  // through the seams when it is shut.\n  const ca = cos((min(S.th, 90) * PI) / 180), open = sm(0, 0.3, sqrt(1 - ca * ca));\n  const amount = 0.3 + 0.7 * sqrt(S.mist), surge = P.burstDone && S.c \u003c P.burst + 1.2 ? 1 : 0;\n  S.macc += ds * amount * (70 * open + 120 * surge + 3);\n  const gapL = HX + 28 * ca;\n  for (; S.macc >= 1; S.macc--) {\n    const x = S.th > 50 ? CX + (Math.random() - 0.5) * 16 : min(gapL + Math.random() * (CX + 14 - gapL), CX + 10);\n    puff(S, x, open > 0.05 ? 70 + Math.random() * 34 : CB - 1, (Math.random() - 0.3) * 4, 3 + Math.random() * 6);\n  }\n  const D = S.dust;\n  for (let i = 0; i \u003c DUST; i++)\n    if (D[3 * i + 2] \u003c 3) (D[3 * i + 2] += ds), (D[3 * i + 1] += ds * (7 + (i % 4))), (D[3 * i] += ds * 3 * sin(S.t * 2 + i));\n  const m = S.m;\n  for (let i = 0; i \u003c S.nm; i++) {\n    const o = 6 * i;\n    if (m[o + 4] >= m[o + 5]) continue;\n    m[o + 4] += ds;\n    if (m[o + 1] \u003c FLOOR + 2 + (i % 9)) {\n      // Cold mist sinks down the coffin's front.\n      m[o + 3] = min(16, m[o + 3] + 20 * ds);\n    } else {\n      // On the floor it spreads outwards and lifts a little as it thins.\n      m[o + 3] += (-1.5 - m[o + 3]) * min(1, 4 * ds);\n      m[o + 2] += ((m[o] \u003c CX ? -1 : 1) * (7 + (i % 5) * 2.5) - m[o + 2]) * min(1, 1.5 * ds);\n    }\n    m[o] += (m[o + 2] + 2.4 * vn(S.t * 1.3 + i, 77)) * ds;\n    m[o + 1] += m[o + 3] * ds;\n  }\n}\n\n// Where the lid face at offset off (0 front, THK back) meets the LED, in\n// the lid's own closed coordinates, or null.\nfunction lidHit(px, py, off, c, s) {\n  const u = (px - HX - off * s) / (abs(c) \u003c 0.03 ? (c \u003c 0 ? -0.03 : 0.03) : c);\n  if (u \u003c 0 || u > 29) return null;\n  const y = VY + ((py - VY) * (VIEW - (u * s - off * c))) / VIEW, x = HX + u;\n  return y \u003c CT || y > CB || abs(x - CX) > hw(y) ? null : [x, y];\n}\n// Distance inside the coffin's outline.\nconst inset = (x, y) => min(hw(y) - abs(x - CX), y - CT, CB - y);\n// Buttoned satin, on a diamond grid 4 LEDs across, times v.\nfunction satin(x, y, v) {\n  const a = (x + y) / 4, b = (x - y) / 4, fa = a - floor(a) - 0.5, fb = b - floor(b) - 0.5;\n  v *= fa * fa + fb * fb \u003c 0.03 ? 0.45 : abs(fa) + abs(fb) \u003c 0.3 ? 1.05 : 0.75;\n  return [84 * v, 10 * v, 30 * v];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const C = S.C, M = S.M, GL = S.GL, K = S.K, MC = hsv(0.33 + S.hue, 0.62, 1, S.mc), EC = hsv(S.hue, 0.9, 1, S.ec);\n  C.set(BG);\n  K.fill(0);\n  const th = (S.th * PI) / 180, c = cos(th), s = sin(th), sx = round(S.shake * 1.4 * sin(S.t * 70));\n  const open = sm(0, 0.4, sin(min(th, PI / 2))), shade = 0.2 + 0.8 * sm(45, 95, S.th);\n  // The coffin's box: its right side, then the inside, which only shows\n  // where the lid is not. Barely open, the lid keeps the inside in shadow,\n  // a black crack.\n  for (let y = CT; y \u003c CB; y++)\n    for (let x = 14; x \u003c 50; x++) {\n      const p = y * W + x, px = x + 0.5 - sx, py = y + 0.5, e = hw(py), dx = px - CX;\n      if (dx > e && dx \u003c e + 2.2) {\n        const v = py \u003c CT + 1.5 ? 1.4 : 1;\n        set(C, p, 36 * v, 17 * v, 15 * v);\n        K[p] = 1;\n      } else if (abs(dx) \u003c= e) {\n        const d = inset(px, py), gl = open * 0.3 * sm(50, CB, py);\n        K[p] = 2;\n        if (d \u003c 1) set(C, p, 60 * shade, 28 * shade, 22 * shade);\n        else if (d \u003c 3.4) set(C, p, ...satin(px, py, shade));\n        // The black inside, with the mist's glow rising from the bottom.\n        else set(C, p, 4 + MC[0] * gl, 2 + MC[1] * gl, 6 + MC[2] * gl);\n      }\n    }\n  // The eyes, at head height in the dark: peering out of the gap while it\n  // is narrow, in the middle once the lid is wide.\n  if (S.eyes > 0.01) {\n    const e = CX + hw(37), mid = max(CX, (HX + (e - HX) * c + e) / 2 - 0.5), ex = CX + (mid - CX) * (1 - sm(35, 70, S.th));\n    for (const ox of [-1.5, 1.5])\n      for (let yy = -2; yy \u003c= 2; yy++)\n        for (let xx = -2; xx \u003c= 2; xx++) {\n          const p = (37 + yy) * W + floor(ex + ox + sx) + xx;\n          if (K[p] === 2) mix(C, p, EC[0], EC[1] * 0.6, EC[2] * 0.6, (xx || yy ? 0.4 / (xx * xx + yy * yy + 0.5) : 1) * S.eyes);\n        }\n  }\n  // The lid, swung th about its hinge: the face towards us (wood in front,\n  // satin behind), and the slab's edge where only the other face reaches.\n  const front = c >= 0;\n  for (let y = CT - 10; y \u003c= CB + 10; y++)\n    for (let x = front ? HX - 2 : 6; x \u003c 50; x++) {\n      const p = y * W + x, px = x + 0.5 - sx, py = y + 0.5, h = lidHit(px, py, front ? 0 : THK, c, s);\n      if (h) {\n        const [lx, ly] = h, d = inset(lx, ly);\n        if (front) {\n          // Planks running the length of the lid, a carved moulding 3 in\n          // from the edge, two iron hinge straps and a ring; it darkens as\n          // it turns from the light.\n          const sh = 0.6 + 0.4 * c, v = (d > 2.5 && d \u003c 3.5 ? 1.35 : d >= 3.5 && d \u003c 4.5 ? 0.6 : 0.85 + 0.2 * round(hash(floor(lx) * 31 + floor(ly / 13)) * 2) / 2) * sh;\n          if (lx - (CX - hw(ly)) \u003c 3.5 && lx - HX \u003c 4 && ((ly > 36 && ly \u003c 39) || (ly > 92 && ly \u003c 95))) set(C, p, 46 * sh, 44 * sh, 54 * sh);\n          else if (abs(lx - (CX + hw(ly) - 3)) \u003c 1 && abs(ly - 68) \u003c 1.5) set(C, p, 56 * sh, 52 * sh, 62 * sh);\n          else set(C, p, 76 * v, 37 * v, 29 * v);\n        } else {\n          const sh = 0.55 - 0.45 * c;\n          if (d \u003c 1.6) set(C, p, 50 * sh, 24 * sh, 20 * sh);\n          else set(C, p, ...satin(lx, ly, sh));\n        }\n      } else if (lidHit(px, py, front ? THK : 0, c, s)) set(C, p, 92, 50, 36);\n      else continue;\n      K[p] = 1;\n    }\n  // Candlelight on everything but the dark inside of the coffin.\n  for (let p = 0; p \u003c N; p++) {\n    const l = (HALO[0][p] * S.fl[0] + HALO[1][p] * S.fl[1]) * (K[p] === 2 ? 0.1 : K[p] === 1 ? 0.8 : LIT[p]);\n    if (l > 0) add(C, p, 255, 120, 40, l);\n  }\n  // Mist: each puff a soft disc that grows as it ages and flattens into a\n  // low bank on the floor, and throws its light twice as far as it reaches.\n  M.fill(0);\n  GL.fill(0);\n  const m = S.m;\n  for (let i = 0; i \u003c S.nm; i++) {\n    const o = 6 * i, a = m[o + 4], L = m[o + 5], mx = m[o], my = m[o + 1];\n    if (a >= L) continue;\n    const al = sm(0, 0.4, a) * (1 - sm(L * 0.55, L, a)) * 0.19, r = 2.5 + 6 * (a / L), fl = my > FLOOR ? 0.55 : 1, rx = r * (2 - fl), ry = r * fl;\n    for (let y = max(0, floor(my - 2 * ry)); y \u003c= min(H - 1, floor(my + 2 * ry)); y++)\n      for (let x = max(0, floor(mx - 2 * rx)); x \u003c= min(W - 1, floor(mx + 2 * rx)); x++) {\n        const dd = ((x + 0.5 - mx) / rx) ** 2 + ((y + 0.5 - my) / ry) ** 2;\n        if (dd \u003c 4) GL[y * W + x] += al * (1 - dd / 4);\n        if (dd \u003c 1) M[y * W + x] += al * (1 - dd);\n      }\n  }\n  // The light where puffs crowd, in three steps; the mist itself as light\n  // in six: thin mist tints what is behind it, thick mist glows pale.\n  for (let p = 0; p \u003c N; p++) {\n    const q = min(5, floor(M[p] * 6)) / 5, w = max(0, q - 0.6) * 200;\n    add(C, p, MC[0], MC[1], MC[2], min(3, floor(GL[p] * 6)) * 0.06);\n    if (M[p] >= 0.04) add(C, p, MC[0] + w, MC[1] + w, MC[2] + w, 0.1 + 0.5 * q);\n  }\n  // Bats, wheeling up round a rising centre and out of the top. The far\n  // side of each turn is drawn small and dark purple, the near side black\n  // with moonlight on the top edge of its wings; one bat in three swings\n  // close past us there.\n  const bats = [];\n  for (let i = 0; i \u003c S.nb; i++) {\n    const t = S.bt[i], o = 4 * i;\n    if (t \u003c 0) continue;\n    const rad = (10 + (i % 7) * 2.6) * (1 - exp(-t / 0.45)), a = S.bp[o + 2] + S.bp[o + 3] * t;\n    const x = CX + 4 * sin(0.7 * t + i) + rad * sin(a) + 1.5 * vn(t * 3 + i * 7, 5), y = S.bp[o + 1] - (12 * t + 6 * t * t) + rad * 0.35 * cos(a) + 1.2 * vn(t * 3 + i * 7, 9);\n    if (y \u003c -10) S.bt[i] = -9;\n    else bats.push([x, y, cos(a) \u003c -0.2 ? 0 : i % 3 === 0 && cos(a) > 0.5 ? 2 : 1, floor((t * (7 + (i % 3)) + i * 0.3) * 4) % 4]);\n  }\n  const blit = (bt) => {\n    const spr = SPR[bt[2]][[0, 1, 2, 1][bt[3]]], h = spr.length, w = spr[0].length, x0 = round(bt[0] - w / 2), y0 = round(bt[1] - h / 2);\n    for (let j = 0; j \u003c h; j++)\n      for (let i = 0; i \u003c w; i++) {\n        const x = x0 + i, y = y0 + j;\n        if (spr[j][i] !== \"#\" || x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        if (!bt[2]) set(C, y * W + x, 26, 14, 36);\n        else if (!j || spr[j - 1][i] !== \"#\") set(C, y * W + x, 84, 68, 104);\n        else set(C, y * W + x, 6, 3, 10);\n      }\n  };\n  const D = S.dust;\n  for (let i = 0; i \u003c DUST; i++) {\n    const a = D[3 * i + 2], x = floor(D[3 * i]), y = floor(D[3 * i + 1]);\n    if (a >= 0 && a \u003c 3 && x >= 0 && x \u003c W && y \u003c H) mix(C, y * W + x, 150, 140, 160, 0.55 * (1 - a / 3));\n  }\n  for (const b of bats) if (!b[2]) blit(b);\n  // Flames: teardrops with a white core, leaning in the draught.\n  for (let i = 0; i \u003c 2; i++) {\n    const [fx, fy] = CANDLE[i], h = max(1.5, S.fh[i]), L = S.fx[i], f = S.fl[i];\n    for (let y = floor(fy - h - 1); y \u003c= fy + 1; y++)\n      for (let x = fx - 6; x \u003c= fx + 5; x++) {\n        const t = (fy - y) / h, wv = 2.74 * sqrt(max(0, (t + 0.25) * (1 - t))), dx = abs(x + 0.5 - fx - L * t * t);\n        if (t \u003c -0.25 || t > 1 || dx > wv) continue;\n        const col = t \u003c 0.55 && dx \u003c 0.5 * wv ? [255, 240, 200] : t > 0.7 ? [235, 105, 30] : [255, 175, 60];\n        set(C, y * W + x, col[0] * f + 30, col[1] * f + 10, col[2] * f);\n      }\n  }\n  for (const b of bats) if (b[2]) blit(b);\n  // Channels go out in steps of 6, which the eye does not see on the panel\n  // and which keeps the soft light from turning into noise.\n  const q6 = (v) => min(255, round(v / 6) * 6);\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, floor(p / W), q6(C[3 * p]), q6(C[3 * p + 1]), q6(C[3 * p + 2]));\n}\n","candy-corn":"// ===== Patternflow pattern =====\n// Title:   Candy Corn\n// Family:  halloween\n// Idea:    Candy corn kernels, white tip, orange middle and yellow base, pour in three wandering streams from above the panel, tumble end over end down all 128 rows, bounce off a growing heap, slide down its slopes and settle at random angles, and when the heap stands high the floor splits into a trapdoor and the whole heap drops out the bottom while the pour goes on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Pour=14..44, Bounce=0..1\n//\n// Knob 1: Hue. The night behind the candy and the trapdoor floor, kept to the cool side so the night never turns brown: deep purple at 0, blue at 0.25, teal at 0.5, green at 0.75 and a toxic yellow-green at 1. The candy keeps its own colours.\n// Knob 2: Speed. Runs the whole scene faster or slower: at 2 a kernel takes about 2.6 seconds to fall the panel, and at the lowest pour the heap fills in 4.5 to 6 seconds and drains in about 2; at 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Pour. Kernels a second at Speed 2, 14 to 44. At 14 about 40 kernels are in the air at once and the heap fills and drops every 6.5 to 8 seconds; at 44 about 120 are in the air and it goes every 4.5 seconds.\n// Knob 4: Bounce. How hard a kernel bounces off the heap: at 0.06 it keeps a fifth of its speed, hops less than a row and skids; at 1 it keeps nine tenths, springs back up 4 to 10 rows and skitters sideways up to 25 LEDs, so the heap spreads flatter.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sin, cos, abs, round, random, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * random();\nconst gauss = () => (random() + random() + random() - 1.5) * 1.15;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The three bands of a kernel, base to tip. The orange is full and bright:\n// any darker and it reads brown on LEDs.\nconst YELLOW = [255, 205, 18], ORANGE = [255, 112, 0], WHITE = [255, 248, 232];\n// A kernel is 8 LEDs from base to tip and 5.8 across the base, give or\n// take the 0.98 to 1.14 size each kernel draws.\nconst LEN = 8, BASE = 2.9;\n// The floor: its top row, and the rows under it where the trapdoor swings.\nconst FLOOR = 120;\n// Fall: gravity and the speed drag holds a kernel to, in LEDs per second at\n// Speed 2. Candy is light; at 55 a second a kernel stays about a second in\n// the top third, and that is what keeps the top of the panel busy.\nconst G = 150, VT = 55;\n// The heap is full when its mean height over the middle columns reaches\n// this many rows, or one peak reaches PEAK.\nconst FULL = 40, PEAK = 66;\n// The trapdoor opens and closes in this many seconds.\nconst DOOR = 0.35;\n// Rows a kernel may overlap those under it, and the drop over 4 columns\n// past which a kernel slides on: about the angle a heap of candy holds.\nconst OVERLAP = 3, SLOPE = 4;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, pour: 14, bounce: 0.06,\n    kernels: [], acc: 0,\n    // Height of the heap's surface: the top lit row in each column.\n    surf: new Float32Array(W).fill(FLOOR),\n    // The settled heap, drawn once into a buffer as each kernel comes to rest.\n    heap: new Uint8Array(N * 3), mask: new Uint8Array(N),\n    door: 0, open: false, held: 0, warm: 0,\n    bg: null, bgHue: NaN,\n  };\n}\n\n// The corners of a kernel at angle a, in panel offsets from its centre: the\n// two base corners and the two sides of the blunt tip. The tip points up at\n// angle 0.\nfunction extent(k) {\n  const L = LEN * k.sz, B = BASE * k.sz, sa = sin(k.a), ca = cos(k.a);\n  let x0 = 9, x1 = -9, y1 = -9;\n  for (const [s, t] of [[-L / 2, -B], [-L / 2, B], [L / 2, -0.3 * B], [L / 2, 0.3 * B]]) {\n    const dx = s * sa + t * ca, dy = -s * ca + t * sa;\n    x0 = min(x0, dx);\n    x1 = max(x1, dx);\n    y1 = max(y1, dy);\n  }\n  return [x0, x1, y1];\n}\n\n// Every LED the kernel covers, with its colour: a blunt triangle with a\n// rounded base, banded yellow, orange and white from base to tip.\nfunction raster(k, out) {\n  const L = LEN * k.sz, B = BASE * k.sz, sa = sin(k.a), ca = cos(k.a), R = L / 2 + 1;\n  for (let py = floor(k.y - R); py \u003c= ceil(k.y + R); py++) {\n    if (py \u003c 0 || py >= H) continue;\n    for (let px = floor(k.x - R); px \u003c= ceil(k.x + R); px++) {\n      if (px \u003c 0 || px >= W) continue;\n      const dx = px + 0.5 - k.x, dy = py + 0.5 - k.y;\n      const s = dx * sa - dy * ca, t = dx * ca + dy * sa, q = (s + L / 2) / L;\n      if (q \u003c 0 || q > 1) continue;\n      let hw = B * (1 - 0.74 * q);\n      if (q \u003c 0.16) hw *= 0.78 + 1.375 * q;\n      if (abs(t) > hw) continue;\n      out(px, py, q \u003c 0.37 ? YELLOW : q \u003c 0.7 ? ORANGE : WHITE);\n    }\n  }\n}\n\nfunction spawn(S) {\n  // Three streams whose mouths wander slowly across the top, out of step.\n  const i = floor(random() * 3), c = 32 + 21 * sin(S.t * (0.23 + 0.07 * i) + 2.1 * i);\n  S.kernels.push({\n    x: cl(c + gauss() * 3.5, 4, 60), y: -5, vx: gauss() * 7, vy: rnd(4, 16),\n    a: rnd(0, TAU), w: gauss() * 6, st: 0, slide: 0, delay: 0, drop: 0, sz: rnd(0.98, 1.14), sh: rnd(0.86, 1),\n  });\n}\n\n// How far a kernel has sunk into the heap: the most any of its LEDs lies\n// below the surface row of its column, less the three rows a kernel may\n// overlap the ones it rests on. The overlap packs the heap the way a jumble\n// of candy looks; resting on the top row alone left it full of holes. Also\n// notes the column where the kernel sank deepest.\nfunction sink(S, k) {\n  let p = -1e9;\n  const surf = S.surf;\n  raster(k, (x, y) => {\n    const v = y - surf[x] + 1 - OVERLAP;\n    if (v > p) (p = v), (S.deep = x);\n  });\n  return p;\n}\n\n// Stamp a kernel into the heap and raise the surface under it.\nfunction settle(S, k) {\n  k.st = 2;\n  const heap = S.heap, mask = S.mask, surf = S.surf, sh = k.sh;\n  raster(k, (x, y, c) => {\n    const i = y * W + x;\n    heap[i * 3] = c[0] * sh;\n    heap[i * 3 + 1] = c[1] * sh;\n    heap[i * 3 + 2] = c[2] * sh;\n    mask[i] = 1;\n    if (y \u003c surf[x]) surf[x] = y;\n  });\n}\n\nfunction step(S, k, d) {\n  const e = 0.15 + 0.75 * S.bounce;\n  if (k.st === 3) {\n    // Waiting on the open trapdoor: the bottom of the heap goes first.\n    k.delay -= d;\n    if (k.delay \u003c= 0) k.st = 0;\n    return;\n  }\n  const ox = k.x, oy = k.y, oa = k.a;\n  if (k.st === 0) {\n    k.vy += (G - (G / VT) * k.vy) * d;\n    k.vx -= k.vx * 0.8 * d;\n    k.x += k.vx * d;\n    k.y += k.vy * d;\n    k.a += k.w * d;\n  }\n  const [x0, x1] = extent(k);\n  // The side walls of the panel.\n  if (k.x + x0 \u003c 0) (k.x = -x0), (k.vx = abs(k.vx) * 0.4);\n  if (k.x + x1 > W) (k.x = W - x1), (k.vx = -abs(k.vx) * 0.4);\n  // Under the floor line, or with the trapdoor open, nothing holds a kernel.\n  if (S.open || k.y > FLOOR + 3) return;\n  if (k.st === 0) {\n    let p = sink(S, k);\n    if (p \u003c= 0) return;\n    // Sunk deeper than this step's fall: it ran into the side of a peak, not\n    // onto it. Take back the sideways move and the turn and glance off;\n    // lifting it to the top instead built the heap into thin towers.\n    const fair = max(0, k.y - oy) + 1.5;\n    if (p > fair) {\n      k.x = ox;\n      k.a = oa;\n      k.vx = -k.vx * 0.5;\n      k.w = -k.w * 0.5;\n      p = sink(S, k);\n      if (p > fair) {\n        k.x += k.x \u003c S.deep + 0.5 ? -1 : 1;\n        k.vx += k.x \u003c S.deep + 0.5 ? -6 : 6;\n        return;\n      }\n      if (p \u003c= 0) return;\n    }\n    k.y -= p;\n    if (k.vy > 20) {\n      // A bounce: back up with some of its speed, kicked sideways and spun.\n      k.vy = -k.vy * e * rnd(0.7, 1.1);\n      k.vx = k.vx * 0.4 + gauss() * (6 + 40 * e);\n      k.w = gauss() * (6 + 12 * e);\n      return;\n    }\n    k.st = 1;\n    k.slide = 0;\n  }\n  // On the heap: slide down the steeper side while the slope is steeper\n  // than the candy can hold, rolling as it goes, then come to rest.\n  const c = cl(floor(k.x), 0, W - 1), surf = S.surf;\n  const top = min(surf[max(0, c - 1)], surf[c], surf[min(W - 1, c + 1)]);\n  const l = c >= 4 ? surf[c - 4] : -1e9, r = c \u003c= W - 5 ? surf[c + 4] : -1e9;\n  const drop = max(l, r) - top, dir = r > l ? 1 : -1;\n  k.slide += d;\n  if (drop >= SLOPE && k.slide \u003c 1.6) {\n    const sx = k.x, sa = k.a;\n    k.x += dir * 22 * d;\n    k.a += dir * 5 * d;\n    const p = sink(S, k);\n    if (p > 1.5) {\n      // Slid into something higher: stop where it was.\n      k.x = sx;\n      k.a = sa;\n      settle(S, k);\n    } else if (p \u003c -2) {\n      // Off the edge of a step it falls again.\n      (k.st = 0), (k.vy = 0), (k.vx = dir * 16);\n    } else k.y -= p;\n    return;\n  }\n  settle(S, k);\n}\n\n// One step of the scene, d seconds of scene time.\nfunction advance(S, d) {\n  S.t += d;\n  S.acc += S.pour * d;\n  while (S.acc >= 1) {\n    S.acc -= 1;\n    spawn(S);\n  }\n  // Two sub-steps a frame keep a fast kernel from passing through a peak.\n  for (let n = 0; n \u003c 2; n++) for (const k of S.kernels) if (k.st !== 2) step(S, k, d / 2);\n  S.kernels = S.kernels.filter((k) => k.y \u003c H + 10);\n  // The trapdoor.\n  if (!S.open) {\n    S.door = max(0, S.door - d / DOOR);\n    let sum = 0, peak = FLOOR;\n    for (let x = 6; x \u003c W - 6; x++) (sum += FLOOR - S.surf[x]), (peak = min(peak, S.surf[x]));\n    if (sum / (W - 12) >= FULL || FLOOR - peak >= PEAK) {\n      S.open = true;\n      S.held = 0;\n      // Every kernel in the heap lets go, the lowest first and the top ones\n      // up to 0.4 seconds later, each with a little spin, so the heap pours\n      // out from below instead of dropping as one block.\n      for (const k of S.kernels) if (k.st === 2 || k.st === 1) (k.st = 3), (k.drop = 1), (k.delay = (FLOOR - k.y) * 0.009 + random() * 0.06), (k.vy = 0), (k.vx = gauss() * 5), (k.w = gauss() * 4);\n      S.heap.fill(0);\n      S.mask.fill(0);\n    }\n  } else {\n    S.door = min(1, S.door + d / DOOR);\n    S.held += d;\n    if (S.held > 0.6 && !S.kernels.some((k) => k.drop)) {\n      S.open = false;\n      S.surf.fill(FLOOR);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 14, 0.06];\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.pour = cl(kv[2], 14, 44);\n  S.bounce = cl(kv[3], 0, 1);\n  // The pattern opens on a pour already under way: the first 2.2 seconds\n  // of candy have fallen and the heap has begun.\n  if (!S.warm) {\n    S.warm = 1;\n    for (let n = 0; n \u003c 66; n++) advance(S, 1 / 30);\n  }\n  advance(S, cl(dt || 0, 0, 0.1) * (S.speed / 2));\n}\n\nfunction backdrop(S) {\n  // Night behind the candy, kept at or under 24 of 255 so only the candy\n  // and the floor count as lit, a little lighter toward the floor.\n  const h = 0.78 - 0.55 * S.hue;\n  S.bg = new Uint8Array(H * 3);\n  for (let y = 0; y \u003c H; y++) {\n    const c = hsv(h, 0.85, 0.05 + 0.044 * (y / H));\n    for (let j = 0; j \u003c 3; j++) S.bg[y * 3 + j] = round(255 * c[j]);\n  }\n  S.floor = hsv(h, 0.55, 0.85);\n  S.floorDark = hsv(h, 0.7, 0.5);\n  S.bgHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.bgHue !== S.hue) backdrop(S);\n  const bg = S.bg, heap = S.heap, mask = S.mask;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (mask[i]) display.setPixel(x, y, heap[i * 3], heap[i * 3 + 1], heap[i * 3 + 2]);\n      else display.setPixel(x, y, bg[y * 3], bg[y * 3 + 1], bg[y * 3 + 2]);\n    }\n  // The trapdoor: two leaves hinged at the walls, swinging down from the\n  // floor line as it opens. Drawn under the candy so kernels fall in front.\n  const th = (S.door * PI) / 2, fc = S.floor, fd = S.floorDark;\n  for (let side = 0; side \u003c 2; side++)\n    for (let r = 0; r \u003c 32; r += 0.5)\n      for (let w = 0; w \u003c 2; w++) {\n        const px = side ? W - 1 - r * cos(th) : r * cos(th), py = FLOOR + w + r * sin(th);\n        const x = round(px), y = round(py);\n        if (y >= H || x \u003c 0 || x >= W || mask[y * W + x]) continue;\n        const c = w ? fd : fc;\n        display.setPixel(x, y, round(255 * c[0]), round(255 * c[1]), round(255 * c[2]));\n      }\n  // Kernels in the air and on the move, over the heap.\n  for (const k of S.kernels) {\n    if (k.st === 2) continue;\n    const sh = k.sh;\n    raster(k, (x, y, c) => display.setPixel(x, y, round(c[0] * sh), round(c[1] * sh), round(c[2] * sh)));\n  }\n}\n","corn-maze":"// ===== Patternflow pattern =====\n// Title:   Corn Maze\n// Family:  halloween\n// Idea:    Seen from above at night, someone with a flashlight steps into a corn maze and walks its dirt paths, the warm beam lighting the corn tops ahead while the corridors behind the corn fall into violet shadow, until at a dead end two green eyes glint back out of the stalks, the beam shakes, and the walker turns and runs.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Beam=0..1, Moon=0..1\n//\n// Knob 1: Hue. The colour of the flashlight: warm amber at 0, orange-gold at 0.95, toxic green at 0.2, cold blue at 0.45 and violet at 0.6; the eyes stay green, or turn yellow while the beam itself is green.\n// Knob 2: Speed. How fast the walker goes: at 2 it walks 15 LEDs a second, about two corridors, and runs 36 after the eyes; at 0.2 it creeps ten times slower, at 3 half as fast again. The pauses at the dead ends scale with it.\n// Knob 3: Beam. The flashlight's reach and spread: at 0 the cone is 68 LEDs long and 103 degrees wide, so pointed up the aisle it fills the half of the panel ahead of the walker; at 1 it is 94 long and 126 wide and lights most of the panel.\n// Knob 4: Moon. Moonlight on the corn tops outside the beam: at 0.06 the brightest stalks reach 20 of 255, just enough to hint at the maze in a dark room; at 1 the whole maze stands out lilac and the beam is a warm patch on it.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, atan2, sqrt, ceil, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The maze: 8 by 16 cells of 8 LEDs. Each cell keeps a 4 by 4 patch of path\n// in its middle, so corridors are 4 wide and the corn between them 4 thick\n// (2 on the outer edge). A stalk row any thinner reads as a drawn line, not\n// as a field.\nconst P = 8, CW = 8, CH = 16;\n// The top cell row of the entrance aisle.\nconst AISLE_TOP = 3;\n// Materials: trampled path, a gap between stalks, a leaf, a tassel.\nconst PATH = 0, GAP = 1, LEAF = 2, TASSEL = 3;\n// The torch is held up over the corn, so the tops of the stalks catch the\n// beam all over the cone; each row of corn the light has crossed takes this\n// share off the tops beyond it.\nconst CORN_PASS = 0.94;\n// How far the beam fades over its last quarter.\nconst FAR = 0.25;\n// The ground behind corn gets only this share of the light over the tops: the\n// paths beyond a wall lie in the corn's shadow.\nconst GROUND_SHADOW = 0.45;\n// The shadowed ground takes the night's violet, lifted a little: blue\n// carries the least light of the three, and at the same level it reads dimmer.\nconst SHADOW = hsv(0.765, 0.7, 1), SHADOW_LIFT = 1.3;\n// The pool of spill light round the torch, LEDs.\nconst POOL = 6.5;\n// Below this the beam is not drawn at all, so the shadows end hard.\nconst CUT = 0.36;\n// Walking pace at Speed 2, LEDs a second, and how much faster a run is.\nconst WALK = 15, RUN = 2.4;\n// Story seconds (one a second at Speed 2): standing at the entrance, looking\n// at a dead end, staring at the eyes, and how long a run lasts.\nconst ENTER = 2.25, LOOK = 0.7, STARE = 1.25, RUNFOR = 2.2;\n\nconst cx0 = (c) => (c % CW) * P + 3.5 + 0.5, cy0 = (c) => floor(c / CW) * P + 3.5 + 0.5;\n\nexport function setup(params) {\n  const S = (params.s = {\n    t: 0, hue: 0, speed: 2, beamK: 0, moon: 0.06,\n    east: new Uint8Array(CW * CH), south: new Uint8Array(CW * CH),\n    path: new Uint8Array(N), phase: new Float32Array(N), light: new Float32Array(N), shade: new Uint8Array(N),\n    aisle: 3, route: [], seg: 0, u: 0, mode: \"enter\", timer: 0, visits: new Uint16Array(CW * CH),\n    wx: 0, wy: 0, ang: -PI / 2, look: -PI / 2, stride: 0, power: 1, jitter: 0,\n    eyes: null, seen: 0, flick: 0, nextFlick: 8 + 6 * Math.random(), runLeft: 0, deadAt: -1, sub: new Uint8Array(CW * CH), up: new Int16Array(CW * CH),\n  });\n  buildMaze(S);\n  rootTree(S);\n  // The walker starts in the entrance gap at the foot of the aisle, facing in.\n  const c = 15 * CW + S.aisle;\n  S.wx = cx0(c);\n  S.wy = cy0(c) + 2;\n  S.route = [];\n  for (let cy = 15; cy >= AISLE_TOP; cy--) S.route.push(cy * CW + S.aisle);\n  S.seg = 0;\n  S.u = -2;\n  S.visits[c] = 1;\n}\n\n// A recursive backtracker grown from a straight entrance aisle. The aisle\n// runs up from a gap in the bottom edge through 13 of the 16 cell rows, the\n// way a field maze is often cut, and ends blind: its top cell takes no\n// branch. The backtracker grows the rest of the maze off its other cells.\nfunction buildMaze(S) {\n  const { east, south } = S;\n  const seen = new Uint8Array(CW * CH);\n  S.aisle = Math.random() \u003c 0.5 ? 3 : 4;\n  const stack = [];\n  for (let cy = AISLE_TOP; cy \u003c= 15; cy++) {\n    const c = cy * CW + S.aisle;\n    seen[c] = 1;\n    if (cy \u003c 15) south[c] = 1;\n    if (cy > AISLE_TOP) stack.splice(floor(Math.random() * (stack.length + 1)), 0, c);\n  }\n  while (stack.length) {\n    const c = stack[stack.length - 1], x = c % CW, y = floor(c / CW);\n    const opts = [];\n    if (x > 0 && !seen[c - 1]) opts.push(c - 1);\n    if (x \u003c CW - 1 && !seen[c + 1]) opts.push(c + 1);\n    if (y > 0 && !seen[c - CW]) opts.push(c - CW);\n    if (y \u003c CH - 1 && !seen[c + CW]) opts.push(c + CW);\n    if (!opts.length) {\n      stack.pop();\n      continue;\n    }\n    const n = opts[floor(Math.random() * opts.length)];\n    if (n === c + 1) east[c] = 1;\n    else if (n === c - 1) east[n] = 1;\n    else if (n === c + CW) south[c] = 1;\n    else south[n] = 1;\n    seen[n] = 1;\n    stack.push(n);\n  }\n  // Mark the LEDs: path where a cell or a link between cells is, and the\n  // entrance gap; corn everywhere else.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const cx = floor(x / P), cy = floor(y / P), lx = x - cx * P, ly = y - cy * P, c = cy * CW + cx;\n      const inX = lx >= 2 && lx \u003c= 5, inY = ly >= 2 && ly \u003c= 5;\n      let p = inX && inY;\n      if (inY && lx >= 6 && east[c]) p = true;\n      if (inY && lx \u003c= 1 && cx > 0 && east[c - 1]) p = true;\n      if (inX && ly >= 6 && (south[c] || (cy === 15 && cx === S.aisle))) p = true;\n      if (inX && ly \u003c= 1 && cy > 0 && south[c - CW]) p = true;\n      const i = y * W + x;\n      S.path[i] = p ? 1 : 0;\n      S.phase[i] = hash(i * 7 + 3);\n    }\n}\n\n// How many cells lie beyond the step from c to n: the maze is a tree, so\n// rooted at cell 0 this is n's subtree when n hangs below c, and everything\n// but c's subtree when n is c's parent. A runner prefers the roomier way.\nfunction rootTree(S) {\n  const order = [0], seen = new Uint8Array(CW * CH);\n  seen[0] = 1;\n  S.up.fill(-1);\n  for (let k = 0; k \u003c order.length; k++)\n    for (const n of neighbours(S, order[k])) if (!seen[n]) (seen[n] = 1), (S.up[n] = order[k]), order.push(n);\n  S.sub.fill(1);\n  for (let k = order.length - 1; k > 0; k--) S.sub[S.up[order[k]]] += S.sub[order[k]];\n}\nconst room = (S, c, n) => (S.up[n] === c ? S.sub[n] : CW * CH - S.sub[c]);\n\nconst linked = (S, a, b) => {\n  if (b === a + 1) return a % CW \u003c CW - 1 && S.east[a];\n  if (b === a - 1) return b % CW \u003c CW - 1 && S.east[b];\n  if (b === a + CW) return S.south[a];\n  if (b === a - CW) return S.south[b];\n  return false;\n};\nconst neighbours = (S, c) => [c - 1, c + 1, c - CW, c + CW].filter((n) => n >= 0 && n \u003c CW * CH && linked(S, c, n));\n\n// Decide where the walker goes after the last cell of its route. Walking, it\n// prefers corridors it has seen least; running, the ones that lead away from\n// the eyes. A cell with no way on but back is a dead end: the route marks\n// it, then turns round.\nfunction extend(S) {\n  const r = S.route, c = r[r.length - 1], prev = r.length > 1 ? r[r.length - 2] : -1;\n  const opts = neighbours(S, c).filter((n) => n !== prev);\n  if (!opts.length) {\n    S.deadAt = r.length - 1;\n    r.push(prev);\n    return;\n  }\n  let best = opts[0], score = -1e9;\n  for (const n of opts) {\n    let v = Math.random() * 1.5;\n    if (S.runLeft > 0 && S.eyes) v += 0.3 * sqrt((cx0(n) - S.eyes.x) ** 2 + (cy0(n) - S.eyes.y) ** 2) + 2 * Math.log(room(S, c, n));\n    else v -= 2 * S.visits[n];\n    if (v > score) (score = v), (best = n);\n  }\n  r.push(best);\n}\n\n// The walker's place on its route, a distance ahead along it, never past a\n// dead end it has not reached.\nfunction along(S, ahead) {\n  let seg = S.seg, u = S.u + ahead;\n  while (u > P) {\n    if (seg + 1 === S.deadAt || seg + 2 >= S.route.length) {\n      u = P;\n      break;\n    }\n    u -= P;\n    seg++;\n  }\n  const a = S.route[seg], b = S.route[seg + 1];\n  const t = u / P;\n  return [cx0(a) + (cx0(b) - cx0(a)) * t, cy0(a) + (cy0(b) - cy0(a)) * t];\n}\n\nfunction turnTo(a, target, rate) {\n  let d = target - a;\n  d -= TAU * round(d / TAU);\n  return a + cl(d, -rate, rate);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.beamK = cl(k[2], 0, 1);\n  S.moon = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1) * (S.speed / 2);\n  S.t += d;\n  S.timer += d;\n  // Keep two cells of route decided ahead, so the beam can look round a\n  // corner before the walker gets there.\n  while (S.route.length \u003c S.seg + 4 && S.deadAt \u003c S.seg) extend(S);\n\n  let pace = 0, turnRate = 7;\n  if (S.mode === \"enter\") {\n    // At the entrance the walker sweeps the beam left and right once, then\n    // goes in. The sweep is back on the aisle at 2 seconds.\n    const u = cl(S.timer / ENTER, 0, 1);\n    S.look = -PI / 2 + 0.55 * sin(TAU * cl(S.timer / 2, 0, 1)) * (1 - u);\n    turnRate = 99;\n    if (S.timer >= ENTER) (S.mode = \"walk\"), (S.timer = 0);\n  } else if (S.mode === \"walk\" || S.mode === \"run\") {\n    pace = WALK * (S.mode === \"run\" ? RUN : 1);\n    turnRate = S.mode === \"run\" ? 14 : 7;\n    if (S.mode === \"run\" && (S.runLeft -= d) \u003c= 0) S.mode = \"walk\";\n  } else if (S.mode === \"look\") {\n    // A dead end with nothing in it: a glance either side, then back.\n    S.look = S.deadAng + 0.45 * sin(TAU * S.timer / LOOK);\n    if (S.timer >= LOOK) leave(S, false);\n  } else if (S.mode === \"stare\") {\n    // Eyes. The walker freezes, the beam shakes more and more, the torch\n    // stutters, and then it turns and runs.\n    const u = S.timer / STARE;\n    S.jitter = 0.04 + 0.16 * u;\n    S.look = S.deadAng + S.jitter * (2 * Math.random() - 1);\n    S.power = 0.75 + 0.25 * Math.random() - (Math.random() \u003c 0.08 ? 0.6 : 0);\n    if (S.eyes) S.eyes.on = S.timer > 0.15 && !(S.timer > 0.7 && S.timer \u003c 0.82);\n    if (S.timer >= STARE) leave(S, true);\n  }\n\n  if (pace > 0) {\n    S.u += pace * d;\n    S.stride += pace * d;\n    while (S.u >= P) {\n      S.u -= P;\n      S.seg++;\n      const c = S.route[S.seg];\n      S.visits[c] = min(65000, S.visits[c] + 1);\n      while (S.route.length \u003c S.seg + 4 && S.deadAt \u003c S.seg) extend(S);\n      if (S.seg === S.deadAt) {\n        // Arrived at a dead end: stand in it facing the corn.\n        const a = S.route[S.seg - 1], b = S.route[S.seg];\n        S.u = 0;\n        S.deadAng = atan2(cy0(b) - cy0(a), cx0(b) - cx0(a));\n        S.timer = 0;\n        const ran = S.mode === \"run\";\n        S.runLeft = 0;\n        // Eyes in the corn beyond, at the first dead end the walker finds and\n        // then at three in five; never in the entrance gap, which opens on\n        // the field outside. A runner who hits a dead end only looks and\n        // turns: the same eyes twice in a row would be one fright too many.\n        const entrance = b === 15 * CW + S.aisle && S.deadAng > 0;\n        if (!entrance && !ran && (S.seen === 0 || Math.random() \u003c 0.6)) {\n          S.seen++;\n          const ex = cx0(b) + cos(S.deadAng) * 6.5, ey = cy0(b) + sin(S.deadAng) * 6.5;\n          S.eyes = { x: cl(ex, 1, W - 2), y: cl(ey, 1, H - 2), ang: S.deadAng, on: false, fade: 1 };\n          S.mode = \"stare\";\n        } else S.mode = \"look\";\n        break;\n      }\n    }\n    S.seg = min(S.seg, S.route.length - 2);\n    const [x, y] = along(S, 0);\n    S.wx = x;\n    S.wy = y;\n    if (S.mode === \"walk\" || S.mode === \"run\") {\n      const [lx, ly] = along(S, 7);\n      if (abs(lx - x) + abs(ly - y) > 0.5) S.look = atan2(ly - y, lx - x);\n    }\n  }\n  S.ang = turnTo(S.ang, S.look, turnRate * d + 1e-6);\n  if (S.mode !== \"stare\") S.power = 1;\n\n  // The eyes stay a moment after the walker has run, then blink out.\n  if (S.eyes && S.mode !== \"stare\") {\n    S.eyes.fade -= d * 0.8;\n    S.eyes.on = S.eyes.fade > 0;\n    if (S.eyes.fade \u003c= 0 && S.runLeft \u003c= 0) S.eyes = null;\n  }\n  // Now and then the old torch flickers: a few fast drops over 0.4 seconds.\n  if (S.t >= S.nextFlick) {\n    S.flick = 0.4;\n    S.nextFlick = S.t + 6 + 10 * Math.random();\n  }\n  if (S.flick > 0) {\n    S.flick -= d;\n    const f = floor(S.flick * 20);\n    S.power *= [1, 0.15, 1, 0.5, 0, 0.9, 0.2, 1, 0][f % 9];\n  }\n}\n\n// Leave a dead end: turn round, the route already heads back.\nfunction leave(S, ran) {\n  S.mode = ran ? \"run\" : \"walk\";\n  S.runLeft = ran ? RUNFOR : 0;\n  S.jitter = 0;\n  S.timer = 0;\n  // Drop the decided cells after the turn: a runner picks its way afresh.\n  S.route.length = S.seg + 2;\n  S.deadAt = -1;\n  S.look = S.deadAng + PI;\n}\n\n// The light is cast from just ahead of the walker's head, not from the torch\n// held out in front: at a dead end the torch is already in the corn, and a\n// beam starting inside a wall would light nothing.\nconst torch = (S) => [S.wx + 0.8 * cos(S.ang), S.wy + 0.8 * sin(S.ang)];\n\n// Cast the beam: rays fanned over the cone from the torch, each one dimmed\n// by the corn it passes through. The tops of the stalks catch what is left;\n// the ground behind any corn lies in shadow.\nfunction castBeam(S) {\n  const L = S.light, Sh = S.shade;\n  L.fill(0);\n  const pw = S.power;\n  if (pw \u003c= 0.02) return;\n  const len = 68 + 26 * S.beamK, half = 0.9 + 0.2 * S.beamK;\n  const [ox, oy] = torch(S);\n  const rays = ceil((2 * half * len) / 0.55);\n  for (let r = 0; r \u003c= rays; r++) {\n    const phi = -half + (2 * half * r) / rays, a = S.ang + phi, dx = cos(a), dy = sin(a);\n    const edge = abs(phi) / half;\n    const prof = pw * (edge \u003c 0.6 ? 1 : 1 - 0.35 * (edge - 0.6) / 0.4);\n    let T = 1, walls = 0, inCorn = false;\n    for (let s = 0.5; s \u003c len; s += 0.5) {\n      const x = ox + dx * s, y = oy + dy * s;\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) break;\n      const p = (y | 0) * W + (x | 0);\n      const fall = s \u003c 0.72 * len ? 1 : 1 - FAR * (s - 0.72 * len) / (0.28 * len);\n      let v, sh = 0;\n      if (S.path[p]) {\n        inCorn = false;\n        v = walls ? T * GROUND_SHADOW : 1;\n        sh = walls ? 1 : 0;\n      } else {\n        if (!inCorn) (walls++), (T *= CORN_PASS), (inCorn = true);\n        v = T;\n      }\n      v *= prof * fall;\n      if (v > L[p]) (L[p] = v), (Sh[p] = sh);\n    }\n  }\n  // Spill: the torch also lights the ground round the walker, as far as it\n  // can see along the path, so the walker stands in a small pool of light\n  // even facing a wall at the panel's edge.\n  for (let y = floor(oy - POOL); y \u003c= oy + POOL; y++)\n    for (let x = floor(ox - POOL); x \u003c= ox + POOL; x++) {\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) continue;\n      const ex = x + 0.5 - ox, ey = y + 0.5 - oy, dd = sqrt(ex * ex + ey * ey);\n      if (dd >= POOL) continue;\n      let clear = true;\n      for (let t = 0.5; t \u003c dd - 0.5 && clear; t += 0.5) clear = S.path[floor(oy + (ey * t) / dd) * W + floor(ox + (ex * t) / dd)] === 1;\n      const p = y * W + x, v = pw * (0.95 - (0.3 * dd) / POOL);\n      if (clear && v > L[p]) (L[p] = v), (Sh[p] = 0);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  castBeam(S);\n  const L = S.light;\n  // The beam's colours: the hue knob turns the torch round the wheel from\n  // amber. Leaves take the full colour, tassels a paler one, the dirt path a\n  // cream between.\n  const h0 = 0.115 + S.hue;\n  const cols = [hsv(h0, 0.5, 0.92), null, hsv(h0, 0.86, 1), hsv(h0 + 0.02, 0.35, 1)];\n  // Moonlight on the corn tops, lilac, faint at the start.\n  const m = 0.045 + 0.55 * S.moon;\n  const moon = [0.62 * m, 0.5 * m, m];\n  const wind = S.t * 0.9;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      // Corn rustles: each stalk LED rolls a new look about once a second.\n      let mat = PATH;\n      if (!S.path[i]) {\n        const roll = hash(i * 131 + floor(wind + S.phase[i] * 7));\n        mat = roll \u003c 0.14 ? GAP : roll \u003c 0.68 ? LEAF : TASSEL;\n      }\n      let r = 0, g = 0, b = 0;\n      if (mat === TASSEL) (r = moon[0]), (g = moon[1]), (b = moon[2]);\n      else if (mat === LEAF) (r = moon[0] * 0.55), (g = moon[1] * 0.55), (b = moon[2] * 0.55);\n      else if (mat === PATH) (r = moon[0] * 0.12), (g = moon[1] * 0.12), (b = moon[2] * 0.12);\n      let v = L[i];\n      if (v >= CUT && mat === PATH && S.shade[i]) {\n        // Ground in the corn's shadow, inside the cone: a violet channel.\n        v = min(1, round(v * 8) / 8 * SHADOW_LIFT);\n        (r = SHADOW[0] * v), (g = SHADOW[1] * v), (b = SHADOW[2] * v);\n      } else if (v >= CUT && mat !== GAP) {\n        // The lit corn and path never go below 60% brightness: a warm\n        // colour any dimmer reads brown on the panel. The edge of the beam\n        // is a step, the way a torch's edge is.\n        v = round((0.6 + (0.4 * (v - CUT)) / (1 - CUT)) * 10) / 10;\n        const c = cols[mat];\n        r = max(r, c[0] * v);\n        g = max(g, c[1] * v);\n        b = max(b, c[2] * v);\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  drawEyes(display, S);\n  drawWalker(display, S);\n}\n\n// Two eyes in the corn, side by side across the corridor: each 2 LEDs wide\n// with a 2 LED gap, the narrowest pair that still reads as a face. Round\n// them a dark head blots out the lit stalks, so the eyes do not drown in\n// the gold of the beam.\nfunction drawEyes(display, S) {\n  const e = S.eyes;\n  if (!e || !e.on) return;\n  const c = abs(((0.115 + S.hue) % 1) - 0.3) \u003c 0.08 ? [255, 235, 40] : [90, 255, 70];\n  const ca = cos(e.ang), sa = sin(e.ang);\n  for (let y = floor(e.y - 4); y \u003c= e.y + 4; y++)\n    for (let x = floor(e.x - 4); x \u003c= e.x + 4; x++) {\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) continue;\n      const dx = x + 0.5 - e.x, dy = y + 0.5 - e.y, f = dx * ca + dy * sa - 0.6, s = -dx * sa + dy * ca;\n      if ((f / 2.1) ** 2 + (s / 3.9) ** 2 \u003c 1) display.setPixel(x, y, 8, 3, 14);\n    }\n  for (const o of [-2.5, -1.5, 1.5, 2.5]) {\n    const x = floor(e.x - sa * o), y = floor(e.y + ca * o);\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, c[0], c[1], c[2]);\n  }\n}\n\n// The walker from above: a pale head over shoulders in a violet coat that\n// rock with each step, one arm out in front holding the torch. About 5 LEDs\n// across, so it fills the corridor and reads as someone, not a spark.\nfunction drawWalker(display, S) {\n  const ca = cos(S.ang), sa = sin(S.ang);\n  const rock = 0.22 * sin(S.stride * 0.8);\n  for (let y = floor(S.wy - 5); y \u003c= S.wy + 5; y++)\n    for (let x = floor(S.wx - 5); x \u003c= S.wx + 5; x++) {\n      if (x \u003c 0 || y \u003c 0 || x >= W || y >= H) continue;\n      const dx = x + 0.5 - S.wx, dy = y + 0.5 - S.wy;\n      const f = dx * ca + dy * sa, s = -dx * sa + dy * ca, fs = f + rock * s;\n      if (f > 2.3 && f \u003c 3.5 && s > 0.2 && s \u003c 1.6) display.setPixel(x, y, 255, 250, 225);\n      else if ((f - 0.15) ** 2 + s * s \u003c 1.5) display.setPixel(x, y, 255, 208, 165);\n      else if (f > 0.4 && f \u003c= 2.3 && s > 0.3 && s \u003c 1.5) display.setPixel(x, y, 175, 95, 255);\n      else if (((fs + 0.45) / 1.45) ** 2 + (s / 2.6) ** 2 \u003c 1) display.setPixel(x, y, 140, 55, 255);\n    }\n}\n","fogged-mirror":"// ===== Patternflow pattern =====\n// Title:   Fogged Mirror\n// Family:  halloween\n// Idea:    A tall oval mirror in a dark purple room, lit by one candle below, mists over from its rim inwards until the glass is milky; then an unseen finger writes on the fog from the other side, BOO or GET OUT or a smile with too many teeth, stroke by stroke down to the dark glass, drops run from the strokes leaving streaks, and as the fog clears the mirror shows, for one second, a pale thin figure standing in the room behind you.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fog=0..1, Drips=0..1\n//\n// Knob 1: Hue. Tints the fog and the figure in the glass: at 0 the fog is milky violet and the figure ghost green; at 0.3 the fog is peach and the figure pale cyan; at 0.6 the fog is pale green and the figure pale blue; at 1 the fog is violet again and the figure lilac. The candle and the room stay as they are.\n// Knob 2: Speed. At 2 one round takes 9 to 11 seconds: the fog creeps in for 2.2, the finger writes for 3 to 5, the drops run on for 1, the fog clears in 1.3 with the figure showing through it for 1.3, and the glass rests dark for 0.8. At 0.2 everything runs ten times slower, at 3 half as fast again; the candle flickers at its own pace.\n// Knob 3: Fog. How thick the fog is and how fast it comes: at 0 it creeps in from the rim in 2.2 seconds to a milky veil with the dark glass faintly through it; at 1 it rolls in within a second, paler and opaque.\n// Knob 4: Drips. How wet the breath is: at 0.06 a stroke's end sheds a drop about every other time and the fog gathers a few beads; at 1 every stroke end sheds one, drops fall from the strokes three times as often, the fog is a quarter thinner, beads all over and sweats ten drops a second of its own, each running down the glass and clearing a streak.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, sqrt, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst q = (v, n) => round(v * n) / n;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The glass: an ellipse, and the frame 3 LEDs round it.\nconst MX = 32, MY = 52, MA = 27, MB = 47, FR = 3;\n// The candle below the mirror: wick, wax body, the dish it stands in.\nconst CX = 32, WICK = 112, WAX_TOP = 113;\n// One round, in story seconds (one a second at Speed 2).\nconst CREEP = 2.2, HOLD = 1.0, CLEAR = 1.3, STAY = 0.6, REST = 0.8;\n\n// A chunky hand-written font: each letter is strokes on a 4 by 6 grid, in\n// the order a finger would draw them.\nconst FONT = {\n  B: [[[0, 6], [0, 0]], [[0, 0], [3, 0], [4, 1], [4, 2], [3, 3], [0, 3]], [[3, 3], [4, 4], [4, 5], [3, 6], [0, 6]]],\n  O: [[[1.5, 0], [0.3, 1], [0, 3], [0.3, 5], [1.5, 6], [2.5, 6], [3.7, 5], [4, 3], [3.7, 1], [2.5, 0], [1.5, 0]]],\n  H: [[[0, 0], [0, 6]], [[4, 0], [4, 6]], [[0, 3], [4, 3]]],\n  I: [[[0.5, 0], [3.5, 0]], [[2, 0], [2, 6]], [[0.5, 6], [3.5, 6]]],\n  G: [[[4, 1], [3, 0], [1, 0], [0, 1.2], [0, 4.8], [1, 6], [3, 6], [4, 5], [4, 3.3], [2.3, 3.3]]],\n  E: [[[4, 0], [0, 0], [0, 6], [4, 6]], [[0, 3], [3, 3]]],\n  T: [[[0, 0], [4, 0]], [[2, 0], [2, 6]]],\n  U: [[[0, 0], [0, 4.8], [1, 6], [3, 6], [4, 4.8], [4, 0]]],\n  L: [[[0, 0], [0, 6], [4, 6]]],\n  K: [[[0, 0], [0, 6]], [[4, 0], [0, 4]], [[1.4, 2.7], [4, 6]]],\n  A: [[[0, 6], [0, 2], [2, 0], [4, 2], [4, 6]], [[0, 3.6], [4, 3.6]]],\n  C: [[[4, 1], [3, 0], [1, 0], [0, 1.2], [0, 4.8], [1, 6], [3, 6], [4, 5]]],\n};\n\n// Lay a word out: lines of text, centred on the glass, at a scale chosen so\n// the widest line fits. The finger behind the glass writes backwards for\n// itself so that it reads the right way round to us. Returns strokes in\n// panel LEDs and the finger's radius.\nfunction words(lines, sc, y0) {\n  const strokes = [], pitch = 4 * sc + 5, lh = 6 * sc + 6;\n  lines.forEach((line, li) => {\n    const w = (line.length - 1) * pitch + 4 * sc, x0 = MX - w / 2, top = y0 + li * lh;\n    [...line].forEach((ch, ci) => {\n      for (const s of FONT[ch]) strokes.push(s.map(([x, y]) => [x0 + ci * pitch + x * sc, top + y * sc]));\n    });\n  });\n  return { strokes, r: 1.6 };\n}\n\n// A smile with too many teeth: the face, two eyes, the mouth, eleven teeth.\nfunction smile() {\n  const strokes = [], arc = (cx, cy, rx, ry, a0, a1, n) => {\n    const pts = [];\n    for (let i = 0; i \u003c= n; i++) {\n      const a = a0 + ((a1 - a0) * i) / n;\n      pts.push([cx + rx * cos(a), cy + ry * sin(a)]);\n    }\n    return pts;\n  };\n  strokes.push(arc(MX, 50, 19, 21, -PI / 2, (3 * PI) / 2, 28));\n  strokes.push(arc(MX - 7, 42, 2.4, 3, 0, TAU, 8), arc(MX + 7, 42, 2.4, 3, 0, TAU, 8));\n  strokes.push(arc(MX, 49, 13, 6, 0.15, PI - 0.15, 12));\n  strokes.push(arc(MX, 49, 13, 13, 0.25, PI - 0.25, 14));\n  for (let k = 0; k \u003c 11; k++) {\n    const x = MX - 11 + 2.2 * k, y = 49 + 6 * sin(PI * (0.08 + (0.84 * k) / 10));\n    strokes.push([[x, y - 0.5], [x, y + 6.5 * sin(PI * (0.08 + (0.84 * k) / 10)) + 0.5]]);\n  }\n  return { strokes, r: 1.1 };\n}\n\n// A hand pressed flat against the other side: the palm, then four fingers\n// and the thumb pushed out of it, as strokes from the palm outwards.\nfunction hand() {\n  const strokes = [], cx = MX + 1, cy = 60;\n  for (let ring = 6; ring >= 0; ring -= 2) {\n    const pts = [];\n    for (let i = 0; i \u003c= 16; i++) pts.push([cx + ring * 1.05 * cos((TAU * i) / 16), cy + ring * 1.2 * sin((TAU * i) / 16)]);\n    strokes.push(pts);\n  }\n  for (const [dx, len, a] of [[-6, 14, -0.32], [-2, 18, -0.1], [2.2, 19, 0.06], [6, 15, 0.24]])\n    strokes.push([[cx + dx, cy - 5], [cx + dx + len * sin(a), cy - 5 - len * cos(a)]]);\n  strokes.push([[cx - 7, cy + 1], [cx - 15, cy - 7]]);\n  return { strokes, r: 2.1 };\n}\n\nconst MESSAGES = [\n  () => words([\"BOO\"], 2.4, 40),\n  () => words([\"GET\", \"OUT\"], 2.2, 30),\n  smile,\n  () => words([\"HI\"], 3.2, 36),\n  hand,\n  () => words([\"LOOK\", \"BACK\"], 1.7, 37),\n];\n\nexport function setup(params) {\n  const rho = new Float32Array(N), n1 = new Float32Array(N), n2 = new Float32Array(N);\n  // Two fixed fields of soft value noise; their blend drifts over time, so\n  // the fog's front creeps unevenly.\n  const lat = (seed, gx, gy, x, y) => {\n    const fx = (x / W) * gx, fy = (y / H) * gy, ix = floor(fx), iy = floor(fy), tx = fx - ix, ty = fy - iy;\n    const v = (i, j) => hash(seed + i * 131 + j * 977);\n    const sx = tx * tx * (3 - 2 * tx), sy = ty * ty * (3 - 2 * ty);\n    return mix(mix(v(ix, iy), v(ix + 1, iy), sx), mix(v(ix, iy + 1), v(ix + 1, iy + 1), sx), sy);\n  };\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      rho[i] = hypot((x + 0.5 - MX) / MA, (y + 0.5 - MY) / MB);\n      n1[i] = 0.65 * lat(11, 5, 9, x, y) + 0.35 * lat(23, 11, 19, x, y);\n      n2[i] = 0.65 * lat(37, 5, 9, x, y) + 0.35 * lat(51, 11, 19, x, y);\n    }\n  params.s = {\n    t: 0, rt: 0, hue: 0, speed: 2, fogK: 0, drips: 0.06,\n    rho, n1, n2,\n    clear: new Float32Array(N), wet: new Uint8Array(N), bead: new Uint8Array(N),\n    // The round: phase, time in it, which message, the finger's progress.\n    phase: \"creep\", pt: CREEP * 0.3, msg: 0, cur: null, si: 0, sd: 0, pause: 0,\n    drops: [], fig: 0, near: 1, flame: 1, sway: 0,\n    rgb: new Float32Array(N * 3),\n  };\n}\n\n// Clear the fog along a segment of the finger's path: inside the radius to\n// the glass, and a wet rim one LED round it where the water piles up.\nfunction wipe(S, x0, y0, x1, y1, r) {\n  const ex = x1 - x0, ey = y1 - y0, L2 = ex * ex + ey * ey || 1e-6;\n  const xa = max(0, floor(min(x0, x1) - r - 2)), xb = min(W - 1, floor(max(x0, x1) + r + 2));\n  const ya = max(0, floor(min(y0, y1) - r - 2)), yb = min(H - 1, floor(max(y0, y1) + r + 2));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * ex + py * ey) / L2, 0, 1);\n      const d = hypot(px - t * ex, py - t * ey), i = y * W + x;\n      if (d \u003c r) (S.clear[i] = 1), (S.wet[i] = 0);\n      else if (d \u003c r + 1.1 && S.clear[i] \u003c 1) S.wet[i] = 1;\n    }\n}\n\nfunction spawnDrop(S, x, y, big) {\n  if (S.drops.length > 40) return;\n  S.drops.push({ x, y, v: 0, wait: 0.15 + 0.6 * Math.random(), stop: 0, big: big ? 1 : 0, ph: TAU * Math.random() });\n}\n\n// The fog's thickness at an LED for a front that has come in by p (0 none,\n// 1 the whole glass): it starts at the rim and creeps inwards unevenly.\nfunction fogAt(S, i, p, wob) {\n  const n = mix(S.n1[i], S.n2[i], wob), front = p * 2 - (1 - S.rho[i]) - 0.55 * n;\n  return cl(front / 0.22, 0, 1);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.fogK = cl(k[2], 0, 1);\n  S.drips = cl(k[3], 0, 1);\n  const g = (d * S.speed) / 2;\n  S.t += g;\n  S.rt += d;\n  S.pt += g;\n  // The candle keeps its own time: a flicker of two beats and a slow sway.\n  S.flame = 0.86 + 0.08 * sin(S.rt * 13.1) + 0.06 * sin(S.rt * 7.3 + 1.3 * sin(S.rt * 2.1));\n  S.sway = 0.7 * sin(S.rt * 1.7) + 0.3 * sin(S.rt * 4.3);\n  const creep = mix(CREEP, 1, S.fogK);\n  if (S.phase === \"creep\" && S.pt >= creep) {\n    S.phase = \"write\";\n    S.pt = 0;\n    S.cur = MESSAGES[S.msg % MESSAGES.length]();\n    S.si = 0;\n    S.sd = 0;\n    S.pause = 0.3;\n    let len = 0;\n    for (const s of S.cur.strokes) for (let j = 1; j \u003c s.length; j++) len += hypot(s[j][0] - s[j - 1][0], s[j][1] - s[j - 1][1]);\n    // The finger writes 55 LEDs a second, faster for a long message so no\n    // message takes more than about 3.5 seconds.\n    S.fspeed = max(55, len / 3.2);\n  }\n  if (S.phase === \"write\") {\n    if (S.pause > 0) S.pause -= g;\n    else {\n      // Move the finger along the current stroke, wiping as it goes.\n      let budget = g * S.fspeed;\n      const { strokes, r } = S.cur;\n      while (budget > 0 && S.si \u003c strokes.length) {\n        const st = strokes[S.si];\n        let acc = 0, seg = 0;\n        for (seg = 1; seg \u003c st.length; seg++) {\n          const l = hypot(st[seg][0] - st[seg - 1][0], st[seg][1] - st[seg - 1][1]);\n          if (acc + l > S.sd) break;\n          acc += l;\n        }\n        if (seg >= st.length) {\n          // The stroke is done: its end sheds a drop, sometimes.\n          const end = st[st.length - 1];\n          if (Math.random() \u003c 0.45 + 0.55 * S.drips) spawnDrop(S, end[0], end[1] + r, false);\n          S.si++;\n          S.sd = 0;\n          S.pause = 0.1;\n          break;\n        }\n        const a = st[seg - 1], b = st[seg], l = hypot(b[0] - a[0], b[1] - a[1]) || 1e-6;\n        const u0 = (S.sd - acc) / l, step = min(budget, acc + l - S.sd), u1 = (S.sd - acc + step) / l;\n        wipe(S, mix(a[0], b[0], u0), mix(a[1], b[1], u0), mix(a[0], b[0], u1), mix(a[1], b[1], u1), r);\n        // Water squeezed off the finger now and then runs from where it is.\n        if (Math.random() \u003c step * (0.012 + 0.03 * S.drips)) spawnDrop(S, mix(a[0], b[0], u1), mix(a[1], b[1], u1) + r, false);\n        S.sd += step;\n        budget -= step;\n      }\n      if (S.si >= strokes.length) {\n        S.phase = \"hold\";\n        S.pt = 0;\n      }\n    }\n  } else if (S.phase === \"hold\" && S.pt >= HOLD) {\n    S.phase = \"clear\";\n    S.pt = 0;\n  } else if (S.phase === \"clear\" && S.pt >= CLEAR + STAY) {\n    S.phase = \"rest\";\n    S.pt = 0;\n  } else if (S.phase === \"rest\" && S.pt >= REST) {\n    // New breath on the glass: the old writing fogs over with the rest.\n    S.phase = \"creep\";\n    S.pt = 0;\n    S.msg++;\n    S.clear.fill(0);\n    S.wet.fill(0);\n    S.bead.fill(0);\n    S.drops.length = 0;\n  }\n  // The figure behind you: it is there as the fog thins, stays a second,\n  // and is gone in a blink.\n  // While it is there it comes a step closer: from 1 to 1.14 times its size.\n  if (S.phase === \"clear\") S.fig = S.pt \u003c CLEAR * 0.45 ? 0 : S.pt \u003c CLEAR + STAY ? 1 : 0;\n  else S.fig = 0;\n  S.near = S.fig ? 1 + 0.14 * cl((S.pt - CLEAR * 0.45) / (CLEAR * 0.55 + STAY), 0, 1) : 1;\n  // Fog that sits gathers beads of water, a few at Drips 0.06 and hundreds\n  // a second at 1, and with Drips up it sweats drops of its own.\n  const fogged = S.phase === \"write\" || S.phase === \"hold\" || (S.phase === \"creep\" && S.pt > creep * 0.6);\n  if (fogged) {\n    let nb = g * (6 + 150 * S.drips ** 1.5);\n    while (nb > 0) {\n      if (nb >= 1 || Math.random() \u003c nb) {\n        const i = floor(Math.random() * N);\n        if (S.rho[i] \u003c 0.97 && S.clear[i] \u003c 1) S.bead[i] = 1;\n      }\n      nb -= 1;\n    }\n  }\n  if (fogged && Math.random() \u003c g * 10 * S.drips * S.drips) {\n    const a = TAU * Math.random(), rr = sqrt(Math.random()) * 0.8;\n    spawnDrop(S, MX + MA * rr * cos(a), MY + MB * rr * sin(a) * 0.7, Math.random() \u003c 0.5);\n  }\n  // Drops: swell, then run down in fits and starts, clearing a streak.\n  for (const p of S.drops) {\n    if (p.wait > 0) {\n      p.wait -= g;\n      continue;\n    }\n    if (p.stop > 0) p.stop -= g;\n    else {\n      p.v = min(p.v + g * 55, 26 + 8 * p.big);\n      if (Math.random() \u003c g * 1.4) (p.stop = 0.1 + 0.25 * Math.random()), (p.v *= 0.3);\n    }\n    const y0 = p.y;\n    p.y += p.v * (p.stop > 0 ? 0 : g);\n    p.x += 0.25 * sin(p.y * 0.3 + p.ph) * g;\n    const x = floor(p.x);\n    for (let y = floor(y0); y \u003c= floor(p.y); y++) {\n      if (y \u003c 0 || y >= H) continue;\n      for (let dx = 0; dx \u003c= p.big; dx++) {\n        const i = y * W + x + dx;\n        if (x + dx >= 0 && x + dx \u003c W && S.clear[i] \u003c 0.8) (S.clear[i] = 0.8), (S.wet[i] = 0);\n      }\n    }\n    const i = cl(floor(p.y), 0, H - 1) * W + cl(x, 0, W - 1);\n    if (S.rho[i] > 0.985) p.dead = 1;\n  }\n  S.drops = S.drops.filter((p) => !p.dead);\n}\n\n// How far the fog is in, 0 to 1, by phase.\nfunction fogProgress(S) {\n  const creep = mix(CREEP, 1, S.fogK);\n  if (S.phase === \"creep\") return S.pt / creep;\n  if (S.phase === \"write\" || S.phase === \"hold\") return 1;\n  if (S.phase === \"clear\") return 1 - cl(S.pt / CLEAR, 0, 1);\n  return 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, fl = S.flame;\n  const p = fogProgress(S), wob = 0.5 + 0.5 * sin(S.t * 0.6);\n  const thick = mix(0.72, 1, S.fogK);\n  // Wetter breath (Drips up) makes a thinner, glassier fog.\n  const wetK = 1 - 0.25 * S.drips;\n  const fogTint = hsv(0.76 + S.hue, mix(0.24, 0.12, S.fogK), 1);\n  // The figure turns only half as far, through the cold hues: a dim warm\n  // figure would read brown.\n  const ghost = hsv(0.36 + 0.5 * S.hue, 0.22, 1);\n  const flameX = CX + S.sway, flameH = 7 + 1.5 * fl;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x, ro = S.rho[i];\n      let r, gg, b;\n      // Candlelight on the room and the frame: brighter near the flame, in\n      // steps of a 24th so the glow does not cost a smooth gradient.\n      const dl = hypot((x + 0.5 - flameX) * 1.1, y + 0.5 - (WICK - 3));\n      const lamp = q(cl(1 - dl / 70, 0, 1) ** 1.6 * fl, 24);\n      if (ro \u003c 1) {\n        // The glass: the dark room reflected, the candle's own flame low in\n        // it, a faint sheen, and sometimes the one standing behind you.\n        const sheen = abs(((x - y * 0.45 + 40) % 46) - 23) \u003c 3 ? 0.03 : 0;\n        r = 0.04 + sheen + 0.18 * lamp;\n        gg = 0.02 + sheen + 0.08 * lamp;\n        b = 0.08 + sheen * 1.4 + 0.1 * lamp;\n        const fy = y + 0.5 - 96, fx = x + 0.5 - (CX - S.sway * 0.8);\n        if (fy > -5 && fy \u003c 2) {\n          const w = (fy \u003c 0 ? 1.7 * (1 + fy / 5) : 1.7 - fy * 0.6) * fl;\n          if (abs(fx) \u003c w) (r = 1), (gg = fy > -1.5 && abs(fx) \u003c w * 0.5 ? 0.85 : 0.5), (b = 0.1);\n        }\n        if (S.fig > 0) {\n          // Scaled about its feet, below the frame, as it comes closer.\n          const f = figure(40 + (x + 0.5 - 40) / S.near, 104 + (y + 0.5 - 104) / S.near);\n          if (f > 0) {\n            // The face is the palest, lit from below; the body fades into\n            // the dark of the room, the hands catch the light again.\n            const lit = f === 1 ? (y > 27 ? 0.66 : 0.52) : f === 2 ? 0.05 : f === 5 ? 0.46 : q(0.4 - 0.26 * cl((y - 34) / 62, 0, 1), 16);\n            r = ghost[0] * lit;\n            gg = ghost[1] * lit;\n            b = ghost[2] * lit;\n            if (f === 3) (r = ghost[0] * 0.35), (gg = 0.95), (b = ghost[2] * 0.35);\n          }\n        }\n        // The fog over it, thinner on a bead of water.\n        const fog = fogAt(S, i, p, wob) * thick * wetK * (1 - S.clear[i]) * (S.bead[i] ? 0.5 : 1);\n        if (fog > 0) {\n          // The fog scatters the flame's reflection into a warm patch, and\n          // hides the flame itself once it is thick.\n          const a = min(1, q(fog, 12) * (fy > -6 && fy \u003c 3 ? 1.4 : 1));\n          const spot = q(cl(1 - hypot(fx, fy * 0.8) / 10, 0, 1), 8) * fl;\n          // Milky, brighter low down where the candle lights it, and a\n          // bright rim where the finger piled the water up.\n          const L = (0.55 + 0.25 * lamp + 0.1 * (y / H)) * (S.wet[i] ? 1.3 : 1);\n          r = mix(r, min(1, fogTint[0] * L + 0.15 * lamp + 0.4 * spot), a);\n          gg = mix(gg, min(1, fogTint[1] * L + 0.06 * lamp + 0.15 * spot), a);\n          b = mix(b, min(1, fogTint[2] * L), a);\n        }\n      } else if (ro \u003c 1 + FR / MA) {\n        // The frame: dark violet up top, candle gold at the bottom, with a\n        // lighter bevel on its inner edge.\n        const bev = ro \u003c 1 + 1.2 / MA ? 1.25 : ro > 1 + 2.4 / MA ? 0.7 : 1;\n        const warm = cl(lamp * 2.2, 0, 1);\n        r = mix(0.2, 1, warm) * bev;\n        gg = mix(0.08, 0.6, warm) * bev;\n        b = mix(0.26, 0.12, warm) * bev;\n      } else {\n        // The wall: dark purple, warmer round the candle.\n        r = 0.09 + 0.55 * lamp;\n        gg = 0.025 + 0.2 * lamp;\n        b = 0.15 + 0.08 * lamp;\n      }\n      // The candle: an ivory stub with a lit left side, in a dish.\n      if (y >= WAX_TOP && y \u003c 124 && abs(x + 0.5 - CX) \u003c 4) {\n        const side = x + 0.5 - CX;\n        const v = side \u003c -1 ? 1 : side \u003c 1.5 ? 0.82 : 0.6;\n        (r = 1 * v), (gg = 0.9 * v), (b = 0.72 * v);\n        if (y === WAX_TOP && (x === CX - 3 || x === CX + 1)) (r = 1), (gg = 0.97), (b = 0.85);\n      } else if (y >= 124 && y \u003c 127 && abs(x + 0.5 - CX) \u003c 9 - (y - 124) * 2) {\n        (r = 0.72), (gg = 0.36), (b = 0.1);\n        if (y === 124) (r = 1), (gg = 0.6), (b = 0.2);\n      }\n      // The flame: a teardrop that sways and stretches with the flicker.\n      const fy = WICK - (y + 0.5), fx = x + 0.5 - CX - S.sway * (fy / flameH);\n      if (fy > -1 && fy \u003c flameH) {\n        const u = fy / flameH, w = u \u003c 0.3 ? 2.3 * sqrt(u / 0.3) : 2.3 * (1 - (u - 0.3) / 0.7) ** 0.8;\n        if (abs(fx) \u003c w + 0.2) {\n          const core = abs(fx) \u003c w * 0.45 && u \u003c 0.6, mid = abs(fx) \u003c w * 0.75 && u \u003c 0.8;\n          if (fy \u003c 0.6) (r = 0.35), (gg = 0.3), (b = 0.9);\n          else if (core) (r = 1), (gg = 0.97), (b = 0.75);\n          else if (mid) (r = 1), (gg = 0.78), (b = 0.2);\n          else (r = 1), (gg = 0.5), (b = 0.05);\n        }\n      }\n      const o = i * 3;\n      rgb[o] = r;\n      rgb[o + 1] = gg;\n      rgb[o + 2] = b;\n    }\n  // Drop heads: a bright bead, bigger for a big drop.\n  for (const p of S.drops) {\n    const x = floor(p.x), y = floor(p.y);\n    for (let dy = -1; dy \u003c= 0; dy++)\n      for (let dx = 0; dx \u003c= p.big; dx++) {\n        const xx = x + dx, yy = y + dy;\n        if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || S.rho[yy * W + xx] >= 1) continue;\n        const o = (yy * W + xx) * 3, v = dy === 0 ? 1 : 0.7;\n        rgb[o] = mix(rgb[o], 0.95, v);\n        rgb[o + 1] = mix(rgb[o + 1], 0.95, v);\n        rgb[o + 2] = mix(rgb[o + 2], 1, v);\n      }\n  }\n  for (let i = 0; i \u003c N; i++) {\n    const o = i * 3;\n    display.setPixel(i % W, floor(i / W), round(255 * cl(rgb[o], 0, 1)), round(255 * cl(rgb[o + 1], 0, 1)), round(255 * cl(rgb[o + 2], 0, 1)));\n  }\n}\n\n// The one standing behind you, as the mirror shows it: 1 for the pale\n// face, 2 for the eye holes, 3 for the faint light in them, 4 for the body,\n// 5 for the hands, 0 elsewhere.\n// Tall and thin, head at row 27, arms hanging past the hips.\nfunction figure(x, y) {\n  const cx = 40;\n  const hx = (x - cx) / 3.6, hy = (y - 27) / 4.8;\n  if (hx * hx + hy * hy \u003c 1) {\n    for (const ex of [-1.6, 1.6]) {\n      const dx = x - (cx + ex), dy = y - 27.2;\n      if (abs(dx) \u003c 1 && abs(dy) \u003c 1.2) return abs(dx) \u003c 0.5 && abs(dy) \u003c 0.5 ? 3 : 2;\n    }\n    return 1;\n  }\n  if (y >= 31.5 && y \u003c 34 && abs(x - cx) \u003c 1.4) return 4;\n  if (y >= 34) {\n    // Narrow shoulders, a body that tapers to the waist and widens a little\n    // to the hem of a long shape below.\n    const u = (y - 34) / 66, half = y \u003c 36 ? 3 + (y - 34) * 1.2 : 5.4 - 2.2 * sin(PI * cl(u * 1.4, 0, 1)) + 1.6 * u;\n    if (abs(x - cx) \u003c half) return 4;\n    // The arms: a thin line each side, an LED clear of the body.\n    const arm = y \u003c 76 ? 1 : 0, side = abs(x - cx), at = 6.6 + 0.02 * (y - 36);\n    if (arm && y > 35 && side > at - 0.8 && side \u003c at + 0.7) return y > 68 ? 5 : 4;\n  }\n  return 0;\n}\n","hadwiger-nelson":"// ===== Patternflow pattern =====\n// Title:   Hadwiger-Nelson\n// Family:  cells\n// Idea:    Isbell's seven-colouring of the plane, regular hexagons in seven glass colours with each cell's six neighbours the six other colours, drifts and turns slowly under rigid figures of unit length, a Moser spindle, an equilateral triangle and single sticks, that tumble over it with every unit edge drawn in light and the cells under its ends lit, so the two ends of every edge always sit on different colours until the hexagons are sized out of the window where the colouring works, and then the edges that land on one colour flash red and their cells pulse.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Hadwiger-Nelson problem (Edward Nelson, 1950), with John Isbell's seven-colouring, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=-1..1, Figures=0..1\n//\n// Knob 1: Hue. Turns the seven glass colours round the colour wheel together: at 0 they are amber, olive, green, teal, blue, violet and crimson; at 0.5 the amber cells have turned sky blue and the teal ones rose. The light of the edges stays white.\n// Knob 2: Speed. How fast the figures glide and tumble and the mosaic drifts: at 2 a figure glides 5 to 13 LEDs a second and turns once in 5 to 9 seconds, and the mosaic slides 4 LEDs a second and turns once in 70; at 0.2 ten times slower, at 3 half as fast again. The red flashes beat three times a second at any Speed.\n// Knob 3: Size. The hexagon's diameter in units, 0.87 times 1.6 to the power of the knob: 0.54 at -1, 0.87 at 0, 1.39 at 1. Isbell's colouring is proper from 0.756 to 1 (the knob from -0.30 to 0.30), and there nothing ever flashes; below it two cells of one colour lie closer than 1 and a unit edge can reach from one to the other, above it a whole unit edge fits inside one hexagon, and each such edge flashes red while its cells pulse.\n// Knob 4: Figures. How many unit figures tumble over the plane: 3 at 0 and 0.06 (a Moser spindle, a unit triangle and a stick), one more at each eighth of the range, up to 10 at 1 (two spindles, three triangles and five sticks, 36 unit edges).\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, sin, cos, sqrt, hypot, PI } = Math;\nconst TAU = 2 * PI, SQ3 = sqrt(3);\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The unit length on the panel, in LEDs.\nconst U = 22;\n\n// The window. Hexagon centres sit on a triangular lattice with spacing s; a\n// hexagon of diameter D (corner to corner) has s = D√3/2. Centre (a, b), at\n// a·(s, 0) + b·(s/2, s√3/2), gets colour (a + 3b) mod 7: its six neighbours\n// (±1, 0), (0, ±1), (1, -1), (-1, 1) get +1, -1, +3, -3, -2, +2, the six\n// other colours. The cells of one colour sit on the sublattice of index 7,\n// whose shortest vectors are √7 lattice steps long. The nearest two points of\n// two hexagons whose centres differ by v are |v| less the hexagon's size in\n// that direction, which is the distance from v to the hexagon doubled. That\n// is computed here over the sublattice and comes out at √7/2 = 1.3229\n// diameters, corner to corner, so the colouring needs D > 2/√7 = 0.7559 for\n// two cells of one colour to be more than 1 apart, and D \u003c 1 for no two\n// points of one cell to be 1 apart.\nfunction sameColourGap() {\n  const D = 1, s = (D * SQ3) / 2, R = D / 2;\n  // The doubled hexagon: corners at 30° + 60°k, circumradius 2R.\n  const P = [];\n  for (let k = 0; k \u003c 6; k++) P.push([2 * R * cos(PI / 6 + (k * PI) / 3), 2 * R * sin(PI / 6 + (k * PI) / 3)]);\n  let gap = Infinity;\n  for (let a = -6; a \u003c= 6; a++)\n    for (let b = -6; b \u003c= 6; b++) {\n      if ((a === 0 && b === 0) || (((a + 3 * b) % 7) + 7) % 7 !== 0) continue;\n      const vx = s * (a + b / 2), vy = (s * SQ3 * b) / 2;\n      for (let k = 0; k \u003c 6; k++) {\n        const [x0, y0] = P[k], [x1, y1] = P[(k + 1) % 6];\n        const ex = x1 - x0, ey = y1 - y0, t = cl(((vx - x0) * ex + (vy - y0) * ey) / (ex * ex + ey * ey), 0, 1);\n        gap = min(gap, hypot(vx - x0 - t * ex, vy - y0 - t * ey));\n      }\n    }\n  return gap;\n}\nconst GAP = sameColourGap();\nconst D_LO = 1 / GAP, D_HI = 1;\n// Size 0 is the geometric middle of the window: √(0.7559 · 1) = 0.87.\nconst D_MID = 0.87, D_STEP = 1.6;\n\n// Seven glass colours, one per colour class, a seventh of the wheel apart\n// with saturation and value varied so neighbours never blur together.\nconst SAT = [0.95, 0.8, 1, 0.85, 1, 0.75, 0.9];\nconst VAL = [0.62, 0.5, 0.46, 0.52, 0.6, 0.52, 0.56];\n// Hue 0 opens on amber, not red.\nconst HUE0 = 0.09;\nconst LIGHT = [1, 0.96, 0.86], RED = [1, 0.08, 0.04];\n\n// The figures, in units. Every listed edge is exactly 1 long.\nfunction spindle() {\n  // Two rhombi of two unit triangles each share the corner A; the second is\n  // turned about A until its far tip is 1 from the first one's (2√3 sin(β/2)\n  // = 1). Seven points, eleven unit edges, and no proper 3-colouring.\n  const beta = 2 * Math.asin(1 / (2 * SQ3)), pts = [[0, 0]];\n  for (const r of [-beta / 2, beta / 2]) {\n    const at = (d, a) => [d * cos(a + r), d * sin(a + r)];\n    pts.push(at(1, -PI / 6), at(1, PI / 6), at(SQ3, 0));\n  }\n  const edges = [[0, 1], [0, 2], [1, 2], [1, 3], [2, 3], [0, 4], [0, 5], [4, 5], [4, 6], [5, 6], [3, 6]];\n  return centre({ pts, edges });\n}\nconst triangle = () => centre({ pts: [[0, 0], [1, 0], [0.5, SQ3 / 2]], edges: [[0, 1], [1, 2], [2, 0]] });\nconst stick = () => centre({ pts: [[0, 0], [1, 0]], edges: [[0, 1]] });\nfunction centre(f) {\n  let cx = 0, cy = 0;\n  for (const p of f.pts) (cx += p[0]), (cy += p[1]);\n  cx /= f.pts.length;\n  cy /= f.pts.length;\n  f.pts = f.pts.map((p) => [p[0] - cx, p[1] - cy]);\n  f.reach = max(...f.pts.map((p) => hypot(p[0], p[1])));\n  return f;\n}\nconst KINDS = [spindle, triangle, stick, stick, triangle, stick, spindle, stick, triangle, stick];\n\nfunction makeFigure(i) {\n  const f = KINDS[i]();\n  const a = TAU * hash(i * 7 + 1), v = 5 + 3 * hash(i * 7 + 2);\n  f.x = 14 + 36 * hash(i * 7 + 3);\n  f.y = 14 + 100 * ((i * 0.38 + 0.2 * hash(i * 7 + 4)) % 1);\n  f.vx = v * cos(a);\n  f.vy = v * sin(a) * 1.6;\n  f.ang = TAU * hash(i * 7 + 5);\n  f.spin = (hash(i * 7 + 6) \u003c 0.5 ? -1 : 1) * (0.35 + 0.35 * hash(i * 7 + 7));\n  f.ph = TAU * hash(i * 7 + 8);\n  // Per edge: how hot its flash is; per point: where it is on the panel.\n  f.hot = new Float32Array(f.edges.length);\n  f.at = f.pts.map(() => [0, 0]);\n  return f;\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, rt: 0, hue: 0, speed: 2, size: 0, D: D_MID, n: 3,\n    // The plane under the panel: its turn and where the panel's centre is.\n    rot: 0.3, ox: 0.37, oy: 0.21,\n    figs: KINDS.map((_, i) => makeFigure(i)),\n    lit: new Map(), pulse: new Map(),\n    rgb: new Float32Array(W * H * 3),\n    pal: null, palHue: NaN, flash: 0,\n  };\n}\n\n// The cell of the colouring that holds plane point (x, y), in units:\n// lattice coordinates a, b of its centre and its colour.\nfunction cellAt(S, x, y) {\n  const s = S.s, b = (2 * y) / (s * SQ3), a = x / s - b / 2, c = -a - b;\n  let ra = round(a), rb = round(b);\n  const rc = round(c), da = abs(ra - a), db = abs(rb - b), dc = abs(rc - c);\n  if (da > db && da > dc) ra = -rb - rc;\n  else if (db > dc) rb = -ra - rc;\n  return [ra, rb, (((ra + 3 * rb) % 7) + 7) % 7];\n}\nconst key = (a, b) => (a + 2048) * 4096 + b + 2048;\n\n// A panel point (LEDs) to the plane (units).\nfunction toPlane(S, px, py) {\n  const u = (px - W / 2) / U, v = (py - H / 2) / U, c = cos(S.rot), s = sin(S.rot);\n  return [c * u - s * v + S.ox, s * u + c * v + S.oy];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.size = cl(k[2], -1, 1);\n  S.D = D_MID * D_STEP ** S.size;\n  S.s = (S.D * SQ3) / 2;\n  S.n = min(KINDS.length, 3 + floor(cl(k[3], 0, 1) * 7.99));\n  const g = d * S.speed;\n  S.t += g;\n  S.rt += d;\n  // The mosaic drifts a tenth of a unit a second and turns once in 140 s at\n  // Speed 1, so its cells slide under the figures as well.\n  S.rot += g * 0.045;\n  S.ox += g * 0.06 * cos(S.t * 0.13);\n  S.oy += g * 0.1;\n  S.lit.clear();\n  S.pulse.clear();\n  // Flashes beat three times a second whatever the Speed.\n  S.flash = 0.5 + 0.5 * sin(S.rt * TAU * 3);\n  for (let i = 0; i \u003c S.n; i++) {\n    const f = S.figs[i];\n    // Glide, bounce off the panel's sides so the figure stays mostly on it,\n    // and tumble with a spin that swells and slackens.\n    f.x += f.vx * g * 0.5;\n    f.y += f.vy * g * 0.5;\n    const mx = 4 + f.reach * U * 0.5, my = 6 + f.reach * U * 0.5;\n    if (f.x \u003c mx) f.vx = abs(f.vx);\n    if (f.x > W - mx) f.vx = -abs(f.vx);\n    if (f.y \u003c my) f.vy = abs(f.vy);\n    if (f.y > H - my) f.vy = -abs(f.vy);\n    f.ang += g * f.spin * (0.75 + 0.5 * sin(S.t * 0.7 + f.ph));\n    const c = cos(f.ang), s = sin(f.ang);\n    const cells = f.pts.map((p, j) => {\n      const px = f.x + U * (c * p[0] - s * p[1]), py = f.y + U * (s * p[0] + c * p[1]);\n      f.at[j][0] = px;\n      f.at[j][1] = py;\n      const [x, y] = toPlane(S, px, py);\n      const cell = cellAt(S, x, y);\n      S.lit.set(key(cell[0], cell[1]), 1);\n      return cell;\n    });\n    // A unit edge whose two ends land on one colour breaks the colouring.\n    // Inside the window it cannot happen; outside it the edge heats up and\n    // cools over a third of a second after it lands on two colours again.\n    f.edges.forEach(([p, q], e) => {\n      const bad = cells[p][2] === cells[q][2];\n      f.hot[e] = bad ? 1 : max(0, f.hot[e] - d * 3);\n      if (f.hot[e] > 0) {\n        for (const cc of [cells[p], cells[q]]) {\n          const kk = key(cc[0], cc[1]);\n          S.pulse.set(kk, max(S.pulse.get(kk) || 0, f.hot[e]));\n        }\n      }\n    });\n  }\n}\n\nfunction palette(S) {\n  S.pal = [];\n  for (let c = 0; c \u003c 7; c++) {\n    const h = HUE0 + S.hue + c / 7, f = h - floor(h);\n    // Dim amber and orange read brown on LEDs: lift them.\n    const band = max(0, 1 - abs(f - 0.08) / 0.07);\n    S.pal.push(hsv(h, SAT[c], VAL[c] + 0.2 * band), hsv(h, SAT[c] * 0.8, 1));\n  }\n  S.palHue = S.hue;\n}\n\n// Light along a segment, a line about 1.6 LEDs wide in three steps of\n// brightness, blended over what is there.\nfunction line(S, x0, y0, x1, y1, col, a) {\n  const rgb = S.rgb, ex = x1 - x0, ey = y1 - y0, L2 = ex * ex + ey * ey || 1;\n  const xa = max(0, floor(min(x0, x1) - 1)), xb = min(W - 1, floor(max(x0, x1) + 1));\n  const ya = max(0, floor(min(y0, y1) - 1)), yb = min(H - 1, floor(max(y0, y1) + 1));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, t = cl((px * ex + py * ey) / L2, 0, 1);\n      const dd = hypot(px - t * ex, py - t * ey);\n      if (dd >= 1.2) continue;\n      const w = a * (dd \u003c 0.45 ? 1 : dd \u003c 0.85 ? 0.6 : 0.25), i = (y * W + x) * 3;\n      rgb[i] += (col[0] - rgb[i]) * w;\n      rgb[i + 1] += (col[1] - rgb[i + 1]) * w;\n      rgb[i + 2] += (col[2] - rgb[i + 2]) * w;\n    }\n}\n\nfunction dot(S, px, py, col) {\n  const rgb = S.rgb, cx = round(px - 0.5), cy = round(py - 0.5);\n  for (let dy = -2; dy \u003c= 2; dy++)\n    for (let dx = -2; dx \u003c= 2; dx++) {\n      const x = cx + dx, y = cy + dy, r2 = dx * dx + dy * dy;\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || r2 > 5 || r2 === 4) continue;\n      const i = (y * W + x) * 3;\n      // A round white core with a dark ring, so the point reads on any glass.\n      const c = r2 \u003c= 1 ? col : r2 === 2 ? [col[0] * 0.75, col[1] * 0.75, col[2] * 0.75] : [0.03, 0.02, 0.05];\n      rgb[i] = c[0];\n      rgb[i + 1] = c[1];\n      rgb[i + 2] = c[2];\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.s) return;\n  if (S.palHue !== S.hue) palette(S);\n  const rgb = S.rgb, s = S.s, half = s / 2, pal = S.pal;\n  const c = cos(S.rot), sn = sin(S.rot);\n  // Grout: a dark line about 1.4 LEDs wide on every cell boundary.\n  const g1 = 0.45 / U, g2 = 0.9 / U;\n  for (let y = 0; y \u003c H; y++) {\n    const v = (y + 0.5 - H / 2) / U;\n    for (let x = 0; x \u003c W; x++) {\n      const u = (x + 0.5 - W / 2) / U;\n      const px = c * u - sn * v + S.ox, py = sn * u + c * v + S.oy;\n      const [a, b, col] = cellAt(S, px, py);\n      // Distance to the cell's edge: its inradius less the largest\n      // projection on the three face normals.\n      const lx = px - s * (a + b / 2), ly = py - (s * SQ3 * b) / 2;\n      const hd = max(abs(lx), abs(0.5 * lx + 0.866 * ly), abs(-0.5 * lx + 0.866 * ly));\n      const edge = half - hd, kk = key(a, b);\n      let r, gg, bb;\n      const lit = S.lit.has(kk), p = S.pulse.get(kk) || 0;\n      const base = pal[col * 2 + (lit ? 1 : 0)];\n      // A bevel: the glass a little darker near the lead.\n      const bev = edge \u003c half * 0.28 ? 0.8 : 1;\n      r = base[0] * bev;\n      gg = base[1] * bev;\n      bb = base[2] * bev;\n      if (p > 0) {\n        // An offending cell pulses towards white and red with its edge.\n        const w = p * 0.85 * S.flash;\n        r += (1 - r) * w;\n        gg += (0.75 - gg) * w;\n        bb += (0.7 - bb) * w;\n      }\n      if (edge \u003c g2) {\n        const f = edge \u003c g1 ? 0.06 : 0.4;\n        r *= f;\n        gg *= f;\n        bb *= f;\n      }\n      const i = (y * W + x) * 3;\n      rgb[i] = r;\n      rgb[i + 1] = gg;\n      rgb[i + 2] = bb;\n    }\n  }\n  for (let n = 0; n \u003c S.n; n++) {\n    const f = S.figs[n];\n    f.edges.forEach(([p, q], e) => {\n      const h = f.hot[e];\n      const col = h > 0 ? (S.flash > 0.5 ? RED : LIGHT) : LIGHT;\n      line(S, f.at[p][0], f.at[p][1], f.at[q][0], f.at[q][1], col, h > 0 ? 1 : 0.85);\n    });\n    for (const pt of f.at) dot(S, pt[0], pt[1], [1, 1, 1]);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = (y * W + x) * 3;\n      display.setPixel(x, y, round(255 * cl(rgb[i], 0, 1)), round(255 * cl(rgb[i + 1], 0, 1)), round(255 * cl(rgb[i + 2], 0, 1)));\n    }\n}\n","ising-interface":"// ===== Patternflow pattern =====\n// Title:   Ising Interface\n// Family:  noise\n// Idea:    An Ising magnet at its critical temperature, held up on the left and down on the right, boils in two quiet colours while the one domain wall that must cross it from bottom to top is traced every frame as a bright fractal thread, the curve whose scaling limit is SLE(3).\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Ising model (Wilhelm Lenz, 1920), with the SLE(3) interface of Stanislav Smirnov (2010), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Temp=-0.15..0.3, Trail=0..1\n//\n// Knob 1: Hue. Turns the thread round the wheel from pale gold at 0: pale green at 0.25, sky blue at 0.45, lilac at 0.6, pink at 0.8; its ghost turns with it from rose. The spins stay cool and quiet: teal and indigo at 0 and 0.5, green and navy at 0.25, azure and violet at 0.75.\n// Knob 2: Speed. Sweeps a second, every spin offered a flip once per sweep: 20 at 2, 2 at 0.2, 30 at 3. At 2 the small bays of the wall open and close several times a second while its big bends shift over tens of seconds.\n// Knob 3: Temp. The temperature as a step from Onsager's critical point T_c = 2.269: 0 is T_c, where the thread is the SLE(3) curve, about 240 lattice edges long on this 32 by 64 lattice. At -0.15 (0.85 T_c) the magnet orders, the islands shrink and the thread straightens to about 135 edges; at 0.3 (1.3 T_c) the spins scatter and the thread, about 485 edges, winds round every island it touches.\n// Knob 4: Trail. How long earlier walls linger as a ghost under the thread: a half-life of 0.12 seconds at 0.06, 0.08 at 0, and 3.5 at 1, where the ghost fills the whole band the wall has wandered over.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, exp, log, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// One spin for each 2 by 2 block of LEDs: a lattice of 32 by 64. With a spin\n// per LED the wall is rough at the scale of single LEDs, its strands run\n// side by side one LED apart and merge into a blob; on 2 by 2 blocks every\n// strand has a spin's width of its own colour between it and the next, and\n// the thread is drawn one LED wide on the up side of the wall. The smaller\n// lattice also settles before the first frame: near T_c the big domains take\n// about L^2.17 sweeps to form, some 1800 for L = 32, and a 64 by 128\n// lattice would want four times the sweeps of four times the spins.\nconst B = 2, NX = W / B, NY = H / B, PW = NX + 2;\n// Onsager's critical temperature, 2 / ln(1 + sqrt 2).\nconst TC = 2 / log(1 + sqrt(2));\n// Sweeps a second at Speed 1.\nconst SWEEPS = 10;\n// How far a fresh ghost of the wall covers the spins under it.\nconst GHOST = 0.6;\n// Half sweeps run before the first frame, 2500 full sweeps. Tried with 300,\n// the magnet still looked frozen in its ordered start: two flat halves with\n// specks, and a wall that hardly left the middle line.\nconst BURN = 5000;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, temp: 0, trailK: 0.06, beta: 0, acc: 0, ready: false,\n    spin: new Int8Array(PW * (NY + 2)), p: new Float32Array(5), parity: 0, line: new Uint8Array(N), trail: new Float32Array(N), len: 0,\n  };\n  const S = params.s;\n  // The lattice is stored with a frame of fixed boundary spins round it.\n  // Start ordered, up on the left half and down on the right, the wall\n  // straight up the middle; the first update shakes it to the knob's\n  // temperature.\n  for (let j = -1; j \u003c= NY; j++) for (let i = -1; i \u003c= NX; i++) S.spin[(j + 1) * PW + i + 1] = bound(i, j);\n}\n\n// Dobrushin boundary: up all along the left edge, down all along the right,\n// and on the top and bottom rows up over the left half and down over the\n// right. Exactly one wall then runs from the middle of the bottom edge to\n// the middle of the top.\nconst bound = (i, j) => (i \u003c 0 ? 1 : i >= NX ? -1 : i \u003c NX / 2 ? 1 : -1);\nconst spinAt = (S, i, j) => (i \u003c -1 || i > NX || j \u003c -1 || j > NY ? bound(i, j) : S.spin[(j + 1) * PW + i + 1]);\n\n// Heat-bath probabilities that a spin comes up, for local field -4..4 in\n// steps of 2: 1 / (1 + exp(-2 beta h)).\nfunction table(S) {\n  const beta = 1 / (TC * (1 + S.temp));\n  S.beta = beta;\n  for (let k = 0; k \u003c 5; k++) S.p[k] = 1 / (1 + exp(-2 * beta * (2 * k - 4)));\n}\n\n// Half a sweep: every spin of one colour of the checkerboard, which share no\n// neighbours, so each sees the others as they were.\nfunction halfSweep(S, parity) {\n  const sp = S.spin, p = S.p;\n  for (let j = 0; j \u003c NY; j++)\n    for (let i = (j + parity) & 1, q = (j + 1) * PW + i + 1; i \u003c NX; i += 2, q += 2) {\n      const h = sp[q - 1] + sp[q + 1] + sp[q - PW] + sp[q + PW];\n      sp[q] = Math.random() \u003c p[(h + 4) >> 1] ? 1 : -1;\n    }\n}\n\n// The exploration path. It walks the corners of the spin squares from the\n// middle of the bottom edge, keeping up spins on its left and down spins on\n// its right, until it reaches the middle of the top edge. At each corner it\n// looks at the two spins ahead: a down spin ahead on the left turns it left,\n// an up spin ahead on the right turns it right, otherwise it goes straight.\n// Where both happen at once it turns left.\n// Directions: 0 up, 1 right, 2 down, 3 left.\nconst DX = [0, 1, 0, -1], DY = [-1, 0, 1, 0];\nfunction trace(S) {\n  const L = S.line;\n  L.fill(0);\n  let a = NX / 2, b = NY, d = 0, n = 0;\n  const cap = 4 * (NX + 1) * (NY + 1);\n  while (n++ \u003c cap && !(a === NX / 2 && b === 0)) {\n    // The spins ahead on the left and on the right of the corner (a, b).\n    let fl, fr;\n    if (d === 0) (fl = spinAt(S, a - 1, b - 1)), (fr = spinAt(S, a, b - 1));\n    else if (d === 1) (fl = spinAt(S, a, b - 1)), (fr = spinAt(S, a, b));\n    else if (d === 2) (fl = spinAt(S, a, b)), (fr = spinAt(S, a - 1, b));\n    else (fl = spinAt(S, a - 1, b)), (fr = spinAt(S, a - 1, b - 1));\n    if (fl \u003c 0) d = (d + 3) & 3;\n    else if (fr > 0) d = (d + 1) & 3;\n    const na = a + DX[d], nb = b + DY[d];\n    edge(L, a, b, na, nb, d);\n    a = na;\n    b = nb;\n  }\n  S.len = n;\n}\n\n// Light the two LEDs along one edge of the wall, inside the spin on its\n// left, the up side; or inside the spin on its right where the left one is\n// the fixed frame outside the panel, as it is all along the left edge.\nfunction edge(L, a, b, na, nb, d) {\n  // The spin on the left of the step and the one on its right.\n  let li, lj, ri, rj;\n  if (d === 0) (li = a - 1), (lj = nb), (ri = a), (rj = nb);\n  else if (d === 2) (li = a), (lj = b), (ri = a - 1), (rj = b);\n  else if (d === 1) (li = a), (lj = b - 1), (ri = a), (rj = b);\n  else (li = na), (lj = b), (ri = na), (rj = b - 1);\n  let i = li, j = lj;\n  if (i \u003c 0 || i >= NX || j \u003c 0 || j >= NY) (i = ri), (j = rj);\n  if (i \u003c 0 || i >= NX || j \u003c 0 || j >= NY) return;\n  // Which two of the block's four LEDs touch the edge: for a vertical step\n  // the block's right column if the block lies west of it, else its left\n  // column; for a horizontal step its bottom or top row the same way.\n  const vertical = d === 0 || d === 2;\n  const x0 = B * i, y0 = B * j;\n  if (vertical) {\n    const west = i \u003c a;\n    const x = west ? x0 + B - 1 : x0;\n    for (let k = 0; k \u003c B; k++) L[(y0 + k) * W + x] = 1;\n  } else {\n    const north = j \u003c b;\n    const y = north ? y0 + B - 1 : y0;\n    for (let k = 0; k \u003c B; k++) L[y * W + x0 + k] = 1;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const temp = cl(k[2], -0.15, 0.3);\n  if (temp !== S.temp || !S.beta) {\n    S.temp = temp;\n    table(S);\n  }\n  S.trailK = cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1);\n  S.t += d;\n  if (!S.ready) {\n    // Settle the ordered start at this temperature before the first frame.\n    for (let n = 0; n \u003c BURN; n++) halfSweep(S, n & 1);\n    S.ready = true;\n  }\n  S.acc += d * S.speed * SWEEPS * 2;\n  let n = 0;\n  while (S.acc >= 1 && n \u003c 16) {\n    halfSweep(S, (S.parity ^= 1));\n    S.acc -= 1;\n    n++;\n  }\n  trace(S);\n  // The ghost of earlier walls fades with a half-life set by Trail.\n  const half = 0.08 + 3 * S.trailK * S.trailK + 0.4 * S.trailK;\n  const keep = exp((-d * Math.LN2) / half);\n  const tr = S.trail, L = S.line;\n  for (let p = 0; p \u003c N; p++) tr[p] = L[p] ? 1 : tr[p] * keep;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  // The wall goes round the whole wheel from pale gold. The spins stay in\n  // cool hues, teal to azure for up and blue to violet for down: dark warm\n  // colours read brown on the panel, and these two are meant to be quiet.\n  const k = S.hue, w = sin(2 * PI * k);\n  const up = hsv(0.48 - 0.12 * w, 0.75, 0.42), down = hsv(0.72 - 0.1 * w, 0.8, 0.3);\n  const wall = hsv(0.12 + k, 0.3, 1), ghost = hsv(0.93 + k, 0.55, 0.9);\n  const sp = S.spin, L = S.line, tr = S.trail;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let c = sp[(floor(y / B) + 1) * PW + floor(x / B) + 1] > 0 ? up : down;\n      let r = c[0], g = c[1], b = c[2];\n      if (L[p]) (r = wall[0]), (g = wall[1]), (b = wall[2]);\n      else if (tr[p] > 0.05) {\n        const a = (round(tr[p] * 8) / 8) * GHOST;\n        r += (ghost[0] - r) * a;\n        g += (ghost[1] - g) * a;\n        b += (ghost[2] - b) * a;\n      }\n      display.setPixel(x, y, round(255 * r), round(255 * g), round(255 * b));\n    }\n}\n","mummy":"// ===== Patternflow pattern =====\n// Title:   Mummy\n// Family:  halloween\n// Idea:    A mummy the height of the panel shambles in a dark purple tomb with its arms out and its hands hanging, glowing green eyes in the slit of its wrappings, loose bandage ends fluttering in the draught, and every few seconds one long strip peels off and whips away in the wind, twisting as it goes, baring a glowing empty hollow where it was, then winds itself back on.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Glow=0..1, Speed=0.2..3, Wind=0..1, Torch=0..1\n//\n// Knob 1: Glow. The colour of the eyes, of the hollow inside and of the motes that blow out of it: toxic green at 0, cyan at 0.35, blue at 0.6, violet at 0.8, magenta at 1. The wrappings stay bone white, with the glow only on their right flanks and the undersides of the arms.\n// Knob 2: Speed. At 2 a shambling step takes 2.8 seconds, a strip peels off in 1.6, flies for 2.4 and winds back on in 1.8, and the next comes 2 to 4 seconds later; the first starts at 1.6 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Wind. At 0 a draught: the loose ends hang and sway, and the strip that peels off, 38 LEDs long, streams out to the right and curls down beside the legs. At 1 a gale from the left: the ends stand out straight and snap, the strip is 64 LEDs long and climbs the right side of the panel, the mummy leans into it, and two strips can be off at once.\n// Knob 4: Torch. A torch on the left wall. At 0 a small low flame and a little warm light on the mummy's left side; at 0.06 about the same; at 1 a flame twice the size that throws flickering orange light over the wall and the wrappings.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, asin, atan2, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n// Piecewise linear lookup in a table of [at, value] rows.\nconst tab = (T, v) => {\n  if (v \u003c= T[0][0]) return T[0][1];\n  for (let i = 1; i \u003c T.length; i++) if (v \u003c= T[i][0]) return T[i - 1][1] + ((T[i][1] - T[i - 1][1]) * (v - T[i - 1][0])) / (T[i][0] - T[i - 1][0]);\n  return T[T.length - 1][1];\n};\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Linen in the light, and the cold purple of the tomb it turns to in shadow.\n// A dark warm shade reads brown on the panel, so the shadows go violet.\nconst CREAM = [1, 0.93, 0.76], DUSK = [0.16, 0.09, 0.26];\nconst FIRE = [1, 0.52, 0.12];\n// Half widths of the torso by row (shoulders, chest, waist, hips) and of a\n// leg by distance down from the hip.\nconst TORSO_W = [[31, 7], [34, 12], [44, 11.5], [62, 9.2], [72, 10.4], [80, 10.8]];\nconst LEG_W = [[0, 5.9], [14, 5.2], [23, 4.3], [34, 3.9], [44, 3.5]];\n// The torch on the left wall: the top of its bowl.\nconst TX = 4, TY = 74;\n// One strip's turn, in story seconds: it peels off, flies, winds back on.\nconst PEEL = 1.6, FLY = 2.4, REWIND = 1.8;\n// Where the loose ends hang: which part, how far along it, which side, length.\nconst ENDS = [\n  [\"armL\", 0.45, 1, 9], [\"armR\", 0.82, 1, 7], [\"torso\", 35, -1, 8], [\"torso\", 21, 1, 10],\n  [\"legR\", 23, 1, 7], [\"legL\", 36, -1, 6], [\"head\", -6, 1, 6],\n];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, glow: 0, speed: 2, wind: 0, torch: 0.06, gust: 0.5,\n    ev: [], rest: 1.6, motes: [], voids: [],\n    bg: null, buf: new Float32Array(N * 3), pose: null,\n  };\n}\n\n// The tomb wall: courses of big stones, all below the panel's lit threshold\n// of 24, so what counts as lit is the mummy and the torch.\nfunction wall(S) {\n  const bg = new Float32Array(N * 3);\n  for (let y = 0; y \u003c H; y++) {\n    const row = floor(y / 11), off = (row & 1) * 9, my = y % 11 === 0;\n    for (let x = 0; x \u003c W; x++) {\n      const col = floor((x + off) / 18), mx = (x + off) % 18 === 0;\n      const v = (0.62 + 0.38 * hash(row * 31 + col * 7)) * (my || mx ? 0.45 : 1) * (0.7 + 0.3 * (y / H));\n      const o = (y * W + x) * 3;\n      const floorY = y >= 124;\n      bg[o] = (floorY ? 0.07 : 0.05) * v;\n      bg[o + 1] = (floorY ? 0.035 : 0.022) * v;\n      bg[o + 2] = 0.085 * v;\n    }\n  }\n  S.bg = bg;\n}\n\nfunction newEvent(S) {\n  const busy = S.ev.map((e) => e.part);\n  // The first strip always comes off the chest, where it shows most.\n  let part = \"torso\";\n  for (let k = S.begun ? 0 : 6; k \u003c 6; k++) {\n    const r = Math.random() * 5.6;\n    part = r \u003c 3 ? \"torso\" : r \u003c 4 ? \"legL\" : r \u003c 5 ? \"legR\" : \"head\";\n    if (!busy.includes(part)) break;\n  }\n  // A band well inside the part, so the strip and its hollow are seen whole.\n  const span = { torso: [9, 40, 4.2], legL: [9, 36, 4], legR: [9, 36, 4], head: [4, 16, 3] }[part];\n  const band = floor((span[0] + Math.random() * (span[1] - span[0])) / span[2]);\n  // A strip off the chest is two bands wide.\n  S.ev.push({ part, band, bands: part === \"torso\" ? 2 : 1, stage: 0, timer: 0, p: 0, seed: Math.random() * 6.3 });\n  S.begun = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.glow = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[2], 0, 1);\n  S.torch = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  const T = S.t, wind = S.wind;\n  // Gusts: the draught swells and drops on two slow beats.\n  S.gust = 0.5 + 0.5 * sin(T * 0.9) * sin(T * 0.37 + 1);\n  // The strips: one at a time, two at once in a strong wind. The rest\n  // before the next one only runs while there is room for it.\n  if (S.ev.length \u003c (wind > 0.5 ? 2 : 1)) S.rest -= ds;\n  if (S.rest \u003c= 0) {\n    newEvent(S);\n    S.rest = (2 + 2 * Math.random()) * (1 - 0.35 * wind);\n  }\n  for (const e of S.ev) {\n    e.timer += ds;\n    if (e.stage === 0) {\n      e.p = sm(0, PEEL, e.timer);\n      if (e.timer >= PEEL) (e.stage = 1), (e.timer = 0);\n    } else if (e.stage === 1) {\n      e.p = 1;\n      if (e.timer >= FLY) (e.stage = 2), (e.timer = 0);\n    } else {\n      e.p = 1 - sm(0, REWIND, e.timer);\n      if (e.timer >= REWIND) e.done = true;\n    }\n  }\n  S.ev = S.ev.filter((e) => !e.done);\n  // Motes of the glow blow out of an open hollow and away on the wind.\n  const aw = windAngle(S), v0 = 9 + 22 * wind;\n  if (S.voids.length) {\n    let n = ds * 14;\n    while (n > 0 && S.motes.length \u003c 60) {\n      if (Math.random() \u003c n) {\n        const [x, y] = S.voids[floor(Math.random() * S.voids.length)];\n        const a = aw + (Math.random() - 0.5) * 0.9, v = v0 * (0.5 + Math.random());\n        S.motes.push({ x, y, vx: cos(a) * v, vy: sin(a) * v - 4, life: 1, ph: Math.random() * 6 });\n      }\n      n -= 1;\n    }\n  }\n  for (const m of S.motes) {\n    m.life -= ds * 0.75;\n    m.x += m.vx * ds;\n    m.y += (m.vy + 4 * sin(T * 5 + m.ph)) * ds;\n  }\n  S.motes = S.motes.filter((m) => m.life > 0 && m.x > -2 && m.x \u003c W + 2 && m.y > -2 && m.y \u003c H + 2);\n  S.pose = pose(S);\n}\n\n// The wind's direction for strips and ends: down and to the right in a\n// draught, out and up to the right in a gale.\nfunction windAngle(S) {\n  const B = 0.45 + 0.25 * S.gust + S.wind * (0.3 + 0.3 * S.gust);\n  return mix(1.45, -0.4, min(1.05, B));\n}\n\n// The body this frame. The shamble is one step every 2.8 story seconds: the\n// weight goes from foot to foot, the free foot drags up, the hips and then\n// the shoulders swing over it, the head lolls behind, and the arms bob out\n// of step.\nfunction pose(S) {\n  const T = S.t, w = (2 * PI * T) / 2.8, sw = sin(w);\n  const dy = 0.6 - 0.9 * abs(sw);\n  const hipX = 32 + 1.1 * sw;\n  // The gale pushes the mummy over a little; it leans back into it.\n  const lean = -2.4 * S.wind * (0.6 + 0.4 * S.gust);\n  const sway = 2.1 * sin(w - 0.4) + lean;\n  const torsoX = (y) => hipX + sway * cl((78 - y) / 46, 0, 1.15);\n  const torso = { y0: 31 + dy, y1: 80 + dy, cx: (y) => torsoX(y - dy), w: (y) => tab(TORSO_W, y - dy), tilt: 0.42, bw: 4.2, seed: 0.3 };\n  const legs = {};\n  for (const [name, side, lift] of [[\"legL\", -1, 2.6 * max(0, sw) ** 1.5], [\"legR\", 1, 2.6 * max(0, -sw) ** 1.5]]) {\n    const hx = hipX + side * 6.1, ax = 32 + side * 7.2, y0 = 77 + dy, y1 = 120 - lift, L = y1 - y0;\n    // A lifted leg bends its knee in.\n    const knee = -side * 1.6 * (lift / 2.6);\n    legs[name] = {\n      y0, y1, cx: (y) => mix(hx, ax, (y - y0) / L) + knee * sin((PI * (y - y0)) / L),\n      w: (y) => tab(LEG_W, ((y - y0) * 44) / L), tilt: side * 0.5, bw: 4, seed: side > 0 ? 0.6 : 0.1, foot: [ax + side * 0.8, y1 + 3],\n    };\n  }\n  const sy = 37 + dy, shX = torsoX(37);\n  const reach = -1.4 * sin(T * 0.7);\n  const arms = {};\n  for (const [name, side, bob] of [[\"armL\", -1, 2.6 * sin(w + 0.6)], [\"armR\", 1, 2.6 * sin(w + PI + 0.6)]]) {\n    const x0 = shX + side * 9, x1 = cl(shX + side * 25, 4, 59), wy = sy - 1.5 + bob + reach;\n    arms[name] = {\n      x0, x1, cy: (x) => mix(sy, wy, (x - x0) / (x1 - x0)), w: (x) => mix(4.3, 3, (x - x0) / (x1 - x0)), tilt: 0.5, bw: 3.6, seed: side > 0 ? 0.5 : 0,\n      // The hand hangs limp from the wrist and swings.\n      hand: [x1 + side * 0.5, wy, 1.3 * sin(w * 2 + side) + side * 0.6],\n    };\n  }\n  const head = { hx: torsoX(31) + 1.3 * sin(w - 1.3), hy: 18.5 + dy * 0.5 - 0.6 * abs(sin(w - 0.9)), rx: 8.4, ry: 11 };\n  return { dy, torso, ...legs, ...arms, head };\n}\n\n// The colour of bandage: lit level v (0 to 1) on the linen ramp, in steps\n// of 1/14 so a smooth shade does not cost the frame its bytes.\nfunction linen(buf, o, v) {\n  v = round(cl(v, 0, 1) * 14) / 14;\n  const k = 0.32 + 0.68 * v;\n  buf[o] = mix(DUSK[0], CREAM[0], v) * k;\n  buf[o + 1] = mix(DUSK[1], CREAM[1], v) * k;\n  buf[o + 2] = mix(DUSK[2], CREAM[2], v) * k;\n}\n\n// The torch turns the side of the linen that faces it orange, in steps;\n// t is where the LED sits across its limb, -1 on the left.\nfunction torchlit(S, o, x, y, t, v) {\n  const dx = x - TX, dy = y - TY + 6;\n  const warm = round(((S.tl * max(0, 0.6 - t)) / 1.6 / (1 + (dx * dx + dy * dy) / 5000)) * 10) / 10;\n  if (warm \u003c= 0) return;\n  const a = min(0.85, warm * 0.9), k = 0.35 + 0.65 * v;\n  S.buf[o] = S.buf[o] * (1 - a) + FIRE[0] * k * a;\n  S.buf[o + 1] = S.buf[o + 1] * (1 - a) + FIRE[1] * k * a;\n  S.buf[o + 2] = S.buf[o + 2] * (1 - a) + FIRE[2] * k * a;\n}\n\n// One LED on a wrapped limb. t runs across the limb (-1 to 1), s along it;\n// the bands run round it on a helix, so on the front they cross at a slant\n// and bend over the curve. Each band throws a thin shadow on the next, and\n// the light comes from the upper left.\nfunction wrapped(S, o, x, y, t, s, part, id, light) {\n  const th = asin(t), phi = (s + part.tilt * part.wd * th) / part.bw + part.seed, b = floor(phi), f = phi - b;\n  for (const e of S.ev)\n    if (e.part === id && b >= e.band && b \u003c e.band + e.bands && t \u003c -1 + 2 * min(1, e.p * 1.5)) {\n      // The hollow: nothing inside but the glow, brightest deep in the middle.\n      const g = round((0.12 + 0.55 * (1 - abs(t)) * (0.85 + 0.15 * sin(S.t * 7 + y * 0.4))) * 10) / 10;\n      S.buf[o] = S.G[0] * g;\n      S.buf[o + 1] = S.G[1] * g;\n      S.buf[o + 2] = S.G[2] * g;\n      if (((x * 7 + y * 3) & 7) === 0) S.voids.push([x, y]);\n      return;\n    }\n  const lam = 0.36 + 0.64 * max(0, cos(th - light));\n  const band = f \u003c 0.15 ? 0.5 : 0.78 + 0.22 * ((f - 0.15) / 0.85);\n  const vary = 0.86 + 0.14 * hash(b * 13 + floor(part.seed * 10));\n  const v = lam * band * vary;\n  linen(S.buf, o, v);\n  // The torch turns the near side orange, in steps.\n  torchlit(S, o, x, y, t, v);\n  // The glow from inside the tomb catches the far side: the right flank of\n  // an upright limb, the underside of an arm.\n  const gl = round(max(0, t - 0.05) * 0.66 * 8 * (0.9 + 0.1 * sin(S.t * 3.1))) / 8;\n  if (gl > 0) {\n    S.buf[o] = S.buf[o] * (1 - gl) + S.G[0] * gl;\n    S.buf[o + 1] = S.buf[o + 1] * (1 - gl) + S.G[1] * gl;\n    S.buf[o + 2] = S.buf[o + 2] * (1 - gl) + S.G[2] * gl;\n  }\n}\n\n// A limb standing up: centre and half width by row.\nfunction upright(S, part, id) {\n  const y0 = max(0, Math.ceil(part.y0)), y1 = min(H - 1, floor(part.y1));\n  for (let y = y0; y \u003c= y1; y++) {\n    const c = part.cx(y), w = part.w(y);\n    if (w \u003c 0.6) continue;\n    part.wd = w;\n    for (let x = max(0, Math.ceil(c - w)); x \u003c= min(W - 1, floor(c + w)); x++) {\n      const t = (x - c) / w;\n      if (abs(t) > 1) continue;\n      wrapped(S, (y * W + x) * 3, x, y, t, y - part.y0, part, id, -0.55);\n    }\n  }\n}\n\n// An arm held out: centre row and half height by column.\nfunction outstretched(S, arm) {\n  const a = min(arm.x0, arm.x1), b = max(arm.x0, arm.x1);\n  for (let x = max(0, Math.ceil(a)); x \u003c= min(W - 1, floor(b)); x++) {\n    const c = arm.cy(x), w = arm.w(x);\n    arm.wd = w;\n    for (let y = max(0, Math.ceil(c - w)); y \u003c= min(H - 1, floor(c + w)); y++) {\n      const t = (y - c) / w;\n      if (abs(t) > 1) continue;\n      wrapped(S, (y * W + x) * 3, x, y, t, abs(x - arm.x0), arm, \"arm\", -1.1);\n    }\n  }\n  // The hand hangs from the wrist, wrapped too, with the fingers parted at\n  // the bottom.\n  const [hx, hy, swing] = arm.hand;\n  const hand = { y0: hy - 2, y1: hy + 8, cx: (y) => hx + (swing * (y - hy)) / 8, w: (y) => (y \u003c hy + 4 ? 2.7 : 2.7 - (y - hy - 4) * 0.2), tilt: 0.2, bw: 2.4, seed: 0.2 };\n  upright(S, hand, \"hand\");\n  for (let y = round(hy + 4); y \u003c= round(hy + 8); y++)\n    for (const f of [-0.9, 0.9]) {\n      const x = round(hand.cx(y) + f);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) linen(S.buf, (y * W + x) * 3, 0.12);\n    }\n}\n\n// A ribbon of linen from (x, y), heading off at angle a0 and turning into\n// the wind over its first 9 LEDs, whipping more towards its free end and\n// curling by curl radians an LED after that. It\n// twists as it goes: where it turns edge-on it narrows, and its back is\n// darker than its face, so the twist reads as a spiral.\nfunction ribbon(S, x, y, a0, L, aw, flut, ph, wide, curl) {\n  const buf = S.buf;\n  for (let s = 0; s \u003c L; s += 0.5) {\n    const u = s / L;\n    const a = mix(a0, aw, sm(0, 9, s)) + curl * max(0, s - 6) + flut * u * sin(ph - 0.3 * s) + 0.18 * flut * sin(ph * 1.7 - 0.7 * s);\n    x += 0.5 * cos(a);\n    y += 0.5 * sin(a);\n    const tw = cos(0.36 * s - ph * 1.2), hw = wide * (0.3 + 0.7 * abs(tw)), face = tw > 0 ? 1 : 0.74;\n    const nx = -sin(a), ny = cos(a);\n    for (let q = -hw; q \u003c= hw + 1e-6; q += 0.5) {\n      const px = round(x + q * nx), py = round(y + q * ny);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const o = (py * W + px) * 3, v = face * (1 - 0.25 * (q / max(hw, 0.5)) ** 2) * (0.92 + 0.08 * cos(s * 1.3));\n      linen(buf, o, v);\n      torchlit(S, o, px, py, 0, v);\n    }\n  }\n}\n\n// The torch: a bowl on a bracket and a flame that licks and leans with the\n// wind, its light on the wall in steps.\nfunction torch(S) {\n  const buf = S.buf, T = S.t, size = 0.75 + 0.85 * S.torch, lit = S.tl;\n  for (let y = 40; y \u003c 104; y++)\n    for (let x = 0; x \u003c 30; x++) {\n      const dx = x - TX, dy = (y - TY + 6) * 0.8, r = sqrt(dx * dx + dy * dy);\n      const g = round(exp(-r / (5 + 9 * S.torch)) * lit * 14) / 20;\n      if (g \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      buf[o] += FIRE[0] * g * 0.55;\n      buf[o + 1] += FIRE[1] * g * 0.45;\n      buf[o + 2] += FIRE[2] * g * 0.4;\n    }\n  // Bracket and bowl, dark iron with a lit rim.\n  for (let y = TY; y \u003c TY + 10; y++) for (const x of [TX - 1, TX]) if (y > TY + 2 || x === TX) buf.set([0.1, 0.06, 0.1], (y * W + x) * 3);\n  for (let x = TX - 3; x \u003c= TX + 3; x++) {\n    buf.set([0.32, 0.16, 0.08], (TY * W + x) * 3);\n    if (abs(x - TX) \u003c 3) buf.set([0.12, 0.07, 0.1], ((TY + 1) * W + x) * 3);\n  }\n  const Hf = 9 * size * (0.9 + 0.1 * sin(T * 17) * sin(T * 6.1)), bend = (0.15 + 0.5 * S.wind) * (0.7 + 0.6 * S.gust);\n  for (let y = floor(TY - Hf - 1); y \u003c TY; y++) {\n    const u = (TY - y) / Hf;\n    if (u > 1 || y \u003c 0) continue;\n    const fx = TX + bend * u * u * Hf * 0.5 + 0.8 * u * sin(T * 13 + y * 0.7);\n    const fw = 2.6 * size * sin(PI * min(1, u * 1.2 + 0.12)) ** 0.7 * (1 - 0.5 * u);\n    for (let x = floor(fx - fw); x \u003c= Math.ceil(fx + fw); x++) {\n      if (x \u003c 0 || x >= W) continue;\n      const r = abs(x - fx) / max(0.5, fw);\n      if (r > 1) continue;\n      const o = (y * W + x) * 3;\n      const c = r \u003c 0.45 && u \u003c 0.55 ? [1, 0.92, 0.55] : r \u003c 0.75 && u \u003c 0.85 ? [1, 0.62, 0.12] : [1, 0.36, 0.05];\n      buf[o] = c[0];\n      buf[o + 1] = c[1];\n      buf[o + 2] = c[2];\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.pose) return;\n  if (!S.bg) wall(S);\n  const P = S.pose, buf = S.buf, T = S.t;\n  S.G = hsv(0.3 + 0.55 * S.glow, 0.88, 1);\n  // The torch's light now: it flickers.\n  S.tl = (0.12 + 1.25 * S.torch) * (0.82 + 0.18 * sin(T * 11) * sin(T * 7.3 + 1));\n  buf.set(S.bg);\n  S.voids = [];\n  torch(S);\n  // A shadow on the floor under the feet.\n  for (let y = 122; y \u003c H; y++)\n    for (let x = 14; x \u003c 50; x++) {\n      const q = ((x - 32) / 18) ** 2 + ((y - 125) / 3) ** 2;\n      if (q \u003c 1) for (let c = 0; c \u003c 3; c++) buf[(y * W + x) * 3 + c] *= 0.4;\n    }\n  // Back to front: legs and feet, torso, neck, arms, head.\n  for (const id of [\"legL\", \"legR\"]) {\n    const L = P[id];\n    upright(S, L, id);\n    const [fx, fy] = L.foot;\n    upright(S, { y0: fy - 2.6, y1: fy + 2.4, cx: () => fx, w: (y) => 4.6 * sqrt(max(0, 1 - ((y - fy) / 2.7) ** 2)), tilt: 0.1, bw: 2.5, seed: 0.4 }, \"foot\");\n  }\n  upright(S, { y0: P.head.hy + 8, y1: P.torso.y0 + 2, cx: (y) => P.torso.cx(y), w: () => 5, tilt: 0.3, bw: 2.6, seed: 0 }, \"neck\");\n  upright(S, P.torso, \"torso\");\n  outstretched(S, P.armL);\n  outstretched(S, P.armR);\n  const h = P.head;\n  const head = {\n    y0: h.hy - h.ry, y1: h.hy + h.ry, cx: () => h.hx, tilt: -0.12, bw: 3, seed: 0.1,\n    w: (y) => h.rx * sqrt(max(0, 1 - ((y - h.hy) / h.ry) ** 2)) * (y > h.hy ? 1 - (0.14 * (y - h.hy)) / h.ry : 1),\n  };\n  upright(S, head, \"head\");\n  // The slit in the wrappings and the eyes in it.\n  const ey = round(h.hy), ex = round(h.hx);\n  const flare = S.ev.reduce((m, e) => max(m, e.p), 0);\n  const eg = 0.8 + 0.2 * sin(T * 3.1) + 0.2 * flare;\n  for (let y = ey - 2; y \u003c= ey + 1; y++)\n    for (let x = ex - 6; x \u003c= ex + 6; x++) {\n      if (abs(x - ex) > (y === ey - 2 || y === ey + 1 ? 4 : 6)) continue;\n      const o = (y * W + x) * 3, eye = (y === ey - 1 || y === ey) && (x === ex - 4 || x === ex - 3 || x === ex + 3 || x === ex + 4);\n      const near = abs(abs(x - ex) - 3.5) \u003c 2 ? 0.3 : 0.06;\n      const g = eye ? min(1, eg) : near * eg;\n      buf[o] = 0.02 + S.G[0] * g + (eye ? 0.35 * flare : 0);\n      buf[o + 1] = 0.01 + S.G[1] * g + (eye ? 0.35 * flare : 0);\n      buf[o + 2] = 0.04 + S.G[2] * g + (eye ? 0.35 * flare : 0);\n    }\n  // Loose ends: short tails pinned to the body, fluttering on the wind.\n  const aw = windAngle(S), wind = S.wind;\n  ENDS.forEach(([id, at, side, len], n) => {\n    let x, y;\n    if (id === \"armL\" || id === \"armR\") {\n      const A = P[id];\n      x = mix(A.x0, A.x1, at);\n      y = A.cy(x) + A.w(x) * side;\n    } else if (id === \"head\") {\n      x = h.hx + side * 5.5;\n      y = h.hy + at;\n    } else {\n      const L = P[id], yy = L.y0 + at;\n      x = L.cx(yy) + L.w(yy) * side;\n      y = yy;\n    }\n    const a = mix(1.5, aw, 0.35 + 0.6 * wind), ph = T * (6 + 7 * wind) + n * 1.9;\n    ribbon(S, x, y, PI / 2 - side * 0.2, len * (1 + 0.3 * wind), a, 0.5 + 0.6 * wind, ph, 1, 0);\n  });\n  // The strips coming off: each leaves its band at the peel point, which\n  // runs across the front from the left as it unwinds and back as it winds\n  // on.\n  for (const e of S.ev) {\n    const part = P[e.part === \"head\" ? \"head\" : e.part], geo = e.part === \"head\" ? head : part;\n    const tp = cl(-1 + 2 * min(1, e.p * 1.5), -0.98, 0.98), th = asin(tp);\n    const mid = e.band + e.bands / 2 - geo.seed;\n    let y = geo.y0 + mid * geo.bw;\n    for (let it = 0; it \u003c 3; it++) y = geo.y0 + mid * geo.bw - geo.tilt * geo.w(y) * th;\n    const x = geo.cx(y) + geo.w(y) * tp;\n    const L = e.p * (38 + 26 * wind);\n    // In a draught the strip streams out to the right and curls down into\n    // the open space beside the legs; in a gale it catches the updraft and\n    // climbs the right side of the panel. Either way it stays on the panel.\n    if (L > 1) ribbon(S, x, y, atan2(-geo.tilt, cos(th)), L, aw + mix(0.15, -0.7, wind), 0.7 + 0.6 * wind, T * (7 + 6 * wind) + e.seed, 0.9 + 0.7 * e.bands, mix(0.035, -0.02, wind));\n  }\n  // Motes from the hollows.\n  for (const m of S.motes) {\n    const x = round(m.x), y = round(m.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3, g = round(m.life * 4) / 4;\n    buf[o] = max(buf[o], S.G[0] * g);\n    buf[o + 1] = max(buf[o + 1], S.G[1] * g);\n    buf[o + 2] = max(buf[o + 2], S.G[2] * g);\n  }\n  for (let p = 0, o = 0; p \u003c N; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, round(255 * min(1, buf[o])), round(255 * min(1, buf[o + 1])), round(255 * min(1, buf[o + 2])));\n}\n","plancherel-growth":"// ===== Patternflow pattern =====\n// Title:   Plancherel Growth\n// Family:  data\n// Idea:    A Young diagram grows one diamond box at a time by Robinson-Schensted insertion of random numbers, its corner on the left edge and its rows and columns running up and down the panel, and as the boxes pile up the diagram fills out toward the thin Logan-Shepp-Vershik-Kerov curve drawn for its final size, in rings coloured by arrival that are the same curve, smaller.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Plancherel growth of Young diagrams, with the limit shape of Benjamin Logan and Larry Shepp, and of Anatoly Vershik and Sergei Kerov (1977), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Size=3..6, Curve=0..1\n//\n// Knob 1: Hue. Turns the arrival colours round the wheel: at 0 the first boxes in the corner are violet, then blue, cyan and green out to the last boxes at the edge; at 0.35 they run orange, red, magenta and violet to blue; at 0.6 green, yellow, orange and red to pink.\n// Knob 2: Speed. At 2 the boxes come 27 a second: after a second's pause a diagram of 196 boxes grows in 7.3 seconds, holds for 3, then shrinks back into the corner in one, and a new random diagram starts. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Size. The half-diagonal of a box in LEDs, 3 to 6. The final count is chosen so the limit curve keeps its place on the panel: 196 boxes at 3, 110 at 4, 71 at 5, 49 at 6, and as the boxes come at the same rate the bigger ones fill it sooner.\n// Knob 4: Curve. Brightness of the limit curve and of the two axes it leans on, from dim at 0 to white at 1. Past about 0.3 the boxes the limit shape expects but the diagram has not yet reached show faintly, each in the colour it is expected to arrive in.\n\nconst W = 64, H = 128, MIDY = 64;\nconst { floor, min, max, abs, sqrt, round, asin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The limit shape in Russian coordinates: u is the content j - i, v is\n// i + j, both over the square root of the box count. A box is then a\n// diamond of half-diagonal 1/sqrt(n) and area 2/n, so the area between\n// Omega and |u| is 2 whatever n is (checked numerically: 2.0000, and an RSK\n// run of 10000 boxes sits within 0.01 of the curve on average).\nconst omega = (u) => (abs(u) >= 2 ? abs(u) : (2 / PI) * (u * asin(u / 2) + sqrt(4 - u * u)));\n\n// The unit of the limit shape on the panel, h sqrt(n) LEDs: the curve's\n// middle sits 4/pi of it from the corner (53 LEDs) and its ends would meet\n// the axes at twice it, past the right edge, so the curve leaves the panel\n// 12 rows from the top and bottom. At 38 the full diagram lit a quarter of\n// the panel and the picture changed too little while it grew (drift 0.20);\n// at 42 it lights about a third.\nconst SCALE = 42;\n// One cycle, in story seconds (one a second at Speed 2): an empty pause, the\n// growth at BPS boxes a second, the hold on the full diagram, and the\n// shrink back to the corner. The rate is in boxes, not in share of the\n// diagram, so bigger boxes fill the curve sooner: 196 boxes take 7.3\n// seconds and 49 take 1.8.\nconst PRE = 1, BPS = 27, HOLD = 3, SHRINK = 1;\n// The seams between boxes keep this much of the box's colour, so each box\n// reads as its own diamond.\nconst SEAM = 0.4;\n// Rows and columns kept for a diagram: far more than any arm of 196 boxes reaches.\nconst M = 64;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: -1, speed: 2, size: 0, curveK: 0.06,\n    h: 3, n: 0, sc: SCALE, phase: 0, cycleT: 0, shown: 0,\n    rows: [], count: 0, arr: new Int16Array(M * M), col: null, colHue: NaN,\n    cell: new Int32Array(W * H * 4), inner: new Uint8Array(W * H), lens: new Uint8Array(W * H),\n    curveX: new Int16Array(H), expect: new Float32Array(M * M),\n  };\n}\n\n// The pixel tables for box half-diagonal h. With A = x + y - 64 and\n// B = x - y + 64, box (i, j) has its centre at A = (2j+1)h, B = (2i+1)h,\n// so j = floor(A / 2h), i = floor(B / 2h), and a pixel with A or B a\n// multiple of 2h lies on a seam between two boxes (four at a vertex).\nfunction rebuild(S, h) {\n  S.h = h;\n  S.n = round((SCALE / h) ** 2);\n  S.sc = h * sqrt(S.n);\n  S.size = h;\n  const cell = S.cell, h2 = 2 * h;\n  cell.fill(-1);\n  S.inner.fill(0);\n  S.lens.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const xc = S.sc * omega((y - MIDY) / S.sc);\n    S.curveX[y] = abs(y - MIDY) \u003c 2 * S.sc ? round(xc) : -1;\n    for (let x = 0; x \u003c W; x++) {\n      const A = x + y - MIDY, B = x - y + MIDY, p = y * W + x;\n      if (A \u003c 0 || B \u003c 0) continue;\n      const j = floor(A / h2), i = floor(B / h2), sa = A % h2 === 0, sb = B % h2 === 0;\n      if (x \u003c= xc) S.lens[p] = 1;\n      if (!sa && !sb) {\n        S.inner[p] = 1;\n        cell[p * 4] = i \u003c M && j \u003c M ? i * M + j : -1;\n        continue;\n      }\n      // A seam: the boxes on either side of it that exist.\n      let n = 0;\n      for (const [di, dj] of [[0, 0], [0, sa ? -1 : 0], [sb ? -1 : 0, 0], [sb ? -1 : 0, sa ? -1 : 0]]) {\n        const ii = i + di, jj = j + dj;\n        if (ii \u003c 0 || jj \u003c 0 || ii >= M || jj >= M) continue;\n        const c = ii * M + jj;\n        if (n === 0 || cell[p * 4 + n - 1] !== c) cell[p * 4 + n++] = c;\n      }\n    }\n  }\n  // When the limit shape expects each box to be covered, kept as the square\n  // root of the share k/n of the final count: the diagram after k boxes\n  // hugs the curve scaled by sqrt(k/n), and those scaled curves are nested,\n  // so it is the scale whose curve passes through the box's centre.\n  const rn = sqrt(S.n);\n  for (let i = 0; i \u003c M; i++)\n    for (let j = 0; j \u003c M; j++) {\n      const u = (j - i) / rn, v = (i + j + 1) / rn;\n      if (v > omega(u)) {\n        S.expect[i * M + j] = -1;\n        continue;\n      }\n      let lo = 0, hi = 1;\n      for (let it = 0; it \u003c 24; it++) {\n        const s = (lo + hi) / 2;\n        if (s * omega(u / s) \u003c v) lo = s;\n        else hi = s;\n      }\n      S.expect[i * M + j] = hi;\n    }\n  S.colHue = NaN;\n  restart(S);\n}\n\n// A fresh diagram: empty rows, and no box has arrived yet.\nfunction restart(S) {\n  S.rows = [];\n  S.count = 0;\n  S.shown = 0;\n  S.arr.fill(-1);\n  S.phase = 0;\n  S.cycleT = 0;\n}\n\n// Robinson-Schensted row insertion of one uniform random number: into row 0\n// it bumps the smallest entry bigger than itself into the next row, and so\n// on; where nothing is bumped it goes on the end of the row, and that is the\n// new box. After k insertions the shape is Plancherel-distributed.\nfunction insert(S) {\n  let x = Math.random(), r = 0;\n  for (;;) {\n    if (r === S.rows.length) S.rows.push([]);\n    const row = S.rows[r];\n    let lo = 0, hi = row.length;\n    while (lo \u003c hi) {\n      const m = (lo + hi) >> 1;\n      if (row[m] > x) hi = m;\n      else lo = m + 1;\n    }\n    if (lo === row.length) {\n      row.push(x);\n      if (r \u003c M && lo \u003c M) S.arr[r * M + lo] = S.count;\n      S.count++;\n      return;\n    }\n    const y = row[lo];\n    row[lo] = x;\n    x = y;\n    r++;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.curveK = cl(k[3], 0, 1);\n  const h = cl(round(k[2]), 3, 6);\n  if (h !== S.size) rebuild(S, h);\n  const ds = (d * S.speed) / 2;\n  S.cycleT += ds;\n  if (S.phase === 0) {\n    // Growing: the boxes come at an even rate, one random number each.\n    const want = min(S.n, floor(BPS * max(0, S.cycleT - PRE)));\n    while (S.count \u003c want) insert(S);\n    S.shown = S.count;\n    if (S.count >= S.n) (S.phase = 1), (S.cycleT = 0);\n  } else if (S.phase === 1) {\n    if (S.cycleT >= HOLD) (S.phase = 2), (S.cycleT = 0);\n  } else {\n    // Shrinking back the way it came: the last box to arrive leaves first,\n    // so the rings close in on the corner.\n    S.shown = floor(S.n * (1 - cl(S.cycleT / SHRINK, 0, 1)));\n    if (S.cycleT >= SHRINK) restart(S);\n  }\n}\n\n// One colour per arrival. Colouring by arrival is the recording tableau of\n// the insertion, so a box never changes colour once it is down (the\n// inserted values do change as they are bumped). And it shows the\n// mathematics: the boxes that came by the k-th hug the limit curve scaled\n// by sqrt(k/n), so the hue runs with sqrt(k/n) and the colour bands are\n// evenly spaced copies of the curve, nested in the corner.\nfunction palette(S) {\n  const n = S.n;\n  S.col = new Float32Array(n * 3);\n  for (let a = 0; a \u003c n; a++) {\n    const c = hsv(0.8 + S.hue - 0.5 * sqrt((a + 1) / n), 0.88, 1);\n    S.col.set(c, a * 3);\n  }\n  S.colHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.n) return;\n  if (S.colHue !== S.hue) palette(S);\n  const { cell, inner, lens, arr, col, shown, expect } = S;\n  const ck = S.curveK;\n  // The limit curve and the axes: dim at 0, white at 1.\n  const lineV = 0.42 + 0.58 * ck, axisV = 0.18 + 0.4 * ck;\n  // The expected boxes show from about 0.3 up.\n  const ghost = 0.3 * cl((ck - 0.25) / 0.75, 0, 1);\n  for (let y = 0; y \u003c H; y++) {\n    const cx = S.curveX[y];\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r = 0, g = 0, b = 0;\n      if (inner[p]) {\n        const c = cell[p * 4];\n        const a = c >= 0 ? arr[c] : -1;\n        if (a >= 0 && a \u003c shown) (r = col[a * 3]), (g = col[a * 3 + 1]), (b = col[a * 3 + 2]);\n        else if (ghost > 0 && c >= 0 && lens[p] && expect[c] > 0) {\n          const e = min(S.n - 1, floor(expect[c] * expect[c] * S.n)) * 3;\n          (r = col[e] * ghost), (g = col[e + 1] * ghost), (b = col[e + 2] * ghost);\n        }\n      } else if (cell[p * 4] >= 0 || cell[p * 4 + 1] >= 0) {\n        // A seam takes the colour of the first box beside it to arrive, so it\n        // is set once and never changes while the diagram grows.\n        let best = 1e9;\n        for (let q = 0; q \u003c 4; q++) {\n          const c = cell[p * 4 + q];\n          if (c \u003c 0) break;\n          const a = arr[c];\n          if (a >= 0 && a \u003c shown && a \u003c best) best = a;\n        }\n        if (best \u003c 1e9) (r = col[best * 3] * SEAM), (g = col[best * 3 + 1] * SEAM), (b = col[best * 3 + 2] * SEAM);\n        // The two axes the diagram stands on: the outer seams of row 0 and\n        // column 0.\n        if (x + y === MIDY || x - y + MIDY === 0) {\n          r = max(r, axisV * 0.85);\n          g = max(g, axisV * 0.9);\n          b = max(b, axisV);\n        }\n      }\n      if (x === cx) {\n        // The limit curve for the final count, drawn over everything.\n        r = lineV;\n        g = lineV * 0.96;\n        b = lineV * 0.88;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  }\n}\n","poltergeist":"// ===== Patternflow pattern =====\n// Title:   Poltergeist\n// Family:  halloween\n// Idea:    In a dim parlour lit by a hanging oil lamp, an unseen spirit gets restless: books fly off the shelf flapping open like birds, plates spin up off the table and circle the lamp, the chair rises and tilts, the picture swings crooked and the clock hands race backwards, each flying thing trailing green ectoplasm, until everything drops at once with a crash, the lamp gutters, and after a pause it starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Fury=1..5, Lamp=0..1\n//\n// Knob 1: Hue. The colour of the ectoplasm the spirit and the flying things trail, and of the mist it leaves pooled on the floor: toxic green at 0, cyan at 0.2, blue at 0.3, violet at 0.45, pink at 0.55, orange at 0.78 and yellow at 0.86. The lamplight and the room stay orange and purple.\n// Knob 2: Speed. At 2 one haunting takes about 10 seconds: 1.2 quiet, 1.2 of rattling, 5 in the air, a crash, and 1.6 while the lamp gutters; the first things lift at 1.8 seconds. At 0.2 it all runs ten times slower, at 3 half as fast again.\n// Knob 3: Fury. How many things fly and how wildly. At 1 two books, one plate and the chair, which rocks about 2 LEDs off the floor; at 3 four books, three plates and the chair about 10 LEDs up; at 5 all six books and all four plates, flying half as fast again in loops a third wider, and the chair about 19 LEDs up.\n// Knob 4: Lamp. How far the hanging lamp swings, so its pool of light sweeps the walls and the things in the air: at 0 a sway of 4 degrees, at 0.06 6 degrees, at 1 a swing of 30 degrees either way. While things fly the spirit pushes it further, half as far again at Fury 1 and 2.2 times at Fury 5, never past 45 degrees.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sqrt, sin, cos, exp, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The room. The lamp hangs on a chain from a hook above the panel; the\n// wall runs down to the chair rail, then panelling, then the floor.\nconst HOOK_X = 32, CHAIN = 40, RAIL = 84, BASE = 104;\n// The table: its top and its two ends.\nconst TOP = 93, TX0 = 5, TX1 = 37;\n// The shelf on the right wall, and the books on it.\nconst SHELF = 60, SX0 = 40, SX1 = 62;\n// The chair's resting place: the middle of its seat.\nconst CHX = 51, CHY = 98;\n// Picture frame on a nail, and the clock.\nconst NAIL_X = 14, NAIL_Y = 7, FW = 16, FH = 20;\nconst CLX = 52, CLY = 20, CLR = 8;\n\n// The lamplight on a surface, as a ramp from purple shadow through rose to\n// orange and yellow. Light is quantised into eleven steps: the steps do not\n// show on the panel and a smooth glow would only add noise.\nconst RAMP = [\n  [0, [0.05, 0.012, 0.09]],\n  [0.14, [0.15, 0.04, 0.24]],\n  [0.3, [0.36, 0.08, 0.42]],\n  [0.46, [0.8, 0.22, 0.36]],\n  [0.62, [1, 0.46, 0.1]],\n  [0.8, [1, 0.7, 0.22]],\n  [1, [1, 0.9, 0.55]],\n];\nconst LUT = [];\nfor (let n = 0; n \u003c= 10; n++) {\n  const f = n / 10;\n  let k = 1;\n  while (k \u003c RAMP.length - 1 && RAMP[k][0] \u003c f) k++;\n  const [f0, c0] = RAMP[k - 1], [f1, c1] = RAMP[k], u = cl((f - f0) / (f1 - f0), 0, 1);\n  LUT.push([0, 1, 2].map((i) => c0[i] + (c1[i] - c0[i]) * u));\n}\nconst ramp = (f) => LUT[cl(round(f * 10), 0, 10)];\n\n// Book covers (no dark warm colours: they read brown), and the pages.\nconst COVERS = [[0.2, 0.75, 0.7], [0.55, 0.3, 1], [0.95, 0.85, 0.6], [0.3, 0.9, 0.35], [1, 0.35, 0.55], [0.35, 0.5, 1]];\nconst PAGES = [1, 0.95, 0.82];\n\n// One haunting, in story seconds: quiet, rattling, in the air, the drop,\n// and the hush while the lamp gutters.\nconst QUIET = 1.2, STIR = 1.2, FLY = 5, HUSH = 1.6;\n\nfunction newThing(kind, k) {\n  const book = kind === 0;\n  return {\n    kind, k, x: 0, y: 0, rx: book ? SX0 + 2 + 3.3 * k : 9 + 7.5 * k, ry: book ? SHELF - 4 : TOP - 1,\n    // Where it lies: 0 standing on the shelf, 1 flat on the table or floor.\n    pose: book ? 0 : 1, state: \"rest\", lift: 0, vx: 0, vy: 0, tilt: 0,\n    // Its own loop through the room: frequencies, phases, size.\n    w1: rnd(0.55, 0.85) * (Math.random() \u003c 0.5 ? -1 : 1), w2: rnd(0.9, 1.4), p1: rnd(0, TAU), p2: rnd(0, TAU),\n    ax: rnd(16, 24), ay: rnd(16, 28), cy: book ? rnd(44, 60) : rnd(40, 56), flap: rnd(0, TAU), spin: rnd(0, TAU),\n    col: COVERS[k % COVERS.length],\n  };\n}\n\nexport function setup(params) {\n  const tex = new Float32Array(N);\n  // How much lamplight each surface returns: striped wallpaper, a chair rail,\n  // panelling and floorboards.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let f = 1;\n      if (y \u003c RAIL) f = x % 6 === 0 ? 0.84 : (x + 3) % 6 === 0 && (y >> 2) % 2 ? 0.92 : 1;\n      else if (y \u003c RAIL + 2) f = 1.05;\n      else if (y \u003c BASE) f = x % 11 === 0 || y === RAIL + 3 || y === BASE - 2 ? 0.45 : 0.72;\n      else if (y \u003c BASE + 2) f = 0.4;\n      else f = (y - BASE) % 5 === 0 ? 0.35 : 0.58;\n      tex[y * W + x] = f;\n    }\n  const things = [];\n  for (let k = 0; k \u003c 6; k++) things.push(newThing(0, k));\n  for (let k = 0; k \u003c 4; k++) things.push(newThing(1, k));\n  params.s = {\n    t: 0, hue: 0, speed: 2, fury: 1, lampK: 0.06,\n    phase: \"quiet\", pt: QUIET - 0.6, age: 0,\n    lampA: 0.1, lampP: 0, glow: 1, gutter: 0,\n    pic: 0.06, picV: 0, hands: [0.4, 2.2],\n    chair: { h: 0, tilt: 0, vh: 0, lift: 0 },\n    mist: 0, shake: 0, crashed: false,\n    things, dust: [], tex,\n    E: new Float32Array(N), F: new Float32Array(N * 3), L: new Float32Array(N),\n    lx: HOOK_X, ly: CHAIN,\n  };\n}\n\n// Where a flying thing wants to be at story time a: a loop of its own\n// through the room, wider and faster with Fury.\nfunction path(S, o, a) {\n  const g = 0.75 + 0.12 * S.fury, sz = 0.8 + 0.07 * S.fury;\n  return [\n    cl(32 + o.ax * sz * sin(o.w1 * g * a + o.p1) + 4 * sin(2.3 * o.w2 * g * a), 5, 59),\n    cl(o.cy + o.ay * sz * 0.8 * sin(o.w2 * g * a + o.p2), 8, 100),\n  ];\n}\n\nfunction flying(S) {\n  const f = S.fury;\n  const books = round(0.5 + f), plates = round(0.75 * f + 0.25);\n  return (o) => (o.kind === 0 ? o.k \u003c min(6, books) : o.k \u003c min(4, plates));\n}\n\nfunction startPhase(S, ph) {\n  S.phase = ph;\n  S.pt = 0;\n  if (ph === \"fly\") {\n    const flies = flying(S);\n    let n = 0;\n    for (const o of S.things)\n      if (flies(o)) {\n        o.state = \"lift\";\n        o.lift = -0.18 * n++;\n        o.x = o.rx;\n        o.y = o.ry;\n      }\n  }\n  if (ph === \"drop\") {\n    // Everything lets go at once: each thing keeps the speed it had.\n    for (const o of S.things) {\n      // A thing still waiting its turn to lift stays where it is.\n      if (o.state === \"lift\" && o.lift \u003c= 0) o.state = \"rest\";\n      if (o.state === \"lift\" || o.state === \"fly\") {\n        o.state = \"fall\";\n        const [ax, ay] = path(S, o, S.age), [bx, by] = path(S, o, S.age + 0.05);\n        o.vx = ((bx - ax) / 0.05) * 0.5;\n        o.vy = ((by - ay) / 0.05) * 0.5;\n        o.land = rnd(BASE + 7, 124);\n      }\n    }\n    S.crashed = false;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.fury = cl(k[2], 1, 5);\n  S.lampK = cl(k[3], 0, 1);\n  // Story time: one story second a second at Speed 2.\n  const d = cl(dt || 0, 0, 0.1) * S.speed * 0.5;\n  S.t += d;\n  S.age += d;\n  S.pt += d;\n  if (S.phase === \"quiet\" && S.pt >= QUIET) startPhase(S, \"stir\");\n  else if (S.phase === \"stir\" && S.pt >= STIR) startPhase(S, \"fly\");\n  else if (S.phase === \"fly\" && S.pt >= FLY) startPhase(S, \"drop\");\n  else if (S.phase === \"drop\" && S.things.every((o) => o.state === \"rest\") && S.chair.h \u003c= 0 && S.pt > 0.3) startPhase(S, \"hush\");\n  else if (S.phase === \"hush\" && S.pt >= HUSH) startPhase(S, \"quiet\");\n  const ph = S.phase, active = ph === \"stir\" ? sm(S.pt / STIR) * 0.4 : ph === \"fly\" ? 1 : 0;\n\n  // The lamp: a pendulum whose swing grows while the spirit is about.\n  const target = min(0.78, (0.07 + 0.45 * S.lampK) * (1 + active * (0.4 + 0.15 * S.fury)));\n  S.lampA += (target - S.lampA) * (1 - exp(-d * 1.5));\n  S.lampP += (d * TAU) / 2.2;\n  const th = S.lampA * sin(S.lampP);\n  S.lx = HOOK_X + CHAIN * sin(th);\n  S.ly = CHAIN * cos(th) - 2;\n  // The flame: a steady flicker, guttering after the crash.\n  if (ph === \"hush\") S.gutter = max(S.gutter, 1 - S.pt / HUSH);\n  else S.gutter *= exp(-d * 4);\n  const fl = 0.04 * sin(S.t * 23) + 0.03 * sin(S.t * 37);\n  S.glow = (1 + fl) * (1 - 0.7 * S.gutter * (0.6 + 0.4 * sin(S.t * 41) * sin(S.t * 17)));\n\n  // The picture on its nail: swings while the spirit pushes it, and when the\n  // push stops friction holds it wherever it is, crooked.\n  if (active > 0) {\n    S.picV += d * (-9 * S.pic + 3.5 * active * sin(S.t * 2.6) * (0.6 + 0.12 * S.fury));\n    S.picV *= exp(-d * 0.6);\n  } else S.picV *= exp(-d * 6);\n  S.pic = cl(S.pic + S.picV * d, -0.6, 0.6);\n  // The clock: its hands race backwards while things fly.\n  S.hands[0] += d * (active ? -1.2 * active * (0.6 + 0.2 * S.fury) : 0.01);\n  S.hands[1] += d * (active ? -9 * active * (0.6 + 0.2 * S.fury) : 0.1);\n\n  // The chair rises and tilts while things fly, and drops with them.\n  const C = S.chair;\n  if (ph === \"fly\") {\n    C.lift = min(1, C.lift + d / 0.9);\n    const hgt = (2 + 4.5 * (S.fury - 1)) * (0.75 + 0.25 * sin(S.age * 1.7)) + 1.5 * sin(S.age * 5.1);\n    C.h += (sm(C.lift) * hgt - C.h) * (1 - exp(-d * 6));\n    C.tilt = sm(C.lift) * (0.12 + 0.05 * S.fury) * sin(S.age * 1.3 + 0.5) + 0.04 * sin(S.age * 6.7);\n  } else if (C.h > 0 || C.vh) {\n    C.vh += d * 300;\n    C.h -= C.vh * d;\n    C.tilt *= exp(-d * 5);\n    if (C.h \u003c= 0) {\n      // A bounce, then it stands.\n      C.vh = C.vh > 40 ? -C.vh * 0.3 : 0;\n      C.h = 0;\n      if (C.vh === 0) C.lift = 0;\n      dustAt(S, CHX, 121, 6);\n    }\n  } else C.tilt *= exp(-d * 5);\n  if (ph === \"stir\") C.tilt = 0.03 * active * sin(S.t * 31);\n\n  // The flying things.\n  for (const o of S.things) {\n    if (o.state === \"lift\" || o.state === \"fly\") {\n      o.lift += d / 0.8;\n      if (o.lift \u003c 0) continue;\n      o.state = o.lift >= 1 ? \"fly\" : \"lift\";\n      const [px, py] = path(S, o, S.age), e = sm(o.lift);\n      const nx = o.rx + (px - o.rx) * e, ny = o.ry - 5 * sin(PI * e) + (py - o.ry) * e;\n      o.tilt = cl((nx - o.x) / max(d, 1e-3) / 60, -0.5, 0.5);\n      o.x = nx;\n      o.y = ny;\n      o.flap += d * (o.kind === 0 ? 13 : 0);\n      o.spin += d * (o.kind === 1 ? 9 + S.fury : 0);\n      if (e > 0.2) deposit(S, o.x, o.y + (o.kind === 0 ? 0 : 0.5), 0.85, 2);\n    } else if (o.state === \"fall\") {\n      o.vy += d * 320;\n      o.x = cl(o.x + o.vx * d, 4, 60);\n      // It lands on the table if it comes down onto it, or else on the floor.\n      if (o.y \u003c TOP - 1 && o.y + o.vy * d >= TOP - 1 && o.x > TX0 + 2 && o.x \u003c TX1 - 2) o.land = TOP - 1;\n      o.y += o.vy * d;\n      o.spin += d * 6;\n      if (o.y >= o.land) {\n        o.y = o.land;\n        o.state = \"rest\";\n        o.rx = o.x;\n        o.ry = o.y;\n        o.pose = 1;\n        o.flap = 0;\n        dustAt(S, o.x, o.y, o.kind === 1 ? 7 : 5);\n        if (!S.crashed) {\n          S.crashed = true;\n          S.shake = 0.45;\n        }\n      }\n    }\n  }\n  S.shake = max(0, S.shake - d);\n  S.mist += ((ph === \"fly\" || ph === \"drop\" ? 1 : ph === \"stir\" ? sm(S.pt / STIR) : 0) - S.mist) * (1 - exp(-d * 1.2));\n\n  // The spirit itself is never seen, only the faint trail it leaves as it\n  // drifts round the room, brighter while it stirs things up.\n  const wx = 32 + 22 * sin(S.t * 0.83) + 6 * sin(S.t * 2.1), wy = 58 + 34 * sin(S.t * 0.57 + 1) + 5 * cos(S.t * 1.9);\n  deposit(S, wx, wy, ph === \"quiet\" || ph === \"hush\" ? 0.45 : 0.75, 2.2);\n  const fade = exp(-d * 1.7);\n  for (let i = 0; i \u003c N; i++) S.E[i] *= fade;\n\n  for (const p of S.dust) {\n    p.x += p.vx * d;\n    p.y += p.vy * d;\n    p.vx *= exp(-d * 2);\n    p.vy = p.vy * exp(-d * 2) - d * 2;\n    p.life -= d / p.span;\n  }\n  S.dust = S.dust.filter((p) => p.life > 0);\n}\n\nfunction deposit(S, x, y, v, r = 1.6) {\n  const x0 = round(x), y0 = round(y), R = Math.ceil(r);\n  for (let j = -R; j \u003c= R; j++)\n    for (let i = -R; i \u003c= R; i++) {\n      const xx = x0 + i, yy = y0 + j, dd = sqrt(i * i + j * j);\n      if (xx \u003c 0 || xx >= W || yy \u003c 0 || yy >= H || dd > r + 0.4) continue;\n      const n = yy * W + xx;\n      S.E[n] = max(S.E[n], v * (dd > r - 0.6 ? 0.55 : 1));\n    }\n}\n\nfunction dustAt(S, x, y, n) {\n  for (let k = 0; k \u003c n; k++) S.dust.push({ x: x + rnd(-3, 3), y: y - rnd(0, 2), vx: rnd(-14, 14), vy: rnd(-16, -4), life: 1, span: rnd(0.7, 1.4) });\n}\n\n// Painting into the frame buffer.\nfunction put(S, x, y, c, a = 1) {\n  x = round(x);\n  y = round(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const n = (y * W + x) * 3;\n  S.F[n] += (c[0] - S.F[n]) * a;\n  S.F[n + 1] += (c[1] - S.F[n + 1]) * a;\n  S.F[n + 2] += (c[2] - S.F[n + 2]) * a;\n}\n// An object's colour in the lamplight where it stands.\nfunction lit(S, c, x, y, lo = 0.3) {\n  const f = S.L[cl(round(y), 0, H - 1) * W + cl(round(x), 0, W - 1)], v = lo + (1.15 - lo) * f;\n  return [min(1, c[0] * v), min(1, c[1] * v), min(1, c[2] * v)];\n}\n// A thick segment: every LED within r of the line from a to b.\nfunction seg(S, ax, ay, bx, by, r, c) {\n  const x0 = floor(min(ax, bx) - r), x1 = Math.ceil(max(ax, bx) + r), y0 = floor(min(ay, by) - r), y1 = Math.ceil(max(ay, by) + r);\n  const dx = bx - ax, dy = by - ay, ll = dx * dx + dy * dy || 1;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const u = cl(((x - ax) * dx + (y - ay) * dy) / ll, 0, 1), ex = ax + dx * u - x, ey = ay + dy * u - y;\n      if (ex * ex + ey * ey \u003c= r * r) put(S, x, y, c);\n    }\n}\n// A box in a frame turned by angle a about (ox, oy): local x from x0 to x1,\n// local y from y0 to y1.\nfunction box(S, ox, oy, a, x0, y0, x1, y1, c) {\n  const ca = cos(a), sa = sin(a);\n  const rad = sqrt(max(x0 * x0, x1 * x1) + max(y0 * y0, y1 * y1)) + 1;\n  for (let y = floor(oy - rad); y \u003c= oy + rad; y++)\n    for (let x = floor(ox - rad); x \u003c= ox + rad; x++) {\n      const dx = x - ox, dy = y - oy, u = dx * ca + dy * sa, v = -dx * sa + dy * ca;\n      if (u >= x0 - 0.5 && u \u003c= x1 + 0.5 && v >= y0 - 0.5 && v \u003c= y1 + 0.5) put(S, x, y, typeof c === \"function\" ? c(u, v, x, y) : c);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const F = S.F, L = S.L, lx = S.lx, ly = S.ly - 1, g = S.glow;\n  // The room in the lamplight.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - lx, dy = (y - ly) * 0.85, n = y * W + x;\n      const f = (g * 1.1) / (1 + (dx * dx + dy * dy) / 380);\n      L[n] = f;\n      const c = ramp(f * S.tex[n]);\n      F[n * 3] = c[0];\n      F[n * 3 + 1] = c[1];\n      F[n * 3 + 2] = c[2];\n    }\n  const DARK = [0.03, 0.008, 0.05];\n\n  // The picture: a gilt frame round a dim portrait, hanging on a nail.\n  const pc = cos(S.pic), ps = sin(S.pic), cord = lit(S, [0.6, 0.5, 0.4], NAIL_X, NAIL_Y);\n  for (const u of [-6, 6]) seg(S, NAIL_X, NAIL_Y, NAIL_X + u * pc - 4 * ps, NAIL_Y + u * ps + 4 * pc, 0.45, cord);\n  const gold = lit(S, [1, 0.72, 0.2], NAIL_X, NAIL_Y + 12, 0.45), canvas = lit(S, [0.16, 0.12, 0.3], NAIL_X, NAIL_Y + 12);\n  const face = lit(S, [0.75, 0.62, 0.7], NAIL_X, NAIL_Y + 12, 0.25);\n  box(S, NAIL_X, NAIL_Y, S.pic, -FW / 2, 3, FW / 2, 3 + FH, (u, v) => {\n    if (abs(u) > FW / 2 - 2 || v \u003c 5 || v > FH + 1) return gold;\n    // The sitter: a pale oval head over dark shoulders.\n    const hu = u / 2.6, hv = (v - 11) / 3.4;\n    if (hu * hu + hv * hv \u003c 1) return face;\n    if (v > 16 && abs(u) \u003c 5 - (v - 16) * -0.4) return DARK;\n    return canvas;\n  });\n\n  // The clock: a pale face with a dark rim and two hands.\n  const cface = lit(S, [0.95, 0.9, 0.75], CLX, CLY, 0.3), rim = lit(S, [0.35, 0.18, 0.45], CLX, CLY, 0.3);\n  for (let y = CLY - CLR; y \u003c= CLY + CLR; y++)\n    for (let x = CLX - CLR; x \u003c= CLX + CLR; x++) {\n      const r = sqrt((x - CLX) ** 2 + (y - CLY) ** 2);\n      if (r \u003c= CLR) put(S, x, y, r > CLR - 1.5 ? rim : cface);\n    }\n  seg(S, CLX, CLY, CLX + 3.5 * sin(S.hands[0]), CLY - 3.5 * cos(S.hands[0]), 0.6, DARK);\n  seg(S, CLX, CLY, CLX + 5.5 * sin(S.hands[1]), CLY - 5.5 * cos(S.hands[1]), 0.5, DARK);\n\n  // The shelf and the table.\n  seg(S, SX0, SHELF, SX1, SHELF, 0.6, lit(S, [0.45, 0.25, 0.55], 51, SHELF));\n  const cloth = lit(S, [0.75, 0.6, 1], 20, TOP + 3, 0.25);\n  for (let y = TOP; y \u003c= TOP + 7; y++)\n    for (let x = TX0; x \u003c= TX1; x++) put(S, x, y, y === TOP || (y === TOP + 7 && (x & 3) === 0) ? lit(S, [1, 0.9, 1], x, y, 0.3) : (x - TX0) % 5 === 2 ? lit(S, [0.55, 0.42, 0.8], x, y, 0.25) : cloth);\n  for (const lxg of [TX0 + 3, TX1 - 3]) seg(S, lxg, TOP + 8, lxg, 121, 0.7, DARK);\n  seg(S, TX0 + 3, 113, TX1 - 3, 113, 0.5, DARK);\n\n  // Ectoplasm: added light in the trail colour, in steps of a twelfth, under\n  // the things that leave it.\n  // It also pools on the floor as a low mist that rolls and thickens while\n  // the spirit is about.\n  const ec = hsv(0.31 + S.hue, 0.85, 1), E = S.E, M = 0.2 + 0.16 * S.mist;\n  for (let x = 0; x \u003c W; x++) {\n    // Its top rolls along in two slow waves going opposite ways.\n    const top = BASE + 2 - 8 * S.mist + 2.5 * sin(x * 0.13 + S.t * 0.7) + 1.5 * sin(x * 0.31 - S.t * 1.1);\n    for (let y = max(0, floor(top)); y \u003c H; y++) {\n      const n = y * W + x;\n      E[n] = max(E[n], cl((y - top) / 22, 0, 1) * M * (0.8 + 0.2 * sin(x * 0.07 - S.t * 0.5 + y * 0.05)));\n    }\n  }\n  for (let n = 0; n \u003c N; n++) {\n    const e = round(E[n] * 12) / 12;\n    if (e \u003c= 0) continue;\n    F[n * 3] = min(1, F[n * 3] * (1 - 0.5 * e) + ec[0] * e);\n    F[n * 3 + 1] = min(1, F[n * 3 + 1] * (1 - 0.5 * e) + ec[1] * e);\n    F[n * 3 + 2] = min(1, F[n * 3 + 2] * (1 - 0.5 * e) + ec[2] * e);\n  }\n  // The chair: a dark shape against the lit wall, with a rim of lamplight.\n  const C = S.chair, cx = CHX, cy = CHY - C.h;\n  const rimC = lit(S, [1, 0.6, 0.3], cx, cy - 12, 0.15);\n  // Seen from the side: the back leg runs on up into the back, the front leg\n  // stops at the seat, so it reads as a chair and not a ladder.\n  const chairCol = (u, v) => (v \u003c -21.5 || (v \u003c -1.2 && u \u003c 3) ? rimC : DARK);\n  const parts = [[-8, -2, 7, 1], [4, -23, 7, 22], [-8, 2, -6, 22], [-6, 13, 4, 14], [3, -12, 7, -10]];\n  for (const [x0, y0, x1, y1] of parts) box(S, cx, cy, C.tilt, x0, y0, x1, y1, chairCol);\n\n  // Books on the shelf stand upright; books on the table or the floor lie\n  // closed; books in the air open into a V and flap like wings.\n  const tremble = S.phase === \"stir\" ? 0.6 * sm(S.pt / STIR) : S.phase === \"fly\" ? 0.4 : 0;\n  for (const o of S.things) {\n    const air = o.state === \"fly\" || o.state === \"fall\" || (o.state === \"lift\" && o.lift > 0);\n    const jx = !air && tremble ? (Math.random() - 0.5) * 2 * tremble : 0, jy = !air && tremble && Math.random() \u003c tremble * 0.5 ? -1 : 0;\n    const x = (air ? o.x : o.rx) + jx, y = (air ? o.y : o.ry) + jy;\n    if (o.kind === 0) {\n      const col = lit(S, o.col, x, y, 0.35), pg = lit(S, PAGES, x, y, 0.4);\n      if (o.state === \"fall\" || (air && o.lift \u003c 0.15)) box(S, x, y, o.spin * 0.5, -3, -1, 3, 0, (u, v) => (v \u003c -0.5 ? col : pg));\n      else if (air) {\n        // Wings: each cover from the spine out to a tip that beats up and down.\n        const beat = 0.85 * sin(o.flap), L5 = 6.5;\n        for (const s of [-1, 1]) {\n          const a = o.tilt * s + beat, tx = x + s * L5 * cos(a), ty = y - L5 * sin(a);\n          seg(S, x, y, tx, ty, 0.9, col);\n          seg(S, x, y - 1, x + s * 3.8 * cos(a), y - 1 - 3.8 * sin(a), 0.45, pg);\n        }\n      } else if (o.pose === 0) box(S, x, y, 0, -1, -3, 0, 3, (u, v) => (v \u003c -2.5 ? pg : col));\n      else box(S, x, y, 0, -3, -1, 3, 0, (u, v) => (v \u003c -0.5 ? col : pg));\n    } else {\n      // A plate: a cream disc with a blue rim, seen flat on the table and\n      // tumbling edge over edge in the air.\n      const a = 3.1, b = air ? 0.6 + 2.5 * abs(sin(o.spin)) : 0.9, rot = air ? 0.4 * sin(o.spin * 0.37) : 0;\n      const cream = lit(S, [1, 0.96, 0.85], x, y, 0.62), blue = lit(S, [0.35, 0.45, 1], x, y, 0.62);\n      const ca = cos(rot), sa = sin(rot);\n      for (let yy = floor(y - 4); yy \u003c= y + 4; yy++)\n        for (let xx = floor(x - 4); xx \u003c= x + 4; xx++) {\n          const dx = xx - x, dy = yy - y, u = (dx * ca + dy * sa) / a, v = (-dx * sa + dy * ca) / b, r = u * u + v * v;\n          if (r \u003c= 1.15) put(S, xx, yy, r > 0.55 ? blue : cream);\n        }\n    }\n  }\n\n  // The lamp: chain, brass cap, the glass chimney with the flame, the oil font.\n  const th = atan2(S.lx - HOOK_X, S.ly + 2);\n  for (let s = 0; s \u003c CHAIN - 6; s += 2) put(S, HOOK_X + s * sin(th), s * cos(th), lit(S, [0.75, 0.6, 0.5], HOOK_X, s, 0.2));\n  // Its iron cap and font are dark against its own pool of light.\n  const iron = [0.1, 0.03, 0.12], edge = [1, 0.6, 0.15], glass = [1, 0.95 * min(1, g), 0.55 * min(1, g)];\n  box(S, S.lx, S.ly, -th, -4, -7, 4, -5, (u, v) => (v > -5.5 ? edge : iron));\n  box(S, S.lx, S.ly, -th, -2, -4, 2, 2, (u, v) => (abs(u) \u003c 1 && v > -2 ? [1, 1, 0.85] : glass));\n  box(S, S.lx, S.ly, -th, -4, 3, 4, 6, (u, v) => (v \u003c 3.5 ? edge : iron));\n\n  for (const p of S.dust) put(S, p.x, p.y, [0.8, 0.72, 0.85], 0.7 * p.life);\n\n  // The crash shakes the whole room for a moment.\n  const sx = S.shake > 0 ? round((Math.random() - 0.5) * 3) : 0, sy = S.shake > 0 ? round((Math.random() - 0.5) * 3) : 0;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const xx = cl(x + sx, 0, W - 1), yy = cl(y + sy, 0, H - 1), n = (yy * W + xx) * 3;\n      display.setPixel(x, y, round(255 * F[n]), round(255 * F[n + 1]), round(255 * F[n + 2]));\n    }\n}\n","polya-orchard":"// ===== Patternflow pattern =====\n// Title:   Pólya's Orchard\n// Family:  space\n// Idea:    Seen from above, a lantern at the centre of a round orchard of trunks on the integer lattice throws a shadow wedge behind every trunk, and as the trunks slowly thicken towards Pólya's threshold 1/R the lines of sight that escape between them narrow into thin rays and go out one by one, the last eight towards the lattice points just outside the orchard, until no ray leaves, then the trunks thin and the starburst comes back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Pólya's orchard problem (George Pólya, 1918), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Trunk=0.45..0.95, Walk=0..1\n//\n// Knob 1: Hue. Turns the lantern light round the colour wheel: aqua at 0, blue at 0.15, violet at 0.3, pink at 0.45, orange at 0.6, yellow at 0.67 and green at 0.83; the escaping rays are a paler tint of it, and the lit faces of the trunks sit about a third of the wheel away (pink when the light is aqua).\n// Knob 2: Speed. How fast the trunks breathe: at 2 one breath, thin to thick and back, takes 8 seconds; at 0.2 it takes 80 seconds and at 3 it takes 5.3.\n// Knob 3: Trunk. The thinnest the trunks get, as a multiple of the threshold radius 1/R; the thickest is always 1.03, just past it. At 0.45 all 32 rays open and then go out in four groups of eight, at 0.69, 0.74, 0.80 and 0.97; at 0.95 only the last eight ever open, as hairlines.\n// Knob 4: Walk. The observer walks a small loop off the lattice point, which breaks the eightfold symmetry so the rays of one group go out one at a time, and sweeps the gaps round. At 0 the observer stands still on the point; at 0.06 the loop is 0.015 of a tree spacing across; at 1 it is a quarter of a spacing and some rays escape past the threshold.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, round, sqrt, sin, cos, atan2, asin, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst q = (v, n) => round(v * n) / n;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), qq = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? qq : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? qq : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? qq : p];\n}\n\n// The orchard: every lattice point within radius R of the origin but the\n// origin itself. R = 4 gives 48 trees and 32 directions in which a thin\n// enough line of sight escapes (between Farey neighbours of the visible\n// points). The lattice spacing in LEDs puts the circle 30 LEDs across each\n// way from the centre, so the orchard fills the panel width and the rows\n// above and below it show only the light that gets out.\nconst R = 4, SP = 7.5, CX = 31.5, CY = 63.5;\nconst gcd = (a, b) => (b ? gcd(b, a % b) : a);\nconst TREES = [];\nfor (let j = -R; j \u003c= R; j++)\n  for (let i = -R; i \u003c= R; i++)\n    if ((i || j) && i * i + j * j \u003c= R * R) TREES.push({ i, j, x: CX + SP * i, y: CY + SP * j, seen: gcd(abs(i), abs(j)) === 1 });\nconst NT = TREES.length;\n// Which tree stands at lattice point (i, j), for the trunk lookup per LED.\nconst AT = new Int16Array((2 * R + 1) * (2 * R + 1)).fill(-1);\nTREES.forEach((T, k) => (AT[(T.j + R) * (2 * R + 1) + T.i + R] = k));\n// The thickest the trunks get, as a multiple of 1/R: a little past Pólya's\n// bound, so at the top of every breath the orchard is closed in every direction.\nconst TOP = 1.03;\n// Shadows are found per LED through a table of angle bins: each bin lists\n// the trees whose shadow wedge (padded by an LED's angular size) reaches it.\nconst NB = 720;\n\nexport function setup(params) {\n  const bins = [];\n  for (let b = 0; b \u003c NB; b++) bins.push([]);\n  params.s = {\n    t: 0, hue: 0, speed: 2, thin: 0.45, walk: 0.06, rR: 0.3, ox: CX, oy: CY,\n    bins, ta: new Float32Array(NT), td: new Float32Array(NT), tw: new Float32Array(NT), lit: new Float32Array(NT),\n    lo: new Float32Array(64), hi: new Float32Array(64),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.thin = cl(k[2], 0.45, 0.95);\n  S.walk = cl(k[3], 0, 1);\n  S.t += d * S.speed;\n  // One breath is 16 story seconds (8 s at Speed 2). It starts thin, so the\n  // picture opens on the full starburst, and runs at an even pace through\n  // the middle, where the rays narrow and go out, easing only at its ends.\n  const p = (S.t / 16) % 1, tri = 1 - abs(2 * p - 1);\n  S.rR = S.thin + (TOP - S.thin) * (0.5 * tri + 0.5 * tri * tri * (3 - 2 * tri));\n  // The walk: a small loop round the lattice point, two lobes so it never\n  // repeats the breath. A quarter of a spacing across at Walk 1.\n  const w = S.walk * 0.125 * SP, u = (TAU * S.t) / 11.3;\n  S.ox = CX + w * cos(u) + 0.35 * w * sin(2 * u);\n  S.oy = CY + w * sin(u);\n}\n\n// Length of the union of the intervals [lo[i], hi[i]], i \u003c n (already clipped\n// to the LED's window). n is small, so an insertion sort is the cheap way.\nfunction union(lo, hi, n) {\n  for (let i = 1; i \u003c n; i++) {\n    const a = lo[i], bb = hi[i];\n    let j = i - 1;\n    while (j >= 0 && lo[j] > a) {\n      lo[j + 1] = lo[j];\n      hi[j + 1] = hi[j];\n      j--;\n    }\n    lo[j + 1] = a;\n    hi[j + 1] = bb;\n  }\n  let sum = 0, a = lo[0], e = hi[0];\n  for (let i = 1; i \u003c n; i++) {\n    if (lo[i] > e) {\n      sum += e - a;\n      a = lo[i];\n      e = hi[i];\n    } else if (hi[i] > e) e = hi[i];\n  }\n  return sum + e - a;\n}\n\nconst wrap = (a) => (a > PI ? a - TAU : a \u003c -PI ? a + TAU : a);\n\n// The share of the angular window [phi - hw, phi + hw] that the shadows of\n// the trees nearer than rho leave in the light. Exact for the wedges, so a\n// ray narrower than an LED dims in proportion instead of flickering.\nfunction lightAt(S, phi, hw, rho, skip) {\n  const list = S.bins[min(NB - 1, floor(((phi + PI) / TAU) * NB))];\n  let n = 0;\n  for (let m = 0; m \u003c list.length; m++) {\n    const k = list[m];\n    if (k === skip || S.td[k] >= rho) continue;\n    const rel = wrap(S.ta[k] - phi), w = S.tw[k];\n    const lo = max(-hw, rel - w), hi = min(hw, rel + w);\n    if (lo \u003c hi) {\n      S.lo[n] = lo;\n      S.hi[n] = hi;\n      n++;\n    }\n  }\n  return n ? max(0, 1 - union(S.lo, S.hi, n) / (2 * hw)) : 1;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rr = (S.rR / R) * SP, ox = S.ox, oy = S.oy;\n  // Each tree's direction, distance and the half angle of its shadow wedge,\n  // then the bins its padded wedge covers.\n  for (const list of S.bins) list.length = 0;\n  for (let k = 0; k \u003c NT; k++) {\n    const T = TREES[k], dx = T.x - ox, dy = T.y - oy, dd = sqrt(dx * dx + dy * dy);\n    S.ta[k] = atan2(dy, dx);\n    S.td[k] = dd;\n    S.tw[k] = asin(min(1, rr / dd));\n    const pad = S.tw[k] + 0.6 / max(1, dd - rr);\n    const b0 = floor(((S.ta[k] - pad + PI) / TAU) * NB), b1 = floor(((S.ta[k] + pad + PI) / TAU) * NB);\n    for (let b = b0; b \u003c= b1; b++) S.bins[((b % NB) + NB) % NB].push(k);\n  }\n  // How much of each trunk's near face the lantern reaches: the visible trees\n  // are the ones with coprime coordinates, Euclid's orchard.\n  for (let k = 0; k \u003c NT; k++) S.lit[k] = lightAt(S, S.ta[k], max(0.004, S.tw[k] * 0.8), S.td[k] - 0.01, k);\n\n  const h = 0.5 + S.hue;\n  const LAMP = hsv(h, 0.72, 1), RAY = hsv(h + 0.05, 0.36, 1), FACE = hsv(h + 0.36, 0.55, 1);\n  const SHADE = [0.035, 0.02, 0.075], CORE = [0.16, 0.1, 0.3], RIM = [0.01, 0, 0.02];\n  const RING = (R + 0.5) * SP;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const dx = x - ox, dy = y - oy, rho = sqrt(dx * dx + dy * dy);\n      const cx = x - CX, cy = y - CY, rc = sqrt(cx * cx + cy * cy);\n      let r, g, b;\n      if (rho \u003c 2.2) {\n        // The lantern: a white core in a small halo of its own light.\n        const v = rho \u003c 1.1 ? 1 : 0.55;\n        r = v + (1 - v) * LAMP[0];\n        g = v + (1 - v) * LAMP[1];\n        b = v + (1 - v) * LAMP[2];\n      } else {\n        const phi = atan2(dy, dx), hw = min(0.4, 0.55 / rho);\n        const L = lightAt(S, phi, hw, rho, -1);\n        // The light fades with distance in steps, gently, so a ray reads as\n        // one line from the lantern to the panel's edge; past the circle the\n        // escaping light turns a paler tint.\n        const out = cl((rc - RING + 1.5) / 3, 0, 1);\n        const fall = q(1 - 0.0065 * rho, 20);\n        const col = out ? RAY : LAMP, v = L * fall;\n        r = SHADE[0] + (col[0] - SHADE[0]) * v;\n        g = SHADE[1] + (col[1] - SHADE[1]) * v;\n        b = SHADE[2] + (col[2] - SHADE[2]) * v;\n        // The edge of the orchard, a faint dotted circle where it runs in shadow.\n        if (abs(rc - RING) \u003c 0.5 && ((x + y) & 1) === 0 && v \u003c 0.2) (r = CORE[0] * 1.3), (g = CORE[1] * 1.3), (b = CORE[2] * 1.3);\n      }\n      // A trunk on this LED: the nearest lattice point within the orchard.\n      const ti = round(cx / SP), tj = round(cy / SP);\n      if ((ti || tj) && ti * ti + tj * tj \u003c= R * R) {\n        const tx = cx - SP * ti, ty = cy - SP * tj, dt = sqrt(tx * tx + ty * ty);\n        const cov = cl(rr + 0.5 - dt, 0, 1);\n        if (cov > 0) {\n          const k = AT[(tj + R) * (2 * R + 1) + ti + R];\n          // The face turned to the lantern catches its light, if the lantern\n          // reaches the trunk; the rest of the disk is a dark rim.\n          const fx = ox - (CX + SP * ti), fy = oy - (CY + SP * tj), fd = sqrt(fx * fx + fy * fy) || 1;\n          const facing = dt \u003c 0.01 ? 1 : (tx * fx + ty * fy) / (dt * fd);\n          const inner = cl(rr - 0.35 - dt, 0, 1);\n          const lit = S.lit[k] * cl(0.45 + facing, 0, 1);\n          const cr = RIM[0] + (CORE[0] + (FACE[0] - CORE[0]) * lit - RIM[0]) * inner;\n          const cg = RIM[1] + (CORE[1] + (FACE[1] - CORE[1]) * lit - RIM[1]) * inner;\n          const cb = RIM[2] + (CORE[2] + (FACE[2] - CORE[2]) * lit - RIM[2]) * inner;\n          r += (cr - r) * cov;\n          g += (cg - g) * cov;\n          b += (cb - b) * cov;\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  }\n}\n","rotor-router":"// ===== Patternflow pattern =====\n// Title:   Rotor-Router\n// Family:  sim\n// Idea:    Chips leave by turns from two sources on the centre column and walk by the arrow at every lit LED, each arrow turning a quarter turn before a chip leaves along it, and each chip stops on the first dark LED it reaches, so the lit set grows into a tall peanut with a smooth rim and a filling waist while the arrows inside, one colour for each direction, set into a lace of triangles and diagonals; when the shape reaches the sides it holds, dissolves from the rim inward and grows again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: rotor-router walk, the Eulerian walkers of Vyatcheslav Priezzhev, Deepak Dhar, Abhishek Dhar and Supriya Krishnamurthy (1996), with the disk and smash sum of Lionel Levine and Yuval Peres (2009), pattern round 45\n// Round:   45\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Join=0..1, Random=0..1\n//\n// Knob 1: Hue. Turns the four arrow colours round the wheel together: at 0 north is cream, east teal, south deep purple and west pink; at 0.5 east is crimson, south dark green and west aqua. North stays a pale tint.\n// Knob 2: Speed. Arrow steps a frame, which grow with the shape so its area grows at a steady rate: at 2 the peanut of about 5,500 LEDs grows in 4.2 seconds, holds 1.3, dissolves in 1 and starts again 0.3 later; at 3 it grows in 2.8 seconds, at 0.2 in 42.\n// Knob 3: Join. Slides the two sources together along the centre column: at 0 they sit on rows 40 and 87 and grow two disks that meet and fill in the waist; at 0.5 on rows 52 and 75 and the shape is an oval; at 1 on rows 64 and 63, side by side, and the chips grow one disk of about 2,800 LEDs, 60 across.\n// Knob 4: Random. The chance that a step ignores its arrow and goes a random way, which then becomes the arrow, is the square of the knob: one step in 280 at 0.06, one in 16 at 0.25, every step at 1. At 1 the walk is internal DLA, the rim turns ragged and the lace inside turns to noise.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// Arrow directions N, E, S, W as steps on the LED index.\nconst STEP = [-W, 1, W, -1];\n// The four arrow colours: hue at Hue 0, saturation, value. One pale, two\n// strong and one dark: four hues alone at one brightness read as confetti on\n// a 64 LED wide disk, and the brightness steps are what bring out the\n// triangles and diagonals of the arrows.\nconst ARROW = [\n  [0.1, 0.12, 1],\n  [0.47, 1, 0.8],\n  [0.8, 1, 0.6],\n  [0.93, 0.65, 1],\n];\n// The sources sit on the centre column, mirrored about the middle of the\n// panel; how far each one sits from the middle at Join 0.\nconst SX = 32, HALF = 24;\n// How long the shape holds once it reaches a side, how long it takes to\n// dissolve, and the dark pause before it grows again, in seconds at Speed 2.\nconst HOLD = 1.3, MELT = 1, PAUSE = 0.3;\n// Steps a frame at Speed 1: A plus B for every lit LED. A chip's walk from\n// a source to the rim takes about a sixth as many steps as there are lit\n// LEDs, so this lets through about 20 chips a frame at any size and the area\n// grows at a steady rate instead of slowing down as the shape gets big.\nconst A = 500, B = 3.4;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, join: 0, rand: 0.0036,\n    occ: new Uint8Array(N), rot: new Uint8Array(N), born: new Float32Array(N), key: new Float32Array(N),\n    lit: 0, t0: 0, grown: 0, chip: -1, next: 0, src: [0, 0], gap: -1,\n    phase: 0, clock: 0, cycle: 0, turn: 1,\n    pal: null, palHue: NaN,\n  };\n  for (let i = 0; i \u003c N; i++) params.s.key[i] = Math.random();\n}\n\n// Clear the lattice and set the arrows. The top half starts with every arrow\n// one way and turns clockwise; the bottom half is its mirror image, its\n// arrows reflected and turning the other way, so the two lobes come up as\n// mirror images of each other. Each round starts from another direction and\n// every fourth round swaps the turning, so the lace comes up new each time.\nfunction start(S) {\n  S.cycle++;\n  const d0 = S.cycle & 3;\n  S.turn = (S.cycle >> 2) & 1 ? 3 : 1;\n  S.occ.fill(0);\n  S.rot.fill(d0, 0, N / 2);\n  S.rot.fill((2 - d0) & 3, N / 2);\n  S.lit = 0;\n  S.chip = -1;\n  S.next = 0;\n  S.gap = round(HALF * (1 - S.join));\n  S.src = [(64 - S.gap) * W + SX, (63 + S.gap) * W + SX];\n  S.phase = 0;\n  S.clock = 0;\n  S.t0 = S.t;\n}\n\n// Run up to `budget` steps of the walk. A chip on a lit LED turns that LED's\n// arrow a quarter turn and steps where it now points; a chip on a dark LED\n// stops and lights it, and the next chip leaves from the other source. The\n// growth stops once a chip lights an LED one in from any side.\nfunction walk(S, budget) {\n  const occ = S.occ, rot = S.rot, p = S.rand, top = S.turn, bottom = 4 - S.turn, half = N / 2;\n  let chip = S.chip;\n  while (budget > 0) {\n    if (chip \u003c 0) {\n      chip = S.src[S.next];\n      S.next ^= 1;\n    }\n    if (!occ[chip]) {\n      occ[chip] = 1;\n      S.born[chip] = S.t;\n      S.lit++;\n      const x = chip % W, y = (chip / W) | 0;\n      chip = -1;\n      if (x \u003c= 1 || x >= W - 2 || y \u003c= 1 || y >= H - 2) {\n        S.phase = 1;\n        S.clock = 0;\n        S.grown = S.t;\n        break;\n      }\n      continue;\n    }\n    let d;\n    if (p > 0 && Math.random() \u003c p) d = (Math.random() * 4) | 0;\n    else d = (rot[chip] + (chip \u003c half ? top : bottom)) & 3;\n    rot[chip] = d;\n    chip += STEP[d];\n    budget--;\n  }\n  S.chip = chip;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.join = cl(k[2], 0, 1);\n  const r = cl(k[3], 0, 1);\n  S.rand = r * r;\n  S.t += d;\n  if (S.cycle === 0) start(S);\n  // Moving the sources by two LEDs or more sends the shape off to dissolve,\n  // and the next one grows from the new places.\n  if (S.phase \u003c 2 && abs(round(HALF * (1 - S.join)) - S.gap) >= 2) {\n    S.phase = 2;\n    S.clock = 0;\n    S.grown = S.t;\n  }\n  S.clock += (d * S.speed) / 2;\n  if (S.phase === 0) walk(S, round(S.speed * (A + B * S.lit)));\n  else if (S.phase === 1 && S.clock >= HOLD) (S.phase = 2), (S.clock = 0);\n  else if (S.phase === 2 && S.clock >= MELT + PAUSE) start(S);\n}\n\nfunction palette(S) {\n  S.pal = ARROW.map(([h0, s, v]) => {\n    const h = h0 + S.hue - floor(h0 + S.hue);\n    // A dark orange reads brown on LEDs, so a colour near orange is lifted\n    // toward full brightness.\n    const warm = max(0, 1 - abs(h - 0.08) / 0.1);\n    return hsv(h, s, v + (1 - v) * warm);\n  });\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.cycle) return;\n  if (S.palHue !== S.hue) palette(S);\n  const pal = S.pal, occ = S.occ, rot = S.rot, born = S.born, key = S.key, t = S.t;\n  // While it dissolves the rim goes first: an LED goes dark when its share of\n  // the way from the first lit to the last lit, roughened by a fixed random\n  // key, passes the melt.\n  const melt = S.phase === 2 ? min(1, S.clock / MELT) : -1;\n  const t0 = S.t0, span = max(0.01, S.grown - t0), fade = S.speed;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const i = y * W + x;\n      if (!occ[i]) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      if (melt >= 0 && 0.65 * cl((born[i] - t0) / span, 0, 1) + 0.35 * key[i] > 1 - melt) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const c = pal[rot[i]];\n      // LEDs lit in the last half second (at Speed 2) are lifted toward\n      // white, so the growing rim reads as a bright edge.\n      const fresh = cl(1 - (t - born[i]) * fade, 0, 1) * 0.5;\n      display.setPixel(x, y, round(255 * (c[0] + (1 - c[0]) * fresh)), round(255 * (c[1] + (1 - c[1]) * fresh)), round(255 * (c[2] + (1 - c[2]) * fresh)));\n    }\n  // The sources, white.\n  for (const s of S.src) if (occ[s] && melt \u003c 0) display.setPixel(s % W, (s / W) | 0, 255, 255, 255);\n}\n","ballistic-annihilation":"// ===== Patternflow pattern =====\n// Title:   Ballistic Annihilation\n// Family:  particle\n// Idea:    A gun at the foot of the panel fires one bullet a beat straight up at one of three speeds, and the panel is their space-time diagram, the gun's present at the right edge and the past scrolling left, so each bullet is a straight rising line of its speed's slope that ends in a spark where a faster bullet catches a slower one and both vanish.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: ballistic annihilation (Yves Elskens and Harry Frisch, 1985); with three speeds the middle ones survive exactly when their share is over 1/4 (Droz, Rey, Frachebourg and Piasecki, 1995; proved by Haslegrave, Sidoravicius and Tournier, 2018)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Middle=-1..1, Spread=-1..1\n//\n// Knob 1: Hue. Turns the three bullet colours round the wheel together. At 0 slow bullets are magenta, middle ones gold and fast ones cyan; at 0.33 slow lime, middle aqua and fast purple.\n// Knob 2: Speed. Columns of time a second. At 2 the diagram scrolls 8 columns a second, the gun fires twice a second and a middle bullet climbs the 128 rows in 8 s; at 0.2 ten times slower, at 3 half as fast again.\n// Knob 3: Middle. The share p of middle-speed bullets, p = 0.25 + 0.15 x knob, from 0.10 at -1 to 0.40 at 1, the rest split evenly between slow and fast. It opens at 0, the critical 1/4: above it a middle bullet outlives every collision with positive probability, at or below it every middle bullet is caught in the end. On the panel 14% of the middle bullets reach the top at -1, 22% at 0 and 33% at 1.\n// Knob 4: Spread. How far the slow and fast speeds sit from the middle one, which climbs 2 rows a column. Their paces (columns a row) sit symmetric round the middle's, 1/2 x (1 +- r) with r = 0.35 + 0.25 x knob. At -1 r is 0.1, the speeds 1.82, 2 and 2.22 rows a column, the lines nearly parallel and a third of the bullets reach the top; at 0.06 the speeds are 1.47, 2 and 3.15 and a fifth reach it; at 1 they are 1.25, 2 and 5, the first meetings come 7 rows over the gun and one bullet in seven reaches the top. The spread changes where bullets meet, never which ones meet.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Time runs in columns of the diagram. The gun fires every BEAT columns on\n// average; each gap is drawn from 0.9 to 1.1 of it, so no three bullets ever\n// meet at one point and the threshold stays the one for any spacing.\nconst BEAT = 4, WOB = 0.2;\n// The middle speed in rows a column: a middle bullet crosses the 128 rows\n// while the diagram scrolls its 64 columns, so a survivor runs corner to\n// corner.\nconst VM = 2;\n// Columns a second at Speed 1.\nconst RATE = 4;\n// Slow, middle and fast on the wheel at Hue 0: magenta, gold, cyan.\nconst HUES = [0.9, 0.135, 0.52];\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: 0, speed: 2, p: 0.25, r: 0.365,\n    now: 0, next: 0, top: H + 2, keep: true,\n    live: [], done: [], sparks: [], shot: [0, 0, 0], out: [0, 0, 0], muzzle: 0, mk: 1,\n    pal: [new Float32Array(3), new Float32Array(3), new Float32Array(3)],\n    tip: [new Float32Array(3), new Float32Array(3), new Float32Array(3)],\n    rgb: new Uint8Array(W * H * 3),\n  };\n}\n\n// Speed of class k (0 slow, 1 middle, 2 fast) in rows a column. The paces,\n// not the speeds, sit symmetric round the middle: swap time and height in\n// the diagram and the gun's bullets become particles spaced along a line at\n// relative speeds -r, 0 and +r, the three-speed problem the 1/4 belongs to.\nconst speedOf = (k, r) => VM / (1 + r * (1 - k));\n\nfunction fire(S, t) {\n  const u = Math.random(), q = (1 - S.p) / 2;\n  const k = u \u003c q ? 0 : u \u003c q + S.p ? 1 : 2;\n  S.live.push({ t0: t, v: speedOf(k, S.r), k, t1: 0 });\n  S.shot[k]++;\n  S.muzzle = t;\n  S.mk = k;\n  S.next = t + BEAT * (1 + WOB * (Math.random() - 0.5));\n}\n\n// Run the gun and its bullets on to time t1. The live bullets sit in firing\n// order, which is also height order, oldest and highest first: two bullets\n// cannot pass without meeting. So the next event is a shot, the oldest\n// bullet leaving over the top, or the earliest meeting of two neighbours in\n// the list, a newer bullet faster than the one above it. Each is taken at\n// its exact time; a meeting removes both and makes their outer neighbours\n// the new pair.\nfunction advance(S, t1) {\n  const L = S.live;\n  for (;;) {\n    let tc = Infinity, at = -1;\n    for (let i = 0; i + 1 \u003c L.length; i++) {\n      const a = L[i], b = L[i + 1];\n      if (b.v \u003c= a.v) continue;\n      const t = (b.v * b.t0 - a.v * a.t0) / (b.v - a.v);\n      if (t \u003c tc) (tc = t), (at = i);\n    }\n    const te = L.length ? L[0].t0 + S.top / L[0].v : Infinity;\n    const t = min(tc, te, S.next);\n    if (t > t1) break;\n    if (t === S.next) fire(S, t);\n    else if (t === tc) {\n      const a = L[at], b = L[at + 1], h = a.v * (t - a.t0);\n      a.t1 = b.t1 = t;\n      L.splice(at, 2);\n      if (S.keep) {\n        S.done.push(a, b);\n        S.sparks.push({ t, h });\n      }\n    } else {\n      const a = L.shift();\n      a.t1 = t;\n      S.out[a.k]++;\n      if (S.keep) S.done.push(a);\n    }\n  }\n  S.now = t1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.p = 0.25 + 0.15 * cl(k[2], -1, 1);\n  S.r = 0.35 + 0.25 * cl(k[3], -1, 1);\n  // The first frame already shows a full diagram: the gun has been firing\n  // for as long as the slowest bullet takes to clear the panel's 64 columns.\n  if (!S.begun) {\n    S.begun = true;\n    fire(S, 0);\n    advance(S, W + H / speedOf(0, S.r) + 8);\n  }\n  advance(S, S.now + cl(dt || 0, 0, 0.1) * S.speed * RATE);\n  // Forget lines and sparks that have scrolled off the left edge.\n  const left = floor(S.now) - W - 2;\n  if (S.done.length > 400 || S.sparks.length > 200 || (S.done.length && S.done[0].t1 \u003c left)) {\n    S.done = S.done.filter((b) => b.t1 >= left);\n    S.sparks = S.sparks.filter((s) => s.t >= left - 3);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const { rgb, pal, tip } = S;\n  rgb.fill(0);\n  for (let k = 0; k \u003c 3; k++) {\n    hsv(HUES[k] + S.hue, k === 1 ? 0.88 : 0.82, 1, pal[k]);\n    hsv(HUES[k] + S.hue, 0.3, 1, tip[k]);\n  }\n  const put = (x, y, c, a) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = (y * W + x) * 3;\n    rgb[o] = round(c[0] * a * 255);\n    rgb[o + 1] = round(c[1] * a * 255);\n    rgb[o + 2] = round(c[2] * a * 255);\n  };\n  // Time T sits in column T + off: the diagram moves a whole column at a\n  // time, and the heads grow smoothly up the right edge.\n  const nq = floor(S.now), off = W - 1 - nq;\n  const line = (b, live) => {\n    const end = live ? S.now : b.t1, top = min(H - 1, floor(b.v * (end - b.t0)));\n    const c = pal[b.k];\n    for (let h = 0; h \u003c= top; h++) {\n      let x = round(b.t0 + h / b.v + off);\n      if (x > W - 1) x = W - 1;\n      if (x \u003c 0) continue;\n      const y = H - 1 - h, head = live && h > top - 3;\n      put(x - 1, y, head ? tip[b.k] : c, 1);\n      put(x, y, head ? tip[b.k] : c, 1);\n    }\n  };\n  // Middle bullets last, over the others: they are the ones the question is\n  // about.\n  for (const k of [0, 2, 1]) {\n    for (const b of S.done) if (b.k === k && b.t1 + off >= -1) line(b, false);\n    for (const b of S.live) if (b.k === k) line(b, true);\n  }\n  // Sparks: a burst for the first three columns, then a small white cross\n  // that stays on the diagram where the two lines end.\n  const white = [1, 0.97, 0.88], hot = [1, 0.75, 0.35];\n  for (const s of S.sparks) {\n    const x = round(s.t + off) - 1, y = H - 1 - round(s.h), age = S.now - s.t;\n    if (x \u003c -4) continue;\n    if (age \u003c 3) {\n      const r = 1 + floor(age);\n      for (let d = -r - 1; d \u003c= r + 1; d++) {\n        put(x + d, y, hot, 1);\n        put(x, y + d, hot, 1);\n      }\n      for (let d = -r; d \u003c= r; d++) {\n        put(x + d, y + d, hot, 0.8);\n        put(x + d, y - d, hot, 0.8);\n      }\n    }\n    for (let d = -2; d \u003c= 2; d++) {\n      put(x + d, y, white, 1);\n      put(x, y + d, white, 1);\n    }\n  }\n  // The gun's muzzle flash at the foot of the right edge.\n  const m = S.now - S.muzzle;\n  if (m \u003c 1.2) {\n    const a = 1 - m / 1.2;\n    for (let y = H - 3; y \u003c H; y++) for (let x = W - 3; x \u003c W; x++) put(x, y, tip[S.mk], a);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o], rgb[o + 1], rgb[o + 2]);\n}\n","black-cat":"// ===== Patternflow pattern =====\n// Title:   Black Cat\n// Family:  halloween\n// Idea:    A big black cat sits in profile on a garden wall against a low harvest moon beside a jack-o'-lantern, swishing its tail in slow S-curves, twitching its ears and following the bats round the moon with glowing eyes, and now and then it arches its back, fur on end and mouth open in a hiss, before it settles again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Mood=0..1, Startle=0..1\n//\n// Knob 1: Hue. The moon and the light it throws round the cat's edges and whiskers, with the eyes in the colour opposite; the jack-o'-lantern stays candle orange. At 0 a harvest orange moon and toxic green eyes; at 0.25 a green moon and blue eyes, at 0.5 a cold blue moon and magenta eyes, at 0.75 a magenta moon and orange eyes.\n// Knob 2: Speed. The cat's clock. At 2 a wave runs down the tail every 2.6 seconds while the whole curl sways once in 5.2, the tail snaps upright every 1.6 to 3.2 seconds, the cat blinks every 2 to 5 seconds and the bats flap 4.5 times a second; at 0.2 everything is ten times slower, at 3 half as fast again.\n// Knob 3: Mood. At 0 the cat is watchful: the wave on its tail bends each joint 0.3 rad, the ears stand up, the pupils are wide. At 1 it is furious: the wave runs 1.7 times as fast and bends 0.52 rad, the tail snaps up 2.4 times as often, the cat leans 0.12 rad forward over its paws, its ears are laid back, its eyes narrow to slits and the fur along its back stands up.\n// Knob 4: Startle. How often it arches and hisses: up in 0.35 s, held 1.6 s, down in 1.2 s. At 0.06 the first arch comes at 3.1 s and the next 11.5 s after the last has settled; at 1 the first comes at 0.5 s and the next 3 s after.\n// Buttons: K4 tap startles it into an arch at once.\n\nconst W = 64, H = 128, N = W * H, WALL = 102;\nconst { floor, round, min, max, abs, sqrt, sin, cos, atan2, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Signed distances in LEDs: negative inside.\nconst circle = (px, py, cx, cy, r) => sqrt((px - cx) ** 2 + (py - cy) ** 2) - r;\nfunction capsule(px, py, ax, ay, bx, by, ra, rb) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey || 1), 0, 1);\n  return sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) - (ra + (rb - ra) * u);\n}\nfunction tri(px, py, v) {\n  let dd = 1e9, s = 1;\n  for (let i = 0, j = 4; i \u003c 6; j = i, i += 2) {\n    const ex = v[j] - v[i], ey = v[j + 1] - v[i + 1], wx = px - v[i], wy = py - v[i + 1];\n    const u = cl((wx * ex + wy * ey) / (ex * ex + ey * ey), 0, 1), bx = wx - ex * u, by = wy - ey * u;\n    dd = min(dd, bx * bx + by * by);\n    const c1 = py >= v[i + 1], c2 = py \u003c v[j + 1], c3 = ex * wy > ey * wx;\n    if ((c1 && c2 && c3) || (!c1 && !c2 && !c3)) s = -s;\n  }\n  return s * sqrt(dd);\n}\n// Smooth union, so the parts of the cat grow into one another.\nconst smin = (a, b, k) => {\n  const h = cl(0.5 + (0.5 * (b - a)) / k, 0, 1);\n  return b + (a - b) * h - k * h * (1 - h);\n};\n\n// The moon: centre and radius, and its seas in three tones.\nconst MX = 43, MY = 47, MR = 26;\nconst SEAS = [[-9, -9, 7, 5], [6, -12, 6, 4], [11, 2, 6, 7], [-12, 6, 5, 7], [2, 12, 7, 4]];\nconst MOONT = new Float32Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n    if (r > MR + 1) continue;\n    let e = 9;\n    for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2);\n    MOONT[y * W + x] = (e \u003c 1 ? 0.8 : e \u003c 1.6 ? 0.9 : 1) * cl(MR + 0.5 - r, 0, 1);\n  }\n// Sky by row, in eight steps: near black at the top, a purple band over the wall.\nconst SKY = new Float32Array(H * 3);\nfor (let y = 0; y \u003c H; y++) {\n  const t = round(8 * sm(10, WALL, y)) / 8;\n  SKY[3 * y] = 0.02 + 0.17 * t;\n  SKY[3 * y + 1] = 0.008 + 0.05 * t;\n  SKY[3 * y + 2] = 0.05 + 0.22 * t;\n}\n// Stars, as each LED's twinkle phase (or -1); and the moon's glow by LED.\nconst STAR = new Float32Array(N).fill(-1), GLOW = new Float32Array(N);\nfor (let i = 0, n = 0; n \u003c 16 && i \u003c 400; i++) {\n  const x = floor(hash(i * 3 + 11) * W), y = floor(hash(i * 3 + 12) * 92);\n  if ((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2 \u003c (MR + 6) ** 2) continue;\n  STAR[y * W + x] = hash(i * 3 + 13) * 6.28;\n  n++;\n}\nfor (let p = 0; p \u003c N; p++) {\n  const out = max(0, sqrt(((p % W) + 0.5 - MX) ** 2 + (floor(p / W) + 0.5 - MY) ** 2) - MR);\n  GLOW[p] = round((0.22 * exp(-out / 5) + 0.08 * exp(-out / 16)) * 16) / 16;\n}\n\n// A jack-o'-lantern on the wall by the cat's front paws, as pixel art:\n// s stem, o skin, f the carved face lit from inside.\nconst PUMPKIN = [\n  \"........ss.......\",\n  \".......ss........\",\n  \"....ooooooooo....\",\n  \"..ooooooooooooo..\",\n  \".ooooooooooooooo.\",\n  \".oooofooooofoooo.\",\n  \"ooooffoooooffoooo\",\n  \"oooffffooofffffoo\",\n  \"oooooooofoooooooo\",\n  \"oofoooooooooooofo\",\n  \"ooffffofffoffffoo\",\n  \".oofffffffffffoo.\",\n  \"..ooooffffoooo...\",\n  \"....ooooooooo....\",\n];\nconst FLAME = [1, 0.5, 0.08];\nconst PX0 = 0, PY0 = WALL - PUMPKIN.length, PCX = 8.5, PCY = WALL - 7;\n// How far its light reaches each LED, before the flame's flicker.\nconst WARM = new Float32Array(N);\nfor (let p = 0; p \u003c N; p++) WARM[p] = 0.5 * exp(-sqrt(((p % W) + 0.5 - PCX) ** 2 + ((floor(p / W) + 0.5 - PCY) * 1.3) ** 2) / 9);\nconst vn = (x, sd) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + sd) * (1 - u) + hash((i + 1) * 7919 + sd) * u) * 2 - 1;\n};\n\n// Bats flitting round the moon, behind the cat: each loops on its own\n// figure of eight [centre x, centre y, half width, half height, rate x,\n// rate y, phase], with a jitter on top, and flaps about 4.5 times a second.\nconst BATS = [[50, 32, 11, 10, 0.53, 0.97, 0], [44, 19, 16, 7, 0.41, 0.83, 2.1], [54, 58, 7, 12, 0.67, 0.59, 4.2], [47, 45, 13, 15, 0.47, 0.71, 5.3]];\nconst batAt = (b, t) => [b[0] + b[2] * sin(b[4] * t + b[6]) + 1.5 * vn(t * 1.7, b[6] * 9), b[1] + b[3] * sin(b[5] * t + b[6] * 1.3) + 1.5 * vn(t * 1.9, b[6] * 9 + 3)];\nfunction batDist(px, py, bx, by, dir, flap) {\n  const x = (px - bx) * dir, y = py - by, ax = abs(x), tip = -1.2 + 3.2 * flap;\n  let d = sqrt((x / 1.2) ** 2 + (y / 1.7) ** 2) - 1;\n  d = min(d, tri(ax, y, [0.6, -0.9, 0.6, 0.7, 5.6, tip]));\n  d = min(d, tri(ax, y, [0.6, 0.4, 3.4, 0.6 + 1.6 * flap, 5.6, tip]));\n  d = min(d, tri(x, y, [-0.9, -1.2, 0.1, -1.4, -0.6, -2.6]));\n  return min(d, tri(x, y, [0.9, -1.2, -0.1, -1.4, 0.6, -2.6]));\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, mood: 0, startle: 0.06, t: 0, begun: false, fl: 0.72,\n    // The arch: its age (-1 when none), the wait for the next.\n    arch: -1, wait: 3.3,\n    // Eyes: blink clock, look target and where they look now; ear twitches.\n    blink: 1.5, blinkAge: 9, look: 0, lookTo: 0.6, lookWait: 1.2, tilt: 0,\n    earWait: [2.5, 4], earAge: [9, 9], lash: 9, lashWait: 0.8,\n    tail: new Float32Array(2 * 15), blk: new Uint8Array(16 * 32), tb: [0, 0, 0, 0], flap: 0, bats: BATS.map(() => [0, 0, 1]),\n    c: [0, 0, 0], e: [0, 0, 0],\n  };\n}\n\n// How far the cat is arched at an arch's age: up in 0.35 s, held 1.6 s, down in 1.2 s.\nconst archOf = (a) => (a \u003c 0 ? 0 : a \u003c 0.35 ? sm(0, 0.35, a) : a \u003c 1.95 ? 1 : 1 - sm(1.95, 3.15, a));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.mood = cl(k[2], 0, 1);\n  S.startle = cl(k[3], 0, 1);\n  if (!S.begun) {\n    S.wait = 3.3 - 2.8 * S.startle;\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // The candle in the pumpkin: two noises, about 3 and 9 times a second.\n  S.fl = 0.72 + 0.17 * vn(S.t * 2.8, 5) + 0.11 * vn(S.t * 9, 11);\n  if (input.btnPressed && input.btnPressed[3] && S.arch \u003c 0) S.arch = 0;\n  if (S.arch >= 0) {\n    S.arch += ds;\n    if (S.arch > 3.15) {\n      S.arch = -1;\n      S.wait = 12 - 9 * S.startle;\n    }\n  } else {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) S.arch = 0;\n  }\n  // The bats, and which way each is flying.\n  S.flap += ds * 2 * PI * 4.5;\n  BATS.forEach((b, i) => {\n    const [x, y] = batAt(b, S.t * 1.6), [x2] = batAt(b, S.t * 1.6 + 0.05);\n    S.bats[i] = [x, y, x2 >= x ? 1 : -1];\n  });\n  // Blinks every 2 to 5 s, each 0.18 s shut.\n  S.blink -= ds;\n  S.blinkAge += ds;\n  if (S.blink \u003c= 0) {\n    S.blinkAge = 0;\n    S.blink = 2 + 3 * Math.random();\n  }\n  // The eyes pick somewhere new to look every 1 to 3 s and get there in about 0.3 s; the head follows a little.\n  S.lookWait -= ds;\n  if (S.lookWait \u003c= 0) {\n    S.lookTo = Math.random() * 2 - 1;\n    S.lookWait = 1 + 2 * Math.random();\n  }\n  S.look += (S.lookTo - S.look) * min(1, ds * 10);\n  // The head follows the nearest bat up and down.\n  let near = 1e9, aim = 0;\n  for (const [bx, by] of S.bats) {\n    const dd = (bx - 20) ** 2 + (by - 40) ** 2;\n    if (dd \u003c near) (near = dd), (aim = cl((by - 40) / 25, -1, 1));\n  }\n  S.tilt += (-0.3 * aim + 0.06 * S.lookTo - S.tilt) * min(1, ds * 4);\n  // Now and then the tail lashes: it whips out straight in a quarter of a\n  // second and curls back over a second. Every 2.5 to 4.5 s when watchful,\n  // more than twice as often when cross.\n  S.lash += ds;\n  S.lashWait -= ds * (1 + 1.4 * S.mood);\n  if (S.lashWait \u003c= 0 && S.arch \u003c 0) {\n    S.lash = 0;\n    S.lashWait = 1.6 + 1.6 * Math.random();\n  }\n  // Each ear flicks back now and then, quicker and more often when cross.\n  for (let i = 0; i \u003c 2; i++) {\n    S.earWait[i] -= ds * (1 + S.mood);\n    S.earAge[i] += ds;\n    if (S.earWait[i] \u003c= 0) {\n      S.earAge[i] = 0;\n      S.earWait[i] = 1.5 + 3 * Math.random();\n    }\n  }\n}\n\n// The cat, built from its pose: arch a, mood m, the head's tilt and the ears.\nfunction pose(S) {\n  const a = archOf(S.arch), m = S.mood, t = S.t;\n  // The tail: fifteen joints from the root behind the haunch. It rises,\n  // then curls forward over the back like a question mark; the whole curl\n  // swings to and fro while a wave runs out to the tip. Arched, it stands\n  // straight up from the raised haunch and puffs.\n  const amp = (0.3 + 0.22 * m) * (1 - 0.7 * a), w = (2 * PI) / (2.6 / (1 + 0.7 * m));\n  const swing = (0.38 + 0.25 * m) * sin(w * 0.5 * t), la = S.lash;\n  const lash = la \u003c 0.25 ? sm(0, 0.25, la) : 1 - sm(0.25, 1.3, la);\n  let x = 48 - 2 * a, y = WALL - 6 - 26 * a, head = 0;\n  const T = S.tail;\n  for (let i = 0; i \u003c 15; i++) {\n    const u = i / 14;\n    const calm = -0.8 + swing * (1 - 0.4 * u) - 0.8 * sm(0, 0.35, u) - 1.1 * sm(0.45, 1, u) + amp * sin(w * t - 0.6 * i) * (0.25 + 0.75 * u);\n    const up = -1.5 - 0.15 * u + 0.08 * sin(w * 2 * t - 0.4 * i);\n    head = calm + (up - calm) * max(a, 0.85 * lash);\n    T[2 * i] = x;\n    T[2 * i + 1] = y;\n    x += cos(head) * 3.4;\n    y += sin(head) * 3.4;\n  }\n  // The tail's box, with room for its fur.\n  const tb = S.tb;\n  tb[0] = tb[1] = 1e9;\n  tb[2] = tb[3] = -1e9;\n  for (let i = 0; i \u003c 15; i++) {\n    tb[0] = min(tb[0], T[2 * i] - 8);\n    tb[1] = min(tb[1], T[2 * i + 1] - 8);\n    tb[2] = max(tb[2], T[2 * i] + 8);\n    tb[3] = max(tb[3], T[2 * i + 1] + 8);\n  }\n  return a;\n}\n\n// Fur standing up: a row of teeth every 2.4 LEDs along a coordinate.\nconst teeth = (v) => max(0, 1 - 3 * abs(v / 2.4 - floor(v / 2.4) - 0.5));\n\n// The cat is drawn 1.1 times the size it is laid out at, standing on the\n// wall, its middle (38 as laid out) at x = 35.\nconst SC = 1.1, AX = 35;\nconst ARC = [];\nfor (let k = 0; k \u003c= 6; k++) {\n  const th = PI + 0.25 + (k * (PI - 0.5)) / 6;\n  ARC.push([34 + 14 * cos(th), 82 + 24 * sin(th), 7.5 - 1.5 * sin((k * PI) / 6)]);\n}\nfunction catDist(S, sx, sy, a) {\n  const px = 38 + (sx - AX) / SC, py = WALL + (sy - WALL) / SC;\n  const m = S.mood, hiss = sm(0.3, 0.8, a) * (S.arch >= 0 ? 0.6 + 0.4 * sin(S.arch * 14) : 0);\n  let d = 1e9;\n  // A cross cat leans forward over its front paws, about the root of its\n  // tail: the sitting body and the head are drawn turned by up to 0.12 rad.\n  const ln = -0.12 * m * (1 - a), lc = cos(ln), ls = sin(ln);\n  const lx = 40 + lc * (px - 40) + ls * (py - 100), ly = 100 - ls * (px - 40) + lc * (py - 100);\n  // Sitting: haunch, back and chest from the wall up to the neck, the front\n  // legs and the paws.\n  if (a \u003c 1) {\n    const px = lx, py = ly;\n    let ds = circle(px, py, 38, WALL - 14, 14);\n    ds = smin(ds, capsule(px, py, 37, WALL - 16, 27, 63, 13, 9), 2);\n    ds = smin(ds, circle(px, py, 25, 74, 9), 3);\n    ds = min(ds, capsule(px, py, 22, 76, 21, WALL - 1, 3.4, 2.6));\n    ds = min(ds, capsule(px, py, 27.5, 78, 27, WALL - 1, 3, 2.4));\n    ds = min(ds, capsule(px, py, 17.5, WALL - 1, 23, WALL - 1, 1.8, 1.8));\n    ds = min(ds, capsule(px, py, 31, WALL - 1.5, 44, WALL - 1.5, 2.2, 2.2));\n    // A cross cat's fur rises along its back.\n    if (m > 0) ds -= 1.4 * m * sm(36, 44, px) * sm(96, 80, py) * teeth(py);\n    d = ds;\n  }\n  // Arched: up on straight legs, the back bowed high, the fur on end.\n  if (a > 0) {\n    let da = 1e9;\n    for (let k = 0; k \u003c 6; k++) da = min(da, capsule(px, py, ARC[k][0], ARC[k][1], ARC[k + 1][0], ARC[k + 1][1], ARC[k][2], ARC[k + 1][2]));\n    da = smin(da, circle(px, py, 21, 74, 7), 2);\n    da = smin(da, circle(px, py, 46, 74, 8), 2);\n    da = min(da, capsule(px, py, 21, 78, 20, WALL - 1, 3, 2.4));\n    da = min(da, capsule(px, py, 25, 80, 26, WALL - 1, 2.6, 2.2));\n    da = min(da, capsule(px, py, 46, 78, 45, WALL - 1, 3.4, 2.4));\n    da = min(da, capsule(px, py, 49, 80, 50, WALL - 1, 2.8, 2.2));\n    if (py \u003c 80) da -= 1.8 * teeth(atan2(py - 82, px - 34) * 18);\n    d = a \u003c 1 ? d + (da - d) * a : da;\n  }\n  // The tail.\n  const T = S.tail, puff = 1 + 0.7 * a;\n  if (px > S.tb[0] && px \u003c S.tb[2] && py > S.tb[1] && py \u003c S.tb[3]) for (let i = 0; i \u003c 14; i++) {\n    const r0 = (3.2 - 1.3 * (i / 14)) * puff, r1 = (3.2 - 1.3 * ((i + 1) / 14)) * puff;\n    let dt = capsule(px, py, T[2 * i], T[2 * i + 1], T[2 * i + 2], T[2 * i + 3], r0, r1);\n    if (a > 0.05) dt -= a * 1.4 * teeth(py);\n    d = smin(d, dt, 1.5);\n  }\n  // The head, turned about the neck by its tilt; arched, it comes down and\n  // forward with the chest and dips its nose.\n  const tl = S.tilt + 0.3 * a, c = cos(tl), s = sin(tl), nx = 28 - 5 * a, ny = 58 + 13 * a;\n  const qx = 28 + c * (lx - nx) + s * (ly - ny), qy = 58 - s * (lx - nx) + c * (ly - ny);\n  let dh = circle(qx, qy, 24, 47, 9.5);\n  dh = smin(dh, circle(qx, qy, 16, 50, 5), 3);\n  dh = smin(dh, circle(qx, qy, 19.5, 53.5, 5), 2.5);\n  dh = smin(dh, capsule(qx, qy, 24, 47, 28, 60, 7, 8), 3);\n  // Ears: laid back by mood and arch, each flicking back now and then.\n  for (let i = 0; i \u003c 2; i++) {\n    const fl = S.earAge[i] \u003c 0.3 ? sin((PI * S.earAge[i]) / 0.3) : 0;\n    const ang = (0.55 * m + 0.7 * a + 0.5 * fl) * (i ? 1 : 0.8);\n    const bx = i ? 28 : 20, by = 40, ec = cos(ang), es = sin(ang);\n    const ex = bx + ec * (qx - bx) + es * (qy - by), ey = by - es * (qx - bx) + ec * (qy - by);\n    dh = min(dh, tri(ex, ey, i ? [24, 41, 32.5, 43, 29.5, 30] : [15.5, 44, 23.5, 40, 17.5, 30]) - 0.6);\n  }\n  // A hiss opens the mouth: a wedge cut from the muzzle.\n  if (hiss > 0.05) dh = max(dh, -tri(qx, qy, [10, 51.5 - 1.5 * hiss, 19, 52.5, 10, 53.5 + 3 * hiss]));\n  // Three whiskers from the muzzle, thin enough to show only as light.\n  let wk = 1e9;\n  if (qx \u003c 16 && qy > 45 && qy \u003c 58) for (let i = 0; i \u003c 3; i++) wk = min(wk, capsule(qx, qy, 13, 50 + i, 7.5, 48 + 2.6 * i, 0.3, 0.3));\n  return { d: min(d, dh) * SC, qx, qy, wk: wk * SC };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const a = pose(S), L = S.c, E = S.e;\n  // The light: moon and rim in one hue, the eyes in the opposite one.\n  hsv(0.075 + S.hue, 0.78, 1, L);\n  hsv(0.33 + S.hue, 0.85, 1, E);\n  // Eye: open, blinking, narrowed by mood or a hiss.\n  const bl = S.blinkAge \u003c 0.18 ? abs(1 - S.blinkAge / 0.09) : 1;\n  const open = bl * (1 - 0.45 * max(S.mood, sm(0.3, 0.8, a)));\n  const slit = 1.1 - 0.75 * max(S.mood, a);\n  // The cat's distance is worked out only near its outline and its eye: a\n  // first pass over 4 x 4 blocks marks each as clear of the cat (0), deep\n  // inside it (1) or near its edge (2). The fur's teeth make the distance\n  // change up to 3.3 times faster than the LEDs, hence the wider margin.\n  const blk = S.blk, margin = a > 0.01 || S.mood > 0 ? 11 : 5;\n  for (let by = 0; by \u003c 32; by++)\n    for (let bx = 0; bx \u003c 16; bx++) {\n      const y0 = by * 4;\n      if (y0 + 4 \u003c= 8 || y0 > WALL) {\n        blk[by * 16 + bx] = 0;\n        continue;\n      }\n      const C = catDist(S, bx * 4 + 2, y0 + 2, a), nearEye = (C.qx - 19.5) ** 2 + (C.qy - 46) ** 2 \u003c 64;\n      blk[by * 16 + bx] = C.d > margin ? 0 : C.d \u003c -margin && !nearEye ? 1 : 2;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, px = x + 0.5, py = y + 0.5;\n      let R = SKY[3 * y], G = SKY[3 * y + 1], B = SKY[3 * y + 2];\n      // Moon glow in rings, then the moon.\n      const glow = GLOW[p];\n      R += L[0] * glow;\n      G += L[1] * glow;\n      B += L[2] * glow;\n      const mt = MOONT[p];\n      if (mt > 0) {\n        R += (L[0] * 0.95 * mt - R) * mt;\n        G += (L[1] * 0.95 * mt - G) * mt;\n        B += (L[2] * 0.95 * mt - B) * mt;\n      }\n      if (STAR[p] >= 0) {\n        const v = 0.25 + 0.2 * sin(S.t * 2.1 + STAR[p]);\n        R = max(R, v);\n        G = max(G, v);\n        B = max(B, v * 1.1);\n      }\n      // Bats: black against the moon, a shade lighter than the night sky.\n      for (let i = 0; i \u003c BATS.length; i++) {\n        const [bx, by, dir] = S.bats[i];\n        if (abs(px - bx) > 7 || abs(py - by) > 6) continue;\n        const cov = cl(0.5 - batDist(px, py, bx, by, dir, sin(S.flap + i * 2.2)), 0, 1);\n        if (cov > 0) {\n          R += (0.03 - R) * cov;\n          G += (0.01 - G) * cov;\n          B += (0.05 - B) * cov;\n        }\n      }\n      // The pumpkin's candlelight, in rings that breathe with the flame.\n      const warm = round(S.fl * WARM[p] * 20) / 20;\n      // The wall: a coping stone lit along its top, bricks below in shadow.\n      if (y >= WALL) {\n        if (y \u003c WALL + 3) {\n          const top = y === WALL ? 0.55 : 0.12;\n          R = 0.1 + L[0] * top;\n          G = 0.07 + L[1] * top;\n          B = 0.13 + L[2] * top;\n        } else {\n          const row = floor((y - WALL - 3) / 5), bx = (x + (row & 1) * 5) % 10, by = (y - WALL - 3) % 5;\n          const tone = 0.7 + 0.3 * hash(row * 17 + floor((x + (row & 1) * 5) / 10));\n          const mortar = by === 4 || bx === 9;\n          R = mortar ? 0.03 : 0.13 * tone;\n          G = mortar ? 0.02 : 0.08 * tone;\n          B = mortar ? 0.05 : 0.17 * tone;\n        }\n      }\n      R += FLAME[0] * warm;\n      G += FLAME[1] * warm;\n      B += FLAME[2] * warm;\n      // The jack-o'-lantern itself.\n      const sx = x - PX0, sy = y - PY0;\n      if (sy >= 0 && sy \u003c PUMPKIN.length && sx >= 0 && sx \u003c 17) {\n        const ch = PUMPKIN[sy][sx];\n        if (ch === \"f\") {\n          const v = min(1, S.fl * 1.25);\n          R = v;\n          G = 0.78 * v * v;\n          B = 0.2 * v * v * v;\n        } else if (ch === \"o\") {\n          const edge = PUMPKIN[sy - 1] === undefined || PUMPKIN[sy - 1][sx] === \".\" || PUMPKIN[sy - 1][sx] === \"s\" || sx === 0 || PUMPKIN[sy][sx - 1] === \".\" || PUMPKIN[sy][sx + 1] === \".\" || sx === 16;\n          R = edge ? 0.62 : 0.3 + 0.14 * S.fl;\n          G = edge ? 0.24 : 0.09 + 0.04 * S.fl;\n          B = edge ? 0.04 : 0.02;\n        } else if (ch === \"s\") {\n          R = 0.16;\n          G = 0.2;\n          B = 0.05;\n        }\n      }\n      const bk = blk[(y >> 2) * 16 + (x >> 2)];\n      if (bk === 1) {\n        R = 0.012;\n        G = 0.008;\n        B = 0.02;\n      } else if (bk === 2 && y > 8 && y \u003c WALL + 1) {\n        const C = catDist(S, px, py, a), cov = cl(0.5 - C.d, 0, 1);\n        // The whiskers catch the moonlight where the night is behind them.\n        const wv = cov === 0 ? cl(0.6 - C.wk, 0, 0.6) * (1 - MOONT[p]) : 0;\n        if (wv > 0) {\n          R += (L[0] - R) * wv;\n          G += (L[1] - G) * wv;\n          B += (L[2] - B) * wv;\n        }\n        if (cov > 0) {\n          // Rim light: the first LED inside the edge in the moon's colour,\n          // the second at a third, strongest away from the moon's face.\n          const rim = (C.d > -1.2 ? 1 : C.d > -2.2 ? 0.35 : 0) * (0.35 + 0.65 * (1 - MOONT[p]));\n          const k = 1 - cov;\n          // Where the pumpkin's light reaches, its warm rim joins the moon's.\n          const rw = C.d > -1.2 ? min(1, 1.6 * warm) : 0;\n          R = R * k + cov * (0.012 + L[0] * 0.9 * rim + FLAME[0] * rw);\n          G = G * k + cov * (0.008 + L[1] * 0.9 * rim + FLAME[1] * rw);\n          B = B * k + cov * (0.02 + L[2] * 0.9 * rim + FLAME[2] * rw);\n          // The eye: an almond of light with a slit pupil that looks round.\n          const ex = (C.qx - 19.5) / 2.6, ey = (C.qy - 46) / (1.8 * open + 0.01);\n          if (open > 0.1 && ex * ex + ey * ey \u003c 1) {\n            const pup = abs(C.qx - (19.3 + 1.1 * S.look)) \u003c slit * 0.6 + 0.2;\n            R = pup ? 0 : E[0];\n            G = pup ? 0 : E[1];\n            B = pup ? 0 : E[2];\n          }\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, R)), round(255 * min(1, G)), round(255 * min(1, B)));\n    }\n}\n","bulgarian-solitaire":"// ===== Patternflow pattern =====\n// Title:   Bulgarian Solitaire\n// Family:  number\n// Idea:    Cards stand in piles on the floor, and every move one card lifts off each pile, they fly up into a new pile that drops into its place while the old piles slide into order, until the ten cards stand as the staircase 4, 3, 2, 1, which holds, and they are gathered and dealt again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Bulgarian solitaire (Jørgen Brandt, 1982)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.25..6, Size=4..8, Extra=0..1\n//\n// Knob 1: Hue. Turns the cards' colours together. Each pile of a deal has its own colour and its cards keep it through the play; at 0 the piles are azure, blue, violet, rose, orange, lime and so on in steps of 0.13 round the wheel, every card at full brightness, with a white suit on its face.\n// Knob 2: Speed. At 2 a move takes 1.6 seconds, so the slowest start of ten cards reaches the staircase in 12 moves and 19 seconds; at 0.25 a move takes 12.8 seconds, at 6 half a second.\n// Knob 3: Size. The staircase k, from 4 to 8: 10, 15, 21, 28 or 36 cards. A new size is dealt first from the slowest start, k - 1, k - 1, k - 2, ..., 2, 1, 1, which takes the most moves any start can, k^2 - k: 12, 20, 30, 42 or 56; then twice from a random start, then the slowest again. The tally along the top lights a mark a move against k^2 - k dim marks.\n// Knob 4: Extra. Cards beyond k(k + 1)/2: none below 1/(k + 1), 0.2 at Size 4, and one more for each further 1/(k + 1), up to k at 1. Then the play never settles: it falls into a cycle where the piles are the staircase with one extra card, rimmed white, on some of its steps, and the white rims move round the steps and come back to where they were after k + 1 moves or a divisor of it. The cycle is played round once more with gold marks in the tally, and then the cards are dealt again.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst lerp = (a, b, t) => a + (b - a) * t;\n\n// The floor's top row; cards stand on it. Rows above TOP stay clear for the tally.\nconst FLOOR = 124, TOP = 10;\n// Tallest and shortest card, in LEDs, and the widest pile slot.\nconst CHMAX = 18, CHMIN = 4, SWMAX = 14;\n// Seconds at Speed 2: one move, gathering the cards, dealing them, holding the end.\nconst MOVE = 1.6, GATHER = 0.9, DEAL = 1.8, HOLD = 2.6;\n// Phases of a move: the lift ends at A and the flight at B; the old piles\n// slide into order from S0 to SL, clearing the place under the new pile,\n// which drops from SL to C and bounces BOUNCE LEDs.\nconst A = 0.14, B = 0.5, S0 = 0.36, SL = 0.68, C = 0.86, BOUNCE = 2;\n// Every DEALS-th deal is the slowest start, k - 1, k - 1, k - 2, ..., 2, 1, 1.\nconst DEALS = 3;\n// Hue at Hue 0 and the step between the hues of the dealt piles.\nconst HUE0 = 0.55, STEP = 0.13;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// One move of Bulgarian solitaire on piles of card ids (each pile bottom to\n// top): the top card of every pile, left to right, makes a new pile; the\n// piles are then sorted tallest first, the new one after the old of its height.\nfunction move(piles) {\n  const fresh = piles.map((p) => p[p.length - 1]);\n  const out = piles.map((p) => p.slice(0, -1)).filter((p) => p.length);\n  out.push(fresh);\n  return out.map((p, i) => [p, i]).sort((a, b) => b[0].length - a[0].length || a[1] - b[1]).map((e) => e[0]);\n}\n\nconst key = (piles) => piles.map((p) => p.length).join(\",\");\n\n// Play from a start until the heights repeat: the staircase, or a cycle.\nfunction play(start) {\n  const states = [start], seen = new Map([[key(start), 0]]);\n  for (;;) {\n    const next = move(states[states.length - 1]), k = key(next);\n    if (seen.has(k)) return { states, loop: seen.get(k) };\n    seen.set(k, states.length);\n    states.push(next);\n  }\n}\n\n// Partitions of n into at most b parts of at most a each, counted, so a\n// random start can be drawn evenly from those that fit a box of side k + 1.\nconst QCOUNT = new Map();\nfunction qcount(n, a, b) {\n  if (n === 0) return 1;\n  if (a === 0 || b === 0 || n > a * b) return 0;\n  const key = (n * 64 + a) * 64 + b;\n  if (QCOUNT.has(key)) return QCOUNT.get(key);\n  let s = 0;\n  for (let p = 1; p \u003c= min(n, a); p++) s += qcount(n - p, p, b - 1);\n  QCOUNT.set(key, s);\n  return s;\n}\nfunction randomPartition(n, side) {\n  const out = [];\n  let a = side, b = side;\n  while (n > 0) {\n    let r = Math.random() * qcount(n, a, b), p = min(n, a);\n    for (; p > 1; p--) {\n      const c = qcount(n - p, p, b - 1);\n      if (r \u003c c) break;\n      r -= c;\n    }\n    out.push(p);\n    n -= p;\n    a = p;\n    b--;\n  }\n  return out;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, k: 4, extra: 0, hue: 0, rate: 1, deals: 0,\n    game: null, mode: \"deal\", t: 0, at: 0, hues: null, prevHues: null, suits: null, prevSuits: null, prev: null, cards: null,\n    rgb: new Float32Array(W * H * 3), c3: new Float32Array(3),\n  };\n}\n\n// A new game: the heights of the start, the cards dealt into them, the play\n// worked out to the end, and the layout that fits every state of it.\nfunction newGame(S) {\n  const k = S.k, tri = (k * (k + 1)) / 2, n = tri + S.extra;\n  let heights;\n  if (S.extra === 0 && S.deals % DEALS === 0) {\n    heights = [k - 1];\n    for (let h = k - 1; h >= 1; h--) heights.push(h);\n    heights.push(1);\n  } else heights = randomPartition(n, k + 1);\n  S.deals++;\n  let id = 0;\n  const start = heights.map((h) => Array.from({ length: h }, () => id++));\n  const hues = new Float32Array(n), suits = new Uint8Array(n);\n  start.forEach((p, i) => p.forEach((c) => ((hues[c] = i * STEP), (suits[c] = i % 4))));\n  const g = play(start);\n  // Slots for the most piles of any state; cards as tall as the tallest pile allows.\n  let slots = 0, tall = 0;\n  for (const s of g.states) {\n    slots = max(slots, s.length);\n    for (const p of s) tall = max(tall, p.length);\n  }\n  const sw = min(SWMAX, floor(W / slots)), cw = sw - (sw >= 8 ? 2 : 1);\n  const ch = cl(floor((FLOOR - TOP) / (tall + 0.6)), CHMIN, CHMAX);\n  S.game = { ...g, n, k, tri: S.extra === 0, sw, cw, ch, period: g.states.length - g.loop };\n  S.prevHues = S.hues;\n  S.prevSuits = S.suits;\n  S.hues = hues;\n  S.suits = suits;\n  S.prev = S.cards;\n  S.mode = \"gather\";\n  S.t = 0;\n  S.at = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kn[0];\n  S.rate = cl(kn[1], 0.25, 6) / 2;\n  const k = round(cl(kn[2], 4, 8)), extra = min(k, floor(cl(kn[3], 0, 1) * (k + 1)));\n  if (!S.begun || k !== S.k || extra !== S.extra) {\n    // A new size starts again from the slowest start.\n    if (k !== S.k || !S.begun) S.deals = 0;\n    S.k = k;\n    S.extra = extra;\n    newGame(S);\n    if (!S.begun) (S.mode = \"deal\"), (S.prev = null);\n    S.begun = true;\n  }\n  S.t += d * S.rate;\n  const G = S.game;\n  if (S.mode === \"gather\" && S.t >= GATHER) (S.mode = \"deal\"), (S.t = 0);\n  else if (S.mode === \"deal\" && S.t >= DEAL) (S.mode = \"move\"), (S.t = 0), (S.at = 0);\n  else if (S.mode === \"move\") {\n    while (S.t >= MOVE && S.mode === \"move\") {\n      S.t -= MOVE;\n      S.at++;\n      // A cycle is played round once more after it is found.\n      const last = G.states.length - 1 + (G.tri ? 0 : G.period);\n      if (S.at >= last) (S.mode = \"hold\"), (S.t = 0);\n    }\n  } else if (S.mode === \"hold\" && S.t >= HOLD) newGame(S);\n}\n\n// The state after `i` moves; past the end of a cycle's states it goes round the cycle.\nfunction stateAt(G, i) {\n  const L = G.states.length;\n  if (i \u003c L) return G.states[i];\n  return G.states[G.loop + ((i - G.loop) % G.period)];\n}\n\n// In a cycle every state is the staircase k, k - 1, ..., 1, 0 with one card\n// more on some of its k + 1 steps; those top cards are the extra ones.\nfunction extras(G, i) {\n  const out = new Set();\n  if (G.tri || i \u003c G.loop) return out;\n  stateAt(G, i).forEach((p, j) => {\n    if (p.length > G.k - j) out.add(p[p.length - 1]);\n  });\n  return out;\n}\n\nconst slotX = (G, i, count) => (W - count * G.sw) / 2 + i * G.sw + (G.sw - G.cw) / 2;\nconst levelY = (G, j) => FLOOR - (j + 1) * G.ch;\n\n// Where every card is this frame, as [id, x, y, flying, extra]: x and y\n// are its top-left corner, a card of the last game has id -1 - its id.\nfunction layout(S) {\n  const G = S.game, out = [];\n  const rest = (piles, ex) => piles.forEach((p, i) => p.forEach((c, j) => out.push([c, slotX(G, i, piles.length), levelY(G, j), 0, ex.has(c)])));\n  if (S.mode === \"gather\" || S.mode === \"deal\") {\n    // The deck sits high in the middle; cards fly to it and from it.\n    const dx = (W - G.cw) / 2, dy = 30;\n    if (S.mode === \"gather\") {\n      const u = S.t / GATHER;\n      for (const [c, x, y] of S.prev || []) {\n        const e = sm(u * 1.4 - (c % 7) * 0.05);\n        out.push([-1 - c, lerp(x, dx, e), lerp(y, dy, e) - 14 * sin(PI * e), 0]);\n      }\n      return out;\n    }\n    const start = G.states[0], n = G.n, u = S.t / DEAL;\n    let order = 0;\n    start.forEach((p, i) =>\n      p.forEach((c, j) => {\n        const e = sm((u - (order++ / n) * 0.7) / 0.3);\n        out.push([c, lerp(dx, slotX(G, i, start.length), e), lerp(dy, levelY(G, j), e) - 10 * sin(PI * e), 0]);\n      }),\n    );\n    return out;\n  }\n  const P = stateAt(G, S.at);\n  if (S.mode === \"hold\") {\n    rest(P, extras(G, S.at));\n    return out;\n  }\n  const Q = stateAt(G, S.at + 1), m = P.length, u = S.t / MOVE;\n  // The top cards lift, fly up and stack bottom first into the new pile,\n  // which hangs at the top of the panel above its place in Q; the old piles\n  // slide into their places, and it drops to the floor.\n  const a = sm(u / A), c = sm((u - S0) / (SL - S0)), d = cl((u - SL) / (C - SL), 0, 1);\n  const qIndex = new Map(Q.map((p, i) => [p[0], i]));\n  const nx = slotX(G, qIndex.get(P[0][P[0].length - 1]), Q.length);\n  const R = max(0, FLOOR - m * G.ch - TOP);\n  const drop = R * (1 - d * d) - (u > C ? BOUNCE * sin((PI * (u - C)) / (1 - C)) : 0);\n  const st = min(0.03, (B - A) / (2 * m)), lift = a * (G.ch * 0.5 + 3), ex = extras(G, u \u003c SL ? S.at : S.at + 1);\n  P.forEach((p, i) => {\n    const below = p.length - 1;\n    let x = slotX(G, i, m);\n    if (below > 0) x = lerp(x, slotX(G, qIndex.get(p[0]), Q.length), c);\n    for (let j = 0; j \u003c below; j++) out.push([p[j], x, levelY(G, j), 0, ex.has(p[j])]);\n    const f = sm((u - A - i * st) / (B - A - (m - 1) * st));\n    const tx = lerp(x, nx, f), ty = lerp(levelY(G, below) - lift, levelY(G, i) - R, f) - 6 * sin(PI * f) + (u >= B ? R - drop : 0);\n    out.push([p[below], u \u003c B ? tx : nx, ty, 1, ex.has(p[below])]);\n  });\n  return out;\n}\n\n// Suits, 5 by 5, one row per string: diamond, heart, spade, club.\nconst SUITS = [\n  [\"..#..\", \".###.\", \"#####\", \".###.\", \"..#..\"],\n  [\".#.#.\", \"#####\", \"#####\", \".###.\", \"..#..\"],\n  [\"..#..\", \".###.\", \"#####\", \"#.#.#\", \"..#..\"],\n  [\"..#..\", \".###.\", \"##.##\", \"#####\", \"..#..\"],\n].map((rows) => rows.map((r) => [...r].map((ch) => ch === \"#\")));\n// The same, 3 by 3, for the corners.\nconst PIPS = [\n  [\".#.\", \"###\", \".#.\"],\n  [\"#.#\", \"###\", \".#.\"],\n  [\".#.\", \"###\", \"#.#\"],\n  [\".#.\", \"###\", \"###\"],\n].map((rows) => rows.map((r) => [...r].map((ch) => ch === \"#\")));\n\nfunction put(rgb, x, y, r, g, b) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= FLOOR) return;\n  const o = (y * W + x) * 3;\n  (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.game) return;\n  const G = S.game, { rgb, c3 } = S;\n  rgb.fill(0);\n  const cards = layout(S);\n  S.cards = cards.filter((e) => e[0] >= 0);\n  // The floor.\n  for (let x = 0; x \u003c W; x++)\n    for (let y = FLOOR; y \u003c FLOOR + 2; y++) {\n      const o = (y * W + x) * 3;\n      (rgb[o] = 0.3), (rgb[o + 1] = 0.26), (rgb[o + 2] = 0.42);\n    }\n  // Cards: resting ones first, flying ones on top. A card is its pile's\n  // colour with a paler rim and a white suit in the middle; an extra card of\n  // a cycle has a white rim.\n  cards.sort((p, q) => p[3] - q[3]);\n  const cw = G.cw, chh = G.ch - 1;\n  for (const [id, x0, y0, , mark] of cards) {\n    const old = id \u003c 0, c = old ? -1 - id : id;\n    hsv(HUE0 + S.hue + (old ? S.prevHues : S.hues)[c], 0.85, 1, c3, 0);\n    const [r, g, b] = c3, X = round(x0), Y = round(y0);\n    const rr = mark ? 1 : r + (1 - r) * 0.45, rg = mark ? 1 : g + (1 - g) * 0.45, rb = mark ? 1 : b + (1 - b) * 0.45;\n    for (let y = Y; y \u003c Y + chh; y++)\n      for (let x = X; x \u003c X + cw; x++) {\n        const rim = x === X || x === X + cw - 1 || y === Y || y === Y + chh - 1;\n        if (rim) put(rgb, x, y, rr, rg, rb);\n        else put(rgb, x, y, r, g, b);\n      }\n    if (cw >= 7 && chh >= 7) {\n      const suit = SUITS[(old ? S.prevSuits : S.suits)[c]], sx = X + ((cw - 5) >> 1), sy = Y + ((chh - 5) >> 1);\n      for (let v = 0; v \u003c 5; v++) for (let u = 0; u \u003c 5; u++) if (suit[v][u]) put(rgb, sx + u, sy + v, 1, 1, 1);\n      if (cw >= 9 && chh >= 15) {\n        // Corner pips, the bottom one upside down.\n        const pip = PIPS[(old ? S.prevSuits : S.suits)[c]];\n        for (let v = 0; v \u003c 3; v++)\n          for (let u = 0; u \u003c 3; u++)\n            if (pip[v][u]) put(rgb, X + 2 + u, Y + 2 + v, 1, 1, 1), put(rgb, X + cw - 3 - u, Y + chh - 3 - v, 1, 1, 1);\n      }\n    } else if (cw >= 3 && chh >= 3) put(rgb, X + ((cw - 1) >> 1), Y + ((chh - 1) >> 1), 1, 1, 1);\n  }\n  // The staircase, once reached, is outlined in white step by step.\n  if (S.mode === \"hold\" && G.tri) {\n    const P = stateAt(G, S.at), e = cl(S.t / 0.8, 0, 1) * P.length;\n    for (let i = 0; i \u003c P.length && i \u003c e; i++) {\n      const x0 = round(slotX(G, i, P.length)) - 1, y0 = round(levelY(G, P[i].length - 1)) - 2, x1 = x0 + G.sw;\n      for (let x = x0; x \u003c= x1; x++) put(rgb, x, y0, 1, 1, 1);\n      const y1 = i + 1 \u003c P.length ? round(levelY(G, P[i + 1].length - 1)) - 2 : FLOOR;\n      for (let y = y0; y \u003c= y1; y++) put(rgb, x1, y, 1, 1, 1);\n    }\n  }\n  // The tally: a mark a move, along the top; for a staircase the dim marks\n  // count out the most moves any start can take, k^2 - k.\n  const done = S.mode === \"hold\" ? S.at : S.mode === \"move\" ? S.at + (S.t / MOVE > C ? 1 : 0) : 0;\n  const total = G.tri ? G.k * G.k - G.k : G.states.length - 1 + G.period;\n  const rows = Math.ceil(total / 32), per = Math.ceil(total / rows), pitch = floor(W / per), tw = max(1, pitch - 1);\n  const x0 = floor((W - per * pitch + 1) / 2);\n  for (let i = 0; i \u003c total; i++) {\n    const lit = i \u003c done, loop = !G.tri && i >= G.loop;\n    const v = lit ? 1 : G.tri ? 0.22 : 0;\n    if (!v) continue;\n    const X = x0 + (i % per) * pitch, Y = 2 + floor(i / per) * 5;\n    for (let y = Y; y \u003c Y + 3; y++) for (let x = X; x \u003c X + tw; x++) put(rgb, x, y, v, v * (loop ? 0.8 : 1), v * (loop ? 0.2 : 1));\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o] * 255, rgb[o + 1] * 255, rgb[o + 2] * 255);\n}\n","crystal-ball":"// ===== Patternflow pattern =====\n// Title:   Crystal Ball\n// Family:  halloween\n// Idea:    A big crystal ball sits on a small brass stand in a dark room, purple and toxic green smoke rising up its middle and spiralling down its sides, and now and then the smoke gathers into a vision, a grinning skull, a staring eye or a crescent moon, holds it for a second or two and lets it go back into the swirl.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Smoke=0..1, Visions=0..1\n//\n// Knob 1: Hue. The two smokes' colours, kept out of red, orange and yellow, which turn brown when smoke thins. At 0 purple and toxic green, at 0.25 indigo and sea green, at 0.5 magenta and sky blue, at 0.75 crimson and blue violet, at 1 cyan and pink; the glass takes a dark shade of the first, visions stay bone white.\n// Knob 2: Speed. At 2 the smoke rises up the middle of the ball at 14 LEDs a second and sinks down the sides, the whole swirl turning once in 3.9 s; a vision gathers in 1.4 s and lets go over 1.6 s. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Smoke. How much smoke: 700 chunks at 0, 1500 at 1, each living 4.5 to 8 s from one of two wells low in the glass, one for each colour, turning slowly round the middle.\n// Knob 4: Visions. How often a vision comes and how much of the smoke goes into it. At 0.06 the first comes at 2 s and takes 62% of the smoke, holds 1.5 s, and the next comes 12.4 s after one has gone; at 1 the first comes at 0.4 s and takes all of it, holds 2.6 s, and the next comes after 3 s. They come as a grinning skull with a chattering jaw, a slit-pupilled eye that blinks once, and a crescent moon, then in any order.\n// Buttons: any tap calls the next vision at once when none is showing.\n\nconst W = 64, H = 128, CX = 32, CY = 60, R = 28, RIN = 25.5, GW = 32, GH = 64;\nconst { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (v) => v * v * (3 - 2 * v);\nconst MAXN = 1500;\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const r = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  const g = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  const b = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return [round(r * 63) * 4, round(g * 63) * 4, round(b * 63) * 4];\n}\n\n// The visions, in u, v from -1 to 1 (v down), 20 LEDs to a unit, tested\n// at the middle of each 2x2 cell. Each returns 0 outside, else the colour\n// class: 1 the first smoke, 2 the second, 3 bone. The skull is drawn by\n// hand, one character to a cell.\nconst SKULL = [\n  \"......######......\",\n  \"...############...\",\n  \"..##############..\",\n  \".################.\",\n  \".################.\",\n  \"##################\",\n  \"##################\",\n  \"##.....####.....##\",\n  \"#......####......#\",\n  \"#......####......#\",\n  \"##.....####.....##\",\n  \"###...######...###\",\n  \".#######..#######.\",\n  \"..######..######..\",\n  \"...############...\",\n  \"...#.##.##.##.#...\",\n  \"....##########....\",\n  \".....########.....\",\n];\nfunction skull(u, v) {\n  const c = floor(u * 10 + 9), r = floor(v * 10 + 9);\n  return r >= 0 && r \u003c SKULL.length && c >= 0 && c \u003c 18 && SKULL[r][c] === \"#\" ? 3 : 0;\n}\nfunction eye(u, v) {\n  const lid = 0.5 * (1 - u * u) ** 0.9;\n  if (abs(u) >= 1 || abs(v) > lid + 0.1) return 0;\n  if (abs(v) > lid) return 1;\n  // A slit pupil in a green iris.\n  if (u * u + v * v \u003c 0.38 ** 2) return abs(u) \u003c 0.06 && abs(v) \u003c 0.32 ? 0 : 2;\n  return 3;\n}\nfunction moon(u, v) {\n  if (u * u + v * v > 0.82 ** 2) return 0;\n  return (u - 0.42) ** 2 + (v + 0.2) ** 2 \u003c 0.64 ** 2 ? 0 : 3;\n}\nconst SHAPES = [skull, eye, moon];\n// Which layer a vision's colour class draws in: lids, iris, bone.\nconst LAYER = [0, 3, 4, 2];\n\n// The two smoke hues along Hue, kept out of red, orange and yellow, which\n// go brown when the smoke thins.\nconst STOPS = [[0.78, 0.33], [0.66, 0.46], [0.88, 0.55], [0.95, 0.7], [0.55, 0.9]];\nfunction smokeHues(k) {\n  const f = cl(k, 0, 1) * 4, i = min(3, floor(f)), u = f - i;\n  return [0, 1].map((j) => STOPS[i][j] + (STOPS[i + 1][j] - STOPS[i][j]) * u);\n}\n\n// Targets on the 2-LED lattice the smoke is drawn on, so a vision's cells\n// tile it edge to edge: [x, y, class] relative to the ball's middle.\nfunction targets(shape) {\n  const cells = [];\n  for (let j = -24; j \u003c 24; j += 2)\n    for (let i = -24; i \u003c 24; i += 2) {\n      const a = shape((i + 1) / 20, (j + 1) / 20);\n      if (a) cells.push(i, j, a);\n    }\n  return cells;\n}\n\nexport function setup(params) {\n  const P = {\n    hue: 0, speed: 1, smoke: 0, rate: 0.06, share: 0.62, n: 0, t: 0, warm: false,\n    x: new Float32Array(MAXN), y: new Float32Array(MAXN), z: new Float32Array(MAXN),\n    age: new Float32Array(MAXN), life: new Float32Array(MAXN), sp: new Uint8Array(MAXN), lag: new Float32Array(MAXN),\n    slot: new Uint16Array(MAXN),\n    shapes: SHAPES.map(targets), vis: -1, vt: 0, next: 2, order: 0, glow: 0,\n    vc: 0, sparks: [], cw: [0, 1, 2, 3, 4].map(() => new Float32Array(GW * GH)), tmp: new Float32Array(GW * GH),\n  };\n  for (let i = 0; i \u003c MAXN; i++) {\n    P.sp[i] = Math.random() \u003c 0.55 ? 1 : 2;\n    P.lag[i] = Math.random();\n    P.slot[i] = floor(Math.random() * 65536);\n    spawn(P, i, Math.random());\n  }\n  params.s = P;\n}\n\n// A particle starts at one of two wells low in the ball, the purple one and\n// the green one across from it, both turning slowly round the middle.\nfunction spawn(P, i, age) {\n  const a = P.t * 0.35 + (P.sp[i] === 1 ? 0 : PI) + (Math.random() - 0.5) * 1.2, rr = (0.3 + 0.4 * Math.random()) * RIN;\n  P.x[i] = rr * cos(a);\n  P.z[i] = rr * sin(a);\n  P.y[i] = (0.4 + 0.3 * Math.random()) * RIN;\n  P.life[i] = 4.5 + 3.5 * Math.random();\n  P.age[i] = age * P.life[i];\n}\n\n// The flow inside the glass: a turn about the upright axis, a ring vortex\n// rising up the middle and sinking down the sides (Hill's vortex, which\n// never crosses the glass), and an ABC flow drifting in phase for the curls.\nfunction step(P, d) {\n  const t = P.t, om = 1.6, C = 14, Rq = RIN * RIN, k = 0.16;\n  const p1 = t * 0.7, p2 = t * 0.53 + 2, p3 = t * 0.47 + 4;\n  const s = P.vis >= 0 ? 1 - 0.7 * P.glow : 1;\n  for (let i = 0; i \u003c P.n; i++) {\n    let x = P.x[i], y = P.y[i], z = P.z[i];\n    const vx = -om * z - (C * x * y) / Rq + 8 * sin(k * z + p1) + 6 * cos(k * y + p2);\n    const vz = om * x - (C * z * y) / Rq + 8 * cos(k * x + p3) + 6 * sin(k * y + p1);\n    const vy = -C * (1 - (2 * (x * x + z * z) + y * y) / Rq) + 6 * sin(k * x + p2) + 8 * cos(k * z + p3);\n    x += vx * d;\n    y += vy * d;\n    z += vz * d;\n    const r = sqrt(x * x + y * y + z * z);\n    if (r > RIN) {\n      const f = RIN / r;\n      x *= f;\n      y *= f;\n      z *= f;\n    }\n    P.x[i] = x;\n    P.y[i] = y;\n    P.z[i] = z;\n    P.age[i] += d * s;\n    if (P.age[i] > P.life[i]) spawn(P, i, 0);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3) / 2;\n  P.smoke = cl(k[2], 0, 1);\n  P.rate = cl(k[3], 0, 1);\n  P.share = 0.6 + 0.4 * P.rate;\n  P.n = round(700 + 800 * P.smoke);\n  const real = cl(dt || 0, 0, 0.1), d = real * P.speed;\n  if (!P.warm) {\n    // Let the smoke fill the ball before the first frame.\n    P.warm = true;\n    for (let i = 0; i \u003c 120; i++) {\n      P.t += 0.05;\n      step(P, 0.05);\n    }\n  }\n  P.t += d;\n  P.vc += d;\n  step(P, d);\n\n  // Visions: gather 1.4 s, hold 1.4 to 2.6 s, let go over 1.6 s. The\n  // smoke ages slower while it is held.\n  const press = input.btnPressed && (input.btnPressed[0] || input.btnPressed[1] || input.btnPressed[2] || input.btnPressed[3]);\n  if (P.order === 0) P.next = 2.1 - 1.7 * P.rate;\n  if (P.vis \u003c 0 && (P.vc >= P.next || press)) {\n    P.vis = P.order \u003c 3 ? P.order : floor(Math.random() * 3);\n    P.order++;\n    P.vt = 0;\n    const cells = P.shapes[P.vis], m = cells.length / 3;\n    // The particles that join take the cells in turn, so every cell gets\n    // one before any gets two.\n    const idx = [];\n    for (let i = 0; i \u003c P.n; i++) idx.push(i);\n    for (let i = idx.length - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [idx[i], idx[j]] = [idx[j], idx[i]];\n    }\n    let q = 0;\n    for (const i of idx) if (P.lag[i] \u003c P.share) P.slot[i] = q++ % m;\n  }\n  if (P.vis >= 0) {\n    P.vt += d;\n    const hold = 1.4 + 1.2 * P.rate, end = 1.4 + hold + 1.6;\n    P.glow = P.vt \u003c 1.4 ? ease(P.vt / 1.4) : P.vt \u003c 1.4 + hold ? 1 : 1 - ease(cl((P.vt - 1.4 - hold) / 1.6, 0, 1));\n    if (P.vt > 1.4 && P.vt - d \u003c= 1.4)\n      for (let i = 0; i \u003c 26; i++) {\n        const a = Math.random() * 2 * PI;\n        P.sparks.push({ x: CX + R * cos(a), y: CY + R * sin(a), vx: cos(a) * 8, vy: sin(a) * 8 - 6, life: 0.8 + 0.8 * Math.random(), g: 1 });\n      }\n    if (P.vt > end) {\n      P.vis = -1;\n      P.glow = 0;\n      P.next = P.vc + 13 - 10 * P.rate;\n    }\n  }\n\n  // Sparks leave the top of the glass and drift up.\n  if (Math.random() \u003c 8 * d) {\n    const a = -PI / 2 + (Math.random() - 0.5) * 2.4;\n    P.sparks.push({ x: CX + (R + 1) * cos(a), y: CY + (R + 1) * sin(a), vx: (Math.random() - 0.5) * 3, vy: -5 - 5 * Math.random(), life: 1 + Math.random(), g: Math.random() \u003c 0.5 ? 1 : 0 });\n  }\n  for (const s of P.sparks) {\n    s.x += s.vx * d;\n    s.y += s.vy * d;\n    s.vx += sin(s.y * 0.3 + P.t * 3) * 6 * d;\n    s.life -= d;\n  }\n  P.sparks = P.sparks.filter((s) => s.life > 0 && s.y > -1);\n}\n\n// Blur one coarse layer with a 1-2-1 kernel each way.\nfunction blur(a, tmp) {\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      const p = y * GW + x;\n      tmp[p] = (2 * a[p] + (x > 0 ? a[p - 1] : 0) + (x \u003c GW - 1 ? a[p + 1] : 0)) / 4;\n    }\n  for (let y = 0; y \u003c GH; y++)\n    for (let x = 0; x \u003c GW; x++) {\n      const p = y * GW + x;\n      a[p] = (2 * tmp[p] + (y > 0 ? tmp[p - GW] : 0) + (y \u003c GH - 1 ? tmp[p + GW] : 0)) / 4;\n    }\n}\n\nconst put = (display, x, y, c) => {\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) display.setPixel(x, y, c[0], c[1], c[2]);\n};\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.warm) return;\n  const cw = P.cw;\n  const vis = P.vis, cells = vis >= 0 ? P.shapes[vis] : null, G = P.glow;\n  // Smoke on 2x2-LED cells. A vision takes a share of the particles that\n  // grows with Visions; each comes a little earlier or later than the next.\n  const share = P.share;\n  // Held, a vision bobs a cell up and down; the skull's jaw chatters and the\n  // eye blinks once.\n  const vt = P.vt - 1.4, hold = 1.4 + 1.2 * P.rate;\n  const bob = 2 * round(sin(P.vt * 4)), jaw = vt > 0 && sin(vt * 14) > 0.2 ? 2 : 0;\n  const blink = vt > 0 ? max(0, 1 - abs(vt - hold * 0.6) / 0.18) : 0;\n  for (const c of P.cw) c.fill(0);\n  const raw = [];\n  for (let i = 0; i \u003c P.n; i++) {\n    let x = P.x[i], y = P.y[i];\n    const a = P.age[i] / P.life[i];\n    let w = (0.55 + 0.45 * cl((P.z[i] / RIN + 1) / 2, 0, 1)) * min(1, a / 0.12, (1 - a) / 0.3);\n    let cls = P.sp[i] - 1;\n    if (cells && P.lag[i] >= share) w *= 1 - 0.5 * G;\n    if (cells && P.lag[i] \u003c share) {\n      const s = ease(cl(G * 1.5 - (0.5 * P.lag[i]) / share, 0, 1));\n      if (s > 0) {\n        const c = (P.slot[i] % (cells.length / 3)) * 3;\n        let ty = cells[c + 1];\n        if (vis === 0 && ty >= 10) ty += jaw;\n        if (vis === 1) ty = 2 * round((ty * (1 - blink)) / 2);\n        x += (cells[c] + 1 - x) * s;\n        y += (ty + bob + 1 - y) * s;\n        w += (1.4 - w) * s;\n        if (s > 0.5) cls = LAYER[cells[c + 2]];\n      }\n    }\n    const gx = floor((CX + x) / 2), gy = floor((CY + y) / 2);\n    if (gx >= 0 && gx \u003c GW && gy >= 0 && gy \u003c GH) cw[cls][gy * GW + gx] += w;\n  }\n  // The free smoke is blurred into soft blobs; a vision stands sharp.\n  for (let k = 0; k \u003c 5; k++) {\n    const c = cw[k];\n    if (G > 0) raw[k] = c.slice();\n    blur(c, P.tmp);\n    if (G > 0) for (let p = 0; p \u003c c.length; p++) c[p] += (raw[k][p] - c[p]) * G;\n  }\n  // Colours: the two smokes in four levels, bone for visions; a vision's\n  // lids and iris stay saturated.\n  const [hA, hB] = smokeHues(P.hue);\n  const PUR = [hsv(hA, 0.85, 0.36), hsv(hA, 0.82, 0.6), hsv(hA + 0.01, 0.66, 0.84), hsv(hA + 0.02, 0.36, 1)];\n  const GRN = [hsv(hB, 0.9, 0.36), hsv(hB - 0.01, 0.9, 0.6), hsv(hB - 0.03, 0.78, 0.86), hsv(hB - 0.05, 0.4, 1)];\n  const BONE = [hsv(hB, 0.3, 0.4), hsv(hB, 0.25, 0.65), hsv(hB - 0.02, 0.18, 0.88), [244, 255, 232]];\n  const PAL = [PUR, GRN, BONE, [PUR[0], PUR[1], PUR[2], PUR[2]], [GRN[0], GRN[1], GRN[2], GRN[2]]];\n  const GLASS = hsv(hA - 0.03, 0.75, 0.12), RIM = hsv(hA - 0.04, 0.5, 0.36);\n  let sumP = 0, sumG = 0;\n\n  // The ball.\n  for (let y = CY - R - 1; y \u003c= CY + R + 1; y++)\n    for (let x = CX - R - 1; x \u003c= CX + R + 1; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);\n      if (r > R + 0.5) continue;\n      if (r > R - 0.6) {\n        put(display, x, y, RIM);\n        continue;\n      }\n      const p = (y >> 1) * GW + (x >> 1);\n      let w = 0, top = 0, best = 0;\n      for (let k = 0; k \u003c 5; k++) {\n        const v = cw[k][p];\n        w += v;\n        if (v > best) (best = v), (top = k);\n      }\n      sumP += cw[0][p];\n      sumG += cw[1][p];\n      let col = GLASS;\n      if (w >= 0.3) col = PAL[top][w \u003c 0.75 ? 0 : w \u003c 1.4 ? 1 : w \u003c 2.3 ? 2 : 3];\n      put(display, x, y, col);\n    }\n  // The highlight: an arc high on the left and a small glint.\n  for (let y = CY - R; y \u003c CY; y++)\n    for (let x = CX - R; x \u003c CX; x++) {\n      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy), an = Math.atan2(dy, dx);\n      if (r > R - 4.6 && r \u003c R - 2.4 && an > -2.75 && an \u003c -1.95) display.setPixel(x, y, 200, 196, 228);\n    }\n  for (const [x, y] of [[13, 44], [14, 44], [13, 45], [16, 41]]) display.setPixel(x, y, 236, 236, 252);\n\n  // Light under the ball: the smoke's colour, brighter in a vision.\n  const gmix = sumG / max(1e-6, sumP + sumG), lit = 0.55 + 0.45 * G;\n  const tint = hsv(gmix > 0.5 ? hB : hA, 0.75, 1);\n  // The table: a pool of light in three rings, then the stand on it.\n  for (let y = 100; y \u003c 118; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const e = ((x + 0.5 - CX) / 30) ** 2 + ((y + 0.5 - 104) / 7) ** 2;\n      if (e >= 1) continue;\n      const v = lit * (e \u003c 0.25 ? 0.5 : e \u003c 0.6 ? 0.32 : 0.18);\n      put(display, x, y, [round((tint[0] * v) / 4) * 4, round((tint[1] * v) / 4) * 4, round((tint[2] * v) / 4) * 4]);\n    }\n  drawStand(display, G);\n\n  // A faint ring round the glass while a vision holds.\n  if (G > 0.3)\n    for (let a = 0; a \u003c 2 * PI; a += 0.02) {\n      const c = G > 0.8 ? BONE[1] : PUR[0];\n      put(display, floor(CX + (R + 2) * cos(a)), floor(CY + (R + 2) * sin(a)), c);\n    }\n  for (const s of P.sparks) {\n    const c = s.life \u003c 0.3 ? (s.g ? GRN[1] : PUR[1]) : s.g ? GRN[3] : PUR[3];\n    put(display, floor(s.x), floor(s.y), c);\n  }\n}\n\n// The brass stand: a cup round the bottom of the glass, a neck and a foot,\n// lit from the left in three tones, its top edge catching the ball's light.\nconst BRASS = [[244, 204, 96], [184, 128, 40], [112, 72, 24]];\nfunction drawStand(display) {\n  const rows = [];\n  for (let y = 80; y \u003c= 91; y++) rows.push([y, 19 - ((y - 80) * 7) / 11]);\n  for (let y = 92; y \u003c= 95; y++) rows.push([y, 6]);\n  for (let y = 96; y \u003c= 103; y++) rows.push([y, y === 96 ? 8 : 10 + ((y - 97) * 7) / 6]);\n  for (const [y, hw] of rows) {\n    const x0 = round(CX - hw), x1 = round(CX + hw);\n    for (let x = x0; x \u003c x1; x++) {\n      const u = (x + 0.5 - CX) / hw;\n      let t = u \u003c -0.35 ? 0 : u \u003c 0.45 ? 1 : 2;\n      if (y === 80 || y === 92 || y === 97) t = max(0, t - 1);\n      if (y === 91 || y === 95 || y === 103) t = 2;\n      put(display, x, y, BRASS[t]);\n    }\n  }\n}\n","ham-sandwich":"// ===== Patternflow pattern =====\n// Title:   Ham Sandwich\n// Family:  topology\n// Idea:    Two clouds of 4,401 crumbs each, cyan bread and magenta ham, drift round each other, stretch, split and merge, and every frame one straight knife through one crumb of each leaves 2,200 of each cloud on either side, the crumbs on one side lit bright and on the other dim.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: ham sandwich theorem (Arthur Stone and John Tukey, 1942)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..6, Thin=0..1, Scatter=0..1\n//\n// Knob 1: Hue. The two clouds' colours. At 0 the bread is cyan and the ham magenta, at 0.14 azure and rose, at 0.64 green and blue, and back to cyan and magenta at 1. They stay between green and rose because red, orange and yellow turn brown on the dim side of the knife.\n// Knob 2: Speed. At 2 the clouds go once round each other in 10 seconds and each cloud's two lobes part and meet again every 7.7 seconds; at 0.2 everything takes ten times as long, at 6 a third as long.\n// Knob 3: Thin. Crumbs in each cloud, always an odd number: 4,401 at 0, 2,401 at 0.5, 401 at 1. At 0 the clouds fill the panel with a checkerboard stipple; at 1 the crumbs stand apart and the knife can be seen to pass between them.\n// Knob 4: Scatter. The share of crumbs that leave their cloud for a place of their own anywhere on the panel: about 4% at the start, all of them at 1, when bread and ham are two even sprinklings over the whole panel and the knife still halves both.\n\nconst W = 64, H = 128;\nconst { floor, round, min, abs, sqrt, sin, cos, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Crumbs in each cloud at Thin 0 and at Thin 1.\nconst NMAX = 4401, NMIN = 401;\n// The bread's hue sweeps HUE_LO..HUE_LO + HUE_SPAN as Hue turns, cyan (0.52)\n// at Hue 0; the ham stays GAP round the wheel from it.\nconst HUE_LO = 0.32, HUE_SPAN = 0.28, GAP = 0.34, HUE_U0 = 0.357;\n// Level of a crumb on the bright side and the dim side of the knife.\nconst BRIGHT = 1, DIM = 0.38;\n// Level of the glow round a crumb on the bright side.\nconst GLOW = 0.4;\n// Half width of the knife in LEDs.\nconst KNIFE = 2.0;\n// One orbit of the two clouds round each other, in seconds at Speed 2, and\n// the orbit's half axes in LEDs.\nconst ORBIT = 10, RX = 13, RY = 32;\n// The orbit's angle at the start.\nconst PHASE0 = -0.9 * PI;\n// Most distance between a cloud's two lobes, in LEDs.\nconst SPLIT = 26;\n// A lobe's half axes in LEDs: long LA +- LA1, short LB +- LB1; how far its rim frays.\nconst LA = 32, LA1 = 5, LB = 21, LB1 = 3, FRAY = 0.3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A crumb's place in its lobe: even over the unit disk, its rim frayed.\nfunction inDisk() {\n  const r = sqrt(Math.random()) * (1 + FRAY * (Math.random() + Math.random() - 1)), a = TAU * Math.random();\n  return [r * cos(a), r * sin(a)];\n}\n\nfunction cloud() {\n  const C = {\n    gx: new Float32Array(NMAX), gy: new Float32Array(NMAX), w: new Float32Array(NMAX), lobe: new Uint8Array(NMAX),\n    ux: new Float32Array(NMAX), uy: new Float32Array(NMAX), rank: new Float32Array(NMAX), ph: new Float32Array(NMAX),\n    x: new Float64Array(NMAX), y: new Float64Array(NMAX), lobes: [new Float64Array(6), new Float64Array(6)],\n  };\n  for (let i = 0; i \u003c NMAX; i++) {\n    const [a, b] = inDisk();\n    C.gx[i] = a;\n    C.gy[i] = b;\n    C.w[i] = (0.15 + 0.35 * Math.random()) * (Math.random() \u003c 0.5 ? -1 : 1);\n    C.lobe[i] = Math.random() \u003c 0.5 ? 1 : 0;\n    C.ux[i] = Math.random() * W;\n    C.uy[i] = Math.random() * H;\n    C.rank[i] = Math.random();\n    C.ph[i] = Math.random() * TAU;\n  }\n  return C;\n}\n\nexport function setup(params) {\n  params.s = {\n    A: cloud(), B: cloud(), nA: NMAX, nB: NMAX, tau: 0, hue: 0, scatter: 0.06, th: 0,\n    proj: new Float64Array(NMAX), idx: new Int32Array(NMAX), idxN: 0, m: 0, med: 0,\n    line: { ax: 0, ay: 0, nx: 1, ny: 0, ia: 0, ib: 0 },\n    rgb: new Float32Array(W * H * 3), c: new Float32Array(12),\n  };\n}\n\nconst odd = (v) => {\n  const n = round(v);\n  return n % 2 ? n : n + 1;\n};\n\n// Place the crumbs of cloud C (centre cx, cy) at time tau.\nfunction place(C, n, cx, cy, tau, k, scatter) {\n  const split = SPLIT * (0.5 - 0.5 * cos((TAU * tau) / 7.7 + k * 2.1));\n  const beta = (TAU * tau) / 17 + k * 1.3;\n  const dx = 0.5 * split * cos(beta), dy = 0.5 * split * sin(beta);\n  for (let L = 0; L \u003c 2; L++) {\n    // Each lobe is a disk stretched to an ellipse that breathes and turns.\n    const sa = LA + LA1 * sin((TAU * tau) / 9.1 + k + L * 2), sb = LB + LB1 * sin((TAU * tau) / 6.3 + 2 * k + L);\n    const phi = (TAU * tau) / 13 + k * 0.7 + L * 1.9;\n    C.lobes[L].set([cx + (L ? dx : -dx), cy + (L ? dy : -dy), sa, sb, cos(phi), sin(phi)]);\n  }\n  for (let i = 0; i \u003c n; i++) {\n    // Each crumb also circles inside its lobe at its own pace.\n    const [lx, ly, sa, sb, pc, ps] = C.lobes[C.lobe[i]];\n    const sw = C.w[i] * tau, swc = cos(sw), sws = sin(sw);\n    const gx = C.gx[i] * swc - C.gy[i] * sws, gy = C.gx[i] * sws + C.gy[i] * swc;\n    const ex = gx * sa, ey = gy * sb;\n    let x = lx + ex * pc - ey * ps, y = ly + ex * ps + ey * pc;\n    const u = sm((1.04 * scatter - C.rank[i]) / 0.04);\n    if (u > 0) {\n      const sx = C.ux[i] + 6 * sin(0.4 * tau + C.ph[i]), sy = C.uy[i] + 10 * cos(0.3 * tau + C.ph[i]);\n      x += (sx - x) * u;\n      y += (sy - y) * u;\n    }\n    // Mirror back off the panel's edges.\n    if (x \u003c 0) x = -x;\n    if (x >= W) x = 2 * W - x;\n    if (y \u003c 0) y = -y;\n    if (y >= H) y = 2 * H - y;\n    C.x[i] = cl(x, 0.001, W - 0.001);\n    C.y[i] = cl(y, 0.001, H - 0.001);\n  }\n}\n\n// The index of the k-th smallest key among idx[0..n-1] (Hoare's select).\nfunction select(idx, key, n, k) {\n  let lo = 0, hi = n - 1;\n  while (hi > lo) {\n    const pv = key[idx[(lo + hi) >> 1]];\n    let i = lo, j = hi;\n    while (i \u003c= j) {\n      while (key[idx[i]] \u003c pv) i++;\n      while (key[idx[j]] > pv) j--;\n      if (i \u003c= j) {\n        const t = idx[i];\n        idx[i] = idx[j];\n        idx[j] = t;\n        i++;\n        j--;\n      }\n    }\n    if (k \u003c= j) hi = j;\n    else if (k >= i) lo = i;\n    else break;\n  }\n  return idx[k];\n}\n\n// For the normal at angle th: the bread crumb at the median of the\n// projections (left in S.m, its projection in S.med), and how many ham\n// crumbs lie above the line through it minus how many lie below. idx keeps\n// last call's order, so the select starts nearly done.\nfunction halve(S, th) {\n  const { A, B, nA, nB, proj, idx } = S, c = cos(th), s = sin(th), ax = A.x, ay = A.y, bx = B.x, by = B.y;\n  for (let i = 0; i \u003c nA; i++) proj[i] = c * ax[i] + s * ay[i];\n  const m = select(idx, proj, nA, (nA - 1) >> 1), med = proj[m];\n  let g = 0;\n  for (let j = 0; j \u003c nB; j++) {\n    const v = c * bx[j] + s * by[j] - med;\n    g += v > 0 ? 1 : v \u003c 0 ? -1 : 0;\n  }\n  S.m = m;\n  S.med = med;\n  return g;\n}\n\n// The cut, searched for near last frame's angle so the knife does not jump\n// from one cut to another. g(th + pi) = -g(th), so g changes sign within\n// pi/2 of any angle.\nconst STEPS = [0.02, 0.06, 0.15, 0.35, 0.8, PI / 2];\nfunction cut(S) {\n  if (S.idxN !== S.nA) {\n    for (let i = 0; i \u003c S.nA; i++) S.idx[i] = i;\n    S.idxN = S.nA;\n  }\n  let lo = S.th, hi = NaN;\n  const g0 = halve(S, lo);\n  if (g0 === 0) return finish(S, lo, lo);\n  outer: for (const sgn of [1, -1]) {\n    let prev = lo;\n    for (const d of STEPS) {\n      const t = S.th + sgn * d, g = halve(S, t);\n      if (g === 0) return finish(S, t, t);\n      if (g * g0 \u003c 0) {\n        (lo = prev), (hi = t);\n        break outer;\n      }\n      prev = t;\n    }\n  }\n  if (hi !== hi) hi = lo + PI;\n  // Halve the bracket until it is narrow, then until the median bread crumb\n  // is the same at both ends and one ham crumb crosses between them.\n  for (let it = 0; it \u003c 80; it++) {\n    if (abs(hi - lo) \u003c 2e-6 && finish(S, lo, hi)) return;\n    const mid = 0.5 * (lo + hi), g = halve(S, mid);\n    if (g === 0) return finish(S, mid, mid);\n    if (g * g0 > 0) lo = mid;\n    else hi = mid;\n  }\n  finish(S, lo, hi, true);\n}\n\n// Between th0 and th1 the line through the median bread crumb turns across\n// one ham crumb. The knife is the line through those two crumbs.\nfunction finish(S, th0, th1, force) {\n  const { A, B, nB } = S;\n  halve(S, th0);\n  const m0 = S.m, med0 = S.med;\n  halve(S, th1);\n  const m1 = S.m, med1 = S.med;\n  const c0 = cos(th0), s0 = sin(th0), c1 = cos(th1), s1 = sin(th1);\n  let ib = -1, crossed = 0, best = 1e9;\n  for (let j = 0; j \u003c nB; j++) {\n    const v0 = c0 * B.x[j] + s0 * B.y[j] - med0, v1 = c1 * B.x[j] + s1 * B.y[j] - med1;\n    if (v0 * v1 \u003c= 0) {\n      crossed++;\n      if (best > 0) (best = 0), (ib = j);\n    } else if (min(abs(v0), abs(v1)) \u003c best) (best = min(abs(v0), abs(v1))), (ib = j);\n  }\n  if (!force && (m0 !== m1 || crossed !== 1)) return false;\n  const th = 0.5 * (th0 + th1), ia = m0;\n  const ax = A.x[ia], ay = A.y[ia], bx = B.x[ib], by = B.y[ib];\n  let nx = cos(th), ny = sin(th);\n  const L = sqrt((bx - ax) ** 2 + (by - ay) ** 2);\n  if (L > 1e-6) {\n    // The normal of the line through both crumbs, turned to face like th's.\n    let qx = -(by - ay) / L, qy = (bx - ax) / L;\n    if (qx * nx + qy * ny \u003c 0) (qx = -qx), (qy = -qy);\n    (nx = qx), (ny = qy);\n  }\n  S.th = th;\n  Object.assign(S.line, { ax, ay, nx, ny, ia, ib });\n  return true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.tau += (d * cl(k[1], 0.2, 6)) / 2;\n  S.nA = S.nB = odd(NMAX - (NMAX - NMIN) * cl(k[2], 0, 1));\n  S.scatter = cl(k[3], 0, 1);\n  const w = PHASE0 + (TAU * S.tau) / ORBIT + 0.35 * sin((TAU * S.tau) / 23);\n  const rx = RX + 3 * sin((TAU * S.tau) / 11), ry = RY + 5 * sin((TAU * S.tau) / 14.5);\n  place(S.A, S.nA, W / 2 + rx * cos(w), H / 2 + ry * sin(w), S.tau, 0, S.scatter);\n  place(S.B, S.nB, W / 2 - rx * cos(w), H / 2 - ry * sin(w), S.tau, 1, S.scatter);\n  cut(S);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, c, A, B, nA, nB, line } = S;\n  rgb.fill(0);\n  // Hue runs the bread up and down HUE_LO..HUE_LO + HUE_SPAN and the ham\n  // GAP behind it, both between green and pink: red, orange and yellow\n  // turn brown on the dim side.\n  const u = (S.hue + HUE_U0) % 1, ha = HUE_LO + HUE_SPAN * (1 - abs(2 * u - 1)), hb = ha + GAP;\n  hsv(ha, 0.85, BRIGHT, c, 0);\n  hsv(ha, 0.9, DIM, c, 3);\n  hsv(hb, 0.75, BRIGHT, c, 6);\n  hsv(hb, 0.9, DIM, c, 9);\n  const { ax, ay, nx, ny } = line;\n  // Crumbs sit on the white squares of a checkerboard of LEDs (x + y even);\n  // one off it steps to the nearer neighbour on it. A crumb on the bright\n  // side lights its four neighbours at GLOW.\n  const spot = (C, i) => {\n    const x = C.x[i], y = C.y[i];\n    let X = x | 0, Y = y | 0;\n    if ((X + Y) & 1) {\n      const fx = x - X - 0.5, fy = y - Y - 0.5;\n      if (abs(fx) > abs(fy)) X += fx > 0 ? (X \u003c W - 1 ? 1 : -1) : X > 0 ? -1 : 1;\n      else Y += fy > 0 ? (Y \u003c H - 1 ? 1 : -1) : Y > 0 ? -1 : 1;\n    }\n    return Y * W + X;\n  };\n  const glow = (C, n, o) => {\n    const r = c[o] * GLOW, g = c[o + 1] * GLOW, b = c[o + 2] * GLOW;\n    const put = (p) => {\n      (rgb[3 * p] = r), (rgb[3 * p + 1] = g), (rgb[3 * p + 2] = b);\n    };\n    for (let i = 0; i \u003c n; i++) {\n      if (nx * (C.x[i] - ax) + ny * (C.y[i] - ay) \u003c= 0) continue;\n      const p = spot(C, i), X = p % W;\n      if (X > 0) put(p - 1);\n      if (X \u003c W - 1) put(p + 1);\n      if (p >= W) put(p - W);\n      if (p \u003c W * (H - 1)) put(p + W);\n    }\n  };\n  const dot = (C, n, o) => {\n    for (let i = 0; i \u003c n; i++) {\n      const q = nx * (C.x[i] - ax) + ny * (C.y[i] - ay) > 0 ? o : o + 3, p = spot(C, i) * 3;\n      rgb[p] = c[q];\n      rgb[p + 1] = c[q + 1];\n      rgb[p + 2] = c[q + 2];\n    }\n  };\n  glow(A, nA, 0);\n  glow(B, nB, 6);\n  dot(A, nA, 0);\n  dot(B, nB, 6);\n  // The knife.\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p += 3) {\n      const dd = abs(nx * (x + 0.5 - ax) + ny * (y + 0.5 - ay));\n      if (dd \u003c KNIFE) (rgb[p] = 1), (rgb[p + 1] = 0.95), (rgb[p + 2] = 0.8);\n    }\n  // The two crumbs the knife passes through: white, in a hole in the blade\n  // ringed in their cloud's colour.\n  for (const [C, i, o] of [[A, line.ia, 0], [B, line.ib, 6]]) {\n    const p0 = spot(C, i), x = p0 % W, y = (p0 - x) / W;\n    for (let v = -3; v \u003c= 3; v++)\n      for (let u = -3; u \u003c= 3; u++) {\n        const r = u * u + v * v, X = x + u, Y = y + v;\n        if (r > 13 || X \u003c 0 || X >= W || Y \u003c 0 || Y >= H) continue;\n        const p = (Y * W + X) * 3, m = r === 0 ? -1 : r \u003c 7 ? 0 : 1;\n        rgb[p] = m \u003c 0 ? 1 : c[o] * m;\n        rgb[p + 1] = m \u003c 0 ? 1 : c[o + 1] * m;\n        rgb[p + 2] = m \u003c 0 ? 1 : c[o + 2] * m;\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, rgb[o] * 255, rgb[o + 1] * 255, rgb[o + 2] * 255);\n}\n","haunted-swing":"// ===== Patternflow pattern =====\n// Title:   Haunted Swing\n// Family:  halloween\n// Idea:    An empty swing set seen from the side on a purple night, a plank swing on 100 LEDs of chain swinging by itself as a lightly damped pendulum, a glowing hand of mist now and then shoving it on as it passes the bottom, and the smaller swing behind it on the same crossbar starting to move on its own as the shared bar hands the motion over and back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Coupling=0.2..1, Haunt=0..1\n//\n// Knob 1: Hue. The ghost's light and the night with it. At 0 a toxic green hand in a purple night with lilac moonlight on the metal; at 0.25 cold white in deep blue; at 0.5 violet in dark teal with pale aqua moonlight; at 0.75 pumpkin orange in indigo.\n// Knob 2: Speed. The clock of the scene. At 2 a swing takes 2.6 s to go out and back; at 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Coupling. How strongly the shared bar ties the two swings, as the time the near swing takes to hand all its motion to the one behind: 9 s at 0.2, 3.7 s at 0.5 and 1.6 s at 1 (at Speed 2). At 0.2 the swing behind starts still, and after the first push it swings 15 degrees by 8 s while the near one falls from 17 to 8.\n// Knob 4: Haunt. How often and how hard the hand comes, and how much of the ghost stays. After a hand has faded the next comes in 8 to 11 s at 0, 7.6 to 10.5 s at 0.06 and 2 to 3 s at 1, pushing twice as hard there, and three times in ten for the swing behind. The seats' after-image lasts 0.9 s at 0.06 and 2 s at 1, where a cold glow also sits on each seat. The first hand comes at 2.2 to 3.5 s at Speed 2 whatever the knob.\n\nconst W = 64, H = 128;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The pendulum, in seconds at Speed 2: angular frequency for a 2.6 s swing,\n// damping (a swing left alone loses half its energy in 15 s), and the\n// half beat of the coupling through the bar at Coupling 1: the two swings\n// trade their motion in 1.8 s there, and in 9 s at 0.2.\nconst OM = (2 * PI) / 2.6, GAM = 0.046, HALF = 1.8;\n// The coupling constant that splits the two swings' frequencies by dw.\nconst kappa = (dw) => ((OM + dw) ** 2 - OM * OM) / 2;\n// The largest swing a push may give, in radians.\nconst AMAX = 0.32;\n// The near swing in LEDs: pivot and the distance from pivot to seat. Swings\n// farther back are the near one scaled by DEPTH about the point VP, so each\n// hangs a little higher and to the right, a fifth smaller.\nconst PX = 31, PY = 9, LEN = 100, DEPTH = 0.82, VPX = 64, VPY = 0;\n// Seconds a push lasts, and its hand fades after.\nconst PUSH = 0.5, FADE = 1.6;\n// Along Hue: the ghost's light (toxic green, cold white, violet, pumpkin,\n// green), the night behind it at its glow over the ground (purple, deep\n// blue, dark teal, indigo, purple) and the moonlight on the metal and the\n// seats (lilac, ice, pale aqua, lavender, lilac).\nconst TINTS = [[0.45, 1, 0.2], [0.78, 0.92, 1], [0.72, 0.42, 1], [1, 0.5, 0.08], [0.45, 1, 0.2]];\nconst NIGHTS = [[0.2, 0.04, 0.25], [0.03, 0.07, 0.3], [0, 0.16, 0.2], [0.12, 0.03, 0.3], [0.2, 0.04, 0.25]];\nconst MOONS = [[0.84, 0.78, 1], [0.7, 0.86, 1], [0.66, 1, 0.9], [0.88, 0.74, 1], [0.84, 0.78, 1]];\n// The moon, top left, and the stars.\nconst MX = 12, MY = 21, MR = 5;\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 12; i++) {\n  const x = floor(hash(i * 3 + 7) * W), y = floor(hash(i * 3 + 8) * 70);\n  if ((x - MX) ** 2 + (y - MY) ** 2 > 140) STARS.push([x, y, hash(i * 3 + 9) * 6.28]);\n}\n// The sky by row, black at the top and the night's colour towards the\n// ground, in five bands.\nconst SKY = new Float32Array(H);\nfor (let y = 0; y \u003c H; y++) SKY[y] = round(cl((y - 30) / 90, 0, 1) ** 1.6 * 5) / 5;\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: 0, speed: 2, couple: 0.2, haunt: 0.06,\n    // Angle and angular speed of the near swing (0) and the one behind (1).\n    t: 0, th: new Float64Array(2), om: new Float64Array(2),\n    // Seconds to the next push, and the one under way.\n    wait: 2.2, push: null,\n    // Recent angles, for the after-image of the seats.\n    trail: [], rgb: new Float32Array(W * H * 3), tint: [0.45, 1, 0.2], night: [0.2, 0.04, 0.25], moon: [0.84, 0.78, 1],\n  };\n}\n\nconst scaleOf = (j) => DEPTH ** j;\nconst pivot = (j) => [VPX + (PX - VPX) * scaleOf(j), VPY + (PY - VPY) * scaleOf(j)];\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 2, 0.06];\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.couple = cl(k[2], 0.2, 1);\n  S.haunt = cl(k[3], 0, 1);\n  if (!S.begun) {\n    S.begun = true;\n    // The near swing is already moving when the picture opens, more the\n    // more haunted the night.\n    S.th[0] = 0.21 + 0.09 * S.haunt;\n  }\n  const ds = (cl(dt || 0, 0, 0.1) * S.speed) / 2;\n  S.t += ds;\n  // Pushes: when one is due, the hand comes for the near swing, or now and\n  // then, with Haunt, for the one at the back.\n  const P = S.push;\n  if (!P) {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) {\n      const j = Math.random() \u003c 0.3 * S.haunt ? 1 : 0;\n      S.push = { j, age: -1, dir: 0, last: S.th[j], at: null };\n    }\n  } else if (P.age \u003c 0) {\n    // The hand waits for the seat to pass the bottom of its arc, and shoves\n    // it on from behind, the way it is going.\n    const th = S.th[P.j];\n    if ((th \u003c= 0 && P.last > 0) || (th >= 0 && P.last \u003c 0) || abs(th) + abs(S.om[P.j]) \u003c 0.02) {\n      P.age = 0;\n      P.dir = S.om[P.j] >= 0 ? 1 : -1;\n    }\n    P.last = th;\n  } else {\n    P.age += ds;\n    if (P.age > PUSH + FADE) {\n      S.push = null;\n      const h = S.haunt;\n      S.wait = 8 - 6 * h + (3 - 2 * h) * Math.random();\n    }\n  }\n  // The pendulums in small steps: the large-angle equation with light\n  // damping, each swing pulled towards its neighbours through the bar.\n  const steps = max(1, ceil(ds / 0.004)), h = ds / steps, KAP = kappa((PI / HALF) * S.couple);\n  for (let i = 0; i \u003c steps; i++) {\n    for (let j = 0; j \u003c 2; j++) {\n      let a = -OM * OM * sin(S.th[j]) - GAM * S.om[j];\n      a += KAP * (S.th[1 - j] - S.th[j]);\n      const Q = S.push;\n      if (Q && Q.j === j && Q.age >= 0 && Q.age \u003c PUSH) {\n        // The push gives out as the swing nears the largest swing allowed.\n        const e = (S.om[j] / OM) ** 2 + 2 * (1 - cos(S.th[j]));\n        a += Q.dir * (3 + 3 * S.haunt) * cl(1 - e / (AMAX * AMAX), 0, 1);\n      }\n      S.om[j] += a * h;\n    }\n    for (let j = 0; j \u003c 2; j++) S.th[j] += S.om[j] * h;\n  }\n  S.trail.push([S.t, S.th[0], S.th[1]]);\n  while (S.trail.length && S.t - S.trail[0][0] > 2) S.trail.shift();\n}\n\n// --- drawing -------------------------------------------------------------\n\nfunction put(rgb, x, y, c, f) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = 3 * (y * W + x);\n  rgb[o] = c[0] * f;\n  rgb[o + 1] = c[1] * f;\n  rgb[o + 2] = c[2] * f;\n}\nfunction glow(rgb, x, y, c, f) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = 3 * (y * W + x);\n  rgb[o] = max(rgb[o], c[0] * f);\n  rgb[o + 1] = max(rgb[o + 1], c[1] * f);\n  rgb[o + 2] = max(rgb[o + 2], c[2] * f);\n}\n// A capsule of radius r round a-b with a hard edge. fn(x, y, u) paints a\n// covered LED, u the share of the way from a to b.\nfunction capsule(ax, ay, bx, by, r, fn) {\n  const ex = bx - ax, ey = by - ay, L2 = ex * ex + ey * ey || 1;\n  for (let y = max(0, floor(min(ay, by) - r)); y \u003c= min(H - 1, ceil(max(ay, by) + r)); y++)\n    for (let x = max(0, floor(min(ax, bx) - r)); x \u003c= min(W - 1, ceil(max(ax, bx) + r)); x++) {\n      const qx = x + 0.5 - ax, qy = y + 0.5 - ay, u = cl((qx * ex + qy * ey) / L2, 0, 1);\n      if ((qx - u * ex) ** 2 + (qy - u * ey) ** 2 \u003c= r * r) fn(x, y, u);\n    }\n}\nconst fill = (rgb, c, f) => (x, y) => put(rgb, x, y, c, f);\n\nconst PIPE = [0.17, 0.13, 0.27];\nconst mul = (c, f) => [c[0] * f, c[1] * f, c[2] * f];\n\n// Where swing j's seat is at angle th, and the way along it.\nfunction seatOf(j, th) {\n  const s = scaleOf(j), [px, py] = pivot(j);\n  return [px + sin(th) * LEN * s, py + cos(th) * LEN * s, cos(th), -sin(th)];\n}\n\n// One swing seen from the side: a chain from the bar, two hangers spread to\n// the ends of the seat, and the seat, a plank seen edge on, top lit.\nfunction drawSwing(rgb, C, j, th, f) {\n  const s = scaleOf(j), [px, py] = pivot(j), [cx, cy, vx, vy] = seatOf(j, th);\n  const ux = sin(th), uy = cos(th), half = 9 * s;\n  const kx = px + ux * (LEN - 17) * s, ky = py + uy * (LEN - 17) * s;\n  const len = (LEN - 17) * s, r = j ? 0.6 : 0.9;\n  // Links: every other two LEDs of chain catch the moon, and one glint\n  // runs up and down the chain as its angle to the moon changes.\n  const g = (0.45 + 2.4 * th) * len;\n  capsule(px, py, kx, ky, r, (x, y, u) => put(rgb, x, y, abs(u * len - g) \u003c 2 ? C.glint : floor((u * len) / 2) % 2 ? C.linkDim : C.link, f));\n  for (const e of [-1, 1]) capsule(kx, ky, cx + e * vx * half, cy + e * vy * half, 0.6, (x, y, u) => put(rgb, x, y, floor(u * 8) % 2 ? C.linkDim : C.link, f));\n  const t = max(1, 2.1 * s);\n  capsule(cx - vx * half, cy - vy * half, cx + vx * half, cy + vy * half, t, fill(rgb, C.seat, f));\n  capsule(cx - vx * half - ux * t * 0.6, cy - vy * half - uy * t * 0.6, cx + vx * half - ux * t * 0.6, cy + vy * half - uy * t * 0.6, 0.6, fill(rgb, C.seatLit, f));\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb, T = S.tint, N = S.night, M = S.moon, hn = S.haunt;\n  const hk = S.hue * (TINTS.length - 1), i0 = min(TINTS.length - 2, floor(hk)), ht = hk - i0;\n  for (let c = 0; c \u003c 3; c++) {\n    T[c] = TINTS[i0][c] + (TINTS[i0 + 1][c] - TINTS[i0][c]) * ht;\n    N[c] = NIGHTS[i0][c] + (NIGHTS[i0 + 1][c] - NIGHTS[i0][c]) * ht;\n    M[c] = MOONS[i0][c] + (MOONS[i0 + 1][c] - MOONS[i0][c]) * ht;\n  }\n  const C = { pipe: PIPE, pipeLit: mul(M, 0.6), link: mul(M, 0.78), linkDim: mul(M, 0.4), seat: mul(M, 0.16), seatLit: mul(M, 1), glint: [1, 1, 1] };\n  // Sky, moon and its rings.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = 3 * (y * W + x), d = sqrt((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2);\n      let R = 0.012 + N[0] * SKY[y], G = 0.004 + N[1] * SKY[y], B = 0.035 + N[2] * SKY[y];\n      if (d \u003c MR) {\n        R = 0.95 * M[0];\n        G = 0.95 * M[1];\n        B = 0.95 * M[2];\n      }\n      else {\n        const g = d \u003c MR + 2 ? 0.16 : d \u003c MR + 5 ? 0.08 : 0;\n        R += g;\n        G += g;\n        B += g * 1.2;\n      }\n      rgb[o] = R;\n      rgb[o + 1] = G;\n      rgb[o + 2] = B;\n    }\n  for (const [x, y, ph] of STARS) glow(rgb, x, y, [0.8, 0.8, 1], 0.3 + 0.2 * sin(S.t * 2 + ph));\n  // Fog over the ground: three layers of streaks drifting, the nearer ones\n  // faster and lower, tinted by the ghost's light, with gaps where the\n  // night shows through.\n  const fc = [0.3 + 0.4 * T[0], 0.24 + 0.4 * T[1], 0.4 + 0.4 * T[2]];\n  for (let l = 0; l \u003c 3; l++) {\n    const v = [-1.6, 2.4, -3.4][l], y0 = [104, 111, 117][l], thick = 3 + 2 * l, a = [0.3, 0.38, 0.46][l];\n    for (let x = 0; x \u003c W; x++) {\n      const u = x + S.t * v;\n      const d = sin(u * 0.08 + l * 1.7) + 0.7 * sin(u * 0.21 + l * 2.9);\n      if (d \u003c -0.3) continue;\n      const top = y0 + round(1.5 * sin(u * 0.05 + l)), hgt = round(thick * min(1, (d + 0.3) * 1.5));\n      for (let y = top; y \u003c top + hgt && y \u003c H; y++) {\n        const o = 3 * (y * W + x);\n        for (let q = 0; q \u003c 3; q++) rgb[o + q] = rgb[o + q] * (1 - a) + fc[q] * a;\n      }\n    }\n  }\n  // The ground: black with a ragged edge of grass.\n  for (let x = 0; x \u003c W; x++) {\n    const g = 124 - (hash(x + 99) \u003c 0.3 ? 1 : 0) - (hash(x + 5) \u003c 0.12 ? 2 : 0);\n    for (let y = g; y \u003c H; y++) put(rgb, x, y, [0.02, 0.01, 0.03], 1);\n  }\n  // The swings at the back, then the bar, the frame and the near swing.\n  const afterimage = (j) => {\n    const s = scaleOf(j), len = 0.8 + 1.2 * hn;\n    let prev = null;\n    for (const p of S.trail) {\n      const a = 1 - (S.t - p[0]) / len;\n      if (a \u003c= 0) continue;\n      const [cx, cy] = seatOf(j, p[1 + j]);\n      const bx = cx - sin(p[1 + j]) * -2.5 * s, by = cy + cos(p[1 + j]) * 2.5 * s;\n      if (prev) capsule(prev[0], prev[1], bx, by, 0.8 * s + 0.3, (x, y) => glow(rgb, x, y, T, (ceil(a * 3) / 3) * (0.4 + 0.3 * hn) * DEPTH ** j));\n      prev = [bx, by];\n    }\n  };\n  // With Haunt, a cold glow sits on each seat, as if something invisible\n  // were riding it.\n  const halo = (j) => {\n    const s = scaleOf(j), [cx, cy] = seatOf(j, S.th[j]), R = 13 * s;\n    for (let y = max(0, floor(cy - R)); y \u003c= min(H - 1, ceil(cy + R)); y++)\n      for (let x = max(0, floor(cx - R)); x \u003c= min(W - 1, ceil(cx + R)); x++) {\n        const d = sqrt((x + 0.5 - cx) ** 2 + (y + 0.5 - cy + 3 * s) ** 2) / s;\n        const g = d \u003c 7 ? 0.24 : d \u003c 13 ? 0.12 : 0;\n        if (g) glow(rgb, x, y, T, round(g * hn * 16) / 16);\n      }\n  };\n  halo(1);\n  afterimage(1);\n  drawSwing(rgb, C, 1, S.th[1], 0.75 * DEPTH ** 2);\n  const [bx0, by0] = pivot(0), [bx1, by1] = pivot(1.6);\n  capsule(bx0, by0, bx1, by1, 1.7, fill(rgb, PIPE, 1));\n  capsule(bx0, by0 - 1.2, bx1, by1 - 1.2, 0.55, fill(rgb, C.pipeLit, 1));\n  for (const side of [-1, 1]) {\n    const fx = PX + side * 38;\n    capsule(PX, PY, fx, 132, 1.7, fill(rgb, PIPE, 1));\n    capsule(PX - 1.1, PY, fx - 1.1, 132, 0.55, fill(rgb, C.pipeLit, 1));\n  }\n  capsule(PX, PY, PX, PY, 3, fill(rgb, PIPE, 1));\n  capsule(PX - 1, PY - 1, PX - 1, PY - 1, 1.2, fill(rgb, C.pipeLit, 1));\n  halo(0);\n  afterimage(0);\n  drawSwing(rgb, C, 0, S.th[0], 1);\n  if (S.push && S.push.age >= 0) drawHand(S);\n  // Out in steps of 4, which keeps the frame small for its colours.\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3)\n    display.setPixel(p % W, (p / W) | 0, 4 * round(63.75 * min(1, rgb[o])), 4 * round(63.75 * min(1, rgb[o + 1])), 4 * round(63.75 * min(1, rgb[o + 2])));\n}\n\n// A hand of mist behind the seat's back end, palm to it, fingers up and the\n// thumb towards the seat, in the ghost's colour with a lit outline, and a\n// cold glow round it. It rides with the seat while it pushes, then lets go\n// and drifts back and up as it fades.\nconst HAND = [\n  [0, -0.5, 0, 1.5, 4],\n  [-3.6, -3, -5, -10, 1.05],\n  [-1.3, -4, -1.8, -12, 1.05],\n  [1.3, -4, 1.8, -11.5, 1.05],\n  [3.5, -3, 4.8, -9, 1],\n  [3.5, 1.5, 8, -2.5, 1],\n];\nfunction drawHand(S) {\n  const P = S.push, j = P.j, rgb = S.rgb, T = S.tint, s = scaleOf(j), hn = S.haunt;\n  const a = P.age \u003c 0.12 ? P.age / 0.12 : P.age \u003c PUSH ? 1 : 1 - (P.age - PUSH) / FADE;\n  const f = round(a * 4) / 4, big = (1.4 + 0.3 * hn) * s, back = -P.dir;\n  if (P.age \u003c PUSH || !P.at) {\n    const [cx, cy, vx, vy] = seatOf(j, S.th[j]);\n    P.at = [cx - P.dir * vx * 9 * s + back * 5.5 * big, cy - P.dir * vy * 9 * s - 3 * big];\n  }\n  const drift = P.age > PUSH ? (P.age - PUSH) * 7 : 0;\n  const hx = P.at[0] + back * drift * big, hy = P.at[1] - drift * 0.6 * big;\n  for (let y = max(0, floor(hy - 30)); y \u003c= min(H - 1, floor(hy + 30)); y++)\n    for (let x = max(0, floor(hx - 30)); x \u003c= min(W - 1, floor(hx + 30)); x++) {\n      const d = sqrt((x + 0.5 - hx) ** 2 + (y + 0.5 - hy + 3 * big) ** 2) / big;\n      const g = d \u003c 10 ? 0.3 : d \u003c 15 ? 0.18 : d \u003c 20 ? 0.09 : 0;\n      if (g) glow(rgb, x, y, T, g * f);\n    }\n  const mask = new Uint8Array(W * H);\n  for (const [x0, y0, x1, y1, r] of HAND)\n    capsule(hx - x0 * big * back, hy + y0 * big, hx - x1 * big * back, hy + y1 * big, r * big, (x, y) => (mask[y * W + x] = 1));\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (!mask[p]) continue;\n      const edge = !mask[p - 1] || !mask[p + 1] || !mask[p - W] || !mask[p + W];\n      glow(rgb, x, y, T, (edge ? 1 : 0.5) * f);\n    }\n}\n","kac-ring":"// ===== Patternflow pattern =====\n// Title:   Kac Ring\n// Family:  rhythm\n// Idea:    Mark Kac's ring of 64 balls steps round the 64 columns, every ball changing colour as it crosses one of an odd number of marked edges, the newest step entering at the bottom so the panel always holds one whole period of 128 steps, a quilt of parallelograms whose middle row is the start with light and dark swapped and whose ends are the start again, each period on a fresh set of marks, with each row's light share traced in white against the dashed Stosszahlansatz curve that says it should settle at one half.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kac ring model (Mark Kac, 1959)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Marks=3..15, Dark=0..0.5\n//\n// Knob 1: Hue. Turns the colour of the light balls round the wheel, and the dashed prediction opposite them; the dark balls stay a deep navy and the measured trace white. At 0 the light balls are ice cyan and the prediction coral, at 0.25 violet, at 0.5 rose with a cyan prediction and at 0.75 lime.\n// Knob 2: Speed. Steps a second, eight times the knob: 16 at 2, so a whole period of 128 steps passes in 8 s; 1.6 at 0.2 and 24 at 3.\n// Knob 3: Marks. How many of the 64 edges are marked, the knob rounded to an odd number: 3 at the start, 7 at a quarter of the way, 9 at half, 13 at three quarters and 15 at the end. Three marks make parallelograms tens of LEDs tall; fifteen make a close weave. A new count redraws the whole period at once.\n// Knob 4: Dark. How many balls start dark, side by side in one run: none at 0, 4 of 64 at 0.06 (a 4-LED band that crosses the quilt and inverts it), 16 at 0.25 and half the ring at 0.5. The ring comes back to exactly this start every 128 steps whatever the share, and the prediction starts from it.\n\nconst W = 64, H = 128;\n// The ring: N sites, one per column, and the period 2N, one per row.\nconst N = 64, P = 128;\nconst { floor, round, min, max, pow } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// Steps a second for each unit of Speed.\nconst RATE = 8;\n// Hue of the light balls at knob 0.\nconst HUE0 = 0.5;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, hue: 0, speed: 2, m: 0, nd: -1, acc: 0,\n    // marks[e] is 1 when the edge from site e to site e+1 is marked; init is\n    // the start (1 = a dark ball), cur the ring now, at step k of its period.\n    marks: new Uint8Array(N), init: new Uint8Array(N), cur: new Uint8Array(N), nxt: new Uint8Array(N), k: 0,\n    // One row per step of the period, indexed by step mod 128: the colours,\n    // the light share, and the Stosszahlansatz prediction for that step.\n    rows: new Uint8Array(P * N), wf: new Float32Array(P), wp: new Float32Array(P),\n    col: new Float32Array(15),\n  };\n}\n\nconst oddOf = (v) => 2 * round((cl(v, 3, 15) - 1) / 2) + 1;\n\n// m distinct edges out of N, a partial shuffle.\nfunction pick(out, m) {\n  const idx = Array.from({ length: N }, (_, i) => i);\n  out.fill(0);\n  for (let i = 0; i \u003c m; i++) {\n    const j = i + floor(Math.random() * (N - i));\n    const t = idx[i];\n    idx[i] = idx[j];\n    idx[j] = t;\n    out[idx[i]] = 1;\n  }\n}\n\n// One step of the ring: every ball moves one site on, and a ball that\n// crosses a marked edge changes colour.\nfunction step(cur, marks, out) {\n  for (let x = 0; x \u003c N; x++) out[(x + 1) % N] = cur[x] ^ marks[x];\n}\n\nfunction lightShare(c) {\n  let n = 0;\n  for (let x = 0; x \u003c N; x++) n += c[x] ? 0 : 1;\n  return n / N;\n}\n\n// Boltzmann's coarse equation for the ring: the light-minus-dark share\n// shrinks by (1 - 2 mu) every step, so the light share heads for one half.\nfunction predict(S, k) {\n  const w0 = lightShare(S.init), mu = S.m / N;\n  return 0.5 + (w0 - 0.5) * pow(1 - 2 * mu, k);\n}\n\nfunction store(S, k, c) {\n  S.rows.set(c, k * N);\n  S.wf[k] = lightShare(c);\n  S.wp[k] = predict(S, k);\n}\n\n// The whole period at once, as if these marks had run all along: rows for\n// steps 0..127 from the start, and the ring set back to step k.\nfunction fill(S) {\n  const a = S.init.slice(), b = new Uint8Array(N);\n  for (let k = 0; k \u003c P; k++) {\n    store(S, k, a);\n    if (k === S.k) S.cur.set(a);\n    step(a, S.marks, b);\n    a.set(b);\n  }\n}\n\nfunction advance(S) {\n  step(S.cur, S.marks, S.nxt);\n  S.cur.set(S.nxt);\n  S.k = (S.k + 1) % P;\n  // Back at the start: a fresh set of marks, as many as before.\n  if (S.k === 0) pick(S.marks, S.m);\n  store(S, S.k, S.cur);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 3, 0.06];\n  S.hue = cl(kv[0], 0, 1);\n  S.speed = cl(kv[1], 0.2, 3);\n  const m = oddOf(kv[2]), nd = round(cl(kv[3], 0, 0.5) * N);\n  if (!S.begun || m !== S.m || nd !== S.nd) {\n    if (m !== S.m) {\n      S.m = m;\n      pick(S.marks, m);\n    }\n    if (nd !== S.nd) {\n      S.nd = nd;\n      // The dark balls start side by side, a run of nd from a random site.\n      const a = floor(Math.random() * N);\n      S.init.fill(0);\n      for (let i = 0; i \u003c nd; i++) S.init[(a + i) % N] = 1;\n    }\n    S.begun = true;\n    fill(S);\n  }\n  S.acc += cl(dt || 0, 0, 0.1) * RATE * S.speed;\n  for (let n = 0; S.acc >= 1 && n \u003c 8; n++) {\n    S.acc -= 1;\n    advance(S);\n  }\n  S.acc = min(S.acc, 1);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const C = S.col;\n  // Light balls, dark balls, the measured trace and the predicted one.\n  hsv(HUE0 + S.hue, 0.6, 1, C, 0);\n  hsv(0.66, 0.85, 0.2, C, 3);\n  C[6] = C[7] = C[8] = 1;\n  hsv(HUE0 + S.hue + 0.5, 0.7, 0.9, C, 9);\n  const c8 = Array.from(C, (v) => round(v * 255));\n  const xa = new Int16Array(H), xp = new Int16Array(H);\n  for (let y = 0; y \u003c H; y++) {\n    const r = (S.k + 1 + y) % P;\n    xa[y] = round(S.wf[r] * (W - 2));\n    xp[y] = round(S.wp[r] * (W - 2));\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const r = (S.k + 1 + y) % P, o = r * N;\n    const a0 = min(xa[y], y ? xa[y - 1] : xa[y]), a1 = max(xa[y], y ? xa[y - 1] : xa[y]) + 1;\n    // The prediction starts again with each period, so it is not joined\n    // across the start row.\n    const q = y && r ? xp[y - 1] : xp[y], p0 = min(xp[y], q), p1 = max(xp[y], q) + 1;\n    // The prediction is dashed, two rows on and two off, the dashes riding\n    // with their steps.\n    const dash = (r & 3) \u003c 2;\n    for (let x = 0; x \u003c W; x++) {\n      let c = S.rows[o + x] ? 3 : 0;\n      if (x >= a0 && x \u003c= a1) c = 6;\n      // A black edge each side keeps the white trace apart from light balls.\n      else if (x === a0 - 1 || x === a1 + 1) c = 12;\n      else if (dash && x >= p0 && x \u003c= p1) c = 9;\n      display.setPixel(x, y, c8[c], c8[c + 1], c8[c + 2]);\n    }\n  }\n}\n","lace-phantom":"// ===== Patternflow pattern =====\n// Title:   Lace Phantom\n// Family:  halloween\n// Idea:    A lace curtain fills a tall broken window at night and billows in the wind with the moon behind it, and now and then a face presses through from behind, the lace stretching over a brow, two eye hollows and an open mouth before it sinks back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Lace=-1..1, Haunt=0..1\n//\n// Knob 1: Hue. The tint of the lace. At 0 lavender, at 0.35 cold blue-white, at 0.7 ice cyan and at 1 a ghostly green.\n// Knob 2: Speed. The wind. At 2 the hem swings about 5 LEDs each way every 4 seconds and the pleats ripple across it; at 0.2 all of it, the face too, is ten times slower, at 3 half as fast again.\n// Knob 3: Lace. The size of the pattern. At 0 a diamond trellis 26 LEDs across with a flower in each diamond; at -1 a finer one 20 LEDs across, its threads broken; at 1 a bold one 34 LEDs across with thick threads.\n// Knob 4: Haunt. How often a face presses through, and how hard. At 0.06 the first one starts at 2.2 s, is pressed full by 3.5 s, holds 1.6 s and is gone by 6.9 s, and the next comes 8.6 s later; at 1 the first is there at once, 25% bigger and deeper, and the next comes 2 s after the last has gone.\n// Buttons: K4 tap sends a face through now, or straight after the one already there.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// The tulle is a one-LED checker: the threads (x + y even) stand STEP above\n// the holes beside them, so every pair of neighbours is a gentle step. The\n// knots of the lace are threads at full level, each with four holes round\n// it, and there are always KNOTS of them: that count alone fixes how many\n// neighbour pairs are hard steps.\nconst STEP = 39, KNOTS = 800;\nconst CAND = [];\nfor (let y = 1; y \u003c H - 1; y++) for (let x = 2 - (y & 1); x \u003c W - 1; x += 2) CAND.push(y * W + x);\n// A fixed shuffle: where two places score the same, the earlier one in this\n// order gets the knot, so ties do not flicker from frame to frame.\nconst ORDER = CAND.slice();\nfor (let i = ORDER.length - 1; i > 0; i--) {\n  const j = floor(hash(i * 31 + 7) * (i + 1));\n  [ORDER[i], ORDER[j]] = [ORDER[j], ORDER[i]];\n}\nconst BINS = 1280, LO = -12, PER = 64;\n\n// The window behind the curtain: a mullion down the middle and two\n// transoms make six panes, and their shadows fall on the curtain. The moon\n// stands behind the upper right pane. The lower left pane is broken: a\n// jagged hole round (15, 108) lets the moonlight in unglazed, so the lace\n// over it is lit a little more, and cracks run from its points to the frame,\n// glinting where they catch the light.\nconst MOON = [48, 21, 8];\nconst HOLE = [15, 108];\nconst SPIKES = 11;\nconst RIM = [];\nfor (let k = 0; k \u003c SPIKES; k++) RIM.push((k & 1 ? 4 : 8.5) + 2.5 * hash(k + 60));\nconst holeR = (a) => {\n  const f = ((a / (2 * PI)) * SPIKES + SPIKES) % SPIKES, i = floor(f), u = f - i;\n  return RIM[i] + (RIM[(i + 1) % SPIKES] - RIM[i]) * u;\n};\nconst CRACKS = [];\nfor (let k = 0; k \u003c SPIKES; k += 2) {\n  const a = ((k + 0.5) / SPIKES) * 2 * PI, r0 = RIM[k] * 0.9, len = 12 + 14 * hash(k + 50);\n  CRACKS.push([HOLE[0] + cos(a) * r0, HOLE[1] + sin(a) * r0, HOLE[0] + cos(a + 0.15) * (r0 + len), HOLE[1] + sin(a + 0.15) * (r0 + len)]);\n}\nconst SHADE = new Float32Array(N), GAP = new Float32Array(N);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    let s = 0;\n    if (abs(x - 31.5) \u003c 2) s = 1;\n    if (abs(y - 43.5) \u003c 2 || abs(y - 86.5) \u003c 2) s = 1;\n    const hx = x - HOLE[0], hy = y - HOLE[1];\n    if (s === 0 && sqrt(hx * hx + hy * hy) \u003c holeR(Math.atan2(hy, hx) + PI)) GAP[y * W + x] = 1;\n    for (const [x0, y0, x1, y1] of CRACKS) {\n      if (x > 29 || y \u003c 89) continue;\n      const ex = x1 - x0, ey = y1 - y0, qx = x - x0, qy = y - y0, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey), 0, 1);\n      if (sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) \u003c 0.7) GAP[y * W + x] = max(GAP[y * W + x], 0.6);\n    }\n    SHADE[y * W + x] = s;\n  }\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, lace: 0, haunt: 0.06, t: 0,\n    face: null, wait: 2.3, queued: false,\n    L: new Uint8Array(N), lit: new Float32Array(N), score: new Float32Array(N), knot: new Uint8Array(N),\n    hist: new Int32Array(BINS), c: [0, 0, 0],\n  };\n}\n\nfunction newFace(S) {\n  S.face = {\n    x: 22 + 20 * Math.random(), y: 52 + 22 * Math.random(), r: (17 + 3 * Math.random()) * (1 + 0.25 * S.haunt),\n    age: 0, deep: 0.75 + 0.35 * S.haunt, turn: (Math.random() - 0.5) * 0.3, open: 1,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.lace = cl(k[2], -1, 1);\n  S.haunt = cl(k[3], 0, 1);\n  if (!S.begun) {\n    // The first face comes sooner the higher Haunt is.\n    S.wait = 2.3 * (1 - S.haunt);\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  if (input.btnPressed && input.btnPressed[3]) {\n    if (S.face) S.queued = true;\n    else newFace(S);\n  }\n  if (S.face) {\n    S.face.age += ds;\n    // The mouth works open and shut while the face is held.\n    S.face.open = 0.75 + 0.3 * sin(S.face.age * 4.2);\n    if (S.face.age > 4.7) {\n      S.face = null;\n      S.wait = S.queued ? 0 : 9 - 7 * S.haunt;\n      S.queued = false;\n    }\n  } else {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) newFace(S);\n  }\n}\n\n// How far the face presses at its age: in for 1.3 s, held 1.6 s, back for 1.8 s.\nconst press = (a) => (a \u003c 1.3 ? sm(0, 1.3, a) : a \u003c 2.9 ? 1 : 1 - sm(2.9, 4.7, a));\n\n// Distance in LEDs from curtain point (u, v) to the nearest thread of the\n// lace motif: a diamond trellis, a ring and a centre knot in each diamond,\n// and a scalloped hem along the bottom.\nfunction motif(u, v, T) {\n  const a = u / T, b = v / T;\n  const p = a + b, q = a - b;\n  let dd = (abs(p - floor(p) - 0.5) * T) / 1.4142;\n  dd = min(dd, (abs(q - floor(q) - 0.5) * T) / 1.4142);\n  // Diamond centres sit where a + b and a - b are both whole.\n  const cp = round(p), cq = round(q), ca = (cp + cq) / 2, cb = (cp - cq) / 2;\n  const rx = (a - ca) * T, ry = (b - cb) * T, rr = sqrt(rx * rx + ry * ry);\n  dd = min(dd, abs(rr - 0.2 * T), rr);\n  if (v > 108) {\n    const sx = T / 2, k = round(u / sx), hx = u - k * sx, hy = v - 114;\n    dd = min(dd, abs(v - 109.5), hy > 0 ? abs(sqrt(hx * hx + hy * hy) - sx / 2) : 9);\n  }\n  return dd;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { L, lit, score, knot, hist } = S, t = S.t, T = 26 * 1.3 ** S.lace;\n  const F = S.face, fa = F ? press(F.age) * F.deep : 0;\n  // Face fields are drawn in the face's own units, its radius 1.\n  for (let y = 0; y \u003c H; y++) {\n    const sy = (y / H) ** 1.3;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      // The wind comes in at the broken pane and the hem swings most.\n      const gust = 1 + 0.9 * exp(-((x - HOLE[0]) ** 2 + (y - HOLE[1]) ** 2) / 700);\n      const dx = gust * sy * (5 * sin(1.6 * t - 0.045 * y + 0.6) + 1.6 * sin(3.1 * t - 0.11 * y + 0.07 * x));\n      const dy = gust * sy * 2.2 * sin(2.2 * t + 0.08 * x - 0.03 * y);\n      // Pleats: the cloth gathers into folds 13 LEDs apart that ripple.\n      const ph = (2 * PI * (x + dx)) / 13 + 0.7 * sin(0.9 * t + y * 0.02);\n      let u = x + dx + 1.4 * sin(ph), v = y + dy;\n      let light = 0.5 + 0.5 * cos(ph);\n      let face = -99, thin = 0, deep = 0, rise = 0;\n      if (fa > 0) {\n        const fx = (x - F.x) / F.r, fy = (y - F.y) / F.r, e = fx * fx + (fy / 1.25) ** 2;\n        if (e \u003c 1.6) {\n          const dome = max(0, 1 - e);\n          // The lace stretches over the head: the pattern grows there.\n          const st = 1 - 0.35 * fa * dome;\n          u = F.x + (u - F.x) * st;\n          v = F.y + (v - F.y) * st;\n          // The cloth drawn over the face lets more moonlight through: a\n          // pale glow, its level ramped over 8 LEDs or more so the checker\n          // keeps its gentle steps. The eye sockets and the open mouth are\n          // dark hollows in it. Where the cloth is drawn tightest (brow,\n          // nose, cheekbones) its knots crowd.\n          const ax = abs(fx + F.turn * fy), op = F.open;\n          const eye = ((ax - 0.36) / 0.2) ** 2 + ((fy + 0.08) / 0.16) ** 2;\n          const mouth = (fx / 0.17) ** 2 + ((fy - 0.56) / (0.22 * op)) ** 2;\n          const hol = min(sm(0.45, 2.2, eye), sm(0.45, 2.2, mouth));\n          let hi = sm(0.1, 0.05, abs(fy + 0.38 - 0.2 * ax * ax)) * sm(0.66, 0.5, ax);\n          hi = max(hi, sm(0.07, 0.03, abs(fx)) * sm(-0.3, -0.18, fy) * sm(0.36, 0.28, fy));\n          hi = max(hi, sm(0.06, 0.03, abs(fy - 0.15 - 0.4 * (ax - 0.36) ** 2)) * sm(0.66, 0.52, ax) * sm(0.1, 0.2, ax));\n          face = hi > 0 ? 1.6 * fa * hi - 1 : -99;\n          thin = 0.6 * fa * dome;\n          if (eye \u003c 1.2 || mouth \u003c 1.2) deep = fa;\n          rise = fa * sm(0, 0.8, dome);\n          light = light * (1 - rise) + rise * hol;\n          rise *= hol;\n        }\n      }\n      // The face is in front of the window, so no frame shadow falls on it.\n      const sh = SHADE[p] * (1 - min(1, 3 * rise));\n      // The moon is a disc behind the upper right pane, its rim ramped over 6 LEDs.\n      const mg = sm(MOON[2] + 6, MOON[2], sqrt((x - MOON[0]) ** 2 + (y - MOON[1]) ** 2));\n      L[p] = sh >= 1 ? 0 : round(min(80, 64 * mg + 76 * rise + 28 * GAP[p]) * (1 - sh));\n      lit[p] = deep > 0.3 ? 0 : cl(light * (1 - sh) + mg + GAP[p], 0, 1);\n      if ((x + y) & 1) continue;\n      score[p] = max(-motif(u, v, T) - thin, face) - 9 * deep - 9 * sh - 0.012 * L[p];\n    }\n  }\n  // Exactly KNOTS knots: the best-scored places, ties broken by ORDER.\n  hist.fill(0);\n  const binOf = (s) => cl(floor((s - LO) * PER), 0, BINS - 1);\n  for (const p of CAND) hist[binOf(score[p])]++;\n  let need = KNOTS, cut = BINS - 1;\n  while (cut > 0 && hist[cut] \u003c need) need -= hist[cut--];\n  knot.fill(0);\n  for (const p of ORDER) {\n    const b = binOf(score[p]);\n    if (b > cut) knot[p] = 1;\n    else if (b === cut && need > 0) {\n      knot[p] = 1;\n      need--;\n    }\n  }\n  // Colours: a pale tint where the lace is lit, the deep tint in shadow;\n  // either way the brightest channel is the level the checker asks for.\n  const h = 0.76 - 0.42 * S.hue, c = S.c;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let lv;\n      const q = round(lit[p] * 3) / 3;\n      if ((x + y) & 1) {\n        lv = L[p];\n        if (lv === 0) {\n          display.setPixel(x, y, 0, 0, 0);\n          continue;\n        }\n        hsv(h, 0.9 - 0.5 * q, 1, c);\n      } else if (knot[p]) {\n        lv = 255;\n        hsv(h, 0.38 - 0.26 * q, 1, c);\n      } else {\n        let m = 255;\n        if (x > 0) m = min(m, L[p - 1]);\n        if (x \u003c W - 1) m = min(m, L[p + 1]);\n        if (y > 0) m = min(m, L[p - W]);\n        if (y \u003c H - 1) m = min(m, L[p + W]);\n        lv = m + STEP;\n        hsv(h + 0.03 * (1 - q), 1 - 0.72 * q, 1, c);\n      }\n      display.setPixel(x, y, round(c[0] * lv), round(c[1] * lv), round(c[2] * lv));\n    }\n}\n","peregrine-soliton":"// ===== Patternflow pattern =====\n// Title:   Peregrine Soliton\n// Family:  wave\n// Idea:    A regular train of sea waves runs under a dark sky with the modulus of a breather of the focusing nonlinear Schrödinger equation as its envelope, so one crest rises out of nowhere to three times the swell between two calm holes and sinks again, while the envelope's space-time record scrolls up above the sea.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Peregrine soliton (Howell Peregrine, 1983)\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Family=-1..1, Swell=0..1\n//\n// Knob 1: Hue. Turns the sea and the record from teal at 0 through blue (0.25), indigo (0.5) and purple (0.75) to rose at 1; the foam stays white.\n// Knob 2: Speed. At 2 the equation's clock runs 0.77 units a second at the opening swell: the Peregrine crest stands above twice the swell for 1.7 s and the next breather comes 9 s later. The crests run 14 LEDs a second and the envelope 7, the group speed of deep water. At 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Family. Which breather of the one-parameter family. At 0 the Peregrine soliton (a = 1/2): one crest three times the swell, once, one to three crests further on each time. Below 0 Akhmediev breathers, periodic along the sea, down to a = 0.2 at -1: three crests 20.5 LEDs apart rising together to 2.26 times the swell (the sea is drawn finer for them). Above 0 Kuznetsov-Ma breathers, periodic in time, up to a = 0.9 at 1: one crest that pulses to 3.68 times the swell every 2.6 units (3.4 s) for ever.\n// Knob 4: Swell. The background amplitude A, 0.75 at 0 to 1.35 at 1, 0.79 at 0.06: a swell 12.6 LEDs high and a rogue of 38 standing 15.7 LEDs wide between its holes. The equation's scaling A psi(Ax, A^2 t) keeps the rogue three times the swell at every A, but makes it 1/A as wide and 1/A^2 as quick: at 1 the swell is 22 LEDs, the rogue 65 LEDs high and 9 wide, and a breather comes every 3 s.\n\nconst W = 64, H = 128, REC = 40, MEAN = 96, VS = 16, LAM = 16;\nconst { floor, round, min, max, abs, sqrt, cos, sin, cosh, sinh, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => v * v * (3 - 2 * v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const r = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  const g = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  const b = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return [round(r * 63) * 4, round(g * 63) * 4, round(b * 63) * 4];\n}\n\n// The breather family of i psi_t + psi_xx / 2 + |psi|^2 psi = 0 on the\n// background e^{it}, written as psi = phi(x, t) e^{it}. For a \u003c 1/2 the\n// Akhmediev breather, for a > 1/2 the Kuznetsov-Ma breather (b and w turn\n// imaginary, cos and cosh trade places), at a = 1/2 the Peregrine soliton.\n// out gets [Re phi, Im phi].\nexport function breather(a, x, t, out) {\n  if (abs(a - 0.5) \u003c 1e-9) {\n    const D = 1 + 4 * x * x + 4 * t * t;\n    out[0] = 1 - 4 / D;\n    out[1] = (-8 * t) / D;\n    return out;\n  }\n  const s = sqrt(2 * a);\n  if (a \u003c 0.5) {\n    const b = sqrt(8 * a * (1 - 2 * a)), w = 2 * sqrt(1 - 2 * a);\n    const ch = cosh(b * t), c = cos(w * x), den = s * c - ch;\n    out[0] = ((1 - 4 * a) * ch + s * c) / den;\n    out[1] = (b * sinh(b * t)) / den;\n    return out;\n  }\n  const b = sqrt(8 * a * (2 * a - 1)), w = 2 * sqrt(2 * a - 1);\n  const ch = cosh(min(30, w * abs(x))), c = cos(b * t), den = s * ch - c;\n  out[0] = ((1 - 4 * a) * c + s * ch) / den;\n  out[1] = (-b * sin(b * t)) / den;\n  return out;\n}\nconst tmp = [0, 0];\nconst amp = (a, x, t) => {\n  breather(a, x, t, tmp);\n  return sqrt(tmp[0] * tmp[0] + tmp[1] * tmp[1]);\n};\n\n// Half a cycle of the equation's clock. Peregrine and Akhmediev breathers\n// rise once out of the background, so the clock runs -3.5..3.5 and starts\n// again with the next one; a Kuznetsov-Ma breather is periodic, and the\n// clock runs one whole period when that is not too long. |psi| is even in t,\n// so the end of a cycle and the start of the next one agree.\nfunction halfCycle(a) {\n  if (a \u003c= 0.5) return 3.5;\n  const T = PI / sqrt(8 * a * (2 * a - 1));\n  return T \u003c= 6 ? T : 3.5;\n}\nconst knobA = (k) => (abs(k) \u003c 0.02 ? 0.5 : 0.5 + (k \u003c 0 ? 0.3 : 0.4) * k);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, a: 0.5, A: 0.8, t: -3.4, xu: 14 + 10 * Math.random(), started: false, kap: 1.8,\n    rec: new Uint8Array(REC * W), head: 0, acc: 0, env: new Float32Array(W), spray: [],\n  };\n}\n\n// Units of the equation per LED at A = 1: 0.14, so the Peregrine crest is\n// 15.7 LEDs wide between its holes at the opening swell; finer for an\n// Akhmediev breather, so three of its peaks fit at a = 0.2.\nconst xScale = (a) => 0.14 * (a \u003c 0.5 ? 1 + (0.8 * (0.5 - a)) / 0.3 : 1);\n\n// The envelope |psi| along the sea, unscaled (the background is 1), with\n// the breather's middle at column xu. A localised breather wraps round the\n// 64 columns; an Akhmediev breather is periodic in x and needs no wrap.\nfunction envelope(P, xu, t) {\n  const k = P.A * xScale(P.a);\n  for (let x = 0; x \u003c W; x++) {\n    let dx = x + 0.5 - xu;\n    if (P.a >= 0.5) dx -= 64 * floor(dx / 64 + 0.5);\n    P.env[x] = amp(P.a, k * dx, t);\n  }\n}\n\n// One row of the record: the envelope in nine levels, black where it\n// falls under half the swell, the background 0.9..1.1.\nconst LEVELS = [0.5, 0.7, 0.9, 1.1, 1.35, 1.7, 2.1, 2.5];\nfunction pushRow(P) {\n  P.head = (P.head + 1) % REC;\n  const o = P.head * W;\n  for (let x = 0; x \u003c W; x++) {\n    const e = P.env[x];\n    let l = 0;\n    while (l \u003c 8 && e >= LEVELS[l]) l++;\n    P.rec[o + x] = l;\n  }\n}\n\n// The carrier: crests at theta = 0 (mod 2 pi), 1 at a crest and -0.5 in a\n// trough, the troughs a little flatter than the crests.\nconst theta = (P, x) => (2 * PI * (x + 0.5 - P.xu)) / LAM - P.kap * P.t;\nconst shape = (th) => 1.5 * ((1 + cos(th)) / 2) ** 0.8 - 0.5;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06];\n  const speed = cl(k[1], 0.2, 3);\n  P.hue = k[0];\n  P.a = knobA(cl(k[2], -1, 1));\n  P.A = 0.75 + 0.6 * cl(k[3], 0, 1);\n  const d = cl(dt || 0, 0, 0.1);\n  // The equation's clock runs A^2 as fast at swell A: the scaling at work.\n  // The envelope travels at the group speed, half the crests' speed in deep\n  // water; the crests run through it once every 2 pi / kap units of the\n  // clock, and one stands on the breather's middle at t = 0.\n  const step = 0.625 * speed * P.A * P.A;\n  let T = halfCycle(P.a);\n  P.kap = (2 * PI * max(1, round((3.6 * T) / PI))) / (2 * T);\n  const cg = (LAM * P.kap * step) / (2 * PI);\n  if (!P.started) {\n    // Fill the record with the 4 units before the opening.\n    P.started = true;\n    for (let i = REC - 1; i >= 0; i--) {\n      envelope(P, P.xu - (cg * i * 0.1) / step, P.t - i * 0.1);\n      pushRow(P);\n    }\n  }\n  P.t += step * d;\n  P.xu += cg * d;\n  while (P.t > T) {\n    P.t -= 2 * T;\n    // Once a breather has risen and gone, the next one rises one to three\n    // crests further on; a whole number of crests, so the sea does not jump.\n    if (P.a \u003c= 0.5 || T === 3.5) P.xu += LAM * floor(1 + 3 * Math.random());\n  }\n  envelope(P, P.xu, P.t);\n  P.acc += step * d;\n  for (; P.acc >= 0.1; P.acc -= 0.1) pushRow(P);\n\n  // Spray off a crest higher than 2.3 times the swell.\n  const sp = speed / 2;\n  for (let x = 0; x \u003c W; x++) {\n    const hgt = P.env[x] * shape(theta(P, x));\n    if (hgt > 2.3 && Math.random() \u003c 6 * sp * (hgt - 2.2) * d * 30 * 0.1) {\n      P.spray.push({ x: x + Math.random(), y: MEAN - VS * P.A * hgt - 1, vx: (Math.random() - 0.3) * 16, vy: -(10 + 16 * Math.random()) * P.A, life: 1 + 0.5 * Math.random() });\n    }\n  }\n  for (const p of P.spray) {\n    p.x += p.vx * d * sp;\n    p.y += p.vy * d * sp;\n    p.vy += 40 * d * sp;\n    p.life -= d * sp;\n  }\n  P.spray = P.spray.filter((p) => p.life > 0 && p.y \u003c MEAN + 6 && p.x >= 0 && p.x \u003c W);\n  if (P.spray.length > 160) P.spray.splice(0, P.spray.length - 160);\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.started) return;\n  const h0 = 0.52 + 0.4 * P.hue;\n  const REC_COL = [null, hsv(h0 + 0.1, 0.8, 0.08), hsv(h0 + 0.06, 0.8, 0.12), hsv(h0, 0.85, 0.17), hsv(h0, 0.85, 0.26),\n    hsv(h0, 0.85, 0.38), hsv(h0, 0.8, 0.54), hsv(h0 - 0.03, 0.55, 0.78), [228, 248, 252]];\n  const FOAM = [236, 248, 252], SURF = hsv(h0, 0.7, 0.86), BODY = hsv(h0 + 0.02, 0.9, 0.52), DEEP = hsv(h0 + 0.05, 0.95, 0.3);\n\n  // The record: newest row at the bottom, scrolling up.\n  for (let r = 0; r \u003c REC; r++) {\n    const o = ((P.head + 1 + r) % REC) * W;\n    for (let x = 0; x \u003c W; x++) {\n      const c = REC_COL[P.rec[o + x]];\n      if (c) display.setPixel(x, r, c[0], c[1], c[2]);\n    }\n  }\n  // The sea under the envelope, foam on the crests, a lit band under the\n  // surface and a darker deep.\n  for (let x = 0; x \u003c W; x++) {\n    const th = theta(P, x), c = (1 + cos(th)) / 2;\n    const e = P.env[x], hgt = VS * P.A * e * shape(th);\n    const ys = round(MEAN - hgt);\n    const foam = c > 0.85 - 0.06 * e ? cl(round((e - 0.6) * 2.5), 1, 6) : 0;\n    const deep = MEAN + 18 + round(3 * shape(th));\n    for (let y = max(0, ys); y \u003c H; y++) {\n      const col = y \u003c ys + foam ? FOAM : y \u003c ys + foam + 3 ? SURF : y \u003c deep ? BODY : DEEP;\n      display.setPixel(x, y, col[0], col[1], col[2]);\n    }\n  }\n  for (const p of P.spray) {\n    const x = floor(p.x), y = floor(p.y);\n    if (y >= 0 && y \u003c H) display.setPixel(x, y, FOAM[0], FOAM[1], FOAM[2]);\n  }\n}\n","slime-drip":"// ===== Patternflow pattern =====\n// Title:   Slime Drip\n// Family:  halloween\n// Idea:    Toxic green ectoplasm oozes from under a purple stone ledge along the top edge, bulges swell and stretch into drips whose necks thin and pinch off, some hanging long on a thread and swaying before they snap, and the drops fall the full height of the panel to splat into a glowing puddle at the bottom that grows and bubbles.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 44\n// Round:   44\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drips=5..12, Viscosity=-1..1\n//\n// Knob 1: Hue. The slime's colour, the stone opposite it on the wheel. At 0 toxic green on purple stone; at 0.3 aqua on dark red, at 0.5 blue, at 0.75 violet on olive and at 1 pink. The warm hues from red to yellow are left out: in the slime's dark edges and its glow they turn brown.\n// Knob 2: Speed. At 2 a drip swells for half a second and stretches for 2 to 2.6 s, a drip on a thread hangs and sways 2.3 to 3.3 s more, and a drop falls from row 10 to the puddle in 1.1 s at up to 130 rows a second; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Drips. How many drips hang from the ledge, 5 to 12, spread along it. At 5 about 0.9 drops fall a second and the puddle rises from 9 rows deep at the start to 18 in a minute; at 12 about 2.1 a second and it rises to 26.\n// Knob 4: Viscosity. How thick the slime is. At -1 it runs: drops 4 to 6 LEDs across let go about 19 rows down, 1.6 a second, and one drip at a time hangs long on a thread. At 0.06 drops 7 or 8 across let go anywhere from row 28 to 96, 0.9 a second, and three drips of five hang on threads at a time, swaying, with lumps of goo sliding down them. At 1 every drip stretches to row 74 to 102 on a thread before it drops 9 or 10 LEDs across, 0.5 a second.\n\nconst W = 64, H = 128, STONE = 4;\nconst { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Tones: 0 dark, 1 glow, 2 slime edge, 3 slime, 4 slime core, 5 shine,\n// 6 stone, 7 stone lip, 8 deep puddle, 9 bubble, 10 faint glow.\nconst SLIME = 2;\n\nexport function setup(params) {\n  params.s = {\n    begun: false, t: 0, hue: 0, speed: 1, n: 0, visc: 0.53,\n    drips: [], drops: [], bits: [], rips: [], bubs: [], flashes: [],\n    level: 6, bubWait: 0.3,\n    tone: new Uint8Array(W * H), pal: Array.from({ length: 11 }, () => [0, 0, 0]),\n  };\n}\n\n// The underside of the slime coat on the stone, a slow wave.\nconst coat = (S, x) => 7.5 + 1.3 * sin(x * 0.21 + S.t * 0.5) + 0.8 * sin(x * 0.53 - S.t * 0.8);\n\nfunction newCycle(S, d) {\n  const v = S.visc;\n  d.phase = \"swell\";\n  d.pt = 0;\n  d.Rt = 2.2 + 2.2 * v + rnd(0, 0.8);\n  // Drips take turns at hanging long: a drip hangs when fewer than the\n  // share of them are hanging already.\n  let hanging = 0;\n  for (const o of S.drips) if (o !== d && o.long && o.phase !== \"rest\" && o.phase !== \"recoil\") hanging++;\n  d.long = hanging \u003c round(S.n * (0.1 + 0.8 * v)) || Math.random() \u003c 0.1;\n  d.Lp = d.long ? rnd(50, 95) : 10 + 10 * v + rnd(0, 40 * v);\n  d.T = 0.8 + 2.2 * v + rnd(0, 0.6);\n  d.hang = 1.2 + 2 * v + rnd(0, 1);\n  d.amp = d.long ? rnd(0.07, 0.16) : rnd(0.02, 0.06);\n  d.w = rnd(2.2, 3.4);\n  d.ph = rnd(0, 2 * PI);\n  d.Ls = d.L;\n}\n\nfunction build(S, n) {\n  S.n = n;\n  S.drips = [];\n  const slot = W / n;\n  for (let i = 0; i \u003c n; i++) {\n    const d = {\n      x: (i + 0.5) * slot + rnd(-0.15, 0.15) * slot, root: min(slot * 0.36, 3 + 1.5 * S.visc + rnd(0, 1)),\n      L: 2, R: 1.2, neck: 1.5, th: 0, phase: \"rest\", pt: 0, lump: -rnd(0, 20),\n      // Starts spread over a whole cycle, so the drips never fall in step.\n      wait: (((i * 0.618) % 1) + rnd(0, 0.1)) * (1.5 + 5 * S.visc),\n    };\n    S.drips.push(d);\n  }\n}\n\n// The surface of the puddle at column x, in rows from the top.\nfunction surface(S, x) {\n  let y = H - S.level;\n  for (const r of S.rips) {\n    const dx = abs(x - r.x), front = 16 * r.age + 2;\n    if (dx > front) continue;\n    y -= r.a * exp(-r.age * 1.8 - dx / 22) * cos(0.7 * dx - 10 * r.age);\n  }\n  return y;\n}\n\nfunction splat(S, x, y, R, vy) {\n  S.level += (PI * R * R) / W;\n  S.rips.push({ x, age: 0, a: 0.5 + 0.35 * R });\n  S.flashes.push({ x, y, age: 0, r: R });\n  const n = 3 + round(R * 1.6);\n  for (let i = 0; i \u003c n; i++)\n    S.bits.push({ x, y: y - 1, vx: rnd(-1, 1) * (18 + 8 * R), vy: -rnd(25, 45 + 0.1 * vy) * sqrt(R / 3), big: Math.random() \u003c 0.35 });\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  const g = 260;\n  for (const d of S.drips) {\n    d.pt += dt;\n    // Lumps of goo slide down a long drip into its bulb.\n    d.lump += 16 * dt;\n    if (d.lump > d.L) d.lump = -rnd(4, 16);\n    if (d.phase === \"rest\") {\n      if (d.pt > d.wait) newCycle(S, d);\n    } else if (d.phase === \"swell\") {\n      const u = cl(d.pt / 0.5, 0, 1);\n      d.R = 1.2 + (d.Rt * 0.7 - 1.2) * u;\n      d.L = d.Ls + (d.R + 1 - d.Ls) * u;\n      d.neck = d.root * (0.9 - 0.3 * u);\n      if (u >= 1) (d.phase = \"stretch\"), (d.pt = 0), (d.Ls = d.L), (d.n0 = d.neck);\n    } else if (d.phase === \"stretch\") {\n      // The bulb grows and sinks faster as it fills; the neck above it thins.\n      const u = cl(d.pt / d.T, 0, 1);\n      d.R = d.Rt * (0.7 + 0.3 * u);\n      d.L = d.Ls + (d.Lp - d.Ls) * u * u * (1.5 - 0.5 * u);\n      // A drip that will hang keeps a thread 2 LEDs wide; the others thin to one.\n      const thin = d.long ? 1 : 0.5;\n      d.neck = thin + (d.n0 - thin) * (1 - u) ** 1.4;\n      if (u >= 1) {\n        if (d.long) (d.phase = \"hang\"), (d.pt = 0), (d.L0 = d.L);\n        else pinch(S, d);\n      }\n    } else if (d.phase === \"hang\") {\n      // On a thread: the bulb sways like a pendulum and creeps lower.\n      d.L = d.L0 + 8 * (d.pt / d.hang) + 1.5 * sin(d.pt * 7);\n      if (d.pt > d.hang) pinch(S, d);\n    } else if (d.phase === \"recoil\") {\n      // What is left above the pinch snaps back up and wobbles.\n      const u = d.pt;\n      d.L = d.stub + (d.Lr - d.stub) * exp(-u * 11) + 1.2 * sin(u * 26) * exp(-u * 5);\n      d.R = 1.3;\n      d.neck = d.root * 0.6 * (1 - exp(-u * 4)) + 0.5;\n      if (u > 0.6) (d.phase = \"rest\"), (d.pt = 0), (d.wait = rnd(0.1, 0.7));\n    }\n    // Sway: the angle of the bulb under the root.\n    if (d.phase === \"recoil\") d.th = d.th0 * exp(-d.pt * 5);\n    else d.th = (d.phase === \"hang\" ? d.amp * min(1, d.pt / 0.6) : d.amp * 0.4) * sin(d.pt * d.w + d.ph);\n  }\n  // Drops fall, with air holding them under 130 rows a second.\n  for (const p of S.drops) {\n    p.vy += (g - 0.0154 * p.vy * p.vy) * dt;\n    p.y += p.vy * dt;\n    p.x += p.vx * dt;\n    p.vx *= exp(-dt * 1.5);\n    if (p.x \u003c p.R) (p.x = p.R), (p.vx = abs(p.vx));\n    if (p.x > W - p.R) (p.x = W - p.R), (p.vx = -abs(p.vx));\n    if (p.y + p.R >= surface(S, p.x)) (p.dead = true), splat(S, p.x, surface(S, p.x), p.R, p.vy);\n  }\n  S.drops = S.drops.filter((p) => !p.dead);\n  for (const b of S.bits) {\n    b.vy += g * dt;\n    b.x += b.vx * dt;\n    b.y += b.vy * dt;\n    if (b.vy > 0 && b.y >= surface(S, b.x)) b.dead = true;\n    if (b.x \u003c 0 || b.x >= W) b.dead = true;\n  }\n  S.bits = S.bits.filter((b) => !b.dead);\n  for (const r of S.rips) r.age += dt;\n  S.rips = S.rips.filter((r) => r.age \u003c 2.5);\n  for (const f of S.flashes) f.age += dt;\n  S.flashes = S.flashes.filter((f) => f.age \u003c 0.2);\n  // The puddle drains slowly toward 6 rows.\n  S.level -= (S.level - 6) * 0.06 * dt;\n  S.level = min(S.level, 26);\n  // Bubbles rise through the puddle, swell into a dome and pop.\n  S.bubWait -= dt;\n  if (S.bubWait \u003c= 0) {\n    S.bubWait = rnd(0.15, 0.6);\n    S.bubs.push({ x: rnd(3, W - 3), y: H - 1, r: rnd(1, 1.6), vy: rnd(5, 10), dome: -1 });\n  }\n  for (const b of S.bubs) {\n    const top = surface(S, b.x);\n    if (b.dome \u003c 0) {\n      b.y -= b.vy * dt;\n      b.r = min(b.r + dt * 1.2, 3);\n      if (b.y - b.r \u003c= top) b.dome = 0;\n    } else {\n      b.dome += dt;\n      b.y = top;\n      if (b.dome > 0.45) {\n        b.dead = true;\n        S.flashes.push({ x: b.x, y: top - b.r, age: 0, r: b.r * 0.7 });\n        for (let i = 0; i \u003c 2; i++) S.bits.push({ x: b.x, y: top - b.r, vx: rnd(-14, 14), vy: rnd(-40, -20), big: false });\n      }\n    }\n  }\n  S.bubs = S.bubs.filter((b) => !b.dead);\n}\n\nfunction pinch(S, d) {\n  const X = d.L * sin(d.th), y = coat(S, d.x) + d.L;\n  const swing = d.L * d.amp * d.w * cos(d.pt * d.w + d.ph);\n  S.drops.push({ x: d.x + X, y, vx: d.phase === \"hang\" ? swing : 0, vy: 15, R: d.R });\n  // Now and then a small satellite drop from the neck.\n  if (Math.random() \u003c 0.5) S.drops.push({ x: d.x + X * 0.85, y: y - d.R - 2, vx: 0, vy: 5, R: 1 });\n  d.phase = \"recoil\";\n  d.pt = 0;\n  d.th0 = d.th;\n  d.Lr = max(3, d.L - d.R * 1.6);\n  d.stub = rnd(3, 8);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06];\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3) / 2;\n  S.visc = (cl(k[3], -1, 1) + 1) / 2;\n  const n = cl(round(k[2]), 5, 12);\n  if (n !== S.n) build(S, n);\n  if (!S.begun) {\n    // The first frame is a drip already running: 8 s of it, run at once.\n    S.begun = true;\n    for (let i = 0; i \u003c 240; i++) step(S, 1 / 30);\n  }\n  step(S, cl(dt || 0, 0, 0.1) * S.speed);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  const { tone, pal } = S;\n  tone.fill(0);\n  const put = (x, y, v) => {\n    x = floor(x);\n    y = floor(y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const o = y * W + x;\n    if (v > tone[o] || tone[o] >= 8 || tone[o] === 1) tone[o] = v;\n  };\n  // A horizontal run of slime at row y between xa and xb, lit from the left.\n  const span = (y, xc, h) => {\n    const a = floor(xc - h + 0.5), b = max(a, floor(xc + h - 0.5));\n    for (let x = a; x \u003c= b; x++) {\n      const u = h \u003c 1.2 ? 0 : (x + 0.5 - xc) / h;\n      put(x, y, u > 0.7 || u \u003c -0.85 ? 2 : u > -0.6 && u \u003c -0.15 ? 4 : 3);\n    }\n  };\n  // The stone ledge and its slime coat.\n  for (let x = 0; x \u003c W; x++) {\n    for (let y = 0; y \u003c STONE; y++) put(x, y, y === STONE - 1 || ((x * 7 + y * 13) % 11 === 0 && y > 0) ? 7 : 6);\n    const c = round(coat(S, x));\n    for (let y = STONE; y \u003c c; y++) put(x, y, y === STONE ? 4 : y === c - 1 ? 2 : 3);\n  }\n  // Drips: a root that tapers into the neck, and the bulb under it.\n  for (const d of S.drips) {\n    const y0 = coat(S, d.x) - 1, X = d.L * sin(d.th), k = 3 + 0.12 * d.L;\n    const yb = y0 + d.L * cos(d.th), R = d.R, ry = R * 1.12;\n    for (let y = floor(y0); y \u003c= min(H - 1, ceil(yb + ry)); y++) {\n      const dd = y + 0.5 - y0;\n      if (dd \u003c= d.L) {\n        const f = dd / max(1, d.L);\n        const lump = d.L > 18 && (d.phase === \"stretch\" || d.phase === \"hang\") ? 1.1 * exp(-(((dd - d.lump) / 2.5) ** 2)) : 0;\n        span(y, d.x + X * f * f, d.neck + (d.root - d.neck) * exp(-dd / k) + lump);\n      }\n      const dy = (y + 0.5 - yb) / ry;\n      if (abs(dy) \u003c 1) span(y, d.x + X, R * sqrt(1 - dy * dy));\n    }\n    if (R > 2) put(d.x + X - R * 0.45, yb - ry * 0.45, 5);\n  }\n  // Falling drops: round below, drawn out to a point above as they speed up.\n  for (const p of S.drops) {\n    const s = 1 + p.vy / 260, rx = p.R / sqrt(s), ry = p.R * s;\n    for (let y = floor(p.y - ry * 1.7); y \u003c= p.y + ry; y++) {\n      const dy = (y + 0.5 - p.y) / ry;\n      const h = dy >= 0 ? rx * sqrt(max(0, 1 - dy * dy)) : rx * max(0, 1 + dy / 1.7) ** 1.4;\n      if (h > 0.3) span(y, p.x, max(0.5, h));\n    }\n    if (p.R > 1.5) put(p.x - rx * 0.4, p.y - ry * 0.35, 5);\n  }\n  // The puddle: a bright skin, slime under it and deep slime below.\n  for (let x = 0; x \u003c W; x++) {\n    const top = round(surface(S, x));\n    for (let y = max(0, top); y \u003c H; y++) put(x, y, y === top ? 4 : y \u003c top + 4 ? 3 : 8);\n  }\n  for (const b of S.bubs) {\n    if (b.dome \u003c 0) {\n      // A rising bubble: a bright ring in the deep slime.\n      const r = b.r;\n      for (let a = 0; a \u003c 12; a++) put(b.x + r * cos((a * PI) / 6), b.y + r * sin((a * PI) / 6), 9);\n    } else {\n      const r = b.r * min(1, b.dome / 0.2 + 0.3);\n      for (let y = floor(b.y - r); y \u003c= b.y; y++) {\n        const dy = (y + 0.5 - b.y) / r;\n        if (abs(dy) \u003c 1) span(y, b.x, r * sqrt(1 - dy * dy));\n      }\n      put(b.x - r * 0.4, b.y - r * 0.6, 5);\n    }\n  }\n  for (const b of S.bits) {\n    put(b.x, b.y, 3);\n    if (b.big) put(b.x + 1, b.y, 3), put(b.x, b.y - 1, 4);\n  }\n  for (const f of S.flashes) {\n    const r = f.r + f.age * 40;\n    for (let a = 0; a \u003c 16; a++) put(f.x + r * cos((a * PI) / 8), f.y - abs(r * 0.6 * sin((a * PI) / 8)), 5);\n  }\n  // Glow: one LED of light round every bit of slime.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      if (tone[o]) continue;\n      let lit = false;\n      for (let j = max(0, y - 1); j \u003c= min(H - 1, y + 1) && !lit; j++)\n        for (let i = max(0, x - 1); i \u003c= min(W - 1, x + 1); i++) {\n          const v = tone[j * W + i];\n          if (v >= SLIME && v \u003c= 5) {\n            lit = true;\n            break;\n          }\n        }\n      if (lit) tone[o] = 1;\n    }\n  // And a fainter LED round that.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      if (tone[o]) continue;\n      if ((x > 0 && tone[o - 1] === 1) || (x \u003c W - 1 && tone[o + 1] === 1) || (y > 0 && tone[o - W] === 1) || (y \u003c H - 1 && tone[o + W] === 1)) tone[o] = 10;\n    }\n  const h = 0.31 + 0.62 * S.hue;\n  hsv(h, 1, 0.26, pal[1]);\n  hsv(h, 1, 0.13, pal[10]);\n  hsv(h + 0.01, 1, 0.55, pal[2]);\n  hsv(h, 0.92, 0.86, pal[3]);\n  hsv(h - 0.04, 0.6, 1, pal[4]);\n  hsv(h - 0.04, 0.16, 1, pal[5]);\n  hsv(h + 0.47, 0.6, 0.3, pal[6]);\n  hsv(h + 0.47, 0.5, 0.46, pal[7]);\n  hsv(h + 0.02, 1, 0.42, pal[8]);\n  hsv(h + 0.47, 0.45, 0.9, pal[9]);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const t = tone[o];\n      if (!t) continue;\n      const c = pal[t];\n      display.setPixel(x, y, round(c[0] * 255), round(c[1] * 255), round(c[2] * 255));\n    }\n}\n","bone-jig":"// ===== Patternflow pattern =====\n// Title:   Bone Jig\n// Family:  halloween\n// Idea:    A skeleton the height of the panel dances on a black floor lit from below by a toxic green pool, its jaw clacking on the beat, going through a hopping jig, side kicks, swinging arms, a hip shake, a spin and a rattling shiver, every bone a knobbed capsule rimmed with the glow.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the jointed dancing skeletons of Halloween decorations and the danse macabre\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Glow=0..1, Speed=0.2..3, Dancers=1..3, Trails=0..1\n//\n// Knob 1: Glow. Three lights round the knob: at 0 a toxic green pool with a violet rim, at 0.33 an orange one with violet, at 0.67 a violet one with green. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again. The bones stay near white, 12 percent of the light in them; the light takes their lower edges, the embers in the eye sockets and the pool, and the faint haze round them fades through the rim colour, so a dim orange never reads brown.\n// Knob 2: Speed. The tempo: 2 is 96 beats a minute, and the six moves take 8, 8, 8, 8, 4 and 4 beats, 25 seconds in all. At 0.2 the round takes 250 seconds, at 3 about 17.\n// Knob 3: Dancers, 1 to 3. At 2 a second skeleton 0.6 the size dances on the right, standing 10 rows further back on the floor and dimmer, a quarter beat behind the first; at 3 a third on the left dances the same moves mirrored. Both stand behind the first.\n// Knob 4: Trails. Afterimages behind every moving bone, in the light's colour where they are strong and the rim colour where they fade. Up to 0.1 almost none; at 1 a swinging leg leaves a fan of them that fades by half in 0.28 seconds.\n// Buttons: K1 tap pops the skull off: it flies up out of the top of the panel with its jaw chattering, spins twice and drops back onto the neck 1.4 seconds later while the body dances on with its arms up.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sstep = (t) => {\n  t = cl(t, 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// Bone lengths in LEDs for the first dancer before its scale.\nconst FEMUR = 22, TIBIA = 21, HUMERUS = 16, ULNA = 14, SPINE = 29, NECK = 5, SKULL = 8.6;\nconst HIP_X = 6, HIP_Y = 3, SHOULDER_X = 11;\n// Ribs: half width, droop toward the breastbone, for four pairs.\nconst RIBS = [[8.2, 3.2], [9.8, 3.8], [10.2, 4.2], [9.2, 4]];\n// Floor row for the first dancer and for the two behind it.\nconst FLOOR = 122, FLOOR_BACK = 112;\n// Lights round K1: the glow (pool, bone rims, eye embers) and the rim\n// colour round the pool, on the floor line and in faint haze.\nconst PAL = [\n  [[0.42, 1, 0.12], [0.55, 0.18, 0.95]],\n  [[1, 0.5, 0.06], [0.6, 0.2, 1]],\n  [[0.72, 0.32, 1], [0.3, 0.95, 0.25]],\n];\nconst BONE = [1, 0.95, 0.84];\n\n// A pose is 25 numbers: root shift x and hop y, turn about the vertical,\n// torso lean, pelvis tilt, spine bend, head tilt, jaw, shoulder shimmy,\n// then for the screen-left and screen-right arm and leg the upper bone's\n// angle out from straight down and its pitch toward the viewer, and the\n// same for the lower bone.\nconst PX = 0, PY = 1, SPIN = 2, LEAN = 3, TILT = 4, CURVE = 5, HEAD = 6, JAW = 7, SHIM = 8, ARM = 9, LEG = 17, NP = 25;\nconst limb = (o, at, s, a1, p1, a2, p2) => {\n  const k = at + 4 * s;\n  (o[k] = a1), (o[k + 1] = p1), (o[k + 2] = a2), (o[k + 3] = p2);\n};\nconst clack = (b) => max(0, sin(TAU * b)) ** 2;\n\n// The moves, each a function of the beat b since it started.\nfunction jig(b, o) {\n  // Hop on alternate feet: four beats of knees up, four of the foot\n  // flicked out to the side; the arms flap out a little on each hop.\n  const f = b - floor(b), side = floor(b) & 1, lift = sin(PI * f) ** 1.3, flick = sstep(b - 3.6);\n  o[PX] = 1.6 * sin(PI * b);\n  o[PY] = -3.5 * lift;\n  o[SPIN] = 0.2 * sin((PI * b) / 2);\n  o[LEAN] = 0.05 * sin(PI * b);\n  o[TILT] = (side ? -0.1 : 0.1) * lift;\n  o[HEAD] = 0.12 * sin(PI * b);\n  o[JAW] = clack(b);\n  for (const s of [0, 1]) limb(o, ARM, s, 0.14 + 0.3 * lift, 0.1, 0.1 + 0.5 * lift, 0);\n  limb(o, LEG, side, mix(0.1, 0.3, flick) * lift, mix(1.3, 0.5, flick) * lift, mix(-0.1, 1.1, flick) * lift, mix(-0.15, 0.2, flick) * lift);\n  limb(o, LEG, 1 - side, 0.03, 0, 0.02, 0);\n}\n\nfunction kicks(b, o) {\n  // Kick out to alternate sides, leaning away; hands on hips for four\n  // beats, then fists pumping overhead.\n  const f = b - floor(b), side = floor(b) & 1, sg = side ? 1 : -1, k = sin(PI * f) ** 0.8, up = sstep(b - 3.6);\n  o[PX] = -sg * 3.5 * k;\n  o[PY] = -1 * k;\n  o[SPIN] = sg * 0.15 * k;\n  o[LEAN] = -sg * 0.14 * k;\n  o[TILT] = -sg * 0.1 * k;\n  o[HEAD] = sg * 0.12 * k;\n  o[JAW] = clack(b);\n  for (const s of [0, 1]) limb(o, ARM, s, mix(0.8, 2.45 + 0.2 * k, up), mix(0.15, 0, up), mix(-0.85, 3.1 - 0.35 * k, up), mix(0.35, 0, up));\n  limb(o, LEG, side, 0.65 * k, 0.3 * k, 0.9 * k, 0.15 * k);\n  limb(o, LEG, 1 - side, -0.05 * k, 0, -0.03 * k, 0);\n}\n\nfunction windmill(b, o) {\n  // Arms swing over and down in turn, forearms bent up so the hands stay\n  // on the panel; the knees twist in and out, Charleston fashion.\n  const th = (PI * b) / 2, tw = sin(PI * b);\n  for (const s of [0, 1]) {\n    const c = cos(th + s * PI), a1 = 1.45 - 1.25 * c;\n    limb(o, ARM, s, a1, 0.25 * sin(th + s * PI), a1 + 1.6, 0);\n    limb(o, LEG, s, 0.06 + 0.12 * tw, 0.1, 0.04 - 0.28 * tw, 0);\n  }\n  o[SPIN] = 0.3 * sin(th);\n  o[LEAN] = 0.08 * sin(th);\n  o[HEAD] = -0.1 * sin(th);\n  o[JAW] = clack(b);\n}\n\nfunction hips(b, o) {\n  // Hips out to one side each beat, chest held over the feet, the other\n  // knee bent; arms up in a Y with the hands waving.\n  const sw = sin(PI * b);\n  o[PX] = 5.5 * sw;\n  o[TILT] = -0.25 * sw;\n  o[LEAN] = -0.2 * sw;\n  o[CURVE] = 0.5 * sw;\n  o[HEAD] = 0.1 * sw;\n  o[JAW] = clack(2 * b);\n  for (const s of [0, 1]) {\n    const sg = s ? 1 : -1, bend = max(0, -sg * sw);\n    limb(o, ARM, s, 2.55 - 0.12 * sg * sw, 0.1, 3.0 + 0.35 * sin(TAU * b + s * PI), 0);\n    limb(o, LEG, s, 0.04 + 0.02 * (1 - bend), 0.5 * bend, 0.04 - 0.14 * bend, -0.3 * bend);\n  }\n}\n\nfunction spin(b, o) {\n  // One whole turn on one foot, the other drawn up to the knee.\n  const e = sstep(b / 3.2);\n  o[SPIN] = TAU * e;\n  o[PY] = -2.5 * sin(PI * min(1, b / 3.2));\n  o[JAW] = 0.7;\n  for (const s of [0, 1]) limb(o, ARM, s, 1.2, 0.25, 2.5, 0);\n  limb(o, LEG, 1, 0.35, 1.0, -0.55, 0.2);\n  limb(o, LEG, 0, 0.02, 0, 0.02, 0);\n}\n\nfunction rattle(b, o) {\n  // A crouched shiver: shoulders shaking four times a beat, knees\n  // knocking, teeth chattering.\n  const q = sin(8 * PI * b);\n  o[SHIM] = 1.6 * q;\n  o[JAW] = 0.5 + 0.5 * sin(16 * PI * b);\n  o[HEAD] = 0.12 * sin(4 * PI * b);\n  for (const s of [0, 1]) {\n    limb(o, ARM, s, 0.95, 0.35, -1.25 + 0.3 * q, 0.5);\n    limb(o, LEG, s, 0.22 + 0.1 * q, 0.45, -0.2 - 0.1 * q, -0.45);\n  }\n}\n\nconst MOVES = [[jig, 8], [kicks, 8], [windmill, 8], [hips, 8], [spin, 4], [rattle, 4]];\nconst ROUND = MOVES.reduce((a, m) => a + m[1], 0);\n// The last BLEND of a beat of each move eases into the next one's start.\nconst BLEND = 0.6;\n\nfunction pose(B, out, tmp) {\n  let b = B - floor(B / ROUND) * ROUND, m = 0;\n  while (b >= MOVES[m][1]) (b -= MOVES[m][1]), m++;\n  out.fill(0);\n  MOVES[m][0](b, out);\n  out[SPIN] -= TAU * round(out[SPIN] / TAU);\n  const w = sstep((b - (MOVES[m][1] - BLEND)) / BLEND);\n  if (w > 0) {\n    tmp.fill(0);\n    MOVES[(m + 1) % MOVES.length][0](0, tmp);\n    for (let i = 0; i \u003c NP; i++) out[i] = mix(out[i], tmp[i], w);\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, count: 1, trail: 0.06, beat: 0, dt: 0,\n    // Skull flight after a K1 tap: seconds since, or -1.\n    fly: -1,\n    pose: new Float64Array(NP), tmp: new Float64Array(NP),\n    rgb: new Float32Array(N * 3), a: new Float32Array(N), halo: new Float32Array(N), blur: new Float32Array(N), ghost: new Float32Array(N),\n    prims: [],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 1, 3);\n  S.trail = cl(k[3], 0, 1);\n  S.beat += d * S.speed * 0.8;\n  S.dt = d;\n  if (input.btnPressed && input.btnPressed[0] && S.fly \u003c 0) S.fly = 0;\n  if (S.fly >= 0) {\n    S.fly += d;\n    if (S.fly > 1.75) S.fly = -1;\n  }\n}\n\n// --- the body ---\n\n// A unit vector for a bone on side sg (-1 screen left, 1 right): angle a\n// out from straight down, pitch p toward the viewer (negative z).\nfunction dir(sg, a, p) {\n  const cp = cos(p);\n  return [sg * sin(a) * cp, cos(a) * cp, -sin(p)];\n}\nconst rot = (v, a) => [v[0] * cos(a) - v[1] * sin(a), v[0] * sin(a) + v[1] * cos(a), v[2]];\nconst add = (a, b, k = 1) => [a[0] + k * b[0], a[1] + k * b[1], a[2] + k * b[2]];\n\n// Build one dancer as primitives on the panel. kind 0 a plain capsule,\n// 1 a long bone with knobbed ends, 2 a disc, 3 the skull.\nfunction build(S, P, cx, floorY, sc, mirror, dim, flyY, flySpin, armsUp, back) {\n  const out = S.prims, lean = P[LEAN], tilt = P[TILT], sh = P[SHIM];\n  const segs = [];\n  const seg = (a, b, r, kind) => segs.push([a, b, r, kind]);\n  // Pelvis: two wings, the arch in front and the sacrum behind.\n  const pel = (x, y, z) => rot([x, y, z], tilt);\n  for (const sg of [-1, 1]) {\n    const pts = [[1.5, -4, 1.5], [8, -7, 1], [10.5, -3, 0.5], [8, 1.5, -0.5], [HIP_X, HIP_Y, 0], [3, 6, -2], [0, 6.5, -2.5]].map(([x, y, z]) => pel(sg * x, y, z));\n    for (let i = 0; i + 1 \u003c pts.length; i++) seg(pts[i], pts[i + 1], 1.15, 0);\n  }\n  const base = pel(0, -5, 2);\n  seg(base, pel(0, 2, 2.5), 1.5, 0);\n  // Spine, bent sideways by CURVE and leant by LEAN; the vertebrae are\n  // beads along it.\n  const torso = (v) => add(base, rot(v, lean));\n  let prev = base;\n  for (let i = 1; i \u003c= 8; i++) {\n    const u = i / 8, q = torso([P[CURVE] * 6 * sin(PI * u), -SPINE * u, 1.5 + 2 * sin(PI * u)]);\n    seg(prev, q, 0.7, 0);\n    segs.push([q, q, 1.35, 2]);\n    prev = q;\n  }\n  const neck = prev, chest = (x, y, z) => add(neck, rot([x, y, z], lean));\n  // Ribs: half ellipses round from the spine to the breastbone, dipping\n  // toward the front, and the breastbone down the middle.\n  RIBS.forEach(([w, droop], k) => {\n    for (const sg of [-1, 1]) {\n      let p0 = null;\n      for (let j = 0; j \u003c= 6; j++) {\n        const th = 0.25 + ((PI - 0.6) * j) / 6;\n        const p = chest(sg * w * sin(th) + 0.5 * sh, 4 + 5.2 * k + (droop * (1 - cos(th))) / 2, 0.75 * w * cos(th));\n        if (p0) seg(p0, p, 0.75, 0);\n        p0 = p;\n      }\n    }\n  });\n  seg(chest(0.5 * sh, 4 + RIBS[0][1], -6), chest(0.5 * sh, 4 + 5.2 * 3 + RIBS[3][1], -7), 1, 0);\n  // Shoulders, collarbones and arms.\n  for (const s of [0, 1]) {\n    const sg = s ? 1 : -1, o = ARM + 4 * s, w = armsUp;\n    const sho = chest(sg * SHOULDER_X + sh, 3, 0);\n    seg(chest(0, 1, -2), sho, 0.9, 0);\n    // Arms thrown up for the flying skull swing up through the front, so a\n    // straight arm never sweeps out past the panel's sides.\n    const a1 = mix(P[o], 2.7, w), p1 = mix(P[o + 1], 0, w) + 1.3 * sin(PI * w), a2 = mix(P[o + 2], 3.0, w), p2 = mix(P[o + 3], 0, w) + 1.1 * sin(PI * w);\n    const elb = add(sho, rot(dir(sg, a1, p1), lean), HUMERUS), d2 = rot(dir(sg, a2, p2), lean), wri = add(elb, d2, ULNA);\n    seg(sho, elb, 1.05, 1);\n    seg(elb, wri, 0.95, 1);\n    // A bony hand: palm knob and three fingers fanned along the forearm.\n    segs.push([add(wri, d2, 1.2), add(wri, d2, 1.2), 1.5, 2]);\n    for (const f of [-0.45, 0, 0.45]) {\n      const fd = rot(d2, f * sg);\n      seg(add(wri, d2, 1.5), add(wri, fd, 5), 0.55, 0);\n    }\n  }\n  // Legs and feet.\n  let low = -1e9;\n  const legs = [];\n  for (const s of [0, 1]) {\n    const sg = s ? 1 : -1, o = LEG + 4 * s;\n    const hip = pel(sg * HIP_X, HIP_Y, 0);\n    const kne = add(hip, dir(sg, P[o], P[o + 1]), FEMUR), ank = add(kne, dir(sg, P[o + 2], P[o + 3]), TIBIA);\n    const fd = [sg * 0.45, 0.3, -0.84], toe = add(ank, fd, 5);\n    legs.push([hip, kne, ank, toe]);\n    low = max(low, ank[1] + 1.5, toe[1] + 1);\n  }\n  for (const [hip, kne, ank, toe] of legs) {\n    segs.push([hip, hip, 2, 2]);\n    seg(hip, kne, 1.2, 1);\n    seg(kne, ank, 1.1, 1);\n    seg(ank, toe, 1.1, 0);\n  }\n  // Neck and skull.\n  const nt = add(neck, rot(rot([0, -NECK, 0], P[HEAD] * 0.5), lean));\n  seg(neck, nt, 1.1, 0);\n  segs.push([nt, nt, 1.3, 2]);\n  const sk = add(nt, rot(rot([0, -SKULL * 0.95, 0], P[HEAD]), lean));\n  // Turn about the vertical through the root, mirror, scale and place\n  // with the lowest foot on the floor.\n  const sp = P[SPIN], cs = cos(sp), sn = sin(sp), m = mirror ? -1 : 1;\n  const ry = floorY - low * sc + P[PY] * sc, rx = cx + m * P[PX] * sc;\n  const proj = (v) => {\n    const x = (v[0] * cs + v[2] * sn) * m, z = -v[0] * sn + v[2] * cs;\n    return [rx + x * sc, ry + v[1] * sc, z];\n  };\n  for (const [a, b, r, kind] of segs) {\n    const A = proj(a), B = proj(b);\n    out.push({ kind, x0: A[0], y0: A[1], x1: B[0], y1: B[1], z: (A[2] + B[2]) / 2 + back, r: r * sc, dim });\n  }\n  const C = proj(sk);\n  out.push({ kind: 3, x0: C[0], y0: C[1] + flyY * sc, z: C[2] - 1 + back, r: SKULL * sc, dim, yaw: m * (sp + flySpin), roll: m * (P[HEAD] + lean), jaw: P[JAW] });\n}\n\n// --- drawing ---\n\nfunction shade(S, ny, y, dim, out, edge = 1) {\n  // Lit from below: the lower edge takes the glow, more so near the floor;\n  // the upper edge is a little darker.\n  const g = S.glow, rim = max(0, ny) * edge, low = cl((y - 40) / 85, 0, 1);\n  const t = cl(0.05 + 0.75 * rim ** 3 + 0.2 * low, 0, 0.85), lum = (0.86 + 0.14 * rim + 0.22 * min(0, ny)) * dim;\n  // Bone white, a little of the light's colour in it everywhere.\n  for (let c = 0; c \u003c 3; c++) out[c] = mix(mix(BONE[c], g[c], 0.12) * lum, g[c] * dim, t);\n}\n\nconst COL = [0, 0, 0];\n\nfunction capsule(S, p) {\n  const { rgb, a } = S, r = p.r, knob = p.kind === 1, x0 = p.x0, y0 = p.y0, x1 = p.x1, y1 = p.y1;\n  const dx = x1 - x0, dy = y1 - y0, ll = dx * dx + dy * dy, len = sqrt(ll) || 1;\n  const nx = -dy / len, ny = dx / len, lo = 0.7 * r, lr = 0.78 * r + 0.15, ux = dx / len, uy = dy / len;\n  const pad = r + 2.6;\n  const xa = max(0, floor(min(x0, x1) - pad)), xb = min(W - 1, floor(max(x0, x1) + pad));\n  const ya = max(0, floor(min(y0, y1) - pad)), yb = min(H - 1, floor(max(y0, y1) + pad));\n  // Knobs: two lobes at each end, set a little in from the joint.\n  const L = knob ? [[x0 + ux * 0.4 * r + nx * lo, y0 + uy * 0.4 * r + ny * lo], [x0 + ux * 0.4 * r - nx * lo, y0 + uy * 0.4 * r - ny * lo], [x1 - ux * 0.4 * r + nx * lo, y1 - uy * 0.4 * r + ny * lo], [x1 - ux * 0.4 * r - nx * lo, y1 - uy * 0.4 * r - ny * lo]] : [];\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      const u = ll > 0 ? cl(((px - x0) * dx + (py - y0) * dy) / ll, 0, 1) : 0;\n      let cx = x0 + u * dx, cy = y0 + u * dy, dd = sqrt((px - cx) ** 2 + (py - cy) ** 2) - r;\n      for (let k = 0; k \u003c L.length; k++) {\n        const lx = L[k][0], ly = L[k][1], e = sqrt((px - lx) ** 2 + (py - ly) ** 2) - lr;\n        if (e \u003c dd) (dd = e), (cx = lx), (cy = ly);\n      }\n      const o = y * W + x;\n      // A dark line round each bone where it passes in front of another.\n      if (dd > 0.5) {\n        if (dd \u003c 1.3) for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] *= 0.35;\n        continue;\n      }\n      const cov = cl(0.5 - dd, 0, 1), dl = sqrt((px - cx) ** 2 + (py - cy) ** 2) || 1;\n      shade(S, (py - cy) / dl, py, p.dim, COL);\n      for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] = mix(rgb[o * 3 + c], COL[c], cov);\n      if (cov > a[o]) a[o] = cov;\n    }\n}\n\nfunction skull(S, p) {\n  const { rgb, a } = S, r = p.r, cx = p.x0, cy = p.y0, yaw = p.yaw, cr = cos(p.roll), sr = sin(p.roll);\n  const vn = cos(yaw), sn = sin(yaw), rx = r * (0.92 + 0.14 * abs(sn)), ry = r, rm = min(rx, ry);\n  // The jaw hangs below the cranium and drops as it opens; seen from the\n  // side it juts forward.\n  const jo = cl(p.jaw, 0, 1), fwd = sn * r * 0.35;\n  const jx = fwd, jy = 0.74 * r + 0.3 * r * jo, jrx = 0.58 * r * (0.62 + 0.38 * abs(vn)), jry = 0.37 * r;\n  // Mouth with a row of teeth along each lip, the nose, and the two eye\n  // sockets, each turned with the head and faded as it turns away.\n  const mouthY = 0.8 * r + 0.15 * r * jo, mh = 0.05 * r + 0.18 * r * jo, mw = 0.42 * r * (0.55 + 0.45 * abs(vn)), mx = fwd * 0.7;\n  const nx = sn * rx * 0.95, ny = 0.42 * r, nw = 0.13 * r * vn + 0.35;\n  const eyes = [-0.48, 0.48].map((f) => {\n    const vis = cos(f + yaw);\n    return [vis, sin(f + yaw) * rx * 0.82, 0.04 * r, 0.3 * r * (0.35 + 0.65 * vis), 0.3 * r];\n  }).filter((e) => e[0] >= 0.12);\n  const ex = S.ember, glow = S.glow, dim = p.dim;\n  const pad = r * 1.3 + 4;\n  for (let y = max(0, floor(cy - pad)); y \u003c= min(H - 1, floor(cy + pad + r)); y++)\n    for (let x = max(0, floor(cx - pad)); x \u003c= min(W - 1, floor(cx + pad)); x++) {\n      // Into the skull's own frame, rolled with the head.\n      const qx = x + 0.5 - cx, qy = y + 0.5 - cy, X = qx * cr + qy * sr, Y = -qx * sr + qy * cr;\n      const dc = sqrt((X / rx) ** 2 + (Y / ry) ** 2), dj = sqrt(((X - jx) / jrx) ** 2 + ((Y - jy) / jry) ** 2);\n      const ec = (1 - dc) * rm, ej = (1 - dj) * jry;\n      const e = max(ec, ej), o = y * W + x;\n      if (e \u003c -0.5) {\n        if (e > -1.3) for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] *= 0.35;\n        continue;\n      }\n      const cov = cl(e + 0.5, 0, 1), onC = ec >= ej;\n      const nyv = onC ? Y / ry / max(dc, 1e-3) : (Y - jy) / jry / max(dj, 1e-3);\n      shade(S, cl(nyv, -1, 1), y + 0.5, dim, COL, sstep(((onC ? dc : dj) - 0.6) / 0.4));\n      let dark = 0, ember = 0;\n      if (vn > 0.2 && ec \u003c ej + 0.6 && abs(Y - mouthY) \u003c mh + 0.5 && abs(X - mx) \u003c mw) {\n        const tooth = (X - mx) / (0.21 * r) + 10.25, gap = tooth - floor(tooth) \u003c 0.3;\n        dark = abs(Y - mouthY) > mh - 1 && !gap ? 0 : 1;\n      }\n      for (const [vis, fx, fy, ew, eh] of eyes) {\n        const de = ((X - fx) / ew) ** 2 + ((Y - fy) / eh) ** 2;\n        if (de \u003c 1) {\n          dark = 1;\n          if (de \u003c 0.16) ember = max(ember, vis * (1 - de / 0.16));\n        }\n      }\n      // The nose: a small triangle pointing down.\n      if (vn > 0.15 && Y > ny && Y \u003c ny + 0.22 * r && abs(X - nx) \u003c nw * (1 - (Y - ny) / (0.26 * r))) dark = 1;\n      for (let c = 0; c \u003c 3; c++) {\n        const v = dark ? (0.04 + ex * ember * glow[c]) * dim : COL[c];\n        rgb[o * 3 + c] = mix(rgb[o * 3 + c], v, cov);\n      }\n      if (cov > a[o]) a[o] = cov;\n    }\n}\n\nfunction lights(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  S.glow = [0, 1, 2].map((c) => mix(PAL[i][0][c], PAL[j][0][c], s));\n  S.rim = [0, 1, 2].map((c) => mix(PAL[i][1][c], PAL[j][1][c], s));\n}\n\n// Box blur of src into dst, radius 2, across then down.\nfunction blur(src, tmp, dst) {\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let k = -2; k \u003c= 2; k++) s += src[y * W + cl(x + k, 0, W - 1)];\n      tmp[y * W + x] = s / 5;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let s = 0;\n      for (let k = -2; k \u003c= 2; k++) s += tmp[cl(y + k, 0, H - 1) * W + x];\n      dst[y * W + x] = s / 5;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  lights(S);\n  const { rgb, a, halo, ghost } = S, P = S.pose;\n  rgb.fill(0);\n  a.fill(0);\n  S.prims.length = 0;\n  const pulse = 0.5 + 0.5 * cos(TAU * S.beat);\n  S.ember = 0.75 + 0.25 * pulse;\n  // The skull's flight: up out of the panel and back in 1.4 seconds, two\n  // turns, then a little bounce on the neck.\n  let flyY = 0, flySpin = 0, armsUp = 0;\n  if (S.fly >= 0) {\n    const u = S.fly / 1.4;\n    if (u \u003c 1) {\n      flyY = -150 * u * (1 - u);\n      flySpin = 2 * TAU * sstep(u);\n      armsUp = sin(PI * u) ** 0.6;\n    } else flyY = -3 * sin(PI * cl((S.fly - 1.4) / 0.35, 0, 1));\n  }\n  // Backing dancers first: smaller, dimmer, a quarter beat behind, the\n  // one on the left mirrored.\n  if (S.count > 1) {\n    pose(S.beat - 0.25, P, S.tmp);\n    const backs = S.count > 2 ? [12, 52] : [50];\n    for (const bx of backs) build(S, P, bx, FLOOR_BACK, 0.6, bx \u003c 32, 0.72, 0, 0, 0, 100);\n  }\n  pose(S.beat, P, S.tmp);\n  if (S.fly >= 0 && S.fly \u003c 1.4) P[JAW] = 0.5 + 0.5 * sin(TAU * 7 * S.fly);\n  build(S, P, 32, FLOOR, 1.08, false, 1, flyY, flySpin, armsUp, 0);\n  S.prims.sort((p, q) => q.z - p.z);\n  for (const p of S.prims) (p.kind === 3 ? skull : capsule)(S, p);\n  // Haze round the bones, and the afterimages.\n  blur(a, S.blur, halo);\n  const keep = (0.5 + 0.42 * S.trail) ** (S.dt * 30), gain = sstep(S.trail / 0.6);\n  for (let o = 0; o \u003c N; o++) ghost[o] = max(ghost[o] * keep, a[o]);\n  const g = S.glow, rim = S.rim;\n  for (let y = 0, o = 0; y \u003c H; y++) {\n    // The floor: a pool of light under the first dancer with a rim of the\n    // second colour, and a faint floor line.\n    const fy = (y + 0.5 - FLOOR - 1.5) / 5.5;\n    for (let x = 0; x \u003c W; x++, o++) {\n      const fx = (x + 0.5 - 32) / 27, q = sqrt(fx * fx + fy * fy);\n      const pool = max(0, 1 - q) ** 1.3 * (0.9 + 0.1 * pulse), ring = max(0, 1 - abs(q - 0.95) / 0.35) * 0.35;\n      const line = abs(y - FLOOR - 2) \u003c 0.6 ? 0.16 * max(0, 1 - abs(fx) / 1.25) : 0;\n      const hz = 0.22 * halo[o] * (1 - a[o]), gh = gain * 0.9 * max(0, ghost[o] - a[o]);\n      // Bones are already weighted by their cover, and the light shows\n      // round them in steps of 1/24: a smooth ramp costs more to store than\n      // it shows. Faint haze and afterimages take the rim colour, so a faint\n      // orange never reads brown; the brighter, the more the glow's own.\n      const al = 1 - a[o], lp = round(pool * 0.75 * 24) / 24, lh = round((hz + gh) * 24) / 24, lr = round((ring + line) * 24) / 24;\n      const wg = sstep((lh - 0.3) * 2.5);\n      const r = rgb[o * 3] + min(1, g[0] * lp + mix(rim[0], g[0], wg) * lh + rim[0] * lr) * al;\n      const gg = rgb[o * 3 + 1] + min(1, g[1] * lp + mix(rim[1], g[1], wg) * lh + rim[1] * lr) * al;\n      const b = rgb[o * 3 + 2] + min(1, g[2] * lp + mix(rim[2], g[2], wg) * lh + rim[2] * lr) * al;\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, gg)), round(255 * min(1, b)));\n    }\n  }\n}\n","grave-hand":"// ===== Patternflow pattern =====\n// Title:   Grave Hand\n// Family:  halloween\n// Idea:    Under a big low moon a headstone and a heap of fresh grave earth stand black; the heap heaves and cracks with green light, a bony hand bursts out of it throwing clods, gropes and claws at the air in front of the moon, then sinks back and the earth settles, and it all begins again a few seconds later.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the hand rising from the grave of Halloween yard decorations\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Hands=1..3, Fog=0..1\n//\n// Knob 1: Colour. Three palettes round the knob: at 0 an orange moon in a purple sky, with toxic green light from the grave on the hands; at 0.33 a sickly green moon and orange light; at 0.67 a lilac moon and green light. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 a round takes 12 to 13 seconds: the earth heaves for 1.6, the hand is out in 0.45, gropes for 4.2, sinks back in three pulls over 2.2, the heap settles for 1.5 and rests 0.8 to 2.2. The first hand bursts out at 2.3 seconds. At 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Hands, 1 to 3. The first comes up in the middle of the heap in front of the moon, its fingertips 56 LEDs above the hole at full stretch. The second, 0.86 its size, comes up on the right, and the third, 0.82, on the left in front of the headstone; each keeps its own round, so they rise and sink out of step.\n// Knob 4: Fog. How high and thick the ground fog lies. At 0 a thin layer fills the bottom 29 rows; at 1 it climbs to row 55, over the heap and the lower half of the moon, three times as thick. Over a glowing hole it is lit the colour of the grave light.\n// Buttons: K1 tap brings every hand that is under the earth, resting, heaving, sinking or settling, bursting out at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The moon, low behind the grave.\nconst MX = 35, MY = 58, MR = 25;\n// The ground line, and the mound of fresh earth on it: centre, half width,\n// height.\nconst GY = 105, KX = 37, KW = 27, KH = 13;\n// Palettes, cycled by K1: sky top, sky at the horizon, moon, moon's bright\n// limb, rim light on the hands, glow from the grave, fog, lit edge of earth.\nconst PAL = [\n  [[0.02, 0, 0.05], [0.24, 0.06, 0.32], [1, 0.55, 0.12], [1, 0.8, 0.45], [0.45, 1, 0.12], [0.35, 1, 0.1], [0.55, 0.42, 0.85], [1, 0.55, 0.15]],\n  [[0, 0.02, 0.05], [0.2, 0.04, 0.3], [0.62, 1, 0.22], [0.85, 1, 0.6], [1, 0.5, 0.08], [1, 0.42, 0.05], [0.4, 0.9, 0.35], [0.6, 1, 0.25]],\n  [[0.01, 0, 0.03], [0.13, 0.03, 0.16], [0.82, 0.68, 1], [0.95, 0.9, 1], [0.45, 1, 0.15], [0.4, 1, 0.12], [0.7, 0.45, 1], [0.8, 0.65, 1]],\n];\n// Where each hand comes up: x on the mound, its size, and when its first\n// burst comes, in story seconds (one a second at Speed 2).\nconst HANDS = [\n  { x: 37, s: 1.12, first: 2.3 },\n  { x: 53, s: 0.86, first: 0.9 },\n  { x: 22, s: 0.82, first: 1.3 },\n];\n// One round, in story seconds: the earth heaves, the hand bursts out, gropes,\n// sinks back, and the earth settles.\nconst HEAVE = 1.6, BURST = 0.45, GROPE = 4.2, SINK = 2.2, SETTLE = 1.5;\n// Fingers: base on the palm (local x across, y up, at full size), splay\n// angle, segment lengths, and which way the finger hooks as the hand closes.\n// The last is the thumb. RAD holds the radii at the knuckles and the tip.\nconst FINGERS = [\n  { bx: -3.4, by: 9.2, a: -0.32, len: [4.4, 3.1, 2.7], hook: 1 },\n  { bx: -1.1, by: 10, a: -0.08, len: [4.9, 3.4, 2.9], hook: 0.4 },\n  { bx: 1.2, by: 9.8, a: 0.14, len: [4.6, 3.2, 2.7], hook: -1 },\n  { bx: 3.4, by: 8.8, a: 0.4, len: [3.6, 2.6, 2.3], hook: -1 },\n  { bx: -4.2, by: 3, a: -1.05, len: [3.6, 3.1], hook: 1 },\n];\nconst RAD = [1.35, 1.2, 1.0, 0.55];\n// Upper arm, forearm and hand (wrist to fingertip), and how far the\n// fingertips reach above the hole, all at full size.\nconst UA = 22, FA = 21, HL = 21, REACH = 50;\n\n// The surface of the mound, before any heave: a heap with a few lumps.\nconst mound = (x) => {\n  const q = (x - KX) / KW;\n  return q * q \u003c 1 ? GY - KH * (1 - q * q) ** 0.7 - 0.8 * sin(x * 1.7) * (1 - q * q) : GY;\n};\n\nfunction newHand(d, i) {\n  // The first round starts in the heave, or rests until it is due.\n  const wait = d.first - HEAVE;\n  const cracks = [];\n  for (let c = 0; c \u003c 4; c++) {\n    let a = PI / 2 + (c - 1.5) * 0.75 + 0.3 * (hash(i * 31 + c) - 0.5), x = 0, y = 1;\n    const pts = [[x, y]];\n    for (let k = 0; k \u003c 3; k++) {\n      a += 0.6 * (hash(i * 31 + c * 7 + k) - 0.5);\n      x += cos(a) * (2.5 + 1.5 * hash(i * 17 + c * 5 + k)) * 1.6;\n      y += sin(a) * (2.5 + 1.5 * hash(i * 19 + c * 3 + k)) * 0.7;\n      pts.push([x, y]);\n    }\n    cracks.push(pts);\n  }\n  return {\n    ...d, i, on: false, phase: wait > 0 ? \"rest\" : \"heave\", timer: wait > 0 ? 0 : -wait, rest: max(0, wait),\n    L: 0, from: 0, bump: 0, lift: 0, glow: 0, crack: 0, sway: 0, bend: 0, tilt: 0, open: 0.3, g: 0, cracks,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, pal: -1, colour: 0, speed: 2, count: 1, fog: 0.06,\n    hands: HANDS.map(newHand), clods: [],\n    bg: new Float32Array(N * 3), rgb: new Float32Array(N * 3), sdf: new Float32Array(N), surf: new Float32Array(W), gx: new Float32Array(W),\n  };\n}\n\nfunction spawnClods(S, h, n, fast) {\n  const y0 = mound(h.x) - h.bump;\n  for (let k = 0; k \u003c n; k++) {\n    const a = -PI / 2 + (Math.random() - 0.5) * (fast ? 2.3 : 1.6), v = (fast ? 28 + 52 * Math.random() : 8 + 14 * Math.random()) * (0.6 + 0.4 * h.s);\n    S.clods.push({ x: h.x + (Math.random() - 0.5) * 6 * h.s, y: y0 - 1, vx: cos(a) * v, vy: sin(a) * v, r: fast ? 0.5 + 1.1 * Math.random() : 0.5, life: 3 + Math.random() * 2, hot: fast ? 1 : 0.4, bounces: 0 });\n  }\n}\n\n// A hand at rest or switched off: the heap and the light die down.\nfunction calm(h, d) {\n  const f = exp(-d * 3);\n  h.bump *= f;\n  h.lift *= f;\n  h.glow *= f;\n  h.crack *= f;\n}\n\n// One hand's round. Everything runs on story time d.\nfunction stepHand(S, h, d, tap) {\n  h.timer += d;\n  h.g += d;\n  const s = h.s;\n  // A tap: a hand under the earth bursts out now, even one sinking back.\n  if (tap && h.phase !== \"burst\" && h.phase !== \"grope\") {\n    h.phase = \"heave\";\n    h.timer = HEAVE;\n  }\n  // The pose eases towards what the phase asks for, so nothing snaps when\n  // one phase hands over to the next.\n  const ease = 1 - exp(-d * 9);\n  if (h.phase === \"rest\") {\n    calm(h, d);\n    if (h.timer >= h.rest) {\n      h.phase = \"heave\";\n      h.timer = 0;\n    }\n  }\n  if (h.phase === \"heave\") {\n    const u = cl(h.timer / HEAVE, 0, 1);\n    // The earth swells and trembles over the hand, and a few crumbs hop.\n    h.bump = s * (4.5 * sm(0, 1, u) + 0.9 * u * sin(h.g * 31 + h.i));\n    h.crack = sm(0.35, 1, u);\n    h.glow = 0.3 * u;\n    if (Math.random() \u003c d * 7 * u) spawnClods(S, h, 1, false);\n    if (h.timer >= HEAVE) {\n      h.phase = \"burst\";\n      h.timer = 0;\n      h.from = h.L;\n      spawnClods(S, h, round(26 * s), true);\n    }\n  } else if (h.phase === \"burst\") {\n    const u = cl(h.timer / BURST, 0, 1);\n    // Out in under half a second, a little past full height and back.\n    h.L = mix(h.from, REACH * s * (1 + 0.12 * sin(PI * u)), 1 - (1 - u) ** 3);\n    h.bump = 4.5 * s * (1 - u);\n    h.lift = 3.2 * s * sm(0, 1, u);\n    h.glow = 1;\n    h.open = mix(0.05, 1, u);\n    h.sway += (0.08 * sin(h.g * 5 + h.i) - h.sway) * ease;\n    h.bend += (0 - h.bend) * ease;\n    h.tilt += (0 - h.tilt) * ease;\n    if (h.timer >= BURST) {\n      h.phase = \"grope\";\n      h.timer = 0;\n    }\n  } else if (h.phase === \"grope\") {\n    const t = h.timer;\n    // Groping at the air: the arm sways and stretches, the wrist turns, and\n    // the fingers open wide and close into a claw about once a second.\n    const w = sm(0, 0.8, t);\n    h.L = REACH * s * (1 + w * (0.09 * sin(t * 2.6) - 0.05 * sin(t * 5.1 + 1)));\n    h.sway += (w * (0.2 * sin(t * 1.8 + h.i * 2) + 0.06 * sin(t * 4.1)) - h.sway) * ease;\n    h.bend += (w * 0.5 * sin(t * 1.25 + 2 + h.i) - h.bend) * ease;\n    h.tilt += (w * (0.45 * sin(t * 2.4 + 1 + h.i) + 0.12 * sin(t * 4.7)) - h.tilt) * ease;\n    h.open += (0.5 + 0.5 * sin(t * 6.3 + 1.6) - h.open) * ease;\n    h.glow = mix(1, 0.35, sm(0, 1.5, t));\n    h.crack = 1 - sm(0, 2, t) * 0.5;\n    if (h.timer >= GROPE) {\n      h.phase = \"sink\";\n      h.timer = 0;\n    }\n  } else if (h.phase === \"sink\") {\n    const u = cl(h.timer / SINK, 0, 1);\n    // Back down in three pulls, the fingers clawing at the earth.\n    const pull = (u * 3 + 0.35 * sin(u * 6 * PI)) / 3;\n    h.L = REACH * s * (1 - sm(0, 1, pull)) * (1 + 0.05 * sin(h.g * 4));\n    h.sway *= exp(-d * 1.5);\n    h.bend *= exp(-d * 2);\n    h.tilt += (0.25 * sin(h.timer * 3.1) - h.tilt) * ease;\n    h.open += (0.25 + 0.25 * sin(h.timer * 9) - h.open) * ease;\n    h.glow = 0.35 * (1 - u) + 0.15;\n    h.lift = 3.2 * s * (1 - 0.4 * u);\n    if (h.timer >= SINK) {\n      h.phase = \"settle\";\n      h.timer = 0;\n      h.L = 0;\n    }\n  } else if (h.phase === \"settle\") {\n    h.L = 0;\n    const u = cl(h.timer / SETTLE, 0, 1);\n    // The heap slumps back and wobbles still.\n    h.lift = 1.9 * s * (1 - sm(0, 1, u));\n    h.bump = -1.2 * s * sin(u * PI) * exp(-u * 2);\n    h.glow = 0.15 * (1 - u);\n    h.crack = 0.5 * (1 - u);\n    if (h.timer >= SETTLE) {\n      h.phase = \"rest\";\n      h.timer = 0;\n      h.rest = 0.8 + 1.4 * Math.random();\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.colour = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 1, 3);\n  S.fog = cl(k[3], 0, 1);\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  const tap = !!(input.btnPressed && input.btnPressed[0]);\n  // The hands the knob asks for at the start keep their first schedule; one\n  // turned on later comes up after a short rest.\n  if (!S.begun) for (const h of S.hands) h.on = h.i \u003c S.count;\n  S.begun = true;\n  for (const h of S.hands) {\n    const on = h.i \u003c S.count;\n    if (on && !h.on) {\n      h.phase = \"rest\";\n      h.timer = 0;\n      h.rest = 0.3 + 0.5 * h.i;\n    }\n    h.on = on;\n    if (on) stepHand(S, h, ds, tap);\n    else {\n      h.L = 0;\n      calm(h, ds);\n    }\n  }\n  // Clods: thrown, falling, bouncing once on the heap, then lying on it until\n  // they fade into it.\n  const surf = S.surf;\n  surface(S, surf);\n  for (const c of S.clods) {\n    c.life -= ds;\n    c.hot *= exp(-ds * 2);\n    if (c.bounces \u003c 2) {\n      c.vy += 120 * ds;\n      c.x += c.vx * ds;\n      c.y += c.vy * ds;\n      const xi = cl(floor(c.x), 0, W - 1);\n      if (c.y >= surf[xi] - c.r * 0.5 && c.vy > 0) {\n        c.y = surf[xi] - c.r * 0.5;\n        c.vy *= -0.25;\n        c.vx *= 0.4;\n        c.bounces++;\n      }\n    } else {\n      const xi = cl(floor(c.x), 0, W - 1);\n      c.y = surf[xi] - c.r * 0.5;\n    }\n  }\n  S.clods = S.clods.filter((c) => c.life > 0 && c.x > -3 && c.x \u003c W + 3 && c.y \u003c H + 3);\n}\n\n// The heap's surface now, column by column: the mound, the heave over each\n// hand and the earth pushed up on either side of an arm.\nfunction surface(S, surf) {\n  for (let x = 0; x \u003c W; x++) {\n    let y = mound(x + 0.5);\n    for (const h of S.hands) {\n      const dx = x + 0.5 - h.x, w = 5.5 * h.s, sh = 4.6 * h.s, sw = 2.6 * h.s;\n      y -= h.bump * exp(-(dx * dx) / (w * w));\n      y -= h.lift * (exp(-((dx - sh) ** 2) / (sw * sw)) + exp(-((dx + sh) ** 2) / (sw * sw)));\n    }\n    surf[x] = y;\n  }\n}\n\nfunction palette(S) {\n  const h = (S.colour - floor(S.colour)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  // Each palette holds for 0.1 either side of 0, 1/3 and 2/3 of the knob.\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  return PAL[0].map((_, n) => [0, 1, 2].map((c) => mix(PAL[i][n][c], PAL[j][n][c], s)));\n}\n\n// Sky, stars, moon and headstone: they change only with the palette.\nfunction background(S, pal) {\n  const bg = S.bg, [top, hor, moon, limb, , , , edge] = pal;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3, f = cl(y / GY, 0, 1) ** 1.6;\n      const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n      // The halo in steps of 0.02: a smooth one costs the frame a third more\n      // bytes and looks no different on the panel.\n      const halo = round(15 * exp(-max(0, r - MR) / 7)) * 0.02;\n      const a = cl(MR - r + 0.5, 0, 1);\n      let sea = 0;\n      for (const [sx, sy, sr] of [[-8, -6, 7], [6, 4, 6], [-3, 10, 4], [9, -9, 4], [-12, 5, 3]]) sea = max(sea, cl(1 - sqrt((dx - sx) ** 2 + (dy - sy) ** 2) / sr, 0, 1));\n      const lift = cl(0.55 - (dx + dy) / (2.2 * MR), 0, 1);\n      for (let c = 0; c \u003c 3; c++) {\n        const sky = mix(top[c], hor[c], f) + halo * moon[c];\n        bg[o + c] = mix(sky, mix(moon[c], limb[c], lift) * (1 - 0.25 * sea), a);\n      }\n    }\n  // Stars, out of the moon's halo.\n  for (let n = 0; n \u003c 16; n++) {\n    const x = floor(hash(n * 3 + 1) * W), y = floor(hash(n * 3 + 2) * 40), dx = x - MX, dy = y - MY;\n    if (dx * dx + dy * dy \u003c (MR + 6) ** 2) continue;\n    const o = (y * W + x) * 3, b = 0.35 + 0.4 * hash(n * 3 + 3);\n    bg[o] = max(bg[o], b * 0.9);\n    bg[o + 1] = max(bg[o + 1], b * 0.85);\n    bg[o + 2] = max(bg[o + 2], b);\n  }\n  // The headstone: a slab with a round top, leaning a little, black against\n  // the moon with its right edge lit.\n  for (let y = 60; y \u003c GY; y++)\n    for (let x = 0; x \u003c 26; x++) {\n      const lx = x + 0.5 - 12 - (GY - y) * 0.08, ly = y + 0.5;\n      const top = 75, half = 8.5;\n      let inside = abs(lx) \u003c half && ly > top;\n      if (!inside && ly \u003c= top) inside = lx * lx + (ly - top) ** 2 \u003c half * half;\n      if (!inside) continue;\n      const o = (y * W + x) * 3, d = min(half - abs(lx), ly \u003c= top ? half - sqrt(lx * lx + (ly - top) ** 2) : 99);\n      const rim = lx > 0 && d \u003c 1.2 ? 0.55 : 0;\n      for (let c = 0; c \u003c 3; c++) bg[o + c] = 0.025 + rim * edge[c] * 0.8;\n    }\n  // RIP cut into the stone, a little lighter than the stone.\n  const RIP = [\"110 111 110\", \"101 010 101\", \"110 010 110\", \"101 010 100\", \"101 111 100\"];\n  RIP.forEach((row, j) => {\n    for (let i = 0; i \u003c row.length; i++) {\n      if (row[i] !== \"1\") continue;\n      const y = 79 + j, x = floor(6.5 + i + (GY - y) * 0.08), o = (y * W + x) * 3;\n      for (let c = 0; c \u003c 3; c++) bg[o + c] = 0.06 + 0.16 * edge[c] * 0.6 + (c === 2 ? 0.08 : 0.03);\n    }\n  });\n  // Grass along the ground line, black against the glow of the horizon.\n  for (let x = 0; x \u003c W; x++) {\n    const tall = floor(1 + 3.2 * hash(x * 7 + 5) * hash(x * 11 + 3));\n    for (let y = GY - tall; y \u003c GY; y++) for (let c = 0; c \u003c 3; c++) bg[(y * W + x) * 3 + c] = 0.02;\n  }\n  for (let y = GY; y \u003c H; y++) for (let x = 0; x \u003c W; x++) for (let c = 0; c \u003c 3; c++) bg[(y * W + x) * 3 + c] = c === 2 ? 0.035 : 0.02;\n}\n\n// The fog's two waves across the panel, as tables.\nconst SX1 = new Float32Array(W), CX1 = new Float32Array(W), SX2 = new Float32Array(W), CX2 = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++) {\n  SX1[x] = sin(x * 0.17);\n  CX1[x] = cos(x * 0.17);\n  SX2[x] = sin(x * 0.07);\n  CX2[x] = cos(x * 0.07);\n}\n\n// How bright the glow from a hand's hole is this instant: it throbs.\nconst pulse = (h) => 0.62 + 0.25 * sin(h.g * 6.3) + 0.13 * sin(h.g * 15.1 + 1);\n\n// The hand's bones for this frame, in panel coordinates. L is how high the\n// fingertips stand above the hole when the arm is straight; the arm slides\n// out of the hole along the upper arm, and bends at the elbow only once the\n// elbow is out.\nfunction bones(h) {\n  const s = h.s, hole = mound(h.x);\n  const d1x = sin(h.sway), d1y = -cos(h.sway), e = h.L - (FA + HL) * s;\n  const ex = h.x + e * d1x, ey = hole + e * d1y;\n  const a2 = h.sway + h.bend * sm(0, 5 * s, e), d2x = sin(a2), d2y = -cos(a2);\n  const wx = ex + FA * s * d2x, wy = ey + FA * s * d2y;\n  const ang = a2 + h.tilt, ux = sin(ang), uy = -cos(ang), rx = -uy, ry = ux;\n  const P = (lx, ly) => [wx + (lx * rx + ly * ux) * s, wy + (lx * ry + ly * uy) * s];\n  const caps = [];\n  caps.push([ex, ey, ex - d1x * UA * s, ey - d1y * UA * s, 4 * s, 4.6 * s]);\n  caps.push([ex, ey, wx, wy, 3.9 * s, 3.2 * s]);\n  // Palm: two fat bones side by side.\n  const p0 = P(-2.2, 1.5), p1 = P(-2.4, 7.6), p2 = P(2.2, 1.5), p3 = P(2.3, 7.2);\n  caps.push([p0[0], p0[1], p1[0], p1[1], 3 * s, 2.6 * s]);\n  caps.push([p2[0], p2[1], p3[0], p3[1], 3 * s, 2.5 * s]);\n  // Fingers splay with h.open and hook inwards as they close.\n  const close = 1 - h.open;\n  for (let f = 0; f \u003c FINGERS.length; f++) {\n    const F = FINGERS[f], lag = sin(h.g * 6.3 + 1.6 - f * 0.5) * 0.12;\n    const c = cl(close + lag, 0, 1);\n    let [x, y] = [F.bx, F.by], a = F.a * (0.55 + 0.75 * (1 - c));\n    for (let k = 0; k \u003c F.len.length; k++) {\n      a += F.hook * c * [0.35, 0.6, 0.55][k];\n      const l = F.len[k] * (1 - 0.35 * c);\n      const nx = x + sin(a) * l, ny = y + cos(a) * l;\n      const A = P(x, y), B = P(nx, ny);\n      const r0 = RAD[k] * (f === 4 ? 1.1 : 1), r1 = (k === F.len.length - 1 ? RAD[3] : RAD[k + 1]) * (f === 4 ? 1.1 : 1);\n      caps.push([A[0], A[1], B[0], B[1], r0 * s, r1 * s]);\n      x = nx;\n      y = ny;\n    }\n  }\n  return { caps, wx, wy };\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const pal = palette(S);\n  const [, , , , rimC, glowC, fogC, edgeC] = pal;\n  if (S.pal !== S.colour) {\n    background(S, pal);\n    S.pal = S.colour;\n  }\n  const { rgb, sdf, surf } = S;\n  rgb.set(S.bg);\n  surface(S, surf);\n  sdf.fill(99);\n  // The hands, as one distance field: below zero is inside.\n  for (const h of S.hands) {\n    if (!h.on || h.L \u003c= 0.2) continue;\n    const B = bones(h);\n    let bx0 = 99, bx1 = -99, by0 = 999;\n    for (const c of B.caps) {\n      bx0 = min(bx0, c[0] - c[4], c[2] - c[5]);\n      bx1 = max(bx1, c[0] + c[4], c[2] + c[5]);\n      by0 = min(by0, c[1] - c[4], c[3] - c[5]);\n    }\n    const x0 = max(0, floor(bx0 - 1)), x1 = min(W - 1, floor(bx1 + 1)), y0 = max(0, floor(by0 - 1)), y1 = min(H - 1, floor(mound(h.x) + 2));\n    // Each bone as a, b - a, 1 / |b - a|^2 and its two radii, for the\n    // distance from a pixel to the bone rounded from ra to rb.\n    const n = B.caps.length, K = new Float64Array(n * 7);\n    B.caps.forEach((c, i) => {\n      const ex = c[2] - c[0], ey = c[3] - c[1];\n      K.set([c[0], c[1], ex, ey, 1 / (ex * ex + ey * ey || 1e-9), c[4], c[5] - c[4]], i * 7);\n    });\n    for (let y = y0; y \u003c= y1; y++)\n      for (let x = x0; x \u003c= x1; x++) {\n        if (y > surf[x] + 1) continue;\n        const px = x + 0.5, py = y + 0.5;\n        let d = 99;\n        for (let i = 0; i \u003c n * 7; i += 7) {\n          const wx = px - K[i], wy = py - K[i + 1];\n          let t = (wx * K[i + 2] + wy * K[i + 3]) * K[i + 4];\n          t = t \u003c 0 ? 0 : t > 1 ? 1 : t;\n          const dx = wx - K[i + 2] * t, dy = wy - K[i + 3] * t, e = sqrt(dx * dx + dy * dy) - K[i + 5] - K[i + 6] * t;\n          if (e \u003c d) d = e;\n        }\n        const o = y * W + x;\n        if (d \u003c sdf[o]) sdf[o] = d;\n      }\n  }\n  // Hands: black, with a rim of light from the grave all round. The fingers\n  // are thin enough to be all rim.\n  for (let o = 0; o \u003c N; o++) {\n    const d = sdf[o];\n    if (d >= 0.7) continue;\n    const q = o * 3;\n    if (d >= 0) {\n      const a = 0.55 * (1 - d / 0.7);\n      for (let c = 0; c \u003c 3; c++) rgb[q + c] = mix(rgb[q + c], rimC[c], a);\n    } else {\n      const rim = cl(1 + d / 1.5, 0, 1);\n      for (let c = 0; c \u003c 3; c++) rgb[q + c] = 0.015 + rimC[c] * rim * 0.8;\n    }\n  }\n  // The heap: dark earth up to its surface, its top edge caught by the moon,\n  // cracks and the ground round each arm lit from below.\n  for (let x = 0; x \u003c W; x++) {\n    const ys = surf[x];\n    for (let y = max(0, floor(ys)); y \u003c GY + 1; y++) {\n      const o = (y * W + x) * 3, cov = cl(y + 1 - ys, 0, 1);\n      if (cov \u003c= 0) continue;\n      const depth = y + 0.5 - ys, lit = depth \u003c 1.3 ? 0.45 * (1 - depth / 1.3) : 0;\n      for (let c = 0; c \u003c 3; c++) {\n        const earth = (c === 2 ? 0.04 : c === 0 ? 0.035 : 0.022) + edgeC[c] * lit;\n        rgb[o + c] = mix(rgb[o + c], earth, cov);\n      }\n    }\n  }\n  for (const h of S.hands) {\n    if (h.glow \u003c= 0.01 && h.crack \u003c= 0.01) continue;\n    const ys = mound(h.x) - h.bump;\n    // Glow from the hole, throbbing, spilling up into the air and over the\n    // earth.\n    const R = 11 * h.s, beat = h.glow * pulse(h), gx = S.gx;\n    for (let x = 0; x \u003c W; x++) gx[x] = exp(-(((x + 0.5 - h.x) / (1.6 * R)) ** 2));\n    for (let y = max(0, floor(ys - 2.6 * R)); y \u003c min(H, ys + 2.2 * R); y++) {\n      const gy = beat * exp(-(((y + 0.5 - ys) / R) ** 2));\n      for (let x = 0; x \u003c W; x++) {\n        const g = gy * gx[x] * (y + 0.5 >= surf[x] ? 0.6 : 0.35), o = (y * W + x) * 3;\n        rgb[o] += glowC[0] * g;\n        rgb[o + 1] += glowC[1] * g;\n        rgb[o + 2] += glowC[2] * g;\n      }\n    }\n    // Cracks in the heaving earth.\n    if (h.crack > 0.01)\n      for (const pts of h.cracks)\n        for (let k = 0; k + 1 \u003c pts.length; k++)\n          for (let n = 0; n \u003c= 4; n++) {\n            const x = floor(h.x + mix(pts[k][0], pts[k + 1][0], n / 4) * h.s), y = floor(ys + 1 + mix(pts[k][1], pts[k + 1][1], n / 4) * h.s);\n            if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || y \u003c surf[x] + 0.5) continue;\n            const o = (y * W + x) * 3, a = h.crack * (1 - 0.25 * k);\n            for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(rgb[o + c], glowC[c], a * 0.85);\n          }\n  }\n  // Clods: black against the moon, dim earth against the night, and green\n  // while they are fresh from the hole.\n  for (const c of S.clods) {\n    const fade = cl(c.life / 1.2, 0, 1);\n    for (let y = floor(c.y - c.r); y \u003c= floor(c.y + c.r); y++)\n      for (let x = floor(c.x - c.r); x \u003c= floor(c.x + c.r); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const dx = x + 0.5 - c.x, dy = y + 0.5 - c.y;\n        if (dx * dx + dy * dy > (c.r + 0.35) ** 2) continue;\n        const o = (y * W + x) * 3, lum = max(rgb[o], rgb[o + 1], rgb[o + 2]);\n        for (let ch = 0; ch \u003c 3; ch++) {\n          const col = lum > 0.3 ? 0.02 : edgeC[ch] * 0.3;\n          rgb[o + ch] = mix(rgb[o + ch], mix(col, glowC[ch] * 0.8, c.hot * 0.6), fade);\n        }\n      }\n  }\n  // Ground fog rolling in front of everything, lit green where the grave\n  // glows under it.\n  const fog = S.fog, top = GY - 6 - 44 * fog, dens = 0.22 + 0.5 * fog, t = S.t;\n  // Each lamp's light falls off as a Gaussian, so it splits into a factor per\n  // column, kept here, and one per row.\n  const lamps = S.hands.filter((h) => h.glow > 0.01).map((h) => {\n    const r2 = (16 * h.s) ** 2, gx = new Float32Array(W);\n    for (let x = 0; x \u003c W; x++) gx[x] = exp(-((x + 0.5 - h.x) ** 2) / r2);\n    return { y: mound(h.x), g: h.glow * pulse(h), r2, gx };\n  });\n  for (let y = max(0, floor(top)); y \u003c H; y++) {\n    const rise = sm(top, top + 12 + 10 * fog, y), p1 = y * 0.09 - t * 0.9, p2 = -y * 0.21 + t * 0.55 + 1.3;\n    const s1 = sin(p1), c1 = cos(p1), s2 = sin(p2), c2 = cos(p2);\n    for (const L of lamps) L.row = L.g * exp(-((y + 0.5 - L.y) ** 2) / L.r2);\n    for (let x = 0; x \u003c W; x++) {\n      // sin(x k + p) as sin(x k) cos p + cos(x k) sin p, from tables.\n      const n = 0.5 + 0.28 * (SX1[x] * c1 + CX1[x] * s1) + 0.22 * (SX2[x] * c2 + CX2[x] * s2);\n      const a = round(16 * cl(dens * rise * n, 0, 0.85)) / 16, o = (y * W + x) * 3;\n      let lit = 0;\n      for (const L of lamps) lit += L.row * L.gx[x];\n      lit = round(12 * min(1, lit)) / 12;\n      for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(rgb[o + c], mix(fogC[c] * 0.6, glowC[c] * 0.9, lit), a);\n    }\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * cl(rgb[o * 3], 0, 1)), round(255 * cl(rgb[o * 3 + 1], 0, 1)), round(255 * cl(rgb[o * 3 + 2], 0, 1)));\n}\n","hitomezashi":"// ===== Patternflow pattern =====\n// Title:   Hitomezashi\n// Family:  line\n// Idea:    Rows and columns of running stitches, each line's dashes set one step on or off by a bit, split a woven cloth into regions of two colours, and as the bits flip one at a time a whole line of dashes jumps over by one and a wave recolours everything on one side of it, while a light runs round the newest closed loop of thread.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: hitomezashi sashiko, with the loop theorem of Colin Defant and Noah Kravitz (2022), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Cell=6..10, Loops=0..1\n//\n// Knob 1: Hue. Turns the light cloth round the colour wheel: aqua at 0, blue at 0.2, violet at 0.3, pink at 0.45, orange at 0.6, yellow at 0.7 and green at 0.85; the dark cloth stays indigo to violet and the thread stays cream.\n// Knob 2: Speed. How often a bit flips and how fast the light runs: at 2 about 2.7 flips a second and 24 stitches a second round the loop; at 0.2 one flip every 3.7 seconds, at 3 four flips a second.\n// Knob 3: Cell. The stitch length in LEDs, 6 to 10: at 6 the panel holds 11 by 22 crossings of the thread lines, at 10 it holds 7 by 13.\n// Knob 4: Loops. Picks the closed loops out of the open threads: the loops are lit gold, biggest first, and the threads that run off the panel dim. At 0 only the loop with the running light is gold; at 0.06 the biggest 6% of the others are too; at 1 every closed loop on the panel is gold, each 4, 12, 20, 28 or more stitches long and always 4 more than a multiple of 8, and the open threads are down to a third.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, log, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The thread, the gold of a lit loop, and the head of the running light.\nconst THREAD = [1, 0.94, 0.84], GOLD = [1, 0.62, 0.1], HEAD = [1, 1, 0.85];\n// The cloth is a plain weave: an LED with x + y even is a thread lying on\n// top and catches more light. Brightness of the two kinds in each fill.\nconst WEAVE = { lightHi: 1, lightLo: 0.6, darkHi: 0.2, darkLo: 0 };\n// The recolouring runs out from a flipped line at this many LEDs a second.\nconst WAVE = 150;\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, pitch: 0, loopsK: 0.06,\n    // Row line bits a[j] and column line bits b[i], enough for any pitch.\n    a: new Uint8Array(32), b: new Uint8Array(16),\n    nextFlip: 0.4, swap: 0, recent: [],\n    // Cells: colour (0 dark, 1 light), the colour shown, and when it turned.\n    col: new Uint8Array(0), show: new Uint8Array(0), when: new Float32Array(0),\n    // Lines that just flipped glow for a moment: [row?, index, glow].\n    flash: [],\n    loops: [], cur: null, head: 0, laps: 0,\n    loopOf: new Int16Array(N), posOf: new Float32Array(N),\n    geo: null, pal: null, palHue: NaN,\n  };\n  const S = params.s;\n  for (let j = 0; j \u003c S.a.length; j++) S.a[j] = Math.random() \u003c 0.5 ? 1 : 0;\n  for (let i = 0; i \u003c S.b.length; i++) S.b[i] = Math.random() \u003c 0.5 ? 1 : 0;\n}\n\n// The lattice for a pitch P: node columns i = 0..NI-1 at x = OX + P i and\n// node rows j = 0..NJ-1 at y = OY + P j. Cells run one past the nodes on\n// every side (cell i lies between node columns i and i+1) and are stored\n// at i + 1.\nfunction geometry(P) {\n  const NI = floor(63 / P) + 1, NJ = floor(127 / P) + 1;\n  const OX = floor((63 - P * (NI - 1)) / 2), OY = floor((127 - P * (NJ - 1)) / 2);\n  return { P, NI, NJ, OX, OY, CW: NI + 1, CH: NJ + 1 };\n}\n\n// The stitch rule. On row line j the segment from node i to i+1 is a stitch\n// when i + a[j] is even; on column line i the segment from node j to j+1 is\n// a stitch when j + b[i] is even. So every node has exactly one horizontal\n// and one vertical stitch, and the thread turns at every node.\nconst hs = (S, i, j) => ((i + S.a[j]) & 1) === 0;\nconst vs = (S, i, j) => ((j + S.b[i]) & 1) === 0;\n\n// Two-colour the cells: crossing a stitch changes colour, crossing a gap\n// does not. It is consistent because two stitches meet at every node.\n// Starts from the top-left cell, coloured S.swap.\nfunction colour(S, out) {\n  const { NI, NJ, CW } = S.geo;\n  let c = S.swap;\n  for (let j = -1; j \u003c NJ; j++) {\n    if (j >= 0) c ^= hs(S, -1, j) ? 1 : 0;\n    let r = c;\n    out[(j + 1) * CW] = r;\n    for (let i = 0; i \u003c NI; i++) {\n      r ^= vs(S, i, j) ? 1 : 0;\n      out[(j + 1) * CW + i + 1] = r;\n    }\n  }\n}\n\n// Follow the thread from node (i0, j0): its nodes in order if it closes into\n// a loop on the panel's lattice, or null if it runs off the edge.\nfunction trace(S, i0, j0) {\n  const { NI, NJ } = S.geo;\n  const path = [];\n  let i = i0, j = j0, pi = -9, pj = -9;\n  for (let n = 0; n \u003c= NI * NJ; n++) {\n    path.push(j * NI + i);\n    const hx = hs(S, i, j) ? i + 1 : i - 1, vy = vs(S, i, j) ? j + 1 : j - 1;\n    if (hx \u003c 0 || hx >= NI || vy \u003c 0 || vy >= NJ) return null;\n    // The thread alternates: after a horizontal stitch comes a vertical one.\n    if (hx === pi && j === pj) (pi = i), (pj = j), (j = vy);\n    else (pi = i), (pj = j), (i = hx);\n    if (i === i0 && j === j0) return path;\n  }\n  return null;\n}\n\n// Every closed loop on the lattice, biggest first, and which LED lies on\n// which loop and how far round it, in stitches.\nfunction findLoops(S) {\n  const { NI, NJ, P, OX, OY } = S.geo;\n  const seen = new Uint8Array(NI * NJ), loops = [];\n  for (let n = 0; n \u003c NI * NJ; n++) {\n    if (seen[n]) continue;\n    const path = trace(S, n % NI, floor(n / NI));\n    if (!path) continue;\n    for (const u of path) seen[u] = 1;\n    loops.push(path);\n  }\n  loops.sort((p, q) => q.length - p.length);\n  S.loops = loops;\n  S.loopOf.fill(-1);\n  loops.forEach((path, n) => {\n    const L = path.length;\n    for (let k = 0; k \u003c L; k++) {\n      const u = path[k], v = path[(k + 1) % L];\n      const x0 = OX + P * (u % NI), y0 = OY + P * floor(u / NI), x1 = OX + P * (v % NI), y1 = OY + P * floor(v / NI);\n      for (let s = 0; s \u003c P; s++) {\n        const x = x0 + ((x1 - x0) / P) * s, y = y0 + ((y1 - y0) / P) * s;\n        S.loopOf[y * W + x] = n;\n        S.posOf[y * W + x] = k + s / P;\n      }\n    }\n  });\n}\n\n// The longest loop through line k (a row line or a column line), which is\n// the longest loop a flip of that line's bit makes or keeps whole: a loop\n// that does not touch the line is left as it was.\nfunction longestThrough(S, row, k) {\n  const { NI, NJ } = S.geo;\n  let best = 0;\n  for (let n = 0; n \u003c (row ? NI : NJ); n++) {\n    const path = row ? trace(S, n, k) : trace(S, k, n);\n    if (path) best = max(best, path.length);\n  }\n  return best;\n}\n\n// Put the running light on a loop: the given one, or a loop drawn at random\n// weighted by length cubed, so the long winding loops come round far more\n// often than the squares of 4 stitches.\nfunction setLoop(S, path) {\n  if (!path) {\n    let total = 0;\n    for (const p of S.loops) total += p.length ** 3;\n    let r = Math.random() * total;\n    for (const p of S.loops) if ((r -= p.length ** 3) \u003c= 0) {\n      path = p;\n      break;\n    }\n  }\n  S.cur = path || null;\n  S.head = 0;\n  S.laps = 0;\n}\n\nfunction rebuild(S, P) {\n  S.pitch = P;\n  S.geo = geometry(P);\n  const n = S.geo.CW * S.geo.CH;\n  S.col = new Uint8Array(n);\n  S.when = new Float32Array(n).fill(-9);\n  colour(S, S.col);\n  S.show = S.col.slice();\n  S.flash = [];\n  S.recent = [];\n  findLoops(S);\n  setLoop(S, null);\n}\n\n// Flip one bit: every stitch on that line moves over by one, and every cell\n// on one side of the line changes colour. The line is drawn at random,\n// weighted towards lines whose flip closes a long loop. Which side changes\n// colour is a choice (the other is the same picture with the colours\n// swapped): take the bigger side, and let the change run out from the line.\nfunction flip(S) {\n  const { NI, NJ, CW, CH, P, OX, OY } = S.geo;\n  const cand = [];\n  let total = 0;\n  for (let row = 0; row \u003c 2; row++)\n    for (let k = 0; k \u003c (row ? NJ : NI); k++) {\n      if (S.recent.some((r) => r[0] === row && r[1] === k)) continue;\n      const bits = row ? S.a : S.b;\n      bits[k] ^= 1;\n      const L = longestThrough(S, row, k);\n      bits[k] ^= 1;\n      const w = L >= 12 ? (L / 4) ** 2 : 1;\n      cand.push([row, k, w]);\n      total += w;\n    }\n  let r = Math.random() * total, pick = cand[cand.length - 1];\n  for (const c of cand) if ((r -= c[2]) \u003c= 0) {\n    pick = c;\n    break;\n  }\n  const [row, k] = pick;\n  (row ? S.a : S.b)[k] ^= 1;\n  S.recent.push([row, k]);\n  if (S.recent.length > 3) S.recent.shift();\n  const old = S.col.slice();\n  colour(S, S.col);\n  let changed = 0;\n  for (let c = 0; c \u003c old.length; c++) changed += old[c] !== S.col[c] ? 1 : 0;\n  if (changed * 2 \u003c old.length) {\n    S.swap ^= 1;\n    colour(S, S.col);\n  }\n  const at = row ? OY + P * k : OX + P * k;\n  for (let cj = 0; cj \u003c CH; cj++)\n    for (let ci = 0; ci \u003c CW; ci++) {\n      const c = cj * CW + ci;\n      if (old[c] === S.col[c]) continue;\n      const centre = row ? OY + P * (cj - 1) + P / 2 : OX + P * (ci - 1) + P / 2;\n      S.when[c] = max(S.when[c], S.t + abs(centre - at) / WAVE);\n    }\n  S.flash.push([row, k, 1]);\n  // The light stays on its loop if the flip left it whole; it moves to the\n  // longest loop the flip closed if that one is longer.\n  const kept = S.cur && !S.cur.some((u) => (row ? floor(u / NI) : u % NI) === k);\n  findLoops(S);\n  if (kept) {\n    const u = S.cur[0];\n    S.cur = S.loops[S.loopOf[(OY + P * floor(u / NI)) * W + OX + P * (u % NI)]];\n  }\n  let fresh = null;\n  for (const p of S.loops) if (p.some((u) => (row ? floor(u / NI) : u % NI) === k)) {\n    fresh = p;\n    break;\n  }\n  if (fresh && fresh.length >= 12 && (!kept || fresh.length >= S.cur.length)) setLoop(S, fresh);\n  else if (!kept) setLoop(S, null);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.loopsK = cl(k[3], 0, 1);\n  const P = cl(round(k[2]), 6, 10);\n  if (P !== S.pitch) rebuild(S, P);\n  S.t += d;\n  // Flips come at random, 1.34 a second per unit of Speed on average, never\n  // closer than 0.28 seconds at Speed 1.\n  S.nextFlip -= d * S.speed * 1.2;\n  if (S.nextFlip \u003c= 0) {\n    flip(S);\n    S.nextFlip = 0.33 - 0.67 * log(1 - Math.random() * 0.95);\n  }\n  for (let c = 0; c \u003c S.show.length; c++) if (S.t >= S.when[c]) S.show[c] = S.col[c];\n  for (const f of S.flash) f[2] -= d * 2.5;\n  S.flash = S.flash.filter((f) => f[2] > 0);\n  // The running light: 12 stitches a second per unit of Speed, two laps\n  // round a short loop and one round a long one before it moves on.\n  if (S.cur) {\n    const L = S.cur.length;\n    S.head += d * S.speed * 12;\n    if (S.head >= L) {\n      S.head -= L;\n      if (++S.laps >= (L \u003c 40 ? 2 : 1)) {\n        const was = S.cur;\n        setLoop(S, null);\n        if (S.cur === was && S.loops.length > 1) setLoop(S, S.loops.find((p) => p !== was));\n      }\n    }\n  }\n}\n\nfunction palette(S) {\n  const hB = 0.47 + S.hue;\n  const band = max(0, 1 - abs(hB - floor(hB) - 0.1) / 0.12);\n  const hD = 0.66 + 0.06 * sin(TAU * S.hue);\n  S.pal = {\n    // The light cloth takes any hue; near orange its low threads are lifted\n    // so they do not read brown.\n    lightHi: hsv(hB, 0.45, WEAVE.lightHi),\n    lightLo: hsv(hB, 0.85, WEAVE.lightLo + 0.2 * band),\n    // The dark cloth keeps to indigo and violet: a dark warm cloth reads brown.\n    darkHi: hsv(hD, 0.8, WEAVE.darkHi),\n    darkLo: hsv(hD, 0.9, WEAVE.darkLo),\n  };\n  S.palHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.geo) return;\n  if (S.palHue !== S.hue) palette(S);\n  const { P, NI, NJ, OX, OY, CW } = S.geo;\n  const pal = S.pal;\n  // K4 lights the closed loops gold, the biggest first. It also dims the\n  // threads that run off the panel, down to a third at 1.\n  const lit = round(S.loopsK * S.loops.length), open = 1 - 0.67 * S.loopsK;\n  const cur = S.cur ? S.loops.indexOf(S.cur) : -1, Lc = S.cur ? S.cur.length : 1;\n  const rowGlow = new Float32Array(NJ), colGlow = new Float32Array(NI);\n  for (const [row, k, g] of S.flash) {\n    if (row) rowGlow[k] = max(rowGlow[k], g);\n    else colGlow[k] = max(colGlow[k], g);\n  }\n  for (let y = 0; y \u003c H; y++) {\n    const v = y - OY, j = floor(v / P), fy = v - j * P;\n    for (let x = 0; x \u003c W; x++) {\n      const u = x - OX, i = floor(u / P), fx = u - i * P;\n      const cell = (min(max(j, -1), NJ - 1) + 1) * CW + min(max(i, -1), NI - 1) + 1;\n      // The cloth under this LED: the cell's colour in the weave.\n      const up = ((x + y) & 1) === 0, m = S.show[cell];\n      const c = m ? (up ? pal.lightHi : pal.lightLo) : up ? pal.darkHi : pal.darkLo;\n      let r = c[0], g = c[1], b = c[2];\n      let stitch = false, glow = 0, onLine = true;\n      if (fx === 0 && fy === 0 && i >= 0 && i \u003c NI && j >= 0 && j \u003c NJ) stitch = true;\n      else if (fy === 0 && j >= 0 && j \u003c NJ) (stitch = hs(S, i, j)), (glow = rowGlow[j]);\n      else if (fx === 0 && i >= 0 && i \u003c NI) (stitch = vs(S, i, j)), (glow = colGlow[i]);\n      else onLine = false;\n      if (onLine) {\n        if (stitch) {\n          const n = S.loopOf[y * W + x];\n          if (n >= 0 && n === cur) {\n            // The running light: a head and a fading tail a third of the loop long.\n            let dd = S.head - S.posOf[y * W + x];\n            if (dd \u003c 0) dd += Lc;\n            const tail = max(0, 1 - dd / max(4, Lc / 3));\n            r = GOLD[0] + (HEAD[0] - GOLD[0]) * tail;\n            g = GOLD[1] + (HEAD[1] - GOLD[1]) * tail;\n            b = GOLD[2] + (HEAD[2] - GOLD[2]) * tail;\n          } else if (n >= 0 && n \u003c lit) [r, g, b] = GOLD;\n          else if (n >= 0) [r, g, b] = THREAD;\n          else (r = THREAD[0] * open), (g = THREAD[1] * open), (b = THREAD[2] * open);\n        } else if (glow > 0) {\n          // A line that just flipped: its gaps flash with thread for a moment.\n          r += (THREAD[0] - r) * glow * 0.8;\n          g += (THREAD[1] - g) * glow * 0.8;\n          b += (THREAD[2] - b) * glow * 0.8;\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n  }\n}\n","kaleidocycle":"// ===== Patternflow pattern =====\n// Title:   Kaleidocycle\n// Family:  space\n// Idea:    A closed ring of six tetrahedra joined edge to edge by hinges turns through itself without end, seen from the front in the top half of the panel and from behind in the bottom half, every piece tumbling over in its place so the hexagon of faces on each side changes colour through four face sets.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: kaleidocycles (Wallace Walker, 1958), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Tetrahedra=6..12, Tilt=0..1\n//\n// Knob 1: Hue. Turns the four face sets' colours round the wheel together. At 0 they are gold, green, azure and magenta; a set that comes round to orange or yellow is paled and lit higher, so it never reads brown.\n// Knob 2: Speed. At 2 the ring turns a quarter in 2.6 seconds, every piece rolls a quarter over and the next face set comes to the front; after 10.5 seconds all four sets have had their turn and it is back where it started. At 0.2 a quarter takes 26 seconds, at 3 it takes 1.7.\n// Knob 3: Tetrahedra, 6 to 12 in steps of 2. 6 is the hexagonal ring of the paper models, here six isosceles tetrahedra whose faces are as tall as their hinge edge is long, the fattest six that still turn all the way: neighbours close face to face at the end of each swing. Six regular tetrahedra would run into each other; 8, 10 and 12 are rings of regular ones, each a wider hoop with a bigger hole.\n// Knob 4: Tilt. How far both views look off the ring's axis, 10 degrees at 0 and 70 at 1. At 0 each view is a hexagon of six faces round a hole that opens into a three-pointed star; at 1 both look at the ring from 20 degrees off its side, where the pieces tumble as wedges and the face set on the outer wall comes into view.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, acos, atan2, round, pow, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The light, a unit vector toward it: from the upper left, in front.\nconst LX = -0.48, LY = -0.62, LZ = -0.62;\n// The camera sits this many ring radii in front of the ring's centre.\nconst CAM = 4.2;\n// The two views: centre row on the panel, and which side of the ring.\nconst VIEWS = [[32, 1], [96, -1]];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, n: 6, tilt: 0.06, phase: 0,\n    // Hinge midpoints p_i and hinge directions z_i, i = 0..N, as the chain\n    // builds them; the tetrahedra's corners about the ring's centre, axis\n    // first; and the same corners on the panel for one view.\n    p: new Float64Array(13 * 3), z: new Float64Array(13 * 3),\n    v: new Float64Array(12 * 4 * 3), sv: new Float64Array(12 * 4 * 3), P: new Float64Array(12 * 4 * 3),\n    fitKey: \"\", scale: 1, radius: 1, gap: 0,\n    id: new Int16Array(W * H), cs: new Uint8Array(W * H), zb: new Float32Array(W * H), sh: new Float32Array(W * H),\n    col: new Float32Array(12), colHue: NaN, warm: new Float32Array(4),\n  };\n}\n\n// The joint angles of the turning ring. Hinge i is where tetrahedra i - 1\n// and i meet, and going from one tetrahedron's common perpendicular to the\n// next one's turns theta_i about it. Every tetrahedron holds its two hinges\n// at right angles, 1 apart, each crossed at its middle by the perpendicular\n// between them. The ring turns with theta = A, B, -A, -B, A, B, ... and is\n// closed exactly when cos(A/2) cos(B/2) = cos(2 pi / N); phi walks once\n// round that loop, and a quarter of it hands each tetrahedron's place and\n// pose to its neighbour.\nfunction angles(n, phi) {\n  const c = cos(TAU / n), s = sin(phi) ** 2;\n  const u = acos(pow(c, s)) * (sin(phi) \u003c 0 ? -1 : 1), w = acos(pow(c, 1 - s)) * (cos(phi) \u003c 0 ? -1 : 1);\n  return [2 * u, 2 * w];\n}\n\n// Build the chain from hinge 0 with Denavit-Hartenberg steps: 1 along the\n// common perpendicular x, a quarter turn about it, then theta about the new\n// hinge. The frame (x, y, z) at hinge i + 1 is c x + s z, -s x + c z, -y.\nfunction chain(S, n, phi) {\n  const [A, B] = angles(n, phi), th = [A, B, -A, -B];\n  const { p, z } = S;\n  let x0 = 1, x1 = 0, x2 = 0, y0 = 0, y1 = 1, y2 = 0, z0 = 0, z1 = 0, z2 = 1, q0 = 0, q1 = 0, q2 = 0;\n  for (let i = 0; i \u003c= n; i++) {\n    (p[3 * i] = q0), (p[3 * i + 1] = q1), (p[3 * i + 2] = q2);\n    (z[3 * i] = z0), (z[3 * i + 1] = z1), (z[3 * i + 2] = z2);\n    const t = th[(i + 1) % 4], c = cos(t), s = sin(t);\n    (q0 += x0), (q1 += x1), (q2 += x2);\n    const a0 = c * x0 + s * z0, a1 = c * x1 + s * z1, a2 = c * x2 + s * z2;\n    const b0 = -s * x0 + c * z0, b1 = -s * x1 + c * z1, b2 = -s * x2 + c * z2;\n    (z0 = -y0), (z1 = -y1), (z2 = -y2);\n    (x0 = a0), (x1 = a1), (x2 = a2);\n    (y0 = b0), (y1 = b1), (y2 = b2);\n  }\n  // How far the chain misses its own start: hinge N must lie on hinge 0,\n  // pointing the other way when N is 2 more than a multiple of 4.\n  const sg = n % 4 === 2 ? -1 : 1;\n  S.gap = max(\n    sqrt((p[3 * n] - p[0]) ** 2 + (p[3 * n + 1] - p[1]) ** 2 + (p[3 * n + 2] - p[2]) ** 2),\n    sqrt((z[3 * n] - sg * z[0]) ** 2 + (z[3 * n + 1] - sg * z[1]) ** 2 + (z[3 * n + 2] - sg * z[2]) ** 2),\n  );\n}\n\n// Half the hinge edge for N tetrahedra. Neighbours sharing hinge i stay\n// apart while 180 - |theta_i| >= 2 atan(a), and |theta| reaches 720 / N\n// degrees, so six tetrahedra can be at most tan 30 degrees; from eight on\n// they are regular, 1 / sqrt 2.\nconst halfHinge = (n) => (n === 6 ? 1 / sqrt(3) : 1 / sqrt(2));\n\n// The ring about its centre: the hinge midpoints' mean, the axis along their\n// polygon's vector area, turned about the axis so the tetrahedra keep their\n// places on average. Each corner is written as (along the axis, and two\n// across it).\nfunction place(S, n, phi, out) {\n  chain(S, n, phi);\n  const { p, z } = S, a = halfHinge(n);\n  let c0 = 0, c1 = 0, c2 = 0;\n  for (let i = 0; i \u003c n; i++) (c0 += p[3 * i]), (c1 += p[3 * i + 1]), (c2 += p[3 * i + 2]);\n  (c0 /= n), (c1 /= n), (c2 /= n);\n  let e0 = 0, e1 = 0, e2 = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const r0 = p[3 * i] - c0, r1 = p[3 * i + 1] - c1, r2 = p[3 * i + 2] - c2;\n    const s0 = p[3 * i + 3] - c0, s1 = p[3 * i + 4] - c1, s2 = p[3 * i + 5] - c2;\n    (e0 += r1 * s2 - r2 * s1), (e1 += r2 * s0 - r0 * s2), (e2 += r0 * s1 - r1 * s0);\n  }\n  let l = sqrt(e0 * e0 + e1 * e1 + e2 * e2);\n  (e0 /= l), (e1 /= l), (e2 /= l);\n  // A first direction across the axis from hinge 0, then the mean turn that\n  // puts tetrahedron i at angle 2 pi i / N.\n  let u0 = p[0] - c0, u1 = p[1] - c1, u2 = p[2] - c2;\n  const d = u0 * e0 + u1 * e1 + u2 * e2;\n  (u0 -= d * e0), (u1 -= d * e1), (u2 -= d * e2);\n  l = sqrt(u0 * u0 + u1 * u1 + u2 * u2);\n  (u0 /= l), (u1 /= l), (u2 /= l);\n  const w0 = e1 * u2 - e2 * u1, w1 = e2 * u0 - e0 * u2, w2 = e0 * u1 - e1 * u0;\n  let sx = 0, sy = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const g0 = (p[3 * i] + p[3 * i + 3]) / 2 - c0, g1 = (p[3 * i + 1] + p[3 * i + 4]) / 2 - c1, g2 = (p[3 * i + 2] + p[3 * i + 5]) / 2 - c2;\n    const az = atan2(g0 * w0 + g1 * w1 + g2 * w2, g0 * u0 + g1 * u1 + g2 * u2) - (TAU * i) / n;\n    (sx += cos(az)), (sy += sin(az));\n  }\n  const rho = atan2(sy, sx) + PI / 2, cr = cos(rho), sr = sin(rho);\n  const f0 = cr * u0 + sr * w0, f1 = cr * u1 + sr * w1, f2 = cr * u2 + sr * w2;\n  const h0 = -sr * u0 + cr * w0, h1 = -sr * u1 + cr * w1, h2 = -sr * u2 + cr * w2;\n  let k = 0;\n  for (let i = 0; i \u003c n; i++)\n    for (let j = 0; j \u003c 4; j++, k += 3) {\n      const m = j \u003c 2 ? i : i + 1, sg = j & 1 ? -a : a;\n      const q0 = p[3 * m] + sg * z[3 * m] - c0, q1 = p[3 * m + 1] + sg * z[3 * m + 1] - c1, q2 = p[3 * m + 2] + sg * z[3 * m + 2] - c2;\n      out[k] = q0 * e0 + q1 * e1 + q2 * e2;\n      out[k + 1] = q0 * f0 + q1 * f1 + q2 * f2;\n      out[k + 2] = q0 * h0 + q1 * h1 + q2 * h2;\n    }\n}\n\n// One view: side 1 looks at the ring from the end its axis points to, side\n// -1 from the other end, both tipped off the axis by `off` about the\n// panel's vertical. Writes screen x, y about the view's centre and depth.\nfunction view(v, nv, side, off, out) {\n  const co = cos(off), so = sin(off);\n  for (let k = 0; k \u003c nv; k++) {\n    const X = v[3 * k], Y = v[3 * k + 1], Z = v[3 * k + 2];\n    const x = side * Z, dz = -side * X;\n    out[3 * k] = x * co - dz * so;\n    out[3 * k + 1] = Y;\n    out[3 * k + 2] = x * so + dz * co;\n  }\n}\n\nconst offAxis = (tilt) => ((10 + 60 * tilt) * PI) / 180;\n\n// The scale that keeps the whole turn inside each half of the panel, from\n// 48 poses round the loop, seen through the camera from both sides.\nfunction fit(S) {\n  const key = S.n + \":\" + S.tilt.toFixed(3);\n  if (key === S.fitKey) return;\n  const v = S.v, sv = S.sv, nv = S.n * 4, off = offAxis(S.tilt);\n  let R = 0, mx = 0, my = 0;\n  for (let q = 0; q \u003c 48; q++) {\n    place(S, S.n, (q / 48) * TAU, v);\n    for (let k = 0; k \u003c nv; k++) R = max(R, sqrt(v[3 * k] ** 2 + v[3 * k + 1] ** 2 + v[3 * k + 2] ** 2));\n  }\n  for (let q = 0; q \u003c 48; q++) {\n    place(S, S.n, (q / 48) * TAU, v);\n    for (const [, side] of VIEWS) {\n      view(v, nv, side, off, sv);\n      for (let k = 0; k \u003c nv; k++) {\n        const pf = (CAM * R) / (CAM * R + sv[3 * k + 2]);\n        mx = max(mx, abs(sv[3 * k] * pf));\n        my = max(my, abs(sv[3 * k + 1] * pf));\n      }\n    }\n  }\n  S.radius = R;\n  S.scale = min((W / 2 - 1) / mx, (H / 4 - 1) / my);\n  S.fitKey = key;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 6, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.n = cl(2 * round(cl(k[2], 6, 12) / 2), 6, 12);\n  S.tilt = cl(k[3], 0, 1);\n  S.phase += d * S.speed * 0.3;\n  fit(S);\n}\n\nfunction palette(S) {\n  const col = S.col;\n  for (let c = 0; c \u003c 4; c++) {\n    const h = S.hue + 0.12 + 0.25 * c, hh = h - floor(h);\n    // Orange and yellow go brown in shade: paler, and lit higher.\n    S.warm[c] = cl(1.6 - abs(hh - 0.11) / 0.08, 0, 1);\n    hsv(h, 0.8 - 0.25 * S.warm[c], 1, col, 3 * c);\n  }\n  S.colHue = S.hue;\n}\n\n// Corners of face f of a tetrahedron, 0 and 1 the ends of its first hinge,\n// 2 and 3 of its second, and the corner left out: two faces hold each hinge.\nconst FACES = [[0, 1, 2, 3], [0, 1, 3, 2], [2, 3, 0, 1], [2, 3, 1, 0]];\n// The face sets. Along the ring the pieces come in fours: every second one\n// is turned end for end and every odd one turned over, so the faces of a\n// set are the ones that face the same way at the same time, front, back,\n// inside or outside. Numbered in the order they come round to the front.\nconst CLASS = [[1, 3, 2, 0], [0, 2, 1, 3], [3, 1, 0, 2], [2, 0, 3, 1]];\n\n// Rasterise one view into rows y0..y1 of the panel: back faces culled, the\n// nearest face kept at each LED, lit flat.\nfunction render(S, n, cy, y0, y1) {\n  const v = S.sv, P = S.P, { id, cs, zb, sh, warm } = S, cam = CAM * S.radius, k = S.scale;\n  for (let q = 0; q \u003c n * 4; q++) {\n    const pf = cam / (cam + v[3 * q + 2]);\n    P[3 * q] = W / 2 + v[3 * q] * pf * k;\n    P[3 * q + 1] = cy + v[3 * q + 1] * pf * k;\n    P[3 * q + 2] = v[3 * q + 2];\n  }\n  for (let t = 0; t \u003c n; t++)\n    for (let f = 0; f \u003c 4; f++) {\n      const F = FACES[f], o = t * 4;\n      let ia = o + F[0], ib = o + F[1];\n      const ic = o + F[2], other = o + F[3];\n      // Outward normal; a face turned away from the camera is skipped.\n      const ax = v[3 * ia], ay = v[3 * ia + 1], az = v[3 * ia + 2];\n      let n0 = (v[3 * ib + 1] - ay) * (v[3 * ic + 2] - az) - (v[3 * ib + 2] - az) * (v[3 * ic + 1] - ay);\n      let n1 = (v[3 * ib + 2] - az) * (v[3 * ic] - ax) - (v[3 * ib] - ax) * (v[3 * ic + 2] - az);\n      let n2 = (v[3 * ib] - ax) * (v[3 * ic + 1] - ay) - (v[3 * ib + 1] - ay) * (v[3 * ic] - ax);\n      if (n0 * (v[3 * other] - ax) + n1 * (v[3 * other + 1] - ay) + n2 * (v[3 * other + 2] - az) > 0) (n0 = -n0), (n1 = -n1), (n2 = -n2), ([ia, ib] = [ib, ia]);\n      if (n0 * ax + n1 * ay + n2 * (az + cam) >= 0) continue;\n      const nl = sqrt(n0 * n0 + n1 * n1 + n2 * n2), cls = CLASS[t & 3][f];\n      const lit0 = 0.26 + 0.74 * max(0, (n0 * LX + n1 * LY + n2 * LZ) / nl);\n      const lit = lit0 + (1 - lit0) * 0.6 * warm[cls];\n      const x0 = P[3 * ia], yy0 = P[3 * ia + 1], x1 = P[3 * ib], yy1 = P[3 * ib + 1], x2 = P[3 * ic], yy2 = P[3 * ic + 1];\n      const area = (x1 - x0) * (yy2 - yy0) - (yy1 - yy0) * (x2 - x0);\n      if (abs(area) \u003c 1e-9) continue;\n      const za = P[3 * ia + 2], zbb = P[3 * ib + 2], zc = P[3 * ic + 2];\n      const xa = max(0, floor(min(x0, x1, x2))), xb = min(W - 1, floor(max(x0, x1, x2)));\n      const ya = max(y0, floor(min(yy0, yy1, yy2))), yb = min(y1, floor(max(yy0, yy1, yy2)));\n      const tag = 1 + t * 4 + f;\n      for (let y = ya; y \u003c= yb; y++) {\n        const Y = y + 0.5;\n        for (let x = xa; x \u003c= xb; x++) {\n          const X = x + 0.5;\n          const w0 = ((x1 - X) * (yy2 - Y) - (yy1 - Y) * (x2 - X)) / area;\n          const w1 = ((x2 - X) * (yy0 - Y) - (yy2 - Y) * (x0 - X)) / area;\n          const w2 = 1 - w0 - w1;\n          if (w0 \u003c -1e-6 || w1 \u003c -1e-6 || w2 \u003c -1e-6) continue;\n          const zz = w0 * za + w1 * zbb + w2 * zc, q = y * W + x;\n          if (zz \u003c zb[q]) (zb[q] = zz), (id[q] = tag), (cs[q] = cls), (sh[q] = lit);\n        }\n      }\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  const n = S.n, col = S.col, { id, cs, zb, sh } = S;\n  place(S, n, S.phase, S.v);\n  id.fill(0);\n  zb.fill(1e9);\n  for (const [cy, side] of VIEWS) {\n    view(S.v, n * 4, side, offAxis(S.tilt), S.sv);\n    render(S, n, cy, cy - 32, cy + 31);\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) {\n      const g = id[o];\n      if (!g) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      // A one-LED dark seam where two faces meet, on the far one's side.\n      let edge = false;\n      for (const q of [x > 0 ? o - 1 : -1, x \u003c W - 1 ? o + 1 : -1, y > 0 ? o - W : -1, y \u003c H - 1 ? o + W : -1]) {\n        if (q \u003c 0 || id[q] === 0 || id[q] === g) continue;\n        if (zb[q] \u003c zb[o] - 1e-3 || (abs(zb[q] - zb[o]) \u003c= 1e-3 && id[q] \u003c g)) edge = true;\n      }\n      const c = cs[o] * 3, b = sh[o] * (edge ? 0.45 : 1);\n      display.setPixel(x, y, round(255 * col[c] * b), round(255 * col[c + 1] * b), round(255 * col[c + 2] * b));\n    }\n}\n","leaf-devil":"// ===== Patternflow pattern =====\n// Title:   Leaf Devil\n// Family:  halloween\n// Idea:    A drift of orange, red and yellow leaves lies at the foot of a deep purple night until a dust devil spins up out of it, skids the pile in, lifts the leaves round and round a swaying funnel that climbs all 128 rows, flings them off the top and then breaks, and the leaves flutter and zigzag back down, flashing as they turn, onto a new pile.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after autumn leaves caught in a dust devil on Halloween night\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Leaves=150..300, Wind=0..1\n//\n// Knob 1: Colour. Three nights round the knob: at 0 orange, red and yellow leaves with a few purple-black ones under a purple sky; at 0.33 toxic green and orange leaves under a green-black sky; at 0.67 orange, gold and violet leaves under a blue night. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 one round takes about 13 seconds: the devil spins up at 0.6 seconds, reaches the top of the panel 1.6 seconds later, spins for 4.2, breaks over 0.8, and the leaves are down about 5 seconds after that. At 0.2 a round takes about two minutes, at 3 about 9 seconds.\n// Knob 3: Leaves, 150 to 300. With 150 the pile at the foot is 7 or 8 rows deep in the middle, with 300 about 16; the funnel takes up nearly all of them at once.\n// Knob 4: Wind. A crosswind from the left: it leans the top of the funnel up to 20 LEDs to the right, makes the funnel half as wide again, widens its sway from 7 to 19 LEDs and blows the falling leaves along at up to 22 LEDs a second, so the new pile drifts to the right.\n// Buttons: K1 tap is a gust: it throws the whole pile into the air at once and spins up a devil if none is turning.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\n// The ground's top row; the pile stacks up from here.\nconst GROUND = 125;\nconst MAXLEAVES = 300;\n// Leaf shapes as LED offsets, 2 to 4 LEDs: maple, oak, a slim willow leaf and\n// a small curled one. The first offset is the stem end, drawn when edge on.\nconst SHAPES = [\n  [[0, 0], [-1, -1], [1, -1], [0, -1]],\n  [[0, 0], [1, 0], [0, -1]],\n  [[0, 0], [1, -1]],\n  [[0, 0], [1, 0], [1, -1]],\n];\n// Palettes, cycled by K1: sky at the top, sky at the horizon, ground, dust,\n// and five leaf colours (the last is the dark one, given to 8% of leaves).\nconst PAL = [\n  {\n    top: [0.04, 0, 0.08], low: [0.2, 0.04, 0.3], ground: [0.05, 0.01, 0.06], dust: [0.5, 0.36, 0.62],\n    leaf: [[1, 0.5, 0.04], [1, 0.14, 0.04], [1, 0.8, 0.08], [1, 0.33, 0.02], [0.36, 0.1, 0.5]],\n  },\n  {\n    top: [0, 0.05, 0.04], low: [0.04, 0.2, 0.12], ground: [0.01, 0.05, 0.03], dust: [0.4, 0.62, 0.4],\n    leaf: [[0.5, 1, 0.08], [1, 0.48, 0.04], [0.8, 1, 0.1], [1, 0.62, 0.05], [0.42, 0.08, 0.5]],\n  },\n  {\n    top: [0.01, 0.02, 0.1], low: [0.08, 0.1, 0.32], ground: [0.02, 0.02, 0.07], dust: [0.45, 0.5, 0.72],\n    leaf: [[1, 0.5, 0.04], [1, 0.75, 0.12], [0.72, 0.3, 1], [1, 0.3, 0.06], [0.45, 0.12, 0.62]],\n  },\n];\n// The devil's phases, in seconds at Speed 2: calm, spin-up, full, break.\nconst CALM = 1.4, SPIN = 1.6, FULL = 4.2, BREAK = 0.8;\n\nfunction rnd(a, b) {\n  return a + (b - a) * Math.random();\n}\n\nfunction newLeaf(i) {\n  const r = Math.random();\n  return {\n    i, state: 0, x: 0, y: 0, vx: 0, vy: 0, th: 0, rise: rnd(24, 40), rf: rnd(0.45, 1.1), ceil: 0, hover: null, bob: 0,\n    phi: rnd(0, TAU), spin: rnd(5, 13) * (Math.random() \u003c 0.5 ? -1 : 1), psi: rnd(0, TAU), wf: rnd(2.4, 4.4), af: rnd(14, 30),\n    tumble: Math.random() \u003c 0.3, quarter: floor(rnd(0, 4)), shape: floor(rnd(0, 4)), col: r \u003c 0.08 ? 4 : floor(rnd(0, 4)), release: 0, hop: 0, order: i,\n  };\n}\n\nexport function setup(params) {\n  params.s = {\n    t: 0, tau: 0, speed: 2, count: 150, wind: 0.06, hue: 0,\n    // Devil: phase 0 calm, 1 spin-up, 2 full, 3 break; time in phase; base x.\n    phase: 0, ph: CALM - 0.6, x0: 32, x0v: 0, s: 0, top: GROUND, spinA: 0, life: 0,\n    leaves: [], landed: 0, stack: new Float32Array(W),\n    rgb: new Float32Array(N * 3), sky: new Float32Array(N * 3), skyHue: NaN, pal: null,\n    stars: [], wasDown: false,\n  };\n  const S = params.s;\n  for (let i = 0; i \u003c MAXLEAVES; i++) S.leaves.push(newLeaf(i));\n  // The first pile: leaves dropped round the middle of the foot, each\n  // rolling off where the pile is steep, so they make a low mound.\n  for (const L of S.leaves) {\n    L.x = cl(round(31 + (Math.random() + Math.random() + Math.random() - 1.5) * 30), 1, 62);\n    L.order = S.landed++;\n    L.phi = Math.random() \u003c 0.5 ? 0 : PI;\n    roll(S, L);\n    stackLeaf(S, L);\n  }\n  for (let n = 0; n \u003c 12; n++) S.stars.push([floor(rnd(0, W)), floor(rnd(0, 50)), rnd(0.12, 0.3), rnd(0, TAU)]);\n}\n\n// The funnel's axis at row y: it sways, more toward the top, and a\n// crosswind leans the top over to the right.\nfunction axis(S, y) {\n  const up = cl((GROUND - y) / GROUND, 0, 1.1);\n  const sway = (7 + 12 * S.wind) * sin(1.1 * S.tau + 0.035 * (GROUND - y)) * up + 2 * sin(2.7 * S.tau + 0.08 * y) * up;\n  return S.x0 + sway + 20 * S.wind * up * (0.4 + 0.6 * up);\n}\n// The funnel widens upward, and a stronger wind feeds a wider one.\nconst radius = (S, y) => (3.5 + 17 * cl((GROUND - y) / GROUND, 0, 1.1) ** 1.2 * (0.9 + 0.2 * S.s)) * (0.9 + 0.5 * S.wind);\n\n// A resting leaf lies on whatever is under its width, and adds half a row to\n// the pile there: leaves lie flat and overlap.\nfunction stackLeaf(S, L) {\n  const w = L.shape === 0 ? 3 : 2, x = L.shape === 0 ? L.x - 1 : L.x;\n  L.y = pileTop(S, x, w);\n  for (let c = x; c \u003c x + w; c++) S.stack[(c + W) % W] = GROUND - 1 - L.y + 0.5;\n}\n\n// A leaf landing where the pile is steeper than about half a row a column\n// slides down the slope.\nfunction roll(S, L) {\n  for (let k = 0; k \u003c 24; k++) {\n    const here = S.stack[L.x], l = S.stack[(L.x + W - 2) % W], r = S.stack[(L.x + 2) % W];\n    if (here > l + 1 && l \u003c= r) L.x = (L.x + W - 1) % W;\n    else if (here > r + 1) L.x = (L.x + 1) % W;\n    else break;\n  }\n}\n\n// The top row of the pile over columns x..x+w-1.\nfunction pileTop(S, x, w) {\n  let h = 0;\n  for (let c = x; c \u003c x + w; c++) h = max(h, S.stack[(c + W) % W]);\n  return GROUND - 1 - h;\n}\n\nfunction enter(L) {\n  L.state = 2;\n  L.ceil = Math.random() \u003c 0.17 ? 2 : rnd(0.12, 0.98);\n  L.hover = null;\n}\n\nfunction release(S, L) {\n  // Thrown off the funnel along its spin, still rising a little.\n  const w = 5 * S.s + 1;\n  L.state = 3;\n  L.vx = -sin(L.th) * w * radius(S, L.y) * L.rf + rnd(-8, 8);\n  L.vy = -L.rise * 0.4 * S.s - rnd(0, 12);\n}\n\nfunction stepDevil(S, d, gust) {\n  S.ph += d;\n  if (gust && S.phase === 0) (S.phase = 1), (S.ph = 0.4 * SPIN);\n  if (S.phase === 0 && S.ph > CALM) {\n    // A new devil, somewhere the pile is.\n    let sum = 0, n = 0;\n    for (const L of S.leaves) if (L.i \u003c S.count && L.state === 0) (sum += L.x), n++;\n    S.x0 = cl((n ? sum / n : 32) + rnd(-10, 10), 18, 46);\n    S.x0v = rnd(-3, 3);\n    S.phase = 1;\n    S.ph = 0;\n  } else if (S.phase === 1 && S.ph > SPIN) (S.phase = 2), (S.ph = 0);\n  else if (S.phase === 2 && S.ph > FULL) {\n    S.phase = 3;\n    S.ph = 0;\n    for (const L of S.leaves) L.release = rnd(0, BREAK);\n  } else if (S.phase === 3 && S.ph > BREAK) {\n    // Calm again once nearly everything has landed.\n    let flying = 0;\n    for (const L of S.leaves) if (L.i \u003c S.count && L.state === 3) flying++;\n    if (flying \u003c S.count * 0.04 || S.ph > BREAK + 7) (S.phase = 0), (S.ph = 0);\n  }\n  const u = S.ph / (S.phase === 1 ? SPIN : S.phase === 3 ? BREAK : 1);\n  S.s = S.phase === 1 ? 0.3 + 0.7 * ease(u) : S.phase === 2 ? 1 : S.phase === 3 ? 1 - ease(u) : 0;\n  S.top = S.phase === 1 ? GROUND - (GROUND + 12) * ease(u) : S.phase === 0 ? GROUND : -12;\n  // The base wanders, more so in a crosswind.\n  S.x0v += (rnd(-1, 1) * 6 + (32 - S.x0) * 0.08) * d;\n  S.x0 = cl(S.x0 + (S.x0v + 4 * S.wind) * d, 16, 48 - 10 * S.wind);\n  S.spinA += d * 5 * S.s;\n  S.life = S.phase === 1 ? ease(u) * 0.5 : S.phase === 2 ? 0.5 + 0.5 * min(1, S.ph / 2) : S.phase === 3 ? 1 : 0;\n}\n\nfunction stepLeaf(S, L, d, gust) {\n  const active = S.phase === 1 || S.phase === 2;\n  if (L.state === 0) {\n    // Lying in the pile: now and then one turns over in the draught.\n    if (Math.random() \u003c d * 0.05) L.flipT = 0.4;\n    if (gust) {\n      L.state = 3;\n      L.vx = rnd(-35, 35);\n      L.vy = rnd(-130, -50);\n      return;\n    }\n    if (active) {\n      const dx = L.x - S.x0, reach = 5 + 36 * S.life;\n      if (abs(dx) \u003c reach && Math.random() \u003c d * (1.5 + 4 * S.s)) L.state = 1;\n    }\n  } else if (L.state === 1) {\n    // Skidding over the pile toward the foot of the funnel in little hops.\n    if (!active) {\n      L.state = 3;\n      L.vx = rnd(-10, 10);\n      L.vy = -rnd(5, 20);\n      return;\n    }\n    const dx = L.x - S.x0;\n    L.x -= Math.sign(dx) * (24 + 30 * S.s) * d;\n    L.hop += d * 9;\n    L.y = pileTop(S, floor(L.x), 2) - 2.5 * abs(sin(L.hop));\n    L.phi += L.spin * d;\n    if (abs(dx) \u003c 2 + 3 * L.rf) {\n      enter(L);\n      const r = radius(S, L.y) * L.rf;\n      L.th = Math.acos(cl((L.x - axis(S, L.y)) / r, -1, 1)) * (Math.random() \u003c 0.5 ? 1 : -1);\n    }\n  } else if (L.state === 2) {\n    // Round and up the funnel, faster round near the ground. Each leaf rises\n    // to its own height and rides round there, bobbing, so the funnel is full\n    // from the ground to the top; one in six goes over the top.\n    if (S.phase === 3 && S.ph >= L.release) return release(S, L);\n    if (!active && S.phase !== 3) return release(S, L);\n    const up = (GROUND - L.y) / GROUND;\n    L.th += d * S.s * (6.5 - 3 * min(1, up));\n    if (L.ceil \u003c 1 && up >= L.ceil) {\n      if (L.hover === null) (L.hover = L.y), (L.bob = 0);\n      L.bob += d * 2.2;\n      L.y = L.hover - 3 * sin(L.bob);\n    } else L.y -= d * L.rise * S.s * (0.75 + 0.5 * up);\n    L.phi += L.spin * d * 1.4;\n    // Flung out over the top of the column.\n    if (L.y \u003c max(S.top, 0) + 3 + 6 * L.rf) return release(S, L);\n    L.x = axis(S, L.y) + radius(S, L.y) * L.rf * cos(L.th);\n  } else if (L.state === 3) {\n    // Fluttering down: rocking from side to side, falling fastest through the\n    // middle of each swing, with the crosswind and some drag.\n    L.psi += L.wf * d;\n    const tx = L.af * cos(L.psi) + 22 * S.wind, ty = 16 + 12 * abs(sin(L.psi));\n    L.vx += (tx - L.vx) * min(1, d * 2.2);\n    L.vy += (ty - L.vy) * min(1, d * (L.vy \u003c 0 ? 1.4 : 2.2));\n    L.x += L.vx * d;\n    L.y += L.vy * d;\n    L.x = (L.x + W) % W;\n    if (L.tumble) L.phi += L.spin * d;\n    else L.phi = 1.3 * sin(L.psi);\n    // Caught again by the foot of a turning funnel.\n    if (active && S.s > 0.6 && L.y > GROUND - 45) {\n      const dx = L.x - axis(S, L.y);\n      if (abs(dx) \u003c radius(S, L.y) * 0.9 && Math.random() \u003c d * 3) {\n        enter(L);\n        L.rf = cl(abs(dx) / radius(S, L.y), 0.4, 1.1);\n        L.th = dx >= 0 ? 0 : PI;\n        return;\n      }\n    }\n    if (L.vy > 0 && L.y >= pileTop(S, floor(L.x), 2)) {\n      L.state = 0;\n      L.order = S.landed++;\n      L.x = floor(L.x);\n      L.phi = cos(L.phi) \u003c 0 ? PI : 0;\n      roll(S, L);\n      stackLeaf(S, L);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 150, 0.06], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[3], 0, 1);\n  const count = cl(round(k[2]), 150, MAXLEAVES);\n  // Leaves added by K3 drift in from above the panel; on the first frame\n  // they are simply part of the pile.\n  if (!S.started) (S.started = true), (S.count = count);\n  for (const L of S.leaves)\n    if (L.i >= S.count && L.i \u003c count) {\n      L.state = 3;\n      L.x = rnd(0, W);\n      L.y = rnd(-40, -2);\n      L.vx = L.vy = 0;\n    }\n  S.count = count;\n  const down = !!(input.btnPressed && input.btnPressed[0]);\n  const gust = down && !S.wasDown;\n  S.wasDown = down;\n  const d = d0 * S.speed * 0.5;\n  S.t += d0;\n  S.tau += d;\n  stepDevil(S, d, gust);\n  // The pile, restacked each frame in landing order so it settles into gaps\n  // left by the leaves the devil took.\n  S.stack.fill(0);\n  const resting = [];\n  for (const L of S.leaves) if (L.i \u003c S.count && L.state === 0) resting.push(L);\n  resting.sort((a, b) => a.order - b.order);\n  for (const L of resting) stackLeaf(S, L);\n  for (const L of S.leaves) {\n    if (L.i >= S.count) continue;\n    stepLeaf(S, L, d, gust);\n    if (L.flipT > 0) {\n      L.flipT -= d;\n      L.phi += (PI / 0.4) * d;\n    }\n  }\n}\n\n// --- drawing ---\n\nfunction palette(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  const m = (a, b) => a.map((v, c) => mix(v, b[c], s));\n  const A = PAL[i], B = PAL[j];\n  return { top: m(A.top, B.top), low: m(A.low, B.low), ground: m(A.ground, B.ground), dust: m(A.dust, B.dust), leaf: A.leaf.map((c, n) => m(c, B.leaf[n])) };\n}\n\nfunction put(rgb, x, y, c, a) {\n  x = floor(x);\n  y = floor(y);\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = (y * W + x) * 3;\n  rgb[o] = mix(rgb[o], c[0], a);\n  rgb[o + 1] = mix(rgb[o + 1], c[1], a);\n  rgb[o + 2] = mix(rgb[o + 2], c[2], a);\n}\n\nfunction drawLeaf(S, rgb, L, pal) {\n  const base = pal.leaf[L.col], c = cos(L.phi);\n  // The far side of the funnel is a little darker, never so dark that an\n  // orange leaf turns brown.\n  const far = L.state === 2 ? 0.88 + 0.12 * sin(L.th) : 1;\n  const back = c \u003c 0;\n  // Back of the leaf: a shade warmer and deeper.\n  const col = back ? [base[0], base[1] * 0.78, base[2] * 0.8] : base;\n  const lit = col.map((v) => min(1, v * far));\n  const ox = L.x, oy = L.y;\n  if (abs(c) \u003c 0.32) {\n    // Edge on: a sliver catching the light.\n    put(rgb, ox, oy, lit.map((v) => mix(v, 1, 0.35)), 1);\n    if (L.shape !== 2) put(rgb, ox + (L.quarter & 1 ? 0 : 1), oy - (L.quarter & 1 ? 1 : 0), lit, 0.7);\n    return;\n  }\n  const shape = SHAPES[L.shape], q = L.quarter;\n  for (let n = 0; n \u003c shape.length; n++) {\n    let [dx, dy] = shape[n];\n    if (back) dx = -dx;\n    for (let r = 0; r \u003c q; r++) [dx, dy] = [-dy, dx];\n    put(rgb, ox + dx, oy + dy, lit, 1);\n  }\n  // Face full on: a flash on the leaf's blade.\n  if (abs(c) > 0.93) {\n    let [dx, dy] = shape[shape.length - 1];\n    if (back) dx = -dx;\n    for (let r = 0; r \u003c q; r++) [dx, dy] = [-dy, dx];\n    put(rgb, ox + dx, oy + dy, [1, 0.95, 0.7], 0.55 * (abs(c) - 0.93) / 0.07 + (L.col === 4 ? 0.2 : 0));\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const pal = (S.pal = S.skyHue === S.hue && S.pal ? S.pal : palette(S));\n  const { rgb, sky } = S;\n  // Sky, stars and ground only change with the colour.\n  if (S.skyHue !== S.hue) {\n    for (let y = 0; y \u003c H; y++) {\n      const u = (y / GROUND) ** 1.6;\n      for (let x = 0; x \u003c W; x++) {\n        const o = (y * W + x) * 3, c = y >= GROUND ? pal.ground : null;\n        for (let ch = 0; ch \u003c 3; ch++) sky[o + ch] = c ? c[ch] : mix(pal.top[ch], pal.low[ch], u);\n      }\n    }\n    S.skyHue = S.hue;\n  }\n  rgb.set(sky);\n  for (const [x, y, a, p] of S.stars) put(rgb, x, y, [0.9, 0.85, 1], a * (0.6 + 0.4 * sin(S.t * 1.3 + p)));\n  const flying = [];\n  for (const L of S.leaves) if (L.i \u003c S.count) flying.push(L);\n  // The far half of the funnel's leaves go behind the dust.\n  for (const L of flying) if (L.state === 2 && sin(L.th) \u003c 0) drawLeaf(S, rgb, L, pal);\n  // Dust: a twisting veil round the funnel's axis, and a cloud at its foot.\n  if (S.s > 0.01) {\n    const dust = pal.dust;\n    for (let y = max(0, floor(S.top - 6)); y \u003c= GROUND + 2 && y \u003c H; y++) {\n      const xa = axis(S, y), r = radius(S, y) * 1.1, fade = cl((y - S.top) / 14, 0, 1);\n      for (let x = 0; x \u003c W; x++) {\n        const u = (x - xa) / r;\n        if (abs(u) > 1.7) continue;\n        const band = 0.55 + 0.45 * sin(0.3 * y - 3 * S.spinA + 2.6 * u);\n        let a = exp(-u * u * 1.6) * band * 0.3;\n        const gy = (y - GROUND) / 5, gx = (x - S.x0) / (10 + 12 * S.life);\n        a += 0.35 * exp(-gy * gy - gx * gx);\n        a *= S.s * fade;\n        if (a > 0.004) {\n          const o = (y * W + x) * 3;\n          for (let ch = 0; ch \u003c 3; ch++) rgb[o + ch] = min(1, rgb[o + ch] + dust[ch] * a);\n        }\n      }\n    }\n  }\n  // The pile, bottom up, then everything in the air.\n  for (const L of flying) if (L.state === 0) drawLeaf(S, rgb, L, pal);\n  for (const L of flying) if (L.state === 1 || L.state === 3 || (L.state === 2 && sin(L.th) >= 0)) drawLeaf(S, rgb, L, pal);\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","mobius-loxodrome":"// ===== Patternflow pattern =====\n// Title:   Möbius Loxodrome\n// Family:  geometry\n// Idea:    The flow of a Möbius transformation with a source above the panel and a sink below it: a conformal checkerboard, every tile streaked with bright sawtooth ripples, pours out of the source and into the sink along circles, and along double spirals once the transformation is turned loxodromic.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Möbius transformations (August Ferdinand Möbius, 1855), the loxodromic case, drawn as a conformal checkerboard shaded like an enhanced phase portrait (Elias Wegert, 2012), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Twist=0..1, Poles=0..1\n//\n// Knob 1: Hue. Turns both colours of the checker round the wheel together. At 0 the tiles are teal and magenta, at 0.25 violet and orange, at 0.6 green and coral; where a colour lands on orange, the dark half of each ripple is turned towards rose so it does not read brown.\n// Knob 2: Speed. How fast the plane streams from the source to the sink. At 2 the multiplier is 1.068 a second, so a ring of tiles passes every 5.3 seconds and a tile in the middle moves 3.3 LEDs a second; at 0.2 a ring takes 53 seconds, at 3 it takes 3.5. The axis through the two fixed points also rocks 7 degrees either way, once in 42 seconds at 2.\n// Knob 3: Twist. The argument of the multiplier. At 0 the transformation is hyperbolic: the tiles run straight down the circles through both fixed points. Turned up, it turns loxodromic and the lanes of tiles wind into spirals; at 1 they cross the circles through the fixed points at 54 degrees and the plane turns 3.1 degrees a second about each fixed point while it streams.\n// Knob 4: Poles. How far the fixed points stand beyond the panel's top and bottom edges: 38 LEDs at 0, so the middle tiles are 17 LEDs across and the rings only bow, down to 0 at 1, where they sit on the middle of the edges, the lanes fan out of them and the tiles shrink into a pale glow there.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, atan2, log, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// In w = log((z - p) / (z - q)) the transformation z -> (az + b) / (cz + d)\n// that fixes p and q is a shift by log k, k its multiplier, so a picture\n// drawn in w and slid along log k is the flow. The picture: a checker whose\n// rows are the flow lines, and over it ripples, a sawtooth whose drops run at\n// 45 degrees to the flow. On the panel those come out near diagonal, so a\n// ripple climbs about 30 levels from one LED to the next along a row and\n// along a column alike, and only its drop is a hard edge.\n//\n// The tiling of the w-plane. w is only defined up to 2 pi i, so it has to\n// close up when v goes once round: LANES flow lanes round each fixed point\n// (even, so the checker closes too), ARMS ripple arms, and rings spaced\n// RING apart in u.\nconst LANES = 18, ARMS = 42, RING = (2 * PI) / LANES;\n// The steepest a ripple may rise from one LED to the next along a row or a\n// column, in levels of 255. Where the ripples crowd, near a fixed point, their\n// height is cut so a rise never passes it.\nconst LIM = 38;\n// How far the fixed points stand beyond the panel's top and bottom, in LEDs,\n// at Poles 0 and 1.\nconst FAR = 38, NEAR = 0;\n\nexport function setup(params) {\n  params.s = { hue: 0, speed: 2, twist: 0, poles: 0.06, T: 0, clock: 0, rgb: new Float64Array(3) };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.twist = cl(k[2], 0, 1);\n  S.poles = cl(k[3], 0, 1);\n  // T is how far the flow has carried the w-plane along log k.\n  S.T += d * S.speed * 0.033;\n  S.clock += d * S.speed;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const rgb = S.rgb;\n  // The fixed points: p above, q below, on an axis through the middle of the\n  // panel that rocks slowly from side to side.\n  const R = 64 + FAR + (NEAR - FAR) * S.poles, sway = 0.12 * sin(S.clock * 0.075);\n  const px = 32 - R * sin(sway) + 1e-4, py = 64 - R * cos(sway), qx = 32 + R * sin(sway) + 1e-4, qy = 64 + R * cos(sway);\n  const dx = px - qx, dy = py - qy;\n  // log k = |log k| e^(i beta): beta 0 is hyperbolic, the flow running\n  // straight along the circles through p and q; beta > 0 is loxodromic.\n  const beta = S.twist * 0.95, cb = cos(beta), sb = sin(beta), tb = sb / cb;\n  // Ripples at 45 degrees to the flow: r = ARMS v / 2 pi + kap u.\n  const m = ARMS / (2 * PI), kap = m / Math.tan(beta + PI / 4), rw = sqrt(kap * kap + m * m);\n  const ou = S.T * cb, ov = S.T * sb;\n  const h0 = S.hue + 0.48, h1 = S.hue + 0.84;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const ax = x + 0.5 - px, ay = y + 0.5 - py, bx = x + 0.5 - qx, by = y + 0.5 - qy;\n      // w = log((z - p) / (z - q)), moved back along the flow.\n      const u = 0.5 * log((ax * ax + ay * ay) / (bx * bx + by * by)) - ou;\n      const v = atan2(ay, ax) - atan2(by, bx) - ov;\n      // dw/dz = (p - q) / ((z - p)(z - q)): how far w moves over one LED.\n      const mr = ax * bx - ay * by, mi = ax * by + ay * bx, mm = mr * mr + mi * mi;\n      const wr = (dx * mr + dy * mi) / mm, wi = (dy * mr - dx * mi) / mm, sc = sqrt(wr * wr + wi * wi);\n      // The checker: rows are the flow lines, cut by the circles round p.\n      const a = u / RING, b = (v - u * tb) / RING;\n      const odd = (floor(a) + floor(b)) & 1;\n      // The ripple's sawtooth: dark, rising to a bright crest, then a drop.\n      const r = m * v + kap * u, f = r - floor(r);\n      const gx = kap * wr + m * wi, gy = m * wr - kap * wi;\n      const amp = min(1, LIM / 255 / max(abs(gx), abs(gy)));\n      let lev = 1 - amp + amp * f;\n      // Ripples narrower than 2.8 LEDs fade into the glow of the fixed point,\n      // gone under 1.6, and the checker after them, from 6 LEDs to 3.\n      const pr = 1 / (rw * sc), fr = cl((pr - 1.6) / 1.2, 0, 1), ft = cl((RING / sc - 3) / 3, 0, 1);\n      const core = cl(1 - pr / 1.6, 0, 1);\n      lev = lev * fr + (0.6 + 0.4 * core) * (1 - fr);\n      let h = odd ? h1 : h0;\n      // An orange family turns towards rose and plum in its dark half, which\n      // would read brown on the panel.\n      const warm = max(0, 1 - abs(h - floor(h) - 0.095) / 0.09);\n      h -= 0.17 * warm * (1 - f) * fr;\n      const sat = ((f > 0.8 ? 0.55 : 0.88) * fr + 0.45 * (1 - fr)) * ft + 0.4 * (1 - ft);\n      hsv(h * ft + (0.5 * (h0 + h1) + 0.25) * (1 - ft), sat * (1 - core), lev, rgb);\n      display.setPixel(x, y, round(rgb[0] * 255), round(rgb[1] * 255), round(rgb[2] * 255));\n    }\n}\n","orb-weaver":"// ===== Patternflow pattern =====\n// Title:   Orb Weaver\n// Family:  halloween\n// Idea:    A purple and orange garden spider builds an orb web down the whole panel: bridge line, frame, radii one by one, a temporary spiral, then the sticky spiral from the rim inward with turnbacks in the long lower half, until the finished web shimmers with orange dew and a gust tears it away.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the orb webs of garden spiders (Araneidae) and the cobwebs of Halloween\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Radii=20..44, Wind=0..1\n//\n// Knob 1: Colour. Three silks round the knob, all lit brighter and warmer toward the bottom of the panel: at 0 silver-violet, at 0.33 toxic green, at 0.67 the bone white of Halloween cobwebs. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again. The spider stays purple with an orange cross and the dew stays orange.\n// Knob 2: Speed. At 2 a web of 20 radii takes 63 seconds: 2 for the bridge line to float across, 5 for the frame, 22 for the radii, 2.5 for the hub and temporary spiral, 16 for the sticky spiral, 11 shimmering with dew, 3.3 for the gust and 1.5 for the spider to walk back in. At 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Radii, 20 to 44 in steps of 2, spaced evenly along the frame so the long lower half gets as many as the rest; at 44 the radii take 44 seconds at Speed 2. Turning it respins the web at the same stage of building.\n// Knob 4: Wind. Sways the web sideways, 1 LED at the hub at 0.06 and 6 LEDs at 1, makes the floating bridge line flutter harder, and throws the torn pieces further.\n// Buttons: K1 tap sends the gust: the web tears now and a new one starts.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, round, exp, atan2, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// Silks by K1: silver-violet, toxic green, bone white. The spider's body,\n// its cross and leg colour, and the dew stay put.\nconst SILK = [[0.76, 0.62, 1], [0.42, 1, 0.22], [0.92, 0.9, 0.84]];\nconst BODY = [0.55, 0.14, 1], MARK = [1, 0.55, 0.05], LEG = [0.72, 0.38, 1], DEW = [1, 0.5, 0.04], GLINT = [1, 0.82, 0.45];\n// Spider speeds in LEDs per second at Speed 1: walking on laid silk,\n// laying a frame line or radius, dropping, laying the sticky spiral.\nconst WALK = 65, LAY = 50, DROP = 60, STICKY = 40;\n// Sticky spiral: spacing, the free zone round the hub, the gap to the frame.\nconst GAP = 3.3, FREE = 7.5, RIM = 4;\n// Seconds at Speed 1: bridge float, dew, tear, walking back in.\nconst FLOAT = 4, DEWT = 22, TEAR = 6.5, ENTER = 3;\n\n// A thread or path: points subdivided to at most 5 LEDs apart, with the\n// length up to each point and, for spirals, the distance from the hub.\nfunction poly(points, rs) {\n  const xs = [], ys = [], r = [];\n  for (let i = 0; i \u003c points.length; i++) {\n    const [x, y] = points[i];\n    if (i) {\n      const [px, py] = points[i - 1], n = Math.ceil(sqrt((x - px) ** 2 + (y - py) ** 2) / 5);\n      for (let k = 1; k \u003c n; k++) xs.push(mix(px, x, k / n)), ys.push(mix(py, y, k / n)), r.push(rs ? mix(rs[i - 1], rs[i], k / n) : 0);\n    }\n    xs.push(x), ys.push(y), r.push(rs ? rs[i] : 0);\n  }\n  const cum = [0];\n  for (let i = 1; i \u003c xs.length; i++) cum.push(cum[i - 1] + sqrt((xs[i] - xs[i - 1]) ** 2 + (ys[i] - ys[i - 1]) ** 2));\n  return { xs, ys, r, cum, len: cum[cum.length - 1] };\n}\n\n// The point at distance s along a path, and the heading there.\nfunction along(p, s, out) {\n  const { xs, ys, cum } = p;\n  let i = 1;\n  while (i \u003c cum.length - 1 && cum[i] \u003c s) i++;\n  const f = cl((s - cum[i - 1]) / (cum[i] - cum[i - 1] || 1), 0, 1);\n  out[0] = mix(xs[i - 1], xs[i], f);\n  out[1] = mix(ys[i - 1], ys[i], f);\n  out[2] = atan2(ys[i] - ys[i - 1], xs[i] - xs[i - 1]);\n}\n\n// The web's plan: hub, bridge, frame, radii anchored evenly along the frame,\n// and the moves the spider makes to build it, each tagged with its stage:\n// 0 bridge, 1 frame, 2 radii, 3 hub and temporary spiral, 4 sticky, 5 home.\nfunction plan(S, n) {\n  // Each web's own wobble, kept while K3 respins it.\n  let ji = 0;\n  const j = () => S.jit[ji++];\n  const hub = [31.5 + 1.5 * j(), 37 + 2 * j()];\n  const BL = [0, 6 + 1.5 * j()], BR = [63, 5 + 1.5 * j()];\n  const onBridge = (x) => [x, mix(BL[1], BR[1], x / 63)];\n  const F0 = onBridge(7 + 2 * j()), F1 = onBridge(56 + 2 * j());\n  const F2 = [60 + j(), 47 + 3 * j()], F3 = [51 + 2 * j(), 121 + j()], F4 = [12 + 2 * j(), 122 + j()], F5 = [3 + j(), 49 + 3 * j()];\n  const M = onBridge(hub[0]), G = [hub[0], mix(F4[1], F3[1], (hub[0] - F4[0]) / (F3[0] - F4[0]))];\n  // The frame as a ring from M: down the right side to G and back up the left.\n  const ring = [M, F1, F2, F3, G, F4, F5, F0], R = ring.length, sAt = [0];\n  for (let i = 1; i \u003c= R; i++) sAt.push(sAt[i - 1] + sqrt((ring[i % R][0] - ring[i - 1][0]) ** 2 + (ring[i % R][1] - ring[i - 1][1]) ** 2));\n  const P = sAt[R], sG = sAt[4], wrap = (s) => ((s % P) + P) % P;\n  const ringAt = (s) => {\n    s = wrap(s);\n    let i = 1;\n    while (sAt[i] \u003c s) i++;\n    const f = (s - sAt[i - 1]) / (sAt[i] - sAt[i - 1]);\n    return [mix(ring[i - 1][0], ring[i % R][0], f), mix(ring[i - 1][1], ring[i % R][1], f)];\n  };\n  // Along the frame from s0 to s1 the short way, through its corners.\n  const frameWalk = (s0, s1) => {\n    let d = wrap(s1 - s0);\n    if (d > P / 2) d -= P;\n    const mid = [];\n    for (let k = 0; k \u003c R; k++) {\n      const t = d > 0 ? wrap(sAt[k] - s0) : wrap(s0 - sAt[k]);\n      if (t > 0 && t \u003c abs(d)) mid.push([t, ring[k]]);\n    }\n    mid.sort((a, b) => a[0] - b[0]);\n    return [ringAt(s0), ...mid.map((m) => m[1]), ringAt(s0 + d)];\n  };\n  const h = n / 2, rad = [];\n  for (let k = 0; k \u003c n; k++) {\n    const s = k \u003c= h ? (sG * k) / h : sG + ((P - sG) * (k - h)) / h, a = ringAt(s);\n    const dx = a[0] - hub[0], dy = a[1] - hub[1], L = sqrt(dx * dx + dy * dy);\n    rad.push({ s, a, L, ux: dx / L, uy: dy / L, th: atan2(dy, dx) });\n  }\n  const at = (k, r) => [hub[0] + r * rad[k].ux, hub[1] + r * rad[k].uy];\n\n  const threads = [], moves = [];\n  const thread = (pts, rs, a) => (threads.push({ p: poly(pts, rs), a, shown: 0 }), threads.length - 1);\n  const lay = (t, v, stage) => moves.push({ p: threads[t].p, t, v, stage });\n  const walk = (pts, v, stage) => moves.push({ p: poly(pts), t: -1, v, stage });\n\n  // The bridge floats across first (drawn apart); then the spider walks to M.\n  const bridge = thread([BL, BR], null, 0.85);\n  walk([BL, M], WALK, 0);\n  // Drop from M through the hub to G, frame the left side up to the bridge,\n  // cross it, frame the right side down, and climb back to the hub.\n  lay(thread([M, hub, G], null, 0.85), DROP, 1);\n  const left = thread([G, F4, F5, F0], null, 0.8);\n  lay(left, LAY, 1);\n  walk([F0, M, F1], WALK, 1);\n  const right = thread([F1, F2, F3, G], null, 0.8);\n  lay(right, LAY, 1);\n  walk([G, hub], WALK, 1);\n  // Moorings to the panel's edges, each grown once the spider framing that\n  // side has passed its corner.\n  const d2 = (a, b) => sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2);\n  const moor = [\n    [F2, [63, F2[1] - 7], right, d2(F1, F2)],\n    [F3, [57, 127], right, d2(F1, F2) + d2(F2, F3)],\n    [F4, [6, 127], left, d2(G, F4)],\n    [F5, [0, F5[1] + 6], left, d2(G, F4) + d2(F4, F5)],\n  ].map(([a, b, f, s]) => ({ t: thread([a, b], null, 0.75), f, s }));\n  // Radii: up and down are the drag line. Each new one goes into the widest\n  // gap left: out along the nearest laid radius, along the frame, and back\n  // to the hub laying the new one.\n  const laid = new Set([0, h]);\n  while (laid.size \u003c n) {\n    let best = -1, gap = -1, nb = 0;\n    for (let k = 0; k \u003c n; k++) {\n      if (laid.has(k)) continue;\n      let g = 1e9, near = 0;\n      for (const q of laid) {\n        const dd = abs(((rad[k].th - rad[q].th + 3 * PI) % TAU) - PI);\n        if (dd \u003c g) (g = dd), (near = q);\n      }\n      if (g > gap + 1e-6) (gap = g), (best = k), (nb = near);\n    }\n    walk([hub, rad[nb].a], WALK, 2);\n    walk(frameWalk(rad[nb].s, rad[best].s), WALK, 2);\n    lay(thread([rad[best].a, hub], null, 0.85), LAY, 2);\n    laid.add(best);\n  }\n  // The hub mesh and the temporary spiral, outward to the shortest radius.\n  let Rf = 1e9, Rx = 0;\n  for (const r of rad) (Rf = min(Rf, r.L - RIM)), (Rx = max(Rx, r.L - RIM));\n  const spiral = (r0, r1, pitch, k0) => {\n    const pts = [], rs = [];\n    for (let q = 0, r = r0; r \u003c= r1; q++, r = r0 + (pitch * q) / n) pts.push(at((k0 + q) % n, r)), rs.push(r);\n    return [pts, rs];\n  };\n  const [hp, hr] = spiral(1.6, FREE - 1.5, 1.4, 0);\n  lay(thread(hp, hr, 1), LAY, 3);\n  const [tp, tr] = spiral(FREE - 1.5, Rf + 2, 7, hp.length % n);\n  const temp = thread(tp, tr, 0.5);\n  lay(temp, 1.4 * LAY, 3);\n  // The sticky spiral from the rim inward: an arc round the bottom radius at\n  // every level only the long lower radii reach, turning back at each end,\n  // then whole turns once every radius is long enough.\n  const sp = [], sr = [];\n  let dir = 1, kEnd = h, kStart = -1;\n  for (let r = Rf + GAP * floor((Rx - Rf) / GAP); r > Rf + 1e-6; r -= GAP) {\n    let lo = h, hi = h;\n    while (lo > 1 && rad[lo - 1].L - RIM >= r) lo--;\n    while (hi \u003c n - 1 && rad[hi + 1].L - RIM >= r) hi++;\n    if (hi - lo \u003c 1) continue;\n    for (let k = dir > 0 ? lo : hi; dir > 0 ? k \u003c= hi : k >= lo; k += dir) {\n      if (kStart \u003c 0) kStart = k;\n      sp.push(at(k, r)), sr.push(r);\n    }\n    kEnd = dir > 0 ? hi : lo;\n    dir = -dir;\n  }\n  if (sp.length) dir = -dir;\n  for (let q = 0, r = Rf; r >= FREE; q++, r = Rf - (GAP * q) / n) {\n    const k = (((kEnd + dir * q) % n) + n) % n;\n    if (kStart \u003c 0) kStart = k;\n    sp.push(at(k, r)), sr.push(r);\n  }\n  const kT = (hp.length + tp.length - 1) % n;\n  walk([tp[tp.length - 1], rad[kT].a], WALK, 4);\n  walk(frameWalk(rad[kT].s, rad[kStart].s), WALK, 4);\n  walk([rad[kStart].a, sp[0]], WALK, 4);\n  const sticky = thread(sp, sr, 1);\n  lay(sticky, STICKY, 4);\n  walk([sp[sp.length - 1], hub], WALK, 5);\n  Object.assign(S, { threads, moves, bridge, moor, temp, sticky, hub, BL, BR, mi: 0, ms: 0 });\n}\n\n// Jump to a share f of the way through a stage, everything before it built.\nfunction seek(S, stage, f) {\n  const { moves, threads } = S;\n  let total = 0;\n  for (const m of moves) if (m.stage === stage) total += m.p.len;\n  let left = f * total;\n  S.mi = moves.length;\n  for (let i = 0; i \u003c moves.length; i++) {\n    const m = moves[i];\n    if (m.stage \u003c stage || (m.stage === stage && left >= m.p.len && i \u003c moves.length - 1)) {\n      if (m.stage === stage) left -= m.p.len;\n      if (m.t >= 0) threads[m.t].shown = m.p.len;\n      continue;\n    }\n    S.mi = i;\n    S.ms = m.stage === stage ? left : 0;\n    if (m.t >= 0) threads[m.t].shown = S.ms;\n    break;\n  }\n  threads[S.bridge].shown = threads[S.bridge].p.len;\n  for (const m of S.moor) threads[m.t].shown = stage > 1 ? threads[m.t].p.len : 0;\n}\n\n// How far through its stage the build is, 0..1.\nfunction progress(S) {\n  const stage = S.moves[S.mi].stage;\n  let total = 0, done = 0;\n  S.moves.forEach((m, i) => {\n    if (m.stage !== stage) return;\n    total += m.p.len;\n    if (i \u003c S.mi) done += m.p.len;\n  });\n  return [stage, (done + S.ms) / (total || 1)];\n}\n\nexport function setup(params) {\n  params.s = {\n    col: 0, speed: 2, wind: 0.06, rt: 0, phase: \"build\", clock: 0, builtFor: -1, gust: 1,\n    T: new Float32Array(N), rgb: new Float32Array(N * 3), legs: new Float32Array(N), row: new Float32Array(H * 3),\n    pos: [0, 0, 0], heading: 0, gait: 0, frags: [], dew: [], fly: null, jit: [],\n  };\n  newJitter(params.s);\n}\n\nfunction newJitter(S) {\n  S.jit = Array.from({ length: 16 }, () => rnd(-1, 1));\n}\n\n// The gust: the web bellies out downwind, then breaks piece by piece from\n// the windward side, each piece flying off, tumbling, falling and fading.\nfunction gustOn(S, f, x) {\n  const side = S.gust > 0 ? x / 63 : 1 - x / 63, w = 1 + 1.5 * S.wind;\n  return Object.assign(f, { tb: 0.5 + 2.2 * side + rnd(0, 0.6), vx: S.gust * rnd(8, 22) * w, vy: rnd(-8, 2), om: rnd(-3, 3) });\n}\n\n// Where a piece is now: offset, turn and how much is left of it.\nfunction blown(S, f, x, y) {\n  const tau = S.clock - f.tb, belly = S.gust * (2 + 3 * S.wind) * sin(PI * cl(x / 63, 0, 1)) * sin(PI * cl(y / 127, 0, 1));\n  if (tau \u003c 0) return [belly * (S.clock / f.tb) ** 2, 0, 0, 1];\n  return [belly + f.vx * tau, f.vy * tau + 6 * tau * tau, f.om * tau, max(0, 1 - tau / 2.6)];\n}\n\nfunction startTear(S) {\n  S.dewOn = S.phase === \"dew\" ? 1 : 0;\n  S.phase = \"tear\";\n  S.clock = 0;\n  S.gust = Math.random() \u003c 0.5 ? -1 : 1;\n  const frags = [], cut = S.rCut;\n  for (const th of S.threads) {\n    const { xs, ys, r, cum } = th.p;\n    for (let i = 1; i \u003c xs.length && cum[i] \u003c= th.shown + 1e-6; i++) {\n      if (th === S.threads[S.temp] && r[i] > cut) continue;\n      const [ax, ay] = sway(S, xs[i - 1], ys[i - 1]), [bx, by] = sway(S, xs[i], ys[i]);\n      const cx = (ax + bx) / 2, cy = (ay + by) / 2;\n      frags.push(gustOn(S, { cx, cy, hx: (bx - ax) / 2, hy: (by - ay) / 2, a: th.a }, cx));\n    }\n  }\n  S.frags = frags;\n  for (const d of S.dew) gustOn(S, d, d.x);\n  S.fly = gustOn(S, { x: S.pos[0], y: S.pos[1] }, S.pos[0]);\n  S.fly.om = 5 * S.gust;\n}\n\n// Where the wind has pushed a point of the web: anchored at the panel's\n// edges, freest in the middle.\nfunction sway(S, x, y) {\n  const f = sin(PI * cl(x / 63, 0, 1)) ** 0.7 * sin(PI * cl(y / 127, 0, 1)) ** 0.7;\n  return [x + S.dx * f, y + S.dy * f];\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 20, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.col = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.wind = cl(k[3], 0, 1);\n  const n = 20 + 2 * round((cl(k[2], 20, 44) - 20) / 2), sp = d * S.speed;\n  S.rt += d;\n  const A = 0.6 + 6 * S.wind;\n  S.dx = A * (0.65 * sin(0.8 * S.rt) + 0.35 * sin(2.1 * S.rt + 1.3));\n  S.dy = 0.3 * A * sin(1.3 * S.rt + 0.4);\n  if (S.builtFor !== n) {\n    // The first web opens with the spider at the rim, about to lay the\n    // sticky spiral; a new count respins the web at the same stage.\n    if (S.builtFor \u003c 0) {\n      plan(S, n);\n      seek(S, 4, 0);\n      while (S.moves[S.mi].t !== S.sticky) S.mi++;\n    } else if (S.phase === \"build\") {\n      const [stage, f] = progress(S);\n      plan(S, n);\n      seek(S, stage, f);\n    } else if (S.phase === \"dew\") plan(S, n), seek(S, 6, 0), makeDew(S);\n    else if (S.phase !== \"tear\") plan(S, n);\n    S.builtFor = n;\n  }\n  if (input.btnPressed && input.btnPressed[0] && (S.phase === \"build\" || S.phase === \"dew\" || S.phase === \"float\")) startTear(S);\n  S.clock += sp;\n  const pos = S.pos;\n  let moved = 0;\n  if (S.phase === \"float\") {\n    (pos[0] = S.BL[0] + 1.5), (pos[1] = S.BL[1] + 1), (pos[2] = 0);\n    if (S.clock >= FLOAT) (S.phase = \"build\"), (S.mi = 0), (S.ms = 0), (S.threads[S.bridge].shown = S.threads[S.bridge].p.len);\n  } else if (S.phase === \"build\") {\n    let m = S.moves[S.mi];\n    S.ms += m.v * sp;\n    moved = m.v * sp;\n    while (S.ms >= m.p.len) {\n      if (m.t >= 0) S.threads[m.t].shown = m.p.len;\n      S.ms -= m.p.len;\n      if (++S.mi >= S.moves.length) break;\n      m = S.moves[S.mi];\n    }\n    if (S.mi >= S.moves.length) {\n      S.phase = \"dew\";\n      S.clock = 0;\n      S.mi = S.moves.length - 1;\n      S.ms = m.p.len;\n      makeDew(S);\n    } else if (m.t >= 0) S.threads[m.t].shown = S.ms;\n    along(S.moves[S.mi].p, S.ms, pos);\n    for (const mo of S.moor) if (S.threads[mo.f].shown >= mo.s) S.threads[mo.t].shown = min(S.threads[mo.t].p.len, S.threads[mo.t].shown + 2 * LAY * sp);\n  } else if (S.phase === \"dew\") {\n    (pos[0] = S.hub[0]), (pos[1] = S.hub[1] + 1), (pos[2] = PI / 2);\n    if (S.clock >= DEWT) startTear(S);\n  } else if (S.phase === \"tear\") {\n    if (S.clock >= TEAR) {\n      newJitter(S);\n      plan(S, n);\n      S.phase = \"enter\";\n      S.clock = 0;\n      S.fly = null;\n    }\n  } else if (S.phase === \"enter\") {\n    const u = cl(S.clock / ENTER, 0, 1);\n    moved = (sp * 12) / ENTER;\n    (pos[0] = mix(-8, S.BL[0] + 1.5, u)), (pos[1] = S.BL[1] + 1), (pos[2] = 0);\n    if (u >= 1) (S.phase = \"float\"), (S.clock = 0);\n  }\n  // The temporary spiral is taken up as the sticky one passes over it.\n  const st = S.threads[S.sticky];\n  S.rCut = 1e9;\n  if (st.shown > 0) {\n    const { cum, r } = st.p;\n    let i = 0;\n    while (i \u003c cum.length - 1 && cum[i + 1] \u003c= st.shown) i++;\n    S.rCut = st.shown >= st.p.len ? 0 : r[i] - 0.5 * GAP;\n  }\n  // Heading eases round to the way the spider is going; the legs step with\n  // the distance it covers.\n  let dh = ((pos[2] - S.heading + 3 * PI) % TAU) - PI;\n  S.heading += dh * min(1, d * 14);\n  S.gait += moved * 0.9;\n}\n\nfunction makeDew(S) {\n  const p = S.threads[S.sticky].p, out = [0, 0, 0];\n  S.dew = [];\n  for (let s = rnd(1, 4); s \u003c p.len; s += rnd(3, 7)) {\n    along(p, s, out);\n    S.dew.push({ x: out[0], y: out[1], ph: rnd(0, TAU), w: rnd(1.2, 3.2), on: rnd(0, 6) });\n  }\n}\n\n// --- drawing ---\n\nfunction plot(buf, x, y, c) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || c \u003c= 0) return;\n  const o = y * W + x;\n  if (c > buf[o]) buf[o] = c;\n}\n\n// Xiaolin Wu's antialiased line, one LED wide, keeping the most at each LED.\nfunction wu(buf, x0, y0, x1, y1, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  if (steep) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x0 > x1) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const dx = x1 - x0, g = dx \u003c 1e-9 ? 0 : (y1 - y0) / dx;\n  const xs = round(x0), xe = round(x1);\n  let yy = y0 + g * (xs - x0);\n  for (let x = xs; x \u003c= xe; x++, yy += g) {\n    const yi = floor(yy), f = yy - yi;\n    if (steep) plot(buf, yi, x, (1 - f) * a), plot(buf, yi + 1, x, f * a);\n    else plot(buf, x, yi, (1 - f) * a), plot(buf, x, yi + 1, f * a);\n  }\n}\n\nfunction silk(S) {\n  const h = (S.col - floor(S.col)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  return [0, 1, 2].map((c) => mix(SILK[i][c], SILK[j][c], s));\n}\n\n// The spider: abdomen behind, head in front, four legs a side that step as\n// it walks. Heading hd points the way the head faces.\nfunction drawSpider(S, x, y, hd) {\n  const { rgb, legs } = S, fx = cos(hd), fy = sin(hd), sx = -fy, sy = fx;\n  const x0 = max(0, floor(x - 9)), x1 = min(W - 1, floor(x + 9)), y0 = max(0, floor(y - 9)), y1 = min(H - 1, floor(y + 9));\n  for (let yy = y0; yy \u003c= y1; yy++) legs.fill(0, yy * W + x0, yy * W + x1 + 1);\n  const hx = x + 1.3 * fx, hy = y + 1.3 * fy;\n  const base = [0.55, 1.15, 1.95, 2.55];\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let k = 0; k \u003c 4; k++) {\n      const a = base[k] + 0.22 * sin(S.gait + k * 1.7 + (side > 0 ? PI : 0));\n      const ca = cos(a), sa = side * sin(a), cb = 2.6 * cos(a * 0.9) + (k \u003c 2 ? 0.8 : -0.8), sb = 2.6 * side * sin(a * 0.9);\n      const rx = hx - 0.3 * k * fx, ry = hy - 0.3 * k * fy;\n      const kx = rx + (ca * fx + sa * sx) * 3, ky = ry + (ca * fy + sa * sy) * 3, lx = kx + cb * fx + sb * sx, ly = ky + cb * fy + sb * sy;\n      wu(legs, rx, ry, kx, ky, 1);\n      wu(legs, kx, ky, lx, ly, 0.9);\n    }\n  for (let yy = y0; yy \u003c= y1; yy++)\n    for (let xx = x0; xx \u003c= x1; xx++) {\n      const o = yy * W + xx, a = legs[o];\n      if (a > 0.08) for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] = mix(rgb[o * 3 + c], LEG[c], min(1, a * 1.3));\n    }\n  // Abdomen with the orange cross, head orange.\n  const blob = (cx, cy, ra, rb, cross) => {\n    for (let yy = max(0, floor(cy - 4)); yy \u003c= min(H - 1, floor(cy + 4)); yy++)\n      for (let xx = max(0, floor(cx - 4)); xx \u003c= min(W - 1, floor(cx + 4)); xx++) {\n        const px = xx - cx, py = yy - cy, u = px * fx + py * fy, v = px * sx + py * sy;\n        const q = sqrt((u / ra) ** 2 + (v / rb) ** 2), a = cl((1 - q) * min(ra, rb) + 0.6, 0, 1);\n        if (a \u003c= 0) continue;\n        const o = (yy * W + xx) * 3, mark = cross === 2 || (cross === 1 && q \u003c 0.75 && (abs(v) \u003c 0.6 || abs(u + 0.3) \u003c 0.6));\n        const col = mark ? MARK : BODY, sh = 1 - 0.3 * cl(q, 0, 1);\n        for (let c = 0; c \u003c 3; c++) rgb[o + c] = mix(rgb[o + c], col[c] * sh, a);\n      }\n  };\n  blob(x - 1.9 * fx, y - 1.9 * fy, 2.7, 2.2, 1);\n  blob(hx, hy, 1.4, 1.2, 2);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.threads) return;\n  const { T, rgb, row } = S;\n  T.fill(0);\n  rgb.fill(0);\n  const tear = S.phase === \"tear\", dew = S.phase === \"dew\" ? cl(S.clock / 3, 0, 1) : 0;\n  if (tear) {\n    for (const f of S.frags) {\n      const [ox, oy, an, left] = blown(S, f, f.cx, f.cy), c = cos(an), s = sin(an);\n      const cx = f.cx + ox, cy = f.cy + oy, hx = f.hx * c - f.hy * s, hy = f.hx * s + f.hy * c;\n      if (left > 0.02) wu(T, cx - hx, cy - hy, cx + hx, cy + hy, f.a * left);\n    }\n  } else if (S.phase !== \"enter\") {\n    for (let ti = 0; ti \u003c S.threads.length; ti++) {\n      const th = S.threads[ti];\n      if (th.shown \u003c= 0) continue;\n      if (ti === S.bridge && S.phase === \"float\") continue;\n      // Silk just laid shines, fading over the 60 LEDs behind the spider.\n      const { xs, ys, r, cum } = th.p, temp = ti === S.temp, fresh = S.phase === \"build\" && S.moves[S.mi].t === ti;\n      let [ax, ay] = sway(S, xs[0], ys[0]);\n      for (let i = 1; i \u003c xs.length; i++) {\n        if (cum[i - 1] >= th.shown) break;\n        let bx = xs[i], by = ys[i];\n        if (cum[i] > th.shown) {\n          const f = (th.shown - cum[i - 1]) / (cum[i] - cum[i - 1]);\n          bx = mix(xs[i - 1], xs[i], f);\n          by = mix(ys[i - 1], ys[i], f);\n        }\n        const [px, py] = sway(S, bx, by);\n        const glow = fresh ? 1 + 0.9 * cl(1 - (th.shown - cum[i]) / 60, 0, 1) : 1;\n        if (!temp || r[i] \u003c= S.rCut) wu(T, ax, ay, px, py, th.a * glow);\n        ax = px;\n        ay = py;\n      }\n    }\n    if (S.phase === \"float\") {\n      // The bridge line drifting out on the breeze from the left anchor, its\n      // free end fluttering, until it snags on the far side.\n      const u = cl(S.clock / FLOAT, 0, 1), e = u * u * (3 - 2 * u), A = 1.5 + 5 * S.wind;\n      const ex = mix(S.BL[0], S.BR[0], e), ey = mix(S.BL[1], S.BR[1], e) + A * sin(S.rt * 5) * (1 - e) + 4 * (1 - e) * e;\n      let px = S.BL[0], py = S.BL[1];\n      for (let k = 1; k \u003c= 16; k++) {\n        const t = k / 16, qx = mix(S.BL[0], ex, t), qy = mix(S.BL[1], ey, t) + (6 * (1 - e) + 1) * sin(PI * t) * (0.7 + 0.3 * sin(S.rt * 3 + t * 4));\n        wu(T, px, py, qx, qy, 0.85);\n        (px = qx), (py = qy);\n      }\n    }\n  }\n  // Silk lit from below: brighter and warmer toward the bottom row. When\n  // the web is done a band of light climbs it, catching the dew.\n  const sk = silk(S), band = 135 - ((S.clock * 20) % 180);\n  for (let y = 0; y \u003c H; y++) {\n    const v = y / 127, lit = 0.42 + 0.58 * v ** 1.2, warm = 0.3 * v * v;\n    const sh = 1 + 0.8 * dew * exp(-(((y - band) / 9) ** 2));\n    row[y * 3] = mix(sk[0], 1, warm) * lit * sh;\n    row[y * 3 + 1] = mix(sk[1], 0.72, warm) * lit * sh;\n    row[y * 3 + 2] = mix(sk[2], 0.42, warm) * lit * sh;\n  }\n  for (let o = 0; o \u003c N; o++) {\n    const t = T[o];\n    if (t \u003c= 0) continue;\n    const y3 = floor(o / W) * 3;\n    rgb[o * 3] = row[y3] * t;\n    rgb[o * 3 + 1] = row[y3 + 1] * t;\n    rgb[o * 3 + 2] = row[y3 + 2] * t;\n  }\n  // Dew: orange beads along the sticky spiral that gather over the first\n  // three seconds, each glinting now and then and all flaring pale gold as\n  // the band of light climbs past.\n  if (dew > 0)\n    for (const dd of S.dew) {\n      const [x, y] = sway(S, dd.x, dd.y), xi = round(x), yi = round(y);\n      if (xi \u003c 0 || xi >= W || yi \u003c 0 || yi >= H) continue;\n      const on = cl((S.clock - dd.on) / 1.5, 0, 1);\n      if (on \u003c= 0) continue;\n      const tw = (0.5 + 0.5 * sin(S.rt * dd.w + dd.ph)) ** 8, b = min(1, max(tw, exp(-(((y - band) / 7) ** 2))));\n      const v = on * (0.62 + 0.38 * b), o = yi * W + xi;\n      for (let c = 0; c \u003c 3; c++) rgb[o * 3 + c] = mix(DEW[c], GLINT[c], b * b) * v;\n      if (b > 0.4)\n        for (const q of [o - 1, o + 1, o - W, o + W])\n          if (q >= 0 && q \u003c N && abs((q % W) - xi) \u003c= 1) for (let c = 0; c \u003c 3; c++) rgb[q * 3 + c] = max(rgb[q * 3 + c], DEW[c] * on * (b - 0.4));\n    }\n  if (tear && S.dewOn)\n    for (const dd of S.dew) {\n      const [ox, oy, , left] = blown(S, dd, dd.x, dd.y), xi = round(dd.x + ox), yi = round(dd.y + oy);\n      if (left > 0.05 && xi >= 0 && xi \u003c W && yi >= 0 && yi \u003c H) for (let c = 0; c \u003c 3; c++) rgb[(yi * W + xi) * 3 + c] = DEW[c] * left;\n    }\n  if (!tear) drawSpider(S, ...sway(S, S.pos[0], S.pos[1]), S.heading);\n  else if (S.fly) {\n    const f = S.fly, [ox, oy, an] = blown(S, f, f.x, f.y);\n    drawSpider(S, f.x + ox, f.y + oy, S.heading + an);\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","runge-phenomenon":"// ===== Patternflow pattern =====\n// Title:   Runge Phenomenon\n// Family:  wave\n// Idea:    The bump 1/(1 + 25x²) stands up the panel with its interpolation nodes as beads on it, and as equally spaced nodes multiply from 3 to 21 the polynomial through them throws pink and gold lobes from edge to edge at the top and bottom, until the beads slide to Chebyshev's places and the curve lies down on the bump, while a violet glow behind shows where the nodes leave room for error.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Runge's phenomenon (Carl Runge, 1901), with Chebyshev nodes, pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Nodes=21..41, Chebyshev=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the bump is azure, the lobes where the polynomial overshoots it pink and where it falls short gold, the curve white and the beads pale gold; at 0.25 the bump is violet with yellow and green lobes. The dim bump never takes red, orange or yellow, which read maroon, brown and olive: from 0.35 to 0.53 it is crimson and from 0.53 to 0.72 green, while the lobes keep turning.\n// Knob 2: Speed. At 2 one round takes 17.5 seconds: 7 to climb from 3 nodes to the most, 1.2 held, 3 sliding to Chebyshev's nodes, 1.3 held, 3.5 back down to 3 and 1.5 sliding home. At 0.2 a round takes 175 seconds, at 3 about 11.7.\n// Knob 3: Nodes, the most the climb reaches, odd counts from 21 to 41. At 21 the worst error is 59.8 where the bump is 1 tall, at 31 it is 2,388 and at 41 about 105,000. The lobes that run off the panel's edge reach in 11 rows from each end at 21 nodes and 14 at 41, as thinner bars, and the climb goes 2.1 times as fast.\n// Knob 4: Chebyshev. Where the nodes sit while they climb, from equally spaced to Chebyshev's. Up to 0.06 equally spaced exactly; at 0.5 nearly halfway, the worst error 1.6 at 21 nodes and 44 at 41; at 0.75 about 0.15 at any count; at 1 Chebyshev's all along, the curve never more than 0.6 off the bump (at 3 nodes) and 0.015 at 21, so the lobes never come and the beads and the glow do the moving.\n\nconst W = 64, H = 128;\nconst { floor, min, max, abs, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Runge's function: 1 in the middle, 1/26 at the ends.\nconst A = 25;\nconst runge = (x) => 1 / (1 + A * x * x);\n\n// The interval stands up the panel: x = -1 at the centre of row 2, x = 1 at\n// the centre of row 125, so the end beads fit.\nconst YA = 2.5, YB = 125.5;\nconst toX = (py) => -1 + (2 * (py - YA)) / (YB - YA);\nconst toY = (x) => YA + ((x + 1) * (YB - YA)) / 2;\n// A value v sits at column C0 + SC v: the bump's foot at column 16.5, its top\n// at 52.5. Past -0.4 and 1.15 the scale squeezes into the last LEDs, so a\n// lobe of 2 and a lobe of 60 both reach the edge and still differ there.\nconst C0 = 16.5, SC = 36, VL = -0.4, VH = 1.15;\nfunction col(v) {\n  if (v > VH) return C0 + SC * VH + 5.6 * (1 - exp(-(v - VH) / 0.7));\n  if (v \u003c VL) return C0 + SC * VL - 2.8 * (1 - exp((v - VL) / 0.7));\n  return C0 + SC * v;\n}\n\n// The round, in units that pass at one a second at Speed 2.\nconst T_CLIMB = 7, T_WILD = 1.2, T_SETTLE = 3, T_CALM = 1.3, T_DOWN = 3.5, T_HOME = 1.5;\nconst T_ROUND = T_CLIMB + T_WILD + T_SETTLE + T_CALM + T_DOWN + T_HOME;\nconst NMAX = 41, SUB = 4;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, top: 21, base: 0, tau: 0,\n    // Up to three node sets in play: the one sliding, or the old set at its\n    // new places and the new set it is blending into.\n    sets: [0, 1].map(() => ({ X: new Float64Array(NMAX + 2), w: new Float64Array(NMAX + 2), F: new Float64Array(NMAX + 2), n: 0, k: 0 })),\n    nsets: 1,\n    dots: new Float64Array((NMAX + 2) * 3), ndots: 0,\n    pc: new Float64Array(SUB), fc: new Float64Array(SUB), om: new Float64Array(H),\n    col: new Float32Array(8 * 3), colHue: NaN,\n    tmpA: new Float64Array(NMAX + 2), tmpB: new Float64Array(NMAX + 2),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 21, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  // Odd counts only: every set then has a node at 0 and the picture is the\n  // same at the top and the bottom.\n  S.top = 2 * round((cl(k[2], 21, 41) - 1) / 2) + 1;\n  // Up to 0.06 the nodes are equally spaced exactly.\n  S.base = max(0, cl(k[3], 0, 1) - 0.06) / 0.94;\n  S.tau = (S.tau + d * S.speed * 0.5) % T_ROUND;\n}\n\n// n nodes, sorted, a fraction c of the way from equally spaced to\n// Chebyshev's, cos((2k + 1) pi / 2n).\nfunction nodes(n, c, out) {\n  for (let k = 0; k \u003c n; k++) {\n    const e = -1 + (2 * k) / (n - 1), ch = -cos(((2 * k + 1) * PI) / (2 * n));\n    out[k] = e + (ch - e) * c;\n  }\n}\n\n// Barycentric weights w_j = 1 / prod (x_j - x_k), scaled to a largest of 1.\n// With them p(x) = sum w_j f_j / (x - x_j) / sum w_j / (x - x_j), the second\n// barycentric form (Berrut and Trefethen, 2004), stable for any nodes.\nfunction prepare(set, X, n, weight) {\n  let big = 0;\n  for (let j = 0; j \u003c n; j++) {\n    let p = 1;\n    for (let k = 0; k \u003c n; k++) if (k !== j) p *= X[j] - X[k];\n    set.X[j] = X[j];\n    set.F[j] = runge(X[j]);\n    set.w[j] = 1 / p;\n    big = max(big, abs(set.w[j]));\n  }\n  for (let j = 0; j \u003c n; j++) set.w[j] /= big;\n  set.n = n;\n  set.k = weight;\n}\n\nfunction bary(set, x) {\n  const { X, w, F, n } = set;\n  let num = 0, den = 0;\n  for (let j = 0; j \u003c n; j++) {\n    const d = x - X[j];\n    if (d === 0) return F[j];\n    const t = w[j] / d;\n    num += t * F[j];\n    den += t;\n  }\n  return num / den;\n}\n\n// Where the round is: the node level m (n = 2m + 1) with the step's progress\n// u, and how far the nodes are toward Chebyshev's.\nfunction stage(S) {\n  const M = (S.top - 1) / 2, b = S.base;\n  let t = S.tau;\n  if (t \u003c T_CLIMB) return [1 + (M - 1) * (t / T_CLIMB), b];\n  t -= T_CLIMB;\n  if (t \u003c T_WILD) return [M, b];\n  t -= T_WILD;\n  if (t \u003c T_SETTLE) return [M, mix(b, 1, sm(t / T_SETTLE))];\n  t -= T_SETTLE;\n  if (t \u003c T_CALM) return [M, 1];\n  t -= T_CALM;\n  if (t \u003c T_DOWN) return [M - (M - 1) * (t / T_DOWN), 1];\n  t -= T_DOWN;\n  return [1, mix(1, b, sm(t / T_HOME))];\n}\n\n// Build the node sets and the beads for this frame. Going from n to n + 2\n// nodes takes two halves: first the n nodes spread to their places in the\n// new set, the curve through them all the way; then the two new nodes beside\n// the middle one grow in and the curve blends to the one through all n + 2.\nfunction build(S) {\n  const [lv, c] = stage(S);\n  let m = floor(lv), u = lv - m;\n  if (m >= (S.top - 1) / 2) (m = (S.top - 1) / 2), (u = 0);\n  const n = 2 * m + 1, OLD = S.tmpA, NEW = S.tmpB;\n  nodes(n, c, OLD);\n  if (u === 0) {\n    prepare(S.sets[0], OLD, n, 1);\n    S.nsets = 1;\n    for (let k = 0; k \u003c n; k++) setDot(S, k, OLD[k], 1);\n    S.ndots = n;\n    return;\n  }\n  nodes(n + 2, c, NEW);\n  // Old node k goes to new k below the middle, the middle to the middle, and\n  // the rest two places on: new m and m + 2 are the ones born.\n  const to = (k) => (k \u003c m ? k : k === m ? m + 1 : k + 2);\n  if (u \u003c 0.5) {\n    const e = sm(u / 0.5);\n    for (let k = 0; k \u003c n; k++) OLD[k] = mix(OLD[k], NEW[to(k)], e);\n    prepare(S.sets[0], OLD, n, 1);\n    S.nsets = 1;\n    for (let k = 0; k \u003c n; k++) setDot(S, k, OLD[k], 1);\n    S.ndots = n;\n    return;\n  }\n  const e = sm((u - 0.5) / 0.5);\n  for (let k = 0; k \u003c n; k++) OLD[k] = NEW[to(k)];\n  prepare(S.sets[0], OLD, n, 1 - e);\n  prepare(S.sets[1], NEW, n + 2, e);\n  S.nsets = 2;\n  for (let k = 0; k \u003c n + 2; k++) setDot(S, k, NEW[k], k === m || k === m + 2 ? e : 1);\n  S.ndots = n + 2;\n}\n\nfunction setDot(S, k, x, size) {\n  S.dots[3 * k] = col(runge(x));\n  S.dots[3 * k + 1] = toY(x);\n  S.dots[3 * k + 2] = size;\n}\n\n// The bump's hue, which skips red, orange and yellow: dim, those read\n// maroon, brown and olive on the panel. A hue from -0.07 to 0.3 takes the\n// nearer end, crimson-pink or green, so the bump jumps between the two.\nfunction bumpHue(h) {\n  let f = h - floor(h);\n  if (f >= 0.93) f -= 1;\n  if (f >= 0.3) return f;\n  return f \u003c 0.11 ? 0.93 : 0.3;\n}\n\nfunction palette(S) {\n  const c = S.col, h = S.hue, hb = bumpHue(h + 0.58);\n  // 0 the bump, 1 its edge, 2 overshoot lobes, 3 short lobes, 4 the curve,\n  // 5 the beads, 6 the axis, 7 the glow of the node polynomial.\n  hsv(hb, 0.85, 0.3, c, 0);\n  hsv(hb, 0.55, 0.8, c, 3);\n  hsv(h + 0.9, 0.8, 1, c, 6);\n  hsv(h + 0.13, 0.85, 1, c, 9);\n  hsv(hb, 0.12, 1, c, 12);\n  hsv(h + 0.13, 0.35, 1, c, 15);\n  hsv(hb, 0.5, 0.16, c, 18);\n  hsv(0.72, 0.6, 0.24, c, 21);\n  S.colHue = h;\n}\n\n// The node polynomial (x - x_1) ... (x - x_n), the factor the error carries\n// whatever the function: log10 of its size, the largest in each row, blended\n// like the curve. Equally spaced, it is 54,000 times bigger at the ends than\n// in the middle at 21 nodes; Chebyshev's, the same in every gap.\nfunction omega(S) {\n  const { sets, nsets, om } = S;\n  let top = -1e9;\n  for (let y = 0; y \u003c H; y++) {\n    let L = 0;\n    for (let s = 0; s \u003c nsets; s++) {\n      const { X, n, k } = sets[s];\n      if (k \u003c= 0) continue;\n      let best = -1e9;\n      for (let i = 0; i \u003c SUB; i++) {\n        const x = cl(toX(y + (i + 0.5) / SUB), -1, 1);\n        let p = 1;\n        for (let j = 0; j \u003c n; j++) p *= x - X[j];\n        best = max(best, Math.log10(abs(p) + 1e-300));\n      }\n      L += k * best;\n    }\n    om[y] = L;\n    top = max(top, L);\n  }\n  for (let y = 0; y \u003c H; y++) om[y] = cl(1 + (om[y] - top) / 5, 0, 1) ** 1.5;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  build(S);\n  omega(S);\n  const { sets, nsets, pc, fc, dots, ndots, om } = S, c = S.col;\n  const axis = floor(C0);\n  for (let y = 0; y \u003c H; y++) {\n    // The curve and the bump at four heights inside the row, so a lobe\n    // that crosses the panel in one row is drawn whole.\n    let pLo = 1e9, pHi = -1e9, bLo = 1e9, bHi = -1e9;\n    const inside = y + 1 > YA - 0.5 && y \u003c YB + 0.5;\n    if (inside)\n      for (let i = 0; i \u003c SUB; i++) {\n        const x = cl(toX(y + (i + 0.5) / SUB), -1, 1);\n        let p = 0;\n        for (let s = 0; s \u003c nsets; s++) if (sets[s].k > 0) p += sets[s].k * bary(sets[s], x);\n        pc[i] = col(p);\n        fc[i] = col(runge(x));\n        pLo = min(pLo, pc[i]);\n        pHi = max(pHi, pc[i]);\n        bLo = min(bLo, pc[i], fc[i]);\n        bHi = max(bHi, pc[i], fc[i]);\n      }\n    const fRow = col(runge(cl(toX(y + 0.5), -1, 1)));\n    for (let x = 0; x \u003c W; x++) {\n      const X = x + 0.5;\n      let o = -1;\n      if (inside) {\n        if (X >= pLo - 0.9 && X \u003c= pHi + 0.9) o = 12;\n        else if (X >= bLo && X \u003c= bHi && abs(X - fRow) > 0.6) o = X > fRow ? 6 : 9;\n        else if (abs(X - fRow) \u003c 0.75) o = 3;\n        else if (X > C0 && X \u003c fRow) o = 0;\n      }\n      if (o \u003c 0 && x === axis) o = 18;\n      if (o \u003c 0) {\n        // Behind everything, the node polynomial's glow.\n        const g = inside ? om[y] : 0;\n        display.setPixel(x, y, round(255 * c[21] * g), round(255 * c[22] * g), round(255 * c[23] * g));\n      }\n      else display.setPixel(x, y, round(255 * c[o]), round(255 * c[o + 1]), round(255 * c[o + 2]));\n    }\n  }\n  // The beads, each in a dark ring so the curve threads through it.\n  for (let k = 0; k \u003c ndots; k++) {\n    const bx = dots[3 * k], by = dots[3 * k + 1], sz = dots[3 * k + 2];\n    if (sz \u003c= 0.02) continue;\n    const r = 1.75 * sz, ring = r + 0.9;\n    for (let yy = max(0, floor(by - ring)); yy \u003c= min(H - 1, floor(by + ring)); yy++)\n      for (let xx = max(0, floor(bx - ring)); xx \u003c= min(W - 1, floor(bx + ring)); xx++) {\n        const dx = xx + 0.5 - bx, dy = yy + 0.5 - by, d = Math.sqrt(dx * dx + dy * dy);\n        if (d \u003c r) display.setPixel(xx, yy, round(255 * c[15]), round(255 * c[16]), round(255 * c[17]));\n        else if (d \u003c ring) display.setPixel(xx, yy, 0, 0, 0);\n      }\n  }\n}\n","scarecrow-crows":"// ===== Patternflow pattern =====\n// Title:   Scarecrow Crows\n// Family:  halloween\n// Idea:    A black scarecrow with a straw hat and a stitched sack face sways on its pole against a big low moon in a dusk sky, crows fly in and land on its arms and hat, hop, turn, stretch and caw, and when its head twitches round they all burst off flapping, circle above it and come back one by one, the ones that find it full pecking along the glowing horizon.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 43; after the scarecrows and crows of Halloween fields\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Crows=8..20, Nerves=0..1\n//\n// Knob 1: Colour. Three skies round the knob: at 0 a pale gold moon in a sky going from violet at the top through rose to orange at the horizon; at 0.33 a toxic green moon in a purple sky over a green glow; at 0.67 a cold white moon in a blue night. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 the first twitch comes at 3.4 seconds, the crows climb for 0.7 of a second, circle 2 to 6 seconds and take 1.5 seconds to land (0.9 to 2.8); at 0.2 everything is ten times slower, at 3 one and a half times faster.\n// Knob 3: Crows, 8 to 20. There are seven places on the scarecrow, two on each arm, the crown of the hat and the two ends of its brim, and six on the ground along the horizon; at 8 one crow is left for the ground, at 20 six peck there and seven keep circling. At the start 0.45 of them are already perched, 4 of 8 and 9 of 20.\n// Knob 4: Nerves. How jumpy the scarecrow is. At 0.06 the head twitches round every 11.5 seconds on average and a crow spends 41% of its time perched; at 1 every 3 seconds, and the crows hardly ever get to land. The twitch turns the face 0.67 of the way to its side at 0.06 and all the way at 1, and from 0.3 the head keeps glancing about between twitches.\n// Buttons: K1 tap twitches the head at once and every perched crow bursts off.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, sqrt, sin, cos, round, atan2, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst rnd = (a, b) => a + (b - a) * Math.random();\n\n// The horizon, the moon, the scarecrow's neck, and the row its pole sways\n// about, in the ground below the horizon.\nconst HZ = 101, MX = 32, MY = 61, MR = 26, NX = 32, NY = 50, BASE = 118;\n// Crows are drawn this many times their unit size: 14 LEDs beak to tail\n// sitting, and a little bigger in the air, where the wings spread.\nconst K = 1.2, KF = 1.45;\n// Skies, cycled by K1: sky at the top, in the middle, low down and at the\n// horizon; the moon, its seas, and the dim field.\nconst PAL = [\n  [[104, 40, 168], [196, 62, 142], [246, 100, 58], [255, 182, 74], [255, 206, 104], [236, 168, 72], [24, 8, 30]],\n  [[70, 30, 140], [128, 46, 172], [150, 70, 176], [130, 236, 92], [176, 255, 96], [134, 218, 64], [10, 22, 14]],\n  [[40, 52, 142], [62, 92, 192], [106, 128, 222], [196, 172, 244], [240, 240, 222], [202, 204, 196], [10, 12, 32]],\n];\n// Places to land: two on each arm, the crown of the hat and the brim's ends.\n// Feet at (x, y); arm places dip with their arm, hat places turn with the\n// head.\nconst SLOTS = [\n  { x: 6.5, y: 54.4, arm: -1 }, { x: 18, y: 54.4, arm: -1 },\n  { x: 46, y: 54.4, arm: 1 }, { x: 57.5, y: 54.4, arm: 1 },\n  { x: 32, y: 21.8, arm: 0 }, { x: 18.6, y: 33.3, arm: 0, out: -1 }, { x: 45.4, y: 33.3, arm: 0, out: 1 },\n  // And six on the ground along the horizon, against its glow, for the\n  // crows that find the scarecrow full; they peck.\n  ...[5, 14, 23, 42, 51, 59].map((x) => ({ x, y: HZ, arm: 0, ground: true })),\n];\n\nexport function setup(params) {\n  params.s = {\n    t: 0, hue: 0, speed: 2, count: 8, nerves: 0.06,\n    // The head: how far it is turned (-1 left, 1 right), where it is going,\n    // and how long it holds there; the shudder of a twitch; the sway.\n    turn: 0, turnTo: 0, hold: 0, glance: 2, jolt: 0, sway: 0, next: -1, started: false,\n    // Each arm's dip when a crow lands on it: a damped spring.\n    dip: [0, 0], dipV: [0, 0],\n    crows: [], bg: new Uint8Array(N * 3), bgHue: NaN, m: new Uint8Array(N),\n  };\n}\n\nfunction newCrow(i) {\n  return {\n    i, st: \"circle\", x: 32, y: 30, vx: 0, vy: 0, face: 1, slot: -1, flap: Math.random() * TAU,\n    beak: 0, cawT: 0, hop: 0, hopT: -1, flip: false, wing: 0, stretchT: 0, peck: 0, peckT: 0, act: rnd(0.4, 1.5),\n    circ: 0, ang: Math.random() * TAU, dir: Math.random() \u003c 0.5 ? -1 : 1, rx: rnd(16, 31), ry: rnd(6, 13), cy: rnd(12, 22), wait: rnd(2, 6), delay: 0,\n  };\n}\n\n// The opening: 0.45 of the crows already perched, 4 of 8, the rest in the\n// air coming down one by one.\nfunction start(S) {\n  S.crows = [];\n  for (let i = 0; i \u003c 20; i++) S.crows.push(newCrow(i));\n  const first = [1, 2, 4, 6, 0, 3, 5, 8, 11, 9];\n  const n0 = round(S.count * 0.45);\n  for (let i = 0; i \u003c n0; i++) perch(S, S.crows[i], first[i], i & 1 ? -1 : 1, false);\n  for (let i = n0; i \u003c 20; i++) {\n    const c = S.crows[i];\n    c.ang = (i * 2.3) % TAU;\n    c.x = NX + c.rx * cos(c.ang);\n    c.y = c.cy + c.ry * sin(c.ang);\n    c.wait = 0.3 + (i - n0) * 0.8;\n  }\n  S.started = true;\n}\n\nfunction perch(S, c, slot, face, bounce) {\n  c.st = \"perch\";\n  c.slot = slot;\n  // On a brim end a crow faces out, or it is lost against the crown.\n  c.face = SLOTS[slot].out || face;\n  c.vx = c.vy = 0;\n  c.act = rnd(0.3, 1.2);\n  const arm = SLOTS[slot].arm;\n  if (bounce && arm) S.dipV[arm > 0 ? 1 : 0] += 9;\n}\n\n// Every point of the scarecrow goes through here: the sway leans it about\n// row BASE, and a twitch shudders it.\nfunction body(S, x, y, out) {\n  out[0] = x + S.sway * (BASE - y);\n  out[1] = y + S.jolt;\n}\n\n// A point of an arm, dipping more the further it is from the shoulder.\nfunction armPoint(S, x, y, out) {\n  const side = x \u003c NX ? 0 : 1, reach = cl((abs(x - NX) - 8) / 22, 0, 1.2);\n  body(S, x, y + S.dip[side] * reach, out);\n}\n\n// A point of the head or hat, tilted and shifted with the turn.\nfunction headPoint(S, x, y, out) {\n  const a = 0.15 * S.turn, c = cos(a), s = sin(a), dx = x - NX, dy = y - NY;\n  body(S, NX + 1.4 * S.turn + dx * c - dy * s, NY + dx * s + dy * c, out);\n}\n\nfunction slotPos(S, k, out) {\n  const s = SLOTS[k];\n  if (s.ground) (out[0] = s.x), (out[1] = s.y);\n  else if (s.arm) armPoint(S, s.x, s.y, out);\n  else headPoint(S, s.x, s.y, out);\n}\n\nfunction twitch(S) {\n  S.turnTo = (Math.random() \u003c 0.5 ? -1 : 1) * (0.65 + 0.35 * S.nerves);\n  S.hold = rnd(0.7, 1.2);\n  S.jolt = -1.6;\n  for (const c of S.crows) {\n    if (c.i >= S.count) continue;\n    if (c.st === \"perch\" || c.st === \"land\") {\n      c.delay = c.st === \"land\" ? 0 : rnd(0, 0.25);\n      c.st = \"flee\";\n      c.slot = -1;\n      c.circ = 0;\n    }\n    // Back one by one: each circles 2 to 6 seconds before it tries to land.\n    c.wait = max(c.wait, rnd(2, 6));\n  }\n}\n\nconst P = [0, 0];\n\nfunction stepPerched(S, c, d) {\n  // On the scarecrow: now and then a hop, a turn, a stretch or a caw.\n  c.act -= d;\n  if (c.hopT >= 0) {\n    c.hopT += d;\n    const u = c.hopT / 0.4;\n    c.hop = 3.4 * 4 * u * (1 - u);\n    c.wing = sin(PI * cl(u, 0, 1)) * 0.9;\n    if (u > 0.5 && c.flip) (c.face = -c.face), (c.flip = false);\n    if (u >= 1) (c.hopT = -1), (c.hop = 0), (c.wing = 0);\n  }\n  if (c.stretchT > 0) {\n    c.stretchT -= d;\n    c.wing = sin(PI * cl(1 - c.stretchT / 0.8, 0, 1));\n    if (c.stretchT \u003c= 0) c.wing = 0;\n  }\n  if (c.cawT > 0) {\n    c.cawT -= d;\n    c.beak = sin(((0.9 - c.cawT) / 0.45) * PI) > 0.2 ? 1 : 0;\n    if (c.cawT \u003c= 0) c.beak = 0;\n  }\n  if (c.peckT > 0) {\n    // Two jabs at the ground in 0.7 of a second.\n    c.peckT -= d;\n    c.peck = max(0, sin(((0.7 - c.peckT) / 0.35) * PI));\n    if (c.peckT \u003c= 0) c.peck = 0;\n  }\n  if (c.act \u003c= 0 && c.hopT \u003c 0 && c.cawT \u003c= 0 && c.stretchT \u003c= 0 && c.peckT \u003c= 0) {\n    const r = Math.random();\n    const fixed = !!SLOTS[c.slot].out;\n    if (SLOTS[c.slot].ground && r \u003c 0.5) c.peckT = 0.7;\n    else if (r \u003c 0.35) (c.hopT = 0), (c.flip = !fixed && Math.random() \u003c 0.6);\n    else if (r \u003c 0.55 && !fixed) c.face = -c.face;\n    else if (r \u003c 0.75) c.stretchT = 0.8;\n    else c.cawT = 0.9;\n    c.act = rnd(0.4, 1.6);\n  }\n  slotPos(S, c.slot, P);\n  c.x = P[0];\n  c.y = P[1] - c.hop;\n}\n\nfunction stepCrow(S, c, d) {\n  c.flap += d * (c.st === \"flee\" ? 38 : 25);\n  if (c.st === \"perch\") return stepPerched(S, c, d);\n  if (c.st === \"flee\") {\n    // Burst off: up and away from the head, wings going hard.\n    if (c.delay > 0) {\n      c.delay -= d;\n      return;\n    }\n    if (c.circ === 0) {\n      const away = c.x \u003c NX ? -1 : 1;\n      c.vx = away * rnd(16, 30);\n      c.vy = -rnd(26, 40);\n      c.beak = c.hop = c.wing = c.peck = 0;\n      c.hopT = -1;\n      c.stretchT = c.cawT = c.peckT = 0;\n    }\n    c.circ += d;\n    c.vy += 22 * d;\n    c.x += c.vx * d;\n    c.y += c.vy * d;\n    c.face = c.vx >= 0 ? 1 : -1;\n    if (c.circ > 0.7) {\n      // Join its own ellipse where it is, going round the way it flies.\n      c.st = \"circle\";\n      c.ang = atan2((c.y - c.cy) / c.ry, (c.x - NX) / c.rx);\n      c.dir = -sin(c.ang) * c.vx >= 0 ? 1 : -1;\n    }\n    return;\n  }\n  if (c.st === \"circle\") {\n    // Round and round above the scarecrow, each on an ellipse of its own;\n    // when its time is up and a place is free, come in to land.\n    c.ang += d * c.dir * (24 / ((c.rx + c.ry) / 2));\n    steer(c, NX + c.rx * cos(c.ang), c.cy + c.ry * sin(c.ang), 34, d, 3);\n    c.wait -= d;\n    if (c.wait \u003c= 0) {\n      const k = freeSlot(S, c);\n      if (k >= 0) (c.st = \"land\"), (c.slot = k);\n      else c.wait = rnd(1, 3);\n    }\n    return;\n  }\n  // Landing: come in above the place, then drop onto it.\n  slotPos(S, c.slot, P);\n  const dx = P[0] - c.x, dy = P[1] - c.y, dist = sqrt(dx * dx + dy * dy);\n  steer(c, P[0], P[1] - (dist > 9 ? 6 : 0), min(30, 4 + dist * 2.6), d, 5);\n  if (dist \u003c 0.8) perch(S, c, c.slot, c.vx >= 0 ? 1 : -1, true);\n}\n\nfunction steer(c, tx, ty, speed, d, k) {\n  const dx = tx - c.x, dy = ty - c.y, L = sqrt(dx * dx + dy * dy) || 1;\n  const v = min(speed, L * 4), f = min(1, d * k);\n  c.vx += ((dx / L) * v - c.vx) * f;\n  c.vy += ((dy / L) * v - c.vy) * f;\n  c.x += c.vx * d;\n  c.y += c.vy * d;\n  if (abs(c.vx) > 3) c.face = c.vx > 0 ? 1 : -1;\n}\n\n// The nearest free place, so crows do not cross each other's paths.\nfunction freeSlot(S, me) {\n  let best = -1, bd = 1e9;\n  for (let k = 0; k \u003c SLOTS.length; k++) {\n    let taken = false;\n    for (const c of S.crows) if (c !== me && c.i \u003c S.count && c.slot === k) taken = true;\n    if (taken) continue;\n    slotPos(S, k, P);\n    const dd = (P[0] - me.x) ** 2 + (P[1] - me.y) ** 2;\n    if (dd \u003c bd) (bd = dd), (best = k);\n  }\n  return best;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 8, 0.06], d0 = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 8, 20);\n  S.nerves = cl(k[3], 0, 1);\n  if (!S.started) start(S);\n  const d = d0 * S.speed * 0.5;\n  S.t += d;\n  // Twitches come every 11.5 seconds on average at Nerves 0.06, every 3 at\n  // 1; the first at 0.3 of the interval, 3.4 seconds at the start knobs.\n  const T = mix(12, 3, S.nerves);\n  if (S.next \u003c 0) S.next = 0.3 * T;\n  const tap = !!(input.btnPressed && input.btnPressed[0]);\n  if (tap || S.t >= S.next) {\n    twitch(S);\n    S.next = S.t + T * rnd(0.7, 1.3);\n  }\n  // The head snaps to its side, holds, then comes slowly back; between\n  // twitches a nervous one glances about.\n  if (S.hold > 0) {\n    S.hold -= d;\n    if (S.hold \u003c= 0) S.turnTo = 0;\n  } else {\n    S.glance -= d;\n    if (S.glance \u003c= 0) {\n      S.turnTo = S.nerves > 0.3 ? (rnd(-1, 1) * 0.45 * (S.nerves - 0.3)) / 0.7 : 0;\n      S.glance = rnd(0.8, 2.5);\n    }\n  }\n  S.turn += (S.turnTo - S.turn) * min(1, d * (S.hold > 0 ? 30 : 2.2));\n  S.jolt *= exp(-d * 9);\n  // The wind leans the scarecrow up to 2 LEDs at the hat.\n  S.sway = 0.012 * sin(S.t * 0.8) + 0.007 * sin(S.t * 2.1 + 1);\n  for (let a = 0; a \u003c 2; a++) {\n    S.dipV[a] += (-60 * S.dip[a] - 5 * S.dipV[a]) * d;\n    S.dip[a] += S.dipV[a] * d;\n  }\n  for (const c of S.crows) {\n    if (c.i >= S.count) {\n      // A crow the knob takes away is gone, and its place is free.\n      c.slot = -1;\n      if (c.st !== \"circle\") c.st = \"circle\";\n      continue;\n    }\n    stepCrow(S, c, d);\n  }\n}\n\n// --- drawing: a sky, then one silhouette mask for the scarecrow and crows ---\n\nfunction inPoly(x, y, pts) {\n  let inside = false;\n  for (let i = 0, j = pts.length - 2; i \u003c pts.length; j = i, i += 2) {\n    const xi = pts[i], yi = pts[i + 1], xj = pts[j], yj = pts[j + 1];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;\n  }\n  return inside;\n}\n\nfunction fillPoly(m, pts, v) {\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let i = 0; i \u003c pts.length; i += 2) (x0 = min(x0, pts[i])), (x1 = max(x1, pts[i])), (y0 = min(y0, pts[i + 1])), (y1 = max(y1, pts[i + 1]));\n  for (let y = max(0, floor(y0)); y \u003c= min(H - 1, floor(y1)); y++)\n    for (let x = max(0, floor(x0)); x \u003c= min(W - 1, floor(x1)); x++) if (inPoly(x + 0.5, y + 0.5, pts)) m[y * W + x] = v;\n}\n\nfunction fillEllipse(m, cx, cy, rx, ry, rot, v) {\n  const c = cos(rot), s = sin(rot), R = max(rx, ry) + 1;\n  for (let y = max(0, floor(cy - R)); y \u003c= min(H - 1, floor(cy + R)); y++)\n    for (let x = max(0, floor(cx - R)); x \u003c= min(W - 1, floor(cx + R)); x++) {\n      const dx = x + 0.5 - cx, dy = y + 0.5 - cy, u = (dx * c + dy * s) / rx, w = (-dx * s + dy * c) / ry;\n      if (u * u + w * w \u003c= 1) m[y * W + x] = v;\n    }\n}\n\nfunction stroke(m, x0, y0, x1, y1, r, v) {\n  const dx = x1 - x0, dy = y1 - y0, ll = dx * dx + dy * dy || 1e-9;\n  for (let y = max(0, floor(min(y0, y1) - r)); y \u003c= min(H - 1, floor(max(y0, y1) + r)); y++)\n    for (let x = max(0, floor(min(x0, x1) - r)); x \u003c= min(W - 1, floor(max(x0, x1) + r)); x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = cl((px * dx + py * dy) / ll, 0, 1), ex = px - u * dx, ey = py - u * dy;\n      if (ex * ex + ey * ey \u003c= r * r) m[y * W + x] = v;\n    }\n}\n\nfunction setAt(m, x, y, v) {\n  x = floor(x);\n  y = floor(y);\n  if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) m[y * W + x] = v;\n}\n\n// A flat list of points [x0, y0, x1, y1, ...] moved through fn.\nfunction moved(S, fn, pts) {\n  const out = [];\n  for (let i = 0; i \u003c pts.length; i += 2) {\n    fn(S, pts[i], pts[i + 1], P);\n    out.push(P[0], P[1]);\n  }\n  return out;\n}\n\nfunction scarecrow(S, m) {\n  const t = S.t, A = [0, 0], B = [0, 0];\n  // Pole, shirt with a ragged hem, and the sleeves on the crossbar.\n  body(S, NX, 60, A);\n  body(S, NX, H + 4, B);\n  stroke(m, A[0], A[1], B[0], B[1], 1.4, 1);\n  fillPoly(m, moved(S, body, [24, 53, 40, 53, 42.5, 68, 44, 82, 42, 85.5, 40, 83, 37.5, 86, 35, 83.2, 32.5, 86.5, 30, 83.2, 27, 86, 24.5, 83, 22, 85.5, 20, 82, 21.5, 68]), 1);\n  fillPoly(m, moved(S, armPoint, [3.5, 54.6, 22, 54.6, 42, 54.6, 60.5, 54.6, 61.8, 60, 56, 59, 42, 59.6, 32, 60, 22, 59.6, 8, 59, 2.2, 60]), 1);\n  // Straw: out of the cuffs, the hem and the neck, trembling in the air.\n  const straw = (fn, x, y, a, L, n) => {\n    fn(S, x, y, A);\n    const w = a + 0.18 * sin(t * 4.1 + n * 1.7) + 0.08 * sin(t * 9.3 + n);\n    stroke(m, A[0], A[1], A[0] + L * cos(w), A[1] + L * sin(w), 0.5, 1);\n  };\n  for (let n = 0; n \u003c 4; n++) {\n    straw(armPoint, 3, 58, PI * (0.62 + 0.09 * n), 4.5 + (n & 1), n);\n    straw(armPoint, 61, 58, PI * (0.38 - 0.09 * n), 4.5 + (n & 1), n + 4);\n  }\n  for (let n = 0; n \u003c 6; n++) straw(body, 23 + n * 3.6, 85, PI * (0.5 + 0.06 * (n - 2.5)), 3 + (n % 3), n + 8);\n  for (let n = 0; n \u003c 3; n++) straw(headPoint, NX, 51.5, PI * (0.25 + 0.25 * n), 3.5, n + 14);\n  // Head: a sack, tied at the neck, under a straw hat; all of it turns.\n  headPoint(S, NX, 41.5, A);\n  fillEllipse(m, A[0], A[1], 7.6, 8.4, 0.15 * S.turn, 1);\n  headPoint(S, NX, 50.5, A);\n  fillEllipse(m, A[0], A[1], 3.4, 1.9, 0, 1);\n  fillPoly(m, moved(S, headPoint, [16.5, 34.5, 21, 31.6, 43, 31.6, 47.5, 34.5, 41, 34.2, 23, 34.2]), 1);\n  fillPoly(m, moved(S, headPoint, [24, 31.8, 24.8, 25.5, 27, 22.6, 32, 21.6, 37, 22.6, 39.2, 25.5, 40, 31.8]), 1);\n  for (let n = 0; n \u003c 3; n++) {\n    straw(headPoint, 17 + n * 1.3, 34.2, PI * (0.62 - 0.05 * n), 2.6, n + 17);\n    straw(headPoint, 47 - n * 1.3, 34.2, PI * (0.38 + 0.05 * n), 2.6, n + 20);\n  }\n  // The face is cut out, so the moon shows through: X-stitched eyes and a\n  // stitched mouth, sliding to the side the head turns to.\n  const tu = S.turn, fx = NX + 4.4 * tu, sp = 3.4 * (1 - 0.45 * abs(tu));\n  for (const e of [-1, 1]) {\n    headPoint(S, fx + e * sp, 39.5, A);\n    for (const [ox, oy] of [[0, 0], [-1, -1], [1, -1], [-1, 1], [1, 1]]) setAt(m, A[0] + ox, A[1] + oy, 0);\n  }\n  const half = 4.2 * (1 - 0.35 * abs(tu));\n  for (let u = -half; u \u003c= half + 0.01; u += 1) {\n    headPoint(S, fx + u, 45.5 - (abs(u) > half - 1.2 ? 0.8 : 0), A);\n    setAt(m, A[0], A[1], 0);\n    if (round(u + half) % 2 === 1) {\n      setAt(m, A[0], A[1] - 1, 0);\n      setAt(m, A[0], A[1] + 1, 0);\n    }\n  }\n}\n\n// Wings from a shoulder at (x, y): a near and a far one, root along the\n// back, tip out and up (a > 0) or down. pt maps body coordinates (u along,\n// v below) to the panel.\nfunction wings(m, pt, a, L) {\n  for (const [k, back, sh] of [[1, 0, 0], [0.8, -1.2, 0.35]]) {\n    const l = L * k, sa = sin(a + sh), ca = cos(a + sh);\n    fillPoly(m, [...pt(1.4 + back * 0.3, -0.6), ...pt(0.2 + back - 1.2 * ca, -0.6 - 0.6 * l * sa), ...pt(-1.6 + back - 2.2 * ca, -0.6 - l * sa), ...pt(-1.8 + back * 0.3, -0.6)], 1);\n  }\n}\n\n// A crow standing, feet at (fx, fy), facing f (1 right, -1 left), beak open\n// when b is 1, wings raised by w (0 folded, 1 stretched high), head down to\n// the ground by p (0 up, 1 pecking).\nfunction crowSitting(m, fx, fy, f, b, w, p) {\n  const pt = (u, v) => [fx + f * u * K, fy + v * K];\n  // The head and beak swing down about the shoulder as it pecks.\n  const hp = (u, v) => pt(mix(u, 1.2 + 0.25 * (u - 1.2) + 0.95 * (v + 4.2), p), mix(v, -2.4 + 0.25 * (v + 4.2) + 0.95 * (u - 1.2), p));\n  stroke(m, ...pt(-0.8, -2), ...pt(-0.8, -0.2), 0.5, 1);\n  stroke(m, ...pt(0.6, -2), ...pt(0.6, -0.2), 0.5, 1);\n  const bc = pt(-0.6, -3.6), hc = hp(2.1, -5.6);\n  fillEllipse(m, bc[0], bc[1], 3 * K, 2 * K, (-0.35 + 0.5 * p) * f, 1);\n  fillEllipse(m, hc[0], hc[1], 1.6 * K, 1.5 * K, 0, 1);\n  fillPoly(m, [...pt(-2.6, -4.6), ...pt(-6, -1.4 - 2 * p), ...pt(-5.4, -0.4 - 2 * p), ...pt(-2.4, -2.4)], 1);\n  if (b) {\n    fillPoly(m, [...hp(3.2, -6.6), ...hp(5.7, -7.6), ...hp(3.4, -5.6)], 1);\n    fillPoly(m, [...hp(3.2, -5.2), ...hp(5.2, -3.8), ...hp(3.2, -4.4)], 1);\n  } else fillPoly(m, [...hp(3.2, -6.5), ...hp(5.8, -5.5), ...hp(3.2, -4.6)], 1);\n  if (w > 0.05) wings(m, (u, v) => pt(u - 0.8, v - 4.2), 0.2 + 1.1 * w, 6.5 * K * w + 1);\n  const e = hp(2.5, -6.1);\n  setAt(m, e[0], e[1], 2);\n}\n\n// A crow in the air, centre (x, y), facing f, nose tilted down by tilt,\n// wings at angle a, drawn a little from above so both wings show.\nfunction crowFlying(m, x, y, f, a, tilt) {\n  const c = cos(tilt), s = sin(tilt);\n  const pt = (u, v) => [x + f * KF * (u * c - v * s), y + KF * (u * s + v * c)];\n  fillEllipse(m, x, y, 3.2 * KF, 1.5 * KF, tilt * f, 1);\n  const hd = pt(3.2, -0.6);\n  fillEllipse(m, hd[0], hd[1], 1.4 * KF, 1.3 * KF, 0, 1);\n  fillPoly(m, [...pt(4.2, -1), ...pt(6, -0.4), ...pt(4.2, 0.1)], 1);\n  fillPoly(m, [...pt(-2.6, -0.8), ...pt(-6, -1.6), ...pt(-6, 1.2), ...pt(-2.6, 0.8)], 1);\n  wings(m, pt, a, 7.5);\n  const e = pt(3.6, -1.1);\n  setAt(m, e[0], e[1], 2);\n}\n\nfunction palette(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  const g = cl((f - 0.3) / 0.4, 0, 1), sm = g * g * (3 - 2 * g);\n  return PAL[0].map((_, n) => [0, 1, 2].map((ch) => mix(PAL[i][n][ch], PAL[j][n][ch], sm)));\n}\n\n// The sky, the moon and the field only change with the colour.\nfunction background(S) {\n  const [top, midc, low, hz, moon, sea, field] = palette(S), bg = S.bg;\n  const lerp3 = (a, b, u) => [0, 1, 2].map((ch) => mix(a[ch], b[ch], u));\n  // Violet at the top, the middle colour at row 45, the low one at row 80\n  // and the horizon's glow at 101.\n  const skyAt = (y) => (y \u003c 45 ? lerp3(top, midc, y / 45) : y \u003c 80 ? lerp3(midc, low, (y - 45) / 35) : lerp3(low, hz, (y - 80) / (HZ - 80)));\n  for (let y = 0; y \u003c H; y++) {\n    const sky = skyAt(y);\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let c = sky;\n      if (y >= HZ) {\n        // The field: dark, with furrows running to the foot of the pole.\n        const u = (x + 0.5 - NX) / (y + 1 - HZ + 4), lane = abs(u * 3 - round(u * 3));\n        c = field.map((v) => v * (lane \u003c 0.1 + (0.02 * (y - HZ)) / 4 ? 1.9 : 1));\n      } else {\n        const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n        if (r \u003c MR) {\n          let s = 0;\n          for (const [sx, sy, sr] of [[-8, -6, 6], [6, 4, 5], [-3, 10, 4], [9, -10, 3.5]]) if ((dx - sx) ** 2 + (dy - sy) ** 2 \u003c sr * sr) s = 1;\n          c = s ? sea : moon;\n        } else if (r \u003c MR + 3) c = sky.map((v, ch) => min(255, v + 0.25 * (moon[ch] - v)));\n      }\n      bg[o] = c[0];\n      bg[o + 1] = c[1];\n      bg[o + 2] = c[2];\n    }\n  }\n  // Three pumpkins left in the field, lit orange whatever the sky.\n  for (const [px, py, rx, ry] of [[11, 113, 5.5, 4.2], [53, 109, 4.2, 3.3], [41, 121, 6.5, 4.8]]) {\n    for (let y = floor(py - ry - 2); y \u003c= floor(py + ry); y++)\n      for (let x = floor(px - rx); x \u003c= floor(px + rx); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        const u = (x + 0.5 - px) / rx, v = (y + 0.5 - py) / ry, o = (y * W + x) * 3;\n        let c = null;\n        if (u * u + v * v \u003c= 1) {\n          // Ribs as darker grooves, and a darker rim at the bottom.\n          const rib = abs(abs(u) - 0.45) \u003c 0.13 || abs(u) \u003c 0.07 ? 0.62 : 1, rim = v > 0.65 ? 0.75 : 1;\n          c = [236 * rib * rim, 112 * rib * rim, 18 * rib * rim];\n        } else if (abs(x + 0.5 - px) \u003c 0.9 && y + 0.5 \u003c py - ry + 0.6 && y + 0.5 > py - ry - 2) c = [70, 120, 30];\n        if (c) (bg[o] = c[0]), (bg[o + 1] = c[1]), (bg[o + 2] = c[2]);\n      }\n  }\n  S.bgHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.started) return;\n  if (S.bgHue !== S.hue) background(S);\n  const m = S.m, bg = S.bg;\n  m.fill(0);\n  scarecrow(S, m);\n  for (const c of S.crows) {\n    if (c.i >= S.count) continue;\n    if (c.st === \"perch\" || (c.st === \"flee\" && c.delay > 0)) crowSitting(m, c.x, c.y, c.face, c.beak, c.wing, c.peck);\n    else {\n      // Flapping in the air; gliding with wings raised on the way in.\n      const glide = c.st === \"land\" && Math.hypot(c.vx, c.vy) \u003c 14;\n      crowFlying(m, c.x, c.y, c.face, glide ? 0.75 : 0.25 + sin(c.flap), cl(c.vy / 60, -0.5, 0.5));\n    }\n  }\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const v = m[p];\n      if (v === 1) display.setPixel(x, y, 6, 2, 10);\n      else if (v === 2) display.setPixel(x, y, 150, 140, 120);\n      else display.setPixel(x, y, bg[p * 3], bg[p * 3 + 1], bg[p * 3 + 2]);\n    }\n}\n","tutte-embedding":"// ===== Patternflow pattern =====\n// Title:   Tutte Embedding\n// Family:  algo\n// Idea:    A 3-connected planar net of 90 to 210 knots is pinned by its outer face to a tall convex polygon that fills the panel, its inner knots are thrown into a tangle whose crossing threads glow orange, and every knot keeps moving to the average of its neighbours until the crossings are gone and every face is convex, as Tutte proved, while the rim knots slide round the polygon and keep the whole net flowing.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Tutte's spring embedding (W. T. Tutte, 1963), pattern round 43\n// Round:   43\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Knots=90..210, Triangles=0..1\n//\n// Knob 1: Hue. Turns the net's colour round the wheel. At 0 the settled net is azure with pale knots and a crossing thread glows orange; the alarm colour always sits 0.46 of the wheel from the net's, and a net that lands on orange, near 0.5, is paled and lifted so it does not read brown.\n// Knob 2: Speed. How fast the knots relax and the rim turns. At 2 a tangle of 90 knots comes apart in about 3.5 seconds and one of 210 in about 4, the rim knots go once round the polygon in 75 seconds, and the net is thrown again every 20 seconds; at 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Knots, 90 to 210 inner and rim knots together, from random points 7.5 LEDs apart at 90 down to 5 at 210. Turning it builds a new net in steps of 10, thrown into a fresh tangle.\n// Knob 4: Triangles. At 0 as many threads are cut as the net allows while it stays 3-connected and no face passes six sides: about 80 of 229 at 90 knots, leaving about a third of the faces triangles and the rest quadrilaterals, pentagons and hexagons. At 1 every face is a triangle. Cutting or restoring threads moves the knots to the new net's embedding, still without a crossing.\n// Buttons: K1 tap throws the inner knots into a new tangle.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, round, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst ease = (u) => (u \u003c= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u));\n\nfunction hsv(h, s, v) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  return [i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p, i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p, i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p];\n}\n\n// The rim: a superellipse |x/A|^p + |y/B|^p = 1 about the panel's centre,\n// strictly convex for every p above 1, so knots taken round it in order\n// always make a convex polygon. p breathes between 2.6 and 4.6.\nconst CX = 31.5, CY = 63.5, A = 31, B = 63, SAMPLES = 400;\n// Seconds per rim turn, between tangles and for the throw, all at Speed 1.\nconst TURN = 150, EVERY = 38.6, THROW = 1.4;\n// The relaxation rate after a throw, in sweeps per second at Speed 1: it\n// starts at K0 and grows e-fold every KT seconds up to KMAX, so the tangle\n// shrinks slowly at first and the net settles fast once it is nearly there.\nconst K0 = 0.067, KT = 1.78, KMAX = 15;\n\nfunction rimPoint(t, p) {\n  const c = cos(t), s = sin(t), e = 2 / p;\n  return [CX + A * Math.sign(c) * abs(c) ** e, CY + B * Math.sign(s) * abs(s) ** e];\n}\n\n// The rim sampled by arc length: cum[k] is the length up to sample k.\nfunction rimTable(S, p) {\n  const { rx, ry, cum } = S;\n  for (let k = 0; k \u003c= SAMPLES; k++) {\n    const [x, y] = rimPoint((k / SAMPLES) * TAU, p);\n    rx[k] = x;\n    ry[k] = y;\n    cum[k] = k ? cum[k - 1] + sqrt((x - rx[k - 1]) ** 2 + (y - ry[k - 1]) ** 2) : 0;\n  }\n}\n\n// The point a share u of the way round the rim, by length.\nfunction rimAt(S, u, X, Y, i) {\n  const { rx, ry, cum } = S;\n  const d = (u - floor(u)) * cum[SAMPLES];\n  let lo = 0, hi = SAMPLES;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >> 1;\n    if (cum[mid] \u003c= d) lo = mid;\n    else hi = mid;\n  }\n  const f = (d - cum[lo]) / (cum[hi] - cum[lo] || 1);\n  X[i] = rx[lo] + (rx[hi] - rx[lo]) * f;\n  Y[i] = ry[lo] + (ry[hi] - ry[lo]) * f;\n}\n\n// Bowyer-Watson Delaunay triangulation; triangles come back as vertex\n// triples that all turn the same way.\nfunction delaunay(px, py) {\n  const n = px.length;\n  const X = [...px, -3000, 3000, CX], Y = [...py, -3000, -3000, 6000];\n  const circ = (a, b, c) => {\n    const ax = X[a], ay = Y[a], bx = X[b], by = Y[b], cx = X[c], cy = Y[c];\n    const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));\n    const a2 = ax * ax + ay * ay, b2 = bx * bx + by * by, c2 = cx * cx + cy * cy;\n    const ux = (a2 * (by - cy) + b2 * (cy - ay) + c2 * (ay - by)) / d, uy = (a2 * (cx - bx) + b2 * (ax - cx) + c2 * (bx - ax)) / d;\n    return [a, b, c, ux, uy, (ax - ux) ** 2 + (ay - uy) ** 2];\n  };\n  let tri = [circ(n, n + 1, n + 2)];\n  for (let i = 0; i \u003c n; i++) {\n    const keep = [], edges = new Map();\n    for (const t of tri) {\n      if ((X[i] - t[3]) ** 2 + (Y[i] - t[4]) ** 2 \u003c t[5])\n        for (let k = 0; k \u003c 3; k++) {\n          const a = t[k], b = t[(k + 1) % 3], key = a \u003c b ? a * 4096 + b : b * 4096 + a;\n          edges.set(key, edges.has(key) ? null : [a, b]);\n        }\n      else keep.push(t);\n    }\n    for (const e of edges.values()) if (e) keep.push(circ(e[0], e[1], i));\n    tri = keep;\n  }\n  const out = [];\n  for (const [a, b, c] of tri) {\n    if (a >= n || b >= n || c >= n) continue;\n    const cr = (X[b] - X[a]) * (Y[c] - Y[a]) - (Y[b] - Y[a]) * (X[c] - X[a]);\n    out.push(cr > 0 ? [a, b, c] : [a, c, b]);\n  }\n  return out;\n}\n\n// A new net of about n knots: m on the rim, the rest scattered inside by\n// dart throwing so no two sit closer than d. Tried again while the\n// triangulation has a chord between two rim knots, which would make those\n// two a cut pair and the net only 2-connected.\nfunction buildNet(S, n) {\n  rimTable(S, 3.4);\n  const perim = S.cum[SAMPLES], area = 4 * A * B * 0.9;\n  for (let tries = 0; tries \u003c 16; tries++) {\n    const d = 0.86 * sqrt(area / n), m = max(12, round(perim / (1.15 * d)));\n    const px = new Float64Array(m), py = new Float64Array(m);\n    for (let k = 0; k \u003c m; k++) rimAt(S, k / m, px, py, k);\n    const X = [...px], Y = [...py];\n    // Inner knots keep 0.55 of a spacing inside the rim polygon.\n    const inside = (x, y) => {\n      for (let k = 0; k \u003c m; k++) {\n        const j = (k + 1) % m, ex = X[j] - X[k], ey = Y[j] - Y[k];\n        if (((x - X[k]) * ey - (y - Y[k]) * ex) / sqrt(ex * ex + ey * ey) > -0.55 * d) return false;\n      }\n      return true;\n    };\n    for (let k = 0; k \u003c 60 * n && X.length \u003c n; k++) {\n      const x = CX + (Math.random() * 2 - 1) * A, y = CY + (Math.random() * 2 - 1) * B;\n      if (!inside(x, y)) continue;\n      let ok = true;\n      for (let j = 0; j \u003c X.length && ok; j++) if ((X[j] - x) ** 2 + (Y[j] - y) ** 2 \u003c d * d) ok = false;\n      if (ok) X.push(x), Y.push(y);\n    }\n    const tri = delaunay(X, Y), N = X.length;\n    const seen = new Map(), E = [];\n    for (const t of tri)\n      for (let k = 0; k \u003c 3; k++) {\n        const a = min(t[k], t[(k + 1) % 3]), b = max(t[k], t[(k + 1) % 3]), key = a * 4096 + b;\n        if (!seen.has(key)) seen.set(key, E.length), E.push([a, b]);\n      }\n    let chord = false;\n    for (const [a, b] of E) if (b \u003c m && b - a !== 1 && !(a === 0 && b === m - 1)) chord = true;\n    if (chord && tries \u003c 15) continue;\n    S.n = N;\n    S.m = m;\n    S.E = E;\n    S.tris = tri;\n    S.x = Float64Array.from(X);\n    S.y = Float64Array.from(Y);\n    for (const k of [\"nx\", \"ny\", \"fx\", \"fy\", \"tx\", \"ty\"]) S[k] = new Float64Array(N);\n    // The order threads are tried for cutting, fixed with the net, so a\n    // Triangles setting always cuts the same ones.\n    const order = E.map((_, i) => i);\n    for (let i = order.length - 1; i > 0; i--) {\n      const j = floor(Math.random() * (i + 1));\n      [order[i], order[j]] = [order[j], order[i]];\n    }\n    S.cuts = cutThreads(S, order, Infinity).cuts;\n    S.heat = new Float32Array(E.length);\n    S.cutsOn = -1;\n    return;\n  }\n}\n\n// Cut threads in the given order while the net stays 3-connected. A\n// 2-connected plane graph is 3-connected exactly when any two faces meet in\n// nothing, one knot, or one thread (both ends of it); a cut joins the\n// thread's two faces into one, so only the joined face needs checking, and\n// both ends must keep at least three threads. Faces are kept to hexagons.\n// Returns the cuts in order and the faces after the first `limit` of them.\nfunction cutThreads(S, order, limit) {\n  const { E, n, m, tris } = S;\n  // Face 0 is the outer face: the rim knots in order.\n  const faces = [[...Array(m).keys()], ...tris.map((t) => t.slice())];\n  const alive = faces.map(() => true);\n  const deg = new Int32Array(n);\n  for (const [a, b] of E) deg[a]++, deg[b]++;\n  const at = Array.from({ length: n }, () => []);\n  faces.forEach((f, i) => f.forEach((v) => at[v].push(i)));\n  const step = (f, a, b) => {\n    const L = f.length;\n    for (let k = 0; k \u003c L; k++) if (f[k] === a && f[(k + 1) % L] === b) return true;\n    return false;\n  };\n  const rot = (f, s) => {\n    const k = f.indexOf(s);\n    return [...f.slice(k), ...f.slice(0, k)];\n  };\n  const cuts = [];\n  for (const ei of order) {\n    if (cuts.length >= limit) break;\n    const [a, b] = E[ei];\n    if (b \u003c m || deg[a] \u003c 4 || deg[b] \u003c 4) continue;\n    // The face with the step a -> b and the one with b -> a.\n    let f1 = -1, f2 = -1;\n    for (const fi of at[a]) {\n      if (!alive[fi]) continue;\n      if (step(faces[fi], a, b)) f1 = fi;\n      else if (step(faces[fi], b, a)) f2 = fi;\n    }\n    if (f1 \u003c= 0 || f2 \u003c= 0 || faces[f1].length + faces[f2].length > 8) continue;\n    const g1 = rot(faces[f1], b), g2 = rot(faces[f2], a);\n    const joined = [...g1, ...g2.slice(1, -1)];\n    let ok = true;\n    const checked = new Set([f1, f2]);\n    for (const v of joined) {\n      for (const fi of at[v]) {\n        if (!alive[fi] || checked.has(fi)) continue;\n        checked.add(fi);\n        const g = faces[fi], both = joined.filter((u) => g.includes(u));\n        if (both.length > 2) ok = false;\n        else if (both.length === 2) {\n          const [p, q] = both;\n          if (!((step(joined, p, q) || step(joined, q, p)) && (step(g, p, q) || step(g, q, p)))) ok = false;\n        }\n        if (!ok) break;\n      }\n      if (!ok) break;\n    }\n    if (!ok) continue;\n    cuts.push(ei);\n    deg[a]--;\n    deg[b]--;\n    alive[f1] = alive[f2] = false;\n    faces.push(joined);\n    alive.push(true);\n    joined.forEach((v) => at[v].push(faces.length - 1));\n  }\n  return { cuts, faces: faces.filter((_, i) => alive[i]) };\n}\n\n// The live threads and each knot's neighbours (CSR) for the first k cuts.\nfunction wire(S, k) {\n  const { E, n } = S, off = new Uint8Array(E.length);\n  for (let i = 0; i \u003c k; i++) off[S.cuts[i]] = 1;\n  S.live = [];\n  for (let i = 0; i \u003c E.length; i++) if (!off[i]) S.live.push(i);\n  const deg = new Int32Array(n + 1);\n  for (const i of S.live) deg[E[i][0] + 1]++, deg[E[i][1] + 1]++;\n  for (let i = 0; i \u003c n; i++) deg[i + 1] += deg[i];\n  const adj = new Int32Array(deg[n]), fill = deg.slice();\n  for (const i of S.live) {\n    const [a, b] = E[i];\n    adj[fill[a]++] = b;\n    adj[fill[b]++] = a;\n  }\n  S.start = deg;\n  S.adj = adj;\n  S.cutsOn = k;\n}\n\n// Inner knots to random places inside the rim, the far end of a throw.\nfunction throwTargets(S) {\n  const { m, n, tx, ty } = S;\n  for (let i = m; i \u003c n; i++) {\n    let x, y;\n    do {\n      x = (Math.random() * 2 - 1) * 0.94;\n      y = (Math.random() * 2 - 1) * 0.94;\n    } while (abs(x) ** 3 + abs(y) ** 3 > 0.8);\n    tx[i] = CX + A * x;\n    ty[i] = CY + B * y;\n  }\n}\n\nfunction startThrow(S, instant) {\n  throwTargets(S);\n  S.fx.set(S.x);\n  S.fy.set(S.y);\n  S.phase = instant ? 1 : 0;\n  S.clock = 0;\n  if (instant) for (let i = S.m; i \u003c S.n; i++) (S.x[i] = S.tx[i]), (S.y[i] = S.ty[i]);\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, tri: 0.06, t: 0, turn: 0,\n    rx: new Float64Array(SAMPLES + 1), ry: new Float64Array(SAMPLES + 1), cum: new Float64Array(SAMPLES + 1),\n    builtFor: -1, phase: 1, clock: 0, crossings: 0, crossing: null,\n    C: new Float32Array(W * H), Al: new Float32Array(W * H), V: new Float32Array(W * H),\n  };\n}\n\n// Place the rim knots for this moment: evenly by length round the rim, the\n// whole ring turning, with a ripple in the spacing that travels round it.\nfunction placeRim(S) {\n  const p = 3.6 + 1.0 * sin(S.t * 0.21);\n  rimTable(S, p);\n  const { m } = S;\n  for (let k = 0; k \u003c m; k++) {\n    const u = (k + S.turn * m + 0.3 * sin((TAU * 2 * k) / m - S.t * 0.37)) / m;\n    rimAt(S, u, S.x, S.y, k);\n  }\n}\n\n// Damped Jacobi sweeps: every inner knot moves the share w of the way to\n// the mean of its neighbours. The fixed point is Tutte's barycentric\n// embedding.\nfunction relax(S, sweeps, w) {\n  const { m, n, x, y, nx, ny, start, adj } = S;\n  for (let s = 0; s \u003c sweeps; s++) {\n    for (let i = m; i \u003c n; i++) {\n      let sx = 0, sy = 0;\n      const a = start[i], b = start[i + 1];\n      for (let j = a; j \u003c b; j++) (sx += x[adj[j]]), (sy += y[adj[j]]);\n      const k = b - a;\n      nx[i] = x[i] + w * (sx / k - x[i]);\n      ny[i] = y[i] + w * (sy / k - y[i]);\n    }\n    for (let i = m; i \u003c n; i++) (x[i] = nx[i]), (y[i] = ny[i]);\n  }\n}\n\n// Which live threads cross another: a sweep over threads sorted by their\n// left end, testing pairs whose boxes meet. Threads sharing a knot never\n// count as crossing.\nfunction countCrossings(S, flags) {\n  const { E, live, x, y } = S, L = live.length;\n  const lo = new Float64Array(L), idx = live.slice();\n  idx.sort((p, q) => min(x[E[p][0]], x[E[p][1]]) - min(x[E[q][0]], x[E[q][1]]));\n  for (let i = 0; i \u003c L; i++) lo[i] = min(x[E[idx[i]][0]], x[E[idx[i]][1]]);\n  let count = 0;\n  for (let i = 0; i \u003c L; i++) {\n    const [a, b] = E[idx[i]], ax = x[a], ay = y[a], bx = x[b], by = y[b];\n    const hiX = max(ax, bx), loY = min(ay, by), hiY = max(ay, by);\n    for (let j = i + 1; j \u003c L && lo[j] \u003c= hiX; j++) {\n      const [c, d] = E[idx[j]];\n      if (c === a || c === b || d === a || d === b) continue;\n      const cx = x[c], cy = y[c], dx = x[d], dy = y[d];\n      if (max(cy, dy) \u003c loY || min(cy, dy) > hiY) continue;\n      const o1 = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax), o2 = (bx - ax) * (dy - ay) - (by - ay) * (dx - ax);\n      if (o1 * o2 >= 0) continue;\n      const o3 = (dx - cx) * (ay - cy) - (dy - cy) * (ax - cx), o4 = (dx - cx) * (by - cy) - (dy - cy) * (bx - cx);\n      if (o3 * o4 >= 0) continue;\n      count++;\n      if (flags) flags[idx[i]] = flags[idx[j]] = 1;\n    }\n  }\n  return count;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 90, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tri = cl(k[3], 0, 1);\n  const want = 90 + 10 * round((cl(k[2], 90, 210) - 90) / 10);\n  const fresh = S.builtFor !== want;\n  if (fresh) {\n    buildNet(S, want);\n    S.builtFor = want;\n    S.crossing = new Uint8Array(S.E.length);\n  }\n  const cuts = round((1 - S.tri) * S.cuts.length);\n  if (S.cutsOn !== cuts) wire(S, cuts);\n  const sp = d * S.speed;\n  S.t += sp;\n  S.turn += sp / TURN;\n  placeRim(S);\n  if (fresh) startThrow(S, S.t \u003c 0.5);\n  if (input.btnPressed && input.btnPressed[0] && S.phase === 1 && S.clock > 0.3) startThrow(S, false);\n  S.clock += sp;\n  if (S.phase === 0) {\n    // The throw: inner knots fly out to the tangle along eased paths.\n    const u = ease(S.clock / THROW);\n    for (let i = S.m; i \u003c S.n; i++) {\n      S.x[i] = S.fx[i] + (S.tx[i] - S.fx[i]) * u;\n      S.y[i] = S.fy[i] + (S.ty[i] - S.fy[i]) * u;\n    }\n    if (S.clock >= THROW) (S.phase = 1), (S.clock = 0);\n  } else {\n    const k = min(KMAX, K0 * exp(S.clock / KT)) * sp, n = min(12, Math.ceil(k / 0.9));\n    relax(S, n, k / n);\n    if (S.clock > EVERY) startThrow(S, false);\n  }\n  S.crossing.fill(0);\n  S.crossings = countCrossings(S, S.crossing);\n  const fade = exp(-d / 0.35);\n  for (let i = 0; i \u003c S.E.length; i++) S.heat[i] = S.crossing[i] ? 1 : S.heat[i] * fade;\n}\n\n// --- drawing ---\n\nfunction plot(buf, x, y, c) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || c \u003c= 0) return;\n  const o = y * W + x;\n  if (c > buf[o]) buf[o] = c;\n}\n\n// Xiaolin Wu's antialiased line, one LED wide, keeping the most at each LED.\nfunction wu(buf, x0, y0, x1, y1, a) {\n  const steep = abs(y1 - y0) > abs(x1 - x0);\n  if (steep) [x0, y0, x1, y1] = [y0, x0, y1, x1];\n  if (x0 > x1) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n  const dx = x1 - x0, g = dx \u003c 1e-9 ? 0 : (y1 - y0) / dx;\n  const xs = round(x0), xe = round(x1);\n  let yy = y0 + g * (xs - x0);\n  for (let x = xs; x \u003c= xe; x++, yy += g) {\n    const yi = floor(yy), f = yy - yi;\n    if (steep) plot(buf, yi, x, (1 - f) * a), plot(buf, yi + 1, x, f * a);\n    else plot(buf, x, yi, (1 - f) * a), plot(buf, x, yi + 1, f * a);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.live) return;\n  const { C, Al, V, E, x, y, heat } = S;\n  C.fill(0);\n  Al.fill(0);\n  V.fill(0);\n  // A net turned orange is paled and lifted: dim orange reads brown.\n  const nh = S.hue + 0.56, band = max(0, 1 - abs(nh - floor(nh) - 0.09) / 0.13), lift = 1 + 0.6 * band;\n  const net = hsv(nh, 0.78 - 0.22 * band, 1).map((c) => c * lift), alarm = hsv(S.hue + 0.1, 0.92, 1), knot = hsv(S.hue + 0.53, 0.25, 1);\n  for (const i of S.live) {\n    const [a, b] = E[i], h = heat[i];\n    if (h \u003c 0.98) wu(C, x[a], y[a], x[b], y[b], 0.62 * (1 - h));\n    if (h > 0.02) wu(Al, x[a], y[a], x[b], y[b], h);\n  }\n  for (let i = 0; i \u003c S.n; i++) {\n    const px = round(x[i]), py = round(y[i]);\n    plot(V, px, py, 1);\n  }\n  for (let o = 0, py = 0; py \u003c H; py++)\n    for (let px = 0; px \u003c W; px++, o++) {\n      const c = C[o], al = Al[o], v = V[o];\n      const r = net[0] * c + alarm[0] * al + knot[0] * v, g = net[1] * c + alarm[1] * al + knot[1] * v, b = net[2] * c + alarm[2] * al + knot[2] * v;\n      display.setPixel(px, py, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","bat-emergence":"// ===== Patternflow pattern =====\n// Title:   Bat Emergence\n// Family:  halloween\n// Idea:    At dusk a ribbon of bats pours out of a cave mouth in a dark ridge and climbs the whole panel in pulses, twisting and swaying like smoke where the gusts push it, each bat a three-LED silhouette flapping against a sky that runs from deep purple to burnt orange.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Bats=400..1200, Swirl=0..1\n//\n// Knob 1: Hue. Turns the sky round the wheel; the bats stay black. At 0 it is deep purple overhead, mauve and dusky rose lower down, and burnt orange going to peach over the ridge; at 0.5 green overhead, teal lower down and sky blue over the ridge.\n// Knob 2: Speed. At 2 a bat takes 4.7 seconds from the cave mouth to the top of the panel and beats its wings 5 times a second, and about 5,200 bats leave the cave a minute; at 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Bats. How many are in the air on average: 400 at the start, a ribbon over the ridge with sky showing through it; at 1200 the lower ribbon is solid black. The stream comes in pulses about every 3.7 seconds, and between pulses the cave lets out 0.15 of what it lets out at their height.\n// Knob 4: Swirl. How hard the column twists and sways. At 0 the ribbon turns once in the panel's height, the waves running up it swing its top up to 7 LEDs and a gust leans it up to 5 more; at 0.06, where the knob opens, about the same; at 1 it turns four times, swings 23 LEDs and a gust leans it 18.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sin, cos, exp, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The sky, top to horizon, as hue, saturation and value stops at heights\n// 0..1 of the sky. Hue runs the short way round between stops.\nconst SKY = [\n  [0, 0.75, 0.86, 0.26],\n  [0.4, 0.79, 0.74, 0.42],\n  [0.7, 0.9, 0.56, 0.6],\n  [0.86, 0.02, 0.52, 0.8],\n  [0.94, 0.065, 0.62, 0.93],\n  [1, 0.09, 0.5, 1],\n];\n// The ridge: its height above the bottom row at each column, and the cave\n// mouth, an arch MW wide at the base and MH tall, centred on column MX.\nconst MX = 29.5, MW = 7, MH = 8;\nconst RIDGE = new Float32Array(W);\nfor (let x = 0; x \u003c W; x++)\n  RIDGE[x] = 13 + 4 * sin(x * 0.09 + 0.6) + 2.4 * sin(x * 0.23 + 2.1) + 1.2 * sin(x * 0.61 + 0.3) + 4 * exp(-(((x - MX) / 9) ** 2));\nconst RIDGE_TOP = H - 1 - 13;\n// The row of the top of the cave mouth; a bat's height is counted from it.\nconst MOUTH_Y = H - 1 - MH + 1;\nconst MAXB = 2600;\n// Rise speed in rows per second of scene time, and flaps per second.\nconst VUP = 20, FLAP = 5;\n\nexport function setup(params) {\n  const S = (params.s = {\n    hue: -1, speed: 2, bats: 400, swirl: 0.06, t: 0, begun: false,\n    x: new Float32Array(MAXB), y: new Float32Array(MAXB), sl: new Float32Array(MAXB), th: new Float32Array(MAXB), dp: new Float32Array(MAXB), jt: new Float32Array(MAXB),\n    ph: new Float32Array(MAXB), fr: new Float32Array(MAXB), vv: new Float32Array(MAXB), live: new Uint8Array(MAXB),\n    count: 0, next: 0, carry: 0, gust: 0, gustV: 0, gustTo: 0, gustWait: 2,\n    sky: new Float32Array(H * 3), rgb: new Float32Array(W * H * 3), stars: [],\n  });\n  for (let i = 0; i \u003c 9; i++) S.stars.push([floor(hash(i * 7 + 1) * W), floor(hash(i * 7 + 2) * 36), hash(i * 7 + 3) * TAU]);\n}\n\n// The column's centre at height h above the mouth: waves running up it like\n// smoke, wider higher up, and the gust bending the top.\nfunction centre(S, h, sw) {\n  const t = S.t, u = h / 120;\n  return (\n    MX +\n    sw * (4 * u * sin(h * 0.045 - 1.1 * t) + 2.5 * u * u * sin(h * 0.09 - 1.7 * t + 1.3) + 1.2 * sin(h * 0.02 - 0.5 * t + 2)) +\n    S.gust * 18 * u * u\n  );\n}\n\n// Pulses: the stream thickens about every 3.7 seconds.\nconst pulse = (t) => {\n  const p = 0.5 + 0.5 * sin(TAU * (t / 3.7) + 0.8 * sin((TAU * t) / 9.1));\n  return 0.15 + 0.85 * p * p;\n};\n\nfunction spawn(S) {\n  // The next free slot, searched from where the last one was found.\n  let i = -1;\n  for (let n = 0; n \u003c MAXB; n++) {\n    const j = (S.next + n) % MAXB;\n    if (!S.live[j]) {\n      i = j;\n      break;\n    }\n  }\n  if (i \u003c 0) return;\n  S.next = (i + 1) % MAXB;\n  S.count = max(S.count, i + 1);\n  S.live[i] = 1;\n  S.x[i] = MX + (Math.random() * 2 - 1) * (MW / 2 - 0.5);\n  S.y[i] = H - 1 - Math.random() * (MH - 2);\n  S.sl[i] = Math.random() * 2 - 1;\n  S.th[i] = Math.random() * 2 - 1;\n  S.jt[i] = Math.random() * TAU;\n  S.ph[i] = Math.random();\n  S.fr[i] = FLAP * (0.8 + 0.4 * Math.random());\n  S.vv[i] = 0.75 + 0.5 * Math.random();\n}\n\nfunction step(S, dt) {\n  S.t += dt;\n  const sw = 0.9 + 2.1 * S.swirl, twist = (TAU * (1 + 3 * S.swirl)) / 120;\n  // Gusts: every 3 to 8 seconds the wind picks a new lean, eased in.\n  S.gustWait -= dt;\n  if (S.gustWait \u003c= 0) {\n    S.gustTo = (Math.random() * 2 - 1) * (0.3 + 0.7 * S.swirl);\n    S.gustWait = 3 + 5 * Math.random();\n  }\n  S.gustV += ((S.gustTo - S.gust) * 1.6 - S.gustV * 1.8) * dt;\n  S.gust += S.gustV * dt;\n  // Bats leaving the cave per second: 0.43 times S.bats at the height of a\n  // pulse, which keeps about S.bats in the air on average.\n  S.carry += S.bats * 0.43 * pulse(S.t) * dt;\n  while (S.carry >= 1) {\n    spawn(S);\n    S.carry -= 1;\n  }\n  const { x, y, sl, th, dp, jt, ph, fr, vv, live } = S, k = min(1, 8 * dt);\n  for (let i = 0; i \u003c S.count; i++) {\n    if (!live[i]) continue;\n    const h = MOUTH_Y - y[i], u = cl(h / 120, 0, 1.2);\n    // Out of the mouth fast, slower over the ridge, then faster again as\n    // the column breaks up at the top.\n    y[i] -= vv[i] * VUP * (1 + 0.6 * exp(-h / 12)) * (0.8 + 1.8 * u * u) * dt;\n    // The ribbon: a flat band turning about the column, each bat at its\n    // own place across it, so where the band turns edge-on it pinches and\n    // the bats on it cross over. It widens as it climbs and frays at the top.\n    const wdt = 3 + 20 * u ** 1.3 + 90 * max(0, u - 0.55) ** 2, phi = twist * h - 1.3 * S.t + 0.4, c = cos(phi), sn = sin(phi);\n    const tx = centre(S, h, sw) + wdt * (sl[i] * c + 0.18 * th[i] * sn) + sin(jt[i] + 2.3 * S.t) * (0.4 + 1.5 * u);\n    dp[i] = sl[i] * sn;\n    x[i] += (tx - x[i]) * k;\n    ph[i] += fr[i] * dt;\n    if (y[i] \u003c -3 || x[i] \u003c -4 || x[i] > W + 3) live[i] = 0;\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kn = input.knobValues || [0, 2, 400, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hueK = kn[0];\n  S.speed = cl(kn[1], 0.2, 3);\n  S.bats = cl(kn[2], 400, 1200);\n  S.swirl = cl(kn[3], 0, 1);\n  // The first frame opens on a column already standing up the panel.\n  if (!S.begun) {\n    S.begun = true;\n    for (let k = 0; k \u003c 140; k++) step(S, 1 / 20);\n  }\n  step(S, (d * S.speed) / 2);\n}\n\nfunction paintSky(S) {\n  const c = [0, 0, 0];\n  for (let y = 0; y \u003c H; y++) {\n    const f = cl(y / RIDGE_TOP, 0, 1);\n    let j = 0;\n    while (j \u003c SKY.length - 2 && f > SKY[j + 1][0]) j++;\n    const a = SKY[j], b = SKY[j + 1], t = (f - a[0]) / (b[0] - a[0]);\n    let dh = b[1] - a[1];\n    dh -= round(dh);\n    hsv(S.hueK + a[1] + dh * t, mix(a[2], b[2], t), mix(a[3], b[3], t), c, 0);\n    S.sky[y * 3] = c[0];\n    S.sky[y * 3 + 1] = c[1];\n    S.sky[y * 3 + 2] = c[2];\n  }\n  S.hue = S.hueK;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.hue !== S.hueK) paintSky(S);\n  const { rgb, sky } = S;\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) {\n      rgb[q] = sky[y * 3];\n      rgb[q + 1] = sky[y * 3 + 1];\n      rgb[q + 2] = sky[y * 3 + 2];\n    }\n  // A few faint stars high up, breathing slowly.\n  for (const [sx, sy, sp] of S.stars) {\n    const q = (sy * W + sx) * 3, a = 0.18 + 0.12 * sin(0.9 * S.t + sp);\n    rgb[q] += a;\n    rgb[q + 1] += a;\n    rgb[q + 2] += a;\n  }\n  // The ridge: dark purple, its skyline lit by the afterglow, and the cave\n  // mouth black.\n  const r0 = sky[RIDGE_TOP * 3], g0 = sky[RIDGE_TOP * 3 + 1], b0 = sky[RIDGE_TOP * 3 + 2];\n  for (let x = 0; x \u003c W; x++) {\n    const top = H - RIDGE[x];\n    for (let y = max(0, floor(top)); y \u003c H; y++) {\n      const q = (y * W + x) * 3, rim = y - top \u003c 1.2 ? 0.5 : 0;\n      const dx = (x + 0.5 - MX) / (MW / 2), dy = (H - 0.5 - y) / MH;\n      const cave = dx * dx + dy * dy \u003c 1;\n      if (cave) rgb[q] = rgb[q + 1] = rgb[q + 2] = 0;\n      else {\n        rgb[q] = 0.15 + rim * r0 * 0.5;\n        rgb[q + 1] = 0.075 + rim * g0 * 0.5;\n        rgb[q + 2] = 0.17 + rim * b0 * 0.5;\n      }\n    }\n  }\n  // The bats: three LEDs each, wings up, level, down, a third of a beat\n  // each. Bats on the far side of the band are a little hazed with the sky\n  // behind them, which shows which way the ribbon turns.\n  const { x, y, ph, dp, live } = S;\n  for (let i = 0; i \u003c S.count; i++) {\n    if (!live[i]) continue;\n    const bx = round(x[i]), by = round(y[i]), st = floor(ph[i] * 3) % 3, wy = st - 1, hz = 0.3 * max(0, -dp[i]);\n    for (let w = -1; w \u003c= 1; w++) {\n      const px = bx + w, py = by + (w ? wy : 0);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const q = (py * W + px) * 3, sy = min(py, RIDGE_TOP) * 3;\n      rgb[q] = 0.02 + hz * sky[sy];\n      rgb[q + 1] = 0.008 + hz * sky[sy + 1];\n      rgb[q + 2] = 0.03 + hz * sky[sy + 2];\n    }\n  }\n  for (let yy = 0, q = 0; yy \u003c H; yy++)\n    for (let xx = 0; xx \u003c W; xx++, q += 3) display.setPixel(xx, yy, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","candle-vigil":"// ===== Patternflow pattern =====\n// Title:   Candle Vigil\n// Family:  halloween\n// Idea:    Three pillar candles of purple, ivory and pumpkin wax stand on a dark purple floor, their teardrop flames swaying and flickering in a warm halo that breathes with them, wax drips forming at the rims and creeping down the sides, a draft now and then bending every flame the same way, and a flame now and then guttering out in a thin curl of smoke before it lights again.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Candles=3..6, Draft=0..1\n//\n// Knob 1: Hue. Turns the colours of the wax round the wheel; the flames and their light stay candle light. At 0 purple, ivory and pumpkin orange (then toxic green, black and violet as more candles come); at 0.5 the purple wax turns olive and the orange wax sky blue.\n// Knob 2: Speed. How fast the room lives. At 2 a flame sways about twice a second and its light flickers about nine times, a drip starts down at 3 to 6 LEDs a second and slows to a stop, and smoke leaves the wick at 8 LEDs a second; at 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Candles. How many candles stand on the floor, 3 to 6, each 15 LEDs wide at 3 and 8 at 6, between 50 and 90 LEDs tall. Each throws less light the more there are, so six light the room about as much as three.\n// Knob 4: Draft. How much the air moves. At 0 a draft comes about every 18 s and one of three flames gutters out about once a minute; at 0.06 a draft every 15 s and a guttering every 40 s, the first draft at 4 s and the first guttering at 6.5 s; at 1 a draft every 5 s, every flame leaning hard to the right even between them and fluttering, and a guttering every 7 or 8 s. A guttered flame stays dark 3 to 4.5 s while its smoke curls up, then lights again.\n\nconst W = 64, H = 128, FLOOR = 123;\nconst { floor, round, min, max, abs, exp, sqrt, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n// Smooth 1-D value noise, -1..1.\nconst vn = (x, s) => {\n  const i = floor(x), f = x - i, u = f * f * (3 - 2 * f);\n  return (hash(i * 7919 + s) * (1 - u) + hash((i + 1) * 7919 + s) * u) * 2 - 1;\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n  return out;\n}\n\n// Wax colours as hue, saturation, value: purple, ivory, pumpkin, toxic\n// green, black, violet. Which candle gets which, for 3 to 6 candles, and how\n// tall each stands.\nconst WAX = [[0.78, 0.6, 0.55], [0.11, 0.22, 0.85], [0.075, 0.85, 0.8], [0.3, 0.85, 0.6], [0.76, 0.3, 0.2], [0.84, 0.45, 0.65]];\nconst ORDER = { 3: [0, 1, 2], 4: [0, 1, 3, 2], 5: [4, 0, 1, 3, 2], 6: [4, 0, 1, 5, 3, 2] };\nconst TALL = { 3: [68, 90, 52], 4: [62, 88, 74, 50], 5: [54, 80, 90, 64, 50], 6: [50, 76, 90, 58, 84, 54] };\n// Flame palette by heat: deep orange at the rim, white-yellow in the core.\nconst HEAT = [[0, 0.95, 0.32, 0.03], [0.28, 1, 0.55, 0.08], [0.5, 1, 0.82, 0.3], [0.68, 1, 0.95, 0.72], [1, 1, 1, 0.92]];\nconst WARM = [1, 0.52, 0.1], ROSE = [0.95, 0.36, 0.3], BLUE = [0.18, 0.32, 1], SMOKE = [0.6, 0.55, 0.72];\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 1, draft: 0.06, count: 0, t: 0, real: 0,\n    cands: [], gust: 0, gDir: 1, gStart: -1, gLen: 0, gPow: 0, nextGust: -1,\n    // The opening guttering: the right-hand candle goes out at 6.5 s.\n    scripted: true,\n    rgb: new Float32Array(W * H * 3), c3: [0, 0, 0],\n  };\n}\n\nfunction build(P, n) {\n  const sw = W / n, cands = [];\n  for (let i = 0; i \u003c n; i++) {\n    const w = min(15, max(8, round(sw * 0.72))), h = TALL[n][i];\n    const xc = (i + 0.5) * sw + (hash(i * 31 + n) - 0.5) * sw * 0.12;\n    const x0 = round(xc - w / 2);\n    cands.push({\n      x0, w, xc: x0 + w / 2, top: FLOOR - h, wax: WAX[ORDER[n][i]], seed: i * 101 + 7,\n      mode: \"lit\", mt: 0, s: 1, wait: 0, drips: [], wisp: [], emit: 0, ember: 0,\n      // Flame for this frame: base, height, half-width, lean, light.\n      fx: 0, fy: 0, hf: 0, r: 0, lean: 0, I: 1,\n    });\n  }\n  P.cands = cands;\n  P.count = n;\n  // More candles light the room no brighter than three: each throws less.\n  P.share = (3 / n) ** 0.8;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 3, 0.06];\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3) / 2;\n  P.draft = cl(k[3], 0, 1);\n  const n = cl(round(k[2]), 3, 6);\n  if (n !== P.count) build(P, n);\n  const real = cl(dt || 0, 0, 0.1), d = real * P.speed;\n  P.real += real;\n  P.t += d;\n  const t = P.t, dr = P.draft;\n  // The first draft comes at 4 s, sooner the more the air moves.\n  if (P.nextGust \u003c 0) P.nextGust = 4 - 2.5 * dr;\n\n  // Drafts: a gust rises in 0.5 s, holds and then dies away over 1.2 s, all\n  // flames leaning its way.\n  if (t >= P.nextGust && P.gStart \u003c 0) {\n    P.gStart = t;\n    P.gDir = Math.random() \u003c 0.5 ? -1 : 1;\n    P.gLen = 1.2 + 1.3 * Math.random();\n    P.gPow = 0.6 + 0.4 * Math.random();\n  }\n  if (P.gStart >= 0) {\n    const a = t - P.gStart;\n    P.gust = P.gDir * P.gPow * sm(0, 0.5, a) * (1 - sm(P.gLen, P.gLen + 1.2, a));\n    if (a > P.gLen + 1.2) {\n      P.gStart = -1;\n      P.gust = 0;\n      P.nextGust = t - Math.log(1 - Math.random() * 0.95) / (0.06 + 0.35 * dr);\n    }\n  }\n  const breeze = 0.45 * dr * dr, flutter = abs(P.gust) + 0.7 * dr;\n  let out = 0;\n  for (const c of P.cands) if (c.mode !== \"lit\") out++;\n\n  for (const c of P.cands) {\n    c.mt += d;\n    const sd = c.seed;\n    // A flame goes out, stays dark a while, then lights again.\n    if (c.mode === \"lit\") {\n      let chance = (0.006 + 0.05 * dr + (abs(P.gust) > 0.6 ? 0.15 * dr : 0)) * d;\n      if (out) chance *= 0.3;\n      // The opening keeps its own guttering at 6.5 s and none before 10 s.\n      if (P.scripted || P.real \u003c 10) chance = 0;\n      const due = P.scripted && c === P.cands[P.cands.length - 1] && P.real >= 6.5;\n      if (due || Math.random() \u003c chance) {\n        if (due) P.scripted = false;\n        (c.mode = \"dying\"), (c.mt = 0), out++;\n      }\n    } else if (c.mode === \"dying\") {\n      c.s = 1 - sm(0, 1.1, c.mt);\n      if (c.mt > 1.1) (c.mode = \"out\"), (c.mt = 0), (c.s = 0), (c.ember = 1), (c.wait = 3 + 1.5 * Math.random());\n    } else if (c.mode === \"out\") {\n      c.ember = max(0, 1 - c.mt / 2);\n      if (c.mt > c.wait) (c.mode = \"relight\"), (c.mt = 0);\n    } else if (c.mode === \"relight\") {\n      c.s = sm(0.25, 1.2, c.mt);\n      if (c.mt > 1.2) (c.mode = \"lit\"), (c.mt = 0), (c.s = 1);\n    }\n    if (P.scripted && c.mode !== \"lit\") P.scripted = false;\n\n    // The flame: noise for height and sway, the draft for lean.\n    const n1 = vn(t * 2.8, sd), n2 = vn(t * 9, sd + 1), n3 = vn(t * 1.9, sd + 2), n4 = vn(t * 14, sd + 3);\n    const flick = 1 + 0.12 * n1 + 0.07 * n2 + 0.1 * flutter * n4;\n    c.lean = 0.22 * n3 + 0.07 * n2 + P.gust * (0.5 + 0.4 * dr) + breeze + 0.08 * flutter * n4;\n    const bend = min(1, abs(c.lean));\n    const hf0 = cl(c.w * 1.9, 13, 28), sz = c.s * (c.mode === \"dying\" ? 1 + 0.25 * vn(t * 20, sd) : 1);\n    c.hf = hf0 * sz * flick * (1 - 0.3 * bend);\n    c.r = hf0 * 0.23 * (c.s > 0 ? c.s ** 0.6 : 0) * (1 + 0.15 * bend);\n    // A flame bent by the air is smaller and gives less light.\n    c.I = c.s * (0.72 + 0.16 * n1 + 0.16 * n2 + 0.06 * flutter * n4) * (1 - 0.3 * bend);\n    c.fx = round(c.xc - 0.5);\n    c.fy = c.top - 2;\n\n    // Drips: a bead swells on the rim for half a second, runs down fast and\n    // slows to a stop, holds for 40 s and sinks back into the wax over 10.\n    if (c.mode === \"lit\" && c.drips.length \u003c 7 && Math.random() \u003c 0.16 * d) {\n      const edge = Math.random() \u003c 0.45;\n      const dx = edge ? (Math.random() \u003c 0.5 ? -1 : c.w) : 1 + floor(Math.random() * (c.w - 3));\n      if (!c.drips.some((q) => abs(q.dx - dx) \u003c 3))\n        c.drips.push({ dx, len: 0, max: 8 + Math.random() * min(46, (FLOOR - c.top) * 0.6), v: 3 + 3 * Math.random(), age: 0, wig: Math.random() * 9 });\n    }\n    for (const q of c.drips) {\n      q.age += d;\n      if (q.age > 0.5) q.len = q.max * (1 - exp((-(q.age - 0.5) * q.v) / q.max));\n    }\n    c.drips = c.drips.filter((q) => q.age \u003c 60);\n\n    // Smoke: for 2.5 s after the flame dies a curl leaves the wick, rising\n    // 10 LEDs a second and swinging with the air.\n    if (c.mode === \"out\" && c.mt \u003c 2.5) {\n      c.emit += 40 * d;\n      for (; c.emit >= 1; c.emit--)\n        c.wisp.push({ x: c.fx + 0.5, y: c.fy, a: 0, ph: t * 2.1 + c.seed, w: 1 - c.mt / 2.5 });\n    }\n    for (const p of c.wisp) {\n      p.a += d;\n      p.y -= (8 + 4 * p.a) * d;\n      p.x += (5 * sin(p.ph + p.a * 2.4) * min(1, p.a) + (P.gust + breeze) * 14) * d;\n    }\n    c.wisp = c.wisp.filter((p) => p.a \u003c 4 && p.y > -2);\n  }\n}\n\n// Where a flame is and how hot, at LED (x, y): 0 outside.\nfunction flameAt(c, x, y, out) {\n  if (c.s \u003c= 0.02) return 0;\n  const tau = (c.fy + 1 - y + c.hf * 0.12) / (c.hf * 1.12);\n  if (tau \u003c= 0 || tau >= 1) return 0;\n  const prof = (sqrt(tau) * (1 - tau) ** 1.1) / 0.37;\n  const xc = c.fx + 0.5 + c.lean * c.hf * tau ** 1.7;\n  const d = abs(x + 0.5 - xc) / max(0.3, c.r * prof);\n  if (d >= 1) return 0;\n  const heat = cl((1 - d) * (1.15 - 0.95 * tau), 0, 1);\n  let j = 0;\n  while (j \u003c HEAT.length - 2 && heat > HEAT[j + 1][0]) j++;\n  const [h0, r0, g0, b0] = HEAT[j], [h1, r1, g1, b1] = HEAT[j + 1], f = cl((heat - h0) / (h1 - h0), 0, 1);\n  (out[0] = r0 + (r1 - r0) * f), (out[1] = g0 + (g1 - g0) * f), (out[2] = b0 + (b1 - b0) * f);\n  // The thin blue base, and a small flame is mostly blue.\n  const bw = max((1 - tau / 0.26) * sm(0.15, 0.7, d), c.s \u003c 0.45 ? (1 - c.s / 0.45) * 0.8 : 0);\n  for (let i = 0; i \u003c 3; i++) out[i] += (BLUE[i] - out[i]) * cl(bw, 0, 1);\n  return sm(1, 0.68, d) * cl(tau / 0.07, 0, 1) * (1 - sm(0.86, 1, tau));\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.cands.length) return;\n  const { rgb, c3, cands } = P;\n  // Light in the air round each flame: a tight halo and a wide one, both\n  // breathing with the flame.\n  rgb.fill(0);\n  for (let y = 0; y \u003c H; y++) {\n    const g = y / (H - 1), br = 0.008 + 0.05 * g * g, bg = 0.002 + 0.012 * g * g, bb = 0.015 + 0.072 * g * g;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let L = 0, F = 0;\n      for (const c of cands) {\n        if (c.I \u003c= 0.01) continue;\n        const cx = c.fx + 0.5 + c.lean * c.hf * 0.45, cy = c.fy - c.hf * 0.4;\n        const dx = x + 0.5 - cx, dy = y + 0.5 - cy, d2 = dx * dx + dy * dy, s1 = 9 + 3 * c.I;\n        L += c.I * P.share * 0.42 * exp(-d2 / (2 * s1 * s1));\n        F += c.I * P.share * 0.1 * exp(-d2 / 1100);\n      }\n      // The near halo is flame orange; the far one leans rose, so where it\n      // thins out over the purple it does not read brown.\n      (rgb[p * 3] = br + WARM[0] * L + ROSE[0] * F), (rgb[p * 3 + 1] = bg + WARM[1] * L + ROSE[1] * F), (rgb[p * 3 + 2] = bb + WARM[2] * L + ROSE[2] * F);\n    }\n  }\n  // The floor: dark plum, lit in pools under the flames.\n  for (let y = FLOOR; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let L = 0;\n      for (const c of cands) {\n        const dx = (x + 0.5 - c.xc) / 18;\n        L += c.I * P.share * 0.5 * exp(-dx * dx) * (1 - (y - FLOOR) * 0.12);\n      }\n      (rgb[p * 3] = 0.07 + 0.55 * L), (rgb[p * 3 + 1] = 0.025 + 0.28 * L), (rgb[p * 3 + 2] = 0.1 + 0.07 * L);\n    }\n\n  for (const c of cands) {\n    const wax = hsv(c.wax[0] + P.hue, c.wax[1], c.wax[2], [0, 0, 0]);\n    // A wax LED's colour: lit by every flame by distance, rounder in the\n    // middle, glowing through from its own flame near the top.\n    const waxAt = (x, y, lift) => {\n      const u = (x + 0.5 - c.xc) / (c.w / 2), cyl = 0.45 + 0.55 * sqrt(max(0, 1 - u * u));\n      let L = 0;\n      for (const o of cands) {\n        if (o.I \u003c= 0.01) continue;\n        const dx = o.fx + 0.5 - (x + 0.5), dy = o.fy - (y + 0.5), r = (dx * dx + dy * dy) / 450;\n        const face = o === c ? 1 : P.share * cl(0.55 + 0.6 * u * Math.sign(dx), 0.15, 1.15);\n        L += (o.I * face) / (1 + r);\n      }\n      const glow = c.I * 0.5 * exp(-(y - c.top) / 6);\n      const k = (0.16 + 0.95 * L) * cyl * lift;\n      (c3[0] = wax[0] * k + glow * 1.0), (c3[1] = wax[1] * k + glow * 0.6), (c3[2] = wax[2] * k + glow * 0.28);\n      return c3;\n    };\n    const put = (x, y, col) => {\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n      const o = (y * W + x) * 3;\n      (rgb[o] = col[0]), (rgb[o + 1] = col[1]), (rgb[o + 2] = col[2]);\n    };\n    // Body, with the rim standing a little proud of the melt pool.\n    for (let y = c.top - 1; y \u003c FLOOR; y++)\n      for (let x = c.x0; x \u003c c.x0 + c.w; x++) {\n        const u = (x + 0.5 - c.xc) / (c.w / 2);\n        if (y === c.top - 1 && abs(u) \u003c 0.72) continue;\n        put(x, y, waxAt(x, y, 1));\n        // The melt pool: a shallow lit ellipse inside the rim.\n        const e = (u / 0.8) ** 2 + ((y - c.top - 0.6) / 1.4) ** 2;\n        if (e \u003c 1 && c.s > 0) {\n          const o = (y * W + x) * 3, k = c.I * (1 - e) * 0.75;\n          (rgb[o] += k), (rgb[o + 1] += k * 0.62), (rgb[o + 2] += k * 0.3);\n        }\n      }\n    // Drips: a raised streak, lighter on its left, a bead at its foot. A drip\n    // on the edge stands one LED out from the side.\n    for (const q of c.drips) {\n      const fade = 1 - sm(50, 60, q.age), bead = q.age \u003c 0.5 ? q.age / 0.5 : 1;\n      if (q.len \u003c 0.5 && bead \u003c 1) {\n        const x = c.x0 + q.dx, y = c.top;\n        const col = waxAt(cl(x, c.x0, c.x0 + c.w - 1), y, 1.25 * bead + (1 - bead));\n        put(x, y, col);\n        continue;\n      }\n      const end = c.top + round(q.len);\n      for (let y = c.top; y \u003c= end; y++) {\n        const x = c.x0 + q.dx + (vn(y * 0.18 + q.wig, 5) > 0.55 ? 1 : 0) * (q.dx >= 0 && q.dx \u003c c.w - 1 ? 1 : 0);\n        const lift = 1 + 0.32 * fade;\n        put(x, y, waxAt(cl(x, c.x0, c.x0 + c.w - 1), y, lift));\n        if (q.dx >= 0 && q.dx \u003c c.w - 1) put(x + 1, y, waxAt(x + 1, y, 1 + 0.12 * fade));\n        if (y === end) {\n          put(x - 1, y, waxAt(cl(x - 1, c.x0, c.x0 + c.w - 1), y, 1 + 0.2 * fade));\n          put(x, y + 1, waxAt(cl(x, c.x0, c.x0 + c.w - 1), y + 1, 1 + 0.25 * fade));\n        }\n      }\n    }\n    // Wick, and its ember after the flame dies.\n    for (let y = c.top - 3; y \u003c c.top; y++) put(c.fx, y, [0.07, 0.04, 0.05]);\n    if (c.ember > 0) put(c.fx, c.top - 3, [0.9 * c.ember, 0.25 * c.ember, 0.05 * c.ember]);\n    if (c.mode === \"relight\" && c.mt \u003c 0.3) put(c.fx, c.top - 4, [1, 0.95, 0.8]);\n  }\n  // Flames over everything.\n  for (const c of cands) {\n    if (c.s \u003c= 0.02) continue;\n    const reach = c.r + abs(c.lean) * c.hf + 2;\n    for (let y = max(0, floor(c.fy - c.hf - 1)); y \u003c= min(H - 1, c.fy + 2); y++)\n      for (let x = max(0, floor(c.fx - reach)); x \u003c= min(W - 1, c.fx + reach + 1); x++) {\n        const a = flameAt(c, x, y, c3);\n        if (a \u003c= 0) continue;\n        const o = (y * W + x) * 3;\n        for (let i = 0; i \u003c 3; i++) rgb[o + i] = rgb[o + i] * (1 - a) + c3[i] * a;\n      }\n  }\n  // Smoke curls, thin and grey-violet, fading as they rise.\n  for (const c of cands)\n    for (const p of c.wisp) {\n      const x = floor(p.x), y = floor(p.y);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const a = 0.55 * (1 - p.a / 4) * (0.4 + 0.6 * p.w), o = (y * W + x) * 3;\n      for (let i = 0; i \u003c 3; i++) rgb[o + i] = max(rgb[o + i], rgb[o + i] * (1 - a) + SMOKE[i] * a);\n    }\n  // Out in steps of 4 levels, 64 to a channel: the soft light then packs\n  // into runs, and no step shows on the panel.\n  const lv = (v) => min(255, round(v * 63.75) * 4);\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, lv(rgb[o]), lv(rgb[o + 1]), lv(rgb[o + 2]));\n}\n","fput-recurrence":"// ===== Patternflow pattern =====\n// Title:   FPUT Recurrence\n// Family:  physics\n// Idea:    The 1955 chain of 31 masses on springs with a quadratic term vibrates as a string down the panel, plucked with all its energy in its lowest mode; the energy runs into modes 2, 3 and 4, drawn as coloured lobes round the string, until mode 1 keeps 9% of it, and 147 swings after the pluck 98% of it is back in mode 1.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Fermi–Pasta–Ulam–Tsingou problem (Enrico Fermi, John Pasta, Stanislaw Ulam, Mary Tsingou, 1955), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Amplitude=1..1.9, Alpha=0..1\n//\n// Knob 1: Hue. Turns the mode colours round the wheel together. At 0 mode 1 is magenta, mode 2 cyan, mode 3 gold, mode 4 green and modes 5 to 8 a pale ice blue; at 0.5 mode 1 is green and mode 2 red.\n// Knob 2: Speed. At 2 the chain runs 300 units of its own time a second, so mode 1 swings 4.7 times a second and the energy is back in mode 1 after 31 seconds; at 0.2 a swing takes 2.1 seconds and the return 5 minutes, at 3 the return takes 21 seconds.\n// Knob 3: Amplitude. How far the pluck pulls the middle mass: 1 unit at the start, as in 1955, drawn 24 LEDs to the side; up to 1.9 units, drawn 31 LEDs to the side, the scale shrinking so the string stays on the panel. Only Alpha times Amplitude matters to the motion. At 1.9 mode 1 drops to 4.5% and 97% is back after 107 swings.\n// Knob 4: Alpha. The strength of the springs' quadratic term, alpha = 0.25 times the square root of the knob over 0.06: 0.25 at 0.06, where the knob opens, as in 1955; 0.5 at 0.24; 1.02 at 1, where mode 1 drops to 2% and 95% is back after 73 swings. At 0 the springs are linear and the energy never leaves mode 1. With Amplitude at 1.9 and Alpha at 1 the energy runs up into modes 5 to 8 within 2 seconds and does not come back in two minutes. A turned Amplitude or Alpha plucks the chain again once the knob has rested 0.4 seconds.\n// Buttons: K1 tap plucks the chain again, all its energy in mode 1.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\n// The chain: N springs, masses 1..N-1 moving, masses 0 and N held. In the\n// model each mass moves along the chain; here its displacement is drawn\n// sideways, so the chain reads as a string stretched from the top of the\n// panel to the bottom.\nconst N = 32;\n// Rows of the two held ends and the step between masses.\nconst Y0 = 0.5, DY = 127 / N;\nconst CX = 31.5;\n// LEDs per unit of displacement: 24 at amplitude 1, fewer for a bigger\n// pluck so the swing stays on the panel, 31 LEDs either side at 1.9.\nconst scaleOf = (A) => 24 * A ** -0.6;\n// Velocity Verlet step in the chain's own time. With a step of 0.1 the\n// energy is back in mode 1 after 147 periods of mode 1 (T1 = 64.03); 0.05\n// gives the same within half a period. A coarser step stretches it: a step\n// of 0.354, the square root of 1/8, gives 157 periods and 0.4 gives 160.\nconst HSTEP = 0.1;\n// Chain time per second at Speed 1.\nconst RATE = 150;\n// Mode k: frequency 2 sin(pi k / 2N), shape sqrt(2/N) sin(pi k i / N).\nconst OM = new Float64Array(N), SH = new Float64Array(N * (N + 1));\nfor (let k = 1; k \u003c N; k++) {\n  OM[k] = 2 * sin((PI * k) / (2 * N));\n  for (let i = 0; i \u003c= N; i++) SH[k * (N + 1) + i] = sqrt(2 / N) * sin((PI * k * i) / N);\n}\nconst T1 = (2 * PI) / OM[1];\n// Energy of mode 1 plucked to amplitude 1: the unit the lobes are drawn in.\nconst EREF = 0.5 * OM[1] * OM[1] * (N / 2);\n// Mode colours at Hue 0: magenta, cyan, gold and green for modes 1 to 4,\n// and one pale ice blue for modes 5 to 8. At the opening knobs mode 5 holds\n// 15% at most and mode 6 4%; a larger Alpha or Amplitude fills up to mode 8.\nconst MHUE = [0, 0.87, 0.5, 0.13, 0.3, 0.58, 0.58, 0.58, 0.58], MSAT = [0, 0.75, 0.8, 0.7, 0.75, 0.35, 0.35, 0.35, 0.35];\nconst GHOSTS = 8;\n// Lobe fill, as a share of the outline's level.\nconst FILL = 0.2;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nconst alphaOf = (k) => 0.25 * sqrt(max(0, k) / 0.06);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, amp: 1, alpha: 0.25, ampSet: -1, alphaSet: -1, wait: 0, begun: false,\n    u: new Float64Array(N + 1), v: new Float64Array(N + 1), a: new Float64Array(N + 1),\n    clock: 0, carry: 0, e: new Float64Array(N), es: new Float64Array(N),\n    rgb: new Float32Array(W * H * 3), col: new Float32Array(3 * (GHOSTS + 1)),\n  };\n}\n\nfunction accel(S) {\n  const { u, a } = S, al = S.alphaSet;\n  for (let i = 1; i \u003c N; i++) {\n    const dr = u[i + 1] - u[i], dl = u[i] - u[i - 1];\n    a[i] = dr - dl + al * (dr * dr - dl * dl);\n  }\n}\n\nfunction modes(S, out) {\n  const { u, v } = S;\n  for (let k = 1; k \u003c N; k++) {\n    let q = 0, p = 0;\n    const o = k * (N + 1);\n    for (let i = 1; i \u003c N; i++) {\n      q += SH[o + i] * u[i];\n      p += SH[o + i] * v[i];\n    }\n    out[k] = 0.5 * (p * p + OM[k] * OM[k] * q * q);\n  }\n}\n\nfunction pluck(S) {\n  const { u, v } = S;\n  S.ampSet = S.amp;\n  S.alphaSet = S.alpha;\n  for (let i = 0; i \u003c= N; i++) {\n    u[i] = S.amp * sin((PI * i) / N);\n    v[i] = 0;\n  }\n  u[0] = u[N] = 0;\n  accel(S);\n  S.clock = 0;\n  S.carry = 0;\n  modes(S, S.es);\n  S.wait = 0;\n}\n\n// The string's column at row y (any real y), straight between masses.\nfunction colAt(u, y, sc) {\n  const f = cl((y - Y0) / DY, 0, N), i = min(N - 1, floor(f)), t = f - i;\n  return CX + sc * (u[i] + (u[i + 1] - u[i]) * t);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.amp = cl(k[2], 1, 1.9);\n  S.alpha = alphaOf(cl(k[3], 0, 1));\n  if (!S.begun) {\n    pluck(S);\n    S.begun = true;\n  }\n  if (abs(S.amp - S.ampSet) > 0.004 || abs(S.alpha - S.alphaSet) > 0.004) {\n    S.wait += d;\n    if (S.wait > 0.4) pluck(S);\n  } else S.wait = 0;\n  if (input.btnPressed && input.btnPressed[0]) pluck(S);\n\n  const { u, v, a } = S;\n  S.carry += d * S.speed * RATE;\n  while (S.carry >= HSTEP) {\n    for (let i = 1; i \u003c N; i++) {\n      v[i] += 0.5 * HSTEP * a[i];\n      u[i] += HSTEP * v[i];\n    }\n    accel(S);\n    for (let i = 1; i \u003c N; i++) v[i] += 0.5 * HSTEP * a[i];\n    S.carry -= HSTEP;\n    S.clock += HSTEP;\n  }\n  // A chain thrown past its springs' hump starts again.\n  let big = 0;\n  for (let i = 1; i \u003c N; i++) big = max(big, abs(u[i]));\n  if (!(big \u003c 6)) pluck(S);\n  // Mode energies, smoothed over one period of mode 1 so the lobes show\n  // where the energy is, not the swing of each mode.\n  modes(S, S.e);\n  const g = 1 - exp(-(d * S.speed * RATE) / T1);\n  for (let k2 = 1; k2 \u003c N; k2++) S.es[k2] += (S.e[k2] - S.es[k2]) * g;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, col, es, u } = S, sc = scaleOf(S.ampSet);\n  for (let m = 1; m \u003c= GHOSTS; m++) hsv(S.hue + MHUE[m], MSAT[m], 1, col, 3 * m);\n  let tot = 0;\n  for (let k = 1; k \u003c N; k++) tot += es[k];\n  tot = max(tot, 1e-12);\n  // String colour: the modes' colours weighted by the fourth power of their\n  // shares, so the string takes the colour of the mode holding the most.\n  let wr = 0, wg = 0, wb = 0, ws = 0;\n  for (let m = 1; m \u003c= GHOSTS; m++) {\n    const w = (es[m] / tot) ** 4;\n    wr += w * col[3 * m];\n    wg += w * col[3 * m + 1];\n    wb += w * col[3 * m + 2];\n    ws += w;\n  }\n  ws = max(ws, 1e-9);\n  const sr = wr / ws, sg = wg / ws, sb = wb / ws;\n  rgb.fill(0);\n  // Lobes: mode m as the envelope it would swing through if it held its\n  // energy alone, |sin(pi m y / L)| wide, outlined in its colour. A mode\n  // holding under 5% of the energy is not drawn; from 20% it is at full.\n  for (let m = 1; m \u003c= GHOSTS; m++) {\n    const sh = es[m] / tot, w = sc * sqrt(es[m] / EREF), lv = 0.85 * sm(0.05, 0.2, sh);\n    if (w \u003c 0.8 || lv \u003c= 0) continue;\n    const cr = col[3 * m] * lv, cg = col[3 * m + 1] * lv, cb = col[3 * m + 2] * lv, L = N * DY;\n    for (let y = 0; y \u003c H; y++) {\n      const hw0 = w * abs(sin((PI * m * (y - Y0)) / L)), hw1 = w * abs(sin((PI * m * (y + 1 - Y0)) / L));\n      const lo = min(hw0, hw1) - 0.6, hi = max(hw0, hw1) + 0.6;\n      for (let x = max(0, floor(CX - lo + 1)); x \u003c= min(W - 1, floor(CX + lo - 1)); x++) {\n        const q = (y * W + x) * 3;\n        rgb[q] = max(rgb[q], FILL * cr);\n        rgb[q + 1] = max(rgb[q + 1], FILL * cg);\n        rgb[q + 2] = max(rgb[q + 2], FILL * cb);\n      }\n      for (const sgn of [-1, 1]) {\n        const xa = CX + sgn * lo, xb = CX + sgn * hi;\n        for (let x = max(0, floor(min(xa, xb))); x \u003c= min(W - 1, floor(max(xa, xb))); x++) {\n          const q = (y * W + x) * 3;\n          rgb[q] = max(rgb[q], cr);\n          rgb[q + 1] = max(rgb[q + 1], cg);\n          rgb[q + 2] = max(rgb[q + 2], cb);\n        }\n      }\n    }\n  }\n  // The string, straight between masses, and the 31 masses on it.\n  for (let y = 0; y \u003c H; y++) {\n    const xa = colAt(u, y, sc), xb = colAt(u, y + 1, sc), x0 = floor(min(xa, xb) - 0.4), x1 = floor(max(xa, xb) + 0.4);\n    for (let x = max(0, x0); x \u003c= min(W - 1, x1); x++) {\n      const q = (y * W + x) * 3;\n      rgb[q] = 0.25 + 0.75 * sr;\n      rgb[q + 1] = 0.25 + 0.75 * sg;\n      rgb[q + 2] = 0.25 + 0.75 * sb;\n    }\n  }\n  for (let i = 1; i \u003c N; i++) {\n    const bx = CX + sc * u[i], by = Y0 + i * DY;\n    for (let y = floor(by - 1); y \u003c= floor(by + 1); y++)\n      for (let x = floor(bx - 1); x \u003c= floor(bx + 1); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n        if ((x + 0.5 - bx) ** 2 + (y + 0.5 - by) ** 2 > 1.2) continue;\n        const q = (y * W + x) * 3;\n        rgb[q] = rgb[q + 1] = rgb[q + 2] = 1;\n      }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","graveyard-fog":"// ===== Patternflow pattern =====\n// Title:   Graveyard Fog\n// Family:  halloween\n// Idea:    Banks of ground fog roll sideways at three depths through a night graveyard of black headstones, a cross, a leaning stone and a crooked iron fence under a thin crescent moon, the mist carrying a fine one-LED dither like suspended droplets, while small toxic-green will-o'-wisps bob and drift between the stones and light the fog round them.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wisps=4..14, Fog=0..1\n//\n// Knob 1: Hue. Turns the fog, the sky and the wisps round the wheel together. At 0 the fog is a cold periwinkle under a deep violet sky and the wisps are toxic green; at 0.25 the fog goes rose and the wisps sky blue; at 0.6 the fog is green under a dark green sky and the wisps pink. From about 0.2 to 0.53, where the sky would come out maroon, brown or olive, it is held purple instead.\n// Knob 2: Speed. How fast the fog rolls: at 2 the front bank slides 9 LEDs a second, the middle one 4.5 and the far one 2.5, and a wisp bobs once in about 4 seconds; at 0.2 everything runs ten times slower, at 3 half as fast again.\n// Knob 3: Wisps. How many will-o'-wisps there are, 4 to 14. Each one floats at its own depth, so a stone or the fence can hide it as it passes, and lights the fog for about 10 LEDs round it. Every wisp past the fourth also gives all the fog 3% of their green, so at 14 the banks have a green cast.\n// Knob 4: Fog. How high and thick the banks stand. Near 0 the front bank reaches the knees of the near stones; at 1 it climbs past the crossbar of the cross, the middle bank swallows the fence, the far bank rises half again and the haze over the sky thickens by a third.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Value noise on a 256 x 256 lattice of fixed random values.\nconst NT = new Float32Array(65536);\nfor (let i = 0; i \u003c 65536; i++) NT[i] = hash(i * 7 + 3);\nfunction vn(x, y) {\n  const xi = floor(x), yi = floor(y);\n  let fx = x - xi, fy = y - yi;\n  fx = fx * fx * (3 - 2 * fx);\n  fy = fy * fy * (3 - 2 * fy);\n  const x0 = xi & 255, x1 = (xi + 1) & 255, y0 = (yi & 255) \u003c\u003c 8, y1 = ((yi + 1) & 255) \u003c\u003c 8;\n  const a = NT[y0 + x0], b = NT[y0 + x1], c = NT[y1 + x0], d = NT[y1 + x1];\n  return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;\n}\n\n// ---- The graveyard, built once as coverage masks (4 x 4 samples per LED).\n// Far row: small stones standing on a low rise at row 84.\nconst FAR_BASE = 84;\n// Front row: three big stones on the ground at row 125.\nconst FRONT_BASE = 125;\n// The fence stands on row 111.\nconst FENCE_BASE = 111;\n\nfunction roundStone(px, py, cx, base, w, h, lean) {\n  const dx = px - cx, dy = py - base, c = cos(lean), s = sin(lean);\n  const lx = dx * c - dy * s, ly = dx * s + dy * c, r = w / 2;\n  if (ly > 1 || abs(lx) > r || ly \u003c -h) return false;\n  const top = -h + r;\n  return ly >= top || lx * lx + (ly - top) * (ly - top) \u003c= r * r;\n}\nfunction gableStone(px, py, cx, base, w, h, peak) {\n  const dx = abs(px - cx), up = base - py;\n  if (up \u003c -1 || up > h || dx > w / 2) return false;\n  return up \u003c= h - peak || dx \u003c= ((w / 2) * (h - up)) / peak;\n}\nfunction cross(px, py, cx, base, h, bw, aw, ay, at) {\n  const dx = abs(px - cx), up = base - py;\n  if (up \u003c -1) return false;\n  if (up \u003c= h && dx \u003c= bw / 2) return true;\n  if (dx \u003c= aw / 2 && abs(up - ay) \u003c= at / 2) return true;\n  return up \u003c= 4 && dx \u003c= 6.5;\n}\n\nfunction farInside(px, py) {\n  if (py >= FAR_BASE + 1.5 * sin(px * 0.16 + 1)) return true;\n  return (\n    roundStone(px, py, 4, FAR_BASE + 1, 7, 10, -0.05) ||\n    cross(px, py, 16, FAR_BASE + 1, 14, 2.4, 8, 10, 2.2) ||\n    gableStone(px, py, 26.5, FAR_BASE + 1, 6, 9, 3) ||\n    roundStone(px, py, 38, FAR_BASE + 1, 8, 11, 0.12) ||\n    gableStone(px, py, 50, FAR_BASE + 1, 3.4, 15, 4) ||\n    roundStone(px, py, 60, FAR_BASE + 1, 6, 8, 0)\n  );\n}\n\nfunction frontInside(px, py) {\n  if (py >= FRONT_BASE + 1.2 * sin(px * 0.11 + 2)) return true;\n  return (\n    roundStone(px, py, 11.5, FRONT_BASE + 1, 15, 31, -0.03) ||\n    cross(px, py, 32, FRONT_BASE + 1, 39, 5, 18, 29, 5) ||\n    roundStone(px, py, 51.5, FRONT_BASE + 1, 13, 27, 0.24)\n  );\n}\n\n// The fence: thin iron pickets with spear tips, leaning this way and that,\n// on two sagging rails; one picket snapped short and one gone.\nconst PICKETS = [];\nfor (let i = 0; i \u003c 13; i++) {\n  if (i === 9) continue;\n  PICKETS.push({\n    x: 2.5 + 5 * i + (hash(i * 5 + 1) - 0.5) * 1.2,\n    lean: (hash(i * 5 + 2) - 0.5) * 0.16,\n    top: FENCE_BASE - 18 + (hash(i * 5 + 3) - 0.5) * 3 + (i === 5 ? 7 : 0),\n    tip: i !== 5,\n  });\n}\nconst RAILS = [FENCE_BASE - 5, FENCE_BASE - 14].map((y0, r) => PICKETS.map((p, i) => y0 + (hash(i * 11 + r * 3 + 7) - 0.5) * 2.4));\nfunction fenceInside(px, py) {\n  if (py > FENCE_BASE + 0.5) return false;\n  for (const p of PICKETS) {\n    const cx = p.x + p.lean * (FENCE_BASE - py);\n    if (py >= p.top && abs(px - cx) \u003c= 0.62) return true;\n    if (p.tip && py \u003c p.top && py >= p.top - 3.2 && abs(px - cx) \u003c= ((py - (p.top - 3.2)) / 3.2) * 1.7) return true;\n  }\n  for (const rail of RAILS)\n    for (let i = 0; i + 1 \u003c PICKETS.length; i++) {\n      const a = PICKETS[i], b = PICKETS[i + 1];\n      if (px \u003c a.x || px > b.x) continue;\n      const f = (px - a.x) / (b.x - a.x), y = rail[i] + (rail[i + 1] - rail[i]) * f;\n      if (abs(py - y) \u003c= 0.62) return true;\n    }\n  return false;\n}\n\nfunction buildMask(inside) {\n  const m = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      let c = 0;\n      for (let j = 0; j \u003c 4; j++) for (let i = 0; i \u003c 4; i++) if (inside(x + (i + 0.5) / 4, y + (j + 0.5) / 4)) c++;\n      m[y * W + x] = c / 16;\n    }\n  return m;\n}\n\n// The crescent: a disc of radius 6.5 with a slightly smaller one cut from its\n// lower left, so a thin bow is left on the upper right.\nconst MOON_X = 47, MOON_Y = 19;\nfunction moonInside(px, py) {\n  const a = (px - MOON_X) ** 2 + (py - MOON_Y) ** 2, b = (px - MOON_X + 2.6) ** 2 + (py - MOON_Y - 1.4) ** 2;\n  return a \u003c= 6.5 * 6.5 && b > 6.1 * 6.1;\n}\n\n// Fog banks, back to front: the row they lie on, how high they stand at the\n// opening, how fast they slide at Speed 2 (LEDs a second), how much the Fog\n// knob raises them, how bright they are and how thick, and how big their\n// billows are.\nconst BANKS = [\n  { base: 86, h: 18, v: 2.5, rise: 0.5, lum: 0.62, op: 0.8, sx: 12, sy: 7, seed: 17 },\n  { base: 114, h: 22, v: 4.5, rise: 1.3, lum: 0.8, op: 0.84, sx: 15, sy: 8, seed: 59 },\n  { base: 131, h: 20, v: 9, rise: 2, lum: 1, op: 0.9, sx: 17, sy: 9, seed: 101 },\n];\n// Wisp depth slots: 0 behind the far stones, 1 between them and the fence,\n// 2 between the fence and the near stones, 3 in front of everything. Each\n// slot has the rows a wisp there floats at.\nconst SLOT_ROWS = [[72, 80], [86, 100], [98, 112], [108, 120]];\nconst WMAX = 14;\n// Grain: neighbouring LEDs alternate half a step above and below the fog,\n// so the mist carries a fine ordered dither. GRAIN is the half step at full\n// fog, in levels of 255.\nconst GRAIN = 16, AIR = 0.2;\n\nexport function setup(params) {\n  const wisps = [];\n  // The first four, the opening count, take slots 1, 2, 3 and 1 and are\n  // spread across the width; the rest are placed at random.\n  const open = [[1, 10], [2, 44], [3, 24], [1, 56]];\n  for (let i = 0; i \u003c WMAX; i++) {\n    const slot = i \u003c 4 ? open[i][0] : floor(Math.random() * 4);\n    const [r0, r1] = SLOT_ROWS[slot];\n    wisps.push({\n      slot,\n      x0: i \u003c 4 ? open[i][1] : Math.random() * W,\n      y0: r0 + Math.random() * (r1 - r0),\n      dir: Math.random() \u003c 0.5 ? -1 : 1,\n      v: 1.2 + Math.random() * 2,\n      ph: Math.random() * 2 * PI,\n      bob: 2 + Math.random() * 2.5,\n      flick: 0.6 + Math.random() * 0.8,\n    });\n  }\n  params.s = {\n    hue: 0, speed: 2, count: 4, fog: 0.06, t: 0,\n    far: buildMask(farInside), fence: buildMask(fenceInside), front: buildMask(frontInside), moon: buildMask(moonInside),\n    wisps, wx: new Float32Array(WMAX), wy: new Float32Array(WMAX), wb: new Float32Array(WMAX),\n    // Light the wisps cast on the fog, and their own glow at each depth.\n    lit: new Float32Array(N), glow: [new Float32Array(N), new Float32Array(N), new Float32Array(N), new Float32Array(N)],\n    tops: [new Float32Array(W), new Float32Array(W), new Float32Array(W)],\n    sky: new Float32Array(H * 3), fogC: [0, 0, 0], wispC: [0, 0, 0], hazeC: [0, 0, 0], colHue: NaN,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = round(cl(k[2], 4, WMAX));\n  S.fog = cl(k[3], 0, 1);\n  // The pattern's clock: one unit a second at Speed 2.\n  S.t += (d * S.speed) / 2;\n  const t = S.t;\n  for (let i = 0; i \u003c WMAX; i++) {\n    const w = S.wisps[i];\n    // Drift with the fog plus a slow wander, wrapping round the width.\n    let x = w.x0 + w.dir * w.v * t + 7 * sin(0.5 * t + w.ph);\n    x = ((((x + 8) % (W + 16)) + (W + 16)) % (W + 16)) - 8;\n    S.wx[i] = x;\n    S.wy[i] = w.y0 + w.bob * sin(1.6 * t + w.ph) + 1.1 * sin(3.7 * t + 2 * w.ph);\n    S.wb[i] = 0.82 + 0.18 * sin(w.flick * 9 * t + w.ph) * sin(w.flick * 5.3 * t);\n  }\n}\n\nfunction palette(S) {\n  const h = S.hue;\n  // Fog: cold periwinkle at Hue 0.\n  hsv(h + 0.68, 0.32, 1, S.fogC);\n  // Wisps: toxic yellow-green at Hue 0, always 0.6 of the wheel from the fog.\n  hsv(h + 0.28, 0.82, 1, S.wispC);\n  // Sky: a deep version of the fog's hue, a little further round. A dark\n  // sky from red through orange to yellow-green reads maroon, brown or\n  // olive, so across that stretch it is blended over to purple (0.8).\n  const sh = h + 0.73, dw = abs(((sh - 0.09 + 10.5) % 1) - 0.5), w = 1 - sm(0.17, 0.21, dw);\n  const c = [0, 0, 0], e = [0, 0, 0];\n  for (let y = 0; y \u003c H; y++) {\n    // Darkest at the top, a hazy glow toward the horizon at row 80.\n    const u = sm(0, 84, y), sat = 0.75 - 0.2 * u, val = 0.1 + 0.22 * u * u;\n    hsv(sh, sat, val, c);\n    hsv(0.8, sat, val, e);\n    for (let i = 0; i \u003c 3; i++) S.sky[y * 3 + i] = (c[i] + (e[i] - c[i]) * w) * 255;\n  }\n  hsv(sh, 0.45, 0.5, c);\n  hsv(0.8, 0.45, 0.5, e);\n  for (let i = 0; i \u003c 3; i++) S.hazeC[i] = c[i] + (e[i] - c[i]) * w;\n  S.colHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  const { far, fence, front, moon, lit, glow, tops, sky, fogC, wispC, hazeC, t } = S;\n  const fog = S.fog, thick = 0.88 + 0.12 * fog;\n  // Every wisp past the first four adds 3% of their green to all the fog.\n  const amb = 0.03 * (S.count - 4), dropOff = 1.5 * t;\n\n  // Each bank's top edge along the width: its height times a billow that\n  // slides with it.\n  for (let b = 0; b \u003c 3; b++) {\n    const B = BANKS[b], off = B.v * t, tp = tops[b], rise = 0.8 + B.rise * fog;\n    for (let x = 0; x \u003c W; x++) tp[x] = B.base - B.h * rise * (0.45 + 0.8 * vn((x + off) / B.sx, B.seed + 0.13 * t));\n  }\n\n  // Wisp light.\n  lit.fill(0);\n  for (const g of glow) g.fill(0);\n  for (let i = 0; i \u003c S.count; i++) {\n    const wx = S.wx[i], wy = S.wy[i], wb = S.wb[i], g = glow[S.wisps[i].slot], R = 13;\n    for (let y = max(0, floor(wy - R)); y \u003c= min(H - 1, floor(wy + R)); y++)\n      for (let x = max(0, floor(wx - R)); x \u003c= min(W - 1, floor(wx + R)); x++) {\n        const dx = x + 0.5 - wx, dy = y + 0.5 - wy, d2 = dx * dx + dy * dy;\n        if (d2 > R * R) continue;\n        const p = y * W + x;\n        lit[p] += wb * exp(-d2 / 70);\n        g[p] += wb * (sm(2.2, 0.8, sqrt(d2)) + 0.45 * exp(-d2 / 7));\n      }\n  }\n\n  const hazeOff = 1.6 * t;\n  for (let y = 0; y \u003c H; y++) {\n    const sr = sky[y * 3], sg = sky[y * 3 + 1], sb = sky[y * 3 + 2];\n    // High haze: thin at the top, thicker toward the horizon, in slow streaks.\n    const hz = (0.3 + 0.5 * sm(0, 90, y)) * (0.7 + 0.6 * fog);\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r = sr, g = sg, b = sb;\n      // The moon and a faint halo round it.\n      const md = (x + 0.5 - MOON_X) ** 2 + (y + 0.5 - MOON_Y) ** 2;\n      if (md \u003c 400) {\n        const halo = 30 * exp(-md / 90);\n        r += halo;\n        g += halo;\n        b += halo * 0.9;\n      }\n      const mo = moon[p];\n      if (mo > 0) {\n        r += (250 - r) * mo;\n        g += (240 - g) * mo;\n        b += (205 - b) * mo;\n      }\n      // Mist in view along the line of sight, for the grain: the night air\n      // itself counts for AIR, then the haze and banks add to it.\n      let seen = 0;\n      const ha = min(0.85, hz * (0.15 + 1.3 * vn((x + hazeOff) / 21, y / 5 + 40)));\n      r += (hazeC[0] * 255 - r) * ha;\n      g += (hazeC[1] * 255 - g) * ha;\n      b += (hazeC[2] * 255 - b) * ha;\n      seen = AIR + (1 - AIR) * ha;\n      for (let layer = 0; layer \u003c 3; layer++) {\n        // Wisps at this depth, then this depth's silhouettes, then the bank in front of them.\n        const gl = glow[layer];\n        if (gl[p] > 0) {\n          const a = min(1, gl[p]);\n          r += (wispC[0] * 255 + 120 - r) * a;\n          g += (wispC[1] * 255 + 120 - g) * a;\n          b += (wispC[2] * 255 + 120 - b) * a;\n        }\n        const m = layer === 0 ? far[p] : layer === 1 ? fence[p] : front[p];\n        if (m > 0) {\n          const sc = layer === 0 ? 0.11 : layer === 1 ? 0.05 : 0.025;\n          r += (hazeC[0] * 255 * sc - r) * m;\n          g += (hazeC[1] * 255 * sc - g) * m;\n          b += (hazeC[2] * 255 * sc - b) * m;\n          seen *= 1 - m;\n        }\n        const B = BANKS[layer], top = tops[layer][x];\n        if (y > top - 6) {\n          const body = sm(top - 6, top + 8, y) * (0.3 + 1.0 * vn((x + B.v * 1.35 * t) / (B.sx * 0.6), y / B.sy + B.seed - 0.25 * t));\n          const a = min(0.95, body * B.op * thick);\n          if (a > 0) {\n            const L = lit[p] + amb, lv = B.lum * 255, keep = 1 - 0.25 * min(1, L);\n            const fr = fogC[0] * lv * keep + wispC[0] * 230 * L;\n            const fg = fogC[1] * lv * keep + wispC[1] * 230 * L;\n            const fb = fogC[2] * lv * keep + wispC[2] * 230 * L;\n            r += (fr - r) * a;\n            g += (fg - g) * a;\n            b += (fb - b) * a;\n            seen = seen + (1 - seen) * a;\n          }\n        }\n      }\n      if (glow[3][p] > 0) {\n        const a = min(1, glow[3][p]);\n        r += (wispC[0] * 255 + 120 - r) * a;\n        g += (wispC[1] * 255 + 120 - g) * a;\n        b += (wispC[2] * 255 + 120 - b) * a;\n      }\n      r = min(255, r);\n      g = min(255, g);\n      b = min(255, b);\n      // The grain: half a step up on one colour of the checker, half down on\n      // the other, scaled by the fog in view and kept inside 0..255.\n      const m = max(r, g, b, 1);\n      // Droplets: the half step swells and shrinks over a few LEDs, and that\n      // pattern drifts with the air, so the dither reads as moving mist\n      // rather than a ruled grid.\n      const drop = 0.7 + 0.3 * vn((x + dropOff) / 2.3, y / 2.3 + 90);\n      const amp = min(GRAIN * min(1, 2.4 * seen) * drop, 0.45 * m, 0.45 * (255 - m));\n      const f = (m + ((x + y) & 1 ? amp : -amp)) / m;\n      display.setPixel(x, y, round(r * f), round(g * f), round(b * f));\n    }\n  }\n}\n","haunted-manor":"// ===== Patternflow pattern =====\n// Title:   Haunted Manor\n// Family:  halloween\n// Idea:    A crooked house with two spired towers and a dead tree stands on a hill under a violet storm, rain slanting across, and every few seconds a branching bolt cracks down behind it, the sky flashes pale violet and the house goes stark black while its orange and green windows flicker, a figure passes behind one and a shutter bangs.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Storm=0..1, Lights=0..1\n//\n// Knob 1: Hue. The storm's tint, kept to the cool side of the wheel so the dim sky never reads brown: violet at 0, blue at 0.25, teal at 0.5, sea green at 0.75 and a sickly green at 1. The flash pales the same hue; the windows stay orange and green.\n// Knob 2: Speed. Rain falls at 115 LEDs a second at 2, so a drop crosses the panel in about a second; 30 at 0.2 and 160 at 3. Clouds, candle flicker, the figure and the shutter run on the same clock, and the gaps between strikes stretch by 2 over Speed, though never past 2.9 times; a flash always lasts the same half second.\n// Knob 3: Storm. At 0 a strike comes every 4.2 seconds on average (each gap 0.6 to 1.4 times that) and 90 drops a second fall; at 1 every 1.1 seconds and 330 drops. The first strike always comes 2.4 seconds after the start, down behind the house; later ones may hit the tall spire or the tree.\n// Knob 4: Lights. How many of the thirteen windows are lit: 2 at 0, 3 at the opening 0.06, 8 at 0.5 and all 13 at 1, each with a one-LED glow on the wall round it. Every 4 to 8 seconds one room goes dark and another lights. The wet ground under the house mirrors the lower windows and the door, broken into rippling rows.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// A fixed generator for the house and the tree, so they never change with\n// the knobs; Math.random is left for the weather.\nfunction prng(seed) {\n  let a = seed >>> 0;\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0;\n    let t = a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n// Smooth value noise on a 16 x 16 lattice that wraps.\nconst LAT = new Float32Array(256);\n{\n  const r = prng(7);\n  for (let i = 0; i \u003c 256; i++) LAT[i] = r();\n}\nfunction noise(x, y) {\n  const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n  const u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);\n  const a = LAT[(yi & 15) * 16 + (xi & 15)], b = LAT[(yi & 15) * 16 + ((xi + 1) & 15)];\n  const c = LAT[((yi + 1) & 15) * 16 + (xi & 15)], d = LAT[((yi + 1) & 15) * 16 + ((xi + 1) & 15)];\n  return mix(mix(a, b, u), mix(c, d, u), v);\n}\n\n// The hill's top edge.\nconst hillTop = (x) => 101 + 0.0075 * (x - 20) * (x - 20);\n\n// The house, part by part: a polygon and how far it leans, in LEDs per row\n// above row 108. Windows are rectangles (or a circle) in the part they sit in.\nconst PARTS = [\n  { lean: 0.03, pts: [[1, 50], [11, 50], [11, 108], [1, 108]] },\n  { lean: 0.03, pts: [[-1, 51], [13, 51], [8.5, 34], [10, 15], [5.5, 32]] },\n  { lean: -0.012, pts: [[10, 74], [36, 74], [36, 108], [10, 108]] },\n  { lean: -0.012, pts: [[7.5, 75], [38.5, 75], [24.5, 48], [22.5, 46.5], [20.5, 49]] },\n  { lean: 0.05, pts: [[29, 64], [32, 64], [32, 53], [29, 53]] },\n  { lean: 0.05, pts: [[28, 53], [33, 53], [33, 51], [28, 51]] },\n  { lean: -0.045, pts: [[34, 68], [43, 68], [43, 106], [34, 106]] },\n  { lean: -0.045, pts: [[32, 69], [45, 69], [38.5, 49]] },\n  { lean: -0.012, pts: [[17, 92], [29, 92], [23, 87]] },\n];\n// Windows: part, x0, y0, width, height (or round with a radius), colour\n// 0 orange, 1 green. The order is the order they light in as Lights rises.\nconst WINDOWS = [\n  { part: 2, x: 11, y: 77, w: 9, h: 10, c: 0 },\n  { part: 3, round: true, x: 22.5, y: 63, r: 3.2, c: 1 },\n  { part: 2, x: 26, y: 92, w: 9, h: 10, c: 0 },\n  { part: 0, x: 4, y: 56, w: 5, h: 9, c: 1, arch: true },\n  { part: 2, x: 26, y: 77, w: 9, h: 10, c: 0 },\n  { part: 6, x: 36, y: 74, w: 5, h: 8, c: 0, arch: true },\n  { part: 2, x: 20.5, y: 94, w: 5, h: 14, c: 0, arch: true, door: true },\n  { part: 0, x: 4, y: 72, w: 5, h: 9, c: 0 },\n  { part: 2, x: 11, y: 92, w: 9, h: 10, c: 1 },\n  { part: 1, x: 6, y: 38, w: 3, h: 5, c: 0, arch: true },\n  { part: 3, x: 13, y: 67, w: 3, h: 4, c: 0 },\n  { part: 3, x: 29, y: 67, w: 3, h: 4, c: 1 },\n  { part: 6, x: 36, y: 89, w: 5, h: 8, c: 0, arch: true },\n];\nconst NW = WINDOWS.length;\n// The tip of the tall spire, leant.\nconst SPIRE = [10 + 0.03 * (108 - 15), 15];\n\nfunction inPoly(pts, x, y) {\n  let c = false;\n  for (let i = 0, j = pts.length - 1; i \u003c pts.length; j = i++) {\n    const [xi, yi] = pts[i], [xj, yj] = pts[j];\n    if (yi > y !== yj > y && x \u003c ((xj - xi) * (y - yi)) / (yj - yi) + xi) c = !c;\n  }\n  return c;\n}\n\n// The dead tree: branches as segments, each with its parent, grown once from\n// a fixed seed. Each frame they are laid out again with the wind's sway.\nfunction growTree() {\n  const r = prng(31), segs = [];\n  const grow = (parent, ang, len, depth, width) => {\n    const i = segs.length;\n    segs.push({ parent, ang, len, width, depth });\n    if (depth >= 5 || len \u003c 3) return;\n    const kids = depth \u003c 2 ? 2 : r() \u003c 0.35 ? 3 : 2;\n    for (let k = 0; k \u003c kids; k++) {\n      const spread = (k - (kids - 1) / 2) * (0.55 + 0.35 * r()) + (r() - 0.5) * 0.3;\n      grow(i, ang + spread, len * (0.62 + 0.18 * r()), depth + 1, max(1, width - 1));\n    }\n  };\n  grow(-1, -PI / 2 + 0.1, 22, 0, 3);\n  return segs;\n}\nconst TREE_X = 55;\n\n// Branch ends for a given sway, root first; each branch bends with the wind\n// in proportion to how far out it is.\nfunction layTree(tree, sway, ends) {\n  for (let i = 0; i \u003c tree.length; i++) {\n    const g = tree[i];\n    const x0 = g.parent \u003c 0 ? TREE_X : ends[g.parent][2], y0 = g.parent \u003c 0 ? hillTop(TREE_X) + 2 : ends[g.parent][3];\n    const a = g.ang + sway * g.depth;\n    ends[i] = [x0, y0, x0 + cos(a) * g.len, y0 + sin(a) * g.len];\n  }\n  return ends;\n}\n\nexport function setup(params) {\n  const house = new Uint8Array(N), win = new Int8Array(N).fill(-1), pane = new Uint8Array(N);\n  // Window pixels keep their place in the window, for mullions and figures.\n  const wx = new Float32Array(N), wy = new Float32Array(N);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, X = x + 0.5, Y = y + 0.5;\n      if (Y >= hillTop(X)) house[p] = 2;\n      for (let k = 0; k \u003c PARTS.length; k++) {\n        const part = PARTS[k], sx = X - part.lean * (108 - Y);\n        if (inPoly(part.pts, sx, Y)) house[p] = 1;\n      }\n      for (let n = 0; n \u003c NW; n++) {\n        const w = WINDOWS[n], part = PARTS[w.part], sx = X - part.lean * (108 - Y);\n        let inside = false, u = 0, v = 0;\n        if (w.round) {\n          const dx = sx - w.x, dy = Y - w.y;\n          inside = dx * dx + dy * dy \u003c= w.r * w.r;\n          u = dx;\n          v = dy;\n          if (inside && (abs(dx) \u003c 0.5 || abs(dy) \u003c 0.5)) pane[p] = 1;\n        } else {\n          inside = sx >= w.x && sx \u003c w.x + w.w && Y >= w.y && Y \u003c w.y + w.h;\n          u = sx - w.x;\n          v = Y - w.y;\n          if (inside && w.arch && v \u003c 1 && (u \u003c 1 || u >= w.w - 1)) inside = false;\n          if (inside && !w.door && w.w > 3 && (floor(u) === floor(w.w / 2) || floor(v) === floor(w.h * 0.4))) pane[p] = 1;\n        }\n        if (inside) {\n          win[p] = n;\n          wx[p] = u;\n          wy[p] = v;\n        }\n      }\n    }\n  const tree = growTree(), still = layTree(tree, 0, []);\n  let treeTop = [TREE_X, 99];\n  for (const e of still) if (e[3] \u003c treeTop[1]) treeTop = [e[2], e[3]];\n  // A one-LED glow round each window on the wall: which window, and how\n  // strong (full beside an edge, less at a corner).\n  const halo = new Int8Array(N).fill(-1), haloW = new Float32Array(N);\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x;\n      if (house[p] !== 1 || win[p] >= 0) continue;\n      for (const [dx, dy, wt] of [[1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1], [1, 1, 0.5], [-1, 1, 0.5], [1, -1, 0.5], [-1, -1, 0.5]]) {\n        const n = win[p + dy * W + dx];\n        if (n >= 0 && wt > haloW[p]) (halo[p] = n), (haloW[p] = wt);\n      }\n    }\n  params.s = {\n    hue: 0, speed: 2, storm: 0, lights: 0.06,\n    t: 0, clock: 0, house, win, pane, wx, wy, halo, haloW,\n    tree, treeMask: new Uint8Array(N), ends: [], treeTop,\n    drops: [], dropCarry: 0,\n    // Windows: how lit each is (0..1), the flicker phase, and the order.\n    lit: new Float32Array(NW), fl: new Float32Array(NW),\nwant: new Uint8Array(NW), order: WINDOWS.map((_, i) => i),\n    swapAt: 6, gust: 0,\n    // Lightning: when the strike began, its strokes, the bolt as a field.\n    strikeAt: -99, nextStrike: 2.4, strikes: 0, strokes: [], bolt: new Float32Array(N), boltX: 32,\n    figure: null, figureAt: 4, shutter: null, shutterAt: 3,\n    rgb: new Float32Array(3), sky: new Float32Array(3), buf: new Float32Array(N * 3),\n  };\n}\n\n// The bolt: a jagged main channel by midpoint displacement from the top of\n// the panel to its target, and a few branches peeling off it.\nfunction makeBolt(S) {\n  const b = S.bolt;\n  b.fill(0);\n  // The first strike comes down behind the house; later ones may hit the\n  // tall spire or the top of the tree instead.\n  const first = S.strikes++ === 0, pick = first ? 1 : Math.random();\n  const x0 = first ? 30 + Math.random() * 16 : 6 + Math.random() * 52;\n  let tx, ty;\n  if (pick \u003c 0.2) (tx = SPIRE[0]), (ty = SPIRE[1]);\n  else if (pick \u003c 0.35) (tx = S.treeTop[0]), (ty = S.treeTop[1]);\n  else (tx = first ? 22 + Math.random() * 14 : 4 + Math.random() * 56), (ty = 100);\n  S.boltX = (x0 + tx) / 2;\n  const path = (ax, ay, bx, by, rough, depth, out) => {\n    if (depth === 0) {\n      out.push([bx, by]);\n      return;\n    }\n    const L = sqrt((bx - ax) ** 2 + (by - ay) ** 2);\n    const mx = (ax + bx) / 2 + (Math.random() - 0.5) * L * rough, my = (ay + by) / 2 + (Math.random() - 0.5) * L * rough * 0.3;\n    path(ax, ay, mx, my, rough, depth - 1, out);\n    path(mx, my, bx, by, rough, depth - 1, out);\n  };\n  const line = (pts, level) => {\n    for (let i = 1; i \u003c pts.length; i++) {\n      const [ax, ay] = pts[i - 1], [bx, by] = pts[i], n = max(1, Math.ceil(max(abs(bx - ax), abs(by - ay)) * 2));\n      for (let s = 0; s \u003c= n; s++) {\n        const x = floor(ax + ((bx - ax) * s) / n), y = floor(ay + ((by - ay) * s) / n);\n        if (x >= 0 && x \u003c W && y >= 0 && y \u003c H && b[y * W + x] \u003c level) b[y * W + x] = level;\n      }\n    }\n  };\n  const main = [[x0, -2]];\n  path(x0, -2, tx, ty, 0.55, 6, main);\n  line(main, 1);\n  const branches = 2 + floor(Math.random() * 3);\n  for (let k = 0; k \u003c branches; k++) {\n    const at = main[3 + floor(Math.random() * (main.length * 0.6))];\n    const side = Math.random() \u003c 0.5 ? -1 : 1, len = 12 + Math.random() * 22;\n    const br = [[at[0], at[1]]];\n    path(at[0], at[1], at[0] + side * len * 0.8, at[1] + len * 0.7, 0.6, 4, br);\n    line(br, 0.55);\n  }\n  // A glow one LED round the channel.\n  const glow = Float32Array.from(b);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (b[p] > 0) continue;\n      let g = 0;\n      if (x > 0) g = max(g, glow[p - 1]);\n      if (x \u003c W - 1) g = max(g, glow[p + 1]);\n      if (y > 0) g = max(g, glow[p - W]);\n      if (y \u003c H - 1) g = max(g, glow[p + W]);\n      b[p] = 0.45 * g;\n    }\n  // Two to four return strokes down the same channel.\n  S.strokes = [0];\n  const extra = 1 + floor(Math.random() * 3);\n  for (let k = 0; k \u003c extra; k++) S.strokes.push(S.strokes[k] + 0.07 + Math.random() * 0.09);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.storm = cl(k[2], 0, 1);\n  S.lights = cl(k[3], 0, 1);\n  const sp = S.speed / 2, ds = d * sp;\n  S.t += d;\n  S.clock += ds;\n  S.gust = 0.5 + 0.5 * sin(S.clock * 0.7 + 1.5 * sin(S.clock * 0.23));\n\n  // Lightning on the knob's clock, except the first, at 2.4 s.\n  if (S.t >= S.nextStrike) {\n    S.strikeAt = S.t;\n    makeBolt(S);\n    const mean = mix(4.2, 1.1, S.storm);\n    S.nextStrike = S.t + (mean * (0.6 + 0.8 * Math.random())) / max(0.35, sp);\n  }\n\n  // Rain: drops spawned at the top at a rate set by Storm.\n  const rate = mix(90, 330, S.storm) * sp;\n  S.dropCarry += rate * d;\n  const vy0 = 95 * sp + 20;\n  while (S.dropCarry >= 1) {\n    S.dropCarry -= 1;\n    S.drops.push({ x: -20 + Math.random() * (W + 30), y: -8 - Math.random() * 20, v: vy0 * (0.8 + 0.4 * Math.random()), l: 3 + floor(Math.random() * 4), a: 0.5 + 0.5 * Math.random() });\n  }\n  const slant = 0.18 + 0.22 * S.gust;\n  for (const r of S.drops) {\n    r.y += r.v * d;\n    r.x += r.v * slant * d;\n  }\n  S.drops = S.drops.filter((r) => r.y \u003c H + 8 && r.y \u003c hillTop(r.x) + 6);\n  S.slant = slant;\n\n  // Windows: the first n of the order want light; now and then one room goes\n  // dark and another lights.\n  const n = round(2 + 11 * S.lights);\n  if (S.clock >= S.swapAt && n \u003c NW) {\n    S.swapAt = S.clock + 4 + 4 * Math.random();\n    const a = floor(Math.random() * n), b = n + floor(Math.random() * (NW - n));\n    [S.order[a], S.order[b]] = [S.order[b], S.order[a]];\n  }\n  S.want.fill(0);\n  for (let i = 0; i \u003c n; i++) S.want[S.order[i]] = 1;\n  for (let i = 0; i \u003c NW; i++) S.lit[i] = cl(S.lit[i] + (S.want[i] ? 1 : -1) * d * 3, 0, 1);\n  if (S.t \u003c d * 1.5) for (let i = 0; i \u003c NW; i++) S.lit[i] = S.want[i];\n\n  // A figure crossing a lit window, left to right or right to left.\n  if (!S.figure && S.clock >= S.figureAt) {\n    const cands = [0, 2, 4, 8].filter((i) => S.lit[i] > 0.9);\n    if (cands.length) S.figure = { w: cands[floor(Math.random() * cands.length)], u: 0, dir: Math.random() \u003c 0.5 ? 1 : -1 };\n    S.figureAt = S.clock + 5 + 5 * Math.random();\n  }\n  if (S.figure) {\n    S.figure.u += ds / 1.8;\n    if (S.figure.u >= 1) S.figure = null;\n  }\n  // A shutter banging shut and swinging open on a gust.\n  if (!S.shutter && S.clock >= S.shutterAt) {\n    const cands = [];\n    for (let i = 0; i \u003c NW; i++) if (S.lit[i] > 0.9 && !WINDOWS[i].round) cands.push(i);\n    if (cands.length) S.shutter = { w: cands[floor(Math.random() * cands.length)], u: 0 };\n    S.shutterAt = S.clock + 4 + 5 * Math.random();\n  }\n  if (S.shutter) {\n    S.shutter.u += ds;\n    if (S.shutter.u >= 1.2) S.shutter = null;\n  }\n}\n\n// How bright the strike is t seconds after it began: a spike for each\n// return stroke and a slow afterglow.\nfunction flashAt(S, t) {\n  if (t \u003c 0 || t > 3) return [0, 0, 0];\n  let spike = 0, chan = 0;\n  for (const s of S.strokes)\n    if (t >= s) {\n      spike = max(spike, exp(-(t - s) / 0.05));\n      chan = max(chan, exp(-(t - s) / 0.12));\n    }\n  return [spike, exp(-t / 0.55), chan];\n}\n\n// How much of the window a shutter covers, from its hinge: shut in 0.06 s,\n// open again, a smaller swing back, and still by 1.2.\nfunction shutterCover(u) {\n  if (u \u003c 0.06) return u / 0.06;\n  if (u \u003c 0.3) return 1 - sm(0.06, 0.3, u);\n  if (u \u003c 0.5) return 0.6 * sm(0.3, 0.42, u) * (1 - sm(0.42, 0.5, u));\n  if (u \u003c 0.75) return 0.25 * sm(0.5, 0.6, u) * (1 - sm(0.6, 0.75, u));\n  return 0;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { house, win, pane, wx, wy, bolt, lit, halo, haloW } = S;\n  const ts = S.t - S.strikeAt, [spike, glow, chan] = flashAt(S, ts);\n  // The channel stays a moment after the strokes as a fading violet trace.\n  const flash = min(1, 0.62 * spike + 0.3 * glow), boltOn = max(chan, 0.3 * glow * glow);\n  const skyH = 0.76 - 0.44 * S.hue, col = S.rgb, lite = S.sky;\n  // What the sky turns to at full flash: the storm's own hue, pale.\n  hsv(skyH, 0.32, 1, lite);\n  // The tree, laid out with the wind.\n  const tm = S.treeMask;\n  tm.fill(0);\n  const sway = (S.gust - 0.5) * 0.08 + 0.02 * sin(S.clock * 5.3);\n  const ends = layTree(S.tree, sway, S.ends);\n  for (let i = 0; i \u003c S.tree.length; i++) {\n    const g = S.tree[i], [x0, y0, x1, y1] = ends[i];\n    const steps = Math.ceil(g.len * 2), hw = g.width / 2;\n    for (let s = 0; s \u003c= steps; s++) {\n      const x = x0 + ((x1 - x0) * s) / steps, y = y0 + ((y1 - y0) * s) / steps;\n      for (let yy = floor(y - hw + 0.5); yy \u003c= floor(y + hw - 0.5); yy++)\n        for (let xx = floor(x - hw + 0.5); xx \u003c= floor(x + hw - 0.5); xx++) if (xx >= 0 && xx \u003c W && yy >= 0 && yy \u003c H) tm[yy * W + xx] = 1;\n    }\n  }\n  // The figure's place, in the window's own columns.\n  const fig = S.figure, fw = fig ? WINDOWS[fig.w] : null;\n  const fx = fig ? (fig.dir > 0 ? mix(-3, fw.w + 3, fig.u) : mix(fw.w + 3, -3, fig.u)) : 0;\n  const sh = S.shutter, shCover = sh ? shutterCover(sh.u) : 0;\n  const rgb = S.buf, fl = S.fl;\n  for (let n = 0; n \u003c NW; n++) fl[n] = lit[n] * (0.78 + 0.22 * noise(S.clock * 7 + n * 3.7, n * 5.1));\n  for (let y = 0; y \u003c H; y++) {\n    const yt = y / 100;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, q = p * 3;\n      let r, g, b;\n      const hm = house[p] || tm[p];\n      if (!hm) {\n        // Sky: a violet gradient, brighter toward the hill, with storm\n        // clouds drifting across, lit up by the flash nearest the bolt.\n        const c1 = noise(x / 20 + S.clock * 0.25, y / 13 + 2), c2 = noise(x / 11 + S.clock * 0.45 + 5, y / 8);\n        const cloud = cl((0.75 * c1 + 0.25 * c2 - 0.35) * 1.8, 0, 1) * (1 - sm(0.3, 0.85, yt));\n        hsv(skyH + 0.03 * yt, 0.72 - 0.15 * yt - 0.25 * cloud, 0.2 + 0.2 * yt + 0.16 * cloud, col);\n        const near = 0.55 + 0.45 * exp(-((x - S.boltX) ** 2) / 600);\n        const f = flash * near * (0.85 + 0.25 * cloud);\n        r = mix(col[0], lite[0], f);\n        g = mix(col[1], lite[1], f);\n        b = mix(col[2], lite[2], f);\n        const bl = bolt[p] * boltOn;\n        if (bl > 0) {\n          const wt = min(1, chan * 2);\n          r = mix(r, mix(lite[0], 1, wt), bl);\n          g = mix(g, mix(lite[1], 1, wt), bl);\n          b = mix(b, mix(lite[2], 1, wt), bl);\n        }\n      } else {\n        // Hill, house and tree: dark, and black while the sky is lit.\n        const k = 1 - min(1, flash * 2.2);\n        r = 0.07 * k;\n        g = 0.04 * k;\n        b = 0.1 * k;\n        const n = house[p] === 1 ? win[p] : -1;\n        if (house[p] === 2 && !tm[p] && y > 108) {\n          // The wet ground under the house mirrors what is lit above row\n          // 108, each row shifted a little and some rows dropped, more of\n          // them further down. Rows above are already drawn, so it copies.\n          const dy = y - 108, sy = 216 - y, sx = x + round(0.9 * sin(dy * 3.1 + S.clock * 4));\n          if (sx >= 0 && sx \u003c W && sin(dy * 2.3 - S.clock * 5) > -0.6 + dy / 16) {\n            const sp = sy * W + sx;\n            if (house[sp] === 1 && win[sp] >= 0) {\n              r = 0.8 * rgb[sp * 3];\n              g = 0.8 * rgb[sp * 3 + 1];\n              b = 0.8 * rgb[sp * 3 + 2];\n            }\n          }\n        }\n        const hn = house[p] === 1 ? halo[p] : -1;\n        if (hn >= 0 && fl[hn] > 0) {\n          const a = 0.42 * haloW[p] * fl[hn] * k, c = WINDOWS[hn].c;\n          r += ((c ? 0.45 : 1) - r) * a;\n          g += ((c ? 1 : 0.5) - g) * a;\n          b += ((c ? 0.18 : 0.1) - b) * a;\n        }\n        if (n >= 0 && lit[n] > 0) {\n          const w = WINDOWS[n];\n          let on = fl[n];\n          if (pane[p]) on *= 0.15;\n          if (fig && fig.w === n) {\n            const u = wx[p], v = wy[p], du = u - fx;\n            if (du * du + (v - 2.2) ** 2 \u003c 2.6 || (v > 3.6 && abs(du) \u003c 1.2 + 0.6 * (v - 3.6))) on *= 0.06;\n          }\n          if (sh && sh.w === n && wx[p] >= w.w * (1 - shCover)) on *= 0.04;\n          if (w.c === 0) (r = 1 * on), (g = 0.5 * on), (b = 0.1 * on);\n          else (r = 0.45 * on), (g = 1 * on), (b = 0.18 * on);\n        }\n      }\n      rgb[q] = r;\n      rgb[q + 1] = g;\n      rgb[q + 2] = b;\n    }\n  }\n  // Rain over everything, pale, turning white while the sky is lit.\n  const sl = S.slant, rl = mix(0.28, 0.85, flash);\n  for (const d of S.drops) {\n    for (let s = 0; s \u003c d.l; s++) {\n      const x = floor(d.x - sl * s), y = floor(d.y - s);\n      if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n      const q = (y * W + x) * 3, a = d.a * rl * (1 - s / (d.l + 1));\n      rgb[q] += (0.75 - rgb[q]) * a;\n      rgb[q + 1] += (0.72 - rgb[q + 1]) * a;\n      rgb[q + 2] += (0.95 - rgb[q + 2]) * a;\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","knights-tour":"// ===== Patternflow pattern =====\n// Title:   Knight's Tour\n// Family:  algo\n// Idea:    A knight tours an 8 by 16 chessboard of 8-LED squares filling the panel by Warnsdorff's rule, always jumping to the unvisited square with the fewest onward moves, each jump leaving a 1-LED line from centre to centre over the dotted lines of the tour before, until the 127 lines of a whole tour show whether it closed and fade, and the next tour starts from another square.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: knight's tour by Warnsdorff's rule (H. C. von Warnsdorff, 1823), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.25..12, Board=0..1, Stray=0..1\n//\n// Knob 1: Hue. Turns the tour's colours round the wheel. At 0 the first jumps are cyan and the last violet, the newest jumps near white, and a closed tour's jump home gold; at 0.5 the tour runs from red through orange and yellow to green and the jump home is blue.\n// Knob 2: Speed. Jumps a second. At 2 a jump takes half a second, the knight gliding the 18 LEDs from centre to centre in 0.36 s and resting on its square for the rest, so a tour of 127 jumps takes about a minute; at 0.25 a jump takes 4 s, at 12 a whole tour takes 11 s.\n// Knob 3: Board. Columns of squares: 8 at 0, 7 at 0.25, 6 at 0.5, 5 at 0.75 and 4 at 1, always with twice as many rows, so the board fills the panel with squares from 8 to 16 LEDs. A new board starts with a tour run up to four fifths at 40 jumps a second. No board 4 squares wide has a closed tour (Schwenk, 1991), so at 1 every tour ends open.\n// Knob 4: Stray. The chance that the knight ignores the rule and takes any legal jump. Up to 0.1 it never strays, and a tour that would dead-end on an unlucky tie (2.2% of them on 8 by 16, 81% on 4 by 8) is drawn again with other ties, so every tour completes. Past 0.1 the chance climbs to 1 at 1: at 0.2 four tours in ten complete, at 0.3 one in ten, and at 1 the knight wanders at random and is stuck after about 60 of the 128 squares. A stuck square flashes red three times and a red cross marks each square left unvisited.\n\nconst W = 64, H = 128;\nconst { floor, round, min, max, abs, exp, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => {\n  const t = cl(v, 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst MOVES = [[1, 2], [2, 1], [2, -1], [1, -2], [-1, -2], [-2, -1], [-2, 1], [-1, 2]];\n// Stray at or under DEAD never strays; a tour that dead-ends is re-rolled up to TRIES times.\nconst DEAD = 0.1, TRIES = 400;\n// The opening shows a tour this far in, so the first frames already hold a web.\nconst HEAD = 0.8;\n// Share of each jump spent gliding; the rest the knight rests on its square.\nconst GLIDE = 0.72;\n// Seconds for the end: the sweep along the tour, the hold, the fade.\nconst SWEEP = 3, HOLD = 1.6, FADE = 2, STUCK = 2.2;\n// Hue at knob 0, and how far round the wheel the tour's colours run.\nconst HUE0 = 0.52, SPAN = 0.3;\n// Line colour: saturation and value a line settles to, the ghost's value,\n// and the tint of a visited light and dark square.\nconst SAT = 0.75, VAL = 1, GHOST = 0.85, TINT = [0.09, 0];\n// A square just reached glows WAKE brighter, fading over the next WAKEN jumps.\nconst WAKE = 0.34, WAKEN = 6;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\nexport function setup(params) {\n  params.s = {\n    begun: false, ghost: null, hue: 0, speed: 2, stray: 0.06, planStray: 0.06, boardWait: 0,\n    C: 0, R: 0, N: 0, path: null, vis: null, cx: null, cy: null, xs: null, ys: null,\n    len: 0, at: 0, phase: 0, ff: 0, lastStart: -1,\n    mode: \"run\", mt: 0, closed: false,\n    rgb: new Float32Array(W * H * 3), c3: new Float32Array(3), gold: new Float32Array(3),\n  };\n}\n\nconst colsOf = (k) => 8 - round(cl(k, 0, 1) * 4);\nconst strayP = (k) => (k \u003c= DEAD ? 0 : (k - DEAD) / (1 - DEAD));\n\nfunction newBoard(P, C) {\n  const R = 2 * C, N = C * R, sx = W / C;\n  Object.assign(P, { C, R, N, path: new Int16Array(N), vis: new Uint8Array(N), cx: new Int16Array(N), cy: new Int16Array(N) });\n  // Square (c, r) covers LEDs xs[c]..xs[c+1]-1 and ys[r]..ys[r+1]-1; its\n  // centre LED is the one just up and left of the middle when the side is even.\n  P.xs = Array.from({ length: C + 1 }, (_, c) => round(c * sx));\n  P.ys = Array.from({ length: R + 1 }, (_, r) => round(r * sx));\n  for (let q = 0; q \u003c N; q++) {\n    const c = q % C, r = floor(q / C);\n    P.cx[q] = floor((P.xs[c] + P.xs[c + 1] - 1) / 2);\n    P.cy[q] = floor((P.ys[r] + P.ys[r + 1] - 1) / 2);\n  }\n  P.lastStart = -1;\n}\n\n// Unvisited squares one knight's move from q.\nfunction onward(P, q, list) {\n  const { C, R, vis } = P, x = q % C, y = floor(q / C);\n  let n = 0;\n  for (const [dx, dy] of MOVES) {\n    const a = x + dx, b = y + dy;\n    if (a \u003c 0 || a >= C || b \u003c 0 || b >= R) continue;\n    const t = b * C + a;\n    if (vis[t]) continue;\n    if (list) list[n] = t;\n    n++;\n  }\n  return n;\n}\n\n// Plan the rest of the tour after path[0..from]. Warnsdorff's rule: the next\n// square is the unvisited neighbour with the fewest unvisited neighbours of\n// its own, ties broken at random; with probability p any unvisited neighbour.\nfunction plan(P, from) {\n  const { N, path, vis } = P, p = strayP(P.stray), tries = p === 0 ? TRIES : 1;\n  const cand = new Int16Array(8), best = new Int16Array(8);\n  P.planStray = P.stray;\n  for (let t = 0; t \u003c tries; t++) {\n    vis.fill(0);\n    for (let i = 0; i \u003c= from; i++) vis[path[i]] = 1;\n    let n = from + 1, q = path[from];\n    while (n \u003c N) {\n      const k = onward(P, q, cand);\n      if (!k) break;\n      let next;\n      if (p > 0 && Math.random() \u003c p) next = cand[floor(Math.random() * k)];\n      else {\n        let lo = 99, m = 0;\n        for (let j = 0; j \u003c k; j++) {\n          const d = onward(P, cand[j], null);\n          if (d \u003c lo) (lo = d), (m = 0);\n          if (d === lo) best[m++] = cand[j];\n        }\n        next = best[floor(Math.random() * m)];\n      }\n      path[n++] = next;\n      vis[next] = 1;\n      q = next;\n    }\n    P.len = n;\n    if (n === N) break;\n  }\n}\n\nconst isMove = (P, a, b) => {\n  const dx = abs((a % P.C) - (b % P.C)), dy = abs(floor(a / P.C) - floor(b / P.C));\n  return (dx === 1 && dy === 2) || (dx === 2 && dy === 1);\n};\n\n// A new tour from a square other than the last one's start, shown `head` of\n// the way in at once (the opening), or run up to there at 40 jumps a second\n// (`ff`, after the board changes), or from its first square.\nfunction startTour(P, head, ff, fresh) {\n  if (fresh) {\n    // A new board has no tour before it, so one is run for the ghost.\n    P.path[0] = floor(Math.random() * P.N);\n    plan(P, 0);\n    P.lastStart = P.path[0];\n  }\n  P.ghost = P.path.slice(0, P.len);\n  let s = floor(Math.random() * P.N);\n  if (s === P.lastStart) s = (s + 1 + floor(Math.random() * (P.N - 1))) % P.N;\n  P.lastStart = s;\n  P.path[0] = s;\n  plan(P, 0);\n  const target = min(round(head * P.N), max(0, P.len - 7));\n  P.at = ff ? 0 : target;\n  P.ff = ff ? target : 0;\n  P.phase = 0;\n  P.mode = \"run\";\n  P.mt = 0;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.25, 12);\n  P.stray = cl(k[3], 0, 1);\n  const cols = colsOf(k[2]);\n  if (!P.begun) {\n    P.begun = true;\n    newBoard(P, cols);\n    startTour(P, HEAD, false, true);\n    return;\n  }\n  // The board changes once the knob has rested 0.4 s on a new size.\n  if (cols !== P.C) {\n    P.boardWait += d;\n    if (P.boardWait >= 0.4) {\n      newBoard(P, cols);\n      startTour(P, HEAD, true, true);\n      P.boardWait = 0;\n    }\n  } else P.boardWait = 0;\n  // Stray moved: plan again from the square the knight is jumping to.\n  if (P.mode === \"run\" && abs(P.stray - P.planStray) > 0.02 && P.at + 1 \u003c P.len) plan(P, P.at + 1);\n\n  P.mt += d;\n  if (P.mode === \"run\") {\n    const rate = P.at \u003c P.ff ? 40 : P.speed;\n    P.phase += d * rate;\n    while (P.phase >= 1 && P.mode === \"run\") {\n      P.phase -= 1;\n      P.at++;\n      if (P.at >= P.len - 1) {\n        P.phase = 0;\n        P.mt = 0;\n        if (P.len === P.N) (P.mode = \"end\"), (P.closed = isMove(P, P.path[P.N - 1], P.path[0]));\n        else P.mode = \"stuck\";\n      }\n    }\n  } else if (P.mode === \"end\") {\n    // A closed tour first jumps home along the closing line, one jump long.\n    const home = P.closed ? 1 / P.speed : 0;\n    if (P.mt > home + SWEEP + HOLD) (P.mode = \"fade\"), (P.mt = 0);\n  } else if (P.mode === \"stuck\") {\n    if (P.mt > STUCK) (P.mode = \"fade\"), (P.mt = 0);\n  } else if (P.mode === \"fade\") {\n    if (P.mt >= FADE) startTour(P, 0, false, false);\n  }\n}\n\n// Paint the line between the centres of squares a and b up to share f of\n// the way from a. The LEDs are worked out from the lower-numbered end, so a\n// jump and its reverse light the same LEDs.\nfunction seg(P, a, b, f, r, g, bl, odd = 1) {\n  const { rgb } = P;\n  const flip = a > b, p = flip ? b : a, q = flip ? a : b;\n  const x0 = P.cx[p], y0 = P.cy[p], dx = P.cx[q] - x0, dy = P.cy[q] - y0, n = max(abs(dx), abs(dy));\n  const lim = f * n + 1e-6;\n  for (let i = 0; i \u003c= n; i++) {\n    if ((flip ? n - i : i) > lim) continue;\n    const x = x0 + round((dx * i) / n), y = y0 + round((dy * i) / n);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const o = (y * W + x) * 3, m = i & 1 ? odd : 1;\n    if (m \u003c= 0) continue;\n    (rgb[o] = r * m), (rgb[o + 1] = g * m), (rgb[o + 2] = bl * m);\n  }\n}\n\nfunction box(P, q, r, g, b, inset) {\n  const { rgb } = P, c = q % P.C, w = floor(q / P.C);\n  const x0 = P.xs[c] + inset, x1 = P.xs[c + 1] - 1 - inset, y0 = P.ys[w] + inset, y1 = P.ys[w + 1] - 1 - inset;\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      if (x !== x0 && x !== x1 && y !== y0 && y !== y1) continue;\n      const o = (y * W + x) * 3;\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n}\n\nfunction fill(P, q, r, g, b) {\n  const { rgb } = P, c = q % P.C, w = floor(q / P.C);\n  for (let y = P.ys[w]; y \u003c P.ys[w + 1]; y++)\n    for (let x = P.xs[c]; x \u003c P.xs[c + 1]; x++) {\n      const o = (y * W + x) * 3;\n      (rgb[o] = r), (rgb[o + 1] = g), (rgb[o + 2] = b);\n    }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || !P.begun) return;\n  const { rgb, c3, path, N, C, ghost } = P;\n  rgb.fill(0);\n  const base = HUE0 + P.hue, gold = P.gold;\n  const hueOf = (i) => base + (SPAN * i) / (N - 1);\n  // The knight's place: e is how far along jump `at` it has glided.\n  const run = P.mode === \"run\";\n  const e = run ? sm(P.phase / GLIDE) : 0;\n  const done = P.at + e; // jumps made, counting the glide\n  const last = run ? P.at : P.len - 1; // squares path[0..last] are visited\n  // u runs 0 to 1 over the fade, while this tour turns into the next one's ghost.\n  const u = P.mode === \"fade\" ? sm(P.mt / FADE) : 0, keep = 1 - u;\n\n  // Visited squares: a faint tint in the colour of the jump that reached\n  // them, lighter on the light squares of the chessboard.\n  for (let i = 0; i \u003c= min(last + (run ? 1 : 0), P.len - 1); i++) {\n    const q = path[i], w = cl((done - i + 0.5) * 2, 0, 1) * keep;\n    if (w \u003c= 0) continue;\n    const light = ((q % C) + floor(q / C)) % 2 === 0;\n    hsv(hueOf(i), 0.75, ((light ? TINT[0] : TINT[1]) + WAKE * exp(-max(0, done - i) / WAKEN)) * w, c3, 0);\n    fill(P, q, c3[0], c3[1], c3[2]);\n  }\n  // The tour before this one, dotted: every other LED of each of its lines.\n  if (ghost && keep > 0)\n    for (let i = 0; i + 1 \u003c ghost.length; i++) {\n      hsv(hueOf(i), 0.85, GHOST * keep, c3, 0);\n      seg(P, ghost[i], ghost[i + 1], 1, c3[0], c3[1], c3[2], 0);\n    }\n\n  // The lines, oldest first so the newest lie on top. A line fresh from the\n  // knight is near white; over the next jumps it settles into its colour.\n  // In the fade they dim to the ghost's level and lose every other LED.\n  // The end's sweep: a gold light runs the tour in order, from the first\n  // jump to the last. On a closed tour it carries on over the jump home and\n  // keeps going round, since the tour is a loop.\n  const end = P.mode === \"end\", home = P.closed ? 1 / P.speed : 0;\n  const sweepAt = end ? ((P.mt - home) / SWEEP) * (N - 1 + (P.closed ? 1 : 0)) : -1e9;\n  hsv(base + 0.62, 0.62, 1, gold, 0);\n  const sweep = (c, lag) => {\n    if (sweepAt \u003c 0) return;\n    if (P.closed) lag = ((lag % N) + N) % N;\n    if (lag \u003c 0 || lag >= 14) return;\n    const w = exp(-lag / 3.5);\n    for (let j = 0; j \u003c 3; j++) c[j] += (gold[j] - c[j]) * w;\n  };\n  for (let i = 0; i \u003c last + (run ? 1 : 0) && i \u003c P.len - 1; i++) {\n    const age = max(0, done - i - 1), f = i \u003c P.at ? 1 : e;\n    if (f \u003c= 0) continue;\n    const s = SAT - (SAT - 0.1) * exp(-age / 2.5), v = VAL + (1 - VAL) * exp(-age / 3);\n    hsv(hueOf(i), s, v * keep + GHOST * u, c3, 0);\n    sweep(c3, sweepAt - i);\n    seg(P, path[i], path[i + 1], f, c3[0], c3[1], c3[2], keep);\n  }\n  let mx = -1, my = -1;\n  if (end || (P.mode === \"fade\" && P.len === N)) {\n    const a = path[N - 1], b = path[0];\n    if (P.closed) {\n      // The jump home, gold, drawn at the knight's pace.\n      const f = end ? sm((P.mt * P.speed) / GLIDE) : 1;\n      hsv(base + 0.62, 0.7, keep, c3, 0);\n      sweep(c3, sweepAt - (N - 1));\n      seg(P, a, b, f, c3[0], c3[1], c3[2]);\n      if (f \u003c 1) (mx = P.cx[a] + (P.cx[b] - P.cx[a]) * f), (my = P.cy[a] + (P.cy[b] - P.cy[a]) * f);\n    } else {\n      // An open tour: once the sweep reaches the end, its two ends are boxed.\n      const w = (end ? cl(sweepAt - (N - 1) + 1, 0, 1) : 1) * keep;\n      hsv(base + 0.62, 0.7, w, c3, 0);\n      box(P, a, c3[0], c3[1], c3[2], 1);\n      box(P, b, c3[0], c3[1], c3[2], 1);\n    }\n  }\n  if (P.mode === \"stuck\" || (P.mode === \"fade\" && P.len \u003c N)) {\n    // Stuck: a small red cross on each square the walk can no longer reach.\n    const seen = new Uint8Array(N);\n    for (let i = 0; i \u003c P.len; i++) seen[path[i]] = 1;\n    for (let q = 0; q \u003c N; q++) {\n      if (seen[q]) continue;\n      const x = P.cx[q], y = P.cy[q], w = 0.7 * keep;\n      for (const [dx, dy] of [[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]) {\n        const o = ((y + dy) * W + x + dx) * 3;\n        (rgb[o] = w), (rgb[o + 1] = 0.1 * w), (rgb[o + 2] = 0.15 * w);\n      }\n    }\n  }\n  if (P.mode === \"stuck\") {\n    // The square the knight is stuck on flashes three times.\n    const w = sin((PI * 3 * P.mt) / STUCK) ** 2;\n    fill(P, path[P.len - 1], 0.95 * w, 0.12 * w, 0.1 * w);\n  }\n  if (run) {\n    const a = path[P.at], b = path[min(P.at + 1, P.len - 1)];\n    (mx = P.cx[a] + (P.cx[b] - P.cx[a]) * e), (my = P.cy[a] + (P.cy[b] - P.cy[a]) * e);\n  }\n  if (mx >= 0) {\n    // The knight: a white point in a soft round glow that swells as it\n    // lands and settles while it rests.\n    const land = run && P.at > 0 ? exp(-((P.phase - GLIDE + 1) % 1) / 0.3) : 0, gr = 7 + 7 * land, ga = 0.75 + 0.25 * land;\n    for (let py = floor(my) - 5; py \u003c= floor(my) + 6; py++)\n      for (let px = floor(mx) - 5; px \u003c= floor(mx) + 6; px++) {\n        if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n        const r2 = (px - mx) ** 2 + (py - my) ** 2, l = r2 \u003c 0.3 ? 1 : ga * exp(-r2 / gr);\n        if (l \u003c 0.04) continue;\n        const o = (py * W + px) * 3;\n        (rgb[o] = max(rgb[o], l)), (rgb[o + 1] = max(rgb[o + 1], l * 0.95)), (rgb[o + 2] = max(rgb[o + 2], l * 0.85));\n      }\n  }\n  for (let y = 0, o = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o += 3) display.setPixel(x, y, min(255, rgb[o] * 255), min(255, rgb[o + 1] * 255), min(255, rgb[o + 2] * 255));\n}\n","morley-triangle":"// ===== Patternflow pattern =====\n// Title:   Morley Triangle\n// Family:  geometry\n// Idea:    A triangle bigger than the panel is wide keeps changing shape, and the three points where the angle trisectors next to each side meet always form an equilateral triangle, filled bright gold among the six flat triangles the trisectors cut, turning, growing and shrinking while the big one writhes.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Morley's trisector theorem (Frank Morley, 1899), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Wander=0..1, Exterior=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together. At 0 the equilateral triangle is gold and the three triangles on the sides of the big one are teal, blue and magenta; the rest of the big triangle stays dim slate at every hue, and a side triangle that lands between orange and yellow is paled and lifted so it does not read brown.\n// Knob 2: Speed. How fast the shape changes. At 2 the angles swing from about 60, 60, 60 out to their widest and back in about 10 seconds; at 0.2 it takes 95 seconds, at 3 about 6.\n// Knob 3: Wander. How far the angles roam. At 0 they stay between 31 and 103 degrees and the equilateral triangle's side between 14 and 21 LEDs; at 1 they reach 12 and 132 degrees, a sliver lying along the panel's diagonal whose Morley triangle shrinks to 6 LEDs a side.\n// Knob 4: Exterior. Draws the exterior Morley triangle behind the big one: the points where the trisectors of the exterior angles meet beyond each side, also always equilateral, its sides parallel to the inner one's and 7 to 17 times as long, so mostly its edges cross the panel. Up to 0.1 nothing; its edge comes up to full by 0.6, and from 0.4 a dim fill grows inside it.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, round, PI } = Math;\nconst TAU = 2 * PI, DEG = PI / 180;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// Smallest and largest angle the triangle may take at Wander 1, in degrees.\nconst AMIN = 12, AMAX = 132;\n// How far past the panel's edge the triangle's box may reach, in LEDs: a\n// corner may leave the panel sideways by up to OX and up or down by up to OY.\nconst OX = 12, OY = 2;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, wander: 0, ext: 0.06,\n    tau: 0, theta: NaN,\n    ang: new Float64Array(3),\n    // Panel corners A, B, C, the Morley points P (by BC), Q (by CA), R (by AB)\n    // and the exterior ones P', Q', R'.\n    v: new Float64Array(6), m: new Float64Array(6), e: new Float64Array(6),\n    lab: new Uint8Array(W * H), col: new Float32Array(9 * 3), colHue: NaN,\n  };\n}\n\n// The angles at time tau: a point in the plane a + b + c = 180 that swings\n// out from 60, 60, 60 toward a corner or an edge of the allowed region and\n// back, turning as it goes so every vertex takes its turn at being obtuse.\nfunction angles(S) {\n  const t = S.tau, roam = 0.6 + 0.4 * S.wander;\n  const phi = 0.23 * t + 1.3 * sin(0.071 * t + 0.4);\n  const e = 0.55 - 0.45 * cos(0.47 * t + 0.9 * sin(0.13 * t) + 0.9);\n  const c = [cos(phi), cos(phi - TAU / 3), cos(phi + TAU / 3)];\n  let rmax = 1e9;\n  for (const ck of c) rmax = min(rmax, ck > 0 ? (AMAX - 60) / ck : ck \u003c 0 ? (60 - AMIN) / -ck : 1e9);\n  const rho = roam * e * rmax;\n  for (let k = 0; k \u003c 3; k++) S.ang[k] = 60 + rho * c[k];\n}\n\n// The triangle with these angles, side V0V1 of length 1, about its centroid.\nfunction canonical(ang) {\n  const [a, b, c] = ang, L = sin(b * DEG) / sin(c * DEG);\n  const x = [0, 1, L * cos(a * DEG)], y = [0, 0, L * sin(a * DEG)];\n  const gx = (x[0] + x[1] + x[2]) / 3, gy = (y[0] + y[1] + y[2]) / 3;\n  return [x[0] - gx, y[0] - gy, x[1] - gx, y[1] - gy, x[2] - gx, y[2] - gy];\n}\n\n// The scale at which the triangle, turned by th, just fits inside the panel.\nfunction fit(T, th) {\n  const c = cos(th), s = sin(th);\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let k = 0; k \u003c 3; k++) {\n    const x = T[2 * k] * c - T[2 * k + 1] * s, y = T[2 * k] * s + T[2 * k + 1] * c;\n    x0 = min(x0, x), x1 = max(x1, x), y0 = min(y0, y), y1 = max(y1, y);\n  }\n  return { k: min((W + 2 * OX) / (x1 - x0), (H + 2 * OY) / (y1 - y0)), cx: (x0 + x1) / 2, cy: (y0 + y1) / 2 };\n}\n\n// Where the ray from p along d meets the ray from q along e.\nfunction meet(px, py, dx, dy, qx, qy, ex, ey, out, o) {\n  const den = dx * ey - dy * ex, t = ((qx - px) * ey - (qy - py) * ex) / den;\n  out[o] = px + t * dx;\n  out[o + 1] = py + t * dy;\n}\n\n// The trisector from vertex i nearest the side towards vertex j: the unit\n// vector from i to j turned a third of the angle at i towards the third\n// vertex, or with ext a third of the exterior angle, 180 less the angle,\n// away from it.\nfunction trisector(v, ang, i, j, out, ext) {\n  const k = 3 - i - j;\n  let ux = v[2 * j] - v[2 * i], uy = v[2 * j + 1] - v[2 * i + 1];\n  const ul = sqrt(ux * ux + uy * uy);\n  ux /= ul;\n  uy /= ul;\n  const wx = v[2 * k] - v[2 * i], wy = v[2 * k + 1] - v[2 * i + 1], dp = wx * ux + wy * uy;\n  let nx = wx - dp * ux, ny = wy - dp * uy;\n  const nl = sqrt(nx * nx + ny * ny);\n  nx /= ext ? -nl : nl;\n  ny /= ext ? -nl : nl;\n  const t = ((ext ? 180 - ang[i] : ang[i]) * DEG) / 3;\n  out[0] = ux * cos(t) + nx * sin(t);\n  out[1] = uy * cos(t) + ny * sin(t);\n}\n\nconst PAIRS = [[1, 2], [2, 1], [2, 0], [0, 2], [0, 1], [1, 0]];\nconst D = [new Float64Array(2), new Float64Array(2), new Float64Array(2), new Float64Array(2), new Float64Array(2), new Float64Array(2)];\n\nfunction place(S, d) {\n  angles(S);\n  const T = canonical(S.ang);\n  // Turn towards the angle at which the triangle fits largest, preferring\n  // angles near the current one so it does not flip between equal fits.\n  if (S.theta !== S.theta) {\n    let top = -1;\n    for (let n = 0; n \u003c 90; n++) {\n      const th = (n / 90) * PI, sc = fit(T, th).k;\n      if (sc > top) (top = sc), (S.theta = th);\n    }\n  }\n  let best = -1, target = S.theta;\n  for (let n = 0; n \u003c 60; n++) {\n    const th = S.theta + ((n - 30) / 30) * (PI / 2), u = (th - S.theta) / (PI / 2);\n    const sc = fit(T, th).k * (1 - 0.22 * u * u);\n    if (sc > best) (best = sc), (target = th);\n  }\n  S.theta += (target - S.theta) * min(1, d);\n  const F = fit(T, S.theta), c = cos(S.theta), s = sin(S.theta);\n  for (let k = 0; k \u003c 3; k++) {\n    const x = T[2 * k] * c - T[2 * k + 1] * s, y = T[2 * k] * s + T[2 * k + 1] * c;\n    S.v[2 * k] = W / 2 + (x - F.cx) * F.k;\n    S.v[2 * k + 1] = H / 2 + (y - F.cy) * F.k;\n  }\n  // Morley points: P where the trisectors of B and C next to BC meet, Q for\n  // C and A next to CA, R for A and B next to AB; then the same with the\n  // exterior trisectors, P', Q' and R' beyond the sides.\n  const v = S.v, a = S.ang;\n  for (const [ext, out] of [[false, S.m], [true, S.e]]) {\n    for (let n = 0; n \u003c 6; n++) trisector(v, a, PAIRS[n][0], PAIRS[n][1], D[n], ext);\n    for (let n = 0; n \u003c 3; n++) {\n      const i = PAIRS[2 * n][0], j = PAIRS[2 * n][1];\n      meet(v[2 * i], v[2 * i + 1], D[2 * n][0], D[2 * n][1], v[2 * j], v[2 * j + 1], D[2 * n + 1][0], D[2 * n + 1][1], out, 2 * n);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.wander = cl(k[2], 0, 1);\n  S.ext = cl(k[3], 0, 1);\n  S.tau += d * S.speed * 0.7;\n  place(S, d * (0.6 + 0.6 * S.speed));\n}\n\n// Inside test for triangle p0 p1 p2 at (x, y), either winding.\nfunction inside(x, y, ax, ay, bx, by, cx, cy) {\n  const e0 = (bx - ax) * (y - ay) - (by - ay) * (x - ax);\n  const e1 = (cx - bx) * (y - by) - (cy - by) * (x - bx);\n  const e2 = (ax - cx) * (y - cy) - (ay - cy) * (x - cx);\n  return (e0 >= 0 && e1 >= 0 && e2 >= 0) || (e0 \u003c= 0 && e1 \u003c= 0 && e2 \u003c= 0);\n}\n\nfunction palette(S) {\n  const col = S.col, h0 = S.hue + 0.13;\n  // 1 Morley, 2..4 the side triangles, 5 the dim rest, 6 the rim of ABC,\n  // 7 the rim of the exterior Morley triangle.\n  hsv(h0, 0.62, 1, col, 3);\n  const sides = [0.34, 0.49, 0.71];\n  for (let n = 0; n \u003c 3; n++) {\n    const h = h0 + sides[n], hf = h - floor(h), band = max(0, 1 - abs(hf - 0.12) / 0.13);\n    hsv(h, 0.82 - 0.25 * band, 0.62 + 0.3 * band, col, 6 + 3 * n);\n  }\n  // The dim rest stays slate whatever the hue: a dim warm colour reads brown.\n  hsv(0.68, 0.5, 0.19, col, 15);\n  hsv(h0 + 0.55, 0.25, 0.8, col, 18);\n  hsv(h0, 0.35, 1, col, 21);\n  S.colHue = S.hue;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  if (S.colHue !== S.hue) palette(S);\n  const { v, m, e, lab, col } = S;\n  const [ax, ay, bx, by, cx, cy] = v, [px, py, qx, qy, rx, ry] = m;\n  const amt = sm(0.1, 0.6, S.ext), fill = 0.8 * sm(0.4, 1, S.ext);\n  // Edge lines of the exterior Morley triangle as unit normals pointing in,\n  // so a point's distance inside is the least of three dot products.\n  const nrm = [];\n  if (amt > 0) {\n    const turn = (e[2] - e[0]) * (e[5] - e[1]) - (e[3] - e[1]) * (e[4] - e[0]) > 0 ? 1 : -1;\n    for (let k = 0; k \u003c 3; k++) {\n      const x0 = e[2 * k], y0 = e[2 * k + 1], x1 = e[(2 * k + 2) % 6], y1 = e[(2 * k + 3) % 6], L = sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2);\n      nrm.push([(-(y1 - y0) * turn) / L, ((x1 - x0) * turn) / L, x0, y0]);\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const X = x + 0.5, Y = y + 0.5;\n      let l = 0;\n      if (inside(X, Y, ax, ay, bx, by, cx, cy)) {\n        if (inside(X, Y, px, py, qx, qy, rx, ry)) l = 1;\n        else if (inside(X, Y, bx, by, cx, cy, px, py)) l = 2;\n        else if (inside(X, Y, cx, cy, ax, ay, qx, qy)) l = 3;\n        else if (inside(X, Y, ax, ay, bx, by, rx, ry)) l = 4;\n        else l = 5;\n      }\n      lab[y * W + x] = l;\n    }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, l = lab[p];\n      let r = 0, g = 0, b = 0;\n      if (l > 0) {\n        let o = l * 3;\n        if ((x > 0 && lab[p - 1] === 0) || (x \u003c W - 1 && lab[p + 1] === 0) || (y > 0 && lab[p - W] === 0) || (y \u003c H - 1 && lab[p + W] === 0)) o = 18;\n        (r = col[o]), (g = col[o + 1]), (b = col[o + 2]);\n      } else if (amt > 0) {\n        // Behind the triangle, the exterior Morley triangle: an edge two\n        // LEDs wide in the hero's colour, paled, and a dim fill.\n        let d = 1e9;\n        for (const [nx, ny, x0, y0] of nrm) d = min(d, (x + 0.5 - x0) * nx + (y + 0.5 - y0) * ny);\n        if (d >= 0 && d \u003c 1.6) (r = col[21] * amt), (g = col[22] * amt), (b = col[23] * amt);\n        else if (d >= 1.6) (r = col[15] * fill), (g = col[16] * fill), (b = col[17] * fill);\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","peaucellier-linkage":"// ===== Patternflow pattern =====\n// Title:   Peaucellier Linkage\n// Family:  line\n// Idea:    A Peaucellier inversor of seven thick bars swings on two fixed pivots, its crank rocking one corner of the rhombus along a circle through the main pivot so that the opposite corner runs up and down an exact straight line nearly the height of the panel, drawn as a glowing rail, and moving the crank's pivot off its place sends that corner along a circle arc beside the rail instead.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Peaucellier–Lipkin linkage (Charles-Nicolas Peaucellier, 1864; Yom Tov Lipman Lipkin, 1871), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Arms=0..1, Offset=0..1\n//\n// Knob 1: Hue. Turns the bars round the wheel together. At 0 the long arms are azure, the rhombus gold, the crank rose and the rail mint; at 0.5 the arms are orange, the rhombus blue, the crank green and the rail pink.\n// Knob 2: Speed. How fast the crank rocks: at 2 the output joint runs the rail top to bottom and back in 6 seconds, at 0.2 in a minute, at 3 in 4 seconds.\n// Knob 3: Arms. The ratio of the long arms to the rhombus side, with their sum kept at 78 LEDs. At 0 the arms are 52 and the side 26, the rail stands 51 LEDs from the main pivot and the output runs 53 LEDs either side of centre; at 1 the arms are 45 and the side 33, the rhombus opens out, the rail moves in to 34 LEDs and the crank swings 116 degrees each way for a stroke of 55. The crank is always 0.44 of the inversion radius, so the output joint never crosses the joint the crank drives.\n// Knob 4: Offset. Moves the crank's pivot away from the main pivot. Up to 0.08 it sits exactly the crank's length away and the output runs on the straight rail, within 1e-13 LEDs of it; at 1 it is a tenth of the inversion radius farther (4.5 LEDs at Arms 0), the crank's circle misses the main pivot, and the output's white track runs on a circle arc of radius about 200, 5 LEDs inside the rail at the middle of the stroke.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, ceil, min, max, sqrt, abs, sin, cos, atan, hypot, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// The main pivot O, on the left edge halfway down. The crank's pivot Q lies\n// to its right, and the output rail stands farther right, upright, so the\n// stroke runs along the panel's long side.\nconst OX = 6.5, OY = 64;\n// Arms plus side, in LEDs, and the half stroke the crank aims for.\nconst REACH = 78, STROKE = 55;\n// Bar half widths: arms and crank 4 LEDs wide, the rhombus 3.\nconst HW_ARM = 2, HW_RH = 1.5, HW_CR = 2;\n// Base hues of the arms, rhombus, crank and rail.\nconst HUES = [0.56, 0.12, 0.93, 0.42];\nconst TRAIL = 150;\n\n// The linkage for the knobs: long arm L, side s, inversion constant k =\n// L^2 - s^2 (|OP| |OP'| = k), crank length r, the rail's distance from O\n// d = k / 2r, and the crank pivot's offset.\nfunction geometry(G, arms, off) {\n  const rho = 2 - 0.65 * arms;\n  G.s = REACH / (1 + rho);\n  G.L = REACH - G.s;\n  G.k = G.L * G.L - G.s * G.s;\n  G.r = 0.44 * sqrt(G.k);\n  G.d = G.k / (2 * G.r);\n  G.off = (0.1 * sqrt(G.k) * max(0, off - 0.08)) / 0.92;\n  G.qx = OX + G.r + G.off;\n}\n\n// Solve the linkage for crank angle th: P on the crank's circle, A and B\n// where the circle of radius L round O meets the circle of radius s round\n// P, and P' the fourth corner of the rhombus, A + B - P. Nothing here uses\n// the inversion; the straight line is what the bars give.\nfunction solve(G, th, J) {\n  const px = G.qx + G.r * cos(th), py = OY + G.r * sin(th);\n  const dx = px - OX, dy = py - OY, D = hypot(dx, dy), ex = dx / D, ey = dy / D;\n  const a = (G.L * G.L - G.s * G.s + D * D) / (2 * D), hh = sqrt(max(0, G.L * G.L - a * a));\n  const mx = OX + a * ex, my = OY + a * ey;\n  J.px = px;\n  J.py = py;\n  J.ax = mx - hh * ey;\n  J.ay = my + hh * ex;\n  J.bx = mx + hh * ey;\n  J.by = my - hh * ex;\n  J.qx = 2 * mx - px;\n  J.qy = 2 * my - py;\n  J.D = D;\n  J.ok = G.L * G.L - a * a >= 0;\n}\n\n// How far the crank may swing: the largest angle up to the one that gives\n// the full stroke at which the rhombus is not flat, the arms are not\n// straight and P' stays on the panel. Both sides are mirror images.\nfunction swing(G, J) {\n  const goal = 2 * atan(STROKE / G.d);\n  let ok = 0;\n  for (let th = 0; th \u003c= goal + 1e-9; th += 0.004) {\n    solve(G, th, J);\n    const Dp = hypot(J.qx - OX, J.qy - OY);\n    if (!J.ok || J.D \u003c G.L - G.s + 1.5 || Dp > G.L + G.s - 3 || J.qy \u003c 6 || J.qy > H - 6) break;\n    ok = th;\n  }\n  return ok;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, arms: 0, offset: 0.06, ph: 0,\n    G: {}, J: {}, theta: 0, amp: 0, gKey: '',\n    rgb: new Float32Array(N * 3), tr: new Float32Array(N), col: new Float32Array(15),\n    tx: new Float32Array(TRAIL), ty: new Float32Array(TRAIL), tn: 0, ti: 0,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.arms = cl(k[2], 0, 1);\n  S.offset = cl(k[3], 0, 1);\n  // Inside the dead band the linkage is the same, so the track is kept.\n  const key = S.arms.toFixed(4) + ',' + max(0, S.offset - 0.08).toFixed(4);\n  if (key !== S.gKey) {\n    geometry(S.G, S.arms, S.offset);\n    S.amp = swing(S.G, S.J);\n    // A changed linkage starts a fresh track.\n    if (S.gKey) S.tn = 0;\n    S.gKey = key;\n  }\n  // One full rock (out, back, out the other way, back) is 6 s at Speed 2.\n  S.ph += (d * S.speed * 2 * PI) / 12;\n  // The crank angle is chosen so that, with the pivot in place, P' runs the\n  // rail in simple harmonic motion: y = T sin(phase) along the rail.\n  const T = S.G.d * Math.tan(S.amp / 2);\n  S.theta = 2 * atan((T * sin(S.ph)) / S.G.d);\n  S.stroke = T;\n  solve(S.G, S.theta, S.J);\n  S.tx[S.ti] = S.J.qx;\n  S.ty[S.ti] = S.J.qy;\n  S.ti = (S.ti + 1) % TRAIL;\n  S.tn = min(TRAIL, S.tn + 1);\n}\n\n// Paint colour c at cover a over what is there.\nfunction paint(rgb, p, a, r, g, b) {\n  const q = p * 3;\n  rgb[q] += (r - rgb[q]) * a;\n  rgb[q + 1] += (g - rgb[q + 1]) * a;\n  rgb[q + 2] += (b - rgb[q + 2]) * a;\n}\n\n// A bar from (ax, ay) to (bx, by) with round ends: a black rim one LED wide\n// first, so crossing bars stay apart, then the bar in its flat colour.\nfunction bar(rgb, ax, ay, bx, by, hw, col, o) {\n  const R = hw + 1.2, vx = bx - ax, vy = by - ay, ll = vx * vx + vy * vy || 1;\n  const x0 = max(0, floor(min(ax, bx) - R)), x1 = min(W - 1, ceil(max(ax, bx) + R));\n  const y0 = max(0, floor(min(ay, by) - R)), y1 = min(H - 1, ceil(max(ay, by) + R));\n  for (let y = y0; y \u003c= y1; y++)\n    for (let x = x0; x \u003c= x1; x++) {\n      const cx = x + 0.5 - ax, cy = y + 0.5 - ay, t = cl((cx * vx + cy * vy) / ll, 0, 1);\n      const dd = hypot(cx - t * vx, cy - t * vy), p = y * W + x;\n      const rim = cl(R + 0.5 - dd, 0, 1);\n      if (rim \u003c= 0) continue;\n      paint(rgb, p, rim, 0, 0, 0);\n      const c = cl(hw + 0.5 - dd, 0, 1);\n      if (c > 0) paint(rgb, p, c, col[o], col[o + 1], col[o + 2]);\n    }\n}\n\n// A moving joint: a disc a shade paler than its bar, with a dark pin.\nfunction joint(rgb, cx, cy, rad, col, o) {\n  for (let y = max(0, floor(cy - rad - 2)); y \u003c= min(H - 1, ceil(cy + rad + 2)); y++)\n    for (let x = max(0, floor(cx - rad - 2)); x \u003c= min(W - 1, ceil(cx + rad + 2)); x++) {\n      const dd = hypot(x + 0.5 - cx, y + 0.5 - cy), p = y * W + x;\n      const rim = cl(rad + 1.5 - dd, 0, 1);\n      if (rim \u003c= 0) continue;\n      paint(rgb, p, rim, 0, 0, 0);\n      const c = cl(rad + 0.5 - dd, 0, 1);\n      if (c > 0) paint(rgb, p, c, 0.55 + 0.45 * col[o], 0.55 + 0.45 * col[o + 1], 0.55 + 0.45 * col[o + 2]);\n      const pin = cl(1.2 - dd, 0, 1);\n      if (pin > 0) paint(rgb, p, pin, 0.08, 0.08, 0.1);\n    }\n}\n\n// A fixed pivot: a pale ring round a dark centre, on a short ground bar.\nfunction anchor(rgb, cx, cy) {\n  for (let y = max(0, floor(cy - 6)); y \u003c= min(H - 1, ceil(cy + 6)); y++)\n    for (let x = max(0, floor(cx - 6)); x \u003c= min(W - 1, ceil(cx + 6)); x++) {\n      const dd = hypot(x + 0.5 - cx, y + 0.5 - cy), p = y * W + x;\n      const rim = cl(4.6 - dd, 0, 1);\n      if (rim \u003c= 0) continue;\n      paint(rgb, p, rim, 0, 0, 0);\n      const ring = cl(3.6 - dd, 0, 1) * cl(dd - 1.1, 0, 1);\n      if (ring > 0) paint(rgb, p, ring, 0.86, 0.88, 0.92);\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.gKey) return;\n  const { rgb, col, G, J, tr } = S;\n  for (let i = 0; i \u003c 4; i++) hsv(S.hue + HUES[i], i === 3 ? 0.55 : 0.78, 1, col, i * 3);\n  rgb.fill(0);\n  tr.fill(0);\n\n  // The crank's circle, dotted and faint: it runs through O only when the\n  // crank's pivot is in place.\n  const nd = max(24, round((2 * PI * G.r) / 2.6));\n  for (let i = 0; i \u003c nd; i++) {\n    const a = (2 * PI * i) / nd, x = floor(G.qx + G.r * cos(a)), y = floor(OY + G.r * sin(a));\n    if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) paint(rgb, y * W + x, 0.6, col[6], col[7], col[8]);\n  }\n\n  // The rail: the straight line P' runs on with the pivot in place, at d\n  // from O and as long as the stroke, glowing.\n  const lx = OX + G.d, top = OY - S.stroke - 2, bot = OY + S.stroke + 2;\n  for (let y = max(0, floor(top)); y \u003c= min(H - 1, ceil(bot)); y++) {\n    const end = cl(y + 1 - top, 0, 1) * cl(bot - y, 0, 1);\n    for (let x = max(0, floor(lx - 4)); x \u003c= min(W - 1, ceil(lx + 4)); x++) {\n      const dx = abs(x + 0.5 - lx), v = (cl(1.25 - dx, 0, 1) * 0.85 + 0.22 * Math.exp(-dx * dx / 3)) * end;\n      if (v > 0) paint(rgb, y * W + x, min(1, v), col[9], col[10], col[11]);\n    }\n  }\n\n  // P's own track over the last five seconds, a white line one LED wide,\n  // newest brightest. With the pivot in place it lies on the rail's centre.\n  for (let n = 0; n + 1 \u003c S.tn; n++) {\n    const i = (S.ti - 1 - n + TRAIL) % TRAIL, j = (i - 1 + TRAIL) % TRAIL, a = 1 - (0.75 * n) / TRAIL;\n    const x0 = S.tx[i], y0 = S.ty[i], x1 = S.tx[j], y1 = S.ty[j], steps = max(1, ceil(hypot(x1 - x0, y1 - y0) * 2));\n    for (let m = 0; m \u003c steps; m++) {\n      const f = m / steps, tx = x0 + (x1 - x0) * f, ty = y0 + (y1 - y0) * f, x = floor(tx), y = floor(ty);\n      if (x >= 0 && x \u003c W && y >= 0 && y \u003c H) tr[y * W + x] = max(tr[y * W + x], a * cl(1.3 - abs(x + 0.5 - tx), 0, 1));\n    }\n  }\n  for (let p = 0; p \u003c N; p++) if (tr[p] > 0) paint(rgb, p, tr[p], 1, 1, 1);\n\n  // Bars, back to front: arms, crank, rhombus.\n  bar(rgb, OX, OY, J.ax, J.ay, HW_ARM, col, 0);\n  bar(rgb, OX, OY, J.bx, J.by, HW_ARM, col, 0);\n  bar(rgb, G.qx, OY, J.px, J.py, HW_CR, col, 6);\n  bar(rgb, J.ax, J.ay, J.px, J.py, HW_RH, col, 3);\n  bar(rgb, J.px, J.py, J.bx, J.by, HW_RH, col, 3);\n  bar(rgb, J.bx, J.by, J.qx, J.qy, HW_RH, col, 3);\n  bar(rgb, J.qx, J.qy, J.ax, J.ay, HW_RH, col, 3);\n  joint(rgb, J.ax, J.ay, 2.4, col, 0);\n  joint(rgb, J.bx, J.by, 2.4, col, 0);\n  joint(rgb, J.px, J.py, 2.4, col, 6);\n  joint(rgb, J.qx, J.qy, 2.6, col, 9);\n  anchor(rgb, OX, OY);\n  anchor(rgb, G.qx, OY);\n\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) display.setPixel(p % W, (p / W) | 0, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","pivot-walk":"// ===== Patternflow pattern =====\n// Title:   Pivot Walk\n// Family:  sim\n// Idea:    A self-avoiding walk of 80 to 160 steps on a 16 x 32 square lattice, drawn as a glowing chain coloured end to end, thrashes by the pivot algorithm: a random site is picked, one of the seven non-identity symmetries of the lattice is applied to the walk on one side of it, and when the result still avoids itself and fits on the panel the moved part swings round the pivot (a rotation) or folds over it (a reflection).\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: self-avoiding walk by the pivot algorithm (Moti Lal, 1969; Neal Madras and Alan Sokal, 1988), pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Length=80..160, Stiff=0..1\n//\n// Knob 1: Hue. Turns the chain's gradient round the wheel. At 0 it runs from aqua at the first site through blue and violet to pink at the last; at 0.5 from coral through gold to green. The two end sites carry a white bead.\n// Knob 2: Speed. Pivot tries a second while the chain is at rest: 14 times the knob, so 28 at 2. An accepted try swings for 0.5 s at 2 when the moved arm is the whole chain and down to 0.25 s for an arm of one site; 0.33 s at 3 and 1.5 s at 0.2. A rejected try flashes its pivot site white for 0.15 s. At the opening knobs that comes to about 1.6 swings a second, the chain moving 66% of the time.\n// Knob 3: Length. The number of steps, 80 to 160, on 512 lattice sites 4 LEDs apart. Turning it grows or trims the chain at its ends, 30 steps a second. At 80 one try in 5 is accepted, at 160 one in 21, and the longer chain swings about half as often.\n// Knob 4: Stiff. A bending cost J from 0 to 3 per corner, taken by the Metropolis rule. A pivot changes only the corner at its own site, so a try that makes a new corner passes with chance exp(-J). Up to 0.06 there is no cost and the walk is the plain self-avoiding walk, with a corner at 66% of its sites; at 1 only 9% are corners, straight runs average 11 steps and the chain folds like a hairpin between the walls.\n// Buttons: K1 tap shrinks the chain to one site in the middle and it grows back at both ends, 30 steps a second, swinging as it grows.\n\nconst W = 64, H = 128, GW = 16, GH = 32, STEP = 4, NMAX = 160;\nconst { floor, min, max, sqrt, abs, round, cos, sin, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n// The seven non-identity symmetries of the square lattice acting on a\n// vector: rotations by +90, -90 and 180 degrees, then reflections in the\n// horizontal axis, the vertical axis, the diagonal y = x and y = -x.\nconst SX = [[0, -1], [0, 1], [-1, 0], [1, 0], [-1, 0], [0, 1], [0, -1]];\nconst SY = [[1, 0], [-1, 0], [0, -1], [0, -1], [0, 1], [1, 0], [-1, 0]];\n// For the drawing: the angle each rotation swings through, and the axis\n// each reflection folds about.\nconst ANG = [PI / 2, -PI / 2, PI];\nconst R2 = Math.SQRT1_2;\nconst AXIS = [null, null, null, [1, 0], [0, 1], [R2, R2], [R2, -R2]];\n// Gradient start hue at Hue 0 (aqua) and its span (to pink).\nconst HUE0 = 0.47, SPAN = 0.42;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, len: 80, J: 0, begun: false,\n    n: 0, xs: new Int16Array(NMAX + 1), ys: new Int16Array(NMAX + 1), grid: new Int16Array(GW * GH),\n    nx: new Int16Array(NMAX + 1), ny: new Int16Array(NMAX + 1),\n    // The swing under way: pivot k, moved side lo..hi, symmetry g, how far\n    // through (0..1) and how long it takes.\n    swing: null, acc: 0, grow: 0, flashes: [], tries: 0, accepted: 0,\n    // Drawing: positions in LEDs, the two layers (resting chain and the arm\n    // in motion) and the gradient table.\n    px: new Float32Array(NMAX + 1), py: new Float32Array(NMAX + 1),\n    keyA: new Float32Array(W * H), rgbA: new Float32Array(W * H * 3),\n    covB: new Float32Array(W * H), rgbB: new Float32Array(W * H * 3),\n    lut: new Float32Array(256 * 3), lutHue: NaN,\n  };\n}\n\nconst cell = (x, y) => y * GW + x;\n\n// One site in the middle of the lattice, for the walk to grow from.\nfunction seed(S) {\n  S.grid.fill(0);\n  S.n = 0;\n  S.xs[0] = GW >> 1;\n  S.ys[0] = GH >> 1;\n  S.grid[cell(S.xs[0], S.ys[0])] = 1;\n  S.swing = null;\n  S.flashes.length = 0;\n}\n\n// One pivot try. Returns true if it was accepted (and the walk changed).\n// The pivot site, the side that moves (a coin toss) and the symmetry are\n// all picked evenly, and a symmetry's inverse is one of the seven too, so a\n// move and its undoing are equally likely and the walks are sampled evenly.\nfunction attempt(S, animate) {\n  const n = S.n;\n  if (n \u003c 2) return false;\n  const k = 1 + floor(Math.random() * (n - 1)), tail = Math.random() \u003c 0.5, g = floor(Math.random() * 7);\n  const xs = S.xs, ys = S.ys, grid = S.grid, sx = SX[g], sy = SY[g];\n  const lo = tail ? k + 1 : 0, hi = tail ? n : k - 1, cx = xs[k], cy = ys[k];\n  S.tries++;\n  // The corner at k is the only one a pivot changes.\n  if (S.J > 0) {\n    let ax = xs[k] - xs[k - 1], ay = ys[k] - ys[k - 1], bx = xs[k + 1] - xs[k], by = ys[k + 1] - ys[k];\n    const before = ax !== bx || ay !== by;\n    if (tail) [bx, by] = [sx[0] * bx + sx[1] * by, sy[0] * bx + sy[1] * by];\n    else [ax, ay] = [sx[0] * ax + sx[1] * ay, sy[0] * ax + sy[1] * ay];\n    const after = ax !== bx || ay !== by;\n    if (after && !before && Math.random() > exp(-S.J)) return reject(S, k, animate);\n  }\n  // New places for the moved side. A place off the lattice cannot meet the\n  // resting side, which is all on it; the walk is slid back on afterwards\n  // if its bounding box still fits in 16 by 32 sites.\n  const nx = S.nx, ny = S.ny;\n  let x0 = GW, x1 = -1, y0 = GH, y1 = -1;\n  for (let i = 0; i \u003c= n; i++) {\n    if (i >= lo && i \u003c= hi) {\n      const dx = xs[i] - cx, dy = ys[i] - cy, x = cx + sx[0] * dx + sx[1] * dy, y = cy + sy[0] * dx + sy[1] * dy;\n      if (x >= 0 && x \u003c GW && y >= 0 && y \u003c GH) {\n        const o = grid[cell(x, y)] - 1;\n        if (o >= 0 && (o \u003c lo || o > hi)) return reject(S, k, animate);\n      }\n      nx[i] = x;\n      ny[i] = y;\n    } else {\n      nx[i] = xs[i];\n      ny[i] = ys[i];\n    }\n    if (nx[i] \u003c x0) x0 = nx[i];\n    if (nx[i] > x1) x1 = nx[i];\n    if (ny[i] \u003c y0) y0 = ny[i];\n    if (ny[i] > y1) y1 = ny[i];\n  }\n  if (x1 - x0 >= GW || y1 - y0 >= GH) return reject(S, k, animate);\n  // The slide also centres the walk's box on the lattice. Which shapes are\n  // allowed depends only on the size of that box, never where it sits.\n  const ox = floor((GW - 1 - x0 - x1) / 2), oy = floor((GH - 1 - y0 - y1) / 2);\n  if (animate) {\n    S.px.set(xs.subarray(0, n + 1));\n    S.py.set(ys.subarray(0, n + 1));\n  }\n  grid.fill(0);\n  for (let i = 0; i \u003c= n; i++) {\n    xs[i] = nx[i] + ox;\n    ys[i] = ny[i] + oy;\n    grid[cell(xs[i], ys[i])] = i + 1;\n  }\n  S.accepted++;\n  if (animate) {\n    // A short arm swings in as little as half the time of a long one.\n    const size = hi - lo + 1, T = cl(1 / S.speed, 0.3, 1.5) * (0.5 + 0.5 * sqrt(size / n));\n    S.swing = { k, lo, hi, g, t: 0, T, sx: ox, sy: oy, ox: S.px.slice(0, n + 1), oy: S.py.slice(0, n + 1) };\n  }\n  return true;\n}\n\nfunction reject(S, k, animate) {\n  if (animate && S.flashes.length \u003c 24) S.flashes.push({ k, life: 1 });\n  return false;\n}\n\n// Grow one step at an end: a free neighbour of the last (or first) site.\nfunction growOne(S) {\n  const n = S.n, xs = S.xs, ys = S.ys, grid = S.grid;\n  for (const atEnd of Math.random() \u003c 0.5 ? [true, false] : [false, true]) {\n    const e = atEnd ? n : 0, free = [];\n    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {\n      const x = xs[e] + dx, y = ys[e] + dy;\n      if (x >= 0 && x \u003c GW && y >= 0 && y \u003c GH && !grid[cell(x, y)]) free.push([x, y]);\n    }\n    if (!free.length) continue;\n    const [x, y] = free[floor(Math.random() * free.length)];\n    if (!atEnd) {\n      for (let i = n; i >= 0; i--) {\n        xs[i + 1] = xs[i];\n        ys[i + 1] = ys[i];\n        grid[cell(xs[i + 1], ys[i + 1])] = i + 2;\n      }\n      xs[0] = x;\n      ys[0] = y;\n      grid[cell(x, y)] = 1;\n    } else {\n      xs[n + 1] = x;\n      ys[n + 1] = y;\n      grid[cell(x, y)] = n + 2;\n    }\n    S.n = n + 1;\n    return true;\n  }\n  return false;\n}\n\n// Trim one step, from the end the coin picks.\nfunction trimOne(S) {\n  const n = S.n, xs = S.xs, ys = S.ys, grid = S.grid;\n  if (Math.random() \u003c 0.5) grid[cell(xs[n], ys[n])] = 0;\n  else {\n    grid[cell(xs[0], ys[0])] = 0;\n    for (let i = 0; i \u003c n; i++) {\n      xs[i] = xs[i + 1];\n      ys[i] = ys[i + 1];\n      grid[cell(xs[i], ys[i])] = i + 1;\n    }\n  }\n  S.n = n - 1;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, kv = input.knobValues || [0, 2, 80, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = kv[0];\n  S.speed = cl(kv[1], 0.2, 3);\n  S.len = round(cl(kv[2], 80, NMAX));\n  const st = cl(kv[3], 0, 1);\n  S.J = st \u003c= 0.06 ? 0 : (3 * (st - 0.06)) / 0.94;\n  if (!S.begun) {\n    // Open on a walk already crumpled: grown from one site a step at a\n    // time with 30 tries after each step, then 30 tries a step more.\n    seed(S);\n    for (let guard = 0; S.n \u003c S.len && guard \u003c 20 * S.len; guard++) {\n      growOne(S);\n      for (let i = 0; i \u003c 30; i++) attempt(S, false);\n    }\n    for (let i = 0; i \u003c 30 * S.len; i++) attempt(S, false);\n    S.begun = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) seed(S);\n  for (const f of S.flashes) f.life -= d / 0.15;\n  S.flashes = S.flashes.filter((f) => f.life > 0 && f.k \u003c S.n);\n  if (S.swing) {\n    S.swing.t += d / S.swing.T;\n    if (S.swing.t >= 1) S.swing = null;\n    return;\n  }\n  // Length: 30 steps a second toward the knob, with no tries meanwhile\n  // unless both ends are boxed in and only a pivot can free them.\n  if (S.n !== S.len) {\n    S.grow += d * 30;\n    let stuck = false;\n    while (S.grow >= 1 && S.n !== S.len) {\n      S.grow -= 1;\n      if (S.n > S.len) trimOne(S);\n      else if (!growOne(S)) {\n        stuck = true;\n        break;\n      }\n    }\n    if (!stuck) {\n      S.acc = 0;\n      return;\n    }\n  } else S.grow = 0;\n  S.acc += d * 14 * S.speed;\n  while (S.acc >= 1 && !S.swing) {\n    S.acc -= 1;\n    attempt(S, true);\n  }\n  if (S.swing) S.acc = 0;\n}\n\nconst ease = (t) => t * t * (3 - 2 * t);\n\n// Where every site is drawn this frame, in LEDs.\nfunction positions(S) {\n  const { xs, ys, px, py, n, swing } = S;\n  if (!swing) {\n    for (let i = 0; i \u003c= n; i++) {\n      px[i] = xs[i] * STEP + 2;\n      py[i] = ys[i] * STEP + 2;\n    }\n    return 1;\n  }\n  // Every site from where it was: the resting side only slides with the\n  // shift that keeps the walk on the panel, the moved side turns about the\n  // pivot as well.\n  const e = ease(cl(swing.t, 0, 1)), ox = swing.ox, oy = swing.oy, cx = ox[swing.k], cy = oy[swing.k];\n  const tx = swing.sx * e * STEP, ty = swing.sy * e * STEP;\n  for (let i = 0; i \u003c= n; i++) {\n    px[i] = ox[i] * STEP + 2 + tx;\n    py[i] = oy[i] * STEP + 2 + ty;\n  }\n  let fold = 1;\n  if (swing.g \u003c 3) {\n    const a = ANG[swing.g] * e, c = cos(a), s = sin(a);\n    for (let i = swing.lo; i \u003c= swing.hi; i++) {\n      const dx = (ox[i] - cx) * STEP, dy = (oy[i] - cy) * STEP;\n      px[i] = cx * STEP + 2 + tx + c * dx - s * dy;\n      py[i] = cy * STEP + 2 + ty + s * dx + c * dy;\n    }\n  } else {\n    // A fold: the part across the axis shrinks through zero and opens on\n    // the other side, as if the arm turned over out of the panel.\n    const [ax, ay] = AXIS[swing.g], f = cos(PI * e);\n    fold = 0.55 + 0.45 * abs(f);\n    for (let i = swing.lo; i \u003c= swing.hi; i++) {\n      const dx = (ox[i] - cx) * STEP, dy = (oy[i] - cy) * STEP;\n      const along = dx * ax + dy * ay, across = (dx * -ay + dy * ax) * f;\n      px[i] = cx * STEP + 2 + tx + along * ax - across * ay;\n      py[i] = cy * STEP + 2 + ty + along * ay + across * ax;\n    }\n  }\n  return fold;\n}\n\n// One bond as a 2-LED line with a dim glow 2 LEDs out, its colour taken\n// from the gradient at each LED's place along the chain.\nfunction bond(S, i, moving, bright) {\n  const { px, py, lut, n } = S, x0 = px[i], y0 = py[i], x1 = px[i + 1], y1 = py[i + 1];\n  const ex = x1 - x0, ey = y1 - y0, L2 = ex * ex + ey * ey || 1, R = 3.2;\n  const xa = max(0, floor(min(x0, x1) - R)), xb = min(W - 1, floor(max(x0, x1) + R));\n  const ya = max(0, floor(min(y0, y1) - R)), yb = min(H - 1, floor(max(y0, y1) + R));\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const qx = x + 0.5 - x0, qy = y + 0.5 - y0, u = cl((qx * ex + qy * ey) / L2, 0, 1);\n      const dx = qx - u * ex, dy = qy - u * ey, dd = sqrt(dx * dx + dy * dy);\n      if (dd >= R) continue;\n      const cov = cl(1.5 - dd, 0, 1), glow = 0.18 * cl(1 - (dd - 1.2) / 1.8, 0, 1);\n      const c = 3 * min(255, floor(((i + u) / n) * 255.99)), p = y * W + x;\n      if (moving) {\n        if (cov \u003c= S.covB[p]) continue;\n        S.covB[p] = cov;\n        S.rgbB[3 * p] = lut[c] * bright;\n        S.rgbB[3 * p + 1] = lut[c + 1] * bright;\n        S.rgbB[3 * p + 2] = lut[c + 2] * bright;\n      } else {\n        const key = cov > 0 ? 1 + cov : glow;\n        if (key \u003c= S.keyA[p]) continue;\n        S.keyA[p] = key;\n        const v = cov > 0 ? cov : glow;\n        S.rgbA[3 * p] = lut[c] * v;\n        S.rgbA[3 * p + 1] = lut[c + 1] * v;\n        S.rgbA[3 * p + 2] = lut[c + 2] * v;\n      }\n    }\n}\n\n// A round dot: white core of radius r, edge of the given colour.\nfunction bead(S, x0, y0, r, wr, wg, wb, a) {\n  for (let y = max(0, floor(y0 - r - 1)); y \u003c= min(H - 1, floor(y0 + r + 1)); y++)\n    for (let x = max(0, floor(x0 - r - 1)); x \u003c= min(W - 1, floor(x0 + r + 1)); x++) {\n      const dd = sqrt((x + 0.5 - x0) ** 2 + (y + 0.5 - y0) ** 2), c = cl(r + 0.5 - dd, 0, 1) * a, p = y * W + x;\n      if (c \u003c= 0) continue;\n      const o = 3 * p, bA = S.covB[p];\n      // Beads sit on top of both layers: write the moving layer.\n      S.rgbB[o] = S.rgbB[o] * bA * (1 - c) + wr * c;\n      S.rgbB[o + 1] = S.rgbB[o + 1] * bA * (1 - c) + wg * c;\n      S.rgbB[o + 2] = S.rgbB[o + 2] * bA * (1 - c) + wb * c;\n      const nb = 1 - (1 - bA) * (1 - c);\n      if (nb > 0) {\n        S.rgbB[o] /= nb;\n        S.rgbB[o + 1] /= nb;\n        S.rgbB[o + 2] /= nb;\n      }\n      S.covB[p] = nb;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.begun) return;\n  if (S.lutHue !== S.hue) {\n    for (let i = 0; i \u003c 256; i++) {\n      const t = i / 255, h = S.hue + HUE0 + SPAN * t, hf = h - floor(h);\n      // Pure blue reads dim beside the rest: a little white in it.\n      const blue = max(0, 1 - abs(hf - 0.66) / 0.08);\n      hsv(h, 0.92 - 0.25 * blue, 1, S.lut, 3 * i);\n    }\n    S.lutHue = S.hue;\n  }\n  const fold = positions(S), sw = S.swing, n = S.n;\n  S.keyA.fill(0);\n  S.rgbA.fill(0);\n  S.covB.fill(0);\n  S.rgbB.fill(0);\n  // The bond from the pivot into the moved side turns with it.\n  for (let i = 0; i \u003c n; i++) {\n    const moving = sw && ((sw.lo > sw.k && i >= sw.k) || (sw.lo \u003c sw.k && i \u003c sw.k));\n    if (!moving) bond(S, i, false, 1);\n  }\n  if (sw) {\n    const lift = 1 + 0.25 * sin(PI * cl(sw.t, 0, 1));\n    for (let i = 0; i \u003c n; i++)\n      if ((sw.lo > sw.k && i >= sw.k) || (sw.lo \u003c sw.k && i \u003c sw.k)) bond(S, i, true, fold * lift);\n  }\n  const { px, py } = S;\n  bead(S, px[0], py[0], 1.9, 1, 1, 1, 1);\n  bead(S, px[n], py[n], 1.9, 1, 1, 1, 1);\n  if (sw) bead(S, px[sw.k], py[sw.k], 1.2, 1, 1, 1, 0.9 * sin(PI * cl(sw.t, 0, 1)));\n  for (const f of S.flashes) bead(S, px[f.k], py[f.k], 1.1, 1, 1, 1, 0.85 * f.life);\n  const { rgbA, rgbB, covB } = S;\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const a = covB[p];\n    let r = rgbA[o], g = rgbA[o + 1], b = rgbA[o + 2];\n    if (a > 0) {\n      r = r * (1 - a) + min(1, rgbB[o]) * a;\n      g = g * (1 - a) + min(1, rgbB[o + 1]) * a;\n      b = b * (1 - a) + min(1, rgbB[o + 2]) * a;\n    }\n    display.setPixel(p % W, (p / W) | 0, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n  }\n}\n","witch-moon":"// ===== Patternflow pattern =====\n// Title:   Witch Moon\n// Family:  halloween\n// Idea:    A huge full moon hangs in the upper middle of a purple night, ragged clouds drift across it with their edges lit by its light, bare branches sway along the bottom, and every so often a witch on a broomstick, cloak and bristles fluttering and a trail of green sparks behind her, flies across the face of the moon.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 42\n// Round:   42\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Clouds=0..1, Flights=0..1\n//\n// Knob 1: Hue. The moon's tint, and the light on the cloud edges with it. At 0 harvest orange, at 0.25 amber, at 0.5 bone white, at 0.75 a ghostly green and at 1 lilac.\n// Knob 2: Speed. The clock of the whole scene. At 2 the near clouds drift 7 LEDs a second and the far ones 3.5, a branch sways once in 3 seconds, and a witch flies 18 LEDs a second and is in sight for about 7 seconds; at 0.2 all of it is ten times slower, at 3 half as fast again.\n// Knob 3: Clouds. At 0 three near and three far cloud banks take turns across the sky and a fifth of the moon is under cloud on average; at 0.5 six of each and 43% of the moon is hidden; at 1 eight of each, 30% longer and 60% thicker, and two thirds of it. Far banks let 30% of the light behind them through, near ones none.\n// Knob 4: Flights. How many witches fly together and how often. Below 0.25 one witch, then two, three and from 0.75 four, the others smaller and ahead of the last in a V. The next flight leaves 8 seconds after the last one has gone at 0 and 2 seconds after at 1 (at Speed 2). The first flight leaves at once and its middle crosses the middle of the moon at 3.7 seconds.\n// Buttons: K1 tap sends the next flight at once, or the moment the one in the air has gone.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, abs, sin, cos, exp, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n// A fixed hash, so the clouds, stars and trees are the same on every run.\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The moon: centre and radius in LEDs.\nconst MX = 32, MY = 42, MR = 24;\n// Moon tints along Hue: harvest orange, amber, bone white, ghost green, lilac.\nconst TINTS = [[1, 0.57, 0.16], [1, 0.79, 0.36], [0.94, 0.9, 0.8], [0.69, 1, 0.6], [0.8, 0.67, 1]];\n\n// Value noise on a 64 x 64 table that wraps, for ragged cloud edges and\n// the shores of the moon's seas.\nconst NT = new Float32Array(64 * 64);\nfor (let i = 0; i \u003c NT.length; i++) NT[i] = hash(i * 7 + 3);\nfunction vnoise(x, y) {\n  const xi = floor(x), yi = floor(y), fx = x - xi, fy = y - yi;\n  const ux = fx * fx * (3 - 2 * fx), uy = fy * fy * (3 - 2 * fy);\n  const i0 = xi & 63, i1 = (xi + 1) & 63, j0 = (yi & 63) \u003c\u003c 6, j1 = ((yi + 1) & 63) \u003c\u003c 6;\n  const a = NT[j0 + i0], b = NT[j0 + i1], c = NT[j1 + i0], d = NT[j1 + i1];\n  return a + (b - a) * ux + (c - a) * uy + (a - b - c + d) * ux * uy;\n}\n\n// Cloud streaks in two layers, both drifting left: far ones thin, slow and\n// letting 30% of what is behind them through, near ones thicker, faster and\n// dark. Each is [row, length, thickness, where it is at the start]; the\n// Clouds knob brings in more of each list and fattens them. Speeds are\n// LEDs a second at Speed 2.\nconst LAYERS = [\n  { v: 3.5, body: [0.1, 0.065, 0.15], op: 0.7, list: [[28, 56, 6, 40], [64, 60, 6, 0], [46, 48, 5, 100], [14, 44, 5, 75], [36, 52, 6, 130], [72, 40, 5, 60], [54, 50, 6, 20], [20, 46, 5, 115]] },\n  { v: 7, body: [0.04, 0.028, 0.075], op: 1, list: [[61, 46, 10, 74], [32, 38, 9, 18], [70, 52, 11, 110], [84, 44, 10, 40], [42, 34, 8, 128], [24, 30, 8, 95], [60, 40, 9, -10], [92, 50, 11, 130]] },\n];\nconst CLOUDS = [];\nLAYERS.forEach((L, l) =>\n  L.list.forEach(([y, len, th, x], i) => {\n    const puffs = [];\n    for (let k = 0; k \u003c 5; k++) {\n      const hs = (n) => hash(l * 1000 + i * 50 + k * 7 + n);\n      puffs.push([(k + 0.5) / 5 - 0.5 + (hs(1) - 0.5) / 10, (0.75 + 0.5 * hs(2)) / 5, 0.55 + 0.45 * sin((PI * (k + 0.5)) / 5) * hs(3)]);\n    }\n    CLOUDS.push({ l, i, y, len, th, x, puffs, seed: l * 13 + i * 5.7 });\n  }),\n);\n\n// The moon's face, fixed and drawn in four tones like pixel art: bright\n// highland, the shore of a sea, the seas and crater floors. Six seas are\n// ellipses with wobbly edges, placed roughly where they are on the Moon;\n// a ring at the limb is one tone darker, and each crater is a dark floor\n// with a lit rim on its lower right.\nconst TONES = [1, 0.88, 0.76, 0.66];\nconst SEAS = [[-7, -8, 8, 6], [6, -10, 6, 5], [10, -2, 6, 5], [-12, 4, 6, 9], [3, 7, 5, 4], [15, 8, 3.5, 3]];\nconst CRATERS = [[-4, 15, 2.6], [14, -14, 2.2], [-16, -7, 2], [9, 16, 2.2], [-1, -18, 1.8]];\nconst FACE = new Float32Array(W * H);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n    if (r > MR + 1) continue;\n    let e = 9;\n    for (const [cx, cy, rx, ry] of SEAS) e = min(e, ((dx - cx) / rx) ** 2 + ((dy - cy) / ry) ** 2);\n    e += 0.6 * (vnoise(x / 3.1 + 7, y / 3.1 + 2) - 0.5);\n    let tone = e \u003c 1 ? 2 : e \u003c 1.35 ? 1 : 0;\n    if (r > MR - 2.2) tone++;\n    for (const [cx, cy, cr] of CRATERS) {\n      const qx = dx - cx, qy = dy - cy, d = sqrt(qx * qx + qy * qy);\n      if (d \u003c cr) tone = max(tone + 1, 2);\n      else if (d \u003c cr + 1.2 && qx + qy > 0.6 * cr) tone = 0;\n    }\n    FACE[y * W + x] = TONES[min(3, tone)];\n  }\n\n// The sky by row: deep blue-violet at the top, a purple glow at the horizon.\nconst SKY = [[0, 0.02, 0.016, 0.08], [60, 0.065, 0.032, 0.135], [98, 0.19, 0.065, 0.25], [120, 0.33, 0.11, 0.33]];\nconst SKYROW = new Float32Array(H * 3);\nfor (let y = 0; y \u003c H; y++) {\n  let k = 0;\n  while (k \u003c SKY.length - 2 && y > SKY[k + 1][0]) k++;\n  const [y0, r0, g0, b0] = SKY[k], [y1, r1, g1, b1] = SKY[k + 1], t = sm(0, 1, cl((y - y0) / (y1 - y0), 0, 1));\n  SKYROW[3 * y] = r0 + (r1 - r0) * t;\n  SKYROW[3 * y + 1] = g0 + (g1 - g0) * t;\n  SKYROW[3 * y + 2] = b0 + (b1 - b0) * t;\n}\n\n// Stars in the dark upper sky, clear of the moon's glow.\nconst STARS = [];\nfor (let i = 0; STARS.length \u003c 14 && i \u003c 400; i++) {\n  const x = floor(hash(i * 3 + 101) * W), y = floor(hash(i * 3 + 102) * 80);\n  if ((x + 0.5 - MX) ** 2 + (y + 0.5 - MY) ** 2 \u003c (MR + 9) ** 2) continue;\n  STARS.push([x, y, hash(i * 3 + 103) * 6.28]);\n}\n\n// The trees: two bare trees grown from fixed numbers. Each branch is\n// [parent, angle to its parent, length, start radius, end radius, depth,\n// sway phase]; angle 0 is straight up.\nconst TREES = [];\nfunction grow(root, x, y, angle, len, r, depth, maxD, seed) {\n  const id = TREES.length;\n  TREES.push({ parent: root, x, y, a: angle, len, r0: r, r1: max(0.5, r * 0.66), depth, ph: hash(seed) * 6.28 });\n  if (depth >= maxD) return;\n  const kids = depth \u003c 2 ? 2 : hash(seed + 1) \u003c 0.65 ? 2 : 1;\n  for (let k = 0; k \u003c kids; k++) {\n    const s = seed * 5 + k * 17 + 3, side = kids === 1 ? (hash(s) \u003c 0.5 ? -1 : 1) : k === 0 ? -1 : 1;\n    const da = side * (0.3 + 0.45 * hash(s + 1)) + (hash(s + 2) - 0.5) * 0.3;\n    grow(id, 0, 0, da, len * (0.62 + 0.22 * hash(s + 3)), max(0.5, r * 0.66), depth + 1, maxD, s + 9);\n  }\n}\ngrow(-1, 3, 131, 0.32, 24, 3.6, 0, 6, 5);\ngrow(-1, 62, 131, -0.42, 18, 2.8, 0, 5, 77);\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, clouds: 0, flights: 0.06,\n    // Scene clock (seconds at Speed 2; the clouds are placed from it), the\n    // flight under way and the wait for the next, sparks behind the brooms.\n    t: 0, flight: null, wait: 0, nflight: 0, sparks: [],\n    rgb: new Float32Array(W * H * 3), mask: new Float32Array(W * H), tint: [1, 0.6, 0.2],\n    bx: new Float32Array(TREES.length), by: new Float32Array(TREES.length), ex: new Float32Array(TREES.length), ey: new Float32Array(TREES.length),\n    begun: false, queued: false,\n  };\n}\n\n// A flight: direction alternates; the leader's centre runs from 35 LEDs off\n// one side to 35 off the other, rising gently, at 18 LEDs a second at Speed 2.\nfunction launch(S) {\n  const dir = S.nflight % 2 === 0 ? 1 : -1, n = 1 + min(3, floor(4 * S.flights));\n  // The flight is placed by its middle, so whatever the number of witches\n  // the group is centred on the moon 3.7 s after it leaves (at Speed 2).\n  let mid = 0;\n  for (let j = 0; j \u003c n; j++) mid += COVEN[j][0] / n;\n  S.flight = { dir, age: 0, n, mid };\n  S.nflight++;\n}\n// Places of the witches in a flight, as [LEDs ahead of the last one, LEDs\n// up or down, scale]: the last is the biggest, the others fly ahead of her\n// in a V, smaller as if farther off.\nconst COVEN = [[0, 0, 0.88], [22, -19, 0.7], [22, 19, 0.72], [44, 0, 0.64]];\nconst FLY = 18, MARGIN = 35;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.clouds = cl(k[2], 0, 1);\n  S.flights = cl(k[3], 0, 1);\n  // The first flight leaves at once, with as many witches as the knob asks.\n  if (!S.begun) {\n    launch(S);\n    S.begun = true;\n  }\n  const ds = (d * S.speed) / 2;\n  S.t += ds;\n  // A tap sends the next flight at once, or straight after the one in the air.\n  if (input.btnPressed && input.btnPressed[0]) {\n    if (S.flight) S.queued = true;\n    else launch(S);\n  }\n  if (S.flight) {\n    const f = S.flight;\n    f.age += ds;\n    const span = W + 2 * MARGIN + f.mid;\n    if (f.age * FLY > span) {\n      S.flight = null;\n      S.wait = S.queued ? 0 : 8 - 6 * S.flights;\n      S.queued = false;\n    } else {\n      // Sparks from each broom's bristles, 40 a second each.\n      for (let j = 0; j \u003c f.n; j++) {\n        const w = witchPlace(S, f, j), bx = w.x - w.dir * 20 * w.s, by = w.y + 2 * w.s;\n        for (let e = ds * 40; e > 0 && S.sparks.length \u003c 400; e--) {\n          if (e \u003c 1 && Math.random() > e) break;\n          S.sparks.push({ x: bx + (Math.random() - 0.5) * 4, y: by + (Math.random() - 0.5) * 4, vx: -w.dir * (1 + 4 * Math.random()), vy: 1.5 + 4 * Math.random(), life: 1, ph: Math.random() * 6.28 });\n        }\n      }\n    }\n  } else {\n    S.wait -= ds;\n    if (S.wait \u003c= 0) launch(S);\n  }\n  for (const p of S.sparks) {\n    p.x += p.vx * ds;\n    p.y += p.vy * ds;\n    p.life -= ds / 2;\n  }\n  S.sparks = S.sparks.filter((p) => p.life > 0);\n}\n\n// Witch j of a flight: centre, scale, direction, tilt. She climbs 0.22 LEDs\n// for each LED she flies and swoops 3.5 LEDs up and down every 2.6 s.\nfunction witchPlace(S, f, j) {\n  const [ahead, up, s] = COVEN[j], run = f.age * FLY - MARGIN + ahead - f.mid, x = f.dir > 0 ? run : W - run;\n  const ph = f.age * 2.4 + j * 0.5, y = MY + 1 + up - 0.22 * (run - MX) + 3.5 * sin(ph);\n  return { x, y, s, dir: f.dir, tilt: f.dir * (-0.14 + 0.28 * cos(ph)) };\n}\n\n// Signed distance to a capsule and to a polygon, in the witch's own units.\nfunction capsule(px, py, ax, ay, bx, by, r) {\n  const ex = bx - ax, ey = by - ay, qx = px - ax, qy = py - ay, u = cl((qx * ex + qy * ey) / (ex * ex + ey * ey), 0, 1);\n  return sqrt((qx - u * ex) ** 2 + (qy - u * ey) ** 2) - r;\n}\nfunction poly(px, py, v) {\n  let dd = 1e9, s = 1;\n  for (let i = 0, j = v.length - 2; i \u003c v.length; j = i, i += 2) {\n    const ex = v[j] - v[i], ey = v[j + 1] - v[i + 1], wx = px - v[i], wy = py - v[i + 1];\n    const u = cl((wx * ex + wy * ey) / (ex * ex + ey * ey), 0, 1), bx = wx - ex * u, by = wy - ey * u;\n    dd = min(dd, bx * bx + by * by);\n    const c1 = py >= v[i + 1], c2 = py \u003c v[j + 1], c3 = ex * wy > ey * wx;\n    if ((c1 && c2 && c3) || (!c1 && !c2 && !c3)) s = -s;\n  }\n  return s * sqrt(dd);\n}\n\n// The witch as one shape, facing +x with y down, the seat on the broom at\n// the origin; fl is her own flutter clock. Generic: pointed hat with a brim\n// and a bent tip, hair and cloak streaming back, a hooked nose, one arm to\n// the broom, a boot hanging below it and a fan of bristles.\nfunction witchShapes(fl) {\n  const f = (k, a) => a * sin(fl * 9 + k * 1.9);\n  return [\n    [\"c\", -11, 1.2, 15, -1.2, 0.9],\n    [\"p\", [-10, 0, -10, 2.4, -18.5, 6 + f(1, 1), -21, 3.5 + f(2, 1.2), -21, 0 + f(3, 1.2), -18.5, -2.5 + f(4, 1)]],\n    [\"p\", [4.5, -9, 6, -2, 5, 1.5, -2, 1.5, -8 + f(5, 1), -1 + f(6, 1.4), -12.5 + f(7, 1.2), -4 + f(8, 1.8), -5, -6.5, 1, -9.5]],\n    [\"c\", 3, 1, 6.5, 5.5, 1.2],\n    [\"c\", 6.5, 5.5, 9.5, 5, 0.9],\n    [\"c\", 3.5, -7, 9.5, -1.5, 1],\n    [\"c\", 3.5, -11.5, 3.5, -11.5, 2.4],\n    [\"p\", [5.5, -12.3, 8.4, -10.6, 5.6, -10.4]],\n    [\"c\", 2, -11, -3.5 + f(9, 0.8), -8.5 + f(10, 0.8), 1],\n    [\"c\", 2, -10, -4.5 + f(11, 0.8), -6.2 + f(12, 0.8), 0.8],\n    [\"c\", -2, -13.6, 8.8, -14.6, 0.75],\n    [\"p\", [0.5, -14, 6.5, -14.6, 3.8, -19.5, -1.5 + f(13, 0.6), -23 + f(14, 0.4), 2, -19]],\n  ];\n}\n\nfunction drawWitch(S, w, fl) {\n  const shapes = witchShapes(fl), mask = S.mask, c = cos(w.tilt), s = sin(w.tilt), R = 24 * w.s;\n  for (let y = max(0, floor(w.y - R)); y \u003c= min(H - 1, floor(w.y + R)); y++)\n    for (let x = max(0, floor(w.x - R)); x \u003c= min(W - 1, floor(w.x + R)); x++) {\n      const dx = x + 0.5 - w.x, dy = y + 0.5 - w.y;\n      const lx = ((c * dx + s * dy) / w.s) * w.dir, ly = (-s * dx + c * dy) / w.s;\n      if (lx \u003c -23 || lx > 17 || ly \u003c -25 || ly > 8) continue;\n      let dd = 1e9;\n      for (const sh of shapes) {\n        const v = sh[0] === \"c\" ? capsule(lx, ly, sh[1], sh[2], sh[3], sh[4], sh[5]) : poly(lx, ly, sh[1]);\n        if (v \u003c dd) dd = v;\n      }\n      const cov = cl(0.5 - dd * w.s, 0, 1), p = y * W + x;\n      if (cov > mask[p]) mask[p] = cov;\n    }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, mask } = S;\n  // Moon tint from Hue.\n  const hk = S.hue * (TINTS.length - 1), i0 = min(TINTS.length - 2, floor(hk)), ht = hk - i0;\n  const T = S.tint;\n  for (let c = 0; c \u003c 3; c++) T[c] = TINTS[i0][c] + (TINTS[i0 + 1][c] - TINTS[i0][c]) * ht;\n  // Where each cloud is now, and how big, for the clouds the knob lets in.\n  const live = [], c = S.clouds;\n  for (const C of CLOUDS) {\n    if (C.i >= 3 + round(5 * c)) continue;\n    const len = C.len * (1 + 0.3 * c), th = C.th * (1 + 0.6 * c), m = len / 2 + 8, span = W + 2 * m;\n    let u = (C.x + m - LAYERS[C.l].v * S.t) % span;\n    if (u \u003c 0) u += span;\n    live.push({ C, cx: u - m, len, th });\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, o = 3 * p, dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy);\n      let R = SKYROW[3 * y], G = SKYROW[3 * y + 1], B = SKYROW[3 * y + 2];\n      // Glow round the moon in rings, then the moon itself.\n      const out = max(0, r - MR), glow = round((0.34 * exp(-out / 6) + 0.12 * exp(-out / 22)) * 20) / 20;\n      R += T[0] * glow;\n      G += T[1] * glow;\n      B += T[2] * glow;\n      if (r \u003c MR + 0.5) {\n        const f = FACE[p], disc = r \u003c MR - 0.3 ? 1 : 0.6;\n        R += (T[0] * f - R) * disc;\n        G += (T[1] * f - G) * disc;\n        B += (T[2] * f - B) * disc;\n      }\n      // Clouds, far then near, in flat tones: a puffy top, a flatter base\n      // and a ragged edge. The edge of a cloud near the moon is lit in the\n      // moon's tint; its body takes a little of that light.\n      const light = round(4 * exp(-max(0, r - 0.8 * MR) / 10)) / 4;\n      for (const K of live) {\n        const { C, cx, len, th } = K, qx = x + 0.5 - cx, qy = y + 0.5 - C.y;\n        if (abs(qx) > len / 2 + 4 || qy \u003c -th - 2 || qy > 0.5 * th + 2) continue;\n        let dd = 1e9;\n        for (const [px, rx, ry] of C.puffs) {\n          const ex = (qx - px * len) / (rx * len), ey = qy / (qy \u003c 0 ? ry * th : 0.42 * th);\n          dd = min(dd, (sqrt(ex * ex + ey * ey) - 1) * min(rx * len, ry * th));\n        }\n        dd += 2.2 * (vnoise(qx / 3.2 + C.seed, y / 2.6) - 0.5) + 1.6 * (vnoise(qx / 7 + C.seed, y / 5) - 0.5);\n        if (dd >= 0) continue;\n        // The lit edge is the tint halfway to white, so over the moon it\n        // still shows as a line brighter than the face behind it.\n        const L = LAYERS[C.l], a = L.op;\n        if (dd > -1.1) {\n          R += ((T[0] * 0.55 + 0.45) * light + L.body[0] - R) * a;\n          G += ((T[1] * 0.55 + 0.45) * light + L.body[1] - G) * a;\n          B += ((T[2] * 0.55 + 0.45) * light + L.body[2] - B) * a;\n        } else {\n          R += (L.body[0] + T[0] * 0.12 * light - R) * a;\n          G += (L.body[1] + T[1] * 0.12 * light - G) * a;\n          B += (L.body[2] + T[2] * 0.12 * light - B) * a;\n        }\n      }\n      rgb[o] = R;\n      rgb[o + 1] = G;\n      rgb[o + 2] = B;\n    }\n  // Stars twinkle where nothing covers them.\n  for (const [x, y, ph] of STARS) {\n    const o = 3 * (y * W + x), v = 0.22 + 0.2 * sin(S.t * 2.3 + ph);\n    if (rgb[o + 2] \u003c 0.2) {\n      rgb[o] = max(rgb[o], v);\n      rgb[o + 1] = max(rgb[o + 1], v);\n      rgb[o + 2] = max(rgb[o + 2], v * 1.1);\n    }\n  }\n  // Silhouettes: the witches, then the trees and the ground, all black.\n  mask.fill(0);\n  if (S.flight) for (let j = 0; j \u003c S.flight.n; j++) drawWitch(S, witchPlace(S, S.flight, j), S.t * 1.1 + j * 2.3);\n  for (let p = 0; p \u003c W * H; p++) {\n    const a = mask[p];\n    if (a > 0) {\n      rgb[3 * p] *= 1 - a;\n      rgb[3 * p + 1] *= 1 - a;\n      rgb[3 * p + 2] *= 1 - a;\n    }\n  }\n  // Sparks over the witches, under the trees: toxic green, flickering.\n  for (const sp of S.sparks) {\n    const x = floor(sp.x), y = floor(sp.y);\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n    const v = min(1, sp.life * 1.3) * (0.6 + 0.4 * sin(S.t * 30 + sp.ph));\n    spark(rgb, x, y, v);\n    // A new spark is a small cross.\n    if (sp.life > 0.75) for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) spark(rgb, x + dx, y + dy, 0.45 * v);\n  }\n  mask.fill(0);\n  drawTrees(S);\n  for (let x = 0; x \u003c W; x++) {\n    const g = 119.5 + 2.6 * sin(x * 0.11 + 1.3) + 1.4 * sin(x * 0.31);\n    for (let y = floor(g) - 1; y \u003c H; y++) {\n      const p = y * W + x;\n      mask[p] = max(mask[p], cl(y + 0.5 - g + 0.5, 0, 1));\n    }\n  }\n  for (let p = 0, o = 0; p \u003c W * H; p++, o += 3) {\n    const a = 1 - mask[p];\n    display.setPixel(p % W, (p / W) | 0, round(255 * min(1, rgb[o] * a)), round(255 * min(1, rgb[o + 1] * a)), round(255 * min(1, rgb[o + 2] * a)));\n  }\n}\n\nfunction spark(rgb, x, y, v) {\n  if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n  const o = 3 * (y * W + x);\n  rgb[o] = max(rgb[o], 0.45 * v);\n  rgb[o + 1] = max(rgb[o + 1], v);\n  rgb[o + 2] = max(rgb[o + 2], 0.3 * v);\n}\n\n// Each branch is placed from its parent's end every frame, its angle swayed\n// by the wind: more at the twigs, a slow sway and a faster shiver.\nfunction drawTrees(S) {\n  const { bx, by, ex, ey, mask } = S, t = S.t, ang = new Float32Array(TREES.length);\n  for (let i = 0; i \u003c TREES.length; i++) {\n    const b = TREES[i], w = (b.depth / 6) ** 1.5;\n    const sway = w * (0.15 * sin(t * 2.1 + b.ph) + 0.05 * sin(t * 5.3 + 2 * b.ph)) + 0.04 * (b.depth / 6) * sin(t * 0.9);\n    ang[i] = (b.parent \u003c 0 ? b.a : ang[b.parent] + b.a) + sway;\n    if (b.parent \u003c 0) {\n      bx[i] = b.x;\n      by[i] = b.y;\n    } else {\n      bx[i] = ex[b.parent];\n      by[i] = ey[b.parent];\n    }\n    ex[i] = bx[i] + sin(ang[i]) * b.len;\n    ey[i] = by[i] - cos(ang[i]) * b.len;\n    const x0 = bx[i], y0 = by[i], x1 = ex[i], y1 = ey[i], R = b.r0 + 1;\n    const exx = x1 - x0, eyy = y1 - y0, L2 = exx * exx + eyy * eyy || 1;\n    for (let y = max(0, floor(min(y0, y1) - R)); y \u003c= min(H - 1, floor(max(y0, y1) + R)); y++)\n      for (let x = max(0, floor(min(x0, x1) - R)); x \u003c= min(W - 1, floor(max(x0, x1) + R)); x++) {\n        const qx = x + 0.5 - x0, qy = y + 0.5 - y0, u = cl((qx * exx + qy * eyy) / L2, 0, 1);\n        const dd = sqrt((qx - u * exx) ** 2 + (qy - u * eyy) ** 2), rr = b.r0 + (b.r1 - b.r0) * u;\n        const cov = cl(rr + 0.5 - dd, 0, 1), p = y * W + x;\n        if (cov > mask[p]) mask[p] = cov;\n      }\n  }\n}\n","cauldron":"// ===== Patternflow pattern =====\n// Title:   Cauldron\n// Family:  halloween\n// Idea:    A black iron cauldron over a small fire near the foot of the panel heaves with glowing toxic-green brew; bubbles swell and pop into flying droplets, green and purple fumes curl up the full height of the panel, and a tap drops an eyeball in with a splash that turns the brew another colour.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the witch's cauldron of Halloween decorations\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Boil=0..1, Fume=0..1\n//\n// Knob 1: Hue. Turns the brew and its fumes round the wheel together. At 0 the brew is toxic green and the fumes green and purple; at 0.5 the brew is purple and the fumes purple and lime; at 0.75 the brew is orange and the fumes orange and cyan.\n// Knob 2: Speed. Runs everything faster or slower: at 2 a fume takes about 4 seconds to climb from the brew to the top of the panel, at 0.2 about 40.\n// Knob 3: Boil. How hard it boils. At 0 about 3 bubbles a second swell to as much as 9 LEDs across before they pop, and the brew heaves up to 4 LEDs over the far lip; at 1 about 11 a second swell to 19 across, the brew heaves up to 9 LEDs and the droplets fly about four times as high.\n// Knob 4: Fume. How much fume rises: 12 puffs a second at 0, each swelling to as much as 17 LEDs across as it climbs; 36 a second at 1, each up to 28 across, when the two ribbons thicken into plumes that fill most of the panel above the pot.\n// Buttons: K1 tap drops an eyeball from the top of the panel. It lands in the brew with a splash a third of the panel high, the surface rings, and the brew turns from green to violet, then orange, then cyan, then green again.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, random, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// The pot. The mouth is an ellipse centred on (CX, RY0): the brew fills the\n// inner one, the iron lip lies between the inner and the outer one. The body\n// is the part of a wider ellipse below the lip, cut flat at its foot.\nconst CX = 32, RY0 = 89;\nconst IN_A = 23.5, IN_B = 4.5, OUT_A = 27.5, OUT_B = 6.5;\nconst BODY_CY = 100, BODY_A = 30, BODY_B = 21, FOOT = 120;\n// Brew hue at Hue 0, and the four brews a tap steps through: green, violet,\n// orange, cyan.\nconst BREW0 = 0.3, BREWS = [0, 0.46, 0.77, 0.25];\n\n// Pot pixels, worked out once: 0 none, 1-3 body from shadow to light, 4 the\n// glint, 5 lip, 6 lip highlight, 7 leg. FRONT marks the half of the lip that\n// lies in front of the brew.\nconst POT = new Uint8Array(W * H), FRONT = new Uint8Array(W * H);\nfor (let y = 0; y \u003c H; y++)\n  for (let x = 0; x \u003c W; x++) {\n    const px = x + 0.5 - CX, py = y + 0.5, p = y * W + x;\n    const u = px / BODY_A, v = (py - BODY_CY) / BODY_B, r2 = u * u + v * v;\n    if (r2 \u003c= 1 && py >= RY0 && py \u003c= FOOT) {\n      // Lit from the upper left: three flat bands and a glint, so the round\n      // body reads from across a room.\n      const nz = sqrt(max(0, 1 - r2)), l = -0.62 * u - 0.38 * v + 0.55 * nz;\n      POT[p] = l > 0.8 ? 4 : l > 0.5 ? 3 : l > 0.15 ? 2 : 1;\n    }\n    // Two stubby legs, splayed out from under the body.\n    for (const s of [-1, 1]) {\n      const t = (py - 114) / 11;\n      if (t >= 0 && t \u003c= 1 && abs(px - s * (14 + 4 * t)) \u003c= 2.6 - 0.8 * t && !POT[p]) POT[p] = 7;\n    }\n    const ei = (px / IN_A) ** 2 + ((py - RY0) / IN_B) ** 2, eo = (px / OUT_A) ** 2 + ((py - RY0) / OUT_B) ** 2;\n    if (eo \u003c= 1 && ei > 1) {\n      // The lip's top face catches the light on the far side and the left.\n      POT[p] = py \u003c RY0 - 2.5 || (px \u003c -18 && py \u003c RY0 + 2) ? 6 : 5;\n      FRONT[p] = py > RY0 ? 1 : 0;\n    }\n  }\n// Iron colours for 1-7 (index 0 unused).\nconst IRON = [\n  [0, 0, 0], [0.07, 0.05, 0.1], [0.14, 0.1, 0.19], [0.25, 0.2, 0.32], [0.62, 0.58, 0.72], [0.26, 0.22, 0.32], [0.5, 0.46, 0.6], [0.12, 0.09, 0.15],\n];\n\n// Inner mouth half-depth at column x (0 outside the mouth).\nconst mouth = (x) => {\n  const u = (x - CX) / IN_A;\n  return abs(u) \u003c 1 ? IN_B * sqrt(1 - u * u) : 0;\n};\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, boil: 0, fume: 0.06,\n    t: 0, begun: false,\n    brew: 0, brewFrom: 0, brewTo: 0, brewMix: 1, brewIdx: 0,\n    bubbles: [], drops: [], puffs: [], rings: [],\n    bubbleDue: 0, puffDue: 0, vent: 0,\n    eye: null, jet: null, shock: null,\n    lift: new Float32Array(W),\n    fg: new Float32Array(W * H), fp: new Float32Array(W * H), cf: new Float32Array(6 * W * H),\n    rgb: new Float32Array(W * H * 3),\n    c: new Float32Array(9 * 3),\n  };\n}\n\n// The fumes swirl in a velocity field with no divergence, the curl of a\n// stream function made of three travelling cells, on top of a steady rise.\nfunction flow(x, y, t, out) {\n  // psi = sum a sin(kx x + p) sin(ky y + q), velocity (dpsi/dy, -dpsi/dx).\n  let vx = 0, vy = 0;\n  const M = [\n    [10, 0.16, 0.1, 0.8, 1.2, 0.0], [8, 0.22, 0.17, -1.1, 0.7, 2.0], [6, 0.1, 0.24, 0.6, -1.5, 4.0],\n  ];\n  for (const [a, kx, ky, w1, w2, ph] of M) {\n    const sx = sin(kx * x + w1 * t + ph), cx = cos(kx * x + w1 * t + ph), sy = sin(ky * y + w2 * t), cy = cos(ky * y + w2 * t);\n    vx += a * sx * cy;\n    vy -= ((a * kx) / ky) * cx * sy;\n  }\n  out[0] = vx;\n  out[1] = vy * 0.5 - 22;\n}\n\nfunction spawnBubble(S) {\n  const x = CX + (random() * 2 - 1) * (IN_A - 6), d = random();\n  const R = 3 + 2 * S.boil + random() * (1.5 + 3 * S.boil);\n  S.bubbles.push({ x, d, R, age: 0, life: 0.55 + random() * 0.6 });\n}\n\nfunction pop(S, b, y) {\n  const n = 2 + floor(b.R * 0.6);\n  const sp = 1 + S.boil;\n  for (let i = 0; i \u003c n; i++) {\n    const a = -PI / 2 + (random() * 2 - 1) * 0.9;\n    const v = (26 + random() * 30) * sqrt(sp) * (0.6 + b.R / 8);\n    S.drops.push({ x: b.x, y: y - b.R * 0.5, vx: cos(a) * v * 0.7, vy: sin(a) * v, big: random() \u003c 0.5 });\n  }\n  S.rings.push({ x: b.x, y, r: b.R, age: 0 });\n}\n\n// Two vents, one for each colour of fume, wander across the brew, so each\n// lays a ribbon that the swirl then bends and curls.\nfunction emitPuff(S, kind, x) {\n  S.puffs.push({\n    x, y: RY0 - 3, age: 0, life: 4.4 + random() * 1.4 + 1.2 * S.fume,\n    R: 4.5 + random() * 2 + 4 * S.fume, kind, brew: S.brew,\n  });\n}\n\nfunction step(S, d) {\n  S.t += d;\n  const t = S.t, boil = S.boil;\n  // The surface lift, LEDs up from the far edge of the mouth: a slow heave\n  // of the whole brew, two travelling swells, a dome in the middle that\n  // breathes, and the ring a splash leaves.\n  const amp = 2 + 3 * boil;\n  for (let x = 0; x \u003c W; x++) {\n    const u = (x + 0.5 - CX) / IN_A;\n    if (abs(u) >= 1) {\n      S.lift[x] = 0;\n      continue;\n    }\n    let L = amp * (0.55 + 0.45 * sin(1.3 * t)) * (1 - u * u) + amp * 0.5 * (sin(0.31 * x + 2.6 * t) * 0.6 + sin(0.53 * x - 3.4 * t + 1) * 0.4 + 0.6);\n    if (S.shock) {\n      const g = S.shock, a = g.age, dx = abs(x + 0.5 - g.x);\n      L += 7 * Math.exp(-1.6 * a) * cos(0.42 * dx - 9 * a) * Math.exp(-dx / 30);\n    }\n    S.lift[x] = max(0, L);\n  }\n  // Bubbles, at 3 a second at Boil 0 and 11 at 1, faster for 3 seconds\n  // after a splash.\n  const rate = (3 + 8 * boil) * (S.shock ? 1 + 2 * Math.exp(-S.shock.age) : 1);\n  S.bubbleDue += d * rate;\n  while (S.bubbleDue >= 1) (S.bubbleDue -= 1), spawnBubble(S);\n  for (let i = S.bubbles.length - 1; i >= 0; i--) {\n    const b = S.bubbles[i];\n    b.age += d;\n    if (b.age >= b.life) {\n      pop(S, b, surfY(S, b));\n      S.bubbles.splice(i, 1);\n    }\n  }\n  // Droplets fly, fall back into the mouth or off the foot of the panel.\n  for (let i = S.drops.length - 1; i >= 0; i--) {\n    const p = S.drops[i];\n    p.vy += 150 * d;\n    p.x += p.vx * d;\n    p.y += p.vy * d;\n    const xi = floor(p.x), m = xi >= 0 && xi \u003c W ? mouth(p.x) : 0;\n    const back = p.vy > 0 && m > 0 && p.y > RY0 - m - S.lift[cl(xi, 0, W - 1)] + 1.5;\n    const hit = p.vy > 0 && xi >= 0 && xi \u003c W && p.y >= 0 && p.y \u003c H && POT[floor(p.y) * W + xi] && !m;\n    if (back || hit || p.y > H + 2 || p.x \u003c -3 || p.x > W + 3) S.drops.splice(i, 1);\n  }\n  for (let i = S.rings.length - 1; i >= 0; i--) if ((S.rings[i].age += d) > 0.18) S.rings.splice(i, 1);\n  // Fumes.\n  S.puffDue += d * (12 + 24 * S.fume);\n  while (S.puffDue >= 1) {\n    S.puffDue -= 1;\n    const kind = (S.vent = 1 - S.vent);\n    emitPuff(S, kind, CX + 13 * sin(0.43 * t + kind * 2.4) + 3 * sin(1.7 * t + kind));\n  }\n  const v = [0, 0];\n  for (let i = S.puffs.length - 1; i >= 0; i--) {\n    const q = S.puffs[i];\n    q.age += d;\n    flow(q.x, q.y, t, v);\n    // Fresh fume leaves straight up and only takes the swirl as it climbs.\n    const k = cl(q.age / 0.8, 0, 1);\n    q.x += v[0] * k * d;\n    q.y += v[1] * d;\n    if (q.age > q.life || q.y \u003c -20) S.puffs.splice(i, 1);\n  }\n  // The eyeball, the jet it throws up, and the brew changing colour.\n  if (S.eye) {\n    const e = S.eye;\n    e.vy += 150 * d;\n    e.y += e.vy * d;\n    e.spin += d * 5;\n    const top = RY0 - mouth(e.x) - S.lift[floor(e.x)];\n    if (!e.in && e.y > top) {\n      e.in = true;\n      S.jet = { x: e.x, age: 0 };\n      S.shock = { x: e.x, age: 0 };\n      for (let i = 0; i \u003c 26; i++) {\n        const a = -PI / 2 + (random() * 2 - 1) * 1.1, sp = 60 + random() * 55;\n        S.drops.push({ x: e.x + (random() * 2 - 1) * 4, y: top, vx: cos(a) * sp * 0.6, vy: sin(a) * sp, big: true });\n      }\n      S.brewFrom = S.brew;\n      S.brewIdx = (S.brewIdx + 1) % BREWS.length;\n      S.brewTo = BREWS[S.brewIdx];\n      S.brewMix = 0;\n    }\n    if (e.in) e.vy = min(e.vy, 20);\n    if (e.in && e.y > top + 10) S.eye = null;\n  }\n  if (S.jet && (S.jet.age += d) > 0.7) S.jet = null;\n  if (S.shock && (S.shock.age += d) > 3) S.shock = null;\n  if (S.brewMix \u003c 1) {\n    S.brewMix = min(1, S.brewMix + d / 0.8);\n    let dh = S.brewTo - S.brewFrom;\n    dh -= Math.round(dh);\n    S.brew = S.brewFrom + dh * S.brewMix;\n  }\n}\n\n// Row of a bubble's centre: its place between the far and the near edge of\n// the brew, the far edge lifted with the surface.\nfunction surfY(S, b) {\n  const xi = cl(floor(b.x), 0, W - 1), m = mouth(b.x);\n  return RY0 - m - S.lift[xi] + (2 * m + S.lift[xi]) * (0.15 + 0.6 * b.d);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.boil = cl(k[2], 0, 1);\n  S.fume = cl(k[3], 0, 1);\n  if (!S.begun) {\n    // Start with the fume already up the panel.\n    S.begun = true;\n    for (let i = 0; i \u003c 150; i++) step(S, 1 / 30);\n  }\n  if (input.btnPressed && input.btnPressed[0] && !S.eye) S.eye = { x: CX - 6 + random() * 12, y: -6, vy: 10, spin: 0, in: false };\n  step(S, d * S.speed * 0.5);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, fg, fp, cf, c, lift } = S;\n  const bh = BREW0 + S.hue + S.brew;\n  // Palette, three entries each: brew 0, brew crest 3, brew deep 6, bubble\n  // 9, bubble rim 12, flame 15, flame core 18, droplet 21, white 24.\n  hsv(bh, 0.88, 1, c, 0);\n  hsv(bh - 0.02, 0.45, 1, c, 3);\n  hsv(bh, 0.92, 0.62, c, 6);\n  hsv(bh + 0.02, 0.55, 1, c, 9);\n  hsv(bh, 0.95, 0.5, c, 12);\n  hsv(0.04, 0.95, 1, c, 15);\n  hsv(0.13, 0.75, 1, c, 18);\n  hsv(bh, 0.6, 1, c, 21);\n  c[24] = c[25] = c[26] = 1;\n  rgb.fill(0);\n  const put = (x, y, o) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const q = (y * W + x) * 3;\n    rgb[q] = c[o];\n    rgb[q + 1] = c[o + 1];\n    rgb[q + 2] = c[o + 2];\n  };\n\n  // Fume: one field per vent, each puff a soft bump that swells and fades\n  // with age, cut into three flat levels so the fume reads as bold shapes.\n  // A puff keeps the colour of the brew it rose from, so after a splash the\n  // new colour climbs the panel under the old one.\n  fg.fill(0);\n  fp.fill(0);\n  cf.fill(0);\n  const pc = [0, 0, 0];\n  for (const q of S.puffs) {\n    const a = q.age / q.life, R = q.R * (0.45 + 0.9 * sqrt(a));\n    const w = cl(q.age / 0.5, 0, 1) * (a \u003c 0.55 ? 1 : 1 - (a - 0.55) / 0.45) * 1.25;\n    const F = q.kind ? fp : fg, o3 = q.kind ? 3 * W * H : 0;\n    hsv(BREW0 + S.hue + q.brew + (q.kind ? 0.47 : 0), q.kind ? 0.72 : 0.8, 1, pc, 0);\n    for (let y = max(0, floor(q.y - R)); y \u003c= min(H - 1, floor(q.y + R)); y++)\n      for (let x = max(0, floor(q.x - R)); x \u003c= min(W - 1, floor(q.x + R)); x++) {\n        const dx = (x + 0.5 - q.x) / R, dy = (y + 0.5 - q.y) / R, r2 = dx * dx + dy * dy;\n        if (r2 >= 1) continue;\n        const k = w * (1 - r2) * (1 - r2), p = y * W + x, i = o3 + p * 3;\n        F[p] += k;\n        cf[i] += k * pc[0];\n        cf[i + 1] += k * pc[1];\n        cf[i + 2] += k * pc[2];\n      }\n  }\n  for (let p = 0; p \u003c W * H; p++) {\n    const a = fg[p], b = fp[p], top = a >= b ? a : b, i = (a >= b ? 0 : 3 * W * H) + p * 3;\n    const lv = top > 1.1 ? 0.92 : top > 0.55 ? 0.55 : top > 0.25 ? 0.3 : 0;\n    if (!lv) continue;\n    rgb[p * 3] = (cf[i] / top) * lv;\n    rgb[p * 3 + 1] = (cf[i + 1] / top) * lv;\n    rgb[p * 3 + 2] = (cf[i + 2] / top) * lv;\n  }\n\n  // Fire under the pot: tongues that flicker, red-orange round a yellow core.\n  const t = S.t;\n  for (let x = 12; x \u003c 52; x++) {\n    const e = 1 - abs(x + 0.5 - CX) / 20;\n    const h = e * (6 + 3.5 * sin(0.9 * x + 11 * t) * sin(0.37 * x - 7 * t) + 2 * sin(1.7 * x + 17 * t));\n    for (let y = H - 1; y > H - 1 - h; y--) {\n      const core = H - 1 - y \u003c h * 0.5 && e > 0.25;\n      put(x, y, core ? 18 : 15);\n    }\n  }\n\n  // The pot body and legs, the far half of the lip, with the brew's light\n  // on the top of the body and the fire's on its foot.\n  const gl = [c[0], c[1], c[2]];\n  for (let y = 80; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, m = POT[p];\n      if (!m || FRONT[p]) continue;\n      const q = p * 3, col = IRON[m];\n      let r = col[0], g = col[1], b = col[2];\n      if (m \u003c= 4 && y \u003c RY0 + 5 && m > 1) {\n        r = r * 0.6 + gl[0] * 0.25;\n        g = g * 0.6 + gl[1] * 0.25;\n        b = b * 0.6 + gl[2] * 0.25;\n      } else if (m \u003c= 2 && y > FOOT - 5) {\n        r = max(r, 0.45);\n        g = max(g, 0.16);\n      }\n      rgb[q] = r;\n      rgb[q + 1] = g;\n      rgb[q + 2] = b;\n    }\n\n  // The brew: the inner mouth, its far edge lifted by the heave.\n  for (let x = 0; x \u003c W; x++) {\n    const m = mouth(x + 0.5);\n    if (!m) continue;\n    const top = RY0 - m - lift[x], bot = RY0 + m;\n    for (let y = max(0, floor(top)); y \u003c= floor(bot); y++) {\n      const o = y - top \u003c 1.6 ? 3 : y > bot - 1.5 ? 6 : 0;\n      put(x, y, o);\n    }\n  }\n  // Bubbles: a pale dome with a dark rim and a white glint; a popped one\n  // leaves a ring for a moment.\n  for (const b of S.bubbles) {\n    const a = b.age / b.life, R = b.R * (0.35 + 0.65 * sqrt(a)), cy = surfY(S, b) - R * 0.45;\n    for (let y = floor(cy - R - 1); y \u003c= floor(cy + R + 1); y++)\n      for (let x = floor(b.x - R - 1); x \u003c= floor(b.x + R + 1); x++) {\n        const dd = sqrt((x + 0.5 - b.x) ** 2 + (y + 0.5 - cy) ** 2);\n        if (dd > R + 0.5) continue;\n        put(x, y, dd > R - 0.8 ? 12 : 9);\n      }\n    const gx = floor(b.x - R * 0.4), gy = floor(cy - R * 0.4);\n    if (R > 2.2) put(gx, gy, 24);\n  }\n  for (const g of S.rings) {\n    const R = g.r * (1 + g.age * 6);\n    for (let i = 0; i \u003c 24; i++) {\n      const a = (2 * PI * i) / 24;\n      put(floor(g.x + R * cos(a)), floor(g.y - g.r * 0.4 + R * 0.5 * sin(a)), 3);\n    }\n  }\n  // The jet a splash throws up: a column of brew that shoots up 42 LEDs and\n  // falls back in 0.7 seconds of pattern time.\n  if (S.jet) {\n    const j = S.jet, hgt = 42 * sin((PI * j.age) / 0.7), base = RY0 - mouth(j.x) - lift[floor(j.x)];\n    for (let y = floor(base - hgt); y \u003c= base; y++) {\n      const w = 2.6 + 1.6 * ((y - (base - hgt)) / max(1, hgt));\n      for (let x = floor(j.x - w); x \u003c= floor(j.x + w); x++) put(x, y, abs(x + 0.5 - j.x) \u003c w * 0.45 ? 3 : 0);\n    }\n    for (let x = floor(j.x - 3); x \u003c= floor(j.x + 3); x++)\n      for (let y = floor(base - hgt - 3); y \u003c= floor(base - hgt + 1); y++)\n        if ((x + 0.5 - j.x) ** 2 + (y + 0.5 - (base - hgt - 1)) ** 2 \u003c 9) put(x, y, 3);\n  }\n  // The near half of the lip, in front of the brew.\n  for (let y = RY0; y \u003c RY0 + OUT_B + 1; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      if (!FRONT[p]) continue;\n      const col = IRON[POT[p]], q = p * 3;\n      rgb[q] = col[0];\n      rgb[q + 1] = col[1];\n      rgb[q + 2] = col[2];\n    }\n  // Droplets, 2 LEDs square, the big ones 3.\n  for (const p of S.drops) {\n    const s = p.big ? 3 : 2, x0 = floor(p.x - s / 2), y0 = floor(p.y - s / 2);\n    for (let y = y0; y \u003c y0 + s; y++) for (let x = x0; x \u003c x0 + s; x++) put(x, y, 21);\n  }\n  // The eyeball: white, a violet iris that rolls as it falls, a black pupil.\n  if (S.eye) {\n    const e = S.eye, ix = e.x + 2 * cos(e.spin), iy = e.y + 2 * sin(e.spin);\n    const top = RY0 - mouth(e.x) - lift[floor(e.x)];\n    for (let y = floor(e.y - 5); y \u003c= floor(e.y + 5); y++)\n      for (let x = floor(e.x - 5); x \u003c= floor(e.x + 5); x++) {\n        if (x \u003c 0 || x >= W || y \u003c 0 || y >= H || (e.in && y > top)) continue;\n        const d0 = (x + 0.5 - e.x) ** 2 + (y + 0.5 - e.y) ** 2;\n        if (d0 > 4.6 * 4.6) continue;\n        const di = (x + 0.5 - ix) ** 2 + (y + 0.5 - iy) ** 2, q = (y * W + x) * 3;\n        const col = di \u003c 1.1 ? [0, 0, 0] : di \u003c 5.3 ? [0.55, 0.2, 1] : [0.95, 0.93, 0.9];\n        rgb[q] = col[0];\n        rgb[q + 1] = col[1];\n        rgb[q + 2] = col[2];\n      }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, floor(min(1, rgb[q]) * 255), floor(min(1, rgb[q + 1]) * 255), floor(min(1, rgb[q + 2]) * 255));\n}\n","eyes-in-the-dark":"// ===== Patternflow pattern =====\n// Title:   Eyes in the Dark\n// Family:  halloween\n// Idea:    On a black panel sets of glowing eyes, a cat's slit-pupilled almonds, an owl's orange discs, a pair of red slits that glare and a spider's eight, open, follow a wandering will-o'-the-wisp with their pupils, blink, prowl, dash across the dark, shut and open again somewhere else.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the will-o'-the-wisp of European folklore\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Shift=0..1, Speed=0.2..3, Pairs=5..9, Jumpy=0..1\n//\n// Knob 1: Shift. Turns every colour round the wheel together. At 0 the cat's eyes are yellow-green, the owl's orange, the slits red, the spider's eight magenta and the wisp pale aqua; at 0.25 the owl turns green and the slits lime, at 0.5 the owl is blue and the cat violet. An iris edge that lands between orange and lime is paled and lifted, so it never reads brown or olive.\n// Knob 2: Speed. At 2 the wisp moves 26 LEDs a second on average and 57 at its fastest, and crosses the panel's height in about five seconds; a set of eyes stays open 2 to 4.5 seconds and is gone 0.3 to 1.2 before it opens elsewhere. At 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Pairs. How many sets of eyes, 5 to 9, and never fewer than all but two of them open at once. At 5 they are full size: a cat's eye 18 LEDs wide, an owl's 15, a slit 16, the spider's eight 23 across. Each set over 5 makes the eyes 7% smaller, to 72% at 9, so they still fit.\n// Knob 4: Jumpy. At 0.06 the eyes blink every 1 to 3 seconds, glance away from the wisp every 1.5 to 6, dash to a new spot every 3 to 8 and prowl at up to 4.5 LEDs a second; at 1 they blink every 0.3 to 0.8 seconds, glance every 0.3 to 1.2, dash every 0.9 to 2.4, prowl two and a half times as fast and their pupils catch up with what they look at in 0.04 seconds instead of 0.11. Any eye blinks when the wisp comes within 10 LEDs of it.\n// Buttons: K1 tap opens every set at once, the shut ones wherever there is room, and for 2.5 seconds they all stare at the middle of the panel without blinking before they go back to the wisp.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, sin, cos, abs, round, exp, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst len = (x, y) => sqrt(x * x + y * y);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst rnd = (a, b) => a + (b - a) * Math.random();\n// How bright the eyes' glow on the dark is, against the eyes themselves.\nconst GLOW = 1.3;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The kinds: a cat's almonds, an owl's discs, a pair of red slits that\n// glare, and a spider's eight. For each: half-size of the group's box, the\n// eye's half-width and half-height, how far each eye sits from the middle,\n// and the hues of the iris centre and edge at Shift 0.\nconst CAT = 0, OWL = 1, RED = 2, SPIDER = 3;\nconst BOX = [[21, 8], [16, 9], [18, 7], [13, 11]];\nconst EYE = [[9, 5.6, 11.6], [7.4, 7.4, 8.6], [7.8, 3.1, 10]];\nconst HUE = [[0.17, 0.27], [0.13, 0.05], [0.05, 0.99], [0.83, 0.92]];\n// The spider's eight: x, y and radius, the big front pair in the middle.\nconst SPIDER_EYES = [[-3.4, 2.4, 4], [3.4, 2.4, 4], [-9, 1.2, 2.5], [9, 1.2, 2.5], [-7.6, -6, 1.9], [-2.6, -7.8, 1.9], [2.6, -7.8, 1.9], [7.6, -6, 1.9]];\n\nexport function setup(params) {\n  params.s = {\n    shift: 0, speed: 2, pairs: 5, jumpy: 0.06,\n    clock: 0, stare: 0,\n    wx: 32, wy: 64, wvx: 0, wvy: -1, flick: 1, trail: [],\n    groups: [],\n    rgb: new Float32Array(N * 3), glow: new Float32Array(N * 3), halo: new Float32Array(N * 3), tmp: new Float32Array(N * 3), inside: new Uint8Array(N),\n    col: new Float32Array(4 * 6), warm: new Float32Array(4),\n  };\n}\n\nfunction overlaps(S, g, x, y) {\n  const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc;\n  for (const o of S.groups) {\n    if (o === g || o.state === 0) continue;\n    const w2 = w + BOX[o.type][0] * o.sc + 2, h2 = h + BOX[o.type][1] * o.sc + 3;\n    if (abs(o.x - x) \u003c w2 && abs(o.y - y) \u003c h2) return true;\n    // A set in the middle of a dash already holds where it is going.\n    if (o.dash >= 0 && abs(o.x1 - x) \u003c w2 && abs(o.y1 - y) \u003c h2) return true;\n  }\n  return false;\n}\n\n// Somewhere free on the panel, as a new kind (one spider at a time); false\n// if nowhere was found.\nfunction place(S, g) {\n  const spider = S.groups.some((o) => o !== g && o.state !== 0 && o.type === SPIDER);\n  g.type = floor(rnd(0, spider ? 3 : 4));\n  // More pairs, smaller eyes: full size at 5, 0.72 at 9.\n  g.sc = 1 - 0.07 * (S.pairs - 5);\n  const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc;\n  for (let n = 0; n \u003c 120; n++) {\n    const x = rnd(w + 1, W - 1 - w), y = rnd(h + 3, H - 3 - h);\n    if (!overlaps(S, g, x, y)) {\n      g.x = x;\n      g.y = y;\n      g.ph = rnd(0, 7);\n      const a = rnd(0, 2 * PI);\n      g.vx = cos(a) * rnd(2, 4.5);\n      g.vy = sin(a) * rnd(1, 2.5);\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction newGroup(S, open) {\n  const g = { type: CAT, x: 32, y: 64, sc: 1, vx: 0, vy: 0, ph: 0, state: 0, t: 0, dur: rnd(0.3, 1.5), o: 0, blink: rnd(0.5, 3), bt: -1, px: 0, py: 0, gx: 0, gy: 0, glance: 0, gap: rnd(1, 5), dil: 0.5, near: 0, dash: -1, dashT: rnd(0.8, 4.5), x0: 0, y0: 0, x1: 0, y1: 0 };\n  if (open && place(S, g)) (g.state = 2), (g.o = 1), (g.dur = rnd(2, 7));\n  return g;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 5, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.shift = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.pairs = round(cl(k[2], 5, 9));\n  S.jumpy = cl(k[3], 0, 1);\n  const J = S.jumpy, f = (d * S.speed) / 2;\n  S.clock += f;\n  while (S.groups.length \u003c S.pairs) S.groups.push(newGroup(S, S.groups.length \u003c S.pairs - 1));\n  // Groups past the count shut and leave when the knob comes down.\n  for (let i = S.pairs; i \u003c S.groups.length; i++) if (S.groups[i].state === 2) (S.groups[i].state = 3), (S.groups[i].t = 0);\n  S.groups = S.groups.filter((g, i) => i \u003c S.pairs || g.state !== 0);\n\n  // The wisp wanders the whole panel on two slow beats.\n  const T = S.clock * 2.5, ox = S.wx, oy = S.wy;\n  S.wx = 32 + 24 * sin(0.37 * T + 1.3 * sin(0.13 * T));\n  S.wy = 64 + 54 * sin(0.23 * T + 0.8 * sin(0.17 * T + 1));\n  if (f > 0) (S.wvx = (S.wx - ox) / f), (S.wvy = (S.wy - oy) / f);\n  S.flick = 0.82 + 0.18 * sin(T * 7.1) * sin(T * 3.3 + 1);\n  S.trail.unshift([S.wx, S.wy]);\n  if (S.trail.length > 16) S.trail.pop();\n\n  if (input.btnPressed && input.btnPressed[0]) {\n    S.stare = 2.5;\n    for (const g of S.groups) {\n      if (g.state === 0 && !place(S, g)) continue;\n      (g.state = 2), (g.t = 0), (g.dur = rnd(2.5, 5)), (g.bt = -1);\n    }\n  }\n  S.stare = max(0, S.stare - f);\n\n  for (const g of S.groups) {\n    g.t += f;\n    // A dash slides the eyes to somewhere else on the panel in 0.7 seconds,\n    // narrowed, looking where they go. Otherwise whatever owns them prowls:\n    // it drifts a few LEDs a second and turns back from the panel's edge and\n    // from the others.\n    if (g.dash >= 0) {\n      g.dash = min(1, g.dash + f / 0.7);\n      const e = sm(0, 1, g.dash);\n      g.x = g.x0 + (g.x1 - g.x0) * e;\n      g.y = g.y0 + (g.y1 - g.y0) * e;\n      if (g.dash >= 1) (g.dash = -1), (g.dashT = rnd(2.5, 7) * (1 - 0.7 * J));\n    } else if (g.state !== 0) {\n      const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc, sp = f * (1 + 1.5 * J);\n      let nx = g.x + g.vx * sp, ny = g.y + g.vy * sp;\n      if (nx \u003c w + 1 || nx > W - 1 - w || overlaps(S, g, nx, g.y)) (g.vx = -g.vx), (nx = g.x);\n      if (ny \u003c h + 3 || ny > H - 3 - h || overlaps(S, g, nx, ny)) (g.vy = -g.vy), (ny = g.y);\n      g.x = nx;\n      g.y = ny;\n    }\n    if (g.state === 0) {\n      if (g.t > g.dur && S.groups.indexOf(g) \u003c S.pairs && place(S, g)) (g.state = 1), (g.t = 0);\n    } else if (g.state === 1) {\n      g.o = sm(0, 0.35, g.t);\n      if (g.t > 0.35) (g.state = 2), (g.t = 0), (g.dur = rnd(2, 4.5) * (1 - 0.6 * J));\n    } else if (g.state === 2) {\n      g.o = S.stare > 0 ? min(1, g.o + f * 12) : 1;\n      // It shuts when its time is up, unless that would leave fewer than\n      // all but two of the sets open.\n      if (g.t > g.dur && S.stare \u003c= 0) {\n        if (S.groups.filter((o) => o.state === 1 || o.state === 2).length > S.pairs - 2) (g.state = 3), (g.t = 0);\n        else g.dur += rnd(0.4, 1.2);\n      }\n    } else {\n      g.o = 1 - sm(0, 0.3, g.t);\n      if (g.t > 0.3) (g.state = 0), (g.t = 0), (g.o = 0), (g.dur = rnd(0.3, 1.2) * (1 - 0.5 * J));\n    }\n    // Blinks: every 1 to 3 seconds when calm, 0.3 to 0.8 when jumpy, and\n    // a flinch when the wisp comes within 10 LEDs.\n    if (g.state === 2 && S.stare \u003c= 0) {\n      g.blink -= f;\n      if (g.near > 0.7 && g.blink > 0.6) g.blink = 0;\n      if (g.blink \u003c= 0 && g.bt \u003c 0) (g.bt = 0), (g.blink = rnd(1, 3) * (1 - 0.72 * J));\n    }\n    if (g.bt >= 0) {\n      g.bt += f / (g.type === OWL ? 0.32 : 0.2);\n      if (g.bt >= 1) g.bt = -1;\n    }\n    if (g.state === 2 && g.dash \u003c 0 && g.bt \u003c 0 && S.stare \u003c= 0) {\n      g.dashT -= f;\n      if (g.dashT \u003c= 0) {\n        const w = BOX[g.type][0] * g.sc, h = BOX[g.type][1] * g.sc;\n        g.dashT = 0.5;\n        for (let n = 0; n \u003c 60; n++) {\n          const x = rnd(w + 1, W - 1 - w), y = rnd(h + 3, H - 3 - h);\n          if (len(x - g.x, y - g.y) > 24 && !overlaps(S, g, x, y)) {\n            Object.assign(g, { dash: 0, x0: g.x, y0: g.y, x1: x, y1: y });\n            break;\n          }\n        }\n      }\n    }\n    // Where it looks: the wisp, the centre when staring, ahead in a dash, or\n    // a glance away.\n    g.glance -= f;\n    if (g.glance \u003c -g.gap) (g.glance = rnd(0.3, 0.8)), (g.gap = rnd(1.5, 6) * (1 - 0.8 * J)), (g.gx = rnd(0, W)), (g.gy = rnd(0, H));\n    let tx = S.wx, ty = S.wy;\n    if (S.stare > 0) (tx = 31.5), (ty = 63.5);\n    else if (g.dash >= 0) (tx = 2 * g.x1 - g.x0), (ty = 2 * g.y1 - g.y0);\n    else if (g.glance > 0) (tx = g.gx), (ty = g.gy);\n    const dx = tx - g.x, dy = ty - g.y, r = len(dx, dy) + 8, a = 1 - exp(-f * (8 + 20 * J));\n    g.px += (dx / r - g.px) * a;\n    g.py += (dy / r - g.py) * a;\n    // The wisp's light: cat pupils shut to slits near it, and every eye\n    // burns brighter.\n    const wd = len(S.wx - g.x, S.wy - g.y);\n    g.dil += (cl(wd / 40, 0, 1) - g.dil) * (1 - exp(-f * 3));\n    g.near = exp(-wd / 28);\n  }\n}\n\n// Signed distance to an almond (a lens of half-width a and half-height b)\n// in its own frame, negative inside.\nfunction almond(u, v, a, b) {\n  const au = abs(u);\n  if (au >= a) return len(au - a, v);\n  const h = b * (1 - (u * u) / (a * a)), s = (2 * b * au) / (a * a);\n  return (abs(v) - h) / sqrt(1 + s * s);\n}\n\nfunction put(S, x, y, r, g, b) {\n  const p = y * W + x, q = p * 3;\n  S.rgb[q] = r;\n  S.rgb[q + 1] = g;\n  S.rgb[q + 2] = b;\n  S.inside[p] = 1;\n}\n\n// One eye of a pair: centre (cx, cy), side -1 or 1, lids open by `open`.\nfunction eye(S, g, cx, cy, side, open, gain) {\n  const type = g.type, c = S.col, o = type * 6, a = EYE[type][0] * g.sc, b = EYE[type][1] * g.sc, z = g.sc;\n  // A cat's outer corner rises; a red eye's inner corner drops, so it glares.\n  const tilt = type === CAT ? -0.16 * side : type === RED ? 0.32 * side : 0, ct = cos(tilt), st = sin(tilt);\n  const pu = g.px * (type === OWL ? 2.6 : 3.8) * z, pv = g.py * (type === OWL ? 2.4 : 1.2) * z;\n  const bo = b * open, pw = 1.1 + 1.8 * g.dil * z;\n  for (let y = max(0, floor(cy - b - 2)); y \u003c= min(H - 1, floor(cy + b + 2)); y++)\n    for (let x = max(0, floor(cx - a - 2)); x \u003c= min(W - 1, floor(cx + a + 2)); x++) {\n      const X = x + 0.5 - cx, Y = y + 0.5 - cy, u = ct * X + st * Y, v = -st * X + ct * Y;\n      let dd, rr;\n      if (type === OWL) {\n        // Round, with lids that close from above and below.\n        rr = len(u, v);\n        dd = max(rr - a, abs(v) - bo);\n        rr /= a;\n      } else {\n        dd = almond(u, v, a, bo);\n        rr = len(u / a, v / b);\n      }\n      const cov = cl(0.5 - dd, 0, 1);\n      if (cov \u003c= 0) continue;\n      // Iris: bright at the centre, deeper at the edge.\n      const m = rr >= 1 ? 1 : rr * sqrt(rr), k = gain;\n      let R = (c[o] + (c[o + 3] - c[o]) * m) * k, G = (c[o + 1] + (c[o + 4] - c[o + 1]) * m) * k, B = (c[o + 2] + (c[o + 5] - c[o + 2]) * m) * k;\n      // Pupil: a slit for the cat, a disc for the owl, a coal for the red.\n      let p;\n      if (type === CAT) p = (len((u - pu) / pw, (v - pv) / (b * 0.92)) - 1) * pw;\n      else if (type === OWL) p = len(u - pu, v - pv) - 3.8 * z;\n      else p = len(u - pu * 0.8, v - pv) - 1.6 * z;\n      const pc = cl(0.5 - p, 0, 1) * (type === RED ? 0.75 : 1);\n      R *= 1 - pc;\n      G *= 1 - pc;\n      B *= 1 - pc;\n      // A glint, upper left of the middle.\n      if (type !== RED && len(u + 1.8 * z, v + (type === OWL ? 2.2 : 1.3) * z) \u003c 1.15) (R = 1), (G = 1), (B = 0.95);\n      put(S, x, y, R * cov, G * cov, B * cov);\n    }\n}\n\nfunction spider(S, g, open, gain) {\n  const c = S.col, o = SPIDER * 6, fl = 0.35 + 0.35 * S.warm[SPIDER];\n  for (let i = 0; i \u003c 8; i++) {\n    const [ex, ey, er0] = SPIDER_EYES[i];\n    // The eight light up one after another, the big pair first.\n    const er = er0 * g.sc * cl(open * 1.6 - i * 0.08, 0, 1);\n    if (er \u003c= 0.2) continue;\n    const cx = g.x + (ex + g.px * 1.5) * g.sc, cy = g.y + (ey + g.py * 1.5) * g.sc;\n    for (let y = max(0, floor(cy - er - 1)); y \u003c= min(H - 1, floor(cy + er + 1)); y++)\n      for (let x = max(0, floor(cx - er - 1)); x \u003c= min(W - 1, floor(cx + er + 1)); x++) {\n        const u = x + 0.5 - cx, v = y + 0.5 - cy, rr = len(u, v), cov = cl(er + 0.5 - rr, 0, 1);\n        if (cov \u003c= 0) continue;\n        // A glossy dome: dark in the middle, the rim lit, and the wisp's\n        // reflection sliding toward where it is.\n        const m = (fl + (1 - fl) * (rr / er) ** 2) * gain;\n        let R = c[o + 3] * m, G = c[o + 4] * m, B = c[o + 5] * m;\n        const hl = cl(er * 0.42 + 0.5 - len(u - g.px * er * 0.5, v - g.py * er * 0.5 + er * 0.25), 0, 1);\n        R += (1 - R) * hl;\n        G += (c[o + 1] * 0.4 + 0.6 - G) * hl;\n        B += (1 - B) * hl;\n        put(S, x, y, R * cov, G * cov, B * cov);\n      }\n  }\n}\n\n// Box blur of radius r along rows then columns, from src into dst, the\n// three colours in step.\nfunction blur(src, dst, tmp, r) {\n  const n = 1 / (2 * r + 1), st = W * 3;\n  for (let y = 0; y \u003c H; y++) {\n    const row = y * st;\n    let a = 0, b = 0, c = 0;\n    for (let x = 0; x \u003c= r; x++) (a += src[row + x * 3]), (b += src[row + x * 3 + 1]), (c += src[row + x * 3 + 2]);\n    for (let x = 0, q = row; x \u003c W; x++, q += 3) {\n      tmp[q] = a * n;\n      tmp[q + 1] = b * n;\n      tmp[q + 2] = c * n;\n      if (x >= r) (a -= src[q - r * 3]), (b -= src[q - r * 3 + 1]), (c -= src[q - r * 3 + 2]);\n      if (x + r + 1 \u003c W) (a += src[q + (r + 1) * 3]), (b += src[q + (r + 1) * 3 + 1]), (c += src[q + (r + 1) * 3 + 2]);\n    }\n  }\n  for (let x = 0; x \u003c W; x++) {\n    let a = 0, b = 0, c = 0;\n    for (let y = 0; y \u003c= r; y++) (a += tmp[y * st + x * 3]), (b += tmp[y * st + x * 3 + 1]), (c += tmp[y * st + x * 3 + 2]);\n    for (let y = 0, q = x * 3; y \u003c H; y++, q += st) {\n      dst[q] = a * n;\n      dst[q + 1] = b * n;\n      dst[q + 2] = c * n;\n      if (y >= r) (a -= tmp[q - r * st]), (b -= tmp[q - r * st + 1]), (c -= tmp[q - r * st + 2]);\n      if (y + r + 1 \u003c H) (a += tmp[q + (r + 1) * st]), (b += tmp[q + (r + 1) * st + 1]), (c += tmp[q + (r + 1) * st + 2]);\n    }\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { rgb, glow, halo, tmp, inside, col } = S;\n  for (let t = 0; t \u003c 4; t++) {\n    // An edge from orange round to lime is paled and lifted, or it would\n    // read brown or olive; the spider's dark domes most of all.\n    const e = S.shift + HUE[t][1], wm = max(0, 1 - abs(e - floor(e) - 0.14) / 0.14);\n    S.warm[t] = wm;\n    hsv(S.shift + HUE[t][0], t === SPIDER ? 0.6 : 0.55, 1, col, t * 6);\n    hsv(e, 0.95 - 0.3 * wm, (t === SPIDER ? 0.8 : 0.9) + 0.1 * wm, col, t * 6 + 3);\n  }\n  rgb.fill(0);\n  inside.fill(0);\n  for (const g of S.groups) {\n    if (g.state === 0) continue;\n    // A blink closes the lids and opens them again, quicker down than up;\n    // between blinks the lids narrow and widen a little on their own.\n    const bl = g.bt >= 0 ? sin(PI * (g.bt \u003c 0.4 ? g.bt / 0.8 : 0.5 + (g.bt - 0.4) / 1.2)) : 0;\n    const open = g.o * (1 - bl) * (g.type === OWL ? 1 : 0.86 + 0.14 * sin(S.clock * 1.7 + g.ph)) * (g.dash >= 0 ? 1 - 0.45 * sin(PI * g.dash) : 1);\n    const gain = 0.62 + 0.38 * g.near;\n    if (g.type === SPIDER) spider(S, g, g.o, gain);\n    else {\n      // The head turns with the eyes: the pair slides toward where it looks.\n      const sep = EYE[g.type][2] * g.sc * (1 - 0.1 * abs(g.px)), hx = g.x + g.px * 2.5 * g.sc, hy = g.y + g.py * 1.5 * g.sc;\n      eye(S, g, hx - sep, hy, -1, open, gain);\n      eye(S, g, hx + sep, hy, 1, open, gain);\n    }\n  }\n  // The eyes' glow on the dark round them.\n  blur(rgb, halo, tmp, 3);\n  blur(halo, glow, tmp, 3);\n  // The wisp: a pale flame whose tail is where it has just been.\n  const wc = [0, 0, 0];\n  hsv(S.shift + 0.45, 0.45, 1, wc, 0);\n  const tr = S.trail;\n  let x0 = W, x1 = 0, y0 = H, y1 = 0;\n  for (const [tx, ty] of tr) (x0 = min(x0, tx)), (x1 = max(x1, tx)), (y0 = min(y0, ty)), (y1 = max(y1, ty));\n  x0 = max(0, floor(x0 - 14));\n  x1 = min(W - 1, floor(x1 + 14));\n  y0 = max(0, floor(y0 - 14));\n  y1 = min(H - 1, floor(y1 + 14));\n  for (let y = 0, p = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, p++) {\n      const q = p * 3;\n      let r = rgb[q], gg = rgb[q + 1], b = rgb[q + 2];\n      if (!inside[p]) (r = floor(glow[q] * GLOW * 40) / 40), (gg = floor(glow[q + 1] * GLOW * 40) / 40), (b = floor(glow[q + 2] * GLOW * 40) / 40);\n      if (x >= x0 && x \u003c= x1 && y >= y0 && y \u003c= y1) {\n        let wl = 0, core = 0;\n        for (let i = 0; i \u003c tr.length; i += 3) {\n          const k = 1 - i / tr.length, rad = 1.2 + 1.9 * k, dd = len(x + 0.5 - tr[i][0], y + 0.5 - tr[i][1]);\n          if (dd \u003c 13) wl += k * k * exp(-dd / (2.4 + 2.6 * k)) * (1 - dd / 13);\n          core = max(core, k * cl(rad + 0.5 - dd, 0, 1));\n        }\n        wl *= 0.5 * S.flick;\n        r += wc[0] * wl + core * (1 - r) * 0.85;\n        gg += wc[1] * wl + core * (1 - gg) * 0.85;\n        b += wc[2] * wl + core * (1 - b) * 0.85;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, gg)), round(255 * min(1, b)));\n    }\n}\n","hinged-dissection":"// ===== Patternflow pattern =====\n// Title:   Hinged Dissection\n// Family:  geometry\n// Idea:    An equilateral triangle 62 LEDs on a side, cut into Dudeney's four pieces and hinged at three points, swings open into a chain that stands the height of the panel and folds shut into a square of the same area, then swings back.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dudeney's hinged dissection of the triangle into the square (Henry Dudeney, 1902), and the Wallace-Bolyai-Gerwien theorem that any two polygons of equal area cut into each other (William Wallace, 1807; Farkas Bolyai, 1832; Paul Gerwien, 1833), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hold=0..3, Gap=0..1\n//\n// Knob 1: Hue. Turns the four pieces round the wheel together. At 0 they are gold, rose, azure and mint.\n// Knob 2: Speed. At 2 one swing, triangle to square, takes 2.5 seconds; at 0.2 it takes 25 and at 3 it takes 1.7.\n// Knob 3: Hold. Seconds the triangle and the square stand still before the next swing: none at 0, so the pieces never stop, up to 3.\n// Knob 4: Gap. Pushes each piece out from the middle of the chain, an exploded view: at 0 the pieces meet along their cuts with a dark seam under 1 LED wide, at 1 each has moved 7 LEDs out.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, hypot, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = [v, q, p, p, t, v][i];\n  out[o + 1] = [t, v, v, q, p, p][i];\n  out[o + 2] = [p, p, t, v, v, q][i];\n}\n\n// Dudeney's cut, on a triangle of side 2 with A bottom left, B the apex and\n// C bottom right. D and E are the midpoints of AB and BC. The square has\n// side s = 3^(1/4), the root of the triangle's area sqrt(3). J is the point\n// of AC at distance s from E, K is 1 (half a side) further along AC, and L\n// and M are the feet of the perpendiculars from D and K to the cut EJ.\n// Pieces, each listed clockwise: ADLJ, DBEL, ECKM and the triangle JMK,\n// hinged at D, E and K.\nconst S3 = sqrt(3), SQ = 3 ** 0.25;\nconst A = [0, 0], B = [1, S3], C = [2, 0], D = [0.5, S3 / 2], E = [1.5, S3 / 2];\nconst J = [1.5 - sqrt(SQ * SQ - 0.75), 0], K = [J[0] + 1, 0];\nconst U = [(J[0] - E[0]) / SQ, (J[1] - E[1]) / SQ];\nconst foot = (p) => {\n  const t = (p[0] - E[0]) * U[0] + (p[1] - E[1]) * U[1];\n  return [E[0] + t * U[0], E[1] + t * U[1]];\n};\nconst L = foot(D), M = foot(K);\nconst PIECES = [[A, D, L, J], [D, B, E, L], [E, C, K, M], [J, M, K]];\n// Which corner of each piece is a hinge, as [piece, corner] pairs per hinge.\nconst HINGES = [[[0, 1], [1, 0]], [[1, 2], [2, 0]], [[2, 2], [3, 2]]];\nconst AREA = PIECES.map((p) => {\n  let a = 0;\n  for (let i = 0; i \u003c p.length; i++) a += p[i][0] * p[(i + 1) % p.length][1] - p[(i + 1) % p.length][0] * p[i][1];\n  return abs(a) / 2;\n});\n\n// LEDs per unit: the triangle is 62 LEDs on a side, the square 40.8.\nconst SC = 31;\n// Base hues: gold, rose, azure, mint.\nconst HUES = [0.13, 0.95, 0.58, 0.4];\n\n// Swing f runs 0 (triangle) to 1 (square). Every hinge turns the same way\n// by pi f, so piece n has turned n pi f: a search over the swing found no\n// overlap this way, where turning any hinge the other way overlaps.\n// The whole chain is turned by G(f) degrees as well: 0 at the triangle,\n// -41.15 at the square, which is the angle that sets the square upright,\n// and between them a sum of three sines fitted so the open chain stands\n// along the panel and never hangs more than 4 LEDs over either side.\nconst G = (f) => (PI / 180) * (-41.1503 * f + 34 * sin(PI * f) + 57 * sin(2 * PI * f) + 34 * sin(3 * PI * f));\n\nfunction rotAbout(p, c, a, out) {\n  const x = p[0] - c[0], y = p[1] - c[1], cs = cos(a), sn = sin(a);\n  out[0] = c[0] + cs * x - sn * y;\n  out[1] = c[1] + sn * x + cs * y;\n}\n\n// The four pieces at swing f, in triangle units.\nfunction pose(f, out) {\n  const t = PI * f, q = [0, 0];\n  for (let n = 0; n \u003c 4; n++) {\n    const src = PIECES[n], dst = out[n];\n    for (let i = 0; i \u003c src.length; i++) {\n      let p = src[i];\n      // Turn about the hinges from the far end of the chain inward: K, E, D.\n      if (n >= 3) (rotAbout(p, K, t, q), (p = [q[0], q[1]]));\n      if (n >= 2) (rotAbout(p, E, t, q), (p = [q[0], q[1]]));\n      if (n >= 1) (rotAbout(p, D, t, q), (p = [q[0], q[1]]));\n      dst[i][0] = p[0];\n      dst[i][1] = p[1];\n    }\n  }\n}\n\nfunction centroid(p) {\n  let a = 0, x = 0, y = 0;\n  for (let i = 0; i \u003c p.length; i++) {\n    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % p.length], c = x0 * y1 - x1 * y0;\n    a += c;\n    x += (x0 + x1) * c;\n    y += (y0 + y1) * c;\n  }\n  return [x / (3 * a), y / (3 * a)];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, hold: 0, gap: 0.06,\n    tau: 0, dir: 1, wait: 0, begun: false,\n    world: PIECES.map((p) => p.map(() => [0, 0])),\n    scr: PIECES.map((p) => p.map(() => [0, 0])),\n    col: new Float32Array(4 * 6), colHue: NaN,\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.hold = cl(k[2], 0, 3);\n  S.gap = cl(k[3], 0, 1);\n  // The triangle stands for one hold before the first swing too.\n  if (!S.begun) (S.begun = true), (S.wait = S.hold);\n  if (S.wait > 0) {\n    S.wait = min(S.wait, S.hold) - d;\n    return;\n  }\n  S.tau += (S.dir * d * S.speed) / 5;\n  if (S.tau >= 1) (S.tau = 1), (S.dir = -1), (S.wait = S.hold);\n  else if (S.tau \u003c= 0) (S.tau = 0), (S.dir = 1), (S.wait = S.hold);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { world, scr, col } = S;\n  if (S.colHue !== S.hue) {\n    for (let n = 0; n \u003c 4; n++) {\n      hsv(S.hue + HUES[n], 0.8, 0.9, col, n * 6);\n      hsv(S.hue + HUES[n], 0.42, 1, col, n * 6 + 3);\n    }\n    S.colHue = S.hue;\n  }\n  const t = S.tau, f = t * t * (3 - 2 * t);\n  pose(f, world);\n  // Turn the chain about its centre of area, then centre its bounding box.\n  let ax = 0, ay = 0, at = 0;\n  const cent = world.map(centroid);\n  for (let n = 0; n \u003c 4; n++) (ax += AREA[n] * cent[n][0]), (ay += AREA[n] * cent[n][1]), (at += AREA[n]);\n  (ax /= at), (ay /= at);\n  const g = G(f), cg = cos(g), sg = sin(g);\n  let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n  for (let n = 0; n \u003c 4; n++)\n    for (let i = 0; i \u003c world[n].length; i++) {\n      const x = world[n][i][0] - ax, y = world[n][i][1] - ay, X = cg * x - sg * y, Y = sg * x + cg * y;\n      scr[n][i][0] = X;\n      scr[n][i][1] = Y;\n      (x0 = min(x0, X)), (x1 = max(x1, X)), (y0 = min(y0, Y)), (y1 = max(y1, Y));\n    }\n  const mx = (x0 + x1) / 2, my = (y0 + y1) / 2;\n  // To LEDs, y down. The gap pushes each piece out along the line from the\n  // chain's centre to its own.\n  const gapL = 7 * S.gap;\n  const polys = [];\n  for (let n = 0; n \u003c 4; n++) {\n    let cx = 0, cy = 0;\n    for (const p of scr[n]) (cx += p[0]), (cy += p[1]);\n    (cx /= scr[n].length), (cy /= scr[n].length);\n    const r = hypot(cx, cy) || 1, ox = (gapL * cx) / r, oy = (gapL * cy) / r;\n    const pts = scr[n].map((p) => [W / 2 + (p[0] - mx) * SC + ox, H / 2 - (p[1] - my) * SC - oy]);\n    // Edges as half-planes, n.p \u003c= c inside, with n turned outward by the\n    // sign of the piece's area as it now lies.\n    let sa = 0;\n    for (let i = 0; i \u003c pts.length; i++) sa += pts[i][0] * pts[(i + 1) % pts.length][1] - pts[(i + 1) % pts.length][0] * pts[i][1];\n    const sgn = sa > 0 ? 1 : -1, edges = [];\n    let bx0 = 1e9, bx1 = -1e9, by0 = 1e9, by1 = -1e9;\n    for (let i = 0; i \u003c pts.length; i++) {\n      const [px, py] = pts[i], [qx, qy] = pts[(i + 1) % pts.length], len = hypot(qx - px, qy - py);\n      const nx = (sgn * (qy - py)) / len, ny = (-sgn * (qx - px)) / len;\n      edges.push(nx, ny, nx * px + ny * py);\n      (bx0 = min(bx0, px)), (bx1 = max(bx1, px)), (by0 = min(by0, py)), (by1 = max(by1, py));\n    }\n    polys.push({ edges, pts, bx0, bx1, by0, by1 });\n  }\n  // Signed distance to a convex piece: the largest of its edge distances.\n  // Inside by more than 0.35 LED is lit, so pieces that touch keep a dark\n  // seam; the outer 1.1 LED of a piece is its rim.\n  const sd = (e, x, y) => {\n    let m = -1e9;\n    for (let i = 0; i \u003c e.length; i += 3) m = max(m, e[i] * x + e[i + 1] * y - e[i + 2]);\n    return m;\n  };\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5, py = y + 0.5;\n      let r = 0, gg = 0, b = 0;\n      for (let n = 0; n \u003c 4; n++) {\n        const P = polys[n];\n        if (px \u003c P.bx0 || px > P.bx1 || py \u003c P.by0 || py > P.by1) continue;\n        const dd = sd(P.edges, px, py);\n        if (dd > -0.35) continue;\n        const o = n * 6 + (dd > -1.45 ? 3 : 0);\n        (r = col[o]), (gg = col[o + 1]), (b = col[o + 2]);\n      }\n      display.setPixel(x, y, floor(r * 255), floor(gg * 255), floor(b * 255));\n    }\n  // The hinges: a white pin on each piece's own copy of the hinge point.\n  for (const pair of HINGES)\n    for (const [n, i] of pair) {\n      const [hx, hy] = polys[n].pts[i];\n      for (let y = floor(hy - 2); y \u003c= floor(hy + 2); y++)\n        for (let x = floor(hx - 2); x \u003c= floor(hx + 2); x++) {\n          if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) continue;\n          if (hypot(x + 0.5 - hx, y + 0.5 - hy) \u003c 1.6) display.setPixel(x, y, 255, 255, 255);\n        }\n    }\n}\n","jack-o-lantern":"// ===== Patternflow pattern =====\n// Title:   Jack-o'-Lantern\n// Family:  halloween\n// Idea:    A carved pumpkin sits at the foot of the panel lit by a candle inside, its eyes, nose and grin pulsing from deep orange to white-hot as the flame flickers, and from every opening a shaft of light climbs the panel and swings with the flame, a violet haze in clear air that turns orange where it crosses the drifting purple fog banks.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the carved turnip and pumpkin lanterns of Halloween\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Fire=0..1, Speed=0.2..3, Face=0..3, Fog=-1..1\n//\n// Knob 1: Fire. The colour of the candle, and so of the carving and the shafts. At 0 an orange flame in purple mist; at 0.33 toxic green in purple; at 0.67 violet in green mist; at 1 a blue flame in purple. The pumpkin itself stays orange.\n// Knob 2: Speed. Runs the flame, its sway and the mist together. At 2 the flame pulses on beats of 1.4, 3.4 and 7.2 a second under a wandering dip, the candle sways up to 3 LEDs either way and swings the eye shafts about 5 degrees, and the fog banks sink 1.6 LEDs a second while their ripples drift left at about 6; at 0.2 all of it runs ten times slower, at 3 half as fast again.\n// Knob 3: Face. Four carvings. 0: triangle eyes and nose and a grin with three teeth. 1: slanted angry eyes and a jagged mouth whose teeth interlock. 2: round eyes with the pupils left standing, so each eye's shaft carries a dark core up the panel, and an open O. 3: crescent eyes and a grin crossed by stitches, each gap throwing its own thin shaft down to the ground fog.\n// Knob 4: Fog. At -1 the air is clear and the shafts show only as violet haze, about 108 to 126 LEDs long. At 0.06, the opening, fog banks about 20 rows apart drift across, turning orange where a shaft crosses them, and the shafts reach about 81 to 94 LEDs, their ends ragged with the mist. At 1 the fog fills most of the panel and the shafts reach about 57 to 66.\n// Buttons: K1 tap snuffs the candle: for 0.8 seconds it gutters and the shafts draw back into the pumpkin, then it is out for 1.2 seconds with the carving an ember red, then it flares white and burns again by 2.5 seconds.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, abs, round, sin, hypot, sqrt, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\nconst mix = (a, b, t) => a + (b - a) * t;\n\nfunction hash(i, j) {\n  let h = Math.imul(i, 374761393) ^ Math.imul(j, 668265263);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\nfunction vnoise(x, y) {\n  const i = floor(x), j = floor(y), fx = x - i, fy = y - j;\n  const u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);\n  const a = hash(i, j), b = hash(i + 1, j), c = hash(i, j + 1), d = hash(i + 1, j + 1);\n  return a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v;\n}\n\n// The pumpkin, centred at PX, PY: five lobes, [x offset, half-width,\n// half-height], the front one first so it shades the LEDs it holds.\nconst PX = 32, PY = 100;\nconst LOBES = [\n  [0, 13, 22],\n  [-10, 13, 21],\n  [10, 13, 21],\n  [-18, 10, 18],\n  [18, 10, 18],\n];\n// The candle, from the pumpkin's centre: between the nose and the grin.\nconst CX = 0, CY = 4.5;\n\nfunction inTri(px, py, t) {\n  const [[ax, ay], [bx, by], [cx, cy]] = t;\n  const d1 = (px - bx) * (ay - by) - (ax - bx) * (py - by);\n  const d2 = (px - cx) * (by - cy) - (bx - cx) * (py - cy);\n  const d3 = (px - ax) * (cy - ay) - (cx - ax) * (py - ay);\n  return !((d1 \u003c 0 || d2 \u003c 0 || d3 \u003c 0) && (d1 > 0 || d2 > 0 || d3 > 0));\n}\nconst tri = (x) => abs(x - 6 * floor(x / 6) - 3);\n\n// The four carvings, in pumpkin coordinates (x right, y down from the\n// centre): 1 where the knife went through.\nconst FACES = [\n  // Triangle eyes, triangle nose, a grin with two teeth above and one below.\n  (x, y) => {\n    if (inTri(x, y, [[-17, -4], [-5, -4], [-11, -15]]) || inTri(x, y, [[17, -4], [5, -4], [11, -15]])) return 1;\n    if (inTri(x, y, [[-3.5, 3], [3.5, 3], [0, -3]])) return 1;\n    const u = x / 20;\n    if (abs(u) >= 1) return 0;\n    const top = 6 + 4 * (1 - u * u), bot = 6 + 12 * (1 - u * u);\n    if (y \u003c= top || y >= bot) return 0;\n    if (((x > -10 && x \u003c -5) || (x > 5 && x \u003c 10)) && y \u003c top + 4) return 0;\n    return x > -2.5 && x \u003c 2.5 && y > bot - 4 ? 0 : 1;\n  },\n  // Slanted angry eyes and a jagged mouth whose teeth interlock.\n  (x, y) => {\n    if (inTri(x, y, [[-18, -13], [-4, -6], [-13, -2]]) || inTri(x, y, [[18, -13], [4, -6], [13, -2]])) return 1;\n    if (inTri(x, y, [[-3, 3], [3, 3], [0, -2]])) return 1;\n    if (abs(x) > 19) return 0;\n    const bend = 0.012 * x * x;\n    return y > 7 + tri(x + 19) - bend && y \u003c 16 - tri(x + 22) - bend ? 1 : 0;\n  },\n  // Round eyes with the pupils left standing, and an open O.\n  (x, y) => {\n    for (const s of [-1, 1]) {\n      const d = hypot(x - s * 10, y + 7);\n      if (d \u003c 6) return d > 2.4 ? 1 : 0;\n    }\n    if (inTri(x, y, [[-2.5, 3], [2.5, 3], [0, -1]])) return 1;\n    return hypot(x / 7.5, (y - 11) / 6.5) \u003c 1 ? 1 : 0;\n  },\n  // Crescent eyes and a wide grin crossed by stitches.\n  (x, y) => {\n    for (const s of [-1, 1]) {\n      const ex = x - s * 10, ey = y + 6;\n      if (hypot(ex, ey) \u003c 6.5 && hypot(ex, ey + 4) > 6) return 1;\n    }\n    const u = x / 22;\n    if (abs(u) >= 1) return 0;\n    const top = 3 + 8 * (1 - u * u), bot = top + 5 + 2 * (1 - u * u);\n    return y > top && y \u003c bot && abs(x + 30 - 5 * floor((x + 30) / 5) - 2.5) \u003c 1.4 ? 1 : 0;\n  },\n];\n\n// Fire colours along K1: flame, white-hot core, mist.\nconst FIRES = [\n  [[1, 0.48, 0.03], [1, 0.93, 0.55], [0.42, 0.1, 0.66]],\n  [[0.42, 1, 0.06], [0.88, 1, 0.6], [0.42, 0.1, 0.66]],\n  [[0.68, 0.2, 1], [0.96, 0.82, 1], [0.08, 0.5, 0.2]],\n  [[0.2, 0.55, 1], [0.82, 0.96, 1], [0.4, 0.1, 0.62]],\n];\n\nexport function setup(params) {\n  const body = new Float32Array(N), holes = FACES.map(() => new Uint8Array(N)), stem = new Uint8Array(N);\n  // The stem: a thick green curve leaning right from the top of the pumpkin.\n  const curve = [];\n  for (let i = 0; i \u003c= 24; i++) {\n    const t = i / 24;\n    curve.push([mix(mix(-1, -1.5, t), mix(-1.5, 5, t), t), mix(mix(-19, -26, t), mix(-26, -29, t), t), 2.4 - 0.8 * t]);\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5 - PX, py = y + 0.5 - PY, p = y * W + x;\n      for (const [lx, rx, ry] of LOBES) {\n        const rho = hypot((px - lx) / rx, py / ry);\n        if (rho \u003c 1) {\n          body[p] = sqrt(1 - rho * rho);\n          break;\n        }\n      }\n      if (body[p] > 0) FACES.forEach((f, i) => (holes[i][p] = f(px, py)));\n      else for (const [sx, sy, sr] of curve) if (hypot(px - sx, py - sy) \u003c sr) stem[p] = 1;\n    }\n  // Each hole LED's distance to the flesh, for the glowing cut rim.\n  const edges = holes.map((h) => {\n    const e = new Float32Array(N);\n    for (let p = 0; p \u003c N; p++) {\n      if (!h[p]) continue;\n      const x = p % W, y = floor(p / W);\n      let best = 9;\n      for (let j = -3; j \u003c= 3; j++)\n        for (let i = -3; i \u003c= 3; i++) if (!h[(y + j) * W + x + i]) best = min(best, hypot(i, j));\n      e[p] = best;\n    }\n    return e;\n  });\n  // The openings of each carving, by flood fill. Slivers at the tapering\n  // ends of a grin, under 10 LEDs, throw no shaft of their own.\n  const openings = holes.map((h) => {\n    const seen = new Uint8Array(N), out = [];\n    for (let p0 = 0; p0 \u003c N; p0++) {\n      if (!h[p0] || seen[p0]) continue;\n      const px = [], stack = [p0];\n      seen[p0] = 1;\n      while (stack.length) {\n        const p = stack.pop(), x = p % W;\n        px.push(p);\n        for (const q of [x \u003c W - 1 ? p + 1 : -1, x > 0 ? p - 1 : -1, p + W, p - W]) if (q >= 0 && q \u003c N && h[q] && !seen[q]) (seen[q] = 1), stack.push(q);\n      }\n      if (px.length \u003c 10) continue;\n      let sx = 0, sy = 0;\n      for (const p of px) (sx += (p % W) + 0.5), (sy += floor(p / W) + 0.5);\n      out.push({ px, x: sx / px.length, y: sy / px.length, ux: 0, uy: 1, mask: new Uint8Array(NB), end: new Float32Array(NB) });\n    }\n    return out;\n  });\n  params.s = {\n    fire: 0, speed: 2, face: 0, fog: 0.06, t: 0, pulse: 0.5, sway: 0, bob: 0, light: 1, gut: -1,\n    body, holes, edges, openings, stem, grid: new Float32Array(17 * 33), pal: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n}\n\n// The candle out, then back: seconds from the tap.\nconst DIE = 0.8, DARK = 2, LIGHT = 2.5;\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.fire = cl(k[0], 0, 1);\n  S.speed = cl(k[1], 0.2, 3);\n  S.face = round(cl(k[2], 0, 3));\n  S.fog = cl(k[3], -1, 1);\n  S.t += d * S.speed;\n  // The flame: a slow breath, a quick shiver and a wandering dip, 0..1.\n  const t = S.t * 2.5;\n  S.pulse = cl(0.55 + 0.2 * sin(t * 1.7) + 0.12 * sin(t * 4.3 + 1) + 0.1 * sin(t * 9.1 + 2) + 0.7 * (vnoise(t * 2.6, 3.7) - 0.5), 0, 1);\n  S.sway = 3 * (vnoise(S.t * 1.1, 9.1) - 0.5) * 2;\n  S.bob = vnoise(S.t * 2.3, 1.3) - 0.5;\n  if (input.btnPressed && input.btnPressed[0] && S.gut \u003c 0) S.gut = 0;\n  if (S.gut >= 0) {\n    S.gut += d;\n    const g = S.gut;\n    // Gutters: shrinking with big shudders; out; then a flare and back.\n    if (g \u003c DIE) S.light = (1 - g / DIE) * (0.6 + 0.4 * vnoise(g * 14, 2.2));\n    else if (g \u003c DARK) S.light = 0;\n    else if (g \u003c LIGHT) S.light = 1.25 * sm(DARK, DARK + 0.12, g) - 0.25 * sm(DARK + 0.12, LIGHT, g);\n    else (S.light = 1), (S.gut = -1);\n  }\n}\n\n// Each opening throws its own shaft: the opening pushed outward along the\n// line from the candle through its middle, that line squeezed sideways to\n// 0.42 so the shafts climb the tall panel instead of leaving by its sides,\n// and widening by 0.6% a LED. The profile across a shaft is the opening's\n// own, teeth and pupils and all.\nconst SQUEEZE = 0.42, SPREAD = 0.006, BIN = 2, NB = 120;\nfunction aim(S, cx, cy) {\n  const list = S.openings[S.face];\n  for (const c of list) {\n    let ux = (c.x - cx) * SQUEEZE, uy = c.y - cy;\n    const l = hypot(ux, uy) || 1;\n    (ux /= l), (uy /= l), (c.ux = ux), (c.uy = uy);\n    c.mask.fill(0);\n    c.end.fill(-1e9);\n    for (const p of c.px) {\n      const dx = (p % W) + 0.5 - c.x, dy = floor(p / W) + 0.5 - c.y, sv = dx * ux + dy * uy, vv = dy * ux - dx * uy;\n      for (let b = floor((vv - 0.5) * BIN + NB / 2); b \u003c= floor((vv + 0.5) * BIN + NB / 2); b++) {\n        if (b \u003c 0 || b >= NB) continue;\n        c.mask[b] = 1;\n        c.end[b] = max(c.end[b], sv);\n      }\n    }\n  }\n  return list;\n}\n\nfunction palette(S) {\n  const u = S.fire * 3, i = min(2, floor(u)), t = u - i;\n  for (let c = 0; c \u003c 3; c++) for (let ch = 0; ch \u003c 3; ch++) S.pal[c][ch] = mix(FIRES[i][c][ch], FIRES[i + 1][c][ch], t);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const { body, stem, grid: G } = S, hole = S.holes[S.face], edge = S.edges[S.face];\n  const [flame, hot, mist] = S.pal, P = S.pulse, L = S.light;\n  const list = aim(S, PX + CX + S.sway, PY + CY + S.bob);\n  // Fog: how much of the dark the mist takes, and how far the shafts reach,\n  // which breathes with the flame and shrinks to nothing as it gutters.\n  const fogD = 0.37 + 0.3 * S.fog, reach = (96 - 30 * S.fog) * (0.86 + 0.14 * P) * min(1, L);\n  // The mist, on a grid 4 LEDs a cell read back bilinearly: banks every 20\n  // rows, sinking slowly and rippled by a noise drifting left, broken by a\n  // finer noise drifting right and up, thicker on the ground where the\n  // grin's shaft lands, and cut at two levels.\n  const mt = S.t;\n  for (let j = 0; j \u003c 33; j++)\n    for (let i = 0; i \u003c 17; i++)\n      G[j * 17 + i] = 0.5 + 0.28 * sin(TAU * (j / 5 - mt * 0.04) + 3 * (vnoise(i / 8 + mt * 0.09, j / 4) - 0.5)) + 0.3 * (vnoise(i / 4 - mt * 0.16, j / 1.5 + 0.3 * mt) - 0.5) + 0.2 * sm(28, 32, j);\n  // The openings: white-hot inside, flame-coloured at the cut rim; as the\n  // candle dies they sink to an ember red.\n  const ember = [0.45, 0.04, 0.02], lit = min(1, L), flare = max(0, L - 1) * 4;\n  const holeCol = (rim, ch) => mix(ember[ch], mix(rim ? flame[ch] : mix(flame[ch], hot[ch], 0.45 + 0.55 * P), 1, flare) * (0.82 + 0.18 * P), lit);\n  const inner = [holeCol(false, 0), holeCol(false, 1), holeCol(false, 2)], rim = [holeCol(true, 0), holeCol(true, 1), holeCol(true, 2)];\n  // Lit mist: the flame colour a little toward white-hot when the flame peaks.\n  const beam = [0, 1, 2].map((ch) => mix(flame[ch], hot[ch], 0.3 * P) * (0.84 + 0.16 * P));\n  const glow = mix(0.45, 0.74 + 0.26 * P, lit);\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      let r = 0, g = 0, b = 0;\n      if (body[p] > 0) {\n        if (hole[p]) {\n          const c = edge[p] \u003c 1.6 ? rim : inner;\n          (r = c[0]), (g = c[1]), (b = c[2]);\n        } else {\n          // Two tones a lobe and a dark seam between lobes, warmed by the candle.\n          const v = (body[p] > 0.6 ? 0.74 : body[p] > 0.4 ? 0.52 : 0) * glow;\n          (r = v), (g = 0.36 * v * v), (b = 0.02 * v);\n        }\n      } else if (stem[p]) {\n        (r = 0.32), (g = 0.86), (b = 0.12);\n      } else {\n        const gx = x / 4, gy = y / 4, i = floor(gx), j = floor(gy), u = gx - i, v = gy - j, q = j * 17 + i;\n        const n = (G[q] * (1 - u) + G[q + 1] * u) * (1 - v) + (G[q + 17] * (1 - u) + G[q + 18] * u) * v;\n        const m = n > 1.12 - fogD ? 2 : n > 1 - fogD ? 1 : 0;\n        // Inside a shaft? Its end is ragged with the mist.\n        let inside = false;\n        const far = reach * (0.75 + 0.5 * n);\n        for (const c of list) {\n          const dx = x + 0.5 - c.x, dy = y + 0.5 - c.y, sv = dx * c.ux + dy * c.uy;\n          if (sv \u003c= 0) continue;\n          const bn = floor(((dy * c.ux - dx * c.uy) / (1 + SPREAD * sv)) * BIN + NB / 2);\n          if (bn >= 0 && bn \u003c NB && c.mask[bn] && sv > c.end[bn] && sv \u003c c.end[bn] + far) {\n            inside = true;\n            break;\n          }\n        }\n        // Lit mist takes the flame's colour; a shaft through clear air shows\n        // as a faint violet haze between the banks.\n        if (inside && m) {\n          const lv = m === 2 ? 1 : 0.8;\n          (r = beam[0] * lv), (g = beam[1] * lv), (b = beam[2] * lv);\n        } else if (inside) {\n          (r = mist[0] * 0.3 + beam[0] * 0.12), (g = mist[1] * 0.3 + beam[1] * 0.12), (b = mist[2] * 0.3 + beam[2] * 0.12);\n        } else if (m) {\n          const lv = m === 2 ? 0.44 : 0.26;\n          (r = mist[0] * lv), (g = mist[1] * lv), (b = mist[2] * lv);\n        }\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","polytope-slices":"// ===== Patternflow pattern =====\n// Title:   Polytope Slices\n// Family:  space\n// Idea:    A regular four-dimensional polytope passes down through three parallel 3D hyperplanes stacked up the panel while it tilts slowly in 4D, and each cut is drawn as a flat-shaded solid turning in space that swells from a point or a whole cell into a polyhedron, changes shape each time its hyperplane crosses a layer of vertices and shrinks away, every face coloured by the 4D cell it lies in.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: the regular convex 4-polytopes (Ludwig Schläfli, 1852), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Polytope=0..3, Tilt=-1..1\n//\n// Knob 1: Hue. Turns the cell colours round the wheel together. At 0 the 24-cell's three families of cells, three 16-cells' worth that never share a face, are teal, violet and rose; the tesseract and the 16-cell add azure and the 5-cell plum. A face that comes round to orange, yellow or lime is paled and lit higher, so it never reads brown or olive.\n// Knob 2: Speed. At 2 a pass takes 7 seconds, from the top slice's first point to the bottom slice's last, and a pass spends most of it near the polytope's middle and crosses its outer fifth fast; at 0.2 it takes 70 seconds, at 3 under 5. The slices turn round the vertical once in 12.6 seconds at 2, and the 4D wander keeps the same pace.\n// Knob 3: Polytope. 0 the 24-cell (24 octahedra, its slices up to 18 faces), 1 the tesseract (8 cubes, up to 8), 2 the 16-cell (16 tetrahedra, up to 14), 3 the 5-cell (5 tetrahedra, up to 5). Each is scaled so its circumradius is 29 LEDs, and a slice through the middle can fill the panel's width.\n// Knob 4: Tilt. Swings the hyperplanes' normal from the centre of one cell (-1) to a vertex of that cell (+1), 45 degrees for the 24-cell, 60 for the tesseract and the 16-cell, 75.5 for the 5-cell. At -1 nothing turns in 4D: the 24-cell comes in as a whole octahedron, is a truncated octahedron all the way down and a cuboctahedron at its middle, and the tesseract is one cube that appears and vanishes whole. At +1 the tesseract grows from a point as a tetrahedron, is truncated from half its reach on and is an octahedron at the middle, and the 24-cell grows as a cube, chamfers and is a rhombic dodecahedron at the middle. Between the ends the normal wanders up to 0.3 radians toward the vertex and 0.9 round it, most at 0, so the polytope turns slowly in 4D and no two passes are alike.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, sin, cos, abs, round, acos, hypot } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst dot4 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// A polytope is its facets, one per 3D cell (unit normal n and offset d, the\n// cell lying in n.x = d and the polytope in n.x \u003c= d), a colour class per\n// cell chosen so two cells that share a 2-face never share a class, and its\n// vertices. It is turned once so that the centre of one cell lies on the\n// fourth axis and a vertex of that same cell in the plane of the first and\n// fourth axes, alpha away: Tilt swings the hyperplanes' normal through that\n// angle, from the cell to the vertex.\nfunction build(normals, d, cls, verts, cellAxis, vertexAxis) {\n  const unit = (x) => {\n    const l = hypot(x[0], x[1], x[2], x[3]);\n    return x.map((t) => t / l);\n  };\n  const g4 = unit(cellAxis), vv = unit(vertexAxis), c = dot4(vv, g4);\n  const G = [unit(vv.map((t, i) => t - c * g4[i])), g4];\n  for (const e of [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) {\n    if (G.length === 4) break;\n    let w = e.slice();\n    for (const g of G) {\n      const p = dot4(w, g);\n      w = w.map((t, i) => t - p * g[i]);\n    }\n    if (hypot(w[0], w[1], w[2], w[3]) > 1e-6) G.push(unit(w));\n  }\n  const B = [G[0], G[2], G[3], G[1]], to = (x) => B.map((b) => dot4(b, x));\n  // The edges: pairs of vertices at the shortest distance.\n  const dist = (a, b) => hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]);\n  let shortest = 1e9;\n  for (let i = 0; i \u003c verts.length; i++) for (let j = i + 1; j \u003c verts.length; j++) shortest = min(shortest, dist(verts[i], verts[j]));\n  const edges = [];\n  for (let i = 0; i \u003c verts.length; i++) for (let j = i + 1; j \u003c verts.length; j++) if (dist(verts[i], verts[j]) \u003c shortest + 1e-9) edges.push(i, j);\n  return {\n    n: normals.map(to).flat(), d, cls, v: verts.map(to).flat(), k: normals.length, edges,\n    R: hypot(verts[0][0], verts[0][1], verts[0][2], verts[0][3]), alpha: acos(c),\n  };\n}\nconst sgn = (m, i) => ((m >> i) & 1 ? -1 : 1);\nconst pop = (m) => (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1);\nconst axes = () => {\n  const out = [];\n  for (let i = 0; i \u003c 4; i++)\n    for (const s of [1, -1]) {\n      const e = [0, 0, 0, 0];\n      e[i] = s;\n      out.push([e, i]);\n    }\n  return out;\n};\nconst halves = () => Array.from({ length: 16 }, (_, m) => [[0, 1, 2, 3].map((i) => sgn(m, i) / 2), pop(m)]);\n\n// The 24-cell: 24 octahedra, 24 vertices (+-1, +-1, 0, 0). Its cells fall\n// into three 16-cells' worth, and cells in the same one never touch.\nfunction cell24() {\n  const f = [...axes().map(([e]) => [e, 0]), ...halves().map(([e, p]) => [e, 1 + (p & 1)])], v = [];\n  for (let i = 0; i \u003c 4; i++)\n    for (let j = i + 1; j \u003c 4; j++)\n      for (let m = 0; m \u003c 4; m++) {\n        const e = [0, 0, 0, 0];\n        e[i] = sgn(m, 0);\n        e[j] = sgn(m, 1);\n        v.push(e);\n      }\n  return build(f.map((x) => x[0]), f.map(() => 1), f.map((x) => x[1]), v, [0, 0, 0, 1], [1, 0, 0, 1]);\n}\n// The tesseract: 8 cubes, opposite ones share a colour.\nfunction tesseract() {\n  const f = axes();\n  const v = Array.from({ length: 16 }, (_, m) => [0, 1, 2, 3].map((i) => sgn(m, i)));\n  return build(f.map((x) => x[0]), f.map(() => 1), f.map((x) => x[1]), v, [0, 0, 0, 1], [1, 1, 1, 1]);\n}\n// The 16-cell: 16 tetrahedra; two touch when their normals differ in one\n// sign, so the count of minus signs, mod 4, never repeats across a face.\nfunction cell16() {\n  const f = halves();\n  return build(f.map((x) => x[0]), f.map(() => 0.5), f.map((x) => x[1] & 3), axes().map(([e]) => e), [1, 1, 1, 1], [1, 0, 0, 0]);\n}\n// The 5-cell: 5 tetrahedra, every one touching every other.\nfunction cell5() {\n  const a = 1 / sqrt(5), R = sqrt(3.2);\n  const v = [[1, 1, 1, -a], [1, -1, -1, -a], [-1, 1, -1, -a], [-1, -1, 1, -a], [0, 0, 0, 4 * a]];\n  return build(v.map((p) => p.map((x) => -x / R)), v.map(() => R / 4), [0, 1, 2, 3, 4], v, v[0].map((x) => -x), v[4]);\n}\nconst POLY = [cell24(), tesseract(), cell16(), cell5()];\n\n// LEDs to the circumradius: a slice through the centre is up to 58 LEDs\n// across. The map's detail comes from the seams and rims and its drift from\n// the dark moment between passes, and both grow with the slices: at 28 they\n// read 0.092 and 0.357, at 30 0.096 and 0.401, near the drift axis's end.\nconst FILL = 29;\n// How far a rim LED is lifted toward white, and a seam's share of its face.\nconst RING = 0.5, SEAM = 0.06;\n// The three hyperplanes' rows, and how far apart they lie in 4D as a share\n// of the polytope's reach along the normal: close enough that the three cuts\n// are plainly one solid, far enough that the top one empties first.\nconst SLOT_Y = [23, 64, 105], DEL = 0.22;\n// Seconds a pass takes at Speed 1, and how much of it the slices spend near\n// the middle: the hyperplanes cross the outer fifth of the polytope fast.\nconst PASS = 14, DW = 0.3;\n// Opening hues of the five colour classes: teal, violet, rose, azure, plum.\nconst PAL = [0.5, 0.75, 0.92, 0.6, 0.83];\n// Light from the upper left, in front.\nconst LX = -0.45, LY = -0.55, LZ = -0.7;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, poly: 0, tilt: 0.06,\n    pass: 0.15, spin: 0.7, view: 0.4,\n    m: new Float64Array(3 * 24), w: new Float64Array(24), fcol: new Float32Array(3 * 24),\n    vx: new Float64Array(24), vy: new Float64Array(24), vw: new Float64Array(24),\n    fa: new Float64Array(24), fb: new Float64Array(24), fc: new Float64Array(24), fr: new Float64Array(24), fi: new Int8Array(24),\n    ba: new Float64Array(24), bb: new Float64Array(24), bc: new Float64Array(24), br: new Float64Array(24),\n    col: new Float32Array(5 * 3), warm: new Float32Array(5),\n    id: new Int16Array(W * H), rgb: new Float32Array(W * H * 3), z: new Float32Array(W * H), e: new Uint8Array(W * H),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.poly = min(3, floor(cl(k[2], 0, 3) + 0.5));\n  S.tilt = cl(k[3], -1, 1);\n  const v = d * S.speed;\n  S.pass += v / PASS;\n  S.spin += v * 0.12;\n  S.view += v * 0.25;\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const P = POLY[S.poly], K = P.k, m = S.m, w = S.w, fcol = S.fcol, id = S.id, rgb = S.rgb, z = S.z, col = S.col, warm = S.warm;\n  for (let c = 0; c \u003c 5; c++) {\n    const h = S.hue + PAL[c], hh = h - floor(h);\n    // Orange to lime would read brown or olive in shadow: paler, lit higher.\n    warm[c] = min(1, max(0, 1.6 - abs(hh - 0.15) / 0.1));\n    hsv(h, 0.75 - 0.25 * warm[c], 1, col, c * 3);\n  }\n  // The hyperplanes' normal u, in the polytope's frame: tilted theta from\n  // the cell axis toward D, D a unit vector in the first three axes near the\n  // vertex. Between the ends of Tilt both wander, so the polytope turns in 4D.\n  const t4 = S.tilt, amp = 1 - t4 * t4;\n  const th = (P.alpha * (t4 + 1)) / 2 + 0.3 * amp * sin(S.spin);\n  const ph = 0.9 * amp * sin(0.77 * S.spin + 1), ps = 0.9 * amp * sin(0.53 * S.spin + 2);\n  const D0 = cos(ph) * cos(ps), D1 = sin(ph) * cos(ps), D2 = sin(ps), ct = cos(th), st = sin(th);\n  // The hyperplane's own axes are the first three axes turned with u, in\n  // the plane of D and the fourth axis; then the whole slice turns round the\n  // panel's vertical and leans 0.45 radians toward the viewer.\n  const ca = cos(S.view), sa = sin(S.view), cb = cos(0.45), sb = sin(0.45);\n  for (let f = 0, o = 0; f \u003c K; f++, o += 4) {\n    const n0 = P.n[o], n1 = P.n[o + 1], n2 = P.n[o + 2], n3 = P.n[o + 3], nD = n0 * D0 + n1 * D1 + n2 * D2, g = (ct - 1) * nD - st * n3;\n    const x0 = n0 + D0 * g, y0 = n1 + D1 * g, z0 = n2 + D2 * g;\n    const x1 = ca * x0 + sa * z0, z1 = -sa * x0 + ca * z0;\n    m[f * 3] = x1;\n    m[f * 3 + 1] = cb * y0 - sb * z1;\n    m[f * 3 + 2] = sb * y0 + cb * z1;\n    w[f] = st * nD + ct * n3;\n    // Flat shading, 0.32 to 0.92 of the cell's colour by how the face meets\n    // the light.\n    const nx = m[f * 3], ny = m[f * 3 + 1], nz = m[f * 3 + 2], c3 = P.cls[f];\n    const lit0 = 0.32 + 0.6 * max(0, (nx * LX + ny * LY + nz * LZ) / sqrt(nx * nx + ny * ny + nz * nz)), lit = lit0 + (1 - lit0) * 0.75 * warm[c3];\n    for (let i = 0; i \u003c 3; i++) fcol[f * 3 + i] = col[c3 * 3 + i] * lit;\n  }\n  // Each vertex on the screen (vx, vy) and along u (vw), to find where the\n  // edges cross a hyperplane and so the slice's own box on the panel.\n  const { vx, vy, vw } = S;\n  let reach = 0;\n  for (let j = 0, o = 0; o \u003c P.v.length; j++, o += 4) {\n    const v0 = P.v[o], v1 = P.v[o + 1], v2 = P.v[o + 2], v3 = P.v[o + 3], vD = v0 * D0 + v1 * D1 + v2 * D2, g = (ct - 1) * vD - st * v3;\n    const x0 = v0 + D0 * g, y0 = v1 + D1 * g, z0 = v2 + D2 * g;\n    vx[j] = ca * x0 + sa * z0;\n    vy[j] = cb * y0 - sb * (-sa * x0 + ca * z0);\n    vw[j] = st * vD + ct * v3;\n    reach = max(reach, vw[j]);\n  }\n  id.fill(0);\n  rgb.fill(0);\n  z.fill(1e9);\n  const sc = FILL / P.R, E = P.edges;\n  const { fa, fb, fc, fr, fi, ba, bb, bc, br } = S;\n  // One pass: the middle hyperplane runs from (1 + DEL) reach to -(1 + DEL)\n  // reach, the top one DEL behind it and the bottom one DEL ahead, so the\n  // top meets the polytope first.\n  const a = S.pass - floor(S.pass), u = 1 - 2 * a, mid = (1 + DEL) * u * (DW + (1 - DW) * u * u * u * u);\n  for (let s = 0; s \u003c 3; s++) {\n    const c = reach * (mid - (1 - s) * DEL);\n    if (abs(c) >= reach) continue;\n    let x0 = 1e9, x1 = -1e9, y0 = 1e9, y1 = -1e9;\n    for (let q = 0; q \u003c E.length; q += 2) {\n      const i = E[q], j = E[q + 1], wi = vw[i] - c, wj = vw[j] - c;\n      if (wi * wj > 0 || wi === wj) continue;\n      const t = wi / (wi - wj), X = vx[i] + t * (vx[j] - vx[i]), Y = vy[i] + t * (vy[j] - vy[i]);\n      (x0 = min(x0, X)), (x1 = max(x1, X)), (y0 = min(y0, Y)), (y1 = max(y1, Y));\n    }\n    if (x1 \u003c x0) continue;\n    // Along the view ray (X, Y, t) a face's half-space starts or ends at\n    // t = a + b X + c Y: faces turned toward the viewer give where the ray\n    // may enter, the others where it must leave. The face of the latest\n    // entry is the one seen.\n    let nf = 0, nb = 0, side = false;\n    for (let f = 0; f \u003c K; f++) {\n      const h = P.d[f] - c * w[f], mx = m[f * 3], my = m[f * 3 + 1], mz = m[f * 3 + 2];\n      if (mz \u003c -1e-9) (fa[nf] = h / mz), (fb[nf] = -mx / mz), (fc[nf] = -my / mz), (fi[nf++] = f);\n      else if (mz > 1e-9) (ba[nb] = h / mz), (bb[nb] = -mx / mz), (bc[nb++] = -my / mz);\n      else side = true;\n    }\n    const cy = SLOT_Y[s], cx = 31.5;\n    const ya = max(0, floor(cy + y0 * sc)), yb = min(H - 1, floor(cy + y1 * sc)), xa = max(0, floor(cx + x0 * sc)), xb = min(W - 1, floor(cx + x1 * sc));\n    for (let y = ya; y \u003c= yb; y++) {\n      const Y = (y + 0.5 - cy) / sc;\n      for (let f = 0; f \u003c nf; f++) fr[f] = fa[f] + fc[f] * Y;\n      for (let f = 0; f \u003c nb; f++) br[f] = ba[f] + bc[f] * Y;\n      for (let x = xa; x \u003c= xb; x++) {\n        const X = (x + 0.5 - cx) / sc;\n        let lo = -1e9, hi = 1e9, face = -1;\n        for (let f = 0; f \u003c nf; f++) {\n          const t = fr[f] + fb[f] * X;\n          if (t > lo) (lo = t), (face = f);\n        }\n        for (let f = 0; f \u003c nb && hi > lo; f++) {\n          const t = br[f] + bb[f] * X;\n          if (t \u003c hi) hi = t;\n        }\n        if (lo >= hi || face \u003c 0) continue;\n        if (side) {\n          let out = false;\n          for (let f = 0; f \u003c K && !out; f++) if (abs(m[f * 3 + 2]) \u003c= 1e-9 && P.d[f] - c * w[f] - m[f * 3] * X - m[f * 3 + 1] * Y \u003c 0) out = true;\n          if (out) continue;\n        }\n        face = fi[face];\n        // A lower slice stands in front of the one above where they overlap.\n        const q = y * W + x, zz = lo - s * 100;\n        if (zz >= z[q]) continue;\n        z[q] = zz;\n        id[q] = s * 64 + face + 1;\n        rgb[q * 3] = fcol[face * 3];\n        rgb[q * 3 + 1] = fcol[face * 3 + 1];\n        rgb[q * 3 + 2] = fcol[face * 3 + 2];\n      }\n    }\n  }\n  // Seams: an LED with a 4-neighbour on another lit face, so two LEDs wide.\n  // Rims: an LED beside a seam or beside the dark.\n  const e = S.e;\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      const i = id[q];\n      e[q] = 0;\n      if (!i) continue;\n      const l = x > 0 ? id[q - 1] : i, r = x \u003c W - 1 ? id[q + 1] : i, u = y > 0 ? id[q - W] : i, d = y \u003c H - 1 ? id[q + W] : i;\n      e[q] = (l && l !== i) || (r && r !== i) || (u && u !== i) || (d && d !== i) ? 2 : !l || !r || !u || !d ? 3 : 1;\n    }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      if (e[q] !== 1) continue;\n      if ((x > 0 && e[q - 1] === 2) || (x \u003c W - 1 && e[q + 1] === 2) || (y > 0 && e[q - W] === 2) || (y \u003c H - 1 && e[q + W] === 2)) e[q] = 3;\n    }\n  for (let q = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q++) {\n      let r = rgb[q * 3], g = rgb[q * 3 + 1], b = rgb[q * 3 + 2];\n      if (e[q] === 3) {\n        const o = P.cls[(id[q] - 1) & 63] * 3;\n        (r = col[o] + (1 - col[o]) * RING), (g = col[o + 1] + (1 - col[o + 1]) * RING), (b = col[o + 2] + (1 - col[o + 2]) * RING);\n      } else if (e[q] === 2) (r *= SEAM), (g *= SEAM), (b *= SEAM);\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n","poncelet-porism":"// ===== Patternflow pattern =====\n// Title:   Poncelet Porism\n// Family:  line\n// Idea:    Three polygons with their corners on a tall ellipse and every side tangent to a smaller ellipse inside it slide round together in three colours, the corners creeping past the end where the inner ellipse comes close and racing round the far end, and each one closes from wherever it starts.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Poncelet's porism (Jean-Victor Poncelet, 1822), with Euler's relation for triangles (Leonhard Euler, 1765) and Fuss's for quadrilaterals (Nicolas Fuss, 1798), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Shape=0..5, Centre=0..1\n//\n// Knob 1: Hue. Turns the colours round the wheel together, a fifth of the wheel apart. At 0 cyan, violet and pink, and the inner ellipse, where all three fills overlap, pale lavender; at 0.25 violet, rose and pale yellow; at 0.5 red, yellow-green and green. A polygon that comes round between orange and yellow-green is paled and its fill raised from 42% to 60%, so it never reads brown or olive.\n// Knob 2: Speed. At 2 each corner goes once round the circles in 12 seconds while the two circles turn once round the centre in 64, so the end where the corners crowd wanders round the panel; at 0.2 that is 120 and 640 seconds, at 3 8 and 43.\n// Knob 3: Shape. Six polygons: 0 triangles, 1 quadrilaterals, 2 pentagrams {5/2}, 3 heptagrams {7/2}, 4 heptagrams {7/3}, 5 octagrams {8/3}, whose sides wind round the inner circle 2 or 3 times before they close. Fills are even-odd, so the pentagram and the {7/2} leave the middle round the inner ellipse dark and the {7/3} and {8/3} light it again. From 3 up two polygons instead of three.\n// Knob 4: Centre. How near the centre the inner circle sits, set as the fastest corner against the slowest: 3.4 times at 0, 3.24 at the opening 0.06, where a corner creeps past the near end at 7.5 LEDs a second and races past the far end at 39; 2.1 times at 0.5; at 1 the circles are concentric, the polygons are regular ones seen through the stretch and only the stretch changes a corner's pace, 14.7 to 29.3 LEDs a second. The inner radius comes from Euler's relation for triangles, d^2 = R^2 - 2Rr, Fuss's for quadrilaterals and bisection on the closing gap for the stars; at the opening the triangles' inner circle is 0.414 of the outer one and sits 0.415 of it off centre.\n// Buttons: K1 tap swings both circles half a turn round the centre in 1.6 seconds, carrying the crowded end to the far end of the panel, and every polygon stays closed through the swing.\n\nconst W = 64, H = 128;\nconst { floor, min, max, sqrt, asin, atan2, cos, sin, round, hypot, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// The two circles: the outer one of radius 1 at the origin, the inner one of\n// radius r centred (0, e). The panel shows them through the affine map\n// x -> CX + S x, y -> CY + 2 S y, turned by phi first, which keeps every\n// corner on the outer ellipse and every side tangent to the inner one.\nconst S = 28, CX = 31.5, CY = 63.5;\n// The polygons K3 steps through, as [corners, turns]: a triangle, a\n// quadrilateral, then the stars {5/2}, {7/2}, {7/3} and {8/3}, whose sides\n// go round the inner circle two or three times before they close.\nconst SHAPES = [[3, 1], [4, 1], [5, 2], [7, 2], [7, 3], [8, 3]];\n// Polygons on the panel at once, and the samples of the table that turns the\n// invariant parameter into an angle.\nconst POLYS = 3, M = 512;\n// Line half-width and corner disc radius, in LEDs.\nconst HW = 1.25, DISC = 3.3;\n// Opening hues: cyan, violet, pink, a fifth of the wheel apart.\nconst HUE0 = 0.5, SPREAD = 0.2;\n\n// One Poncelet step from angle th on the outer circle: the tangent from that\n// point to the inner circle, on the side that turns counterclockwise, meets\n// the outer circle again at th + the returned advance, in (0, 2 pi).\nfunction advance(th, e, r) {\n  const px = cos(th), py = sin(th), wx = -px, wy = e - py, D = hypot(wx, wy);\n  const a = -asin(cl(r / D, -1, 1)), ca = cos(a), sa = sin(a);\n  const ux = (wx * ca - wy * sa) / D, uy = (wx * sa + wy * ca) / D;\n  const t = -2 * (px * ux + py * uy);\n  const d = atan2(py + t * uy, px + t * ux) - th;\n  return d - floor(d / TAU) * TAU;\n}\n\n// How far n steps overshoot k whole turns. It has one sign for every start\n// unless the polygon closes, so bisection on r finds the closing circle.\nfunction overshoot(e, r, n, k) {\n  let th = 0.3, s = 0;\n  for (let i = 0; i \u003c n; i++) {\n    const d = advance(th, e, r);\n    s += d;\n    th += d;\n  }\n  return s - TAU * k;\n}\n\nfunction closingRadius(e, n, k) {\n  let lo = 0, hi = 1 - e;\n  for (let i = 0; i \u003c 52; i++) {\n    const m = (lo + hi) / 2;\n    if (overshoot(e, m, n, k) > 0) lo = m;\n    else hi = m;\n  }\n  return (lo + hi) / 2;\n}\n\n// A corner moves along the outer circle as fast as the tangent from it to the\n// inner circle is long, so the longest tangent over the shortest is the\n// fastest corner against the slowest.\nconst ratioAt = (e, r) => sqrt((1 + e) ** 2 - r * r) / sqrt(max(1e-12, (1 - e) ** 2 - r * r));\n\nfunction solve(P, n, k, rho) {\n  let lo = 0, hi = 0.95;\n  for (let i = 0; i \u003c 40; i++) {\n    const m = (lo + hi) / 2;\n    if (ratioAt(m, closingRadius(m, n, k)) \u003c rho) lo = m;\n    else hi = m;\n  }\n  P.e = (lo + hi) / 2;\n  P.r = closingRadius(P.e, n, k);\n  // The invariant parameter: the integral of d theta over the tangent length,\n  // scaled to 1 round the circle. Each Poncelet step adds exactly k/n to it.\n  const { e, r, tab } = P, L = (th) => 1 / sqrt(1 + e * e - 2 * e * sin(th) - r * r);\n  let acc = 0;\n  tab[0] = 0;\n  for (let i = 0; i \u003c M; i++) {\n    const a = (TAU * i) / M, b = (TAU * (i + 1)) / M;\n    acc += ((b - a) / 6) * (L(a) + 4 * L((a + b) / 2) + L(b));\n    tab[i + 1] = acc;\n  }\n  for (let i = 0; i \u003c= M; i++) tab[i] /= acc;\n}\n\nfunction angleOf(tab, s) {\n  s -= floor(s);\n  let lo = 0, hi = M;\n  while (hi - lo > 1) {\n    const m = (lo + hi) >> 1;\n    if (tab[m] \u003c= s) lo = m;\n    else hi = m;\n  }\n  return (TAU * (lo + (s - tab[lo]) / max(1e-12, tab[lo + 1] - tab[lo]))) / M;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, shape: 0, rho: 0, key: '', e: 0, r: 0.5, tab: new Float64Array(M + 1),\n    t: 0, phi: 0, swing: 0, from: 0,\n    vx: new Float32Array(POLYS * 8), vy: new Float32Array(POLYS * 8), xs: new Float32Array(8),\n    rgb: new Float32Array(W * H * 3), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0]], fill: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3);\n  P.shape = round(cl(k[2], 0, 5));\n  P.rho = 1 + 2.4 * (1 - cl(k[3], 0, 1)) ** 1.1;\n  const key = P.shape + ':' + P.rho.toFixed(4);\n  if (key !== P.key) {\n    const [n, t] = SHAPES[P.shape];\n    solve(P, n, t, P.rho);\n    P.key = key;\n  }\n  if (input.btnPressed && input.btnPressed[0] && P.swing \u003c= 0) {\n    P.swing = 1;\n    P.from = P.phi;\n  }\n  // The corners go round once in 12 seconds at Speed 2, and the pair of\n  // circles turns once in 64, so the side where the corners crowd wanders.\n  // A swing adds half a turn over 1.6 seconds on top of that.\n  const turn = (d * P.speed * TAU) / 128;\n  P.t += (d * P.speed) / 24;\n  if (P.swing > 0) {\n    P.from += turn;\n    P.swing = max(0, P.swing - d / 1.6);\n    P.phi = P.from + PI * sm(0, 1, 1 - P.swing);\n  } else P.phi += turn;\n}\n\n// Paint value a of colour c over the buffer at q.\nfunction over(rgb, q, c, a, wh) {\n  rgb[q] += (c[0] + (1 - c[0]) * wh - rgb[q]) * a;\n  rgb[q + 1] += (c[1] + (1 - c[1]) * wh - rgb[q + 1]) * a;\n  rgb[q + 2] += (c[2] + (1 - c[2]) * wh - rgb[q + 2]) * a;\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const { e, r, tab, vx, vy, xs, rgb, col, fill } = P, [n, turns] = SHAPES[P.shape];\n  const cp = cos(P.phi), sp = sin(P.phi);\n  // Three polygons, or two of the seven- and eight-cornered stars, which\n  // would otherwise draw 21 or 24 sides.\n  const polys = n \u003c 7 ? POLYS : 2;\n  for (let j = 0; j \u003c polys; j++) {\n    const h = P.hue + HUE0 + (j * SPREAD * 2) / (polys - 1), hh = h - floor(h);\n    const warm = sm(0.0, 0.06, hh) * (1 - sm(0.17, 0.24, hh));\n    hsv(h, 0.85 - 0.35 * warm, 1, col[j]);\n    const f = 0.42 + 0.18 * warm;\n    for (let c = 0; c \u003c 3; c++) fill[j][c] = col[j][c] * f;\n    // The first corner rides the invariant parameter; the rest are the\n    // Poncelet steps from it.\n    let th = angleOf(tab, P.t + j / (polys * n));\n    for (let i = 0; i \u003c n; i++) {\n      const x = cos(th), y = sin(th);\n      vx[j * 8 + i] = CX + S * (x * cp - y * sp);\n      vy[j * 8 + i] = CY + 2 * S * (x * sp + y * cp);\n      th += advance(th, e, r);\n    }\n  }\n  rgb.fill(0);\n  // Fills, even-odd, added: a triangle is filled whole, a star has its points\n  // filled and its middle left open, and where several overlap they sum.\n  for (let j = 0; j \u003c polys; j++) {\n    const o = j * 8, f = fill[j];\n    for (let y = 0; y \u003c H; y++) {\n      const yc = y + 0.5;\n      let m = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const ax = vx[o + i], ay = vy[o + i], bx = vx[o + ((i + 1) % n)], by = vy[o + ((i + 1) % n)];\n        if ((ay \u003c= yc) === (by \u003c= yc)) continue;\n        const x = ax + ((yc - ay) * (bx - ax)) / (by - ay);\n        let p = m++;\n        for (; p > 0 && xs[p - 1] > x; p--) xs[p] = xs[p - 1];\n        xs[p] = x;\n      }\n      for (let i = 0; i + 1 \u003c m; i += 2) {\n        const xa = xs[i], xb = xs[i + 1];\n        for (let x = max(0, floor(xa)); x \u003c= min(W - 1, floor(xb)); x++) {\n          const a = min(x + 1, xb) - max(x, xa);\n          if (a \u003c= 0) continue;\n          const q = (y * W + x) * 3;\n          rgb[q] += f[0] * a;\n          rgb[q + 1] += f[1] * a;\n          rgb[q + 2] += f[2] * a;\n        }\n      }\n    }\n  }\n  // Sides, laid over the fills in each polygon's full colour. For each row\n  // only the stretch of the band within reach of the line is visited.\n  const R = HW + 1;\n  for (let j = 0; j \u003c polys; j++) {\n    const o = j * 8, c = col[j];\n    for (let i = 0; i \u003c n; i++) {\n      const ax = vx[o + i], ay = vy[o + i], bx = vx[o + ((i + 1) % n)], by = vy[o + ((i + 1) % n)];\n      const dx = bx - ax, dy = by - ay, l2 = dx * dx + dy * dy || 1, l = sqrt(l2), nx = -dy / l, ny = dx / l;\n      const xmin = min(ax, bx) - R, xmax = max(ax, bx) + R;\n      for (let y = max(0, floor(min(ay, by) - R)); y \u003c= min(H - 1, floor(max(ay, by) + R)); y++) {\n        const py = y + 0.5;\n        let x0 = xmin, x1 = xmax;\n        if (nx > 0.02 || nx \u003c -0.02) {\n          const u = (-R - ny * (py - ay)) / nx + ax, v = (R - ny * (py - ay)) / nx + ax;\n          x0 = max(x0, min(u, v));\n          x1 = min(x1, max(u, v));\n        }\n        for (let x = max(0, floor(x0)); x \u003c= min(W - 1, floor(x1)); x++) {\n          const px = x + 0.5 - ax, qy = py - ay, u = cl((px * dx + qy * dy) / l2, 0, 1);\n          const a = cl(HW + 0.5 - hypot(px - u * dx, qy - u * dy), 0, 1);\n          if (a > 0) over(rgb, (y * W + x) * 3, c, a, 0);\n        }\n      }\n    }\n  }\n  // Corners: a disc of the polygon's colour with a white heart.\n  for (let j = 0; j \u003c polys; j++) {\n    const o = j * 8, c = col[j];\n    for (let i = 0; i \u003c n; i++) {\n      const cx = vx[o + i], cy = vy[o + i];\n      for (let y = max(0, floor(cy - DISC - 1)); y \u003c= min(H - 1, floor(cy + DISC + 1)); y++)\n        for (let x = max(0, floor(cx - DISC - 1)); x \u003c= min(W - 1, floor(cx + DISC + 1)); x++) {\n          const dd = hypot(x + 0.5 - cx, y + 0.5 - cy), a = cl(DISC + 0.5 - dd, 0, 1);\n          if (a > 0) over(rgb, (y * W + x) * 3, c, a, sm(DISC - 0.6, 0.6, dd) * 0.85);\n        }\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","sheet-ghosts":"// ===== Patternflow pattern =====\n// Title:   Sheet Ghosts\n// Family:  halloween\n// Idea:    Bedsheet ghosts 24 to 40 LEDs wide rise up the tall panel through the dark, swaying, their hems rippling and their bodies trailing behind the sway, see-through where they pass through one another, with dark eye holes and a cold glow round each sheet.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the bedsheet ghost costume of Halloween\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Glow=0..1, Speed=0.2..3, Ghosts=3..6, Wind=-1..1\n//\n// Knob 1: Glow. The colour of the glow round each sheet and of the sheet's edge. At 0 toxic green; at 0.25 ice blue; at 0.5 purple; at 0.75 pumpkin orange, which starts half as bright again at the sheet's edge and falls off a third sooner, so it never fades through brown. The sheets stay cold white at the head and pale violet at the hem.\n// Knob 2: Speed. At 2 the ghosts rise 3.7 LEDs a second when 24 wide and 6 when 40 wide, the wide ones being nearer, sway 4 to 9 LEDs each way once every 2.8 to 4.5 seconds, and a wave of the hem runs across in 1.8 seconds; at 0.2 all of it ten times slower, at 3 half as fast again.\n// Knob 3: Ghosts. How many take turns coming up, 3 to 6. Each starts 0.45 to 1.15 of an even share of a 194-row cycle below the last, so at 3 two or three are on the panel at once and at 6 five or six crowd it, overlapping, each sheet showing the others through it.\n// Knob 4: Wind. From -1 (to the left) to 1 (to the right): pushes the ghosts up to 9 LEDs downwind, swings them half as wide again, runs the hem's ripple downwind twice as fast and leans every body so its hem trails downwind, 16 LEDs behind the head on a 40-wide ghost. The opening 0.06 is a breath to the right.\n// Buttons: K1 tap: every ghost rushes at the viewer, swelling to 3.2 times its size about its face in 0.8 seconds, eyes up to 19 LEDs wide, and fades out by 1.1; then a new set fades in where it stands by 2.1.\n\nconst W = 64, H = 128, MAXG = 6;\nconst { floor, min, max, sqrt, sin, cos, exp, abs, round, sign, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Opening glow: toxic green.\nconst HUE0 = 0.31;\n// Glow reach in LEDs and its strength at the sheet's edge.\nconst GR = 2.1, GK = 0.65;\n// A ghost's shape, in units of its width w, from the centre of its head:\n// the head a circle of radius 0.46, the body flaring below it to a hem 1.25\n// down, rippling 0.07 up and down in 2.5 waves across.\nconst RH = 0.46, LB = 1.25, AH = 0.07, WAVES = 2.5;\n// The rush on a K1 tap: swell for 0.8 s, gone by 1.1, back in by 2.1.\nconst SWELL = 0.8, GONE = 1.1, BACK = 2.1;\n\n// A fresh ghost: its size, sway and colour.\nfunction dress(g) {\n  g.w = 24 + 16 * Math.random();\n  g.sa = 4 + 5 * Math.random();\n  g.sf = 0.22 + 0.14 * Math.random();\n  g.ph = TAU * Math.random();\n  g.tint = Math.random();\n  g.on = true;\n}\n\n// Where the head is across the panel: its lane, pushed up to 9 LEDs\n// downwind, and its sway, half as wide again in a full wind.\nconst swayX = (g, P) => g.x0 + 9 * P.wind + g.sa * (1 + 0.5 * abs(P.wind)) * sin(TAU * g.sf * P.t + g.ph);\n\n// A ghost from below, on the other side of the middle from the one that\n// came up last.\nfunction spawn(g, P) {\n  dress(g);\n  let low = null, n = 0;\n  for (const o of P.gs) {\n    if (o === g || !o.on) continue;\n    n++;\n    if (!low || o.hy > low.hy) low = o;\n  }\n  const side = low ? (low.x0 \u003c 32 ? 1 : -1) : Math.random() \u003c 0.5 ? 1 : -1;\n  g.x0 = 32 + side * (3 + 13 * Math.random());\n  g.cx = swayX(g, P);\n  // Below the panel, and 0.45 to 1.15 times an even share of the cycle\n  // below the lowest ghost already up: they keep coming at a steady pace,\n  // sometimes two close enough to cross.\n  g.hy = max(H + RH * g.w + 3, low ? low.hy + ((H + 66) * (0.45 + 0.7 * Math.random())) / (n + 1) : 0);\n}\n\n// Ghosts spread up the panel, lanes taking turns left and right: the\n// opening frame, and the return after a rush.\nfunction spread(P) {\n  P.gs.forEach((g, i) => {\n    g.on = false;\n    if (i >= P.count) return;\n    dress(g);\n    g.x0 = 32 + (i % 2 ? 1 : -1) * (8 + 6 * Math.random());\n    g.hy = -8 + (i * (H + 66)) / P.count + 6 * Math.random();\n    g.cx = swayX(g, P);\n  });\n}\n\nexport function setup(params) {\n  const gs = [];\n  for (let i = 0; i \u003c MAXG; i++) gs.push({ w: 30, x0: 32, hy: 0, sa: 6, sf: 0.3, ph: 0, tint: 0, on: false, cx: 32, vx: 0, shear: 0 });\n  params.s = { hue: 0, speed: 2, count: 3, wind: 0.06, t: 0, rip: 0, fl: 0, gs, begun: false, boo: -1, rgb: new Float32Array(W * H * 3), glow: [0, 0, 0] };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3);\n  P.count = round(cl(k[2], 3, MAXG));\n  P.wind = cl(k[3], -1, 1);\n  if (!P.begun) {\n    spread(P);\n    P.begun = true;\n  }\n  const sp = P.speed / 2, wa = abs(P.wind);\n  P.t += d * sp;\n  // The hem's ripple runs downwind, faster in a wind; the sides flutter.\n  P.rip += d * sp * (3.4 + 4 * wa) * (P.wind \u003c 0 ? -1 : 1);\n  P.fl += d * sp * (2.6 + 4 * wa);\n  if (input.btnPressed && input.btnPressed[0] && P.boo \u003c 0) P.boo = 0;\n  if (P.boo >= 0) {\n    const was = P.boo;\n    P.boo += d;\n    if (was \u003c GONE && P.boo >= GONE) spread(P);\n    if (P.boo >= BACK) P.boo = -1;\n  }\n  const rushing = P.boo >= 0 && P.boo \u003c GONE;\n  for (let i = 0; i \u003c MAXG; i++) {\n    const g = P.gs[i];\n    if (i >= P.count) {\n      g.on = false;\n      continue;\n    }\n    if (!g.on && !rushing) spawn(g, P);\n    // Bigger ghosts are nearer, so they rise faster, 3.7 to 6 LEDs a second\n    // at Speed 2, and now and then a near one catches up a far one and\n    // passes through it.\n    if (!rushing) g.hy -= d * sp * (0.2 + 0.145 * g.w);\n    const cx = swayX(g, P);\n    g.vx = d > 0 ? (cx - g.cx) / d : 0;\n    g.cx = cx;\n    // The body trails the head: it leans away from the way the head is\n    // going, and the wind pushes the hem further downwind.\n    g.shear += (cl(-0.02 * g.vx + 0.32 * P.wind, -0.5, 0.5) - g.shear) * min(1, d * 4);\n    if (g.hy + (LB + AH) * g.w \u003c -GR * 3 && !rushing) spawn(g, P);\n  }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const { rgb, glow, gs } = P;\n  const gh = P.hue + HUE0, hh = gh - floor(gh);\n  // Orange and yellow glows start half as bright again and fall off a third\n  // sooner, so they do not fade through brown.\n  const warm = sm(0.0, 0.05, hh) * (1 - sm(0.14, 0.2, hh));\n  hsv(gh, 0.9 - 0.15 * warm, 1, glow);\n  const reach = GR * (1 - 0.35 * warm), gk = GK * (1 + 0.5 * warm);\n  rgb.fill(0);\n  const T = P.t, boo = P.boo, rip = P.rip, wa = abs(P.wind);\n  // The rush: each ghost swells to 3.2 times its size about its face and\n  // fades out, and then the next ones fade in where they stand.\n  let sc = 1, fade = 1, flare = 1;\n  if (boo >= 0 && boo \u003c GONE) {\n    const u = cl(boo / SWELL, 0, 1);\n    sc = 1 + 2.2 * u * u * u;\n    fade = 1 - sm(0.55, GONE, boo);\n    flare = 1 + 0.8 * sm(0, 0.5, boo);\n  } else if (boo >= GONE) fade = sm(GONE, BACK, boo);\n  // Far (narrow) ghosts first.\n  const order = gs.filter((g) => g.on).sort((a, b) => a.w - b.w);\n  for (const g of order) {\n    const w = g.w, hx = g.cx, hy = g.hy, rh = RH * w, lb = LB * w, ah = AH * w, sh = g.shear;\n    const kk = (TAU * WAVES) / (2.4 * rh), ph = g.ph * 3;\n    const ex = 0.16 * w, ey = -0.08 * w, erx = 0.075 * w, ery = 0.115 * w;\n    // The eyes look a little the way the ghost is swaying; the mouth opens\n    // and closes.\n    const look = cl(g.vx * 0.06, -1, 1) * 0.05 * w;\n    const my = 0.13 * w, mrx = 0.05 * w, mry = (0.055 + 0.02 * sin(1.7 * T + g.ph)) * w;\n    // Sheet colour: cold white at the head to pale violet at the hem; the\n    // nearer (wider) ghosts are brighter.\n    const br = 0.86 + (0.14 * (w - 24)) / 16, vr = 0.66 + 0.1 * g.tint, vg = 0.52 + 0.12 * g.tint;\n    const op = 0.9 * fade, flut = 0.05 * w * (1 + 1.5 * wa);\n    const pad = reach * 3 + 1, side = rh * 1.3 + flut + abs(sh) * lb + pad;\n    const fy = hy - sc * (rh + pad), ly = hy + sc * (lb + ah + pad);\n    for (let y = max(0, floor(fy)); y \u003c= min(H - 1, floor(ly)); y++) {\n      const v = (y + 0.5 - hy) / sc, t = cl(v / lb, 0, 1);\n      // The sides flare toward the hem and flutter.\n      const hw = rh * (1 + 0.2 * t ** 1.4) + flut * t * sin(0.22 * v - P.fl + ph);\n      const off = sh * max(0, v), vt = sm(-0.3, 0.9, t), fa = 1 - 0.55 * sm(0.35, 1.05, t), fz = sm(0.55, 1, t);\n      const cr = br * (0.97 + (vr - 0.97) * vt), cg = br * (0.95 + (vg - 0.95) * vt), cb = br;\n      for (let x = max(0, floor(hx - sc * side)); x \u003c= min(W - 1, floor(hx + sc * side)); x++) {\n        const u = (x + 0.5 - hx) / sc - off;\n        const dh = sqrt(u * u + v * v) - rh;\n        const hem = lb + ah * (sin(kk * u - rip + ph) + 0.2 * sin(2 * kk * u + 1.3 * rip));\n        const dd = min(dh, max(abs(u) - hw, v - hem, -v)) * sc;\n        const q = (y * W + x) * 3;\n        if (dd > 0) {\n          // Outside: the cold glow.\n          const a = gk * flare * fade * exp(-dd / (reach * sc));\n          if (a \u003c 0.01) continue;\n          rgb[q] = 1 - (1 - rgb[q]) * (1 - glow[0] * a);\n          rgb[q + 1] = 1 - (1 - rgb[q + 1]) * (1 - glow[1] * a);\n          rgb[q + 2] = 1 - (1 - rgb[q + 2]) * (1 - glow[2] * a);\n          continue;\n        }\n        // Eye holes and the mouth darken whatever is behind them.\n        const e1 = ((abs(u) - ex - look * sign(u)) / erx) ** 2 + ((v - ey) / ery) ** 2;\n        const e2 = ((u - look) / mrx) ** 2 + ((v - my) / mry) ** 2;\n        const hole = max(sm(1.25, 0.75, e1), sm(1.3, 0.7, e2));\n        // Folds run down to the troughs of the hem; the sheet's edge takes\n        // the glow's colour; the lower body thins toward the hem.\n        const lit = 1 - 0.18 * fz * (0.5 + 0.5 * cos(kk * u - rip + ph));\n        const rim = sm(-2.2 * sc, 0, dd) * 0.75, a = op * cl(0.5 - dd, 0, 1) * fa;\n        const r = cr * lit * (1 - rim) + glow[0] * rim, gg = cg * lit * (1 - rim) + glow[1] * rim, b = cb * lit * (1 - rim) + glow[2] * rim;\n        const dark = 1 - 0.92 * hole * a, ab = a * (1 - hole);\n        rgb[q] = 1 - (1 - rgb[q] * dark) * (1 - r * ab);\n        rgb[q + 1] = 1 - (1 - rgb[q + 1] * dark) * (1 - gg * ab);\n        rgb[q + 2] = 1 - (1 - rgb[q + 2] * dark) * (1 - b * ab);\n      }\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","siteswap":"// ===== Patternflow pattern =====\n// Title:   Siteswap\n// Family:  rhythm\n// Idea:    Glowing balls fly between two hands at the foot of the panel, each throw staying up as many beats as its siteswap number says, so in 531 the 5 reaches the top while the 1 zips straight across, and the juggler works through a list of patterns with the throws between two of them found in the state diagram.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: siteswap juggling notation (Paul Klimek, 1981; Bruce Tiemann and Bengt Magnusson, 1985), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Balls=3..7, Tail=0..1\n//\n// Knob 1: Hue. Turns every ball round the wheel together. The balls sit 0.618 of a turn apart, so at 0 three balls are azure, yellow and violet, a fourth is green and a fifth red. A ball that comes round to orange is paled and its tail kept at full brightness, so it never reads brown.\n// Knob 2: Speed. At 2 the highest throw of the pattern stays up 1.8 seconds and the beat follows from it: 0.4 s in 51, 0.21 s in 97531, and never longer than 0.62 s, so a plain 3 stays up 1.55 s. At 0.2 everything takes ten times as long, at 3 two thirds as long.\n// Knob 3: Balls, 3 to 7, each count with its own list of 7 to 10 patterns (for 3: 51, 531, 3, 441, 6316131 and on). Turning it brings a new ball out of a hand that has a free beat or lets one fall off the bottom of the panel, and the throws in between come from the state diagram. Each pattern runs 7 seconds at Speed 2 and then to the end of its cycle.\n// Knob 4: Tail. Each ball trails a comet tail as wide as the ball that tapers to nothing. At Speed 2 it holds the last 0.72 s of flight at 0, 0.78 s at the opening 0.06 and 1.8 s at 1, the whole flight of the highest throw, so every ball paints its full arch.\n// Buttons: K1 tap moves on to the next pattern at the next beat.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, round, sin, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// Hands: the ball centre's row at the hands, the inner point each hand\n// throws from and the outer point it catches at. Hand 0 is the left.\nconst YH = 114, YTOP = 9, HMAX = YH - YTOP, DIP = 5;\nconst THROW_X = [26, 38], CATCH_X = [7, 57];\n// Dwell: the share of a beat a ball spends in the hand before it is thrown\n// again. A 1 is in the air 1 - DWELL beats, a 9 is in the air 8.5.\nconst DWELL = 0.5;\n// The highest throw of a pattern takes T_HI seconds at Speed 2, and a beat\n// is never shorter than B_MIN or longer than B_MAX seconds.\nconst T_HI = 1.8, B_MIN = 0.2, B_MAX = 0.62;\n// Each pattern runs at least this many seconds (at Speed 2), then the next.\nconst RUN = 7;\nconst MAXT = 9;\nconst R_BALL = 4, R_GLOW = 7, R_TAIL = 3.7;\nconst HUE0 = 0.55, GOLD = 0.618034;\n\n// Patterns by ball count. Every one is checked in setup: a sequence is\n// jugglable exactly when i + s_i mod n hits every i once, and then its\n// average is the number of balls. The first of each list opens.\nconst LISTS = {\n  3: [\"51\", \"531\", \"3\", \"441\", \"6316131\", \"423\", \"711\", \"52512\", \"4413\", \"72312\"],\n  4: [\"4\", \"534\", \"7531\", \"5551\", \"633\", \"741\", \"552\", \"6451\", \"53\", \"7441\"],\n  5: [\"5\", \"744\", \"97531\", \"645\", \"75751\", \"663\", \"771\", \"753\", \"726\"],\n  6: [\"6\", \"75\", \"864\", \"756\", \"9555\", \"774\", \"8448\", \"855\"],\n  7: [\"7\", \"966\", \"86\", \"975\", \"95\", \"9559\", \"8677\"],\n};\n\nfunction jugglable(seq) {\n  const n = seq.length, hit = new Array(n).fill(false);\n  for (let i = 0; i \u003c n; i++) {\n    const j = (i + seq[i]) % n;\n    if (hit[j]) return false;\n    hit[j] = true;\n  }\n  return true;\n}\n\n// The state at phase j: bit k is set when a ball thrown earlier lands k\n// beats from now, bit 0 being the ball in the hand that throws now.\nfunction stateAt(seq, j) {\n  const n = seq.length;\n  let st = 0;\n  for (let m = 1; m \u003c= MAXT; m++) {\n    const k = seq[(((j - m) % n) + n) % n] - m;\n    if (k >= 0) st |= 1 \u003c\u003c k;\n  }\n  return st;\n}\n\nconst pop = (st) => {\n  let c = 0;\n  for (; st; st &= st - 1) c++;\n  return c;\n};\n\nfunction buildLists() {\n  const out = {};\n  for (const [count, list] of Object.entries(LISTS)) {\n    out[count] = [];\n    for (const text of list) {\n      const seq = [...text].map(Number), sum = seq.reduce((a, b) => a + b, 0);\n      if (!jugglable(seq) || sum !== +count * seq.length) continue;\n      out[count].push({ text, seq, top: max(...seq), states: seq.map((_, j) => stateAt(seq, j)) });\n    }\n  }\n  return out;\n}\n\n// Shortest run of throws from state st to any state of pattern P, throws no\n// higher than the lowest cap that finds one. Where the ball count differs a\n// throw may be a new ball from an empty hand (add) or a ball let fall (drop).\nfunction bridge(st, P, cap0) {\n  const want = pop(P.states[0]);\n  for (let cap = cap0; cap \u003c= MAXT; cap++) {\n    const prev = new Map([[st, null]]);\n    let front = [st];\n    while (front.length) {\n      const next = [];\n      for (const s of front) {\n        const j = P.states.indexOf(s);\n        if (j >= 0) {\n          const path = [];\n          for (let c = s; prev.get(c); c = prev.get(c).from) path.unshift(prev.get(c).move);\n          return { path, phase: j };\n        }\n        const here = s & 1, rest = s >> 1, c = pop(s);\n        const moves = [];\n        if (here && c > want) moves.push({ v: 0, drop: true, to: rest });\n        if (!here) moves.push({ v: 0, to: rest });\n        if (here || c \u003c want)\n          for (let v = 1; v \u003c= cap; v++) if (!(rest & (1 \u003c\u003c (v - 1)))) moves.push({ v, add: !here, to: rest | (1 \u003c\u003c (v - 1)) });\n        for (const m of moves)\n          if (!prev.has(m.to)) {\n            prev.set(m.to, { from: s, move: m });\n            next.push(m.to);\n          }\n      }\n      front = next;\n    }\n  }\n  return null;\n}\n\nexport function setup(params) {\n  const lists = buildLists();\n  params.s = {\n    lists, count: 3, pat: lists[3][0], idx: 0, phase: 0, st: 0, trans: [],\n    beat: 0, next: 0, run: 0, want: false, begun: false,\n    air: 1, bLen: 1, balls: [],\n    hue: 0, speed: 2, tail: 0.06,\n    zA: new Float32Array(N), zC: new Float32Array(N), zB: new Int8Array(N),\n    rgb: new Float32Array(N * 3),\n  };\n}\n\nconst beatLen = (air) => cl(T_HI / air, B_MIN, B_MAX);\n\nfunction newBall(S, t) {\n  let id = 0;\n  while (S.balls.some((b) => b.id === id)) id++;\n  const b = { id, segs: [], land: 0, born: t, gone: false };\n  S.balls.push(b);\n  return b;\n}\n\n// A throw from hand (t & 1) at beat t: up along a parabola to the far hand's\n// catching point, then a scoop in that hand back to its throwing point. A\n// throw of v climbs HMAX ((v - DWELL) / air)^2 rows, air being the beats the\n// pattern's highest throw stays up, so in 531 the 5 climbs 105 rows, the 3\n// climbs 32 and the 1 barely leaves the hands.\nfunction launch(S, b, t, v) {\n  const h = t & 1, h2 = (t + v) & 1, t1 = t + v - DWELL;\n  const a = (v - DWELL) / S.air, A = HMAX * min(1, a * a);\n  b.segs.push({ k: 0, t0: t, t1, x0: THROW_X[h], x1: CATCH_X[h2], A });\n  b.segs.push({ k: 1, t0: t1, t1: t + v, x0: CATCH_X[h2], x1: THROW_X[h2] });\n  b.land = t + v;\n}\n\n// The pattern already running at beat 0: every throw of the last MAXT beats\n// that is still to land, in flight.\nfunction start(S, P) {\n  S.pat = P;\n  S.air = P.top - DWELL;\n  S.bLen = beatLen(S.air);\n  S.st = P.states[0];\n  S.phase = 0;\n  const n = P.seq.length;\n  for (let m = MAXT; m >= 1; m--) {\n    const v = P.seq[(((-m) % n) + n) % n];\n    if (v - m >= 0 && v > 0) launch(S, newBall(S, -m - 1), -m, v);\n  }\n  S.beat = -0.001;\n  S.next = 0;\n}\n\n// The next pattern: the next in the list, or the first when the ball count\n// is changing, reached by the shortest bridge from where the juggle stands.\nfunction plan(S) {\n  const list = S.lists[S.count];\n  if (S.count !== pop(S.st)) S.idx = 0;\n  else S.idx = (S.idx + 1) % list.length;\n  const P = list[S.idx];\n  const cap = max(P.top, S.pat.top);\n  const r = bridge(S.st, P, min(MAXT, cap));\n  if (!r) return;\n  S.trans = r.path;\n  S.pat = P;\n  S.phase = r.phase;\n  S.run = 0;\n}\n\n// Beat t: hand t & 1 throws the ball that lands now with the next value of\n// the bridge, or of the pattern once the bridge is done. A 0 leaves the hand\n// empty, a drop lets its ball fall off the panel, and a throw from an empty\n// hand is a new ball.\nfunction onBeat(S, t) {\n  const sw = S.want || (S.count !== pop(S.st) && !S.trans.length) || (S.run >= RUN && S.phase === 0 && !S.trans.length);\n  if (sw) {\n    S.want = false;\n    plan(S);\n  }\n  let move;\n  if (S.trans.length) move = S.trans.shift();\n  else {\n    const v = S.pat.seq[S.phase];\n    S.phase = (S.phase + 1) % S.pat.seq.length;\n    move = { v };\n  }\n  const here = S.st & 1, rest = S.st >> 1;\n  const b = S.balls.find((x) => !x.gone && x.land === t);\n  if (move.drop) {\n    if (b) {\n      b.gone = true;\n      b.segs.push({ k: 2, t0: t, x0: THROW_X[t & 1], dir: t & 1 ? 1 : -1 });\n    }\n    S.st = rest;\n  } else if (move.v === 0) S.st = rest;\n  else {\n    const ball = here && b ? b : newBall(S, t);\n    launch(S, ball, t, move.v);\n    S.st = rest | (1 \u003c\u003c (move.v - 1));\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 3, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 3, 7);\n  S.tail = cl(k[3], 0, 1);\n  // The first frame opens on the first pattern for the knob's ball count.\n  if (!S.begun) {\n    start(S, S.lists[S.count][0]);\n    S.begun = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) S.want = true;\n  const pd = d * S.speed * 0.5;\n  // Scale and tempo ease toward the pattern being juggled.\n  const e = 1 - Math.exp(-pd / 0.5);\n  S.air += (S.pat.top - DWELL - S.air) * e;\n  S.bLen += (beatLen(S.pat.top - DWELL) - S.bLen) * e;\n  S.run += pd;\n  S.beat += pd / S.bLen;\n  while (S.beat >= S.next) onBeat(S, S.next++);\n  // Forget what the longest tail no longer reaches.\n  const keep = S.beat - T_HI / S.bLen - 2;\n  for (const b of S.balls) while (b.segs.length > 2 && (b.segs[0].t1 ?? 1e9) \u003c keep) b.segs.shift();\n  S.balls = S.balls.filter((b) => !(b.gone && S.beat - b.segs[b.segs.length - 1].t0 > 4));\n}\n\n// Where ball b is at beat t, or false before its first segment.\nfunction posAt(b, t, out) {\n  for (let i = b.segs.length - 1; i >= 0; i--) {\n    const s = b.segs[i];\n    if (t \u003c s.t0) continue;\n    if (s.k === 2) {\n      const u = t - s.t0;\n      out[0] = s.x0 + s.dir * 10 * u;\n      out[1] = YH + 70 * u * u;\n      return true;\n    }\n    const u = cl((t - s.t0) / (s.t1 - s.t0), 0, 1);\n    if (s.k === 0) {\n      out[0] = s.x0 + (s.x1 - s.x0) * u;\n      out[1] = YH - 4 * s.A * u * (1 - u);\n    } else {\n      const w = u * u * (3 - 2 * u);\n      out[0] = s.x0 + (s.x1 - s.x0) * w;\n      out[1] = YH + DIP * sin(PI * u);\n    }\n    return true;\n  }\n  return false;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { zA, zC, zB, rgb, balls } = S;\n  zA.fill(1e9);\n  zC.fill(0);\n  rgb.fill(0);\n  // Tail length in beats.\n  const L = (T_HI * (0.4 + 0.6 * S.tail)) / S.bLen;\n  const p = [0, 0], q = [0, 0];\n  for (let bi = 0; bi \u003c balls.length; bi++) {\n    const b = balls[bi];\n    const steps = max(8, Math.ceil(L * 40));\n    let have = posAt(b, S.beat, q);\n    for (let s = 1; s \u003c= steps && have; s++) {\n      const a0 = ((s - 1) / steps) * L, a1 = (s / steps) * L;\n      p[0] = q[0];\n      p[1] = q[1];\n      have = posAt(b, S.beat - a1, q) && S.beat - a1 >= b.born;\n      if (!have) break;\n      // A capsule from p to q, its radius tapering with age.\n      const r = R_TAIL * (1 - a0 / L) ** 0.5;\n      if (r \u003c 0.3) break;\n      const x0 = max(0, floor(min(p[0], q[0]) - r - 1)), x1 = min(W - 1, floor(max(p[0], q[0]) + r + 1));\n      const y0 = max(0, floor(min(p[1], q[1]) - r - 1)), y1 = min(H - 1, floor(max(p[1], q[1]) + r + 1));\n      const dx = q[0] - p[0], dy = q[1] - p[1], ll = dx * dx + dy * dy || 1e-9;\n      for (let y = y0; y \u003c= y1; y++)\n        for (let x = x0; x \u003c= x1; x++) {\n          const px = x + 0.5 - p[0], py = y + 0.5 - p[1], u = cl((px * dx + py * dy) / ll, 0, 1);\n          const ex = px - u * dx, ey = py - u * dy, dd = sqrt(ex * ex + ey * ey);\n          const c = cl(r - dd + 0.5, 0, 1);\n          if (c \u003c= 0) continue;\n          const o = y * W + x, age = a0 + u * (a1 - a0);\n          if (age \u003c zA[o] - 0.02 || (zB[o] === bi && c > zC[o])) {\n            zA[o] = age;\n            zB[o] = bi;\n            zC[o] = c;\n          }\n        }\n    }\n  }\n  const col = [0, 0, 0];\n  const cols = balls.map((b) => {\n    const h = S.hue + HUE0 + b.id * GOLD, hh = h - floor(h);\n    const warm = max(0, 1 - abs(hh - 0.11) / 0.1);\n    hsv(h, 0.85 - 0.25 * warm, 1, col);\n    return [col[0], col[1], col[2], warm];\n  });\n  for (let o = 0; o \u003c N; o++) {\n    const c = zC[o];\n    if (c \u003c= 0) continue;\n    const bc = cols[zB[o]], age = zA[o] / L, lv = (1 - 0.45 * age) * (1 - 0.6 * bc[3]) + bc[3];\n    rgb[o * 3] = bc[0] * lv * c;\n    rgb[o * 3 + 1] = bc[1] * lv * c;\n    rgb[o * 3 + 2] = bc[2] * lv * c;\n  }\n  // The balls: a glow, a full disc and a pale core.\n  for (let bi = 0; bi \u003c balls.length; bi++) {\n    const b = balls[bi];\n    if (!posAt(b, S.beat, q)) continue;\n    const grow = cl((S.beat - b.born) / 0.4, 0, 1), c = cols[bi];\n    const R = R_BALL * grow, G = R_GLOW * grow;\n    for (let y = max(0, floor(q[1] - G)); y \u003c= min(H - 1, floor(q[1] + G)); y++)\n      for (let x = max(0, floor(q[0] - G)); x \u003c= min(W - 1, floor(q[0] + G)); x++) {\n        const dd = sqrt((x + 0.5 - q[0]) ** 2 + (y + 0.5 - q[1]) ** 2);\n        if (dd > G) continue;\n        const o = (y * W + x) * 3, halo = 0.55 * (1 - dd / G) ** 1.4, disc = cl(R - dd + 0.5, 0, 1), core = cl(1 - dd / (R * 0.8), 0, 1) * 0.6;\n        for (let ch = 0; ch \u003c 3; ch++) {\n          let v = 1 - (1 - rgb[o + ch]) * (1 - c[ch] * halo);\n          v += (c[ch] - v) * disc;\n          v += (1 - v) * core * disc;\n          rgb[o + ch] = v;\n        }\n      }\n  }\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","spider-drop":"// ===== Patternflow pattern =====\n// Title:   Spider Drop\n// Family:  halloween\n// Idea:    A spider sits at the hub of an orb web strung across the moon, lets go and falls on its silk to the foot of the panel between two corner cobwebs, bounces and twists on the line, then climbs back up it, and the web jolts each time the line snaps tight or the spider lets go.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 41; after the drop-down spiders hung over doorways at Halloween\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Colour=0..1, Speed=0.2..3, Spiders=1..3, Wind=0..1\n//\n// Knob 1: Colour. Three palettes round the knob: at 0 an orange moon, a violet web and a toxic green spider with orange spots; at 0.33 a toxic green moon, an orange web and a purple spider; at 0.67 a lilac moon, a green web and an orange spider. Each holds for 0.1 either side of its point and blends into the next in between, and 1 is 0 again.\n// Knob 2: Speed. At 2 one round takes 8.4 seconds: 1.1 at the hub, a 1.3-second fall to 62 rows below it, 3.2 bouncing and twisting on the line and 2.7 climbing back. At 0.2 a round takes 84 seconds, at 3 it takes 5.6.\n// Knob 3: Spiders, 1 to 3. The second and third are 0.72 the size of the first and hang from the left and right of the web's rim, dropping 44 and 52 rows. With all three on their lines the hub sags 9 LEDs when they land, against 6 for one.\n// Knob 4: Wind. Sways the web sideways, up to 3 LEDs at the hub, and swings the spiders on their lines. At 0.06 the main spider swings about 10 LEDs either side, most of it from the landing; at 1 the gusts swing it 20.\n// Buttons: K1 tap drops every spider that is sitting at the hub or climbing, at once.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, round, sin, cos, exp, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst mix = (a, b, t) => a + (b - a) * t;\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\n// The orb web: hub, spokes, frame radius per spoke, capture spiral.\nconst HX = 31, HY = 30, SPOKES = 10, TURNS = 3.2, R_IN = 6;\n// The moon behind it.\nconst MX = 37, MY = 27, MR = 19;\n// Palettes, cycled by K1: moon, moon's rim, web, spider, spider's mark.\nconst PAL = [\n  [[1, 0.62, 0.16], [1, 0.84, 0.5], [0.72, 0.5, 1], [0.42, 1, 0.16], [1, 0.45, 0.05]],\n  [[0.55, 1, 0.22], [0.85, 1, 0.6], [1, 0.58, 0.12], [0.72, 0.3, 1], [0.45, 1, 0.2]],\n  [[0.74, 0.5, 1], [0.9, 0.8, 1], [0.45, 1, 0.25], [1, 0.55, 0.08], [0.75, 0.3, 1]],\n];\n// Spiders: where each hangs from (the hub, or a point on spoke n at 0.8 of\n// its length), how far it drops in rows, and its size.\nconst SPIDERS = [\n  { from: -1, drop: 62, size: 1 },\n  { from: 8, drop: 44, size: 0.72 },\n  { from: 3, drop: 52, size: 0.72 },\n];\n\nfunction webGeometry() {\n  const spokes = [];\n  for (let i = 0; i \u003c SPOKES; i++) {\n    const a = (TAU * (i + 0.3 * (hash(i * 7 + 1) - 0.5))) / SPOKES - PI / 2;\n    const R = 24 + 4 * hash(i * 7 + 2);\n    spokes.push({ a, R });\n  }\n  return spokes;\n}\n\n// Corner cobwebs at the foot of the panel, drawn once: radial threads from\n// each bottom corner and three sagging arcs across them.\nfunction cornerWebs() {\n  const cov = new Float32Array(N);\n  for (const side of [-1, 1]) {\n    const cx = side \u003c 0 ? 0 : W, cy = H, angs = [0.05, 0.55, 1.05, 1.52];\n    const pt = (r, a) => [cx - side * r * cos(a), cy - r * sin(a)];\n    for (const a of angs) line(cov, ...pt(0, a), ...pt(31, a), 1.6, 0.8);\n    for (const r of [10, 19, 28])\n      for (let n = 0; n \u003c angs.length - 1; n++)\n        for (let m = 1; m \u003c= 6; m++) {\n          const at = (k) => pt(r - 1.6 * sin((PI * k) / 6) * (r / 20), mix(angs[n], angs[n + 1], k / 6));\n          line(cov, ...at(m - 1), ...at(m), 1.5, 0.75);\n        }\n  }\n  return cov;\n}\n\nexport function setup(params) {\n  params.s = {\n    spokes: webGeometry(), t: 0, hue: 0, speed: 2, count: 1, wind: 0.06,\n    // The web's sag (rows) and its rate: a damped spring the spiders kick.\n    sag: 0, sagV: 0, gust: 0,\n    sp: SPIDERS.map((d, i) => ({ ...d, i, phase: \"rest\", timer: 0, y: 0, vy: 0, spin: 0, spinV: 0, sw: 0, swV: 0, gait: 0, on: i === 0 })),\n    base: cornerWebs(), cov: new Float32Array(N), legs: new Float32Array(N), rgb: new Float32Array(N * 3), moon: new Float32Array(N * 3), pal: -1,\n  };\n}\n\nconst REST = 1.1, HANG = 3.2, CLIMB = 30;\n\nfunction kickWeb(S, v) {\n  S.sagV += v;\n}\n\nfunction stepSpider(S, p, d, tap) {\n  p.timer += d;\n  if (!p.on) {\n    p.phase = \"rest\";\n    p.y = 0;\n    return;\n  }\n  if (tap && p.phase !== \"drop\" && p.phase !== \"hang\") {\n    p.phase = \"drop\";\n    p.timer = 0;\n    p.vy = max(p.vy, 0);\n    kickWeb(S, -6 * p.size);\n  }\n  if (p.phase === \"rest\") {\n    p.y = 0;\n    p.vy = 0;\n    p.spin *= exp(-d * 3);\n    if (p.timer > REST) {\n      p.phase = \"drop\";\n      p.timer = 0;\n      kickWeb(S, -6 * p.size);\n    }\n  } else if (p.phase === \"drop\" || p.phase === \"hang\") {\n    // A fall with drag, at most 79 rows a second, until the line runs out;\n    // then the line stretches like a spring, about 7 rows past its length.\n    const L = p.drop;\n    let acc = 150 - 1.9 * p.vy;\n    if (p.y > L) acc -= 110 * (p.y - L) + 1.6 * p.vy;\n    if (p.phase === \"drop\" && p.y > L) {\n      p.phase = \"hang\";\n      p.timer = 0;\n      p.spinV += (p.i & 1 ? -1 : 1) * 7;\n      p.swV += (p.i & 1 ? 1 : -1) * 0.2;\n      kickWeb(S, 0.17 * p.vy * p.size);\n    }\n    p.vy += acc * d;\n    p.y += p.vy * d;\n    if (p.phase === \"hang\") {\n      // Twisting on the line: a torsion pendulum.\n      p.spinV += (-5 * p.spin - 0.45 * p.spinV) * d;\n      p.spin += p.spinV * d;\n      if (p.timer > HANG) {\n        p.phase = \"climb\";\n        p.timer = 0;\n      }\n    }\n  } else if (p.phase === \"climb\") {\n    p.gait += d * 9;\n    const v = CLIMB * (0.55 + 0.45 * sin(p.gait) ** 2);\n    p.y = max(0, p.y - v * d);\n    p.vy = 0;\n    p.spin *= exp(-d * 2);\n    if (p.y \u003c= 0) {\n      p.phase = \"rest\";\n      p.timer = 0;\n      kickWeb(S, 3 * p.size);\n    }\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.count = cl(round(k[2]), 1, 3);\n  S.wind = cl(k[3], 0, 1);\n  const pd = d * S.speed * 0.5;\n  S.t += pd;\n  const tap = !!(input.btnPressed && input.btnPressed[0]);\n  for (const p of S.sp) {\n    const on = p.i \u003c S.count;\n    if (on && !p.on) p.timer = REST - 0.3 - p.i * 0.4;\n    p.on = on;\n    stepSpider(S, p, pd, tap);\n  }\n  // The web: a spring pulled down by the weight on its lines, and harder\n  // while a line is stretched past its length.\n  let load = 0;\n  for (const p of S.sp) if (p.on && p.y > 0) load += p.size * (p.phase === \"hang\" ? 1 + 0.03 * max(0, p.y - p.drop) * 10 : 1);\n  S.sagV += (-30 * (S.sag - 1.7 * load) - 2.4 * S.sagV) * pd;\n  S.sag += S.sagV * pd;\n  // Wind: a slow swell with gusts.\n  S.gust = S.wind * (0.6 * sin(S.t * 0.9) + 0.4 * sin(S.t * 2.3 + 1)) + 0.15 * sin(S.t * 1.7);\n  for (const p of S.sp) {\n    if (!p.on) continue;\n    const L = max(4, p.y);\n    p.swV += ((-90 / L) * sin(p.sw) - 0.5 * p.swV + (S.gust * 18) / L) * pd;\n    p.sw += p.swV * pd;\n    p.sw = cl(p.sw, -0.6, 0.6);\n  }\n}\n\n// --- drawing ---\n\n// Anti-aliased line of width w into the coverage buffer, keeping the most\n// coverage at each LED.\nfunction line(cov, x0, y0, x1, y1, w, a) {\n  const r = w / 2;\n  const xa = max(0, floor(min(x0, x1) - r - 1)), xb = min(W - 1, floor(max(x0, x1) + r + 1));\n  const ya = max(0, floor(min(y0, y1) - r - 1)), yb = min(H - 1, floor(max(y0, y1) + r + 1));\n  const dx = x1 - x0, dy = y1 - y0, ll = dx * dx + dy * dy || 1e-9;\n  for (let y = ya; y \u003c= yb; y++)\n    for (let x = xa; x \u003c= xb; x++) {\n      const px = x + 0.5 - x0, py = y + 0.5 - y0, u = cl((px * dx + py * dy) / ll, 0, 1);\n      const ex = px - u * dx, ey = py - u * dy, c = cl(r - sqrt(ex * ex + ey * ey) + 0.5, 0, 1) * a;\n      const o = y * W + x;\n      if (c > cov[o]) cov[o] = c;\n    }\n}\n\nfunction palette(S) {\n  const h = (S.hue - floor(S.hue)) * 3, i = floor(h) % 3, f = h - floor(h), j = (i + 1) % 3;\n  // Each palette holds for 0.1 either side of 0, 1/3 and 2/3 of the knob.\n  const g = cl((f - 0.3) / 0.4, 0, 1), s = g * g * (3 - 2 * g);\n  return PAL[0].map((_, n) => [0, 1, 2].map((c) => mix(PAL[i][n][c], PAL[j][n][c], s)));\n}\n\n// Where the web's point at radius r, angle a sits now: pulled down by the\n// sag, cone-shaped about the hub, and pushed sideways by the wind.\nfunction webPoint(S, r, a, R, out) {\n  const f = max(0, 1 - r / (R + 4));\n  out[0] = HX + r * cos(a) + S.gust * 3 * f;\n  out[1] = HY + r * sin(a) + S.sag * f + 0.6 * S.sag * f * sin(3 * a);\n}\n\nfunction drawSpider(S, rgb, p, x, y, pal) {\n  const sz = p.size, c = cos(p.spin), sx = (abs(c) \u003c 0.18 ? 0.18 * Math.sign(c || 1) : c) * sz;\n  const body = pal[3], mark = pal[4];\n  const legs = S.legs;\n  const bx0 = max(0, floor(x - 19 * sz)), bx1 = min(W - 1, floor(x + 19 * sz)), by0 = max(0, floor(y - 11 * sz)), by1 = min(H - 1, floor(y + 22 * sz));\n  for (let yy = by0; yy \u003c= by1; yy++) legs.fill(0, yy * W + bx0, yy * W + bx1 + 1);\n  // Head down: abdomen at (x, y), head below it. Legs from the head.\n  const hx = x, hy = y + 7.5 * sz;\n  const idle = p.phase === \"climb\" ? 0.35 : p.phase === \"drop\" ? 0.08 : 0.12;\n  const base = [0.45, 1.0, 1.85, 2.45];\n  for (let side = -1; side \u003c= 1; side += 2)\n    for (let j = 0; j \u003c 4; j++) {\n      const wig = idle * sin(p.gait + S.t * (p.phase === \"climb\" ? 0 : 2.2) + j * 1.6 + (side > 0 ? PI : 0));\n      const a = base[j] + wig + (p.phase === \"drop\" ? (j \u003c 2 ? -0.25 : 0.25) : 0);\n      const rx = hx + side * 1.2 * sx, ry = hy - 1 + j * 0.9 * sz;\n      const kx = rx + side * sin(a - 0.5) * 7 * sx, ky = ry + cos(a - 0.5) * 7 * sz - 3 * sz;\n      const fx = kx + side * sin(a + 0.35) * 8 * sx, fy = ky + cos(a + 0.35) * 8 * sz;\n      line(legs, rx, ry, kx, ky, 1.9, 1);\n      line(legs, kx, ky, fx, fy, 1.6, 1);\n    }\n  for (let yy = by0; yy \u003c= by1; yy++)\n    for (let xx = bx0; xx \u003c= bx1; xx++) {\n      const o = yy * W + xx, a = legs[o];\n      if (a \u003c= 0) continue;\n      for (let ch = 0; ch \u003c 3; ch++) rgb[o * 3 + ch] = mix(rgb[o * 3 + ch], body[ch] * 0.8, a);\n    }\n  // Abdomen and head: filled ellipses with a soft edge.\n  const blob = (cx, cy, rx, ry, col, lit) => {\n    for (let yy = max(0, floor(cy - ry - 1)); yy \u003c= min(H - 1, floor(cy + ry + 1)); yy++)\n      for (let xx = max(0, floor(cx - rx - 1)); xx \u003c= min(W - 1, floor(cx + rx + 1)); xx++) {\n        const u = (xx + 0.5 - cx) / rx, v = (yy + 0.5 - cy) / ry, q = sqrt(u * u + v * v);\n        const a = cl((1 - q) * min(rx, ry) + 0.5, 0, 1);\n        if (a \u003c= 0) continue;\n        const o = (yy * W + xx) * 3, sh = lit * (1 - 0.35 * cl(q, 0, 1));\n        for (let ch = 0; ch \u003c 3; ch++) rgb[o + ch] = mix(rgb[o + ch], col[ch] * sh, a);\n      }\n  };\n  const ax = 5.2 * sz * (0.75 + 0.25 * abs(c));\n  blob(x, y, ax, 6.2 * sz, body, 1);\n  blob(hx, hy, 3.2 * sz * (0.8 + 0.2 * abs(c)), 3 * sz, body, 0.85);\n  // The mark on the abdomen's back, seen when the back faces out.\n  const face = cl(c * 1.4, 0, 1);\n  if (face > 0) {\n    blob(x, y - 1.6 * sz, 1.6 * sz * abs(c) + 0.3, 1.6 * sz, mark, face);\n    blob(x, y + 2 * sz, 1.3 * sz * abs(c) + 0.3, 1.3 * sz, mark, face);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cov, rgb, spokes } = S;\n  const pal = palette(S);\n  const [moon, rim, web] = pal;\n  cov.set(S.base);\n  // Moon: a disc lit brighter toward its rim colour at the upper left, with\n  // a few darker seas, and a faint halo. It only changes with the colour.\n  if (S.pal !== S.hue) {\n    S.moon.fill(0);\n    for (let y = 0; y \u003c 60; y++)\n      for (let x = 0; x \u003c W; x++) {\n        const dx = x + 0.5 - MX, dy = y + 0.5 - MY, r = sqrt(dx * dx + dy * dy), o = (y * W + x) * 3;\n        const a = cl(MR - r + 0.5, 0, 1);\n        const halo = 0.09 * cl(1 - (r - MR) / 7, 0, 1) * (r > MR ? 1 : 0);\n        let sea = 0;\n        for (const [sx, sy, sr] of [[-5, -3, 5], [4, 5, 4], [-2, 8, 3], [6, -6, 3]]) sea = max(sea, cl(1 - sqrt((dx - sx) ** 2 + (dy - sy) ** 2) / sr, 0, 1));\n        const lift = cl(0.5 - (dx + dy) / (2.4 * MR), 0, 1);\n        for (let ch = 0; ch \u003c 3; ch++) S.moon[o + ch] = a * mix(moon[ch], rim[ch], lift) * (1 - 0.28 * sea) + halo * moon[ch];\n      }\n    S.pal = S.hue;\n  }\n  rgb.set(S.moon);\n  // The orb web.\n  const P = [0, 0], Q = [0, 0];\n  for (const s of spokes) {\n    webPoint(S, 1.5, s.a, s.R, P);\n    webPoint(S, s.R, s.a, s.R, Q);\n    line(cov, P[0], P[1], Q[0], Q[1], 1.8, 1);\n  }\n  for (let i = 0; i \u003c SPOKES; i++) {\n    const a = spokes[i], b = spokes[(i + 1) % SPOKES];\n    webPoint(S, a.R, a.a, a.R, P);\n    webPoint(S, b.R, b.a, b.R, Q);\n    line(cov, P[0], P[1], Q[0], Q[1], 1.9, 1);\n  }\n  const steps = floor(TURNS * SPOKES);\n  for (let k = 0; k \u003c steps; k++) {\n    const i = k % SPOKES, j = (k + 1) % SPOKES, f0 = k / steps, f1 = (k + 1) / steps;\n    const a = spokes[i], b = spokes[j];\n    const r0 = R_IN + (a.R - 3 - R_IN) * f0, r1 = R_IN + (b.R - 3 - R_IN) * f1;\n    webPoint(S, r0, a.a, a.R, P);\n    webPoint(S, r1, b.a, b.R, Q);\n    line(cov, P[0], P[1], Q[0], Q[1], 1.7, 0.95);\n  }\n  // Moorings from the frame to the panel's edges.\n  for (const [i, ex, ey] of [[0, 30, 0], [2, 63, 2], [4, 63, 52], [7, 0, 56], [9, 0, 3]]) {\n    const s = spokes[i];\n    webPoint(S, s.R, s.a, s.R, P);\n    line(cov, P[0], P[1], ex, ey, 1.3, 0.85);\n  }\n  // Silk lines and the spiders' places.\n  const places = [];\n  for (const p of S.sp) {\n    if (!p.on) continue;\n    let ax, ay;\n    if (p.from \u003c 0) webPoint(S, 0, 0, 30, P);\n    else {\n      const s = spokes[p.from];\n      webPoint(S, s.R * 0.8, s.a, s.R, P);\n    }\n    ax = P[0];\n    ay = P[1];\n    const L = p.y, x = ax + sin(p.sw) * L, y = ay + cos(p.sw) * L;\n    if (L > 1) line(cov, ax, ay, x, y - 5 * p.size, 1, 0.9);\n    places.push([p, x, y + 2 * p.size]);\n  }\n  for (let o = 0; o \u003c N; o++) {\n    // Threads are drawn whole or not at all: a lit LED is a lit LED.\n    const c = cov[o] > 0.42 ? 1 : 0;\n    if (c \u003c= 0) continue;\n    const q = o * 3, lum = max(rgb[q], rgb[q + 1], rgb[q + 2]);\n    // Over the moon a thread is a dark line; over the sky a pale one.\n    if (lum > 0.3) for (let ch = 0; ch \u003c 3; ch++) rgb[q + ch] *= 1 - 0.85 * c;\n    else for (let ch = 0; ch \u003c 3; ch++) rgb[q + ch] = max(rgb[q + ch], web[ch] * c * 0.9);\n  }\n  for (const [p, x, y] of places) drawSpider(S, rgb, p, x, y, pal);\n  for (let o = 0, y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, o++) display.setPixel(x, y, round(255 * min(1, rgb[o * 3])), round(255 * min(1, rgb[o * 3 + 1])), round(255 * min(1, rgb[o * 3 + 2])));\n}\n","square-wheels":"// ===== Patternflow pattern =====\n// Title:   Square Wheels\n// Family:  physics\n// Idea:    Three lanes of polygon wheels, squares to begin with, roll along roads of inverted catenary arcs cut to the length of one side, and each wheel is only ever set down on its road, yet its axle runs dead level along a faint line, until the road is flattened and the axles start to bob.\n// Author:  patternflow-lab\n// Date:    2026-10-25\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Roads and wheels, the square wheel on inverted catenaries (Leon Hall and Stan Wagon, 1992), pattern round 41\n// Round:   41\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Sides=4..8, Road=0..1\n//\n// Knob 1: Hue. Turns the three lanes round the wheel together, a third of the wheel apart. At 0 azure, magenta and lime wheels on blue, wine and green roads; at 0.5 orange, green and violet. A road that comes round to orange, yellow or yellow-green is lifted and paled so it never reads brown or olive.\n// Knob 2: Speed. At 2 the wheels travel 10 LEDs a second, so a square of side 22.6 turns a quarter in 2 seconds; at 0.2 they travel 1 LED a second, at 3 they travel 15. The top and bottom lanes roll right, the middle one left.\n// Knob 3: Sides. The number of sides of every wheel, 4 to 8, each with its own road. Every wheel sweeps the same circle of radius 16, so a square has inradius 11.3 and humps 19.9 LEDs apart and 4.7 deep; an octagon has inradius 14.8 and humps 11.9 apart and 1.2 deep. Triangles are left out: on their road a corner cuts 0.095 of the inradius into the next hump.\n// Knob 4: Road. Up to 0.06 the road is Hall and Wagon's: the arcs y = -r cosh(x / r), and the axles stay on the line. Above that the humps flatten toward a flat road at 1, and since each wheel is only set down on the road, its axle lifts off the line as it tips over a corner: by 4.7 LEDs for a square on the flat road, 1.2 for an octagon.\n\nconst W = 64, H = 128;\nconst { floor, ceil, min, max, abs, round, sin, cos, tan, sinh, cosh, asinh, hypot, sign, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Three lanes down the panel. R is the circle every wheel in a lane sweeps,\n// whatever its number of sides, so no wheel leaves its lane: 1 row above\n// the wheel, the axle, 2R rows down to the bottom of a trough, and the rest\n// of the lane is road. The middle lane is half a LED smaller, so its humps\n// fall out of step with the others.\nconst LANES = [\n  { y0: 0, h: 43, dir: 1, R: 16, hue: 0, start: 0 },\n  { y0: 43, h: 42, dir: -1, R: 15.5, hue: 1 / 3, start: 13.7 },\n  { y0: 85, h: 43, dir: 1, R: 16, hue: 2 / 3, start: 27.4 },\n];\n// Bands: 2 LEDs lit and 1 dark, inside the wheels and in the road.\nconst BW = 2, BP = 3;\n// Opening hues: azure, magenta, lime.\nconst HUE0 = 0.55;\n// Travel in LEDs a second per unit of Speed.\nconst PACE = 5;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, sides: 4, road: 0, t: 0,\n    code: new Uint8Array(W * H), key: \"\", rgb: new Float32Array(W * H * 3),\n    pal: LANES.map(() => [[0, 0, 0], [0, 0, 0], [0, 0, 0]]),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 4, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.sides = round(cl(k[2], 4, 8));\n  // Up to 0.06, the opening, the road is exactly the catenary one.\n  S.road = max(0, (cl(k[3], 0, 1) - 0.06) / 0.94);\n  S.t += d * S.speed * PACE;\n}\n\n// A lane's road and wheels for n sides at road blend kr (0 catenary, 1\n// flat). r is the inradius and a the half-span of one catenary arc, whose\n// length r sinh(a / r) = r tan(pi / n) is half a side; c is half a side. The\n// flat road needs a whole side per hump, so the hump spacing P blends the\n// two. Wheels sit a whole number of humps apart, at least 2R + 5.\nfunction laneGeom(L, n, kr) {\n  const R = L.R, r = R * cos(PI / n), a = r * asinh(tan(PI / n)), c = r * tan(PI / n);\n  const P = 2 * ((1 - kr) * a + kr * c);\n  // Arc i is y = -A cosh(sc (x - iP)) - B, axle level at y = 0, y up.\n  return { n, R, r, a, c, P, D: ceil((2 * R + 5) / P) * P, kr, A: r * (1 - kr), sc: (2 * a) / (P * r), B: r * kr };\n}\n\nconst roadAt = (g, x) => {\n  const xl = x - g.P * round(x / g.P);\n  return -g.A * cosh(g.sc * xl) - g.B;\n};\n\n// How far the axle sits from the middle of its hump when the wheel has\n// tipped by th: on the catenary road x = r asinh(tan th), so the axle stays\n// straight above the point of contact; on the flat road the wheel pivots on\n// a corner. The road blend blends the two.\nfunction xOfTheta(g, th) {\n  const cat = g.r * asinh(tan(th));\n  const piv = sign(th) * (g.c - g.R * sin(PI / g.n - abs(th)));\n  return (1 - g.kr) * cat + g.kr * piv;\n}\n\nfunction thetaOfX(g, xl) {\n  let lo = -PI / g.n, hi = PI / g.n;\n  for (let i = 0; i \u003c 36; i++) {\n    const mid = (lo + hi) / 2;\n    if (xOfTheta(g, mid) \u003c xl) lo = mid;\n    else hi = mid;\n  }\n  return (lo + hi) / 2;\n}\n\n// The wheels of a lane at axle position X: their turn psi (y up,\n// anticlockwise) from rolling, and their height Y found by setting the wheel\n// down on the road, the lowest height at which no side dips below it. The\n// road minus a side's line is concave along each arc, so its highest point\n// on a stretch is where the arc's slope equals the side's, or an end.\nfunction pose(g, X) {\n  const q = round(X / g.P), th = thetaOfX(g, X - q * g.P);\n  const psi = -(q * TAU) / g.n - th;\n  let Y = -1e9;\n  for (let i = 0; i \u003c g.n; i++) {\n    const a0 = psi - PI / 2 + ((i - 0.5) * TAU) / g.n, a1 = a0 + TAU / g.n;\n    let x0 = X + g.R * cos(a0), y0 = g.R * sin(a0), x1 = X + g.R * cos(a1), y1 = g.R * sin(a1);\n    if (x1 \u003c x0) [x0, y0, x1, y1] = [x1, y1, x0, y0];\n    if (x1 - x0 \u003c 1e-9) {\n      Y = max(Y, roadAt(g, x0) - min(y0, y1));\n      continue;\n    }\n    const m = (y1 - y0) / (x1 - x0);\n    for (let k = round(x0 / g.P); k \u003c= round(x1 / g.P); k++) {\n      const c = k * g.P, lo = max(x0, c - g.P / 2), hi = min(x1, c + g.P / 2);\n      if (hi \u003c lo) continue;\n      const t = cl(g.A > 1e-9 ? c + asinh(-m / (g.A * g.sc)) / g.sc : lo, lo, hi);\n      const need = (x) => -g.A * cosh(g.sc * (x - c)) - g.B - (y0 + m * (x - x0));\n      Y = max(Y, need(t), need(lo), need(hi));\n    }\n  }\n  return { psi, Y };\n}\n\n// Distance from (px, py) to arc k, by Newton's method on the squared\n// distance with the foot kept on the arc.\nfunction arcDist(g, k, px, py) {\n  const c = k * g.P, hw = g.P / 2, { A, B, sc } = g;\n  let t = cl(px, c - hw, c + hw);\n  for (let i = 0; i \u003c 4; i++) {\n    const u = sc * (t - c), ch = cosh(u), sh = sinh(u);\n    const gy = -A * ch - B, g1 = -A * sc * sh, g2 = -A * sc * sc * ch;\n    const f1 = t - px + (gy - py) * g1, f2 = 1 + g1 * g1 + (gy - py) * g2;\n    t = cl(t - f1 / max(0.2, f2), c - hw, c + hw);\n  }\n  return hypot(t - px, -A * cosh(sc * (t - c)) - B - py);\n}\n\nconst axleRow = (L) => floor(L.y0 + 1 + L.R) + 0.5;\n\n// The road layer, kept until Sides or Road moves: 1 for the surface band,\n// 2 for a lit band below it, the bands following the road's shape by true\n// distance, so under each trough they meet in a crease; 3 for the axle line.\nfunction buildRoads(S) {\n  const code = S.code;\n  code.fill(0);\n  for (const L of LANES) {\n    const g = laneGeom(L, S.sides, S.road), yA = axleRow(L);\n    for (let x = 0; x \u003c W; x++) {\n      const lx = x + 0.5, ry = roadAt(g, lx), k0 = round(lx / g.P), k1 = lx > k0 * g.P ? k0 + 1 : k0 - 1;\n      for (let y = L.y0; y \u003c L.y0 + L.h; y++) {\n        const ly = yA - (y + 0.5), p = y * W + x;\n        if (abs(ly) \u003c 0.5) code[p] = 3;\n        if (ly >= ry) continue;\n        const d = min(arcDist(g, k0, lx, ly), arcDist(g, k1, lx, ly));\n        if (d \u003c BW) code[p] = 1;\n        else if (d >= BP && (d - BP) % BP \u003c BW) code[p] = 2;\n      }\n    }\n  }\n}\n\nfunction palette(S) {\n  LANES.forEach((L, i) => {\n    const [wheel, road, top] = S.pal[i], h = S.hue + HUE0 + L.hue, hr = h + 0.06, f = hr - floor(hr);\n    // A deep road from orange round to yellow-green reads brown or olive:\n    // lift and pale it.\n    const warm = sm(0, 0.05, f) * (1 - sm(0.2, 0.26, f));\n    hsv(h, 0.8, 1, wheel);\n    hsv(hr, 0.75 - 0.25 * warm, 0.6 + 0.3 * warm, road);\n    hsv(hr, 0.4, 1, top);\n  });\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const key = S.sides + \"/\" + S.road;\n  if (key !== S.key) {\n    buildRoads(S);\n    S.key = key;\n  }\n  palette(S);\n  const { rgb, code, pal } = S;\n  rgb.fill(0);\n  for (let li = 0; li \u003c LANES.length; li++) {\n    const L = LANES[li], [, road, top] = pal[li];\n    for (let p = L.y0 * W; p \u003c (L.y0 + L.h) * W; p++) {\n      const c = code[p], o = p * 3;\n      if (c === 1) (rgb[o] = top[0]), (rgb[o + 1] = top[1]), (rgb[o + 2] = top[2]);\n      else if (c === 2) (rgb[o] = road[0]), (rgb[o + 1] = road[1]), (rgb[o + 2] = road[2]);\n      else if (c === 3) (rgb[o] = 0.11), (rgb[o + 1] = 0.11), (rgb[o + 2] = 0.15);\n    }\n  }\n  // The wheels: nested polygons 2 LEDs wide with 1-LED grooves, round a\n  // white hub on the axle.\n  for (let li = 0; li \u003c LANES.length; li++) {\n    const L = LANES[li], g = laneGeom(L, S.sides, S.road), wheel = pal[li][0], yA = axleRow(L);\n    const X0 = L.dir * S.t + L.start, { psi, Y } = pose(g, X0 - g.D * floor(X0 / g.D));\n    const ux = [], uy = [];\n    for (let i = 0; i \u003c g.n; i++) {\n      const an = -PI / 2 + (i * TAU) / g.n - psi;\n      ux.push(cos(an));\n      uy.push(sin(an));\n    }\n    for (let j = ceil((-g.R - 1 - X0) / g.D); X0 + j * g.D \u003c W + g.R + 1; j++) {\n      const cx = X0 + j * g.D, cy = yA - Y;\n      for (let y = max(L.y0, floor(cy - g.R)); y \u003c= min(L.y0 + L.h - 1, ceil(cy + g.R)); y++)\n        for (let x = max(0, floor(cx - g.R)); x \u003c= min(W - 1, ceil(cx + g.R)); x++) {\n          const dx = x + 0.5 - cx, dy = cy - (y + 0.5);\n          let gauge = -1e9;\n          for (let i = 0; i \u003c g.n; i++) gauge = max(gauge, dx * ux[i] + dy * uy[i]);\n          const e = g.r - gauge;\n          if (e \u003c 0) continue;\n          const rr = hypot(dx, dy), o = (y * W + x) * 3;\n          if (rr \u003c 2.2) (rgb[o] = 1), (rgb[o + 1] = 1), (rgb[o + 2] = 1);\n          else if (rr > 3.2 && e % BP \u003c BW) (rgb[o] = wheel[0]), (rgb[o + 1] = wheel[1]), (rgb[o + 2] = wheel[2]);\n          else rgb[o] = rgb[o + 1] = rgb[o + 2] = 0;\n        }\n    }\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, round(255 * min(1, rgb[q])), round(255 * min(1, rgb[q + 1])), round(255 * min(1, rgb[q + 2])));\n}\n","marbling":"// ===== Patternflow pattern =====\n// Title:   Marbling\n// Family:  print\n// Idea:    Drops of ink land on a dark bath and spread into rings, a comb is drawn across them one way and back the other and then down through them, dragging the rings into chevrons and feathers, then the paper is lifted and the bath starts again.\n// Author:  patternflow-lab\n// Date:    2026-10-23\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Aubrey Jaffer's mathematical marbling, after Turkish ebru and Japanese suminagashi\n// Round:   15\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Drops=3..8, Comb=0..1\n//\n// Knob 1: Hue. Turns the four inks round the colour wheel together, opening on ultramarine, turquoise, gold and rose.\n// Knob 2: Speed. How fast the marbler works: one bath, drops to lift, takes 116 s at the bottom of the range, 11.6 s where it opens and 7.7 s at the top.\n// Knob 3: Drops. How many places the inks are dropped, from 3 bullseyes about 50 LEDs across to 8 about 30 across; turning it lifts the print and the next bath has the new count.\n// Knob 4: Comb. How close the comb's teeth stand, from 3 teeth 43 LEDs apart that drag the rings most of the panel's width to 16 teeth 8 LEDs apart that crimp them; the comb drawn down afterwards goes from 3 teeth to 10.\n// Buttons: K1 tap lifts the paper now, whatever is on the bath, and the next bath starts.\n\nconst W = 64;\nconst H = 128;\nconst GW = W + 1;\nconst MAXSITES = 8;\n// Five drops land on each site: ink, clear water, ink, clear water, ink.\nconst DROPS = 5;\n// The drops of all the sites add up to this share of the panel's area.\nconst FILL = 0.8;\n// A clear drop's radius against an ink drop's: the dark rings between inks.\nconst CLEAR = 0.8;\n// How far a site stands off the panel's middle, in LEDs: OFF and up to 4 more.\nconst OFF = 5;\n// The bath's programme in bath seconds. Speed 2 runs 0.9 of them a second.\nconst RATE = 0.45;\nconst DROPS_END = 2.6;\nconst SPREAD = 0.5;\nconst ACROSS = 3.0;\nconst BACK = 4.8;\nconst PASS = 1.6;\nconst DOWN = 6.6;\nconst DOWN_LEN = 1.4;\nconst LIFT = 9.0;\nconst LIFT_LEN = 1.0;\nconst REST = 0.4;\n// The first frame finds the last site's drops landing.\nconst START = 1.6;\n// How far a coarse comb drags the ink sideways at a tooth, in LEDs, and how\n// far its pull reaches between teeth, as a share of the gap between them.\nconst ACROSS_PULL = 60;\nconst REACH = 0.75;\n// The sideways pull of the comb, in LEDs, as a function of height, and the\n// downward pull as a function of column: tables at a quarter LED, reaching\n// 64 LEDs past the panel, since the bath goes on beyond it.\nconst TQ = 4;\nconst TY0 = -64;\nconst TY = (H + 128) * TQ;\nconst TX0 = -64;\nconst TX = (W + 128) * TQ;\n// Ink hue and saturation, ultramarine, turquoise, gold, rose, before Hue turns them.\nconst INKS = [\n  [0.63, 1],\n  [0.48, 0.95],\n  [0.12, 1],\n  [0.94, 0.9],\n];\nconst NI = INKS.length;\n\nfunction hsvInto(out, o, h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[o] = (k === 0 || k === 5 ? v : k === 1 ? q : k === 4 ? t : p) * 255;\n  out[o + 1] = (k === 1 || k === 2 ? v : k === 0 ? t : k === 3 ? q : p) * 255;\n  out[o + 2] = (k === 3 || k === 4 ? v : k === 2 ? t : k === 5 ? q : p) * 255;\n}\n\nfunction ease(a, len, v) {\n  const t = Math.max(0, Math.min(1, (v - a) / len));\n  return t * t * (3 - 2 * t);\n}\n\n// Distance from d to the nearest tooth of a comb whose teeth stand at\n// phase, phase + pitch, phase + 2 pitch and so on.\nfunction toothDistance(d, phase, pitch) {\n  d -= phase;\n  d -= Math.floor(d / pitch) * pitch;\n  return d \u003c pitch - d ? d : pitch - d;\n}\n\n// A fresh bath. Each site is a spot where five drops land one after another.\n// The sites stand one above the other near the middle of their bands, every\n// other one 5 to 9 LEDs left of the panel's middle and the rest as far right,\n// and land in a shuffled order. All sites take the same size of drop.\nfunction newBath(P) {\n  P.tau = 0;\n  P.lift = -1;\n  const sites = P.sites;\n  const order = [];\n  for (let i = 0; i \u003c sites; i++) order.push(i);\n  for (let i = sites - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    const t = order[i];\n    order[i] = order[j];\n    order[j] = t;\n  }\n  const each = (DROPS_END - 0.1) / sites;\n  const R = Math.sqrt((FILL * W * H) / (sites * (DROPS - 0.5) * Math.PI));\n  let ink = Math.floor(Math.random() * NI);\n  const flip = Math.random() \u003c 0.5 ? 1 : -1;\n  for (let s = 0; s \u003c sites; s++) {\n    const band = order[s];\n    P.cx[s] = W / 2 + (band % 2 === 0 ? flip : -flip) * (OFF + Math.random() * 4);\n    P.cy[s] = ((band + 0.35 + Math.random() * 0.3) * H) / sites;\n    for (let d = 0; d \u003c DROPS; d++) {\n      const o = s * DROPS + d;\n      // Ink and clear water take turns, ink first and last, so the rings\n      // come out ink, dark, ink round an ink centre. The inks come round in\n      // turn, so every bath carries all four.\n      const clear = d % 2 === 1;\n      P.ink[o] = clear ? -1 : ink++ % NI;\n      P.rad[o] = R * (clear ? CLEAR : 1);\n      P.t0[o] = 0.1 + s * each + (d * each * 0.8) / DROPS;\n    }\n  }\n  // The first pass is drawn towards the side the even bands stand on (the\n  // top and bottom sites at Drops 3), so it drags the odd ones across the\n  // middle and folds the even ones back off the edge. Left to a coin, some\n  // baths came out of the first pass looking much as they went in.\n  P.dir = flip;\n}\n\nexport function setup(params) {\n  params.cx = new Float64Array(MAXSITES);\n  params.cy = new Float64Array(MAXSITES);\n  params.ink = new Int8Array(MAXSITES * DROPS);\n  params.rad = new Float64Array(MAXSITES * DROPS);\n  params.t0 = new Float64Array(MAXSITES * DROPS);\n  params.r2 = new Float64Array(MAXSITES * DROPS);\n  params.rowShift = new Float64Array(TY + 1);\n  params.colShift = new Float64Array(TX + 1);\n  params.tau = 0;\n  params.lift = -1;\n  params.dir = 1;\n  params.sites = 3;\n  params.live = 0;\n  params.hue = 0;\n  params.started = false;\n  params.idx = new Int8Array(GW * (H + 1));\n  params.px = new Float64Array(GW);\n  params.py = new Float64Array(GW);\n  params.hit = new Int8Array(GW);\n  params.rgb = new Float32Array(NI * 3);\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  dt = Math.min(dt, 0.1);\n  const P = params;\n  P.hue = k[0];\n  const comb = Math.max(0, Math.min(1, k[3]));\n  const sites = Math.max(3, Math.min(MAXSITES, Math.round(k[2])));\n  const step = dt * Math.max(0.05, k[1]) * RATE;\n  if (!P.started) {\n    P.started = true;\n    P.sites = sites;\n    newBath(P);\n    P.tau = START;\n  }\n  // The paper goes down on the bath and comes up with the print; then the\n  // bath is skimmed and the next drops fall. A tap, or a new Drops count,\n  // lifts whatever is on the bath now.\n  const tap = input.btnPressed && input.btnPressed[0];\n  if (P.lift \u003c 0 && (P.tau >= LIFT || tap || sites !== P.sites)) P.lift = 0;\n  if (P.lift >= 0) {\n    P.lift += step;\n    if (P.lift >= LIFT_LEN + REST) {\n      P.sites = sites;\n      newBath(P);\n    }\n  } else P.tau += step;\n  const tau = P.tau;\n\n  // Every drop's radius squared as it stands now. A drop spreads fast and\n  // slows as it meets the bath.\n  let live = 0;\n  for (let o = 0; o \u003c P.sites * DROPS; o++) {\n    const u = Math.max(0, Math.min(1, (tau - P.t0[o]) / SPREAD));\n    const r = P.rad[o] * (1 - (1 - u) * (1 - u) * (1 - u));\n    P.r2[o] = r * r;\n    if (u > 0) live = Math.floor(o / DROPS) + 1;\n  }\n  P.live = live;\n\n  // The comb is drawn across, then back the other way with its teeth\n  // between the first pass's, then a finer comb is drawn down. A tooth drags\n  // the bath along with it, less the further from the tooth: Jaffer's tine\n  // line, a pull of size * lam / (d + lam) at distance d.\n  const teeth = 3 + Math.round(comb * 13);\n  const pitch = H / teeth;\n  const lam = 2 + pitch * REACH;\n  // A fine comb drags the ink less far than a coarse one.\n  const pull = ACROSS_PULL * Math.min(1, pitch / 30);\n  const a1 = pull * ease(ACROSS, PASS, tau) * P.dir;\n  const a2 = -pull * ease(BACK, PASS, tau) * P.dir;\n  const rows = P.rowShift;\n  for (let i = 0; i \u003c= TY; i++) {\n    const y = TY0 + i / TQ;\n    let sh = 0;\n    if (a1 !== 0) sh += (a1 * lam) / (toothDistance(y, pitch * 0.5, pitch) + lam);\n    if (a2 !== 0) sh += (a2 * lam) / (toothDistance(y, 0, pitch) + lam);\n    rows[i] = sh;\n  }\n  const down = 3 + Math.round(comb * 7);\n  const dpitch = W / down;\n  const a3 = 14 * Math.min(1, dpitch / 16) * ease(DOWN, DOWN_LEN, tau);\n  const cols = P.colShift;\n  for (let i = 0; i \u003c= TX; i++) cols[i] = a3 === 0 ? 0 : (a3 * 2.5) / (toothDistance(TX0 + i / TQ, dpitch * 0.5, dpitch) + 2.5);\n}\n\nfunction lookup(table, v, v0, n) {\n  let f = (v - v0) * TQ;\n  if (f \u003c= 0) return table[0];\n  if (f >= n) return table[n];\n  const i = Math.floor(f);\n  f -= i;\n  return table[i] + (table[i + 1] - table[i]) * f;\n}\n\n// Finds whose ink lies under each corner of LEDs along the row at height y:\n// follows each point backwards through the comb strokes and then every site,\n// newest first, and writes 0..3 into hit, or -1 for the dark bath. The whole\n// row goes through one site before the next, so the processor can work on\n// many points while each waits on its square root.\nfunction inkRow(P, y) {\n  const cx = P.cx;\n  const cy = P.cy;\n  const r2 = P.r2;\n  const inks = P.ink;\n  const px = P.px;\n  const py = P.py;\n  const hit = P.hit;\n  const rows = P.rowShift;\n  const cols = P.colShift;\n  for (let j = 0; j \u003c GW; j++) {\n    const yy = y - lookup(cols, j, TX0, TX);\n    let x = j - lookup(rows, yy, TY0, TY);\n    // The bath past the panel's sides mirrors the panel, so a comb pulls\n    // ink in from beyond the edge.\n    x -= Math.floor(x / (2 * W)) * 2 * W;\n    px[j] = x \u003c W ? x : 2 * W - x;\n    py[j] = yy;\n    hit[j] = -2;\n  }\n  for (let s = P.live - 1; s >= 0; s--) {\n    const ox = cx[s];\n    const oy = cy[s];\n    const base = s * DROPS;\n    for (let j = 0; j \u003c GW; j++) {\n      if (hit[j] !== -2) continue;\n      const dx = px[j] - ox;\n      const dy = py[j] - oy;\n      const d2 = dx * dx + dy * dy;\n      // Drops on one spot push straight outward, so their areas add up: a\n      // point is in the newest drop, or in the ring of the one before, and so\n      // on, and past them all it comes in by their total area.\n      let rest = d2;\n      let o = base + DROPS - 1;\n      for (; o >= base; o--) {\n        if (rest \u003c r2[o]) break;\n        rest -= r2[o];\n      }\n      if (o >= base) hit[j] = inks[o];\n      else if (rest \u003c d2) {\n        const f = Math.sqrt(rest / d2);\n        px[j] = ox + dx * f;\n        py[j] = oy + dy * f;\n      }\n    }\n  }\n}\n\nexport function draw(display, params, time) {\n  const P = params;\n  const idx = P.idx;\n  const rgb = P.rgb;\n  const hit = P.hit;\n  for (let i = 0; i \u003c NI; i++) hsvInto(rgb, i * 3, INKS[i][0] + P.hue, INKS[i][1], 1);\n  // The bath is sampled at the LEDs' corners, and each LED shows the mean of\n  // its four corners: one sample an LED, and edges come out soft by a step.\n  for (let y = 0; y \u003c= H; y++) {\n    inkRow(P, y);\n    for (let j = 0; j \u003c GW; j++) idx[y * GW + j] = hit[j] === -2 ? -1 : hit[j];\n  }\n  for (let y = 0; y \u003c H; y++) {\n    // The paper peels off from the top and takes the print with it.\n    const fade = P.lift \u003c 0 ? 1 : 1 - ease((y / H) * 0.4, 0.6, P.lift);\n    if (fade \u003c= 0) continue;\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * GW + x;\n      const a = idx[p];\n      const b2 = idx[p + 1];\n      const c = idx[p + GW];\n      const d = idx[p + GW + 1];\n      let r = 0;\n      let g = 0;\n      let b = 0;\n      if (a === b2 && a === c && a === d) {\n        if (a \u003c 0) continue;\n        r = rgb[a * 3];\n        g = rgb[a * 3 + 1];\n        b = rgb[a * 3 + 2];\n      } else {\n        for (let n = 0; n \u003c 4; n++) {\n          const e = n === 0 ? a : n === 1 ? b2 : n === 2 ? c : d;\n          if (e \u003c 0) continue;\n          r += rgb[e * 3] * 0.25;\n          g += rgb[e * 3 + 1] * 0.25;\n          b += rgb[e * 3 + 2] * 0.25;\n        }\n      }\n      display.setPixel(x, y, r * fade, g * fade, b * fade);\n    }\n  }\n}\n","constant-width":"// ===== Patternflow pattern =====\n// Title:   Constant Width\n// Family:  geometry\n// Idea:    A column of curves of constant width 62, Reuleaux triangles, pentagons and heptagons, smooth curves built from odd harmonics and a disc, slides down a channel exactly 62 LEDs wide, each turning at its own rate while it touches both walls and the lines it shares with the curves above and below, so the stack never jams and never comes apart.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Curves of constant width, the Reuleaux polygons (Franz Reuleaux, 1876), and Barbier's theorem that they all have perimeter pi times their width (Joseph-Émile Barbier, 1860)\n// Round:   35\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Round=0..1, Spin=0..1\n//\n// Knob 1: Hue. Turns the eight colours round the wheel together. At 0 the Reuleaux polygons are gold, rose, teal and lime, lit to 81%, and the smooth curves and the disc violet, azure, indigo and sky at 52%. Where a deep one would land between orange and lime it is lifted and paled, since there it would read brown or olive.\n// Knob 2: Speed. How fast the column slides: 3 rows a second times the knob, so at 2 a curve takes 10 seconds to pass down its own height of 62 rows and at 0.2 it takes 100.\n// Knob 3: Round. Mixes every curve with the disc of the same width, support function by support function, which keeps the width at 62. At 0 the Reuleaux triangle has the least area a curve of width 62 can have, 2709 LEDs; at 1 every curve is the disc, 3019. The perimeter stays 194.8 the whole way.\n// Knob 4: Spin. How fast the curves turn, 0.4 radians a second at 0 and 3 at 1; neighbours turn opposite ways and each at its own multiple of that.\n// Buttons: K1 tap turns the corner trace on or off: each corner leaves a gold line in its own 62 x 62 square, and a turning Reuleaux triangle draws the square with rounded corners that the Watts drill cuts.\n\nconst W = 64, H = 128, WD = 62, N = 256, CYCLE = 8;\nconst { min, max, floor, ceil, round, sin, cos, sqrt, abs, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst hash = (i) => {\n  let h = Math.imul(i ^ 0x9e3779b9, 0x85ebca6b);\n  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n};\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The eight curves of the cycle, all of width WD. A Reuleaux n-gon is the\n// intersection of the n disks of radius WD centred on the corners of a\n// regular n-gon whose corner-to-far-corner distance is WD. A harmonic curve\n// has support function h = WD/2 + sum a cos(k t + c) over odd k from 3 up:\n// odd k is what makes h(t) + h(t + pi) = WD, the width in every direction,\n// and the radius of curvature h + h'' = WD/2 - sum a (k^2 - 1) cos(k t + c)\n// stays above 0, so it is convex. The amplitudes below keep that radius at\n// least 2 LEDs.\nconst SHAPES = [\n  { n: 3 },\n  { harm: [[3, 3.6, 0]] },\n  { n: 5 },\n  { harm: [[3, 2.2, 0], [5, 0.5, 1.1]] },\n  { n: 7 },\n  { disc: true },\n  { n: 3 },\n  { harm: [[3, 2.6, 0], [7, 0.16, 2.0]] },\n];\n// Base hue and brightness for each place in the cycle. The sharp curves are\n// lit brighter than the smooth ones, so the column reads as light and deep\n// shapes taking turns as it slides. The map's drift comes mostly from the\n// dark corners of each square, which swing round as the curves turn: with\n// all eight at one brightness it reads 0.263, with these 0.277.\nconst BASE = [[0.13, 0.86], [0.76, 0.55], [0.95, 0.86], [0.6, 0.55], [0.48, 0.86], [0.68, 0.55], [0.3, 0.86], [0.54, 0.55]];\n// The body angles each curve's trace follows: the n corners of a Reuleaux\n// polygon and the k peaks of a curve with one harmonic, which all run round\n// the same path, and for a curve of two harmonics the one point where its\n// support function peaks, since its corners are not alike and each would\n// draw a path of its own.\nfor (const s of SHAPES) {\n  if (s.n) s.tr = Array.from({ length: s.n }, (_, c) => (TAU * c) / s.n);\n  else if (s.harm && s.harm.length === 1) {\n    const [k, , c0] = s.harm[0];\n    s.tr = Array.from({ length: k }, (_, m) => (TAU * m - c0) / k);\n  } else if (s.harm) {\n    let best = -1e9, at = 0;\n    for (let i = 0; i \u003c 3600; i++) {\n      const b = (TAU * i) / 3600;\n      let h = 0;\n      for (const [k, a, c] of s.harm) h += a * cos(k * b + c);\n      if (h > best) (best = h), (at = b);\n    }\n    s.tr = [at];\n  } else s.tr = [0];\n}\n\n// Support function h and its derivative at body angle b, for a curve mixed\n// a share t of the way to the disc.\nfunction support(s, b, t, out) {\n  let h, d;\n  if (s.n) {\n    const n = s.n, R = WD / (2 * cos(PI / (2 * n))), step = TAU / n, half = PI / (2 * n);\n    let del = b - round(b / step) * step;\n    if (abs(del) \u003c= half) (h = R * cos(del)), (d = -R * sin(del));\n    else {\n      // The opposite direction falls in a corner's cone, so here the curve\n      // is the arc of radius WD round that corner.\n      const b2 = b + PI;\n      del = b2 - round(b2 / step) * step;\n      (h = WD - R * cos(del)), (d = R * sin(del));\n    }\n  } else if (s.harm) {\n    (h = WD / 2), (d = 0);\n    for (const [k, a, c] of s.harm) (h += a * cos(k * b + c)), (d -= a * k * sin(k * b + c));\n  } else (h = WD / 2), (d = 0);\n  out[0] = (1 - t) * h + (t * WD) / 2;\n  out[1] = (1 - t) * d;\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, round: 0, spin: 0.06,\n    // The column's slide in rows and the spin clock in radians.\n    slide: 15, clock: 0,\n    trace: false, traces: new Map(),\n    px: new Float32Array(N), py: new Float32Array(N),\n    xl: new Float32Array(H), xr: new Float32Array(H),\n    lab: new Int8Array(W * H), rgb: new Float32Array(W * H * 3),\n    col: new Float32Array(CYCLE * 6), colHue: NaN, sup: new Float32Array(2),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = k[0];\n  P.speed = cl(k[1], 0.2, 3);\n  P.round = cl(k[2], 0, 1);\n  P.spin = cl(k[3], 0, 1);\n  if (input.btnPressed && input.btnPressed[0]) {\n    P.trace = !P.trace;\n    P.traces.clear();\n  }\n  P.slide += d * P.speed * 3;\n  P.clock += d * (0.4 + 2.6 * P.spin);\n}\n\n// The angle a curve in slot j has turned to: neighbours turn opposite ways,\n// each at a rate between 0.7 and 1.3 times the clock, from a start of its own.\nconst angle = (j, clock) => hash(j * 3 + 1) * TAU + (j & 1 ? -1 : 1) * (0.7 + 0.6 * hash(j * 3 + 2)) * clock;\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const { px, py, xl, xr, lab, rgb, col, sup, traces } = P;\n  if (P.colHue !== P.hue) {\n    // Fill and rim colours for each place in the cycle. The rim is the fill\n    // pushed to full brightness and halfway to white, at least 40 levels\n    // above every fill so it reads as a hard line.\n    // A deep fill from orange round to lime reads as brown or olive, so in\n    // that band the deep curves are lifted toward the light ones' level and\n    // paled a little.\n    for (let c = 0; c \u003c CYCLE; c++) {\n      const h = P.hue + BASE[c][0], hf = h - floor(h), band = BASE[c][1] \u003c 0.7 ? max(0, 1 - abs(hf - 0.14) / 0.15) : 0;\n      hsv(h, 0.8 - 0.22 * band, (BASE[c][1] + 0.3 * band) * 0.94, col, c * 6);\n      hsv(h, 0.45, 1, col, c * 6 + 3);\n    }\n    P.colHue = P.hue;\n  }\n  lab.fill(0);\n  rgb.fill(0);\n  // Slot j's top line sits at row slide - j * WD: the slots stack upward\n  // with j and the column slides down as slide grows.\n  const jLo = floor((P.slide - H) / WD), jHi = ceil(P.slide / WD);\n  const vis = [];\n  for (let j = jLo; j \u003c= jHi; j++) {\n    const top = P.slide - j * WD;\n    if (top >= H || top + WD \u003c= 0) continue;\n    const shape = SHAPES[((j % CYCLE) + CYCLE) % CYCLE], phi = angle(j, P.clock);\n    // Boundary points from the support function, panel direction a = 2 pi i\n    // / N: the point is h u(a) + h' u'(a) with the body angle a - phi. The\n    // panel's y runs down, so i = N/2 faces the left wall and 3N/4 faces up.\n    for (let i = 0; i \u003c N; i++) {\n      const a = (TAU * i) / N, ca = cos(a), sa = sin(a);\n      support(shape, a - phi, P.round, sup);\n      px[i] = sup[0] * ca - sup[1] * sa;\n      py[i] = sup[0] * sa + sup[1] * ca;\n    }\n    // The left support line on the inner face of the left wall, x = 1, and\n    // the top one on the slot's top line. The width is WD in every\n    // direction, so the right one lands on x = 63 and the bottom one on the\n    // next slot's top line without being placed there.\n    const ox = 1 - px[N / 2], oy = top - py[(3 * N) / 4];\n    const label = vis.length + 1;\n    xl.fill(1e9);\n    xr.fill(-1e9);\n    for (let i = 0; i \u003c N; i++) {\n      const xa = px[i] + ox, ya = py[i] + oy, i2 = (i + 1) % N, xb = px[i2] + ox, yb = py[i2] + oy;\n      if (ya === yb) continue;\n      const r0 = max(0, ceil(min(ya, yb) - 0.5)), r1 = min(H - 1, floor(max(ya, yb) - 0.5));\n      for (let r = r0; r \u003c= r1; r++) {\n        const x = xa + ((r + 0.5 - ya) * (xb - xa)) / (yb - ya);\n        if (x \u003c xl[r]) xl[r] = x;\n        if (x > xr[r]) xr[r] = x;\n      }\n    }\n    for (let r = max(0, floor(top)); r \u003c= min(H - 1, ceil(top + WD)); r++) {\n      if (xr[r] \u003c xl[r]) continue;\n      const x0 = max(1, ceil(xl[r] - 0.5)), x1 = min(W - 2, floor(xr[r] - 0.5));\n      for (let x = x0; x \u003c= x1; x++) lab[r * W + x] = label;\n    }\n    vis.push({\n      j, top, c: ((j % CYCLE) + CYCLE) % CYCLE, shape, phi, ox, oy,\n      left: py[N / 2] + oy, right: py[0] + oy, upX: px[(3 * N) / 4] + ox, downX: px[N / 4] + ox,\n    });\n  }\n  // Fill, with a rim wherever a 4-neighbour belongs to something else.\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, l = lab[p];\n      if (!l) continue;\n      const rim = lab[p - 1] !== l || lab[p + 1] !== l || (y > 0 && lab[p - W] !== l) || (y \u003c H - 1 && lab[p + W] !== l);\n      const o = vis[l - 1].c * 6 + (rim ? 3 : 0), q = p * 3;\n      (rgb[q] = col[o]), (rgb[q + 1] = col[o + 1]), (rgb[q + 2] = col[o + 2]);\n    }\n  // The walls: dim slate, brighter where a slot's line meets them, and white\n  // over five rows where a curve touches them.\n  for (let y = 0; y \u003c H; y++)\n    for (const x of [0, W - 1]) {\n      const q = (y * W + x) * 3;\n      (rgb[q] = 0.14), (rgb[q + 1] = 0.18), (rgb[q + 2] = 0.24);\n    }\n  const dot = (x, y, r, g, b) => {\n    if (x \u003c 0 || x >= W || y \u003c 0 || y >= H) return;\n    const q = (y * W + x) * 3;\n    (rgb[q] = r), (rgb[q + 1] = g), (rgb[q + 2] = b);\n  };\n  for (const v of vis) {\n    const ty = floor(v.top);\n    for (const x of [0, W - 1]) dot(x, ty, 0.55, 0.6, 0.7);\n    for (let e = -2; e \u003c= 2; e++) dot(0, floor(v.left) + e, 1, 1, 1), dot(W - 1, floor(v.right) + e, 1, 1, 1);\n    // Above and below: a small white cross where the curve meets the line.\n    for (const [cx, cy] of [[v.upX, v.top], [v.downX, v.top + WD]]) {\n      const x = floor(cx), y = floor(cy - (cy === v.top ? 0 : 1e-3));\n      dot(x, y, 1, 1, 1), dot(x - 1, y, 1, 1, 1), dot(x + 1, y, 1, 1, 1), dot(x, y - 1, 1, 1, 1), dot(x, y + 1, 1, 1, 1);\n    }\n  }\n  // The corner trace, kept in each slot's own square so it slides with it.\n  if (P.trace) {\n    const seen = new Set();\n    for (const v of vis) {\n      seen.add(v.j);\n      let t = traces.get(v.j);\n      if (!t) traces.set(v.j, (t = { xs: [], ys: [], last: null }));\n      const tr = v.shape.tr, m = tr.length, now = [];\n      for (let c = 0; c \u003c m; c++) {\n        // At a peak of the support function h' is 0, so the point is h times\n        // the unit vector there.\n        const a = tr[c] + v.phi;\n        support(v.shape, tr[c], P.round, sup);\n        const ca = cos(a), sa = sin(a);\n        now.push([sup[0] * ca - sup[1] * sa + v.ox, sup[0] * sa + sup[1] * ca + v.oy - v.top]);\n      }\n      if (t.xs.length \u003c 12000)\n        for (let c = 0; c \u003c m; c++) {\n          const [x1, y1] = now[c], [x0, y0] = t.last ? t.last[c] : now[c];\n          const steps = max(1, ceil(sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) / 0.7));\n          for (let s = 1; s \u003c= steps; s++) t.xs.push(x0 + ((x1 - x0) * s) / steps), t.ys.push(y0 + ((y1 - y0) * s) / steps);\n        }\n      t.last = now;\n      for (let i = 0; i \u003c t.xs.length; i++) dot(floor(t.xs[i]), floor(t.ys[i] + v.top), 1, 0.78, 0.25);\n    }\n    for (const j of traces.keys()) if (!seen.has(j)) traces.delete(j);\n  }\n  for (let y = 0, q = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++, q += 3) display.setPixel(x, y, min(255, rgb[q] * 255), min(255, rgb[q + 1] * 255), min(255, rgb[q + 2] * 255));\n}\n","voronoi":"// ===== Patternflow pattern =====\n// Title:   Voronoi\n// Family:  cells\n// Idea:    Seeds swirl in a current and every LED takes the colour of the nearest one, so flat panes of glass jostle behind lead, each with a roundel at its seed that turns from disc to diamond to square as the measure of distance changes.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// Round:   2\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..6, Cells=20..60, Metric=0..2\n//\n// Knob 1: Hue. The colour of most of the glass; a few panes take the colours across the wheel from it.\n// Knob 2: Speed. How fast the current carries the seeds round.\n// Knob 3: Cells. How many panes, from 20 big ones to 60 small ones.\n// Knob 4: Metric. How distance is measured: 0 is a ruler, 1 is city blocks, 2 is a king's moves on a chessboard, and the roundels go disc, diamond, square.\n// Buttons: K1 tap reshuffles the glass colours.\n\nconst W = 64;\nconst H = 128;\nconst MAX = 64;\n// Buckets of 8x8 LEDs, each holding the few seeds that can own one of its LEDs.\nconst B = 8;\nconst BX = W / B;\nconst BY = H / B;\n// Seeds keep this far off the frame, so a roundel is seldom cut in half.\nconst EDGE = 2.5;\n\n// Kinds of glass: hue offset, saturation, brightness, and how often each turns up.\nconst GLASS = [\n  [0.0, 0.95, 0.9, 0.34],\n  [0.0, 0.8, 0.62, 0.2],\n  [-0.1, 0.9, 0.85, 0.16],\n  [0.07, 0.75, 1.0, 0.1],\n  [0.5, 0.95, 1.0, 0.12],\n  [0.38, 0.9, 0.9, 0.08],\n];\n\nfunction hsv(h, s, v, out, o) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[o] = (k === 0 || k === 5 ? v : k === 1 ? q : k === 4 ? t : p) * 255;\n  out[o + 1] = (k === 1 || k === 2 ? v : k === 0 ? t : k === 3 ? q : p) * 255;\n  out[o + 2] = (k === 3 || k === 4 ? v : k === 2 ? t : k === 5 ? q : p) * 255;\n}\n\nfunction pickGlass(p) {\n  for (let i = 0; i \u003c MAX; i++) {\n    let r = Math.random();\n    let g = 0;\n    while (g \u003c GLASS.length - 1 && r > GLASS[g][3]) {\n      r -= GLASS[g][3];\n      g++;\n    }\n    p.kind[i] = g;\n    p.jitter[i] = (Math.random() - 0.5) * 0.05;\n  }\n  p.hue = -1;\n}\n\n// The current is a stream function made of four box modes, (1,2), (1,3),\n// (2,3) and (1,1), whose strengths rise and fall out of step. A stream\n// function cannot pile seeds up, and a box mode never flows through a wall,\n// so the seeds stay spread out and on the panel; the mix keeps the vortices\n// moving. Each mode is scaled so its fastest point moves at about one unit.\nfunction flow(amp, x, y, out) {\n  const px = Math.PI / W;\n  const py = Math.PI / H;\n  const s1x = Math.sin(px * x), c1x = Math.cos(px * x);\n  const s2x = Math.sin(2 * px * x), c2x = Math.cos(2 * px * x);\n  const s1y = Math.sin(py * y), c1y = Math.cos(py * y);\n  const s2y = Math.sin(2 * py * y), c2y = Math.cos(2 * py * y);\n  const s3y = Math.sin(3 * py * y), c3y = Math.cos(3 * py * y);\n  out[0] = amp[0] * 0.71 * s1x * c2y + amp[1] * 0.83 * s1x * c3y + amp[2] * 0.6 * s2x * c3y + amp[3] * 0.45 * s1x * c1y;\n  out[1] = -amp[0] * 0.71 * c1x * s2y - amp[1] * 0.55 * c1x * s3y - amp[2] * 0.8 * c2x * s3y - amp[3] * 0.9 * c1x * s1y;\n}\n\n// Push seeds apart where they crowd, so the panes stay roughly one size.\nfunction spread(p, n, strength) {\n  const reach = 0.95 * Math.sqrt((W * H) / n);\n  const sx = p.sx;\n  const sy = p.sy;\n  for (let i = 0; i \u003c n; i++) {\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = sx[j] - sx[i];\n      const dy = sy[j] - sy[i];\n      const d2 = dx * dx + dy * dy;\n      if (d2 >= reach * reach || d2 \u003c 1e-6) continue;\n      const d = Math.sqrt(d2);\n      const push = ((reach - d) / d) * strength * 0.5;\n      sx[i] -= dx * push;\n      sy[i] -= dy * push;\n      sx[j] += dx * push;\n      sy[j] += dy * push;\n    }\n  }\n  for (let i = 0; i \u003c n; i++) {\n    sx[i] = Math.min(W - EDGE, Math.max(EDGE, sx[i]));\n    sy[i] = Math.min(H - EDGE, Math.max(EDGE, sy[i]));\n  }\n}\n\nexport function setup(params) {\n  const p = params;\n  p.sx = new Float32Array(MAX);\n  p.sy = new Float32Array(MAX);\n  for (let i = 0; i \u003c MAX; i++) {\n    p.sx[i] = Math.random() * W;\n    p.sy[i] = Math.random() * H;\n  }\n  p.kind = new Uint8Array(MAX);\n  p.jitter = new Float32Array(MAX);\n  p.rgb = new Uint8Array(MAX * 3);\n  p.pale = new Uint8Array(MAX * 3);\n  p.jewel = new Float32Array(MAX);\n  p.tmp = new Float32Array(3);\n  p.owner = new Uint8Array(W * H);\n  p.cand = new Uint8Array(BX * BY * MAX);\n  p.count = new Uint8Array(BX * BY);\n  p.T = 0;\n  p.amp = new Float32Array(4);\n  p.vel = new Float32Array(2);\n  p.settled = false;\n  pickGlass(p);\n}\n\nexport function update(dt, input, params) {\n  const p = params;\n  const k = input.knobValues || [0, 2, 20, 0.06];\n  const n = Math.max(2, Math.min(MAX, Math.round(k[2])));\n  p.n = n;\n  if (!p.settled) {\n    // Relax the random scatter before the first frame, so it opens on even\n    // panes: all the seeds first, for when K3 turns up, then the ones in use.\n    for (let s = 0; s \u003c 30; s++) spread(p, MAX, 0.5);\n    for (let s = 0; s \u003c 30; s++) spread(p, n, 0.5);\n    p.settled = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) pickGlass(p);\n\n  const speed = k[1];\n  p.T += dt * speed * 0.16;\n  const T = p.T;\n  const amp = p.amp;\n  amp[0] = Math.cos(T * 1.0);\n  amp[1] = Math.cos(T * 0.71 + 1.3) * 0.9;\n  amp[2] = Math.cos(T * 1.37 + 2.1) * 0.6;\n  amp[3] = Math.cos(T * 0.53 + 4.0) * 0.8;\n  // A plain Euler step spirals outward round every vortex and, fast enough,\n  // packs the seeds against the walls. A midpoint step does not.\n  const step = 15.6 * speed * dt;\n  const vel = p.vel;\n  for (let i = 0; i \u003c MAX; i++) {\n    const x = p.sx[i];\n    const y = p.sy[i];\n    flow(amp, x, y, vel);\n    flow(amp, x + vel[0] * step * 0.5, y + vel[1] * step * 0.5, vel);\n    p.sx[i] = Math.min(W - EDGE, Math.max(EDGE, x + vel[0] * step));\n    p.sy[i] = Math.min(H - EDGE, Math.max(EDGE, y + vel[1] * step));\n  }\n  // A fast current shears the panes apart faster, so the push keeps pace.\n  spread(p, n, Math.min(0.35, 0.05 + 0.04 * speed));\n\n  // K4 0..1 blends a ruler into city blocks, 1..2 city blocks into king's moves.\n  const m = Math.max(0, Math.min(2, k[3]));\n  p.we = m \u003c 1 ? 1 - m : 0;\n  p.wm = m \u003c 1 ? m : 2 - m;\n  p.wc = m \u003c 1 ? 0 : m - 1;\n\n  if (k[0] !== p.hue) {\n    p.hue = k[0];\n    // K1 at 0 opens on cobalt rather than the red most of the study opens on.\n    const base = 0.6 + k[0];\n    for (let i = 0; i \u003c MAX; i++) {\n      const g = GLASS[p.kind[i]];\n      let h = base + g[0] + p.jitter[i];\n      h -= Math.floor(h);\n      // Dim orange glass reads as brown on the panel, so warm panes stay bright.\n      const warm = h > 0.02 && h \u003c 0.2;\n      hsv(h, g[1], warm ? Math.max(0.92, g[2]) : g[2], p.tmp, 0);\n      p.rgb[i * 3] = p.tmp[0];\n      p.rgb[i * 3 + 1] = p.tmp[1];\n      p.rgb[i * 3 + 2] = p.tmp[2];\n      // The roundel at the heart of each pane is a thinner, paler glass.\n      hsv(h, g[1] * 0.45, 1, p.tmp, 0);\n      p.pale[i * 3] = p.tmp[0];\n      p.pale[i * 3 + 1] = p.tmp[1];\n      p.pale[i * 3 + 2] = p.tmp[2];\n    }\n  }\n}\n\nexport function draw(display, params, time) {\n  const p = params;\n  const n = p.n;\n  const sx = p.sx;\n  const sy = p.sy;\n  const we = p.we;\n  const wm = p.wm;\n  const wc = p.wc;\n  const cand = p.cand;\n  const count = p.count;\n  const owner = p.owner;\n\n  // Each pane has a roundel round its seed, drawn in the same measure, so it\n  // is a disc, a diamond or a square. Under a third of the way to the nearest\n  // other seed it can never cross into the next pane.\n  const jewel = p.jewel;\n  for (let i = 0; i \u003c n; i++) jewel[i] = 1e9;\n  for (let i = 0; i \u003c n; i++) {\n    for (let j = i + 1; j \u003c n; j++) {\n      const dx = sx[j] - sx[i];\n      const dy = sy[j] - sy[i];\n      const ax = dx \u003c 0 ? -dx : dx;\n      const ay = dy \u003c 0 ? -dy : dy;\n      const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n      if (d \u003c jewel[i]) jewel[i] = d;\n      if (d \u003c jewel[j]) jewel[j] = d;\n    }\n  }\n  // A roundel under about two LEDs across would be all lead, a dark speck.\n  for (let i = 0; i \u003c n; i++) jewel[i] = jewel[i] * 0.3 \u003c 2.2 ? 0 : jewel[i] * 0.3;\n\n  // Any seed that owns an LED in a bucket is within the nearest seed's\n  // distance from the bucket centre plus twice the centre-to-corner distance.\n  // That holds for all three measures and for any blend of them.\n  const reachCorner = we * Math.SQRT2 * 3.5 + wm * 7 + wc * 3.5;\n  for (let by = 0; by \u003c BY; by++) {\n    for (let bx = 0; bx \u003c BX; bx++) {\n      const cx = bx * B + B / 2;\n      const cy = by * B + B / 2;\n      let best = 1e9;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = sx[i] - cx;\n        const dy = sy[i] - cy;\n        const ax = dx \u003c 0 ? -dx : dx;\n        const ay = dy \u003c 0 ? -dy : dy;\n        const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n        if (d \u003c best) best = d;\n      }\n      const limit = best + 2 * reachCorner + 0.01;\n      const b = by * BX + bx;\n      let c = 0;\n      for (let i = 0; i \u003c n; i++) {\n        const dx = sx[i] - cx;\n        const dy = sy[i] - cy;\n        const ax = dx \u003c 0 ? -dx : dx;\n        const ay = dy \u003c 0 ? -dy : dy;\n        const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n        if (d \u003c= limit) cand[b * MAX + c++] = i;\n      }\n      count[b] = c;\n    }\n  }\n\n  for (let y = 0; y \u003c H; y++) {\n    const row = ((y / B) | 0) * BX;\n    const py = y + 0.5;\n    for (let x = 0; x \u003c W; x++) {\n      const b = row + ((x / B) | 0);\n      const c = count[b];\n      const base = b * MAX;\n      const px = x + 0.5;\n      let best = 1e9;\n      let who = 0;\n      for (let j = 0; j \u003c c; j++) {\n        const i = cand[base + j];\n        const dx = sx[i] - px;\n        const dy = sy[i] - py;\n        const ax = dx \u003c 0 ? -dx : dx;\n        const ay = dy \u003c 0 ? -dy : dy;\n        const d = we * Math.sqrt(dx * dx + dy * dy) + wm * (ax + ay) + wc * (ax > ay ? ax : ay);\n        if (d \u003c best) {\n          best = d;\n          who = i;\n        }\n      }\n      // Which piece of glass: the seed's number doubled, plus one inside its roundel.\n      owner[y * W + x] = who * 2 + (best \u003c jewel[who] ? 1 : 0);\n    }\n  }\n\n  // Lead goes on an LED whose right or lower neighbour belongs to another\n  // piece of glass, which draws one unbroken line between any two pieces\n  // whatever the measure.\n  const rgb = p.rgb;\n  const pale = p.pale;\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const o = y * W + x;\n      const id = owner[o];\n      const lead = (x \u003c W - 1 && owner[o + 1] !== id) || (y \u003c H - 1 && owner[o + W] !== id);\n      const c = (id >> 1) * 3;\n      if (lead) display.setPixel(x, y, 0, 0, 0);\n      else if (id & 1) display.setPixel(x, y, pale[c], pale[c + 1], pale[c + 2]);\n      else display.setPixel(x, y, rgb[c], rgb[c + 1], rgb[c + 2]);\n    }\n  }\n}\n","pentomino-cover":"// ===== Patternflow pattern =====\n// Title:   Pentomino Cover\n// Family:  algo\n// Idea:    A rectangle of sixty cells stands on the panel and Knuth's dancing links fill it with the twelve pentominoes as an exact cover, always placing a piece on the cell with the fewest choices left and taking pieces back out as it backs up, so the board flickers with pieces dropping in and leaving their outlines as they go, and each full cover holds for two seconds under a sweep of light and adds a tick below the board.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Dancing Links and Algorithm X (Donald Knuth, 2000) on Solomon Golomb's pentominoes (1953), pattern round 34\n// Round:   34\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Board=0..3, Shuffle=0..1\n//\n// Knob 1: Hue. Turns the twelve piece colours, 30 degrees apart, together round the wheel. At 0 the F is sky blue, the I blue, the X green and the U red-orange; at 0.5 each piece takes the colour the piece six letters on had.\n// Knob 2: Speed. Steps of the search a second, one step being a column chosen, a row tried or a step back: 5 at 0.2, where each piece can be followed in and out; 394 at 2, where the 6 by 10 search averages 1532 steps, about 4 seconds, from one cover to the next; 4457 at 3.\n// Knob 3: Board. 0 is 6 by 10 cells of 10 LEDs, with 2339 covers; 1 is 5 by 12 of 10 LEDs, 1010 covers; 2 is 4 by 15 of 8 LEDs, 368 covers; 3 is 3 by 20 of 6 LEDs, where the whole search, 33,545 steps, finds only 2 covers before it starts again. Covers are counted once for each set of rotations and mirror images.\n// Knob 4: Shuffle. How far the rows are shuffled when a search starts: at 0 every column tries its placements in the fixed order F to Z, top left first; at 0.06 a row moves by up to 12% of the list; at 1 the order is random and the same board gives other covers first. Turning it by more than 0.04 starts a new search.\n// Buttons: K1 tap starts a new search in a new shuffled order.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, round, abs, pow, exp, random } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The twelve pentominoes, F I L N P T U V W X Y Z.\nconst PIECES = [\n  [[1, 0], [2, 0], [0, 1], [1, 1], [1, 2]],\n  [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]],\n  [[0, 0], [0, 1], [1, 1], [2, 1], [3, 1]],\n  [[0, 0], [1, 0], [1, 1], [2, 1], [3, 1]],\n  [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2]],\n  [[0, 0], [1, 0], [2, 0], [1, 1], [1, 2]],\n  [[0, 0], [2, 0], [0, 1], [1, 1], [2, 1]],\n  [[0, 0], [0, 1], [0, 2], [1, 2], [2, 2]],\n  [[0, 0], [0, 1], [1, 1], [1, 2], [2, 2]],\n  [[1, 0], [0, 1], [1, 1], [2, 1], [1, 2]],\n  [[1, 0], [0, 1], [1, 1], [2, 1], [3, 1]],\n  [[0, 0], [1, 0], [1, 1], [1, 2], [2, 2]],\n];\nconst P_ = 4, X_ = 9;\n// Boards, columns by rows, and the LEDs a cell takes.\nconst BOARDS = [[6, 10, 10], [5, 12, 10], [4, 15, 8], [3, 20, 6]];\n\n// Every distinct orientation of a piece: the four turns first, then the\n// four turns of its mirror image, so flip marks the mirrored ones.\nfunction orientations(cells) {\n  const out = [], seen = new Set();\n  for (let f = 0; f \u003c 2; f++)\n    for (let q = 0; q \u003c 4; q++) {\n      let c = cells.map(([x, y]) => (f ? [-x, y] : [x, y]));\n      for (let k = 0; k \u003c q; k++) c = c.map(([x, y]) => [-y, x]);\n      const mx = min(...c.map((p) => p[0])), my = min(...c.map((p) => p[1]));\n      c = c.map(([x, y]) => [x - mx, y - my]).sort((a, b) => a[1] - b[1] || a[0] - b[0]);\n      const key = c.join(\";\");\n      if (!seen.has(key)) seen.add(key), out.push({ cells: c, flip: f });\n    }\n  return out;\n}\nconst ORIENT = PIECES.map(orientations);\n\n// The exact cover matrix: one column per piece, one per cell, and one\n// secondary column that keeps the count to solutions up to symmetry. The X\n// may only sit in the board's first quarter; when it sits on a mirror line\n// of the board the P may not be mirrored, and the secondary column holds\n// those two choices apart.\nfunction placements(bw, bh) {\n  const rows = [];\n  PIECES.forEach((_, pi) => {\n    for (const o of ORIENT[pi]) {\n      const ow = max(...o.cells.map((p) => p[0])) + 1, oh = max(...o.cells.map((p) => p[1])) + 1;\n      for (let y = 0; y + oh \u003c= bh; y++)\n        for (let x = 0; x + ow \u003c= bw; x++) {\n          let sec = pi === P_ && o.flip === 1;\n          if (pi === X_) {\n            const cx = x + 1, cy = y + 1;\n            if (2 * cx > bw - 1 || 2 * cy > bh - 1) continue;\n            sec = (bw % 2 === 1 && 2 * cx === bw - 1) || (bh % 2 === 1 && 2 * cy === bh - 1);\n          }\n          rows.push({ piece: pi, cells: o.cells.map(([a, b]) => (y + b) * bw + x + a), sec });\n        }\n    }\n  });\n  return rows;\n}\n\nconst MAXN = 16000;\nfunction newSearch(S, again) {\n  const [bw, bh] = BOARDS[S.board];\n  const rows = placements(bw, bh);\n  // Shuffle moves each row by up to twice that share of the list. A search\n  // started again keeps the order it had.\n  if (!again) S.jit = rows.map(() => random());\n  const key = rows.map((_, i) => i / rows.length + 2 * S.shuffle * S.jit[i]);\n  const order = rows.map((_, i) => i).sort((a, b) => key[a] - key[b]);\n  const NC = 12 + bw * bh, SEC = NC + 1;\n  const { L, R, U, D, C, RW, SZ } = S;\n  for (let c = 0; c \u003c= NC; c++) (L[c] = c - 1), (R[c] = c + 1), (U[c] = D[c] = C[c] = c), (SZ[c] = 0);\n  L[0] = NC;\n  R[NC] = 0;\n  L[SEC] = R[SEC] = U[SEC] = D[SEC] = C[SEC] = SEC;\n  let k = SEC + 1;\n  S.rows = order.map((i) => rows[i]);\n  S.rows.forEach((r, ri) => {\n    const cols = [1 + r.piece, ...r.cells.map((c) => 13 + c)];\n    if (r.sec) cols.push(SEC);\n    const first = k;\n    for (const c of cols) {\n      C[k] = c;\n      RW[k] = ri;\n      U[k] = U[c];\n      D[k] = c;\n      D[U[c]] = k;\n      U[c] = k;\n      SZ[c]++;\n      L[k] = k - 1;\n      R[k] = k + 1;\n      k++;\n    }\n    L[first] = k - 1;\n    R[k - 1] = first;\n  });\n  S.bw = bw;\n  S.bh = bh;\n  S.cs = BOARDS[S.board][2];\n  S.k = 0;\n  S.mode = 0;\n  S.done = false;\n  S.found = 0;\n  S.hold = 0;\n  S.cell.fill(-1);\n  S.age.fill(9);\n  S.ghost.fill(-1);\n  S.gAge.fill(9);\n  S.builtBoard = S.board;\n  S.builtShuffle = S.shuffle;\n}\n\nfunction cover(S, c) {\n  const { L, R, U, D, C, SZ } = S;\n  L[R[c]] = L[c];\n  R[L[c]] = R[c];\n  for (let i = D[c]; i !== c; i = D[i])\n    for (let j = R[i]; j !== i; j = R[j]) (U[D[j]] = U[j]), (D[U[j]] = D[j]), SZ[C[j]]--;\n}\nfunction uncover(S, c) {\n  const { L, R, U, D, C, SZ } = S;\n  for (let i = U[c]; i !== c; i = U[i])\n    for (let j = L[i]; j !== i; j = L[j]) SZ[C[j]]++, (U[D[j]] = j), (D[U[j]] = j);\n  L[R[c]] = c;\n  R[L[c]] = c;\n}\nfunction place(S, node, on) {\n  const r = S.rows[S.RW[node]];\n  for (const c of r.cells) {\n    if (on) (S.cell[c] = r.piece), (S.age[c] = 0);\n    else (S.ghost[c] = S.cell[c]), (S.gAge[c] = 0), (S.cell[c] = -1);\n  }\n}\n\n// Algorithm X, one node of the search tree a call: enter a level and cover\n// the column with the fewest rows left, try its next row, or step back.\n// Returns true when the board is full.\nfunction searchStep(S) {\n  const { L, R, D, C, SZ, col, row } = S;\n  if (S.mode === 0) {\n    if (R[0] === 0) {\n      S.mode = 2;\n      return true;\n    }\n    let c = R[0], best = 1e9;\n    for (let j = R[0]; j !== 0; j = R[j]) if (SZ[j] \u003c best) (best = SZ[j]), (c = j);\n    cover(S, c);\n    col[S.k] = c;\n    row[S.k] = D[c];\n    S.mode = 1;\n  } else if (S.mode === 1) {\n    const r = row[S.k];\n    if (r === col[S.k]) {\n      uncover(S, col[S.k]);\n      S.mode = 2;\n      return false;\n    }\n    for (let j = R[r]; j !== r; j = R[j]) cover(S, C[j]);\n    place(S, r, true);\n    S.k++;\n    S.mode = 0;\n  } else {\n    if (S.k === 0) {\n      S.done = true;\n      return false;\n    }\n    S.k--;\n    const r = row[S.k];\n    place(S, r, false);\n    for (let j = L[r]; j !== r; j = L[j]) uncover(S, C[j]);\n    row[S.k] = D[r];\n    S.mode = 1;\n  }\n  return false;\n}\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const rgb = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i];\n  out[0] = rgb[0];\n  out[1] = rgb[1];\n  out[2] = rgb[2];\n}\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, board: 0, shuffle: 0.06, warm: false, acc: 0, sweep: 0,\n    L: new Int32Array(MAXN), R: new Int32Array(MAXN), U: new Int32Array(MAXN), D: new Int32Array(MAXN),\n    C: new Int32Array(MAXN), RW: new Int32Array(MAXN), SZ: new Int32Array(80), col: new Int32Array(16), row: new Int32Array(16),\n    cell: new Int8Array(60), age: new Float32Array(60), ghost: new Int8Array(60), gAge: new Float32Array(60),\n    key: new Int8Array(60), pc: new Int8Array(N), c: [0, 0, 0],\n  };\n}\n\n// A full cover holds for HOLD seconds; the search takes rate(Speed) steps a\n// second.\nconst HOLD = 2;\nconst rate = (sp) => 5 * pow(2, 3.5 * (sp - 0.2));\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.board = cl(round(k[2]), 0, 3);\n  S.shuffle = cl(k[3], 0, 1);\n  const pressed = input.btnPressed && input.btnPressed[0];\n  if (!S.warm || pressed || S.board !== S.builtBoard || abs(S.shuffle - S.builtShuffle) > 0.04) {\n    newSearch(S);\n    if (!S.warm) {\n      // Open about 1100 steps short of the first full board, so at Speed 2\n      // the first solution comes near 2.8 s.\n      let n = 0;\n      while (!searchStep(S) && !S.done) n++;\n      newSearch(S, true);\n      for (let i = 0; i \u003c n - 1100; i++) searchStep(S);\n      S.age.fill(9);\n      S.ghost.fill(-1);\n      S.warm = true;\n    }\n  }\n  for (let c = 0; c \u003c 60; c++) (S.age[c] += d), (S.gAge[c] += d);\n  if (S.hold > 0) {\n    S.hold = max(0, S.hold - d);\n    S.sweep += d / HOLD;\n    return;\n  }\n  if (S.done) {\n    newSearch(S);\n    return;\n  }\n  S.acc += d * rate(S.speed);\n  while (S.acc >= 1) {\n    S.acc--;\n    if (searchStep(S)) {\n      S.found++;\n      S.hold = HOLD;\n      S.sweep = 0;\n      S.acc = 0;\n      break;\n    }\n    if (S.done) break;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { bw, bh, cs, cell, age, ghost, gAge, key, pc, c } = S, base = S.hue + 0.55;\n  const BW = bw * cs + 1, BH = bh * cs + 1, ox = floor((W - BW) / 2), oy = floor((H - BH) / 2);\n  for (let p = 0; p \u003c N; p++) display.setPixel(p % W, (p / W) | 0, 0, 0, 0);\n  // Each cell shows its piece, or for 0.18 s after the search takes a\n  // piece out, that piece's outline fading.\n  for (let i = 0; i \u003c bw * bh; i++) key[i] = cell[i] >= 0 ? cell[i] : ghost[i] >= 0 && gAge[i] \u003c 0.18 ? 12 + ghost[i] : -1;\n  const at = (x, y) => (x \u003c 0 || y \u003c 0 || x >= bw || y >= bh ? -2 : key[y * bw + x]);\n  // A cell's own LEDs show its piece, a grid line between two cells of one\n  // piece that piece, any other grid line the dark seam.\n  pc.fill(-1);\n  for (let Y = 0; Y \u003c BH; Y++)\n    for (let X = 0; X \u003c BW; X++) {\n      const gx = X % cs === 0, gy = Y % cs === 0, cx = floor(X / cs), cy = floor(Y / cs);\n      let q;\n      if (!gx && !gy) q = at(cx, cy);\n      else if (gx && !gy) q = at(cx - 1, cy) === at(cx, cy) ? at(cx, cy) : -1;\n      else if (!gx && gy) q = at(cx, cy - 1) === at(cx, cy) ? at(cx, cy) : -1;\n      else {\n        const a = at(cx - 1, cy - 1);\n        q = a === at(cx, cy - 1) && a === at(cx - 1, cy) && a === at(cx, cy) ? a : -1;\n      }\n      pc[(oy + Y) * W + ox + X] = q;\n    }\n  // A light sweeps across the board while a solution holds.\n  const band = S.hold > 0 ? -0.25 + 1.5 * cl(S.sweep, 0, 1) : -9;\n  for (let Y = 0; Y \u003c BH; Y++)\n    for (let X = 0; X \u003c BW; X++) {\n      const p = (oy + Y) * W + ox + X, q = pc[p];\n      const cx = min(bw - 1, floor(X / cs)), cy = min(bh - 1, floor(Y / cs)), ci = cy * bw + cx;\n      const g = (X / BW + Y / BH) / 2 - band, lit = S.hold > 0 ? exp(-g * g * 90) : 0;\n      if (q >= 0 && q \u003c 12) {\n        // A slight bevel: lighter next to a seam above or to the left,\n        // darker next to one below or to the right.\n        const up = pc[p - W] \u003c 0 || pc[p - W] >= 12, lf = pc[p - 1] \u003c 0 || pc[p - 1] >= 12;\n        const dn = pc[p + W] \u003c 0 || pc[p + W] >= 12, rt = pc[p + 1] \u003c 0 || pc[p + 1] >= 12;\n        const fresh = cl(1 - age[ci] / 0.15, 0, 1);\n        const v = min(1, 0.82 + (up || lf ? 0.18 : 0) - (dn || rt ? 0.2 : 0) + 0.15 * fresh + 0.3 * lit);\n        hsv(base + q / 12, (0.72 - 0.3 * fresh) * (1 - 0.7 * lit), 1, c);\n        display.setPixel(ox + X, oy + Y, round(c[0] * 255 * v), round(c[1] * 255 * v), round(c[2] * 255 * v));\n      } else if (q >= 12) {\n        // A piece just taken out leaves its outline for a moment.\n        if (pc[p - W] === q && pc[p + W] === q && pc[p - 1] === q && pc[p + 1] === q) continue;\n        const f = cl(1 - gAge[ci] / 0.18, 0, 1);\n        hsv(base + (q - 12) / 12, 0.6, 1, c);\n        display.setPixel(ox + X, oy + Y, round(c[0] * 150 * f), round(c[1] * 150 * f), round(c[2] * 150 * f));\n      } else if (X === 0 || Y === 0 || X === BW - 1 || Y === BH - 1) display.setPixel(ox + X, oy + Y, 44, 44, 54);\n      else if (X % cs === 0 && Y % cs === 0) display.setPixel(ox + X, oy + Y, 40, 40, 48);\n    }\n  // One tick under the board for each solution this search has found, 31\n  // to a row; a full row turns dim and the next starts over it.\n  const ty = oy + BH + (oy > 6 ? 2 : 0), full = floor(S.found / 31), part = S.found % 31;\n  for (let i = 0; i \u003c 31; i++) {\n    const on = i \u003c part, x = 1 + 2 * i;\n    if (!on && full === 0) continue;\n    hsv(base + 0.1 * (on ? full : full - 1), on ? 0.25 : 0.5, 1, c);\n    const v = on ? (i === part - 1 && S.hold > 0 ? 255 : 190) : 70;\n    for (let y = ty; y \u003c min(H, ty + 2); y++) display.setPixel(x, y, round(c[0] * v), round(c[1] * v), round(c[2] * v));\n  }\n}\n","moire-rings":"// ===== Patternflow pattern =====\n// Title:   Moire Rings\n// Family:  wave\n// Idea:    Two sets of rings slide past each other, and where they disagree the panel draws a third shape nobody drew.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.1..6, Rings=5..16, Spread=-1..1\n//\n// Knob 1: Hue. Turns the two-colour pair around the colour wheel.\n// Knob 2: Speed. How fast the two centres orbit.\n// Knob 3: Rings. Ring spacing in LEDs; small is a fine moire, large is a few fat bands.\n// Knob 4: Spread. How far apart the two centres travel, and below 0 the second one turns the other way.\n// Buttons: K1 tap swaps which set of rings is drawn bright.\n\nfunction hsv(h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  const r = k === 0 ? v : k === 1 ? q : k === 2 ? p : k === 3 ? p : k === 4 ? t : v;\n  const g = k === 0 ? t : k === 1 ? v : k === 2 ? v : k === 3 ? q : k === 4 ? p : p;\n  const b = k === 0 ? p : k === 1 ? p : k === 2 ? t : k === 3 ? v : k === 4 ? v : q;\n  return [r * 255, g * 255, b * 255];\n}\n\nexport function setup(params) {\n  params.phase = 0;\n  params.swap = false;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  // K1 at 0 opens on cyan rather than the red most of the study opens on.\n  params.hue = k[0] + 0.52;\n  params.speed = k[1];\n  params.spacing = k[2];\n  params.spread = k[3];\n  params.phase += dt * params.speed * 0.35;\n  if (input.btnPressed && input.btnPressed[0]) params.swap = !params.swap;\n}\n\nexport function draw(display, params, time) {\n  const w = display.width;\n  const h = display.height;\n  const reach = 0.15 + Math.abs(params.spread) * 0.85;\n  // Below 0 the second centre runs the other way round.\n  const dir = params.spread \u003c 0 ? -1 : 1;\n  const ax = w / 2 + Math.cos(params.phase) * w * 0.3 * reach;\n  const ay = h / 2 + Math.sin(params.phase * 1.3) * h * 0.35 * reach;\n  const bx = w / 2 - Math.cos(params.phase * 0.8) * w * 0.3 * reach;\n  const by = h / 2 - Math.sin(params.phase * 1.1) * h * 0.35 * reach * dir;\n  const s = params.spacing;\n  const a = hsv(params.hue, 0.85, 1);\n  const b = hsv(params.hue + 0.5, 0.7, 1);\n  const front = params.swap ? b : a;\n  const back = params.swap ? a : b;\n  for (let y = 0; y \u003c h; y++) {\n    for (let x = 0; x \u003c w; x++) {\n      const da = Math.hypot(x - ax, y - ay) / s;\n      const db = Math.hypot(x - bx, y - by) / s;\n      const ra = da - Math.floor(da) \u003c 0.5 ? 1 : 0;\n      const rb = db - Math.floor(db) \u003c 0.5 ? 1 : 0;\n      if (ra && rb) display.setPixel(x, y, front[0], front[1], front[2]);\n      else if (ra !== rb) display.setPixel(x, y, back[0] * 0.18, back[1] * 0.18, back[2] * 0.18);\n      else display.setPixel(x, y, 0, 0, 0);\n    }\n  }\n}\n","kuramoto-sivashinsky":"// ===== Patternflow pattern =====\n// Title:   Kuramoto-Sivashinsky\n// Family:  noise\n// Idea:    The Kuramoto-Sivashinsky equation u_t + u u_x + u_xx + u_xxxx = 0 runs on a ring as wide as the panel, one grid point per column, and each new moment of u enters at the top and scrolls down, so the 128 rows are its space-time diagram: cyan streaks where u is positive and magenta where it is negative wobble, split and merge in a chaotic braid, black where u crosses zero.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kuramoto-Sivashinsky equation (Yoshiki Kuramoto, 1976; Gregory Sivashinsky, 1977), pattern round 37\n// Round:   37\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Length=22..66, Dispersion=-1..1\n//\n// Knob 1: Hue. Turns both sides of the colour map round the wheel together. At 0 positive u is cyan and negative u magenta, black where u crosses zero and pale where |u| passes 2.6; at 0.3 gold and violet, at 0.6 orange and teal.\n// Knob 2: Speed. Rows a second, 15 times the knob, and each row is 1.25 time units of the equation, so the panel always holds the last 160 time units. At 2 that is one row a frame and a moment takes 4.3 s from top to bottom; at 0.2 it takes 43 s.\n// Knob 3: Length. The length L of the ring, 22 to 66. L / 2 pi is the number of linearly unstable modes, 3.5 at 22 and 10.5 at 66. At 22, the size Predrag Cvitanovic and his group studied, two fat cyan streaks wobble in step and now and then slip sideways all at once; at 66 about seven thin ones split and merge.\n// Knob 4: Dispersion. A third-derivative term delta u_xxx, which makes it the Kawahara equation. At the start, 0.06, it is still Kuramoto-Sivashinsky; from about 0.15 at L 22 and 0.25 at L 66 the chaos settles into a train of pulses that lean one way across the diagram, right and cyan for positive delta, left and magenta for negative.\n// Buttons: K1 tap dents the front at a random place: u gets a dipole of plus and minus 4 there, its two halves run apart, as u above zero travels right and u below it left, and they leave a calm patch in the braid that the streaks fill in again over 1 to 3 s.\n\n// The solver is ETDRK4, the exponential time-differencing Runge-Kutta\n// scheme of Steven Cox and Paul Matthews (2002), with the coefficients\n// taken as means round a circle in the complex plane, the way Aly-Khan\n// Kassam and Lloyd Trefethen (2005) do it, so they hold for every mode from\n// the growing ones to the most damped. In Fourier space\n//   v_t = (k^2 - k^4 + i delta k^3) v - (i k / 2) FFT(u^2),\n// the linear part solved exactly and only u^2 stepped, 0.25 time units a\n// step, five steps a row, 40 FFTs of size 64 a frame at Speed 2. At 0.4\n// time units a row the streaks hardly bent in 128 rows; at 1.25 they braid.\n//\n// Checked over 10,000 time units from the same start at delta 0:\n// - The energy, the mean of u^2, stays bounded: it averages 1.41 at L 22\n//   and 1.71 at L 66, and never passes 3.13.\n// - The fastest-growing wavelength is 2 pi sqrt 2, so a ring of length L\n//   should hold about L / 8.89 cells. Counting the positive humps of u\n//   (with a 0.4 dead band) gives 2.26 at L 22 against 2.48, 3.66 at 36\n//   against 4.05, 5.34 at 50 against 5.63 and 6.89 at 66 against 7.43:\n//   always 91 to 93 percent of it.\n// - 64 grid points resolve the ring up to L 66, where the highest mode\n//   never carries more than 0.65 percent of the largest. At L 100 it\n//   reached 21 percent, so the knob stops at 66.\nconst W = 64, H = 128, N = 64, STEP = 0.25, ROW = 1.25, RATE = 15, MC = 32, PRERUN = 100;\nconst { floor, exp, cos, sin, abs, round, random, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// A complex FFT of size 64: bit reversal, then six rounds of butterflies.\nconst BR = new Uint8Array(N), CS = new Float64Array(N / 2), SN = new Float64Array(N / 2);\nfor (let i = 0; i \u003c N; i++) {\n  let r = 0;\n  for (let b = 0, v = i; b \u003c 6; b++, v >>= 1) r = (r \u003c\u003c 1) | (v & 1);\n  BR[i] = r;\n}\nfor (let k = 0; k \u003c N / 2; k++) (CS[k] = cos((TAU * k) / N)), (SN[k] = sin((TAU * k) / N));\n\nfunction fft(re, im, sign) {\n  for (let i = 0; i \u003c N; i++) {\n    const j = BR[i];\n    if (j > i) {\n      let t = re[i];\n      re[i] = re[j];\n      re[j] = t;\n      t = im[i];\n      im[i] = im[j];\n      im[j] = t;\n    }\n  }\n  for (let size = 2; size \u003c= N; size \u003c\u003c= 1) {\n    const half = size >> 1, step = N / size;\n    for (let i = 0; i \u003c N; i += size)\n      for (let k = 0; k \u003c half; k++) {\n        const wr = CS[k * step], wi = sign * SN[k * step], a = i + k, b = a + half;\n        const tr = re[b] * wr - im[b] * wi, ti = re[b] * wi + im[b] * wr;\n        re[b] = re[a] - tr;\n        im[b] = im[a] - ti;\n        re[a] += tr;\n        im[a] += ti;\n      }\n  }\n}\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = 255 * (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p);\n  out[o + 1] = 255 * (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p);\n  out[o + 2] = 255 * (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p);\n}\n\nconst f64 = () => new Float64Array(N);\n\nexport function setup(params) {\n  params.s = {\n    ready: false, hue: -1, speed: 2, L: -1, delta: NaN, acc: 0, head: 0,\n    vr: f64(), vi: f64(), g: f64(),\n    Er: f64(), Ei: f64(), E2r: f64(), E2i: f64(), Qr: f64(), Qi: f64(),\n    f1r: f64(), f1i: f64(), f2r: f64(), f2i: f64(), f3r: f64(), f3i: f64(),\n    ar: f64(), ai: f64(), br: f64(), bi: f64(), cr: f64(), ci: f64(),\n    Nvr: f64(), Nvi: f64(), Nar: f64(), Nai: f64(), Nbr: f64(), Nbi: f64(), Ncr: f64(), Nci: f64(),\n    tr: f64(), ti: f64(), u: f64(),\n    hist: new Float32Array(H * N), next: new Float32Array(N), lut: new Uint8Array(2 * 257 * 3),\n  };\n}\n\n// The ETDRK4 coefficients for ring length L and dispersion delta. Mode n\n// has wavenumber k = 2 pi n / L for n below 32 and 2 pi (n - 64) / L above;\n// the Nyquist mode, n = 32, gets the damping of its true wavenumber but no\n// share of the nonlinear term, as an odd derivative cannot be taken there.\nfunction coefficients(S) {\n  const { L, delta, g } = S;\n  for (let n = 0; n \u003c N; n++) {\n    const kk = (TAU * (n \u003c N / 2 ? n : n - N)) / L, kn = n === N / 2 ? (TAU * (N / 2)) / L : kk;\n    g[n] = n === N / 2 ? 0 : -0.5 * kk;\n    const zr = STEP * (kn * kn - kn * kn * kn * kn), zi = n === N / 2 ? 0 : STEP * delta * kk * kk * kk;\n    let em = exp(zr);\n    S.Er[n] = em * cos(zi);\n    S.Ei[n] = em * sin(zi);\n    em = exp(zr / 2);\n    S.E2r[n] = em * cos(zi / 2);\n    S.E2i[n] = em * sin(zi / 2);\n    let qr = 0, qi = 0, a1 = 0, b1 = 0, a2 = 0, b2 = 0, a3 = 0, b3 = 0;\n    for (let j = 0; j \u003c MC; j++) {\n      const th = (TAU * (j + 0.5)) / MC, lr = zr + cos(th), li = zi + sin(th);\n      const ex = exp(lr), er = ex * cos(li), ei = ex * sin(li);\n      const hx = exp(lr / 2), hr = hx * cos(li / 2), hi = hx * sin(li / 2);\n      const l2r = lr * lr - li * li, l2i = 2 * lr * li;\n      const l3r = l2r * lr - l2i * li, l3i = l2r * li + l2i * lr;\n      const d1 = lr * lr + li * li, d3 = l3r * l3r + l3i * l3i;\n      qr += ((hr - 1) * lr + hi * li) / d1;\n      qi += (hi * lr - (hr - 1) * li) / d1;\n      let pr = 4 - 3 * lr + l2r, pi = -3 * li + l2i;\n      let nr = -4 - lr + er * pr - ei * pi, ni = -li + er * pi + ei * pr;\n      a1 += (nr * l3r + ni * l3i) / d3;\n      b1 += (ni * l3r - nr * l3i) / d3;\n      pr = lr - 2;\n      pi = li;\n      nr = 2 + lr + er * pr - ei * pi;\n      ni = li + er * pi + ei * pr;\n      a2 += (nr * l3r + ni * l3i) / d3;\n      b2 += (ni * l3r - nr * l3i) / d3;\n      pr = 4 - lr;\n      pi = -li;\n      nr = -4 - 3 * lr - l2r + er * pr - ei * pi;\n      ni = -3 * li - l2i + er * pi + ei * pr;\n      a3 += (nr * l3r + ni * l3i) / d3;\n      b3 += (ni * l3r - nr * l3i) / d3;\n    }\n    const m = STEP / MC;\n    S.Qr[n] = qr * m;\n    S.Qi[n] = qi * m;\n    S.f1r[n] = a1 * m;\n    S.f1i[n] = b1 * m;\n    S.f2r[n] = a2 * m;\n    S.f2i[n] = b2 * m;\n    S.f3r[n] = a3 * m;\n    S.f3i[n] = b3 * m;\n  }\n}\n\n// N(v) = -(i k / 2) FFT(u^2), u the real part of the inverse FFT of v.\nfunction nonlinear(S, xr, xi, outr, outi) {\n  const { tr, ti, g } = S;\n  for (let n = 0; n \u003c N; n++) (tr[n] = xr[n]), (ti[n] = xi[n]);\n  fft(tr, ti, 1);\n  for (let j = 0; j \u003c N; j++) {\n    const u = tr[j] / N;\n    tr[j] = u * u;\n    ti[j] = 0;\n  }\n  fft(tr, ti, -1);\n  for (let n = 0; n \u003c N; n++) {\n    outr[n] = -g[n] * ti[n];\n    outi[n] = g[n] * tr[n];\n  }\n}\n\nfunction step(S) {\n  const { vr, vi, ar, ai, br, bi, cr, ci, Nvr, Nvi, Nar, Nai, Nbr, Nbi, Ncr, Nci, E2r, E2i, Qr, Qi } = S;\n  nonlinear(S, vr, vi, Nvr, Nvi);\n  for (let n = 0; n \u003c N; n++) {\n    ar[n] = E2r[n] * vr[n] - E2i[n] * vi[n] + Qr[n] * Nvr[n] - Qi[n] * Nvi[n];\n    ai[n] = E2r[n] * vi[n] + E2i[n] * vr[n] + Qr[n] * Nvi[n] + Qi[n] * Nvr[n];\n  }\n  nonlinear(S, ar, ai, Nar, Nai);\n  for (let n = 0; n \u003c N; n++) {\n    br[n] = E2r[n] * vr[n] - E2i[n] * vi[n] + Qr[n] * Nar[n] - Qi[n] * Nai[n];\n    bi[n] = E2r[n] * vi[n] + E2i[n] * vr[n] + Qr[n] * Nai[n] + Qi[n] * Nar[n];\n  }\n  nonlinear(S, br, bi, Nbr, Nbi);\n  for (let n = 0; n \u003c N; n++) {\n    const xr = 2 * Nbr[n] - Nvr[n], xi = 2 * Nbi[n] - Nvi[n];\n    cr[n] = E2r[n] * ar[n] - E2i[n] * ai[n] + Qr[n] * xr - Qi[n] * xi;\n    ci[n] = E2r[n] * ai[n] + E2i[n] * ar[n] + Qr[n] * xi + Qi[n] * xr;\n  }\n  nonlinear(S, cr, ci, Ncr, Nci);\n  const { Er, Ei, f1r, f1i, f2r, f2i, f3r, f3i } = S;\n  for (let n = 0; n \u003c N; n++) {\n    const sr = Nar[n] + Nbr[n], si = Nai[n] + Nbi[n];\n    const nr =\n      Er[n] * vr[n] - Ei[n] * vi[n] +\n      (Nvr[n] * f1r[n] - Nvi[n] * f1i[n]) + 2 * (sr * f2r[n] - si * f2i[n]) + (Ncr[n] * f3r[n] - Nci[n] * f3i[n]);\n    const ni =\n      Er[n] * vi[n] + Ei[n] * vr[n] +\n      (Nvr[n] * f1i[n] + Nvi[n] * f1r[n]) + 2 * (sr * f2i[n] + si * f2r[n]) + (Ncr[n] * f3i[n] + Nci[n] * f3r[n]);\n    vr[n] = nr;\n    vi[n] = ni;\n  }\n  // u is real, so v_(64-n) is the conjugate of v_n. Round-off breaks that,\n  // and the broken part is invisible to u^2, so nothing holds it down: it\n  // grew at the linear rate of modes 2 and 3, 0.19 a time unit at L = 22,\n  // and blew the run up at t = 340. Folding it back each step keeps it at 0.\n  for (let n = 1; n \u003c N / 2; n++) {\n    const a = 0.5 * (vr[n] + vr[N - n]), b = 0.5 * (vi[n] - vi[N - n]);\n    vr[n] = vr[N - n] = a;\n    vi[n] = b;\n    vi[N - n] = -b;\n  }\n  vr[0] = vi[0] = vi[N / 2] = 0;\n}\n\n// u on the 64 grid points, one per column.\nfunction physical(S, out) {\n  const { tr, ti } = S;\n  for (let n = 0; n \u003c N; n++) (tr[n] = S.vr[n]), (ti[n] = S.vi[n]);\n  fft(tr, ti, 1);\n  for (let j = 0; j \u003c N; j++) out[j] = tr[j] / N;\n}\n\nfunction advanceRow(S) {\n  for (let s = 0, n = round(ROW / STEP); s \u003c n; s++) step(S);\n}\n\n// The row just computed goes in at the head; `next` is one row ahead of it,\n// so the top of the panel can slide between the two.\nfunction pushRow(S) {\n  S.head = (S.head + H - 1) % H;\n  S.hist.set(S.next, S.head * N);\n  advanceRow(S);\n  physical(S, S.next);\n}\n\n// u is the slope of Sivashinsky's flame front, so a dent pushed into the\n// front shows in u as a dipole, up on one side and down on the other: the\n// derivative of a Gaussian, 4 columns wide, peaks of +-amp. It has no mean.\n// A plain bump had one, and taking it off shifted the whole row by 0.78,\n// a hard line straight across the diagram.\nfunction kick(S, x0, amp) {\n  const u = S.u;\n  physical(S, u);\n  for (let j = 0; j \u003c N; j++) {\n    let d = j - x0;\n    if (d > N / 2) d -= N;\n    if (d \u003c -N / 2) d += N;\n    const q = d / 4;\n    S.tr[j] = u[j] + amp * 1.6487 * q * exp(-0.5 * q * q);\n    S.ti[j] = 0;\n  }\n  fft(S.tr, S.ti, -1);\n  for (let n = 0; n \u003c N; n++) (S.vr[n] = S.tr[n]), (S.vi[n] = S.ti[n]);\n  S.vr[0] = S.vi[0] = 0;\n}\n\nfunction start(S) {\n  // Low modes with random phases, then PRERUN time units so the first\n  // frame is already chaos, then a full panel of history.\n  for (let n = 0; n \u003c N; n++) S.vr[n] = S.vi[n] = 0;\n  for (let n = 1; n \u003c= 6; n++) {\n    const ph = random() * TAU, a = (0.3 * N) / n;\n    S.vr[n] = a * cos(ph);\n    S.vi[n] = a * sin(ph);\n    S.vr[N - n] = a * cos(ph);\n    S.vi[N - n] = -a * sin(ph);\n  }\n  for (let s = 0, n = round(PRERUN / STEP); s \u003c n; s++) step(S);\n  physical(S, S.next);\n  for (let r = 0; r \u003c H; r++) pushRow(S);\n  S.ready = true;\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 22, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  const L = cl(k[2], 22, 66), delta = cl(k[3], -1, 1);\n  if (L !== S.L || delta !== S.delta) {\n    S.L = L;\n    S.delta = delta;\n    coefficients(S);\n  }\n  if (!S.ready) start(S);\n  if (input.btnPressed && input.btnPressed[0]) kick(S, random() * N, 4);\n  S.acc += d * S.speed * RATE;\n  // 30 rows a second at 30 frames lands on 0.9999...; a hair of slack\n  // keeps it one row a frame instead of none and then two.\n  while (S.acc >= 1 - 1e-6) {\n    S.acc = Math.max(0, S.acc - 1);\n    pushRow(S);\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S || !S.ready) return;\n  const lut = S.lut;\n  if (S.lutHue !== S.hue) {\n    // Two ramps of 257 steps, positive u then negative: black at zero,\n    // rising straight to full colour at |u| = 2.64, then paling to a tint at\n    // 3.3. A straight ramp keeps the steps between neighbours soft; the\n    // first, steeper ramp put a hard step on 23 percent of them.\n    for (let side = 0; side \u003c 2; side++) {\n      const h = S.hue + (side === 0 ? 0.5 : 0.86);\n      for (let i = 0; i \u003c= 256; i++) {\n        const a = i / 256, f = cl(a / 0.8, 0, 1), w = cl((a - 0.8) / 0.2, 0, 1);\n        hsv(h + 0.05 * (f - 1), 1 - 0.55 * w, f, lut, (side * 257 + i) * 3);\n      }\n    }\n    S.lutHue = S.hue;\n  }\n  // Pulses grow with the dispersion, |u| up to 3.5 at delta 0 and 4.7 at\n  // delta 1, so the map stretches with it and the pulses do not wash out pale.\n  const { hist, next, head, acc } = S, inv = 256 / (3.3 * (1 + 0.4 * abs(S.delta)));\n  for (let y = 0; y \u003c H; y++) {\n    // Display row y is `acc` of the way from history row y - 1 to row y,\n    // where row -1 is the one computed ahead.\n    const a = y - acc, r0 = floor(a), t = a - r0;\n    const A = r0 \u003c 0 ? next : null, o0 = ((head + r0 + H) % H) * N, o1 = ((head + r0 + 1) % H) * N;\n    for (let x = 0; x \u003c W; x++) {\n      const u0 = A ? A[x] : hist[o0 + x], u1 = r0 + 1 \u003c H ? hist[o1 + x] : u0;\n      const u = u0 + (u1 - u0) * t, i = Math.min(256, round(abs(u) * inv)), o = ((u \u003c 0 ? 257 : 0) + i) * 3;\n      display.setPixel(x, y, lut[o], lut[o + 1], lut[o + 2]);\n    }\n  }\n}\n","plait":"// ===== Patternflow pattern =====\n// Title:   Plait\n// Family:  textile\n// Idea:    Coloured strands hang from a clip and are plaited down the panel, the outside strand crossing over to the middle each time, until the plait is tied off with a ribbon and lowered away, and the next clip of loose strands comes down.\n// Author:  patternflow-lab\n// Date:    2026-10-23\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern round 13\n// Round:   15\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Strands=3..7, Tension=0..1\n//\n// Knob 1: Hue. Turns the strands' colours together, starting from teal, blue and magenta.\n// Knob 2: Speed. How fast the hands work: at 2 the plait grows by 1.2 rows of crossings a second, at 3 by nearly two, at 0.2 by one every eight seconds.\n// Knob 3: Strands. 3 is the plait everyone knows; 4 to 7 make a flat braid, each outside strand weaving over and under all the way to the far edge.\n// Knob 4: Tension. At 0 the plait is loose and fat, 54 LEDs across with three strands crossing every 17 rows; at 1 it is pulled tight to 34 LEDs, crossing every 6 or 7.\n// Buttons: K1 tap ties the plait off with a ribbon where it has got to, long tails and all; it is lowered away and a new one starts.\n\nconst W = 64;\nconst H = 128;\nconst MAXN = 7;\n// The clip holds the strands at rows 1..6; the plait starts under it.\nconst CLIP = 7;\n// The plait is tied once its point gets this far down.\nconst TIE_AT = 100;\n// Seconds a tied plait hangs, and the seconds it takes to lower it away.\nconst HANG = 1.6;\nconst LOWER = 1.4;\n// Crossings a second at Speed 1.\nconst RATE = 0.6;\n// A tied plait is pinched to this share of its width at the ribbon.\nconst GATHER = 0.4;\n\nfunction hsvInto(out, o, h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[o] = (k === 0 || k === 5 ? v : k === 1 ? q : k === 4 ? t : p) * 255;\n  out[o + 1] = (k === 1 || k === 2 ? v : k === 0 ? t : k === 3 ? q : p) * 255;\n  out[o + 2] = (k === 3 || k === 4 ? v : k === 2 ? t : k === 5 ? q : p) * 255;\n}\n\nfunction smooth(a, b, v) {\n  const t = Math.max(0, Math.min(1, (v - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n}\n\n// A strand's lane on a cycle of 2N steps: it walks one lane a step from the\n// left edge to the right, waits a step there, walks back and waits again.\n// Spaced two steps apart, N strands always fill the N lanes, and between two\n// whole steps a strand walking right swaps lanes with one walking left.\nfunction laneAt(q, n) {\n  if (q \u003c= n - 1) return q;\n  if (q \u003c= n) return n - 1;\n  if (q \u003c= 2 * n - 1) return 2 * n - 1 - q;\n  return 0;\n}\n\n// The integral of laneAt, so the lane can be averaged over one step and the\n// strand turns round at the edges instead of folding.\nfunction laneInt(q, n) {\n  const c = 2 * n;\n  const m = n - 1;\n  const total = m * m + m;\n  const k = Math.floor(q / c);\n  const r = q - k * c;\n  let f;\n  if (r \u003c= m) f = (r * r) / 2;\n  else if (r \u003c= n) f = (m * m) / 2 + m * (r - m);\n  else if (r \u003c= 2 * n - 1) f = (m * m) / 2 + m + (2 * n - 1) * (r - n) - (r * r - n * n) / 2;\n  else f = total;\n  return k * total + f;\n}\n\n// Lane, its slope in lanes per step, and depth for strand k at step t.\n// Crossings fall on half steps. At a crossing after an even step the strand\n// walking right is on top, after an odd step the one walking left, so every\n// strand goes over, under, over, and for three strands the outside strand\n// always crosses over the middle one.\nfunction strandAt(k, t, n, out) {\n  const c = 2 * n;\n  const q = 2 * k + t;\n  out[0] = laneInt(q + 0.5, n) - laneInt(q - 0.5, n);\n  const qa = (((q + 0.5) % c) + c) % c;\n  const qb = (((q - 0.5) % c) + c) % c;\n  out[1] = laneAt(qa, n) - laneAt(qb, n);\n  const r = ((q % c) + c) % c;\n  const wave = Math.cos(Math.PI * (t - 0.5));\n  out[2] = r \u003c n - 1 ? wave : r >= n && r \u003c 2 * n - 1 ? -wave : 0;\n}\n\nexport function setup(params) {\n  params.t = 0;\n  params.phase = 0; // 0 plaiting, 1 tied and hanging, 2 lowered away\n  params.timer = 0;\n  params.tiedT = 0;\n  params.started = false;\n  params.n = 3;\n  params.hue = 0;\n  params.speed = 2;\n  params.tension = 0.06;\n  // Each strand's centre row by row: x, depth, the nudge from a row to the\n  // nearest point (slope / (1 + slope^2)) and radius, radius 0 where the strand\n  // is absent; lo..hi is the span of LEDs it can reach in that row.\n  params.cx = new Float32Array(MAXN * H);\n  params.cz = new Float32Array(MAXN * H);\n  params.cs = new Float32Array(MAXN * H);\n  params.cr = new Float32Array(MAXN * H);\n  params.lo = new Float32Array(MAXN * H);\n  params.hi = new Float32Array(MAXN * H);\n  params.dist = new Float32Array(MAXN);\n  params.surf = new Float32Array(MAXN);\n  params.col = new Float32Array(MAXN * 3 + 3);\n  params.tmp = new Float32Array(3);\n  params.img = new Float32Array(W * H * 3);\n  params.out = new Float32Array(W * H * 3);\n  // The tied plait and the next one, drawn once each while one replaces the other.\n  params.old = new Float32Array(W * H * 3);\n  params.next = new Float32Array(W * H * 3);\n  params.valid = 0;\n  params.cn = -1;\n  params.zbuf = new Float32Array(W * H);\n}\n\n// The plait's shape for the current knobs.\nfunction geometry(params) {\n  const n = params.n;\n  const tension = params.tension;\n  // Half the plait's width, from 27 LEDs loose to 17 tight.\n  const half = 27 - 10 * tension;\n  const lane = (2 * half) / (n - 1 + 1.4);\n  return {\n    n: n,\n    lane: lane,\n    radius: lane * 0.7,\n    step: lane * (1.1 - 0.45 * tension),\n    spread: (W - 4 - 1.4 * lane * 0.7) / (n - 1),\n  };\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 3, 0.06];\n  dt = Math.min(dt, 0.1);\n  params.hue = k[0];\n  params.speed = Math.max(0.05, k[1]);\n  params.n = Math.max(3, Math.min(MAXN, Math.round(k[2])));\n  params.tension = Math.max(0, Math.min(1, k[3]));\n  const g = geometry(params);\n  if (!params.started) {\n    params.started = true;\n    // Start part way down, so the first frame already shows a plait.\n    params.t = (44 - CLIP) / g.step;\n  }\n  if (input.btnPressed && input.btnPressed[0] && params.phase === 0) {\n    params.phase = 1;\n    params.timer = 0;\n  }\n  if (params.phase === 0) {\n    params.t += dt * params.speed * RATE;\n    if (CLIP + params.t * g.step >= TIE_AT) {\n      params.phase = 1;\n      params.timer = 0;\n    }\n  } else if (params.phase === 1) {\n    params.timer += dt;\n    if (params.timer > HANG) {\n      params.phase = 2;\n      params.timer = 0;\n      params.tiedT = params.t;\n      params.t = 0;\n    }\n  } else {\n    params.timer += dt;\n    if (params.timer > LOWER) {\n      params.phase = 0;\n      params.timer = 0;\n    }\n  }\n}\n\n// Lay out each strand's centre line, row by row, for a plait whose point is at\n// step tp, its clip shifted down by off rows; tied (0..1) is how far the\n// ribbon has pulled its end in.\nfunction layout(params, g, tp, off, tied) {\n  const n = g.n;\n  const mid = W / 2;\n  const tmp = params.tmp;\n  const cx = params.cx;\n  const cz = params.cz;\n  const cs = params.cs;\n  const cr = params.cr;\n  const depth = g.radius * 0.9;\n  const yp = CLIP + tp * g.step;\n  // The tails get shorter as the plait uses up the strands.\n  const prog = Math.min(1, (yp - CLIP) / (TIE_AT - CLIP));\n  const tailEnd = yp + (H - 1 - CLIP) * (1 - prog) + (20 - 4 * tied) * prog;\n  const reach = 26 - 16 * tied;\n  for (let k = 0; k \u003c n; k++) {\n    // Where the strand leaves the plait, which way it is going there, and how\n    // deep it lies: it keeps that depth all the way down, so a strand crossing\n    // over stays over to the hand.\n    strandAt(k, tp, n, tmp);\n    const c0 = tmp[0] - (n - 1) / 2;\n    const pinch = 1 - (1 - GATHER) * tied;\n    const x0 = mid + c0 * g.lane * pinch;\n    const s0 = ((1 - tied) * tmp[1] * g.lane) / g.step;\n    const z0 = tmp[2] * depth + k * 0.01;\n    const x1 = (x0 + c0 * 4) * tied + (mid + c0 * g.spread) * (1 - tied);\n    for (let y = 0; y \u003c H; y++) {\n      const i = k * H + y;\n      const yy = y + 0.5 - off;\n      cr[i] = 0;\n      if (yy \u003c 2) continue;\n      let sl = 0;\n      if (yy \u003c CLIP) {\n        // Under the clip the strands come straight down.\n        strandAt(k, 0, n, tmp);\n        cx[i] = mid + (tmp[0] - (n - 1) / 2) * g.lane;\n        cz[i] = -depth;\n        cr[i] = g.radius;\n      } else if (yy \u003c= yp) {\n        strandAt(k, (yy - CLIP) / g.step, n, tmp);\n        // A tied plait is gathered in to the ribbon over its last 14 rows.\n        const gather = 1 - (1 - GATHER) * tied * smooth(yp - 14, yp, yy);\n        cx[i] = mid + (tmp[0] - (n - 1) / 2) * g.lane * gather;\n        cz[i] = tmp[2] * depth;\n        sl = (tmp[1] * g.lane * gather) / g.step;\n        cr[i] = g.radius;\n      } else if (yy \u003c tailEnd) {\n        // Below the point a loose strand leaves the way it was going and bends\n        // down to the hand holding it; a tied plait's tails splay a little.\n        const u = Math.min(1, (yy - yp) / reach);\n        const u2 = u * u;\n        const u3 = u2 * u;\n        cx[i] = (2 * u3 - 3 * u2 + 1) * x0 + (u3 - 2 * u2 + u) * reach * s0 + (3 * u2 - 2 * u3) * x1;\n        sl = u \u003c 1 ? ((6 * u2 - 6 * u) * x0 + (3 * u2 - 4 * u + 1) * reach * s0 + (6 * u - 6 * u2) * x1) / reach : 0;\n        cz[i] = z0;\n        // A strand thins to its tip over the last eight rows.\n        const tip = Math.min(1, (tailEnd - yy) / 8);\n        cr[i] = g.radius * (1 - 0.25 * tied) * (0.45 + 0.55 * Math.sqrt(tip));\n      }\n      cs[i] = sl / (1 + sl * sl);\n    }\n  }\n  // The span of LEDs each strand can touch in each row: an LED within the\n  // radius of a strand finds its nearest point at most half a radius up or down.\n  const lo = params.lo;\n  const hi = params.hi;\n  const rows = Math.ceil(g.radius / 2 + 2);\n  for (let k = 0; k \u003c n; k++)\n    for (let y = 0; y \u003c H; y++) {\n      let a = 1e9;\n      let b = -1e9;\n      const j1 = Math.min(H - 1, y + rows);\n      for (let j = Math.max(0, y - rows); j \u003c= j1; j++) {\n        const i = k * H + j;\n        if (cr[i] === 0) continue;\n        if (cx[i] - cr[i] \u003c a) a = cx[i] - cr[i];\n        if (cx[i] + cr[i] > b) b = cx[i] + cr[i];\n      }\n      lo[k * H + y] = a - 2.5;\n      hi[k * H + y] = b + 2.5;\n    }\n}\n\n// Render the laid-out strands into img and zbuf from row y0 down. For each LED\n// and strand, step from the LED's row\n// along the strand's slope to the nearest point of its centre line, so where\n// one strand dives under another the edge follows the strand and not the row.\nfunction render(params, g, y0) {\n  const n = g.n;\n  const cx = params.cx;\n  const cz = params.cz;\n  const cs = params.cs;\n  const cr = params.cr;\n  const lo = params.lo;\n  const hi = params.hi;\n  const col = params.col;\n  const img = params.img;\n  const zbuf = params.zbuf;\n  const dist = params.dist;\n  const surf = params.surf;\n  const depth = g.radius * 0.9;\n  const hl = Math.sqrt(0.45 * 0.45 + 0.5 * 0.5 + 1.74 * 1.74);\n  for (let y = y0; y \u003c H; y++) {\n    const py = y + 0.5;\n    let xa = 1e9;\n    let xb = -1e9;\n    for (let k = 0; k \u003c n; k++) {\n      if (lo[k * H + y] \u003c xa) xa = lo[k * H + y];\n      if (hi[k * H + y] > xb) xb = hi[k * H + y];\n    }\n    xa = Math.max(0, Math.floor(xa));\n    xb = Math.min(W - 1, Math.ceil(xb));\n    for (let x = xa; x \u003c= xb; x++) {\n      const p = y * W + x;\n      const px = x + 0.5;\n      let best = -1e9;\n      let bk = -1;\n      let bnx = 0;\n      let bny = 0;\n      let bz = 0;\n      let bcov = 0;\n      for (let k = 0; k \u003c n; k++) {\n        const i0 = k * H + y;\n        dist[k] = 1e9;\n        if (px \u003c lo[i0] || px > hi[i0]) continue;\n        let ys = cr[i0] > 0 ? py + (px - cx[i0]) * cs[i0] : py;\n        if (ys \u003c 0.5) ys = 0.5;\n        else if (ys > H - 1.5) ys = H - 1.5;\n        const ya = Math.floor(ys - 0.5);\n        const f = ys - 0.5 - ya;\n        const ia = k * H + ya;\n        const ra = cr[ia];\n        const rb = cr[ia + 1];\n        let xs;\n        let zs;\n        let rs;\n        if (rb === 0) {\n          if (ra === 0) continue;\n          xs = cx[ia];\n          zs = cz[ia];\n          rs = ra;\n          ys = ya + 0.5;\n        } else if (ra === 0) {\n          xs = cx[ia + 1];\n          zs = cz[ia + 1];\n          rs = rb;\n          ys = ya + 1.5;\n        } else {\n          xs = cx[ia] + (cx[ia + 1] - cx[ia]) * f;\n          zs = cz[ia] + (cz[ia + 1] - cz[ia]) * f;\n          rs = ra + (rb - ra) * f;\n        }\n        const dx = px - xs;\n        const dy = py - ys;\n        const d2 = dx * dx + dy * dy;\n        if (d2 > (rs + 2) * (rs + 2)) continue;\n        const d = Math.sqrt(d2);\n        dist[k] = d - rs;\n        if (d >= rs) {\n          surf[k] = zs;\n          if (d \u003c rs + 0.5 && zs > best) {\n            best = zs;\n            bk = k;\n            bnx = dx / d;\n            bny = dy / d;\n            bz = zs / depth;\n            bcov = rs + 0.5 - d;\n          }\n          continue;\n        }\n        surf[k] = zs + Math.sqrt(rs * rs - d * d);\n        if (surf[k] > best) {\n          best = surf[k];\n          bk = k;\n          bnx = dx / rs;\n          bny = dy / rs;\n          bz = zs / depth;\n          bcov = Math.min(1, rs + 0.5 - d);\n        }\n      }\n      if (bk \u003c 0) continue;\n      // A strand lying over this one darkens the LEDs just outside its edge,\n      // so a strand going under reads as tucked in.\n      let shade = 1;\n      for (let k = 0; k \u003c n; k++) {\n        if (k === bk || dist[k] > 2 || dist[k] \u003c -0.5) continue;\n        if (surf[k] > best - 1) shade = Math.min(shade, 0.12 + 0.88 * smooth(0, 2, dist[k]));\n      }\n      const nn = Math.min(1, bnx * bnx + bny * bny);\n      const nz = Math.sqrt(1 - nn);\n      // Light from the upper left and in front.\n      // The square root flattens the lit middle of a strand and keeps its\n      // fall-off for the rim, so it reads as round without a smear of greys.\n      const diff = Math.sqrt(Math.max(0, -0.45 * bnx - 0.5 * bny + 0.74 * nz));\n      let sp = Math.max(0, (-0.45 * bnx - 0.5 * bny + 1.74 * nz) / hl);\n      sp *= sp;\n      sp *= sp;\n      sp *= sp;\n      sp *= sp;\n      // Under, a strand is dimmer; over, it is lit full. The floor stays high\n      // enough that an orange strand going under does not turn brown.\n      const lit = (0.56 + 0.44 * (0.5 + 0.5 * bz)) * shade;\n      const v = lit * (0.14 + 0.86 * diff);\n      const spec = sp * 0.5 * lit * 255;\n      const c = bk * 3;\n      const o = p * 3;\n      img[o] = img[o] * (1 - bcov) + Math.min(255, col[c] * v + spec) * bcov;\n      img[o + 1] = img[o + 1] * (1 - bcov) + Math.min(255, col[c + 1] * v + spec) * bcov;\n      img[o + 2] = img[o + 2] * (1 - bcov) + Math.min(255, col[c + 2] * v + spec) * bcov;\n      zbuf[p] = best;\n    }\n  }\n}\n\n// A ribbon tied in a bow round the plait at row yp, grown to size (0..1):\n// a band round the gathered strands, two loops, a knot and two tails cut in a fork.\nfunction ribbon(img, params, yp, band, size) {\n  if (size \u003c= 0) return;\n  const col = params.col;\n  const c = MAXN * 3;\n  const cx = W / 2;\n  const lw = 12 * size;\n  const lh = 6 * size;\n  const ca = Math.cos(0.42);\n  const sa = Math.sin(0.42);\n  for (let y = Math.max(0, Math.floor(yp - 14)); y \u003c Math.min(H, yp + 20); y++)\n    for (let x = 0; x \u003c W; x++) {\n      const px = x + 0.5 - cx;\n      const py = y + 0.5 - yp;\n      let v = 0;\n      // The band round the plait.\n      if (Math.abs(py) \u003c 1.8 && Math.abs(px) \u003c band * size) v = 0.85 - 0.12 * Math.max(0, py);\n      // The loops, tilted up and out, with a fold darker along the middle.\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const lx = s * px - lw * 0.55;\n        const ly = py + 2.5 * size;\n        const u = (lx * ca + ly * sa) / lw;\n        const w = (-lx * sa + ly * ca) / lh;\n        const e = (u * u) / 0.3 + w * w;\n        if (e \u003c 1) v = Math.max(v, Math.abs(w) \u003c 0.18 && u > -0.2 ? 0.72 : 1 - 0.18 * e);\n      }\n      // The tails, hanging down and out from the knot, forked at the end.\n      for (let s = -1; s \u003c= 1; s += 2) {\n        const along = py / size;\n        const off = s * px - (1.5 + py * 0.42);\n        if (along > 0 && along \u003c 15 && Math.abs(off) \u003c 2.4 && !(along > 12 && Math.abs(off) \u003c (along - 12) * 0.9)) v = Math.max(v, 0.95 - 0.2 * (along / 15));\n      }\n      // The knot.\n      const kr = px * px + (py + 0.3) * (py + 0.3);\n      if (kr \u003c 10 * size * size) v = Math.max(v, 1);\n      else if (kr \u003c 14 * size * size) v = Math.min(v, 0.75);\n      if (v \u003c= 0) continue;\n      const o = (y * W + x) * 3;\n      img[o] = col[c] * v;\n      img[o + 1] = col[c + 1] * v;\n      img[o + 2] = col[c + 2] * v;\n    }\n}\n\n// The clip at the top, a rounded silver bar a little wider than the plait,\n// shifted down by off rows, drawn from row y0 down.\nfunction clip(params, half, off, y0) {\n  const img = params.img;\n  for (let j = 1; j \u003c CLIP; j++) {\n    const y = j + Math.round(off);\n    if (y \u003c y0 || y >= H) continue;\n    const u = (j + 0.5 - (CLIP + 1) / 2) / ((CLIP - 1) / 2);\n    const v = 0.35 + 0.65 * Math.sqrt(Math.max(0, 1 - u * u)) + (Math.abs(u + 0.35) \u003c 0.3 ? 0.25 : 0);\n    for (let x = 0; x \u003c W; x++) {\n      const ex = Math.abs(x + 0.5 - W / 2) - (half + 2);\n      if (ex > 1) continue;\n      const a = Math.max(0, Math.min(1, 1 - ex)) * (j === 1 || j === CLIP - 1 ? 0.75 : 1);\n      const o = (y * W + x) * 3;\n      img[o] = img[o] * (1 - a) + Math.min(255, 215 * v) * a;\n      img[o + 1] = img[o + 1] * (1 - a) + Math.min(255, 220 * v) * a;\n      img[o + 2] = img[o + 2] * (1 - a) + Math.min(255, 232 * v) * a;\n    }\n  }\n}\n\n// Copy src into out moved down by off rows, blending neighbouring rows for the\n// fraction. On top, src covers out where it is lit and lets it through where dark.\nfunction slide(out, src, off, top) {\n  const fo = Math.floor(off);\n  const fr = off - fo;\n  for (let y = 0; y \u003c H; y++) {\n    const ya = y - fo;\n    const yb = ya - 1;\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      let r = 0;\n      let g = 0;\n      let b = 0;\n      let cov = 0;\n      if (ya >= 0 && ya \u003c H) {\n        const a = (ya * W + x) * 3;\n        r += src[a] * (1 - fr);\n        g += src[a + 1] * (1 - fr);\n        b += src[a + 2] * (1 - fr);\n        if (src[a] + src[a + 1] + src[a + 2] > 0) cov += 1 - fr;\n      }\n      if (yb >= 0 && yb \u003c H) {\n        const a = (yb * W + x) * 3;\n        r += src[a] * fr;\n        g += src[a + 1] * fr;\n        b += src[a + 2] * fr;\n        if (src[a] + src[a + 1] + src[a + 2] > 0) cov += fr;\n      }\n      if (!top) cov = 1;\n      out[o] = r + out[o] * (1 - cov);\n      out[o + 1] = g + out[o + 1] * (1 - cov);\n      out[o + 2] = b + out[o + 2] * (1 - cov);\n    }\n  }\n}\n\nexport function draw(display, params, time) {\n  const g = geometry(params);\n  const col = params.col;\n  const hue = params.hue + 0.47;\n  const fan = (0.62 * (g.n - 1)) / g.n;\n  for (let k = 0; k \u003c g.n; k++) hsvInto(col, k * 3, hue + (k * 0.62) / g.n, 0.78, 1);\n  // The ribbon takes the colour in the middle of the gap the strands leave on the wheel.\n  hsvInto(col, MAXN * 3, hue + fan + (1 - fan) / 2 - 0.04, 0.68, 1);\n  const half = ((g.n - 1) * g.lane) / 2 + g.radius;\n  // Half the width of the gathered end, where the ribbon's band goes round.\n  const band = ((g.n - 1) * g.lane * GATHER) / 2 + g.radius * 0.9;\n  const img = params.img;\n  const zbuf = params.zbuf;\n  const phase = params.phase;\n  // While the knobs stay put, the plait above its point does not change, so\n  // the rows that were finished last frame are kept and only the rest drawn.\n  const same = params.cn === g.n && params.ct === params.tension && params.ch === params.hue && params.cp === phase;\n  let y0 = same ? params.valid : 0;\n  params.cn = g.n;\n  params.ct = params.tension;\n  params.ch = params.hue;\n  params.cp = phase;\n  let out = img;\n  if (phase === 2) {\n    // The tied plait is lowered out of sight on its clip and the next clip of\n    // loose strands comes down after it. Neither changes shape on the way, so\n    // each is drawn once and slid down a fraction of a row at a time.\n    if (!same) {\n      img.fill(0);\n      zbuf.fill(-1e9);\n      layout(params, g, params.tiedT, 0, 1);\n      render(params, g, 0);\n      clip(params, half, 0, 0);\n      ribbon(img, params, CLIP + params.tiedT * g.step, band, 1);\n      params.old.set(img);\n      img.fill(0);\n      zbuf.fill(-1e9);\n      layout(params, g, 0, 0, 0);\n      render(params, g, 0);\n      clip(params, half, 0, 0);\n      params.next.set(img);\n    }\n    const off = smooth(0, 1, params.timer / LOWER) * (H + 4);\n    out = params.out;\n    slide(out, params.next, off - H - 4, false);\n    slide(out, params.old, off, true);\n    params.valid = 0;\n  } else {\n    img.fill(0, y0 * W * 3);\n    zbuf.fill(-1e9, y0 * W);\n    const yp = CLIP + params.t * g.step;\n    if (y0 \u003c H) {\n      layout(params, g, params.t, 0, phase === 1 ? smooth(0, 0.35, params.timer) : 0);\n      render(params, g, y0);\n      clip(params, half, 0, y0);\n    }\n    // A hanging plait is still; a growing one is settled down to a radius above its point.\n    params.valid = phase === 1 ? (params.timer > 0.4 ? H : Math.floor(yp - 20 - g.radius)) : Math.max(0, Math.floor(yp - g.radius - 4));\n    if (phase === 1) {\n      out = params.out;\n      out.set(img);\n      ribbon(out, params, yp, band, smooth(0, 0.35, params.timer));\n    }\n  }\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      if (out[o] + out[o + 1] + out[o + 2] \u003c 1) continue;\n      display.setPixel(x, y, out[o], out[o + 1], out[o + 2]);\n    }\n}\n","domain-warp":"// ===== Patternflow pattern =====\n// Title:   Domain Warp\n// Family:  noise\n// Idea:    Noise that is pushed around by its own noise twice over stops looking like noise and starts looking like stone being poured.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// ===============================\n// @matrix 64x128\n// @knobs Cycle=0..1, Speed=0..5, Warp=1..6, Zoom=0.035..0.095\n// @ramp oklab wrap 0:#05030f 0.16:#0e1450 0.22:#2a7ac0 0.27:#100c44 0.5:#2c1478 0.62:#c83888 0.68:#ffd890 0.74:#ff6a3a 0.84:#4a0a3a 1:#05030f\n//\n// Knob 1: Cycle. Slides the palette through the stone, so the gold veins move onto other contours; one turn comes back.\n// Knob 2: Speed. How fast the marble pours; 0 holds it still.\n// Knob 3: Warp. How hard the noise is folded into itself, from loose marble to tight swirls.\n// Knob 4: Zoom. Size of the stone; low is a few big swirls, high is fine grain.\n\n// The noise is built once into a tileable texture, so each stage of the\n// warp is one lookup instead of four octaves of noise.\nconst N = 128;\n\nfunction hash(x, y, s) {\n  let h = Math.imul(x, 374761393) + Math.imul(y, 668265263) + Math.imul(s, 2147483647);\n  h = Math.imul(h ^ (h >>> 13), 1274126177);\n  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;\n}\n\nfunction fade(t) {\n  return t * t * t * (t * (t * 6 - 15) + 10);\n}\n\nfunction tap(tex, u, v) {\n  const fu = Math.floor(u);\n  const fv = Math.floor(v);\n  const x0 = fu & (N - 1);\n  const y0 = fv & (N - 1);\n  const x1 = (x0 + 1) & (N - 1);\n  const y1 = (y0 + 1) & (N - 1);\n  const tx = u - fu;\n  const ty = v - fv;\n  const a = tex[y0 * N + x0];\n  const b = tex[y0 * N + x1];\n  const c = tex[y1 * N + x0];\n  const d = tex[y1 * N + x1];\n  return a + (b - a) * tx + (c - a) * ty + (a - b - c + d) * tx * ty;\n}\n\nexport function setup(params) {\n  const tex = new Float32Array(N * N);\n  let amp = 1;\n  for (let o = 0; o \u003c 4; o++) {\n    const cells = 4 \u003c\u003c o;\n    const size = N / cells;\n    for (let y = 0; y \u003c N; y++) {\n      const gy = Math.floor(y / size);\n      const fy = fade(y / size - gy);\n      for (let x = 0; x \u003c N; x++) {\n        const gx = Math.floor(x / size);\n        const fx = fade(x / size - gx);\n        const x1 = (gx + 1) % cells;\n        const y1 = (gy + 1) % cells;\n        const a = hash(gx, gy, o);\n        const b = hash(x1, gy, o);\n        const c = hash(gx, y1, o);\n        const d = hash(x1, y1, o);\n        const top = a + (b - a) * fx;\n        const bottom = c + (d - c) * fx;\n        tex[y * N + x] += (top + (bottom - top) * fy) * amp;\n      }\n    }\n    amp *= 0.5;\n  }\n  let lo = Infinity;\n  let hi = -Infinity;\n  for (let i = 0; i \u003c tex.length; i++) {\n    lo = Math.min(lo, tex[i]);\n    hi = Math.max(hi, tex[i]);\n  }\n  for (let i = 0; i \u003c tex.length; i++) tex[i] = (tex[i] - lo) / (hi - lo);\n  params.tex = tex;\n  params.clock = 0;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 1, 0.06];\n  params.colour = k[0];\n  params.speed = k[1];\n  params.warp = k[2];\n  params.zoom = k[3];\n  params.clock += dt * params.speed * 0.4;\n}\n\nexport function draw(display, params, time) {\n  const tex = params.tex;\n  const w = display.width;\n  const h = display.height;\n  const t = params.clock;\n  // Texels per LED; the texture's coarsest noise cell is 32 texels wide.\n  const s = params.zoom * 12;\n  const amount = 36 + (params.warp - 1) * 5.5;\n  const ox = t * 3.1;\n  const oy = t * 1.7;\n  for (let y = 0; y \u003c h; y++) {\n    for (let x = 0; x \u003c w; x++) {\n      const px = (x - w / 2) * s + 64 + t * 1.3;\n      const py = (y - h / 2) * s + 64 + t * 0.4;\n      const qx = tap(tex, px + ox, py) - 0.5;\n      const qy = tap(tex, px + 41.3, py + 17.9 - oy) - 0.5;\n      const rx = tap(tex, px + amount * qx + 23.7 - oy, py + amount * qy + 91.1) - 0.5;\n      const ry = tap(tex, px + amount * qx + 77.2, py + amount * qy + 5.3 + ox * 0.6) - 0.5;\n      const f = tap(tex, px + amount * rx, py + amount * ry);\n      let v = f * 3 + params.colour;\n      v -= Math.floor(v);\n      display.setValue(x, y, v);\n    }\n  }\n}\n","heawood-torus":"// ===== Patternflow pattern =====\n// Title:   Heawood Torus\n// Family:  topology\n// Idea:    A tall torus turns and leans in front of you painted with Heawood's map of seven hexagonal countries, each of which touches all six others, so this map needs seven colours where a map on the sphere never needs more than four.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Heawood's seven-colour map on the torus (Percy Heawood, 1890), pattern round 36\n// Round:   36\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Hole=0..1, Tilt=0..1\n//\n// Knob 1: Hue. Turns the seven colours round the wheel together, a seventh apart. At 0 they are orange, lime, green, cyan, blue, violet and pink; every seventh of the way round the same seven come back, each moved on to another country, and halfway between, at 0.07, 0.21 and so on, one of them is pure red.\n// Knob 2: Speed. How fast the torus turns about its long axis. At 2 a turn takes 16 s, so it goes from face-on to edge-on in 4 s, and its lean nods 3 degrees each way every 29 s; at 0.2 everything is ten times slower, at 3 a turn takes 10 s.\n// Knob 3: Hole. The tube's radius against the radius of the curve it runs round, the torus keeping its width, 59 LEDs at the opening tilt. At 0 it is 0.85: the tube is 27 LEDs thick and the hole a slot 5 LEDs wide and 65 tall; at 0.5 the tube is 23 thick and the hole 14 wide; at 1 it is 0.4, a 17 LED tube round a hole 25 wide and 86 tall.\n// Knob 4: Tilt. How far the top of the torus leans toward you: 8 degrees at 0.06, so you look almost straight at its side, 23 at 0.5 and 40 at 1, where you look down into the hole and see the top bend from above.\n// Buttons: K1 tap draws, for six seconds, the capital of each country and the 21 roads between them in white: the complete graph on seven points, drawn on the torus with no two roads crossing, each road crossing one border. Tapping again while they show keeps them up.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sin, cos, abs, round, PI } = Math;\nconst TAU = 2 * PI;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\n\n// The plane tiled by hexagons, the hexagon at axial (a, b) coloured\n// (a + 3b) mod 7. Its six neighbours sit at (+-1, 0), (0, +-1) and\n// +-(1, -1), so their colours differ from its own by +-1, +-3 and +-2: all\n// six other colours, once each. The colouring repeats on the lattice L of\n// (a, b) with a + 3b = 0 mod 7, which has index 7, so the torus plane / L\n// holds exactly one hexagon of each colour, and each touches the other six.\n// L is spanned by E1 = (2, -3) and E2 = (1, 2) (determinant 7); of all the\n// bases of L these two shear the hexagons least on the long, thin parameter\n// square of this torus.\nconst E1A = 2, E1B = -3, E2A = 1, E2B = 2;\n\n// Samples round the core curve and round the tube; samples along each road.\nconst NU = 600, NV = 120, NS = NU * NV, NR = 200;\n// The outer half width of the torus in LEDs, and its half height before it leans.\nconst RO = 31, HALF = 63;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;\n  out[o + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;\n  out[o + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;\n}\n\n// The country at fractional axial coordinates (qa, qb): round to the nearest\n// hexagon centre in cube coordinates, then colour it.\nfunction country(qa, qb) {\n  const x = qa, z = qb, y = -x - z;\n  let rx = round(x), ry = round(y), rz = round(z);\n  const dx = abs(rx - x), dy = abs(ry - y), dz = abs(rz - z);\n  if (dx > dy && dx > dz) rx = -ry - rz;\n  else if (dy \u003c= dz) rz = -rx - ry;\n  return (((rx + 3 * rz) % 7) + 7) % 7;\n}\n\n// The surface: a tube of radius r round a stadium, two half circles of\n// radius rc joined by straights 2 ly long, standing up in the x-y plane.\n// (U, V) in the unit square is the fraction of the way round the stadium and\n// round the tube. core() writes the point of the stadium at U and its\n// outward normal in the plane, (cx, cy, ox, oy), at out[o..o+3]; the surface\n// point is (cx + r cos v ox, cy + r cos v oy, r sin v) with v = 2 pi V, and\n// its normal (cos v ox, cos v oy, sin v).\nfunction core(S, U, out, o) {\n  const rc = S.rc, ly = S.ly;\n  let s = (U - floor(U)) * S.per, cx, cy, ox, oy;\n  if (s \u003c 2 * ly) (cx = rc), (cy = -ly + s), (ox = 1), (oy = 0);\n  else if ((s -= 2 * ly) \u003c PI * rc) {\n    const a = s / rc;\n    (ox = cos(a)), (oy = sin(a)), (cx = rc * ox), (cy = ly + rc * oy);\n  } else if ((s -= PI * rc) \u003c 2 * ly) (cx = -rc), (cy = ly - s), (ox = -1), (oy = 0);\n  else {\n    const a = PI + (s - 2 * ly) / rc;\n    (ox = cos(a)), (oy = sin(a)), (cx = rc * ox), (cy = -ly + rc * oy);\n  }\n  out[o] = cx;\n  out[o + 1] = cy;\n  out[o + 2] = ox;\n  out[o + 3] = oy;\n}\n\n// The plane point U E1 + V E2 is the one painted at (U, V), so the square's\n// sides go to E1 and E2 and the map closes up on the torus. Back the other\n// way, (qa, qb) lands at U = (2 qa - qb) / 7, V = (3 qa + 2 qb) / 7.\nfunction build(S) {\n  S.rc = RO / (1 + S.ratio);\n  S.r = S.rc * S.ratio;\n  S.ly = HALF - RO;\n  S.per = 4 * S.ly + TAU * S.rc;\n  const { cc, tc, ts, cid, road } = S;\n  for (let j = 0; j \u003c NV; j++) {\n    tc[j] = cos((TAU * (j + 0.5)) / NV);\n    ts[j] = sin((TAU * (j + 0.5)) / NV);\n  }\n  for (let i = 0; i \u003c NU; i++) {\n    const U = (i + 0.5) / NU;\n    core(S, U, cc, 4 * i);\n    for (let j = 0; j \u003c NV; j++) cid[i * NV + j] = country(U * E1A + (j + 0.5) / NV * E2A, U * E1B + (j + 0.5) / NV * E2B);\n  }\n  // The dual graph: the capital of country a sits at the hexagon (a, 0), and\n  // three roads leave it toward (a + 1, 0), (a, 1) and (a + 1, -1). Seven\n  // capitals times three is all 21 roads of K7, each crossing one border.\n  const q4 = [0, 0, 0, 0];\n  let n = 0;\n  for (let a = 0; a \u003c 7; a++)\n    for (const [da, db] of [[1, 0], [0, 1], [1, -1]])\n      for (let t = 0; t \u003c NR; t++, n++) {\n        const qa = a + (da * t) / (NR - 1), qb = (db * t) / (NR - 1), v = (TAU * (3 * qa + 2 * qb)) / 7, o = 3 * n;\n        core(S, (2 * qa - qb) / 7, q4, 0);\n        road[o] = q4[0] + S.r * cos(v) * q4[2];\n        road[o + 1] = q4[1] + S.r * cos(v) * q4[3];\n        road[o + 2] = S.r * sin(v);\n      }\n}\n\nexport function setup(params) {\n  // The turn starts 0.4 short of face-on, so at Speed 2 the torus faces you\n  // squarely one second in and stands edge-on five seconds in.\n  params.s = {\n    hue: 0, speed: 2, ratio: -1, tilt: 0.06, spin: -0.4, nod: 0, roads: -1, rc: 0, r: 0, ly: 0, per: 0,\n    cc: new Float32Array(4 * NU), tc: new Float32Array(NV), ts: new Float32Array(NV), cid: new Uint8Array(NS), road: new Float32Array(3 * 21 * NR),\n    zb: new Float32Array(N), ib: new Int32Array(N), ib2: new Int32Array(N), cb: new Uint8Array(N), rb: new Uint8Array(N), pal: new Float32Array(21),\n  };\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.tilt = cl(k[3], 0, 1);\n  const ratio = 0.85 - 0.45 * cl(k[2], 0, 1);\n  if (abs(ratio - S.ratio) > 1e-4) {\n    S.ratio = ratio;\n    build(S);\n  }\n  S.spin += d * S.speed * 0.2;\n  S.nod += d * S.speed * 0.11;\n  if (S.roads >= 0) {\n    S.roads += d;\n    if (S.roads > 7) S.roads = -1;\n  }\n  if (input.btnPressed && input.btnPressed[0]) S.roads = S.roads \u003c 0 ? 0 : min(S.roads, 0.5);\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  const { cc, tc, ts, cid, zb, ib, ib2, cb, rb, road, pal } = S, r = S.r;\n  // Spin about the torus's long axis, then lean the top of that axis toward\n  // the viewer, who looks along +z.\n  const ph = S.spin, cp = cos(ph), sp = sin(ph);\n  const la = -(0.1 + 0.6 * S.tilt + 0.05 * sin(S.nod)), cla = cos(la), sla = sin(la);\n  const m0 = cp, m2 = sp;\n  const m3 = sla * sp, m4 = cla, m5 = -sla * cp;\n  const m6 = -cla * sp, m7 = sla, m8 = cla * cp;\n  // Fit the leaning torus to the panel height.\n  const sc = min(1, 63.5 / (HALF * cla - RO * sla));\n  zb.fill(1e9);\n  ib.fill(-1);\n  // Each sample's screen x, y and depth are a column part plus cos v and\n  // sin v times a part, so the loop over the tube is a few multiplies.\n  const Xb = sc * m2 * r, Yb = -sc * m5 * r, Zb = m8 * r;\n  for (let i = 0; i \u003c NU; i++) {\n    const cx = cc[4 * i], cy = cc[4 * i + 1], ox = cc[4 * i + 2], oy = cc[4 * i + 3], A = m6 * ox + m7 * oy;\n    const X0 = 32 + sc * m0 * cx, Xa = sc * m0 * r * ox, Y0 = 64 - sc * (m3 * cx + m4 * cy), Ya = -sc * r * (m3 * ox + m4 * oy);\n    const Z0 = m6 * cx + m7 * cy, Za = r * A;\n    for (let j = 0, k = i * NV; j \u003c NV; j++, k++) {\n      const cv = tc[j], sv = ts[j];\n      // Facing away from the eye.\n      if (cv * A + sv * m8 > 0.05) continue;\n      const px = floor(X0 + cv * Xa + sv * Xb), py = floor(Y0 + cv * Ya + sv * Yb);\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px, Z = Z0 + cv * Za + sv * Zb;\n      if (Z \u003c zb[p]) (zb[p] = Z), (ib[p] = k);\n    }\n  }\n  // Fill LEDs that no front sample reached, or where the back of the tube\n  // shows through between two front samples.\n  ib2.set(ib);\n  for (let y = 1; y \u003c H - 1; y++)\n    for (let x = 1; x \u003c W - 1; x++) {\n      const p = y * W + x, z = zb[p];\n      for (let q = 1; q \u003c= W; q += W - 1) {\n        const a = zb[p - q], b = zb[p + q];\n        if (a \u003c 1e8 && b \u003c 1e8 && abs(a - b) \u003c 4 && z > max(a, b) + 3) {\n          ib2[p] = a \u003c b ? ib[p - q] : ib[p + q];\n          break;\n        }\n      }\n    }\n  for (let p = 0; p \u003c N; p++) {\n    const k = ib2[p];\n    cb[p] = k \u003c 0 ? 255 : cid[k];\n    if (k >= 0 && k !== ib[p]) {\n      const i = (k / NV) | 0, j = k - i * NV, o = 4 * i;\n      zb[p] = m6 * (cc[o] + r * tc[j] * cc[o + 2]) + m7 * (cc[o + 1] + r * tc[j] * cc[o + 3]) + m8 * r * ts[j];\n    }\n  }\n\n  // The roads, where they lie on the visible surface, and the capitals at\n  // their ends as 2 x 2 dots.\n  const e = S.roads \u003c 0 ? 0 : sm(S.roads / 0.5) * (1 - sm(S.roads - 6));\n  if (e > 0) {\n    rb.fill(0);\n    for (let i = 0, o = 0; i \u003c 21 * NR; i++, o += 3) {\n      const x = road[o], y = road[o + 1], z = road[o + 2];\n      const px = floor(32 + sc * (m0 * x + m2 * z)), py = floor(64 - sc * (m3 * x + m4 * y + m5 * z));\n      if (px \u003c 0 || px >= W || py \u003c 0 || py >= H) continue;\n      const p = py * W + px;\n      if (m6 * x + m7 * y + m8 * z > zb[p] + 1.5) continue;\n      rb[p] = 1;\n      if (i % NR === 0 && px \u003c W - 1 && py \u003c H - 1) rb[p + 1] = rb[p + W] = rb[p + W + 1] = 1;\n    }\n  }\n\n  // The seven colours, a seventh apart, opening off red.\n  const h0 = S.hue + 1 / 14;\n  for (let c = 0; c \u003c 7; c++) hsv(h0 + c / 7, 1, 1, pal, 3 * c);\n  // Light from the upper left, in front.\n  const lx = -0.45, ly = 0.6, lz = -0.66;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x, c = cb[p];\n      if (c === 255) {\n        display.setPixel(x, y, 0, 0, 0);\n        continue;\n      }\n      const k = ib2[p], i = (k / NV) | 0, j = k - i * NV, nx = tc[j] * cc[4 * i + 2], ny = tc[j] * cc[4 * i + 3], nz = ts[j];\n      const vx = m0 * nx + m2 * nz, vy = m3 * nx + m4 * ny + m5 * nz, vz = m6 * nx + m7 * ny + m8 * nz;\n      const dif = max(0, vx * lx + vy * ly + vz * lz);\n      // Half vector of the light and the eye at -z, for a small shine.\n      let hv = max(0, (vx * lx + vy * ly + vz * (lz - 1)) / 1.82);\n      (hv *= hv), (hv *= hv), (hv *= hv), (hv *= hv), (hv *= hv);\n      const spec = hv * 0.5;\n      const lit = (0.6 + 0.55 * dif) * (1 - 0.2 * e);\n      let R = pal[3 * c] * lit + spec, G = pal[3 * c + 1] * lit + spec, B = pal[3 * c + 2] * lit + spec;\n      // A dark LED where the country changes to the right or below, and\n      // where the surface folds behind a nearer part of the tube.\n      const r = x \u003c W - 1 ? cb[p + 1] : 255, b = y \u003c H - 1 ? cb[p + W] : 255, zf = zb[p] - 6;\n      if ((r !== 255 && r !== c) || (b !== 255 && b !== c) ||\n        (x > 0 && cb[p - 1] !== 255 && zb[p - 1] \u003c zf) || (r !== 255 && zb[p + 1] \u003c zf) ||\n        (y > 0 && cb[p - W] !== 255 && zb[p - W] \u003c zf) || (b !== 255 && zb[p + W] \u003c zf)) (R *= 0.08), (G *= 0.08), (B *= 0.08);\n      if (e > 0 && rb[p]) {\n        R += (1 - R) * e;\n        G += (1 - G) * e;\n        B += (1 - B) * e;\n      }\n      display.setPixel(x, y, cl(R * 255, 0, 255), cl(G * 255, 0, 255), cl(B * 255, 0, 255));\n    }\n}\n","perron-tree":"// ===== Patternflow pattern =====\n// Title:   Perron Tree\n// Family:  geometry\n// Idea:    A tall triangle that holds a needle in every direction between its sides is cut into thin slivers that slide over each other level by level, as Perron did, until it is a tree of sprouts on a third of the area that still holds every direction, and a white needle turns through all of them, hopping from sprout to sprout.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: Kakeya needle problem (Sōichi Kakeya, 1917), Besicovitch set drawn as Oskar Perron's tree (1928), pattern round 29\n// Round:   29\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Depth=5..8, Slide=-1..1\n//\n// Knob 1: Hue. Turns the sweep of colours that marks each sliver's direction round the wheel.\n// Knob 2: Speed. How fast the slivers slide and the needle turns; at 2 the tree takes five and a half seconds to grow, stands for six and folds back up in three.\n// Knob 3: Depth. How many times the base is halved, 5 to 8: from 32 slivers to 256, and as many levels of sliding. The finished tree covers 30% of the triangle at 5 and 24% at 8.\n// Knob 4: Slide. How far each pair slides over the other: at -1 a little, and the tree is a tall trunk with a small crown frayed out at the top; at 1 a long way, and a short stub carries a crown that fans out nearly as wide as the triangle was.\n// Buttons: K1 tap starts again from the single triangle.\n\nconst W = 64, H = 128, N = W * H;\nconst { min, max, floor, sqrt, exp, cos, abs, pow, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (v) => ((v = cl(v, 0, 1)), v * v * (3 - 2 * v));\n\n// The triangle: base on the bottom edge, BW LEDs wide, apex HT LEDs up.\nconst BW = 60, HT = 120, Y0 = 128, MAXN = 8, MAXM = 1 \u003c\u003c MAXN;\n// How much of the blurred light comes back as glow (the blur sums to 81).\nconst GLOW = 0.22 / 81;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  const c = i === 0 ? [v, t, p] : i === 1 ? [q, v, p] : i === 2 ? [p, v, t] : i === 3 ? [p, q, v] : i === 4 ? [t, p, v] : [v, p, q];\n  out[o] = c[0];\n  out[o + 1] = c[1];\n  out[o + 2] = c[2];\n}\n\nexport function setup(params) {\n  params.s = {\n    lam: 0, hold: 0, phase: 0, needle: 0, n: 5, g: 0.8, hue: 0,\n    acc: new Float32Array(N * 3), trail: new Float32Array(N), fade: 1, blo: new Float32Array(N * 3), sh: new Float32Array(MAXM), tj: new Float32Array(MAXN + 1), dur: new Float32Array(MAXN + 1),\n    col: new Float32Array(MAXM * 3),\n  };\n}\n\n// Perron's slides. At level j the base pieces pair up in groups of 2^j and\n// the right half of each group slides left by tj[j]: first closing the gap\n// its heart left at the level before, then a further 2(1 - g) of its half\n// base, so the two halves cross at 2g - 1 of the group triangle's height and\n// fork into two sprouts above it. What lies below is the group's heart, its\n// triangle shrunk by g^j toward its left corner, and the next level slides\n// hearts the same way. (Stein's write-up of Schoenberg's version.)\nfunction slides(P, n, g) {\n  const w = BW / (1 \u003c\u003c n);\n  for (let j = 1; j \u003c= n; j++) {\n    const half = w * (1 \u003c\u003c (j - 1)), s = pow(g, j - 1);\n    P.tj[j] = half * (1 - s) + 2 * (1 - g) * s * half;\n  }\n  // Seconds per level at Speed 2: the first levels move a fraction of an\n  // LED and go by quickly, the last ones take their time.\n  for (let j = 1; j \u003c= n; j++) P.dur[j] = 0.3 + 1.7 * pow(P.tj[j] / P.tj[n], 0.6);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1) * cl(k[1], 0.2, 3) / 2;\n  P.hue = cl(k[0], 0, 1);\n  const n = cl(round(k[2]), 5, MAXN), g = 0.8 - 0.12 * cl(k[3], -1, 1);\n  if (n !== P.n || abs(g - P.g) > 1e-4) {\n    // Keep the same share of the build when the depth changes.\n    const frac = P.lam / P.n;\n    P.n = n;\n    P.g = g;\n    P.lam = frac * n;\n  }\n  slides(P, P.n, P.g);\n  if (input.btnPressed && input.btnPressed[0]) (P.phase = 0), (P.lam = 0), (P.hold = 0);\n  // Build level by level, hold the tree, take it apart again from the top\n  // level down at twice the pace, rest on the whole triangle, and again.\n  if (P.phase === 0) {\n    P.lam += d / P.dur[min(P.n, floor(P.lam) + 1)];\n    if (P.lam >= P.n) (P.lam = P.n), (P.phase = 1), (P.hold = 0);\n  } else if (P.phase === 1) {\n    if ((P.hold += d) > 6) P.phase = 2;\n  } else if (P.phase === 2) {\n    P.lam -= (2 * d) / P.dur[cl(Math.ceil(P.lam), 1, P.n)];\n    if (P.lam \u003c= 0) (P.lam = 0), (P.phase = 3), (P.hold = 0);\n  } else if ((P.hold += d) > 1.2) P.phase = 0;\n  P.needle += d * 0.11;\n  P.fade = exp(-cl(dt || 0, 0, 0.1) / 0.12);\n}\n\n// One row of one sliver into the light buffer: the span [l, r) at row y.\n// A span under an LED wide is drawn one LED wide and dimmer, so the sprouts\n// taper in light rather than vanish between LEDs.\nfunction span(acc, y, l, r, cr, cg, cb) {\n  let wd = r - l, k = 1;\n  if (wd \u003c 1) {\n    const c = (l + r) / 2;\n    k = sqrt(max(wd, 0));\n    (l = c - 0.5), (r = c + 0.5), (wd = 1);\n  }\n  const x0 = max(0, floor(l)), x1 = min(W - 1, floor(r - 1e-6));\n  for (let x = x0, p = (y * W + x0) * 3; x \u003c= x1; x++, p += 3) {\n    const cov = (min(r, x + 1) - max(l, x)) * k;\n    if (cov \u003c= 0) continue;\n    acc[p] += cr * cov;\n    acc[p + 1] += cg * cov;\n    acc[p + 2] += cb * cov;\n  }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P) return;\n  const n = P.n, M = 1 \u003c\u003c n, w = BW / M, acc = P.acc, sh = P.sh, col = P.col;\n  acc.fill(0);\n  // How far each level has slid: level j runs while lam goes from j-1 to j.\n  let lo = 1e9, hi = -1e9;\n  for (let i = 0; i \u003c M; i++) {\n    let s = 0;\n    for (let j = 1; j \u003c= n; j++) if ((i >> (j - 1)) & 1) s -= P.tj[j] * sm(P.lam - (j - 1));\n    sh[i] = s;\n    lo = min(lo, s + i * w, s + BW / 2);\n    hi = max(hi, s + (i + 1) * w, s + BW / 2);\n  }\n  // Keep the whole figure centred as it slides.\n  const ox = W / 2 - (lo + hi) / 2;\n  // Each sliver's colour from its direction, the hue sweeping 0.8 of the wheel\n  // from one side of the triangle to the other.\n  // One sliver alone tones to about 140 of 255, two to 200, four near white.\n  for (let i = 0; i \u003c M; i++) hsv(P.hue + 0.5 + (0.8 * (i + 0.5)) / M, 0.85, 0.5, col, i * 3);\n  for (let y = Y0 - HT; y \u003c Y0; y++) {\n    const h = Y0 - (y + 0.5), f = h / HT;\n    if (f \u003c 0 || f > 1) continue;\n    for (let i = 0; i \u003c M; i++) {\n      const a = ox + sh[i] + BW / 2, l = ox + sh[i] + i * w, r = l + w;\n      span(acc, y, l + (a - l) * f, r + (a - r) * f, col[i * 3], col[i * 3 + 1], col[i * 3 + 2]);\n    }\n  }\n  // The needle: a segment the height of the triangle, swinging through every\n  // direction between its sides and back. Its direction picks the base point\n  // it stands on, and that point the sliver whose sprout holds it.\n  const sw = 0.5 - 0.5 * cos(P.needle * 2 * PI), b = sw * BW, i = min(M - 1, floor(b / w));\n  const bx = ox + sh[i] + b, ax = ox + sh[i] + BW / 2, tr = P.trail, fd = P.fade;\n  // Its light fades over about a tenth of a second, which softens each hop.\n  for (let p = 0; p \u003c N; p++) tr[p] *= fd;\n  for (let y = Y0 - HT; y \u003c Y0; y++) {\n    const h = Y0 - (y + 0.5), f = h / HT, x = bx + (ax - bx) * f;\n    for (let xx = max(0, floor(x - 2)); xx \u003c= min(W - 1, floor(x + 2)); xx++) {\n      const dd = abs(xx + 0.5 - x), wgt = dd \u003c 0.5 ? 1 : dd \u003c 1.5 ? 0.9 * (1.5 - dd) : 0.12 * (2.5 - dd), p = y * W + xx;\n      if (wgt > tr[p]) tr[p] = wgt;\n    }\n  }\n  for (let p = 0, q = 0; p \u003c N; p++, q += 3) {\n    const v = tr[p];\n    if (v \u003c 0.01) continue;\n    acc[q] += 1.6 * v;\n    acc[q + 1] += 1.55 * v;\n    acc[q + 2] += 1.4 * v;\n  }\n  // A soft glow round everything bright: a 5 by 5 blur, about a fifth of it\n  // added back, so the thin sprouts read from a few metres away.\n  const blo = P.blo;\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0, p = y * W * 3; x \u003c W; x++, p += 3)\n      for (let c = 0; c \u003c 3; c++) blo[p + c] = (x > 1 ? acc[p + c - 6] : 0) + 2 * (x > 0 ? acc[p + c - 3] : 0) + 3 * acc[p + c] + 2 * (x \u003c W - 1 ? acc[p + c + 3] : 0) + (x \u003c W - 2 ? acc[p + c + 6] : 0);\n  // Overlaps add up: light piles toward white where many slivers cross.\n  const R = W * 3, tone = (q, y) => {\n    const g = (y > 1 ? blo[q - 2 * R] : 0) + 2 * (y > 0 ? blo[q - R] : 0) + 3 * blo[q] + 2 * (y \u003c H - 1 ? blo[q + R] : 0) + (y \u003c H - 2 ? blo[q + 2 * R] : 0);\n    return 255 * (1 - exp(-1.6 * (acc[q] + GLOW * g)));\n  };\n  for (let p = 0, y = 0; y \u003c H; y++) for (let x = 0; x \u003c W; x++, p += 3) display.setPixel(x, y, tone(p, y), tone(p + 1, y), tone(p + 2, y));\n}\n","figure-eight-orbit":"// ===== Patternflow pattern =====\n// Title:   Figure-Eight Orbit\n// Family:  physics\n// Idea:    Three equal masses under Newton's gravity chase one another round one figure eight standing the height of the panel, each a third of a period behind the next, integrated step by step from Chenciner and Montgomery's starting values with a faint line of the exact eight under them, and a kick to their starting velocities leaves the eight wobbling or breaks it into a tight binary and a body flung off the panel.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: figure-eight solution of the three-body problem (Cris Moore, 1993; Alain Chenciner and Richard Montgomery, 2000), pattern round 38\n// Round:   38\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Trail=0.33..2, Kick=0..1\n//\n// Knob 1: Hue. Turns the three bodies round the wheel together, a third of the wheel apart. At 0 azure, rose and lime; at 0.25 magenta, butter yellow and cyan; at 0.5 peach, sea green and violet; at 0.75 green, blue and red. A body that comes round to orange or yellow is paled and its tail kept near full brightness, so it never reads brown or olive.\n// Knob 2: Speed. At 2 one period of the eight, 6.33 units of the orbit's own time, takes 6.3 seconds, and a body runs up to 67 LEDs a second through the crossing and slows to 25 at the far ends; at 0.2 a period takes 63 seconds, at 3 it takes 4.2.\n// Knob 3: Trail. How long each tail is, in periods; a tail is 8 LEDs wide at its body and narrows to nothing at its end. At 0.33 each tail ends just at the next body, so the eight is three comets in three colours; from 1 the whole eight is drawn, each stretch in the colour of the body that passed it last; with a kick the older passes show under the newest, a band of eights 2 periods deep at 2.\n// Knob 4: Kick. Pushes bodies 1 and 2 apart along the line between them at the start, then scales every velocity back to the old kinetic energy, so energy, momentum and angular momentum stay those of the eight. Up to 0.06 no kick: the exact eight, its energy within 1e-8 of the start for 200 periods. At 0.25 a push of 0.07, 5% of the fastest speed, and the eight wobbles; at 0.5 (0.18) it swings wide but holds; from about 0.65 (0.25) it holds a few periods and then two bodies pair off and the third is slung away; at 1 (0.45) a body leaves the panel in the first tenth of a period. The push keeps the symmetry of the starting line-up, which is why the eight survives so much of it. The three start again after a body has been off the panel 3 seconds, and 0.4 seconds after the knob comes to rest.\n// Buttons: K1 tap nudges the running orbit: two bodies pushed apart by 0.05, or by the Kick if that is more, a different pair on each tap. Away from the starting line-up the eight is far less forgiving: one tap leaves it wobbling for a minute or more before it breaks, three taps a second apart break it in about 20 seconds.\n\nconst W = 64, H = 128, N = W * H;\nconst { floor, min, max, sqrt, abs, hypot, round, cbrt, exp } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\nconst sm = (a, b, v) => {\n  const t = cl((v - a) / (b - a), 0, 1);\n  return t * t * (3 - 2 * t);\n};\n\nfunction hsv(h, s, v, out) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[0] = [v, q, p, p, t, v][i];\n  out[1] = [t, v, v, q, p, p][i];\n  out[2] = [p, p, t, v, v, q][i];\n}\n\n// Chenciner and Montgomery's starting values, G = m = 1: body 3 at the\n// crossing, bodies 1 and 2 opposite each other, both moving at half body 3's\n// velocity the other way. The period is 6.32591398.\nconst X1 = 0.97000436, Y1 = -0.24308753, VX3 = -0.93240737, VY3 = -0.86473146, PERIOD = 6.32591398;\n// Orbit to panel: the eight's long axis down the panel, SC LEDs to the unit.\n// It reaches 1.081 along that axis and 0.358 across, so 115 by 38 LEDs.\nconst SC = 53, CX = 31.5, CY = 63.5;\n// Under RS the pull is that of a uniform ball, so a close pass of a binary\n// stays finite. The eight never comes closer than 0.69, so it never feels it.\nconst RS = 0.05;\n// Step in orbit time: Yoshida's fourth-order leapfrog at H0, shortened by\n// (r / 0.5)^1.5 when two bodies are closer than 0.5.\nconst H0 = 1 / 128;\nconst YW1 = 1 / (2 - cbrt(2)), YW0 = -cbrt(2) * YW1;\nconst YC = [YW1 / 2, (YW0 + YW1) / 2, (YW0 + YW1) / 2, YW1 / 2], YD = [YW1, YW0, YW1];\n// Tail half-width at the head, in LEDs, and how far a body glows.\nconst HW = 3.6, GLOW = 6;\n// Opening hues: azure, rose, lime.\nconst HUE0 = 0.58;\n// Longest tail, in periods, and so the history the pattern keeps.\nconst LMAX = 2;\n\nexport function setup(params) {\n  params.s = {\n    hue: 0, speed: 2, trail: 0.33, kick: 0, kickSet: -1, kickWait: 0, begun: false,\n    p: new Float64Array(6), v: new Float64Array(6), a: new Float64Array(6),\n    clock: 0, carry: 0, out: 0, fade: 1, phase: 0, nudges: 0,\n    // Per body and LED: when the body last passed (orbit time) and how close.\n    tv: new Float32Array(3 * N).fill(-1e9), td: new Float32Array(3 * N).fill(99),\n    lx: new Float32Array(3), ly: new Float32Array(3), warm: [0, 0, 0],\n    ref: new Float32Array(N), col: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],\n  };\n  drawReference(params.s);\n}\n\n// Pull on each body; under RS the force grows linearly from the centre.\nfunction accel(p, a) {\n  a.fill(0);\n  for (let i = 0; i \u003c 3; i++)\n    for (let j = i + 1; j \u003c 3; j++) {\n      const dx = p[2 * j] - p[2 * i], dy = p[2 * j + 1] - p[2 * i + 1], r = sqrt(dx * dx + dy * dy), q = max(r, RS);\n      const f = 1 / (q * q * q);\n      a[2 * i] += dx * f;\n      a[2 * i + 1] += dy * f;\n      a[2 * j] -= dx * f;\n      a[2 * j + 1] -= dy * f;\n    }\n}\n\nfunction closest(p) {\n  let m = 1e9;\n  for (let i = 0; i \u003c 3; i++)\n    for (let j = i + 1; j \u003c 3; j++) m = min(m, hypot(p[2 * j] - p[2 * i], p[2 * j + 1] - p[2 * i + 1]));\n  return m;\n}\n\n// One step of Yoshida's fourth-order symplectic integrator: three leapfrogs\n// of h w1, h w0, h w1, with w0 negative.\nfunction step(p, v, a, h) {\n  for (let s = 0; s \u003c 3; s++) {\n    for (let i = 0; i \u003c 6; i++) p[i] += YC[s] * h * v[i];\n    accel(p, a);\n    for (let i = 0; i \u003c 6; i++) v[i] += YD[s] * h * a[i];\n  }\n  for (let i = 0; i \u003c 6; i++) p[i] += YC[3] * h * v[i];\n}\n\nconst stepLength = (p) => H0 * min(1, (max(closest(p), RS) / 0.5) ** 1.5);\n\n// The kick: bodies i and j pushed apart along the line between them, each\n// by eps, and then every velocity scaled back to the kinetic energy before\n// the push. Positions do not move, so the energy stays what it was; the\n// momentum stays zero and the angular momentum stays zero too, as for the\n// eight itself, so only the shape of the motion changes.\nfunction push(S, i, j, eps) {\n  const { p, v } = S, dx = p[2 * i] - p[2 * j], dy = p[2 * i + 1] - p[2 * j + 1], r = hypot(dx, dy) || 1;\n  let k0 = 0, k1 = 0;\n  for (let n = 0; n \u003c 6; n++) k0 += v[n] * v[n];\n  v[2 * i] += (eps * dx) / r;\n  v[2 * i + 1] += (eps * dy) / r;\n  v[2 * j] -= (eps * dx) / r;\n  v[2 * j + 1] -= (eps * dy) / r;\n  for (let n = 0; n \u003c 6; n++) k1 += v[n] * v[n];\n  const f = sqrt(k0 / k1);\n  for (let n = 0; n \u003c 6; n++) v[n] *= f;\n}\n\n// Kick 0..1 to eps: nothing up to 0.06, then up to 0.45.\nconst epsOf = (k) => 0.45 * (max(0, k - 0.06) / 0.94) ** 1.2;\n\nfunction initial(S) {\n  const { p, v } = S;\n  p.set([X1, Y1, -X1, -Y1, 0, 0]);\n  v.set([-VX3 / 2, -VY3 / 2, -VX3 / 2, -VY3 / 2, VX3, VY3]);\n  push(S, 0, 1, epsOf(S.kick));\n  S.kickSet = S.kick;\n}\n\nconst toCol = (y) => CX + y * SC, toRow = (x) => CY - x * SC;\n\n// A tail at an LED: age a in orbit time, distance d in LEDs, tail length L.\n// It narrows from HW at the head to nothing at its end, and dims from full\n// at the head to 0.6 a third of a period behind it and 0.55 after that.\nfunction tailCover(a, d, L) {\n  if (a \u003c 0 || a >= L) return 0;\n  return cl((HW + 0.5) * (1 - a / L) ** 1.5 - d + 0.5, 0, 1);\n}\nconst tailBright = (a) => 0.55 + 0.45 * exp(-a / (0.15 * PERIOD));\nconst tailValue = (a, d, L) => tailCover(a, d, L) * tailBright(a);\n\n// Mark the LEDs round body k at orbit time t. Within one pass the closest\n// approach is kept; a later pass takes the LED when it would light it more.\nfunction deposit(S, k, t) {\n  const bx = toCol(S.p[2 * k + 1]), by = toRow(S.p[2 * k]), R = HW + 1.5, L = LMAX * PERIOD;\n  if (bx \u003c -R || bx > W + R || by \u003c -R || by > H + R) return;\n  const o = k * N, tv = S.tv, td = S.td;\n  for (let y = max(0, floor(by - R)); y \u003c= min(H - 1, floor(by + R)); y++)\n    for (let x = max(0, floor(bx - R)); x \u003c= min(W - 1, floor(bx + R)); x++) {\n      const d = hypot(x + 0.5 - bx, y + 0.5 - by);\n      if (d > R) continue;\n      const q = o + y * W + x, t0 = tv[q];\n      if (abs(t - t0) \u003c 0.3) {\n        if (d \u003c td[q]) {\n          tv[q] = t;\n          td[q] = d;\n        }\n        continue;\n      }\n      const ref = max(t, t0), vNew = tailValue(ref - t, d, L), vOld = tailValue(ref - t0, td[q], L);\n      if (vNew > vOld || (vNew === vOld && t > t0)) {\n        tv[q] = t;\n        td[q] = d;\n      }\n    }\n}\n\n// Deposit body k if it has moved half an LED since it last did.\nfunction trace(S, t) {\n  for (let k = 0; k \u003c 3; k++) {\n    const bx = toCol(S.p[2 * k + 1]), by = toRow(S.p[2 * k]);\n    if (hypot(bx - S.lx[k], by - S.ly[k]) \u003c 0.5) continue;\n    S.lx[k] = bx;\n    S.ly[k] = by;\n    deposit(S, k, t);\n  }\n}\n\nconst farthest = (p) => max(hypot(p[0], p[1]), hypot(p[2], p[3]), hypot(p[4], p[5]));\n\n// Start (or start again): the starting line-up with the current kick, and\n// its own past drawn behind it by running the orbit backward for up to LMAX\n// periods, or until a body would come in from off the panel.\nfunction restart(S) {\n  S.tv.fill(-1e9);\n  S.td.fill(99);\n  S.clock = 0;\n  S.carry = 0;\n  S.out = 0;\n  initial(S);\n  const { p, v, a } = S;\n  const p0 = Float64Array.from(p), v0 = Float64Array.from(v);\n  S.lx.fill(-99);\n  S.ly.fill(-99);\n  let t = 0;\n  while (t > -LMAX * PERIOD && farthest(p) \u003c 1.4) {\n    trace(S, t);\n    const h = stepLength(p);\n    step(p, v, a, -h);\n    t -= h;\n  }\n  p.set(p0);\n  v.set(v0);\n  S.lx.fill(-99);\n  S.ly.fill(-99);\n  trace(S, 0);\n}\n\n// Whole steps only, the remainder carried to the next frame, so at the\n// opening the step never changes and the integrator stays symplectic.\nfunction advance(S, dt) {\n  const { p, v, a } = S;\n  S.carry += dt;\n  for (let h = stepLength(p); S.carry >= h; h = stepLength(p)) {\n    step(p, v, a, h);\n    S.carry -= h;\n    S.clock += h;\n    trace(S, S.clock);\n  }\n}\n\n// The exact eight, sampled over one period, as a faint line under the tails.\nfunction drawReference(S) {\n  const p = Float64Array.from([X1, Y1, -X1, -Y1, 0, 0]);\n  const v = Float64Array.from([-VX3 / 2, -VY3 / 2, -VX3 / 2, -VY3 / 2, VX3, VY3]), a = new Float64Array(6);\n  const n = 1600, h = PERIOD / n, ref = S.ref;\n  for (let s = 0; s \u003c n; s++) {\n    const bx = toCol(p[1]), by = toRow(p[0]);\n    for (let y = max(0, floor(by - 1)); y \u003c= min(H - 1, floor(by + 1)); y++)\n      for (let x = max(0, floor(bx - 1)); x \u003c= min(W - 1, floor(bx + 1)); x++) {\n        const c = cl(1.1 - hypot(x + 0.5 - bx, y + 0.5 - by), 0, 1);\n        if (c > ref[y * W + x]) ref[y * W + x] = c;\n      }\n    step(p, v, a, h);\n  }\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const S = params.s, k = input.knobValues || [0, 2, 0.33, 0.06], d = cl(dt || 0, 0, 0.1);\n  S.hue = k[0];\n  S.speed = cl(k[1], 0.2, 3);\n  S.trail = cl(k[2], 0.33, 2);\n  S.kick = cl(k[3], 0, 1);\n  if (!S.begun) {\n    restart(S);\n    S.begun = true;\n  }\n  // A turned Kick starts the three again once the knob has rested 0.4 s,\n  // fading the old orbit out over 0.5 s and the new one in.\n  if (abs(S.kick - S.kickSet) > 0.004) {\n    S.kickWait += d;\n    if (S.kickWait > 0.4 && S.phase === 0) S.phase = -1;\n  } else S.kickWait = 0;\n  if (input.btnPressed && input.btnPressed[0] && S.phase === 0) {\n    const pair = S.nudges++ % 3;\n    push(S, pair, (pair + 1) % 3, max(0.05, epsOf(S.kick)));\n  }\n  // At Speed 2 the orbit's clock runs 1 unit a second.\n  advance(S, d * S.speed * 0.5);\n  // Off the panel: a body more than 1.35 from the centre.\n  if (farthest(S.p) > 1.35) S.out += d;\n  else S.out = max(0, S.out - d);\n  if ((S.out > 3 || farthest(S.p) > 8) && S.phase === 0) S.phase = -1;\n  if (S.phase \u003c 0) {\n    S.fade -= d / 0.5;\n    if (S.fade \u003c= 0) {\n      S.fade = 0;\n      restart(S);\n      S.kickWait = 0;\n      S.phase = 1;\n    }\n  } else if (S.phase > 0) {\n    S.fade += d / 0.5;\n    if (S.fade >= 1) {\n      S.fade = 1;\n      S.phase = 0;\n    }\n  }\n}\n\nfunction palette(S) {\n  for (let k = 0; k \u003c 3; k++) {\n    const h = S.hue + HUE0 + k / 3, hh = h - floor(h);\n    // Orange to yellow-green: paler and kept at full value, so a tail never\n    // reads brown or olive.\n    const warm = sm(0.02, 0.08, hh) * (1 - sm(0.2, 0.27, hh));\n    hsv(h, 0.85 - 0.3 * warm, 1, S.col[k]);\n    S.warm[k] = warm;\n  }\n}\n\nexport function draw(display, params) {\n  const S = params.s;\n  if (!S) return;\n  palette(S);\n  const { tv, td, ref, col, clock, fade } = S, L = S.trail * PERIOD;\n  const bx = [0, 0, 0], by = [0, 0, 0];\n  for (let k = 0; k \u003c 3; k++) {\n    bx[k] = toCol(S.p[2 * k + 1]);\n    by[k] = toRow(S.p[2 * k]);\n  }\n  const ord = [0, 1, 2], ag = [0, 0, 0];\n  for (let y = 0; y \u003c H; y++)\n    for (let x = 0; x \u003c W; x++) {\n      const p = y * W + x;\n      // The faint reference eight, then the tails painted oldest first, so\n      // the newest pass lies on top.\n      let r = 0.13 * ref[p], g = 0.13 * ref[p], b = 0.16 * ref[p];\n      for (let k = 0; k \u003c 3; k++) ag[k] = clock - tv[k * N + p];\n      ord[0] = 0;\n      ord[1] = 1;\n      ord[2] = 2;\n      if (ag[ord[0]] \u003c ag[ord[1]]) [ord[0], ord[1]] = [ord[1], ord[0]];\n      if (ag[ord[1]] \u003c ag[ord[2]]) [ord[1], ord[2]] = [ord[2], ord[1]];\n      if (ag[ord[0]] \u003c ag[ord[1]]) [ord[0], ord[1]] = [ord[1], ord[0]];\n      for (let n = 0; n \u003c 3; n++) {\n        const k = ord[n], age = ag[k], d = td[k * N + p], al = tailCover(age, d, L) * fade;\n        if (al \u003c= 0) continue;\n        const c = col[k], lv = 1 - (1 - tailBright(age)) * (1 - 0.8 * S.warm[k]), wh = 0.5 * (1 - age / L) ** 8 * cl(1 - d / HW, 0, 1);\n        r += ((c[0] + (1 - c[0]) * wh) * lv - r) * al;\n        g += ((c[1] + (1 - c[1]) * wh) * lv - g) * al;\n        b += ((c[2] + (1 - c[2]) * wh) * lv - b) * al;\n      }\n      // The bodies: a white core in a glow of the body's colour.\n      for (let k = 0; k \u003c 3; k++) {\n        const dx = x + 0.5 - bx[k], dy = y + 0.5 - by[k], d2 = dx * dx + dy * dy;\n        if (d2 >= GLOW * GLOW) continue;\n        const dd = sqrt(d2), halo = 0.7 * fade * (1 - dd / GLOW) ** 1.5, core = sm(2.8, 1.4, dd) * fade, c = col[k];\n        r = 1 - (1 - r) * (1 - c[0] * halo);\n        g = 1 - (1 - g) * (1 - c[1] * halo);\n        b = 1 - (1 - b) * (1 - c[2] * halo);\n        r += (1 - r) * core;\n        g += (1 - g) * core;\n        b += (1 - b) * core;\n      }\n      display.setPixel(x, y, round(255 * min(1, r)), round(255 * min(1, g)), round(255 * min(1, b)));\n    }\n}\n\n","kdv-solitons":"// ===== Patternflow pattern =====\n// Title:   KdV Solitons\n// Family:  wave\n// Idea:    Zabusky and Kruskal's numerical experiment as a space-time diagram falling down the panel: the top row is the wave now, a cosine that steepens, nearly breaks and splits into a train of solitons, each a bright ridge whose slant is its speed, the tall fast ones passing through the small slow ones with a sideways jog, until the whole train pinches back together into the cosine and fans out again.\n// Author:  patternflow-lab\n// Date:    2026-10-24\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: solitons of the Korteweg-de Vries equation (Norman Zabusky and Martin Kruskal, 1965), pattern round 31\n// Round:   31\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Speed=0.2..3, Dispersion=0..1, Start=0..1\n//\n// Knob 1: Hue. Turns the crest colour round the wheel; at 0 the crests are cyan over indigo troughs and the tallest go pale.\n// Knob 2: Speed. How fast the equation runs and the diagram falls: at 2 the cosine breaks after half a second, the panel holds the last five seconds and the train gathers back into the cosine after sixteen; at 0.2 everything is ten times slower.\n// Knob 3: Dispersion. The delta of the equation, 0.022 at 0 as in the 1965 paper, giving eight thin solitons; turned up to 0.06 at 1 the cosine breaks into three wide ones and gathers back almost three times as often.\n// Knob 4: Start. The wave each run starts from: the cosine of the paper, two humps of unequal height, a flat plateau whose front edge breaks into a ranked train, or a random sum of five cosines drawn fresh each run.\n// Buttons: K1 tap drops a tall sech-squared soliton into the lowest trough of the wave, a pale ridge that races through the whole train.\n\nconst W = 64, H = 128;\nconst { min, max, floor, abs, sqrt, cos, sin, exp, tanh, cosh, atan2, round, PI } = Math;\nconst cl = (v, a, b) => (v \u003c a ? a : v > b ? b : v);\n\n// The equation u_t + u u_x + delta^2 u_xxx = 0 on a ring of length 2, held on\n// 256 points, four to an LED column.\nconst NX = 256, MK = NX - 1, DX = 2 / NX, SUB = NX / W;\n// Rows of the diagram per unit of time, and history rows kept.\nconst RPT = 40, HR = H + 2;\n// Robert-Asselin filter on the leapfrog's middle level: it damps the\n// odd-even mode that otherwise grows to overflow after about five time units,\n// and takes under one percent off a soliton over a whole run.\nconst NU = 0.001;\n// Colour table over the height above the troughs, from UL to UH.\nconst NL = 512, UL = -0.5, UH = 5;\n\nfunction hsv(h, s, v, out, o) {\n  h = (h - floor(h)) * 6;\n  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);\n  out[o] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;\n  out[o + 1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;\n  out[o + 2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;\n}\n\n// Dark troughs, the crest hue at the top of a soliton, pale at the very top.\n// Below the crest the hue leans away round the wheel, so the small solitons\n// and the ripples between read as deeper water rather than a dim copy of the\n// crests. A dim orange or yellow reads brown or olive, so for crests from\n// pink round to yellow the lean runs the other way, through violet,\n// magenta and red, and only the brightest tones reach the crest hue; the two\n// leans meet at a yellow green, where the middle tones change side.\nconst LH = [0, 0.08, 0.17, 0.27, 0.27, 0.33, 0.5, 0.67, 0.83, 0.92, 1];\nconst LL = [-0.3, -0.36, -0.42, -0.47, 0.53, 0.15, 0.12, 0.12, 0, -0.2, -0.3];\nfunction lean(h) {\n  h -= floor(h);\n  for (let i = 1; i \u003c LH.length; i++) if (h \u003c= LH[i] && LH[i] > LH[i - 1]) return LL[i - 1] + ((LL[i] - LL[i - 1]) * (h - LH[i - 1])) / (LH[i] - LH[i - 1]);\n  return LL[0];\n}\nfunction palette(P) {\n  const t = P.lut, h0 = P.hue + 0.5, L = lean(h0);\n  for (let i = 0; i \u003c NL; i++) {\n    const e = UL + ((UH - UL) * i) / (NL - 1);\n    const v = cl(e / 2.5, 0, 1), w = cl((e - 2.1) / 1.4, 0, 1), q = cl((e - 0.3) / 1.9, 0, 1);\n    hsv(h0 + L * (1 - q) ** 0.6, 0.9 - 0.8 * w * w, 0.04 + 0.96 * v ** 1.15, t, i * 3);\n  }\n  P.lutHue = P.hue;\n}\n\n// du/dt at point i in the scheme's own differences.\nfunction rhs(u, i, d2) {\n  const m2 = u[(i - 2) & MK], m1 = u[(i - 1) & MK], z = u[i], p1 = u[(i + 1) & MK], p2 = u[(i + 2) & MK];\n  return -((p1 + z + m1) * (p1 - m1)) / (6 * DX) - (d2 * (p2 - 2 * p1 + 2 * m1 - m2)) / (2 * DX * DX * DX);\n}\n\n// Leapfrog is stable while dt times the largest rate of the linear scheme\n// stays under 1: |u|/dx for the u u_x term and 2.6 delta^2/dx^3 for the\n// third derivative (its worst wave is three grid cells long). A new dt, or a\n// new wave, starts the leapfrog again with one step back by Euler.\nfunction restartLeap(P) {\n  const d2 = P.delta * P.delta;\n  P.dt = 0.85 / (P.umax / DX + (2.6 * d2) / (DX * DX * DX));\n  const a = P.ua, b = P.ub;\n  for (let i = 0; i \u003c NX; i++) a[i] = b[i] - P.dt * rhs(b, i, d2);\n}\n\n// A starting wave into out, mean zero. Places and heights for the humps,\n// the plateau and the random sum are drawn fresh each run.\nfunction makeWave(P, kind, phase, out) {\n  const R = P.rnd;\n  if (kind) {\n    R[0] = Math.random() * 2;\n    R[1] = R[0] + 0.7 + Math.random() * 0.6;\n    R[2] = 1.05 + Math.random() * 0.3;\n    R[3] = 0.6 + Math.random() * 0.3;\n    for (let k = 1; k \u003c= 5; k++) (R[3 + k] = (0.3 + Math.random()) / k), (R[8 + k] = Math.random() * 2 * PI);\n  }\n  for (let i = 0; i \u003c NX; i++) {\n    const x = i * DX;\n    let v = 0;\n    if (kind === 0) v = cos(PI * (x - phase));\n    else if (kind === 1) {\n      // Two humps, about 1.2 and 0.75 high.\n      const d1 = ((x - R[0] + 3) % 2) - 1, d2 = ((x - R[1] + 3) % 2) - 1;\n      v = R[2] * exp(-((d1 / 0.3) ** 2)) + R[3] * exp(-((d2 / 0.22) ** 2));\n    } else if (kind === 2) {\n      // A plateau 1.1 high and 0.8 wide with soft edges.\n      const d = ((x - R[0] + 3) % 2) - 1;\n      v = 0.55 * (tanh((d + 0.4) / 0.05) - tanh((d - 0.4) / 0.05));\n    } else for (let k = 1; k \u003c= 5; k++) v += R[3 + k] * cos(PI * k * x + R[8 + k]);\n    out[i] = v;\n  }\n  let s = 0, mx = 0;\n  for (let i = 0; i \u003c NX; i++) s += out[i];\n  s /= NX;\n  for (let i = 0; i \u003c NX; i++) mx = max(mx, abs((out[i] -= s)));\n  // The random sum peaks at 1, like the cosine.\n  if (kind === 3) for (let i = 0; i \u003c NX; i++) out[i] /= mx;\n}\n\nfunction begin(P, kind) {\n  P.ub.set(P.tg);\n  P.kind = kind;\n  P.tau = 0;\n  P.rec = 0;\n  P.drops = 0;\n  P.umax = 3;\n  restartLeap(P);\n}\n\n// The wave into one row of 64 columns as height above the troughs: a\n// little more than half the brightest of a column's four points and the\n// rest their mean, so a thin crest keeps its peak. The trough level follows\n// the lowest point of the wave over about a quarter time unit; it is -1 for\n// the cosine and sinks to about -0.7 once the solitons have taken their mass.\nfunction sample(P, out, o) {\n  const u = P.ub, bg = P.bg;\n  for (let c = 0, i = 0; c \u003c W; c++) {\n    let mx = -9, s = 0;\n    for (let k = 0; k \u003c SUB; k++, i++) {\n      const v = u[i];\n      s += v;\n      if (v > mx) mx = v;\n    }\n    out[o + c] = 0.55 * mx + (0.45 * s) / SUB - bg;\n  }\n}\n\n// The share of the wave's energy in the first cosine mode, 1 for the cosine\n// itself, and where that mode's crest stands.\nfunction mode1(P) {\n  const u = P.ub;\n  let c1 = 0, s1 = 0, e = 0;\n  for (let i = 0; i \u003c NX; i++) {\n    const a = PI * i * DX;\n    c1 += u[i] * cos(a);\n    s1 += u[i] * sin(a);\n    e += u[i] * u[i];\n  }\n  P.phase = atan2(s1, c1) / PI;\n  return (2 * (c1 * c1 + s1 * s1)) / (NX * e + 1e-9);\n}\n\n// A soliton 4.4 high over the trough, in the lowest stretch of the wave. Its\n// mass is taken evenly off the rest so the mean stays zero, and the older\n// leapfrog level gets it one step back along its path.\nfunction drop(P) {\n  const u = P.ub, a = P.ua;\n  let best = 99, at = 0;\n  for (let i = 0; i \u003c NX; i += 4) {\n    let s = 0;\n    for (let k = -12; k \u003c= 12; k++) s += u[(i + k) & MK];\n    if (s \u003c best) (best = s), (at = i);\n  }\n  const A = 4.4, w = P.delta * sqrt(12 / A), c = best / 25 + A / 3;\n  for (let pass = 0; pass \u003c 2; pass++) {\n    const tgt = pass ? a : u, back = pass ? c * P.dt : 0;\n    let m = 0;\n    for (let i = 0; i \u003c NX; i++) {\n      const d = ((((i - at) * DX + back + 3) % 2) - 1) / w;\n      m += P.uc[i] = A / cosh(d) ** 2;\n    }\n    for (let i = 0; i \u003c NX; i++) tgt[i] += P.uc[i] - m / NX;\n    if (!pass) P.bg -= m / NX;\n  }\n}\n\nfunction step(P, n) {\n  const d2 = P.delta * P.delta, k1 = P.dt / (3 * DX), k2 = (d2 * P.dt) / (DX * DX * DX);\n  for (let s = 0; s \u003c n; s++) {\n    const a = P.ua, b = P.ub, c = P.uc;\n    for (let i = 0; i \u003c NX; i++) {\n      const m2 = b[(i - 2) & MK], m1 = b[(i - 1) & MK], z = b[i], p1 = b[(i + 1) & MK], p2 = b[(i + 2) & MK];\n      c[i] = a[i] - k1 * (p1 + z + m1) * (p1 - m1) - k2 * (p2 - 2 * p1 + 2 * m1 - m2);\n    }\n    for (let i = 0; i \u003c NX; i++) b[i] += NU * (a[i] - 2 * b[i] + c[i]);\n    P.ua = b;\n    P.ub = c;\n    P.uc = a;\n  }\n}\n\nexport function setup(params) {\n  params.s = {\n    ua: new Float64Array(NX), ub: new Float64Array(NX), uc: new Float64Array(NX), tg: new Float64Array(NX),\n    hist: new Float32Array(HR * W), now: new Float32Array(W), head: 0, frac: 0,\n    lut: new Float32Array(NL * 3), lutHue: -1, hue: 0, speed: 2, delta: 0.022,\n    dt: 1e-4, umax: 3, tau: 0, kind: -1, want: 0, wantT: 0, rnd: new Float64Array(14),\n    f1: 0, rising: 0, rec: 0, phase: 1, reform: -1, toKind: 0, rem: 1, rlen: 1, bg: -1, drops: 0,\n  };\n}\n\n// One row of time has passed: store it, keep dt safe, and watch for the\n// moment to start a new run.\nfunction row(P) {\n  const u = P.ub;\n  let um = 0, lo = 9, bad = false;\n  for (let i = 0; i \u003c NX; i++) {\n    const v = u[i];\n    if (!(v === v) || abs(v) > 40) bad = true;\n    else if (abs(v) > um) um = abs(v);\n    if (v \u003c lo) lo = v;\n  }\n  if (bad) return makeWave(P, P.kind, 1, P.tg), begin(P, P.kind);\n  P.bg += (lo - P.bg) * 0.1;\n  P.head = (P.head + HR - 1) % HR;\n  sample(P, P.hist, P.head * W);\n  // A taller wave than dt was set for: a smaller dt, from here.\n  if (um > 0.9 * P.umax) (P.umax = um * 1.4), restartLeap(P);\n  const f = mode1(P), Tr = 0.21 / P.delta, rowT = 1 / RPT;\n  // Each time the train gathers back, the energy flows into the first mode\n  // and out again; a peak of that share over 0.6 is one return.\n  if (f > P.f1) P.rising = 1;\n  else if (P.rising && P.f1 > 0.6 && P.tau > 0.5 * Tr) (P.rising = 0), P.rec++;\n  else P.rising = 0;\n  P.f1 = f;\n  if (P.reform \u003c 0) {\n    // The cosine runs through one return and is drawn back onto an exact\n    // cosine at the second, where the returning one stands; other starts,\n    // and runs a dropped soliton keeps from returning, start a fresh wave\n    // after about as long.\n    if (P.kind === 0 ? P.rec >= 1 && P.rising && f > 0.55 : P.tau > 1.2 * Tr) newRun(P, P.kind, P.kind ? 1 : 0.4);\n    else if (P.tau > 2.6 * Tr) newRun(P, P.kind, 1);\n  }\n  if (P.reform >= 0) {\n    // Both leapfrog levels are drawn over to the new wave, the cosine target\n    // following the returning crest, so that what is left of the old wave\n    // falls along a smoothstep; then the run starts from the new one exactly.\n    const r = (P.reform = min(1, P.reform + rowT / P.rlen)), rem = 1 - r * r * (3 - 2 * r), g = P.rem > 0 ? 1 - rem / P.rem : 1;\n    P.rem = rem;\n    if (P.toKind === 0) for (let i = 0; i \u003c NX; i++) P.tg[i] = cos(PI * (i * DX - P.phase));\n    for (let i = 0; i \u003c NX; i++) (u[i] += (P.tg[i] - u[i]) * g), (P.ua[i] += (P.tg[i] - P.ua[i]) * g);\n    if (r >= 1) (P.reform = -1), begin(P, P.toKind);\n  }\n}\n\n// A new run toward a wave of this kind, drawn over in len time units: 0.4\n// for the cosine coming back to itself, a whole unit for a different wave.\nfunction newRun(P, kind, len) {\n  P.reform = 0;\n  P.rem = 1;\n  P.rlen = len;\n  P.toKind = kind;\n  makeWave(P, kind, P.phase, P.tg);\n}\n\nexport function update(dt, input, params) {\n  if (!params.s) setup(params);\n  const P = params.s, k = input.knobValues || [0, 2, 0, 0.06], d = cl(dt || 0, 0, 0.1);\n  P.hue = cl(k[0], 0, 1);\n  P.speed = cl(k[1], 0.2, 3);\n  // Delta from 0.022 to 0.06 on a log scale.\n  const delta = 0.022 * (0.06 / 0.022) ** cl(k[2], 0, 1);\n  const kind = min(3, floor(cl(k[3], 0, 1) * 4));\n  if (abs(delta - P.delta) > 1e-6) (P.delta = delta), restartLeap(P);\n  if (P.kind \u003c 0) {\n    // Before the first frame the panel shows the starting wave as if it had\n    // been held still, so the diagram falls out of it.\n    makeWave(P, kind, 1, P.tg);\n    begin(P, kind);\n    P.bg = 9;\n    for (let i = 0; i \u003c NX; i++) P.bg = min(P.bg, P.ub[i]);\n    sample(P, P.hist, 0);\n    for (let r = 1; r \u003c HR; r++) P.hist.copyWithin(r * W, 0, W);\n  }\n  // A new Start is taken once the knob has rested on it a quarter second,\n  // and the wave is drawn over into it like any new run.\n  if (kind === (P.reform >= 0 ? P.toKind : P.kind)) P.wantT = 0;\n  else {\n    if (kind !== P.want) (P.want = kind), (P.wantT = 0);\n    if ((P.wantT += d) > 0.25) newRun(P, kind, 1);\n  }\n  const b = input.btnPressed || [];\n  // Four drops a run at most; past that the train is lost in white.\n  if (b[0] && P.drops \u003c 4) P.drops++, drop(P);\n\n  // 0.6 time units a second at Speed 2; the cosine breaks at 1/pi.\n  let left = d * P.speed * 0.3;\n  const rowT = 1 / RPT;\n  while (left > 1e-12) {\n    const run = min(left, (1 - P.frac) * rowT);\n    step(P, min(4000, max(1, round(run / P.dt))));\n    P.tau += run;\n    left -= run;\n    P.frac += run / rowT;\n    if (P.frac >= 1 - 1e-9) (P.frac = 0), row(P);\n  }\n}\n\nexport function draw(display, params) {\n  const P = params.s;\n  if (!P || P.kind \u003c 0) return;\n  if (P.lutHue !== P.hue) palette(P);\n  const now = P.now, hist = P.hist, lut = P.lut, f = P.frac, sc = (NL - 1) / (UH - UL);\n  sample(P, now, 0);\n  for (let y = 0; y \u003c H; y++) {\n    // Row y is the wave y rows of time ago. The newest stored row is f rows\n    // old; the top row is the wave now.\n    let ra = hist, ia, ib, w;\n    if (y \u003c= f) (ra = now), (ia = 0), (ib = P.head * W), (w = f > 0 ? y / f : 0);\n    else {\n      const kk = floor(y - f);\n      ia = ((P.head + kk) % HR) * W;\n      ib = ((P.head + kk + 1) % HR) * W;\n      w = y - f - kk;\n    }\n    for (let x = 0; x \u003c W; x++) {\n      const u = ra[ia + x] + (hist[ib + x] - ra[ia + x]) * w;\n      const o = cl(round((u - UL) * sc), 0, NL - 1) * 3;\n      display.setPixel(x, y, lut[o], lut[o + 1], lut[o + 2]);\n    }\n  }\n}\n","bokeh":"// ===== Patternflow pattern =====\n// Title:   Bokeh\n// Family:  light\n// Idea:    A city at night with the lens left out of focus, so every lamp turns into a disc the shape of the iris.\n// Author:  patternflow-lab\n// Date:    2026-10-22\n// SPDX-License-Identifier: CC-BY-SA-4.0\n// Lineage: original, pattern study 2026-10\n// ===============================\n// @matrix 64x128\n// @knobs Hue=0..1, Pace=0.2..4, Size=-1..1, Lights=40..90\n//\n// Knob 1: Hue. Turns the lights round the colour wheel, starting from sodium amber with a few red and blue ones among them.\n// Knob 2: Pace. How fast the lights drift past and how quickly each one blooms and goes out.\n// Knob 3: Size. How far out of focus they are, from small bright points to wide soft discs.\n// Knob 4: Lights. How many are lit at once; big discs come in fewer.\n// Buttons: K1 tap racks the focus through, so every disc closes to a point and opens out again.\n\nconst W = 64;\nconst H = 128;\nconst N = 160;\n\nfunction hsvInto(out, h, s, v) {\n  h = h - Math.floor(h);\n  const i = Math.floor(h * 6);\n  const f = h * 6 - i;\n  const p = v * (1 - s);\n  const q = v * (1 - f * s);\n  const t = v * (1 - (1 - f) * s);\n  const k = i % 6;\n  out[0] = (k === 0 ? v : k === 1 ? q : k === 2 ? p : k === 3 ? p : k === 4 ? t : v) * 255;\n  out[1] = (k === 0 ? t : k === 1 ? v : k === 2 ? v : k === 3 ? q : k === 4 ? p : p) * 255;\n  out[2] = (k === 0 ? p : k === 1 ? p : k === 2 ? t : k === 3 ? v : k === 4 ? v : q) * 255;\n}\n\nfunction smooth(a, b, x) {\n  const t = Math.max(0, Math.min(1, (x - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n}\n\nfunction spawn(params, i) {\n  params.x[i] = Math.random() * (W + 12) - 6;\n  params.y[i] = Math.random() * (H + 20) - 10;\n  // Bigger discs are nearer lamps, so they also drift faster.\n  params.size[i] = 0.65 + Math.random() * 0.75;\n  const pick = Math.random();\n  if (pick \u003c 0.62) {\n    params.off[i] = (Math.random() - 0.5) * 0.07;\n    params.sat[i] = 0.82 + Math.random() * 0.18;\n  } else if (pick \u003c 0.8) {\n    // Pale lamps, nearly white.\n    params.off[i] = (Math.random() - 0.5) * 0.05;\n    params.sat[i] = 0.25 + Math.random() * 0.25;\n  } else if (pick \u003c 0.92) {\n    // Tail lights, a step towards red.\n    params.off[i] = -0.07 - Math.random() * 0.03;\n    params.sat[i] = 0.95;\n  } else {\n    // The odd cool one across the wheel.\n    params.off[i] = 0.47 + Math.random() * 0.08;\n    params.sat[i] = 0.75;\n  }\n  params.bright[i] = 0.65 + Math.random() * 0.35;\n  params.life[i] = 1.8 + Math.random() * 1.6;\n  params.age[i] = 0;\n  params.jx[i] = (Math.random() - 0.5) * 2;\n  params.jy[i] = (Math.random() - 0.5) * 2;\n  params.on[i] = 1;\n}\n\nexport function setup(params) {\n  params.x = new Float32Array(N);\n  params.y = new Float32Array(N);\n  params.size = new Float32Array(N);\n  params.off = new Float32Array(N);\n  params.sat = new Float32Array(N);\n  params.bright = new Float32Array(N);\n  params.life = new Float32Array(N);\n  params.age = new Float32Array(N);\n  params.jx = new Float32Array(N);\n  params.jy = new Float32Array(N);\n  params.on = new Uint8Array(N);\n  params.buf = new Float32Array(W * H * 3);\n  params.col = new Float32Array(3);\n  params.t = 0;\n  params.rack = 0;\n  params.started = false;\n}\n\nexport function update(dt, input, params) {\n  const k = input.knobValues || [0, 2, 0, 40];\n  params.hue = k[0];\n  const pace = Math.max(0.05, k[1]);\n  params.radius = 9 * Math.pow(1.6, k[2]);\n  const want = Math.min(N, Math.round(k[3] * Math.pow(9 / params.radius, 1.8)));\n  // A crowd dims each lamp a little, so the overlaps stay colours rather than a white wash.\n  params.crowd = Math.min(1, Math.pow(45 / k[3], 0.6));\n  dt = Math.min(dt, 0.1);\n  const step = dt * pace;\n  params.t += step;\n\n  if (!params.started) {\n    // The first frame finds each lamp somewhere in its life, so they never bloom together.\n    for (let i = 0; i \u003c want; i++) {\n      spawn(params, i);\n      params.age[i] = Math.random() * params.life[i];\n    }\n    params.started = true;\n  }\n  if (input.btnPressed && input.btnPressed[0]) params.rack = 1;\n  params.rack = Math.max(0, params.rack - dt * 0.9);\n\n  // The whole view pans slowly, the way a car window passes a street.\n  const t = params.t;\n  const ang = 0.6 * Math.sin(t * 0.11) + 0.3 * Math.sin(t * 0.23 + 2);\n  const sp = 9;\n  const dx = Math.cos(ang) * sp;\n  const dy = Math.sin(ang) * sp * 0.6;\n  for (let i = 0; i \u003c N; i++) {\n    if (!params.on[i]) {\n      if (i \u003c want) {\n        spawn(params, i);\n        // A lamp that K4 adds waits a moment, so a quick turn does not light a crowd at once.\n        params.age[i] = -Math.random() * 1.5;\n      }\n      continue;\n    }\n    params.age[i] += step;\n    if (params.age[i] >= params.life[i]) {\n      if (i \u003c want) spawn(params, i);\n      else params.on[i] = 0;\n      continue;\n    }\n    const s = params.size[i];\n    params.x[i] += (dx * s + params.jx[i]) * step;\n    params.y[i] += (dy * s + params.jy[i]) * step;\n  }\n}\n\nexport function draw(display, params, time) {\n  const buf = params.buf;\n  buf.fill(0);\n  const col = params.col;\n  // Racking focus: the discs close to points and open again, brighter as they shrink.\n  const r0 = params.rack > 0 ? Math.sin(params.rack * Math.PI) : 0;\n  const focus = 1 - 0.8 * r0;\n  const gain = Math.min(4, 1 / (focus * focus));\n  // A six-bladed iris, turned a little off square.\n  const ic = Math.cos(0.3);\n  const is = Math.sin(0.3);\n  for (let i = 0; i \u003c N; i++) {\n    if (!params.on[i]) continue;\n    const u = params.age[i] / params.life[i];\n    const env = smooth(0, 0.2, u) * (1 - smooth(0.45, 1, u));\n    if (env \u003c= 0.01) continue;\n    const r = params.radius * params.size[i] * (0.6 + 0.4 * smooth(0, 0.35, u) + 0.1 * smooth(0.5, 1, u)) * focus;\n    hsvInto(col, params.hue + 0.075 + params.off[i], params.sat[i], 1);\n    const level = params.bright[i] * env * gain * params.crowd;\n    const cr = col[0] * level;\n    const cg = col[1] * level;\n    const cb = col[2] * level;\n    const cx = params.x[i];\n    const cy = params.y[i];\n    // Soft edge never narrower than four and a half LEDs.\n    const e = Math.max(0.3, 4.5 / r);\n    const e0 = 1 - e * 0.5;\n    const e1 = 1 + e * 0.5;\n    // Near the panel's edge the lens barrel clips the disc into a cat's eye,\n    // measured against the long side so the corners clip as much as before.\n    const vx = ((cx - W / 2) / (H / 2)) * 0.45 * r;\n    const vy = ((cy - H / 2) / (H / 2)) * 0.45 * r;\n    const reach = r * e1 * 1.12 + 1;\n    const x0 = Math.max(0, Math.floor(cx - reach));\n    const x1 = Math.min(W - 1, Math.ceil(cx + reach));\n    const y0 = Math.max(0, Math.floor(cy - reach));\n    const y1 = Math.min(H - 1, Math.ceil(cy + reach));\n    const inv = 1 / r;\n    const vinv = 1 / (r * 1.12);\n    for (let y = y0; y \u003c= y1; y++) {\n      const py = y - cy;\n      for (let x = x0; x \u003c= x1; x++) {\n        const px = x - cx;\n        const round = Math.sqrt(px * px + py * py) * inv;\n        if (round > e1 * 1.2) continue;\n        const ax = Math.abs(px * ic - py * is);\n        const ay = Math.abs(px * is + py * ic);\n        const hex = Math.max(ay, ax * 0.866 + ay * 0.5) * inv * 1.05;\n        let d = round * 0.6 + hex * 0.4;\n        const qx = px + vx;\n        const qy = py + vy;\n        const clip = Math.sqrt(qx * qx + qy * qy) * vinv;\n        if (clip > d) d = clip;\n        if (d >= e1) continue;\n        // Brighter towards the rim, the way a lens draws an out-of-focus light.\n        const v = (1 - smooth(e0, e1, d)) * (0.64 + 0.36 * smooth(0.15, e0, d));\n        const o = (y * W + x) * 3;\n        buf[o] += cr * v;\n        buf[o + 1] += cg * v;\n        buf[o + 2] += cb * v;\n      }\n    }\n  }\n  for (let y = 0; y \u003c H; y++) {\n    for (let x = 0; x \u003c W; x++) {\n      const o = (y * W + x) * 3;\n      display.setPixel(x, y, knee(buf[o]), knee(buf[o + 1]), knee(buf[o + 2]));\n    }\n  }\n}\n\n// Overlaps add up, and past 160 the light rolls off instead of clipping flat.\nfunction knee(c) {\n  if (c \u003c 160) return c;\n  return 160 + 95 * (1 - Math.exp(-(c - 160) / 95));\n}\n"}</script>
 <script>
 "use strict";(()=>{var PANEL_GEOMETRIES={"128x64_SINGLE":{id:1,physW:128,physH:64,chain:1,resW:128,resH:64},"64x64_SINGLE":{id:2,physW:64,physH:64,chain:1,resW:64,resH:64},"64x64_CHAIN2":{id:3,physW:64,physH:64,chain:2,resW:128,resH:64}},PANEL_GEOM_DEFAULT="128x64_SINGLE",KNOB_COUNT=4,DETENTS_PER_TURN=24,TURNS_PER_FULL_RANGE=2;function knobUnitsPerTurn(range){return(range[1]-range[0])/TURNS_PER_FULL_RANGE}var KNOB_SPAN_FLOOR=1e-4;function normalizeKnob(value,range){return(value-range[0])/Math.max(KNOB_SPAN_FLOOR,range[1]-range[0])}var LOGICAL_KNOB_WRAP=[!0,!1,!1,!0];function wrapKnobDelta(delta,span=1){return delta>span/2?delta-span:delta<-span/2?delta+span:delta}var PATTERN_MATRIX_WIDTH=PANEL_GEOMETRIES[PANEL_GEOM_DEFAULT].resW,PATTERN_MATRIX_HEIGHT=PANEL_GEOMETRIES[PANEL_GEOM_DEFAULT].resH,PATTERN_KNOB_COUNT=KNOB_COUNT,PATTERN_DETENTS_PER_TURN=DETENTS_PER_TURN;function clampByte(value){return Number.isFinite(value)?Math.max(0,Math.min(255,Math.round(value))):0}function rgbToHsv(r,g,b){let rf=r/255,gf=g/255,bf=b/255,max=Math.max(rf,gf,bf),min=Math.min(rf,gf,bf),delta=max-min,h=0;delta>0&&(max===rf?h=(gf-bf)/delta%6:max===gf?h=(bf-rf)/delta+2:h=(rf-gf)/delta+4,h/=6,h<0&&(h+=1));let s=max===0?0:delta/max;return[h,s,max]}function hsvToRgbTuple(h,s,v){h=h-Math.floor(h);let i=Math.floor(h*6),f=h*6-i,p=v*(1-s),q=v*(1-f*s),t=v*(1-(1-f)*s),r,g,b;switch(i%6){case 0:r=v,g=t,b=p;break;case 1:r=q,g=v,b=p;break;case 2:r=p,g=v,b=t;break;case 3:r=p,g=q,b=v;break;case 4:r=t,g=p,b=v;break;default:r=v,g=p,b=q;break}return[Math.round(r*255),Math.round(g*255),Math.round(b*255)]}function srgbChannelToLinear(c){return c/=255,c<=.04045?c/12.92:Math.pow((c+.055)/1.055,2.4)}function linearChannelToSrgb(c){let v=c<=.0031308?c*12.92:1.055*Math.pow(c,.4166666666666667)-.055;return Math.max(0,Math.min(1,v))*255}function srgbToOklab(r,g,b){let lr=srgbChannelToLinear(r),lg=srgbChannelToLinear(g),lb=srgbChannelToLinear(b),l=Math.cbrt(.4122214708*lr+.5363325363*lg+.0514459929*lb),m=Math.cbrt(.2119034982*lr+.6806995451*lg+.1073969566*lb),s=Math.cbrt(.0883024619*lr+.2817188376*lg+.6299787005*lb);return[.2104542553*l+.793617785*m-.0040720468*s,1.9779984951*l-2.428592205*m+.4505937099*s,.0259040371*l+.7827717662*m-.808675766*s]}function oklabToLinearRgb(L,A,B){let l_=L+.3963377774*A+.2158037573*B,m_=L-.1055613458*A-.0638541728*B,s_=L-.0894841775*A-1.291485548*B,l=l_*l_*l_,m=m_*m_*m_,s=s_*s_*s_;return[4.0767416621*l-3.3077115913*m+.2309699292*s,-1.2684380046*l+2.6097574011*m-.3413193965*s,-.0041960863*l-.7034186147*m+1.707614701*s]}var GAMUT_EPS=1e-4;function inLinearGamut(rgb){return rgb[0]>=-GAMUT_EPS&&rgb[0]<=1+GAMUT_EPS&&rgb[1]>=-GAMUT_EPS&&rgb[1]<=1+GAMUT_EPS&&rgb[2]>=-GAMUT_EPS&&rgb[2]<=1+GAMUT_EPS}function oklabToSrgb(L,A,B){let rgb=oklabToLinearRgb(L,A,B);if(!inLinearGamut(rgb)){let lo=0,hi=1;for(let i=0;i<16;i++){let mid=(lo+hi)/2;inLinearGamut(oklabToLinearRgb(L,A*mid,B*mid))?lo=mid:hi=mid}rgb=oklabToLinearRgb(L,A*lo,B*lo)}return[linearChannelToSrgb(rgb[0]),linearChannelToSrgb(rgb[1]),linearChannelToSrgb(rgb[2])]}function mixRampColors(a,b,t,mode){if(mode==="smooth"&&(t=t*t*(3-2*t)),mode==="oklab"||mode==="oklchShort"||mode==="oklchLong"){let[La,Aa,Ba]=srgbToOklab(a[0],a[1],a[2]),[Lb,Ab,Bb]=srgbToOklab(b[0],b[1],b[2]),L=La+(Lb-La)*t;if(mode==="oklab")return oklabToSrgb(L,Aa+(Ab-Aa)*t,Ba+(Bb-Ba)*t);let CHROMA_EPS=1e-4,TWO_PI=Math.PI*2,Ca=Math.sqrt(Aa*Aa+Ba*Ba),Cb=Math.sqrt(Ab*Ab+Bb*Bb),hueA=Math.atan2(Ba,Aa)/TWO_PI;hueA<0&&(hueA+=1);let hueB=Math.atan2(Bb,Ab)/TWO_PI;hueB<0&&(hueB+=1);let h1=Ca<CHROMA_EPS?Cb<CHROMA_EPS?0:hueB:hueA,dh=(Cb<CHROMA_EPS?h1:hueB)-h1;mode==="oklchShort"?(dh>.5&&(dh-=1),dh<-.5&&(dh+=1)):dh>0&&dh<.5?dh-=1:dh<=0&&dh>-.5&&(dh+=1);let C=Ca+(Cb-Ca)*t,H=(h1+dh*t)*TWO_PI;return oklabToSrgb(L,Math.cos(H)*C,Math.sin(H)*C)}if(mode==="hsvShort"||mode==="hsvLong"){let ha=rgbToHsv(a[0],a[1],a[2]),hb=rgbToHsv(b[0],b[1],b[2]),h1=ha[1]===0?hb[0]:ha[0],dh=(hb[1]===0?h1:hb[0])-h1;return mode==="hsvShort"?(dh>.5&&(dh-=1),dh<-.5&&(dh+=1)):dh>0&&dh<.5?dh-=1:dh<=0&&dh>-.5&&(dh+=1),hsvToRgbTuple(h1+dh*t,ha[1]+(hb[1]-ha[1])*t,ha[2]+(hb[2]-ha[2])*t)}return[a[0]+(b[0]-a[0])*t,a[1]+(b[1]-a[1])*t,a[2]+(b[2]-a[2])*t]}function stopAlpha(stop){let a=stop.alpha;return a===void 0||!Number.isFinite(a)?1:Math.max(0,Math.min(1,a))}function mixStopAlpha(a,b,t,mode){mode==="smooth"&&(t=t*t*(3-2*t));let aa=stopAlpha(a);return aa+(stopAlpha(b)-aa)*t}function sampleSortedRampRGBA(stops,mode,wrap,t){if(stops.length===0)return[255,255,255,1];if(stops.length===1)return[...stops[0].color,stopAlpha(stops[0])];t=Math.max(0,Math.min(1,t));let first=stops[0],last2=stops[stops.length-1];if(t<=first.position||t>=last2.position){if(!wrap){let edge=t<=first.position?first:last2;return[...edge.color,stopAlpha(edge)]}let span=1-last2.position+first.position,local=span<=0?0:(t>=last2.position?t-last2.position:t+1-last2.position)/span;return mode==="step"?[...last2.color,stopAlpha(last2)]:[...mixRampColors(last2.color,first.color,local,mode),mixStopAlpha(last2,first,local,mode)]}for(let i=0;i<stops.length-1;i++){let a=stops[i],b=stops[i+1];if(t>b.position)continue;if(mode==="step")return[...a.color,stopAlpha(a)];let span=b.position-a.position,local=span<=0?0:(t-a.position)/span;return[...mixRampColors(a.color,b.color,local,mode),mixStopAlpha(a,b,local,mode)]}return[...last2.color,stopAlpha(last2)]}function buildRampLUTRGBA(ramp){let sorted=[...ramp.stops].sort((a,b)=>a.position-b.position),lut=new Uint8Array(256*4);for(let i=0;i<256;i++){let[r,g,b,a]=sampleSortedRampRGBA(sorted,ramp.mode,ramp.wrap,i/255);lut[i*4]=clampByte(r),lut[i*4+1]=clampByte(g),lut[i*4+2]=clampByte(b),lut[i*4+3]=clampByte(a*255)}return lut}function normalizePatternCode(code){return code.replace(/^\s*import\s+.*?;?\s*$/gm,"").replace(/\bexport\s+function\b/g,"function")}var WRAPPER_LINES_BEFORE_CODE=2,functionPreambleLines=null;function stackLocation(error){let stack=error instanceof Error?error.stack:null;if(!stack)return null;let match=stack.match(/(?:<anonymous>|Function|eval):(\d+):(\d+)/);return match?{line:Number(match[1]),column:Number(match[2])}:null}function getFunctionPreambleLines(){if(functionPreambleLines!==null)return functionPreambleLines;functionPreambleLines=2;try{new Function("throw new Error('probe');")()}catch(error){let location2=stackLocation(error);location2&&(functionPreambleLines=location2.line-1)}return functionPreambleLines}var OPENER_OF={")":"(","]":"[","}":"{"},REGEX_AFTER_WORDS=new Set(["return","typeof","instanceof","in","of","new","delete","void","throw","case","do","else","yield","await"]);function regexCanStart(prev,word){return word?REGEX_AFTER_WORDS.has(word):prev===""||"(,=:[!&|?{};+-*%<>~^".includes(prev)}function openAtEnd(code){let stack=[],innermostFirst=inside=>inside?[inside,...stack.slice().reverse()]:stack.slice().reverse(),prev="",word="",i=0;for(;i<code.length;){let c=code[i];if(stack[stack.length-1]==="`"){c==="\\"?i+=2:c==="`"?(stack.pop(),prev=c,word="",i++):c==="$"&&code[i+1]==="{"?(stack.push("${"),prev="{",word="",i+=2):i++;continue}if(/\s/.test(c)){i++;continue}if(/[\w$]/.test(c)){let j=i+1;for(;j<code.length&&/[\w$]/.test(code[j]);)j++;word=code.slice(i,j),prev=code[j-1],i=j;continue}let next=code[i+1];if(c==="/"&&next==="/"){let end=code.indexOf(`
 `,i);if(end<0)break;i=end;continue}if(c==="/"&&next==="*"){let end=code.indexOf("*/",i+2);if(end<0)return innermostFirst("/*");i=end+2;continue}if(c==='"'||c==="'"){let j=i+1;for(;j<code.length&&code[j]!==c;){if(code[j]===`